From b1c0ac365e18708390fb9de6c07dd29770a4d137 Mon Sep 17 00:00:00 2001 From: gururaj1512 Date: Thu, 27 Feb 2025 20:25:12 +0000 Subject: [PATCH 1/4] feat: add `number/uint32/base/mul` Ref: https://github.com/stdlib-js/stdlib/issues/2261 --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: passed - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: missing_dependencies - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../@stdlib/number/uint32/base/mul/README.md | 124 +++++++ .../uint32/base/mul/benchmark/benchmark.js | 72 ++++ .../number/uint32/base/mul/docs/repl.txt | 25 ++ .../uint32/base/mul/docs/types/index.d.ts | 37 ++ .../number/uint32/base/mul/docs/types/test.ts | 56 +++ .../number/uint32/base/mul/examples/index.js | 38 ++ .../number/uint32/base/mul/lib/index.js | 40 +++ .../number/uint32/base/mul/lib/main.js | 132 +++++++ .../number/uint32/base/mul/package.json | 73 ++++ .../uint32/base/mul/test/fixtures/c/Makefile | 131 +++++++ .../uint32/base/mul/test/fixtures/c/data.json | 1 + .../uint32/base/mul/test/fixtures/c/runner.c | 327 ++++++++++++++++++ .../number/uint32/base/mul/test/test.js | 55 +++ 13 files changed, 1111 insertions(+) create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/README.md create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/examples/index.js create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/lib/index.js create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/lib/main.js create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/package.json create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/Makefile create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/data.json create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/runner.c create mode 100644 lib/node_modules/@stdlib/number/uint32/base/mul/test/test.js diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/README.md b/lib/node_modules/@stdlib/number/uint32/base/mul/README.md new file mode 100644 index 000000000000..9962f60e4497 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/README.md @@ -0,0 +1,124 @@ + + +# umul + +> Perform C-like multiplication of two unsigned 32-bit integers. + +
+ +
+ + + +
+ +## Usage + +```javascript +var umul = require( '@stdlib/number/uint32/base/mul' ); +``` + +#### umul( a, b ) + +Performs C-like multiplication of two unsigned 32-bit integers. + +```javascript +var v = umul( 10>>>0, 4>>>0 ); +// returns 40 + +v = umul( 2147483648>>>0, 5>>>0 ); // 2^31 * 5 = 10737418240 => 32-bit integer overflow +// returns 2147483648 +``` + +
+ + + + + +
+ +## Notes + +- The function emulates C-like multiplication of two unsigned 32-bit integers. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory; +var UINT32_MAX = require( '@stdlib/constants/uint32/max' ); +var umul = require( '@stdlib/number/uint32/base/mul' ); + +var randi; +var a; +var b; +var y; +var i; + +randi = discreteUniform( 0, UINT32_MAX ); + +for ( i = 0; i < 100; i++ ) { + a = randi()>>>0; + b = randi()>>>0; + y = umul( a, b ); + console.log( '%d x %d = %d', a, b, y ); +} +``` + +
+ + + + + +
+ +* * * + +## See Also + +- [`@stdlib/math/base/ops/imul`][@stdlib/math/base/ops/imul]: perform C-like multiplication of two signed 32-bit integers. + +
+ + + + + +
+ + + +[@stdlib/math/base/ops/imul]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/ops/imul + + + +
+ + diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/benchmark/benchmark.js b/lib/node_modules/@stdlib/number/uint32/base/mul/benchmark/benchmark.js new file mode 100644 index 000000000000..ad8c3194065e --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/benchmark/benchmark.js @@ -0,0 +1,72 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2018 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var minstd = require( '@stdlib/random/base/minstd' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pkg = require( './../package.json' ).name; +var umul = require( './../lib' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var x; + var y; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = minstd(); + y = umul( x>>>0, x>>>0 ); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::naive_multiplication', function benchmark( b ) { + var x; + var y; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = minstd(); + y = ( x>>>0 ) * ( x>>>0 ); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/docs/repl.txt b/lib/node_modules/@stdlib/number/uint32/base/mul/docs/repl.txt new file mode 100644 index 000000000000..f83d70e84b8f --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/docs/repl.txt @@ -0,0 +1,25 @@ + +{{alias}}( a, b ) + Performs C-like multiplication of two unsigned 32-bit integers. + + Parameters + ---------- + a: integer + Unsigned 32-bit integer. + + b: integer + Unsigned 32-bit integer. + + Returns + ------- + out: integer + Product. + + Examples + -------- + > var v = {{alias}}( 10>>>0, 4>>>0 ) + 40 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/index.d.ts b/lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/index.d.ts new file mode 100644 index 000000000000..141bd9ede6d9 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/index.d.ts @@ -0,0 +1,37 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2019 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/** +* Performs C-like multiplication of two unsigned 32-bit integers. +* +* @param a - unsigned 32-bit integer +* @param b - Unsigned 32-bit integer +* @returns product +* +* @example +* var v = umul( 10>>>0, 4>>>0 ); +* // returns 40 +*/ +declare function umul( a: number, b: number ): number; + + +// EXPORTS // + +export = umul; diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/test.ts b/lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/test.ts new file mode 100644 index 000000000000..08a0d81fbdf9 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/docs/types/test.ts @@ -0,0 +1,56 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2019 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import umul = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + umul( 10, 4 ); // $ExpectType number +} + +// The compiler throws an error if the function is provided values other than two numbers... +{ + umul( true, 4 ); // $ExpectError + umul( false, 4 ); // $ExpectError + umul( '5', 4 ); // $ExpectError + umul( [], 4 ); // $ExpectError + umul( {}, 4 ); // $ExpectError + umul( ( x: number ): number => x, 4 ); // $ExpectError + + umul( 10, true ); // $ExpectError + umul( 10, false ); // $ExpectError + umul( 10, '5' ); // $ExpectError + umul( 10, [] ); // $ExpectError + umul( 10, {} ); // $ExpectError + umul( 10, ( x: number ): number => x ); // $ExpectError + + umul( [], true ); // $ExpectError + umul( {}, false ); // $ExpectError + umul( false, '5' ); // $ExpectError + umul( {}, [] ); // $ExpectError + umul( '5', ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided insufficient arguments... +{ + umul(); // $ExpectError + umul( 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/examples/index.js b/lib/node_modules/@stdlib/number/uint32/base/mul/examples/index.js new file mode 100644 index 000000000000..9e2730b93b31 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/examples/index.js @@ -0,0 +1,38 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2018 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory; +var UINT32_MAX = require( '@stdlib/constants/uint32/max' ); +var umul = require( './../lib' ); + +var randi; +var a; +var b; +var y; +var i; + +randi = discreteUniform( 0, UINT32_MAX ); + +for ( i = 0; i < 100; i++ ) { + a = randi()>>>0; + b = randi()>>>0; + y = umul( a, b ); + console.log( '%d x %d = %d', a, b, y ); +} diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/lib/index.js b/lib/node_modules/@stdlib/number/uint32/base/mul/lib/index.js new file mode 100644 index 000000000000..dc2bc2fcf442 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/lib/index.js @@ -0,0 +1,40 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2018 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* Perform C-like multiplication of two unsigned 32-bit integers. +* +* @module @stdlib/number/uint32/base/mul +* +* @example +* var umul = require( '@stdlib/number/uint32/base/mul' ); +* +* var v = umul( 10>>>0, 4>>>0 ); +* // returns 40 +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/lib/main.js b/lib/node_modules/@stdlib/number/uint32/base/mul/lib/main.js new file mode 100644 index 000000000000..ec2bb94aa1bf --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/lib/main.js @@ -0,0 +1,132 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2018 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// VARIABLES // + +// Define a mask for the least significant 16 bits (low word): 65535 => 0x0000ffff => 00000000000000001111111111111111 +var LOW_WORD_MASK = 0x0000ffff>>>0; // asm type annotation + + +// MAIN // + +/** +* Performs C-like multiplication of two unsigned 32-bit integers. +* +* ## Method +* +* - To emulate C-like multiplication without the aid of 64-bit integers, we recognize that a 32-bit integer can be split into two 16-bit words +* +* ```tex +* a = w_h*2^{16} + w_l +* ``` +* +* where \\( w_h \\) is the most significant 16 bits and \\( w_l \\) is the least significant 16 bits. For example, consider the maximum unsigned 32-bit integer \\( 2^{32}-1 \\) +* +* ```binarystring +* 11111111111111111111111111111111 +* ``` +* +* The 16-bit high word is then +* +* ```binarystring +* 1111111111111111 +* ``` +* +* and the 16-bit low word +* +* ```binarystring +* 1111111111111111 +* ``` +* +* If we cast the high word to 32-bit precision and multiply by \\( 2^{16} \\) (equivalent to a 16-bit left shift), then the bit sequence is +* +* ```binarystring +* 11111111111111110000000000000000 +* ``` +* +* Similarly, upon casting the low word to 32-bit precision, the bit sequence is +* +* ```binarystring +* 00000000000000001111111111111111 +* ``` +* +* From the rules of binary addition, we recognize that adding the two 32-bit values for the high and low words will return our original value \\( 2^{32}-1 \\). +* +* - Accordingly, the multiplication of two 32-bit integers can be expressed +* +* ```tex +* \begin{align*} +* a \cdot b &= ( a_h \cdot 2^{16} + a_l) \cdot ( b_h \cdot 2^{16} + b_l) \\ +* &= a_l \cdot b_l + a_h \cdot b_l \cdot 2^{16} + a_l \cdot b_h \cdot 2^{16} + (a_h \cdot b_h) \cdot 2^{32} \\ +* &= a_l \cdot b_l + (a_h \cdot b_l + a_l \cdot b_h) \cdot 2^{16} + (a_h \cdot b_h) \cdot 2^{32} +* \end{align*} +* ``` +* +* - We note that multiplying (dividing) an integer by \\( 2^n \\) is equivalent to performing a left (right) shift of \\( n \\) bits. +* +* - Further, as we want to return an integer of the same precision, for a 32-bit integer, the return value will be modulo \\( 2^{32} \\). Stated another way, we only care about the low word of a 64-bit result. +* +* - Accordingly, the last term, being evenly divisible by \\( 2^{32} \\), drops from the equation leaving the remaining two terms as the remainder. +* +* ```tex +* a \cdot b = a_l \cdot b_l + (a_h \cdot b_l + a_l \cdot b_h) << 16 +* ``` +* +* - Lastly, the second term in the above equation contributes to the middle bits and may cause the product to "overflow". However, we can disregard (`>>>0`) overflow bits due to modulo arithmetic, as discussed earlier with regard to the term involving the partial product of high words. +* +* @param {uinteger32} a - integer +* @param {uinteger32} b - integer +* @returns {uinteger32} product +* +* @example +* var v = umul( 10>>>0, 4>>>0 ); +* // returns 40 +*/ +function umul( a, b ) { + var lbits; + var mbits; + var ha; + var hb; + var la; + var lb; + + a >>>= 0; // asm type annotation + b >>>= 0; // asm type annotation + + // Isolate the most significant 16-bits: + ha = ( a>>>16 )>>>0; // asm type annotation + hb = ( b>>>16 )>>>0; // asm type annotation + + // Isolate the least significant 16-bits: + la = ( a&LOW_WORD_MASK )>>>0; // asm type annotation + lb = ( b&LOW_WORD_MASK )>>>0; // asm type annotation + + // Compute partial sums: + lbits = ( la*lb )>>>0; // asm type annotation; no integer overflow possible + mbits = ( ((ha*lb) + (la*hb))<<16 )>>>0; // asm type annotation; possible integer overflow + + // The final `>>>0` converts the intermediate sum to an unsigned integer (possible integer overflow during sum): + return ( lbits + mbits )>>>0; // asm type annotation +} + + +// EXPORTS // + +module.exports = umul; diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/package.json b/lib/node_modules/@stdlib/number/uint32/base/mul/package.json new file mode 100644 index 000000000000..a0f1cbcf437b --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/package.json @@ -0,0 +1,73 @@ +{ + "name": "@stdlib/number/uint32/base/mul", + "version": "0.0.0", + "description": "Perform C-like multiplication of two unsigned 32-bit integers.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "math.imul", + "imul", + "umul", + "multiplication", + "multiply", + "mult", + "integer", + "unsigned", + "uint", + "uint32", + "32-bit", + "32bit", + "long", + "c", + "emulate", + "emulation" + ] +} diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/Makefile b/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/Makefile new file mode 100644 index 000000000000..5c9bf0c69840 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/Makefile @@ -0,0 +1,131 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2018 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +endif + +# Determine the OS: +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate [position independent code][1]: +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of C targets: +c_targets := runner.out + + +# RULES # + +#/ +# Compiles C source files. +# +# @param {string} [C_COMPILER] - C compiler +# @param {string} [CFLAGS] - C compiler flags +# @param {(string|void)} [fPIC] - flag indicating whether to generate position independent code +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler +# @param {string} CFLAGS - C compiler flags +# @param {(string|void)} fPIC - flag indicating whether to generate position independent code +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) -o $@ $< -lm + +#/ +# Generates test fixtures. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean + +#/ +# Removes generated test fixtures. +# +# @example +# make clean-fixtures +#/ +clean-fixtures: + $(QUIET) -rm -f *.json + +.PHONY: clean-fixtures diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/data.json b/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/data.json new file mode 100644 index 000000000000..5124ce359874 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/data.json @@ -0,0 +1 @@ +{"a":[33613,564950497,3245300145,1969887315,2288217859,940422543,202055087,2915701755,2917555845,4014475417,1647128879,2230876329,3568968983,148486083,229615973,2275045005,2882564653,33063457,1646757679,287085223,1793088605,2949666337,2529635417,3996194313,3634259119,2263141865,394986197,2808560555,1786703631,3011590669,3909798193,3273615651,1127227023,203858533,3161447619,1409755265,2717161957,3248758297,4256473157,1569117641,1061023933,4220021343,3103802785,3235638671,2798250969,312183489,2712850455,3799788181,1171280387,1874372713,3292070001,2051842305,1021233415,1180715887,1543031335,715142979,2089576247,3855404391,3905019059,260121805,3885455443,2166909331,2217457097,1370236047,4237595601,2121613705,1143081953,389694815,4070616455,316749865,2150520595,1649877961,1190057269,3924816025,2275247729,1994779627,4041478125,215109071,3270678849,3308003337,3555448229,538440187,68151257,2956893001,3729093033,2703868389,3162060209,3115620807,4292638901,3816388595,1001564375,1315642245,1507599009,2204493763,2538813503,3633463131,1769873431,3614260673,1156708875,1784106287,2307703001,2009689793,1233567741,765911655,660222273,2455238715,3446306353,141964793,2295444587,2140955807,4103243217,3213892461,2381919489,3825688349,2683707269,3616532595,686196283,913760797,3069655935,560180823,390800519,1179347113,12883187,1779376015,115432789,3048651935,4028238225,1030409059,776942011,1363821923,3809595883,2800570729,645684163,2926359703,1657061533,1665267641,2146371389,633649423,2521947341,3631719801,2534497179,4103449661,2388629475,636306113,4223263231,1755639579,609111279,2426221357,1082874669,2098154011,1992995943,4127872195,541298189,857950637,1371166907,2702690445,544224577,2797113519,2669897809,3449172251,1064472245,2046259011,1672091625,872953539,121870475,3872658187,1831792439,609975687,4069424731,1762281067,563450451,3803830787,395882725,696637475,305215687,1569119179,1086873099,580290317,3363617245,1955529893,1501194769,1942614433,3474390543,4001511077,2798798493,924484769,2918826991,3903789769,1074281245,3697364839,2024056287,2173063935,2578671469,3511399829,3246323249,1985327067,4086092083,2717592021,1886909357,3542048303,2959150487,3015954589,4239757635,4099180791,3656175383,1242603629,2308225981,2209480065,444245337,1778238793,2476979105,3764821093,1889951649,3134242419,3733459323,3073660421,3439067615,3034546753,3185645521,82001249,3805474669,2254803735,1989955989,280005551,3064125533,2099994877,2867659747,2929378661,857081111,3936912601,3718937743,3822601119,2336240187,597837967,1934227509,4249279577,925702813,1915656029,1356060385,2210445537,3786031359,1888606909,2008033709,3464535011,1568341925,908467003,4291173351,659726215,2707926497,2647204661,2555687,3775275,3321521615,3123879993,1370857301,1794109697,2931290405,2922991461,881593061,3592396027,3044790837,3559273549,406084017,351060359,3281375857,2703990445,918488107,917176519,348153473,1669983089,4089494633,4069675049,1674408399,1156268511,2972843127,1219921193,3336613295,3366675407,1814451099,1211850299,833083951,48602823,823877107,4222965593,1048205007,3520696761,586069495,1710014129,2581318755,759695397,3557756417,677450257,4243157105,1104530965,1003300893,436529213,942361545,2726090643,2989328609,3413510351,2990340105,3233854447,2875569259,2720560731,242410799,2569320887,974990739,1369140569,3005766031,504387795,3275216309,2259682265,2379031113,2525393151,1415906355,3019316531,614374713,694443421,2084455755,3694641227,3492949637,2391591473,3173966265,1357241181,581247439,2270097523,1334613265,2525952393,2225152061,1850477175,1111721177,1590109745,1687997753,1919274607,2043958715,1665722399,1199554507,336137919,1588029829,1090587893,2885290959,2904415459,2207339909,3129349091,3095674213,4057682475,1978679999,4037969851,1381090069,1977549713,2221122225,2840500227,1725859185,2601202719,4236996707,645936835,2878050713,1476685169,2326627457,2245442029,3561553125,64212203,1177721833,2761573285,2345638837,3942125933,1145095493,4166490537,1059710789,3624846605,2980808945,1957438205,3509423495,94848769,690411315,3036326917,3040090811,1875347859,2501479647,3228570263,4258601945,2987919205,1200493793,3237815839,735207899,18270461,2128976959,343240405,700427799,3879649039,3362925065,3206962515,1874434005,27237351,2511641899,2226847867,287117559,2336559757,1673883663,926965147,1656867097,2692349083,2830612497,3046505541,2313532619,1203831757,3504401965,1597339939,2946784079,1332165445,40147299,445805941,2237506457,3332380635,947835491,237420597,303374459,688371241,3108541551,1275700247,217336487,2052153915,1963495391,2233333541,1917658127,645583119,1228113195,3580637501,2987739879,2481529005,2925579101,1422385601,246854409,4238630159,2329560835,7118547,3677319297,126080825,1621566639,2103038049,2474644023,3173803565,2917709575,2303248233,152848015,526163099,4180530647,808638389,1508902513,2637649021,2609671379,540877331,2374524819,4097521185,1532981105,3599619129,4184381919,1112457483,1080302805,1822508703,3492014613,3856512281,1050489819,3266826399,2984385597,1940686253,1132240341,2858315573,500668827,900063249,488233281,2349239033,26110695,755803683,2574228629,1855031947,354362889,2952422745,1611944439,3591479821,531018477,4180490107,127282609,345113857,2122764505,3304708377,4011630331,1074408711,1544718607,3303319719,2147291795,3218011183,2885803439,2927732231,3250303159,156197733,990298703,952053877,2416357395,2802989801,2648321621,1595433231,965513781,1003697341,2804663455,712653341,3195903321,686154089,204606239,2843240479,536634315,4076598905,2079539253,2667370699,3925707421,77071125,2549259187,3100415065,2132803453,230615653,1896797589,2229839061,3315474883,280703031,1901770011,4196957029,2008933847,1413285201,1915254193,3192337321,881934205,736068647,1599960215,4036089871,4144004561,1095034029,302087419,531926431,2260603809,687551945,2223535561,451765439,3614541581,1582962337,1820595729,1405431653,3064659071,2477233455,3744714249,3256640767,3593160333,3005579897,1671000951,4016832091,2601043151,1555137331,2317154933,1954521039,1725254767,1032683981,356850419,1810666515,2028856421,1244537487,450839035,929371435,3444643867,2265333649,2872561533,3709317377,1046899635,3056146027,1132423649,1644205835,347916055,1974666057,1000156067,3416013453,2110302479,13867507,1142973079,2854816791,1826181869,802406165,4138096095,575693729,3418174021,4063230503,735106127,2602755751,274034473,1492465349,1256140489,2188965419,3546940829,3583456383,3120049419,1414909493,3444926073,2713402597,194736893,177899429,658483385,3294519157,265134257,2230390327,3990667957,947107001,878591049,382220577,3005149915,3034228065,2124423599,1124330177,3056175339,1625070433,861761691,999042075,1873019085,2016480675,3698771871,4197206641,1909195437,147072991,2249582493,135887575,3234856717,2540851973,3534290069,1415530469,996767823,2304371367,1849491977,1733367567,4240527467,4152845333,3653001037,3725945229,1338334089,637331951,4284653321,2746731649,2010365637,4002543261,2966845805,3502145395,2325873595,2460185277,683828007,4059819005,3527601357,667497529,176414781,1475808213,472529847,414628729,2228114241,96228907,2411554211,3680254899,2220103405,2897061663,3166142063,2999864281,97923307,824563953,2881884433,1485507799,284714577,604346929,3956169493,952007243,1632579757,2516918633,718603031,113128095,2968365523,3274242057,3065298077,332105415,2533211805,3975005313,3993021521,1848751503,2173122931,3570217241,3948089113,2584013991,3108853909,2230533859,2108042987,693291109,4192384441,2466858623,1173604585,2282462853,3000284463,2864954887,418469581,2356804395,2623098303,2868889711,2126547139,2454928605,2529254877,1895425827,649471597,2157253531,3141183669,135963841,221692085,2242245503,1377148171,150579437,1052878299,460336819,1644837245,2370089337,2564819209,2624699885,4016874621,3315844861,2203955983,2090279631,2792277397,2993573941,1750361277,2091002739,2060651671,3051359781,2294365713,1188189665,2600766655,1203036353,3020948819,2278435365,4029770351,1011046977,1775944181,2566140867,3362969421,3952453807,2926982051,3526929781,2265221579,989001043,617118727,3863413779,1079849767,2798233625,20682881,4019814253,1182632357,3688371567,1197989073,4090659739,2176775121,528065161,1788748329,3017091603,1874715463,462734663,3290695707,428919517,1895219693,1479944753,1275880923,3253958019,1453887637,1420596299,238826753,2461801881,2084287671,869653439,491664597,4184792223,3713469517,2112439911,1577948779,3457072303,696660095,685390027,247918087,641029835,2010480299,1634700201,3795482589,1821639641,1770591461,2797289001,1324256489,258309921,3497892113,3855407019,3949187855,3870701609,3307324345,733564273,2458619337,134878191,3450009005,2242894841,3700637349,1190557035,3734448599,2520552977,1671480523,3487064107,2257736525,4036717285,1804049777,2490490499,3217553469,3782938829,1452062727,814104987,3191701925,3087735515,3775971303,312970183,3049914631,3775533427,1543522839,385916119,691614899,1790126735,414157481,2897783693,2416398391,3492009573,3771805001,3304376467,2728186255,3850541141,3772754895,2089375749,485634505,1621283741,1643338657,2953124585,522867437,329946941,615477639,2051451527,3043362157,1022285259,1679188819,4191376159,2700532225,2925726683,3902796275,1556496763,3690292087,3411397655,1841996785,315727149,2141601959,2078217999,1935891191,2146011893,3181534739,4006532173,1289013085,627905465,472525703,344980521,4176753647,1753108799,1023964759,4136741555,3579743713,850746845,556118995,843134027,1456505689,2472523323,1890937017,2515453219,1859193697,1581418435,1642038579,2577550109,1844571485,639037109,2878472769,4275213067,2998172549,1729754641,3647622301,3519842451,3407550501,1607388917,41265565,2060633427,2744732873,2776675757,2769815395,3431828199,1620766273,1536188569,1672891755,1435836567,2978940683,622329829,1252091919,2864126133,3669470279,1351621413,619087131,2586641455,24001123,3954932725,1640483937,2218485779,1479425245,1134444555,1249834625,3580491521,534254019,2725669679,209153955,1967291999,1618414787,669469013,3246375311,2860333101,49523571,3413986861,2409109087,1239761477,1784817551,1377015167,2210148503,3088748215,3616551027,995982907,1997190037,1603566055,214933341,317184739,869513325,2431735893,3571368047,1814849085,3605833707,1258612015,778229961,1535561103,4011972575,2531536325,1585016717,1988822037,2696510757,4056390711,1742838921,216816973,1910616705,2559487797,3213971575,3711588487,562739759,449164931,2857476565,3579330547,2496600471,2828637817,4217797133,81243667,3957695877,836139367,4156339301,2246579097,1197418531,3091494933,2536000219,3595239177,3584972653,2834195545,3137251161,2761778589,1501215871,2297275747,2852490869,1389116461,3733133943,1899966055,3942639595,1188278139,4087749173,503532593,1786738177,3592205291,4134058179,1429916221,2259933223,2301914925,3513744223,3993847561,2847103901,1044658459,4043406641,2562906425,541310255,1060743899,3808457199,842577917,699899507,3590579983,2587310387,2676806659,3602097263,2884707117,1681717553,3742135557,2866237263,496526543,172765,2903678161,2700474305,1952265243,2466797041,138595911,1509219635,3672551181,1592733799,2840800391,2475748239,257525407,3197467197,1200414257,1901054287,757718349,394281739,3853636831,4262409197,2551894159,141749235,2967528575,2092558903,2445296255,3847105599,1866175323,2957489679,872558297,2068972769,1170133165,4067849029,1049261317,4094229755,2048491917,545837121,4129336763,3681456095,933768107,30098879,3360702761,216437539,4123404055,2754680501,2462735087,588811737,554235189,3541744937,2155445419,2817016343,2169211845,2261104249,508512437,3878597699,2872922861,1192222485,1660895691,1681451737,3569533339,1043682787,530189219,3128052783,2783462127,864219047,3645118721,96879037,453387239,807363123,1550343321,3348607449,3088958867,2862011897,2495244179,1508274643,674972519,1254520185,726319855,960770243,2883432761,1738452731,3807532935,2488342045,1468225443,1877933277,3004927033,3583217585,3401538727,3646718355,1212123911,1136713541,729976681,2291502709,314321671,4289536977,3221959455,524934239,706949803,1825820623,3320879231,917266693,1863707891,142065701,3991405343,455451621,1143693045,2070383471,3404965209,1106059213,918761265,1213175731,1634783105,893882823,3987995849,3281628079,2648118305,2473268513,1530443465,3899176589,849976277,490084501,3397922515,2998585387,78388319,3212502275,491899857,3843839749,2811609195,1485588583,1642451265,923629123,1422886551,76386471,3927181291,3373567745,1689858927,3135254967,3571484383,3770108237,556667683,1474998655,4046157717,1555600523,1512088289,346411431,2456254253,3334584343,3625817495,2118687999,3510348739,2760522795,1869922583,1513179089,1499617855,1209224599,3947584285,2689304383,3197947125,676629565,3334688543,1082139601,2628768017,3670492441,1351228971,2613249025,540831537,1604865061,572490713,1124691637,541298971,871093711,3223479631,304728507,1971019507,4137099627,1007925229,848333073,2937525931,349294593,3668917753,655251519,516154823,3475160381,4055276461,195508347,258824925,3563629753,606360647,3440989567,977055665,1714613499,2573519053,2814089997,230754857,4236399217,3488824287,1776310727,136744901,464065623,4185303957,3724248267,2882264813,3583587165,1023135199,3079228517,2532776619,955801505,978231781,6758641,1923346449,1759930505,4007227857,96472191,2205461105,1617061321,3691569715,3409654981,2617645925,1425085839,2680081535,2808363373,2767633051,1112910943,111670437,4239311281,892276407,2758765901,2406576183,1618916889,518362739,1928898947,591483923,2515992351,2330450633,2077051651,3807916825,350446687,1557325141,432971957,1285102069,3614936257,3921314575,3555919695,4167401955,3493011233,3426835445,3606895675,1927239015,2757777857,2980389851,3503659935,2010943611,831650397,1724664509,3997119657,2006646551,1625406975,2223055791,978205637,3862323727,4234182273,588384831,1969160635,2959808981,1198361365,1757836795,3177982239,134239495,1305379921,827411301,3492622035,1180551953,3082759891,1755037321,3371862955,3102224455,2478450125,2718450469,3429943011,1182615,2696357935,1487911357,2026608237,2114014645,2274699353,1368158783,3684757905,592713955,1714303705,1661778589,3635416541,241096949,1962280407,3287933923,1256256063,4131417637,4294967061,4291068069,3185218935,1502304935,3421305219,854700467,2580134539,2331413555,1081012529,865938089,2472286557,2206578149,3211350653,2611425373,4250450725,3429318073,2382751531,629949067,459606165,2249637349,1057852367,2455119109,1436088311,2915034797,297927327,3627704185,3763515771,1426241265,624489847,3195776093,2842800387,1729942659,2512673533,2385651329,2122213819,2639263363,3972113609,2636792627,1101159303,170352481,2665947169,1475275181,103795611,736129519,2623035919,1820401823,2441420805,3136926859,1606202169,1570428399,1616097169,371968933,2504460967,1796007975,475910399,1396991371,2942760199,2422290989,3744656397,2284322203,4185608855,258734365,2041587833,473014271,4261375603,2360148977,3000913155,546479449,2040041577,254893443,1911721189,3942681209,1887684637,3687277381,4282841441,2359235547,533797027,3634939723,817151411,2853342565,2818669251,4179832837,1965447601,684388659,597795287,1216904749,4178846515,2568202923,3660206261,270093471,3975521439,4077616615,2004322047,1212173893,1976761015,1850376821,3720038793,853111999,1652556627,3260723791,3497067997,2889391289,3099185065,2935029923,1348561077,723627507,2955117641,3955388571,711953071,16400019,757229323,765156345,850628985,2870213269,2896749975,2222569141,1389013675,2005609641,1377929781,402196825,3738501119,1911779913,634688183,2800517485,4045779549,3789665535,2838660825,875800829,731633271,69039781,710446693,468508737,1551309663,2410048267,4139657855,1054390285,102481757,129021811,3806078107,3806851613,3922265073,2351070405,741208841,2091854893,3497902067,4022703897,2504238831,2357535517,2026163875,3235557099,1427270365,740704371,2203162191,1633919369,3556941047,4153395843,20520725,1294458361,1952346023,3824466501,3622944403,1075270989,3152123071,3605866907,1816604415,3042893959,1743216061,2260441659,2257264189,393133427,1733826223,3359224271,1137259873,1322244017,794431369,3249685837,2665768761,2771739219,1405799815,662423217,791798877,1955065733,2289992237,697622531,3976149997,1756889039,133949029,718485153,2426919843,4232394283,602407959,1432671761,1327653769,1521820059,699512649,1383624871,1630293987,2754687889,2586905203,161846465,1439256959,335926911,2336585667,2109353033,1236397761,1085417561,1886866915,2828725609,1398349983,7148319,4177697301,433232401,1367417083,4103907887,1500099269,710415109,4232643743,500114885,179894643,4127274025,3372756881,946569561,435771557,1093339035,1879094319,1043723457,1213729909,2358918163,3789458727,3657806063,2879638625,2394918389,3254868655,3874045007,3665239709,3262875421,1004807761,4287623219,1122199807,1610785101,1286355231,3201993521,4259897727,3291290809,1840864243,2755930225,1992009885,440097271,781170235,3708105987,2161904375,3998507485,3857035277,1250549003,2702140685,4189310139,2336672437,3567696423,235406633,814419863,4188855563,3286548193,3736095717,138894145,2226671179,1612489637,4164688019,829561821,981706029,2563869955,3850457083,2359992089,364096539,3337121123,3311806015,3042547965,223062197,3794881417,307676425,4272037099,1159285901,2146509329,2952007003,3214503233,4057229905,2962270597,3916035831,735415167,3501823737,1214734883,2069647005,3912083029,3020148657,1715014513,723426763,3876180527,902218703,2355210307,1601065051,1130232053,3464757509,1012898517,2830005903,1441414771,2242534843,1945118257,2606487571,2865191097,93483757,3518458395,1620557779,2326997205,4164829371,3205264885,3407137653,3258587169,1946600395,1746977173,1048941633,3016268061,918346951,2839734921,1748263125,1187100427,1473812765,1294773663,2956659443,4098651021,3342265581,3875365741,93012283,4184329465,230863105,1760756059,702444759,3418957407,49729829,2585597773,3957674219,472133361,2340823115,313697571,2390222865,1646608079,2067725317,1679043871,1755235123,2401353875,4041899507,3002309051,2532467051,47859423,1214455189,1663797241,3203162353,2429620681,2380738315,1153566107,503212039,694154393,1521729453,3471664901,1141318923,823220663,1780045873,2783801607,2274892113,312908809,2018401813,1627599885,424588515,2118513077,570434685,928767393,1882444561,1516665929,4268362913,3831751209,1502980233,1886136823,3442971247,4218380367,1293722917,2476640597,2370484431,615229479,2175593701,2146775691,3133785843,354753785,932277229,742716097,1654502721,1608987297,1135434461,707315591,3678652245,1054101391,3836974887,3397990499,4141192475,1076944861,1220118717,2361431869,3087642529,2213155601,2089436773,1511264873,3687127895,1770430239,87630847,3932847787,4121085549,2442255805,4285869977,1720232571,2523981689,3463268285,1753314513,186432663,2342626521,558771155,2468314207,4162768403,2926314061,889956439,2421769371,3567757259,1257877285,1314524733,4200411295,4230207687,2506994633,1429659497,2240140249,353882545,3469215725,2927690831,2554493359,876830695,860721957,704101913,1205973627,848105409,3406144377,3744466613,3389589809,389749053,687227227,1060967429,3270358615,2220797793,1682738897,3727994989,1428912057,2562818051,3350975731,4237968795,4098917969,3533893323,3337355035,2948197705,3616141157,2697232405,3300226765,1703621445,2513661117,1804106441,3442842347,2051958067,2966845349,3494481403,2366178871,1266126557,2521085829,2037189499,3859626025,1843577699,1116344983,1993005895,168165,2826365961,394451693,2415086415,2916465411,2867420355,3200884611,2802316533,4217608227,1201267819,3361968939,22254715,372857233,254249891,3980444607,921955311,3355899325,1089467273,1230899795,3170383467,1270697311,2032337015,3908306023,3964518225,3830192559,1076553447,3231558207,2937369225,2010504145,2035479923,896585957,2174928753,3855896537,3586582293,4117611261,4179439505,3944651265,638677477,1129105039,1702902387,3313355193,3309778847,3331673741,1951969915,1798186639,2732977895,2779256035,3186874801,3562641033,1168812783,3351025225,774847159,515382711,3383175879,4259977187,331807735,1825071339,3612564925,2721043297,4057930267,1848352849,4062879741,3429783781,1619971299,1059962433,3559260019,178685307,981833049,403727801,3699810987,186792783,4100196067,3540049939,3732385091,2198912373,3221672241,4287663129,1792967177,908825941,1733909729,467742319,1555024219,416081549,875856217,1662539387,3537246645,3862063067,4148236947,3509268827,1790310987,3510880845,3113693749,1969346153,1782842713,2545651253,2591410443,2866971147,4240980343,3174397677,18048077,2686336365,559108833,3848701059,2911267779,1410165211,1017189791,1939004023,2923771789,1111663875,627035031,3023010641,2571739367,2967678453,316591155,3778048919,871723943,930886973,3146487269,3374223161,4115501051,3072878387,3180324059,838502589,925338515,87866837,3604164423,3267726885,938984623,1804737411,1162653255,2907053185,3589927851,216862451,2674965451,2721685465,1965945961,470390591,3114858783,75236121,1773118017,2311442753,439192247,2750301043,1871628479,119402103,1041435629,1416910359,2713742583,1613914301,2339212103,3302189945,339049353,3275860833,207295251,792824929,2020052521,3601245477,1453641697,1582050013,3667035437,3378904859,1196420751,3501675649,3020787161,3856416653,3738237317,1773026993,781602385,2381316449,2280329657,1507397643,3115102695,4174665105,1010721757,604938935,1021112453,3442674847,3531752861,1722348553,3727552811,2587160999,166042543,3243263201,2094707859,4203061395,1525798153,3134829097,708854587,3774754253,1332847303,2910200117,645839153,1236309339,3894276301,95214447,2541394167,4057010039,3561950029,2440010437,907708353,130477389,2500173789,2755851327,665971199,293190235,1320810233,2466627445,1583163233,902087507,150199135,3251077173,280149149,1182609825,3309676243,1607208313,1300821431,1522281163,4154320283,2672681923,2997136015,1488596879,663274609,2216242339,2428634811,2991090401,2959177437,3468903239,1970705923,3161660633,694914269,1408063503,53521787,1892526469,3459569219,4007621661,2420168725,2435503701,2472407693,4242510901,3128682219,477491097,2193978893,1909052467,2039143495,2340698445,2513336175,637773541,3116521863,2256817917,1482574511,2524550689,141549403,3903919445,3253745777,2181703637,1757254987,1989469771,698074213,2977634783,148904999,2975369891,737570801,1076858729,4067465487,3193005511,3522268947,1239995833,1428671549,2815567389,3586445731,1822413727,1895752981,1852981581,253599879,1645627511,2767188117,2224839793,897156193,3168950617,2958591125,2204692043,1576338169,2157353797,531387037,1784943439,3492814783,125100295,2321668105,497991551,3147725751,2714553665,2360867593,2193790385,3035765805,2199416015,3096448747,4190373531,3029232605,4065073259,1641535161,2706538371,791807449,2099135337,1306272849,2949950315,3007486369,3648304797,2105650841,3438166227,769820519,1931990111,1005069743,100820105,2266407705,3744351549,1455709161,1970179109,2897432323,805890095,2562965489,1533998903,3525880939,1817203261,222796799,3629304525,595659093,3968597837,3676754739,3522456401,95567917,4187197163,1183623157,3160877991,425952057,3560727001,3359415311,53101859,3424731161,2599932839,73992723,2350164301,2692188089,124786339,1339976907,2478370313,1377050185,2798696029,3497339615,3159507721,3165627931,2948782345,557283755,3239386171,1357974059,13826103,447096051,2445548757,3795939419,909646863,2646243901,1034931543,3771886601,380860373,1619037757,2549791215,3452275073,1673994071,2782592403,3426636955,270874245,4213088175,2542165147,4129969017,1422847191,3709830245,1076737523,2030356245,682275691,3739847757,3069888309,170723347,309157443,3393702861,798337313,177409941,1021593157,2931932387,827881053,2797809311,1479172071,1174316431,1361556693,97613625,4209673167,980700513,2844031719,950103113,3989605199,265202471,3376863025,1239055065,2797052949,1651897819,778072323,3181106531,1104607611,2291490215,104335013,1211924345,2077575073,4015135791,4156100109,2521446447,3803128931,1484690815,3733533665,28159121,823961113,1339887141,969673151,2190752227,3513051827,946682577,2335231469,824183717,786225275,2768817387,3838176919,2125705853,1200336685,597301683,1510836909,789304241,2977391421,353687159,185363223,1548417617,1048071379,1274810965,2451043089,1649896875,1507944867,3722361875,1242445527,3945972961,1377585679,3208809099,2845200235,3409482349,4011187195,2216556547,3414561373,3474997683,1320811175,2482459639,1386875563,430099609,254189467,2964898439,837536091,1861275805,2215669239,1386477699,2333133949,4225870723,2630084683,29894139,4214604875,2263538283,2762616229,2694529469,821654353,1224877467,737364533,1905079747,3989115159,619034779,1706761391,3747126011,841451761,3247432085,3441664543,3731442709,3540167275,1409483949,2452121239,2590494749,361803971,3460636393,468778609,1792081073,3195945189,1389829565,2833370989,2163840351,2176717765,3859050163,754999653,1945798301,1151085197,1756230609,1952617901,4098952753,4118508011,2071247579,748159189,2942236791,2215307321,3893656461,2562465449,1719761211,3191768757,4210980939,1485588047,1633442713,4135718243,3560808105,427562945,570150559,448429005,3373670165,3411231867,3350565163,1632519713,1507759125,600596081,1045209273,416035657,104549373,519705571,3023039901,3063512187,381423243,2489259259,3998939259,2523926307,2532463011,4274926437,2475749433,277592965,1170498277,1614351825,1102743383,1024181277,3480792287,4221440135,1179636165,576012857,191823729,2755959609,2485866773,2816001879,2298984573,1507958393,3949693357,3776739135,333020725,736957799,3659035997,2076302893,4108443001,412348975,2566994409,528580639,1862452487,517327143,1703506151,575914859,2839738637,1810717937,2893105975,1107403257,2033272303,2447822263,3352049115,803497213,1000503361,663049123,2721466431,2579608817,2085538489,417315095,133227369,1474447415,3371401625,3938585733,1774496209,3999879227,1142099307,1054232669,1748396939,3436112325,609627957,2520093915,2545960077,3486848117,2922559889,2218097045,3535907495,2829805487,2367990353,1646933473,3241654981,835158083,548800995,2403559553,2458024007,3014068763,2609451111,1133800349,3307566265,504546419,1646242583,219801339,529248539,202945905,707810705,3410098655,1484540255,1203071745,3615782163,958587541,558498599,2182432809,1127546909,1285215241,1222050767,473657867,2193391693,629916655,4209824975,3532137569,3893168615,2953172315,1325065547,971245845,2853216521,700247743,853447847,3002186669,475592777,353685711,161026687,546149995,797875493,1005535789,3638687933,3683774765,1248949151,1583231885,2055921671,863661073,2857184291,2962048723,186999513,3279739883,977979191,56445805,3791856761,1011890561,3069158587,791187575,270847607,3765383309,2749181373,233203965,2448884433,4024071129,4008470585,3803132511,1544859875,1382643701,2319638973,754108379,4146025359,698847663,3092107051,4233932857,691417413,2765946827,2837315233,4030239849,311965275,3340295051,821439089,1901902713,2132312249,564884613,2137987757,1463867101,1641723281,1573303917,2700287961,3115348929,4018152649,3320824987,5587785,3719606127,2171229125,1805790857,1688051001,2814213743,2310553879,2679756105,1633828657,2032344463,4033484559,3306198717,3289970947,1132780079,3339757551,377611177,2844375407,2431500035,3902269935,1300234971,255582531,608321323,2034332747,3090835395,41079641,3230776053,2676608829,277168453,2625659681,2968296817,2119500315,4278041869,3297207529,2498929521,3318275521,106385663,1317460543,2002962437,4131012387,1778897605,664730507,915716261,1575401031,3586744607,2550655365,796174947,2489230225,3510964821,230111087,2006491415,3313003517,1694127609,1864549343,1399447583,1274642343,3911980429,1295750457,2193767025,2643154285,647362959,1077113017,4046316609,4226098367,2161130097,3870119021,2105702417,10036765,1184201695,4294431569,3880988613,107341519,202663159,250665977,3875144125,663279465,2297857131,4033877169,1314860399,1252015169,1574188883,394042347,4125142781,1912677325,2832589785,1919046605,2506896395,4073540725,2220315521,2167127981,1597340353,2953742177,2312801593,1802379657,190587423,3452201137,431351719,4118533061,2492262929,2942013421,2756095025,466836191,3505600099,259541607,2724002245,2249361775,721247443,1608087639,3194751631,2804536729,2877736753,494926743,3177105223,2574100759,4000888151,919215799,262594081,2487325235,1558568949,4157783837,755091885,3495941525,1136645561,3882404115,2422847163,207370933,2064812303,4259625101,3004232921,507211789,3493443233,2097524857,8739253,851753981,303184571,1791890919,26911,452309983,4176758001,1826286477,2560552821,3933960767,1352103939,138967025,3451565339,2630396615,977567969,1734972239,1145478713,2017334489,868954593,1631061757,2773696397,4235319403,2520259565,1035072333,1843176837,2968991937,917480273,1158379657,4095135597,93109235,1518834435,2059737609,573621629,2952127673,947636629,1190114257,587646047,2437319829,2931299931,3083094943,3091288991,3369700319,1114539555,1713948557,4282740741,666770647,844610889,508321559,670511153,3581753115,263027907,1188704229,2659109215,2513899241,1511289215,4096243889,1540303703,2116472189,628968421,1157758019,2237200319,2482086563,3706521819,1306596563,4095644219,51584601,3693979719,964919269,3896636039,1100625367,4081392011,1032893209,3873345415,497131553,1578641247,2210480097,71913985,1772553087,1406598831,1206583247,2504054161,3548754121,3994683969,4019711275,3746848405,470695013,3936312043,2215294025,3670190589,572969701,585108365,2736171395,617835713,3028895599,2695980711,3737842177,3721843601,1121748997,2623956019,104653347,2267196589,4118223055,1576959381,4008129293,2362005161,4133026585,1271785039,3133912335,2480704829,1958554951,803737047,736426105,3312789527,2392564973,2355711589,1436177037,111285385,2062709611,3279419009,4174984461,2083170755,3572482697,3368902459,589808417,125566773,1571829263,3685581947,1557485967,3135974539,2780429105,1427825821,1486318775,1029886327,581319875,3487529375,1487561213,436705323,3902242315,836025631,2244778349,997017953,2213338983,876570753,786844057,283784579,2153739719,4214087501,2157968053,2265253041,1517782877,1566071479,1403786727,1188191553,2632498271,1940362009,4272606021,2131223367,3738881309,4006665949,3537386317,1914563077,166685297,1161127797,3038484343,645243947,4117583979,3720910931,2626233483,4022252443,3506586041,3945366919,4076739667,150358893,1641162585,739620833,1172008201,1221840729,1238516495,2335241547,993564663,8468775,600797529,135978515,468318003,2640610619,845641437,648872619,680164873,2623067983,2359301471,1641781695,2555068015,1945139499,2963501865,3135120637,1313800073,610985263,3857499387,460911185,2708272019,4159425621,2578751809,566706915,2700646413,549917105,3982151147,3833969327,128183813,2606747603,2940581627,166769737,2580310877,1000159027,3465762173,718417189,1284648895,293408133,688054625,2082143733,3491193119,2934564505,2116215339,607057765,2272549911,3897192735,1867080451,990106799,2021690643,1068390873,3482130397,941251141,1243399791,2804418833,896258681,969368315,1362340869,392357775,1582344941,33955745,3758540213,3701383839,851912583,2968808385,2127489103,1106648377,2230906025,4068069655,462355205,1208112395,2434640833,855087099,488323975,3873533091,3651402085,2622162729,29599375,3555473621,965203531,84292885,3666295275,3823904007,2759042333,2757601513,16576243,3719026091,1012498661,404593405,1068148239,3699148053,1929762927,2227493901,2555076409,2086217457,3238795683,23576831,1118824375,714474299,3735973369,2377558603,3546721345,4189556089,2175386793,2964240229,2659902503,2961788775,113020771,1164571055,779779433,1807733243,4268961445,1006376651,591186391,1810339321,824674157,439115767,1464901683,1850073779,2921779193,1981841255,1334624621,2716812685,1673511087,3255014903,2037067849,1815054475,2762856143,2431796773,299610913,1858963029,1999548653,2590119521,2645281563,2040785953,4175686287,993858455,651263625,2211097069,1851427801,4203990477,4255977445,1827620645,3509077927,2876821981,2300222915,845935917,1303230685,3359907495,4030271053,836410903,130110265,624888015,1297851081,3139216241,1429139797,2095476937,4244053459,3284650761,1910727151,120786425,2832899013,2821274307,718368795,471290937,1067104829,3342425359,2265787293,1907021653,2266990949,662031575,2799406371,2551155727,615824493,3586059411,3919468075,2586565253,3038241403,857118661,273048157,2095321513,1631842291,3007229453,3625284879,1756945475,1082468881,3868009683,1013797003,750990929,3290650737,3968076021,3496527815,2400487003,2357283685,2088590745,176974159,2287339671,3360586003,2549053127,3932131939,679762801,160411173,3086108079,2193458215,1747951909,251460409,47293573,294148827,251996801,472499329,4196679997,1647824317,1034200913,82122779,1553062085,1798233763,3524990963,4039245805,1351212477,2336034367,1433588521,3850737207,2773068863,2278290053,1587511567,970093047,658009711,3923414827,200149413,951809895,2610719215,971987807,2438469973,786933669,1789893463,788522271,2719723513,3351157049,2990413127,166167907,1055288655,2316484465,3570867245,1987804459,2773946487,4143614739,3133230263,3902022607,1438360569,2450169357,4144952327,4139235309,2542594251,2751985357,115122819,2133953439,2378561179,3217147001,1246398447,1663222697,2136735933,1899297603,1297901419,3985247007,31513525,1366854319,3235467927,4223523855,1840979853,404020201,24243199,3728536763,1944573087,2033749969,1886020137,1481829645,2890489709,85493535,2370783355,1344277853,1749925737,3360816547,2128838841,2316858473,1266885113,2385234639,3708839577,1606449623,1434420483,653653365,3720751603,4243375081,473086303,1177050133,62245973,2491032575,3738290213,2662050065,401157663,3453174561,3906787005,4204186463,3254946853,893351499,3647967969,739549939,4275460037,2854030045,1488243729,3317817147,992428433,2386687635,2359539585,1348796399,383717067,2386853581,853626713,1713420237,3993201089,571783585,2124893223,427366157,1557701937,2470815035,3244511659,1602704995,2922967097,472107313,1903034379,3972353535,2374261615,3968818851,3096369743,2862553303,3004720233,107529985,3370211221,1111334881,3687567461,568281413,3393430535,516321525,1981953601,3222823843,2167801473,31818515,2197853955,2612710091,72902387,1204756325,1863747165,802143819,4023814167,3984677545,3345467573,1856670463,2123097537,312042613,345147523,2688588967,4058852295,165008269,3040089259,1849263395,2186557187,1726491251,339434099,1152352267,1577039629,1061890135,1598409181,3737665197,747340741,2071483137,412215201,318654791,4101840819,1118625745,1671067183,835026021,2624202255,4243141799,847283023,2469204757,1950373077,729934137,1576465701,5816827,3274147727,1479893767,418959221,1996249287,2972249981,4135818253,946708881,2777322797,759714793,3883744989,3484080011,3643642581,1057197821,44099075,2438795763,1967518905,1137056635,2201390245,1917594005,3862851959,227275615,1595353745,3924559873,2265068359,2708799797,144888585,4190976497,278380285,1518083635,2325943891,3641650149,1930131549,4127956561,1959237551,3686260659,79696669,3727104255,3638214895,28392393,449596323,1517947321,34914493,2692348673,2823721627,3195770389,2746933259,1103857613,2571175711,2084246649,180196685,613759331,3236620029,2112065699,3878502283,1269266149,3748601045,4157511729,476740023,2455580057,593306759,3087625945,1934428313,3329225111,3747518445,3142122705,3033440011,1764501903,3529302751,3493022723,3619947875,2252232421,1723554531,2521588587,1897108617,3162319363,3176254791,1165792017,4120618591,3184027287,2949113469,1827517529,1776007315,3627234005,156167805,487298807,3823403691,2940165909,1769731899,1235532349,3720307253,1070151925,3015360303,2841527421,1810039567,81675973,2633528231,2071030553,1395570501,537034579,2213901365,1738590439,1827023997,2071149579,3396040483,1432044621,3672213671,215170523,8535319,1719202537,2392069427,2617004555,3530482131,1840025913,1551019797,1833237699,3425624037,426630595,2080013285,2044491935,2037616351,2443793001,56752091,349670975,1404835439,1634024961,1036658497,2732031421,4051736693,832169687,1862436951,256213591,2624612155,2542396511,3723536471,3804011323,3430151277,3501509277,224572957,3416420973,369556531,613926199,1746203211,925864181,332800711,1334149795,3326346691,2614553739,994323265,4168358001,2381407179,3805228767,2416896115,3267322253,2728269187,949411971,963516193,1789974177,2145082469,445607453,3196485935,1888212999,3977522927,3356887079,510779575,3327680419,3555683765,202126445,4115015661,3504863245,760138311,2411877427,522611623,325448337,2316851503,1149740323,627769761,2486715869,4201856469,2749443341,341132847,3933406139,620405731,3273515185,3733662255,2189371251,1777824665,4106664397,584122605,3348372251,3430953375,4097468481,647184977,2380736837,1128725361,3911588829,3304063845,1768915595,400812903,1953760535,1828365921,3150029777,2783613001,3399958365,2855377985,2668234839,1269439225,2362522083,4231000051,2939354499,1017265911,3218352863,38484611,2565779783,1589197927,3542941803,796335811,897904179,2855449437,3869128603,2639616267,1313436549,3091171983,1403146863,3318899187,1998405537,557638085,604675893,895132853,3522413589,3670993927,1189769585,3384678331,3741884187,2936428967,3387457115,3200266641,1006029331,3343713739,2444753483,3314671183,3952786307,4220342257,4202437089,3917989093,3499118543,2993179559,3711917591,1799023393,3911400491,138667079,2705340211,2129168799,3567495285,1149847561,2430118827,2163143549,3350468433,6778603,2258847783,1238794021,2704653735,3476468549,271852273,3470935595,1768774863,2330497473,2864291531,2154347171,1538631383,4074561007,2188325919,1388798917,2691139229,3971432789,4079152769,2052658561,1855146125,2273352535,207025127,547818155,3064836849,1170181007,576962229,3263017051,3385183171,3636795479,1942071445,2938325815,908043099,1461586117,1959930839,2453450193,3451388157,3947466035,701876633,2460398313,4264324059,375241441,1670928101,2792442141,1467459055,1882152043,895283197,1754277903,3493226511,2750045497,1871634151,214731407,1218247295,973213373,1561721265,1304184027,2202857313,804802117,1457188419,1062264551,3596251599,3420880031,2298500339,1959372143,1653381109,4232890883,358829571,714535827,475107171,782040257,1150696565,3814427173,2395683173,3223691461,3864955317,1218675169,3869524397,701791437,1028509141,3204758537,3486881405,3482031305,3570779191,507880881,1853970595,3991056295,3178936473,3287148451,939730041,1448075855,2526223987,2494865125,3727448653,836577493,2929988395,2514945861,1921962379,4267669779,772182659,2977771445,2445783233,3441810257,1885490613,1172054365,1997719077,1905206747,1828636865,3408818291,1440298977,669254261,3932005741,2853720309,577478071,3342838957,627194291,1404726167,4092457751,2331191747,1648052767,578792769,3964131773,1630061089,3135338497,680405799,2377343971,4234368615,3720234825,4147821823,827247053,732105899,3717531283,1659064369,967193941,3472342697,3943101707,365059935,2349048519,1119109191,1206409517,3879141345,3420046595,1175843369,1254999895,198871237,944342333,1657456207,4003586265,3316744857,150319579,980412187,2293103931,1456256061,2571992821,2932512537,1988527515,2041446797,2397589513,903809489,3321746845,2614353309,1920663549,3913070439,2435679351,1129589949,1262850169,3289407535,253449183,3407847133,2297915647,722388287,3602383571,3401718379,2371162225,3416978649,1152482475,3765445485,3794173405,1293020623,3558087221,1942305791,2582011743,3816810125,3791251791,3729061653,2176464729,3901241405,1193600437,3345298485,3309775741,3279471199,757174497,4138663057,1514689475,1114871593,2999543929,3303701831,4274480885,3577291557,2587033893,2324739295,575874353,2158954295,1661153159,1713749119,930786275,1454055983,4249987521,4234183033,601158151,1901985175,3518251083,2431232289,3697230207,4056263557,3900728937,1170485349,1397070929,4279891505,24301429,412241079,753586337,3962000053,161981401,3707126311,2876359019,3109155169,2998843385,119593411,4256749185,1913352943,1302799629,410116597,3702123009,390240891,363613905,3815426073,2004326297,1283603643,4200694239,395712907,2137473643,1413087691,2890670917,3131056391,1725494255,762791503,4054402431,2685555313,316869751,4165444597,660466385,2263061805,3344385071,842928525,2297600869,4021849029,1021374237,3547511241,285468985,398780303,2151590687,2455045029,191025751,2229245245,1925143959,1905910017,763593873,359965845,2632023769,2555341483,2246348881,1623145513,2869369603,1602157395,2309388485,272848323,3031678769,2228078667,3793303983,3860514245,3886989357,2177598165,1476063787,472994771,3933639103,240864385,2348544553,1238887217,4270998907,890262133,3264601135,4239079195,1286574299,2588902103,3658973707,1029394863,911219015,3299598801,4034332379,375640281,4079264687,3933664387,665812573,1922130347,2795740661,1071109873,1935723163,3616932591,3113961761,2178856543,1150786363,1028694865,2031254511,2894530471,3574071059,4294698829,4077860139,1802262621,2518530665,2042221091,2526246889,2879779039,459889193,2711521651,2941415823,1302200027,3217507665,3013111001,3692214353,1359183965,3168847069,1218259889,1184880731,2822087739,1504818537,2717741093,97395167,538049561,2092834663,2785027281,1399958561,1272715001,1583914493,643612445,2466733629,3367797721,3497313321,2717584463,1759882051,3192861479,1101523123,1990107927,2833627517,2180339153,299208869,3691744109,2045727645,1331357851,3646784117,2317385845,1540491729,981657877,1754579291,4263687333,2558689441,2680904165,3749403901,471243345,267226085,3028005171,615459197,1741496833,3430147721,3441743585,764934309,1413837227,2603220587,3791565831,417197345,2449170413,240602401,2240346759,3824696115,3187099607,3045988181,2208197687,366154761,3569919925,3246066395,1963349183,4070982979,2181951439,1627095907,544164857,1793399479,3879558361,1838899919,4101275109,200672363,1151095957,1937073929,549452989,476720829,2132986499,3307069775,749973577,3371884849,3470196913,2238648371,1049692763,2755608089,872837427,2465343385,1476803283,16802161,3221062623,2631747991,2215307931,3903908731,3073675579,3693828121,2711978977,2037759317,551655269,3130702437,71556671,62143983,776886645,433285561,2260877203,987517609,1454847253,368993235,4031512209,221683325,2095016183,795128275,2077683097,1535727865,2519774215,1467729471,2132066461,728892991,1257794055,4210645417,141437087,2016224433,3687079871,963290871,2297954617,1377357077,3661662579,3271593627,1502808007,3286501735,2955276111,2323826567,2415524033,1681576549,1372281329,4252911823,1843319219,1067038917,2234642375,2440394695,3070965265,1091253663,1189985467,2718039811,822981299,2052022419,4048409413,745149549,3898824839,3528048615,3889595441,3028379013,2603654397,2492675913,1293100921,612688413,2417570379,1714775419,999941199,4099694271,3696299155,1292974475,2782477785,1500252229,3281213829,4275753143,3485295293,2594050685,4291845501,3366616677,827375989,2899133251,3623583227,3222051369,2069732837,1059694159,3345346195,4111637711,2566232417,606682977,268455289,2212400329,2280482151,4070364301,373764881,2624187945,4002633629,190693487,939851491,3489286005,946470565,3066913079,1705640265,2084230505,4203831771,1588605703,2179367623,1150573335,1743300563,3680666773,552535135,738741123,3566591407,3138239191,2187729623,4251753927,3857397617,3045430089,1418280031,4258983417,809384521,1164241155,3825084721,1128466061,3848501023,3844230021,780976111,445463919,784109997,1577078393,1713396683,3597329011,54107045,3139023087,2477767813,4135734567,3835165573,3053621159,1646640113,2606120755,995081879,4033481617,3256752523,1176476131,3299896241,443471871,1663497613,2462281851,1561208873,1282346271,247912211,542271903,43292659,1770263933,1587493199,661382071,473127231,1864927029,3452248891,1233953197,2949303353,723930623,3754620959,2254991271,846906247,431697819,1345501173,835428507,798849869,202004045,2057838861,3021102345,563779553,745113513,3293167787,3322462431,1756305329,3208436941,885308023,1605252951,2796790649,1538389013,1048417,440892149,1255782899,473917583,2263471211,1635337125,1615362375,907188057,4270764399,1243853471,1839484005,1033106629,3165328061,2203834549,49338393,301700215,2614123391,2351399017,1969223431,4015221353,1299173349,3887738047,1875929113,3680681037,792270183,1286371087,3468485313,3536558229,881789943,2606424507,1805274449,1598716333,310034273,950715495,1397007591,3215369739,1440727071,3569262825,792121283,3078776081,3518619355,30845205,3019301961,369496723,3903700437,3867845615,2551273421,2593907551,1886192363,81464733,3378184845,1980047335,1248982239,2139341901,2748128839,4018101497,2461113323,3396595247,2166028581,299593729,1570151541,1257912057,1898937737,3839568145,4033204765,2898668253,103329135,1486001975,396021,2360974459,3989887247,710615913,3312589277,3321930517,1406361319,1509686357,2926813247,689840953,2040187371,2705253201,666791729,1198936063,2826851493,4259820723,1997084581,4126134357,1398225981,2218013999,2140153373,3501636861,2368877245,3668025435,2837932069,1512500619,2981474447,257628437,634125113,1926934583,1936156527,2310546751,2559955809,2489914671,2129546861,1331648731,4240636983,1698513451,2562951839,1304583353,324394807,1790041969,3284462613,3043491009,3187900823,3627123611,2595743141,2672182435,3192175787,2461999561,1111728137,1707086465,620710141,4094766761,2484017171,1794512123,1104929599,3408175237,3517392281,882248957,1731138217,1131580369,356100757,2095999163,136203959,4257355311,3510578037,2319366987,477806971,3207905917,550322243,2201370925,1592882765,1049504659,3889111455,3483960899,1641727197,1639120129,771801193,861439677,4176887365,4000507225,3106927105,4206477383,3103733647,2073636305,2240771425,2372122989,2384670021,2809239439,311805137,648855685,395555135,3780766933,3603712301,4258847019,2811910629,2256822527,1560054781,3360358497,3020327079,418785773,3376076045,897184087,3637765075,1058202241,4040484133,688954703,29885503,4069459623,2348710911,4034866123,756341101,3016678367,3519392599,141855231,454036053,3122045433,602178439,1870096415,139806219,376029721,2034648179,4097333725,2677308179,3441209315,375393007,4218297863,4202045483,1631234345,1379415619,3899839621,3403620513,4275557305,193846027,2384983743,3786997799,951694813,676536041,1762830675,1210777519,4277706961,1963376067,227855073,2744369763,968853281,1296099019,3757081265,655681273,3444063007,1092754217,639992781,1760582897,2087078319,527434141,4068097071,923135917,1723507897,1737810949,1611037449,1232600773,1693949655,3168643759,2096196013,3444661909,2568565543,1164826013,769891245,3120681993,3456646123,2123787423,3317022027,513748475,1686375191,418678837,1578802693,628935725,608236347,606141115,4046282537,3653450263,2686152023,1755840133,3979822357,3348701443,373748731,2352754895,3282628507,2282442525,2658631767,3079365293,536603557,3559649199,2424666273,716381645,1432999239,2536609221,945833909,956570275,1014047289,662580437,3434195417,2751893553,2867140285,2788715415,3256884583,3396008551,895363497,3103880003,238474303,833142025,1024652541,2811391747,2125907341,291778207,3358659401,233424371,1858280781,3417908399,3893888843,2173142429,3897920127,1207455913,4286049741,446558825,2006325963,532251753,3433323369,980284699,150413115,2552471739,1259201707,2099248817,3213531209,605324419,3204974747,2825755581,3020696915,2339652131,2107805953,1004427965,2199359141,2140567429,1870741465,2391226981,1342916515,344754441,377027087,1617509365,2631910635,653898345,3543163169,221866879,885040967,1411810053,2892245521,3825622055,1569504011,3259777229,473102345,1446668027,339695261,1246734707,3019777223,4062257863,1567814823,639398277,358688757,2642842223,3992471513,1194701635,378296801,1482756093,1281432069,2062788373,308204649,264995985,4201420117,4005609865,2967651705,4162004813,2977558813,3167044503,987304185,2162797379,1827356537,3365182065,2485655869,3566305645,2630404551,1110948321,1485620835,2184510629,1689729297,956563557,901137863,1369401603,3097997175,150031869,439837511,710351209,3158676443,2079240467,1940641691,383286807,3745408349,2037477585,111552839,2262841695,3939963595,3457386373,1680267291,842418593,2317108333,1171314839,2453407477,2733460345,2297858597,4058516231,3106715209,645141311,2392580727,2620489067,1965133199,3990168833,1148264521,1593769311,3064781399,238232857,1070126397,2586311207,3063457575,3758526653,3473480919,1598362391,2951265667,3639770963,411423505,4192489295,4229139801,1738903807,2798832679,1499048871,236245099,2021616043,4109555967,1938099361,604019437,2746978743,1868307201,133257579,1982186885,2848660737,1440597347,1388991557,1633872415,2767785169,3669558169,2828788643,2457762421,2912560155,1656292173,1619536003,2333877149,3831931241,233810763,4057403831,1590477585,3575317339,3766090319,1746996561,1374795749,3563095823,222533725,3502787101,226124455,3722644095,1690749773,927834513,3383399577,3724702179,1921229209,535216177,1716790009,499416977,1335056769,1389989533,1226985871,1813572209,3620215245,2450952717,131014671,2940337775,363316467,3111352901,1281419463,1850919331,4248069775,2067397069,457147029,3868611537,2539222593,1919104173,3474441771,567532779,3696040779,1245416337,2336769103,897394591,2880738509,3700799601,3917526399,17587779,3540042467,3606803187,372793199,3472997747,2067625175,4290924571,773448049,2770344705,3738006781,2193375735,361710549,1890492839,3640088161,1447602997,3168834169,1001449589,3681401237,11769701,244885989,1220166277,3160772789,2952789337,3478288889,801535595,2391327987,3040524357,572020893,1818361485,2509198391,4108481851,1065300925,3088981889,3248942651,3059943541,532732037,2915521969,4190859837,2612642959,3239582157,356943467,3374524251,585986093,308276715,1476209247,2917740991,2831256945,992841195,734043981,1931137105,3848467077,3273699599,2538141059,921631411,2207079319,3044580255,20021875,1500220999,2756331219,141581455,147650115,3359370973,3602880387,3161770303,2538137959,869529711,2707135395,2236055229,416428109,2405522843,1095300685,488807517,3410488897,3748370255,278624199,1322578939,2128498129,885479183,186971777,2813580931,264817183,1196294903,1386548313,3519943447,810022979,3304870173,2435968409,1692820461,1370149377,2780932911,1305358675,470329779,2092791499,2059569933,2050458391,3531594581,3357103887,4154671631,4282820465,2006691915,2387839723,247846131,3726632637,6698463,911934803,2444945835,2252563953,3000645561,343994385,487667777,1434747893,1861465941,1116317697,1534410093,1846816681,4014307929,3127125357,81115227,1799004797,3598857519,4268904531,49823053,4152413541,690840187,1654444033,622618081,1801775989,2929641229,975094193,3107891947,3242707701,1348353947,1537360891,4196238433,2816392757,278536531,4144110157,2869786001,10623993,2463808103,1443122473,879111299,536127739,4152510661,2323136027,3694520135,1457756393,2018268981,3690059755,3801561025,902698437,1828165057,4069075823,193151605,3598735071,2210920995,3187119377,3378262571,3286388217,1047379085,2524327589,686874997,3730972407,4225736149,368299465,961254407,2430842521,1441366725,1435025721,2235953843,3007400901,2211844121,1522228883,3275650323,964220975,750343369,997044405,2657917747,3963733035,3518406111,741820591,3783602555,4017371021,3068905073,825345071,3125232777,2632261519,2256238439,333222353,4125719595,3017255635,336633993,1335610959,2114326275,3217297469,3775314123,2152647805,3042158079,2260182783,2201302551,443720947,1554750651,113191467,4033458727,2872040293,3538771285,3716883783,3661433751,3720648725,2514304535,4028098179,2971623231,2191965591,2431224105,3559681719,2971229913,4171404553,2045199115,1038288729,66569587,2143569075,779798259,2124141825,683521853,3209256021,1766683701,1544076091,1094487895,4008115163,2124522251,2782374341,4056636215,1574057355,2478418545,2187685409,3508649229,4261629283,2328781443,4087746379,456573835,2824874567,1098396499,980545887,245232537,2749631219,3498798393,1907385803,4092292705,3852230919,2108082683,1360461781,3170264111,3559648313,2409775271,3846381377,2579078051,1754888915,877603313,961210801,1697956479,1791858023,3742111133,2455743095,3333486425,2352978845,2751588863,2041182749,2254702071,281289141,3162586193,3365899307,1655440281,186689041,2356604273,3554615143,3716632961,3740835691,2494225871,1573441263,713694889,3521331381,2662193247,2807617537,3117269281,1933770361,860960435,417234365,3071365553,3523926785,3333475335,2166589215,1132234779,2764835039,1331363493,3741609211,2609874629,3956900081,346097877,1481319469,2905896265,1325442587,3013189831,722142869,3772610539,3958151751,4203046391,1273625925,4008912279,2636748981,367600981,2106735701,196571777,952023759,1910164169,3543649833,4106261433,2401441245,1215359803,3982742857,893937415,610556299,942868733,2660464771,3821892463,3310760677,2653421375,1407652829,1741258457,3718729583,324055999,390663207,3166511623,621124613,2470863077,4051953553,181968413,326420769,1480646951,192820827,2334316519,2626488243,4009036469,429043017,3970884193,3448834385,3975892971,1732020351,3072704625,259906125,260521683,2016270401,164696753,2099407141,1579515383,4017181967,4186441789,1372954221,2677305785,3400973357,2734479353,2244456877,4183972637,2823589497,975061479,2558067749,822061309,3769619665,935172667,2161702329,602720363,2388278495,3327319841,1790416613,991169733,2706553205,1041122487,448900059,2700740155,2125438899,1008608101,3735428189,1804652931,4037765189,2236303129,287916115,2872988567,2296543227,3425929111,1259042019,3710339895,1052490485,2532281509,1224422323,1677693913,541327487,1350362123,929036571,2111551913,3833235569,680814989,664665713,4121690797,4024724353,2102304471,3030300459,537658967,4118055893,3062434941,3750986191,1294987611,2257516185,333462905,3873709765,2325794709,1134348275,3926623959,2596423409,1220544829,933161665,2722530067,3276269893,2787399377,2613070387,1833429965,2362071405,951422199,389679837,3818881209,4240222227,3317643947,2376423327,1646006789,551778875,913181185,1918051639,2964372009,579761669,3068564897,3697941627,3128197615,922686257,2756006865,3280098365,2708018871,4199734479,1444895763,618025271,1919829611,2781976355,1662652807,1148529291,1748791407,1476001413,3719642247,2778297965,4264461487,2684993837,3765044501,1349802611,115252975,26518037,3307033383,138333233,1389357783,3494065503,3966082159,50460239,1976696761,770459843,4087173991,3721350601,1425832585,2345739675,1341942905,1161160347,3585552193,3984589737,1869678517,1706129121,1710498709,2135720227,2008196037,1897814413,2139730853],"b":[695310515,3772802731,2893355401,1004538745,4061238601,1616947565,1779672623,805556151,1245335975,986124969,3818550537,2977585217,3610816531,3400556397,21599927,2252737199,1617423789,1193634803,3922887847,4228098435,1416534621,693681311,2160574867,3128302999,2693875145,2709332767,512580787,3535879445,2358369137,3151913333,80800341,801683089,575292351,967181269,3259364393,2124502281,2446738551,2317970707,2780332775,4103774805,3558357389,2188052073,1081236489,335066515,760811977,849280007,1672776493,3793595427,168878965,3670367521,3546665825,3256431449,75152707,371178919,2111597551,305306141,3089379557,1342614139,3852655597,655711241,3947735183,930479775,597677777,3536881473,2019584557,31141823,3709593393,1390933253,4203186029,3620521791,3308104045,953080291,2487428317,3291068123,2393147935,3563619335,431265321,2666441875,1199864335,1248449821,1780927163,415773461,4287755789,3350303797,1534708645,2569612851,1587062393,2010760217,2044314733,3354349631,813563979,2688915057,949512337,2650367555,1621707617,177488001,2333547577,2587781931,2012112079,3290222897,1072336435,1075714227,2011689549,483728481,3946476725,1254412639,3213761527,181311751,2174804417,1766181385,1691585667,2091803089,2627232239,3628475359,3839735307,2547729205,3155811355,1170346685,3361512375,938718155,1621177029,4144797367,1534822589,189702365,1461933213,3498606017,2969089665,2559994769,3144715391,3659040673,2154892425,2112780773,3011849119,3958600049,3147656289,1547105831,475720547,2501116101,1413419935,4179728531,212376659,296703305,235435607,1301385881,2419057725,942795877,1435973979,993456873,2491809539,3911822279,2932690701,687962569,534958541,1681669051,2926962443,3197378125,3998348447,1184083611,2309793781,2789690901,2472008609,1830073407,1782975921,489510815,2345916501,18890193,3954878095,722317527,2413120251,4230885415,1012667247,3238018307,4138087575,432498089,1910737181,289360635,1381232443,75462237,1278482335,4026216563,1412074177,3036410295,146457563,496018685,54537947,1791258413,2254400451,3801896389,2244193891,4058934229,1542073007,1788393459,1347758807,124777499,1191403027,773166967,2341166825,1795464247,4222375785,4020203833,3435336123,448902825,2747228317,1767930125,1017887789,785354527,1019057633,3267053459,2505615723,4024122891,583467225,923335179,777537037,2774489317,382056667,250314545,2263593795,3695606413,2534961563,3318416961,2483567743,2830910315,3756965373,3002851723,3063220767,4073461891,895352483,2918767705,2907369967,324148337,1942587973,3029677323,2949514097,4265905031,1176834081,726027303,338816073,3650091167,2064400373,1631284885,2228841399,3727638825,4032798297,362127871,314489105,2808632921,3002958993,571140363,4199162951,429159255,1629528965,2781865017,4086362335,2964750091,2639218549,3218924711,1059599359,1752042595,284143307,3887913921,536876137,3845933965,3649359155,2646376571,3264716233,1878563987,720368121,4009191961,3042397061,1981785963,405331977,596425961,3972446431,3935564687,2539383615,330433633,205375495,2887224189,1036473717,3921401255,717783161,3513442181,3212394961,2983240753,4174129615,600675915,2386979311,2966770823,2241922921,250479791,745916023,3896051475,4160760101,3532520699,1742499937,3109447473,3616629419,2313517251,945541781,341742273,1291127039,1797391991,2262230841,2263275005,2632670177,534618857,267567357,173829087,967722095,3759092387,96870375,307805005,2138113865,3583364257,1571687737,1306954465,1520968545,3567986027,807813767,534382441,589090939,951815909,2711796513,3266054163,2890317027,1478194455,1923393495,2550632627,414017381,543122993,1462660407,2835653693,1874540833,1822695547,2337334427,1808860471,1739445971,3321048439,3761145549,244625757,1141414347,2427011831,1483469305,383484271,2769218503,1989798943,1935500723,4173350805,396118127,358071595,860135077,3725311635,3574421613,1596525319,2140367621,2807535703,1741885243,1368220003,418715151,2189132091,2053229839,2866680883,3657480589,1704364401,2115620727,3498315763,2385757981,3914713983,4288919595,1435554769,2537728991,2585939123,1104809081,1382629211,2076105543,791581551,2597434945,1041561205,3527466191,2690729861,1386152107,1155876499,679264737,379384113,2577339701,2603211523,3639227183,4157014927,716923397,1948290515,88052955,2437282355,2301474413,405026333,4049401841,245017769,3434992737,3267548911,2242742899,1146948155,944442419,3339601609,2051661277,2273663113,1131942279,2143754833,3901832965,2546014769,111089267,3061521679,1286693639,299682189,3056898761,898722105,3717429837,4249028741,1004869455,1029546983,3467899855,2286700211,1203116371,70844051,970041525,4087046751,1582827921,3856433311,4018208323,4256537905,2657337277,2797708333,4077002119,266422363,2404751399,1014543259,408413639,850311667,1832016937,88146279,4005778823,1512361517,643587133,2041314845,179872249,3750898067,4108854837,3039109333,2559516289,3692836619,3227674039,2080667059,147569671,2007348665,540935091,3345297139,3287153519,1024907917,2808528885,1254425941,3437328241,3865658993,160455819,3836473401,3559449885,3369763169,2170859505,4183522105,3841432761,1012067525,1748425241,3911784039,2289991021,677185219,4083630733,4388217,738335927,1051429529,1880663193,1641985011,1677232733,1380209815,68022617,794840521,1536368913,408966069,1545068089,587129105,2339010223,4204160079,2811510965,4129604267,3882428529,2833173261,3135593149,665374669,3152212407,812369765,4092596829,373708399,1674894971,744149527,4271324261,2063519517,4006607269,2551151557,545739303,2485309637,2042151715,1360244457,3812666937,2876167779,4189951783,235881263,201591685,3717238929,1040437985,1829376827,2960457743,3512169711,3300828141,3221013289,1802591453,3750242795,1685632921,828248829,389085955,2427441023,106964661,2458745341,2252627419,4067318623,724662263,3166392557,2914949645,3161744957,2112147737,962347655,3625192481,204012289,1450657417,2964863581,251677685,3699051305,303719291,2188995371,4050344093,3196545251,2885137011,317011423,2251558607,3283664515,2514759805,3089886481,1272551219,3126197713,1670071695,1283728381,2002198511,4176609987,3633582473,3775654425,3577136225,4271336263,2265237131,1250383507,4215616707,2089529531,3070248579,1930813943,2712050637,3242148937,547141987,290415861,1936546649,277392617,2098216735,3047198211,1070335427,1804511123,1654398133,4146144075,2694107475,2319135783,886928637,3073108685,2755975251,2748761867,1772501211,534718899,1948973251,2972862319,1542481137,57899781,2459027629,2702074541,3077627931,1401531481,1938977677,2480974567,2197074223,2392656249,3889787321,1958338879,1467182237,1524639211,836360079,3570878591,2178496681,3692520317,2206553619,2799074943,1275812625,2106073533,1952416083,706997627,2629598591,450080483,1065289853,2902894785,2419175755,2926526087,158510127,1199999015,3512016581,727172231,2401751793,2139772745,1399389359,296071575,2502851379,513466223,1237533121,2987543905,3482761281,2954583941,3575427259,1318548465,3107798315,1669034677,1034436031,4033751005,3489389345,2683305945,1166447421,2251091737,4026915013,266021445,4256457161,1300272869,892534217,2796811277,1885083809,2924834125,1786475851,3478259503,307645093,3745440175,2572377167,802281171,2037321937,1790544197,3135474021,2958157667,3509498025,1347474479,3936011391,1457203155,1309932503,33245683,414462767,3733758201,3801935673,2904440079,2621128249,4117930485,954702685,3985200511,3545022547,1407661867,1893160123,1224490115,2817074057,3139211043,1341777011,2667947183,729772127,3148530925,3362211201,4093952149,1677735169,1234717079,2902966245,3620203975,2261537827,3500690589,3644752917,2538745797,2495528389,1990024819,1436831361,2518574265,2775006291,480904097,3721695071,2920372581,4110717135,4273980761,3761642077,4294804559,1559896955,707776915,2842190125,63203813,1409580279,4071139549,518456135,3498605519,2960719779,3621241469,2518830309,2783370505,3619295387,4170768487,4239739735,3798335491,2525723321,2670106251,2657489651,1063690857,1798372777,1566431967,3167541249,746179619,4031342153,1658519427,398288335,2473019099,1633509661,965945985,3972782675,996883007,4240268855,4101320743,967643001,2429759529,419389357,635610451,1121206585,2097572123,803138915,3568523463,1250566031,2988330281,3814480831,3297513179,3341021777,150621089,1752923463,2203989901,2660339457,1715740065,32877345,2813740589,2948189189,3473012745,2319696561,1721989895,1994555099,267836029,394432097,2085736443,3744327973,1059467329,3827981679,2572998933,2662367745,1445438129,1143636045,1112384471,4148157415,2172574503,2942722433,1787557827,188193665,1875016077,1220186867,3506828919,3732450171,3292711933,4250858841,1698589097,3834334161,1964981557,1441521739,4040346019,2662639999,1726243813,475710927,2339432761,2715821657,2197172667,4047204557,1969971227,3698526843,79021045,961826275,3452293409,1982167223,2518201503,804962651,4155283357,1679197465,41722187,1145144793,700108343,2805519341,2212627461,1802922381,722215103,691680083,2885674223,755998919,1560592787,3812690751,3276409677,841781771,203975567,833470763,2254784813,1671933935,2517625003,4000629033,859186867,673648047,468955751,474339373,762561153,182909981,3266452263,991249139,4041129847,2951535313,3876743991,1782423563,4090931791,2454185791,2929681861,1657996217,194632453,2717543643,1073820311,245414395,1511151331,1778827501,3781459873,2365052999,3818432323,990762519,157474801,979144109,2455353455,1079774239,1528834529,2627593001,1101867705,3486530307,1876094513,2165591543,1544230651,3692177815,745089799,2894606589,558418991,844461153,2286675901,794538201,750243967,3621362285,254417527,2502935565,1928380325,464938557,1676836519,3310975705,1972429677,2068023053,2388125529,756420279,52455719,1154990769,2972669803,2601832019,1928739925,2213768463,3799873819,2610598253,3233946767,132224205,1794139243,3427870027,3815246173,3275714291,2039331151,1199665543,2202319971,363629711,4081077515,42126231,3640945007,2963711837,2369152747,4003420255,526614787,3182116275,895505843,1201321931,4271429323,3829296551,3197216167,1276320341,2049321757,1608056119,2664994991,2651888711,1417972745,3389394909,1409032047,3446938913,2183466125,1314619745,1502310685,3517945469,1589745085,4149091721,695586269,4112432915,3046324163,3560079867,1072968761,3113282721,3651133145,2397055443,517629587,2491715165,2325678461,3475535433,1768840837,3439322491,3023280391,2810460323,3651333349,1466916777,1358020285,790746485,1447382565,3759000839,2853190433,261786727,1803028439,2504731909,2054762875,2862613171,4010921709,2049500639,319558599,2112272699,3062583989,1961068633,101517481,1102304255,2233691569,3640067429,1099160273,932393623,2698950055,2103999257,1449797703,1400552265,2661163541,2681217971,433606755,3364217467,3453526459,1231202103,3956306729,3258532695,1031055877,3058077549,3530742845,1926878817,998897365,3735845409,226934883,163638315,1490108851,305184249,1040740713,2622359029,3328813475,1124119487,3810075803,2276651581,4114483721,3154482253,306965841,919186399,4063435575,4181751231,4143124501,3483734785,2136396493,489296817,3044219409,2545217741,3895308847,269345893,912581,2452863791,2185664331,3900129635,3982918517,3846255035,455648057,150225603,3695924849,3591948121,4106769283,2346941607,67977559,37550715,4049658887,270222597,1850774827,1819391047,2633177749,475446873,2196444477,398449815,892046165,3184055901,3430028967,1445845107,3688747997,3229680789,1448375957,3275071007,4112558845,867862379,454090235,4032682307,2707651235,2315843521,1388456025,1223120679,1275799675,1888422883,3210076021,2663521819,3662090671,1876601283,2092940345,266257361,3926530079,1018582249,3867209159,444292017,2562789553,2872009845,3027031749,1435024819,2220793929,1617796649,3165325529,2161279225,2081546023,2035415737,4112779149,275544413,1100223165,1616550291,3692623093,3933909851,496358727,1474656547,2591315855,1277230631,168696611,605543843,2597866621,4001772443,2896609561,4157598337,1932360679,2938238825,3740969463,447564581,1730197879,2507188779,397704025,1242455517,4113874891,1511811031,4276470813,2662273101,4149723715,2727574839,2164407017,3110738639,3842419911,423228399,733879935,3468983277,3315904589,3207804479,3140421071,203881137,3541353047,4158884777,2078721289,1804751633,1401682409,180657279,4059995395,2197220793,561090945,2802319091,4260600533,2218449369,867482375,2657297595,2130772959,463841347,415897225,2072890043,2583247873,3117610565,3374763255,307959027,431794325,2967477515,1234393483,1759255567,1253479479,415043289,605689573,752183437,1858296223,3677442093,2189913197,2296376499,623731615,3337072751,2498817811,1440765551,4215996185,4172448983,2419064949,1064209645,1927708105,2051838899,963988773,1142691649,2419790075,366500445,789896325,43645327,3402587715,4097190495,270041569,3103204525,1770617439,3233901247,3662136859,2652882999,949101985,48548785,4210627735,4139223007,2335834537,2370013005,1281907285,1459809097,2158326757,3999023875,3946067419,2965141285,624081519,627974691,1636007085,4285445507,3176099869,2856985257,3911851579,3425135801,810782731,3189120155,2645600065,3098881773,2132568573,577954787,2765070181,988427793,3867407859,3783842917,3762167861,246754365,2557190651,3260544399,482026653,1113657293,4065640299,2581841853,961468895,1740775043,4183925073,2024181349,4274980969,3392268757,2465155149,2608088125,3995898411,2956001499,1630520801,2271783493,3900907291,4168081027,2021272455,2629839745,208188467,2920204359,1283409981,945817005,672464747,2056069121,3341853223,1239832129,2972265715,105292297,121127357,4267975843,1621233013,790753161,1559586097,4073121097,3757562313,150720421,3422396387,2014091867,2204781461,3079186495,1826512865,2070488643,877623719,1304174443,2041779025,3686378215,2055460361,1700358491,3507768061,2336740589,418159793,1445164773,844309047,4025197653,1467122983,528757233,535500551,2201296533,342576421,2425750593,1760678709,3697390603,2457071835,4190783135,1323512445,638064295,3708257047,405802501,4209555535,3298626783,582527735,2313195925,4134950287,3538673495,2073327253,1341501755,2336686885,3810523959,1218874885,2931183915,1133214031,2043254227,2710294465,3790937191,2736546747,2631409483,820971269,2629186561,2115026861,2107144489,2772104399,3248412781,2744353039,687773013,1644058143,2160623905,3952484665,3445612457,1364556603,3272460761,3191827263,899323987,948358729,441547075,3673189593,3732589695,1342724507,1412643279,4011373021,1044766835,1569914779,1573620417,3724736167,2492465525,2052077099,672448879,1789375645,675489733,1357401295,3272283437,211542795,3461820233,3185708313,1137346393,2776385657,2189071989,1043095525,3544978667,670170707,2154844487,1307086807,3745240539,3512062209,1494042027,1985563871,3771089617,4165819461,2665838339,3941136665,1698337393,3898912327,703492137,3842370277,3883997055,3425585979,4081957083,1940123725,267766833,3526422219,2324561633,1884876413,3734096847,903624407,211073671,4167187753,4187885513,4162787019,3239193173,2409223967,3170549637,4063516501,1246907219,1624219113,3733495627,3683821749,2038609239,1951392441,682515709,3478862989,1860499707,2056692035,926266939,2806987123,1111835771,3516091103,488186781,1567713533,3231984541,1512830175,4225354845,2549657725,1208708643,3865846381,3309885935,836534463,2206783185,2362423411,2572619747,584355937,2975015881,3377659319,1737466441,115858787,1618465733,1525718435,1795008671,860477247,886228237,4186387767,465006467,2818199889,586232997,163024949,4066168371,2867213369,4017038203,1770200241,517021755,865817329,442673237,1125757857,1281389335,1344558035,2163977317,183738033,3653051,1267302847,816155389,3293069987,1678737831,906588137,2777843547,922025455,239842239,2349205907,3764329307,2214438935,2183594841,3477949557,3688317259,285234517,753043921,3435548929,4025533267,2812820187,363894657,4239057643,924349835,650991253,1928308159,3547011889,482794509,1134111203,4237122149,2754240529,3658060271,2857145187,2304827795,930742785,723119553,3007869351,1495148683,3405262087,1800720465,2369318537,2494885491,4069740015,2766291961,48047783,85254415,2646860809,2813369711,1009809937,2459849371,3628190453,3346287459,2751592583,2103704789,795641321,2110512631,3545892171,3138530553,2789683463,2346998143,1018178111,1369829087,1692786175,793904575,2985793667,4131282273,2019904313,1110313621,3703119817,4258691065,190791751,2591374539,2263532619,2667421381,482552501,1361650041,1666513461,1610031659,1508157419,2999756045,2573768149,2705679175,3531169453,506944885,3302554999,2179544637,4125647633,1807790301,932967957,3761847005,3444062161,1078535495,2184100591,3388155219,2048398687,3273887805,1406352007,1353179573,1037278487,267301469,16765,281786161,2926066745,1028283721,3711091891,806385375,2297201861,1610688867,3963917687,2326884981,2278680603,3856518123,1148676313,4219790161,3513294205,725362329,2047499937,1053498437,2293061597,744748523,1453748151,3371222391,926199895,1680178615,3647008355,1791186617,1047725079,4044481453,3447402533,1385592877,346832477,942839787,2173969349,616095391,3844074803,2467194479,2523369083,1757133831,4248168173,3721172255,2723338657,3981340141,3088293367,266887985,1640525765,2921488975,1399114623,4268518211,2146877401,548258519,1876100009,2257962815,3545006021,1129909385,2336643727,3085167453,3564226209,2041062051,226130785,3829032405,3052681639,3035996649,1784243829,324404101,1946246227,89442891,28132943,383987467,2636499087,462599817,1024338985,1836423349,1132268765,3336037741,2283273917,3746935229,1929945981,1009115185,3668054389,3324561947,2683132389,2544459023,4028437303,81345711,1377782091,2214938289,1986302931,3307569155,553118649,1955926333,3869194555,3748071531,3847904519,2408721881,3321924823,1310662261,3708353801,2031946979,1647938265,2949324949,1086894595,941573589,2367816033,3012104527,3956275011,2725448269,782883379,2436146137,384927663,1258504083,3259184131,3389806141,4025640977,328134863,224653751,479358437,3513591215,1422242105,2130084431,1776653133,1596595249,3315681131,3747113167,625582653,87730065,1305437419,1793780187,1688183129,739921745,1934468891,4011219557,2760464681,893200585,1111556371,3115182597,1222610725,1294937385,1413367803,3303546007,1655546917,1978920293,3781623815,825458899,743372679,4099741807,200269413,2968649895,3758714967,2343507023,2472466387,934013665,4157192185,3696098603,2217264305,2424948197,1159711019,701532967,979371145,1976180213,678772195,691165307,2823768579,3984892653,2665820435,3640224137,3732951629,3130781951,1407948469,2415112643,3357279407,2809668977,3236083009,1676305147,2970141089,3051408761,3117572573,2736231711,1631566725,2670758985,743088107,3611907497,261585489,2715788667,1642709737,972800733,3216415373,1834828533,98000017,2113828923,3448236993,2525460215,2543051003,1838681633,432542307,2653909107,1015029965,4293514087,1345770521,1067393049,3891571605,1882029009,3122418053,2569835485,1033904737,3694227335,831634087,1450542339,1030747635,2172421549,372024555,3439299921,2643946401,1075554689,3625301677,2039269461,162841713,986520919,1883347599,3809123713,3454744127,221711709,2572066071,4163625287,148094273,2234399891,2659933401,3481091461,659722965,2653303747,3725646327,609655469,2982488099,114208425,3945602657,3743820939,1127681479,3546933231,3455756797,61787223,3370755913,1676038737,2787555513,942280845,1369765743,628163567,515478723,701882269,2555122565,2861961349,1645683943,3715640741,4244463327,1583367649,42739925,1070398183,2859251215,3341102039,1499584523,649013675,3050893065,3040204489,3785934005,252378231,2588226045,886401489,2803266837,3009498379,3104418515,699310899,2287779915,2169832323,4099543407,1160727907,612500407,3552720831,1943702235,282242287,2002241839,609856389,2064383245,1343414589,125949571,3710547955,254387611,2000137353,3894465833,3280678771,3872967925,2742591711,1149904375,3384991725,419162557,1118750145,3761857983,3628569407,1125432749,112266473,1371986451,3591864571,2702544433,2385168187,2591980813,3863245149,2540652651,184285215,610206337,3650991987,24612937,1352788741,3058499651,2035076571,2707383481,2110669337,1884682619,477001089,2548349025,688224213,637441955,1838523255,2065650555,1168257289,2604772155,4098965443,36821547,384466899,2104378123,3522431271,3968175301,870159481,406777903,3423267773,3774574487,2606487435,2862905345,331555539,1881380461,812206405,1347005309,345638495,2350420783,2707913769,2433285165,3840178787,1411362977,3968173777,844545613,3706195121,110750571,1664025301,2741199479,3520464915,984401067,614733387,2427710045,333450121,3658849077,3229705747,1867845063,956038801,671498359,2993855181,2182194663,1419994381,3007292809,395141877,1130107021,1363344685,83624111,1016145245,1563188577,195493047,1677825,2429417817,3266170361,548289519,2397117009,1552369349,3040321693,1460814339,1873559875,2515603617,91965589,3772412583,631105259,2711855933,4264726103,2837427655,1624749109,4051203811,465956501,1605552151,3530477755,1766478481,2389910845,697455233,1164372511,1737817719,1724820839,2329590673,508605813,1153000837,3887621031,4204208495,3625238677,980428461,2566621049,2843453707,4120357311,3087661621,2534034845,627969417,1547366967,569666005,894464515,879591411,15435535,1727015911,567460131,2475045843,1337257717,4021584217,865646247,1862265357,1667200527,272648039,3960472875,264504519,236318349,3252728793,2269122725,2131052455,866363325,1029293421,3501250615,172208017,3787169663,3840213061,1987406095,373610033,21657609,3222198573,248823171,2967874741,3615603571,2251959091,1424664515,4188823655,2750270437,1357233437,451094031,920121913,2606750197,2984178985,2763125663,2666652119,438467949,3461926439,675745261,1357093097,2387366945,891800873,3356400551,923638067,1573208359,1094244655,4214947777,3731724903,3988034539,3931890909,923738885,3267656485,4050739117,1245779031,4137599867,825524321,1842920233,2951215803,2801706715,2558331689,963133595,3949584179,1941784489,2410423617,1858230717,2576482751,1085354755,831286473,4198128429,221817177,49699453,2075068341,539196713,4193149151,2434437711,1736182939,18877143,3735546745,3797223623,1018427021,1258292163,3992411985,194214539,4283597633,2183652609,153889039,842784291,4168427325,3546535647,1068529803,1522159613,2111429433,1774714209,3368837933,3800287229,968845535,1165911997,1842155157,2977485353,1932402283,3637477253,515745181,885274581,1043193257,892593097,3786407437,3914382561,3013677335,325688009,2050051513,988163329,3717528705,1615735923,2890441999,3578598859,3084022137,1494769373,1325166211,2663105693,963228283,1246038101,4196822063,4035527579,3283497505,4002790029,2819308287,2035209007,638268039,2837615161,481195157,23605903,1607437479,857447099,1498138329,2112634881,559842275,3290758871,1490516865,2867708253,3744619003,1655841245,2630723695,2179834235,402986631,4127868679,482204777,4107387361,4145043965,1384427881,2241581175,3096689357,3939338507,1541466945,192244013,1229738209,827476741,297504821,821613137,532160155,1893835783,3990373147,287202625,3766264019,371405167,1619180393,652107173,3503706423,2792267427,2826008151,2970673611,3411571427,467615495,3718460545,97301627,3260890075,1996835891,4241368821,1113612835,3318434693,2781589467,3750160779,307190009,391810681,977270671,1033252047,1314401093,2122393815,1369488841,269238947,2498438453,3654830233,109504049,2188566517,1137562209,2108637875,2101639137,437966509,3624158947,13275527,4078467101,3413538367,3461205017,1435707589,811207437,1737219309,257278557,3343626541,979216697,3675339971,1219287095,1269262797,3692263981,2193281761,3077256825,3754287527,945966941,3192439099,2592517051,4285862627,1596701121,800104541,4109407173,3732285897,531758815,3738448991,1035664617,3207759437,2383400177,2941807801,3595206979,3043820867,141889641,1032364923,3584377201,1416368369,2194451241,1257870715,1204102743,3763896373,3528051785,3942873631,826753897,1033567595,2322849035,3166012885,828769635,552337809,1717250335,3941148765,1901702093,3055459203,2473874563,3126391227,627494199,2150312629,2449560693,2505071067,3460024087,3062653549,3130163553,3899435165,900895815,1596268161,2113280409,2819296783,1841861279,2333245101,1799035093,4108042391,2269231293,3955754831,2572717597,2228920887,768626347,3336377777,3703291675,2852141177,4101777605,56188047,3754685349,3337194001,241699267,3495504445,2380576589,2730404519,2478198543,2785079089,2270695617,2796844535,2444051015,98226095,1618554575,3018885929,1967181487,4056006897,3882011611,120999729,2122932047,1825619477,4235185703,273163665,4036664469,916371265,3994118671,3108682377,3642562829,89675133,3931424237,1670317169,1114442605,84509907,3018816735,804237929,564815291,972892903,470549269,1486792635,404116759,1647093505,1636345511,1383436701,2762688091,3902314103,2042566547,4037358587,3992477903,1302098365,1508874431,2165674847,2944320979,2884516685,2776094223,1585908045,4084469851,1222542561,149305037,1108873969,981725123,2884782813,2953940225,1346427035,3511489259,454405965,749221829,3622158095,744694315,542674295,2511327709,1241223831,592797465,3117856275,3209443931,629919777,4262296429,656602383,1745289601,2750690087,4115323693,92022481,433629133,3740324513,2492791813,3241032221,3253332645,3828128701,749030393,404693243,2746125505,412838017,2196388715,3756225175,3447245819,3046667973,748559949,1087875523,248161309,433894695,3908657753,1286109747,3371111227,3352833841,1107485213,3410706795,3115614647,4189107781,3230608825,4160975127,2851495387,1837919663,511014399,2979400093,4048666405,769446799,4240812659,356132689,2632680287,704537627,4234051531,2685971331,3013916983,58484651,3699003131,3789026167,682737437,2910478191,1024461577,3896827093,16702651,1548598053,4080659231,1601961631,3314150231,3787080631,2343852237,3979510791,2407178975,3160107445,360287317,3740036379,1945090969,2147858155,4146889115,2331092873,4281244743,1293336025,269114047,399244153,1357583049,2032055621,3473884359,4084011177,2103543231,2375303309,1733439,3364122315,1854306795,1051635107,1040845345,85941759,1314149535,2189425803,2694680129,3353796973,114975561,3953955527,2396586327,1223131563,1458727063,1152450495,3227957625,2551929667,738532191,55071283,2165101977,1906029477,2771358093,3590149721,3945831541,3295707033,3049897013,3479427701,2761679703,4134206163,3917083309,1160508737,1223877511,1110973217,1904047907,3826849455,723579341,2145591679,413965335,3963353165,1428898315,2331856257,4226537749,955888783,2445113127,769273303,1324865387,1902124019,1556834897,783375637,2119591755,1519906655,2900669973,3681466117,1102207861,613597611,518591989,1486936403,2820425535,3632926967,1348499671,3986544159,357910719,2451259439,991124031,1938439691,2028978453,3295529311,62923359,990957195,3429394333,3664453351,2931458397,1451465711,3664958957,2839243851,2084784223,625268315,3394585887,2754453413,2941034365,3480970009,2913446495,3668106671,4203265521,661576541,3741584521,2194909799,374920433,570713939,1327222077,2856307203,1105732589,4019126285,2504856063,4141419153,591754713,2772192587,435621203,2861306651,3527076539,436815991,1467272097,3034916231,805527679,766807071,2824577103,393886345,1503217167,1573319267,2958275411,1193454139,886467999,3921100407,4251365413,1622610113,2460836391,3037166417,4264665429,1817679737,3935961637,620987677,169379725,3496706253,1104527175,939602363,3597159003,1491749883,2116205309,438483555,3724216481,2348037511,1306966911,1730148467,1676721295,1374405937,1306492833,2352254109,3455852793,1675191995,1441264601,4013594947,4028938765,4214450251,3959740009,832127539,1154055515,138757707,4228525007,4290962931,1418164569,2318413583,1633815119,1804811297,2404455257,332251959,701209519,4133115197,2761086923,2761287291,1833904973,1755596273,4176234631,1619941475,558710465,1448297377,1954376947,3598467817,2014150311,3187049769,2208360915,3109527757,670995313,3129095647,3131008199,915531311,2761913675,3771606273,4259322265,2209435563,3991267517,2433977333,2588544481,1943388047,3591619159,2872872243,341485759,1274863535,3334587079,3671801447,1876856343,2084766471,326910451,1120797737,3815998375,3033071423,4159577975,844398193,1228507181,1612425615,3088670265,2306445377,2347639695,3210807987,2080772499,1919699751,599419335,2742475721,3495427739,1091378847,3293952955,3633879125,171550001,1317829339,3906349515,1146259327,2252212105,1382103519,1830734687,12206999,3299586181,3822228039,360851921,344433925,3580049263,1691158401,3500678015,3433421699,2632917009,388156987,3994145023,3551580441,4252003975,3764987059,384374917,558436649,1141239159,3777594409,1822708961,2562783525,2770697249,1073279201,4035880507,625223813,2646640773,3410191953,3052599741,1659536963,320146711,3406736495,811291957,3157746949,3637103985,2832164493,3361098549,2573479161,2143625153,1722301205,2931774975,2477224863,3600308505,2885822469,3247569441,1455239541,2667210357,1230839427,2155778491,4119990153,1211804409,61810721,3765686799,3554970509,1099334735,3864576457,3441109737,2996752855,3638761347,622676569,2784783805,1602824723,640268299,2096246629,397727,2389647201,561357819,2992703115,4294257871,961646327,427907373,2063984661,3234347889,2578914365,3298785607,3251882703,933789977,397667969,636462325,2553751021,1285257811,1937524757,3831551891,2448009901,2210713687,3997861115,1583429275,1078488107,1387650475,569143711,706203845,2173406399,4039496623,1271743309,2432556225,178818795,3225365865,1941892287,4222184603,807007959,4171036561,155324865,3499875403,2828823697,3046914999,605358637,3780076673,592447069,1523717997,2533385557,2600287883,1746249937,1711188063,836791023,2223819811,934187895,2790508501,3328509927,317355545,3740249767,1236535791,3405287771,2232391453,3263854287,276739447,4005290427,1893824533,3801294397,716448935,2563942269,770871187,2410698011,2175003381,815202039,155018419,2644404775,189511919,2556074585,1682692313,2945057701,2381701457,161224525,3871213261,3316724921,4110222521,255970557,2834907011,2209958341,4187662775,419229453,2243071217,2370021487,1424464259,823121063,106068673,284776907,1651927239,1272534263,2841218221,908282461,1189575957,130372535,737892611,2190552105,149601373,1794425827,3949520021,863480983,4125378955,1587086449,2415069409,2630645569,866770553,3578607123,3222915185,3702986467,2017477615,3274473275,2656411709,126588839,1569823349,36956407,2651058919,356560483,1232679457,3016391643,2995389625,2201791207,66627751,3121131423,2420281545,36702147,2672678393,2937807305,783380117,2194887115,4288637739,993368271,1002675725,2814232519,2626122111,2150423239,13615669,1205299107,2396349651,1540285325,1807593143,1914300745,52638667,4229797805,4208042447,3637960531,48263939,3718188307,4111732149,4153451883,962385005,4252933931,2214888375,1147398333,4215616771,2090605179,3968795339,2701203559,1323935339,3450676459,575892337,2461211383,749722373,3444866515,1712411291,4215714843,3738901283,47401673,2110985527,2903920655,2481103669,71924243,1944959293,4229746917,3352767831,4293022437,1672543559,4173640983,978172479,3305037221,948576851,4107523529,2138652247,4042015943,664281609,1961022163,3615463485,4192500983,130612723,479765033,1757315599,3008175655,2348232717,292826859,3803484389,3163906127,4075193575,4229961707,2667776067,2148792809,2675749717,3017942245,3286553675,3828231691,2479983323,2717105491,2299734235,1222625745,1547378525,763921311,1568249017,3641929541,2330905599,1133730625,2135714997,1920295427,2021011279,2535222007,3400731975,2972539373,409695009,911460787,3068093511,70324419,826521089,1415730833,69318277,1096161671,2074497337,3827234367,2897828031,3161587157,3754970431,3833599881,2508839479,2371215161,11706707,3481113125,1023829813,1868704133,2509526409,1031545789,2702093945,3403750959,2172995933,1435761855,1723256099,1800809257,3861645681,1428197739,3442177307,3759532669,3201722655,4002420159,897870491,2289255221,1195496501,852707781,3448799289,3386034499,765195999,1517093763,2869034363,262746009,745811837,2144997373,3310366275,319674255,4056103091,1203776875,2582000191,3622655661,517351489,2112689373,1475689319,2769245683,2446613203,211246871,2783192859,633599065,1675580435,3674808387,874889395,2593031209,42414251,4186729853,1919478575,1177081597,591061421,4004935825,228996013,445311873,2523640169,2018308939,66666567,3773511935,1928045147,3421536499,446856133,2708214225,3188081863,2374895597,1739252443,68423343,3234875109,2849966317,1908643937,3762914373,4203446961,3711038621,4206043779,111118513,3553059201,3335719531,1230085741,2373479771,3713268625,3031015361,3963082293,1171319905,2538551739,3528962877,2075727699,3031092031,956707689,3323564387,3097010645,749291335,495378143,2173850435,2912475087,226554297,2357064001,2691329051,2866803849,1429202857,3155326357,1608919887,2474591,2935762097,769307613,1901513557,4181701945,3314774699,1397612425,495912895,2571492711,3117098355,3355984373,2518869009,3433801405,424701163,4011788013,3724570085,3996092645,1925525043,4015821511,2796094267,2719198621,3119231793,557971193,1908254755,1516899793,3903947867,3731434331,3399358229,1358826821,1461295155,1364699799,1384188639,2515608175,168571895,2804409325,736457725,3844226867,727966833,2871725725,2546794203,326134623,966358423,2314693553,3535780319,692358455,1402170545,4089791737,473167389,2539862535,4084674779,371800163,3962910871,2585197645,1527690217,575010393,523280457,2976606787,51245403,2288046227,2350770813,933391,2802617461,685370535,4215283337,781547235,1454410399,1616722645,2294409477,1923731213,3931691759,1871592129,3803434947,2332934433,872605311,2859137067,1422616603,4129305023,3148001915,3061074719,2364571507,20963573,147470109,334010131,186035265,4253492923,3019932331,2374190725,2777370621,1563492761,1012946241,3632103171,387862181,3334307875,3274187113,2141854269,2023824875,2578689745,3818564561,3213286585,788896145,413489243,256642215,1238561135,3085506027,664704839,484314185,905501971,1702520761,1194334305,2794516079,1964396669,201243711,2163807205,1619632943,3963147729,2271102757,1049711927,3077697437,2569718823,3368133797,555808065,4207268105,3508496419,1693351613,1707286453,3981908457,4050045791,2477950831,2916750799,3368969177,1711137843,4287710777,2593787113,4156958191,4058328739,4250504459,37458117,2493364301,4272903449,2835128469,1637035653,97751413,2230508789,1686691497,1439866485,1990295805,1696325769,154318817,3771095843,4270459843,420148073,502448381,744256269,1770369761,3366144395,1479667003,902703967,1921107767,2789107777,1261378129,23667725,2646479833,705273373,3714832671,3548132719,2140715143,58403369,2332896557,236023379,2590135297,2910428795,194263005,803198401,273337371,2661173917,2855607403,2229095871,3709582435,1206762147,1215859167,3785619017,3548309503,816956537,3873062541,37835529,246593197,4143407369,3942929967,1773593049,1705370989,1853476067,4269458787,775269057,3311255103,2373304569,768648611,3710568825,605149701,268489321,2784376153,3341352147,1408182385,2051571561,765806301,3184504889,2386235695,3353718593,3092610195,4100339477,1655374515,3376327173,822925089,1107300949,313781747,3804968897,2344228319,1710386377,247756303,2216893441,486804243,4101201131,3252291411,3507978039,1570873541,507664175,2506760147,1783620589,2734511303,2781440527,1246926199,1943215973,699571441,2371742015,276607297,1784245377,350421337,1131267691,3690856199,7526157,1938085979,379108163,2234415345,2919668779,871851509,3074888735,2608504543,2404701149,169991509,894058059,2638220007,3616298493,1046611263,2504445117,1529617025,2894101391,657490793,3791894589,1647665757,2664250287,3020550465,4173234275,2732565711,146646841,3677214031,2651842457,640581767,3069736011,1906018155,2581069239,861047279,1876821473,1498706381,3069950257,1211883383,1389126739,3905876289,1782684533,4182087287,1201283105,3618880741,1496780459,765750261,2242640609,3722727419,3091176241,1474711069,3507667109,640040325,2559654905,1727588437,1599970025,4200966541,677325327,2143458595,3217928193,1490990509,2238308373,3925280965,1499559721,232166461,2191423881,1916638723,692329267,911607829,1244461111,3462154897,220471573,3203936789,2560664651,1518520283,1074752239,3023426409,969617555,1256350255,1419535287,3881234539,4240619801,1409735577,2386265741,3858701715,3488568705,1775711347,2947867123,2355016777,2643373635,39011115,2824797923,4105208085,1877690585,3220969883,1073066811,466241777,2105218589,468274157,1903690897,2121549679,66996971,736677375,3240917123,1318880559,99367585,3623707829,1021269889,1793734405,918725055,604594261,3818111123,4182288707,291581751,56823409,1548312601,3578034761,2193161639,1058366371,2504049749,3474601637,3254400641,303101003,387363543,3543633597,3833382981,3158368473,1198155971,2600747131,874896485,2712192839,1337170657,2558366797,1553193751,4011144225,1494359757,3030684687,2700411669,899541991,317384663,4229635993,1488468163,2794912091,30235765,1366378469,3827791565,3672720229,138956241,3270318651,1549122845,15936493,1556682429,2515813255,3615351455,2309612773,4042456739,3777772687,524060013,3193702597,2353291467,3710859523,1195943693,4073696431,542298969,498190921,2203570047,4193787867,284435641,211236871,2615122859,1969588517,1561287167,2598233529,1578460611,3469498139,3379255635,2796945689,4144146293,3477123753,2693931313,3653348343,973182583,1044233735,1200037667,4161640745,1153635231,1664979107,1591947745,2514492695,2895536005,3294211821,3689672693,1591177285,2450273357,1597913033,3988840349,295270403,1922455457,3964897137,1608631955,3753136055,3068013507,3020664485,1794601121,2600718985,401846663,2148295679,2910420395,53084205,3128020383,2238915327,1241454961,182432081,3824321551,1186769753,211142141,1022995749,735492367,504356843,2755006045,3639185801,3461507653,2227143547,961644025,389217659,346022857,220458329,2981344881,2374979969,3157292647,296617565,3089370721,1194107487,3277353247,3815460879,2589310739,1936984371,3339218977,4210699841,1056141255,3761230783,1677153595,50137449,846532525,2740486753,131613621,121988543,1562059769,2698453461,2347678487,3862785131,3399064713,720670703,504753047,824072085,3204993545,3141693567,115884939,2058002397,1474684603,3062853047,2188159145,2880795593,365243095,1132451345,2109692507,2646969985,353323449,2662423841,2388243601,2740856383,2049017737,793359273,2410837541,225116797,3966805265,3613768193,1469532103,2364131427,1214473601,1973247725,2932053907,2870267693,3811454143,3967575491,3674054693,1092456219,4221474983,1765326501,208452161,3057142123,693939945,2212469211,3438181925,1033656805,3822201505,4209862277,4159072283,935167337,2072121019,2543163387,3727519521,2027655969,2543377193,3025989669,1100655435,291777593,3348339903,2887280539,1983548167,4252890841,1490674745,1226230119,1996550227,3735181267,1949602171,658218877,3143900495,2847985483,2976505251,2639697145,2672753095,4193323819,1075115493,538701799,170096847,2664473825,2482586337,3516288849,3811703803,3868643817,3081752553,2004576731,1197680587,3200902831,3108540073,1250859501,3625713277,367096073,2210681533,3457448837,2730099739,1650728377,2598097099,3580448895,4112806131,729030887,3575412127,1064224941,2184787977,2056149839,403513355,95617065,718260305,2942866801,4213950803,4155452061,219638299,2084002553,372642507,940317303,2728253701,689138769,3123482765,3284580893,736455675,3809772517,1474291073,743761631,2046923483,4249937941,3400891973,1366658465,4238717043,3789820223,1143534747,3704836279,3042496841,3658788423,2210293969,1238627983,4209020363,2893925567,1997384119,570534935,2613669143,3306787469,300223929,3571988353,3650397439,2916946583,2364543571,3846410515,3068800417,3361358973,2655458035,1278059097,1207822791,1862233699,1135124521,4088088599,1913298081,380733995,3789970005,3660920821,3689768803,3206498055,2658189373,4233983923,1549683675,851871715,2281939909,2801099243,938484373,1986970249,1638280899,3846731759,4172981031,2771261097,1959937949,2572947963,1805714955,412366087,2854595793,2406835777,1686945953,1421541183,3234590259,2357459661,751252083,3384898721,3151011623,2105629547,3080277969,2991047207,2233215879,4235080187,2794723547,1156344051,4242443907,2002714061,4251524249,4292166765,176166137,1591815799,296876273,3142508783,932318369,1434156077,504749017,756339875,2996072985,802120845,3637690149,4093888253,603835097,3943743657,2564378997,3815991389,2915657721,2177476407,3724644375,949717381,1801574769,3842703983,902659209,1168860061,4145626571,2586352335,3754695871,3514037255,328901797,229611607,2201665643,2251240897,2238879839,645008145,154459765,1845041585,4245040515,2694231777,113312203,1767701385,1468421903,884869203,2819939799,4059096603,4271092825,2468741959,2762061679,1964142207,219468171,3519628551,4107500495,1751519809,87613593,3642859809,786050699,4129685849,958609909,934437575,2691912967,4090745473,3617706459,3235459355,4079454251,2824699241,2446659711,992906827,1837121005,4267838569,3609036189,3543119461,3782233817,2487827925,1417345191,1432029419,3416713657,993729225,2774262309,861700505,4265656267,1290824827,1013082201,1622215597,125173273,3548209351,3428669167,66522977,1360194805,2978165773,483319341,1365028039,2605951025,2437397063,4229371769,1342622689,3996355447,2047470963,566532419,4062859435,3088500839,3753869889,2516659663,661061535,3675813267,584038379,1932785869,1494472567,631715063,75929879,548206841,1007547863,3095877299,3175981583,868952455,1595128391,137035195,1048069587,1244692821,3061537573,1553824097,1720467565,2178558553,437435727,3293240461,248927055,418885835,762850785,755787711,2305787225,4170980913,3515016223,3897515091,2989950449,979873349,1826788253,2403967465,723866403,2675275419,3636350347,3050672509,3628287091,675515031,1782584781,2505555423,3010660791,1166240529,3068825187,3777668363,3065653839,2016430055,2848001531,3246223987,317030633,2574421077,794538189,750042283,231659297,2257453121,3568513551,1083975047,3412337881,464505991,2996634345,1646963777,3750974309,1095286837,256064181,113478285,264074265,1594973959,1836463865,1813221177,2015387715,2509262327,888086909,1065349719,3909062647,3796195911,925540613,3484527923,2581764977,3964381257,1528171383,72032767,3768922161,2097124821,1875268789,1172550157,1740560633,580336203,4134823247,1403512215,869435663,1126470659,376550667,2200253013,4278972251,1754268627,3337324779,2439685113,4029922473,3567761431,1327996089,2980225005,733093213,3131448505,4020786959,351032923,2820259005,834057257,3522054883,1937189479,2491501839,3035275673,2551702079,1208427969,3443525757,653128055,3481801021,3995363297,2552275089,2249072451,153546269,3671783489,1575036237,1750619143,2129989307,177904065,736400637,2884748851,2383140891,2878955293,3795059347,3298145935,1090849987,2995337523,1326112893,1394120891,1943243073,1155041141,3819272007,2218429625,535644967,333528951,688777593,1348165027,2657149745,3940825303,760243553,4180679721,3314125107,3364821563,721666049,53664093,4284263411,488481573,2227315383,3849691677,2380715329,767240405,1517687053,4250524805,379413339,3068541083,3297699729,2181400333,954591953,2124127787,447585187,2076522921,3511486303,404724473,3271008115,252042411,1239066599,2990904887,4136210933,3251514347,3332765273,3117479063,1164609141,1419890835,1266995187,4235248357,1326189443,2680696741,263228733,269019517,3105445737,783961877,3382592847,3050892951,3038288491,1648526677,4248830845,1973798677,3601969583,738789357,82292951,118175595,1902352143,1095947671,2772766631,1493644123,3887925931,738728207,3349512195,1115155713,3479781475,117624733,1233949097,2880394653,2216579103,3793660065,1255249831,104578295,1005797625,3744398291,2241301955,2698806111,3979699743,1287927945,3864793955,2801631329,1291319187,731856133,3814681415,2373761173,4147824745,876357107,1491063029,3457152013,2036346065,2568932669,3040145401,2792841989,3892737097,4290583877,3637338579,2480018557,3309283329,3593437303,3365647393,1716488977,4029906741,3303353707,2718528111,439904811,1841462309,4217690899,2590736123,123609495,3035596269,3644991757,2257962383,3537745397,3654653343,1431481113,2791269303,3230407259,773255365,3826872011,1102678033,4220811121,3492699749,2486691151,3786421043,4143058603,2376187099,1970690087,2895504981,2772791453,1910827477,1806965507,4250524375,372186329,1863268245,1342869967,3857389499,2908990863,1796743645,4250381501,2265870305,3302204337,580935697,1325617023,1649968389,2709880665,1131167885,2013416757,3743109573,2056654999,303802887,3593993343,4121077085,2300001357,1417177905,2915420911,2492378031,581565441,3319789843,4082759047,2533830791,1493401133,4098960295,4245266405,2195797713,2413189149,1093886807,2495563735,2584085041,8023965,1714810447,1588656795,3038070867,2285887403,427154197,2290257511,861115355,3020974805,2715182067,37518125,3501918757,2811736023,3617186779,3091132183,734228263,733397385,3948700015,4261509317,312512881,3953974505,2715549573,1919224173,1196314477,1715528531,772592701,1279412751,2483849099,3264693313,1493347547,3198340393,2991317547,2481852965,4075407527,3530885677,32488947,580902697,770986023,45779369,614725963,2302934877,3476208311,192999501,1042323143,3448456275,1915965495,2262288153,3226517789,4122409779,3223752945,603349611,79147749,3091340403,4233781803,2447620129,4249750271,246722283,2017988477,3270596321,1920955241,225603295,3553442563,1188950077,2496109257,3162738707,1634234811,268640153,1024442283,3572552835,252744531,154695557,1513030435,3296157371,2028793191,181830877,2309820511,3238942011,2482911527,391822591,1177442041,2354076435,4018914817,3245680681,4070588573,4143104385,3145645173,2106017571,1011862749,2601722303,84743113,2643342683,3813768145,4204301459,892717331,1579440981,2766707553,2737935233,197889921,1631233497,1365163283,584029639,1785892689,2266990357,652081831,3077783429,4014986367,1644730941,583438009,432301867,2907801321,3278947721,549014339,1694264867,4171444549,2717411887,3154364513,2623076955,2510093875,1979012263,1032396311,4111915317,2936989165,4212770313,1494825807,2273652449,952712431,599772591,89714725,301879687,1335542001,955349169,1965755217,1559523477,3020666757,1832786625,139390613,1980874267,2262326481,3870696485,3221205277,734366475,3056326469,4165112343,3666207995,2356989047,1431577173,110782429,2199462707,3881201191,3680139965,288407667,2544568443,1572491949,1938443667,2095803085,1135688307,678738019,116769275,4036135667,618730639,890047705,3955677033,1265166611,3567142583,3811919635,3201164947,3218956391,1592045119,4151057513,3669881355,3965608451,678784471,897488039,156351751,3578879229,3501233433,4178397437,3610483565,2099364129,856612699,359279411,3980029413,2533724341,3999263277,3674729539,3844658353,3684984741,110179313,652826683,2711609111,116388749,1935602479,1588596603,2026423923,3311216541,1725193035,4290121551,161992791,3898558041,3338941923,3849220557,3052536077,589536115,4138921647,1565844311,1880741445,2957166375,4028722557,580642395,691057603,1013587451,1524017759,3276518197,2665677411,1236419769,1455306017,3784472489,1458482583,1338442429,2458202331,1716192937,3349329755,2343853927,4007914621,3048980151,954629949,2762726559,253878485,2033191259,1085715755,2603646179,2354555987,3488810693,1547836369,4163938125,1110995245,2274272503,2784025421,1741566717,309720815,4272361477,2316139653,2070579255,2400539603,3241331885,3994818199,1980747591,133282949,2408580475,945314181,811436367,1289878525,2288453663,608613077,2642874931,247227575,1920496533,1106032527,470249663,746281887,1455193135,1887264715,924615621,823089261,3866539753,2078487257,2166343103,1290797689,556973835,2325528025,947157581,1728689109,2919095153,4115821209,4158806599,764783643,3176561059,2018270999,3723976281,2605963405,2645467723,874609779,2188492391,4186693821,1313888751,2101396409,653404307,3829801091,3087085359,1438733999,136472779,185478463,3485256297,1938644913,1183177313,4257512471,1856998863,3347549043,2480198401,2036954143,4198965027,1397617881,587611887,1863192709,73336415,4204497627,4189712907,516059625,1875167595,3766749893,4242522191,3318433249,2757320159,3877794153,2252627121,4062310137,2446383941,653007731,1459515553,1519700043,3723109383,920910601,2977327531,3574855223,294274001,2355796219,2858553447,203649851,3949096539,2335953597,76087131,3191141205,2253649063,4058220155,2425533171,2401434449,1101139431,4131331071,2840052299,2787467877,3764349887,2560326995,138503185,4245741047,1583171219,1036308209,1139708299,3818234153,1955086623,2641090467,320512185,959323425,41599105,3371472913,841755855,4063372649,3124153949,1680268499,862721449,4244792899,2827516959,2559405903,1837579117,3377392365,1545737857,3253985293,1912281755,479212089,1053920379,794706203,3573853581,639546083,2842864199,2802430943,1845529803,3860585853,795537719,369273817,157319295,2660522061,489798199,2881012095,4003992209,1549511077,2245984423,4087634495,2871106741,733464703,785146347,1815143667,4261906087,2686058977,192016011,1692675889,3235295067,1318265835,2652603199,541470679,3756990067,3417883781,3480134117,1749511533,694257213,3249825193,712957759,4017289353,1696310997,4201013107,1459960089,401082007,2181624169,421636311,4040427977,4040108105,2958986695,263102445,2441464395,3869543989,1031074181,3365712877,2817078565,3214976999,3429880479,3245174585,4154567689,2535867271,1360782141,4259587337,2369533373,1810666849,2034469959,1101990185,1250084373,3483038863,3324937321,402108619,2256022877,1005239113,2947421695,3458642969,1325039793,538398367,3660249811,1002038321,691318079,1096440289,2462262769,1240497699,1273598823,3553408965,624268491,3770413095,1385448795,2220213597,454091313,4050800253,2273291783,3480933557,2300797731,1916933841,1357410199,3421932965,2815292901,3268093209,2800824797,620837745,1944439895,4090159319,2356150769,227540709,1755821309,3663447389,3204124239,1416169507,3147144901,1542142303,2953051331,3586654753,1040479187,2521858841,2144300301,184611759,1803464051,1236128205,849957163,168835503,2939901687,1623920039,3001926203,392908009,2240193191,1243678739,3197730575,1332041009,2243718741,368055473,1155448157,2070055331,2184883523,3661991461,209178813,2385080405,1116628739,2467125693,1367282781,1846694173,1955315973,2200808623,732207639,1132508169,3064733475,3727741483,1463204009,3382037919,2314152643,3034640537,466905915,382484073,3138759893,2349233549,4228908401,2144731301,3133461465,3492867327,1008207303,1294183497,1627674069,1671399003,2116957467,195101179,2005486937,3610610947,4240273403,4177758979,1469854547,3488480441,292258299,2837631057,748359229,2009341777,3974397417,2366048037,3362166813,3347923033,175913743,1644797135,1695960567,2606303391,4064645131,3035922453,537231657,1231224017,29648033,78301333,1750528573,607779317,1514772493,2510155119,3008340171,818285835,444770263,2010735487,1628677623,1358261905,556686531,1791776991,2380206309,802075853,2881509605,3775708191,185814093,536255119,1998419027,784364515,1559795125,3291287399,1783552373,1588004991,673135627,446647399,3494989181,2310469129,1255362855,2004172663,2996444299,2747827949,3256010561,1591222679,3213210315,3801993549,3877162011,218151115,2858704829,2747927125,627894299,284858741,3027311277,1838084621,3283463505,3431352029,2207711671,787618437,413887357,2652776919,3461182719,1060945103,2895125533,690376211,2446333989,4108431761,223438295,1526025915,2667857737,3521420499,4159999473,3633547785,3192653209,1896096527,3331991909,3004452197,4192583521,1517828889,2339395163,2083912071,3146878827,1365203879,1266326611,1588426113,3455965787,3574282153,3547588393,1582162649,1265141395,3143337271,1971814303,315366823,380570171,1036580037,1413354201,3074937193,3422938149,2529551213,2580977685,3617266495,135951701,17655105,376623255,3420239529,123517813,1494696895,107028465,3531099169,3620648991,1150987151,108371487,333466159,3928399743,2377254039,2722881491,592718473,1790237731,2279667253,3259275497,630427209,4200771465,1693650289,2432166691,2221855445,2278826885,2020112403,312714957,3055298543,4068629237,1277315291,1591577231,582231191,1624148211,2541845713,3056209073,2192037771,3644353365,118442627,2095391673,2811021411,196637483,2056344501,3675197589,3121240115,4247067989,2410248943,3217452093,2079112397,4083136495,287664739,2943079429,3492622305,1185089843,2041665829,1783893043,3018678387,2773990387,586474745,4226083585,1912689023,3029198071,3484660321,512010869,2547202207,2888490557,845484223,2301544215,1578188547,3191885785,1882903241,635766101,3737216135,1789890295,735277695,1191331833,3871576703,835160027,581473803,1779629977,88804829,2189126791,1964152739,396479495,2136616277,4183206505,2832110855,2459604683,3810686531,3951222489,3707056895,1709684307,1332967695,638661167,854982869,3031497659,3479130191,2056396427,252950577,3617710679,3306384895,2124097299,4230140665,1380555879,1589352971,1853799017,1107344849,1051609047,602854925,354894735,3301223879,1282247267,2878919277,3189738435,152130143,1345790277,1399432141,1015108649,1320988781,1172516387,1172988243,513537447,2434594889,82906291,1836646387,585901137,3175388517,3786194075,328407427,510669605,1479414629,956021443,379762453,346165493,2617741581,3032776231,3493253325,3200708395,4135621515,1935100609,1743602101,158681351,4077760783,132386329,223990017,2208882981,3293956431,3692300257,2802972493,2357426065,186604111,929185763,324054563,366528355,1258979695,2662860427,1136009915,1789036381,3563414273,1279755581,3950825615,1331762871,1864020669,1103958253,4262632191,2004787023,437090937,1793322225,2581150383,2224834487,807978251,3298865029,291760963,3068839493,4018109305,2592342379,1350150323,1664281265,2748219133,1240705461,470487463,448019193,780927175,3917963861,3075044319,928437537,633522063,381407821,2230061705,2762485297,493955345,4030688213,3552651729,782304921,1303937119,2348041851,1379909291,3607050337,231675955,2537424127,1757057169,2959709939,3828729765,2261178453,1755659065,936612481,590852463,492978719,501436913,924382769,1204512991,2068999921,1626476829,3024222793,1469541561,2523092033,1395721775,3079496697,2745110585,534946753,1483548135,1708380081,887677783,2779103625,625319931,4262095999,1582942667,1490002039,2804962259,1439684875,3232943829,455714415,1265504509,656259681,280464381,2185746755,990462509,3705141319,3874336827,4274891155,1882764859,2604947121,2744651711,1412586023,3049071429,2488739295,3849838899,560108189,3465008175,930874685,2939962853,2651937001,2229582775,3303043375,1797745481,3908369977,744425809,324861247,1039564461,32960841,4217057861,541201045,3520218723,1141619417,1578656027,2458887557,347884437,1443262331,3229704705,1850332169,2969572629,2087236129],"expected":[2555283159,973759307,1312704697,2010189883,4180305627,2689709283,356969761,3985456493,827440579,1612148481,1582773671,2249898729,827887797,3287587591,1755333939,3278967907,3853242729,3003928659,353069993,3127134837,4278681545,368949887,3053228059,3231253583,748632167,2980104759,4035479279,2526716935,872962719,3612636401,2018219845,1776381651,2352757169,1519013129,316880699,1272201609,2617400691,2348802267,1375184963,2415406525,3043994905,287759095,3686420137,4240933917,2158270049,4092905287,3096908043,3229019743,3743294559,2127092361,2760592849,1137716313,1376700373,2901616745,2655455081,3061485719,3366888499,1781995133,462189239,882177845,1903677021,638086221,3564924697,2251075919,1370654141,2042039351,1089948945,1061176795,1646072699,3888165143,411934231,3562544187,1124631233,1641060579,619721135,1097244525,2373937909,3246113245,365163727,3394772485,3965141383,4215528087,4135734277,3409271325,532956397,2262156959,2368939689,1125015663,2612459793,3510465741,3878254333,3930067893,458818865,28203529,2040120543,3760499931,2812848415,3873901163,3633281765,232596735,660392251,3738732787,1464854809,816975111,2228242165,997804261,2321364039,165366479,596316075,968884119,929809907,1864413437,223730927,509268291,2211244215,4194449615,3681410105,3164928361,358968521,1518801917,853309923,1713821391,4060352359,3310984819,3497337121,2639648479,1952704529,1619104787,2739662789,429185091,2199608003,1919054829,3488988957,34037159,1024997245,1075741487,478595991,1083074699,179198547,1552735355,4029359937,999382629,2610380837,3610244953,1986196931,27933095,317689845,1676811765,4090815623,3736445949,242348603,2683287579,4153105769,1431154783,1351191817,3576420457,1610876767,1385401333,3579554949,3234152759,1436784341,911965565,2408013081,3539814429,2780294695,1745693435,3075164601,2080259169,4176687417,3909012045,3012205309,874530057,2977749779,2782297627,2523590027,1085746697,25883017,643960249,386812739,3320120863,1832984785,4272900887,3138831317,2407642385,4241661519,1685004109,3117818893,4146092461,1936953911,3521715635,1587149169,3577549069,3956588171,178858679,1952793507,1401285581,2813075819,2294794435,1010744565,985642871,4140889165,452023717,466630167,145208203,4010953483,2411941939,1669792285,3955120147,2885868851,4028770339,703218553,1867209303,66117933,2849957087,815684665,1145565685,1291348573,2633217997,3580144779,3792559009,1982485267,3738664861,1144889665,3711280901,2253182275,2447792503,1731965833,810118173,1879009145,2876006345,2942281867,3084243669,4167490827,267774057,3652538069,3532389775,2893173445,1870994115,2854880341,1534544117,235277129,513344837,4247405349,3997436445,1851733749,761088387,920906199,218413517,1430183271,2177877507,2493015107,2311772307,4127244113,909060467,57500889,1359420327,1997247195,893939727,1446988183,1047794235,3157613501,761879913,109353795,1487436765,894994361,3679816023,81561811,3875961199,819203077,736829243,2131394481,2876576081,1943858001,2013100177,1834704457,146741385,2391308233,377102611,331590871,205164413,2418384951,3154171491,3205326435,3673865225,3519502433,4064614195,1225273497,3350176599,385911195,2898535755,3393800311,343658051,1757370709,3205413527,2385830653,232717997,3553071427,3416530169,4005838069,486846991,2132302071,3901308441,3269703891,3828920047,2425889615,468571535,49957447,3541332871,477810945,706659417,3175137619,2857937733,1688716753,3154330719,1298040411,4106233811,3338689945,1515835807,3956662413,2919099331,326396391,98765781,3523165145,208023527,1339752077,538782037,2503166023,3709110987,2831368977,719481543,2584735647,464485805,2173379929,3285454677,861566009,931232169,30262865,3793382857,3274775937,989534721,718148645,1016964357,1081434973,4116251245,1202548867,1728157493,1303840397,1903811799,1948089883,2371790427,1285888533,2937357241,375040285,2458042841,3700134639,123429957,1187874115,3211469747,4043495823,3138143903,3616485995,285093585,2794143829,4059637973,655735843,514977143,2809002961,2154511831,3056758935,3100153501,3456582895,2254017255,3441440975,2656599131,3703066661,1029535019,1575402363,769729071,2860026961,2056817011,1528863219,1193991423,1184496321,641432303,4271520087,3770272247,64896145,2021156859,573584499,3587357789,4281215411,3055986057,828904369,1853055787,689992315,1204024627,3899324823,2883071907,3309071549,1825349817,609958907,2824058803,3612971949,785692909,3645624845,4124050909,511621601,2683092403,2529087101,3773450763,1770289845,1450151537,518436129,3178832579,3024188871,1057129353,3782677237,3772152319,3526517441,3161458197,1916306213,1696199137,2038894763,2703351995,1528689535,1655920721,18646081,1292424621,3857687947,693539433,3385771787,338462619,824155743,127784213,2604130901,256589129,221864105,1281085679,446657353,3055267597,3788774171,7813401,1434283215,2912703051,1391187355,3842551031,172028759,575875015,878784455,356594791,1142091205,1350831803,353602761,2045988691,1866603775,3300683109,2210571115,1231179687,147635461,3719734831,1416602983,1138213521,761906895,1194076991,3422439533,1864557189,2982075117,875196361,3784179235,850894039,2031369645,884126123,3673255739,989857163,3105045123,3196304147,349405025,3149491835,3352882363,1124522411,3111014757,2706411155,75487681,3678198965,3567234641,1697932201,3267780501,4107575593,3238700955,4261885325,1290218211,1910877027,417017907,2561252507,3709180369,3721181657,305013939,590041275,681775905,3101715695,336802697,4011859891,1353369897,3539035249,209642041,2065713233,3808382507,1815774865,4285762535,2733387261,3727618285,2631592759,1442226825,2019097339,1231199741,1729447127,537272189,1299567383,1662131641,3062528301,2085940641,1612541063,621580939,3985933403,2779879505,4293321243,335637251,929991181,1147272043,3764862647,1653890203,2746648603,2733883819,1503819155,2699553385,3782553915,4020822107,3144118943,1257080617,2783581189,2551880797,253646743,202893887,4105181195,783442029,1465716367,1709751053,300461809,3757840199,1002762365,2532303577,2174398217,395063733,3284244299,3763780257,2863309415,4096065083,1445222573,174409319,474353413,3591586323,28705349,2087002327,2810372637,3005038129,1203570281,2316744657,516605415,241161753,2802105673,646185273,1746485351,3921398329,2245844227,2756363465,1468762075,1568042025,1042127351,2759928731,2036159281,3863559669,1912767361,3337836601,4106237393,4221435725,3262934763,2476153095,2811570245,1320435757,1975014249,2303306137,2006563033,389588437,4216639759,3234330511,500012071,2335358991,4055647187,3688593719,1695864125,3297560021,930899611,2538833269,2395834727,2631559647,1002865993,2445353341,2281818453,942407531,17339743,1489697163,3980761501,2329221821,2509862843,1728686997,3224155395,34198447,692123739,2430007567,4141394677,3283843633,4067516215,2596230433,3485516441,780719309,3639154767,1636312547,923692275,1154214063,2863834955,3174875791,3026461767,1329200201,2202307531,1530089001,1187882693,3484572399,3420678833,1106702391,3886767187,2123772713,3874478169,404591601,578398293,2594203873,1218590719,2870659283,686842129,2369479839,1990139865,1274422509,3081632293,1500353247,3974627099,1240818419,1308459191,4171894031,1750988657,1286023699,3190415935,3147358337,2848168445,318818119,780116183,504639637,3530130851,3898015815,544440085,586214367,1520277929,851894957,3122071909,2085272709,716046973,1510083675,3376474081,4027600745,1347065987,3687074479,2023791573,1723824389,3999394979,495881315,2299902145,190685613,4180121637,2465945753,888601907,4037292437,3660632805,2048281911,1549944707,856394827,1626730467,2584059677,212166489,1280647211,1509945125,3328389965,3410841107,33945837,3354155727,777235805,3953973297,2744858035,3269216811,185665433,1363933397,3338784247,1362963411,3626792145,2291001243,3138902429,2078956697,4282618045,1430111165,2120097175,3030866453,3158884621,350438997,1054959535,289042379,1978154777,306145389,2786904749,1472371399,3229542759,1523882027,571771567,3467170875,2259392017,2391411139,920075383,600392131,1314196765,3234278311,2822774163,3071419585,1147044975,2337532669,4220749707,3613950633,2467034379,319338429,912814895,1193937129,2616026255,3382393089,2973229845,906314607,1733021455,1135554933,4259535131,2545575925,1848471585,1632710011,1181592567,1094186101,1726744873,4259290355,138262823,412227451,3685526663,2826582469,2627251933,3539186263,101903449,2664689399,616263285,3503884937,186552869,2466657241,814732889,2809392555,2626838229,2742822895,2448896809,28882305,3208987533,214594473,3902312191,2403213217,1423781511,205308111,2720186961,777736591,2512401967,3477528693,3736956061,420010513,1519144249,3645714133,576043003,1627952353,1432787825,859576237,1827970967,2687375145,577773793,1389842069,1926851465,3390870339,2874182471,1442177127,1898693797,3966253361,2541933853,1896478389,2734860639,3776881,2696942857,3888157537,2952142005,2196214283,4001112955,1199289351,3139114209,3202902373,3355393253,3407985353,3675532401,3703289865,3692574889,219310507,1783060913,3610675937,2319102819,2181192905,260734041,1076280695,397953457,2767196361,1688241089,3039126579,856873827,1093149829,1158119365,38390763,1456765907,1736530255,4054287741,874970395,766066893,1525040553,1580970195,3778583607,985710587,2881692827,1562307291,9946157,747295809,3060883985,1200641323,1630585719,1728958423,3827072455,930507009,1289274911,1510114283,1531992123,568739917,3966299309,3940836581,1041537713,2469830549,1822384601,619249305,1888096965,1896856657,4245863397,613705565,3108001683,2413018867,441206879,4172252785,1220040517,1108205765,1455501637,958584813,2163998127,1956056871,1380009451,2475001301,2352882193,2275238989,2896235475,2620625427,1342272919,3966300813,3907258993,4045052415,1100620633,2502150451,856033985,1621985941,4091439011,1267082823,2818263693,3764662795,1073772693,2309256849,2143104409,1578340813,537403791,438654049,1686929607,2986404577,3543265803,2819946447,1005031717,3111563965,3613911263,473040083,624432201,3793632831,3633183417,1057340199,702858919,3120870335,2590312787,1703219973,3852782321,1929076245,2534412285,3875240307,4184133251,3270582483,439298761,4054538495,2310010577,1054612179,1429686723,1345919951,3151544059,1347642761,2167854065,2467702807,2046693487,1322055037,1951818859,1969911511,2452199119,1222998611,3274248393,2694460419,2263110507,3516986771,2433160681,1908488957,1207471417,3081959189,426678657,3064658665,1480938995,1417280703,449365485,805789159,1316460675,517504339,2747883485,483691741,1301963079,774341003,1824308965,2917336269,545072525,4110308997,952730251,3257630331,3809463095,2993431769,3547548137,1074823845,3754372787,1994295395,3328189311,1233489173,1641024845,3493867067,3927399351,2119937797,1294144081,216657443,894294581,16393073,3166195203,2109998095,3590620239,4240784405,892238533,2673258529,1879823329,1529531585,2571232679,282200303,3405543029,403434731,1862937531,484450595,3489226585,3099928237,606330113,329913123,3633630795,3894731825,2533242459,2200553165,2315248699,1794015795,4289870951,1419701695,2261575677,2347072573,3062363627,546809387,1639409483,1769624979,2987997243,3317551267,2718212439,1723525131,407839439,321364953,2473632445,2473583823,309825045,4201639497,1152261897,2877115727,3726489431,3810933131,837156079,4019278861,3016526795,4184929125,2193911059,2648375381,2198983467,1330384891,1789938393,3901098061,795948687,3055825595,2349943373,4085675327,1254563065,1299026135,2954235111,3019503793,2894180039,337360897,976723459,2331358201,2834871081,3639545181,2936897213,2081791665,2557362105,1250150623,3861300023,340138281,3710167403,9281105,1314535405,3189825255,1971122997,651864397,2317762889,592806361,3478570389,153792605,3943046419,382397713,4288447389,2185084683,1075174855,3579569171,844773491,3055578085,169402869,3280110895,2869307409,2522056697,353876087,2444322319,3690103833,304165515,3352049351,363197377,2221161487,3510160377,2636233385,3727107323,2895027967,886166343,3787931329,1342044383,3412117675,692229065,2634725427,2937709735,234904299,1986603319,274575573,2584979667,908349585,718803611,1113073265,1848431391,3146645089,2667489523,3958885743,1295175153,2228668849,3333158517,704621717,2955997037,2590570263,826089781,953989629,1750192145,2760934667,3553281061,1270253745,2264242409,1680031829,2001879215,3253124223,3826386133,1991764927,4096339875,3282638737,2939263743,3529279445,2993540649,2366067093,1815633105,3348028235,2564369953,4249375611,1450812747,1316762365,3605659983,3072967973,3023330023,968103625,2534251867,2697691919,2803100083,1131273969,2407816793,3349427085,3061360227,4222466923,1273925033,1959634713,3503786159,994951081,2062056645,3294478977,490589911,673717005,3384454819,869781583,2842717957,1376647941,3894931599,2228424799,3500518155,3790053827,349765121,3674348503,1495058715,586300799,3173219969,462595335,333733831,3825866083,1242020685,2869962053,4029525389,692612125,1344383775,3646142745,1971134443,2163430209,3185273489,3484802615,4210081985,701924825,2089336377,1778926441,193379513,3223239091,2394968613,2658281607,2773165945,2705182457,421668369,239541297,4202462793,4252562021,3136282395,291798949,1649712079,1841876479,3365539139,2093219621,906077053,3615582005,450951403,1954232731,1658165893,2162818853,1535507991,1027135285,1594122593,2329191443,4173727761,3625648313,3125464763,1069318981,278129397,839868619,2280999963,2959286327,3944718591,3254610051,3385672383,1225342503,1625981473,935005751,2103833999,608798041,3635098285,202949921,3893439831,2520089297,3181787059,2718893219,1083793717,1587490183,1448888865,884972363,1992765039,4260125145,1639536133,944060925,794258877,1925787641,140533469,1161021299,1153373863,2360173957,2731617319,1472865671,3134849045,1285094231,2722243981,3407208549,3418698439,632817441,3769135381,1078934877,4208783279,2649489501,1636736545,1325442641,1709507305,4294821059,82408949,1099601589,1633746267,2365706067,131701799,211167401,1476608679,3601207483,3134333771,71074605,358514187,2141508073,1053591175,1249210313,616082849,3517353077,2978541653,2207299245,2379780281,2584048873,2908911863,2426178021,1902106965,1898830925,3475928773,1626721201,819444333,288067153,2697824065,1253731569,3084333757,1171314765,742207245,3925956355,4199949949,1940120461,3679003631,3094648401,1628687975,419402267,3407227855,2095805709,1635867941,3824044943,2211589117,1555419745,173525349,797854471,3843438851,2265525075,2748989725,1254995555,2395287585,3629694367,628361739,3496341109,1761833239,3189969509,4158503729,2734897111,2363547399,162848381,3134682591,1432399813,3371850923,3429977661,1934264297,826633763,1015462657,1013822747,4114279569,1931134851,2324166655,2583090783,1125681067,814449999,1068195163,4172622587,2423481495,3181601255,3099628873,1538271681,3541823205,3406645013,2480067285,3819495379,3754433781,1240163385,3474002713,3248924595,1862529343,109630867,1388311569,3746593087,3377072439,3687544633,2732622163,193386099,71587265,3589464439,512492533,2407498853,2114388595,3833821003,1548474389,3521223465,2036936695,860128773,3221180147,1048370249,293226183,1516905819,2051660271,1795189531,2585277309,3958544239,2865462519,1888622165,110005767,1495038545,3109327529,2155355169,1335674175,4074206477,863427207,1382286903,2084582201,470801099,1676746013,3837585577,4060712791,4002618197,3553103675,329393903,795660201,977493451,2289772789,1235001353,172470393,3678628351,756460401,153059917,3034209451,3090956363,1368985079,799594755,2521930963,1224124395,654959643,746398579,1786852093,3034745147,3359158461,1256666885,609300557,4189947403,578935039,4071162267,1201724819,3872921857,3810818213,1305335591,3654052745,3471386263,1119434255,3339819753,657747057,2564839329,1124928477,455945673,128601461,1294430529,243743949,64360553,590631679,135163375,3946735743,3499255791,1485584037,4262291085,117329725,3914149807,1300696205,194301693,2359940829,2761476523,2888886845,2375900445,3466047459,3639989837,1821937151,466090533,769441535,2306265169,3569755381,2120251213,138132077,3521758063,3451277769,755957869,3452029117,1789090845,3206299045,740826967,1054335389,3943837489,3168668225,4257482419,2897466843,1788002225,367141943,252017577,3385078815,1144594063,1446110807,3897000115,2309955719,2110232697,3979602727,1771706473,1839959073,1473849965,3693971653,40362197,3049328879,3136843173,2765857209,653199829,3267482379,945173735,1404354013,3143211163,3255982837,792472823,2581073983,833647323,1175124415,2033010023,2341388135,812483537,2870127267,1753064043,1116049751,2383009433,2095324295,1235375383,3731427225,2463086327,2438149603,3211205465,1811310041,2204845191,3274801455,934610931,3191671477,840525853,2960528471,3795598527,3243003181,3416147853,2639896083,870706527,612629865,3505997145,4145654821,2967592857,440119301,685702215,2837063247,65144911,3161174565,1798098817,2293545381,3608829305,2468219899,2982337243,1686237415,4095299001,1272547911,3327701483,2165839603,2906279445,2584554323,4054072629,735690001,206475765,3214794627,67475253,1260750229,723329649,2021568705,533473177,161735315,2157467371,2084378121,3404347245,1475922853,612116739,4091890087,1716877545,3276108513,3263540153,2304001875,2998927593,3252588917,3207907577,2909473451,1509376627,3160035417,3912040675,1840071377,1577143161,4219656567,3277219477,3461443159,2262612385,3877029129,1823062379,2866336675,1572744837,2620075279,868503423,3791640499,2229775209,777274181,3385168849,2675579435,1031339715,1913888469,4161745943,2317708301,1035119065,1475383723,211715349,2384526821,1023976729,2403032705,3484706465,2735042795,2854019311,1791460111,1740335853,2494349075,273743745,3428844841,2880100439,2913697563,2280697695,3591982161,1126656499,963902489,3343740557,1838943447,1318173663,3461271897,863847809,4189709989,701787391,3240829325,3984470727,907401647,2405798567,1130825039,1800692001,3244833257,3620609935,4123765373,1945458379,2720848129,3640572035,310530339,845460183,2920796237,2828482155,546928349,1894031057,3786817489,220163485,1008866233,3019342123,914711827,3574205715,2938474699,2005962155,3043039693,3863430487,410955721,67510495,3706450207,4083056115,3969134825,2224566665,4244093577,1265183293,174958231,3913361579,480734157,3321230901,3743292611,1715113935,2483475403,2327457419,4245275921,981344215,3593129641,2326849325,3962799361,1978499341,3398650503,3830447355,152197499,925094713,1676878807,1069864027,2514314035,908804501,3629039859,3273119985,4102001461,1101159689,284988027,325712685,557152331,3853248389,459360143,1934806077,2827067653,1425945267,2196296391,1320840999,1958097185,3080373513,186827179,3126387017,2457997805,1070260445,2400966237,4190637171,2391914107,3637738687,1362896971,3128504303,2568000893,313723355,3147764443,1565483825,3193197327,1851340075,2948711595,512201337,472756199,4117806771,757877873,2547570253,715989885,3456355631,2149959385,1692977067,1723076183,4199786693,1816798971,2882288791,3286763317,3794578179,1800315245,3996009175,1808830143,1287999079,3042091861,219201467,3517763281,4140320583,3899565175,316046885,1326456191,2040707351,519765037,1112145245,135858519,3517308419,2991622089,4165650443,2092791725,1940111213,409813387,2666099581,891107729,2809868319,877358269,2082681771,1312989947,3336365559,3476557977,3625761917,2246868145,3809587623,596888157,3275934901,897983411,1305888639,2693696007,1832048365,255080483,1409433225,810205843,1409919141,2739077441,2671449439,2339055045,674598613,1085234199,963905961,2206634223,118286725,794793225,1892379181,2950519173,1705254611,2848754019,3650275085,1264746175,655933643,2629034863,1402762861,740641101,3757213289,730173349,3845809611,84149233,1307190245,4184983525,1868385511,1386797405,530352343,1745147069,2490043613,115251823,4185415761,2164700747,2190939921,4160405483,1653589929,3281592929,302230781,1713650995,3809072935,4057194497,345742007,3189954877,3062221227,257983231,3749252043,3350898313,1911198935,961441753,1243433133,1049208427,536453819,1313745935,2515105449,2421528001,3849456411,3615264487,2924555833,3111827799,955114127,1399968785,275552049,3139994089,3927986651,321306491,2715406353,4198603757,3405682687,1686839889,767211045,1261135225,3254322631,2903406635,2644765981,2572397141,2668421781,4212064779,1147118743,2201249623,2299283569,1241787771,1471867483,3001071045,2630851351,3873159827,3923107901,2744913021,1913402299,3038280081,1979203571,1161841593,2456149849,1753153681,755745681,3071626597,2794077879,3876070795,1297506715,3424383017,383981063,2170480783,1195327915,4283060439,3439752593,2877893339,4100654597,1955261135,1196544581,678066899,3998059663,582856419,3911814371,1376604297,2472721033,2683829635,3551568061,2273299619,2661088357,3156092891,2187012935,3543320767,138566563,1836811251,2500064563,4053287085,2559996085,364657695,3051658259,776126179,3470053361,4265782527,109217425,3556133471,2826724125,532822415,3686588465,711085057,1926128181,2032253591,474514743,1463629777,3282577967,3641250525,2644210945,1850123495,1966009563,2849612815,4049315703,3479187855,1868399239,2079344555,2411394035,1707255249,1524883915,68290687,1297313251,2867262599,3501007159,2647701905,1621172529,1977827397,2430662517,24532499,315464209,254798475,2758221035,1516319189,1453470875,438798663,4262113813,4221418283,2587298439,3178333215,3412998651,663722975,3803132983,582059813,2741745551,4007061017,523933345,2735001607,3420371681,3183930911,1087948509,2991813541,35727159,2491218457,2947801817,53108389,2299193865,1564856429,3308731719,1847443931,2060462157,4187395939,2524829139,728788783,886713019,2659993519,4167744369,598446711,2879017357,3486554441,2712923729,331312913,3451823513,1103699131,1188739541,347167337,1214453813,223973921,15685667,133163397,3850614951,2164460719,2110445001,895771195,2640336603,3902125183,4155990687,2630818871,3853544385,2084104523,2450850917,3043167063,2875454501,4238167163,381487369,583431137,3409827447,262286047,4061784485,2619114569,1618099783,872952099,3186811977,2224953751,439541559,2794191625,2817485443,920010985,2353592273,938325055,3629085557,591063977,2844049087,1285861199,2615126067,475061695,4039351381,3017269077,1402325827,4149098815,2166018815,607165511,3967627535,3623908199,1032505551,2845167405,300870531,4186370897,2674119833,2633767881,3894020571,119020873,2789803273,3041935401,2921361997,605415225,926436739,2332971491,2949656353,1893826815,2810715777,2009458683,736322089,1052443753,1897129103,514911333,4290158877,3939411635,4127225301,2988543241,4232007785,3006235779,677227287,431691409,4029902025,2418279693,2832801077,2165179453,607377055,2270216791,419038355,1127863475,4130442989,2541499787,4136288363,2970394805,1699586791,489332999,1117596411,2040452521,2130592823,1565626781,3446358739,3461941965,1400946563,1674409589,131534829,1715415869,1095051685,1051009291,2793768405,3935035323,3697543135,1535198485,1187113083,3841638187,4115466829,2487324669,2813410301,3471514543,3548861847,2303244165,172762057,3945297267,1273855577,3354734919,3415634695,4118839853,1776288751,1789575449,3567776883,1878023601,662356953,1943016983,3296331001,3966817613,3796582359,3096651231,74331945,1309063813,2932867111,266410263,2573937047,2234102445,1736260209,3021643153,572433761,2895244109,1095924157,3093027137,1372123115,1147774471,170907213,1021534059,3549639899,156738973,4125907881,2240183559,4096022271,3230323477,3080170481,1304988863,2102980703,191308933,2761114163,1672911443,192172375,3590110513,1814152975,883445155,1935703189,1087425861,4134063599,1557156497,887689913,3045685519,2638885881,6547649,253000551,3854457529,842508839,526181933,1749079003,2075914997,181122675,1182867533,2086377645,4103742667,3870859363,632914217,720291045,494590395,813526665,252598183,856256137,2143050647,2316536181,3421831603,2320962533,143716709,509993345,3651651227,321473725,1071225319,2014854375,141505675,1653584621,657327549,2504813197,1789794327,3161843695,554797269,2079681489,1340237841,1321914505,2092896849,2029590637,1308990739,1517170025,383917443,4210202231,678690307,2459754477,741821651,3950138229,698955519,491190905,718801535,1074621319,3673343233,1270023147,302605541,480570919,882433407,1161349593,3552766579,443159593,2093217147,3660567277,872068373,2678642081,1284222717,2408290433,301955265,120962167,2961547355,1053140715,155260119,2411961693,4267498821,672616401,3585472253,3236385333,1283714557,4210555353,569881353,1135522369,1129819355,948291977,956410333,666109813,3673657919,1720099371,2770081123,2138220339,1262740151,4022103557,3053496289,35339743,607506155,3910692927,4198598989,1877176107,4108607481,2522983651,1696427707,3129886153,3722736509,2755263271,1477663017,2963268307,2398719165,2810757079,3547650831,2871844567,703348645,3688554805,1021960441,966119809,4039587407,2261599183,153503051,2086828685,3971660113,3327815237,1565359369,1278338989,3719486845,2975378983,51805017,334515987,3116846797,124871141,680950127,1218974479,2918768275,2194442649,603523453,2718877175,3415280635,3773880505,2593325639,1285345509,135324579,1635040393,3720807995,1710207409,1260941817,368459193,4179618171,1629877941,3343301419,2007626225,1762077995,564077451,3266644565,2485788367,3382343109,2685248953,3103290853,3466686861,444412309,990115945,3571369565,3318934875,2248253993,1833412093,1171754475,362189637,3794695307,2421739499,1204889671,3362902361,854740379,2671834735,237377129,4049040645,2691293935,3614893309,1153023519,3916872647,3851885451,3131721775,1377898331,4096916273,495476113,2598245029,400056917,3839475239,463148267,1716935987,2068546751,1079816881,1995343487,1613315747,804730475,130056995,1197827067,2628857247,4025061985,1915877087,2060543357,1387428017,2301306295,20316041,1654762753,3401808955,2367107665,3466522677,941583153,1468835845,1974294989,3066147025,631118949,2430321869,3835014963,2656579115,1645603865,3493770397,3614632647,3238724409,1765765341,879492321,3404836945,1496282121,3220742469,920835003,934180539,4202334505,1089264161,577109501,1343987317,3554399579,3868118471,108742043,3402308873,3561886813,531558839,3639797411,1393304717,3970383929,1873920367,512299097,197191823,2296293853,1145482809,2622016025,3526240963,3517897695,116673999,2698566337,490375569,2406621135,2467284867,295112781,2990888769,597716829,1820622545,2636743065,243956287,3540523043,276212221,4057839185,850696025,4218320815,1371283641,3486805603,3121688143,765767143,879152899,3067212393,4187299033,4245400459,1376502597,4284035019,2730233383,411311143,3369216343,3025625003,3613280323,561726737,3762217411,812896539,346990125,4081299797,3126718131,1574284235,2922650851,2728958099,3883989553,2848276915,3472839245,1617079909,1630657533,3742715469,1399278035,3146148895,1993290913,521687961,938430455,193958253,466429641,1540625449,2353585741,2254299667,456121809,47343241,547428713,1250826119,3886445559,1201049199,3177214839,1457827357,328684811,3814162731,100835421,2064374195,402021249,2056187845,139165825,4230891061,2187887409,3608594945,2672118697,911359249,2934496491,1300466531,1226366463,561888933,3274904123,2387900323,2612742287,2199219107,3820827937,1750502991,969554875,561389377,3775331283,3568646385,394897043,4261734861,2019956729,3611803881,624141639,684702269,542950697,1179935659,3391907763,3445141785,146925415,1354535945,2302569109,1319290643,986862805,3492017143,2859801965,2572264379,2199038293,279166805,589620657,2091067885,5304585,4090568469,2839377001,984685597,1128304411,670742473,2376052753,336726953,571750467,2783543129,2844323699,936201637,2888444533,3702166283,2303343929,1496998781,2593079845,3678760171,2235245351,1359417543,2400483987,191589037,2648055437,3701795943,2456837205,487608555,1368185389,566058575,863528765,4016863583,2440494343,1472786647,2505016033,3577003447,779112309,1948243933,2407785509,785454001,1278512481,3739259351,3815337475,3701993979,779179805,2391789383,46212635,1206766705,3560261915,1819494423,3990267671,323932475,3733176043,3765502933,937448447,655978313,3131767847,465240693,3166504045,4198520615,4021546965,1553640847,3017003635,2396227101,681858469,141505965,540559011,2329162489,3316641697,543272407,1463405771,1961207501,3762540023,3166736849,3090205869,492148299,549792307,1336709835,3616117771,3131455475,2712714269,4134050871,3409557265,3694817771,1630679753,1983467537,3183347775,1471294581,1926816993,3445166071,2755731571,3639693753,926645047,4074614111,3565056281,1224572741,2956288431,2200007507,1009418381,2112828047,2740339785,1379956519,759720957,130783481,341787285,1497523897,4032026337,4130047681,4087974489,156043959,2647208561,3454786343,3496212503,2967126755,1917504861,1345810087,4192525859,1828744249,3542957627,2689687635,2475890109,969435031,2705608591,90532001,4134816379,1063749575,3329977799,1724323833,2972297969,3886539565,3815990247,2385981777,3297478247,828587303,1135783497,2611192777,2985750953,2440335715,637302231,2385897965,108673553,200884421,1399595103,2106821183,2264722857,1176464675,3792298255,3901578729,178390715,3168435905,3389980799,1388629329,322873231,2284810251,3413382513,3708004053,2598610147,41914529,405411183,573752597,2465623083,3979512135,3441828201,2664888971,2357104861,2424275765,4068868929,730851199,2144794439,96690665,853836241,2287832729,2767160177,3193937001,3427869255,1279078051,2841946075,1373441865,832861867,929740235,1234454003,1656527199,3333612703,1274210949,3349666807,474114449,467866047,3067085125,2586458175,1273828775,736423253,1915719361,2553293471,2745542769,2173560457,885671833,1158289305,1741757667,1391572427,1391587399,787023077,1711702933,2979954217,155844687,332369063,3287522655,1682386631,2058383047,2287270989,576361835,2348944949,2427659577,153229337,3495644223,667019829,613376093,837424021,3322146145,755835265,4293175637,242349167,1223554425,3903121509,1258269597,3731938273,2842814553,3682554927,815098701,2730162789,120764907,3955322213,2750038065,1242992997,1207921635,3811491779,3075668939,1991552257,23322145,959869175,3800247389,316527645,4156763009,2627705893,4023329907,969915113,3904469639,2912922333,765656669,3638578805,4081116221,4251028821,3244472085,342308159,1665313,2649299159,727886509,442813173,2269754793,90548711,1455293127,664421845,4111274671,1550486245,2418715893,549932291,1401591155,1707421435,4089250667,2787984583,2532123813,2283690411,4165441421,593408609,3575795725,2947747701,3985918251,3968246497,646686915,1529852737,1256307091,2497689809,3734518351,2293737719,2415539309,1039712511,864626215,1981867689,1118477959,2610832197,340285221,2204195077,4079790485,3249531019,3176228553,437300825,1076736837,3157701611,3236102893,3656935693,620652299,1579197285,2687447887,1663618787,1236133851,2648821797,1767795341,565715609,3255552059,2420033573,1701479815,2238327467,125986611,1248003723,1946469237,3095361457,1382225397,235118215,478522073,2340567315,514570415,4152711795,1974986383,3763464775,2163572433,2188633563,2861758771,845589957,1877446643,2642453705,52423079,3160728759,1820827583,4260393231,3512267657,387760981,2252978215,3967016105,2206941365,3464827451,3038896255,169215431,3264293375,2944155247,450631359,446418583,2621805291,3807289123,2558234183,614121511,1534494621,1538935007,3103504917,3665750699,2500969395,2073463107,28525741,3916239775,706312297,2855453073,3123878703,1578634713,3149970891,3788768057,4018644183,268377935,138021529,48707809,5717115,3374854077,2655297521,2257580249,3025563913,54583017,1276382829,3490741871,562329853,3777960063,2399343081,511834505,3370327013,3569038599,2081416655,2572839839,2110075329,1433694703,4136497069,793731953,997744977,3335583589,2999056653,493108429,1606987277,3617572299,3816851887,2037312813,743617427,555871575,2698097745,3149279085,2750886555,3332056029,3469385283,2651308601,3912625641,1224455437,2809815137,3948034445,1214426195,290450913,3109878885,537318605,2865232937,2625605723,1448278473,1174168247,1710295825,1857615517,1367174719,1555357539,3294485971,3938558793,3525021215,36998307,2815136087,3935432773,3867475291,3742944251,149991927,528836755,654779367,3531674895,2773948263,2458561033,3437178487,2159710053,55626125,1309590681,1301947193,3699959125,3728532195,1578855385,3744462429,3187843797,2021800817,1884882385,3589050239,894424337,2475723139,3574881279,878438671,600985867,1339530319,69997945,3878672853,3869730387,432266505,1886935681,3557246327,216929903,3120854111,4031541977,3035075897,720726971,3393749509,1832220521,3835639009,360615951,4182356921,3383415603,3796100785,3476762287,633393137,3119245581,1804395881,3323136821,2395564601,3888919731,1022724313,4074150193,302379845,2514647663,3939642807,2031843607,1638487383,1027131649,699743359,3042703451,2093342149,1171584107,3993074161,2418217719,4182572017,593206509,3015355037,558577225,630660617,2291671871,4216907915,3920411879,1335341445,1648666059,2983446385,2816680865,3910262263,2105661441,3033711121,3123980429,309036767,1255883693,3460445603,1437821557,49803671,753577157,2728643487,3342733385,1139352743,1991052403,2913710187,3728120813,3165414179,1014790843,1957488825,1191132649,3734680709,2838431829,537441829,3360099507,1318083443,3976717227,2404008883,3032382301,1189420871,2347557005,1180976721,4200928799,3299713329,2813027705,2758230577,4157720511,686648961,2468375275,93836647,2422882487,2459086307,1186768513,1571785101,3793921555,2437807239,3475041719,2437937477,3433040171,145174291,4202871207,1621677541,131842897,135279185,121134221,2314415347,1905768597,3374666207,595757875,4039938121,3493283699,3924205391,3524253765,3697712837,747312559,3390173367,2524499257,3873640717,144817893,946693243,3626734223,971286467,3748696221,19393679,391753633,2686190907,3901365033,703679773,830979977,13004703,2174001815,2850190033,1701584795,3378821455,3425360113,2047842965,2026895311,2733476135,959819501,4130898063,746226705,1238207139,1987081477,3742224963,2466844323,2587193329,109482941,2405362173,686850001,3876867223,1996803747,1752093865,1845128097,3911830903,1192502973,1771154929,2258448225,3761886833,3451845139,1215734369,528056599,2344861517,3621709465,2973547797,1576815249,688654785,1984577835,3925268925,3103674847,3071430545,39513839,41978335,3152923563,2589404601,2149818817,1222268847,3913604761,1306058181,3924679807,3225228661,1447428491,468639327,1756031647,1745139723,3677735621,2110090679,1457073185,2450630255,2509723909,4235886641,2785310751,2891761867,3183441911,934848925,4123949281,1798501767,4194779549,2880444591,4204622763,714675543,1193909997,2821326557,3625741773,473658133,2679661131,1577740455,2744320685,3950568871,2018041565,1073190241,1102859901,643837639,3875629147,140333073,2522892047,471867789,3264887929,4011875207,4185126123,3399494829,1033060965,3884883277,4033448095,196735751,439191625,1399566125,538890171,2654533591,167920135,3640006737,1781210131,4173684129,181630903,2798257075,3239198761,2478911429,795907595,542703433,634711465,1820019315,3622144113,1879487021,2473376729,2833366047,756067651,175824661,3646777509,3253483529,2040906537,2167877381,2428601127,3665869171,1848852813,2867335885,1146809203,2758769233,1880147709,3751259473,4001234279,2377506761,3258636267,2192394471,67703897,2477853509,2183714539,2715623183,3145751821,1077789001,2384043611,2921922675,1114848735,3195624697,3771020485,216567393,4186657771,3952950599,2405359209,1722115311,1147403397,1670868027,410824483,88570247,1879319449,1018530901,3736661965,1475631421,2492094683,476004237,338320053,1859297939,3006068831,4155303597,3854032539,4194192529,3252284023,4291862309,2979966921,2409807657,998209641,3627668937,3492307537,1982894399,2652834795,2610178579,3240929905,599316291,962300851,3293872663,2932219375,2121162757,2543145325,734279111,2276578421,3836239609,914319577,2078831645,4107124843,430640023,2216262611,3354954489,3285187495,2701041635,651448321,411876579,2495407601,740749235,4119742111,4196432917,1901167355,2496368085,2479537445,3910017769,4148781687,4043266791,1408720735,2680013089,3239697409,465399643,793628079,3390226137,3965276617,1955328553,4226048591,2991016861,261757687,2175207541,1102412277,3141553391,3401165993,3006243719,4198680443,810363057,337284189,585668991,1860119363,4167139923,904627445,2175389627,1648881911,3407106055,4091040325,113248391,2981541265,2322756037,660581159,1946011565,2700115325,3508278417,3834004627,2775956927,267458093,3759905793,2689831429,905870517,1748345229,1860502311,34013709,1300553827,779894357,2387336737,3866394873,2503828643,3653338267,3277278213,159125389,3053578593,3058905799,1543075563,1185057437,4095601691,3868005095,2335133777,3332987331,461189043,927774189,213748167,1535830451,2592529007,4251009401,4223729495,321385815,1366225441,2332885001,2417345883,3556345671,3096025831,1264385039,663228695,3864541687,1504421073,3905578203,4001767597,2120542471,369336707,1397709771,1052485769,2619097877,1460088313,2625750489,2909102715,2747971261,3448344219,3960558285,4246923085,3842584959,2402907331,1567861285,2850529637,2653121815,3059520679,632765951,122431201,2688859109,225814099,1118438285,2413242031,2595389279,201767445,2139680209,2536197851,3866771339,543096201,2454962583,2585677435,2689600599,1145410957,4095601057,3404044851,3152138557,3357562425,3348927869,2414427397,898983873,1625551239,2338222109,3987670449,689187519,337132421,1926111059,426655155,3660809277,107535863,3533406499,577093983,1098316789,354516141,828164813,474366707,1216228085,223214967,246624401,4136619697,921049025,3177815257,2403321211,1333993877,2510941905,2168767021,3221872771,385294363,96239439,2405960505,1613402075,4036429239,1029467605,2414104607,1528634867,301663123,1054178789,4216520933,608456865,762797595,3094225895,3615220315,3520446119,1515093941,1027040471,369665609,2139350745,3157148733,2844642775,1790483441,1646846495,427686737,3187230737,2658794731,327337301,2188614777,965404757,3177179957,4180671223,3821891773,3167611387,644840845,2257363897,2869460473,2199545427,3489829933,3334629591,990697731,1141538357,1510938003,3592080159,2046587111,3570601189,534760763,1782999483,817264263,2243899207,1648458861,1066954355,1347687621,4048683547,403307993,2476175603,260568183,2753945749,1385381841,4129780839,1475429783,1340789631,660994467,401616977,972326173,1741452539,3362105455,1057821895,1915049107,224802497,1737519603,1744852047,3155936485,1437543521,4133606895,1800848269,2213329939,560197927,1248124873,1619909619,3587531659,1515983757,3054159863,2551429627,1938585179,1935676125,1406532637,4155236303,4097296921,1422855435,4130663969,1454580973,2440047679,3185945559,1342512523,2348519141,3987306563,606228415,1167617377,2965814093,4186274815,1824612619,2078500595,4077954517,3909358141,3374525981,3922724499,574866377,2511882779,2077416993,741828003,4082488007,146499205,3084974149,1526986021,991334237,2873849491,754498549,2431416081,322081,2166233373,35887985,652911611,1299848575,2469885595,199764253,2734269923,1831554129,664464981,1298066767,3351973831,1349808825,551459265,1921335501,3851289641,1566617255,4049650637,3684766521,2212779447,1066468359,782220253,2795679157,892733967,374619083,401168799,112640679,1649978537,965063305,1763089665,989866383,880878393,2845032789,3641632327,1622197919,1576009479,2603415965,2927961333,4060870317,2895777775,1446024305,2941996925,2591444153,1643327437,2458055553,644382365,666984591,631962925,3492332899,3786907237,471838729,2622427435,1478888877,4160640065,3147975479,1309149849,1478380115,835968507,1681027481,1200876483,1455454579,2303573671,3519248397,168952241,1915631459,3065263067,3001923975,3758573525,15372769,2034766247,3199119623,928081895,2023815699,2867284539,1581849775,588148761,855789805,2273661273,518296937,3715126351,874498841,220503213,431463541,2587374973,303504797,1753271983,2550607909,3842207573,2579561409,641441109,3977834745,367234157,1740078281,3619906531,1308557415,1257495683,4173740995,579865121,18090097,751319189,2405509641,1885879827,3504405745,3187539067,188761735,359001165,2498649739,3142256969,4129026741,1402784007,2834001749,4076464671,3653305231,329075843,1496007551,2907895529,2506806949,1370122193,30332141,3318369007,2899671237,3574843723,714712239,694086781,1054528373,3690741847,4245263747,1652477019,154263469,3236329183,3365076157,3630264965,1602124121,1278687927,494780491,4137272851,99879513,1123426509,1557471271,2410965889,4040380339,1065292949,1253520491,3020976873,2478979243,253890131,3583184727,3846121627,2287856981,1419831943,1761701467,2416980741,2314836313,1567906185,1474946547,2013235511,2251495003,1730665183,1621379153,61310201,808573383,1790407589,479709203,1643560357,2186493869,826937781,1650908295,3923608103,2346854769,3156158083,3909826069,2264203141,2730443619,204956823,2388853537,264451405,1145222959,1640994493,3464679947,2348777161,851418625,956507089,3439610977,1444160793,3685421859,3676907585,3157664533,697759587,548037595,819899527,2347327797,4279885987,2744218777,3926517643,747813327,2204528913,4157382143,475591667,944813529,953705025,3260447029,1503279239,3341178239,2865960253,1104238295,1426716707,1589657661,4276382849,2810894895,4272907593,218861757,2238087611,54951299,1691353809,3604292457,4215276863,3135718245,3112212049,373193351,2486049573,57815771,240766573,1611975871,4161983259,1572569243,376553813,2391173183,3844730539,1648539297,1085016917,2550564305,2885542337,2340265717,3224277889,3479286325,3027946373,1096916329,4171092885,3014538965,1584359025,4051407643,1190426811,1658817653,4027310053,41256541,3593043153,284808891,3296530951,1538382657,3946797753,2845963591,875126725,3359045923,2852961011,3399506219,3780304273,1428454353,1995161373,3313155227,1285156031,4287096683,3454790193,2555757621,1395681841,1028551001,1939841203,4232701165,1579352587,3177456573,1079008951,1094331635,1728673729,4089758383,1388731427,4134999447,2201061761,4225120241,3084073,3597885293,66913067,497593801,941429981,3749151649,3953434649,1574970059,3249306153,3097222401,1179222761,3500641875,4055365685,1713162607,2409151615,3309286709,2706490735,2663110943,856540803,4020058735,3064075279,460961549,2141088389,659676235,1195235789,676467221,3556685649,1394571581,354581911,1445752945,1319129849,1433459419,3483185451,3543050833,12153885,278231415,4203200489,3390748443,231456405,4190547727,1585488373,3765038993,2197554565,1844720011,352003975,2041881651,1840603749,3119672107,2619355153,3829267197,1400229175,2626490161,2911183007,2587598599,4259947989,160347431,855717133,642060651,4289770631,1290660799,2848297301,1782225885,2596488101,2549801597,2105534889,998897601,2866022789,2067071915,2221000357,2223508427,3358725123,33084769,2737345709,4065231449,4009490505,2005829809,2933236639,3353262407,1188005267,2860937367,3374913821,3684632971,1295165935,1059047729,4144988535,311107931,1419190861,2282925295,3354923159,495660105,1064657161,3234266585,2075885073,3094728767,2285875059,4005080859,3485217321,687783357,2925654537,736139249,3317466575,3708606777,2955955923,1116082613,2304514819,2278106115,2050824389,2563466179,1862037513,144707303,142530945,1711310405,1059857967,3792251735,1599811791,2292696641,3065268965,553238251,3570117123,755875689,109216405,67977035,1883928813,2732424209,2540121219,2076492907,3423627579,2383448715,2151734073,3750884433,77616197,2238115365,3071196259,250322939,3704726099,2554398527,1832999317,1316750281,743765523,1262582087,1247473605,1315683831,1979476767,117098421,4270483915,1772666829,151388271,3662452199,3516266293,3579745283,2589593479,3052628219,1095179855,1516989891,979244193,3170100317,3489080229,2607342995,4146892013,886783561,3259754649,1568485825,2789330691,2633801123,3926063867,4005759259,523034519,3799548113,4187156333,2493007151,1395386643,2072891747,592721865,778796759,37500819,2123300599,710832713,1242850465,3711333753,3839308857,2979971465,40159231,2685933335,3729748979,3930203337,3716537659,2375821321,1658199585,4054599351,2777402815,4246800719,1813348429,1655174293,201143941,625033323,2899229679,521699077,686182417,941654509,2078555165,3070923431,2933161329,542714149,1406637791,2463248161,2323030609,1034761527,4155958205,283223695,2456134619,3051690883,1647279369,3306202447,1851174587,3150544237,4111607181,103445305,570441413,2574430119,3361220619,2864913285,2884633413,3752037647,4118825385,1174285619,1571024387,2161169719,1126507597,3929368537,552229907,2991117645,1109059383,1474537683,3293776701,3584440059,3109559607,2702225989,2793081393,2801073385,3674412665,3596980471,3083507069,1110642353,2910858911,1730341503,2652367077,1356380691,3987742123,2765901257,3462751483,1913678921,1957027715,923920093,4045151309,737555055,2922199251,2151843375,3634975497,1644471067,2229390623,3567201069,3260559081,3751240223,97640243,1428524935,2964624747,1954254149,1312703009,149366099,2181012261,2735546355,3029054923,4151952565,1944466969,3859840719,4173916427,1721654011,2705144629,1788941689,1307222025,643581177,1887498043,1909161435,2696355747,446218615,1814119071,4172114077,406928715,957563655,3972292479,3017386729,598316827,1601342303,2403836611,3677417489,3484589753,1594344973,1381068405,913377269,1761660799,1975758677,1230407621,1738778653,1784604239,2555960379,2547343561,1920006009,2438070435,522364057,3150398095,2621845871,159947583,2941856253,1427543439,302314625,12227719,2973221483,766679865,2151202267,3630304747,3130758149,1697968535,2889753459,2766161573,2433976495,2002797665,117647271,1352911695,3740449795,3177966689,3062082435,1762650261,453180915,3198420539,1408539823,3764308089,2953996353,4045146927,2478192707,2404609435,2679995391,1012241373,415197545,3065009613,2210719039,2237556413,313135233,2954796009,3098806069,4170551327,2143556911,2395742545,1060845267,456254537,3837672597,3612249887,867614969,1743125725,3565878789,3530983481,734617645,1729878141,3367692063,783832609,3512970469,1365637061,3547300005,2824923495,4142011207,3707296001,1071551249,1975639561,275891727,1501556509,2287026529,3196295563,2336541697,1988865307,3677968657,4026006287,2257547099,2134866557,3693316299,3521787187,883027775,2010581369,4095927107,280749367,3337644155,3775629887,4079741459,4106094591,1464474843,3541079969,2322769541,549674843,2522529035,824265105,3613745983,3790208375,954808255,885306715,1662342661,1380259409,1736486131,2686117765,1521233015,1053423475,760444873,13467329,937893161,1861523963,3306805171,1256261317,2760257139,640542865,747894071,4142273863,4079723447,23653571,808125799,2610277223,3363126569,2498622539,3058523763,721688805,1395512021,3765640481,2227217705,3529190151,487113173,43790731,1031931729,386716209,265377589,3344872845,3777622401,3356452729,3143735081,3722658633,3805049679,1527296533,434613517,2560241103,87469073,1533530159,2940044341,904537485,3103935297,1283409253,530314667,2604691905,1468448623,2759088909,3117448013,1899835851,1995701661,2700212777,4101359853,2056986823,604224455,3418499057,958762069,3695648839,1619000399,396105573,4078860669,3975535909,3004806677,906054199,2211919425,1433028715,1635797259,4120951995,3892606625,3460350859,690756599,4222781119,2378410341,1231363459,1961478231,353698297,1394496385,3971142863,2416405493,2510294711,3099367755,3626089891,478534431,1118542739,1026335867,3718824909,2398813963,2942556043,3027230511,3242860527,1755726111,2525702919,2827495513,2511045671,3133674437,1827094509,2481567959,4043790079,938581217,3959171099,2019207759,3699111565,4005666751,1311410787,2845252683,2392596855,2363370749,3968963841,1448351067,3017730721,3011583025,1441087693,1919863577,3025911809,3469406445,124206507,1682871127,838240253,2425595063,3494439965,162876161,365028715,2591721761,560955455,722713087,732943017,1415806481,837930219,2341500649,2269534237,2560768431,1417989837,2241791959,477170893,3719343467,2391304259,419929613,3808972933,3344754121,3414369543,3878129851,2011911051,2631499897,1001760339,954825207,1359820543,4086900343,4274268623,1622172647,2395736235,3618226079,2368334133,4088763693,3660108837,746092685,142706181,104784591,1463467629,1458946711,4145081835,805115923,3940267943,313950119,236091843,601872125,1759173291,1269405577,1885483249,1738151917,1874834667,43846545,460318181,1866262569,2621253425,2238297753,2795390325,1191151387,295443085,1401615503,3542516809,3957622883,3758471417,3782981987,1027913179,3089019849,1175578801,1272267391,3332935927,3293478891,1034614895,3647460413,856861185,2749255523,869795797,1002384175,3056865629,2511259735,2161634439,1715978477,1544763403,2014010157,3440329245,1611439297,1025019069,1528929465,655647113,1112696463,2040865103,3269673599,2795602989,1601757055,304689087,701924731,2557647177,1482468161,1432578531,1454079093,2425923355,2742590101,2914430733,3195850463,3598177835,4074323979,3177325599,4242712459,691985405,444151277,319248813,1152237037,778285577,1305822981,2182267429,4039423365,4067149795,942920803,551797551,1265053823,298156685,730544733,1925644181,2115202803,8540103,2531372731,312407791,1595852509,179024349,2377362261,805333945,666396095,763324933,528848379,2436317123,3427412485,964981675,3482993959,582256441,3487706571,2060690861,144477617,665512167,3465667045,3773066609,2658212969,4045585277,1838320741,3993068315,1358453429,2684687699,339171747,4185099383,2015318995,1690066839,4029434969,4232095697,2905655865,219706299,2064748191,1664274877,776364167,2006272561,3785702683,1352306867,2232669327,2202359577,463364845,1547123305,809822863,1746185463,2666647263,3204834965,3636486377,2252955135,3662887411,3471356857,447749271,2850280003,4206836055,4035020373,1627859625,1117940799,3039268005,1593797833,907007095,1379594013,3739649393,3739143,1118185745,315209881,2822763503,1176416933,3842806067,4262320039,1252575341,2903750123,3820004249,3860343775,507059989,4167876135,2070945751,2945900609,3939887229,3377864081,1593346481,3177444741,3817738525,1909983211,699968701,4200828135,1302445841,108411705,709529705,3692883973,861313117,600971787,1505288009,730554105,1058513395,3953753875,1183048683,2402642999,1051538259,2835633097,3811435639,3287068961,3187477359,3243276177,4192682007,2185002749,2702779315,8423563,1264713447,3070008799,4075018329,1696554633,4136906985,609706293,3048963343,2419257415,3230879877,2858561547,387043503,552698305,272982065,2232819597,3921967807,2387069567,3796001211,541882421,1328109595,4245476751,982038201,1139067989,731320981,3120471243,2655639827,3458535361,2931042113,1977570103,448980045,3957034235,393954729,3777564993,370042133,3454141537,3808948265,2289419625,3126082721,3681069145,1674754147,2924381607,1652281567,3879970483,594090985,3761361985,3784455047,2905294787,302293357,2810213321,3292183887,1520241141,3860317293,2122213563,944961359,235818907,511105117,2462543499,3178186125,525687595,1786556899,1353050155,977403711,2485334953,2872312501,1222131495,1573233915,3208102887,958581369,337287057,508566601,1489211869,860873331,2242847639,3877841735,1130144653,2477540925,3560444397,674029927,4063134105,4025213319,2642486899,95270883,4221050375,3964972569,1349434597,4027268831,2721944791,1630854753,1605365251,2524622199,1152658909,2821897915,202041285,2156560725,3417990197,1267216629,3369623385,4042477365,79427701,1224358381,1937592833,324310725,215565167,279918175,2947340123,1932955977,973236693,1788885267,3308762423,989203809,3716037543,3214582497,569992801,1389075107,3040175221,1184047435,2237026203,1455888051,2167382697,3231576897,508511947,2542247377,3248696317,4028245925,3155363671,1219062447,2011387899,2139939169,709060157,2258108217,110006243,4252292247,638802851,2736877823,2795406749,1052341587,2422361799,1841969195,1484035369,258230173,3175174007,4121510399,4026845425,161393927,827180647,1069338179,3331981075,208060269,921544335,854709859,1820886427,175608139,437869517,2453925301,1405793843,1777516161,36271049,3101338895,812998307,2468443513,581978513,1202898887,1522833759,4264367887,1257654929,2502408271,4059842889,1882868847,1308243013,3365964919,3051921749,1245508891,1251765947,3235765521,3673591757,1622473047,4113791999,2680935159,3149193739,2824069389,2305305589,2723071455,3003777033,2464037381,1428653631,2396646467,3092006779,3959318675,3251057157,2810022077,3692206077,1962448077,1351760689,2973811765,3629122639,172125155,2332139987,2168288921,298763119,2910108679,2842002439,1065085429,1635478389,285629523,3624686673,597434415,614157599,3236018567,2787928777,1033618677,3136583119,303042741,3425012419,2548206633,470562687,625425149,671807573,551959843,2498493315,1605428483,4240404689,355904355,1855728901,2323124573,3394383419,1161545443,4199672593,3367230127,1608362091,1193014065,3735918889,2077161049,66959977,4115104333,2243538907,74529575,2578031685,1217317847,3823318833,2111089643,4124518369,893463407,1612178047,3796064563,1425540505,2367911905,4230790671,3748084819,2103391445,4075846125,3932915073,3668943357,1036658947,55060861,2551531747,3928389015,4044946587,3643664629,377584287,3997916771,466452569,170715719,548063571,3391404375,2644142311,3940179165,2528406425,1069325097,886622413,2261510627,1708173989,1882729447,2799426931,1174138679,1164205993,277908081,714194507,3006087537,1883749417,2228543681,4063648481,3490718709,1427217261,3570403517,4145309411,93692121,2432392201,1961301613,1297973591,3598338261,602715919,95618263,2443483039,4193787913,195301411,208354271,601848287,4258418653,353589739,2517831379,803751265,3574336875,2276584741,1964020021,3711224219,2509205013,1976530323,1182079397,2036503543,1230374653,3203466937,511267251,1563774627,1290617629,755151545,3366536967,3585235489,1758879145,385785029,699004945,743465657,3448827303,2939428741,3096611785,2602831391,725117289,866751609,2213517597,2488519825,3317106147,1767140635,235721727,3997328395,4083625487,298866501,932928379,1615886459,2409701255,2074492309,1684232303,1154073759,1138961763,3706738345,3864031677,3501079215,681231693,1085304565,3271128065,3323353709,3467710973,3420872281,3995428975,3370259893,1330078457,657870205,3621728595,2282451559,1510786245,3775713853,1073658289,2048486065,878282993,3847475687,2580424415,692332681,3047081497,2544219235,4261790459,3718458561,295338841,396568723,3186536755,1144528987,1245323521,2416547623,2039915633,2565824009,3956332221,3735565991,4253037399,1126678099,1776925865,3879942177,2906224203,891426793,3551118995,3214288347,847287115,2813451477,574465455,2091092969,500479841,948650375,4224679473,1521410227,220746073,2441510613,872409617,3754977479,1690149997,923570161,2355578905,4089146323,1204529673,257563637,3141055383,459204387,2115233261,1104538001,380691013]} diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/runner.c b/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/runner.c new file mode 100644 index 000000000000..5db586da8d00 --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/test/fixtures/c/runner.c @@ -0,0 +1,327 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2018 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/** +* Generate C test fixtures. +* +* ## Notes +* +* - Run this script from the directory in which fixtures should be written. +* +*/ + +#include +#include + +/** +* Generates a linearly spaced numeric array of doubles. +* +* ## Notes +* +* - Assumes that the output array has at least 2 elements. +* - Output array is guaranteed to include both the start and end values. +* +* +* @param out output array +* @param len array length +* @param start first value +* @param end last value +*/ +void linspace_f64( double *out, const unsigned int len, const double start, const double end ) { + unsigned int i; + double incr; + + incr = (end-start) / (len-1); + for ( i = 0; i < len-1; i++ ) { + out[ i ] = start + (incr*i); + } + out[ i ] = end; +} + +/** +* Generates a linearly spaced numeric array of integers. +* +* ## Notes +* +* - Assumes that the output array has at least 2 elements. +* - Output array is guaranteed to include both the start and end values. +* +* +* @param out output array +* @param len array length +* @param start first value +* @param end last value +*/ +void linspace_ui32( unsigned int *out, const unsigned int len, const unsigned int start, const unsigned int end ) { + unsigned int incr; + unsigned int i; + + incr = (end-start) / (len-1); + for ( i = 0; i < len-1; i++ ) { + out[ i ] = start + (incr*i); + } + out[ i ] = end; +} + +/** +* Generates a random number on the interval [0,1]. +* +* @return random number +*/ +double rand_double() { + int r = rand(); + return (double)r / ( (double)RAND_MAX + 1.0 ); +} + +/** +* Generates an array of pseudorandom doubles drawn from a uniform distribution. +* +* @param out output array +* @param len array length +* @param a lower bound (inclusive) +* @param b upper bound (exclusive) +*/ +void rand_array_f64( double *out, const unsigned int len, const double a, const double b ) { + unsigned int i; + double delta; + + delta = b - a; + + for ( i = 0; i < len; i++ ) { + out[ i ] = a + ( rand_double()*delta ); + } +} + +/** +* Generates an array of pseudorandom integers drawn from a uniform distribution. +* +* ## Notes +* +* - WARNING: the method used here is not particularly robust, as some integer values may be sampled more frequently than others. +* +* +* @param out output array +* @param len array length +* @param a lower bound (inclusive) +* @param b upper bound (exclusive) +*/ +void rand_array_ui32( unsigned int *out, const unsigned int len, const unsigned int a, const unsigned int b ) { + unsigned int i; + unsigned int r; + double delta; + + delta = (double)b - (double)a; + + for ( i = 0; i < len; i++ ) { + r = (unsigned int)( delta * rand_double() ); // truncation + out[ i ] = a + r; + } +} + +/** +* Casts an array of integers to an array of doubles. +* +* @param out output array +* @param x input array +* @param len array length +*/ +void ui32_to_f64( double *out, unsigned int *x, unsigned int len ) { + unsigned int i; + + for ( i = 0; i < len; i++ ) { + out[ i ] = (double) x[ i ]; + } +} + +/** +* Casts an array of doubles to an array of integers. +* +* @param out output array +* @param x input array +* @param len array length +*/ +void f64_to_ui32( unsigned int *out, double *x, unsigned int len ) { + unsigned int i; + + for ( i = 0; i < len; i++ ) { + out[ i ] = (unsigned int) x[ i ]; + } +} + +/** +* Writes an array of doubles to a file as a series of comma-separated values. +* +* @param f file to write to +* @param x array of doubles +* @param len array length +*/ +void write_array_f64( FILE *f, const double *x, const unsigned int len ) { + unsigned int i; + + for ( i = 0; i < len; i++ ) { + fprintf( f, "%.17g", x[ i ] ); + if ( i < len-1 ) { + fprintf( f, "," ); + } + } +} + +/** +* Writes an array of integers to a file as a series of comma-separated values. +* +* @param f file to write to +* @param x array of integers +* @param len array length +*/ +void write_array_ui32( FILE *f, const unsigned int *x, const unsigned int len ) { + unsigned int i; + + for ( i = 0; i < len; i++ ) { + fprintf( f, "%u", x[ i ] ); + if ( i < len-1 ) { + fprintf( f, "," ); + } + } +} + +/** +* Writes a named array of doubles to a file as JSON. +* +* @param f file to write to +* @param name array name +* @param x data +* @param len array length +*/ +void write_named_array_f64( FILE *f, const char *name, const double *x, const unsigned int len ) { + fprintf( f, "\"%s\":[", name ); + write_array_f64( f, x, len ); + fprintf( f, "]" ); +} + +/** +* Writes a named array of integers to a file as JSON. +* +* @param f file to write to +* @param name array name +* @param x data +* @param len array length +*/ +void write_named_array_ui32( FILE *f, const char *name, const unsigned int *x, const unsigned int len ) { + fprintf( f, "\"%s\":[", name ); + write_array_ui32( f, x, len ); + fprintf( f, "]" ); +} + +/** +* Writes data to a file as JSON. +* +* ## Notes +* +* - This function SHOULD be tailored to the input data (e.g., input types, output types, number of arguments, etc) and may vary from use case to use case. +* +* +* @param f file to write to +* @param a domain +* @param b domain +* @param y results +* @param len array length +*/ +void write_data_as_json( FILE *f, const unsigned int *a, const unsigned int *b, const unsigned int *y, const unsigned int len ) { + fprintf( f, "{" ); + write_named_array_ui32( f, "a", a, len ); + fprintf( f, "," ); + write_named_array_ui32( f, "b", b, len ); + fprintf( f, "," ); + write_named_array_ui32( f, "expected", y, len ); + fprintf( f, "}" ); +} + +/** +* Generates test fixtures. +* +* @param a domain +* @param b domain +* @param len number of values in the domain +* @param name output filename +*/ +void generate( unsigned int *a, unsigned int *b, const unsigned int len, const char *name ) { + unsigned int i; + unsigned int *y; + FILE *f; + + // Allocate an output array: + y = (unsigned int*) malloc( len * sizeof(unsigned int) ); + if ( y == NULL ) { + printf( "Error allocating memory.\n" ); + exit( 1 ); + } + + // Generate fixture data: + for ( i = 0; i < len; i++ ) { + y[ i ] = a[ i ] * b[ i ]; + } + // Open a new file: + f = fopen( name, "w" ); + if ( f == NULL ) { + printf( "Error opening file.\n" ); + exit( 1 ); + } + // Write data as JSON: + write_data_as_json( f, a, b, y, len ); + + // Close the file: + fclose( f ); + + // Free allocated memory: + free( y ); +} + +/** +* Main execution sequence. +*/ +int main( void ) { + unsigned int len; + unsigned int *a; + unsigned int *b; + + // Define the array length: + len = 5000; + + // Allocate arrays: + a = (unsigned int*) malloc( len * sizeof(unsigned int) ); + if ( a == NULL ) { + printf( "Error allocating memory.\n" ); + exit( 1 ); + } + b = (unsigned int*) malloc( len * sizeof(unsigned int) ); + if ( b == NULL ) { + printf( "Error allocating memory.\n" ); + exit( 1 ); + } + + // Generate fixture data: + rand_array_ui32( a, len, 0, 4294967295 ); + rand_array_ui32( b, len, 0, 4294967295 ); + generate( a, b, len, "data.json" ); + + // Free allocated memory: + free( a ); + free( b ); + + return 0; +} diff --git a/lib/node_modules/@stdlib/number/uint32/base/mul/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/mul/test/test.js new file mode 100644 index 000000000000..cc4e0b3fb00f --- /dev/null +++ b/lib/node_modules/@stdlib/number/uint32/base/mul/test/test.js @@ -0,0 +1,55 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2018 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var umul = require( './../lib' ); + + +// FIXTURES // + +var data = require( './fixtures/c/data.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof umul, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function emulates C-like multiplication of two unsigned 32-bit integers', function test( t ) { + var expected; + var actual; + var a; + var b; + var i; + + a = data.a; + b = data.b; + expected = data.expected; + for ( i = 0; i < expected.length; i++ ) { + actual = umul( a[ i ], b[ i ] ); + t.strictEqual( actual, expected[ i ], 'returns expected value. a: '+a[i]+'. b: '+b[i]+'. expected: '+expected[i]+'. actual: '+actual+'.' ); + } + t.end(); +}); From 3e7b26c4bf92ba582a038a1c672dd1ab4ab2a959 Mon Sep 17 00:00:00 2001 From: gururaj1512 Date: Thu, 27 Feb 2025 20:32:34 +0000 Subject: [PATCH 2/4] remove: remove `umul` from namespace This commit removes the `umul` symbol from the `@stdlib/math/base/ops` namespace due to a package migration. BREAKING CHANGE: remove `umul` To migrate, users should access the same symbol via the `@stdlib/number/uint32/base` namespace. --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/math/base/ops/docs/types/index.d.ts | 14 -------------- .../@stdlib/math/base/ops/lib/index.js | 9 --------- 2 files changed, 23 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/ops/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/ops/docs/types/index.d.ts index 59c1c66ac71d..1c9eebae09d3 100644 --- a/lib/node_modules/@stdlib/math/base/ops/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/ops/docs/types/index.d.ts @@ -32,7 +32,6 @@ import csubf = require( '@stdlib/math/base/ops/csubf' ); import imul = require( '@stdlib/math/base/ops/imul' ); import imuldw = require( '@stdlib/math/base/ops/imuldw' ); import mulf = require( '@stdlib/number/float32/base/mul' ); -import umul = require( '@stdlib/math/base/ops/umul' ); import umuldw = require( '@stdlib/math/base/ops/umuldw' ); import addf = require( '@stdlib/number/float32/base/add' ); import divf = require( '@stdlib/number/float32/base/div' ); @@ -475,19 +474,6 @@ interface Namespace { */ mulf: typeof mulf; - /** - * Performs C-like multiplication of two unsigned 32-bit integers. - * - * @param a - unsigned 32-bit integer - * @param b - Unsigned 32-bit integer - * @returns product - * - * @example - * var v = ns.umul( 10>>>0, 4>>>0 ); - * // returns 40 - */ - umul: typeof umul; - /** * Performs multiplication of two unsigned 32-bit integers and returns an array of two unsigned 32-bit integers which represents the unsigned 64-bit integer product. * diff --git a/lib/node_modules/@stdlib/math/base/ops/lib/index.js b/lib/node_modules/@stdlib/math/base/ops/lib/index.js index 1f463b008c4b..ec317d059aa4 100644 --- a/lib/node_modules/@stdlib/math/base/ops/lib/index.js +++ b/lib/node_modules/@stdlib/math/base/ops/lib/index.js @@ -135,15 +135,6 @@ setReadOnly( ns, 'imul', require( '@stdlib/math/base/ops/imul' ) ); */ setReadOnly( ns, 'imuldw', require( '@stdlib/math/base/ops/imuldw' ) ); -/** -* @name umul -* @memberof ns -* @readonly -* @type {Function} -* @see {@link module:@stdlib/math/base/ops/umul} -*/ -setReadOnly( ns, 'umul', require( '@stdlib/math/base/ops/umul' ) ); - /** * @name umuldw * @memberof ns From 97e8837986c41a624c248fe0822e33f85763ec38 Mon Sep 17 00:00:00 2001 From: gururaj1512 Date: Thu, 27 Feb 2025 20:39:37 +0000 Subject: [PATCH 3/4] refactor: update paths Ref: https://github.com/stdlib-js/stdlib/issues/2261 --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/math/base/ops/README.md | 9 ++------- lib/node_modules/@stdlib/math/base/ops/umuldw/README.md | 4 ++-- .../@stdlib/namespace/alias2pkg/data/data.csv | 2 +- .../@stdlib/namespace/alias2pkg/data/data.json | 2 +- .../@stdlib/namespace/lib/namespace/base/u.js | 6 +++--- .../@stdlib/namespace/pkg2alias/data/data.csv | 2 +- .../@stdlib/namespace/pkg2alias/data/data.json | 2 +- .../@stdlib/namespace/pkg2related/data/data.csv | 4 ++-- .../@stdlib/namespace/pkg2related/data/data.json | 2 +- .../@stdlib/namespace/pkg2standalone/data/data.csv | 2 +- .../@stdlib/namespace/pkg2standalone/data/data.json | 2 +- .../@stdlib/namespace/standalone2pkg/data/data.csv | 2 +- .../@stdlib/namespace/standalone2pkg/data/data.json | 2 +- .../@stdlib/random/base/mt19937/lib/factory.js | 2 +- 14 files changed, 19 insertions(+), 24 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/ops/README.md b/lib/node_modules/@stdlib/math/base/ops/README.md index 64ba08f4084b..c09f8f5c1a40 100644 --- a/lib/node_modules/@stdlib/math/base/ops/README.md +++ b/lib/node_modules/@stdlib/math/base/ops/README.md @@ -53,7 +53,7 @@ The namespace contains the following functions: - [`imul( a, b )`][@stdlib/math/base/ops/imul]: perform C-like multiplication of two signed 32-bit integers. - [`imuldw( a, b )`][@stdlib/math/base/ops/imuldw]: compute the double word product of two signed 32-bit integers. - [`subf( x, y )`][@stdlib/number/float32/base/sub]: subtract two single-precision floating-point numbers. -- [`umul( a, b )`][@stdlib/math/base/ops/umul]: perform C-like multiplication of two unsigned 32-bit integers. +- [`umul( a, b )`][@stdlib/number/uint32/base/mul]: perform C-like multiplication of two unsigned 32-bit integers. - [`umuldw( a, b )`][@stdlib/math/base/ops/umuldw]: compute the double word product of two unsigned 32-bit integers. @@ -93,11 +93,6 @@ console.log( ns.cmul( z1, z2 ) ); // { 're': -13.0, 'im': -1.0 } console.log( ns.imul( 1073741824|0, -5|0 ) ); // => -1073741824 -// Operations for unsigned 32-bit integers: -// 2^31 * 5 = 10737418240 => 32-bit integer overflow -console.log( ns.umul( 2147483648>>>0, 5>>>0 ) ); -// => 2147483648 - // Operations for double word product: // -(2^31) * 2^30 = -2305843009213694000 => 32-bit integer overflow console.log( ns.imuldw( 0x80000000|0, 0x40000000|0 ) ); @@ -138,7 +133,7 @@ console.log( ns.imuldw( 0x80000000|0, 0x40000000|0 ) ); [@stdlib/number/float32/base/sub]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/number/float32/base/sub -[@stdlib/math/base/ops/umul]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/ops/umul +[@stdlib/number/uint32/base/mul]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/number/uint32/base/mul [@stdlib/math/base/ops/umuldw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/ops/umuldw diff --git a/lib/node_modules/@stdlib/math/base/ops/umuldw/README.md b/lib/node_modules/@stdlib/math/base/ops/umuldw/README.md index 63be1813c715..14525613e70d 100644 --- a/lib/node_modules/@stdlib/math/base/ops/umuldw/README.md +++ b/lib/node_modules/@stdlib/math/base/ops/umuldw/README.md @@ -111,7 +111,7 @@ for ( i = 0xFFFFFFF0; i < 0xFFFFFFFF; i++ ) { ## See Also - [`@stdlib/math/base/ops/imuldw`][@stdlib/math/base/ops/imuldw]: compute the double word product of two signed 32-bit integers. -- [`@stdlib/math/base/ops/umul`][@stdlib/math/base/ops/umul]: perform C-like multiplication of two unsigned 32-bit integers. +- [`@stdlib/number/uint32/base/mul`][@stdlib/number/uint32/base/mul]: perform C-like multiplication of two unsigned 32-bit integers. @@ -127,7 +127,7 @@ for ( i = 0xFFFFFFF0; i < 0xFFFFFFFF; i++ ) { [@stdlib/math/base/ops/imuldw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/ops/imuldw -[@stdlib/math/base/ops/umul]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/ops/umul +[@stdlib/number/uint32/base/mul]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/number/uint32/base/mul diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv index 95e10353a45e..5e5fe59a6757 100644 --- a/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv +++ b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv @@ -1480,7 +1480,7 @@ base.truncf,"@stdlib/math/base/special/truncf" base.truncn,"@stdlib/math/base/special/truncn" base.truncsd,"@stdlib/math/base/special/truncsd" base.uint32ToInt32,"@stdlib/number/uint32/base/to-int32" -base.umul,"@stdlib/math/base/ops/umul" +base.umul,"@stdlib/number/uint32/base/mul" base.umuldw,"@stdlib/math/base/ops/umuldw" base.uncapitalize,"@stdlib/string/base/uncapitalize" base.uppercase,"@stdlib/string/base/uppercase" diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json index ac36441647d6..4d169f13f9d6 100644 --- a/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json +++ b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json @@ -1 +1 @@ -{"abs":"@stdlib/math/special/abs","acartesianPower":"@stdlib/array/cartesian-power","acartesianProduct":"@stdlib/array/cartesian-product","acartesianSquare":"@stdlib/array/cartesian-square","acronym":"@stdlib/string/acronym","aempty":"@stdlib/array/empty","aemptyLike":"@stdlib/array/empty-like","AFINN_96":"@stdlib/datasets/afinn-96","AFINN_111":"@stdlib/datasets/afinn-111","afull":"@stdlib/array/full","afullLike":"@stdlib/array/full-like","alias2pkg":"@stdlib/namespace/alias2pkg","alias2related":"@stdlib/namespace/alias2related","alias2standalone":"@stdlib/namespace/alias2standalone","aliases":"@stdlib/namespace/aliases","allocUnsafe":"@stdlib/buffer/alloc-unsafe","amskfilter":"@stdlib/array/mskfilter","amskput":"@stdlib/array/mskput","amskreject":"@stdlib/array/mskreject","anans":"@stdlib/array/nans","anansLike":"@stdlib/array/nans-like","anova1":"@stdlib/stats/anova1","ANSCOMBES_QUARTET":"@stdlib/datasets/anscombes-quartet","any":"@stdlib/utils/any","anyBy":"@stdlib/utils/any-by","anyByAsync":"@stdlib/utils/async/any-by","anyByRight":"@stdlib/utils/any-by-right","anyByRightAsync":"@stdlib/utils/async/any-by-right","anyInBy":"@stdlib/utils/any-in-by","anyOwnBy":"@stdlib/utils/any-own-by","aones":"@stdlib/array/ones","aonesLike":"@stdlib/array/ones-like","aoneTo":"@stdlib/array/one-to","aoneToLike":"@stdlib/array/one-to-like","APERY":"@stdlib/constants/float64/apery","aplace":"@stdlib/array/place","append":"@stdlib/utils/append","aput":"@stdlib/array/put","ARCH":"@stdlib/os/arch","argumentFunction":"@stdlib/utils/argument-function","ARGV":"@stdlib/process/argv","array":"@stdlib/ndarray/array","array2buffer":"@stdlib/buffer/from-array","array2fancy":"@stdlib/array/to-fancy","array2iterator":"@stdlib/array/to-iterator","array2iteratorRight":"@stdlib/array/to-iterator-right","ArrayBuffer":"@stdlib/array/buffer","arraybuffer2buffer":"@stdlib/buffer/from-arraybuffer","arrayCtors":"@stdlib/array/ctors","arrayDataType":"@stdlib/array/dtype","arrayDataTypes":"@stdlib/array/dtypes","ArrayIndex":"@stdlib/array/index","arrayMinDataType":"@stdlib/array/min-dtype","arrayMostlySafeCasts":"@stdlib/array/mostly-safe-casts","arrayNextDataType":"@stdlib/array/next-dtype","arrayPromotionRules":"@stdlib/array/promotion-rules","arraySafeCasts":"@stdlib/array/safe-casts","arraySameKindCasts":"@stdlib/array/same-kind-casts","arrayShape":"@stdlib/array/shape","arrayStream":"@stdlib/streams/node/from-array","arrayview2iterator":"@stdlib/array/to-view-iterator","arrayview2iteratorRight":"@stdlib/array/to-view-iterator-right","aslice":"@stdlib/array/slice","AsyncIteratorSymbol":"@stdlib/symbol/async-iterator","atake":"@stdlib/array/take","azeros":"@stdlib/array/zeros","azerosLike":"@stdlib/array/zeros-like","azeroTo":"@stdlib/array/zero-to","azeroToLike":"@stdlib/array/zero-to-like","bartlettTest":"@stdlib/stats/bartlett-test","base.abs":"@stdlib/math/base/special/abs","base.abs2":"@stdlib/math/base/special/abs2","base.abs2f":"@stdlib/math/base/special/abs2f","base.absdiff":"@stdlib/math/base/utils/absolute-difference","base.absf":"@stdlib/math/base/special/absf","base.acartesianPower":"@stdlib/array/base/cartesian-power","base.acartesianProduct":"@stdlib/array/base/cartesian-product","base.acartesianSquare":"@stdlib/array/base/cartesian-square","base.acos":"@stdlib/math/base/special/acos","base.acosd":"@stdlib/math/base/special/acosd","base.acosf":"@stdlib/math/base/special/acosf","base.acosh":"@stdlib/math/base/special/acosh","base.acot":"@stdlib/math/base/special/acot","base.acotd":"@stdlib/math/base/special/acotd","base.acotf":"@stdlib/math/base/special/acotf","base.acoth":"@stdlib/math/base/special/acoth","base.acovercos":"@stdlib/math/base/special/acovercos","base.acoversin":"@stdlib/math/base/special/acoversin","base.acsc":"@stdlib/math/base/special/acsc","base.acscd":"@stdlib/math/base/special/acscd","base.acscdf":"@stdlib/math/base/special/acscdf","base.acscf":"@stdlib/math/base/special/acscf","base.acsch":"@stdlib/math/base/special/acsch","base.add":"@stdlib/number/float64/base/add","base.add3":"@stdlib/number/float64/base/add3","base.add4":"@stdlib/number/float64/base/add4","base.add5":"@stdlib/number/float64/base/add5","base.addf":"@stdlib/number/float32/base/add","base.afilled":"@stdlib/array/base/filled","base.afilled2d":"@stdlib/array/base/filled2d","base.afilled2dBy":"@stdlib/array/base/filled2d-by","base.afilled3d":"@stdlib/array/base/filled3d","base.afilled3dBy":"@stdlib/array/base/filled3d-by","base.afilled4d":"@stdlib/array/base/filled4d","base.afilled4dBy":"@stdlib/array/base/filled4d-by","base.afilled5d":"@stdlib/array/base/filled5d","base.afilled5dBy":"@stdlib/array/base/filled5d-by","base.afilledBy":"@stdlib/array/base/filled-by","base.afillednd":"@stdlib/array/base/fillednd","base.afilledndBy":"@stdlib/array/base/fillednd-by","base.afilter":"@stdlib/array/base/filter","base.afirst":"@stdlib/array/base/first","base.aflatten":"@stdlib/array/base/flatten","base.aflatten2d":"@stdlib/array/base/flatten2d","base.aflatten2dBy":"@stdlib/array/base/flatten2d-by","base.aflatten3d":"@stdlib/array/base/flatten3d","base.aflatten3dBy":"@stdlib/array/base/flatten3d-by","base.aflatten4d":"@stdlib/array/base/flatten4d","base.aflatten4dBy":"@stdlib/array/base/flatten4d-by","base.aflatten5d":"@stdlib/array/base/flatten5d","base.aflatten5dBy":"@stdlib/array/base/flatten5d-by","base.aflattenBy":"@stdlib/array/base/flatten-by","base.afliplr2d":"@stdlib/array/base/fliplr2d","base.afliplr3d":"@stdlib/array/base/fliplr3d","base.afliplr4d":"@stdlib/array/base/fliplr4d","base.afliplr5d":"@stdlib/array/base/fliplr5d","base.aflipud2d":"@stdlib/array/base/flipud2d","base.aflipud3d":"@stdlib/array/base/flipud3d","base.aflipud4d":"@stdlib/array/base/flipud4d","base.aflipud5d":"@stdlib/array/base/flipud5d","base.ahavercos":"@stdlib/math/base/special/ahavercos","base.ahaversin":"@stdlib/math/base/special/ahaversin","base.altcase":"@stdlib/string/base/altcase","base.aones":"@stdlib/array/base/ones","base.aones2d":"@stdlib/array/base/ones2d","base.aones3d":"@stdlib/array/base/ones3d","base.aones4d":"@stdlib/array/base/ones4d","base.aones5d":"@stdlib/array/base/ones5d","base.aonesnd":"@stdlib/array/base/onesnd","base.aoneTo":"@stdlib/array/base/one-to","base.args2multislice":"@stdlib/slice/base/args2multislice","base.asec":"@stdlib/math/base/special/asec","base.asecd":"@stdlib/math/base/special/asecd","base.asecdf":"@stdlib/math/base/special/asecdf","base.asecf":"@stdlib/math/base/special/asecf","base.asech":"@stdlib/math/base/special/asech","base.asin":"@stdlib/math/base/special/asin","base.asind":"@stdlib/math/base/special/asind","base.asindf":"@stdlib/math/base/special/asindf","base.asinf":"@stdlib/math/base/special/asinf","base.asinh":"@stdlib/math/base/special/asinh","base.atan":"@stdlib/math/base/special/atan","base.atan2":"@stdlib/math/base/special/atan2","base.atand":"@stdlib/math/base/special/atand","base.atanf":"@stdlib/math/base/special/atanf","base.atanh":"@stdlib/math/base/special/atanh","base.avercos":"@stdlib/math/base/special/avercos","base.aversin":"@stdlib/math/base/special/aversin","base.azeros":"@stdlib/array/base/zeros","base.azeros2d":"@stdlib/array/base/zeros2d","base.azeros3d":"@stdlib/array/base/zeros3d","base.azeros4d":"@stdlib/array/base/zeros4d","base.azeros5d":"@stdlib/array/base/zeros5d","base.azerosnd":"@stdlib/array/base/zerosnd","base.azeroTo":"@stdlib/array/base/zero-to","base.bernoulli":"@stdlib/math/base/special/bernoulli","base.besselj0":"@stdlib/math/base/special/besselj0","base.besselj1":"@stdlib/math/base/special/besselj1","base.bessely0":"@stdlib/math/base/special/bessely0","base.bessely1":"@stdlib/math/base/special/bessely1","base.beta":"@stdlib/math/base/special/beta","base.betainc":"@stdlib/math/base/special/betainc","base.betaincinv":"@stdlib/math/base/special/betaincinv","base.betaln":"@stdlib/math/base/special/betaln","base.binet":"@stdlib/math/base/special/binet","base.binomcoef":"@stdlib/math/base/special/binomcoef","base.binomcoefln":"@stdlib/math/base/special/binomcoefln","base.boxcox":"@stdlib/math/base/special/boxcox","base.boxcox1p":"@stdlib/math/base/special/boxcox1p","base.boxcox1pinv":"@stdlib/math/base/special/boxcox1pinv","base.boxcoxinv":"@stdlib/math/base/special/boxcoxinv","base.cabs":"@stdlib/math/base/special/cabs","base.cabs2":"@stdlib/math/base/special/cabs2","base.cabs2f":"@stdlib/math/base/special/cabs2f","base.cabsf":"@stdlib/math/base/special/cabsf","base.cadd":"@stdlib/complex/float64/base/add","base.caddf":"@stdlib/complex/float32/base/add","base.camelcase":"@stdlib/string/base/camelcase","base.capitalize":"@stdlib/string/base/capitalize","base.cbrt":"@stdlib/math/base/special/cbrt","base.cbrtf":"@stdlib/math/base/special/cbrtf","base.cceil":"@stdlib/math/base/special/cceil","base.cceilf":"@stdlib/math/base/special/cceilf","base.cceiln":"@stdlib/math/base/special/cceiln","base.ccis":"@stdlib/math/base/special/ccis","base.cdiv":"@stdlib/math/base/ops/cdiv","base.ceil":"@stdlib/math/base/special/ceil","base.ceil2":"@stdlib/math/base/special/ceil2","base.ceil10":"@stdlib/math/base/special/ceil10","base.ceilb":"@stdlib/math/base/special/ceilb","base.ceilf":"@stdlib/math/base/special/ceilf","base.ceiln":"@stdlib/math/base/special/ceiln","base.ceilsd":"@stdlib/math/base/special/ceilsd","base.cexp":"@stdlib/math/base/special/cexp","base.cflipsign":"@stdlib/math/base/special/cflipsign","base.cflipsignf":"@stdlib/math/base/special/cflipsignf","base.cfloor":"@stdlib/math/base/special/cfloor","base.cfloorn":"@stdlib/math/base/special/cfloorn","base.cidentity":"@stdlib/math/base/special/cidentity","base.cidentityf":"@stdlib/math/base/special/cidentityf","base.cinv":"@stdlib/math/base/special/cinv","base.clamp":"@stdlib/math/base/special/clamp","base.clampf":"@stdlib/math/base/special/clampf","base.cmul":"@stdlib/complex/float64/base/mul","base.cmulf":"@stdlib/complex/float32/base/mul","base.cneg":"@stdlib/math/base/ops/cneg","base.cnegf":"@stdlib/math/base/ops/cnegf","base.codePointAt":"@stdlib/string/base/code-point-at","base.constantcase":"@stdlib/string/base/constantcase","base.continuedFraction":"@stdlib/math/base/tools/continued-fraction","base.copysign":"@stdlib/math/base/special/copysign","base.copysignf":"@stdlib/math/base/special/copysignf","base.cos":"@stdlib/math/base/special/cos","base.cosd":"@stdlib/math/base/special/cosd","base.cosh":"@stdlib/math/base/special/cosh","base.cosm1":"@stdlib/math/base/special/cosm1","base.cospi":"@stdlib/math/base/special/cospi","base.cot":"@stdlib/math/base/special/cot","base.cotd":"@stdlib/math/base/special/cotd","base.coth":"@stdlib/math/base/special/coth","base.covercos":"@stdlib/math/base/special/covercos","base.coversin":"@stdlib/math/base/special/coversin","base.cphase":"@stdlib/math/base/special/cphase","base.cpolar":"@stdlib/math/base/special/cpolar","base.cround":"@stdlib/math/base/special/cround","base.croundn":"@stdlib/math/base/special/croundn","base.csc":"@stdlib/math/base/special/csc","base.cscd":"@stdlib/math/base/special/cscd","base.csch":"@stdlib/math/base/special/csch","base.csignum":"@stdlib/math/base/special/csignum","base.csub":"@stdlib/math/base/ops/csub","base.csubf":"@stdlib/math/base/ops/csubf","base.deg2rad":"@stdlib/math/base/special/deg2rad","base.deg2radf":"@stdlib/math/base/special/deg2radf","base.digamma":"@stdlib/math/base/special/digamma","base.diracDelta":"@stdlib/math/base/special/dirac-delta","base.div":"@stdlib/number/float64/base/div","base.divf":"@stdlib/number/float32/base/div","base.dotcase":"@stdlib/string/base/dotcase","base.dists.arcsine.Arcsine":"@stdlib/stats/base/dists/arcsine/ctor","base.dists.arcsine.cdf":"@stdlib/stats/base/dists/arcsine/cdf","base.dists.arcsine.entropy":"@stdlib/stats/base/dists/arcsine/entropy","base.dists.arcsine.kurtosis":"@stdlib/stats/base/dists/arcsine/kurtosis","base.dists.arcsine.logcdf":"@stdlib/stats/base/dists/arcsine/logcdf","base.dists.arcsine.logpdf":"@stdlib/stats/base/dists/arcsine/logpdf","base.dists.arcsine.mean":"@stdlib/stats/base/dists/arcsine/mean","base.dists.arcsine.median":"@stdlib/stats/base/dists/arcsine/median","base.dists.arcsine.mode":"@stdlib/stats/base/dists/arcsine/mode","base.dists.arcsine.pdf":"@stdlib/stats/base/dists/arcsine/pdf","base.dists.arcsine.quantile":"@stdlib/stats/base/dists/arcsine/quantile","base.dists.arcsine.skewness":"@stdlib/stats/base/dists/arcsine/skewness","base.dists.arcsine.stdev":"@stdlib/stats/base/dists/arcsine/stdev","base.dists.arcsine.variance":"@stdlib/stats/base/dists/arcsine/variance","base.dists.bernoulli.Bernoulli":"@stdlib/stats/base/dists/bernoulli/ctor","base.dists.bernoulli.cdf":"@stdlib/stats/base/dists/bernoulli/cdf","base.dists.bernoulli.entropy":"@stdlib/stats/base/dists/bernoulli/entropy","base.dists.bernoulli.kurtosis":"@stdlib/stats/base/dists/bernoulli/kurtosis","base.dists.bernoulli.mean":"@stdlib/stats/base/dists/bernoulli/mean","base.dists.bernoulli.median":"@stdlib/stats/base/dists/bernoulli/median","base.dists.bernoulli.mgf":"@stdlib/stats/base/dists/bernoulli/mgf","base.dists.bernoulli.mode":"@stdlib/stats/base/dists/bernoulli/mode","base.dists.bernoulli.pmf":"@stdlib/stats/base/dists/bernoulli/pmf","base.dists.bernoulli.quantile":"@stdlib/stats/base/dists/bernoulli/quantile","base.dists.bernoulli.skewness":"@stdlib/stats/base/dists/bernoulli/skewness","base.dists.bernoulli.stdev":"@stdlib/stats/base/dists/bernoulli/stdev","base.dists.bernoulli.variance":"@stdlib/stats/base/dists/bernoulli/variance","base.dists.beta.Beta":"@stdlib/stats/base/dists/beta/ctor","base.dists.beta.cdf":"@stdlib/stats/base/dists/beta/cdf","base.dists.beta.entropy":"@stdlib/stats/base/dists/beta/entropy","base.dists.beta.kurtosis":"@stdlib/stats/base/dists/beta/kurtosis","base.dists.beta.logcdf":"@stdlib/stats/base/dists/beta/logcdf","base.dists.beta.logpdf":"@stdlib/stats/base/dists/beta/logpdf","base.dists.beta.mean":"@stdlib/stats/base/dists/beta/mean","base.dists.beta.median":"@stdlib/stats/base/dists/beta/median","base.dists.beta.mgf":"@stdlib/stats/base/dists/beta/mgf","base.dists.beta.mode":"@stdlib/stats/base/dists/beta/mode","base.dists.beta.pdf":"@stdlib/stats/base/dists/beta/pdf","base.dists.beta.quantile":"@stdlib/stats/base/dists/beta/quantile","base.dists.beta.skewness":"@stdlib/stats/base/dists/beta/skewness","base.dists.beta.stdev":"@stdlib/stats/base/dists/beta/stdev","base.dists.beta.variance":"@stdlib/stats/base/dists/beta/variance","base.dists.betaprime.BetaPrime":"@stdlib/stats/base/dists/betaprime/ctor","base.dists.betaprime.cdf":"@stdlib/stats/base/dists/betaprime/cdf","base.dists.betaprime.kurtosis":"@stdlib/stats/base/dists/betaprime/kurtosis","base.dists.betaprime.logcdf":"@stdlib/stats/base/dists/betaprime/logcdf","base.dists.betaprime.logpdf":"@stdlib/stats/base/dists/betaprime/logpdf","base.dists.betaprime.mean":"@stdlib/stats/base/dists/betaprime/mean","base.dists.betaprime.mode":"@stdlib/stats/base/dists/betaprime/mode","base.dists.betaprime.pdf":"@stdlib/stats/base/dists/betaprime/pdf","base.dists.betaprime.quantile":"@stdlib/stats/base/dists/betaprime/quantile","base.dists.betaprime.skewness":"@stdlib/stats/base/dists/betaprime/skewness","base.dists.betaprime.stdev":"@stdlib/stats/base/dists/betaprime/stdev","base.dists.betaprime.variance":"@stdlib/stats/base/dists/betaprime/variance","base.dists.binomial.Binomial":"@stdlib/stats/base/dists/binomial/ctor","base.dists.binomial.cdf":"@stdlib/stats/base/dists/binomial/cdf","base.dists.binomial.entropy":"@stdlib/stats/base/dists/binomial/entropy","base.dists.binomial.kurtosis":"@stdlib/stats/base/dists/binomial/kurtosis","base.dists.binomial.logpmf":"@stdlib/stats/base/dists/binomial/logpmf","base.dists.binomial.mean":"@stdlib/stats/base/dists/binomial/mean","base.dists.binomial.median":"@stdlib/stats/base/dists/binomial/median","base.dists.binomial.mgf":"@stdlib/stats/base/dists/binomial/mgf","base.dists.binomial.mode":"@stdlib/stats/base/dists/binomial/mode","base.dists.binomial.pmf":"@stdlib/stats/base/dists/binomial/pmf","base.dists.binomial.quantile":"@stdlib/stats/base/dists/binomial/quantile","base.dists.binomial.skewness":"@stdlib/stats/base/dists/binomial/skewness","base.dists.binomial.stdev":"@stdlib/stats/base/dists/binomial/stdev","base.dists.binomial.variance":"@stdlib/stats/base/dists/binomial/variance","base.dists.cauchy.Cauchy":"@stdlib/stats/base/dists/cauchy/ctor","base.dists.cauchy.cdf":"@stdlib/stats/base/dists/cauchy/cdf","base.dists.cauchy.entropy":"@stdlib/stats/base/dists/cauchy/entropy","base.dists.cauchy.logcdf":"@stdlib/stats/base/dists/cauchy/logcdf","base.dists.cauchy.logpdf":"@stdlib/stats/base/dists/cauchy/logpdf","base.dists.cauchy.median":"@stdlib/stats/base/dists/cauchy/median","base.dists.cauchy.mode":"@stdlib/stats/base/dists/cauchy/mode","base.dists.cauchy.pdf":"@stdlib/stats/base/dists/cauchy/pdf","base.dists.cauchy.quantile":"@stdlib/stats/base/dists/cauchy/quantile","base.dists.chi.cdf":"@stdlib/stats/base/dists/chi/cdf","base.dists.chi.Chi":"@stdlib/stats/base/dists/chi/ctor","base.dists.chi.entropy":"@stdlib/stats/base/dists/chi/entropy","base.dists.chi.kurtosis":"@stdlib/stats/base/dists/chi/kurtosis","base.dists.chi.logpdf":"@stdlib/stats/base/dists/chi/logpdf","base.dists.chi.mean":"@stdlib/stats/base/dists/chi/mean","base.dists.chi.mode":"@stdlib/stats/base/dists/chi/mode","base.dists.chi.pdf":"@stdlib/stats/base/dists/chi/pdf","base.dists.chi.quantile":"@stdlib/stats/base/dists/chi/quantile","base.dists.chi.skewness":"@stdlib/stats/base/dists/chi/skewness","base.dists.chi.stdev":"@stdlib/stats/base/dists/chi/stdev","base.dists.chi.variance":"@stdlib/stats/base/dists/chi/variance","base.dists.chisquare.cdf":"@stdlib/stats/base/dists/chisquare/cdf","base.dists.chisquare.ChiSquare":"@stdlib/stats/base/dists/chisquare/ctor","base.dists.chisquare.entropy":"@stdlib/stats/base/dists/chisquare/entropy","base.dists.chisquare.kurtosis":"@stdlib/stats/base/dists/chisquare/kurtosis","base.dists.chisquare.logpdf":"@stdlib/stats/base/dists/chisquare/logpdf","base.dists.chisquare.mean":"@stdlib/stats/base/dists/chisquare/mean","base.dists.chisquare.median":"@stdlib/stats/base/dists/chisquare/median","base.dists.chisquare.mgf":"@stdlib/stats/base/dists/chisquare/mgf","base.dists.chisquare.mode":"@stdlib/stats/base/dists/chisquare/mode","base.dists.chisquare.pdf":"@stdlib/stats/base/dists/chisquare/pdf","base.dists.chisquare.quantile":"@stdlib/stats/base/dists/chisquare/quantile","base.dists.chisquare.skewness":"@stdlib/stats/base/dists/chisquare/skewness","base.dists.chisquare.stdev":"@stdlib/stats/base/dists/chisquare/stdev","base.dists.chisquare.variance":"@stdlib/stats/base/dists/chisquare/variance","base.dists.cosine.cdf":"@stdlib/stats/base/dists/cosine/cdf","base.dists.cosine.Cosine":"@stdlib/stats/base/dists/cosine/ctor","base.dists.cosine.kurtosis":"@stdlib/stats/base/dists/cosine/kurtosis","base.dists.cosine.logcdf":"@stdlib/stats/base/dists/cosine/logcdf","base.dists.cosine.logpdf":"@stdlib/stats/base/dists/cosine/logpdf","base.dists.cosine.mean":"@stdlib/stats/base/dists/cosine/mean","base.dists.cosine.median":"@stdlib/stats/base/dists/cosine/median","base.dists.cosine.mgf":"@stdlib/stats/base/dists/cosine/mgf","base.dists.cosine.mode":"@stdlib/stats/base/dists/cosine/mode","base.dists.cosine.pdf":"@stdlib/stats/base/dists/cosine/pdf","base.dists.cosine.quantile":"@stdlib/stats/base/dists/cosine/quantile","base.dists.cosine.skewness":"@stdlib/stats/base/dists/cosine/skewness","base.dists.cosine.stdev":"@stdlib/stats/base/dists/cosine/stdev","base.dists.cosine.variance":"@stdlib/stats/base/dists/cosine/variance","base.dists.degenerate.cdf":"@stdlib/stats/base/dists/degenerate/cdf","base.dists.degenerate.Degenerate":"@stdlib/stats/base/dists/degenerate/ctor","base.dists.degenerate.entropy":"@stdlib/stats/base/dists/degenerate/entropy","base.dists.degenerate.logcdf":"@stdlib/stats/base/dists/degenerate/logcdf","base.dists.degenerate.logpdf":"@stdlib/stats/base/dists/degenerate/logpdf","base.dists.degenerate.logpmf":"@stdlib/stats/base/dists/degenerate/logpmf","base.dists.degenerate.mean":"@stdlib/stats/base/dists/degenerate/mean","base.dists.degenerate.median":"@stdlib/stats/base/dists/degenerate/median","base.dists.degenerate.mgf":"@stdlib/stats/base/dists/degenerate/mgf","base.dists.degenerate.mode":"@stdlib/stats/base/dists/degenerate/mode","base.dists.degenerate.pdf":"@stdlib/stats/base/dists/degenerate/pdf","base.dists.degenerate.pmf":"@stdlib/stats/base/dists/degenerate/pmf","base.dists.degenerate.quantile":"@stdlib/stats/base/dists/degenerate/quantile","base.dists.degenerate.stdev":"@stdlib/stats/base/dists/degenerate/stdev","base.dists.degenerate.variance":"@stdlib/stats/base/dists/degenerate/variance","base.dists.discreteUniform.cdf":"@stdlib/stats/base/dists/discrete-uniform/cdf","base.dists.discreteUniform.DiscreteUniform":"@stdlib/stats/base/dists/discrete-uniform/ctor","base.dists.discreteUniform.entropy":"@stdlib/stats/base/dists/discrete-uniform/entropy","base.dists.discreteUniform.kurtosis":"@stdlib/stats/base/dists/discrete-uniform/kurtosis","base.dists.discreteUniform.logcdf":"@stdlib/stats/base/dists/discrete-uniform/logcdf","base.dists.discreteUniform.logpmf":"@stdlib/stats/base/dists/discrete-uniform/logpmf","base.dists.discreteUniform.mean":"@stdlib/stats/base/dists/discrete-uniform/mean","base.dists.discreteUniform.median":"@stdlib/stats/base/dists/discrete-uniform/median","base.dists.discreteUniform.mgf":"@stdlib/stats/base/dists/discrete-uniform/mgf","base.dists.discreteUniform.pmf":"@stdlib/stats/base/dists/discrete-uniform/pmf","base.dists.discreteUniform.quantile":"@stdlib/stats/base/dists/discrete-uniform/quantile","base.dists.discreteUniform.skewness":"@stdlib/stats/base/dists/discrete-uniform/skewness","base.dists.discreteUniform.stdev":"@stdlib/stats/base/dists/discrete-uniform/stdev","base.dists.discreteUniform.variance":"@stdlib/stats/base/dists/discrete-uniform/variance","base.dists.erlang.cdf":"@stdlib/stats/base/dists/erlang/cdf","base.dists.erlang.entropy":"@stdlib/stats/base/dists/erlang/entropy","base.dists.erlang.Erlang":"@stdlib/stats/base/dists/erlang/ctor","base.dists.erlang.kurtosis":"@stdlib/stats/base/dists/erlang/kurtosis","base.dists.erlang.logpdf":"@stdlib/stats/base/dists/erlang/logpdf","base.dists.erlang.mean":"@stdlib/stats/base/dists/erlang/mean","base.dists.erlang.mgf":"@stdlib/stats/base/dists/erlang/mgf","base.dists.erlang.mode":"@stdlib/stats/base/dists/erlang/mode","base.dists.erlang.pdf":"@stdlib/stats/base/dists/erlang/pdf","base.dists.erlang.quantile":"@stdlib/stats/base/dists/erlang/quantile","base.dists.erlang.skewness":"@stdlib/stats/base/dists/erlang/skewness","base.dists.erlang.stdev":"@stdlib/stats/base/dists/erlang/stdev","base.dists.erlang.variance":"@stdlib/stats/base/dists/erlang/variance","base.dists.exponential.cdf":"@stdlib/stats/base/dists/exponential/cdf","base.dists.exponential.entropy":"@stdlib/stats/base/dists/exponential/entropy","base.dists.exponential.Exponential":"@stdlib/stats/base/dists/exponential/ctor","base.dists.exponential.kurtosis":"@stdlib/stats/base/dists/exponential/kurtosis","base.dists.exponential.logcdf":"@stdlib/stats/base/dists/exponential/logcdf","base.dists.exponential.logpdf":"@stdlib/stats/base/dists/exponential/logpdf","base.dists.exponential.mean":"@stdlib/stats/base/dists/exponential/mean","base.dists.exponential.median":"@stdlib/stats/base/dists/exponential/median","base.dists.exponential.mgf":"@stdlib/stats/base/dists/exponential/mgf","base.dists.exponential.mode":"@stdlib/stats/base/dists/exponential/mode","base.dists.exponential.pdf":"@stdlib/stats/base/dists/exponential/pdf","base.dists.exponential.quantile":"@stdlib/stats/base/dists/exponential/quantile","base.dists.exponential.skewness":"@stdlib/stats/base/dists/exponential/skewness","base.dists.exponential.stdev":"@stdlib/stats/base/dists/exponential/stdev","base.dists.exponential.variance":"@stdlib/stats/base/dists/exponential/variance","base.dists.f.cdf":"@stdlib/stats/base/dists/f/cdf","base.dists.f.entropy":"@stdlib/stats/base/dists/f/entropy","base.dists.f.F":"@stdlib/stats/base/dists/f/ctor","base.dists.f.kurtosis":"@stdlib/stats/base/dists/f/kurtosis","base.dists.f.mean":"@stdlib/stats/base/dists/f/mean","base.dists.f.mode":"@stdlib/stats/base/dists/f/mode","base.dists.f.pdf":"@stdlib/stats/base/dists/f/pdf","base.dists.f.quantile":"@stdlib/stats/base/dists/f/quantile","base.dists.f.skewness":"@stdlib/stats/base/dists/f/skewness","base.dists.f.stdev":"@stdlib/stats/base/dists/f/stdev","base.dists.f.variance":"@stdlib/stats/base/dists/f/variance","base.dists.frechet.cdf":"@stdlib/stats/base/dists/frechet/cdf","base.dists.frechet.entropy":"@stdlib/stats/base/dists/frechet/entropy","base.dists.frechet.Frechet":"@stdlib/stats/base/dists/frechet/ctor","base.dists.frechet.kurtosis":"@stdlib/stats/base/dists/frechet/kurtosis","base.dists.frechet.logcdf":"@stdlib/stats/base/dists/frechet/logcdf","base.dists.frechet.logpdf":"@stdlib/stats/base/dists/frechet/logpdf","base.dists.frechet.mean":"@stdlib/stats/base/dists/frechet/mean","base.dists.frechet.median":"@stdlib/stats/base/dists/frechet/median","base.dists.frechet.mode":"@stdlib/stats/base/dists/frechet/mode","base.dists.frechet.pdf":"@stdlib/stats/base/dists/frechet/pdf","base.dists.frechet.quantile":"@stdlib/stats/base/dists/frechet/quantile","base.dists.frechet.skewness":"@stdlib/stats/base/dists/frechet/skewness","base.dists.frechet.stdev":"@stdlib/stats/base/dists/frechet/stdev","base.dists.frechet.variance":"@stdlib/stats/base/dists/frechet/variance","base.dists.gamma.cdf":"@stdlib/stats/base/dists/gamma/cdf","base.dists.gamma.entropy":"@stdlib/stats/base/dists/gamma/entropy","base.dists.gamma.Gamma":"@stdlib/stats/base/dists/gamma/ctor","base.dists.gamma.kurtosis":"@stdlib/stats/base/dists/gamma/kurtosis","base.dists.gamma.logcdf":"@stdlib/stats/base/dists/gamma/logcdf","base.dists.gamma.logpdf":"@stdlib/stats/base/dists/gamma/logpdf","base.dists.gamma.mean":"@stdlib/stats/base/dists/gamma/mean","base.dists.gamma.mgf":"@stdlib/stats/base/dists/gamma/mgf","base.dists.gamma.mode":"@stdlib/stats/base/dists/gamma/mode","base.dists.gamma.pdf":"@stdlib/stats/base/dists/gamma/pdf","base.dists.gamma.quantile":"@stdlib/stats/base/dists/gamma/quantile","base.dists.gamma.skewness":"@stdlib/stats/base/dists/gamma/skewness","base.dists.gamma.stdev":"@stdlib/stats/base/dists/gamma/stdev","base.dists.gamma.variance":"@stdlib/stats/base/dists/gamma/variance","base.dists.geometric.cdf":"@stdlib/stats/base/dists/geometric/cdf","base.dists.geometric.entropy":"@stdlib/stats/base/dists/geometric/entropy","base.dists.geometric.Geometric":"@stdlib/stats/base/dists/geometric/ctor","base.dists.geometric.kurtosis":"@stdlib/stats/base/dists/geometric/kurtosis","base.dists.geometric.logcdf":"@stdlib/stats/base/dists/geometric/logcdf","base.dists.geometric.logpmf":"@stdlib/stats/base/dists/geometric/logpmf","base.dists.geometric.mean":"@stdlib/stats/base/dists/geometric/mean","base.dists.geometric.median":"@stdlib/stats/base/dists/geometric/median","base.dists.geometric.mgf":"@stdlib/stats/base/dists/geometric/mgf","base.dists.geometric.mode":"@stdlib/stats/base/dists/geometric/mode","base.dists.geometric.pmf":"@stdlib/stats/base/dists/geometric/pmf","base.dists.geometric.quantile":"@stdlib/stats/base/dists/geometric/quantile","base.dists.geometric.skewness":"@stdlib/stats/base/dists/geometric/skewness","base.dists.geometric.stdev":"@stdlib/stats/base/dists/geometric/stdev","base.dists.geometric.variance":"@stdlib/stats/base/dists/geometric/variance","base.dists.gumbel.cdf":"@stdlib/stats/base/dists/gumbel/cdf","base.dists.gumbel.entropy":"@stdlib/stats/base/dists/gumbel/entropy","base.dists.gumbel.Gumbel":"@stdlib/stats/base/dists/gumbel/ctor","base.dists.gumbel.kurtosis":"@stdlib/stats/base/dists/gumbel/kurtosis","base.dists.gumbel.logcdf":"@stdlib/stats/base/dists/gumbel/logcdf","base.dists.gumbel.logpdf":"@stdlib/stats/base/dists/gumbel/logpdf","base.dists.gumbel.mean":"@stdlib/stats/base/dists/gumbel/mean","base.dists.gumbel.median":"@stdlib/stats/base/dists/gumbel/median","base.dists.gumbel.mgf":"@stdlib/stats/base/dists/gumbel/mgf","base.dists.gumbel.mode":"@stdlib/stats/base/dists/gumbel/mode","base.dists.gumbel.pdf":"@stdlib/stats/base/dists/gumbel/pdf","base.dists.gumbel.quantile":"@stdlib/stats/base/dists/gumbel/quantile","base.dists.gumbel.skewness":"@stdlib/stats/base/dists/gumbel/skewness","base.dists.gumbel.stdev":"@stdlib/stats/base/dists/gumbel/stdev","base.dists.gumbel.variance":"@stdlib/stats/base/dists/gumbel/variance","base.dists.hypergeometric.cdf":"@stdlib/stats/base/dists/hypergeometric/cdf","base.dists.hypergeometric.Hypergeometric":"@stdlib/stats/base/dists/hypergeometric/ctor","base.dists.hypergeometric.kurtosis":"@stdlib/stats/base/dists/hypergeometric/kurtosis","base.dists.hypergeometric.logpmf":"@stdlib/stats/base/dists/hypergeometric/logpmf","base.dists.hypergeometric.mean":"@stdlib/stats/base/dists/hypergeometric/mean","base.dists.hypergeometric.mode":"@stdlib/stats/base/dists/hypergeometric/mode","base.dists.hypergeometric.pmf":"@stdlib/stats/base/dists/hypergeometric/pmf","base.dists.hypergeometric.quantile":"@stdlib/stats/base/dists/hypergeometric/quantile","base.dists.hypergeometric.skewness":"@stdlib/stats/base/dists/hypergeometric/skewness","base.dists.hypergeometric.stdev":"@stdlib/stats/base/dists/hypergeometric/stdev","base.dists.hypergeometric.variance":"@stdlib/stats/base/dists/hypergeometric/variance","base.dists.invgamma.cdf":"@stdlib/stats/base/dists/invgamma/cdf","base.dists.invgamma.entropy":"@stdlib/stats/base/dists/invgamma/entropy","base.dists.invgamma.InvGamma":"@stdlib/stats/base/dists/invgamma/ctor","base.dists.invgamma.kurtosis":"@stdlib/stats/base/dists/invgamma/kurtosis","base.dists.invgamma.logpdf":"@stdlib/stats/base/dists/invgamma/logpdf","base.dists.invgamma.mean":"@stdlib/stats/base/dists/invgamma/mean","base.dists.invgamma.mode":"@stdlib/stats/base/dists/invgamma/mode","base.dists.invgamma.pdf":"@stdlib/stats/base/dists/invgamma/pdf","base.dists.invgamma.quantile":"@stdlib/stats/base/dists/invgamma/quantile","base.dists.invgamma.skewness":"@stdlib/stats/base/dists/invgamma/skewness","base.dists.invgamma.stdev":"@stdlib/stats/base/dists/invgamma/stdev","base.dists.invgamma.variance":"@stdlib/stats/base/dists/invgamma/variance","base.dists.kumaraswamy.cdf":"@stdlib/stats/base/dists/kumaraswamy/cdf","base.dists.kumaraswamy.Kumaraswamy":"@stdlib/stats/base/dists/kumaraswamy/ctor","base.dists.kumaraswamy.kurtosis":"@stdlib/stats/base/dists/kumaraswamy/kurtosis","base.dists.kumaraswamy.logcdf":"@stdlib/stats/base/dists/kumaraswamy/logcdf","base.dists.kumaraswamy.logpdf":"@stdlib/stats/base/dists/kumaraswamy/logpdf","base.dists.kumaraswamy.mean":"@stdlib/stats/base/dists/kumaraswamy/mean","base.dists.kumaraswamy.median":"@stdlib/stats/base/dists/kumaraswamy/median","base.dists.kumaraswamy.mode":"@stdlib/stats/base/dists/kumaraswamy/mode","base.dists.kumaraswamy.pdf":"@stdlib/stats/base/dists/kumaraswamy/pdf","base.dists.kumaraswamy.quantile":"@stdlib/stats/base/dists/kumaraswamy/quantile","base.dists.kumaraswamy.skewness":"@stdlib/stats/base/dists/kumaraswamy/skewness","base.dists.kumaraswamy.stdev":"@stdlib/stats/base/dists/kumaraswamy/stdev","base.dists.kumaraswamy.variance":"@stdlib/stats/base/dists/kumaraswamy/variance","base.dists.laplace.cdf":"@stdlib/stats/base/dists/laplace/cdf","base.dists.laplace.entropy":"@stdlib/stats/base/dists/laplace/entropy","base.dists.laplace.kurtosis":"@stdlib/stats/base/dists/laplace/kurtosis","base.dists.laplace.Laplace":"@stdlib/stats/base/dists/laplace/ctor","base.dists.laplace.logcdf":"@stdlib/stats/base/dists/laplace/logcdf","base.dists.laplace.logpdf":"@stdlib/stats/base/dists/laplace/logpdf","base.dists.laplace.mean":"@stdlib/stats/base/dists/laplace/mean","base.dists.laplace.median":"@stdlib/stats/base/dists/laplace/median","base.dists.laplace.mgf":"@stdlib/stats/base/dists/laplace/mgf","base.dists.laplace.mode":"@stdlib/stats/base/dists/laplace/mode","base.dists.laplace.pdf":"@stdlib/stats/base/dists/laplace/pdf","base.dists.laplace.quantile":"@stdlib/stats/base/dists/laplace/quantile","base.dists.laplace.skewness":"@stdlib/stats/base/dists/laplace/skewness","base.dists.laplace.stdev":"@stdlib/stats/base/dists/laplace/stdev","base.dists.laplace.variance":"@stdlib/stats/base/dists/laplace/variance","base.dists.levy.cdf":"@stdlib/stats/base/dists/levy/cdf","base.dists.levy.entropy":"@stdlib/stats/base/dists/levy/entropy","base.dists.levy.Levy":"@stdlib/stats/base/dists/levy/ctor","base.dists.levy.logcdf":"@stdlib/stats/base/dists/levy/logcdf","base.dists.levy.logpdf":"@stdlib/stats/base/dists/levy/logpdf","base.dists.levy.mean":"@stdlib/stats/base/dists/levy/mean","base.dists.levy.median":"@stdlib/stats/base/dists/levy/median","base.dists.levy.mode":"@stdlib/stats/base/dists/levy/mode","base.dists.levy.pdf":"@stdlib/stats/base/dists/levy/pdf","base.dists.levy.quantile":"@stdlib/stats/base/dists/levy/quantile","base.dists.levy.stdev":"@stdlib/stats/base/dists/levy/stdev","base.dists.levy.variance":"@stdlib/stats/base/dists/levy/variance","base.dists.logistic.cdf":"@stdlib/stats/base/dists/logistic/cdf","base.dists.logistic.entropy":"@stdlib/stats/base/dists/logistic/entropy","base.dists.logistic.kurtosis":"@stdlib/stats/base/dists/logistic/kurtosis","base.dists.logistic.logcdf":"@stdlib/stats/base/dists/logistic/logcdf","base.dists.logistic.Logistic":"@stdlib/stats/base/dists/logistic/ctor","base.dists.logistic.logpdf":"@stdlib/stats/base/dists/logistic/logpdf","base.dists.logistic.mean":"@stdlib/stats/base/dists/logistic/mean","base.dists.logistic.median":"@stdlib/stats/base/dists/logistic/median","base.dists.logistic.mgf":"@stdlib/stats/base/dists/logistic/mgf","base.dists.logistic.mode":"@stdlib/stats/base/dists/logistic/mode","base.dists.logistic.pdf":"@stdlib/stats/base/dists/logistic/pdf","base.dists.logistic.quantile":"@stdlib/stats/base/dists/logistic/quantile","base.dists.logistic.skewness":"@stdlib/stats/base/dists/logistic/skewness","base.dists.logistic.stdev":"@stdlib/stats/base/dists/logistic/stdev","base.dists.logistic.variance":"@stdlib/stats/base/dists/logistic/variance","base.dists.lognormal.cdf":"@stdlib/stats/base/dists/lognormal/cdf","base.dists.lognormal.entropy":"@stdlib/stats/base/dists/lognormal/entropy","base.dists.lognormal.kurtosis":"@stdlib/stats/base/dists/lognormal/kurtosis","base.dists.lognormal.LogNormal":"@stdlib/stats/base/dists/lognormal/ctor","base.dists.lognormal.logcdf":"@stdlib/stats/base/dists/lognormal/logcdf","base.dists.lognormal.logpdf":"@stdlib/stats/base/dists/lognormal/logpdf","base.dists.lognormal.mean":"@stdlib/stats/base/dists/lognormal/mean","base.dists.lognormal.median":"@stdlib/stats/base/dists/lognormal/median","base.dists.lognormal.mode":"@stdlib/stats/base/dists/lognormal/mode","base.dists.lognormal.pdf":"@stdlib/stats/base/dists/lognormal/pdf","base.dists.lognormal.quantile":"@stdlib/stats/base/dists/lognormal/quantile","base.dists.lognormal.skewness":"@stdlib/stats/base/dists/lognormal/skewness","base.dists.lognormal.stdev":"@stdlib/stats/base/dists/lognormal/stdev","base.dists.lognormal.variance":"@stdlib/stats/base/dists/lognormal/variance","base.dists.negativeBinomial.cdf":"@stdlib/stats/base/dists/negative-binomial/cdf","base.dists.negativeBinomial.kurtosis":"@stdlib/stats/base/dists/negative-binomial/kurtosis","base.dists.negativeBinomial.logpmf":"@stdlib/stats/base/dists/negative-binomial/logpmf","base.dists.negativeBinomial.mean":"@stdlib/stats/base/dists/negative-binomial/mean","base.dists.negativeBinomial.mgf":"@stdlib/stats/base/dists/negative-binomial/mgf","base.dists.negativeBinomial.mode":"@stdlib/stats/base/dists/negative-binomial/mode","base.dists.negativeBinomial.NegativeBinomial":"@stdlib/stats/base/dists/negative-binomial/ctor","base.dists.negativeBinomial.pmf":"@stdlib/stats/base/dists/negative-binomial/pmf","base.dists.negativeBinomial.quantile":"@stdlib/stats/base/dists/negative-binomial/quantile","base.dists.negativeBinomial.skewness":"@stdlib/stats/base/dists/negative-binomial/skewness","base.dists.negativeBinomial.stdev":"@stdlib/stats/base/dists/negative-binomial/stdev","base.dists.negativeBinomial.variance":"@stdlib/stats/base/dists/negative-binomial/variance","base.dists.normal.cdf":"@stdlib/stats/base/dists/normal/cdf","base.dists.normal.entropy":"@stdlib/stats/base/dists/normal/entropy","base.dists.normal.kurtosis":"@stdlib/stats/base/dists/normal/kurtosis","base.dists.normal.logcdf":"@stdlib/stats/base/dists/normal/logcdf","base.dists.normal.logpdf":"@stdlib/stats/base/dists/normal/logpdf","base.dists.normal.mean":"@stdlib/stats/base/dists/normal/mean","base.dists.normal.median":"@stdlib/stats/base/dists/normal/median","base.dists.normal.mgf":"@stdlib/stats/base/dists/normal/mgf","base.dists.normal.mode":"@stdlib/stats/base/dists/normal/mode","base.dists.normal.Normal":"@stdlib/stats/base/dists/normal/ctor","base.dists.normal.pdf":"@stdlib/stats/base/dists/normal/pdf","base.dists.normal.quantile":"@stdlib/stats/base/dists/normal/quantile","base.dists.normal.skewness":"@stdlib/stats/base/dists/normal/skewness","base.dists.normal.stdev":"@stdlib/stats/base/dists/normal/stdev","base.dists.normal.variance":"@stdlib/stats/base/dists/normal/variance","base.dists.pareto1.cdf":"@stdlib/stats/base/dists/pareto-type1/cdf","base.dists.pareto1.entropy":"@stdlib/stats/base/dists/pareto-type1/entropy","base.dists.pareto1.kurtosis":"@stdlib/stats/base/dists/pareto-type1/kurtosis","base.dists.pareto1.logcdf":"@stdlib/stats/base/dists/pareto-type1/logcdf","base.dists.pareto1.logpdf":"@stdlib/stats/base/dists/pareto-type1/logpdf","base.dists.pareto1.mean":"@stdlib/stats/base/dists/pareto-type1/mean","base.dists.pareto1.median":"@stdlib/stats/base/dists/pareto-type1/median","base.dists.pareto1.mode":"@stdlib/stats/base/dists/pareto-type1/mode","base.dists.pareto1.Pareto1":"@stdlib/stats/base/dists/pareto-type1/ctor","base.dists.pareto1.pdf":"@stdlib/stats/base/dists/pareto-type1/pdf","base.dists.pareto1.quantile":"@stdlib/stats/base/dists/pareto-type1/quantile","base.dists.pareto1.skewness":"@stdlib/stats/base/dists/pareto-type1/skewness","base.dists.pareto1.stdev":"@stdlib/stats/base/dists/pareto-type1/stdev","base.dists.pareto1.variance":"@stdlib/stats/base/dists/pareto-type1/variance","base.dists.poisson.cdf":"@stdlib/stats/base/dists/poisson/cdf","base.dists.poisson.entropy":"@stdlib/stats/base/dists/poisson/entropy","base.dists.poisson.kurtosis":"@stdlib/stats/base/dists/poisson/kurtosis","base.dists.poisson.logpmf":"@stdlib/stats/base/dists/poisson/logpmf","base.dists.poisson.mean":"@stdlib/stats/base/dists/poisson/mean","base.dists.poisson.median":"@stdlib/stats/base/dists/poisson/median","base.dists.poisson.mgf":"@stdlib/stats/base/dists/poisson/mgf","base.dists.poisson.mode":"@stdlib/stats/base/dists/poisson/mode","base.dists.poisson.pmf":"@stdlib/stats/base/dists/poisson/pmf","base.dists.poisson.Poisson":"@stdlib/stats/base/dists/poisson/ctor","base.dists.poisson.quantile":"@stdlib/stats/base/dists/poisson/quantile","base.dists.poisson.skewness":"@stdlib/stats/base/dists/poisson/skewness","base.dists.poisson.stdev":"@stdlib/stats/base/dists/poisson/stdev","base.dists.poisson.variance":"@stdlib/stats/base/dists/poisson/variance","base.dists.rayleigh.cdf":"@stdlib/stats/base/dists/rayleigh/cdf","base.dists.rayleigh.entropy":"@stdlib/stats/base/dists/rayleigh/entropy","base.dists.rayleigh.kurtosis":"@stdlib/stats/base/dists/rayleigh/kurtosis","base.dists.rayleigh.logcdf":"@stdlib/stats/base/dists/rayleigh/logcdf","base.dists.rayleigh.logpdf":"@stdlib/stats/base/dists/rayleigh/logpdf","base.dists.rayleigh.mean":"@stdlib/stats/base/dists/rayleigh/mean","base.dists.rayleigh.median":"@stdlib/stats/base/dists/rayleigh/median","base.dists.rayleigh.mgf":"@stdlib/stats/base/dists/rayleigh/mgf","base.dists.rayleigh.mode":"@stdlib/stats/base/dists/rayleigh/mode","base.dists.rayleigh.pdf":"@stdlib/stats/base/dists/rayleigh/pdf","base.dists.rayleigh.quantile":"@stdlib/stats/base/dists/rayleigh/quantile","base.dists.rayleigh.Rayleigh":"@stdlib/stats/base/dists/rayleigh/ctor","base.dists.rayleigh.skewness":"@stdlib/stats/base/dists/rayleigh/skewness","base.dists.rayleigh.stdev":"@stdlib/stats/base/dists/rayleigh/stdev","base.dists.rayleigh.variance":"@stdlib/stats/base/dists/rayleigh/variance","base.dists.signrank.cdf":"@stdlib/stats/base/dists/signrank/cdf","base.dists.signrank.pdf":"@stdlib/stats/base/dists/signrank/pdf","base.dists.signrank.quantile":"@stdlib/stats/base/dists/signrank/quantile","base.dists.studentizedRange.cdf":"@stdlib/stats/base/dists/studentized-range/cdf","base.dists.studentizedRange.quantile":"@stdlib/stats/base/dists/studentized-range/quantile","base.dists.t.cdf":"@stdlib/stats/base/dists/t/cdf","base.dists.t.entropy":"@stdlib/stats/base/dists/t/entropy","base.dists.t.kurtosis":"@stdlib/stats/base/dists/t/kurtosis","base.dists.t.logcdf":"@stdlib/stats/base/dists/t/logcdf","base.dists.t.logpdf":"@stdlib/stats/base/dists/t/logpdf","base.dists.t.mean":"@stdlib/stats/base/dists/t/mean","base.dists.t.median":"@stdlib/stats/base/dists/t/median","base.dists.t.mode":"@stdlib/stats/base/dists/t/mode","base.dists.t.pdf":"@stdlib/stats/base/dists/t/pdf","base.dists.t.quantile":"@stdlib/stats/base/dists/t/quantile","base.dists.t.skewness":"@stdlib/stats/base/dists/t/skewness","base.dists.t.stdev":"@stdlib/stats/base/dists/t/stdev","base.dists.t.T":"@stdlib/stats/base/dists/t/ctor","base.dists.t.variance":"@stdlib/stats/base/dists/t/variance","base.dists.triangular.cdf":"@stdlib/stats/base/dists/triangular/cdf","base.dists.triangular.entropy":"@stdlib/stats/base/dists/triangular/entropy","base.dists.triangular.kurtosis":"@stdlib/stats/base/dists/triangular/kurtosis","base.dists.triangular.logcdf":"@stdlib/stats/base/dists/triangular/logcdf","base.dists.triangular.logpdf":"@stdlib/stats/base/dists/triangular/logpdf","base.dists.triangular.mean":"@stdlib/stats/base/dists/triangular/mean","base.dists.triangular.median":"@stdlib/stats/base/dists/triangular/median","base.dists.triangular.mgf":"@stdlib/stats/base/dists/triangular/mgf","base.dists.triangular.mode":"@stdlib/stats/base/dists/triangular/mode","base.dists.triangular.pdf":"@stdlib/stats/base/dists/triangular/pdf","base.dists.triangular.quantile":"@stdlib/stats/base/dists/triangular/quantile","base.dists.triangular.skewness":"@stdlib/stats/base/dists/triangular/skewness","base.dists.triangular.stdev":"@stdlib/stats/base/dists/triangular/stdev","base.dists.triangular.Triangular":"@stdlib/stats/base/dists/triangular/ctor","base.dists.triangular.variance":"@stdlib/stats/base/dists/triangular/variance","base.dists.truncatedNormal.pdf":"@stdlib/stats/base/dists/truncated-normal/pdf","base.dists.uniform.cdf":"@stdlib/stats/base/dists/uniform/cdf","base.dists.uniform.entropy":"@stdlib/stats/base/dists/uniform/entropy","base.dists.uniform.kurtosis":"@stdlib/stats/base/dists/uniform/kurtosis","base.dists.uniform.logcdf":"@stdlib/stats/base/dists/uniform/logcdf","base.dists.uniform.logpdf":"@stdlib/stats/base/dists/uniform/logpdf","base.dists.uniform.mean":"@stdlib/stats/base/dists/uniform/mean","base.dists.uniform.median":"@stdlib/stats/base/dists/uniform/median","base.dists.uniform.mgf":"@stdlib/stats/base/dists/uniform/mgf","base.dists.uniform.pdf":"@stdlib/stats/base/dists/uniform/pdf","base.dists.uniform.quantile":"@stdlib/stats/base/dists/uniform/quantile","base.dists.uniform.skewness":"@stdlib/stats/base/dists/uniform/skewness","base.dists.uniform.stdev":"@stdlib/stats/base/dists/uniform/stdev","base.dists.uniform.Uniform":"@stdlib/stats/base/dists/uniform/ctor","base.dists.uniform.variance":"@stdlib/stats/base/dists/uniform/variance","base.dists.weibull.cdf":"@stdlib/stats/base/dists/weibull/cdf","base.dists.weibull.entropy":"@stdlib/stats/base/dists/weibull/entropy","base.dists.weibull.kurtosis":"@stdlib/stats/base/dists/weibull/kurtosis","base.dists.weibull.logcdf":"@stdlib/stats/base/dists/weibull/logcdf","base.dists.weibull.logpdf":"@stdlib/stats/base/dists/weibull/logpdf","base.dists.weibull.mean":"@stdlib/stats/base/dists/weibull/mean","base.dists.weibull.median":"@stdlib/stats/base/dists/weibull/median","base.dists.weibull.mgf":"@stdlib/stats/base/dists/weibull/mgf","base.dists.weibull.mode":"@stdlib/stats/base/dists/weibull/mode","base.dists.weibull.pdf":"@stdlib/stats/base/dists/weibull/pdf","base.dists.weibull.quantile":"@stdlib/stats/base/dists/weibull/quantile","base.dists.weibull.skewness":"@stdlib/stats/base/dists/weibull/skewness","base.dists.weibull.stdev":"@stdlib/stats/base/dists/weibull/stdev","base.dists.weibull.variance":"@stdlib/stats/base/dists/weibull/variance","base.dists.weibull.Weibull":"@stdlib/stats/base/dists/weibull/ctor","base.ellipe":"@stdlib/math/base/special/ellipe","base.ellipj":"@stdlib/math/base/special/ellipj","base.ellipk":"@stdlib/math/base/special/ellipk","base.endsWith":"@stdlib/string/base/ends-with","base.epsdiff":"@stdlib/math/base/utils/float64-epsilon-difference","base.erf":"@stdlib/math/base/special/erf","base.erfc":"@stdlib/math/base/special/erfc","base.erfcinv":"@stdlib/math/base/special/erfcinv","base.erfcx":"@stdlib/math/base/special/erfcx","base.erfinv":"@stdlib/math/base/special/erfinv","base.eta":"@stdlib/math/base/special/dirichlet-eta","base.evalpoly":"@stdlib/math/base/tools/evalpoly","base.evalrational":"@stdlib/math/base/tools/evalrational","base.exp":"@stdlib/math/base/special/exp","base.exp2":"@stdlib/math/base/special/exp2","base.exp10":"@stdlib/math/base/special/exp10","base.expit":"@stdlib/math/base/special/expit","base.expm1":"@stdlib/math/base/special/expm1","base.expm1rel":"@stdlib/math/base/special/expm1rel","base.exponent":"@stdlib/number/float64/base/exponent","base.exponentf":"@stdlib/number/float32/base/exponent","base.factorial":"@stdlib/math/base/special/factorial","base.factorial2":"@stdlib/math/base/special/factorial2","base.factorialln":"@stdlib/math/base/special/factorialln","base.fallingFactorial":"@stdlib/math/base/special/falling-factorial","base.fibonacci":"@stdlib/math/base/special/fibonacci","base.fibonacciIndex":"@stdlib/math/base/special/fibonacci-index","base.fibpoly":"@stdlib/math/base/tools/fibpoly","base.firstCodePoint":"@stdlib/string/base/first-code-point","base.firstCodeUnit":"@stdlib/string/base/first","base.firstGraphemeCluster":"@stdlib/string/base/first-grapheme-cluster","base.flipsign":"@stdlib/math/base/special/flipsign","base.flipsignf":"@stdlib/math/base/special/flipsignf","base.float32ToInt32":"@stdlib/number/float32/base/to-int32","base.float32ToUint32":"@stdlib/number/float32/base/to-uint32","base.float64ToFloat32":"@stdlib/number/float64/base/to-float32","base.float64ToInt32":"@stdlib/number/float64/base/to-int32","base.float64ToInt64Bytes":"@stdlib/number/float64/base/to-int64-bytes","base.float64ToUint32":"@stdlib/number/float64/base/to-uint32","base.floor":"@stdlib/math/base/special/floor","base.floor2":"@stdlib/math/base/special/floor2","base.floor10":"@stdlib/math/base/special/floor10","base.floorb":"@stdlib/math/base/special/floorb","base.floorf":"@stdlib/math/base/special/floorf","base.floorn":"@stdlib/math/base/special/floorn","base.floorsd":"@stdlib/math/base/special/floorsd","base.forEachChar":"@stdlib/string/base/for-each","base.forEachCodePoint":"@stdlib/string/base/for-each-code-point","base.forEachCodePointRight":"@stdlib/string/base/for-each-code-point-right","base.forEachGraphemeCluster":"@stdlib/string/base/for-each-grapheme-cluster","base.forEachRight":"@stdlib/string/base/for-each-right","base.formatInterpolate":"@stdlib/string/base/format-interpolate","base.formatTokenize":"@stdlib/string/base/format-tokenize","base.fresnel":"@stdlib/math/base/special/fresnel","base.fresnelc":"@stdlib/math/base/special/fresnelc","base.fresnels":"@stdlib/math/base/special/fresnels","base.frexp":"@stdlib/math/base/special/frexp","base.fromBinaryString":"@stdlib/number/float64/base/from-binary-string","base.fromBinaryStringf":"@stdlib/number/float32/base/from-binary-string","base.fromBinaryStringUint8":"@stdlib/number/uint8/base/from-binary-string","base.fromBinaryStringUint16":"@stdlib/number/uint16/base/from-binary-string","base.fromBinaryStringUint32":"@stdlib/number/uint32/base/from-binary-string","base.fromInt64Bytes":"@stdlib/number/float64/base/from-int64-bytes","base.fromWordf":"@stdlib/number/float32/base/from-word","base.fromWords":"@stdlib/number/float64/base/from-words","base.gamma":"@stdlib/math/base/special/gamma","base.gamma1pm1":"@stdlib/math/base/special/gamma1pm1","base.gammaDeltaRatio":"@stdlib/math/base/special/gamma-delta-ratio","base.gammainc":"@stdlib/math/base/special/gammainc","base.gammaincinv":"@stdlib/math/base/special/gammaincinv","base.gammaLanczosSum":"@stdlib/math/base/special/gamma-lanczos-sum","base.gammaLanczosSumExpGScaled":"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled","base.gammaln":"@stdlib/math/base/special/gammaln","base.gammasgn":"@stdlib/math/base/special/gammasgn","base.gcd":"@stdlib/math/base/special/gcd","base.getHighWord":"@stdlib/number/float64/base/get-high-word","base.getLowWord":"@stdlib/number/float64/base/get-low-word","base.hacovercos":"@stdlib/math/base/special/hacovercos","base.hacoversin":"@stdlib/math/base/special/hacoversin","base.havercos":"@stdlib/math/base/special/havercos","base.haversin":"@stdlib/math/base/special/haversin","base.headercase":"@stdlib/string/base/headercase","base.heaviside":"@stdlib/math/base/special/heaviside","base.hermitepoly":"@stdlib/math/base/tools/hermitepoly","base.hypot":"@stdlib/math/base/special/hypot","base.hypotf":"@stdlib/math/base/special/hypotf","base.identity":"@stdlib/math/base/special/identity","base.identityf":"@stdlib/math/base/special/identityf","base.imul":"@stdlib/math/base/ops/imul","base.imuldw":"@stdlib/math/base/ops/imuldw","base.int2slice":"@stdlib/slice/base/int2slice","base.int32ToUint32":"@stdlib/number/int32/base/to-uint32","base.inv":"@stdlib/math/base/special/inv","base.invcase":"@stdlib/string/base/invcase","base.invf":"@stdlib/math/base/special/invf","base.isComposite":"@stdlib/math/base/assert/is-composite","base.isCoprime":"@stdlib/math/base/assert/is-coprime","base.isEven":"@stdlib/math/base/assert/is-even","base.isEvenInt32":"@stdlib/math/base/assert/int32-is-even","base.isFinite":"@stdlib/math/base/assert/is-finite","base.isFinitef":"@stdlib/math/base/assert/is-finitef","base.isInfinite":"@stdlib/math/base/assert/is-infinite","base.isInfinitef":"@stdlib/math/base/assert/is-infinitef","base.isInteger":"@stdlib/math/base/assert/is-integer","base.isnan":"@stdlib/math/base/assert/is-nan","base.isnanf":"@stdlib/math/base/assert/is-nanf","base.isNegativeFinite":"@stdlib/math/base/assert/is-negative-finite","base.isNegativeInteger":"@stdlib/math/base/assert/is-negative-integer","base.isNegativeZero":"@stdlib/math/base/assert/is-negative-zero","base.isNegativeZerof":"@stdlib/math/base/assert/is-negative-zerof","base.isNonNegativeFinite":"@stdlib/math/base/assert/is-nonnegative-finite","base.isNonNegativeInteger":"@stdlib/math/base/assert/is-nonnegative-integer","base.isNonPositiveFinite":"@stdlib/math/base/assert/is-nonpositive-finite","base.isNonPositiveInteger":"@stdlib/math/base/assert/is-nonpositive-integer","base.isOdd":"@stdlib/math/base/assert/is-odd","base.isOddInt32":"@stdlib/math/base/assert/int32-is-odd","base.isPositiveFinite":"@stdlib/math/base/assert/is-positive-finite","base.isPositiveInteger":"@stdlib/math/base/assert/is-positive-integer","base.isPositiveZero":"@stdlib/math/base/assert/is-positive-zero","base.isPositiveZerof":"@stdlib/math/base/assert/is-positive-zerof","base.isPow2Uint32":"@stdlib/math/base/assert/uint32-is-pow2","base.isPrime":"@stdlib/math/base/assert/is-prime","base.isProbability":"@stdlib/math/base/assert/is-probability","base.isSafeInteger":"@stdlib/math/base/assert/is-safe-integer","base.kebabcase":"@stdlib/string/base/kebabcase","base.kernelBetainc":"@stdlib/math/base/special/kernel-betainc","base.kernelBetaincinv":"@stdlib/math/base/special/kernel-betaincinv","base.kernelCos":"@stdlib/math/base/special/kernel-cos","base.kernelLog1p":"@stdlib/math/base/special/kernel-log1p","base.kernelSin":"@stdlib/math/base/special/kernel-sin","base.kernelTan":"@stdlib/math/base/special/kernel-tan","base.kroneckerDelta":"@stdlib/math/base/special/kronecker-delta","base.kroneckerDeltaf":"@stdlib/math/base/special/kronecker-deltaf","base.labs":"@stdlib/math/base/special/labs","base.last":"@stdlib/string/base/last","base.lastCodePoint":"@stdlib/string/base/last-code-point","base.lastGraphemeCluster":"@stdlib/string/base/last-grapheme-cluster","base.lcm":"@stdlib/math/base/special/lcm","base.ldexp":"@stdlib/math/base/special/ldexp","base.leftPad":"@stdlib/string/base/left-pad","base.leftTrim":"@stdlib/string/base/left-trim","base.ln":"@stdlib/math/base/special/ln","base.log":"@stdlib/math/base/special/log","base.log1mexp":"@stdlib/math/base/special/log1mexp","base.log1p":"@stdlib/math/base/special/log1p","base.log1pexp":"@stdlib/math/base/special/log1pexp","base.log1pmx":"@stdlib/math/base/special/log1pmx","base.log2":"@stdlib/math/base/special/log2","base.log10":"@stdlib/math/base/special/log10","base.logaddexp":"@stdlib/math/base/special/logaddexp","base.logit":"@stdlib/math/base/special/logit","base.lowercase":"@stdlib/string/base/lowercase","base.lucas":"@stdlib/math/base/special/lucas","base.lucaspoly":"@stdlib/math/base/tools/lucaspoly","base.max":"@stdlib/math/base/special/max","base.maxabs":"@stdlib/math/base/special/maxabs","base.maxabsn":"@stdlib/math/base/special/maxabsn","base.maxn":"@stdlib/math/base/special/maxn","base.min":"@stdlib/math/base/special/min","base.minabs":"@stdlib/math/base/special/minabs","base.minabsn":"@stdlib/math/base/special/minabsn","base.minmax":"@stdlib/math/base/special/minmax","base.minmaxabs":"@stdlib/math/base/special/minmaxabs","base.minmaxabsn":"@stdlib/math/base/special/minmaxabsn","base.minmaxn":"@stdlib/math/base/special/minmaxn","base.minn":"@stdlib/math/base/special/minn","base.modf":"@stdlib/math/base/special/modf","base.mul":"@stdlib/number/float64/base/mul","base.mulf":"@stdlib/number/float32/base/mul","base.ndarray":"@stdlib/ndarray/base/ctor","base.ndarrayUnary":"@stdlib/ndarray/base/unary","base.ndzeros":"@stdlib/ndarray/base/zeros","base.ndzerosLike":"@stdlib/ndarray/base/zeros-like","base.negafibonacci":"@stdlib/math/base/special/negafibonacci","base.negalucas":"@stdlib/math/base/special/negalucas","base.nonfibonacci":"@stdlib/math/base/special/nonfibonacci","base.normalize":"@stdlib/number/float64/base/normalize","base.normalizef":"@stdlib/number/float32/base/normalize","base.normalizeMultiSlice":"@stdlib/slice/base/normalize-multi-slice","base.normalizeSlice":"@stdlib/slice/base/normalize-slice","base.normhermitepoly":"@stdlib/math/base/tools/normhermitepoly","base.pascalcase":"@stdlib/string/base/pascalcase","base.pdiff":"@stdlib/math/base/special/pdiff","base.pdifff":"@stdlib/math/base/special/pdifff","base.percentEncode":"@stdlib/string/base/percent-encode","base.polygamma":"@stdlib/math/base/special/polygamma","base.pow":"@stdlib/math/base/special/pow","base.powm1":"@stdlib/math/base/special/powm1","base.rad2deg":"@stdlib/math/base/special/rad2deg","base.rad2degf":"@stdlib/math/base/special/rad2degf","base.ramp":"@stdlib/math/base/special/ramp","base.rampf":"@stdlib/math/base/special/rampf","base.random.arcsine":"@stdlib/random/base/arcsine","base.random.bernoulli":"@stdlib/random/base/bernoulli","base.random.beta":"@stdlib/random/base/beta","base.random.betaprime":"@stdlib/random/base/betaprime","base.random.binomial":"@stdlib/random/base/binomial","base.random.boxMuller":"@stdlib/random/base/box-muller","base.random.cauchy":"@stdlib/random/base/cauchy","base.random.chi":"@stdlib/random/base/chi","base.random.chisquare":"@stdlib/random/base/chisquare","base.random.cosine":"@stdlib/random/base/cosine","base.random.discreteUniform":"@stdlib/random/base/discrete-uniform","base.random.erlang":"@stdlib/random/base/erlang","base.random.exponential":"@stdlib/random/base/exponential","base.random.f":"@stdlib/random/base/f","base.random.frechet":"@stdlib/random/base/frechet","base.random.gamma":"@stdlib/random/base/gamma","base.random.geometric":"@stdlib/random/base/geometric","base.random.gumbel":"@stdlib/random/base/gumbel","base.random.hypergeometric":"@stdlib/random/base/hypergeometric","base.random.improvedZiggurat":"@stdlib/random/base/improved-ziggurat","base.random.invgamma":"@stdlib/random/base/invgamma","base.random.kumaraswamy":"@stdlib/random/base/kumaraswamy","base.random.laplace":"@stdlib/random/base/laplace","base.random.levy":"@stdlib/random/base/levy","base.random.logistic":"@stdlib/random/base/logistic","base.random.lognormal":"@stdlib/random/base/lognormal","base.random.minstd":"@stdlib/random/base/minstd","base.random.minstdShuffle":"@stdlib/random/base/minstd-shuffle","base.random.mt19937":"@stdlib/random/base/mt19937","base.random.negativeBinomial":"@stdlib/random/base/negative-binomial","base.random.normal":"@stdlib/random/base/normal","base.random.pareto1":"@stdlib/random/base/pareto-type1","base.random.poisson":"@stdlib/random/base/poisson","base.random.randi":"@stdlib/random/base/randi","base.random.randn":"@stdlib/random/base/randn","base.random.randu":"@stdlib/random/base/randu","base.random.rayleigh":"@stdlib/random/base/rayleigh","base.random.t":"@stdlib/random/base/t","base.random.triangular":"@stdlib/random/base/triangular","base.random.uniform":"@stdlib/random/base/uniform","base.random.weibull":"@stdlib/random/base/weibull","base.rcbrt":"@stdlib/math/base/special/rcbrt","base.rcbrtf":"@stdlib/math/base/special/rcbrtf","base.reldiff":"@stdlib/math/base/utils/relative-difference","base.removeFirst":"@stdlib/string/base/remove-first","base.removeFirstCodePoint":"@stdlib/string/base/remove-first-code-point","base.removeFirstGraphemeCluster":"@stdlib/string/base/remove-first-grapheme-cluster","base.removeLast":"@stdlib/string/base/remove-last","base.removeLastCodePoint":"@stdlib/string/base/remove-last-code-point","base.removeLastGraphemeCluster":"@stdlib/string/base/remove-last-grapheme-cluster","base.rempio2":"@stdlib/math/base/special/rempio2","base.repeat":"@stdlib/string/base/repeat","base.replace":"@stdlib/string/base/replace","base.replaceAfter":"@stdlib/string/base/replace-after","base.replaceAfterLast":"@stdlib/string/base/replace-after-last","base.replaceBefore":"@stdlib/string/base/replace-before","base.replaceBeforeLast":"@stdlib/string/base/replace-before-last","base.reverse":"@stdlib/string/base/reverse","base.reverseCodePoints":"@stdlib/string/base/reverse-code-points","base.reverseGraphemeClusters":"@stdlib/string/base/reverse-grapheme-clusters","base.rightPad":"@stdlib/string/base/right-pad","base.rightTrim":"@stdlib/string/base/right-trim","base.risingFactorial":"@stdlib/math/base/special/rising-factorial","base.rotl32":"@stdlib/number/uint32/base/rotl","base.rotr32":"@stdlib/number/uint32/base/rotr","base.round":"@stdlib/math/base/special/round","base.round2":"@stdlib/math/base/special/round2","base.round10":"@stdlib/math/base/special/round10","base.roundb":"@stdlib/math/base/special/roundb","base.roundn":"@stdlib/math/base/special/roundn","base.roundsd":"@stdlib/math/base/special/roundsd","base.rsqrt":"@stdlib/math/base/special/rsqrt","base.rsqrtf":"@stdlib/math/base/special/rsqrtf","base.sargs2multislice":"@stdlib/slice/base/sargs2multislice","base.scalar2ndarray":"@stdlib/ndarray/base/from-scalar","base.secd":"@stdlib/math/base/special/secd","base.seq2multislice":"@stdlib/slice/base/seq2multislice","base.seq2slice":"@stdlib/slice/base/seq2slice","base.setHighWord":"@stdlib/number/float64/base/set-high-word","base.setLowWord":"@stdlib/number/float64/base/set-low-word","base.sici":"@stdlib/math/base/special/sici","base.signbit":"@stdlib/number/float64/base/signbit","base.signbitf":"@stdlib/number/float32/base/signbit","base.significandf":"@stdlib/number/float32/base/significand","base.signum":"@stdlib/math/base/special/signum","base.signumf":"@stdlib/math/base/special/signumf","base.sin":"@stdlib/math/base/special/sin","base.sinc":"@stdlib/math/base/special/sinc","base.sincos":"@stdlib/math/base/special/sincos","base.sincospi":"@stdlib/math/base/special/sincospi","base.sinh":"@stdlib/math/base/special/sinh","base.sinpi":"@stdlib/math/base/special/sinpi","base.slice2seq":"@stdlib/slice/base/slice2seq","base.sliceLength":"@stdlib/slice/base/length","base.sliceNonReducedDimensions":"@stdlib/slice/base/nonreduced-dimensions","base.sliceReducedDimensions":"@stdlib/slice/base/reduced-dimensions","base.sliceShape":"@stdlib/slice/base/shape","base.snakecase":"@stdlib/string/base/snakecase","base.spence":"@stdlib/math/base/special/spence","base.sqrt":"@stdlib/math/base/special/sqrt","base.sqrt1pm1":"@stdlib/math/base/special/sqrt1pm1","base.sqrtf":"@stdlib/math/base/special/sqrtf","base.sqrtpi":"@stdlib/math/base/special/sqrtpi","base.startcase":"@stdlib/string/base/startcase","base.startsWith":"@stdlib/string/base/starts-with","base.stickycase":"@stdlib/string/base/stickycase","base.strided.binary":"@stdlib/strided/base/binary","base.strided.binaryDtypeSignatures":"@stdlib/strided/base/binary-dtype-signatures","base.strided.binarySignatureCallbacks":"@stdlib/strided/base/binary-signature-callbacks","base.strided.ccopy":"@stdlib/blas/base/ccopy","base.strided.cmap":"@stdlib/strided/base/cmap","base.strided.cswap":"@stdlib/blas/base/cswap","base.strided.cumax":"@stdlib/stats/base/cumax","base.strided.cumaxabs":"@stdlib/stats/base/cumaxabs","base.strided.cumin":"@stdlib/stats/base/cumin","base.strided.cuminabs":"@stdlib/stats/base/cuminabs","base.strided.dabs":"@stdlib/math/strided/special/dabs","base.strided.dabs2":"@stdlib/math/strided/special/dabs2","base.strided.dapx":"@stdlib/blas/ext/base/dapx","base.strided.dapxsum":"@stdlib/blas/ext/base/dapxsum","base.strided.dapxsumkbn":"@stdlib/blas/ext/base/dapxsumkbn","base.strided.dapxsumkbn2":"@stdlib/blas/ext/base/dapxsumkbn2","base.strided.dapxsumors":"@stdlib/blas/ext/base/dapxsumors","base.strided.dapxsumpw":"@stdlib/blas/ext/base/dapxsumpw","base.strided.dasum":"@stdlib/blas/base/dasum","base.strided.dasumpw":"@stdlib/blas/ext/base/dasumpw","base.strided.daxpy":"@stdlib/blas/base/daxpy","base.strided.dcbrt":"@stdlib/math/strided/special/dcbrt","base.strided.dceil":"@stdlib/math/strided/special/dceil","base.strided.dcopy":"@stdlib/blas/base/dcopy","base.strided.dcumax":"@stdlib/stats/strided/dcumax","base.strided.dcumaxabs":"@stdlib/stats/strided/dcumaxabs","base.strided.dcumin":"@stdlib/stats/base/dcumin","base.strided.dcuminabs":"@stdlib/stats/strided/dcuminabs","base.strided.dcusum":"@stdlib/blas/ext/base/dcusum","base.strided.dcusumkbn":"@stdlib/blas/ext/base/dcusumkbn","base.strided.dcusumkbn2":"@stdlib/blas/ext/base/dcusumkbn2","base.strided.dcusumors":"@stdlib/blas/ext/base/dcusumors","base.strided.dcusumpw":"@stdlib/blas/ext/base/dcusumpw","base.strided.ddeg2rad":"@stdlib/math/strided/special/ddeg2rad","base.strided.ddot":"@stdlib/blas/base/ddot","base.strided.dfill":"@stdlib/blas/ext/base/dfill","base.strided.dfloor":"@stdlib/math/strided/special/dfloor","base.strided.dinv":"@stdlib/math/strided/special/dinv","base.strided.dmap":"@stdlib/strided/base/dmap","base.strided.dmap2":"@stdlib/strided/base/dmap2","base.strided.dmax":"@stdlib/stats/strided/dmax","base.strided.dmaxabs":"@stdlib/stats/strided/dmaxabs","base.strided.dmaxabssorted":"@stdlib/stats/strided/dmaxabssorted","base.strided.dmaxsorted":"@stdlib/stats/strided/dmaxsorted","base.strided.dmean":"@stdlib/stats/base/dmean","base.strided.dmeankbn":"@stdlib/stats/strided/dmeankbn","base.strided.dmeankbn2":"@stdlib/stats/strided/dmeankbn2","base.strided.dmeanli":"@stdlib/stats/strided/dmeanli","base.strided.dmeanlipw":"@stdlib/stats/strided/dmeanlipw","base.strided.dmeanors":"@stdlib/stats/strided/dmeanors","base.strided.dmeanpn":"@stdlib/stats/base/dmeanpn","base.strided.dmeanpw":"@stdlib/stats/strided/dmeanpw","base.strided.dmeanstdev":"@stdlib/stats/base/dmeanstdev","base.strided.dmeanstdevpn":"@stdlib/stats/base/dmeanstdevpn","base.strided.dmeanvar":"@stdlib/stats/base/dmeanvar","base.strided.dmeanvarpn":"@stdlib/stats/base/dmeanvarpn","base.strided.dmeanwd":"@stdlib/stats/strided/dmeanwd","base.strided.dmediansorted":"@stdlib/stats/strided/dmediansorted","base.strided.dmidrange":"@stdlib/stats/strided/dmidrange","base.strided.dmin":"@stdlib/stats/strided/dmin","base.strided.dminabs":"@stdlib/stats/strided/dminabs","base.strided.dminsorted":"@stdlib/stats/strided/dminsorted","base.strided.dmskabs":"@stdlib/math/strided/special/dmskabs","base.strided.dmskabs2":"@stdlib/math/strided/special/dmskabs2","base.strided.dmskcbrt":"@stdlib/math/strided/special/dmskcbrt","base.strided.dmskceil":"@stdlib/math/strided/special/dmskceil","base.strided.dmskdeg2rad":"@stdlib/math/strided/special/dmskdeg2rad","base.strided.dmskfloor":"@stdlib/math/strided/special/dmskfloor","base.strided.dmskinv":"@stdlib/math/strided/special/dmskinv","base.strided.dmskmap":"@stdlib/strided/base/dmskmap","base.strided.dmskmap2":"@stdlib/strided/base/dmskmap2","base.strided.dmskmax":"@stdlib/stats/base/dmskmax","base.strided.dmskmin":"@stdlib/stats/base/dmskmin","base.strided.dmskramp":"@stdlib/math/strided/special/dmskramp","base.strided.dmskrange":"@stdlib/stats/base/dmskrange","base.strided.dmskrsqrt":"@stdlib/math/strided/special/dmskrsqrt","base.strided.dmsksqrt":"@stdlib/math/strided/special/dmsksqrt","base.strided.dmsktrunc":"@stdlib/math/strided/special/dmsktrunc","base.strided.dnanasum":"@stdlib/blas/ext/base/dnanasum","base.strided.dnanasumors":"@stdlib/blas/ext/base/dnanasumors","base.strided.dnanmax":"@stdlib/stats/strided/dnanmax","base.strided.dnanmaxabs":"@stdlib/stats/strided/dnanmaxabs","base.strided.dnanmean":"@stdlib/stats/strided/dnanmean","base.strided.dnanmeanors":"@stdlib/stats/base/dnanmeanors","base.strided.dnanmeanpn":"@stdlib/stats/base/dnanmeanpn","base.strided.dnanmeanpw":"@stdlib/stats/base/dnanmeanpw","base.strided.dnanmeanwd":"@stdlib/stats/base/dnanmeanwd","base.strided.dnanmin":"@stdlib/stats/base/dnanmin","base.strided.dnanminabs":"@stdlib/stats/base/dnanminabs","base.strided.dnanmskmax":"@stdlib/stats/base/dnanmskmax","base.strided.dnanmskmin":"@stdlib/stats/base/dnanmskmin","base.strided.dnanmskrange":"@stdlib/stats/base/dnanmskrange","base.strided.dnannsum":"@stdlib/blas/ext/base/dnannsum","base.strided.dnannsumkbn":"@stdlib/blas/ext/base/dnannsumkbn","base.strided.dnannsumkbn2":"@stdlib/blas/ext/base/dnannsumkbn2","base.strided.dnannsumors":"@stdlib/blas/ext/base/dnannsumors","base.strided.dnannsumpw":"@stdlib/blas/ext/base/dnannsumpw","base.strided.dnanrange":"@stdlib/stats/base/dnanrange","base.strided.dnanstdev":"@stdlib/stats/base/dnanstdev","base.strided.dnanstdevch":"@stdlib/stats/base/dnanstdevch","base.strided.dnanstdevpn":"@stdlib/stats/base/dnanstdevpn","base.strided.dnanstdevtk":"@stdlib/stats/base/dnanstdevtk","base.strided.dnanstdevwd":"@stdlib/stats/base/dnanstdevwd","base.strided.dnanstdevyc":"@stdlib/stats/base/dnanstdevyc","base.strided.dnansum":"@stdlib/blas/ext/base/dnansum","base.strided.dnansumkbn":"@stdlib/blas/ext/base/dnansumkbn","base.strided.dnansumkbn2":"@stdlib/blas/ext/base/dnansumkbn2","base.strided.dnansumors":"@stdlib/blas/ext/base/dnansumors","base.strided.dnansumpw":"@stdlib/blas/ext/base/dnansumpw","base.strided.dnanvariance":"@stdlib/stats/base/dnanvariance","base.strided.dnanvariancech":"@stdlib/stats/base/dnanvariancech","base.strided.dnanvariancepn":"@stdlib/stats/base/dnanvariancepn","base.strided.dnanvariancetk":"@stdlib/stats/base/dnanvariancetk","base.strided.dnanvariancewd":"@stdlib/stats/base/dnanvariancewd","base.strided.dnanvarianceyc":"@stdlib/stats/base/dnanvarianceyc","base.strided.dnrm2":"@stdlib/blas/base/dnrm2","base.strided.dramp":"@stdlib/math/strided/special/dramp","base.strided.drange":"@stdlib/stats/base/drange","base.strided.drev":"@stdlib/blas/ext/base/drev","base.strided.drsqrt":"@stdlib/math/strided/special/drsqrt","base.strided.dsapxsum":"@stdlib/blas/ext/base/dsapxsum","base.strided.dsapxsumpw":"@stdlib/blas/ext/base/dsapxsumpw","base.strided.dscal":"@stdlib/blas/base/dscal","base.strided.dsdot":"@stdlib/blas/base/dsdot","base.strided.dsem":"@stdlib/stats/base/dsem","base.strided.dsemch":"@stdlib/stats/base/dsemch","base.strided.dsempn":"@stdlib/stats/base/dsempn","base.strided.dsemtk":"@stdlib/stats/base/dsemtk","base.strided.dsemwd":"@stdlib/stats/base/dsemwd","base.strided.dsemyc":"@stdlib/stats/base/dsemyc","base.strided.dsmean":"@stdlib/stats/base/dsmean","base.strided.dsmeanors":"@stdlib/stats/base/dsmeanors","base.strided.dsmeanpn":"@stdlib/stats/base/dsmeanpn","base.strided.dsmeanpw":"@stdlib/stats/base/dsmeanpw","base.strided.dsmeanwd":"@stdlib/stats/base/dsmeanwd","base.strided.dsnanmean":"@stdlib/stats/base/dsnanmean","base.strided.dsnanmeanors":"@stdlib/stats/base/dsnanmeanors","base.strided.dsnanmeanpn":"@stdlib/stats/base/dsnanmeanpn","base.strided.dsnanmeanwd":"@stdlib/stats/base/dsnanmeanwd","base.strided.dsnannsumors":"@stdlib/blas/ext/base/dsnannsumors","base.strided.dsnansum":"@stdlib/blas/ext/base/dsnansum","base.strided.dsnansumors":"@stdlib/blas/ext/base/dsnansumors","base.strided.dsnansumpw":"@stdlib/blas/ext/base/dsnansumpw","base.strided.dsort2hp":"@stdlib/blas/ext/base/dsort2hp","base.strided.dsort2ins":"@stdlib/blas/ext/base/dsort2ins","base.strided.dsort2sh":"@stdlib/blas/ext/base/dsort2sh","base.strided.dsorthp":"@stdlib/blas/ext/base/dsorthp","base.strided.dsortins":"@stdlib/blas/ext/base/dsortins","base.strided.dsortsh":"@stdlib/blas/ext/base/dsortsh","base.strided.dsqrt":"@stdlib/math/strided/special/dsqrt","base.strided.dssum":"@stdlib/blas/ext/base/dssum","base.strided.dssumors":"@stdlib/blas/ext/base/dssumors","base.strided.dssumpw":"@stdlib/blas/ext/base/dssumpw","base.strided.dstdev":"@stdlib/stats/base/dstdev","base.strided.dstdevch":"@stdlib/stats/base/dstdevch","base.strided.dstdevpn":"@stdlib/stats/base/dstdevpn","base.strided.dstdevtk":"@stdlib/stats/base/dstdevtk","base.strided.dstdevwd":"@stdlib/stats/base/dstdevwd","base.strided.dstdevyc":"@stdlib/stats/base/dstdevyc","base.strided.dsum":"@stdlib/blas/ext/base/dsum","base.strided.dsumkbn":"@stdlib/blas/ext/base/dsumkbn","base.strided.dsumkbn2":"@stdlib/blas/ext/base/dsumkbn2","base.strided.dsumors":"@stdlib/blas/ext/base/dsumors","base.strided.dsumpw":"@stdlib/blas/ext/base/dsumpw","base.strided.dsvariance":"@stdlib/stats/base/dsvariance","base.strided.dsvariancepn":"@stdlib/stats/base/dsvariancepn","base.strided.dswap":"@stdlib/blas/base/dswap","base.strided.dtrunc":"@stdlib/math/strided/special/dtrunc","base.strided.dtypeEnum2Str":"@stdlib/strided/base/dtype-enum2str","base.strided.dtypeResolveEnum":"@stdlib/strided/base/dtype-resolve-enum","base.strided.dtypeResolveStr":"@stdlib/strided/base/dtype-resolve-str","base.strided.dtypeStr2Enum":"@stdlib/strided/base/dtype-str2enum","base.strided.dvariance":"@stdlib/stats/base/dvariance","base.strided.dvariancech":"@stdlib/stats/base/dvariancech","base.strided.dvariancepn":"@stdlib/stats/base/dvariancepn","base.strided.dvariancetk":"@stdlib/stats/base/dvariancetk","base.strided.dvariancewd":"@stdlib/stats/base/dvariancewd","base.strided.dvarianceyc":"@stdlib/stats/base/dvarianceyc","base.strided.dvarm":"@stdlib/stats/base/dvarm","base.strided.dvarmpn":"@stdlib/stats/base/dvarmpn","base.strided.dvarmtk":"@stdlib/stats/base/dvarmtk","base.strided.functionObject":"@stdlib/strided/base/function-object","base.strided.gapx":"@stdlib/blas/ext/base/gapx","base.strided.gapxsum":"@stdlib/blas/ext/base/gapxsum","base.strided.gapxsumkbn":"@stdlib/blas/ext/base/gapxsumkbn","base.strided.gapxsumkbn2":"@stdlib/blas/ext/base/gapxsumkbn2","base.strided.gapxsumors":"@stdlib/blas/ext/base/gapxsumors","base.strided.gapxsumpw":"@stdlib/blas/ext/base/gapxsumpw","base.strided.gasum":"@stdlib/blas/base/gasum","base.strided.gasumpw":"@stdlib/blas/ext/base/gasumpw","base.strided.gaxpy":"@stdlib/blas/base/gaxpy","base.strided.gcopy":"@stdlib/blas/base/gcopy","base.strided.gcusum":"@stdlib/blas/ext/base/gcusum","base.strided.gcusumkbn":"@stdlib/blas/ext/base/gcusumkbn","base.strided.gcusumkbn2":"@stdlib/blas/ext/base/gcusumkbn2","base.strided.gcusumors":"@stdlib/blas/ext/base/gcusumors","base.strided.gcusumpw":"@stdlib/blas/ext/base/gcusumpw","base.strided.gdot":"@stdlib/blas/base/gdot","base.strided.gfill":"@stdlib/blas/ext/base/gfill","base.strided.gfillBy":"@stdlib/blas/ext/base/gfill-by","base.strided.gnannsumkbn":"@stdlib/blas/ext/base/gnannsumkbn","base.strided.gnansum":"@stdlib/blas/ext/base/gnansum","base.strided.gnansumkbn":"@stdlib/blas/ext/base/gnansumkbn","base.strided.gnansumkbn2":"@stdlib/blas/ext/base/gnansumkbn2","base.strided.gnansumors":"@stdlib/blas/ext/base/gnansumors","base.strided.gnansumpw":"@stdlib/blas/ext/base/gnansumpw","base.strided.gnrm2":"@stdlib/blas/base/gnrm2","base.strided.grev":"@stdlib/blas/ext/base/grev","base.strided.gscal":"@stdlib/blas/base/gscal","base.strided.gsort2hp":"@stdlib/blas/ext/base/gsort2hp","base.strided.gsort2ins":"@stdlib/blas/ext/base/gsort2ins","base.strided.gsort2sh":"@stdlib/blas/ext/base/gsort2sh","base.strided.gsorthp":"@stdlib/blas/ext/base/gsorthp","base.strided.gsortins":"@stdlib/blas/ext/base/gsortins","base.strided.gsortsh":"@stdlib/blas/ext/base/gsortsh","base.strided.gsum":"@stdlib/blas/ext/base/gsum","base.strided.gsumkbn":"@stdlib/blas/ext/base/gsumkbn","base.strided.gsumkbn2":"@stdlib/blas/ext/base/gsumkbn2","base.strided.gsumors":"@stdlib/blas/ext/base/gsumors","base.strided.gsumpw":"@stdlib/blas/ext/base/gsumpw","base.strided.gswap":"@stdlib/blas/base/gswap","base.strided.mapBy":"@stdlib/strided/base/map-by","base.strided.mapBy2":"@stdlib/strided/base/map-by2","base.strided.max":"@stdlib/stats/base/max","base.strided.maxabs":"@stdlib/stats/base/maxabs","base.strided.maxBy":"@stdlib/stats/base/max-by","base.strided.maxsorted":"@stdlib/stats/base/maxsorted","base.strided.maxViewBufferIndex":"@stdlib/strided/base/max-view-buffer-index","base.strided.mean":"@stdlib/stats/base/mean","base.strided.meankbn":"@stdlib/stats/base/meankbn","base.strided.meankbn2":"@stdlib/stats/base/meankbn2","base.strided.meanors":"@stdlib/stats/base/meanors","base.strided.meanpn":"@stdlib/stats/base/meanpn","base.strided.meanpw":"@stdlib/stats/base/meanpw","base.strided.meanwd":"@stdlib/stats/base/meanwd","base.strided.mediansorted":"@stdlib/stats/base/mediansorted","base.strided.metaDataProps":"@stdlib/strided/base/meta-data-props","base.strided.min":"@stdlib/stats/base/min","base.strided.minabs":"@stdlib/stats/base/minabs","base.strided.minBy":"@stdlib/stats/base/min-by","base.strided.minsorted":"@stdlib/stats/base/minsorted","base.strided.minViewBufferIndex":"@stdlib/strided/base/min-view-buffer-index","base.strided.mskmax":"@stdlib/stats/base/mskmax","base.strided.mskmin":"@stdlib/stats/base/mskmin","base.strided.mskrange":"@stdlib/stats/base/mskrange","base.strided.mskunary":"@stdlib/strided/base/mskunary","base.strided.mskunaryDtypeSignatures":"@stdlib/strided/base/mskunary-dtype-signatures","base.strided.mskunarySignatureCallbacks":"@stdlib/strided/base/mskunary-signature-callbacks","base.strided.nanmax":"@stdlib/stats/base/nanmax","base.strided.nanmaxabs":"@stdlib/stats/base/nanmaxabs","base.strided.nanmaxBy":"@stdlib/stats/base/nanmax-by","base.strided.nanmean":"@stdlib/stats/base/nanmean","base.strided.nanmeanors":"@stdlib/stats/base/nanmeanors","base.strided.nanmeanpn":"@stdlib/stats/base/nanmeanpn","base.strided.nanmeanwd":"@stdlib/stats/base/nanmeanwd","base.strided.nanmin":"@stdlib/stats/base/nanmin","base.strided.nanminabs":"@stdlib/stats/base/nanminabs","base.strided.nanminBy":"@stdlib/stats/base/nanmin-by","base.strided.nanmskmax":"@stdlib/stats/base/nanmskmax","base.strided.nanmskmin":"@stdlib/stats/base/nanmskmin","base.strided.nanmskrange":"@stdlib/stats/base/nanmskrange","base.strided.nanrange":"@stdlib/stats/base/nanrange","base.strided.nanrangeBy":"@stdlib/stats/base/nanrange-by","base.strided.nanstdev":"@stdlib/stats/base/nanstdev","base.strided.nanstdevch":"@stdlib/stats/base/nanstdevch","base.strided.nanstdevpn":"@stdlib/stats/base/nanstdevpn","base.strided.nanstdevtk":"@stdlib/stats/base/nanstdevtk","base.strided.nanstdevwd":"@stdlib/stats/base/nanstdevwd","base.strided.nanstdevyc":"@stdlib/stats/base/nanstdevyc","base.strided.nanvariance":"@stdlib/stats/base/nanvariance","base.strided.nanvariancech":"@stdlib/stats/base/nanvariancech","base.strided.nanvariancepn":"@stdlib/stats/base/nanvariancepn","base.strided.nanvariancetk":"@stdlib/stats/base/nanvariancetk","base.strided.nanvariancewd":"@stdlib/stats/base/nanvariancewd","base.strided.nanvarianceyc":"@stdlib/stats/base/nanvarianceyc","base.strided.nullary":"@stdlib/strided/base/nullary","base.strided.offsetView":"@stdlib/strided/base/offset-view","base.strided.quaternary":"@stdlib/strided/base/quaternary","base.strided.quinary":"@stdlib/strided/base/quinary","base.strided.range":"@stdlib/stats/base/range","base.strided.rangeBy":"@stdlib/stats/base/range-by","base.strided.reinterpretComplex":"@stdlib/strided/base/reinterpret-complex","base.strided.reinterpretComplex64":"@stdlib/strided/base/reinterpret-complex64","base.strided.reinterpretComplex128":"@stdlib/strided/base/reinterpret-complex128","base.strided.sabs":"@stdlib/math/strided/special/sabs","base.strided.sabs2":"@stdlib/math/strided/special/sabs2","base.strided.sapx":"@stdlib/blas/ext/base/sapx","base.strided.sapxsum":"@stdlib/blas/ext/base/sapxsum","base.strided.sapxsumkbn":"@stdlib/blas/ext/base/sapxsumkbn","base.strided.sapxsumkbn2":"@stdlib/blas/ext/base/sapxsumkbn2","base.strided.sapxsumors":"@stdlib/blas/ext/base/sapxsumors","base.strided.sapxsumpw":"@stdlib/blas/ext/base/sapxsumpw","base.strided.sasum":"@stdlib/blas/base/sasum","base.strided.sasumpw":"@stdlib/blas/ext/base/sasumpw","base.strided.saxpy":"@stdlib/blas/base/saxpy","base.strided.scbrt":"@stdlib/math/strided/special/scbrt","base.strided.sceil":"@stdlib/math/strided/special/sceil","base.strided.scopy":"@stdlib/blas/base/scopy","base.strided.scumax":"@stdlib/stats/base/scumax","base.strided.scumaxabs":"@stdlib/stats/base/scumaxabs","base.strided.scumin":"@stdlib/stats/base/scumin","base.strided.scuminabs":"@stdlib/stats/base/scuminabs","base.strided.scusum":"@stdlib/blas/ext/base/scusum","base.strided.scusumkbn":"@stdlib/blas/ext/base/scusumkbn","base.strided.scusumkbn2":"@stdlib/blas/ext/base/scusumkbn2","base.strided.scusumors":"@stdlib/blas/ext/base/scusumors","base.strided.scusumpw":"@stdlib/blas/ext/base/scusumpw","base.strided.sdeg2rad":"@stdlib/math/strided/special/sdeg2rad","base.strided.sdot":"@stdlib/blas/base/sdot","base.strided.sdsapxsum":"@stdlib/blas/ext/base/sdsapxsum","base.strided.sdsapxsumpw":"@stdlib/blas/ext/base/sdsapxsumpw","base.strided.sdsdot":"@stdlib/blas/base/sdsdot","base.strided.sdsmean":"@stdlib/stats/base/sdsmean","base.strided.sdsmeanors":"@stdlib/stats/base/sdsmeanors","base.strided.sdsnanmean":"@stdlib/stats/base/sdsnanmean","base.strided.sdsnanmeanors":"@stdlib/stats/base/sdsnanmeanors","base.strided.sdsnansum":"@stdlib/blas/ext/base/sdsnansum","base.strided.sdsnansumpw":"@stdlib/blas/ext/base/sdsnansumpw","base.strided.sdssum":"@stdlib/blas/ext/base/sdssum","base.strided.sdssumpw":"@stdlib/blas/ext/base/sdssumpw","base.strided.sfill":"@stdlib/blas/ext/base/sfill","base.strided.sfloor":"@stdlib/math/strided/special/sfloor","base.strided.sinv":"@stdlib/math/strided/special/sinv","base.strided.smap":"@stdlib/strided/base/smap","base.strided.smap2":"@stdlib/strided/base/smap2","base.strided.smax":"@stdlib/stats/base/smax","base.strided.smaxabs":"@stdlib/stats/base/smaxabs","base.strided.smaxabssorted":"@stdlib/stats/base/smaxabssorted","base.strided.smaxsorted":"@stdlib/stats/base/smaxsorted","base.strided.smean":"@stdlib/stats/base/smean","base.strided.smeankbn":"@stdlib/stats/base/smeankbn","base.strided.smeankbn2":"@stdlib/stats/base/smeankbn2","base.strided.smeanli":"@stdlib/stats/base/smeanli","base.strided.smeanlipw":"@stdlib/stats/base/smeanlipw","base.strided.smeanors":"@stdlib/stats/base/smeanors","base.strided.smeanpn":"@stdlib/stats/base/smeanpn","base.strided.smeanpw":"@stdlib/stats/base/smeanpw","base.strided.smeanwd":"@stdlib/stats/base/smeanwd","base.strided.smediansorted":"@stdlib/stats/base/smediansorted","base.strided.smidrange":"@stdlib/stats/base/smidrange","base.strided.smin":"@stdlib/stats/base/smin","base.strided.sminabs":"@stdlib/stats/base/sminabs","base.strided.sminsorted":"@stdlib/stats/base/sminsorted","base.strided.smskabs":"@stdlib/math/strided/special/smskabs","base.strided.smskabs2":"@stdlib/math/strided/special/smskabs2","base.strided.smskcbrt":"@stdlib/math/strided/special/smskcbrt","base.strided.smskceil":"@stdlib/math/strided/special/smskceil","base.strided.smskdeg2rad":"@stdlib/math/strided/special/smskdeg2rad","base.strided.smskfloor":"@stdlib/math/strided/special/smskfloor","base.strided.smskinv":"@stdlib/math/strided/special/smskinv","base.strided.smskmap":"@stdlib/strided/base/smskmap","base.strided.smskmap2":"@stdlib/strided/base/smskmap2","base.strided.smskmax":"@stdlib/stats/base/smskmax","base.strided.smskmin":"@stdlib/stats/base/smskmin","base.strided.smskramp":"@stdlib/math/strided/special/smskramp","base.strided.smskrange":"@stdlib/stats/base/smskrange","base.strided.smskrsqrt":"@stdlib/math/strided/special/smskrsqrt","base.strided.smsksqrt":"@stdlib/math/strided/special/smsksqrt","base.strided.smsktrunc":"@stdlib/math/strided/special/smsktrunc","base.strided.snanmax":"@stdlib/stats/base/snanmax","base.strided.snanmaxabs":"@stdlib/stats/base/snanmaxabs","base.strided.snanmean":"@stdlib/stats/base/snanmean","base.strided.snanmeanors":"@stdlib/stats/base/snanmeanors","base.strided.snanmeanpn":"@stdlib/stats/base/snanmeanpn","base.strided.snanmeanwd":"@stdlib/stats/base/snanmeanwd","base.strided.snanmin":"@stdlib/stats/base/snanmin","base.strided.snanminabs":"@stdlib/stats/base/snanminabs","base.strided.snanmskmax":"@stdlib/stats/base/snanmskmax","base.strided.snanmskmin":"@stdlib/stats/base/snanmskmin","base.strided.snanmskrange":"@stdlib/stats/base/snanmskrange","base.strided.snanrange":"@stdlib/stats/base/snanrange","base.strided.snanstdev":"@stdlib/stats/base/snanstdev","base.strided.snanstdevch":"@stdlib/stats/base/snanstdevch","base.strided.snanstdevpn":"@stdlib/stats/base/snanstdevpn","base.strided.snanstdevtk":"@stdlib/stats/base/snanstdevtk","base.strided.snanstdevwd":"@stdlib/stats/base/snanstdevwd","base.strided.snanstdevyc":"@stdlib/stats/base/snanstdevyc","base.strided.snansum":"@stdlib/blas/ext/base/snansum","base.strided.snansumkbn":"@stdlib/blas/ext/base/snansumkbn","base.strided.snansumkbn2":"@stdlib/blas/ext/base/snansumkbn2","base.strided.snansumors":"@stdlib/blas/ext/base/snansumors","base.strided.snansumpw":"@stdlib/blas/ext/base/snansumpw","base.strided.snanvariance":"@stdlib/stats/base/snanvariance","base.strided.snanvariancech":"@stdlib/stats/base/snanvariancech","base.strided.snanvariancepn":"@stdlib/stats/base/snanvariancepn","base.strided.snanvariancetk":"@stdlib/stats/base/snanvariancetk","base.strided.snanvariancewd":"@stdlib/stats/base/snanvariancewd","base.strided.snanvarianceyc":"@stdlib/stats/base/snanvarianceyc","base.strided.snrm2":"@stdlib/blas/base/snrm2","base.strided.sramp":"@stdlib/math/strided/special/sramp","base.strided.srange":"@stdlib/stats/base/srange","base.strided.srev":"@stdlib/blas/ext/base/srev","base.strided.srsqrt":"@stdlib/math/strided/special/srsqrt","base.strided.sscal":"@stdlib/blas/base/sscal","base.strided.ssort2hp":"@stdlib/blas/ext/base/ssort2hp","base.strided.ssort2ins":"@stdlib/blas/ext/base/ssort2ins","base.strided.ssort2sh":"@stdlib/blas/ext/base/ssort2sh","base.strided.ssorthp":"@stdlib/blas/ext/base/ssorthp","base.strided.ssortins":"@stdlib/blas/ext/base/ssortins","base.strided.ssortsh":"@stdlib/blas/ext/base/ssortsh","base.strided.ssqrt":"@stdlib/math/strided/special/ssqrt","base.strided.sstdev":"@stdlib/stats/base/sstdev","base.strided.sstdevch":"@stdlib/stats/base/sstdevch","base.strided.sstdevpn":"@stdlib/stats/base/sstdevpn","base.strided.sstdevtk":"@stdlib/stats/base/sstdevtk","base.strided.sstdevwd":"@stdlib/stats/base/sstdevwd","base.strided.sstdevyc":"@stdlib/stats/base/sstdevyc","base.strided.ssum":"@stdlib/blas/ext/base/ssum","base.strided.ssumkbn":"@stdlib/blas/ext/base/ssumkbn","base.strided.ssumkbn2":"@stdlib/blas/ext/base/ssumkbn2","base.strided.ssumors":"@stdlib/blas/ext/base/ssumors","base.strided.ssumpw":"@stdlib/blas/ext/base/ssumpw","base.strided.sswap":"@stdlib/blas/base/sswap","base.strided.stdev":"@stdlib/stats/base/stdev","base.strided.stdevch":"@stdlib/stats/base/stdevch","base.strided.stdevpn":"@stdlib/stats/base/stdevpn","base.strided.stdevtk":"@stdlib/stats/base/stdevtk","base.strided.stdevwd":"@stdlib/stats/base/stdevwd","base.strided.stdevyc":"@stdlib/stats/base/stdevyc","base.strided.strunc":"@stdlib/math/strided/special/strunc","base.strided.svariance":"@stdlib/stats/base/svariance","base.strided.svariancech":"@stdlib/stats/base/svariancech","base.strided.svariancepn":"@stdlib/stats/base/svariancepn","base.strided.svariancetk":"@stdlib/stats/base/svariancetk","base.strided.svariancewd":"@stdlib/stats/base/svariancewd","base.strided.svarianceyc":"@stdlib/stats/base/svarianceyc","base.strided.ternary":"@stdlib/strided/base/ternary","base.strided.unary":"@stdlib/strided/base/unary","base.strided.unaryBy":"@stdlib/strided/base/unary-by","base.strided.unaryDtypeSignatures":"@stdlib/strided/base/unary-dtype-signatures","base.strided.unarySignatureCallbacks":"@stdlib/strided/base/unary-signature-callbacks","base.strided.variance":"@stdlib/stats/base/variance","base.strided.variancech":"@stdlib/stats/base/variancech","base.strided.variancepn":"@stdlib/stats/base/variancepn","base.strided.variancetk":"@stdlib/stats/base/variancetk","base.strided.variancewd":"@stdlib/stats/base/variancewd","base.strided.varianceyc":"@stdlib/stats/base/varianceyc","base.strided.zmap":"@stdlib/strided/base/zmap","base.str2multislice":"@stdlib/slice/base/str2multislice","base.str2slice":"@stdlib/slice/base/str2slice","base.sub":"@stdlib/number/float64/base/sub","base.subf":"@stdlib/math/base/ops/subf","base.sumSeries":"@stdlib/math/base/tools/sum-series","base.tan":"@stdlib/math/base/special/tan","base.tand":"@stdlib/math/base/special/tand","base.tanh":"@stdlib/math/base/special/tanh","base.toBinaryString":"@stdlib/number/float64/base/to-binary-string","base.toBinaryStringf":"@stdlib/number/float32/base/to-binary-string","base.toBinaryStringUint8":"@stdlib/number/uint8/base/to-binary-string","base.toBinaryStringUint16":"@stdlib/number/uint16/base/to-binary-string","base.toBinaryStringUint32":"@stdlib/number/uint32/base/to-binary-string","base.toWordf":"@stdlib/number/float32/base/to-word","base.toWords":"@stdlib/number/float64/base/to-words","base.transpose":"@stdlib/ndarray/base/transpose","base.tribonacci":"@stdlib/math/base/special/tribonacci","base.trigamma":"@stdlib/math/base/special/trigamma","base.trim":"@stdlib/string/base/trim","base.trunc":"@stdlib/math/base/special/trunc","base.trunc2":"@stdlib/math/base/special/trunc2","base.trunc10":"@stdlib/math/base/special/trunc10","base.truncateMiddle":"@stdlib/string/base/truncate-middle","base.truncb":"@stdlib/math/base/special/truncb","base.truncf":"@stdlib/math/base/special/truncf","base.truncn":"@stdlib/math/base/special/truncn","base.truncsd":"@stdlib/math/base/special/truncsd","base.uint32ToInt32":"@stdlib/number/uint32/base/to-int32","base.umul":"@stdlib/math/base/ops/umul","base.umuldw":"@stdlib/math/base/ops/umuldw","base.uncapitalize":"@stdlib/string/base/uncapitalize","base.uppercase":"@stdlib/string/base/uppercase","base.vercos":"@stdlib/math/base/special/vercos","base.versin":"@stdlib/math/base/special/versin","base.wrap":"@stdlib/math/base/special/wrap","base.xlog1py":"@stdlib/math/base/special/xlog1py","base.xlogy":"@stdlib/math/base/special/xlogy","base.zeta":"@stdlib/math/base/special/riemann-zeta","bench":"@stdlib/bench","BERNDT_CPS_WAGES_1985":"@stdlib/datasets/berndt-cps-wages-1985","bifurcate":"@stdlib/utils/bifurcate","bifurcateBy":"@stdlib/utils/bifurcate-by","bifurcateByAsync":"@stdlib/utils/async/bifurcate-by","bifurcateIn":"@stdlib/utils/bifurcate-in","bifurcateOwn":"@stdlib/utils/bifurcate-own","BigInt":"@stdlib/bigint/ctor","binomialTest":"@stdlib/stats/binomial-test","Boolean":"@stdlib/boolean/ctor","BooleanArray":"@stdlib/array/bool","broadcastArray":"@stdlib/ndarray/broadcast-array","broadcastArrays":"@stdlib/ndarray/broadcast-arrays","Buffer":"@stdlib/buffer/ctor","buffer2json":"@stdlib/buffer/to-json","BYTE_ORDER":"@stdlib/os/byte-order","camelcase":"@stdlib/string/camelcase","capitalize":"@stdlib/string/capitalize","capitalizeKeys":"@stdlib/utils/capitalize-keys","CATALAN":"@stdlib/constants/float64/catalan","CBRT_EPS":"@stdlib/constants/float64/cbrt-eps","CDC_NCHS_US_BIRTHS_1969_1988":"@stdlib/datasets/cdc-nchs-us-births-1969-1988","CDC_NCHS_US_BIRTHS_1994_2003":"@stdlib/datasets/cdc-nchs-us-births-1994-2003","CDC_NCHS_US_INFANT_MORTALITY_BW_1915_2013":"@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013","chdir":"@stdlib/process/chdir","chi2gof":"@stdlib/stats/chi2gof","chi2test":"@stdlib/stats/chi2test","circarray2iterator":"@stdlib/array/to-circular-iterator","circularArrayStream":"@stdlib/streams/node/from-circular-array","CircularBuffer":"@stdlib/dstructs/circular-buffer","close":"@stdlib/fs/close","CMUDICT":"@stdlib/datasets/cmudict","codePointAt":"@stdlib/string/code-point-at","commonKeys":"@stdlib/utils/common-keys","commonKeysIn":"@stdlib/utils/common-keys-in","complex":"@stdlib/complex/cmplx","Complex64":"@stdlib/complex/float32/ctor","COMPLEX64_NAN":"@stdlib/constants/complex64/nan","COMPLEX64_NUM_BYTES":"@stdlib/constants/complex64/num-bytes","COMPLEX64_ZERO":"@stdlib/constants/complex64/zero","Complex64Array":"@stdlib/array/complex64","Complex128":"@stdlib/complex/float64/ctor","COMPLEX128_NAN":"@stdlib/constants/complex128/nan","COMPLEX128_NUM_BYTES":"@stdlib/constants/complex128/num-bytes","COMPLEX128_ZERO":"@stdlib/constants/complex128/zero","Complex128Array":"@stdlib/array/complex128","complexarray":"@stdlib/array/typed-complex","complexarrayCtors":"@stdlib/array/typed-complex-ctors","complexarrayDataTypes":"@stdlib/array/typed-complex-dtypes","complexCtors":"@stdlib/complex/ctors","complexDataType":"@stdlib/complex/dtype","complexDataTypes":"@stdlib/complex/dtypes","complexPromotionRules":"@stdlib/complex/promotion-rules","compose":"@stdlib/utils/compose","composeAsync":"@stdlib/utils/async/compose","configdir":"@stdlib/os/configdir","conj":"@stdlib/complex/float64/conj","conjf":"@stdlib/complex/float32/conj","constantcase":"@stdlib/string/constantcase","constantFunction":"@stdlib/utils/constant-function","constantStream":"@stdlib/streams/node/from-constant","constructorName":"@stdlib/utils/constructor-name","contains":"@stdlib/assert/contains","convertArray":"@stdlib/array/convert","convertArraySame":"@stdlib/array/convert-same","convertPath":"@stdlib/utils/convert-path","copy":"@stdlib/utils/copy","copyBuffer":"@stdlib/buffer/from-buffer","countBy":"@stdlib/utils/count-by","countByAsync":"@stdlib/utils/async/count-by","currentYear":"@stdlib/time/current-year","curry":"@stdlib/utils/curry","curryRight":"@stdlib/utils/curry-right","cwd":"@stdlib/process/cwd","DALE_CHALL_NEW":"@stdlib/datasets/dale-chall-new","datasets":"@stdlib/datasets","DataView":"@stdlib/array/dataview","datespace":"@stdlib/array/datespace","dayOfQuarter":"@stdlib/time/day-of-quarter","dayOfYear":"@stdlib/time/day-of-year","daysInMonth":"@stdlib/time/days-in-month","daysInYear":"@stdlib/time/days-in-year","ddot":"@stdlib/blas/ddot","debugSinkStream":"@stdlib/streams/node/debug-sink","debugStream":"@stdlib/streams/node/debug","decorateAfter":"@stdlib/utils/decorate-after","deepEqual":"@stdlib/assert/deep-equal","deepGet":"@stdlib/utils/deep-get","deepHasOwnProp":"@stdlib/assert/deep-has-own-property","deepHasProp":"@stdlib/assert/deep-has-property","deepPluck":"@stdlib/utils/deep-pluck","deepSet":"@stdlib/utils/deep-set","defineMemoizedProperty":"@stdlib/utils/define-memoized-property","defineProperties":"@stdlib/utils/define-properties","defineProperty":"@stdlib/utils/define-property","dirname":"@stdlib/utils/dirname","dotcase":"@stdlib/string/dotcase","DoublyLinkedList":"@stdlib/dstructs/doubly-linked-list","doUntil":"@stdlib/utils/do-until","doUntilAsync":"@stdlib/utils/async/do-until","doUntilEach":"@stdlib/utils/do-until-each","doUntilEachRight":"@stdlib/utils/do-until-each-right","doWhile":"@stdlib/utils/do-while","doWhileAsync":"@stdlib/utils/async/do-while","doWhileEach":"@stdlib/utils/do-while-each","doWhileEachRight":"@stdlib/utils/do-while-each-right","dswap":"@stdlib/blas/dswap","E":"@stdlib/constants/float64/e","EMOJI":"@stdlib/datasets/emoji","EMOJI_CODE_PICTO":"@stdlib/datasets/emoji-code-picto","EMOJI_PICTO_CODE":"@stdlib/datasets/emoji-picto-code","emptyStream":"@stdlib/streams/node/empty","endsWith":"@stdlib/string/ends-with","enumerableProperties":"@stdlib/utils/enumerable-properties","enumerablePropertiesIn":"@stdlib/utils/enumerable-properties-in","enumerablePropertySymbols":"@stdlib/utils/enumerable-property-symbols","enumerablePropertySymbolsIn":"@stdlib/utils/enumerable-property-symbols-in","ENV":"@stdlib/process/env","EPS":"@stdlib/constants/float64/eps","error2json":"@stdlib/error/to-json","EULERGAMMA":"@stdlib/constants/float64/eulergamma","every":"@stdlib/utils/every","everyBy":"@stdlib/utils/every-by","everyByAsync":"@stdlib/utils/async/every-by","everyByRight":"@stdlib/utils/every-by-right","everyByRightAsync":"@stdlib/utils/async/every-by-right","everyInBy":"@stdlib/utils/every-in-by","everyOwnBy":"@stdlib/utils/every-own-by","evil":"@stdlib/utils/eval","EXEC_PATH":"@stdlib/process/exec-path","exists":"@stdlib/fs/exists","expandAcronyms":"@stdlib/nlp/expand-acronyms","expandContractions":"@stdlib/nlp/expand-contractions","extname":"@stdlib/utils/extname","FancyArray":"@stdlib/ndarray/fancy","fastmath.abs":"@stdlib/math/base/special/fast/abs","fastmath.acosh":"@stdlib/math/base/special/fast/acosh","fastmath.ampbm":"@stdlib/math/base/special/fast/alpha-max-plus-beta-min","fastmath.asinh":"@stdlib/math/base/special/fast/asinh","fastmath.atanh":"@stdlib/math/base/special/fast/atanh","fastmath.hypot":"@stdlib/math/base/special/fast/hypot","fastmath.log2Uint32":"@stdlib/math/base/special/fast/uint32-log2","fastmath.max":"@stdlib/math/base/special/fast/max","fastmath.min":"@stdlib/math/base/special/fast/min","fastmath.powint":"@stdlib/math/base/special/fast/pow-int","fastmath.sqrtUint32":"@stdlib/math/base/special/fast/uint32-sqrt","FEMALE_FIRST_NAMES_EN":"@stdlib/datasets/female-first-names-en","FIFO":"@stdlib/dstructs/fifo","filledarray":"@stdlib/array/filled","filledarrayBy":"@stdlib/array/filled-by","filterArguments":"@stdlib/utils/filter-arguments","find":"@stdlib/utils/find","firstChar":"@stdlib/string/first","FIVETHIRTYEIGHT_FFQ":"@stdlib/datasets/fivethirtyeight-ffq","flattenArray":"@stdlib/utils/flatten-array","flattenObject":"@stdlib/utils/flatten-object","flignerTest":"@stdlib/stats/fligner-test","FLOAT_WORD_ORDER":"@stdlib/os/float-word-order","FLOAT16_CBRT_EPS":"@stdlib/constants/float16/cbrt-eps","FLOAT16_EPS":"@stdlib/constants/float16/eps","FLOAT16_EXPONENT_BIAS":"@stdlib/constants/float16/exponent-bias","FLOAT16_MAX":"@stdlib/constants/float16/max","FLOAT16_MAX_SAFE_INTEGER":"@stdlib/constants/float16/max-safe-integer","FLOAT16_MIN_SAFE_INTEGER":"@stdlib/constants/float16/min-safe-integer","FLOAT16_NINF":"@stdlib/constants/float16/ninf","FLOAT16_NUM_BYTES":"@stdlib/constants/float16/num-bytes","FLOAT16_PINF":"@stdlib/constants/float16/pinf","FLOAT16_PRECISION":"@stdlib/constants/float16/precision","FLOAT16_SMALLEST_NORMAL":"@stdlib/constants/float16/smallest-normal","FLOAT16_SMALLEST_SUBNORMAL":"@stdlib/constants/float16/smallest-subnormal","FLOAT16_SQRT_EPS":"@stdlib/constants/float16/sqrt-eps","FLOAT32_ABS_MASK":"@stdlib/constants/float32/abs-mask","FLOAT32_CBRT_EPS":"@stdlib/constants/float32/cbrt-eps","FLOAT32_E":"@stdlib/constants/float32/e","FLOAT32_EPS":"@stdlib/constants/float32/eps","FLOAT32_EXPONENT_BIAS":"@stdlib/constants/float32/exponent-bias","FLOAT32_EXPONENT_MASK":"@stdlib/constants/float32/exponent-mask","FLOAT32_FOURTH_PI":"@stdlib/constants/float32/fourth-pi","FLOAT32_HALF_LN_TWO":"@stdlib/constants/float32/half-ln-two","FLOAT32_HALF_PI":"@stdlib/constants/float32/half-pi","FLOAT32_LN_HALF":"@stdlib/constants/float32/ln-half","FLOAT32_LN_PI":"@stdlib/constants/float32/ln-pi","FLOAT32_LN_TEN":"@stdlib/constants/float32/ln-ten","FLOAT32_LN_TWO":"@stdlib/constants/float32/ln-two","FLOAT32_MAX":"@stdlib/constants/float32/max","FLOAT32_MAX_BASE2_EXPONENT":"@stdlib/constants/float32/max-base2-exponent","FLOAT32_MAX_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/max-base2-exponent-subnormal","FLOAT32_MAX_BASE10_EXPONENT":"@stdlib/constants/float32/max-base10-exponent","FLOAT32_MAX_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/max-base10-exponent-subnormal","FLOAT32_MAX_SAFE_FIBONACCI":"@stdlib/constants/float32/max-safe-fibonacci","FLOAT32_MAX_SAFE_INTEGER":"@stdlib/constants/float32/max-safe-integer","FLOAT32_MAX_SAFE_NTH_FACTORIAL":"@stdlib/constants/float32/max-safe-nth-factorial","FLOAT32_MAX_SAFE_NTH_FIBONACCI":"@stdlib/constants/float32/max-safe-nth-fibonacci","FLOAT32_MAX_SAFE_NTH_LUCAS":"@stdlib/constants/float32/max-safe-nth-lucas","FLOAT32_MIN_BASE2_EXPONENT":"@stdlib/constants/float32/min-base2-exponent","FLOAT32_MIN_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/min-base2-exponent-subnormal","FLOAT32_MIN_BASE10_EXPONENT":"@stdlib/constants/float32/min-base10-exponent","FLOAT32_MIN_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/min-base10-exponent-subnormal","FLOAT32_MIN_SAFE_INTEGER":"@stdlib/constants/float32/min-safe-integer","FLOAT32_NAN":"@stdlib/constants/float32/nan","FLOAT32_NINF":"@stdlib/constants/float32/ninf","FLOAT32_NUM_BYTES":"@stdlib/constants/float32/num-bytes","FLOAT32_PHI":"@stdlib/constants/float32/phi","FLOAT32_PI":"@stdlib/constants/float32/pi","FLOAT32_PINF":"@stdlib/constants/float32/pinf","FLOAT32_PRECISION":"@stdlib/constants/float32/precision","FLOAT32_SIGN_MASK":"@stdlib/constants/float32/sign-mask","FLOAT32_SIGNIFICAND_MASK":"@stdlib/constants/float32/significand-mask","FLOAT32_SMALLEST_NORMAL":"@stdlib/constants/float32/smallest-normal","FLOAT32_SMALLEST_SUBNORMAL":"@stdlib/constants/float32/smallest-subnormal","FLOAT32_SQRT_EPS":"@stdlib/constants/float32/sqrt-eps","FLOAT32_SQRT_HALF":"@stdlib/constants/float32/sqrt-half","FLOAT32_SQRT_HALF_PI":"@stdlib/constants/float32/sqrt-half-pi","FLOAT32_SQRT_PHI":"@stdlib/constants/float32/sqrt-phi","FLOAT32_SQRT_PI":"@stdlib/constants/float32/sqrt-pi","FLOAT32_SQRT_THREE":"@stdlib/constants/float32/sqrt-three","FLOAT32_SQRT_TWO":"@stdlib/constants/float32/sqrt-two","FLOAT32_SQRT_TWO_PI":"@stdlib/constants/float32/sqrt-two-pi","FLOAT32_TWO_PI":"@stdlib/constants/float32/two-pi","Float32Array":"@stdlib/array/float32","Float32ArrayFE":"@stdlib/array/fixed-endian-float32","Float32ArrayLE":"@stdlib/array/little-endian-float32","FLOAT64_EXPONENT_BIAS":"@stdlib/constants/float64/exponent-bias","FLOAT64_HIGH_WORD_ABS_MASK":"@stdlib/constants/float64/high-word-abs-mask","FLOAT64_HIGH_WORD_EXPONENT_MASK":"@stdlib/constants/float64/high-word-exponent-mask","FLOAT64_HIGH_WORD_SIGN_MASK":"@stdlib/constants/float64/high-word-sign-mask","FLOAT64_HIGH_WORD_SIGNIFICAND_MASK":"@stdlib/constants/float64/high-word-significand-mask","FLOAT64_MAX":"@stdlib/constants/float64/max","FLOAT64_MAX_BASE2_EXPONENT":"@stdlib/constants/float64/max-base2-exponent","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/max-base2-exponent-subnormal","FLOAT64_MAX_BASE10_EXPONENT":"@stdlib/constants/float64/max-base10-exponent","FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/max-base10-exponent-subnormal","FLOAT64_MAX_LN":"@stdlib/constants/float64/max-ln","FLOAT64_MAX_SAFE_FIBONACCI":"@stdlib/constants/float64/max-safe-fibonacci","FLOAT64_MAX_SAFE_INTEGER":"@stdlib/constants/float64/max-safe-integer","FLOAT64_MAX_SAFE_LUCAS":"@stdlib/constants/float64/max-safe-lucas","FLOAT64_MAX_SAFE_NTH_FIBONACCI":"@stdlib/constants/float64/max-safe-nth-fibonacci","FLOAT64_MAX_SAFE_NTH_LUCAS":"@stdlib/constants/float64/max-safe-nth-lucas","FLOAT64_MIN_BASE2_EXPONENT":"@stdlib/constants/float64/min-base2-exponent","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/min-base2-exponent-subnormal","FLOAT64_MIN_BASE10_EXPONENT":"@stdlib/constants/float64/min-base10-exponent","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/min-base10-exponent-subnormal","FLOAT64_MIN_LN":"@stdlib/constants/float64/min-ln","FLOAT64_MIN_SAFE_INTEGER":"@stdlib/constants/float64/min-safe-integer","FLOAT64_NUM_BYTES":"@stdlib/constants/float64/num-bytes","FLOAT64_PRECISION":"@stdlib/constants/float64/precision","FLOAT64_SMALLEST_NORMAL":"@stdlib/constants/float64/smallest-normal","FLOAT64_SMALLEST_SUBNORMAL":"@stdlib/constants/float64/smallest-subnormal","Float64Array":"@stdlib/array/float64","Float64ArrayFE":"@stdlib/array/fixed-endian-float64","Float64ArrayLE":"@stdlib/array/little-endian-float64","forEach":"@stdlib/utils/for-each","forEachAsync":"@stdlib/utils/async/for-each","forEachChar":"@stdlib/string/for-each","forEachRight":"@stdlib/utils/for-each-right","forEachRightAsync":"@stdlib/utils/async/for-each-right","forIn":"@stdlib/utils/for-in","format":"@stdlib/string/format","forOwn":"@stdlib/utils/for-own","FOURTH_PI":"@stdlib/constants/float64/fourth-pi","FOURTH_ROOT_EPS":"@stdlib/constants/float64/fourth-root-eps","FRB_SF_WAGE_RIGIDITY":"@stdlib/datasets/frb-sf-wage-rigidity","fromCodePoint":"@stdlib/string/from-code-point","Function":"@stdlib/function/ctor","function2string":"@stdlib/function/to-string","functionName":"@stdlib/utils/function-name","functionSequence":"@stdlib/utils/function-sequence","functionSequenceAsync":"@stdlib/utils/async/function-sequence","GAMMA_LANCZOS_G":"@stdlib/constants/float64/gamma-lanczos-g","gdot":"@stdlib/blas/gdot","getegid":"@stdlib/process/getegid","geteuid":"@stdlib/process/geteuid","getgid":"@stdlib/process/getgid","getGlobal":"@stdlib/utils/global","getPrototypeOf":"@stdlib/utils/get-prototype-of","getuid":"@stdlib/process/getuid","GLAISHER":"@stdlib/constants/float64/glaisher-kinkelin","graphemeClusters2iterator":"@stdlib/string/to-grapheme-cluster-iterator","graphemeClusters2iteratorRight":"@stdlib/string/to-grapheme-cluster-iterator-right","group":"@stdlib/utils/group","groupBy":"@stdlib/utils/group-by","groupByAsync":"@stdlib/utils/async/group-by","groupIn":"@stdlib/utils/group-in","groupOwn":"@stdlib/utils/group-own","gswap":"@stdlib/blas/gswap","HALF_LN2":"@stdlib/constants/float64/half-ln-two","HALF_PI":"@stdlib/constants/float64/half-pi","HARRISON_BOSTON_HOUSE_PRICES":"@stdlib/datasets/harrison-boston-house-prices","HARRISON_BOSTON_HOUSE_PRICES_CORRECTED":"@stdlib/datasets/harrison-boston-house-prices-corrected","hasArrayBufferSupport":"@stdlib/assert/has-arraybuffer-support","hasArrowFunctionSupport":"@stdlib/assert/has-arrow-function-support","hasAsyncAwaitSupport":"@stdlib/assert/has-async-await-support","hasAsyncIteratorSymbolSupport":"@stdlib/assert/has-async-iterator-symbol-support","hasAtobSupport":"@stdlib/assert/has-atob-support","hasBigInt64ArraySupport":"@stdlib/assert/has-bigint64array-support","hasBigIntSupport":"@stdlib/assert/has-bigint-support","hasBigUint64ArraySupport":"@stdlib/assert/has-biguint64array-support","hasBtoaSupport":"@stdlib/assert/has-btoa-support","hasClassSupport":"@stdlib/assert/has-class-support","hasDataViewSupport":"@stdlib/assert/has-dataview-support","hasDefinePropertiesSupport":"@stdlib/assert/has-define-properties-support","hasDefinePropertySupport":"@stdlib/assert/has-define-property-support","hasFloat32ArraySupport":"@stdlib/assert/has-float32array-support","hasFloat64ArraySupport":"@stdlib/assert/has-float64array-support","hasFunctionNameSupport":"@stdlib/assert/has-function-name-support","hasGeneratorSupport":"@stdlib/assert/has-generator-support","hasGlobalThisSupport":"@stdlib/assert/has-globalthis-support","hasInt8ArraySupport":"@stdlib/assert/has-int8array-support","hasInt16ArraySupport":"@stdlib/assert/has-int16array-support","hasInt32ArraySupport":"@stdlib/assert/has-int32array-support","hasIteratorSymbolSupport":"@stdlib/assert/has-iterator-symbol-support","hasMapSupport":"@stdlib/assert/has-map-support","hasNodeBufferSupport":"@stdlib/assert/has-node-buffer-support","hasOwnProp":"@stdlib/assert/has-own-property","hasProp":"@stdlib/assert/has-property","hasProxySupport":"@stdlib/assert/has-proxy-support","hasSetSupport":"@stdlib/assert/has-set-support","hasSharedArrayBufferSupport":"@stdlib/assert/has-sharedarraybuffer-support","hasSymbolSupport":"@stdlib/assert/has-symbol-support","hasToStringTagSupport":"@stdlib/assert/has-tostringtag-support","hasUint8ArraySupport":"@stdlib/assert/has-uint8array-support","hasUint8ClampedArraySupport":"@stdlib/assert/has-uint8clampedarray-support","hasUint16ArraySupport":"@stdlib/assert/has-uint16array-support","hasUint32ArraySupport":"@stdlib/assert/has-uint32array-support","hasUTF16SurrogatePairAt":"@stdlib/assert/has-utf16-surrogate-pair-at","hasWeakMapSupport":"@stdlib/assert/has-weakmap-support","hasWeakSetSupport":"@stdlib/assert/has-weakset-support","hasWebAssemblySupport":"@stdlib/assert/has-wasm-support","headercase":"@stdlib/string/headercase","HERNDON_VENUS_SEMIDIAMETERS":"@stdlib/datasets/herndon-venus-semidiameters","homedir":"@stdlib/os/homedir","HOURS_IN_DAY":"@stdlib/constants/time/hours-in-day","HOURS_IN_WEEK":"@stdlib/constants/time/hours-in-week","hoursInMonth":"@stdlib/time/hours-in-month","hoursInYear":"@stdlib/time/hours-in-year","httpServer":"@stdlib/net/http-server","identity":"@stdlib/utils/identity-function","ifelse":"@stdlib/utils/if-else","ifelseAsync":"@stdlib/utils/async/if-else","ifthen":"@stdlib/utils/if-then","ifthenAsync":"@stdlib/utils/async/if-then","imag":"@stdlib/complex/float64/imag","imagf":"@stdlib/complex/float32/imag","IMG_ACANTHUS_MOLLIS":"@stdlib/datasets/img-acanthus-mollis","IMG_AIRPLANE_FROM_ABOVE":"@stdlib/datasets/img-airplane-from-above","IMG_ALLIUM_OREOPHILUM":"@stdlib/datasets/img-allium-oreophilum","IMG_BLACK_CANYON":"@stdlib/datasets/img-black-canyon","IMG_DUST_BOWL_HOME":"@stdlib/datasets/img-dust-bowl-home","IMG_FRENCH_ALPINE_LANDSCAPE":"@stdlib/datasets/img-french-alpine-landscape","IMG_LOCOMOTION_HOUSE_CAT":"@stdlib/datasets/img-locomotion-house-cat","IMG_LOCOMOTION_NUDE_MALE":"@stdlib/datasets/img-locomotion-nude-male","IMG_MARCH_PASTORAL":"@stdlib/datasets/img-march-pastoral","IMG_NAGASAKI_BOATS":"@stdlib/datasets/img-nagasaki-boats","incrapcorr":"@stdlib/stats/incr/apcorr","incrBinaryClassification":"@stdlib/ml/incr/binary-classification","incrcount":"@stdlib/stats/incr/count","incrcovariance":"@stdlib/stats/incr/covariance","incrcovmat":"@stdlib/stats/incr/covmat","incrcv":"@stdlib/stats/incr/cv","increwmean":"@stdlib/stats/incr/ewmean","increwstdev":"@stdlib/stats/incr/ewstdev","increwvariance":"@stdlib/stats/incr/ewvariance","incrgmean":"@stdlib/stats/incr/gmean","incrgrubbs":"@stdlib/stats/incr/grubbs","incrhmean":"@stdlib/stats/incr/hmean","incrkmeans":"@stdlib/ml/incr/kmeans","incrkurtosis":"@stdlib/stats/incr/kurtosis","incrmaape":"@stdlib/stats/incr/maape","incrmae":"@stdlib/stats/incr/mae","incrmapcorr":"@stdlib/stats/incr/mapcorr","incrmape":"@stdlib/stats/incr/mape","incrmax":"@stdlib/stats/incr/max","incrmaxabs":"@stdlib/stats/incr/maxabs","incrmcovariance":"@stdlib/stats/incr/mcovariance","incrmcv":"@stdlib/stats/incr/mcv","incrmda":"@stdlib/stats/incr/mda","incrme":"@stdlib/stats/incr/me","incrmean":"@stdlib/stats/incr/mean","incrmeanabs":"@stdlib/stats/incr/meanabs","incrmeanabs2":"@stdlib/stats/incr/meanabs2","incrmeanstdev":"@stdlib/stats/incr/meanstdev","incrmeanvar":"@stdlib/stats/incr/meanvar","incrmgmean":"@stdlib/stats/incr/mgmean","incrmgrubbs":"@stdlib/stats/incr/mgrubbs","incrmhmean":"@stdlib/stats/incr/mhmean","incrmidrange":"@stdlib/stats/incr/midrange","incrmin":"@stdlib/stats/incr/min","incrminabs":"@stdlib/stats/incr/minabs","incrminmax":"@stdlib/stats/incr/minmax","incrminmaxabs":"@stdlib/stats/incr/minmaxabs","incrmmaape":"@stdlib/stats/incr/mmaape","incrmmae":"@stdlib/stats/incr/mmae","incrmmape":"@stdlib/stats/incr/mmape","incrmmax":"@stdlib/stats/incr/mmax","incrmmaxabs":"@stdlib/stats/incr/mmaxabs","incrmmda":"@stdlib/stats/incr/mmda","incrmme":"@stdlib/stats/incr/mme","incrmmean":"@stdlib/stats/incr/mmean","incrmmeanabs":"@stdlib/stats/incr/mmeanabs","incrmmeanabs2":"@stdlib/stats/incr/mmeanabs2","incrmmeanstdev":"@stdlib/stats/incr/mmeanstdev","incrmmeanvar":"@stdlib/stats/incr/mmeanvar","incrmmidrange":"@stdlib/stats/incr/mmidrange","incrmmin":"@stdlib/stats/incr/mmin","incrmminabs":"@stdlib/stats/incr/mminabs","incrmminmax":"@stdlib/stats/incr/mminmax","incrmminmaxabs":"@stdlib/stats/incr/mminmaxabs","incrmmpe":"@stdlib/stats/incr/mmpe","incrmmse":"@stdlib/stats/incr/mmse","incrmpcorr":"@stdlib/stats/incr/mpcorr","incrmpcorr2":"@stdlib/stats/incr/mpcorr2","incrmpcorrdist":"@stdlib/stats/incr/mpcorrdist","incrmpe":"@stdlib/stats/incr/mpe","incrmprod":"@stdlib/stats/incr/mprod","incrmrange":"@stdlib/stats/incr/mrange","incrmrmse":"@stdlib/stats/incr/mrmse","incrmrss":"@stdlib/stats/incr/mrss","incrmse":"@stdlib/stats/incr/mse","incrmstdev":"@stdlib/stats/incr/mstdev","incrmsum":"@stdlib/stats/incr/msum","incrmsumabs":"@stdlib/stats/incr/msumabs","incrmsumabs2":"@stdlib/stats/incr/msumabs2","incrmsummary":"@stdlib/stats/incr/msummary","incrmsumprod":"@stdlib/stats/incr/msumprod","incrmvariance":"@stdlib/stats/incr/mvariance","incrmvmr":"@stdlib/stats/incr/mvmr","incrnancount":"@stdlib/stats/incr/nancount","incrnansum":"@stdlib/stats/incr/nansum","incrnansumabs":"@stdlib/stats/incr/nansumabs","incrnansumabs2":"@stdlib/stats/incr/nansumabs2","incrpcorr":"@stdlib/stats/incr/pcorr","incrpcorr2":"@stdlib/stats/incr/pcorr2","incrpcorrdist":"@stdlib/stats/incr/pcorrdist","incrpcorrdistmat":"@stdlib/stats/incr/pcorrdistmat","incrpcorrmat":"@stdlib/stats/incr/pcorrmat","incrprod":"@stdlib/stats/incr/prod","incrrange":"@stdlib/stats/incr/range","incrrmse":"@stdlib/stats/incr/rmse","incrrss":"@stdlib/stats/incr/rss","incrSGDRegression":"@stdlib/ml/incr/sgd-regression","incrskewness":"@stdlib/stats/incr/skewness","incrspace":"@stdlib/array/incrspace","incrstdev":"@stdlib/stats/incr/stdev","incrsum":"@stdlib/stats/incr/sum","incrsumabs":"@stdlib/stats/incr/sumabs","incrsumabs2":"@stdlib/stats/incr/sumabs2","incrsummary":"@stdlib/stats/incr/summary","incrsumprod":"@stdlib/stats/incr/sumprod","incrvariance":"@stdlib/stats/incr/variance","incrvmr":"@stdlib/stats/incr/vmr","incrwmean":"@stdlib/stats/incr/wmean","ind2sub":"@stdlib/ndarray/ind2sub","indexOf":"@stdlib/utils/index-of","inherit":"@stdlib/utils/inherit","inheritedEnumerableProperties":"@stdlib/utils/inherited-enumerable-properties","inheritedEnumerablePropertySymbols":"@stdlib/utils/inherited-enumerable-property-symbols","inheritedKeys":"@stdlib/utils/inherited-keys","inheritedNonEnumerableProperties":"@stdlib/utils/inherited-nonenumerable-properties","inheritedNonEnumerablePropertyNames":"@stdlib/utils/inherited-nonenumerable-property-names","inheritedNonEnumerablePropertySymbols":"@stdlib/utils/inherited-nonenumerable-property-symbols","inheritedProperties":"@stdlib/utils/inherited-properties","inheritedPropertyDescriptor":"@stdlib/utils/inherited-property-descriptor","inheritedPropertyDescriptors":"@stdlib/utils/inherited-property-descriptors","inheritedPropertyNames":"@stdlib/utils/inherited-property-names","inheritedPropertySymbols":"@stdlib/utils/inherited-property-symbols","inheritedWritableProperties":"@stdlib/utils/inherited-writable-properties","inheritedWritablePropertyNames":"@stdlib/utils/inherited-writable-property-names","inheritedWritablePropertySymbols":"@stdlib/utils/inherited-writable-property-symbols","inmap":"@stdlib/utils/inmap","inmapAsync":"@stdlib/utils/async/inmap","inmapRight":"@stdlib/utils/inmap-right","inmapRightAsync":"@stdlib/utils/async/inmap-right","inspectSinkStream":"@stdlib/streams/node/inspect-sink","inspectStream":"@stdlib/streams/node/inspect","instanceOf":"@stdlib/assert/instance-of","INT8_MAX":"@stdlib/constants/int8/max","INT8_MIN":"@stdlib/constants/int8/min","INT8_NUM_BYTES":"@stdlib/constants/int8/num-bytes","Int8Array":"@stdlib/array/int8","INT16_MAX":"@stdlib/constants/int16/max","INT16_MIN":"@stdlib/constants/int16/min","INT16_NUM_BYTES":"@stdlib/constants/int16/num-bytes","Int16Array":"@stdlib/array/int16","INT32_MAX":"@stdlib/constants/int32/max","INT32_MIN":"@stdlib/constants/int32/min","INT32_NUM_BYTES":"@stdlib/constants/int32/num-bytes","Int32Array":"@stdlib/array/int32","IS_BIG_ENDIAN":"@stdlib/assert/is-big-endian","IS_BROWSER":"@stdlib/assert/is-browser","IS_DARWIN":"@stdlib/assert/is-darwin","IS_DOCKER":"@stdlib/assert/is-docker","IS_ELECTRON":"@stdlib/assert/is-electron","IS_ELECTRON_MAIN":"@stdlib/assert/is-electron-main","IS_ELECTRON_RENDERER":"@stdlib/assert/is-electron-renderer","IS_LITTLE_ENDIAN":"@stdlib/assert/is-little-endian","IS_MOBILE":"@stdlib/assert/is-mobile","IS_NODE":"@stdlib/assert/is-node","IS_TOUCH_DEVICE":"@stdlib/assert/is-touch-device","IS_WEB_WORKER":"@stdlib/assert/is-web-worker","IS_WINDOWS":"@stdlib/assert/is-windows","isAbsoluteHttpURI":"@stdlib/assert/is-absolute-http-uri","isAbsolutePath":"@stdlib/assert/is-absolute-path","isAbsoluteURI":"@stdlib/assert/is-absolute-uri","isAccessorArray":"@stdlib/assert/is-accessor-array","isAccessorProperty":"@stdlib/assert/is-accessor-property","isAccessorPropertyIn":"@stdlib/assert/is-accessor-property-in","isAlphagram":"@stdlib/assert/is-alphagram","isAlphaNumeric":"@stdlib/assert/is-alphanumeric","isAnagram":"@stdlib/assert/is-anagram","isArguments":"@stdlib/assert/is-arguments","isArray":"@stdlib/assert/is-array","isArrayArray":"@stdlib/assert/is-array-array","isArrayBuffer":"@stdlib/assert/is-arraybuffer","isArrayBufferView":"@stdlib/assert/is-arraybuffer-view","isArrayLength":"@stdlib/assert/is-array-length","isArrayLike":"@stdlib/assert/is-array-like","isArrayLikeObject":"@stdlib/assert/is-array-like-object","isArrowFunction":"@stdlib/assert/is-arrow-function","isASCII":"@stdlib/assert/is-ascii","isBetween":"@stdlib/assert/is-between","isBetweenArray":"@stdlib/assert/is-between-array","isBigInt":"@stdlib/assert/is-bigint","isBigInt64Array":"@stdlib/assert/is-bigint64array","isBigUint64Array":"@stdlib/assert/is-biguint64array","isBinaryString":"@stdlib/assert/is-binary-string","isBlankString":"@stdlib/assert/is-blank-string","isBoolean":"@stdlib/assert/is-boolean","isBooleanArray":"@stdlib/assert/is-boolean-array","isBoxedPrimitive":"@stdlib/assert/is-boxed-primitive","isBuffer":"@stdlib/assert/is-buffer","isCamelcase":"@stdlib/assert/is-camelcase","isCapitalized":"@stdlib/assert/is-capitalized","isCentrosymmetricMatrix":"@stdlib/assert/is-centrosymmetric-matrix","isCircular":"@stdlib/assert/is-circular","isCircularArray":"@stdlib/assert/is-circular-array","isCircularPlainObject":"@stdlib/assert/is-circular-plain-object","isClass":"@stdlib/assert/is-class","isCollection":"@stdlib/assert/is-collection","isComplex":"@stdlib/assert/is-complex","isComplex64":"@stdlib/assert/is-complex64","isComplex64Array":"@stdlib/assert/is-complex64array","isComplex64MatrixLike":"@stdlib/assert/is-complex64matrix-like","isComplex64ndarrayLike":"@stdlib/assert/is-complex64ndarray-like","isComplex64VectorLike":"@stdlib/assert/is-complex64vector-like","isComplex128":"@stdlib/assert/is-complex128","isComplex128Array":"@stdlib/assert/is-complex128array","isComplex128MatrixLike":"@stdlib/assert/is-complex128matrix-like","isComplex128ndarrayLike":"@stdlib/assert/is-complex128ndarray-like","isComplex128VectorLike":"@stdlib/assert/is-complex128vector-like","isComplexLike":"@stdlib/assert/is-complex-like","isComplexTypedArray":"@stdlib/assert/is-complex-typed-array","isComplexTypedArrayLike":"@stdlib/assert/is-complex-typed-array-like","isComposite":"@stdlib/assert/is-composite","isConfigurableProperty":"@stdlib/assert/is-configurable-property","isConfigurablePropertyIn":"@stdlib/assert/is-configurable-property-in","isConstantcase":"@stdlib/assert/is-constantcase","isCubeNumber":"@stdlib/assert/is-cube-number","isCurrentYear":"@stdlib/assert/is-current-year","isDataProperty":"@stdlib/assert/is-data-property","isDataPropertyIn":"@stdlib/assert/is-data-property-in","isDataView":"@stdlib/assert/is-dataview","isDateObject":"@stdlib/assert/is-date-object","isDateObjectArray":"@stdlib/assert/is-date-object-array","isDigitString":"@stdlib/assert/is-digit-string","isDomainName":"@stdlib/assert/is-domain-name","isDurationString":"@stdlib/assert/is-duration-string","isEmailAddress":"@stdlib/assert/is-email-address","isEmptyArray":"@stdlib/assert/is-empty-array","isEmptyArrayLikeObject":"@stdlib/assert/is-empty-array-like-object","isEmptyCollection":"@stdlib/assert/is-empty-collection","isEmptyObject":"@stdlib/assert/is-empty-object","isEmptyString":"@stdlib/assert/is-empty-string","isEnumerableProperty":"@stdlib/assert/is-enumerable-property","isEnumerablePropertyIn":"@stdlib/assert/is-enumerable-property-in","isEqualArray":"@stdlib/assert/is-equal-array","isError":"@stdlib/assert/is-error","isEvalError":"@stdlib/assert/is-eval-error","isEven":"@stdlib/assert/is-even","isFalsy":"@stdlib/assert/is-falsy","isFalsyArray":"@stdlib/assert/is-falsy-array","isFinite":"@stdlib/assert/is-finite","isFiniteArray":"@stdlib/assert/is-finite-array","isFloat32Array":"@stdlib/assert/is-float32array","isFloat32MatrixLike":"@stdlib/assert/is-float32matrix-like","isFloat32ndarrayLike":"@stdlib/assert/is-float32ndarray-like","isFloat32VectorLike":"@stdlib/assert/is-float32vector-like","isFloat64Array":"@stdlib/assert/is-float64array","isFloat64MatrixLike":"@stdlib/assert/is-float64matrix-like","isFloat64ndarrayLike":"@stdlib/assert/is-float64ndarray-like","isFloat64VectorLike":"@stdlib/assert/is-float64vector-like","isFunction":"@stdlib/assert/is-function","isFunctionArray":"@stdlib/assert/is-function-array","isGeneratorObject":"@stdlib/assert/is-generator-object","isGeneratorObjectLike":"@stdlib/assert/is-generator-object-like","isgzipBuffer":"@stdlib/assert/is-gzip-buffer","isHexString":"@stdlib/assert/is-hex-string","isInfinite":"@stdlib/assert/is-infinite","isInheritedProperty":"@stdlib/assert/is-inherited-property","isInt8Array":"@stdlib/assert/is-int8array","isInt16Array":"@stdlib/assert/is-int16array","isInt32Array":"@stdlib/assert/is-int32array","isInteger":"@stdlib/assert/is-integer","isIntegerArray":"@stdlib/assert/is-integer-array","isIterableLike":"@stdlib/assert/is-iterable-like","isIteratorLike":"@stdlib/assert/is-iterator-like","isJSON":"@stdlib/assert/is-json","isKebabcase":"@stdlib/assert/is-kebabcase","isLeapYear":"@stdlib/assert/is-leap-year","isLocalhost":"@stdlib/assert/is-localhost","isLowercase":"@stdlib/assert/is-lowercase","isMatrixLike":"@stdlib/assert/is-matrix-like","isMethod":"@stdlib/assert/is-method","isMethodIn":"@stdlib/assert/is-method-in","isMultiSlice":"@stdlib/assert/is-multi-slice","isNamedTypedTupleLike":"@stdlib/assert/is-named-typed-tuple-like","isnan":"@stdlib/assert/is-nan","isNaNArray":"@stdlib/assert/is-nan-array","isNativeFunction":"@stdlib/assert/is-native-function","isndarrayLike":"@stdlib/assert/is-ndarray-like","isndarrayLikeWithDataType":"@stdlib/assert/is-ndarray-like-with-data-type","isNegativeFinite":"@stdlib/assert/is-negative-finite","isNegativeInteger":"@stdlib/assert/is-negative-integer","isNegativeIntegerArray":"@stdlib/assert/is-negative-integer-array","isNegativeNumber":"@stdlib/assert/is-negative-number","isNegativeNumberArray":"@stdlib/assert/is-negative-number-array","isNegativeZero":"@stdlib/assert/is-negative-zero","isNodeBuiltin":"@stdlib/assert/is-node-builtin","isNodeDuplexStreamLike":"@stdlib/assert/is-node-duplex-stream-like","isNodeReadableStreamLike":"@stdlib/assert/is-node-readable-stream-like","isNodeREPL":"@stdlib/assert/is-node-repl","isNodeStreamLike":"@stdlib/assert/is-node-stream-like","isNodeTransformStreamLike":"@stdlib/assert/is-node-transform-stream-like","isNodeWritableStreamLike":"@stdlib/assert/is-node-writable-stream-like","isNonConfigurableProperty":"@stdlib/assert/is-nonconfigurable-property","isNonConfigurablePropertyIn":"@stdlib/assert/is-nonconfigurable-property-in","isNonEnumerableProperty":"@stdlib/assert/is-nonenumerable-property","isNonEnumerablePropertyIn":"@stdlib/assert/is-nonenumerable-property-in","isNonNegativeFinite":"@stdlib/assert/is-nonnegative-finite","isNonNegativeInteger":"@stdlib/assert/is-nonnegative-integer","isNonNegativeIntegerArray":"@stdlib/assert/is-nonnegative-integer-array","isNonNegativeNumber":"@stdlib/assert/is-nonnegative-number","isNonNegativeNumberArray":"@stdlib/assert/is-nonnegative-number-array","isNonPositiveFinite":"@stdlib/assert/is-nonpositive-finite","isNonPositiveInteger":"@stdlib/assert/is-nonpositive-integer","isNonPositiveIntegerArray":"@stdlib/assert/is-nonpositive-integer-array","isNonPositiveNumber":"@stdlib/assert/is-nonpositive-number","isNonPositiveNumberArray":"@stdlib/assert/is-nonpositive-number-array","isNonSymmetricMatrix":"@stdlib/assert/is-nonsymmetric-matrix","isNull":"@stdlib/assert/is-null","isNullArray":"@stdlib/assert/is-null-array","isNumber":"@stdlib/assert/is-number","isNumberArray":"@stdlib/assert/is-number-array","isNumericArray":"@stdlib/assert/is-numeric-array","isObject":"@stdlib/assert/is-object","isObjectArray":"@stdlib/assert/is-object-array","isObjectLike":"@stdlib/assert/is-object-like","isOdd":"@stdlib/assert/is-odd","isoWeeksInYear":"@stdlib/time/iso-weeks-in-year","isPascalcase":"@stdlib/assert/is-pascalcase","isPersymmetricMatrix":"@stdlib/assert/is-persymmetric-matrix","isPlainObject":"@stdlib/assert/is-plain-object","isPlainObjectArray":"@stdlib/assert/is-plain-object-array","isPositiveFinite":"@stdlib/assert/is-positive-finite","isPositiveInteger":"@stdlib/assert/is-positive-integer","isPositiveIntegerArray":"@stdlib/assert/is-positive-integer-array","isPositiveNumber":"@stdlib/assert/is-positive-number","isPositiveNumberArray":"@stdlib/assert/is-positive-number-array","isPositiveZero":"@stdlib/assert/is-positive-zero","isPrime":"@stdlib/assert/is-prime","isPrimitive":"@stdlib/assert/is-primitive","isPrimitiveArray":"@stdlib/assert/is-primitive-array","isPRNGLike":"@stdlib/assert/is-prng-like","isProbability":"@stdlib/assert/is-probability","isProbabilityArray":"@stdlib/assert/is-probability-array","isPropertyKey":"@stdlib/assert/is-property-key","isPrototypeOf":"@stdlib/assert/is-prototype-of","isRaggedNestedArray":"@stdlib/assert/is-ragged-nested-array","isRangeError":"@stdlib/assert/is-range-error","isReadableProperty":"@stdlib/assert/is-readable-property","isReadablePropertyIn":"@stdlib/assert/is-readable-property-in","isReadOnlyProperty":"@stdlib/assert/is-read-only-property","isReadOnlyPropertyIn":"@stdlib/assert/is-read-only-property-in","isReadWriteProperty":"@stdlib/assert/is-read-write-property","isReadWritePropertyIn":"@stdlib/assert/is-read-write-property-in","isReferenceError":"@stdlib/assert/is-reference-error","isRegExp":"@stdlib/assert/is-regexp","isRegExpString":"@stdlib/assert/is-regexp-string","isRelativePath":"@stdlib/assert/is-relative-path","isRelativeURI":"@stdlib/assert/is-relative-uri","isSafeInteger":"@stdlib/assert/is-safe-integer","isSafeIntegerArray":"@stdlib/assert/is-safe-integer-array","isSameArray":"@stdlib/assert/is-same-array","isSameArrayLike":"@stdlib/assert/is-same-array-like","isSameComplex64":"@stdlib/assert/is-same-complex64","isSameComplex64Array":"@stdlib/assert/is-same-complex64array","isSameComplex128":"@stdlib/assert/is-same-complex128","isSameComplex128Array":"@stdlib/assert/is-same-complex128array","isSameDateObject":"@stdlib/assert/is-same-date-object","isSameFloat32Array":"@stdlib/assert/is-same-float32array","isSameFloat64Array":"@stdlib/assert/is-same-float64array","isSameNativeClass":"@stdlib/assert/is-same-native-class","isSameType":"@stdlib/assert/is-same-type","isSameValue":"@stdlib/assert/is-same-value","isSameValueZero":"@stdlib/assert/is-same-value-zero","isSemVer":"@stdlib/assert/is-semver","isSharedArrayBuffer":"@stdlib/assert/is-sharedarraybuffer","isSkewCentrosymmetricMatrix":"@stdlib/assert/is-skew-centrosymmetric-matrix","isSkewPersymmetricMatrix":"@stdlib/assert/is-skew-persymmetric-matrix","isSkewSymmetricMatrix":"@stdlib/assert/is-skew-symmetric-matrix","isSlice":"@stdlib/assert/is-slice","isSnakecase":"@stdlib/assert/is-snakecase","isSquareMatrix":"@stdlib/assert/is-square-matrix","isSquareNumber":"@stdlib/assert/is-square-number","isSquareTriangularNumber":"@stdlib/assert/is-square-triangular-number","isStartcase":"@stdlib/assert/is-startcase","isStrictEqual":"@stdlib/assert/is-strict-equal","isString":"@stdlib/assert/is-string","isStringArray":"@stdlib/assert/is-string-array","isSymbol":"@stdlib/assert/is-symbol","isSymbolArray":"@stdlib/assert/is-symbol-array","isSymmetricMatrix":"@stdlib/assert/is-symmetric-matrix","isSyntaxError":"@stdlib/assert/is-syntax-error","isTriangularNumber":"@stdlib/assert/is-triangular-number","isTruthy":"@stdlib/assert/is-truthy","isTruthyArray":"@stdlib/assert/is-truthy-array","isTypedArray":"@stdlib/assert/is-typed-array","isTypedArrayLength":"@stdlib/assert/is-typed-array-length","isTypedArrayLike":"@stdlib/assert/is-typed-array-like","isTypeError":"@stdlib/assert/is-type-error","isUint8Array":"@stdlib/assert/is-uint8array","isUint8ClampedArray":"@stdlib/assert/is-uint8clampedarray","isUint16Array":"@stdlib/assert/is-uint16array","isUint32Array":"@stdlib/assert/is-uint32array","isUNCPath":"@stdlib/assert/is-unc-path","isUndefined":"@stdlib/assert/is-undefined","isUndefinedOrNull":"@stdlib/assert/is-undefined-or-null","isUnityProbabilityArray":"@stdlib/assert/is-unity-probability-array","isUppercase":"@stdlib/assert/is-uppercase","isURI":"@stdlib/assert/is-uri","isURIError":"@stdlib/assert/is-uri-error","isVectorLike":"@stdlib/assert/is-vector-like","isWebAssemblyMemory":"@stdlib/assert/is-wasm-memory","isWellFormedString":"@stdlib/assert/is-well-formed-string","isWhitespace":"@stdlib/assert/is-whitespace","isWritableProperty":"@stdlib/assert/is-writable-property","isWritablePropertyIn":"@stdlib/assert/is-writable-property-in","isWriteOnlyProperty":"@stdlib/assert/is-write-only-property","isWriteOnlyPropertyIn":"@stdlib/assert/is-write-only-property-in","iterAbs":"@stdlib/math/iter/special/abs","iterAbs2":"@stdlib/math/iter/special/abs2","iterAcos":"@stdlib/math/iter/special/acos","iterAcosh":"@stdlib/math/iter/special/acosh","iterAcot":"@stdlib/math/iter/special/acot","iterAcoth":"@stdlib/math/iter/special/acoth","iterAcovercos":"@stdlib/math/iter/special/acovercos","iterAcoversin":"@stdlib/math/iter/special/acoversin","iterAdd":"@stdlib/math/iter/ops/add","iterAdvance":"@stdlib/iter/advance","iterAhavercos":"@stdlib/math/iter/special/ahavercos","iterAhaversin":"@stdlib/math/iter/special/ahaversin","iterAny":"@stdlib/iter/any","iterAnyBy":"@stdlib/iter/any-by","iterAsin":"@stdlib/math/iter/special/asin","iterAsinh":"@stdlib/math/iter/special/asinh","iterAtan":"@stdlib/math/iter/special/atan","iterAtan2":"@stdlib/math/iter/special/atan2","iterAtanh":"@stdlib/math/iter/special/atanh","iterator2array":"@stdlib/array/from-iterator","iterator2arrayview":"@stdlib/iter/to-array-view","iterator2arrayviewRight":"@stdlib/iter/to-array-view-right","iteratorStream":"@stdlib/streams/node/from-iterator","IteratorSymbol":"@stdlib/symbol/iterator","iterAvercos":"@stdlib/math/iter/special/avercos","iterAversin":"@stdlib/math/iter/special/aversin","iterawgn":"@stdlib/simulate/iter/awgn","iterawln":"@stdlib/simulate/iter/awln","iterawun":"@stdlib/simulate/iter/awun","iterBartlettHannPulse":"@stdlib/simulate/iter/bartlett-hann-pulse","iterBartlettPulse":"@stdlib/simulate/iter/bartlett-pulse","iterBesselj0":"@stdlib/math/iter/special/besselj0","iterBesselj1":"@stdlib/math/iter/special/besselj1","iterBessely0":"@stdlib/math/iter/special/bessely0","iterBessely1":"@stdlib/math/iter/special/bessely1","iterBeta":"@stdlib/math/iter/special/beta","iterBetaln":"@stdlib/math/iter/special/betaln","iterBinet":"@stdlib/math/iter/special/binet","iterCbrt":"@stdlib/math/iter/special/cbrt","iterCeil":"@stdlib/math/iter/special/ceil","iterCeil2":"@stdlib/math/iter/special/ceil2","iterCeil10":"@stdlib/math/iter/special/ceil10","iterCompositesSeq":"@stdlib/math/iter/sequences/composites","iterConcat":"@stdlib/iter/concat","iterConstant":"@stdlib/iter/constant","iterContinuedFraction":"@stdlib/math/iter/utils/continued-fraction","iterContinuedFractionSeq":"@stdlib/math/iter/sequences/continued-fraction","iterCos":"@stdlib/math/iter/special/cos","iterCosh":"@stdlib/math/iter/special/cosh","iterCosineWave":"@stdlib/simulate/iter/cosine-wave","iterCosm1":"@stdlib/math/iter/special/cosm1","iterCospi":"@stdlib/math/iter/special/cospi","iterCounter":"@stdlib/iter/counter","iterCovercos":"@stdlib/math/iter/special/covercos","iterCoversin":"@stdlib/math/iter/special/coversin","iterCubesSeq":"@stdlib/math/iter/sequences/cubes","itercugmean":"@stdlib/stats/iter/cugmean","itercuhmean":"@stdlib/stats/iter/cuhmean","itercumax":"@stdlib/stats/iter/cumax","itercumaxabs":"@stdlib/stats/iter/cumaxabs","itercumean":"@stdlib/stats/iter/cumean","itercumeanabs":"@stdlib/stats/iter/cumeanabs","itercumeanabs2":"@stdlib/stats/iter/cumeanabs2","itercumidrange":"@stdlib/stats/iter/cumidrange","itercumin":"@stdlib/stats/iter/cumin","itercuminabs":"@stdlib/stats/iter/cuminabs","itercuprod":"@stdlib/stats/iter/cuprod","itercurange":"@stdlib/stats/iter/curange","itercusum":"@stdlib/stats/iter/cusum","itercusumabs":"@stdlib/stats/iter/cusumabs","itercusumabs2":"@stdlib/stats/iter/cusumabs2","iterDatespace":"@stdlib/iter/datespace","iterDedupe":"@stdlib/iter/dedupe","iterDedupeBy":"@stdlib/iter/dedupe-by","iterDeg2rad":"@stdlib/math/iter/special/deg2rad","iterDigamma":"@stdlib/math/iter/special/digamma","iterDiracComb":"@stdlib/simulate/iter/dirac-comb","iterDiracDelta":"@stdlib/math/iter/special/dirac-delta","iterDivide":"@stdlib/math/iter/ops/divide","iterDoUntilEach":"@stdlib/iter/do-until-each","iterDoWhileEach":"@stdlib/iter/do-while-each","iterEllipe":"@stdlib/math/iter/special/ellipe","iterEllipk":"@stdlib/math/iter/special/ellipk","iterEmpty":"@stdlib/iter/empty","iterErf":"@stdlib/math/iter/special/erf","iterErfc":"@stdlib/math/iter/special/erfc","iterErfcinv":"@stdlib/math/iter/special/erfcinv","iterErfinv":"@stdlib/math/iter/special/erfinv","iterEta":"@stdlib/math/iter/special/dirichlet-eta","iterEvenIntegersSeq":"@stdlib/math/iter/sequences/even-integers","iterEvery":"@stdlib/iter/every","iterEveryBy":"@stdlib/iter/every-by","iterExp":"@stdlib/math/iter/special/exp","iterExp2":"@stdlib/math/iter/special/exp2","iterExp10":"@stdlib/math/iter/special/exp10","iterExpit":"@stdlib/math/iter/special/expit","iterExpm1":"@stdlib/math/iter/special/expm1","iterExpm1rel":"@stdlib/math/iter/special/expm1rel","iterFactorial":"@stdlib/math/iter/special/factorial","iterFactorialln":"@stdlib/math/iter/special/factorialln","iterFactorialsSeq":"@stdlib/math/iter/sequences/factorials","iterFibonacciSeq":"@stdlib/math/iter/sequences/fibonacci","iterFifthPowersSeq":"@stdlib/math/iter/sequences/fifth-powers","iterFill":"@stdlib/iter/fill","iterFilter":"@stdlib/iter/filter","iterFilterMap":"@stdlib/iter/filter-map","iterFirst":"@stdlib/iter/first","iterFlatTopPulse":"@stdlib/simulate/iter/flat-top-pulse","iterFloor":"@stdlib/math/iter/special/floor","iterFloor2":"@stdlib/math/iter/special/floor2","iterFloor10":"@stdlib/math/iter/special/floor10","iterFlow":"@stdlib/iter/flow","iterForEach":"@stdlib/iter/for-each","iterFourthPowersSeq":"@stdlib/math/iter/sequences/fourth-powers","iterFresnelc":"@stdlib/math/iter/special/fresnelc","iterFresnels":"@stdlib/math/iter/special/fresnels","iterGamma":"@stdlib/math/iter/special/gamma","iterGamma1pm1":"@stdlib/math/iter/special/gamma1pm1","iterGammaln":"@stdlib/math/iter/special/gammaln","iterHacovercos":"@stdlib/math/iter/special/hacovercos","iterHacoversin":"@stdlib/math/iter/special/hacoversin","iterHannPulse":"@stdlib/simulate/iter/hann-pulse","iterHavercos":"@stdlib/math/iter/special/havercos","iterHaversin":"@stdlib/math/iter/special/haversin","iterHead":"@stdlib/iter/head","iterIncrspace":"@stdlib/iter/incrspace","iterIntegersSeq":"@stdlib/math/iter/sequences/integers","iterIntersection":"@stdlib/iter/intersection","iterIntersectionByHash":"@stdlib/iter/intersection-by-hash","iterInv":"@stdlib/math/iter/special/inv","iterLanczosPulse":"@stdlib/simulate/iter/lanczos-pulse","iterLast":"@stdlib/iter/last","iterLength":"@stdlib/iter/length","iterLinspace":"@stdlib/iter/linspace","iterLn":"@stdlib/math/iter/special/ln","iterLog":"@stdlib/math/iter/special/log","iterLog1mexp":"@stdlib/math/iter/special/log1mexp","iterLog1p":"@stdlib/math/iter/special/log1p","iterLog1pexp":"@stdlib/math/iter/special/log1pexp","iterLog2":"@stdlib/math/iter/special/log2","iterLog10":"@stdlib/math/iter/special/log10","iterLogit":"@stdlib/math/iter/special/logit","iterLogspace":"@stdlib/iter/logspace","iterLucasSeq":"@stdlib/math/iter/sequences/lucas","iterMap":"@stdlib/iter/map","iterMapN":"@stdlib/iter/mapn","itermax":"@stdlib/stats/iter/max","itermaxabs":"@stdlib/stats/iter/maxabs","itermean":"@stdlib/stats/iter/mean","itermeanabs":"@stdlib/stats/iter/meanabs","itermeanabs2":"@stdlib/stats/iter/meanabs2","itermidrange":"@stdlib/stats/iter/midrange","itermin":"@stdlib/stats/iter/min","iterminabs":"@stdlib/stats/iter/minabs","itermmax":"@stdlib/stats/iter/mmax","itermmaxabs":"@stdlib/stats/iter/mmaxabs","itermmean":"@stdlib/stats/iter/mmean","itermmeanabs":"@stdlib/stats/iter/mmeanabs","itermmeanabs2":"@stdlib/stats/iter/mmeanabs2","itermmidrange":"@stdlib/stats/iter/mmidrange","itermmin":"@stdlib/stats/iter/mmin","itermminabs":"@stdlib/stats/iter/mminabs","iterMod":"@stdlib/math/iter/ops/mod","itermprod":"@stdlib/stats/iter/mprod","itermrange":"@stdlib/stats/iter/mrange","itermsum":"@stdlib/stats/iter/msum","itermsumabs":"@stdlib/stats/iter/msumabs","itermsumabs2":"@stdlib/stats/iter/msumabs2","iterMultiply":"@stdlib/math/iter/ops/multiply","iterNegaFibonacciSeq":"@stdlib/math/iter/sequences/negafibonacci","iterNegaLucasSeq":"@stdlib/math/iter/sequences/negalucas","iterNegativeEvenIntegersSeq":"@stdlib/math/iter/sequences/negative-even-integers","iterNegativeIntegersSeq":"@stdlib/math/iter/sequences/negative-integers","iterNegativeOddIntegersSeq":"@stdlib/math/iter/sequences/negative-odd-integers","iterNone":"@stdlib/iter/none","iterNoneBy":"@stdlib/iter/none-by","iterNonFibonacciSeq":"@stdlib/math/iter/sequences/nonfibonacci","iterNonNegativeEvenIntegersSeq":"@stdlib/math/iter/sequences/nonnegative-even-integers","iterNonNegativeIntegersSeq":"@stdlib/math/iter/sequences/nonnegative-integers","iterNonPositiveEvenIntegersSeq":"@stdlib/math/iter/sequences/nonpositive-even-integers","iterNonPositiveIntegersSeq":"@stdlib/math/iter/sequences/nonpositive-integers","iterNonSquaresSeq":"@stdlib/math/iter/sequences/nonsquares","iterNth":"@stdlib/iter/nth","iterOddIntegersSeq":"@stdlib/math/iter/sequences/odd-integers","iterPeriodicSinc":"@stdlib/simulate/iter/periodic-sinc","iterPipeline":"@stdlib/iter/pipeline","iterPop":"@stdlib/iter/pop","iterPositiveEvenIntegersSeq":"@stdlib/math/iter/sequences/positive-even-integers","iterPositiveIntegersSeq":"@stdlib/math/iter/sequences/positive-integers","iterPositiveOddIntegersSeq":"@stdlib/math/iter/sequences/positive-odd-integers","iterPow":"@stdlib/math/iter/special/pow","iterPrimesSeq":"@stdlib/math/iter/sequences/primes","iterprod":"@stdlib/stats/iter/prod","iterPulse":"@stdlib/simulate/iter/pulse","iterPush":"@stdlib/iter/push","iterRad2deg":"@stdlib/math/iter/special/rad2deg","iterRamp":"@stdlib/math/iter/special/ramp","iterrange":"@stdlib/stats/iter/range","iterReject":"@stdlib/iter/reject","iterReplicate":"@stdlib/iter/replicate","iterReplicateBy":"@stdlib/iter/replicate-by","iterRound":"@stdlib/math/iter/special/round","iterRound2":"@stdlib/math/iter/special/round2","iterRound10":"@stdlib/math/iter/special/round10","iterRsqrt":"@stdlib/math/iter/special/rsqrt","iterSawtoothWave":"@stdlib/simulate/iter/sawtooth-wave","iterShift":"@stdlib/iter/shift","iterSignum":"@stdlib/math/iter/special/signum","iterSin":"@stdlib/math/iter/special/sin","iterSinc":"@stdlib/math/iter/special/sinc","iterSineWave":"@stdlib/simulate/iter/sine-wave","iterSinh":"@stdlib/math/iter/special/sinh","iterSinpi":"@stdlib/math/iter/special/sinpi","iterSlice":"@stdlib/iter/slice","iterSome":"@stdlib/iter/some","iterSomeBy":"@stdlib/iter/some-by","iterSpence":"@stdlib/math/iter/special/spence","iterSqrt":"@stdlib/math/iter/special/sqrt","iterSqrt1pm1":"@stdlib/math/iter/special/sqrt1pm1","iterSquaredTriangularSeq":"@stdlib/math/iter/sequences/squared-triangular","iterSquaresSeq":"@stdlib/math/iter/sequences/squares","iterSquareWave":"@stdlib/simulate/iter/square-wave","iterstdev":"@stdlib/stats/iter/stdev","iterStep":"@stdlib/iter/step","iterStrided":"@stdlib/iter/strided","iterStridedBy":"@stdlib/iter/strided-by","iterSubtract":"@stdlib/math/iter/ops/subtract","itersum":"@stdlib/stats/iter/sum","itersumabs":"@stdlib/stats/iter/sumabs","itersumabs2":"@stdlib/stats/iter/sumabs2","iterTan":"@stdlib/math/iter/special/tan","iterTanh":"@stdlib/math/iter/special/tanh","iterThunk":"@stdlib/iter/pipeline-thunk","iterTriangleWave":"@stdlib/simulate/iter/triangle-wave","iterTriangularSeq":"@stdlib/math/iter/sequences/triangular","iterTribonnaciSeq":"@stdlib/math/iter/sequences/tribonacci","iterTrigamma":"@stdlib/math/iter/special/trigamma","iterTrunc":"@stdlib/math/iter/special/trunc","iterTrunc2":"@stdlib/math/iter/special/trunc2","iterTrunc10":"@stdlib/math/iter/special/trunc10","iterUnion":"@stdlib/iter/union","iterUnique":"@stdlib/iter/unique","iterUniqueBy":"@stdlib/iter/unique-by","iterUniqueByHash":"@stdlib/iter/unique-by-hash","iterUnitspace":"@stdlib/iter/unitspace","iterUnshift":"@stdlib/iter/unshift","iterUntilEach":"@stdlib/iter/until-each","itervariance":"@stdlib/stats/iter/variance","iterVercos":"@stdlib/math/iter/special/vercos","iterVersin":"@stdlib/math/iter/special/versin","iterWhileEach":"@stdlib/iter/while-each","iterZeta":"@stdlib/math/iter/special/riemann-zeta","joinStream":"@stdlib/streams/node/join","kde2d":"@stdlib/stats/kde2d","kebabcase":"@stdlib/string/kebabcase","keyBy":"@stdlib/utils/key-by","keyByRight":"@stdlib/utils/key-by-right","keysIn":"@stdlib/utils/keys-in","kruskalTest":"@stdlib/stats/kruskal-test","kstest":"@stdlib/stats/kstest","last":"@stdlib/string/last","lda":"@stdlib/nlp/lda","leveneTest":"@stdlib/stats/levene-test","LinkedList":"@stdlib/dstructs/linked-list","linspace":"@stdlib/array/linspace","LIU_NEGATIVE_OPINION_WORDS_EN":"@stdlib/datasets/liu-negative-opinion-words-en","LIU_POSITIVE_OPINION_WORDS_EN":"@stdlib/datasets/liu-positive-opinion-words-en","LN_HALF":"@stdlib/constants/float64/ln-half","LN_PI":"@stdlib/constants/float64/ln-pi","LN_SQRT_TWO_PI":"@stdlib/constants/float64/ln-sqrt-two-pi","LN_TWO_PI":"@stdlib/constants/float64/ln-two-pi","LN2":"@stdlib/constants/float64/ln-two","LN10":"@stdlib/constants/float64/ln-ten","LOG2E":"@stdlib/constants/float64/log2-e","LOG10E":"@stdlib/constants/float64/log10-e","logspace":"@stdlib/array/logspace","lowercase":"@stdlib/string/lowercase","lowercaseKeys":"@stdlib/utils/lowercase-keys","lowess":"@stdlib/stats/lowess","lpad":"@stdlib/string/left-pad","ltrim":"@stdlib/string/left-trim","ltrimN":"@stdlib/string/left-trim-n","MALE_FIRST_NAMES_EN":"@stdlib/datasets/male-first-names-en","map":"@stdlib/utils/map","map2":"@stdlib/utils/map2","map2d":"@stdlib/utils/map2d","map2Right":"@stdlib/utils/map2-right","map3d":"@stdlib/utils/map3d","map4d":"@stdlib/utils/map4d","map5d":"@stdlib/utils/map5d","mapArguments":"@stdlib/utils/map-arguments","mapFun":"@stdlib/utils/map-function","mapFunAsync":"@stdlib/utils/async/map-function","mapKeys":"@stdlib/utils/map-keys","mapKeysAsync":"@stdlib/utils/async/map-keys","mapReduce":"@stdlib/utils/map-reduce","mapReduceRight":"@stdlib/utils/map-reduce-right","mapRight":"@stdlib/utils/map-right","mapValues":"@stdlib/utils/map-values","mapValuesAsync":"@stdlib/utils/async/map-values","maskArguments":"@stdlib/utils/mask-arguments","MAX_ARRAY_LENGTH":"@stdlib/constants/array/max-array-length","MAX_TYPED_ARRAY_LENGTH":"@stdlib/constants/array/max-typed-array-length","maybeBroadcastArray":"@stdlib/ndarray/maybe-broadcast-array","maybeBroadcastArrays":"@stdlib/ndarray/maybe-broadcast-arrays","memoize":"@stdlib/utils/memoize","merge":"@stdlib/utils/merge","MILLISECONDS_IN_DAY":"@stdlib/constants/time/milliseconds-in-day","MILLISECONDS_IN_HOUR":"@stdlib/constants/time/milliseconds-in-hour","MILLISECONDS_IN_MINUTE":"@stdlib/constants/time/milliseconds-in-minute","MILLISECONDS_IN_SECOND":"@stdlib/constants/time/milliseconds-in-second","MILLISECONDS_IN_WEEK":"@stdlib/constants/time/milliseconds-in-week","MINARD_NAPOLEONS_MARCH":"@stdlib/datasets/minard-napoleons-march","MINUTES_IN_DAY":"@stdlib/constants/time/minutes-in-day","MINUTES_IN_HOUR":"@stdlib/constants/time/minutes-in-hour","MINUTES_IN_WEEK":"@stdlib/constants/time/minutes-in-week","minutesInMonth":"@stdlib/time/minutes-in-month","minutesInYear":"@stdlib/time/minutes-in-year","MOBY_DICK":"@stdlib/datasets/moby-dick","MONTH_NAMES_EN":"@stdlib/datasets/month-names-en","MONTHS_IN_YEAR":"@stdlib/constants/time/months-in-year","moveProperty":"@stdlib/utils/move-property","MultiSlice":"@stdlib/slice/multi","namedtypedtuple":"@stdlib/dstructs/named-typed-tuple","NAN":"@stdlib/constants/float64/nan","naryFunction":"@stdlib/utils/nary-function","nativeClass":"@stdlib/utils/native-class","ndarray":"@stdlib/ndarray/ctor","ndarray2array":"@stdlib/ndarray/to-array","ndarray2fancy":"@stdlib/ndarray/to-fancy","ndarray2json":"@stdlib/ndarray/to-json","ndarrayCastingModes":"@stdlib/ndarray/casting-modes","ndarrayDataBuffer":"@stdlib/ndarray/data-buffer","ndarrayDataType":"@stdlib/ndarray/dtype","ndarrayDataTypes":"@stdlib/ndarray/dtypes","ndarrayDispatch":"@stdlib/ndarray/dispatch","ndarrayFlag":"@stdlib/ndarray/flag","ndarrayFlags":"@stdlib/ndarray/flags","ndarrayIndexModes":"@stdlib/ndarray/index-modes","ndarraylike2ndarray":"@stdlib/ndarray/ndarraylike2ndarray","ndarrayMinDataType":"@stdlib/ndarray/min-dtype","ndarrayMostlySafeCasts":"@stdlib/ndarray/mostly-safe-casts","ndarrayNextDataType":"@stdlib/ndarray/next-dtype","ndarrayOffset":"@stdlib/ndarray/offset","ndarrayOrder":"@stdlib/ndarray/order","ndarrayOrders":"@stdlib/ndarray/orders","ndarrayPromotionRules":"@stdlib/ndarray/promotion-rules","ndarraySafeCasts":"@stdlib/ndarray/safe-casts","ndarraySameKindCasts":"@stdlib/ndarray/same-kind-casts","ndarrayShape":"@stdlib/ndarray/shape","ndarrayStride":"@stdlib/ndarray/stride","ndarrayStrides":"@stdlib/ndarray/strides","ndat":"@stdlib/ndarray/at","ndempty":"@stdlib/ndarray/empty","ndemptyLike":"@stdlib/ndarray/empty-like","ndfilter":"@stdlib/ndarray/filter","ndfilterMap":"@stdlib/ndarray/filter-map","ndforEach":"@stdlib/ndarray/for-each","ndims":"@stdlib/ndarray/ndims","ndindex":"@stdlib/ndarray/index","nditer2arrayEach":"@stdlib/ndarray/iter/to-array-each","nditerColumnEntries":"@stdlib/ndarray/iter/column-entries","nditerColumns":"@stdlib/ndarray/iter/columns","nditerEntries":"@stdlib/ndarray/iter/entries","nditerIndices":"@stdlib/ndarray/iter/indices","nditerInterleaveSubarrays":"@stdlib/ndarray/iter/interleave-subarrays","nditerMatrices":"@stdlib/ndarray/iter/matrices","nditerMatrixEntries":"@stdlib/ndarray/iter/matrix-entries","nditerRowEntries":"@stdlib/ndarray/iter/row-entries","nditerRows":"@stdlib/ndarray/iter/rows","nditerSelectDimension":"@stdlib/ndarray/iter/select-dimension","nditerStacks":"@stdlib/ndarray/iter/stacks","nditerSubarrays":"@stdlib/ndarray/iter/subarrays","nditerValues":"@stdlib/ndarray/iter/values","ndmap":"@stdlib/ndarray/map","ndreject":"@stdlib/ndarray/reject","ndslice":"@stdlib/ndarray/slice","ndsliceAssign":"@stdlib/ndarray/slice-assign","ndsliceDimension":"@stdlib/ndarray/slice-dimension","ndsliceDimensionFrom":"@stdlib/ndarray/slice-dimension-from","ndsliceDimensionTo":"@stdlib/ndarray/slice-dimension-to","ndsliceFrom":"@stdlib/ndarray/slice-from","ndsliceTo":"@stdlib/ndarray/slice-to","ndzeros":"@stdlib/ndarray/zeros","ndzerosLike":"@stdlib/ndarray/zeros-like","nextGraphemeClusterBreak":"@stdlib/string/next-grapheme-cluster-break","nextTick":"@stdlib/utils/next-tick","NIGHTINGALES_ROSE":"@stdlib/datasets/nightingales-rose","NINF":"@stdlib/constants/float64/ninf","NODE_VERSION":"@stdlib/process/node-version","none":"@stdlib/utils/none","noneBy":"@stdlib/utils/none-by","noneByAsync":"@stdlib/utils/async/none-by","noneByRight":"@stdlib/utils/none-by-right","noneByRightAsync":"@stdlib/utils/async/none-by-right","noneInBy":"@stdlib/utils/none-in-by","nonEnumerableProperties":"@stdlib/utils/nonenumerable-properties","nonEnumerablePropertiesIn":"@stdlib/utils/nonenumerable-properties-in","nonEnumerablePropertyNames":"@stdlib/utils/nonenumerable-property-names","nonEnumerablePropertyNamesIn":"@stdlib/utils/nonenumerable-property-names-in","nonEnumerablePropertySymbols":"@stdlib/utils/nonenumerable-property-symbols","nonEnumerablePropertySymbolsIn":"@stdlib/utils/nonenumerable-property-symbols-in","noneOwnBy":"@stdlib/utils/none-own-by","nonIndexKeys":"@stdlib/utils/nonindex-keys","noop":"@stdlib/utils/noop","now":"@stdlib/time/now","NUM_CPUS":"@stdlib/os/num-cpus","num2words":"@stdlib/string/num2words","Number":"@stdlib/number/ctor","numel":"@stdlib/ndarray/numel","numelDimension":"@stdlib/ndarray/numel-dimension","numGraphemeClusters":"@stdlib/string/num-grapheme-clusters","Object":"@stdlib/object/ctor","objectEntries":"@stdlib/utils/entries","objectEntriesIn":"@stdlib/utils/entries-in","objectFromEntries":"@stdlib/utils/from-entries","objectInverse":"@stdlib/utils/object-inverse","objectInverseBy":"@stdlib/utils/object-inverse-by","objectKeys":"@stdlib/utils/keys","objectValues":"@stdlib/utils/values","objectValuesIn":"@stdlib/utils/values-in","omit":"@stdlib/utils/omit","omitBy":"@stdlib/utils/omit-by","open":"@stdlib/fs/open","openURL":"@stdlib/utils/open-url","ordinalize":"@stdlib/nlp/ordinalize","PACE_BOSTON_HOUSE_PRICES":"@stdlib/datasets/pace-boston-house-prices","pad":"@stdlib/string/pad","padjust":"@stdlib/stats/padjust","papply":"@stdlib/utils/papply","papplyRight":"@stdlib/utils/papply-right","parallel":"@stdlib/utils/parallel","parseJSON":"@stdlib/utils/parse-json","pascalcase":"@stdlib/string/pascalcase","PATH_DELIMITER":"@stdlib/constants/path/delimiter","PATH_DELIMITER_POSIX":"@stdlib/constants/path/delimiter-posix","PATH_DELIMITER_WIN32":"@stdlib/constants/path/delimiter-win32","PATH_SEP":"@stdlib/constants/path/sep","PATH_SEP_POSIX":"@stdlib/constants/path/sep-posix","PATH_SEP_WIN32":"@stdlib/constants/path/sep-win32","pcorrtest":"@stdlib/stats/pcorrtest","percentEncode":"@stdlib/string/percent-encode","PHI":"@stdlib/constants/float64/phi","PI":"@stdlib/constants/float64/pi","PI_SQUARED":"@stdlib/constants/float64/pi-squared","pick":"@stdlib/utils/pick","pickArguments":"@stdlib/utils/pick-arguments","pickBy":"@stdlib/utils/pick-by","PINF":"@stdlib/constants/float64/pinf","pkg2alias":"@stdlib/namespace/pkg2alias","pkg2related":"@stdlib/namespace/pkg2related","pkg2standalone":"@stdlib/namespace/pkg2standalone","PLATFORM":"@stdlib/os/platform","plot":"@stdlib/plot","Plot":"@stdlib/plot/ctor","pluck":"@stdlib/utils/pluck","pop":"@stdlib/utils/pop","porterStemmer":"@stdlib/nlp/porter-stemmer","prepend":"@stdlib/utils/prepend","prevGraphemeClusterBreak":"@stdlib/string/prev-grapheme-cluster-break","PRIMES_100K":"@stdlib/datasets/primes-100k","properties":"@stdlib/utils/properties","propertiesIn":"@stdlib/utils/properties-in","propertyDescriptor":"@stdlib/utils/property-descriptor","propertyDescriptorIn":"@stdlib/utils/property-descriptor-in","propertyDescriptors":"@stdlib/utils/property-descriptors","propertyDescriptorsIn":"@stdlib/utils/property-descriptors-in","propertyNames":"@stdlib/utils/property-names","propertyNamesIn":"@stdlib/utils/property-names-in","propertySymbols":"@stdlib/utils/property-symbols","propertySymbolsIn":"@stdlib/utils/property-symbols-in","Proxy":"@stdlib/proxy/ctor","push":"@stdlib/utils/push","quarterOfYear":"@stdlib/time/quarter-of-year","random.array.arcsine":"@stdlib/random/array/arcsine","random.array.bernoulli":"@stdlib/random/array/bernoulli","random.array.beta":"@stdlib/random/array/beta","random.array.betaprime":"@stdlib/random/array/betaprime","random.array.binomial":"@stdlib/random/array/binomial","random.array.cauchy":"@stdlib/random/array/cauchy","random.array.chi":"@stdlib/random/array/chi","random.array.chisquare":"@stdlib/random/array/chisquare","random.array.cosine":"@stdlib/random/array/cosine","random.array.discreteUniform":"@stdlib/random/array/discrete-uniform","random.array.erlang":"@stdlib/random/array/erlang","random.array.exponential":"@stdlib/random/array/exponential","random.array.f":"@stdlib/random/array/f","random.array.frechet":"@stdlib/random/array/frechet","random.array.gamma":"@stdlib/random/array/gamma","random.array.geometric":"@stdlib/random/array/geometric","random.array.gumbel":"@stdlib/random/array/gumbel","random.array.hypergeometric":"@stdlib/random/array/hypergeometric","random.array.invgamma":"@stdlib/random/array/invgamma","random.array.kumaraswamy":"@stdlib/random/array/kumaraswamy","random.array.laplace":"@stdlib/random/array/laplace","random.array.levy":"@stdlib/random/array/levy","random.array.logistic":"@stdlib/random/array/logistic","random.array.lognormal":"@stdlib/random/array/lognormal","random.array.minstd":"@stdlib/random/array/minstd","random.array.minstdShuffle":"@stdlib/random/array/minstd-shuffle","random.array.mt19937":"@stdlib/random/array/mt19937","random.array.negativeBinomial":"@stdlib/random/array/negative-binomial","random.array.normal":"@stdlib/random/array/normal","random.array.pareto1":"@stdlib/random/array/pareto-type1","random.array.poisson":"@stdlib/random/array/poisson","random.array.randu":"@stdlib/random/array/randu","random.array.rayleigh":"@stdlib/random/array/rayleigh","random.array.t":"@stdlib/random/array/t","random.array.triangular":"@stdlib/random/array/triangular","random.array.uniform":"@stdlib/random/array/uniform","random.array.weibull":"@stdlib/random/array/weibull","random.iterators.arcsine":"@stdlib/random/iter/arcsine","random.iterators.bernoulli":"@stdlib/random/iter/bernoulli","random.iterators.beta":"@stdlib/random/iter/beta","random.iterators.betaprime":"@stdlib/random/iter/betaprime","random.iterators.binomial":"@stdlib/random/iter/binomial","random.iterators.boxMuller":"@stdlib/random/iter/box-muller","random.iterators.cauchy":"@stdlib/random/iter/cauchy","random.iterators.chi":"@stdlib/random/iter/chi","random.iterators.chisquare":"@stdlib/random/iter/chisquare","random.iterators.cosine":"@stdlib/random/iter/cosine","random.iterators.discreteUniform":"@stdlib/random/iter/discrete-uniform","random.iterators.erlang":"@stdlib/random/iter/erlang","random.iterators.exponential":"@stdlib/random/iter/exponential","random.iterators.f":"@stdlib/random/iter/f","random.iterators.frechet":"@stdlib/random/iter/frechet","random.iterators.gamma":"@stdlib/random/iter/gamma","random.iterators.geometric":"@stdlib/random/iter/geometric","random.iterators.gumbel":"@stdlib/random/iter/gumbel","random.iterators.hypergeometric":"@stdlib/random/iter/hypergeometric","random.iterators.improvedZiggurat":"@stdlib/random/iter/improved-ziggurat","random.iterators.invgamma":"@stdlib/random/iter/invgamma","random.iterators.kumaraswamy":"@stdlib/random/iter/kumaraswamy","random.iterators.laplace":"@stdlib/random/iter/laplace","random.iterators.levy":"@stdlib/random/iter/levy","random.iterators.logistic":"@stdlib/random/iter/logistic","random.iterators.lognormal":"@stdlib/random/iter/lognormal","random.iterators.minstd":"@stdlib/random/iter/minstd","random.iterators.minstdShuffle":"@stdlib/random/iter/minstd-shuffle","random.iterators.mt19937":"@stdlib/random/iter/mt19937","random.iterators.negativeBinomial":"@stdlib/random/iter/negative-binomial","random.iterators.normal":"@stdlib/random/iter/normal","random.iterators.pareto1":"@stdlib/random/iter/pareto-type1","random.iterators.poisson":"@stdlib/random/iter/poisson","random.iterators.randi":"@stdlib/random/iter/randi","random.iterators.randn":"@stdlib/random/iter/randn","random.iterators.randu":"@stdlib/random/iter/randu","random.iterators.rayleigh":"@stdlib/random/iter/rayleigh","random.iterators.t":"@stdlib/random/iter/t","random.iterators.triangular":"@stdlib/random/iter/triangular","random.iterators.uniform":"@stdlib/random/iter/uniform","random.iterators.weibull":"@stdlib/random/iter/weibull","random.streams.arcsine":"@stdlib/random/streams/arcsine","random.streams.bernoulli":"@stdlib/random/streams/bernoulli","random.streams.beta":"@stdlib/random/streams/beta","random.streams.betaprime":"@stdlib/random/streams/betaprime","random.streams.binomial":"@stdlib/random/streams/binomial","random.streams.boxMuller":"@stdlib/random/streams/box-muller","random.streams.cauchy":"@stdlib/random/streams/cauchy","random.streams.chi":"@stdlib/random/streams/chi","random.streams.chisquare":"@stdlib/random/streams/chisquare","random.streams.cosine":"@stdlib/random/streams/cosine","random.streams.discreteUniform":"@stdlib/random/streams/discrete-uniform","random.streams.erlang":"@stdlib/random/streams/erlang","random.streams.exponential":"@stdlib/random/streams/exponential","random.streams.f":"@stdlib/random/streams/f","random.streams.frechet":"@stdlib/random/streams/frechet","random.streams.gamma":"@stdlib/random/streams/gamma","random.streams.geometric":"@stdlib/random/streams/geometric","random.streams.gumbel":"@stdlib/random/streams/gumbel","random.streams.hypergeometric":"@stdlib/random/streams/hypergeometric","random.streams.improvedZiggurat":"@stdlib/random/streams/improved-ziggurat","random.streams.invgamma":"@stdlib/random/streams/invgamma","random.streams.kumaraswamy":"@stdlib/random/streams/kumaraswamy","random.streams.laplace":"@stdlib/random/streams/laplace","random.streams.levy":"@stdlib/random/streams/levy","random.streams.logistic":"@stdlib/random/streams/logistic","random.streams.lognormal":"@stdlib/random/streams/lognormal","random.streams.minstd":"@stdlib/random/streams/minstd","random.streams.minstdShuffle":"@stdlib/random/streams/minstd-shuffle","random.streams.mt19937":"@stdlib/random/streams/mt19937","random.streams.negativeBinomial":"@stdlib/random/streams/negative-binomial","random.streams.normal":"@stdlib/random/streams/normal","random.streams.pareto1":"@stdlib/random/streams/pareto-type1","random.streams.poisson":"@stdlib/random/streams/poisson","random.streams.randi":"@stdlib/random/streams/randi","random.streams.randn":"@stdlib/random/streams/randn","random.streams.randu":"@stdlib/random/streams/randu","random.streams.rayleigh":"@stdlib/random/streams/rayleigh","random.streams.t":"@stdlib/random/streams/t","random.streams.triangular":"@stdlib/random/streams/triangular","random.streams.uniform":"@stdlib/random/streams/uniform","random.streams.weibull":"@stdlib/random/streams/weibull","random.strided.arcsine":"@stdlib/random/strided/arcsine","random.strided.bernoulli":"@stdlib/random/strided/bernoulli","random.strided.beta":"@stdlib/random/strided/beta","random.strided.betaprime":"@stdlib/random/strided/betaprime","random.strided.chi":"@stdlib/random/strided/chi","random.strided.chisquare":"@stdlib/random/strided/chisquare","random.strided.cosine":"@stdlib/random/strided/cosine","random.strided.discreteUniform":"@stdlib/random/strided/discrete-uniform","random.strided.exponential":"@stdlib/random/strided/exponential","random.strided.gamma":"@stdlib/random/strided/gamma","random.strided.geometric":"@stdlib/random/strided/geometric","random.strided.invgamma":"@stdlib/random/strided/invgamma","random.strided.lognormal":"@stdlib/random/strided/lognormal","random.strided.minstd":"@stdlib/random/strided/minstd","random.strided.minstdShuffle":"@stdlib/random/strided/minstd-shuffle","random.strided.mt19937":"@stdlib/random/strided/mt19937","random.strided.normal":"@stdlib/random/strided/normal","random.strided.poisson":"@stdlib/random/strided/poisson","random.strided.randu":"@stdlib/random/strided/randu","random.strided.rayleigh":"@stdlib/random/strided/rayleigh","random.strided.t":"@stdlib/random/strided/t","random.strided.uniform":"@stdlib/random/strided/uniform","random.strided.weibull":"@stdlib/random/strided/weibull","ranks":"@stdlib/stats/ranks","readDir":"@stdlib/fs/read-dir","readFile":"@stdlib/fs/read-file","readFileList":"@stdlib/fs/read-file-list","readJSON":"@stdlib/fs/read-json","readWASM":"@stdlib/fs/read-wasm","real":"@stdlib/complex/float64/real","realarray":"@stdlib/array/typed-real","realarrayCtors":"@stdlib/array/typed-real-ctors","realarrayDataTypes":"@stdlib/array/typed-real-dtypes","realf":"@stdlib/complex/float32/real","realmax":"@stdlib/utils/real-max","realmin":"@stdlib/utils/real-min","reBasename":"@stdlib/regexp/basename","reBasenamePosix":"@stdlib/regexp/basename-posix","reBasenameWindows":"@stdlib/regexp/basename-windows","reColorHexadecimal":"@stdlib/regexp/color-hexadecimal","reDecimalNumber":"@stdlib/regexp/decimal-number","reDirname":"@stdlib/regexp/dirname","reDirnamePosix":"@stdlib/regexp/dirname-posix","reDirnameWindows":"@stdlib/regexp/dirname-windows","reduce":"@stdlib/utils/reduce","reduce2d":"@stdlib/utils/reduce2d","reduceAsync":"@stdlib/utils/async/reduce","reduceRight":"@stdlib/utils/reduce-right","reduceRightAsync":"@stdlib/utils/async/reduce-right","reDurationString":"@stdlib/regexp/duration-string","reEOL":"@stdlib/regexp/eol","reExtendedLengthPath":"@stdlib/regexp/extended-length-path","reExtname":"@stdlib/regexp/extname","reExtnamePosix":"@stdlib/regexp/extname-posix","reExtnameWindows":"@stdlib/regexp/extname-windows","reFilename":"@stdlib/regexp/filename","reFilenamePosix":"@stdlib/regexp/filename-posix","reFilenameWindows":"@stdlib/regexp/filename-windows","reFromString":"@stdlib/utils/regexp-from-string","reFunctionName":"@stdlib/regexp/function-name","regexp2json":"@stdlib/regexp/to-json","reim":"@stdlib/complex/float64/reim","reimf":"@stdlib/complex/float32/reim","rejectArguments":"@stdlib/utils/reject-arguments","removeFirst":"@stdlib/string/remove-first","removeLast":"@stdlib/string/remove-last","removePunctuation":"@stdlib/string/remove-punctuation","removeUTF8BOM":"@stdlib/string/remove-utf8-bom","removeWords":"@stdlib/string/remove-words","rename":"@stdlib/fs/rename","reNativeFunction":"@stdlib/regexp/native-function","reorderArguments":"@stdlib/utils/reorder-arguments","repeat":"@stdlib/string/repeat","replace":"@stdlib/string/replace","replaceBefore":"@stdlib/string/replace-before","reRegExp":"@stdlib/regexp/regexp","rescape":"@stdlib/utils/escape-regexp-string","reSemVer":"@stdlib/regexp/semver","resolveParentPath":"@stdlib/fs/resolve-parent-path","resolveParentPathBy":"@stdlib/fs/resolve-parent-path-by","reUncPath":"@stdlib/regexp/unc-path","reUtf16SurrogatePair":"@stdlib/regexp/utf16-surrogate-pair","reUtf16UnpairedSurrogate":"@stdlib/regexp/utf16-unpaired-surrogate","reverseArguments":"@stdlib/utils/reverse-arguments","reverseString":"@stdlib/string/reverse","reviveBasePRNG":"@stdlib/random/base/reviver","reviveBuffer":"@stdlib/buffer/reviver","reviveComplex":"@stdlib/complex/reviver","reviveComplex64":"@stdlib/complex/float32/reviver","reviveComplex128":"@stdlib/complex/float64/reviver","reviveError":"@stdlib/error/reviver","reviveRegExp":"@stdlib/regexp/reviver","reviveTypedArray":"@stdlib/array/reviver","reWhitespace":"@stdlib/regexp/whitespace","rpad":"@stdlib/string/right-pad","rtrim":"@stdlib/string/right-trim","rtrimN":"@stdlib/string/right-trim-n","safeintmax":"@stdlib/utils/safe-int-max","safeintmin":"@stdlib/utils/safe-int-min","sample":"@stdlib/random/sample","SAVOY_STOPWORDS_FIN":"@stdlib/datasets/savoy-stopwords-fin","SAVOY_STOPWORDS_FR":"@stdlib/datasets/savoy-stopwords-fr","SAVOY_STOPWORDS_GER":"@stdlib/datasets/savoy-stopwords-ger","SAVOY_STOPWORDS_IT":"@stdlib/datasets/savoy-stopwords-it","SAVOY_STOPWORDS_POR":"@stdlib/datasets/savoy-stopwords-por","SAVOY_STOPWORDS_SP":"@stdlib/datasets/savoy-stopwords-sp","SAVOY_STOPWORDS_SWE":"@stdlib/datasets/savoy-stopwords-swe","scalar2array":"@stdlib/array/from-scalar","scalar2ndarray":"@stdlib/ndarray/from-scalar","sdot":"@stdlib/blas/sdot","SECONDS_IN_DAY":"@stdlib/constants/time/seconds-in-day","SECONDS_IN_HOUR":"@stdlib/constants/time/seconds-in-hour","SECONDS_IN_MINUTE":"@stdlib/constants/time/seconds-in-minute","SECONDS_IN_WEEK":"@stdlib/constants/time/seconds-in-week","secondsInMonth":"@stdlib/time/seconds-in-month","secondsInYear":"@stdlib/time/seconds-in-year","sentencize":"@stdlib/nlp/sentencize","seq2slice":"@stdlib/slice/seq2slice","setConfigurableReadOnly":"@stdlib/utils/define-configurable-read-only-property","setConfigurableReadOnlyAccessor":"@stdlib/utils/define-configurable-read-only-accessor","setConfigurableReadWriteAccessor":"@stdlib/utils/define-configurable-read-write-accessor","setConfigurableWriteOnlyAccessor":"@stdlib/utils/define-configurable-write-only-accessor","setMemoizedConfigurableReadOnly":"@stdlib/utils/define-memoized-configurable-read-only-property","setMemoizedReadOnly":"@stdlib/utils/define-memoized-read-only-property","setNonEnumerableProperty":"@stdlib/utils/define-nonenumerable-property","setNonEnumerableReadOnly":"@stdlib/utils/define-nonenumerable-read-only-property","setNonEnumerableReadOnlyAccessor":"@stdlib/utils/define-nonenumerable-read-only-accessor","setNonEnumerableReadWriteAccessor":"@stdlib/utils/define-nonenumerable-read-write-accessor","setNonEnumerableWriteOnlyAccessor":"@stdlib/utils/define-nonenumerable-write-only-accessor","setReadOnly":"@stdlib/utils/define-read-only-property","setReadOnlyAccessor":"@stdlib/utils/define-read-only-accessor","setReadWriteAccessor":"@stdlib/utils/define-read-write-accessor","setWriteOnlyAccessor":"@stdlib/utils/define-write-only-accessor","SharedArrayBuffer":"@stdlib/array/shared-buffer","shift":"@stdlib/utils/shift","shuffle":"@stdlib/random/shuffle","sizeOf":"@stdlib/utils/size-of","Slice":"@stdlib/slice/ctor","snakecase":"@stdlib/string/snakecase","some":"@stdlib/utils/some","someBy":"@stdlib/utils/some-by","someByAsync":"@stdlib/utils/async/some-by","someByRight":"@stdlib/utils/some-by-right","someByRightAsync":"@stdlib/utils/async/some-by-right","someInBy":"@stdlib/utils/some-in-by","someOwnBy":"@stdlib/utils/some-own-by","SOTU":"@stdlib/datasets/sotu","SPACHE_REVISED":"@stdlib/datasets/spache-revised","SPAM_ASSASSIN":"@stdlib/datasets/spam-assassin","SparklineBase":"@stdlib/plot/sparklines/base/ctor","sparsearray2iterator":"@stdlib/array/to-sparse-iterator","sparsearray2iteratorRight":"@stdlib/array/to-sparse-iterator-right","splitStream":"@stdlib/streams/node/split","SQRT_EPS":"@stdlib/constants/float64/sqrt-eps","SQRT_HALF":"@stdlib/constants/float64/sqrt-half","SQRT_HALF_PI":"@stdlib/constants/float64/sqrt-half-pi","SQRT_PHI":"@stdlib/constants/float64/sqrt-phi","SQRT_PI":"@stdlib/constants/float64/sqrt-pi","SQRT_THREE":"@stdlib/constants/float64/sqrt-three","SQRT_TWO":"@stdlib/constants/float64/sqrt-two","SQRT_TWO_PI":"@stdlib/constants/float64/sqrt-two-pi","SSA_US_BIRTHS_2000_2014":"@stdlib/datasets/ssa-us-births-2000-2014","sswap":"@stdlib/blas/sswap","Stack":"@stdlib/dstructs/stack","standalone2pkg":"@stdlib/namespace/standalone2pkg","STANDARD_CARD_DECK":"@stdlib/datasets/standard-card-deck","startcase":"@stdlib/string/startcase","startsWith":"@stdlib/string/starts-with","STOPWORDS_EN":"@stdlib/datasets/stopwords-en","strided.abs":"@stdlib/math/strided/special/abs","strided.abs2":"@stdlib/math/strided/special/abs2","strided.abs2By":"@stdlib/math/strided/special/abs2-by","strided.absBy":"@stdlib/math/strided/special/abs-by","strided.acosBy":"@stdlib/math/strided/special/acos-by","strided.acoshBy":"@stdlib/math/strided/special/acosh-by","strided.acotBy":"@stdlib/math/strided/special/acot-by","strided.acothBy":"@stdlib/math/strided/special/acoth-by","strided.acovercosBy":"@stdlib/math/strided/special/acovercos-by","strided.acoversinBy":"@stdlib/math/strided/special/acoversin-by","strided.add":"@stdlib/math/strided/ops/add","strided.addBy":"@stdlib/math/strided/ops/add-by","strided.ahavercosBy":"@stdlib/math/strided/special/ahavercos-by","strided.ahaversinBy":"@stdlib/math/strided/special/ahaversin-by","strided.asinBy":"@stdlib/math/strided/special/asin-by","strided.asinhBy":"@stdlib/math/strided/special/asinh-by","strided.atanBy":"@stdlib/math/strided/special/atan-by","strided.atanhBy":"@stdlib/math/strided/special/atanh-by","strided.avercosBy":"@stdlib/math/strided/special/avercos-by","strided.aversinBy":"@stdlib/math/strided/special/aversin-by","strided.besselj0By":"@stdlib/math/strided/special/besselj0-by","strided.besselj1By":"@stdlib/math/strided/special/besselj1-by","strided.bessely0By":"@stdlib/math/strided/special/bessely0-by","strided.bessely1By":"@stdlib/math/strided/special/bessely1-by","strided.binetBy":"@stdlib/math/strided/special/binet-by","strided.cbrt":"@stdlib/math/strided/special/cbrt","strided.cbrtBy":"@stdlib/math/strided/special/cbrt-by","strided.ceil":"@stdlib/math/strided/special/ceil","strided.cosBy":"@stdlib/math/strided/special/cos-by","strided.deg2rad":"@stdlib/math/strided/special/deg2rad","strided.dataTypes":"@stdlib/strided/dtypes","strided.dcbrtBy":"@stdlib/math/strided/special/dcbrt-by","strided.dispatch":"@stdlib/strided/dispatch","strided.dispatchBy":"@stdlib/strided/dispatch-by","strided.floor":"@stdlib/math/strided/special/floor","strided.inv":"@stdlib/math/strided/special/inv","strided.mul":"@stdlib/math/strided/ops/mul","strided.mulBy":"@stdlib/math/strided/ops/mul-by","strided.ramp":"@stdlib/math/strided/special/ramp","strided.rsqrt":"@stdlib/math/strided/special/rsqrt","strided.sinBy":"@stdlib/math/strided/special/sin-by","strided.sqrt":"@stdlib/math/strided/special/sqrt","strided.sqrtBy":"@stdlib/math/strided/special/sqrt-by","strided.sub":"@stdlib/math/strided/ops/sub","strided.subBy":"@stdlib/math/strided/ops/sub-by","strided.trunc":"@stdlib/math/strided/special/trunc","stridedarray2iterator":"@stdlib/array/to-strided-iterator","stridedArrayStream":"@stdlib/streams/node/from-strided-array","string2buffer":"@stdlib/buffer/from-string","sub2ind":"@stdlib/ndarray/sub2ind","substringAfter":"@stdlib/string/substring-after","substringAfterLast":"@stdlib/string/substring-after-last","substringBefore":"@stdlib/string/substring-before","substringBeforeLast":"@stdlib/string/substring-before-last","SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK":"@stdlib/datasets/suthaharan-multi-hop-sensor-network","SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK":"@stdlib/datasets/suthaharan-single-hop-sensor-network","Symbol":"@stdlib/symbol/ctor","tabulate":"@stdlib/utils/tabulate","tabulateBy":"@stdlib/utils/tabulate-by","tabulateByAsync":"@stdlib/utils/async/tabulate-by","thunk":"@stdlib/function/thunk","tic":"@stdlib/time/tic","timeit":"@stdlib/utils/timeit","tmpdir":"@stdlib/os/tmpdir","toc":"@stdlib/time/toc","tokenize":"@stdlib/nlp/tokenize","transformStream":"@stdlib/streams/node/transform","trim":"@stdlib/string/trim","truncate":"@stdlib/string/truncate","truncateMiddle":"@stdlib/string/truncate-middle","trycatch":"@stdlib/utils/try-catch","trycatchAsync":"@stdlib/utils/async/try-catch","tryFunction":"@stdlib/utils/try-function","tryRequire":"@stdlib/utils/try-require","trythen":"@stdlib/utils/try-then","trythenAsync":"@stdlib/utils/async/try-then","ttest":"@stdlib/stats/ttest","ttest2":"@stdlib/stats/ttest2","TWO_PI":"@stdlib/constants/float64/two-pi","typedarray":"@stdlib/array/typed","typedarray2json":"@stdlib/array/to-json","typedarrayCtors":"@stdlib/array/typed-ctors","typedarrayDataTypes":"@stdlib/array/typed-dtypes","typedarraypool":"@stdlib/array/pool","typemax":"@stdlib/utils/type-max","typemin":"@stdlib/utils/type-min","typeOf":"@stdlib/utils/type-of","UINT8_MAX":"@stdlib/constants/uint8/max","UINT8_NUM_BYTES":"@stdlib/constants/uint8/num-bytes","Uint8Array":"@stdlib/array/uint8","Uint8ClampedArray":"@stdlib/array/uint8c","UINT16_MAX":"@stdlib/constants/uint16/max","UINT16_NUM_BYTES":"@stdlib/constants/uint16/num-bytes","Uint16Array":"@stdlib/array/uint16","UINT32_MAX":"@stdlib/constants/uint32/max","UINT32_NUM_BYTES":"@stdlib/constants/uint32/num-bytes","Uint32Array":"@stdlib/array/uint32","umask":"@stdlib/process/umask","uncapitalize":"@stdlib/string/uncapitalize","uncapitalizeKeys":"@stdlib/utils/uncapitalize-keys","uncurry":"@stdlib/utils/uncurry","uncurryRight":"@stdlib/utils/uncurry-right","UNICODE_MAX":"@stdlib/constants/unicode/max","UNICODE_MAX_BMP":"@stdlib/constants/unicode/max-bmp","UnicodeColumnChartSparkline":"@stdlib/plot/sparklines/unicode/column","UnicodeLineChartSparkline":"@stdlib/plot/sparklines/unicode/line","UnicodeSparkline":"@stdlib/plot/sparklines/unicode","UnicodeTristateChartSparkline":"@stdlib/plot/sparklines/unicode/tristate","UnicodeUpDownChartSparkline":"@stdlib/plot/sparklines/unicode/up-down","UnicodeWinLossChartSparkline":"@stdlib/plot/sparklines/unicode/win-loss","unlink":"@stdlib/fs/unlink","unshift":"@stdlib/utils/unshift","until":"@stdlib/utils/until","untilAsync":"@stdlib/utils/async/until","untilEach":"@stdlib/utils/until-each","untilEachRight":"@stdlib/utils/until-each-right","unzip":"@stdlib/utils/unzip","uppercase":"@stdlib/string/uppercase","uppercaseKeys":"@stdlib/utils/uppercase-keys","US_STATES_ABBR":"@stdlib/datasets/us-states-abbr","US_STATES_CAPITALS":"@stdlib/datasets/us-states-capitals","US_STATES_CAPITALS_NAMES":"@stdlib/datasets/us-states-capitals-names","US_STATES_NAMES":"@stdlib/datasets/us-states-names","US_STATES_NAMES_CAPITALS":"@stdlib/datasets/us-states-names-capitals","utf16ToUTF8Array":"@stdlib/string/utf16-to-utf8-array","vartest":"@stdlib/stats/vartest","waterfall":"@stdlib/utils/async/series-waterfall","WebAssemblyMemory":"@stdlib/wasm/memory","whileAsync":"@stdlib/utils/async/while","whileEach":"@stdlib/utils/while-each","whileEachRight":"@stdlib/utils/while-each-right","whilst":"@stdlib/utils/while","wilcoxon":"@stdlib/stats/wilcoxon","writableProperties":"@stdlib/utils/writable-properties","writablePropertiesIn":"@stdlib/utils/writable-properties-in","writablePropertyNames":"@stdlib/utils/writable-property-names","writablePropertyNamesIn":"@stdlib/utils/writable-property-names-in","writablePropertySymbols":"@stdlib/utils/writable-property-symbols","writablePropertySymbolsIn":"@stdlib/utils/writable-property-symbols-in","writeFile":"@stdlib/fs/write-file","zip":"@stdlib/utils/zip","ztest":"@stdlib/stats/ztest","ztest2":"@stdlib/stats/ztest2"} +{"abs":"@stdlib/math/special/abs","acartesianPower":"@stdlib/array/cartesian-power","acartesianProduct":"@stdlib/array/cartesian-product","acartesianSquare":"@stdlib/array/cartesian-square","acronym":"@stdlib/string/acronym","aempty":"@stdlib/array/empty","aemptyLike":"@stdlib/array/empty-like","AFINN_96":"@stdlib/datasets/afinn-96","AFINN_111":"@stdlib/datasets/afinn-111","afull":"@stdlib/array/full","afullLike":"@stdlib/array/full-like","alias2pkg":"@stdlib/namespace/alias2pkg","alias2related":"@stdlib/namespace/alias2related","alias2standalone":"@stdlib/namespace/alias2standalone","aliases":"@stdlib/namespace/aliases","allocUnsafe":"@stdlib/buffer/alloc-unsafe","amskfilter":"@stdlib/array/mskfilter","amskput":"@stdlib/array/mskput","amskreject":"@stdlib/array/mskreject","anans":"@stdlib/array/nans","anansLike":"@stdlib/array/nans-like","anova1":"@stdlib/stats/anova1","ANSCOMBES_QUARTET":"@stdlib/datasets/anscombes-quartet","any":"@stdlib/utils/any","anyBy":"@stdlib/utils/any-by","anyByAsync":"@stdlib/utils/async/any-by","anyByRight":"@stdlib/utils/any-by-right","anyByRightAsync":"@stdlib/utils/async/any-by-right","anyInBy":"@stdlib/utils/any-in-by","anyOwnBy":"@stdlib/utils/any-own-by","aones":"@stdlib/array/ones","aonesLike":"@stdlib/array/ones-like","aoneTo":"@stdlib/array/one-to","aoneToLike":"@stdlib/array/one-to-like","APERY":"@stdlib/constants/float64/apery","aplace":"@stdlib/array/place","append":"@stdlib/utils/append","aput":"@stdlib/array/put","ARCH":"@stdlib/os/arch","argumentFunction":"@stdlib/utils/argument-function","ARGV":"@stdlib/process/argv","array":"@stdlib/ndarray/array","array2buffer":"@stdlib/buffer/from-array","array2fancy":"@stdlib/array/to-fancy","array2iterator":"@stdlib/array/to-iterator","array2iteratorRight":"@stdlib/array/to-iterator-right","ArrayBuffer":"@stdlib/array/buffer","arraybuffer2buffer":"@stdlib/buffer/from-arraybuffer","arrayCtors":"@stdlib/array/ctors","arrayDataType":"@stdlib/array/dtype","arrayDataTypes":"@stdlib/array/dtypes","ArrayIndex":"@stdlib/array/index","arrayMinDataType":"@stdlib/array/min-dtype","arrayMostlySafeCasts":"@stdlib/array/mostly-safe-casts","arrayNextDataType":"@stdlib/array/next-dtype","arrayPromotionRules":"@stdlib/array/promotion-rules","arraySafeCasts":"@stdlib/array/safe-casts","arraySameKindCasts":"@stdlib/array/same-kind-casts","arrayShape":"@stdlib/array/shape","arrayStream":"@stdlib/streams/node/from-array","arrayview2iterator":"@stdlib/array/to-view-iterator","arrayview2iteratorRight":"@stdlib/array/to-view-iterator-right","aslice":"@stdlib/array/slice","AsyncIteratorSymbol":"@stdlib/symbol/async-iterator","atake":"@stdlib/array/take","azeros":"@stdlib/array/zeros","azerosLike":"@stdlib/array/zeros-like","azeroTo":"@stdlib/array/zero-to","azeroToLike":"@stdlib/array/zero-to-like","bartlettTest":"@stdlib/stats/bartlett-test","base.abs":"@stdlib/math/base/special/abs","base.abs2":"@stdlib/math/base/special/abs2","base.abs2f":"@stdlib/math/base/special/abs2f","base.absdiff":"@stdlib/math/base/utils/absolute-difference","base.absf":"@stdlib/math/base/special/absf","base.acartesianPower":"@stdlib/array/base/cartesian-power","base.acartesianProduct":"@stdlib/array/base/cartesian-product","base.acartesianSquare":"@stdlib/array/base/cartesian-square","base.acos":"@stdlib/math/base/special/acos","base.acosd":"@stdlib/math/base/special/acosd","base.acosf":"@stdlib/math/base/special/acosf","base.acosh":"@stdlib/math/base/special/acosh","base.acot":"@stdlib/math/base/special/acot","base.acotd":"@stdlib/math/base/special/acotd","base.acotf":"@stdlib/math/base/special/acotf","base.acoth":"@stdlib/math/base/special/acoth","base.acovercos":"@stdlib/math/base/special/acovercos","base.acoversin":"@stdlib/math/base/special/acoversin","base.acsc":"@stdlib/math/base/special/acsc","base.acscd":"@stdlib/math/base/special/acscd","base.acscdf":"@stdlib/math/base/special/acscdf","base.acscf":"@stdlib/math/base/special/acscf","base.acsch":"@stdlib/math/base/special/acsch","base.add":"@stdlib/number/float64/base/add","base.add3":"@stdlib/number/float64/base/add3","base.add4":"@stdlib/number/float64/base/add4","base.add5":"@stdlib/number/float64/base/add5","base.addf":"@stdlib/number/float32/base/add","base.afilled":"@stdlib/array/base/filled","base.afilled2d":"@stdlib/array/base/filled2d","base.afilled2dBy":"@stdlib/array/base/filled2d-by","base.afilled3d":"@stdlib/array/base/filled3d","base.afilled3dBy":"@stdlib/array/base/filled3d-by","base.afilled4d":"@stdlib/array/base/filled4d","base.afilled4dBy":"@stdlib/array/base/filled4d-by","base.afilled5d":"@stdlib/array/base/filled5d","base.afilled5dBy":"@stdlib/array/base/filled5d-by","base.afilledBy":"@stdlib/array/base/filled-by","base.afillednd":"@stdlib/array/base/fillednd","base.afilledndBy":"@stdlib/array/base/fillednd-by","base.afilter":"@stdlib/array/base/filter","base.afirst":"@stdlib/array/base/first","base.aflatten":"@stdlib/array/base/flatten","base.aflatten2d":"@stdlib/array/base/flatten2d","base.aflatten2dBy":"@stdlib/array/base/flatten2d-by","base.aflatten3d":"@stdlib/array/base/flatten3d","base.aflatten3dBy":"@stdlib/array/base/flatten3d-by","base.aflatten4d":"@stdlib/array/base/flatten4d","base.aflatten4dBy":"@stdlib/array/base/flatten4d-by","base.aflatten5d":"@stdlib/array/base/flatten5d","base.aflatten5dBy":"@stdlib/array/base/flatten5d-by","base.aflattenBy":"@stdlib/array/base/flatten-by","base.afliplr2d":"@stdlib/array/base/fliplr2d","base.afliplr3d":"@stdlib/array/base/fliplr3d","base.afliplr4d":"@stdlib/array/base/fliplr4d","base.afliplr5d":"@stdlib/array/base/fliplr5d","base.aflipud2d":"@stdlib/array/base/flipud2d","base.aflipud3d":"@stdlib/array/base/flipud3d","base.aflipud4d":"@stdlib/array/base/flipud4d","base.aflipud5d":"@stdlib/array/base/flipud5d","base.ahavercos":"@stdlib/math/base/special/ahavercos","base.ahaversin":"@stdlib/math/base/special/ahaversin","base.altcase":"@stdlib/string/base/altcase","base.aones":"@stdlib/array/base/ones","base.aones2d":"@stdlib/array/base/ones2d","base.aones3d":"@stdlib/array/base/ones3d","base.aones4d":"@stdlib/array/base/ones4d","base.aones5d":"@stdlib/array/base/ones5d","base.aonesnd":"@stdlib/array/base/onesnd","base.aoneTo":"@stdlib/array/base/one-to","base.args2multislice":"@stdlib/slice/base/args2multislice","base.asec":"@stdlib/math/base/special/asec","base.asecd":"@stdlib/math/base/special/asecd","base.asecdf":"@stdlib/math/base/special/asecdf","base.asecf":"@stdlib/math/base/special/asecf","base.asech":"@stdlib/math/base/special/asech","base.asin":"@stdlib/math/base/special/asin","base.asind":"@stdlib/math/base/special/asind","base.asindf":"@stdlib/math/base/special/asindf","base.asinf":"@stdlib/math/base/special/asinf","base.asinh":"@stdlib/math/base/special/asinh","base.atan":"@stdlib/math/base/special/atan","base.atan2":"@stdlib/math/base/special/atan2","base.atand":"@stdlib/math/base/special/atand","base.atanf":"@stdlib/math/base/special/atanf","base.atanh":"@stdlib/math/base/special/atanh","base.avercos":"@stdlib/math/base/special/avercos","base.aversin":"@stdlib/math/base/special/aversin","base.azeros":"@stdlib/array/base/zeros","base.azeros2d":"@stdlib/array/base/zeros2d","base.azeros3d":"@stdlib/array/base/zeros3d","base.azeros4d":"@stdlib/array/base/zeros4d","base.azeros5d":"@stdlib/array/base/zeros5d","base.azerosnd":"@stdlib/array/base/zerosnd","base.azeroTo":"@stdlib/array/base/zero-to","base.bernoulli":"@stdlib/math/base/special/bernoulli","base.besselj0":"@stdlib/math/base/special/besselj0","base.besselj1":"@stdlib/math/base/special/besselj1","base.bessely0":"@stdlib/math/base/special/bessely0","base.bessely1":"@stdlib/math/base/special/bessely1","base.beta":"@stdlib/math/base/special/beta","base.betainc":"@stdlib/math/base/special/betainc","base.betaincinv":"@stdlib/math/base/special/betaincinv","base.betaln":"@stdlib/math/base/special/betaln","base.binet":"@stdlib/math/base/special/binet","base.binomcoef":"@stdlib/math/base/special/binomcoef","base.binomcoefln":"@stdlib/math/base/special/binomcoefln","base.boxcox":"@stdlib/math/base/special/boxcox","base.boxcox1p":"@stdlib/math/base/special/boxcox1p","base.boxcox1pinv":"@stdlib/math/base/special/boxcox1pinv","base.boxcoxinv":"@stdlib/math/base/special/boxcoxinv","base.cabs":"@stdlib/math/base/special/cabs","base.cabs2":"@stdlib/math/base/special/cabs2","base.cabs2f":"@stdlib/math/base/special/cabs2f","base.cabsf":"@stdlib/math/base/special/cabsf","base.cadd":"@stdlib/complex/float64/base/add","base.caddf":"@stdlib/complex/float32/base/add","base.camelcase":"@stdlib/string/base/camelcase","base.capitalize":"@stdlib/string/base/capitalize","base.cbrt":"@stdlib/math/base/special/cbrt","base.cbrtf":"@stdlib/math/base/special/cbrtf","base.cceil":"@stdlib/math/base/special/cceil","base.cceilf":"@stdlib/math/base/special/cceilf","base.cceiln":"@stdlib/math/base/special/cceiln","base.ccis":"@stdlib/math/base/special/ccis","base.cdiv":"@stdlib/math/base/ops/cdiv","base.ceil":"@stdlib/math/base/special/ceil","base.ceil2":"@stdlib/math/base/special/ceil2","base.ceil10":"@stdlib/math/base/special/ceil10","base.ceilb":"@stdlib/math/base/special/ceilb","base.ceilf":"@stdlib/math/base/special/ceilf","base.ceiln":"@stdlib/math/base/special/ceiln","base.ceilsd":"@stdlib/math/base/special/ceilsd","base.cexp":"@stdlib/math/base/special/cexp","base.cflipsign":"@stdlib/math/base/special/cflipsign","base.cflipsignf":"@stdlib/math/base/special/cflipsignf","base.cfloor":"@stdlib/math/base/special/cfloor","base.cfloorn":"@stdlib/math/base/special/cfloorn","base.cidentity":"@stdlib/math/base/special/cidentity","base.cidentityf":"@stdlib/math/base/special/cidentityf","base.cinv":"@stdlib/math/base/special/cinv","base.clamp":"@stdlib/math/base/special/clamp","base.clampf":"@stdlib/math/base/special/clampf","base.cmul":"@stdlib/complex/float64/base/mul","base.cmulf":"@stdlib/complex/float32/base/mul","base.cneg":"@stdlib/math/base/ops/cneg","base.cnegf":"@stdlib/math/base/ops/cnegf","base.codePointAt":"@stdlib/string/base/code-point-at","base.constantcase":"@stdlib/string/base/constantcase","base.continuedFraction":"@stdlib/math/base/tools/continued-fraction","base.copysign":"@stdlib/math/base/special/copysign","base.copysignf":"@stdlib/math/base/special/copysignf","base.cos":"@stdlib/math/base/special/cos","base.cosd":"@stdlib/math/base/special/cosd","base.cosh":"@stdlib/math/base/special/cosh","base.cosm1":"@stdlib/math/base/special/cosm1","base.cospi":"@stdlib/math/base/special/cospi","base.cot":"@stdlib/math/base/special/cot","base.cotd":"@stdlib/math/base/special/cotd","base.coth":"@stdlib/math/base/special/coth","base.covercos":"@stdlib/math/base/special/covercos","base.coversin":"@stdlib/math/base/special/coversin","base.cphase":"@stdlib/math/base/special/cphase","base.cpolar":"@stdlib/math/base/special/cpolar","base.cround":"@stdlib/math/base/special/cround","base.croundn":"@stdlib/math/base/special/croundn","base.csc":"@stdlib/math/base/special/csc","base.cscd":"@stdlib/math/base/special/cscd","base.csch":"@stdlib/math/base/special/csch","base.csignum":"@stdlib/math/base/special/csignum","base.csub":"@stdlib/math/base/ops/csub","base.csubf":"@stdlib/math/base/ops/csubf","base.deg2rad":"@stdlib/math/base/special/deg2rad","base.deg2radf":"@stdlib/math/base/special/deg2radf","base.digamma":"@stdlib/math/base/special/digamma","base.diracDelta":"@stdlib/math/base/special/dirac-delta","base.div":"@stdlib/number/float64/base/div","base.divf":"@stdlib/number/float32/base/div","base.dotcase":"@stdlib/string/base/dotcase","base.dists.arcsine.Arcsine":"@stdlib/stats/base/dists/arcsine/ctor","base.dists.arcsine.cdf":"@stdlib/stats/base/dists/arcsine/cdf","base.dists.arcsine.entropy":"@stdlib/stats/base/dists/arcsine/entropy","base.dists.arcsine.kurtosis":"@stdlib/stats/base/dists/arcsine/kurtosis","base.dists.arcsine.logcdf":"@stdlib/stats/base/dists/arcsine/logcdf","base.dists.arcsine.logpdf":"@stdlib/stats/base/dists/arcsine/logpdf","base.dists.arcsine.mean":"@stdlib/stats/base/dists/arcsine/mean","base.dists.arcsine.median":"@stdlib/stats/base/dists/arcsine/median","base.dists.arcsine.mode":"@stdlib/stats/base/dists/arcsine/mode","base.dists.arcsine.pdf":"@stdlib/stats/base/dists/arcsine/pdf","base.dists.arcsine.quantile":"@stdlib/stats/base/dists/arcsine/quantile","base.dists.arcsine.skewness":"@stdlib/stats/base/dists/arcsine/skewness","base.dists.arcsine.stdev":"@stdlib/stats/base/dists/arcsine/stdev","base.dists.arcsine.variance":"@stdlib/stats/base/dists/arcsine/variance","base.dists.bernoulli.Bernoulli":"@stdlib/stats/base/dists/bernoulli/ctor","base.dists.bernoulli.cdf":"@stdlib/stats/base/dists/bernoulli/cdf","base.dists.bernoulli.entropy":"@stdlib/stats/base/dists/bernoulli/entropy","base.dists.bernoulli.kurtosis":"@stdlib/stats/base/dists/bernoulli/kurtosis","base.dists.bernoulli.mean":"@stdlib/stats/base/dists/bernoulli/mean","base.dists.bernoulli.median":"@stdlib/stats/base/dists/bernoulli/median","base.dists.bernoulli.mgf":"@stdlib/stats/base/dists/bernoulli/mgf","base.dists.bernoulli.mode":"@stdlib/stats/base/dists/bernoulli/mode","base.dists.bernoulli.pmf":"@stdlib/stats/base/dists/bernoulli/pmf","base.dists.bernoulli.quantile":"@stdlib/stats/base/dists/bernoulli/quantile","base.dists.bernoulli.skewness":"@stdlib/stats/base/dists/bernoulli/skewness","base.dists.bernoulli.stdev":"@stdlib/stats/base/dists/bernoulli/stdev","base.dists.bernoulli.variance":"@stdlib/stats/base/dists/bernoulli/variance","base.dists.beta.Beta":"@stdlib/stats/base/dists/beta/ctor","base.dists.beta.cdf":"@stdlib/stats/base/dists/beta/cdf","base.dists.beta.entropy":"@stdlib/stats/base/dists/beta/entropy","base.dists.beta.kurtosis":"@stdlib/stats/base/dists/beta/kurtosis","base.dists.beta.logcdf":"@stdlib/stats/base/dists/beta/logcdf","base.dists.beta.logpdf":"@stdlib/stats/base/dists/beta/logpdf","base.dists.beta.mean":"@stdlib/stats/base/dists/beta/mean","base.dists.beta.median":"@stdlib/stats/base/dists/beta/median","base.dists.beta.mgf":"@stdlib/stats/base/dists/beta/mgf","base.dists.beta.mode":"@stdlib/stats/base/dists/beta/mode","base.dists.beta.pdf":"@stdlib/stats/base/dists/beta/pdf","base.dists.beta.quantile":"@stdlib/stats/base/dists/beta/quantile","base.dists.beta.skewness":"@stdlib/stats/base/dists/beta/skewness","base.dists.beta.stdev":"@stdlib/stats/base/dists/beta/stdev","base.dists.beta.variance":"@stdlib/stats/base/dists/beta/variance","base.dists.betaprime.BetaPrime":"@stdlib/stats/base/dists/betaprime/ctor","base.dists.betaprime.cdf":"@stdlib/stats/base/dists/betaprime/cdf","base.dists.betaprime.kurtosis":"@stdlib/stats/base/dists/betaprime/kurtosis","base.dists.betaprime.logcdf":"@stdlib/stats/base/dists/betaprime/logcdf","base.dists.betaprime.logpdf":"@stdlib/stats/base/dists/betaprime/logpdf","base.dists.betaprime.mean":"@stdlib/stats/base/dists/betaprime/mean","base.dists.betaprime.mode":"@stdlib/stats/base/dists/betaprime/mode","base.dists.betaprime.pdf":"@stdlib/stats/base/dists/betaprime/pdf","base.dists.betaprime.quantile":"@stdlib/stats/base/dists/betaprime/quantile","base.dists.betaprime.skewness":"@stdlib/stats/base/dists/betaprime/skewness","base.dists.betaprime.stdev":"@stdlib/stats/base/dists/betaprime/stdev","base.dists.betaprime.variance":"@stdlib/stats/base/dists/betaprime/variance","base.dists.binomial.Binomial":"@stdlib/stats/base/dists/binomial/ctor","base.dists.binomial.cdf":"@stdlib/stats/base/dists/binomial/cdf","base.dists.binomial.entropy":"@stdlib/stats/base/dists/binomial/entropy","base.dists.binomial.kurtosis":"@stdlib/stats/base/dists/binomial/kurtosis","base.dists.binomial.logpmf":"@stdlib/stats/base/dists/binomial/logpmf","base.dists.binomial.mean":"@stdlib/stats/base/dists/binomial/mean","base.dists.binomial.median":"@stdlib/stats/base/dists/binomial/median","base.dists.binomial.mgf":"@stdlib/stats/base/dists/binomial/mgf","base.dists.binomial.mode":"@stdlib/stats/base/dists/binomial/mode","base.dists.binomial.pmf":"@stdlib/stats/base/dists/binomial/pmf","base.dists.binomial.quantile":"@stdlib/stats/base/dists/binomial/quantile","base.dists.binomial.skewness":"@stdlib/stats/base/dists/binomial/skewness","base.dists.binomial.stdev":"@stdlib/stats/base/dists/binomial/stdev","base.dists.binomial.variance":"@stdlib/stats/base/dists/binomial/variance","base.dists.cauchy.Cauchy":"@stdlib/stats/base/dists/cauchy/ctor","base.dists.cauchy.cdf":"@stdlib/stats/base/dists/cauchy/cdf","base.dists.cauchy.entropy":"@stdlib/stats/base/dists/cauchy/entropy","base.dists.cauchy.logcdf":"@stdlib/stats/base/dists/cauchy/logcdf","base.dists.cauchy.logpdf":"@stdlib/stats/base/dists/cauchy/logpdf","base.dists.cauchy.median":"@stdlib/stats/base/dists/cauchy/median","base.dists.cauchy.mode":"@stdlib/stats/base/dists/cauchy/mode","base.dists.cauchy.pdf":"@stdlib/stats/base/dists/cauchy/pdf","base.dists.cauchy.quantile":"@stdlib/stats/base/dists/cauchy/quantile","base.dists.chi.cdf":"@stdlib/stats/base/dists/chi/cdf","base.dists.chi.Chi":"@stdlib/stats/base/dists/chi/ctor","base.dists.chi.entropy":"@stdlib/stats/base/dists/chi/entropy","base.dists.chi.kurtosis":"@stdlib/stats/base/dists/chi/kurtosis","base.dists.chi.logpdf":"@stdlib/stats/base/dists/chi/logpdf","base.dists.chi.mean":"@stdlib/stats/base/dists/chi/mean","base.dists.chi.mode":"@stdlib/stats/base/dists/chi/mode","base.dists.chi.pdf":"@stdlib/stats/base/dists/chi/pdf","base.dists.chi.quantile":"@stdlib/stats/base/dists/chi/quantile","base.dists.chi.skewness":"@stdlib/stats/base/dists/chi/skewness","base.dists.chi.stdev":"@stdlib/stats/base/dists/chi/stdev","base.dists.chi.variance":"@stdlib/stats/base/dists/chi/variance","base.dists.chisquare.cdf":"@stdlib/stats/base/dists/chisquare/cdf","base.dists.chisquare.ChiSquare":"@stdlib/stats/base/dists/chisquare/ctor","base.dists.chisquare.entropy":"@stdlib/stats/base/dists/chisquare/entropy","base.dists.chisquare.kurtosis":"@stdlib/stats/base/dists/chisquare/kurtosis","base.dists.chisquare.logpdf":"@stdlib/stats/base/dists/chisquare/logpdf","base.dists.chisquare.mean":"@stdlib/stats/base/dists/chisquare/mean","base.dists.chisquare.median":"@stdlib/stats/base/dists/chisquare/median","base.dists.chisquare.mgf":"@stdlib/stats/base/dists/chisquare/mgf","base.dists.chisquare.mode":"@stdlib/stats/base/dists/chisquare/mode","base.dists.chisquare.pdf":"@stdlib/stats/base/dists/chisquare/pdf","base.dists.chisquare.quantile":"@stdlib/stats/base/dists/chisquare/quantile","base.dists.chisquare.skewness":"@stdlib/stats/base/dists/chisquare/skewness","base.dists.chisquare.stdev":"@stdlib/stats/base/dists/chisquare/stdev","base.dists.chisquare.variance":"@stdlib/stats/base/dists/chisquare/variance","base.dists.cosine.cdf":"@stdlib/stats/base/dists/cosine/cdf","base.dists.cosine.Cosine":"@stdlib/stats/base/dists/cosine/ctor","base.dists.cosine.kurtosis":"@stdlib/stats/base/dists/cosine/kurtosis","base.dists.cosine.logcdf":"@stdlib/stats/base/dists/cosine/logcdf","base.dists.cosine.logpdf":"@stdlib/stats/base/dists/cosine/logpdf","base.dists.cosine.mean":"@stdlib/stats/base/dists/cosine/mean","base.dists.cosine.median":"@stdlib/stats/base/dists/cosine/median","base.dists.cosine.mgf":"@stdlib/stats/base/dists/cosine/mgf","base.dists.cosine.mode":"@stdlib/stats/base/dists/cosine/mode","base.dists.cosine.pdf":"@stdlib/stats/base/dists/cosine/pdf","base.dists.cosine.quantile":"@stdlib/stats/base/dists/cosine/quantile","base.dists.cosine.skewness":"@stdlib/stats/base/dists/cosine/skewness","base.dists.cosine.stdev":"@stdlib/stats/base/dists/cosine/stdev","base.dists.cosine.variance":"@stdlib/stats/base/dists/cosine/variance","base.dists.degenerate.cdf":"@stdlib/stats/base/dists/degenerate/cdf","base.dists.degenerate.Degenerate":"@stdlib/stats/base/dists/degenerate/ctor","base.dists.degenerate.entropy":"@stdlib/stats/base/dists/degenerate/entropy","base.dists.degenerate.logcdf":"@stdlib/stats/base/dists/degenerate/logcdf","base.dists.degenerate.logpdf":"@stdlib/stats/base/dists/degenerate/logpdf","base.dists.degenerate.logpmf":"@stdlib/stats/base/dists/degenerate/logpmf","base.dists.degenerate.mean":"@stdlib/stats/base/dists/degenerate/mean","base.dists.degenerate.median":"@stdlib/stats/base/dists/degenerate/median","base.dists.degenerate.mgf":"@stdlib/stats/base/dists/degenerate/mgf","base.dists.degenerate.mode":"@stdlib/stats/base/dists/degenerate/mode","base.dists.degenerate.pdf":"@stdlib/stats/base/dists/degenerate/pdf","base.dists.degenerate.pmf":"@stdlib/stats/base/dists/degenerate/pmf","base.dists.degenerate.quantile":"@stdlib/stats/base/dists/degenerate/quantile","base.dists.degenerate.stdev":"@stdlib/stats/base/dists/degenerate/stdev","base.dists.degenerate.variance":"@stdlib/stats/base/dists/degenerate/variance","base.dists.discreteUniform.cdf":"@stdlib/stats/base/dists/discrete-uniform/cdf","base.dists.discreteUniform.DiscreteUniform":"@stdlib/stats/base/dists/discrete-uniform/ctor","base.dists.discreteUniform.entropy":"@stdlib/stats/base/dists/discrete-uniform/entropy","base.dists.discreteUniform.kurtosis":"@stdlib/stats/base/dists/discrete-uniform/kurtosis","base.dists.discreteUniform.logcdf":"@stdlib/stats/base/dists/discrete-uniform/logcdf","base.dists.discreteUniform.logpmf":"@stdlib/stats/base/dists/discrete-uniform/logpmf","base.dists.discreteUniform.mean":"@stdlib/stats/base/dists/discrete-uniform/mean","base.dists.discreteUniform.median":"@stdlib/stats/base/dists/discrete-uniform/median","base.dists.discreteUniform.mgf":"@stdlib/stats/base/dists/discrete-uniform/mgf","base.dists.discreteUniform.pmf":"@stdlib/stats/base/dists/discrete-uniform/pmf","base.dists.discreteUniform.quantile":"@stdlib/stats/base/dists/discrete-uniform/quantile","base.dists.discreteUniform.skewness":"@stdlib/stats/base/dists/discrete-uniform/skewness","base.dists.discreteUniform.stdev":"@stdlib/stats/base/dists/discrete-uniform/stdev","base.dists.discreteUniform.variance":"@stdlib/stats/base/dists/discrete-uniform/variance","base.dists.erlang.cdf":"@stdlib/stats/base/dists/erlang/cdf","base.dists.erlang.entropy":"@stdlib/stats/base/dists/erlang/entropy","base.dists.erlang.Erlang":"@stdlib/stats/base/dists/erlang/ctor","base.dists.erlang.kurtosis":"@stdlib/stats/base/dists/erlang/kurtosis","base.dists.erlang.logpdf":"@stdlib/stats/base/dists/erlang/logpdf","base.dists.erlang.mean":"@stdlib/stats/base/dists/erlang/mean","base.dists.erlang.mgf":"@stdlib/stats/base/dists/erlang/mgf","base.dists.erlang.mode":"@stdlib/stats/base/dists/erlang/mode","base.dists.erlang.pdf":"@stdlib/stats/base/dists/erlang/pdf","base.dists.erlang.quantile":"@stdlib/stats/base/dists/erlang/quantile","base.dists.erlang.skewness":"@stdlib/stats/base/dists/erlang/skewness","base.dists.erlang.stdev":"@stdlib/stats/base/dists/erlang/stdev","base.dists.erlang.variance":"@stdlib/stats/base/dists/erlang/variance","base.dists.exponential.cdf":"@stdlib/stats/base/dists/exponential/cdf","base.dists.exponential.entropy":"@stdlib/stats/base/dists/exponential/entropy","base.dists.exponential.Exponential":"@stdlib/stats/base/dists/exponential/ctor","base.dists.exponential.kurtosis":"@stdlib/stats/base/dists/exponential/kurtosis","base.dists.exponential.logcdf":"@stdlib/stats/base/dists/exponential/logcdf","base.dists.exponential.logpdf":"@stdlib/stats/base/dists/exponential/logpdf","base.dists.exponential.mean":"@stdlib/stats/base/dists/exponential/mean","base.dists.exponential.median":"@stdlib/stats/base/dists/exponential/median","base.dists.exponential.mgf":"@stdlib/stats/base/dists/exponential/mgf","base.dists.exponential.mode":"@stdlib/stats/base/dists/exponential/mode","base.dists.exponential.pdf":"@stdlib/stats/base/dists/exponential/pdf","base.dists.exponential.quantile":"@stdlib/stats/base/dists/exponential/quantile","base.dists.exponential.skewness":"@stdlib/stats/base/dists/exponential/skewness","base.dists.exponential.stdev":"@stdlib/stats/base/dists/exponential/stdev","base.dists.exponential.variance":"@stdlib/stats/base/dists/exponential/variance","base.dists.f.cdf":"@stdlib/stats/base/dists/f/cdf","base.dists.f.entropy":"@stdlib/stats/base/dists/f/entropy","base.dists.f.F":"@stdlib/stats/base/dists/f/ctor","base.dists.f.kurtosis":"@stdlib/stats/base/dists/f/kurtosis","base.dists.f.mean":"@stdlib/stats/base/dists/f/mean","base.dists.f.mode":"@stdlib/stats/base/dists/f/mode","base.dists.f.pdf":"@stdlib/stats/base/dists/f/pdf","base.dists.f.quantile":"@stdlib/stats/base/dists/f/quantile","base.dists.f.skewness":"@stdlib/stats/base/dists/f/skewness","base.dists.f.stdev":"@stdlib/stats/base/dists/f/stdev","base.dists.f.variance":"@stdlib/stats/base/dists/f/variance","base.dists.frechet.cdf":"@stdlib/stats/base/dists/frechet/cdf","base.dists.frechet.entropy":"@stdlib/stats/base/dists/frechet/entropy","base.dists.frechet.Frechet":"@stdlib/stats/base/dists/frechet/ctor","base.dists.frechet.kurtosis":"@stdlib/stats/base/dists/frechet/kurtosis","base.dists.frechet.logcdf":"@stdlib/stats/base/dists/frechet/logcdf","base.dists.frechet.logpdf":"@stdlib/stats/base/dists/frechet/logpdf","base.dists.frechet.mean":"@stdlib/stats/base/dists/frechet/mean","base.dists.frechet.median":"@stdlib/stats/base/dists/frechet/median","base.dists.frechet.mode":"@stdlib/stats/base/dists/frechet/mode","base.dists.frechet.pdf":"@stdlib/stats/base/dists/frechet/pdf","base.dists.frechet.quantile":"@stdlib/stats/base/dists/frechet/quantile","base.dists.frechet.skewness":"@stdlib/stats/base/dists/frechet/skewness","base.dists.frechet.stdev":"@stdlib/stats/base/dists/frechet/stdev","base.dists.frechet.variance":"@stdlib/stats/base/dists/frechet/variance","base.dists.gamma.cdf":"@stdlib/stats/base/dists/gamma/cdf","base.dists.gamma.entropy":"@stdlib/stats/base/dists/gamma/entropy","base.dists.gamma.Gamma":"@stdlib/stats/base/dists/gamma/ctor","base.dists.gamma.kurtosis":"@stdlib/stats/base/dists/gamma/kurtosis","base.dists.gamma.logcdf":"@stdlib/stats/base/dists/gamma/logcdf","base.dists.gamma.logpdf":"@stdlib/stats/base/dists/gamma/logpdf","base.dists.gamma.mean":"@stdlib/stats/base/dists/gamma/mean","base.dists.gamma.mgf":"@stdlib/stats/base/dists/gamma/mgf","base.dists.gamma.mode":"@stdlib/stats/base/dists/gamma/mode","base.dists.gamma.pdf":"@stdlib/stats/base/dists/gamma/pdf","base.dists.gamma.quantile":"@stdlib/stats/base/dists/gamma/quantile","base.dists.gamma.skewness":"@stdlib/stats/base/dists/gamma/skewness","base.dists.gamma.stdev":"@stdlib/stats/base/dists/gamma/stdev","base.dists.gamma.variance":"@stdlib/stats/base/dists/gamma/variance","base.dists.geometric.cdf":"@stdlib/stats/base/dists/geometric/cdf","base.dists.geometric.entropy":"@stdlib/stats/base/dists/geometric/entropy","base.dists.geometric.Geometric":"@stdlib/stats/base/dists/geometric/ctor","base.dists.geometric.kurtosis":"@stdlib/stats/base/dists/geometric/kurtosis","base.dists.geometric.logcdf":"@stdlib/stats/base/dists/geometric/logcdf","base.dists.geometric.logpmf":"@stdlib/stats/base/dists/geometric/logpmf","base.dists.geometric.mean":"@stdlib/stats/base/dists/geometric/mean","base.dists.geometric.median":"@stdlib/stats/base/dists/geometric/median","base.dists.geometric.mgf":"@stdlib/stats/base/dists/geometric/mgf","base.dists.geometric.mode":"@stdlib/stats/base/dists/geometric/mode","base.dists.geometric.pmf":"@stdlib/stats/base/dists/geometric/pmf","base.dists.geometric.quantile":"@stdlib/stats/base/dists/geometric/quantile","base.dists.geometric.skewness":"@stdlib/stats/base/dists/geometric/skewness","base.dists.geometric.stdev":"@stdlib/stats/base/dists/geometric/stdev","base.dists.geometric.variance":"@stdlib/stats/base/dists/geometric/variance","base.dists.gumbel.cdf":"@stdlib/stats/base/dists/gumbel/cdf","base.dists.gumbel.entropy":"@stdlib/stats/base/dists/gumbel/entropy","base.dists.gumbel.Gumbel":"@stdlib/stats/base/dists/gumbel/ctor","base.dists.gumbel.kurtosis":"@stdlib/stats/base/dists/gumbel/kurtosis","base.dists.gumbel.logcdf":"@stdlib/stats/base/dists/gumbel/logcdf","base.dists.gumbel.logpdf":"@stdlib/stats/base/dists/gumbel/logpdf","base.dists.gumbel.mean":"@stdlib/stats/base/dists/gumbel/mean","base.dists.gumbel.median":"@stdlib/stats/base/dists/gumbel/median","base.dists.gumbel.mgf":"@stdlib/stats/base/dists/gumbel/mgf","base.dists.gumbel.mode":"@stdlib/stats/base/dists/gumbel/mode","base.dists.gumbel.pdf":"@stdlib/stats/base/dists/gumbel/pdf","base.dists.gumbel.quantile":"@stdlib/stats/base/dists/gumbel/quantile","base.dists.gumbel.skewness":"@stdlib/stats/base/dists/gumbel/skewness","base.dists.gumbel.stdev":"@stdlib/stats/base/dists/gumbel/stdev","base.dists.gumbel.variance":"@stdlib/stats/base/dists/gumbel/variance","base.dists.hypergeometric.cdf":"@stdlib/stats/base/dists/hypergeometric/cdf","base.dists.hypergeometric.Hypergeometric":"@stdlib/stats/base/dists/hypergeometric/ctor","base.dists.hypergeometric.kurtosis":"@stdlib/stats/base/dists/hypergeometric/kurtosis","base.dists.hypergeometric.logpmf":"@stdlib/stats/base/dists/hypergeometric/logpmf","base.dists.hypergeometric.mean":"@stdlib/stats/base/dists/hypergeometric/mean","base.dists.hypergeometric.mode":"@stdlib/stats/base/dists/hypergeometric/mode","base.dists.hypergeometric.pmf":"@stdlib/stats/base/dists/hypergeometric/pmf","base.dists.hypergeometric.quantile":"@stdlib/stats/base/dists/hypergeometric/quantile","base.dists.hypergeometric.skewness":"@stdlib/stats/base/dists/hypergeometric/skewness","base.dists.hypergeometric.stdev":"@stdlib/stats/base/dists/hypergeometric/stdev","base.dists.hypergeometric.variance":"@stdlib/stats/base/dists/hypergeometric/variance","base.dists.invgamma.cdf":"@stdlib/stats/base/dists/invgamma/cdf","base.dists.invgamma.entropy":"@stdlib/stats/base/dists/invgamma/entropy","base.dists.invgamma.InvGamma":"@stdlib/stats/base/dists/invgamma/ctor","base.dists.invgamma.kurtosis":"@stdlib/stats/base/dists/invgamma/kurtosis","base.dists.invgamma.logpdf":"@stdlib/stats/base/dists/invgamma/logpdf","base.dists.invgamma.mean":"@stdlib/stats/base/dists/invgamma/mean","base.dists.invgamma.mode":"@stdlib/stats/base/dists/invgamma/mode","base.dists.invgamma.pdf":"@stdlib/stats/base/dists/invgamma/pdf","base.dists.invgamma.quantile":"@stdlib/stats/base/dists/invgamma/quantile","base.dists.invgamma.skewness":"@stdlib/stats/base/dists/invgamma/skewness","base.dists.invgamma.stdev":"@stdlib/stats/base/dists/invgamma/stdev","base.dists.invgamma.variance":"@stdlib/stats/base/dists/invgamma/variance","base.dists.kumaraswamy.cdf":"@stdlib/stats/base/dists/kumaraswamy/cdf","base.dists.kumaraswamy.Kumaraswamy":"@stdlib/stats/base/dists/kumaraswamy/ctor","base.dists.kumaraswamy.kurtosis":"@stdlib/stats/base/dists/kumaraswamy/kurtosis","base.dists.kumaraswamy.logcdf":"@stdlib/stats/base/dists/kumaraswamy/logcdf","base.dists.kumaraswamy.logpdf":"@stdlib/stats/base/dists/kumaraswamy/logpdf","base.dists.kumaraswamy.mean":"@stdlib/stats/base/dists/kumaraswamy/mean","base.dists.kumaraswamy.median":"@stdlib/stats/base/dists/kumaraswamy/median","base.dists.kumaraswamy.mode":"@stdlib/stats/base/dists/kumaraswamy/mode","base.dists.kumaraswamy.pdf":"@stdlib/stats/base/dists/kumaraswamy/pdf","base.dists.kumaraswamy.quantile":"@stdlib/stats/base/dists/kumaraswamy/quantile","base.dists.kumaraswamy.skewness":"@stdlib/stats/base/dists/kumaraswamy/skewness","base.dists.kumaraswamy.stdev":"@stdlib/stats/base/dists/kumaraswamy/stdev","base.dists.kumaraswamy.variance":"@stdlib/stats/base/dists/kumaraswamy/variance","base.dists.laplace.cdf":"@stdlib/stats/base/dists/laplace/cdf","base.dists.laplace.entropy":"@stdlib/stats/base/dists/laplace/entropy","base.dists.laplace.kurtosis":"@stdlib/stats/base/dists/laplace/kurtosis","base.dists.laplace.Laplace":"@stdlib/stats/base/dists/laplace/ctor","base.dists.laplace.logcdf":"@stdlib/stats/base/dists/laplace/logcdf","base.dists.laplace.logpdf":"@stdlib/stats/base/dists/laplace/logpdf","base.dists.laplace.mean":"@stdlib/stats/base/dists/laplace/mean","base.dists.laplace.median":"@stdlib/stats/base/dists/laplace/median","base.dists.laplace.mgf":"@stdlib/stats/base/dists/laplace/mgf","base.dists.laplace.mode":"@stdlib/stats/base/dists/laplace/mode","base.dists.laplace.pdf":"@stdlib/stats/base/dists/laplace/pdf","base.dists.laplace.quantile":"@stdlib/stats/base/dists/laplace/quantile","base.dists.laplace.skewness":"@stdlib/stats/base/dists/laplace/skewness","base.dists.laplace.stdev":"@stdlib/stats/base/dists/laplace/stdev","base.dists.laplace.variance":"@stdlib/stats/base/dists/laplace/variance","base.dists.levy.cdf":"@stdlib/stats/base/dists/levy/cdf","base.dists.levy.entropy":"@stdlib/stats/base/dists/levy/entropy","base.dists.levy.Levy":"@stdlib/stats/base/dists/levy/ctor","base.dists.levy.logcdf":"@stdlib/stats/base/dists/levy/logcdf","base.dists.levy.logpdf":"@stdlib/stats/base/dists/levy/logpdf","base.dists.levy.mean":"@stdlib/stats/base/dists/levy/mean","base.dists.levy.median":"@stdlib/stats/base/dists/levy/median","base.dists.levy.mode":"@stdlib/stats/base/dists/levy/mode","base.dists.levy.pdf":"@stdlib/stats/base/dists/levy/pdf","base.dists.levy.quantile":"@stdlib/stats/base/dists/levy/quantile","base.dists.levy.stdev":"@stdlib/stats/base/dists/levy/stdev","base.dists.levy.variance":"@stdlib/stats/base/dists/levy/variance","base.dists.logistic.cdf":"@stdlib/stats/base/dists/logistic/cdf","base.dists.logistic.entropy":"@stdlib/stats/base/dists/logistic/entropy","base.dists.logistic.kurtosis":"@stdlib/stats/base/dists/logistic/kurtosis","base.dists.logistic.logcdf":"@stdlib/stats/base/dists/logistic/logcdf","base.dists.logistic.Logistic":"@stdlib/stats/base/dists/logistic/ctor","base.dists.logistic.logpdf":"@stdlib/stats/base/dists/logistic/logpdf","base.dists.logistic.mean":"@stdlib/stats/base/dists/logistic/mean","base.dists.logistic.median":"@stdlib/stats/base/dists/logistic/median","base.dists.logistic.mgf":"@stdlib/stats/base/dists/logistic/mgf","base.dists.logistic.mode":"@stdlib/stats/base/dists/logistic/mode","base.dists.logistic.pdf":"@stdlib/stats/base/dists/logistic/pdf","base.dists.logistic.quantile":"@stdlib/stats/base/dists/logistic/quantile","base.dists.logistic.skewness":"@stdlib/stats/base/dists/logistic/skewness","base.dists.logistic.stdev":"@stdlib/stats/base/dists/logistic/stdev","base.dists.logistic.variance":"@stdlib/stats/base/dists/logistic/variance","base.dists.lognormal.cdf":"@stdlib/stats/base/dists/lognormal/cdf","base.dists.lognormal.entropy":"@stdlib/stats/base/dists/lognormal/entropy","base.dists.lognormal.kurtosis":"@stdlib/stats/base/dists/lognormal/kurtosis","base.dists.lognormal.LogNormal":"@stdlib/stats/base/dists/lognormal/ctor","base.dists.lognormal.logcdf":"@stdlib/stats/base/dists/lognormal/logcdf","base.dists.lognormal.logpdf":"@stdlib/stats/base/dists/lognormal/logpdf","base.dists.lognormal.mean":"@stdlib/stats/base/dists/lognormal/mean","base.dists.lognormal.median":"@stdlib/stats/base/dists/lognormal/median","base.dists.lognormal.mode":"@stdlib/stats/base/dists/lognormal/mode","base.dists.lognormal.pdf":"@stdlib/stats/base/dists/lognormal/pdf","base.dists.lognormal.quantile":"@stdlib/stats/base/dists/lognormal/quantile","base.dists.lognormal.skewness":"@stdlib/stats/base/dists/lognormal/skewness","base.dists.lognormal.stdev":"@stdlib/stats/base/dists/lognormal/stdev","base.dists.lognormal.variance":"@stdlib/stats/base/dists/lognormal/variance","base.dists.negativeBinomial.cdf":"@stdlib/stats/base/dists/negative-binomial/cdf","base.dists.negativeBinomial.kurtosis":"@stdlib/stats/base/dists/negative-binomial/kurtosis","base.dists.negativeBinomial.logpmf":"@stdlib/stats/base/dists/negative-binomial/logpmf","base.dists.negativeBinomial.mean":"@stdlib/stats/base/dists/negative-binomial/mean","base.dists.negativeBinomial.mgf":"@stdlib/stats/base/dists/negative-binomial/mgf","base.dists.negativeBinomial.mode":"@stdlib/stats/base/dists/negative-binomial/mode","base.dists.negativeBinomial.NegativeBinomial":"@stdlib/stats/base/dists/negative-binomial/ctor","base.dists.negativeBinomial.pmf":"@stdlib/stats/base/dists/negative-binomial/pmf","base.dists.negativeBinomial.quantile":"@stdlib/stats/base/dists/negative-binomial/quantile","base.dists.negativeBinomial.skewness":"@stdlib/stats/base/dists/negative-binomial/skewness","base.dists.negativeBinomial.stdev":"@stdlib/stats/base/dists/negative-binomial/stdev","base.dists.negativeBinomial.variance":"@stdlib/stats/base/dists/negative-binomial/variance","base.dists.normal.cdf":"@stdlib/stats/base/dists/normal/cdf","base.dists.normal.entropy":"@stdlib/stats/base/dists/normal/entropy","base.dists.normal.kurtosis":"@stdlib/stats/base/dists/normal/kurtosis","base.dists.normal.logcdf":"@stdlib/stats/base/dists/normal/logcdf","base.dists.normal.logpdf":"@stdlib/stats/base/dists/normal/logpdf","base.dists.normal.mean":"@stdlib/stats/base/dists/normal/mean","base.dists.normal.median":"@stdlib/stats/base/dists/normal/median","base.dists.normal.mgf":"@stdlib/stats/base/dists/normal/mgf","base.dists.normal.mode":"@stdlib/stats/base/dists/normal/mode","base.dists.normal.Normal":"@stdlib/stats/base/dists/normal/ctor","base.dists.normal.pdf":"@stdlib/stats/base/dists/normal/pdf","base.dists.normal.quantile":"@stdlib/stats/base/dists/normal/quantile","base.dists.normal.skewness":"@stdlib/stats/base/dists/normal/skewness","base.dists.normal.stdev":"@stdlib/stats/base/dists/normal/stdev","base.dists.normal.variance":"@stdlib/stats/base/dists/normal/variance","base.dists.pareto1.cdf":"@stdlib/stats/base/dists/pareto-type1/cdf","base.dists.pareto1.entropy":"@stdlib/stats/base/dists/pareto-type1/entropy","base.dists.pareto1.kurtosis":"@stdlib/stats/base/dists/pareto-type1/kurtosis","base.dists.pareto1.logcdf":"@stdlib/stats/base/dists/pareto-type1/logcdf","base.dists.pareto1.logpdf":"@stdlib/stats/base/dists/pareto-type1/logpdf","base.dists.pareto1.mean":"@stdlib/stats/base/dists/pareto-type1/mean","base.dists.pareto1.median":"@stdlib/stats/base/dists/pareto-type1/median","base.dists.pareto1.mode":"@stdlib/stats/base/dists/pareto-type1/mode","base.dists.pareto1.Pareto1":"@stdlib/stats/base/dists/pareto-type1/ctor","base.dists.pareto1.pdf":"@stdlib/stats/base/dists/pareto-type1/pdf","base.dists.pareto1.quantile":"@stdlib/stats/base/dists/pareto-type1/quantile","base.dists.pareto1.skewness":"@stdlib/stats/base/dists/pareto-type1/skewness","base.dists.pareto1.stdev":"@stdlib/stats/base/dists/pareto-type1/stdev","base.dists.pareto1.variance":"@stdlib/stats/base/dists/pareto-type1/variance","base.dists.poisson.cdf":"@stdlib/stats/base/dists/poisson/cdf","base.dists.poisson.entropy":"@stdlib/stats/base/dists/poisson/entropy","base.dists.poisson.kurtosis":"@stdlib/stats/base/dists/poisson/kurtosis","base.dists.poisson.logpmf":"@stdlib/stats/base/dists/poisson/logpmf","base.dists.poisson.mean":"@stdlib/stats/base/dists/poisson/mean","base.dists.poisson.median":"@stdlib/stats/base/dists/poisson/median","base.dists.poisson.mgf":"@stdlib/stats/base/dists/poisson/mgf","base.dists.poisson.mode":"@stdlib/stats/base/dists/poisson/mode","base.dists.poisson.pmf":"@stdlib/stats/base/dists/poisson/pmf","base.dists.poisson.Poisson":"@stdlib/stats/base/dists/poisson/ctor","base.dists.poisson.quantile":"@stdlib/stats/base/dists/poisson/quantile","base.dists.poisson.skewness":"@stdlib/stats/base/dists/poisson/skewness","base.dists.poisson.stdev":"@stdlib/stats/base/dists/poisson/stdev","base.dists.poisson.variance":"@stdlib/stats/base/dists/poisson/variance","base.dists.rayleigh.cdf":"@stdlib/stats/base/dists/rayleigh/cdf","base.dists.rayleigh.entropy":"@stdlib/stats/base/dists/rayleigh/entropy","base.dists.rayleigh.kurtosis":"@stdlib/stats/base/dists/rayleigh/kurtosis","base.dists.rayleigh.logcdf":"@stdlib/stats/base/dists/rayleigh/logcdf","base.dists.rayleigh.logpdf":"@stdlib/stats/base/dists/rayleigh/logpdf","base.dists.rayleigh.mean":"@stdlib/stats/base/dists/rayleigh/mean","base.dists.rayleigh.median":"@stdlib/stats/base/dists/rayleigh/median","base.dists.rayleigh.mgf":"@stdlib/stats/base/dists/rayleigh/mgf","base.dists.rayleigh.mode":"@stdlib/stats/base/dists/rayleigh/mode","base.dists.rayleigh.pdf":"@stdlib/stats/base/dists/rayleigh/pdf","base.dists.rayleigh.quantile":"@stdlib/stats/base/dists/rayleigh/quantile","base.dists.rayleigh.Rayleigh":"@stdlib/stats/base/dists/rayleigh/ctor","base.dists.rayleigh.skewness":"@stdlib/stats/base/dists/rayleigh/skewness","base.dists.rayleigh.stdev":"@stdlib/stats/base/dists/rayleigh/stdev","base.dists.rayleigh.variance":"@stdlib/stats/base/dists/rayleigh/variance","base.dists.signrank.cdf":"@stdlib/stats/base/dists/signrank/cdf","base.dists.signrank.pdf":"@stdlib/stats/base/dists/signrank/pdf","base.dists.signrank.quantile":"@stdlib/stats/base/dists/signrank/quantile","base.dists.studentizedRange.cdf":"@stdlib/stats/base/dists/studentized-range/cdf","base.dists.studentizedRange.quantile":"@stdlib/stats/base/dists/studentized-range/quantile","base.dists.t.cdf":"@stdlib/stats/base/dists/t/cdf","base.dists.t.entropy":"@stdlib/stats/base/dists/t/entropy","base.dists.t.kurtosis":"@stdlib/stats/base/dists/t/kurtosis","base.dists.t.logcdf":"@stdlib/stats/base/dists/t/logcdf","base.dists.t.logpdf":"@stdlib/stats/base/dists/t/logpdf","base.dists.t.mean":"@stdlib/stats/base/dists/t/mean","base.dists.t.median":"@stdlib/stats/base/dists/t/median","base.dists.t.mode":"@stdlib/stats/base/dists/t/mode","base.dists.t.pdf":"@stdlib/stats/base/dists/t/pdf","base.dists.t.quantile":"@stdlib/stats/base/dists/t/quantile","base.dists.t.skewness":"@stdlib/stats/base/dists/t/skewness","base.dists.t.stdev":"@stdlib/stats/base/dists/t/stdev","base.dists.t.T":"@stdlib/stats/base/dists/t/ctor","base.dists.t.variance":"@stdlib/stats/base/dists/t/variance","base.dists.triangular.cdf":"@stdlib/stats/base/dists/triangular/cdf","base.dists.triangular.entropy":"@stdlib/stats/base/dists/triangular/entropy","base.dists.triangular.kurtosis":"@stdlib/stats/base/dists/triangular/kurtosis","base.dists.triangular.logcdf":"@stdlib/stats/base/dists/triangular/logcdf","base.dists.triangular.logpdf":"@stdlib/stats/base/dists/triangular/logpdf","base.dists.triangular.mean":"@stdlib/stats/base/dists/triangular/mean","base.dists.triangular.median":"@stdlib/stats/base/dists/triangular/median","base.dists.triangular.mgf":"@stdlib/stats/base/dists/triangular/mgf","base.dists.triangular.mode":"@stdlib/stats/base/dists/triangular/mode","base.dists.triangular.pdf":"@stdlib/stats/base/dists/triangular/pdf","base.dists.triangular.quantile":"@stdlib/stats/base/dists/triangular/quantile","base.dists.triangular.skewness":"@stdlib/stats/base/dists/triangular/skewness","base.dists.triangular.stdev":"@stdlib/stats/base/dists/triangular/stdev","base.dists.triangular.Triangular":"@stdlib/stats/base/dists/triangular/ctor","base.dists.triangular.variance":"@stdlib/stats/base/dists/triangular/variance","base.dists.truncatedNormal.pdf":"@stdlib/stats/base/dists/truncated-normal/pdf","base.dists.uniform.cdf":"@stdlib/stats/base/dists/uniform/cdf","base.dists.uniform.entropy":"@stdlib/stats/base/dists/uniform/entropy","base.dists.uniform.kurtosis":"@stdlib/stats/base/dists/uniform/kurtosis","base.dists.uniform.logcdf":"@stdlib/stats/base/dists/uniform/logcdf","base.dists.uniform.logpdf":"@stdlib/stats/base/dists/uniform/logpdf","base.dists.uniform.mean":"@stdlib/stats/base/dists/uniform/mean","base.dists.uniform.median":"@stdlib/stats/base/dists/uniform/median","base.dists.uniform.mgf":"@stdlib/stats/base/dists/uniform/mgf","base.dists.uniform.pdf":"@stdlib/stats/base/dists/uniform/pdf","base.dists.uniform.quantile":"@stdlib/stats/base/dists/uniform/quantile","base.dists.uniform.skewness":"@stdlib/stats/base/dists/uniform/skewness","base.dists.uniform.stdev":"@stdlib/stats/base/dists/uniform/stdev","base.dists.uniform.Uniform":"@stdlib/stats/base/dists/uniform/ctor","base.dists.uniform.variance":"@stdlib/stats/base/dists/uniform/variance","base.dists.weibull.cdf":"@stdlib/stats/base/dists/weibull/cdf","base.dists.weibull.entropy":"@stdlib/stats/base/dists/weibull/entropy","base.dists.weibull.kurtosis":"@stdlib/stats/base/dists/weibull/kurtosis","base.dists.weibull.logcdf":"@stdlib/stats/base/dists/weibull/logcdf","base.dists.weibull.logpdf":"@stdlib/stats/base/dists/weibull/logpdf","base.dists.weibull.mean":"@stdlib/stats/base/dists/weibull/mean","base.dists.weibull.median":"@stdlib/stats/base/dists/weibull/median","base.dists.weibull.mgf":"@stdlib/stats/base/dists/weibull/mgf","base.dists.weibull.mode":"@stdlib/stats/base/dists/weibull/mode","base.dists.weibull.pdf":"@stdlib/stats/base/dists/weibull/pdf","base.dists.weibull.quantile":"@stdlib/stats/base/dists/weibull/quantile","base.dists.weibull.skewness":"@stdlib/stats/base/dists/weibull/skewness","base.dists.weibull.stdev":"@stdlib/stats/base/dists/weibull/stdev","base.dists.weibull.variance":"@stdlib/stats/base/dists/weibull/variance","base.dists.weibull.Weibull":"@stdlib/stats/base/dists/weibull/ctor","base.ellipe":"@stdlib/math/base/special/ellipe","base.ellipj":"@stdlib/math/base/special/ellipj","base.ellipk":"@stdlib/math/base/special/ellipk","base.endsWith":"@stdlib/string/base/ends-with","base.epsdiff":"@stdlib/math/base/utils/float64-epsilon-difference","base.erf":"@stdlib/math/base/special/erf","base.erfc":"@stdlib/math/base/special/erfc","base.erfcinv":"@stdlib/math/base/special/erfcinv","base.erfcx":"@stdlib/math/base/special/erfcx","base.erfinv":"@stdlib/math/base/special/erfinv","base.eta":"@stdlib/math/base/special/dirichlet-eta","base.evalpoly":"@stdlib/math/base/tools/evalpoly","base.evalrational":"@stdlib/math/base/tools/evalrational","base.exp":"@stdlib/math/base/special/exp","base.exp2":"@stdlib/math/base/special/exp2","base.exp10":"@stdlib/math/base/special/exp10","base.expit":"@stdlib/math/base/special/expit","base.expm1":"@stdlib/math/base/special/expm1","base.expm1rel":"@stdlib/math/base/special/expm1rel","base.exponent":"@stdlib/number/float64/base/exponent","base.exponentf":"@stdlib/number/float32/base/exponent","base.factorial":"@stdlib/math/base/special/factorial","base.factorial2":"@stdlib/math/base/special/factorial2","base.factorialln":"@stdlib/math/base/special/factorialln","base.fallingFactorial":"@stdlib/math/base/special/falling-factorial","base.fibonacci":"@stdlib/math/base/special/fibonacci","base.fibonacciIndex":"@stdlib/math/base/special/fibonacci-index","base.fibpoly":"@stdlib/math/base/tools/fibpoly","base.firstCodePoint":"@stdlib/string/base/first-code-point","base.firstCodeUnit":"@stdlib/string/base/first","base.firstGraphemeCluster":"@stdlib/string/base/first-grapheme-cluster","base.flipsign":"@stdlib/math/base/special/flipsign","base.flipsignf":"@stdlib/math/base/special/flipsignf","base.float32ToInt32":"@stdlib/number/float32/base/to-int32","base.float32ToUint32":"@stdlib/number/float32/base/to-uint32","base.float64ToFloat32":"@stdlib/number/float64/base/to-float32","base.float64ToInt32":"@stdlib/number/float64/base/to-int32","base.float64ToInt64Bytes":"@stdlib/number/float64/base/to-int64-bytes","base.float64ToUint32":"@stdlib/number/float64/base/to-uint32","base.floor":"@stdlib/math/base/special/floor","base.floor2":"@stdlib/math/base/special/floor2","base.floor10":"@stdlib/math/base/special/floor10","base.floorb":"@stdlib/math/base/special/floorb","base.floorf":"@stdlib/math/base/special/floorf","base.floorn":"@stdlib/math/base/special/floorn","base.floorsd":"@stdlib/math/base/special/floorsd","base.forEachChar":"@stdlib/string/base/for-each","base.forEachCodePoint":"@stdlib/string/base/for-each-code-point","base.forEachCodePointRight":"@stdlib/string/base/for-each-code-point-right","base.forEachGraphemeCluster":"@stdlib/string/base/for-each-grapheme-cluster","base.forEachRight":"@stdlib/string/base/for-each-right","base.formatInterpolate":"@stdlib/string/base/format-interpolate","base.formatTokenize":"@stdlib/string/base/format-tokenize","base.fresnel":"@stdlib/math/base/special/fresnel","base.fresnelc":"@stdlib/math/base/special/fresnelc","base.fresnels":"@stdlib/math/base/special/fresnels","base.frexp":"@stdlib/math/base/special/frexp","base.fromBinaryString":"@stdlib/number/float64/base/from-binary-string","base.fromBinaryStringf":"@stdlib/number/float32/base/from-binary-string","base.fromBinaryStringUint8":"@stdlib/number/uint8/base/from-binary-string","base.fromBinaryStringUint16":"@stdlib/number/uint16/base/from-binary-string","base.fromBinaryStringUint32":"@stdlib/number/uint32/base/from-binary-string","base.fromInt64Bytes":"@stdlib/number/float64/base/from-int64-bytes","base.fromWordf":"@stdlib/number/float32/base/from-word","base.fromWords":"@stdlib/number/float64/base/from-words","base.gamma":"@stdlib/math/base/special/gamma","base.gamma1pm1":"@stdlib/math/base/special/gamma1pm1","base.gammaDeltaRatio":"@stdlib/math/base/special/gamma-delta-ratio","base.gammainc":"@stdlib/math/base/special/gammainc","base.gammaincinv":"@stdlib/math/base/special/gammaincinv","base.gammaLanczosSum":"@stdlib/math/base/special/gamma-lanczos-sum","base.gammaLanczosSumExpGScaled":"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled","base.gammaln":"@stdlib/math/base/special/gammaln","base.gammasgn":"@stdlib/math/base/special/gammasgn","base.gcd":"@stdlib/math/base/special/gcd","base.getHighWord":"@stdlib/number/float64/base/get-high-word","base.getLowWord":"@stdlib/number/float64/base/get-low-word","base.hacovercos":"@stdlib/math/base/special/hacovercos","base.hacoversin":"@stdlib/math/base/special/hacoversin","base.havercos":"@stdlib/math/base/special/havercos","base.haversin":"@stdlib/math/base/special/haversin","base.headercase":"@stdlib/string/base/headercase","base.heaviside":"@stdlib/math/base/special/heaviside","base.hermitepoly":"@stdlib/math/base/tools/hermitepoly","base.hypot":"@stdlib/math/base/special/hypot","base.hypotf":"@stdlib/math/base/special/hypotf","base.identity":"@stdlib/math/base/special/identity","base.identityf":"@stdlib/math/base/special/identityf","base.imul":"@stdlib/math/base/ops/imul","base.imuldw":"@stdlib/math/base/ops/imuldw","base.int2slice":"@stdlib/slice/base/int2slice","base.int32ToUint32":"@stdlib/number/int32/base/to-uint32","base.inv":"@stdlib/math/base/special/inv","base.invcase":"@stdlib/string/base/invcase","base.invf":"@stdlib/math/base/special/invf","base.isComposite":"@stdlib/math/base/assert/is-composite","base.isCoprime":"@stdlib/math/base/assert/is-coprime","base.isEven":"@stdlib/math/base/assert/is-even","base.isEvenInt32":"@stdlib/math/base/assert/int32-is-even","base.isFinite":"@stdlib/math/base/assert/is-finite","base.isFinitef":"@stdlib/math/base/assert/is-finitef","base.isInfinite":"@stdlib/math/base/assert/is-infinite","base.isInfinitef":"@stdlib/math/base/assert/is-infinitef","base.isInteger":"@stdlib/math/base/assert/is-integer","base.isnan":"@stdlib/math/base/assert/is-nan","base.isnanf":"@stdlib/math/base/assert/is-nanf","base.isNegativeFinite":"@stdlib/math/base/assert/is-negative-finite","base.isNegativeInteger":"@stdlib/math/base/assert/is-negative-integer","base.isNegativeZero":"@stdlib/math/base/assert/is-negative-zero","base.isNegativeZerof":"@stdlib/math/base/assert/is-negative-zerof","base.isNonNegativeFinite":"@stdlib/math/base/assert/is-nonnegative-finite","base.isNonNegativeInteger":"@stdlib/math/base/assert/is-nonnegative-integer","base.isNonPositiveFinite":"@stdlib/math/base/assert/is-nonpositive-finite","base.isNonPositiveInteger":"@stdlib/math/base/assert/is-nonpositive-integer","base.isOdd":"@stdlib/math/base/assert/is-odd","base.isOddInt32":"@stdlib/math/base/assert/int32-is-odd","base.isPositiveFinite":"@stdlib/math/base/assert/is-positive-finite","base.isPositiveInteger":"@stdlib/math/base/assert/is-positive-integer","base.isPositiveZero":"@stdlib/math/base/assert/is-positive-zero","base.isPositiveZerof":"@stdlib/math/base/assert/is-positive-zerof","base.isPow2Uint32":"@stdlib/math/base/assert/uint32-is-pow2","base.isPrime":"@stdlib/math/base/assert/is-prime","base.isProbability":"@stdlib/math/base/assert/is-probability","base.isSafeInteger":"@stdlib/math/base/assert/is-safe-integer","base.kebabcase":"@stdlib/string/base/kebabcase","base.kernelBetainc":"@stdlib/math/base/special/kernel-betainc","base.kernelBetaincinv":"@stdlib/math/base/special/kernel-betaincinv","base.kernelCos":"@stdlib/math/base/special/kernel-cos","base.kernelLog1p":"@stdlib/math/base/special/kernel-log1p","base.kernelSin":"@stdlib/math/base/special/kernel-sin","base.kernelTan":"@stdlib/math/base/special/kernel-tan","base.kroneckerDelta":"@stdlib/math/base/special/kronecker-delta","base.kroneckerDeltaf":"@stdlib/math/base/special/kronecker-deltaf","base.labs":"@stdlib/math/base/special/labs","base.last":"@stdlib/string/base/last","base.lastCodePoint":"@stdlib/string/base/last-code-point","base.lastGraphemeCluster":"@stdlib/string/base/last-grapheme-cluster","base.lcm":"@stdlib/math/base/special/lcm","base.ldexp":"@stdlib/math/base/special/ldexp","base.leftPad":"@stdlib/string/base/left-pad","base.leftTrim":"@stdlib/string/base/left-trim","base.ln":"@stdlib/math/base/special/ln","base.log":"@stdlib/math/base/special/log","base.log1mexp":"@stdlib/math/base/special/log1mexp","base.log1p":"@stdlib/math/base/special/log1p","base.log1pexp":"@stdlib/math/base/special/log1pexp","base.log1pmx":"@stdlib/math/base/special/log1pmx","base.log2":"@stdlib/math/base/special/log2","base.log10":"@stdlib/math/base/special/log10","base.logaddexp":"@stdlib/math/base/special/logaddexp","base.logit":"@stdlib/math/base/special/logit","base.lowercase":"@stdlib/string/base/lowercase","base.lucas":"@stdlib/math/base/special/lucas","base.lucaspoly":"@stdlib/math/base/tools/lucaspoly","base.max":"@stdlib/math/base/special/max","base.maxabs":"@stdlib/math/base/special/maxabs","base.maxabsn":"@stdlib/math/base/special/maxabsn","base.maxn":"@stdlib/math/base/special/maxn","base.min":"@stdlib/math/base/special/min","base.minabs":"@stdlib/math/base/special/minabs","base.minabsn":"@stdlib/math/base/special/minabsn","base.minmax":"@stdlib/math/base/special/minmax","base.minmaxabs":"@stdlib/math/base/special/minmaxabs","base.minmaxabsn":"@stdlib/math/base/special/minmaxabsn","base.minmaxn":"@stdlib/math/base/special/minmaxn","base.minn":"@stdlib/math/base/special/minn","base.modf":"@stdlib/math/base/special/modf","base.mul":"@stdlib/number/float64/base/mul","base.mulf":"@stdlib/number/float32/base/mul","base.ndarray":"@stdlib/ndarray/base/ctor","base.ndarrayUnary":"@stdlib/ndarray/base/unary","base.ndzeros":"@stdlib/ndarray/base/zeros","base.ndzerosLike":"@stdlib/ndarray/base/zeros-like","base.negafibonacci":"@stdlib/math/base/special/negafibonacci","base.negalucas":"@stdlib/math/base/special/negalucas","base.nonfibonacci":"@stdlib/math/base/special/nonfibonacci","base.normalize":"@stdlib/number/float64/base/normalize","base.normalizef":"@stdlib/number/float32/base/normalize","base.normalizeMultiSlice":"@stdlib/slice/base/normalize-multi-slice","base.normalizeSlice":"@stdlib/slice/base/normalize-slice","base.normhermitepoly":"@stdlib/math/base/tools/normhermitepoly","base.pascalcase":"@stdlib/string/base/pascalcase","base.pdiff":"@stdlib/math/base/special/pdiff","base.pdifff":"@stdlib/math/base/special/pdifff","base.percentEncode":"@stdlib/string/base/percent-encode","base.polygamma":"@stdlib/math/base/special/polygamma","base.pow":"@stdlib/math/base/special/pow","base.powm1":"@stdlib/math/base/special/powm1","base.rad2deg":"@stdlib/math/base/special/rad2deg","base.rad2degf":"@stdlib/math/base/special/rad2degf","base.ramp":"@stdlib/math/base/special/ramp","base.rampf":"@stdlib/math/base/special/rampf","base.random.arcsine":"@stdlib/random/base/arcsine","base.random.bernoulli":"@stdlib/random/base/bernoulli","base.random.beta":"@stdlib/random/base/beta","base.random.betaprime":"@stdlib/random/base/betaprime","base.random.binomial":"@stdlib/random/base/binomial","base.random.boxMuller":"@stdlib/random/base/box-muller","base.random.cauchy":"@stdlib/random/base/cauchy","base.random.chi":"@stdlib/random/base/chi","base.random.chisquare":"@stdlib/random/base/chisquare","base.random.cosine":"@stdlib/random/base/cosine","base.random.discreteUniform":"@stdlib/random/base/discrete-uniform","base.random.erlang":"@stdlib/random/base/erlang","base.random.exponential":"@stdlib/random/base/exponential","base.random.f":"@stdlib/random/base/f","base.random.frechet":"@stdlib/random/base/frechet","base.random.gamma":"@stdlib/random/base/gamma","base.random.geometric":"@stdlib/random/base/geometric","base.random.gumbel":"@stdlib/random/base/gumbel","base.random.hypergeometric":"@stdlib/random/base/hypergeometric","base.random.improvedZiggurat":"@stdlib/random/base/improved-ziggurat","base.random.invgamma":"@stdlib/random/base/invgamma","base.random.kumaraswamy":"@stdlib/random/base/kumaraswamy","base.random.laplace":"@stdlib/random/base/laplace","base.random.levy":"@stdlib/random/base/levy","base.random.logistic":"@stdlib/random/base/logistic","base.random.lognormal":"@stdlib/random/base/lognormal","base.random.minstd":"@stdlib/random/base/minstd","base.random.minstdShuffle":"@stdlib/random/base/minstd-shuffle","base.random.mt19937":"@stdlib/random/base/mt19937","base.random.negativeBinomial":"@stdlib/random/base/negative-binomial","base.random.normal":"@stdlib/random/base/normal","base.random.pareto1":"@stdlib/random/base/pareto-type1","base.random.poisson":"@stdlib/random/base/poisson","base.random.randi":"@stdlib/random/base/randi","base.random.randn":"@stdlib/random/base/randn","base.random.randu":"@stdlib/random/base/randu","base.random.rayleigh":"@stdlib/random/base/rayleigh","base.random.t":"@stdlib/random/base/t","base.random.triangular":"@stdlib/random/base/triangular","base.random.uniform":"@stdlib/random/base/uniform","base.random.weibull":"@stdlib/random/base/weibull","base.rcbrt":"@stdlib/math/base/special/rcbrt","base.rcbrtf":"@stdlib/math/base/special/rcbrtf","base.reldiff":"@stdlib/math/base/utils/relative-difference","base.removeFirst":"@stdlib/string/base/remove-first","base.removeFirstCodePoint":"@stdlib/string/base/remove-first-code-point","base.removeFirstGraphemeCluster":"@stdlib/string/base/remove-first-grapheme-cluster","base.removeLast":"@stdlib/string/base/remove-last","base.removeLastCodePoint":"@stdlib/string/base/remove-last-code-point","base.removeLastGraphemeCluster":"@stdlib/string/base/remove-last-grapheme-cluster","base.rempio2":"@stdlib/math/base/special/rempio2","base.repeat":"@stdlib/string/base/repeat","base.replace":"@stdlib/string/base/replace","base.replaceAfter":"@stdlib/string/base/replace-after","base.replaceAfterLast":"@stdlib/string/base/replace-after-last","base.replaceBefore":"@stdlib/string/base/replace-before","base.replaceBeforeLast":"@stdlib/string/base/replace-before-last","base.reverse":"@stdlib/string/base/reverse","base.reverseCodePoints":"@stdlib/string/base/reverse-code-points","base.reverseGraphemeClusters":"@stdlib/string/base/reverse-grapheme-clusters","base.rightPad":"@stdlib/string/base/right-pad","base.rightTrim":"@stdlib/string/base/right-trim","base.risingFactorial":"@stdlib/math/base/special/rising-factorial","base.rotl32":"@stdlib/number/uint32/base/rotl","base.rotr32":"@stdlib/number/uint32/base/rotr","base.round":"@stdlib/math/base/special/round","base.round2":"@stdlib/math/base/special/round2","base.round10":"@stdlib/math/base/special/round10","base.roundb":"@stdlib/math/base/special/roundb","base.roundn":"@stdlib/math/base/special/roundn","base.roundsd":"@stdlib/math/base/special/roundsd","base.rsqrt":"@stdlib/math/base/special/rsqrt","base.rsqrtf":"@stdlib/math/base/special/rsqrtf","base.sargs2multislice":"@stdlib/slice/base/sargs2multislice","base.scalar2ndarray":"@stdlib/ndarray/base/from-scalar","base.secd":"@stdlib/math/base/special/secd","base.seq2multislice":"@stdlib/slice/base/seq2multislice","base.seq2slice":"@stdlib/slice/base/seq2slice","base.setHighWord":"@stdlib/number/float64/base/set-high-word","base.setLowWord":"@stdlib/number/float64/base/set-low-word","base.sici":"@stdlib/math/base/special/sici","base.signbit":"@stdlib/number/float64/base/signbit","base.signbitf":"@stdlib/number/float32/base/signbit","base.significandf":"@stdlib/number/float32/base/significand","base.signum":"@stdlib/math/base/special/signum","base.signumf":"@stdlib/math/base/special/signumf","base.sin":"@stdlib/math/base/special/sin","base.sinc":"@stdlib/math/base/special/sinc","base.sincos":"@stdlib/math/base/special/sincos","base.sincospi":"@stdlib/math/base/special/sincospi","base.sinh":"@stdlib/math/base/special/sinh","base.sinpi":"@stdlib/math/base/special/sinpi","base.slice2seq":"@stdlib/slice/base/slice2seq","base.sliceLength":"@stdlib/slice/base/length","base.sliceNonReducedDimensions":"@stdlib/slice/base/nonreduced-dimensions","base.sliceReducedDimensions":"@stdlib/slice/base/reduced-dimensions","base.sliceShape":"@stdlib/slice/base/shape","base.snakecase":"@stdlib/string/base/snakecase","base.spence":"@stdlib/math/base/special/spence","base.sqrt":"@stdlib/math/base/special/sqrt","base.sqrt1pm1":"@stdlib/math/base/special/sqrt1pm1","base.sqrtf":"@stdlib/math/base/special/sqrtf","base.sqrtpi":"@stdlib/math/base/special/sqrtpi","base.startcase":"@stdlib/string/base/startcase","base.startsWith":"@stdlib/string/base/starts-with","base.stickycase":"@stdlib/string/base/stickycase","base.strided.binary":"@stdlib/strided/base/binary","base.strided.binaryDtypeSignatures":"@stdlib/strided/base/binary-dtype-signatures","base.strided.binarySignatureCallbacks":"@stdlib/strided/base/binary-signature-callbacks","base.strided.ccopy":"@stdlib/blas/base/ccopy","base.strided.cmap":"@stdlib/strided/base/cmap","base.strided.cswap":"@stdlib/blas/base/cswap","base.strided.cumax":"@stdlib/stats/base/cumax","base.strided.cumaxabs":"@stdlib/stats/base/cumaxabs","base.strided.cumin":"@stdlib/stats/base/cumin","base.strided.cuminabs":"@stdlib/stats/base/cuminabs","base.strided.dabs":"@stdlib/math/strided/special/dabs","base.strided.dabs2":"@stdlib/math/strided/special/dabs2","base.strided.dapx":"@stdlib/blas/ext/base/dapx","base.strided.dapxsum":"@stdlib/blas/ext/base/dapxsum","base.strided.dapxsumkbn":"@stdlib/blas/ext/base/dapxsumkbn","base.strided.dapxsumkbn2":"@stdlib/blas/ext/base/dapxsumkbn2","base.strided.dapxsumors":"@stdlib/blas/ext/base/dapxsumors","base.strided.dapxsumpw":"@stdlib/blas/ext/base/dapxsumpw","base.strided.dasum":"@stdlib/blas/base/dasum","base.strided.dasumpw":"@stdlib/blas/ext/base/dasumpw","base.strided.daxpy":"@stdlib/blas/base/daxpy","base.strided.dcbrt":"@stdlib/math/strided/special/dcbrt","base.strided.dceil":"@stdlib/math/strided/special/dceil","base.strided.dcopy":"@stdlib/blas/base/dcopy","base.strided.dcumax":"@stdlib/stats/strided/dcumax","base.strided.dcumaxabs":"@stdlib/stats/strided/dcumaxabs","base.strided.dcumin":"@stdlib/stats/base/dcumin","base.strided.dcuminabs":"@stdlib/stats/strided/dcuminabs","base.strided.dcusum":"@stdlib/blas/ext/base/dcusum","base.strided.dcusumkbn":"@stdlib/blas/ext/base/dcusumkbn","base.strided.dcusumkbn2":"@stdlib/blas/ext/base/dcusumkbn2","base.strided.dcusumors":"@stdlib/blas/ext/base/dcusumors","base.strided.dcusumpw":"@stdlib/blas/ext/base/dcusumpw","base.strided.ddeg2rad":"@stdlib/math/strided/special/ddeg2rad","base.strided.ddot":"@stdlib/blas/base/ddot","base.strided.dfill":"@stdlib/blas/ext/base/dfill","base.strided.dfloor":"@stdlib/math/strided/special/dfloor","base.strided.dinv":"@stdlib/math/strided/special/dinv","base.strided.dmap":"@stdlib/strided/base/dmap","base.strided.dmap2":"@stdlib/strided/base/dmap2","base.strided.dmax":"@stdlib/stats/strided/dmax","base.strided.dmaxabs":"@stdlib/stats/strided/dmaxabs","base.strided.dmaxabssorted":"@stdlib/stats/strided/dmaxabssorted","base.strided.dmaxsorted":"@stdlib/stats/strided/dmaxsorted","base.strided.dmean":"@stdlib/stats/base/dmean","base.strided.dmeankbn":"@stdlib/stats/strided/dmeankbn","base.strided.dmeankbn2":"@stdlib/stats/strided/dmeankbn2","base.strided.dmeanli":"@stdlib/stats/strided/dmeanli","base.strided.dmeanlipw":"@stdlib/stats/strided/dmeanlipw","base.strided.dmeanors":"@stdlib/stats/strided/dmeanors","base.strided.dmeanpn":"@stdlib/stats/base/dmeanpn","base.strided.dmeanpw":"@stdlib/stats/strided/dmeanpw","base.strided.dmeanstdev":"@stdlib/stats/base/dmeanstdev","base.strided.dmeanstdevpn":"@stdlib/stats/base/dmeanstdevpn","base.strided.dmeanvar":"@stdlib/stats/base/dmeanvar","base.strided.dmeanvarpn":"@stdlib/stats/base/dmeanvarpn","base.strided.dmeanwd":"@stdlib/stats/strided/dmeanwd","base.strided.dmediansorted":"@stdlib/stats/strided/dmediansorted","base.strided.dmidrange":"@stdlib/stats/strided/dmidrange","base.strided.dmin":"@stdlib/stats/strided/dmin","base.strided.dminabs":"@stdlib/stats/strided/dminabs","base.strided.dminsorted":"@stdlib/stats/strided/dminsorted","base.strided.dmskabs":"@stdlib/math/strided/special/dmskabs","base.strided.dmskabs2":"@stdlib/math/strided/special/dmskabs2","base.strided.dmskcbrt":"@stdlib/math/strided/special/dmskcbrt","base.strided.dmskceil":"@stdlib/math/strided/special/dmskceil","base.strided.dmskdeg2rad":"@stdlib/math/strided/special/dmskdeg2rad","base.strided.dmskfloor":"@stdlib/math/strided/special/dmskfloor","base.strided.dmskinv":"@stdlib/math/strided/special/dmskinv","base.strided.dmskmap":"@stdlib/strided/base/dmskmap","base.strided.dmskmap2":"@stdlib/strided/base/dmskmap2","base.strided.dmskmax":"@stdlib/stats/base/dmskmax","base.strided.dmskmin":"@stdlib/stats/base/dmskmin","base.strided.dmskramp":"@stdlib/math/strided/special/dmskramp","base.strided.dmskrange":"@stdlib/stats/base/dmskrange","base.strided.dmskrsqrt":"@stdlib/math/strided/special/dmskrsqrt","base.strided.dmsksqrt":"@stdlib/math/strided/special/dmsksqrt","base.strided.dmsktrunc":"@stdlib/math/strided/special/dmsktrunc","base.strided.dnanasum":"@stdlib/blas/ext/base/dnanasum","base.strided.dnanasumors":"@stdlib/blas/ext/base/dnanasumors","base.strided.dnanmax":"@stdlib/stats/strided/dnanmax","base.strided.dnanmaxabs":"@stdlib/stats/strided/dnanmaxabs","base.strided.dnanmean":"@stdlib/stats/strided/dnanmean","base.strided.dnanmeanors":"@stdlib/stats/base/dnanmeanors","base.strided.dnanmeanpn":"@stdlib/stats/base/dnanmeanpn","base.strided.dnanmeanpw":"@stdlib/stats/base/dnanmeanpw","base.strided.dnanmeanwd":"@stdlib/stats/base/dnanmeanwd","base.strided.dnanmin":"@stdlib/stats/base/dnanmin","base.strided.dnanminabs":"@stdlib/stats/base/dnanminabs","base.strided.dnanmskmax":"@stdlib/stats/base/dnanmskmax","base.strided.dnanmskmin":"@stdlib/stats/base/dnanmskmin","base.strided.dnanmskrange":"@stdlib/stats/base/dnanmskrange","base.strided.dnannsum":"@stdlib/blas/ext/base/dnannsum","base.strided.dnannsumkbn":"@stdlib/blas/ext/base/dnannsumkbn","base.strided.dnannsumkbn2":"@stdlib/blas/ext/base/dnannsumkbn2","base.strided.dnannsumors":"@stdlib/blas/ext/base/dnannsumors","base.strided.dnannsumpw":"@stdlib/blas/ext/base/dnannsumpw","base.strided.dnanrange":"@stdlib/stats/base/dnanrange","base.strided.dnanstdev":"@stdlib/stats/base/dnanstdev","base.strided.dnanstdevch":"@stdlib/stats/base/dnanstdevch","base.strided.dnanstdevpn":"@stdlib/stats/base/dnanstdevpn","base.strided.dnanstdevtk":"@stdlib/stats/base/dnanstdevtk","base.strided.dnanstdevwd":"@stdlib/stats/base/dnanstdevwd","base.strided.dnanstdevyc":"@stdlib/stats/base/dnanstdevyc","base.strided.dnansum":"@stdlib/blas/ext/base/dnansum","base.strided.dnansumkbn":"@stdlib/blas/ext/base/dnansumkbn","base.strided.dnansumkbn2":"@stdlib/blas/ext/base/dnansumkbn2","base.strided.dnansumors":"@stdlib/blas/ext/base/dnansumors","base.strided.dnansumpw":"@stdlib/blas/ext/base/dnansumpw","base.strided.dnanvariance":"@stdlib/stats/base/dnanvariance","base.strided.dnanvariancech":"@stdlib/stats/base/dnanvariancech","base.strided.dnanvariancepn":"@stdlib/stats/base/dnanvariancepn","base.strided.dnanvariancetk":"@stdlib/stats/base/dnanvariancetk","base.strided.dnanvariancewd":"@stdlib/stats/base/dnanvariancewd","base.strided.dnanvarianceyc":"@stdlib/stats/base/dnanvarianceyc","base.strided.dnrm2":"@stdlib/blas/base/dnrm2","base.strided.dramp":"@stdlib/math/strided/special/dramp","base.strided.drange":"@stdlib/stats/base/drange","base.strided.drev":"@stdlib/blas/ext/base/drev","base.strided.drsqrt":"@stdlib/math/strided/special/drsqrt","base.strided.dsapxsum":"@stdlib/blas/ext/base/dsapxsum","base.strided.dsapxsumpw":"@stdlib/blas/ext/base/dsapxsumpw","base.strided.dscal":"@stdlib/blas/base/dscal","base.strided.dsdot":"@stdlib/blas/base/dsdot","base.strided.dsem":"@stdlib/stats/base/dsem","base.strided.dsemch":"@stdlib/stats/base/dsemch","base.strided.dsempn":"@stdlib/stats/base/dsempn","base.strided.dsemtk":"@stdlib/stats/base/dsemtk","base.strided.dsemwd":"@stdlib/stats/base/dsemwd","base.strided.dsemyc":"@stdlib/stats/base/dsemyc","base.strided.dsmean":"@stdlib/stats/base/dsmean","base.strided.dsmeanors":"@stdlib/stats/base/dsmeanors","base.strided.dsmeanpn":"@stdlib/stats/base/dsmeanpn","base.strided.dsmeanpw":"@stdlib/stats/base/dsmeanpw","base.strided.dsmeanwd":"@stdlib/stats/base/dsmeanwd","base.strided.dsnanmean":"@stdlib/stats/base/dsnanmean","base.strided.dsnanmeanors":"@stdlib/stats/base/dsnanmeanors","base.strided.dsnanmeanpn":"@stdlib/stats/base/dsnanmeanpn","base.strided.dsnanmeanwd":"@stdlib/stats/base/dsnanmeanwd","base.strided.dsnannsumors":"@stdlib/blas/ext/base/dsnannsumors","base.strided.dsnansum":"@stdlib/blas/ext/base/dsnansum","base.strided.dsnansumors":"@stdlib/blas/ext/base/dsnansumors","base.strided.dsnansumpw":"@stdlib/blas/ext/base/dsnansumpw","base.strided.dsort2hp":"@stdlib/blas/ext/base/dsort2hp","base.strided.dsort2ins":"@stdlib/blas/ext/base/dsort2ins","base.strided.dsort2sh":"@stdlib/blas/ext/base/dsort2sh","base.strided.dsorthp":"@stdlib/blas/ext/base/dsorthp","base.strided.dsortins":"@stdlib/blas/ext/base/dsortins","base.strided.dsortsh":"@stdlib/blas/ext/base/dsortsh","base.strided.dsqrt":"@stdlib/math/strided/special/dsqrt","base.strided.dssum":"@stdlib/blas/ext/base/dssum","base.strided.dssumors":"@stdlib/blas/ext/base/dssumors","base.strided.dssumpw":"@stdlib/blas/ext/base/dssumpw","base.strided.dstdev":"@stdlib/stats/base/dstdev","base.strided.dstdevch":"@stdlib/stats/base/dstdevch","base.strided.dstdevpn":"@stdlib/stats/base/dstdevpn","base.strided.dstdevtk":"@stdlib/stats/base/dstdevtk","base.strided.dstdevwd":"@stdlib/stats/base/dstdevwd","base.strided.dstdevyc":"@stdlib/stats/base/dstdevyc","base.strided.dsum":"@stdlib/blas/ext/base/dsum","base.strided.dsumkbn":"@stdlib/blas/ext/base/dsumkbn","base.strided.dsumkbn2":"@stdlib/blas/ext/base/dsumkbn2","base.strided.dsumors":"@stdlib/blas/ext/base/dsumors","base.strided.dsumpw":"@stdlib/blas/ext/base/dsumpw","base.strided.dsvariance":"@stdlib/stats/base/dsvariance","base.strided.dsvariancepn":"@stdlib/stats/base/dsvariancepn","base.strided.dswap":"@stdlib/blas/base/dswap","base.strided.dtrunc":"@stdlib/math/strided/special/dtrunc","base.strided.dtypeEnum2Str":"@stdlib/strided/base/dtype-enum2str","base.strided.dtypeResolveEnum":"@stdlib/strided/base/dtype-resolve-enum","base.strided.dtypeResolveStr":"@stdlib/strided/base/dtype-resolve-str","base.strided.dtypeStr2Enum":"@stdlib/strided/base/dtype-str2enum","base.strided.dvariance":"@stdlib/stats/base/dvariance","base.strided.dvariancech":"@stdlib/stats/base/dvariancech","base.strided.dvariancepn":"@stdlib/stats/base/dvariancepn","base.strided.dvariancetk":"@stdlib/stats/base/dvariancetk","base.strided.dvariancewd":"@stdlib/stats/base/dvariancewd","base.strided.dvarianceyc":"@stdlib/stats/base/dvarianceyc","base.strided.dvarm":"@stdlib/stats/base/dvarm","base.strided.dvarmpn":"@stdlib/stats/base/dvarmpn","base.strided.dvarmtk":"@stdlib/stats/base/dvarmtk","base.strided.functionObject":"@stdlib/strided/base/function-object","base.strided.gapx":"@stdlib/blas/ext/base/gapx","base.strided.gapxsum":"@stdlib/blas/ext/base/gapxsum","base.strided.gapxsumkbn":"@stdlib/blas/ext/base/gapxsumkbn","base.strided.gapxsumkbn2":"@stdlib/blas/ext/base/gapxsumkbn2","base.strided.gapxsumors":"@stdlib/blas/ext/base/gapxsumors","base.strided.gapxsumpw":"@stdlib/blas/ext/base/gapxsumpw","base.strided.gasum":"@stdlib/blas/base/gasum","base.strided.gasumpw":"@stdlib/blas/ext/base/gasumpw","base.strided.gaxpy":"@stdlib/blas/base/gaxpy","base.strided.gcopy":"@stdlib/blas/base/gcopy","base.strided.gcusum":"@stdlib/blas/ext/base/gcusum","base.strided.gcusumkbn":"@stdlib/blas/ext/base/gcusumkbn","base.strided.gcusumkbn2":"@stdlib/blas/ext/base/gcusumkbn2","base.strided.gcusumors":"@stdlib/blas/ext/base/gcusumors","base.strided.gcusumpw":"@stdlib/blas/ext/base/gcusumpw","base.strided.gdot":"@stdlib/blas/base/gdot","base.strided.gfill":"@stdlib/blas/ext/base/gfill","base.strided.gfillBy":"@stdlib/blas/ext/base/gfill-by","base.strided.gnannsumkbn":"@stdlib/blas/ext/base/gnannsumkbn","base.strided.gnansum":"@stdlib/blas/ext/base/gnansum","base.strided.gnansumkbn":"@stdlib/blas/ext/base/gnansumkbn","base.strided.gnansumkbn2":"@stdlib/blas/ext/base/gnansumkbn2","base.strided.gnansumors":"@stdlib/blas/ext/base/gnansumors","base.strided.gnansumpw":"@stdlib/blas/ext/base/gnansumpw","base.strided.gnrm2":"@stdlib/blas/base/gnrm2","base.strided.grev":"@stdlib/blas/ext/base/grev","base.strided.gscal":"@stdlib/blas/base/gscal","base.strided.gsort2hp":"@stdlib/blas/ext/base/gsort2hp","base.strided.gsort2ins":"@stdlib/blas/ext/base/gsort2ins","base.strided.gsort2sh":"@stdlib/blas/ext/base/gsort2sh","base.strided.gsorthp":"@stdlib/blas/ext/base/gsorthp","base.strided.gsortins":"@stdlib/blas/ext/base/gsortins","base.strided.gsortsh":"@stdlib/blas/ext/base/gsortsh","base.strided.gsum":"@stdlib/blas/ext/base/gsum","base.strided.gsumkbn":"@stdlib/blas/ext/base/gsumkbn","base.strided.gsumkbn2":"@stdlib/blas/ext/base/gsumkbn2","base.strided.gsumors":"@stdlib/blas/ext/base/gsumors","base.strided.gsumpw":"@stdlib/blas/ext/base/gsumpw","base.strided.gswap":"@stdlib/blas/base/gswap","base.strided.mapBy":"@stdlib/strided/base/map-by","base.strided.mapBy2":"@stdlib/strided/base/map-by2","base.strided.max":"@stdlib/stats/base/max","base.strided.maxabs":"@stdlib/stats/base/maxabs","base.strided.maxBy":"@stdlib/stats/base/max-by","base.strided.maxsorted":"@stdlib/stats/base/maxsorted","base.strided.maxViewBufferIndex":"@stdlib/strided/base/max-view-buffer-index","base.strided.mean":"@stdlib/stats/base/mean","base.strided.meankbn":"@stdlib/stats/base/meankbn","base.strided.meankbn2":"@stdlib/stats/base/meankbn2","base.strided.meanors":"@stdlib/stats/base/meanors","base.strided.meanpn":"@stdlib/stats/base/meanpn","base.strided.meanpw":"@stdlib/stats/base/meanpw","base.strided.meanwd":"@stdlib/stats/base/meanwd","base.strided.mediansorted":"@stdlib/stats/base/mediansorted","base.strided.metaDataProps":"@stdlib/strided/base/meta-data-props","base.strided.min":"@stdlib/stats/base/min","base.strided.minabs":"@stdlib/stats/base/minabs","base.strided.minBy":"@stdlib/stats/base/min-by","base.strided.minsorted":"@stdlib/stats/base/minsorted","base.strided.minViewBufferIndex":"@stdlib/strided/base/min-view-buffer-index","base.strided.mskmax":"@stdlib/stats/base/mskmax","base.strided.mskmin":"@stdlib/stats/base/mskmin","base.strided.mskrange":"@stdlib/stats/base/mskrange","base.strided.mskunary":"@stdlib/strided/base/mskunary","base.strided.mskunaryDtypeSignatures":"@stdlib/strided/base/mskunary-dtype-signatures","base.strided.mskunarySignatureCallbacks":"@stdlib/strided/base/mskunary-signature-callbacks","base.strided.nanmax":"@stdlib/stats/base/nanmax","base.strided.nanmaxabs":"@stdlib/stats/base/nanmaxabs","base.strided.nanmaxBy":"@stdlib/stats/base/nanmax-by","base.strided.nanmean":"@stdlib/stats/base/nanmean","base.strided.nanmeanors":"@stdlib/stats/base/nanmeanors","base.strided.nanmeanpn":"@stdlib/stats/base/nanmeanpn","base.strided.nanmeanwd":"@stdlib/stats/base/nanmeanwd","base.strided.nanmin":"@stdlib/stats/base/nanmin","base.strided.nanminabs":"@stdlib/stats/base/nanminabs","base.strided.nanminBy":"@stdlib/stats/base/nanmin-by","base.strided.nanmskmax":"@stdlib/stats/base/nanmskmax","base.strided.nanmskmin":"@stdlib/stats/base/nanmskmin","base.strided.nanmskrange":"@stdlib/stats/base/nanmskrange","base.strided.nanrange":"@stdlib/stats/base/nanrange","base.strided.nanrangeBy":"@stdlib/stats/base/nanrange-by","base.strided.nanstdev":"@stdlib/stats/base/nanstdev","base.strided.nanstdevch":"@stdlib/stats/base/nanstdevch","base.strided.nanstdevpn":"@stdlib/stats/base/nanstdevpn","base.strided.nanstdevtk":"@stdlib/stats/base/nanstdevtk","base.strided.nanstdevwd":"@stdlib/stats/base/nanstdevwd","base.strided.nanstdevyc":"@stdlib/stats/base/nanstdevyc","base.strided.nanvariance":"@stdlib/stats/base/nanvariance","base.strided.nanvariancech":"@stdlib/stats/base/nanvariancech","base.strided.nanvariancepn":"@stdlib/stats/base/nanvariancepn","base.strided.nanvariancetk":"@stdlib/stats/base/nanvariancetk","base.strided.nanvariancewd":"@stdlib/stats/base/nanvariancewd","base.strided.nanvarianceyc":"@stdlib/stats/base/nanvarianceyc","base.strided.nullary":"@stdlib/strided/base/nullary","base.strided.offsetView":"@stdlib/strided/base/offset-view","base.strided.quaternary":"@stdlib/strided/base/quaternary","base.strided.quinary":"@stdlib/strided/base/quinary","base.strided.range":"@stdlib/stats/base/range","base.strided.rangeBy":"@stdlib/stats/base/range-by","base.strided.reinterpretComplex":"@stdlib/strided/base/reinterpret-complex","base.strided.reinterpretComplex64":"@stdlib/strided/base/reinterpret-complex64","base.strided.reinterpretComplex128":"@stdlib/strided/base/reinterpret-complex128","base.strided.sabs":"@stdlib/math/strided/special/sabs","base.strided.sabs2":"@stdlib/math/strided/special/sabs2","base.strided.sapx":"@stdlib/blas/ext/base/sapx","base.strided.sapxsum":"@stdlib/blas/ext/base/sapxsum","base.strided.sapxsumkbn":"@stdlib/blas/ext/base/sapxsumkbn","base.strided.sapxsumkbn2":"@stdlib/blas/ext/base/sapxsumkbn2","base.strided.sapxsumors":"@stdlib/blas/ext/base/sapxsumors","base.strided.sapxsumpw":"@stdlib/blas/ext/base/sapxsumpw","base.strided.sasum":"@stdlib/blas/base/sasum","base.strided.sasumpw":"@stdlib/blas/ext/base/sasumpw","base.strided.saxpy":"@stdlib/blas/base/saxpy","base.strided.scbrt":"@stdlib/math/strided/special/scbrt","base.strided.sceil":"@stdlib/math/strided/special/sceil","base.strided.scopy":"@stdlib/blas/base/scopy","base.strided.scumax":"@stdlib/stats/base/scumax","base.strided.scumaxabs":"@stdlib/stats/base/scumaxabs","base.strided.scumin":"@stdlib/stats/base/scumin","base.strided.scuminabs":"@stdlib/stats/base/scuminabs","base.strided.scusum":"@stdlib/blas/ext/base/scusum","base.strided.scusumkbn":"@stdlib/blas/ext/base/scusumkbn","base.strided.scusumkbn2":"@stdlib/blas/ext/base/scusumkbn2","base.strided.scusumors":"@stdlib/blas/ext/base/scusumors","base.strided.scusumpw":"@stdlib/blas/ext/base/scusumpw","base.strided.sdeg2rad":"@stdlib/math/strided/special/sdeg2rad","base.strided.sdot":"@stdlib/blas/base/sdot","base.strided.sdsapxsum":"@stdlib/blas/ext/base/sdsapxsum","base.strided.sdsapxsumpw":"@stdlib/blas/ext/base/sdsapxsumpw","base.strided.sdsdot":"@stdlib/blas/base/sdsdot","base.strided.sdsmean":"@stdlib/stats/base/sdsmean","base.strided.sdsmeanors":"@stdlib/stats/base/sdsmeanors","base.strided.sdsnanmean":"@stdlib/stats/base/sdsnanmean","base.strided.sdsnanmeanors":"@stdlib/stats/base/sdsnanmeanors","base.strided.sdsnansum":"@stdlib/blas/ext/base/sdsnansum","base.strided.sdsnansumpw":"@stdlib/blas/ext/base/sdsnansumpw","base.strided.sdssum":"@stdlib/blas/ext/base/sdssum","base.strided.sdssumpw":"@stdlib/blas/ext/base/sdssumpw","base.strided.sfill":"@stdlib/blas/ext/base/sfill","base.strided.sfloor":"@stdlib/math/strided/special/sfloor","base.strided.sinv":"@stdlib/math/strided/special/sinv","base.strided.smap":"@stdlib/strided/base/smap","base.strided.smap2":"@stdlib/strided/base/smap2","base.strided.smax":"@stdlib/stats/base/smax","base.strided.smaxabs":"@stdlib/stats/base/smaxabs","base.strided.smaxabssorted":"@stdlib/stats/base/smaxabssorted","base.strided.smaxsorted":"@stdlib/stats/base/smaxsorted","base.strided.smean":"@stdlib/stats/base/smean","base.strided.smeankbn":"@stdlib/stats/base/smeankbn","base.strided.smeankbn2":"@stdlib/stats/base/smeankbn2","base.strided.smeanli":"@stdlib/stats/base/smeanli","base.strided.smeanlipw":"@stdlib/stats/base/smeanlipw","base.strided.smeanors":"@stdlib/stats/base/smeanors","base.strided.smeanpn":"@stdlib/stats/base/smeanpn","base.strided.smeanpw":"@stdlib/stats/base/smeanpw","base.strided.smeanwd":"@stdlib/stats/base/smeanwd","base.strided.smediansorted":"@stdlib/stats/base/smediansorted","base.strided.smidrange":"@stdlib/stats/base/smidrange","base.strided.smin":"@stdlib/stats/base/smin","base.strided.sminabs":"@stdlib/stats/base/sminabs","base.strided.sminsorted":"@stdlib/stats/base/sminsorted","base.strided.smskabs":"@stdlib/math/strided/special/smskabs","base.strided.smskabs2":"@stdlib/math/strided/special/smskabs2","base.strided.smskcbrt":"@stdlib/math/strided/special/smskcbrt","base.strided.smskceil":"@stdlib/math/strided/special/smskceil","base.strided.smskdeg2rad":"@stdlib/math/strided/special/smskdeg2rad","base.strided.smskfloor":"@stdlib/math/strided/special/smskfloor","base.strided.smskinv":"@stdlib/math/strided/special/smskinv","base.strided.smskmap":"@stdlib/strided/base/smskmap","base.strided.smskmap2":"@stdlib/strided/base/smskmap2","base.strided.smskmax":"@stdlib/stats/base/smskmax","base.strided.smskmin":"@stdlib/stats/base/smskmin","base.strided.smskramp":"@stdlib/math/strided/special/smskramp","base.strided.smskrange":"@stdlib/stats/base/smskrange","base.strided.smskrsqrt":"@stdlib/math/strided/special/smskrsqrt","base.strided.smsksqrt":"@stdlib/math/strided/special/smsksqrt","base.strided.smsktrunc":"@stdlib/math/strided/special/smsktrunc","base.strided.snanmax":"@stdlib/stats/base/snanmax","base.strided.snanmaxabs":"@stdlib/stats/base/snanmaxabs","base.strided.snanmean":"@stdlib/stats/base/snanmean","base.strided.snanmeanors":"@stdlib/stats/base/snanmeanors","base.strided.snanmeanpn":"@stdlib/stats/base/snanmeanpn","base.strided.snanmeanwd":"@stdlib/stats/base/snanmeanwd","base.strided.snanmin":"@stdlib/stats/base/snanmin","base.strided.snanminabs":"@stdlib/stats/base/snanminabs","base.strided.snanmskmax":"@stdlib/stats/base/snanmskmax","base.strided.snanmskmin":"@stdlib/stats/base/snanmskmin","base.strided.snanmskrange":"@stdlib/stats/base/snanmskrange","base.strided.snanrange":"@stdlib/stats/base/snanrange","base.strided.snanstdev":"@stdlib/stats/base/snanstdev","base.strided.snanstdevch":"@stdlib/stats/base/snanstdevch","base.strided.snanstdevpn":"@stdlib/stats/base/snanstdevpn","base.strided.snanstdevtk":"@stdlib/stats/base/snanstdevtk","base.strided.snanstdevwd":"@stdlib/stats/base/snanstdevwd","base.strided.snanstdevyc":"@stdlib/stats/base/snanstdevyc","base.strided.snansum":"@stdlib/blas/ext/base/snansum","base.strided.snansumkbn":"@stdlib/blas/ext/base/snansumkbn","base.strided.snansumkbn2":"@stdlib/blas/ext/base/snansumkbn2","base.strided.snansumors":"@stdlib/blas/ext/base/snansumors","base.strided.snansumpw":"@stdlib/blas/ext/base/snansumpw","base.strided.snanvariance":"@stdlib/stats/base/snanvariance","base.strided.snanvariancech":"@stdlib/stats/base/snanvariancech","base.strided.snanvariancepn":"@stdlib/stats/base/snanvariancepn","base.strided.snanvariancetk":"@stdlib/stats/base/snanvariancetk","base.strided.snanvariancewd":"@stdlib/stats/base/snanvariancewd","base.strided.snanvarianceyc":"@stdlib/stats/base/snanvarianceyc","base.strided.snrm2":"@stdlib/blas/base/snrm2","base.strided.sramp":"@stdlib/math/strided/special/sramp","base.strided.srange":"@stdlib/stats/base/srange","base.strided.srev":"@stdlib/blas/ext/base/srev","base.strided.srsqrt":"@stdlib/math/strided/special/srsqrt","base.strided.sscal":"@stdlib/blas/base/sscal","base.strided.ssort2hp":"@stdlib/blas/ext/base/ssort2hp","base.strided.ssort2ins":"@stdlib/blas/ext/base/ssort2ins","base.strided.ssort2sh":"@stdlib/blas/ext/base/ssort2sh","base.strided.ssorthp":"@stdlib/blas/ext/base/ssorthp","base.strided.ssortins":"@stdlib/blas/ext/base/ssortins","base.strided.ssortsh":"@stdlib/blas/ext/base/ssortsh","base.strided.ssqrt":"@stdlib/math/strided/special/ssqrt","base.strided.sstdev":"@stdlib/stats/base/sstdev","base.strided.sstdevch":"@stdlib/stats/base/sstdevch","base.strided.sstdevpn":"@stdlib/stats/base/sstdevpn","base.strided.sstdevtk":"@stdlib/stats/base/sstdevtk","base.strided.sstdevwd":"@stdlib/stats/base/sstdevwd","base.strided.sstdevyc":"@stdlib/stats/base/sstdevyc","base.strided.ssum":"@stdlib/blas/ext/base/ssum","base.strided.ssumkbn":"@stdlib/blas/ext/base/ssumkbn","base.strided.ssumkbn2":"@stdlib/blas/ext/base/ssumkbn2","base.strided.ssumors":"@stdlib/blas/ext/base/ssumors","base.strided.ssumpw":"@stdlib/blas/ext/base/ssumpw","base.strided.sswap":"@stdlib/blas/base/sswap","base.strided.stdev":"@stdlib/stats/base/stdev","base.strided.stdevch":"@stdlib/stats/base/stdevch","base.strided.stdevpn":"@stdlib/stats/base/stdevpn","base.strided.stdevtk":"@stdlib/stats/base/stdevtk","base.strided.stdevwd":"@stdlib/stats/base/stdevwd","base.strided.stdevyc":"@stdlib/stats/base/stdevyc","base.strided.strunc":"@stdlib/math/strided/special/strunc","base.strided.svariance":"@stdlib/stats/base/svariance","base.strided.svariancech":"@stdlib/stats/base/svariancech","base.strided.svariancepn":"@stdlib/stats/base/svariancepn","base.strided.svariancetk":"@stdlib/stats/base/svariancetk","base.strided.svariancewd":"@stdlib/stats/base/svariancewd","base.strided.svarianceyc":"@stdlib/stats/base/svarianceyc","base.strided.ternary":"@stdlib/strided/base/ternary","base.strided.unary":"@stdlib/strided/base/unary","base.strided.unaryBy":"@stdlib/strided/base/unary-by","base.strided.unaryDtypeSignatures":"@stdlib/strided/base/unary-dtype-signatures","base.strided.unarySignatureCallbacks":"@stdlib/strided/base/unary-signature-callbacks","base.strided.variance":"@stdlib/stats/base/variance","base.strided.variancech":"@stdlib/stats/base/variancech","base.strided.variancepn":"@stdlib/stats/base/variancepn","base.strided.variancetk":"@stdlib/stats/base/variancetk","base.strided.variancewd":"@stdlib/stats/base/variancewd","base.strided.varianceyc":"@stdlib/stats/base/varianceyc","base.strided.zmap":"@stdlib/strided/base/zmap","base.str2multislice":"@stdlib/slice/base/str2multislice","base.str2slice":"@stdlib/slice/base/str2slice","base.sub":"@stdlib/number/float64/base/sub","base.subf":"@stdlib/math/base/ops/subf","base.sumSeries":"@stdlib/math/base/tools/sum-series","base.tan":"@stdlib/math/base/special/tan","base.tand":"@stdlib/math/base/special/tand","base.tanh":"@stdlib/math/base/special/tanh","base.toBinaryString":"@stdlib/number/float64/base/to-binary-string","base.toBinaryStringf":"@stdlib/number/float32/base/to-binary-string","base.toBinaryStringUint8":"@stdlib/number/uint8/base/to-binary-string","base.toBinaryStringUint16":"@stdlib/number/uint16/base/to-binary-string","base.toBinaryStringUint32":"@stdlib/number/uint32/base/to-binary-string","base.toWordf":"@stdlib/number/float32/base/to-word","base.toWords":"@stdlib/number/float64/base/to-words","base.transpose":"@stdlib/ndarray/base/transpose","base.tribonacci":"@stdlib/math/base/special/tribonacci","base.trigamma":"@stdlib/math/base/special/trigamma","base.trim":"@stdlib/string/base/trim","base.trunc":"@stdlib/math/base/special/trunc","base.trunc2":"@stdlib/math/base/special/trunc2","base.trunc10":"@stdlib/math/base/special/trunc10","base.truncateMiddle":"@stdlib/string/base/truncate-middle","base.truncb":"@stdlib/math/base/special/truncb","base.truncf":"@stdlib/math/base/special/truncf","base.truncn":"@stdlib/math/base/special/truncn","base.truncsd":"@stdlib/math/base/special/truncsd","base.uint32ToInt32":"@stdlib/number/uint32/base/to-int32","base.umul":"@stdlib/number/uint32/base/mul","base.umuldw":"@stdlib/math/base/ops/umuldw","base.uncapitalize":"@stdlib/string/base/uncapitalize","base.uppercase":"@stdlib/string/base/uppercase","base.vercos":"@stdlib/math/base/special/vercos","base.versin":"@stdlib/math/base/special/versin","base.wrap":"@stdlib/math/base/special/wrap","base.xlog1py":"@stdlib/math/base/special/xlog1py","base.xlogy":"@stdlib/math/base/special/xlogy","base.zeta":"@stdlib/math/base/special/riemann-zeta","bench":"@stdlib/bench","BERNDT_CPS_WAGES_1985":"@stdlib/datasets/berndt-cps-wages-1985","bifurcate":"@stdlib/utils/bifurcate","bifurcateBy":"@stdlib/utils/bifurcate-by","bifurcateByAsync":"@stdlib/utils/async/bifurcate-by","bifurcateIn":"@stdlib/utils/bifurcate-in","bifurcateOwn":"@stdlib/utils/bifurcate-own","BigInt":"@stdlib/bigint/ctor","binomialTest":"@stdlib/stats/binomial-test","Boolean":"@stdlib/boolean/ctor","BooleanArray":"@stdlib/array/bool","broadcastArray":"@stdlib/ndarray/broadcast-array","broadcastArrays":"@stdlib/ndarray/broadcast-arrays","Buffer":"@stdlib/buffer/ctor","buffer2json":"@stdlib/buffer/to-json","BYTE_ORDER":"@stdlib/os/byte-order","camelcase":"@stdlib/string/camelcase","capitalize":"@stdlib/string/capitalize","capitalizeKeys":"@stdlib/utils/capitalize-keys","CATALAN":"@stdlib/constants/float64/catalan","CBRT_EPS":"@stdlib/constants/float64/cbrt-eps","CDC_NCHS_US_BIRTHS_1969_1988":"@stdlib/datasets/cdc-nchs-us-births-1969-1988","CDC_NCHS_US_BIRTHS_1994_2003":"@stdlib/datasets/cdc-nchs-us-births-1994-2003","CDC_NCHS_US_INFANT_MORTALITY_BW_1915_2013":"@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013","chdir":"@stdlib/process/chdir","chi2gof":"@stdlib/stats/chi2gof","chi2test":"@stdlib/stats/chi2test","circarray2iterator":"@stdlib/array/to-circular-iterator","circularArrayStream":"@stdlib/streams/node/from-circular-array","CircularBuffer":"@stdlib/dstructs/circular-buffer","close":"@stdlib/fs/close","CMUDICT":"@stdlib/datasets/cmudict","codePointAt":"@stdlib/string/code-point-at","commonKeys":"@stdlib/utils/common-keys","commonKeysIn":"@stdlib/utils/common-keys-in","complex":"@stdlib/complex/cmplx","Complex64":"@stdlib/complex/float32/ctor","COMPLEX64_NAN":"@stdlib/constants/complex64/nan","COMPLEX64_NUM_BYTES":"@stdlib/constants/complex64/num-bytes","COMPLEX64_ZERO":"@stdlib/constants/complex64/zero","Complex64Array":"@stdlib/array/complex64","Complex128":"@stdlib/complex/float64/ctor","COMPLEX128_NAN":"@stdlib/constants/complex128/nan","COMPLEX128_NUM_BYTES":"@stdlib/constants/complex128/num-bytes","COMPLEX128_ZERO":"@stdlib/constants/complex128/zero","Complex128Array":"@stdlib/array/complex128","complexarray":"@stdlib/array/typed-complex","complexarrayCtors":"@stdlib/array/typed-complex-ctors","complexarrayDataTypes":"@stdlib/array/typed-complex-dtypes","complexCtors":"@stdlib/complex/ctors","complexDataType":"@stdlib/complex/dtype","complexDataTypes":"@stdlib/complex/dtypes","complexPromotionRules":"@stdlib/complex/promotion-rules","compose":"@stdlib/utils/compose","composeAsync":"@stdlib/utils/async/compose","configdir":"@stdlib/os/configdir","conj":"@stdlib/complex/float64/conj","conjf":"@stdlib/complex/float32/conj","constantcase":"@stdlib/string/constantcase","constantFunction":"@stdlib/utils/constant-function","constantStream":"@stdlib/streams/node/from-constant","constructorName":"@stdlib/utils/constructor-name","contains":"@stdlib/assert/contains","convertArray":"@stdlib/array/convert","convertArraySame":"@stdlib/array/convert-same","convertPath":"@stdlib/utils/convert-path","copy":"@stdlib/utils/copy","copyBuffer":"@stdlib/buffer/from-buffer","countBy":"@stdlib/utils/count-by","countByAsync":"@stdlib/utils/async/count-by","currentYear":"@stdlib/time/current-year","curry":"@stdlib/utils/curry","curryRight":"@stdlib/utils/curry-right","cwd":"@stdlib/process/cwd","DALE_CHALL_NEW":"@stdlib/datasets/dale-chall-new","datasets":"@stdlib/datasets","DataView":"@stdlib/array/dataview","datespace":"@stdlib/array/datespace","dayOfQuarter":"@stdlib/time/day-of-quarter","dayOfYear":"@stdlib/time/day-of-year","daysInMonth":"@stdlib/time/days-in-month","daysInYear":"@stdlib/time/days-in-year","ddot":"@stdlib/blas/ddot","debugSinkStream":"@stdlib/streams/node/debug-sink","debugStream":"@stdlib/streams/node/debug","decorateAfter":"@stdlib/utils/decorate-after","deepEqual":"@stdlib/assert/deep-equal","deepGet":"@stdlib/utils/deep-get","deepHasOwnProp":"@stdlib/assert/deep-has-own-property","deepHasProp":"@stdlib/assert/deep-has-property","deepPluck":"@stdlib/utils/deep-pluck","deepSet":"@stdlib/utils/deep-set","defineMemoizedProperty":"@stdlib/utils/define-memoized-property","defineProperties":"@stdlib/utils/define-properties","defineProperty":"@stdlib/utils/define-property","dirname":"@stdlib/utils/dirname","dotcase":"@stdlib/string/dotcase","DoublyLinkedList":"@stdlib/dstructs/doubly-linked-list","doUntil":"@stdlib/utils/do-until","doUntilAsync":"@stdlib/utils/async/do-until","doUntilEach":"@stdlib/utils/do-until-each","doUntilEachRight":"@stdlib/utils/do-until-each-right","doWhile":"@stdlib/utils/do-while","doWhileAsync":"@stdlib/utils/async/do-while","doWhileEach":"@stdlib/utils/do-while-each","doWhileEachRight":"@stdlib/utils/do-while-each-right","dswap":"@stdlib/blas/dswap","E":"@stdlib/constants/float64/e","EMOJI":"@stdlib/datasets/emoji","EMOJI_CODE_PICTO":"@stdlib/datasets/emoji-code-picto","EMOJI_PICTO_CODE":"@stdlib/datasets/emoji-picto-code","emptyStream":"@stdlib/streams/node/empty","endsWith":"@stdlib/string/ends-with","enumerableProperties":"@stdlib/utils/enumerable-properties","enumerablePropertiesIn":"@stdlib/utils/enumerable-properties-in","enumerablePropertySymbols":"@stdlib/utils/enumerable-property-symbols","enumerablePropertySymbolsIn":"@stdlib/utils/enumerable-property-symbols-in","ENV":"@stdlib/process/env","EPS":"@stdlib/constants/float64/eps","error2json":"@stdlib/error/to-json","EULERGAMMA":"@stdlib/constants/float64/eulergamma","every":"@stdlib/utils/every","everyBy":"@stdlib/utils/every-by","everyByAsync":"@stdlib/utils/async/every-by","everyByRight":"@stdlib/utils/every-by-right","everyByRightAsync":"@stdlib/utils/async/every-by-right","everyInBy":"@stdlib/utils/every-in-by","everyOwnBy":"@stdlib/utils/every-own-by","evil":"@stdlib/utils/eval","EXEC_PATH":"@stdlib/process/exec-path","exists":"@stdlib/fs/exists","expandAcronyms":"@stdlib/nlp/expand-acronyms","expandContractions":"@stdlib/nlp/expand-contractions","extname":"@stdlib/utils/extname","FancyArray":"@stdlib/ndarray/fancy","fastmath.abs":"@stdlib/math/base/special/fast/abs","fastmath.acosh":"@stdlib/math/base/special/fast/acosh","fastmath.ampbm":"@stdlib/math/base/special/fast/alpha-max-plus-beta-min","fastmath.asinh":"@stdlib/math/base/special/fast/asinh","fastmath.atanh":"@stdlib/math/base/special/fast/atanh","fastmath.hypot":"@stdlib/math/base/special/fast/hypot","fastmath.log2Uint32":"@stdlib/math/base/special/fast/uint32-log2","fastmath.max":"@stdlib/math/base/special/fast/max","fastmath.min":"@stdlib/math/base/special/fast/min","fastmath.powint":"@stdlib/math/base/special/fast/pow-int","fastmath.sqrtUint32":"@stdlib/math/base/special/fast/uint32-sqrt","FEMALE_FIRST_NAMES_EN":"@stdlib/datasets/female-first-names-en","FIFO":"@stdlib/dstructs/fifo","filledarray":"@stdlib/array/filled","filledarrayBy":"@stdlib/array/filled-by","filterArguments":"@stdlib/utils/filter-arguments","find":"@stdlib/utils/find","firstChar":"@stdlib/string/first","FIVETHIRTYEIGHT_FFQ":"@stdlib/datasets/fivethirtyeight-ffq","flattenArray":"@stdlib/utils/flatten-array","flattenObject":"@stdlib/utils/flatten-object","flignerTest":"@stdlib/stats/fligner-test","FLOAT_WORD_ORDER":"@stdlib/os/float-word-order","FLOAT16_CBRT_EPS":"@stdlib/constants/float16/cbrt-eps","FLOAT16_EPS":"@stdlib/constants/float16/eps","FLOAT16_EXPONENT_BIAS":"@stdlib/constants/float16/exponent-bias","FLOAT16_MAX":"@stdlib/constants/float16/max","FLOAT16_MAX_SAFE_INTEGER":"@stdlib/constants/float16/max-safe-integer","FLOAT16_MIN_SAFE_INTEGER":"@stdlib/constants/float16/min-safe-integer","FLOAT16_NINF":"@stdlib/constants/float16/ninf","FLOAT16_NUM_BYTES":"@stdlib/constants/float16/num-bytes","FLOAT16_PINF":"@stdlib/constants/float16/pinf","FLOAT16_PRECISION":"@stdlib/constants/float16/precision","FLOAT16_SMALLEST_NORMAL":"@stdlib/constants/float16/smallest-normal","FLOAT16_SMALLEST_SUBNORMAL":"@stdlib/constants/float16/smallest-subnormal","FLOAT16_SQRT_EPS":"@stdlib/constants/float16/sqrt-eps","FLOAT32_ABS_MASK":"@stdlib/constants/float32/abs-mask","FLOAT32_CBRT_EPS":"@stdlib/constants/float32/cbrt-eps","FLOAT32_E":"@stdlib/constants/float32/e","FLOAT32_EPS":"@stdlib/constants/float32/eps","FLOAT32_EXPONENT_BIAS":"@stdlib/constants/float32/exponent-bias","FLOAT32_EXPONENT_MASK":"@stdlib/constants/float32/exponent-mask","FLOAT32_FOURTH_PI":"@stdlib/constants/float32/fourth-pi","FLOAT32_HALF_LN_TWO":"@stdlib/constants/float32/half-ln-two","FLOAT32_HALF_PI":"@stdlib/constants/float32/half-pi","FLOAT32_LN_HALF":"@stdlib/constants/float32/ln-half","FLOAT32_LN_PI":"@stdlib/constants/float32/ln-pi","FLOAT32_LN_TEN":"@stdlib/constants/float32/ln-ten","FLOAT32_LN_TWO":"@stdlib/constants/float32/ln-two","FLOAT32_MAX":"@stdlib/constants/float32/max","FLOAT32_MAX_BASE2_EXPONENT":"@stdlib/constants/float32/max-base2-exponent","FLOAT32_MAX_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/max-base2-exponent-subnormal","FLOAT32_MAX_BASE10_EXPONENT":"@stdlib/constants/float32/max-base10-exponent","FLOAT32_MAX_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/max-base10-exponent-subnormal","FLOAT32_MAX_SAFE_FIBONACCI":"@stdlib/constants/float32/max-safe-fibonacci","FLOAT32_MAX_SAFE_INTEGER":"@stdlib/constants/float32/max-safe-integer","FLOAT32_MAX_SAFE_NTH_FACTORIAL":"@stdlib/constants/float32/max-safe-nth-factorial","FLOAT32_MAX_SAFE_NTH_FIBONACCI":"@stdlib/constants/float32/max-safe-nth-fibonacci","FLOAT32_MAX_SAFE_NTH_LUCAS":"@stdlib/constants/float32/max-safe-nth-lucas","FLOAT32_MIN_BASE2_EXPONENT":"@stdlib/constants/float32/min-base2-exponent","FLOAT32_MIN_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/min-base2-exponent-subnormal","FLOAT32_MIN_BASE10_EXPONENT":"@stdlib/constants/float32/min-base10-exponent","FLOAT32_MIN_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float32/min-base10-exponent-subnormal","FLOAT32_MIN_SAFE_INTEGER":"@stdlib/constants/float32/min-safe-integer","FLOAT32_NAN":"@stdlib/constants/float32/nan","FLOAT32_NINF":"@stdlib/constants/float32/ninf","FLOAT32_NUM_BYTES":"@stdlib/constants/float32/num-bytes","FLOAT32_PHI":"@stdlib/constants/float32/phi","FLOAT32_PI":"@stdlib/constants/float32/pi","FLOAT32_PINF":"@stdlib/constants/float32/pinf","FLOAT32_PRECISION":"@stdlib/constants/float32/precision","FLOAT32_SIGN_MASK":"@stdlib/constants/float32/sign-mask","FLOAT32_SIGNIFICAND_MASK":"@stdlib/constants/float32/significand-mask","FLOAT32_SMALLEST_NORMAL":"@stdlib/constants/float32/smallest-normal","FLOAT32_SMALLEST_SUBNORMAL":"@stdlib/constants/float32/smallest-subnormal","FLOAT32_SQRT_EPS":"@stdlib/constants/float32/sqrt-eps","FLOAT32_SQRT_HALF":"@stdlib/constants/float32/sqrt-half","FLOAT32_SQRT_HALF_PI":"@stdlib/constants/float32/sqrt-half-pi","FLOAT32_SQRT_PHI":"@stdlib/constants/float32/sqrt-phi","FLOAT32_SQRT_PI":"@stdlib/constants/float32/sqrt-pi","FLOAT32_SQRT_THREE":"@stdlib/constants/float32/sqrt-three","FLOAT32_SQRT_TWO":"@stdlib/constants/float32/sqrt-two","FLOAT32_SQRT_TWO_PI":"@stdlib/constants/float32/sqrt-two-pi","FLOAT32_TWO_PI":"@stdlib/constants/float32/two-pi","Float32Array":"@stdlib/array/float32","Float32ArrayFE":"@stdlib/array/fixed-endian-float32","Float32ArrayLE":"@stdlib/array/little-endian-float32","FLOAT64_EXPONENT_BIAS":"@stdlib/constants/float64/exponent-bias","FLOAT64_HIGH_WORD_ABS_MASK":"@stdlib/constants/float64/high-word-abs-mask","FLOAT64_HIGH_WORD_EXPONENT_MASK":"@stdlib/constants/float64/high-word-exponent-mask","FLOAT64_HIGH_WORD_SIGN_MASK":"@stdlib/constants/float64/high-word-sign-mask","FLOAT64_HIGH_WORD_SIGNIFICAND_MASK":"@stdlib/constants/float64/high-word-significand-mask","FLOAT64_MAX":"@stdlib/constants/float64/max","FLOAT64_MAX_BASE2_EXPONENT":"@stdlib/constants/float64/max-base2-exponent","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/max-base2-exponent-subnormal","FLOAT64_MAX_BASE10_EXPONENT":"@stdlib/constants/float64/max-base10-exponent","FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/max-base10-exponent-subnormal","FLOAT64_MAX_LN":"@stdlib/constants/float64/max-ln","FLOAT64_MAX_SAFE_FIBONACCI":"@stdlib/constants/float64/max-safe-fibonacci","FLOAT64_MAX_SAFE_INTEGER":"@stdlib/constants/float64/max-safe-integer","FLOAT64_MAX_SAFE_LUCAS":"@stdlib/constants/float64/max-safe-lucas","FLOAT64_MAX_SAFE_NTH_FIBONACCI":"@stdlib/constants/float64/max-safe-nth-fibonacci","FLOAT64_MAX_SAFE_NTH_LUCAS":"@stdlib/constants/float64/max-safe-nth-lucas","FLOAT64_MIN_BASE2_EXPONENT":"@stdlib/constants/float64/min-base2-exponent","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/min-base2-exponent-subnormal","FLOAT64_MIN_BASE10_EXPONENT":"@stdlib/constants/float64/min-base10-exponent","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/float64/min-base10-exponent-subnormal","FLOAT64_MIN_LN":"@stdlib/constants/float64/min-ln","FLOAT64_MIN_SAFE_INTEGER":"@stdlib/constants/float64/min-safe-integer","FLOAT64_NUM_BYTES":"@stdlib/constants/float64/num-bytes","FLOAT64_PRECISION":"@stdlib/constants/float64/precision","FLOAT64_SMALLEST_NORMAL":"@stdlib/constants/float64/smallest-normal","FLOAT64_SMALLEST_SUBNORMAL":"@stdlib/constants/float64/smallest-subnormal","Float64Array":"@stdlib/array/float64","Float64ArrayFE":"@stdlib/array/fixed-endian-float64","Float64ArrayLE":"@stdlib/array/little-endian-float64","forEach":"@stdlib/utils/for-each","forEachAsync":"@stdlib/utils/async/for-each","forEachChar":"@stdlib/string/for-each","forEachRight":"@stdlib/utils/for-each-right","forEachRightAsync":"@stdlib/utils/async/for-each-right","forIn":"@stdlib/utils/for-in","format":"@stdlib/string/format","forOwn":"@stdlib/utils/for-own","FOURTH_PI":"@stdlib/constants/float64/fourth-pi","FOURTH_ROOT_EPS":"@stdlib/constants/float64/fourth-root-eps","FRB_SF_WAGE_RIGIDITY":"@stdlib/datasets/frb-sf-wage-rigidity","fromCodePoint":"@stdlib/string/from-code-point","Function":"@stdlib/function/ctor","function2string":"@stdlib/function/to-string","functionName":"@stdlib/utils/function-name","functionSequence":"@stdlib/utils/function-sequence","functionSequenceAsync":"@stdlib/utils/async/function-sequence","GAMMA_LANCZOS_G":"@stdlib/constants/float64/gamma-lanczos-g","gdot":"@stdlib/blas/gdot","getegid":"@stdlib/process/getegid","geteuid":"@stdlib/process/geteuid","getgid":"@stdlib/process/getgid","getGlobal":"@stdlib/utils/global","getPrototypeOf":"@stdlib/utils/get-prototype-of","getuid":"@stdlib/process/getuid","GLAISHER":"@stdlib/constants/float64/glaisher-kinkelin","graphemeClusters2iterator":"@stdlib/string/to-grapheme-cluster-iterator","graphemeClusters2iteratorRight":"@stdlib/string/to-grapheme-cluster-iterator-right","group":"@stdlib/utils/group","groupBy":"@stdlib/utils/group-by","groupByAsync":"@stdlib/utils/async/group-by","groupIn":"@stdlib/utils/group-in","groupOwn":"@stdlib/utils/group-own","gswap":"@stdlib/blas/gswap","HALF_LN2":"@stdlib/constants/float64/half-ln-two","HALF_PI":"@stdlib/constants/float64/half-pi","HARRISON_BOSTON_HOUSE_PRICES":"@stdlib/datasets/harrison-boston-house-prices","HARRISON_BOSTON_HOUSE_PRICES_CORRECTED":"@stdlib/datasets/harrison-boston-house-prices-corrected","hasArrayBufferSupport":"@stdlib/assert/has-arraybuffer-support","hasArrowFunctionSupport":"@stdlib/assert/has-arrow-function-support","hasAsyncAwaitSupport":"@stdlib/assert/has-async-await-support","hasAsyncIteratorSymbolSupport":"@stdlib/assert/has-async-iterator-symbol-support","hasAtobSupport":"@stdlib/assert/has-atob-support","hasBigInt64ArraySupport":"@stdlib/assert/has-bigint64array-support","hasBigIntSupport":"@stdlib/assert/has-bigint-support","hasBigUint64ArraySupport":"@stdlib/assert/has-biguint64array-support","hasBtoaSupport":"@stdlib/assert/has-btoa-support","hasClassSupport":"@stdlib/assert/has-class-support","hasDataViewSupport":"@stdlib/assert/has-dataview-support","hasDefinePropertiesSupport":"@stdlib/assert/has-define-properties-support","hasDefinePropertySupport":"@stdlib/assert/has-define-property-support","hasFloat32ArraySupport":"@stdlib/assert/has-float32array-support","hasFloat64ArraySupport":"@stdlib/assert/has-float64array-support","hasFunctionNameSupport":"@stdlib/assert/has-function-name-support","hasGeneratorSupport":"@stdlib/assert/has-generator-support","hasGlobalThisSupport":"@stdlib/assert/has-globalthis-support","hasInt8ArraySupport":"@stdlib/assert/has-int8array-support","hasInt16ArraySupport":"@stdlib/assert/has-int16array-support","hasInt32ArraySupport":"@stdlib/assert/has-int32array-support","hasIteratorSymbolSupport":"@stdlib/assert/has-iterator-symbol-support","hasMapSupport":"@stdlib/assert/has-map-support","hasNodeBufferSupport":"@stdlib/assert/has-node-buffer-support","hasOwnProp":"@stdlib/assert/has-own-property","hasProp":"@stdlib/assert/has-property","hasProxySupport":"@stdlib/assert/has-proxy-support","hasSetSupport":"@stdlib/assert/has-set-support","hasSharedArrayBufferSupport":"@stdlib/assert/has-sharedarraybuffer-support","hasSymbolSupport":"@stdlib/assert/has-symbol-support","hasToStringTagSupport":"@stdlib/assert/has-tostringtag-support","hasUint8ArraySupport":"@stdlib/assert/has-uint8array-support","hasUint8ClampedArraySupport":"@stdlib/assert/has-uint8clampedarray-support","hasUint16ArraySupport":"@stdlib/assert/has-uint16array-support","hasUint32ArraySupport":"@stdlib/assert/has-uint32array-support","hasUTF16SurrogatePairAt":"@stdlib/assert/has-utf16-surrogate-pair-at","hasWeakMapSupport":"@stdlib/assert/has-weakmap-support","hasWeakSetSupport":"@stdlib/assert/has-weakset-support","hasWebAssemblySupport":"@stdlib/assert/has-wasm-support","headercase":"@stdlib/string/headercase","HERNDON_VENUS_SEMIDIAMETERS":"@stdlib/datasets/herndon-venus-semidiameters","homedir":"@stdlib/os/homedir","HOURS_IN_DAY":"@stdlib/constants/time/hours-in-day","HOURS_IN_WEEK":"@stdlib/constants/time/hours-in-week","hoursInMonth":"@stdlib/time/hours-in-month","hoursInYear":"@stdlib/time/hours-in-year","httpServer":"@stdlib/net/http-server","identity":"@stdlib/utils/identity-function","ifelse":"@stdlib/utils/if-else","ifelseAsync":"@stdlib/utils/async/if-else","ifthen":"@stdlib/utils/if-then","ifthenAsync":"@stdlib/utils/async/if-then","imag":"@stdlib/complex/float64/imag","imagf":"@stdlib/complex/float32/imag","IMG_ACANTHUS_MOLLIS":"@stdlib/datasets/img-acanthus-mollis","IMG_AIRPLANE_FROM_ABOVE":"@stdlib/datasets/img-airplane-from-above","IMG_ALLIUM_OREOPHILUM":"@stdlib/datasets/img-allium-oreophilum","IMG_BLACK_CANYON":"@stdlib/datasets/img-black-canyon","IMG_DUST_BOWL_HOME":"@stdlib/datasets/img-dust-bowl-home","IMG_FRENCH_ALPINE_LANDSCAPE":"@stdlib/datasets/img-french-alpine-landscape","IMG_LOCOMOTION_HOUSE_CAT":"@stdlib/datasets/img-locomotion-house-cat","IMG_LOCOMOTION_NUDE_MALE":"@stdlib/datasets/img-locomotion-nude-male","IMG_MARCH_PASTORAL":"@stdlib/datasets/img-march-pastoral","IMG_NAGASAKI_BOATS":"@stdlib/datasets/img-nagasaki-boats","incrapcorr":"@stdlib/stats/incr/apcorr","incrBinaryClassification":"@stdlib/ml/incr/binary-classification","incrcount":"@stdlib/stats/incr/count","incrcovariance":"@stdlib/stats/incr/covariance","incrcovmat":"@stdlib/stats/incr/covmat","incrcv":"@stdlib/stats/incr/cv","increwmean":"@stdlib/stats/incr/ewmean","increwstdev":"@stdlib/stats/incr/ewstdev","increwvariance":"@stdlib/stats/incr/ewvariance","incrgmean":"@stdlib/stats/incr/gmean","incrgrubbs":"@stdlib/stats/incr/grubbs","incrhmean":"@stdlib/stats/incr/hmean","incrkmeans":"@stdlib/ml/incr/kmeans","incrkurtosis":"@stdlib/stats/incr/kurtosis","incrmaape":"@stdlib/stats/incr/maape","incrmae":"@stdlib/stats/incr/mae","incrmapcorr":"@stdlib/stats/incr/mapcorr","incrmape":"@stdlib/stats/incr/mape","incrmax":"@stdlib/stats/incr/max","incrmaxabs":"@stdlib/stats/incr/maxabs","incrmcovariance":"@stdlib/stats/incr/mcovariance","incrmcv":"@stdlib/stats/incr/mcv","incrmda":"@stdlib/stats/incr/mda","incrme":"@stdlib/stats/incr/me","incrmean":"@stdlib/stats/incr/mean","incrmeanabs":"@stdlib/stats/incr/meanabs","incrmeanabs2":"@stdlib/stats/incr/meanabs2","incrmeanstdev":"@stdlib/stats/incr/meanstdev","incrmeanvar":"@stdlib/stats/incr/meanvar","incrmgmean":"@stdlib/stats/incr/mgmean","incrmgrubbs":"@stdlib/stats/incr/mgrubbs","incrmhmean":"@stdlib/stats/incr/mhmean","incrmidrange":"@stdlib/stats/incr/midrange","incrmin":"@stdlib/stats/incr/min","incrminabs":"@stdlib/stats/incr/minabs","incrminmax":"@stdlib/stats/incr/minmax","incrminmaxabs":"@stdlib/stats/incr/minmaxabs","incrmmaape":"@stdlib/stats/incr/mmaape","incrmmae":"@stdlib/stats/incr/mmae","incrmmape":"@stdlib/stats/incr/mmape","incrmmax":"@stdlib/stats/incr/mmax","incrmmaxabs":"@stdlib/stats/incr/mmaxabs","incrmmda":"@stdlib/stats/incr/mmda","incrmme":"@stdlib/stats/incr/mme","incrmmean":"@stdlib/stats/incr/mmean","incrmmeanabs":"@stdlib/stats/incr/mmeanabs","incrmmeanabs2":"@stdlib/stats/incr/mmeanabs2","incrmmeanstdev":"@stdlib/stats/incr/mmeanstdev","incrmmeanvar":"@stdlib/stats/incr/mmeanvar","incrmmidrange":"@stdlib/stats/incr/mmidrange","incrmmin":"@stdlib/stats/incr/mmin","incrmminabs":"@stdlib/stats/incr/mminabs","incrmminmax":"@stdlib/stats/incr/mminmax","incrmminmaxabs":"@stdlib/stats/incr/mminmaxabs","incrmmpe":"@stdlib/stats/incr/mmpe","incrmmse":"@stdlib/stats/incr/mmse","incrmpcorr":"@stdlib/stats/incr/mpcorr","incrmpcorr2":"@stdlib/stats/incr/mpcorr2","incrmpcorrdist":"@stdlib/stats/incr/mpcorrdist","incrmpe":"@stdlib/stats/incr/mpe","incrmprod":"@stdlib/stats/incr/mprod","incrmrange":"@stdlib/stats/incr/mrange","incrmrmse":"@stdlib/stats/incr/mrmse","incrmrss":"@stdlib/stats/incr/mrss","incrmse":"@stdlib/stats/incr/mse","incrmstdev":"@stdlib/stats/incr/mstdev","incrmsum":"@stdlib/stats/incr/msum","incrmsumabs":"@stdlib/stats/incr/msumabs","incrmsumabs2":"@stdlib/stats/incr/msumabs2","incrmsummary":"@stdlib/stats/incr/msummary","incrmsumprod":"@stdlib/stats/incr/msumprod","incrmvariance":"@stdlib/stats/incr/mvariance","incrmvmr":"@stdlib/stats/incr/mvmr","incrnancount":"@stdlib/stats/incr/nancount","incrnansum":"@stdlib/stats/incr/nansum","incrnansumabs":"@stdlib/stats/incr/nansumabs","incrnansumabs2":"@stdlib/stats/incr/nansumabs2","incrpcorr":"@stdlib/stats/incr/pcorr","incrpcorr2":"@stdlib/stats/incr/pcorr2","incrpcorrdist":"@stdlib/stats/incr/pcorrdist","incrpcorrdistmat":"@stdlib/stats/incr/pcorrdistmat","incrpcorrmat":"@stdlib/stats/incr/pcorrmat","incrprod":"@stdlib/stats/incr/prod","incrrange":"@stdlib/stats/incr/range","incrrmse":"@stdlib/stats/incr/rmse","incrrss":"@stdlib/stats/incr/rss","incrSGDRegression":"@stdlib/ml/incr/sgd-regression","incrskewness":"@stdlib/stats/incr/skewness","incrspace":"@stdlib/array/incrspace","incrstdev":"@stdlib/stats/incr/stdev","incrsum":"@stdlib/stats/incr/sum","incrsumabs":"@stdlib/stats/incr/sumabs","incrsumabs2":"@stdlib/stats/incr/sumabs2","incrsummary":"@stdlib/stats/incr/summary","incrsumprod":"@stdlib/stats/incr/sumprod","incrvariance":"@stdlib/stats/incr/variance","incrvmr":"@stdlib/stats/incr/vmr","incrwmean":"@stdlib/stats/incr/wmean","ind2sub":"@stdlib/ndarray/ind2sub","indexOf":"@stdlib/utils/index-of","inherit":"@stdlib/utils/inherit","inheritedEnumerableProperties":"@stdlib/utils/inherited-enumerable-properties","inheritedEnumerablePropertySymbols":"@stdlib/utils/inherited-enumerable-property-symbols","inheritedKeys":"@stdlib/utils/inherited-keys","inheritedNonEnumerableProperties":"@stdlib/utils/inherited-nonenumerable-properties","inheritedNonEnumerablePropertyNames":"@stdlib/utils/inherited-nonenumerable-property-names","inheritedNonEnumerablePropertySymbols":"@stdlib/utils/inherited-nonenumerable-property-symbols","inheritedProperties":"@stdlib/utils/inherited-properties","inheritedPropertyDescriptor":"@stdlib/utils/inherited-property-descriptor","inheritedPropertyDescriptors":"@stdlib/utils/inherited-property-descriptors","inheritedPropertyNames":"@stdlib/utils/inherited-property-names","inheritedPropertySymbols":"@stdlib/utils/inherited-property-symbols","inheritedWritableProperties":"@stdlib/utils/inherited-writable-properties","inheritedWritablePropertyNames":"@stdlib/utils/inherited-writable-property-names","inheritedWritablePropertySymbols":"@stdlib/utils/inherited-writable-property-symbols","inmap":"@stdlib/utils/inmap","inmapAsync":"@stdlib/utils/async/inmap","inmapRight":"@stdlib/utils/inmap-right","inmapRightAsync":"@stdlib/utils/async/inmap-right","inspectSinkStream":"@stdlib/streams/node/inspect-sink","inspectStream":"@stdlib/streams/node/inspect","instanceOf":"@stdlib/assert/instance-of","INT8_MAX":"@stdlib/constants/int8/max","INT8_MIN":"@stdlib/constants/int8/min","INT8_NUM_BYTES":"@stdlib/constants/int8/num-bytes","Int8Array":"@stdlib/array/int8","INT16_MAX":"@stdlib/constants/int16/max","INT16_MIN":"@stdlib/constants/int16/min","INT16_NUM_BYTES":"@stdlib/constants/int16/num-bytes","Int16Array":"@stdlib/array/int16","INT32_MAX":"@stdlib/constants/int32/max","INT32_MIN":"@stdlib/constants/int32/min","INT32_NUM_BYTES":"@stdlib/constants/int32/num-bytes","Int32Array":"@stdlib/array/int32","IS_BIG_ENDIAN":"@stdlib/assert/is-big-endian","IS_BROWSER":"@stdlib/assert/is-browser","IS_DARWIN":"@stdlib/assert/is-darwin","IS_DOCKER":"@stdlib/assert/is-docker","IS_ELECTRON":"@stdlib/assert/is-electron","IS_ELECTRON_MAIN":"@stdlib/assert/is-electron-main","IS_ELECTRON_RENDERER":"@stdlib/assert/is-electron-renderer","IS_LITTLE_ENDIAN":"@stdlib/assert/is-little-endian","IS_MOBILE":"@stdlib/assert/is-mobile","IS_NODE":"@stdlib/assert/is-node","IS_TOUCH_DEVICE":"@stdlib/assert/is-touch-device","IS_WEB_WORKER":"@stdlib/assert/is-web-worker","IS_WINDOWS":"@stdlib/assert/is-windows","isAbsoluteHttpURI":"@stdlib/assert/is-absolute-http-uri","isAbsolutePath":"@stdlib/assert/is-absolute-path","isAbsoluteURI":"@stdlib/assert/is-absolute-uri","isAccessorArray":"@stdlib/assert/is-accessor-array","isAccessorProperty":"@stdlib/assert/is-accessor-property","isAccessorPropertyIn":"@stdlib/assert/is-accessor-property-in","isAlphagram":"@stdlib/assert/is-alphagram","isAlphaNumeric":"@stdlib/assert/is-alphanumeric","isAnagram":"@stdlib/assert/is-anagram","isArguments":"@stdlib/assert/is-arguments","isArray":"@stdlib/assert/is-array","isArrayArray":"@stdlib/assert/is-array-array","isArrayBuffer":"@stdlib/assert/is-arraybuffer","isArrayBufferView":"@stdlib/assert/is-arraybuffer-view","isArrayLength":"@stdlib/assert/is-array-length","isArrayLike":"@stdlib/assert/is-array-like","isArrayLikeObject":"@stdlib/assert/is-array-like-object","isArrowFunction":"@stdlib/assert/is-arrow-function","isASCII":"@stdlib/assert/is-ascii","isBetween":"@stdlib/assert/is-between","isBetweenArray":"@stdlib/assert/is-between-array","isBigInt":"@stdlib/assert/is-bigint","isBigInt64Array":"@stdlib/assert/is-bigint64array","isBigUint64Array":"@stdlib/assert/is-biguint64array","isBinaryString":"@stdlib/assert/is-binary-string","isBlankString":"@stdlib/assert/is-blank-string","isBoolean":"@stdlib/assert/is-boolean","isBooleanArray":"@stdlib/assert/is-boolean-array","isBoxedPrimitive":"@stdlib/assert/is-boxed-primitive","isBuffer":"@stdlib/assert/is-buffer","isCamelcase":"@stdlib/assert/is-camelcase","isCapitalized":"@stdlib/assert/is-capitalized","isCentrosymmetricMatrix":"@stdlib/assert/is-centrosymmetric-matrix","isCircular":"@stdlib/assert/is-circular","isCircularArray":"@stdlib/assert/is-circular-array","isCircularPlainObject":"@stdlib/assert/is-circular-plain-object","isClass":"@stdlib/assert/is-class","isCollection":"@stdlib/assert/is-collection","isComplex":"@stdlib/assert/is-complex","isComplex64":"@stdlib/assert/is-complex64","isComplex64Array":"@stdlib/assert/is-complex64array","isComplex64MatrixLike":"@stdlib/assert/is-complex64matrix-like","isComplex64ndarrayLike":"@stdlib/assert/is-complex64ndarray-like","isComplex64VectorLike":"@stdlib/assert/is-complex64vector-like","isComplex128":"@stdlib/assert/is-complex128","isComplex128Array":"@stdlib/assert/is-complex128array","isComplex128MatrixLike":"@stdlib/assert/is-complex128matrix-like","isComplex128ndarrayLike":"@stdlib/assert/is-complex128ndarray-like","isComplex128VectorLike":"@stdlib/assert/is-complex128vector-like","isComplexLike":"@stdlib/assert/is-complex-like","isComplexTypedArray":"@stdlib/assert/is-complex-typed-array","isComplexTypedArrayLike":"@stdlib/assert/is-complex-typed-array-like","isComposite":"@stdlib/assert/is-composite","isConfigurableProperty":"@stdlib/assert/is-configurable-property","isConfigurablePropertyIn":"@stdlib/assert/is-configurable-property-in","isConstantcase":"@stdlib/assert/is-constantcase","isCubeNumber":"@stdlib/assert/is-cube-number","isCurrentYear":"@stdlib/assert/is-current-year","isDataProperty":"@stdlib/assert/is-data-property","isDataPropertyIn":"@stdlib/assert/is-data-property-in","isDataView":"@stdlib/assert/is-dataview","isDateObject":"@stdlib/assert/is-date-object","isDateObjectArray":"@stdlib/assert/is-date-object-array","isDigitString":"@stdlib/assert/is-digit-string","isDomainName":"@stdlib/assert/is-domain-name","isDurationString":"@stdlib/assert/is-duration-string","isEmailAddress":"@stdlib/assert/is-email-address","isEmptyArray":"@stdlib/assert/is-empty-array","isEmptyArrayLikeObject":"@stdlib/assert/is-empty-array-like-object","isEmptyCollection":"@stdlib/assert/is-empty-collection","isEmptyObject":"@stdlib/assert/is-empty-object","isEmptyString":"@stdlib/assert/is-empty-string","isEnumerableProperty":"@stdlib/assert/is-enumerable-property","isEnumerablePropertyIn":"@stdlib/assert/is-enumerable-property-in","isEqualArray":"@stdlib/assert/is-equal-array","isError":"@stdlib/assert/is-error","isEvalError":"@stdlib/assert/is-eval-error","isEven":"@stdlib/assert/is-even","isFalsy":"@stdlib/assert/is-falsy","isFalsyArray":"@stdlib/assert/is-falsy-array","isFinite":"@stdlib/assert/is-finite","isFiniteArray":"@stdlib/assert/is-finite-array","isFloat32Array":"@stdlib/assert/is-float32array","isFloat32MatrixLike":"@stdlib/assert/is-float32matrix-like","isFloat32ndarrayLike":"@stdlib/assert/is-float32ndarray-like","isFloat32VectorLike":"@stdlib/assert/is-float32vector-like","isFloat64Array":"@stdlib/assert/is-float64array","isFloat64MatrixLike":"@stdlib/assert/is-float64matrix-like","isFloat64ndarrayLike":"@stdlib/assert/is-float64ndarray-like","isFloat64VectorLike":"@stdlib/assert/is-float64vector-like","isFunction":"@stdlib/assert/is-function","isFunctionArray":"@stdlib/assert/is-function-array","isGeneratorObject":"@stdlib/assert/is-generator-object","isGeneratorObjectLike":"@stdlib/assert/is-generator-object-like","isgzipBuffer":"@stdlib/assert/is-gzip-buffer","isHexString":"@stdlib/assert/is-hex-string","isInfinite":"@stdlib/assert/is-infinite","isInheritedProperty":"@stdlib/assert/is-inherited-property","isInt8Array":"@stdlib/assert/is-int8array","isInt16Array":"@stdlib/assert/is-int16array","isInt32Array":"@stdlib/assert/is-int32array","isInteger":"@stdlib/assert/is-integer","isIntegerArray":"@stdlib/assert/is-integer-array","isIterableLike":"@stdlib/assert/is-iterable-like","isIteratorLike":"@stdlib/assert/is-iterator-like","isJSON":"@stdlib/assert/is-json","isKebabcase":"@stdlib/assert/is-kebabcase","isLeapYear":"@stdlib/assert/is-leap-year","isLocalhost":"@stdlib/assert/is-localhost","isLowercase":"@stdlib/assert/is-lowercase","isMatrixLike":"@stdlib/assert/is-matrix-like","isMethod":"@stdlib/assert/is-method","isMethodIn":"@stdlib/assert/is-method-in","isMultiSlice":"@stdlib/assert/is-multi-slice","isNamedTypedTupleLike":"@stdlib/assert/is-named-typed-tuple-like","isnan":"@stdlib/assert/is-nan","isNaNArray":"@stdlib/assert/is-nan-array","isNativeFunction":"@stdlib/assert/is-native-function","isndarrayLike":"@stdlib/assert/is-ndarray-like","isndarrayLikeWithDataType":"@stdlib/assert/is-ndarray-like-with-data-type","isNegativeFinite":"@stdlib/assert/is-negative-finite","isNegativeInteger":"@stdlib/assert/is-negative-integer","isNegativeIntegerArray":"@stdlib/assert/is-negative-integer-array","isNegativeNumber":"@stdlib/assert/is-negative-number","isNegativeNumberArray":"@stdlib/assert/is-negative-number-array","isNegativeZero":"@stdlib/assert/is-negative-zero","isNodeBuiltin":"@stdlib/assert/is-node-builtin","isNodeDuplexStreamLike":"@stdlib/assert/is-node-duplex-stream-like","isNodeReadableStreamLike":"@stdlib/assert/is-node-readable-stream-like","isNodeREPL":"@stdlib/assert/is-node-repl","isNodeStreamLike":"@stdlib/assert/is-node-stream-like","isNodeTransformStreamLike":"@stdlib/assert/is-node-transform-stream-like","isNodeWritableStreamLike":"@stdlib/assert/is-node-writable-stream-like","isNonConfigurableProperty":"@stdlib/assert/is-nonconfigurable-property","isNonConfigurablePropertyIn":"@stdlib/assert/is-nonconfigurable-property-in","isNonEnumerableProperty":"@stdlib/assert/is-nonenumerable-property","isNonEnumerablePropertyIn":"@stdlib/assert/is-nonenumerable-property-in","isNonNegativeFinite":"@stdlib/assert/is-nonnegative-finite","isNonNegativeInteger":"@stdlib/assert/is-nonnegative-integer","isNonNegativeIntegerArray":"@stdlib/assert/is-nonnegative-integer-array","isNonNegativeNumber":"@stdlib/assert/is-nonnegative-number","isNonNegativeNumberArray":"@stdlib/assert/is-nonnegative-number-array","isNonPositiveFinite":"@stdlib/assert/is-nonpositive-finite","isNonPositiveInteger":"@stdlib/assert/is-nonpositive-integer","isNonPositiveIntegerArray":"@stdlib/assert/is-nonpositive-integer-array","isNonPositiveNumber":"@stdlib/assert/is-nonpositive-number","isNonPositiveNumberArray":"@stdlib/assert/is-nonpositive-number-array","isNonSymmetricMatrix":"@stdlib/assert/is-nonsymmetric-matrix","isNull":"@stdlib/assert/is-null","isNullArray":"@stdlib/assert/is-null-array","isNumber":"@stdlib/assert/is-number","isNumberArray":"@stdlib/assert/is-number-array","isNumericArray":"@stdlib/assert/is-numeric-array","isObject":"@stdlib/assert/is-object","isObjectArray":"@stdlib/assert/is-object-array","isObjectLike":"@stdlib/assert/is-object-like","isOdd":"@stdlib/assert/is-odd","isoWeeksInYear":"@stdlib/time/iso-weeks-in-year","isPascalcase":"@stdlib/assert/is-pascalcase","isPersymmetricMatrix":"@stdlib/assert/is-persymmetric-matrix","isPlainObject":"@stdlib/assert/is-plain-object","isPlainObjectArray":"@stdlib/assert/is-plain-object-array","isPositiveFinite":"@stdlib/assert/is-positive-finite","isPositiveInteger":"@stdlib/assert/is-positive-integer","isPositiveIntegerArray":"@stdlib/assert/is-positive-integer-array","isPositiveNumber":"@stdlib/assert/is-positive-number","isPositiveNumberArray":"@stdlib/assert/is-positive-number-array","isPositiveZero":"@stdlib/assert/is-positive-zero","isPrime":"@stdlib/assert/is-prime","isPrimitive":"@stdlib/assert/is-primitive","isPrimitiveArray":"@stdlib/assert/is-primitive-array","isPRNGLike":"@stdlib/assert/is-prng-like","isProbability":"@stdlib/assert/is-probability","isProbabilityArray":"@stdlib/assert/is-probability-array","isPropertyKey":"@stdlib/assert/is-property-key","isPrototypeOf":"@stdlib/assert/is-prototype-of","isRaggedNestedArray":"@stdlib/assert/is-ragged-nested-array","isRangeError":"@stdlib/assert/is-range-error","isReadableProperty":"@stdlib/assert/is-readable-property","isReadablePropertyIn":"@stdlib/assert/is-readable-property-in","isReadOnlyProperty":"@stdlib/assert/is-read-only-property","isReadOnlyPropertyIn":"@stdlib/assert/is-read-only-property-in","isReadWriteProperty":"@stdlib/assert/is-read-write-property","isReadWritePropertyIn":"@stdlib/assert/is-read-write-property-in","isReferenceError":"@stdlib/assert/is-reference-error","isRegExp":"@stdlib/assert/is-regexp","isRegExpString":"@stdlib/assert/is-regexp-string","isRelativePath":"@stdlib/assert/is-relative-path","isRelativeURI":"@stdlib/assert/is-relative-uri","isSafeInteger":"@stdlib/assert/is-safe-integer","isSafeIntegerArray":"@stdlib/assert/is-safe-integer-array","isSameArray":"@stdlib/assert/is-same-array","isSameArrayLike":"@stdlib/assert/is-same-array-like","isSameComplex64":"@stdlib/assert/is-same-complex64","isSameComplex64Array":"@stdlib/assert/is-same-complex64array","isSameComplex128":"@stdlib/assert/is-same-complex128","isSameComplex128Array":"@stdlib/assert/is-same-complex128array","isSameDateObject":"@stdlib/assert/is-same-date-object","isSameFloat32Array":"@stdlib/assert/is-same-float32array","isSameFloat64Array":"@stdlib/assert/is-same-float64array","isSameNativeClass":"@stdlib/assert/is-same-native-class","isSameType":"@stdlib/assert/is-same-type","isSameValue":"@stdlib/assert/is-same-value","isSameValueZero":"@stdlib/assert/is-same-value-zero","isSemVer":"@stdlib/assert/is-semver","isSharedArrayBuffer":"@stdlib/assert/is-sharedarraybuffer","isSkewCentrosymmetricMatrix":"@stdlib/assert/is-skew-centrosymmetric-matrix","isSkewPersymmetricMatrix":"@stdlib/assert/is-skew-persymmetric-matrix","isSkewSymmetricMatrix":"@stdlib/assert/is-skew-symmetric-matrix","isSlice":"@stdlib/assert/is-slice","isSnakecase":"@stdlib/assert/is-snakecase","isSquareMatrix":"@stdlib/assert/is-square-matrix","isSquareNumber":"@stdlib/assert/is-square-number","isSquareTriangularNumber":"@stdlib/assert/is-square-triangular-number","isStartcase":"@stdlib/assert/is-startcase","isStrictEqual":"@stdlib/assert/is-strict-equal","isString":"@stdlib/assert/is-string","isStringArray":"@stdlib/assert/is-string-array","isSymbol":"@stdlib/assert/is-symbol","isSymbolArray":"@stdlib/assert/is-symbol-array","isSymmetricMatrix":"@stdlib/assert/is-symmetric-matrix","isSyntaxError":"@stdlib/assert/is-syntax-error","isTriangularNumber":"@stdlib/assert/is-triangular-number","isTruthy":"@stdlib/assert/is-truthy","isTruthyArray":"@stdlib/assert/is-truthy-array","isTypedArray":"@stdlib/assert/is-typed-array","isTypedArrayLength":"@stdlib/assert/is-typed-array-length","isTypedArrayLike":"@stdlib/assert/is-typed-array-like","isTypeError":"@stdlib/assert/is-type-error","isUint8Array":"@stdlib/assert/is-uint8array","isUint8ClampedArray":"@stdlib/assert/is-uint8clampedarray","isUint16Array":"@stdlib/assert/is-uint16array","isUint32Array":"@stdlib/assert/is-uint32array","isUNCPath":"@stdlib/assert/is-unc-path","isUndefined":"@stdlib/assert/is-undefined","isUndefinedOrNull":"@stdlib/assert/is-undefined-or-null","isUnityProbabilityArray":"@stdlib/assert/is-unity-probability-array","isUppercase":"@stdlib/assert/is-uppercase","isURI":"@stdlib/assert/is-uri","isURIError":"@stdlib/assert/is-uri-error","isVectorLike":"@stdlib/assert/is-vector-like","isWebAssemblyMemory":"@stdlib/assert/is-wasm-memory","isWellFormedString":"@stdlib/assert/is-well-formed-string","isWhitespace":"@stdlib/assert/is-whitespace","isWritableProperty":"@stdlib/assert/is-writable-property","isWritablePropertyIn":"@stdlib/assert/is-writable-property-in","isWriteOnlyProperty":"@stdlib/assert/is-write-only-property","isWriteOnlyPropertyIn":"@stdlib/assert/is-write-only-property-in","iterAbs":"@stdlib/math/iter/special/abs","iterAbs2":"@stdlib/math/iter/special/abs2","iterAcos":"@stdlib/math/iter/special/acos","iterAcosh":"@stdlib/math/iter/special/acosh","iterAcot":"@stdlib/math/iter/special/acot","iterAcoth":"@stdlib/math/iter/special/acoth","iterAcovercos":"@stdlib/math/iter/special/acovercos","iterAcoversin":"@stdlib/math/iter/special/acoversin","iterAdd":"@stdlib/math/iter/ops/add","iterAdvance":"@stdlib/iter/advance","iterAhavercos":"@stdlib/math/iter/special/ahavercos","iterAhaversin":"@stdlib/math/iter/special/ahaversin","iterAny":"@stdlib/iter/any","iterAnyBy":"@stdlib/iter/any-by","iterAsin":"@stdlib/math/iter/special/asin","iterAsinh":"@stdlib/math/iter/special/asinh","iterAtan":"@stdlib/math/iter/special/atan","iterAtan2":"@stdlib/math/iter/special/atan2","iterAtanh":"@stdlib/math/iter/special/atanh","iterator2array":"@stdlib/array/from-iterator","iterator2arrayview":"@stdlib/iter/to-array-view","iterator2arrayviewRight":"@stdlib/iter/to-array-view-right","iteratorStream":"@stdlib/streams/node/from-iterator","IteratorSymbol":"@stdlib/symbol/iterator","iterAvercos":"@stdlib/math/iter/special/avercos","iterAversin":"@stdlib/math/iter/special/aversin","iterawgn":"@stdlib/simulate/iter/awgn","iterawln":"@stdlib/simulate/iter/awln","iterawun":"@stdlib/simulate/iter/awun","iterBartlettHannPulse":"@stdlib/simulate/iter/bartlett-hann-pulse","iterBartlettPulse":"@stdlib/simulate/iter/bartlett-pulse","iterBesselj0":"@stdlib/math/iter/special/besselj0","iterBesselj1":"@stdlib/math/iter/special/besselj1","iterBessely0":"@stdlib/math/iter/special/bessely0","iterBessely1":"@stdlib/math/iter/special/bessely1","iterBeta":"@stdlib/math/iter/special/beta","iterBetaln":"@stdlib/math/iter/special/betaln","iterBinet":"@stdlib/math/iter/special/binet","iterCbrt":"@stdlib/math/iter/special/cbrt","iterCeil":"@stdlib/math/iter/special/ceil","iterCeil2":"@stdlib/math/iter/special/ceil2","iterCeil10":"@stdlib/math/iter/special/ceil10","iterCompositesSeq":"@stdlib/math/iter/sequences/composites","iterConcat":"@stdlib/iter/concat","iterConstant":"@stdlib/iter/constant","iterContinuedFraction":"@stdlib/math/iter/utils/continued-fraction","iterContinuedFractionSeq":"@stdlib/math/iter/sequences/continued-fraction","iterCos":"@stdlib/math/iter/special/cos","iterCosh":"@stdlib/math/iter/special/cosh","iterCosineWave":"@stdlib/simulate/iter/cosine-wave","iterCosm1":"@stdlib/math/iter/special/cosm1","iterCospi":"@stdlib/math/iter/special/cospi","iterCounter":"@stdlib/iter/counter","iterCovercos":"@stdlib/math/iter/special/covercos","iterCoversin":"@stdlib/math/iter/special/coversin","iterCubesSeq":"@stdlib/math/iter/sequences/cubes","itercugmean":"@stdlib/stats/iter/cugmean","itercuhmean":"@stdlib/stats/iter/cuhmean","itercumax":"@stdlib/stats/iter/cumax","itercumaxabs":"@stdlib/stats/iter/cumaxabs","itercumean":"@stdlib/stats/iter/cumean","itercumeanabs":"@stdlib/stats/iter/cumeanabs","itercumeanabs2":"@stdlib/stats/iter/cumeanabs2","itercumidrange":"@stdlib/stats/iter/cumidrange","itercumin":"@stdlib/stats/iter/cumin","itercuminabs":"@stdlib/stats/iter/cuminabs","itercuprod":"@stdlib/stats/iter/cuprod","itercurange":"@stdlib/stats/iter/curange","itercusum":"@stdlib/stats/iter/cusum","itercusumabs":"@stdlib/stats/iter/cusumabs","itercusumabs2":"@stdlib/stats/iter/cusumabs2","iterDatespace":"@stdlib/iter/datespace","iterDedupe":"@stdlib/iter/dedupe","iterDedupeBy":"@stdlib/iter/dedupe-by","iterDeg2rad":"@stdlib/math/iter/special/deg2rad","iterDigamma":"@stdlib/math/iter/special/digamma","iterDiracComb":"@stdlib/simulate/iter/dirac-comb","iterDiracDelta":"@stdlib/math/iter/special/dirac-delta","iterDivide":"@stdlib/math/iter/ops/divide","iterDoUntilEach":"@stdlib/iter/do-until-each","iterDoWhileEach":"@stdlib/iter/do-while-each","iterEllipe":"@stdlib/math/iter/special/ellipe","iterEllipk":"@stdlib/math/iter/special/ellipk","iterEmpty":"@stdlib/iter/empty","iterErf":"@stdlib/math/iter/special/erf","iterErfc":"@stdlib/math/iter/special/erfc","iterErfcinv":"@stdlib/math/iter/special/erfcinv","iterErfinv":"@stdlib/math/iter/special/erfinv","iterEta":"@stdlib/math/iter/special/dirichlet-eta","iterEvenIntegersSeq":"@stdlib/math/iter/sequences/even-integers","iterEvery":"@stdlib/iter/every","iterEveryBy":"@stdlib/iter/every-by","iterExp":"@stdlib/math/iter/special/exp","iterExp2":"@stdlib/math/iter/special/exp2","iterExp10":"@stdlib/math/iter/special/exp10","iterExpit":"@stdlib/math/iter/special/expit","iterExpm1":"@stdlib/math/iter/special/expm1","iterExpm1rel":"@stdlib/math/iter/special/expm1rel","iterFactorial":"@stdlib/math/iter/special/factorial","iterFactorialln":"@stdlib/math/iter/special/factorialln","iterFactorialsSeq":"@stdlib/math/iter/sequences/factorials","iterFibonacciSeq":"@stdlib/math/iter/sequences/fibonacci","iterFifthPowersSeq":"@stdlib/math/iter/sequences/fifth-powers","iterFill":"@stdlib/iter/fill","iterFilter":"@stdlib/iter/filter","iterFilterMap":"@stdlib/iter/filter-map","iterFirst":"@stdlib/iter/first","iterFlatTopPulse":"@stdlib/simulate/iter/flat-top-pulse","iterFloor":"@stdlib/math/iter/special/floor","iterFloor2":"@stdlib/math/iter/special/floor2","iterFloor10":"@stdlib/math/iter/special/floor10","iterFlow":"@stdlib/iter/flow","iterForEach":"@stdlib/iter/for-each","iterFourthPowersSeq":"@stdlib/math/iter/sequences/fourth-powers","iterFresnelc":"@stdlib/math/iter/special/fresnelc","iterFresnels":"@stdlib/math/iter/special/fresnels","iterGamma":"@stdlib/math/iter/special/gamma","iterGamma1pm1":"@stdlib/math/iter/special/gamma1pm1","iterGammaln":"@stdlib/math/iter/special/gammaln","iterHacovercos":"@stdlib/math/iter/special/hacovercos","iterHacoversin":"@stdlib/math/iter/special/hacoversin","iterHannPulse":"@stdlib/simulate/iter/hann-pulse","iterHavercos":"@stdlib/math/iter/special/havercos","iterHaversin":"@stdlib/math/iter/special/haversin","iterHead":"@stdlib/iter/head","iterIncrspace":"@stdlib/iter/incrspace","iterIntegersSeq":"@stdlib/math/iter/sequences/integers","iterIntersection":"@stdlib/iter/intersection","iterIntersectionByHash":"@stdlib/iter/intersection-by-hash","iterInv":"@stdlib/math/iter/special/inv","iterLanczosPulse":"@stdlib/simulate/iter/lanczos-pulse","iterLast":"@stdlib/iter/last","iterLength":"@stdlib/iter/length","iterLinspace":"@stdlib/iter/linspace","iterLn":"@stdlib/math/iter/special/ln","iterLog":"@stdlib/math/iter/special/log","iterLog1mexp":"@stdlib/math/iter/special/log1mexp","iterLog1p":"@stdlib/math/iter/special/log1p","iterLog1pexp":"@stdlib/math/iter/special/log1pexp","iterLog2":"@stdlib/math/iter/special/log2","iterLog10":"@stdlib/math/iter/special/log10","iterLogit":"@stdlib/math/iter/special/logit","iterLogspace":"@stdlib/iter/logspace","iterLucasSeq":"@stdlib/math/iter/sequences/lucas","iterMap":"@stdlib/iter/map","iterMapN":"@stdlib/iter/mapn","itermax":"@stdlib/stats/iter/max","itermaxabs":"@stdlib/stats/iter/maxabs","itermean":"@stdlib/stats/iter/mean","itermeanabs":"@stdlib/stats/iter/meanabs","itermeanabs2":"@stdlib/stats/iter/meanabs2","itermidrange":"@stdlib/stats/iter/midrange","itermin":"@stdlib/stats/iter/min","iterminabs":"@stdlib/stats/iter/minabs","itermmax":"@stdlib/stats/iter/mmax","itermmaxabs":"@stdlib/stats/iter/mmaxabs","itermmean":"@stdlib/stats/iter/mmean","itermmeanabs":"@stdlib/stats/iter/mmeanabs","itermmeanabs2":"@stdlib/stats/iter/mmeanabs2","itermmidrange":"@stdlib/stats/iter/mmidrange","itermmin":"@stdlib/stats/iter/mmin","itermminabs":"@stdlib/stats/iter/mminabs","iterMod":"@stdlib/math/iter/ops/mod","itermprod":"@stdlib/stats/iter/mprod","itermrange":"@stdlib/stats/iter/mrange","itermsum":"@stdlib/stats/iter/msum","itermsumabs":"@stdlib/stats/iter/msumabs","itermsumabs2":"@stdlib/stats/iter/msumabs2","iterMultiply":"@stdlib/math/iter/ops/multiply","iterNegaFibonacciSeq":"@stdlib/math/iter/sequences/negafibonacci","iterNegaLucasSeq":"@stdlib/math/iter/sequences/negalucas","iterNegativeEvenIntegersSeq":"@stdlib/math/iter/sequences/negative-even-integers","iterNegativeIntegersSeq":"@stdlib/math/iter/sequences/negative-integers","iterNegativeOddIntegersSeq":"@stdlib/math/iter/sequences/negative-odd-integers","iterNone":"@stdlib/iter/none","iterNoneBy":"@stdlib/iter/none-by","iterNonFibonacciSeq":"@stdlib/math/iter/sequences/nonfibonacci","iterNonNegativeEvenIntegersSeq":"@stdlib/math/iter/sequences/nonnegative-even-integers","iterNonNegativeIntegersSeq":"@stdlib/math/iter/sequences/nonnegative-integers","iterNonPositiveEvenIntegersSeq":"@stdlib/math/iter/sequences/nonpositive-even-integers","iterNonPositiveIntegersSeq":"@stdlib/math/iter/sequences/nonpositive-integers","iterNonSquaresSeq":"@stdlib/math/iter/sequences/nonsquares","iterNth":"@stdlib/iter/nth","iterOddIntegersSeq":"@stdlib/math/iter/sequences/odd-integers","iterPeriodicSinc":"@stdlib/simulate/iter/periodic-sinc","iterPipeline":"@stdlib/iter/pipeline","iterPop":"@stdlib/iter/pop","iterPositiveEvenIntegersSeq":"@stdlib/math/iter/sequences/positive-even-integers","iterPositiveIntegersSeq":"@stdlib/math/iter/sequences/positive-integers","iterPositiveOddIntegersSeq":"@stdlib/math/iter/sequences/positive-odd-integers","iterPow":"@stdlib/math/iter/special/pow","iterPrimesSeq":"@stdlib/math/iter/sequences/primes","iterprod":"@stdlib/stats/iter/prod","iterPulse":"@stdlib/simulate/iter/pulse","iterPush":"@stdlib/iter/push","iterRad2deg":"@stdlib/math/iter/special/rad2deg","iterRamp":"@stdlib/math/iter/special/ramp","iterrange":"@stdlib/stats/iter/range","iterReject":"@stdlib/iter/reject","iterReplicate":"@stdlib/iter/replicate","iterReplicateBy":"@stdlib/iter/replicate-by","iterRound":"@stdlib/math/iter/special/round","iterRound2":"@stdlib/math/iter/special/round2","iterRound10":"@stdlib/math/iter/special/round10","iterRsqrt":"@stdlib/math/iter/special/rsqrt","iterSawtoothWave":"@stdlib/simulate/iter/sawtooth-wave","iterShift":"@stdlib/iter/shift","iterSignum":"@stdlib/math/iter/special/signum","iterSin":"@stdlib/math/iter/special/sin","iterSinc":"@stdlib/math/iter/special/sinc","iterSineWave":"@stdlib/simulate/iter/sine-wave","iterSinh":"@stdlib/math/iter/special/sinh","iterSinpi":"@stdlib/math/iter/special/sinpi","iterSlice":"@stdlib/iter/slice","iterSome":"@stdlib/iter/some","iterSomeBy":"@stdlib/iter/some-by","iterSpence":"@stdlib/math/iter/special/spence","iterSqrt":"@stdlib/math/iter/special/sqrt","iterSqrt1pm1":"@stdlib/math/iter/special/sqrt1pm1","iterSquaredTriangularSeq":"@stdlib/math/iter/sequences/squared-triangular","iterSquaresSeq":"@stdlib/math/iter/sequences/squares","iterSquareWave":"@stdlib/simulate/iter/square-wave","iterstdev":"@stdlib/stats/iter/stdev","iterStep":"@stdlib/iter/step","iterStrided":"@stdlib/iter/strided","iterStridedBy":"@stdlib/iter/strided-by","iterSubtract":"@stdlib/math/iter/ops/subtract","itersum":"@stdlib/stats/iter/sum","itersumabs":"@stdlib/stats/iter/sumabs","itersumabs2":"@stdlib/stats/iter/sumabs2","iterTan":"@stdlib/math/iter/special/tan","iterTanh":"@stdlib/math/iter/special/tanh","iterThunk":"@stdlib/iter/pipeline-thunk","iterTriangleWave":"@stdlib/simulate/iter/triangle-wave","iterTriangularSeq":"@stdlib/math/iter/sequences/triangular","iterTribonnaciSeq":"@stdlib/math/iter/sequences/tribonacci","iterTrigamma":"@stdlib/math/iter/special/trigamma","iterTrunc":"@stdlib/math/iter/special/trunc","iterTrunc2":"@stdlib/math/iter/special/trunc2","iterTrunc10":"@stdlib/math/iter/special/trunc10","iterUnion":"@stdlib/iter/union","iterUnique":"@stdlib/iter/unique","iterUniqueBy":"@stdlib/iter/unique-by","iterUniqueByHash":"@stdlib/iter/unique-by-hash","iterUnitspace":"@stdlib/iter/unitspace","iterUnshift":"@stdlib/iter/unshift","iterUntilEach":"@stdlib/iter/until-each","itervariance":"@stdlib/stats/iter/variance","iterVercos":"@stdlib/math/iter/special/vercos","iterVersin":"@stdlib/math/iter/special/versin","iterWhileEach":"@stdlib/iter/while-each","iterZeta":"@stdlib/math/iter/special/riemann-zeta","joinStream":"@stdlib/streams/node/join","kde2d":"@stdlib/stats/kde2d","kebabcase":"@stdlib/string/kebabcase","keyBy":"@stdlib/utils/key-by","keyByRight":"@stdlib/utils/key-by-right","keysIn":"@stdlib/utils/keys-in","kruskalTest":"@stdlib/stats/kruskal-test","kstest":"@stdlib/stats/kstest","last":"@stdlib/string/last","lda":"@stdlib/nlp/lda","leveneTest":"@stdlib/stats/levene-test","LinkedList":"@stdlib/dstructs/linked-list","linspace":"@stdlib/array/linspace","LIU_NEGATIVE_OPINION_WORDS_EN":"@stdlib/datasets/liu-negative-opinion-words-en","LIU_POSITIVE_OPINION_WORDS_EN":"@stdlib/datasets/liu-positive-opinion-words-en","LN_HALF":"@stdlib/constants/float64/ln-half","LN_PI":"@stdlib/constants/float64/ln-pi","LN_SQRT_TWO_PI":"@stdlib/constants/float64/ln-sqrt-two-pi","LN_TWO_PI":"@stdlib/constants/float64/ln-two-pi","LN2":"@stdlib/constants/float64/ln-two","LN10":"@stdlib/constants/float64/ln-ten","LOG2E":"@stdlib/constants/float64/log2-e","LOG10E":"@stdlib/constants/float64/log10-e","logspace":"@stdlib/array/logspace","lowercase":"@stdlib/string/lowercase","lowercaseKeys":"@stdlib/utils/lowercase-keys","lowess":"@stdlib/stats/lowess","lpad":"@stdlib/string/left-pad","ltrim":"@stdlib/string/left-trim","ltrimN":"@stdlib/string/left-trim-n","MALE_FIRST_NAMES_EN":"@stdlib/datasets/male-first-names-en","map":"@stdlib/utils/map","map2":"@stdlib/utils/map2","map2d":"@stdlib/utils/map2d","map2Right":"@stdlib/utils/map2-right","map3d":"@stdlib/utils/map3d","map4d":"@stdlib/utils/map4d","map5d":"@stdlib/utils/map5d","mapArguments":"@stdlib/utils/map-arguments","mapFun":"@stdlib/utils/map-function","mapFunAsync":"@stdlib/utils/async/map-function","mapKeys":"@stdlib/utils/map-keys","mapKeysAsync":"@stdlib/utils/async/map-keys","mapReduce":"@stdlib/utils/map-reduce","mapReduceRight":"@stdlib/utils/map-reduce-right","mapRight":"@stdlib/utils/map-right","mapValues":"@stdlib/utils/map-values","mapValuesAsync":"@stdlib/utils/async/map-values","maskArguments":"@stdlib/utils/mask-arguments","MAX_ARRAY_LENGTH":"@stdlib/constants/array/max-array-length","MAX_TYPED_ARRAY_LENGTH":"@stdlib/constants/array/max-typed-array-length","maybeBroadcastArray":"@stdlib/ndarray/maybe-broadcast-array","maybeBroadcastArrays":"@stdlib/ndarray/maybe-broadcast-arrays","memoize":"@stdlib/utils/memoize","merge":"@stdlib/utils/merge","MILLISECONDS_IN_DAY":"@stdlib/constants/time/milliseconds-in-day","MILLISECONDS_IN_HOUR":"@stdlib/constants/time/milliseconds-in-hour","MILLISECONDS_IN_MINUTE":"@stdlib/constants/time/milliseconds-in-minute","MILLISECONDS_IN_SECOND":"@stdlib/constants/time/milliseconds-in-second","MILLISECONDS_IN_WEEK":"@stdlib/constants/time/milliseconds-in-week","MINARD_NAPOLEONS_MARCH":"@stdlib/datasets/minard-napoleons-march","MINUTES_IN_DAY":"@stdlib/constants/time/minutes-in-day","MINUTES_IN_HOUR":"@stdlib/constants/time/minutes-in-hour","MINUTES_IN_WEEK":"@stdlib/constants/time/minutes-in-week","minutesInMonth":"@stdlib/time/minutes-in-month","minutesInYear":"@stdlib/time/minutes-in-year","MOBY_DICK":"@stdlib/datasets/moby-dick","MONTH_NAMES_EN":"@stdlib/datasets/month-names-en","MONTHS_IN_YEAR":"@stdlib/constants/time/months-in-year","moveProperty":"@stdlib/utils/move-property","MultiSlice":"@stdlib/slice/multi","namedtypedtuple":"@stdlib/dstructs/named-typed-tuple","NAN":"@stdlib/constants/float64/nan","naryFunction":"@stdlib/utils/nary-function","nativeClass":"@stdlib/utils/native-class","ndarray":"@stdlib/ndarray/ctor","ndarray2array":"@stdlib/ndarray/to-array","ndarray2fancy":"@stdlib/ndarray/to-fancy","ndarray2json":"@stdlib/ndarray/to-json","ndarrayCastingModes":"@stdlib/ndarray/casting-modes","ndarrayDataBuffer":"@stdlib/ndarray/data-buffer","ndarrayDataType":"@stdlib/ndarray/dtype","ndarrayDataTypes":"@stdlib/ndarray/dtypes","ndarrayDispatch":"@stdlib/ndarray/dispatch","ndarrayFlag":"@stdlib/ndarray/flag","ndarrayFlags":"@stdlib/ndarray/flags","ndarrayIndexModes":"@stdlib/ndarray/index-modes","ndarraylike2ndarray":"@stdlib/ndarray/ndarraylike2ndarray","ndarrayMinDataType":"@stdlib/ndarray/min-dtype","ndarrayMostlySafeCasts":"@stdlib/ndarray/mostly-safe-casts","ndarrayNextDataType":"@stdlib/ndarray/next-dtype","ndarrayOffset":"@stdlib/ndarray/offset","ndarrayOrder":"@stdlib/ndarray/order","ndarrayOrders":"@stdlib/ndarray/orders","ndarrayPromotionRules":"@stdlib/ndarray/promotion-rules","ndarraySafeCasts":"@stdlib/ndarray/safe-casts","ndarraySameKindCasts":"@stdlib/ndarray/same-kind-casts","ndarrayShape":"@stdlib/ndarray/shape","ndarrayStride":"@stdlib/ndarray/stride","ndarrayStrides":"@stdlib/ndarray/strides","ndat":"@stdlib/ndarray/at","ndempty":"@stdlib/ndarray/empty","ndemptyLike":"@stdlib/ndarray/empty-like","ndfilter":"@stdlib/ndarray/filter","ndfilterMap":"@stdlib/ndarray/filter-map","ndforEach":"@stdlib/ndarray/for-each","ndims":"@stdlib/ndarray/ndims","ndindex":"@stdlib/ndarray/index","nditer2arrayEach":"@stdlib/ndarray/iter/to-array-each","nditerColumnEntries":"@stdlib/ndarray/iter/column-entries","nditerColumns":"@stdlib/ndarray/iter/columns","nditerEntries":"@stdlib/ndarray/iter/entries","nditerIndices":"@stdlib/ndarray/iter/indices","nditerInterleaveSubarrays":"@stdlib/ndarray/iter/interleave-subarrays","nditerMatrices":"@stdlib/ndarray/iter/matrices","nditerMatrixEntries":"@stdlib/ndarray/iter/matrix-entries","nditerRowEntries":"@stdlib/ndarray/iter/row-entries","nditerRows":"@stdlib/ndarray/iter/rows","nditerSelectDimension":"@stdlib/ndarray/iter/select-dimension","nditerStacks":"@stdlib/ndarray/iter/stacks","nditerSubarrays":"@stdlib/ndarray/iter/subarrays","nditerValues":"@stdlib/ndarray/iter/values","ndmap":"@stdlib/ndarray/map","ndreject":"@stdlib/ndarray/reject","ndslice":"@stdlib/ndarray/slice","ndsliceAssign":"@stdlib/ndarray/slice-assign","ndsliceDimension":"@stdlib/ndarray/slice-dimension","ndsliceDimensionFrom":"@stdlib/ndarray/slice-dimension-from","ndsliceDimensionTo":"@stdlib/ndarray/slice-dimension-to","ndsliceFrom":"@stdlib/ndarray/slice-from","ndsliceTo":"@stdlib/ndarray/slice-to","ndzeros":"@stdlib/ndarray/zeros","ndzerosLike":"@stdlib/ndarray/zeros-like","nextGraphemeClusterBreak":"@stdlib/string/next-grapheme-cluster-break","nextTick":"@stdlib/utils/next-tick","NIGHTINGALES_ROSE":"@stdlib/datasets/nightingales-rose","NINF":"@stdlib/constants/float64/ninf","NODE_VERSION":"@stdlib/process/node-version","none":"@stdlib/utils/none","noneBy":"@stdlib/utils/none-by","noneByAsync":"@stdlib/utils/async/none-by","noneByRight":"@stdlib/utils/none-by-right","noneByRightAsync":"@stdlib/utils/async/none-by-right","noneInBy":"@stdlib/utils/none-in-by","nonEnumerableProperties":"@stdlib/utils/nonenumerable-properties","nonEnumerablePropertiesIn":"@stdlib/utils/nonenumerable-properties-in","nonEnumerablePropertyNames":"@stdlib/utils/nonenumerable-property-names","nonEnumerablePropertyNamesIn":"@stdlib/utils/nonenumerable-property-names-in","nonEnumerablePropertySymbols":"@stdlib/utils/nonenumerable-property-symbols","nonEnumerablePropertySymbolsIn":"@stdlib/utils/nonenumerable-property-symbols-in","noneOwnBy":"@stdlib/utils/none-own-by","nonIndexKeys":"@stdlib/utils/nonindex-keys","noop":"@stdlib/utils/noop","now":"@stdlib/time/now","NUM_CPUS":"@stdlib/os/num-cpus","num2words":"@stdlib/string/num2words","Number":"@stdlib/number/ctor","numel":"@stdlib/ndarray/numel","numelDimension":"@stdlib/ndarray/numel-dimension","numGraphemeClusters":"@stdlib/string/num-grapheme-clusters","Object":"@stdlib/object/ctor","objectEntries":"@stdlib/utils/entries","objectEntriesIn":"@stdlib/utils/entries-in","objectFromEntries":"@stdlib/utils/from-entries","objectInverse":"@stdlib/utils/object-inverse","objectInverseBy":"@stdlib/utils/object-inverse-by","objectKeys":"@stdlib/utils/keys","objectValues":"@stdlib/utils/values","objectValuesIn":"@stdlib/utils/values-in","omit":"@stdlib/utils/omit","omitBy":"@stdlib/utils/omit-by","open":"@stdlib/fs/open","openURL":"@stdlib/utils/open-url","ordinalize":"@stdlib/nlp/ordinalize","PACE_BOSTON_HOUSE_PRICES":"@stdlib/datasets/pace-boston-house-prices","pad":"@stdlib/string/pad","padjust":"@stdlib/stats/padjust","papply":"@stdlib/utils/papply","papplyRight":"@stdlib/utils/papply-right","parallel":"@stdlib/utils/parallel","parseJSON":"@stdlib/utils/parse-json","pascalcase":"@stdlib/string/pascalcase","PATH_DELIMITER":"@stdlib/constants/path/delimiter","PATH_DELIMITER_POSIX":"@stdlib/constants/path/delimiter-posix","PATH_DELIMITER_WIN32":"@stdlib/constants/path/delimiter-win32","PATH_SEP":"@stdlib/constants/path/sep","PATH_SEP_POSIX":"@stdlib/constants/path/sep-posix","PATH_SEP_WIN32":"@stdlib/constants/path/sep-win32","pcorrtest":"@stdlib/stats/pcorrtest","percentEncode":"@stdlib/string/percent-encode","PHI":"@stdlib/constants/float64/phi","PI":"@stdlib/constants/float64/pi","PI_SQUARED":"@stdlib/constants/float64/pi-squared","pick":"@stdlib/utils/pick","pickArguments":"@stdlib/utils/pick-arguments","pickBy":"@stdlib/utils/pick-by","PINF":"@stdlib/constants/float64/pinf","pkg2alias":"@stdlib/namespace/pkg2alias","pkg2related":"@stdlib/namespace/pkg2related","pkg2standalone":"@stdlib/namespace/pkg2standalone","PLATFORM":"@stdlib/os/platform","plot":"@stdlib/plot","Plot":"@stdlib/plot/ctor","pluck":"@stdlib/utils/pluck","pop":"@stdlib/utils/pop","porterStemmer":"@stdlib/nlp/porter-stemmer","prepend":"@stdlib/utils/prepend","prevGraphemeClusterBreak":"@stdlib/string/prev-grapheme-cluster-break","PRIMES_100K":"@stdlib/datasets/primes-100k","properties":"@stdlib/utils/properties","propertiesIn":"@stdlib/utils/properties-in","propertyDescriptor":"@stdlib/utils/property-descriptor","propertyDescriptorIn":"@stdlib/utils/property-descriptor-in","propertyDescriptors":"@stdlib/utils/property-descriptors","propertyDescriptorsIn":"@stdlib/utils/property-descriptors-in","propertyNames":"@stdlib/utils/property-names","propertyNamesIn":"@stdlib/utils/property-names-in","propertySymbols":"@stdlib/utils/property-symbols","propertySymbolsIn":"@stdlib/utils/property-symbols-in","Proxy":"@stdlib/proxy/ctor","push":"@stdlib/utils/push","quarterOfYear":"@stdlib/time/quarter-of-year","random.array.arcsine":"@stdlib/random/array/arcsine","random.array.bernoulli":"@stdlib/random/array/bernoulli","random.array.beta":"@stdlib/random/array/beta","random.array.betaprime":"@stdlib/random/array/betaprime","random.array.binomial":"@stdlib/random/array/binomial","random.array.cauchy":"@stdlib/random/array/cauchy","random.array.chi":"@stdlib/random/array/chi","random.array.chisquare":"@stdlib/random/array/chisquare","random.array.cosine":"@stdlib/random/array/cosine","random.array.discreteUniform":"@stdlib/random/array/discrete-uniform","random.array.erlang":"@stdlib/random/array/erlang","random.array.exponential":"@stdlib/random/array/exponential","random.array.f":"@stdlib/random/array/f","random.array.frechet":"@stdlib/random/array/frechet","random.array.gamma":"@stdlib/random/array/gamma","random.array.geometric":"@stdlib/random/array/geometric","random.array.gumbel":"@stdlib/random/array/gumbel","random.array.hypergeometric":"@stdlib/random/array/hypergeometric","random.array.invgamma":"@stdlib/random/array/invgamma","random.array.kumaraswamy":"@stdlib/random/array/kumaraswamy","random.array.laplace":"@stdlib/random/array/laplace","random.array.levy":"@stdlib/random/array/levy","random.array.logistic":"@stdlib/random/array/logistic","random.array.lognormal":"@stdlib/random/array/lognormal","random.array.minstd":"@stdlib/random/array/minstd","random.array.minstdShuffle":"@stdlib/random/array/minstd-shuffle","random.array.mt19937":"@stdlib/random/array/mt19937","random.array.negativeBinomial":"@stdlib/random/array/negative-binomial","random.array.normal":"@stdlib/random/array/normal","random.array.pareto1":"@stdlib/random/array/pareto-type1","random.array.poisson":"@stdlib/random/array/poisson","random.array.randu":"@stdlib/random/array/randu","random.array.rayleigh":"@stdlib/random/array/rayleigh","random.array.t":"@stdlib/random/array/t","random.array.triangular":"@stdlib/random/array/triangular","random.array.uniform":"@stdlib/random/array/uniform","random.array.weibull":"@stdlib/random/array/weibull","random.iterators.arcsine":"@stdlib/random/iter/arcsine","random.iterators.bernoulli":"@stdlib/random/iter/bernoulli","random.iterators.beta":"@stdlib/random/iter/beta","random.iterators.betaprime":"@stdlib/random/iter/betaprime","random.iterators.binomial":"@stdlib/random/iter/binomial","random.iterators.boxMuller":"@stdlib/random/iter/box-muller","random.iterators.cauchy":"@stdlib/random/iter/cauchy","random.iterators.chi":"@stdlib/random/iter/chi","random.iterators.chisquare":"@stdlib/random/iter/chisquare","random.iterators.cosine":"@stdlib/random/iter/cosine","random.iterators.discreteUniform":"@stdlib/random/iter/discrete-uniform","random.iterators.erlang":"@stdlib/random/iter/erlang","random.iterators.exponential":"@stdlib/random/iter/exponential","random.iterators.f":"@stdlib/random/iter/f","random.iterators.frechet":"@stdlib/random/iter/frechet","random.iterators.gamma":"@stdlib/random/iter/gamma","random.iterators.geometric":"@stdlib/random/iter/geometric","random.iterators.gumbel":"@stdlib/random/iter/gumbel","random.iterators.hypergeometric":"@stdlib/random/iter/hypergeometric","random.iterators.improvedZiggurat":"@stdlib/random/iter/improved-ziggurat","random.iterators.invgamma":"@stdlib/random/iter/invgamma","random.iterators.kumaraswamy":"@stdlib/random/iter/kumaraswamy","random.iterators.laplace":"@stdlib/random/iter/laplace","random.iterators.levy":"@stdlib/random/iter/levy","random.iterators.logistic":"@stdlib/random/iter/logistic","random.iterators.lognormal":"@stdlib/random/iter/lognormal","random.iterators.minstd":"@stdlib/random/iter/minstd","random.iterators.minstdShuffle":"@stdlib/random/iter/minstd-shuffle","random.iterators.mt19937":"@stdlib/random/iter/mt19937","random.iterators.negativeBinomial":"@stdlib/random/iter/negative-binomial","random.iterators.normal":"@stdlib/random/iter/normal","random.iterators.pareto1":"@stdlib/random/iter/pareto-type1","random.iterators.poisson":"@stdlib/random/iter/poisson","random.iterators.randi":"@stdlib/random/iter/randi","random.iterators.randn":"@stdlib/random/iter/randn","random.iterators.randu":"@stdlib/random/iter/randu","random.iterators.rayleigh":"@stdlib/random/iter/rayleigh","random.iterators.t":"@stdlib/random/iter/t","random.iterators.triangular":"@stdlib/random/iter/triangular","random.iterators.uniform":"@stdlib/random/iter/uniform","random.iterators.weibull":"@stdlib/random/iter/weibull","random.streams.arcsine":"@stdlib/random/streams/arcsine","random.streams.bernoulli":"@stdlib/random/streams/bernoulli","random.streams.beta":"@stdlib/random/streams/beta","random.streams.betaprime":"@stdlib/random/streams/betaprime","random.streams.binomial":"@stdlib/random/streams/binomial","random.streams.boxMuller":"@stdlib/random/streams/box-muller","random.streams.cauchy":"@stdlib/random/streams/cauchy","random.streams.chi":"@stdlib/random/streams/chi","random.streams.chisquare":"@stdlib/random/streams/chisquare","random.streams.cosine":"@stdlib/random/streams/cosine","random.streams.discreteUniform":"@stdlib/random/streams/discrete-uniform","random.streams.erlang":"@stdlib/random/streams/erlang","random.streams.exponential":"@stdlib/random/streams/exponential","random.streams.f":"@stdlib/random/streams/f","random.streams.frechet":"@stdlib/random/streams/frechet","random.streams.gamma":"@stdlib/random/streams/gamma","random.streams.geometric":"@stdlib/random/streams/geometric","random.streams.gumbel":"@stdlib/random/streams/gumbel","random.streams.hypergeometric":"@stdlib/random/streams/hypergeometric","random.streams.improvedZiggurat":"@stdlib/random/streams/improved-ziggurat","random.streams.invgamma":"@stdlib/random/streams/invgamma","random.streams.kumaraswamy":"@stdlib/random/streams/kumaraswamy","random.streams.laplace":"@stdlib/random/streams/laplace","random.streams.levy":"@stdlib/random/streams/levy","random.streams.logistic":"@stdlib/random/streams/logistic","random.streams.lognormal":"@stdlib/random/streams/lognormal","random.streams.minstd":"@stdlib/random/streams/minstd","random.streams.minstdShuffle":"@stdlib/random/streams/minstd-shuffle","random.streams.mt19937":"@stdlib/random/streams/mt19937","random.streams.negativeBinomial":"@stdlib/random/streams/negative-binomial","random.streams.normal":"@stdlib/random/streams/normal","random.streams.pareto1":"@stdlib/random/streams/pareto-type1","random.streams.poisson":"@stdlib/random/streams/poisson","random.streams.randi":"@stdlib/random/streams/randi","random.streams.randn":"@stdlib/random/streams/randn","random.streams.randu":"@stdlib/random/streams/randu","random.streams.rayleigh":"@stdlib/random/streams/rayleigh","random.streams.t":"@stdlib/random/streams/t","random.streams.triangular":"@stdlib/random/streams/triangular","random.streams.uniform":"@stdlib/random/streams/uniform","random.streams.weibull":"@stdlib/random/streams/weibull","random.strided.arcsine":"@stdlib/random/strided/arcsine","random.strided.bernoulli":"@stdlib/random/strided/bernoulli","random.strided.beta":"@stdlib/random/strided/beta","random.strided.betaprime":"@stdlib/random/strided/betaprime","random.strided.chi":"@stdlib/random/strided/chi","random.strided.chisquare":"@stdlib/random/strided/chisquare","random.strided.cosine":"@stdlib/random/strided/cosine","random.strided.discreteUniform":"@stdlib/random/strided/discrete-uniform","random.strided.exponential":"@stdlib/random/strided/exponential","random.strided.gamma":"@stdlib/random/strided/gamma","random.strided.geometric":"@stdlib/random/strided/geometric","random.strided.invgamma":"@stdlib/random/strided/invgamma","random.strided.lognormal":"@stdlib/random/strided/lognormal","random.strided.minstd":"@stdlib/random/strided/minstd","random.strided.minstdShuffle":"@stdlib/random/strided/minstd-shuffle","random.strided.mt19937":"@stdlib/random/strided/mt19937","random.strided.normal":"@stdlib/random/strided/normal","random.strided.poisson":"@stdlib/random/strided/poisson","random.strided.randu":"@stdlib/random/strided/randu","random.strided.rayleigh":"@stdlib/random/strided/rayleigh","random.strided.t":"@stdlib/random/strided/t","random.strided.uniform":"@stdlib/random/strided/uniform","random.strided.weibull":"@stdlib/random/strided/weibull","ranks":"@stdlib/stats/ranks","readDir":"@stdlib/fs/read-dir","readFile":"@stdlib/fs/read-file","readFileList":"@stdlib/fs/read-file-list","readJSON":"@stdlib/fs/read-json","readWASM":"@stdlib/fs/read-wasm","real":"@stdlib/complex/float64/real","realarray":"@stdlib/array/typed-real","realarrayCtors":"@stdlib/array/typed-real-ctors","realarrayDataTypes":"@stdlib/array/typed-real-dtypes","realf":"@stdlib/complex/float32/real","realmax":"@stdlib/utils/real-max","realmin":"@stdlib/utils/real-min","reBasename":"@stdlib/regexp/basename","reBasenamePosix":"@stdlib/regexp/basename-posix","reBasenameWindows":"@stdlib/regexp/basename-windows","reColorHexadecimal":"@stdlib/regexp/color-hexadecimal","reDecimalNumber":"@stdlib/regexp/decimal-number","reDirname":"@stdlib/regexp/dirname","reDirnamePosix":"@stdlib/regexp/dirname-posix","reDirnameWindows":"@stdlib/regexp/dirname-windows","reduce":"@stdlib/utils/reduce","reduce2d":"@stdlib/utils/reduce2d","reduceAsync":"@stdlib/utils/async/reduce","reduceRight":"@stdlib/utils/reduce-right","reduceRightAsync":"@stdlib/utils/async/reduce-right","reDurationString":"@stdlib/regexp/duration-string","reEOL":"@stdlib/regexp/eol","reExtendedLengthPath":"@stdlib/regexp/extended-length-path","reExtname":"@stdlib/regexp/extname","reExtnamePosix":"@stdlib/regexp/extname-posix","reExtnameWindows":"@stdlib/regexp/extname-windows","reFilename":"@stdlib/regexp/filename","reFilenamePosix":"@stdlib/regexp/filename-posix","reFilenameWindows":"@stdlib/regexp/filename-windows","reFromString":"@stdlib/utils/regexp-from-string","reFunctionName":"@stdlib/regexp/function-name","regexp2json":"@stdlib/regexp/to-json","reim":"@stdlib/complex/float64/reim","reimf":"@stdlib/complex/float32/reim","rejectArguments":"@stdlib/utils/reject-arguments","removeFirst":"@stdlib/string/remove-first","removeLast":"@stdlib/string/remove-last","removePunctuation":"@stdlib/string/remove-punctuation","removeUTF8BOM":"@stdlib/string/remove-utf8-bom","removeWords":"@stdlib/string/remove-words","rename":"@stdlib/fs/rename","reNativeFunction":"@stdlib/regexp/native-function","reorderArguments":"@stdlib/utils/reorder-arguments","repeat":"@stdlib/string/repeat","replace":"@stdlib/string/replace","replaceBefore":"@stdlib/string/replace-before","reRegExp":"@stdlib/regexp/regexp","rescape":"@stdlib/utils/escape-regexp-string","reSemVer":"@stdlib/regexp/semver","resolveParentPath":"@stdlib/fs/resolve-parent-path","resolveParentPathBy":"@stdlib/fs/resolve-parent-path-by","reUncPath":"@stdlib/regexp/unc-path","reUtf16SurrogatePair":"@stdlib/regexp/utf16-surrogate-pair","reUtf16UnpairedSurrogate":"@stdlib/regexp/utf16-unpaired-surrogate","reverseArguments":"@stdlib/utils/reverse-arguments","reverseString":"@stdlib/string/reverse","reviveBasePRNG":"@stdlib/random/base/reviver","reviveBuffer":"@stdlib/buffer/reviver","reviveComplex":"@stdlib/complex/reviver","reviveComplex64":"@stdlib/complex/float32/reviver","reviveComplex128":"@stdlib/complex/float64/reviver","reviveError":"@stdlib/error/reviver","reviveRegExp":"@stdlib/regexp/reviver","reviveTypedArray":"@stdlib/array/reviver","reWhitespace":"@stdlib/regexp/whitespace","rpad":"@stdlib/string/right-pad","rtrim":"@stdlib/string/right-trim","rtrimN":"@stdlib/string/right-trim-n","safeintmax":"@stdlib/utils/safe-int-max","safeintmin":"@stdlib/utils/safe-int-min","sample":"@stdlib/random/sample","SAVOY_STOPWORDS_FIN":"@stdlib/datasets/savoy-stopwords-fin","SAVOY_STOPWORDS_FR":"@stdlib/datasets/savoy-stopwords-fr","SAVOY_STOPWORDS_GER":"@stdlib/datasets/savoy-stopwords-ger","SAVOY_STOPWORDS_IT":"@stdlib/datasets/savoy-stopwords-it","SAVOY_STOPWORDS_POR":"@stdlib/datasets/savoy-stopwords-por","SAVOY_STOPWORDS_SP":"@stdlib/datasets/savoy-stopwords-sp","SAVOY_STOPWORDS_SWE":"@stdlib/datasets/savoy-stopwords-swe","scalar2array":"@stdlib/array/from-scalar","scalar2ndarray":"@stdlib/ndarray/from-scalar","sdot":"@stdlib/blas/sdot","SECONDS_IN_DAY":"@stdlib/constants/time/seconds-in-day","SECONDS_IN_HOUR":"@stdlib/constants/time/seconds-in-hour","SECONDS_IN_MINUTE":"@stdlib/constants/time/seconds-in-minute","SECONDS_IN_WEEK":"@stdlib/constants/time/seconds-in-week","secondsInMonth":"@stdlib/time/seconds-in-month","secondsInYear":"@stdlib/time/seconds-in-year","sentencize":"@stdlib/nlp/sentencize","seq2slice":"@stdlib/slice/seq2slice","setConfigurableReadOnly":"@stdlib/utils/define-configurable-read-only-property","setConfigurableReadOnlyAccessor":"@stdlib/utils/define-configurable-read-only-accessor","setConfigurableReadWriteAccessor":"@stdlib/utils/define-configurable-read-write-accessor","setConfigurableWriteOnlyAccessor":"@stdlib/utils/define-configurable-write-only-accessor","setMemoizedConfigurableReadOnly":"@stdlib/utils/define-memoized-configurable-read-only-property","setMemoizedReadOnly":"@stdlib/utils/define-memoized-read-only-property","setNonEnumerableProperty":"@stdlib/utils/define-nonenumerable-property","setNonEnumerableReadOnly":"@stdlib/utils/define-nonenumerable-read-only-property","setNonEnumerableReadOnlyAccessor":"@stdlib/utils/define-nonenumerable-read-only-accessor","setNonEnumerableReadWriteAccessor":"@stdlib/utils/define-nonenumerable-read-write-accessor","setNonEnumerableWriteOnlyAccessor":"@stdlib/utils/define-nonenumerable-write-only-accessor","setReadOnly":"@stdlib/utils/define-read-only-property","setReadOnlyAccessor":"@stdlib/utils/define-read-only-accessor","setReadWriteAccessor":"@stdlib/utils/define-read-write-accessor","setWriteOnlyAccessor":"@stdlib/utils/define-write-only-accessor","SharedArrayBuffer":"@stdlib/array/shared-buffer","shift":"@stdlib/utils/shift","shuffle":"@stdlib/random/shuffle","sizeOf":"@stdlib/utils/size-of","Slice":"@stdlib/slice/ctor","snakecase":"@stdlib/string/snakecase","some":"@stdlib/utils/some","someBy":"@stdlib/utils/some-by","someByAsync":"@stdlib/utils/async/some-by","someByRight":"@stdlib/utils/some-by-right","someByRightAsync":"@stdlib/utils/async/some-by-right","someInBy":"@stdlib/utils/some-in-by","someOwnBy":"@stdlib/utils/some-own-by","SOTU":"@stdlib/datasets/sotu","SPACHE_REVISED":"@stdlib/datasets/spache-revised","SPAM_ASSASSIN":"@stdlib/datasets/spam-assassin","SparklineBase":"@stdlib/plot/sparklines/base/ctor","sparsearray2iterator":"@stdlib/array/to-sparse-iterator","sparsearray2iteratorRight":"@stdlib/array/to-sparse-iterator-right","splitStream":"@stdlib/streams/node/split","SQRT_EPS":"@stdlib/constants/float64/sqrt-eps","SQRT_HALF":"@stdlib/constants/float64/sqrt-half","SQRT_HALF_PI":"@stdlib/constants/float64/sqrt-half-pi","SQRT_PHI":"@stdlib/constants/float64/sqrt-phi","SQRT_PI":"@stdlib/constants/float64/sqrt-pi","SQRT_THREE":"@stdlib/constants/float64/sqrt-three","SQRT_TWO":"@stdlib/constants/float64/sqrt-two","SQRT_TWO_PI":"@stdlib/constants/float64/sqrt-two-pi","SSA_US_BIRTHS_2000_2014":"@stdlib/datasets/ssa-us-births-2000-2014","sswap":"@stdlib/blas/sswap","Stack":"@stdlib/dstructs/stack","standalone2pkg":"@stdlib/namespace/standalone2pkg","STANDARD_CARD_DECK":"@stdlib/datasets/standard-card-deck","startcase":"@stdlib/string/startcase","startsWith":"@stdlib/string/starts-with","STOPWORDS_EN":"@stdlib/datasets/stopwords-en","strided.abs":"@stdlib/math/strided/special/abs","strided.abs2":"@stdlib/math/strided/special/abs2","strided.abs2By":"@stdlib/math/strided/special/abs2-by","strided.absBy":"@stdlib/math/strided/special/abs-by","strided.acosBy":"@stdlib/math/strided/special/acos-by","strided.acoshBy":"@stdlib/math/strided/special/acosh-by","strided.acotBy":"@stdlib/math/strided/special/acot-by","strided.acothBy":"@stdlib/math/strided/special/acoth-by","strided.acovercosBy":"@stdlib/math/strided/special/acovercos-by","strided.acoversinBy":"@stdlib/math/strided/special/acoversin-by","strided.add":"@stdlib/math/strided/ops/add","strided.addBy":"@stdlib/math/strided/ops/add-by","strided.ahavercosBy":"@stdlib/math/strided/special/ahavercos-by","strided.ahaversinBy":"@stdlib/math/strided/special/ahaversin-by","strided.asinBy":"@stdlib/math/strided/special/asin-by","strided.asinhBy":"@stdlib/math/strided/special/asinh-by","strided.atanBy":"@stdlib/math/strided/special/atan-by","strided.atanhBy":"@stdlib/math/strided/special/atanh-by","strided.avercosBy":"@stdlib/math/strided/special/avercos-by","strided.aversinBy":"@stdlib/math/strided/special/aversin-by","strided.besselj0By":"@stdlib/math/strided/special/besselj0-by","strided.besselj1By":"@stdlib/math/strided/special/besselj1-by","strided.bessely0By":"@stdlib/math/strided/special/bessely0-by","strided.bessely1By":"@stdlib/math/strided/special/bessely1-by","strided.binetBy":"@stdlib/math/strided/special/binet-by","strided.cbrt":"@stdlib/math/strided/special/cbrt","strided.cbrtBy":"@stdlib/math/strided/special/cbrt-by","strided.ceil":"@stdlib/math/strided/special/ceil","strided.cosBy":"@stdlib/math/strided/special/cos-by","strided.deg2rad":"@stdlib/math/strided/special/deg2rad","strided.dataTypes":"@stdlib/strided/dtypes","strided.dcbrtBy":"@stdlib/math/strided/special/dcbrt-by","strided.dispatch":"@stdlib/strided/dispatch","strided.dispatchBy":"@stdlib/strided/dispatch-by","strided.floor":"@stdlib/math/strided/special/floor","strided.inv":"@stdlib/math/strided/special/inv","strided.mul":"@stdlib/math/strided/ops/mul","strided.mulBy":"@stdlib/math/strided/ops/mul-by","strided.ramp":"@stdlib/math/strided/special/ramp","strided.rsqrt":"@stdlib/math/strided/special/rsqrt","strided.sinBy":"@stdlib/math/strided/special/sin-by","strided.sqrt":"@stdlib/math/strided/special/sqrt","strided.sqrtBy":"@stdlib/math/strided/special/sqrt-by","strided.sub":"@stdlib/math/strided/ops/sub","strided.subBy":"@stdlib/math/strided/ops/sub-by","strided.trunc":"@stdlib/math/strided/special/trunc","stridedarray2iterator":"@stdlib/array/to-strided-iterator","stridedArrayStream":"@stdlib/streams/node/from-strided-array","string2buffer":"@stdlib/buffer/from-string","sub2ind":"@stdlib/ndarray/sub2ind","substringAfter":"@stdlib/string/substring-after","substringAfterLast":"@stdlib/string/substring-after-last","substringBefore":"@stdlib/string/substring-before","substringBeforeLast":"@stdlib/string/substring-before-last","SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK":"@stdlib/datasets/suthaharan-multi-hop-sensor-network","SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK":"@stdlib/datasets/suthaharan-single-hop-sensor-network","Symbol":"@stdlib/symbol/ctor","tabulate":"@stdlib/utils/tabulate","tabulateBy":"@stdlib/utils/tabulate-by","tabulateByAsync":"@stdlib/utils/async/tabulate-by","thunk":"@stdlib/function/thunk","tic":"@stdlib/time/tic","timeit":"@stdlib/utils/timeit","tmpdir":"@stdlib/os/tmpdir","toc":"@stdlib/time/toc","tokenize":"@stdlib/nlp/tokenize","transformStream":"@stdlib/streams/node/transform","trim":"@stdlib/string/trim","truncate":"@stdlib/string/truncate","truncateMiddle":"@stdlib/string/truncate-middle","trycatch":"@stdlib/utils/try-catch","trycatchAsync":"@stdlib/utils/async/try-catch","tryFunction":"@stdlib/utils/try-function","tryRequire":"@stdlib/utils/try-require","trythen":"@stdlib/utils/try-then","trythenAsync":"@stdlib/utils/async/try-then","ttest":"@stdlib/stats/ttest","ttest2":"@stdlib/stats/ttest2","TWO_PI":"@stdlib/constants/float64/two-pi","typedarray":"@stdlib/array/typed","typedarray2json":"@stdlib/array/to-json","typedarrayCtors":"@stdlib/array/typed-ctors","typedarrayDataTypes":"@stdlib/array/typed-dtypes","typedarraypool":"@stdlib/array/pool","typemax":"@stdlib/utils/type-max","typemin":"@stdlib/utils/type-min","typeOf":"@stdlib/utils/type-of","UINT8_MAX":"@stdlib/constants/uint8/max","UINT8_NUM_BYTES":"@stdlib/constants/uint8/num-bytes","Uint8Array":"@stdlib/array/uint8","Uint8ClampedArray":"@stdlib/array/uint8c","UINT16_MAX":"@stdlib/constants/uint16/max","UINT16_NUM_BYTES":"@stdlib/constants/uint16/num-bytes","Uint16Array":"@stdlib/array/uint16","UINT32_MAX":"@stdlib/constants/uint32/max","UINT32_NUM_BYTES":"@stdlib/constants/uint32/num-bytes","Uint32Array":"@stdlib/array/uint32","umask":"@stdlib/process/umask","uncapitalize":"@stdlib/string/uncapitalize","uncapitalizeKeys":"@stdlib/utils/uncapitalize-keys","uncurry":"@stdlib/utils/uncurry","uncurryRight":"@stdlib/utils/uncurry-right","UNICODE_MAX":"@stdlib/constants/unicode/max","UNICODE_MAX_BMP":"@stdlib/constants/unicode/max-bmp","UnicodeColumnChartSparkline":"@stdlib/plot/sparklines/unicode/column","UnicodeLineChartSparkline":"@stdlib/plot/sparklines/unicode/line","UnicodeSparkline":"@stdlib/plot/sparklines/unicode","UnicodeTristateChartSparkline":"@stdlib/plot/sparklines/unicode/tristate","UnicodeUpDownChartSparkline":"@stdlib/plot/sparklines/unicode/up-down","UnicodeWinLossChartSparkline":"@stdlib/plot/sparklines/unicode/win-loss","unlink":"@stdlib/fs/unlink","unshift":"@stdlib/utils/unshift","until":"@stdlib/utils/until","untilAsync":"@stdlib/utils/async/until","untilEach":"@stdlib/utils/until-each","untilEachRight":"@stdlib/utils/until-each-right","unzip":"@stdlib/utils/unzip","uppercase":"@stdlib/string/uppercase","uppercaseKeys":"@stdlib/utils/uppercase-keys","US_STATES_ABBR":"@stdlib/datasets/us-states-abbr","US_STATES_CAPITALS":"@stdlib/datasets/us-states-capitals","US_STATES_CAPITALS_NAMES":"@stdlib/datasets/us-states-capitals-names","US_STATES_NAMES":"@stdlib/datasets/us-states-names","US_STATES_NAMES_CAPITALS":"@stdlib/datasets/us-states-names-capitals","utf16ToUTF8Array":"@stdlib/string/utf16-to-utf8-array","vartest":"@stdlib/stats/vartest","waterfall":"@stdlib/utils/async/series-waterfall","WebAssemblyMemory":"@stdlib/wasm/memory","whileAsync":"@stdlib/utils/async/while","whileEach":"@stdlib/utils/while-each","whileEachRight":"@stdlib/utils/while-each-right","whilst":"@stdlib/utils/while","wilcoxon":"@stdlib/stats/wilcoxon","writableProperties":"@stdlib/utils/writable-properties","writablePropertiesIn":"@stdlib/utils/writable-properties-in","writablePropertyNames":"@stdlib/utils/writable-property-names","writablePropertyNamesIn":"@stdlib/utils/writable-property-names-in","writablePropertySymbols":"@stdlib/utils/writable-property-symbols","writablePropertySymbolsIn":"@stdlib/utils/writable-property-symbols-in","writeFile":"@stdlib/fs/write-file","zip":"@stdlib/utils/zip","ztest":"@stdlib/stats/ztest","ztest2":"@stdlib/stats/ztest2"} diff --git a/lib/node_modules/@stdlib/namespace/lib/namespace/base/u.js b/lib/node_modules/@stdlib/namespace/lib/namespace/base/u.js index 28d43eedc2e5..9aa3c250bc7a 100644 --- a/lib/node_modules/@stdlib/namespace/lib/namespace/base/u.js +++ b/lib/node_modules/@stdlib/namespace/lib/namespace/base/u.js @@ -36,8 +36,8 @@ ns.push({ ns.push({ 'alias': 'base.umul', - 'path': '@stdlib/math/base/ops/umul', - 'value': require( '@stdlib/math/base/ops/umul' ), + 'path': '@stdlib/number/uint32/base/mul', + 'value': require( '@stdlib/number/uint32/base/mul' ), 'type': 'Function', 'related': [ '@stdlib/math/base/ops/imul' @@ -51,7 +51,7 @@ ns.push({ 'type': 'Function', 'related': [ '@stdlib/math/base/ops/imuldw', - '@stdlib/math/base/ops/umul' + '@stdlib/number/uint32/base/mul' ] }); diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv index 57bf06981023..017c5b1fb855 100644 --- a/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv +++ b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv @@ -1480,7 +1480,7 @@ "@stdlib/math/base/special/truncn",base.truncn "@stdlib/math/base/special/truncsd",base.truncsd "@stdlib/number/uint32/base/to-int32",base.uint32ToInt32 -"@stdlib/math/base/ops/umul",base.umul +"@stdlib/number/uint32/base/mul",base.umul "@stdlib/math/base/ops/umuldw",base.umuldw "@stdlib/string/base/uncapitalize",base.uncapitalize "@stdlib/string/base/uppercase",base.uppercase diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json index 13eac9abd0cf..bd871068bdf3 100644 --- a/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json +++ b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json @@ -1 +1 @@ -{"@stdlib/math/special/abs":"abs","@stdlib/array/cartesian-power":"acartesianPower","@stdlib/array/cartesian-product":"acartesianProduct","@stdlib/array/cartesian-square":"acartesianSquare","@stdlib/string/acronym":"acronym","@stdlib/array/empty":"aempty","@stdlib/array/empty-like":"aemptyLike","@stdlib/datasets/afinn-96":"AFINN_96","@stdlib/datasets/afinn-111":"AFINN_111","@stdlib/array/full":"afull","@stdlib/array/full-like":"afullLike","@stdlib/namespace/alias2pkg":"alias2pkg","@stdlib/namespace/alias2related":"alias2related","@stdlib/namespace/alias2standalone":"alias2standalone","@stdlib/namespace/aliases":"aliases","@stdlib/buffer/alloc-unsafe":"allocUnsafe","@stdlib/array/mskfilter":"amskfilter","@stdlib/array/mskput":"amskput","@stdlib/array/mskreject":"amskreject","@stdlib/array/nans":"anans","@stdlib/array/nans-like":"anansLike","@stdlib/stats/anova1":"anova1","@stdlib/datasets/anscombes-quartet":"ANSCOMBES_QUARTET","@stdlib/utils/any":"any","@stdlib/utils/any-by":"anyBy","@stdlib/utils/async/any-by":"anyByAsync","@stdlib/utils/any-by-right":"anyByRight","@stdlib/utils/async/any-by-right":"anyByRightAsync","@stdlib/utils/any-in-by":"anyInBy","@stdlib/utils/any-own-by":"anyOwnBy","@stdlib/array/ones":"aones","@stdlib/array/ones-like":"aonesLike","@stdlib/array/one-to":"aoneTo","@stdlib/array/one-to-like":"aoneToLike","@stdlib/constants/float64/apery":"APERY","@stdlib/array/place":"aplace","@stdlib/utils/append":"append","@stdlib/array/put":"aput","@stdlib/os/arch":"ARCH","@stdlib/utils/argument-function":"argumentFunction","@stdlib/process/argv":"ARGV","@stdlib/ndarray/array":"array","@stdlib/buffer/from-array":"array2buffer","@stdlib/array/to-fancy":"array2fancy","@stdlib/array/to-iterator":"array2iterator","@stdlib/array/to-iterator-right":"array2iteratorRight","@stdlib/array/buffer":"ArrayBuffer","@stdlib/buffer/from-arraybuffer":"arraybuffer2buffer","@stdlib/array/ctors":"arrayCtors","@stdlib/array/dtype":"arrayDataType","@stdlib/array/dtypes":"arrayDataTypes","@stdlib/array/index":"ArrayIndex","@stdlib/array/min-dtype":"arrayMinDataType","@stdlib/array/mostly-safe-casts":"arrayMostlySafeCasts","@stdlib/array/next-dtype":"arrayNextDataType","@stdlib/array/promotion-rules":"arrayPromotionRules","@stdlib/array/safe-casts":"arraySafeCasts","@stdlib/array/same-kind-casts":"arraySameKindCasts","@stdlib/array/shape":"arrayShape","@stdlib/streams/node/from-array":"arrayStream","@stdlib/array/to-view-iterator":"arrayview2iterator","@stdlib/array/to-view-iterator-right":"arrayview2iteratorRight","@stdlib/array/slice":"aslice","@stdlib/symbol/async-iterator":"AsyncIteratorSymbol","@stdlib/array/take":"atake","@stdlib/array/zeros":"azeros","@stdlib/array/zeros-like":"azerosLike","@stdlib/array/zero-to":"azeroTo","@stdlib/array/zero-to-like":"azeroToLike","@stdlib/stats/bartlett-test":"bartlettTest","@stdlib/math/base/special/abs":"base.abs","@stdlib/math/base/special/abs2":"base.abs2","@stdlib/math/base/special/abs2f":"base.abs2f","@stdlib/math/base/utils/absolute-difference":"base.absdiff","@stdlib/math/base/special/absf":"base.absf","@stdlib/array/base/cartesian-power":"base.acartesianPower","@stdlib/array/base/cartesian-product":"base.acartesianProduct","@stdlib/array/base/cartesian-square":"base.acartesianSquare","@stdlib/math/base/special/acos":"base.acos","@stdlib/math/base/special/acosd":"base.acosd","@stdlib/math/base/special/acosf":"base.acosf","@stdlib/math/base/special/acosh":"base.acosh","@stdlib/math/base/special/acot":"base.acot","@stdlib/math/base/special/acotd":"base.acotd","@stdlib/math/base/special/acotf":"base.acotf","@stdlib/math/base/special/acoth":"base.acoth","@stdlib/math/base/special/acovercos":"base.acovercos","@stdlib/math/base/special/acoversin":"base.acoversin","@stdlib/math/base/special/acsc":"base.acsc","@stdlib/math/base/special/acscd":"base.acscd","@stdlib/math/base/special/acscdf":"base.acscdf","@stdlib/math/base/special/acscf":"base.acscf","@stdlib/math/base/special/acsch":"base.acsch","@stdlib/number/float64/base/add":"base.add","@stdlib/number/float64/base/add3":"base.add3","@stdlib/number/float64/base/add4":"base.add4","@stdlib/number/float64/base/add5":"base.add5","@stdlib/number/float32/base/add":"base.addf","@stdlib/array/base/filled":"base.afilled","@stdlib/array/base/filled2d":"base.afilled2d","@stdlib/array/base/filled2d-by":"base.afilled2dBy","@stdlib/array/base/filled3d":"base.afilled3d","@stdlib/array/base/filled3d-by":"base.afilled3dBy","@stdlib/array/base/filled4d":"base.afilled4d","@stdlib/array/base/filled4d-by":"base.afilled4dBy","@stdlib/array/base/filled5d":"base.afilled5d","@stdlib/array/base/filled5d-by":"base.afilled5dBy","@stdlib/array/base/filled-by":"base.afilledBy","@stdlib/array/base/fillednd":"base.afillednd","@stdlib/array/base/fillednd-by":"base.afilledndBy","@stdlib/array/base/filter":"base.afilter","@stdlib/array/base/first":"base.afirst","@stdlib/array/base/flatten":"base.aflatten","@stdlib/array/base/flatten2d":"base.aflatten2d","@stdlib/array/base/flatten2d-by":"base.aflatten2dBy","@stdlib/array/base/flatten3d":"base.aflatten3d","@stdlib/array/base/flatten3d-by":"base.aflatten3dBy","@stdlib/array/base/flatten4d":"base.aflatten4d","@stdlib/array/base/flatten4d-by":"base.aflatten4dBy","@stdlib/array/base/flatten5d":"base.aflatten5d","@stdlib/array/base/flatten5d-by":"base.aflatten5dBy","@stdlib/array/base/flatten-by":"base.aflattenBy","@stdlib/array/base/fliplr2d":"base.afliplr2d","@stdlib/array/base/fliplr3d":"base.afliplr3d","@stdlib/array/base/fliplr4d":"base.afliplr4d","@stdlib/array/base/fliplr5d":"base.afliplr5d","@stdlib/array/base/flipud2d":"base.aflipud2d","@stdlib/array/base/flipud3d":"base.aflipud3d","@stdlib/array/base/flipud4d":"base.aflipud4d","@stdlib/array/base/flipud5d":"base.aflipud5d","@stdlib/math/base/special/ahavercos":"base.ahavercos","@stdlib/math/base/special/ahaversin":"base.ahaversin","@stdlib/string/base/altcase":"base.altcase","@stdlib/array/base/ones":"base.aones","@stdlib/array/base/ones2d":"base.aones2d","@stdlib/array/base/ones3d":"base.aones3d","@stdlib/array/base/ones4d":"base.aones4d","@stdlib/array/base/ones5d":"base.aones5d","@stdlib/array/base/onesnd":"base.aonesnd","@stdlib/array/base/one-to":"base.aoneTo","@stdlib/slice/base/args2multislice":"base.args2multislice","@stdlib/math/base/special/asec":"base.asec","@stdlib/math/base/special/asecd":"base.asecd","@stdlib/math/base/special/asecdf":"base.asecdf","@stdlib/math/base/special/asecf":"base.asecf","@stdlib/math/base/special/asech":"base.asech","@stdlib/math/base/special/asin":"base.asin","@stdlib/math/base/special/asind":"base.asind","@stdlib/math/base/special/asindf":"base.asindf","@stdlib/math/base/special/asinf":"base.asinf","@stdlib/math/base/special/asinh":"base.asinh","@stdlib/math/base/special/atan":"base.atan","@stdlib/math/base/special/atan2":"base.atan2","@stdlib/math/base/special/atand":"base.atand","@stdlib/math/base/special/atanf":"base.atanf","@stdlib/math/base/special/atanh":"base.atanh","@stdlib/math/base/special/avercos":"base.avercos","@stdlib/math/base/special/aversin":"base.aversin","@stdlib/array/base/zeros":"base.azeros","@stdlib/array/base/zeros2d":"base.azeros2d","@stdlib/array/base/zeros3d":"base.azeros3d","@stdlib/array/base/zeros4d":"base.azeros4d","@stdlib/array/base/zeros5d":"base.azeros5d","@stdlib/array/base/zerosnd":"base.azerosnd","@stdlib/array/base/zero-to":"base.azeroTo","@stdlib/math/base/special/bernoulli":"base.bernoulli","@stdlib/math/base/special/besselj0":"base.besselj0","@stdlib/math/base/special/besselj1":"base.besselj1","@stdlib/math/base/special/bessely0":"base.bessely0","@stdlib/math/base/special/bessely1":"base.bessely1","@stdlib/math/base/special/beta":"base.beta","@stdlib/math/base/special/betainc":"base.betainc","@stdlib/math/base/special/betaincinv":"base.betaincinv","@stdlib/math/base/special/betaln":"base.betaln","@stdlib/math/base/special/binet":"base.binet","@stdlib/math/base/special/binomcoef":"base.binomcoef","@stdlib/math/base/special/binomcoefln":"base.binomcoefln","@stdlib/math/base/special/boxcox":"base.boxcox","@stdlib/math/base/special/boxcox1p":"base.boxcox1p","@stdlib/math/base/special/boxcox1pinv":"base.boxcox1pinv","@stdlib/math/base/special/boxcoxinv":"base.boxcoxinv","@stdlib/math/base/special/cabs":"base.cabs","@stdlib/math/base/special/cabs2":"base.cabs2","@stdlib/math/base/special/cabs2f":"base.cabs2f","@stdlib/math/base/special/cabsf":"base.cabsf","@stdlib/complex/float64/base/add":"base.cadd","@stdlib/complex/float32/base/add":"base.caddf","@stdlib/string/base/camelcase":"base.camelcase","@stdlib/string/base/capitalize":"base.capitalize","@stdlib/math/base/special/cbrt":"base.cbrt","@stdlib/math/base/special/cbrtf":"base.cbrtf","@stdlib/math/base/special/cceil":"base.cceil","@stdlib/math/base/special/cceilf":"base.cceilf","@stdlib/math/base/special/cceiln":"base.cceiln","@stdlib/math/base/special/ccis":"base.ccis","@stdlib/math/base/ops/cdiv":"base.cdiv","@stdlib/math/base/special/ceil":"base.ceil","@stdlib/math/base/special/ceil2":"base.ceil2","@stdlib/math/base/special/ceil10":"base.ceil10","@stdlib/math/base/special/ceilb":"base.ceilb","@stdlib/math/base/special/ceilf":"base.ceilf","@stdlib/math/base/special/ceiln":"base.ceiln","@stdlib/math/base/special/ceilsd":"base.ceilsd","@stdlib/math/base/special/cexp":"base.cexp","@stdlib/math/base/special/cflipsign":"base.cflipsign","@stdlib/math/base/special/cflipsignf":"base.cflipsignf","@stdlib/math/base/special/cfloor":"base.cfloor","@stdlib/math/base/special/cfloorn":"base.cfloorn","@stdlib/math/base/special/cidentity":"base.cidentity","@stdlib/math/base/special/cidentityf":"base.cidentityf","@stdlib/math/base/special/cinv":"base.cinv","@stdlib/math/base/special/clamp":"base.clamp","@stdlib/math/base/special/clampf":"base.clampf","@stdlib/complex/float64/base/mul":"base.cmul","@stdlib/complex/float32/base/mul":"base.cmulf","@stdlib/math/base/ops/cneg":"base.cneg","@stdlib/math/base/ops/cnegf":"base.cnegf","@stdlib/string/base/code-point-at":"base.codePointAt","@stdlib/string/base/constantcase":"base.constantcase","@stdlib/math/base/tools/continued-fraction":"base.continuedFraction","@stdlib/math/base/special/copysign":"base.copysign","@stdlib/math/base/special/copysignf":"base.copysignf","@stdlib/math/base/special/cos":"base.cos","@stdlib/math/base/special/cosd":"base.cosd","@stdlib/math/base/special/cosh":"base.cosh","@stdlib/math/base/special/cosm1":"base.cosm1","@stdlib/math/base/special/cospi":"base.cospi","@stdlib/math/base/special/cot":"base.cot","@stdlib/math/base/special/cotd":"base.cotd","@stdlib/math/base/special/coth":"base.coth","@stdlib/math/base/special/covercos":"base.covercos","@stdlib/math/base/special/coversin":"base.coversin","@stdlib/math/base/special/cphase":"base.cphase","@stdlib/math/base/special/cpolar":"base.cpolar","@stdlib/math/base/special/cround":"base.cround","@stdlib/math/base/special/croundn":"base.croundn","@stdlib/math/base/special/csc":"base.csc","@stdlib/math/base/special/cscd":"base.cscd","@stdlib/math/base/special/csch":"base.csch","@stdlib/math/base/special/csignum":"base.csignum","@stdlib/math/base/ops/csub":"base.csub","@stdlib/math/base/ops/csubf":"base.csubf","@stdlib/math/base/special/deg2rad":"base.deg2rad","@stdlib/math/base/special/deg2radf":"base.deg2radf","@stdlib/math/base/special/digamma":"base.digamma","@stdlib/math/base/special/dirac-delta":"base.diracDelta","@stdlib/number/float64/base/div":"base.div","@stdlib/number/float32/base/div":"base.divf","@stdlib/string/base/dotcase":"base.dotcase","@stdlib/stats/base/dists/arcsine/ctor":"base.dists.arcsine.Arcsine","@stdlib/stats/base/dists/arcsine/cdf":"base.dists.arcsine.cdf","@stdlib/stats/base/dists/arcsine/entropy":"base.dists.arcsine.entropy","@stdlib/stats/base/dists/arcsine/kurtosis":"base.dists.arcsine.kurtosis","@stdlib/stats/base/dists/arcsine/logcdf":"base.dists.arcsine.logcdf","@stdlib/stats/base/dists/arcsine/logpdf":"base.dists.arcsine.logpdf","@stdlib/stats/base/dists/arcsine/mean":"base.dists.arcsine.mean","@stdlib/stats/base/dists/arcsine/median":"base.dists.arcsine.median","@stdlib/stats/base/dists/arcsine/mode":"base.dists.arcsine.mode","@stdlib/stats/base/dists/arcsine/pdf":"base.dists.arcsine.pdf","@stdlib/stats/base/dists/arcsine/quantile":"base.dists.arcsine.quantile","@stdlib/stats/base/dists/arcsine/skewness":"base.dists.arcsine.skewness","@stdlib/stats/base/dists/arcsine/stdev":"base.dists.arcsine.stdev","@stdlib/stats/base/dists/arcsine/variance":"base.dists.arcsine.variance","@stdlib/stats/base/dists/bernoulli/ctor":"base.dists.bernoulli.Bernoulli","@stdlib/stats/base/dists/bernoulli/cdf":"base.dists.bernoulli.cdf","@stdlib/stats/base/dists/bernoulli/entropy":"base.dists.bernoulli.entropy","@stdlib/stats/base/dists/bernoulli/kurtosis":"base.dists.bernoulli.kurtosis","@stdlib/stats/base/dists/bernoulli/mean":"base.dists.bernoulli.mean","@stdlib/stats/base/dists/bernoulli/median":"base.dists.bernoulli.median","@stdlib/stats/base/dists/bernoulli/mgf":"base.dists.bernoulli.mgf","@stdlib/stats/base/dists/bernoulli/mode":"base.dists.bernoulli.mode","@stdlib/stats/base/dists/bernoulli/pmf":"base.dists.bernoulli.pmf","@stdlib/stats/base/dists/bernoulli/quantile":"base.dists.bernoulli.quantile","@stdlib/stats/base/dists/bernoulli/skewness":"base.dists.bernoulli.skewness","@stdlib/stats/base/dists/bernoulli/stdev":"base.dists.bernoulli.stdev","@stdlib/stats/base/dists/bernoulli/variance":"base.dists.bernoulli.variance","@stdlib/stats/base/dists/beta/ctor":"base.dists.beta.Beta","@stdlib/stats/base/dists/beta/cdf":"base.dists.beta.cdf","@stdlib/stats/base/dists/beta/entropy":"base.dists.beta.entropy","@stdlib/stats/base/dists/beta/kurtosis":"base.dists.beta.kurtosis","@stdlib/stats/base/dists/beta/logcdf":"base.dists.beta.logcdf","@stdlib/stats/base/dists/beta/logpdf":"base.dists.beta.logpdf","@stdlib/stats/base/dists/beta/mean":"base.dists.beta.mean","@stdlib/stats/base/dists/beta/median":"base.dists.beta.median","@stdlib/stats/base/dists/beta/mgf":"base.dists.beta.mgf","@stdlib/stats/base/dists/beta/mode":"base.dists.beta.mode","@stdlib/stats/base/dists/beta/pdf":"base.dists.beta.pdf","@stdlib/stats/base/dists/beta/quantile":"base.dists.beta.quantile","@stdlib/stats/base/dists/beta/skewness":"base.dists.beta.skewness","@stdlib/stats/base/dists/beta/stdev":"base.dists.beta.stdev","@stdlib/stats/base/dists/beta/variance":"base.dists.beta.variance","@stdlib/stats/base/dists/betaprime/ctor":"base.dists.betaprime.BetaPrime","@stdlib/stats/base/dists/betaprime/cdf":"base.dists.betaprime.cdf","@stdlib/stats/base/dists/betaprime/kurtosis":"base.dists.betaprime.kurtosis","@stdlib/stats/base/dists/betaprime/logcdf":"base.dists.betaprime.logcdf","@stdlib/stats/base/dists/betaprime/logpdf":"base.dists.betaprime.logpdf","@stdlib/stats/base/dists/betaprime/mean":"base.dists.betaprime.mean","@stdlib/stats/base/dists/betaprime/mode":"base.dists.betaprime.mode","@stdlib/stats/base/dists/betaprime/pdf":"base.dists.betaprime.pdf","@stdlib/stats/base/dists/betaprime/quantile":"base.dists.betaprime.quantile","@stdlib/stats/base/dists/betaprime/skewness":"base.dists.betaprime.skewness","@stdlib/stats/base/dists/betaprime/stdev":"base.dists.betaprime.stdev","@stdlib/stats/base/dists/betaprime/variance":"base.dists.betaprime.variance","@stdlib/stats/base/dists/binomial/ctor":"base.dists.binomial.Binomial","@stdlib/stats/base/dists/binomial/cdf":"base.dists.binomial.cdf","@stdlib/stats/base/dists/binomial/entropy":"base.dists.binomial.entropy","@stdlib/stats/base/dists/binomial/kurtosis":"base.dists.binomial.kurtosis","@stdlib/stats/base/dists/binomial/logpmf":"base.dists.binomial.logpmf","@stdlib/stats/base/dists/binomial/mean":"base.dists.binomial.mean","@stdlib/stats/base/dists/binomial/median":"base.dists.binomial.median","@stdlib/stats/base/dists/binomial/mgf":"base.dists.binomial.mgf","@stdlib/stats/base/dists/binomial/mode":"base.dists.binomial.mode","@stdlib/stats/base/dists/binomial/pmf":"base.dists.binomial.pmf","@stdlib/stats/base/dists/binomial/quantile":"base.dists.binomial.quantile","@stdlib/stats/base/dists/binomial/skewness":"base.dists.binomial.skewness","@stdlib/stats/base/dists/binomial/stdev":"base.dists.binomial.stdev","@stdlib/stats/base/dists/binomial/variance":"base.dists.binomial.variance","@stdlib/stats/base/dists/cauchy/ctor":"base.dists.cauchy.Cauchy","@stdlib/stats/base/dists/cauchy/cdf":"base.dists.cauchy.cdf","@stdlib/stats/base/dists/cauchy/entropy":"base.dists.cauchy.entropy","@stdlib/stats/base/dists/cauchy/logcdf":"base.dists.cauchy.logcdf","@stdlib/stats/base/dists/cauchy/logpdf":"base.dists.cauchy.logpdf","@stdlib/stats/base/dists/cauchy/median":"base.dists.cauchy.median","@stdlib/stats/base/dists/cauchy/mode":"base.dists.cauchy.mode","@stdlib/stats/base/dists/cauchy/pdf":"base.dists.cauchy.pdf","@stdlib/stats/base/dists/cauchy/quantile":"base.dists.cauchy.quantile","@stdlib/stats/base/dists/chi/cdf":"base.dists.chi.cdf","@stdlib/stats/base/dists/chi/ctor":"base.dists.chi.Chi","@stdlib/stats/base/dists/chi/entropy":"base.dists.chi.entropy","@stdlib/stats/base/dists/chi/kurtosis":"base.dists.chi.kurtosis","@stdlib/stats/base/dists/chi/logpdf":"base.dists.chi.logpdf","@stdlib/stats/base/dists/chi/mean":"base.dists.chi.mean","@stdlib/stats/base/dists/chi/mode":"base.dists.chi.mode","@stdlib/stats/base/dists/chi/pdf":"base.dists.chi.pdf","@stdlib/stats/base/dists/chi/quantile":"base.dists.chi.quantile","@stdlib/stats/base/dists/chi/skewness":"base.dists.chi.skewness","@stdlib/stats/base/dists/chi/stdev":"base.dists.chi.stdev","@stdlib/stats/base/dists/chi/variance":"base.dists.chi.variance","@stdlib/stats/base/dists/chisquare/cdf":"base.dists.chisquare.cdf","@stdlib/stats/base/dists/chisquare/ctor":"base.dists.chisquare.ChiSquare","@stdlib/stats/base/dists/chisquare/entropy":"base.dists.chisquare.entropy","@stdlib/stats/base/dists/chisquare/kurtosis":"base.dists.chisquare.kurtosis","@stdlib/stats/base/dists/chisquare/logpdf":"base.dists.chisquare.logpdf","@stdlib/stats/base/dists/chisquare/mean":"base.dists.chisquare.mean","@stdlib/stats/base/dists/chisquare/median":"base.dists.chisquare.median","@stdlib/stats/base/dists/chisquare/mgf":"base.dists.chisquare.mgf","@stdlib/stats/base/dists/chisquare/mode":"base.dists.chisquare.mode","@stdlib/stats/base/dists/chisquare/pdf":"base.dists.chisquare.pdf","@stdlib/stats/base/dists/chisquare/quantile":"base.dists.chisquare.quantile","@stdlib/stats/base/dists/chisquare/skewness":"base.dists.chisquare.skewness","@stdlib/stats/base/dists/chisquare/stdev":"base.dists.chisquare.stdev","@stdlib/stats/base/dists/chisquare/variance":"base.dists.chisquare.variance","@stdlib/stats/base/dists/cosine/cdf":"base.dists.cosine.cdf","@stdlib/stats/base/dists/cosine/ctor":"base.dists.cosine.Cosine","@stdlib/stats/base/dists/cosine/kurtosis":"base.dists.cosine.kurtosis","@stdlib/stats/base/dists/cosine/logcdf":"base.dists.cosine.logcdf","@stdlib/stats/base/dists/cosine/logpdf":"base.dists.cosine.logpdf","@stdlib/stats/base/dists/cosine/mean":"base.dists.cosine.mean","@stdlib/stats/base/dists/cosine/median":"base.dists.cosine.median","@stdlib/stats/base/dists/cosine/mgf":"base.dists.cosine.mgf","@stdlib/stats/base/dists/cosine/mode":"base.dists.cosine.mode","@stdlib/stats/base/dists/cosine/pdf":"base.dists.cosine.pdf","@stdlib/stats/base/dists/cosine/quantile":"base.dists.cosine.quantile","@stdlib/stats/base/dists/cosine/skewness":"base.dists.cosine.skewness","@stdlib/stats/base/dists/cosine/stdev":"base.dists.cosine.stdev","@stdlib/stats/base/dists/cosine/variance":"base.dists.cosine.variance","@stdlib/stats/base/dists/degenerate/cdf":"base.dists.degenerate.cdf","@stdlib/stats/base/dists/degenerate/ctor":"base.dists.degenerate.Degenerate","@stdlib/stats/base/dists/degenerate/entropy":"base.dists.degenerate.entropy","@stdlib/stats/base/dists/degenerate/logcdf":"base.dists.degenerate.logcdf","@stdlib/stats/base/dists/degenerate/logpdf":"base.dists.degenerate.logpdf","@stdlib/stats/base/dists/degenerate/logpmf":"base.dists.degenerate.logpmf","@stdlib/stats/base/dists/degenerate/mean":"base.dists.degenerate.mean","@stdlib/stats/base/dists/degenerate/median":"base.dists.degenerate.median","@stdlib/stats/base/dists/degenerate/mgf":"base.dists.degenerate.mgf","@stdlib/stats/base/dists/degenerate/mode":"base.dists.degenerate.mode","@stdlib/stats/base/dists/degenerate/pdf":"base.dists.degenerate.pdf","@stdlib/stats/base/dists/degenerate/pmf":"base.dists.degenerate.pmf","@stdlib/stats/base/dists/degenerate/quantile":"base.dists.degenerate.quantile","@stdlib/stats/base/dists/degenerate/stdev":"base.dists.degenerate.stdev","@stdlib/stats/base/dists/degenerate/variance":"base.dists.degenerate.variance","@stdlib/stats/base/dists/discrete-uniform/cdf":"base.dists.discreteUniform.cdf","@stdlib/stats/base/dists/discrete-uniform/ctor":"base.dists.discreteUniform.DiscreteUniform","@stdlib/stats/base/dists/discrete-uniform/entropy":"base.dists.discreteUniform.entropy","@stdlib/stats/base/dists/discrete-uniform/kurtosis":"base.dists.discreteUniform.kurtosis","@stdlib/stats/base/dists/discrete-uniform/logcdf":"base.dists.discreteUniform.logcdf","@stdlib/stats/base/dists/discrete-uniform/logpmf":"base.dists.discreteUniform.logpmf","@stdlib/stats/base/dists/discrete-uniform/mean":"base.dists.discreteUniform.mean","@stdlib/stats/base/dists/discrete-uniform/median":"base.dists.discreteUniform.median","@stdlib/stats/base/dists/discrete-uniform/mgf":"base.dists.discreteUniform.mgf","@stdlib/stats/base/dists/discrete-uniform/pmf":"base.dists.discreteUniform.pmf","@stdlib/stats/base/dists/discrete-uniform/quantile":"base.dists.discreteUniform.quantile","@stdlib/stats/base/dists/discrete-uniform/skewness":"base.dists.discreteUniform.skewness","@stdlib/stats/base/dists/discrete-uniform/stdev":"base.dists.discreteUniform.stdev","@stdlib/stats/base/dists/discrete-uniform/variance":"base.dists.discreteUniform.variance","@stdlib/stats/base/dists/erlang/cdf":"base.dists.erlang.cdf","@stdlib/stats/base/dists/erlang/entropy":"base.dists.erlang.entropy","@stdlib/stats/base/dists/erlang/ctor":"base.dists.erlang.Erlang","@stdlib/stats/base/dists/erlang/kurtosis":"base.dists.erlang.kurtosis","@stdlib/stats/base/dists/erlang/logpdf":"base.dists.erlang.logpdf","@stdlib/stats/base/dists/erlang/mean":"base.dists.erlang.mean","@stdlib/stats/base/dists/erlang/mgf":"base.dists.erlang.mgf","@stdlib/stats/base/dists/erlang/mode":"base.dists.erlang.mode","@stdlib/stats/base/dists/erlang/pdf":"base.dists.erlang.pdf","@stdlib/stats/base/dists/erlang/quantile":"base.dists.erlang.quantile","@stdlib/stats/base/dists/erlang/skewness":"base.dists.erlang.skewness","@stdlib/stats/base/dists/erlang/stdev":"base.dists.erlang.stdev","@stdlib/stats/base/dists/erlang/variance":"base.dists.erlang.variance","@stdlib/stats/base/dists/exponential/cdf":"base.dists.exponential.cdf","@stdlib/stats/base/dists/exponential/entropy":"base.dists.exponential.entropy","@stdlib/stats/base/dists/exponential/ctor":"base.dists.exponential.Exponential","@stdlib/stats/base/dists/exponential/kurtosis":"base.dists.exponential.kurtosis","@stdlib/stats/base/dists/exponential/logcdf":"base.dists.exponential.logcdf","@stdlib/stats/base/dists/exponential/logpdf":"base.dists.exponential.logpdf","@stdlib/stats/base/dists/exponential/mean":"base.dists.exponential.mean","@stdlib/stats/base/dists/exponential/median":"base.dists.exponential.median","@stdlib/stats/base/dists/exponential/mgf":"base.dists.exponential.mgf","@stdlib/stats/base/dists/exponential/mode":"base.dists.exponential.mode","@stdlib/stats/base/dists/exponential/pdf":"base.dists.exponential.pdf","@stdlib/stats/base/dists/exponential/quantile":"base.dists.exponential.quantile","@stdlib/stats/base/dists/exponential/skewness":"base.dists.exponential.skewness","@stdlib/stats/base/dists/exponential/stdev":"base.dists.exponential.stdev","@stdlib/stats/base/dists/exponential/variance":"base.dists.exponential.variance","@stdlib/stats/base/dists/f/cdf":"base.dists.f.cdf","@stdlib/stats/base/dists/f/entropy":"base.dists.f.entropy","@stdlib/stats/base/dists/f/ctor":"base.dists.f.F","@stdlib/stats/base/dists/f/kurtosis":"base.dists.f.kurtosis","@stdlib/stats/base/dists/f/mean":"base.dists.f.mean","@stdlib/stats/base/dists/f/mode":"base.dists.f.mode","@stdlib/stats/base/dists/f/pdf":"base.dists.f.pdf","@stdlib/stats/base/dists/f/quantile":"base.dists.f.quantile","@stdlib/stats/base/dists/f/skewness":"base.dists.f.skewness","@stdlib/stats/base/dists/f/stdev":"base.dists.f.stdev","@stdlib/stats/base/dists/f/variance":"base.dists.f.variance","@stdlib/stats/base/dists/frechet/cdf":"base.dists.frechet.cdf","@stdlib/stats/base/dists/frechet/entropy":"base.dists.frechet.entropy","@stdlib/stats/base/dists/frechet/ctor":"base.dists.frechet.Frechet","@stdlib/stats/base/dists/frechet/kurtosis":"base.dists.frechet.kurtosis","@stdlib/stats/base/dists/frechet/logcdf":"base.dists.frechet.logcdf","@stdlib/stats/base/dists/frechet/logpdf":"base.dists.frechet.logpdf","@stdlib/stats/base/dists/frechet/mean":"base.dists.frechet.mean","@stdlib/stats/base/dists/frechet/median":"base.dists.frechet.median","@stdlib/stats/base/dists/frechet/mode":"base.dists.frechet.mode","@stdlib/stats/base/dists/frechet/pdf":"base.dists.frechet.pdf","@stdlib/stats/base/dists/frechet/quantile":"base.dists.frechet.quantile","@stdlib/stats/base/dists/frechet/skewness":"base.dists.frechet.skewness","@stdlib/stats/base/dists/frechet/stdev":"base.dists.frechet.stdev","@stdlib/stats/base/dists/frechet/variance":"base.dists.frechet.variance","@stdlib/stats/base/dists/gamma/cdf":"base.dists.gamma.cdf","@stdlib/stats/base/dists/gamma/entropy":"base.dists.gamma.entropy","@stdlib/stats/base/dists/gamma/ctor":"base.dists.gamma.Gamma","@stdlib/stats/base/dists/gamma/kurtosis":"base.dists.gamma.kurtosis","@stdlib/stats/base/dists/gamma/logcdf":"base.dists.gamma.logcdf","@stdlib/stats/base/dists/gamma/logpdf":"base.dists.gamma.logpdf","@stdlib/stats/base/dists/gamma/mean":"base.dists.gamma.mean","@stdlib/stats/base/dists/gamma/mgf":"base.dists.gamma.mgf","@stdlib/stats/base/dists/gamma/mode":"base.dists.gamma.mode","@stdlib/stats/base/dists/gamma/pdf":"base.dists.gamma.pdf","@stdlib/stats/base/dists/gamma/quantile":"base.dists.gamma.quantile","@stdlib/stats/base/dists/gamma/skewness":"base.dists.gamma.skewness","@stdlib/stats/base/dists/gamma/stdev":"base.dists.gamma.stdev","@stdlib/stats/base/dists/gamma/variance":"base.dists.gamma.variance","@stdlib/stats/base/dists/geometric/cdf":"base.dists.geometric.cdf","@stdlib/stats/base/dists/geometric/entropy":"base.dists.geometric.entropy","@stdlib/stats/base/dists/geometric/ctor":"base.dists.geometric.Geometric","@stdlib/stats/base/dists/geometric/kurtosis":"base.dists.geometric.kurtosis","@stdlib/stats/base/dists/geometric/logcdf":"base.dists.geometric.logcdf","@stdlib/stats/base/dists/geometric/logpmf":"base.dists.geometric.logpmf","@stdlib/stats/base/dists/geometric/mean":"base.dists.geometric.mean","@stdlib/stats/base/dists/geometric/median":"base.dists.geometric.median","@stdlib/stats/base/dists/geometric/mgf":"base.dists.geometric.mgf","@stdlib/stats/base/dists/geometric/mode":"base.dists.geometric.mode","@stdlib/stats/base/dists/geometric/pmf":"base.dists.geometric.pmf","@stdlib/stats/base/dists/geometric/quantile":"base.dists.geometric.quantile","@stdlib/stats/base/dists/geometric/skewness":"base.dists.geometric.skewness","@stdlib/stats/base/dists/geometric/stdev":"base.dists.geometric.stdev","@stdlib/stats/base/dists/geometric/variance":"base.dists.geometric.variance","@stdlib/stats/base/dists/gumbel/cdf":"base.dists.gumbel.cdf","@stdlib/stats/base/dists/gumbel/entropy":"base.dists.gumbel.entropy","@stdlib/stats/base/dists/gumbel/ctor":"base.dists.gumbel.Gumbel","@stdlib/stats/base/dists/gumbel/kurtosis":"base.dists.gumbel.kurtosis","@stdlib/stats/base/dists/gumbel/logcdf":"base.dists.gumbel.logcdf","@stdlib/stats/base/dists/gumbel/logpdf":"base.dists.gumbel.logpdf","@stdlib/stats/base/dists/gumbel/mean":"base.dists.gumbel.mean","@stdlib/stats/base/dists/gumbel/median":"base.dists.gumbel.median","@stdlib/stats/base/dists/gumbel/mgf":"base.dists.gumbel.mgf","@stdlib/stats/base/dists/gumbel/mode":"base.dists.gumbel.mode","@stdlib/stats/base/dists/gumbel/pdf":"base.dists.gumbel.pdf","@stdlib/stats/base/dists/gumbel/quantile":"base.dists.gumbel.quantile","@stdlib/stats/base/dists/gumbel/skewness":"base.dists.gumbel.skewness","@stdlib/stats/base/dists/gumbel/stdev":"base.dists.gumbel.stdev","@stdlib/stats/base/dists/gumbel/variance":"base.dists.gumbel.variance","@stdlib/stats/base/dists/hypergeometric/cdf":"base.dists.hypergeometric.cdf","@stdlib/stats/base/dists/hypergeometric/ctor":"base.dists.hypergeometric.Hypergeometric","@stdlib/stats/base/dists/hypergeometric/kurtosis":"base.dists.hypergeometric.kurtosis","@stdlib/stats/base/dists/hypergeometric/logpmf":"base.dists.hypergeometric.logpmf","@stdlib/stats/base/dists/hypergeometric/mean":"base.dists.hypergeometric.mean","@stdlib/stats/base/dists/hypergeometric/mode":"base.dists.hypergeometric.mode","@stdlib/stats/base/dists/hypergeometric/pmf":"base.dists.hypergeometric.pmf","@stdlib/stats/base/dists/hypergeometric/quantile":"base.dists.hypergeometric.quantile","@stdlib/stats/base/dists/hypergeometric/skewness":"base.dists.hypergeometric.skewness","@stdlib/stats/base/dists/hypergeometric/stdev":"base.dists.hypergeometric.stdev","@stdlib/stats/base/dists/hypergeometric/variance":"base.dists.hypergeometric.variance","@stdlib/stats/base/dists/invgamma/cdf":"base.dists.invgamma.cdf","@stdlib/stats/base/dists/invgamma/entropy":"base.dists.invgamma.entropy","@stdlib/stats/base/dists/invgamma/ctor":"base.dists.invgamma.InvGamma","@stdlib/stats/base/dists/invgamma/kurtosis":"base.dists.invgamma.kurtosis","@stdlib/stats/base/dists/invgamma/logpdf":"base.dists.invgamma.logpdf","@stdlib/stats/base/dists/invgamma/mean":"base.dists.invgamma.mean","@stdlib/stats/base/dists/invgamma/mode":"base.dists.invgamma.mode","@stdlib/stats/base/dists/invgamma/pdf":"base.dists.invgamma.pdf","@stdlib/stats/base/dists/invgamma/quantile":"base.dists.invgamma.quantile","@stdlib/stats/base/dists/invgamma/skewness":"base.dists.invgamma.skewness","@stdlib/stats/base/dists/invgamma/stdev":"base.dists.invgamma.stdev","@stdlib/stats/base/dists/invgamma/variance":"base.dists.invgamma.variance","@stdlib/stats/base/dists/kumaraswamy/cdf":"base.dists.kumaraswamy.cdf","@stdlib/stats/base/dists/kumaraswamy/ctor":"base.dists.kumaraswamy.Kumaraswamy","@stdlib/stats/base/dists/kumaraswamy/kurtosis":"base.dists.kumaraswamy.kurtosis","@stdlib/stats/base/dists/kumaraswamy/logcdf":"base.dists.kumaraswamy.logcdf","@stdlib/stats/base/dists/kumaraswamy/logpdf":"base.dists.kumaraswamy.logpdf","@stdlib/stats/base/dists/kumaraswamy/mean":"base.dists.kumaraswamy.mean","@stdlib/stats/base/dists/kumaraswamy/median":"base.dists.kumaraswamy.median","@stdlib/stats/base/dists/kumaraswamy/mode":"base.dists.kumaraswamy.mode","@stdlib/stats/base/dists/kumaraswamy/pdf":"base.dists.kumaraswamy.pdf","@stdlib/stats/base/dists/kumaraswamy/quantile":"base.dists.kumaraswamy.quantile","@stdlib/stats/base/dists/kumaraswamy/skewness":"base.dists.kumaraswamy.skewness","@stdlib/stats/base/dists/kumaraswamy/stdev":"base.dists.kumaraswamy.stdev","@stdlib/stats/base/dists/kumaraswamy/variance":"base.dists.kumaraswamy.variance","@stdlib/stats/base/dists/laplace/cdf":"base.dists.laplace.cdf","@stdlib/stats/base/dists/laplace/entropy":"base.dists.laplace.entropy","@stdlib/stats/base/dists/laplace/kurtosis":"base.dists.laplace.kurtosis","@stdlib/stats/base/dists/laplace/ctor":"base.dists.laplace.Laplace","@stdlib/stats/base/dists/laplace/logcdf":"base.dists.laplace.logcdf","@stdlib/stats/base/dists/laplace/logpdf":"base.dists.laplace.logpdf","@stdlib/stats/base/dists/laplace/mean":"base.dists.laplace.mean","@stdlib/stats/base/dists/laplace/median":"base.dists.laplace.median","@stdlib/stats/base/dists/laplace/mgf":"base.dists.laplace.mgf","@stdlib/stats/base/dists/laplace/mode":"base.dists.laplace.mode","@stdlib/stats/base/dists/laplace/pdf":"base.dists.laplace.pdf","@stdlib/stats/base/dists/laplace/quantile":"base.dists.laplace.quantile","@stdlib/stats/base/dists/laplace/skewness":"base.dists.laplace.skewness","@stdlib/stats/base/dists/laplace/stdev":"base.dists.laplace.stdev","@stdlib/stats/base/dists/laplace/variance":"base.dists.laplace.variance","@stdlib/stats/base/dists/levy/cdf":"base.dists.levy.cdf","@stdlib/stats/base/dists/levy/entropy":"base.dists.levy.entropy","@stdlib/stats/base/dists/levy/ctor":"base.dists.levy.Levy","@stdlib/stats/base/dists/levy/logcdf":"base.dists.levy.logcdf","@stdlib/stats/base/dists/levy/logpdf":"base.dists.levy.logpdf","@stdlib/stats/base/dists/levy/mean":"base.dists.levy.mean","@stdlib/stats/base/dists/levy/median":"base.dists.levy.median","@stdlib/stats/base/dists/levy/mode":"base.dists.levy.mode","@stdlib/stats/base/dists/levy/pdf":"base.dists.levy.pdf","@stdlib/stats/base/dists/levy/quantile":"base.dists.levy.quantile","@stdlib/stats/base/dists/levy/stdev":"base.dists.levy.stdev","@stdlib/stats/base/dists/levy/variance":"base.dists.levy.variance","@stdlib/stats/base/dists/logistic/cdf":"base.dists.logistic.cdf","@stdlib/stats/base/dists/logistic/entropy":"base.dists.logistic.entropy","@stdlib/stats/base/dists/logistic/kurtosis":"base.dists.logistic.kurtosis","@stdlib/stats/base/dists/logistic/logcdf":"base.dists.logistic.logcdf","@stdlib/stats/base/dists/logistic/ctor":"base.dists.logistic.Logistic","@stdlib/stats/base/dists/logistic/logpdf":"base.dists.logistic.logpdf","@stdlib/stats/base/dists/logistic/mean":"base.dists.logistic.mean","@stdlib/stats/base/dists/logistic/median":"base.dists.logistic.median","@stdlib/stats/base/dists/logistic/mgf":"base.dists.logistic.mgf","@stdlib/stats/base/dists/logistic/mode":"base.dists.logistic.mode","@stdlib/stats/base/dists/logistic/pdf":"base.dists.logistic.pdf","@stdlib/stats/base/dists/logistic/quantile":"base.dists.logistic.quantile","@stdlib/stats/base/dists/logistic/skewness":"base.dists.logistic.skewness","@stdlib/stats/base/dists/logistic/stdev":"base.dists.logistic.stdev","@stdlib/stats/base/dists/logistic/variance":"base.dists.logistic.variance","@stdlib/stats/base/dists/lognormal/cdf":"base.dists.lognormal.cdf","@stdlib/stats/base/dists/lognormal/entropy":"base.dists.lognormal.entropy","@stdlib/stats/base/dists/lognormal/kurtosis":"base.dists.lognormal.kurtosis","@stdlib/stats/base/dists/lognormal/ctor":"base.dists.lognormal.LogNormal","@stdlib/stats/base/dists/lognormal/logcdf":"base.dists.lognormal.logcdf","@stdlib/stats/base/dists/lognormal/logpdf":"base.dists.lognormal.logpdf","@stdlib/stats/base/dists/lognormal/mean":"base.dists.lognormal.mean","@stdlib/stats/base/dists/lognormal/median":"base.dists.lognormal.median","@stdlib/stats/base/dists/lognormal/mode":"base.dists.lognormal.mode","@stdlib/stats/base/dists/lognormal/pdf":"base.dists.lognormal.pdf","@stdlib/stats/base/dists/lognormal/quantile":"base.dists.lognormal.quantile","@stdlib/stats/base/dists/lognormal/skewness":"base.dists.lognormal.skewness","@stdlib/stats/base/dists/lognormal/stdev":"base.dists.lognormal.stdev","@stdlib/stats/base/dists/lognormal/variance":"base.dists.lognormal.variance","@stdlib/stats/base/dists/negative-binomial/cdf":"base.dists.negativeBinomial.cdf","@stdlib/stats/base/dists/negative-binomial/kurtosis":"base.dists.negativeBinomial.kurtosis","@stdlib/stats/base/dists/negative-binomial/logpmf":"base.dists.negativeBinomial.logpmf","@stdlib/stats/base/dists/negative-binomial/mean":"base.dists.negativeBinomial.mean","@stdlib/stats/base/dists/negative-binomial/mgf":"base.dists.negativeBinomial.mgf","@stdlib/stats/base/dists/negative-binomial/mode":"base.dists.negativeBinomial.mode","@stdlib/stats/base/dists/negative-binomial/ctor":"base.dists.negativeBinomial.NegativeBinomial","@stdlib/stats/base/dists/negative-binomial/pmf":"base.dists.negativeBinomial.pmf","@stdlib/stats/base/dists/negative-binomial/quantile":"base.dists.negativeBinomial.quantile","@stdlib/stats/base/dists/negative-binomial/skewness":"base.dists.negativeBinomial.skewness","@stdlib/stats/base/dists/negative-binomial/stdev":"base.dists.negativeBinomial.stdev","@stdlib/stats/base/dists/negative-binomial/variance":"base.dists.negativeBinomial.variance","@stdlib/stats/base/dists/normal/cdf":"base.dists.normal.cdf","@stdlib/stats/base/dists/normal/entropy":"base.dists.normal.entropy","@stdlib/stats/base/dists/normal/kurtosis":"base.dists.normal.kurtosis","@stdlib/stats/base/dists/normal/logcdf":"base.dists.normal.logcdf","@stdlib/stats/base/dists/normal/logpdf":"base.dists.normal.logpdf","@stdlib/stats/base/dists/normal/mean":"base.dists.normal.mean","@stdlib/stats/base/dists/normal/median":"base.dists.normal.median","@stdlib/stats/base/dists/normal/mgf":"base.dists.normal.mgf","@stdlib/stats/base/dists/normal/mode":"base.dists.normal.mode","@stdlib/stats/base/dists/normal/ctor":"base.dists.normal.Normal","@stdlib/stats/base/dists/normal/pdf":"base.dists.normal.pdf","@stdlib/stats/base/dists/normal/quantile":"base.dists.normal.quantile","@stdlib/stats/base/dists/normal/skewness":"base.dists.normal.skewness","@stdlib/stats/base/dists/normal/stdev":"base.dists.normal.stdev","@stdlib/stats/base/dists/normal/variance":"base.dists.normal.variance","@stdlib/stats/base/dists/pareto-type1/cdf":"base.dists.pareto1.cdf","@stdlib/stats/base/dists/pareto-type1/entropy":"base.dists.pareto1.entropy","@stdlib/stats/base/dists/pareto-type1/kurtosis":"base.dists.pareto1.kurtosis","@stdlib/stats/base/dists/pareto-type1/logcdf":"base.dists.pareto1.logcdf","@stdlib/stats/base/dists/pareto-type1/logpdf":"base.dists.pareto1.logpdf","@stdlib/stats/base/dists/pareto-type1/mean":"base.dists.pareto1.mean","@stdlib/stats/base/dists/pareto-type1/median":"base.dists.pareto1.median","@stdlib/stats/base/dists/pareto-type1/mode":"base.dists.pareto1.mode","@stdlib/stats/base/dists/pareto-type1/ctor":"base.dists.pareto1.Pareto1","@stdlib/stats/base/dists/pareto-type1/pdf":"base.dists.pareto1.pdf","@stdlib/stats/base/dists/pareto-type1/quantile":"base.dists.pareto1.quantile","@stdlib/stats/base/dists/pareto-type1/skewness":"base.dists.pareto1.skewness","@stdlib/stats/base/dists/pareto-type1/stdev":"base.dists.pareto1.stdev","@stdlib/stats/base/dists/pareto-type1/variance":"base.dists.pareto1.variance","@stdlib/stats/base/dists/poisson/cdf":"base.dists.poisson.cdf","@stdlib/stats/base/dists/poisson/entropy":"base.dists.poisson.entropy","@stdlib/stats/base/dists/poisson/kurtosis":"base.dists.poisson.kurtosis","@stdlib/stats/base/dists/poisson/logpmf":"base.dists.poisson.logpmf","@stdlib/stats/base/dists/poisson/mean":"base.dists.poisson.mean","@stdlib/stats/base/dists/poisson/median":"base.dists.poisson.median","@stdlib/stats/base/dists/poisson/mgf":"base.dists.poisson.mgf","@stdlib/stats/base/dists/poisson/mode":"base.dists.poisson.mode","@stdlib/stats/base/dists/poisson/pmf":"base.dists.poisson.pmf","@stdlib/stats/base/dists/poisson/ctor":"base.dists.poisson.Poisson","@stdlib/stats/base/dists/poisson/quantile":"base.dists.poisson.quantile","@stdlib/stats/base/dists/poisson/skewness":"base.dists.poisson.skewness","@stdlib/stats/base/dists/poisson/stdev":"base.dists.poisson.stdev","@stdlib/stats/base/dists/poisson/variance":"base.dists.poisson.variance","@stdlib/stats/base/dists/rayleigh/cdf":"base.dists.rayleigh.cdf","@stdlib/stats/base/dists/rayleigh/entropy":"base.dists.rayleigh.entropy","@stdlib/stats/base/dists/rayleigh/kurtosis":"base.dists.rayleigh.kurtosis","@stdlib/stats/base/dists/rayleigh/logcdf":"base.dists.rayleigh.logcdf","@stdlib/stats/base/dists/rayleigh/logpdf":"base.dists.rayleigh.logpdf","@stdlib/stats/base/dists/rayleigh/mean":"base.dists.rayleigh.mean","@stdlib/stats/base/dists/rayleigh/median":"base.dists.rayleigh.median","@stdlib/stats/base/dists/rayleigh/mgf":"base.dists.rayleigh.mgf","@stdlib/stats/base/dists/rayleigh/mode":"base.dists.rayleigh.mode","@stdlib/stats/base/dists/rayleigh/pdf":"base.dists.rayleigh.pdf","@stdlib/stats/base/dists/rayleigh/quantile":"base.dists.rayleigh.quantile","@stdlib/stats/base/dists/rayleigh/ctor":"base.dists.rayleigh.Rayleigh","@stdlib/stats/base/dists/rayleigh/skewness":"base.dists.rayleigh.skewness","@stdlib/stats/base/dists/rayleigh/stdev":"base.dists.rayleigh.stdev","@stdlib/stats/base/dists/rayleigh/variance":"base.dists.rayleigh.variance","@stdlib/stats/base/dists/signrank/cdf":"base.dists.signrank.cdf","@stdlib/stats/base/dists/signrank/pdf":"base.dists.signrank.pdf","@stdlib/stats/base/dists/signrank/quantile":"base.dists.signrank.quantile","@stdlib/stats/base/dists/studentized-range/cdf":"base.dists.studentizedRange.cdf","@stdlib/stats/base/dists/studentized-range/quantile":"base.dists.studentizedRange.quantile","@stdlib/stats/base/dists/t/cdf":"base.dists.t.cdf","@stdlib/stats/base/dists/t/entropy":"base.dists.t.entropy","@stdlib/stats/base/dists/t/kurtosis":"base.dists.t.kurtosis","@stdlib/stats/base/dists/t/logcdf":"base.dists.t.logcdf","@stdlib/stats/base/dists/t/logpdf":"base.dists.t.logpdf","@stdlib/stats/base/dists/t/mean":"base.dists.t.mean","@stdlib/stats/base/dists/t/median":"base.dists.t.median","@stdlib/stats/base/dists/t/mode":"base.dists.t.mode","@stdlib/stats/base/dists/t/pdf":"base.dists.t.pdf","@stdlib/stats/base/dists/t/quantile":"base.dists.t.quantile","@stdlib/stats/base/dists/t/skewness":"base.dists.t.skewness","@stdlib/stats/base/dists/t/stdev":"base.dists.t.stdev","@stdlib/stats/base/dists/t/ctor":"base.dists.t.T","@stdlib/stats/base/dists/t/variance":"base.dists.t.variance","@stdlib/stats/base/dists/triangular/cdf":"base.dists.triangular.cdf","@stdlib/stats/base/dists/triangular/entropy":"base.dists.triangular.entropy","@stdlib/stats/base/dists/triangular/kurtosis":"base.dists.triangular.kurtosis","@stdlib/stats/base/dists/triangular/logcdf":"base.dists.triangular.logcdf","@stdlib/stats/base/dists/triangular/logpdf":"base.dists.triangular.logpdf","@stdlib/stats/base/dists/triangular/mean":"base.dists.triangular.mean","@stdlib/stats/base/dists/triangular/median":"base.dists.triangular.median","@stdlib/stats/base/dists/triangular/mgf":"base.dists.triangular.mgf","@stdlib/stats/base/dists/triangular/mode":"base.dists.triangular.mode","@stdlib/stats/base/dists/triangular/pdf":"base.dists.triangular.pdf","@stdlib/stats/base/dists/triangular/quantile":"base.dists.triangular.quantile","@stdlib/stats/base/dists/triangular/skewness":"base.dists.triangular.skewness","@stdlib/stats/base/dists/triangular/stdev":"base.dists.triangular.stdev","@stdlib/stats/base/dists/triangular/ctor":"base.dists.triangular.Triangular","@stdlib/stats/base/dists/triangular/variance":"base.dists.triangular.variance","@stdlib/stats/base/dists/truncated-normal/pdf":"base.dists.truncatedNormal.pdf","@stdlib/stats/base/dists/uniform/cdf":"base.dists.uniform.cdf","@stdlib/stats/base/dists/uniform/entropy":"base.dists.uniform.entropy","@stdlib/stats/base/dists/uniform/kurtosis":"base.dists.uniform.kurtosis","@stdlib/stats/base/dists/uniform/logcdf":"base.dists.uniform.logcdf","@stdlib/stats/base/dists/uniform/logpdf":"base.dists.uniform.logpdf","@stdlib/stats/base/dists/uniform/mean":"base.dists.uniform.mean","@stdlib/stats/base/dists/uniform/median":"base.dists.uniform.median","@stdlib/stats/base/dists/uniform/mgf":"base.dists.uniform.mgf","@stdlib/stats/base/dists/uniform/pdf":"base.dists.uniform.pdf","@stdlib/stats/base/dists/uniform/quantile":"base.dists.uniform.quantile","@stdlib/stats/base/dists/uniform/skewness":"base.dists.uniform.skewness","@stdlib/stats/base/dists/uniform/stdev":"base.dists.uniform.stdev","@stdlib/stats/base/dists/uniform/ctor":"base.dists.uniform.Uniform","@stdlib/stats/base/dists/uniform/variance":"base.dists.uniform.variance","@stdlib/stats/base/dists/weibull/cdf":"base.dists.weibull.cdf","@stdlib/stats/base/dists/weibull/entropy":"base.dists.weibull.entropy","@stdlib/stats/base/dists/weibull/kurtosis":"base.dists.weibull.kurtosis","@stdlib/stats/base/dists/weibull/logcdf":"base.dists.weibull.logcdf","@stdlib/stats/base/dists/weibull/logpdf":"base.dists.weibull.logpdf","@stdlib/stats/base/dists/weibull/mean":"base.dists.weibull.mean","@stdlib/stats/base/dists/weibull/median":"base.dists.weibull.median","@stdlib/stats/base/dists/weibull/mgf":"base.dists.weibull.mgf","@stdlib/stats/base/dists/weibull/mode":"base.dists.weibull.mode","@stdlib/stats/base/dists/weibull/pdf":"base.dists.weibull.pdf","@stdlib/stats/base/dists/weibull/quantile":"base.dists.weibull.quantile","@stdlib/stats/base/dists/weibull/skewness":"base.dists.weibull.skewness","@stdlib/stats/base/dists/weibull/stdev":"base.dists.weibull.stdev","@stdlib/stats/base/dists/weibull/variance":"base.dists.weibull.variance","@stdlib/stats/base/dists/weibull/ctor":"base.dists.weibull.Weibull","@stdlib/math/base/special/ellipe":"base.ellipe","@stdlib/math/base/special/ellipj":"base.ellipj","@stdlib/math/base/special/ellipk":"base.ellipk","@stdlib/string/base/ends-with":"base.endsWith","@stdlib/math/base/utils/float64-epsilon-difference":"base.epsdiff","@stdlib/math/base/special/erf":"base.erf","@stdlib/math/base/special/erfc":"base.erfc","@stdlib/math/base/special/erfcinv":"base.erfcinv","@stdlib/math/base/special/erfcx":"base.erfcx","@stdlib/math/base/special/erfinv":"base.erfinv","@stdlib/math/base/special/dirichlet-eta":"base.eta","@stdlib/math/base/tools/evalpoly":"base.evalpoly","@stdlib/math/base/tools/evalrational":"base.evalrational","@stdlib/math/base/special/exp":"base.exp","@stdlib/math/base/special/exp2":"base.exp2","@stdlib/math/base/special/exp10":"base.exp10","@stdlib/math/base/special/expit":"base.expit","@stdlib/math/base/special/expm1":"base.expm1","@stdlib/math/base/special/expm1rel":"base.expm1rel","@stdlib/number/float64/base/exponent":"base.exponent","@stdlib/number/float32/base/exponent":"base.exponentf","@stdlib/math/base/special/factorial":"base.factorial","@stdlib/math/base/special/factorial2":"base.factorial2","@stdlib/math/base/special/factorialln":"base.factorialln","@stdlib/math/base/special/falling-factorial":"base.fallingFactorial","@stdlib/math/base/special/fibonacci":"base.fibonacci","@stdlib/math/base/special/fibonacci-index":"base.fibonacciIndex","@stdlib/math/base/tools/fibpoly":"base.fibpoly","@stdlib/string/base/first-code-point":"base.firstCodePoint","@stdlib/string/base/first":"base.firstCodeUnit","@stdlib/string/base/first-grapheme-cluster":"base.firstGraphemeCluster","@stdlib/math/base/special/flipsign":"base.flipsign","@stdlib/math/base/special/flipsignf":"base.flipsignf","@stdlib/number/float32/base/to-int32":"base.float32ToInt32","@stdlib/number/float32/base/to-uint32":"base.float32ToUint32","@stdlib/number/float64/base/to-float32":"base.float64ToFloat32","@stdlib/number/float64/base/to-int32":"base.float64ToInt32","@stdlib/number/float64/base/to-int64-bytes":"base.float64ToInt64Bytes","@stdlib/number/float64/base/to-uint32":"base.float64ToUint32","@stdlib/math/base/special/floor":"base.floor","@stdlib/math/base/special/floor2":"base.floor2","@stdlib/math/base/special/floor10":"base.floor10","@stdlib/math/base/special/floorb":"base.floorb","@stdlib/math/base/special/floorf":"base.floorf","@stdlib/math/base/special/floorn":"base.floorn","@stdlib/math/base/special/floorsd":"base.floorsd","@stdlib/string/base/for-each":"base.forEachChar","@stdlib/string/base/for-each-code-point":"base.forEachCodePoint","@stdlib/string/base/for-each-code-point-right":"base.forEachCodePointRight","@stdlib/string/base/for-each-grapheme-cluster":"base.forEachGraphemeCluster","@stdlib/string/base/for-each-right":"base.forEachRight","@stdlib/string/base/format-interpolate":"base.formatInterpolate","@stdlib/string/base/format-tokenize":"base.formatTokenize","@stdlib/math/base/special/fresnel":"base.fresnel","@stdlib/math/base/special/fresnelc":"base.fresnelc","@stdlib/math/base/special/fresnels":"base.fresnels","@stdlib/math/base/special/frexp":"base.frexp","@stdlib/number/float64/base/from-binary-string":"base.fromBinaryString","@stdlib/number/float32/base/from-binary-string":"base.fromBinaryStringf","@stdlib/number/uint8/base/from-binary-string":"base.fromBinaryStringUint8","@stdlib/number/uint16/base/from-binary-string":"base.fromBinaryStringUint16","@stdlib/number/uint32/base/from-binary-string":"base.fromBinaryStringUint32","@stdlib/number/float64/base/from-int64-bytes":"base.fromInt64Bytes","@stdlib/number/float32/base/from-word":"base.fromWordf","@stdlib/number/float64/base/from-words":"base.fromWords","@stdlib/math/base/special/gamma":"base.gamma","@stdlib/math/base/special/gamma1pm1":"base.gamma1pm1","@stdlib/math/base/special/gamma-delta-ratio":"base.gammaDeltaRatio","@stdlib/math/base/special/gammainc":"base.gammainc","@stdlib/math/base/special/gammaincinv":"base.gammaincinv","@stdlib/math/base/special/gamma-lanczos-sum":"base.gammaLanczosSum","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":"base.gammaLanczosSumExpGScaled","@stdlib/math/base/special/gammaln":"base.gammaln","@stdlib/math/base/special/gammasgn":"base.gammasgn","@stdlib/math/base/special/gcd":"base.gcd","@stdlib/number/float64/base/get-high-word":"base.getHighWord","@stdlib/number/float64/base/get-low-word":"base.getLowWord","@stdlib/math/base/special/hacovercos":"base.hacovercos","@stdlib/math/base/special/hacoversin":"base.hacoversin","@stdlib/math/base/special/havercos":"base.havercos","@stdlib/math/base/special/haversin":"base.haversin","@stdlib/string/base/headercase":"base.headercase","@stdlib/math/base/special/heaviside":"base.heaviside","@stdlib/math/base/tools/hermitepoly":"base.hermitepoly","@stdlib/math/base/special/hypot":"base.hypot","@stdlib/math/base/special/hypotf":"base.hypotf","@stdlib/math/base/special/identity":"base.identity","@stdlib/math/base/special/identityf":"base.identityf","@stdlib/math/base/ops/imul":"base.imul","@stdlib/math/base/ops/imuldw":"base.imuldw","@stdlib/slice/base/int2slice":"base.int2slice","@stdlib/number/int32/base/to-uint32":"base.int32ToUint32","@stdlib/math/base/special/inv":"base.inv","@stdlib/string/base/invcase":"base.invcase","@stdlib/math/base/special/invf":"base.invf","@stdlib/math/base/assert/is-composite":"base.isComposite","@stdlib/math/base/assert/is-coprime":"base.isCoprime","@stdlib/math/base/assert/is-even":"base.isEven","@stdlib/math/base/assert/int32-is-even":"base.isEvenInt32","@stdlib/math/base/assert/is-finite":"base.isFinite","@stdlib/math/base/assert/is-finitef":"base.isFinitef","@stdlib/math/base/assert/is-infinite":"base.isInfinite","@stdlib/math/base/assert/is-infinitef":"base.isInfinitef","@stdlib/math/base/assert/is-integer":"base.isInteger","@stdlib/math/base/assert/is-nan":"base.isnan","@stdlib/math/base/assert/is-nanf":"base.isnanf","@stdlib/math/base/assert/is-negative-finite":"base.isNegativeFinite","@stdlib/math/base/assert/is-negative-integer":"base.isNegativeInteger","@stdlib/math/base/assert/is-negative-zero":"base.isNegativeZero","@stdlib/math/base/assert/is-negative-zerof":"base.isNegativeZerof","@stdlib/math/base/assert/is-nonnegative-finite":"base.isNonNegativeFinite","@stdlib/math/base/assert/is-nonnegative-integer":"base.isNonNegativeInteger","@stdlib/math/base/assert/is-nonpositive-finite":"base.isNonPositiveFinite","@stdlib/math/base/assert/is-nonpositive-integer":"base.isNonPositiveInteger","@stdlib/math/base/assert/is-odd":"base.isOdd","@stdlib/math/base/assert/int32-is-odd":"base.isOddInt32","@stdlib/math/base/assert/is-positive-finite":"base.isPositiveFinite","@stdlib/math/base/assert/is-positive-integer":"base.isPositiveInteger","@stdlib/math/base/assert/is-positive-zero":"base.isPositiveZero","@stdlib/math/base/assert/is-positive-zerof":"base.isPositiveZerof","@stdlib/math/base/assert/uint32-is-pow2":"base.isPow2Uint32","@stdlib/math/base/assert/is-prime":"base.isPrime","@stdlib/math/base/assert/is-probability":"base.isProbability","@stdlib/math/base/assert/is-safe-integer":"base.isSafeInteger","@stdlib/string/base/kebabcase":"base.kebabcase","@stdlib/math/base/special/kernel-betainc":"base.kernelBetainc","@stdlib/math/base/special/kernel-betaincinv":"base.kernelBetaincinv","@stdlib/math/base/special/kernel-cos":"base.kernelCos","@stdlib/math/base/special/kernel-log1p":"base.kernelLog1p","@stdlib/math/base/special/kernel-sin":"base.kernelSin","@stdlib/math/base/special/kernel-tan":"base.kernelTan","@stdlib/math/base/special/kronecker-delta":"base.kroneckerDelta","@stdlib/math/base/special/kronecker-deltaf":"base.kroneckerDeltaf","@stdlib/math/base/special/labs":"base.labs","@stdlib/string/base/last":"base.last","@stdlib/string/base/last-code-point":"base.lastCodePoint","@stdlib/string/base/last-grapheme-cluster":"base.lastGraphemeCluster","@stdlib/math/base/special/lcm":"base.lcm","@stdlib/math/base/special/ldexp":"base.ldexp","@stdlib/string/base/left-pad":"base.leftPad","@stdlib/string/base/left-trim":"base.leftTrim","@stdlib/math/base/special/ln":"base.ln","@stdlib/math/base/special/log":"base.log","@stdlib/math/base/special/log1mexp":"base.log1mexp","@stdlib/math/base/special/log1p":"base.log1p","@stdlib/math/base/special/log1pexp":"base.log1pexp","@stdlib/math/base/special/log1pmx":"base.log1pmx","@stdlib/math/base/special/log2":"base.log2","@stdlib/math/base/special/log10":"base.log10","@stdlib/math/base/special/logaddexp":"base.logaddexp","@stdlib/math/base/special/logit":"base.logit","@stdlib/string/base/lowercase":"base.lowercase","@stdlib/math/base/special/lucas":"base.lucas","@stdlib/math/base/tools/lucaspoly":"base.lucaspoly","@stdlib/math/base/special/max":"base.max","@stdlib/math/base/special/maxabs":"base.maxabs","@stdlib/math/base/special/maxabsn":"base.maxabsn","@stdlib/math/base/special/maxn":"base.maxn","@stdlib/math/base/special/min":"base.min","@stdlib/math/base/special/minabs":"base.minabs","@stdlib/math/base/special/minabsn":"base.minabsn","@stdlib/math/base/special/minmax":"base.minmax","@stdlib/math/base/special/minmaxabs":"base.minmaxabs","@stdlib/math/base/special/minmaxabsn":"base.minmaxabsn","@stdlib/math/base/special/minmaxn":"base.minmaxn","@stdlib/math/base/special/minn":"base.minn","@stdlib/math/base/special/modf":"base.modf","@stdlib/number/float64/base/mul":"base.mul","@stdlib/number/float32/base/mul":"base.mulf","@stdlib/ndarray/base/ctor":"base.ndarray","@stdlib/ndarray/base/unary":"base.ndarrayUnary","@stdlib/ndarray/base/zeros":"base.ndzeros","@stdlib/ndarray/base/zeros-like":"base.ndzerosLike","@stdlib/math/base/special/negafibonacci":"base.negafibonacci","@stdlib/math/base/special/negalucas":"base.negalucas","@stdlib/math/base/special/nonfibonacci":"base.nonfibonacci","@stdlib/number/float64/base/normalize":"base.normalize","@stdlib/number/float32/base/normalize":"base.normalizef","@stdlib/slice/base/normalize-multi-slice":"base.normalizeMultiSlice","@stdlib/slice/base/normalize-slice":"base.normalizeSlice","@stdlib/math/base/tools/normhermitepoly":"base.normhermitepoly","@stdlib/string/base/pascalcase":"base.pascalcase","@stdlib/math/base/special/pdiff":"base.pdiff","@stdlib/math/base/special/pdifff":"base.pdifff","@stdlib/string/base/percent-encode":"base.percentEncode","@stdlib/math/base/special/polygamma":"base.polygamma","@stdlib/math/base/special/pow":"base.pow","@stdlib/math/base/special/powm1":"base.powm1","@stdlib/math/base/special/rad2deg":"base.rad2deg","@stdlib/math/base/special/rad2degf":"base.rad2degf","@stdlib/math/base/special/ramp":"base.ramp","@stdlib/math/base/special/rampf":"base.rampf","@stdlib/random/base/arcsine":"base.random.arcsine","@stdlib/random/base/bernoulli":"base.random.bernoulli","@stdlib/random/base/beta":"base.random.beta","@stdlib/random/base/betaprime":"base.random.betaprime","@stdlib/random/base/binomial":"base.random.binomial","@stdlib/random/base/box-muller":"base.random.boxMuller","@stdlib/random/base/cauchy":"base.random.cauchy","@stdlib/random/base/chi":"base.random.chi","@stdlib/random/base/chisquare":"base.random.chisquare","@stdlib/random/base/cosine":"base.random.cosine","@stdlib/random/base/discrete-uniform":"base.random.discreteUniform","@stdlib/random/base/erlang":"base.random.erlang","@stdlib/random/base/exponential":"base.random.exponential","@stdlib/random/base/f":"base.random.f","@stdlib/random/base/frechet":"base.random.frechet","@stdlib/random/base/gamma":"base.random.gamma","@stdlib/random/base/geometric":"base.random.geometric","@stdlib/random/base/gumbel":"base.random.gumbel","@stdlib/random/base/hypergeometric":"base.random.hypergeometric","@stdlib/random/base/improved-ziggurat":"base.random.improvedZiggurat","@stdlib/random/base/invgamma":"base.random.invgamma","@stdlib/random/base/kumaraswamy":"base.random.kumaraswamy","@stdlib/random/base/laplace":"base.random.laplace","@stdlib/random/base/levy":"base.random.levy","@stdlib/random/base/logistic":"base.random.logistic","@stdlib/random/base/lognormal":"base.random.lognormal","@stdlib/random/base/minstd":"base.random.minstd","@stdlib/random/base/minstd-shuffle":"base.random.minstdShuffle","@stdlib/random/base/mt19937":"base.random.mt19937","@stdlib/random/base/negative-binomial":"base.random.negativeBinomial","@stdlib/random/base/normal":"base.random.normal","@stdlib/random/base/pareto-type1":"base.random.pareto1","@stdlib/random/base/poisson":"base.random.poisson","@stdlib/random/base/randi":"base.random.randi","@stdlib/random/base/randn":"base.random.randn","@stdlib/random/base/randu":"base.random.randu","@stdlib/random/base/rayleigh":"base.random.rayleigh","@stdlib/random/base/t":"base.random.t","@stdlib/random/base/triangular":"base.random.triangular","@stdlib/random/base/uniform":"base.random.uniform","@stdlib/random/base/weibull":"base.random.weibull","@stdlib/math/base/special/rcbrt":"base.rcbrt","@stdlib/math/base/special/rcbrtf":"base.rcbrtf","@stdlib/math/base/utils/relative-difference":"base.reldiff","@stdlib/string/base/remove-first":"base.removeFirst","@stdlib/string/base/remove-first-code-point":"base.removeFirstCodePoint","@stdlib/string/base/remove-first-grapheme-cluster":"base.removeFirstGraphemeCluster","@stdlib/string/base/remove-last":"base.removeLast","@stdlib/string/base/remove-last-code-point":"base.removeLastCodePoint","@stdlib/string/base/remove-last-grapheme-cluster":"base.removeLastGraphemeCluster","@stdlib/math/base/special/rempio2":"base.rempio2","@stdlib/string/base/repeat":"base.repeat","@stdlib/string/base/replace":"base.replace","@stdlib/string/base/replace-after":"base.replaceAfter","@stdlib/string/base/replace-after-last":"base.replaceAfterLast","@stdlib/string/base/replace-before":"base.replaceBefore","@stdlib/string/base/replace-before-last":"base.replaceBeforeLast","@stdlib/string/base/reverse":"base.reverse","@stdlib/string/base/reverse-code-points":"base.reverseCodePoints","@stdlib/string/base/reverse-grapheme-clusters":"base.reverseGraphemeClusters","@stdlib/string/base/right-pad":"base.rightPad","@stdlib/string/base/right-trim":"base.rightTrim","@stdlib/math/base/special/rising-factorial":"base.risingFactorial","@stdlib/number/uint32/base/rotl":"base.rotl32","@stdlib/number/uint32/base/rotr":"base.rotr32","@stdlib/math/base/special/round":"base.round","@stdlib/math/base/special/round2":"base.round2","@stdlib/math/base/special/round10":"base.round10","@stdlib/math/base/special/roundb":"base.roundb","@stdlib/math/base/special/roundn":"base.roundn","@stdlib/math/base/special/roundsd":"base.roundsd","@stdlib/math/base/special/rsqrt":"base.rsqrt","@stdlib/math/base/special/rsqrtf":"base.rsqrtf","@stdlib/slice/base/sargs2multislice":"base.sargs2multislice","@stdlib/ndarray/base/from-scalar":"base.scalar2ndarray","@stdlib/math/base/special/secd":"base.secd","@stdlib/slice/base/seq2multislice":"base.seq2multislice","@stdlib/slice/base/seq2slice":"base.seq2slice","@stdlib/number/float64/base/set-high-word":"base.setHighWord","@stdlib/number/float64/base/set-low-word":"base.setLowWord","@stdlib/math/base/special/sici":"base.sici","@stdlib/number/float64/base/signbit":"base.signbit","@stdlib/number/float32/base/signbit":"base.signbitf","@stdlib/number/float32/base/significand":"base.significandf","@stdlib/math/base/special/signum":"base.signum","@stdlib/math/base/special/signumf":"base.signumf","@stdlib/math/base/special/sin":"base.sin","@stdlib/math/base/special/sinc":"base.sinc","@stdlib/math/base/special/sincos":"base.sincos","@stdlib/math/base/special/sincospi":"base.sincospi","@stdlib/math/base/special/sinh":"base.sinh","@stdlib/math/base/special/sinpi":"base.sinpi","@stdlib/slice/base/slice2seq":"base.slice2seq","@stdlib/slice/base/length":"base.sliceLength","@stdlib/slice/base/nonreduced-dimensions":"base.sliceNonReducedDimensions","@stdlib/slice/base/reduced-dimensions":"base.sliceReducedDimensions","@stdlib/slice/base/shape":"base.sliceShape","@stdlib/string/base/snakecase":"base.snakecase","@stdlib/math/base/special/spence":"base.spence","@stdlib/math/base/special/sqrt":"base.sqrt","@stdlib/math/base/special/sqrt1pm1":"base.sqrt1pm1","@stdlib/math/base/special/sqrtf":"base.sqrtf","@stdlib/math/base/special/sqrtpi":"base.sqrtpi","@stdlib/string/base/startcase":"base.startcase","@stdlib/string/base/starts-with":"base.startsWith","@stdlib/string/base/stickycase":"base.stickycase","@stdlib/strided/base/binary":"base.strided.binary","@stdlib/strided/base/binary-dtype-signatures":"base.strided.binaryDtypeSignatures","@stdlib/strided/base/binary-signature-callbacks":"base.strided.binarySignatureCallbacks","@stdlib/blas/base/ccopy":"base.strided.ccopy","@stdlib/strided/base/cmap":"base.strided.cmap","@stdlib/blas/base/cswap":"base.strided.cswap","@stdlib/stats/base/cumax":"base.strided.cumax","@stdlib/stats/base/cumaxabs":"base.strided.cumaxabs","@stdlib/stats/base/cumin":"base.strided.cumin","@stdlib/stats/base/cuminabs":"base.strided.cuminabs","@stdlib/math/strided/special/dabs":"base.strided.dabs","@stdlib/math/strided/special/dabs2":"base.strided.dabs2","@stdlib/blas/ext/base/dapx":"base.strided.dapx","@stdlib/blas/ext/base/dapxsum":"base.strided.dapxsum","@stdlib/blas/ext/base/dapxsumkbn":"base.strided.dapxsumkbn","@stdlib/blas/ext/base/dapxsumkbn2":"base.strided.dapxsumkbn2","@stdlib/blas/ext/base/dapxsumors":"base.strided.dapxsumors","@stdlib/blas/ext/base/dapxsumpw":"base.strided.dapxsumpw","@stdlib/blas/base/dasum":"base.strided.dasum","@stdlib/blas/ext/base/dasumpw":"base.strided.dasumpw","@stdlib/blas/base/daxpy":"base.strided.daxpy","@stdlib/math/strided/special/dcbrt":"base.strided.dcbrt","@stdlib/math/strided/special/dceil":"base.strided.dceil","@stdlib/blas/base/dcopy":"base.strided.dcopy","@stdlib/stats/strided/dcumax":"base.strided.dcumax","@stdlib/stats/strided/dcumaxabs":"base.strided.dcumaxabs","@stdlib/stats/base/dcumin":"base.strided.dcumin","@stdlib/stats/strided/dcuminabs":"base.strided.dcuminabs","@stdlib/blas/ext/base/dcusum":"base.strided.dcusum","@stdlib/blas/ext/base/dcusumkbn":"base.strided.dcusumkbn","@stdlib/blas/ext/base/dcusumkbn2":"base.strided.dcusumkbn2","@stdlib/blas/ext/base/dcusumors":"base.strided.dcusumors","@stdlib/blas/ext/base/dcusumpw":"base.strided.dcusumpw","@stdlib/math/strided/special/ddeg2rad":"base.strided.ddeg2rad","@stdlib/blas/base/ddot":"base.strided.ddot","@stdlib/blas/ext/base/dfill":"base.strided.dfill","@stdlib/math/strided/special/dfloor":"base.strided.dfloor","@stdlib/math/strided/special/dinv":"base.strided.dinv","@stdlib/strided/base/dmap":"base.strided.dmap","@stdlib/strided/base/dmap2":"base.strided.dmap2","@stdlib/stats/strided/dmax":"base.strided.dmax","@stdlib/stats/strided/dmaxabs":"base.strided.dmaxabs","@stdlib/stats/strided/dmaxabssorted":"base.strided.dmaxabssorted","@stdlib/stats/strided/dmaxsorted":"base.strided.dmaxsorted","@stdlib/stats/base/dmean":"base.strided.dmean","@stdlib/stats/strided/dmeankbn":"base.strided.dmeankbn","@stdlib/stats/strided/dmeankbn2":"base.strided.dmeankbn2","@stdlib/stats/strided/dmeanli":"base.strided.dmeanli","@stdlib/stats/strided/dmeanlipw":"base.strided.dmeanlipw","@stdlib/stats/strided/dmeanors":"base.strided.dmeanors","@stdlib/stats/base/dmeanpn":"base.strided.dmeanpn","@stdlib/stats/strided/dmeanpw":"base.strided.dmeanpw","@stdlib/stats/base/dmeanstdev":"base.strided.dmeanstdev","@stdlib/stats/base/dmeanstdevpn":"base.strided.dmeanstdevpn","@stdlib/stats/base/dmeanvar":"base.strided.dmeanvar","@stdlib/stats/base/dmeanvarpn":"base.strided.dmeanvarpn","@stdlib/stats/strided/dmeanwd":"base.strided.dmeanwd","@stdlib/stats/strided/dmediansorted":"base.strided.dmediansorted","@stdlib/stats/strided/dmidrange":"base.strided.dmidrange","@stdlib/stats/strided/dmin":"base.strided.dmin","@stdlib/stats/strided/dminabs":"base.strided.dminabs","@stdlib/stats/strided/dminsorted":"base.strided.dminsorted","@stdlib/math/strided/special/dmskabs":"base.strided.dmskabs","@stdlib/math/strided/special/dmskabs2":"base.strided.dmskabs2","@stdlib/math/strided/special/dmskcbrt":"base.strided.dmskcbrt","@stdlib/math/strided/special/dmskceil":"base.strided.dmskceil","@stdlib/math/strided/special/dmskdeg2rad":"base.strided.dmskdeg2rad","@stdlib/math/strided/special/dmskfloor":"base.strided.dmskfloor","@stdlib/math/strided/special/dmskinv":"base.strided.dmskinv","@stdlib/strided/base/dmskmap":"base.strided.dmskmap","@stdlib/strided/base/dmskmap2":"base.strided.dmskmap2","@stdlib/stats/base/dmskmax":"base.strided.dmskmax","@stdlib/stats/base/dmskmin":"base.strided.dmskmin","@stdlib/math/strided/special/dmskramp":"base.strided.dmskramp","@stdlib/stats/base/dmskrange":"base.strided.dmskrange","@stdlib/math/strided/special/dmskrsqrt":"base.strided.dmskrsqrt","@stdlib/math/strided/special/dmsksqrt":"base.strided.dmsksqrt","@stdlib/math/strided/special/dmsktrunc":"base.strided.dmsktrunc","@stdlib/blas/ext/base/dnanasum":"base.strided.dnanasum","@stdlib/blas/ext/base/dnanasumors":"base.strided.dnanasumors","@stdlib/stats/strided/dnanmax":"base.strided.dnanmax","@stdlib/stats/strided/dnanmaxabs":"base.strided.dnanmaxabs","@stdlib/stats/strided/dnanmean":"base.strided.dnanmean","@stdlib/stats/base/dnanmeanors":"base.strided.dnanmeanors","@stdlib/stats/base/dnanmeanpn":"base.strided.dnanmeanpn","@stdlib/stats/base/dnanmeanpw":"base.strided.dnanmeanpw","@stdlib/stats/base/dnanmeanwd":"base.strided.dnanmeanwd","@stdlib/stats/base/dnanmin":"base.strided.dnanmin","@stdlib/stats/base/dnanminabs":"base.strided.dnanminabs","@stdlib/stats/base/dnanmskmax":"base.strided.dnanmskmax","@stdlib/stats/base/dnanmskmin":"base.strided.dnanmskmin","@stdlib/stats/base/dnanmskrange":"base.strided.dnanmskrange","@stdlib/blas/ext/base/dnannsum":"base.strided.dnannsum","@stdlib/blas/ext/base/dnannsumkbn":"base.strided.dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2":"base.strided.dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors":"base.strided.dnannsumors","@stdlib/blas/ext/base/dnannsumpw":"base.strided.dnannsumpw","@stdlib/stats/base/dnanrange":"base.strided.dnanrange","@stdlib/stats/base/dnanstdev":"base.strided.dnanstdev","@stdlib/stats/base/dnanstdevch":"base.strided.dnanstdevch","@stdlib/stats/base/dnanstdevpn":"base.strided.dnanstdevpn","@stdlib/stats/base/dnanstdevtk":"base.strided.dnanstdevtk","@stdlib/stats/base/dnanstdevwd":"base.strided.dnanstdevwd","@stdlib/stats/base/dnanstdevyc":"base.strided.dnanstdevyc","@stdlib/blas/ext/base/dnansum":"base.strided.dnansum","@stdlib/blas/ext/base/dnansumkbn":"base.strided.dnansumkbn","@stdlib/blas/ext/base/dnansumkbn2":"base.strided.dnansumkbn2","@stdlib/blas/ext/base/dnansumors":"base.strided.dnansumors","@stdlib/blas/ext/base/dnansumpw":"base.strided.dnansumpw","@stdlib/stats/base/dnanvariance":"base.strided.dnanvariance","@stdlib/stats/base/dnanvariancech":"base.strided.dnanvariancech","@stdlib/stats/base/dnanvariancepn":"base.strided.dnanvariancepn","@stdlib/stats/base/dnanvariancetk":"base.strided.dnanvariancetk","@stdlib/stats/base/dnanvariancewd":"base.strided.dnanvariancewd","@stdlib/stats/base/dnanvarianceyc":"base.strided.dnanvarianceyc","@stdlib/blas/base/dnrm2":"base.strided.dnrm2","@stdlib/math/strided/special/dramp":"base.strided.dramp","@stdlib/stats/base/drange":"base.strided.drange","@stdlib/blas/ext/base/drev":"base.strided.drev","@stdlib/math/strided/special/drsqrt":"base.strided.drsqrt","@stdlib/blas/ext/base/dsapxsum":"base.strided.dsapxsum","@stdlib/blas/ext/base/dsapxsumpw":"base.strided.dsapxsumpw","@stdlib/blas/base/dscal":"base.strided.dscal","@stdlib/blas/base/dsdot":"base.strided.dsdot","@stdlib/stats/base/dsem":"base.strided.dsem","@stdlib/stats/base/dsemch":"base.strided.dsemch","@stdlib/stats/base/dsempn":"base.strided.dsempn","@stdlib/stats/base/dsemtk":"base.strided.dsemtk","@stdlib/stats/base/dsemwd":"base.strided.dsemwd","@stdlib/stats/base/dsemyc":"base.strided.dsemyc","@stdlib/stats/base/dsmean":"base.strided.dsmean","@stdlib/stats/base/dsmeanors":"base.strided.dsmeanors","@stdlib/stats/base/dsmeanpn":"base.strided.dsmeanpn","@stdlib/stats/base/dsmeanpw":"base.strided.dsmeanpw","@stdlib/stats/base/dsmeanwd":"base.strided.dsmeanwd","@stdlib/stats/base/dsnanmean":"base.strided.dsnanmean","@stdlib/stats/base/dsnanmeanors":"base.strided.dsnanmeanors","@stdlib/stats/base/dsnanmeanpn":"base.strided.dsnanmeanpn","@stdlib/stats/base/dsnanmeanwd":"base.strided.dsnanmeanwd","@stdlib/blas/ext/base/dsnannsumors":"base.strided.dsnannsumors","@stdlib/blas/ext/base/dsnansum":"base.strided.dsnansum","@stdlib/blas/ext/base/dsnansumors":"base.strided.dsnansumors","@stdlib/blas/ext/base/dsnansumpw":"base.strided.dsnansumpw","@stdlib/blas/ext/base/dsort2hp":"base.strided.dsort2hp","@stdlib/blas/ext/base/dsort2ins":"base.strided.dsort2ins","@stdlib/blas/ext/base/dsort2sh":"base.strided.dsort2sh","@stdlib/blas/ext/base/dsorthp":"base.strided.dsorthp","@stdlib/blas/ext/base/dsortins":"base.strided.dsortins","@stdlib/blas/ext/base/dsortsh":"base.strided.dsortsh","@stdlib/math/strided/special/dsqrt":"base.strided.dsqrt","@stdlib/blas/ext/base/dssum":"base.strided.dssum","@stdlib/blas/ext/base/dssumors":"base.strided.dssumors","@stdlib/blas/ext/base/dssumpw":"base.strided.dssumpw","@stdlib/stats/base/dstdev":"base.strided.dstdev","@stdlib/stats/base/dstdevch":"base.strided.dstdevch","@stdlib/stats/base/dstdevpn":"base.strided.dstdevpn","@stdlib/stats/base/dstdevtk":"base.strided.dstdevtk","@stdlib/stats/base/dstdevwd":"base.strided.dstdevwd","@stdlib/stats/base/dstdevyc":"base.strided.dstdevyc","@stdlib/blas/ext/base/dsum":"base.strided.dsum","@stdlib/blas/ext/base/dsumkbn":"base.strided.dsumkbn","@stdlib/blas/ext/base/dsumkbn2":"base.strided.dsumkbn2","@stdlib/blas/ext/base/dsumors":"base.strided.dsumors","@stdlib/blas/ext/base/dsumpw":"base.strided.dsumpw","@stdlib/stats/base/dsvariance":"base.strided.dsvariance","@stdlib/stats/base/dsvariancepn":"base.strided.dsvariancepn","@stdlib/blas/base/dswap":"base.strided.dswap","@stdlib/math/strided/special/dtrunc":"base.strided.dtrunc","@stdlib/strided/base/dtype-enum2str":"base.strided.dtypeEnum2Str","@stdlib/strided/base/dtype-resolve-enum":"base.strided.dtypeResolveEnum","@stdlib/strided/base/dtype-resolve-str":"base.strided.dtypeResolveStr","@stdlib/strided/base/dtype-str2enum":"base.strided.dtypeStr2Enum","@stdlib/stats/base/dvariance":"base.strided.dvariance","@stdlib/stats/base/dvariancech":"base.strided.dvariancech","@stdlib/stats/base/dvariancepn":"base.strided.dvariancepn","@stdlib/stats/base/dvariancetk":"base.strided.dvariancetk","@stdlib/stats/base/dvariancewd":"base.strided.dvariancewd","@stdlib/stats/base/dvarianceyc":"base.strided.dvarianceyc","@stdlib/stats/base/dvarm":"base.strided.dvarm","@stdlib/stats/base/dvarmpn":"base.strided.dvarmpn","@stdlib/stats/base/dvarmtk":"base.strided.dvarmtk","@stdlib/strided/base/function-object":"base.strided.functionObject","@stdlib/blas/ext/base/gapx":"base.strided.gapx","@stdlib/blas/ext/base/gapxsum":"base.strided.gapxsum","@stdlib/blas/ext/base/gapxsumkbn":"base.strided.gapxsumkbn","@stdlib/blas/ext/base/gapxsumkbn2":"base.strided.gapxsumkbn2","@stdlib/blas/ext/base/gapxsumors":"base.strided.gapxsumors","@stdlib/blas/ext/base/gapxsumpw":"base.strided.gapxsumpw","@stdlib/blas/base/gasum":"base.strided.gasum","@stdlib/blas/ext/base/gasumpw":"base.strided.gasumpw","@stdlib/blas/base/gaxpy":"base.strided.gaxpy","@stdlib/blas/base/gcopy":"base.strided.gcopy","@stdlib/blas/ext/base/gcusum":"base.strided.gcusum","@stdlib/blas/ext/base/gcusumkbn":"base.strided.gcusumkbn","@stdlib/blas/ext/base/gcusumkbn2":"base.strided.gcusumkbn2","@stdlib/blas/ext/base/gcusumors":"base.strided.gcusumors","@stdlib/blas/ext/base/gcusumpw":"base.strided.gcusumpw","@stdlib/blas/base/gdot":"base.strided.gdot","@stdlib/blas/ext/base/gfill":"base.strided.gfill","@stdlib/blas/ext/base/gfill-by":"base.strided.gfillBy","@stdlib/blas/ext/base/gnannsumkbn":"base.strided.gnannsumkbn","@stdlib/blas/ext/base/gnansum":"base.strided.gnansum","@stdlib/blas/ext/base/gnansumkbn":"base.strided.gnansumkbn","@stdlib/blas/ext/base/gnansumkbn2":"base.strided.gnansumkbn2","@stdlib/blas/ext/base/gnansumors":"base.strided.gnansumors","@stdlib/blas/ext/base/gnansumpw":"base.strided.gnansumpw","@stdlib/blas/base/gnrm2":"base.strided.gnrm2","@stdlib/blas/ext/base/grev":"base.strided.grev","@stdlib/blas/base/gscal":"base.strided.gscal","@stdlib/blas/ext/base/gsort2hp":"base.strided.gsort2hp","@stdlib/blas/ext/base/gsort2ins":"base.strided.gsort2ins","@stdlib/blas/ext/base/gsort2sh":"base.strided.gsort2sh","@stdlib/blas/ext/base/gsorthp":"base.strided.gsorthp","@stdlib/blas/ext/base/gsortins":"base.strided.gsortins","@stdlib/blas/ext/base/gsortsh":"base.strided.gsortsh","@stdlib/blas/ext/base/gsum":"base.strided.gsum","@stdlib/blas/ext/base/gsumkbn":"base.strided.gsumkbn","@stdlib/blas/ext/base/gsumkbn2":"base.strided.gsumkbn2","@stdlib/blas/ext/base/gsumors":"base.strided.gsumors","@stdlib/blas/ext/base/gsumpw":"base.strided.gsumpw","@stdlib/blas/base/gswap":"base.strided.gswap","@stdlib/strided/base/map-by":"base.strided.mapBy","@stdlib/strided/base/map-by2":"base.strided.mapBy2","@stdlib/stats/base/max":"base.strided.max","@stdlib/stats/base/maxabs":"base.strided.maxabs","@stdlib/stats/base/max-by":"base.strided.maxBy","@stdlib/stats/base/maxsorted":"base.strided.maxsorted","@stdlib/strided/base/max-view-buffer-index":"base.strided.maxViewBufferIndex","@stdlib/stats/base/mean":"base.strided.mean","@stdlib/stats/base/meankbn":"base.strided.meankbn","@stdlib/stats/base/meankbn2":"base.strided.meankbn2","@stdlib/stats/base/meanors":"base.strided.meanors","@stdlib/stats/base/meanpn":"base.strided.meanpn","@stdlib/stats/base/meanpw":"base.strided.meanpw","@stdlib/stats/base/meanwd":"base.strided.meanwd","@stdlib/stats/base/mediansorted":"base.strided.mediansorted","@stdlib/strided/base/meta-data-props":"base.strided.metaDataProps","@stdlib/stats/base/min":"base.strided.min","@stdlib/stats/base/minabs":"base.strided.minabs","@stdlib/stats/base/min-by":"base.strided.minBy","@stdlib/stats/base/minsorted":"base.strided.minsorted","@stdlib/strided/base/min-view-buffer-index":"base.strided.minViewBufferIndex","@stdlib/stats/base/mskmax":"base.strided.mskmax","@stdlib/stats/base/mskmin":"base.strided.mskmin","@stdlib/stats/base/mskrange":"base.strided.mskrange","@stdlib/strided/base/mskunary":"base.strided.mskunary","@stdlib/strided/base/mskunary-dtype-signatures":"base.strided.mskunaryDtypeSignatures","@stdlib/strided/base/mskunary-signature-callbacks":"base.strided.mskunarySignatureCallbacks","@stdlib/stats/base/nanmax":"base.strided.nanmax","@stdlib/stats/base/nanmaxabs":"base.strided.nanmaxabs","@stdlib/stats/base/nanmax-by":"base.strided.nanmaxBy","@stdlib/stats/base/nanmean":"base.strided.nanmean","@stdlib/stats/base/nanmeanors":"base.strided.nanmeanors","@stdlib/stats/base/nanmeanpn":"base.strided.nanmeanpn","@stdlib/stats/base/nanmeanwd":"base.strided.nanmeanwd","@stdlib/stats/base/nanmin":"base.strided.nanmin","@stdlib/stats/base/nanminabs":"base.strided.nanminabs","@stdlib/stats/base/nanmin-by":"base.strided.nanminBy","@stdlib/stats/base/nanmskmax":"base.strided.nanmskmax","@stdlib/stats/base/nanmskmin":"base.strided.nanmskmin","@stdlib/stats/base/nanmskrange":"base.strided.nanmskrange","@stdlib/stats/base/nanrange":"base.strided.nanrange","@stdlib/stats/base/nanrange-by":"base.strided.nanrangeBy","@stdlib/stats/base/nanstdev":"base.strided.nanstdev","@stdlib/stats/base/nanstdevch":"base.strided.nanstdevch","@stdlib/stats/base/nanstdevpn":"base.strided.nanstdevpn","@stdlib/stats/base/nanstdevtk":"base.strided.nanstdevtk","@stdlib/stats/base/nanstdevwd":"base.strided.nanstdevwd","@stdlib/stats/base/nanstdevyc":"base.strided.nanstdevyc","@stdlib/stats/base/nanvariance":"base.strided.nanvariance","@stdlib/stats/base/nanvariancech":"base.strided.nanvariancech","@stdlib/stats/base/nanvariancepn":"base.strided.nanvariancepn","@stdlib/stats/base/nanvariancetk":"base.strided.nanvariancetk","@stdlib/stats/base/nanvariancewd":"base.strided.nanvariancewd","@stdlib/stats/base/nanvarianceyc":"base.strided.nanvarianceyc","@stdlib/strided/base/nullary":"base.strided.nullary","@stdlib/strided/base/offset-view":"base.strided.offsetView","@stdlib/strided/base/quaternary":"base.strided.quaternary","@stdlib/strided/base/quinary":"base.strided.quinary","@stdlib/stats/base/range":"base.strided.range","@stdlib/stats/base/range-by":"base.strided.rangeBy","@stdlib/strided/base/reinterpret-complex":"base.strided.reinterpretComplex","@stdlib/strided/base/reinterpret-complex64":"base.strided.reinterpretComplex64","@stdlib/strided/base/reinterpret-complex128":"base.strided.reinterpretComplex128","@stdlib/math/strided/special/sabs":"base.strided.sabs","@stdlib/math/strided/special/sabs2":"base.strided.sabs2","@stdlib/blas/ext/base/sapx":"base.strided.sapx","@stdlib/blas/ext/base/sapxsum":"base.strided.sapxsum","@stdlib/blas/ext/base/sapxsumkbn":"base.strided.sapxsumkbn","@stdlib/blas/ext/base/sapxsumkbn2":"base.strided.sapxsumkbn2","@stdlib/blas/ext/base/sapxsumors":"base.strided.sapxsumors","@stdlib/blas/ext/base/sapxsumpw":"base.strided.sapxsumpw","@stdlib/blas/base/sasum":"base.strided.sasum","@stdlib/blas/ext/base/sasumpw":"base.strided.sasumpw","@stdlib/blas/base/saxpy":"base.strided.saxpy","@stdlib/math/strided/special/scbrt":"base.strided.scbrt","@stdlib/math/strided/special/sceil":"base.strided.sceil","@stdlib/blas/base/scopy":"base.strided.scopy","@stdlib/stats/base/scumax":"base.strided.scumax","@stdlib/stats/base/scumaxabs":"base.strided.scumaxabs","@stdlib/stats/base/scumin":"base.strided.scumin","@stdlib/stats/base/scuminabs":"base.strided.scuminabs","@stdlib/blas/ext/base/scusum":"base.strided.scusum","@stdlib/blas/ext/base/scusumkbn":"base.strided.scusumkbn","@stdlib/blas/ext/base/scusumkbn2":"base.strided.scusumkbn2","@stdlib/blas/ext/base/scusumors":"base.strided.scusumors","@stdlib/blas/ext/base/scusumpw":"base.strided.scusumpw","@stdlib/math/strided/special/sdeg2rad":"base.strided.sdeg2rad","@stdlib/blas/base/sdot":"base.strided.sdot","@stdlib/blas/ext/base/sdsapxsum":"base.strided.sdsapxsum","@stdlib/blas/ext/base/sdsapxsumpw":"base.strided.sdsapxsumpw","@stdlib/blas/base/sdsdot":"base.strided.sdsdot","@stdlib/stats/base/sdsmean":"base.strided.sdsmean","@stdlib/stats/base/sdsmeanors":"base.strided.sdsmeanors","@stdlib/stats/base/sdsnanmean":"base.strided.sdsnanmean","@stdlib/stats/base/sdsnanmeanors":"base.strided.sdsnanmeanors","@stdlib/blas/ext/base/sdsnansum":"base.strided.sdsnansum","@stdlib/blas/ext/base/sdsnansumpw":"base.strided.sdsnansumpw","@stdlib/blas/ext/base/sdssum":"base.strided.sdssum","@stdlib/blas/ext/base/sdssumpw":"base.strided.sdssumpw","@stdlib/blas/ext/base/sfill":"base.strided.sfill","@stdlib/math/strided/special/sfloor":"base.strided.sfloor","@stdlib/math/strided/special/sinv":"base.strided.sinv","@stdlib/strided/base/smap":"base.strided.smap","@stdlib/strided/base/smap2":"base.strided.smap2","@stdlib/stats/base/smax":"base.strided.smax","@stdlib/stats/base/smaxabs":"base.strided.smaxabs","@stdlib/stats/base/smaxabssorted":"base.strided.smaxabssorted","@stdlib/stats/base/smaxsorted":"base.strided.smaxsorted","@stdlib/stats/base/smean":"base.strided.smean","@stdlib/stats/base/smeankbn":"base.strided.smeankbn","@stdlib/stats/base/smeankbn2":"base.strided.smeankbn2","@stdlib/stats/base/smeanli":"base.strided.smeanli","@stdlib/stats/base/smeanlipw":"base.strided.smeanlipw","@stdlib/stats/base/smeanors":"base.strided.smeanors","@stdlib/stats/base/smeanpn":"base.strided.smeanpn","@stdlib/stats/base/smeanpw":"base.strided.smeanpw","@stdlib/stats/base/smeanwd":"base.strided.smeanwd","@stdlib/stats/base/smediansorted":"base.strided.smediansorted","@stdlib/stats/base/smidrange":"base.strided.smidrange","@stdlib/stats/base/smin":"base.strided.smin","@stdlib/stats/base/sminabs":"base.strided.sminabs","@stdlib/stats/base/sminsorted":"base.strided.sminsorted","@stdlib/math/strided/special/smskabs":"base.strided.smskabs","@stdlib/math/strided/special/smskabs2":"base.strided.smskabs2","@stdlib/math/strided/special/smskcbrt":"base.strided.smskcbrt","@stdlib/math/strided/special/smskceil":"base.strided.smskceil","@stdlib/math/strided/special/smskdeg2rad":"base.strided.smskdeg2rad","@stdlib/math/strided/special/smskfloor":"base.strided.smskfloor","@stdlib/math/strided/special/smskinv":"base.strided.smskinv","@stdlib/strided/base/smskmap":"base.strided.smskmap","@stdlib/strided/base/smskmap2":"base.strided.smskmap2","@stdlib/stats/base/smskmax":"base.strided.smskmax","@stdlib/stats/base/smskmin":"base.strided.smskmin","@stdlib/math/strided/special/smskramp":"base.strided.smskramp","@stdlib/stats/base/smskrange":"base.strided.smskrange","@stdlib/math/strided/special/smskrsqrt":"base.strided.smskrsqrt","@stdlib/math/strided/special/smsksqrt":"base.strided.smsksqrt","@stdlib/math/strided/special/smsktrunc":"base.strided.smsktrunc","@stdlib/stats/base/snanmax":"base.strided.snanmax","@stdlib/stats/base/snanmaxabs":"base.strided.snanmaxabs","@stdlib/stats/base/snanmean":"base.strided.snanmean","@stdlib/stats/base/snanmeanors":"base.strided.snanmeanors","@stdlib/stats/base/snanmeanpn":"base.strided.snanmeanpn","@stdlib/stats/base/snanmeanwd":"base.strided.snanmeanwd","@stdlib/stats/base/snanmin":"base.strided.snanmin","@stdlib/stats/base/snanminabs":"base.strided.snanminabs","@stdlib/stats/base/snanmskmax":"base.strided.snanmskmax","@stdlib/stats/base/snanmskmin":"base.strided.snanmskmin","@stdlib/stats/base/snanmskrange":"base.strided.snanmskrange","@stdlib/stats/base/snanrange":"base.strided.snanrange","@stdlib/stats/base/snanstdev":"base.strided.snanstdev","@stdlib/stats/base/snanstdevch":"base.strided.snanstdevch","@stdlib/stats/base/snanstdevpn":"base.strided.snanstdevpn","@stdlib/stats/base/snanstdevtk":"base.strided.snanstdevtk","@stdlib/stats/base/snanstdevwd":"base.strided.snanstdevwd","@stdlib/stats/base/snanstdevyc":"base.strided.snanstdevyc","@stdlib/blas/ext/base/snansum":"base.strided.snansum","@stdlib/blas/ext/base/snansumkbn":"base.strided.snansumkbn","@stdlib/blas/ext/base/snansumkbn2":"base.strided.snansumkbn2","@stdlib/blas/ext/base/snansumors":"base.strided.snansumors","@stdlib/blas/ext/base/snansumpw":"base.strided.snansumpw","@stdlib/stats/base/snanvariance":"base.strided.snanvariance","@stdlib/stats/base/snanvariancech":"base.strided.snanvariancech","@stdlib/stats/base/snanvariancepn":"base.strided.snanvariancepn","@stdlib/stats/base/snanvariancetk":"base.strided.snanvariancetk","@stdlib/stats/base/snanvariancewd":"base.strided.snanvariancewd","@stdlib/stats/base/snanvarianceyc":"base.strided.snanvarianceyc","@stdlib/blas/base/snrm2":"base.strided.snrm2","@stdlib/math/strided/special/sramp":"base.strided.sramp","@stdlib/stats/base/srange":"base.strided.srange","@stdlib/blas/ext/base/srev":"base.strided.srev","@stdlib/math/strided/special/srsqrt":"base.strided.srsqrt","@stdlib/blas/base/sscal":"base.strided.sscal","@stdlib/blas/ext/base/ssort2hp":"base.strided.ssort2hp","@stdlib/blas/ext/base/ssort2ins":"base.strided.ssort2ins","@stdlib/blas/ext/base/ssort2sh":"base.strided.ssort2sh","@stdlib/blas/ext/base/ssorthp":"base.strided.ssorthp","@stdlib/blas/ext/base/ssortins":"base.strided.ssortins","@stdlib/blas/ext/base/ssortsh":"base.strided.ssortsh","@stdlib/math/strided/special/ssqrt":"base.strided.ssqrt","@stdlib/stats/base/sstdev":"base.strided.sstdev","@stdlib/stats/base/sstdevch":"base.strided.sstdevch","@stdlib/stats/base/sstdevpn":"base.strided.sstdevpn","@stdlib/stats/base/sstdevtk":"base.strided.sstdevtk","@stdlib/stats/base/sstdevwd":"base.strided.sstdevwd","@stdlib/stats/base/sstdevyc":"base.strided.sstdevyc","@stdlib/blas/ext/base/ssum":"base.strided.ssum","@stdlib/blas/ext/base/ssumkbn":"base.strided.ssumkbn","@stdlib/blas/ext/base/ssumkbn2":"base.strided.ssumkbn2","@stdlib/blas/ext/base/ssumors":"base.strided.ssumors","@stdlib/blas/ext/base/ssumpw":"base.strided.ssumpw","@stdlib/blas/base/sswap":"base.strided.sswap","@stdlib/stats/base/stdev":"base.strided.stdev","@stdlib/stats/base/stdevch":"base.strided.stdevch","@stdlib/stats/base/stdevpn":"base.strided.stdevpn","@stdlib/stats/base/stdevtk":"base.strided.stdevtk","@stdlib/stats/base/stdevwd":"base.strided.stdevwd","@stdlib/stats/base/stdevyc":"base.strided.stdevyc","@stdlib/math/strided/special/strunc":"base.strided.strunc","@stdlib/stats/base/svariance":"base.strided.svariance","@stdlib/stats/base/svariancech":"base.strided.svariancech","@stdlib/stats/base/svariancepn":"base.strided.svariancepn","@stdlib/stats/base/svariancetk":"base.strided.svariancetk","@stdlib/stats/base/svariancewd":"base.strided.svariancewd","@stdlib/stats/base/svarianceyc":"base.strided.svarianceyc","@stdlib/strided/base/ternary":"base.strided.ternary","@stdlib/strided/base/unary":"base.strided.unary","@stdlib/strided/base/unary-by":"base.strided.unaryBy","@stdlib/strided/base/unary-dtype-signatures":"base.strided.unaryDtypeSignatures","@stdlib/strided/base/unary-signature-callbacks":"base.strided.unarySignatureCallbacks","@stdlib/stats/base/variance":"base.strided.variance","@stdlib/stats/base/variancech":"base.strided.variancech","@stdlib/stats/base/variancepn":"base.strided.variancepn","@stdlib/stats/base/variancetk":"base.strided.variancetk","@stdlib/stats/base/variancewd":"base.strided.variancewd","@stdlib/stats/base/varianceyc":"base.strided.varianceyc","@stdlib/strided/base/zmap":"base.strided.zmap","@stdlib/slice/base/str2multislice":"base.str2multislice","@stdlib/slice/base/str2slice":"base.str2slice","@stdlib/number/float64/base/sub":"base.sub","@stdlib/math/base/ops/subf":"base.subf","@stdlib/math/base/tools/sum-series":"base.sumSeries","@stdlib/math/base/special/tan":"base.tan","@stdlib/math/base/special/tand":"base.tand","@stdlib/math/base/special/tanh":"base.tanh","@stdlib/number/float64/base/to-binary-string":"base.toBinaryString","@stdlib/number/float32/base/to-binary-string":"base.toBinaryStringf","@stdlib/number/uint8/base/to-binary-string":"base.toBinaryStringUint8","@stdlib/number/uint16/base/to-binary-string":"base.toBinaryStringUint16","@stdlib/number/uint32/base/to-binary-string":"base.toBinaryStringUint32","@stdlib/number/float32/base/to-word":"base.toWordf","@stdlib/number/float64/base/to-words":"base.toWords","@stdlib/ndarray/base/transpose":"base.transpose","@stdlib/math/base/special/tribonacci":"base.tribonacci","@stdlib/math/base/special/trigamma":"base.trigamma","@stdlib/string/base/trim":"base.trim","@stdlib/math/base/special/trunc":"base.trunc","@stdlib/math/base/special/trunc2":"base.trunc2","@stdlib/math/base/special/trunc10":"base.trunc10","@stdlib/string/base/truncate-middle":"base.truncateMiddle","@stdlib/math/base/special/truncb":"base.truncb","@stdlib/math/base/special/truncf":"base.truncf","@stdlib/math/base/special/truncn":"base.truncn","@stdlib/math/base/special/truncsd":"base.truncsd","@stdlib/number/uint32/base/to-int32":"base.uint32ToInt32","@stdlib/math/base/ops/umul":"base.umul","@stdlib/math/base/ops/umuldw":"base.umuldw","@stdlib/string/base/uncapitalize":"base.uncapitalize","@stdlib/string/base/uppercase":"base.uppercase","@stdlib/math/base/special/vercos":"base.vercos","@stdlib/math/base/special/versin":"base.versin","@stdlib/math/base/special/wrap":"base.wrap","@stdlib/math/base/special/xlog1py":"base.xlog1py","@stdlib/math/base/special/xlogy":"base.xlogy","@stdlib/math/base/special/riemann-zeta":"base.zeta","@stdlib/bench":"bench","@stdlib/datasets/berndt-cps-wages-1985":"BERNDT_CPS_WAGES_1985","@stdlib/utils/bifurcate":"bifurcate","@stdlib/utils/bifurcate-by":"bifurcateBy","@stdlib/utils/async/bifurcate-by":"bifurcateByAsync","@stdlib/utils/bifurcate-in":"bifurcateIn","@stdlib/utils/bifurcate-own":"bifurcateOwn","@stdlib/bigint/ctor":"BigInt","@stdlib/stats/binomial-test":"binomialTest","@stdlib/boolean/ctor":"Boolean","@stdlib/array/bool":"BooleanArray","@stdlib/ndarray/broadcast-array":"broadcastArray","@stdlib/ndarray/broadcast-arrays":"broadcastArrays","@stdlib/buffer/ctor":"Buffer","@stdlib/buffer/to-json":"buffer2json","@stdlib/os/byte-order":"BYTE_ORDER","@stdlib/string/camelcase":"camelcase","@stdlib/string/capitalize":"capitalize","@stdlib/utils/capitalize-keys":"capitalizeKeys","@stdlib/constants/float64/catalan":"CATALAN","@stdlib/constants/float64/cbrt-eps":"CBRT_EPS","@stdlib/datasets/cdc-nchs-us-births-1969-1988":"CDC_NCHS_US_BIRTHS_1969_1988","@stdlib/datasets/cdc-nchs-us-births-1994-2003":"CDC_NCHS_US_BIRTHS_1994_2003","@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013":"CDC_NCHS_US_INFANT_MORTALITY_BW_1915_2013","@stdlib/process/chdir":"chdir","@stdlib/stats/chi2gof":"chi2gof","@stdlib/stats/chi2test":"chi2test","@stdlib/array/to-circular-iterator":"circarray2iterator","@stdlib/streams/node/from-circular-array":"circularArrayStream","@stdlib/dstructs/circular-buffer":"CircularBuffer","@stdlib/fs/close":"close","@stdlib/datasets/cmudict":"CMUDICT","@stdlib/string/code-point-at":"codePointAt","@stdlib/utils/common-keys":"commonKeys","@stdlib/utils/common-keys-in":"commonKeysIn","@stdlib/complex/cmplx":"complex","@stdlib/complex/float32/ctor":"Complex64","@stdlib/constants/complex64/nan":"COMPLEX64_NAN","@stdlib/constants/complex64/num-bytes":"COMPLEX64_NUM_BYTES","@stdlib/constants/complex64/zero":"COMPLEX64_ZERO","@stdlib/array/complex64":"Complex64Array","@stdlib/complex/float64/ctor":"Complex128","@stdlib/constants/complex128/nan":"COMPLEX128_NAN","@stdlib/constants/complex128/num-bytes":"COMPLEX128_NUM_BYTES","@stdlib/constants/complex128/zero":"COMPLEX128_ZERO","@stdlib/array/complex128":"Complex128Array","@stdlib/array/typed-complex":"complexarray","@stdlib/array/typed-complex-ctors":"complexarrayCtors","@stdlib/array/typed-complex-dtypes":"complexarrayDataTypes","@stdlib/complex/ctors":"complexCtors","@stdlib/complex/dtype":"complexDataType","@stdlib/complex/dtypes":"complexDataTypes","@stdlib/complex/promotion-rules":"complexPromotionRules","@stdlib/utils/compose":"compose","@stdlib/utils/async/compose":"composeAsync","@stdlib/os/configdir":"configdir","@stdlib/complex/float64/conj":"conj","@stdlib/complex/float32/conj":"conjf","@stdlib/string/constantcase":"constantcase","@stdlib/utils/constant-function":"constantFunction","@stdlib/streams/node/from-constant":"constantStream","@stdlib/utils/constructor-name":"constructorName","@stdlib/assert/contains":"contains","@stdlib/array/convert":"convertArray","@stdlib/array/convert-same":"convertArraySame","@stdlib/utils/convert-path":"convertPath","@stdlib/utils/copy":"copy","@stdlib/buffer/from-buffer":"copyBuffer","@stdlib/utils/count-by":"countBy","@stdlib/utils/async/count-by":"countByAsync","@stdlib/time/current-year":"currentYear","@stdlib/utils/curry":"curry","@stdlib/utils/curry-right":"curryRight","@stdlib/process/cwd":"cwd","@stdlib/datasets/dale-chall-new":"DALE_CHALL_NEW","@stdlib/datasets":"datasets","@stdlib/array/dataview":"DataView","@stdlib/array/datespace":"datespace","@stdlib/time/day-of-quarter":"dayOfQuarter","@stdlib/time/day-of-year":"dayOfYear","@stdlib/time/days-in-month":"daysInMonth","@stdlib/time/days-in-year":"daysInYear","@stdlib/blas/ddot":"ddot","@stdlib/streams/node/debug-sink":"debugSinkStream","@stdlib/streams/node/debug":"debugStream","@stdlib/utils/decorate-after":"decorateAfter","@stdlib/assert/deep-equal":"deepEqual","@stdlib/utils/deep-get":"deepGet","@stdlib/assert/deep-has-own-property":"deepHasOwnProp","@stdlib/assert/deep-has-property":"deepHasProp","@stdlib/utils/deep-pluck":"deepPluck","@stdlib/utils/deep-set":"deepSet","@stdlib/utils/define-memoized-property":"defineMemoizedProperty","@stdlib/utils/define-properties":"defineProperties","@stdlib/utils/define-property":"defineProperty","@stdlib/utils/dirname":"dirname","@stdlib/string/dotcase":"dotcase","@stdlib/dstructs/doubly-linked-list":"DoublyLinkedList","@stdlib/utils/do-until":"doUntil","@stdlib/utils/async/do-until":"doUntilAsync","@stdlib/utils/do-until-each":"doUntilEach","@stdlib/utils/do-until-each-right":"doUntilEachRight","@stdlib/utils/do-while":"doWhile","@stdlib/utils/async/do-while":"doWhileAsync","@stdlib/utils/do-while-each":"doWhileEach","@stdlib/utils/do-while-each-right":"doWhileEachRight","@stdlib/blas/dswap":"dswap","@stdlib/constants/float64/e":"E","@stdlib/datasets/emoji":"EMOJI","@stdlib/datasets/emoji-code-picto":"EMOJI_CODE_PICTO","@stdlib/datasets/emoji-picto-code":"EMOJI_PICTO_CODE","@stdlib/streams/node/empty":"emptyStream","@stdlib/string/ends-with":"endsWith","@stdlib/utils/enumerable-properties":"enumerableProperties","@stdlib/utils/enumerable-properties-in":"enumerablePropertiesIn","@stdlib/utils/enumerable-property-symbols":"enumerablePropertySymbols","@stdlib/utils/enumerable-property-symbols-in":"enumerablePropertySymbolsIn","@stdlib/process/env":"ENV","@stdlib/constants/float64/eps":"EPS","@stdlib/error/to-json":"error2json","@stdlib/constants/float64/eulergamma":"EULERGAMMA","@stdlib/utils/every":"every","@stdlib/utils/every-by":"everyBy","@stdlib/utils/async/every-by":"everyByAsync","@stdlib/utils/every-by-right":"everyByRight","@stdlib/utils/async/every-by-right":"everyByRightAsync","@stdlib/utils/every-in-by":"everyInBy","@stdlib/utils/every-own-by":"everyOwnBy","@stdlib/utils/eval":"evil","@stdlib/process/exec-path":"EXEC_PATH","@stdlib/fs/exists":"exists","@stdlib/nlp/expand-acronyms":"expandAcronyms","@stdlib/nlp/expand-contractions":"expandContractions","@stdlib/utils/extname":"extname","@stdlib/ndarray/fancy":"FancyArray","@stdlib/math/base/special/fast/abs":"fastmath.abs","@stdlib/math/base/special/fast/acosh":"fastmath.acosh","@stdlib/math/base/special/fast/alpha-max-plus-beta-min":"fastmath.ampbm","@stdlib/math/base/special/fast/asinh":"fastmath.asinh","@stdlib/math/base/special/fast/atanh":"fastmath.atanh","@stdlib/math/base/special/fast/hypot":"fastmath.hypot","@stdlib/math/base/special/fast/uint32-log2":"fastmath.log2Uint32","@stdlib/math/base/special/fast/max":"fastmath.max","@stdlib/math/base/special/fast/min":"fastmath.min","@stdlib/math/base/special/fast/pow-int":"fastmath.powint","@stdlib/math/base/special/fast/uint32-sqrt":"fastmath.sqrtUint32","@stdlib/datasets/female-first-names-en":"FEMALE_FIRST_NAMES_EN","@stdlib/dstructs/fifo":"FIFO","@stdlib/array/filled":"filledarray","@stdlib/array/filled-by":"filledarrayBy","@stdlib/utils/filter-arguments":"filterArguments","@stdlib/utils/find":"find","@stdlib/string/first":"firstChar","@stdlib/datasets/fivethirtyeight-ffq":"FIVETHIRTYEIGHT_FFQ","@stdlib/utils/flatten-array":"flattenArray","@stdlib/utils/flatten-object":"flattenObject","@stdlib/stats/fligner-test":"flignerTest","@stdlib/os/float-word-order":"FLOAT_WORD_ORDER","@stdlib/constants/float16/cbrt-eps":"FLOAT16_CBRT_EPS","@stdlib/constants/float16/eps":"FLOAT16_EPS","@stdlib/constants/float16/exponent-bias":"FLOAT16_EXPONENT_BIAS","@stdlib/constants/float16/max":"FLOAT16_MAX","@stdlib/constants/float16/max-safe-integer":"FLOAT16_MAX_SAFE_INTEGER","@stdlib/constants/float16/min-safe-integer":"FLOAT16_MIN_SAFE_INTEGER","@stdlib/constants/float16/ninf":"FLOAT16_NINF","@stdlib/constants/float16/num-bytes":"FLOAT16_NUM_BYTES","@stdlib/constants/float16/pinf":"FLOAT16_PINF","@stdlib/constants/float16/precision":"FLOAT16_PRECISION","@stdlib/constants/float16/smallest-normal":"FLOAT16_SMALLEST_NORMAL","@stdlib/constants/float16/smallest-subnormal":"FLOAT16_SMALLEST_SUBNORMAL","@stdlib/constants/float16/sqrt-eps":"FLOAT16_SQRT_EPS","@stdlib/constants/float32/abs-mask":"FLOAT32_ABS_MASK","@stdlib/constants/float32/cbrt-eps":"FLOAT32_CBRT_EPS","@stdlib/constants/float32/e":"FLOAT32_E","@stdlib/constants/float32/eps":"FLOAT32_EPS","@stdlib/constants/float32/exponent-bias":"FLOAT32_EXPONENT_BIAS","@stdlib/constants/float32/exponent-mask":"FLOAT32_EXPONENT_MASK","@stdlib/constants/float32/fourth-pi":"FLOAT32_FOURTH_PI","@stdlib/constants/float32/half-ln-two":"FLOAT32_HALF_LN_TWO","@stdlib/constants/float32/half-pi":"FLOAT32_HALF_PI","@stdlib/constants/float32/ln-half":"FLOAT32_LN_HALF","@stdlib/constants/float32/ln-pi":"FLOAT32_LN_PI","@stdlib/constants/float32/ln-ten":"FLOAT32_LN_TEN","@stdlib/constants/float32/ln-two":"FLOAT32_LN_TWO","@stdlib/constants/float32/max":"FLOAT32_MAX","@stdlib/constants/float32/max-base2-exponent":"FLOAT32_MAX_BASE2_EXPONENT","@stdlib/constants/float32/max-base2-exponent-subnormal":"FLOAT32_MAX_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float32/max-base10-exponent":"FLOAT32_MAX_BASE10_EXPONENT","@stdlib/constants/float32/max-base10-exponent-subnormal":"FLOAT32_MAX_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float32/max-safe-fibonacci":"FLOAT32_MAX_SAFE_FIBONACCI","@stdlib/constants/float32/max-safe-integer":"FLOAT32_MAX_SAFE_INTEGER","@stdlib/constants/float32/max-safe-nth-factorial":"FLOAT32_MAX_SAFE_NTH_FACTORIAL","@stdlib/constants/float32/max-safe-nth-fibonacci":"FLOAT32_MAX_SAFE_NTH_FIBONACCI","@stdlib/constants/float32/max-safe-nth-lucas":"FLOAT32_MAX_SAFE_NTH_LUCAS","@stdlib/constants/float32/min-base2-exponent":"FLOAT32_MIN_BASE2_EXPONENT","@stdlib/constants/float32/min-base2-exponent-subnormal":"FLOAT32_MIN_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float32/min-base10-exponent":"FLOAT32_MIN_BASE10_EXPONENT","@stdlib/constants/float32/min-base10-exponent-subnormal":"FLOAT32_MIN_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float32/min-safe-integer":"FLOAT32_MIN_SAFE_INTEGER","@stdlib/constants/float32/nan":"FLOAT32_NAN","@stdlib/constants/float32/ninf":"FLOAT32_NINF","@stdlib/constants/float32/num-bytes":"FLOAT32_NUM_BYTES","@stdlib/constants/float32/phi":"FLOAT32_PHI","@stdlib/constants/float32/pi":"FLOAT32_PI","@stdlib/constants/float32/pinf":"FLOAT32_PINF","@stdlib/constants/float32/precision":"FLOAT32_PRECISION","@stdlib/constants/float32/sign-mask":"FLOAT32_SIGN_MASK","@stdlib/constants/float32/significand-mask":"FLOAT32_SIGNIFICAND_MASK","@stdlib/constants/float32/smallest-normal":"FLOAT32_SMALLEST_NORMAL","@stdlib/constants/float32/smallest-subnormal":"FLOAT32_SMALLEST_SUBNORMAL","@stdlib/constants/float32/sqrt-eps":"FLOAT32_SQRT_EPS","@stdlib/constants/float32/sqrt-half":"FLOAT32_SQRT_HALF","@stdlib/constants/float32/sqrt-half-pi":"FLOAT32_SQRT_HALF_PI","@stdlib/constants/float32/sqrt-phi":"FLOAT32_SQRT_PHI","@stdlib/constants/float32/sqrt-pi":"FLOAT32_SQRT_PI","@stdlib/constants/float32/sqrt-three":"FLOAT32_SQRT_THREE","@stdlib/constants/float32/sqrt-two":"FLOAT32_SQRT_TWO","@stdlib/constants/float32/sqrt-two-pi":"FLOAT32_SQRT_TWO_PI","@stdlib/constants/float32/two-pi":"FLOAT32_TWO_PI","@stdlib/array/float32":"Float32Array","@stdlib/array/fixed-endian-float32":"Float32ArrayFE","@stdlib/array/little-endian-float32":"Float32ArrayLE","@stdlib/constants/float64/exponent-bias":"FLOAT64_EXPONENT_BIAS","@stdlib/constants/float64/high-word-abs-mask":"FLOAT64_HIGH_WORD_ABS_MASK","@stdlib/constants/float64/high-word-exponent-mask":"FLOAT64_HIGH_WORD_EXPONENT_MASK","@stdlib/constants/float64/high-word-sign-mask":"FLOAT64_HIGH_WORD_SIGN_MASK","@stdlib/constants/float64/high-word-significand-mask":"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK","@stdlib/constants/float64/max":"FLOAT64_MAX","@stdlib/constants/float64/max-base2-exponent":"FLOAT64_MAX_BASE2_EXPONENT","@stdlib/constants/float64/max-base2-exponent-subnormal":"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float64/max-base10-exponent":"FLOAT64_MAX_BASE10_EXPONENT","@stdlib/constants/float64/max-base10-exponent-subnormal":"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float64/max-ln":"FLOAT64_MAX_LN","@stdlib/constants/float64/max-safe-fibonacci":"FLOAT64_MAX_SAFE_FIBONACCI","@stdlib/constants/float64/max-safe-integer":"FLOAT64_MAX_SAFE_INTEGER","@stdlib/constants/float64/max-safe-lucas":"FLOAT64_MAX_SAFE_LUCAS","@stdlib/constants/float64/max-safe-nth-fibonacci":"FLOAT64_MAX_SAFE_NTH_FIBONACCI","@stdlib/constants/float64/max-safe-nth-lucas":"FLOAT64_MAX_SAFE_NTH_LUCAS","@stdlib/constants/float64/min-base2-exponent":"FLOAT64_MIN_BASE2_EXPONENT","@stdlib/constants/float64/min-base2-exponent-subnormal":"FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float64/min-base10-exponent":"FLOAT64_MIN_BASE10_EXPONENT","@stdlib/constants/float64/min-base10-exponent-subnormal":"FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float64/min-ln":"FLOAT64_MIN_LN","@stdlib/constants/float64/min-safe-integer":"FLOAT64_MIN_SAFE_INTEGER","@stdlib/constants/float64/num-bytes":"FLOAT64_NUM_BYTES","@stdlib/constants/float64/precision":"FLOAT64_PRECISION","@stdlib/constants/float64/smallest-normal":"FLOAT64_SMALLEST_NORMAL","@stdlib/constants/float64/smallest-subnormal":"FLOAT64_SMALLEST_SUBNORMAL","@stdlib/array/float64":"Float64Array","@stdlib/array/fixed-endian-float64":"Float64ArrayFE","@stdlib/array/little-endian-float64":"Float64ArrayLE","@stdlib/utils/for-each":"forEach","@stdlib/utils/async/for-each":"forEachAsync","@stdlib/string/for-each":"forEachChar","@stdlib/utils/for-each-right":"forEachRight","@stdlib/utils/async/for-each-right":"forEachRightAsync","@stdlib/utils/for-in":"forIn","@stdlib/string/format":"format","@stdlib/utils/for-own":"forOwn","@stdlib/constants/float64/fourth-pi":"FOURTH_PI","@stdlib/constants/float64/fourth-root-eps":"FOURTH_ROOT_EPS","@stdlib/datasets/frb-sf-wage-rigidity":"FRB_SF_WAGE_RIGIDITY","@stdlib/string/from-code-point":"fromCodePoint","@stdlib/function/ctor":"Function","@stdlib/function/to-string":"function2string","@stdlib/utils/function-name":"functionName","@stdlib/utils/function-sequence":"functionSequence","@stdlib/utils/async/function-sequence":"functionSequenceAsync","@stdlib/constants/float64/gamma-lanczos-g":"GAMMA_LANCZOS_G","@stdlib/blas/gdot":"gdot","@stdlib/process/getegid":"getegid","@stdlib/process/geteuid":"geteuid","@stdlib/process/getgid":"getgid","@stdlib/utils/global":"getGlobal","@stdlib/utils/get-prototype-of":"getPrototypeOf","@stdlib/process/getuid":"getuid","@stdlib/constants/float64/glaisher-kinkelin":"GLAISHER","@stdlib/string/to-grapheme-cluster-iterator":"graphemeClusters2iterator","@stdlib/string/to-grapheme-cluster-iterator-right":"graphemeClusters2iteratorRight","@stdlib/utils/group":"group","@stdlib/utils/group-by":"groupBy","@stdlib/utils/async/group-by":"groupByAsync","@stdlib/utils/group-in":"groupIn","@stdlib/utils/group-own":"groupOwn","@stdlib/blas/gswap":"gswap","@stdlib/constants/float64/half-ln-two":"HALF_LN2","@stdlib/constants/float64/half-pi":"HALF_PI","@stdlib/datasets/harrison-boston-house-prices":"HARRISON_BOSTON_HOUSE_PRICES","@stdlib/datasets/harrison-boston-house-prices-corrected":"HARRISON_BOSTON_HOUSE_PRICES_CORRECTED","@stdlib/assert/has-arraybuffer-support":"hasArrayBufferSupport","@stdlib/assert/has-arrow-function-support":"hasArrowFunctionSupport","@stdlib/assert/has-async-await-support":"hasAsyncAwaitSupport","@stdlib/assert/has-async-iterator-symbol-support":"hasAsyncIteratorSymbolSupport","@stdlib/assert/has-atob-support":"hasAtobSupport","@stdlib/assert/has-bigint64array-support":"hasBigInt64ArraySupport","@stdlib/assert/has-bigint-support":"hasBigIntSupport","@stdlib/assert/has-biguint64array-support":"hasBigUint64ArraySupport","@stdlib/assert/has-btoa-support":"hasBtoaSupport","@stdlib/assert/has-class-support":"hasClassSupport","@stdlib/assert/has-dataview-support":"hasDataViewSupport","@stdlib/assert/has-define-properties-support":"hasDefinePropertiesSupport","@stdlib/assert/has-define-property-support":"hasDefinePropertySupport","@stdlib/assert/has-float32array-support":"hasFloat32ArraySupport","@stdlib/assert/has-float64array-support":"hasFloat64ArraySupport","@stdlib/assert/has-function-name-support":"hasFunctionNameSupport","@stdlib/assert/has-generator-support":"hasGeneratorSupport","@stdlib/assert/has-globalthis-support":"hasGlobalThisSupport","@stdlib/assert/has-int8array-support":"hasInt8ArraySupport","@stdlib/assert/has-int16array-support":"hasInt16ArraySupport","@stdlib/assert/has-int32array-support":"hasInt32ArraySupport","@stdlib/assert/has-iterator-symbol-support":"hasIteratorSymbolSupport","@stdlib/assert/has-map-support":"hasMapSupport","@stdlib/assert/has-node-buffer-support":"hasNodeBufferSupport","@stdlib/assert/has-own-property":"hasOwnProp","@stdlib/assert/has-property":"hasProp","@stdlib/assert/has-proxy-support":"hasProxySupport","@stdlib/assert/has-set-support":"hasSetSupport","@stdlib/assert/has-sharedarraybuffer-support":"hasSharedArrayBufferSupport","@stdlib/assert/has-symbol-support":"hasSymbolSupport","@stdlib/assert/has-tostringtag-support":"hasToStringTagSupport","@stdlib/assert/has-uint8array-support":"hasUint8ArraySupport","@stdlib/assert/has-uint8clampedarray-support":"hasUint8ClampedArraySupport","@stdlib/assert/has-uint16array-support":"hasUint16ArraySupport","@stdlib/assert/has-uint32array-support":"hasUint32ArraySupport","@stdlib/assert/has-utf16-surrogate-pair-at":"hasUTF16SurrogatePairAt","@stdlib/assert/has-weakmap-support":"hasWeakMapSupport","@stdlib/assert/has-weakset-support":"hasWeakSetSupport","@stdlib/assert/has-wasm-support":"hasWebAssemblySupport","@stdlib/string/headercase":"headercase","@stdlib/datasets/herndon-venus-semidiameters":"HERNDON_VENUS_SEMIDIAMETERS","@stdlib/os/homedir":"homedir","@stdlib/constants/time/hours-in-day":"HOURS_IN_DAY","@stdlib/constants/time/hours-in-week":"HOURS_IN_WEEK","@stdlib/time/hours-in-month":"hoursInMonth","@stdlib/time/hours-in-year":"hoursInYear","@stdlib/net/http-server":"httpServer","@stdlib/utils/identity-function":"identity","@stdlib/utils/if-else":"ifelse","@stdlib/utils/async/if-else":"ifelseAsync","@stdlib/utils/if-then":"ifthen","@stdlib/utils/async/if-then":"ifthenAsync","@stdlib/complex/float64/imag":"imag","@stdlib/complex/float32/imag":"imagf","@stdlib/datasets/img-acanthus-mollis":"IMG_ACANTHUS_MOLLIS","@stdlib/datasets/img-airplane-from-above":"IMG_AIRPLANE_FROM_ABOVE","@stdlib/datasets/img-allium-oreophilum":"IMG_ALLIUM_OREOPHILUM","@stdlib/datasets/img-black-canyon":"IMG_BLACK_CANYON","@stdlib/datasets/img-dust-bowl-home":"IMG_DUST_BOWL_HOME","@stdlib/datasets/img-french-alpine-landscape":"IMG_FRENCH_ALPINE_LANDSCAPE","@stdlib/datasets/img-locomotion-house-cat":"IMG_LOCOMOTION_HOUSE_CAT","@stdlib/datasets/img-locomotion-nude-male":"IMG_LOCOMOTION_NUDE_MALE","@stdlib/datasets/img-march-pastoral":"IMG_MARCH_PASTORAL","@stdlib/datasets/img-nagasaki-boats":"IMG_NAGASAKI_BOATS","@stdlib/stats/incr/apcorr":"incrapcorr","@stdlib/ml/incr/binary-classification":"incrBinaryClassification","@stdlib/stats/incr/count":"incrcount","@stdlib/stats/incr/covariance":"incrcovariance","@stdlib/stats/incr/covmat":"incrcovmat","@stdlib/stats/incr/cv":"incrcv","@stdlib/stats/incr/ewmean":"increwmean","@stdlib/stats/incr/ewstdev":"increwstdev","@stdlib/stats/incr/ewvariance":"increwvariance","@stdlib/stats/incr/gmean":"incrgmean","@stdlib/stats/incr/grubbs":"incrgrubbs","@stdlib/stats/incr/hmean":"incrhmean","@stdlib/ml/incr/kmeans":"incrkmeans","@stdlib/stats/incr/kurtosis":"incrkurtosis","@stdlib/stats/incr/maape":"incrmaape","@stdlib/stats/incr/mae":"incrmae","@stdlib/stats/incr/mapcorr":"incrmapcorr","@stdlib/stats/incr/mape":"incrmape","@stdlib/stats/incr/max":"incrmax","@stdlib/stats/incr/maxabs":"incrmaxabs","@stdlib/stats/incr/mcovariance":"incrmcovariance","@stdlib/stats/incr/mcv":"incrmcv","@stdlib/stats/incr/mda":"incrmda","@stdlib/stats/incr/me":"incrme","@stdlib/stats/incr/mean":"incrmean","@stdlib/stats/incr/meanabs":"incrmeanabs","@stdlib/stats/incr/meanabs2":"incrmeanabs2","@stdlib/stats/incr/meanstdev":"incrmeanstdev","@stdlib/stats/incr/meanvar":"incrmeanvar","@stdlib/stats/incr/mgmean":"incrmgmean","@stdlib/stats/incr/mgrubbs":"incrmgrubbs","@stdlib/stats/incr/mhmean":"incrmhmean","@stdlib/stats/incr/midrange":"incrmidrange","@stdlib/stats/incr/min":"incrmin","@stdlib/stats/incr/minabs":"incrminabs","@stdlib/stats/incr/minmax":"incrminmax","@stdlib/stats/incr/minmaxabs":"incrminmaxabs","@stdlib/stats/incr/mmaape":"incrmmaape","@stdlib/stats/incr/mmae":"incrmmae","@stdlib/stats/incr/mmape":"incrmmape","@stdlib/stats/incr/mmax":"incrmmax","@stdlib/stats/incr/mmaxabs":"incrmmaxabs","@stdlib/stats/incr/mmda":"incrmmda","@stdlib/stats/incr/mme":"incrmme","@stdlib/stats/incr/mmean":"incrmmean","@stdlib/stats/incr/mmeanabs":"incrmmeanabs","@stdlib/stats/incr/mmeanabs2":"incrmmeanabs2","@stdlib/stats/incr/mmeanstdev":"incrmmeanstdev","@stdlib/stats/incr/mmeanvar":"incrmmeanvar","@stdlib/stats/incr/mmidrange":"incrmmidrange","@stdlib/stats/incr/mmin":"incrmmin","@stdlib/stats/incr/mminabs":"incrmminabs","@stdlib/stats/incr/mminmax":"incrmminmax","@stdlib/stats/incr/mminmaxabs":"incrmminmaxabs","@stdlib/stats/incr/mmpe":"incrmmpe","@stdlib/stats/incr/mmse":"incrmmse","@stdlib/stats/incr/mpcorr":"incrmpcorr","@stdlib/stats/incr/mpcorr2":"incrmpcorr2","@stdlib/stats/incr/mpcorrdist":"incrmpcorrdist","@stdlib/stats/incr/mpe":"incrmpe","@stdlib/stats/incr/mprod":"incrmprod","@stdlib/stats/incr/mrange":"incrmrange","@stdlib/stats/incr/mrmse":"incrmrmse","@stdlib/stats/incr/mrss":"incrmrss","@stdlib/stats/incr/mse":"incrmse","@stdlib/stats/incr/mstdev":"incrmstdev","@stdlib/stats/incr/msum":"incrmsum","@stdlib/stats/incr/msumabs":"incrmsumabs","@stdlib/stats/incr/msumabs2":"incrmsumabs2","@stdlib/stats/incr/msummary":"incrmsummary","@stdlib/stats/incr/msumprod":"incrmsumprod","@stdlib/stats/incr/mvariance":"incrmvariance","@stdlib/stats/incr/mvmr":"incrmvmr","@stdlib/stats/incr/nancount":"incrnancount","@stdlib/stats/incr/nansum":"incrnansum","@stdlib/stats/incr/nansumabs":"incrnansumabs","@stdlib/stats/incr/nansumabs2":"incrnansumabs2","@stdlib/stats/incr/pcorr":"incrpcorr","@stdlib/stats/incr/pcorr2":"incrpcorr2","@stdlib/stats/incr/pcorrdist":"incrpcorrdist","@stdlib/stats/incr/pcorrdistmat":"incrpcorrdistmat","@stdlib/stats/incr/pcorrmat":"incrpcorrmat","@stdlib/stats/incr/prod":"incrprod","@stdlib/stats/incr/range":"incrrange","@stdlib/stats/incr/rmse":"incrrmse","@stdlib/stats/incr/rss":"incrrss","@stdlib/ml/incr/sgd-regression":"incrSGDRegression","@stdlib/stats/incr/skewness":"incrskewness","@stdlib/array/incrspace":"incrspace","@stdlib/stats/incr/stdev":"incrstdev","@stdlib/stats/incr/sum":"incrsum","@stdlib/stats/incr/sumabs":"incrsumabs","@stdlib/stats/incr/sumabs2":"incrsumabs2","@stdlib/stats/incr/summary":"incrsummary","@stdlib/stats/incr/sumprod":"incrsumprod","@stdlib/stats/incr/variance":"incrvariance","@stdlib/stats/incr/vmr":"incrvmr","@stdlib/stats/incr/wmean":"incrwmean","@stdlib/ndarray/ind2sub":"ind2sub","@stdlib/utils/index-of":"indexOf","@stdlib/utils/inherit":"inherit","@stdlib/utils/inherited-enumerable-properties":"inheritedEnumerableProperties","@stdlib/utils/inherited-enumerable-property-symbols":"inheritedEnumerablePropertySymbols","@stdlib/utils/inherited-keys":"inheritedKeys","@stdlib/utils/inherited-nonenumerable-properties":"inheritedNonEnumerableProperties","@stdlib/utils/inherited-nonenumerable-property-names":"inheritedNonEnumerablePropertyNames","@stdlib/utils/inherited-nonenumerable-property-symbols":"inheritedNonEnumerablePropertySymbols","@stdlib/utils/inherited-properties":"inheritedProperties","@stdlib/utils/inherited-property-descriptor":"inheritedPropertyDescriptor","@stdlib/utils/inherited-property-descriptors":"inheritedPropertyDescriptors","@stdlib/utils/inherited-property-names":"inheritedPropertyNames","@stdlib/utils/inherited-property-symbols":"inheritedPropertySymbols","@stdlib/utils/inherited-writable-properties":"inheritedWritableProperties","@stdlib/utils/inherited-writable-property-names":"inheritedWritablePropertyNames","@stdlib/utils/inherited-writable-property-symbols":"inheritedWritablePropertySymbols","@stdlib/utils/inmap":"inmap","@stdlib/utils/async/inmap":"inmapAsync","@stdlib/utils/inmap-right":"inmapRight","@stdlib/utils/async/inmap-right":"inmapRightAsync","@stdlib/streams/node/inspect-sink":"inspectSinkStream","@stdlib/streams/node/inspect":"inspectStream","@stdlib/assert/instance-of":"instanceOf","@stdlib/constants/int8/max":"INT8_MAX","@stdlib/constants/int8/min":"INT8_MIN","@stdlib/constants/int8/num-bytes":"INT8_NUM_BYTES","@stdlib/array/int8":"Int8Array","@stdlib/constants/int16/max":"INT16_MAX","@stdlib/constants/int16/min":"INT16_MIN","@stdlib/constants/int16/num-bytes":"INT16_NUM_BYTES","@stdlib/array/int16":"Int16Array","@stdlib/constants/int32/max":"INT32_MAX","@stdlib/constants/int32/min":"INT32_MIN","@stdlib/constants/int32/num-bytes":"INT32_NUM_BYTES","@stdlib/array/int32":"Int32Array","@stdlib/assert/is-big-endian":"IS_BIG_ENDIAN","@stdlib/assert/is-browser":"IS_BROWSER","@stdlib/assert/is-darwin":"IS_DARWIN","@stdlib/assert/is-docker":"IS_DOCKER","@stdlib/assert/is-electron":"IS_ELECTRON","@stdlib/assert/is-electron-main":"IS_ELECTRON_MAIN","@stdlib/assert/is-electron-renderer":"IS_ELECTRON_RENDERER","@stdlib/assert/is-little-endian":"IS_LITTLE_ENDIAN","@stdlib/assert/is-mobile":"IS_MOBILE","@stdlib/assert/is-node":"IS_NODE","@stdlib/assert/is-touch-device":"IS_TOUCH_DEVICE","@stdlib/assert/is-web-worker":"IS_WEB_WORKER","@stdlib/assert/is-windows":"IS_WINDOWS","@stdlib/assert/is-absolute-http-uri":"isAbsoluteHttpURI","@stdlib/assert/is-absolute-path":"isAbsolutePath","@stdlib/assert/is-absolute-uri":"isAbsoluteURI","@stdlib/assert/is-accessor-array":"isAccessorArray","@stdlib/assert/is-accessor-property":"isAccessorProperty","@stdlib/assert/is-accessor-property-in":"isAccessorPropertyIn","@stdlib/assert/is-alphagram":"isAlphagram","@stdlib/assert/is-alphanumeric":"isAlphaNumeric","@stdlib/assert/is-anagram":"isAnagram","@stdlib/assert/is-arguments":"isArguments","@stdlib/assert/is-array":"isArray","@stdlib/assert/is-array-array":"isArrayArray","@stdlib/assert/is-arraybuffer":"isArrayBuffer","@stdlib/assert/is-arraybuffer-view":"isArrayBufferView","@stdlib/assert/is-array-length":"isArrayLength","@stdlib/assert/is-array-like":"isArrayLike","@stdlib/assert/is-array-like-object":"isArrayLikeObject","@stdlib/assert/is-arrow-function":"isArrowFunction","@stdlib/assert/is-ascii":"isASCII","@stdlib/assert/is-between":"isBetween","@stdlib/assert/is-between-array":"isBetweenArray","@stdlib/assert/is-bigint":"isBigInt","@stdlib/assert/is-bigint64array":"isBigInt64Array","@stdlib/assert/is-biguint64array":"isBigUint64Array","@stdlib/assert/is-binary-string":"isBinaryString","@stdlib/assert/is-blank-string":"isBlankString","@stdlib/assert/is-boolean":"isBoolean","@stdlib/assert/is-boolean-array":"isBooleanArray","@stdlib/assert/is-boxed-primitive":"isBoxedPrimitive","@stdlib/assert/is-buffer":"isBuffer","@stdlib/assert/is-camelcase":"isCamelcase","@stdlib/assert/is-capitalized":"isCapitalized","@stdlib/assert/is-centrosymmetric-matrix":"isCentrosymmetricMatrix","@stdlib/assert/is-circular":"isCircular","@stdlib/assert/is-circular-array":"isCircularArray","@stdlib/assert/is-circular-plain-object":"isCircularPlainObject","@stdlib/assert/is-class":"isClass","@stdlib/assert/is-collection":"isCollection","@stdlib/assert/is-complex":"isComplex","@stdlib/assert/is-complex64":"isComplex64","@stdlib/assert/is-complex64array":"isComplex64Array","@stdlib/assert/is-complex64matrix-like":"isComplex64MatrixLike","@stdlib/assert/is-complex64ndarray-like":"isComplex64ndarrayLike","@stdlib/assert/is-complex64vector-like":"isComplex64VectorLike","@stdlib/assert/is-complex128":"isComplex128","@stdlib/assert/is-complex128array":"isComplex128Array","@stdlib/assert/is-complex128matrix-like":"isComplex128MatrixLike","@stdlib/assert/is-complex128ndarray-like":"isComplex128ndarrayLike","@stdlib/assert/is-complex128vector-like":"isComplex128VectorLike","@stdlib/assert/is-complex-like":"isComplexLike","@stdlib/assert/is-complex-typed-array":"isComplexTypedArray","@stdlib/assert/is-complex-typed-array-like":"isComplexTypedArrayLike","@stdlib/assert/is-composite":"isComposite","@stdlib/assert/is-configurable-property":"isConfigurableProperty","@stdlib/assert/is-configurable-property-in":"isConfigurablePropertyIn","@stdlib/assert/is-constantcase":"isConstantcase","@stdlib/assert/is-cube-number":"isCubeNumber","@stdlib/assert/is-current-year":"isCurrentYear","@stdlib/assert/is-data-property":"isDataProperty","@stdlib/assert/is-data-property-in":"isDataPropertyIn","@stdlib/assert/is-dataview":"isDataView","@stdlib/assert/is-date-object":"isDateObject","@stdlib/assert/is-date-object-array":"isDateObjectArray","@stdlib/assert/is-digit-string":"isDigitString","@stdlib/assert/is-domain-name":"isDomainName","@stdlib/assert/is-duration-string":"isDurationString","@stdlib/assert/is-email-address":"isEmailAddress","@stdlib/assert/is-empty-array":"isEmptyArray","@stdlib/assert/is-empty-array-like-object":"isEmptyArrayLikeObject","@stdlib/assert/is-empty-collection":"isEmptyCollection","@stdlib/assert/is-empty-object":"isEmptyObject","@stdlib/assert/is-empty-string":"isEmptyString","@stdlib/assert/is-enumerable-property":"isEnumerableProperty","@stdlib/assert/is-enumerable-property-in":"isEnumerablePropertyIn","@stdlib/assert/is-equal-array":"isEqualArray","@stdlib/assert/is-error":"isError","@stdlib/assert/is-eval-error":"isEvalError","@stdlib/assert/is-even":"isEven","@stdlib/assert/is-falsy":"isFalsy","@stdlib/assert/is-falsy-array":"isFalsyArray","@stdlib/assert/is-finite":"isFinite","@stdlib/assert/is-finite-array":"isFiniteArray","@stdlib/assert/is-float32array":"isFloat32Array","@stdlib/assert/is-float32matrix-like":"isFloat32MatrixLike","@stdlib/assert/is-float32ndarray-like":"isFloat32ndarrayLike","@stdlib/assert/is-float32vector-like":"isFloat32VectorLike","@stdlib/assert/is-float64array":"isFloat64Array","@stdlib/assert/is-float64matrix-like":"isFloat64MatrixLike","@stdlib/assert/is-float64ndarray-like":"isFloat64ndarrayLike","@stdlib/assert/is-float64vector-like":"isFloat64VectorLike","@stdlib/assert/is-function":"isFunction","@stdlib/assert/is-function-array":"isFunctionArray","@stdlib/assert/is-generator-object":"isGeneratorObject","@stdlib/assert/is-generator-object-like":"isGeneratorObjectLike","@stdlib/assert/is-gzip-buffer":"isgzipBuffer","@stdlib/assert/is-hex-string":"isHexString","@stdlib/assert/is-infinite":"isInfinite","@stdlib/assert/is-inherited-property":"isInheritedProperty","@stdlib/assert/is-int8array":"isInt8Array","@stdlib/assert/is-int16array":"isInt16Array","@stdlib/assert/is-int32array":"isInt32Array","@stdlib/assert/is-integer":"isInteger","@stdlib/assert/is-integer-array":"isIntegerArray","@stdlib/assert/is-iterable-like":"isIterableLike","@stdlib/assert/is-iterator-like":"isIteratorLike","@stdlib/assert/is-json":"isJSON","@stdlib/assert/is-kebabcase":"isKebabcase","@stdlib/assert/is-leap-year":"isLeapYear","@stdlib/assert/is-localhost":"isLocalhost","@stdlib/assert/is-lowercase":"isLowercase","@stdlib/assert/is-matrix-like":"isMatrixLike","@stdlib/assert/is-method":"isMethod","@stdlib/assert/is-method-in":"isMethodIn","@stdlib/assert/is-multi-slice":"isMultiSlice","@stdlib/assert/is-named-typed-tuple-like":"isNamedTypedTupleLike","@stdlib/assert/is-nan":"isnan","@stdlib/assert/is-nan-array":"isNaNArray","@stdlib/assert/is-native-function":"isNativeFunction","@stdlib/assert/is-ndarray-like":"isndarrayLike","@stdlib/assert/is-ndarray-like-with-data-type":"isndarrayLikeWithDataType","@stdlib/assert/is-negative-finite":"isNegativeFinite","@stdlib/assert/is-negative-integer":"isNegativeInteger","@stdlib/assert/is-negative-integer-array":"isNegativeIntegerArray","@stdlib/assert/is-negative-number":"isNegativeNumber","@stdlib/assert/is-negative-number-array":"isNegativeNumberArray","@stdlib/assert/is-negative-zero":"isNegativeZero","@stdlib/assert/is-node-builtin":"isNodeBuiltin","@stdlib/assert/is-node-duplex-stream-like":"isNodeDuplexStreamLike","@stdlib/assert/is-node-readable-stream-like":"isNodeReadableStreamLike","@stdlib/assert/is-node-repl":"isNodeREPL","@stdlib/assert/is-node-stream-like":"isNodeStreamLike","@stdlib/assert/is-node-transform-stream-like":"isNodeTransformStreamLike","@stdlib/assert/is-node-writable-stream-like":"isNodeWritableStreamLike","@stdlib/assert/is-nonconfigurable-property":"isNonConfigurableProperty","@stdlib/assert/is-nonconfigurable-property-in":"isNonConfigurablePropertyIn","@stdlib/assert/is-nonenumerable-property":"isNonEnumerableProperty","@stdlib/assert/is-nonenumerable-property-in":"isNonEnumerablePropertyIn","@stdlib/assert/is-nonnegative-finite":"isNonNegativeFinite","@stdlib/assert/is-nonnegative-integer":"isNonNegativeInteger","@stdlib/assert/is-nonnegative-integer-array":"isNonNegativeIntegerArray","@stdlib/assert/is-nonnegative-number":"isNonNegativeNumber","@stdlib/assert/is-nonnegative-number-array":"isNonNegativeNumberArray","@stdlib/assert/is-nonpositive-finite":"isNonPositiveFinite","@stdlib/assert/is-nonpositive-integer":"isNonPositiveInteger","@stdlib/assert/is-nonpositive-integer-array":"isNonPositiveIntegerArray","@stdlib/assert/is-nonpositive-number":"isNonPositiveNumber","@stdlib/assert/is-nonpositive-number-array":"isNonPositiveNumberArray","@stdlib/assert/is-nonsymmetric-matrix":"isNonSymmetricMatrix","@stdlib/assert/is-null":"isNull","@stdlib/assert/is-null-array":"isNullArray","@stdlib/assert/is-number":"isNumber","@stdlib/assert/is-number-array":"isNumberArray","@stdlib/assert/is-numeric-array":"isNumericArray","@stdlib/assert/is-object":"isObject","@stdlib/assert/is-object-array":"isObjectArray","@stdlib/assert/is-object-like":"isObjectLike","@stdlib/assert/is-odd":"isOdd","@stdlib/time/iso-weeks-in-year":"isoWeeksInYear","@stdlib/assert/is-pascalcase":"isPascalcase","@stdlib/assert/is-persymmetric-matrix":"isPersymmetricMatrix","@stdlib/assert/is-plain-object":"isPlainObject","@stdlib/assert/is-plain-object-array":"isPlainObjectArray","@stdlib/assert/is-positive-finite":"isPositiveFinite","@stdlib/assert/is-positive-integer":"isPositiveInteger","@stdlib/assert/is-positive-integer-array":"isPositiveIntegerArray","@stdlib/assert/is-positive-number":"isPositiveNumber","@stdlib/assert/is-positive-number-array":"isPositiveNumberArray","@stdlib/assert/is-positive-zero":"isPositiveZero","@stdlib/assert/is-prime":"isPrime","@stdlib/assert/is-primitive":"isPrimitive","@stdlib/assert/is-primitive-array":"isPrimitiveArray","@stdlib/assert/is-prng-like":"isPRNGLike","@stdlib/assert/is-probability":"isProbability","@stdlib/assert/is-probability-array":"isProbabilityArray","@stdlib/assert/is-property-key":"isPropertyKey","@stdlib/assert/is-prototype-of":"isPrototypeOf","@stdlib/assert/is-ragged-nested-array":"isRaggedNestedArray","@stdlib/assert/is-range-error":"isRangeError","@stdlib/assert/is-readable-property":"isReadableProperty","@stdlib/assert/is-readable-property-in":"isReadablePropertyIn","@stdlib/assert/is-read-only-property":"isReadOnlyProperty","@stdlib/assert/is-read-only-property-in":"isReadOnlyPropertyIn","@stdlib/assert/is-read-write-property":"isReadWriteProperty","@stdlib/assert/is-read-write-property-in":"isReadWritePropertyIn","@stdlib/assert/is-reference-error":"isReferenceError","@stdlib/assert/is-regexp":"isRegExp","@stdlib/assert/is-regexp-string":"isRegExpString","@stdlib/assert/is-relative-path":"isRelativePath","@stdlib/assert/is-relative-uri":"isRelativeURI","@stdlib/assert/is-safe-integer":"isSafeInteger","@stdlib/assert/is-safe-integer-array":"isSafeIntegerArray","@stdlib/assert/is-same-array":"isSameArray","@stdlib/assert/is-same-array-like":"isSameArrayLike","@stdlib/assert/is-same-complex64":"isSameComplex64","@stdlib/assert/is-same-complex64array":"isSameComplex64Array","@stdlib/assert/is-same-complex128":"isSameComplex128","@stdlib/assert/is-same-complex128array":"isSameComplex128Array","@stdlib/assert/is-same-date-object":"isSameDateObject","@stdlib/assert/is-same-float32array":"isSameFloat32Array","@stdlib/assert/is-same-float64array":"isSameFloat64Array","@stdlib/assert/is-same-native-class":"isSameNativeClass","@stdlib/assert/is-same-type":"isSameType","@stdlib/assert/is-same-value":"isSameValue","@stdlib/assert/is-same-value-zero":"isSameValueZero","@stdlib/assert/is-semver":"isSemVer","@stdlib/assert/is-sharedarraybuffer":"isSharedArrayBuffer","@stdlib/assert/is-skew-centrosymmetric-matrix":"isSkewCentrosymmetricMatrix","@stdlib/assert/is-skew-persymmetric-matrix":"isSkewPersymmetricMatrix","@stdlib/assert/is-skew-symmetric-matrix":"isSkewSymmetricMatrix","@stdlib/assert/is-slice":"isSlice","@stdlib/assert/is-snakecase":"isSnakecase","@stdlib/assert/is-square-matrix":"isSquareMatrix","@stdlib/assert/is-square-number":"isSquareNumber","@stdlib/assert/is-square-triangular-number":"isSquareTriangularNumber","@stdlib/assert/is-startcase":"isStartcase","@stdlib/assert/is-strict-equal":"isStrictEqual","@stdlib/assert/is-string":"isString","@stdlib/assert/is-string-array":"isStringArray","@stdlib/assert/is-symbol":"isSymbol","@stdlib/assert/is-symbol-array":"isSymbolArray","@stdlib/assert/is-symmetric-matrix":"isSymmetricMatrix","@stdlib/assert/is-syntax-error":"isSyntaxError","@stdlib/assert/is-triangular-number":"isTriangularNumber","@stdlib/assert/is-truthy":"isTruthy","@stdlib/assert/is-truthy-array":"isTruthyArray","@stdlib/assert/is-typed-array":"isTypedArray","@stdlib/assert/is-typed-array-length":"isTypedArrayLength","@stdlib/assert/is-typed-array-like":"isTypedArrayLike","@stdlib/assert/is-type-error":"isTypeError","@stdlib/assert/is-uint8array":"isUint8Array","@stdlib/assert/is-uint8clampedarray":"isUint8ClampedArray","@stdlib/assert/is-uint16array":"isUint16Array","@stdlib/assert/is-uint32array":"isUint32Array","@stdlib/assert/is-unc-path":"isUNCPath","@stdlib/assert/is-undefined":"isUndefined","@stdlib/assert/is-undefined-or-null":"isUndefinedOrNull","@stdlib/assert/is-unity-probability-array":"isUnityProbabilityArray","@stdlib/assert/is-uppercase":"isUppercase","@stdlib/assert/is-uri":"isURI","@stdlib/assert/is-uri-error":"isURIError","@stdlib/assert/is-vector-like":"isVectorLike","@stdlib/assert/is-wasm-memory":"isWebAssemblyMemory","@stdlib/assert/is-well-formed-string":"isWellFormedString","@stdlib/assert/is-whitespace":"isWhitespace","@stdlib/assert/is-writable-property":"isWritableProperty","@stdlib/assert/is-writable-property-in":"isWritablePropertyIn","@stdlib/assert/is-write-only-property":"isWriteOnlyProperty","@stdlib/assert/is-write-only-property-in":"isWriteOnlyPropertyIn","@stdlib/math/iter/special/abs":"iterAbs","@stdlib/math/iter/special/abs2":"iterAbs2","@stdlib/math/iter/special/acos":"iterAcos","@stdlib/math/iter/special/acosh":"iterAcosh","@stdlib/math/iter/special/acot":"iterAcot","@stdlib/math/iter/special/acoth":"iterAcoth","@stdlib/math/iter/special/acovercos":"iterAcovercos","@stdlib/math/iter/special/acoversin":"iterAcoversin","@stdlib/math/iter/ops/add":"iterAdd","@stdlib/iter/advance":"iterAdvance","@stdlib/math/iter/special/ahavercos":"iterAhavercos","@stdlib/math/iter/special/ahaversin":"iterAhaversin","@stdlib/iter/any":"iterAny","@stdlib/iter/any-by":"iterAnyBy","@stdlib/math/iter/special/asin":"iterAsin","@stdlib/math/iter/special/asinh":"iterAsinh","@stdlib/math/iter/special/atan":"iterAtan","@stdlib/math/iter/special/atan2":"iterAtan2","@stdlib/math/iter/special/atanh":"iterAtanh","@stdlib/array/from-iterator":"iterator2array","@stdlib/iter/to-array-view":"iterator2arrayview","@stdlib/iter/to-array-view-right":"iterator2arrayviewRight","@stdlib/streams/node/from-iterator":"iteratorStream","@stdlib/symbol/iterator":"IteratorSymbol","@stdlib/math/iter/special/avercos":"iterAvercos","@stdlib/math/iter/special/aversin":"iterAversin","@stdlib/simulate/iter/awgn":"iterawgn","@stdlib/simulate/iter/awln":"iterawln","@stdlib/simulate/iter/awun":"iterawun","@stdlib/simulate/iter/bartlett-hann-pulse":"iterBartlettHannPulse","@stdlib/simulate/iter/bartlett-pulse":"iterBartlettPulse","@stdlib/math/iter/special/besselj0":"iterBesselj0","@stdlib/math/iter/special/besselj1":"iterBesselj1","@stdlib/math/iter/special/bessely0":"iterBessely0","@stdlib/math/iter/special/bessely1":"iterBessely1","@stdlib/math/iter/special/beta":"iterBeta","@stdlib/math/iter/special/betaln":"iterBetaln","@stdlib/math/iter/special/binet":"iterBinet","@stdlib/math/iter/special/cbrt":"iterCbrt","@stdlib/math/iter/special/ceil":"iterCeil","@stdlib/math/iter/special/ceil2":"iterCeil2","@stdlib/math/iter/special/ceil10":"iterCeil10","@stdlib/math/iter/sequences/composites":"iterCompositesSeq","@stdlib/iter/concat":"iterConcat","@stdlib/iter/constant":"iterConstant","@stdlib/math/iter/utils/continued-fraction":"iterContinuedFraction","@stdlib/math/iter/sequences/continued-fraction":"iterContinuedFractionSeq","@stdlib/math/iter/special/cos":"iterCos","@stdlib/math/iter/special/cosh":"iterCosh","@stdlib/simulate/iter/cosine-wave":"iterCosineWave","@stdlib/math/iter/special/cosm1":"iterCosm1","@stdlib/math/iter/special/cospi":"iterCospi","@stdlib/iter/counter":"iterCounter","@stdlib/math/iter/special/covercos":"iterCovercos","@stdlib/math/iter/special/coversin":"iterCoversin","@stdlib/math/iter/sequences/cubes":"iterCubesSeq","@stdlib/stats/iter/cugmean":"itercugmean","@stdlib/stats/iter/cuhmean":"itercuhmean","@stdlib/stats/iter/cumax":"itercumax","@stdlib/stats/iter/cumaxabs":"itercumaxabs","@stdlib/stats/iter/cumean":"itercumean","@stdlib/stats/iter/cumeanabs":"itercumeanabs","@stdlib/stats/iter/cumeanabs2":"itercumeanabs2","@stdlib/stats/iter/cumidrange":"itercumidrange","@stdlib/stats/iter/cumin":"itercumin","@stdlib/stats/iter/cuminabs":"itercuminabs","@stdlib/stats/iter/cuprod":"itercuprod","@stdlib/stats/iter/curange":"itercurange","@stdlib/stats/iter/cusum":"itercusum","@stdlib/stats/iter/cusumabs":"itercusumabs","@stdlib/stats/iter/cusumabs2":"itercusumabs2","@stdlib/iter/datespace":"iterDatespace","@stdlib/iter/dedupe":"iterDedupe","@stdlib/iter/dedupe-by":"iterDedupeBy","@stdlib/math/iter/special/deg2rad":"iterDeg2rad","@stdlib/math/iter/special/digamma":"iterDigamma","@stdlib/simulate/iter/dirac-comb":"iterDiracComb","@stdlib/math/iter/special/dirac-delta":"iterDiracDelta","@stdlib/math/iter/ops/divide":"iterDivide","@stdlib/iter/do-until-each":"iterDoUntilEach","@stdlib/iter/do-while-each":"iterDoWhileEach","@stdlib/math/iter/special/ellipe":"iterEllipe","@stdlib/math/iter/special/ellipk":"iterEllipk","@stdlib/iter/empty":"iterEmpty","@stdlib/math/iter/special/erf":"iterErf","@stdlib/math/iter/special/erfc":"iterErfc","@stdlib/math/iter/special/erfcinv":"iterErfcinv","@stdlib/math/iter/special/erfinv":"iterErfinv","@stdlib/math/iter/special/dirichlet-eta":"iterEta","@stdlib/math/iter/sequences/even-integers":"iterEvenIntegersSeq","@stdlib/iter/every":"iterEvery","@stdlib/iter/every-by":"iterEveryBy","@stdlib/math/iter/special/exp":"iterExp","@stdlib/math/iter/special/exp2":"iterExp2","@stdlib/math/iter/special/exp10":"iterExp10","@stdlib/math/iter/special/expit":"iterExpit","@stdlib/math/iter/special/expm1":"iterExpm1","@stdlib/math/iter/special/expm1rel":"iterExpm1rel","@stdlib/math/iter/special/factorial":"iterFactorial","@stdlib/math/iter/special/factorialln":"iterFactorialln","@stdlib/math/iter/sequences/factorials":"iterFactorialsSeq","@stdlib/math/iter/sequences/fibonacci":"iterFibonacciSeq","@stdlib/math/iter/sequences/fifth-powers":"iterFifthPowersSeq","@stdlib/iter/fill":"iterFill","@stdlib/iter/filter":"iterFilter","@stdlib/iter/filter-map":"iterFilterMap","@stdlib/iter/first":"iterFirst","@stdlib/simulate/iter/flat-top-pulse":"iterFlatTopPulse","@stdlib/math/iter/special/floor":"iterFloor","@stdlib/math/iter/special/floor2":"iterFloor2","@stdlib/math/iter/special/floor10":"iterFloor10","@stdlib/iter/flow":"iterFlow","@stdlib/iter/for-each":"iterForEach","@stdlib/math/iter/sequences/fourth-powers":"iterFourthPowersSeq","@stdlib/math/iter/special/fresnelc":"iterFresnelc","@stdlib/math/iter/special/fresnels":"iterFresnels","@stdlib/math/iter/special/gamma":"iterGamma","@stdlib/math/iter/special/gamma1pm1":"iterGamma1pm1","@stdlib/math/iter/special/gammaln":"iterGammaln","@stdlib/math/iter/special/hacovercos":"iterHacovercos","@stdlib/math/iter/special/hacoversin":"iterHacoversin","@stdlib/simulate/iter/hann-pulse":"iterHannPulse","@stdlib/math/iter/special/havercos":"iterHavercos","@stdlib/math/iter/special/haversin":"iterHaversin","@stdlib/iter/head":"iterHead","@stdlib/iter/incrspace":"iterIncrspace","@stdlib/math/iter/sequences/integers":"iterIntegersSeq","@stdlib/iter/intersection":"iterIntersection","@stdlib/iter/intersection-by-hash":"iterIntersectionByHash","@stdlib/math/iter/special/inv":"iterInv","@stdlib/simulate/iter/lanczos-pulse":"iterLanczosPulse","@stdlib/iter/last":"iterLast","@stdlib/iter/length":"iterLength","@stdlib/iter/linspace":"iterLinspace","@stdlib/math/iter/special/ln":"iterLn","@stdlib/math/iter/special/log":"iterLog","@stdlib/math/iter/special/log1mexp":"iterLog1mexp","@stdlib/math/iter/special/log1p":"iterLog1p","@stdlib/math/iter/special/log1pexp":"iterLog1pexp","@stdlib/math/iter/special/log2":"iterLog2","@stdlib/math/iter/special/log10":"iterLog10","@stdlib/math/iter/special/logit":"iterLogit","@stdlib/iter/logspace":"iterLogspace","@stdlib/math/iter/sequences/lucas":"iterLucasSeq","@stdlib/iter/map":"iterMap","@stdlib/iter/mapn":"iterMapN","@stdlib/stats/iter/max":"itermax","@stdlib/stats/iter/maxabs":"itermaxabs","@stdlib/stats/iter/mean":"itermean","@stdlib/stats/iter/meanabs":"itermeanabs","@stdlib/stats/iter/meanabs2":"itermeanabs2","@stdlib/stats/iter/midrange":"itermidrange","@stdlib/stats/iter/min":"itermin","@stdlib/stats/iter/minabs":"iterminabs","@stdlib/stats/iter/mmax":"itermmax","@stdlib/stats/iter/mmaxabs":"itermmaxabs","@stdlib/stats/iter/mmean":"itermmean","@stdlib/stats/iter/mmeanabs":"itermmeanabs","@stdlib/stats/iter/mmeanabs2":"itermmeanabs2","@stdlib/stats/iter/mmidrange":"itermmidrange","@stdlib/stats/iter/mmin":"itermmin","@stdlib/stats/iter/mminabs":"itermminabs","@stdlib/math/iter/ops/mod":"iterMod","@stdlib/stats/iter/mprod":"itermprod","@stdlib/stats/iter/mrange":"itermrange","@stdlib/stats/iter/msum":"itermsum","@stdlib/stats/iter/msumabs":"itermsumabs","@stdlib/stats/iter/msumabs2":"itermsumabs2","@stdlib/math/iter/ops/multiply":"iterMultiply","@stdlib/math/iter/sequences/negafibonacci":"iterNegaFibonacciSeq","@stdlib/math/iter/sequences/negalucas":"iterNegaLucasSeq","@stdlib/math/iter/sequences/negative-even-integers":"iterNegativeEvenIntegersSeq","@stdlib/math/iter/sequences/negative-integers":"iterNegativeIntegersSeq","@stdlib/math/iter/sequences/negative-odd-integers":"iterNegativeOddIntegersSeq","@stdlib/iter/none":"iterNone","@stdlib/iter/none-by":"iterNoneBy","@stdlib/math/iter/sequences/nonfibonacci":"iterNonFibonacciSeq","@stdlib/math/iter/sequences/nonnegative-even-integers":"iterNonNegativeEvenIntegersSeq","@stdlib/math/iter/sequences/nonnegative-integers":"iterNonNegativeIntegersSeq","@stdlib/math/iter/sequences/nonpositive-even-integers":"iterNonPositiveEvenIntegersSeq","@stdlib/math/iter/sequences/nonpositive-integers":"iterNonPositiveIntegersSeq","@stdlib/math/iter/sequences/nonsquares":"iterNonSquaresSeq","@stdlib/iter/nth":"iterNth","@stdlib/math/iter/sequences/odd-integers":"iterOddIntegersSeq","@stdlib/simulate/iter/periodic-sinc":"iterPeriodicSinc","@stdlib/iter/pipeline":"iterPipeline","@stdlib/iter/pop":"iterPop","@stdlib/math/iter/sequences/positive-even-integers":"iterPositiveEvenIntegersSeq","@stdlib/math/iter/sequences/positive-integers":"iterPositiveIntegersSeq","@stdlib/math/iter/sequences/positive-odd-integers":"iterPositiveOddIntegersSeq","@stdlib/math/iter/special/pow":"iterPow","@stdlib/math/iter/sequences/primes":"iterPrimesSeq","@stdlib/stats/iter/prod":"iterprod","@stdlib/simulate/iter/pulse":"iterPulse","@stdlib/iter/push":"iterPush","@stdlib/math/iter/special/rad2deg":"iterRad2deg","@stdlib/math/iter/special/ramp":"iterRamp","@stdlib/stats/iter/range":"iterrange","@stdlib/iter/reject":"iterReject","@stdlib/iter/replicate":"iterReplicate","@stdlib/iter/replicate-by":"iterReplicateBy","@stdlib/math/iter/special/round":"iterRound","@stdlib/math/iter/special/round2":"iterRound2","@stdlib/math/iter/special/round10":"iterRound10","@stdlib/math/iter/special/rsqrt":"iterRsqrt","@stdlib/simulate/iter/sawtooth-wave":"iterSawtoothWave","@stdlib/iter/shift":"iterShift","@stdlib/math/iter/special/signum":"iterSignum","@stdlib/math/iter/special/sin":"iterSin","@stdlib/math/iter/special/sinc":"iterSinc","@stdlib/simulate/iter/sine-wave":"iterSineWave","@stdlib/math/iter/special/sinh":"iterSinh","@stdlib/math/iter/special/sinpi":"iterSinpi","@stdlib/iter/slice":"iterSlice","@stdlib/iter/some":"iterSome","@stdlib/iter/some-by":"iterSomeBy","@stdlib/math/iter/special/spence":"iterSpence","@stdlib/math/iter/special/sqrt":"iterSqrt","@stdlib/math/iter/special/sqrt1pm1":"iterSqrt1pm1","@stdlib/math/iter/sequences/squared-triangular":"iterSquaredTriangularSeq","@stdlib/math/iter/sequences/squares":"iterSquaresSeq","@stdlib/simulate/iter/square-wave":"iterSquareWave","@stdlib/stats/iter/stdev":"iterstdev","@stdlib/iter/step":"iterStep","@stdlib/iter/strided":"iterStrided","@stdlib/iter/strided-by":"iterStridedBy","@stdlib/math/iter/ops/subtract":"iterSubtract","@stdlib/stats/iter/sum":"itersum","@stdlib/stats/iter/sumabs":"itersumabs","@stdlib/stats/iter/sumabs2":"itersumabs2","@stdlib/math/iter/special/tan":"iterTan","@stdlib/math/iter/special/tanh":"iterTanh","@stdlib/iter/pipeline-thunk":"iterThunk","@stdlib/simulate/iter/triangle-wave":"iterTriangleWave","@stdlib/math/iter/sequences/triangular":"iterTriangularSeq","@stdlib/math/iter/sequences/tribonacci":"iterTribonnaciSeq","@stdlib/math/iter/special/trigamma":"iterTrigamma","@stdlib/math/iter/special/trunc":"iterTrunc","@stdlib/math/iter/special/trunc2":"iterTrunc2","@stdlib/math/iter/special/trunc10":"iterTrunc10","@stdlib/iter/union":"iterUnion","@stdlib/iter/unique":"iterUnique","@stdlib/iter/unique-by":"iterUniqueBy","@stdlib/iter/unique-by-hash":"iterUniqueByHash","@stdlib/iter/unitspace":"iterUnitspace","@stdlib/iter/unshift":"iterUnshift","@stdlib/iter/until-each":"iterUntilEach","@stdlib/stats/iter/variance":"itervariance","@stdlib/math/iter/special/vercos":"iterVercos","@stdlib/math/iter/special/versin":"iterVersin","@stdlib/iter/while-each":"iterWhileEach","@stdlib/math/iter/special/riemann-zeta":"iterZeta","@stdlib/streams/node/join":"joinStream","@stdlib/stats/kde2d":"kde2d","@stdlib/string/kebabcase":"kebabcase","@stdlib/utils/key-by":"keyBy","@stdlib/utils/key-by-right":"keyByRight","@stdlib/utils/keys-in":"keysIn","@stdlib/stats/kruskal-test":"kruskalTest","@stdlib/stats/kstest":"kstest","@stdlib/string/last":"last","@stdlib/nlp/lda":"lda","@stdlib/stats/levene-test":"leveneTest","@stdlib/dstructs/linked-list":"LinkedList","@stdlib/array/linspace":"linspace","@stdlib/datasets/liu-negative-opinion-words-en":"LIU_NEGATIVE_OPINION_WORDS_EN","@stdlib/datasets/liu-positive-opinion-words-en":"LIU_POSITIVE_OPINION_WORDS_EN","@stdlib/constants/float64/ln-half":"LN_HALF","@stdlib/constants/float64/ln-pi":"LN_PI","@stdlib/constants/float64/ln-sqrt-two-pi":"LN_SQRT_TWO_PI","@stdlib/constants/float64/ln-two-pi":"LN_TWO_PI","@stdlib/constants/float64/ln-two":"LN2","@stdlib/constants/float64/ln-ten":"LN10","@stdlib/constants/float64/log2-e":"LOG2E","@stdlib/constants/float64/log10-e":"LOG10E","@stdlib/array/logspace":"logspace","@stdlib/string/lowercase":"lowercase","@stdlib/utils/lowercase-keys":"lowercaseKeys","@stdlib/stats/lowess":"lowess","@stdlib/string/left-pad":"lpad","@stdlib/string/left-trim":"ltrim","@stdlib/string/left-trim-n":"ltrimN","@stdlib/datasets/male-first-names-en":"MALE_FIRST_NAMES_EN","@stdlib/utils/map":"map","@stdlib/utils/map2":"map2","@stdlib/utils/map2d":"map2d","@stdlib/utils/map2-right":"map2Right","@stdlib/utils/map3d":"map3d","@stdlib/utils/map4d":"map4d","@stdlib/utils/map5d":"map5d","@stdlib/utils/map-arguments":"mapArguments","@stdlib/utils/map-function":"mapFun","@stdlib/utils/async/map-function":"mapFunAsync","@stdlib/utils/map-keys":"mapKeys","@stdlib/utils/async/map-keys":"mapKeysAsync","@stdlib/utils/map-reduce":"mapReduce","@stdlib/utils/map-reduce-right":"mapReduceRight","@stdlib/utils/map-right":"mapRight","@stdlib/utils/map-values":"mapValues","@stdlib/utils/async/map-values":"mapValuesAsync","@stdlib/utils/mask-arguments":"maskArguments","@stdlib/constants/array/max-array-length":"MAX_ARRAY_LENGTH","@stdlib/constants/array/max-typed-array-length":"MAX_TYPED_ARRAY_LENGTH","@stdlib/ndarray/maybe-broadcast-array":"maybeBroadcastArray","@stdlib/ndarray/maybe-broadcast-arrays":"maybeBroadcastArrays","@stdlib/utils/memoize":"memoize","@stdlib/utils/merge":"merge","@stdlib/constants/time/milliseconds-in-day":"MILLISECONDS_IN_DAY","@stdlib/constants/time/milliseconds-in-hour":"MILLISECONDS_IN_HOUR","@stdlib/constants/time/milliseconds-in-minute":"MILLISECONDS_IN_MINUTE","@stdlib/constants/time/milliseconds-in-second":"MILLISECONDS_IN_SECOND","@stdlib/constants/time/milliseconds-in-week":"MILLISECONDS_IN_WEEK","@stdlib/datasets/minard-napoleons-march":"MINARD_NAPOLEONS_MARCH","@stdlib/constants/time/minutes-in-day":"MINUTES_IN_DAY","@stdlib/constants/time/minutes-in-hour":"MINUTES_IN_HOUR","@stdlib/constants/time/minutes-in-week":"MINUTES_IN_WEEK","@stdlib/time/minutes-in-month":"minutesInMonth","@stdlib/time/minutes-in-year":"minutesInYear","@stdlib/datasets/moby-dick":"MOBY_DICK","@stdlib/datasets/month-names-en":"MONTH_NAMES_EN","@stdlib/constants/time/months-in-year":"MONTHS_IN_YEAR","@stdlib/utils/move-property":"moveProperty","@stdlib/slice/multi":"MultiSlice","@stdlib/dstructs/named-typed-tuple":"namedtypedtuple","@stdlib/constants/float64/nan":"NAN","@stdlib/utils/nary-function":"naryFunction","@stdlib/utils/native-class":"nativeClass","@stdlib/ndarray/ctor":"ndarray","@stdlib/ndarray/to-array":"ndarray2array","@stdlib/ndarray/to-fancy":"ndarray2fancy","@stdlib/ndarray/to-json":"ndarray2json","@stdlib/ndarray/casting-modes":"ndarrayCastingModes","@stdlib/ndarray/data-buffer":"ndarrayDataBuffer","@stdlib/ndarray/dtype":"ndarrayDataType","@stdlib/ndarray/dtypes":"ndarrayDataTypes","@stdlib/ndarray/dispatch":"ndarrayDispatch","@stdlib/ndarray/flag":"ndarrayFlag","@stdlib/ndarray/flags":"ndarrayFlags","@stdlib/ndarray/index-modes":"ndarrayIndexModes","@stdlib/ndarray/ndarraylike2ndarray":"ndarraylike2ndarray","@stdlib/ndarray/min-dtype":"ndarrayMinDataType","@stdlib/ndarray/mostly-safe-casts":"ndarrayMostlySafeCasts","@stdlib/ndarray/next-dtype":"ndarrayNextDataType","@stdlib/ndarray/offset":"ndarrayOffset","@stdlib/ndarray/order":"ndarrayOrder","@stdlib/ndarray/orders":"ndarrayOrders","@stdlib/ndarray/promotion-rules":"ndarrayPromotionRules","@stdlib/ndarray/safe-casts":"ndarraySafeCasts","@stdlib/ndarray/same-kind-casts":"ndarraySameKindCasts","@stdlib/ndarray/shape":"ndarrayShape","@stdlib/ndarray/stride":"ndarrayStride","@stdlib/ndarray/strides":"ndarrayStrides","@stdlib/ndarray/at":"ndat","@stdlib/ndarray/empty":"ndempty","@stdlib/ndarray/empty-like":"ndemptyLike","@stdlib/ndarray/filter":"ndfilter","@stdlib/ndarray/filter-map":"ndfilterMap","@stdlib/ndarray/for-each":"ndforEach","@stdlib/ndarray/ndims":"ndims","@stdlib/ndarray/index":"ndindex","@stdlib/ndarray/iter/to-array-each":"nditer2arrayEach","@stdlib/ndarray/iter/column-entries":"nditerColumnEntries","@stdlib/ndarray/iter/columns":"nditerColumns","@stdlib/ndarray/iter/entries":"nditerEntries","@stdlib/ndarray/iter/indices":"nditerIndices","@stdlib/ndarray/iter/interleave-subarrays":"nditerInterleaveSubarrays","@stdlib/ndarray/iter/matrices":"nditerMatrices","@stdlib/ndarray/iter/matrix-entries":"nditerMatrixEntries","@stdlib/ndarray/iter/row-entries":"nditerRowEntries","@stdlib/ndarray/iter/rows":"nditerRows","@stdlib/ndarray/iter/select-dimension":"nditerSelectDimension","@stdlib/ndarray/iter/stacks":"nditerStacks","@stdlib/ndarray/iter/subarrays":"nditerSubarrays","@stdlib/ndarray/iter/values":"nditerValues","@stdlib/ndarray/map":"ndmap","@stdlib/ndarray/reject":"ndreject","@stdlib/ndarray/slice":"ndslice","@stdlib/ndarray/slice-assign":"ndsliceAssign","@stdlib/ndarray/slice-dimension":"ndsliceDimension","@stdlib/ndarray/slice-dimension-from":"ndsliceDimensionFrom","@stdlib/ndarray/slice-dimension-to":"ndsliceDimensionTo","@stdlib/ndarray/slice-from":"ndsliceFrom","@stdlib/ndarray/slice-to":"ndsliceTo","@stdlib/ndarray/zeros":"ndzeros","@stdlib/ndarray/zeros-like":"ndzerosLike","@stdlib/string/next-grapheme-cluster-break":"nextGraphemeClusterBreak","@stdlib/utils/next-tick":"nextTick","@stdlib/datasets/nightingales-rose":"NIGHTINGALES_ROSE","@stdlib/constants/float64/ninf":"NINF","@stdlib/process/node-version":"NODE_VERSION","@stdlib/utils/none":"none","@stdlib/utils/none-by":"noneBy","@stdlib/utils/async/none-by":"noneByAsync","@stdlib/utils/none-by-right":"noneByRight","@stdlib/utils/async/none-by-right":"noneByRightAsync","@stdlib/utils/none-in-by":"noneInBy","@stdlib/utils/nonenumerable-properties":"nonEnumerableProperties","@stdlib/utils/nonenumerable-properties-in":"nonEnumerablePropertiesIn","@stdlib/utils/nonenumerable-property-names":"nonEnumerablePropertyNames","@stdlib/utils/nonenumerable-property-names-in":"nonEnumerablePropertyNamesIn","@stdlib/utils/nonenumerable-property-symbols":"nonEnumerablePropertySymbols","@stdlib/utils/nonenumerable-property-symbols-in":"nonEnumerablePropertySymbolsIn","@stdlib/utils/none-own-by":"noneOwnBy","@stdlib/utils/nonindex-keys":"nonIndexKeys","@stdlib/utils/noop":"noop","@stdlib/time/now":"now","@stdlib/os/num-cpus":"NUM_CPUS","@stdlib/string/num2words":"num2words","@stdlib/number/ctor":"Number","@stdlib/ndarray/numel":"numel","@stdlib/ndarray/numel-dimension":"numelDimension","@stdlib/string/num-grapheme-clusters":"numGraphemeClusters","@stdlib/object/ctor":"Object","@stdlib/utils/entries":"objectEntries","@stdlib/utils/entries-in":"objectEntriesIn","@stdlib/utils/from-entries":"objectFromEntries","@stdlib/utils/object-inverse":"objectInverse","@stdlib/utils/object-inverse-by":"objectInverseBy","@stdlib/utils/keys":"objectKeys","@stdlib/utils/values":"objectValues","@stdlib/utils/values-in":"objectValuesIn","@stdlib/utils/omit":"omit","@stdlib/utils/omit-by":"omitBy","@stdlib/fs/open":"open","@stdlib/utils/open-url":"openURL","@stdlib/nlp/ordinalize":"ordinalize","@stdlib/datasets/pace-boston-house-prices":"PACE_BOSTON_HOUSE_PRICES","@stdlib/string/pad":"pad","@stdlib/stats/padjust":"padjust","@stdlib/utils/papply":"papply","@stdlib/utils/papply-right":"papplyRight","@stdlib/utils/parallel":"parallel","@stdlib/utils/parse-json":"parseJSON","@stdlib/string/pascalcase":"pascalcase","@stdlib/constants/path/delimiter":"PATH_DELIMITER","@stdlib/constants/path/delimiter-posix":"PATH_DELIMITER_POSIX","@stdlib/constants/path/delimiter-win32":"PATH_DELIMITER_WIN32","@stdlib/constants/path/sep":"PATH_SEP","@stdlib/constants/path/sep-posix":"PATH_SEP_POSIX","@stdlib/constants/path/sep-win32":"PATH_SEP_WIN32","@stdlib/stats/pcorrtest":"pcorrtest","@stdlib/string/percent-encode":"percentEncode","@stdlib/constants/float64/phi":"PHI","@stdlib/constants/float64/pi":"PI","@stdlib/constants/float64/pi-squared":"PI_SQUARED","@stdlib/utils/pick":"pick","@stdlib/utils/pick-arguments":"pickArguments","@stdlib/utils/pick-by":"pickBy","@stdlib/constants/float64/pinf":"PINF","@stdlib/namespace/pkg2alias":"pkg2alias","@stdlib/namespace/pkg2related":"pkg2related","@stdlib/namespace/pkg2standalone":"pkg2standalone","@stdlib/os/platform":"PLATFORM","@stdlib/plot":"plot","@stdlib/plot/ctor":"Plot","@stdlib/utils/pluck":"pluck","@stdlib/utils/pop":"pop","@stdlib/nlp/porter-stemmer":"porterStemmer","@stdlib/utils/prepend":"prepend","@stdlib/string/prev-grapheme-cluster-break":"prevGraphemeClusterBreak","@stdlib/datasets/primes-100k":"PRIMES_100K","@stdlib/utils/properties":"properties","@stdlib/utils/properties-in":"propertiesIn","@stdlib/utils/property-descriptor":"propertyDescriptor","@stdlib/utils/property-descriptor-in":"propertyDescriptorIn","@stdlib/utils/property-descriptors":"propertyDescriptors","@stdlib/utils/property-descriptors-in":"propertyDescriptorsIn","@stdlib/utils/property-names":"propertyNames","@stdlib/utils/property-names-in":"propertyNamesIn","@stdlib/utils/property-symbols":"propertySymbols","@stdlib/utils/property-symbols-in":"propertySymbolsIn","@stdlib/proxy/ctor":"Proxy","@stdlib/utils/push":"push","@stdlib/time/quarter-of-year":"quarterOfYear","@stdlib/random/array/arcsine":"random.array.arcsine","@stdlib/random/array/bernoulli":"random.array.bernoulli","@stdlib/random/array/beta":"random.array.beta","@stdlib/random/array/betaprime":"random.array.betaprime","@stdlib/random/array/binomial":"random.array.binomial","@stdlib/random/array/cauchy":"random.array.cauchy","@stdlib/random/array/chi":"random.array.chi","@stdlib/random/array/chisquare":"random.array.chisquare","@stdlib/random/array/cosine":"random.array.cosine","@stdlib/random/array/discrete-uniform":"random.array.discreteUniform","@stdlib/random/array/erlang":"random.array.erlang","@stdlib/random/array/exponential":"random.array.exponential","@stdlib/random/array/f":"random.array.f","@stdlib/random/array/frechet":"random.array.frechet","@stdlib/random/array/gamma":"random.array.gamma","@stdlib/random/array/geometric":"random.array.geometric","@stdlib/random/array/gumbel":"random.array.gumbel","@stdlib/random/array/hypergeometric":"random.array.hypergeometric","@stdlib/random/array/invgamma":"random.array.invgamma","@stdlib/random/array/kumaraswamy":"random.array.kumaraswamy","@stdlib/random/array/laplace":"random.array.laplace","@stdlib/random/array/levy":"random.array.levy","@stdlib/random/array/logistic":"random.array.logistic","@stdlib/random/array/lognormal":"random.array.lognormal","@stdlib/random/array/minstd":"random.array.minstd","@stdlib/random/array/minstd-shuffle":"random.array.minstdShuffle","@stdlib/random/array/mt19937":"random.array.mt19937","@stdlib/random/array/negative-binomial":"random.array.negativeBinomial","@stdlib/random/array/normal":"random.array.normal","@stdlib/random/array/pareto-type1":"random.array.pareto1","@stdlib/random/array/poisson":"random.array.poisson","@stdlib/random/array/randu":"random.array.randu","@stdlib/random/array/rayleigh":"random.array.rayleigh","@stdlib/random/array/t":"random.array.t","@stdlib/random/array/triangular":"random.array.triangular","@stdlib/random/array/uniform":"random.array.uniform","@stdlib/random/array/weibull":"random.array.weibull","@stdlib/random/iter/arcsine":"random.iterators.arcsine","@stdlib/random/iter/bernoulli":"random.iterators.bernoulli","@stdlib/random/iter/beta":"random.iterators.beta","@stdlib/random/iter/betaprime":"random.iterators.betaprime","@stdlib/random/iter/binomial":"random.iterators.binomial","@stdlib/random/iter/box-muller":"random.iterators.boxMuller","@stdlib/random/iter/cauchy":"random.iterators.cauchy","@stdlib/random/iter/chi":"random.iterators.chi","@stdlib/random/iter/chisquare":"random.iterators.chisquare","@stdlib/random/iter/cosine":"random.iterators.cosine","@stdlib/random/iter/discrete-uniform":"random.iterators.discreteUniform","@stdlib/random/iter/erlang":"random.iterators.erlang","@stdlib/random/iter/exponential":"random.iterators.exponential","@stdlib/random/iter/f":"random.iterators.f","@stdlib/random/iter/frechet":"random.iterators.frechet","@stdlib/random/iter/gamma":"random.iterators.gamma","@stdlib/random/iter/geometric":"random.iterators.geometric","@stdlib/random/iter/gumbel":"random.iterators.gumbel","@stdlib/random/iter/hypergeometric":"random.iterators.hypergeometric","@stdlib/random/iter/improved-ziggurat":"random.iterators.improvedZiggurat","@stdlib/random/iter/invgamma":"random.iterators.invgamma","@stdlib/random/iter/kumaraswamy":"random.iterators.kumaraswamy","@stdlib/random/iter/laplace":"random.iterators.laplace","@stdlib/random/iter/levy":"random.iterators.levy","@stdlib/random/iter/logistic":"random.iterators.logistic","@stdlib/random/iter/lognormal":"random.iterators.lognormal","@stdlib/random/iter/minstd":"random.iterators.minstd","@stdlib/random/iter/minstd-shuffle":"random.iterators.minstdShuffle","@stdlib/random/iter/mt19937":"random.iterators.mt19937","@stdlib/random/iter/negative-binomial":"random.iterators.negativeBinomial","@stdlib/random/iter/normal":"random.iterators.normal","@stdlib/random/iter/pareto-type1":"random.iterators.pareto1","@stdlib/random/iter/poisson":"random.iterators.poisson","@stdlib/random/iter/randi":"random.iterators.randi","@stdlib/random/iter/randn":"random.iterators.randn","@stdlib/random/iter/randu":"random.iterators.randu","@stdlib/random/iter/rayleigh":"random.iterators.rayleigh","@stdlib/random/iter/t":"random.iterators.t","@stdlib/random/iter/triangular":"random.iterators.triangular","@stdlib/random/iter/uniform":"random.iterators.uniform","@stdlib/random/iter/weibull":"random.iterators.weibull","@stdlib/random/streams/arcsine":"random.streams.arcsine","@stdlib/random/streams/bernoulli":"random.streams.bernoulli","@stdlib/random/streams/beta":"random.streams.beta","@stdlib/random/streams/betaprime":"random.streams.betaprime","@stdlib/random/streams/binomial":"random.streams.binomial","@stdlib/random/streams/box-muller":"random.streams.boxMuller","@stdlib/random/streams/cauchy":"random.streams.cauchy","@stdlib/random/streams/chi":"random.streams.chi","@stdlib/random/streams/chisquare":"random.streams.chisquare","@stdlib/random/streams/cosine":"random.streams.cosine","@stdlib/random/streams/discrete-uniform":"random.streams.discreteUniform","@stdlib/random/streams/erlang":"random.streams.erlang","@stdlib/random/streams/exponential":"random.streams.exponential","@stdlib/random/streams/f":"random.streams.f","@stdlib/random/streams/frechet":"random.streams.frechet","@stdlib/random/streams/gamma":"random.streams.gamma","@stdlib/random/streams/geometric":"random.streams.geometric","@stdlib/random/streams/gumbel":"random.streams.gumbel","@stdlib/random/streams/hypergeometric":"random.streams.hypergeometric","@stdlib/random/streams/improved-ziggurat":"random.streams.improvedZiggurat","@stdlib/random/streams/invgamma":"random.streams.invgamma","@stdlib/random/streams/kumaraswamy":"random.streams.kumaraswamy","@stdlib/random/streams/laplace":"random.streams.laplace","@stdlib/random/streams/levy":"random.streams.levy","@stdlib/random/streams/logistic":"random.streams.logistic","@stdlib/random/streams/lognormal":"random.streams.lognormal","@stdlib/random/streams/minstd":"random.streams.minstd","@stdlib/random/streams/minstd-shuffle":"random.streams.minstdShuffle","@stdlib/random/streams/mt19937":"random.streams.mt19937","@stdlib/random/streams/negative-binomial":"random.streams.negativeBinomial","@stdlib/random/streams/normal":"random.streams.normal","@stdlib/random/streams/pareto-type1":"random.streams.pareto1","@stdlib/random/streams/poisson":"random.streams.poisson","@stdlib/random/streams/randi":"random.streams.randi","@stdlib/random/streams/randn":"random.streams.randn","@stdlib/random/streams/randu":"random.streams.randu","@stdlib/random/streams/rayleigh":"random.streams.rayleigh","@stdlib/random/streams/t":"random.streams.t","@stdlib/random/streams/triangular":"random.streams.triangular","@stdlib/random/streams/uniform":"random.streams.uniform","@stdlib/random/streams/weibull":"random.streams.weibull","@stdlib/random/strided/arcsine":"random.strided.arcsine","@stdlib/random/strided/bernoulli":"random.strided.bernoulli","@stdlib/random/strided/beta":"random.strided.beta","@stdlib/random/strided/betaprime":"random.strided.betaprime","@stdlib/random/strided/chi":"random.strided.chi","@stdlib/random/strided/chisquare":"random.strided.chisquare","@stdlib/random/strided/cosine":"random.strided.cosine","@stdlib/random/strided/discrete-uniform":"random.strided.discreteUniform","@stdlib/random/strided/exponential":"random.strided.exponential","@stdlib/random/strided/gamma":"random.strided.gamma","@stdlib/random/strided/geometric":"random.strided.geometric","@stdlib/random/strided/invgamma":"random.strided.invgamma","@stdlib/random/strided/lognormal":"random.strided.lognormal","@stdlib/random/strided/minstd":"random.strided.minstd","@stdlib/random/strided/minstd-shuffle":"random.strided.minstdShuffle","@stdlib/random/strided/mt19937":"random.strided.mt19937","@stdlib/random/strided/normal":"random.strided.normal","@stdlib/random/strided/poisson":"random.strided.poisson","@stdlib/random/strided/randu":"random.strided.randu","@stdlib/random/strided/rayleigh":"random.strided.rayleigh","@stdlib/random/strided/t":"random.strided.t","@stdlib/random/strided/uniform":"random.strided.uniform","@stdlib/random/strided/weibull":"random.strided.weibull","@stdlib/stats/ranks":"ranks","@stdlib/fs/read-dir":"readDir","@stdlib/fs/read-file":"readFile","@stdlib/fs/read-file-list":"readFileList","@stdlib/fs/read-json":"readJSON","@stdlib/fs/read-wasm":"readWASM","@stdlib/complex/float64/real":"real","@stdlib/array/typed-real":"realarray","@stdlib/array/typed-real-ctors":"realarrayCtors","@stdlib/array/typed-real-dtypes":"realarrayDataTypes","@stdlib/complex/float32/real":"realf","@stdlib/utils/real-max":"realmax","@stdlib/utils/real-min":"realmin","@stdlib/regexp/basename":"reBasename","@stdlib/regexp/basename-posix":"reBasenamePosix","@stdlib/regexp/basename-windows":"reBasenameWindows","@stdlib/regexp/color-hexadecimal":"reColorHexadecimal","@stdlib/regexp/decimal-number":"reDecimalNumber","@stdlib/regexp/dirname":"reDirname","@stdlib/regexp/dirname-posix":"reDirnamePosix","@stdlib/regexp/dirname-windows":"reDirnameWindows","@stdlib/utils/reduce":"reduce","@stdlib/utils/reduce2d":"reduce2d","@stdlib/utils/async/reduce":"reduceAsync","@stdlib/utils/reduce-right":"reduceRight","@stdlib/utils/async/reduce-right":"reduceRightAsync","@stdlib/regexp/duration-string":"reDurationString","@stdlib/regexp/eol":"reEOL","@stdlib/regexp/extended-length-path":"reExtendedLengthPath","@stdlib/regexp/extname":"reExtname","@stdlib/regexp/extname-posix":"reExtnamePosix","@stdlib/regexp/extname-windows":"reExtnameWindows","@stdlib/regexp/filename":"reFilename","@stdlib/regexp/filename-posix":"reFilenamePosix","@stdlib/regexp/filename-windows":"reFilenameWindows","@stdlib/utils/regexp-from-string":"reFromString","@stdlib/regexp/function-name":"reFunctionName","@stdlib/regexp/to-json":"regexp2json","@stdlib/complex/float64/reim":"reim","@stdlib/complex/float32/reim":"reimf","@stdlib/utils/reject-arguments":"rejectArguments","@stdlib/string/remove-first":"removeFirst","@stdlib/string/remove-last":"removeLast","@stdlib/string/remove-punctuation":"removePunctuation","@stdlib/string/remove-utf8-bom":"removeUTF8BOM","@stdlib/string/remove-words":"removeWords","@stdlib/fs/rename":"rename","@stdlib/regexp/native-function":"reNativeFunction","@stdlib/utils/reorder-arguments":"reorderArguments","@stdlib/string/repeat":"repeat","@stdlib/string/replace":"replace","@stdlib/string/replace-before":"replaceBefore","@stdlib/regexp/regexp":"reRegExp","@stdlib/utils/escape-regexp-string":"rescape","@stdlib/regexp/semver":"reSemVer","@stdlib/fs/resolve-parent-path":"resolveParentPath","@stdlib/fs/resolve-parent-path-by":"resolveParentPathBy","@stdlib/regexp/unc-path":"reUncPath","@stdlib/regexp/utf16-surrogate-pair":"reUtf16SurrogatePair","@stdlib/regexp/utf16-unpaired-surrogate":"reUtf16UnpairedSurrogate","@stdlib/utils/reverse-arguments":"reverseArguments","@stdlib/string/reverse":"reverseString","@stdlib/random/base/reviver":"reviveBasePRNG","@stdlib/buffer/reviver":"reviveBuffer","@stdlib/complex/reviver":"reviveComplex","@stdlib/complex/float32/reviver":"reviveComplex64","@stdlib/complex/float64/reviver":"reviveComplex128","@stdlib/error/reviver":"reviveError","@stdlib/regexp/reviver":"reviveRegExp","@stdlib/array/reviver":"reviveTypedArray","@stdlib/regexp/whitespace":"reWhitespace","@stdlib/string/right-pad":"rpad","@stdlib/string/right-trim":"rtrim","@stdlib/string/right-trim-n":"rtrimN","@stdlib/utils/safe-int-max":"safeintmax","@stdlib/utils/safe-int-min":"safeintmin","@stdlib/random/sample":"sample","@stdlib/datasets/savoy-stopwords-fin":"SAVOY_STOPWORDS_FIN","@stdlib/datasets/savoy-stopwords-fr":"SAVOY_STOPWORDS_FR","@stdlib/datasets/savoy-stopwords-ger":"SAVOY_STOPWORDS_GER","@stdlib/datasets/savoy-stopwords-it":"SAVOY_STOPWORDS_IT","@stdlib/datasets/savoy-stopwords-por":"SAVOY_STOPWORDS_POR","@stdlib/datasets/savoy-stopwords-sp":"SAVOY_STOPWORDS_SP","@stdlib/datasets/savoy-stopwords-swe":"SAVOY_STOPWORDS_SWE","@stdlib/array/from-scalar":"scalar2array","@stdlib/ndarray/from-scalar":"scalar2ndarray","@stdlib/blas/sdot":"sdot","@stdlib/constants/time/seconds-in-day":"SECONDS_IN_DAY","@stdlib/constants/time/seconds-in-hour":"SECONDS_IN_HOUR","@stdlib/constants/time/seconds-in-minute":"SECONDS_IN_MINUTE","@stdlib/constants/time/seconds-in-week":"SECONDS_IN_WEEK","@stdlib/time/seconds-in-month":"secondsInMonth","@stdlib/time/seconds-in-year":"secondsInYear","@stdlib/nlp/sentencize":"sentencize","@stdlib/slice/seq2slice":"seq2slice","@stdlib/utils/define-configurable-read-only-property":"setConfigurableReadOnly","@stdlib/utils/define-configurable-read-only-accessor":"setConfigurableReadOnlyAccessor","@stdlib/utils/define-configurable-read-write-accessor":"setConfigurableReadWriteAccessor","@stdlib/utils/define-configurable-write-only-accessor":"setConfigurableWriteOnlyAccessor","@stdlib/utils/define-memoized-configurable-read-only-property":"setMemoizedConfigurableReadOnly","@stdlib/utils/define-memoized-read-only-property":"setMemoizedReadOnly","@stdlib/utils/define-nonenumerable-property":"setNonEnumerableProperty","@stdlib/utils/define-nonenumerable-read-only-property":"setNonEnumerableReadOnly","@stdlib/utils/define-nonenumerable-read-only-accessor":"setNonEnumerableReadOnlyAccessor","@stdlib/utils/define-nonenumerable-read-write-accessor":"setNonEnumerableReadWriteAccessor","@stdlib/utils/define-nonenumerable-write-only-accessor":"setNonEnumerableWriteOnlyAccessor","@stdlib/utils/define-read-only-property":"setReadOnly","@stdlib/utils/define-read-only-accessor":"setReadOnlyAccessor","@stdlib/utils/define-read-write-accessor":"setReadWriteAccessor","@stdlib/utils/define-write-only-accessor":"setWriteOnlyAccessor","@stdlib/array/shared-buffer":"SharedArrayBuffer","@stdlib/utils/shift":"shift","@stdlib/random/shuffle":"shuffle","@stdlib/utils/size-of":"sizeOf","@stdlib/slice/ctor":"Slice","@stdlib/string/snakecase":"snakecase","@stdlib/utils/some":"some","@stdlib/utils/some-by":"someBy","@stdlib/utils/async/some-by":"someByAsync","@stdlib/utils/some-by-right":"someByRight","@stdlib/utils/async/some-by-right":"someByRightAsync","@stdlib/utils/some-in-by":"someInBy","@stdlib/utils/some-own-by":"someOwnBy","@stdlib/datasets/sotu":"SOTU","@stdlib/datasets/spache-revised":"SPACHE_REVISED","@stdlib/datasets/spam-assassin":"SPAM_ASSASSIN","@stdlib/plot/sparklines/base/ctor":"SparklineBase","@stdlib/array/to-sparse-iterator":"sparsearray2iterator","@stdlib/array/to-sparse-iterator-right":"sparsearray2iteratorRight","@stdlib/streams/node/split":"splitStream","@stdlib/constants/float64/sqrt-eps":"SQRT_EPS","@stdlib/constants/float64/sqrt-half":"SQRT_HALF","@stdlib/constants/float64/sqrt-half-pi":"SQRT_HALF_PI","@stdlib/constants/float64/sqrt-phi":"SQRT_PHI","@stdlib/constants/float64/sqrt-pi":"SQRT_PI","@stdlib/constants/float64/sqrt-three":"SQRT_THREE","@stdlib/constants/float64/sqrt-two":"SQRT_TWO","@stdlib/constants/float64/sqrt-two-pi":"SQRT_TWO_PI","@stdlib/datasets/ssa-us-births-2000-2014":"SSA_US_BIRTHS_2000_2014","@stdlib/blas/sswap":"sswap","@stdlib/dstructs/stack":"Stack","@stdlib/namespace/standalone2pkg":"standalone2pkg","@stdlib/datasets/standard-card-deck":"STANDARD_CARD_DECK","@stdlib/string/startcase":"startcase","@stdlib/string/starts-with":"startsWith","@stdlib/datasets/stopwords-en":"STOPWORDS_EN","@stdlib/math/strided/special/abs":"strided.abs","@stdlib/math/strided/special/abs2":"strided.abs2","@stdlib/math/strided/special/abs2-by":"strided.abs2By","@stdlib/math/strided/special/abs-by":"strided.absBy","@stdlib/math/strided/special/acos-by":"strided.acosBy","@stdlib/math/strided/special/acosh-by":"strided.acoshBy","@stdlib/math/strided/special/acot-by":"strided.acotBy","@stdlib/math/strided/special/acoth-by":"strided.acothBy","@stdlib/math/strided/special/acovercos-by":"strided.acovercosBy","@stdlib/math/strided/special/acoversin-by":"strided.acoversinBy","@stdlib/math/strided/ops/add":"strided.add","@stdlib/math/strided/ops/add-by":"strided.addBy","@stdlib/math/strided/special/ahavercos-by":"strided.ahavercosBy","@stdlib/math/strided/special/ahaversin-by":"strided.ahaversinBy","@stdlib/math/strided/special/asin-by":"strided.asinBy","@stdlib/math/strided/special/asinh-by":"strided.asinhBy","@stdlib/math/strided/special/atan-by":"strided.atanBy","@stdlib/math/strided/special/atanh-by":"strided.atanhBy","@stdlib/math/strided/special/avercos-by":"strided.avercosBy","@stdlib/math/strided/special/aversin-by":"strided.aversinBy","@stdlib/math/strided/special/besselj0-by":"strided.besselj0By","@stdlib/math/strided/special/besselj1-by":"strided.besselj1By","@stdlib/math/strided/special/bessely0-by":"strided.bessely0By","@stdlib/math/strided/special/bessely1-by":"strided.bessely1By","@stdlib/math/strided/special/binet-by":"strided.binetBy","@stdlib/math/strided/special/cbrt":"strided.cbrt","@stdlib/math/strided/special/cbrt-by":"strided.cbrtBy","@stdlib/math/strided/special/ceil":"strided.ceil","@stdlib/math/strided/special/cos-by":"strided.cosBy","@stdlib/math/strided/special/deg2rad":"strided.deg2rad","@stdlib/strided/dtypes":"strided.dataTypes","@stdlib/math/strided/special/dcbrt-by":"strided.dcbrtBy","@stdlib/strided/dispatch":"strided.dispatch","@stdlib/strided/dispatch-by":"strided.dispatchBy","@stdlib/math/strided/special/floor":"strided.floor","@stdlib/math/strided/special/inv":"strided.inv","@stdlib/math/strided/ops/mul":"strided.mul","@stdlib/math/strided/ops/mul-by":"strided.mulBy","@stdlib/math/strided/special/ramp":"strided.ramp","@stdlib/math/strided/special/rsqrt":"strided.rsqrt","@stdlib/math/strided/special/sin-by":"strided.sinBy","@stdlib/math/strided/special/sqrt":"strided.sqrt","@stdlib/math/strided/special/sqrt-by":"strided.sqrtBy","@stdlib/math/strided/ops/sub":"strided.sub","@stdlib/math/strided/ops/sub-by":"strided.subBy","@stdlib/math/strided/special/trunc":"strided.trunc","@stdlib/array/to-strided-iterator":"stridedarray2iterator","@stdlib/streams/node/from-strided-array":"stridedArrayStream","@stdlib/buffer/from-string":"string2buffer","@stdlib/ndarray/sub2ind":"sub2ind","@stdlib/string/substring-after":"substringAfter","@stdlib/string/substring-after-last":"substringAfterLast","@stdlib/string/substring-before":"substringBefore","@stdlib/string/substring-before-last":"substringBeforeLast","@stdlib/datasets/suthaharan-multi-hop-sensor-network":"SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK","@stdlib/datasets/suthaharan-single-hop-sensor-network":"SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK","@stdlib/symbol/ctor":"Symbol","@stdlib/utils/tabulate":"tabulate","@stdlib/utils/tabulate-by":"tabulateBy","@stdlib/utils/async/tabulate-by":"tabulateByAsync","@stdlib/function/thunk":"thunk","@stdlib/time/tic":"tic","@stdlib/utils/timeit":"timeit","@stdlib/os/tmpdir":"tmpdir","@stdlib/time/toc":"toc","@stdlib/nlp/tokenize":"tokenize","@stdlib/streams/node/transform":"transformStream","@stdlib/string/trim":"trim","@stdlib/string/truncate":"truncate","@stdlib/string/truncate-middle":"truncateMiddle","@stdlib/utils/try-catch":"trycatch","@stdlib/utils/async/try-catch":"trycatchAsync","@stdlib/utils/try-function":"tryFunction","@stdlib/utils/try-require":"tryRequire","@stdlib/utils/try-then":"trythen","@stdlib/utils/async/try-then":"trythenAsync","@stdlib/stats/ttest":"ttest","@stdlib/stats/ttest2":"ttest2","@stdlib/constants/float64/two-pi":"TWO_PI","@stdlib/array/typed":"typedarray","@stdlib/array/to-json":"typedarray2json","@stdlib/array/typed-ctors":"typedarrayCtors","@stdlib/array/typed-dtypes":"typedarrayDataTypes","@stdlib/array/pool":"typedarraypool","@stdlib/utils/type-max":"typemax","@stdlib/utils/type-min":"typemin","@stdlib/utils/type-of":"typeOf","@stdlib/constants/uint8/max":"UINT8_MAX","@stdlib/constants/uint8/num-bytes":"UINT8_NUM_BYTES","@stdlib/array/uint8":"Uint8Array","@stdlib/array/uint8c":"Uint8ClampedArray","@stdlib/constants/uint16/max":"UINT16_MAX","@stdlib/constants/uint16/num-bytes":"UINT16_NUM_BYTES","@stdlib/array/uint16":"Uint16Array","@stdlib/constants/uint32/max":"UINT32_MAX","@stdlib/constants/uint32/num-bytes":"UINT32_NUM_BYTES","@stdlib/array/uint32":"Uint32Array","@stdlib/process/umask":"umask","@stdlib/string/uncapitalize":"uncapitalize","@stdlib/utils/uncapitalize-keys":"uncapitalizeKeys","@stdlib/utils/uncurry":"uncurry","@stdlib/utils/uncurry-right":"uncurryRight","@stdlib/constants/unicode/max":"UNICODE_MAX","@stdlib/constants/unicode/max-bmp":"UNICODE_MAX_BMP","@stdlib/plot/sparklines/unicode/column":"UnicodeColumnChartSparkline","@stdlib/plot/sparklines/unicode/line":"UnicodeLineChartSparkline","@stdlib/plot/sparklines/unicode":"UnicodeSparkline","@stdlib/plot/sparklines/unicode/tristate":"UnicodeTristateChartSparkline","@stdlib/plot/sparklines/unicode/up-down":"UnicodeUpDownChartSparkline","@stdlib/plot/sparklines/unicode/win-loss":"UnicodeWinLossChartSparkline","@stdlib/fs/unlink":"unlink","@stdlib/utils/unshift":"unshift","@stdlib/utils/until":"until","@stdlib/utils/async/until":"untilAsync","@stdlib/utils/until-each":"untilEach","@stdlib/utils/until-each-right":"untilEachRight","@stdlib/utils/unzip":"unzip","@stdlib/string/uppercase":"uppercase","@stdlib/utils/uppercase-keys":"uppercaseKeys","@stdlib/datasets/us-states-abbr":"US_STATES_ABBR","@stdlib/datasets/us-states-capitals":"US_STATES_CAPITALS","@stdlib/datasets/us-states-capitals-names":"US_STATES_CAPITALS_NAMES","@stdlib/datasets/us-states-names":"US_STATES_NAMES","@stdlib/datasets/us-states-names-capitals":"US_STATES_NAMES_CAPITALS","@stdlib/string/utf16-to-utf8-array":"utf16ToUTF8Array","@stdlib/stats/vartest":"vartest","@stdlib/utils/async/series-waterfall":"waterfall","@stdlib/wasm/memory":"WebAssemblyMemory","@stdlib/utils/async/while":"whileAsync","@stdlib/utils/while-each":"whileEach","@stdlib/utils/while-each-right":"whileEachRight","@stdlib/utils/while":"whilst","@stdlib/stats/wilcoxon":"wilcoxon","@stdlib/utils/writable-properties":"writableProperties","@stdlib/utils/writable-properties-in":"writablePropertiesIn","@stdlib/utils/writable-property-names":"writablePropertyNames","@stdlib/utils/writable-property-names-in":"writablePropertyNamesIn","@stdlib/utils/writable-property-symbols":"writablePropertySymbols","@stdlib/utils/writable-property-symbols-in":"writablePropertySymbolsIn","@stdlib/fs/write-file":"writeFile","@stdlib/utils/zip":"zip","@stdlib/stats/ztest":"ztest","@stdlib/stats/ztest2":"ztest2"} +{"@stdlib/math/special/abs":"abs","@stdlib/array/cartesian-power":"acartesianPower","@stdlib/array/cartesian-product":"acartesianProduct","@stdlib/array/cartesian-square":"acartesianSquare","@stdlib/string/acronym":"acronym","@stdlib/array/empty":"aempty","@stdlib/array/empty-like":"aemptyLike","@stdlib/datasets/afinn-96":"AFINN_96","@stdlib/datasets/afinn-111":"AFINN_111","@stdlib/array/full":"afull","@stdlib/array/full-like":"afullLike","@stdlib/namespace/alias2pkg":"alias2pkg","@stdlib/namespace/alias2related":"alias2related","@stdlib/namespace/alias2standalone":"alias2standalone","@stdlib/namespace/aliases":"aliases","@stdlib/buffer/alloc-unsafe":"allocUnsafe","@stdlib/array/mskfilter":"amskfilter","@stdlib/array/mskput":"amskput","@stdlib/array/mskreject":"amskreject","@stdlib/array/nans":"anans","@stdlib/array/nans-like":"anansLike","@stdlib/stats/anova1":"anova1","@stdlib/datasets/anscombes-quartet":"ANSCOMBES_QUARTET","@stdlib/utils/any":"any","@stdlib/utils/any-by":"anyBy","@stdlib/utils/async/any-by":"anyByAsync","@stdlib/utils/any-by-right":"anyByRight","@stdlib/utils/async/any-by-right":"anyByRightAsync","@stdlib/utils/any-in-by":"anyInBy","@stdlib/utils/any-own-by":"anyOwnBy","@stdlib/array/ones":"aones","@stdlib/array/ones-like":"aonesLike","@stdlib/array/one-to":"aoneTo","@stdlib/array/one-to-like":"aoneToLike","@stdlib/constants/float64/apery":"APERY","@stdlib/array/place":"aplace","@stdlib/utils/append":"append","@stdlib/array/put":"aput","@stdlib/os/arch":"ARCH","@stdlib/utils/argument-function":"argumentFunction","@stdlib/process/argv":"ARGV","@stdlib/ndarray/array":"array","@stdlib/buffer/from-array":"array2buffer","@stdlib/array/to-fancy":"array2fancy","@stdlib/array/to-iterator":"array2iterator","@stdlib/array/to-iterator-right":"array2iteratorRight","@stdlib/array/buffer":"ArrayBuffer","@stdlib/buffer/from-arraybuffer":"arraybuffer2buffer","@stdlib/array/ctors":"arrayCtors","@stdlib/array/dtype":"arrayDataType","@stdlib/array/dtypes":"arrayDataTypes","@stdlib/array/index":"ArrayIndex","@stdlib/array/min-dtype":"arrayMinDataType","@stdlib/array/mostly-safe-casts":"arrayMostlySafeCasts","@stdlib/array/next-dtype":"arrayNextDataType","@stdlib/array/promotion-rules":"arrayPromotionRules","@stdlib/array/safe-casts":"arraySafeCasts","@stdlib/array/same-kind-casts":"arraySameKindCasts","@stdlib/array/shape":"arrayShape","@stdlib/streams/node/from-array":"arrayStream","@stdlib/array/to-view-iterator":"arrayview2iterator","@stdlib/array/to-view-iterator-right":"arrayview2iteratorRight","@stdlib/array/slice":"aslice","@stdlib/symbol/async-iterator":"AsyncIteratorSymbol","@stdlib/array/take":"atake","@stdlib/array/zeros":"azeros","@stdlib/array/zeros-like":"azerosLike","@stdlib/array/zero-to":"azeroTo","@stdlib/array/zero-to-like":"azeroToLike","@stdlib/stats/bartlett-test":"bartlettTest","@stdlib/math/base/special/abs":"base.abs","@stdlib/math/base/special/abs2":"base.abs2","@stdlib/math/base/special/abs2f":"base.abs2f","@stdlib/math/base/utils/absolute-difference":"base.absdiff","@stdlib/math/base/special/absf":"base.absf","@stdlib/array/base/cartesian-power":"base.acartesianPower","@stdlib/array/base/cartesian-product":"base.acartesianProduct","@stdlib/array/base/cartesian-square":"base.acartesianSquare","@stdlib/math/base/special/acos":"base.acos","@stdlib/math/base/special/acosd":"base.acosd","@stdlib/math/base/special/acosf":"base.acosf","@stdlib/math/base/special/acosh":"base.acosh","@stdlib/math/base/special/acot":"base.acot","@stdlib/math/base/special/acotd":"base.acotd","@stdlib/math/base/special/acotf":"base.acotf","@stdlib/math/base/special/acoth":"base.acoth","@stdlib/math/base/special/acovercos":"base.acovercos","@stdlib/math/base/special/acoversin":"base.acoversin","@stdlib/math/base/special/acsc":"base.acsc","@stdlib/math/base/special/acscd":"base.acscd","@stdlib/math/base/special/acscdf":"base.acscdf","@stdlib/math/base/special/acscf":"base.acscf","@stdlib/math/base/special/acsch":"base.acsch","@stdlib/number/float64/base/add":"base.add","@stdlib/number/float64/base/add3":"base.add3","@stdlib/number/float64/base/add4":"base.add4","@stdlib/number/float64/base/add5":"base.add5","@stdlib/number/float32/base/add":"base.addf","@stdlib/array/base/filled":"base.afilled","@stdlib/array/base/filled2d":"base.afilled2d","@stdlib/array/base/filled2d-by":"base.afilled2dBy","@stdlib/array/base/filled3d":"base.afilled3d","@stdlib/array/base/filled3d-by":"base.afilled3dBy","@stdlib/array/base/filled4d":"base.afilled4d","@stdlib/array/base/filled4d-by":"base.afilled4dBy","@stdlib/array/base/filled5d":"base.afilled5d","@stdlib/array/base/filled5d-by":"base.afilled5dBy","@stdlib/array/base/filled-by":"base.afilledBy","@stdlib/array/base/fillednd":"base.afillednd","@stdlib/array/base/fillednd-by":"base.afilledndBy","@stdlib/array/base/filter":"base.afilter","@stdlib/array/base/first":"base.afirst","@stdlib/array/base/flatten":"base.aflatten","@stdlib/array/base/flatten2d":"base.aflatten2d","@stdlib/array/base/flatten2d-by":"base.aflatten2dBy","@stdlib/array/base/flatten3d":"base.aflatten3d","@stdlib/array/base/flatten3d-by":"base.aflatten3dBy","@stdlib/array/base/flatten4d":"base.aflatten4d","@stdlib/array/base/flatten4d-by":"base.aflatten4dBy","@stdlib/array/base/flatten5d":"base.aflatten5d","@stdlib/array/base/flatten5d-by":"base.aflatten5dBy","@stdlib/array/base/flatten-by":"base.aflattenBy","@stdlib/array/base/fliplr2d":"base.afliplr2d","@stdlib/array/base/fliplr3d":"base.afliplr3d","@stdlib/array/base/fliplr4d":"base.afliplr4d","@stdlib/array/base/fliplr5d":"base.afliplr5d","@stdlib/array/base/flipud2d":"base.aflipud2d","@stdlib/array/base/flipud3d":"base.aflipud3d","@stdlib/array/base/flipud4d":"base.aflipud4d","@stdlib/array/base/flipud5d":"base.aflipud5d","@stdlib/math/base/special/ahavercos":"base.ahavercos","@stdlib/math/base/special/ahaversin":"base.ahaversin","@stdlib/string/base/altcase":"base.altcase","@stdlib/array/base/ones":"base.aones","@stdlib/array/base/ones2d":"base.aones2d","@stdlib/array/base/ones3d":"base.aones3d","@stdlib/array/base/ones4d":"base.aones4d","@stdlib/array/base/ones5d":"base.aones5d","@stdlib/array/base/onesnd":"base.aonesnd","@stdlib/array/base/one-to":"base.aoneTo","@stdlib/slice/base/args2multislice":"base.args2multislice","@stdlib/math/base/special/asec":"base.asec","@stdlib/math/base/special/asecd":"base.asecd","@stdlib/math/base/special/asecdf":"base.asecdf","@stdlib/math/base/special/asecf":"base.asecf","@stdlib/math/base/special/asech":"base.asech","@stdlib/math/base/special/asin":"base.asin","@stdlib/math/base/special/asind":"base.asind","@stdlib/math/base/special/asindf":"base.asindf","@stdlib/math/base/special/asinf":"base.asinf","@stdlib/math/base/special/asinh":"base.asinh","@stdlib/math/base/special/atan":"base.atan","@stdlib/math/base/special/atan2":"base.atan2","@stdlib/math/base/special/atand":"base.atand","@stdlib/math/base/special/atanf":"base.atanf","@stdlib/math/base/special/atanh":"base.atanh","@stdlib/math/base/special/avercos":"base.avercos","@stdlib/math/base/special/aversin":"base.aversin","@stdlib/array/base/zeros":"base.azeros","@stdlib/array/base/zeros2d":"base.azeros2d","@stdlib/array/base/zeros3d":"base.azeros3d","@stdlib/array/base/zeros4d":"base.azeros4d","@stdlib/array/base/zeros5d":"base.azeros5d","@stdlib/array/base/zerosnd":"base.azerosnd","@stdlib/array/base/zero-to":"base.azeroTo","@stdlib/math/base/special/bernoulli":"base.bernoulli","@stdlib/math/base/special/besselj0":"base.besselj0","@stdlib/math/base/special/besselj1":"base.besselj1","@stdlib/math/base/special/bessely0":"base.bessely0","@stdlib/math/base/special/bessely1":"base.bessely1","@stdlib/math/base/special/beta":"base.beta","@stdlib/math/base/special/betainc":"base.betainc","@stdlib/math/base/special/betaincinv":"base.betaincinv","@stdlib/math/base/special/betaln":"base.betaln","@stdlib/math/base/special/binet":"base.binet","@stdlib/math/base/special/binomcoef":"base.binomcoef","@stdlib/math/base/special/binomcoefln":"base.binomcoefln","@stdlib/math/base/special/boxcox":"base.boxcox","@stdlib/math/base/special/boxcox1p":"base.boxcox1p","@stdlib/math/base/special/boxcox1pinv":"base.boxcox1pinv","@stdlib/math/base/special/boxcoxinv":"base.boxcoxinv","@stdlib/math/base/special/cabs":"base.cabs","@stdlib/math/base/special/cabs2":"base.cabs2","@stdlib/math/base/special/cabs2f":"base.cabs2f","@stdlib/math/base/special/cabsf":"base.cabsf","@stdlib/complex/float64/base/add":"base.cadd","@stdlib/complex/float32/base/add":"base.caddf","@stdlib/string/base/camelcase":"base.camelcase","@stdlib/string/base/capitalize":"base.capitalize","@stdlib/math/base/special/cbrt":"base.cbrt","@stdlib/math/base/special/cbrtf":"base.cbrtf","@stdlib/math/base/special/cceil":"base.cceil","@stdlib/math/base/special/cceilf":"base.cceilf","@stdlib/math/base/special/cceiln":"base.cceiln","@stdlib/math/base/special/ccis":"base.ccis","@stdlib/math/base/ops/cdiv":"base.cdiv","@stdlib/math/base/special/ceil":"base.ceil","@stdlib/math/base/special/ceil2":"base.ceil2","@stdlib/math/base/special/ceil10":"base.ceil10","@stdlib/math/base/special/ceilb":"base.ceilb","@stdlib/math/base/special/ceilf":"base.ceilf","@stdlib/math/base/special/ceiln":"base.ceiln","@stdlib/math/base/special/ceilsd":"base.ceilsd","@stdlib/math/base/special/cexp":"base.cexp","@stdlib/math/base/special/cflipsign":"base.cflipsign","@stdlib/math/base/special/cflipsignf":"base.cflipsignf","@stdlib/math/base/special/cfloor":"base.cfloor","@stdlib/math/base/special/cfloorn":"base.cfloorn","@stdlib/math/base/special/cidentity":"base.cidentity","@stdlib/math/base/special/cidentityf":"base.cidentityf","@stdlib/math/base/special/cinv":"base.cinv","@stdlib/math/base/special/clamp":"base.clamp","@stdlib/math/base/special/clampf":"base.clampf","@stdlib/complex/float64/base/mul":"base.cmul","@stdlib/complex/float32/base/mul":"base.cmulf","@stdlib/math/base/ops/cneg":"base.cneg","@stdlib/math/base/ops/cnegf":"base.cnegf","@stdlib/string/base/code-point-at":"base.codePointAt","@stdlib/string/base/constantcase":"base.constantcase","@stdlib/math/base/tools/continued-fraction":"base.continuedFraction","@stdlib/math/base/special/copysign":"base.copysign","@stdlib/math/base/special/copysignf":"base.copysignf","@stdlib/math/base/special/cos":"base.cos","@stdlib/math/base/special/cosd":"base.cosd","@stdlib/math/base/special/cosh":"base.cosh","@stdlib/math/base/special/cosm1":"base.cosm1","@stdlib/math/base/special/cospi":"base.cospi","@stdlib/math/base/special/cot":"base.cot","@stdlib/math/base/special/cotd":"base.cotd","@stdlib/math/base/special/coth":"base.coth","@stdlib/math/base/special/covercos":"base.covercos","@stdlib/math/base/special/coversin":"base.coversin","@stdlib/math/base/special/cphase":"base.cphase","@stdlib/math/base/special/cpolar":"base.cpolar","@stdlib/math/base/special/cround":"base.cround","@stdlib/math/base/special/croundn":"base.croundn","@stdlib/math/base/special/csc":"base.csc","@stdlib/math/base/special/cscd":"base.cscd","@stdlib/math/base/special/csch":"base.csch","@stdlib/math/base/special/csignum":"base.csignum","@stdlib/math/base/ops/csub":"base.csub","@stdlib/math/base/ops/csubf":"base.csubf","@stdlib/math/base/special/deg2rad":"base.deg2rad","@stdlib/math/base/special/deg2radf":"base.deg2radf","@stdlib/math/base/special/digamma":"base.digamma","@stdlib/math/base/special/dirac-delta":"base.diracDelta","@stdlib/number/float64/base/div":"base.div","@stdlib/number/float32/base/div":"base.divf","@stdlib/string/base/dotcase":"base.dotcase","@stdlib/stats/base/dists/arcsine/ctor":"base.dists.arcsine.Arcsine","@stdlib/stats/base/dists/arcsine/cdf":"base.dists.arcsine.cdf","@stdlib/stats/base/dists/arcsine/entropy":"base.dists.arcsine.entropy","@stdlib/stats/base/dists/arcsine/kurtosis":"base.dists.arcsine.kurtosis","@stdlib/stats/base/dists/arcsine/logcdf":"base.dists.arcsine.logcdf","@stdlib/stats/base/dists/arcsine/logpdf":"base.dists.arcsine.logpdf","@stdlib/stats/base/dists/arcsine/mean":"base.dists.arcsine.mean","@stdlib/stats/base/dists/arcsine/median":"base.dists.arcsine.median","@stdlib/stats/base/dists/arcsine/mode":"base.dists.arcsine.mode","@stdlib/stats/base/dists/arcsine/pdf":"base.dists.arcsine.pdf","@stdlib/stats/base/dists/arcsine/quantile":"base.dists.arcsine.quantile","@stdlib/stats/base/dists/arcsine/skewness":"base.dists.arcsine.skewness","@stdlib/stats/base/dists/arcsine/stdev":"base.dists.arcsine.stdev","@stdlib/stats/base/dists/arcsine/variance":"base.dists.arcsine.variance","@stdlib/stats/base/dists/bernoulli/ctor":"base.dists.bernoulli.Bernoulli","@stdlib/stats/base/dists/bernoulli/cdf":"base.dists.bernoulli.cdf","@stdlib/stats/base/dists/bernoulli/entropy":"base.dists.bernoulli.entropy","@stdlib/stats/base/dists/bernoulli/kurtosis":"base.dists.bernoulli.kurtosis","@stdlib/stats/base/dists/bernoulli/mean":"base.dists.bernoulli.mean","@stdlib/stats/base/dists/bernoulli/median":"base.dists.bernoulli.median","@stdlib/stats/base/dists/bernoulli/mgf":"base.dists.bernoulli.mgf","@stdlib/stats/base/dists/bernoulli/mode":"base.dists.bernoulli.mode","@stdlib/stats/base/dists/bernoulli/pmf":"base.dists.bernoulli.pmf","@stdlib/stats/base/dists/bernoulli/quantile":"base.dists.bernoulli.quantile","@stdlib/stats/base/dists/bernoulli/skewness":"base.dists.bernoulli.skewness","@stdlib/stats/base/dists/bernoulli/stdev":"base.dists.bernoulli.stdev","@stdlib/stats/base/dists/bernoulli/variance":"base.dists.bernoulli.variance","@stdlib/stats/base/dists/beta/ctor":"base.dists.beta.Beta","@stdlib/stats/base/dists/beta/cdf":"base.dists.beta.cdf","@stdlib/stats/base/dists/beta/entropy":"base.dists.beta.entropy","@stdlib/stats/base/dists/beta/kurtosis":"base.dists.beta.kurtosis","@stdlib/stats/base/dists/beta/logcdf":"base.dists.beta.logcdf","@stdlib/stats/base/dists/beta/logpdf":"base.dists.beta.logpdf","@stdlib/stats/base/dists/beta/mean":"base.dists.beta.mean","@stdlib/stats/base/dists/beta/median":"base.dists.beta.median","@stdlib/stats/base/dists/beta/mgf":"base.dists.beta.mgf","@stdlib/stats/base/dists/beta/mode":"base.dists.beta.mode","@stdlib/stats/base/dists/beta/pdf":"base.dists.beta.pdf","@stdlib/stats/base/dists/beta/quantile":"base.dists.beta.quantile","@stdlib/stats/base/dists/beta/skewness":"base.dists.beta.skewness","@stdlib/stats/base/dists/beta/stdev":"base.dists.beta.stdev","@stdlib/stats/base/dists/beta/variance":"base.dists.beta.variance","@stdlib/stats/base/dists/betaprime/ctor":"base.dists.betaprime.BetaPrime","@stdlib/stats/base/dists/betaprime/cdf":"base.dists.betaprime.cdf","@stdlib/stats/base/dists/betaprime/kurtosis":"base.dists.betaprime.kurtosis","@stdlib/stats/base/dists/betaprime/logcdf":"base.dists.betaprime.logcdf","@stdlib/stats/base/dists/betaprime/logpdf":"base.dists.betaprime.logpdf","@stdlib/stats/base/dists/betaprime/mean":"base.dists.betaprime.mean","@stdlib/stats/base/dists/betaprime/mode":"base.dists.betaprime.mode","@stdlib/stats/base/dists/betaprime/pdf":"base.dists.betaprime.pdf","@stdlib/stats/base/dists/betaprime/quantile":"base.dists.betaprime.quantile","@stdlib/stats/base/dists/betaprime/skewness":"base.dists.betaprime.skewness","@stdlib/stats/base/dists/betaprime/stdev":"base.dists.betaprime.stdev","@stdlib/stats/base/dists/betaprime/variance":"base.dists.betaprime.variance","@stdlib/stats/base/dists/binomial/ctor":"base.dists.binomial.Binomial","@stdlib/stats/base/dists/binomial/cdf":"base.dists.binomial.cdf","@stdlib/stats/base/dists/binomial/entropy":"base.dists.binomial.entropy","@stdlib/stats/base/dists/binomial/kurtosis":"base.dists.binomial.kurtosis","@stdlib/stats/base/dists/binomial/logpmf":"base.dists.binomial.logpmf","@stdlib/stats/base/dists/binomial/mean":"base.dists.binomial.mean","@stdlib/stats/base/dists/binomial/median":"base.dists.binomial.median","@stdlib/stats/base/dists/binomial/mgf":"base.dists.binomial.mgf","@stdlib/stats/base/dists/binomial/mode":"base.dists.binomial.mode","@stdlib/stats/base/dists/binomial/pmf":"base.dists.binomial.pmf","@stdlib/stats/base/dists/binomial/quantile":"base.dists.binomial.quantile","@stdlib/stats/base/dists/binomial/skewness":"base.dists.binomial.skewness","@stdlib/stats/base/dists/binomial/stdev":"base.dists.binomial.stdev","@stdlib/stats/base/dists/binomial/variance":"base.dists.binomial.variance","@stdlib/stats/base/dists/cauchy/ctor":"base.dists.cauchy.Cauchy","@stdlib/stats/base/dists/cauchy/cdf":"base.dists.cauchy.cdf","@stdlib/stats/base/dists/cauchy/entropy":"base.dists.cauchy.entropy","@stdlib/stats/base/dists/cauchy/logcdf":"base.dists.cauchy.logcdf","@stdlib/stats/base/dists/cauchy/logpdf":"base.dists.cauchy.logpdf","@stdlib/stats/base/dists/cauchy/median":"base.dists.cauchy.median","@stdlib/stats/base/dists/cauchy/mode":"base.dists.cauchy.mode","@stdlib/stats/base/dists/cauchy/pdf":"base.dists.cauchy.pdf","@stdlib/stats/base/dists/cauchy/quantile":"base.dists.cauchy.quantile","@stdlib/stats/base/dists/chi/cdf":"base.dists.chi.cdf","@stdlib/stats/base/dists/chi/ctor":"base.dists.chi.Chi","@stdlib/stats/base/dists/chi/entropy":"base.dists.chi.entropy","@stdlib/stats/base/dists/chi/kurtosis":"base.dists.chi.kurtosis","@stdlib/stats/base/dists/chi/logpdf":"base.dists.chi.logpdf","@stdlib/stats/base/dists/chi/mean":"base.dists.chi.mean","@stdlib/stats/base/dists/chi/mode":"base.dists.chi.mode","@stdlib/stats/base/dists/chi/pdf":"base.dists.chi.pdf","@stdlib/stats/base/dists/chi/quantile":"base.dists.chi.quantile","@stdlib/stats/base/dists/chi/skewness":"base.dists.chi.skewness","@stdlib/stats/base/dists/chi/stdev":"base.dists.chi.stdev","@stdlib/stats/base/dists/chi/variance":"base.dists.chi.variance","@stdlib/stats/base/dists/chisquare/cdf":"base.dists.chisquare.cdf","@stdlib/stats/base/dists/chisquare/ctor":"base.dists.chisquare.ChiSquare","@stdlib/stats/base/dists/chisquare/entropy":"base.dists.chisquare.entropy","@stdlib/stats/base/dists/chisquare/kurtosis":"base.dists.chisquare.kurtosis","@stdlib/stats/base/dists/chisquare/logpdf":"base.dists.chisquare.logpdf","@stdlib/stats/base/dists/chisquare/mean":"base.dists.chisquare.mean","@stdlib/stats/base/dists/chisquare/median":"base.dists.chisquare.median","@stdlib/stats/base/dists/chisquare/mgf":"base.dists.chisquare.mgf","@stdlib/stats/base/dists/chisquare/mode":"base.dists.chisquare.mode","@stdlib/stats/base/dists/chisquare/pdf":"base.dists.chisquare.pdf","@stdlib/stats/base/dists/chisquare/quantile":"base.dists.chisquare.quantile","@stdlib/stats/base/dists/chisquare/skewness":"base.dists.chisquare.skewness","@stdlib/stats/base/dists/chisquare/stdev":"base.dists.chisquare.stdev","@stdlib/stats/base/dists/chisquare/variance":"base.dists.chisquare.variance","@stdlib/stats/base/dists/cosine/cdf":"base.dists.cosine.cdf","@stdlib/stats/base/dists/cosine/ctor":"base.dists.cosine.Cosine","@stdlib/stats/base/dists/cosine/kurtosis":"base.dists.cosine.kurtosis","@stdlib/stats/base/dists/cosine/logcdf":"base.dists.cosine.logcdf","@stdlib/stats/base/dists/cosine/logpdf":"base.dists.cosine.logpdf","@stdlib/stats/base/dists/cosine/mean":"base.dists.cosine.mean","@stdlib/stats/base/dists/cosine/median":"base.dists.cosine.median","@stdlib/stats/base/dists/cosine/mgf":"base.dists.cosine.mgf","@stdlib/stats/base/dists/cosine/mode":"base.dists.cosine.mode","@stdlib/stats/base/dists/cosine/pdf":"base.dists.cosine.pdf","@stdlib/stats/base/dists/cosine/quantile":"base.dists.cosine.quantile","@stdlib/stats/base/dists/cosine/skewness":"base.dists.cosine.skewness","@stdlib/stats/base/dists/cosine/stdev":"base.dists.cosine.stdev","@stdlib/stats/base/dists/cosine/variance":"base.dists.cosine.variance","@stdlib/stats/base/dists/degenerate/cdf":"base.dists.degenerate.cdf","@stdlib/stats/base/dists/degenerate/ctor":"base.dists.degenerate.Degenerate","@stdlib/stats/base/dists/degenerate/entropy":"base.dists.degenerate.entropy","@stdlib/stats/base/dists/degenerate/logcdf":"base.dists.degenerate.logcdf","@stdlib/stats/base/dists/degenerate/logpdf":"base.dists.degenerate.logpdf","@stdlib/stats/base/dists/degenerate/logpmf":"base.dists.degenerate.logpmf","@stdlib/stats/base/dists/degenerate/mean":"base.dists.degenerate.mean","@stdlib/stats/base/dists/degenerate/median":"base.dists.degenerate.median","@stdlib/stats/base/dists/degenerate/mgf":"base.dists.degenerate.mgf","@stdlib/stats/base/dists/degenerate/mode":"base.dists.degenerate.mode","@stdlib/stats/base/dists/degenerate/pdf":"base.dists.degenerate.pdf","@stdlib/stats/base/dists/degenerate/pmf":"base.dists.degenerate.pmf","@stdlib/stats/base/dists/degenerate/quantile":"base.dists.degenerate.quantile","@stdlib/stats/base/dists/degenerate/stdev":"base.dists.degenerate.stdev","@stdlib/stats/base/dists/degenerate/variance":"base.dists.degenerate.variance","@stdlib/stats/base/dists/discrete-uniform/cdf":"base.dists.discreteUniform.cdf","@stdlib/stats/base/dists/discrete-uniform/ctor":"base.dists.discreteUniform.DiscreteUniform","@stdlib/stats/base/dists/discrete-uniform/entropy":"base.dists.discreteUniform.entropy","@stdlib/stats/base/dists/discrete-uniform/kurtosis":"base.dists.discreteUniform.kurtosis","@stdlib/stats/base/dists/discrete-uniform/logcdf":"base.dists.discreteUniform.logcdf","@stdlib/stats/base/dists/discrete-uniform/logpmf":"base.dists.discreteUniform.logpmf","@stdlib/stats/base/dists/discrete-uniform/mean":"base.dists.discreteUniform.mean","@stdlib/stats/base/dists/discrete-uniform/median":"base.dists.discreteUniform.median","@stdlib/stats/base/dists/discrete-uniform/mgf":"base.dists.discreteUniform.mgf","@stdlib/stats/base/dists/discrete-uniform/pmf":"base.dists.discreteUniform.pmf","@stdlib/stats/base/dists/discrete-uniform/quantile":"base.dists.discreteUniform.quantile","@stdlib/stats/base/dists/discrete-uniform/skewness":"base.dists.discreteUniform.skewness","@stdlib/stats/base/dists/discrete-uniform/stdev":"base.dists.discreteUniform.stdev","@stdlib/stats/base/dists/discrete-uniform/variance":"base.dists.discreteUniform.variance","@stdlib/stats/base/dists/erlang/cdf":"base.dists.erlang.cdf","@stdlib/stats/base/dists/erlang/entropy":"base.dists.erlang.entropy","@stdlib/stats/base/dists/erlang/ctor":"base.dists.erlang.Erlang","@stdlib/stats/base/dists/erlang/kurtosis":"base.dists.erlang.kurtosis","@stdlib/stats/base/dists/erlang/logpdf":"base.dists.erlang.logpdf","@stdlib/stats/base/dists/erlang/mean":"base.dists.erlang.mean","@stdlib/stats/base/dists/erlang/mgf":"base.dists.erlang.mgf","@stdlib/stats/base/dists/erlang/mode":"base.dists.erlang.mode","@stdlib/stats/base/dists/erlang/pdf":"base.dists.erlang.pdf","@stdlib/stats/base/dists/erlang/quantile":"base.dists.erlang.quantile","@stdlib/stats/base/dists/erlang/skewness":"base.dists.erlang.skewness","@stdlib/stats/base/dists/erlang/stdev":"base.dists.erlang.stdev","@stdlib/stats/base/dists/erlang/variance":"base.dists.erlang.variance","@stdlib/stats/base/dists/exponential/cdf":"base.dists.exponential.cdf","@stdlib/stats/base/dists/exponential/entropy":"base.dists.exponential.entropy","@stdlib/stats/base/dists/exponential/ctor":"base.dists.exponential.Exponential","@stdlib/stats/base/dists/exponential/kurtosis":"base.dists.exponential.kurtosis","@stdlib/stats/base/dists/exponential/logcdf":"base.dists.exponential.logcdf","@stdlib/stats/base/dists/exponential/logpdf":"base.dists.exponential.logpdf","@stdlib/stats/base/dists/exponential/mean":"base.dists.exponential.mean","@stdlib/stats/base/dists/exponential/median":"base.dists.exponential.median","@stdlib/stats/base/dists/exponential/mgf":"base.dists.exponential.mgf","@stdlib/stats/base/dists/exponential/mode":"base.dists.exponential.mode","@stdlib/stats/base/dists/exponential/pdf":"base.dists.exponential.pdf","@stdlib/stats/base/dists/exponential/quantile":"base.dists.exponential.quantile","@stdlib/stats/base/dists/exponential/skewness":"base.dists.exponential.skewness","@stdlib/stats/base/dists/exponential/stdev":"base.dists.exponential.stdev","@stdlib/stats/base/dists/exponential/variance":"base.dists.exponential.variance","@stdlib/stats/base/dists/f/cdf":"base.dists.f.cdf","@stdlib/stats/base/dists/f/entropy":"base.dists.f.entropy","@stdlib/stats/base/dists/f/ctor":"base.dists.f.F","@stdlib/stats/base/dists/f/kurtosis":"base.dists.f.kurtosis","@stdlib/stats/base/dists/f/mean":"base.dists.f.mean","@stdlib/stats/base/dists/f/mode":"base.dists.f.mode","@stdlib/stats/base/dists/f/pdf":"base.dists.f.pdf","@stdlib/stats/base/dists/f/quantile":"base.dists.f.quantile","@stdlib/stats/base/dists/f/skewness":"base.dists.f.skewness","@stdlib/stats/base/dists/f/stdev":"base.dists.f.stdev","@stdlib/stats/base/dists/f/variance":"base.dists.f.variance","@stdlib/stats/base/dists/frechet/cdf":"base.dists.frechet.cdf","@stdlib/stats/base/dists/frechet/entropy":"base.dists.frechet.entropy","@stdlib/stats/base/dists/frechet/ctor":"base.dists.frechet.Frechet","@stdlib/stats/base/dists/frechet/kurtosis":"base.dists.frechet.kurtosis","@stdlib/stats/base/dists/frechet/logcdf":"base.dists.frechet.logcdf","@stdlib/stats/base/dists/frechet/logpdf":"base.dists.frechet.logpdf","@stdlib/stats/base/dists/frechet/mean":"base.dists.frechet.mean","@stdlib/stats/base/dists/frechet/median":"base.dists.frechet.median","@stdlib/stats/base/dists/frechet/mode":"base.dists.frechet.mode","@stdlib/stats/base/dists/frechet/pdf":"base.dists.frechet.pdf","@stdlib/stats/base/dists/frechet/quantile":"base.dists.frechet.quantile","@stdlib/stats/base/dists/frechet/skewness":"base.dists.frechet.skewness","@stdlib/stats/base/dists/frechet/stdev":"base.dists.frechet.stdev","@stdlib/stats/base/dists/frechet/variance":"base.dists.frechet.variance","@stdlib/stats/base/dists/gamma/cdf":"base.dists.gamma.cdf","@stdlib/stats/base/dists/gamma/entropy":"base.dists.gamma.entropy","@stdlib/stats/base/dists/gamma/ctor":"base.dists.gamma.Gamma","@stdlib/stats/base/dists/gamma/kurtosis":"base.dists.gamma.kurtosis","@stdlib/stats/base/dists/gamma/logcdf":"base.dists.gamma.logcdf","@stdlib/stats/base/dists/gamma/logpdf":"base.dists.gamma.logpdf","@stdlib/stats/base/dists/gamma/mean":"base.dists.gamma.mean","@stdlib/stats/base/dists/gamma/mgf":"base.dists.gamma.mgf","@stdlib/stats/base/dists/gamma/mode":"base.dists.gamma.mode","@stdlib/stats/base/dists/gamma/pdf":"base.dists.gamma.pdf","@stdlib/stats/base/dists/gamma/quantile":"base.dists.gamma.quantile","@stdlib/stats/base/dists/gamma/skewness":"base.dists.gamma.skewness","@stdlib/stats/base/dists/gamma/stdev":"base.dists.gamma.stdev","@stdlib/stats/base/dists/gamma/variance":"base.dists.gamma.variance","@stdlib/stats/base/dists/geometric/cdf":"base.dists.geometric.cdf","@stdlib/stats/base/dists/geometric/entropy":"base.dists.geometric.entropy","@stdlib/stats/base/dists/geometric/ctor":"base.dists.geometric.Geometric","@stdlib/stats/base/dists/geometric/kurtosis":"base.dists.geometric.kurtosis","@stdlib/stats/base/dists/geometric/logcdf":"base.dists.geometric.logcdf","@stdlib/stats/base/dists/geometric/logpmf":"base.dists.geometric.logpmf","@stdlib/stats/base/dists/geometric/mean":"base.dists.geometric.mean","@stdlib/stats/base/dists/geometric/median":"base.dists.geometric.median","@stdlib/stats/base/dists/geometric/mgf":"base.dists.geometric.mgf","@stdlib/stats/base/dists/geometric/mode":"base.dists.geometric.mode","@stdlib/stats/base/dists/geometric/pmf":"base.dists.geometric.pmf","@stdlib/stats/base/dists/geometric/quantile":"base.dists.geometric.quantile","@stdlib/stats/base/dists/geometric/skewness":"base.dists.geometric.skewness","@stdlib/stats/base/dists/geometric/stdev":"base.dists.geometric.stdev","@stdlib/stats/base/dists/geometric/variance":"base.dists.geometric.variance","@stdlib/stats/base/dists/gumbel/cdf":"base.dists.gumbel.cdf","@stdlib/stats/base/dists/gumbel/entropy":"base.dists.gumbel.entropy","@stdlib/stats/base/dists/gumbel/ctor":"base.dists.gumbel.Gumbel","@stdlib/stats/base/dists/gumbel/kurtosis":"base.dists.gumbel.kurtosis","@stdlib/stats/base/dists/gumbel/logcdf":"base.dists.gumbel.logcdf","@stdlib/stats/base/dists/gumbel/logpdf":"base.dists.gumbel.logpdf","@stdlib/stats/base/dists/gumbel/mean":"base.dists.gumbel.mean","@stdlib/stats/base/dists/gumbel/median":"base.dists.gumbel.median","@stdlib/stats/base/dists/gumbel/mgf":"base.dists.gumbel.mgf","@stdlib/stats/base/dists/gumbel/mode":"base.dists.gumbel.mode","@stdlib/stats/base/dists/gumbel/pdf":"base.dists.gumbel.pdf","@stdlib/stats/base/dists/gumbel/quantile":"base.dists.gumbel.quantile","@stdlib/stats/base/dists/gumbel/skewness":"base.dists.gumbel.skewness","@stdlib/stats/base/dists/gumbel/stdev":"base.dists.gumbel.stdev","@stdlib/stats/base/dists/gumbel/variance":"base.dists.gumbel.variance","@stdlib/stats/base/dists/hypergeometric/cdf":"base.dists.hypergeometric.cdf","@stdlib/stats/base/dists/hypergeometric/ctor":"base.dists.hypergeometric.Hypergeometric","@stdlib/stats/base/dists/hypergeometric/kurtosis":"base.dists.hypergeometric.kurtosis","@stdlib/stats/base/dists/hypergeometric/logpmf":"base.dists.hypergeometric.logpmf","@stdlib/stats/base/dists/hypergeometric/mean":"base.dists.hypergeometric.mean","@stdlib/stats/base/dists/hypergeometric/mode":"base.dists.hypergeometric.mode","@stdlib/stats/base/dists/hypergeometric/pmf":"base.dists.hypergeometric.pmf","@stdlib/stats/base/dists/hypergeometric/quantile":"base.dists.hypergeometric.quantile","@stdlib/stats/base/dists/hypergeometric/skewness":"base.dists.hypergeometric.skewness","@stdlib/stats/base/dists/hypergeometric/stdev":"base.dists.hypergeometric.stdev","@stdlib/stats/base/dists/hypergeometric/variance":"base.dists.hypergeometric.variance","@stdlib/stats/base/dists/invgamma/cdf":"base.dists.invgamma.cdf","@stdlib/stats/base/dists/invgamma/entropy":"base.dists.invgamma.entropy","@stdlib/stats/base/dists/invgamma/ctor":"base.dists.invgamma.InvGamma","@stdlib/stats/base/dists/invgamma/kurtosis":"base.dists.invgamma.kurtosis","@stdlib/stats/base/dists/invgamma/logpdf":"base.dists.invgamma.logpdf","@stdlib/stats/base/dists/invgamma/mean":"base.dists.invgamma.mean","@stdlib/stats/base/dists/invgamma/mode":"base.dists.invgamma.mode","@stdlib/stats/base/dists/invgamma/pdf":"base.dists.invgamma.pdf","@stdlib/stats/base/dists/invgamma/quantile":"base.dists.invgamma.quantile","@stdlib/stats/base/dists/invgamma/skewness":"base.dists.invgamma.skewness","@stdlib/stats/base/dists/invgamma/stdev":"base.dists.invgamma.stdev","@stdlib/stats/base/dists/invgamma/variance":"base.dists.invgamma.variance","@stdlib/stats/base/dists/kumaraswamy/cdf":"base.dists.kumaraswamy.cdf","@stdlib/stats/base/dists/kumaraswamy/ctor":"base.dists.kumaraswamy.Kumaraswamy","@stdlib/stats/base/dists/kumaraswamy/kurtosis":"base.dists.kumaraswamy.kurtosis","@stdlib/stats/base/dists/kumaraswamy/logcdf":"base.dists.kumaraswamy.logcdf","@stdlib/stats/base/dists/kumaraswamy/logpdf":"base.dists.kumaraswamy.logpdf","@stdlib/stats/base/dists/kumaraswamy/mean":"base.dists.kumaraswamy.mean","@stdlib/stats/base/dists/kumaraswamy/median":"base.dists.kumaraswamy.median","@stdlib/stats/base/dists/kumaraswamy/mode":"base.dists.kumaraswamy.mode","@stdlib/stats/base/dists/kumaraswamy/pdf":"base.dists.kumaraswamy.pdf","@stdlib/stats/base/dists/kumaraswamy/quantile":"base.dists.kumaraswamy.quantile","@stdlib/stats/base/dists/kumaraswamy/skewness":"base.dists.kumaraswamy.skewness","@stdlib/stats/base/dists/kumaraswamy/stdev":"base.dists.kumaraswamy.stdev","@stdlib/stats/base/dists/kumaraswamy/variance":"base.dists.kumaraswamy.variance","@stdlib/stats/base/dists/laplace/cdf":"base.dists.laplace.cdf","@stdlib/stats/base/dists/laplace/entropy":"base.dists.laplace.entropy","@stdlib/stats/base/dists/laplace/kurtosis":"base.dists.laplace.kurtosis","@stdlib/stats/base/dists/laplace/ctor":"base.dists.laplace.Laplace","@stdlib/stats/base/dists/laplace/logcdf":"base.dists.laplace.logcdf","@stdlib/stats/base/dists/laplace/logpdf":"base.dists.laplace.logpdf","@stdlib/stats/base/dists/laplace/mean":"base.dists.laplace.mean","@stdlib/stats/base/dists/laplace/median":"base.dists.laplace.median","@stdlib/stats/base/dists/laplace/mgf":"base.dists.laplace.mgf","@stdlib/stats/base/dists/laplace/mode":"base.dists.laplace.mode","@stdlib/stats/base/dists/laplace/pdf":"base.dists.laplace.pdf","@stdlib/stats/base/dists/laplace/quantile":"base.dists.laplace.quantile","@stdlib/stats/base/dists/laplace/skewness":"base.dists.laplace.skewness","@stdlib/stats/base/dists/laplace/stdev":"base.dists.laplace.stdev","@stdlib/stats/base/dists/laplace/variance":"base.dists.laplace.variance","@stdlib/stats/base/dists/levy/cdf":"base.dists.levy.cdf","@stdlib/stats/base/dists/levy/entropy":"base.dists.levy.entropy","@stdlib/stats/base/dists/levy/ctor":"base.dists.levy.Levy","@stdlib/stats/base/dists/levy/logcdf":"base.dists.levy.logcdf","@stdlib/stats/base/dists/levy/logpdf":"base.dists.levy.logpdf","@stdlib/stats/base/dists/levy/mean":"base.dists.levy.mean","@stdlib/stats/base/dists/levy/median":"base.dists.levy.median","@stdlib/stats/base/dists/levy/mode":"base.dists.levy.mode","@stdlib/stats/base/dists/levy/pdf":"base.dists.levy.pdf","@stdlib/stats/base/dists/levy/quantile":"base.dists.levy.quantile","@stdlib/stats/base/dists/levy/stdev":"base.dists.levy.stdev","@stdlib/stats/base/dists/levy/variance":"base.dists.levy.variance","@stdlib/stats/base/dists/logistic/cdf":"base.dists.logistic.cdf","@stdlib/stats/base/dists/logistic/entropy":"base.dists.logistic.entropy","@stdlib/stats/base/dists/logistic/kurtosis":"base.dists.logistic.kurtosis","@stdlib/stats/base/dists/logistic/logcdf":"base.dists.logistic.logcdf","@stdlib/stats/base/dists/logistic/ctor":"base.dists.logistic.Logistic","@stdlib/stats/base/dists/logistic/logpdf":"base.dists.logistic.logpdf","@stdlib/stats/base/dists/logistic/mean":"base.dists.logistic.mean","@stdlib/stats/base/dists/logistic/median":"base.dists.logistic.median","@stdlib/stats/base/dists/logistic/mgf":"base.dists.logistic.mgf","@stdlib/stats/base/dists/logistic/mode":"base.dists.logistic.mode","@stdlib/stats/base/dists/logistic/pdf":"base.dists.logistic.pdf","@stdlib/stats/base/dists/logistic/quantile":"base.dists.logistic.quantile","@stdlib/stats/base/dists/logistic/skewness":"base.dists.logistic.skewness","@stdlib/stats/base/dists/logistic/stdev":"base.dists.logistic.stdev","@stdlib/stats/base/dists/logistic/variance":"base.dists.logistic.variance","@stdlib/stats/base/dists/lognormal/cdf":"base.dists.lognormal.cdf","@stdlib/stats/base/dists/lognormal/entropy":"base.dists.lognormal.entropy","@stdlib/stats/base/dists/lognormal/kurtosis":"base.dists.lognormal.kurtosis","@stdlib/stats/base/dists/lognormal/ctor":"base.dists.lognormal.LogNormal","@stdlib/stats/base/dists/lognormal/logcdf":"base.dists.lognormal.logcdf","@stdlib/stats/base/dists/lognormal/logpdf":"base.dists.lognormal.logpdf","@stdlib/stats/base/dists/lognormal/mean":"base.dists.lognormal.mean","@stdlib/stats/base/dists/lognormal/median":"base.dists.lognormal.median","@stdlib/stats/base/dists/lognormal/mode":"base.dists.lognormal.mode","@stdlib/stats/base/dists/lognormal/pdf":"base.dists.lognormal.pdf","@stdlib/stats/base/dists/lognormal/quantile":"base.dists.lognormal.quantile","@stdlib/stats/base/dists/lognormal/skewness":"base.dists.lognormal.skewness","@stdlib/stats/base/dists/lognormal/stdev":"base.dists.lognormal.stdev","@stdlib/stats/base/dists/lognormal/variance":"base.dists.lognormal.variance","@stdlib/stats/base/dists/negative-binomial/cdf":"base.dists.negativeBinomial.cdf","@stdlib/stats/base/dists/negative-binomial/kurtosis":"base.dists.negativeBinomial.kurtosis","@stdlib/stats/base/dists/negative-binomial/logpmf":"base.dists.negativeBinomial.logpmf","@stdlib/stats/base/dists/negative-binomial/mean":"base.dists.negativeBinomial.mean","@stdlib/stats/base/dists/negative-binomial/mgf":"base.dists.negativeBinomial.mgf","@stdlib/stats/base/dists/negative-binomial/mode":"base.dists.negativeBinomial.mode","@stdlib/stats/base/dists/negative-binomial/ctor":"base.dists.negativeBinomial.NegativeBinomial","@stdlib/stats/base/dists/negative-binomial/pmf":"base.dists.negativeBinomial.pmf","@stdlib/stats/base/dists/negative-binomial/quantile":"base.dists.negativeBinomial.quantile","@stdlib/stats/base/dists/negative-binomial/skewness":"base.dists.negativeBinomial.skewness","@stdlib/stats/base/dists/negative-binomial/stdev":"base.dists.negativeBinomial.stdev","@stdlib/stats/base/dists/negative-binomial/variance":"base.dists.negativeBinomial.variance","@stdlib/stats/base/dists/normal/cdf":"base.dists.normal.cdf","@stdlib/stats/base/dists/normal/entropy":"base.dists.normal.entropy","@stdlib/stats/base/dists/normal/kurtosis":"base.dists.normal.kurtosis","@stdlib/stats/base/dists/normal/logcdf":"base.dists.normal.logcdf","@stdlib/stats/base/dists/normal/logpdf":"base.dists.normal.logpdf","@stdlib/stats/base/dists/normal/mean":"base.dists.normal.mean","@stdlib/stats/base/dists/normal/median":"base.dists.normal.median","@stdlib/stats/base/dists/normal/mgf":"base.dists.normal.mgf","@stdlib/stats/base/dists/normal/mode":"base.dists.normal.mode","@stdlib/stats/base/dists/normal/ctor":"base.dists.normal.Normal","@stdlib/stats/base/dists/normal/pdf":"base.dists.normal.pdf","@stdlib/stats/base/dists/normal/quantile":"base.dists.normal.quantile","@stdlib/stats/base/dists/normal/skewness":"base.dists.normal.skewness","@stdlib/stats/base/dists/normal/stdev":"base.dists.normal.stdev","@stdlib/stats/base/dists/normal/variance":"base.dists.normal.variance","@stdlib/stats/base/dists/pareto-type1/cdf":"base.dists.pareto1.cdf","@stdlib/stats/base/dists/pareto-type1/entropy":"base.dists.pareto1.entropy","@stdlib/stats/base/dists/pareto-type1/kurtosis":"base.dists.pareto1.kurtosis","@stdlib/stats/base/dists/pareto-type1/logcdf":"base.dists.pareto1.logcdf","@stdlib/stats/base/dists/pareto-type1/logpdf":"base.dists.pareto1.logpdf","@stdlib/stats/base/dists/pareto-type1/mean":"base.dists.pareto1.mean","@stdlib/stats/base/dists/pareto-type1/median":"base.dists.pareto1.median","@stdlib/stats/base/dists/pareto-type1/mode":"base.dists.pareto1.mode","@stdlib/stats/base/dists/pareto-type1/ctor":"base.dists.pareto1.Pareto1","@stdlib/stats/base/dists/pareto-type1/pdf":"base.dists.pareto1.pdf","@stdlib/stats/base/dists/pareto-type1/quantile":"base.dists.pareto1.quantile","@stdlib/stats/base/dists/pareto-type1/skewness":"base.dists.pareto1.skewness","@stdlib/stats/base/dists/pareto-type1/stdev":"base.dists.pareto1.stdev","@stdlib/stats/base/dists/pareto-type1/variance":"base.dists.pareto1.variance","@stdlib/stats/base/dists/poisson/cdf":"base.dists.poisson.cdf","@stdlib/stats/base/dists/poisson/entropy":"base.dists.poisson.entropy","@stdlib/stats/base/dists/poisson/kurtosis":"base.dists.poisson.kurtosis","@stdlib/stats/base/dists/poisson/logpmf":"base.dists.poisson.logpmf","@stdlib/stats/base/dists/poisson/mean":"base.dists.poisson.mean","@stdlib/stats/base/dists/poisson/median":"base.dists.poisson.median","@stdlib/stats/base/dists/poisson/mgf":"base.dists.poisson.mgf","@stdlib/stats/base/dists/poisson/mode":"base.dists.poisson.mode","@stdlib/stats/base/dists/poisson/pmf":"base.dists.poisson.pmf","@stdlib/stats/base/dists/poisson/ctor":"base.dists.poisson.Poisson","@stdlib/stats/base/dists/poisson/quantile":"base.dists.poisson.quantile","@stdlib/stats/base/dists/poisson/skewness":"base.dists.poisson.skewness","@stdlib/stats/base/dists/poisson/stdev":"base.dists.poisson.stdev","@stdlib/stats/base/dists/poisson/variance":"base.dists.poisson.variance","@stdlib/stats/base/dists/rayleigh/cdf":"base.dists.rayleigh.cdf","@stdlib/stats/base/dists/rayleigh/entropy":"base.dists.rayleigh.entropy","@stdlib/stats/base/dists/rayleigh/kurtosis":"base.dists.rayleigh.kurtosis","@stdlib/stats/base/dists/rayleigh/logcdf":"base.dists.rayleigh.logcdf","@stdlib/stats/base/dists/rayleigh/logpdf":"base.dists.rayleigh.logpdf","@stdlib/stats/base/dists/rayleigh/mean":"base.dists.rayleigh.mean","@stdlib/stats/base/dists/rayleigh/median":"base.dists.rayleigh.median","@stdlib/stats/base/dists/rayleigh/mgf":"base.dists.rayleigh.mgf","@stdlib/stats/base/dists/rayleigh/mode":"base.dists.rayleigh.mode","@stdlib/stats/base/dists/rayleigh/pdf":"base.dists.rayleigh.pdf","@stdlib/stats/base/dists/rayleigh/quantile":"base.dists.rayleigh.quantile","@stdlib/stats/base/dists/rayleigh/ctor":"base.dists.rayleigh.Rayleigh","@stdlib/stats/base/dists/rayleigh/skewness":"base.dists.rayleigh.skewness","@stdlib/stats/base/dists/rayleigh/stdev":"base.dists.rayleigh.stdev","@stdlib/stats/base/dists/rayleigh/variance":"base.dists.rayleigh.variance","@stdlib/stats/base/dists/signrank/cdf":"base.dists.signrank.cdf","@stdlib/stats/base/dists/signrank/pdf":"base.dists.signrank.pdf","@stdlib/stats/base/dists/signrank/quantile":"base.dists.signrank.quantile","@stdlib/stats/base/dists/studentized-range/cdf":"base.dists.studentizedRange.cdf","@stdlib/stats/base/dists/studentized-range/quantile":"base.dists.studentizedRange.quantile","@stdlib/stats/base/dists/t/cdf":"base.dists.t.cdf","@stdlib/stats/base/dists/t/entropy":"base.dists.t.entropy","@stdlib/stats/base/dists/t/kurtosis":"base.dists.t.kurtosis","@stdlib/stats/base/dists/t/logcdf":"base.dists.t.logcdf","@stdlib/stats/base/dists/t/logpdf":"base.dists.t.logpdf","@stdlib/stats/base/dists/t/mean":"base.dists.t.mean","@stdlib/stats/base/dists/t/median":"base.dists.t.median","@stdlib/stats/base/dists/t/mode":"base.dists.t.mode","@stdlib/stats/base/dists/t/pdf":"base.dists.t.pdf","@stdlib/stats/base/dists/t/quantile":"base.dists.t.quantile","@stdlib/stats/base/dists/t/skewness":"base.dists.t.skewness","@stdlib/stats/base/dists/t/stdev":"base.dists.t.stdev","@stdlib/stats/base/dists/t/ctor":"base.dists.t.T","@stdlib/stats/base/dists/t/variance":"base.dists.t.variance","@stdlib/stats/base/dists/triangular/cdf":"base.dists.triangular.cdf","@stdlib/stats/base/dists/triangular/entropy":"base.dists.triangular.entropy","@stdlib/stats/base/dists/triangular/kurtosis":"base.dists.triangular.kurtosis","@stdlib/stats/base/dists/triangular/logcdf":"base.dists.triangular.logcdf","@stdlib/stats/base/dists/triangular/logpdf":"base.dists.triangular.logpdf","@stdlib/stats/base/dists/triangular/mean":"base.dists.triangular.mean","@stdlib/stats/base/dists/triangular/median":"base.dists.triangular.median","@stdlib/stats/base/dists/triangular/mgf":"base.dists.triangular.mgf","@stdlib/stats/base/dists/triangular/mode":"base.dists.triangular.mode","@stdlib/stats/base/dists/triangular/pdf":"base.dists.triangular.pdf","@stdlib/stats/base/dists/triangular/quantile":"base.dists.triangular.quantile","@stdlib/stats/base/dists/triangular/skewness":"base.dists.triangular.skewness","@stdlib/stats/base/dists/triangular/stdev":"base.dists.triangular.stdev","@stdlib/stats/base/dists/triangular/ctor":"base.dists.triangular.Triangular","@stdlib/stats/base/dists/triangular/variance":"base.dists.triangular.variance","@stdlib/stats/base/dists/truncated-normal/pdf":"base.dists.truncatedNormal.pdf","@stdlib/stats/base/dists/uniform/cdf":"base.dists.uniform.cdf","@stdlib/stats/base/dists/uniform/entropy":"base.dists.uniform.entropy","@stdlib/stats/base/dists/uniform/kurtosis":"base.dists.uniform.kurtosis","@stdlib/stats/base/dists/uniform/logcdf":"base.dists.uniform.logcdf","@stdlib/stats/base/dists/uniform/logpdf":"base.dists.uniform.logpdf","@stdlib/stats/base/dists/uniform/mean":"base.dists.uniform.mean","@stdlib/stats/base/dists/uniform/median":"base.dists.uniform.median","@stdlib/stats/base/dists/uniform/mgf":"base.dists.uniform.mgf","@stdlib/stats/base/dists/uniform/pdf":"base.dists.uniform.pdf","@stdlib/stats/base/dists/uniform/quantile":"base.dists.uniform.quantile","@stdlib/stats/base/dists/uniform/skewness":"base.dists.uniform.skewness","@stdlib/stats/base/dists/uniform/stdev":"base.dists.uniform.stdev","@stdlib/stats/base/dists/uniform/ctor":"base.dists.uniform.Uniform","@stdlib/stats/base/dists/uniform/variance":"base.dists.uniform.variance","@stdlib/stats/base/dists/weibull/cdf":"base.dists.weibull.cdf","@stdlib/stats/base/dists/weibull/entropy":"base.dists.weibull.entropy","@stdlib/stats/base/dists/weibull/kurtosis":"base.dists.weibull.kurtosis","@stdlib/stats/base/dists/weibull/logcdf":"base.dists.weibull.logcdf","@stdlib/stats/base/dists/weibull/logpdf":"base.dists.weibull.logpdf","@stdlib/stats/base/dists/weibull/mean":"base.dists.weibull.mean","@stdlib/stats/base/dists/weibull/median":"base.dists.weibull.median","@stdlib/stats/base/dists/weibull/mgf":"base.dists.weibull.mgf","@stdlib/stats/base/dists/weibull/mode":"base.dists.weibull.mode","@stdlib/stats/base/dists/weibull/pdf":"base.dists.weibull.pdf","@stdlib/stats/base/dists/weibull/quantile":"base.dists.weibull.quantile","@stdlib/stats/base/dists/weibull/skewness":"base.dists.weibull.skewness","@stdlib/stats/base/dists/weibull/stdev":"base.dists.weibull.stdev","@stdlib/stats/base/dists/weibull/variance":"base.dists.weibull.variance","@stdlib/stats/base/dists/weibull/ctor":"base.dists.weibull.Weibull","@stdlib/math/base/special/ellipe":"base.ellipe","@stdlib/math/base/special/ellipj":"base.ellipj","@stdlib/math/base/special/ellipk":"base.ellipk","@stdlib/string/base/ends-with":"base.endsWith","@stdlib/math/base/utils/float64-epsilon-difference":"base.epsdiff","@stdlib/math/base/special/erf":"base.erf","@stdlib/math/base/special/erfc":"base.erfc","@stdlib/math/base/special/erfcinv":"base.erfcinv","@stdlib/math/base/special/erfcx":"base.erfcx","@stdlib/math/base/special/erfinv":"base.erfinv","@stdlib/math/base/special/dirichlet-eta":"base.eta","@stdlib/math/base/tools/evalpoly":"base.evalpoly","@stdlib/math/base/tools/evalrational":"base.evalrational","@stdlib/math/base/special/exp":"base.exp","@stdlib/math/base/special/exp2":"base.exp2","@stdlib/math/base/special/exp10":"base.exp10","@stdlib/math/base/special/expit":"base.expit","@stdlib/math/base/special/expm1":"base.expm1","@stdlib/math/base/special/expm1rel":"base.expm1rel","@stdlib/number/float64/base/exponent":"base.exponent","@stdlib/number/float32/base/exponent":"base.exponentf","@stdlib/math/base/special/factorial":"base.factorial","@stdlib/math/base/special/factorial2":"base.factorial2","@stdlib/math/base/special/factorialln":"base.factorialln","@stdlib/math/base/special/falling-factorial":"base.fallingFactorial","@stdlib/math/base/special/fibonacci":"base.fibonacci","@stdlib/math/base/special/fibonacci-index":"base.fibonacciIndex","@stdlib/math/base/tools/fibpoly":"base.fibpoly","@stdlib/string/base/first-code-point":"base.firstCodePoint","@stdlib/string/base/first":"base.firstCodeUnit","@stdlib/string/base/first-grapheme-cluster":"base.firstGraphemeCluster","@stdlib/math/base/special/flipsign":"base.flipsign","@stdlib/math/base/special/flipsignf":"base.flipsignf","@stdlib/number/float32/base/to-int32":"base.float32ToInt32","@stdlib/number/float32/base/to-uint32":"base.float32ToUint32","@stdlib/number/float64/base/to-float32":"base.float64ToFloat32","@stdlib/number/float64/base/to-int32":"base.float64ToInt32","@stdlib/number/float64/base/to-int64-bytes":"base.float64ToInt64Bytes","@stdlib/number/float64/base/to-uint32":"base.float64ToUint32","@stdlib/math/base/special/floor":"base.floor","@stdlib/math/base/special/floor2":"base.floor2","@stdlib/math/base/special/floor10":"base.floor10","@stdlib/math/base/special/floorb":"base.floorb","@stdlib/math/base/special/floorf":"base.floorf","@stdlib/math/base/special/floorn":"base.floorn","@stdlib/math/base/special/floorsd":"base.floorsd","@stdlib/string/base/for-each":"base.forEachChar","@stdlib/string/base/for-each-code-point":"base.forEachCodePoint","@stdlib/string/base/for-each-code-point-right":"base.forEachCodePointRight","@stdlib/string/base/for-each-grapheme-cluster":"base.forEachGraphemeCluster","@stdlib/string/base/for-each-right":"base.forEachRight","@stdlib/string/base/format-interpolate":"base.formatInterpolate","@stdlib/string/base/format-tokenize":"base.formatTokenize","@stdlib/math/base/special/fresnel":"base.fresnel","@stdlib/math/base/special/fresnelc":"base.fresnelc","@stdlib/math/base/special/fresnels":"base.fresnels","@stdlib/math/base/special/frexp":"base.frexp","@stdlib/number/float64/base/from-binary-string":"base.fromBinaryString","@stdlib/number/float32/base/from-binary-string":"base.fromBinaryStringf","@stdlib/number/uint8/base/from-binary-string":"base.fromBinaryStringUint8","@stdlib/number/uint16/base/from-binary-string":"base.fromBinaryStringUint16","@stdlib/number/uint32/base/from-binary-string":"base.fromBinaryStringUint32","@stdlib/number/float64/base/from-int64-bytes":"base.fromInt64Bytes","@stdlib/number/float32/base/from-word":"base.fromWordf","@stdlib/number/float64/base/from-words":"base.fromWords","@stdlib/math/base/special/gamma":"base.gamma","@stdlib/math/base/special/gamma1pm1":"base.gamma1pm1","@stdlib/math/base/special/gamma-delta-ratio":"base.gammaDeltaRatio","@stdlib/math/base/special/gammainc":"base.gammainc","@stdlib/math/base/special/gammaincinv":"base.gammaincinv","@stdlib/math/base/special/gamma-lanczos-sum":"base.gammaLanczosSum","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":"base.gammaLanczosSumExpGScaled","@stdlib/math/base/special/gammaln":"base.gammaln","@stdlib/math/base/special/gammasgn":"base.gammasgn","@stdlib/math/base/special/gcd":"base.gcd","@stdlib/number/float64/base/get-high-word":"base.getHighWord","@stdlib/number/float64/base/get-low-word":"base.getLowWord","@stdlib/math/base/special/hacovercos":"base.hacovercos","@stdlib/math/base/special/hacoversin":"base.hacoversin","@stdlib/math/base/special/havercos":"base.havercos","@stdlib/math/base/special/haversin":"base.haversin","@stdlib/string/base/headercase":"base.headercase","@stdlib/math/base/special/heaviside":"base.heaviside","@stdlib/math/base/tools/hermitepoly":"base.hermitepoly","@stdlib/math/base/special/hypot":"base.hypot","@stdlib/math/base/special/hypotf":"base.hypotf","@stdlib/math/base/special/identity":"base.identity","@stdlib/math/base/special/identityf":"base.identityf","@stdlib/math/base/ops/imul":"base.imul","@stdlib/math/base/ops/imuldw":"base.imuldw","@stdlib/slice/base/int2slice":"base.int2slice","@stdlib/number/int32/base/to-uint32":"base.int32ToUint32","@stdlib/math/base/special/inv":"base.inv","@stdlib/string/base/invcase":"base.invcase","@stdlib/math/base/special/invf":"base.invf","@stdlib/math/base/assert/is-composite":"base.isComposite","@stdlib/math/base/assert/is-coprime":"base.isCoprime","@stdlib/math/base/assert/is-even":"base.isEven","@stdlib/math/base/assert/int32-is-even":"base.isEvenInt32","@stdlib/math/base/assert/is-finite":"base.isFinite","@stdlib/math/base/assert/is-finitef":"base.isFinitef","@stdlib/math/base/assert/is-infinite":"base.isInfinite","@stdlib/math/base/assert/is-infinitef":"base.isInfinitef","@stdlib/math/base/assert/is-integer":"base.isInteger","@stdlib/math/base/assert/is-nan":"base.isnan","@stdlib/math/base/assert/is-nanf":"base.isnanf","@stdlib/math/base/assert/is-negative-finite":"base.isNegativeFinite","@stdlib/math/base/assert/is-negative-integer":"base.isNegativeInteger","@stdlib/math/base/assert/is-negative-zero":"base.isNegativeZero","@stdlib/math/base/assert/is-negative-zerof":"base.isNegativeZerof","@stdlib/math/base/assert/is-nonnegative-finite":"base.isNonNegativeFinite","@stdlib/math/base/assert/is-nonnegative-integer":"base.isNonNegativeInteger","@stdlib/math/base/assert/is-nonpositive-finite":"base.isNonPositiveFinite","@stdlib/math/base/assert/is-nonpositive-integer":"base.isNonPositiveInteger","@stdlib/math/base/assert/is-odd":"base.isOdd","@stdlib/math/base/assert/int32-is-odd":"base.isOddInt32","@stdlib/math/base/assert/is-positive-finite":"base.isPositiveFinite","@stdlib/math/base/assert/is-positive-integer":"base.isPositiveInteger","@stdlib/math/base/assert/is-positive-zero":"base.isPositiveZero","@stdlib/math/base/assert/is-positive-zerof":"base.isPositiveZerof","@stdlib/math/base/assert/uint32-is-pow2":"base.isPow2Uint32","@stdlib/math/base/assert/is-prime":"base.isPrime","@stdlib/math/base/assert/is-probability":"base.isProbability","@stdlib/math/base/assert/is-safe-integer":"base.isSafeInteger","@stdlib/string/base/kebabcase":"base.kebabcase","@stdlib/math/base/special/kernel-betainc":"base.kernelBetainc","@stdlib/math/base/special/kernel-betaincinv":"base.kernelBetaincinv","@stdlib/math/base/special/kernel-cos":"base.kernelCos","@stdlib/math/base/special/kernel-log1p":"base.kernelLog1p","@stdlib/math/base/special/kernel-sin":"base.kernelSin","@stdlib/math/base/special/kernel-tan":"base.kernelTan","@stdlib/math/base/special/kronecker-delta":"base.kroneckerDelta","@stdlib/math/base/special/kronecker-deltaf":"base.kroneckerDeltaf","@stdlib/math/base/special/labs":"base.labs","@stdlib/string/base/last":"base.last","@stdlib/string/base/last-code-point":"base.lastCodePoint","@stdlib/string/base/last-grapheme-cluster":"base.lastGraphemeCluster","@stdlib/math/base/special/lcm":"base.lcm","@stdlib/math/base/special/ldexp":"base.ldexp","@stdlib/string/base/left-pad":"base.leftPad","@stdlib/string/base/left-trim":"base.leftTrim","@stdlib/math/base/special/ln":"base.ln","@stdlib/math/base/special/log":"base.log","@stdlib/math/base/special/log1mexp":"base.log1mexp","@stdlib/math/base/special/log1p":"base.log1p","@stdlib/math/base/special/log1pexp":"base.log1pexp","@stdlib/math/base/special/log1pmx":"base.log1pmx","@stdlib/math/base/special/log2":"base.log2","@stdlib/math/base/special/log10":"base.log10","@stdlib/math/base/special/logaddexp":"base.logaddexp","@stdlib/math/base/special/logit":"base.logit","@stdlib/string/base/lowercase":"base.lowercase","@stdlib/math/base/special/lucas":"base.lucas","@stdlib/math/base/tools/lucaspoly":"base.lucaspoly","@stdlib/math/base/special/max":"base.max","@stdlib/math/base/special/maxabs":"base.maxabs","@stdlib/math/base/special/maxabsn":"base.maxabsn","@stdlib/math/base/special/maxn":"base.maxn","@stdlib/math/base/special/min":"base.min","@stdlib/math/base/special/minabs":"base.minabs","@stdlib/math/base/special/minabsn":"base.minabsn","@stdlib/math/base/special/minmax":"base.minmax","@stdlib/math/base/special/minmaxabs":"base.minmaxabs","@stdlib/math/base/special/minmaxabsn":"base.minmaxabsn","@stdlib/math/base/special/minmaxn":"base.minmaxn","@stdlib/math/base/special/minn":"base.minn","@stdlib/math/base/special/modf":"base.modf","@stdlib/number/float64/base/mul":"base.mul","@stdlib/number/float32/base/mul":"base.mulf","@stdlib/ndarray/base/ctor":"base.ndarray","@stdlib/ndarray/base/unary":"base.ndarrayUnary","@stdlib/ndarray/base/zeros":"base.ndzeros","@stdlib/ndarray/base/zeros-like":"base.ndzerosLike","@stdlib/math/base/special/negafibonacci":"base.negafibonacci","@stdlib/math/base/special/negalucas":"base.negalucas","@stdlib/math/base/special/nonfibonacci":"base.nonfibonacci","@stdlib/number/float64/base/normalize":"base.normalize","@stdlib/number/float32/base/normalize":"base.normalizef","@stdlib/slice/base/normalize-multi-slice":"base.normalizeMultiSlice","@stdlib/slice/base/normalize-slice":"base.normalizeSlice","@stdlib/math/base/tools/normhermitepoly":"base.normhermitepoly","@stdlib/string/base/pascalcase":"base.pascalcase","@stdlib/math/base/special/pdiff":"base.pdiff","@stdlib/math/base/special/pdifff":"base.pdifff","@stdlib/string/base/percent-encode":"base.percentEncode","@stdlib/math/base/special/polygamma":"base.polygamma","@stdlib/math/base/special/pow":"base.pow","@stdlib/math/base/special/powm1":"base.powm1","@stdlib/math/base/special/rad2deg":"base.rad2deg","@stdlib/math/base/special/rad2degf":"base.rad2degf","@stdlib/math/base/special/ramp":"base.ramp","@stdlib/math/base/special/rampf":"base.rampf","@stdlib/random/base/arcsine":"base.random.arcsine","@stdlib/random/base/bernoulli":"base.random.bernoulli","@stdlib/random/base/beta":"base.random.beta","@stdlib/random/base/betaprime":"base.random.betaprime","@stdlib/random/base/binomial":"base.random.binomial","@stdlib/random/base/box-muller":"base.random.boxMuller","@stdlib/random/base/cauchy":"base.random.cauchy","@stdlib/random/base/chi":"base.random.chi","@stdlib/random/base/chisquare":"base.random.chisquare","@stdlib/random/base/cosine":"base.random.cosine","@stdlib/random/base/discrete-uniform":"base.random.discreteUniform","@stdlib/random/base/erlang":"base.random.erlang","@stdlib/random/base/exponential":"base.random.exponential","@stdlib/random/base/f":"base.random.f","@stdlib/random/base/frechet":"base.random.frechet","@stdlib/random/base/gamma":"base.random.gamma","@stdlib/random/base/geometric":"base.random.geometric","@stdlib/random/base/gumbel":"base.random.gumbel","@stdlib/random/base/hypergeometric":"base.random.hypergeometric","@stdlib/random/base/improved-ziggurat":"base.random.improvedZiggurat","@stdlib/random/base/invgamma":"base.random.invgamma","@stdlib/random/base/kumaraswamy":"base.random.kumaraswamy","@stdlib/random/base/laplace":"base.random.laplace","@stdlib/random/base/levy":"base.random.levy","@stdlib/random/base/logistic":"base.random.logistic","@stdlib/random/base/lognormal":"base.random.lognormal","@stdlib/random/base/minstd":"base.random.minstd","@stdlib/random/base/minstd-shuffle":"base.random.minstdShuffle","@stdlib/random/base/mt19937":"base.random.mt19937","@stdlib/random/base/negative-binomial":"base.random.negativeBinomial","@stdlib/random/base/normal":"base.random.normal","@stdlib/random/base/pareto-type1":"base.random.pareto1","@stdlib/random/base/poisson":"base.random.poisson","@stdlib/random/base/randi":"base.random.randi","@stdlib/random/base/randn":"base.random.randn","@stdlib/random/base/randu":"base.random.randu","@stdlib/random/base/rayleigh":"base.random.rayleigh","@stdlib/random/base/t":"base.random.t","@stdlib/random/base/triangular":"base.random.triangular","@stdlib/random/base/uniform":"base.random.uniform","@stdlib/random/base/weibull":"base.random.weibull","@stdlib/math/base/special/rcbrt":"base.rcbrt","@stdlib/math/base/special/rcbrtf":"base.rcbrtf","@stdlib/math/base/utils/relative-difference":"base.reldiff","@stdlib/string/base/remove-first":"base.removeFirst","@stdlib/string/base/remove-first-code-point":"base.removeFirstCodePoint","@stdlib/string/base/remove-first-grapheme-cluster":"base.removeFirstGraphemeCluster","@stdlib/string/base/remove-last":"base.removeLast","@stdlib/string/base/remove-last-code-point":"base.removeLastCodePoint","@stdlib/string/base/remove-last-grapheme-cluster":"base.removeLastGraphemeCluster","@stdlib/math/base/special/rempio2":"base.rempio2","@stdlib/string/base/repeat":"base.repeat","@stdlib/string/base/replace":"base.replace","@stdlib/string/base/replace-after":"base.replaceAfter","@stdlib/string/base/replace-after-last":"base.replaceAfterLast","@stdlib/string/base/replace-before":"base.replaceBefore","@stdlib/string/base/replace-before-last":"base.replaceBeforeLast","@stdlib/string/base/reverse":"base.reverse","@stdlib/string/base/reverse-code-points":"base.reverseCodePoints","@stdlib/string/base/reverse-grapheme-clusters":"base.reverseGraphemeClusters","@stdlib/string/base/right-pad":"base.rightPad","@stdlib/string/base/right-trim":"base.rightTrim","@stdlib/math/base/special/rising-factorial":"base.risingFactorial","@stdlib/number/uint32/base/rotl":"base.rotl32","@stdlib/number/uint32/base/rotr":"base.rotr32","@stdlib/math/base/special/round":"base.round","@stdlib/math/base/special/round2":"base.round2","@stdlib/math/base/special/round10":"base.round10","@stdlib/math/base/special/roundb":"base.roundb","@stdlib/math/base/special/roundn":"base.roundn","@stdlib/math/base/special/roundsd":"base.roundsd","@stdlib/math/base/special/rsqrt":"base.rsqrt","@stdlib/math/base/special/rsqrtf":"base.rsqrtf","@stdlib/slice/base/sargs2multislice":"base.sargs2multislice","@stdlib/ndarray/base/from-scalar":"base.scalar2ndarray","@stdlib/math/base/special/secd":"base.secd","@stdlib/slice/base/seq2multislice":"base.seq2multislice","@stdlib/slice/base/seq2slice":"base.seq2slice","@stdlib/number/float64/base/set-high-word":"base.setHighWord","@stdlib/number/float64/base/set-low-word":"base.setLowWord","@stdlib/math/base/special/sici":"base.sici","@stdlib/number/float64/base/signbit":"base.signbit","@stdlib/number/float32/base/signbit":"base.signbitf","@stdlib/number/float32/base/significand":"base.significandf","@stdlib/math/base/special/signum":"base.signum","@stdlib/math/base/special/signumf":"base.signumf","@stdlib/math/base/special/sin":"base.sin","@stdlib/math/base/special/sinc":"base.sinc","@stdlib/math/base/special/sincos":"base.sincos","@stdlib/math/base/special/sincospi":"base.sincospi","@stdlib/math/base/special/sinh":"base.sinh","@stdlib/math/base/special/sinpi":"base.sinpi","@stdlib/slice/base/slice2seq":"base.slice2seq","@stdlib/slice/base/length":"base.sliceLength","@stdlib/slice/base/nonreduced-dimensions":"base.sliceNonReducedDimensions","@stdlib/slice/base/reduced-dimensions":"base.sliceReducedDimensions","@stdlib/slice/base/shape":"base.sliceShape","@stdlib/string/base/snakecase":"base.snakecase","@stdlib/math/base/special/spence":"base.spence","@stdlib/math/base/special/sqrt":"base.sqrt","@stdlib/math/base/special/sqrt1pm1":"base.sqrt1pm1","@stdlib/math/base/special/sqrtf":"base.sqrtf","@stdlib/math/base/special/sqrtpi":"base.sqrtpi","@stdlib/string/base/startcase":"base.startcase","@stdlib/string/base/starts-with":"base.startsWith","@stdlib/string/base/stickycase":"base.stickycase","@stdlib/strided/base/binary":"base.strided.binary","@stdlib/strided/base/binary-dtype-signatures":"base.strided.binaryDtypeSignatures","@stdlib/strided/base/binary-signature-callbacks":"base.strided.binarySignatureCallbacks","@stdlib/blas/base/ccopy":"base.strided.ccopy","@stdlib/strided/base/cmap":"base.strided.cmap","@stdlib/blas/base/cswap":"base.strided.cswap","@stdlib/stats/base/cumax":"base.strided.cumax","@stdlib/stats/base/cumaxabs":"base.strided.cumaxabs","@stdlib/stats/base/cumin":"base.strided.cumin","@stdlib/stats/base/cuminabs":"base.strided.cuminabs","@stdlib/math/strided/special/dabs":"base.strided.dabs","@stdlib/math/strided/special/dabs2":"base.strided.dabs2","@stdlib/blas/ext/base/dapx":"base.strided.dapx","@stdlib/blas/ext/base/dapxsum":"base.strided.dapxsum","@stdlib/blas/ext/base/dapxsumkbn":"base.strided.dapxsumkbn","@stdlib/blas/ext/base/dapxsumkbn2":"base.strided.dapxsumkbn2","@stdlib/blas/ext/base/dapxsumors":"base.strided.dapxsumors","@stdlib/blas/ext/base/dapxsumpw":"base.strided.dapxsumpw","@stdlib/blas/base/dasum":"base.strided.dasum","@stdlib/blas/ext/base/dasumpw":"base.strided.dasumpw","@stdlib/blas/base/daxpy":"base.strided.daxpy","@stdlib/math/strided/special/dcbrt":"base.strided.dcbrt","@stdlib/math/strided/special/dceil":"base.strided.dceil","@stdlib/blas/base/dcopy":"base.strided.dcopy","@stdlib/stats/strided/dcumax":"base.strided.dcumax","@stdlib/stats/strided/dcumaxabs":"base.strided.dcumaxabs","@stdlib/stats/base/dcumin":"base.strided.dcumin","@stdlib/stats/strided/dcuminabs":"base.strided.dcuminabs","@stdlib/blas/ext/base/dcusum":"base.strided.dcusum","@stdlib/blas/ext/base/dcusumkbn":"base.strided.dcusumkbn","@stdlib/blas/ext/base/dcusumkbn2":"base.strided.dcusumkbn2","@stdlib/blas/ext/base/dcusumors":"base.strided.dcusumors","@stdlib/blas/ext/base/dcusumpw":"base.strided.dcusumpw","@stdlib/math/strided/special/ddeg2rad":"base.strided.ddeg2rad","@stdlib/blas/base/ddot":"base.strided.ddot","@stdlib/blas/ext/base/dfill":"base.strided.dfill","@stdlib/math/strided/special/dfloor":"base.strided.dfloor","@stdlib/math/strided/special/dinv":"base.strided.dinv","@stdlib/strided/base/dmap":"base.strided.dmap","@stdlib/strided/base/dmap2":"base.strided.dmap2","@stdlib/stats/strided/dmax":"base.strided.dmax","@stdlib/stats/strided/dmaxabs":"base.strided.dmaxabs","@stdlib/stats/strided/dmaxabssorted":"base.strided.dmaxabssorted","@stdlib/stats/strided/dmaxsorted":"base.strided.dmaxsorted","@stdlib/stats/base/dmean":"base.strided.dmean","@stdlib/stats/strided/dmeankbn":"base.strided.dmeankbn","@stdlib/stats/strided/dmeankbn2":"base.strided.dmeankbn2","@stdlib/stats/strided/dmeanli":"base.strided.dmeanli","@stdlib/stats/strided/dmeanlipw":"base.strided.dmeanlipw","@stdlib/stats/strided/dmeanors":"base.strided.dmeanors","@stdlib/stats/base/dmeanpn":"base.strided.dmeanpn","@stdlib/stats/strided/dmeanpw":"base.strided.dmeanpw","@stdlib/stats/base/dmeanstdev":"base.strided.dmeanstdev","@stdlib/stats/base/dmeanstdevpn":"base.strided.dmeanstdevpn","@stdlib/stats/base/dmeanvar":"base.strided.dmeanvar","@stdlib/stats/base/dmeanvarpn":"base.strided.dmeanvarpn","@stdlib/stats/strided/dmeanwd":"base.strided.dmeanwd","@stdlib/stats/strided/dmediansorted":"base.strided.dmediansorted","@stdlib/stats/strided/dmidrange":"base.strided.dmidrange","@stdlib/stats/strided/dmin":"base.strided.dmin","@stdlib/stats/strided/dminabs":"base.strided.dminabs","@stdlib/stats/strided/dminsorted":"base.strided.dminsorted","@stdlib/math/strided/special/dmskabs":"base.strided.dmskabs","@stdlib/math/strided/special/dmskabs2":"base.strided.dmskabs2","@stdlib/math/strided/special/dmskcbrt":"base.strided.dmskcbrt","@stdlib/math/strided/special/dmskceil":"base.strided.dmskceil","@stdlib/math/strided/special/dmskdeg2rad":"base.strided.dmskdeg2rad","@stdlib/math/strided/special/dmskfloor":"base.strided.dmskfloor","@stdlib/math/strided/special/dmskinv":"base.strided.dmskinv","@stdlib/strided/base/dmskmap":"base.strided.dmskmap","@stdlib/strided/base/dmskmap2":"base.strided.dmskmap2","@stdlib/stats/base/dmskmax":"base.strided.dmskmax","@stdlib/stats/base/dmskmin":"base.strided.dmskmin","@stdlib/math/strided/special/dmskramp":"base.strided.dmskramp","@stdlib/stats/base/dmskrange":"base.strided.dmskrange","@stdlib/math/strided/special/dmskrsqrt":"base.strided.dmskrsqrt","@stdlib/math/strided/special/dmsksqrt":"base.strided.dmsksqrt","@stdlib/math/strided/special/dmsktrunc":"base.strided.dmsktrunc","@stdlib/blas/ext/base/dnanasum":"base.strided.dnanasum","@stdlib/blas/ext/base/dnanasumors":"base.strided.dnanasumors","@stdlib/stats/strided/dnanmax":"base.strided.dnanmax","@stdlib/stats/strided/dnanmaxabs":"base.strided.dnanmaxabs","@stdlib/stats/strided/dnanmean":"base.strided.dnanmean","@stdlib/stats/base/dnanmeanors":"base.strided.dnanmeanors","@stdlib/stats/base/dnanmeanpn":"base.strided.dnanmeanpn","@stdlib/stats/base/dnanmeanpw":"base.strided.dnanmeanpw","@stdlib/stats/base/dnanmeanwd":"base.strided.dnanmeanwd","@stdlib/stats/base/dnanmin":"base.strided.dnanmin","@stdlib/stats/base/dnanminabs":"base.strided.dnanminabs","@stdlib/stats/base/dnanmskmax":"base.strided.dnanmskmax","@stdlib/stats/base/dnanmskmin":"base.strided.dnanmskmin","@stdlib/stats/base/dnanmskrange":"base.strided.dnanmskrange","@stdlib/blas/ext/base/dnannsum":"base.strided.dnannsum","@stdlib/blas/ext/base/dnannsumkbn":"base.strided.dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2":"base.strided.dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors":"base.strided.dnannsumors","@stdlib/blas/ext/base/dnannsumpw":"base.strided.dnannsumpw","@stdlib/stats/base/dnanrange":"base.strided.dnanrange","@stdlib/stats/base/dnanstdev":"base.strided.dnanstdev","@stdlib/stats/base/dnanstdevch":"base.strided.dnanstdevch","@stdlib/stats/base/dnanstdevpn":"base.strided.dnanstdevpn","@stdlib/stats/base/dnanstdevtk":"base.strided.dnanstdevtk","@stdlib/stats/base/dnanstdevwd":"base.strided.dnanstdevwd","@stdlib/stats/base/dnanstdevyc":"base.strided.dnanstdevyc","@stdlib/blas/ext/base/dnansum":"base.strided.dnansum","@stdlib/blas/ext/base/dnansumkbn":"base.strided.dnansumkbn","@stdlib/blas/ext/base/dnansumkbn2":"base.strided.dnansumkbn2","@stdlib/blas/ext/base/dnansumors":"base.strided.dnansumors","@stdlib/blas/ext/base/dnansumpw":"base.strided.dnansumpw","@stdlib/stats/base/dnanvariance":"base.strided.dnanvariance","@stdlib/stats/base/dnanvariancech":"base.strided.dnanvariancech","@stdlib/stats/base/dnanvariancepn":"base.strided.dnanvariancepn","@stdlib/stats/base/dnanvariancetk":"base.strided.dnanvariancetk","@stdlib/stats/base/dnanvariancewd":"base.strided.dnanvariancewd","@stdlib/stats/base/dnanvarianceyc":"base.strided.dnanvarianceyc","@stdlib/blas/base/dnrm2":"base.strided.dnrm2","@stdlib/math/strided/special/dramp":"base.strided.dramp","@stdlib/stats/base/drange":"base.strided.drange","@stdlib/blas/ext/base/drev":"base.strided.drev","@stdlib/math/strided/special/drsqrt":"base.strided.drsqrt","@stdlib/blas/ext/base/dsapxsum":"base.strided.dsapxsum","@stdlib/blas/ext/base/dsapxsumpw":"base.strided.dsapxsumpw","@stdlib/blas/base/dscal":"base.strided.dscal","@stdlib/blas/base/dsdot":"base.strided.dsdot","@stdlib/stats/base/dsem":"base.strided.dsem","@stdlib/stats/base/dsemch":"base.strided.dsemch","@stdlib/stats/base/dsempn":"base.strided.dsempn","@stdlib/stats/base/dsemtk":"base.strided.dsemtk","@stdlib/stats/base/dsemwd":"base.strided.dsemwd","@stdlib/stats/base/dsemyc":"base.strided.dsemyc","@stdlib/stats/base/dsmean":"base.strided.dsmean","@stdlib/stats/base/dsmeanors":"base.strided.dsmeanors","@stdlib/stats/base/dsmeanpn":"base.strided.dsmeanpn","@stdlib/stats/base/dsmeanpw":"base.strided.dsmeanpw","@stdlib/stats/base/dsmeanwd":"base.strided.dsmeanwd","@stdlib/stats/base/dsnanmean":"base.strided.dsnanmean","@stdlib/stats/base/dsnanmeanors":"base.strided.dsnanmeanors","@stdlib/stats/base/dsnanmeanpn":"base.strided.dsnanmeanpn","@stdlib/stats/base/dsnanmeanwd":"base.strided.dsnanmeanwd","@stdlib/blas/ext/base/dsnannsumors":"base.strided.dsnannsumors","@stdlib/blas/ext/base/dsnansum":"base.strided.dsnansum","@stdlib/blas/ext/base/dsnansumors":"base.strided.dsnansumors","@stdlib/blas/ext/base/dsnansumpw":"base.strided.dsnansumpw","@stdlib/blas/ext/base/dsort2hp":"base.strided.dsort2hp","@stdlib/blas/ext/base/dsort2ins":"base.strided.dsort2ins","@stdlib/blas/ext/base/dsort2sh":"base.strided.dsort2sh","@stdlib/blas/ext/base/dsorthp":"base.strided.dsorthp","@stdlib/blas/ext/base/dsortins":"base.strided.dsortins","@stdlib/blas/ext/base/dsortsh":"base.strided.dsortsh","@stdlib/math/strided/special/dsqrt":"base.strided.dsqrt","@stdlib/blas/ext/base/dssum":"base.strided.dssum","@stdlib/blas/ext/base/dssumors":"base.strided.dssumors","@stdlib/blas/ext/base/dssumpw":"base.strided.dssumpw","@stdlib/stats/base/dstdev":"base.strided.dstdev","@stdlib/stats/base/dstdevch":"base.strided.dstdevch","@stdlib/stats/base/dstdevpn":"base.strided.dstdevpn","@stdlib/stats/base/dstdevtk":"base.strided.dstdevtk","@stdlib/stats/base/dstdevwd":"base.strided.dstdevwd","@stdlib/stats/base/dstdevyc":"base.strided.dstdevyc","@stdlib/blas/ext/base/dsum":"base.strided.dsum","@stdlib/blas/ext/base/dsumkbn":"base.strided.dsumkbn","@stdlib/blas/ext/base/dsumkbn2":"base.strided.dsumkbn2","@stdlib/blas/ext/base/dsumors":"base.strided.dsumors","@stdlib/blas/ext/base/dsumpw":"base.strided.dsumpw","@stdlib/stats/base/dsvariance":"base.strided.dsvariance","@stdlib/stats/base/dsvariancepn":"base.strided.dsvariancepn","@stdlib/blas/base/dswap":"base.strided.dswap","@stdlib/math/strided/special/dtrunc":"base.strided.dtrunc","@stdlib/strided/base/dtype-enum2str":"base.strided.dtypeEnum2Str","@stdlib/strided/base/dtype-resolve-enum":"base.strided.dtypeResolveEnum","@stdlib/strided/base/dtype-resolve-str":"base.strided.dtypeResolveStr","@stdlib/strided/base/dtype-str2enum":"base.strided.dtypeStr2Enum","@stdlib/stats/base/dvariance":"base.strided.dvariance","@stdlib/stats/base/dvariancech":"base.strided.dvariancech","@stdlib/stats/base/dvariancepn":"base.strided.dvariancepn","@stdlib/stats/base/dvariancetk":"base.strided.dvariancetk","@stdlib/stats/base/dvariancewd":"base.strided.dvariancewd","@stdlib/stats/base/dvarianceyc":"base.strided.dvarianceyc","@stdlib/stats/base/dvarm":"base.strided.dvarm","@stdlib/stats/base/dvarmpn":"base.strided.dvarmpn","@stdlib/stats/base/dvarmtk":"base.strided.dvarmtk","@stdlib/strided/base/function-object":"base.strided.functionObject","@stdlib/blas/ext/base/gapx":"base.strided.gapx","@stdlib/blas/ext/base/gapxsum":"base.strided.gapxsum","@stdlib/blas/ext/base/gapxsumkbn":"base.strided.gapxsumkbn","@stdlib/blas/ext/base/gapxsumkbn2":"base.strided.gapxsumkbn2","@stdlib/blas/ext/base/gapxsumors":"base.strided.gapxsumors","@stdlib/blas/ext/base/gapxsumpw":"base.strided.gapxsumpw","@stdlib/blas/base/gasum":"base.strided.gasum","@stdlib/blas/ext/base/gasumpw":"base.strided.gasumpw","@stdlib/blas/base/gaxpy":"base.strided.gaxpy","@stdlib/blas/base/gcopy":"base.strided.gcopy","@stdlib/blas/ext/base/gcusum":"base.strided.gcusum","@stdlib/blas/ext/base/gcusumkbn":"base.strided.gcusumkbn","@stdlib/blas/ext/base/gcusumkbn2":"base.strided.gcusumkbn2","@stdlib/blas/ext/base/gcusumors":"base.strided.gcusumors","@stdlib/blas/ext/base/gcusumpw":"base.strided.gcusumpw","@stdlib/blas/base/gdot":"base.strided.gdot","@stdlib/blas/ext/base/gfill":"base.strided.gfill","@stdlib/blas/ext/base/gfill-by":"base.strided.gfillBy","@stdlib/blas/ext/base/gnannsumkbn":"base.strided.gnannsumkbn","@stdlib/blas/ext/base/gnansum":"base.strided.gnansum","@stdlib/blas/ext/base/gnansumkbn":"base.strided.gnansumkbn","@stdlib/blas/ext/base/gnansumkbn2":"base.strided.gnansumkbn2","@stdlib/blas/ext/base/gnansumors":"base.strided.gnansumors","@stdlib/blas/ext/base/gnansumpw":"base.strided.gnansumpw","@stdlib/blas/base/gnrm2":"base.strided.gnrm2","@stdlib/blas/ext/base/grev":"base.strided.grev","@stdlib/blas/base/gscal":"base.strided.gscal","@stdlib/blas/ext/base/gsort2hp":"base.strided.gsort2hp","@stdlib/blas/ext/base/gsort2ins":"base.strided.gsort2ins","@stdlib/blas/ext/base/gsort2sh":"base.strided.gsort2sh","@stdlib/blas/ext/base/gsorthp":"base.strided.gsorthp","@stdlib/blas/ext/base/gsortins":"base.strided.gsortins","@stdlib/blas/ext/base/gsortsh":"base.strided.gsortsh","@stdlib/blas/ext/base/gsum":"base.strided.gsum","@stdlib/blas/ext/base/gsumkbn":"base.strided.gsumkbn","@stdlib/blas/ext/base/gsumkbn2":"base.strided.gsumkbn2","@stdlib/blas/ext/base/gsumors":"base.strided.gsumors","@stdlib/blas/ext/base/gsumpw":"base.strided.gsumpw","@stdlib/blas/base/gswap":"base.strided.gswap","@stdlib/strided/base/map-by":"base.strided.mapBy","@stdlib/strided/base/map-by2":"base.strided.mapBy2","@stdlib/stats/base/max":"base.strided.max","@stdlib/stats/base/maxabs":"base.strided.maxabs","@stdlib/stats/base/max-by":"base.strided.maxBy","@stdlib/stats/base/maxsorted":"base.strided.maxsorted","@stdlib/strided/base/max-view-buffer-index":"base.strided.maxViewBufferIndex","@stdlib/stats/base/mean":"base.strided.mean","@stdlib/stats/base/meankbn":"base.strided.meankbn","@stdlib/stats/base/meankbn2":"base.strided.meankbn2","@stdlib/stats/base/meanors":"base.strided.meanors","@stdlib/stats/base/meanpn":"base.strided.meanpn","@stdlib/stats/base/meanpw":"base.strided.meanpw","@stdlib/stats/base/meanwd":"base.strided.meanwd","@stdlib/stats/base/mediansorted":"base.strided.mediansorted","@stdlib/strided/base/meta-data-props":"base.strided.metaDataProps","@stdlib/stats/base/min":"base.strided.min","@stdlib/stats/base/minabs":"base.strided.minabs","@stdlib/stats/base/min-by":"base.strided.minBy","@stdlib/stats/base/minsorted":"base.strided.minsorted","@stdlib/strided/base/min-view-buffer-index":"base.strided.minViewBufferIndex","@stdlib/stats/base/mskmax":"base.strided.mskmax","@stdlib/stats/base/mskmin":"base.strided.mskmin","@stdlib/stats/base/mskrange":"base.strided.mskrange","@stdlib/strided/base/mskunary":"base.strided.mskunary","@stdlib/strided/base/mskunary-dtype-signatures":"base.strided.mskunaryDtypeSignatures","@stdlib/strided/base/mskunary-signature-callbacks":"base.strided.mskunarySignatureCallbacks","@stdlib/stats/base/nanmax":"base.strided.nanmax","@stdlib/stats/base/nanmaxabs":"base.strided.nanmaxabs","@stdlib/stats/base/nanmax-by":"base.strided.nanmaxBy","@stdlib/stats/base/nanmean":"base.strided.nanmean","@stdlib/stats/base/nanmeanors":"base.strided.nanmeanors","@stdlib/stats/base/nanmeanpn":"base.strided.nanmeanpn","@stdlib/stats/base/nanmeanwd":"base.strided.nanmeanwd","@stdlib/stats/base/nanmin":"base.strided.nanmin","@stdlib/stats/base/nanminabs":"base.strided.nanminabs","@stdlib/stats/base/nanmin-by":"base.strided.nanminBy","@stdlib/stats/base/nanmskmax":"base.strided.nanmskmax","@stdlib/stats/base/nanmskmin":"base.strided.nanmskmin","@stdlib/stats/base/nanmskrange":"base.strided.nanmskrange","@stdlib/stats/base/nanrange":"base.strided.nanrange","@stdlib/stats/base/nanrange-by":"base.strided.nanrangeBy","@stdlib/stats/base/nanstdev":"base.strided.nanstdev","@stdlib/stats/base/nanstdevch":"base.strided.nanstdevch","@stdlib/stats/base/nanstdevpn":"base.strided.nanstdevpn","@stdlib/stats/base/nanstdevtk":"base.strided.nanstdevtk","@stdlib/stats/base/nanstdevwd":"base.strided.nanstdevwd","@stdlib/stats/base/nanstdevyc":"base.strided.nanstdevyc","@stdlib/stats/base/nanvariance":"base.strided.nanvariance","@stdlib/stats/base/nanvariancech":"base.strided.nanvariancech","@stdlib/stats/base/nanvariancepn":"base.strided.nanvariancepn","@stdlib/stats/base/nanvariancetk":"base.strided.nanvariancetk","@stdlib/stats/base/nanvariancewd":"base.strided.nanvariancewd","@stdlib/stats/base/nanvarianceyc":"base.strided.nanvarianceyc","@stdlib/strided/base/nullary":"base.strided.nullary","@stdlib/strided/base/offset-view":"base.strided.offsetView","@stdlib/strided/base/quaternary":"base.strided.quaternary","@stdlib/strided/base/quinary":"base.strided.quinary","@stdlib/stats/base/range":"base.strided.range","@stdlib/stats/base/range-by":"base.strided.rangeBy","@stdlib/strided/base/reinterpret-complex":"base.strided.reinterpretComplex","@stdlib/strided/base/reinterpret-complex64":"base.strided.reinterpretComplex64","@stdlib/strided/base/reinterpret-complex128":"base.strided.reinterpretComplex128","@stdlib/math/strided/special/sabs":"base.strided.sabs","@stdlib/math/strided/special/sabs2":"base.strided.sabs2","@stdlib/blas/ext/base/sapx":"base.strided.sapx","@stdlib/blas/ext/base/sapxsum":"base.strided.sapxsum","@stdlib/blas/ext/base/sapxsumkbn":"base.strided.sapxsumkbn","@stdlib/blas/ext/base/sapxsumkbn2":"base.strided.sapxsumkbn2","@stdlib/blas/ext/base/sapxsumors":"base.strided.sapxsumors","@stdlib/blas/ext/base/sapxsumpw":"base.strided.sapxsumpw","@stdlib/blas/base/sasum":"base.strided.sasum","@stdlib/blas/ext/base/sasumpw":"base.strided.sasumpw","@stdlib/blas/base/saxpy":"base.strided.saxpy","@stdlib/math/strided/special/scbrt":"base.strided.scbrt","@stdlib/math/strided/special/sceil":"base.strided.sceil","@stdlib/blas/base/scopy":"base.strided.scopy","@stdlib/stats/base/scumax":"base.strided.scumax","@stdlib/stats/base/scumaxabs":"base.strided.scumaxabs","@stdlib/stats/base/scumin":"base.strided.scumin","@stdlib/stats/base/scuminabs":"base.strided.scuminabs","@stdlib/blas/ext/base/scusum":"base.strided.scusum","@stdlib/blas/ext/base/scusumkbn":"base.strided.scusumkbn","@stdlib/blas/ext/base/scusumkbn2":"base.strided.scusumkbn2","@stdlib/blas/ext/base/scusumors":"base.strided.scusumors","@stdlib/blas/ext/base/scusumpw":"base.strided.scusumpw","@stdlib/math/strided/special/sdeg2rad":"base.strided.sdeg2rad","@stdlib/blas/base/sdot":"base.strided.sdot","@stdlib/blas/ext/base/sdsapxsum":"base.strided.sdsapxsum","@stdlib/blas/ext/base/sdsapxsumpw":"base.strided.sdsapxsumpw","@stdlib/blas/base/sdsdot":"base.strided.sdsdot","@stdlib/stats/base/sdsmean":"base.strided.sdsmean","@stdlib/stats/base/sdsmeanors":"base.strided.sdsmeanors","@stdlib/stats/base/sdsnanmean":"base.strided.sdsnanmean","@stdlib/stats/base/sdsnanmeanors":"base.strided.sdsnanmeanors","@stdlib/blas/ext/base/sdsnansum":"base.strided.sdsnansum","@stdlib/blas/ext/base/sdsnansumpw":"base.strided.sdsnansumpw","@stdlib/blas/ext/base/sdssum":"base.strided.sdssum","@stdlib/blas/ext/base/sdssumpw":"base.strided.sdssumpw","@stdlib/blas/ext/base/sfill":"base.strided.sfill","@stdlib/math/strided/special/sfloor":"base.strided.sfloor","@stdlib/math/strided/special/sinv":"base.strided.sinv","@stdlib/strided/base/smap":"base.strided.smap","@stdlib/strided/base/smap2":"base.strided.smap2","@stdlib/stats/base/smax":"base.strided.smax","@stdlib/stats/base/smaxabs":"base.strided.smaxabs","@stdlib/stats/base/smaxabssorted":"base.strided.smaxabssorted","@stdlib/stats/base/smaxsorted":"base.strided.smaxsorted","@stdlib/stats/base/smean":"base.strided.smean","@stdlib/stats/base/smeankbn":"base.strided.smeankbn","@stdlib/stats/base/smeankbn2":"base.strided.smeankbn2","@stdlib/stats/base/smeanli":"base.strided.smeanli","@stdlib/stats/base/smeanlipw":"base.strided.smeanlipw","@stdlib/stats/base/smeanors":"base.strided.smeanors","@stdlib/stats/base/smeanpn":"base.strided.smeanpn","@stdlib/stats/base/smeanpw":"base.strided.smeanpw","@stdlib/stats/base/smeanwd":"base.strided.smeanwd","@stdlib/stats/base/smediansorted":"base.strided.smediansorted","@stdlib/stats/base/smidrange":"base.strided.smidrange","@stdlib/stats/base/smin":"base.strided.smin","@stdlib/stats/base/sminabs":"base.strided.sminabs","@stdlib/stats/base/sminsorted":"base.strided.sminsorted","@stdlib/math/strided/special/smskabs":"base.strided.smskabs","@stdlib/math/strided/special/smskabs2":"base.strided.smskabs2","@stdlib/math/strided/special/smskcbrt":"base.strided.smskcbrt","@stdlib/math/strided/special/smskceil":"base.strided.smskceil","@stdlib/math/strided/special/smskdeg2rad":"base.strided.smskdeg2rad","@stdlib/math/strided/special/smskfloor":"base.strided.smskfloor","@stdlib/math/strided/special/smskinv":"base.strided.smskinv","@stdlib/strided/base/smskmap":"base.strided.smskmap","@stdlib/strided/base/smskmap2":"base.strided.smskmap2","@stdlib/stats/base/smskmax":"base.strided.smskmax","@stdlib/stats/base/smskmin":"base.strided.smskmin","@stdlib/math/strided/special/smskramp":"base.strided.smskramp","@stdlib/stats/base/smskrange":"base.strided.smskrange","@stdlib/math/strided/special/smskrsqrt":"base.strided.smskrsqrt","@stdlib/math/strided/special/smsksqrt":"base.strided.smsksqrt","@stdlib/math/strided/special/smsktrunc":"base.strided.smsktrunc","@stdlib/stats/base/snanmax":"base.strided.snanmax","@stdlib/stats/base/snanmaxabs":"base.strided.snanmaxabs","@stdlib/stats/base/snanmean":"base.strided.snanmean","@stdlib/stats/base/snanmeanors":"base.strided.snanmeanors","@stdlib/stats/base/snanmeanpn":"base.strided.snanmeanpn","@stdlib/stats/base/snanmeanwd":"base.strided.snanmeanwd","@stdlib/stats/base/snanmin":"base.strided.snanmin","@stdlib/stats/base/snanminabs":"base.strided.snanminabs","@stdlib/stats/base/snanmskmax":"base.strided.snanmskmax","@stdlib/stats/base/snanmskmin":"base.strided.snanmskmin","@stdlib/stats/base/snanmskrange":"base.strided.snanmskrange","@stdlib/stats/base/snanrange":"base.strided.snanrange","@stdlib/stats/base/snanstdev":"base.strided.snanstdev","@stdlib/stats/base/snanstdevch":"base.strided.snanstdevch","@stdlib/stats/base/snanstdevpn":"base.strided.snanstdevpn","@stdlib/stats/base/snanstdevtk":"base.strided.snanstdevtk","@stdlib/stats/base/snanstdevwd":"base.strided.snanstdevwd","@stdlib/stats/base/snanstdevyc":"base.strided.snanstdevyc","@stdlib/blas/ext/base/snansum":"base.strided.snansum","@stdlib/blas/ext/base/snansumkbn":"base.strided.snansumkbn","@stdlib/blas/ext/base/snansumkbn2":"base.strided.snansumkbn2","@stdlib/blas/ext/base/snansumors":"base.strided.snansumors","@stdlib/blas/ext/base/snansumpw":"base.strided.snansumpw","@stdlib/stats/base/snanvariance":"base.strided.snanvariance","@stdlib/stats/base/snanvariancech":"base.strided.snanvariancech","@stdlib/stats/base/snanvariancepn":"base.strided.snanvariancepn","@stdlib/stats/base/snanvariancetk":"base.strided.snanvariancetk","@stdlib/stats/base/snanvariancewd":"base.strided.snanvariancewd","@stdlib/stats/base/snanvarianceyc":"base.strided.snanvarianceyc","@stdlib/blas/base/snrm2":"base.strided.snrm2","@stdlib/math/strided/special/sramp":"base.strided.sramp","@stdlib/stats/base/srange":"base.strided.srange","@stdlib/blas/ext/base/srev":"base.strided.srev","@stdlib/math/strided/special/srsqrt":"base.strided.srsqrt","@stdlib/blas/base/sscal":"base.strided.sscal","@stdlib/blas/ext/base/ssort2hp":"base.strided.ssort2hp","@stdlib/blas/ext/base/ssort2ins":"base.strided.ssort2ins","@stdlib/blas/ext/base/ssort2sh":"base.strided.ssort2sh","@stdlib/blas/ext/base/ssorthp":"base.strided.ssorthp","@stdlib/blas/ext/base/ssortins":"base.strided.ssortins","@stdlib/blas/ext/base/ssortsh":"base.strided.ssortsh","@stdlib/math/strided/special/ssqrt":"base.strided.ssqrt","@stdlib/stats/base/sstdev":"base.strided.sstdev","@stdlib/stats/base/sstdevch":"base.strided.sstdevch","@stdlib/stats/base/sstdevpn":"base.strided.sstdevpn","@stdlib/stats/base/sstdevtk":"base.strided.sstdevtk","@stdlib/stats/base/sstdevwd":"base.strided.sstdevwd","@stdlib/stats/base/sstdevyc":"base.strided.sstdevyc","@stdlib/blas/ext/base/ssum":"base.strided.ssum","@stdlib/blas/ext/base/ssumkbn":"base.strided.ssumkbn","@stdlib/blas/ext/base/ssumkbn2":"base.strided.ssumkbn2","@stdlib/blas/ext/base/ssumors":"base.strided.ssumors","@stdlib/blas/ext/base/ssumpw":"base.strided.ssumpw","@stdlib/blas/base/sswap":"base.strided.sswap","@stdlib/stats/base/stdev":"base.strided.stdev","@stdlib/stats/base/stdevch":"base.strided.stdevch","@stdlib/stats/base/stdevpn":"base.strided.stdevpn","@stdlib/stats/base/stdevtk":"base.strided.stdevtk","@stdlib/stats/base/stdevwd":"base.strided.stdevwd","@stdlib/stats/base/stdevyc":"base.strided.stdevyc","@stdlib/math/strided/special/strunc":"base.strided.strunc","@stdlib/stats/base/svariance":"base.strided.svariance","@stdlib/stats/base/svariancech":"base.strided.svariancech","@stdlib/stats/base/svariancepn":"base.strided.svariancepn","@stdlib/stats/base/svariancetk":"base.strided.svariancetk","@stdlib/stats/base/svariancewd":"base.strided.svariancewd","@stdlib/stats/base/svarianceyc":"base.strided.svarianceyc","@stdlib/strided/base/ternary":"base.strided.ternary","@stdlib/strided/base/unary":"base.strided.unary","@stdlib/strided/base/unary-by":"base.strided.unaryBy","@stdlib/strided/base/unary-dtype-signatures":"base.strided.unaryDtypeSignatures","@stdlib/strided/base/unary-signature-callbacks":"base.strided.unarySignatureCallbacks","@stdlib/stats/base/variance":"base.strided.variance","@stdlib/stats/base/variancech":"base.strided.variancech","@stdlib/stats/base/variancepn":"base.strided.variancepn","@stdlib/stats/base/variancetk":"base.strided.variancetk","@stdlib/stats/base/variancewd":"base.strided.variancewd","@stdlib/stats/base/varianceyc":"base.strided.varianceyc","@stdlib/strided/base/zmap":"base.strided.zmap","@stdlib/slice/base/str2multislice":"base.str2multislice","@stdlib/slice/base/str2slice":"base.str2slice","@stdlib/number/float64/base/sub":"base.sub","@stdlib/math/base/ops/subf":"base.subf","@stdlib/math/base/tools/sum-series":"base.sumSeries","@stdlib/math/base/special/tan":"base.tan","@stdlib/math/base/special/tand":"base.tand","@stdlib/math/base/special/tanh":"base.tanh","@stdlib/number/float64/base/to-binary-string":"base.toBinaryString","@stdlib/number/float32/base/to-binary-string":"base.toBinaryStringf","@stdlib/number/uint8/base/to-binary-string":"base.toBinaryStringUint8","@stdlib/number/uint16/base/to-binary-string":"base.toBinaryStringUint16","@stdlib/number/uint32/base/to-binary-string":"base.toBinaryStringUint32","@stdlib/number/float32/base/to-word":"base.toWordf","@stdlib/number/float64/base/to-words":"base.toWords","@stdlib/ndarray/base/transpose":"base.transpose","@stdlib/math/base/special/tribonacci":"base.tribonacci","@stdlib/math/base/special/trigamma":"base.trigamma","@stdlib/string/base/trim":"base.trim","@stdlib/math/base/special/trunc":"base.trunc","@stdlib/math/base/special/trunc2":"base.trunc2","@stdlib/math/base/special/trunc10":"base.trunc10","@stdlib/string/base/truncate-middle":"base.truncateMiddle","@stdlib/math/base/special/truncb":"base.truncb","@stdlib/math/base/special/truncf":"base.truncf","@stdlib/math/base/special/truncn":"base.truncn","@stdlib/math/base/special/truncsd":"base.truncsd","@stdlib/number/uint32/base/to-int32":"base.uint32ToInt32","@stdlib/number/uint32/base/mul":"base.umul","@stdlib/math/base/ops/umuldw":"base.umuldw","@stdlib/string/base/uncapitalize":"base.uncapitalize","@stdlib/string/base/uppercase":"base.uppercase","@stdlib/math/base/special/vercos":"base.vercos","@stdlib/math/base/special/versin":"base.versin","@stdlib/math/base/special/wrap":"base.wrap","@stdlib/math/base/special/xlog1py":"base.xlog1py","@stdlib/math/base/special/xlogy":"base.xlogy","@stdlib/math/base/special/riemann-zeta":"base.zeta","@stdlib/bench":"bench","@stdlib/datasets/berndt-cps-wages-1985":"BERNDT_CPS_WAGES_1985","@stdlib/utils/bifurcate":"bifurcate","@stdlib/utils/bifurcate-by":"bifurcateBy","@stdlib/utils/async/bifurcate-by":"bifurcateByAsync","@stdlib/utils/bifurcate-in":"bifurcateIn","@stdlib/utils/bifurcate-own":"bifurcateOwn","@stdlib/bigint/ctor":"BigInt","@stdlib/stats/binomial-test":"binomialTest","@stdlib/boolean/ctor":"Boolean","@stdlib/array/bool":"BooleanArray","@stdlib/ndarray/broadcast-array":"broadcastArray","@stdlib/ndarray/broadcast-arrays":"broadcastArrays","@stdlib/buffer/ctor":"Buffer","@stdlib/buffer/to-json":"buffer2json","@stdlib/os/byte-order":"BYTE_ORDER","@stdlib/string/camelcase":"camelcase","@stdlib/string/capitalize":"capitalize","@stdlib/utils/capitalize-keys":"capitalizeKeys","@stdlib/constants/float64/catalan":"CATALAN","@stdlib/constants/float64/cbrt-eps":"CBRT_EPS","@stdlib/datasets/cdc-nchs-us-births-1969-1988":"CDC_NCHS_US_BIRTHS_1969_1988","@stdlib/datasets/cdc-nchs-us-births-1994-2003":"CDC_NCHS_US_BIRTHS_1994_2003","@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013":"CDC_NCHS_US_INFANT_MORTALITY_BW_1915_2013","@stdlib/process/chdir":"chdir","@stdlib/stats/chi2gof":"chi2gof","@stdlib/stats/chi2test":"chi2test","@stdlib/array/to-circular-iterator":"circarray2iterator","@stdlib/streams/node/from-circular-array":"circularArrayStream","@stdlib/dstructs/circular-buffer":"CircularBuffer","@stdlib/fs/close":"close","@stdlib/datasets/cmudict":"CMUDICT","@stdlib/string/code-point-at":"codePointAt","@stdlib/utils/common-keys":"commonKeys","@stdlib/utils/common-keys-in":"commonKeysIn","@stdlib/complex/cmplx":"complex","@stdlib/complex/float32/ctor":"Complex64","@stdlib/constants/complex64/nan":"COMPLEX64_NAN","@stdlib/constants/complex64/num-bytes":"COMPLEX64_NUM_BYTES","@stdlib/constants/complex64/zero":"COMPLEX64_ZERO","@stdlib/array/complex64":"Complex64Array","@stdlib/complex/float64/ctor":"Complex128","@stdlib/constants/complex128/nan":"COMPLEX128_NAN","@stdlib/constants/complex128/num-bytes":"COMPLEX128_NUM_BYTES","@stdlib/constants/complex128/zero":"COMPLEX128_ZERO","@stdlib/array/complex128":"Complex128Array","@stdlib/array/typed-complex":"complexarray","@stdlib/array/typed-complex-ctors":"complexarrayCtors","@stdlib/array/typed-complex-dtypes":"complexarrayDataTypes","@stdlib/complex/ctors":"complexCtors","@stdlib/complex/dtype":"complexDataType","@stdlib/complex/dtypes":"complexDataTypes","@stdlib/complex/promotion-rules":"complexPromotionRules","@stdlib/utils/compose":"compose","@stdlib/utils/async/compose":"composeAsync","@stdlib/os/configdir":"configdir","@stdlib/complex/float64/conj":"conj","@stdlib/complex/float32/conj":"conjf","@stdlib/string/constantcase":"constantcase","@stdlib/utils/constant-function":"constantFunction","@stdlib/streams/node/from-constant":"constantStream","@stdlib/utils/constructor-name":"constructorName","@stdlib/assert/contains":"contains","@stdlib/array/convert":"convertArray","@stdlib/array/convert-same":"convertArraySame","@stdlib/utils/convert-path":"convertPath","@stdlib/utils/copy":"copy","@stdlib/buffer/from-buffer":"copyBuffer","@stdlib/utils/count-by":"countBy","@stdlib/utils/async/count-by":"countByAsync","@stdlib/time/current-year":"currentYear","@stdlib/utils/curry":"curry","@stdlib/utils/curry-right":"curryRight","@stdlib/process/cwd":"cwd","@stdlib/datasets/dale-chall-new":"DALE_CHALL_NEW","@stdlib/datasets":"datasets","@stdlib/array/dataview":"DataView","@stdlib/array/datespace":"datespace","@stdlib/time/day-of-quarter":"dayOfQuarter","@stdlib/time/day-of-year":"dayOfYear","@stdlib/time/days-in-month":"daysInMonth","@stdlib/time/days-in-year":"daysInYear","@stdlib/blas/ddot":"ddot","@stdlib/streams/node/debug-sink":"debugSinkStream","@stdlib/streams/node/debug":"debugStream","@stdlib/utils/decorate-after":"decorateAfter","@stdlib/assert/deep-equal":"deepEqual","@stdlib/utils/deep-get":"deepGet","@stdlib/assert/deep-has-own-property":"deepHasOwnProp","@stdlib/assert/deep-has-property":"deepHasProp","@stdlib/utils/deep-pluck":"deepPluck","@stdlib/utils/deep-set":"deepSet","@stdlib/utils/define-memoized-property":"defineMemoizedProperty","@stdlib/utils/define-properties":"defineProperties","@stdlib/utils/define-property":"defineProperty","@stdlib/utils/dirname":"dirname","@stdlib/string/dotcase":"dotcase","@stdlib/dstructs/doubly-linked-list":"DoublyLinkedList","@stdlib/utils/do-until":"doUntil","@stdlib/utils/async/do-until":"doUntilAsync","@stdlib/utils/do-until-each":"doUntilEach","@stdlib/utils/do-until-each-right":"doUntilEachRight","@stdlib/utils/do-while":"doWhile","@stdlib/utils/async/do-while":"doWhileAsync","@stdlib/utils/do-while-each":"doWhileEach","@stdlib/utils/do-while-each-right":"doWhileEachRight","@stdlib/blas/dswap":"dswap","@stdlib/constants/float64/e":"E","@stdlib/datasets/emoji":"EMOJI","@stdlib/datasets/emoji-code-picto":"EMOJI_CODE_PICTO","@stdlib/datasets/emoji-picto-code":"EMOJI_PICTO_CODE","@stdlib/streams/node/empty":"emptyStream","@stdlib/string/ends-with":"endsWith","@stdlib/utils/enumerable-properties":"enumerableProperties","@stdlib/utils/enumerable-properties-in":"enumerablePropertiesIn","@stdlib/utils/enumerable-property-symbols":"enumerablePropertySymbols","@stdlib/utils/enumerable-property-symbols-in":"enumerablePropertySymbolsIn","@stdlib/process/env":"ENV","@stdlib/constants/float64/eps":"EPS","@stdlib/error/to-json":"error2json","@stdlib/constants/float64/eulergamma":"EULERGAMMA","@stdlib/utils/every":"every","@stdlib/utils/every-by":"everyBy","@stdlib/utils/async/every-by":"everyByAsync","@stdlib/utils/every-by-right":"everyByRight","@stdlib/utils/async/every-by-right":"everyByRightAsync","@stdlib/utils/every-in-by":"everyInBy","@stdlib/utils/every-own-by":"everyOwnBy","@stdlib/utils/eval":"evil","@stdlib/process/exec-path":"EXEC_PATH","@stdlib/fs/exists":"exists","@stdlib/nlp/expand-acronyms":"expandAcronyms","@stdlib/nlp/expand-contractions":"expandContractions","@stdlib/utils/extname":"extname","@stdlib/ndarray/fancy":"FancyArray","@stdlib/math/base/special/fast/abs":"fastmath.abs","@stdlib/math/base/special/fast/acosh":"fastmath.acosh","@stdlib/math/base/special/fast/alpha-max-plus-beta-min":"fastmath.ampbm","@stdlib/math/base/special/fast/asinh":"fastmath.asinh","@stdlib/math/base/special/fast/atanh":"fastmath.atanh","@stdlib/math/base/special/fast/hypot":"fastmath.hypot","@stdlib/math/base/special/fast/uint32-log2":"fastmath.log2Uint32","@stdlib/math/base/special/fast/max":"fastmath.max","@stdlib/math/base/special/fast/min":"fastmath.min","@stdlib/math/base/special/fast/pow-int":"fastmath.powint","@stdlib/math/base/special/fast/uint32-sqrt":"fastmath.sqrtUint32","@stdlib/datasets/female-first-names-en":"FEMALE_FIRST_NAMES_EN","@stdlib/dstructs/fifo":"FIFO","@stdlib/array/filled":"filledarray","@stdlib/array/filled-by":"filledarrayBy","@stdlib/utils/filter-arguments":"filterArguments","@stdlib/utils/find":"find","@stdlib/string/first":"firstChar","@stdlib/datasets/fivethirtyeight-ffq":"FIVETHIRTYEIGHT_FFQ","@stdlib/utils/flatten-array":"flattenArray","@stdlib/utils/flatten-object":"flattenObject","@stdlib/stats/fligner-test":"flignerTest","@stdlib/os/float-word-order":"FLOAT_WORD_ORDER","@stdlib/constants/float16/cbrt-eps":"FLOAT16_CBRT_EPS","@stdlib/constants/float16/eps":"FLOAT16_EPS","@stdlib/constants/float16/exponent-bias":"FLOAT16_EXPONENT_BIAS","@stdlib/constants/float16/max":"FLOAT16_MAX","@stdlib/constants/float16/max-safe-integer":"FLOAT16_MAX_SAFE_INTEGER","@stdlib/constants/float16/min-safe-integer":"FLOAT16_MIN_SAFE_INTEGER","@stdlib/constants/float16/ninf":"FLOAT16_NINF","@stdlib/constants/float16/num-bytes":"FLOAT16_NUM_BYTES","@stdlib/constants/float16/pinf":"FLOAT16_PINF","@stdlib/constants/float16/precision":"FLOAT16_PRECISION","@stdlib/constants/float16/smallest-normal":"FLOAT16_SMALLEST_NORMAL","@stdlib/constants/float16/smallest-subnormal":"FLOAT16_SMALLEST_SUBNORMAL","@stdlib/constants/float16/sqrt-eps":"FLOAT16_SQRT_EPS","@stdlib/constants/float32/abs-mask":"FLOAT32_ABS_MASK","@stdlib/constants/float32/cbrt-eps":"FLOAT32_CBRT_EPS","@stdlib/constants/float32/e":"FLOAT32_E","@stdlib/constants/float32/eps":"FLOAT32_EPS","@stdlib/constants/float32/exponent-bias":"FLOAT32_EXPONENT_BIAS","@stdlib/constants/float32/exponent-mask":"FLOAT32_EXPONENT_MASK","@stdlib/constants/float32/fourth-pi":"FLOAT32_FOURTH_PI","@stdlib/constants/float32/half-ln-two":"FLOAT32_HALF_LN_TWO","@stdlib/constants/float32/half-pi":"FLOAT32_HALF_PI","@stdlib/constants/float32/ln-half":"FLOAT32_LN_HALF","@stdlib/constants/float32/ln-pi":"FLOAT32_LN_PI","@stdlib/constants/float32/ln-ten":"FLOAT32_LN_TEN","@stdlib/constants/float32/ln-two":"FLOAT32_LN_TWO","@stdlib/constants/float32/max":"FLOAT32_MAX","@stdlib/constants/float32/max-base2-exponent":"FLOAT32_MAX_BASE2_EXPONENT","@stdlib/constants/float32/max-base2-exponent-subnormal":"FLOAT32_MAX_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float32/max-base10-exponent":"FLOAT32_MAX_BASE10_EXPONENT","@stdlib/constants/float32/max-base10-exponent-subnormal":"FLOAT32_MAX_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float32/max-safe-fibonacci":"FLOAT32_MAX_SAFE_FIBONACCI","@stdlib/constants/float32/max-safe-integer":"FLOAT32_MAX_SAFE_INTEGER","@stdlib/constants/float32/max-safe-nth-factorial":"FLOAT32_MAX_SAFE_NTH_FACTORIAL","@stdlib/constants/float32/max-safe-nth-fibonacci":"FLOAT32_MAX_SAFE_NTH_FIBONACCI","@stdlib/constants/float32/max-safe-nth-lucas":"FLOAT32_MAX_SAFE_NTH_LUCAS","@stdlib/constants/float32/min-base2-exponent":"FLOAT32_MIN_BASE2_EXPONENT","@stdlib/constants/float32/min-base2-exponent-subnormal":"FLOAT32_MIN_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float32/min-base10-exponent":"FLOAT32_MIN_BASE10_EXPONENT","@stdlib/constants/float32/min-base10-exponent-subnormal":"FLOAT32_MIN_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float32/min-safe-integer":"FLOAT32_MIN_SAFE_INTEGER","@stdlib/constants/float32/nan":"FLOAT32_NAN","@stdlib/constants/float32/ninf":"FLOAT32_NINF","@stdlib/constants/float32/num-bytes":"FLOAT32_NUM_BYTES","@stdlib/constants/float32/phi":"FLOAT32_PHI","@stdlib/constants/float32/pi":"FLOAT32_PI","@stdlib/constants/float32/pinf":"FLOAT32_PINF","@stdlib/constants/float32/precision":"FLOAT32_PRECISION","@stdlib/constants/float32/sign-mask":"FLOAT32_SIGN_MASK","@stdlib/constants/float32/significand-mask":"FLOAT32_SIGNIFICAND_MASK","@stdlib/constants/float32/smallest-normal":"FLOAT32_SMALLEST_NORMAL","@stdlib/constants/float32/smallest-subnormal":"FLOAT32_SMALLEST_SUBNORMAL","@stdlib/constants/float32/sqrt-eps":"FLOAT32_SQRT_EPS","@stdlib/constants/float32/sqrt-half":"FLOAT32_SQRT_HALF","@stdlib/constants/float32/sqrt-half-pi":"FLOAT32_SQRT_HALF_PI","@stdlib/constants/float32/sqrt-phi":"FLOAT32_SQRT_PHI","@stdlib/constants/float32/sqrt-pi":"FLOAT32_SQRT_PI","@stdlib/constants/float32/sqrt-three":"FLOAT32_SQRT_THREE","@stdlib/constants/float32/sqrt-two":"FLOAT32_SQRT_TWO","@stdlib/constants/float32/sqrt-two-pi":"FLOAT32_SQRT_TWO_PI","@stdlib/constants/float32/two-pi":"FLOAT32_TWO_PI","@stdlib/array/float32":"Float32Array","@stdlib/array/fixed-endian-float32":"Float32ArrayFE","@stdlib/array/little-endian-float32":"Float32ArrayLE","@stdlib/constants/float64/exponent-bias":"FLOAT64_EXPONENT_BIAS","@stdlib/constants/float64/high-word-abs-mask":"FLOAT64_HIGH_WORD_ABS_MASK","@stdlib/constants/float64/high-word-exponent-mask":"FLOAT64_HIGH_WORD_EXPONENT_MASK","@stdlib/constants/float64/high-word-sign-mask":"FLOAT64_HIGH_WORD_SIGN_MASK","@stdlib/constants/float64/high-word-significand-mask":"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK","@stdlib/constants/float64/max":"FLOAT64_MAX","@stdlib/constants/float64/max-base2-exponent":"FLOAT64_MAX_BASE2_EXPONENT","@stdlib/constants/float64/max-base2-exponent-subnormal":"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float64/max-base10-exponent":"FLOAT64_MAX_BASE10_EXPONENT","@stdlib/constants/float64/max-base10-exponent-subnormal":"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float64/max-ln":"FLOAT64_MAX_LN","@stdlib/constants/float64/max-safe-fibonacci":"FLOAT64_MAX_SAFE_FIBONACCI","@stdlib/constants/float64/max-safe-integer":"FLOAT64_MAX_SAFE_INTEGER","@stdlib/constants/float64/max-safe-lucas":"FLOAT64_MAX_SAFE_LUCAS","@stdlib/constants/float64/max-safe-nth-fibonacci":"FLOAT64_MAX_SAFE_NTH_FIBONACCI","@stdlib/constants/float64/max-safe-nth-lucas":"FLOAT64_MAX_SAFE_NTH_LUCAS","@stdlib/constants/float64/min-base2-exponent":"FLOAT64_MIN_BASE2_EXPONENT","@stdlib/constants/float64/min-base2-exponent-subnormal":"FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/float64/min-base10-exponent":"FLOAT64_MIN_BASE10_EXPONENT","@stdlib/constants/float64/min-base10-exponent-subnormal":"FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/float64/min-ln":"FLOAT64_MIN_LN","@stdlib/constants/float64/min-safe-integer":"FLOAT64_MIN_SAFE_INTEGER","@stdlib/constants/float64/num-bytes":"FLOAT64_NUM_BYTES","@stdlib/constants/float64/precision":"FLOAT64_PRECISION","@stdlib/constants/float64/smallest-normal":"FLOAT64_SMALLEST_NORMAL","@stdlib/constants/float64/smallest-subnormal":"FLOAT64_SMALLEST_SUBNORMAL","@stdlib/array/float64":"Float64Array","@stdlib/array/fixed-endian-float64":"Float64ArrayFE","@stdlib/array/little-endian-float64":"Float64ArrayLE","@stdlib/utils/for-each":"forEach","@stdlib/utils/async/for-each":"forEachAsync","@stdlib/string/for-each":"forEachChar","@stdlib/utils/for-each-right":"forEachRight","@stdlib/utils/async/for-each-right":"forEachRightAsync","@stdlib/utils/for-in":"forIn","@stdlib/string/format":"format","@stdlib/utils/for-own":"forOwn","@stdlib/constants/float64/fourth-pi":"FOURTH_PI","@stdlib/constants/float64/fourth-root-eps":"FOURTH_ROOT_EPS","@stdlib/datasets/frb-sf-wage-rigidity":"FRB_SF_WAGE_RIGIDITY","@stdlib/string/from-code-point":"fromCodePoint","@stdlib/function/ctor":"Function","@stdlib/function/to-string":"function2string","@stdlib/utils/function-name":"functionName","@stdlib/utils/function-sequence":"functionSequence","@stdlib/utils/async/function-sequence":"functionSequenceAsync","@stdlib/constants/float64/gamma-lanczos-g":"GAMMA_LANCZOS_G","@stdlib/blas/gdot":"gdot","@stdlib/process/getegid":"getegid","@stdlib/process/geteuid":"geteuid","@stdlib/process/getgid":"getgid","@stdlib/utils/global":"getGlobal","@stdlib/utils/get-prototype-of":"getPrototypeOf","@stdlib/process/getuid":"getuid","@stdlib/constants/float64/glaisher-kinkelin":"GLAISHER","@stdlib/string/to-grapheme-cluster-iterator":"graphemeClusters2iterator","@stdlib/string/to-grapheme-cluster-iterator-right":"graphemeClusters2iteratorRight","@stdlib/utils/group":"group","@stdlib/utils/group-by":"groupBy","@stdlib/utils/async/group-by":"groupByAsync","@stdlib/utils/group-in":"groupIn","@stdlib/utils/group-own":"groupOwn","@stdlib/blas/gswap":"gswap","@stdlib/constants/float64/half-ln-two":"HALF_LN2","@stdlib/constants/float64/half-pi":"HALF_PI","@stdlib/datasets/harrison-boston-house-prices":"HARRISON_BOSTON_HOUSE_PRICES","@stdlib/datasets/harrison-boston-house-prices-corrected":"HARRISON_BOSTON_HOUSE_PRICES_CORRECTED","@stdlib/assert/has-arraybuffer-support":"hasArrayBufferSupport","@stdlib/assert/has-arrow-function-support":"hasArrowFunctionSupport","@stdlib/assert/has-async-await-support":"hasAsyncAwaitSupport","@stdlib/assert/has-async-iterator-symbol-support":"hasAsyncIteratorSymbolSupport","@stdlib/assert/has-atob-support":"hasAtobSupport","@stdlib/assert/has-bigint64array-support":"hasBigInt64ArraySupport","@stdlib/assert/has-bigint-support":"hasBigIntSupport","@stdlib/assert/has-biguint64array-support":"hasBigUint64ArraySupport","@stdlib/assert/has-btoa-support":"hasBtoaSupport","@stdlib/assert/has-class-support":"hasClassSupport","@stdlib/assert/has-dataview-support":"hasDataViewSupport","@stdlib/assert/has-define-properties-support":"hasDefinePropertiesSupport","@stdlib/assert/has-define-property-support":"hasDefinePropertySupport","@stdlib/assert/has-float32array-support":"hasFloat32ArraySupport","@stdlib/assert/has-float64array-support":"hasFloat64ArraySupport","@stdlib/assert/has-function-name-support":"hasFunctionNameSupport","@stdlib/assert/has-generator-support":"hasGeneratorSupport","@stdlib/assert/has-globalthis-support":"hasGlobalThisSupport","@stdlib/assert/has-int8array-support":"hasInt8ArraySupport","@stdlib/assert/has-int16array-support":"hasInt16ArraySupport","@stdlib/assert/has-int32array-support":"hasInt32ArraySupport","@stdlib/assert/has-iterator-symbol-support":"hasIteratorSymbolSupport","@stdlib/assert/has-map-support":"hasMapSupport","@stdlib/assert/has-node-buffer-support":"hasNodeBufferSupport","@stdlib/assert/has-own-property":"hasOwnProp","@stdlib/assert/has-property":"hasProp","@stdlib/assert/has-proxy-support":"hasProxySupport","@stdlib/assert/has-set-support":"hasSetSupport","@stdlib/assert/has-sharedarraybuffer-support":"hasSharedArrayBufferSupport","@stdlib/assert/has-symbol-support":"hasSymbolSupport","@stdlib/assert/has-tostringtag-support":"hasToStringTagSupport","@stdlib/assert/has-uint8array-support":"hasUint8ArraySupport","@stdlib/assert/has-uint8clampedarray-support":"hasUint8ClampedArraySupport","@stdlib/assert/has-uint16array-support":"hasUint16ArraySupport","@stdlib/assert/has-uint32array-support":"hasUint32ArraySupport","@stdlib/assert/has-utf16-surrogate-pair-at":"hasUTF16SurrogatePairAt","@stdlib/assert/has-weakmap-support":"hasWeakMapSupport","@stdlib/assert/has-weakset-support":"hasWeakSetSupport","@stdlib/assert/has-wasm-support":"hasWebAssemblySupport","@stdlib/string/headercase":"headercase","@stdlib/datasets/herndon-venus-semidiameters":"HERNDON_VENUS_SEMIDIAMETERS","@stdlib/os/homedir":"homedir","@stdlib/constants/time/hours-in-day":"HOURS_IN_DAY","@stdlib/constants/time/hours-in-week":"HOURS_IN_WEEK","@stdlib/time/hours-in-month":"hoursInMonth","@stdlib/time/hours-in-year":"hoursInYear","@stdlib/net/http-server":"httpServer","@stdlib/utils/identity-function":"identity","@stdlib/utils/if-else":"ifelse","@stdlib/utils/async/if-else":"ifelseAsync","@stdlib/utils/if-then":"ifthen","@stdlib/utils/async/if-then":"ifthenAsync","@stdlib/complex/float64/imag":"imag","@stdlib/complex/float32/imag":"imagf","@stdlib/datasets/img-acanthus-mollis":"IMG_ACANTHUS_MOLLIS","@stdlib/datasets/img-airplane-from-above":"IMG_AIRPLANE_FROM_ABOVE","@stdlib/datasets/img-allium-oreophilum":"IMG_ALLIUM_OREOPHILUM","@stdlib/datasets/img-black-canyon":"IMG_BLACK_CANYON","@stdlib/datasets/img-dust-bowl-home":"IMG_DUST_BOWL_HOME","@stdlib/datasets/img-french-alpine-landscape":"IMG_FRENCH_ALPINE_LANDSCAPE","@stdlib/datasets/img-locomotion-house-cat":"IMG_LOCOMOTION_HOUSE_CAT","@stdlib/datasets/img-locomotion-nude-male":"IMG_LOCOMOTION_NUDE_MALE","@stdlib/datasets/img-march-pastoral":"IMG_MARCH_PASTORAL","@stdlib/datasets/img-nagasaki-boats":"IMG_NAGASAKI_BOATS","@stdlib/stats/incr/apcorr":"incrapcorr","@stdlib/ml/incr/binary-classification":"incrBinaryClassification","@stdlib/stats/incr/count":"incrcount","@stdlib/stats/incr/covariance":"incrcovariance","@stdlib/stats/incr/covmat":"incrcovmat","@stdlib/stats/incr/cv":"incrcv","@stdlib/stats/incr/ewmean":"increwmean","@stdlib/stats/incr/ewstdev":"increwstdev","@stdlib/stats/incr/ewvariance":"increwvariance","@stdlib/stats/incr/gmean":"incrgmean","@stdlib/stats/incr/grubbs":"incrgrubbs","@stdlib/stats/incr/hmean":"incrhmean","@stdlib/ml/incr/kmeans":"incrkmeans","@stdlib/stats/incr/kurtosis":"incrkurtosis","@stdlib/stats/incr/maape":"incrmaape","@stdlib/stats/incr/mae":"incrmae","@stdlib/stats/incr/mapcorr":"incrmapcorr","@stdlib/stats/incr/mape":"incrmape","@stdlib/stats/incr/max":"incrmax","@stdlib/stats/incr/maxabs":"incrmaxabs","@stdlib/stats/incr/mcovariance":"incrmcovariance","@stdlib/stats/incr/mcv":"incrmcv","@stdlib/stats/incr/mda":"incrmda","@stdlib/stats/incr/me":"incrme","@stdlib/stats/incr/mean":"incrmean","@stdlib/stats/incr/meanabs":"incrmeanabs","@stdlib/stats/incr/meanabs2":"incrmeanabs2","@stdlib/stats/incr/meanstdev":"incrmeanstdev","@stdlib/stats/incr/meanvar":"incrmeanvar","@stdlib/stats/incr/mgmean":"incrmgmean","@stdlib/stats/incr/mgrubbs":"incrmgrubbs","@stdlib/stats/incr/mhmean":"incrmhmean","@stdlib/stats/incr/midrange":"incrmidrange","@stdlib/stats/incr/min":"incrmin","@stdlib/stats/incr/minabs":"incrminabs","@stdlib/stats/incr/minmax":"incrminmax","@stdlib/stats/incr/minmaxabs":"incrminmaxabs","@stdlib/stats/incr/mmaape":"incrmmaape","@stdlib/stats/incr/mmae":"incrmmae","@stdlib/stats/incr/mmape":"incrmmape","@stdlib/stats/incr/mmax":"incrmmax","@stdlib/stats/incr/mmaxabs":"incrmmaxabs","@stdlib/stats/incr/mmda":"incrmmda","@stdlib/stats/incr/mme":"incrmme","@stdlib/stats/incr/mmean":"incrmmean","@stdlib/stats/incr/mmeanabs":"incrmmeanabs","@stdlib/stats/incr/mmeanabs2":"incrmmeanabs2","@stdlib/stats/incr/mmeanstdev":"incrmmeanstdev","@stdlib/stats/incr/mmeanvar":"incrmmeanvar","@stdlib/stats/incr/mmidrange":"incrmmidrange","@stdlib/stats/incr/mmin":"incrmmin","@stdlib/stats/incr/mminabs":"incrmminabs","@stdlib/stats/incr/mminmax":"incrmminmax","@stdlib/stats/incr/mminmaxabs":"incrmminmaxabs","@stdlib/stats/incr/mmpe":"incrmmpe","@stdlib/stats/incr/mmse":"incrmmse","@stdlib/stats/incr/mpcorr":"incrmpcorr","@stdlib/stats/incr/mpcorr2":"incrmpcorr2","@stdlib/stats/incr/mpcorrdist":"incrmpcorrdist","@stdlib/stats/incr/mpe":"incrmpe","@stdlib/stats/incr/mprod":"incrmprod","@stdlib/stats/incr/mrange":"incrmrange","@stdlib/stats/incr/mrmse":"incrmrmse","@stdlib/stats/incr/mrss":"incrmrss","@stdlib/stats/incr/mse":"incrmse","@stdlib/stats/incr/mstdev":"incrmstdev","@stdlib/stats/incr/msum":"incrmsum","@stdlib/stats/incr/msumabs":"incrmsumabs","@stdlib/stats/incr/msumabs2":"incrmsumabs2","@stdlib/stats/incr/msummary":"incrmsummary","@stdlib/stats/incr/msumprod":"incrmsumprod","@stdlib/stats/incr/mvariance":"incrmvariance","@stdlib/stats/incr/mvmr":"incrmvmr","@stdlib/stats/incr/nancount":"incrnancount","@stdlib/stats/incr/nansum":"incrnansum","@stdlib/stats/incr/nansumabs":"incrnansumabs","@stdlib/stats/incr/nansumabs2":"incrnansumabs2","@stdlib/stats/incr/pcorr":"incrpcorr","@stdlib/stats/incr/pcorr2":"incrpcorr2","@stdlib/stats/incr/pcorrdist":"incrpcorrdist","@stdlib/stats/incr/pcorrdistmat":"incrpcorrdistmat","@stdlib/stats/incr/pcorrmat":"incrpcorrmat","@stdlib/stats/incr/prod":"incrprod","@stdlib/stats/incr/range":"incrrange","@stdlib/stats/incr/rmse":"incrrmse","@stdlib/stats/incr/rss":"incrrss","@stdlib/ml/incr/sgd-regression":"incrSGDRegression","@stdlib/stats/incr/skewness":"incrskewness","@stdlib/array/incrspace":"incrspace","@stdlib/stats/incr/stdev":"incrstdev","@stdlib/stats/incr/sum":"incrsum","@stdlib/stats/incr/sumabs":"incrsumabs","@stdlib/stats/incr/sumabs2":"incrsumabs2","@stdlib/stats/incr/summary":"incrsummary","@stdlib/stats/incr/sumprod":"incrsumprod","@stdlib/stats/incr/variance":"incrvariance","@stdlib/stats/incr/vmr":"incrvmr","@stdlib/stats/incr/wmean":"incrwmean","@stdlib/ndarray/ind2sub":"ind2sub","@stdlib/utils/index-of":"indexOf","@stdlib/utils/inherit":"inherit","@stdlib/utils/inherited-enumerable-properties":"inheritedEnumerableProperties","@stdlib/utils/inherited-enumerable-property-symbols":"inheritedEnumerablePropertySymbols","@stdlib/utils/inherited-keys":"inheritedKeys","@stdlib/utils/inherited-nonenumerable-properties":"inheritedNonEnumerableProperties","@stdlib/utils/inherited-nonenumerable-property-names":"inheritedNonEnumerablePropertyNames","@stdlib/utils/inherited-nonenumerable-property-symbols":"inheritedNonEnumerablePropertySymbols","@stdlib/utils/inherited-properties":"inheritedProperties","@stdlib/utils/inherited-property-descriptor":"inheritedPropertyDescriptor","@stdlib/utils/inherited-property-descriptors":"inheritedPropertyDescriptors","@stdlib/utils/inherited-property-names":"inheritedPropertyNames","@stdlib/utils/inherited-property-symbols":"inheritedPropertySymbols","@stdlib/utils/inherited-writable-properties":"inheritedWritableProperties","@stdlib/utils/inherited-writable-property-names":"inheritedWritablePropertyNames","@stdlib/utils/inherited-writable-property-symbols":"inheritedWritablePropertySymbols","@stdlib/utils/inmap":"inmap","@stdlib/utils/async/inmap":"inmapAsync","@stdlib/utils/inmap-right":"inmapRight","@stdlib/utils/async/inmap-right":"inmapRightAsync","@stdlib/streams/node/inspect-sink":"inspectSinkStream","@stdlib/streams/node/inspect":"inspectStream","@stdlib/assert/instance-of":"instanceOf","@stdlib/constants/int8/max":"INT8_MAX","@stdlib/constants/int8/min":"INT8_MIN","@stdlib/constants/int8/num-bytes":"INT8_NUM_BYTES","@stdlib/array/int8":"Int8Array","@stdlib/constants/int16/max":"INT16_MAX","@stdlib/constants/int16/min":"INT16_MIN","@stdlib/constants/int16/num-bytes":"INT16_NUM_BYTES","@stdlib/array/int16":"Int16Array","@stdlib/constants/int32/max":"INT32_MAX","@stdlib/constants/int32/min":"INT32_MIN","@stdlib/constants/int32/num-bytes":"INT32_NUM_BYTES","@stdlib/array/int32":"Int32Array","@stdlib/assert/is-big-endian":"IS_BIG_ENDIAN","@stdlib/assert/is-browser":"IS_BROWSER","@stdlib/assert/is-darwin":"IS_DARWIN","@stdlib/assert/is-docker":"IS_DOCKER","@stdlib/assert/is-electron":"IS_ELECTRON","@stdlib/assert/is-electron-main":"IS_ELECTRON_MAIN","@stdlib/assert/is-electron-renderer":"IS_ELECTRON_RENDERER","@stdlib/assert/is-little-endian":"IS_LITTLE_ENDIAN","@stdlib/assert/is-mobile":"IS_MOBILE","@stdlib/assert/is-node":"IS_NODE","@stdlib/assert/is-touch-device":"IS_TOUCH_DEVICE","@stdlib/assert/is-web-worker":"IS_WEB_WORKER","@stdlib/assert/is-windows":"IS_WINDOWS","@stdlib/assert/is-absolute-http-uri":"isAbsoluteHttpURI","@stdlib/assert/is-absolute-path":"isAbsolutePath","@stdlib/assert/is-absolute-uri":"isAbsoluteURI","@stdlib/assert/is-accessor-array":"isAccessorArray","@stdlib/assert/is-accessor-property":"isAccessorProperty","@stdlib/assert/is-accessor-property-in":"isAccessorPropertyIn","@stdlib/assert/is-alphagram":"isAlphagram","@stdlib/assert/is-alphanumeric":"isAlphaNumeric","@stdlib/assert/is-anagram":"isAnagram","@stdlib/assert/is-arguments":"isArguments","@stdlib/assert/is-array":"isArray","@stdlib/assert/is-array-array":"isArrayArray","@stdlib/assert/is-arraybuffer":"isArrayBuffer","@stdlib/assert/is-arraybuffer-view":"isArrayBufferView","@stdlib/assert/is-array-length":"isArrayLength","@stdlib/assert/is-array-like":"isArrayLike","@stdlib/assert/is-array-like-object":"isArrayLikeObject","@stdlib/assert/is-arrow-function":"isArrowFunction","@stdlib/assert/is-ascii":"isASCII","@stdlib/assert/is-between":"isBetween","@stdlib/assert/is-between-array":"isBetweenArray","@stdlib/assert/is-bigint":"isBigInt","@stdlib/assert/is-bigint64array":"isBigInt64Array","@stdlib/assert/is-biguint64array":"isBigUint64Array","@stdlib/assert/is-binary-string":"isBinaryString","@stdlib/assert/is-blank-string":"isBlankString","@stdlib/assert/is-boolean":"isBoolean","@stdlib/assert/is-boolean-array":"isBooleanArray","@stdlib/assert/is-boxed-primitive":"isBoxedPrimitive","@stdlib/assert/is-buffer":"isBuffer","@stdlib/assert/is-camelcase":"isCamelcase","@stdlib/assert/is-capitalized":"isCapitalized","@stdlib/assert/is-centrosymmetric-matrix":"isCentrosymmetricMatrix","@stdlib/assert/is-circular":"isCircular","@stdlib/assert/is-circular-array":"isCircularArray","@stdlib/assert/is-circular-plain-object":"isCircularPlainObject","@stdlib/assert/is-class":"isClass","@stdlib/assert/is-collection":"isCollection","@stdlib/assert/is-complex":"isComplex","@stdlib/assert/is-complex64":"isComplex64","@stdlib/assert/is-complex64array":"isComplex64Array","@stdlib/assert/is-complex64matrix-like":"isComplex64MatrixLike","@stdlib/assert/is-complex64ndarray-like":"isComplex64ndarrayLike","@stdlib/assert/is-complex64vector-like":"isComplex64VectorLike","@stdlib/assert/is-complex128":"isComplex128","@stdlib/assert/is-complex128array":"isComplex128Array","@stdlib/assert/is-complex128matrix-like":"isComplex128MatrixLike","@stdlib/assert/is-complex128ndarray-like":"isComplex128ndarrayLike","@stdlib/assert/is-complex128vector-like":"isComplex128VectorLike","@stdlib/assert/is-complex-like":"isComplexLike","@stdlib/assert/is-complex-typed-array":"isComplexTypedArray","@stdlib/assert/is-complex-typed-array-like":"isComplexTypedArrayLike","@stdlib/assert/is-composite":"isComposite","@stdlib/assert/is-configurable-property":"isConfigurableProperty","@stdlib/assert/is-configurable-property-in":"isConfigurablePropertyIn","@stdlib/assert/is-constantcase":"isConstantcase","@stdlib/assert/is-cube-number":"isCubeNumber","@stdlib/assert/is-current-year":"isCurrentYear","@stdlib/assert/is-data-property":"isDataProperty","@stdlib/assert/is-data-property-in":"isDataPropertyIn","@stdlib/assert/is-dataview":"isDataView","@stdlib/assert/is-date-object":"isDateObject","@stdlib/assert/is-date-object-array":"isDateObjectArray","@stdlib/assert/is-digit-string":"isDigitString","@stdlib/assert/is-domain-name":"isDomainName","@stdlib/assert/is-duration-string":"isDurationString","@stdlib/assert/is-email-address":"isEmailAddress","@stdlib/assert/is-empty-array":"isEmptyArray","@stdlib/assert/is-empty-array-like-object":"isEmptyArrayLikeObject","@stdlib/assert/is-empty-collection":"isEmptyCollection","@stdlib/assert/is-empty-object":"isEmptyObject","@stdlib/assert/is-empty-string":"isEmptyString","@stdlib/assert/is-enumerable-property":"isEnumerableProperty","@stdlib/assert/is-enumerable-property-in":"isEnumerablePropertyIn","@stdlib/assert/is-equal-array":"isEqualArray","@stdlib/assert/is-error":"isError","@stdlib/assert/is-eval-error":"isEvalError","@stdlib/assert/is-even":"isEven","@stdlib/assert/is-falsy":"isFalsy","@stdlib/assert/is-falsy-array":"isFalsyArray","@stdlib/assert/is-finite":"isFinite","@stdlib/assert/is-finite-array":"isFiniteArray","@stdlib/assert/is-float32array":"isFloat32Array","@stdlib/assert/is-float32matrix-like":"isFloat32MatrixLike","@stdlib/assert/is-float32ndarray-like":"isFloat32ndarrayLike","@stdlib/assert/is-float32vector-like":"isFloat32VectorLike","@stdlib/assert/is-float64array":"isFloat64Array","@stdlib/assert/is-float64matrix-like":"isFloat64MatrixLike","@stdlib/assert/is-float64ndarray-like":"isFloat64ndarrayLike","@stdlib/assert/is-float64vector-like":"isFloat64VectorLike","@stdlib/assert/is-function":"isFunction","@stdlib/assert/is-function-array":"isFunctionArray","@stdlib/assert/is-generator-object":"isGeneratorObject","@stdlib/assert/is-generator-object-like":"isGeneratorObjectLike","@stdlib/assert/is-gzip-buffer":"isgzipBuffer","@stdlib/assert/is-hex-string":"isHexString","@stdlib/assert/is-infinite":"isInfinite","@stdlib/assert/is-inherited-property":"isInheritedProperty","@stdlib/assert/is-int8array":"isInt8Array","@stdlib/assert/is-int16array":"isInt16Array","@stdlib/assert/is-int32array":"isInt32Array","@stdlib/assert/is-integer":"isInteger","@stdlib/assert/is-integer-array":"isIntegerArray","@stdlib/assert/is-iterable-like":"isIterableLike","@stdlib/assert/is-iterator-like":"isIteratorLike","@stdlib/assert/is-json":"isJSON","@stdlib/assert/is-kebabcase":"isKebabcase","@stdlib/assert/is-leap-year":"isLeapYear","@stdlib/assert/is-localhost":"isLocalhost","@stdlib/assert/is-lowercase":"isLowercase","@stdlib/assert/is-matrix-like":"isMatrixLike","@stdlib/assert/is-method":"isMethod","@stdlib/assert/is-method-in":"isMethodIn","@stdlib/assert/is-multi-slice":"isMultiSlice","@stdlib/assert/is-named-typed-tuple-like":"isNamedTypedTupleLike","@stdlib/assert/is-nan":"isnan","@stdlib/assert/is-nan-array":"isNaNArray","@stdlib/assert/is-native-function":"isNativeFunction","@stdlib/assert/is-ndarray-like":"isndarrayLike","@stdlib/assert/is-ndarray-like-with-data-type":"isndarrayLikeWithDataType","@stdlib/assert/is-negative-finite":"isNegativeFinite","@stdlib/assert/is-negative-integer":"isNegativeInteger","@stdlib/assert/is-negative-integer-array":"isNegativeIntegerArray","@stdlib/assert/is-negative-number":"isNegativeNumber","@stdlib/assert/is-negative-number-array":"isNegativeNumberArray","@stdlib/assert/is-negative-zero":"isNegativeZero","@stdlib/assert/is-node-builtin":"isNodeBuiltin","@stdlib/assert/is-node-duplex-stream-like":"isNodeDuplexStreamLike","@stdlib/assert/is-node-readable-stream-like":"isNodeReadableStreamLike","@stdlib/assert/is-node-repl":"isNodeREPL","@stdlib/assert/is-node-stream-like":"isNodeStreamLike","@stdlib/assert/is-node-transform-stream-like":"isNodeTransformStreamLike","@stdlib/assert/is-node-writable-stream-like":"isNodeWritableStreamLike","@stdlib/assert/is-nonconfigurable-property":"isNonConfigurableProperty","@stdlib/assert/is-nonconfigurable-property-in":"isNonConfigurablePropertyIn","@stdlib/assert/is-nonenumerable-property":"isNonEnumerableProperty","@stdlib/assert/is-nonenumerable-property-in":"isNonEnumerablePropertyIn","@stdlib/assert/is-nonnegative-finite":"isNonNegativeFinite","@stdlib/assert/is-nonnegative-integer":"isNonNegativeInteger","@stdlib/assert/is-nonnegative-integer-array":"isNonNegativeIntegerArray","@stdlib/assert/is-nonnegative-number":"isNonNegativeNumber","@stdlib/assert/is-nonnegative-number-array":"isNonNegativeNumberArray","@stdlib/assert/is-nonpositive-finite":"isNonPositiveFinite","@stdlib/assert/is-nonpositive-integer":"isNonPositiveInteger","@stdlib/assert/is-nonpositive-integer-array":"isNonPositiveIntegerArray","@stdlib/assert/is-nonpositive-number":"isNonPositiveNumber","@stdlib/assert/is-nonpositive-number-array":"isNonPositiveNumberArray","@stdlib/assert/is-nonsymmetric-matrix":"isNonSymmetricMatrix","@stdlib/assert/is-null":"isNull","@stdlib/assert/is-null-array":"isNullArray","@stdlib/assert/is-number":"isNumber","@stdlib/assert/is-number-array":"isNumberArray","@stdlib/assert/is-numeric-array":"isNumericArray","@stdlib/assert/is-object":"isObject","@stdlib/assert/is-object-array":"isObjectArray","@stdlib/assert/is-object-like":"isObjectLike","@stdlib/assert/is-odd":"isOdd","@stdlib/time/iso-weeks-in-year":"isoWeeksInYear","@stdlib/assert/is-pascalcase":"isPascalcase","@stdlib/assert/is-persymmetric-matrix":"isPersymmetricMatrix","@stdlib/assert/is-plain-object":"isPlainObject","@stdlib/assert/is-plain-object-array":"isPlainObjectArray","@stdlib/assert/is-positive-finite":"isPositiveFinite","@stdlib/assert/is-positive-integer":"isPositiveInteger","@stdlib/assert/is-positive-integer-array":"isPositiveIntegerArray","@stdlib/assert/is-positive-number":"isPositiveNumber","@stdlib/assert/is-positive-number-array":"isPositiveNumberArray","@stdlib/assert/is-positive-zero":"isPositiveZero","@stdlib/assert/is-prime":"isPrime","@stdlib/assert/is-primitive":"isPrimitive","@stdlib/assert/is-primitive-array":"isPrimitiveArray","@stdlib/assert/is-prng-like":"isPRNGLike","@stdlib/assert/is-probability":"isProbability","@stdlib/assert/is-probability-array":"isProbabilityArray","@stdlib/assert/is-property-key":"isPropertyKey","@stdlib/assert/is-prototype-of":"isPrototypeOf","@stdlib/assert/is-ragged-nested-array":"isRaggedNestedArray","@stdlib/assert/is-range-error":"isRangeError","@stdlib/assert/is-readable-property":"isReadableProperty","@stdlib/assert/is-readable-property-in":"isReadablePropertyIn","@stdlib/assert/is-read-only-property":"isReadOnlyProperty","@stdlib/assert/is-read-only-property-in":"isReadOnlyPropertyIn","@stdlib/assert/is-read-write-property":"isReadWriteProperty","@stdlib/assert/is-read-write-property-in":"isReadWritePropertyIn","@stdlib/assert/is-reference-error":"isReferenceError","@stdlib/assert/is-regexp":"isRegExp","@stdlib/assert/is-regexp-string":"isRegExpString","@stdlib/assert/is-relative-path":"isRelativePath","@stdlib/assert/is-relative-uri":"isRelativeURI","@stdlib/assert/is-safe-integer":"isSafeInteger","@stdlib/assert/is-safe-integer-array":"isSafeIntegerArray","@stdlib/assert/is-same-array":"isSameArray","@stdlib/assert/is-same-array-like":"isSameArrayLike","@stdlib/assert/is-same-complex64":"isSameComplex64","@stdlib/assert/is-same-complex64array":"isSameComplex64Array","@stdlib/assert/is-same-complex128":"isSameComplex128","@stdlib/assert/is-same-complex128array":"isSameComplex128Array","@stdlib/assert/is-same-date-object":"isSameDateObject","@stdlib/assert/is-same-float32array":"isSameFloat32Array","@stdlib/assert/is-same-float64array":"isSameFloat64Array","@stdlib/assert/is-same-native-class":"isSameNativeClass","@stdlib/assert/is-same-type":"isSameType","@stdlib/assert/is-same-value":"isSameValue","@stdlib/assert/is-same-value-zero":"isSameValueZero","@stdlib/assert/is-semver":"isSemVer","@stdlib/assert/is-sharedarraybuffer":"isSharedArrayBuffer","@stdlib/assert/is-skew-centrosymmetric-matrix":"isSkewCentrosymmetricMatrix","@stdlib/assert/is-skew-persymmetric-matrix":"isSkewPersymmetricMatrix","@stdlib/assert/is-skew-symmetric-matrix":"isSkewSymmetricMatrix","@stdlib/assert/is-slice":"isSlice","@stdlib/assert/is-snakecase":"isSnakecase","@stdlib/assert/is-square-matrix":"isSquareMatrix","@stdlib/assert/is-square-number":"isSquareNumber","@stdlib/assert/is-square-triangular-number":"isSquareTriangularNumber","@stdlib/assert/is-startcase":"isStartcase","@stdlib/assert/is-strict-equal":"isStrictEqual","@stdlib/assert/is-string":"isString","@stdlib/assert/is-string-array":"isStringArray","@stdlib/assert/is-symbol":"isSymbol","@stdlib/assert/is-symbol-array":"isSymbolArray","@stdlib/assert/is-symmetric-matrix":"isSymmetricMatrix","@stdlib/assert/is-syntax-error":"isSyntaxError","@stdlib/assert/is-triangular-number":"isTriangularNumber","@stdlib/assert/is-truthy":"isTruthy","@stdlib/assert/is-truthy-array":"isTruthyArray","@stdlib/assert/is-typed-array":"isTypedArray","@stdlib/assert/is-typed-array-length":"isTypedArrayLength","@stdlib/assert/is-typed-array-like":"isTypedArrayLike","@stdlib/assert/is-type-error":"isTypeError","@stdlib/assert/is-uint8array":"isUint8Array","@stdlib/assert/is-uint8clampedarray":"isUint8ClampedArray","@stdlib/assert/is-uint16array":"isUint16Array","@stdlib/assert/is-uint32array":"isUint32Array","@stdlib/assert/is-unc-path":"isUNCPath","@stdlib/assert/is-undefined":"isUndefined","@stdlib/assert/is-undefined-or-null":"isUndefinedOrNull","@stdlib/assert/is-unity-probability-array":"isUnityProbabilityArray","@stdlib/assert/is-uppercase":"isUppercase","@stdlib/assert/is-uri":"isURI","@stdlib/assert/is-uri-error":"isURIError","@stdlib/assert/is-vector-like":"isVectorLike","@stdlib/assert/is-wasm-memory":"isWebAssemblyMemory","@stdlib/assert/is-well-formed-string":"isWellFormedString","@stdlib/assert/is-whitespace":"isWhitespace","@stdlib/assert/is-writable-property":"isWritableProperty","@stdlib/assert/is-writable-property-in":"isWritablePropertyIn","@stdlib/assert/is-write-only-property":"isWriteOnlyProperty","@stdlib/assert/is-write-only-property-in":"isWriteOnlyPropertyIn","@stdlib/math/iter/special/abs":"iterAbs","@stdlib/math/iter/special/abs2":"iterAbs2","@stdlib/math/iter/special/acos":"iterAcos","@stdlib/math/iter/special/acosh":"iterAcosh","@stdlib/math/iter/special/acot":"iterAcot","@stdlib/math/iter/special/acoth":"iterAcoth","@stdlib/math/iter/special/acovercos":"iterAcovercos","@stdlib/math/iter/special/acoversin":"iterAcoversin","@stdlib/math/iter/ops/add":"iterAdd","@stdlib/iter/advance":"iterAdvance","@stdlib/math/iter/special/ahavercos":"iterAhavercos","@stdlib/math/iter/special/ahaversin":"iterAhaversin","@stdlib/iter/any":"iterAny","@stdlib/iter/any-by":"iterAnyBy","@stdlib/math/iter/special/asin":"iterAsin","@stdlib/math/iter/special/asinh":"iterAsinh","@stdlib/math/iter/special/atan":"iterAtan","@stdlib/math/iter/special/atan2":"iterAtan2","@stdlib/math/iter/special/atanh":"iterAtanh","@stdlib/array/from-iterator":"iterator2array","@stdlib/iter/to-array-view":"iterator2arrayview","@stdlib/iter/to-array-view-right":"iterator2arrayviewRight","@stdlib/streams/node/from-iterator":"iteratorStream","@stdlib/symbol/iterator":"IteratorSymbol","@stdlib/math/iter/special/avercos":"iterAvercos","@stdlib/math/iter/special/aversin":"iterAversin","@stdlib/simulate/iter/awgn":"iterawgn","@stdlib/simulate/iter/awln":"iterawln","@stdlib/simulate/iter/awun":"iterawun","@stdlib/simulate/iter/bartlett-hann-pulse":"iterBartlettHannPulse","@stdlib/simulate/iter/bartlett-pulse":"iterBartlettPulse","@stdlib/math/iter/special/besselj0":"iterBesselj0","@stdlib/math/iter/special/besselj1":"iterBesselj1","@stdlib/math/iter/special/bessely0":"iterBessely0","@stdlib/math/iter/special/bessely1":"iterBessely1","@stdlib/math/iter/special/beta":"iterBeta","@stdlib/math/iter/special/betaln":"iterBetaln","@stdlib/math/iter/special/binet":"iterBinet","@stdlib/math/iter/special/cbrt":"iterCbrt","@stdlib/math/iter/special/ceil":"iterCeil","@stdlib/math/iter/special/ceil2":"iterCeil2","@stdlib/math/iter/special/ceil10":"iterCeil10","@stdlib/math/iter/sequences/composites":"iterCompositesSeq","@stdlib/iter/concat":"iterConcat","@stdlib/iter/constant":"iterConstant","@stdlib/math/iter/utils/continued-fraction":"iterContinuedFraction","@stdlib/math/iter/sequences/continued-fraction":"iterContinuedFractionSeq","@stdlib/math/iter/special/cos":"iterCos","@stdlib/math/iter/special/cosh":"iterCosh","@stdlib/simulate/iter/cosine-wave":"iterCosineWave","@stdlib/math/iter/special/cosm1":"iterCosm1","@stdlib/math/iter/special/cospi":"iterCospi","@stdlib/iter/counter":"iterCounter","@stdlib/math/iter/special/covercos":"iterCovercos","@stdlib/math/iter/special/coversin":"iterCoversin","@stdlib/math/iter/sequences/cubes":"iterCubesSeq","@stdlib/stats/iter/cugmean":"itercugmean","@stdlib/stats/iter/cuhmean":"itercuhmean","@stdlib/stats/iter/cumax":"itercumax","@stdlib/stats/iter/cumaxabs":"itercumaxabs","@stdlib/stats/iter/cumean":"itercumean","@stdlib/stats/iter/cumeanabs":"itercumeanabs","@stdlib/stats/iter/cumeanabs2":"itercumeanabs2","@stdlib/stats/iter/cumidrange":"itercumidrange","@stdlib/stats/iter/cumin":"itercumin","@stdlib/stats/iter/cuminabs":"itercuminabs","@stdlib/stats/iter/cuprod":"itercuprod","@stdlib/stats/iter/curange":"itercurange","@stdlib/stats/iter/cusum":"itercusum","@stdlib/stats/iter/cusumabs":"itercusumabs","@stdlib/stats/iter/cusumabs2":"itercusumabs2","@stdlib/iter/datespace":"iterDatespace","@stdlib/iter/dedupe":"iterDedupe","@stdlib/iter/dedupe-by":"iterDedupeBy","@stdlib/math/iter/special/deg2rad":"iterDeg2rad","@stdlib/math/iter/special/digamma":"iterDigamma","@stdlib/simulate/iter/dirac-comb":"iterDiracComb","@stdlib/math/iter/special/dirac-delta":"iterDiracDelta","@stdlib/math/iter/ops/divide":"iterDivide","@stdlib/iter/do-until-each":"iterDoUntilEach","@stdlib/iter/do-while-each":"iterDoWhileEach","@stdlib/math/iter/special/ellipe":"iterEllipe","@stdlib/math/iter/special/ellipk":"iterEllipk","@stdlib/iter/empty":"iterEmpty","@stdlib/math/iter/special/erf":"iterErf","@stdlib/math/iter/special/erfc":"iterErfc","@stdlib/math/iter/special/erfcinv":"iterErfcinv","@stdlib/math/iter/special/erfinv":"iterErfinv","@stdlib/math/iter/special/dirichlet-eta":"iterEta","@stdlib/math/iter/sequences/even-integers":"iterEvenIntegersSeq","@stdlib/iter/every":"iterEvery","@stdlib/iter/every-by":"iterEveryBy","@stdlib/math/iter/special/exp":"iterExp","@stdlib/math/iter/special/exp2":"iterExp2","@stdlib/math/iter/special/exp10":"iterExp10","@stdlib/math/iter/special/expit":"iterExpit","@stdlib/math/iter/special/expm1":"iterExpm1","@stdlib/math/iter/special/expm1rel":"iterExpm1rel","@stdlib/math/iter/special/factorial":"iterFactorial","@stdlib/math/iter/special/factorialln":"iterFactorialln","@stdlib/math/iter/sequences/factorials":"iterFactorialsSeq","@stdlib/math/iter/sequences/fibonacci":"iterFibonacciSeq","@stdlib/math/iter/sequences/fifth-powers":"iterFifthPowersSeq","@stdlib/iter/fill":"iterFill","@stdlib/iter/filter":"iterFilter","@stdlib/iter/filter-map":"iterFilterMap","@stdlib/iter/first":"iterFirst","@stdlib/simulate/iter/flat-top-pulse":"iterFlatTopPulse","@stdlib/math/iter/special/floor":"iterFloor","@stdlib/math/iter/special/floor2":"iterFloor2","@stdlib/math/iter/special/floor10":"iterFloor10","@stdlib/iter/flow":"iterFlow","@stdlib/iter/for-each":"iterForEach","@stdlib/math/iter/sequences/fourth-powers":"iterFourthPowersSeq","@stdlib/math/iter/special/fresnelc":"iterFresnelc","@stdlib/math/iter/special/fresnels":"iterFresnels","@stdlib/math/iter/special/gamma":"iterGamma","@stdlib/math/iter/special/gamma1pm1":"iterGamma1pm1","@stdlib/math/iter/special/gammaln":"iterGammaln","@stdlib/math/iter/special/hacovercos":"iterHacovercos","@stdlib/math/iter/special/hacoversin":"iterHacoversin","@stdlib/simulate/iter/hann-pulse":"iterHannPulse","@stdlib/math/iter/special/havercos":"iterHavercos","@stdlib/math/iter/special/haversin":"iterHaversin","@stdlib/iter/head":"iterHead","@stdlib/iter/incrspace":"iterIncrspace","@stdlib/math/iter/sequences/integers":"iterIntegersSeq","@stdlib/iter/intersection":"iterIntersection","@stdlib/iter/intersection-by-hash":"iterIntersectionByHash","@stdlib/math/iter/special/inv":"iterInv","@stdlib/simulate/iter/lanczos-pulse":"iterLanczosPulse","@stdlib/iter/last":"iterLast","@stdlib/iter/length":"iterLength","@stdlib/iter/linspace":"iterLinspace","@stdlib/math/iter/special/ln":"iterLn","@stdlib/math/iter/special/log":"iterLog","@stdlib/math/iter/special/log1mexp":"iterLog1mexp","@stdlib/math/iter/special/log1p":"iterLog1p","@stdlib/math/iter/special/log1pexp":"iterLog1pexp","@stdlib/math/iter/special/log2":"iterLog2","@stdlib/math/iter/special/log10":"iterLog10","@stdlib/math/iter/special/logit":"iterLogit","@stdlib/iter/logspace":"iterLogspace","@stdlib/math/iter/sequences/lucas":"iterLucasSeq","@stdlib/iter/map":"iterMap","@stdlib/iter/mapn":"iterMapN","@stdlib/stats/iter/max":"itermax","@stdlib/stats/iter/maxabs":"itermaxabs","@stdlib/stats/iter/mean":"itermean","@stdlib/stats/iter/meanabs":"itermeanabs","@stdlib/stats/iter/meanabs2":"itermeanabs2","@stdlib/stats/iter/midrange":"itermidrange","@stdlib/stats/iter/min":"itermin","@stdlib/stats/iter/minabs":"iterminabs","@stdlib/stats/iter/mmax":"itermmax","@stdlib/stats/iter/mmaxabs":"itermmaxabs","@stdlib/stats/iter/mmean":"itermmean","@stdlib/stats/iter/mmeanabs":"itermmeanabs","@stdlib/stats/iter/mmeanabs2":"itermmeanabs2","@stdlib/stats/iter/mmidrange":"itermmidrange","@stdlib/stats/iter/mmin":"itermmin","@stdlib/stats/iter/mminabs":"itermminabs","@stdlib/math/iter/ops/mod":"iterMod","@stdlib/stats/iter/mprod":"itermprod","@stdlib/stats/iter/mrange":"itermrange","@stdlib/stats/iter/msum":"itermsum","@stdlib/stats/iter/msumabs":"itermsumabs","@stdlib/stats/iter/msumabs2":"itermsumabs2","@stdlib/math/iter/ops/multiply":"iterMultiply","@stdlib/math/iter/sequences/negafibonacci":"iterNegaFibonacciSeq","@stdlib/math/iter/sequences/negalucas":"iterNegaLucasSeq","@stdlib/math/iter/sequences/negative-even-integers":"iterNegativeEvenIntegersSeq","@stdlib/math/iter/sequences/negative-integers":"iterNegativeIntegersSeq","@stdlib/math/iter/sequences/negative-odd-integers":"iterNegativeOddIntegersSeq","@stdlib/iter/none":"iterNone","@stdlib/iter/none-by":"iterNoneBy","@stdlib/math/iter/sequences/nonfibonacci":"iterNonFibonacciSeq","@stdlib/math/iter/sequences/nonnegative-even-integers":"iterNonNegativeEvenIntegersSeq","@stdlib/math/iter/sequences/nonnegative-integers":"iterNonNegativeIntegersSeq","@stdlib/math/iter/sequences/nonpositive-even-integers":"iterNonPositiveEvenIntegersSeq","@stdlib/math/iter/sequences/nonpositive-integers":"iterNonPositiveIntegersSeq","@stdlib/math/iter/sequences/nonsquares":"iterNonSquaresSeq","@stdlib/iter/nth":"iterNth","@stdlib/math/iter/sequences/odd-integers":"iterOddIntegersSeq","@stdlib/simulate/iter/periodic-sinc":"iterPeriodicSinc","@stdlib/iter/pipeline":"iterPipeline","@stdlib/iter/pop":"iterPop","@stdlib/math/iter/sequences/positive-even-integers":"iterPositiveEvenIntegersSeq","@stdlib/math/iter/sequences/positive-integers":"iterPositiveIntegersSeq","@stdlib/math/iter/sequences/positive-odd-integers":"iterPositiveOddIntegersSeq","@stdlib/math/iter/special/pow":"iterPow","@stdlib/math/iter/sequences/primes":"iterPrimesSeq","@stdlib/stats/iter/prod":"iterprod","@stdlib/simulate/iter/pulse":"iterPulse","@stdlib/iter/push":"iterPush","@stdlib/math/iter/special/rad2deg":"iterRad2deg","@stdlib/math/iter/special/ramp":"iterRamp","@stdlib/stats/iter/range":"iterrange","@stdlib/iter/reject":"iterReject","@stdlib/iter/replicate":"iterReplicate","@stdlib/iter/replicate-by":"iterReplicateBy","@stdlib/math/iter/special/round":"iterRound","@stdlib/math/iter/special/round2":"iterRound2","@stdlib/math/iter/special/round10":"iterRound10","@stdlib/math/iter/special/rsqrt":"iterRsqrt","@stdlib/simulate/iter/sawtooth-wave":"iterSawtoothWave","@stdlib/iter/shift":"iterShift","@stdlib/math/iter/special/signum":"iterSignum","@stdlib/math/iter/special/sin":"iterSin","@stdlib/math/iter/special/sinc":"iterSinc","@stdlib/simulate/iter/sine-wave":"iterSineWave","@stdlib/math/iter/special/sinh":"iterSinh","@stdlib/math/iter/special/sinpi":"iterSinpi","@stdlib/iter/slice":"iterSlice","@stdlib/iter/some":"iterSome","@stdlib/iter/some-by":"iterSomeBy","@stdlib/math/iter/special/spence":"iterSpence","@stdlib/math/iter/special/sqrt":"iterSqrt","@stdlib/math/iter/special/sqrt1pm1":"iterSqrt1pm1","@stdlib/math/iter/sequences/squared-triangular":"iterSquaredTriangularSeq","@stdlib/math/iter/sequences/squares":"iterSquaresSeq","@stdlib/simulate/iter/square-wave":"iterSquareWave","@stdlib/stats/iter/stdev":"iterstdev","@stdlib/iter/step":"iterStep","@stdlib/iter/strided":"iterStrided","@stdlib/iter/strided-by":"iterStridedBy","@stdlib/math/iter/ops/subtract":"iterSubtract","@stdlib/stats/iter/sum":"itersum","@stdlib/stats/iter/sumabs":"itersumabs","@stdlib/stats/iter/sumabs2":"itersumabs2","@stdlib/math/iter/special/tan":"iterTan","@stdlib/math/iter/special/tanh":"iterTanh","@stdlib/iter/pipeline-thunk":"iterThunk","@stdlib/simulate/iter/triangle-wave":"iterTriangleWave","@stdlib/math/iter/sequences/triangular":"iterTriangularSeq","@stdlib/math/iter/sequences/tribonacci":"iterTribonnaciSeq","@stdlib/math/iter/special/trigamma":"iterTrigamma","@stdlib/math/iter/special/trunc":"iterTrunc","@stdlib/math/iter/special/trunc2":"iterTrunc2","@stdlib/math/iter/special/trunc10":"iterTrunc10","@stdlib/iter/union":"iterUnion","@stdlib/iter/unique":"iterUnique","@stdlib/iter/unique-by":"iterUniqueBy","@stdlib/iter/unique-by-hash":"iterUniqueByHash","@stdlib/iter/unitspace":"iterUnitspace","@stdlib/iter/unshift":"iterUnshift","@stdlib/iter/until-each":"iterUntilEach","@stdlib/stats/iter/variance":"itervariance","@stdlib/math/iter/special/vercos":"iterVercos","@stdlib/math/iter/special/versin":"iterVersin","@stdlib/iter/while-each":"iterWhileEach","@stdlib/math/iter/special/riemann-zeta":"iterZeta","@stdlib/streams/node/join":"joinStream","@stdlib/stats/kde2d":"kde2d","@stdlib/string/kebabcase":"kebabcase","@stdlib/utils/key-by":"keyBy","@stdlib/utils/key-by-right":"keyByRight","@stdlib/utils/keys-in":"keysIn","@stdlib/stats/kruskal-test":"kruskalTest","@stdlib/stats/kstest":"kstest","@stdlib/string/last":"last","@stdlib/nlp/lda":"lda","@stdlib/stats/levene-test":"leveneTest","@stdlib/dstructs/linked-list":"LinkedList","@stdlib/array/linspace":"linspace","@stdlib/datasets/liu-negative-opinion-words-en":"LIU_NEGATIVE_OPINION_WORDS_EN","@stdlib/datasets/liu-positive-opinion-words-en":"LIU_POSITIVE_OPINION_WORDS_EN","@stdlib/constants/float64/ln-half":"LN_HALF","@stdlib/constants/float64/ln-pi":"LN_PI","@stdlib/constants/float64/ln-sqrt-two-pi":"LN_SQRT_TWO_PI","@stdlib/constants/float64/ln-two-pi":"LN_TWO_PI","@stdlib/constants/float64/ln-two":"LN2","@stdlib/constants/float64/ln-ten":"LN10","@stdlib/constants/float64/log2-e":"LOG2E","@stdlib/constants/float64/log10-e":"LOG10E","@stdlib/array/logspace":"logspace","@stdlib/string/lowercase":"lowercase","@stdlib/utils/lowercase-keys":"lowercaseKeys","@stdlib/stats/lowess":"lowess","@stdlib/string/left-pad":"lpad","@stdlib/string/left-trim":"ltrim","@stdlib/string/left-trim-n":"ltrimN","@stdlib/datasets/male-first-names-en":"MALE_FIRST_NAMES_EN","@stdlib/utils/map":"map","@stdlib/utils/map2":"map2","@stdlib/utils/map2d":"map2d","@stdlib/utils/map2-right":"map2Right","@stdlib/utils/map3d":"map3d","@stdlib/utils/map4d":"map4d","@stdlib/utils/map5d":"map5d","@stdlib/utils/map-arguments":"mapArguments","@stdlib/utils/map-function":"mapFun","@stdlib/utils/async/map-function":"mapFunAsync","@stdlib/utils/map-keys":"mapKeys","@stdlib/utils/async/map-keys":"mapKeysAsync","@stdlib/utils/map-reduce":"mapReduce","@stdlib/utils/map-reduce-right":"mapReduceRight","@stdlib/utils/map-right":"mapRight","@stdlib/utils/map-values":"mapValues","@stdlib/utils/async/map-values":"mapValuesAsync","@stdlib/utils/mask-arguments":"maskArguments","@stdlib/constants/array/max-array-length":"MAX_ARRAY_LENGTH","@stdlib/constants/array/max-typed-array-length":"MAX_TYPED_ARRAY_LENGTH","@stdlib/ndarray/maybe-broadcast-array":"maybeBroadcastArray","@stdlib/ndarray/maybe-broadcast-arrays":"maybeBroadcastArrays","@stdlib/utils/memoize":"memoize","@stdlib/utils/merge":"merge","@stdlib/constants/time/milliseconds-in-day":"MILLISECONDS_IN_DAY","@stdlib/constants/time/milliseconds-in-hour":"MILLISECONDS_IN_HOUR","@stdlib/constants/time/milliseconds-in-minute":"MILLISECONDS_IN_MINUTE","@stdlib/constants/time/milliseconds-in-second":"MILLISECONDS_IN_SECOND","@stdlib/constants/time/milliseconds-in-week":"MILLISECONDS_IN_WEEK","@stdlib/datasets/minard-napoleons-march":"MINARD_NAPOLEONS_MARCH","@stdlib/constants/time/minutes-in-day":"MINUTES_IN_DAY","@stdlib/constants/time/minutes-in-hour":"MINUTES_IN_HOUR","@stdlib/constants/time/minutes-in-week":"MINUTES_IN_WEEK","@stdlib/time/minutes-in-month":"minutesInMonth","@stdlib/time/minutes-in-year":"minutesInYear","@stdlib/datasets/moby-dick":"MOBY_DICK","@stdlib/datasets/month-names-en":"MONTH_NAMES_EN","@stdlib/constants/time/months-in-year":"MONTHS_IN_YEAR","@stdlib/utils/move-property":"moveProperty","@stdlib/slice/multi":"MultiSlice","@stdlib/dstructs/named-typed-tuple":"namedtypedtuple","@stdlib/constants/float64/nan":"NAN","@stdlib/utils/nary-function":"naryFunction","@stdlib/utils/native-class":"nativeClass","@stdlib/ndarray/ctor":"ndarray","@stdlib/ndarray/to-array":"ndarray2array","@stdlib/ndarray/to-fancy":"ndarray2fancy","@stdlib/ndarray/to-json":"ndarray2json","@stdlib/ndarray/casting-modes":"ndarrayCastingModes","@stdlib/ndarray/data-buffer":"ndarrayDataBuffer","@stdlib/ndarray/dtype":"ndarrayDataType","@stdlib/ndarray/dtypes":"ndarrayDataTypes","@stdlib/ndarray/dispatch":"ndarrayDispatch","@stdlib/ndarray/flag":"ndarrayFlag","@stdlib/ndarray/flags":"ndarrayFlags","@stdlib/ndarray/index-modes":"ndarrayIndexModes","@stdlib/ndarray/ndarraylike2ndarray":"ndarraylike2ndarray","@stdlib/ndarray/min-dtype":"ndarrayMinDataType","@stdlib/ndarray/mostly-safe-casts":"ndarrayMostlySafeCasts","@stdlib/ndarray/next-dtype":"ndarrayNextDataType","@stdlib/ndarray/offset":"ndarrayOffset","@stdlib/ndarray/order":"ndarrayOrder","@stdlib/ndarray/orders":"ndarrayOrders","@stdlib/ndarray/promotion-rules":"ndarrayPromotionRules","@stdlib/ndarray/safe-casts":"ndarraySafeCasts","@stdlib/ndarray/same-kind-casts":"ndarraySameKindCasts","@stdlib/ndarray/shape":"ndarrayShape","@stdlib/ndarray/stride":"ndarrayStride","@stdlib/ndarray/strides":"ndarrayStrides","@stdlib/ndarray/at":"ndat","@stdlib/ndarray/empty":"ndempty","@stdlib/ndarray/empty-like":"ndemptyLike","@stdlib/ndarray/filter":"ndfilter","@stdlib/ndarray/filter-map":"ndfilterMap","@stdlib/ndarray/for-each":"ndforEach","@stdlib/ndarray/ndims":"ndims","@stdlib/ndarray/index":"ndindex","@stdlib/ndarray/iter/to-array-each":"nditer2arrayEach","@stdlib/ndarray/iter/column-entries":"nditerColumnEntries","@stdlib/ndarray/iter/columns":"nditerColumns","@stdlib/ndarray/iter/entries":"nditerEntries","@stdlib/ndarray/iter/indices":"nditerIndices","@stdlib/ndarray/iter/interleave-subarrays":"nditerInterleaveSubarrays","@stdlib/ndarray/iter/matrices":"nditerMatrices","@stdlib/ndarray/iter/matrix-entries":"nditerMatrixEntries","@stdlib/ndarray/iter/row-entries":"nditerRowEntries","@stdlib/ndarray/iter/rows":"nditerRows","@stdlib/ndarray/iter/select-dimension":"nditerSelectDimension","@stdlib/ndarray/iter/stacks":"nditerStacks","@stdlib/ndarray/iter/subarrays":"nditerSubarrays","@stdlib/ndarray/iter/values":"nditerValues","@stdlib/ndarray/map":"ndmap","@stdlib/ndarray/reject":"ndreject","@stdlib/ndarray/slice":"ndslice","@stdlib/ndarray/slice-assign":"ndsliceAssign","@stdlib/ndarray/slice-dimension":"ndsliceDimension","@stdlib/ndarray/slice-dimension-from":"ndsliceDimensionFrom","@stdlib/ndarray/slice-dimension-to":"ndsliceDimensionTo","@stdlib/ndarray/slice-from":"ndsliceFrom","@stdlib/ndarray/slice-to":"ndsliceTo","@stdlib/ndarray/zeros":"ndzeros","@stdlib/ndarray/zeros-like":"ndzerosLike","@stdlib/string/next-grapheme-cluster-break":"nextGraphemeClusterBreak","@stdlib/utils/next-tick":"nextTick","@stdlib/datasets/nightingales-rose":"NIGHTINGALES_ROSE","@stdlib/constants/float64/ninf":"NINF","@stdlib/process/node-version":"NODE_VERSION","@stdlib/utils/none":"none","@stdlib/utils/none-by":"noneBy","@stdlib/utils/async/none-by":"noneByAsync","@stdlib/utils/none-by-right":"noneByRight","@stdlib/utils/async/none-by-right":"noneByRightAsync","@stdlib/utils/none-in-by":"noneInBy","@stdlib/utils/nonenumerable-properties":"nonEnumerableProperties","@stdlib/utils/nonenumerable-properties-in":"nonEnumerablePropertiesIn","@stdlib/utils/nonenumerable-property-names":"nonEnumerablePropertyNames","@stdlib/utils/nonenumerable-property-names-in":"nonEnumerablePropertyNamesIn","@stdlib/utils/nonenumerable-property-symbols":"nonEnumerablePropertySymbols","@stdlib/utils/nonenumerable-property-symbols-in":"nonEnumerablePropertySymbolsIn","@stdlib/utils/none-own-by":"noneOwnBy","@stdlib/utils/nonindex-keys":"nonIndexKeys","@stdlib/utils/noop":"noop","@stdlib/time/now":"now","@stdlib/os/num-cpus":"NUM_CPUS","@stdlib/string/num2words":"num2words","@stdlib/number/ctor":"Number","@stdlib/ndarray/numel":"numel","@stdlib/ndarray/numel-dimension":"numelDimension","@stdlib/string/num-grapheme-clusters":"numGraphemeClusters","@stdlib/object/ctor":"Object","@stdlib/utils/entries":"objectEntries","@stdlib/utils/entries-in":"objectEntriesIn","@stdlib/utils/from-entries":"objectFromEntries","@stdlib/utils/object-inverse":"objectInverse","@stdlib/utils/object-inverse-by":"objectInverseBy","@stdlib/utils/keys":"objectKeys","@stdlib/utils/values":"objectValues","@stdlib/utils/values-in":"objectValuesIn","@stdlib/utils/omit":"omit","@stdlib/utils/omit-by":"omitBy","@stdlib/fs/open":"open","@stdlib/utils/open-url":"openURL","@stdlib/nlp/ordinalize":"ordinalize","@stdlib/datasets/pace-boston-house-prices":"PACE_BOSTON_HOUSE_PRICES","@stdlib/string/pad":"pad","@stdlib/stats/padjust":"padjust","@stdlib/utils/papply":"papply","@stdlib/utils/papply-right":"papplyRight","@stdlib/utils/parallel":"parallel","@stdlib/utils/parse-json":"parseJSON","@stdlib/string/pascalcase":"pascalcase","@stdlib/constants/path/delimiter":"PATH_DELIMITER","@stdlib/constants/path/delimiter-posix":"PATH_DELIMITER_POSIX","@stdlib/constants/path/delimiter-win32":"PATH_DELIMITER_WIN32","@stdlib/constants/path/sep":"PATH_SEP","@stdlib/constants/path/sep-posix":"PATH_SEP_POSIX","@stdlib/constants/path/sep-win32":"PATH_SEP_WIN32","@stdlib/stats/pcorrtest":"pcorrtest","@stdlib/string/percent-encode":"percentEncode","@stdlib/constants/float64/phi":"PHI","@stdlib/constants/float64/pi":"PI","@stdlib/constants/float64/pi-squared":"PI_SQUARED","@stdlib/utils/pick":"pick","@stdlib/utils/pick-arguments":"pickArguments","@stdlib/utils/pick-by":"pickBy","@stdlib/constants/float64/pinf":"PINF","@stdlib/namespace/pkg2alias":"pkg2alias","@stdlib/namespace/pkg2related":"pkg2related","@stdlib/namespace/pkg2standalone":"pkg2standalone","@stdlib/os/platform":"PLATFORM","@stdlib/plot":"plot","@stdlib/plot/ctor":"Plot","@stdlib/utils/pluck":"pluck","@stdlib/utils/pop":"pop","@stdlib/nlp/porter-stemmer":"porterStemmer","@stdlib/utils/prepend":"prepend","@stdlib/string/prev-grapheme-cluster-break":"prevGraphemeClusterBreak","@stdlib/datasets/primes-100k":"PRIMES_100K","@stdlib/utils/properties":"properties","@stdlib/utils/properties-in":"propertiesIn","@stdlib/utils/property-descriptor":"propertyDescriptor","@stdlib/utils/property-descriptor-in":"propertyDescriptorIn","@stdlib/utils/property-descriptors":"propertyDescriptors","@stdlib/utils/property-descriptors-in":"propertyDescriptorsIn","@stdlib/utils/property-names":"propertyNames","@stdlib/utils/property-names-in":"propertyNamesIn","@stdlib/utils/property-symbols":"propertySymbols","@stdlib/utils/property-symbols-in":"propertySymbolsIn","@stdlib/proxy/ctor":"Proxy","@stdlib/utils/push":"push","@stdlib/time/quarter-of-year":"quarterOfYear","@stdlib/random/array/arcsine":"random.array.arcsine","@stdlib/random/array/bernoulli":"random.array.bernoulli","@stdlib/random/array/beta":"random.array.beta","@stdlib/random/array/betaprime":"random.array.betaprime","@stdlib/random/array/binomial":"random.array.binomial","@stdlib/random/array/cauchy":"random.array.cauchy","@stdlib/random/array/chi":"random.array.chi","@stdlib/random/array/chisquare":"random.array.chisquare","@stdlib/random/array/cosine":"random.array.cosine","@stdlib/random/array/discrete-uniform":"random.array.discreteUniform","@stdlib/random/array/erlang":"random.array.erlang","@stdlib/random/array/exponential":"random.array.exponential","@stdlib/random/array/f":"random.array.f","@stdlib/random/array/frechet":"random.array.frechet","@stdlib/random/array/gamma":"random.array.gamma","@stdlib/random/array/geometric":"random.array.geometric","@stdlib/random/array/gumbel":"random.array.gumbel","@stdlib/random/array/hypergeometric":"random.array.hypergeometric","@stdlib/random/array/invgamma":"random.array.invgamma","@stdlib/random/array/kumaraswamy":"random.array.kumaraswamy","@stdlib/random/array/laplace":"random.array.laplace","@stdlib/random/array/levy":"random.array.levy","@stdlib/random/array/logistic":"random.array.logistic","@stdlib/random/array/lognormal":"random.array.lognormal","@stdlib/random/array/minstd":"random.array.minstd","@stdlib/random/array/minstd-shuffle":"random.array.minstdShuffle","@stdlib/random/array/mt19937":"random.array.mt19937","@stdlib/random/array/negative-binomial":"random.array.negativeBinomial","@stdlib/random/array/normal":"random.array.normal","@stdlib/random/array/pareto-type1":"random.array.pareto1","@stdlib/random/array/poisson":"random.array.poisson","@stdlib/random/array/randu":"random.array.randu","@stdlib/random/array/rayleigh":"random.array.rayleigh","@stdlib/random/array/t":"random.array.t","@stdlib/random/array/triangular":"random.array.triangular","@stdlib/random/array/uniform":"random.array.uniform","@stdlib/random/array/weibull":"random.array.weibull","@stdlib/random/iter/arcsine":"random.iterators.arcsine","@stdlib/random/iter/bernoulli":"random.iterators.bernoulli","@stdlib/random/iter/beta":"random.iterators.beta","@stdlib/random/iter/betaprime":"random.iterators.betaprime","@stdlib/random/iter/binomial":"random.iterators.binomial","@stdlib/random/iter/box-muller":"random.iterators.boxMuller","@stdlib/random/iter/cauchy":"random.iterators.cauchy","@stdlib/random/iter/chi":"random.iterators.chi","@stdlib/random/iter/chisquare":"random.iterators.chisquare","@stdlib/random/iter/cosine":"random.iterators.cosine","@stdlib/random/iter/discrete-uniform":"random.iterators.discreteUniform","@stdlib/random/iter/erlang":"random.iterators.erlang","@stdlib/random/iter/exponential":"random.iterators.exponential","@stdlib/random/iter/f":"random.iterators.f","@stdlib/random/iter/frechet":"random.iterators.frechet","@stdlib/random/iter/gamma":"random.iterators.gamma","@stdlib/random/iter/geometric":"random.iterators.geometric","@stdlib/random/iter/gumbel":"random.iterators.gumbel","@stdlib/random/iter/hypergeometric":"random.iterators.hypergeometric","@stdlib/random/iter/improved-ziggurat":"random.iterators.improvedZiggurat","@stdlib/random/iter/invgamma":"random.iterators.invgamma","@stdlib/random/iter/kumaraswamy":"random.iterators.kumaraswamy","@stdlib/random/iter/laplace":"random.iterators.laplace","@stdlib/random/iter/levy":"random.iterators.levy","@stdlib/random/iter/logistic":"random.iterators.logistic","@stdlib/random/iter/lognormal":"random.iterators.lognormal","@stdlib/random/iter/minstd":"random.iterators.minstd","@stdlib/random/iter/minstd-shuffle":"random.iterators.minstdShuffle","@stdlib/random/iter/mt19937":"random.iterators.mt19937","@stdlib/random/iter/negative-binomial":"random.iterators.negativeBinomial","@stdlib/random/iter/normal":"random.iterators.normal","@stdlib/random/iter/pareto-type1":"random.iterators.pareto1","@stdlib/random/iter/poisson":"random.iterators.poisson","@stdlib/random/iter/randi":"random.iterators.randi","@stdlib/random/iter/randn":"random.iterators.randn","@stdlib/random/iter/randu":"random.iterators.randu","@stdlib/random/iter/rayleigh":"random.iterators.rayleigh","@stdlib/random/iter/t":"random.iterators.t","@stdlib/random/iter/triangular":"random.iterators.triangular","@stdlib/random/iter/uniform":"random.iterators.uniform","@stdlib/random/iter/weibull":"random.iterators.weibull","@stdlib/random/streams/arcsine":"random.streams.arcsine","@stdlib/random/streams/bernoulli":"random.streams.bernoulli","@stdlib/random/streams/beta":"random.streams.beta","@stdlib/random/streams/betaprime":"random.streams.betaprime","@stdlib/random/streams/binomial":"random.streams.binomial","@stdlib/random/streams/box-muller":"random.streams.boxMuller","@stdlib/random/streams/cauchy":"random.streams.cauchy","@stdlib/random/streams/chi":"random.streams.chi","@stdlib/random/streams/chisquare":"random.streams.chisquare","@stdlib/random/streams/cosine":"random.streams.cosine","@stdlib/random/streams/discrete-uniform":"random.streams.discreteUniform","@stdlib/random/streams/erlang":"random.streams.erlang","@stdlib/random/streams/exponential":"random.streams.exponential","@stdlib/random/streams/f":"random.streams.f","@stdlib/random/streams/frechet":"random.streams.frechet","@stdlib/random/streams/gamma":"random.streams.gamma","@stdlib/random/streams/geometric":"random.streams.geometric","@stdlib/random/streams/gumbel":"random.streams.gumbel","@stdlib/random/streams/hypergeometric":"random.streams.hypergeometric","@stdlib/random/streams/improved-ziggurat":"random.streams.improvedZiggurat","@stdlib/random/streams/invgamma":"random.streams.invgamma","@stdlib/random/streams/kumaraswamy":"random.streams.kumaraswamy","@stdlib/random/streams/laplace":"random.streams.laplace","@stdlib/random/streams/levy":"random.streams.levy","@stdlib/random/streams/logistic":"random.streams.logistic","@stdlib/random/streams/lognormal":"random.streams.lognormal","@stdlib/random/streams/minstd":"random.streams.minstd","@stdlib/random/streams/minstd-shuffle":"random.streams.minstdShuffle","@stdlib/random/streams/mt19937":"random.streams.mt19937","@stdlib/random/streams/negative-binomial":"random.streams.negativeBinomial","@stdlib/random/streams/normal":"random.streams.normal","@stdlib/random/streams/pareto-type1":"random.streams.pareto1","@stdlib/random/streams/poisson":"random.streams.poisson","@stdlib/random/streams/randi":"random.streams.randi","@stdlib/random/streams/randn":"random.streams.randn","@stdlib/random/streams/randu":"random.streams.randu","@stdlib/random/streams/rayleigh":"random.streams.rayleigh","@stdlib/random/streams/t":"random.streams.t","@stdlib/random/streams/triangular":"random.streams.triangular","@stdlib/random/streams/uniform":"random.streams.uniform","@stdlib/random/streams/weibull":"random.streams.weibull","@stdlib/random/strided/arcsine":"random.strided.arcsine","@stdlib/random/strided/bernoulli":"random.strided.bernoulli","@stdlib/random/strided/beta":"random.strided.beta","@stdlib/random/strided/betaprime":"random.strided.betaprime","@stdlib/random/strided/chi":"random.strided.chi","@stdlib/random/strided/chisquare":"random.strided.chisquare","@stdlib/random/strided/cosine":"random.strided.cosine","@stdlib/random/strided/discrete-uniform":"random.strided.discreteUniform","@stdlib/random/strided/exponential":"random.strided.exponential","@stdlib/random/strided/gamma":"random.strided.gamma","@stdlib/random/strided/geometric":"random.strided.geometric","@stdlib/random/strided/invgamma":"random.strided.invgamma","@stdlib/random/strided/lognormal":"random.strided.lognormal","@stdlib/random/strided/minstd":"random.strided.minstd","@stdlib/random/strided/minstd-shuffle":"random.strided.minstdShuffle","@stdlib/random/strided/mt19937":"random.strided.mt19937","@stdlib/random/strided/normal":"random.strided.normal","@stdlib/random/strided/poisson":"random.strided.poisson","@stdlib/random/strided/randu":"random.strided.randu","@stdlib/random/strided/rayleigh":"random.strided.rayleigh","@stdlib/random/strided/t":"random.strided.t","@stdlib/random/strided/uniform":"random.strided.uniform","@stdlib/random/strided/weibull":"random.strided.weibull","@stdlib/stats/ranks":"ranks","@stdlib/fs/read-dir":"readDir","@stdlib/fs/read-file":"readFile","@stdlib/fs/read-file-list":"readFileList","@stdlib/fs/read-json":"readJSON","@stdlib/fs/read-wasm":"readWASM","@stdlib/complex/float64/real":"real","@stdlib/array/typed-real":"realarray","@stdlib/array/typed-real-ctors":"realarrayCtors","@stdlib/array/typed-real-dtypes":"realarrayDataTypes","@stdlib/complex/float32/real":"realf","@stdlib/utils/real-max":"realmax","@stdlib/utils/real-min":"realmin","@stdlib/regexp/basename":"reBasename","@stdlib/regexp/basename-posix":"reBasenamePosix","@stdlib/regexp/basename-windows":"reBasenameWindows","@stdlib/regexp/color-hexadecimal":"reColorHexadecimal","@stdlib/regexp/decimal-number":"reDecimalNumber","@stdlib/regexp/dirname":"reDirname","@stdlib/regexp/dirname-posix":"reDirnamePosix","@stdlib/regexp/dirname-windows":"reDirnameWindows","@stdlib/utils/reduce":"reduce","@stdlib/utils/reduce2d":"reduce2d","@stdlib/utils/async/reduce":"reduceAsync","@stdlib/utils/reduce-right":"reduceRight","@stdlib/utils/async/reduce-right":"reduceRightAsync","@stdlib/regexp/duration-string":"reDurationString","@stdlib/regexp/eol":"reEOL","@stdlib/regexp/extended-length-path":"reExtendedLengthPath","@stdlib/regexp/extname":"reExtname","@stdlib/regexp/extname-posix":"reExtnamePosix","@stdlib/regexp/extname-windows":"reExtnameWindows","@stdlib/regexp/filename":"reFilename","@stdlib/regexp/filename-posix":"reFilenamePosix","@stdlib/regexp/filename-windows":"reFilenameWindows","@stdlib/utils/regexp-from-string":"reFromString","@stdlib/regexp/function-name":"reFunctionName","@stdlib/regexp/to-json":"regexp2json","@stdlib/complex/float64/reim":"reim","@stdlib/complex/float32/reim":"reimf","@stdlib/utils/reject-arguments":"rejectArguments","@stdlib/string/remove-first":"removeFirst","@stdlib/string/remove-last":"removeLast","@stdlib/string/remove-punctuation":"removePunctuation","@stdlib/string/remove-utf8-bom":"removeUTF8BOM","@stdlib/string/remove-words":"removeWords","@stdlib/fs/rename":"rename","@stdlib/regexp/native-function":"reNativeFunction","@stdlib/utils/reorder-arguments":"reorderArguments","@stdlib/string/repeat":"repeat","@stdlib/string/replace":"replace","@stdlib/string/replace-before":"replaceBefore","@stdlib/regexp/regexp":"reRegExp","@stdlib/utils/escape-regexp-string":"rescape","@stdlib/regexp/semver":"reSemVer","@stdlib/fs/resolve-parent-path":"resolveParentPath","@stdlib/fs/resolve-parent-path-by":"resolveParentPathBy","@stdlib/regexp/unc-path":"reUncPath","@stdlib/regexp/utf16-surrogate-pair":"reUtf16SurrogatePair","@stdlib/regexp/utf16-unpaired-surrogate":"reUtf16UnpairedSurrogate","@stdlib/utils/reverse-arguments":"reverseArguments","@stdlib/string/reverse":"reverseString","@stdlib/random/base/reviver":"reviveBasePRNG","@stdlib/buffer/reviver":"reviveBuffer","@stdlib/complex/reviver":"reviveComplex","@stdlib/complex/float32/reviver":"reviveComplex64","@stdlib/complex/float64/reviver":"reviveComplex128","@stdlib/error/reviver":"reviveError","@stdlib/regexp/reviver":"reviveRegExp","@stdlib/array/reviver":"reviveTypedArray","@stdlib/regexp/whitespace":"reWhitespace","@stdlib/string/right-pad":"rpad","@stdlib/string/right-trim":"rtrim","@stdlib/string/right-trim-n":"rtrimN","@stdlib/utils/safe-int-max":"safeintmax","@stdlib/utils/safe-int-min":"safeintmin","@stdlib/random/sample":"sample","@stdlib/datasets/savoy-stopwords-fin":"SAVOY_STOPWORDS_FIN","@stdlib/datasets/savoy-stopwords-fr":"SAVOY_STOPWORDS_FR","@stdlib/datasets/savoy-stopwords-ger":"SAVOY_STOPWORDS_GER","@stdlib/datasets/savoy-stopwords-it":"SAVOY_STOPWORDS_IT","@stdlib/datasets/savoy-stopwords-por":"SAVOY_STOPWORDS_POR","@stdlib/datasets/savoy-stopwords-sp":"SAVOY_STOPWORDS_SP","@stdlib/datasets/savoy-stopwords-swe":"SAVOY_STOPWORDS_SWE","@stdlib/array/from-scalar":"scalar2array","@stdlib/ndarray/from-scalar":"scalar2ndarray","@stdlib/blas/sdot":"sdot","@stdlib/constants/time/seconds-in-day":"SECONDS_IN_DAY","@stdlib/constants/time/seconds-in-hour":"SECONDS_IN_HOUR","@stdlib/constants/time/seconds-in-minute":"SECONDS_IN_MINUTE","@stdlib/constants/time/seconds-in-week":"SECONDS_IN_WEEK","@stdlib/time/seconds-in-month":"secondsInMonth","@stdlib/time/seconds-in-year":"secondsInYear","@stdlib/nlp/sentencize":"sentencize","@stdlib/slice/seq2slice":"seq2slice","@stdlib/utils/define-configurable-read-only-property":"setConfigurableReadOnly","@stdlib/utils/define-configurable-read-only-accessor":"setConfigurableReadOnlyAccessor","@stdlib/utils/define-configurable-read-write-accessor":"setConfigurableReadWriteAccessor","@stdlib/utils/define-configurable-write-only-accessor":"setConfigurableWriteOnlyAccessor","@stdlib/utils/define-memoized-configurable-read-only-property":"setMemoizedConfigurableReadOnly","@stdlib/utils/define-memoized-read-only-property":"setMemoizedReadOnly","@stdlib/utils/define-nonenumerable-property":"setNonEnumerableProperty","@stdlib/utils/define-nonenumerable-read-only-property":"setNonEnumerableReadOnly","@stdlib/utils/define-nonenumerable-read-only-accessor":"setNonEnumerableReadOnlyAccessor","@stdlib/utils/define-nonenumerable-read-write-accessor":"setNonEnumerableReadWriteAccessor","@stdlib/utils/define-nonenumerable-write-only-accessor":"setNonEnumerableWriteOnlyAccessor","@stdlib/utils/define-read-only-property":"setReadOnly","@stdlib/utils/define-read-only-accessor":"setReadOnlyAccessor","@stdlib/utils/define-read-write-accessor":"setReadWriteAccessor","@stdlib/utils/define-write-only-accessor":"setWriteOnlyAccessor","@stdlib/array/shared-buffer":"SharedArrayBuffer","@stdlib/utils/shift":"shift","@stdlib/random/shuffle":"shuffle","@stdlib/utils/size-of":"sizeOf","@stdlib/slice/ctor":"Slice","@stdlib/string/snakecase":"snakecase","@stdlib/utils/some":"some","@stdlib/utils/some-by":"someBy","@stdlib/utils/async/some-by":"someByAsync","@stdlib/utils/some-by-right":"someByRight","@stdlib/utils/async/some-by-right":"someByRightAsync","@stdlib/utils/some-in-by":"someInBy","@stdlib/utils/some-own-by":"someOwnBy","@stdlib/datasets/sotu":"SOTU","@stdlib/datasets/spache-revised":"SPACHE_REVISED","@stdlib/datasets/spam-assassin":"SPAM_ASSASSIN","@stdlib/plot/sparklines/base/ctor":"SparklineBase","@stdlib/array/to-sparse-iterator":"sparsearray2iterator","@stdlib/array/to-sparse-iterator-right":"sparsearray2iteratorRight","@stdlib/streams/node/split":"splitStream","@stdlib/constants/float64/sqrt-eps":"SQRT_EPS","@stdlib/constants/float64/sqrt-half":"SQRT_HALF","@stdlib/constants/float64/sqrt-half-pi":"SQRT_HALF_PI","@stdlib/constants/float64/sqrt-phi":"SQRT_PHI","@stdlib/constants/float64/sqrt-pi":"SQRT_PI","@stdlib/constants/float64/sqrt-three":"SQRT_THREE","@stdlib/constants/float64/sqrt-two":"SQRT_TWO","@stdlib/constants/float64/sqrt-two-pi":"SQRT_TWO_PI","@stdlib/datasets/ssa-us-births-2000-2014":"SSA_US_BIRTHS_2000_2014","@stdlib/blas/sswap":"sswap","@stdlib/dstructs/stack":"Stack","@stdlib/namespace/standalone2pkg":"standalone2pkg","@stdlib/datasets/standard-card-deck":"STANDARD_CARD_DECK","@stdlib/string/startcase":"startcase","@stdlib/string/starts-with":"startsWith","@stdlib/datasets/stopwords-en":"STOPWORDS_EN","@stdlib/math/strided/special/abs":"strided.abs","@stdlib/math/strided/special/abs2":"strided.abs2","@stdlib/math/strided/special/abs2-by":"strided.abs2By","@stdlib/math/strided/special/abs-by":"strided.absBy","@stdlib/math/strided/special/acos-by":"strided.acosBy","@stdlib/math/strided/special/acosh-by":"strided.acoshBy","@stdlib/math/strided/special/acot-by":"strided.acotBy","@stdlib/math/strided/special/acoth-by":"strided.acothBy","@stdlib/math/strided/special/acovercos-by":"strided.acovercosBy","@stdlib/math/strided/special/acoversin-by":"strided.acoversinBy","@stdlib/math/strided/ops/add":"strided.add","@stdlib/math/strided/ops/add-by":"strided.addBy","@stdlib/math/strided/special/ahavercos-by":"strided.ahavercosBy","@stdlib/math/strided/special/ahaversin-by":"strided.ahaversinBy","@stdlib/math/strided/special/asin-by":"strided.asinBy","@stdlib/math/strided/special/asinh-by":"strided.asinhBy","@stdlib/math/strided/special/atan-by":"strided.atanBy","@stdlib/math/strided/special/atanh-by":"strided.atanhBy","@stdlib/math/strided/special/avercos-by":"strided.avercosBy","@stdlib/math/strided/special/aversin-by":"strided.aversinBy","@stdlib/math/strided/special/besselj0-by":"strided.besselj0By","@stdlib/math/strided/special/besselj1-by":"strided.besselj1By","@stdlib/math/strided/special/bessely0-by":"strided.bessely0By","@stdlib/math/strided/special/bessely1-by":"strided.bessely1By","@stdlib/math/strided/special/binet-by":"strided.binetBy","@stdlib/math/strided/special/cbrt":"strided.cbrt","@stdlib/math/strided/special/cbrt-by":"strided.cbrtBy","@stdlib/math/strided/special/ceil":"strided.ceil","@stdlib/math/strided/special/cos-by":"strided.cosBy","@stdlib/math/strided/special/deg2rad":"strided.deg2rad","@stdlib/strided/dtypes":"strided.dataTypes","@stdlib/math/strided/special/dcbrt-by":"strided.dcbrtBy","@stdlib/strided/dispatch":"strided.dispatch","@stdlib/strided/dispatch-by":"strided.dispatchBy","@stdlib/math/strided/special/floor":"strided.floor","@stdlib/math/strided/special/inv":"strided.inv","@stdlib/math/strided/ops/mul":"strided.mul","@stdlib/math/strided/ops/mul-by":"strided.mulBy","@stdlib/math/strided/special/ramp":"strided.ramp","@stdlib/math/strided/special/rsqrt":"strided.rsqrt","@stdlib/math/strided/special/sin-by":"strided.sinBy","@stdlib/math/strided/special/sqrt":"strided.sqrt","@stdlib/math/strided/special/sqrt-by":"strided.sqrtBy","@stdlib/math/strided/ops/sub":"strided.sub","@stdlib/math/strided/ops/sub-by":"strided.subBy","@stdlib/math/strided/special/trunc":"strided.trunc","@stdlib/array/to-strided-iterator":"stridedarray2iterator","@stdlib/streams/node/from-strided-array":"stridedArrayStream","@stdlib/buffer/from-string":"string2buffer","@stdlib/ndarray/sub2ind":"sub2ind","@stdlib/string/substring-after":"substringAfter","@stdlib/string/substring-after-last":"substringAfterLast","@stdlib/string/substring-before":"substringBefore","@stdlib/string/substring-before-last":"substringBeforeLast","@stdlib/datasets/suthaharan-multi-hop-sensor-network":"SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK","@stdlib/datasets/suthaharan-single-hop-sensor-network":"SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK","@stdlib/symbol/ctor":"Symbol","@stdlib/utils/tabulate":"tabulate","@stdlib/utils/tabulate-by":"tabulateBy","@stdlib/utils/async/tabulate-by":"tabulateByAsync","@stdlib/function/thunk":"thunk","@stdlib/time/tic":"tic","@stdlib/utils/timeit":"timeit","@stdlib/os/tmpdir":"tmpdir","@stdlib/time/toc":"toc","@stdlib/nlp/tokenize":"tokenize","@stdlib/streams/node/transform":"transformStream","@stdlib/string/trim":"trim","@stdlib/string/truncate":"truncate","@stdlib/string/truncate-middle":"truncateMiddle","@stdlib/utils/try-catch":"trycatch","@stdlib/utils/async/try-catch":"trycatchAsync","@stdlib/utils/try-function":"tryFunction","@stdlib/utils/try-require":"tryRequire","@stdlib/utils/try-then":"trythen","@stdlib/utils/async/try-then":"trythenAsync","@stdlib/stats/ttest":"ttest","@stdlib/stats/ttest2":"ttest2","@stdlib/constants/float64/two-pi":"TWO_PI","@stdlib/array/typed":"typedarray","@stdlib/array/to-json":"typedarray2json","@stdlib/array/typed-ctors":"typedarrayCtors","@stdlib/array/typed-dtypes":"typedarrayDataTypes","@stdlib/array/pool":"typedarraypool","@stdlib/utils/type-max":"typemax","@stdlib/utils/type-min":"typemin","@stdlib/utils/type-of":"typeOf","@stdlib/constants/uint8/max":"UINT8_MAX","@stdlib/constants/uint8/num-bytes":"UINT8_NUM_BYTES","@stdlib/array/uint8":"Uint8Array","@stdlib/array/uint8c":"Uint8ClampedArray","@stdlib/constants/uint16/max":"UINT16_MAX","@stdlib/constants/uint16/num-bytes":"UINT16_NUM_BYTES","@stdlib/array/uint16":"Uint16Array","@stdlib/constants/uint32/max":"UINT32_MAX","@stdlib/constants/uint32/num-bytes":"UINT32_NUM_BYTES","@stdlib/array/uint32":"Uint32Array","@stdlib/process/umask":"umask","@stdlib/string/uncapitalize":"uncapitalize","@stdlib/utils/uncapitalize-keys":"uncapitalizeKeys","@stdlib/utils/uncurry":"uncurry","@stdlib/utils/uncurry-right":"uncurryRight","@stdlib/constants/unicode/max":"UNICODE_MAX","@stdlib/constants/unicode/max-bmp":"UNICODE_MAX_BMP","@stdlib/plot/sparklines/unicode/column":"UnicodeColumnChartSparkline","@stdlib/plot/sparklines/unicode/line":"UnicodeLineChartSparkline","@stdlib/plot/sparklines/unicode":"UnicodeSparkline","@stdlib/plot/sparklines/unicode/tristate":"UnicodeTristateChartSparkline","@stdlib/plot/sparklines/unicode/up-down":"UnicodeUpDownChartSparkline","@stdlib/plot/sparklines/unicode/win-loss":"UnicodeWinLossChartSparkline","@stdlib/fs/unlink":"unlink","@stdlib/utils/unshift":"unshift","@stdlib/utils/until":"until","@stdlib/utils/async/until":"untilAsync","@stdlib/utils/until-each":"untilEach","@stdlib/utils/until-each-right":"untilEachRight","@stdlib/utils/unzip":"unzip","@stdlib/string/uppercase":"uppercase","@stdlib/utils/uppercase-keys":"uppercaseKeys","@stdlib/datasets/us-states-abbr":"US_STATES_ABBR","@stdlib/datasets/us-states-capitals":"US_STATES_CAPITALS","@stdlib/datasets/us-states-capitals-names":"US_STATES_CAPITALS_NAMES","@stdlib/datasets/us-states-names":"US_STATES_NAMES","@stdlib/datasets/us-states-names-capitals":"US_STATES_NAMES_CAPITALS","@stdlib/string/utf16-to-utf8-array":"utf16ToUTF8Array","@stdlib/stats/vartest":"vartest","@stdlib/utils/async/series-waterfall":"waterfall","@stdlib/wasm/memory":"WebAssemblyMemory","@stdlib/utils/async/while":"whileAsync","@stdlib/utils/while-each":"whileEach","@stdlib/utils/while-each-right":"whileEachRight","@stdlib/utils/while":"whilst","@stdlib/stats/wilcoxon":"wilcoxon","@stdlib/utils/writable-properties":"writableProperties","@stdlib/utils/writable-properties-in":"writablePropertiesIn","@stdlib/utils/writable-property-names":"writablePropertyNames","@stdlib/utils/writable-property-names-in":"writablePropertyNamesIn","@stdlib/utils/writable-property-symbols":"writablePropertySymbols","@stdlib/utils/writable-property-symbols-in":"writablePropertySymbolsIn","@stdlib/fs/write-file":"writeFile","@stdlib/utils/zip":"zip","@stdlib/stats/ztest":"ztest","@stdlib/stats/ztest2":"ztest2"} diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv index a187a08f8ea2..d4dc3f378262 100644 --- a/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv +++ b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv @@ -1480,8 +1480,8 @@ "@stdlib/math/base/special/truncn","@stdlib/math/base/special/ceiln,@stdlib/math/base/special/floorn,@stdlib/math/base/special/roundn,@stdlib/math/base/special/trunc,@stdlib/math/base/special/truncb" "@stdlib/math/base/special/truncsd","@stdlib/math/base/special/ceilsd,@stdlib/math/base/special/floorsd,@stdlib/math/base/special/roundsd,@stdlib/math/base/special/trunc" "@stdlib/number/uint32/base/to-int32","" -"@stdlib/math/base/ops/umul","@stdlib/math/base/ops/imul" -"@stdlib/math/base/ops/umuldw","@stdlib/math/base/ops/imuldw,@stdlib/math/base/ops/umul" +"@stdlib/number/uint32/base/mul","@stdlib/math/base/ops/imul" +"@stdlib/math/base/ops/umuldw","@stdlib/math/base/ops/imuldw,@stdlib/number/uint32/base/mul" "@stdlib/string/base/uncapitalize","@stdlib/string/base/capitalize" "@stdlib/string/base/uppercase","@stdlib/string/base/lowercase" "@stdlib/math/base/special/vercos","@stdlib/math/base/special/cos,@stdlib/math/base/special/versin" diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json index b758a167f733..cf67324e0bea 100644 --- a/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json +++ b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json @@ -1 +1 @@ -{"@stdlib/math/special/abs":[],"@stdlib/array/cartesian-power":["@stdlib/array/cartesian-product","@stdlib/array/cartesian-square"],"@stdlib/array/cartesian-product":["@stdlib/array/cartesian-power","@stdlib/array/cartesian-square"],"@stdlib/array/cartesian-square":["@stdlib/array/cartesian-power","@stdlib/array/cartesian-product"],"@stdlib/string/acronym":[],"@stdlib/array/empty":["@stdlib/array/empty-like","@stdlib/array/full","@stdlib/array/ones","@stdlib/array/zeros","@stdlib/ndarray/empty"],"@stdlib/array/empty-like":["@stdlib/array/empty","@stdlib/array/full-like","@stdlib/array/ones-like","@stdlib/array/zeros-like","@stdlib/ndarray/empty-like"],"@stdlib/datasets/afinn-96":["@stdlib/datasets/afinn-111"],"@stdlib/datasets/afinn-111":["@stdlib/datasets/afinn-96"],"@stdlib/array/full":["@stdlib/array/full-like","@stdlib/array/ones","@stdlib/array/zeros"],"@stdlib/array/full-like":["@stdlib/array/full","@stdlib/array/ones-like","@stdlib/array/zeros-like"],"@stdlib/namespace/alias2pkg":["@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias"],"@stdlib/namespace/alias2related":["@stdlib/namespace/alias2pkg","@stdlib/namespace/aliases","@stdlib/namespace/pkg2related"],"@stdlib/namespace/alias2standalone":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias","@stdlib/namespace/pkg2standalone"],"@stdlib/namespace/aliases":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2related","@stdlib/namespace/pkg2alias"],"@stdlib/buffer/alloc-unsafe":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/mskfilter":["@stdlib/array/mskreject"],"@stdlib/array/mskput":["@stdlib/array/place","@stdlib/array/put","@stdlib/array/take"],"@stdlib/array/mskreject":["@stdlib/array/mskfilter"],"@stdlib/array/nans":["@stdlib/array/full","@stdlib/array/nans-like","@stdlib/array/ones","@stdlib/array/zeros"],"@stdlib/array/nans-like":["@stdlib/array/full-like","@stdlib/array/nans","@stdlib/array/ones-like","@stdlib/array/zeros-like"],"@stdlib/stats/anova1":[],"@stdlib/datasets/anscombes-quartet":[],"@stdlib/utils/any":["@stdlib/utils/any-by","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some"],"@stdlib/utils/any-by":["@stdlib/utils/async/any-by","@stdlib/utils/any-by-right","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some-by"],"@stdlib/utils/async/any-by":["@stdlib/utils/any-by","@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/async/some-by"],"@stdlib/utils/any-by-right":["@stdlib/utils/any-by","@stdlib/utils/async/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by-right"],"@stdlib/utils/async/any-by-right":["@stdlib/utils/async/any-by","@stdlib/utils/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/any-in-by":["@stdlib/utils/any-by","@stdlib/utils/any-own-by","@stdlib/utils/every-in-by","@stdlib/utils/some-in-by"],"@stdlib/utils/any-own-by":["@stdlib/utils/any-by","@stdlib/utils/any-in-by","@stdlib/utils/every-own-by","@stdlib/utils/some-own-by"],"@stdlib/array/ones":["@stdlib/array/full","@stdlib/array/nans","@stdlib/array/ones-like","@stdlib/array/zeros"],"@stdlib/array/ones-like":["@stdlib/array/full-like","@stdlib/array/nans-like","@stdlib/array/ones","@stdlib/array/zeros-like"],"@stdlib/array/one-to":["@stdlib/array/full","@stdlib/array/ones","@stdlib/array/one-to-like","@stdlib/array/zero-to"],"@stdlib/array/one-to-like":["@stdlib/array/full-like","@stdlib/array/ones-like","@stdlib/array/one-to","@stdlib/array/zero-to-like"],"@stdlib/constants/float64/apery":[],"@stdlib/array/place":["@stdlib/array/mskput","@stdlib/array/put","@stdlib/array/take"],"@stdlib/utils/append":["@stdlib/utils/prepend","@stdlib/utils/push"],"@stdlib/array/put":["@stdlib/array/mskput","@stdlib/array/place","@stdlib/array/take"],"@stdlib/os/arch":["@stdlib/os/platform"],"@stdlib/utils/argument-function":["@stdlib/utils/constant-function","@stdlib/utils/identity-function"],"@stdlib/process/argv":["@stdlib/process/env"],"@stdlib/ndarray/array":["@stdlib/ndarray/ctor"],"@stdlib/buffer/from-array":["@stdlib/buffer/ctor","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/to-fancy":["@stdlib/array/slice","@stdlib/ndarray/fancy"],"@stdlib/array/to-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-circular-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-strided-iterator"],"@stdlib/array/to-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator"],"@stdlib/array/buffer":["@stdlib/buffer/ctor","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/shared-buffer","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/buffer/from-arraybuffer":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/ctors":["@stdlib/array/typed-ctors"],"@stdlib/array/dtype":["@stdlib/array/dtypes"],"@stdlib/array/dtypes":["@stdlib/array/typed-dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/index":["@stdlib/array/to-fancy"],"@stdlib/array/min-dtype":["@stdlib/array/dtypes","@stdlib/array/promotion-rules","@stdlib/array/safe-casts"],"@stdlib/array/mostly-safe-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/array/same-kind-casts","@stdlib/ndarray/mostly-safe-casts"],"@stdlib/array/next-dtype":["@stdlib/array/dtype","@stdlib/array/dtypes"],"@stdlib/array/promotion-rules":["@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/ndarray/promotion-rules"],"@stdlib/array/safe-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/mostly-safe-casts","@stdlib/array/same-kind-casts","@stdlib/ndarray/safe-casts"],"@stdlib/array/same-kind-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/ndarray/same-kind-casts"],"@stdlib/array/shape":["@stdlib/ndarray/ctor"],"@stdlib/streams/node/from-array":["@stdlib/streams/node/from-circular-array","@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-strided-array"],"@stdlib/array/to-view-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator","@stdlib/array/to-strided-iterator","@stdlib/array/to-view-iterator-right"],"@stdlib/array/to-view-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-strided-iterator","@stdlib/array/to-view-iterator"],"@stdlib/array/slice":["@stdlib/array/take"],"@stdlib/symbol/async-iterator":["@stdlib/symbol/ctor","@stdlib/symbol/iterator"],"@stdlib/array/take":["@stdlib/array/put","@stdlib/array/slice"],"@stdlib/array/zeros":["@stdlib/array/empty","@stdlib/array/full","@stdlib/array/nans","@stdlib/array/ones","@stdlib/array/zeros-like","@stdlib/ndarray/zeros"],"@stdlib/array/zeros-like":["@stdlib/array/empty-like","@stdlib/array/full-like","@stdlib/array/nans-like","@stdlib/array/ones-like","@stdlib/array/zeros","@stdlib/ndarray/zeros-like"],"@stdlib/array/zero-to":["@stdlib/array/empty","@stdlib/array/full","@stdlib/array/one-to","@stdlib/array/zero-to-like","@stdlib/array/zeros"],"@stdlib/array/zero-to-like":["@stdlib/array/empty-like","@stdlib/array/full-like","@stdlib/array/nans-like","@stdlib/array/one-to-like","@stdlib/array/ones-like","@stdlib/array/zero-to","@stdlib/array/zeros-like"],"@stdlib/stats/bartlett-test":["@stdlib/stats/vartest","@stdlib/stats/levene-test"],"@stdlib/math/base/special/abs":["@stdlib/math/base/special/abs2","@stdlib/math/base/special/absf","@stdlib/math/base/special/labs"],"@stdlib/math/base/special/abs2":["@stdlib/math/base/special/abs","@stdlib/math/base/special/abs2f"],"@stdlib/math/base/special/abs2f":["@stdlib/math/base/special/abs2","@stdlib/math/base/special/absf"],"@stdlib/math/base/utils/absolute-difference":["@stdlib/math/base/utils/relative-difference","@stdlib/math/base/utils/float64-epsilon-difference"],"@stdlib/math/base/special/absf":["@stdlib/math/base/special/abs","@stdlib/math/base/special/abs2f","@stdlib/math/base/special/labs"],"@stdlib/array/base/cartesian-power":["@stdlib/array/cartesian-power","@stdlib/array/base/cartesian-product","@stdlib/array/base/cartesian-square"],"@stdlib/array/base/cartesian-product":["@stdlib/array/cartesian-product","@stdlib/array/base/cartesian-power","@stdlib/array/base/cartesian-square"],"@stdlib/array/base/cartesian-square":["@stdlib/array/cartesian-square","@stdlib/array/base/cartesian-power","@stdlib/array/base/cartesian-product"],"@stdlib/math/base/special/acos":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asin","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/acosd":["@stdlib/math/base/special/acos","@stdlib/math/base/special/acosh","@stdlib/math/base/special/asind","@stdlib/math/base/special/atand"],"@stdlib/math/base/special/acosf":["@stdlib/math/base/special/acos","@stdlib/math/base/special/acosh","@stdlib/math/base/special/asinf","@stdlib/math/base/special/atanf"],"@stdlib/math/base/special/acosh":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/acot":["@stdlib/math/base/special/acoth","@stdlib/math/base/special/atan","@stdlib/math/base/special/cot"],"@stdlib/math/base/special/acotd":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acoth","@stdlib/math/base/special/atand","@stdlib/math/base/special/cotd"],"@stdlib/math/base/special/acotf":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acoth","@stdlib/math/base/special/atanf"],"@stdlib/math/base/special/acoth":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/acot","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/acovercos":["@stdlib/math/base/special/acoversin","@stdlib/math/base/special/avercos","@stdlib/math/base/special/covercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/acoversin":["@stdlib/math/base/special/acovercos","@stdlib/math/base/special/aversin","@stdlib/math/base/special/coversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/acsc":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asec","@stdlib/math/base/special/asin","@stdlib/math/base/special/csc"],"@stdlib/math/base/special/acscd":["@stdlib/math/base/special/acsc","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asecd","@stdlib/math/base/special/asind","@stdlib/math/base/special/cscd"],"@stdlib/math/base/special/acscdf":["@stdlib/math/base/special/acsc","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asecdf","@stdlib/math/base/special/asindf"],"@stdlib/math/base/special/acscf":["@stdlib/math/base/special/acsc","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asecf","@stdlib/math/base/special/asinf"],"@stdlib/math/base/special/acsch":["@stdlib/math/base/special/acoth","@stdlib/math/base/special/acsc","@stdlib/math/base/special/asech","@stdlib/math/base/special/asinh","@stdlib/math/base/special/csc","@stdlib/math/base/special/csch"],"@stdlib/number/float64/base/add":["@stdlib/number/float64/base/div","@stdlib/number/float64/base/mul","@stdlib/number/float64/base/sub"],"@stdlib/number/float64/base/add3":["@stdlib/number/float64/base/add"],"@stdlib/number/float64/base/add4":["@stdlib/number/float64/base/add"],"@stdlib/number/float64/base/add5":["@stdlib/number/float64/base/add"],"@stdlib/number/float32/base/add":["@stdlib/number/float64/base/add","@stdlib/number/float32/base/div","@stdlib/number/float32/base/mul","@stdlib/math/base/ops/subf"],"@stdlib/array/base/filled":[],"@stdlib/array/base/filled2d":[],"@stdlib/array/base/filled2d-by":["@stdlib/array/base/filled2d"],"@stdlib/array/base/filled3d":[],"@stdlib/array/base/filled3d-by":["@stdlib/array/base/filled3d"],"@stdlib/array/base/filled4d":[],"@stdlib/array/base/filled4d-by":["@stdlib/array/base/filled4d"],"@stdlib/array/base/filled5d":[],"@stdlib/array/base/filled5d-by":["@stdlib/array/base/filled5d"],"@stdlib/array/base/filled-by":["@stdlib/array/base/filled"],"@stdlib/array/base/fillednd":[],"@stdlib/array/base/fillednd-by":["@stdlib/array/base/fillednd"],"@stdlib/array/base/filter":[],"@stdlib/array/base/first":[],"@stdlib/array/base/flatten":["@stdlib/array/base/flatten-by"],"@stdlib/array/base/flatten2d":["@stdlib/array/base/flatten2d-by"],"@stdlib/array/base/flatten2d-by":["@stdlib/array/base/flatten2d"],"@stdlib/array/base/flatten3d":["@stdlib/array/base/flatten3d-by"],"@stdlib/array/base/flatten3d-by":["@stdlib/array/base/flatten3d"],"@stdlib/array/base/flatten4d":["@stdlib/array/base/flatten4d-by"],"@stdlib/array/base/flatten4d-by":["@stdlib/array/base/flatten4d"],"@stdlib/array/base/flatten5d":["@stdlib/array/base/flatten5d-by"],"@stdlib/array/base/flatten5d-by":["@stdlib/array/base/flatten5d"],"@stdlib/array/base/flatten-by":["@stdlib/array/base/flatten"],"@stdlib/array/base/fliplr2d":["@stdlib/array/base/fliplr3d","@stdlib/array/base/fliplr4d","@stdlib/array/base/fliplr5d"],"@stdlib/array/base/fliplr3d":["@stdlib/array/base/fliplr2d","@stdlib/array/base/fliplr4d","@stdlib/array/base/fliplr5d"],"@stdlib/array/base/fliplr4d":["@stdlib/array/base/fliplr2d","@stdlib/array/base/fliplr3d","@stdlib/array/base/fliplr5d"],"@stdlib/array/base/fliplr5d":["@stdlib/array/base/fliplr2d","@stdlib/array/base/fliplr3d","@stdlib/array/base/fliplr4d"],"@stdlib/array/base/flipud2d":["@stdlib/array/base/flipud3d","@stdlib/array/base/flipud4d","@stdlib/array/base/flipud5d"],"@stdlib/array/base/flipud3d":["@stdlib/array/base/flipud2d","@stdlib/array/base/flipud4d","@stdlib/array/base/flipud5d"],"@stdlib/array/base/flipud4d":["@stdlib/array/base/flipud2d","@stdlib/array/base/flipud3d","@stdlib/array/base/flipud5d"],"@stdlib/array/base/flipud5d":["@stdlib/array/base/flipud2d","@stdlib/array/base/flipud3d","@stdlib/array/base/flipud4d"],"@stdlib/math/base/special/ahavercos":["@stdlib/math/base/special/ahaversin","@stdlib/math/base/special/havercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/ahaversin":["@stdlib/math/base/special/ahavercos","@stdlib/math/base/special/haversin","@stdlib/math/base/special/versin"],"@stdlib/string/base/altcase":["@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/array/base/ones":["@stdlib/array/base/zeros","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones2d":["@stdlib/array/base/zeros2d","@stdlib/array/base/ones","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones3d":["@stdlib/array/base/zeros3d","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones4d":["@stdlib/array/base/zeros4d","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones5d":["@stdlib/array/base/zeros5d","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/onesnd"],"@stdlib/array/base/onesnd":["@stdlib/array/base/zerosnd","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d"],"@stdlib/array/base/one-to":["@stdlib/array/base/zero-to","@stdlib/array/base/ones"],"@stdlib/slice/base/args2multislice":[],"@stdlib/math/base/special/asec":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acsc","@stdlib/math/base/special/asech","@stdlib/math/base/special/acos"],"@stdlib/math/base/special/asecd":["@stdlib/math/base/special/asec","@stdlib/math/base/special/asech","@stdlib/math/base/special/acosd","@stdlib/math/base/special/secd"],"@stdlib/math/base/special/asecdf":["@stdlib/math/base/special/asec","@stdlib/math/base/special/asech"],"@stdlib/math/base/special/asecf":["@stdlib/math/base/special/asec","@stdlib/math/base/special/asech","@stdlib/math/base/special/acosf"],"@stdlib/math/base/special/asech":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asec","@stdlib/math/base/special/asech","@stdlib/math/base/special/acoth"],"@stdlib/math/base/special/asin":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/asind":["@stdlib/math/base/special/asin","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atand"],"@stdlib/math/base/special/asindf":["@stdlib/math/base/special/asinf","@stdlib/math/base/special/asind"],"@stdlib/math/base/special/asinf":["@stdlib/math/base/special/asin","@stdlib/math/base/special/asindf"],"@stdlib/math/base/special/asinh":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asin","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/atan":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asin","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/atan2":["@stdlib/math/base/special/atan"],"@stdlib/math/base/special/atand":["@stdlib/math/base/special/atan","@stdlib/math/base/special/atanh","@stdlib/math/base/special/acosd"],"@stdlib/math/base/special/atanf":["@stdlib/math/base/special/atan","@stdlib/math/base/special/atanh","@stdlib/math/base/special/acosf"],"@stdlib/math/base/special/atanh":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/avercos":["@stdlib/math/base/special/aversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/aversin":["@stdlib/math/base/special/avercos","@stdlib/math/base/special/vercos"],"@stdlib/array/base/zeros":["@stdlib/array/base/ones","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros2d":["@stdlib/array/base/zeros","@stdlib/array/base/ones2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros3d":["@stdlib/array/base/zeros","@stdlib/array/base/ones3d","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros4d":["@stdlib/array/base/zeros","@stdlib/array/base/ones4d","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros5d":["@stdlib/array/base/zeros","@stdlib/array/base/ones5d","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zerosnd":["@stdlib/array/base/zeros","@stdlib/array/base/onesnd","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d"],"@stdlib/array/base/zero-to":["@stdlib/array/base/one-to"],"@stdlib/math/base/special/bernoulli":[],"@stdlib/math/base/special/besselj0":["@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely0","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/besselj1":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/bessely0","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/bessely0":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/bessely1":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely0"],"@stdlib/math/base/special/beta":["@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betainc":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betaincinv":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betaln":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaincinv"],"@stdlib/math/base/special/binet":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/binomcoef":[],"@stdlib/math/base/special/binomcoefln":[],"@stdlib/math/base/special/boxcox":["@stdlib/math/base/special/boxcoxinv","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox1pinv"],"@stdlib/math/base/special/boxcox1p":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1pinv","@stdlib/math/base/special/boxcoxinv"],"@stdlib/math/base/special/boxcox1pinv":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcoxinv"],"@stdlib/math/base/special/boxcoxinv":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox1pinv"],"@stdlib/math/base/special/cabs":["@stdlib/math/base/special/cabs2","@stdlib/math/base/special/abs"],"@stdlib/math/base/special/cabs2":["@stdlib/math/base/special/cabs","@stdlib/math/base/special/abs2"],"@stdlib/math/base/special/cabs2f":["@stdlib/math/base/special/cabs2","@stdlib/math/base/special/cabsf","@stdlib/math/base/special/abs2f"],"@stdlib/math/base/special/cabsf":["@stdlib/math/base/special/cabs","@stdlib/math/base/special/cabs2f","@stdlib/math/base/special/absf"],"@stdlib/complex/float64/base/add":["@stdlib/math/base/ops/cdiv","@stdlib/complex/float64/base/mul","@stdlib/math/base/ops/csub"],"@stdlib/complex/float32/base/add":["@stdlib/complex/float64/base/add","@stdlib/complex/float32/base/mul","@stdlib/math/base/ops/csubf"],"@stdlib/string/base/camelcase":["@stdlib/string/base/constantcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/string/base/capitalize":["@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/cbrt":["@stdlib/math/base/special/pow","@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/cbrtf":["@stdlib/math/base/special/cbrt","@stdlib/math/base/special/sqrtf"],"@stdlib/math/base/special/cceil":["@stdlib/math/base/special/cceiln","@stdlib/math/base/special/cfloor","@stdlib/math/base/special/cround"],"@stdlib/math/base/special/cceilf":["@stdlib/math/base/special/cceil"],"@stdlib/math/base/special/cceiln":["@stdlib/math/base/special/cceil","@stdlib/math/base/special/cfloorn","@stdlib/math/base/special/croundn"],"@stdlib/math/base/special/ccis":[],"@stdlib/math/base/ops/cdiv":["@stdlib/complex/float64/base/add","@stdlib/complex/float64/base/mul","@stdlib/math/base/ops/csub"],"@stdlib/math/base/special/ceil":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floor","@stdlib/math/base/special/round"],"@stdlib/math/base/special/ceil2":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/ceil10":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/ceilb":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/ceilf":["@stdlib/math/base/special/floorf"],"@stdlib/math/base/special/ceiln":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/ceilsd":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/special/cexp":[],"@stdlib/math/base/special/cflipsign":["@stdlib/math/base/ops/cneg","@stdlib/math/base/special/csignum"],"@stdlib/math/base/special/cflipsignf":["@stdlib/math/base/ops/cnegf","@stdlib/math/base/special/cflipsign"],"@stdlib/math/base/special/cfloor":["@stdlib/math/base/special/cceil","@stdlib/math/base/special/cfloorn","@stdlib/math/base/special/cround"],"@stdlib/math/base/special/cfloorn":["@stdlib/math/base/special/cceiln","@stdlib/math/base/special/cfloor","@stdlib/math/base/special/croundn"],"@stdlib/math/base/special/cidentity":["@stdlib/math/base/special/cidentityf","@stdlib/math/base/special/identity"],"@stdlib/math/base/special/cidentityf":["@stdlib/math/base/special/cidentity","@stdlib/math/base/special/identityf"],"@stdlib/math/base/special/cinv":["@stdlib/math/base/ops/cdiv"],"@stdlib/math/base/special/clamp":["@stdlib/math/base/special/clampf","@stdlib/math/base/special/wrap"],"@stdlib/math/base/special/clampf":["@stdlib/math/base/special/clamp"],"@stdlib/complex/float64/base/mul":["@stdlib/complex/float64/base/add","@stdlib/math/base/ops/cdiv","@stdlib/math/base/ops/csub"],"@stdlib/complex/float32/base/mul":["@stdlib/complex/float32/base/add","@stdlib/complex/float64/base/mul","@stdlib/math/base/ops/csubf"],"@stdlib/math/base/ops/cneg":["@stdlib/math/base/special/cabs"],"@stdlib/math/base/ops/cnegf":["@stdlib/math/base/ops/cneg","@stdlib/math/base/special/cabsf"],"@stdlib/string/base/code-point-at":[],"@stdlib/string/base/constantcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/math/base/tools/continued-fraction":[],"@stdlib/math/base/special/copysign":["@stdlib/math/base/special/flipsign"],"@stdlib/math/base/special/copysignf":["@stdlib/math/base/special/copysign","@stdlib/math/base/special/flipsignf"],"@stdlib/math/base/special/cos":["@stdlib/math/base/special/cospi","@stdlib/math/base/special/cosm1","@stdlib/math/base/special/sin","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/cosd":["@stdlib/math/base/special/tand"],"@stdlib/math/base/special/cosh":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sinh","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/cosm1":["@stdlib/math/base/special/cos"],"@stdlib/math/base/special/cospi":["@stdlib/math/base/special/cos"],"@stdlib/math/base/special/cot":["@stdlib/math/base/special/csc","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/cotd":["@stdlib/math/base/special/cscd","@stdlib/math/base/special/secd","@stdlib/math/base/special/tand"],"@stdlib/math/base/special/coth":["@stdlib/math/base/special/acoth","@stdlib/math/base/special/cot","@stdlib/math/base/special/csch","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/covercos":["@stdlib/math/base/special/coversin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/coversin":["@stdlib/math/base/special/covercos","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/cphase":["@stdlib/math/base/special/cabs"],"@stdlib/math/base/special/cpolar":["@stdlib/math/base/special/cabs","@stdlib/math/base/special/cphase"],"@stdlib/math/base/special/cround":["@stdlib/math/base/special/cceil","@stdlib/math/base/special/cfloor","@stdlib/math/base/special/croundn"],"@stdlib/math/base/special/croundn":["@stdlib/math/base/special/cceiln","@stdlib/math/base/special/cfloorn","@stdlib/math/base/special/cround"],"@stdlib/math/base/special/csc":["@stdlib/math/base/special/cot","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/cscd":["@stdlib/math/base/special/cotd","@stdlib/math/base/special/secd"],"@stdlib/math/base/special/csch":["@stdlib/math/base/special/acsch","@stdlib/math/base/special/csc","@stdlib/math/base/special/coth","@stdlib/math/base/special/sinh"],"@stdlib/math/base/special/csignum":["@stdlib/math/base/special/signum"],"@stdlib/math/base/ops/csub":["@stdlib/complex/float64/base/add","@stdlib/math/base/ops/cdiv","@stdlib/complex/float64/base/mul"],"@stdlib/math/base/ops/csubf":["@stdlib/complex/float32/base/add","@stdlib/complex/float32/base/mul","@stdlib/math/base/ops/csub"],"@stdlib/math/base/special/deg2rad":["@stdlib/math/base/special/rad2deg"],"@stdlib/math/base/special/deg2radf":["@stdlib/math/base/special/deg2rad","@stdlib/math/base/special/rad2degf"],"@stdlib/math/base/special/digamma":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/trigamma"],"@stdlib/math/base/special/dirac-delta":["@stdlib/math/base/special/kronecker-delta"],"@stdlib/number/float64/base/div":["@stdlib/number/float64/base/add","@stdlib/number/float64/base/mul","@stdlib/number/float64/base/sub"],"@stdlib/number/float32/base/div":["@stdlib/number/float32/base/add","@stdlib/number/float64/base/div","@stdlib/number/float32/base/mul","@stdlib/math/base/ops/subf"],"@stdlib/string/base/dotcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/stats/base/dists/arcsine/ctor":[],"@stdlib/stats/base/dists/arcsine/cdf":[],"@stdlib/stats/base/dists/arcsine/entropy":[],"@stdlib/stats/base/dists/arcsine/kurtosis":[],"@stdlib/stats/base/dists/arcsine/logcdf":[],"@stdlib/stats/base/dists/arcsine/logpdf":[],"@stdlib/stats/base/dists/arcsine/mean":[],"@stdlib/stats/base/dists/arcsine/median":[],"@stdlib/stats/base/dists/arcsine/mode":[],"@stdlib/stats/base/dists/arcsine/pdf":[],"@stdlib/stats/base/dists/arcsine/quantile":[],"@stdlib/stats/base/dists/arcsine/skewness":[],"@stdlib/stats/base/dists/arcsine/stdev":[],"@stdlib/stats/base/dists/arcsine/variance":[],"@stdlib/stats/base/dists/bernoulli/ctor":[],"@stdlib/stats/base/dists/bernoulli/cdf":[],"@stdlib/stats/base/dists/bernoulli/entropy":[],"@stdlib/stats/base/dists/bernoulli/kurtosis":[],"@stdlib/stats/base/dists/bernoulli/mean":[],"@stdlib/stats/base/dists/bernoulli/median":[],"@stdlib/stats/base/dists/bernoulli/mgf":[],"@stdlib/stats/base/dists/bernoulli/mode":[],"@stdlib/stats/base/dists/bernoulli/pmf":[],"@stdlib/stats/base/dists/bernoulli/quantile":[],"@stdlib/stats/base/dists/bernoulli/skewness":[],"@stdlib/stats/base/dists/bernoulli/stdev":[],"@stdlib/stats/base/dists/bernoulli/variance":[],"@stdlib/stats/base/dists/beta/ctor":[],"@stdlib/stats/base/dists/beta/cdf":[],"@stdlib/stats/base/dists/beta/entropy":[],"@stdlib/stats/base/dists/beta/kurtosis":[],"@stdlib/stats/base/dists/beta/logcdf":[],"@stdlib/stats/base/dists/beta/logpdf":[],"@stdlib/stats/base/dists/beta/mean":[],"@stdlib/stats/base/dists/beta/median":[],"@stdlib/stats/base/dists/beta/mgf":[],"@stdlib/stats/base/dists/beta/mode":[],"@stdlib/stats/base/dists/beta/pdf":[],"@stdlib/stats/base/dists/beta/quantile":[],"@stdlib/stats/base/dists/beta/skewness":[],"@stdlib/stats/base/dists/beta/stdev":[],"@stdlib/stats/base/dists/beta/variance":[],"@stdlib/stats/base/dists/betaprime/ctor":[],"@stdlib/stats/base/dists/betaprime/cdf":[],"@stdlib/stats/base/dists/betaprime/kurtosis":[],"@stdlib/stats/base/dists/betaprime/logcdf":[],"@stdlib/stats/base/dists/betaprime/logpdf":[],"@stdlib/stats/base/dists/betaprime/mean":[],"@stdlib/stats/base/dists/betaprime/mode":[],"@stdlib/stats/base/dists/betaprime/pdf":[],"@stdlib/stats/base/dists/betaprime/quantile":[],"@stdlib/stats/base/dists/betaprime/skewness":[],"@stdlib/stats/base/dists/betaprime/stdev":[],"@stdlib/stats/base/dists/betaprime/variance":[],"@stdlib/stats/base/dists/binomial/ctor":[],"@stdlib/stats/base/dists/binomial/cdf":[],"@stdlib/stats/base/dists/binomial/entropy":[],"@stdlib/stats/base/dists/binomial/kurtosis":[],"@stdlib/stats/base/dists/binomial/logpmf":[],"@stdlib/stats/base/dists/binomial/mean":[],"@stdlib/stats/base/dists/binomial/median":[],"@stdlib/stats/base/dists/binomial/mgf":[],"@stdlib/stats/base/dists/binomial/mode":[],"@stdlib/stats/base/dists/binomial/pmf":[],"@stdlib/stats/base/dists/binomial/quantile":[],"@stdlib/stats/base/dists/binomial/skewness":[],"@stdlib/stats/base/dists/binomial/stdev":[],"@stdlib/stats/base/dists/binomial/variance":[],"@stdlib/stats/base/dists/cauchy/ctor":[],"@stdlib/stats/base/dists/cauchy/cdf":[],"@stdlib/stats/base/dists/cauchy/entropy":[],"@stdlib/stats/base/dists/cauchy/logcdf":[],"@stdlib/stats/base/dists/cauchy/logpdf":[],"@stdlib/stats/base/dists/cauchy/median":[],"@stdlib/stats/base/dists/cauchy/mode":[],"@stdlib/stats/base/dists/cauchy/pdf":[],"@stdlib/stats/base/dists/cauchy/quantile":[],"@stdlib/stats/base/dists/chi/cdf":[],"@stdlib/stats/base/dists/chi/ctor":[],"@stdlib/stats/base/dists/chi/entropy":[],"@stdlib/stats/base/dists/chi/kurtosis":[],"@stdlib/stats/base/dists/chi/logpdf":[],"@stdlib/stats/base/dists/chi/mean":[],"@stdlib/stats/base/dists/chi/mode":[],"@stdlib/stats/base/dists/chi/pdf":[],"@stdlib/stats/base/dists/chi/quantile":[],"@stdlib/stats/base/dists/chi/skewness":[],"@stdlib/stats/base/dists/chi/stdev":[],"@stdlib/stats/base/dists/chi/variance":[],"@stdlib/stats/base/dists/chisquare/cdf":[],"@stdlib/stats/base/dists/chisquare/ctor":[],"@stdlib/stats/base/dists/chisquare/entropy":[],"@stdlib/stats/base/dists/chisquare/kurtosis":[],"@stdlib/stats/base/dists/chisquare/logpdf":[],"@stdlib/stats/base/dists/chisquare/mean":[],"@stdlib/stats/base/dists/chisquare/median":[],"@stdlib/stats/base/dists/chisquare/mgf":[],"@stdlib/stats/base/dists/chisquare/mode":[],"@stdlib/stats/base/dists/chisquare/pdf":[],"@stdlib/stats/base/dists/chisquare/quantile":[],"@stdlib/stats/base/dists/chisquare/skewness":[],"@stdlib/stats/base/dists/chisquare/stdev":[],"@stdlib/stats/base/dists/chisquare/variance":[],"@stdlib/stats/base/dists/cosine/cdf":[],"@stdlib/stats/base/dists/cosine/ctor":[],"@stdlib/stats/base/dists/cosine/kurtosis":[],"@stdlib/stats/base/dists/cosine/logcdf":[],"@stdlib/stats/base/dists/cosine/logpdf":[],"@stdlib/stats/base/dists/cosine/mean":[],"@stdlib/stats/base/dists/cosine/median":[],"@stdlib/stats/base/dists/cosine/mgf":[],"@stdlib/stats/base/dists/cosine/mode":[],"@stdlib/stats/base/dists/cosine/pdf":[],"@stdlib/stats/base/dists/cosine/quantile":[],"@stdlib/stats/base/dists/cosine/skewness":[],"@stdlib/stats/base/dists/cosine/stdev":[],"@stdlib/stats/base/dists/cosine/variance":[],"@stdlib/stats/base/dists/degenerate/cdf":[],"@stdlib/stats/base/dists/degenerate/ctor":[],"@stdlib/stats/base/dists/degenerate/entropy":[],"@stdlib/stats/base/dists/degenerate/logcdf":[],"@stdlib/stats/base/dists/degenerate/logpdf":[],"@stdlib/stats/base/dists/degenerate/logpmf":[],"@stdlib/stats/base/dists/degenerate/mean":[],"@stdlib/stats/base/dists/degenerate/median":[],"@stdlib/stats/base/dists/degenerate/mgf":[],"@stdlib/stats/base/dists/degenerate/mode":[],"@stdlib/stats/base/dists/degenerate/pdf":[],"@stdlib/stats/base/dists/degenerate/pmf":[],"@stdlib/stats/base/dists/degenerate/quantile":[],"@stdlib/stats/base/dists/degenerate/stdev":[],"@stdlib/stats/base/dists/degenerate/variance":[],"@stdlib/stats/base/dists/discrete-uniform/cdf":[],"@stdlib/stats/base/dists/discrete-uniform/ctor":[],"@stdlib/stats/base/dists/discrete-uniform/entropy":[],"@stdlib/stats/base/dists/discrete-uniform/kurtosis":[],"@stdlib/stats/base/dists/discrete-uniform/logcdf":[],"@stdlib/stats/base/dists/discrete-uniform/logpmf":[],"@stdlib/stats/base/dists/discrete-uniform/mean":[],"@stdlib/stats/base/dists/discrete-uniform/median":[],"@stdlib/stats/base/dists/discrete-uniform/mgf":[],"@stdlib/stats/base/dists/discrete-uniform/pmf":[],"@stdlib/stats/base/dists/discrete-uniform/quantile":[],"@stdlib/stats/base/dists/discrete-uniform/skewness":[],"@stdlib/stats/base/dists/discrete-uniform/stdev":[],"@stdlib/stats/base/dists/discrete-uniform/variance":[],"@stdlib/stats/base/dists/erlang/cdf":[],"@stdlib/stats/base/dists/erlang/entropy":[],"@stdlib/stats/base/dists/erlang/ctor":[],"@stdlib/stats/base/dists/erlang/kurtosis":[],"@stdlib/stats/base/dists/erlang/logpdf":[],"@stdlib/stats/base/dists/erlang/mean":[],"@stdlib/stats/base/dists/erlang/mgf":[],"@stdlib/stats/base/dists/erlang/mode":[],"@stdlib/stats/base/dists/erlang/pdf":[],"@stdlib/stats/base/dists/erlang/quantile":[],"@stdlib/stats/base/dists/erlang/skewness":[],"@stdlib/stats/base/dists/erlang/stdev":[],"@stdlib/stats/base/dists/erlang/variance":[],"@stdlib/stats/base/dists/exponential/cdf":[],"@stdlib/stats/base/dists/exponential/entropy":[],"@stdlib/stats/base/dists/exponential/ctor":[],"@stdlib/stats/base/dists/exponential/kurtosis":[],"@stdlib/stats/base/dists/exponential/logcdf":[],"@stdlib/stats/base/dists/exponential/logpdf":[],"@stdlib/stats/base/dists/exponential/mean":[],"@stdlib/stats/base/dists/exponential/median":[],"@stdlib/stats/base/dists/exponential/mgf":[],"@stdlib/stats/base/dists/exponential/mode":[],"@stdlib/stats/base/dists/exponential/pdf":[],"@stdlib/stats/base/dists/exponential/quantile":[],"@stdlib/stats/base/dists/exponential/skewness":[],"@stdlib/stats/base/dists/exponential/stdev":[],"@stdlib/stats/base/dists/exponential/variance":[],"@stdlib/stats/base/dists/f/cdf":[],"@stdlib/stats/base/dists/f/entropy":[],"@stdlib/stats/base/dists/f/ctor":[],"@stdlib/stats/base/dists/f/kurtosis":[],"@stdlib/stats/base/dists/f/mean":[],"@stdlib/stats/base/dists/f/mode":[],"@stdlib/stats/base/dists/f/pdf":[],"@stdlib/stats/base/dists/f/quantile":[],"@stdlib/stats/base/dists/f/skewness":[],"@stdlib/stats/base/dists/f/stdev":[],"@stdlib/stats/base/dists/f/variance":[],"@stdlib/stats/base/dists/frechet/cdf":[],"@stdlib/stats/base/dists/frechet/entropy":[],"@stdlib/stats/base/dists/frechet/ctor":[],"@stdlib/stats/base/dists/frechet/kurtosis":[],"@stdlib/stats/base/dists/frechet/logcdf":[],"@stdlib/stats/base/dists/frechet/logpdf":[],"@stdlib/stats/base/dists/frechet/mean":[],"@stdlib/stats/base/dists/frechet/median":[],"@stdlib/stats/base/dists/frechet/mode":[],"@stdlib/stats/base/dists/frechet/pdf":[],"@stdlib/stats/base/dists/frechet/quantile":[],"@stdlib/stats/base/dists/frechet/skewness":[],"@stdlib/stats/base/dists/frechet/stdev":[],"@stdlib/stats/base/dists/frechet/variance":[],"@stdlib/stats/base/dists/gamma/cdf":[],"@stdlib/stats/base/dists/gamma/entropy":[],"@stdlib/stats/base/dists/gamma/ctor":[],"@stdlib/stats/base/dists/gamma/kurtosis":[],"@stdlib/stats/base/dists/gamma/logcdf":[],"@stdlib/stats/base/dists/gamma/logpdf":[],"@stdlib/stats/base/dists/gamma/mean":[],"@stdlib/stats/base/dists/gamma/mgf":[],"@stdlib/stats/base/dists/gamma/mode":[],"@stdlib/stats/base/dists/gamma/pdf":[],"@stdlib/stats/base/dists/gamma/quantile":[],"@stdlib/stats/base/dists/gamma/skewness":[],"@stdlib/stats/base/dists/gamma/stdev":[],"@stdlib/stats/base/dists/gamma/variance":[],"@stdlib/stats/base/dists/geometric/cdf":[],"@stdlib/stats/base/dists/geometric/entropy":[],"@stdlib/stats/base/dists/geometric/ctor":[],"@stdlib/stats/base/dists/geometric/kurtosis":[],"@stdlib/stats/base/dists/geometric/logcdf":[],"@stdlib/stats/base/dists/geometric/logpmf":[],"@stdlib/stats/base/dists/geometric/mean":[],"@stdlib/stats/base/dists/geometric/median":[],"@stdlib/stats/base/dists/geometric/mgf":[],"@stdlib/stats/base/dists/geometric/mode":[],"@stdlib/stats/base/dists/geometric/pmf":[],"@stdlib/stats/base/dists/geometric/quantile":[],"@stdlib/stats/base/dists/geometric/skewness":[],"@stdlib/stats/base/dists/geometric/stdev":[],"@stdlib/stats/base/dists/geometric/variance":[],"@stdlib/stats/base/dists/gumbel/cdf":[],"@stdlib/stats/base/dists/gumbel/entropy":[],"@stdlib/stats/base/dists/gumbel/ctor":[],"@stdlib/stats/base/dists/gumbel/kurtosis":[],"@stdlib/stats/base/dists/gumbel/logcdf":[],"@stdlib/stats/base/dists/gumbel/logpdf":[],"@stdlib/stats/base/dists/gumbel/mean":[],"@stdlib/stats/base/dists/gumbel/median":[],"@stdlib/stats/base/dists/gumbel/mgf":[],"@stdlib/stats/base/dists/gumbel/mode":[],"@stdlib/stats/base/dists/gumbel/pdf":[],"@stdlib/stats/base/dists/gumbel/quantile":[],"@stdlib/stats/base/dists/gumbel/skewness":[],"@stdlib/stats/base/dists/gumbel/stdev":[],"@stdlib/stats/base/dists/gumbel/variance":[],"@stdlib/stats/base/dists/hypergeometric/cdf":[],"@stdlib/stats/base/dists/hypergeometric/ctor":[],"@stdlib/stats/base/dists/hypergeometric/kurtosis":[],"@stdlib/stats/base/dists/hypergeometric/logpmf":[],"@stdlib/stats/base/dists/hypergeometric/mean":[],"@stdlib/stats/base/dists/hypergeometric/mode":[],"@stdlib/stats/base/dists/hypergeometric/pmf":[],"@stdlib/stats/base/dists/hypergeometric/quantile":[],"@stdlib/stats/base/dists/hypergeometric/skewness":[],"@stdlib/stats/base/dists/hypergeometric/stdev":[],"@stdlib/stats/base/dists/hypergeometric/variance":[],"@stdlib/stats/base/dists/invgamma/cdf":[],"@stdlib/stats/base/dists/invgamma/entropy":[],"@stdlib/stats/base/dists/invgamma/ctor":[],"@stdlib/stats/base/dists/invgamma/kurtosis":[],"@stdlib/stats/base/dists/invgamma/logpdf":[],"@stdlib/stats/base/dists/invgamma/mean":[],"@stdlib/stats/base/dists/invgamma/mode":[],"@stdlib/stats/base/dists/invgamma/pdf":[],"@stdlib/stats/base/dists/invgamma/quantile":[],"@stdlib/stats/base/dists/invgamma/skewness":[],"@stdlib/stats/base/dists/invgamma/stdev":[],"@stdlib/stats/base/dists/invgamma/variance":[],"@stdlib/stats/base/dists/kumaraswamy/cdf":[],"@stdlib/stats/base/dists/kumaraswamy/ctor":[],"@stdlib/stats/base/dists/kumaraswamy/kurtosis":[],"@stdlib/stats/base/dists/kumaraswamy/logcdf":[],"@stdlib/stats/base/dists/kumaraswamy/logpdf":[],"@stdlib/stats/base/dists/kumaraswamy/mean":[],"@stdlib/stats/base/dists/kumaraswamy/median":[],"@stdlib/stats/base/dists/kumaraswamy/mode":[],"@stdlib/stats/base/dists/kumaraswamy/pdf":[],"@stdlib/stats/base/dists/kumaraswamy/quantile":[],"@stdlib/stats/base/dists/kumaraswamy/skewness":[],"@stdlib/stats/base/dists/kumaraswamy/stdev":[],"@stdlib/stats/base/dists/kumaraswamy/variance":[],"@stdlib/stats/base/dists/laplace/cdf":[],"@stdlib/stats/base/dists/laplace/entropy":[],"@stdlib/stats/base/dists/laplace/kurtosis":[],"@stdlib/stats/base/dists/laplace/ctor":[],"@stdlib/stats/base/dists/laplace/logcdf":[],"@stdlib/stats/base/dists/laplace/logpdf":[],"@stdlib/stats/base/dists/laplace/mean":[],"@stdlib/stats/base/dists/laplace/median":[],"@stdlib/stats/base/dists/laplace/mgf":[],"@stdlib/stats/base/dists/laplace/mode":[],"@stdlib/stats/base/dists/laplace/pdf":[],"@stdlib/stats/base/dists/laplace/quantile":[],"@stdlib/stats/base/dists/laplace/skewness":[],"@stdlib/stats/base/dists/laplace/stdev":[],"@stdlib/stats/base/dists/laplace/variance":[],"@stdlib/stats/base/dists/levy/cdf":[],"@stdlib/stats/base/dists/levy/entropy":[],"@stdlib/stats/base/dists/levy/ctor":[],"@stdlib/stats/base/dists/levy/logcdf":[],"@stdlib/stats/base/dists/levy/logpdf":[],"@stdlib/stats/base/dists/levy/mean":[],"@stdlib/stats/base/dists/levy/median":[],"@stdlib/stats/base/dists/levy/mode":[],"@stdlib/stats/base/dists/levy/pdf":[],"@stdlib/stats/base/dists/levy/quantile":[],"@stdlib/stats/base/dists/levy/stdev":[],"@stdlib/stats/base/dists/levy/variance":[],"@stdlib/stats/base/dists/logistic/cdf":[],"@stdlib/stats/base/dists/logistic/entropy":[],"@stdlib/stats/base/dists/logistic/kurtosis":[],"@stdlib/stats/base/dists/logistic/logcdf":[],"@stdlib/stats/base/dists/logistic/ctor":[],"@stdlib/stats/base/dists/logistic/logpdf":[],"@stdlib/stats/base/dists/logistic/mean":[],"@stdlib/stats/base/dists/logistic/median":[],"@stdlib/stats/base/dists/logistic/mgf":[],"@stdlib/stats/base/dists/logistic/mode":[],"@stdlib/stats/base/dists/logistic/pdf":[],"@stdlib/stats/base/dists/logistic/quantile":[],"@stdlib/stats/base/dists/logistic/skewness":[],"@stdlib/stats/base/dists/logistic/stdev":[],"@stdlib/stats/base/dists/logistic/variance":[],"@stdlib/stats/base/dists/lognormal/cdf":[],"@stdlib/stats/base/dists/lognormal/entropy":[],"@stdlib/stats/base/dists/lognormal/kurtosis":[],"@stdlib/stats/base/dists/lognormal/ctor":[],"@stdlib/stats/base/dists/lognormal/logcdf":[],"@stdlib/stats/base/dists/lognormal/logpdf":[],"@stdlib/stats/base/dists/lognormal/mean":[],"@stdlib/stats/base/dists/lognormal/median":[],"@stdlib/stats/base/dists/lognormal/mode":[],"@stdlib/stats/base/dists/lognormal/pdf":[],"@stdlib/stats/base/dists/lognormal/quantile":[],"@stdlib/stats/base/dists/lognormal/skewness":[],"@stdlib/stats/base/dists/lognormal/stdev":[],"@stdlib/stats/base/dists/lognormal/variance":[],"@stdlib/stats/base/dists/negative-binomial/cdf":[],"@stdlib/stats/base/dists/negative-binomial/kurtosis":[],"@stdlib/stats/base/dists/negative-binomial/logpmf":[],"@stdlib/stats/base/dists/negative-binomial/mean":[],"@stdlib/stats/base/dists/negative-binomial/mgf":[],"@stdlib/stats/base/dists/negative-binomial/mode":[],"@stdlib/stats/base/dists/negative-binomial/ctor":[],"@stdlib/stats/base/dists/negative-binomial/pmf":[],"@stdlib/stats/base/dists/negative-binomial/quantile":[],"@stdlib/stats/base/dists/negative-binomial/skewness":[],"@stdlib/stats/base/dists/negative-binomial/stdev":[],"@stdlib/stats/base/dists/negative-binomial/variance":[],"@stdlib/stats/base/dists/normal/cdf":[],"@stdlib/stats/base/dists/normal/entropy":[],"@stdlib/stats/base/dists/normal/kurtosis":[],"@stdlib/stats/base/dists/normal/logcdf":[],"@stdlib/stats/base/dists/normal/logpdf":[],"@stdlib/stats/base/dists/normal/mean":[],"@stdlib/stats/base/dists/normal/median":[],"@stdlib/stats/base/dists/normal/mgf":[],"@stdlib/stats/base/dists/normal/mode":[],"@stdlib/stats/base/dists/normal/ctor":[],"@stdlib/stats/base/dists/normal/pdf":[],"@stdlib/stats/base/dists/normal/quantile":[],"@stdlib/stats/base/dists/normal/skewness":[],"@stdlib/stats/base/dists/normal/stdev":[],"@stdlib/stats/base/dists/normal/variance":[],"@stdlib/stats/base/dists/pareto-type1/cdf":[],"@stdlib/stats/base/dists/pareto-type1/entropy":[],"@stdlib/stats/base/dists/pareto-type1/kurtosis":[],"@stdlib/stats/base/dists/pareto-type1/logcdf":[],"@stdlib/stats/base/dists/pareto-type1/logpdf":[],"@stdlib/stats/base/dists/pareto-type1/mean":[],"@stdlib/stats/base/dists/pareto-type1/median":[],"@stdlib/stats/base/dists/pareto-type1/mode":[],"@stdlib/stats/base/dists/pareto-type1/ctor":[],"@stdlib/stats/base/dists/pareto-type1/pdf":[],"@stdlib/stats/base/dists/pareto-type1/quantile":[],"@stdlib/stats/base/dists/pareto-type1/skewness":[],"@stdlib/stats/base/dists/pareto-type1/stdev":[],"@stdlib/stats/base/dists/pareto-type1/variance":[],"@stdlib/stats/base/dists/poisson/cdf":[],"@stdlib/stats/base/dists/poisson/entropy":[],"@stdlib/stats/base/dists/poisson/kurtosis":[],"@stdlib/stats/base/dists/poisson/logpmf":[],"@stdlib/stats/base/dists/poisson/mean":[],"@stdlib/stats/base/dists/poisson/median":[],"@stdlib/stats/base/dists/poisson/mgf":[],"@stdlib/stats/base/dists/poisson/mode":[],"@stdlib/stats/base/dists/poisson/pmf":[],"@stdlib/stats/base/dists/poisson/ctor":[],"@stdlib/stats/base/dists/poisson/quantile":[],"@stdlib/stats/base/dists/poisson/skewness":[],"@stdlib/stats/base/dists/poisson/stdev":[],"@stdlib/stats/base/dists/poisson/variance":[],"@stdlib/stats/base/dists/rayleigh/cdf":[],"@stdlib/stats/base/dists/rayleigh/entropy":[],"@stdlib/stats/base/dists/rayleigh/kurtosis":[],"@stdlib/stats/base/dists/rayleigh/logcdf":[],"@stdlib/stats/base/dists/rayleigh/logpdf":[],"@stdlib/stats/base/dists/rayleigh/mean":[],"@stdlib/stats/base/dists/rayleigh/median":[],"@stdlib/stats/base/dists/rayleigh/mgf":[],"@stdlib/stats/base/dists/rayleigh/mode":[],"@stdlib/stats/base/dists/rayleigh/pdf":[],"@stdlib/stats/base/dists/rayleigh/quantile":[],"@stdlib/stats/base/dists/rayleigh/ctor":[],"@stdlib/stats/base/dists/rayleigh/skewness":[],"@stdlib/stats/base/dists/rayleigh/stdev":[],"@stdlib/stats/base/dists/rayleigh/variance":[],"@stdlib/stats/base/dists/signrank/cdf":[],"@stdlib/stats/base/dists/signrank/pdf":[],"@stdlib/stats/base/dists/signrank/quantile":[],"@stdlib/stats/base/dists/studentized-range/cdf":[],"@stdlib/stats/base/dists/studentized-range/quantile":[],"@stdlib/stats/base/dists/t/cdf":[],"@stdlib/stats/base/dists/t/entropy":[],"@stdlib/stats/base/dists/t/kurtosis":[],"@stdlib/stats/base/dists/t/logcdf":[],"@stdlib/stats/base/dists/t/logpdf":[],"@stdlib/stats/base/dists/t/mean":[],"@stdlib/stats/base/dists/t/median":[],"@stdlib/stats/base/dists/t/mode":[],"@stdlib/stats/base/dists/t/pdf":[],"@stdlib/stats/base/dists/t/quantile":[],"@stdlib/stats/base/dists/t/skewness":[],"@stdlib/stats/base/dists/t/stdev":[],"@stdlib/stats/base/dists/t/ctor":[],"@stdlib/stats/base/dists/t/variance":[],"@stdlib/stats/base/dists/triangular/cdf":[],"@stdlib/stats/base/dists/triangular/entropy":[],"@stdlib/stats/base/dists/triangular/kurtosis":[],"@stdlib/stats/base/dists/triangular/logcdf":[],"@stdlib/stats/base/dists/triangular/logpdf":[],"@stdlib/stats/base/dists/triangular/mean":[],"@stdlib/stats/base/dists/triangular/median":[],"@stdlib/stats/base/dists/triangular/mgf":[],"@stdlib/stats/base/dists/triangular/mode":[],"@stdlib/stats/base/dists/triangular/pdf":[],"@stdlib/stats/base/dists/triangular/quantile":[],"@stdlib/stats/base/dists/triangular/skewness":[],"@stdlib/stats/base/dists/triangular/stdev":[],"@stdlib/stats/base/dists/triangular/ctor":[],"@stdlib/stats/base/dists/triangular/variance":[],"@stdlib/stats/base/dists/truncated-normal/pdf":[],"@stdlib/stats/base/dists/uniform/cdf":[],"@stdlib/stats/base/dists/uniform/entropy":[],"@stdlib/stats/base/dists/uniform/kurtosis":[],"@stdlib/stats/base/dists/uniform/logcdf":[],"@stdlib/stats/base/dists/uniform/logpdf":[],"@stdlib/stats/base/dists/uniform/mean":[],"@stdlib/stats/base/dists/uniform/median":[],"@stdlib/stats/base/dists/uniform/mgf":[],"@stdlib/stats/base/dists/uniform/pdf":[],"@stdlib/stats/base/dists/uniform/quantile":[],"@stdlib/stats/base/dists/uniform/skewness":[],"@stdlib/stats/base/dists/uniform/stdev":[],"@stdlib/stats/base/dists/uniform/ctor":[],"@stdlib/stats/base/dists/uniform/variance":[],"@stdlib/stats/base/dists/weibull/cdf":[],"@stdlib/stats/base/dists/weibull/entropy":[],"@stdlib/stats/base/dists/weibull/kurtosis":[],"@stdlib/stats/base/dists/weibull/logcdf":[],"@stdlib/stats/base/dists/weibull/logpdf":[],"@stdlib/stats/base/dists/weibull/mean":[],"@stdlib/stats/base/dists/weibull/median":[],"@stdlib/stats/base/dists/weibull/mgf":[],"@stdlib/stats/base/dists/weibull/mode":[],"@stdlib/stats/base/dists/weibull/pdf":[],"@stdlib/stats/base/dists/weibull/quantile":[],"@stdlib/stats/base/dists/weibull/skewness":[],"@stdlib/stats/base/dists/weibull/stdev":[],"@stdlib/stats/base/dists/weibull/variance":[],"@stdlib/stats/base/dists/weibull/ctor":[],"@stdlib/math/base/special/ellipe":["@stdlib/math/base/special/ellipj","@stdlib/math/base/special/ellipk"],"@stdlib/math/base/special/ellipj":["@stdlib/math/base/special/ellipe","@stdlib/math/base/special/ellipk"],"@stdlib/math/base/special/ellipk":["@stdlib/math/base/special/ellipe","@stdlib/math/base/special/ellipj"],"@stdlib/string/base/ends-with":["@stdlib/string/base/starts-with"],"@stdlib/math/base/utils/float64-epsilon-difference":["@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/relative-difference"],"@stdlib/math/base/special/erf":["@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/erfc":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcinv","@stdlib/math/base/special/erfcx"],"@stdlib/math/base/special/erfcinv":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcx"],"@stdlib/math/base/special/erfcx":["@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfcinv","@stdlib/math/base/special/erf","@stdlib/math/base/special/erfinv"],"@stdlib/math/base/special/erfinv":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/dirichlet-eta":[],"@stdlib/math/base/tools/evalpoly":["@stdlib/math/base/tools/evalrational"],"@stdlib/math/base/tools/evalrational":["@stdlib/math/base/tools/evalpoly"],"@stdlib/math/base/special/exp":["@stdlib/math/base/special/exp10","@stdlib/math/base/special/exp2","@stdlib/math/base/special/expm1","@stdlib/math/base/special/ln"],"@stdlib/math/base/special/exp2":["@stdlib/math/base/special/exp","@stdlib/math/base/special/exp10","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/exp10":["@stdlib/math/base/special/exp","@stdlib/math/base/special/exp2","@stdlib/math/base/special/log10"],"@stdlib/math/base/special/expit":["@stdlib/math/base/special/exp","@stdlib/math/base/special/logit"],"@stdlib/math/base/special/expm1":["@stdlib/math/base/special/exp","@stdlib/math/base/special/expm1rel"],"@stdlib/math/base/special/expm1rel":["@stdlib/math/base/special/exp","@stdlib/math/base/special/expm1"],"@stdlib/number/float64/base/exponent":["@stdlib/number/float32/base/exponent"],"@stdlib/number/float32/base/exponent":["@stdlib/number/float64/base/exponent"],"@stdlib/math/base/special/factorial":["@stdlib/math/base/special/factorialln"],"@stdlib/math/base/special/factorial2":["@stdlib/math/base/special/factorial"],"@stdlib/math/base/special/factorialln":["@stdlib/math/base/special/factorial"],"@stdlib/math/base/special/falling-factorial":["@stdlib/math/base/special/rising-factorial"],"@stdlib/math/base/special/fibonacci":["@stdlib/math/base/special/binet","@stdlib/math/base/special/fibonacci-index","@stdlib/math/base/special/lucas","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/fibonacci-index":["@stdlib/math/base/special/fibonacci"],"@stdlib/math/base/tools/fibpoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/lucaspoly"],"@stdlib/string/base/first-code-point":["@stdlib/string/base/first","@stdlib/string/base/first-grapheme-cluster","@stdlib/string/base/last-code-point","@stdlib/string/base/remove-first-code-point","@stdlib/string/first"],"@stdlib/string/base/first":["@stdlib/string/base/first-code-point","@stdlib/string/base/first-grapheme-cluster","@stdlib/string/base/last","@stdlib/string/base/remove-first","@stdlib/string/first"],"@stdlib/string/base/first-grapheme-cluster":["@stdlib/string/base/first","@stdlib/string/base/first-code-point","@stdlib/string/base/last-grapheme-cluster","@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string/first"],"@stdlib/math/base/special/flipsign":["@stdlib/math/base/special/copysign"],"@stdlib/math/base/special/flipsignf":["@stdlib/math/base/special/copysignf","@stdlib/math/base/special/flipsign"],"@stdlib/number/float32/base/to-int32":["@stdlib/number/float32/base/to-uint32"],"@stdlib/number/float32/base/to-uint32":["@stdlib/number/float32/base/to-int32"],"@stdlib/number/float64/base/to-float32":[],"@stdlib/number/float64/base/to-int32":["@stdlib/number/float64/base/to-uint32"],"@stdlib/number/float64/base/to-int64-bytes":["@stdlib/number/float64/base/to-int32"],"@stdlib/number/float64/base/to-uint32":["@stdlib/number/float64/base/to-int32"],"@stdlib/math/base/special/floor":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/round"],"@stdlib/math/base/special/floor2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/floor10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/floorb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floor","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/floorf":["@stdlib/math/base/special/ceilf","@stdlib/math/base/special/floor"],"@stdlib/math/base/special/floorn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floor","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/floorsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floor","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/truncsd"],"@stdlib/string/base/for-each":["@stdlib/string/base/for-each-code-point","@stdlib/string/base/for-each-grapheme-cluster","@stdlib/string/for-each"],"@stdlib/string/base/for-each-code-point":["@stdlib/string/base/for-each","@stdlib/string/base/for-each-grapheme-cluster","@stdlib/string/for-each"],"@stdlib/string/base/for-each-code-point-right":["@stdlib/string/base/for-each-code-point","@stdlib/string/base/for-each-right"],"@stdlib/string/base/for-each-grapheme-cluster":["@stdlib/string/base/for-each","@stdlib/string/base/for-each-code-point","@stdlib/string/for-each"],"@stdlib/string/base/for-each-right":["@stdlib/string/base/for-each","@stdlib/string/base/for-each-code-point-right"],"@stdlib/string/base/format-interpolate":["@stdlib/string/base/format-tokenize"],"@stdlib/string/base/format-tokenize":["@stdlib/string/base/format-interpolate"],"@stdlib/math/base/special/fresnel":["@stdlib/math/base/special/fresnelc","@stdlib/math/base/special/fresnels"],"@stdlib/math/base/special/fresnelc":["@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnels"],"@stdlib/math/base/special/fresnels":["@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnelc"],"@stdlib/math/base/special/frexp":["@stdlib/math/base/special/ldexp"],"@stdlib/number/float64/base/from-binary-string":["@stdlib/number/float32/base/from-binary-string","@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/float32/base/from-binary-string":["@stdlib/number/float32/base/to-binary-string","@stdlib/number/float64/base/from-binary-string"],"@stdlib/number/uint8/base/from-binary-string":["@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint8/base/to-binary-string"],"@stdlib/number/uint16/base/from-binary-string":["@stdlib/number/uint16/base/to-binary-string","@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint8/base/from-binary-string"],"@stdlib/number/uint32/base/from-binary-string":["@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint32/base/to-binary-string","@stdlib/number/uint8/base/from-binary-string"],"@stdlib/number/float64/base/from-int64-bytes":["@stdlib/number/float64/base/to-int64-bytes"],"@stdlib/number/float32/base/from-word":["@stdlib/number/float64/base/from-words"],"@stdlib/number/float64/base/from-words":["@stdlib/number/float32/base/from-word"],"@stdlib/math/base/special/gamma":["@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma1pm1":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma-delta-ratio":["@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/gammainc":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gammaincinv":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma-lanczos-sum":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled"],"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma-lanczos-sum"],"@stdlib/math/base/special/gammaln":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv"],"@stdlib/math/base/special/gammasgn":["@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/gcd":["@stdlib/math/base/special/lcm"],"@stdlib/number/float64/base/get-high-word":["@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/number/float64/base/get-low-word":["@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/math/base/special/hacovercos":["@stdlib/math/base/special/hacoversin","@stdlib/math/base/special/havercos"],"@stdlib/math/base/special/hacoversin":["@stdlib/math/base/special/hacovercos","@stdlib/math/base/special/haversin"],"@stdlib/math/base/special/havercos":["@stdlib/math/base/special/haversin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/haversin":["@stdlib/math/base/special/havercos","@stdlib/math/base/special/versin"],"@stdlib/string/base/headercase":["@stdlib/string/base/camelcase","@stdlib/string/base/pascalcase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/heaviside":["@stdlib/math/base/special/ramp"],"@stdlib/math/base/tools/hermitepoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/normhermitepoly"],"@stdlib/math/base/special/hypot":[],"@stdlib/math/base/special/hypotf":["@stdlib/math/base/special/hypot"],"@stdlib/math/base/special/identity":[],"@stdlib/math/base/special/identityf":["@stdlib/math/base/special/identityf"],"@stdlib/math/base/ops/imul":["@stdlib/math/base/ops/imuldw"],"@stdlib/math/base/ops/imuldw":["@stdlib/math/base/ops/imul"],"@stdlib/slice/base/int2slice":["@stdlib/slice/base/seq2slice","@stdlib/slice/base/str2slice"],"@stdlib/number/int32/base/to-uint32":["@stdlib/number/uint32/base/to-int32"],"@stdlib/math/base/special/inv":["@stdlib/math/base/special/pow"],"@stdlib/string/base/invcase":["@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/invf":["@stdlib/math/base/special/inv"],"@stdlib/math/base/assert/is-composite":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-prime"],"@stdlib/math/base/assert/is-coprime":["@stdlib/math/base/assert/is-composite","@stdlib/math/base/assert/is-prime","@stdlib/math/base/special/gcd"],"@stdlib/math/base/assert/is-even":["@stdlib/math/base/assert/is-odd"],"@stdlib/math/base/assert/int32-is-even":["@stdlib/math/base/assert/is-even","@stdlib/math/base/assert/int32-is-odd"],"@stdlib/math/base/assert/is-finite":["@stdlib/math/base/assert/is-infinite"],"@stdlib/math/base/assert/is-finitef":["@stdlib/math/base/assert/is-infinitef"],"@stdlib/math/base/assert/is-infinite":["@stdlib/math/base/assert/is-finite"],"@stdlib/math/base/assert/is-infinitef":["@stdlib/math/base/assert/is-finitef"],"@stdlib/math/base/assert/is-integer":[],"@stdlib/math/base/assert/is-nan":["@stdlib/math/base/assert/is-nanf"],"@stdlib/math/base/assert/is-nanf":["@stdlib/math/base/assert/is-nan"],"@stdlib/math/base/assert/is-negative-finite":["@stdlib/math/base/assert/is-positive-finite","@stdlib/math/base/assert/is-nonnegative-finite","@stdlib/math/base/assert/is-nonpositive-finite"],"@stdlib/math/base/assert/is-negative-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-negative-zero":["@stdlib/math/base/assert/is-positive-zero"],"@stdlib/math/base/assert/is-negative-zerof":["@stdlib/math/base/assert/is-negative-zero","@stdlib/math/base/assert/is-positive-zerof"],"@stdlib/math/base/assert/is-nonnegative-finite":["@stdlib/math/base/assert/is-negative-finite","@stdlib/math/base/assert/is-positive-finite","@stdlib/math/base/assert/is-nonpositive-finite"],"@stdlib/math/base/assert/is-nonnegative-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-nonpositive-finite":["@stdlib/math/base/assert/is-negative-finite","@stdlib/math/base/assert/is-positive-finite","@stdlib/math/base/assert/is-nonnegative-finite"],"@stdlib/math/base/assert/is-nonpositive-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-odd":["@stdlib/math/base/assert/is-even"],"@stdlib/math/base/assert/int32-is-odd":["@stdlib/math/base/assert/int32-is-even","@stdlib/math/base/assert/is-odd"],"@stdlib/math/base/assert/is-positive-finite":["@stdlib/math/base/assert/is-negative-finite","@stdlib/math/base/assert/is-nonnegative-finite","@stdlib/math/base/assert/is-nonpositive-finite"],"@stdlib/math/base/assert/is-positive-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-integer"],"@stdlib/math/base/assert/is-positive-zero":["@stdlib/math/base/assert/is-negative-zero"],"@stdlib/math/base/assert/is-positive-zerof":["@stdlib/math/base/assert/is-negative-zerof","@stdlib/math/base/assert/is-positive-zero"],"@stdlib/math/base/assert/uint32-is-pow2":[],"@stdlib/math/base/assert/is-prime":["@stdlib/math/base/assert/is-composite","@stdlib/math/base/assert/is-integer"],"@stdlib/math/base/assert/is-probability":[],"@stdlib/math/base/assert/is-safe-integer":[],"@stdlib/string/base/kebabcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/pascalcase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/kernel-betainc":["@stdlib/math/base/special/betainc"],"@stdlib/math/base/special/kernel-betaincinv":["@stdlib/math/base/special/betaincinv"],"@stdlib/math/base/special/kernel-cos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/kernel-tan"],"@stdlib/math/base/special/kernel-log1p":["@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/kernel-sin":["@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/kernel-tan","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/kernel-tan":["@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/kronecker-delta":["@stdlib/math/base/special/dirac-delta"],"@stdlib/math/base/special/kronecker-deltaf":["@stdlib/math/base/special/kronecker-delta"],"@stdlib/math/base/special/labs":["@stdlib/math/base/special/abs"],"@stdlib/string/base/last":["@stdlib/string/base/first","@stdlib/string/base/last-code-point","@stdlib/string/base/last-grapheme-cluster"],"@stdlib/string/base/last-code-point":["@stdlib/string/base/first-code-point","@stdlib/string/base/last-grapheme-cluster","@stdlib/string/base/last"],"@stdlib/string/base/last-grapheme-cluster":["@stdlib/string/base/first-grapheme-cluster","@stdlib/string/base/last-code-point","@stdlib/string/base/last"],"@stdlib/math/base/special/lcm":["@stdlib/math/base/special/gcd"],"@stdlib/math/base/special/ldexp":["@stdlib/math/base/special/frexp"],"@stdlib/string/base/left-pad":["@stdlib/string/base/right-pad"],"@stdlib/string/base/left-trim":["@stdlib/string/base/right-trim","@stdlib/string/base/trim"],"@stdlib/math/base/special/ln":["@stdlib/math/base/special/exp","@stdlib/math/base/special/log10","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/log":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log10","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/log1mexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log1pexp"],"@stdlib/math/base/special/log1p":["@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/log1pexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log1mexp","@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/log1pmx":["@stdlib/math/base/special/ln","@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/log2":["@stdlib/math/base/special/exp2","@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/log10":["@stdlib/math/base/special/exp10","@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/logaddexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln"],"@stdlib/math/base/special/logit":[],"@stdlib/string/base/lowercase":["@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/lucas":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negalucas"],"@stdlib/math/base/tools/lucaspoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/fibpoly"],"@stdlib/math/base/special/max":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/maxn","@stdlib/math/base/special/min"],"@stdlib/math/base/special/maxabs":["@stdlib/math/base/special/max","@stdlib/math/base/special/minabs"],"@stdlib/math/base/special/maxabsn":["@stdlib/math/base/special/maxn","@stdlib/math/base/special/maxabs","@stdlib/math/base/special/minabsn"],"@stdlib/math/base/special/maxn":["@stdlib/math/base/special/max","@stdlib/math/base/special/maxabsn","@stdlib/math/base/special/minn"],"@stdlib/math/base/special/min":["@stdlib/math/base/special/max","@stdlib/math/base/special/minabs","@stdlib/math/base/special/minn"],"@stdlib/math/base/special/minabs":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/min"],"@stdlib/math/base/special/minabsn":["@stdlib/math/base/special/maxabsn","@stdlib/math/base/special/minn","@stdlib/math/base/special/minabs"],"@stdlib/math/base/special/minmax":["@stdlib/math/base/special/max","@stdlib/math/base/special/min","@stdlib/math/base/special/minmaxabs"],"@stdlib/math/base/special/minmaxabs":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/minabs","@stdlib/math/base/special/minmax"],"@stdlib/math/base/special/minmaxabsn":["@stdlib/math/base/special/maxabsn","@stdlib/math/base/special/minabsn","@stdlib/math/base/special/minmaxn"],"@stdlib/math/base/special/minmaxn":["@stdlib/math/base/special/maxn","@stdlib/math/base/special/minn","@stdlib/math/base/special/minmaxabsn"],"@stdlib/math/base/special/minn":["@stdlib/math/base/special/maxn","@stdlib/math/base/special/min","@stdlib/math/base/special/minabsn"],"@stdlib/math/base/special/modf":[],"@stdlib/number/float64/base/mul":["@stdlib/number/float64/base/add","@stdlib/number/float64/base/div","@stdlib/number/float64/base/sub"],"@stdlib/number/float32/base/mul":["@stdlib/number/float32/base/add","@stdlib/number/float32/base/div","@stdlib/number/float64/base/mul","@stdlib/math/base/ops/subf"],"@stdlib/ndarray/base/ctor":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/base/unary":["@stdlib/ndarray/dispatch"],"@stdlib/ndarray/base/zeros":["@stdlib/ndarray/base/ctor","@stdlib/ndarray/base/zeros-like"],"@stdlib/ndarray/base/zeros-like":["@stdlib/ndarray/base/ctor","@stdlib/ndarray/base/zeros"],"@stdlib/math/base/special/negafibonacci":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negalucas"],"@stdlib/math/base/special/negalucas":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/lucas","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/nonfibonacci":["@stdlib/math/base/special/fibonacci"],"@stdlib/number/float64/base/normalize":["@stdlib/number/float32/base/normalize"],"@stdlib/number/float32/base/normalize":["@stdlib/number/float64/base/normalize"],"@stdlib/slice/base/normalize-multi-slice":["@stdlib/slice/base/normalize-slice"],"@stdlib/slice/base/normalize-slice":["@stdlib/slice/base/normalize-multi-slice"],"@stdlib/math/base/tools/normhermitepoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/hermitepoly"],"@stdlib/string/base/pascalcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/pdiff":[],"@stdlib/math/base/special/pdifff":["@stdlib/math/base/special/pdiff"],"@stdlib/string/base/percent-encode":[],"@stdlib/math/base/special/polygamma":["@stdlib/math/base/special/trigamma","@stdlib/math/base/special/digamma","@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/pow":["@stdlib/math/base/special/exp","@stdlib/math/base/special/powm1"],"@stdlib/math/base/special/powm1":["@stdlib/math/base/special/pow"],"@stdlib/math/base/special/rad2deg":["@stdlib/math/base/special/deg2rad"],"@stdlib/math/base/special/rad2degf":["@stdlib/math/base/special/rad2deg"],"@stdlib/math/base/special/ramp":["@stdlib/math/base/special/heaviside"],"@stdlib/math/base/special/rampf":["@stdlib/math/base/special/ramp"],"@stdlib/random/base/arcsine":["@stdlib/random/array/arcsine","@stdlib/random/iter/arcsine","@stdlib/random/streams/arcsine","@stdlib/random/base/beta"],"@stdlib/random/base/bernoulli":["@stdlib/random/array/bernoulli","@stdlib/random/iter/bernoulli","@stdlib/random/streams/bernoulli","@stdlib/random/base/binomial"],"@stdlib/random/base/beta":["@stdlib/random/array/beta","@stdlib/random/iter/beta","@stdlib/random/streams/beta"],"@stdlib/random/base/betaprime":["@stdlib/random/array/betaprime","@stdlib/random/iter/betaprime","@stdlib/random/streams/betaprime"],"@stdlib/random/base/binomial":["@stdlib/random/array/binomial","@stdlib/random/iter/binomial","@stdlib/random/streams/binomial"],"@stdlib/random/base/box-muller":["@stdlib/random/iter/box-muller","@stdlib/random/streams/box-muller"],"@stdlib/random/base/cauchy":["@stdlib/random/array/cauchy","@stdlib/random/iter/cauchy","@stdlib/random/streams/cauchy"],"@stdlib/random/base/chi":["@stdlib/random/array/chi","@stdlib/random/iter/chi","@stdlib/random/streams/chi"],"@stdlib/random/base/chisquare":["@stdlib/random/array/chisquare","@stdlib/random/iter/chisquare","@stdlib/random/streams/chisquare"],"@stdlib/random/base/cosine":["@stdlib/random/array/cosine","@stdlib/random/iter/cosine","@stdlib/random/streams/cosine"],"@stdlib/random/base/discrete-uniform":["@stdlib/random/array/discrete-uniform","@stdlib/random/iter/discrete-uniform","@stdlib/random/streams/discrete-uniform"],"@stdlib/random/base/erlang":["@stdlib/random/array/erlang","@stdlib/random/iter/erlang","@stdlib/random/streams/erlang"],"@stdlib/random/base/exponential":["@stdlib/random/array/exponential","@stdlib/random/iter/exponential","@stdlib/random/streams/exponential"],"@stdlib/random/base/f":["@stdlib/random/array/f","@stdlib/random/iter/f","@stdlib/random/streams/f"],"@stdlib/random/base/frechet":["@stdlib/random/array/frechet","@stdlib/random/iter/frechet","@stdlib/random/streams/frechet"],"@stdlib/random/base/gamma":["@stdlib/random/array/gamma","@stdlib/random/iter/gamma","@stdlib/random/streams/gamma"],"@stdlib/random/base/geometric":["@stdlib/random/array/geometric","@stdlib/random/iter/geometric","@stdlib/random/streams/geometric"],"@stdlib/random/base/gumbel":["@stdlib/random/array/gumbel","@stdlib/random/iter/gumbel","@stdlib/random/streams/gumbel"],"@stdlib/random/base/hypergeometric":["@stdlib/random/array/hypergeometric","@stdlib/random/iter/hypergeometric","@stdlib/random/streams/hypergeometric"],"@stdlib/random/base/improved-ziggurat":["@stdlib/random/iter/improved-ziggurat","@stdlib/random/streams/improved-ziggurat"],"@stdlib/random/base/invgamma":["@stdlib/random/array/invgamma","@stdlib/random/iter/invgamma","@stdlib/random/streams/invgamma"],"@stdlib/random/base/kumaraswamy":["@stdlib/random/array/kumaraswamy","@stdlib/random/iter/kumaraswamy","@stdlib/random/streams/kumaraswamy"],"@stdlib/random/base/laplace":["@stdlib/random/array/laplace","@stdlib/random/iter/laplace","@stdlib/random/streams/laplace"],"@stdlib/random/base/levy":["@stdlib/random/array/levy","@stdlib/random/iter/levy","@stdlib/random/streams/levy"],"@stdlib/random/base/logistic":["@stdlib/random/array/logistic","@stdlib/random/iter/logistic","@stdlib/random/streams/logistic"],"@stdlib/random/base/lognormal":["@stdlib/random/array/lognormal","@stdlib/random/iter/lognormal","@stdlib/random/streams/lognormal"],"@stdlib/random/base/minstd":["@stdlib/random/array/minstd","@stdlib/random/iter/minstd","@stdlib/random/streams/minstd","@stdlib/random/base/minstd-shuffle","@stdlib/random/base/mt19937","@stdlib/random/base/randi"],"@stdlib/random/base/minstd-shuffle":["@stdlib/random/array/minstd-shuffle","@stdlib/random/iter/minstd-shuffle","@stdlib/random/streams/minstd-shuffle","@stdlib/random/base/minstd","@stdlib/random/base/mt19937","@stdlib/random/base/randi"],"@stdlib/random/base/mt19937":["@stdlib/random/array/mt19937","@stdlib/random/iter/mt19937","@stdlib/random/streams/mt19937","@stdlib/random/base/minstd","@stdlib/random/base/randi"],"@stdlib/random/base/negative-binomial":["@stdlib/random/array/negative-binomial","@stdlib/random/iter/negative-binomial","@stdlib/random/streams/negative-binomial"],"@stdlib/random/base/normal":["@stdlib/random/array/normal","@stdlib/random/iter/normal","@stdlib/random/streams/normal"],"@stdlib/random/base/pareto-type1":["@stdlib/random/array/pareto-type1","@stdlib/random/iter/pareto-type1","@stdlib/random/streams/pareto-type1"],"@stdlib/random/base/poisson":["@stdlib/random/array/poisson","@stdlib/random/iter/poisson","@stdlib/random/streams/poisson"],"@stdlib/random/base/randi":["@stdlib/random/iter/randi","@stdlib/random/streams/randi","@stdlib/random/base/minstd","@stdlib/random/base/minstd-shuffle","@stdlib/random/base/mt19937"],"@stdlib/random/base/randn":["@stdlib/random/iter/randn","@stdlib/random/streams/randn","@stdlib/random/base/improved-ziggurat","@stdlib/random/base/randu"],"@stdlib/random/base/randu":["@stdlib/random/array/randu","@stdlib/random/iter/randu","@stdlib/random/streams/randu","@stdlib/random/base/discrete-uniform","@stdlib/random/base/randn"],"@stdlib/random/base/rayleigh":["@stdlib/random/array/rayleigh","@stdlib/random/iter/rayleigh","@stdlib/random/streams/rayleigh"],"@stdlib/random/base/t":["@stdlib/random/array/t","@stdlib/random/iter/t","@stdlib/random/streams/t"],"@stdlib/random/base/triangular":["@stdlib/random/array/triangular","@stdlib/random/iter/triangular","@stdlib/random/streams/triangular"],"@stdlib/random/base/uniform":["@stdlib/random/array/uniform","@stdlib/random/iter/uniform","@stdlib/random/streams/uniform","@stdlib/random/base/discrete-uniform","@stdlib/random/base/randu"],"@stdlib/random/base/weibull":["@stdlib/random/array/weibull","@stdlib/random/iter/weibull","@stdlib/random/streams/weibull"],"@stdlib/math/base/special/rcbrt":["@stdlib/math/base/special/cbrt"],"@stdlib/math/base/special/rcbrtf":["@stdlib/math/base/special/rcbrt","@stdlib/math/base/special/cbrtf"],"@stdlib/math/base/utils/relative-difference":["@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/float64-epsilon-difference"],"@stdlib/string/base/remove-first":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string/base/remove-last"],"@stdlib/string/base/remove-first-code-point":["@stdlib/string/base/remove-last-code-point","@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string/base/remove-first"],"@stdlib/string/base/remove-first-grapheme-cluster":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/string/base/remove-first"],"@stdlib/string/base/remove-last":["@stdlib/string/base/remove-last-code-point","@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/string/base/remove-first"],"@stdlib/string/base/remove-last-code-point":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/string/base/remove-last"],"@stdlib/string/base/remove-last-grapheme-cluster":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-last-code-point","@stdlib/string/base/remove-last"],"@stdlib/math/base/special/rempio2":[],"@stdlib/string/base/repeat":[],"@stdlib/string/base/replace":["@stdlib/string/base/replace-after","@stdlib/string/base/replace-before","@stdlib/string/base/replace-after-last","@stdlib/string/base/replace-before-last"],"@stdlib/string/base/replace-after":["@stdlib/string/base/replace-after-last","@stdlib/string/base/replace-before","@stdlib/string/base/replace-before-last"],"@stdlib/string/base/replace-after-last":["@stdlib/string/base/replace-after","@stdlib/string/base/replace-before-last","@stdlib/string/base/replace-before"],"@stdlib/string/base/replace-before":["@stdlib/string/base/replace-after","@stdlib/string/base/replace-before-last","@stdlib/string/base/replace-after-last"],"@stdlib/string/base/replace-before-last":["@stdlib/string/base/replace-after-last","@stdlib/string/base/replace-after","@stdlib/string/base/replace-before"],"@stdlib/string/base/reverse":["@stdlib/string/base/reverse-code-points","@stdlib/string/base/reverse-grapheme-clusters"],"@stdlib/string/base/reverse-code-points":["@stdlib/string/base/reverse-grapheme-clusters","@stdlib/string/base/reverse"],"@stdlib/string/base/reverse-grapheme-clusters":["@stdlib/string/base/reverse-code-points","@stdlib/string/base/reverse"],"@stdlib/string/base/right-pad":["@stdlib/string/base/left-pad"],"@stdlib/string/base/right-trim":["@stdlib/string/base/left-trim"],"@stdlib/math/base/special/rising-factorial":["@stdlib/math/base/special/falling-factorial"],"@stdlib/number/uint32/base/rotl":["@stdlib/number/uint32/base/rotr"],"@stdlib/number/uint32/base/rotr":["@stdlib/number/uint32/base/rotl"],"@stdlib/math/base/special/round":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floor","@stdlib/math/base/special/roundn","@stdlib/math/base/special/trunc"],"@stdlib/math/base/special/round2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/round10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/roundb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorb","@stdlib/math/base/special/round","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/roundn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorn","@stdlib/math/base/special/round","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/roundsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/round","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/special/rsqrt":["@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/rsqrtf":["@stdlib/math/base/special/rsqrt","@stdlib/math/base/special/sqrtf"],"@stdlib/slice/base/sargs2multislice":["@stdlib/slice/base/args2multislice","@stdlib/slice/base/seq2multislice"],"@stdlib/ndarray/base/from-scalar":["@stdlib/ndarray/array","@stdlib/ndarray/base/ctor","@stdlib/ndarray/ctor"],"@stdlib/math/base/special/secd":["@stdlib/math/base/special/cosd","@stdlib/math/base/special/cos"],"@stdlib/slice/base/seq2multislice":["@stdlib/slice/base/seq2slice","@stdlib/slice/base/sargs2multislice"],"@stdlib/slice/base/seq2slice":["@stdlib/slice/base/seq2multislice","@stdlib/slice/base/slice2seq"],"@stdlib/number/float64/base/set-high-word":["@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/set-low-word"],"@stdlib/number/float64/base/set-low-word":["@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/math/base/special/sici":[],"@stdlib/number/float64/base/signbit":["@stdlib/number/float32/base/signbit"],"@stdlib/number/float32/base/signbit":["@stdlib/number/float64/base/signbit"],"@stdlib/number/float32/base/significand":[],"@stdlib/math/base/special/signum":[],"@stdlib/math/base/special/signumf":["@stdlib/math/base/special/signum"],"@stdlib/math/base/special/sin":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sinpi","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/sinc":["@stdlib/math/base/special/sin"],"@stdlib/math/base/special/sincos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin","@stdlib/math/base/special/sincospi"],"@stdlib/math/base/special/sincospi":["@stdlib/math/base/special/cospi","@stdlib/math/base/special/sincos","@stdlib/math/base/special/sinpi"],"@stdlib/math/base/special/sinh":["@stdlib/math/base/special/cosh","@stdlib/math/base/special/sin","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/sinpi":["@stdlib/math/base/special/sin"],"@stdlib/slice/base/slice2seq":["@stdlib/slice/base/seq2slice"],"@stdlib/slice/base/length":["@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice/base/reduced-dimensions","@stdlib/slice/base/shape"],"@stdlib/slice/base/nonreduced-dimensions":["@stdlib/slice/base/length","@stdlib/slice/base/reduced-dimensions","@stdlib/slice/base/shape"],"@stdlib/slice/base/reduced-dimensions":["@stdlib/slice/base/length","@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice/base/shape"],"@stdlib/slice/base/shape":["@stdlib/slice/base/length","@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice/base/reduced-dimensions"],"@stdlib/string/base/snakecase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/stickycase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/spence":[],"@stdlib/math/base/special/sqrt":["@stdlib/math/base/special/cbrt","@stdlib/math/base/special/rsqrt"],"@stdlib/math/base/special/sqrt1pm1":["@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/sqrtf":["@stdlib/math/base/special/cbrtf","@stdlib/math/base/special/rsqrtf","@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/sqrtpi":["@stdlib/math/base/special/sqrt"],"@stdlib/string/base/startcase":["@stdlib/string/base/capitalize","@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/string/base/starts-with":["@stdlib/string/base/ends-with"],"@stdlib/string/base/stickycase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/strided/base/binary":["@stdlib/strided/base/dmap2","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/smap2","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/strided/base/binary-dtype-signatures":["@stdlib/strided/base/binary-signature-callbacks"],"@stdlib/strided/base/binary-signature-callbacks":["@stdlib/strided/base/binary-dtype-signatures"],"@stdlib/blas/base/ccopy":["@stdlib/blas/base/cswap"],"@stdlib/strided/base/cmap":["@stdlib/strided/base/zmap","@stdlib/strided/base/unary"],"@stdlib/blas/base/cswap":["@stdlib/blas/base/ccopy"],"@stdlib/stats/base/cumax":["@stdlib/stats/base/cumin","@stdlib/stats/strided/dcumax","@stdlib/stats/base/scumax"],"@stdlib/stats/base/cumaxabs":["@stdlib/stats/base/cumax","@stdlib/stats/base/cuminabs","@stdlib/stats/strided/dcumaxabs","@stdlib/stats/base/scumaxabs"],"@stdlib/stats/base/cumin":["@stdlib/stats/base/cumax","@stdlib/stats/base/dcumin","@stdlib/stats/base/scumin"],"@stdlib/stats/base/cuminabs":["@stdlib/stats/base/cumaxabs","@stdlib/stats/base/cumin","@stdlib/stats/strided/dcuminabs","@stdlib/stats/base/scuminabs"],"@stdlib/math/strided/special/dabs":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/sabs"],"@stdlib/math/strided/special/dabs2":["@stdlib/math/strided/special/abs2","@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/sabs2"],"@stdlib/blas/ext/base/dapx":["@stdlib/blas/ext/base/gapx","@stdlib/blas/ext/base/sapx"],"@stdlib/blas/ext/base/dapxsum":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/sapxsum"],"@stdlib/blas/ext/base/dapxsumkbn":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gapxsumkbn","@stdlib/blas/ext/base/sapxsumkbn"],"@stdlib/blas/ext/base/dapxsumkbn2":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gapxsumkbn2","@stdlib/blas/ext/base/sapxsumkbn2"],"@stdlib/blas/ext/base/dapxsumors":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gapxsumors","@stdlib/blas/ext/base/sapxsumors"],"@stdlib/blas/ext/base/dapxsumpw":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas/ext/base/sapxsumpw"],"@stdlib/blas/base/dasum":["@stdlib/blas/base/daxpy","@stdlib/blas/base/gasum","@stdlib/blas/base/sasum","@stdlib/blas/ext/base/dsum"],"@stdlib/blas/ext/base/dasumpw":["@stdlib/blas/base/dasum","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gasumpw","@stdlib/blas/ext/base/sasumpw"],"@stdlib/blas/base/daxpy":["@stdlib/blas/base/dasum","@stdlib/blas/base/gaxpy","@stdlib/blas/base/saxpy"],"@stdlib/math/strided/special/dcbrt":["@stdlib/math/strided/special/cbrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/scbrt"],"@stdlib/math/strided/special/dceil":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/sceil"],"@stdlib/blas/base/dcopy":["@stdlib/blas/base/dswap","@stdlib/blas/base/gcopy","@stdlib/blas/base/scopy"],"@stdlib/stats/strided/dcumax":["@stdlib/stats/base/cumax","@stdlib/stats/base/dcumin","@stdlib/stats/base/scumax"],"@stdlib/stats/strided/dcumaxabs":["@stdlib/stats/base/cumaxabs","@stdlib/stats/strided/dcumax","@stdlib/stats/strided/dcuminabs","@stdlib/stats/base/scumaxabs"],"@stdlib/stats/base/dcumin":["@stdlib/stats/base/cumin","@stdlib/stats/strided/dcumax","@stdlib/stats/base/scumin"],"@stdlib/stats/strided/dcuminabs":["@stdlib/stats/base/cuminabs","@stdlib/stats/strided/dcumaxabs","@stdlib/stats/base/dcumin","@stdlib/stats/base/scuminabs"],"@stdlib/blas/ext/base/dcusum":["@stdlib/blas/ext/base/dcusumpw","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/scusum"],"@stdlib/blas/ext/base/dcusumkbn":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas/ext/base/scusumkbn"],"@stdlib/blas/ext/base/dcusumkbn2":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas/ext/base/scusumkbn2"],"@stdlib/blas/ext/base/dcusumors":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumors","@stdlib/blas/ext/base/scusumors"],"@stdlib/blas/ext/base/dcusumpw":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusumpw"],"@stdlib/math/strided/special/ddeg2rad":["@stdlib/math/strided/special/deg2rad","@stdlib/math/strided/special/sdeg2rad"],"@stdlib/blas/base/ddot":["@stdlib/blas/base/dsdot","@stdlib/blas/base/gdot","@stdlib/blas/base/sdot","@stdlib/blas/base/sdsdot","@stdlib/blas/ddot"],"@stdlib/blas/ext/base/dfill":["@stdlib/blas/ext/base/gfill","@stdlib/blas/ext/base/sfill"],"@stdlib/math/strided/special/dfloor":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/sfloor"],"@stdlib/math/strided/special/dinv":["@stdlib/math/strided/special/inv","@stdlib/math/strided/special/sinv"],"@stdlib/strided/base/dmap":["@stdlib/strided/base/smap","@stdlib/strided/base/unary"],"@stdlib/strided/base/dmap2":["@stdlib/strided/base/smap2","@stdlib/strided/base/binary"],"@stdlib/stats/strided/dmax":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/max","@stdlib/stats/base/smax"],"@stdlib/stats/strided/dmaxabs":["@stdlib/stats/strided/dmax","@stdlib/stats/strided/dminabs","@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/smaxabs"],"@stdlib/stats/strided/dmaxabssorted":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/smaxabssorted"],"@stdlib/stats/strided/dmaxsorted":["@stdlib/stats/strided/dmax","@stdlib/stats/strided/dminsorted","@stdlib/stats/base/maxsorted","@stdlib/stats/base/smaxsorted"],"@stdlib/stats/base/dmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/mean","@stdlib/stats/base/smean"],"@stdlib/stats/strided/dmeankbn":["@stdlib/stats/base/dmean","@stdlib/stats/base/meankbn","@stdlib/stats/base/smeankbn"],"@stdlib/stats/strided/dmeankbn2":["@stdlib/stats/base/dmean","@stdlib/stats/base/meankbn2","@stdlib/stats/base/smeankbn2"],"@stdlib/stats/strided/dmeanli":["@stdlib/stats/base/dmean","@stdlib/stats/strided/dmeanlipw","@stdlib/stats/base/smeanli"],"@stdlib/stats/strided/dmeanlipw":["@stdlib/stats/base/dmean","@stdlib/stats/strided/dmeanli","@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/smeanlipw"],"@stdlib/stats/strided/dmeanors":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/smeanors"],"@stdlib/stats/base/dmeanpn":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/smeanpn"],"@stdlib/stats/strided/dmeanpw":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanpw","@stdlib/stats/base/meanpw","@stdlib/stats/base/smeanpw"],"@stdlib/stats/base/dmeanstdev":["@stdlib/stats/base/dmean","@stdlib/stats/base/dmeanvar","@stdlib/stats/base/dstdev"],"@stdlib/stats/base/dmeanstdevpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/dmeanstdev","@stdlib/stats/base/dmeanvarpn","@stdlib/stats/base/dstdevpn"],"@stdlib/stats/base/dmeanvar":["@stdlib/stats/base/dmean","@stdlib/stats/base/dvariance"],"@stdlib/stats/base/dmeanvarpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/dmeanstdevpn","@stdlib/stats/base/dmeanvar","@stdlib/stats/base/dvariancepn"],"@stdlib/stats/strided/dmeanwd":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/smeanwd"],"@stdlib/stats/strided/dmediansorted":["@stdlib/stats/base/dmean","@stdlib/stats/base/mediansorted","@stdlib/stats/base/smediansorted"],"@stdlib/stats/strided/dmidrange":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dmean","@stdlib/stats/strided/dmin","@stdlib/stats/base/drange","@stdlib/stats/base/smidrange"],"@stdlib/stats/strided/dmin":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/min","@stdlib/stats/base/smin"],"@stdlib/stats/strided/dminabs":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dmaxabs","@stdlib/stats/base/dnanminabs","@stdlib/stats/base/minabs","@stdlib/stats/base/sminabs"],"@stdlib/stats/strided/dminsorted":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/minsorted","@stdlib/stats/base/sminsorted"],"@stdlib/math/strided/special/dmskabs":["@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/dmskabs2","@stdlib/math/strided/special/smskabs"],"@stdlib/math/strided/special/dmskabs2":["@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/dmskabs","@stdlib/math/strided/special/smskabs2"],"@stdlib/math/strided/special/dmskcbrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/dmsksqrt","@stdlib/math/strided/special/smskcbrt"],"@stdlib/math/strided/special/dmskceil":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/dmskfloor","@stdlib/math/strided/special/dmsktrunc","@stdlib/math/strided/special/smskceil"],"@stdlib/math/strided/special/dmskdeg2rad":["@stdlib/math/strided/special/ddeg2rad","@stdlib/math/strided/special/dmskdeg2rad","@stdlib/math/strided/special/smskdeg2rad"],"@stdlib/math/strided/special/dmskfloor":["@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/dmskceil","@stdlib/math/strided/special/dmsktrunc","@stdlib/math/strided/special/smskfloor"],"@stdlib/math/strided/special/dmskinv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/smskinv"],"@stdlib/strided/base/dmskmap":["@stdlib/strided/base/dmap","@stdlib/strided/base/dmskmap2","@stdlib/strided/base/mskunary","@stdlib/strided/base/smskmap"],"@stdlib/strided/base/dmskmap2":["@stdlib/strided/base/dmap2","@stdlib/strided/base/dmskmap","@stdlib/strided/base/smskmap2"],"@stdlib/stats/base/dmskmax":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dmskmin","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/mskmax","@stdlib/stats/base/smskmax"],"@stdlib/stats/base/dmskmin":["@stdlib/stats/strided/dmin","@stdlib/stats/base/dmskmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/mskmin","@stdlib/stats/base/smskmin"],"@stdlib/math/strided/special/dmskramp":["@stdlib/math/strided/special/dramp","@stdlib/math/strided/special/smskramp"],"@stdlib/stats/base/dmskrange":["@stdlib/stats/base/dmskmax","@stdlib/stats/base/dmskmin","@stdlib/stats/base/dnanrange","@stdlib/stats/base/drange","@stdlib/stats/base/mskrange","@stdlib/stats/base/smskrange"],"@stdlib/math/strided/special/dmskrsqrt":["@stdlib/math/strided/special/dmsksqrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/smskrsqrt"],"@stdlib/math/strided/special/dmsksqrt":["@stdlib/math/strided/special/dmskcbrt","@stdlib/math/strided/special/dmskrsqrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/smsksqrt"],"@stdlib/math/strided/special/dmsktrunc":["@stdlib/math/strided/special/dmskceil","@stdlib/math/strided/special/dmskfloor","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/smsktrunc"],"@stdlib/blas/ext/base/dnanasum":["@stdlib/blas/base/dasum","@stdlib/blas/ext/base/dasumpw"],"@stdlib/blas/ext/base/dnanasumors":["@stdlib/blas/ext/base/dnanasum"],"@stdlib/stats/strided/dnanmax":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/nanmax","@stdlib/stats/base/snanmax"],"@stdlib/stats/strided/dnanmaxabs":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanminabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/snanmaxabs"],"@stdlib/stats/strided/dnanmean":["@stdlib/stats/base/dmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/dnanmeanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/strided/dnanmean","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/dnanmeanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/strided/dnanmean","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/dnanmeanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/strided/dnanmean"],"@stdlib/stats/base/dnanmeanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/strided/dnanmean","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/snanmeanwd"],"@stdlib/stats/base/dnanmin":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/dnanminabs":["@stdlib/stats/strided/dminabs","@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/dnanmin","@stdlib/stats/base/nanminabs","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/dnanmskmax":["@stdlib/stats/base/dmskmax","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/dnanmskmin":["@stdlib/stats/base/dmskmin","@stdlib/stats/base/dnanmin","@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/dnanmskrange":["@stdlib/stats/base/dmskrange","@stdlib/stats/base/dnanrange","@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/nanmskrange","@stdlib/stats/base/snanmskrange"],"@stdlib/blas/ext/base/dnannsum":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dsum"],"@stdlib/blas/ext/base/dnannsumkbn":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dnannsumpw","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gnannsumkbn"],"@stdlib/blas/ext/base/dnannsumkbn2":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dnannsumpw","@stdlib/blas/ext/base/dsumkbn2"],"@stdlib/blas/ext/base/dnannsumors":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas/ext/base/dnannsumpw","@stdlib/blas/ext/base/dsumors"],"@stdlib/blas/ext/base/dnannsumpw":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dsumpw"],"@stdlib/stats/base/dnanrange":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/drange","@stdlib/stats/base/nanrange","@stdlib/stats/base/snanrange"],"@stdlib/stats/base/dnanstdev":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/dstdev","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdev"],"@stdlib/stats/base/dnanstdevch":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/dstdevch","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/snanstdevch"],"@stdlib/stats/base/dnanstdevpn":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/dstdevpn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/snanstdevpn"],"@stdlib/stats/base/dnanstdevtk":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/dstdevtk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/snanstdevtk"],"@stdlib/stats/base/dnanstdevwd":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/dstdevwd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/snanstdevwd"],"@stdlib/stats/base/dnanstdevyc":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/dstdevyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/snanstdevyc"],"@stdlib/blas/ext/base/dnansum":["@stdlib/stats/strided/dnanmean","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/gnansum"],"@stdlib/blas/ext/base/dnansumkbn":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/snansumkbn"],"@stdlib/blas/ext/base/dnansumkbn2":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/snansumkbn2"],"@stdlib/blas/ext/base/dnansumors":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/snansumors"],"@stdlib/blas/ext/base/dnansumpw":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/stats/base/dnanvariance":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dvariance","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariance"],"@stdlib/stats/base/dnanvariancech":["@stdlib/stats/base/dvariancech","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/snanvariancech"],"@stdlib/stats/base/dnanvariancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/snanvariancepn"],"@stdlib/stats/base/dnanvariancetk":["@stdlib/stats/base/dvariancetk","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/snanvariancetk"],"@stdlib/stats/base/dnanvariancewd":["@stdlib/stats/base/dvariancewd","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/snanvariancewd"],"@stdlib/stats/base/dnanvarianceyc":["@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/snanvarianceyc"],"@stdlib/blas/base/dnrm2":["@stdlib/blas/base/gnrm2","@stdlib/blas/base/snrm2"],"@stdlib/math/strided/special/dramp":["@stdlib/math/strided/special/ramp","@stdlib/math/strided/special/sramp"],"@stdlib/stats/base/drange":["@stdlib/stats/strided/dmax","@stdlib/stats/strided/dmin","@stdlib/stats/base/dnanrange","@stdlib/stats/base/range","@stdlib/stats/base/srange"],"@stdlib/blas/ext/base/drev":["@stdlib/blas/ext/base/grev","@stdlib/blas/ext/base/srev"],"@stdlib/math/strided/special/drsqrt":["@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/rsqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/blas/ext/base/dsapxsum":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/sapxsum"],"@stdlib/blas/ext/base/dsapxsumpw":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/dsapxsum","@stdlib/blas/ext/base/dssumpw","@stdlib/blas/ext/base/sapxsumpw"],"@stdlib/blas/base/dscal":["@stdlib/blas/base/daxpy","@stdlib/blas/base/gscal","@stdlib/blas/base/sscal","@stdlib/blas/base/saxpy"],"@stdlib/blas/base/dsdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/sdot","@stdlib/blas/base/sdsdot"],"@stdlib/stats/base/dsem":["@stdlib/stats/base/dstdev"],"@stdlib/stats/base/dsemch":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevch"],"@stdlib/stats/base/dsempn":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevpn"],"@stdlib/stats/base/dsemtk":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevtk"],"@stdlib/stats/base/dsemwd":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevwd"],"@stdlib/stats/base/dsemyc":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevyc"],"@stdlib/stats/base/dsmean":["@stdlib/stats/base/dmean","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/mean","@stdlib/stats/base/sdsmean","@stdlib/stats/base/smean"],"@stdlib/stats/base/dsmeanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/base/dsmean","@stdlib/stats/base/dsnanmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/smeanors"],"@stdlib/stats/base/dsmeanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/dsmean","@stdlib/stats/base/dsnanmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/smeanpn"],"@stdlib/stats/base/dsmeanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/dsmean","@stdlib/stats/base/meanpw","@stdlib/stats/base/smeanpw"],"@stdlib/stats/base/dsmeanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/base/dsmean","@stdlib/stats/base/dsnanmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/smeanwd"],"@stdlib/stats/base/dsnanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/dsmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/dsnanmeanors":["@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/dsmeanors","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/dsnanmeanpn":["@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/dsmeanpn","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/dsnanmeanwd":["@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/dsmeanwd","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmeanwd"],"@stdlib/blas/ext/base/dsnannsumors":["@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dsnansumors","@stdlib/blas/ext/base/dssumors"],"@stdlib/blas/ext/base/dsnansum":["@stdlib/stats/base/dsnanmean","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/sdsnansum","@stdlib/blas/ext/base/snansum"],"@stdlib/blas/ext/base/dsnansumors":["@stdlib/stats/base/dsnanmeanors","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dssumors","@stdlib/blas/ext/base/snansumors"],"@stdlib/blas/ext/base/dsnansumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dssumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/blas/ext/base/dsort2hp":["@stdlib/blas/ext/base/dsorthp","@stdlib/blas/ext/base/gsort2hp","@stdlib/blas/ext/base/ssort2hp"],"@stdlib/blas/ext/base/dsort2ins":["@stdlib/blas/ext/base/dsortins","@stdlib/blas/ext/base/gsort2ins","@stdlib/blas/ext/base/ssort2ins"],"@stdlib/blas/ext/base/dsort2sh":["@stdlib/blas/ext/base/dsortsh","@stdlib/blas/ext/base/gsort2sh","@stdlib/blas/ext/base/ssort2sh"],"@stdlib/blas/ext/base/dsorthp":["@stdlib/blas/ext/base/dsort2hp","@stdlib/blas/ext/base/gsorthp","@stdlib/blas/ext/base/ssorthp"],"@stdlib/blas/ext/base/dsortins":["@stdlib/blas/ext/base/dsort2ins","@stdlib/blas/ext/base/gsortins","@stdlib/blas/ext/base/ssortins"],"@stdlib/blas/ext/base/dsortsh":["@stdlib/blas/ext/base/dsort2sh","@stdlib/blas/ext/base/gsortsh","@stdlib/blas/ext/base/ssortsh"],"@stdlib/math/strided/special/dsqrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/drsqrt","@stdlib/math/strided/special/sqrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/blas/ext/base/dssum":["@stdlib/blas/ext/base/dsnansum","@stdlib/blas/ext/base/sdssum","@stdlib/blas/ext/base/ssum","@stdlib/stats/base/dsmean"],"@stdlib/blas/ext/base/dssumors":["@stdlib/blas/ext/base/dsnansumors","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/dssumpw":["@stdlib/blas/ext/base/dsnansumpw","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/ssumpw"],"@stdlib/stats/base/dstdev":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dvariance","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdev"],"@stdlib/stats/base/dstdevch":["@stdlib/stats/base/dnanstdevch","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancech","@stdlib/stats/base/sstdevch","@stdlib/stats/base/stdevch"],"@stdlib/stats/base/dstdevpn":["@stdlib/stats/base/dnanstdevpn","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancepn","@stdlib/stats/base/sstdevpn","@stdlib/stats/base/stdevpn"],"@stdlib/stats/base/dstdevtk":["@stdlib/stats/base/dnanstdevtk","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancetk","@stdlib/stats/base/sstdevtk","@stdlib/stats/base/stdevtk"],"@stdlib/stats/base/dstdevwd":["@stdlib/stats/base/dnanstdevwd","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancewd","@stdlib/stats/base/sstdevwd","@stdlib/stats/base/stdevwd"],"@stdlib/stats/base/dstdevyc":["@stdlib/stats/base/dnanstdevyc","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/sstdevyc","@stdlib/stats/base/stdevyc"],"@stdlib/blas/ext/base/dsum":["@stdlib/blas/base/dasum","@stdlib/stats/base/dmean","@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/gsum"],"@stdlib/blas/ext/base/dsumkbn":["@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/dsumkbn2":["@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/dsumors":["@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/dsumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumpw"],"@stdlib/stats/base/dsvariance":["@stdlib/stats/base/dvariance","@stdlib/stats/base/variance","@stdlib/stats/base/svariance"],"@stdlib/stats/base/dsvariancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/dsvariance","@stdlib/stats/base/variancepn","@stdlib/stats/base/svariancepn"],"@stdlib/blas/base/dswap":["@stdlib/blas/base/dcopy","@stdlib/blas/base/gswap","@stdlib/blas/base/sswap","@stdlib/blas/dswap"],"@stdlib/math/strided/special/dtrunc":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/trunc","@stdlib/math/strided/special/strunc"],"@stdlib/strided/base/dtype-enum2str":["@stdlib/strided/base/dtype-str2enum"],"@stdlib/strided/base/dtype-resolve-enum":["@stdlib/strided/base/dtype-resolve-str"],"@stdlib/strided/base/dtype-resolve-str":["@stdlib/strided/base/dtype-resolve-enum"],"@stdlib/strided/base/dtype-str2enum":["@stdlib/strided/base/dtype-enum2str"],"@stdlib/stats/base/dvariance":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvarm","@stdlib/stats/base/svariance","@stdlib/stats/base/variance"],"@stdlib/stats/base/dvariancech":["@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/dstdevch","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancech","@stdlib/stats/base/variancech"],"@stdlib/stats/base/dvariancepn":["@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/dstdevpn","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancepn","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/dvariancetk":["@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/dstdevtk","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancetk","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/dvariancewd":["@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/dstdevwd","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancewd","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/dvarianceyc":["@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/dstdevyc","@stdlib/stats/base/dvariance","@stdlib/stats/base/svarianceyc","@stdlib/stats/base/varianceyc"],"@stdlib/stats/base/dvarm":["@stdlib/stats/base/dvariance"],"@stdlib/stats/base/dvarmpn":["@stdlib/stats/base/dvarm"],"@stdlib/stats/base/dvarmtk":["@stdlib/stats/base/dvarm"],"@stdlib/strided/base/function-object":[],"@stdlib/blas/ext/base/gapx":["@stdlib/blas/ext/base/dapx","@stdlib/blas/ext/base/sapx"],"@stdlib/blas/ext/base/gapxsum":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/sapxsum"],"@stdlib/blas/ext/base/gapxsumkbn":["@stdlib/blas/ext/base/dapxsumkbn","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/sapxsumkbn"],"@stdlib/blas/ext/base/gapxsumkbn2":["@stdlib/blas/ext/base/dapxsumkbn2","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/sapxsumkbn2"],"@stdlib/blas/ext/base/gapxsumors":["@stdlib/blas/ext/base/dapxsumors","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/sapxsumors"],"@stdlib/blas/ext/base/gapxsumpw":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/sapxsumpw"],"@stdlib/blas/base/gasum":["@stdlib/blas/base/dasum","@stdlib/blas/base/sasum"],"@stdlib/blas/ext/base/gasumpw":["@stdlib/blas/base/gasum","@stdlib/blas/ext/base/dasumpw","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/sasumpw"],"@stdlib/blas/base/gaxpy":["@stdlib/blas/base/daxpy","@stdlib/blas/base/saxpy"],"@stdlib/blas/base/gcopy":["@stdlib/blas/base/dcopy","@stdlib/blas/base/scopy"],"@stdlib/blas/ext/base/gcusum":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusum"],"@stdlib/blas/ext/base/gcusumkbn":["@stdlib/blas/ext/base/dcusumkbn","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas/ext/base/scusumkbn"],"@stdlib/blas/ext/base/gcusumkbn2":["@stdlib/blas/ext/base/dcusumkbn2","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas/ext/base/scusumkbn2"],"@stdlib/blas/ext/base/gcusumors":["@stdlib/blas/ext/base/dcusumors","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusumors"],"@stdlib/blas/ext/base/gcusumpw":["@stdlib/blas/ext/base/dcusumpw","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/scusumpw"],"@stdlib/blas/base/gdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/sdot","@stdlib/blas/gdot"],"@stdlib/blas/ext/base/gfill":["@stdlib/blas/ext/base/dfill","@stdlib/blas/ext/base/sfill"],"@stdlib/blas/ext/base/gfill-by":["@stdlib/blas/ext/base/gfill"],"@stdlib/blas/ext/base/gnannsumkbn":["@stdlib/blas/ext/base/dnannsumkbn"],"@stdlib/blas/ext/base/gnansum":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/gsum","@stdlib/stats/base/nanmean"],"@stdlib/blas/ext/base/gnansumkbn":["@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/snansumkbn"],"@stdlib/blas/ext/base/gnansumkbn2":["@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/snansumkbn2"],"@stdlib/blas/ext/base/gnansumors":["@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/snansumors"],"@stdlib/blas/ext/base/gnansumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/blas/base/gnrm2":["@stdlib/blas/base/dnrm2","@stdlib/blas/base/snrm2"],"@stdlib/blas/ext/base/grev":["@stdlib/blas/ext/base/drev","@stdlib/blas/ext/base/srev"],"@stdlib/blas/base/gscal":["@stdlib/blas/base/dscal","@stdlib/blas/base/gaxpy","@stdlib/blas/base/sscal"],"@stdlib/blas/ext/base/gsort2hp":["@stdlib/blas/ext/base/dsort2hp","@stdlib/blas/ext/base/gsorthp","@stdlib/blas/ext/base/ssort2hp"],"@stdlib/blas/ext/base/gsort2ins":["@stdlib/blas/ext/base/dsort2ins","@stdlib/blas/ext/base/gsortins","@stdlib/blas/ext/base/ssort2ins"],"@stdlib/blas/ext/base/gsort2sh":["@stdlib/blas/ext/base/dsort2sh","@stdlib/blas/ext/base/gsortsh","@stdlib/blas/ext/base/ssort2sh"],"@stdlib/blas/ext/base/gsorthp":["@stdlib/blas/ext/base/dsorthp","@stdlib/blas/ext/base/gsort2hp","@stdlib/blas/ext/base/ssorthp"],"@stdlib/blas/ext/base/gsortins":["@stdlib/blas/ext/base/dsortins","@stdlib/blas/ext/base/gsort2ins","@stdlib/blas/ext/base/ssortins"],"@stdlib/blas/ext/base/gsortsh":["@stdlib/blas/ext/base/dsortsh","@stdlib/blas/ext/base/gsort2sh","@stdlib/blas/ext/base/ssortsh"],"@stdlib/blas/ext/base/gsum":["@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/ssum","@stdlib/stats/base/mean"],"@stdlib/blas/ext/base/gsumkbn":["@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/gsumkbn2":["@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/gsumors":["@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/gsumpw":["@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/base/gswap":["@stdlib/blas/base/dswap","@stdlib/blas/base/gcopy","@stdlib/blas/base/sswap","@stdlib/blas/gswap"],"@stdlib/strided/base/map-by":["@stdlib/strided/base/map-by2","@stdlib/strided/base/unary"],"@stdlib/strided/base/map-by2":["@stdlib/strided/base/map-by","@stdlib/strided/base/binary"],"@stdlib/stats/base/max":["@stdlib/stats/strided/dmax","@stdlib/stats/base/min","@stdlib/stats/base/nanmax","@stdlib/stats/base/smax"],"@stdlib/stats/base/maxabs":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/base/max","@stdlib/stats/base/minabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/smaxabs"],"@stdlib/stats/base/max-by":["@stdlib/stats/strided/dmax","@stdlib/stats/base/max","@stdlib/stats/base/min-by","@stdlib/stats/base/nanmax-by","@stdlib/stats/base/smax"],"@stdlib/stats/base/maxsorted":["@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/max","@stdlib/stats/base/minsorted","@stdlib/stats/base/smaxsorted"],"@stdlib/strided/base/max-view-buffer-index":[],"@stdlib/stats/base/mean":["@stdlib/stats/base/dmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/smean"],"@stdlib/stats/base/meankbn":["@stdlib/stats/strided/dmeankbn","@stdlib/stats/base/mean","@stdlib/stats/base/smeankbn"],"@stdlib/stats/base/meankbn2":["@stdlib/stats/strided/dmeankbn2","@stdlib/stats/base/mean","@stdlib/stats/base/smeankbn2"],"@stdlib/stats/base/meanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/base/mean","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/smeanors"],"@stdlib/stats/base/meanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/mean","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/smeanpn"],"@stdlib/stats/base/meanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/mean","@stdlib/stats/base/smeanpw"],"@stdlib/stats/base/meanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/base/mean","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/smeanwd"],"@stdlib/stats/base/mediansorted":["@stdlib/stats/strided/dmediansorted","@stdlib/stats/base/mean","@stdlib/stats/base/smediansorted"],"@stdlib/strided/base/meta-data-props":[],"@stdlib/stats/base/min":["@stdlib/stats/strided/dmin","@stdlib/stats/base/max","@stdlib/stats/base/nanmin","@stdlib/stats/base/smin"],"@stdlib/stats/base/minabs":["@stdlib/stats/strided/dminabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/min","@stdlib/stats/base/nanminabs","@stdlib/stats/base/sminabs"],"@stdlib/stats/base/min-by":["@stdlib/stats/strided/dmin","@stdlib/stats/base/max-by","@stdlib/stats/base/min","@stdlib/stats/base/nanmin-by","@stdlib/stats/base/smin"],"@stdlib/stats/base/minsorted":["@stdlib/stats/strided/dminsorted","@stdlib/stats/base/maxsorted","@stdlib/stats/base/min","@stdlib/stats/base/sminsorted"],"@stdlib/strided/base/min-view-buffer-index":["@stdlib/strided/base/offset-view"],"@stdlib/stats/base/mskmax":["@stdlib/stats/base/dmskmax","@stdlib/stats/base/max","@stdlib/stats/base/mskmin","@stdlib/stats/base/nanmax","@stdlib/stats/base/smskmax"],"@stdlib/stats/base/mskmin":["@stdlib/stats/base/dmskmin","@stdlib/stats/base/min","@stdlib/stats/base/mskmax","@stdlib/stats/base/nanmin","@stdlib/stats/base/smskmin"],"@stdlib/stats/base/mskrange":["@stdlib/stats/base/dmskrange","@stdlib/stats/base/range","@stdlib/stats/base/mskmax","@stdlib/stats/base/mskmin","@stdlib/stats/base/nanrange","@stdlib/stats/base/smskrange"],"@stdlib/strided/base/mskunary":["@stdlib/strided/base/dmskmap","@stdlib/strided/base/smskmap","@stdlib/strided/base/unary"],"@stdlib/strided/base/mskunary-dtype-signatures":["@stdlib/strided/base/mskunary-signature-callbacks"],"@stdlib/strided/base/mskunary-signature-callbacks":["@stdlib/strided/base/mskunary-dtype-signatures"],"@stdlib/stats/base/nanmax":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/max","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/nanmaxabs":["@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanminabs","@stdlib/stats/base/snanmaxabs"],"@stdlib/stats/base/nanmax-by":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/max-by","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanmin-by","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/nanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/mean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/nanmeanors":["@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/nanmeanpn":["@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/nanmeanwd":["@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmeanwd"],"@stdlib/stats/base/nanmin":["@stdlib/stats/base/dnanmin","@stdlib/stats/base/min","@stdlib/stats/base/nanmax","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/nanminabs":["@stdlib/stats/base/dnanminabs","@stdlib/stats/base/minabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/nanmin-by":["@stdlib/stats/base/dnanmin","@stdlib/stats/base/min-by","@stdlib/stats/base/nanmax-by","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/nanmskmax":["@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/mskmax","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/nanmskmin":["@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/mskmin","@stdlib/stats/base/nanmin","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/nanmskrange":["@stdlib/stats/base/dnanmskrange","@stdlib/stats/base/mskrange","@stdlib/stats/base/nanrange","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/snanmskrange"],"@stdlib/stats/base/nanrange":["@stdlib/stats/base/dnanrange","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanmin","@stdlib/stats/base/range","@stdlib/stats/base/snanrange"],"@stdlib/stats/base/nanrange-by":["@stdlib/stats/base/dnanrange","@stdlib/stats/base/nanmax-by","@stdlib/stats/base/nanmin-by","@stdlib/stats/base/nanrange","@stdlib/stats/base/range-by","@stdlib/stats/base/snanrange"],"@stdlib/stats/base/nanstdev":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanstdev","@stdlib/stats/base/stdev"],"@stdlib/stats/base/nanstdevch":["@stdlib/stats/base/dnanstdevch","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevch","@stdlib/stats/base/stdevch"],"@stdlib/stats/base/nanstdevpn":["@stdlib/stats/base/dnanstdevpn","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevpn","@stdlib/stats/base/stdevpn"],"@stdlib/stats/base/nanstdevtk":["@stdlib/stats/base/dnanstdevtk","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevtk","@stdlib/stats/base/stdevtk"],"@stdlib/stats/base/nanstdevwd":["@stdlib/stats/base/dnanstdevwd","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevwd","@stdlib/stats/base/stdevwd"],"@stdlib/stats/base/nanstdevyc":["@stdlib/stats/base/dnanstdevyc","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevyc","@stdlib/stats/base/stdevyc"],"@stdlib/stats/base/nanvariance":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanvariance","@stdlib/stats/base/variance"],"@stdlib/stats/base/nanvariancech":["@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancech","@stdlib/stats/base/variancech"],"@stdlib/stats/base/nanvariancepn":["@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancepn","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/nanvariancetk":["@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancetk","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/nanvariancewd":["@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancewd","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/nanvarianceyc":["@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvarianceyc","@stdlib/stats/base/varianceyc"],"@stdlib/strided/base/nullary":["@stdlib/strided/base/binary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/strided/base/offset-view":["@stdlib/strided/base/min-view-buffer-index"],"@stdlib/strided/base/quaternary":["@stdlib/strided/base/binary","@stdlib/strided/base/nullary","@stdlib/strided/base/quinary","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/strided/base/quinary":["@stdlib/strided/base/binary","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/stats/base/range":["@stdlib/stats/base/drange","@stdlib/stats/base/max","@stdlib/stats/base/min","@stdlib/stats/base/nanrange","@stdlib/stats/base/srange"],"@stdlib/stats/base/range-by":["@stdlib/stats/base/drange","@stdlib/stats/base/max-by","@stdlib/stats/base/min-by","@stdlib/stats/base/nanrange-by","@stdlib/stats/base/range","@stdlib/stats/base/srange"],"@stdlib/strided/base/reinterpret-complex":["@stdlib/strided/base/reinterpret-complex128","@stdlib/strided/base/reinterpret-complex64"],"@stdlib/strided/base/reinterpret-complex64":["@stdlib/strided/base/reinterpret-complex","@stdlib/strided/base/reinterpret-complex128"],"@stdlib/strided/base/reinterpret-complex128":["@stdlib/strided/base/reinterpret-complex","@stdlib/strided/base/reinterpret-complex64"],"@stdlib/math/strided/special/sabs":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/sabs2"],"@stdlib/math/strided/special/sabs2":["@stdlib/math/strided/special/abs2","@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/sabs"],"@stdlib/blas/ext/base/sapx":["@stdlib/blas/ext/base/dapx","@stdlib/blas/ext/base/gapx"],"@stdlib/blas/ext/base/sapxsum":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/sapxsumpw","@stdlib/blas/ext/base/ssum"],"@stdlib/blas/ext/base/sapxsumkbn":["@stdlib/blas/ext/base/dapxsumkbn","@stdlib/blas/ext/base/gapxsumkbn","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/sapxsumkbn2":["@stdlib/blas/ext/base/dapxsumkbn2","@stdlib/blas/ext/base/gapxsumkbn2","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/sapxsumors":["@stdlib/blas/ext/base/dapxsumors","@stdlib/blas/ext/base/gapxsumors","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/sapxsumpw":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/base/sasum":["@stdlib/blas/base/dasum","@stdlib/blas/base/gasum"],"@stdlib/blas/ext/base/sasumpw":["@stdlib/blas/base/sasum","@stdlib/blas/ext/base/dasumpw","@stdlib/blas/ext/base/gasumpw","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/base/saxpy":["@stdlib/blas/base/daxpy","@stdlib/blas/base/gaxpy"],"@stdlib/math/strided/special/scbrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/cbrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/math/strided/special/sceil":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/sfloor","@stdlib/math/strided/special/strunc"],"@stdlib/blas/base/scopy":["@stdlib/blas/base/dcopy","@stdlib/blas/base/gcopy","@stdlib/blas/base/sswap"],"@stdlib/stats/base/scumax":["@stdlib/stats/base/cumax","@stdlib/stats/strided/dcumax","@stdlib/stats/base/scumin"],"@stdlib/stats/base/scumaxabs":["@stdlib/stats/base/cumaxabs","@stdlib/stats/strided/dcumaxabs","@stdlib/stats/base/scumax","@stdlib/stats/base/scuminabs"],"@stdlib/stats/base/scumin":["@stdlib/stats/base/cumin","@stdlib/stats/base/dcumin","@stdlib/stats/base/scumax"],"@stdlib/stats/base/scuminabs":["@stdlib/stats/base/cuminabs","@stdlib/stats/strided/dcuminabs","@stdlib/stats/base/scumaxabs","@stdlib/stats/base/scumin"],"@stdlib/blas/ext/base/scusum":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/scusumpw"],"@stdlib/blas/ext/base/scusumkbn":["@stdlib/blas/ext/base/dcusumkbn","@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas/ext/base/scusum","@stdlib/blas/ext/base/scusumkbn2"],"@stdlib/blas/ext/base/scusumkbn2":["@stdlib/blas/ext/base/dcusumkbn2","@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas/ext/base/scusum","@stdlib/blas/ext/base/scusumkbn"],"@stdlib/blas/ext/base/scusumors":["@stdlib/blas/ext/base/dcusumors","@stdlib/blas/ext/base/gcusumors","@stdlib/blas/ext/base/scusum"],"@stdlib/blas/ext/base/scusumpw":["@stdlib/blas/ext/base/dcusumpw","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusum"],"@stdlib/math/strided/special/sdeg2rad":["@stdlib/math/strided/special/ddeg2rad","@stdlib/math/strided/special/deg2rad"],"@stdlib/blas/base/sdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/dsdot","@stdlib/blas/base/sdsdot","@stdlib/blas/sdot"],"@stdlib/blas/ext/base/sdsapxsum":["@stdlib/blas/ext/base/dsapxsum","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/sdssum"],"@stdlib/blas/ext/base/sdsapxsumpw":["@stdlib/blas/ext/base/dsapxsumpw","@stdlib/blas/ext/base/sapxsumpw","@stdlib/blas/ext/base/sdsapxsum","@stdlib/blas/ext/base/sdssumpw"],"@stdlib/blas/base/sdsdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/dsdot","@stdlib/blas/base/sdot"],"@stdlib/stats/base/sdsmean":["@stdlib/stats/base/dmean","@stdlib/stats/base/dsmean","@stdlib/stats/base/mean","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/smean"],"@stdlib/stats/base/sdsmeanors":["@stdlib/stats/base/sdsmean","@stdlib/stats/base/sdsnanmeanors"],"@stdlib/stats/base/sdsnanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/sdsmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/sdsnanmeanors":["@stdlib/stats/base/sdsmeanors","@stdlib/stats/base/sdsnanmean"],"@stdlib/blas/ext/base/sdsnansum":["@stdlib/blas/ext/base/dsnansum","@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/sdssum","@stdlib/blas/ext/base/snansum"],"@stdlib/blas/ext/base/sdsnansumpw":["@stdlib/blas/ext/base/dsnansumpw","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/sdsnansum","@stdlib/blas/ext/base/sdssumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/blas/ext/base/sdssum":["@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/sdsnansum","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/gsum"],"@stdlib/blas/ext/base/sdssumpw":["@stdlib/blas/ext/base/dssumpw","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/sdsnansumpw","@stdlib/blas/ext/base/sdssum","@stdlib/blas/ext/base/ssumpw","@stdlib/blas/ext/base/gsumpw"],"@stdlib/blas/ext/base/sfill":["@stdlib/blas/ext/base/dfill","@stdlib/blas/ext/base/gfill"],"@stdlib/math/strided/special/sfloor":["@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/sceil","@stdlib/math/strided/special/strunc"],"@stdlib/math/strided/special/sinv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/inv"],"@stdlib/strided/base/smap":["@stdlib/strided/base/dmap","@stdlib/strided/base/unary"],"@stdlib/strided/base/smap2":["@stdlib/strided/base/dmap2","@stdlib/strided/base/binary"],"@stdlib/stats/base/smax":["@stdlib/stats/strided/dmax","@stdlib/stats/base/max","@stdlib/stats/base/smin","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/smaxabs":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/smax","@stdlib/stats/base/sminabs","@stdlib/stats/base/snanmaxabs"],"@stdlib/stats/base/smaxabssorted":["@stdlib/stats/strided/dmaxabssorted","@stdlib/stats/base/smaxabs","@stdlib/stats/base/smaxsorted"],"@stdlib/stats/base/smaxsorted":["@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/maxsorted","@stdlib/stats/base/smax","@stdlib/stats/base/sminsorted"],"@stdlib/stats/base/smean":["@stdlib/stats/base/dmean","@stdlib/stats/base/dsmean","@stdlib/stats/base/mean","@stdlib/stats/base/sdsmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/smeankbn":["@stdlib/stats/strided/dmeankbn","@stdlib/stats/base/meankbn","@stdlib/stats/base/smean"],"@stdlib/stats/base/smeankbn2":["@stdlib/stats/strided/dmeankbn2","@stdlib/stats/base/meankbn2","@stdlib/stats/base/smean"],"@stdlib/stats/base/smeanli":["@stdlib/stats/strided/dmeanli","@stdlib/stats/base/smean","@stdlib/stats/base/smeanlipw"],"@stdlib/stats/base/smeanlipw":["@stdlib/stats/strided/dmeanlipw","@stdlib/stats/base/smean","@stdlib/stats/base/smeanli"],"@stdlib/stats/base/smeanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/smean","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/smeanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/smean","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/smeanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/meanpw","@stdlib/stats/base/smean"],"@stdlib/stats/base/smeanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/smean","@stdlib/stats/base/snanmeanwd"],"@stdlib/stats/base/smediansorted":["@stdlib/stats/strided/dmediansorted","@stdlib/stats/base/mediansorted","@stdlib/stats/base/smean"],"@stdlib/stats/base/smidrange":["@stdlib/stats/strided/dmidrange","@stdlib/stats/base/smax","@stdlib/stats/base/smean","@stdlib/stats/base/smin","@stdlib/stats/base/srange"],"@stdlib/stats/base/smin":["@stdlib/stats/strided/dmin","@stdlib/stats/base/min","@stdlib/stats/base/smax","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/sminabs":["@stdlib/stats/strided/dminabs","@stdlib/stats/base/minabs","@stdlib/stats/base/smaxabs","@stdlib/stats/base/smin","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/sminsorted":["@stdlib/stats/strided/dminsorted","@stdlib/stats/base/minsorted","@stdlib/stats/base/smaxsorted","@stdlib/stats/base/smin"],"@stdlib/math/strided/special/smskabs":["@stdlib/math/strided/special/dmskabs","@stdlib/math/strided/special/sabs","@stdlib/math/strided/special/smskabs2"],"@stdlib/math/strided/special/smskabs2":["@stdlib/math/strided/special/dmskabs2","@stdlib/math/strided/special/sabs2","@stdlib/math/strided/special/smskabs"],"@stdlib/math/strided/special/smskcbrt":["@stdlib/math/strided/special/dmskcbrt","@stdlib/math/strided/special/scbrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/math/strided/special/smskceil":["@stdlib/math/strided/special/dmskceil","@stdlib/math/strided/special/sceil","@stdlib/math/strided/special/smskfloor","@stdlib/math/strided/special/smsktrunc"],"@stdlib/math/strided/special/smskdeg2rad":["@stdlib/math/strided/special/dmskdeg2rad","@stdlib/math/strided/special/sdeg2rad"],"@stdlib/math/strided/special/smskfloor":["@stdlib/math/strided/special/dmskfloor","@stdlib/math/strided/special/sfloor","@stdlib/math/strided/special/smskceil","@stdlib/math/strided/special/smsktrunc"],"@stdlib/math/strided/special/smskinv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/dmskinv"],"@stdlib/strided/base/smskmap":["@stdlib/strided/base/dmskmap","@stdlib/strided/base/mskunary","@stdlib/strided/base/smap","@stdlib/strided/base/smskmap2"],"@stdlib/strided/base/smskmap2":["@stdlib/strided/base/dmskmap2","@stdlib/strided/base/smap2","@stdlib/strided/base/smskmap"],"@stdlib/stats/base/smskmax":["@stdlib/stats/base/dmskmax","@stdlib/stats/base/mskmax","@stdlib/stats/base/smax","@stdlib/stats/base/smskmin","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/smskmin":["@stdlib/stats/base/dmskmin","@stdlib/stats/base/mskmin","@stdlib/stats/base/smin","@stdlib/stats/base/smskmax","@stdlib/stats/base/snanmin","@stdlib/stats/base/snanmskmin"],"@stdlib/math/strided/special/smskramp":["@stdlib/math/strided/special/dmskramp","@stdlib/math/strided/special/sramp"],"@stdlib/stats/base/smskrange":["@stdlib/stats/base/dmskrange","@stdlib/stats/base/mskrange","@stdlib/stats/base/smskmax","@stdlib/stats/base/smskmin","@stdlib/stats/base/snanrange","@stdlib/stats/base/srange"],"@stdlib/math/strided/special/smskrsqrt":["@stdlib/math/strided/special/dmskrsqrt","@stdlib/math/strided/special/smsksqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/math/strided/special/smsksqrt":["@stdlib/math/strided/special/dmsksqrt","@stdlib/math/strided/special/smskcbrt","@stdlib/math/strided/special/smskrsqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/math/strided/special/smsktrunc":["@stdlib/math/strided/special/dmsktrunc","@stdlib/math/strided/special/smskceil","@stdlib/math/strided/special/smskfloor","@stdlib/math/strided/special/strunc"],"@stdlib/stats/base/snanmax":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/nanmax","@stdlib/stats/base/smax","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/snanmaxabs":["@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/smaxabs","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/snanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/smean","@stdlib/stats/base/nanmean"],"@stdlib/stats/base/snanmeanors":["@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/smeanors","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/snanmeanpn":["@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/smeanpn","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/snanmeanwd":["@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/smeanwd","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/snanmin":["@stdlib/stats/base/dnanmin","@stdlib/stats/base/nanmin","@stdlib/stats/base/smin","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/snanminabs":["@stdlib/stats/base/dnanminabs","@stdlib/stats/base/nanminabs","@stdlib/stats/base/sminabs","@stdlib/stats/base/snanmaxabs","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/snanmskmax":["@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/smskmax","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/snanmskmin":["@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/smskmin","@stdlib/stats/base/snanmin","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/snanmskrange":["@stdlib/stats/base/dnanmskrange","@stdlib/stats/base/nanmskrange","@stdlib/stats/base/smskrange","@stdlib/stats/base/snanrange","@stdlib/stats/base/snanmskmax","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/snanrange":["@stdlib/stats/base/dnanrange","@stdlib/stats/base/nanrange","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanmin","@stdlib/stats/base/srange"],"@stdlib/stats/base/snanstdev":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanvariance","@stdlib/stats/base/sstdev"],"@stdlib/stats/base/snanstdevch":["@stdlib/stats/base/dnanstdevch","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancech","@stdlib/stats/base/sstdevch"],"@stdlib/stats/base/snanstdevpn":["@stdlib/stats/base/dnanstdevpn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancepn","@stdlib/stats/base/sstdevpn"],"@stdlib/stats/base/snanstdevtk":["@stdlib/stats/base/dnanstdevtk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancetk","@stdlib/stats/base/sstdevtk"],"@stdlib/stats/base/snanstdevwd":["@stdlib/stats/base/dnanstdevwd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancewd","@stdlib/stats/base/sstdevwd"],"@stdlib/stats/base/snanstdevyc":["@stdlib/stats/base/dnanstdevyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvarianceyc","@stdlib/stats/base/sstdevyc"],"@stdlib/blas/ext/base/snansum":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/gnansum","@stdlib/stats/base/snanmean","@stdlib/blas/ext/base/ssum"],"@stdlib/blas/ext/base/snansumkbn":["@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/snansumkbn2":["@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/snansumors":["@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/snansumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/stats/base/snanvariance":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanstdev","@stdlib/stats/base/svariance"],"@stdlib/stats/base/snanvariancech":["@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/snanstdevch","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancech"],"@stdlib/stats/base/snanvariancepn":["@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/snanstdevpn","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancepn"],"@stdlib/stats/base/snanvariancetk":["@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/snanstdevtk","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancetk"],"@stdlib/stats/base/snanvariancewd":["@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/snanstdevwd","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancewd"],"@stdlib/stats/base/snanvarianceyc":["@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/snanstdevyc","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svarianceyc"],"@stdlib/blas/base/snrm2":["@stdlib/blas/base/dnrm2","@stdlib/blas/base/gnrm2"],"@stdlib/math/strided/special/sramp":["@stdlib/math/strided/special/dramp","@stdlib/math/strided/special/ramp"],"@stdlib/stats/base/srange":["@stdlib/stats/base/drange","@stdlib/stats/base/smax","@stdlib/stats/base/smin","@stdlib/stats/base/snanrange","@stdlib/stats/base/range"],"@stdlib/blas/ext/base/srev":["@stdlib/blas/ext/base/drev","@stdlib/blas/ext/base/grev"],"@stdlib/math/strided/special/srsqrt":["@stdlib/math/strided/special/drsqrt","@stdlib/math/strided/special/rsqrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/blas/base/sscal":["@stdlib/blas/base/daxpy","@stdlib/blas/base/dscal","@stdlib/blas/base/gscal","@stdlib/blas/base/saxpy"],"@stdlib/blas/ext/base/ssort2hp":["@stdlib/blas/ext/base/dsort2hp","@stdlib/blas/ext/base/gsort2hp","@stdlib/blas/ext/base/ssorthp"],"@stdlib/blas/ext/base/ssort2ins":["@stdlib/blas/ext/base/dsort2ins","@stdlib/blas/ext/base/gsort2ins","@stdlib/blas/ext/base/ssortins"],"@stdlib/blas/ext/base/ssort2sh":["@stdlib/blas/ext/base/dsort2sh","@stdlib/blas/ext/base/gsort2sh","@stdlib/blas/ext/base/ssortsh"],"@stdlib/blas/ext/base/ssorthp":["@stdlib/blas/ext/base/dsorthp","@stdlib/blas/ext/base/gsorthp","@stdlib/blas/ext/base/ssort2hp"],"@stdlib/blas/ext/base/ssortins":["@stdlib/blas/ext/base/dsortins","@stdlib/blas/ext/base/gsortins","@stdlib/blas/ext/base/ssort2ins"],"@stdlib/blas/ext/base/ssortsh":["@stdlib/blas/ext/base/dsortsh","@stdlib/blas/ext/base/gsortsh","@stdlib/blas/ext/base/ssort2sh"],"@stdlib/math/strided/special/ssqrt":["@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/scbrt","@stdlib/math/strided/special/sqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/stats/base/sstdev":["@stdlib/stats/base/dstdev","@stdlib/stats/base/snanstdev","@stdlib/stats/base/stdev","@stdlib/stats/base/svariance"],"@stdlib/stats/base/sstdevch":["@stdlib/stats/base/dstdevch","@stdlib/stats/base/snanstdevch","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevch","@stdlib/stats/base/svariancech"],"@stdlib/stats/base/sstdevpn":["@stdlib/stats/base/dstdevpn","@stdlib/stats/base/snanstdevpn","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevpn","@stdlib/stats/base/svariancepn"],"@stdlib/stats/base/sstdevtk":["@stdlib/stats/base/dstdevtk","@stdlib/stats/base/snanstdevtk","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevtk","@stdlib/stats/base/svariancetk"],"@stdlib/stats/base/sstdevwd":["@stdlib/stats/base/dstdevwd","@stdlib/stats/base/snanstdevwd","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevwd","@stdlib/stats/base/svariancewd"],"@stdlib/stats/base/sstdevyc":["@stdlib/stats/base/dstdevyc","@stdlib/stats/base/snanstdevyc","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevyc","@stdlib/stats/base/svarianceyc"],"@stdlib/blas/ext/base/ssum":["@stdlib/blas/ext/base/dsum","@stdlib/stats/base/smean","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/gsum"],"@stdlib/blas/ext/base/ssumkbn":["@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/snansumkbn","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas/ext/base/ssumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/ext/base/ssumkbn2":["@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn","@stdlib/blas/ext/base/ssumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/ext/base/ssumors":["@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/ext/base/ssumpw":["@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/base/sswap":["@stdlib/blas/base/dswap","@stdlib/blas/base/gswap","@stdlib/blas/base/scopy","@stdlib/blas/sswap"],"@stdlib/stats/base/stdev":["@stdlib/stats/base/dstdev","@stdlib/stats/base/nanstdev","@stdlib/stats/base/sstdev","@stdlib/stats/base/variance"],"@stdlib/stats/base/stdevch":["@stdlib/stats/base/dstdevch","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/sstdevch","@stdlib/stats/base/stdev","@stdlib/stats/base/variancech"],"@stdlib/stats/base/stdevpn":["@stdlib/stats/base/dstdevpn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/sstdevpn","@stdlib/stats/base/stdev","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/stdevtk":["@stdlib/stats/base/dstdevtk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/sstdevtk","@stdlib/stats/base/stdev","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/stdevwd":["@stdlib/stats/base/dstdevwd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/sstdevwd","@stdlib/stats/base/stdev","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/stdevyc":["@stdlib/stats/base/dstdevyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/sstdevyc","@stdlib/stats/base/stdev","@stdlib/stats/base/varianceyc"],"@stdlib/math/strided/special/strunc":["@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/sceil","@stdlib/math/strided/special/sfloor","@stdlib/math/strided/special/trunc"],"@stdlib/stats/base/svariance":["@stdlib/stats/base/dvariance","@stdlib/stats/base/snanvariance","@stdlib/stats/base/sstdev","@stdlib/stats/base/variance"],"@stdlib/stats/base/svariancech":["@stdlib/stats/base/dvariancech","@stdlib/stats/base/snanvariancech","@stdlib/stats/base/sstdevch","@stdlib/stats/base/svariance","@stdlib/stats/base/variancech"],"@stdlib/stats/base/svariancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/snanvariancepn","@stdlib/stats/base/sstdevpn","@stdlib/stats/base/svariance","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/svariancetk":["@stdlib/stats/base/dvariancetk","@stdlib/stats/base/snanvariancetk","@stdlib/stats/base/sstdevtk","@stdlib/stats/base/svariance","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/svariancewd":["@stdlib/stats/base/dvariancewd","@stdlib/stats/base/snanvariancewd","@stdlib/stats/base/sstdevwd","@stdlib/stats/base/svariance","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/svarianceyc":["@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/snanvarianceyc","@stdlib/stats/base/sstdevyc","@stdlib/stats/base/svariance","@stdlib/stats/base/varianceyc"],"@stdlib/strided/base/ternary":["@stdlib/strided/base/binary","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/unary"],"@stdlib/strided/base/unary":["@stdlib/strided/base/unary","@stdlib/strided/base/dmap","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/smap","@stdlib/strided/base/ternary"],"@stdlib/strided/base/unary-by":["@stdlib/strided/base/map-by","@stdlib/strided/base/unary"],"@stdlib/strided/base/unary-dtype-signatures":["@stdlib/strided/base/unary-signature-callbacks"],"@stdlib/strided/base/unary-signature-callbacks":["@stdlib/strided/base/unary-dtype-signatures"],"@stdlib/stats/base/variance":["@stdlib/stats/base/dvariance","@stdlib/stats/base/nanvariance","@stdlib/stats/base/stdev","@stdlib/stats/base/svariance"],"@stdlib/stats/base/variancech":["@stdlib/stats/base/dvariancech","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/stdevch","@stdlib/stats/base/variance"],"@stdlib/stats/base/variancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/stdevpn","@stdlib/stats/base/variance"],"@stdlib/stats/base/variancetk":["@stdlib/stats/base/dvariancetk","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/stdevtk","@stdlib/stats/base/variance"],"@stdlib/stats/base/variancewd":["@stdlib/stats/base/dvariancewd","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/stdevwd","@stdlib/stats/base/variance"],"@stdlib/stats/base/varianceyc":["@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/stdevyc","@stdlib/stats/base/variance"],"@stdlib/strided/base/zmap":["@stdlib/strided/base/cmap","@stdlib/strided/base/unary"],"@stdlib/slice/base/str2multislice":["@stdlib/slice/base/str2slice"],"@stdlib/slice/base/str2slice":["@stdlib/slice/base/str2multislice"],"@stdlib/number/float64/base/sub":["@stdlib/number/float64/base/add","@stdlib/number/float64/base/div","@stdlib/number/float64/base/mul"],"@stdlib/math/base/ops/subf":["@stdlib/number/float32/base/add","@stdlib/number/float32/base/div","@stdlib/number/float32/base/mul","@stdlib/number/float64/base/sub"],"@stdlib/math/base/tools/sum-series":[],"@stdlib/math/base/special/tan":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/tand":["@stdlib/math/base/special/tan","@stdlib/math/base/special/cosd"],"@stdlib/math/base/special/tanh":["@stdlib/math/base/special/cosh","@stdlib/math/base/special/sinh","@stdlib/math/base/special/tan"],"@stdlib/number/float64/base/to-binary-string":["@stdlib/number/float64/base/from-binary-string","@stdlib/number/float32/base/to-binary-string"],"@stdlib/number/float32/base/to-binary-string":["@stdlib/number/float32/base/from-binary-string","@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint8/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint16/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint32/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/float32/base/to-word":["@stdlib/number/float32/base/from-word","@stdlib/number/float64/base/to-words"],"@stdlib/number/float64/base/to-words":["@stdlib/number/float64/base/from-words","@stdlib/number/float32/base/to-word"],"@stdlib/ndarray/base/transpose":["@stdlib/ndarray/ctor"],"@stdlib/math/base/special/tribonacci":["@stdlib/math/base/special/fibonacci"],"@stdlib/math/base/special/trigamma":["@stdlib/math/base/special/digamma","@stdlib/math/base/special/gamma"],"@stdlib/string/base/trim":["@stdlib/string/base/left-trim","@stdlib/string/base/right-trim"],"@stdlib/math/base/special/trunc":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floor","@stdlib/math/base/special/round"],"@stdlib/math/base/special/trunc2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round2","@stdlib/math/base/special/trunc","@stdlib/math/base/special/trunc10"],"@stdlib/math/base/special/trunc10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round10","@stdlib/math/base/special/trunc","@stdlib/math/base/special/trunc2"],"@stdlib/string/base/truncate-middle":[],"@stdlib/math/base/special/truncb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundb","@stdlib/math/base/special/trunc","@stdlib/math/base/special/truncn"],"@stdlib/math/base/special/truncf":["@stdlib/math/base/special/ceilf","@stdlib/math/base/special/floorf","@stdlib/math/base/special/trunc"],"@stdlib/math/base/special/truncn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundn","@stdlib/math/base/special/trunc","@stdlib/math/base/special/truncb"],"@stdlib/math/base/special/truncsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/trunc"],"@stdlib/number/uint32/base/to-int32":[],"@stdlib/math/base/ops/umul":["@stdlib/math/base/ops/imul"],"@stdlib/math/base/ops/umuldw":["@stdlib/math/base/ops/imuldw","@stdlib/math/base/ops/umul"],"@stdlib/string/base/uncapitalize":["@stdlib/string/base/capitalize"],"@stdlib/string/base/uppercase":["@stdlib/string/base/lowercase"],"@stdlib/math/base/special/vercos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/versin":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/wrap":["@stdlib/math/base/special/clamp"],"@stdlib/math/base/special/xlog1py":["@stdlib/math/base/special/log1p","@stdlib/math/base/special/xlogy"],"@stdlib/math/base/special/xlogy":["@stdlib/math/base/special/ln","@stdlib/math/base/special/xlog1py"],"@stdlib/math/base/special/riemann-zeta":[],"@stdlib/bench":["@stdlib/utils/timeit"],"@stdlib/datasets/berndt-cps-wages-1985":[],"@stdlib/utils/bifurcate":["@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-own","@stdlib/utils/group"],"@stdlib/utils/bifurcate-by":["@stdlib/utils/bifurcate","@stdlib/utils/group-by"],"@stdlib/utils/async/bifurcate-by":["@stdlib/utils/bifurcate-by","@stdlib/utils/async/group-by"],"@stdlib/utils/bifurcate-in":["@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-own","@stdlib/utils/group-in"],"@stdlib/utils/bifurcate-own":["@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-in","@stdlib/utils/group-own"],"@stdlib/bigint/ctor":[],"@stdlib/stats/binomial-test":[],"@stdlib/boolean/ctor":[],"@stdlib/array/bool":["@stdlib/array/buffer"],"@stdlib/ndarray/broadcast-array":["@stdlib/ndarray/array","@stdlib/ndarray/broadcast-arrays","@stdlib/ndarray/ctor","@stdlib/ndarray/maybe-broadcast-array"],"@stdlib/ndarray/broadcast-arrays":["@stdlib/ndarray/array","@stdlib/ndarray/broadcast-array","@stdlib/ndarray/ctor","@stdlib/ndarray/maybe-broadcast-arrays"],"@stdlib/buffer/ctor":["@stdlib/array/buffer"],"@stdlib/buffer/to-json":["@stdlib/array/to-json","@stdlib/buffer/reviver"],"@stdlib/os/byte-order":["@stdlib/assert/is-big-endian","@stdlib/assert/is-little-endian"],"@stdlib/string/camelcase":["@stdlib/string/constantcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/string/capitalize":["@stdlib/string/uncapitalize","@stdlib/string/uppercase"],"@stdlib/utils/capitalize-keys":["@stdlib/utils/uncapitalize-keys","@stdlib/utils/uppercase-keys"],"@stdlib/constants/float64/catalan":[],"@stdlib/constants/float64/cbrt-eps":["@stdlib/constants/float64/eps","@stdlib/constants/float64/sqrt-eps"],"@stdlib/datasets/cdc-nchs-us-births-1969-1988":["@stdlib/datasets/cdc-nchs-us-births-1994-2003","@stdlib/datasets/ssa-us-births-2000-2014"],"@stdlib/datasets/cdc-nchs-us-births-1994-2003":["@stdlib/datasets/cdc-nchs-us-births-1969-1988","@stdlib/datasets/ssa-us-births-2000-2014"],"@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013":[],"@stdlib/process/chdir":["@stdlib/process/cwd"],"@stdlib/stats/chi2gof":[],"@stdlib/stats/chi2test":[],"@stdlib/array/to-circular-iterator":["@stdlib/array/to-iterator","@stdlib/array/to-strided-iterator"],"@stdlib/streams/node/from-circular-array":["@stdlib/streams/node/from-array","@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-strided-array"],"@stdlib/dstructs/circular-buffer":["@stdlib/dstructs/fifo","@stdlib/dstructs/stack"],"@stdlib/fs/close":["@stdlib/fs/exists","@stdlib/fs/open","@stdlib/fs/read-file"],"@stdlib/datasets/cmudict":[],"@stdlib/string/code-point-at":["@stdlib/string/from-code-point"],"@stdlib/utils/common-keys":["@stdlib/utils/common-keys-in","@stdlib/utils/keys"],"@stdlib/utils/common-keys-in":["@stdlib/utils/common-keys","@stdlib/utils/keys-in"],"@stdlib/complex/cmplx":["@stdlib/complex/float64/ctor","@stdlib/complex/float32/ctor"],"@stdlib/complex/float32/ctor":["@stdlib/complex/cmplx","@stdlib/complex/float64/ctor"],"@stdlib/constants/complex64/nan":["@stdlib/constants/complex128/nan"],"@stdlib/constants/complex64/num-bytes":["@stdlib/constants/complex128/num-bytes","@stdlib/constants/float32/num-bytes"],"@stdlib/constants/complex64/zero":["@stdlib/constants/complex128/zero"],"@stdlib/array/complex64":["@stdlib/array/complex128","@stdlib/complex/cmplx","@stdlib/complex/float32/ctor"],"@stdlib/complex/float64/ctor":["@stdlib/complex/cmplx","@stdlib/complex/float32/ctor"],"@stdlib/constants/complex128/nan":["@stdlib/constants/complex64/nan"],"@stdlib/constants/complex128/num-bytes":["@stdlib/constants/complex64/num-bytes","@stdlib/constants/float64/num-bytes"],"@stdlib/constants/complex128/zero":["@stdlib/constants/complex64/zero"],"@stdlib/array/complex128":["@stdlib/array/complex64","@stdlib/complex/cmplx","@stdlib/complex/float64/ctor"],"@stdlib/array/typed-complex":["@stdlib/array/typed","@stdlib/array/typed-real"],"@stdlib/array/typed-complex-ctors":["@stdlib/array/ctors","@stdlib/array/typed-ctors","@stdlib/array/typed-real-ctors"],"@stdlib/array/typed-complex-dtypes":["@stdlib/array/dtypes","@stdlib/array/typed-dtypes","@stdlib/array/typed-real-dtypes","@stdlib/ndarray/dtypes"],"@stdlib/complex/ctors":["@stdlib/array/typed-complex-ctors"],"@stdlib/complex/dtype":["@stdlib/array/dtype"],"@stdlib/complex/dtypes":["@stdlib/array/typed-complex-dtypes"],"@stdlib/complex/promotion-rules":["@stdlib/array/promotion-rules","@stdlib/ndarray/promotion-rules"],"@stdlib/utils/compose":["@stdlib/utils/async/compose"],"@stdlib/utils/async/compose":["@stdlib/utils/compose"],"@stdlib/os/configdir":["@stdlib/os/homedir","@stdlib/os/tmpdir"],"@stdlib/complex/float64/conj":["@stdlib/complex/float64/imag","@stdlib/complex/float64/real","@stdlib/complex/float64/reim"],"@stdlib/complex/float32/conj":["@stdlib/complex/float64/conj","@stdlib/complex/float32/imag","@stdlib/complex/float32/real","@stdlib/complex/float32/reim"],"@stdlib/string/constantcase":["@stdlib/string/camelcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/utils/constant-function":["@stdlib/utils/argument-function","@stdlib/utils/identity-function"],"@stdlib/streams/node/from-constant":["@stdlib/streams/node/from-array","@stdlib/streams/node/from-iterator"],"@stdlib/utils/constructor-name":["@stdlib/utils/function-name"],"@stdlib/assert/contains":[],"@stdlib/array/convert":["@stdlib/array/convert-same"],"@stdlib/array/convert-same":["@stdlib/array/convert"],"@stdlib/utils/convert-path":[],"@stdlib/utils/copy":["@stdlib/utils/merge"],"@stdlib/buffer/from-buffer":["@stdlib/buffer/alloc-unsafe","@stdlib/buffer/ctor"],"@stdlib/utils/count-by":["@stdlib/utils/group","@stdlib/utils/group-by"],"@stdlib/utils/async/count-by":["@stdlib/utils/count-by","@stdlib/utils/async/group-by","@stdlib/utils/async/tabulate-by"],"@stdlib/time/current-year":["@stdlib/assert/is-current-year"],"@stdlib/utils/curry":["@stdlib/utils/curry-right","@stdlib/utils/uncurry","@stdlib/utils/uncurry-right"],"@stdlib/utils/curry-right":["@stdlib/utils/curry","@stdlib/utils/uncurry","@stdlib/utils/uncurry-right"],"@stdlib/process/cwd":["@stdlib/process/chdir"],"@stdlib/datasets/dale-chall-new":[],"@stdlib/datasets":[],"@stdlib/array/dataview":["@stdlib/array/buffer","@stdlib/array/typed"],"@stdlib/array/datespace":["@stdlib/array/linspace","@stdlib/array/logspace"],"@stdlib/time/day-of-quarter":["@stdlib/time/day-of-year"],"@stdlib/time/day-of-year":["@stdlib/time/day-of-quarter"],"@stdlib/time/days-in-month":["@stdlib/time/days-in-year"],"@stdlib/time/days-in-year":["@stdlib/time/days-in-month"],"@stdlib/blas/ddot":["@stdlib/blas/base/ddot","@stdlib/blas/gdot","@stdlib/blas/sdot"],"@stdlib/streams/node/debug-sink":["@stdlib/streams/node/debug","@stdlib/streams/node/inspect-sink"],"@stdlib/streams/node/debug":["@stdlib/streams/node/debug-sink","@stdlib/streams/node/inspect"],"@stdlib/utils/decorate-after":[],"@stdlib/assert/deep-equal":["@stdlib/assert/is-strict-equal","@stdlib/assert/is-same-value"],"@stdlib/utils/deep-get":["@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/assert/deep-has-own-property":["@stdlib/assert/deep-has-property","@stdlib/assert/has-own-property","@stdlib/utils/deep-get","@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/assert/deep-has-property":["@stdlib/assert/deep-has-own-property","@stdlib/assert/has-own-property","@stdlib/utils/deep-get","@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/utils/deep-pluck":["@stdlib/utils/deep-get","@stdlib/utils/deep-set"],"@stdlib/utils/deep-set":["@stdlib/utils/deep-get","@stdlib/utils/deep-pluck"],"@stdlib/utils/define-memoized-property":["@stdlib/utils/define-memoized-read-only-property","@stdlib/utils/define-property"],"@stdlib/utils/define-properties":["@stdlib/utils/define-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-property":["@stdlib/utils/define-properties","@stdlib/utils/define-read-only-property"],"@stdlib/utils/dirname":["@stdlib/utils/extname"],"@stdlib/string/dotcase":["@stdlib/string/camelcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/dstructs/doubly-linked-list":["@stdlib/dstructs/linked-list","@stdlib/dstructs/stack"],"@stdlib/utils/do-until":["@stdlib/utils/async/do-until","@stdlib/utils/do-until-each","@stdlib/utils/do-while","@stdlib/utils/until","@stdlib/utils/while"],"@stdlib/utils/async/do-until":["@stdlib/utils/do-until","@stdlib/utils/async/do-while","@stdlib/utils/async/until","@stdlib/utils/async/while"],"@stdlib/utils/do-until-each":["@stdlib/utils/do-until-each-right","@stdlib/utils/do-while-each","@stdlib/utils/until-each"],"@stdlib/utils/do-until-each-right":["@stdlib/utils/do-until-each","@stdlib/utils/do-while-each-right","@stdlib/utils/until-each-right"],"@stdlib/utils/do-while":["@stdlib/utils/do-until","@stdlib/utils/async/do-while","@stdlib/utils/do-while-each","@stdlib/utils/until","@stdlib/utils/while"],"@stdlib/utils/async/do-while":["@stdlib/utils/async/do-until","@stdlib/utils/do-while","@stdlib/utils/async/until","@stdlib/utils/async/while"],"@stdlib/utils/do-while-each":["@stdlib/utils/do-until-each","@stdlib/utils/do-while-each-right","@stdlib/utils/while-each"],"@stdlib/utils/do-while-each-right":["@stdlib/utils/do-until-each-right","@stdlib/utils/do-while-each","@stdlib/utils/while-each-right"],"@stdlib/blas/dswap":["@stdlib/blas/base/dswap","@stdlib/blas/gswap","@stdlib/blas/sswap"],"@stdlib/constants/float64/e":[],"@stdlib/datasets/emoji":["@stdlib/datasets/emoji-code-picto","@stdlib/datasets/emoji-picto-code"],"@stdlib/datasets/emoji-code-picto":["@stdlib/datasets/emoji","@stdlib/datasets/emoji-picto-code"],"@stdlib/datasets/emoji-picto-code":["@stdlib/datasets/emoji","@stdlib/datasets/emoji-code-picto"],"@stdlib/streams/node/empty":["@stdlib/streams/node/from-constant"],"@stdlib/string/ends-with":["@stdlib/string/starts-with"],"@stdlib/utils/enumerable-properties":["@stdlib/utils/enumerable-properties-in","@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/keys","@stdlib/utils/nonenumerable-properties","@stdlib/utils/properties"],"@stdlib/utils/enumerable-properties-in":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/keys-in","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties-in"],"@stdlib/utils/enumerable-property-symbols":["@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-symbols"],"@stdlib/utils/enumerable-property-symbols-in":["@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/keys-in","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols-in"],"@stdlib/process/env":["@stdlib/process/argv"],"@stdlib/constants/float64/eps":["@stdlib/constants/float32/eps"],"@stdlib/error/to-json":["@stdlib/error/reviver"],"@stdlib/constants/float64/eulergamma":[],"@stdlib/utils/every":["@stdlib/utils/any","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some"],"@stdlib/utils/every-by":["@stdlib/utils/any-by","@stdlib/utils/every-by-right","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some-by"],"@stdlib/utils/async/every-by":["@stdlib/utils/async/any-by","@stdlib/utils/every-by","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/async/some-by"],"@stdlib/utils/every-by-right":["@stdlib/utils/any-by","@stdlib/utils/every","@stdlib/utils/every-by","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by-right"],"@stdlib/utils/async/every-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by","@stdlib/utils/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/every-in-by":["@stdlib/utils/any-in-by","@stdlib/utils/none-in-by","@stdlib/utils/some-in-by","@stdlib/utils/every-by","@stdlib/utils/every-own-by"],"@stdlib/utils/every-own-by":["@stdlib/utils/any-own-by","@stdlib/utils/every-in-by","@stdlib/utils/none-own-by","@stdlib/utils/some-own-by","@stdlib/utils/every-by"],"@stdlib/utils/eval":[],"@stdlib/process/exec-path":[],"@stdlib/fs/exists":["@stdlib/fs/read-file","@stdlib/fs/read-dir"],"@stdlib/nlp/expand-acronyms":["@stdlib/nlp/expand-contractions"],"@stdlib/nlp/expand-contractions":[],"@stdlib/utils/extname":["@stdlib/utils/dirname"],"@stdlib/ndarray/fancy":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/math/base/special/fast/abs":["@stdlib/math/base/special/abs"],"@stdlib/math/base/special/fast/acosh":["@stdlib/math/base/special/acosh"],"@stdlib/math/base/special/fast/alpha-max-plus-beta-min":["@stdlib/math/base/special/hypot"],"@stdlib/math/base/special/fast/asinh":["@stdlib/math/base/special/asinh"],"@stdlib/math/base/special/fast/atanh":["@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/fast/hypot":["@stdlib/math/base/special/hypot"],"@stdlib/math/base/special/fast/uint32-log2":["@stdlib/math/base/special/log2"],"@stdlib/math/base/special/fast/max":["@stdlib/math/base/special/max"],"@stdlib/math/base/special/fast/min":["@stdlib/math/base/special/min"],"@stdlib/math/base/special/fast/pow-int":["@stdlib/math/base/special/pow"],"@stdlib/math/base/special/fast/uint32-sqrt":["@stdlib/math/base/special/sqrt"],"@stdlib/datasets/female-first-names-en":["@stdlib/datasets/male-first-names-en"],"@stdlib/dstructs/fifo":["@stdlib/dstructs/stack"],"@stdlib/array/filled":["@stdlib/array/filled-by","@stdlib/array/typed"],"@stdlib/array/filled-by":["@stdlib/array/filled","@stdlib/array/typed"],"@stdlib/utils/filter-arguments":["@stdlib/utils/mask-arguments","@stdlib/utils/reject-arguments","@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/utils/find":[],"@stdlib/string/first":["@stdlib/string/remove-first","@stdlib/string/last"],"@stdlib/datasets/fivethirtyeight-ffq":[],"@stdlib/utils/flatten-array":["@stdlib/utils/flatten-object"],"@stdlib/utils/flatten-object":["@stdlib/utils/flatten-array"],"@stdlib/stats/fligner-test":["@stdlib/stats/bartlett-test"],"@stdlib/os/float-word-order":["@stdlib/os/byte-order"],"@stdlib/constants/float16/cbrt-eps":["@stdlib/constants/float16/eps","@stdlib/constants/float16/sqrt-eps","@stdlib/constants/float32/cbrt-eps","@stdlib/constants/float64/cbrt-eps"],"@stdlib/constants/float16/eps":["@stdlib/constants/float32/eps","@stdlib/constants/float64/eps"],"@stdlib/constants/float16/exponent-bias":["@stdlib/constants/float32/exponent-bias","@stdlib/constants/float64/exponent-bias"],"@stdlib/constants/float16/max":["@stdlib/constants/float32/max","@stdlib/constants/float64/max"],"@stdlib/constants/float16/max-safe-integer":["@stdlib/constants/float16/min-safe-integer","@stdlib/constants/float32/max-safe-integer","@stdlib/constants/float64/max-safe-integer"],"@stdlib/constants/float16/min-safe-integer":["@stdlib/constants/float16/max-safe-integer","@stdlib/constants/float32/min-safe-integer","@stdlib/constants/float64/min-safe-integer"],"@stdlib/constants/float16/ninf":["@stdlib/constants/float16/pinf","@stdlib/constants/float32/ninf","@stdlib/constants/float64/ninf"],"@stdlib/constants/float16/num-bytes":["@stdlib/constants/float32/num-bytes","@stdlib/constants/float64/num-bytes"],"@stdlib/constants/float16/pinf":["@stdlib/constants/float16/ninf","@stdlib/constants/float32/pinf","@stdlib/constants/float64/pinf"],"@stdlib/constants/float16/precision":["@stdlib/constants/float32/precision","@stdlib/constants/float64/precision"],"@stdlib/constants/float16/smallest-normal":["@stdlib/constants/float16/smallest-subnormal","@stdlib/constants/float32/smallest-normal","@stdlib/constants/float64/smallest-normal"],"@stdlib/constants/float16/smallest-subnormal":["@stdlib/constants/float16/smallest-normal","@stdlib/constants/float32/smallest-subnormal","@stdlib/constants/float64/smallest-subnormal"],"@stdlib/constants/float16/sqrt-eps":["@stdlib/constants/float16/eps","@stdlib/constants/float32/sqrt-eps","@stdlib/constants/float64/sqrt-eps"],"@stdlib/constants/float32/abs-mask":["@stdlib/constants/float32/exponent-mask","@stdlib/constants/float32/sign-mask","@stdlib/constants/float32/significand-mask"],"@stdlib/constants/float32/cbrt-eps":["@stdlib/constants/float32/eps","@stdlib/constants/float32/sqrt-eps","@stdlib/constants/float64/cbrt-eps"],"@stdlib/constants/float32/e":["@stdlib/constants/float64/e"],"@stdlib/constants/float32/eps":["@stdlib/constants/float64/eps"],"@stdlib/constants/float32/exponent-bias":["@stdlib/constants/float16/exponent-bias","@stdlib/constants/float64/exponent-bias"],"@stdlib/constants/float32/exponent-mask":["@stdlib/constants/float32/sign-mask","@stdlib/constants/float32/significand-mask","@stdlib/constants/float32/abs-mask"],"@stdlib/constants/float32/fourth-pi":["@stdlib/constants/float32/half-pi","@stdlib/constants/float32/pi","@stdlib/constants/float32/two-pi"],"@stdlib/constants/float32/half-ln-two":["@stdlib/constants/float64/half-ln-two"],"@stdlib/constants/float32/half-pi":["@stdlib/constants/float32/fourth-pi","@stdlib/constants/float32/pi","@stdlib/constants/float32/two-pi"],"@stdlib/constants/float32/ln-half":["@stdlib/constants/float64/ln-half"],"@stdlib/constants/float32/ln-pi":["@stdlib/constants/float32/pi","@stdlib/constants/float64/ln-pi"],"@stdlib/constants/float32/ln-ten":["@stdlib/constants/float32/ln-two","@stdlib/constants/float64/ln-ten"],"@stdlib/constants/float32/ln-two":["@stdlib/constants/float32/ln-ten","@stdlib/constants/float64/ln-two"],"@stdlib/constants/float32/max":["@stdlib/constants/float16/max","@stdlib/constants/float64/max"],"@stdlib/constants/float32/max-base2-exponent":["@stdlib/constants/float32/max-base2-exponent-subnormal","@stdlib/constants/float64/max-base2-exponent"],"@stdlib/constants/float32/max-base2-exponent-subnormal":["@stdlib/constants/float32/max-base2-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal"],"@stdlib/constants/float32/max-base10-exponent":["@stdlib/constants/float32/max-base10-exponent-subnormal","@stdlib/constants/float64/max-base10-exponent"],"@stdlib/constants/float32/max-base10-exponent-subnormal":["@stdlib/constants/float32/max-base10-exponent","@stdlib/constants/float64/max-base10-exponent-subnormal"],"@stdlib/constants/float32/max-safe-fibonacci":["@stdlib/constants/float64/max-safe-fibonacci"],"@stdlib/constants/float32/max-safe-integer":["@stdlib/constants/float16/max-safe-integer","@stdlib/constants/float32/min-safe-integer","@stdlib/constants/float64/max-safe-integer"],"@stdlib/constants/float32/max-safe-nth-factorial":[],"@stdlib/constants/float32/max-safe-nth-fibonacci":["@stdlib/constants/float64/max-safe-nth-fibonacci"],"@stdlib/constants/float32/max-safe-nth-lucas":["@stdlib/constants/float64/max-safe-nth-lucas"],"@stdlib/constants/float32/min-base2-exponent":["@stdlib/constants/float32/min-base2-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float32/min-base2-exponent-subnormal":["@stdlib/constants/float32/min-base2-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float32/min-base10-exponent":["@stdlib/constants/float32/min-base10-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent"],"@stdlib/constants/float32/min-base10-exponent-subnormal":["@stdlib/constants/float32/min-base10-exponent","@stdlib/constants/float64/min-base10-exponent-subnormal"],"@stdlib/constants/float32/min-safe-integer":["@stdlib/constants/float16/min-safe-integer","@stdlib/constants/float32/max-safe-integer","@stdlib/constants/float64/min-safe-integer"],"@stdlib/constants/float32/nan":["@stdlib/constants/float64/nan"],"@stdlib/constants/float32/ninf":["@stdlib/constants/float32/pinf","@stdlib/constants/float64/ninf"],"@stdlib/constants/float32/num-bytes":["@stdlib/constants/float16/num-bytes","@stdlib/constants/float64/num-bytes"],"@stdlib/constants/float32/phi":["@stdlib/constants/float64/phi"],"@stdlib/constants/float32/pi":["@stdlib/constants/float32/fourth-pi","@stdlib/constants/float32/half-pi","@stdlib/constants/float32/two-pi"],"@stdlib/constants/float32/pinf":["@stdlib/constants/float32/ninf","@stdlib/constants/float64/pinf"],"@stdlib/constants/float32/precision":["@stdlib/constants/float16/precision","@stdlib/constants/float64/precision"],"@stdlib/constants/float32/sign-mask":["@stdlib/constants/float32/exponent-mask","@stdlib/constants/float32/significand-mask","@stdlib/constants/float32/abs-mask"],"@stdlib/constants/float32/significand-mask":["@stdlib/constants/float32/exponent-mask","@stdlib/constants/float32/sign-mask","@stdlib/constants/float32/abs-mask"],"@stdlib/constants/float32/smallest-normal":["@stdlib/constants/float32/smallest-subnormal","@stdlib/constants/float64/smallest-normal"],"@stdlib/constants/float32/smallest-subnormal":["@stdlib/constants/float32/smallest-normal","@stdlib/constants/float64/smallest-subnormal"],"@stdlib/constants/float32/sqrt-eps":["@stdlib/constants/float32/eps","@stdlib/constants/float64/sqrt-eps"],"@stdlib/constants/float32/sqrt-half":["@stdlib/constants/float64/sqrt-half"],"@stdlib/constants/float32/sqrt-half-pi":["@stdlib/constants/float64/sqrt-half-pi"],"@stdlib/constants/float32/sqrt-phi":["@stdlib/constants/float64/sqrt-phi"],"@stdlib/constants/float32/sqrt-pi":["@stdlib/constants/float32/pi","@stdlib/constants/float64/sqrt-pi"],"@stdlib/constants/float32/sqrt-three":["@stdlib/constants/float32/sqrt-two","@stdlib/constants/float64/sqrt-three"],"@stdlib/constants/float32/sqrt-two":["@stdlib/constants/float32/sqrt-three","@stdlib/constants/float64/sqrt-two"],"@stdlib/constants/float32/sqrt-two-pi":["@stdlib/constants/float32/pi","@stdlib/constants/float32/two-pi","@stdlib/constants/float64/sqrt-two-pi"],"@stdlib/constants/float32/two-pi":["@stdlib/constants/float32/fourth-pi","@stdlib/constants/float32/half-pi","@stdlib/constants/float32/pi"],"@stdlib/array/float32":["@stdlib/array/buffer","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/fixed-endian-float32":["@stdlib/array/fixed-endian-float64","@stdlib/array/float32"],"@stdlib/array/little-endian-float32":["@stdlib/array/fixed-endian-float32","@stdlib/array/float32","@stdlib/array/little-endian-float64"],"@stdlib/constants/float64/exponent-bias":["@stdlib/constants/float16/exponent-bias","@stdlib/constants/float32/exponent-bias"],"@stdlib/constants/float64/high-word-abs-mask":["@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants/float64/high-word-significand-mask"],"@stdlib/constants/float64/high-word-exponent-mask":["@stdlib/constants/float64/high-word-significand-mask","@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants/float64/high-word-abs-mask"],"@stdlib/constants/float64/high-word-sign-mask":["@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants/float64/high-word-significand-mask","@stdlib/constants/float64/high-word-abs-mask"],"@stdlib/constants/float64/high-word-significand-mask":["@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants/float64/high-word-abs-mask"],"@stdlib/constants/float64/max":["@stdlib/constants/float16/max","@stdlib/constants/float32/max"],"@stdlib/constants/float64/max-base2-exponent":["@stdlib/constants/float64/max-base10-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float64/max-base2-exponent-subnormal":["@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants/float64/max-base2-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float64/max-base10-exponent":["@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants/float64/max-base2-exponent","@stdlib/constants/float64/min-base10-exponent"],"@stdlib/constants/float64/max-base10-exponent-subnormal":["@stdlib/constants/float64/max-base10-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent-subnormal"],"@stdlib/constants/float64/max-ln":["@stdlib/constants/float64/min-ln"],"@stdlib/constants/float64/max-safe-fibonacci":["@stdlib/constants/float64/max-safe-nth-fibonacci"],"@stdlib/constants/float64/max-safe-integer":["@stdlib/constants/float16/max-safe-integer","@stdlib/constants/float32/max-safe-integer","@stdlib/constants/float64/min-safe-integer"],"@stdlib/constants/float64/max-safe-lucas":["@stdlib/constants/float64/max-safe-fibonacci","@stdlib/constants/float64/max-safe-nth-lucas"],"@stdlib/constants/float64/max-safe-nth-fibonacci":["@stdlib/constants/float64/max-safe-fibonacci"],"@stdlib/constants/float64/max-safe-nth-lucas":["@stdlib/constants/float64/max-safe-lucas","@stdlib/constants/float64/max-safe-nth-fibonacci"],"@stdlib/constants/float64/min-base2-exponent":["@stdlib/constants/float64/max-base2-exponent","@stdlib/constants/float64/min-base10-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float64/min-base2-exponent-subnormal":["@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float64/min-base10-exponent":["@stdlib/constants/float64/max-base10-exponent","@stdlib/constants/float64/min-base10-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float64/min-base10-exponent-subnormal":["@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float64/min-ln":["@stdlib/constants/float64/max-ln"],"@stdlib/constants/float64/min-safe-integer":["@stdlib/constants/float16/min-safe-integer","@stdlib/constants/float32/min-safe-integer","@stdlib/constants/float64/max-safe-integer"],"@stdlib/constants/float64/num-bytes":["@stdlib/constants/float16/num-bytes","@stdlib/constants/float32/num-bytes"],"@stdlib/constants/float64/precision":["@stdlib/constants/float16/precision","@stdlib/constants/float32/precision"],"@stdlib/constants/float64/smallest-normal":["@stdlib/constants/float32/smallest-normal","@stdlib/constants/float64/smallest-subnormal"],"@stdlib/constants/float64/smallest-subnormal":["@stdlib/constants/float32/smallest-subnormal","@stdlib/constants/float64/smallest-normal"],"@stdlib/array/float64":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/fixed-endian-float64":["@stdlib/array/fixed-endian-float32","@stdlib/array/float64"],"@stdlib/array/little-endian-float64":["@stdlib/array/fixed-endian-float64","@stdlib/array/float64","@stdlib/array/little-endian-float32"],"@stdlib/utils/for-each":["@stdlib/utils/async/for-each","@stdlib/utils/for-each-right"],"@stdlib/utils/async/for-each":["@stdlib/utils/for-each","@stdlib/utils/async/for-each-right"],"@stdlib/string/for-each":["@stdlib/utils/for-each"],"@stdlib/utils/for-each-right":["@stdlib/utils/for-each","@stdlib/utils/async/for-each-right"],"@stdlib/utils/async/for-each-right":["@stdlib/utils/async/for-each","@stdlib/utils/for-each-right"],"@stdlib/utils/for-in":["@stdlib/utils/for-each","@stdlib/utils/for-own"],"@stdlib/string/format":[],"@stdlib/utils/for-own":["@stdlib/utils/for-each","@stdlib/utils/for-in"],"@stdlib/constants/float64/fourth-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/fourth-root-eps":["@stdlib/constants/float64/eps"],"@stdlib/datasets/frb-sf-wage-rigidity":[],"@stdlib/string/from-code-point":["@stdlib/string/code-point-at"],"@stdlib/function/ctor":[],"@stdlib/function/to-string":["@stdlib/function/ctor"],"@stdlib/utils/function-name":["@stdlib/utils/constructor-name"],"@stdlib/utils/function-sequence":["@stdlib/utils/compose","@stdlib/utils/async/function-sequence"],"@stdlib/utils/async/function-sequence":["@stdlib/utils/async/compose","@stdlib/utils/function-sequence"],"@stdlib/constants/float64/gamma-lanczos-g":[],"@stdlib/blas/gdot":["@stdlib/blas/base/gdot","@stdlib/blas/ddot","@stdlib/blas/sdot"],"@stdlib/process/getegid":["@stdlib/process/geteuid","@stdlib/process/getgid","@stdlib/process/getuid"],"@stdlib/process/geteuid":["@stdlib/process/getegid","@stdlib/process/getgid","@stdlib/process/getuid"],"@stdlib/process/getgid":["@stdlib/process/getegid","@stdlib/process/geteuid","@stdlib/process/getuid"],"@stdlib/utils/global":[],"@stdlib/utils/get-prototype-of":["@stdlib/assert/is-prototype-of"],"@stdlib/process/getuid":["@stdlib/process/getegid","@stdlib/process/geteuid","@stdlib/process/getgid"],"@stdlib/constants/float64/glaisher-kinkelin":[],"@stdlib/string/to-grapheme-cluster-iterator":["@stdlib/array/to-iterator","@stdlib/string/to-grapheme-cluster-iterator-right"],"@stdlib/string/to-grapheme-cluster-iterator-right":["@stdlib/array/to-iterator-right","@stdlib/string/to-grapheme-cluster-iterator"],"@stdlib/utils/group":["@stdlib/utils/bifurcate","@stdlib/utils/count-by","@stdlib/utils/group-by"],"@stdlib/utils/group-by":["@stdlib/utils/bifurcate-by","@stdlib/utils/count-by","@stdlib/utils/group"],"@stdlib/utils/async/group-by":["@stdlib/utils/async/bifurcate-by","@stdlib/utils/async/count-by","@stdlib/utils/group-by"],"@stdlib/utils/group-in":["@stdlib/utils/bifurcate-in","@stdlib/utils/group-by","@stdlib/utils/group-own"],"@stdlib/utils/group-own":["@stdlib/utils/bifurcate-own","@stdlib/utils/group","@stdlib/utils/group-by"],"@stdlib/blas/gswap":["@stdlib/blas/base/gswap","@stdlib/blas/dswap","@stdlib/blas/sswap"],"@stdlib/constants/float64/half-ln-two":["@stdlib/constants/float64/ln-two"],"@stdlib/constants/float64/half-pi":["@stdlib/constants/float64/pi"],"@stdlib/datasets/harrison-boston-house-prices":["@stdlib/datasets/harrison-boston-house-prices-corrected","@stdlib/datasets/pace-boston-house-prices"],"@stdlib/datasets/harrison-boston-house-prices-corrected":["@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/pace-boston-house-prices"],"@stdlib/assert/has-arraybuffer-support":["@stdlib/assert/has-float32array-support","@stdlib/assert/has-float64array-support","@stdlib/assert/has-int16array-support","@stdlib/assert/has-int32array-support","@stdlib/assert/has-int8array-support","@stdlib/assert/has-node-buffer-support","@stdlib/assert/has-sharedarraybuffer-support","@stdlib/assert/has-uint16array-support","@stdlib/assert/has-uint32array-support","@stdlib/assert/has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support"],"@stdlib/assert/has-arrow-function-support":[],"@stdlib/assert/has-async-await-support":[],"@stdlib/assert/has-async-iterator-symbol-support":["@stdlib/assert/has-iterator-symbol-support","@stdlib/assert/has-symbol-support"],"@stdlib/assert/has-atob-support":["@stdlib/assert/has-btoa-support"],"@stdlib/assert/has-bigint64array-support":["@stdlib/assert/has-bigint-support","@stdlib/assert/has-biguint64array-support"],"@stdlib/assert/has-bigint-support":[],"@stdlib/assert/has-biguint64array-support":["@stdlib/assert/has-bigint-support","@stdlib/assert/has-bigint64array-support"],"@stdlib/assert/has-btoa-support":["@stdlib/assert/has-atob-support"],"@stdlib/assert/has-class-support":[],"@stdlib/assert/has-dataview-support":["@stdlib/assert/has-arraybuffer-support"],"@stdlib/assert/has-define-properties-support":["@stdlib/assert/has-define-property-support"],"@stdlib/assert/has-define-property-support":["@stdlib/assert/has-define-properties-support"],"@stdlib/assert/has-float32array-support":[],"@stdlib/assert/has-float64array-support":[],"@stdlib/assert/has-function-name-support":[],"@stdlib/assert/has-generator-support":[],"@stdlib/assert/has-globalthis-support":["@stdlib/utils/global"],"@stdlib/assert/has-int8array-support":[],"@stdlib/assert/has-int16array-support":[],"@stdlib/assert/has-int32array-support":[],"@stdlib/assert/has-iterator-symbol-support":["@stdlib/assert/has-async-iterator-symbol-support","@stdlib/assert/has-symbol-support"],"@stdlib/assert/has-map-support":[],"@stdlib/assert/has-node-buffer-support":[],"@stdlib/assert/has-own-property":["@stdlib/assert/has-property"],"@stdlib/assert/has-property":["@stdlib/assert/has-own-property"],"@stdlib/assert/has-proxy-support":[],"@stdlib/assert/has-set-support":[],"@stdlib/assert/has-sharedarraybuffer-support":["@stdlib/assert/has-arraybuffer-support","@stdlib/assert/has-float32array-support","@stdlib/assert/has-float64array-support","@stdlib/assert/has-int16array-support","@stdlib/assert/has-int32array-support","@stdlib/assert/has-int8array-support","@stdlib/assert/has-node-buffer-support","@stdlib/assert/has-uint16array-support","@stdlib/assert/has-uint32array-support","@stdlib/assert/has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support"],"@stdlib/assert/has-symbol-support":["@stdlib/assert/has-iterator-symbol-support"],"@stdlib/assert/has-tostringtag-support":[],"@stdlib/assert/has-uint8array-support":[],"@stdlib/assert/has-uint8clampedarray-support":[],"@stdlib/assert/has-uint16array-support":[],"@stdlib/assert/has-uint32array-support":[],"@stdlib/assert/has-utf16-surrogate-pair-at":[],"@stdlib/assert/has-weakmap-support":[],"@stdlib/assert/has-weakset-support":[],"@stdlib/assert/has-wasm-support":[],"@stdlib/string/headercase":["@stdlib/string/camelcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/datasets/herndon-venus-semidiameters":[],"@stdlib/os/homedir":["@stdlib/os/configdir","@stdlib/os/tmpdir"],"@stdlib/constants/time/hours-in-day":["@stdlib/constants/time/hours-in-week"],"@stdlib/constants/time/hours-in-week":["@stdlib/constants/time/hours-in-day"],"@stdlib/time/hours-in-month":["@stdlib/time/hours-in-year"],"@stdlib/time/hours-in-year":["@stdlib/time/hours-in-month"],"@stdlib/net/http-server":[],"@stdlib/utils/identity-function":["@stdlib/utils/constant-function"],"@stdlib/utils/if-else":["@stdlib/utils/async/if-else","@stdlib/utils/if-then"],"@stdlib/utils/async/if-else":["@stdlib/utils/async/if-then","@stdlib/utils/if-else"],"@stdlib/utils/if-then":["@stdlib/utils/async/if-then","@stdlib/utils/if-else"],"@stdlib/utils/async/if-then":["@stdlib/utils/async/if-else","@stdlib/utils/if-then"],"@stdlib/complex/float64/imag":["@stdlib/complex/float64/real","@stdlib/complex/float64/reim"],"@stdlib/complex/float32/imag":["@stdlib/complex/float64/imag","@stdlib/complex/float32/real","@stdlib/complex/float32/reim"],"@stdlib/datasets/img-acanthus-mollis":["@stdlib/datasets/img-allium-oreophilum"],"@stdlib/datasets/img-airplane-from-above":[],"@stdlib/datasets/img-allium-oreophilum":["@stdlib/datasets/img-acanthus-mollis"],"@stdlib/datasets/img-black-canyon":[],"@stdlib/datasets/img-dust-bowl-home":[],"@stdlib/datasets/img-french-alpine-landscape":[],"@stdlib/datasets/img-locomotion-house-cat":["@stdlib/datasets/img-locomotion-nude-male"],"@stdlib/datasets/img-locomotion-nude-male":["@stdlib/datasets/img-locomotion-house-cat"],"@stdlib/datasets/img-march-pastoral":[],"@stdlib/datasets/img-nagasaki-boats":[],"@stdlib/stats/incr/apcorr":["@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/pcorr2"],"@stdlib/ml/incr/binary-classification":["@stdlib/ml/incr/sgd-regression"],"@stdlib/stats/incr/count":["@stdlib/stats/incr/mean","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/covariance":["@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/covmat":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/pcorrmat"],"@stdlib/stats/incr/cv":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mcv","@stdlib/stats/incr/stdev","@stdlib/stats/incr/vmr"],"@stdlib/stats/incr/ewmean":["@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmean","@stdlib/stats/incr/wmean"],"@stdlib/stats/incr/ewstdev":["@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/ewvariance":["@stdlib/stats/incr/ewmean","@stdlib/stats/incr/ewstdev","@stdlib/stats/incr/variance","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/gmean":["@stdlib/stats/incr/hmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mgmean","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/grubbs":["@stdlib/stats/incr/mgrubbs"],"@stdlib/stats/incr/hmean":["@stdlib/stats/incr/gmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mhmean","@stdlib/stats/incr/summary"],"@stdlib/ml/incr/kmeans":[],"@stdlib/stats/incr/kurtosis":["@stdlib/stats/incr/mean","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/maape":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mape","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmaape"],"@stdlib/stats/incr/mae":["@stdlib/stats/incr/mape","@stdlib/stats/incr/me","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmae"],"@stdlib/stats/incr/mapcorr":["@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mpcorr2"],"@stdlib/stats/incr/mape":["@stdlib/stats/incr/maape","@stdlib/stats/incr/mae","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmape"],"@stdlib/stats/incr/max":["@stdlib/stats/incr/midrange","@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/maxabs":["@stdlib/stats/incr/max","@stdlib/stats/incr/minabs","@stdlib/stats/incr/mmaxabs"],"@stdlib/stats/incr/mcovariance":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mcv":["@stdlib/stats/incr/cv","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/mvmr"],"@stdlib/stats/incr/mda":["@stdlib/stats/incr/mape","@stdlib/stats/incr/mmda"],"@stdlib/stats/incr/me":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mean","@stdlib/stats/incr/mme"],"@stdlib/stats/incr/mean":["@stdlib/stats/incr/midrange","@stdlib/stats/incr/mmean","@stdlib/stats/incr/stdev","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/meanabs":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/meanabs2":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/meanstdev":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/meanvar":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/mgmean":["@stdlib/stats/incr/gmean","@stdlib/stats/incr/mhmean","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mgrubbs":["@stdlib/stats/incr/grubbs"],"@stdlib/stats/incr/mhmean":["@stdlib/stats/incr/hmean","@stdlib/stats/incr/mgmean","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/midrange":["@stdlib/stats/incr/mean","@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/min":["@stdlib/stats/incr/max","@stdlib/stats/incr/midrange","@stdlib/stats/incr/mmin","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/minabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/min","@stdlib/stats/incr/mminabs"],"@stdlib/stats/incr/minmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/mminmax","@stdlib/stats/incr/range"],"@stdlib/stats/incr/minmaxabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/minabs","@stdlib/stats/incr/minmax","@stdlib/stats/incr/mminmaxabs"],"@stdlib/stats/incr/mmaape":["@stdlib/stats/incr/maape","@stdlib/stats/incr/mmape","@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmae":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mme","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmape":["@stdlib/stats/incr/mape","@stdlib/stats/incr/mmaape","@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange","@stdlib/stats/incr/msummary"],"@stdlib/stats/incr/mmaxabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mminabs"],"@stdlib/stats/incr/mmda":["@stdlib/stats/incr/mda","@stdlib/stats/incr/mmape"],"@stdlib/stats/incr/mme":["@stdlib/stats/incr/me","@stdlib/stats/incr/mmae","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmean":["@stdlib/stats/incr/mean","@stdlib/stats/incr/msum","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msummary","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mmeanabs":["@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mmean","@stdlib/stats/incr/msumabs"],"@stdlib/stats/incr/mmeanabs2":["@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/msumabs2"],"@stdlib/stats/incr/mmeanstdev":["@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/mstdev"],"@stdlib/stats/incr/mmeanvar":["@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mmidrange":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange"],"@stdlib/stats/incr/mmin":["@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mrange","@stdlib/stats/incr/msummary"],"@stdlib/stats/incr/mminabs":["@stdlib/stats/incr/minabs","@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/mmin"],"@stdlib/stats/incr/mminmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/minmax","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange"],"@stdlib/stats/incr/mminmaxabs":["@stdlib/stats/incr/minmaxabs","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mminabs","@stdlib/stats/incr/mminmax"],"@stdlib/stats/incr/mmpe":["@stdlib/stats/incr/mmape","@stdlib/stats/incr/mme","@stdlib/stats/incr/mpe"],"@stdlib/stats/incr/mmse":["@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mrss","@stdlib/stats/incr/mse"],"@stdlib/stats/incr/mpcorr":["@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/mpcorrdist","@stdlib/stats/incr/pcorr"],"@stdlib/stats/incr/mpcorr2":["@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/pcorr2"],"@stdlib/stats/incr/mpcorrdist":["@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/pcorrdist"],"@stdlib/stats/incr/mpe":["@stdlib/stats/incr/mape","@stdlib/stats/incr/me","@stdlib/stats/incr/mmpe"],"@stdlib/stats/incr/mprod":["@stdlib/stats/incr/msum","@stdlib/stats/incr/prod"],"@stdlib/stats/incr/mrange":["@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmin","@stdlib/stats/incr/msummary","@stdlib/stats/incr/range"],"@stdlib/stats/incr/mrmse":["@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrss","@stdlib/stats/incr/rmse"],"@stdlib/stats/incr/mrss":["@stdlib/stats/incr/rss","@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrmse"],"@stdlib/stats/incr/mse":["@stdlib/stats/incr/mmse","@stdlib/stats/incr/rmse","@stdlib/stats/incr/rss"],"@stdlib/stats/incr/mstdev":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/msummary","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/msum":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/msummary","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/msumabs":["@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/msum","@stdlib/stats/incr/sum","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/msumabs2":["@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/msumabs","@stdlib/stats/incr/sumabs","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/msummary":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msum","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/msumprod":["@stdlib/stats/incr/mprod","@stdlib/stats/incr/msum","@stdlib/stats/incr/sumprod"],"@stdlib/stats/incr/mvariance":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msummary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/mvmr":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/vmr"],"@stdlib/stats/incr/nancount":["@stdlib/stats/incr/nansum"],"@stdlib/stats/incr/nansum":["@stdlib/stats/incr/nansumabs","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/nansumabs":["@stdlib/stats/incr/nansum","@stdlib/stats/incr/nansumabs2","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/nansumabs2":["@stdlib/stats/incr/nansum","@stdlib/stats/incr/nansumabs","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/pcorr":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/pcorr2":["@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mpcorr2","@stdlib/stats/incr/pcorr"],"@stdlib/stats/incr/pcorrdist":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/pcorrdistmat":["@stdlib/stats/incr/pcorrdist","@stdlib/stats/incr/pcorrmat"],"@stdlib/stats/incr/pcorrmat":["@stdlib/stats/incr/covmat","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/pcorrdistmat"],"@stdlib/stats/incr/prod":["@stdlib/stats/incr/mprod","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/range":["@stdlib/stats/incr/max","@stdlib/stats/incr/mean","@stdlib/stats/incr/min","@stdlib/stats/incr/mrange","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/rmse":["@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mse","@stdlib/stats/incr/rss"],"@stdlib/stats/incr/rss":["@stdlib/stats/incr/mrss","@stdlib/stats/incr/mse","@stdlib/stats/incr/rmse"],"@stdlib/ml/incr/sgd-regression":["@stdlib/ml/incr/binary-classification"],"@stdlib/stats/incr/skewness":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/array/incrspace":["@stdlib/array/linspace","@stdlib/array/logspace"],"@stdlib/stats/incr/stdev":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/skewness","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/sum":["@stdlib/stats/incr/count","@stdlib/stats/incr/mean","@stdlib/stats/incr/msum","@stdlib/stats/incr/prod","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/sumabs":["@stdlib/stats/incr/meanabs","@stdlib/stats/incr/msumabs","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/sumabs2":["@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/msumabs2","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/summary":["@stdlib/stats/incr/count","@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/max","@stdlib/stats/incr/mean","@stdlib/stats/incr/midrange","@stdlib/stats/incr/min","@stdlib/stats/incr/msummary","@stdlib/stats/incr/range","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/sum","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/sumprod":["@stdlib/stats/incr/msumprod","@stdlib/stats/incr/prod","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/variance":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/vmr":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mvmr","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/wmean":["@stdlib/stats/incr/ewmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmean"],"@stdlib/ndarray/ind2sub":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/sub2ind"],"@stdlib/utils/index-of":[],"@stdlib/utils/inherit":[],"@stdlib/utils/inherited-enumerable-properties":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-properties-in","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-properties"],"@stdlib/utils/inherited-enumerable-property-symbols":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/inherited-keys":["@stdlib/utils/keys","@stdlib/utils/keys-in","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-nonenumerable-properties":["@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-nonenumerable-property-names":["@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/inherited-nonenumerable-property-symbols":["@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-properties","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/inherited-properties":["@stdlib/utils/properties","@stdlib/utils/properties-in","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-descriptor":["@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptor-in","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-descriptors":["@stdlib/utils/property-descriptors","@stdlib/utils/property-descriptors-in","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-names":["@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-symbols","@stdlib/utils/property-names","@stdlib/utils/property-names-in"],"@stdlib/utils/inherited-property-symbols":["@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-names","@stdlib/utils/property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/utils/inherited-writable-properties":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties","@stdlib/utils/writable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-writable-property-names":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-names-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-writable-property-symbols":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-property-symbols","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/properties"],"@stdlib/utils/inmap":["@stdlib/utils/for-each","@stdlib/utils/inmap-right","@stdlib/utils/map"],"@stdlib/utils/async/inmap":["@stdlib/utils/async/for-each","@stdlib/utils/async/inmap-right","@stdlib/utils/inmap"],"@stdlib/utils/inmap-right":["@stdlib/utils/for-each-right","@stdlib/utils/inmap","@stdlib/utils/map-right"],"@stdlib/utils/async/inmap-right":["@stdlib/utils/async/for-each-right","@stdlib/utils/async/inmap","@stdlib/utils/inmap-right"],"@stdlib/streams/node/inspect-sink":["@stdlib/streams/node/debug-sink","@stdlib/streams/node/inspect"],"@stdlib/streams/node/inspect":["@stdlib/streams/node/debug"],"@stdlib/assert/instance-of":["@stdlib/assert/is-prototype-of","@stdlib/utils/constructor-name","@stdlib/utils/inherit","@stdlib/utils/type-of"],"@stdlib/constants/int8/max":["@stdlib/constants/int8/min"],"@stdlib/constants/int8/min":["@stdlib/constants/int8/max"],"@stdlib/constants/int8/num-bytes":["@stdlib/constants/int16/num-bytes","@stdlib/constants/int32/num-bytes","@stdlib/constants/uint8/num-bytes"],"@stdlib/array/int8":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/int16/max":["@stdlib/constants/int16/min"],"@stdlib/constants/int16/min":["@stdlib/constants/int16/max"],"@stdlib/constants/int16/num-bytes":["@stdlib/constants/int32/num-bytes","@stdlib/constants/int8/num-bytes","@stdlib/constants/uint16/num-bytes"],"@stdlib/array/int16":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/int32/max":["@stdlib/constants/int32/min"],"@stdlib/constants/int32/min":["@stdlib/constants/int32/max"],"@stdlib/constants/int32/num-bytes":["@stdlib/constants/int16/num-bytes","@stdlib/constants/int8/num-bytes","@stdlib/constants/uint32/num-bytes"],"@stdlib/array/int32":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/assert/is-big-endian":["@stdlib/assert/is-little-endian"],"@stdlib/assert/is-browser":[],"@stdlib/assert/is-darwin":[],"@stdlib/assert/is-docker":[],"@stdlib/assert/is-electron":["@stdlib/assert/is-electron-main","@stdlib/assert/is-electron-renderer"],"@stdlib/assert/is-electron-main":["@stdlib/assert/is-electron","@stdlib/assert/is-electron-renderer"],"@stdlib/assert/is-electron-renderer":["@stdlib/assert/is-electron","@stdlib/assert/is-electron-main"],"@stdlib/assert/is-little-endian":["@stdlib/assert/is-big-endian"],"@stdlib/assert/is-mobile":[],"@stdlib/assert/is-node":[],"@stdlib/assert/is-touch-device":[],"@stdlib/assert/is-web-worker":[],"@stdlib/assert/is-windows":[],"@stdlib/assert/is-absolute-http-uri":["@stdlib/assert/is-absolute-uri"],"@stdlib/assert/is-absolute-path":["@stdlib/assert/is-relative-path"],"@stdlib/assert/is-absolute-uri":["@stdlib/assert/is-relative-uri"],"@stdlib/assert/is-accessor-array":["@stdlib/assert/is-array-like","@stdlib/assert/is-array-like-object","@stdlib/assert/is-collection"],"@stdlib/assert/is-accessor-property":["@stdlib/assert/has-own-property","@stdlib/assert/is-accessor-property-in","@stdlib/assert/is-data-property"],"@stdlib/assert/is-accessor-property-in":["@stdlib/assert/has-property","@stdlib/assert/is-accessor-property","@stdlib/assert/is-data-property-in"],"@stdlib/assert/is-alphagram":["@stdlib/assert/is-anagram"],"@stdlib/assert/is-alphanumeric":["@stdlib/assert/is-digit-string"],"@stdlib/assert/is-anagram":["@stdlib/assert/is-alphagram"],"@stdlib/assert/is-arguments":[],"@stdlib/assert/is-array":["@stdlib/assert/is-array-like"],"@stdlib/assert/is-array-array":[],"@stdlib/assert/is-arraybuffer":["@stdlib/assert/is-sharedarraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-arraybuffer-view":["@stdlib/assert/is-dataview","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-array-length":["@stdlib/assert/is-array"],"@stdlib/assert/is-array-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like-object","@stdlib/assert/is-collection"],"@stdlib/assert/is-array-like-object":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-collection"],"@stdlib/assert/is-arrow-function":[],"@stdlib/assert/is-ascii":["@stdlib/assert/is-string"],"@stdlib/assert/is-between":["@stdlib/assert/is-between-array"],"@stdlib/assert/is-between-array":["@stdlib/assert/is-between"],"@stdlib/assert/is-bigint":[],"@stdlib/assert/is-bigint64array":["@stdlib/assert/is-biguint64array"],"@stdlib/assert/is-biguint64array":["@stdlib/assert/is-bigint64array"],"@stdlib/assert/is-binary-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-blank-string":["@stdlib/assert/is-string","@stdlib/assert/is-empty-string"],"@stdlib/assert/is-boolean":[],"@stdlib/assert/is-boolean-array":[],"@stdlib/assert/is-boxed-primitive":["@stdlib/assert/is-primitive"],"@stdlib/assert/is-buffer":[],"@stdlib/assert/is-camelcase":["@stdlib/assert/is-string","@stdlib/assert/is-constantcase"],"@stdlib/assert/is-capitalized":["@stdlib/assert/is-string"],"@stdlib/assert/is-centrosymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-circular":["@stdlib/assert/is-circular-array","@stdlib/assert/is-circular-plain-object"],"@stdlib/assert/is-circular-array":["@stdlib/assert/is-circular","@stdlib/assert/is-circular-plain-object"],"@stdlib/assert/is-circular-plain-object":["@stdlib/assert/is-circular","@stdlib/assert/is-circular-array"],"@stdlib/assert/is-class":[],"@stdlib/assert/is-collection":["@stdlib/assert/is-array-like","@stdlib/assert/is-array-like-object"],"@stdlib/assert/is-complex":["@stdlib/assert/is-complex64","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex64":["@stdlib/assert/is-complex","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex64array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64","@stdlib/assert/is-complex128array","@stdlib/assert/is-complex-typed-array"],"@stdlib/assert/is-complex64matrix-like":["@stdlib/assert/is-complex128matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-complex64ndarray-like":["@stdlib/assert/is-complex128ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-complex64vector-like":["@stdlib/assert/is-complex128vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-complex128":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64"],"@stdlib/assert/is-complex128array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex128","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex-typed-array"],"@stdlib/assert/is-complex128matrix-like":["@stdlib/assert/is-complex64matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-complex128ndarray-like":["@stdlib/assert/is-complex64ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-complex128vector-like":["@stdlib/assert/is-complex64vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-complex-like":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex-typed-array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex128array"],"@stdlib/assert/is-complex-typed-array-like":["@stdlib/assert/is-complex-like","@stdlib/assert/is-complex-typed-array","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex128array"],"@stdlib/assert/is-composite":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-prime"],"@stdlib/assert/is-configurable-property":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-configurable-property-in":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-constantcase":["@stdlib/assert/is-string","@stdlib/assert/is-camelcase"],"@stdlib/assert/is-cube-number":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-square-number"],"@stdlib/assert/is-current-year":[],"@stdlib/assert/is-data-property":["@stdlib/assert/has-own-property","@stdlib/assert/is-accessor-property","@stdlib/assert/is-data-property-in"],"@stdlib/assert/is-data-property-in":["@stdlib/assert/has-property","@stdlib/assert/is-accessor-property-in","@stdlib/assert/is-data-property"],"@stdlib/assert/is-dataview":["@stdlib/assert/is-arraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-date-object":[],"@stdlib/assert/is-date-object-array":["@stdlib/assert/is-date-object"],"@stdlib/assert/is-digit-string":["@stdlib/assert/is-hex-string","@stdlib/assert/is-string"],"@stdlib/assert/is-domain-name":[],"@stdlib/assert/is-duration-string":[],"@stdlib/assert/is-email-address":[],"@stdlib/assert/is-empty-array":["@stdlib/assert/is-array","@stdlib/assert/is-empty-array-like-object","@stdlib/assert/is-empty-collection"],"@stdlib/assert/is-empty-array-like-object":["@stdlib/assert/is-array-like-object","@stdlib/assert/is-empty-array","@stdlib/assert/is-empty-collection"],"@stdlib/assert/is-empty-collection":["@stdlib/assert/is-collection","@stdlib/assert/is-empty-array","@stdlib/assert/is-empty-array-like-object"],"@stdlib/assert/is-empty-object":["@stdlib/assert/is-object","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-empty-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-enumerable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-enumerable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-equal-array":["@stdlib/assert/is-array","@stdlib/assert/is-same-array"],"@stdlib/assert/is-error":[],"@stdlib/assert/is-eval-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-even":["@stdlib/assert/is-odd"],"@stdlib/assert/is-falsy":["@stdlib/assert/is-falsy-array","@stdlib/assert/is-truthy"],"@stdlib/assert/is-falsy-array":["@stdlib/assert/is-falsy","@stdlib/assert/is-truthy-array"],"@stdlib/assert/is-finite":["@stdlib/assert/is-finite-array","@stdlib/assert/is-infinite"],"@stdlib/assert/is-finite-array":["@stdlib/assert/is-finite","@stdlib/assert/is-infinite"],"@stdlib/assert/is-float32array":["@stdlib/assert/is-float64array"],"@stdlib/assert/is-float32matrix-like":["@stdlib/assert/is-float64matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-float32ndarray-like":["@stdlib/assert/is-float64ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-float32vector-like":["@stdlib/assert/is-float64vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-float64array":["@stdlib/assert/is-float32array"],"@stdlib/assert/is-float64matrix-like":["@stdlib/assert/is-float32matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-float64ndarray-like":["@stdlib/assert/is-float32ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-float64vector-like":["@stdlib/assert/is-float32vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-function":[],"@stdlib/assert/is-function-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-generator-object":["@stdlib/assert/has-generator-support","@stdlib/assert/is-generator-object-like"],"@stdlib/assert/is-generator-object-like":["@stdlib/assert/has-generator-support","@stdlib/assert/is-generator-object"],"@stdlib/assert/is-gzip-buffer":["@stdlib/assert/is-buffer","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-hex-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-infinite":["@stdlib/assert/is-finite"],"@stdlib/assert/is-inherited-property":["@stdlib/assert/has-own-property","@stdlib/assert/has-property"],"@stdlib/assert/is-int8array":["@stdlib/assert/is-int16array","@stdlib/assert/is-int32array"],"@stdlib/assert/is-int16array":["@stdlib/assert/is-int32array","@stdlib/assert/is-int8array"],"@stdlib/assert/is-int32array":["@stdlib/assert/is-int16array","@stdlib/assert/is-int8array"],"@stdlib/assert/is-integer":["@stdlib/assert/is-number"],"@stdlib/assert/is-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-iterable-like":["@stdlib/assert/is-iterator-like"],"@stdlib/assert/is-iterator-like":["@stdlib/assert/is-iterable-like"],"@stdlib/assert/is-json":[],"@stdlib/assert/is-kebabcase":["@stdlib/assert/is-string"],"@stdlib/assert/is-leap-year":[],"@stdlib/assert/is-localhost":[],"@stdlib/assert/is-lowercase":["@stdlib/assert/is-string","@stdlib/assert/is-uppercase"],"@stdlib/assert/is-matrix-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-typed-array-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-method":["@stdlib/assert/has-own-property","@stdlib/assert/is-function","@stdlib/assert/is-method-in"],"@stdlib/assert/is-method-in":["@stdlib/assert/has-property","@stdlib/assert/is-function","@stdlib/assert/is-method"],"@stdlib/assert/is-multi-slice":["@stdlib/assert/is-slice","@stdlib/slice/multi"],"@stdlib/assert/is-named-typed-tuple-like":["@stdlib/dstructs/named-typed-tuple"],"@stdlib/assert/is-nan":["@stdlib/assert/is-number"],"@stdlib/assert/is-nan-array":["@stdlib/assert/is-nan"],"@stdlib/assert/is-native-function":["@stdlib/assert/is-function"],"@stdlib/assert/is-ndarray-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-matrix-like","@stdlib/assert/is-typed-array-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-ndarray-like-with-data-type":["@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-negative-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-negative-number","@stdlib/assert/is-positive-finite"],"@stdlib/assert/is-negative-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-negative-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-negative-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-negative-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-negative-zero":["@stdlib/assert/is-number","@stdlib/assert/is-positive-zero"],"@stdlib/assert/is-node-builtin":[],"@stdlib/assert/is-node-duplex-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-readable-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-repl":[],"@stdlib/assert/is-node-stream-like":[],"@stdlib/assert/is-node-transform-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-writable-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-nonconfigurable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-nonconfigurable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-nonenumerable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-nonenumerable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-nonnegative-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-nonnegative-number","@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-integer":["@stdlib/assert/is-integer","@stdlib/assert/is-nonnegative-number","@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonnegative-number":["@stdlib/assert/is-nonnegative-finite","@stdlib/assert/is-nonnegative-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonpositive-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-nonpositive-number"],"@stdlib/assert/is-nonpositive-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-nonpositive-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonpositive-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-nonpositive-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonsymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-null":["@stdlib/assert/is-undefined","@stdlib/assert/is-undefined-or-null"],"@stdlib/assert/is-null-array":["@stdlib/assert/is-array","@stdlib/assert/is-null"],"@stdlib/assert/is-number":[],"@stdlib/assert/is-number-array":["@stdlib/assert/is-array","@stdlib/assert/is-number","@stdlib/assert/is-numeric-array"],"@stdlib/assert/is-numeric-array":["@stdlib/assert/is-array","@stdlib/assert/is-number-array","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-object":["@stdlib/assert/is-object-like","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-object-array":["@stdlib/assert/is-array","@stdlib/assert/is-object"],"@stdlib/assert/is-object-like":["@stdlib/assert/is-object","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-odd":["@stdlib/assert/is-even"],"@stdlib/time/iso-weeks-in-year":[],"@stdlib/assert/is-pascalcase":["@stdlib/assert/is-string"],"@stdlib/assert/is-persymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-plain-object":["@stdlib/assert/is-object"],"@stdlib/assert/is-plain-object-array":["@stdlib/assert/is-array","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-positive-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-positive-number"],"@stdlib/assert/is-positive-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-positive-integer-array":["@stdlib/assert/is-array","@stdlib/assert/is-integer","@stdlib/assert/is-positive-integer"],"@stdlib/assert/is-positive-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-positive-number-array":["@stdlib/assert/is-array","@stdlib/assert/is-number","@stdlib/assert/is-positive-number"],"@stdlib/assert/is-positive-zero":["@stdlib/assert/is-number","@stdlib/assert/is-negative-zero"],"@stdlib/assert/is-prime":["@stdlib/assert/is-composite","@stdlib/assert/is-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-primitive":["@stdlib/assert/is-boxed-primitive"],"@stdlib/assert/is-primitive-array":["@stdlib/assert/is-array","@stdlib/assert/is-primitive"],"@stdlib/assert/is-prng-like":[],"@stdlib/assert/is-probability":["@stdlib/assert/is-number"],"@stdlib/assert/is-probability-array":["@stdlib/assert/is-array","@stdlib/assert/is-probability"],"@stdlib/assert/is-property-key":["@stdlib/assert/is-string","@stdlib/assert/is-symbol","@stdlib/assert/is-nonnegative-integer","@stdlib/assert/has-own-property","@stdlib/assert/has-property"],"@stdlib/assert/is-prototype-of":["@stdlib/utils/get-prototype-of"],"@stdlib/assert/is-ragged-nested-array":[],"@stdlib/assert/is-range-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-readable-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-readable-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-read-only-property":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-read-only-property-in":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-read-write-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-read-write-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-reference-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-regexp":[],"@stdlib/assert/is-regexp-string":["@stdlib/assert/is-regexp"],"@stdlib/assert/is-relative-path":["@stdlib/assert/is-absolute-path"],"@stdlib/assert/is-relative-uri":["@stdlib/assert/is-uri"],"@stdlib/assert/is-safe-integer":["@stdlib/assert/is-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-safe-integer-array":["@stdlib/assert/is-array","@stdlib/assert/is-safe-integer"],"@stdlib/assert/is-same-array":["@stdlib/assert/is-array","@stdlib/assert/is-equal-array","@stdlib/assert/is-same-array-like","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-array-like":["@stdlib/assert/is-array-like","@stdlib/assert/is-same-array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex64":["@stdlib/assert/is-complex64","@stdlib/assert/is-same-complex128","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex64array":["@stdlib/assert/is-complex64array","@stdlib/assert/is-same-complex128array","@stdlib/assert/is-same-float32array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex128":["@stdlib/assert/is-complex128","@stdlib/assert/is-same-complex64","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex128array":["@stdlib/assert/is-complex128array","@stdlib/assert/is-same-complex64array","@stdlib/assert/is-same-float64array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-date-object":["@stdlib/assert/is-date-object","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-float32array":["@stdlib/assert/is-same-float64array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-float64array":["@stdlib/assert/is-same-float32array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-native-class":["@stdlib/assert/is-same-type","@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-type":["@stdlib/assert/is-same-native-class","@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-value":["@stdlib/assert/is-same-value-zero","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-value-zero":["@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-semver":[],"@stdlib/assert/is-sharedarraybuffer":["@stdlib/assert/is-arraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-skew-centrosymmetric-matrix":["@stdlib/assert/is-centrosymmetric-matrix","@stdlib/assert/is-matrix-like","@stdlib/assert/is-skew-symmetric-matrix"],"@stdlib/assert/is-skew-persymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-persymmetric-matrix","@stdlib/assert/is-skew-symmetric-matrix"],"@stdlib/assert/is-skew-symmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-skew-symmetric-matrix","@stdlib/assert/is-square-matrix"],"@stdlib/assert/is-slice":["@stdlib/assert/is-multi-slice","@stdlib/slice/ctor"],"@stdlib/assert/is-snakecase":["@stdlib/assert/is-string"],"@stdlib/assert/is-square-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-square-number":["@stdlib/assert/is-cube-number","@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-triangular-number"],"@stdlib/assert/is-square-triangular-number":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-square-number","@stdlib/assert/is-triangular-number"],"@stdlib/assert/is-startcase":["@stdlib/assert/is-string"],"@stdlib/assert/is-strict-equal":["@stdlib/assert/is-same-value"],"@stdlib/assert/is-string":[],"@stdlib/assert/is-string-array":["@stdlib/assert/is-array","@stdlib/assert/is-string"],"@stdlib/assert/is-symbol":[],"@stdlib/assert/is-symbol-array":["@stdlib/assert/is-array","@stdlib/assert/is-symbol"],"@stdlib/assert/is-symmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-nonsymmetric-matrix","@stdlib/assert/is-square-matrix"],"@stdlib/assert/is-syntax-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-triangular-number":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-square-number","@stdlib/assert/is-square-triangular-number"],"@stdlib/assert/is-truthy":["@stdlib/assert/is-falsy"],"@stdlib/assert/is-truthy-array":["@stdlib/assert/is-falsy-array","@stdlib/assert/is-truthy"],"@stdlib/assert/is-typed-array":["@stdlib/assert/is-array","@stdlib/assert/is-typed-array-like"],"@stdlib/assert/is-typed-array-length":["@stdlib/assert/is-array-length","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-typed-array-like":["@stdlib/assert/is-typed-array"],"@stdlib/assert/is-type-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-uint8array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint16array","@stdlib/assert/is-uint32array"],"@stdlib/assert/is-uint8clampedarray":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-uint16array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint32array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-uint32array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint16array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-unc-path":[],"@stdlib/assert/is-undefined":["@stdlib/assert/is-null","@stdlib/assert/is-undefined-or-null"],"@stdlib/assert/is-undefined-or-null":["@stdlib/assert/is-null","@stdlib/assert/is-undefined"],"@stdlib/assert/is-unity-probability-array":["@stdlib/assert/is-probability","@stdlib/assert/is-probability-array"],"@stdlib/assert/is-uppercase":["@stdlib/assert/is-lowercase","@stdlib/assert/is-string"],"@stdlib/assert/is-uri":[],"@stdlib/assert/is-uri-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-vector-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-typed-array-like"],"@stdlib/assert/is-wasm-memory":["@stdlib/assert/has-wasm-support"],"@stdlib/assert/is-well-formed-string":[],"@stdlib/assert/is-whitespace":["@stdlib/regexp/whitespace"],"@stdlib/assert/is-writable-property":["@stdlib/assert/is-readable-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-writable-property-in","@stdlib/assert/is-write-only-property"],"@stdlib/assert/is-writable-property-in":["@stdlib/assert/is-readable-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-writable-property","@stdlib/assert/is-write-only-property-in"],"@stdlib/assert/is-write-only-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-writable-property","@stdlib/assert/is-write-only-property-in"],"@stdlib/assert/is-write-only-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-writable-property-in","@stdlib/assert/is-write-only-property"],"@stdlib/math/iter/special/abs":["@stdlib/math/base/special/abs","@stdlib/math/iter/special/abs2"],"@stdlib/math/iter/special/abs2":["@stdlib/math/base/special/abs2","@stdlib/math/iter/special/abs"],"@stdlib/math/iter/special/acos":["@stdlib/math/base/special/acos","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/acosh":["@stdlib/math/base/special/acosh","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/acot":["@stdlib/math/base/special/acot","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/acoth","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/acoth":["@stdlib/math/base/special/acoth","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/acot","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/acovercos":["@stdlib/math/base/special/acovercos","@stdlib/math/iter/special/acoversin","@stdlib/math/iter/special/avercos","@stdlib/math/iter/special/covercos","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/acoversin":["@stdlib/math/base/special/acoversin","@stdlib/math/iter/special/acovercos","@stdlib/math/iter/special/aversin","@stdlib/math/iter/special/coversin","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/ops/add":["@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/multiply","@stdlib/math/iter/ops/subtract"],"@stdlib/iter/advance":["@stdlib/iter/head","@stdlib/iter/slice"],"@stdlib/math/iter/special/ahavercos":["@stdlib/math/base/special/ahavercos","@stdlib/math/iter/special/ahaversin","@stdlib/math/iter/special/havercos","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/ahaversin":["@stdlib/math/base/special/ahaversin","@stdlib/math/iter/special/ahavercos","@stdlib/math/iter/special/haversin","@stdlib/math/iter/special/versin"],"@stdlib/iter/any":["@stdlib/iter/any-by","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some"],"@stdlib/iter/any-by":["@stdlib/iter/any","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some-by"],"@stdlib/math/iter/special/asin":["@stdlib/math/base/special/asin","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/asinh":["@stdlib/math/base/special/asinh","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/atan":["@stdlib/math/base/special/atan","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/atan2":["@stdlib/math/base/special/atan2","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/atanh":["@stdlib/math/base/special/atanh","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atan"],"@stdlib/array/from-iterator":["@stdlib/array/to-iterator","@stdlib/iter/to-array-view"],"@stdlib/iter/to-array-view":["@stdlib/array/from-iterator","@stdlib/array/to-view-iterator","@stdlib/iter/to-array-view-right"],"@stdlib/iter/to-array-view-right":["@stdlib/array/from-iterator","@stdlib/array/to-view-iterator-right","@stdlib/iter/to-array-view"],"@stdlib/streams/node/from-iterator":["@stdlib/streams/node/from-array"],"@stdlib/symbol/iterator":["@stdlib/symbol/ctor"],"@stdlib/math/iter/special/avercos":["@stdlib/math/base/special/avercos","@stdlib/math/iter/special/aversin","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/special/aversin":["@stdlib/math/base/special/aversin","@stdlib/math/iter/special/avercos","@stdlib/math/iter/special/vercos"],"@stdlib/simulate/iter/awgn":["@stdlib/simulate/iter/awln","@stdlib/simulate/iter/awun"],"@stdlib/simulate/iter/awln":["@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awun"],"@stdlib/simulate/iter/awun":["@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awln"],"@stdlib/simulate/iter/bartlett-hann-pulse":["@stdlib/simulate/iter/bartlett-pulse","@stdlib/simulate/iter/hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/triangle-wave"],"@stdlib/simulate/iter/bartlett-pulse":["@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/triangle-wave"],"@stdlib/math/iter/special/besselj0":["@stdlib/math/base/special/besselj0","@stdlib/math/iter/special/besselj1","@stdlib/math/iter/special/bessely0","@stdlib/math/iter/special/bessely1"],"@stdlib/math/iter/special/besselj1":["@stdlib/math/base/special/besselj1","@stdlib/math/iter/special/besselj0","@stdlib/math/iter/special/bessely0","@stdlib/math/iter/special/bessely1"],"@stdlib/math/iter/special/bessely0":["@stdlib/math/base/special/bessely0","@stdlib/math/iter/special/besselj0","@stdlib/math/iter/special/besselj1","@stdlib/math/iter/special/bessely1"],"@stdlib/math/iter/special/bessely1":["@stdlib/math/base/special/bessely1","@stdlib/math/iter/special/besselj0","@stdlib/math/iter/special/besselj1","@stdlib/math/iter/special/bessely0"],"@stdlib/math/iter/special/beta":["@stdlib/math/base/special/beta","@stdlib/math/iter/special/betaln"],"@stdlib/math/iter/special/betaln":["@stdlib/math/base/special/betaln","@stdlib/math/iter/special/beta"],"@stdlib/math/iter/special/binet":["@stdlib/math/base/special/binet"],"@stdlib/math/iter/special/cbrt":["@stdlib/math/base/special/cbrt","@stdlib/math/iter/special/pow","@stdlib/math/iter/special/sqrt"],"@stdlib/math/iter/special/ceil":["@stdlib/math/base/special/ceil","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/round"],"@stdlib/math/iter/special/ceil2":["@stdlib/math/base/special/ceil2","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round2"],"@stdlib/math/iter/special/ceil10":["@stdlib/math/base/special/ceil10","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round10"],"@stdlib/math/iter/sequences/composites":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/positive-integers","@stdlib/math/iter/sequences/primes"],"@stdlib/iter/concat":[],"@stdlib/iter/constant":["@stdlib/utils/constant-function"],"@stdlib/math/iter/utils/continued-fraction":["@stdlib/math/iter/sequences/continued-fraction"],"@stdlib/math/iter/sequences/continued-fraction":["@stdlib/math/iter/utils/continued-fraction"],"@stdlib/math/iter/special/cos":["@stdlib/math/base/special/cos","@stdlib/math/iter/special/cospi","@stdlib/math/iter/special/sin","@stdlib/math/iter/special/tan"],"@stdlib/math/iter/special/cosh":["@stdlib/math/base/special/cosh","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sinh","@stdlib/math/iter/special/tanh"],"@stdlib/simulate/iter/cosine-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/math/iter/special/cosm1":["@stdlib/math/base/special/cosm1","@stdlib/math/iter/special/cos"],"@stdlib/math/iter/special/cospi":["@stdlib/math/base/special/cospi","@stdlib/math/iter/special/cos"],"@stdlib/iter/counter":["@stdlib/iter/length"],"@stdlib/math/iter/special/covercos":["@stdlib/math/base/special/covercos","@stdlib/math/iter/special/coversin","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/coversin":["@stdlib/math/base/special/coversin","@stdlib/math/iter/special/covercos","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/sequences/cubes":["@stdlib/math/iter/sequences/fourth-powers","@stdlib/math/iter/sequences/squares"],"@stdlib/stats/iter/cugmean":["@stdlib/stats/iter/cuhmean","@stdlib/stats/iter/cumean"],"@stdlib/stats/iter/cuhmean":["@stdlib/stats/iter/cugmean","@stdlib/stats/iter/cumean"],"@stdlib/stats/iter/cumax":["@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cumin","@stdlib/stats/iter/curange","@stdlib/stats/iter/max"],"@stdlib/stats/iter/cumaxabs":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cuminabs","@stdlib/stats/iter/maxabs"],"@stdlib/stats/iter/cumean":["@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cusum","@stdlib/stats/iter/mean"],"@stdlib/stats/iter/cumeanabs":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/meanabs"],"@stdlib/stats/iter/cumeanabs2":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cusumabs2","@stdlib/stats/iter/meanabs2"],"@stdlib/stats/iter/cumidrange":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumin","@stdlib/stats/iter/curange","@stdlib/stats/iter/midrange"],"@stdlib/stats/iter/cumin":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/curange","@stdlib/stats/iter/min"],"@stdlib/stats/iter/cuminabs":["@stdlib/stats/iter/cumaxabs","@stdlib/stats/iter/cumin","@stdlib/stats/iter/minabs"],"@stdlib/stats/iter/cuprod":["@stdlib/stats/iter/cusum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/curange":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/cusum":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/sum","@stdlib/stats/iter/cuprod"],"@stdlib/stats/iter/cusumabs":["@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cusum","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/cusumabs2":["@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/sumabs2"],"@stdlib/iter/datespace":["@stdlib/array/from-iterator","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/logspace","@stdlib/iter/step"],"@stdlib/iter/dedupe":["@stdlib/iter/dedupe-by","@stdlib/iter/unique"],"@stdlib/iter/dedupe-by":["@stdlib/iter/dedupe","@stdlib/iter/unique"],"@stdlib/math/iter/special/deg2rad":["@stdlib/math/base/special/deg2rad","@stdlib/math/iter/special/rad2deg"],"@stdlib/math/iter/special/digamma":["@stdlib/math/base/special/digamma","@stdlib/math/iter/special/gamma","@stdlib/math/iter/special/trigamma"],"@stdlib/simulate/iter/dirac-comb":["@stdlib/simulate/iter/pulse"],"@stdlib/math/iter/special/dirac-delta":["@stdlib/math/base/special/dirac-delta"],"@stdlib/math/iter/ops/divide":["@stdlib/math/iter/ops/add","@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/multiply"],"@stdlib/iter/do-until-each":["@stdlib/iter/do-while-each","@stdlib/iter/until-each","@stdlib/iter/while-each"],"@stdlib/iter/do-while-each":["@stdlib/iter/do-until-each","@stdlib/iter/until-each","@stdlib/iter/while-each"],"@stdlib/math/iter/special/ellipe":["@stdlib/math/base/special/ellipe","@stdlib/math/iter/special/ellipk"],"@stdlib/math/iter/special/ellipk":["@stdlib/math/base/special/ellipk","@stdlib/math/iter/special/ellipe"],"@stdlib/iter/empty":["@stdlib/iter/constant"],"@stdlib/math/iter/special/erf":["@stdlib/math/base/special/erf","@stdlib/math/iter/special/erfc","@stdlib/math/iter/special/erfinv","@stdlib/math/iter/special/erfcinv"],"@stdlib/math/iter/special/erfc":["@stdlib/math/base/special/erfc","@stdlib/math/iter/special/erf","@stdlib/math/iter/special/erfinv","@stdlib/math/iter/special/erfcinv"],"@stdlib/math/iter/special/erfcinv":["@stdlib/math/base/special/erfcinv","@stdlib/math/iter/special/erf","@stdlib/math/iter/special/erfc","@stdlib/math/iter/special/erfinv"],"@stdlib/math/iter/special/erfinv":["@stdlib/math/base/special/erfinv","@stdlib/math/iter/special/erf","@stdlib/math/iter/special/erfc","@stdlib/math/iter/special/erfcinv"],"@stdlib/math/iter/special/dirichlet-eta":["@stdlib/math/base/special/dirichlet-eta"],"@stdlib/math/iter/sequences/even-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/odd-integers"],"@stdlib/iter/every":["@stdlib/iter/any","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some"],"@stdlib/iter/every-by":["@stdlib/iter/any-by","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some-by"],"@stdlib/math/iter/special/exp":["@stdlib/math/base/special/exp","@stdlib/math/iter/special/exp10","@stdlib/math/iter/special/exp2","@stdlib/math/iter/special/expm1","@stdlib/math/iter/special/ln"],"@stdlib/math/iter/special/exp2":["@stdlib/math/base/special/exp2","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/exp10","@stdlib/math/iter/special/log2"],"@stdlib/math/iter/special/exp10":["@stdlib/math/base/special/exp10","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/exp2","@stdlib/math/iter/special/log10"],"@stdlib/math/iter/special/expit":["@stdlib/math/base/special/expit","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/logit"],"@stdlib/math/iter/special/expm1":["@stdlib/math/base/special/expm1","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/expm1rel"],"@stdlib/math/iter/special/expm1rel":["@stdlib/math/base/special/expm1rel","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/expm1"],"@stdlib/math/iter/special/factorial":["@stdlib/math/base/special/factorial","@stdlib/math/iter/special/factorialln"],"@stdlib/math/iter/special/factorialln":["@stdlib/math/base/special/factorialln","@stdlib/math/iter/special/factorial"],"@stdlib/math/iter/sequences/factorials":["@stdlib/math/iter/special/factorial"],"@stdlib/math/iter/sequences/fibonacci":["@stdlib/math/base/special/fibonacci","@stdlib/math/iter/sequences/lucas","@stdlib/math/iter/sequences/negafibonacci","@stdlib/math/iter/sequences/nonfibonacci"],"@stdlib/math/iter/sequences/fifth-powers":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/fourth-powers","@stdlib/math/iter/sequences/squares"],"@stdlib/iter/fill":[],"@stdlib/iter/filter":["@stdlib/iter/filter-map","@stdlib/iter/map","@stdlib/iter/reject"],"@stdlib/iter/filter-map":["@stdlib/iter/filter","@stdlib/iter/map"],"@stdlib/iter/first":["@stdlib/iter/head","@stdlib/iter/last","@stdlib/iter/nth"],"@stdlib/simulate/iter/flat-top-pulse":["@stdlib/simulate/iter/pulse"],"@stdlib/math/iter/special/floor":["@stdlib/math/base/special/floor","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/round"],"@stdlib/math/iter/special/floor2":["@stdlib/math/base/special/floor2","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round2"],"@stdlib/math/iter/special/floor10":["@stdlib/math/base/special/floor10","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round10"],"@stdlib/iter/flow":["@stdlib/iter/pipeline"],"@stdlib/iter/for-each":["@stdlib/iter/map"],"@stdlib/math/iter/sequences/fourth-powers":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/fifth-powers","@stdlib/math/iter/sequences/squares"],"@stdlib/math/iter/special/fresnelc":["@stdlib/math/base/special/fresnelc","@stdlib/math/iter/special/fresnels"],"@stdlib/math/iter/special/fresnels":["@stdlib/math/base/special/fresnels","@stdlib/math/iter/special/fresnelc"],"@stdlib/math/iter/special/gamma":["@stdlib/math/base/special/gamma","@stdlib/math/iter/special/gamma1pm1","@stdlib/math/iter/special/gammaln"],"@stdlib/math/iter/special/gamma1pm1":["@stdlib/math/base/special/gamma1pm1","@stdlib/math/iter/special/gamma"],"@stdlib/math/iter/special/gammaln":["@stdlib/math/base/special/gammaln","@stdlib/math/iter/special/gamma"],"@stdlib/math/iter/special/hacovercos":["@stdlib/math/base/special/hacovercos","@stdlib/math/iter/special/covercos","@stdlib/math/iter/special/hacoversin"],"@stdlib/math/iter/special/hacoversin":["@stdlib/math/base/special/hacoversin","@stdlib/math/iter/special/coversin","@stdlib/math/iter/special/hacovercos"],"@stdlib/simulate/iter/hann-pulse":["@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sine-wave"],"@stdlib/math/iter/special/havercos":["@stdlib/math/base/special/havercos","@stdlib/math/iter/special/haversin","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/haversin":["@stdlib/math/base/special/haversin","@stdlib/math/iter/special/havercos","@stdlib/math/iter/special/versin"],"@stdlib/iter/head":["@stdlib/iter/first","@stdlib/iter/slice"],"@stdlib/iter/incrspace":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/linspace","@stdlib/iter/logspace","@stdlib/iter/step","@stdlib/iter/unitspace"],"@stdlib/math/iter/sequences/integers":["@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/iter/intersection":["@stdlib/iter/intersection-by-hash","@stdlib/iter/union","@stdlib/iter/unique"],"@stdlib/iter/intersection-by-hash":["@stdlib/iter/intersection","@stdlib/iter/unique-by-hash"],"@stdlib/math/iter/special/inv":["@stdlib/math/base/special/inv","@stdlib/math/iter/special/pow"],"@stdlib/simulate/iter/lanczos-pulse":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/periodic-sinc"],"@stdlib/iter/last":["@stdlib/iter/first","@stdlib/iter/nth"],"@stdlib/iter/length":["@stdlib/iter/counter"],"@stdlib/iter/linspace":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/incrspace","@stdlib/iter/logspace","@stdlib/iter/step","@stdlib/iter/unitspace"],"@stdlib/math/iter/special/ln":["@stdlib/math/base/special/ln","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log2"],"@stdlib/math/iter/special/log":["@stdlib/math/base/special/log","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log2","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log1mexp":["@stdlib/math/base/special/log1mexp","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log1pexp","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log1p":["@stdlib/math/base/special/log1p","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log2","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log1pexp":["@stdlib/math/base/special/log1pexp","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log1mexp","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log2":["@stdlib/math/base/special/log2","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log10":["@stdlib/math/base/special/log10","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log2","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/logit":["@stdlib/math/base/special/logit"],"@stdlib/iter/logspace":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/step"],"@stdlib/math/iter/sequences/lucas":["@stdlib/math/base/special/lucas","@stdlib/math/iter/sequences/fibonacci","@stdlib/math/iter/sequences/negalucas"],"@stdlib/iter/map":["@stdlib/iter/filter","@stdlib/iter/filter-map","@stdlib/iter/for-each","@stdlib/iter/reject"],"@stdlib/iter/mapn":["@stdlib/iter/map"],"@stdlib/stats/iter/max":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/min","@stdlib/stats/iter/mmax","@stdlib/stats/iter/range"],"@stdlib/stats/iter/maxabs":["@stdlib/stats/iter/max","@stdlib/stats/iter/minabs","@stdlib/stats/iter/mmaxabs"],"@stdlib/stats/iter/mean":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmean","@stdlib/stats/iter/stdev","@stdlib/stats/iter/sum","@stdlib/stats/iter/variance"],"@stdlib/stats/iter/meanabs":["@stdlib/stats/iter/mean","@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/meanabs2":["@stdlib/stats/iter/mean","@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/sumabs2"],"@stdlib/stats/iter/midrange":["@stdlib/stats/iter/mean","@stdlib/stats/iter/max","@stdlib/stats/iter/min","@stdlib/stats/iter/range"],"@stdlib/stats/iter/min":["@stdlib/stats/iter/max","@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/minabs":["@stdlib/stats/iter/maxabs","@stdlib/stats/iter/min","@stdlib/stats/iter/mminabs"],"@stdlib/stats/iter/mmax":["@stdlib/stats/iter/max","@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/mmin","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mmaxabs":["@stdlib/stats/iter/maxabs","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mminabs"],"@stdlib/stats/iter/mmean":["@stdlib/stats/iter/mean","@stdlib/stats/iter/msum"],"@stdlib/stats/iter/mmeanabs":["@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mmean","@stdlib/stats/iter/msumabs"],"@stdlib/stats/iter/mmeanabs2":["@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/msumabs2"],"@stdlib/stats/iter/mmidrange":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmean","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmin","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mmin":["@stdlib/stats/iter/min","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mminabs":["@stdlib/stats/iter/minabs","@stdlib/stats/iter/mmaxabs","@stdlib/stats/iter/mmin"],"@stdlib/math/iter/ops/mod":["@stdlib/math/iter/ops/divide"],"@stdlib/stats/iter/mprod":["@stdlib/stats/iter/msum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/mrange":["@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmean","@stdlib/stats/iter/mmin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/msum":["@stdlib/stats/iter/mmean","@stdlib/stats/iter/sum"],"@stdlib/stats/iter/msumabs":["@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/msum","@stdlib/stats/iter/sum","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/msumabs2":["@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/msumabs","@stdlib/stats/iter/sumabs","@stdlib/stats/iter/sumabs2"],"@stdlib/math/iter/ops/multiply":["@stdlib/math/iter/ops/add","@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/subtract"],"@stdlib/math/iter/sequences/negafibonacci":["@stdlib/math/base/special/negafibonacci","@stdlib/math/iter/sequences/fibonacci","@stdlib/math/iter/sequences/nonfibonacci"],"@stdlib/math/iter/sequences/negalucas":["@stdlib/math/base/special/negalucas","@stdlib/math/iter/sequences/lucas","@stdlib/math/iter/sequences/negafibonacci"],"@stdlib/math/iter/sequences/negative-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/negative-odd-integers","@stdlib/math/iter/sequences/positive-even-integers","@stdlib/math/iter/sequences/nonpositive-even-integers"],"@stdlib/math/iter/sequences/negative-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/sequences/negative-odd-integers":["@stdlib/math/iter/sequences/odd-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/negative-even-integers","@stdlib/math/iter/sequences/positive-odd-integers"],"@stdlib/iter/none":["@stdlib/iter/any","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some"],"@stdlib/iter/none-by":["@stdlib/iter/any-by","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some-by"],"@stdlib/math/iter/sequences/nonfibonacci":["@stdlib/math/base/special/nonfibonacci","@stdlib/math/iter/sequences/fibonacci"],"@stdlib/math/iter/sequences/nonnegative-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-even-integers","@stdlib/math/iter/sequences/positive-even-integers"],"@stdlib/math/iter/sequences/nonnegative-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/sequences/nonpositive-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/nonnegative-even-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/negative-even-integers"],"@stdlib/math/iter/sequences/nonpositive-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/sequences/nonsquares":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/squares"],"@stdlib/iter/nth":["@stdlib/iter/first","@stdlib/iter/last"],"@stdlib/math/iter/sequences/odd-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers"],"@stdlib/simulate/iter/periodic-sinc":["@stdlib/simulate/iter/sine-wave"],"@stdlib/iter/pipeline":["@stdlib/iter/flow","@stdlib/iter/pipeline-thunk"],"@stdlib/iter/pop":["@stdlib/iter/push","@stdlib/iter/shift","@stdlib/iter/slice"],"@stdlib/math/iter/sequences/positive-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-even-integers","@stdlib/math/iter/sequences/nonnegative-even-integers","@stdlib/math/iter/sequences/positive-integers","@stdlib/math/iter/sequences/positive-odd-integers"],"@stdlib/math/iter/sequences/positive-integers":["@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/negative-integers"],"@stdlib/math/iter/sequences/positive-odd-integers":["@stdlib/math/iter/sequences/odd-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-odd-integers","@stdlib/math/iter/sequences/positive-even-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/special/pow":["@stdlib/math/base/special/pow","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/log"],"@stdlib/math/iter/sequences/primes":["@stdlib/math/iter/sequences/composites","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/stats/iter/prod":["@stdlib/stats/iter/mprod","@stdlib/stats/iter/sum"],"@stdlib/simulate/iter/pulse":["@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/push":["@stdlib/iter/concat","@stdlib/iter/unshift"],"@stdlib/math/iter/special/rad2deg":["@stdlib/math/base/special/rad2deg","@stdlib/math/iter/special/deg2rad"],"@stdlib/math/iter/special/ramp":["@stdlib/math/base/special/ramp"],"@stdlib/stats/iter/range":["@stdlib/stats/iter/max","@stdlib/stats/iter/mean","@stdlib/stats/iter/min","@stdlib/stats/iter/mrange"],"@stdlib/iter/reject":["@stdlib/iter/filter","@stdlib/iter/map"],"@stdlib/iter/replicate":["@stdlib/iter/replicate-by"],"@stdlib/iter/replicate-by":["@stdlib/iter/replicate"],"@stdlib/math/iter/special/round":["@stdlib/math/base/special/round","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/trunc"],"@stdlib/math/iter/special/round2":["@stdlib/math/base/special/round2","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round","@stdlib/math/iter/special/round10","@stdlib/math/iter/special/trunc2"],"@stdlib/math/iter/special/round10":["@stdlib/math/base/special/round10","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round","@stdlib/math/iter/special/round2","@stdlib/math/iter/special/trunc10"],"@stdlib/math/iter/special/rsqrt":["@stdlib/math/base/special/rsqrt","@stdlib/math/iter/special/sqrt"],"@stdlib/simulate/iter/sawtooth-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/shift":["@stdlib/iter/pop","@stdlib/iter/slice","@stdlib/iter/unshift"],"@stdlib/math/iter/special/signum":["@stdlib/math/base/special/signum"],"@stdlib/math/iter/special/sin":["@stdlib/math/base/special/sin","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sinpi","@stdlib/math/iter/special/tan"],"@stdlib/math/iter/special/sinc":["@stdlib/math/base/special/sinc","@stdlib/math/iter/special/sin"],"@stdlib/simulate/iter/sine-wave":["@stdlib/simulate/iter/cosine-wave","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/math/iter/special/sinh":["@stdlib/math/base/special/sinh","@stdlib/math/iter/special/cosh","@stdlib/math/iter/special/tanh"],"@stdlib/math/iter/special/sinpi":["@stdlib/math/base/special/sinpi","@stdlib/math/iter/special/sin"],"@stdlib/iter/slice":["@stdlib/iter/first","@stdlib/iter/head"],"@stdlib/iter/some":["@stdlib/iter/any","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some-by"],"@stdlib/iter/some-by":["@stdlib/iter/any-by","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some"],"@stdlib/math/iter/special/spence":["@stdlib/math/base/special/spence"],"@stdlib/math/iter/special/sqrt":["@stdlib/math/base/special/sqrt","@stdlib/math/iter/special/cbrt","@stdlib/math/iter/special/rsqrt"],"@stdlib/math/iter/special/sqrt1pm1":["@stdlib/math/base/special/sqrt1pm1","@stdlib/math/iter/special/sqrt"],"@stdlib/math/iter/sequences/squared-triangular":["@stdlib/math/iter/sequences/triangular"],"@stdlib/math/iter/sequences/squares":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/nonsquares"],"@stdlib/simulate/iter/square-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/stats/iter/stdev":["@stdlib/stats/iter/mean","@stdlib/stats/iter/variance"],"@stdlib/iter/step":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/logspace","@stdlib/iter/unitspace"],"@stdlib/iter/strided":["@stdlib/iter/advance","@stdlib/iter/nth","@stdlib/iter/strided-by"],"@stdlib/iter/strided-by":["@stdlib/iter/advance","@stdlib/iter/nth","@stdlib/iter/strided"],"@stdlib/math/iter/ops/subtract":["@stdlib/math/iter/ops/add","@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/multiply"],"@stdlib/stats/iter/sum":["@stdlib/stats/iter/mean","@stdlib/stats/iter/msum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/sumabs":["@stdlib/stats/iter/meanabs","@stdlib/stats/iter/msumabs","@stdlib/stats/iter/sum"],"@stdlib/stats/iter/sumabs2":["@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/msumabs2","@stdlib/stats/iter/sumabs"],"@stdlib/math/iter/special/tan":["@stdlib/math/base/special/tan","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sin"],"@stdlib/math/iter/special/tanh":["@stdlib/math/base/special/tanh","@stdlib/math/iter/special/cosh","@stdlib/math/iter/special/sinh","@stdlib/math/iter/special/tan"],"@stdlib/iter/pipeline-thunk":["@stdlib/iter/pipeline"],"@stdlib/simulate/iter/triangle-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave"],"@stdlib/math/iter/sequences/triangular":["@stdlib/math/iter/sequences/squared-triangular"],"@stdlib/math/iter/sequences/tribonacci":["@stdlib/math/base/special/tribonacci","@stdlib/math/base/special/fibonacci","@stdlib/math/iter/sequences/lucas"],"@stdlib/math/iter/special/trigamma":["@stdlib/math/base/special/trigamma","@stdlib/math/iter/special/digamma","@stdlib/math/iter/special/gamma"],"@stdlib/math/iter/special/trunc":["@stdlib/math/base/special/trunc","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/round"],"@stdlib/math/iter/special/trunc2":["@stdlib/math/base/special/trunc2","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round2","@stdlib/math/iter/special/trunc"],"@stdlib/math/iter/special/trunc10":["@stdlib/math/base/special/trunc10","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round10","@stdlib/math/iter/special/trunc"],"@stdlib/iter/union":["@stdlib/iter/intersection","@stdlib/iter/unique"],"@stdlib/iter/unique":["@stdlib/iter/unique-by","@stdlib/iter/unique-by-hash"],"@stdlib/iter/unique-by":["@stdlib/iter/unique","@stdlib/iter/unique-by-hash"],"@stdlib/iter/unique-by-hash":["@stdlib/iter/unique","@stdlib/iter/unique-by"],"@stdlib/iter/unitspace":["@stdlib/array/from-iterator","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/step"],"@stdlib/iter/unshift":["@stdlib/iter/concat","@stdlib/iter/push","@stdlib/iter/shift"],"@stdlib/iter/until-each":["@stdlib/iter/while-each"],"@stdlib/stats/iter/variance":["@stdlib/stats/iter/mean","@stdlib/stats/iter/stdev"],"@stdlib/math/iter/special/vercos":["@stdlib/math/base/special/vercos","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sin","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/special/versin":["@stdlib/math/base/special/versin","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sin","@stdlib/math/iter/special/vercos"],"@stdlib/iter/while-each":["@stdlib/iter/until-each"],"@stdlib/math/iter/special/riemann-zeta":["@stdlib/math/base/special/riemann-zeta"],"@stdlib/streams/node/join":["@stdlib/streams/node/split"],"@stdlib/stats/kde2d":[],"@stdlib/string/kebabcase":["@stdlib/string/camelcase","@stdlib/string/constantcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/utils/key-by":["@stdlib/utils/for-each"],"@stdlib/utils/key-by-right":["@stdlib/utils/for-each-right","@stdlib/utils/key-by"],"@stdlib/utils/keys-in":["@stdlib/utils/entries-in","@stdlib/utils/keys","@stdlib/utils/values-in"],"@stdlib/stats/kruskal-test":[],"@stdlib/stats/kstest":[],"@stdlib/string/last":["@stdlib/string/first"],"@stdlib/nlp/lda":[],"@stdlib/stats/levene-test":["@stdlib/stats/vartest","@stdlib/stats/bartlett-test"],"@stdlib/dstructs/linked-list":["@stdlib/dstructs/doubly-linked-list","@stdlib/dstructs/stack"],"@stdlib/array/linspace":["@stdlib/array/incrspace","@stdlib/array/logspace"],"@stdlib/datasets/liu-negative-opinion-words-en":["@stdlib/datasets/liu-positive-opinion-words-en"],"@stdlib/datasets/liu-positive-opinion-words-en":["@stdlib/datasets/liu-negative-opinion-words-en"],"@stdlib/constants/float64/ln-half":[],"@stdlib/constants/float64/ln-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/ln-sqrt-two-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/ln-two-pi":["@stdlib/constants/float64/two-pi"],"@stdlib/constants/float64/ln-two":["@stdlib/constants/float64/ln-ten"],"@stdlib/constants/float64/ln-ten":["@stdlib/constants/float64/ln-two"],"@stdlib/constants/float64/log2-e":["@stdlib/constants/float64/e","@stdlib/constants/float64/log10-e"],"@stdlib/constants/float64/log10-e":["@stdlib/constants/float64/e","@stdlib/constants/float64/log2-e"],"@stdlib/array/logspace":["@stdlib/array/incrspace","@stdlib/array/linspace"],"@stdlib/string/lowercase":["@stdlib/string/uncapitalize","@stdlib/string/uppercase"],"@stdlib/utils/lowercase-keys":["@stdlib/utils/uncapitalize-keys","@stdlib/utils/uppercase-keys"],"@stdlib/stats/lowess":[],"@stdlib/string/left-pad":["@stdlib/string/pad","@stdlib/string/right-pad"],"@stdlib/string/left-trim":["@stdlib/string/trim","@stdlib/string/right-trim"],"@stdlib/string/left-trim-n":["@stdlib/string/right-trim-n","@stdlib/string/trim"],"@stdlib/datasets/male-first-names-en":["@stdlib/datasets/female-first-names-en"],"@stdlib/utils/map":["@stdlib/utils/map-right","@stdlib/utils/reduce"],"@stdlib/utils/map2":["@stdlib/utils/map"],"@stdlib/utils/map2d":["@stdlib/utils/map","@stdlib/utils/map3d","@stdlib/utils/map4d","@stdlib/utils/map5d","@stdlib/utils/reduce2d"],"@stdlib/utils/map2-right":["@stdlib/utils/map-right","@stdlib/utils/map2"],"@stdlib/utils/map3d":["@stdlib/utils/map","@stdlib/utils/map2d","@stdlib/utils/map4d","@stdlib/utils/map5d"],"@stdlib/utils/map4d":["@stdlib/utils/map","@stdlib/utils/map2d","@stdlib/utils/map3d","@stdlib/utils/map5d"],"@stdlib/utils/map5d":["@stdlib/utils/map","@stdlib/utils/map2d","@stdlib/utils/map3d","@stdlib/utils/map4d"],"@stdlib/utils/map-arguments":["@stdlib/utils/filter-arguments"],"@stdlib/utils/map-function":["@stdlib/utils/async/map-function"],"@stdlib/utils/async/map-function":["@stdlib/utils/map-function"],"@stdlib/utils/map-keys":["@stdlib/utils/map-values"],"@stdlib/utils/async/map-keys":["@stdlib/utils/map-keys","@stdlib/utils/async/map-values"],"@stdlib/utils/map-reduce":["@stdlib/utils/map","@stdlib/utils/map-reduce-right","@stdlib/utils/reduce"],"@stdlib/utils/map-reduce-right":["@stdlib/utils/map-right","@stdlib/utils/map-reduce","@stdlib/utils/reduce-right"],"@stdlib/utils/map-right":["@stdlib/utils/map","@stdlib/utils/reduce"],"@stdlib/utils/map-values":["@stdlib/utils/map-keys","@stdlib/utils/omit-by","@stdlib/utils/pick-by"],"@stdlib/utils/async/map-values":["@stdlib/utils/async/map-keys","@stdlib/utils/map-values"],"@stdlib/utils/mask-arguments":["@stdlib/utils/filter-arguments","@stdlib/utils/reject-arguments","@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/constants/array/max-array-length":["@stdlib/constants/array/max-typed-array-length"],"@stdlib/constants/array/max-typed-array-length":["@stdlib/constants/array/max-array-length"],"@stdlib/ndarray/maybe-broadcast-array":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/broadcast-array","@stdlib/ndarray/maybe-broadcast-arrays"],"@stdlib/ndarray/maybe-broadcast-arrays":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/broadcast-arrays","@stdlib/ndarray/maybe-broadcast-array"],"@stdlib/utils/memoize":[],"@stdlib/utils/merge":["@stdlib/utils/copy"],"@stdlib/constants/time/milliseconds-in-day":[],"@stdlib/constants/time/milliseconds-in-hour":[],"@stdlib/constants/time/milliseconds-in-minute":[],"@stdlib/constants/time/milliseconds-in-second":[],"@stdlib/constants/time/milliseconds-in-week":[],"@stdlib/datasets/minard-napoleons-march":[],"@stdlib/constants/time/minutes-in-day":[],"@stdlib/constants/time/minutes-in-hour":[],"@stdlib/constants/time/minutes-in-week":[],"@stdlib/time/minutes-in-month":["@stdlib/time/minutes-in-year"],"@stdlib/time/minutes-in-year":["@stdlib/time/minutes-in-month"],"@stdlib/datasets/moby-dick":[],"@stdlib/datasets/month-names-en":[],"@stdlib/constants/time/months-in-year":[],"@stdlib/utils/move-property":[],"@stdlib/slice/multi":["@stdlib/ndarray/ctor","@stdlib/slice/ctor"],"@stdlib/dstructs/named-typed-tuple":["@stdlib/array/typed"],"@stdlib/constants/float64/nan":["@stdlib/constants/float32/nan"],"@stdlib/utils/nary-function":["@stdlib/utils/mask-arguments","@stdlib/utils/pick-arguments"],"@stdlib/utils/native-class":["@stdlib/utils/constructor-name","@stdlib/utils/type-of"],"@stdlib/ndarray/ctor":["@stdlib/ndarray/array","@stdlib/ndarray/fancy"],"@stdlib/ndarray/to-array":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/to-json"],"@stdlib/ndarray/to-fancy":["@stdlib/array/to-fancy","@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/fancy"],"@stdlib/ndarray/to-json":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/to-array"],"@stdlib/ndarray/casting-modes":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/data-buffer":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/dtype"],"@stdlib/ndarray/dtype":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/dtypes"],"@stdlib/ndarray/dtypes":["@stdlib/array/dtypes","@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/array/typed-dtypes"],"@stdlib/ndarray/dispatch":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/flag":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/flags"],"@stdlib/ndarray/flags":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/flag"],"@stdlib/ndarray/index-modes":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/ndarraylike2ndarray":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/empty-like","@stdlib/ndarray/zeros-like"],"@stdlib/ndarray/min-dtype":["@stdlib/ndarray/dtypes","@stdlib/ndarray/promotion-rules","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/mostly-safe-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts","@stdlib/ndarray/same-kind-casts"],"@stdlib/ndarray/next-dtype":["@stdlib/ndarray/dtypes","@stdlib/ndarray/promotion-rules","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/offset":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/shape","@stdlib/ndarray/strides"],"@stdlib/ndarray/order":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/orders","@stdlib/ndarray/shape","@stdlib/ndarray/strides"],"@stdlib/ndarray/orders":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/promotion-rules":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/safe-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/same-kind-casts"],"@stdlib/ndarray/same-kind-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/shape":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/offset","@stdlib/ndarray/strides"],"@stdlib/ndarray/stride":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/offset","@stdlib/ndarray/order","@stdlib/ndarray/shape","@stdlib/ndarray/strides"],"@stdlib/ndarray/strides":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/offset","@stdlib/ndarray/order","@stdlib/ndarray/shape"],"@stdlib/ndarray/at":["@stdlib/ndarray/array","@stdlib/ndarray/slice"],"@stdlib/ndarray/empty":["@stdlib/ndarray/empty-like","@stdlib/ndarray/zeros"],"@stdlib/ndarray/empty-like":["@stdlib/ndarray/empty","@stdlib/ndarray/zeros-like"],"@stdlib/ndarray/filter":["@stdlib/ndarray/filter-map","@stdlib/ndarray/map","@stdlib/ndarray/reject","@stdlib/ndarray/slice"],"@stdlib/ndarray/filter-map":["@stdlib/ndarray/filter","@stdlib/ndarray/map","@stdlib/ndarray/reject","@stdlib/ndarray/slice"],"@stdlib/ndarray/for-each":["@stdlib/ndarray/map"],"@stdlib/ndarray/ndims":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/numel","@stdlib/ndarray/shape"],"@stdlib/ndarray/index":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/fancy","@stdlib/ndarray/slice","@stdlib/ndarray/to-fancy"],"@stdlib/ndarray/iter/to-array-each":["@stdlib/ndarray/ctor","@stdlib/ndarray/to-array"],"@stdlib/ndarray/iter/column-entries":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/row-entries","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/columns":["@stdlib/ndarray/iter/column-entries","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/entries":["@stdlib/ndarray/ctor","@stdlib/ndarray/iter/indices","@stdlib/ndarray/iter/values"],"@stdlib/ndarray/iter/indices":["@stdlib/ndarray/ctor","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/values"],"@stdlib/ndarray/iter/interleave-subarrays":["@stdlib/ndarray/iter/subarrays","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/matrices":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrix-entries","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/matrix-entries":["@stdlib/ndarray/iter/column-entries","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/row-entries","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/row-entries":["@stdlib/ndarray/iter/column-entries","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/rows":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/row-entries","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/select-dimension":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/stacks":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/rows","@stdlib/ndarray/iter/subarrays","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/subarrays":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/rows","@stdlib/ndarray/iter/stacks","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/values":["@stdlib/ndarray/ctor","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/indices"],"@stdlib/ndarray/map":["@stdlib/ndarray/filter","@stdlib/ndarray/filter-map","@stdlib/ndarray/for-each","@stdlib/ndarray/slice"],"@stdlib/ndarray/reject":["@stdlib/ndarray/filter","@stdlib/ndarray/filter-map","@stdlib/ndarray/map","@stdlib/ndarray/slice"],"@stdlib/ndarray/slice":["@stdlib/ndarray/array","@stdlib/ndarray/at","@stdlib/ndarray/ctor","@stdlib/ndarray/slice-assign","@stdlib/ndarray/slice-dimension"],"@stdlib/ndarray/slice-assign":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice"],"@stdlib/ndarray/slice-dimension":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray/slice-dimension-to"],"@stdlib/ndarray/slice-dimension-from":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension","@stdlib/ndarray/slice-dimension-to","@stdlib/ndarray/slice-from"],"@stdlib/ndarray/slice-dimension-to":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension","@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray/slice-to"],"@stdlib/ndarray/slice-from":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray/slice-to"],"@stdlib/ndarray/slice-to":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension-to","@stdlib/ndarray/slice-from"],"@stdlib/ndarray/zeros":["@stdlib/ndarray/empty","@stdlib/ndarray/zeros-like"],"@stdlib/ndarray/zeros-like":["@stdlib/ndarray/empty-like","@stdlib/ndarray/zeros"],"@stdlib/string/next-grapheme-cluster-break":["@stdlib/string/num-grapheme-clusters","@stdlib/string/prev-grapheme-cluster-break"],"@stdlib/utils/next-tick":[],"@stdlib/datasets/nightingales-rose":[],"@stdlib/constants/float64/ninf":["@stdlib/constants/float16/ninf","@stdlib/constants/float32/ninf","@stdlib/constants/float64/pinf"],"@stdlib/process/node-version":[],"@stdlib/utils/none":["@stdlib/utils/any","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some"],"@stdlib/utils/none-by":["@stdlib/utils/any-by","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/none-by-right","@stdlib/utils/some-by"],"@stdlib/utils/async/none-by":["@stdlib/utils/async/any-by","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/none-by","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by"],"@stdlib/utils/none-by-right":["@stdlib/utils/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none","@stdlib/utils/none-by","@stdlib/utils/some-by-right"],"@stdlib/utils/async/none-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by","@stdlib/utils/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/none-in-by":["@stdlib/utils/any-in-by","@stdlib/utils/every-in-by","@stdlib/utils/for-in","@stdlib/utils/none-by","@stdlib/utils/some-in-by"],"@stdlib/utils/nonenumerable-properties":["@stdlib/utils/enumerable-properties","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/nonenumerable-properties-in":["@stdlib/utils/enumerable-properties-in","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/nonenumerable-properties","@stdlib/utils/properties-in"],"@stdlib/utils/nonenumerable-property-names":["@stdlib/utils/keys","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/nonenumerable-property-names-in":["@stdlib/utils/keys-in","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/property-names-in"],"@stdlib/utils/nonenumerable-property-symbols":["@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/nonenumerable-property-symbols-in":["@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/utils/none-own-by":["@stdlib/utils/any-own-by","@stdlib/utils/every-own-by","@stdlib/utils/for-own","@stdlib/utils/none-by","@stdlib/utils/some-own-by"],"@stdlib/utils/nonindex-keys":["@stdlib/utils/entries","@stdlib/utils/keys","@stdlib/utils/values"],"@stdlib/utils/noop":[],"@stdlib/time/now":[],"@stdlib/os/num-cpus":[],"@stdlib/string/num2words":[],"@stdlib/number/ctor":[],"@stdlib/ndarray/numel":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/numel-dimension"],"@stdlib/ndarray/numel-dimension":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/numel"],"@stdlib/string/num-grapheme-clusters":["@stdlib/string/next-grapheme-cluster-break"],"@stdlib/object/ctor":[],"@stdlib/utils/entries":["@stdlib/utils/entries-in","@stdlib/utils/from-entries","@stdlib/utils/keys","@stdlib/utils/values"],"@stdlib/utils/entries-in":["@stdlib/utils/entries","@stdlib/utils/from-entries","@stdlib/utils/keys-in","@stdlib/utils/values-in"],"@stdlib/utils/from-entries":["@stdlib/utils/entries"],"@stdlib/utils/object-inverse":["@stdlib/utils/object-inverse-by"],"@stdlib/utils/object-inverse-by":["@stdlib/utils/object-inverse"],"@stdlib/utils/keys":["@stdlib/utils/entries","@stdlib/utils/keys-in","@stdlib/utils/nonindex-keys","@stdlib/utils/values"],"@stdlib/utils/values":["@stdlib/utils/entries","@stdlib/utils/keys"],"@stdlib/utils/values-in":["@stdlib/utils/entries-in","@stdlib/utils/keys-in","@stdlib/utils/values"],"@stdlib/utils/omit":["@stdlib/utils/omit-by"],"@stdlib/utils/omit-by":["@stdlib/utils/omit"],"@stdlib/fs/open":["@stdlib/fs/close","@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/utils/open-url":[],"@stdlib/nlp/ordinalize":[],"@stdlib/datasets/pace-boston-house-prices":["@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices-corrected"],"@stdlib/string/pad":["@stdlib/string/left-pad","@stdlib/string/right-pad"],"@stdlib/stats/padjust":[],"@stdlib/utils/papply":["@stdlib/utils/papply-right"],"@stdlib/utils/papply-right":["@stdlib/utils/papply"],"@stdlib/utils/parallel":[],"@stdlib/utils/parse-json":[],"@stdlib/string/pascalcase":["@stdlib/string/camelcase","@stdlib/string/constantcase","@stdlib/string/kebabcase","@stdlib/string/snakecase"],"@stdlib/constants/path/delimiter":["@stdlib/constants/path/delimiter-posix","@stdlib/constants/path/delimiter-win32"],"@stdlib/constants/path/delimiter-posix":["@stdlib/constants/path/delimiter","@stdlib/constants/path/delimiter-win32"],"@stdlib/constants/path/delimiter-win32":["@stdlib/constants/path/delimiter","@stdlib/constants/path/delimiter-posix"],"@stdlib/constants/path/sep":["@stdlib/constants/path/sep-posix","@stdlib/constants/path/sep-win32"],"@stdlib/constants/path/sep-posix":["@stdlib/constants/path/sep","@stdlib/constants/path/sep-win32"],"@stdlib/constants/path/sep-win32":["@stdlib/constants/path/sep","@stdlib/constants/path/sep-posix"],"@stdlib/stats/pcorrtest":[],"@stdlib/string/percent-encode":[],"@stdlib/constants/float64/phi":[],"@stdlib/constants/float64/pi":["@stdlib/constants/float64/two-pi"],"@stdlib/constants/float64/pi-squared":["@stdlib/constants/float64/pi"],"@stdlib/utils/pick":["@stdlib/utils/pick-by"],"@stdlib/utils/pick-arguments":["@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/utils/pick-by":["@stdlib/utils/pick"],"@stdlib/constants/float64/pinf":["@stdlib/constants/float64/ninf"],"@stdlib/namespace/pkg2alias":["@stdlib/namespace/alias2pkg","@stdlib/namespace/aliases","@stdlib/namespace/pkg2related"],"@stdlib/namespace/pkg2related":["@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias"],"@stdlib/namespace/pkg2standalone":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2standalone","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias","@stdlib/namespace/pkg2related"],"@stdlib/os/platform":["@stdlib/os/arch"],"@stdlib/plot":["@stdlib/plot/ctor"],"@stdlib/plot/ctor":["@stdlib/plot"],"@stdlib/utils/pluck":["@stdlib/utils/deep-pluck","@stdlib/utils/pick"],"@stdlib/utils/pop":["@stdlib/utils/push","@stdlib/utils/shift","@stdlib/utils/unshift"],"@stdlib/nlp/porter-stemmer":[],"@stdlib/utils/prepend":["@stdlib/utils/append","@stdlib/utils/unshift"],"@stdlib/string/prev-grapheme-cluster-break":["@stdlib/string/num-grapheme-clusters","@stdlib/string/next-grapheme-cluster-break"],"@stdlib/datasets/primes-100k":["@stdlib/math/iter/sequences/primes"],"@stdlib/utils/properties":["@stdlib/utils/define-properties","@stdlib/utils/inherited-properties","@stdlib/utils/properties-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols"],"@stdlib/utils/properties-in":["@stdlib/utils/define-properties","@stdlib/utils/inherited-properties","@stdlib/utils/properties","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-descriptor":["@stdlib/assert/has-own-property","@stdlib/utils/define-property","@stdlib/utils/property-descriptor-in","@stdlib/utils/property-descriptors"],"@stdlib/utils/property-descriptor-in":["@stdlib/assert/has-property","@stdlib/utils/define-property","@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptors-in"],"@stdlib/utils/property-descriptors":["@stdlib/utils/define-property","@stdlib/utils/define-properties","@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptors-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols"],"@stdlib/utils/property-descriptors-in":["@stdlib/utils/define-properties","@stdlib/utils/property-descriptor-in","@stdlib/utils/property-descriptors","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-names":["@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols"],"@stdlib/utils/property-names-in":["@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-symbols":["@stdlib/utils/property-names","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-symbols-in":["@stdlib/utils/property-names-in","@stdlib/utils/property-symbols"],"@stdlib/proxy/ctor":[],"@stdlib/utils/push":["@stdlib/utils/pop","@stdlib/utils/shift","@stdlib/utils/unshift"],"@stdlib/time/quarter-of-year":["@stdlib/time/day-of-year"],"@stdlib/random/array/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/strided/arcsine"],"@stdlib/random/array/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/strided/bernoulli"],"@stdlib/random/array/beta":["@stdlib/random/base/beta","@stdlib/random/strided/beta"],"@stdlib/random/array/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/strided/betaprime"],"@stdlib/random/array/binomial":["@stdlib/random/array/negative-binomial","@stdlib/random/base/binomial"],"@stdlib/random/array/cauchy":["@stdlib/random/base/cauchy"],"@stdlib/random/array/chi":["@stdlib/random/base/chi","@stdlib/random/strided/chi"],"@stdlib/random/array/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/strided/chisquare"],"@stdlib/random/array/cosine":["@stdlib/random/base/cosine","@stdlib/random/strided/cosine"],"@stdlib/random/array/discrete-uniform":["@stdlib/random/array/uniform","@stdlib/random/base/discrete-uniform","@stdlib/random/strided/discrete-uniform"],"@stdlib/random/array/erlang":["@stdlib/random/base/erlang"],"@stdlib/random/array/exponential":["@stdlib/random/base/exponential","@stdlib/random/strided/exponential"],"@stdlib/random/array/f":["@stdlib/random/base/f"],"@stdlib/random/array/frechet":["@stdlib/random/base/frechet"],"@stdlib/random/array/gamma":["@stdlib/random/base/gamma","@stdlib/random/strided/gamma"],"@stdlib/random/array/geometric":["@stdlib/random/base/geometric","@stdlib/random/strided/geometric"],"@stdlib/random/array/gumbel":["@stdlib/random/base/gumbel"],"@stdlib/random/array/hypergeometric":["@stdlib/random/base/hypergeometric"],"@stdlib/random/array/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/strided/invgamma"],"@stdlib/random/array/kumaraswamy":["@stdlib/random/base/kumaraswamy"],"@stdlib/random/array/laplace":["@stdlib/random/base/laplace"],"@stdlib/random/array/levy":["@stdlib/random/base/levy"],"@stdlib/random/array/logistic":["@stdlib/random/base/logistic"],"@stdlib/random/array/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/strided/lognormal"],"@stdlib/random/array/minstd":["@stdlib/random/array/minstd-shuffle","@stdlib/random/array/randu","@stdlib/random/base/minstd","@stdlib/random/strided/minstd"],"@stdlib/random/array/minstd-shuffle":["@stdlib/random/array/minstd","@stdlib/random/array/randu","@stdlib/random/base/minstd-shuffle","@stdlib/random/strided/minstd-shuffle"],"@stdlib/random/array/mt19937":["@stdlib/random/array/randu","@stdlib/random/base/mt19937","@stdlib/random/strided/mt19937"],"@stdlib/random/array/negative-binomial":["@stdlib/random/array/binomial","@stdlib/random/base/negative-binomial"],"@stdlib/random/array/normal":["@stdlib/random/base/normal","@stdlib/random/strided/normal"],"@stdlib/random/array/pareto-type1":["@stdlib/random/base/pareto-type1"],"@stdlib/random/array/poisson":["@stdlib/random/base/poisson","@stdlib/random/strided/poisson"],"@stdlib/random/array/randu":["@stdlib/random/array/uniform","@stdlib/random/base/randu","@stdlib/random/strided/randu"],"@stdlib/random/array/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/strided/rayleigh"],"@stdlib/random/array/t":["@stdlib/random/base/t","@stdlib/random/strided/t"],"@stdlib/random/array/triangular":["@stdlib/random/base/triangular"],"@stdlib/random/array/uniform":["@stdlib/random/array/discrete-uniform","@stdlib/random/base/uniform","@stdlib/random/strided/uniform"],"@stdlib/random/array/weibull":["@stdlib/random/base/weibull","@stdlib/random/strided/weibull"],"@stdlib/random/iter/arcsine":["@stdlib/random/base/arcsine"],"@stdlib/random/iter/bernoulli":["@stdlib/random/base/bernoulli"],"@stdlib/random/iter/beta":["@stdlib/random/base/beta"],"@stdlib/random/iter/betaprime":["@stdlib/random/base/betaprime"],"@stdlib/random/iter/binomial":["@stdlib/random/base/binomial"],"@stdlib/random/iter/box-muller":["@stdlib/random/base/box-muller"],"@stdlib/random/iter/cauchy":["@stdlib/random/base/cauchy"],"@stdlib/random/iter/chi":["@stdlib/random/base/chi"],"@stdlib/random/iter/chisquare":["@stdlib/random/base/chisquare"],"@stdlib/random/iter/cosine":["@stdlib/random/base/cosine"],"@stdlib/random/iter/discrete-uniform":["@stdlib/random/base/discrete-uniform"],"@stdlib/random/iter/erlang":["@stdlib/random/base/erlang"],"@stdlib/random/iter/exponential":["@stdlib/random/base/exponential"],"@stdlib/random/iter/f":["@stdlib/random/base/f"],"@stdlib/random/iter/frechet":["@stdlib/random/base/frechet"],"@stdlib/random/iter/gamma":["@stdlib/random/base/gamma"],"@stdlib/random/iter/geometric":["@stdlib/random/base/geometric"],"@stdlib/random/iter/gumbel":["@stdlib/random/base/gumbel"],"@stdlib/random/iter/hypergeometric":["@stdlib/random/base/hypergeometric"],"@stdlib/random/iter/improved-ziggurat":["@stdlib/random/base/improved-ziggurat"],"@stdlib/random/iter/invgamma":["@stdlib/random/base/invgamma"],"@stdlib/random/iter/kumaraswamy":["@stdlib/random/base/kumaraswamy"],"@stdlib/random/iter/laplace":["@stdlib/random/base/laplace"],"@stdlib/random/iter/levy":["@stdlib/random/base/levy"],"@stdlib/random/iter/logistic":["@stdlib/random/base/logistic"],"@stdlib/random/iter/lognormal":["@stdlib/random/base/lognormal"],"@stdlib/random/iter/minstd":["@stdlib/random/base/minstd","@stdlib/random/iter/minstd-shuffle","@stdlib/random/iter/mt19937","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/iter/minstd","@stdlib/random/iter/mt19937","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/iter/minstd","@stdlib/random/iter/minstd-shuffle","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/negative-binomial":["@stdlib/random/base/negative-binomial"],"@stdlib/random/iter/normal":["@stdlib/random/base/normal"],"@stdlib/random/iter/pareto-type1":["@stdlib/random/base/pareto-type1"],"@stdlib/random/iter/poisson":["@stdlib/random/base/poisson"],"@stdlib/random/iter/randi":["@stdlib/random/base/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/randn":["@stdlib/random/base/randn"],"@stdlib/random/iter/randu":["@stdlib/random/base/randu","@stdlib/random/iter/randi"],"@stdlib/random/iter/rayleigh":["@stdlib/random/base/rayleigh"],"@stdlib/random/iter/t":["@stdlib/random/base/t"],"@stdlib/random/iter/triangular":["@stdlib/random/base/triangular"],"@stdlib/random/iter/uniform":["@stdlib/random/base/uniform"],"@stdlib/random/iter/weibull":["@stdlib/random/base/weibull"],"@stdlib/random/streams/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/iter/arcsine"],"@stdlib/random/streams/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/iter/bernoulli"],"@stdlib/random/streams/beta":["@stdlib/random/base/beta","@stdlib/random/iter/beta"],"@stdlib/random/streams/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/iter/betaprime"],"@stdlib/random/streams/binomial":["@stdlib/random/base/binomial","@stdlib/random/iter/binomial"],"@stdlib/random/streams/box-muller":["@stdlib/random/base/box-muller","@stdlib/random/iter/box-muller","@stdlib/random/streams/improved-ziggurat","@stdlib/random/streams/randn"],"@stdlib/random/streams/cauchy":["@stdlib/random/base/cauchy","@stdlib/random/iter/cauchy"],"@stdlib/random/streams/chi":["@stdlib/random/base/chi","@stdlib/random/iter/chi"],"@stdlib/random/streams/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/iter/chisquare"],"@stdlib/random/streams/cosine":["@stdlib/random/base/cosine","@stdlib/random/iter/cosine"],"@stdlib/random/streams/discrete-uniform":["@stdlib/random/base/discrete-uniform","@stdlib/random/iter/discrete-uniform"],"@stdlib/random/streams/erlang":["@stdlib/random/base/erlang","@stdlib/random/iter/erlang"],"@stdlib/random/streams/exponential":["@stdlib/random/base/exponential","@stdlib/random/iter/exponential"],"@stdlib/random/streams/f":["@stdlib/random/base/f","@stdlib/random/iter/f"],"@stdlib/random/streams/frechet":["@stdlib/random/base/frechet","@stdlib/random/iter/frechet"],"@stdlib/random/streams/gamma":["@stdlib/random/base/gamma","@stdlib/random/iter/gamma"],"@stdlib/random/streams/geometric":["@stdlib/random/base/geometric","@stdlib/random/iter/geometric"],"@stdlib/random/streams/gumbel":["@stdlib/random/base/gumbel","@stdlib/random/iter/gumbel"],"@stdlib/random/streams/hypergeometric":["@stdlib/random/base/hypergeometric","@stdlib/random/iter/hypergeometric"],"@stdlib/random/streams/improved-ziggurat":["@stdlib/random/base/improved-ziggurat","@stdlib/random/iter/improved-ziggurat","@stdlib/random/streams/box-muller","@stdlib/random/streams/randn"],"@stdlib/random/streams/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/iter/invgamma"],"@stdlib/random/streams/kumaraswamy":["@stdlib/random/base/kumaraswamy","@stdlib/random/iter/kumaraswamy"],"@stdlib/random/streams/laplace":["@stdlib/random/base/laplace","@stdlib/random/iter/laplace"],"@stdlib/random/streams/levy":["@stdlib/random/base/levy","@stdlib/random/iter/levy"],"@stdlib/random/streams/logistic":["@stdlib/random/base/logistic","@stdlib/random/iter/logistic"],"@stdlib/random/streams/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/iter/lognormal"],"@stdlib/random/streams/minstd":["@stdlib/random/base/minstd","@stdlib/random/iter/minstd","@stdlib/random/streams/minstd-shuffle","@stdlib/random/streams/mt19937","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/iter/minstd-shuffle","@stdlib/random/streams/minstd","@stdlib/random/streams/mt19937","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/iter/mt19937","@stdlib/random/streams/minstd","@stdlib/random/streams/minstd-shuffle","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/negative-binomial":["@stdlib/random/base/negative-binomial","@stdlib/random/iter/negative-binomial"],"@stdlib/random/streams/normal":["@stdlib/random/base/normal","@stdlib/random/iter/normal"],"@stdlib/random/streams/pareto-type1":["@stdlib/random/base/pareto-type1","@stdlib/random/iter/pareto-type1"],"@stdlib/random/streams/poisson":["@stdlib/random/base/poisson","@stdlib/random/iter/poisson"],"@stdlib/random/streams/randi":["@stdlib/random/base/randi","@stdlib/random/iter/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/randn":["@stdlib/random/base/randn","@stdlib/random/iter/randn","@stdlib/random/streams/box-muller","@stdlib/random/streams/improved-ziggurat"],"@stdlib/random/streams/randu":["@stdlib/random/base/randu","@stdlib/random/iter/randu","@stdlib/random/streams/randi"],"@stdlib/random/streams/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/iter/rayleigh"],"@stdlib/random/streams/t":["@stdlib/random/base/t","@stdlib/random/iter/t"],"@stdlib/random/streams/triangular":["@stdlib/random/base/triangular","@stdlib/random/iter/triangular"],"@stdlib/random/streams/uniform":["@stdlib/random/base/uniform","@stdlib/random/iter/uniform"],"@stdlib/random/streams/weibull":["@stdlib/random/base/weibull","@stdlib/random/iter/weibull"],"@stdlib/random/strided/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/array/arcsine"],"@stdlib/random/strided/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/array/bernoulli"],"@stdlib/random/strided/beta":["@stdlib/random/base/beta","@stdlib/random/array/beta"],"@stdlib/random/strided/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/array/betaprime"],"@stdlib/random/strided/chi":["@stdlib/random/base/chi","@stdlib/random/array/chi"],"@stdlib/random/strided/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/array/chisquare"],"@stdlib/random/strided/cosine":["@stdlib/random/base/cosine","@stdlib/random/array/cosine"],"@stdlib/random/strided/discrete-uniform":["@stdlib/random/base/discrete-uniform","@stdlib/random/array/discrete-uniform","@stdlib/random/strided/uniform"],"@stdlib/random/strided/exponential":["@stdlib/random/base/exponential","@stdlib/random/array/exponential"],"@stdlib/random/strided/gamma":["@stdlib/random/base/gamma","@stdlib/random/array/gamma"],"@stdlib/random/strided/geometric":["@stdlib/random/base/geometric","@stdlib/random/array/geometric"],"@stdlib/random/strided/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/array/invgamma"],"@stdlib/random/strided/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/array/lognormal"],"@stdlib/random/strided/minstd":["@stdlib/random/base/minstd","@stdlib/random/array/minstd","@stdlib/random/strided/minstd-shuffle","@stdlib/random/strided/randu"],"@stdlib/random/strided/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/array/minstd-shuffle","@stdlib/random/strided/minstd","@stdlib/random/strided/randu"],"@stdlib/random/strided/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/array/mt19937","@stdlib/random/strided/randu"],"@stdlib/random/strided/normal":["@stdlib/random/base/normal","@stdlib/random/array/normal"],"@stdlib/random/strided/poisson":["@stdlib/random/base/poisson","@stdlib/random/array/poisson"],"@stdlib/random/strided/randu":["@stdlib/random/base/randu","@stdlib/random/array/randu","@stdlib/random/strided/uniform"],"@stdlib/random/strided/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/array/rayleigh"],"@stdlib/random/strided/t":["@stdlib/random/base/t","@stdlib/random/array/t"],"@stdlib/random/strided/uniform":["@stdlib/random/base/uniform","@stdlib/random/array/uniform","@stdlib/random/strided/discrete-uniform"],"@stdlib/random/strided/weibull":["@stdlib/random/base/weibull","@stdlib/random/array/weibull"],"@stdlib/stats/ranks":[],"@stdlib/fs/read-dir":["@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/fs/read-file":["@stdlib/fs/exists","@stdlib/fs/open","@stdlib/fs/read-dir","@stdlib/fs/read-json","@stdlib/fs/write-file"],"@stdlib/fs/read-file-list":[],"@stdlib/fs/read-json":["@stdlib/fs/read-file"],"@stdlib/fs/read-wasm":["@stdlib/fs/read-file"],"@stdlib/complex/float64/real":["@stdlib/complex/float64/imag","@stdlib/complex/float64/reim"],"@stdlib/array/typed-real":["@stdlib/array/float64","@stdlib/array/float32","@stdlib/array/int32","@stdlib/array/uint32","@stdlib/array/int16","@stdlib/array/uint16","@stdlib/array/int8","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/typed-real-ctors":["@stdlib/array/ctors","@stdlib/array/typed-complex-ctors"],"@stdlib/array/typed-real-dtypes":["@stdlib/array/dtypes","@stdlib/array/typed-complex-dtypes"],"@stdlib/complex/float32/real":["@stdlib/complex/float32/imag","@stdlib/complex/float64/real","@stdlib/complex/float32/reim"],"@stdlib/utils/real-max":["@stdlib/utils/real-min","@stdlib/utils/type-max"],"@stdlib/utils/real-min":["@stdlib/utils/real-max","@stdlib/utils/type-min"],"@stdlib/regexp/basename":["@stdlib/regexp/basename-posix","@stdlib/regexp/basename-windows"],"@stdlib/regexp/basename-posix":["@stdlib/regexp/basename","@stdlib/regexp/basename-windows"],"@stdlib/regexp/basename-windows":["@stdlib/regexp/basename","@stdlib/regexp/basename-posix"],"@stdlib/regexp/color-hexadecimal":[],"@stdlib/regexp/decimal-number":[],"@stdlib/regexp/dirname":["@stdlib/regexp/dirname-posix","@stdlib/regexp/dirname-windows","@stdlib/utils/dirname"],"@stdlib/regexp/dirname-posix":["@stdlib/regexp/dirname","@stdlib/regexp/dirname-windows","@stdlib/utils/dirname"],"@stdlib/regexp/dirname-windows":["@stdlib/regexp/dirname","@stdlib/regexp/dirname-posix","@stdlib/utils/dirname"],"@stdlib/utils/reduce":["@stdlib/utils/for-each","@stdlib/utils/map","@stdlib/utils/async/reduce","@stdlib/utils/reduce-right"],"@stdlib/utils/reduce2d":["@stdlib/utils/map2d","@stdlib/utils/reduce"],"@stdlib/utils/async/reduce":["@stdlib/utils/async/for-each","@stdlib/utils/reduce","@stdlib/utils/async/reduce-right"],"@stdlib/utils/reduce-right":["@stdlib/utils/for-each-right","@stdlib/utils/map-right","@stdlib/utils/reduce","@stdlib/utils/async/reduce-right"],"@stdlib/utils/async/reduce-right":["@stdlib/utils/async/for-each-right","@stdlib/utils/async/reduce","@stdlib/utils/reduce-right"],"@stdlib/regexp/duration-string":[],"@stdlib/regexp/eol":[],"@stdlib/regexp/extended-length-path":[],"@stdlib/regexp/extname":["@stdlib/regexp/extname-posix","@stdlib/regexp/extname-windows","@stdlib/utils/extname"],"@stdlib/regexp/extname-posix":["@stdlib/regexp/extname","@stdlib/regexp/extname-windows","@stdlib/utils/extname"],"@stdlib/regexp/extname-windows":["@stdlib/regexp/extname","@stdlib/regexp/extname-posix","@stdlib/utils/extname"],"@stdlib/regexp/filename":["@stdlib/regexp/filename-posix","@stdlib/regexp/filename-windows"],"@stdlib/regexp/filename-posix":["@stdlib/regexp/filename","@stdlib/regexp/filename-windows"],"@stdlib/regexp/filename-windows":["@stdlib/regexp/filename","@stdlib/regexp/filename-posix"],"@stdlib/utils/regexp-from-string":[],"@stdlib/regexp/function-name":["@stdlib/utils/function-name"],"@stdlib/regexp/to-json":["@stdlib/regexp/reviver"],"@stdlib/complex/float64/reim":["@stdlib/complex/float64/imag","@stdlib/complex/float64/real"],"@stdlib/complex/float32/reim":["@stdlib/complex/float32/imag","@stdlib/complex/float32/real","@stdlib/complex/float64/reim"],"@stdlib/utils/reject-arguments":["@stdlib/utils/filter-arguments","@stdlib/utils/mask-arguments"],"@stdlib/string/remove-first":["@stdlib/string/remove-last"],"@stdlib/string/remove-last":["@stdlib/string/remove-first"],"@stdlib/string/remove-punctuation":[],"@stdlib/string/remove-utf8-bom":[],"@stdlib/string/remove-words":[],"@stdlib/fs/rename":["@stdlib/fs/exists","@stdlib/fs/read-file","@stdlib/fs/write-file","@stdlib/fs/unlink"],"@stdlib/regexp/native-function":["@stdlib/regexp/function-name","@stdlib/utils/function-name"],"@stdlib/utils/reorder-arguments":["@stdlib/utils/mask-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/string/repeat":["@stdlib/string/pad"],"@stdlib/string/replace":[],"@stdlib/string/replace-before":[],"@stdlib/regexp/regexp":["@stdlib/utils/regexp-from-string"],"@stdlib/utils/escape-regexp-string":[],"@stdlib/regexp/semver":["@stdlib/assert/is-semver"],"@stdlib/fs/resolve-parent-path":["@stdlib/fs/resolve-parent-path-by"],"@stdlib/fs/resolve-parent-path-by":["@stdlib/fs/resolve-parent-path"],"@stdlib/regexp/unc-path":["@stdlib/assert/is-unc-path"],"@stdlib/regexp/utf16-surrogate-pair":["@stdlib/regexp/utf16-unpaired-surrogate"],"@stdlib/regexp/utf16-unpaired-surrogate":["@stdlib/regexp/utf16-surrogate-pair"],"@stdlib/utils/reverse-arguments":["@stdlib/utils/mask-arguments","@stdlib/utils/reorder-arguments"],"@stdlib/string/reverse":[],"@stdlib/random/base/reviver":[],"@stdlib/buffer/reviver":["@stdlib/buffer/to-json"],"@stdlib/complex/reviver":["@stdlib/complex/float64/ctor","@stdlib/complex/float32/ctor","@stdlib/complex/float64/reviver","@stdlib/complex/float32/reviver"],"@stdlib/complex/float32/reviver":["@stdlib/complex/float32/ctor","@stdlib/complex/float64/reviver","@stdlib/complex/reviver"],"@stdlib/complex/float64/reviver":["@stdlib/complex/float64/ctor","@stdlib/complex/float32/reviver","@stdlib/complex/reviver"],"@stdlib/error/reviver":["@stdlib/error/to-json"],"@stdlib/regexp/reviver":["@stdlib/regexp/to-json"],"@stdlib/array/reviver":["@stdlib/array/to-json"],"@stdlib/regexp/whitespace":["@stdlib/assert/is-whitespace"],"@stdlib/string/right-pad":["@stdlib/string/left-pad","@stdlib/string/pad"],"@stdlib/string/right-trim":["@stdlib/string/left-trim","@stdlib/string/trim"],"@stdlib/string/right-trim-n":["@stdlib/string/left-trim-n","@stdlib/string/trim"],"@stdlib/utils/safe-int-max":["@stdlib/utils/safe-int-min","@stdlib/utils/real-max","@stdlib/utils/type-max"],"@stdlib/utils/safe-int-min":["@stdlib/utils/safe-int-max","@stdlib/utils/real-min","@stdlib/utils/type-min"],"@stdlib/random/sample":[],"@stdlib/datasets/savoy-stopwords-fin":[],"@stdlib/datasets/savoy-stopwords-fr":[],"@stdlib/datasets/savoy-stopwords-ger":[],"@stdlib/datasets/savoy-stopwords-it":[],"@stdlib/datasets/savoy-stopwords-por":[],"@stdlib/datasets/savoy-stopwords-sp":[],"@stdlib/datasets/savoy-stopwords-swe":[],"@stdlib/array/from-scalar":["@stdlib/array/from-iterator"],"@stdlib/ndarray/from-scalar":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/blas/sdot":["@stdlib/blas/base/sdot","@stdlib/blas/ddot","@stdlib/blas/gdot"],"@stdlib/constants/time/seconds-in-day":[],"@stdlib/constants/time/seconds-in-hour":[],"@stdlib/constants/time/seconds-in-minute":[],"@stdlib/constants/time/seconds-in-week":[],"@stdlib/time/seconds-in-month":["@stdlib/time/seconds-in-year"],"@stdlib/time/seconds-in-year":["@stdlib/time/seconds-in-month"],"@stdlib/nlp/sentencize":["@stdlib/nlp/tokenize"],"@stdlib/slice/seq2slice":["@stdlib/slice/ctor"],"@stdlib/utils/define-configurable-read-only-property":["@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-configurable-read-only-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-only-accessor"],"@stdlib/utils/define-configurable-read-write-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-write-accessor"],"@stdlib/utils/define-configurable-write-only-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-property","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-memoized-configurable-read-only-property":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-memoized-read-only-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-memoized-read-only-property":["@stdlib/utils/define-memoized-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-property":["@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-read-only-property":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-read-only-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-accessor"],"@stdlib/utils/define-nonenumerable-read-write-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-write-accessor"],"@stdlib/utils/define-nonenumerable-write-only-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-only-property":["@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-only-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-write-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-write-only-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-write-accessor"],"@stdlib/array/shared-buffer":["@stdlib/buffer/ctor","@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/utils/shift":["@stdlib/utils/pop","@stdlib/utils/push","@stdlib/utils/unshift"],"@stdlib/random/shuffle":["@stdlib/random/sample"],"@stdlib/utils/size-of":["@stdlib/utils/real-max","@stdlib/utils/type-max"],"@stdlib/slice/ctor":["@stdlib/ndarray/ctor","@stdlib/slice/multi"],"@stdlib/string/snakecase":["@stdlib/string/camelcase","@stdlib/string/constantcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase"],"@stdlib/utils/some":["@stdlib/utils/any","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some-by"],"@stdlib/utils/some-by":["@stdlib/utils/any-by","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/async/some-by","@stdlib/utils/some-by-right"],"@stdlib/utils/async/some-by":["@stdlib/utils/async/any-by","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/some-by","@stdlib/utils/async/some-by-right"],"@stdlib/utils/some-by-right":["@stdlib/utils/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by","@stdlib/utils/async/some-by-right"],"@stdlib/utils/async/some-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by","@stdlib/utils/some-by-right"],"@stdlib/utils/some-in-by":["@stdlib/utils/any-in-by","@stdlib/utils/every-in-by","@stdlib/utils/some-by","@stdlib/utils/some-own-by"],"@stdlib/utils/some-own-by":["@stdlib/utils/any-own-by","@stdlib/utils/every-own-by","@stdlib/utils/some-by","@stdlib/utils/some-in-by"],"@stdlib/datasets/sotu":[],"@stdlib/datasets/spache-revised":[],"@stdlib/datasets/spam-assassin":[],"@stdlib/plot/sparklines/base/ctor":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/array/to-sparse-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator","@stdlib/array/to-sparse-iterator-right"],"@stdlib/array/to-sparse-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-sparse-iterator"],"@stdlib/streams/node/split":["@stdlib/streams/node/join"],"@stdlib/constants/float64/sqrt-eps":["@stdlib/constants/float64/eps"],"@stdlib/constants/float64/sqrt-half":["@stdlib/constants/float64/ln-half"],"@stdlib/constants/float64/sqrt-half-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/sqrt-phi":["@stdlib/constants/float64/phi"],"@stdlib/constants/float64/sqrt-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/sqrt-three":[],"@stdlib/constants/float64/sqrt-two":["@stdlib/constants/float64/ln-two"],"@stdlib/constants/float64/sqrt-two-pi":["@stdlib/constants/float64/two-pi"],"@stdlib/datasets/ssa-us-births-2000-2014":["@stdlib/datasets/cdc-nchs-us-births-1969-1988","@stdlib/datasets/cdc-nchs-us-births-1994-2003"],"@stdlib/blas/sswap":["@stdlib/blas/base/sswap","@stdlib/blas/dswap","@stdlib/blas/gswap"],"@stdlib/dstructs/stack":["@stdlib/dstructs/fifo"],"@stdlib/namespace/standalone2pkg":["@stdlib/namespace/alias2standalone","@stdlib/namespace/pkg2alias","@stdlib/namespace/pkg2standalone"],"@stdlib/datasets/standard-card-deck":[],"@stdlib/string/startcase":["@stdlib/string/lowercase","@stdlib/string/uppercase"],"@stdlib/string/starts-with":["@stdlib/string/ends-with"],"@stdlib/datasets/stopwords-en":[],"@stdlib/math/strided/special/abs":["@stdlib/math/strided/special/abs2","@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/sabs"],"@stdlib/math/strided/special/abs2":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/sabs2"],"@stdlib/math/strided/special/abs2-by":["@stdlib/math/strided/special/abs-by","@stdlib/math/strided/special/abs2"],"@stdlib/math/strided/special/abs-by":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/abs2-by"],"@stdlib/math/strided/special/acos-by":[],"@stdlib/math/strided/special/acosh-by":[],"@stdlib/math/strided/special/acot-by":[],"@stdlib/math/strided/special/acoth-by":[],"@stdlib/math/strided/special/acovercos-by":[],"@stdlib/math/strided/special/acoversin-by":[],"@stdlib/math/strided/ops/add":["@stdlib/math/strided/ops/mul","@stdlib/math/strided/ops/sub"],"@stdlib/math/strided/ops/add-by":["@stdlib/math/strided/ops/add","@stdlib/math/strided/ops/mul-by","@stdlib/math/strided/ops/sub-by"],"@stdlib/math/strided/special/ahavercos-by":["@stdlib/math/strided/special/ahaversin-by"],"@stdlib/math/strided/special/ahaversin-by":["@stdlib/math/strided/special/ahavercos-by"],"@stdlib/math/strided/special/asin-by":["@stdlib/math/strided/special/asinh-by"],"@stdlib/math/strided/special/asinh-by":["@stdlib/math/strided/special/asin-by"],"@stdlib/math/strided/special/atan-by":["@stdlib/math/strided/special/atanh-by"],"@stdlib/math/strided/special/atanh-by":["@stdlib/math/strided/special/atan-by"],"@stdlib/math/strided/special/avercos-by":[],"@stdlib/math/strided/special/aversin-by":[],"@stdlib/math/strided/special/besselj0-by":["@stdlib/math/strided/special/besselj1-by","@stdlib/math/strided/special/bessely0-by","@stdlib/math/strided/special/bessely1-by"],"@stdlib/math/strided/special/besselj1-by":["@stdlib/math/strided/special/besselj0-by","@stdlib/math/strided/special/bessely0-by","@stdlib/math/strided/special/bessely1-by"],"@stdlib/math/strided/special/bessely0-by":["@stdlib/math/strided/special/besselj0-by","@stdlib/math/strided/special/besselj1-by","@stdlib/math/strided/special/bessely1-by"],"@stdlib/math/strided/special/bessely1-by":["@stdlib/math/strided/special/besselj0-by","@stdlib/math/strided/special/besselj1-by","@stdlib/math/strided/special/bessely0-by"],"@stdlib/math/strided/special/binet-by":[],"@stdlib/math/strided/special/cbrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/scbrt","@stdlib/math/strided/special/sqrt"],"@stdlib/math/strided/special/cbrt-by":["@stdlib/math/strided/special/cbrt"],"@stdlib/math/strided/special/ceil":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/trunc","@stdlib/math/strided/special/sceil"],"@stdlib/math/strided/special/cos-by":[],"@stdlib/math/strided/special/deg2rad":["@stdlib/math/strided/special/ddeg2rad","@stdlib/math/strided/special/sdeg2rad"],"@stdlib/strided/dtypes":[],"@stdlib/math/strided/special/dcbrt-by":["@stdlib/math/strided/special/cbrt"],"@stdlib/strided/dispatch":[],"@stdlib/strided/dispatch-by":["@stdlib/strided/dispatch"],"@stdlib/math/strided/special/floor":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/trunc","@stdlib/math/strided/special/sfloor"],"@stdlib/math/strided/special/inv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/sinv"],"@stdlib/math/strided/ops/mul":["@stdlib/math/strided/ops/add","@stdlib/math/strided/ops/sub"],"@stdlib/math/strided/ops/mul-by":["@stdlib/math/strided/ops/mul","@stdlib/math/strided/ops/add-by","@stdlib/math/strided/ops/sub-by"],"@stdlib/math/strided/special/ramp":["@stdlib/math/strided/special/dramp","@stdlib/math/strided/special/sramp"],"@stdlib/math/strided/special/rsqrt":["@stdlib/math/strided/special/drsqrt","@stdlib/math/strided/special/sqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/math/strided/special/sin-by":[],"@stdlib/math/strided/special/sqrt":["@stdlib/math/strided/special/cbrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/rsqrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/math/strided/special/sqrt-by":["@stdlib/math/strided/special/sqrt"],"@stdlib/math/strided/ops/sub":["@stdlib/math/strided/ops/add","@stdlib/math/strided/ops/mul"],"@stdlib/math/strided/ops/sub-by":["@stdlib/math/strided/ops/sub","@stdlib/math/strided/ops/add-by","@stdlib/math/strided/ops/mul-by"],"@stdlib/math/strided/special/trunc":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/strunc"],"@stdlib/array/to-strided-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator"],"@stdlib/streams/node/from-strided-array":["@stdlib/streams/node/from-array"],"@stdlib/buffer/from-string":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer"],"@stdlib/ndarray/sub2ind":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/ind2sub"],"@stdlib/string/substring-after":["@stdlib/string/substring-before","@stdlib/string/substring-before-last","@stdlib/string/substring-after-last"],"@stdlib/string/substring-after-last":["@stdlib/string/substring-before","@stdlib/string/substring-before-last","@stdlib/string/substring-after"],"@stdlib/string/substring-before":["@stdlib/string/substring-before-last","@stdlib/string/substring-after","@stdlib/string/substring-after-last"],"@stdlib/string/substring-before-last":["@stdlib/string/substring-before","@stdlib/string/substring-after","@stdlib/string/substring-after-last"],"@stdlib/datasets/suthaharan-multi-hop-sensor-network":["@stdlib/datasets/suthaharan-single-hop-sensor-network"],"@stdlib/datasets/suthaharan-single-hop-sensor-network":["@stdlib/datasets/suthaharan-multi-hop-sensor-network"],"@stdlib/symbol/ctor":[],"@stdlib/utils/tabulate":["@stdlib/utils/count-by","@stdlib/utils/group-by","@stdlib/utils/tabulate-by"],"@stdlib/utils/tabulate-by":["@stdlib/utils/count-by","@stdlib/utils/group-by","@stdlib/utils/tabulate"],"@stdlib/utils/async/tabulate-by":["@stdlib/utils/async/count-by","@stdlib/utils/async/group-by","@stdlib/utils/tabulate-by"],"@stdlib/function/thunk":[],"@stdlib/time/tic":["@stdlib/time/toc"],"@stdlib/utils/timeit":[],"@stdlib/os/tmpdir":["@stdlib/os/configdir","@stdlib/os/homedir"],"@stdlib/time/toc":["@stdlib/time/tic"],"@stdlib/nlp/tokenize":[],"@stdlib/streams/node/transform":[],"@stdlib/string/trim":["@stdlib/string/left-trim","@stdlib/string/pad","@stdlib/string/right-trim"],"@stdlib/string/truncate":["@stdlib/string/truncate-middle"],"@stdlib/string/truncate-middle":["@stdlib/string/truncate"],"@stdlib/utils/try-catch":["@stdlib/utils/async/try-catch","@stdlib/utils/try-then"],"@stdlib/utils/async/try-catch":["@stdlib/utils/try-catch","@stdlib/utils/async/try-then"],"@stdlib/utils/try-function":[],"@stdlib/utils/try-require":[],"@stdlib/utils/try-then":["@stdlib/utils/try-catch","@stdlib/utils/async/try-then"],"@stdlib/utils/async/try-then":["@stdlib/utils/async/try-catch","@stdlib/utils/try-then"],"@stdlib/stats/ttest":["@stdlib/stats/ttest2"],"@stdlib/stats/ttest2":["@stdlib/stats/ttest"],"@stdlib/constants/float64/two-pi":["@stdlib/constants/float64/pi"],"@stdlib/array/typed":["@stdlib/array/complex128","@stdlib/array/complex64","@stdlib/array/float64","@stdlib/array/float32","@stdlib/array/int32","@stdlib/array/uint32","@stdlib/array/int16","@stdlib/array/uint16","@stdlib/array/int8","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/to-json":["@stdlib/array/reviver"],"@stdlib/array/typed-ctors":["@stdlib/array/ctors"],"@stdlib/array/typed-dtypes":["@stdlib/array/dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/pool":["@stdlib/array/typed"],"@stdlib/utils/type-max":["@stdlib/utils/real-max","@stdlib/utils/type-min"],"@stdlib/utils/type-min":["@stdlib/utils/real-min","@stdlib/utils/type-max"],"@stdlib/utils/type-of":["@stdlib/utils/constructor-name","@stdlib/utils/native-class"],"@stdlib/constants/uint8/max":["@stdlib/constants/int8/max"],"@stdlib/constants/uint8/num-bytes":["@stdlib/constants/int8/num-bytes","@stdlib/constants/uint16/num-bytes","@stdlib/constants/uint32/num-bytes"],"@stdlib/array/uint8":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8c"],"@stdlib/array/uint8c":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8"],"@stdlib/constants/uint16/max":["@stdlib/constants/int16/max"],"@stdlib/constants/uint16/num-bytes":["@stdlib/constants/int16/num-bytes","@stdlib/constants/uint32/num-bytes","@stdlib/constants/uint8/num-bytes"],"@stdlib/array/uint16":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/uint32/max":["@stdlib/constants/int32/max"],"@stdlib/constants/uint32/num-bytes":["@stdlib/constants/int32/num-bytes","@stdlib/constants/uint16/num-bytes","@stdlib/constants/uint8/num-bytes"],"@stdlib/array/uint32":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/process/umask":[],"@stdlib/string/uncapitalize":["@stdlib/string/capitalize","@stdlib/string/lowercase"],"@stdlib/utils/uncapitalize-keys":["@stdlib/utils/capitalize-keys","@stdlib/utils/lowercase-keys"],"@stdlib/utils/uncurry":["@stdlib/utils/curry","@stdlib/utils/uncurry-right"],"@stdlib/utils/uncurry-right":["@stdlib/utils/curry","@stdlib/utils/curry-right","@stdlib/utils/uncurry"],"@stdlib/constants/unicode/max":["@stdlib/constants/unicode/max-bmp"],"@stdlib/constants/unicode/max-bmp":["@stdlib/constants/unicode/max"],"@stdlib/plot/sparklines/unicode/column":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/line":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/tristate":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/up-down":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/win-loss":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down"],"@stdlib/fs/unlink":["@stdlib/fs/exists"],"@stdlib/utils/unshift":["@stdlib/utils/pop","@stdlib/utils/push","@stdlib/utils/shift"],"@stdlib/utils/until":["@stdlib/utils/do-until","@stdlib/utils/do-while","@stdlib/utils/async/until","@stdlib/utils/until-each","@stdlib/utils/while"],"@stdlib/utils/async/until":["@stdlib/utils/async/do-until","@stdlib/utils/async/do-while","@stdlib/utils/until","@stdlib/utils/async/while"],"@stdlib/utils/until-each":["@stdlib/utils/until-each-right","@stdlib/utils/while-each"],"@stdlib/utils/until-each-right":["@stdlib/utils/until-each","@stdlib/utils/while-each-right"],"@stdlib/utils/unzip":["@stdlib/utils/zip"],"@stdlib/string/uppercase":["@stdlib/string/capitalize","@stdlib/string/lowercase"],"@stdlib/utils/uppercase-keys":["@stdlib/utils/capitalize-keys","@stdlib/utils/lowercase-keys"],"@stdlib/datasets/us-states-abbr":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names"],"@stdlib/datasets/us-states-capitals":["@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-capitals-names":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-names":["@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-names-capitals":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/string/utf16-to-utf8-array":[],"@stdlib/stats/vartest":["@stdlib/stats/bartlett-test"],"@stdlib/utils/async/series-waterfall":[],"@stdlib/wasm/memory":[],"@stdlib/utils/async/while":["@stdlib/utils/async/do-until","@stdlib/utils/async/do-while","@stdlib/utils/async/until","@stdlib/utils/while"],"@stdlib/utils/while-each":["@stdlib/utils/until-each","@stdlib/utils/while-each-right"],"@stdlib/utils/while-each-right":["@stdlib/utils/while-each","@stdlib/utils/until-each-right"],"@stdlib/utils/while":["@stdlib/utils/do-until","@stdlib/utils/do-while","@stdlib/utils/until","@stdlib/utils/async/while","@stdlib/utils/while-each"],"@stdlib/stats/wilcoxon":["@stdlib/stats/ttest","@stdlib/stats/ztest"],"@stdlib/utils/writable-properties":["@stdlib/utils/inherited-writable-properties","@stdlib/utils/writable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/writable-properties-in":["@stdlib/utils/inherited-writable-properties","@stdlib/utils/writable-properties","@stdlib/utils/properties-in"],"@stdlib/utils/writable-property-names":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-properties","@stdlib/utils/writable-property-names-in","@stdlib/utils/writable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/writable-property-names-in":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-properties-in","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/property-names-in"],"@stdlib/utils/writable-property-symbols":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/writable-property-symbols-in":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties-in","@stdlib/utils/writable-property-names-in","@stdlib/utils/writable-property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/fs/write-file":["@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/utils/zip":["@stdlib/utils/unzip"],"@stdlib/stats/ztest":["@stdlib/stats/ztest2"],"@stdlib/stats/ztest2":["@stdlib/stats/ztest"]} +{"@stdlib/math/special/abs":[],"@stdlib/array/cartesian-power":["@stdlib/array/cartesian-product","@stdlib/array/cartesian-square"],"@stdlib/array/cartesian-product":["@stdlib/array/cartesian-power","@stdlib/array/cartesian-square"],"@stdlib/array/cartesian-square":["@stdlib/array/cartesian-power","@stdlib/array/cartesian-product"],"@stdlib/string/acronym":[],"@stdlib/array/empty":["@stdlib/array/empty-like","@stdlib/array/full","@stdlib/array/ones","@stdlib/array/zeros","@stdlib/ndarray/empty"],"@stdlib/array/empty-like":["@stdlib/array/empty","@stdlib/array/full-like","@stdlib/array/ones-like","@stdlib/array/zeros-like","@stdlib/ndarray/empty-like"],"@stdlib/datasets/afinn-96":["@stdlib/datasets/afinn-111"],"@stdlib/datasets/afinn-111":["@stdlib/datasets/afinn-96"],"@stdlib/array/full":["@stdlib/array/full-like","@stdlib/array/ones","@stdlib/array/zeros"],"@stdlib/array/full-like":["@stdlib/array/full","@stdlib/array/ones-like","@stdlib/array/zeros-like"],"@stdlib/namespace/alias2pkg":["@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias"],"@stdlib/namespace/alias2related":["@stdlib/namespace/alias2pkg","@stdlib/namespace/aliases","@stdlib/namespace/pkg2related"],"@stdlib/namespace/alias2standalone":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias","@stdlib/namespace/pkg2standalone"],"@stdlib/namespace/aliases":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2related","@stdlib/namespace/pkg2alias"],"@stdlib/buffer/alloc-unsafe":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/mskfilter":["@stdlib/array/mskreject"],"@stdlib/array/mskput":["@stdlib/array/place","@stdlib/array/put","@stdlib/array/take"],"@stdlib/array/mskreject":["@stdlib/array/mskfilter"],"@stdlib/array/nans":["@stdlib/array/full","@stdlib/array/nans-like","@stdlib/array/ones","@stdlib/array/zeros"],"@stdlib/array/nans-like":["@stdlib/array/full-like","@stdlib/array/nans","@stdlib/array/ones-like","@stdlib/array/zeros-like"],"@stdlib/stats/anova1":[],"@stdlib/datasets/anscombes-quartet":[],"@stdlib/utils/any":["@stdlib/utils/any-by","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some"],"@stdlib/utils/any-by":["@stdlib/utils/async/any-by","@stdlib/utils/any-by-right","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some-by"],"@stdlib/utils/async/any-by":["@stdlib/utils/any-by","@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/async/some-by"],"@stdlib/utils/any-by-right":["@stdlib/utils/any-by","@stdlib/utils/async/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by-right"],"@stdlib/utils/async/any-by-right":["@stdlib/utils/async/any-by","@stdlib/utils/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/any-in-by":["@stdlib/utils/any-by","@stdlib/utils/any-own-by","@stdlib/utils/every-in-by","@stdlib/utils/some-in-by"],"@stdlib/utils/any-own-by":["@stdlib/utils/any-by","@stdlib/utils/any-in-by","@stdlib/utils/every-own-by","@stdlib/utils/some-own-by"],"@stdlib/array/ones":["@stdlib/array/full","@stdlib/array/nans","@stdlib/array/ones-like","@stdlib/array/zeros"],"@stdlib/array/ones-like":["@stdlib/array/full-like","@stdlib/array/nans-like","@stdlib/array/ones","@stdlib/array/zeros-like"],"@stdlib/array/one-to":["@stdlib/array/full","@stdlib/array/ones","@stdlib/array/one-to-like","@stdlib/array/zero-to"],"@stdlib/array/one-to-like":["@stdlib/array/full-like","@stdlib/array/ones-like","@stdlib/array/one-to","@stdlib/array/zero-to-like"],"@stdlib/constants/float64/apery":[],"@stdlib/array/place":["@stdlib/array/mskput","@stdlib/array/put","@stdlib/array/take"],"@stdlib/utils/append":["@stdlib/utils/prepend","@stdlib/utils/push"],"@stdlib/array/put":["@stdlib/array/mskput","@stdlib/array/place","@stdlib/array/take"],"@stdlib/os/arch":["@stdlib/os/platform"],"@stdlib/utils/argument-function":["@stdlib/utils/constant-function","@stdlib/utils/identity-function"],"@stdlib/process/argv":["@stdlib/process/env"],"@stdlib/ndarray/array":["@stdlib/ndarray/ctor"],"@stdlib/buffer/from-array":["@stdlib/buffer/ctor","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/to-fancy":["@stdlib/array/slice","@stdlib/ndarray/fancy"],"@stdlib/array/to-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-circular-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-strided-iterator"],"@stdlib/array/to-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator"],"@stdlib/array/buffer":["@stdlib/buffer/ctor","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/shared-buffer","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/buffer/from-arraybuffer":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/ctors":["@stdlib/array/typed-ctors"],"@stdlib/array/dtype":["@stdlib/array/dtypes"],"@stdlib/array/dtypes":["@stdlib/array/typed-dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/index":["@stdlib/array/to-fancy"],"@stdlib/array/min-dtype":["@stdlib/array/dtypes","@stdlib/array/promotion-rules","@stdlib/array/safe-casts"],"@stdlib/array/mostly-safe-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/array/same-kind-casts","@stdlib/ndarray/mostly-safe-casts"],"@stdlib/array/next-dtype":["@stdlib/array/dtype","@stdlib/array/dtypes"],"@stdlib/array/promotion-rules":["@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/ndarray/promotion-rules"],"@stdlib/array/safe-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/mostly-safe-casts","@stdlib/array/same-kind-casts","@stdlib/ndarray/safe-casts"],"@stdlib/array/same-kind-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/ndarray/same-kind-casts"],"@stdlib/array/shape":["@stdlib/ndarray/ctor"],"@stdlib/streams/node/from-array":["@stdlib/streams/node/from-circular-array","@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-strided-array"],"@stdlib/array/to-view-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator","@stdlib/array/to-strided-iterator","@stdlib/array/to-view-iterator-right"],"@stdlib/array/to-view-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-strided-iterator","@stdlib/array/to-view-iterator"],"@stdlib/array/slice":["@stdlib/array/take"],"@stdlib/symbol/async-iterator":["@stdlib/symbol/ctor","@stdlib/symbol/iterator"],"@stdlib/array/take":["@stdlib/array/put","@stdlib/array/slice"],"@stdlib/array/zeros":["@stdlib/array/empty","@stdlib/array/full","@stdlib/array/nans","@stdlib/array/ones","@stdlib/array/zeros-like","@stdlib/ndarray/zeros"],"@stdlib/array/zeros-like":["@stdlib/array/empty-like","@stdlib/array/full-like","@stdlib/array/nans-like","@stdlib/array/ones-like","@stdlib/array/zeros","@stdlib/ndarray/zeros-like"],"@stdlib/array/zero-to":["@stdlib/array/empty","@stdlib/array/full","@stdlib/array/one-to","@stdlib/array/zero-to-like","@stdlib/array/zeros"],"@stdlib/array/zero-to-like":["@stdlib/array/empty-like","@stdlib/array/full-like","@stdlib/array/nans-like","@stdlib/array/one-to-like","@stdlib/array/ones-like","@stdlib/array/zero-to","@stdlib/array/zeros-like"],"@stdlib/stats/bartlett-test":["@stdlib/stats/vartest","@stdlib/stats/levene-test"],"@stdlib/math/base/special/abs":["@stdlib/math/base/special/abs2","@stdlib/math/base/special/absf","@stdlib/math/base/special/labs"],"@stdlib/math/base/special/abs2":["@stdlib/math/base/special/abs","@stdlib/math/base/special/abs2f"],"@stdlib/math/base/special/abs2f":["@stdlib/math/base/special/abs2","@stdlib/math/base/special/absf"],"@stdlib/math/base/utils/absolute-difference":["@stdlib/math/base/utils/relative-difference","@stdlib/math/base/utils/float64-epsilon-difference"],"@stdlib/math/base/special/absf":["@stdlib/math/base/special/abs","@stdlib/math/base/special/abs2f","@stdlib/math/base/special/labs"],"@stdlib/array/base/cartesian-power":["@stdlib/array/cartesian-power","@stdlib/array/base/cartesian-product","@stdlib/array/base/cartesian-square"],"@stdlib/array/base/cartesian-product":["@stdlib/array/cartesian-product","@stdlib/array/base/cartesian-power","@stdlib/array/base/cartesian-square"],"@stdlib/array/base/cartesian-square":["@stdlib/array/cartesian-square","@stdlib/array/base/cartesian-power","@stdlib/array/base/cartesian-product"],"@stdlib/math/base/special/acos":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asin","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/acosd":["@stdlib/math/base/special/acos","@stdlib/math/base/special/acosh","@stdlib/math/base/special/asind","@stdlib/math/base/special/atand"],"@stdlib/math/base/special/acosf":["@stdlib/math/base/special/acos","@stdlib/math/base/special/acosh","@stdlib/math/base/special/asinf","@stdlib/math/base/special/atanf"],"@stdlib/math/base/special/acosh":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/acot":["@stdlib/math/base/special/acoth","@stdlib/math/base/special/atan","@stdlib/math/base/special/cot"],"@stdlib/math/base/special/acotd":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acoth","@stdlib/math/base/special/atand","@stdlib/math/base/special/cotd"],"@stdlib/math/base/special/acotf":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acoth","@stdlib/math/base/special/atanf"],"@stdlib/math/base/special/acoth":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/acot","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/acovercos":["@stdlib/math/base/special/acoversin","@stdlib/math/base/special/avercos","@stdlib/math/base/special/covercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/acoversin":["@stdlib/math/base/special/acovercos","@stdlib/math/base/special/aversin","@stdlib/math/base/special/coversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/acsc":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asec","@stdlib/math/base/special/asin","@stdlib/math/base/special/csc"],"@stdlib/math/base/special/acscd":["@stdlib/math/base/special/acsc","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asecd","@stdlib/math/base/special/asind","@stdlib/math/base/special/cscd"],"@stdlib/math/base/special/acscdf":["@stdlib/math/base/special/acsc","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asecdf","@stdlib/math/base/special/asindf"],"@stdlib/math/base/special/acscf":["@stdlib/math/base/special/acsc","@stdlib/math/base/special/acsch","@stdlib/math/base/special/asecf","@stdlib/math/base/special/asinf"],"@stdlib/math/base/special/acsch":["@stdlib/math/base/special/acoth","@stdlib/math/base/special/acsc","@stdlib/math/base/special/asech","@stdlib/math/base/special/asinh","@stdlib/math/base/special/csc","@stdlib/math/base/special/csch"],"@stdlib/number/float64/base/add":["@stdlib/number/float64/base/div","@stdlib/number/float64/base/mul","@stdlib/number/float64/base/sub"],"@stdlib/number/float64/base/add3":["@stdlib/number/float64/base/add"],"@stdlib/number/float64/base/add4":["@stdlib/number/float64/base/add"],"@stdlib/number/float64/base/add5":["@stdlib/number/float64/base/add"],"@stdlib/number/float32/base/add":["@stdlib/number/float64/base/add","@stdlib/number/float32/base/div","@stdlib/number/float32/base/mul","@stdlib/math/base/ops/subf"],"@stdlib/array/base/filled":[],"@stdlib/array/base/filled2d":[],"@stdlib/array/base/filled2d-by":["@stdlib/array/base/filled2d"],"@stdlib/array/base/filled3d":[],"@stdlib/array/base/filled3d-by":["@stdlib/array/base/filled3d"],"@stdlib/array/base/filled4d":[],"@stdlib/array/base/filled4d-by":["@stdlib/array/base/filled4d"],"@stdlib/array/base/filled5d":[],"@stdlib/array/base/filled5d-by":["@stdlib/array/base/filled5d"],"@stdlib/array/base/filled-by":["@stdlib/array/base/filled"],"@stdlib/array/base/fillednd":[],"@stdlib/array/base/fillednd-by":["@stdlib/array/base/fillednd"],"@stdlib/array/base/filter":[],"@stdlib/array/base/first":[],"@stdlib/array/base/flatten":["@stdlib/array/base/flatten-by"],"@stdlib/array/base/flatten2d":["@stdlib/array/base/flatten2d-by"],"@stdlib/array/base/flatten2d-by":["@stdlib/array/base/flatten2d"],"@stdlib/array/base/flatten3d":["@stdlib/array/base/flatten3d-by"],"@stdlib/array/base/flatten3d-by":["@stdlib/array/base/flatten3d"],"@stdlib/array/base/flatten4d":["@stdlib/array/base/flatten4d-by"],"@stdlib/array/base/flatten4d-by":["@stdlib/array/base/flatten4d"],"@stdlib/array/base/flatten5d":["@stdlib/array/base/flatten5d-by"],"@stdlib/array/base/flatten5d-by":["@stdlib/array/base/flatten5d"],"@stdlib/array/base/flatten-by":["@stdlib/array/base/flatten"],"@stdlib/array/base/fliplr2d":["@stdlib/array/base/fliplr3d","@stdlib/array/base/fliplr4d","@stdlib/array/base/fliplr5d"],"@stdlib/array/base/fliplr3d":["@stdlib/array/base/fliplr2d","@stdlib/array/base/fliplr4d","@stdlib/array/base/fliplr5d"],"@stdlib/array/base/fliplr4d":["@stdlib/array/base/fliplr2d","@stdlib/array/base/fliplr3d","@stdlib/array/base/fliplr5d"],"@stdlib/array/base/fliplr5d":["@stdlib/array/base/fliplr2d","@stdlib/array/base/fliplr3d","@stdlib/array/base/fliplr4d"],"@stdlib/array/base/flipud2d":["@stdlib/array/base/flipud3d","@stdlib/array/base/flipud4d","@stdlib/array/base/flipud5d"],"@stdlib/array/base/flipud3d":["@stdlib/array/base/flipud2d","@stdlib/array/base/flipud4d","@stdlib/array/base/flipud5d"],"@stdlib/array/base/flipud4d":["@stdlib/array/base/flipud2d","@stdlib/array/base/flipud3d","@stdlib/array/base/flipud5d"],"@stdlib/array/base/flipud5d":["@stdlib/array/base/flipud2d","@stdlib/array/base/flipud3d","@stdlib/array/base/flipud4d"],"@stdlib/math/base/special/ahavercos":["@stdlib/math/base/special/ahaversin","@stdlib/math/base/special/havercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/ahaversin":["@stdlib/math/base/special/ahavercos","@stdlib/math/base/special/haversin","@stdlib/math/base/special/versin"],"@stdlib/string/base/altcase":["@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/array/base/ones":["@stdlib/array/base/zeros","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones2d":["@stdlib/array/base/zeros2d","@stdlib/array/base/ones","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones3d":["@stdlib/array/base/zeros3d","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones4d":["@stdlib/array/base/zeros4d","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones5d","@stdlib/array/base/onesnd"],"@stdlib/array/base/ones5d":["@stdlib/array/base/zeros5d","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/onesnd"],"@stdlib/array/base/onesnd":["@stdlib/array/base/zerosnd","@stdlib/array/base/ones","@stdlib/array/base/ones2d","@stdlib/array/base/ones3d","@stdlib/array/base/ones4d","@stdlib/array/base/ones5d"],"@stdlib/array/base/one-to":["@stdlib/array/base/zero-to","@stdlib/array/base/ones"],"@stdlib/slice/base/args2multislice":[],"@stdlib/math/base/special/asec":["@stdlib/math/base/special/acot","@stdlib/math/base/special/acsc","@stdlib/math/base/special/asech","@stdlib/math/base/special/acos"],"@stdlib/math/base/special/asecd":["@stdlib/math/base/special/asec","@stdlib/math/base/special/asech","@stdlib/math/base/special/acosd","@stdlib/math/base/special/secd"],"@stdlib/math/base/special/asecdf":["@stdlib/math/base/special/asec","@stdlib/math/base/special/asech"],"@stdlib/math/base/special/asecf":["@stdlib/math/base/special/asec","@stdlib/math/base/special/asech","@stdlib/math/base/special/acosf"],"@stdlib/math/base/special/asech":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asec","@stdlib/math/base/special/asech","@stdlib/math/base/special/acoth"],"@stdlib/math/base/special/asin":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/asind":["@stdlib/math/base/special/asin","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atand"],"@stdlib/math/base/special/asindf":["@stdlib/math/base/special/asinf","@stdlib/math/base/special/asind"],"@stdlib/math/base/special/asinf":["@stdlib/math/base/special/asin","@stdlib/math/base/special/asindf"],"@stdlib/math/base/special/asinh":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asin","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/atan":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asin","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/atan2":["@stdlib/math/base/special/atan"],"@stdlib/math/base/special/atand":["@stdlib/math/base/special/atan","@stdlib/math/base/special/atanh","@stdlib/math/base/special/acosd"],"@stdlib/math/base/special/atanf":["@stdlib/math/base/special/atan","@stdlib/math/base/special/atanh","@stdlib/math/base/special/acosf"],"@stdlib/math/base/special/atanh":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/avercos":["@stdlib/math/base/special/aversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/aversin":["@stdlib/math/base/special/avercos","@stdlib/math/base/special/vercos"],"@stdlib/array/base/zeros":["@stdlib/array/base/ones","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros2d":["@stdlib/array/base/zeros","@stdlib/array/base/ones2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros3d":["@stdlib/array/base/zeros","@stdlib/array/base/ones3d","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros4d":["@stdlib/array/base/zeros","@stdlib/array/base/ones4d","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros5d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zeros5d":["@stdlib/array/base/zeros","@stdlib/array/base/ones5d","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zerosnd"],"@stdlib/array/base/zerosnd":["@stdlib/array/base/zeros","@stdlib/array/base/onesnd","@stdlib/array/base/zeros2d","@stdlib/array/base/zeros3d","@stdlib/array/base/zeros4d","@stdlib/array/base/zeros5d"],"@stdlib/array/base/zero-to":["@stdlib/array/base/one-to"],"@stdlib/math/base/special/bernoulli":[],"@stdlib/math/base/special/besselj0":["@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely0","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/besselj1":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/bessely0","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/bessely0":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/bessely1":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely0"],"@stdlib/math/base/special/beta":["@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betainc":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betaincinv":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betaln":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaincinv"],"@stdlib/math/base/special/binet":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/binomcoef":[],"@stdlib/math/base/special/binomcoefln":[],"@stdlib/math/base/special/boxcox":["@stdlib/math/base/special/boxcoxinv","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox1pinv"],"@stdlib/math/base/special/boxcox1p":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1pinv","@stdlib/math/base/special/boxcoxinv"],"@stdlib/math/base/special/boxcox1pinv":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcoxinv"],"@stdlib/math/base/special/boxcoxinv":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox1pinv"],"@stdlib/math/base/special/cabs":["@stdlib/math/base/special/cabs2","@stdlib/math/base/special/abs"],"@stdlib/math/base/special/cabs2":["@stdlib/math/base/special/cabs","@stdlib/math/base/special/abs2"],"@stdlib/math/base/special/cabs2f":["@stdlib/math/base/special/cabs2","@stdlib/math/base/special/cabsf","@stdlib/math/base/special/abs2f"],"@stdlib/math/base/special/cabsf":["@stdlib/math/base/special/cabs","@stdlib/math/base/special/cabs2f","@stdlib/math/base/special/absf"],"@stdlib/complex/float64/base/add":["@stdlib/math/base/ops/cdiv","@stdlib/complex/float64/base/mul","@stdlib/math/base/ops/csub"],"@stdlib/complex/float32/base/add":["@stdlib/complex/float64/base/add","@stdlib/complex/float32/base/mul","@stdlib/math/base/ops/csubf"],"@stdlib/string/base/camelcase":["@stdlib/string/base/constantcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/string/base/capitalize":["@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/cbrt":["@stdlib/math/base/special/pow","@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/cbrtf":["@stdlib/math/base/special/cbrt","@stdlib/math/base/special/sqrtf"],"@stdlib/math/base/special/cceil":["@stdlib/math/base/special/cceiln","@stdlib/math/base/special/cfloor","@stdlib/math/base/special/cround"],"@stdlib/math/base/special/cceilf":["@stdlib/math/base/special/cceil"],"@stdlib/math/base/special/cceiln":["@stdlib/math/base/special/cceil","@stdlib/math/base/special/cfloorn","@stdlib/math/base/special/croundn"],"@stdlib/math/base/special/ccis":[],"@stdlib/math/base/ops/cdiv":["@stdlib/complex/float64/base/add","@stdlib/complex/float64/base/mul","@stdlib/math/base/ops/csub"],"@stdlib/math/base/special/ceil":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floor","@stdlib/math/base/special/round"],"@stdlib/math/base/special/ceil2":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/ceil10":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/ceilb":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/ceilf":["@stdlib/math/base/special/floorf"],"@stdlib/math/base/special/ceiln":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/ceilsd":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/special/cexp":[],"@stdlib/math/base/special/cflipsign":["@stdlib/math/base/ops/cneg","@stdlib/math/base/special/csignum"],"@stdlib/math/base/special/cflipsignf":["@stdlib/math/base/ops/cnegf","@stdlib/math/base/special/cflipsign"],"@stdlib/math/base/special/cfloor":["@stdlib/math/base/special/cceil","@stdlib/math/base/special/cfloorn","@stdlib/math/base/special/cround"],"@stdlib/math/base/special/cfloorn":["@stdlib/math/base/special/cceiln","@stdlib/math/base/special/cfloor","@stdlib/math/base/special/croundn"],"@stdlib/math/base/special/cidentity":["@stdlib/math/base/special/cidentityf","@stdlib/math/base/special/identity"],"@stdlib/math/base/special/cidentityf":["@stdlib/math/base/special/cidentity","@stdlib/math/base/special/identityf"],"@stdlib/math/base/special/cinv":["@stdlib/math/base/ops/cdiv"],"@stdlib/math/base/special/clamp":["@stdlib/math/base/special/clampf","@stdlib/math/base/special/wrap"],"@stdlib/math/base/special/clampf":["@stdlib/math/base/special/clamp"],"@stdlib/complex/float64/base/mul":["@stdlib/complex/float64/base/add","@stdlib/math/base/ops/cdiv","@stdlib/math/base/ops/csub"],"@stdlib/complex/float32/base/mul":["@stdlib/complex/float32/base/add","@stdlib/complex/float64/base/mul","@stdlib/math/base/ops/csubf"],"@stdlib/math/base/ops/cneg":["@stdlib/math/base/special/cabs"],"@stdlib/math/base/ops/cnegf":["@stdlib/math/base/ops/cneg","@stdlib/math/base/special/cabsf"],"@stdlib/string/base/code-point-at":[],"@stdlib/string/base/constantcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/math/base/tools/continued-fraction":[],"@stdlib/math/base/special/copysign":["@stdlib/math/base/special/flipsign"],"@stdlib/math/base/special/copysignf":["@stdlib/math/base/special/copysign","@stdlib/math/base/special/flipsignf"],"@stdlib/math/base/special/cos":["@stdlib/math/base/special/cospi","@stdlib/math/base/special/cosm1","@stdlib/math/base/special/sin","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/cosd":["@stdlib/math/base/special/tand"],"@stdlib/math/base/special/cosh":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sinh","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/cosm1":["@stdlib/math/base/special/cos"],"@stdlib/math/base/special/cospi":["@stdlib/math/base/special/cos"],"@stdlib/math/base/special/cot":["@stdlib/math/base/special/csc","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/cotd":["@stdlib/math/base/special/cscd","@stdlib/math/base/special/secd","@stdlib/math/base/special/tand"],"@stdlib/math/base/special/coth":["@stdlib/math/base/special/acoth","@stdlib/math/base/special/cot","@stdlib/math/base/special/csch","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/covercos":["@stdlib/math/base/special/coversin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/coversin":["@stdlib/math/base/special/covercos","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/cphase":["@stdlib/math/base/special/cabs"],"@stdlib/math/base/special/cpolar":["@stdlib/math/base/special/cabs","@stdlib/math/base/special/cphase"],"@stdlib/math/base/special/cround":["@stdlib/math/base/special/cceil","@stdlib/math/base/special/cfloor","@stdlib/math/base/special/croundn"],"@stdlib/math/base/special/croundn":["@stdlib/math/base/special/cceiln","@stdlib/math/base/special/cfloorn","@stdlib/math/base/special/cround"],"@stdlib/math/base/special/csc":["@stdlib/math/base/special/cot","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/cscd":["@stdlib/math/base/special/cotd","@stdlib/math/base/special/secd"],"@stdlib/math/base/special/csch":["@stdlib/math/base/special/acsch","@stdlib/math/base/special/csc","@stdlib/math/base/special/coth","@stdlib/math/base/special/sinh"],"@stdlib/math/base/special/csignum":["@stdlib/math/base/special/signum"],"@stdlib/math/base/ops/csub":["@stdlib/complex/float64/base/add","@stdlib/math/base/ops/cdiv","@stdlib/complex/float64/base/mul"],"@stdlib/math/base/ops/csubf":["@stdlib/complex/float32/base/add","@stdlib/complex/float32/base/mul","@stdlib/math/base/ops/csub"],"@stdlib/math/base/special/deg2rad":["@stdlib/math/base/special/rad2deg"],"@stdlib/math/base/special/deg2radf":["@stdlib/math/base/special/deg2rad","@stdlib/math/base/special/rad2degf"],"@stdlib/math/base/special/digamma":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/trigamma"],"@stdlib/math/base/special/dirac-delta":["@stdlib/math/base/special/kronecker-delta"],"@stdlib/number/float64/base/div":["@stdlib/number/float64/base/add","@stdlib/number/float64/base/mul","@stdlib/number/float64/base/sub"],"@stdlib/number/float32/base/div":["@stdlib/number/float32/base/add","@stdlib/number/float64/base/div","@stdlib/number/float32/base/mul","@stdlib/math/base/ops/subf"],"@stdlib/string/base/dotcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/stats/base/dists/arcsine/ctor":[],"@stdlib/stats/base/dists/arcsine/cdf":[],"@stdlib/stats/base/dists/arcsine/entropy":[],"@stdlib/stats/base/dists/arcsine/kurtosis":[],"@stdlib/stats/base/dists/arcsine/logcdf":[],"@stdlib/stats/base/dists/arcsine/logpdf":[],"@stdlib/stats/base/dists/arcsine/mean":[],"@stdlib/stats/base/dists/arcsine/median":[],"@stdlib/stats/base/dists/arcsine/mode":[],"@stdlib/stats/base/dists/arcsine/pdf":[],"@stdlib/stats/base/dists/arcsine/quantile":[],"@stdlib/stats/base/dists/arcsine/skewness":[],"@stdlib/stats/base/dists/arcsine/stdev":[],"@stdlib/stats/base/dists/arcsine/variance":[],"@stdlib/stats/base/dists/bernoulli/ctor":[],"@stdlib/stats/base/dists/bernoulli/cdf":[],"@stdlib/stats/base/dists/bernoulli/entropy":[],"@stdlib/stats/base/dists/bernoulli/kurtosis":[],"@stdlib/stats/base/dists/bernoulli/mean":[],"@stdlib/stats/base/dists/bernoulli/median":[],"@stdlib/stats/base/dists/bernoulli/mgf":[],"@stdlib/stats/base/dists/bernoulli/mode":[],"@stdlib/stats/base/dists/bernoulli/pmf":[],"@stdlib/stats/base/dists/bernoulli/quantile":[],"@stdlib/stats/base/dists/bernoulli/skewness":[],"@stdlib/stats/base/dists/bernoulli/stdev":[],"@stdlib/stats/base/dists/bernoulli/variance":[],"@stdlib/stats/base/dists/beta/ctor":[],"@stdlib/stats/base/dists/beta/cdf":[],"@stdlib/stats/base/dists/beta/entropy":[],"@stdlib/stats/base/dists/beta/kurtosis":[],"@stdlib/stats/base/dists/beta/logcdf":[],"@stdlib/stats/base/dists/beta/logpdf":[],"@stdlib/stats/base/dists/beta/mean":[],"@stdlib/stats/base/dists/beta/median":[],"@stdlib/stats/base/dists/beta/mgf":[],"@stdlib/stats/base/dists/beta/mode":[],"@stdlib/stats/base/dists/beta/pdf":[],"@stdlib/stats/base/dists/beta/quantile":[],"@stdlib/stats/base/dists/beta/skewness":[],"@stdlib/stats/base/dists/beta/stdev":[],"@stdlib/stats/base/dists/beta/variance":[],"@stdlib/stats/base/dists/betaprime/ctor":[],"@stdlib/stats/base/dists/betaprime/cdf":[],"@stdlib/stats/base/dists/betaprime/kurtosis":[],"@stdlib/stats/base/dists/betaprime/logcdf":[],"@stdlib/stats/base/dists/betaprime/logpdf":[],"@stdlib/stats/base/dists/betaprime/mean":[],"@stdlib/stats/base/dists/betaprime/mode":[],"@stdlib/stats/base/dists/betaprime/pdf":[],"@stdlib/stats/base/dists/betaprime/quantile":[],"@stdlib/stats/base/dists/betaprime/skewness":[],"@stdlib/stats/base/dists/betaprime/stdev":[],"@stdlib/stats/base/dists/betaprime/variance":[],"@stdlib/stats/base/dists/binomial/ctor":[],"@stdlib/stats/base/dists/binomial/cdf":[],"@stdlib/stats/base/dists/binomial/entropy":[],"@stdlib/stats/base/dists/binomial/kurtosis":[],"@stdlib/stats/base/dists/binomial/logpmf":[],"@stdlib/stats/base/dists/binomial/mean":[],"@stdlib/stats/base/dists/binomial/median":[],"@stdlib/stats/base/dists/binomial/mgf":[],"@stdlib/stats/base/dists/binomial/mode":[],"@stdlib/stats/base/dists/binomial/pmf":[],"@stdlib/stats/base/dists/binomial/quantile":[],"@stdlib/stats/base/dists/binomial/skewness":[],"@stdlib/stats/base/dists/binomial/stdev":[],"@stdlib/stats/base/dists/binomial/variance":[],"@stdlib/stats/base/dists/cauchy/ctor":[],"@stdlib/stats/base/dists/cauchy/cdf":[],"@stdlib/stats/base/dists/cauchy/entropy":[],"@stdlib/stats/base/dists/cauchy/logcdf":[],"@stdlib/stats/base/dists/cauchy/logpdf":[],"@stdlib/stats/base/dists/cauchy/median":[],"@stdlib/stats/base/dists/cauchy/mode":[],"@stdlib/stats/base/dists/cauchy/pdf":[],"@stdlib/stats/base/dists/cauchy/quantile":[],"@stdlib/stats/base/dists/chi/cdf":[],"@stdlib/stats/base/dists/chi/ctor":[],"@stdlib/stats/base/dists/chi/entropy":[],"@stdlib/stats/base/dists/chi/kurtosis":[],"@stdlib/stats/base/dists/chi/logpdf":[],"@stdlib/stats/base/dists/chi/mean":[],"@stdlib/stats/base/dists/chi/mode":[],"@stdlib/stats/base/dists/chi/pdf":[],"@stdlib/stats/base/dists/chi/quantile":[],"@stdlib/stats/base/dists/chi/skewness":[],"@stdlib/stats/base/dists/chi/stdev":[],"@stdlib/stats/base/dists/chi/variance":[],"@stdlib/stats/base/dists/chisquare/cdf":[],"@stdlib/stats/base/dists/chisquare/ctor":[],"@stdlib/stats/base/dists/chisquare/entropy":[],"@stdlib/stats/base/dists/chisquare/kurtosis":[],"@stdlib/stats/base/dists/chisquare/logpdf":[],"@stdlib/stats/base/dists/chisquare/mean":[],"@stdlib/stats/base/dists/chisquare/median":[],"@stdlib/stats/base/dists/chisquare/mgf":[],"@stdlib/stats/base/dists/chisquare/mode":[],"@stdlib/stats/base/dists/chisquare/pdf":[],"@stdlib/stats/base/dists/chisquare/quantile":[],"@stdlib/stats/base/dists/chisquare/skewness":[],"@stdlib/stats/base/dists/chisquare/stdev":[],"@stdlib/stats/base/dists/chisquare/variance":[],"@stdlib/stats/base/dists/cosine/cdf":[],"@stdlib/stats/base/dists/cosine/ctor":[],"@stdlib/stats/base/dists/cosine/kurtosis":[],"@stdlib/stats/base/dists/cosine/logcdf":[],"@stdlib/stats/base/dists/cosine/logpdf":[],"@stdlib/stats/base/dists/cosine/mean":[],"@stdlib/stats/base/dists/cosine/median":[],"@stdlib/stats/base/dists/cosine/mgf":[],"@stdlib/stats/base/dists/cosine/mode":[],"@stdlib/stats/base/dists/cosine/pdf":[],"@stdlib/stats/base/dists/cosine/quantile":[],"@stdlib/stats/base/dists/cosine/skewness":[],"@stdlib/stats/base/dists/cosine/stdev":[],"@stdlib/stats/base/dists/cosine/variance":[],"@stdlib/stats/base/dists/degenerate/cdf":[],"@stdlib/stats/base/dists/degenerate/ctor":[],"@stdlib/stats/base/dists/degenerate/entropy":[],"@stdlib/stats/base/dists/degenerate/logcdf":[],"@stdlib/stats/base/dists/degenerate/logpdf":[],"@stdlib/stats/base/dists/degenerate/logpmf":[],"@stdlib/stats/base/dists/degenerate/mean":[],"@stdlib/stats/base/dists/degenerate/median":[],"@stdlib/stats/base/dists/degenerate/mgf":[],"@stdlib/stats/base/dists/degenerate/mode":[],"@stdlib/stats/base/dists/degenerate/pdf":[],"@stdlib/stats/base/dists/degenerate/pmf":[],"@stdlib/stats/base/dists/degenerate/quantile":[],"@stdlib/stats/base/dists/degenerate/stdev":[],"@stdlib/stats/base/dists/degenerate/variance":[],"@stdlib/stats/base/dists/discrete-uniform/cdf":[],"@stdlib/stats/base/dists/discrete-uniform/ctor":[],"@stdlib/stats/base/dists/discrete-uniform/entropy":[],"@stdlib/stats/base/dists/discrete-uniform/kurtosis":[],"@stdlib/stats/base/dists/discrete-uniform/logcdf":[],"@stdlib/stats/base/dists/discrete-uniform/logpmf":[],"@stdlib/stats/base/dists/discrete-uniform/mean":[],"@stdlib/stats/base/dists/discrete-uniform/median":[],"@stdlib/stats/base/dists/discrete-uniform/mgf":[],"@stdlib/stats/base/dists/discrete-uniform/pmf":[],"@stdlib/stats/base/dists/discrete-uniform/quantile":[],"@stdlib/stats/base/dists/discrete-uniform/skewness":[],"@stdlib/stats/base/dists/discrete-uniform/stdev":[],"@stdlib/stats/base/dists/discrete-uniform/variance":[],"@stdlib/stats/base/dists/erlang/cdf":[],"@stdlib/stats/base/dists/erlang/entropy":[],"@stdlib/stats/base/dists/erlang/ctor":[],"@stdlib/stats/base/dists/erlang/kurtosis":[],"@stdlib/stats/base/dists/erlang/logpdf":[],"@stdlib/stats/base/dists/erlang/mean":[],"@stdlib/stats/base/dists/erlang/mgf":[],"@stdlib/stats/base/dists/erlang/mode":[],"@stdlib/stats/base/dists/erlang/pdf":[],"@stdlib/stats/base/dists/erlang/quantile":[],"@stdlib/stats/base/dists/erlang/skewness":[],"@stdlib/stats/base/dists/erlang/stdev":[],"@stdlib/stats/base/dists/erlang/variance":[],"@stdlib/stats/base/dists/exponential/cdf":[],"@stdlib/stats/base/dists/exponential/entropy":[],"@stdlib/stats/base/dists/exponential/ctor":[],"@stdlib/stats/base/dists/exponential/kurtosis":[],"@stdlib/stats/base/dists/exponential/logcdf":[],"@stdlib/stats/base/dists/exponential/logpdf":[],"@stdlib/stats/base/dists/exponential/mean":[],"@stdlib/stats/base/dists/exponential/median":[],"@stdlib/stats/base/dists/exponential/mgf":[],"@stdlib/stats/base/dists/exponential/mode":[],"@stdlib/stats/base/dists/exponential/pdf":[],"@stdlib/stats/base/dists/exponential/quantile":[],"@stdlib/stats/base/dists/exponential/skewness":[],"@stdlib/stats/base/dists/exponential/stdev":[],"@stdlib/stats/base/dists/exponential/variance":[],"@stdlib/stats/base/dists/f/cdf":[],"@stdlib/stats/base/dists/f/entropy":[],"@stdlib/stats/base/dists/f/ctor":[],"@stdlib/stats/base/dists/f/kurtosis":[],"@stdlib/stats/base/dists/f/mean":[],"@stdlib/stats/base/dists/f/mode":[],"@stdlib/stats/base/dists/f/pdf":[],"@stdlib/stats/base/dists/f/quantile":[],"@stdlib/stats/base/dists/f/skewness":[],"@stdlib/stats/base/dists/f/stdev":[],"@stdlib/stats/base/dists/f/variance":[],"@stdlib/stats/base/dists/frechet/cdf":[],"@stdlib/stats/base/dists/frechet/entropy":[],"@stdlib/stats/base/dists/frechet/ctor":[],"@stdlib/stats/base/dists/frechet/kurtosis":[],"@stdlib/stats/base/dists/frechet/logcdf":[],"@stdlib/stats/base/dists/frechet/logpdf":[],"@stdlib/stats/base/dists/frechet/mean":[],"@stdlib/stats/base/dists/frechet/median":[],"@stdlib/stats/base/dists/frechet/mode":[],"@stdlib/stats/base/dists/frechet/pdf":[],"@stdlib/stats/base/dists/frechet/quantile":[],"@stdlib/stats/base/dists/frechet/skewness":[],"@stdlib/stats/base/dists/frechet/stdev":[],"@stdlib/stats/base/dists/frechet/variance":[],"@stdlib/stats/base/dists/gamma/cdf":[],"@stdlib/stats/base/dists/gamma/entropy":[],"@stdlib/stats/base/dists/gamma/ctor":[],"@stdlib/stats/base/dists/gamma/kurtosis":[],"@stdlib/stats/base/dists/gamma/logcdf":[],"@stdlib/stats/base/dists/gamma/logpdf":[],"@stdlib/stats/base/dists/gamma/mean":[],"@stdlib/stats/base/dists/gamma/mgf":[],"@stdlib/stats/base/dists/gamma/mode":[],"@stdlib/stats/base/dists/gamma/pdf":[],"@stdlib/stats/base/dists/gamma/quantile":[],"@stdlib/stats/base/dists/gamma/skewness":[],"@stdlib/stats/base/dists/gamma/stdev":[],"@stdlib/stats/base/dists/gamma/variance":[],"@stdlib/stats/base/dists/geometric/cdf":[],"@stdlib/stats/base/dists/geometric/entropy":[],"@stdlib/stats/base/dists/geometric/ctor":[],"@stdlib/stats/base/dists/geometric/kurtosis":[],"@stdlib/stats/base/dists/geometric/logcdf":[],"@stdlib/stats/base/dists/geometric/logpmf":[],"@stdlib/stats/base/dists/geometric/mean":[],"@stdlib/stats/base/dists/geometric/median":[],"@stdlib/stats/base/dists/geometric/mgf":[],"@stdlib/stats/base/dists/geometric/mode":[],"@stdlib/stats/base/dists/geometric/pmf":[],"@stdlib/stats/base/dists/geometric/quantile":[],"@stdlib/stats/base/dists/geometric/skewness":[],"@stdlib/stats/base/dists/geometric/stdev":[],"@stdlib/stats/base/dists/geometric/variance":[],"@stdlib/stats/base/dists/gumbel/cdf":[],"@stdlib/stats/base/dists/gumbel/entropy":[],"@stdlib/stats/base/dists/gumbel/ctor":[],"@stdlib/stats/base/dists/gumbel/kurtosis":[],"@stdlib/stats/base/dists/gumbel/logcdf":[],"@stdlib/stats/base/dists/gumbel/logpdf":[],"@stdlib/stats/base/dists/gumbel/mean":[],"@stdlib/stats/base/dists/gumbel/median":[],"@stdlib/stats/base/dists/gumbel/mgf":[],"@stdlib/stats/base/dists/gumbel/mode":[],"@stdlib/stats/base/dists/gumbel/pdf":[],"@stdlib/stats/base/dists/gumbel/quantile":[],"@stdlib/stats/base/dists/gumbel/skewness":[],"@stdlib/stats/base/dists/gumbel/stdev":[],"@stdlib/stats/base/dists/gumbel/variance":[],"@stdlib/stats/base/dists/hypergeometric/cdf":[],"@stdlib/stats/base/dists/hypergeometric/ctor":[],"@stdlib/stats/base/dists/hypergeometric/kurtosis":[],"@stdlib/stats/base/dists/hypergeometric/logpmf":[],"@stdlib/stats/base/dists/hypergeometric/mean":[],"@stdlib/stats/base/dists/hypergeometric/mode":[],"@stdlib/stats/base/dists/hypergeometric/pmf":[],"@stdlib/stats/base/dists/hypergeometric/quantile":[],"@stdlib/stats/base/dists/hypergeometric/skewness":[],"@stdlib/stats/base/dists/hypergeometric/stdev":[],"@stdlib/stats/base/dists/hypergeometric/variance":[],"@stdlib/stats/base/dists/invgamma/cdf":[],"@stdlib/stats/base/dists/invgamma/entropy":[],"@stdlib/stats/base/dists/invgamma/ctor":[],"@stdlib/stats/base/dists/invgamma/kurtosis":[],"@stdlib/stats/base/dists/invgamma/logpdf":[],"@stdlib/stats/base/dists/invgamma/mean":[],"@stdlib/stats/base/dists/invgamma/mode":[],"@stdlib/stats/base/dists/invgamma/pdf":[],"@stdlib/stats/base/dists/invgamma/quantile":[],"@stdlib/stats/base/dists/invgamma/skewness":[],"@stdlib/stats/base/dists/invgamma/stdev":[],"@stdlib/stats/base/dists/invgamma/variance":[],"@stdlib/stats/base/dists/kumaraswamy/cdf":[],"@stdlib/stats/base/dists/kumaraswamy/ctor":[],"@stdlib/stats/base/dists/kumaraswamy/kurtosis":[],"@stdlib/stats/base/dists/kumaraswamy/logcdf":[],"@stdlib/stats/base/dists/kumaraswamy/logpdf":[],"@stdlib/stats/base/dists/kumaraswamy/mean":[],"@stdlib/stats/base/dists/kumaraswamy/median":[],"@stdlib/stats/base/dists/kumaraswamy/mode":[],"@stdlib/stats/base/dists/kumaraswamy/pdf":[],"@stdlib/stats/base/dists/kumaraswamy/quantile":[],"@stdlib/stats/base/dists/kumaraswamy/skewness":[],"@stdlib/stats/base/dists/kumaraswamy/stdev":[],"@stdlib/stats/base/dists/kumaraswamy/variance":[],"@stdlib/stats/base/dists/laplace/cdf":[],"@stdlib/stats/base/dists/laplace/entropy":[],"@stdlib/stats/base/dists/laplace/kurtosis":[],"@stdlib/stats/base/dists/laplace/ctor":[],"@stdlib/stats/base/dists/laplace/logcdf":[],"@stdlib/stats/base/dists/laplace/logpdf":[],"@stdlib/stats/base/dists/laplace/mean":[],"@stdlib/stats/base/dists/laplace/median":[],"@stdlib/stats/base/dists/laplace/mgf":[],"@stdlib/stats/base/dists/laplace/mode":[],"@stdlib/stats/base/dists/laplace/pdf":[],"@stdlib/stats/base/dists/laplace/quantile":[],"@stdlib/stats/base/dists/laplace/skewness":[],"@stdlib/stats/base/dists/laplace/stdev":[],"@stdlib/stats/base/dists/laplace/variance":[],"@stdlib/stats/base/dists/levy/cdf":[],"@stdlib/stats/base/dists/levy/entropy":[],"@stdlib/stats/base/dists/levy/ctor":[],"@stdlib/stats/base/dists/levy/logcdf":[],"@stdlib/stats/base/dists/levy/logpdf":[],"@stdlib/stats/base/dists/levy/mean":[],"@stdlib/stats/base/dists/levy/median":[],"@stdlib/stats/base/dists/levy/mode":[],"@stdlib/stats/base/dists/levy/pdf":[],"@stdlib/stats/base/dists/levy/quantile":[],"@stdlib/stats/base/dists/levy/stdev":[],"@stdlib/stats/base/dists/levy/variance":[],"@stdlib/stats/base/dists/logistic/cdf":[],"@stdlib/stats/base/dists/logistic/entropy":[],"@stdlib/stats/base/dists/logistic/kurtosis":[],"@stdlib/stats/base/dists/logistic/logcdf":[],"@stdlib/stats/base/dists/logistic/ctor":[],"@stdlib/stats/base/dists/logistic/logpdf":[],"@stdlib/stats/base/dists/logistic/mean":[],"@stdlib/stats/base/dists/logistic/median":[],"@stdlib/stats/base/dists/logistic/mgf":[],"@stdlib/stats/base/dists/logistic/mode":[],"@stdlib/stats/base/dists/logistic/pdf":[],"@stdlib/stats/base/dists/logistic/quantile":[],"@stdlib/stats/base/dists/logistic/skewness":[],"@stdlib/stats/base/dists/logistic/stdev":[],"@stdlib/stats/base/dists/logistic/variance":[],"@stdlib/stats/base/dists/lognormal/cdf":[],"@stdlib/stats/base/dists/lognormal/entropy":[],"@stdlib/stats/base/dists/lognormal/kurtosis":[],"@stdlib/stats/base/dists/lognormal/ctor":[],"@stdlib/stats/base/dists/lognormal/logcdf":[],"@stdlib/stats/base/dists/lognormal/logpdf":[],"@stdlib/stats/base/dists/lognormal/mean":[],"@stdlib/stats/base/dists/lognormal/median":[],"@stdlib/stats/base/dists/lognormal/mode":[],"@stdlib/stats/base/dists/lognormal/pdf":[],"@stdlib/stats/base/dists/lognormal/quantile":[],"@stdlib/stats/base/dists/lognormal/skewness":[],"@stdlib/stats/base/dists/lognormal/stdev":[],"@stdlib/stats/base/dists/lognormal/variance":[],"@stdlib/stats/base/dists/negative-binomial/cdf":[],"@stdlib/stats/base/dists/negative-binomial/kurtosis":[],"@stdlib/stats/base/dists/negative-binomial/logpmf":[],"@stdlib/stats/base/dists/negative-binomial/mean":[],"@stdlib/stats/base/dists/negative-binomial/mgf":[],"@stdlib/stats/base/dists/negative-binomial/mode":[],"@stdlib/stats/base/dists/negative-binomial/ctor":[],"@stdlib/stats/base/dists/negative-binomial/pmf":[],"@stdlib/stats/base/dists/negative-binomial/quantile":[],"@stdlib/stats/base/dists/negative-binomial/skewness":[],"@stdlib/stats/base/dists/negative-binomial/stdev":[],"@stdlib/stats/base/dists/negative-binomial/variance":[],"@stdlib/stats/base/dists/normal/cdf":[],"@stdlib/stats/base/dists/normal/entropy":[],"@stdlib/stats/base/dists/normal/kurtosis":[],"@stdlib/stats/base/dists/normal/logcdf":[],"@stdlib/stats/base/dists/normal/logpdf":[],"@stdlib/stats/base/dists/normal/mean":[],"@stdlib/stats/base/dists/normal/median":[],"@stdlib/stats/base/dists/normal/mgf":[],"@stdlib/stats/base/dists/normal/mode":[],"@stdlib/stats/base/dists/normal/ctor":[],"@stdlib/stats/base/dists/normal/pdf":[],"@stdlib/stats/base/dists/normal/quantile":[],"@stdlib/stats/base/dists/normal/skewness":[],"@stdlib/stats/base/dists/normal/stdev":[],"@stdlib/stats/base/dists/normal/variance":[],"@stdlib/stats/base/dists/pareto-type1/cdf":[],"@stdlib/stats/base/dists/pareto-type1/entropy":[],"@stdlib/stats/base/dists/pareto-type1/kurtosis":[],"@stdlib/stats/base/dists/pareto-type1/logcdf":[],"@stdlib/stats/base/dists/pareto-type1/logpdf":[],"@stdlib/stats/base/dists/pareto-type1/mean":[],"@stdlib/stats/base/dists/pareto-type1/median":[],"@stdlib/stats/base/dists/pareto-type1/mode":[],"@stdlib/stats/base/dists/pareto-type1/ctor":[],"@stdlib/stats/base/dists/pareto-type1/pdf":[],"@stdlib/stats/base/dists/pareto-type1/quantile":[],"@stdlib/stats/base/dists/pareto-type1/skewness":[],"@stdlib/stats/base/dists/pareto-type1/stdev":[],"@stdlib/stats/base/dists/pareto-type1/variance":[],"@stdlib/stats/base/dists/poisson/cdf":[],"@stdlib/stats/base/dists/poisson/entropy":[],"@stdlib/stats/base/dists/poisson/kurtosis":[],"@stdlib/stats/base/dists/poisson/logpmf":[],"@stdlib/stats/base/dists/poisson/mean":[],"@stdlib/stats/base/dists/poisson/median":[],"@stdlib/stats/base/dists/poisson/mgf":[],"@stdlib/stats/base/dists/poisson/mode":[],"@stdlib/stats/base/dists/poisson/pmf":[],"@stdlib/stats/base/dists/poisson/ctor":[],"@stdlib/stats/base/dists/poisson/quantile":[],"@stdlib/stats/base/dists/poisson/skewness":[],"@stdlib/stats/base/dists/poisson/stdev":[],"@stdlib/stats/base/dists/poisson/variance":[],"@stdlib/stats/base/dists/rayleigh/cdf":[],"@stdlib/stats/base/dists/rayleigh/entropy":[],"@stdlib/stats/base/dists/rayleigh/kurtosis":[],"@stdlib/stats/base/dists/rayleigh/logcdf":[],"@stdlib/stats/base/dists/rayleigh/logpdf":[],"@stdlib/stats/base/dists/rayleigh/mean":[],"@stdlib/stats/base/dists/rayleigh/median":[],"@stdlib/stats/base/dists/rayleigh/mgf":[],"@stdlib/stats/base/dists/rayleigh/mode":[],"@stdlib/stats/base/dists/rayleigh/pdf":[],"@stdlib/stats/base/dists/rayleigh/quantile":[],"@stdlib/stats/base/dists/rayleigh/ctor":[],"@stdlib/stats/base/dists/rayleigh/skewness":[],"@stdlib/stats/base/dists/rayleigh/stdev":[],"@stdlib/stats/base/dists/rayleigh/variance":[],"@stdlib/stats/base/dists/signrank/cdf":[],"@stdlib/stats/base/dists/signrank/pdf":[],"@stdlib/stats/base/dists/signrank/quantile":[],"@stdlib/stats/base/dists/studentized-range/cdf":[],"@stdlib/stats/base/dists/studentized-range/quantile":[],"@stdlib/stats/base/dists/t/cdf":[],"@stdlib/stats/base/dists/t/entropy":[],"@stdlib/stats/base/dists/t/kurtosis":[],"@stdlib/stats/base/dists/t/logcdf":[],"@stdlib/stats/base/dists/t/logpdf":[],"@stdlib/stats/base/dists/t/mean":[],"@stdlib/stats/base/dists/t/median":[],"@stdlib/stats/base/dists/t/mode":[],"@stdlib/stats/base/dists/t/pdf":[],"@stdlib/stats/base/dists/t/quantile":[],"@stdlib/stats/base/dists/t/skewness":[],"@stdlib/stats/base/dists/t/stdev":[],"@stdlib/stats/base/dists/t/ctor":[],"@stdlib/stats/base/dists/t/variance":[],"@stdlib/stats/base/dists/triangular/cdf":[],"@stdlib/stats/base/dists/triangular/entropy":[],"@stdlib/stats/base/dists/triangular/kurtosis":[],"@stdlib/stats/base/dists/triangular/logcdf":[],"@stdlib/stats/base/dists/triangular/logpdf":[],"@stdlib/stats/base/dists/triangular/mean":[],"@stdlib/stats/base/dists/triangular/median":[],"@stdlib/stats/base/dists/triangular/mgf":[],"@stdlib/stats/base/dists/triangular/mode":[],"@stdlib/stats/base/dists/triangular/pdf":[],"@stdlib/stats/base/dists/triangular/quantile":[],"@stdlib/stats/base/dists/triangular/skewness":[],"@stdlib/stats/base/dists/triangular/stdev":[],"@stdlib/stats/base/dists/triangular/ctor":[],"@stdlib/stats/base/dists/triangular/variance":[],"@stdlib/stats/base/dists/truncated-normal/pdf":[],"@stdlib/stats/base/dists/uniform/cdf":[],"@stdlib/stats/base/dists/uniform/entropy":[],"@stdlib/stats/base/dists/uniform/kurtosis":[],"@stdlib/stats/base/dists/uniform/logcdf":[],"@stdlib/stats/base/dists/uniform/logpdf":[],"@stdlib/stats/base/dists/uniform/mean":[],"@stdlib/stats/base/dists/uniform/median":[],"@stdlib/stats/base/dists/uniform/mgf":[],"@stdlib/stats/base/dists/uniform/pdf":[],"@stdlib/stats/base/dists/uniform/quantile":[],"@stdlib/stats/base/dists/uniform/skewness":[],"@stdlib/stats/base/dists/uniform/stdev":[],"@stdlib/stats/base/dists/uniform/ctor":[],"@stdlib/stats/base/dists/uniform/variance":[],"@stdlib/stats/base/dists/weibull/cdf":[],"@stdlib/stats/base/dists/weibull/entropy":[],"@stdlib/stats/base/dists/weibull/kurtosis":[],"@stdlib/stats/base/dists/weibull/logcdf":[],"@stdlib/stats/base/dists/weibull/logpdf":[],"@stdlib/stats/base/dists/weibull/mean":[],"@stdlib/stats/base/dists/weibull/median":[],"@stdlib/stats/base/dists/weibull/mgf":[],"@stdlib/stats/base/dists/weibull/mode":[],"@stdlib/stats/base/dists/weibull/pdf":[],"@stdlib/stats/base/dists/weibull/quantile":[],"@stdlib/stats/base/dists/weibull/skewness":[],"@stdlib/stats/base/dists/weibull/stdev":[],"@stdlib/stats/base/dists/weibull/variance":[],"@stdlib/stats/base/dists/weibull/ctor":[],"@stdlib/math/base/special/ellipe":["@stdlib/math/base/special/ellipj","@stdlib/math/base/special/ellipk"],"@stdlib/math/base/special/ellipj":["@stdlib/math/base/special/ellipe","@stdlib/math/base/special/ellipk"],"@stdlib/math/base/special/ellipk":["@stdlib/math/base/special/ellipe","@stdlib/math/base/special/ellipj"],"@stdlib/string/base/ends-with":["@stdlib/string/base/starts-with"],"@stdlib/math/base/utils/float64-epsilon-difference":["@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/relative-difference"],"@stdlib/math/base/special/erf":["@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/erfc":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcinv","@stdlib/math/base/special/erfcx"],"@stdlib/math/base/special/erfcinv":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcx"],"@stdlib/math/base/special/erfcx":["@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfcinv","@stdlib/math/base/special/erf","@stdlib/math/base/special/erfinv"],"@stdlib/math/base/special/erfinv":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/dirichlet-eta":[],"@stdlib/math/base/tools/evalpoly":["@stdlib/math/base/tools/evalrational"],"@stdlib/math/base/tools/evalrational":["@stdlib/math/base/tools/evalpoly"],"@stdlib/math/base/special/exp":["@stdlib/math/base/special/exp10","@stdlib/math/base/special/exp2","@stdlib/math/base/special/expm1","@stdlib/math/base/special/ln"],"@stdlib/math/base/special/exp2":["@stdlib/math/base/special/exp","@stdlib/math/base/special/exp10","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/exp10":["@stdlib/math/base/special/exp","@stdlib/math/base/special/exp2","@stdlib/math/base/special/log10"],"@stdlib/math/base/special/expit":["@stdlib/math/base/special/exp","@stdlib/math/base/special/logit"],"@stdlib/math/base/special/expm1":["@stdlib/math/base/special/exp","@stdlib/math/base/special/expm1rel"],"@stdlib/math/base/special/expm1rel":["@stdlib/math/base/special/exp","@stdlib/math/base/special/expm1"],"@stdlib/number/float64/base/exponent":["@stdlib/number/float32/base/exponent"],"@stdlib/number/float32/base/exponent":["@stdlib/number/float64/base/exponent"],"@stdlib/math/base/special/factorial":["@stdlib/math/base/special/factorialln"],"@stdlib/math/base/special/factorial2":["@stdlib/math/base/special/factorial"],"@stdlib/math/base/special/factorialln":["@stdlib/math/base/special/factorial"],"@stdlib/math/base/special/falling-factorial":["@stdlib/math/base/special/rising-factorial"],"@stdlib/math/base/special/fibonacci":["@stdlib/math/base/special/binet","@stdlib/math/base/special/fibonacci-index","@stdlib/math/base/special/lucas","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/fibonacci-index":["@stdlib/math/base/special/fibonacci"],"@stdlib/math/base/tools/fibpoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/lucaspoly"],"@stdlib/string/base/first-code-point":["@stdlib/string/base/first","@stdlib/string/base/first-grapheme-cluster","@stdlib/string/base/last-code-point","@stdlib/string/base/remove-first-code-point","@stdlib/string/first"],"@stdlib/string/base/first":["@stdlib/string/base/first-code-point","@stdlib/string/base/first-grapheme-cluster","@stdlib/string/base/last","@stdlib/string/base/remove-first","@stdlib/string/first"],"@stdlib/string/base/first-grapheme-cluster":["@stdlib/string/base/first","@stdlib/string/base/first-code-point","@stdlib/string/base/last-grapheme-cluster","@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string/first"],"@stdlib/math/base/special/flipsign":["@stdlib/math/base/special/copysign"],"@stdlib/math/base/special/flipsignf":["@stdlib/math/base/special/copysignf","@stdlib/math/base/special/flipsign"],"@stdlib/number/float32/base/to-int32":["@stdlib/number/float32/base/to-uint32"],"@stdlib/number/float32/base/to-uint32":["@stdlib/number/float32/base/to-int32"],"@stdlib/number/float64/base/to-float32":[],"@stdlib/number/float64/base/to-int32":["@stdlib/number/float64/base/to-uint32"],"@stdlib/number/float64/base/to-int64-bytes":["@stdlib/number/float64/base/to-int32"],"@stdlib/number/float64/base/to-uint32":["@stdlib/number/float64/base/to-int32"],"@stdlib/math/base/special/floor":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/round"],"@stdlib/math/base/special/floor2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/floor10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/floorb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floor","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/floorf":["@stdlib/math/base/special/ceilf","@stdlib/math/base/special/floor"],"@stdlib/math/base/special/floorn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floor","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/floorsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floor","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/truncsd"],"@stdlib/string/base/for-each":["@stdlib/string/base/for-each-code-point","@stdlib/string/base/for-each-grapheme-cluster","@stdlib/string/for-each"],"@stdlib/string/base/for-each-code-point":["@stdlib/string/base/for-each","@stdlib/string/base/for-each-grapheme-cluster","@stdlib/string/for-each"],"@stdlib/string/base/for-each-code-point-right":["@stdlib/string/base/for-each-code-point","@stdlib/string/base/for-each-right"],"@stdlib/string/base/for-each-grapheme-cluster":["@stdlib/string/base/for-each","@stdlib/string/base/for-each-code-point","@stdlib/string/for-each"],"@stdlib/string/base/for-each-right":["@stdlib/string/base/for-each","@stdlib/string/base/for-each-code-point-right"],"@stdlib/string/base/format-interpolate":["@stdlib/string/base/format-tokenize"],"@stdlib/string/base/format-tokenize":["@stdlib/string/base/format-interpolate"],"@stdlib/math/base/special/fresnel":["@stdlib/math/base/special/fresnelc","@stdlib/math/base/special/fresnels"],"@stdlib/math/base/special/fresnelc":["@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnels"],"@stdlib/math/base/special/fresnels":["@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnelc"],"@stdlib/math/base/special/frexp":["@stdlib/math/base/special/ldexp"],"@stdlib/number/float64/base/from-binary-string":["@stdlib/number/float32/base/from-binary-string","@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/float32/base/from-binary-string":["@stdlib/number/float32/base/to-binary-string","@stdlib/number/float64/base/from-binary-string"],"@stdlib/number/uint8/base/from-binary-string":["@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint8/base/to-binary-string"],"@stdlib/number/uint16/base/from-binary-string":["@stdlib/number/uint16/base/to-binary-string","@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint8/base/from-binary-string"],"@stdlib/number/uint32/base/from-binary-string":["@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint32/base/to-binary-string","@stdlib/number/uint8/base/from-binary-string"],"@stdlib/number/float64/base/from-int64-bytes":["@stdlib/number/float64/base/to-int64-bytes"],"@stdlib/number/float32/base/from-word":["@stdlib/number/float64/base/from-words"],"@stdlib/number/float64/base/from-words":["@stdlib/number/float32/base/from-word"],"@stdlib/math/base/special/gamma":["@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma1pm1":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma-delta-ratio":["@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/gammainc":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gammaincinv":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma-lanczos-sum":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled"],"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma-lanczos-sum"],"@stdlib/math/base/special/gammaln":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv"],"@stdlib/math/base/special/gammasgn":["@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/gcd":["@stdlib/math/base/special/lcm"],"@stdlib/number/float64/base/get-high-word":["@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/number/float64/base/get-low-word":["@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/math/base/special/hacovercos":["@stdlib/math/base/special/hacoversin","@stdlib/math/base/special/havercos"],"@stdlib/math/base/special/hacoversin":["@stdlib/math/base/special/hacovercos","@stdlib/math/base/special/haversin"],"@stdlib/math/base/special/havercos":["@stdlib/math/base/special/haversin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/haversin":["@stdlib/math/base/special/havercos","@stdlib/math/base/special/versin"],"@stdlib/string/base/headercase":["@stdlib/string/base/camelcase","@stdlib/string/base/pascalcase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/heaviside":["@stdlib/math/base/special/ramp"],"@stdlib/math/base/tools/hermitepoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/normhermitepoly"],"@stdlib/math/base/special/hypot":[],"@stdlib/math/base/special/hypotf":["@stdlib/math/base/special/hypot"],"@stdlib/math/base/special/identity":[],"@stdlib/math/base/special/identityf":["@stdlib/math/base/special/identityf"],"@stdlib/math/base/ops/imul":["@stdlib/math/base/ops/imuldw"],"@stdlib/math/base/ops/imuldw":["@stdlib/math/base/ops/imul"],"@stdlib/slice/base/int2slice":["@stdlib/slice/base/seq2slice","@stdlib/slice/base/str2slice"],"@stdlib/number/int32/base/to-uint32":["@stdlib/number/uint32/base/to-int32"],"@stdlib/math/base/special/inv":["@stdlib/math/base/special/pow"],"@stdlib/string/base/invcase":["@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/invf":["@stdlib/math/base/special/inv"],"@stdlib/math/base/assert/is-composite":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-prime"],"@stdlib/math/base/assert/is-coprime":["@stdlib/math/base/assert/is-composite","@stdlib/math/base/assert/is-prime","@stdlib/math/base/special/gcd"],"@stdlib/math/base/assert/is-even":["@stdlib/math/base/assert/is-odd"],"@stdlib/math/base/assert/int32-is-even":["@stdlib/math/base/assert/is-even","@stdlib/math/base/assert/int32-is-odd"],"@stdlib/math/base/assert/is-finite":["@stdlib/math/base/assert/is-infinite"],"@stdlib/math/base/assert/is-finitef":["@stdlib/math/base/assert/is-infinitef"],"@stdlib/math/base/assert/is-infinite":["@stdlib/math/base/assert/is-finite"],"@stdlib/math/base/assert/is-infinitef":["@stdlib/math/base/assert/is-finitef"],"@stdlib/math/base/assert/is-integer":[],"@stdlib/math/base/assert/is-nan":["@stdlib/math/base/assert/is-nanf"],"@stdlib/math/base/assert/is-nanf":["@stdlib/math/base/assert/is-nan"],"@stdlib/math/base/assert/is-negative-finite":["@stdlib/math/base/assert/is-positive-finite","@stdlib/math/base/assert/is-nonnegative-finite","@stdlib/math/base/assert/is-nonpositive-finite"],"@stdlib/math/base/assert/is-negative-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-negative-zero":["@stdlib/math/base/assert/is-positive-zero"],"@stdlib/math/base/assert/is-negative-zerof":["@stdlib/math/base/assert/is-negative-zero","@stdlib/math/base/assert/is-positive-zerof"],"@stdlib/math/base/assert/is-nonnegative-finite":["@stdlib/math/base/assert/is-negative-finite","@stdlib/math/base/assert/is-positive-finite","@stdlib/math/base/assert/is-nonpositive-finite"],"@stdlib/math/base/assert/is-nonnegative-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-nonpositive-finite":["@stdlib/math/base/assert/is-negative-finite","@stdlib/math/base/assert/is-positive-finite","@stdlib/math/base/assert/is-nonnegative-finite"],"@stdlib/math/base/assert/is-nonpositive-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-odd":["@stdlib/math/base/assert/is-even"],"@stdlib/math/base/assert/int32-is-odd":["@stdlib/math/base/assert/int32-is-even","@stdlib/math/base/assert/is-odd"],"@stdlib/math/base/assert/is-positive-finite":["@stdlib/math/base/assert/is-negative-finite","@stdlib/math/base/assert/is-nonnegative-finite","@stdlib/math/base/assert/is-nonpositive-finite"],"@stdlib/math/base/assert/is-positive-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-integer"],"@stdlib/math/base/assert/is-positive-zero":["@stdlib/math/base/assert/is-negative-zero"],"@stdlib/math/base/assert/is-positive-zerof":["@stdlib/math/base/assert/is-negative-zerof","@stdlib/math/base/assert/is-positive-zero"],"@stdlib/math/base/assert/uint32-is-pow2":[],"@stdlib/math/base/assert/is-prime":["@stdlib/math/base/assert/is-composite","@stdlib/math/base/assert/is-integer"],"@stdlib/math/base/assert/is-probability":[],"@stdlib/math/base/assert/is-safe-integer":[],"@stdlib/string/base/kebabcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/pascalcase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/kernel-betainc":["@stdlib/math/base/special/betainc"],"@stdlib/math/base/special/kernel-betaincinv":["@stdlib/math/base/special/betaincinv"],"@stdlib/math/base/special/kernel-cos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/kernel-tan"],"@stdlib/math/base/special/kernel-log1p":["@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/kernel-sin":["@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/kernel-tan","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/kernel-tan":["@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/kronecker-delta":["@stdlib/math/base/special/dirac-delta"],"@stdlib/math/base/special/kronecker-deltaf":["@stdlib/math/base/special/kronecker-delta"],"@stdlib/math/base/special/labs":["@stdlib/math/base/special/abs"],"@stdlib/string/base/last":["@stdlib/string/base/first","@stdlib/string/base/last-code-point","@stdlib/string/base/last-grapheme-cluster"],"@stdlib/string/base/last-code-point":["@stdlib/string/base/first-code-point","@stdlib/string/base/last-grapheme-cluster","@stdlib/string/base/last"],"@stdlib/string/base/last-grapheme-cluster":["@stdlib/string/base/first-grapheme-cluster","@stdlib/string/base/last-code-point","@stdlib/string/base/last"],"@stdlib/math/base/special/lcm":["@stdlib/math/base/special/gcd"],"@stdlib/math/base/special/ldexp":["@stdlib/math/base/special/frexp"],"@stdlib/string/base/left-pad":["@stdlib/string/base/right-pad"],"@stdlib/string/base/left-trim":["@stdlib/string/base/right-trim","@stdlib/string/base/trim"],"@stdlib/math/base/special/ln":["@stdlib/math/base/special/exp","@stdlib/math/base/special/log10","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/log":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log10","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/log1mexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log1pexp"],"@stdlib/math/base/special/log1p":["@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/log1pexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log1mexp","@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/log1pmx":["@stdlib/math/base/special/ln","@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/log2":["@stdlib/math/base/special/exp2","@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/log10":["@stdlib/math/base/special/exp10","@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/logaddexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln"],"@stdlib/math/base/special/logit":[],"@stdlib/string/base/lowercase":["@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/lucas":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negalucas"],"@stdlib/math/base/tools/lucaspoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/fibpoly"],"@stdlib/math/base/special/max":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/maxn","@stdlib/math/base/special/min"],"@stdlib/math/base/special/maxabs":["@stdlib/math/base/special/max","@stdlib/math/base/special/minabs"],"@stdlib/math/base/special/maxabsn":["@stdlib/math/base/special/maxn","@stdlib/math/base/special/maxabs","@stdlib/math/base/special/minabsn"],"@stdlib/math/base/special/maxn":["@stdlib/math/base/special/max","@stdlib/math/base/special/maxabsn","@stdlib/math/base/special/minn"],"@stdlib/math/base/special/min":["@stdlib/math/base/special/max","@stdlib/math/base/special/minabs","@stdlib/math/base/special/minn"],"@stdlib/math/base/special/minabs":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/min"],"@stdlib/math/base/special/minabsn":["@stdlib/math/base/special/maxabsn","@stdlib/math/base/special/minn","@stdlib/math/base/special/minabs"],"@stdlib/math/base/special/minmax":["@stdlib/math/base/special/max","@stdlib/math/base/special/min","@stdlib/math/base/special/minmaxabs"],"@stdlib/math/base/special/minmaxabs":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/minabs","@stdlib/math/base/special/minmax"],"@stdlib/math/base/special/minmaxabsn":["@stdlib/math/base/special/maxabsn","@stdlib/math/base/special/minabsn","@stdlib/math/base/special/minmaxn"],"@stdlib/math/base/special/minmaxn":["@stdlib/math/base/special/maxn","@stdlib/math/base/special/minn","@stdlib/math/base/special/minmaxabsn"],"@stdlib/math/base/special/minn":["@stdlib/math/base/special/maxn","@stdlib/math/base/special/min","@stdlib/math/base/special/minabsn"],"@stdlib/math/base/special/modf":[],"@stdlib/number/float64/base/mul":["@stdlib/number/float64/base/add","@stdlib/number/float64/base/div","@stdlib/number/float64/base/sub"],"@stdlib/number/float32/base/mul":["@stdlib/number/float32/base/add","@stdlib/number/float32/base/div","@stdlib/number/float64/base/mul","@stdlib/math/base/ops/subf"],"@stdlib/ndarray/base/ctor":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/base/unary":["@stdlib/ndarray/dispatch"],"@stdlib/ndarray/base/zeros":["@stdlib/ndarray/base/ctor","@stdlib/ndarray/base/zeros-like"],"@stdlib/ndarray/base/zeros-like":["@stdlib/ndarray/base/ctor","@stdlib/ndarray/base/zeros"],"@stdlib/math/base/special/negafibonacci":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negalucas"],"@stdlib/math/base/special/negalucas":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/lucas","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/nonfibonacci":["@stdlib/math/base/special/fibonacci"],"@stdlib/number/float64/base/normalize":["@stdlib/number/float32/base/normalize"],"@stdlib/number/float32/base/normalize":["@stdlib/number/float64/base/normalize"],"@stdlib/slice/base/normalize-multi-slice":["@stdlib/slice/base/normalize-slice"],"@stdlib/slice/base/normalize-slice":["@stdlib/slice/base/normalize-multi-slice"],"@stdlib/math/base/tools/normhermitepoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/hermitepoly"],"@stdlib/string/base/pascalcase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/pdiff":[],"@stdlib/math/base/special/pdifff":["@stdlib/math/base/special/pdiff"],"@stdlib/string/base/percent-encode":[],"@stdlib/math/base/special/polygamma":["@stdlib/math/base/special/trigamma","@stdlib/math/base/special/digamma","@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/pow":["@stdlib/math/base/special/exp","@stdlib/math/base/special/powm1"],"@stdlib/math/base/special/powm1":["@stdlib/math/base/special/pow"],"@stdlib/math/base/special/rad2deg":["@stdlib/math/base/special/deg2rad"],"@stdlib/math/base/special/rad2degf":["@stdlib/math/base/special/rad2deg"],"@stdlib/math/base/special/ramp":["@stdlib/math/base/special/heaviside"],"@stdlib/math/base/special/rampf":["@stdlib/math/base/special/ramp"],"@stdlib/random/base/arcsine":["@stdlib/random/array/arcsine","@stdlib/random/iter/arcsine","@stdlib/random/streams/arcsine","@stdlib/random/base/beta"],"@stdlib/random/base/bernoulli":["@stdlib/random/array/bernoulli","@stdlib/random/iter/bernoulli","@stdlib/random/streams/bernoulli","@stdlib/random/base/binomial"],"@stdlib/random/base/beta":["@stdlib/random/array/beta","@stdlib/random/iter/beta","@stdlib/random/streams/beta"],"@stdlib/random/base/betaprime":["@stdlib/random/array/betaprime","@stdlib/random/iter/betaprime","@stdlib/random/streams/betaprime"],"@stdlib/random/base/binomial":["@stdlib/random/array/binomial","@stdlib/random/iter/binomial","@stdlib/random/streams/binomial"],"@stdlib/random/base/box-muller":["@stdlib/random/iter/box-muller","@stdlib/random/streams/box-muller"],"@stdlib/random/base/cauchy":["@stdlib/random/array/cauchy","@stdlib/random/iter/cauchy","@stdlib/random/streams/cauchy"],"@stdlib/random/base/chi":["@stdlib/random/array/chi","@stdlib/random/iter/chi","@stdlib/random/streams/chi"],"@stdlib/random/base/chisquare":["@stdlib/random/array/chisquare","@stdlib/random/iter/chisquare","@stdlib/random/streams/chisquare"],"@stdlib/random/base/cosine":["@stdlib/random/array/cosine","@stdlib/random/iter/cosine","@stdlib/random/streams/cosine"],"@stdlib/random/base/discrete-uniform":["@stdlib/random/array/discrete-uniform","@stdlib/random/iter/discrete-uniform","@stdlib/random/streams/discrete-uniform"],"@stdlib/random/base/erlang":["@stdlib/random/array/erlang","@stdlib/random/iter/erlang","@stdlib/random/streams/erlang"],"@stdlib/random/base/exponential":["@stdlib/random/array/exponential","@stdlib/random/iter/exponential","@stdlib/random/streams/exponential"],"@stdlib/random/base/f":["@stdlib/random/array/f","@stdlib/random/iter/f","@stdlib/random/streams/f"],"@stdlib/random/base/frechet":["@stdlib/random/array/frechet","@stdlib/random/iter/frechet","@stdlib/random/streams/frechet"],"@stdlib/random/base/gamma":["@stdlib/random/array/gamma","@stdlib/random/iter/gamma","@stdlib/random/streams/gamma"],"@stdlib/random/base/geometric":["@stdlib/random/array/geometric","@stdlib/random/iter/geometric","@stdlib/random/streams/geometric"],"@stdlib/random/base/gumbel":["@stdlib/random/array/gumbel","@stdlib/random/iter/gumbel","@stdlib/random/streams/gumbel"],"@stdlib/random/base/hypergeometric":["@stdlib/random/array/hypergeometric","@stdlib/random/iter/hypergeometric","@stdlib/random/streams/hypergeometric"],"@stdlib/random/base/improved-ziggurat":["@stdlib/random/iter/improved-ziggurat","@stdlib/random/streams/improved-ziggurat"],"@stdlib/random/base/invgamma":["@stdlib/random/array/invgamma","@stdlib/random/iter/invgamma","@stdlib/random/streams/invgamma"],"@stdlib/random/base/kumaraswamy":["@stdlib/random/array/kumaraswamy","@stdlib/random/iter/kumaraswamy","@stdlib/random/streams/kumaraswamy"],"@stdlib/random/base/laplace":["@stdlib/random/array/laplace","@stdlib/random/iter/laplace","@stdlib/random/streams/laplace"],"@stdlib/random/base/levy":["@stdlib/random/array/levy","@stdlib/random/iter/levy","@stdlib/random/streams/levy"],"@stdlib/random/base/logistic":["@stdlib/random/array/logistic","@stdlib/random/iter/logistic","@stdlib/random/streams/logistic"],"@stdlib/random/base/lognormal":["@stdlib/random/array/lognormal","@stdlib/random/iter/lognormal","@stdlib/random/streams/lognormal"],"@stdlib/random/base/minstd":["@stdlib/random/array/minstd","@stdlib/random/iter/minstd","@stdlib/random/streams/minstd","@stdlib/random/base/minstd-shuffle","@stdlib/random/base/mt19937","@stdlib/random/base/randi"],"@stdlib/random/base/minstd-shuffle":["@stdlib/random/array/minstd-shuffle","@stdlib/random/iter/minstd-shuffle","@stdlib/random/streams/minstd-shuffle","@stdlib/random/base/minstd","@stdlib/random/base/mt19937","@stdlib/random/base/randi"],"@stdlib/random/base/mt19937":["@stdlib/random/array/mt19937","@stdlib/random/iter/mt19937","@stdlib/random/streams/mt19937","@stdlib/random/base/minstd","@stdlib/random/base/randi"],"@stdlib/random/base/negative-binomial":["@stdlib/random/array/negative-binomial","@stdlib/random/iter/negative-binomial","@stdlib/random/streams/negative-binomial"],"@stdlib/random/base/normal":["@stdlib/random/array/normal","@stdlib/random/iter/normal","@stdlib/random/streams/normal"],"@stdlib/random/base/pareto-type1":["@stdlib/random/array/pareto-type1","@stdlib/random/iter/pareto-type1","@stdlib/random/streams/pareto-type1"],"@stdlib/random/base/poisson":["@stdlib/random/array/poisson","@stdlib/random/iter/poisson","@stdlib/random/streams/poisson"],"@stdlib/random/base/randi":["@stdlib/random/iter/randi","@stdlib/random/streams/randi","@stdlib/random/base/minstd","@stdlib/random/base/minstd-shuffle","@stdlib/random/base/mt19937"],"@stdlib/random/base/randn":["@stdlib/random/iter/randn","@stdlib/random/streams/randn","@stdlib/random/base/improved-ziggurat","@stdlib/random/base/randu"],"@stdlib/random/base/randu":["@stdlib/random/array/randu","@stdlib/random/iter/randu","@stdlib/random/streams/randu","@stdlib/random/base/discrete-uniform","@stdlib/random/base/randn"],"@stdlib/random/base/rayleigh":["@stdlib/random/array/rayleigh","@stdlib/random/iter/rayleigh","@stdlib/random/streams/rayleigh"],"@stdlib/random/base/t":["@stdlib/random/array/t","@stdlib/random/iter/t","@stdlib/random/streams/t"],"@stdlib/random/base/triangular":["@stdlib/random/array/triangular","@stdlib/random/iter/triangular","@stdlib/random/streams/triangular"],"@stdlib/random/base/uniform":["@stdlib/random/array/uniform","@stdlib/random/iter/uniform","@stdlib/random/streams/uniform","@stdlib/random/base/discrete-uniform","@stdlib/random/base/randu"],"@stdlib/random/base/weibull":["@stdlib/random/array/weibull","@stdlib/random/iter/weibull","@stdlib/random/streams/weibull"],"@stdlib/math/base/special/rcbrt":["@stdlib/math/base/special/cbrt"],"@stdlib/math/base/special/rcbrtf":["@stdlib/math/base/special/rcbrt","@stdlib/math/base/special/cbrtf"],"@stdlib/math/base/utils/relative-difference":["@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/float64-epsilon-difference"],"@stdlib/string/base/remove-first":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string/base/remove-last"],"@stdlib/string/base/remove-first-code-point":["@stdlib/string/base/remove-last-code-point","@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string/base/remove-first"],"@stdlib/string/base/remove-first-grapheme-cluster":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/string/base/remove-first"],"@stdlib/string/base/remove-last":["@stdlib/string/base/remove-last-code-point","@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/string/base/remove-first"],"@stdlib/string/base/remove-last-code-point":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/string/base/remove-last"],"@stdlib/string/base/remove-last-grapheme-cluster":["@stdlib/string/base/remove-first-code-point","@stdlib/string/base/remove-last-code-point","@stdlib/string/base/remove-last"],"@stdlib/math/base/special/rempio2":[],"@stdlib/string/base/repeat":[],"@stdlib/string/base/replace":["@stdlib/string/base/replace-after","@stdlib/string/base/replace-before","@stdlib/string/base/replace-after-last","@stdlib/string/base/replace-before-last"],"@stdlib/string/base/replace-after":["@stdlib/string/base/replace-after-last","@stdlib/string/base/replace-before","@stdlib/string/base/replace-before-last"],"@stdlib/string/base/replace-after-last":["@stdlib/string/base/replace-after","@stdlib/string/base/replace-before-last","@stdlib/string/base/replace-before"],"@stdlib/string/base/replace-before":["@stdlib/string/base/replace-after","@stdlib/string/base/replace-before-last","@stdlib/string/base/replace-after-last"],"@stdlib/string/base/replace-before-last":["@stdlib/string/base/replace-after-last","@stdlib/string/base/replace-after","@stdlib/string/base/replace-before"],"@stdlib/string/base/reverse":["@stdlib/string/base/reverse-code-points","@stdlib/string/base/reverse-grapheme-clusters"],"@stdlib/string/base/reverse-code-points":["@stdlib/string/base/reverse-grapheme-clusters","@stdlib/string/base/reverse"],"@stdlib/string/base/reverse-grapheme-clusters":["@stdlib/string/base/reverse-code-points","@stdlib/string/base/reverse"],"@stdlib/string/base/right-pad":["@stdlib/string/base/left-pad"],"@stdlib/string/base/right-trim":["@stdlib/string/base/left-trim"],"@stdlib/math/base/special/rising-factorial":["@stdlib/math/base/special/falling-factorial"],"@stdlib/number/uint32/base/rotl":["@stdlib/number/uint32/base/rotr"],"@stdlib/number/uint32/base/rotr":["@stdlib/number/uint32/base/rotl"],"@stdlib/math/base/special/round":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floor","@stdlib/math/base/special/roundn","@stdlib/math/base/special/trunc"],"@stdlib/math/base/special/round2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/round10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/roundb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorb","@stdlib/math/base/special/round","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/roundn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorn","@stdlib/math/base/special/round","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/roundsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/round","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/special/rsqrt":["@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/rsqrtf":["@stdlib/math/base/special/rsqrt","@stdlib/math/base/special/sqrtf"],"@stdlib/slice/base/sargs2multislice":["@stdlib/slice/base/args2multislice","@stdlib/slice/base/seq2multislice"],"@stdlib/ndarray/base/from-scalar":["@stdlib/ndarray/array","@stdlib/ndarray/base/ctor","@stdlib/ndarray/ctor"],"@stdlib/math/base/special/secd":["@stdlib/math/base/special/cosd","@stdlib/math/base/special/cos"],"@stdlib/slice/base/seq2multislice":["@stdlib/slice/base/seq2slice","@stdlib/slice/base/sargs2multislice"],"@stdlib/slice/base/seq2slice":["@stdlib/slice/base/seq2multislice","@stdlib/slice/base/slice2seq"],"@stdlib/number/float64/base/set-high-word":["@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/set-low-word"],"@stdlib/number/float64/base/set-low-word":["@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/math/base/special/sici":[],"@stdlib/number/float64/base/signbit":["@stdlib/number/float32/base/signbit"],"@stdlib/number/float32/base/signbit":["@stdlib/number/float64/base/signbit"],"@stdlib/number/float32/base/significand":[],"@stdlib/math/base/special/signum":[],"@stdlib/math/base/special/signumf":["@stdlib/math/base/special/signum"],"@stdlib/math/base/special/sin":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sinpi","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/sinc":["@stdlib/math/base/special/sin"],"@stdlib/math/base/special/sincos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin","@stdlib/math/base/special/sincospi"],"@stdlib/math/base/special/sincospi":["@stdlib/math/base/special/cospi","@stdlib/math/base/special/sincos","@stdlib/math/base/special/sinpi"],"@stdlib/math/base/special/sinh":["@stdlib/math/base/special/cosh","@stdlib/math/base/special/sin","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/sinpi":["@stdlib/math/base/special/sin"],"@stdlib/slice/base/slice2seq":["@stdlib/slice/base/seq2slice"],"@stdlib/slice/base/length":["@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice/base/reduced-dimensions","@stdlib/slice/base/shape"],"@stdlib/slice/base/nonreduced-dimensions":["@stdlib/slice/base/length","@stdlib/slice/base/reduced-dimensions","@stdlib/slice/base/shape"],"@stdlib/slice/base/reduced-dimensions":["@stdlib/slice/base/length","@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice/base/shape"],"@stdlib/slice/base/shape":["@stdlib/slice/base/length","@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice/base/reduced-dimensions"],"@stdlib/string/base/snakecase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/stickycase","@stdlib/string/base/uppercase"],"@stdlib/math/base/special/spence":[],"@stdlib/math/base/special/sqrt":["@stdlib/math/base/special/cbrt","@stdlib/math/base/special/rsqrt"],"@stdlib/math/base/special/sqrt1pm1":["@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/sqrtf":["@stdlib/math/base/special/cbrtf","@stdlib/math/base/special/rsqrtf","@stdlib/math/base/special/sqrt"],"@stdlib/math/base/special/sqrtpi":["@stdlib/math/base/special/sqrt"],"@stdlib/string/base/startcase":["@stdlib/string/base/capitalize","@stdlib/string/base/lowercase","@stdlib/string/base/uppercase"],"@stdlib/string/base/starts-with":["@stdlib/string/base/ends-with"],"@stdlib/string/base/stickycase":["@stdlib/string/base/camelcase","@stdlib/string/base/lowercase","@stdlib/string/base/snakecase","@stdlib/string/base/uppercase"],"@stdlib/strided/base/binary":["@stdlib/strided/base/dmap2","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/smap2","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/strided/base/binary-dtype-signatures":["@stdlib/strided/base/binary-signature-callbacks"],"@stdlib/strided/base/binary-signature-callbacks":["@stdlib/strided/base/binary-dtype-signatures"],"@stdlib/blas/base/ccopy":["@stdlib/blas/base/cswap"],"@stdlib/strided/base/cmap":["@stdlib/strided/base/zmap","@stdlib/strided/base/unary"],"@stdlib/blas/base/cswap":["@stdlib/blas/base/ccopy"],"@stdlib/stats/base/cumax":["@stdlib/stats/base/cumin","@stdlib/stats/strided/dcumax","@stdlib/stats/base/scumax"],"@stdlib/stats/base/cumaxabs":["@stdlib/stats/base/cumax","@stdlib/stats/base/cuminabs","@stdlib/stats/strided/dcumaxabs","@stdlib/stats/base/scumaxabs"],"@stdlib/stats/base/cumin":["@stdlib/stats/base/cumax","@stdlib/stats/base/dcumin","@stdlib/stats/base/scumin"],"@stdlib/stats/base/cuminabs":["@stdlib/stats/base/cumaxabs","@stdlib/stats/base/cumin","@stdlib/stats/strided/dcuminabs","@stdlib/stats/base/scuminabs"],"@stdlib/math/strided/special/dabs":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/sabs"],"@stdlib/math/strided/special/dabs2":["@stdlib/math/strided/special/abs2","@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/sabs2"],"@stdlib/blas/ext/base/dapx":["@stdlib/blas/ext/base/gapx","@stdlib/blas/ext/base/sapx"],"@stdlib/blas/ext/base/dapxsum":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/sapxsum"],"@stdlib/blas/ext/base/dapxsumkbn":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gapxsumkbn","@stdlib/blas/ext/base/sapxsumkbn"],"@stdlib/blas/ext/base/dapxsumkbn2":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gapxsumkbn2","@stdlib/blas/ext/base/sapxsumkbn2"],"@stdlib/blas/ext/base/dapxsumors":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gapxsumors","@stdlib/blas/ext/base/sapxsumors"],"@stdlib/blas/ext/base/dapxsumpw":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas/ext/base/sapxsumpw"],"@stdlib/blas/base/dasum":["@stdlib/blas/base/daxpy","@stdlib/blas/base/gasum","@stdlib/blas/base/sasum","@stdlib/blas/ext/base/dsum"],"@stdlib/blas/ext/base/dasumpw":["@stdlib/blas/base/dasum","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gasumpw","@stdlib/blas/ext/base/sasumpw"],"@stdlib/blas/base/daxpy":["@stdlib/blas/base/dasum","@stdlib/blas/base/gaxpy","@stdlib/blas/base/saxpy"],"@stdlib/math/strided/special/dcbrt":["@stdlib/math/strided/special/cbrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/scbrt"],"@stdlib/math/strided/special/dceil":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/sceil"],"@stdlib/blas/base/dcopy":["@stdlib/blas/base/dswap","@stdlib/blas/base/gcopy","@stdlib/blas/base/scopy"],"@stdlib/stats/strided/dcumax":["@stdlib/stats/base/cumax","@stdlib/stats/base/dcumin","@stdlib/stats/base/scumax"],"@stdlib/stats/strided/dcumaxabs":["@stdlib/stats/base/cumaxabs","@stdlib/stats/strided/dcumax","@stdlib/stats/strided/dcuminabs","@stdlib/stats/base/scumaxabs"],"@stdlib/stats/base/dcumin":["@stdlib/stats/base/cumin","@stdlib/stats/strided/dcumax","@stdlib/stats/base/scumin"],"@stdlib/stats/strided/dcuminabs":["@stdlib/stats/base/cuminabs","@stdlib/stats/strided/dcumaxabs","@stdlib/stats/base/dcumin","@stdlib/stats/base/scuminabs"],"@stdlib/blas/ext/base/dcusum":["@stdlib/blas/ext/base/dcusumpw","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/scusum"],"@stdlib/blas/ext/base/dcusumkbn":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas/ext/base/scusumkbn"],"@stdlib/blas/ext/base/dcusumkbn2":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas/ext/base/scusumkbn2"],"@stdlib/blas/ext/base/dcusumors":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumors","@stdlib/blas/ext/base/scusumors"],"@stdlib/blas/ext/base/dcusumpw":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusumpw"],"@stdlib/math/strided/special/ddeg2rad":["@stdlib/math/strided/special/deg2rad","@stdlib/math/strided/special/sdeg2rad"],"@stdlib/blas/base/ddot":["@stdlib/blas/base/dsdot","@stdlib/blas/base/gdot","@stdlib/blas/base/sdot","@stdlib/blas/base/sdsdot","@stdlib/blas/ddot"],"@stdlib/blas/ext/base/dfill":["@stdlib/blas/ext/base/gfill","@stdlib/blas/ext/base/sfill"],"@stdlib/math/strided/special/dfloor":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/sfloor"],"@stdlib/math/strided/special/dinv":["@stdlib/math/strided/special/inv","@stdlib/math/strided/special/sinv"],"@stdlib/strided/base/dmap":["@stdlib/strided/base/smap","@stdlib/strided/base/unary"],"@stdlib/strided/base/dmap2":["@stdlib/strided/base/smap2","@stdlib/strided/base/binary"],"@stdlib/stats/strided/dmax":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/max","@stdlib/stats/base/smax"],"@stdlib/stats/strided/dmaxabs":["@stdlib/stats/strided/dmax","@stdlib/stats/strided/dminabs","@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/smaxabs"],"@stdlib/stats/strided/dmaxabssorted":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/smaxabssorted"],"@stdlib/stats/strided/dmaxsorted":["@stdlib/stats/strided/dmax","@stdlib/stats/strided/dminsorted","@stdlib/stats/base/maxsorted","@stdlib/stats/base/smaxsorted"],"@stdlib/stats/base/dmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/mean","@stdlib/stats/base/smean"],"@stdlib/stats/strided/dmeankbn":["@stdlib/stats/base/dmean","@stdlib/stats/base/meankbn","@stdlib/stats/base/smeankbn"],"@stdlib/stats/strided/dmeankbn2":["@stdlib/stats/base/dmean","@stdlib/stats/base/meankbn2","@stdlib/stats/base/smeankbn2"],"@stdlib/stats/strided/dmeanli":["@stdlib/stats/base/dmean","@stdlib/stats/strided/dmeanlipw","@stdlib/stats/base/smeanli"],"@stdlib/stats/strided/dmeanlipw":["@stdlib/stats/base/dmean","@stdlib/stats/strided/dmeanli","@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/smeanlipw"],"@stdlib/stats/strided/dmeanors":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/smeanors"],"@stdlib/stats/base/dmeanpn":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/smeanpn"],"@stdlib/stats/strided/dmeanpw":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanpw","@stdlib/stats/base/meanpw","@stdlib/stats/base/smeanpw"],"@stdlib/stats/base/dmeanstdev":["@stdlib/stats/base/dmean","@stdlib/stats/base/dmeanvar","@stdlib/stats/base/dstdev"],"@stdlib/stats/base/dmeanstdevpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/dmeanstdev","@stdlib/stats/base/dmeanvarpn","@stdlib/stats/base/dstdevpn"],"@stdlib/stats/base/dmeanvar":["@stdlib/stats/base/dmean","@stdlib/stats/base/dvariance"],"@stdlib/stats/base/dmeanvarpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/dmeanstdevpn","@stdlib/stats/base/dmeanvar","@stdlib/stats/base/dvariancepn"],"@stdlib/stats/strided/dmeanwd":["@stdlib/stats/base/dmean","@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/smeanwd"],"@stdlib/stats/strided/dmediansorted":["@stdlib/stats/base/dmean","@stdlib/stats/base/mediansorted","@stdlib/stats/base/smediansorted"],"@stdlib/stats/strided/dmidrange":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dmean","@stdlib/stats/strided/dmin","@stdlib/stats/base/drange","@stdlib/stats/base/smidrange"],"@stdlib/stats/strided/dmin":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/min","@stdlib/stats/base/smin"],"@stdlib/stats/strided/dminabs":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dmaxabs","@stdlib/stats/base/dnanminabs","@stdlib/stats/base/minabs","@stdlib/stats/base/sminabs"],"@stdlib/stats/strided/dminsorted":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/minsorted","@stdlib/stats/base/sminsorted"],"@stdlib/math/strided/special/dmskabs":["@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/dmskabs2","@stdlib/math/strided/special/smskabs"],"@stdlib/math/strided/special/dmskabs2":["@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/dmskabs","@stdlib/math/strided/special/smskabs2"],"@stdlib/math/strided/special/dmskcbrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/dmsksqrt","@stdlib/math/strided/special/smskcbrt"],"@stdlib/math/strided/special/dmskceil":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/dmskfloor","@stdlib/math/strided/special/dmsktrunc","@stdlib/math/strided/special/smskceil"],"@stdlib/math/strided/special/dmskdeg2rad":["@stdlib/math/strided/special/ddeg2rad","@stdlib/math/strided/special/dmskdeg2rad","@stdlib/math/strided/special/smskdeg2rad"],"@stdlib/math/strided/special/dmskfloor":["@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/dmskceil","@stdlib/math/strided/special/dmsktrunc","@stdlib/math/strided/special/smskfloor"],"@stdlib/math/strided/special/dmskinv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/smskinv"],"@stdlib/strided/base/dmskmap":["@stdlib/strided/base/dmap","@stdlib/strided/base/dmskmap2","@stdlib/strided/base/mskunary","@stdlib/strided/base/smskmap"],"@stdlib/strided/base/dmskmap2":["@stdlib/strided/base/dmap2","@stdlib/strided/base/dmskmap","@stdlib/strided/base/smskmap2"],"@stdlib/stats/base/dmskmax":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dmskmin","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/mskmax","@stdlib/stats/base/smskmax"],"@stdlib/stats/base/dmskmin":["@stdlib/stats/strided/dmin","@stdlib/stats/base/dmskmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/mskmin","@stdlib/stats/base/smskmin"],"@stdlib/math/strided/special/dmskramp":["@stdlib/math/strided/special/dramp","@stdlib/math/strided/special/smskramp"],"@stdlib/stats/base/dmskrange":["@stdlib/stats/base/dmskmax","@stdlib/stats/base/dmskmin","@stdlib/stats/base/dnanrange","@stdlib/stats/base/drange","@stdlib/stats/base/mskrange","@stdlib/stats/base/smskrange"],"@stdlib/math/strided/special/dmskrsqrt":["@stdlib/math/strided/special/dmsksqrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/smskrsqrt"],"@stdlib/math/strided/special/dmsksqrt":["@stdlib/math/strided/special/dmskcbrt","@stdlib/math/strided/special/dmskrsqrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/smsksqrt"],"@stdlib/math/strided/special/dmsktrunc":["@stdlib/math/strided/special/dmskceil","@stdlib/math/strided/special/dmskfloor","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/smsktrunc"],"@stdlib/blas/ext/base/dnanasum":["@stdlib/blas/base/dasum","@stdlib/blas/ext/base/dasumpw"],"@stdlib/blas/ext/base/dnanasumors":["@stdlib/blas/ext/base/dnanasum"],"@stdlib/stats/strided/dnanmax":["@stdlib/stats/strided/dmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/nanmax","@stdlib/stats/base/snanmax"],"@stdlib/stats/strided/dnanmaxabs":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanminabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/snanmaxabs"],"@stdlib/stats/strided/dnanmean":["@stdlib/stats/base/dmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/dnanmeanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/strided/dnanmean","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/dnanmeanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/strided/dnanmean","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/dnanmeanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/strided/dnanmean"],"@stdlib/stats/base/dnanmeanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/strided/dnanmean","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/snanmeanwd"],"@stdlib/stats/base/dnanmin":["@stdlib/stats/strided/dmin","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/dnanminabs":["@stdlib/stats/strided/dminabs","@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/dnanmin","@stdlib/stats/base/nanminabs","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/dnanmskmax":["@stdlib/stats/base/dmskmax","@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/dnanmskmin":["@stdlib/stats/base/dmskmin","@stdlib/stats/base/dnanmin","@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/dnanmskrange":["@stdlib/stats/base/dmskrange","@stdlib/stats/base/dnanrange","@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/nanmskrange","@stdlib/stats/base/snanmskrange"],"@stdlib/blas/ext/base/dnannsum":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dsum"],"@stdlib/blas/ext/base/dnannsumkbn":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dnannsumpw","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gnannsumkbn"],"@stdlib/blas/ext/base/dnannsumkbn2":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dnannsumpw","@stdlib/blas/ext/base/dsumkbn2"],"@stdlib/blas/ext/base/dnannsumors":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas/ext/base/dnannsumpw","@stdlib/blas/ext/base/dsumors"],"@stdlib/blas/ext/base/dnannsumpw":["@stdlib/blas/ext/base/dnannsum","@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dsumpw"],"@stdlib/stats/base/dnanrange":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/dnanmin","@stdlib/stats/base/drange","@stdlib/stats/base/nanrange","@stdlib/stats/base/snanrange"],"@stdlib/stats/base/dnanstdev":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/dstdev","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdev"],"@stdlib/stats/base/dnanstdevch":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/dstdevch","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/snanstdevch"],"@stdlib/stats/base/dnanstdevpn":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/dstdevpn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/snanstdevpn"],"@stdlib/stats/base/dnanstdevtk":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/dstdevtk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/snanstdevtk"],"@stdlib/stats/base/dnanstdevwd":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/dstdevwd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/snanstdevwd"],"@stdlib/stats/base/dnanstdevyc":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/dstdevyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/snanstdevyc"],"@stdlib/blas/ext/base/dnansum":["@stdlib/stats/strided/dnanmean","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/gnansum"],"@stdlib/blas/ext/base/dnansumkbn":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/snansumkbn"],"@stdlib/blas/ext/base/dnansumkbn2":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/snansumkbn2"],"@stdlib/blas/ext/base/dnansumors":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/snansumors"],"@stdlib/blas/ext/base/dnansumpw":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/stats/base/dnanvariance":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dvariance","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariance"],"@stdlib/stats/base/dnanvariancech":["@stdlib/stats/base/dvariancech","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/snanvariancech"],"@stdlib/stats/base/dnanvariancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/snanvariancepn"],"@stdlib/stats/base/dnanvariancetk":["@stdlib/stats/base/dvariancetk","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/snanvariancetk"],"@stdlib/stats/base/dnanvariancewd":["@stdlib/stats/base/dvariancewd","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/snanvariancewd"],"@stdlib/stats/base/dnanvarianceyc":["@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/snanvarianceyc"],"@stdlib/blas/base/dnrm2":["@stdlib/blas/base/gnrm2","@stdlib/blas/base/snrm2"],"@stdlib/math/strided/special/dramp":["@stdlib/math/strided/special/ramp","@stdlib/math/strided/special/sramp"],"@stdlib/stats/base/drange":["@stdlib/stats/strided/dmax","@stdlib/stats/strided/dmin","@stdlib/stats/base/dnanrange","@stdlib/stats/base/range","@stdlib/stats/base/srange"],"@stdlib/blas/ext/base/drev":["@stdlib/blas/ext/base/grev","@stdlib/blas/ext/base/srev"],"@stdlib/math/strided/special/drsqrt":["@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/rsqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/blas/ext/base/dsapxsum":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/sapxsum"],"@stdlib/blas/ext/base/dsapxsumpw":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/dsapxsum","@stdlib/blas/ext/base/dssumpw","@stdlib/blas/ext/base/sapxsumpw"],"@stdlib/blas/base/dscal":["@stdlib/blas/base/daxpy","@stdlib/blas/base/gscal","@stdlib/blas/base/sscal","@stdlib/blas/base/saxpy"],"@stdlib/blas/base/dsdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/sdot","@stdlib/blas/base/sdsdot"],"@stdlib/stats/base/dsem":["@stdlib/stats/base/dstdev"],"@stdlib/stats/base/dsemch":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevch"],"@stdlib/stats/base/dsempn":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevpn"],"@stdlib/stats/base/dsemtk":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevtk"],"@stdlib/stats/base/dsemwd":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevwd"],"@stdlib/stats/base/dsemyc":["@stdlib/stats/base/dsem","@stdlib/stats/base/dstdevyc"],"@stdlib/stats/base/dsmean":["@stdlib/stats/base/dmean","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/mean","@stdlib/stats/base/sdsmean","@stdlib/stats/base/smean"],"@stdlib/stats/base/dsmeanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/base/dsmean","@stdlib/stats/base/dsnanmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/smeanors"],"@stdlib/stats/base/dsmeanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/dsmean","@stdlib/stats/base/dsnanmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/smeanpn"],"@stdlib/stats/base/dsmeanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/dsmean","@stdlib/stats/base/meanpw","@stdlib/stats/base/smeanpw"],"@stdlib/stats/base/dsmeanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/base/dsmean","@stdlib/stats/base/dsnanmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/smeanwd"],"@stdlib/stats/base/dsnanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/dsmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/dsnanmeanors":["@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/dsmeanors","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/dsnanmeanpn":["@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/dsmeanpn","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/dsnanmeanwd":["@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/dsmeanwd","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/snanmeanwd"],"@stdlib/blas/ext/base/dsnannsumors":["@stdlib/blas/ext/base/dnannsumors","@stdlib/blas/ext/base/dsnansumors","@stdlib/blas/ext/base/dssumors"],"@stdlib/blas/ext/base/dsnansum":["@stdlib/stats/base/dsnanmean","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/sdsnansum","@stdlib/blas/ext/base/snansum"],"@stdlib/blas/ext/base/dsnansumors":["@stdlib/stats/base/dsnanmeanors","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dssumors","@stdlib/blas/ext/base/snansumors"],"@stdlib/blas/ext/base/dsnansumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dssumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/blas/ext/base/dsort2hp":["@stdlib/blas/ext/base/dsorthp","@stdlib/blas/ext/base/gsort2hp","@stdlib/blas/ext/base/ssort2hp"],"@stdlib/blas/ext/base/dsort2ins":["@stdlib/blas/ext/base/dsortins","@stdlib/blas/ext/base/gsort2ins","@stdlib/blas/ext/base/ssort2ins"],"@stdlib/blas/ext/base/dsort2sh":["@stdlib/blas/ext/base/dsortsh","@stdlib/blas/ext/base/gsort2sh","@stdlib/blas/ext/base/ssort2sh"],"@stdlib/blas/ext/base/dsorthp":["@stdlib/blas/ext/base/dsort2hp","@stdlib/blas/ext/base/gsorthp","@stdlib/blas/ext/base/ssorthp"],"@stdlib/blas/ext/base/dsortins":["@stdlib/blas/ext/base/dsort2ins","@stdlib/blas/ext/base/gsortins","@stdlib/blas/ext/base/ssortins"],"@stdlib/blas/ext/base/dsortsh":["@stdlib/blas/ext/base/dsort2sh","@stdlib/blas/ext/base/gsortsh","@stdlib/blas/ext/base/ssortsh"],"@stdlib/math/strided/special/dsqrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/drsqrt","@stdlib/math/strided/special/sqrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/blas/ext/base/dssum":["@stdlib/blas/ext/base/dsnansum","@stdlib/blas/ext/base/sdssum","@stdlib/blas/ext/base/ssum","@stdlib/stats/base/dsmean"],"@stdlib/blas/ext/base/dssumors":["@stdlib/blas/ext/base/dsnansumors","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/dssumpw":["@stdlib/blas/ext/base/dsnansumpw","@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/ssumpw"],"@stdlib/stats/base/dstdev":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/dvariance","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdev"],"@stdlib/stats/base/dstdevch":["@stdlib/stats/base/dnanstdevch","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancech","@stdlib/stats/base/sstdevch","@stdlib/stats/base/stdevch"],"@stdlib/stats/base/dstdevpn":["@stdlib/stats/base/dnanstdevpn","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancepn","@stdlib/stats/base/sstdevpn","@stdlib/stats/base/stdevpn"],"@stdlib/stats/base/dstdevtk":["@stdlib/stats/base/dnanstdevtk","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancetk","@stdlib/stats/base/sstdevtk","@stdlib/stats/base/stdevtk"],"@stdlib/stats/base/dstdevwd":["@stdlib/stats/base/dnanstdevwd","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvariancewd","@stdlib/stats/base/sstdevwd","@stdlib/stats/base/stdevwd"],"@stdlib/stats/base/dstdevyc":["@stdlib/stats/base/dnanstdevyc","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/sstdevyc","@stdlib/stats/base/stdevyc"],"@stdlib/blas/ext/base/dsum":["@stdlib/blas/base/dasum","@stdlib/stats/base/dmean","@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/gsum"],"@stdlib/blas/ext/base/dsumkbn":["@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/dsumkbn2":["@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/dsumors":["@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/dsumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumpw"],"@stdlib/stats/base/dsvariance":["@stdlib/stats/base/dvariance","@stdlib/stats/base/variance","@stdlib/stats/base/svariance"],"@stdlib/stats/base/dsvariancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/dsvariance","@stdlib/stats/base/variancepn","@stdlib/stats/base/svariancepn"],"@stdlib/blas/base/dswap":["@stdlib/blas/base/dcopy","@stdlib/blas/base/gswap","@stdlib/blas/base/sswap","@stdlib/blas/dswap"],"@stdlib/math/strided/special/dtrunc":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/trunc","@stdlib/math/strided/special/strunc"],"@stdlib/strided/base/dtype-enum2str":["@stdlib/strided/base/dtype-str2enum"],"@stdlib/strided/base/dtype-resolve-enum":["@stdlib/strided/base/dtype-resolve-str"],"@stdlib/strided/base/dtype-resolve-str":["@stdlib/strided/base/dtype-resolve-enum"],"@stdlib/strided/base/dtype-str2enum":["@stdlib/strided/base/dtype-enum2str"],"@stdlib/stats/base/dvariance":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/dstdev","@stdlib/stats/base/dvarm","@stdlib/stats/base/svariance","@stdlib/stats/base/variance"],"@stdlib/stats/base/dvariancech":["@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/dstdevch","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancech","@stdlib/stats/base/variancech"],"@stdlib/stats/base/dvariancepn":["@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/dstdevpn","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancepn","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/dvariancetk":["@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/dstdevtk","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancetk","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/dvariancewd":["@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/dstdevwd","@stdlib/stats/base/dvariance","@stdlib/stats/base/svariancewd","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/dvarianceyc":["@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/dstdevyc","@stdlib/stats/base/dvariance","@stdlib/stats/base/svarianceyc","@stdlib/stats/base/varianceyc"],"@stdlib/stats/base/dvarm":["@stdlib/stats/base/dvariance"],"@stdlib/stats/base/dvarmpn":["@stdlib/stats/base/dvarm"],"@stdlib/stats/base/dvarmtk":["@stdlib/stats/base/dvarm"],"@stdlib/strided/base/function-object":[],"@stdlib/blas/ext/base/gapx":["@stdlib/blas/ext/base/dapx","@stdlib/blas/ext/base/sapx"],"@stdlib/blas/ext/base/gapxsum":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/sapxsum"],"@stdlib/blas/ext/base/gapxsumkbn":["@stdlib/blas/ext/base/dapxsumkbn","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/sapxsumkbn"],"@stdlib/blas/ext/base/gapxsumkbn2":["@stdlib/blas/ext/base/dapxsumkbn2","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/sapxsumkbn2"],"@stdlib/blas/ext/base/gapxsumors":["@stdlib/blas/ext/base/dapxsumors","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/sapxsumors"],"@stdlib/blas/ext/base/gapxsumpw":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/sapxsumpw"],"@stdlib/blas/base/gasum":["@stdlib/blas/base/dasum","@stdlib/blas/base/sasum"],"@stdlib/blas/ext/base/gasumpw":["@stdlib/blas/base/gasum","@stdlib/blas/ext/base/dasumpw","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/sasumpw"],"@stdlib/blas/base/gaxpy":["@stdlib/blas/base/daxpy","@stdlib/blas/base/saxpy"],"@stdlib/blas/base/gcopy":["@stdlib/blas/base/dcopy","@stdlib/blas/base/scopy"],"@stdlib/blas/ext/base/gcusum":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusum"],"@stdlib/blas/ext/base/gcusumkbn":["@stdlib/blas/ext/base/dcusumkbn","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas/ext/base/scusumkbn"],"@stdlib/blas/ext/base/gcusumkbn2":["@stdlib/blas/ext/base/dcusumkbn2","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas/ext/base/scusumkbn2"],"@stdlib/blas/ext/base/gcusumors":["@stdlib/blas/ext/base/dcusumors","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusumors"],"@stdlib/blas/ext/base/gcusumpw":["@stdlib/blas/ext/base/dcusumpw","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/scusumpw"],"@stdlib/blas/base/gdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/sdot","@stdlib/blas/gdot"],"@stdlib/blas/ext/base/gfill":["@stdlib/blas/ext/base/dfill","@stdlib/blas/ext/base/sfill"],"@stdlib/blas/ext/base/gfill-by":["@stdlib/blas/ext/base/gfill"],"@stdlib/blas/ext/base/gnannsumkbn":["@stdlib/blas/ext/base/dnannsumkbn"],"@stdlib/blas/ext/base/gnansum":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/gsum","@stdlib/stats/base/nanmean"],"@stdlib/blas/ext/base/gnansumkbn":["@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/snansumkbn"],"@stdlib/blas/ext/base/gnansumkbn2":["@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/snansumkbn2"],"@stdlib/blas/ext/base/gnansumors":["@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/snansumors"],"@stdlib/blas/ext/base/gnansumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/blas/base/gnrm2":["@stdlib/blas/base/dnrm2","@stdlib/blas/base/snrm2"],"@stdlib/blas/ext/base/grev":["@stdlib/blas/ext/base/drev","@stdlib/blas/ext/base/srev"],"@stdlib/blas/base/gscal":["@stdlib/blas/base/dscal","@stdlib/blas/base/gaxpy","@stdlib/blas/base/sscal"],"@stdlib/blas/ext/base/gsort2hp":["@stdlib/blas/ext/base/dsort2hp","@stdlib/blas/ext/base/gsorthp","@stdlib/blas/ext/base/ssort2hp"],"@stdlib/blas/ext/base/gsort2ins":["@stdlib/blas/ext/base/dsort2ins","@stdlib/blas/ext/base/gsortins","@stdlib/blas/ext/base/ssort2ins"],"@stdlib/blas/ext/base/gsort2sh":["@stdlib/blas/ext/base/dsort2sh","@stdlib/blas/ext/base/gsortsh","@stdlib/blas/ext/base/ssort2sh"],"@stdlib/blas/ext/base/gsorthp":["@stdlib/blas/ext/base/dsorthp","@stdlib/blas/ext/base/gsort2hp","@stdlib/blas/ext/base/ssorthp"],"@stdlib/blas/ext/base/gsortins":["@stdlib/blas/ext/base/dsortins","@stdlib/blas/ext/base/gsort2ins","@stdlib/blas/ext/base/ssortins"],"@stdlib/blas/ext/base/gsortsh":["@stdlib/blas/ext/base/dsortsh","@stdlib/blas/ext/base/gsort2sh","@stdlib/blas/ext/base/ssortsh"],"@stdlib/blas/ext/base/gsum":["@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/ssum","@stdlib/stats/base/mean"],"@stdlib/blas/ext/base/gsumkbn":["@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/gsumkbn2":["@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/gsumors":["@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/gsumpw":["@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/gsum","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/base/gswap":["@stdlib/blas/base/dswap","@stdlib/blas/base/gcopy","@stdlib/blas/base/sswap","@stdlib/blas/gswap"],"@stdlib/strided/base/map-by":["@stdlib/strided/base/map-by2","@stdlib/strided/base/unary"],"@stdlib/strided/base/map-by2":["@stdlib/strided/base/map-by","@stdlib/strided/base/binary"],"@stdlib/stats/base/max":["@stdlib/stats/strided/dmax","@stdlib/stats/base/min","@stdlib/stats/base/nanmax","@stdlib/stats/base/smax"],"@stdlib/stats/base/maxabs":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/base/max","@stdlib/stats/base/minabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/smaxabs"],"@stdlib/stats/base/max-by":["@stdlib/stats/strided/dmax","@stdlib/stats/base/max","@stdlib/stats/base/min-by","@stdlib/stats/base/nanmax-by","@stdlib/stats/base/smax"],"@stdlib/stats/base/maxsorted":["@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/max","@stdlib/stats/base/minsorted","@stdlib/stats/base/smaxsorted"],"@stdlib/strided/base/max-view-buffer-index":[],"@stdlib/stats/base/mean":["@stdlib/stats/base/dmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/smean"],"@stdlib/stats/base/meankbn":["@stdlib/stats/strided/dmeankbn","@stdlib/stats/base/mean","@stdlib/stats/base/smeankbn"],"@stdlib/stats/base/meankbn2":["@stdlib/stats/strided/dmeankbn2","@stdlib/stats/base/mean","@stdlib/stats/base/smeankbn2"],"@stdlib/stats/base/meanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/base/mean","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/smeanors"],"@stdlib/stats/base/meanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/mean","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/smeanpn"],"@stdlib/stats/base/meanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/mean","@stdlib/stats/base/smeanpw"],"@stdlib/stats/base/meanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/base/mean","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/smeanwd"],"@stdlib/stats/base/mediansorted":["@stdlib/stats/strided/dmediansorted","@stdlib/stats/base/mean","@stdlib/stats/base/smediansorted"],"@stdlib/strided/base/meta-data-props":[],"@stdlib/stats/base/min":["@stdlib/stats/strided/dmin","@stdlib/stats/base/max","@stdlib/stats/base/nanmin","@stdlib/stats/base/smin"],"@stdlib/stats/base/minabs":["@stdlib/stats/strided/dminabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/min","@stdlib/stats/base/nanminabs","@stdlib/stats/base/sminabs"],"@stdlib/stats/base/min-by":["@stdlib/stats/strided/dmin","@stdlib/stats/base/max-by","@stdlib/stats/base/min","@stdlib/stats/base/nanmin-by","@stdlib/stats/base/smin"],"@stdlib/stats/base/minsorted":["@stdlib/stats/strided/dminsorted","@stdlib/stats/base/maxsorted","@stdlib/stats/base/min","@stdlib/stats/base/sminsorted"],"@stdlib/strided/base/min-view-buffer-index":["@stdlib/strided/base/offset-view"],"@stdlib/stats/base/mskmax":["@stdlib/stats/base/dmskmax","@stdlib/stats/base/max","@stdlib/stats/base/mskmin","@stdlib/stats/base/nanmax","@stdlib/stats/base/smskmax"],"@stdlib/stats/base/mskmin":["@stdlib/stats/base/dmskmin","@stdlib/stats/base/min","@stdlib/stats/base/mskmax","@stdlib/stats/base/nanmin","@stdlib/stats/base/smskmin"],"@stdlib/stats/base/mskrange":["@stdlib/stats/base/dmskrange","@stdlib/stats/base/range","@stdlib/stats/base/mskmax","@stdlib/stats/base/mskmin","@stdlib/stats/base/nanrange","@stdlib/stats/base/smskrange"],"@stdlib/strided/base/mskunary":["@stdlib/strided/base/dmskmap","@stdlib/strided/base/smskmap","@stdlib/strided/base/unary"],"@stdlib/strided/base/mskunary-dtype-signatures":["@stdlib/strided/base/mskunary-signature-callbacks"],"@stdlib/strided/base/mskunary-signature-callbacks":["@stdlib/strided/base/mskunary-dtype-signatures"],"@stdlib/stats/base/nanmax":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/max","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/nanmaxabs":["@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanminabs","@stdlib/stats/base/snanmaxabs"],"@stdlib/stats/base/nanmax-by":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/max-by","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanmin-by","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/nanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/mean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/nanmeanors":["@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/nanmeanpn":["@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/nanmeanwd":["@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/nanmean","@stdlib/stats/base/snanmeanwd"],"@stdlib/stats/base/nanmin":["@stdlib/stats/base/dnanmin","@stdlib/stats/base/min","@stdlib/stats/base/nanmax","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/nanminabs":["@stdlib/stats/base/dnanminabs","@stdlib/stats/base/minabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/nanmin-by":["@stdlib/stats/base/dnanmin","@stdlib/stats/base/min-by","@stdlib/stats/base/nanmax-by","@stdlib/stats/base/nanmin","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/nanmskmax":["@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/mskmax","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/nanmskmin":["@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/mskmin","@stdlib/stats/base/nanmin","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/nanmskrange":["@stdlib/stats/base/dnanmskrange","@stdlib/stats/base/mskrange","@stdlib/stats/base/nanrange","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/snanmskrange"],"@stdlib/stats/base/nanrange":["@stdlib/stats/base/dnanrange","@stdlib/stats/base/nanmax","@stdlib/stats/base/nanmin","@stdlib/stats/base/range","@stdlib/stats/base/snanrange"],"@stdlib/stats/base/nanrange-by":["@stdlib/stats/base/dnanrange","@stdlib/stats/base/nanmax-by","@stdlib/stats/base/nanmin-by","@stdlib/stats/base/nanrange","@stdlib/stats/base/range-by","@stdlib/stats/base/snanrange"],"@stdlib/stats/base/nanstdev":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanstdev","@stdlib/stats/base/stdev"],"@stdlib/stats/base/nanstdevch":["@stdlib/stats/base/dnanstdevch","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevch","@stdlib/stats/base/stdevch"],"@stdlib/stats/base/nanstdevpn":["@stdlib/stats/base/dnanstdevpn","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevpn","@stdlib/stats/base/stdevpn"],"@stdlib/stats/base/nanstdevtk":["@stdlib/stats/base/dnanstdevtk","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevtk","@stdlib/stats/base/stdevtk"],"@stdlib/stats/base/nanstdevwd":["@stdlib/stats/base/dnanstdevwd","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevwd","@stdlib/stats/base/stdevwd"],"@stdlib/stats/base/nanstdevyc":["@stdlib/stats/base/dnanstdevyc","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanstdevyc","@stdlib/stats/base/stdevyc"],"@stdlib/stats/base/nanvariance":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanvariance","@stdlib/stats/base/variance"],"@stdlib/stats/base/nanvariancech":["@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancech","@stdlib/stats/base/variancech"],"@stdlib/stats/base/nanvariancepn":["@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancepn","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/nanvariancetk":["@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancetk","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/nanvariancewd":["@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvariancewd","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/nanvarianceyc":["@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanvarianceyc","@stdlib/stats/base/varianceyc"],"@stdlib/strided/base/nullary":["@stdlib/strided/base/binary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/strided/base/offset-view":["@stdlib/strided/base/min-view-buffer-index"],"@stdlib/strided/base/quaternary":["@stdlib/strided/base/binary","@stdlib/strided/base/nullary","@stdlib/strided/base/quinary","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/strided/base/quinary":["@stdlib/strided/base/binary","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/ternary","@stdlib/strided/base/unary"],"@stdlib/stats/base/range":["@stdlib/stats/base/drange","@stdlib/stats/base/max","@stdlib/stats/base/min","@stdlib/stats/base/nanrange","@stdlib/stats/base/srange"],"@stdlib/stats/base/range-by":["@stdlib/stats/base/drange","@stdlib/stats/base/max-by","@stdlib/stats/base/min-by","@stdlib/stats/base/nanrange-by","@stdlib/stats/base/range","@stdlib/stats/base/srange"],"@stdlib/strided/base/reinterpret-complex":["@stdlib/strided/base/reinterpret-complex128","@stdlib/strided/base/reinterpret-complex64"],"@stdlib/strided/base/reinterpret-complex64":["@stdlib/strided/base/reinterpret-complex","@stdlib/strided/base/reinterpret-complex128"],"@stdlib/strided/base/reinterpret-complex128":["@stdlib/strided/base/reinterpret-complex","@stdlib/strided/base/reinterpret-complex64"],"@stdlib/math/strided/special/sabs":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/sabs2"],"@stdlib/math/strided/special/sabs2":["@stdlib/math/strided/special/abs2","@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/sabs"],"@stdlib/blas/ext/base/sapx":["@stdlib/blas/ext/base/dapx","@stdlib/blas/ext/base/gapx"],"@stdlib/blas/ext/base/sapxsum":["@stdlib/blas/ext/base/dapxsum","@stdlib/blas/ext/base/gapxsum","@stdlib/blas/ext/base/sapxsumpw","@stdlib/blas/ext/base/ssum"],"@stdlib/blas/ext/base/sapxsumkbn":["@stdlib/blas/ext/base/dapxsumkbn","@stdlib/blas/ext/base/gapxsumkbn","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/sapxsumkbn2":["@stdlib/blas/ext/base/dapxsumkbn2","@stdlib/blas/ext/base/gapxsumkbn2","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/sapxsumors":["@stdlib/blas/ext/base/dapxsumors","@stdlib/blas/ext/base/gapxsumors","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/sapxsumpw":["@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/base/sasum":["@stdlib/blas/base/dasum","@stdlib/blas/base/gasum"],"@stdlib/blas/ext/base/sasumpw":["@stdlib/blas/base/sasum","@stdlib/blas/ext/base/dasumpw","@stdlib/blas/ext/base/gasumpw","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/base/saxpy":["@stdlib/blas/base/daxpy","@stdlib/blas/base/gaxpy"],"@stdlib/math/strided/special/scbrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/cbrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/math/strided/special/sceil":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/sfloor","@stdlib/math/strided/special/strunc"],"@stdlib/blas/base/scopy":["@stdlib/blas/base/dcopy","@stdlib/blas/base/gcopy","@stdlib/blas/base/sswap"],"@stdlib/stats/base/scumax":["@stdlib/stats/base/cumax","@stdlib/stats/strided/dcumax","@stdlib/stats/base/scumin"],"@stdlib/stats/base/scumaxabs":["@stdlib/stats/base/cumaxabs","@stdlib/stats/strided/dcumaxabs","@stdlib/stats/base/scumax","@stdlib/stats/base/scuminabs"],"@stdlib/stats/base/scumin":["@stdlib/stats/base/cumin","@stdlib/stats/base/dcumin","@stdlib/stats/base/scumax"],"@stdlib/stats/base/scuminabs":["@stdlib/stats/base/cuminabs","@stdlib/stats/strided/dcuminabs","@stdlib/stats/base/scumaxabs","@stdlib/stats/base/scumin"],"@stdlib/blas/ext/base/scusum":["@stdlib/blas/ext/base/dcusum","@stdlib/blas/ext/base/gcusum","@stdlib/blas/ext/base/scusumpw"],"@stdlib/blas/ext/base/scusumkbn":["@stdlib/blas/ext/base/dcusumkbn","@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas/ext/base/scusum","@stdlib/blas/ext/base/scusumkbn2"],"@stdlib/blas/ext/base/scusumkbn2":["@stdlib/blas/ext/base/dcusumkbn2","@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas/ext/base/scusum","@stdlib/blas/ext/base/scusumkbn"],"@stdlib/blas/ext/base/scusumors":["@stdlib/blas/ext/base/dcusumors","@stdlib/blas/ext/base/gcusumors","@stdlib/blas/ext/base/scusum"],"@stdlib/blas/ext/base/scusumpw":["@stdlib/blas/ext/base/dcusumpw","@stdlib/blas/ext/base/gcusumpw","@stdlib/blas/ext/base/scusum"],"@stdlib/math/strided/special/sdeg2rad":["@stdlib/math/strided/special/ddeg2rad","@stdlib/math/strided/special/deg2rad"],"@stdlib/blas/base/sdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/dsdot","@stdlib/blas/base/sdsdot","@stdlib/blas/sdot"],"@stdlib/blas/ext/base/sdsapxsum":["@stdlib/blas/ext/base/dsapxsum","@stdlib/blas/ext/base/sapxsum","@stdlib/blas/ext/base/sdssum"],"@stdlib/blas/ext/base/sdsapxsumpw":["@stdlib/blas/ext/base/dsapxsumpw","@stdlib/blas/ext/base/sapxsumpw","@stdlib/blas/ext/base/sdsapxsum","@stdlib/blas/ext/base/sdssumpw"],"@stdlib/blas/base/sdsdot":["@stdlib/blas/base/ddot","@stdlib/blas/base/dsdot","@stdlib/blas/base/sdot"],"@stdlib/stats/base/sdsmean":["@stdlib/stats/base/dmean","@stdlib/stats/base/dsmean","@stdlib/stats/base/mean","@stdlib/stats/base/sdsnanmean","@stdlib/stats/base/smean"],"@stdlib/stats/base/sdsmeanors":["@stdlib/stats/base/sdsmean","@stdlib/stats/base/sdsnanmeanors"],"@stdlib/stats/base/sdsnanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/dsnanmean","@stdlib/stats/base/nanmean","@stdlib/stats/base/sdsmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/sdsnanmeanors":["@stdlib/stats/base/sdsmeanors","@stdlib/stats/base/sdsnanmean"],"@stdlib/blas/ext/base/sdsnansum":["@stdlib/blas/ext/base/dsnansum","@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/gnansum","@stdlib/blas/ext/base/sdssum","@stdlib/blas/ext/base/snansum"],"@stdlib/blas/ext/base/sdsnansumpw":["@stdlib/blas/ext/base/dsnansumpw","@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/sdsnansum","@stdlib/blas/ext/base/sdssumpw","@stdlib/blas/ext/base/snansumpw"],"@stdlib/blas/ext/base/sdssum":["@stdlib/blas/ext/base/dssum","@stdlib/blas/ext/base/dsum","@stdlib/blas/ext/base/sdsnansum","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/gsum"],"@stdlib/blas/ext/base/sdssumpw":["@stdlib/blas/ext/base/dssumpw","@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/sdsnansumpw","@stdlib/blas/ext/base/sdssum","@stdlib/blas/ext/base/ssumpw","@stdlib/blas/ext/base/gsumpw"],"@stdlib/blas/ext/base/sfill":["@stdlib/blas/ext/base/dfill","@stdlib/blas/ext/base/gfill"],"@stdlib/math/strided/special/sfloor":["@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/sceil","@stdlib/math/strided/special/strunc"],"@stdlib/math/strided/special/sinv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/inv"],"@stdlib/strided/base/smap":["@stdlib/strided/base/dmap","@stdlib/strided/base/unary"],"@stdlib/strided/base/smap2":["@stdlib/strided/base/dmap2","@stdlib/strided/base/binary"],"@stdlib/stats/base/smax":["@stdlib/stats/strided/dmax","@stdlib/stats/base/max","@stdlib/stats/base/smin","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/smaxabs":["@stdlib/stats/strided/dmaxabs","@stdlib/stats/base/maxabs","@stdlib/stats/base/smax","@stdlib/stats/base/sminabs","@stdlib/stats/base/snanmaxabs"],"@stdlib/stats/base/smaxabssorted":["@stdlib/stats/strided/dmaxabssorted","@stdlib/stats/base/smaxabs","@stdlib/stats/base/smaxsorted"],"@stdlib/stats/base/smaxsorted":["@stdlib/stats/strided/dmaxsorted","@stdlib/stats/base/maxsorted","@stdlib/stats/base/smax","@stdlib/stats/base/sminsorted"],"@stdlib/stats/base/smean":["@stdlib/stats/base/dmean","@stdlib/stats/base/dsmean","@stdlib/stats/base/mean","@stdlib/stats/base/sdsmean","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/smeankbn":["@stdlib/stats/strided/dmeankbn","@stdlib/stats/base/meankbn","@stdlib/stats/base/smean"],"@stdlib/stats/base/smeankbn2":["@stdlib/stats/strided/dmeankbn2","@stdlib/stats/base/meankbn2","@stdlib/stats/base/smean"],"@stdlib/stats/base/smeanli":["@stdlib/stats/strided/dmeanli","@stdlib/stats/base/smean","@stdlib/stats/base/smeanlipw"],"@stdlib/stats/base/smeanlipw":["@stdlib/stats/strided/dmeanlipw","@stdlib/stats/base/smean","@stdlib/stats/base/smeanli"],"@stdlib/stats/base/smeanors":["@stdlib/stats/strided/dmeanors","@stdlib/stats/base/meanors","@stdlib/stats/base/smean","@stdlib/stats/base/snanmeanors"],"@stdlib/stats/base/smeanpn":["@stdlib/stats/base/dmeanpn","@stdlib/stats/base/meanpn","@stdlib/stats/base/smean","@stdlib/stats/base/snanmeanpn"],"@stdlib/stats/base/smeanpw":["@stdlib/stats/strided/dmeanpw","@stdlib/stats/base/meanpw","@stdlib/stats/base/smean"],"@stdlib/stats/base/smeanwd":["@stdlib/stats/strided/dmeanwd","@stdlib/stats/base/meanwd","@stdlib/stats/base/smean","@stdlib/stats/base/snanmeanwd"],"@stdlib/stats/base/smediansorted":["@stdlib/stats/strided/dmediansorted","@stdlib/stats/base/mediansorted","@stdlib/stats/base/smean"],"@stdlib/stats/base/smidrange":["@stdlib/stats/strided/dmidrange","@stdlib/stats/base/smax","@stdlib/stats/base/smean","@stdlib/stats/base/smin","@stdlib/stats/base/srange"],"@stdlib/stats/base/smin":["@stdlib/stats/strided/dmin","@stdlib/stats/base/min","@stdlib/stats/base/smax","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/sminabs":["@stdlib/stats/strided/dminabs","@stdlib/stats/base/minabs","@stdlib/stats/base/smaxabs","@stdlib/stats/base/smin","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/sminsorted":["@stdlib/stats/strided/dminsorted","@stdlib/stats/base/minsorted","@stdlib/stats/base/smaxsorted","@stdlib/stats/base/smin"],"@stdlib/math/strided/special/smskabs":["@stdlib/math/strided/special/dmskabs","@stdlib/math/strided/special/sabs","@stdlib/math/strided/special/smskabs2"],"@stdlib/math/strided/special/smskabs2":["@stdlib/math/strided/special/dmskabs2","@stdlib/math/strided/special/sabs2","@stdlib/math/strided/special/smskabs"],"@stdlib/math/strided/special/smskcbrt":["@stdlib/math/strided/special/dmskcbrt","@stdlib/math/strided/special/scbrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/math/strided/special/smskceil":["@stdlib/math/strided/special/dmskceil","@stdlib/math/strided/special/sceil","@stdlib/math/strided/special/smskfloor","@stdlib/math/strided/special/smsktrunc"],"@stdlib/math/strided/special/smskdeg2rad":["@stdlib/math/strided/special/dmskdeg2rad","@stdlib/math/strided/special/sdeg2rad"],"@stdlib/math/strided/special/smskfloor":["@stdlib/math/strided/special/dmskfloor","@stdlib/math/strided/special/sfloor","@stdlib/math/strided/special/smskceil","@stdlib/math/strided/special/smsktrunc"],"@stdlib/math/strided/special/smskinv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/dmskinv"],"@stdlib/strided/base/smskmap":["@stdlib/strided/base/dmskmap","@stdlib/strided/base/mskunary","@stdlib/strided/base/smap","@stdlib/strided/base/smskmap2"],"@stdlib/strided/base/smskmap2":["@stdlib/strided/base/dmskmap2","@stdlib/strided/base/smap2","@stdlib/strided/base/smskmap"],"@stdlib/stats/base/smskmax":["@stdlib/stats/base/dmskmax","@stdlib/stats/base/mskmax","@stdlib/stats/base/smax","@stdlib/stats/base/smskmin","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/smskmin":["@stdlib/stats/base/dmskmin","@stdlib/stats/base/mskmin","@stdlib/stats/base/smin","@stdlib/stats/base/smskmax","@stdlib/stats/base/snanmin","@stdlib/stats/base/snanmskmin"],"@stdlib/math/strided/special/smskramp":["@stdlib/math/strided/special/dmskramp","@stdlib/math/strided/special/sramp"],"@stdlib/stats/base/smskrange":["@stdlib/stats/base/dmskrange","@stdlib/stats/base/mskrange","@stdlib/stats/base/smskmax","@stdlib/stats/base/smskmin","@stdlib/stats/base/snanrange","@stdlib/stats/base/srange"],"@stdlib/math/strided/special/smskrsqrt":["@stdlib/math/strided/special/dmskrsqrt","@stdlib/math/strided/special/smsksqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/math/strided/special/smsksqrt":["@stdlib/math/strided/special/dmsksqrt","@stdlib/math/strided/special/smskcbrt","@stdlib/math/strided/special/smskrsqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/math/strided/special/smsktrunc":["@stdlib/math/strided/special/dmsktrunc","@stdlib/math/strided/special/smskceil","@stdlib/math/strided/special/smskfloor","@stdlib/math/strided/special/strunc"],"@stdlib/stats/base/snanmax":["@stdlib/stats/strided/dnanmax","@stdlib/stats/base/nanmax","@stdlib/stats/base/smax","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/snanmaxabs":["@stdlib/stats/strided/dnanmaxabs","@stdlib/stats/base/nanmaxabs","@stdlib/stats/base/smaxabs","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanminabs"],"@stdlib/stats/base/snanmean":["@stdlib/stats/strided/dnanmean","@stdlib/stats/base/smean","@stdlib/stats/base/nanmean"],"@stdlib/stats/base/snanmeanors":["@stdlib/stats/base/dnanmeanors","@stdlib/stats/base/nanmeanors","@stdlib/stats/base/smeanors","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/snanmeanpn":["@stdlib/stats/base/dnanmeanpn","@stdlib/stats/base/nanmeanpn","@stdlib/stats/base/smeanpn","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/snanmeanwd":["@stdlib/stats/base/dnanmeanwd","@stdlib/stats/base/nanmeanwd","@stdlib/stats/base/smeanwd","@stdlib/stats/base/snanmean"],"@stdlib/stats/base/snanmin":["@stdlib/stats/base/dnanmin","@stdlib/stats/base/nanmin","@stdlib/stats/base/smin","@stdlib/stats/base/snanmax"],"@stdlib/stats/base/snanminabs":["@stdlib/stats/base/dnanminabs","@stdlib/stats/base/nanminabs","@stdlib/stats/base/sminabs","@stdlib/stats/base/snanmaxabs","@stdlib/stats/base/snanmin"],"@stdlib/stats/base/snanmskmax":["@stdlib/stats/base/dnanmskmax","@stdlib/stats/base/nanmskmax","@stdlib/stats/base/smskmax","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/snanmskmin":["@stdlib/stats/base/dnanmskmin","@stdlib/stats/base/nanmskmin","@stdlib/stats/base/smskmin","@stdlib/stats/base/snanmin","@stdlib/stats/base/snanmskmax"],"@stdlib/stats/base/snanmskrange":["@stdlib/stats/base/dnanmskrange","@stdlib/stats/base/nanmskrange","@stdlib/stats/base/smskrange","@stdlib/stats/base/snanrange","@stdlib/stats/base/snanmskmax","@stdlib/stats/base/snanmskmin"],"@stdlib/stats/base/snanrange":["@stdlib/stats/base/dnanrange","@stdlib/stats/base/nanrange","@stdlib/stats/base/snanmax","@stdlib/stats/base/snanmin","@stdlib/stats/base/srange"],"@stdlib/stats/base/snanstdev":["@stdlib/stats/base/dnanstdev","@stdlib/stats/base/nanstdev","@stdlib/stats/base/snanvariance","@stdlib/stats/base/sstdev"],"@stdlib/stats/base/snanstdevch":["@stdlib/stats/base/dnanstdevch","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancech","@stdlib/stats/base/sstdevch"],"@stdlib/stats/base/snanstdevpn":["@stdlib/stats/base/dnanstdevpn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancepn","@stdlib/stats/base/sstdevpn"],"@stdlib/stats/base/snanstdevtk":["@stdlib/stats/base/dnanstdevtk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancetk","@stdlib/stats/base/sstdevtk"],"@stdlib/stats/base/snanstdevwd":["@stdlib/stats/base/dnanstdevwd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvariancewd","@stdlib/stats/base/sstdevwd"],"@stdlib/stats/base/snanstdevyc":["@stdlib/stats/base/dnanstdevyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/snanstdev","@stdlib/stats/base/snanvarianceyc","@stdlib/stats/base/sstdevyc"],"@stdlib/blas/ext/base/snansum":["@stdlib/blas/ext/base/dnansum","@stdlib/blas/ext/base/gnansum","@stdlib/stats/base/snanmean","@stdlib/blas/ext/base/ssum"],"@stdlib/blas/ext/base/snansumkbn":["@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssumkbn"],"@stdlib/blas/ext/base/snansumkbn2":["@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssumkbn2"],"@stdlib/blas/ext/base/snansumors":["@stdlib/blas/ext/base/dnansumors","@stdlib/blas/ext/base/gnansumors","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/ext/base/snansumpw":["@stdlib/blas/ext/base/dnansumpw","@stdlib/blas/ext/base/gnansumpw","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/stats/base/snanvariance":["@stdlib/stats/base/dnanvariance","@stdlib/stats/base/nanvariance","@stdlib/stats/base/snanstdev","@stdlib/stats/base/svariance"],"@stdlib/stats/base/snanvariancech":["@stdlib/stats/base/dnanvariancech","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/snanstdevch","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancech"],"@stdlib/stats/base/snanvariancepn":["@stdlib/stats/base/dnanvariancepn","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/snanstdevpn","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancepn"],"@stdlib/stats/base/snanvariancetk":["@stdlib/stats/base/dnanvariancetk","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/snanstdevtk","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancetk"],"@stdlib/stats/base/snanvariancewd":["@stdlib/stats/base/dnanvariancewd","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/snanstdevwd","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svariancewd"],"@stdlib/stats/base/snanvarianceyc":["@stdlib/stats/base/dnanvarianceyc","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/snanstdevyc","@stdlib/stats/base/snanvariance","@stdlib/stats/base/svarianceyc"],"@stdlib/blas/base/snrm2":["@stdlib/blas/base/dnrm2","@stdlib/blas/base/gnrm2"],"@stdlib/math/strided/special/sramp":["@stdlib/math/strided/special/dramp","@stdlib/math/strided/special/ramp"],"@stdlib/stats/base/srange":["@stdlib/stats/base/drange","@stdlib/stats/base/smax","@stdlib/stats/base/smin","@stdlib/stats/base/snanrange","@stdlib/stats/base/range"],"@stdlib/blas/ext/base/srev":["@stdlib/blas/ext/base/drev","@stdlib/blas/ext/base/grev"],"@stdlib/math/strided/special/srsqrt":["@stdlib/math/strided/special/drsqrt","@stdlib/math/strided/special/rsqrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/blas/base/sscal":["@stdlib/blas/base/daxpy","@stdlib/blas/base/dscal","@stdlib/blas/base/gscal","@stdlib/blas/base/saxpy"],"@stdlib/blas/ext/base/ssort2hp":["@stdlib/blas/ext/base/dsort2hp","@stdlib/blas/ext/base/gsort2hp","@stdlib/blas/ext/base/ssorthp"],"@stdlib/blas/ext/base/ssort2ins":["@stdlib/blas/ext/base/dsort2ins","@stdlib/blas/ext/base/gsort2ins","@stdlib/blas/ext/base/ssortins"],"@stdlib/blas/ext/base/ssort2sh":["@stdlib/blas/ext/base/dsort2sh","@stdlib/blas/ext/base/gsort2sh","@stdlib/blas/ext/base/ssortsh"],"@stdlib/blas/ext/base/ssorthp":["@stdlib/blas/ext/base/dsorthp","@stdlib/blas/ext/base/gsorthp","@stdlib/blas/ext/base/ssort2hp"],"@stdlib/blas/ext/base/ssortins":["@stdlib/blas/ext/base/dsortins","@stdlib/blas/ext/base/gsortins","@stdlib/blas/ext/base/ssort2ins"],"@stdlib/blas/ext/base/ssortsh":["@stdlib/blas/ext/base/dsortsh","@stdlib/blas/ext/base/gsortsh","@stdlib/blas/ext/base/ssort2sh"],"@stdlib/math/strided/special/ssqrt":["@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/scbrt","@stdlib/math/strided/special/sqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/stats/base/sstdev":["@stdlib/stats/base/dstdev","@stdlib/stats/base/snanstdev","@stdlib/stats/base/stdev","@stdlib/stats/base/svariance"],"@stdlib/stats/base/sstdevch":["@stdlib/stats/base/dstdevch","@stdlib/stats/base/snanstdevch","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevch","@stdlib/stats/base/svariancech"],"@stdlib/stats/base/sstdevpn":["@stdlib/stats/base/dstdevpn","@stdlib/stats/base/snanstdevpn","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevpn","@stdlib/stats/base/svariancepn"],"@stdlib/stats/base/sstdevtk":["@stdlib/stats/base/dstdevtk","@stdlib/stats/base/snanstdevtk","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevtk","@stdlib/stats/base/svariancetk"],"@stdlib/stats/base/sstdevwd":["@stdlib/stats/base/dstdevwd","@stdlib/stats/base/snanstdevwd","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevwd","@stdlib/stats/base/svariancewd"],"@stdlib/stats/base/sstdevyc":["@stdlib/stats/base/dstdevyc","@stdlib/stats/base/snanstdevyc","@stdlib/stats/base/sstdev","@stdlib/stats/base/stdevyc","@stdlib/stats/base/svarianceyc"],"@stdlib/blas/ext/base/ssum":["@stdlib/blas/ext/base/dsum","@stdlib/stats/base/smean","@stdlib/blas/ext/base/snansum","@stdlib/blas/ext/base/gsum"],"@stdlib/blas/ext/base/ssumkbn":["@stdlib/blas/ext/base/dsumkbn","@stdlib/blas/ext/base/gsumkbn","@stdlib/blas/ext/base/snansumkbn","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas/ext/base/ssumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/ext/base/ssumkbn2":["@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn","@stdlib/blas/ext/base/ssumors","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/ext/base/ssumors":["@stdlib/blas/ext/base/dsumors","@stdlib/blas/ext/base/gsumors","@stdlib/blas/ext/base/snansumors","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas/ext/base/ssumpw"],"@stdlib/blas/ext/base/ssumpw":["@stdlib/blas/ext/base/dsumpw","@stdlib/blas/ext/base/gsumpw","@stdlib/blas/ext/base/snansumpw","@stdlib/blas/ext/base/ssum","@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas/ext/base/ssumors"],"@stdlib/blas/base/sswap":["@stdlib/blas/base/dswap","@stdlib/blas/base/gswap","@stdlib/blas/base/scopy","@stdlib/blas/sswap"],"@stdlib/stats/base/stdev":["@stdlib/stats/base/dstdev","@stdlib/stats/base/nanstdev","@stdlib/stats/base/sstdev","@stdlib/stats/base/variance"],"@stdlib/stats/base/stdevch":["@stdlib/stats/base/dstdevch","@stdlib/stats/base/nanstdevch","@stdlib/stats/base/sstdevch","@stdlib/stats/base/stdev","@stdlib/stats/base/variancech"],"@stdlib/stats/base/stdevpn":["@stdlib/stats/base/dstdevpn","@stdlib/stats/base/nanstdevpn","@stdlib/stats/base/sstdevpn","@stdlib/stats/base/stdev","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/stdevtk":["@stdlib/stats/base/dstdevtk","@stdlib/stats/base/nanstdevtk","@stdlib/stats/base/sstdevtk","@stdlib/stats/base/stdev","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/stdevwd":["@stdlib/stats/base/dstdevwd","@stdlib/stats/base/nanstdevwd","@stdlib/stats/base/sstdevwd","@stdlib/stats/base/stdev","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/stdevyc":["@stdlib/stats/base/dstdevyc","@stdlib/stats/base/nanstdevyc","@stdlib/stats/base/sstdevyc","@stdlib/stats/base/stdev","@stdlib/stats/base/varianceyc"],"@stdlib/math/strided/special/strunc":["@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/sceil","@stdlib/math/strided/special/sfloor","@stdlib/math/strided/special/trunc"],"@stdlib/stats/base/svariance":["@stdlib/stats/base/dvariance","@stdlib/stats/base/snanvariance","@stdlib/stats/base/sstdev","@stdlib/stats/base/variance"],"@stdlib/stats/base/svariancech":["@stdlib/stats/base/dvariancech","@stdlib/stats/base/snanvariancech","@stdlib/stats/base/sstdevch","@stdlib/stats/base/svariance","@stdlib/stats/base/variancech"],"@stdlib/stats/base/svariancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/snanvariancepn","@stdlib/stats/base/sstdevpn","@stdlib/stats/base/svariance","@stdlib/stats/base/variancepn"],"@stdlib/stats/base/svariancetk":["@stdlib/stats/base/dvariancetk","@stdlib/stats/base/snanvariancetk","@stdlib/stats/base/sstdevtk","@stdlib/stats/base/svariance","@stdlib/stats/base/variancetk"],"@stdlib/stats/base/svariancewd":["@stdlib/stats/base/dvariancewd","@stdlib/stats/base/snanvariancewd","@stdlib/stats/base/sstdevwd","@stdlib/stats/base/svariance","@stdlib/stats/base/variancewd"],"@stdlib/stats/base/svarianceyc":["@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/snanvarianceyc","@stdlib/stats/base/sstdevyc","@stdlib/stats/base/svariance","@stdlib/stats/base/varianceyc"],"@stdlib/strided/base/ternary":["@stdlib/strided/base/binary","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/unary"],"@stdlib/strided/base/unary":["@stdlib/strided/base/unary","@stdlib/strided/base/dmap","@stdlib/strided/base/nullary","@stdlib/strided/base/quaternary","@stdlib/strided/base/quinary","@stdlib/strided/base/smap","@stdlib/strided/base/ternary"],"@stdlib/strided/base/unary-by":["@stdlib/strided/base/map-by","@stdlib/strided/base/unary"],"@stdlib/strided/base/unary-dtype-signatures":["@stdlib/strided/base/unary-signature-callbacks"],"@stdlib/strided/base/unary-signature-callbacks":["@stdlib/strided/base/unary-dtype-signatures"],"@stdlib/stats/base/variance":["@stdlib/stats/base/dvariance","@stdlib/stats/base/nanvariance","@stdlib/stats/base/stdev","@stdlib/stats/base/svariance"],"@stdlib/stats/base/variancech":["@stdlib/stats/base/dvariancech","@stdlib/stats/base/nanvariancech","@stdlib/stats/base/stdevch","@stdlib/stats/base/variance"],"@stdlib/stats/base/variancepn":["@stdlib/stats/base/dvariancepn","@stdlib/stats/base/nanvariancepn","@stdlib/stats/base/stdevpn","@stdlib/stats/base/variance"],"@stdlib/stats/base/variancetk":["@stdlib/stats/base/dvariancetk","@stdlib/stats/base/nanvariancetk","@stdlib/stats/base/stdevtk","@stdlib/stats/base/variance"],"@stdlib/stats/base/variancewd":["@stdlib/stats/base/dvariancewd","@stdlib/stats/base/nanvariancewd","@stdlib/stats/base/stdevwd","@stdlib/stats/base/variance"],"@stdlib/stats/base/varianceyc":["@stdlib/stats/base/dvarianceyc","@stdlib/stats/base/nanvarianceyc","@stdlib/stats/base/stdevyc","@stdlib/stats/base/variance"],"@stdlib/strided/base/zmap":["@stdlib/strided/base/cmap","@stdlib/strided/base/unary"],"@stdlib/slice/base/str2multislice":["@stdlib/slice/base/str2slice"],"@stdlib/slice/base/str2slice":["@stdlib/slice/base/str2multislice"],"@stdlib/number/float64/base/sub":["@stdlib/number/float64/base/add","@stdlib/number/float64/base/div","@stdlib/number/float64/base/mul"],"@stdlib/math/base/ops/subf":["@stdlib/number/float32/base/add","@stdlib/number/float32/base/div","@stdlib/number/float32/base/mul","@stdlib/number/float64/base/sub"],"@stdlib/math/base/tools/sum-series":[],"@stdlib/math/base/special/tan":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/tand":["@stdlib/math/base/special/tan","@stdlib/math/base/special/cosd"],"@stdlib/math/base/special/tanh":["@stdlib/math/base/special/cosh","@stdlib/math/base/special/sinh","@stdlib/math/base/special/tan"],"@stdlib/number/float64/base/to-binary-string":["@stdlib/number/float64/base/from-binary-string","@stdlib/number/float32/base/to-binary-string"],"@stdlib/number/float32/base/to-binary-string":["@stdlib/number/float32/base/from-binary-string","@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint8/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint16/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint32/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/float32/base/to-word":["@stdlib/number/float32/base/from-word","@stdlib/number/float64/base/to-words"],"@stdlib/number/float64/base/to-words":["@stdlib/number/float64/base/from-words","@stdlib/number/float32/base/to-word"],"@stdlib/ndarray/base/transpose":["@stdlib/ndarray/ctor"],"@stdlib/math/base/special/tribonacci":["@stdlib/math/base/special/fibonacci"],"@stdlib/math/base/special/trigamma":["@stdlib/math/base/special/digamma","@stdlib/math/base/special/gamma"],"@stdlib/string/base/trim":["@stdlib/string/base/left-trim","@stdlib/string/base/right-trim"],"@stdlib/math/base/special/trunc":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floor","@stdlib/math/base/special/round"],"@stdlib/math/base/special/trunc2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round2","@stdlib/math/base/special/trunc","@stdlib/math/base/special/trunc10"],"@stdlib/math/base/special/trunc10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round10","@stdlib/math/base/special/trunc","@stdlib/math/base/special/trunc2"],"@stdlib/string/base/truncate-middle":[],"@stdlib/math/base/special/truncb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundb","@stdlib/math/base/special/trunc","@stdlib/math/base/special/truncn"],"@stdlib/math/base/special/truncf":["@stdlib/math/base/special/ceilf","@stdlib/math/base/special/floorf","@stdlib/math/base/special/trunc"],"@stdlib/math/base/special/truncn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundn","@stdlib/math/base/special/trunc","@stdlib/math/base/special/truncb"],"@stdlib/math/base/special/truncsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/trunc"],"@stdlib/number/uint32/base/to-int32":[],"@stdlib/number/uint32/base/mul":["@stdlib/math/base/ops/imul"],"@stdlib/math/base/ops/umuldw":["@stdlib/math/base/ops/imuldw","@stdlib/number/uint32/base/mul"],"@stdlib/string/base/uncapitalize":["@stdlib/string/base/capitalize"],"@stdlib/string/base/uppercase":["@stdlib/string/base/lowercase"],"@stdlib/math/base/special/vercos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/versin":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/wrap":["@stdlib/math/base/special/clamp"],"@stdlib/math/base/special/xlog1py":["@stdlib/math/base/special/log1p","@stdlib/math/base/special/xlogy"],"@stdlib/math/base/special/xlogy":["@stdlib/math/base/special/ln","@stdlib/math/base/special/xlog1py"],"@stdlib/math/base/special/riemann-zeta":[],"@stdlib/bench":["@stdlib/utils/timeit"],"@stdlib/datasets/berndt-cps-wages-1985":[],"@stdlib/utils/bifurcate":["@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-own","@stdlib/utils/group"],"@stdlib/utils/bifurcate-by":["@stdlib/utils/bifurcate","@stdlib/utils/group-by"],"@stdlib/utils/async/bifurcate-by":["@stdlib/utils/bifurcate-by","@stdlib/utils/async/group-by"],"@stdlib/utils/bifurcate-in":["@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-own","@stdlib/utils/group-in"],"@stdlib/utils/bifurcate-own":["@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-in","@stdlib/utils/group-own"],"@stdlib/bigint/ctor":[],"@stdlib/stats/binomial-test":[],"@stdlib/boolean/ctor":[],"@stdlib/array/bool":["@stdlib/array/buffer"],"@stdlib/ndarray/broadcast-array":["@stdlib/ndarray/array","@stdlib/ndarray/broadcast-arrays","@stdlib/ndarray/ctor","@stdlib/ndarray/maybe-broadcast-array"],"@stdlib/ndarray/broadcast-arrays":["@stdlib/ndarray/array","@stdlib/ndarray/broadcast-array","@stdlib/ndarray/ctor","@stdlib/ndarray/maybe-broadcast-arrays"],"@stdlib/buffer/ctor":["@stdlib/array/buffer"],"@stdlib/buffer/to-json":["@stdlib/array/to-json","@stdlib/buffer/reviver"],"@stdlib/os/byte-order":["@stdlib/assert/is-big-endian","@stdlib/assert/is-little-endian"],"@stdlib/string/camelcase":["@stdlib/string/constantcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/string/capitalize":["@stdlib/string/uncapitalize","@stdlib/string/uppercase"],"@stdlib/utils/capitalize-keys":["@stdlib/utils/uncapitalize-keys","@stdlib/utils/uppercase-keys"],"@stdlib/constants/float64/catalan":[],"@stdlib/constants/float64/cbrt-eps":["@stdlib/constants/float64/eps","@stdlib/constants/float64/sqrt-eps"],"@stdlib/datasets/cdc-nchs-us-births-1969-1988":["@stdlib/datasets/cdc-nchs-us-births-1994-2003","@stdlib/datasets/ssa-us-births-2000-2014"],"@stdlib/datasets/cdc-nchs-us-births-1994-2003":["@stdlib/datasets/cdc-nchs-us-births-1969-1988","@stdlib/datasets/ssa-us-births-2000-2014"],"@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013":[],"@stdlib/process/chdir":["@stdlib/process/cwd"],"@stdlib/stats/chi2gof":[],"@stdlib/stats/chi2test":[],"@stdlib/array/to-circular-iterator":["@stdlib/array/to-iterator","@stdlib/array/to-strided-iterator"],"@stdlib/streams/node/from-circular-array":["@stdlib/streams/node/from-array","@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-strided-array"],"@stdlib/dstructs/circular-buffer":["@stdlib/dstructs/fifo","@stdlib/dstructs/stack"],"@stdlib/fs/close":["@stdlib/fs/exists","@stdlib/fs/open","@stdlib/fs/read-file"],"@stdlib/datasets/cmudict":[],"@stdlib/string/code-point-at":["@stdlib/string/from-code-point"],"@stdlib/utils/common-keys":["@stdlib/utils/common-keys-in","@stdlib/utils/keys"],"@stdlib/utils/common-keys-in":["@stdlib/utils/common-keys","@stdlib/utils/keys-in"],"@stdlib/complex/cmplx":["@stdlib/complex/float64/ctor","@stdlib/complex/float32/ctor"],"@stdlib/complex/float32/ctor":["@stdlib/complex/cmplx","@stdlib/complex/float64/ctor"],"@stdlib/constants/complex64/nan":["@stdlib/constants/complex128/nan"],"@stdlib/constants/complex64/num-bytes":["@stdlib/constants/complex128/num-bytes","@stdlib/constants/float32/num-bytes"],"@stdlib/constants/complex64/zero":["@stdlib/constants/complex128/zero"],"@stdlib/array/complex64":["@stdlib/array/complex128","@stdlib/complex/cmplx","@stdlib/complex/float32/ctor"],"@stdlib/complex/float64/ctor":["@stdlib/complex/cmplx","@stdlib/complex/float32/ctor"],"@stdlib/constants/complex128/nan":["@stdlib/constants/complex64/nan"],"@stdlib/constants/complex128/num-bytes":["@stdlib/constants/complex64/num-bytes","@stdlib/constants/float64/num-bytes"],"@stdlib/constants/complex128/zero":["@stdlib/constants/complex64/zero"],"@stdlib/array/complex128":["@stdlib/array/complex64","@stdlib/complex/cmplx","@stdlib/complex/float64/ctor"],"@stdlib/array/typed-complex":["@stdlib/array/typed","@stdlib/array/typed-real"],"@stdlib/array/typed-complex-ctors":["@stdlib/array/ctors","@stdlib/array/typed-ctors","@stdlib/array/typed-real-ctors"],"@stdlib/array/typed-complex-dtypes":["@stdlib/array/dtypes","@stdlib/array/typed-dtypes","@stdlib/array/typed-real-dtypes","@stdlib/ndarray/dtypes"],"@stdlib/complex/ctors":["@stdlib/array/typed-complex-ctors"],"@stdlib/complex/dtype":["@stdlib/array/dtype"],"@stdlib/complex/dtypes":["@stdlib/array/typed-complex-dtypes"],"@stdlib/complex/promotion-rules":["@stdlib/array/promotion-rules","@stdlib/ndarray/promotion-rules"],"@stdlib/utils/compose":["@stdlib/utils/async/compose"],"@stdlib/utils/async/compose":["@stdlib/utils/compose"],"@stdlib/os/configdir":["@stdlib/os/homedir","@stdlib/os/tmpdir"],"@stdlib/complex/float64/conj":["@stdlib/complex/float64/imag","@stdlib/complex/float64/real","@stdlib/complex/float64/reim"],"@stdlib/complex/float32/conj":["@stdlib/complex/float64/conj","@stdlib/complex/float32/imag","@stdlib/complex/float32/real","@stdlib/complex/float32/reim"],"@stdlib/string/constantcase":["@stdlib/string/camelcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/utils/constant-function":["@stdlib/utils/argument-function","@stdlib/utils/identity-function"],"@stdlib/streams/node/from-constant":["@stdlib/streams/node/from-array","@stdlib/streams/node/from-iterator"],"@stdlib/utils/constructor-name":["@stdlib/utils/function-name"],"@stdlib/assert/contains":[],"@stdlib/array/convert":["@stdlib/array/convert-same"],"@stdlib/array/convert-same":["@stdlib/array/convert"],"@stdlib/utils/convert-path":[],"@stdlib/utils/copy":["@stdlib/utils/merge"],"@stdlib/buffer/from-buffer":["@stdlib/buffer/alloc-unsafe","@stdlib/buffer/ctor"],"@stdlib/utils/count-by":["@stdlib/utils/group","@stdlib/utils/group-by"],"@stdlib/utils/async/count-by":["@stdlib/utils/count-by","@stdlib/utils/async/group-by","@stdlib/utils/async/tabulate-by"],"@stdlib/time/current-year":["@stdlib/assert/is-current-year"],"@stdlib/utils/curry":["@stdlib/utils/curry-right","@stdlib/utils/uncurry","@stdlib/utils/uncurry-right"],"@stdlib/utils/curry-right":["@stdlib/utils/curry","@stdlib/utils/uncurry","@stdlib/utils/uncurry-right"],"@stdlib/process/cwd":["@stdlib/process/chdir"],"@stdlib/datasets/dale-chall-new":[],"@stdlib/datasets":[],"@stdlib/array/dataview":["@stdlib/array/buffer","@stdlib/array/typed"],"@stdlib/array/datespace":["@stdlib/array/linspace","@stdlib/array/logspace"],"@stdlib/time/day-of-quarter":["@stdlib/time/day-of-year"],"@stdlib/time/day-of-year":["@stdlib/time/day-of-quarter"],"@stdlib/time/days-in-month":["@stdlib/time/days-in-year"],"@stdlib/time/days-in-year":["@stdlib/time/days-in-month"],"@stdlib/blas/ddot":["@stdlib/blas/base/ddot","@stdlib/blas/gdot","@stdlib/blas/sdot"],"@stdlib/streams/node/debug-sink":["@stdlib/streams/node/debug","@stdlib/streams/node/inspect-sink"],"@stdlib/streams/node/debug":["@stdlib/streams/node/debug-sink","@stdlib/streams/node/inspect"],"@stdlib/utils/decorate-after":[],"@stdlib/assert/deep-equal":["@stdlib/assert/is-strict-equal","@stdlib/assert/is-same-value"],"@stdlib/utils/deep-get":["@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/assert/deep-has-own-property":["@stdlib/assert/deep-has-property","@stdlib/assert/has-own-property","@stdlib/utils/deep-get","@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/assert/deep-has-property":["@stdlib/assert/deep-has-own-property","@stdlib/assert/has-own-property","@stdlib/utils/deep-get","@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/utils/deep-pluck":["@stdlib/utils/deep-get","@stdlib/utils/deep-set"],"@stdlib/utils/deep-set":["@stdlib/utils/deep-get","@stdlib/utils/deep-pluck"],"@stdlib/utils/define-memoized-property":["@stdlib/utils/define-memoized-read-only-property","@stdlib/utils/define-property"],"@stdlib/utils/define-properties":["@stdlib/utils/define-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-property":["@stdlib/utils/define-properties","@stdlib/utils/define-read-only-property"],"@stdlib/utils/dirname":["@stdlib/utils/extname"],"@stdlib/string/dotcase":["@stdlib/string/camelcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/dstructs/doubly-linked-list":["@stdlib/dstructs/linked-list","@stdlib/dstructs/stack"],"@stdlib/utils/do-until":["@stdlib/utils/async/do-until","@stdlib/utils/do-until-each","@stdlib/utils/do-while","@stdlib/utils/until","@stdlib/utils/while"],"@stdlib/utils/async/do-until":["@stdlib/utils/do-until","@stdlib/utils/async/do-while","@stdlib/utils/async/until","@stdlib/utils/async/while"],"@stdlib/utils/do-until-each":["@stdlib/utils/do-until-each-right","@stdlib/utils/do-while-each","@stdlib/utils/until-each"],"@stdlib/utils/do-until-each-right":["@stdlib/utils/do-until-each","@stdlib/utils/do-while-each-right","@stdlib/utils/until-each-right"],"@stdlib/utils/do-while":["@stdlib/utils/do-until","@stdlib/utils/async/do-while","@stdlib/utils/do-while-each","@stdlib/utils/until","@stdlib/utils/while"],"@stdlib/utils/async/do-while":["@stdlib/utils/async/do-until","@stdlib/utils/do-while","@stdlib/utils/async/until","@stdlib/utils/async/while"],"@stdlib/utils/do-while-each":["@stdlib/utils/do-until-each","@stdlib/utils/do-while-each-right","@stdlib/utils/while-each"],"@stdlib/utils/do-while-each-right":["@stdlib/utils/do-until-each-right","@stdlib/utils/do-while-each","@stdlib/utils/while-each-right"],"@stdlib/blas/dswap":["@stdlib/blas/base/dswap","@stdlib/blas/gswap","@stdlib/blas/sswap"],"@stdlib/constants/float64/e":[],"@stdlib/datasets/emoji":["@stdlib/datasets/emoji-code-picto","@stdlib/datasets/emoji-picto-code"],"@stdlib/datasets/emoji-code-picto":["@stdlib/datasets/emoji","@stdlib/datasets/emoji-picto-code"],"@stdlib/datasets/emoji-picto-code":["@stdlib/datasets/emoji","@stdlib/datasets/emoji-code-picto"],"@stdlib/streams/node/empty":["@stdlib/streams/node/from-constant"],"@stdlib/string/ends-with":["@stdlib/string/starts-with"],"@stdlib/utils/enumerable-properties":["@stdlib/utils/enumerable-properties-in","@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/keys","@stdlib/utils/nonenumerable-properties","@stdlib/utils/properties"],"@stdlib/utils/enumerable-properties-in":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/keys-in","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties-in"],"@stdlib/utils/enumerable-property-symbols":["@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-symbols"],"@stdlib/utils/enumerable-property-symbols-in":["@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/keys-in","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols-in"],"@stdlib/process/env":["@stdlib/process/argv"],"@stdlib/constants/float64/eps":["@stdlib/constants/float32/eps"],"@stdlib/error/to-json":["@stdlib/error/reviver"],"@stdlib/constants/float64/eulergamma":[],"@stdlib/utils/every":["@stdlib/utils/any","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some"],"@stdlib/utils/every-by":["@stdlib/utils/any-by","@stdlib/utils/every-by-right","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some-by"],"@stdlib/utils/async/every-by":["@stdlib/utils/async/any-by","@stdlib/utils/every-by","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/async/some-by"],"@stdlib/utils/every-by-right":["@stdlib/utils/any-by","@stdlib/utils/every","@stdlib/utils/every-by","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by-right"],"@stdlib/utils/async/every-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by","@stdlib/utils/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/every-in-by":["@stdlib/utils/any-in-by","@stdlib/utils/none-in-by","@stdlib/utils/some-in-by","@stdlib/utils/every-by","@stdlib/utils/every-own-by"],"@stdlib/utils/every-own-by":["@stdlib/utils/any-own-by","@stdlib/utils/every-in-by","@stdlib/utils/none-own-by","@stdlib/utils/some-own-by","@stdlib/utils/every-by"],"@stdlib/utils/eval":[],"@stdlib/process/exec-path":[],"@stdlib/fs/exists":["@stdlib/fs/read-file","@stdlib/fs/read-dir"],"@stdlib/nlp/expand-acronyms":["@stdlib/nlp/expand-contractions"],"@stdlib/nlp/expand-contractions":[],"@stdlib/utils/extname":["@stdlib/utils/dirname"],"@stdlib/ndarray/fancy":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/math/base/special/fast/abs":["@stdlib/math/base/special/abs"],"@stdlib/math/base/special/fast/acosh":["@stdlib/math/base/special/acosh"],"@stdlib/math/base/special/fast/alpha-max-plus-beta-min":["@stdlib/math/base/special/hypot"],"@stdlib/math/base/special/fast/asinh":["@stdlib/math/base/special/asinh"],"@stdlib/math/base/special/fast/atanh":["@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/fast/hypot":["@stdlib/math/base/special/hypot"],"@stdlib/math/base/special/fast/uint32-log2":["@stdlib/math/base/special/log2"],"@stdlib/math/base/special/fast/max":["@stdlib/math/base/special/max"],"@stdlib/math/base/special/fast/min":["@stdlib/math/base/special/min"],"@stdlib/math/base/special/fast/pow-int":["@stdlib/math/base/special/pow"],"@stdlib/math/base/special/fast/uint32-sqrt":["@stdlib/math/base/special/sqrt"],"@stdlib/datasets/female-first-names-en":["@stdlib/datasets/male-first-names-en"],"@stdlib/dstructs/fifo":["@stdlib/dstructs/stack"],"@stdlib/array/filled":["@stdlib/array/filled-by","@stdlib/array/typed"],"@stdlib/array/filled-by":["@stdlib/array/filled","@stdlib/array/typed"],"@stdlib/utils/filter-arguments":["@stdlib/utils/mask-arguments","@stdlib/utils/reject-arguments","@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/utils/find":[],"@stdlib/string/first":["@stdlib/string/remove-first","@stdlib/string/last"],"@stdlib/datasets/fivethirtyeight-ffq":[],"@stdlib/utils/flatten-array":["@stdlib/utils/flatten-object"],"@stdlib/utils/flatten-object":["@stdlib/utils/flatten-array"],"@stdlib/stats/fligner-test":["@stdlib/stats/bartlett-test"],"@stdlib/os/float-word-order":["@stdlib/os/byte-order"],"@stdlib/constants/float16/cbrt-eps":["@stdlib/constants/float16/eps","@stdlib/constants/float16/sqrt-eps","@stdlib/constants/float32/cbrt-eps","@stdlib/constants/float64/cbrt-eps"],"@stdlib/constants/float16/eps":["@stdlib/constants/float32/eps","@stdlib/constants/float64/eps"],"@stdlib/constants/float16/exponent-bias":["@stdlib/constants/float32/exponent-bias","@stdlib/constants/float64/exponent-bias"],"@stdlib/constants/float16/max":["@stdlib/constants/float32/max","@stdlib/constants/float64/max"],"@stdlib/constants/float16/max-safe-integer":["@stdlib/constants/float16/min-safe-integer","@stdlib/constants/float32/max-safe-integer","@stdlib/constants/float64/max-safe-integer"],"@stdlib/constants/float16/min-safe-integer":["@stdlib/constants/float16/max-safe-integer","@stdlib/constants/float32/min-safe-integer","@stdlib/constants/float64/min-safe-integer"],"@stdlib/constants/float16/ninf":["@stdlib/constants/float16/pinf","@stdlib/constants/float32/ninf","@stdlib/constants/float64/ninf"],"@stdlib/constants/float16/num-bytes":["@stdlib/constants/float32/num-bytes","@stdlib/constants/float64/num-bytes"],"@stdlib/constants/float16/pinf":["@stdlib/constants/float16/ninf","@stdlib/constants/float32/pinf","@stdlib/constants/float64/pinf"],"@stdlib/constants/float16/precision":["@stdlib/constants/float32/precision","@stdlib/constants/float64/precision"],"@stdlib/constants/float16/smallest-normal":["@stdlib/constants/float16/smallest-subnormal","@stdlib/constants/float32/smallest-normal","@stdlib/constants/float64/smallest-normal"],"@stdlib/constants/float16/smallest-subnormal":["@stdlib/constants/float16/smallest-normal","@stdlib/constants/float32/smallest-subnormal","@stdlib/constants/float64/smallest-subnormal"],"@stdlib/constants/float16/sqrt-eps":["@stdlib/constants/float16/eps","@stdlib/constants/float32/sqrt-eps","@stdlib/constants/float64/sqrt-eps"],"@stdlib/constants/float32/abs-mask":["@stdlib/constants/float32/exponent-mask","@stdlib/constants/float32/sign-mask","@stdlib/constants/float32/significand-mask"],"@stdlib/constants/float32/cbrt-eps":["@stdlib/constants/float32/eps","@stdlib/constants/float32/sqrt-eps","@stdlib/constants/float64/cbrt-eps"],"@stdlib/constants/float32/e":["@stdlib/constants/float64/e"],"@stdlib/constants/float32/eps":["@stdlib/constants/float64/eps"],"@stdlib/constants/float32/exponent-bias":["@stdlib/constants/float16/exponent-bias","@stdlib/constants/float64/exponent-bias"],"@stdlib/constants/float32/exponent-mask":["@stdlib/constants/float32/sign-mask","@stdlib/constants/float32/significand-mask","@stdlib/constants/float32/abs-mask"],"@stdlib/constants/float32/fourth-pi":["@stdlib/constants/float32/half-pi","@stdlib/constants/float32/pi","@stdlib/constants/float32/two-pi"],"@stdlib/constants/float32/half-ln-two":["@stdlib/constants/float64/half-ln-two"],"@stdlib/constants/float32/half-pi":["@stdlib/constants/float32/fourth-pi","@stdlib/constants/float32/pi","@stdlib/constants/float32/two-pi"],"@stdlib/constants/float32/ln-half":["@stdlib/constants/float64/ln-half"],"@stdlib/constants/float32/ln-pi":["@stdlib/constants/float32/pi","@stdlib/constants/float64/ln-pi"],"@stdlib/constants/float32/ln-ten":["@stdlib/constants/float32/ln-two","@stdlib/constants/float64/ln-ten"],"@stdlib/constants/float32/ln-two":["@stdlib/constants/float32/ln-ten","@stdlib/constants/float64/ln-two"],"@stdlib/constants/float32/max":["@stdlib/constants/float16/max","@stdlib/constants/float64/max"],"@stdlib/constants/float32/max-base2-exponent":["@stdlib/constants/float32/max-base2-exponent-subnormal","@stdlib/constants/float64/max-base2-exponent"],"@stdlib/constants/float32/max-base2-exponent-subnormal":["@stdlib/constants/float32/max-base2-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal"],"@stdlib/constants/float32/max-base10-exponent":["@stdlib/constants/float32/max-base10-exponent-subnormal","@stdlib/constants/float64/max-base10-exponent"],"@stdlib/constants/float32/max-base10-exponent-subnormal":["@stdlib/constants/float32/max-base10-exponent","@stdlib/constants/float64/max-base10-exponent-subnormal"],"@stdlib/constants/float32/max-safe-fibonacci":["@stdlib/constants/float64/max-safe-fibonacci"],"@stdlib/constants/float32/max-safe-integer":["@stdlib/constants/float16/max-safe-integer","@stdlib/constants/float32/min-safe-integer","@stdlib/constants/float64/max-safe-integer"],"@stdlib/constants/float32/max-safe-nth-factorial":[],"@stdlib/constants/float32/max-safe-nth-fibonacci":["@stdlib/constants/float64/max-safe-nth-fibonacci"],"@stdlib/constants/float32/max-safe-nth-lucas":["@stdlib/constants/float64/max-safe-nth-lucas"],"@stdlib/constants/float32/min-base2-exponent":["@stdlib/constants/float32/min-base2-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float32/min-base2-exponent-subnormal":["@stdlib/constants/float32/min-base2-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float32/min-base10-exponent":["@stdlib/constants/float32/min-base10-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent"],"@stdlib/constants/float32/min-base10-exponent-subnormal":["@stdlib/constants/float32/min-base10-exponent","@stdlib/constants/float64/min-base10-exponent-subnormal"],"@stdlib/constants/float32/min-safe-integer":["@stdlib/constants/float16/min-safe-integer","@stdlib/constants/float32/max-safe-integer","@stdlib/constants/float64/min-safe-integer"],"@stdlib/constants/float32/nan":["@stdlib/constants/float64/nan"],"@stdlib/constants/float32/ninf":["@stdlib/constants/float32/pinf","@stdlib/constants/float64/ninf"],"@stdlib/constants/float32/num-bytes":["@stdlib/constants/float16/num-bytes","@stdlib/constants/float64/num-bytes"],"@stdlib/constants/float32/phi":["@stdlib/constants/float64/phi"],"@stdlib/constants/float32/pi":["@stdlib/constants/float32/fourth-pi","@stdlib/constants/float32/half-pi","@stdlib/constants/float32/two-pi"],"@stdlib/constants/float32/pinf":["@stdlib/constants/float32/ninf","@stdlib/constants/float64/pinf"],"@stdlib/constants/float32/precision":["@stdlib/constants/float16/precision","@stdlib/constants/float64/precision"],"@stdlib/constants/float32/sign-mask":["@stdlib/constants/float32/exponent-mask","@stdlib/constants/float32/significand-mask","@stdlib/constants/float32/abs-mask"],"@stdlib/constants/float32/significand-mask":["@stdlib/constants/float32/exponent-mask","@stdlib/constants/float32/sign-mask","@stdlib/constants/float32/abs-mask"],"@stdlib/constants/float32/smallest-normal":["@stdlib/constants/float32/smallest-subnormal","@stdlib/constants/float64/smallest-normal"],"@stdlib/constants/float32/smallest-subnormal":["@stdlib/constants/float32/smallest-normal","@stdlib/constants/float64/smallest-subnormal"],"@stdlib/constants/float32/sqrt-eps":["@stdlib/constants/float32/eps","@stdlib/constants/float64/sqrt-eps"],"@stdlib/constants/float32/sqrt-half":["@stdlib/constants/float64/sqrt-half"],"@stdlib/constants/float32/sqrt-half-pi":["@stdlib/constants/float64/sqrt-half-pi"],"@stdlib/constants/float32/sqrt-phi":["@stdlib/constants/float64/sqrt-phi"],"@stdlib/constants/float32/sqrt-pi":["@stdlib/constants/float32/pi","@stdlib/constants/float64/sqrt-pi"],"@stdlib/constants/float32/sqrt-three":["@stdlib/constants/float32/sqrt-two","@stdlib/constants/float64/sqrt-three"],"@stdlib/constants/float32/sqrt-two":["@stdlib/constants/float32/sqrt-three","@stdlib/constants/float64/sqrt-two"],"@stdlib/constants/float32/sqrt-two-pi":["@stdlib/constants/float32/pi","@stdlib/constants/float32/two-pi","@stdlib/constants/float64/sqrt-two-pi"],"@stdlib/constants/float32/two-pi":["@stdlib/constants/float32/fourth-pi","@stdlib/constants/float32/half-pi","@stdlib/constants/float32/pi"],"@stdlib/array/float32":["@stdlib/array/buffer","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/fixed-endian-float32":["@stdlib/array/fixed-endian-float64","@stdlib/array/float32"],"@stdlib/array/little-endian-float32":["@stdlib/array/fixed-endian-float32","@stdlib/array/float32","@stdlib/array/little-endian-float64"],"@stdlib/constants/float64/exponent-bias":["@stdlib/constants/float16/exponent-bias","@stdlib/constants/float32/exponent-bias"],"@stdlib/constants/float64/high-word-abs-mask":["@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants/float64/high-word-significand-mask"],"@stdlib/constants/float64/high-word-exponent-mask":["@stdlib/constants/float64/high-word-significand-mask","@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants/float64/high-word-abs-mask"],"@stdlib/constants/float64/high-word-sign-mask":["@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants/float64/high-word-significand-mask","@stdlib/constants/float64/high-word-abs-mask"],"@stdlib/constants/float64/high-word-significand-mask":["@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants/float64/high-word-abs-mask"],"@stdlib/constants/float64/max":["@stdlib/constants/float16/max","@stdlib/constants/float32/max"],"@stdlib/constants/float64/max-base2-exponent":["@stdlib/constants/float64/max-base10-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float64/max-base2-exponent-subnormal":["@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants/float64/max-base2-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float64/max-base10-exponent":["@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants/float64/max-base2-exponent","@stdlib/constants/float64/min-base10-exponent"],"@stdlib/constants/float64/max-base10-exponent-subnormal":["@stdlib/constants/float64/max-base10-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent-subnormal"],"@stdlib/constants/float64/max-ln":["@stdlib/constants/float64/min-ln"],"@stdlib/constants/float64/max-safe-fibonacci":["@stdlib/constants/float64/max-safe-nth-fibonacci"],"@stdlib/constants/float64/max-safe-integer":["@stdlib/constants/float16/max-safe-integer","@stdlib/constants/float32/max-safe-integer","@stdlib/constants/float64/min-safe-integer"],"@stdlib/constants/float64/max-safe-lucas":["@stdlib/constants/float64/max-safe-fibonacci","@stdlib/constants/float64/max-safe-nth-lucas"],"@stdlib/constants/float64/max-safe-nth-fibonacci":["@stdlib/constants/float64/max-safe-fibonacci"],"@stdlib/constants/float64/max-safe-nth-lucas":["@stdlib/constants/float64/max-safe-lucas","@stdlib/constants/float64/max-safe-nth-fibonacci"],"@stdlib/constants/float64/min-base2-exponent":["@stdlib/constants/float64/max-base2-exponent","@stdlib/constants/float64/min-base10-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float64/min-base2-exponent-subnormal":["@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float64/min-base10-exponent":["@stdlib/constants/float64/max-base10-exponent","@stdlib/constants/float64/min-base10-exponent-subnormal","@stdlib/constants/float64/min-base2-exponent"],"@stdlib/constants/float64/min-base10-exponent-subnormal":["@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal"],"@stdlib/constants/float64/min-ln":["@stdlib/constants/float64/max-ln"],"@stdlib/constants/float64/min-safe-integer":["@stdlib/constants/float16/min-safe-integer","@stdlib/constants/float32/min-safe-integer","@stdlib/constants/float64/max-safe-integer"],"@stdlib/constants/float64/num-bytes":["@stdlib/constants/float16/num-bytes","@stdlib/constants/float32/num-bytes"],"@stdlib/constants/float64/precision":["@stdlib/constants/float16/precision","@stdlib/constants/float32/precision"],"@stdlib/constants/float64/smallest-normal":["@stdlib/constants/float32/smallest-normal","@stdlib/constants/float64/smallest-subnormal"],"@stdlib/constants/float64/smallest-subnormal":["@stdlib/constants/float32/smallest-subnormal","@stdlib/constants/float64/smallest-normal"],"@stdlib/array/float64":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/fixed-endian-float64":["@stdlib/array/fixed-endian-float32","@stdlib/array/float64"],"@stdlib/array/little-endian-float64":["@stdlib/array/fixed-endian-float64","@stdlib/array/float64","@stdlib/array/little-endian-float32"],"@stdlib/utils/for-each":["@stdlib/utils/async/for-each","@stdlib/utils/for-each-right"],"@stdlib/utils/async/for-each":["@stdlib/utils/for-each","@stdlib/utils/async/for-each-right"],"@stdlib/string/for-each":["@stdlib/utils/for-each"],"@stdlib/utils/for-each-right":["@stdlib/utils/for-each","@stdlib/utils/async/for-each-right"],"@stdlib/utils/async/for-each-right":["@stdlib/utils/async/for-each","@stdlib/utils/for-each-right"],"@stdlib/utils/for-in":["@stdlib/utils/for-each","@stdlib/utils/for-own"],"@stdlib/string/format":[],"@stdlib/utils/for-own":["@stdlib/utils/for-each","@stdlib/utils/for-in"],"@stdlib/constants/float64/fourth-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/fourth-root-eps":["@stdlib/constants/float64/eps"],"@stdlib/datasets/frb-sf-wage-rigidity":[],"@stdlib/string/from-code-point":["@stdlib/string/code-point-at"],"@stdlib/function/ctor":[],"@stdlib/function/to-string":["@stdlib/function/ctor"],"@stdlib/utils/function-name":["@stdlib/utils/constructor-name"],"@stdlib/utils/function-sequence":["@stdlib/utils/compose","@stdlib/utils/async/function-sequence"],"@stdlib/utils/async/function-sequence":["@stdlib/utils/async/compose","@stdlib/utils/function-sequence"],"@stdlib/constants/float64/gamma-lanczos-g":[],"@stdlib/blas/gdot":["@stdlib/blas/base/gdot","@stdlib/blas/ddot","@stdlib/blas/sdot"],"@stdlib/process/getegid":["@stdlib/process/geteuid","@stdlib/process/getgid","@stdlib/process/getuid"],"@stdlib/process/geteuid":["@stdlib/process/getegid","@stdlib/process/getgid","@stdlib/process/getuid"],"@stdlib/process/getgid":["@stdlib/process/getegid","@stdlib/process/geteuid","@stdlib/process/getuid"],"@stdlib/utils/global":[],"@stdlib/utils/get-prototype-of":["@stdlib/assert/is-prototype-of"],"@stdlib/process/getuid":["@stdlib/process/getegid","@stdlib/process/geteuid","@stdlib/process/getgid"],"@stdlib/constants/float64/glaisher-kinkelin":[],"@stdlib/string/to-grapheme-cluster-iterator":["@stdlib/array/to-iterator","@stdlib/string/to-grapheme-cluster-iterator-right"],"@stdlib/string/to-grapheme-cluster-iterator-right":["@stdlib/array/to-iterator-right","@stdlib/string/to-grapheme-cluster-iterator"],"@stdlib/utils/group":["@stdlib/utils/bifurcate","@stdlib/utils/count-by","@stdlib/utils/group-by"],"@stdlib/utils/group-by":["@stdlib/utils/bifurcate-by","@stdlib/utils/count-by","@stdlib/utils/group"],"@stdlib/utils/async/group-by":["@stdlib/utils/async/bifurcate-by","@stdlib/utils/async/count-by","@stdlib/utils/group-by"],"@stdlib/utils/group-in":["@stdlib/utils/bifurcate-in","@stdlib/utils/group-by","@stdlib/utils/group-own"],"@stdlib/utils/group-own":["@stdlib/utils/bifurcate-own","@stdlib/utils/group","@stdlib/utils/group-by"],"@stdlib/blas/gswap":["@stdlib/blas/base/gswap","@stdlib/blas/dswap","@stdlib/blas/sswap"],"@stdlib/constants/float64/half-ln-two":["@stdlib/constants/float64/ln-two"],"@stdlib/constants/float64/half-pi":["@stdlib/constants/float64/pi"],"@stdlib/datasets/harrison-boston-house-prices":["@stdlib/datasets/harrison-boston-house-prices-corrected","@stdlib/datasets/pace-boston-house-prices"],"@stdlib/datasets/harrison-boston-house-prices-corrected":["@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/pace-boston-house-prices"],"@stdlib/assert/has-arraybuffer-support":["@stdlib/assert/has-float32array-support","@stdlib/assert/has-float64array-support","@stdlib/assert/has-int16array-support","@stdlib/assert/has-int32array-support","@stdlib/assert/has-int8array-support","@stdlib/assert/has-node-buffer-support","@stdlib/assert/has-sharedarraybuffer-support","@stdlib/assert/has-uint16array-support","@stdlib/assert/has-uint32array-support","@stdlib/assert/has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support"],"@stdlib/assert/has-arrow-function-support":[],"@stdlib/assert/has-async-await-support":[],"@stdlib/assert/has-async-iterator-symbol-support":["@stdlib/assert/has-iterator-symbol-support","@stdlib/assert/has-symbol-support"],"@stdlib/assert/has-atob-support":["@stdlib/assert/has-btoa-support"],"@stdlib/assert/has-bigint64array-support":["@stdlib/assert/has-bigint-support","@stdlib/assert/has-biguint64array-support"],"@stdlib/assert/has-bigint-support":[],"@stdlib/assert/has-biguint64array-support":["@stdlib/assert/has-bigint-support","@stdlib/assert/has-bigint64array-support"],"@stdlib/assert/has-btoa-support":["@stdlib/assert/has-atob-support"],"@stdlib/assert/has-class-support":[],"@stdlib/assert/has-dataview-support":["@stdlib/assert/has-arraybuffer-support"],"@stdlib/assert/has-define-properties-support":["@stdlib/assert/has-define-property-support"],"@stdlib/assert/has-define-property-support":["@stdlib/assert/has-define-properties-support"],"@stdlib/assert/has-float32array-support":[],"@stdlib/assert/has-float64array-support":[],"@stdlib/assert/has-function-name-support":[],"@stdlib/assert/has-generator-support":[],"@stdlib/assert/has-globalthis-support":["@stdlib/utils/global"],"@stdlib/assert/has-int8array-support":[],"@stdlib/assert/has-int16array-support":[],"@stdlib/assert/has-int32array-support":[],"@stdlib/assert/has-iterator-symbol-support":["@stdlib/assert/has-async-iterator-symbol-support","@stdlib/assert/has-symbol-support"],"@stdlib/assert/has-map-support":[],"@stdlib/assert/has-node-buffer-support":[],"@stdlib/assert/has-own-property":["@stdlib/assert/has-property"],"@stdlib/assert/has-property":["@stdlib/assert/has-own-property"],"@stdlib/assert/has-proxy-support":[],"@stdlib/assert/has-set-support":[],"@stdlib/assert/has-sharedarraybuffer-support":["@stdlib/assert/has-arraybuffer-support","@stdlib/assert/has-float32array-support","@stdlib/assert/has-float64array-support","@stdlib/assert/has-int16array-support","@stdlib/assert/has-int32array-support","@stdlib/assert/has-int8array-support","@stdlib/assert/has-node-buffer-support","@stdlib/assert/has-uint16array-support","@stdlib/assert/has-uint32array-support","@stdlib/assert/has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support"],"@stdlib/assert/has-symbol-support":["@stdlib/assert/has-iterator-symbol-support"],"@stdlib/assert/has-tostringtag-support":[],"@stdlib/assert/has-uint8array-support":[],"@stdlib/assert/has-uint8clampedarray-support":[],"@stdlib/assert/has-uint16array-support":[],"@stdlib/assert/has-uint32array-support":[],"@stdlib/assert/has-utf16-surrogate-pair-at":[],"@stdlib/assert/has-weakmap-support":[],"@stdlib/assert/has-weakset-support":[],"@stdlib/assert/has-wasm-support":[],"@stdlib/string/headercase":["@stdlib/string/camelcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/datasets/herndon-venus-semidiameters":[],"@stdlib/os/homedir":["@stdlib/os/configdir","@stdlib/os/tmpdir"],"@stdlib/constants/time/hours-in-day":["@stdlib/constants/time/hours-in-week"],"@stdlib/constants/time/hours-in-week":["@stdlib/constants/time/hours-in-day"],"@stdlib/time/hours-in-month":["@stdlib/time/hours-in-year"],"@stdlib/time/hours-in-year":["@stdlib/time/hours-in-month"],"@stdlib/net/http-server":[],"@stdlib/utils/identity-function":["@stdlib/utils/constant-function"],"@stdlib/utils/if-else":["@stdlib/utils/async/if-else","@stdlib/utils/if-then"],"@stdlib/utils/async/if-else":["@stdlib/utils/async/if-then","@stdlib/utils/if-else"],"@stdlib/utils/if-then":["@stdlib/utils/async/if-then","@stdlib/utils/if-else"],"@stdlib/utils/async/if-then":["@stdlib/utils/async/if-else","@stdlib/utils/if-then"],"@stdlib/complex/float64/imag":["@stdlib/complex/float64/real","@stdlib/complex/float64/reim"],"@stdlib/complex/float32/imag":["@stdlib/complex/float64/imag","@stdlib/complex/float32/real","@stdlib/complex/float32/reim"],"@stdlib/datasets/img-acanthus-mollis":["@stdlib/datasets/img-allium-oreophilum"],"@stdlib/datasets/img-airplane-from-above":[],"@stdlib/datasets/img-allium-oreophilum":["@stdlib/datasets/img-acanthus-mollis"],"@stdlib/datasets/img-black-canyon":[],"@stdlib/datasets/img-dust-bowl-home":[],"@stdlib/datasets/img-french-alpine-landscape":[],"@stdlib/datasets/img-locomotion-house-cat":["@stdlib/datasets/img-locomotion-nude-male"],"@stdlib/datasets/img-locomotion-nude-male":["@stdlib/datasets/img-locomotion-house-cat"],"@stdlib/datasets/img-march-pastoral":[],"@stdlib/datasets/img-nagasaki-boats":[],"@stdlib/stats/incr/apcorr":["@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/pcorr2"],"@stdlib/ml/incr/binary-classification":["@stdlib/ml/incr/sgd-regression"],"@stdlib/stats/incr/count":["@stdlib/stats/incr/mean","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/covariance":["@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/covmat":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/pcorrmat"],"@stdlib/stats/incr/cv":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mcv","@stdlib/stats/incr/stdev","@stdlib/stats/incr/vmr"],"@stdlib/stats/incr/ewmean":["@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmean","@stdlib/stats/incr/wmean"],"@stdlib/stats/incr/ewstdev":["@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/ewvariance":["@stdlib/stats/incr/ewmean","@stdlib/stats/incr/ewstdev","@stdlib/stats/incr/variance","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/gmean":["@stdlib/stats/incr/hmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mgmean","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/grubbs":["@stdlib/stats/incr/mgrubbs"],"@stdlib/stats/incr/hmean":["@stdlib/stats/incr/gmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mhmean","@stdlib/stats/incr/summary"],"@stdlib/ml/incr/kmeans":[],"@stdlib/stats/incr/kurtosis":["@stdlib/stats/incr/mean","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/maape":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mape","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmaape"],"@stdlib/stats/incr/mae":["@stdlib/stats/incr/mape","@stdlib/stats/incr/me","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmae"],"@stdlib/stats/incr/mapcorr":["@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mpcorr2"],"@stdlib/stats/incr/mape":["@stdlib/stats/incr/maape","@stdlib/stats/incr/mae","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmape"],"@stdlib/stats/incr/max":["@stdlib/stats/incr/midrange","@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/maxabs":["@stdlib/stats/incr/max","@stdlib/stats/incr/minabs","@stdlib/stats/incr/mmaxabs"],"@stdlib/stats/incr/mcovariance":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mcv":["@stdlib/stats/incr/cv","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/mvmr"],"@stdlib/stats/incr/mda":["@stdlib/stats/incr/mape","@stdlib/stats/incr/mmda"],"@stdlib/stats/incr/me":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mean","@stdlib/stats/incr/mme"],"@stdlib/stats/incr/mean":["@stdlib/stats/incr/midrange","@stdlib/stats/incr/mmean","@stdlib/stats/incr/stdev","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/meanabs":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/meanabs2":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/meanstdev":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/meanvar":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/mgmean":["@stdlib/stats/incr/gmean","@stdlib/stats/incr/mhmean","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mgrubbs":["@stdlib/stats/incr/grubbs"],"@stdlib/stats/incr/mhmean":["@stdlib/stats/incr/hmean","@stdlib/stats/incr/mgmean","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/midrange":["@stdlib/stats/incr/mean","@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/min":["@stdlib/stats/incr/max","@stdlib/stats/incr/midrange","@stdlib/stats/incr/mmin","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/minabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/min","@stdlib/stats/incr/mminabs"],"@stdlib/stats/incr/minmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/mminmax","@stdlib/stats/incr/range"],"@stdlib/stats/incr/minmaxabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/minabs","@stdlib/stats/incr/minmax","@stdlib/stats/incr/mminmaxabs"],"@stdlib/stats/incr/mmaape":["@stdlib/stats/incr/maape","@stdlib/stats/incr/mmape","@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmae":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mme","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmape":["@stdlib/stats/incr/mape","@stdlib/stats/incr/mmaape","@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange","@stdlib/stats/incr/msummary"],"@stdlib/stats/incr/mmaxabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mminabs"],"@stdlib/stats/incr/mmda":["@stdlib/stats/incr/mda","@stdlib/stats/incr/mmape"],"@stdlib/stats/incr/mme":["@stdlib/stats/incr/me","@stdlib/stats/incr/mmae","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmean":["@stdlib/stats/incr/mean","@stdlib/stats/incr/msum","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msummary","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mmeanabs":["@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mmean","@stdlib/stats/incr/msumabs"],"@stdlib/stats/incr/mmeanabs2":["@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/msumabs2"],"@stdlib/stats/incr/mmeanstdev":["@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/mstdev"],"@stdlib/stats/incr/mmeanvar":["@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mmidrange":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange"],"@stdlib/stats/incr/mmin":["@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mrange","@stdlib/stats/incr/msummary"],"@stdlib/stats/incr/mminabs":["@stdlib/stats/incr/minabs","@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/mmin"],"@stdlib/stats/incr/mminmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/minmax","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange"],"@stdlib/stats/incr/mminmaxabs":["@stdlib/stats/incr/minmaxabs","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mminabs","@stdlib/stats/incr/mminmax"],"@stdlib/stats/incr/mmpe":["@stdlib/stats/incr/mmape","@stdlib/stats/incr/mme","@stdlib/stats/incr/mpe"],"@stdlib/stats/incr/mmse":["@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mrss","@stdlib/stats/incr/mse"],"@stdlib/stats/incr/mpcorr":["@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/mpcorrdist","@stdlib/stats/incr/pcorr"],"@stdlib/stats/incr/mpcorr2":["@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/pcorr2"],"@stdlib/stats/incr/mpcorrdist":["@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/pcorrdist"],"@stdlib/stats/incr/mpe":["@stdlib/stats/incr/mape","@stdlib/stats/incr/me","@stdlib/stats/incr/mmpe"],"@stdlib/stats/incr/mprod":["@stdlib/stats/incr/msum","@stdlib/stats/incr/prod"],"@stdlib/stats/incr/mrange":["@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmin","@stdlib/stats/incr/msummary","@stdlib/stats/incr/range"],"@stdlib/stats/incr/mrmse":["@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrss","@stdlib/stats/incr/rmse"],"@stdlib/stats/incr/mrss":["@stdlib/stats/incr/rss","@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrmse"],"@stdlib/stats/incr/mse":["@stdlib/stats/incr/mmse","@stdlib/stats/incr/rmse","@stdlib/stats/incr/rss"],"@stdlib/stats/incr/mstdev":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/msummary","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/msum":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/msummary","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/msumabs":["@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/msum","@stdlib/stats/incr/sum","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/msumabs2":["@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/msumabs","@stdlib/stats/incr/sumabs","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/msummary":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msum","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/msumprod":["@stdlib/stats/incr/mprod","@stdlib/stats/incr/msum","@stdlib/stats/incr/sumprod"],"@stdlib/stats/incr/mvariance":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msummary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/mvmr":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/vmr"],"@stdlib/stats/incr/nancount":["@stdlib/stats/incr/nansum"],"@stdlib/stats/incr/nansum":["@stdlib/stats/incr/nansumabs","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/nansumabs":["@stdlib/stats/incr/nansum","@stdlib/stats/incr/nansumabs2","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/nansumabs2":["@stdlib/stats/incr/nansum","@stdlib/stats/incr/nansumabs","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/pcorr":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/pcorr2":["@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mpcorr2","@stdlib/stats/incr/pcorr"],"@stdlib/stats/incr/pcorrdist":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/pcorrdistmat":["@stdlib/stats/incr/pcorrdist","@stdlib/stats/incr/pcorrmat"],"@stdlib/stats/incr/pcorrmat":["@stdlib/stats/incr/covmat","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/pcorrdistmat"],"@stdlib/stats/incr/prod":["@stdlib/stats/incr/mprod","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/range":["@stdlib/stats/incr/max","@stdlib/stats/incr/mean","@stdlib/stats/incr/min","@stdlib/stats/incr/mrange","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/rmse":["@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mse","@stdlib/stats/incr/rss"],"@stdlib/stats/incr/rss":["@stdlib/stats/incr/mrss","@stdlib/stats/incr/mse","@stdlib/stats/incr/rmse"],"@stdlib/ml/incr/sgd-regression":["@stdlib/ml/incr/binary-classification"],"@stdlib/stats/incr/skewness":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/array/incrspace":["@stdlib/array/linspace","@stdlib/array/logspace"],"@stdlib/stats/incr/stdev":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/skewness","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/sum":["@stdlib/stats/incr/count","@stdlib/stats/incr/mean","@stdlib/stats/incr/msum","@stdlib/stats/incr/prod","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/sumabs":["@stdlib/stats/incr/meanabs","@stdlib/stats/incr/msumabs","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/sumabs2":["@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/msumabs2","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/summary":["@stdlib/stats/incr/count","@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/max","@stdlib/stats/incr/mean","@stdlib/stats/incr/midrange","@stdlib/stats/incr/min","@stdlib/stats/incr/msummary","@stdlib/stats/incr/range","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/sum","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/sumprod":["@stdlib/stats/incr/msumprod","@stdlib/stats/incr/prod","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/variance":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/vmr":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mvmr","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/wmean":["@stdlib/stats/incr/ewmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmean"],"@stdlib/ndarray/ind2sub":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/sub2ind"],"@stdlib/utils/index-of":[],"@stdlib/utils/inherit":[],"@stdlib/utils/inherited-enumerable-properties":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-properties-in","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-properties"],"@stdlib/utils/inherited-enumerable-property-symbols":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/inherited-keys":["@stdlib/utils/keys","@stdlib/utils/keys-in","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-nonenumerable-properties":["@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-nonenumerable-property-names":["@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/inherited-nonenumerable-property-symbols":["@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-properties","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/inherited-properties":["@stdlib/utils/properties","@stdlib/utils/properties-in","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-descriptor":["@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptor-in","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-descriptors":["@stdlib/utils/property-descriptors","@stdlib/utils/property-descriptors-in","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-names":["@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-symbols","@stdlib/utils/property-names","@stdlib/utils/property-names-in"],"@stdlib/utils/inherited-property-symbols":["@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-names","@stdlib/utils/property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/utils/inherited-writable-properties":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties","@stdlib/utils/writable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-writable-property-names":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-names-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-writable-property-symbols":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-property-symbols","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/properties"],"@stdlib/utils/inmap":["@stdlib/utils/for-each","@stdlib/utils/inmap-right","@stdlib/utils/map"],"@stdlib/utils/async/inmap":["@stdlib/utils/async/for-each","@stdlib/utils/async/inmap-right","@stdlib/utils/inmap"],"@stdlib/utils/inmap-right":["@stdlib/utils/for-each-right","@stdlib/utils/inmap","@stdlib/utils/map-right"],"@stdlib/utils/async/inmap-right":["@stdlib/utils/async/for-each-right","@stdlib/utils/async/inmap","@stdlib/utils/inmap-right"],"@stdlib/streams/node/inspect-sink":["@stdlib/streams/node/debug-sink","@stdlib/streams/node/inspect"],"@stdlib/streams/node/inspect":["@stdlib/streams/node/debug"],"@stdlib/assert/instance-of":["@stdlib/assert/is-prototype-of","@stdlib/utils/constructor-name","@stdlib/utils/inherit","@stdlib/utils/type-of"],"@stdlib/constants/int8/max":["@stdlib/constants/int8/min"],"@stdlib/constants/int8/min":["@stdlib/constants/int8/max"],"@stdlib/constants/int8/num-bytes":["@stdlib/constants/int16/num-bytes","@stdlib/constants/int32/num-bytes","@stdlib/constants/uint8/num-bytes"],"@stdlib/array/int8":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/int16/max":["@stdlib/constants/int16/min"],"@stdlib/constants/int16/min":["@stdlib/constants/int16/max"],"@stdlib/constants/int16/num-bytes":["@stdlib/constants/int32/num-bytes","@stdlib/constants/int8/num-bytes","@stdlib/constants/uint16/num-bytes"],"@stdlib/array/int16":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/int32/max":["@stdlib/constants/int32/min"],"@stdlib/constants/int32/min":["@stdlib/constants/int32/max"],"@stdlib/constants/int32/num-bytes":["@stdlib/constants/int16/num-bytes","@stdlib/constants/int8/num-bytes","@stdlib/constants/uint32/num-bytes"],"@stdlib/array/int32":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/assert/is-big-endian":["@stdlib/assert/is-little-endian"],"@stdlib/assert/is-browser":[],"@stdlib/assert/is-darwin":[],"@stdlib/assert/is-docker":[],"@stdlib/assert/is-electron":["@stdlib/assert/is-electron-main","@stdlib/assert/is-electron-renderer"],"@stdlib/assert/is-electron-main":["@stdlib/assert/is-electron","@stdlib/assert/is-electron-renderer"],"@stdlib/assert/is-electron-renderer":["@stdlib/assert/is-electron","@stdlib/assert/is-electron-main"],"@stdlib/assert/is-little-endian":["@stdlib/assert/is-big-endian"],"@stdlib/assert/is-mobile":[],"@stdlib/assert/is-node":[],"@stdlib/assert/is-touch-device":[],"@stdlib/assert/is-web-worker":[],"@stdlib/assert/is-windows":[],"@stdlib/assert/is-absolute-http-uri":["@stdlib/assert/is-absolute-uri"],"@stdlib/assert/is-absolute-path":["@stdlib/assert/is-relative-path"],"@stdlib/assert/is-absolute-uri":["@stdlib/assert/is-relative-uri"],"@stdlib/assert/is-accessor-array":["@stdlib/assert/is-array-like","@stdlib/assert/is-array-like-object","@stdlib/assert/is-collection"],"@stdlib/assert/is-accessor-property":["@stdlib/assert/has-own-property","@stdlib/assert/is-accessor-property-in","@stdlib/assert/is-data-property"],"@stdlib/assert/is-accessor-property-in":["@stdlib/assert/has-property","@stdlib/assert/is-accessor-property","@stdlib/assert/is-data-property-in"],"@stdlib/assert/is-alphagram":["@stdlib/assert/is-anagram"],"@stdlib/assert/is-alphanumeric":["@stdlib/assert/is-digit-string"],"@stdlib/assert/is-anagram":["@stdlib/assert/is-alphagram"],"@stdlib/assert/is-arguments":[],"@stdlib/assert/is-array":["@stdlib/assert/is-array-like"],"@stdlib/assert/is-array-array":[],"@stdlib/assert/is-arraybuffer":["@stdlib/assert/is-sharedarraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-arraybuffer-view":["@stdlib/assert/is-dataview","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-array-length":["@stdlib/assert/is-array"],"@stdlib/assert/is-array-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like-object","@stdlib/assert/is-collection"],"@stdlib/assert/is-array-like-object":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-collection"],"@stdlib/assert/is-arrow-function":[],"@stdlib/assert/is-ascii":["@stdlib/assert/is-string"],"@stdlib/assert/is-between":["@stdlib/assert/is-between-array"],"@stdlib/assert/is-between-array":["@stdlib/assert/is-between"],"@stdlib/assert/is-bigint":[],"@stdlib/assert/is-bigint64array":["@stdlib/assert/is-biguint64array"],"@stdlib/assert/is-biguint64array":["@stdlib/assert/is-bigint64array"],"@stdlib/assert/is-binary-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-blank-string":["@stdlib/assert/is-string","@stdlib/assert/is-empty-string"],"@stdlib/assert/is-boolean":[],"@stdlib/assert/is-boolean-array":[],"@stdlib/assert/is-boxed-primitive":["@stdlib/assert/is-primitive"],"@stdlib/assert/is-buffer":[],"@stdlib/assert/is-camelcase":["@stdlib/assert/is-string","@stdlib/assert/is-constantcase"],"@stdlib/assert/is-capitalized":["@stdlib/assert/is-string"],"@stdlib/assert/is-centrosymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-circular":["@stdlib/assert/is-circular-array","@stdlib/assert/is-circular-plain-object"],"@stdlib/assert/is-circular-array":["@stdlib/assert/is-circular","@stdlib/assert/is-circular-plain-object"],"@stdlib/assert/is-circular-plain-object":["@stdlib/assert/is-circular","@stdlib/assert/is-circular-array"],"@stdlib/assert/is-class":[],"@stdlib/assert/is-collection":["@stdlib/assert/is-array-like","@stdlib/assert/is-array-like-object"],"@stdlib/assert/is-complex":["@stdlib/assert/is-complex64","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex64":["@stdlib/assert/is-complex","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex64array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64","@stdlib/assert/is-complex128array","@stdlib/assert/is-complex-typed-array"],"@stdlib/assert/is-complex64matrix-like":["@stdlib/assert/is-complex128matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-complex64ndarray-like":["@stdlib/assert/is-complex128ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-complex64vector-like":["@stdlib/assert/is-complex128vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-complex128":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64"],"@stdlib/assert/is-complex128array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex128","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex-typed-array"],"@stdlib/assert/is-complex128matrix-like":["@stdlib/assert/is-complex64matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-complex128ndarray-like":["@stdlib/assert/is-complex64ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-complex128vector-like":["@stdlib/assert/is-complex64vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-complex-like":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex-typed-array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex128array"],"@stdlib/assert/is-complex-typed-array-like":["@stdlib/assert/is-complex-like","@stdlib/assert/is-complex-typed-array","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex128array"],"@stdlib/assert/is-composite":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-prime"],"@stdlib/assert/is-configurable-property":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-configurable-property-in":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-constantcase":["@stdlib/assert/is-string","@stdlib/assert/is-camelcase"],"@stdlib/assert/is-cube-number":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-square-number"],"@stdlib/assert/is-current-year":[],"@stdlib/assert/is-data-property":["@stdlib/assert/has-own-property","@stdlib/assert/is-accessor-property","@stdlib/assert/is-data-property-in"],"@stdlib/assert/is-data-property-in":["@stdlib/assert/has-property","@stdlib/assert/is-accessor-property-in","@stdlib/assert/is-data-property"],"@stdlib/assert/is-dataview":["@stdlib/assert/is-arraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-date-object":[],"@stdlib/assert/is-date-object-array":["@stdlib/assert/is-date-object"],"@stdlib/assert/is-digit-string":["@stdlib/assert/is-hex-string","@stdlib/assert/is-string"],"@stdlib/assert/is-domain-name":[],"@stdlib/assert/is-duration-string":[],"@stdlib/assert/is-email-address":[],"@stdlib/assert/is-empty-array":["@stdlib/assert/is-array","@stdlib/assert/is-empty-array-like-object","@stdlib/assert/is-empty-collection"],"@stdlib/assert/is-empty-array-like-object":["@stdlib/assert/is-array-like-object","@stdlib/assert/is-empty-array","@stdlib/assert/is-empty-collection"],"@stdlib/assert/is-empty-collection":["@stdlib/assert/is-collection","@stdlib/assert/is-empty-array","@stdlib/assert/is-empty-array-like-object"],"@stdlib/assert/is-empty-object":["@stdlib/assert/is-object","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-empty-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-enumerable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-enumerable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-equal-array":["@stdlib/assert/is-array","@stdlib/assert/is-same-array"],"@stdlib/assert/is-error":[],"@stdlib/assert/is-eval-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-even":["@stdlib/assert/is-odd"],"@stdlib/assert/is-falsy":["@stdlib/assert/is-falsy-array","@stdlib/assert/is-truthy"],"@stdlib/assert/is-falsy-array":["@stdlib/assert/is-falsy","@stdlib/assert/is-truthy-array"],"@stdlib/assert/is-finite":["@stdlib/assert/is-finite-array","@stdlib/assert/is-infinite"],"@stdlib/assert/is-finite-array":["@stdlib/assert/is-finite","@stdlib/assert/is-infinite"],"@stdlib/assert/is-float32array":["@stdlib/assert/is-float64array"],"@stdlib/assert/is-float32matrix-like":["@stdlib/assert/is-float64matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-float32ndarray-like":["@stdlib/assert/is-float64ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-float32vector-like":["@stdlib/assert/is-float64vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-float64array":["@stdlib/assert/is-float32array"],"@stdlib/assert/is-float64matrix-like":["@stdlib/assert/is-float32matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-matrix-like"],"@stdlib/assert/is-float64ndarray-like":["@stdlib/assert/is-float32ndarray-like","@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-float64vector-like":["@stdlib/assert/is-float32vector-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-function":[],"@stdlib/assert/is-function-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-generator-object":["@stdlib/assert/has-generator-support","@stdlib/assert/is-generator-object-like"],"@stdlib/assert/is-generator-object-like":["@stdlib/assert/has-generator-support","@stdlib/assert/is-generator-object"],"@stdlib/assert/is-gzip-buffer":["@stdlib/assert/is-buffer","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-hex-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-infinite":["@stdlib/assert/is-finite"],"@stdlib/assert/is-inherited-property":["@stdlib/assert/has-own-property","@stdlib/assert/has-property"],"@stdlib/assert/is-int8array":["@stdlib/assert/is-int16array","@stdlib/assert/is-int32array"],"@stdlib/assert/is-int16array":["@stdlib/assert/is-int32array","@stdlib/assert/is-int8array"],"@stdlib/assert/is-int32array":["@stdlib/assert/is-int16array","@stdlib/assert/is-int8array"],"@stdlib/assert/is-integer":["@stdlib/assert/is-number"],"@stdlib/assert/is-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-iterable-like":["@stdlib/assert/is-iterator-like"],"@stdlib/assert/is-iterator-like":["@stdlib/assert/is-iterable-like"],"@stdlib/assert/is-json":[],"@stdlib/assert/is-kebabcase":["@stdlib/assert/is-string"],"@stdlib/assert/is-leap-year":[],"@stdlib/assert/is-localhost":[],"@stdlib/assert/is-lowercase":["@stdlib/assert/is-string","@stdlib/assert/is-uppercase"],"@stdlib/assert/is-matrix-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-typed-array-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-method":["@stdlib/assert/has-own-property","@stdlib/assert/is-function","@stdlib/assert/is-method-in"],"@stdlib/assert/is-method-in":["@stdlib/assert/has-property","@stdlib/assert/is-function","@stdlib/assert/is-method"],"@stdlib/assert/is-multi-slice":["@stdlib/assert/is-slice","@stdlib/slice/multi"],"@stdlib/assert/is-named-typed-tuple-like":["@stdlib/dstructs/named-typed-tuple"],"@stdlib/assert/is-nan":["@stdlib/assert/is-number"],"@stdlib/assert/is-nan-array":["@stdlib/assert/is-nan"],"@stdlib/assert/is-native-function":["@stdlib/assert/is-function"],"@stdlib/assert/is-ndarray-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-matrix-like","@stdlib/assert/is-typed-array-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-ndarray-like-with-data-type":["@stdlib/assert/is-ndarray-like"],"@stdlib/assert/is-negative-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-negative-number","@stdlib/assert/is-positive-finite"],"@stdlib/assert/is-negative-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-negative-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-negative-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-negative-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-negative-zero":["@stdlib/assert/is-number","@stdlib/assert/is-positive-zero"],"@stdlib/assert/is-node-builtin":[],"@stdlib/assert/is-node-duplex-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-readable-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-repl":[],"@stdlib/assert/is-node-stream-like":[],"@stdlib/assert/is-node-transform-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-writable-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-nonconfigurable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-nonconfigurable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-nonenumerable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-nonenumerable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-nonnegative-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-nonnegative-number","@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-integer":["@stdlib/assert/is-integer","@stdlib/assert/is-nonnegative-number","@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonnegative-number":["@stdlib/assert/is-nonnegative-finite","@stdlib/assert/is-nonnegative-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonpositive-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-nonpositive-number"],"@stdlib/assert/is-nonpositive-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-nonpositive-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonpositive-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-nonpositive-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonsymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-null":["@stdlib/assert/is-undefined","@stdlib/assert/is-undefined-or-null"],"@stdlib/assert/is-null-array":["@stdlib/assert/is-array","@stdlib/assert/is-null"],"@stdlib/assert/is-number":[],"@stdlib/assert/is-number-array":["@stdlib/assert/is-array","@stdlib/assert/is-number","@stdlib/assert/is-numeric-array"],"@stdlib/assert/is-numeric-array":["@stdlib/assert/is-array","@stdlib/assert/is-number-array","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-object":["@stdlib/assert/is-object-like","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-object-array":["@stdlib/assert/is-array","@stdlib/assert/is-object"],"@stdlib/assert/is-object-like":["@stdlib/assert/is-object","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-odd":["@stdlib/assert/is-even"],"@stdlib/time/iso-weeks-in-year":[],"@stdlib/assert/is-pascalcase":["@stdlib/assert/is-string"],"@stdlib/assert/is-persymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-plain-object":["@stdlib/assert/is-object"],"@stdlib/assert/is-plain-object-array":["@stdlib/assert/is-array","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-positive-finite":["@stdlib/assert/is-finite","@stdlib/assert/is-positive-number"],"@stdlib/assert/is-positive-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-positive-integer-array":["@stdlib/assert/is-array","@stdlib/assert/is-integer","@stdlib/assert/is-positive-integer"],"@stdlib/assert/is-positive-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-positive-number-array":["@stdlib/assert/is-array","@stdlib/assert/is-number","@stdlib/assert/is-positive-number"],"@stdlib/assert/is-positive-zero":["@stdlib/assert/is-number","@stdlib/assert/is-negative-zero"],"@stdlib/assert/is-prime":["@stdlib/assert/is-composite","@stdlib/assert/is-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-primitive":["@stdlib/assert/is-boxed-primitive"],"@stdlib/assert/is-primitive-array":["@stdlib/assert/is-array","@stdlib/assert/is-primitive"],"@stdlib/assert/is-prng-like":[],"@stdlib/assert/is-probability":["@stdlib/assert/is-number"],"@stdlib/assert/is-probability-array":["@stdlib/assert/is-array","@stdlib/assert/is-probability"],"@stdlib/assert/is-property-key":["@stdlib/assert/is-string","@stdlib/assert/is-symbol","@stdlib/assert/is-nonnegative-integer","@stdlib/assert/has-own-property","@stdlib/assert/has-property"],"@stdlib/assert/is-prototype-of":["@stdlib/utils/get-prototype-of"],"@stdlib/assert/is-ragged-nested-array":[],"@stdlib/assert/is-range-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-readable-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-readable-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-read-only-property":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-read-only-property-in":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-read-write-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-read-write-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-reference-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-regexp":[],"@stdlib/assert/is-regexp-string":["@stdlib/assert/is-regexp"],"@stdlib/assert/is-relative-path":["@stdlib/assert/is-absolute-path"],"@stdlib/assert/is-relative-uri":["@stdlib/assert/is-uri"],"@stdlib/assert/is-safe-integer":["@stdlib/assert/is-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-safe-integer-array":["@stdlib/assert/is-array","@stdlib/assert/is-safe-integer"],"@stdlib/assert/is-same-array":["@stdlib/assert/is-array","@stdlib/assert/is-equal-array","@stdlib/assert/is-same-array-like","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-array-like":["@stdlib/assert/is-array-like","@stdlib/assert/is-same-array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex64":["@stdlib/assert/is-complex64","@stdlib/assert/is-same-complex128","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex64array":["@stdlib/assert/is-complex64array","@stdlib/assert/is-same-complex128array","@stdlib/assert/is-same-float32array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex128":["@stdlib/assert/is-complex128","@stdlib/assert/is-same-complex64","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-complex128array":["@stdlib/assert/is-complex128array","@stdlib/assert/is-same-complex64array","@stdlib/assert/is-same-float64array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-date-object":["@stdlib/assert/is-date-object","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-float32array":["@stdlib/assert/is-same-float64array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-float64array":["@stdlib/assert/is-same-float32array","@stdlib/assert/is-same-value"],"@stdlib/assert/is-same-native-class":["@stdlib/assert/is-same-type","@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-type":["@stdlib/assert/is-same-native-class","@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-value":["@stdlib/assert/is-same-value-zero","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-value-zero":["@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-semver":[],"@stdlib/assert/is-sharedarraybuffer":["@stdlib/assert/is-arraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-skew-centrosymmetric-matrix":["@stdlib/assert/is-centrosymmetric-matrix","@stdlib/assert/is-matrix-like","@stdlib/assert/is-skew-symmetric-matrix"],"@stdlib/assert/is-skew-persymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-persymmetric-matrix","@stdlib/assert/is-skew-symmetric-matrix"],"@stdlib/assert/is-skew-symmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-skew-symmetric-matrix","@stdlib/assert/is-square-matrix"],"@stdlib/assert/is-slice":["@stdlib/assert/is-multi-slice","@stdlib/slice/ctor"],"@stdlib/assert/is-snakecase":["@stdlib/assert/is-string"],"@stdlib/assert/is-square-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-square-number":["@stdlib/assert/is-cube-number","@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-triangular-number"],"@stdlib/assert/is-square-triangular-number":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-square-number","@stdlib/assert/is-triangular-number"],"@stdlib/assert/is-startcase":["@stdlib/assert/is-string"],"@stdlib/assert/is-strict-equal":["@stdlib/assert/is-same-value"],"@stdlib/assert/is-string":[],"@stdlib/assert/is-string-array":["@stdlib/assert/is-array","@stdlib/assert/is-string"],"@stdlib/assert/is-symbol":[],"@stdlib/assert/is-symbol-array":["@stdlib/assert/is-array","@stdlib/assert/is-symbol"],"@stdlib/assert/is-symmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-nonsymmetric-matrix","@stdlib/assert/is-square-matrix"],"@stdlib/assert/is-syntax-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-triangular-number":["@stdlib/assert/is-integer","@stdlib/assert/is-number","@stdlib/assert/is-square-number","@stdlib/assert/is-square-triangular-number"],"@stdlib/assert/is-truthy":["@stdlib/assert/is-falsy"],"@stdlib/assert/is-truthy-array":["@stdlib/assert/is-falsy-array","@stdlib/assert/is-truthy"],"@stdlib/assert/is-typed-array":["@stdlib/assert/is-array","@stdlib/assert/is-typed-array-like"],"@stdlib/assert/is-typed-array-length":["@stdlib/assert/is-array-length","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-typed-array-like":["@stdlib/assert/is-typed-array"],"@stdlib/assert/is-type-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-uint8array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint16array","@stdlib/assert/is-uint32array"],"@stdlib/assert/is-uint8clampedarray":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-uint16array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint32array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-uint32array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint16array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-unc-path":[],"@stdlib/assert/is-undefined":["@stdlib/assert/is-null","@stdlib/assert/is-undefined-or-null"],"@stdlib/assert/is-undefined-or-null":["@stdlib/assert/is-null","@stdlib/assert/is-undefined"],"@stdlib/assert/is-unity-probability-array":["@stdlib/assert/is-probability","@stdlib/assert/is-probability-array"],"@stdlib/assert/is-uppercase":["@stdlib/assert/is-lowercase","@stdlib/assert/is-string"],"@stdlib/assert/is-uri":[],"@stdlib/assert/is-uri-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-vector-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-typed-array-like"],"@stdlib/assert/is-wasm-memory":["@stdlib/assert/has-wasm-support"],"@stdlib/assert/is-well-formed-string":[],"@stdlib/assert/is-whitespace":["@stdlib/regexp/whitespace"],"@stdlib/assert/is-writable-property":["@stdlib/assert/is-readable-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-writable-property-in","@stdlib/assert/is-write-only-property"],"@stdlib/assert/is-writable-property-in":["@stdlib/assert/is-readable-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-writable-property","@stdlib/assert/is-write-only-property-in"],"@stdlib/assert/is-write-only-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-writable-property","@stdlib/assert/is-write-only-property-in"],"@stdlib/assert/is-write-only-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-writable-property-in","@stdlib/assert/is-write-only-property"],"@stdlib/math/iter/special/abs":["@stdlib/math/base/special/abs","@stdlib/math/iter/special/abs2"],"@stdlib/math/iter/special/abs2":["@stdlib/math/base/special/abs2","@stdlib/math/iter/special/abs"],"@stdlib/math/iter/special/acos":["@stdlib/math/base/special/acos","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/acosh":["@stdlib/math/base/special/acosh","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/acot":["@stdlib/math/base/special/acot","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/acoth","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/acoth":["@stdlib/math/base/special/acoth","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/acot","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/acovercos":["@stdlib/math/base/special/acovercos","@stdlib/math/iter/special/acoversin","@stdlib/math/iter/special/avercos","@stdlib/math/iter/special/covercos","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/acoversin":["@stdlib/math/base/special/acoversin","@stdlib/math/iter/special/acovercos","@stdlib/math/iter/special/aversin","@stdlib/math/iter/special/coversin","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/ops/add":["@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/multiply","@stdlib/math/iter/ops/subtract"],"@stdlib/iter/advance":["@stdlib/iter/head","@stdlib/iter/slice"],"@stdlib/math/iter/special/ahavercos":["@stdlib/math/base/special/ahavercos","@stdlib/math/iter/special/ahaversin","@stdlib/math/iter/special/havercos","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/ahaversin":["@stdlib/math/base/special/ahaversin","@stdlib/math/iter/special/ahavercos","@stdlib/math/iter/special/haversin","@stdlib/math/iter/special/versin"],"@stdlib/iter/any":["@stdlib/iter/any-by","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some"],"@stdlib/iter/any-by":["@stdlib/iter/any","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some-by"],"@stdlib/math/iter/special/asin":["@stdlib/math/base/special/asin","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/asinh":["@stdlib/math/base/special/asinh","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/atan":["@stdlib/math/base/special/atan","@stdlib/math/iter/special/acos","@stdlib/math/iter/special/asin","@stdlib/math/iter/special/atanh"],"@stdlib/math/iter/special/atan2":["@stdlib/math/base/special/atan2","@stdlib/math/iter/special/atan"],"@stdlib/math/iter/special/atanh":["@stdlib/math/base/special/atanh","@stdlib/math/iter/special/acosh","@stdlib/math/iter/special/asinh","@stdlib/math/iter/special/atan"],"@stdlib/array/from-iterator":["@stdlib/array/to-iterator","@stdlib/iter/to-array-view"],"@stdlib/iter/to-array-view":["@stdlib/array/from-iterator","@stdlib/array/to-view-iterator","@stdlib/iter/to-array-view-right"],"@stdlib/iter/to-array-view-right":["@stdlib/array/from-iterator","@stdlib/array/to-view-iterator-right","@stdlib/iter/to-array-view"],"@stdlib/streams/node/from-iterator":["@stdlib/streams/node/from-array"],"@stdlib/symbol/iterator":["@stdlib/symbol/ctor"],"@stdlib/math/iter/special/avercos":["@stdlib/math/base/special/avercos","@stdlib/math/iter/special/aversin","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/special/aversin":["@stdlib/math/base/special/aversin","@stdlib/math/iter/special/avercos","@stdlib/math/iter/special/vercos"],"@stdlib/simulate/iter/awgn":["@stdlib/simulate/iter/awln","@stdlib/simulate/iter/awun"],"@stdlib/simulate/iter/awln":["@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awun"],"@stdlib/simulate/iter/awun":["@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awln"],"@stdlib/simulate/iter/bartlett-hann-pulse":["@stdlib/simulate/iter/bartlett-pulse","@stdlib/simulate/iter/hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/triangle-wave"],"@stdlib/simulate/iter/bartlett-pulse":["@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/triangle-wave"],"@stdlib/math/iter/special/besselj0":["@stdlib/math/base/special/besselj0","@stdlib/math/iter/special/besselj1","@stdlib/math/iter/special/bessely0","@stdlib/math/iter/special/bessely1"],"@stdlib/math/iter/special/besselj1":["@stdlib/math/base/special/besselj1","@stdlib/math/iter/special/besselj0","@stdlib/math/iter/special/bessely0","@stdlib/math/iter/special/bessely1"],"@stdlib/math/iter/special/bessely0":["@stdlib/math/base/special/bessely0","@stdlib/math/iter/special/besselj0","@stdlib/math/iter/special/besselj1","@stdlib/math/iter/special/bessely1"],"@stdlib/math/iter/special/bessely1":["@stdlib/math/base/special/bessely1","@stdlib/math/iter/special/besselj0","@stdlib/math/iter/special/besselj1","@stdlib/math/iter/special/bessely0"],"@stdlib/math/iter/special/beta":["@stdlib/math/base/special/beta","@stdlib/math/iter/special/betaln"],"@stdlib/math/iter/special/betaln":["@stdlib/math/base/special/betaln","@stdlib/math/iter/special/beta"],"@stdlib/math/iter/special/binet":["@stdlib/math/base/special/binet"],"@stdlib/math/iter/special/cbrt":["@stdlib/math/base/special/cbrt","@stdlib/math/iter/special/pow","@stdlib/math/iter/special/sqrt"],"@stdlib/math/iter/special/ceil":["@stdlib/math/base/special/ceil","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/round"],"@stdlib/math/iter/special/ceil2":["@stdlib/math/base/special/ceil2","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round2"],"@stdlib/math/iter/special/ceil10":["@stdlib/math/base/special/ceil10","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round10"],"@stdlib/math/iter/sequences/composites":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/positive-integers","@stdlib/math/iter/sequences/primes"],"@stdlib/iter/concat":[],"@stdlib/iter/constant":["@stdlib/utils/constant-function"],"@stdlib/math/iter/utils/continued-fraction":["@stdlib/math/iter/sequences/continued-fraction"],"@stdlib/math/iter/sequences/continued-fraction":["@stdlib/math/iter/utils/continued-fraction"],"@stdlib/math/iter/special/cos":["@stdlib/math/base/special/cos","@stdlib/math/iter/special/cospi","@stdlib/math/iter/special/sin","@stdlib/math/iter/special/tan"],"@stdlib/math/iter/special/cosh":["@stdlib/math/base/special/cosh","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sinh","@stdlib/math/iter/special/tanh"],"@stdlib/simulate/iter/cosine-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/math/iter/special/cosm1":["@stdlib/math/base/special/cosm1","@stdlib/math/iter/special/cos"],"@stdlib/math/iter/special/cospi":["@stdlib/math/base/special/cospi","@stdlib/math/iter/special/cos"],"@stdlib/iter/counter":["@stdlib/iter/length"],"@stdlib/math/iter/special/covercos":["@stdlib/math/base/special/covercos","@stdlib/math/iter/special/coversin","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/coversin":["@stdlib/math/base/special/coversin","@stdlib/math/iter/special/covercos","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/sequences/cubes":["@stdlib/math/iter/sequences/fourth-powers","@stdlib/math/iter/sequences/squares"],"@stdlib/stats/iter/cugmean":["@stdlib/stats/iter/cuhmean","@stdlib/stats/iter/cumean"],"@stdlib/stats/iter/cuhmean":["@stdlib/stats/iter/cugmean","@stdlib/stats/iter/cumean"],"@stdlib/stats/iter/cumax":["@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cumin","@stdlib/stats/iter/curange","@stdlib/stats/iter/max"],"@stdlib/stats/iter/cumaxabs":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cuminabs","@stdlib/stats/iter/maxabs"],"@stdlib/stats/iter/cumean":["@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cusum","@stdlib/stats/iter/mean"],"@stdlib/stats/iter/cumeanabs":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/meanabs"],"@stdlib/stats/iter/cumeanabs2":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cusumabs2","@stdlib/stats/iter/meanabs2"],"@stdlib/stats/iter/cumidrange":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumin","@stdlib/stats/iter/curange","@stdlib/stats/iter/midrange"],"@stdlib/stats/iter/cumin":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/curange","@stdlib/stats/iter/min"],"@stdlib/stats/iter/cuminabs":["@stdlib/stats/iter/cumaxabs","@stdlib/stats/iter/cumin","@stdlib/stats/iter/minabs"],"@stdlib/stats/iter/cuprod":["@stdlib/stats/iter/cusum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/curange":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/cusum":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/sum","@stdlib/stats/iter/cuprod"],"@stdlib/stats/iter/cusumabs":["@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cusum","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/cusumabs2":["@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/sumabs2"],"@stdlib/iter/datespace":["@stdlib/array/from-iterator","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/logspace","@stdlib/iter/step"],"@stdlib/iter/dedupe":["@stdlib/iter/dedupe-by","@stdlib/iter/unique"],"@stdlib/iter/dedupe-by":["@stdlib/iter/dedupe","@stdlib/iter/unique"],"@stdlib/math/iter/special/deg2rad":["@stdlib/math/base/special/deg2rad","@stdlib/math/iter/special/rad2deg"],"@stdlib/math/iter/special/digamma":["@stdlib/math/base/special/digamma","@stdlib/math/iter/special/gamma","@stdlib/math/iter/special/trigamma"],"@stdlib/simulate/iter/dirac-comb":["@stdlib/simulate/iter/pulse"],"@stdlib/math/iter/special/dirac-delta":["@stdlib/math/base/special/dirac-delta"],"@stdlib/math/iter/ops/divide":["@stdlib/math/iter/ops/add","@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/multiply"],"@stdlib/iter/do-until-each":["@stdlib/iter/do-while-each","@stdlib/iter/until-each","@stdlib/iter/while-each"],"@stdlib/iter/do-while-each":["@stdlib/iter/do-until-each","@stdlib/iter/until-each","@stdlib/iter/while-each"],"@stdlib/math/iter/special/ellipe":["@stdlib/math/base/special/ellipe","@stdlib/math/iter/special/ellipk"],"@stdlib/math/iter/special/ellipk":["@stdlib/math/base/special/ellipk","@stdlib/math/iter/special/ellipe"],"@stdlib/iter/empty":["@stdlib/iter/constant"],"@stdlib/math/iter/special/erf":["@stdlib/math/base/special/erf","@stdlib/math/iter/special/erfc","@stdlib/math/iter/special/erfinv","@stdlib/math/iter/special/erfcinv"],"@stdlib/math/iter/special/erfc":["@stdlib/math/base/special/erfc","@stdlib/math/iter/special/erf","@stdlib/math/iter/special/erfinv","@stdlib/math/iter/special/erfcinv"],"@stdlib/math/iter/special/erfcinv":["@stdlib/math/base/special/erfcinv","@stdlib/math/iter/special/erf","@stdlib/math/iter/special/erfc","@stdlib/math/iter/special/erfinv"],"@stdlib/math/iter/special/erfinv":["@stdlib/math/base/special/erfinv","@stdlib/math/iter/special/erf","@stdlib/math/iter/special/erfc","@stdlib/math/iter/special/erfcinv"],"@stdlib/math/iter/special/dirichlet-eta":["@stdlib/math/base/special/dirichlet-eta"],"@stdlib/math/iter/sequences/even-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/odd-integers"],"@stdlib/iter/every":["@stdlib/iter/any","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some"],"@stdlib/iter/every-by":["@stdlib/iter/any-by","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some-by"],"@stdlib/math/iter/special/exp":["@stdlib/math/base/special/exp","@stdlib/math/iter/special/exp10","@stdlib/math/iter/special/exp2","@stdlib/math/iter/special/expm1","@stdlib/math/iter/special/ln"],"@stdlib/math/iter/special/exp2":["@stdlib/math/base/special/exp2","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/exp10","@stdlib/math/iter/special/log2"],"@stdlib/math/iter/special/exp10":["@stdlib/math/base/special/exp10","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/exp2","@stdlib/math/iter/special/log10"],"@stdlib/math/iter/special/expit":["@stdlib/math/base/special/expit","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/logit"],"@stdlib/math/iter/special/expm1":["@stdlib/math/base/special/expm1","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/expm1rel"],"@stdlib/math/iter/special/expm1rel":["@stdlib/math/base/special/expm1rel","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/expm1"],"@stdlib/math/iter/special/factorial":["@stdlib/math/base/special/factorial","@stdlib/math/iter/special/factorialln"],"@stdlib/math/iter/special/factorialln":["@stdlib/math/base/special/factorialln","@stdlib/math/iter/special/factorial"],"@stdlib/math/iter/sequences/factorials":["@stdlib/math/iter/special/factorial"],"@stdlib/math/iter/sequences/fibonacci":["@stdlib/math/base/special/fibonacci","@stdlib/math/iter/sequences/lucas","@stdlib/math/iter/sequences/negafibonacci","@stdlib/math/iter/sequences/nonfibonacci"],"@stdlib/math/iter/sequences/fifth-powers":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/fourth-powers","@stdlib/math/iter/sequences/squares"],"@stdlib/iter/fill":[],"@stdlib/iter/filter":["@stdlib/iter/filter-map","@stdlib/iter/map","@stdlib/iter/reject"],"@stdlib/iter/filter-map":["@stdlib/iter/filter","@stdlib/iter/map"],"@stdlib/iter/first":["@stdlib/iter/head","@stdlib/iter/last","@stdlib/iter/nth"],"@stdlib/simulate/iter/flat-top-pulse":["@stdlib/simulate/iter/pulse"],"@stdlib/math/iter/special/floor":["@stdlib/math/base/special/floor","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/round"],"@stdlib/math/iter/special/floor2":["@stdlib/math/base/special/floor2","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round2"],"@stdlib/math/iter/special/floor10":["@stdlib/math/base/special/floor10","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round10"],"@stdlib/iter/flow":["@stdlib/iter/pipeline"],"@stdlib/iter/for-each":["@stdlib/iter/map"],"@stdlib/math/iter/sequences/fourth-powers":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/fifth-powers","@stdlib/math/iter/sequences/squares"],"@stdlib/math/iter/special/fresnelc":["@stdlib/math/base/special/fresnelc","@stdlib/math/iter/special/fresnels"],"@stdlib/math/iter/special/fresnels":["@stdlib/math/base/special/fresnels","@stdlib/math/iter/special/fresnelc"],"@stdlib/math/iter/special/gamma":["@stdlib/math/base/special/gamma","@stdlib/math/iter/special/gamma1pm1","@stdlib/math/iter/special/gammaln"],"@stdlib/math/iter/special/gamma1pm1":["@stdlib/math/base/special/gamma1pm1","@stdlib/math/iter/special/gamma"],"@stdlib/math/iter/special/gammaln":["@stdlib/math/base/special/gammaln","@stdlib/math/iter/special/gamma"],"@stdlib/math/iter/special/hacovercos":["@stdlib/math/base/special/hacovercos","@stdlib/math/iter/special/covercos","@stdlib/math/iter/special/hacoversin"],"@stdlib/math/iter/special/hacoversin":["@stdlib/math/base/special/hacoversin","@stdlib/math/iter/special/coversin","@stdlib/math/iter/special/hacovercos"],"@stdlib/simulate/iter/hann-pulse":["@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sine-wave"],"@stdlib/math/iter/special/havercos":["@stdlib/math/base/special/havercos","@stdlib/math/iter/special/haversin","@stdlib/math/iter/special/vercos"],"@stdlib/math/iter/special/haversin":["@stdlib/math/base/special/haversin","@stdlib/math/iter/special/havercos","@stdlib/math/iter/special/versin"],"@stdlib/iter/head":["@stdlib/iter/first","@stdlib/iter/slice"],"@stdlib/iter/incrspace":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/linspace","@stdlib/iter/logspace","@stdlib/iter/step","@stdlib/iter/unitspace"],"@stdlib/math/iter/sequences/integers":["@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/iter/intersection":["@stdlib/iter/intersection-by-hash","@stdlib/iter/union","@stdlib/iter/unique"],"@stdlib/iter/intersection-by-hash":["@stdlib/iter/intersection","@stdlib/iter/unique-by-hash"],"@stdlib/math/iter/special/inv":["@stdlib/math/base/special/inv","@stdlib/math/iter/special/pow"],"@stdlib/simulate/iter/lanczos-pulse":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/periodic-sinc"],"@stdlib/iter/last":["@stdlib/iter/first","@stdlib/iter/nth"],"@stdlib/iter/length":["@stdlib/iter/counter"],"@stdlib/iter/linspace":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/incrspace","@stdlib/iter/logspace","@stdlib/iter/step","@stdlib/iter/unitspace"],"@stdlib/math/iter/special/ln":["@stdlib/math/base/special/ln","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log2"],"@stdlib/math/iter/special/log":["@stdlib/math/base/special/log","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log2","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log1mexp":["@stdlib/math/base/special/log1mexp","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log1pexp","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log1p":["@stdlib/math/base/special/log1p","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log2","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log1pexp":["@stdlib/math/base/special/log1pexp","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log1mexp","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log2":["@stdlib/math/base/special/log2","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log10","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/log10":["@stdlib/math/base/special/log10","@stdlib/math/iter/special/log","@stdlib/math/iter/special/log1p","@stdlib/math/iter/special/log2","@stdlib/math/iter/special/pow"],"@stdlib/math/iter/special/logit":["@stdlib/math/base/special/logit"],"@stdlib/iter/logspace":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/step"],"@stdlib/math/iter/sequences/lucas":["@stdlib/math/base/special/lucas","@stdlib/math/iter/sequences/fibonacci","@stdlib/math/iter/sequences/negalucas"],"@stdlib/iter/map":["@stdlib/iter/filter","@stdlib/iter/filter-map","@stdlib/iter/for-each","@stdlib/iter/reject"],"@stdlib/iter/mapn":["@stdlib/iter/map"],"@stdlib/stats/iter/max":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/min","@stdlib/stats/iter/mmax","@stdlib/stats/iter/range"],"@stdlib/stats/iter/maxabs":["@stdlib/stats/iter/max","@stdlib/stats/iter/minabs","@stdlib/stats/iter/mmaxabs"],"@stdlib/stats/iter/mean":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmean","@stdlib/stats/iter/stdev","@stdlib/stats/iter/sum","@stdlib/stats/iter/variance"],"@stdlib/stats/iter/meanabs":["@stdlib/stats/iter/mean","@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/meanabs2":["@stdlib/stats/iter/mean","@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/sumabs2"],"@stdlib/stats/iter/midrange":["@stdlib/stats/iter/mean","@stdlib/stats/iter/max","@stdlib/stats/iter/min","@stdlib/stats/iter/range"],"@stdlib/stats/iter/min":["@stdlib/stats/iter/max","@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/minabs":["@stdlib/stats/iter/maxabs","@stdlib/stats/iter/min","@stdlib/stats/iter/mminabs"],"@stdlib/stats/iter/mmax":["@stdlib/stats/iter/max","@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/mmin","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mmaxabs":["@stdlib/stats/iter/maxabs","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mminabs"],"@stdlib/stats/iter/mmean":["@stdlib/stats/iter/mean","@stdlib/stats/iter/msum"],"@stdlib/stats/iter/mmeanabs":["@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mmean","@stdlib/stats/iter/msumabs"],"@stdlib/stats/iter/mmeanabs2":["@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/msumabs2"],"@stdlib/stats/iter/mmidrange":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmean","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmin","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mmin":["@stdlib/stats/iter/min","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mminabs":["@stdlib/stats/iter/minabs","@stdlib/stats/iter/mmaxabs","@stdlib/stats/iter/mmin"],"@stdlib/math/iter/ops/mod":["@stdlib/math/iter/ops/divide"],"@stdlib/stats/iter/mprod":["@stdlib/stats/iter/msum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/mrange":["@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmean","@stdlib/stats/iter/mmin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/msum":["@stdlib/stats/iter/mmean","@stdlib/stats/iter/sum"],"@stdlib/stats/iter/msumabs":["@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/msum","@stdlib/stats/iter/sum","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/msumabs2":["@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/msumabs","@stdlib/stats/iter/sumabs","@stdlib/stats/iter/sumabs2"],"@stdlib/math/iter/ops/multiply":["@stdlib/math/iter/ops/add","@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/subtract"],"@stdlib/math/iter/sequences/negafibonacci":["@stdlib/math/base/special/negafibonacci","@stdlib/math/iter/sequences/fibonacci","@stdlib/math/iter/sequences/nonfibonacci"],"@stdlib/math/iter/sequences/negalucas":["@stdlib/math/base/special/negalucas","@stdlib/math/iter/sequences/lucas","@stdlib/math/iter/sequences/negafibonacci"],"@stdlib/math/iter/sequences/negative-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/negative-odd-integers","@stdlib/math/iter/sequences/positive-even-integers","@stdlib/math/iter/sequences/nonpositive-even-integers"],"@stdlib/math/iter/sequences/negative-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/sequences/negative-odd-integers":["@stdlib/math/iter/sequences/odd-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/negative-even-integers","@stdlib/math/iter/sequences/positive-odd-integers"],"@stdlib/iter/none":["@stdlib/iter/any","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some"],"@stdlib/iter/none-by":["@stdlib/iter/any-by","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some-by"],"@stdlib/math/iter/sequences/nonfibonacci":["@stdlib/math/base/special/nonfibonacci","@stdlib/math/iter/sequences/fibonacci"],"@stdlib/math/iter/sequences/nonnegative-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-even-integers","@stdlib/math/iter/sequences/positive-even-integers"],"@stdlib/math/iter/sequences/nonnegative-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/sequences/nonpositive-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/nonnegative-even-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/negative-even-integers"],"@stdlib/math/iter/sequences/nonpositive-integers":["@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-integers","@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/sequences/nonsquares":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/squares"],"@stdlib/iter/nth":["@stdlib/iter/first","@stdlib/iter/last"],"@stdlib/math/iter/sequences/odd-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers"],"@stdlib/simulate/iter/periodic-sinc":["@stdlib/simulate/iter/sine-wave"],"@stdlib/iter/pipeline":["@stdlib/iter/flow","@stdlib/iter/pipeline-thunk"],"@stdlib/iter/pop":["@stdlib/iter/push","@stdlib/iter/shift","@stdlib/iter/slice"],"@stdlib/math/iter/sequences/positive-even-integers":["@stdlib/math/iter/sequences/even-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-even-integers","@stdlib/math/iter/sequences/nonnegative-even-integers","@stdlib/math/iter/sequences/positive-integers","@stdlib/math/iter/sequences/positive-odd-integers"],"@stdlib/math/iter/sequences/positive-integers":["@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math/iter/sequences/negative-integers"],"@stdlib/math/iter/sequences/positive-odd-integers":["@stdlib/math/iter/sequences/odd-integers","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/negative-odd-integers","@stdlib/math/iter/sequences/positive-even-integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/math/iter/special/pow":["@stdlib/math/base/special/pow","@stdlib/math/iter/special/exp","@stdlib/math/iter/special/log"],"@stdlib/math/iter/sequences/primes":["@stdlib/math/iter/sequences/composites","@stdlib/math/iter/sequences/integers","@stdlib/math/iter/sequences/positive-integers"],"@stdlib/stats/iter/prod":["@stdlib/stats/iter/mprod","@stdlib/stats/iter/sum"],"@stdlib/simulate/iter/pulse":["@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/push":["@stdlib/iter/concat","@stdlib/iter/unshift"],"@stdlib/math/iter/special/rad2deg":["@stdlib/math/base/special/rad2deg","@stdlib/math/iter/special/deg2rad"],"@stdlib/math/iter/special/ramp":["@stdlib/math/base/special/ramp"],"@stdlib/stats/iter/range":["@stdlib/stats/iter/max","@stdlib/stats/iter/mean","@stdlib/stats/iter/min","@stdlib/stats/iter/mrange"],"@stdlib/iter/reject":["@stdlib/iter/filter","@stdlib/iter/map"],"@stdlib/iter/replicate":["@stdlib/iter/replicate-by"],"@stdlib/iter/replicate-by":["@stdlib/iter/replicate"],"@stdlib/math/iter/special/round":["@stdlib/math/base/special/round","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/trunc"],"@stdlib/math/iter/special/round2":["@stdlib/math/base/special/round2","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round","@stdlib/math/iter/special/round10","@stdlib/math/iter/special/trunc2"],"@stdlib/math/iter/special/round10":["@stdlib/math/base/special/round10","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round","@stdlib/math/iter/special/round2","@stdlib/math/iter/special/trunc10"],"@stdlib/math/iter/special/rsqrt":["@stdlib/math/base/special/rsqrt","@stdlib/math/iter/special/sqrt"],"@stdlib/simulate/iter/sawtooth-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/shift":["@stdlib/iter/pop","@stdlib/iter/slice","@stdlib/iter/unshift"],"@stdlib/math/iter/special/signum":["@stdlib/math/base/special/signum"],"@stdlib/math/iter/special/sin":["@stdlib/math/base/special/sin","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sinpi","@stdlib/math/iter/special/tan"],"@stdlib/math/iter/special/sinc":["@stdlib/math/base/special/sinc","@stdlib/math/iter/special/sin"],"@stdlib/simulate/iter/sine-wave":["@stdlib/simulate/iter/cosine-wave","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/math/iter/special/sinh":["@stdlib/math/base/special/sinh","@stdlib/math/iter/special/cosh","@stdlib/math/iter/special/tanh"],"@stdlib/math/iter/special/sinpi":["@stdlib/math/base/special/sinpi","@stdlib/math/iter/special/sin"],"@stdlib/iter/slice":["@stdlib/iter/first","@stdlib/iter/head"],"@stdlib/iter/some":["@stdlib/iter/any","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some-by"],"@stdlib/iter/some-by":["@stdlib/iter/any-by","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some"],"@stdlib/math/iter/special/spence":["@stdlib/math/base/special/spence"],"@stdlib/math/iter/special/sqrt":["@stdlib/math/base/special/sqrt","@stdlib/math/iter/special/cbrt","@stdlib/math/iter/special/rsqrt"],"@stdlib/math/iter/special/sqrt1pm1":["@stdlib/math/base/special/sqrt1pm1","@stdlib/math/iter/special/sqrt"],"@stdlib/math/iter/sequences/squared-triangular":["@stdlib/math/iter/sequences/triangular"],"@stdlib/math/iter/sequences/squares":["@stdlib/math/iter/sequences/cubes","@stdlib/math/iter/sequences/nonsquares"],"@stdlib/simulate/iter/square-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/stats/iter/stdev":["@stdlib/stats/iter/mean","@stdlib/stats/iter/variance"],"@stdlib/iter/step":["@stdlib/array/from-iterator","@stdlib/iter/datespace","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/logspace","@stdlib/iter/unitspace"],"@stdlib/iter/strided":["@stdlib/iter/advance","@stdlib/iter/nth","@stdlib/iter/strided-by"],"@stdlib/iter/strided-by":["@stdlib/iter/advance","@stdlib/iter/nth","@stdlib/iter/strided"],"@stdlib/math/iter/ops/subtract":["@stdlib/math/iter/ops/add","@stdlib/math/iter/ops/divide","@stdlib/math/iter/ops/multiply"],"@stdlib/stats/iter/sum":["@stdlib/stats/iter/mean","@stdlib/stats/iter/msum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/sumabs":["@stdlib/stats/iter/meanabs","@stdlib/stats/iter/msumabs","@stdlib/stats/iter/sum"],"@stdlib/stats/iter/sumabs2":["@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/msumabs2","@stdlib/stats/iter/sumabs"],"@stdlib/math/iter/special/tan":["@stdlib/math/base/special/tan","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sin"],"@stdlib/math/iter/special/tanh":["@stdlib/math/base/special/tanh","@stdlib/math/iter/special/cosh","@stdlib/math/iter/special/sinh","@stdlib/math/iter/special/tan"],"@stdlib/iter/pipeline-thunk":["@stdlib/iter/pipeline"],"@stdlib/simulate/iter/triangle-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave"],"@stdlib/math/iter/sequences/triangular":["@stdlib/math/iter/sequences/squared-triangular"],"@stdlib/math/iter/sequences/tribonacci":["@stdlib/math/base/special/tribonacci","@stdlib/math/base/special/fibonacci","@stdlib/math/iter/sequences/lucas"],"@stdlib/math/iter/special/trigamma":["@stdlib/math/base/special/trigamma","@stdlib/math/iter/special/digamma","@stdlib/math/iter/special/gamma"],"@stdlib/math/iter/special/trunc":["@stdlib/math/base/special/trunc","@stdlib/math/iter/special/ceil","@stdlib/math/iter/special/floor","@stdlib/math/iter/special/round"],"@stdlib/math/iter/special/trunc2":["@stdlib/math/base/special/trunc2","@stdlib/math/iter/special/ceil2","@stdlib/math/iter/special/floor2","@stdlib/math/iter/special/round2","@stdlib/math/iter/special/trunc"],"@stdlib/math/iter/special/trunc10":["@stdlib/math/base/special/trunc10","@stdlib/math/iter/special/ceil10","@stdlib/math/iter/special/floor10","@stdlib/math/iter/special/round10","@stdlib/math/iter/special/trunc"],"@stdlib/iter/union":["@stdlib/iter/intersection","@stdlib/iter/unique"],"@stdlib/iter/unique":["@stdlib/iter/unique-by","@stdlib/iter/unique-by-hash"],"@stdlib/iter/unique-by":["@stdlib/iter/unique","@stdlib/iter/unique-by-hash"],"@stdlib/iter/unique-by-hash":["@stdlib/iter/unique","@stdlib/iter/unique-by"],"@stdlib/iter/unitspace":["@stdlib/array/from-iterator","@stdlib/iter/incrspace","@stdlib/iter/linspace","@stdlib/iter/step"],"@stdlib/iter/unshift":["@stdlib/iter/concat","@stdlib/iter/push","@stdlib/iter/shift"],"@stdlib/iter/until-each":["@stdlib/iter/while-each"],"@stdlib/stats/iter/variance":["@stdlib/stats/iter/mean","@stdlib/stats/iter/stdev"],"@stdlib/math/iter/special/vercos":["@stdlib/math/base/special/vercos","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sin","@stdlib/math/iter/special/versin"],"@stdlib/math/iter/special/versin":["@stdlib/math/base/special/versin","@stdlib/math/iter/special/cos","@stdlib/math/iter/special/sin","@stdlib/math/iter/special/vercos"],"@stdlib/iter/while-each":["@stdlib/iter/until-each"],"@stdlib/math/iter/special/riemann-zeta":["@stdlib/math/base/special/riemann-zeta"],"@stdlib/streams/node/join":["@stdlib/streams/node/split"],"@stdlib/stats/kde2d":[],"@stdlib/string/kebabcase":["@stdlib/string/camelcase","@stdlib/string/constantcase","@stdlib/string/pascalcase","@stdlib/string/snakecase"],"@stdlib/utils/key-by":["@stdlib/utils/for-each"],"@stdlib/utils/key-by-right":["@stdlib/utils/for-each-right","@stdlib/utils/key-by"],"@stdlib/utils/keys-in":["@stdlib/utils/entries-in","@stdlib/utils/keys","@stdlib/utils/values-in"],"@stdlib/stats/kruskal-test":[],"@stdlib/stats/kstest":[],"@stdlib/string/last":["@stdlib/string/first"],"@stdlib/nlp/lda":[],"@stdlib/stats/levene-test":["@stdlib/stats/vartest","@stdlib/stats/bartlett-test"],"@stdlib/dstructs/linked-list":["@stdlib/dstructs/doubly-linked-list","@stdlib/dstructs/stack"],"@stdlib/array/linspace":["@stdlib/array/incrspace","@stdlib/array/logspace"],"@stdlib/datasets/liu-negative-opinion-words-en":["@stdlib/datasets/liu-positive-opinion-words-en"],"@stdlib/datasets/liu-positive-opinion-words-en":["@stdlib/datasets/liu-negative-opinion-words-en"],"@stdlib/constants/float64/ln-half":[],"@stdlib/constants/float64/ln-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/ln-sqrt-two-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/ln-two-pi":["@stdlib/constants/float64/two-pi"],"@stdlib/constants/float64/ln-two":["@stdlib/constants/float64/ln-ten"],"@stdlib/constants/float64/ln-ten":["@stdlib/constants/float64/ln-two"],"@stdlib/constants/float64/log2-e":["@stdlib/constants/float64/e","@stdlib/constants/float64/log10-e"],"@stdlib/constants/float64/log10-e":["@stdlib/constants/float64/e","@stdlib/constants/float64/log2-e"],"@stdlib/array/logspace":["@stdlib/array/incrspace","@stdlib/array/linspace"],"@stdlib/string/lowercase":["@stdlib/string/uncapitalize","@stdlib/string/uppercase"],"@stdlib/utils/lowercase-keys":["@stdlib/utils/uncapitalize-keys","@stdlib/utils/uppercase-keys"],"@stdlib/stats/lowess":[],"@stdlib/string/left-pad":["@stdlib/string/pad","@stdlib/string/right-pad"],"@stdlib/string/left-trim":["@stdlib/string/trim","@stdlib/string/right-trim"],"@stdlib/string/left-trim-n":["@stdlib/string/right-trim-n","@stdlib/string/trim"],"@stdlib/datasets/male-first-names-en":["@stdlib/datasets/female-first-names-en"],"@stdlib/utils/map":["@stdlib/utils/map-right","@stdlib/utils/reduce"],"@stdlib/utils/map2":["@stdlib/utils/map"],"@stdlib/utils/map2d":["@stdlib/utils/map","@stdlib/utils/map3d","@stdlib/utils/map4d","@stdlib/utils/map5d","@stdlib/utils/reduce2d"],"@stdlib/utils/map2-right":["@stdlib/utils/map-right","@stdlib/utils/map2"],"@stdlib/utils/map3d":["@stdlib/utils/map","@stdlib/utils/map2d","@stdlib/utils/map4d","@stdlib/utils/map5d"],"@stdlib/utils/map4d":["@stdlib/utils/map","@stdlib/utils/map2d","@stdlib/utils/map3d","@stdlib/utils/map5d"],"@stdlib/utils/map5d":["@stdlib/utils/map","@stdlib/utils/map2d","@stdlib/utils/map3d","@stdlib/utils/map4d"],"@stdlib/utils/map-arguments":["@stdlib/utils/filter-arguments"],"@stdlib/utils/map-function":["@stdlib/utils/async/map-function"],"@stdlib/utils/async/map-function":["@stdlib/utils/map-function"],"@stdlib/utils/map-keys":["@stdlib/utils/map-values"],"@stdlib/utils/async/map-keys":["@stdlib/utils/map-keys","@stdlib/utils/async/map-values"],"@stdlib/utils/map-reduce":["@stdlib/utils/map","@stdlib/utils/map-reduce-right","@stdlib/utils/reduce"],"@stdlib/utils/map-reduce-right":["@stdlib/utils/map-right","@stdlib/utils/map-reduce","@stdlib/utils/reduce-right"],"@stdlib/utils/map-right":["@stdlib/utils/map","@stdlib/utils/reduce"],"@stdlib/utils/map-values":["@stdlib/utils/map-keys","@stdlib/utils/omit-by","@stdlib/utils/pick-by"],"@stdlib/utils/async/map-values":["@stdlib/utils/async/map-keys","@stdlib/utils/map-values"],"@stdlib/utils/mask-arguments":["@stdlib/utils/filter-arguments","@stdlib/utils/reject-arguments","@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/constants/array/max-array-length":["@stdlib/constants/array/max-typed-array-length"],"@stdlib/constants/array/max-typed-array-length":["@stdlib/constants/array/max-array-length"],"@stdlib/ndarray/maybe-broadcast-array":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/broadcast-array","@stdlib/ndarray/maybe-broadcast-arrays"],"@stdlib/ndarray/maybe-broadcast-arrays":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/broadcast-arrays","@stdlib/ndarray/maybe-broadcast-array"],"@stdlib/utils/memoize":[],"@stdlib/utils/merge":["@stdlib/utils/copy"],"@stdlib/constants/time/milliseconds-in-day":[],"@stdlib/constants/time/milliseconds-in-hour":[],"@stdlib/constants/time/milliseconds-in-minute":[],"@stdlib/constants/time/milliseconds-in-second":[],"@stdlib/constants/time/milliseconds-in-week":[],"@stdlib/datasets/minard-napoleons-march":[],"@stdlib/constants/time/minutes-in-day":[],"@stdlib/constants/time/minutes-in-hour":[],"@stdlib/constants/time/minutes-in-week":[],"@stdlib/time/minutes-in-month":["@stdlib/time/minutes-in-year"],"@stdlib/time/minutes-in-year":["@stdlib/time/minutes-in-month"],"@stdlib/datasets/moby-dick":[],"@stdlib/datasets/month-names-en":[],"@stdlib/constants/time/months-in-year":[],"@stdlib/utils/move-property":[],"@stdlib/slice/multi":["@stdlib/ndarray/ctor","@stdlib/slice/ctor"],"@stdlib/dstructs/named-typed-tuple":["@stdlib/array/typed"],"@stdlib/constants/float64/nan":["@stdlib/constants/float32/nan"],"@stdlib/utils/nary-function":["@stdlib/utils/mask-arguments","@stdlib/utils/pick-arguments"],"@stdlib/utils/native-class":["@stdlib/utils/constructor-name","@stdlib/utils/type-of"],"@stdlib/ndarray/ctor":["@stdlib/ndarray/array","@stdlib/ndarray/fancy"],"@stdlib/ndarray/to-array":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/to-json"],"@stdlib/ndarray/to-fancy":["@stdlib/array/to-fancy","@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/fancy"],"@stdlib/ndarray/to-json":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/to-array"],"@stdlib/ndarray/casting-modes":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/data-buffer":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/dtype"],"@stdlib/ndarray/dtype":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/dtypes"],"@stdlib/ndarray/dtypes":["@stdlib/array/dtypes","@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/array/typed-dtypes"],"@stdlib/ndarray/dispatch":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/flag":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/flags"],"@stdlib/ndarray/flags":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/flag"],"@stdlib/ndarray/index-modes":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/ndarraylike2ndarray":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/empty-like","@stdlib/ndarray/zeros-like"],"@stdlib/ndarray/min-dtype":["@stdlib/ndarray/dtypes","@stdlib/ndarray/promotion-rules","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/mostly-safe-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts","@stdlib/ndarray/same-kind-casts"],"@stdlib/ndarray/next-dtype":["@stdlib/ndarray/dtypes","@stdlib/ndarray/promotion-rules","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/offset":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/shape","@stdlib/ndarray/strides"],"@stdlib/ndarray/order":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/orders","@stdlib/ndarray/shape","@stdlib/ndarray/strides"],"@stdlib/ndarray/orders":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/promotion-rules":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/safe-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/same-kind-casts"],"@stdlib/ndarray/same-kind-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/shape":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/offset","@stdlib/ndarray/strides"],"@stdlib/ndarray/stride":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/offset","@stdlib/ndarray/order","@stdlib/ndarray/shape","@stdlib/ndarray/strides"],"@stdlib/ndarray/strides":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/offset","@stdlib/ndarray/order","@stdlib/ndarray/shape"],"@stdlib/ndarray/at":["@stdlib/ndarray/array","@stdlib/ndarray/slice"],"@stdlib/ndarray/empty":["@stdlib/ndarray/empty-like","@stdlib/ndarray/zeros"],"@stdlib/ndarray/empty-like":["@stdlib/ndarray/empty","@stdlib/ndarray/zeros-like"],"@stdlib/ndarray/filter":["@stdlib/ndarray/filter-map","@stdlib/ndarray/map","@stdlib/ndarray/reject","@stdlib/ndarray/slice"],"@stdlib/ndarray/filter-map":["@stdlib/ndarray/filter","@stdlib/ndarray/map","@stdlib/ndarray/reject","@stdlib/ndarray/slice"],"@stdlib/ndarray/for-each":["@stdlib/ndarray/map"],"@stdlib/ndarray/ndims":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/numel","@stdlib/ndarray/shape"],"@stdlib/ndarray/index":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/fancy","@stdlib/ndarray/slice","@stdlib/ndarray/to-fancy"],"@stdlib/ndarray/iter/to-array-each":["@stdlib/ndarray/ctor","@stdlib/ndarray/to-array"],"@stdlib/ndarray/iter/column-entries":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/row-entries","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/columns":["@stdlib/ndarray/iter/column-entries","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/entries":["@stdlib/ndarray/ctor","@stdlib/ndarray/iter/indices","@stdlib/ndarray/iter/values"],"@stdlib/ndarray/iter/indices":["@stdlib/ndarray/ctor","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/values"],"@stdlib/ndarray/iter/interleave-subarrays":["@stdlib/ndarray/iter/subarrays","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/matrices":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrix-entries","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/matrix-entries":["@stdlib/ndarray/iter/column-entries","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/row-entries","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/row-entries":["@stdlib/ndarray/iter/column-entries","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/rows":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/row-entries","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/select-dimension":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/rows","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/stacks":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/rows","@stdlib/ndarray/iter/subarrays","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/subarrays":["@stdlib/ndarray/iter/columns","@stdlib/ndarray/iter/matrices","@stdlib/ndarray/iter/rows","@stdlib/ndarray/iter/stacks","@stdlib/ndarray/slice"],"@stdlib/ndarray/iter/values":["@stdlib/ndarray/ctor","@stdlib/ndarray/iter/entries","@stdlib/ndarray/iter/indices"],"@stdlib/ndarray/map":["@stdlib/ndarray/filter","@stdlib/ndarray/filter-map","@stdlib/ndarray/for-each","@stdlib/ndarray/slice"],"@stdlib/ndarray/reject":["@stdlib/ndarray/filter","@stdlib/ndarray/filter-map","@stdlib/ndarray/map","@stdlib/ndarray/slice"],"@stdlib/ndarray/slice":["@stdlib/ndarray/array","@stdlib/ndarray/at","@stdlib/ndarray/ctor","@stdlib/ndarray/slice-assign","@stdlib/ndarray/slice-dimension"],"@stdlib/ndarray/slice-assign":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice"],"@stdlib/ndarray/slice-dimension":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray/slice-dimension-to"],"@stdlib/ndarray/slice-dimension-from":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension","@stdlib/ndarray/slice-dimension-to","@stdlib/ndarray/slice-from"],"@stdlib/ndarray/slice-dimension-to":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension","@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray/slice-to"],"@stdlib/ndarray/slice-from":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray/slice-to"],"@stdlib/ndarray/slice-to":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/slice","@stdlib/ndarray/slice-dimension-to","@stdlib/ndarray/slice-from"],"@stdlib/ndarray/zeros":["@stdlib/ndarray/empty","@stdlib/ndarray/zeros-like"],"@stdlib/ndarray/zeros-like":["@stdlib/ndarray/empty-like","@stdlib/ndarray/zeros"],"@stdlib/string/next-grapheme-cluster-break":["@stdlib/string/num-grapheme-clusters","@stdlib/string/prev-grapheme-cluster-break"],"@stdlib/utils/next-tick":[],"@stdlib/datasets/nightingales-rose":[],"@stdlib/constants/float64/ninf":["@stdlib/constants/float16/ninf","@stdlib/constants/float32/ninf","@stdlib/constants/float64/pinf"],"@stdlib/process/node-version":[],"@stdlib/utils/none":["@stdlib/utils/any","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some"],"@stdlib/utils/none-by":["@stdlib/utils/any-by","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/none-by-right","@stdlib/utils/some-by"],"@stdlib/utils/async/none-by":["@stdlib/utils/async/any-by","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/none-by","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by"],"@stdlib/utils/none-by-right":["@stdlib/utils/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none","@stdlib/utils/none-by","@stdlib/utils/some-by-right"],"@stdlib/utils/async/none-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by","@stdlib/utils/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/none-in-by":["@stdlib/utils/any-in-by","@stdlib/utils/every-in-by","@stdlib/utils/for-in","@stdlib/utils/none-by","@stdlib/utils/some-in-by"],"@stdlib/utils/nonenumerable-properties":["@stdlib/utils/enumerable-properties","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/nonenumerable-properties-in":["@stdlib/utils/enumerable-properties-in","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/nonenumerable-properties","@stdlib/utils/properties-in"],"@stdlib/utils/nonenumerable-property-names":["@stdlib/utils/keys","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/nonenumerable-property-names-in":["@stdlib/utils/keys-in","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/property-names-in"],"@stdlib/utils/nonenumerable-property-symbols":["@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/nonenumerable-property-symbols-in":["@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/utils/none-own-by":["@stdlib/utils/any-own-by","@stdlib/utils/every-own-by","@stdlib/utils/for-own","@stdlib/utils/none-by","@stdlib/utils/some-own-by"],"@stdlib/utils/nonindex-keys":["@stdlib/utils/entries","@stdlib/utils/keys","@stdlib/utils/values"],"@stdlib/utils/noop":[],"@stdlib/time/now":[],"@stdlib/os/num-cpus":[],"@stdlib/string/num2words":[],"@stdlib/number/ctor":[],"@stdlib/ndarray/numel":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/numel-dimension"],"@stdlib/ndarray/numel-dimension":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/numel"],"@stdlib/string/num-grapheme-clusters":["@stdlib/string/next-grapheme-cluster-break"],"@stdlib/object/ctor":[],"@stdlib/utils/entries":["@stdlib/utils/entries-in","@stdlib/utils/from-entries","@stdlib/utils/keys","@stdlib/utils/values"],"@stdlib/utils/entries-in":["@stdlib/utils/entries","@stdlib/utils/from-entries","@stdlib/utils/keys-in","@stdlib/utils/values-in"],"@stdlib/utils/from-entries":["@stdlib/utils/entries"],"@stdlib/utils/object-inverse":["@stdlib/utils/object-inverse-by"],"@stdlib/utils/object-inverse-by":["@stdlib/utils/object-inverse"],"@stdlib/utils/keys":["@stdlib/utils/entries","@stdlib/utils/keys-in","@stdlib/utils/nonindex-keys","@stdlib/utils/values"],"@stdlib/utils/values":["@stdlib/utils/entries","@stdlib/utils/keys"],"@stdlib/utils/values-in":["@stdlib/utils/entries-in","@stdlib/utils/keys-in","@stdlib/utils/values"],"@stdlib/utils/omit":["@stdlib/utils/omit-by"],"@stdlib/utils/omit-by":["@stdlib/utils/omit"],"@stdlib/fs/open":["@stdlib/fs/close","@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/utils/open-url":[],"@stdlib/nlp/ordinalize":[],"@stdlib/datasets/pace-boston-house-prices":["@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices-corrected"],"@stdlib/string/pad":["@stdlib/string/left-pad","@stdlib/string/right-pad"],"@stdlib/stats/padjust":[],"@stdlib/utils/papply":["@stdlib/utils/papply-right"],"@stdlib/utils/papply-right":["@stdlib/utils/papply"],"@stdlib/utils/parallel":[],"@stdlib/utils/parse-json":[],"@stdlib/string/pascalcase":["@stdlib/string/camelcase","@stdlib/string/constantcase","@stdlib/string/kebabcase","@stdlib/string/snakecase"],"@stdlib/constants/path/delimiter":["@stdlib/constants/path/delimiter-posix","@stdlib/constants/path/delimiter-win32"],"@stdlib/constants/path/delimiter-posix":["@stdlib/constants/path/delimiter","@stdlib/constants/path/delimiter-win32"],"@stdlib/constants/path/delimiter-win32":["@stdlib/constants/path/delimiter","@stdlib/constants/path/delimiter-posix"],"@stdlib/constants/path/sep":["@stdlib/constants/path/sep-posix","@stdlib/constants/path/sep-win32"],"@stdlib/constants/path/sep-posix":["@stdlib/constants/path/sep","@stdlib/constants/path/sep-win32"],"@stdlib/constants/path/sep-win32":["@stdlib/constants/path/sep","@stdlib/constants/path/sep-posix"],"@stdlib/stats/pcorrtest":[],"@stdlib/string/percent-encode":[],"@stdlib/constants/float64/phi":[],"@stdlib/constants/float64/pi":["@stdlib/constants/float64/two-pi"],"@stdlib/constants/float64/pi-squared":["@stdlib/constants/float64/pi"],"@stdlib/utils/pick":["@stdlib/utils/pick-by"],"@stdlib/utils/pick-arguments":["@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/utils/pick-by":["@stdlib/utils/pick"],"@stdlib/constants/float64/pinf":["@stdlib/constants/float64/ninf"],"@stdlib/namespace/pkg2alias":["@stdlib/namespace/alias2pkg","@stdlib/namespace/aliases","@stdlib/namespace/pkg2related"],"@stdlib/namespace/pkg2related":["@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias"],"@stdlib/namespace/pkg2standalone":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2standalone","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias","@stdlib/namespace/pkg2related"],"@stdlib/os/platform":["@stdlib/os/arch"],"@stdlib/plot":["@stdlib/plot/ctor"],"@stdlib/plot/ctor":["@stdlib/plot"],"@stdlib/utils/pluck":["@stdlib/utils/deep-pluck","@stdlib/utils/pick"],"@stdlib/utils/pop":["@stdlib/utils/push","@stdlib/utils/shift","@stdlib/utils/unshift"],"@stdlib/nlp/porter-stemmer":[],"@stdlib/utils/prepend":["@stdlib/utils/append","@stdlib/utils/unshift"],"@stdlib/string/prev-grapheme-cluster-break":["@stdlib/string/num-grapheme-clusters","@stdlib/string/next-grapheme-cluster-break"],"@stdlib/datasets/primes-100k":["@stdlib/math/iter/sequences/primes"],"@stdlib/utils/properties":["@stdlib/utils/define-properties","@stdlib/utils/inherited-properties","@stdlib/utils/properties-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols"],"@stdlib/utils/properties-in":["@stdlib/utils/define-properties","@stdlib/utils/inherited-properties","@stdlib/utils/properties","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-descriptor":["@stdlib/assert/has-own-property","@stdlib/utils/define-property","@stdlib/utils/property-descriptor-in","@stdlib/utils/property-descriptors"],"@stdlib/utils/property-descriptor-in":["@stdlib/assert/has-property","@stdlib/utils/define-property","@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptors-in"],"@stdlib/utils/property-descriptors":["@stdlib/utils/define-property","@stdlib/utils/define-properties","@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptors-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols"],"@stdlib/utils/property-descriptors-in":["@stdlib/utils/define-properties","@stdlib/utils/property-descriptor-in","@stdlib/utils/property-descriptors","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-names":["@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols"],"@stdlib/utils/property-names-in":["@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-symbols":["@stdlib/utils/property-names","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-symbols-in":["@stdlib/utils/property-names-in","@stdlib/utils/property-symbols"],"@stdlib/proxy/ctor":[],"@stdlib/utils/push":["@stdlib/utils/pop","@stdlib/utils/shift","@stdlib/utils/unshift"],"@stdlib/time/quarter-of-year":["@stdlib/time/day-of-year"],"@stdlib/random/array/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/strided/arcsine"],"@stdlib/random/array/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/strided/bernoulli"],"@stdlib/random/array/beta":["@stdlib/random/base/beta","@stdlib/random/strided/beta"],"@stdlib/random/array/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/strided/betaprime"],"@stdlib/random/array/binomial":["@stdlib/random/array/negative-binomial","@stdlib/random/base/binomial"],"@stdlib/random/array/cauchy":["@stdlib/random/base/cauchy"],"@stdlib/random/array/chi":["@stdlib/random/base/chi","@stdlib/random/strided/chi"],"@stdlib/random/array/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/strided/chisquare"],"@stdlib/random/array/cosine":["@stdlib/random/base/cosine","@stdlib/random/strided/cosine"],"@stdlib/random/array/discrete-uniform":["@stdlib/random/array/uniform","@stdlib/random/base/discrete-uniform","@stdlib/random/strided/discrete-uniform"],"@stdlib/random/array/erlang":["@stdlib/random/base/erlang"],"@stdlib/random/array/exponential":["@stdlib/random/base/exponential","@stdlib/random/strided/exponential"],"@stdlib/random/array/f":["@stdlib/random/base/f"],"@stdlib/random/array/frechet":["@stdlib/random/base/frechet"],"@stdlib/random/array/gamma":["@stdlib/random/base/gamma","@stdlib/random/strided/gamma"],"@stdlib/random/array/geometric":["@stdlib/random/base/geometric","@stdlib/random/strided/geometric"],"@stdlib/random/array/gumbel":["@stdlib/random/base/gumbel"],"@stdlib/random/array/hypergeometric":["@stdlib/random/base/hypergeometric"],"@stdlib/random/array/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/strided/invgamma"],"@stdlib/random/array/kumaraswamy":["@stdlib/random/base/kumaraswamy"],"@stdlib/random/array/laplace":["@stdlib/random/base/laplace"],"@stdlib/random/array/levy":["@stdlib/random/base/levy"],"@stdlib/random/array/logistic":["@stdlib/random/base/logistic"],"@stdlib/random/array/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/strided/lognormal"],"@stdlib/random/array/minstd":["@stdlib/random/array/minstd-shuffle","@stdlib/random/array/randu","@stdlib/random/base/minstd","@stdlib/random/strided/minstd"],"@stdlib/random/array/minstd-shuffle":["@stdlib/random/array/minstd","@stdlib/random/array/randu","@stdlib/random/base/minstd-shuffle","@stdlib/random/strided/minstd-shuffle"],"@stdlib/random/array/mt19937":["@stdlib/random/array/randu","@stdlib/random/base/mt19937","@stdlib/random/strided/mt19937"],"@stdlib/random/array/negative-binomial":["@stdlib/random/array/binomial","@stdlib/random/base/negative-binomial"],"@stdlib/random/array/normal":["@stdlib/random/base/normal","@stdlib/random/strided/normal"],"@stdlib/random/array/pareto-type1":["@stdlib/random/base/pareto-type1"],"@stdlib/random/array/poisson":["@stdlib/random/base/poisson","@stdlib/random/strided/poisson"],"@stdlib/random/array/randu":["@stdlib/random/array/uniform","@stdlib/random/base/randu","@stdlib/random/strided/randu"],"@stdlib/random/array/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/strided/rayleigh"],"@stdlib/random/array/t":["@stdlib/random/base/t","@stdlib/random/strided/t"],"@stdlib/random/array/triangular":["@stdlib/random/base/triangular"],"@stdlib/random/array/uniform":["@stdlib/random/array/discrete-uniform","@stdlib/random/base/uniform","@stdlib/random/strided/uniform"],"@stdlib/random/array/weibull":["@stdlib/random/base/weibull","@stdlib/random/strided/weibull"],"@stdlib/random/iter/arcsine":["@stdlib/random/base/arcsine"],"@stdlib/random/iter/bernoulli":["@stdlib/random/base/bernoulli"],"@stdlib/random/iter/beta":["@stdlib/random/base/beta"],"@stdlib/random/iter/betaprime":["@stdlib/random/base/betaprime"],"@stdlib/random/iter/binomial":["@stdlib/random/base/binomial"],"@stdlib/random/iter/box-muller":["@stdlib/random/base/box-muller"],"@stdlib/random/iter/cauchy":["@stdlib/random/base/cauchy"],"@stdlib/random/iter/chi":["@stdlib/random/base/chi"],"@stdlib/random/iter/chisquare":["@stdlib/random/base/chisquare"],"@stdlib/random/iter/cosine":["@stdlib/random/base/cosine"],"@stdlib/random/iter/discrete-uniform":["@stdlib/random/base/discrete-uniform"],"@stdlib/random/iter/erlang":["@stdlib/random/base/erlang"],"@stdlib/random/iter/exponential":["@stdlib/random/base/exponential"],"@stdlib/random/iter/f":["@stdlib/random/base/f"],"@stdlib/random/iter/frechet":["@stdlib/random/base/frechet"],"@stdlib/random/iter/gamma":["@stdlib/random/base/gamma"],"@stdlib/random/iter/geometric":["@stdlib/random/base/geometric"],"@stdlib/random/iter/gumbel":["@stdlib/random/base/gumbel"],"@stdlib/random/iter/hypergeometric":["@stdlib/random/base/hypergeometric"],"@stdlib/random/iter/improved-ziggurat":["@stdlib/random/base/improved-ziggurat"],"@stdlib/random/iter/invgamma":["@stdlib/random/base/invgamma"],"@stdlib/random/iter/kumaraswamy":["@stdlib/random/base/kumaraswamy"],"@stdlib/random/iter/laplace":["@stdlib/random/base/laplace"],"@stdlib/random/iter/levy":["@stdlib/random/base/levy"],"@stdlib/random/iter/logistic":["@stdlib/random/base/logistic"],"@stdlib/random/iter/lognormal":["@stdlib/random/base/lognormal"],"@stdlib/random/iter/minstd":["@stdlib/random/base/minstd","@stdlib/random/iter/minstd-shuffle","@stdlib/random/iter/mt19937","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/iter/minstd","@stdlib/random/iter/mt19937","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/iter/minstd","@stdlib/random/iter/minstd-shuffle","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/negative-binomial":["@stdlib/random/base/negative-binomial"],"@stdlib/random/iter/normal":["@stdlib/random/base/normal"],"@stdlib/random/iter/pareto-type1":["@stdlib/random/base/pareto-type1"],"@stdlib/random/iter/poisson":["@stdlib/random/base/poisson"],"@stdlib/random/iter/randi":["@stdlib/random/base/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/randn":["@stdlib/random/base/randn"],"@stdlib/random/iter/randu":["@stdlib/random/base/randu","@stdlib/random/iter/randi"],"@stdlib/random/iter/rayleigh":["@stdlib/random/base/rayleigh"],"@stdlib/random/iter/t":["@stdlib/random/base/t"],"@stdlib/random/iter/triangular":["@stdlib/random/base/triangular"],"@stdlib/random/iter/uniform":["@stdlib/random/base/uniform"],"@stdlib/random/iter/weibull":["@stdlib/random/base/weibull"],"@stdlib/random/streams/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/iter/arcsine"],"@stdlib/random/streams/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/iter/bernoulli"],"@stdlib/random/streams/beta":["@stdlib/random/base/beta","@stdlib/random/iter/beta"],"@stdlib/random/streams/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/iter/betaprime"],"@stdlib/random/streams/binomial":["@stdlib/random/base/binomial","@stdlib/random/iter/binomial"],"@stdlib/random/streams/box-muller":["@stdlib/random/base/box-muller","@stdlib/random/iter/box-muller","@stdlib/random/streams/improved-ziggurat","@stdlib/random/streams/randn"],"@stdlib/random/streams/cauchy":["@stdlib/random/base/cauchy","@stdlib/random/iter/cauchy"],"@stdlib/random/streams/chi":["@stdlib/random/base/chi","@stdlib/random/iter/chi"],"@stdlib/random/streams/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/iter/chisquare"],"@stdlib/random/streams/cosine":["@stdlib/random/base/cosine","@stdlib/random/iter/cosine"],"@stdlib/random/streams/discrete-uniform":["@stdlib/random/base/discrete-uniform","@stdlib/random/iter/discrete-uniform"],"@stdlib/random/streams/erlang":["@stdlib/random/base/erlang","@stdlib/random/iter/erlang"],"@stdlib/random/streams/exponential":["@stdlib/random/base/exponential","@stdlib/random/iter/exponential"],"@stdlib/random/streams/f":["@stdlib/random/base/f","@stdlib/random/iter/f"],"@stdlib/random/streams/frechet":["@stdlib/random/base/frechet","@stdlib/random/iter/frechet"],"@stdlib/random/streams/gamma":["@stdlib/random/base/gamma","@stdlib/random/iter/gamma"],"@stdlib/random/streams/geometric":["@stdlib/random/base/geometric","@stdlib/random/iter/geometric"],"@stdlib/random/streams/gumbel":["@stdlib/random/base/gumbel","@stdlib/random/iter/gumbel"],"@stdlib/random/streams/hypergeometric":["@stdlib/random/base/hypergeometric","@stdlib/random/iter/hypergeometric"],"@stdlib/random/streams/improved-ziggurat":["@stdlib/random/base/improved-ziggurat","@stdlib/random/iter/improved-ziggurat","@stdlib/random/streams/box-muller","@stdlib/random/streams/randn"],"@stdlib/random/streams/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/iter/invgamma"],"@stdlib/random/streams/kumaraswamy":["@stdlib/random/base/kumaraswamy","@stdlib/random/iter/kumaraswamy"],"@stdlib/random/streams/laplace":["@stdlib/random/base/laplace","@stdlib/random/iter/laplace"],"@stdlib/random/streams/levy":["@stdlib/random/base/levy","@stdlib/random/iter/levy"],"@stdlib/random/streams/logistic":["@stdlib/random/base/logistic","@stdlib/random/iter/logistic"],"@stdlib/random/streams/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/iter/lognormal"],"@stdlib/random/streams/minstd":["@stdlib/random/base/minstd","@stdlib/random/iter/minstd","@stdlib/random/streams/minstd-shuffle","@stdlib/random/streams/mt19937","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/iter/minstd-shuffle","@stdlib/random/streams/minstd","@stdlib/random/streams/mt19937","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/iter/mt19937","@stdlib/random/streams/minstd","@stdlib/random/streams/minstd-shuffle","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/negative-binomial":["@stdlib/random/base/negative-binomial","@stdlib/random/iter/negative-binomial"],"@stdlib/random/streams/normal":["@stdlib/random/base/normal","@stdlib/random/iter/normal"],"@stdlib/random/streams/pareto-type1":["@stdlib/random/base/pareto-type1","@stdlib/random/iter/pareto-type1"],"@stdlib/random/streams/poisson":["@stdlib/random/base/poisson","@stdlib/random/iter/poisson"],"@stdlib/random/streams/randi":["@stdlib/random/base/randi","@stdlib/random/iter/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/randn":["@stdlib/random/base/randn","@stdlib/random/iter/randn","@stdlib/random/streams/box-muller","@stdlib/random/streams/improved-ziggurat"],"@stdlib/random/streams/randu":["@stdlib/random/base/randu","@stdlib/random/iter/randu","@stdlib/random/streams/randi"],"@stdlib/random/streams/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/iter/rayleigh"],"@stdlib/random/streams/t":["@stdlib/random/base/t","@stdlib/random/iter/t"],"@stdlib/random/streams/triangular":["@stdlib/random/base/triangular","@stdlib/random/iter/triangular"],"@stdlib/random/streams/uniform":["@stdlib/random/base/uniform","@stdlib/random/iter/uniform"],"@stdlib/random/streams/weibull":["@stdlib/random/base/weibull","@stdlib/random/iter/weibull"],"@stdlib/random/strided/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/array/arcsine"],"@stdlib/random/strided/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/array/bernoulli"],"@stdlib/random/strided/beta":["@stdlib/random/base/beta","@stdlib/random/array/beta"],"@stdlib/random/strided/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/array/betaprime"],"@stdlib/random/strided/chi":["@stdlib/random/base/chi","@stdlib/random/array/chi"],"@stdlib/random/strided/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/array/chisquare"],"@stdlib/random/strided/cosine":["@stdlib/random/base/cosine","@stdlib/random/array/cosine"],"@stdlib/random/strided/discrete-uniform":["@stdlib/random/base/discrete-uniform","@stdlib/random/array/discrete-uniform","@stdlib/random/strided/uniform"],"@stdlib/random/strided/exponential":["@stdlib/random/base/exponential","@stdlib/random/array/exponential"],"@stdlib/random/strided/gamma":["@stdlib/random/base/gamma","@stdlib/random/array/gamma"],"@stdlib/random/strided/geometric":["@stdlib/random/base/geometric","@stdlib/random/array/geometric"],"@stdlib/random/strided/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/array/invgamma"],"@stdlib/random/strided/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/array/lognormal"],"@stdlib/random/strided/minstd":["@stdlib/random/base/minstd","@stdlib/random/array/minstd","@stdlib/random/strided/minstd-shuffle","@stdlib/random/strided/randu"],"@stdlib/random/strided/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/array/minstd-shuffle","@stdlib/random/strided/minstd","@stdlib/random/strided/randu"],"@stdlib/random/strided/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/array/mt19937","@stdlib/random/strided/randu"],"@stdlib/random/strided/normal":["@stdlib/random/base/normal","@stdlib/random/array/normal"],"@stdlib/random/strided/poisson":["@stdlib/random/base/poisson","@stdlib/random/array/poisson"],"@stdlib/random/strided/randu":["@stdlib/random/base/randu","@stdlib/random/array/randu","@stdlib/random/strided/uniform"],"@stdlib/random/strided/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/array/rayleigh"],"@stdlib/random/strided/t":["@stdlib/random/base/t","@stdlib/random/array/t"],"@stdlib/random/strided/uniform":["@stdlib/random/base/uniform","@stdlib/random/array/uniform","@stdlib/random/strided/discrete-uniform"],"@stdlib/random/strided/weibull":["@stdlib/random/base/weibull","@stdlib/random/array/weibull"],"@stdlib/stats/ranks":[],"@stdlib/fs/read-dir":["@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/fs/read-file":["@stdlib/fs/exists","@stdlib/fs/open","@stdlib/fs/read-dir","@stdlib/fs/read-json","@stdlib/fs/write-file"],"@stdlib/fs/read-file-list":[],"@stdlib/fs/read-json":["@stdlib/fs/read-file"],"@stdlib/fs/read-wasm":["@stdlib/fs/read-file"],"@stdlib/complex/float64/real":["@stdlib/complex/float64/imag","@stdlib/complex/float64/reim"],"@stdlib/array/typed-real":["@stdlib/array/float64","@stdlib/array/float32","@stdlib/array/int32","@stdlib/array/uint32","@stdlib/array/int16","@stdlib/array/uint16","@stdlib/array/int8","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/typed-real-ctors":["@stdlib/array/ctors","@stdlib/array/typed-complex-ctors"],"@stdlib/array/typed-real-dtypes":["@stdlib/array/dtypes","@stdlib/array/typed-complex-dtypes"],"@stdlib/complex/float32/real":["@stdlib/complex/float32/imag","@stdlib/complex/float64/real","@stdlib/complex/float32/reim"],"@stdlib/utils/real-max":["@stdlib/utils/real-min","@stdlib/utils/type-max"],"@stdlib/utils/real-min":["@stdlib/utils/real-max","@stdlib/utils/type-min"],"@stdlib/regexp/basename":["@stdlib/regexp/basename-posix","@stdlib/regexp/basename-windows"],"@stdlib/regexp/basename-posix":["@stdlib/regexp/basename","@stdlib/regexp/basename-windows"],"@stdlib/regexp/basename-windows":["@stdlib/regexp/basename","@stdlib/regexp/basename-posix"],"@stdlib/regexp/color-hexadecimal":[],"@stdlib/regexp/decimal-number":[],"@stdlib/regexp/dirname":["@stdlib/regexp/dirname-posix","@stdlib/regexp/dirname-windows","@stdlib/utils/dirname"],"@stdlib/regexp/dirname-posix":["@stdlib/regexp/dirname","@stdlib/regexp/dirname-windows","@stdlib/utils/dirname"],"@stdlib/regexp/dirname-windows":["@stdlib/regexp/dirname","@stdlib/regexp/dirname-posix","@stdlib/utils/dirname"],"@stdlib/utils/reduce":["@stdlib/utils/for-each","@stdlib/utils/map","@stdlib/utils/async/reduce","@stdlib/utils/reduce-right"],"@stdlib/utils/reduce2d":["@stdlib/utils/map2d","@stdlib/utils/reduce"],"@stdlib/utils/async/reduce":["@stdlib/utils/async/for-each","@stdlib/utils/reduce","@stdlib/utils/async/reduce-right"],"@stdlib/utils/reduce-right":["@stdlib/utils/for-each-right","@stdlib/utils/map-right","@stdlib/utils/reduce","@stdlib/utils/async/reduce-right"],"@stdlib/utils/async/reduce-right":["@stdlib/utils/async/for-each-right","@stdlib/utils/async/reduce","@stdlib/utils/reduce-right"],"@stdlib/regexp/duration-string":[],"@stdlib/regexp/eol":[],"@stdlib/regexp/extended-length-path":[],"@stdlib/regexp/extname":["@stdlib/regexp/extname-posix","@stdlib/regexp/extname-windows","@stdlib/utils/extname"],"@stdlib/regexp/extname-posix":["@stdlib/regexp/extname","@stdlib/regexp/extname-windows","@stdlib/utils/extname"],"@stdlib/regexp/extname-windows":["@stdlib/regexp/extname","@stdlib/regexp/extname-posix","@stdlib/utils/extname"],"@stdlib/regexp/filename":["@stdlib/regexp/filename-posix","@stdlib/regexp/filename-windows"],"@stdlib/regexp/filename-posix":["@stdlib/regexp/filename","@stdlib/regexp/filename-windows"],"@stdlib/regexp/filename-windows":["@stdlib/regexp/filename","@stdlib/regexp/filename-posix"],"@stdlib/utils/regexp-from-string":[],"@stdlib/regexp/function-name":["@stdlib/utils/function-name"],"@stdlib/regexp/to-json":["@stdlib/regexp/reviver"],"@stdlib/complex/float64/reim":["@stdlib/complex/float64/imag","@stdlib/complex/float64/real"],"@stdlib/complex/float32/reim":["@stdlib/complex/float32/imag","@stdlib/complex/float32/real","@stdlib/complex/float64/reim"],"@stdlib/utils/reject-arguments":["@stdlib/utils/filter-arguments","@stdlib/utils/mask-arguments"],"@stdlib/string/remove-first":["@stdlib/string/remove-last"],"@stdlib/string/remove-last":["@stdlib/string/remove-first"],"@stdlib/string/remove-punctuation":[],"@stdlib/string/remove-utf8-bom":[],"@stdlib/string/remove-words":[],"@stdlib/fs/rename":["@stdlib/fs/exists","@stdlib/fs/read-file","@stdlib/fs/write-file","@stdlib/fs/unlink"],"@stdlib/regexp/native-function":["@stdlib/regexp/function-name","@stdlib/utils/function-name"],"@stdlib/utils/reorder-arguments":["@stdlib/utils/mask-arguments","@stdlib/utils/reverse-arguments"],"@stdlib/string/repeat":["@stdlib/string/pad"],"@stdlib/string/replace":[],"@stdlib/string/replace-before":[],"@stdlib/regexp/regexp":["@stdlib/utils/regexp-from-string"],"@stdlib/utils/escape-regexp-string":[],"@stdlib/regexp/semver":["@stdlib/assert/is-semver"],"@stdlib/fs/resolve-parent-path":["@stdlib/fs/resolve-parent-path-by"],"@stdlib/fs/resolve-parent-path-by":["@stdlib/fs/resolve-parent-path"],"@stdlib/regexp/unc-path":["@stdlib/assert/is-unc-path"],"@stdlib/regexp/utf16-surrogate-pair":["@stdlib/regexp/utf16-unpaired-surrogate"],"@stdlib/regexp/utf16-unpaired-surrogate":["@stdlib/regexp/utf16-surrogate-pair"],"@stdlib/utils/reverse-arguments":["@stdlib/utils/mask-arguments","@stdlib/utils/reorder-arguments"],"@stdlib/string/reverse":[],"@stdlib/random/base/reviver":[],"@stdlib/buffer/reviver":["@stdlib/buffer/to-json"],"@stdlib/complex/reviver":["@stdlib/complex/float64/ctor","@stdlib/complex/float32/ctor","@stdlib/complex/float64/reviver","@stdlib/complex/float32/reviver"],"@stdlib/complex/float32/reviver":["@stdlib/complex/float32/ctor","@stdlib/complex/float64/reviver","@stdlib/complex/reviver"],"@stdlib/complex/float64/reviver":["@stdlib/complex/float64/ctor","@stdlib/complex/float32/reviver","@stdlib/complex/reviver"],"@stdlib/error/reviver":["@stdlib/error/to-json"],"@stdlib/regexp/reviver":["@stdlib/regexp/to-json"],"@stdlib/array/reviver":["@stdlib/array/to-json"],"@stdlib/regexp/whitespace":["@stdlib/assert/is-whitespace"],"@stdlib/string/right-pad":["@stdlib/string/left-pad","@stdlib/string/pad"],"@stdlib/string/right-trim":["@stdlib/string/left-trim","@stdlib/string/trim"],"@stdlib/string/right-trim-n":["@stdlib/string/left-trim-n","@stdlib/string/trim"],"@stdlib/utils/safe-int-max":["@stdlib/utils/safe-int-min","@stdlib/utils/real-max","@stdlib/utils/type-max"],"@stdlib/utils/safe-int-min":["@stdlib/utils/safe-int-max","@stdlib/utils/real-min","@stdlib/utils/type-min"],"@stdlib/random/sample":[],"@stdlib/datasets/savoy-stopwords-fin":[],"@stdlib/datasets/savoy-stopwords-fr":[],"@stdlib/datasets/savoy-stopwords-ger":[],"@stdlib/datasets/savoy-stopwords-it":[],"@stdlib/datasets/savoy-stopwords-por":[],"@stdlib/datasets/savoy-stopwords-sp":[],"@stdlib/datasets/savoy-stopwords-swe":[],"@stdlib/array/from-scalar":["@stdlib/array/from-iterator"],"@stdlib/ndarray/from-scalar":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/blas/sdot":["@stdlib/blas/base/sdot","@stdlib/blas/ddot","@stdlib/blas/gdot"],"@stdlib/constants/time/seconds-in-day":[],"@stdlib/constants/time/seconds-in-hour":[],"@stdlib/constants/time/seconds-in-minute":[],"@stdlib/constants/time/seconds-in-week":[],"@stdlib/time/seconds-in-month":["@stdlib/time/seconds-in-year"],"@stdlib/time/seconds-in-year":["@stdlib/time/seconds-in-month"],"@stdlib/nlp/sentencize":["@stdlib/nlp/tokenize"],"@stdlib/slice/seq2slice":["@stdlib/slice/ctor"],"@stdlib/utils/define-configurable-read-only-property":["@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-configurable-read-only-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-only-accessor"],"@stdlib/utils/define-configurable-read-write-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-write-accessor"],"@stdlib/utils/define-configurable-write-only-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-property","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-memoized-configurable-read-only-property":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-memoized-read-only-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-memoized-read-only-property":["@stdlib/utils/define-memoized-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-property":["@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-read-only-property":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-read-only-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-accessor"],"@stdlib/utils/define-nonenumerable-read-write-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-write-accessor"],"@stdlib/utils/define-nonenumerable-write-only-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-only-property":["@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-only-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-write-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-write-only-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-write-accessor"],"@stdlib/array/shared-buffer":["@stdlib/buffer/ctor","@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/utils/shift":["@stdlib/utils/pop","@stdlib/utils/push","@stdlib/utils/unshift"],"@stdlib/random/shuffle":["@stdlib/random/sample"],"@stdlib/utils/size-of":["@stdlib/utils/real-max","@stdlib/utils/type-max"],"@stdlib/slice/ctor":["@stdlib/ndarray/ctor","@stdlib/slice/multi"],"@stdlib/string/snakecase":["@stdlib/string/camelcase","@stdlib/string/constantcase","@stdlib/string/kebabcase","@stdlib/string/pascalcase"],"@stdlib/utils/some":["@stdlib/utils/any","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some-by"],"@stdlib/utils/some-by":["@stdlib/utils/any-by","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/async/some-by","@stdlib/utils/some-by-right"],"@stdlib/utils/async/some-by":["@stdlib/utils/async/any-by","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/some-by","@stdlib/utils/async/some-by-right"],"@stdlib/utils/some-by-right":["@stdlib/utils/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by","@stdlib/utils/async/some-by-right"],"@stdlib/utils/async/some-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by","@stdlib/utils/some-by-right"],"@stdlib/utils/some-in-by":["@stdlib/utils/any-in-by","@stdlib/utils/every-in-by","@stdlib/utils/some-by","@stdlib/utils/some-own-by"],"@stdlib/utils/some-own-by":["@stdlib/utils/any-own-by","@stdlib/utils/every-own-by","@stdlib/utils/some-by","@stdlib/utils/some-in-by"],"@stdlib/datasets/sotu":[],"@stdlib/datasets/spache-revised":[],"@stdlib/datasets/spam-assassin":[],"@stdlib/plot/sparklines/base/ctor":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/array/to-sparse-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator","@stdlib/array/to-sparse-iterator-right"],"@stdlib/array/to-sparse-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-sparse-iterator"],"@stdlib/streams/node/split":["@stdlib/streams/node/join"],"@stdlib/constants/float64/sqrt-eps":["@stdlib/constants/float64/eps"],"@stdlib/constants/float64/sqrt-half":["@stdlib/constants/float64/ln-half"],"@stdlib/constants/float64/sqrt-half-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/sqrt-phi":["@stdlib/constants/float64/phi"],"@stdlib/constants/float64/sqrt-pi":["@stdlib/constants/float64/pi"],"@stdlib/constants/float64/sqrt-three":[],"@stdlib/constants/float64/sqrt-two":["@stdlib/constants/float64/ln-two"],"@stdlib/constants/float64/sqrt-two-pi":["@stdlib/constants/float64/two-pi"],"@stdlib/datasets/ssa-us-births-2000-2014":["@stdlib/datasets/cdc-nchs-us-births-1969-1988","@stdlib/datasets/cdc-nchs-us-births-1994-2003"],"@stdlib/blas/sswap":["@stdlib/blas/base/sswap","@stdlib/blas/dswap","@stdlib/blas/gswap"],"@stdlib/dstructs/stack":["@stdlib/dstructs/fifo"],"@stdlib/namespace/standalone2pkg":["@stdlib/namespace/alias2standalone","@stdlib/namespace/pkg2alias","@stdlib/namespace/pkg2standalone"],"@stdlib/datasets/standard-card-deck":[],"@stdlib/string/startcase":["@stdlib/string/lowercase","@stdlib/string/uppercase"],"@stdlib/string/starts-with":["@stdlib/string/ends-with"],"@stdlib/datasets/stopwords-en":[],"@stdlib/math/strided/special/abs":["@stdlib/math/strided/special/abs2","@stdlib/math/strided/special/dabs","@stdlib/math/strided/special/sabs"],"@stdlib/math/strided/special/abs2":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/dabs2","@stdlib/math/strided/special/sabs2"],"@stdlib/math/strided/special/abs2-by":["@stdlib/math/strided/special/abs-by","@stdlib/math/strided/special/abs2"],"@stdlib/math/strided/special/abs-by":["@stdlib/math/strided/special/abs","@stdlib/math/strided/special/abs2-by"],"@stdlib/math/strided/special/acos-by":[],"@stdlib/math/strided/special/acosh-by":[],"@stdlib/math/strided/special/acot-by":[],"@stdlib/math/strided/special/acoth-by":[],"@stdlib/math/strided/special/acovercos-by":[],"@stdlib/math/strided/special/acoversin-by":[],"@stdlib/math/strided/ops/add":["@stdlib/math/strided/ops/mul","@stdlib/math/strided/ops/sub"],"@stdlib/math/strided/ops/add-by":["@stdlib/math/strided/ops/add","@stdlib/math/strided/ops/mul-by","@stdlib/math/strided/ops/sub-by"],"@stdlib/math/strided/special/ahavercos-by":["@stdlib/math/strided/special/ahaversin-by"],"@stdlib/math/strided/special/ahaversin-by":["@stdlib/math/strided/special/ahavercos-by"],"@stdlib/math/strided/special/asin-by":["@stdlib/math/strided/special/asinh-by"],"@stdlib/math/strided/special/asinh-by":["@stdlib/math/strided/special/asin-by"],"@stdlib/math/strided/special/atan-by":["@stdlib/math/strided/special/atanh-by"],"@stdlib/math/strided/special/atanh-by":["@stdlib/math/strided/special/atan-by"],"@stdlib/math/strided/special/avercos-by":[],"@stdlib/math/strided/special/aversin-by":[],"@stdlib/math/strided/special/besselj0-by":["@stdlib/math/strided/special/besselj1-by","@stdlib/math/strided/special/bessely0-by","@stdlib/math/strided/special/bessely1-by"],"@stdlib/math/strided/special/besselj1-by":["@stdlib/math/strided/special/besselj0-by","@stdlib/math/strided/special/bessely0-by","@stdlib/math/strided/special/bessely1-by"],"@stdlib/math/strided/special/bessely0-by":["@stdlib/math/strided/special/besselj0-by","@stdlib/math/strided/special/besselj1-by","@stdlib/math/strided/special/bessely1-by"],"@stdlib/math/strided/special/bessely1-by":["@stdlib/math/strided/special/besselj0-by","@stdlib/math/strided/special/besselj1-by","@stdlib/math/strided/special/bessely0-by"],"@stdlib/math/strided/special/binet-by":[],"@stdlib/math/strided/special/cbrt":["@stdlib/math/strided/special/dcbrt","@stdlib/math/strided/special/scbrt","@stdlib/math/strided/special/sqrt"],"@stdlib/math/strided/special/cbrt-by":["@stdlib/math/strided/special/cbrt"],"@stdlib/math/strided/special/ceil":["@stdlib/math/strided/special/dceil","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/trunc","@stdlib/math/strided/special/sceil"],"@stdlib/math/strided/special/cos-by":[],"@stdlib/math/strided/special/deg2rad":["@stdlib/math/strided/special/ddeg2rad","@stdlib/math/strided/special/sdeg2rad"],"@stdlib/strided/dtypes":[],"@stdlib/math/strided/special/dcbrt-by":["@stdlib/math/strided/special/cbrt"],"@stdlib/strided/dispatch":[],"@stdlib/strided/dispatch-by":["@stdlib/strided/dispatch"],"@stdlib/math/strided/special/floor":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dfloor","@stdlib/math/strided/special/trunc","@stdlib/math/strided/special/sfloor"],"@stdlib/math/strided/special/inv":["@stdlib/math/strided/special/dinv","@stdlib/math/strided/special/sinv"],"@stdlib/math/strided/ops/mul":["@stdlib/math/strided/ops/add","@stdlib/math/strided/ops/sub"],"@stdlib/math/strided/ops/mul-by":["@stdlib/math/strided/ops/mul","@stdlib/math/strided/ops/add-by","@stdlib/math/strided/ops/sub-by"],"@stdlib/math/strided/special/ramp":["@stdlib/math/strided/special/dramp","@stdlib/math/strided/special/sramp"],"@stdlib/math/strided/special/rsqrt":["@stdlib/math/strided/special/drsqrt","@stdlib/math/strided/special/sqrt","@stdlib/math/strided/special/srsqrt"],"@stdlib/math/strided/special/sin-by":[],"@stdlib/math/strided/special/sqrt":["@stdlib/math/strided/special/cbrt","@stdlib/math/strided/special/dsqrt","@stdlib/math/strided/special/rsqrt","@stdlib/math/strided/special/ssqrt"],"@stdlib/math/strided/special/sqrt-by":["@stdlib/math/strided/special/sqrt"],"@stdlib/math/strided/ops/sub":["@stdlib/math/strided/ops/add","@stdlib/math/strided/ops/mul"],"@stdlib/math/strided/ops/sub-by":["@stdlib/math/strided/ops/sub","@stdlib/math/strided/ops/add-by","@stdlib/math/strided/ops/mul-by"],"@stdlib/math/strided/special/trunc":["@stdlib/math/strided/special/ceil","@stdlib/math/strided/special/dtrunc","@stdlib/math/strided/special/floor","@stdlib/math/strided/special/strunc"],"@stdlib/array/to-strided-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator"],"@stdlib/streams/node/from-strided-array":["@stdlib/streams/node/from-array"],"@stdlib/buffer/from-string":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer"],"@stdlib/ndarray/sub2ind":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/ind2sub"],"@stdlib/string/substring-after":["@stdlib/string/substring-before","@stdlib/string/substring-before-last","@stdlib/string/substring-after-last"],"@stdlib/string/substring-after-last":["@stdlib/string/substring-before","@stdlib/string/substring-before-last","@stdlib/string/substring-after"],"@stdlib/string/substring-before":["@stdlib/string/substring-before-last","@stdlib/string/substring-after","@stdlib/string/substring-after-last"],"@stdlib/string/substring-before-last":["@stdlib/string/substring-before","@stdlib/string/substring-after","@stdlib/string/substring-after-last"],"@stdlib/datasets/suthaharan-multi-hop-sensor-network":["@stdlib/datasets/suthaharan-single-hop-sensor-network"],"@stdlib/datasets/suthaharan-single-hop-sensor-network":["@stdlib/datasets/suthaharan-multi-hop-sensor-network"],"@stdlib/symbol/ctor":[],"@stdlib/utils/tabulate":["@stdlib/utils/count-by","@stdlib/utils/group-by","@stdlib/utils/tabulate-by"],"@stdlib/utils/tabulate-by":["@stdlib/utils/count-by","@stdlib/utils/group-by","@stdlib/utils/tabulate"],"@stdlib/utils/async/tabulate-by":["@stdlib/utils/async/count-by","@stdlib/utils/async/group-by","@stdlib/utils/tabulate-by"],"@stdlib/function/thunk":[],"@stdlib/time/tic":["@stdlib/time/toc"],"@stdlib/utils/timeit":[],"@stdlib/os/tmpdir":["@stdlib/os/configdir","@stdlib/os/homedir"],"@stdlib/time/toc":["@stdlib/time/tic"],"@stdlib/nlp/tokenize":[],"@stdlib/streams/node/transform":[],"@stdlib/string/trim":["@stdlib/string/left-trim","@stdlib/string/pad","@stdlib/string/right-trim"],"@stdlib/string/truncate":["@stdlib/string/truncate-middle"],"@stdlib/string/truncate-middle":["@stdlib/string/truncate"],"@stdlib/utils/try-catch":["@stdlib/utils/async/try-catch","@stdlib/utils/try-then"],"@stdlib/utils/async/try-catch":["@stdlib/utils/try-catch","@stdlib/utils/async/try-then"],"@stdlib/utils/try-function":[],"@stdlib/utils/try-require":[],"@stdlib/utils/try-then":["@stdlib/utils/try-catch","@stdlib/utils/async/try-then"],"@stdlib/utils/async/try-then":["@stdlib/utils/async/try-catch","@stdlib/utils/try-then"],"@stdlib/stats/ttest":["@stdlib/stats/ttest2"],"@stdlib/stats/ttest2":["@stdlib/stats/ttest"],"@stdlib/constants/float64/two-pi":["@stdlib/constants/float64/pi"],"@stdlib/array/typed":["@stdlib/array/complex128","@stdlib/array/complex64","@stdlib/array/float64","@stdlib/array/float32","@stdlib/array/int32","@stdlib/array/uint32","@stdlib/array/int16","@stdlib/array/uint16","@stdlib/array/int8","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/to-json":["@stdlib/array/reviver"],"@stdlib/array/typed-ctors":["@stdlib/array/ctors"],"@stdlib/array/typed-dtypes":["@stdlib/array/dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/pool":["@stdlib/array/typed"],"@stdlib/utils/type-max":["@stdlib/utils/real-max","@stdlib/utils/type-min"],"@stdlib/utils/type-min":["@stdlib/utils/real-min","@stdlib/utils/type-max"],"@stdlib/utils/type-of":["@stdlib/utils/constructor-name","@stdlib/utils/native-class"],"@stdlib/constants/uint8/max":["@stdlib/constants/int8/max"],"@stdlib/constants/uint8/num-bytes":["@stdlib/constants/int8/num-bytes","@stdlib/constants/uint16/num-bytes","@stdlib/constants/uint32/num-bytes"],"@stdlib/array/uint8":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8c"],"@stdlib/array/uint8c":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8"],"@stdlib/constants/uint16/max":["@stdlib/constants/int16/max"],"@stdlib/constants/uint16/num-bytes":["@stdlib/constants/int16/num-bytes","@stdlib/constants/uint32/num-bytes","@stdlib/constants/uint8/num-bytes"],"@stdlib/array/uint16":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/uint32/max":["@stdlib/constants/int32/max"],"@stdlib/constants/uint32/num-bytes":["@stdlib/constants/int32/num-bytes","@stdlib/constants/uint16/num-bytes","@stdlib/constants/uint8/num-bytes"],"@stdlib/array/uint32":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/process/umask":[],"@stdlib/string/uncapitalize":["@stdlib/string/capitalize","@stdlib/string/lowercase"],"@stdlib/utils/uncapitalize-keys":["@stdlib/utils/capitalize-keys","@stdlib/utils/lowercase-keys"],"@stdlib/utils/uncurry":["@stdlib/utils/curry","@stdlib/utils/uncurry-right"],"@stdlib/utils/uncurry-right":["@stdlib/utils/curry","@stdlib/utils/curry-right","@stdlib/utils/uncurry"],"@stdlib/constants/unicode/max":["@stdlib/constants/unicode/max-bmp"],"@stdlib/constants/unicode/max-bmp":["@stdlib/constants/unicode/max"],"@stdlib/plot/sparklines/unicode/column":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/line":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/tristate":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/up-down":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/win-loss":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down"],"@stdlib/fs/unlink":["@stdlib/fs/exists"],"@stdlib/utils/unshift":["@stdlib/utils/pop","@stdlib/utils/push","@stdlib/utils/shift"],"@stdlib/utils/until":["@stdlib/utils/do-until","@stdlib/utils/do-while","@stdlib/utils/async/until","@stdlib/utils/until-each","@stdlib/utils/while"],"@stdlib/utils/async/until":["@stdlib/utils/async/do-until","@stdlib/utils/async/do-while","@stdlib/utils/until","@stdlib/utils/async/while"],"@stdlib/utils/until-each":["@stdlib/utils/until-each-right","@stdlib/utils/while-each"],"@stdlib/utils/until-each-right":["@stdlib/utils/until-each","@stdlib/utils/while-each-right"],"@stdlib/utils/unzip":["@stdlib/utils/zip"],"@stdlib/string/uppercase":["@stdlib/string/capitalize","@stdlib/string/lowercase"],"@stdlib/utils/uppercase-keys":["@stdlib/utils/capitalize-keys","@stdlib/utils/lowercase-keys"],"@stdlib/datasets/us-states-abbr":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names"],"@stdlib/datasets/us-states-capitals":["@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-capitals-names":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-names":["@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-names-capitals":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/string/utf16-to-utf8-array":[],"@stdlib/stats/vartest":["@stdlib/stats/bartlett-test"],"@stdlib/utils/async/series-waterfall":[],"@stdlib/wasm/memory":[],"@stdlib/utils/async/while":["@stdlib/utils/async/do-until","@stdlib/utils/async/do-while","@stdlib/utils/async/until","@stdlib/utils/while"],"@stdlib/utils/while-each":["@stdlib/utils/until-each","@stdlib/utils/while-each-right"],"@stdlib/utils/while-each-right":["@stdlib/utils/while-each","@stdlib/utils/until-each-right"],"@stdlib/utils/while":["@stdlib/utils/do-until","@stdlib/utils/do-while","@stdlib/utils/until","@stdlib/utils/async/while","@stdlib/utils/while-each"],"@stdlib/stats/wilcoxon":["@stdlib/stats/ttest","@stdlib/stats/ztest"],"@stdlib/utils/writable-properties":["@stdlib/utils/inherited-writable-properties","@stdlib/utils/writable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/writable-properties-in":["@stdlib/utils/inherited-writable-properties","@stdlib/utils/writable-properties","@stdlib/utils/properties-in"],"@stdlib/utils/writable-property-names":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-properties","@stdlib/utils/writable-property-names-in","@stdlib/utils/writable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/writable-property-names-in":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-properties-in","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/property-names-in"],"@stdlib/utils/writable-property-symbols":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/writable-property-symbols-in":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties-in","@stdlib/utils/writable-property-names-in","@stdlib/utils/writable-property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/fs/write-file":["@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/utils/zip":["@stdlib/utils/unzip"],"@stdlib/stats/ztest":["@stdlib/stats/ztest2"],"@stdlib/stats/ztest2":["@stdlib/stats/ztest"]} diff --git a/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.csv b/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.csv index ebd473b88f77..df68e9a96930 100644 --- a/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.csv +++ b/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.csv @@ -1480,7 +1480,7 @@ "@stdlib/math/base/special/truncn","@stdlib/math-base-special-truncn" "@stdlib/math/base/special/truncsd","@stdlib/math-base-special-truncsd" "@stdlib/number/uint32/base/to-int32","@stdlib/number-uint32-base-to-int32" -"@stdlib/math/base/ops/umul","@stdlib/math-base-ops-umul" +"@stdlib/number/uint32/base/mul","@stdlib/math-base-ops-umul" "@stdlib/math/base/ops/umuldw","@stdlib/math-base-ops-umuldw" "@stdlib/string/base/uncapitalize","@stdlib/string-base-uncapitalize" "@stdlib/string/base/uppercase","@stdlib/string-base-uppercase" diff --git a/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.json b/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.json index d38e6da66a5f..5a1c940a23e2 100644 --- a/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.json +++ b/lib/node_modules/@stdlib/namespace/pkg2standalone/data/data.json @@ -1 +1 @@ -{"@stdlib/math/special/abs":"@stdlib/math-special-abs","@stdlib/array/cartesian-power":"@stdlib/array-cartesian-power","@stdlib/array/cartesian-product":"@stdlib/array-cartesian-product","@stdlib/array/cartesian-square":"@stdlib/array-cartesian-square","@stdlib/string/acronym":"@stdlib/string-acronym","@stdlib/array/empty":"@stdlib/array-empty","@stdlib/array/empty-like":"@stdlib/array-empty-like","@stdlib/datasets/afinn-96":"@stdlib/datasets-afinn-96","@stdlib/datasets/afinn-111":"@stdlib/datasets-afinn-111","@stdlib/array/full":"@stdlib/array-full","@stdlib/array/full-like":"@stdlib/array-full-like","@stdlib/namespace/alias2pkg":"@stdlib/namespace-alias2pkg","@stdlib/namespace/alias2related":"@stdlib/namespace-alias2related","@stdlib/namespace/alias2standalone":"@stdlib/namespace-alias2standalone","@stdlib/namespace/aliases":"@stdlib/namespace-aliases","@stdlib/buffer/alloc-unsafe":"@stdlib/buffer-alloc-unsafe","@stdlib/array/mskfilter":"@stdlib/array-mskfilter","@stdlib/array/mskput":"@stdlib/array-mskput","@stdlib/array/mskreject":"@stdlib/array-mskreject","@stdlib/array/nans":"@stdlib/array-nans","@stdlib/array/nans-like":"@stdlib/array-nans-like","@stdlib/stats/anova1":"@stdlib/stats-anova1","@stdlib/datasets/anscombes-quartet":"@stdlib/datasets-anscombes-quartet","@stdlib/utils/any":"@stdlib/utils-any","@stdlib/utils/any-by":"@stdlib/utils-any-by","@stdlib/utils/async/any-by":"@stdlib/utils-async-any-by","@stdlib/utils/any-by-right":"@stdlib/utils-any-by-right","@stdlib/utils/async/any-by-right":"@stdlib/utils-async-any-by-right","@stdlib/utils/any-in-by":"@stdlib/utils-any-in-by","@stdlib/utils/any-own-by":"@stdlib/utils-any-own-by","@stdlib/array/ones":"@stdlib/array-ones","@stdlib/array/ones-like":"@stdlib/array-ones-like","@stdlib/array/one-to":"@stdlib/array-one-to","@stdlib/array/one-to-like":"@stdlib/array-one-to-like","@stdlib/constants/float64/apery":"@stdlib/constants-float64-apery","@stdlib/array/place":"@stdlib/array-place","@stdlib/utils/append":"@stdlib/utils-append","@stdlib/array/put":"@stdlib/array-put","@stdlib/os/arch":"@stdlib/os-arch","@stdlib/utils/argument-function":"@stdlib/utils-argument-function","@stdlib/process/argv":"@stdlib/process-argv","@stdlib/ndarray/array":"@stdlib/ndarray-array","@stdlib/buffer/from-array":"@stdlib/buffer-from-array","@stdlib/array/to-fancy":"@stdlib/array-to-fancy","@stdlib/array/to-iterator":"@stdlib/array-to-iterator","@stdlib/array/to-iterator-right":"@stdlib/array-to-iterator-right","@stdlib/array/buffer":"@stdlib/array-buffer","@stdlib/buffer/from-arraybuffer":"@stdlib/buffer-from-arraybuffer","@stdlib/array/ctors":"@stdlib/array-ctors","@stdlib/array/dtype":"@stdlib/array-dtype","@stdlib/array/dtypes":"@stdlib/array-dtypes","@stdlib/array/index":"@stdlib/array-index","@stdlib/array/min-dtype":"@stdlib/array-min-dtype","@stdlib/array/mostly-safe-casts":"@stdlib/array-mostly-safe-casts","@stdlib/array/next-dtype":"@stdlib/array-next-dtype","@stdlib/array/promotion-rules":"@stdlib/array-promotion-rules","@stdlib/array/safe-casts":"@stdlib/array-safe-casts","@stdlib/array/same-kind-casts":"@stdlib/array-same-kind-casts","@stdlib/array/shape":"@stdlib/array-shape","@stdlib/streams/node/from-array":"@stdlib/streams-node-from-array","@stdlib/array/to-view-iterator":"@stdlib/array-to-view-iterator","@stdlib/array/to-view-iterator-right":"@stdlib/array-to-view-iterator-right","@stdlib/array/slice":"@stdlib/array-slice","@stdlib/symbol/async-iterator":"@stdlib/symbol-async-iterator","@stdlib/array/take":"@stdlib/array-take","@stdlib/array/zeros":"@stdlib/array-zeros","@stdlib/array/zeros-like":"@stdlib/array-zeros-like","@stdlib/array/zero-to":"@stdlib/array-zero-to","@stdlib/array/zero-to-like":"@stdlib/array-zero-to-like","@stdlib/stats/bartlett-test":"@stdlib/stats-bartlett-test","@stdlib/math/base/special/abs":"@stdlib/math-base-special-abs","@stdlib/math/base/special/abs2":"@stdlib/math-base-special-abs2","@stdlib/math/base/special/abs2f":"@stdlib/math-base-special-abs2f","@stdlib/math/base/utils/absolute-difference":"@stdlib/math-base-utils-absolute-difference","@stdlib/math/base/special/absf":"@stdlib/math-base-special-absf","@stdlib/array/base/cartesian-power":"@stdlib/array-base-cartesian-power","@stdlib/array/base/cartesian-product":"@stdlib/array-base-cartesian-product","@stdlib/array/base/cartesian-square":"@stdlib/array-base-cartesian-square","@stdlib/math/base/special/acos":"@stdlib/math-base-special-acos","@stdlib/math/base/special/acosd":"@stdlib/math-base-special-acosd","@stdlib/math/base/special/acosf":"@stdlib/math-base-special-acosf","@stdlib/math/base/special/acosh":"@stdlib/math-base-special-acosh","@stdlib/math/base/special/acot":"@stdlib/math-base-special-acot","@stdlib/math/base/special/acotd":"@stdlib/math-base-special-acotd","@stdlib/math/base/special/acotf":"@stdlib/math-base-special-acotf","@stdlib/math/base/special/acoth":"@stdlib/math-base-special-acoth","@stdlib/math/base/special/acovercos":"@stdlib/math-base-special-acovercos","@stdlib/math/base/special/acoversin":"@stdlib/math-base-special-acoversin","@stdlib/math/base/special/acsc":"@stdlib/math-base-special-acsc","@stdlib/math/base/special/acscd":"@stdlib/math-base-special-acscd","@stdlib/math/base/special/acscdf":"@stdlib/math-base-special-acscdf","@stdlib/math/base/special/acscf":"@stdlib/math-base-special-acscf","@stdlib/math/base/special/acsch":"@stdlib/math-base-special-acsch","@stdlib/number/float64/base/add":"@stdlib/number-float64-base-add","@stdlib/number/float64/base/add3":"@stdlib/number-float64-base-add3","@stdlib/number/float64/base/add4":"@stdlib/number-float64-base-add4","@stdlib/number/float64/base/add5":"@stdlib/number-float64-base-add5","@stdlib/number/float32/base/add":"@stdlib/number-float32-base-add","@stdlib/array/base/filled":"@stdlib/array-base-filled","@stdlib/array/base/filled2d":"@stdlib/array-base-filled2d","@stdlib/array/base/filled2d-by":"@stdlib/array-base-filled2d-by","@stdlib/array/base/filled3d":"@stdlib/array-base-filled3d","@stdlib/array/base/filled3d-by":"@stdlib/array-base-filled3d-by","@stdlib/array/base/filled4d":"@stdlib/array-base-filled4d","@stdlib/array/base/filled4d-by":"@stdlib/array-base-filled4d-by","@stdlib/array/base/filled5d":"@stdlib/array-base-filled5d","@stdlib/array/base/filled5d-by":"@stdlib/array-base-filled5d-by","@stdlib/array/base/filled-by":"@stdlib/array-base-filled-by","@stdlib/array/base/fillednd":"@stdlib/array-base-fillednd","@stdlib/array/base/fillednd-by":"@stdlib/array-base-fillednd-by","@stdlib/array/base/filter":"@stdlib/array-base-filter","@stdlib/array/base/first":"@stdlib/array-base-first","@stdlib/array/base/flatten":"@stdlib/array-base-flatten","@stdlib/array/base/flatten2d":"@stdlib/array-base-flatten2d","@stdlib/array/base/flatten2d-by":"@stdlib/array-base-flatten2d-by","@stdlib/array/base/flatten3d":"@stdlib/array-base-flatten3d","@stdlib/array/base/flatten3d-by":"@stdlib/array-base-flatten3d-by","@stdlib/array/base/flatten4d":"@stdlib/array-base-flatten4d","@stdlib/array/base/flatten4d-by":"@stdlib/array-base-flatten4d-by","@stdlib/array/base/flatten5d":"@stdlib/array-base-flatten5d","@stdlib/array/base/flatten5d-by":"@stdlib/array-base-flatten5d-by","@stdlib/array/base/flatten-by":"@stdlib/array-base-flatten-by","@stdlib/array/base/fliplr2d":"@stdlib/array-base-fliplr2d","@stdlib/array/base/fliplr3d":"@stdlib/array-base-fliplr3d","@stdlib/array/base/fliplr4d":"@stdlib/array-base-fliplr4d","@stdlib/array/base/fliplr5d":"@stdlib/array-base-fliplr5d","@stdlib/array/base/flipud2d":"@stdlib/array-base-flipud2d","@stdlib/array/base/flipud3d":"@stdlib/array-base-flipud3d","@stdlib/array/base/flipud4d":"@stdlib/array-base-flipud4d","@stdlib/array/base/flipud5d":"@stdlib/array-base-flipud5d","@stdlib/math/base/special/ahavercos":"@stdlib/math-base-special-ahavercos","@stdlib/math/base/special/ahaversin":"@stdlib/math-base-special-ahaversin","@stdlib/string/base/altcase":"@stdlib/string-base-altcase","@stdlib/array/base/ones":"@stdlib/array-base-ones","@stdlib/array/base/ones2d":"@stdlib/array-base-ones2d","@stdlib/array/base/ones3d":"@stdlib/array-base-ones3d","@stdlib/array/base/ones4d":"@stdlib/array-base-ones4d","@stdlib/array/base/ones5d":"@stdlib/array-base-ones5d","@stdlib/array/base/onesnd":"@stdlib/array-base-onesnd","@stdlib/array/base/one-to":"@stdlib/array-base-one-to","@stdlib/slice/base/args2multislice":"@stdlib/slice-base-args2multislice","@stdlib/math/base/special/asec":"@stdlib/math-base-special-asec","@stdlib/math/base/special/asecd":"@stdlib/math-base-special-asecd","@stdlib/math/base/special/asecdf":"@stdlib/math-base-special-asecdf","@stdlib/math/base/special/asecf":"@stdlib/math-base-special-asecf","@stdlib/math/base/special/asech":"@stdlib/math-base-special-asech","@stdlib/math/base/special/asin":"@stdlib/math-base-special-asin","@stdlib/math/base/special/asind":"@stdlib/math-base-special-asind","@stdlib/math/base/special/asindf":"@stdlib/math-base-special-asindf","@stdlib/math/base/special/asinf":"@stdlib/math-base-special-asinf","@stdlib/math/base/special/asinh":"@stdlib/math-base-special-asinh","@stdlib/math/base/special/atan":"@stdlib/math-base-special-atan","@stdlib/math/base/special/atan2":"@stdlib/math-base-special-atan2","@stdlib/math/base/special/atand":"@stdlib/math-base-special-atand","@stdlib/math/base/special/atanf":"@stdlib/math-base-special-atanf","@stdlib/math/base/special/atanh":"@stdlib/math-base-special-atanh","@stdlib/math/base/special/avercos":"@stdlib/math-base-special-avercos","@stdlib/math/base/special/aversin":"@stdlib/math-base-special-aversin","@stdlib/array/base/zeros":"@stdlib/array-base-zeros","@stdlib/array/base/zeros2d":"@stdlib/array-base-zeros2d","@stdlib/array/base/zeros3d":"@stdlib/array-base-zeros3d","@stdlib/array/base/zeros4d":"@stdlib/array-base-zeros4d","@stdlib/array/base/zeros5d":"@stdlib/array-base-zeros5d","@stdlib/array/base/zerosnd":"@stdlib/array-base-zerosnd","@stdlib/array/base/zero-to":"@stdlib/array-base-zero-to","@stdlib/math/base/special/bernoulli":"@stdlib/math-base-special-bernoulli","@stdlib/math/base/special/besselj0":"@stdlib/math-base-special-besselj0","@stdlib/math/base/special/besselj1":"@stdlib/math-base-special-besselj1","@stdlib/math/base/special/bessely0":"@stdlib/math-base-special-bessely0","@stdlib/math/base/special/bessely1":"@stdlib/math-base-special-bessely1","@stdlib/math/base/special/beta":"@stdlib/math-base-special-beta","@stdlib/math/base/special/betainc":"@stdlib/math-base-special-betainc","@stdlib/math/base/special/betaincinv":"@stdlib/math-base-special-betaincinv","@stdlib/math/base/special/betaln":"@stdlib/math-base-special-betaln","@stdlib/math/base/special/binet":"@stdlib/math-base-special-binet","@stdlib/math/base/special/binomcoef":"@stdlib/math-base-special-binomcoef","@stdlib/math/base/special/binomcoefln":"@stdlib/math-base-special-binomcoefln","@stdlib/math/base/special/boxcox":"@stdlib/math-base-special-boxcox","@stdlib/math/base/special/boxcox1p":"@stdlib/math-base-special-boxcox1p","@stdlib/math/base/special/boxcox1pinv":"@stdlib/math-base-special-boxcox1pinv","@stdlib/math/base/special/boxcoxinv":"@stdlib/math-base-special-boxcoxinv","@stdlib/math/base/special/cabs":"@stdlib/math-base-special-cabs","@stdlib/math/base/special/cabs2":"@stdlib/math-base-special-cabs2","@stdlib/math/base/special/cabs2f":"@stdlib/math-base-special-cabs2f","@stdlib/math/base/special/cabsf":"@stdlib/math-base-special-cabsf","@stdlib/complex/float64/base/add":"@stdlib/complex-float64-base-add","@stdlib/complex/float32/base/add":"@stdlib/complex-float32-base-add","@stdlib/string/base/camelcase":"@stdlib/string-base-camelcase","@stdlib/string/base/capitalize":"@stdlib/string-base-capitalize","@stdlib/math/base/special/cbrt":"@stdlib/math-base-special-cbrt","@stdlib/math/base/special/cbrtf":"@stdlib/math-base-special-cbrtf","@stdlib/math/base/special/cceil":"@stdlib/math-base-special-cceil","@stdlib/math/base/special/cceilf":"@stdlib/math-base-special-cceilf","@stdlib/math/base/special/cceiln":"@stdlib/math-base-special-cceiln","@stdlib/math/base/special/ccis":"@stdlib/math-base-special-ccis","@stdlib/math/base/ops/cdiv":"@stdlib/math-base-ops-cdiv","@stdlib/math/base/special/ceil":"@stdlib/math-base-special-ceil","@stdlib/math/base/special/ceil2":"@stdlib/math-base-special-ceil2","@stdlib/math/base/special/ceil10":"@stdlib/math-base-special-ceil10","@stdlib/math/base/special/ceilb":"@stdlib/math-base-special-ceilb","@stdlib/math/base/special/ceilf":"@stdlib/math-base-special-ceilf","@stdlib/math/base/special/ceiln":"@stdlib/math-base-special-ceiln","@stdlib/math/base/special/ceilsd":"@stdlib/math-base-special-ceilsd","@stdlib/math/base/special/cexp":"@stdlib/math-base-special-cexp","@stdlib/math/base/special/cflipsign":"@stdlib/math-base-special-cflipsign","@stdlib/math/base/special/cflipsignf":"@stdlib/math-base-special-cflipsignf","@stdlib/math/base/special/cfloor":"@stdlib/math-base-special-cfloor","@stdlib/math/base/special/cfloorn":"@stdlib/math-base-special-cfloorn","@stdlib/math/base/special/cidentity":"@stdlib/math-base-special-cidentity","@stdlib/math/base/special/cidentityf":"@stdlib/math-base-special-cidentityf","@stdlib/math/base/special/cinv":"@stdlib/math-base-special-cinv","@stdlib/math/base/special/clamp":"@stdlib/math-base-special-clamp","@stdlib/math/base/special/clampf":"@stdlib/math-base-special-clampf","@stdlib/complex/float64/base/mul":"@stdlib/complex-float64-base-mul","@stdlib/complex/float32/base/mul":"@stdlib/complex-float32-base-mul","@stdlib/math/base/ops/cneg":"@stdlib/math-base-ops-cneg","@stdlib/math/base/ops/cnegf":"@stdlib/math-base-ops-cnegf","@stdlib/string/base/code-point-at":"@stdlib/string-base-code-point-at","@stdlib/string/base/constantcase":"@stdlib/string-base-constantcase","@stdlib/math/base/tools/continued-fraction":"@stdlib/math-base-tools-continued-fraction","@stdlib/math/base/special/copysign":"@stdlib/math-base-special-copysign","@stdlib/math/base/special/copysignf":"@stdlib/math-base-special-copysignf","@stdlib/math/base/special/cos":"@stdlib/math-base-special-cos","@stdlib/math/base/special/cosd":"@stdlib/math-base-special-cosd","@stdlib/math/base/special/cosh":"@stdlib/math-base-special-cosh","@stdlib/math/base/special/cosm1":"@stdlib/math-base-special-cosm1","@stdlib/math/base/special/cospi":"@stdlib/math-base-special-cospi","@stdlib/math/base/special/cot":"@stdlib/math-base-special-cot","@stdlib/math/base/special/cotd":"@stdlib/math-base-special-cotd","@stdlib/math/base/special/coth":"@stdlib/math-base-special-coth","@stdlib/math/base/special/covercos":"@stdlib/math-base-special-covercos","@stdlib/math/base/special/coversin":"@stdlib/math-base-special-coversin","@stdlib/math/base/special/cphase":"@stdlib/math-base-special-cphase","@stdlib/math/base/special/cpolar":"@stdlib/math-base-special-cpolar","@stdlib/math/base/special/cround":"@stdlib/math-base-special-cround","@stdlib/math/base/special/croundn":"@stdlib/math-base-special-croundn","@stdlib/math/base/special/csc":"@stdlib/math-base-special-csc","@stdlib/math/base/special/cscd":"@stdlib/math-base-special-cscd","@stdlib/math/base/special/csch":"@stdlib/math-base-special-csch","@stdlib/math/base/special/csignum":"@stdlib/math-base-special-csignum","@stdlib/math/base/ops/csub":"@stdlib/math-base-ops-csub","@stdlib/math/base/ops/csubf":"@stdlib/math-base-ops-csubf","@stdlib/math/base/special/deg2rad":"@stdlib/math-base-special-deg2rad","@stdlib/math/base/special/deg2radf":"@stdlib/math-base-special-deg2radf","@stdlib/math/base/special/digamma":"@stdlib/math-base-special-digamma","@stdlib/math/base/special/dirac-delta":"@stdlib/math-base-special-dirac-delta","@stdlib/number/float64/base/div":"@stdlib/number-float64-base-div","@stdlib/number/float32/base/div":"@stdlib/number-float32-base-div","@stdlib/string/base/dotcase":"@stdlib/string-base-dotcase","@stdlib/stats/base/dists/arcsine/ctor":"@stdlib/stats-base-dists-arcsine-ctor","@stdlib/stats/base/dists/arcsine/cdf":"@stdlib/stats-base-dists-arcsine-cdf","@stdlib/stats/base/dists/arcsine/entropy":"@stdlib/stats-base-dists-arcsine-entropy","@stdlib/stats/base/dists/arcsine/kurtosis":"@stdlib/stats-base-dists-arcsine-kurtosis","@stdlib/stats/base/dists/arcsine/logcdf":"@stdlib/stats-base-dists-arcsine-logcdf","@stdlib/stats/base/dists/arcsine/logpdf":"@stdlib/stats-base-dists-arcsine-logpdf","@stdlib/stats/base/dists/arcsine/mean":"@stdlib/stats-base-dists-arcsine-mean","@stdlib/stats/base/dists/arcsine/median":"@stdlib/stats-base-dists-arcsine-median","@stdlib/stats/base/dists/arcsine/mode":"@stdlib/stats-base-dists-arcsine-mode","@stdlib/stats/base/dists/arcsine/pdf":"@stdlib/stats-base-dists-arcsine-pdf","@stdlib/stats/base/dists/arcsine/quantile":"@stdlib/stats-base-dists-arcsine-quantile","@stdlib/stats/base/dists/arcsine/skewness":"@stdlib/stats-base-dists-arcsine-skewness","@stdlib/stats/base/dists/arcsine/stdev":"@stdlib/stats-base-dists-arcsine-stdev","@stdlib/stats/base/dists/arcsine/variance":"@stdlib/stats-base-dists-arcsine-variance","@stdlib/stats/base/dists/bernoulli/ctor":"@stdlib/stats-base-dists-bernoulli-ctor","@stdlib/stats/base/dists/bernoulli/cdf":"@stdlib/stats-base-dists-bernoulli-cdf","@stdlib/stats/base/dists/bernoulli/entropy":"@stdlib/stats-base-dists-bernoulli-entropy","@stdlib/stats/base/dists/bernoulli/kurtosis":"@stdlib/stats-base-dists-bernoulli-kurtosis","@stdlib/stats/base/dists/bernoulli/mean":"@stdlib/stats-base-dists-bernoulli-mean","@stdlib/stats/base/dists/bernoulli/median":"@stdlib/stats-base-dists-bernoulli-median","@stdlib/stats/base/dists/bernoulli/mgf":"@stdlib/stats-base-dists-bernoulli-mgf","@stdlib/stats/base/dists/bernoulli/mode":"@stdlib/stats-base-dists-bernoulli-mode","@stdlib/stats/base/dists/bernoulli/pmf":"@stdlib/stats-base-dists-bernoulli-pmf","@stdlib/stats/base/dists/bernoulli/quantile":"@stdlib/stats-base-dists-bernoulli-quantile","@stdlib/stats/base/dists/bernoulli/skewness":"@stdlib/stats-base-dists-bernoulli-skewness","@stdlib/stats/base/dists/bernoulli/stdev":"@stdlib/stats-base-dists-bernoulli-stdev","@stdlib/stats/base/dists/bernoulli/variance":"@stdlib/stats-base-dists-bernoulli-variance","@stdlib/stats/base/dists/beta/ctor":"@stdlib/stats-base-dists-beta-ctor","@stdlib/stats/base/dists/beta/cdf":"@stdlib/stats-base-dists-beta-cdf","@stdlib/stats/base/dists/beta/entropy":"@stdlib/stats-base-dists-beta-entropy","@stdlib/stats/base/dists/beta/kurtosis":"@stdlib/stats-base-dists-beta-kurtosis","@stdlib/stats/base/dists/beta/logcdf":"@stdlib/stats-base-dists-beta-logcdf","@stdlib/stats/base/dists/beta/logpdf":"@stdlib/stats-base-dists-beta-logpdf","@stdlib/stats/base/dists/beta/mean":"@stdlib/stats-base-dists-beta-mean","@stdlib/stats/base/dists/beta/median":"@stdlib/stats-base-dists-beta-median","@stdlib/stats/base/dists/beta/mgf":"@stdlib/stats-base-dists-beta-mgf","@stdlib/stats/base/dists/beta/mode":"@stdlib/stats-base-dists-beta-mode","@stdlib/stats/base/dists/beta/pdf":"@stdlib/stats-base-dists-beta-pdf","@stdlib/stats/base/dists/beta/quantile":"@stdlib/stats-base-dists-beta-quantile","@stdlib/stats/base/dists/beta/skewness":"@stdlib/stats-base-dists-beta-skewness","@stdlib/stats/base/dists/beta/stdev":"@stdlib/stats-base-dists-beta-stdev","@stdlib/stats/base/dists/beta/variance":"@stdlib/stats-base-dists-beta-variance","@stdlib/stats/base/dists/betaprime/ctor":"@stdlib/stats-base-dists-betaprime-ctor","@stdlib/stats/base/dists/betaprime/cdf":"@stdlib/stats-base-dists-betaprime-cdf","@stdlib/stats/base/dists/betaprime/kurtosis":"@stdlib/stats-base-dists-betaprime-kurtosis","@stdlib/stats/base/dists/betaprime/logcdf":"@stdlib/stats-base-dists-betaprime-logcdf","@stdlib/stats/base/dists/betaprime/logpdf":"@stdlib/stats-base-dists-betaprime-logpdf","@stdlib/stats/base/dists/betaprime/mean":"@stdlib/stats-base-dists-betaprime-mean","@stdlib/stats/base/dists/betaprime/mode":"@stdlib/stats-base-dists-betaprime-mode","@stdlib/stats/base/dists/betaprime/pdf":"@stdlib/stats-base-dists-betaprime-pdf","@stdlib/stats/base/dists/betaprime/quantile":"@stdlib/stats-base-dists-betaprime-quantile","@stdlib/stats/base/dists/betaprime/skewness":"@stdlib/stats-base-dists-betaprime-skewness","@stdlib/stats/base/dists/betaprime/stdev":"@stdlib/stats-base-dists-betaprime-stdev","@stdlib/stats/base/dists/betaprime/variance":"@stdlib/stats-base-dists-betaprime-variance","@stdlib/stats/base/dists/binomial/ctor":"@stdlib/stats-base-dists-binomial-ctor","@stdlib/stats/base/dists/binomial/cdf":"@stdlib/stats-base-dists-binomial-cdf","@stdlib/stats/base/dists/binomial/entropy":"@stdlib/stats-base-dists-binomial-entropy","@stdlib/stats/base/dists/binomial/kurtosis":"@stdlib/stats-base-dists-binomial-kurtosis","@stdlib/stats/base/dists/binomial/logpmf":"@stdlib/stats-base-dists-binomial-logpmf","@stdlib/stats/base/dists/binomial/mean":"@stdlib/stats-base-dists-binomial-mean","@stdlib/stats/base/dists/binomial/median":"@stdlib/stats-base-dists-binomial-median","@stdlib/stats/base/dists/binomial/mgf":"@stdlib/stats-base-dists-binomial-mgf","@stdlib/stats/base/dists/binomial/mode":"@stdlib/stats-base-dists-binomial-mode","@stdlib/stats/base/dists/binomial/pmf":"@stdlib/stats-base-dists-binomial-pmf","@stdlib/stats/base/dists/binomial/quantile":"@stdlib/stats-base-dists-binomial-quantile","@stdlib/stats/base/dists/binomial/skewness":"@stdlib/stats-base-dists-binomial-skewness","@stdlib/stats/base/dists/binomial/stdev":"@stdlib/stats-base-dists-binomial-stdev","@stdlib/stats/base/dists/binomial/variance":"@stdlib/stats-base-dists-binomial-variance","@stdlib/stats/base/dists/cauchy/ctor":"@stdlib/stats-base-dists-cauchy-ctor","@stdlib/stats/base/dists/cauchy/cdf":"@stdlib/stats-base-dists-cauchy-cdf","@stdlib/stats/base/dists/cauchy/entropy":"@stdlib/stats-base-dists-cauchy-entropy","@stdlib/stats/base/dists/cauchy/logcdf":"@stdlib/stats-base-dists-cauchy-logcdf","@stdlib/stats/base/dists/cauchy/logpdf":"@stdlib/stats-base-dists-cauchy-logpdf","@stdlib/stats/base/dists/cauchy/median":"@stdlib/stats-base-dists-cauchy-median","@stdlib/stats/base/dists/cauchy/mode":"@stdlib/stats-base-dists-cauchy-mode","@stdlib/stats/base/dists/cauchy/pdf":"@stdlib/stats-base-dists-cauchy-pdf","@stdlib/stats/base/dists/cauchy/quantile":"@stdlib/stats-base-dists-cauchy-quantile","@stdlib/stats/base/dists/chi/cdf":"@stdlib/stats-base-dists-chi-cdf","@stdlib/stats/base/dists/chi/ctor":"@stdlib/stats-base-dists-chi-ctor","@stdlib/stats/base/dists/chi/entropy":"@stdlib/stats-base-dists-chi-entropy","@stdlib/stats/base/dists/chi/kurtosis":"@stdlib/stats-base-dists-chi-kurtosis","@stdlib/stats/base/dists/chi/logpdf":"@stdlib/stats-base-dists-chi-logpdf","@stdlib/stats/base/dists/chi/mean":"@stdlib/stats-base-dists-chi-mean","@stdlib/stats/base/dists/chi/mode":"@stdlib/stats-base-dists-chi-mode","@stdlib/stats/base/dists/chi/pdf":"@stdlib/stats-base-dists-chi-pdf","@stdlib/stats/base/dists/chi/quantile":"@stdlib/stats-base-dists-chi-quantile","@stdlib/stats/base/dists/chi/skewness":"@stdlib/stats-base-dists-chi-skewness","@stdlib/stats/base/dists/chi/stdev":"@stdlib/stats-base-dists-chi-stdev","@stdlib/stats/base/dists/chi/variance":"@stdlib/stats-base-dists-chi-variance","@stdlib/stats/base/dists/chisquare/cdf":"@stdlib/stats-base-dists-chisquare-cdf","@stdlib/stats/base/dists/chisquare/ctor":"@stdlib/stats-base-dists-chisquare-ctor","@stdlib/stats/base/dists/chisquare/entropy":"@stdlib/stats-base-dists-chisquare-entropy","@stdlib/stats/base/dists/chisquare/kurtosis":"@stdlib/stats-base-dists-chisquare-kurtosis","@stdlib/stats/base/dists/chisquare/logpdf":"@stdlib/stats-base-dists-chisquare-logpdf","@stdlib/stats/base/dists/chisquare/mean":"@stdlib/stats-base-dists-chisquare-mean","@stdlib/stats/base/dists/chisquare/median":"@stdlib/stats-base-dists-chisquare-median","@stdlib/stats/base/dists/chisquare/mgf":"@stdlib/stats-base-dists-chisquare-mgf","@stdlib/stats/base/dists/chisquare/mode":"@stdlib/stats-base-dists-chisquare-mode","@stdlib/stats/base/dists/chisquare/pdf":"@stdlib/stats-base-dists-chisquare-pdf","@stdlib/stats/base/dists/chisquare/quantile":"@stdlib/stats-base-dists-chisquare-quantile","@stdlib/stats/base/dists/chisquare/skewness":"@stdlib/stats-base-dists-chisquare-skewness","@stdlib/stats/base/dists/chisquare/stdev":"@stdlib/stats-base-dists-chisquare-stdev","@stdlib/stats/base/dists/chisquare/variance":"@stdlib/stats-base-dists-chisquare-variance","@stdlib/stats/base/dists/cosine/cdf":"@stdlib/stats-base-dists-cosine-cdf","@stdlib/stats/base/dists/cosine/ctor":"@stdlib/stats-base-dists-cosine-ctor","@stdlib/stats/base/dists/cosine/kurtosis":"@stdlib/stats-base-dists-cosine-kurtosis","@stdlib/stats/base/dists/cosine/logcdf":"@stdlib/stats-base-dists-cosine-logcdf","@stdlib/stats/base/dists/cosine/logpdf":"@stdlib/stats-base-dists-cosine-logpdf","@stdlib/stats/base/dists/cosine/mean":"@stdlib/stats-base-dists-cosine-mean","@stdlib/stats/base/dists/cosine/median":"@stdlib/stats-base-dists-cosine-median","@stdlib/stats/base/dists/cosine/mgf":"@stdlib/stats-base-dists-cosine-mgf","@stdlib/stats/base/dists/cosine/mode":"@stdlib/stats-base-dists-cosine-mode","@stdlib/stats/base/dists/cosine/pdf":"@stdlib/stats-base-dists-cosine-pdf","@stdlib/stats/base/dists/cosine/quantile":"@stdlib/stats-base-dists-cosine-quantile","@stdlib/stats/base/dists/cosine/skewness":"@stdlib/stats-base-dists-cosine-skewness","@stdlib/stats/base/dists/cosine/stdev":"@stdlib/stats-base-dists-cosine-stdev","@stdlib/stats/base/dists/cosine/variance":"@stdlib/stats-base-dists-cosine-variance","@stdlib/stats/base/dists/degenerate/cdf":"@stdlib/stats-base-dists-degenerate-cdf","@stdlib/stats/base/dists/degenerate/ctor":"@stdlib/stats-base-dists-degenerate-ctor","@stdlib/stats/base/dists/degenerate/entropy":"@stdlib/stats-base-dists-degenerate-entropy","@stdlib/stats/base/dists/degenerate/logcdf":"@stdlib/stats-base-dists-degenerate-logcdf","@stdlib/stats/base/dists/degenerate/logpdf":"@stdlib/stats-base-dists-degenerate-logpdf","@stdlib/stats/base/dists/degenerate/logpmf":"@stdlib/stats-base-dists-degenerate-logpmf","@stdlib/stats/base/dists/degenerate/mean":"@stdlib/stats-base-dists-degenerate-mean","@stdlib/stats/base/dists/degenerate/median":"@stdlib/stats-base-dists-degenerate-median","@stdlib/stats/base/dists/degenerate/mgf":"@stdlib/stats-base-dists-degenerate-mgf","@stdlib/stats/base/dists/degenerate/mode":"@stdlib/stats-base-dists-degenerate-mode","@stdlib/stats/base/dists/degenerate/pdf":"@stdlib/stats-base-dists-degenerate-pdf","@stdlib/stats/base/dists/degenerate/pmf":"@stdlib/stats-base-dists-degenerate-pmf","@stdlib/stats/base/dists/degenerate/quantile":"@stdlib/stats-base-dists-degenerate-quantile","@stdlib/stats/base/dists/degenerate/stdev":"@stdlib/stats-base-dists-degenerate-stdev","@stdlib/stats/base/dists/degenerate/variance":"@stdlib/stats-base-dists-degenerate-variance","@stdlib/stats/base/dists/discrete-uniform/cdf":"@stdlib/stats-base-dists-discrete-uniform-cdf","@stdlib/stats/base/dists/discrete-uniform/ctor":"@stdlib/stats-base-dists-discrete-uniform-ctor","@stdlib/stats/base/dists/discrete-uniform/entropy":"@stdlib/stats-base-dists-discrete-uniform-entropy","@stdlib/stats/base/dists/discrete-uniform/kurtosis":"@stdlib/stats-base-dists-discrete-uniform-kurtosis","@stdlib/stats/base/dists/discrete-uniform/logcdf":"@stdlib/stats-base-dists-discrete-uniform-logcdf","@stdlib/stats/base/dists/discrete-uniform/logpmf":"@stdlib/stats-base-dists-discrete-uniform-logpmf","@stdlib/stats/base/dists/discrete-uniform/mean":"@stdlib/stats-base-dists-discrete-uniform-mean","@stdlib/stats/base/dists/discrete-uniform/median":"@stdlib/stats-base-dists-discrete-uniform-median","@stdlib/stats/base/dists/discrete-uniform/mgf":"@stdlib/stats-base-dists-discrete-uniform-mgf","@stdlib/stats/base/dists/discrete-uniform/pmf":"@stdlib/stats-base-dists-discrete-uniform-pmf","@stdlib/stats/base/dists/discrete-uniform/quantile":"@stdlib/stats-base-dists-discrete-uniform-quantile","@stdlib/stats/base/dists/discrete-uniform/skewness":"@stdlib/stats-base-dists-discrete-uniform-skewness","@stdlib/stats/base/dists/discrete-uniform/stdev":"@stdlib/stats-base-dists-discrete-uniform-stdev","@stdlib/stats/base/dists/discrete-uniform/variance":"@stdlib/stats-base-dists-discrete-uniform-variance","@stdlib/stats/base/dists/erlang/cdf":"@stdlib/stats-base-dists-erlang-cdf","@stdlib/stats/base/dists/erlang/entropy":"@stdlib/stats-base-dists-erlang-entropy","@stdlib/stats/base/dists/erlang/ctor":"@stdlib/stats-base-dists-erlang-ctor","@stdlib/stats/base/dists/erlang/kurtosis":"@stdlib/stats-base-dists-erlang-kurtosis","@stdlib/stats/base/dists/erlang/logpdf":"@stdlib/stats-base-dists-erlang-logpdf","@stdlib/stats/base/dists/erlang/mean":"@stdlib/stats-base-dists-erlang-mean","@stdlib/stats/base/dists/erlang/mgf":"@stdlib/stats-base-dists-erlang-mgf","@stdlib/stats/base/dists/erlang/mode":"@stdlib/stats-base-dists-erlang-mode","@stdlib/stats/base/dists/erlang/pdf":"@stdlib/stats-base-dists-erlang-pdf","@stdlib/stats/base/dists/erlang/quantile":"@stdlib/stats-base-dists-erlang-quantile","@stdlib/stats/base/dists/erlang/skewness":"@stdlib/stats-base-dists-erlang-skewness","@stdlib/stats/base/dists/erlang/stdev":"@stdlib/stats-base-dists-erlang-stdev","@stdlib/stats/base/dists/erlang/variance":"@stdlib/stats-base-dists-erlang-variance","@stdlib/stats/base/dists/exponential/cdf":"@stdlib/stats-base-dists-exponential-cdf","@stdlib/stats/base/dists/exponential/entropy":"@stdlib/stats-base-dists-exponential-entropy","@stdlib/stats/base/dists/exponential/ctor":"@stdlib/stats-base-dists-exponential-ctor","@stdlib/stats/base/dists/exponential/kurtosis":"@stdlib/stats-base-dists-exponential-kurtosis","@stdlib/stats/base/dists/exponential/logcdf":"@stdlib/stats-base-dists-exponential-logcdf","@stdlib/stats/base/dists/exponential/logpdf":"@stdlib/stats-base-dists-exponential-logpdf","@stdlib/stats/base/dists/exponential/mean":"@stdlib/stats-base-dists-exponential-mean","@stdlib/stats/base/dists/exponential/median":"@stdlib/stats-base-dists-exponential-median","@stdlib/stats/base/dists/exponential/mgf":"@stdlib/stats-base-dists-exponential-mgf","@stdlib/stats/base/dists/exponential/mode":"@stdlib/stats-base-dists-exponential-mode","@stdlib/stats/base/dists/exponential/pdf":"@stdlib/stats-base-dists-exponential-pdf","@stdlib/stats/base/dists/exponential/quantile":"@stdlib/stats-base-dists-exponential-quantile","@stdlib/stats/base/dists/exponential/skewness":"@stdlib/stats-base-dists-exponential-skewness","@stdlib/stats/base/dists/exponential/stdev":"@stdlib/stats-base-dists-exponential-stdev","@stdlib/stats/base/dists/exponential/variance":"@stdlib/stats-base-dists-exponential-variance","@stdlib/stats/base/dists/f/cdf":"@stdlib/stats-base-dists-f-cdf","@stdlib/stats/base/dists/f/entropy":"@stdlib/stats-base-dists-f-entropy","@stdlib/stats/base/dists/f/ctor":"@stdlib/stats-base-dists-f-ctor","@stdlib/stats/base/dists/f/kurtosis":"@stdlib/stats-base-dists-f-kurtosis","@stdlib/stats/base/dists/f/mean":"@stdlib/stats-base-dists-f-mean","@stdlib/stats/base/dists/f/mode":"@stdlib/stats-base-dists-f-mode","@stdlib/stats/base/dists/f/pdf":"@stdlib/stats-base-dists-f-pdf","@stdlib/stats/base/dists/f/quantile":"@stdlib/stats-base-dists-f-quantile","@stdlib/stats/base/dists/f/skewness":"@stdlib/stats-base-dists-f-skewness","@stdlib/stats/base/dists/f/stdev":"@stdlib/stats-base-dists-f-stdev","@stdlib/stats/base/dists/f/variance":"@stdlib/stats-base-dists-f-variance","@stdlib/stats/base/dists/frechet/cdf":"@stdlib/stats-base-dists-frechet-cdf","@stdlib/stats/base/dists/frechet/entropy":"@stdlib/stats-base-dists-frechet-entropy","@stdlib/stats/base/dists/frechet/ctor":"@stdlib/stats-base-dists-frechet-ctor","@stdlib/stats/base/dists/frechet/kurtosis":"@stdlib/stats-base-dists-frechet-kurtosis","@stdlib/stats/base/dists/frechet/logcdf":"@stdlib/stats-base-dists-frechet-logcdf","@stdlib/stats/base/dists/frechet/logpdf":"@stdlib/stats-base-dists-frechet-logpdf","@stdlib/stats/base/dists/frechet/mean":"@stdlib/stats-base-dists-frechet-mean","@stdlib/stats/base/dists/frechet/median":"@stdlib/stats-base-dists-frechet-median","@stdlib/stats/base/dists/frechet/mode":"@stdlib/stats-base-dists-frechet-mode","@stdlib/stats/base/dists/frechet/pdf":"@stdlib/stats-base-dists-frechet-pdf","@stdlib/stats/base/dists/frechet/quantile":"@stdlib/stats-base-dists-frechet-quantile","@stdlib/stats/base/dists/frechet/skewness":"@stdlib/stats-base-dists-frechet-skewness","@stdlib/stats/base/dists/frechet/stdev":"@stdlib/stats-base-dists-frechet-stdev","@stdlib/stats/base/dists/frechet/variance":"@stdlib/stats-base-dists-frechet-variance","@stdlib/stats/base/dists/gamma/cdf":"@stdlib/stats-base-dists-gamma-cdf","@stdlib/stats/base/dists/gamma/entropy":"@stdlib/stats-base-dists-gamma-entropy","@stdlib/stats/base/dists/gamma/ctor":"@stdlib/stats-base-dists-gamma-ctor","@stdlib/stats/base/dists/gamma/kurtosis":"@stdlib/stats-base-dists-gamma-kurtosis","@stdlib/stats/base/dists/gamma/logcdf":"@stdlib/stats-base-dists-gamma-logcdf","@stdlib/stats/base/dists/gamma/logpdf":"@stdlib/stats-base-dists-gamma-logpdf","@stdlib/stats/base/dists/gamma/mean":"@stdlib/stats-base-dists-gamma-mean","@stdlib/stats/base/dists/gamma/mgf":"@stdlib/stats-base-dists-gamma-mgf","@stdlib/stats/base/dists/gamma/mode":"@stdlib/stats-base-dists-gamma-mode","@stdlib/stats/base/dists/gamma/pdf":"@stdlib/stats-base-dists-gamma-pdf","@stdlib/stats/base/dists/gamma/quantile":"@stdlib/stats-base-dists-gamma-quantile","@stdlib/stats/base/dists/gamma/skewness":"@stdlib/stats-base-dists-gamma-skewness","@stdlib/stats/base/dists/gamma/stdev":"@stdlib/stats-base-dists-gamma-stdev","@stdlib/stats/base/dists/gamma/variance":"@stdlib/stats-base-dists-gamma-variance","@stdlib/stats/base/dists/geometric/cdf":"@stdlib/stats-base-dists-geometric-cdf","@stdlib/stats/base/dists/geometric/entropy":"@stdlib/stats-base-dists-geometric-entropy","@stdlib/stats/base/dists/geometric/ctor":"@stdlib/stats-base-dists-geometric-ctor","@stdlib/stats/base/dists/geometric/kurtosis":"@stdlib/stats-base-dists-geometric-kurtosis","@stdlib/stats/base/dists/geometric/logcdf":"@stdlib/stats-base-dists-geometric-logcdf","@stdlib/stats/base/dists/geometric/logpmf":"@stdlib/stats-base-dists-geometric-logpmf","@stdlib/stats/base/dists/geometric/mean":"@stdlib/stats-base-dists-geometric-mean","@stdlib/stats/base/dists/geometric/median":"@stdlib/stats-base-dists-geometric-median","@stdlib/stats/base/dists/geometric/mgf":"@stdlib/stats-base-dists-geometric-mgf","@stdlib/stats/base/dists/geometric/mode":"@stdlib/stats-base-dists-geometric-mode","@stdlib/stats/base/dists/geometric/pmf":"@stdlib/stats-base-dists-geometric-pmf","@stdlib/stats/base/dists/geometric/quantile":"@stdlib/stats-base-dists-geometric-quantile","@stdlib/stats/base/dists/geometric/skewness":"@stdlib/stats-base-dists-geometric-skewness","@stdlib/stats/base/dists/geometric/stdev":"@stdlib/stats-base-dists-geometric-stdev","@stdlib/stats/base/dists/geometric/variance":"@stdlib/stats-base-dists-geometric-variance","@stdlib/stats/base/dists/gumbel/cdf":"@stdlib/stats-base-dists-gumbel-cdf","@stdlib/stats/base/dists/gumbel/entropy":"@stdlib/stats-base-dists-gumbel-entropy","@stdlib/stats/base/dists/gumbel/ctor":"@stdlib/stats-base-dists-gumbel-ctor","@stdlib/stats/base/dists/gumbel/kurtosis":"@stdlib/stats-base-dists-gumbel-kurtosis","@stdlib/stats/base/dists/gumbel/logcdf":"@stdlib/stats-base-dists-gumbel-logcdf","@stdlib/stats/base/dists/gumbel/logpdf":"@stdlib/stats-base-dists-gumbel-logpdf","@stdlib/stats/base/dists/gumbel/mean":"@stdlib/stats-base-dists-gumbel-mean","@stdlib/stats/base/dists/gumbel/median":"@stdlib/stats-base-dists-gumbel-median","@stdlib/stats/base/dists/gumbel/mgf":"@stdlib/stats-base-dists-gumbel-mgf","@stdlib/stats/base/dists/gumbel/mode":"@stdlib/stats-base-dists-gumbel-mode","@stdlib/stats/base/dists/gumbel/pdf":"@stdlib/stats-base-dists-gumbel-pdf","@stdlib/stats/base/dists/gumbel/quantile":"@stdlib/stats-base-dists-gumbel-quantile","@stdlib/stats/base/dists/gumbel/skewness":"@stdlib/stats-base-dists-gumbel-skewness","@stdlib/stats/base/dists/gumbel/stdev":"@stdlib/stats-base-dists-gumbel-stdev","@stdlib/stats/base/dists/gumbel/variance":"@stdlib/stats-base-dists-gumbel-variance","@stdlib/stats/base/dists/hypergeometric/cdf":"@stdlib/stats-base-dists-hypergeometric-cdf","@stdlib/stats/base/dists/hypergeometric/ctor":"@stdlib/stats-base-dists-hypergeometric-ctor","@stdlib/stats/base/dists/hypergeometric/kurtosis":"@stdlib/stats-base-dists-hypergeometric-kurtosis","@stdlib/stats/base/dists/hypergeometric/logpmf":"@stdlib/stats-base-dists-hypergeometric-logpmf","@stdlib/stats/base/dists/hypergeometric/mean":"@stdlib/stats-base-dists-hypergeometric-mean","@stdlib/stats/base/dists/hypergeometric/mode":"@stdlib/stats-base-dists-hypergeometric-mode","@stdlib/stats/base/dists/hypergeometric/pmf":"@stdlib/stats-base-dists-hypergeometric-pmf","@stdlib/stats/base/dists/hypergeometric/quantile":"@stdlib/stats-base-dists-hypergeometric-quantile","@stdlib/stats/base/dists/hypergeometric/skewness":"@stdlib/stats-base-dists-hypergeometric-skewness","@stdlib/stats/base/dists/hypergeometric/stdev":"@stdlib/stats-base-dists-hypergeometric-stdev","@stdlib/stats/base/dists/hypergeometric/variance":"@stdlib/stats-base-dists-hypergeometric-variance","@stdlib/stats/base/dists/invgamma/cdf":"@stdlib/stats-base-dists-invgamma-cdf","@stdlib/stats/base/dists/invgamma/entropy":"@stdlib/stats-base-dists-invgamma-entropy","@stdlib/stats/base/dists/invgamma/ctor":"@stdlib/stats-base-dists-invgamma-ctor","@stdlib/stats/base/dists/invgamma/kurtosis":"@stdlib/stats-base-dists-invgamma-kurtosis","@stdlib/stats/base/dists/invgamma/logpdf":"@stdlib/stats-base-dists-invgamma-logpdf","@stdlib/stats/base/dists/invgamma/mean":"@stdlib/stats-base-dists-invgamma-mean","@stdlib/stats/base/dists/invgamma/mode":"@stdlib/stats-base-dists-invgamma-mode","@stdlib/stats/base/dists/invgamma/pdf":"@stdlib/stats-base-dists-invgamma-pdf","@stdlib/stats/base/dists/invgamma/quantile":"@stdlib/stats-base-dists-invgamma-quantile","@stdlib/stats/base/dists/invgamma/skewness":"@stdlib/stats-base-dists-invgamma-skewness","@stdlib/stats/base/dists/invgamma/stdev":"@stdlib/stats-base-dists-invgamma-stdev","@stdlib/stats/base/dists/invgamma/variance":"@stdlib/stats-base-dists-invgamma-variance","@stdlib/stats/base/dists/kumaraswamy/cdf":"@stdlib/stats-base-dists-kumaraswamy-cdf","@stdlib/stats/base/dists/kumaraswamy/ctor":"@stdlib/stats-base-dists-kumaraswamy-ctor","@stdlib/stats/base/dists/kumaraswamy/kurtosis":"@stdlib/stats-base-dists-kumaraswamy-kurtosis","@stdlib/stats/base/dists/kumaraswamy/logcdf":"@stdlib/stats-base-dists-kumaraswamy-logcdf","@stdlib/stats/base/dists/kumaraswamy/logpdf":"@stdlib/stats-base-dists-kumaraswamy-logpdf","@stdlib/stats/base/dists/kumaraswamy/mean":"@stdlib/stats-base-dists-kumaraswamy-mean","@stdlib/stats/base/dists/kumaraswamy/median":"@stdlib/stats-base-dists-kumaraswamy-median","@stdlib/stats/base/dists/kumaraswamy/mode":"@stdlib/stats-base-dists-kumaraswamy-mode","@stdlib/stats/base/dists/kumaraswamy/pdf":"@stdlib/stats-base-dists-kumaraswamy-pdf","@stdlib/stats/base/dists/kumaraswamy/quantile":"@stdlib/stats-base-dists-kumaraswamy-quantile","@stdlib/stats/base/dists/kumaraswamy/skewness":"@stdlib/stats-base-dists-kumaraswamy-skewness","@stdlib/stats/base/dists/kumaraswamy/stdev":"@stdlib/stats-base-dists-kumaraswamy-stdev","@stdlib/stats/base/dists/kumaraswamy/variance":"@stdlib/stats-base-dists-kumaraswamy-variance","@stdlib/stats/base/dists/laplace/cdf":"@stdlib/stats-base-dists-laplace-cdf","@stdlib/stats/base/dists/laplace/entropy":"@stdlib/stats-base-dists-laplace-entropy","@stdlib/stats/base/dists/laplace/kurtosis":"@stdlib/stats-base-dists-laplace-kurtosis","@stdlib/stats/base/dists/laplace/ctor":"@stdlib/stats-base-dists-laplace-ctor","@stdlib/stats/base/dists/laplace/logcdf":"@stdlib/stats-base-dists-laplace-logcdf","@stdlib/stats/base/dists/laplace/logpdf":"@stdlib/stats-base-dists-laplace-logpdf","@stdlib/stats/base/dists/laplace/mean":"@stdlib/stats-base-dists-laplace-mean","@stdlib/stats/base/dists/laplace/median":"@stdlib/stats-base-dists-laplace-median","@stdlib/stats/base/dists/laplace/mgf":"@stdlib/stats-base-dists-laplace-mgf","@stdlib/stats/base/dists/laplace/mode":"@stdlib/stats-base-dists-laplace-mode","@stdlib/stats/base/dists/laplace/pdf":"@stdlib/stats-base-dists-laplace-pdf","@stdlib/stats/base/dists/laplace/quantile":"@stdlib/stats-base-dists-laplace-quantile","@stdlib/stats/base/dists/laplace/skewness":"@stdlib/stats-base-dists-laplace-skewness","@stdlib/stats/base/dists/laplace/stdev":"@stdlib/stats-base-dists-laplace-stdev","@stdlib/stats/base/dists/laplace/variance":"@stdlib/stats-base-dists-laplace-variance","@stdlib/stats/base/dists/levy/cdf":"@stdlib/stats-base-dists-levy-cdf","@stdlib/stats/base/dists/levy/entropy":"@stdlib/stats-base-dists-levy-entropy","@stdlib/stats/base/dists/levy/ctor":"@stdlib/stats-base-dists-levy-ctor","@stdlib/stats/base/dists/levy/logcdf":"@stdlib/stats-base-dists-levy-logcdf","@stdlib/stats/base/dists/levy/logpdf":"@stdlib/stats-base-dists-levy-logpdf","@stdlib/stats/base/dists/levy/mean":"@stdlib/stats-base-dists-levy-mean","@stdlib/stats/base/dists/levy/median":"@stdlib/stats-base-dists-levy-median","@stdlib/stats/base/dists/levy/mode":"@stdlib/stats-base-dists-levy-mode","@stdlib/stats/base/dists/levy/pdf":"@stdlib/stats-base-dists-levy-pdf","@stdlib/stats/base/dists/levy/quantile":"@stdlib/stats-base-dists-levy-quantile","@stdlib/stats/base/dists/levy/stdev":"@stdlib/stats-base-dists-levy-stdev","@stdlib/stats/base/dists/levy/variance":"@stdlib/stats-base-dists-levy-variance","@stdlib/stats/base/dists/logistic/cdf":"@stdlib/stats-base-dists-logistic-cdf","@stdlib/stats/base/dists/logistic/entropy":"@stdlib/stats-base-dists-logistic-entropy","@stdlib/stats/base/dists/logistic/kurtosis":"@stdlib/stats-base-dists-logistic-kurtosis","@stdlib/stats/base/dists/logistic/logcdf":"@stdlib/stats-base-dists-logistic-logcdf","@stdlib/stats/base/dists/logistic/ctor":"@stdlib/stats-base-dists-logistic-ctor","@stdlib/stats/base/dists/logistic/logpdf":"@stdlib/stats-base-dists-logistic-logpdf","@stdlib/stats/base/dists/logistic/mean":"@stdlib/stats-base-dists-logistic-mean","@stdlib/stats/base/dists/logistic/median":"@stdlib/stats-base-dists-logistic-median","@stdlib/stats/base/dists/logistic/mgf":"@stdlib/stats-base-dists-logistic-mgf","@stdlib/stats/base/dists/logistic/mode":"@stdlib/stats-base-dists-logistic-mode","@stdlib/stats/base/dists/logistic/pdf":"@stdlib/stats-base-dists-logistic-pdf","@stdlib/stats/base/dists/logistic/quantile":"@stdlib/stats-base-dists-logistic-quantile","@stdlib/stats/base/dists/logistic/skewness":"@stdlib/stats-base-dists-logistic-skewness","@stdlib/stats/base/dists/logistic/stdev":"@stdlib/stats-base-dists-logistic-stdev","@stdlib/stats/base/dists/logistic/variance":"@stdlib/stats-base-dists-logistic-variance","@stdlib/stats/base/dists/lognormal/cdf":"@stdlib/stats-base-dists-lognormal-cdf","@stdlib/stats/base/dists/lognormal/entropy":"@stdlib/stats-base-dists-lognormal-entropy","@stdlib/stats/base/dists/lognormal/kurtosis":"@stdlib/stats-base-dists-lognormal-kurtosis","@stdlib/stats/base/dists/lognormal/ctor":"@stdlib/stats-base-dists-lognormal-ctor","@stdlib/stats/base/dists/lognormal/logcdf":"@stdlib/stats-base-dists-lognormal-logcdf","@stdlib/stats/base/dists/lognormal/logpdf":"@stdlib/stats-base-dists-lognormal-logpdf","@stdlib/stats/base/dists/lognormal/mean":"@stdlib/stats-base-dists-lognormal-mean","@stdlib/stats/base/dists/lognormal/median":"@stdlib/stats-base-dists-lognormal-median","@stdlib/stats/base/dists/lognormal/mode":"@stdlib/stats-base-dists-lognormal-mode","@stdlib/stats/base/dists/lognormal/pdf":"@stdlib/stats-base-dists-lognormal-pdf","@stdlib/stats/base/dists/lognormal/quantile":"@stdlib/stats-base-dists-lognormal-quantile","@stdlib/stats/base/dists/lognormal/skewness":"@stdlib/stats-base-dists-lognormal-skewness","@stdlib/stats/base/dists/lognormal/stdev":"@stdlib/stats-base-dists-lognormal-stdev","@stdlib/stats/base/dists/lognormal/variance":"@stdlib/stats-base-dists-lognormal-variance","@stdlib/stats/base/dists/negative-binomial/cdf":"@stdlib/stats-base-dists-negative-binomial-cdf","@stdlib/stats/base/dists/negative-binomial/kurtosis":"@stdlib/stats-base-dists-negative-binomial-kurtosis","@stdlib/stats/base/dists/negative-binomial/logpmf":"@stdlib/stats-base-dists-negative-binomial-logpmf","@stdlib/stats/base/dists/negative-binomial/mean":"@stdlib/stats-base-dists-negative-binomial-mean","@stdlib/stats/base/dists/negative-binomial/mgf":"@stdlib/stats-base-dists-negative-binomial-mgf","@stdlib/stats/base/dists/negative-binomial/mode":"@stdlib/stats-base-dists-negative-binomial-mode","@stdlib/stats/base/dists/negative-binomial/ctor":"@stdlib/stats-base-dists-negative-binomial-ctor","@stdlib/stats/base/dists/negative-binomial/pmf":"@stdlib/stats-base-dists-negative-binomial-pmf","@stdlib/stats/base/dists/negative-binomial/quantile":"@stdlib/stats-base-dists-negative-binomial-quantile","@stdlib/stats/base/dists/negative-binomial/skewness":"@stdlib/stats-base-dists-negative-binomial-skewness","@stdlib/stats/base/dists/negative-binomial/stdev":"@stdlib/stats-base-dists-negative-binomial-stdev","@stdlib/stats/base/dists/negative-binomial/variance":"@stdlib/stats-base-dists-negative-binomial-variance","@stdlib/stats/base/dists/normal/cdf":"@stdlib/stats-base-dists-normal-cdf","@stdlib/stats/base/dists/normal/entropy":"@stdlib/stats-base-dists-normal-entropy","@stdlib/stats/base/dists/normal/kurtosis":"@stdlib/stats-base-dists-normal-kurtosis","@stdlib/stats/base/dists/normal/logcdf":"@stdlib/stats-base-dists-normal-logcdf","@stdlib/stats/base/dists/normal/logpdf":"@stdlib/stats-base-dists-normal-logpdf","@stdlib/stats/base/dists/normal/mean":"@stdlib/stats-base-dists-normal-mean","@stdlib/stats/base/dists/normal/median":"@stdlib/stats-base-dists-normal-median","@stdlib/stats/base/dists/normal/mgf":"@stdlib/stats-base-dists-normal-mgf","@stdlib/stats/base/dists/normal/mode":"@stdlib/stats-base-dists-normal-mode","@stdlib/stats/base/dists/normal/ctor":"@stdlib/stats-base-dists-normal-ctor","@stdlib/stats/base/dists/normal/pdf":"@stdlib/stats-base-dists-normal-pdf","@stdlib/stats/base/dists/normal/quantile":"@stdlib/stats-base-dists-normal-quantile","@stdlib/stats/base/dists/normal/skewness":"@stdlib/stats-base-dists-normal-skewness","@stdlib/stats/base/dists/normal/stdev":"@stdlib/stats-base-dists-normal-stdev","@stdlib/stats/base/dists/normal/variance":"@stdlib/stats-base-dists-normal-variance","@stdlib/stats/base/dists/pareto-type1/cdf":"@stdlib/stats-base-dists-pareto-type1-cdf","@stdlib/stats/base/dists/pareto-type1/entropy":"@stdlib/stats-base-dists-pareto-type1-entropy","@stdlib/stats/base/dists/pareto-type1/kurtosis":"@stdlib/stats-base-dists-pareto-type1-kurtosis","@stdlib/stats/base/dists/pareto-type1/logcdf":"@stdlib/stats-base-dists-pareto-type1-logcdf","@stdlib/stats/base/dists/pareto-type1/logpdf":"@stdlib/stats-base-dists-pareto-type1-logpdf","@stdlib/stats/base/dists/pareto-type1/mean":"@stdlib/stats-base-dists-pareto-type1-mean","@stdlib/stats/base/dists/pareto-type1/median":"@stdlib/stats-base-dists-pareto-type1-median","@stdlib/stats/base/dists/pareto-type1/mode":"@stdlib/stats-base-dists-pareto-type1-mode","@stdlib/stats/base/dists/pareto-type1/ctor":"@stdlib/stats-base-dists-pareto-type1-ctor","@stdlib/stats/base/dists/pareto-type1/pdf":"@stdlib/stats-base-dists-pareto-type1-pdf","@stdlib/stats/base/dists/pareto-type1/quantile":"@stdlib/stats-base-dists-pareto-type1-quantile","@stdlib/stats/base/dists/pareto-type1/skewness":"@stdlib/stats-base-dists-pareto-type1-skewness","@stdlib/stats/base/dists/pareto-type1/stdev":"@stdlib/stats-base-dists-pareto-type1-stdev","@stdlib/stats/base/dists/pareto-type1/variance":"@stdlib/stats-base-dists-pareto-type1-variance","@stdlib/stats/base/dists/poisson/cdf":"@stdlib/stats-base-dists-poisson-cdf","@stdlib/stats/base/dists/poisson/entropy":"@stdlib/stats-base-dists-poisson-entropy","@stdlib/stats/base/dists/poisson/kurtosis":"@stdlib/stats-base-dists-poisson-kurtosis","@stdlib/stats/base/dists/poisson/logpmf":"@stdlib/stats-base-dists-poisson-logpmf","@stdlib/stats/base/dists/poisson/mean":"@stdlib/stats-base-dists-poisson-mean","@stdlib/stats/base/dists/poisson/median":"@stdlib/stats-base-dists-poisson-median","@stdlib/stats/base/dists/poisson/mgf":"@stdlib/stats-base-dists-poisson-mgf","@stdlib/stats/base/dists/poisson/mode":"@stdlib/stats-base-dists-poisson-mode","@stdlib/stats/base/dists/poisson/pmf":"@stdlib/stats-base-dists-poisson-pmf","@stdlib/stats/base/dists/poisson/ctor":"@stdlib/stats-base-dists-poisson-ctor","@stdlib/stats/base/dists/poisson/quantile":"@stdlib/stats-base-dists-poisson-quantile","@stdlib/stats/base/dists/poisson/skewness":"@stdlib/stats-base-dists-poisson-skewness","@stdlib/stats/base/dists/poisson/stdev":"@stdlib/stats-base-dists-poisson-stdev","@stdlib/stats/base/dists/poisson/variance":"@stdlib/stats-base-dists-poisson-variance","@stdlib/stats/base/dists/rayleigh/cdf":"@stdlib/stats-base-dists-rayleigh-cdf","@stdlib/stats/base/dists/rayleigh/entropy":"@stdlib/stats-base-dists-rayleigh-entropy","@stdlib/stats/base/dists/rayleigh/kurtosis":"@stdlib/stats-base-dists-rayleigh-kurtosis","@stdlib/stats/base/dists/rayleigh/logcdf":"@stdlib/stats-base-dists-rayleigh-logcdf","@stdlib/stats/base/dists/rayleigh/logpdf":"@stdlib/stats-base-dists-rayleigh-logpdf","@stdlib/stats/base/dists/rayleigh/mean":"@stdlib/stats-base-dists-rayleigh-mean","@stdlib/stats/base/dists/rayleigh/median":"@stdlib/stats-base-dists-rayleigh-median","@stdlib/stats/base/dists/rayleigh/mgf":"@stdlib/stats-base-dists-rayleigh-mgf","@stdlib/stats/base/dists/rayleigh/mode":"@stdlib/stats-base-dists-rayleigh-mode","@stdlib/stats/base/dists/rayleigh/pdf":"@stdlib/stats-base-dists-rayleigh-pdf","@stdlib/stats/base/dists/rayleigh/quantile":"@stdlib/stats-base-dists-rayleigh-quantile","@stdlib/stats/base/dists/rayleigh/ctor":"@stdlib/stats-base-dists-rayleigh-ctor","@stdlib/stats/base/dists/rayleigh/skewness":"@stdlib/stats-base-dists-rayleigh-skewness","@stdlib/stats/base/dists/rayleigh/stdev":"@stdlib/stats-base-dists-rayleigh-stdev","@stdlib/stats/base/dists/rayleigh/variance":"@stdlib/stats-base-dists-rayleigh-variance","@stdlib/stats/base/dists/signrank/cdf":"@stdlib/stats-base-dists-signrank-cdf","@stdlib/stats/base/dists/signrank/pdf":"@stdlib/stats-base-dists-signrank-pdf","@stdlib/stats/base/dists/signrank/quantile":"@stdlib/stats-base-dists-signrank-quantile","@stdlib/stats/base/dists/studentized-range/cdf":"@stdlib/stats-base-dists-studentized-range-cdf","@stdlib/stats/base/dists/studentized-range/quantile":"@stdlib/stats-base-dists-studentized-range-quantile","@stdlib/stats/base/dists/t/cdf":"@stdlib/stats-base-dists-t-cdf","@stdlib/stats/base/dists/t/entropy":"@stdlib/stats-base-dists-t-entropy","@stdlib/stats/base/dists/t/kurtosis":"@stdlib/stats-base-dists-t-kurtosis","@stdlib/stats/base/dists/t/logcdf":"@stdlib/stats-base-dists-t-logcdf","@stdlib/stats/base/dists/t/logpdf":"@stdlib/stats-base-dists-t-logpdf","@stdlib/stats/base/dists/t/mean":"@stdlib/stats-base-dists-t-mean","@stdlib/stats/base/dists/t/median":"@stdlib/stats-base-dists-t-median","@stdlib/stats/base/dists/t/mode":"@stdlib/stats-base-dists-t-mode","@stdlib/stats/base/dists/t/pdf":"@stdlib/stats-base-dists-t-pdf","@stdlib/stats/base/dists/t/quantile":"@stdlib/stats-base-dists-t-quantile","@stdlib/stats/base/dists/t/skewness":"@stdlib/stats-base-dists-t-skewness","@stdlib/stats/base/dists/t/stdev":"@stdlib/stats-base-dists-t-stdev","@stdlib/stats/base/dists/t/ctor":"@stdlib/stats-base-dists-t-ctor","@stdlib/stats/base/dists/t/variance":"@stdlib/stats-base-dists-t-variance","@stdlib/stats/base/dists/triangular/cdf":"@stdlib/stats-base-dists-triangular-cdf","@stdlib/stats/base/dists/triangular/entropy":"@stdlib/stats-base-dists-triangular-entropy","@stdlib/stats/base/dists/triangular/kurtosis":"@stdlib/stats-base-dists-triangular-kurtosis","@stdlib/stats/base/dists/triangular/logcdf":"@stdlib/stats-base-dists-triangular-logcdf","@stdlib/stats/base/dists/triangular/logpdf":"@stdlib/stats-base-dists-triangular-logpdf","@stdlib/stats/base/dists/triangular/mean":"@stdlib/stats-base-dists-triangular-mean","@stdlib/stats/base/dists/triangular/median":"@stdlib/stats-base-dists-triangular-median","@stdlib/stats/base/dists/triangular/mgf":"@stdlib/stats-base-dists-triangular-mgf","@stdlib/stats/base/dists/triangular/mode":"@stdlib/stats-base-dists-triangular-mode","@stdlib/stats/base/dists/triangular/pdf":"@stdlib/stats-base-dists-triangular-pdf","@stdlib/stats/base/dists/triangular/quantile":"@stdlib/stats-base-dists-triangular-quantile","@stdlib/stats/base/dists/triangular/skewness":"@stdlib/stats-base-dists-triangular-skewness","@stdlib/stats/base/dists/triangular/stdev":"@stdlib/stats-base-dists-triangular-stdev","@stdlib/stats/base/dists/triangular/ctor":"@stdlib/stats-base-dists-triangular-ctor","@stdlib/stats/base/dists/triangular/variance":"@stdlib/stats-base-dists-triangular-variance","@stdlib/stats/base/dists/truncated-normal/pdf":"@stdlib/stats-base-dists-truncated-normal-pdf","@stdlib/stats/base/dists/uniform/cdf":"@stdlib/stats-base-dists-uniform-cdf","@stdlib/stats/base/dists/uniform/entropy":"@stdlib/stats-base-dists-uniform-entropy","@stdlib/stats/base/dists/uniform/kurtosis":"@stdlib/stats-base-dists-uniform-kurtosis","@stdlib/stats/base/dists/uniform/logcdf":"@stdlib/stats-base-dists-uniform-logcdf","@stdlib/stats/base/dists/uniform/logpdf":"@stdlib/stats-base-dists-uniform-logpdf","@stdlib/stats/base/dists/uniform/mean":"@stdlib/stats-base-dists-uniform-mean","@stdlib/stats/base/dists/uniform/median":"@stdlib/stats-base-dists-uniform-median","@stdlib/stats/base/dists/uniform/mgf":"@stdlib/stats-base-dists-uniform-mgf","@stdlib/stats/base/dists/uniform/pdf":"@stdlib/stats-base-dists-uniform-pdf","@stdlib/stats/base/dists/uniform/quantile":"@stdlib/stats-base-dists-uniform-quantile","@stdlib/stats/base/dists/uniform/skewness":"@stdlib/stats-base-dists-uniform-skewness","@stdlib/stats/base/dists/uniform/stdev":"@stdlib/stats-base-dists-uniform-stdev","@stdlib/stats/base/dists/uniform/ctor":"@stdlib/stats-base-dists-uniform-ctor","@stdlib/stats/base/dists/uniform/variance":"@stdlib/stats-base-dists-uniform-variance","@stdlib/stats/base/dists/weibull/cdf":"@stdlib/stats-base-dists-weibull-cdf","@stdlib/stats/base/dists/weibull/entropy":"@stdlib/stats-base-dists-weibull-entropy","@stdlib/stats/base/dists/weibull/kurtosis":"@stdlib/stats-base-dists-weibull-kurtosis","@stdlib/stats/base/dists/weibull/logcdf":"@stdlib/stats-base-dists-weibull-logcdf","@stdlib/stats/base/dists/weibull/logpdf":"@stdlib/stats-base-dists-weibull-logpdf","@stdlib/stats/base/dists/weibull/mean":"@stdlib/stats-base-dists-weibull-mean","@stdlib/stats/base/dists/weibull/median":"@stdlib/stats-base-dists-weibull-median","@stdlib/stats/base/dists/weibull/mgf":"@stdlib/stats-base-dists-weibull-mgf","@stdlib/stats/base/dists/weibull/mode":"@stdlib/stats-base-dists-weibull-mode","@stdlib/stats/base/dists/weibull/pdf":"@stdlib/stats-base-dists-weibull-pdf","@stdlib/stats/base/dists/weibull/quantile":"@stdlib/stats-base-dists-weibull-quantile","@stdlib/stats/base/dists/weibull/skewness":"@stdlib/stats-base-dists-weibull-skewness","@stdlib/stats/base/dists/weibull/stdev":"@stdlib/stats-base-dists-weibull-stdev","@stdlib/stats/base/dists/weibull/variance":"@stdlib/stats-base-dists-weibull-variance","@stdlib/stats/base/dists/weibull/ctor":"@stdlib/stats-base-dists-weibull-ctor","@stdlib/math/base/special/ellipe":"@stdlib/math-base-special-ellipe","@stdlib/math/base/special/ellipj":"@stdlib/math-base-special-ellipj","@stdlib/math/base/special/ellipk":"@stdlib/math-base-special-ellipk","@stdlib/string/base/ends-with":"@stdlib/string-base-ends-with","@stdlib/math/base/utils/float64-epsilon-difference":"@stdlib/math-base-utils-float64-epsilon-difference","@stdlib/math/base/special/erf":"@stdlib/math-base-special-erf","@stdlib/math/base/special/erfc":"@stdlib/math-base-special-erfc","@stdlib/math/base/special/erfcinv":"@stdlib/math-base-special-erfcinv","@stdlib/math/base/special/erfcx":"@stdlib/math-base-special-erfcx","@stdlib/math/base/special/erfinv":"@stdlib/math-base-special-erfinv","@stdlib/math/base/special/dirichlet-eta":"@stdlib/math-base-special-dirichlet-eta","@stdlib/math/base/tools/evalpoly":"@stdlib/math-base-tools-evalpoly","@stdlib/math/base/tools/evalrational":"@stdlib/math-base-tools-evalrational","@stdlib/math/base/special/exp":"@stdlib/math-base-special-exp","@stdlib/math/base/special/exp2":"@stdlib/math-base-special-exp2","@stdlib/math/base/special/exp10":"@stdlib/math-base-special-exp10","@stdlib/math/base/special/expit":"@stdlib/math-base-special-expit","@stdlib/math/base/special/expm1":"@stdlib/math-base-special-expm1","@stdlib/math/base/special/expm1rel":"@stdlib/math-base-special-expm1rel","@stdlib/number/float64/base/exponent":"@stdlib/number-float64-base-exponent","@stdlib/number/float32/base/exponent":"@stdlib/number-float32-base-exponent","@stdlib/math/base/special/factorial":"@stdlib/math-base-special-factorial","@stdlib/math/base/special/factorial2":"@stdlib/math-base-special-factorial2","@stdlib/math/base/special/factorialln":"@stdlib/math-base-special-factorialln","@stdlib/math/base/special/falling-factorial":"@stdlib/math-base-special-falling-factorial","@stdlib/math/base/special/fibonacci":"@stdlib/math-base-special-fibonacci","@stdlib/math/base/special/fibonacci-index":"@stdlib/math-base-special-fibonacci-index","@stdlib/math/base/tools/fibpoly":"@stdlib/math-base-tools-fibpoly","@stdlib/string/base/first-code-point":"@stdlib/string-base-first-code-point","@stdlib/string/base/first":"@stdlib/string-base-first","@stdlib/string/base/first-grapheme-cluster":"@stdlib/string-base-first-grapheme-cluster","@stdlib/math/base/special/flipsign":"@stdlib/math-base-special-flipsign","@stdlib/math/base/special/flipsignf":"@stdlib/math-base-special-flipsignf","@stdlib/number/float32/base/to-int32":"@stdlib/number-float32-base-to-int32","@stdlib/number/float32/base/to-uint32":"@stdlib/number-float32-base-to-uint32","@stdlib/number/float64/base/to-float32":"@stdlib/number-float64-base-to-float32","@stdlib/number/float64/base/to-int32":"@stdlib/number-float64-base-to-int32","@stdlib/number/float64/base/to-int64-bytes":"@stdlib/number-float64-base-to-int64-bytes","@stdlib/number/float64/base/to-uint32":"@stdlib/number-float64-base-to-uint32","@stdlib/math/base/special/floor":"@stdlib/math-base-special-floor","@stdlib/math/base/special/floor2":"@stdlib/math-base-special-floor2","@stdlib/math/base/special/floor10":"@stdlib/math-base-special-floor10","@stdlib/math/base/special/floorb":"@stdlib/math-base-special-floorb","@stdlib/math/base/special/floorf":"@stdlib/math-base-special-floorf","@stdlib/math/base/special/floorn":"@stdlib/math-base-special-floorn","@stdlib/math/base/special/floorsd":"@stdlib/math-base-special-floorsd","@stdlib/string/base/for-each":"@stdlib/string-base-for-each","@stdlib/string/base/for-each-code-point":"@stdlib/string-base-for-each-code-point","@stdlib/string/base/for-each-code-point-right":"@stdlib/string-base-for-each-code-point-right","@stdlib/string/base/for-each-grapheme-cluster":"@stdlib/string-base-for-each-grapheme-cluster","@stdlib/string/base/for-each-right":"@stdlib/string-base-for-each-right","@stdlib/string/base/format-interpolate":"@stdlib/string-base-format-interpolate","@stdlib/string/base/format-tokenize":"@stdlib/string-base-format-tokenize","@stdlib/math/base/special/fresnel":"@stdlib/math-base-special-fresnel","@stdlib/math/base/special/fresnelc":"@stdlib/math-base-special-fresnelc","@stdlib/math/base/special/fresnels":"@stdlib/math-base-special-fresnels","@stdlib/math/base/special/frexp":"@stdlib/math-base-special-frexp","@stdlib/number/float64/base/from-binary-string":"@stdlib/number-float64-base-from-binary-string","@stdlib/number/float32/base/from-binary-string":"@stdlib/number-float32-base-from-binary-string","@stdlib/number/uint8/base/from-binary-string":"@stdlib/number-uint8-base-from-binary-string","@stdlib/number/uint16/base/from-binary-string":"@stdlib/number-uint16-base-from-binary-string","@stdlib/number/uint32/base/from-binary-string":"@stdlib/number-uint32-base-from-binary-string","@stdlib/number/float64/base/from-int64-bytes":"@stdlib/number-float64-base-from-int64-bytes","@stdlib/number/float32/base/from-word":"@stdlib/number-float32-base-from-word","@stdlib/number/float64/base/from-words":"@stdlib/number-float64-base-from-words","@stdlib/math/base/special/gamma":"@stdlib/math-base-special-gamma","@stdlib/math/base/special/gamma1pm1":"@stdlib/math-base-special-gamma1pm1","@stdlib/math/base/special/gamma-delta-ratio":"@stdlib/math-base-special-gamma-delta-ratio","@stdlib/math/base/special/gammainc":"@stdlib/math-base-special-gammainc","@stdlib/math/base/special/gammaincinv":"@stdlib/math-base-special-gammaincinv","@stdlib/math/base/special/gamma-lanczos-sum":"@stdlib/math-base-special-gamma-lanczos-sum","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":"@stdlib/math-base-special-gamma-lanczos-sum-expg-scaled","@stdlib/math/base/special/gammaln":"@stdlib/math-base-special-gammaln","@stdlib/math/base/special/gammasgn":"@stdlib/math-base-special-gammasgn","@stdlib/math/base/special/gcd":"@stdlib/math-base-special-gcd","@stdlib/number/float64/base/get-high-word":"@stdlib/number-float64-base-get-high-word","@stdlib/number/float64/base/get-low-word":"@stdlib/number-float64-base-get-low-word","@stdlib/math/base/special/hacovercos":"@stdlib/math-base-special-hacovercos","@stdlib/math/base/special/hacoversin":"@stdlib/math-base-special-hacoversin","@stdlib/math/base/special/havercos":"@stdlib/math-base-special-havercos","@stdlib/math/base/special/haversin":"@stdlib/math-base-special-haversin","@stdlib/string/base/headercase":"@stdlib/string-base-headercase","@stdlib/math/base/special/heaviside":"@stdlib/math-base-special-heaviside","@stdlib/math/base/tools/hermitepoly":"@stdlib/math-base-tools-hermitepoly","@stdlib/math/base/special/hypot":"@stdlib/math-base-special-hypot","@stdlib/math/base/special/hypotf":"@stdlib/math-base-special-hypotf","@stdlib/math/base/special/identity":"@stdlib/math-base-special-identity","@stdlib/math/base/special/identityf":"@stdlib/math-base-special-identityf","@stdlib/math/base/ops/imul":"@stdlib/math-base-ops-imul","@stdlib/math/base/ops/imuldw":"@stdlib/math-base-ops-imuldw","@stdlib/slice/base/int2slice":"@stdlib/slice-base-int2slice","@stdlib/number/int32/base/to-uint32":"@stdlib/number-int32-base-to-uint32","@stdlib/math/base/special/inv":"@stdlib/math-base-special-inv","@stdlib/string/base/invcase":"@stdlib/string-base-invcase","@stdlib/math/base/special/invf":"@stdlib/math-base-special-invf","@stdlib/math/base/assert/is-composite":"@stdlib/math-base-assert-is-composite","@stdlib/math/base/assert/is-coprime":"@stdlib/math-base-assert-is-coprime","@stdlib/math/base/assert/is-even":"@stdlib/math-base-assert-is-even","@stdlib/math/base/assert/int32-is-even":"@stdlib/math-base-assert-int32-is-even","@stdlib/math/base/assert/is-finite":"@stdlib/math-base-assert-is-finite","@stdlib/math/base/assert/is-finitef":"@stdlib/math-base-assert-is-finitef","@stdlib/math/base/assert/is-infinite":"@stdlib/math-base-assert-is-infinite","@stdlib/math/base/assert/is-infinitef":"@stdlib/math-base-assert-is-infinitef","@stdlib/math/base/assert/is-integer":"@stdlib/math-base-assert-is-integer","@stdlib/math/base/assert/is-nan":"@stdlib/math-base-assert-is-nan","@stdlib/math/base/assert/is-nanf":"@stdlib/math-base-assert-is-nanf","@stdlib/math/base/assert/is-negative-finite":"@stdlib/math-base-assert-is-negative-finite","@stdlib/math/base/assert/is-negative-integer":"@stdlib/math-base-assert-is-negative-integer","@stdlib/math/base/assert/is-negative-zero":"@stdlib/math-base-assert-is-negative-zero","@stdlib/math/base/assert/is-negative-zerof":"@stdlib/math-base-assert-is-negative-zerof","@stdlib/math/base/assert/is-nonnegative-finite":"@stdlib/math-base-assert-is-nonnegative-finite","@stdlib/math/base/assert/is-nonnegative-integer":"@stdlib/math-base-assert-is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-finite":"@stdlib/math-base-assert-is-nonpositive-finite","@stdlib/math/base/assert/is-nonpositive-integer":"@stdlib/math-base-assert-is-nonpositive-integer","@stdlib/math/base/assert/is-odd":"@stdlib/math-base-assert-is-odd","@stdlib/math/base/assert/int32-is-odd":"@stdlib/math-base-assert-int32-is-odd","@stdlib/math/base/assert/is-positive-finite":"@stdlib/math-base-assert-is-positive-finite","@stdlib/math/base/assert/is-positive-integer":"@stdlib/math-base-assert-is-positive-integer","@stdlib/math/base/assert/is-positive-zero":"@stdlib/math-base-assert-is-positive-zero","@stdlib/math/base/assert/is-positive-zerof":"@stdlib/math-base-assert-is-positive-zerof","@stdlib/math/base/assert/uint32-is-pow2":"@stdlib/math-base-assert-uint32-is-pow2","@stdlib/math/base/assert/is-prime":"@stdlib/math-base-assert-is-prime","@stdlib/math/base/assert/is-probability":"@stdlib/math-base-assert-is-probability","@stdlib/math/base/assert/is-safe-integer":"@stdlib/math-base-assert-is-safe-integer","@stdlib/string/base/kebabcase":"@stdlib/string-base-kebabcase","@stdlib/math/base/special/kernel-betainc":"@stdlib/math-base-special-kernel-betainc","@stdlib/math/base/special/kernel-betaincinv":"@stdlib/math-base-special-kernel-betaincinv","@stdlib/math/base/special/kernel-cos":"@stdlib/math-base-special-kernel-cos","@stdlib/math/base/special/kernel-log1p":"@stdlib/math-base-special-kernel-log1p","@stdlib/math/base/special/kernel-sin":"@stdlib/math-base-special-kernel-sin","@stdlib/math/base/special/kernel-tan":"@stdlib/math-base-special-kernel-tan","@stdlib/math/base/special/kronecker-delta":"@stdlib/math-base-special-kronecker-delta","@stdlib/math/base/special/kronecker-deltaf":"@stdlib/math-base-special-kronecker-deltaf","@stdlib/math/base/special/labs":"@stdlib/math-base-special-labs","@stdlib/string/base/last":"@stdlib/string-base-last","@stdlib/string/base/last-code-point":"@stdlib/string-base-last-code-point","@stdlib/string/base/last-grapheme-cluster":"@stdlib/string-base-last-grapheme-cluster","@stdlib/math/base/special/lcm":"@stdlib/math-base-special-lcm","@stdlib/math/base/special/ldexp":"@stdlib/math-base-special-ldexp","@stdlib/string/base/left-pad":"@stdlib/string-base-left-pad","@stdlib/string/base/left-trim":"@stdlib/string-base-left-trim","@stdlib/math/base/special/ln":"@stdlib/math-base-special-ln","@stdlib/math/base/special/log":"@stdlib/math-base-special-log","@stdlib/math/base/special/log1mexp":"@stdlib/math-base-special-log1mexp","@stdlib/math/base/special/log1p":"@stdlib/math-base-special-log1p","@stdlib/math/base/special/log1pexp":"@stdlib/math-base-special-log1pexp","@stdlib/math/base/special/log1pmx":"@stdlib/math-base-special-log1pmx","@stdlib/math/base/special/log2":"@stdlib/math-base-special-log2","@stdlib/math/base/special/log10":"@stdlib/math-base-special-log10","@stdlib/math/base/special/logaddexp":"@stdlib/math-base-special-logaddexp","@stdlib/math/base/special/logit":"@stdlib/math-base-special-logit","@stdlib/string/base/lowercase":"@stdlib/string-base-lowercase","@stdlib/math/base/special/lucas":"@stdlib/math-base-special-lucas","@stdlib/math/base/tools/lucaspoly":"@stdlib/math-base-tools-lucaspoly","@stdlib/math/base/special/max":"@stdlib/math-base-special-max","@stdlib/math/base/special/maxabs":"@stdlib/math-base-special-maxabs","@stdlib/math/base/special/maxabsn":"@stdlib/math-base-special-maxabsn","@stdlib/math/base/special/maxn":"@stdlib/math-base-special-maxn","@stdlib/math/base/special/min":"@stdlib/math-base-special-min","@stdlib/math/base/special/minabs":"@stdlib/math-base-special-minabs","@stdlib/math/base/special/minabsn":"@stdlib/math-base-special-minabsn","@stdlib/math/base/special/minmax":"@stdlib/math-base-special-minmax","@stdlib/math/base/special/minmaxabs":"@stdlib/math-base-special-minmaxabs","@stdlib/math/base/special/minmaxabsn":"@stdlib/math-base-special-minmaxabsn","@stdlib/math/base/special/minmaxn":"@stdlib/math-base-special-minmaxn","@stdlib/math/base/special/minn":"@stdlib/math-base-special-minn","@stdlib/math/base/special/modf":"@stdlib/math-base-special-modf","@stdlib/number/float64/base/mul":"@stdlib/number-float64-base-mul","@stdlib/number/float32/base/mul":"@stdlib/number-float32-base-mul","@stdlib/ndarray/base/ctor":"@stdlib/ndarray-base-ctor","@stdlib/ndarray/base/unary":"@stdlib/ndarray-base-unary","@stdlib/ndarray/base/zeros":"@stdlib/ndarray-base-zeros","@stdlib/ndarray/base/zeros-like":"@stdlib/ndarray-base-zeros-like","@stdlib/math/base/special/negafibonacci":"@stdlib/math-base-special-negafibonacci","@stdlib/math/base/special/negalucas":"@stdlib/math-base-special-negalucas","@stdlib/math/base/special/nonfibonacci":"@stdlib/math-base-special-nonfibonacci","@stdlib/number/float64/base/normalize":"@stdlib/number-float64-base-normalize","@stdlib/number/float32/base/normalize":"@stdlib/number-float32-base-normalize","@stdlib/slice/base/normalize-multi-slice":"@stdlib/slice-base-normalize-multi-slice","@stdlib/slice/base/normalize-slice":"@stdlib/slice-base-normalize-slice","@stdlib/math/base/tools/normhermitepoly":"@stdlib/math-base-tools-normhermitepoly","@stdlib/string/base/pascalcase":"@stdlib/string-base-pascalcase","@stdlib/math/base/special/pdiff":"@stdlib/math-base-special-pdiff","@stdlib/math/base/special/pdifff":"@stdlib/math-base-special-pdifff","@stdlib/string/base/percent-encode":"@stdlib/string-base-percent-encode","@stdlib/math/base/special/polygamma":"@stdlib/math-base-special-polygamma","@stdlib/math/base/special/pow":"@stdlib/math-base-special-pow","@stdlib/math/base/special/powm1":"@stdlib/math-base-special-powm1","@stdlib/math/base/special/rad2deg":"@stdlib/math-base-special-rad2deg","@stdlib/math/base/special/rad2degf":"@stdlib/math-base-special-rad2degf","@stdlib/math/base/special/ramp":"@stdlib/math-base-special-ramp","@stdlib/math/base/special/rampf":"@stdlib/math-base-special-rampf","@stdlib/random/base/arcsine":"@stdlib/random-base-arcsine","@stdlib/random/base/bernoulli":"@stdlib/random-base-bernoulli","@stdlib/random/base/beta":"@stdlib/random-base-beta","@stdlib/random/base/betaprime":"@stdlib/random-base-betaprime","@stdlib/random/base/binomial":"@stdlib/random-base-binomial","@stdlib/random/base/box-muller":"@stdlib/random-base-box-muller","@stdlib/random/base/cauchy":"@stdlib/random-base-cauchy","@stdlib/random/base/chi":"@stdlib/random-base-chi","@stdlib/random/base/chisquare":"@stdlib/random-base-chisquare","@stdlib/random/base/cosine":"@stdlib/random-base-cosine","@stdlib/random/base/discrete-uniform":"@stdlib/random-base-discrete-uniform","@stdlib/random/base/erlang":"@stdlib/random-base-erlang","@stdlib/random/base/exponential":"@stdlib/random-base-exponential","@stdlib/random/base/f":"@stdlib/random-base-f","@stdlib/random/base/frechet":"@stdlib/random-base-frechet","@stdlib/random/base/gamma":"@stdlib/random-base-gamma","@stdlib/random/base/geometric":"@stdlib/random-base-geometric","@stdlib/random/base/gumbel":"@stdlib/random-base-gumbel","@stdlib/random/base/hypergeometric":"@stdlib/random-base-hypergeometric","@stdlib/random/base/improved-ziggurat":"@stdlib/random-base-improved-ziggurat","@stdlib/random/base/invgamma":"@stdlib/random-base-invgamma","@stdlib/random/base/kumaraswamy":"@stdlib/random-base-kumaraswamy","@stdlib/random/base/laplace":"@stdlib/random-base-laplace","@stdlib/random/base/levy":"@stdlib/random-base-levy","@stdlib/random/base/logistic":"@stdlib/random-base-logistic","@stdlib/random/base/lognormal":"@stdlib/random-base-lognormal","@stdlib/random/base/minstd":"@stdlib/random-base-minstd","@stdlib/random/base/minstd-shuffle":"@stdlib/random-base-minstd-shuffle","@stdlib/random/base/mt19937":"@stdlib/random-base-mt19937","@stdlib/random/base/negative-binomial":"@stdlib/random-base-negative-binomial","@stdlib/random/base/normal":"@stdlib/random-base-normal","@stdlib/random/base/pareto-type1":"@stdlib/random-base-pareto-type1","@stdlib/random/base/poisson":"@stdlib/random-base-poisson","@stdlib/random/base/randi":"@stdlib/random-base-randi","@stdlib/random/base/randn":"@stdlib/random-base-randn","@stdlib/random/base/randu":"@stdlib/random-base-randu","@stdlib/random/base/rayleigh":"@stdlib/random-base-rayleigh","@stdlib/random/base/t":"@stdlib/random-base-t","@stdlib/random/base/triangular":"@stdlib/random-base-triangular","@stdlib/random/base/uniform":"@stdlib/random-base-uniform","@stdlib/random/base/weibull":"@stdlib/random-base-weibull","@stdlib/math/base/special/rcbrt":"@stdlib/math-base-special-rcbrt","@stdlib/math/base/special/rcbrtf":"@stdlib/math-base-special-rcbrtf","@stdlib/math/base/utils/relative-difference":"@stdlib/math-base-utils-relative-difference","@stdlib/string/base/remove-first":"@stdlib/string-base-remove-first","@stdlib/string/base/remove-first-code-point":"@stdlib/string-base-remove-first-code-point","@stdlib/string/base/remove-first-grapheme-cluster":"@stdlib/string-base-remove-first-grapheme-cluster","@stdlib/string/base/remove-last":"@stdlib/string-base-remove-last","@stdlib/string/base/remove-last-code-point":"@stdlib/string-base-remove-last-code-point","@stdlib/string/base/remove-last-grapheme-cluster":"@stdlib/string-base-remove-last-grapheme-cluster","@stdlib/math/base/special/rempio2":"@stdlib/math-base-special-rempio2","@stdlib/string/base/repeat":"@stdlib/string-base-repeat","@stdlib/string/base/replace":"@stdlib/string-base-replace","@stdlib/string/base/replace-after":"@stdlib/string-base-replace-after","@stdlib/string/base/replace-after-last":"@stdlib/string-base-replace-after-last","@stdlib/string/base/replace-before":"@stdlib/string-base-replace-before","@stdlib/string/base/replace-before-last":"@stdlib/string-base-replace-before-last","@stdlib/string/base/reverse":"@stdlib/string-base-reverse","@stdlib/string/base/reverse-code-points":"@stdlib/string-base-reverse-code-points","@stdlib/string/base/reverse-grapheme-clusters":"@stdlib/string-base-reverse-grapheme-clusters","@stdlib/string/base/right-pad":"@stdlib/string-base-right-pad","@stdlib/string/base/right-trim":"@stdlib/string-base-right-trim","@stdlib/math/base/special/rising-factorial":"@stdlib/math-base-special-rising-factorial","@stdlib/number/uint32/base/rotl":"@stdlib/number-uint32-base-rotl","@stdlib/number/uint32/base/rotr":"@stdlib/number-uint32-base-rotr","@stdlib/math/base/special/round":"@stdlib/math-base-special-round","@stdlib/math/base/special/round2":"@stdlib/math-base-special-round2","@stdlib/math/base/special/round10":"@stdlib/math-base-special-round10","@stdlib/math/base/special/roundb":"@stdlib/math-base-special-roundb","@stdlib/math/base/special/roundn":"@stdlib/math-base-special-roundn","@stdlib/math/base/special/roundsd":"@stdlib/math-base-special-roundsd","@stdlib/math/base/special/rsqrt":"@stdlib/math-base-special-rsqrt","@stdlib/math/base/special/rsqrtf":"@stdlib/math-base-special-rsqrtf","@stdlib/slice/base/sargs2multislice":"@stdlib/slice-base-sargs2multislice","@stdlib/ndarray/base/from-scalar":"@stdlib/ndarray-base-from-scalar","@stdlib/math/base/special/secd":"@stdlib/math-base-special-secd","@stdlib/slice/base/seq2multislice":"@stdlib/slice-base-seq2multislice","@stdlib/slice/base/seq2slice":"@stdlib/slice-base-seq2slice","@stdlib/number/float64/base/set-high-word":"@stdlib/number-float64-base-set-high-word","@stdlib/number/float64/base/set-low-word":"@stdlib/number-float64-base-set-low-word","@stdlib/math/base/special/sici":"@stdlib/math-base-special-sici","@stdlib/number/float64/base/signbit":"@stdlib/number-float64-base-signbit","@stdlib/number/float32/base/signbit":"@stdlib/number-float32-base-signbit","@stdlib/number/float32/base/significand":"@stdlib/number-float32-base-significand","@stdlib/math/base/special/signum":"@stdlib/math-base-special-signum","@stdlib/math/base/special/signumf":"@stdlib/math-base-special-signumf","@stdlib/math/base/special/sin":"@stdlib/math-base-special-sin","@stdlib/math/base/special/sinc":"@stdlib/math-base-special-sinc","@stdlib/math/base/special/sincos":"@stdlib/math-base-special-sincos","@stdlib/math/base/special/sincospi":"@stdlib/math-base-special-sincospi","@stdlib/math/base/special/sinh":"@stdlib/math-base-special-sinh","@stdlib/math/base/special/sinpi":"@stdlib/math-base-special-sinpi","@stdlib/slice/base/slice2seq":"@stdlib/slice-base-slice2seq","@stdlib/slice/base/length":"@stdlib/slice-base-length","@stdlib/slice/base/nonreduced-dimensions":"@stdlib/slice-base-nonreduced-dimensions","@stdlib/slice/base/reduced-dimensions":"@stdlib/slice-base-reduced-dimensions","@stdlib/slice/base/shape":"@stdlib/slice-base-shape","@stdlib/string/base/snakecase":"@stdlib/string-base-snakecase","@stdlib/math/base/special/spence":"@stdlib/math-base-special-spence","@stdlib/math/base/special/sqrt":"@stdlib/math-base-special-sqrt","@stdlib/math/base/special/sqrt1pm1":"@stdlib/math-base-special-sqrt1pm1","@stdlib/math/base/special/sqrtf":"@stdlib/math-base-special-sqrtf","@stdlib/math/base/special/sqrtpi":"@stdlib/math-base-special-sqrtpi","@stdlib/string/base/startcase":"@stdlib/string-base-startcase","@stdlib/string/base/starts-with":"@stdlib/string-base-starts-with","@stdlib/string/base/stickycase":"@stdlib/string-base-stickycase","@stdlib/strided/base/binary":"@stdlib/strided-base-binary","@stdlib/strided/base/binary-dtype-signatures":"@stdlib/strided-base-binary-dtype-signatures","@stdlib/strided/base/binary-signature-callbacks":"@stdlib/strided-base-binary-signature-callbacks","@stdlib/blas/base/ccopy":"@stdlib/blas-base-ccopy","@stdlib/strided/base/cmap":"@stdlib/strided-base-cmap","@stdlib/blas/base/cswap":"@stdlib/blas-base-cswap","@stdlib/stats/base/cumax":"@stdlib/stats-base-cumax","@stdlib/stats/base/cumaxabs":"@stdlib/stats-base-cumaxabs","@stdlib/stats/base/cumin":"@stdlib/stats-base-cumin","@stdlib/stats/base/cuminabs":"@stdlib/stats-base-cuminabs","@stdlib/math/strided/special/dabs":"@stdlib/math-strided-special-dabs","@stdlib/math/strided/special/dabs2":"@stdlib/math-strided-special-dabs2","@stdlib/blas/ext/base/dapx":"@stdlib/blas-ext-base-dapx","@stdlib/blas/ext/base/dapxsum":"@stdlib/blas-ext-base-dapxsum","@stdlib/blas/ext/base/dapxsumkbn":"@stdlib/blas-ext-base-dapxsumkbn","@stdlib/blas/ext/base/dapxsumkbn2":"@stdlib/blas-ext-base-dapxsumkbn2","@stdlib/blas/ext/base/dapxsumors":"@stdlib/blas-ext-base-dapxsumors","@stdlib/blas/ext/base/dapxsumpw":"@stdlib/blas-ext-base-dapxsumpw","@stdlib/blas/base/dasum":"@stdlib/blas-base-dasum","@stdlib/blas/ext/base/dasumpw":"@stdlib/blas-ext-base-dasumpw","@stdlib/blas/base/daxpy":"@stdlib/blas-base-daxpy","@stdlib/math/strided/special/dcbrt":"@stdlib/math-strided-special-dcbrt","@stdlib/math/strided/special/dceil":"@stdlib/math-strided-special-dceil","@stdlib/blas/base/dcopy":"@stdlib/blas-base-dcopy","@stdlib/stats/strided/dcumax":"@stdlib/stats-strided-dcumax","@stdlib/stats/strided/dcumaxabs":"@stdlib/stats-strided-dcumaxabs","@stdlib/stats/base/dcumin":"@stdlib/stats-base-dcumin","@stdlib/stats/strided/dcuminabs":"@stdlib/stats-strided-dcuminabs","@stdlib/blas/ext/base/dcusum":"@stdlib/blas-ext-base-dcusum","@stdlib/blas/ext/base/dcusumkbn":"@stdlib/blas-ext-base-dcusumkbn","@stdlib/blas/ext/base/dcusumkbn2":"@stdlib/blas-ext-base-dcusumkbn2","@stdlib/blas/ext/base/dcusumors":"@stdlib/blas-ext-base-dcusumors","@stdlib/blas/ext/base/dcusumpw":"@stdlib/blas-ext-base-dcusumpw","@stdlib/math/strided/special/ddeg2rad":"@stdlib/math-strided-special-ddeg2rad","@stdlib/blas/base/ddot":"@stdlib/blas-base-ddot","@stdlib/blas/ext/base/dfill":"@stdlib/blas-ext-base-dfill","@stdlib/math/strided/special/dfloor":"@stdlib/math-strided-special-dfloor","@stdlib/math/strided/special/dinv":"@stdlib/math-strided-special-dinv","@stdlib/strided/base/dmap":"@stdlib/strided-base-dmap","@stdlib/strided/base/dmap2":"@stdlib/strided-base-dmap2","@stdlib/stats/strided/dmax":"@stdlib/stats-strided-dmax","@stdlib/stats/strided/dmaxabs":"@stdlib/stats-strided-dmaxabs","@stdlib/stats/strided/dmaxabssorted":"@stdlib/stats-strided-dmaxabssorted","@stdlib/stats/strided/dmaxsorted":"@stdlib/stats-strided-dmaxsorted","@stdlib/stats/base/dmean":"@stdlib/stats-base-dmean","@stdlib/stats/strided/dmeankbn":"@stdlib/stats-strided-dmeankbn","@stdlib/stats/strided/dmeankbn2":"@stdlib/stats-strided-dmeankbn2","@stdlib/stats/strided/dmeanli":"@stdlib/stats-strided-dmeanli","@stdlib/stats/strided/dmeanlipw":"@stdlib/stats-strided-dmeanlipw","@stdlib/stats/strided/dmeanors":"@stdlib/stats-strided-dmeanors","@stdlib/stats/base/dmeanpn":"@stdlib/stats-base-dmeanpn","@stdlib/stats/strided/dmeanpw":"@stdlib/stats-strided-dmeanpw","@stdlib/stats/base/dmeanstdev":"@stdlib/stats-base-dmeanstdev","@stdlib/stats/base/dmeanstdevpn":"@stdlib/stats-base-dmeanstdevpn","@stdlib/stats/base/dmeanvar":"@stdlib/stats-base-dmeanvar","@stdlib/stats/base/dmeanvarpn":"@stdlib/stats-base-dmeanvarpn","@stdlib/stats/strided/dmeanwd":"@stdlib/stats-strided-dmeanwd","@stdlib/stats/strided/dmediansorted":"@stdlib/stats-strided-dmediansorted","@stdlib/stats/strided/dmidrange":"@stdlib/stats-strided-dmidrange","@stdlib/stats/strided/dmin":"@stdlib/stats-strided-dmin","@stdlib/stats/strided/dminabs":"@stdlib/stats-strided-dminabs","@stdlib/stats/strided/dminsorted":"@stdlib/stats-strided-dminsorted","@stdlib/math/strided/special/dmskabs":"@stdlib/math-strided-special-dmskabs","@stdlib/math/strided/special/dmskabs2":"@stdlib/math-strided-special-dmskabs2","@stdlib/math/strided/special/dmskcbrt":"@stdlib/math-strided-special-dmskcbrt","@stdlib/math/strided/special/dmskceil":"@stdlib/math-strided-special-dmskceil","@stdlib/math/strided/special/dmskdeg2rad":"@stdlib/math-strided-special-dmskdeg2rad","@stdlib/math/strided/special/dmskfloor":"@stdlib/math-strided-special-dmskfloor","@stdlib/math/strided/special/dmskinv":"@stdlib/math-strided-special-dmskinv","@stdlib/strided/base/dmskmap":"@stdlib/strided-base-dmskmap","@stdlib/strided/base/dmskmap2":"@stdlib/strided-base-dmskmap2","@stdlib/stats/base/dmskmax":"@stdlib/stats-base-dmskmax","@stdlib/stats/base/dmskmin":"@stdlib/stats-base-dmskmin","@stdlib/math/strided/special/dmskramp":"@stdlib/math-strided-special-dmskramp","@stdlib/stats/base/dmskrange":"@stdlib/stats-base-dmskrange","@stdlib/math/strided/special/dmskrsqrt":"@stdlib/math-strided-special-dmskrsqrt","@stdlib/math/strided/special/dmsksqrt":"@stdlib/math-strided-special-dmsksqrt","@stdlib/math/strided/special/dmsktrunc":"@stdlib/math-strided-special-dmsktrunc","@stdlib/blas/ext/base/dnanasum":"@stdlib/blas-ext-base-dnanasum","@stdlib/blas/ext/base/dnanasumors":"@stdlib/blas-ext-base-dnanasumors","@stdlib/stats/strided/dnanmax":"@stdlib/stats-strided-dnanmax","@stdlib/stats/strided/dnanmaxabs":"@stdlib/stats-strided-dnanmaxabs","@stdlib/stats/strided/dnanmean":"@stdlib/stats-strided-dnanmean","@stdlib/stats/base/dnanmeanors":"@stdlib/stats-base-dnanmeanors","@stdlib/stats/base/dnanmeanpn":"@stdlib/stats-base-dnanmeanpn","@stdlib/stats/base/dnanmeanpw":"@stdlib/stats-base-dnanmeanpw","@stdlib/stats/base/dnanmeanwd":"@stdlib/stats-base-dnanmeanwd","@stdlib/stats/base/dnanmin":"@stdlib/stats-base-dnanmin","@stdlib/stats/base/dnanminabs":"@stdlib/stats-base-dnanminabs","@stdlib/stats/base/dnanmskmax":"@stdlib/stats-base-dnanmskmax","@stdlib/stats/base/dnanmskmin":"@stdlib/stats-base-dnanmskmin","@stdlib/stats/base/dnanmskrange":"@stdlib/stats-base-dnanmskrange","@stdlib/blas/ext/base/dnannsum":"@stdlib/blas-ext-base-dnannsum","@stdlib/blas/ext/base/dnannsumkbn":"@stdlib/blas-ext-base-dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2":"@stdlib/blas-ext-base-dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors":"@stdlib/blas-ext-base-dnannsumors","@stdlib/blas/ext/base/dnannsumpw":"@stdlib/blas-ext-base-dnannsumpw","@stdlib/stats/base/dnanrange":"@stdlib/stats-base-dnanrange","@stdlib/stats/base/dnanstdev":"@stdlib/stats-base-dnanstdev","@stdlib/stats/base/dnanstdevch":"@stdlib/stats-base-dnanstdevch","@stdlib/stats/base/dnanstdevpn":"@stdlib/stats-base-dnanstdevpn","@stdlib/stats/base/dnanstdevtk":"@stdlib/stats-base-dnanstdevtk","@stdlib/stats/base/dnanstdevwd":"@stdlib/stats-base-dnanstdevwd","@stdlib/stats/base/dnanstdevyc":"@stdlib/stats-base-dnanstdevyc","@stdlib/blas/ext/base/dnansum":"@stdlib/blas-ext-base-dnansum","@stdlib/blas/ext/base/dnansumkbn":"@stdlib/blas-ext-base-dnansumkbn","@stdlib/blas/ext/base/dnansumkbn2":"@stdlib/blas-ext-base-dnansumkbn2","@stdlib/blas/ext/base/dnansumors":"@stdlib/blas-ext-base-dnansumors","@stdlib/blas/ext/base/dnansumpw":"@stdlib/blas-ext-base-dnansumpw","@stdlib/stats/base/dnanvariance":"@stdlib/stats-base-dnanvariance","@stdlib/stats/base/dnanvariancech":"@stdlib/stats-base-dnanvariancech","@stdlib/stats/base/dnanvariancepn":"@stdlib/stats-base-dnanvariancepn","@stdlib/stats/base/dnanvariancetk":"@stdlib/stats-base-dnanvariancetk","@stdlib/stats/base/dnanvariancewd":"@stdlib/stats-base-dnanvariancewd","@stdlib/stats/base/dnanvarianceyc":"@stdlib/stats-base-dnanvarianceyc","@stdlib/blas/base/dnrm2":"@stdlib/blas-base-dnrm2","@stdlib/math/strided/special/dramp":"@stdlib/math-strided-special-dramp","@stdlib/stats/base/drange":"@stdlib/stats-base-drange","@stdlib/blas/ext/base/drev":"@stdlib/blas-ext-base-drev","@stdlib/math/strided/special/drsqrt":"@stdlib/math-strided-special-drsqrt","@stdlib/blas/ext/base/dsapxsum":"@stdlib/blas-ext-base-dsapxsum","@stdlib/blas/ext/base/dsapxsumpw":"@stdlib/blas-ext-base-dsapxsumpw","@stdlib/blas/base/dscal":"@stdlib/blas-base-dscal","@stdlib/blas/base/dsdot":"@stdlib/blas-base-dsdot","@stdlib/stats/base/dsem":"@stdlib/stats-base-dsem","@stdlib/stats/base/dsemch":"@stdlib/stats-base-dsemch","@stdlib/stats/base/dsempn":"@stdlib/stats-base-dsempn","@stdlib/stats/base/dsemtk":"@stdlib/stats-base-dsemtk","@stdlib/stats/base/dsemwd":"@stdlib/stats-base-dsemwd","@stdlib/stats/base/dsemyc":"@stdlib/stats-base-dsemyc","@stdlib/stats/base/dsmean":"@stdlib/stats-base-dsmean","@stdlib/stats/base/dsmeanors":"@stdlib/stats-base-dsmeanors","@stdlib/stats/base/dsmeanpn":"@stdlib/stats-base-dsmeanpn","@stdlib/stats/base/dsmeanpw":"@stdlib/stats-base-dsmeanpw","@stdlib/stats/base/dsmeanwd":"@stdlib/stats-base-dsmeanwd","@stdlib/stats/base/dsnanmean":"@stdlib/stats-base-dsnanmean","@stdlib/stats/base/dsnanmeanors":"@stdlib/stats-base-dsnanmeanors","@stdlib/stats/base/dsnanmeanpn":"@stdlib/stats-base-dsnanmeanpn","@stdlib/stats/base/dsnanmeanwd":"@stdlib/stats-base-dsnanmeanwd","@stdlib/blas/ext/base/dsnannsumors":"@stdlib/blas-ext-base-dsnannsumors","@stdlib/blas/ext/base/dsnansum":"@stdlib/blas-ext-base-dsnansum","@stdlib/blas/ext/base/dsnansumors":"@stdlib/blas-ext-base-dsnansumors","@stdlib/blas/ext/base/dsnansumpw":"@stdlib/blas-ext-base-dsnansumpw","@stdlib/blas/ext/base/dsort2hp":"@stdlib/blas-ext-base-dsort2hp","@stdlib/blas/ext/base/dsort2ins":"@stdlib/blas-ext-base-dsort2ins","@stdlib/blas/ext/base/dsort2sh":"@stdlib/blas-ext-base-dsort2sh","@stdlib/blas/ext/base/dsorthp":"@stdlib/blas-ext-base-dsorthp","@stdlib/blas/ext/base/dsortins":"@stdlib/blas-ext-base-dsortins","@stdlib/blas/ext/base/dsortsh":"@stdlib/blas-ext-base-dsortsh","@stdlib/math/strided/special/dsqrt":"@stdlib/math-strided-special-dsqrt","@stdlib/blas/ext/base/dssum":"@stdlib/blas-ext-base-dssum","@stdlib/blas/ext/base/dssumors":"@stdlib/blas-ext-base-dssumors","@stdlib/blas/ext/base/dssumpw":"@stdlib/blas-ext-base-dssumpw","@stdlib/stats/base/dstdev":"@stdlib/stats-base-dstdev","@stdlib/stats/base/dstdevch":"@stdlib/stats-base-dstdevch","@stdlib/stats/base/dstdevpn":"@stdlib/stats-base-dstdevpn","@stdlib/stats/base/dstdevtk":"@stdlib/stats-base-dstdevtk","@stdlib/stats/base/dstdevwd":"@stdlib/stats-base-dstdevwd","@stdlib/stats/base/dstdevyc":"@stdlib/stats-base-dstdevyc","@stdlib/blas/ext/base/dsum":"@stdlib/blas-ext-base-dsum","@stdlib/blas/ext/base/dsumkbn":"@stdlib/blas-ext-base-dsumkbn","@stdlib/blas/ext/base/dsumkbn2":"@stdlib/blas-ext-base-dsumkbn2","@stdlib/blas/ext/base/dsumors":"@stdlib/blas-ext-base-dsumors","@stdlib/blas/ext/base/dsumpw":"@stdlib/blas-ext-base-dsumpw","@stdlib/stats/base/dsvariance":"@stdlib/stats-base-dsvariance","@stdlib/stats/base/dsvariancepn":"@stdlib/stats-base-dsvariancepn","@stdlib/blas/base/dswap":"@stdlib/blas-base-dswap","@stdlib/math/strided/special/dtrunc":"@stdlib/math-strided-special-dtrunc","@stdlib/strided/base/dtype-enum2str":"@stdlib/strided-base-dtype-enum2str","@stdlib/strided/base/dtype-resolve-enum":"@stdlib/strided-base-dtype-resolve-enum","@stdlib/strided/base/dtype-resolve-str":"@stdlib/strided-base-dtype-resolve-str","@stdlib/strided/base/dtype-str2enum":"@stdlib/strided-base-dtype-str2enum","@stdlib/stats/base/dvariance":"@stdlib/stats-base-dvariance","@stdlib/stats/base/dvariancech":"@stdlib/stats-base-dvariancech","@stdlib/stats/base/dvariancepn":"@stdlib/stats-base-dvariancepn","@stdlib/stats/base/dvariancetk":"@stdlib/stats-base-dvariancetk","@stdlib/stats/base/dvariancewd":"@stdlib/stats-base-dvariancewd","@stdlib/stats/base/dvarianceyc":"@stdlib/stats-base-dvarianceyc","@stdlib/stats/base/dvarm":"@stdlib/stats-base-dvarm","@stdlib/stats/base/dvarmpn":"@stdlib/stats-base-dvarmpn","@stdlib/stats/base/dvarmtk":"@stdlib/stats-base-dvarmtk","@stdlib/strided/base/function-object":"@stdlib/strided-base-function-object","@stdlib/blas/ext/base/gapx":"@stdlib/blas-ext-base-gapx","@stdlib/blas/ext/base/gapxsum":"@stdlib/blas-ext-base-gapxsum","@stdlib/blas/ext/base/gapxsumkbn":"@stdlib/blas-ext-base-gapxsumkbn","@stdlib/blas/ext/base/gapxsumkbn2":"@stdlib/blas-ext-base-gapxsumkbn2","@stdlib/blas/ext/base/gapxsumors":"@stdlib/blas-ext-base-gapxsumors","@stdlib/blas/ext/base/gapxsumpw":"@stdlib/blas-ext-base-gapxsumpw","@stdlib/blas/base/gasum":"@stdlib/blas-base-gasum","@stdlib/blas/ext/base/gasumpw":"@stdlib/blas-ext-base-gasumpw","@stdlib/blas/base/gaxpy":"@stdlib/blas-base-gaxpy","@stdlib/blas/base/gcopy":"@stdlib/blas-base-gcopy","@stdlib/blas/ext/base/gcusum":"@stdlib/blas-ext-base-gcusum","@stdlib/blas/ext/base/gcusumkbn":"@stdlib/blas-ext-base-gcusumkbn","@stdlib/blas/ext/base/gcusumkbn2":"@stdlib/blas-ext-base-gcusumkbn2","@stdlib/blas/ext/base/gcusumors":"@stdlib/blas-ext-base-gcusumors","@stdlib/blas/ext/base/gcusumpw":"@stdlib/blas-ext-base-gcusumpw","@stdlib/blas/base/gdot":"@stdlib/blas-base-gdot","@stdlib/blas/ext/base/gfill":"@stdlib/blas-ext-base-gfill","@stdlib/blas/ext/base/gfill-by":"@stdlib/blas-ext-base-gfill-by","@stdlib/blas/ext/base/gnannsumkbn":"@stdlib/blas-ext-base-gnannsumkbn","@stdlib/blas/ext/base/gnansum":"@stdlib/blas-ext-base-gnansum","@stdlib/blas/ext/base/gnansumkbn":"@stdlib/blas-ext-base-gnansumkbn","@stdlib/blas/ext/base/gnansumkbn2":"@stdlib/blas-ext-base-gnansumkbn2","@stdlib/blas/ext/base/gnansumors":"@stdlib/blas-ext-base-gnansumors","@stdlib/blas/ext/base/gnansumpw":"@stdlib/blas-ext-base-gnansumpw","@stdlib/blas/base/gnrm2":"@stdlib/blas-base-gnrm2","@stdlib/blas/ext/base/grev":"@stdlib/blas-ext-base-grev","@stdlib/blas/base/gscal":"@stdlib/blas-base-gscal","@stdlib/blas/ext/base/gsort2hp":"@stdlib/blas-ext-base-gsort2hp","@stdlib/blas/ext/base/gsort2ins":"@stdlib/blas-ext-base-gsort2ins","@stdlib/blas/ext/base/gsort2sh":"@stdlib/blas-ext-base-gsort2sh","@stdlib/blas/ext/base/gsorthp":"@stdlib/blas-ext-base-gsorthp","@stdlib/blas/ext/base/gsortins":"@stdlib/blas-ext-base-gsortins","@stdlib/blas/ext/base/gsortsh":"@stdlib/blas-ext-base-gsortsh","@stdlib/blas/ext/base/gsum":"@stdlib/blas-ext-base-gsum","@stdlib/blas/ext/base/gsumkbn":"@stdlib/blas-ext-base-gsumkbn","@stdlib/blas/ext/base/gsumkbn2":"@stdlib/blas-ext-base-gsumkbn2","@stdlib/blas/ext/base/gsumors":"@stdlib/blas-ext-base-gsumors","@stdlib/blas/ext/base/gsumpw":"@stdlib/blas-ext-base-gsumpw","@stdlib/blas/base/gswap":"@stdlib/blas-base-gswap","@stdlib/strided/base/map-by":"@stdlib/strided-base-map-by","@stdlib/strided/base/map-by2":"@stdlib/strided-base-map-by2","@stdlib/stats/base/max":"@stdlib/stats-base-max","@stdlib/stats/base/maxabs":"@stdlib/stats-base-maxabs","@stdlib/stats/base/max-by":"@stdlib/stats-base-max-by","@stdlib/stats/base/maxsorted":"@stdlib/stats-base-maxsorted","@stdlib/strided/base/max-view-buffer-index":"@stdlib/strided-base-max-view-buffer-index","@stdlib/stats/base/mean":"@stdlib/stats-base-mean","@stdlib/stats/base/meankbn":"@stdlib/stats-base-meankbn","@stdlib/stats/base/meankbn2":"@stdlib/stats-base-meankbn2","@stdlib/stats/base/meanors":"@stdlib/stats-base-meanors","@stdlib/stats/base/meanpn":"@stdlib/stats-base-meanpn","@stdlib/stats/base/meanpw":"@stdlib/stats-base-meanpw","@stdlib/stats/base/meanwd":"@stdlib/stats-base-meanwd","@stdlib/stats/base/mediansorted":"@stdlib/stats-base-mediansorted","@stdlib/strided/base/meta-data-props":"@stdlib/strided-base-meta-data-props","@stdlib/stats/base/min":"@stdlib/stats-base-min","@stdlib/stats/base/minabs":"@stdlib/stats-base-minabs","@stdlib/stats/base/min-by":"@stdlib/stats-base-min-by","@stdlib/stats/base/minsorted":"@stdlib/stats-base-minsorted","@stdlib/strided/base/min-view-buffer-index":"@stdlib/strided-base-min-view-buffer-index","@stdlib/stats/base/mskmax":"@stdlib/stats-base-mskmax","@stdlib/stats/base/mskmin":"@stdlib/stats-base-mskmin","@stdlib/stats/base/mskrange":"@stdlib/stats-base-mskrange","@stdlib/strided/base/mskunary":"@stdlib/strided-base-mskunary","@stdlib/strided/base/mskunary-dtype-signatures":"@stdlib/strided-base-mskunary-dtype-signatures","@stdlib/strided/base/mskunary-signature-callbacks":"@stdlib/strided-base-mskunary-signature-callbacks","@stdlib/stats/base/nanmax":"@stdlib/stats-base-nanmax","@stdlib/stats/base/nanmaxabs":"@stdlib/stats-base-nanmaxabs","@stdlib/stats/base/nanmax-by":"@stdlib/stats-base-nanmax-by","@stdlib/stats/base/nanmean":"@stdlib/stats-base-nanmean","@stdlib/stats/base/nanmeanors":"@stdlib/stats-base-nanmeanors","@stdlib/stats/base/nanmeanpn":"@stdlib/stats-base-nanmeanpn","@stdlib/stats/base/nanmeanwd":"@stdlib/stats-base-nanmeanwd","@stdlib/stats/base/nanmin":"@stdlib/stats-base-nanmin","@stdlib/stats/base/nanminabs":"@stdlib/stats-base-nanminabs","@stdlib/stats/base/nanmin-by":"@stdlib/stats-base-nanmin-by","@stdlib/stats/base/nanmskmax":"@stdlib/stats-base-nanmskmax","@stdlib/stats/base/nanmskmin":"@stdlib/stats-base-nanmskmin","@stdlib/stats/base/nanmskrange":"@stdlib/stats-base-nanmskrange","@stdlib/stats/base/nanrange":"@stdlib/stats-base-nanrange","@stdlib/stats/base/nanrange-by":"@stdlib/stats-base-nanrange-by","@stdlib/stats/base/nanstdev":"@stdlib/stats-base-nanstdev","@stdlib/stats/base/nanstdevch":"@stdlib/stats-base-nanstdevch","@stdlib/stats/base/nanstdevpn":"@stdlib/stats-base-nanstdevpn","@stdlib/stats/base/nanstdevtk":"@stdlib/stats-base-nanstdevtk","@stdlib/stats/base/nanstdevwd":"@stdlib/stats-base-nanstdevwd","@stdlib/stats/base/nanstdevyc":"@stdlib/stats-base-nanstdevyc","@stdlib/stats/base/nanvariance":"@stdlib/stats-base-nanvariance","@stdlib/stats/base/nanvariancech":"@stdlib/stats-base-nanvariancech","@stdlib/stats/base/nanvariancepn":"@stdlib/stats-base-nanvariancepn","@stdlib/stats/base/nanvariancetk":"@stdlib/stats-base-nanvariancetk","@stdlib/stats/base/nanvariancewd":"@stdlib/stats-base-nanvariancewd","@stdlib/stats/base/nanvarianceyc":"@stdlib/stats-base-nanvarianceyc","@stdlib/strided/base/nullary":"@stdlib/strided-base-nullary","@stdlib/strided/base/offset-view":"@stdlib/strided-base-offset-view","@stdlib/strided/base/quaternary":"@stdlib/strided-base-quaternary","@stdlib/strided/base/quinary":"@stdlib/strided-base-quinary","@stdlib/stats/base/range":"@stdlib/stats-base-range","@stdlib/stats/base/range-by":"@stdlib/stats-base-range-by","@stdlib/strided/base/reinterpret-complex":"@stdlib/strided-base-reinterpret-complex","@stdlib/strided/base/reinterpret-complex64":"@stdlib/strided-base-reinterpret-complex64","@stdlib/strided/base/reinterpret-complex128":"@stdlib/strided-base-reinterpret-complex128","@stdlib/math/strided/special/sabs":"@stdlib/math-strided-special-sabs","@stdlib/math/strided/special/sabs2":"@stdlib/math-strided-special-sabs2","@stdlib/blas/ext/base/sapx":"@stdlib/blas-ext-base-sapx","@stdlib/blas/ext/base/sapxsum":"@stdlib/blas-ext-base-sapxsum","@stdlib/blas/ext/base/sapxsumkbn":"@stdlib/blas-ext-base-sapxsumkbn","@stdlib/blas/ext/base/sapxsumkbn2":"@stdlib/blas-ext-base-sapxsumkbn2","@stdlib/blas/ext/base/sapxsumors":"@stdlib/blas-ext-base-sapxsumors","@stdlib/blas/ext/base/sapxsumpw":"@stdlib/blas-ext-base-sapxsumpw","@stdlib/blas/base/sasum":"@stdlib/blas-base-sasum","@stdlib/blas/ext/base/sasumpw":"@stdlib/blas-ext-base-sasumpw","@stdlib/blas/base/saxpy":"@stdlib/blas-base-saxpy","@stdlib/math/strided/special/scbrt":"@stdlib/math-strided-special-scbrt","@stdlib/math/strided/special/sceil":"@stdlib/math-strided-special-sceil","@stdlib/blas/base/scopy":"@stdlib/blas-base-scopy","@stdlib/stats/base/scumax":"@stdlib/stats-base-scumax","@stdlib/stats/base/scumaxabs":"@stdlib/stats-base-scumaxabs","@stdlib/stats/base/scumin":"@stdlib/stats-base-scumin","@stdlib/stats/base/scuminabs":"@stdlib/stats-base-scuminabs","@stdlib/blas/ext/base/scusum":"@stdlib/blas-ext-base-scusum","@stdlib/blas/ext/base/scusumkbn":"@stdlib/blas-ext-base-scusumkbn","@stdlib/blas/ext/base/scusumkbn2":"@stdlib/blas-ext-base-scusumkbn2","@stdlib/blas/ext/base/scusumors":"@stdlib/blas-ext-base-scusumors","@stdlib/blas/ext/base/scusumpw":"@stdlib/blas-ext-base-scusumpw","@stdlib/math/strided/special/sdeg2rad":"@stdlib/math-strided-special-sdeg2rad","@stdlib/blas/base/sdot":"@stdlib/blas-base-sdot","@stdlib/blas/ext/base/sdsapxsum":"@stdlib/blas-ext-base-sdsapxsum","@stdlib/blas/ext/base/sdsapxsumpw":"@stdlib/blas-ext-base-sdsapxsumpw","@stdlib/blas/base/sdsdot":"@stdlib/blas-base-sdsdot","@stdlib/stats/base/sdsmean":"@stdlib/stats-base-sdsmean","@stdlib/stats/base/sdsmeanors":"@stdlib/stats-base-sdsmeanors","@stdlib/stats/base/sdsnanmean":"@stdlib/stats-base-sdsnanmean","@stdlib/stats/base/sdsnanmeanors":"@stdlib/stats-base-sdsnanmeanors","@stdlib/blas/ext/base/sdsnansum":"@stdlib/blas-ext-base-sdsnansum","@stdlib/blas/ext/base/sdsnansumpw":"@stdlib/blas-ext-base-sdsnansumpw","@stdlib/blas/ext/base/sdssum":"@stdlib/blas-ext-base-sdssum","@stdlib/blas/ext/base/sdssumpw":"@stdlib/blas-ext-base-sdssumpw","@stdlib/blas/ext/base/sfill":"@stdlib/blas-ext-base-sfill","@stdlib/math/strided/special/sfloor":"@stdlib/math-strided-special-sfloor","@stdlib/math/strided/special/sinv":"@stdlib/math-strided-special-sinv","@stdlib/strided/base/smap":"@stdlib/strided-base-smap","@stdlib/strided/base/smap2":"@stdlib/strided-base-smap2","@stdlib/stats/base/smax":"@stdlib/stats-base-smax","@stdlib/stats/base/smaxabs":"@stdlib/stats-base-smaxabs","@stdlib/stats/base/smaxabssorted":"@stdlib/stats-base-smaxabssorted","@stdlib/stats/base/smaxsorted":"@stdlib/stats-base-smaxsorted","@stdlib/stats/base/smean":"@stdlib/stats-base-smean","@stdlib/stats/base/smeankbn":"@stdlib/stats-base-smeankbn","@stdlib/stats/base/smeankbn2":"@stdlib/stats-base-smeankbn2","@stdlib/stats/base/smeanli":"@stdlib/stats-base-smeanli","@stdlib/stats/base/smeanlipw":"@stdlib/stats-base-smeanlipw","@stdlib/stats/base/smeanors":"@stdlib/stats-base-smeanors","@stdlib/stats/base/smeanpn":"@stdlib/stats-base-smeanpn","@stdlib/stats/base/smeanpw":"@stdlib/stats-base-smeanpw","@stdlib/stats/base/smeanwd":"@stdlib/stats-base-smeanwd","@stdlib/stats/base/smediansorted":"@stdlib/stats-base-smediansorted","@stdlib/stats/base/smidrange":"@stdlib/stats-base-smidrange","@stdlib/stats/base/smin":"@stdlib/stats-base-smin","@stdlib/stats/base/sminabs":"@stdlib/stats-base-sminabs","@stdlib/stats/base/sminsorted":"@stdlib/stats-base-sminsorted","@stdlib/math/strided/special/smskabs":"@stdlib/math-strided-special-smskabs","@stdlib/math/strided/special/smskabs2":"@stdlib/math-strided-special-smskabs2","@stdlib/math/strided/special/smskcbrt":"@stdlib/math-strided-special-smskcbrt","@stdlib/math/strided/special/smskceil":"@stdlib/math-strided-special-smskceil","@stdlib/math/strided/special/smskdeg2rad":"@stdlib/math-strided-special-smskdeg2rad","@stdlib/math/strided/special/smskfloor":"@stdlib/math-strided-special-smskfloor","@stdlib/math/strided/special/smskinv":"@stdlib/math-strided-special-smskinv","@stdlib/strided/base/smskmap":"@stdlib/strided-base-smskmap","@stdlib/strided/base/smskmap2":"@stdlib/strided-base-smskmap2","@stdlib/stats/base/smskmax":"@stdlib/stats-base-smskmax","@stdlib/stats/base/smskmin":"@stdlib/stats-base-smskmin","@stdlib/math/strided/special/smskramp":"@stdlib/math-strided-special-smskramp","@stdlib/stats/base/smskrange":"@stdlib/stats-base-smskrange","@stdlib/math/strided/special/smskrsqrt":"@stdlib/math-strided-special-smskrsqrt","@stdlib/math/strided/special/smsksqrt":"@stdlib/math-strided-special-smsksqrt","@stdlib/math/strided/special/smsktrunc":"@stdlib/math-strided-special-smsktrunc","@stdlib/stats/base/snanmax":"@stdlib/stats-base-snanmax","@stdlib/stats/base/snanmaxabs":"@stdlib/stats-base-snanmaxabs","@stdlib/stats/base/snanmean":"@stdlib/stats-base-snanmean","@stdlib/stats/base/snanmeanors":"@stdlib/stats-base-snanmeanors","@stdlib/stats/base/snanmeanpn":"@stdlib/stats-base-snanmeanpn","@stdlib/stats/base/snanmeanwd":"@stdlib/stats-base-snanmeanwd","@stdlib/stats/base/snanmin":"@stdlib/stats-base-snanmin","@stdlib/stats/base/snanminabs":"@stdlib/stats-base-snanminabs","@stdlib/stats/base/snanmskmax":"@stdlib/stats-base-snanmskmax","@stdlib/stats/base/snanmskmin":"@stdlib/stats-base-snanmskmin","@stdlib/stats/base/snanmskrange":"@stdlib/stats-base-snanmskrange","@stdlib/stats/base/snanrange":"@stdlib/stats-base-snanrange","@stdlib/stats/base/snanstdev":"@stdlib/stats-base-snanstdev","@stdlib/stats/base/snanstdevch":"@stdlib/stats-base-snanstdevch","@stdlib/stats/base/snanstdevpn":"@stdlib/stats-base-snanstdevpn","@stdlib/stats/base/snanstdevtk":"@stdlib/stats-base-snanstdevtk","@stdlib/stats/base/snanstdevwd":"@stdlib/stats-base-snanstdevwd","@stdlib/stats/base/snanstdevyc":"@stdlib/stats-base-snanstdevyc","@stdlib/blas/ext/base/snansum":"@stdlib/blas-ext-base-snansum","@stdlib/blas/ext/base/snansumkbn":"@stdlib/blas-ext-base-snansumkbn","@stdlib/blas/ext/base/snansumkbn2":"@stdlib/blas-ext-base-snansumkbn2","@stdlib/blas/ext/base/snansumors":"@stdlib/blas-ext-base-snansumors","@stdlib/blas/ext/base/snansumpw":"@stdlib/blas-ext-base-snansumpw","@stdlib/stats/base/snanvariance":"@stdlib/stats-base-snanvariance","@stdlib/stats/base/snanvariancech":"@stdlib/stats-base-snanvariancech","@stdlib/stats/base/snanvariancepn":"@stdlib/stats-base-snanvariancepn","@stdlib/stats/base/snanvariancetk":"@stdlib/stats-base-snanvariancetk","@stdlib/stats/base/snanvariancewd":"@stdlib/stats-base-snanvariancewd","@stdlib/stats/base/snanvarianceyc":"@stdlib/stats-base-snanvarianceyc","@stdlib/blas/base/snrm2":"@stdlib/blas-base-snrm2","@stdlib/math/strided/special/sramp":"@stdlib/math-strided-special-sramp","@stdlib/stats/base/srange":"@stdlib/stats-base-srange","@stdlib/blas/ext/base/srev":"@stdlib/blas-ext-base-srev","@stdlib/math/strided/special/srsqrt":"@stdlib/math-strided-special-srsqrt","@stdlib/blas/base/sscal":"@stdlib/blas-base-sscal","@stdlib/blas/ext/base/ssort2hp":"@stdlib/blas-ext-base-ssort2hp","@stdlib/blas/ext/base/ssort2ins":"@stdlib/blas-ext-base-ssort2ins","@stdlib/blas/ext/base/ssort2sh":"@stdlib/blas-ext-base-ssort2sh","@stdlib/blas/ext/base/ssorthp":"@stdlib/blas-ext-base-ssorthp","@stdlib/blas/ext/base/ssortins":"@stdlib/blas-ext-base-ssortins","@stdlib/blas/ext/base/ssortsh":"@stdlib/blas-ext-base-ssortsh","@stdlib/math/strided/special/ssqrt":"@stdlib/math-strided-special-ssqrt","@stdlib/stats/base/sstdev":"@stdlib/stats-base-sstdev","@stdlib/stats/base/sstdevch":"@stdlib/stats-base-sstdevch","@stdlib/stats/base/sstdevpn":"@stdlib/stats-base-sstdevpn","@stdlib/stats/base/sstdevtk":"@stdlib/stats-base-sstdevtk","@stdlib/stats/base/sstdevwd":"@stdlib/stats-base-sstdevwd","@stdlib/stats/base/sstdevyc":"@stdlib/stats-base-sstdevyc","@stdlib/blas/ext/base/ssum":"@stdlib/blas-ext-base-ssum","@stdlib/blas/ext/base/ssumkbn":"@stdlib/blas-ext-base-ssumkbn","@stdlib/blas/ext/base/ssumkbn2":"@stdlib/blas-ext-base-ssumkbn2","@stdlib/blas/ext/base/ssumors":"@stdlib/blas-ext-base-ssumors","@stdlib/blas/ext/base/ssumpw":"@stdlib/blas-ext-base-ssumpw","@stdlib/blas/base/sswap":"@stdlib/blas-base-sswap","@stdlib/stats/base/stdev":"@stdlib/stats-base-stdev","@stdlib/stats/base/stdevch":"@stdlib/stats-base-stdevch","@stdlib/stats/base/stdevpn":"@stdlib/stats-base-stdevpn","@stdlib/stats/base/stdevtk":"@stdlib/stats-base-stdevtk","@stdlib/stats/base/stdevwd":"@stdlib/stats-base-stdevwd","@stdlib/stats/base/stdevyc":"@stdlib/stats-base-stdevyc","@stdlib/math/strided/special/strunc":"@stdlib/math-strided-special-strunc","@stdlib/stats/base/svariance":"@stdlib/stats-base-svariance","@stdlib/stats/base/svariancech":"@stdlib/stats-base-svariancech","@stdlib/stats/base/svariancepn":"@stdlib/stats-base-svariancepn","@stdlib/stats/base/svariancetk":"@stdlib/stats-base-svariancetk","@stdlib/stats/base/svariancewd":"@stdlib/stats-base-svariancewd","@stdlib/stats/base/svarianceyc":"@stdlib/stats-base-svarianceyc","@stdlib/strided/base/ternary":"@stdlib/strided-base-ternary","@stdlib/strided/base/unary":"@stdlib/strided-base-unary","@stdlib/strided/base/unary-by":"@stdlib/strided-base-unary-by","@stdlib/strided/base/unary-dtype-signatures":"@stdlib/strided-base-unary-dtype-signatures","@stdlib/strided/base/unary-signature-callbacks":"@stdlib/strided-base-unary-signature-callbacks","@stdlib/stats/base/variance":"@stdlib/stats-base-variance","@stdlib/stats/base/variancech":"@stdlib/stats-base-variancech","@stdlib/stats/base/variancepn":"@stdlib/stats-base-variancepn","@stdlib/stats/base/variancetk":"@stdlib/stats-base-variancetk","@stdlib/stats/base/variancewd":"@stdlib/stats-base-variancewd","@stdlib/stats/base/varianceyc":"@stdlib/stats-base-varianceyc","@stdlib/strided/base/zmap":"@stdlib/strided-base-zmap","@stdlib/slice/base/str2multislice":"@stdlib/slice-base-str2multislice","@stdlib/slice/base/str2slice":"@stdlib/slice-base-str2slice","@stdlib/number/float64/base/sub":"@stdlib/number-float64-base-sub","@stdlib/math/base/ops/subf":"@stdlib/math-base-ops-subf","@stdlib/math/base/tools/sum-series":"@stdlib/math-base-tools-sum-series","@stdlib/math/base/special/tan":"@stdlib/math-base-special-tan","@stdlib/math/base/special/tand":"@stdlib/math-base-special-tand","@stdlib/math/base/special/tanh":"@stdlib/math-base-special-tanh","@stdlib/number/float64/base/to-binary-string":"@stdlib/number-float64-base-to-binary-string","@stdlib/number/float32/base/to-binary-string":"@stdlib/number-float32-base-to-binary-string","@stdlib/number/uint8/base/to-binary-string":"@stdlib/number-uint8-base-to-binary-string","@stdlib/number/uint16/base/to-binary-string":"@stdlib/number-uint16-base-to-binary-string","@stdlib/number/uint32/base/to-binary-string":"@stdlib/number-uint32-base-to-binary-string","@stdlib/number/float32/base/to-word":"@stdlib/number-float32-base-to-word","@stdlib/number/float64/base/to-words":"@stdlib/number-float64-base-to-words","@stdlib/ndarray/base/transpose":"@stdlib/ndarray-base-transpose","@stdlib/math/base/special/tribonacci":"@stdlib/math-base-special-tribonacci","@stdlib/math/base/special/trigamma":"@stdlib/math-base-special-trigamma","@stdlib/string/base/trim":"@stdlib/string-base-trim","@stdlib/math/base/special/trunc":"@stdlib/math-base-special-trunc","@stdlib/math/base/special/trunc2":"@stdlib/math-base-special-trunc2","@stdlib/math/base/special/trunc10":"@stdlib/math-base-special-trunc10","@stdlib/string/base/truncate-middle":"@stdlib/string-base-truncate-middle","@stdlib/math/base/special/truncb":"@stdlib/math-base-special-truncb","@stdlib/math/base/special/truncf":"@stdlib/math-base-special-truncf","@stdlib/math/base/special/truncn":"@stdlib/math-base-special-truncn","@stdlib/math/base/special/truncsd":"@stdlib/math-base-special-truncsd","@stdlib/number/uint32/base/to-int32":"@stdlib/number-uint32-base-to-int32","@stdlib/math/base/ops/umul":"@stdlib/math-base-ops-umul","@stdlib/math/base/ops/umuldw":"@stdlib/math-base-ops-umuldw","@stdlib/string/base/uncapitalize":"@stdlib/string-base-uncapitalize","@stdlib/string/base/uppercase":"@stdlib/string-base-uppercase","@stdlib/math/base/special/vercos":"@stdlib/math-base-special-vercos","@stdlib/math/base/special/versin":"@stdlib/math-base-special-versin","@stdlib/math/base/special/wrap":"@stdlib/math-base-special-wrap","@stdlib/math/base/special/xlog1py":"@stdlib/math-base-special-xlog1py","@stdlib/math/base/special/xlogy":"@stdlib/math-base-special-xlogy","@stdlib/math/base/special/riemann-zeta":"@stdlib/math-base-special-riemann-zeta","@stdlib/bench":"@stdlib/bench","@stdlib/datasets/berndt-cps-wages-1985":"@stdlib/datasets-berndt-cps-wages-1985","@stdlib/utils/bifurcate":"@stdlib/utils-bifurcate","@stdlib/utils/bifurcate-by":"@stdlib/utils-bifurcate-by","@stdlib/utils/async/bifurcate-by":"@stdlib/utils-async-bifurcate-by","@stdlib/utils/bifurcate-in":"@stdlib/utils-bifurcate-in","@stdlib/utils/bifurcate-own":"@stdlib/utils-bifurcate-own","@stdlib/bigint/ctor":"@stdlib/bigint-ctor","@stdlib/stats/binomial-test":"@stdlib/stats-binomial-test","@stdlib/boolean/ctor":"@stdlib/boolean-ctor","@stdlib/array/bool":"@stdlib/array-bool","@stdlib/ndarray/broadcast-array":"@stdlib/ndarray-broadcast-array","@stdlib/ndarray/broadcast-arrays":"@stdlib/ndarray-broadcast-arrays","@stdlib/buffer/ctor":"@stdlib/buffer-ctor","@stdlib/buffer/to-json":"@stdlib/buffer-to-json","@stdlib/os/byte-order":"@stdlib/os-byte-order","@stdlib/string/camelcase":"@stdlib/string-camelcase","@stdlib/string/capitalize":"@stdlib/string-capitalize","@stdlib/utils/capitalize-keys":"@stdlib/utils-capitalize-keys","@stdlib/constants/float64/catalan":"@stdlib/constants-float64-catalan","@stdlib/constants/float64/cbrt-eps":"@stdlib/constants-float64-cbrt-eps","@stdlib/datasets/cdc-nchs-us-births-1969-1988":"@stdlib/datasets-cdc-nchs-us-births-1969-1988","@stdlib/datasets/cdc-nchs-us-births-1994-2003":"@stdlib/datasets-cdc-nchs-us-births-1994-2003","@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013":"@stdlib/datasets-cdc-nchs-us-infant-mortality-bw-1915-2013","@stdlib/process/chdir":"@stdlib/process-chdir","@stdlib/stats/chi2gof":"@stdlib/stats-chi2gof","@stdlib/stats/chi2test":"@stdlib/stats-chi2test","@stdlib/array/to-circular-iterator":"@stdlib/array-to-circular-iterator","@stdlib/streams/node/from-circular-array":"@stdlib/streams-node-from-circular-array","@stdlib/dstructs/circular-buffer":"@stdlib/dstructs-circular-buffer","@stdlib/fs/close":"@stdlib/fs-close","@stdlib/datasets/cmudict":"@stdlib/datasets-cmudict","@stdlib/string/code-point-at":"@stdlib/string-code-point-at","@stdlib/utils/common-keys":"@stdlib/utils-common-keys","@stdlib/utils/common-keys-in":"@stdlib/utils-common-keys-in","@stdlib/complex/cmplx":"@stdlib/complex-cmplx","@stdlib/complex/float32/ctor":"@stdlib/complex-float32-ctor","@stdlib/constants/complex64/nan":"@stdlib/constants-complex64-nan","@stdlib/constants/complex64/num-bytes":"@stdlib/constants-complex64-num-bytes","@stdlib/constants/complex64/zero":"@stdlib/constants-complex64-zero","@stdlib/array/complex64":"@stdlib/array-complex64","@stdlib/complex/float64/ctor":"@stdlib/complex-float64-ctor","@stdlib/constants/complex128/nan":"@stdlib/constants-complex128-nan","@stdlib/constants/complex128/num-bytes":"@stdlib/constants-complex128-num-bytes","@stdlib/constants/complex128/zero":"@stdlib/constants-complex128-zero","@stdlib/array/complex128":"@stdlib/array-complex128","@stdlib/array/typed-complex":"@stdlib/array-typed-complex","@stdlib/array/typed-complex-ctors":"@stdlib/array-typed-complex-ctors","@stdlib/array/typed-complex-dtypes":"@stdlib/array-typed-complex-dtypes","@stdlib/complex/ctors":"@stdlib/complex-ctors","@stdlib/complex/dtype":"@stdlib/complex-dtype","@stdlib/complex/dtypes":"@stdlib/complex-dtypes","@stdlib/complex/promotion-rules":"@stdlib/complex-promotion-rules","@stdlib/utils/compose":"@stdlib/utils-compose","@stdlib/utils/async/compose":"@stdlib/utils-async-compose","@stdlib/os/configdir":"@stdlib/os-configdir","@stdlib/complex/float64/conj":"@stdlib/complex-float64-conj","@stdlib/complex/float32/conj":"@stdlib/complex-float32-conj","@stdlib/string/constantcase":"@stdlib/string-constantcase","@stdlib/utils/constant-function":"@stdlib/utils-constant-function","@stdlib/streams/node/from-constant":"@stdlib/streams-node-from-constant","@stdlib/utils/constructor-name":"@stdlib/utils-constructor-name","@stdlib/assert/contains":"@stdlib/assert-contains","@stdlib/array/convert":"@stdlib/array-convert","@stdlib/array/convert-same":"@stdlib/array-convert-same","@stdlib/utils/convert-path":"@stdlib/utils-convert-path","@stdlib/utils/copy":"@stdlib/utils-copy","@stdlib/buffer/from-buffer":"@stdlib/buffer-from-buffer","@stdlib/utils/count-by":"@stdlib/utils-count-by","@stdlib/utils/async/count-by":"@stdlib/utils-async-count-by","@stdlib/time/current-year":"@stdlib/time-current-year","@stdlib/utils/curry":"@stdlib/utils-curry","@stdlib/utils/curry-right":"@stdlib/utils-curry-right","@stdlib/process/cwd":"@stdlib/process-cwd","@stdlib/datasets/dale-chall-new":"@stdlib/datasets-dale-chall-new","@stdlib/datasets":"@stdlib/datasets","@stdlib/array/dataview":"@stdlib/array-dataview","@stdlib/array/datespace":"@stdlib/array-datespace","@stdlib/time/day-of-quarter":"@stdlib/time-day-of-quarter","@stdlib/time/day-of-year":"@stdlib/time-day-of-year","@stdlib/time/days-in-month":"@stdlib/time-days-in-month","@stdlib/time/days-in-year":"@stdlib/time-days-in-year","@stdlib/blas/ddot":"@stdlib/blas-ddot","@stdlib/streams/node/debug-sink":"@stdlib/streams-node-debug-sink","@stdlib/streams/node/debug":"@stdlib/streams-node-debug","@stdlib/utils/decorate-after":"@stdlib/utils-decorate-after","@stdlib/assert/deep-equal":"@stdlib/assert-deep-equal","@stdlib/utils/deep-get":"@stdlib/utils-deep-get","@stdlib/assert/deep-has-own-property":"@stdlib/assert-deep-has-own-property","@stdlib/assert/deep-has-property":"@stdlib/assert-deep-has-property","@stdlib/utils/deep-pluck":"@stdlib/utils-deep-pluck","@stdlib/utils/deep-set":"@stdlib/utils-deep-set","@stdlib/utils/define-memoized-property":"@stdlib/utils-define-memoized-property","@stdlib/utils/define-properties":"@stdlib/utils-define-properties","@stdlib/utils/define-property":"@stdlib/utils-define-property","@stdlib/utils/dirname":"@stdlib/utils-dirname","@stdlib/string/dotcase":"@stdlib/string-dotcase","@stdlib/dstructs/doubly-linked-list":"@stdlib/dstructs-doubly-linked-list","@stdlib/utils/do-until":"@stdlib/utils-do-until","@stdlib/utils/async/do-until":"@stdlib/utils-async-do-until","@stdlib/utils/do-until-each":"@stdlib/utils-do-until-each","@stdlib/utils/do-until-each-right":"@stdlib/utils-do-until-each-right","@stdlib/utils/do-while":"@stdlib/utils-do-while","@stdlib/utils/async/do-while":"@stdlib/utils-async-do-while","@stdlib/utils/do-while-each":"@stdlib/utils-do-while-each","@stdlib/utils/do-while-each-right":"@stdlib/utils-do-while-each-right","@stdlib/blas/dswap":"@stdlib/blas-dswap","@stdlib/constants/float64/e":"@stdlib/constants-float64-e","@stdlib/datasets/emoji":"@stdlib/datasets-emoji","@stdlib/datasets/emoji-code-picto":"@stdlib/datasets-emoji-code-picto","@stdlib/datasets/emoji-picto-code":"@stdlib/datasets-emoji-picto-code","@stdlib/streams/node/empty":"@stdlib/streams-node-empty","@stdlib/string/ends-with":"@stdlib/string-ends-with","@stdlib/utils/enumerable-properties":"@stdlib/utils-enumerable-properties","@stdlib/utils/enumerable-properties-in":"@stdlib/utils-enumerable-properties-in","@stdlib/utils/enumerable-property-symbols":"@stdlib/utils-enumerable-property-symbols","@stdlib/utils/enumerable-property-symbols-in":"@stdlib/utils-enumerable-property-symbols-in","@stdlib/process/env":"@stdlib/process-env","@stdlib/constants/float64/eps":"@stdlib/constants-float64-eps","@stdlib/error/to-json":"@stdlib/error-to-json","@stdlib/constants/float64/eulergamma":"@stdlib/constants-float64-eulergamma","@stdlib/utils/every":"@stdlib/utils-every","@stdlib/utils/every-by":"@stdlib/utils-every-by","@stdlib/utils/async/every-by":"@stdlib/utils-async-every-by","@stdlib/utils/every-by-right":"@stdlib/utils-every-by-right","@stdlib/utils/async/every-by-right":"@stdlib/utils-async-every-by-right","@stdlib/utils/every-in-by":"@stdlib/utils-every-in-by","@stdlib/utils/every-own-by":"@stdlib/utils-every-own-by","@stdlib/utils/eval":"@stdlib/utils-eval","@stdlib/process/exec-path":"@stdlib/process-exec-path","@stdlib/fs/exists":"@stdlib/fs-exists","@stdlib/nlp/expand-acronyms":"@stdlib/nlp-expand-acronyms","@stdlib/nlp/expand-contractions":"@stdlib/nlp-expand-contractions","@stdlib/utils/extname":"@stdlib/utils-extname","@stdlib/ndarray/fancy":"@stdlib/ndarray-fancy","@stdlib/math/base/special/fast/abs":"@stdlib/math-base-special-fast-abs","@stdlib/math/base/special/fast/acosh":"@stdlib/math-base-special-fast-acosh","@stdlib/math/base/special/fast/alpha-max-plus-beta-min":"@stdlib/math-base-special-fast-alpha-max-plus-beta-min","@stdlib/math/base/special/fast/asinh":"@stdlib/math-base-special-fast-asinh","@stdlib/math/base/special/fast/atanh":"@stdlib/math-base-special-fast-atanh","@stdlib/math/base/special/fast/hypot":"@stdlib/math-base-special-fast-hypot","@stdlib/math/base/special/fast/uint32-log2":"@stdlib/math-base-special-fast-uint32-log2","@stdlib/math/base/special/fast/max":"@stdlib/math-base-special-fast-max","@stdlib/math/base/special/fast/min":"@stdlib/math-base-special-fast-min","@stdlib/math/base/special/fast/pow-int":"@stdlib/math-base-special-fast-pow-int","@stdlib/math/base/special/fast/uint32-sqrt":"@stdlib/math-base-special-fast-uint32-sqrt","@stdlib/datasets/female-first-names-en":"@stdlib/datasets-female-first-names-en","@stdlib/dstructs/fifo":"@stdlib/dstructs-fifo","@stdlib/array/filled":"@stdlib/array-filled","@stdlib/array/filled-by":"@stdlib/array-filled-by","@stdlib/utils/filter-arguments":"@stdlib/utils-filter-arguments","@stdlib/utils/find":"@stdlib/utils-find","@stdlib/string/first":"@stdlib/string-first","@stdlib/datasets/fivethirtyeight-ffq":"@stdlib/datasets-fivethirtyeight-ffq","@stdlib/utils/flatten-array":"@stdlib/utils-flatten-array","@stdlib/utils/flatten-object":"@stdlib/utils-flatten-object","@stdlib/stats/fligner-test":"@stdlib/stats-fligner-test","@stdlib/os/float-word-order":"@stdlib/os-float-word-order","@stdlib/constants/float16/cbrt-eps":"@stdlib/constants-float16-cbrt-eps","@stdlib/constants/float16/eps":"@stdlib/constants-float16-eps","@stdlib/constants/float16/exponent-bias":"@stdlib/constants-float16-exponent-bias","@stdlib/constants/float16/max":"@stdlib/constants-float16-max","@stdlib/constants/float16/max-safe-integer":"@stdlib/constants-float16-max-safe-integer","@stdlib/constants/float16/min-safe-integer":"@stdlib/constants-float16-min-safe-integer","@stdlib/constants/float16/ninf":"@stdlib/constants-float16-ninf","@stdlib/constants/float16/num-bytes":"@stdlib/constants-float16-num-bytes","@stdlib/constants/float16/pinf":"@stdlib/constants-float16-pinf","@stdlib/constants/float16/precision":"@stdlib/constants-float16-precision","@stdlib/constants/float16/smallest-normal":"@stdlib/constants-float16-smallest-normal","@stdlib/constants/float16/smallest-subnormal":"@stdlib/constants-float16-smallest-subnormal","@stdlib/constants/float16/sqrt-eps":"@stdlib/constants-float16-sqrt-eps","@stdlib/constants/float32/abs-mask":"@stdlib/constants-float32-abs-mask","@stdlib/constants/float32/cbrt-eps":"@stdlib/constants-float32-cbrt-eps","@stdlib/constants/float32/e":"@stdlib/constants-float32-e","@stdlib/constants/float32/eps":"@stdlib/constants-float32-eps","@stdlib/constants/float32/exponent-bias":"@stdlib/constants-float32-exponent-bias","@stdlib/constants/float32/exponent-mask":"@stdlib/constants-float32-exponent-mask","@stdlib/constants/float32/fourth-pi":"@stdlib/constants-float32-fourth-pi","@stdlib/constants/float32/half-ln-two":"@stdlib/constants-float32-half-ln-two","@stdlib/constants/float32/half-pi":"@stdlib/constants-float32-half-pi","@stdlib/constants/float32/ln-half":"@stdlib/constants-float32-ln-half","@stdlib/constants/float32/ln-pi":"@stdlib/constants-float32-ln-pi","@stdlib/constants/float32/ln-ten":"@stdlib/constants-float32-ln-ten","@stdlib/constants/float32/ln-two":"@stdlib/constants-float32-ln-two","@stdlib/constants/float32/max":"@stdlib/constants-float32-max","@stdlib/constants/float32/max-base2-exponent":"@stdlib/constants-float32-max-base2-exponent","@stdlib/constants/float32/max-base2-exponent-subnormal":"@stdlib/constants-float32-max-base2-exponent-subnormal","@stdlib/constants/float32/max-base10-exponent":"@stdlib/constants-float32-max-base10-exponent","@stdlib/constants/float32/max-base10-exponent-subnormal":"@stdlib/constants-float32-max-base10-exponent-subnormal","@stdlib/constants/float32/max-safe-fibonacci":"@stdlib/constants-float32-max-safe-fibonacci","@stdlib/constants/float32/max-safe-integer":"@stdlib/constants-float32-max-safe-integer","@stdlib/constants/float32/max-safe-nth-factorial":"@stdlib/constants-float32-max-safe-nth-factorial","@stdlib/constants/float32/max-safe-nth-fibonacci":"@stdlib/constants-float32-max-safe-nth-fibonacci","@stdlib/constants/float32/max-safe-nth-lucas":"@stdlib/constants-float32-max-safe-nth-lucas","@stdlib/constants/float32/min-base2-exponent":"@stdlib/constants-float32-min-base2-exponent","@stdlib/constants/float32/min-base2-exponent-subnormal":"@stdlib/constants-float32-min-base2-exponent-subnormal","@stdlib/constants/float32/min-base10-exponent":"@stdlib/constants-float32-min-base10-exponent","@stdlib/constants/float32/min-base10-exponent-subnormal":"@stdlib/constants-float32-min-base10-exponent-subnormal","@stdlib/constants/float32/min-safe-integer":"@stdlib/constants-float32-min-safe-integer","@stdlib/constants/float32/nan":"@stdlib/constants-float32-nan","@stdlib/constants/float32/ninf":"@stdlib/constants-float32-ninf","@stdlib/constants/float32/num-bytes":"@stdlib/constants-float32-num-bytes","@stdlib/constants/float32/phi":"@stdlib/constants-float32-phi","@stdlib/constants/float32/pi":"@stdlib/constants-float32-pi","@stdlib/constants/float32/pinf":"@stdlib/constants-float32-pinf","@stdlib/constants/float32/precision":"@stdlib/constants-float32-precision","@stdlib/constants/float32/sign-mask":"@stdlib/constants-float32-sign-mask","@stdlib/constants/float32/significand-mask":"@stdlib/constants-float32-significand-mask","@stdlib/constants/float32/smallest-normal":"@stdlib/constants-float32-smallest-normal","@stdlib/constants/float32/smallest-subnormal":"@stdlib/constants-float32-smallest-subnormal","@stdlib/constants/float32/sqrt-eps":"@stdlib/constants-float32-sqrt-eps","@stdlib/constants/float32/sqrt-half":"@stdlib/constants-float32-sqrt-half","@stdlib/constants/float32/sqrt-half-pi":"@stdlib/constants-float32-sqrt-half-pi","@stdlib/constants/float32/sqrt-phi":"@stdlib/constants-float32-sqrt-phi","@stdlib/constants/float32/sqrt-pi":"@stdlib/constants-float32-sqrt-pi","@stdlib/constants/float32/sqrt-three":"@stdlib/constants-float32-sqrt-three","@stdlib/constants/float32/sqrt-two":"@stdlib/constants-float32-sqrt-two","@stdlib/constants/float32/sqrt-two-pi":"@stdlib/constants-float32-sqrt-two-pi","@stdlib/constants/float32/two-pi":"@stdlib/constants-float32-two-pi","@stdlib/array/float32":"@stdlib/array-float32","@stdlib/array/fixed-endian-float32":"@stdlib/array-fixed-endian-float32","@stdlib/array/little-endian-float32":"@stdlib/array-little-endian-float32","@stdlib/constants/float64/exponent-bias":"@stdlib/constants-float64-exponent-bias","@stdlib/constants/float64/high-word-abs-mask":"@stdlib/constants-float64-high-word-abs-mask","@stdlib/constants/float64/high-word-exponent-mask":"@stdlib/constants-float64-high-word-exponent-mask","@stdlib/constants/float64/high-word-sign-mask":"@stdlib/constants-float64-high-word-sign-mask","@stdlib/constants/float64/high-word-significand-mask":"@stdlib/constants-float64-high-word-significand-mask","@stdlib/constants/float64/max":"@stdlib/constants-float64-max","@stdlib/constants/float64/max-base2-exponent":"@stdlib/constants-float64-max-base2-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal":"@stdlib/constants-float64-max-base2-exponent-subnormal","@stdlib/constants/float64/max-base10-exponent":"@stdlib/constants-float64-max-base10-exponent","@stdlib/constants/float64/max-base10-exponent-subnormal":"@stdlib/constants-float64-max-base10-exponent-subnormal","@stdlib/constants/float64/max-ln":"@stdlib/constants-float64-max-ln","@stdlib/constants/float64/max-safe-fibonacci":"@stdlib/constants-float64-max-safe-fibonacci","@stdlib/constants/float64/max-safe-integer":"@stdlib/constants-float64-max-safe-integer","@stdlib/constants/float64/max-safe-lucas":"@stdlib/constants-float64-max-safe-lucas","@stdlib/constants/float64/max-safe-nth-fibonacci":"@stdlib/constants-float64-max-safe-nth-fibonacci","@stdlib/constants/float64/max-safe-nth-lucas":"@stdlib/constants-float64-max-safe-nth-lucas","@stdlib/constants/float64/min-base2-exponent":"@stdlib/constants-float64-min-base2-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal":"@stdlib/constants-float64-min-base2-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent":"@stdlib/constants-float64-min-base10-exponent","@stdlib/constants/float64/min-base10-exponent-subnormal":"@stdlib/constants-float64-min-base10-exponent-subnormal","@stdlib/constants/float64/min-ln":"@stdlib/constants-float64-min-ln","@stdlib/constants/float64/min-safe-integer":"@stdlib/constants-float64-min-safe-integer","@stdlib/constants/float64/num-bytes":"@stdlib/constants-float64-num-bytes","@stdlib/constants/float64/precision":"@stdlib/constants-float64-precision","@stdlib/constants/float64/smallest-normal":"@stdlib/constants-float64-smallest-normal","@stdlib/constants/float64/smallest-subnormal":"@stdlib/constants-float64-smallest-subnormal","@stdlib/array/float64":"@stdlib/array-float64","@stdlib/array/fixed-endian-float64":"@stdlib/array-fixed-endian-float64","@stdlib/array/little-endian-float64":"@stdlib/array-little-endian-float64","@stdlib/utils/for-each":"@stdlib/utils-for-each","@stdlib/utils/async/for-each":"@stdlib/utils-async-for-each","@stdlib/string/for-each":"@stdlib/string-for-each","@stdlib/utils/for-each-right":"@stdlib/utils-for-each-right","@stdlib/utils/async/for-each-right":"@stdlib/utils-async-for-each-right","@stdlib/utils/for-in":"@stdlib/utils-for-in","@stdlib/string/format":"@stdlib/string-format","@stdlib/utils/for-own":"@stdlib/utils-for-own","@stdlib/constants/float64/fourth-pi":"@stdlib/constants-float64-fourth-pi","@stdlib/constants/float64/fourth-root-eps":"@stdlib/constants-float64-fourth-root-eps","@stdlib/datasets/frb-sf-wage-rigidity":"@stdlib/datasets-frb-sf-wage-rigidity","@stdlib/string/from-code-point":"@stdlib/string-from-code-point","@stdlib/function/ctor":"@stdlib/function-ctor","@stdlib/function/to-string":"@stdlib/function-to-string","@stdlib/utils/function-name":"@stdlib/utils-function-name","@stdlib/utils/function-sequence":"@stdlib/utils-function-sequence","@stdlib/utils/async/function-sequence":"@stdlib/utils-async-function-sequence","@stdlib/constants/float64/gamma-lanczos-g":"@stdlib/constants-float64-gamma-lanczos-g","@stdlib/blas/gdot":"@stdlib/blas-gdot","@stdlib/process/getegid":"@stdlib/process-getegid","@stdlib/process/geteuid":"@stdlib/process-geteuid","@stdlib/process/getgid":"@stdlib/process-getgid","@stdlib/utils/global":"@stdlib/utils-global","@stdlib/utils/get-prototype-of":"@stdlib/utils-get-prototype-of","@stdlib/process/getuid":"@stdlib/process-getuid","@stdlib/constants/float64/glaisher-kinkelin":"@stdlib/constants-float64-glaisher-kinkelin","@stdlib/string/to-grapheme-cluster-iterator":"@stdlib/string-to-grapheme-cluster-iterator","@stdlib/string/to-grapheme-cluster-iterator-right":"@stdlib/string-to-grapheme-cluster-iterator-right","@stdlib/utils/group":"@stdlib/utils-group","@stdlib/utils/group-by":"@stdlib/utils-group-by","@stdlib/utils/async/group-by":"@stdlib/utils-async-group-by","@stdlib/utils/group-in":"@stdlib/utils-group-in","@stdlib/utils/group-own":"@stdlib/utils-group-own","@stdlib/blas/gswap":"@stdlib/blas-gswap","@stdlib/constants/float64/half-ln-two":"@stdlib/constants-float64-half-ln-two","@stdlib/constants/float64/half-pi":"@stdlib/constants-float64-half-pi","@stdlib/datasets/harrison-boston-house-prices":"@stdlib/datasets-harrison-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices-corrected":"@stdlib/datasets-harrison-boston-house-prices-corrected","@stdlib/assert/has-arraybuffer-support":"@stdlib/assert-has-arraybuffer-support","@stdlib/assert/has-arrow-function-support":"@stdlib/assert-has-arrow-function-support","@stdlib/assert/has-async-await-support":"@stdlib/assert-has-async-await-support","@stdlib/assert/has-async-iterator-symbol-support":"@stdlib/assert-has-async-iterator-symbol-support","@stdlib/assert/has-atob-support":"@stdlib/assert-has-atob-support","@stdlib/assert/has-bigint64array-support":"@stdlib/assert-has-bigint64array-support","@stdlib/assert/has-bigint-support":"@stdlib/assert-has-bigint-support","@stdlib/assert/has-biguint64array-support":"@stdlib/assert-has-biguint64array-support","@stdlib/assert/has-btoa-support":"@stdlib/assert-has-btoa-support","@stdlib/assert/has-class-support":"@stdlib/assert-has-class-support","@stdlib/assert/has-dataview-support":"@stdlib/assert-has-dataview-support","@stdlib/assert/has-define-properties-support":"@stdlib/assert-has-define-properties-support","@stdlib/assert/has-define-property-support":"@stdlib/assert-has-define-property-support","@stdlib/assert/has-float32array-support":"@stdlib/assert-has-float32array-support","@stdlib/assert/has-float64array-support":"@stdlib/assert-has-float64array-support","@stdlib/assert/has-function-name-support":"@stdlib/assert-has-function-name-support","@stdlib/assert/has-generator-support":"@stdlib/assert-has-generator-support","@stdlib/assert/has-globalthis-support":"@stdlib/assert-has-globalthis-support","@stdlib/assert/has-int8array-support":"@stdlib/assert-has-int8array-support","@stdlib/assert/has-int16array-support":"@stdlib/assert-has-int16array-support","@stdlib/assert/has-int32array-support":"@stdlib/assert-has-int32array-support","@stdlib/assert/has-iterator-symbol-support":"@stdlib/assert-has-iterator-symbol-support","@stdlib/assert/has-map-support":"@stdlib/assert-has-map-support","@stdlib/assert/has-node-buffer-support":"@stdlib/assert-has-node-buffer-support","@stdlib/assert/has-own-property":"@stdlib/assert-has-own-property","@stdlib/assert/has-property":"@stdlib/assert-has-property","@stdlib/assert/has-proxy-support":"@stdlib/assert-has-proxy-support","@stdlib/assert/has-set-support":"@stdlib/assert-has-set-support","@stdlib/assert/has-sharedarraybuffer-support":"@stdlib/assert-has-sharedarraybuffer-support","@stdlib/assert/has-symbol-support":"@stdlib/assert-has-symbol-support","@stdlib/assert/has-tostringtag-support":"@stdlib/assert-has-tostringtag-support","@stdlib/assert/has-uint8array-support":"@stdlib/assert-has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support":"@stdlib/assert-has-uint8clampedarray-support","@stdlib/assert/has-uint16array-support":"@stdlib/assert-has-uint16array-support","@stdlib/assert/has-uint32array-support":"@stdlib/assert-has-uint32array-support","@stdlib/assert/has-utf16-surrogate-pair-at":"@stdlib/assert-has-utf16-surrogate-pair-at","@stdlib/assert/has-weakmap-support":"@stdlib/assert-has-weakmap-support","@stdlib/assert/has-weakset-support":"@stdlib/assert-has-weakset-support","@stdlib/assert/has-wasm-support":"@stdlib/assert-has-wasm-support","@stdlib/string/headercase":"@stdlib/string-headercase","@stdlib/datasets/herndon-venus-semidiameters":"@stdlib/datasets-herndon-venus-semidiameters","@stdlib/os/homedir":"@stdlib/os-homedir","@stdlib/constants/time/hours-in-day":"@stdlib/constants-time-hours-in-day","@stdlib/constants/time/hours-in-week":"@stdlib/constants-time-hours-in-week","@stdlib/time/hours-in-month":"@stdlib/time-hours-in-month","@stdlib/time/hours-in-year":"@stdlib/time-hours-in-year","@stdlib/net/http-server":"@stdlib/net-http-server","@stdlib/utils/identity-function":"@stdlib/utils-identity-function","@stdlib/utils/if-else":"@stdlib/utils-if-else","@stdlib/utils/async/if-else":"@stdlib/utils-async-if-else","@stdlib/utils/if-then":"@stdlib/utils-if-then","@stdlib/utils/async/if-then":"@stdlib/utils-async-if-then","@stdlib/complex/float64/imag":"@stdlib/complex-float64-imag","@stdlib/complex/float32/imag":"@stdlib/complex-float32-imag","@stdlib/datasets/img-acanthus-mollis":"@stdlib/datasets-img-acanthus-mollis","@stdlib/datasets/img-airplane-from-above":"@stdlib/datasets-img-airplane-from-above","@stdlib/datasets/img-allium-oreophilum":"@stdlib/datasets-img-allium-oreophilum","@stdlib/datasets/img-black-canyon":"@stdlib/datasets-img-black-canyon","@stdlib/datasets/img-dust-bowl-home":"@stdlib/datasets-img-dust-bowl-home","@stdlib/datasets/img-french-alpine-landscape":"@stdlib/datasets-img-french-alpine-landscape","@stdlib/datasets/img-locomotion-house-cat":"@stdlib/datasets-img-locomotion-house-cat","@stdlib/datasets/img-locomotion-nude-male":"@stdlib/datasets-img-locomotion-nude-male","@stdlib/datasets/img-march-pastoral":"@stdlib/datasets-img-march-pastoral","@stdlib/datasets/img-nagasaki-boats":"@stdlib/datasets-img-nagasaki-boats","@stdlib/stats/incr/apcorr":"@stdlib/stats-incr-apcorr","@stdlib/ml/incr/binary-classification":"@stdlib/ml-incr-binary-classification","@stdlib/stats/incr/count":"@stdlib/stats-incr-count","@stdlib/stats/incr/covariance":"@stdlib/stats-incr-covariance","@stdlib/stats/incr/covmat":"@stdlib/stats-incr-covmat","@stdlib/stats/incr/cv":"@stdlib/stats-incr-cv","@stdlib/stats/incr/ewmean":"@stdlib/stats-incr-ewmean","@stdlib/stats/incr/ewstdev":"@stdlib/stats-incr-ewstdev","@stdlib/stats/incr/ewvariance":"@stdlib/stats-incr-ewvariance","@stdlib/stats/incr/gmean":"@stdlib/stats-incr-gmean","@stdlib/stats/incr/grubbs":"@stdlib/stats-incr-grubbs","@stdlib/stats/incr/hmean":"@stdlib/stats-incr-hmean","@stdlib/ml/incr/kmeans":"@stdlib/ml-incr-kmeans","@stdlib/stats/incr/kurtosis":"@stdlib/stats-incr-kurtosis","@stdlib/stats/incr/maape":"@stdlib/stats-incr-maape","@stdlib/stats/incr/mae":"@stdlib/stats-incr-mae","@stdlib/stats/incr/mapcorr":"@stdlib/stats-incr-mapcorr","@stdlib/stats/incr/mape":"@stdlib/stats-incr-mape","@stdlib/stats/incr/max":"@stdlib/stats-incr-max","@stdlib/stats/incr/maxabs":"@stdlib/stats-incr-maxabs","@stdlib/stats/incr/mcovariance":"@stdlib/stats-incr-mcovariance","@stdlib/stats/incr/mcv":"@stdlib/stats-incr-mcv","@stdlib/stats/incr/mda":"@stdlib/stats-incr-mda","@stdlib/stats/incr/me":"@stdlib/stats-incr-me","@stdlib/stats/incr/mean":"@stdlib/stats-incr-mean","@stdlib/stats/incr/meanabs":"@stdlib/stats-incr-meanabs","@stdlib/stats/incr/meanabs2":"@stdlib/stats-incr-meanabs2","@stdlib/stats/incr/meanstdev":"@stdlib/stats-incr-meanstdev","@stdlib/stats/incr/meanvar":"@stdlib/stats-incr-meanvar","@stdlib/stats/incr/mgmean":"@stdlib/stats-incr-mgmean","@stdlib/stats/incr/mgrubbs":"@stdlib/stats-incr-mgrubbs","@stdlib/stats/incr/mhmean":"@stdlib/stats-incr-mhmean","@stdlib/stats/incr/midrange":"@stdlib/stats-incr-midrange","@stdlib/stats/incr/min":"@stdlib/stats-incr-min","@stdlib/stats/incr/minabs":"@stdlib/stats-incr-minabs","@stdlib/stats/incr/minmax":"@stdlib/stats-incr-minmax","@stdlib/stats/incr/minmaxabs":"@stdlib/stats-incr-minmaxabs","@stdlib/stats/incr/mmaape":"@stdlib/stats-incr-mmaape","@stdlib/stats/incr/mmae":"@stdlib/stats-incr-mmae","@stdlib/stats/incr/mmape":"@stdlib/stats-incr-mmape","@stdlib/stats/incr/mmax":"@stdlib/stats-incr-mmax","@stdlib/stats/incr/mmaxabs":"@stdlib/stats-incr-mmaxabs","@stdlib/stats/incr/mmda":"@stdlib/stats-incr-mmda","@stdlib/stats/incr/mme":"@stdlib/stats-incr-mme","@stdlib/stats/incr/mmean":"@stdlib/stats-incr-mmean","@stdlib/stats/incr/mmeanabs":"@stdlib/stats-incr-mmeanabs","@stdlib/stats/incr/mmeanabs2":"@stdlib/stats-incr-mmeanabs2","@stdlib/stats/incr/mmeanstdev":"@stdlib/stats-incr-mmeanstdev","@stdlib/stats/incr/mmeanvar":"@stdlib/stats-incr-mmeanvar","@stdlib/stats/incr/mmidrange":"@stdlib/stats-incr-mmidrange","@stdlib/stats/incr/mmin":"@stdlib/stats-incr-mmin","@stdlib/stats/incr/mminabs":"@stdlib/stats-incr-mminabs","@stdlib/stats/incr/mminmax":"@stdlib/stats-incr-mminmax","@stdlib/stats/incr/mminmaxabs":"@stdlib/stats-incr-mminmaxabs","@stdlib/stats/incr/mmpe":"@stdlib/stats-incr-mmpe","@stdlib/stats/incr/mmse":"@stdlib/stats-incr-mmse","@stdlib/stats/incr/mpcorr":"@stdlib/stats-incr-mpcorr","@stdlib/stats/incr/mpcorr2":"@stdlib/stats-incr-mpcorr2","@stdlib/stats/incr/mpcorrdist":"@stdlib/stats-incr-mpcorrdist","@stdlib/stats/incr/mpe":"@stdlib/stats-incr-mpe","@stdlib/stats/incr/mprod":"@stdlib/stats-incr-mprod","@stdlib/stats/incr/mrange":"@stdlib/stats-incr-mrange","@stdlib/stats/incr/mrmse":"@stdlib/stats-incr-mrmse","@stdlib/stats/incr/mrss":"@stdlib/stats-incr-mrss","@stdlib/stats/incr/mse":"@stdlib/stats-incr-mse","@stdlib/stats/incr/mstdev":"@stdlib/stats-incr-mstdev","@stdlib/stats/incr/msum":"@stdlib/stats-incr-msum","@stdlib/stats/incr/msumabs":"@stdlib/stats-incr-msumabs","@stdlib/stats/incr/msumabs2":"@stdlib/stats-incr-msumabs2","@stdlib/stats/incr/msummary":"@stdlib/stats-incr-msummary","@stdlib/stats/incr/msumprod":"@stdlib/stats-incr-msumprod","@stdlib/stats/incr/mvariance":"@stdlib/stats-incr-mvariance","@stdlib/stats/incr/mvmr":"@stdlib/stats-incr-mvmr","@stdlib/stats/incr/nancount":"@stdlib/stats-incr-nancount","@stdlib/stats/incr/nansum":"@stdlib/stats-incr-nansum","@stdlib/stats/incr/nansumabs":"@stdlib/stats-incr-nansumabs","@stdlib/stats/incr/nansumabs2":"@stdlib/stats-incr-nansumabs2","@stdlib/stats/incr/pcorr":"@stdlib/stats-incr-pcorr","@stdlib/stats/incr/pcorr2":"@stdlib/stats-incr-pcorr2","@stdlib/stats/incr/pcorrdist":"@stdlib/stats-incr-pcorrdist","@stdlib/stats/incr/pcorrdistmat":"@stdlib/stats-incr-pcorrdistmat","@stdlib/stats/incr/pcorrmat":"@stdlib/stats-incr-pcorrmat","@stdlib/stats/incr/prod":"@stdlib/stats-incr-prod","@stdlib/stats/incr/range":"@stdlib/stats-incr-range","@stdlib/stats/incr/rmse":"@stdlib/stats-incr-rmse","@stdlib/stats/incr/rss":"@stdlib/stats-incr-rss","@stdlib/ml/incr/sgd-regression":"@stdlib/ml-incr-sgd-regression","@stdlib/stats/incr/skewness":"@stdlib/stats-incr-skewness","@stdlib/array/incrspace":"@stdlib/array-incrspace","@stdlib/stats/incr/stdev":"@stdlib/stats-incr-stdev","@stdlib/stats/incr/sum":"@stdlib/stats-incr-sum","@stdlib/stats/incr/sumabs":"@stdlib/stats-incr-sumabs","@stdlib/stats/incr/sumabs2":"@stdlib/stats-incr-sumabs2","@stdlib/stats/incr/summary":"@stdlib/stats-incr-summary","@stdlib/stats/incr/sumprod":"@stdlib/stats-incr-sumprod","@stdlib/stats/incr/variance":"@stdlib/stats-incr-variance","@stdlib/stats/incr/vmr":"@stdlib/stats-incr-vmr","@stdlib/stats/incr/wmean":"@stdlib/stats-incr-wmean","@stdlib/ndarray/ind2sub":"@stdlib/ndarray-ind2sub","@stdlib/utils/index-of":"@stdlib/utils-index-of","@stdlib/utils/inherit":"@stdlib/utils-inherit","@stdlib/utils/inherited-enumerable-properties":"@stdlib/utils-inherited-enumerable-properties","@stdlib/utils/inherited-enumerable-property-symbols":"@stdlib/utils-inherited-enumerable-property-symbols","@stdlib/utils/inherited-keys":"@stdlib/utils-inherited-keys","@stdlib/utils/inherited-nonenumerable-properties":"@stdlib/utils-inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names":"@stdlib/utils-inherited-nonenumerable-property-names","@stdlib/utils/inherited-nonenumerable-property-symbols":"@stdlib/utils-inherited-nonenumerable-property-symbols","@stdlib/utils/inherited-properties":"@stdlib/utils-inherited-properties","@stdlib/utils/inherited-property-descriptor":"@stdlib/utils-inherited-property-descriptor","@stdlib/utils/inherited-property-descriptors":"@stdlib/utils-inherited-property-descriptors","@stdlib/utils/inherited-property-names":"@stdlib/utils-inherited-property-names","@stdlib/utils/inherited-property-symbols":"@stdlib/utils-inherited-property-symbols","@stdlib/utils/inherited-writable-properties":"@stdlib/utils-inherited-writable-properties","@stdlib/utils/inherited-writable-property-names":"@stdlib/utils-inherited-writable-property-names","@stdlib/utils/inherited-writable-property-symbols":"@stdlib/utils-inherited-writable-property-symbols","@stdlib/utils/inmap":"@stdlib/utils-inmap","@stdlib/utils/async/inmap":"@stdlib/utils-async-inmap","@stdlib/utils/inmap-right":"@stdlib/utils-inmap-right","@stdlib/utils/async/inmap-right":"@stdlib/utils-async-inmap-right","@stdlib/streams/node/inspect-sink":"@stdlib/streams-node-inspect-sink","@stdlib/streams/node/inspect":"@stdlib/streams-node-inspect","@stdlib/assert/instance-of":"@stdlib/assert-instance-of","@stdlib/constants/int8/max":"@stdlib/constants-int8-max","@stdlib/constants/int8/min":"@stdlib/constants-int8-min","@stdlib/constants/int8/num-bytes":"@stdlib/constants-int8-num-bytes","@stdlib/array/int8":"@stdlib/array-int8","@stdlib/constants/int16/max":"@stdlib/constants-int16-max","@stdlib/constants/int16/min":"@stdlib/constants-int16-min","@stdlib/constants/int16/num-bytes":"@stdlib/constants-int16-num-bytes","@stdlib/array/int16":"@stdlib/array-int16","@stdlib/constants/int32/max":"@stdlib/constants-int32-max","@stdlib/constants/int32/min":"@stdlib/constants-int32-min","@stdlib/constants/int32/num-bytes":"@stdlib/constants-int32-num-bytes","@stdlib/array/int32":"@stdlib/array-int32","@stdlib/assert/is-big-endian":"@stdlib/assert-is-big-endian","@stdlib/assert/is-browser":"@stdlib/assert-is-browser","@stdlib/assert/is-darwin":"@stdlib/assert-is-darwin","@stdlib/assert/is-docker":"@stdlib/assert-is-docker","@stdlib/assert/is-electron":"@stdlib/assert-is-electron","@stdlib/assert/is-electron-main":"@stdlib/assert-is-electron-main","@stdlib/assert/is-electron-renderer":"@stdlib/assert-is-electron-renderer","@stdlib/assert/is-little-endian":"@stdlib/assert-is-little-endian","@stdlib/assert/is-mobile":"@stdlib/assert-is-mobile","@stdlib/assert/is-node":"@stdlib/assert-is-node","@stdlib/assert/is-touch-device":"@stdlib/assert-is-touch-device","@stdlib/assert/is-web-worker":"@stdlib/assert-is-web-worker","@stdlib/assert/is-windows":"@stdlib/assert-is-windows","@stdlib/assert/is-absolute-http-uri":"@stdlib/assert-is-absolute-http-uri","@stdlib/assert/is-absolute-path":"@stdlib/assert-is-absolute-path","@stdlib/assert/is-absolute-uri":"@stdlib/assert-is-absolute-uri","@stdlib/assert/is-accessor-array":"@stdlib/assert-is-accessor-array","@stdlib/assert/is-accessor-property":"@stdlib/assert-is-accessor-property","@stdlib/assert/is-accessor-property-in":"@stdlib/assert-is-accessor-property-in","@stdlib/assert/is-alphagram":"@stdlib/assert-is-alphagram","@stdlib/assert/is-alphanumeric":"@stdlib/assert-is-alphanumeric","@stdlib/assert/is-anagram":"@stdlib/assert-is-anagram","@stdlib/assert/is-arguments":"@stdlib/assert-is-arguments","@stdlib/assert/is-array":"@stdlib/assert-is-array","@stdlib/assert/is-array-array":"@stdlib/assert-is-array-array","@stdlib/assert/is-arraybuffer":"@stdlib/assert-is-arraybuffer","@stdlib/assert/is-arraybuffer-view":"@stdlib/assert-is-arraybuffer-view","@stdlib/assert/is-array-length":"@stdlib/assert-is-array-length","@stdlib/assert/is-array-like":"@stdlib/assert-is-array-like","@stdlib/assert/is-array-like-object":"@stdlib/assert-is-array-like-object","@stdlib/assert/is-arrow-function":"@stdlib/assert-is-arrow-function","@stdlib/assert/is-ascii":"@stdlib/assert-is-ascii","@stdlib/assert/is-between":"@stdlib/assert-is-between","@stdlib/assert/is-between-array":"@stdlib/assert-is-between-array","@stdlib/assert/is-bigint":"@stdlib/assert-is-bigint","@stdlib/assert/is-bigint64array":"@stdlib/assert-is-bigint64array","@stdlib/assert/is-biguint64array":"@stdlib/assert-is-biguint64array","@stdlib/assert/is-binary-string":"@stdlib/assert-is-binary-string","@stdlib/assert/is-blank-string":"@stdlib/assert-is-blank-string","@stdlib/assert/is-boolean":"@stdlib/assert-is-boolean","@stdlib/assert/is-boolean-array":"@stdlib/assert-is-boolean-array","@stdlib/assert/is-boxed-primitive":"@stdlib/assert-is-boxed-primitive","@stdlib/assert/is-buffer":"@stdlib/assert-is-buffer","@stdlib/assert/is-camelcase":"@stdlib/assert-is-camelcase","@stdlib/assert/is-capitalized":"@stdlib/assert-is-capitalized","@stdlib/assert/is-centrosymmetric-matrix":"@stdlib/assert-is-centrosymmetric-matrix","@stdlib/assert/is-circular":"@stdlib/assert-is-circular","@stdlib/assert/is-circular-array":"@stdlib/assert-is-circular-array","@stdlib/assert/is-circular-plain-object":"@stdlib/assert-is-circular-plain-object","@stdlib/assert/is-class":"@stdlib/assert-is-class","@stdlib/assert/is-collection":"@stdlib/assert-is-collection","@stdlib/assert/is-complex":"@stdlib/assert-is-complex","@stdlib/assert/is-complex64":"@stdlib/assert-is-complex64","@stdlib/assert/is-complex64array":"@stdlib/assert-is-complex64array","@stdlib/assert/is-complex64matrix-like":"@stdlib/assert-is-complex64matrix-like","@stdlib/assert/is-complex64ndarray-like":"@stdlib/assert-is-complex64ndarray-like","@stdlib/assert/is-complex64vector-like":"@stdlib/assert-is-complex64vector-like","@stdlib/assert/is-complex128":"@stdlib/assert-is-complex128","@stdlib/assert/is-complex128array":"@stdlib/assert-is-complex128array","@stdlib/assert/is-complex128matrix-like":"@stdlib/assert-is-complex128matrix-like","@stdlib/assert/is-complex128ndarray-like":"@stdlib/assert-is-complex128ndarray-like","@stdlib/assert/is-complex128vector-like":"@stdlib/assert-is-complex128vector-like","@stdlib/assert/is-complex-like":"@stdlib/assert-is-complex-like","@stdlib/assert/is-complex-typed-array":"@stdlib/assert-is-complex-typed-array","@stdlib/assert/is-complex-typed-array-like":"@stdlib/assert-is-complex-typed-array-like","@stdlib/assert/is-composite":"@stdlib/assert-is-composite","@stdlib/assert/is-configurable-property":"@stdlib/assert-is-configurable-property","@stdlib/assert/is-configurable-property-in":"@stdlib/assert-is-configurable-property-in","@stdlib/assert/is-constantcase":"@stdlib/assert-is-constantcase","@stdlib/assert/is-cube-number":"@stdlib/assert-is-cube-number","@stdlib/assert/is-current-year":"@stdlib/assert-is-current-year","@stdlib/assert/is-data-property":"@stdlib/assert-is-data-property","@stdlib/assert/is-data-property-in":"@stdlib/assert-is-data-property-in","@stdlib/assert/is-dataview":"@stdlib/assert-is-dataview","@stdlib/assert/is-date-object":"@stdlib/assert-is-date-object","@stdlib/assert/is-date-object-array":"@stdlib/assert-is-date-object-array","@stdlib/assert/is-digit-string":"@stdlib/assert-is-digit-string","@stdlib/assert/is-domain-name":"@stdlib/assert-is-domain-name","@stdlib/assert/is-duration-string":"@stdlib/assert-is-duration-string","@stdlib/assert/is-email-address":"@stdlib/assert-is-email-address","@stdlib/assert/is-empty-array":"@stdlib/assert-is-empty-array","@stdlib/assert/is-empty-array-like-object":"@stdlib/assert-is-empty-array-like-object","@stdlib/assert/is-empty-collection":"@stdlib/assert-is-empty-collection","@stdlib/assert/is-empty-object":"@stdlib/assert-is-empty-object","@stdlib/assert/is-empty-string":"@stdlib/assert-is-empty-string","@stdlib/assert/is-enumerable-property":"@stdlib/assert-is-enumerable-property","@stdlib/assert/is-enumerable-property-in":"@stdlib/assert-is-enumerable-property-in","@stdlib/assert/is-equal-array":"@stdlib/assert-is-equal-array","@stdlib/assert/is-error":"@stdlib/assert-is-error","@stdlib/assert/is-eval-error":"@stdlib/assert-is-eval-error","@stdlib/assert/is-even":"@stdlib/assert-is-even","@stdlib/assert/is-falsy":"@stdlib/assert-is-falsy","@stdlib/assert/is-falsy-array":"@stdlib/assert-is-falsy-array","@stdlib/assert/is-finite":"@stdlib/assert-is-finite","@stdlib/assert/is-finite-array":"@stdlib/assert-is-finite-array","@stdlib/assert/is-float32array":"@stdlib/assert-is-float32array","@stdlib/assert/is-float32matrix-like":"@stdlib/assert-is-float32matrix-like","@stdlib/assert/is-float32ndarray-like":"@stdlib/assert-is-float32ndarray-like","@stdlib/assert/is-float32vector-like":"@stdlib/assert-is-float32vector-like","@stdlib/assert/is-float64array":"@stdlib/assert-is-float64array","@stdlib/assert/is-float64matrix-like":"@stdlib/assert-is-float64matrix-like","@stdlib/assert/is-float64ndarray-like":"@stdlib/assert-is-float64ndarray-like","@stdlib/assert/is-float64vector-like":"@stdlib/assert-is-float64vector-like","@stdlib/assert/is-function":"@stdlib/assert-is-function","@stdlib/assert/is-function-array":"@stdlib/assert-is-function-array","@stdlib/assert/is-generator-object":"@stdlib/assert-is-generator-object","@stdlib/assert/is-generator-object-like":"@stdlib/assert-is-generator-object-like","@stdlib/assert/is-gzip-buffer":"@stdlib/assert-is-gzip-buffer","@stdlib/assert/is-hex-string":"@stdlib/assert-is-hex-string","@stdlib/assert/is-infinite":"@stdlib/assert-is-infinite","@stdlib/assert/is-inherited-property":"@stdlib/assert-is-inherited-property","@stdlib/assert/is-int8array":"@stdlib/assert-is-int8array","@stdlib/assert/is-int16array":"@stdlib/assert-is-int16array","@stdlib/assert/is-int32array":"@stdlib/assert-is-int32array","@stdlib/assert/is-integer":"@stdlib/assert-is-integer","@stdlib/assert/is-integer-array":"@stdlib/assert-is-integer-array","@stdlib/assert/is-iterable-like":"@stdlib/assert-is-iterable-like","@stdlib/assert/is-iterator-like":"@stdlib/assert-is-iterator-like","@stdlib/assert/is-json":"@stdlib/assert-is-json","@stdlib/assert/is-kebabcase":"@stdlib/assert-is-kebabcase","@stdlib/assert/is-leap-year":"@stdlib/assert-is-leap-year","@stdlib/assert/is-localhost":"@stdlib/assert-is-localhost","@stdlib/assert/is-lowercase":"@stdlib/assert-is-lowercase","@stdlib/assert/is-matrix-like":"@stdlib/assert-is-matrix-like","@stdlib/assert/is-method":"@stdlib/assert-is-method","@stdlib/assert/is-method-in":"@stdlib/assert-is-method-in","@stdlib/assert/is-multi-slice":"@stdlib/assert-is-multi-slice","@stdlib/assert/is-named-typed-tuple-like":"@stdlib/assert-is-named-typed-tuple-like","@stdlib/assert/is-nan":"@stdlib/assert-is-nan","@stdlib/assert/is-nan-array":"@stdlib/assert-is-nan-array","@stdlib/assert/is-native-function":"@stdlib/assert-is-native-function","@stdlib/assert/is-ndarray-like":"@stdlib/assert-is-ndarray-like","@stdlib/assert/is-ndarray-like-with-data-type":"@stdlib/assert-is-ndarray-like-with-data-type","@stdlib/assert/is-negative-finite":"@stdlib/assert-is-negative-finite","@stdlib/assert/is-negative-integer":"@stdlib/assert-is-negative-integer","@stdlib/assert/is-negative-integer-array":"@stdlib/assert-is-negative-integer-array","@stdlib/assert/is-negative-number":"@stdlib/assert-is-negative-number","@stdlib/assert/is-negative-number-array":"@stdlib/assert-is-negative-number-array","@stdlib/assert/is-negative-zero":"@stdlib/assert-is-negative-zero","@stdlib/assert/is-node-builtin":"@stdlib/assert-is-node-builtin","@stdlib/assert/is-node-duplex-stream-like":"@stdlib/assert-is-node-duplex-stream-like","@stdlib/assert/is-node-readable-stream-like":"@stdlib/assert-is-node-readable-stream-like","@stdlib/assert/is-node-repl":"@stdlib/assert-is-node-repl","@stdlib/assert/is-node-stream-like":"@stdlib/assert-is-node-stream-like","@stdlib/assert/is-node-transform-stream-like":"@stdlib/assert-is-node-transform-stream-like","@stdlib/assert/is-node-writable-stream-like":"@stdlib/assert-is-node-writable-stream-like","@stdlib/assert/is-nonconfigurable-property":"@stdlib/assert-is-nonconfigurable-property","@stdlib/assert/is-nonconfigurable-property-in":"@stdlib/assert-is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property":"@stdlib/assert-is-nonenumerable-property","@stdlib/assert/is-nonenumerable-property-in":"@stdlib/assert-is-nonenumerable-property-in","@stdlib/assert/is-nonnegative-finite":"@stdlib/assert-is-nonnegative-finite","@stdlib/assert/is-nonnegative-integer":"@stdlib/assert-is-nonnegative-integer","@stdlib/assert/is-nonnegative-integer-array":"@stdlib/assert-is-nonnegative-integer-array","@stdlib/assert/is-nonnegative-number":"@stdlib/assert-is-nonnegative-number","@stdlib/assert/is-nonnegative-number-array":"@stdlib/assert-is-nonnegative-number-array","@stdlib/assert/is-nonpositive-finite":"@stdlib/assert-is-nonpositive-finite","@stdlib/assert/is-nonpositive-integer":"@stdlib/assert-is-nonpositive-integer","@stdlib/assert/is-nonpositive-integer-array":"@stdlib/assert-is-nonpositive-integer-array","@stdlib/assert/is-nonpositive-number":"@stdlib/assert-is-nonpositive-number","@stdlib/assert/is-nonpositive-number-array":"@stdlib/assert-is-nonpositive-number-array","@stdlib/assert/is-nonsymmetric-matrix":"@stdlib/assert-is-nonsymmetric-matrix","@stdlib/assert/is-null":"@stdlib/assert-is-null","@stdlib/assert/is-null-array":"@stdlib/assert-is-null-array","@stdlib/assert/is-number":"@stdlib/assert-is-number","@stdlib/assert/is-number-array":"@stdlib/assert-is-number-array","@stdlib/assert/is-numeric-array":"@stdlib/assert-is-numeric-array","@stdlib/assert/is-object":"@stdlib/assert-is-object","@stdlib/assert/is-object-array":"@stdlib/assert-is-object-array","@stdlib/assert/is-object-like":"@stdlib/assert-is-object-like","@stdlib/assert/is-odd":"@stdlib/assert-is-odd","@stdlib/time/iso-weeks-in-year":"@stdlib/time-iso-weeks-in-year","@stdlib/assert/is-pascalcase":"@stdlib/assert-is-pascalcase","@stdlib/assert/is-persymmetric-matrix":"@stdlib/assert-is-persymmetric-matrix","@stdlib/assert/is-plain-object":"@stdlib/assert-is-plain-object","@stdlib/assert/is-plain-object-array":"@stdlib/assert-is-plain-object-array","@stdlib/assert/is-positive-finite":"@stdlib/assert-is-positive-finite","@stdlib/assert/is-positive-integer":"@stdlib/assert-is-positive-integer","@stdlib/assert/is-positive-integer-array":"@stdlib/assert-is-positive-integer-array","@stdlib/assert/is-positive-number":"@stdlib/assert-is-positive-number","@stdlib/assert/is-positive-number-array":"@stdlib/assert-is-positive-number-array","@stdlib/assert/is-positive-zero":"@stdlib/assert-is-positive-zero","@stdlib/assert/is-prime":"@stdlib/assert-is-prime","@stdlib/assert/is-primitive":"@stdlib/assert-is-primitive","@stdlib/assert/is-primitive-array":"@stdlib/assert-is-primitive-array","@stdlib/assert/is-prng-like":"@stdlib/assert-is-prng-like","@stdlib/assert/is-probability":"@stdlib/assert-is-probability","@stdlib/assert/is-probability-array":"@stdlib/assert-is-probability-array","@stdlib/assert/is-property-key":"@stdlib/assert-is-property-key","@stdlib/assert/is-prototype-of":"@stdlib/assert-is-prototype-of","@stdlib/assert/is-ragged-nested-array":"@stdlib/assert-is-ragged-nested-array","@stdlib/assert/is-range-error":"@stdlib/assert-is-range-error","@stdlib/assert/is-readable-property":"@stdlib/assert-is-readable-property","@stdlib/assert/is-readable-property-in":"@stdlib/assert-is-readable-property-in","@stdlib/assert/is-read-only-property":"@stdlib/assert-is-read-only-property","@stdlib/assert/is-read-only-property-in":"@stdlib/assert-is-read-only-property-in","@stdlib/assert/is-read-write-property":"@stdlib/assert-is-read-write-property","@stdlib/assert/is-read-write-property-in":"@stdlib/assert-is-read-write-property-in","@stdlib/assert/is-reference-error":"@stdlib/assert-is-reference-error","@stdlib/assert/is-regexp":"@stdlib/assert-is-regexp","@stdlib/assert/is-regexp-string":"@stdlib/assert-is-regexp-string","@stdlib/assert/is-relative-path":"@stdlib/assert-is-relative-path","@stdlib/assert/is-relative-uri":"@stdlib/assert-is-relative-uri","@stdlib/assert/is-safe-integer":"@stdlib/assert-is-safe-integer","@stdlib/assert/is-safe-integer-array":"@stdlib/assert-is-safe-integer-array","@stdlib/assert/is-same-array":"@stdlib/assert-is-same-array","@stdlib/assert/is-same-array-like":"@stdlib/assert-is-same-array-like","@stdlib/assert/is-same-complex64":"@stdlib/assert-is-same-complex64","@stdlib/assert/is-same-complex64array":"@stdlib/assert-is-same-complex64array","@stdlib/assert/is-same-complex128":"@stdlib/assert-is-same-complex128","@stdlib/assert/is-same-complex128array":"@stdlib/assert-is-same-complex128array","@stdlib/assert/is-same-date-object":"@stdlib/assert-is-same-date-object","@stdlib/assert/is-same-float32array":"@stdlib/assert-is-same-float32array","@stdlib/assert/is-same-float64array":"@stdlib/assert-is-same-float64array","@stdlib/assert/is-same-native-class":"@stdlib/assert-is-same-native-class","@stdlib/assert/is-same-type":"@stdlib/assert-is-same-type","@stdlib/assert/is-same-value":"@stdlib/assert-is-same-value","@stdlib/assert/is-same-value-zero":"@stdlib/assert-is-same-value-zero","@stdlib/assert/is-semver":"@stdlib/assert-is-semver","@stdlib/assert/is-sharedarraybuffer":"@stdlib/assert-is-sharedarraybuffer","@stdlib/assert/is-skew-centrosymmetric-matrix":"@stdlib/assert-is-skew-centrosymmetric-matrix","@stdlib/assert/is-skew-persymmetric-matrix":"@stdlib/assert-is-skew-persymmetric-matrix","@stdlib/assert/is-skew-symmetric-matrix":"@stdlib/assert-is-skew-symmetric-matrix","@stdlib/assert/is-slice":"@stdlib/assert-is-slice","@stdlib/assert/is-snakecase":"@stdlib/assert-is-snakecase","@stdlib/assert/is-square-matrix":"@stdlib/assert-is-square-matrix","@stdlib/assert/is-square-number":"@stdlib/assert-is-square-number","@stdlib/assert/is-square-triangular-number":"@stdlib/assert-is-square-triangular-number","@stdlib/assert/is-startcase":"@stdlib/assert-is-startcase","@stdlib/assert/is-strict-equal":"@stdlib/assert-is-strict-equal","@stdlib/assert/is-string":"@stdlib/assert-is-string","@stdlib/assert/is-string-array":"@stdlib/assert-is-string-array","@stdlib/assert/is-symbol":"@stdlib/assert-is-symbol","@stdlib/assert/is-symbol-array":"@stdlib/assert-is-symbol-array","@stdlib/assert/is-symmetric-matrix":"@stdlib/assert-is-symmetric-matrix","@stdlib/assert/is-syntax-error":"@stdlib/assert-is-syntax-error","@stdlib/assert/is-triangular-number":"@stdlib/assert-is-triangular-number","@stdlib/assert/is-truthy":"@stdlib/assert-is-truthy","@stdlib/assert/is-truthy-array":"@stdlib/assert-is-truthy-array","@stdlib/assert/is-typed-array":"@stdlib/assert-is-typed-array","@stdlib/assert/is-typed-array-length":"@stdlib/assert-is-typed-array-length","@stdlib/assert/is-typed-array-like":"@stdlib/assert-is-typed-array-like","@stdlib/assert/is-type-error":"@stdlib/assert-is-type-error","@stdlib/assert/is-uint8array":"@stdlib/assert-is-uint8array","@stdlib/assert/is-uint8clampedarray":"@stdlib/assert-is-uint8clampedarray","@stdlib/assert/is-uint16array":"@stdlib/assert-is-uint16array","@stdlib/assert/is-uint32array":"@stdlib/assert-is-uint32array","@stdlib/assert/is-unc-path":"@stdlib/assert-is-unc-path","@stdlib/assert/is-undefined":"@stdlib/assert-is-undefined","@stdlib/assert/is-undefined-or-null":"@stdlib/assert-is-undefined-or-null","@stdlib/assert/is-unity-probability-array":"@stdlib/assert-is-unity-probability-array","@stdlib/assert/is-uppercase":"@stdlib/assert-is-uppercase","@stdlib/assert/is-uri":"@stdlib/assert-is-uri","@stdlib/assert/is-uri-error":"@stdlib/assert-is-uri-error","@stdlib/assert/is-vector-like":"@stdlib/assert-is-vector-like","@stdlib/assert/is-wasm-memory":"@stdlib/assert-is-wasm-memory","@stdlib/assert/is-well-formed-string":"@stdlib/assert-is-well-formed-string","@stdlib/assert/is-whitespace":"@stdlib/assert-is-whitespace","@stdlib/assert/is-writable-property":"@stdlib/assert-is-writable-property","@stdlib/assert/is-writable-property-in":"@stdlib/assert-is-writable-property-in","@stdlib/assert/is-write-only-property":"@stdlib/assert-is-write-only-property","@stdlib/assert/is-write-only-property-in":"@stdlib/assert-is-write-only-property-in","@stdlib/math/iter/special/abs":"@stdlib/math-iter-special-abs","@stdlib/math/iter/special/abs2":"@stdlib/math-iter-special-abs2","@stdlib/math/iter/special/acos":"@stdlib/math-iter-special-acos","@stdlib/math/iter/special/acosh":"@stdlib/math-iter-special-acosh","@stdlib/math/iter/special/acot":"@stdlib/math-iter-special-acot","@stdlib/math/iter/special/acoth":"@stdlib/math-iter-special-acoth","@stdlib/math/iter/special/acovercos":"@stdlib/math-iter-special-acovercos","@stdlib/math/iter/special/acoversin":"@stdlib/math-iter-special-acoversin","@stdlib/math/iter/ops/add":"@stdlib/math-iter-ops-add","@stdlib/iter/advance":"@stdlib/iter-advance","@stdlib/math/iter/special/ahavercos":"@stdlib/math-iter-special-ahavercos","@stdlib/math/iter/special/ahaversin":"@stdlib/math-iter-special-ahaversin","@stdlib/iter/any":"@stdlib/iter-any","@stdlib/iter/any-by":"@stdlib/iter-any-by","@stdlib/math/iter/special/asin":"@stdlib/math-iter-special-asin","@stdlib/math/iter/special/asinh":"@stdlib/math-iter-special-asinh","@stdlib/math/iter/special/atan":"@stdlib/math-iter-special-atan","@stdlib/math/iter/special/atan2":"@stdlib/math-iter-special-atan2","@stdlib/math/iter/special/atanh":"@stdlib/math-iter-special-atanh","@stdlib/array/from-iterator":"@stdlib/array-from-iterator","@stdlib/iter/to-array-view":"@stdlib/iter-to-array-view","@stdlib/iter/to-array-view-right":"@stdlib/iter-to-array-view-right","@stdlib/streams/node/from-iterator":"@stdlib/streams-node-from-iterator","@stdlib/symbol/iterator":"@stdlib/symbol-iterator","@stdlib/math/iter/special/avercos":"@stdlib/math-iter-special-avercos","@stdlib/math/iter/special/aversin":"@stdlib/math-iter-special-aversin","@stdlib/simulate/iter/awgn":"@stdlib/simulate-iter-awgn","@stdlib/simulate/iter/awln":"@stdlib/simulate-iter-awln","@stdlib/simulate/iter/awun":"@stdlib/simulate-iter-awun","@stdlib/simulate/iter/bartlett-hann-pulse":"@stdlib/simulate-iter-bartlett-hann-pulse","@stdlib/simulate/iter/bartlett-pulse":"@stdlib/simulate-iter-bartlett-pulse","@stdlib/math/iter/special/besselj0":"@stdlib/math-iter-special-besselj0","@stdlib/math/iter/special/besselj1":"@stdlib/math-iter-special-besselj1","@stdlib/math/iter/special/bessely0":"@stdlib/math-iter-special-bessely0","@stdlib/math/iter/special/bessely1":"@stdlib/math-iter-special-bessely1","@stdlib/math/iter/special/beta":"@stdlib/math-iter-special-beta","@stdlib/math/iter/special/betaln":"@stdlib/math-iter-special-betaln","@stdlib/math/iter/special/binet":"@stdlib/math-iter-special-binet","@stdlib/math/iter/special/cbrt":"@stdlib/math-iter-special-cbrt","@stdlib/math/iter/special/ceil":"@stdlib/math-iter-special-ceil","@stdlib/math/iter/special/ceil2":"@stdlib/math-iter-special-ceil2","@stdlib/math/iter/special/ceil10":"@stdlib/math-iter-special-ceil10","@stdlib/math/iter/sequences/composites":"@stdlib/math-iter-sequences-composites","@stdlib/iter/concat":"@stdlib/iter-concat","@stdlib/iter/constant":"@stdlib/iter-constant","@stdlib/math/iter/utils/continued-fraction":"@stdlib/math-iter-utils-continued-fraction","@stdlib/math/iter/sequences/continued-fraction":"@stdlib/math-iter-sequences-continued-fraction","@stdlib/math/iter/special/cos":"@stdlib/math-iter-special-cos","@stdlib/math/iter/special/cosh":"@stdlib/math-iter-special-cosh","@stdlib/simulate/iter/cosine-wave":"@stdlib/simulate-iter-cosine-wave","@stdlib/math/iter/special/cosm1":"@stdlib/math-iter-special-cosm1","@stdlib/math/iter/special/cospi":"@stdlib/math-iter-special-cospi","@stdlib/iter/counter":"@stdlib/iter-counter","@stdlib/math/iter/special/covercos":"@stdlib/math-iter-special-covercos","@stdlib/math/iter/special/coversin":"@stdlib/math-iter-special-coversin","@stdlib/math/iter/sequences/cubes":"@stdlib/math-iter-sequences-cubes","@stdlib/stats/iter/cugmean":"@stdlib/stats-iter-cugmean","@stdlib/stats/iter/cuhmean":"@stdlib/stats-iter-cuhmean","@stdlib/stats/iter/cumax":"@stdlib/stats-iter-cumax","@stdlib/stats/iter/cumaxabs":"@stdlib/stats-iter-cumaxabs","@stdlib/stats/iter/cumean":"@stdlib/stats-iter-cumean","@stdlib/stats/iter/cumeanabs":"@stdlib/stats-iter-cumeanabs","@stdlib/stats/iter/cumeanabs2":"@stdlib/stats-iter-cumeanabs2","@stdlib/stats/iter/cumidrange":"@stdlib/stats-iter-cumidrange","@stdlib/stats/iter/cumin":"@stdlib/stats-iter-cumin","@stdlib/stats/iter/cuminabs":"@stdlib/stats-iter-cuminabs","@stdlib/stats/iter/cuprod":"@stdlib/stats-iter-cuprod","@stdlib/stats/iter/curange":"@stdlib/stats-iter-curange","@stdlib/stats/iter/cusum":"@stdlib/stats-iter-cusum","@stdlib/stats/iter/cusumabs":"@stdlib/stats-iter-cusumabs","@stdlib/stats/iter/cusumabs2":"@stdlib/stats-iter-cusumabs2","@stdlib/iter/datespace":"@stdlib/iter-datespace","@stdlib/iter/dedupe":"@stdlib/iter-dedupe","@stdlib/iter/dedupe-by":"@stdlib/iter-dedupe-by","@stdlib/math/iter/special/deg2rad":"@stdlib/math-iter-special-deg2rad","@stdlib/math/iter/special/digamma":"@stdlib/math-iter-special-digamma","@stdlib/simulate/iter/dirac-comb":"@stdlib/simulate-iter-dirac-comb","@stdlib/math/iter/special/dirac-delta":"@stdlib/math-iter-special-dirac-delta","@stdlib/math/iter/ops/divide":"@stdlib/math-iter-ops-divide","@stdlib/iter/do-until-each":"@stdlib/iter-do-until-each","@stdlib/iter/do-while-each":"@stdlib/iter-do-while-each","@stdlib/math/iter/special/ellipe":"@stdlib/math-iter-special-ellipe","@stdlib/math/iter/special/ellipk":"@stdlib/math-iter-special-ellipk","@stdlib/iter/empty":"@stdlib/iter-empty","@stdlib/math/iter/special/erf":"@stdlib/math-iter-special-erf","@stdlib/math/iter/special/erfc":"@stdlib/math-iter-special-erfc","@stdlib/math/iter/special/erfcinv":"@stdlib/math-iter-special-erfcinv","@stdlib/math/iter/special/erfinv":"@stdlib/math-iter-special-erfinv","@stdlib/math/iter/special/dirichlet-eta":"@stdlib/math-iter-special-dirichlet-eta","@stdlib/math/iter/sequences/even-integers":"@stdlib/math-iter-sequences-even-integers","@stdlib/iter/every":"@stdlib/iter-every","@stdlib/iter/every-by":"@stdlib/iter-every-by","@stdlib/math/iter/special/exp":"@stdlib/math-iter-special-exp","@stdlib/math/iter/special/exp2":"@stdlib/math-iter-special-exp2","@stdlib/math/iter/special/exp10":"@stdlib/math-iter-special-exp10","@stdlib/math/iter/special/expit":"@stdlib/math-iter-special-expit","@stdlib/math/iter/special/expm1":"@stdlib/math-iter-special-expm1","@stdlib/math/iter/special/expm1rel":"@stdlib/math-iter-special-expm1rel","@stdlib/math/iter/special/factorial":"@stdlib/math-iter-special-factorial","@stdlib/math/iter/special/factorialln":"@stdlib/math-iter-special-factorialln","@stdlib/math/iter/sequences/factorials":"@stdlib/math-iter-sequences-factorials","@stdlib/math/iter/sequences/fibonacci":"@stdlib/math-iter-sequences-fibonacci","@stdlib/math/iter/sequences/fifth-powers":"@stdlib/math-iter-sequences-fifth-powers","@stdlib/iter/fill":"@stdlib/iter-fill","@stdlib/iter/filter":"@stdlib/iter-filter","@stdlib/iter/filter-map":"@stdlib/iter-filter-map","@stdlib/iter/first":"@stdlib/iter-first","@stdlib/simulate/iter/flat-top-pulse":"@stdlib/simulate-iter-flat-top-pulse","@stdlib/math/iter/special/floor":"@stdlib/math-iter-special-floor","@stdlib/math/iter/special/floor2":"@stdlib/math-iter-special-floor2","@stdlib/math/iter/special/floor10":"@stdlib/math-iter-special-floor10","@stdlib/iter/flow":"@stdlib/iter-flow","@stdlib/iter/for-each":"@stdlib/iter-for-each","@stdlib/math/iter/sequences/fourth-powers":"@stdlib/math-iter-sequences-fourth-powers","@stdlib/math/iter/special/fresnelc":"@stdlib/math-iter-special-fresnelc","@stdlib/math/iter/special/fresnels":"@stdlib/math-iter-special-fresnels","@stdlib/math/iter/special/gamma":"@stdlib/math-iter-special-gamma","@stdlib/math/iter/special/gamma1pm1":"@stdlib/math-iter-special-gamma1pm1","@stdlib/math/iter/special/gammaln":"@stdlib/math-iter-special-gammaln","@stdlib/math/iter/special/hacovercos":"@stdlib/math-iter-special-hacovercos","@stdlib/math/iter/special/hacoversin":"@stdlib/math-iter-special-hacoversin","@stdlib/simulate/iter/hann-pulse":"@stdlib/simulate-iter-hann-pulse","@stdlib/math/iter/special/havercos":"@stdlib/math-iter-special-havercos","@stdlib/math/iter/special/haversin":"@stdlib/math-iter-special-haversin","@stdlib/iter/head":"@stdlib/iter-head","@stdlib/iter/incrspace":"@stdlib/iter-incrspace","@stdlib/math/iter/sequences/integers":"@stdlib/math-iter-sequences-integers","@stdlib/iter/intersection":"@stdlib/iter-intersection","@stdlib/iter/intersection-by-hash":"@stdlib/iter-intersection-by-hash","@stdlib/math/iter/special/inv":"@stdlib/math-iter-special-inv","@stdlib/simulate/iter/lanczos-pulse":"@stdlib/simulate-iter-lanczos-pulse","@stdlib/iter/last":"@stdlib/iter-last","@stdlib/iter/length":"@stdlib/iter-length","@stdlib/iter/linspace":"@stdlib/iter-linspace","@stdlib/math/iter/special/ln":"@stdlib/math-iter-special-ln","@stdlib/math/iter/special/log":"@stdlib/math-iter-special-log","@stdlib/math/iter/special/log1mexp":"@stdlib/math-iter-special-log1mexp","@stdlib/math/iter/special/log1p":"@stdlib/math-iter-special-log1p","@stdlib/math/iter/special/log1pexp":"@stdlib/math-iter-special-log1pexp","@stdlib/math/iter/special/log2":"@stdlib/math-iter-special-log2","@stdlib/math/iter/special/log10":"@stdlib/math-iter-special-log10","@stdlib/math/iter/special/logit":"@stdlib/math-iter-special-logit","@stdlib/iter/logspace":"@stdlib/iter-logspace","@stdlib/math/iter/sequences/lucas":"@stdlib/math-iter-sequences-lucas","@stdlib/iter/map":"@stdlib/iter-map","@stdlib/iter/mapn":"@stdlib/iter-mapn","@stdlib/stats/iter/max":"@stdlib/stats-iter-max","@stdlib/stats/iter/maxabs":"@stdlib/stats-iter-maxabs","@stdlib/stats/iter/mean":"@stdlib/stats-iter-mean","@stdlib/stats/iter/meanabs":"@stdlib/stats-iter-meanabs","@stdlib/stats/iter/meanabs2":"@stdlib/stats-iter-meanabs2","@stdlib/stats/iter/midrange":"@stdlib/stats-iter-midrange","@stdlib/stats/iter/min":"@stdlib/stats-iter-min","@stdlib/stats/iter/minabs":"@stdlib/stats-iter-minabs","@stdlib/stats/iter/mmax":"@stdlib/stats-iter-mmax","@stdlib/stats/iter/mmaxabs":"@stdlib/stats-iter-mmaxabs","@stdlib/stats/iter/mmean":"@stdlib/stats-iter-mmean","@stdlib/stats/iter/mmeanabs":"@stdlib/stats-iter-mmeanabs","@stdlib/stats/iter/mmeanabs2":"@stdlib/stats-iter-mmeanabs2","@stdlib/stats/iter/mmidrange":"@stdlib/stats-iter-mmidrange","@stdlib/stats/iter/mmin":"@stdlib/stats-iter-mmin","@stdlib/stats/iter/mminabs":"@stdlib/stats-iter-mminabs","@stdlib/math/iter/ops/mod":"@stdlib/math-iter-ops-mod","@stdlib/stats/iter/mprod":"@stdlib/stats-iter-mprod","@stdlib/stats/iter/mrange":"@stdlib/stats-iter-mrange","@stdlib/stats/iter/msum":"@stdlib/stats-iter-msum","@stdlib/stats/iter/msumabs":"@stdlib/stats-iter-msumabs","@stdlib/stats/iter/msumabs2":"@stdlib/stats-iter-msumabs2","@stdlib/math/iter/ops/multiply":"@stdlib/math-iter-ops-multiply","@stdlib/math/iter/sequences/negafibonacci":"@stdlib/math-iter-sequences-negafibonacci","@stdlib/math/iter/sequences/negalucas":"@stdlib/math-iter-sequences-negalucas","@stdlib/math/iter/sequences/negative-even-integers":"@stdlib/math-iter-sequences-negative-even-integers","@stdlib/math/iter/sequences/negative-integers":"@stdlib/math-iter-sequences-negative-integers","@stdlib/math/iter/sequences/negative-odd-integers":"@stdlib/math-iter-sequences-negative-odd-integers","@stdlib/iter/none":"@stdlib/iter-none","@stdlib/iter/none-by":"@stdlib/iter-none-by","@stdlib/math/iter/sequences/nonfibonacci":"@stdlib/math-iter-sequences-nonfibonacci","@stdlib/math/iter/sequences/nonnegative-even-integers":"@stdlib/math-iter-sequences-nonnegative-even-integers","@stdlib/math/iter/sequences/nonnegative-integers":"@stdlib/math-iter-sequences-nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-even-integers":"@stdlib/math-iter-sequences-nonpositive-even-integers","@stdlib/math/iter/sequences/nonpositive-integers":"@stdlib/math-iter-sequences-nonpositive-integers","@stdlib/math/iter/sequences/nonsquares":"@stdlib/math-iter-sequences-nonsquares","@stdlib/iter/nth":"@stdlib/iter-nth","@stdlib/math/iter/sequences/odd-integers":"@stdlib/math-iter-sequences-odd-integers","@stdlib/simulate/iter/periodic-sinc":"@stdlib/simulate-iter-periodic-sinc","@stdlib/iter/pipeline":"@stdlib/iter-pipeline","@stdlib/iter/pop":"@stdlib/iter-pop","@stdlib/math/iter/sequences/positive-even-integers":"@stdlib/math-iter-sequences-positive-even-integers","@stdlib/math/iter/sequences/positive-integers":"@stdlib/math-iter-sequences-positive-integers","@stdlib/math/iter/sequences/positive-odd-integers":"@stdlib/math-iter-sequences-positive-odd-integers","@stdlib/math/iter/special/pow":"@stdlib/math-iter-special-pow","@stdlib/math/iter/sequences/primes":"@stdlib/math-iter-sequences-primes","@stdlib/stats/iter/prod":"@stdlib/stats-iter-prod","@stdlib/simulate/iter/pulse":"@stdlib/simulate-iter-pulse","@stdlib/iter/push":"@stdlib/iter-push","@stdlib/math/iter/special/rad2deg":"@stdlib/math-iter-special-rad2deg","@stdlib/math/iter/special/ramp":"@stdlib/math-iter-special-ramp","@stdlib/stats/iter/range":"@stdlib/stats-iter-range","@stdlib/iter/reject":"@stdlib/iter-reject","@stdlib/iter/replicate":"@stdlib/iter-replicate","@stdlib/iter/replicate-by":"@stdlib/iter-replicate-by","@stdlib/math/iter/special/round":"@stdlib/math-iter-special-round","@stdlib/math/iter/special/round2":"@stdlib/math-iter-special-round2","@stdlib/math/iter/special/round10":"@stdlib/math-iter-special-round10","@stdlib/math/iter/special/rsqrt":"@stdlib/math-iter-special-rsqrt","@stdlib/simulate/iter/sawtooth-wave":"@stdlib/simulate-iter-sawtooth-wave","@stdlib/iter/shift":"@stdlib/iter-shift","@stdlib/math/iter/special/signum":"@stdlib/math-iter-special-signum","@stdlib/math/iter/special/sin":"@stdlib/math-iter-special-sin","@stdlib/math/iter/special/sinc":"@stdlib/math-iter-special-sinc","@stdlib/simulate/iter/sine-wave":"@stdlib/simulate-iter-sine-wave","@stdlib/math/iter/special/sinh":"@stdlib/math-iter-special-sinh","@stdlib/math/iter/special/sinpi":"@stdlib/math-iter-special-sinpi","@stdlib/iter/slice":"@stdlib/iter-slice","@stdlib/iter/some":"@stdlib/iter-some","@stdlib/iter/some-by":"@stdlib/iter-some-by","@stdlib/math/iter/special/spence":"@stdlib/math-iter-special-spence","@stdlib/math/iter/special/sqrt":"@stdlib/math-iter-special-sqrt","@stdlib/math/iter/special/sqrt1pm1":"@stdlib/math-iter-special-sqrt1pm1","@stdlib/math/iter/sequences/squared-triangular":"@stdlib/math-iter-sequences-squared-triangular","@stdlib/math/iter/sequences/squares":"@stdlib/math-iter-sequences-squares","@stdlib/simulate/iter/square-wave":"@stdlib/simulate-iter-square-wave","@stdlib/stats/iter/stdev":"@stdlib/stats-iter-stdev","@stdlib/iter/step":"@stdlib/iter-step","@stdlib/iter/strided":"@stdlib/iter-strided","@stdlib/iter/strided-by":"@stdlib/iter-strided-by","@stdlib/math/iter/ops/subtract":"@stdlib/math-iter-ops-subtract","@stdlib/stats/iter/sum":"@stdlib/stats-iter-sum","@stdlib/stats/iter/sumabs":"@stdlib/stats-iter-sumabs","@stdlib/stats/iter/sumabs2":"@stdlib/stats-iter-sumabs2","@stdlib/math/iter/special/tan":"@stdlib/math-iter-special-tan","@stdlib/math/iter/special/tanh":"@stdlib/math-iter-special-tanh","@stdlib/iter/pipeline-thunk":"@stdlib/iter-pipeline-thunk","@stdlib/simulate/iter/triangle-wave":"@stdlib/simulate-iter-triangle-wave","@stdlib/math/iter/sequences/triangular":"@stdlib/math-iter-sequences-triangular","@stdlib/math/iter/sequences/tribonacci":"@stdlib/math-iter-sequences-tribonacci","@stdlib/math/iter/special/trigamma":"@stdlib/math-iter-special-trigamma","@stdlib/math/iter/special/trunc":"@stdlib/math-iter-special-trunc","@stdlib/math/iter/special/trunc2":"@stdlib/math-iter-special-trunc2","@stdlib/math/iter/special/trunc10":"@stdlib/math-iter-special-trunc10","@stdlib/iter/union":"@stdlib/iter-union","@stdlib/iter/unique":"@stdlib/iter-unique","@stdlib/iter/unique-by":"@stdlib/iter-unique-by","@stdlib/iter/unique-by-hash":"@stdlib/iter-unique-by-hash","@stdlib/iter/unitspace":"@stdlib/iter-unitspace","@stdlib/iter/unshift":"@stdlib/iter-unshift","@stdlib/iter/until-each":"@stdlib/iter-until-each","@stdlib/stats/iter/variance":"@stdlib/stats-iter-variance","@stdlib/math/iter/special/vercos":"@stdlib/math-iter-special-vercos","@stdlib/math/iter/special/versin":"@stdlib/math-iter-special-versin","@stdlib/iter/while-each":"@stdlib/iter-while-each","@stdlib/math/iter/special/riemann-zeta":"@stdlib/math-iter-special-riemann-zeta","@stdlib/streams/node/join":"@stdlib/streams-node-join","@stdlib/stats/kde2d":"@stdlib/stats-kde2d","@stdlib/string/kebabcase":"@stdlib/string-kebabcase","@stdlib/utils/key-by":"@stdlib/utils-key-by","@stdlib/utils/key-by-right":"@stdlib/utils-key-by-right","@stdlib/utils/keys-in":"@stdlib/utils-keys-in","@stdlib/stats/kruskal-test":"@stdlib/stats-kruskal-test","@stdlib/stats/kstest":"@stdlib/stats-kstest","@stdlib/string/last":"@stdlib/string-last","@stdlib/nlp/lda":"@stdlib/nlp-lda","@stdlib/stats/levene-test":"@stdlib/stats-levene-test","@stdlib/dstructs/linked-list":"@stdlib/dstructs-linked-list","@stdlib/array/linspace":"@stdlib/array-linspace","@stdlib/datasets/liu-negative-opinion-words-en":"@stdlib/datasets-liu-negative-opinion-words-en","@stdlib/datasets/liu-positive-opinion-words-en":"@stdlib/datasets-liu-positive-opinion-words-en","@stdlib/constants/float64/ln-half":"@stdlib/constants-float64-ln-half","@stdlib/constants/float64/ln-pi":"@stdlib/constants-float64-ln-pi","@stdlib/constants/float64/ln-sqrt-two-pi":"@stdlib/constants-float64-ln-sqrt-two-pi","@stdlib/constants/float64/ln-two-pi":"@stdlib/constants-float64-ln-two-pi","@stdlib/constants/float64/ln-two":"@stdlib/constants-float64-ln-two","@stdlib/constants/float64/ln-ten":"@stdlib/constants-float64-ln-ten","@stdlib/constants/float64/log2-e":"@stdlib/constants-float64-log2-e","@stdlib/constants/float64/log10-e":"@stdlib/constants-float64-log10-e","@stdlib/array/logspace":"@stdlib/array-logspace","@stdlib/string/lowercase":"@stdlib/string-lowercase","@stdlib/utils/lowercase-keys":"@stdlib/utils-lowercase-keys","@stdlib/stats/lowess":"@stdlib/stats-lowess","@stdlib/string/left-pad":"@stdlib/string-left-pad","@stdlib/string/left-trim":"@stdlib/string-left-trim","@stdlib/string/left-trim-n":"@stdlib/string-left-trim-n","@stdlib/datasets/male-first-names-en":"@stdlib/datasets-male-first-names-en","@stdlib/utils/map":"@stdlib/utils-map","@stdlib/utils/map2":"@stdlib/utils-map2","@stdlib/utils/map2d":"@stdlib/utils-map2d","@stdlib/utils/map2-right":"@stdlib/utils-map2-right","@stdlib/utils/map3d":"@stdlib/utils-map3d","@stdlib/utils/map4d":"@stdlib/utils-map4d","@stdlib/utils/map5d":"@stdlib/utils-map5d","@stdlib/utils/map-arguments":"@stdlib/utils-map-arguments","@stdlib/utils/map-function":"@stdlib/utils-map-function","@stdlib/utils/async/map-function":"@stdlib/utils-async-map-function","@stdlib/utils/map-keys":"@stdlib/utils-map-keys","@stdlib/utils/async/map-keys":"@stdlib/utils-async-map-keys","@stdlib/utils/map-reduce":"@stdlib/utils-map-reduce","@stdlib/utils/map-reduce-right":"@stdlib/utils-map-reduce-right","@stdlib/utils/map-right":"@stdlib/utils-map-right","@stdlib/utils/map-values":"@stdlib/utils-map-values","@stdlib/utils/async/map-values":"@stdlib/utils-async-map-values","@stdlib/utils/mask-arguments":"@stdlib/utils-mask-arguments","@stdlib/constants/array/max-array-length":"@stdlib/constants-array-max-array-length","@stdlib/constants/array/max-typed-array-length":"@stdlib/constants-array-max-typed-array-length","@stdlib/ndarray/maybe-broadcast-array":"@stdlib/ndarray-maybe-broadcast-array","@stdlib/ndarray/maybe-broadcast-arrays":"@stdlib/ndarray-maybe-broadcast-arrays","@stdlib/utils/memoize":"@stdlib/utils-memoize","@stdlib/utils/merge":"@stdlib/utils-merge","@stdlib/constants/time/milliseconds-in-day":"@stdlib/constants-time-milliseconds-in-day","@stdlib/constants/time/milliseconds-in-hour":"@stdlib/constants-time-milliseconds-in-hour","@stdlib/constants/time/milliseconds-in-minute":"@stdlib/constants-time-milliseconds-in-minute","@stdlib/constants/time/milliseconds-in-second":"@stdlib/constants-time-milliseconds-in-second","@stdlib/constants/time/milliseconds-in-week":"@stdlib/constants-time-milliseconds-in-week","@stdlib/datasets/minard-napoleons-march":"@stdlib/datasets-minard-napoleons-march","@stdlib/constants/time/minutes-in-day":"@stdlib/constants-time-minutes-in-day","@stdlib/constants/time/minutes-in-hour":"@stdlib/constants-time-minutes-in-hour","@stdlib/constants/time/minutes-in-week":"@stdlib/constants-time-minutes-in-week","@stdlib/time/minutes-in-month":"@stdlib/time-minutes-in-month","@stdlib/time/minutes-in-year":"@stdlib/time-minutes-in-year","@stdlib/datasets/moby-dick":"@stdlib/datasets-moby-dick","@stdlib/datasets/month-names-en":"@stdlib/datasets-month-names-en","@stdlib/constants/time/months-in-year":"@stdlib/constants-time-months-in-year","@stdlib/utils/move-property":"@stdlib/utils-move-property","@stdlib/slice/multi":"@stdlib/slice-multi","@stdlib/dstructs/named-typed-tuple":"@stdlib/dstructs-named-typed-tuple","@stdlib/constants/float64/nan":"@stdlib/constants-float64-nan","@stdlib/utils/nary-function":"@stdlib/utils-nary-function","@stdlib/utils/native-class":"@stdlib/utils-native-class","@stdlib/ndarray/ctor":"@stdlib/ndarray-ctor","@stdlib/ndarray/to-array":"@stdlib/ndarray-to-array","@stdlib/ndarray/to-fancy":"@stdlib/ndarray-to-fancy","@stdlib/ndarray/to-json":"@stdlib/ndarray-to-json","@stdlib/ndarray/casting-modes":"@stdlib/ndarray-casting-modes","@stdlib/ndarray/data-buffer":"@stdlib/ndarray-data-buffer","@stdlib/ndarray/dtype":"@stdlib/ndarray-dtype","@stdlib/ndarray/dtypes":"@stdlib/ndarray-dtypes","@stdlib/ndarray/dispatch":"@stdlib/ndarray-dispatch","@stdlib/ndarray/flag":"@stdlib/ndarray-flag","@stdlib/ndarray/flags":"@stdlib/ndarray-flags","@stdlib/ndarray/index-modes":"@stdlib/ndarray-index-modes","@stdlib/ndarray/ndarraylike2ndarray":"@stdlib/ndarray-ndarraylike2ndarray","@stdlib/ndarray/min-dtype":"@stdlib/ndarray-min-dtype","@stdlib/ndarray/mostly-safe-casts":"@stdlib/ndarray-mostly-safe-casts","@stdlib/ndarray/next-dtype":"@stdlib/ndarray-next-dtype","@stdlib/ndarray/offset":"@stdlib/ndarray-offset","@stdlib/ndarray/order":"@stdlib/ndarray-order","@stdlib/ndarray/orders":"@stdlib/ndarray-orders","@stdlib/ndarray/promotion-rules":"@stdlib/ndarray-promotion-rules","@stdlib/ndarray/safe-casts":"@stdlib/ndarray-safe-casts","@stdlib/ndarray/same-kind-casts":"@stdlib/ndarray-same-kind-casts","@stdlib/ndarray/shape":"@stdlib/ndarray-shape","@stdlib/ndarray/stride":"@stdlib/ndarray-stride","@stdlib/ndarray/strides":"@stdlib/ndarray-strides","@stdlib/ndarray/at":"@stdlib/ndarray-at","@stdlib/ndarray/empty":"@stdlib/ndarray-empty","@stdlib/ndarray/empty-like":"@stdlib/ndarray-empty-like","@stdlib/ndarray/filter":"@stdlib/ndarray-filter","@stdlib/ndarray/filter-map":"@stdlib/ndarray-filter-map","@stdlib/ndarray/for-each":"@stdlib/ndarray-for-each","@stdlib/ndarray/ndims":"@stdlib/ndarray-ndims","@stdlib/ndarray/index":"@stdlib/ndarray-index","@stdlib/ndarray/iter/to-array-each":"@stdlib/ndarray-iter-to-array-each","@stdlib/ndarray/iter/column-entries":"@stdlib/ndarray-iter-column-entries","@stdlib/ndarray/iter/columns":"@stdlib/ndarray-iter-columns","@stdlib/ndarray/iter/entries":"@stdlib/ndarray-iter-entries","@stdlib/ndarray/iter/indices":"@stdlib/ndarray-iter-indices","@stdlib/ndarray/iter/interleave-subarrays":"@stdlib/ndarray-iter-interleave-subarrays","@stdlib/ndarray/iter/matrices":"@stdlib/ndarray-iter-matrices","@stdlib/ndarray/iter/matrix-entries":"@stdlib/ndarray-iter-matrix-entries","@stdlib/ndarray/iter/row-entries":"@stdlib/ndarray-iter-row-entries","@stdlib/ndarray/iter/rows":"@stdlib/ndarray-iter-rows","@stdlib/ndarray/iter/select-dimension":"@stdlib/ndarray-iter-select-dimension","@stdlib/ndarray/iter/stacks":"@stdlib/ndarray-iter-stacks","@stdlib/ndarray/iter/subarrays":"@stdlib/ndarray-iter-subarrays","@stdlib/ndarray/iter/values":"@stdlib/ndarray-iter-values","@stdlib/ndarray/map":"@stdlib/ndarray-map","@stdlib/ndarray/reject":"@stdlib/ndarray-reject","@stdlib/ndarray/slice":"@stdlib/ndarray-slice","@stdlib/ndarray/slice-assign":"@stdlib/ndarray-slice-assign","@stdlib/ndarray/slice-dimension":"@stdlib/ndarray-slice-dimension","@stdlib/ndarray/slice-dimension-from":"@stdlib/ndarray-slice-dimension-from","@stdlib/ndarray/slice-dimension-to":"@stdlib/ndarray-slice-dimension-to","@stdlib/ndarray/slice-from":"@stdlib/ndarray-slice-from","@stdlib/ndarray/slice-to":"@stdlib/ndarray-slice-to","@stdlib/ndarray/zeros":"@stdlib/ndarray-zeros","@stdlib/ndarray/zeros-like":"@stdlib/ndarray-zeros-like","@stdlib/string/next-grapheme-cluster-break":"@stdlib/string-next-grapheme-cluster-break","@stdlib/utils/next-tick":"@stdlib/utils-next-tick","@stdlib/datasets/nightingales-rose":"@stdlib/datasets-nightingales-rose","@stdlib/constants/float64/ninf":"@stdlib/constants-float64-ninf","@stdlib/process/node-version":"@stdlib/process-node-version","@stdlib/utils/none":"@stdlib/utils-none","@stdlib/utils/none-by":"@stdlib/utils-none-by","@stdlib/utils/async/none-by":"@stdlib/utils-async-none-by","@stdlib/utils/none-by-right":"@stdlib/utils-none-by-right","@stdlib/utils/async/none-by-right":"@stdlib/utils-async-none-by-right","@stdlib/utils/none-in-by":"@stdlib/utils-none-in-by","@stdlib/utils/nonenumerable-properties":"@stdlib/utils-nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in":"@stdlib/utils-nonenumerable-properties-in","@stdlib/utils/nonenumerable-property-names":"@stdlib/utils-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in":"@stdlib/utils-nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols":"@stdlib/utils-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in":"@stdlib/utils-nonenumerable-property-symbols-in","@stdlib/utils/none-own-by":"@stdlib/utils-none-own-by","@stdlib/utils/nonindex-keys":"@stdlib/utils-nonindex-keys","@stdlib/utils/noop":"@stdlib/utils-noop","@stdlib/time/now":"@stdlib/time-now","@stdlib/os/num-cpus":"@stdlib/os-num-cpus","@stdlib/string/num2words":"@stdlib/string-num2words","@stdlib/number/ctor":"@stdlib/number-ctor","@stdlib/ndarray/numel":"@stdlib/ndarray-numel","@stdlib/ndarray/numel-dimension":"@stdlib/ndarray-numel-dimension","@stdlib/string/num-grapheme-clusters":"@stdlib/string-num-grapheme-clusters","@stdlib/object/ctor":"@stdlib/object-ctor","@stdlib/utils/entries":"@stdlib/utils-entries","@stdlib/utils/entries-in":"@stdlib/utils-entries-in","@stdlib/utils/from-entries":"@stdlib/utils-from-entries","@stdlib/utils/object-inverse":"@stdlib/utils-object-inverse","@stdlib/utils/object-inverse-by":"@stdlib/utils-object-inverse-by","@stdlib/utils/keys":"@stdlib/utils-keys","@stdlib/utils/values":"@stdlib/utils-values","@stdlib/utils/values-in":"@stdlib/utils-values-in","@stdlib/utils/omit":"@stdlib/utils-omit","@stdlib/utils/omit-by":"@stdlib/utils-omit-by","@stdlib/fs/open":"@stdlib/fs-open","@stdlib/utils/open-url":"@stdlib/utils-open-url","@stdlib/nlp/ordinalize":"@stdlib/nlp-ordinalize","@stdlib/datasets/pace-boston-house-prices":"@stdlib/datasets-pace-boston-house-prices","@stdlib/string/pad":"@stdlib/string-pad","@stdlib/stats/padjust":"@stdlib/stats-padjust","@stdlib/utils/papply":"@stdlib/utils-papply","@stdlib/utils/papply-right":"@stdlib/utils-papply-right","@stdlib/utils/parallel":"@stdlib/utils-parallel","@stdlib/utils/parse-json":"@stdlib/utils-parse-json","@stdlib/string/pascalcase":"@stdlib/string-pascalcase","@stdlib/constants/path/delimiter":"@stdlib/constants-path-delimiter","@stdlib/constants/path/delimiter-posix":"@stdlib/constants-path-delimiter-posix","@stdlib/constants/path/delimiter-win32":"@stdlib/constants-path-delimiter-win32","@stdlib/constants/path/sep":"@stdlib/constants-path-sep","@stdlib/constants/path/sep-posix":"@stdlib/constants-path-sep-posix","@stdlib/constants/path/sep-win32":"@stdlib/constants-path-sep-win32","@stdlib/stats/pcorrtest":"@stdlib/stats-pcorrtest","@stdlib/string/percent-encode":"@stdlib/string-percent-encode","@stdlib/constants/float64/phi":"@stdlib/constants-float64-phi","@stdlib/constants/float64/pi":"@stdlib/constants-float64-pi","@stdlib/constants/float64/pi-squared":"@stdlib/constants-float64-pi-squared","@stdlib/utils/pick":"@stdlib/utils-pick","@stdlib/utils/pick-arguments":"@stdlib/utils-pick-arguments","@stdlib/utils/pick-by":"@stdlib/utils-pick-by","@stdlib/constants/float64/pinf":"@stdlib/constants-float64-pinf","@stdlib/namespace/pkg2alias":"@stdlib/namespace-pkg2alias","@stdlib/namespace/pkg2related":"@stdlib/namespace-pkg2related","@stdlib/namespace/pkg2standalone":"@stdlib/namespace-pkg2standalone","@stdlib/os/platform":"@stdlib/os-platform","@stdlib/plot":"@stdlib/plot","@stdlib/plot/ctor":"@stdlib/plot-ctor","@stdlib/utils/pluck":"@stdlib/utils-pluck","@stdlib/utils/pop":"@stdlib/utils-pop","@stdlib/nlp/porter-stemmer":"@stdlib/nlp-porter-stemmer","@stdlib/utils/prepend":"@stdlib/utils-prepend","@stdlib/string/prev-grapheme-cluster-break":"@stdlib/string-prev-grapheme-cluster-break","@stdlib/datasets/primes-100k":"@stdlib/datasets-primes-100k","@stdlib/utils/properties":"@stdlib/utils-properties","@stdlib/utils/properties-in":"@stdlib/utils-properties-in","@stdlib/utils/property-descriptor":"@stdlib/utils-property-descriptor","@stdlib/utils/property-descriptor-in":"@stdlib/utils-property-descriptor-in","@stdlib/utils/property-descriptors":"@stdlib/utils-property-descriptors","@stdlib/utils/property-descriptors-in":"@stdlib/utils-property-descriptors-in","@stdlib/utils/property-names":"@stdlib/utils-property-names","@stdlib/utils/property-names-in":"@stdlib/utils-property-names-in","@stdlib/utils/property-symbols":"@stdlib/utils-property-symbols","@stdlib/utils/property-symbols-in":"@stdlib/utils-property-symbols-in","@stdlib/proxy/ctor":"@stdlib/proxy-ctor","@stdlib/utils/push":"@stdlib/utils-push","@stdlib/time/quarter-of-year":"@stdlib/time-quarter-of-year","@stdlib/random/array/arcsine":"@stdlib/random-array-arcsine","@stdlib/random/array/bernoulli":"@stdlib/random-array-bernoulli","@stdlib/random/array/beta":"@stdlib/random-array-beta","@stdlib/random/array/betaprime":"@stdlib/random-array-betaprime","@stdlib/random/array/binomial":"@stdlib/random-array-binomial","@stdlib/random/array/cauchy":"@stdlib/random-array-cauchy","@stdlib/random/array/chi":"@stdlib/random-array-chi","@stdlib/random/array/chisquare":"@stdlib/random-array-chisquare","@stdlib/random/array/cosine":"@stdlib/random-array-cosine","@stdlib/random/array/discrete-uniform":"@stdlib/random-array-discrete-uniform","@stdlib/random/array/erlang":"@stdlib/random-array-erlang","@stdlib/random/array/exponential":"@stdlib/random-array-exponential","@stdlib/random/array/f":"@stdlib/random-array-f","@stdlib/random/array/frechet":"@stdlib/random-array-frechet","@stdlib/random/array/gamma":"@stdlib/random-array-gamma","@stdlib/random/array/geometric":"@stdlib/random-array-geometric","@stdlib/random/array/gumbel":"@stdlib/random-array-gumbel","@stdlib/random/array/hypergeometric":"@stdlib/random-array-hypergeometric","@stdlib/random/array/invgamma":"@stdlib/random-array-invgamma","@stdlib/random/array/kumaraswamy":"@stdlib/random-array-kumaraswamy","@stdlib/random/array/laplace":"@stdlib/random-array-laplace","@stdlib/random/array/levy":"@stdlib/random-array-levy","@stdlib/random/array/logistic":"@stdlib/random-array-logistic","@stdlib/random/array/lognormal":"@stdlib/random-array-lognormal","@stdlib/random/array/minstd":"@stdlib/random-array-minstd","@stdlib/random/array/minstd-shuffle":"@stdlib/random-array-minstd-shuffle","@stdlib/random/array/mt19937":"@stdlib/random-array-mt19937","@stdlib/random/array/negative-binomial":"@stdlib/random-array-negative-binomial","@stdlib/random/array/normal":"@stdlib/random-array-normal","@stdlib/random/array/pareto-type1":"@stdlib/random-array-pareto-type1","@stdlib/random/array/poisson":"@stdlib/random-array-poisson","@stdlib/random/array/randu":"@stdlib/random-array-randu","@stdlib/random/array/rayleigh":"@stdlib/random-array-rayleigh","@stdlib/random/array/t":"@stdlib/random-array-t","@stdlib/random/array/triangular":"@stdlib/random-array-triangular","@stdlib/random/array/uniform":"@stdlib/random-array-uniform","@stdlib/random/array/weibull":"@stdlib/random-array-weibull","@stdlib/random/iter/arcsine":"@stdlib/random-iter-arcsine","@stdlib/random/iter/bernoulli":"@stdlib/random-iter-bernoulli","@stdlib/random/iter/beta":"@stdlib/random-iter-beta","@stdlib/random/iter/betaprime":"@stdlib/random-iter-betaprime","@stdlib/random/iter/binomial":"@stdlib/random-iter-binomial","@stdlib/random/iter/box-muller":"@stdlib/random-iter-box-muller","@stdlib/random/iter/cauchy":"@stdlib/random-iter-cauchy","@stdlib/random/iter/chi":"@stdlib/random-iter-chi","@stdlib/random/iter/chisquare":"@stdlib/random-iter-chisquare","@stdlib/random/iter/cosine":"@stdlib/random-iter-cosine","@stdlib/random/iter/discrete-uniform":"@stdlib/random-iter-discrete-uniform","@stdlib/random/iter/erlang":"@stdlib/random-iter-erlang","@stdlib/random/iter/exponential":"@stdlib/random-iter-exponential","@stdlib/random/iter/f":"@stdlib/random-iter-f","@stdlib/random/iter/frechet":"@stdlib/random-iter-frechet","@stdlib/random/iter/gamma":"@stdlib/random-iter-gamma","@stdlib/random/iter/geometric":"@stdlib/random-iter-geometric","@stdlib/random/iter/gumbel":"@stdlib/random-iter-gumbel","@stdlib/random/iter/hypergeometric":"@stdlib/random-iter-hypergeometric","@stdlib/random/iter/improved-ziggurat":"@stdlib/random-iter-improved-ziggurat","@stdlib/random/iter/invgamma":"@stdlib/random-iter-invgamma","@stdlib/random/iter/kumaraswamy":"@stdlib/random-iter-kumaraswamy","@stdlib/random/iter/laplace":"@stdlib/random-iter-laplace","@stdlib/random/iter/levy":"@stdlib/random-iter-levy","@stdlib/random/iter/logistic":"@stdlib/random-iter-logistic","@stdlib/random/iter/lognormal":"@stdlib/random-iter-lognormal","@stdlib/random/iter/minstd":"@stdlib/random-iter-minstd","@stdlib/random/iter/minstd-shuffle":"@stdlib/random-iter-minstd-shuffle","@stdlib/random/iter/mt19937":"@stdlib/random-iter-mt19937","@stdlib/random/iter/negative-binomial":"@stdlib/random-iter-negative-binomial","@stdlib/random/iter/normal":"@stdlib/random-iter-normal","@stdlib/random/iter/pareto-type1":"@stdlib/random-iter-pareto-type1","@stdlib/random/iter/poisson":"@stdlib/random-iter-poisson","@stdlib/random/iter/randi":"@stdlib/random-iter-randi","@stdlib/random/iter/randn":"@stdlib/random-iter-randn","@stdlib/random/iter/randu":"@stdlib/random-iter-randu","@stdlib/random/iter/rayleigh":"@stdlib/random-iter-rayleigh","@stdlib/random/iter/t":"@stdlib/random-iter-t","@stdlib/random/iter/triangular":"@stdlib/random-iter-triangular","@stdlib/random/iter/uniform":"@stdlib/random-iter-uniform","@stdlib/random/iter/weibull":"@stdlib/random-iter-weibull","@stdlib/random/streams/arcsine":"@stdlib/random-streams-arcsine","@stdlib/random/streams/bernoulli":"@stdlib/random-streams-bernoulli","@stdlib/random/streams/beta":"@stdlib/random-streams-beta","@stdlib/random/streams/betaprime":"@stdlib/random-streams-betaprime","@stdlib/random/streams/binomial":"@stdlib/random-streams-binomial","@stdlib/random/streams/box-muller":"@stdlib/random-streams-box-muller","@stdlib/random/streams/cauchy":"@stdlib/random-streams-cauchy","@stdlib/random/streams/chi":"@stdlib/random-streams-chi","@stdlib/random/streams/chisquare":"@stdlib/random-streams-chisquare","@stdlib/random/streams/cosine":"@stdlib/random-streams-cosine","@stdlib/random/streams/discrete-uniform":"@stdlib/random-streams-discrete-uniform","@stdlib/random/streams/erlang":"@stdlib/random-streams-erlang","@stdlib/random/streams/exponential":"@stdlib/random-streams-exponential","@stdlib/random/streams/f":"@stdlib/random-streams-f","@stdlib/random/streams/frechet":"@stdlib/random-streams-frechet","@stdlib/random/streams/gamma":"@stdlib/random-streams-gamma","@stdlib/random/streams/geometric":"@stdlib/random-streams-geometric","@stdlib/random/streams/gumbel":"@stdlib/random-streams-gumbel","@stdlib/random/streams/hypergeometric":"@stdlib/random-streams-hypergeometric","@stdlib/random/streams/improved-ziggurat":"@stdlib/random-streams-improved-ziggurat","@stdlib/random/streams/invgamma":"@stdlib/random-streams-invgamma","@stdlib/random/streams/kumaraswamy":"@stdlib/random-streams-kumaraswamy","@stdlib/random/streams/laplace":"@stdlib/random-streams-laplace","@stdlib/random/streams/levy":"@stdlib/random-streams-levy","@stdlib/random/streams/logistic":"@stdlib/random-streams-logistic","@stdlib/random/streams/lognormal":"@stdlib/random-streams-lognormal","@stdlib/random/streams/minstd":"@stdlib/random-streams-minstd","@stdlib/random/streams/minstd-shuffle":"@stdlib/random-streams-minstd-shuffle","@stdlib/random/streams/mt19937":"@stdlib/random-streams-mt19937","@stdlib/random/streams/negative-binomial":"@stdlib/random-streams-negative-binomial","@stdlib/random/streams/normal":"@stdlib/random-streams-normal","@stdlib/random/streams/pareto-type1":"@stdlib/random-streams-pareto-type1","@stdlib/random/streams/poisson":"@stdlib/random-streams-poisson","@stdlib/random/streams/randi":"@stdlib/random-streams-randi","@stdlib/random/streams/randn":"@stdlib/random-streams-randn","@stdlib/random/streams/randu":"@stdlib/random-streams-randu","@stdlib/random/streams/rayleigh":"@stdlib/random-streams-rayleigh","@stdlib/random/streams/t":"@stdlib/random-streams-t","@stdlib/random/streams/triangular":"@stdlib/random-streams-triangular","@stdlib/random/streams/uniform":"@stdlib/random-streams-uniform","@stdlib/random/streams/weibull":"@stdlib/random-streams-weibull","@stdlib/random/strided/arcsine":"@stdlib/random-strided-arcsine","@stdlib/random/strided/bernoulli":"@stdlib/random-strided-bernoulli","@stdlib/random/strided/beta":"@stdlib/random-strided-beta","@stdlib/random/strided/betaprime":"@stdlib/random-strided-betaprime","@stdlib/random/strided/chi":"@stdlib/random-strided-chi","@stdlib/random/strided/chisquare":"@stdlib/random-strided-chisquare","@stdlib/random/strided/cosine":"@stdlib/random-strided-cosine","@stdlib/random/strided/discrete-uniform":"@stdlib/random-strided-discrete-uniform","@stdlib/random/strided/exponential":"@stdlib/random-strided-exponential","@stdlib/random/strided/gamma":"@stdlib/random-strided-gamma","@stdlib/random/strided/geometric":"@stdlib/random-strided-geometric","@stdlib/random/strided/invgamma":"@stdlib/random-strided-invgamma","@stdlib/random/strided/lognormal":"@stdlib/random-strided-lognormal","@stdlib/random/strided/minstd":"@stdlib/random-strided-minstd","@stdlib/random/strided/minstd-shuffle":"@stdlib/random-strided-minstd-shuffle","@stdlib/random/strided/mt19937":"@stdlib/random-strided-mt19937","@stdlib/random/strided/normal":"@stdlib/random-strided-normal","@stdlib/random/strided/poisson":"@stdlib/random-strided-poisson","@stdlib/random/strided/randu":"@stdlib/random-strided-randu","@stdlib/random/strided/rayleigh":"@stdlib/random-strided-rayleigh","@stdlib/random/strided/t":"@stdlib/random-strided-t","@stdlib/random/strided/uniform":"@stdlib/random-strided-uniform","@stdlib/random/strided/weibull":"@stdlib/random-strided-weibull","@stdlib/stats/ranks":"@stdlib/stats-ranks","@stdlib/fs/read-dir":"@stdlib/fs-read-dir","@stdlib/fs/read-file":"@stdlib/fs-read-file","@stdlib/fs/read-file-list":"@stdlib/fs-read-file-list","@stdlib/fs/read-json":"@stdlib/fs-read-json","@stdlib/fs/read-wasm":"@stdlib/fs-read-wasm","@stdlib/complex/float64/real":"@stdlib/complex-float64-real","@stdlib/array/typed-real":"@stdlib/array-typed-real","@stdlib/array/typed-real-ctors":"@stdlib/array-typed-real-ctors","@stdlib/array/typed-real-dtypes":"@stdlib/array-typed-real-dtypes","@stdlib/complex/float32/real":"@stdlib/complex-float32-real","@stdlib/utils/real-max":"@stdlib/utils-real-max","@stdlib/utils/real-min":"@stdlib/utils-real-min","@stdlib/regexp/basename":"@stdlib/regexp-basename","@stdlib/regexp/basename-posix":"@stdlib/regexp-basename-posix","@stdlib/regexp/basename-windows":"@stdlib/regexp-basename-windows","@stdlib/regexp/color-hexadecimal":"@stdlib/regexp-color-hexadecimal","@stdlib/regexp/decimal-number":"@stdlib/regexp-decimal-number","@stdlib/regexp/dirname":"@stdlib/regexp-dirname","@stdlib/regexp/dirname-posix":"@stdlib/regexp-dirname-posix","@stdlib/regexp/dirname-windows":"@stdlib/regexp-dirname-windows","@stdlib/utils/reduce":"@stdlib/utils-reduce","@stdlib/utils/reduce2d":"@stdlib/utils-reduce2d","@stdlib/utils/async/reduce":"@stdlib/utils-async-reduce","@stdlib/utils/reduce-right":"@stdlib/utils-reduce-right","@stdlib/utils/async/reduce-right":"@stdlib/utils-async-reduce-right","@stdlib/regexp/duration-string":"@stdlib/regexp-duration-string","@stdlib/regexp/eol":"@stdlib/regexp-eol","@stdlib/regexp/extended-length-path":"@stdlib/regexp-extended-length-path","@stdlib/regexp/extname":"@stdlib/regexp-extname","@stdlib/regexp/extname-posix":"@stdlib/regexp-extname-posix","@stdlib/regexp/extname-windows":"@stdlib/regexp-extname-windows","@stdlib/regexp/filename":"@stdlib/regexp-filename","@stdlib/regexp/filename-posix":"@stdlib/regexp-filename-posix","@stdlib/regexp/filename-windows":"@stdlib/regexp-filename-windows","@stdlib/utils/regexp-from-string":"@stdlib/utils-regexp-from-string","@stdlib/regexp/function-name":"@stdlib/regexp-function-name","@stdlib/regexp/to-json":"@stdlib/regexp-to-json","@stdlib/complex/float64/reim":"@stdlib/complex-float64-reim","@stdlib/complex/float32/reim":"@stdlib/complex-float32-reim","@stdlib/utils/reject-arguments":"@stdlib/utils-reject-arguments","@stdlib/string/remove-first":"@stdlib/string-remove-first","@stdlib/string/remove-last":"@stdlib/string-remove-last","@stdlib/string/remove-punctuation":"@stdlib/string-remove-punctuation","@stdlib/string/remove-utf8-bom":"@stdlib/string-remove-utf8-bom","@stdlib/string/remove-words":"@stdlib/string-remove-words","@stdlib/fs/rename":"@stdlib/fs-rename","@stdlib/regexp/native-function":"@stdlib/regexp-native-function","@stdlib/utils/reorder-arguments":"@stdlib/utils-reorder-arguments","@stdlib/string/repeat":"@stdlib/string-repeat","@stdlib/string/replace":"@stdlib/string-replace","@stdlib/string/replace-before":"@stdlib/string-replace-before","@stdlib/regexp/regexp":"@stdlib/regexp-regexp","@stdlib/utils/escape-regexp-string":"@stdlib/utils-escape-regexp-string","@stdlib/regexp/semver":"@stdlib/regexp-semver","@stdlib/fs/resolve-parent-path":"@stdlib/fs-resolve-parent-path","@stdlib/fs/resolve-parent-path-by":"@stdlib/fs-resolve-parent-path-by","@stdlib/regexp/unc-path":"@stdlib/regexp-unc-path","@stdlib/regexp/utf16-surrogate-pair":"@stdlib/regexp-utf16-surrogate-pair","@stdlib/regexp/utf16-unpaired-surrogate":"@stdlib/regexp-utf16-unpaired-surrogate","@stdlib/utils/reverse-arguments":"@stdlib/utils-reverse-arguments","@stdlib/string/reverse":"@stdlib/string-reverse","@stdlib/random/base/reviver":"@stdlib/random-base-reviver","@stdlib/buffer/reviver":"@stdlib/buffer-reviver","@stdlib/complex/reviver":"@stdlib/complex-reviver","@stdlib/complex/float32/reviver":"@stdlib/complex-float32-reviver","@stdlib/complex/float64/reviver":"@stdlib/complex-float64-reviver","@stdlib/error/reviver":"@stdlib/error-reviver","@stdlib/regexp/reviver":"@stdlib/regexp-reviver","@stdlib/array/reviver":"@stdlib/array-reviver","@stdlib/regexp/whitespace":"@stdlib/regexp-whitespace","@stdlib/string/right-pad":"@stdlib/string-right-pad","@stdlib/string/right-trim":"@stdlib/string-right-trim","@stdlib/string/right-trim-n":"@stdlib/string-right-trim-n","@stdlib/utils/safe-int-max":"@stdlib/utils-safe-int-max","@stdlib/utils/safe-int-min":"@stdlib/utils-safe-int-min","@stdlib/random/sample":"@stdlib/random-sample","@stdlib/datasets/savoy-stopwords-fin":"@stdlib/datasets-savoy-stopwords-fin","@stdlib/datasets/savoy-stopwords-fr":"@stdlib/datasets-savoy-stopwords-fr","@stdlib/datasets/savoy-stopwords-ger":"@stdlib/datasets-savoy-stopwords-ger","@stdlib/datasets/savoy-stopwords-it":"@stdlib/datasets-savoy-stopwords-it","@stdlib/datasets/savoy-stopwords-por":"@stdlib/datasets-savoy-stopwords-por","@stdlib/datasets/savoy-stopwords-sp":"@stdlib/datasets-savoy-stopwords-sp","@stdlib/datasets/savoy-stopwords-swe":"@stdlib/datasets-savoy-stopwords-swe","@stdlib/array/from-scalar":"@stdlib/array-from-scalar","@stdlib/ndarray/from-scalar":"@stdlib/ndarray-from-scalar","@stdlib/blas/sdot":"@stdlib/blas-sdot","@stdlib/constants/time/seconds-in-day":"@stdlib/constants-time-seconds-in-day","@stdlib/constants/time/seconds-in-hour":"@stdlib/constants-time-seconds-in-hour","@stdlib/constants/time/seconds-in-minute":"@stdlib/constants-time-seconds-in-minute","@stdlib/constants/time/seconds-in-week":"@stdlib/constants-time-seconds-in-week","@stdlib/time/seconds-in-month":"@stdlib/time-seconds-in-month","@stdlib/time/seconds-in-year":"@stdlib/time-seconds-in-year","@stdlib/nlp/sentencize":"@stdlib/nlp-sentencize","@stdlib/slice/seq2slice":"@stdlib/slice-seq2slice","@stdlib/utils/define-configurable-read-only-property":"@stdlib/utils-define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor":"@stdlib/utils-define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor":"@stdlib/utils-define-configurable-read-write-accessor","@stdlib/utils/define-configurable-write-only-accessor":"@stdlib/utils-define-configurable-write-only-accessor","@stdlib/utils/define-memoized-configurable-read-only-property":"@stdlib/utils-define-memoized-configurable-read-only-property","@stdlib/utils/define-memoized-read-only-property":"@stdlib/utils-define-memoized-read-only-property","@stdlib/utils/define-nonenumerable-property":"@stdlib/utils-define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-property":"@stdlib/utils-define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-only-accessor":"@stdlib/utils-define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-write-accessor":"@stdlib/utils-define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor":"@stdlib/utils-define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property":"@stdlib/utils-define-read-only-property","@stdlib/utils/define-read-only-accessor":"@stdlib/utils-define-read-only-accessor","@stdlib/utils/define-read-write-accessor":"@stdlib/utils-define-read-write-accessor","@stdlib/utils/define-write-only-accessor":"@stdlib/utils-define-write-only-accessor","@stdlib/array/shared-buffer":"@stdlib/array-shared-buffer","@stdlib/utils/shift":"@stdlib/utils-shift","@stdlib/random/shuffle":"@stdlib/random-shuffle","@stdlib/utils/size-of":"@stdlib/utils-size-of","@stdlib/slice/ctor":"@stdlib/slice-ctor","@stdlib/string/snakecase":"@stdlib/string-snakecase","@stdlib/utils/some":"@stdlib/utils-some","@stdlib/utils/some-by":"@stdlib/utils-some-by","@stdlib/utils/async/some-by":"@stdlib/utils-async-some-by","@stdlib/utils/some-by-right":"@stdlib/utils-some-by-right","@stdlib/utils/async/some-by-right":"@stdlib/utils-async-some-by-right","@stdlib/utils/some-in-by":"@stdlib/utils-some-in-by","@stdlib/utils/some-own-by":"@stdlib/utils-some-own-by","@stdlib/datasets/sotu":"@stdlib/datasets-sotu","@stdlib/datasets/spache-revised":"@stdlib/datasets-spache-revised","@stdlib/datasets/spam-assassin":"@stdlib/datasets-spam-assassin","@stdlib/plot/sparklines/base/ctor":"@stdlib/plot-sparklines-base-ctor","@stdlib/array/to-sparse-iterator":"@stdlib/array-to-sparse-iterator","@stdlib/array/to-sparse-iterator-right":"@stdlib/array-to-sparse-iterator-right","@stdlib/streams/node/split":"@stdlib/streams-node-split","@stdlib/constants/float64/sqrt-eps":"@stdlib/constants-float64-sqrt-eps","@stdlib/constants/float64/sqrt-half":"@stdlib/constants-float64-sqrt-half","@stdlib/constants/float64/sqrt-half-pi":"@stdlib/constants-float64-sqrt-half-pi","@stdlib/constants/float64/sqrt-phi":"@stdlib/constants-float64-sqrt-phi","@stdlib/constants/float64/sqrt-pi":"@stdlib/constants-float64-sqrt-pi","@stdlib/constants/float64/sqrt-three":"@stdlib/constants-float64-sqrt-three","@stdlib/constants/float64/sqrt-two":"@stdlib/constants-float64-sqrt-two","@stdlib/constants/float64/sqrt-two-pi":"@stdlib/constants-float64-sqrt-two-pi","@stdlib/datasets/ssa-us-births-2000-2014":"@stdlib/datasets-ssa-us-births-2000-2014","@stdlib/blas/sswap":"@stdlib/blas-sswap","@stdlib/dstructs/stack":"@stdlib/dstructs-stack","@stdlib/namespace/standalone2pkg":"@stdlib/namespace-standalone2pkg","@stdlib/datasets/standard-card-deck":"@stdlib/datasets-standard-card-deck","@stdlib/string/startcase":"@stdlib/string-startcase","@stdlib/string/starts-with":"@stdlib/string-starts-with","@stdlib/datasets/stopwords-en":"@stdlib/datasets-stopwords-en","@stdlib/math/strided/special/abs":"@stdlib/math-strided-special-abs","@stdlib/math/strided/special/abs2":"@stdlib/math-strided-special-abs2","@stdlib/math/strided/special/abs2-by":"@stdlib/math-strided-special-abs2-by","@stdlib/math/strided/special/abs-by":"@stdlib/math-strided-special-abs-by","@stdlib/math/strided/special/acos-by":"@stdlib/math-strided-special-acos-by","@stdlib/math/strided/special/acosh-by":"@stdlib/math-strided-special-acosh-by","@stdlib/math/strided/special/acot-by":"@stdlib/math-strided-special-acot-by","@stdlib/math/strided/special/acoth-by":"@stdlib/math-strided-special-acoth-by","@stdlib/math/strided/special/acovercos-by":"@stdlib/math-strided-special-acovercos-by","@stdlib/math/strided/special/acoversin-by":"@stdlib/math-strided-special-acoversin-by","@stdlib/math/strided/ops/add":"@stdlib/math-strided-ops-add","@stdlib/math/strided/ops/add-by":"@stdlib/math-strided-ops-add-by","@stdlib/math/strided/special/ahavercos-by":"@stdlib/math-strided-special-ahavercos-by","@stdlib/math/strided/special/ahaversin-by":"@stdlib/math-strided-special-ahaversin-by","@stdlib/math/strided/special/asin-by":"@stdlib/math-strided-special-asin-by","@stdlib/math/strided/special/asinh-by":"@stdlib/math-strided-special-asinh-by","@stdlib/math/strided/special/atan-by":"@stdlib/math-strided-special-atan-by","@stdlib/math/strided/special/atanh-by":"@stdlib/math-strided-special-atanh-by","@stdlib/math/strided/special/avercos-by":"@stdlib/math-strided-special-avercos-by","@stdlib/math/strided/special/aversin-by":"@stdlib/math-strided-special-aversin-by","@stdlib/math/strided/special/besselj0-by":"@stdlib/math-strided-special-besselj0-by","@stdlib/math/strided/special/besselj1-by":"@stdlib/math-strided-special-besselj1-by","@stdlib/math/strided/special/bessely0-by":"@stdlib/math-strided-special-bessely0-by","@stdlib/math/strided/special/bessely1-by":"@stdlib/math-strided-special-bessely1-by","@stdlib/math/strided/special/binet-by":"@stdlib/math-strided-special-binet-by","@stdlib/math/strided/special/cbrt":"@stdlib/math-strided-special-cbrt","@stdlib/math/strided/special/cbrt-by":"@stdlib/math-strided-special-cbrt-by","@stdlib/math/strided/special/ceil":"@stdlib/math-strided-special-ceil","@stdlib/math/strided/special/cos-by":"@stdlib/math-strided-special-cos-by","@stdlib/math/strided/special/deg2rad":"@stdlib/math-strided-special-deg2rad","@stdlib/strided/dtypes":"@stdlib/strided-dtypes","@stdlib/math/strided/special/dcbrt-by":"@stdlib/math-strided-special-dcbrt-by","@stdlib/strided/dispatch":"@stdlib/strided-dispatch","@stdlib/strided/dispatch-by":"@stdlib/strided-dispatch-by","@stdlib/math/strided/special/floor":"@stdlib/math-strided-special-floor","@stdlib/math/strided/special/inv":"@stdlib/math-strided-special-inv","@stdlib/math/strided/ops/mul":"@stdlib/math-strided-ops-mul","@stdlib/math/strided/ops/mul-by":"@stdlib/math-strided-ops-mul-by","@stdlib/math/strided/special/ramp":"@stdlib/math-strided-special-ramp","@stdlib/math/strided/special/rsqrt":"@stdlib/math-strided-special-rsqrt","@stdlib/math/strided/special/sin-by":"@stdlib/math-strided-special-sin-by","@stdlib/math/strided/special/sqrt":"@stdlib/math-strided-special-sqrt","@stdlib/math/strided/special/sqrt-by":"@stdlib/math-strided-special-sqrt-by","@stdlib/math/strided/ops/sub":"@stdlib/math-strided-ops-sub","@stdlib/math/strided/ops/sub-by":"@stdlib/math-strided-ops-sub-by","@stdlib/math/strided/special/trunc":"@stdlib/math-strided-special-trunc","@stdlib/array/to-strided-iterator":"@stdlib/array-to-strided-iterator","@stdlib/streams/node/from-strided-array":"@stdlib/streams-node-from-strided-array","@stdlib/buffer/from-string":"@stdlib/buffer-from-string","@stdlib/ndarray/sub2ind":"@stdlib/ndarray-sub2ind","@stdlib/string/substring-after":"@stdlib/string-substring-after","@stdlib/string/substring-after-last":"@stdlib/string-substring-after-last","@stdlib/string/substring-before":"@stdlib/string-substring-before","@stdlib/string/substring-before-last":"@stdlib/string-substring-before-last","@stdlib/datasets/suthaharan-multi-hop-sensor-network":"@stdlib/datasets-suthaharan-multi-hop-sensor-network","@stdlib/datasets/suthaharan-single-hop-sensor-network":"@stdlib/datasets-suthaharan-single-hop-sensor-network","@stdlib/symbol/ctor":"@stdlib/symbol-ctor","@stdlib/utils/tabulate":"@stdlib/utils-tabulate","@stdlib/utils/tabulate-by":"@stdlib/utils-tabulate-by","@stdlib/utils/async/tabulate-by":"@stdlib/utils-async-tabulate-by","@stdlib/function/thunk":"@stdlib/function-thunk","@stdlib/time/tic":"@stdlib/time-tic","@stdlib/utils/timeit":"@stdlib/utils-timeit","@stdlib/os/tmpdir":"@stdlib/os-tmpdir","@stdlib/time/toc":"@stdlib/time-toc","@stdlib/nlp/tokenize":"@stdlib/nlp-tokenize","@stdlib/streams/node/transform":"@stdlib/streams-node-transform","@stdlib/string/trim":"@stdlib/string-trim","@stdlib/string/truncate":"@stdlib/string-truncate","@stdlib/string/truncate-middle":"@stdlib/string-truncate-middle","@stdlib/utils/try-catch":"@stdlib/utils-try-catch","@stdlib/utils/async/try-catch":"@stdlib/utils-async-try-catch","@stdlib/utils/try-function":"@stdlib/utils-try-function","@stdlib/utils/try-require":"@stdlib/utils-try-require","@stdlib/utils/try-then":"@stdlib/utils-try-then","@stdlib/utils/async/try-then":"@stdlib/utils-async-try-then","@stdlib/stats/ttest":"@stdlib/stats-ttest","@stdlib/stats/ttest2":"@stdlib/stats-ttest2","@stdlib/constants/float64/two-pi":"@stdlib/constants-float64-two-pi","@stdlib/array/typed":"@stdlib/array-typed","@stdlib/array/to-json":"@stdlib/array-to-json","@stdlib/array/typed-ctors":"@stdlib/array-typed-ctors","@stdlib/array/typed-dtypes":"@stdlib/array-typed-dtypes","@stdlib/array/pool":"@stdlib/array-pool","@stdlib/utils/type-max":"@stdlib/utils-type-max","@stdlib/utils/type-min":"@stdlib/utils-type-min","@stdlib/utils/type-of":"@stdlib/utils-type-of","@stdlib/constants/uint8/max":"@stdlib/constants-uint8-max","@stdlib/constants/uint8/num-bytes":"@stdlib/constants-uint8-num-bytes","@stdlib/array/uint8":"@stdlib/array-uint8","@stdlib/array/uint8c":"@stdlib/array-uint8c","@stdlib/constants/uint16/max":"@stdlib/constants-uint16-max","@stdlib/constants/uint16/num-bytes":"@stdlib/constants-uint16-num-bytes","@stdlib/array/uint16":"@stdlib/array-uint16","@stdlib/constants/uint32/max":"@stdlib/constants-uint32-max","@stdlib/constants/uint32/num-bytes":"@stdlib/constants-uint32-num-bytes","@stdlib/array/uint32":"@stdlib/array-uint32","@stdlib/process/umask":"@stdlib/process-umask","@stdlib/string/uncapitalize":"@stdlib/string-uncapitalize","@stdlib/utils/uncapitalize-keys":"@stdlib/utils-uncapitalize-keys","@stdlib/utils/uncurry":"@stdlib/utils-uncurry","@stdlib/utils/uncurry-right":"@stdlib/utils-uncurry-right","@stdlib/constants/unicode/max":"@stdlib/constants-unicode-max","@stdlib/constants/unicode/max-bmp":"@stdlib/constants-unicode-max-bmp","@stdlib/plot/sparklines/unicode/column":"@stdlib/plot-sparklines-unicode-column","@stdlib/plot/sparklines/unicode/line":"@stdlib/plot-sparklines-unicode-line","@stdlib/plot/sparklines/unicode":"@stdlib/plot-sparklines-unicode","@stdlib/plot/sparklines/unicode/tristate":"@stdlib/plot-sparklines-unicode-tristate","@stdlib/plot/sparklines/unicode/up-down":"@stdlib/plot-sparklines-unicode-up-down","@stdlib/plot/sparklines/unicode/win-loss":"@stdlib/plot-sparklines-unicode-win-loss","@stdlib/fs/unlink":"@stdlib/fs-unlink","@stdlib/utils/unshift":"@stdlib/utils-unshift","@stdlib/utils/until":"@stdlib/utils-until","@stdlib/utils/async/until":"@stdlib/utils-async-until","@stdlib/utils/until-each":"@stdlib/utils-until-each","@stdlib/utils/until-each-right":"@stdlib/utils-until-each-right","@stdlib/utils/unzip":"@stdlib/utils-unzip","@stdlib/string/uppercase":"@stdlib/string-uppercase","@stdlib/utils/uppercase-keys":"@stdlib/utils-uppercase-keys","@stdlib/datasets/us-states-abbr":"@stdlib/datasets-us-states-abbr","@stdlib/datasets/us-states-capitals":"@stdlib/datasets-us-states-capitals","@stdlib/datasets/us-states-capitals-names":"@stdlib/datasets-us-states-capitals-names","@stdlib/datasets/us-states-names":"@stdlib/datasets-us-states-names","@stdlib/datasets/us-states-names-capitals":"@stdlib/datasets-us-states-names-capitals","@stdlib/string/utf16-to-utf8-array":"@stdlib/string-utf16-to-utf8-array","@stdlib/stats/vartest":"@stdlib/stats-vartest","@stdlib/utils/async/series-waterfall":"@stdlib/utils-async-series-waterfall","@stdlib/wasm/memory":"@stdlib/wasm-memory","@stdlib/utils/async/while":"@stdlib/utils-async-while","@stdlib/utils/while-each":"@stdlib/utils-while-each","@stdlib/utils/while-each-right":"@stdlib/utils-while-each-right","@stdlib/utils/while":"@stdlib/utils-while","@stdlib/stats/wilcoxon":"@stdlib/stats-wilcoxon","@stdlib/utils/writable-properties":"@stdlib/utils-writable-properties","@stdlib/utils/writable-properties-in":"@stdlib/utils-writable-properties-in","@stdlib/utils/writable-property-names":"@stdlib/utils-writable-property-names","@stdlib/utils/writable-property-names-in":"@stdlib/utils-writable-property-names-in","@stdlib/utils/writable-property-symbols":"@stdlib/utils-writable-property-symbols","@stdlib/utils/writable-property-symbols-in":"@stdlib/utils-writable-property-symbols-in","@stdlib/fs/write-file":"@stdlib/fs-write-file","@stdlib/utils/zip":"@stdlib/utils-zip","@stdlib/stats/ztest":"@stdlib/stats-ztest","@stdlib/stats/ztest2":"@stdlib/stats-ztest2"} +{"@stdlib/math/special/abs":"@stdlib/math-special-abs","@stdlib/array/cartesian-power":"@stdlib/array-cartesian-power","@stdlib/array/cartesian-product":"@stdlib/array-cartesian-product","@stdlib/array/cartesian-square":"@stdlib/array-cartesian-square","@stdlib/string/acronym":"@stdlib/string-acronym","@stdlib/array/empty":"@stdlib/array-empty","@stdlib/array/empty-like":"@stdlib/array-empty-like","@stdlib/datasets/afinn-96":"@stdlib/datasets-afinn-96","@stdlib/datasets/afinn-111":"@stdlib/datasets-afinn-111","@stdlib/array/full":"@stdlib/array-full","@stdlib/array/full-like":"@stdlib/array-full-like","@stdlib/namespace/alias2pkg":"@stdlib/namespace-alias2pkg","@stdlib/namespace/alias2related":"@stdlib/namespace-alias2related","@stdlib/namespace/alias2standalone":"@stdlib/namespace-alias2standalone","@stdlib/namespace/aliases":"@stdlib/namespace-aliases","@stdlib/buffer/alloc-unsafe":"@stdlib/buffer-alloc-unsafe","@stdlib/array/mskfilter":"@stdlib/array-mskfilter","@stdlib/array/mskput":"@stdlib/array-mskput","@stdlib/array/mskreject":"@stdlib/array-mskreject","@stdlib/array/nans":"@stdlib/array-nans","@stdlib/array/nans-like":"@stdlib/array-nans-like","@stdlib/stats/anova1":"@stdlib/stats-anova1","@stdlib/datasets/anscombes-quartet":"@stdlib/datasets-anscombes-quartet","@stdlib/utils/any":"@stdlib/utils-any","@stdlib/utils/any-by":"@stdlib/utils-any-by","@stdlib/utils/async/any-by":"@stdlib/utils-async-any-by","@stdlib/utils/any-by-right":"@stdlib/utils-any-by-right","@stdlib/utils/async/any-by-right":"@stdlib/utils-async-any-by-right","@stdlib/utils/any-in-by":"@stdlib/utils-any-in-by","@stdlib/utils/any-own-by":"@stdlib/utils-any-own-by","@stdlib/array/ones":"@stdlib/array-ones","@stdlib/array/ones-like":"@stdlib/array-ones-like","@stdlib/array/one-to":"@stdlib/array-one-to","@stdlib/array/one-to-like":"@stdlib/array-one-to-like","@stdlib/constants/float64/apery":"@stdlib/constants-float64-apery","@stdlib/array/place":"@stdlib/array-place","@stdlib/utils/append":"@stdlib/utils-append","@stdlib/array/put":"@stdlib/array-put","@stdlib/os/arch":"@stdlib/os-arch","@stdlib/utils/argument-function":"@stdlib/utils-argument-function","@stdlib/process/argv":"@stdlib/process-argv","@stdlib/ndarray/array":"@stdlib/ndarray-array","@stdlib/buffer/from-array":"@stdlib/buffer-from-array","@stdlib/array/to-fancy":"@stdlib/array-to-fancy","@stdlib/array/to-iterator":"@stdlib/array-to-iterator","@stdlib/array/to-iterator-right":"@stdlib/array-to-iterator-right","@stdlib/array/buffer":"@stdlib/array-buffer","@stdlib/buffer/from-arraybuffer":"@stdlib/buffer-from-arraybuffer","@stdlib/array/ctors":"@stdlib/array-ctors","@stdlib/array/dtype":"@stdlib/array-dtype","@stdlib/array/dtypes":"@stdlib/array-dtypes","@stdlib/array/index":"@stdlib/array-index","@stdlib/array/min-dtype":"@stdlib/array-min-dtype","@stdlib/array/mostly-safe-casts":"@stdlib/array-mostly-safe-casts","@stdlib/array/next-dtype":"@stdlib/array-next-dtype","@stdlib/array/promotion-rules":"@stdlib/array-promotion-rules","@stdlib/array/safe-casts":"@stdlib/array-safe-casts","@stdlib/array/same-kind-casts":"@stdlib/array-same-kind-casts","@stdlib/array/shape":"@stdlib/array-shape","@stdlib/streams/node/from-array":"@stdlib/streams-node-from-array","@stdlib/array/to-view-iterator":"@stdlib/array-to-view-iterator","@stdlib/array/to-view-iterator-right":"@stdlib/array-to-view-iterator-right","@stdlib/array/slice":"@stdlib/array-slice","@stdlib/symbol/async-iterator":"@stdlib/symbol-async-iterator","@stdlib/array/take":"@stdlib/array-take","@stdlib/array/zeros":"@stdlib/array-zeros","@stdlib/array/zeros-like":"@stdlib/array-zeros-like","@stdlib/array/zero-to":"@stdlib/array-zero-to","@stdlib/array/zero-to-like":"@stdlib/array-zero-to-like","@stdlib/stats/bartlett-test":"@stdlib/stats-bartlett-test","@stdlib/math/base/special/abs":"@stdlib/math-base-special-abs","@stdlib/math/base/special/abs2":"@stdlib/math-base-special-abs2","@stdlib/math/base/special/abs2f":"@stdlib/math-base-special-abs2f","@stdlib/math/base/utils/absolute-difference":"@stdlib/math-base-utils-absolute-difference","@stdlib/math/base/special/absf":"@stdlib/math-base-special-absf","@stdlib/array/base/cartesian-power":"@stdlib/array-base-cartesian-power","@stdlib/array/base/cartesian-product":"@stdlib/array-base-cartesian-product","@stdlib/array/base/cartesian-square":"@stdlib/array-base-cartesian-square","@stdlib/math/base/special/acos":"@stdlib/math-base-special-acos","@stdlib/math/base/special/acosd":"@stdlib/math-base-special-acosd","@stdlib/math/base/special/acosf":"@stdlib/math-base-special-acosf","@stdlib/math/base/special/acosh":"@stdlib/math-base-special-acosh","@stdlib/math/base/special/acot":"@stdlib/math-base-special-acot","@stdlib/math/base/special/acotd":"@stdlib/math-base-special-acotd","@stdlib/math/base/special/acotf":"@stdlib/math-base-special-acotf","@stdlib/math/base/special/acoth":"@stdlib/math-base-special-acoth","@stdlib/math/base/special/acovercos":"@stdlib/math-base-special-acovercos","@stdlib/math/base/special/acoversin":"@stdlib/math-base-special-acoversin","@stdlib/math/base/special/acsc":"@stdlib/math-base-special-acsc","@stdlib/math/base/special/acscd":"@stdlib/math-base-special-acscd","@stdlib/math/base/special/acscdf":"@stdlib/math-base-special-acscdf","@stdlib/math/base/special/acscf":"@stdlib/math-base-special-acscf","@stdlib/math/base/special/acsch":"@stdlib/math-base-special-acsch","@stdlib/number/float64/base/add":"@stdlib/number-float64-base-add","@stdlib/number/float64/base/add3":"@stdlib/number-float64-base-add3","@stdlib/number/float64/base/add4":"@stdlib/number-float64-base-add4","@stdlib/number/float64/base/add5":"@stdlib/number-float64-base-add5","@stdlib/number/float32/base/add":"@stdlib/number-float32-base-add","@stdlib/array/base/filled":"@stdlib/array-base-filled","@stdlib/array/base/filled2d":"@stdlib/array-base-filled2d","@stdlib/array/base/filled2d-by":"@stdlib/array-base-filled2d-by","@stdlib/array/base/filled3d":"@stdlib/array-base-filled3d","@stdlib/array/base/filled3d-by":"@stdlib/array-base-filled3d-by","@stdlib/array/base/filled4d":"@stdlib/array-base-filled4d","@stdlib/array/base/filled4d-by":"@stdlib/array-base-filled4d-by","@stdlib/array/base/filled5d":"@stdlib/array-base-filled5d","@stdlib/array/base/filled5d-by":"@stdlib/array-base-filled5d-by","@stdlib/array/base/filled-by":"@stdlib/array-base-filled-by","@stdlib/array/base/fillednd":"@stdlib/array-base-fillednd","@stdlib/array/base/fillednd-by":"@stdlib/array-base-fillednd-by","@stdlib/array/base/filter":"@stdlib/array-base-filter","@stdlib/array/base/first":"@stdlib/array-base-first","@stdlib/array/base/flatten":"@stdlib/array-base-flatten","@stdlib/array/base/flatten2d":"@stdlib/array-base-flatten2d","@stdlib/array/base/flatten2d-by":"@stdlib/array-base-flatten2d-by","@stdlib/array/base/flatten3d":"@stdlib/array-base-flatten3d","@stdlib/array/base/flatten3d-by":"@stdlib/array-base-flatten3d-by","@stdlib/array/base/flatten4d":"@stdlib/array-base-flatten4d","@stdlib/array/base/flatten4d-by":"@stdlib/array-base-flatten4d-by","@stdlib/array/base/flatten5d":"@stdlib/array-base-flatten5d","@stdlib/array/base/flatten5d-by":"@stdlib/array-base-flatten5d-by","@stdlib/array/base/flatten-by":"@stdlib/array-base-flatten-by","@stdlib/array/base/fliplr2d":"@stdlib/array-base-fliplr2d","@stdlib/array/base/fliplr3d":"@stdlib/array-base-fliplr3d","@stdlib/array/base/fliplr4d":"@stdlib/array-base-fliplr4d","@stdlib/array/base/fliplr5d":"@stdlib/array-base-fliplr5d","@stdlib/array/base/flipud2d":"@stdlib/array-base-flipud2d","@stdlib/array/base/flipud3d":"@stdlib/array-base-flipud3d","@stdlib/array/base/flipud4d":"@stdlib/array-base-flipud4d","@stdlib/array/base/flipud5d":"@stdlib/array-base-flipud5d","@stdlib/math/base/special/ahavercos":"@stdlib/math-base-special-ahavercos","@stdlib/math/base/special/ahaversin":"@stdlib/math-base-special-ahaversin","@stdlib/string/base/altcase":"@stdlib/string-base-altcase","@stdlib/array/base/ones":"@stdlib/array-base-ones","@stdlib/array/base/ones2d":"@stdlib/array-base-ones2d","@stdlib/array/base/ones3d":"@stdlib/array-base-ones3d","@stdlib/array/base/ones4d":"@stdlib/array-base-ones4d","@stdlib/array/base/ones5d":"@stdlib/array-base-ones5d","@stdlib/array/base/onesnd":"@stdlib/array-base-onesnd","@stdlib/array/base/one-to":"@stdlib/array-base-one-to","@stdlib/slice/base/args2multislice":"@stdlib/slice-base-args2multislice","@stdlib/math/base/special/asec":"@stdlib/math-base-special-asec","@stdlib/math/base/special/asecd":"@stdlib/math-base-special-asecd","@stdlib/math/base/special/asecdf":"@stdlib/math-base-special-asecdf","@stdlib/math/base/special/asecf":"@stdlib/math-base-special-asecf","@stdlib/math/base/special/asech":"@stdlib/math-base-special-asech","@stdlib/math/base/special/asin":"@stdlib/math-base-special-asin","@stdlib/math/base/special/asind":"@stdlib/math-base-special-asind","@stdlib/math/base/special/asindf":"@stdlib/math-base-special-asindf","@stdlib/math/base/special/asinf":"@stdlib/math-base-special-asinf","@stdlib/math/base/special/asinh":"@stdlib/math-base-special-asinh","@stdlib/math/base/special/atan":"@stdlib/math-base-special-atan","@stdlib/math/base/special/atan2":"@stdlib/math-base-special-atan2","@stdlib/math/base/special/atand":"@stdlib/math-base-special-atand","@stdlib/math/base/special/atanf":"@stdlib/math-base-special-atanf","@stdlib/math/base/special/atanh":"@stdlib/math-base-special-atanh","@stdlib/math/base/special/avercos":"@stdlib/math-base-special-avercos","@stdlib/math/base/special/aversin":"@stdlib/math-base-special-aversin","@stdlib/array/base/zeros":"@stdlib/array-base-zeros","@stdlib/array/base/zeros2d":"@stdlib/array-base-zeros2d","@stdlib/array/base/zeros3d":"@stdlib/array-base-zeros3d","@stdlib/array/base/zeros4d":"@stdlib/array-base-zeros4d","@stdlib/array/base/zeros5d":"@stdlib/array-base-zeros5d","@stdlib/array/base/zerosnd":"@stdlib/array-base-zerosnd","@stdlib/array/base/zero-to":"@stdlib/array-base-zero-to","@stdlib/math/base/special/bernoulli":"@stdlib/math-base-special-bernoulli","@stdlib/math/base/special/besselj0":"@stdlib/math-base-special-besselj0","@stdlib/math/base/special/besselj1":"@stdlib/math-base-special-besselj1","@stdlib/math/base/special/bessely0":"@stdlib/math-base-special-bessely0","@stdlib/math/base/special/bessely1":"@stdlib/math-base-special-bessely1","@stdlib/math/base/special/beta":"@stdlib/math-base-special-beta","@stdlib/math/base/special/betainc":"@stdlib/math-base-special-betainc","@stdlib/math/base/special/betaincinv":"@stdlib/math-base-special-betaincinv","@stdlib/math/base/special/betaln":"@stdlib/math-base-special-betaln","@stdlib/math/base/special/binet":"@stdlib/math-base-special-binet","@stdlib/math/base/special/binomcoef":"@stdlib/math-base-special-binomcoef","@stdlib/math/base/special/binomcoefln":"@stdlib/math-base-special-binomcoefln","@stdlib/math/base/special/boxcox":"@stdlib/math-base-special-boxcox","@stdlib/math/base/special/boxcox1p":"@stdlib/math-base-special-boxcox1p","@stdlib/math/base/special/boxcox1pinv":"@stdlib/math-base-special-boxcox1pinv","@stdlib/math/base/special/boxcoxinv":"@stdlib/math-base-special-boxcoxinv","@stdlib/math/base/special/cabs":"@stdlib/math-base-special-cabs","@stdlib/math/base/special/cabs2":"@stdlib/math-base-special-cabs2","@stdlib/math/base/special/cabs2f":"@stdlib/math-base-special-cabs2f","@stdlib/math/base/special/cabsf":"@stdlib/math-base-special-cabsf","@stdlib/complex/float64/base/add":"@stdlib/complex-float64-base-add","@stdlib/complex/float32/base/add":"@stdlib/complex-float32-base-add","@stdlib/string/base/camelcase":"@stdlib/string-base-camelcase","@stdlib/string/base/capitalize":"@stdlib/string-base-capitalize","@stdlib/math/base/special/cbrt":"@stdlib/math-base-special-cbrt","@stdlib/math/base/special/cbrtf":"@stdlib/math-base-special-cbrtf","@stdlib/math/base/special/cceil":"@stdlib/math-base-special-cceil","@stdlib/math/base/special/cceilf":"@stdlib/math-base-special-cceilf","@stdlib/math/base/special/cceiln":"@stdlib/math-base-special-cceiln","@stdlib/math/base/special/ccis":"@stdlib/math-base-special-ccis","@stdlib/math/base/ops/cdiv":"@stdlib/math-base-ops-cdiv","@stdlib/math/base/special/ceil":"@stdlib/math-base-special-ceil","@stdlib/math/base/special/ceil2":"@stdlib/math-base-special-ceil2","@stdlib/math/base/special/ceil10":"@stdlib/math-base-special-ceil10","@stdlib/math/base/special/ceilb":"@stdlib/math-base-special-ceilb","@stdlib/math/base/special/ceilf":"@stdlib/math-base-special-ceilf","@stdlib/math/base/special/ceiln":"@stdlib/math-base-special-ceiln","@stdlib/math/base/special/ceilsd":"@stdlib/math-base-special-ceilsd","@stdlib/math/base/special/cexp":"@stdlib/math-base-special-cexp","@stdlib/math/base/special/cflipsign":"@stdlib/math-base-special-cflipsign","@stdlib/math/base/special/cflipsignf":"@stdlib/math-base-special-cflipsignf","@stdlib/math/base/special/cfloor":"@stdlib/math-base-special-cfloor","@stdlib/math/base/special/cfloorn":"@stdlib/math-base-special-cfloorn","@stdlib/math/base/special/cidentity":"@stdlib/math-base-special-cidentity","@stdlib/math/base/special/cidentityf":"@stdlib/math-base-special-cidentityf","@stdlib/math/base/special/cinv":"@stdlib/math-base-special-cinv","@stdlib/math/base/special/clamp":"@stdlib/math-base-special-clamp","@stdlib/math/base/special/clampf":"@stdlib/math-base-special-clampf","@stdlib/complex/float64/base/mul":"@stdlib/complex-float64-base-mul","@stdlib/complex/float32/base/mul":"@stdlib/complex-float32-base-mul","@stdlib/math/base/ops/cneg":"@stdlib/math-base-ops-cneg","@stdlib/math/base/ops/cnegf":"@stdlib/math-base-ops-cnegf","@stdlib/string/base/code-point-at":"@stdlib/string-base-code-point-at","@stdlib/string/base/constantcase":"@stdlib/string-base-constantcase","@stdlib/math/base/tools/continued-fraction":"@stdlib/math-base-tools-continued-fraction","@stdlib/math/base/special/copysign":"@stdlib/math-base-special-copysign","@stdlib/math/base/special/copysignf":"@stdlib/math-base-special-copysignf","@stdlib/math/base/special/cos":"@stdlib/math-base-special-cos","@stdlib/math/base/special/cosd":"@stdlib/math-base-special-cosd","@stdlib/math/base/special/cosh":"@stdlib/math-base-special-cosh","@stdlib/math/base/special/cosm1":"@stdlib/math-base-special-cosm1","@stdlib/math/base/special/cospi":"@stdlib/math-base-special-cospi","@stdlib/math/base/special/cot":"@stdlib/math-base-special-cot","@stdlib/math/base/special/cotd":"@stdlib/math-base-special-cotd","@stdlib/math/base/special/coth":"@stdlib/math-base-special-coth","@stdlib/math/base/special/covercos":"@stdlib/math-base-special-covercos","@stdlib/math/base/special/coversin":"@stdlib/math-base-special-coversin","@stdlib/math/base/special/cphase":"@stdlib/math-base-special-cphase","@stdlib/math/base/special/cpolar":"@stdlib/math-base-special-cpolar","@stdlib/math/base/special/cround":"@stdlib/math-base-special-cround","@stdlib/math/base/special/croundn":"@stdlib/math-base-special-croundn","@stdlib/math/base/special/csc":"@stdlib/math-base-special-csc","@stdlib/math/base/special/cscd":"@stdlib/math-base-special-cscd","@stdlib/math/base/special/csch":"@stdlib/math-base-special-csch","@stdlib/math/base/special/csignum":"@stdlib/math-base-special-csignum","@stdlib/math/base/ops/csub":"@stdlib/math-base-ops-csub","@stdlib/math/base/ops/csubf":"@stdlib/math-base-ops-csubf","@stdlib/math/base/special/deg2rad":"@stdlib/math-base-special-deg2rad","@stdlib/math/base/special/deg2radf":"@stdlib/math-base-special-deg2radf","@stdlib/math/base/special/digamma":"@stdlib/math-base-special-digamma","@stdlib/math/base/special/dirac-delta":"@stdlib/math-base-special-dirac-delta","@stdlib/number/float64/base/div":"@stdlib/number-float64-base-div","@stdlib/number/float32/base/div":"@stdlib/number-float32-base-div","@stdlib/string/base/dotcase":"@stdlib/string-base-dotcase","@stdlib/stats/base/dists/arcsine/ctor":"@stdlib/stats-base-dists-arcsine-ctor","@stdlib/stats/base/dists/arcsine/cdf":"@stdlib/stats-base-dists-arcsine-cdf","@stdlib/stats/base/dists/arcsine/entropy":"@stdlib/stats-base-dists-arcsine-entropy","@stdlib/stats/base/dists/arcsine/kurtosis":"@stdlib/stats-base-dists-arcsine-kurtosis","@stdlib/stats/base/dists/arcsine/logcdf":"@stdlib/stats-base-dists-arcsine-logcdf","@stdlib/stats/base/dists/arcsine/logpdf":"@stdlib/stats-base-dists-arcsine-logpdf","@stdlib/stats/base/dists/arcsine/mean":"@stdlib/stats-base-dists-arcsine-mean","@stdlib/stats/base/dists/arcsine/median":"@stdlib/stats-base-dists-arcsine-median","@stdlib/stats/base/dists/arcsine/mode":"@stdlib/stats-base-dists-arcsine-mode","@stdlib/stats/base/dists/arcsine/pdf":"@stdlib/stats-base-dists-arcsine-pdf","@stdlib/stats/base/dists/arcsine/quantile":"@stdlib/stats-base-dists-arcsine-quantile","@stdlib/stats/base/dists/arcsine/skewness":"@stdlib/stats-base-dists-arcsine-skewness","@stdlib/stats/base/dists/arcsine/stdev":"@stdlib/stats-base-dists-arcsine-stdev","@stdlib/stats/base/dists/arcsine/variance":"@stdlib/stats-base-dists-arcsine-variance","@stdlib/stats/base/dists/bernoulli/ctor":"@stdlib/stats-base-dists-bernoulli-ctor","@stdlib/stats/base/dists/bernoulli/cdf":"@stdlib/stats-base-dists-bernoulli-cdf","@stdlib/stats/base/dists/bernoulli/entropy":"@stdlib/stats-base-dists-bernoulli-entropy","@stdlib/stats/base/dists/bernoulli/kurtosis":"@stdlib/stats-base-dists-bernoulli-kurtosis","@stdlib/stats/base/dists/bernoulli/mean":"@stdlib/stats-base-dists-bernoulli-mean","@stdlib/stats/base/dists/bernoulli/median":"@stdlib/stats-base-dists-bernoulli-median","@stdlib/stats/base/dists/bernoulli/mgf":"@stdlib/stats-base-dists-bernoulli-mgf","@stdlib/stats/base/dists/bernoulli/mode":"@stdlib/stats-base-dists-bernoulli-mode","@stdlib/stats/base/dists/bernoulli/pmf":"@stdlib/stats-base-dists-bernoulli-pmf","@stdlib/stats/base/dists/bernoulli/quantile":"@stdlib/stats-base-dists-bernoulli-quantile","@stdlib/stats/base/dists/bernoulli/skewness":"@stdlib/stats-base-dists-bernoulli-skewness","@stdlib/stats/base/dists/bernoulli/stdev":"@stdlib/stats-base-dists-bernoulli-stdev","@stdlib/stats/base/dists/bernoulli/variance":"@stdlib/stats-base-dists-bernoulli-variance","@stdlib/stats/base/dists/beta/ctor":"@stdlib/stats-base-dists-beta-ctor","@stdlib/stats/base/dists/beta/cdf":"@stdlib/stats-base-dists-beta-cdf","@stdlib/stats/base/dists/beta/entropy":"@stdlib/stats-base-dists-beta-entropy","@stdlib/stats/base/dists/beta/kurtosis":"@stdlib/stats-base-dists-beta-kurtosis","@stdlib/stats/base/dists/beta/logcdf":"@stdlib/stats-base-dists-beta-logcdf","@stdlib/stats/base/dists/beta/logpdf":"@stdlib/stats-base-dists-beta-logpdf","@stdlib/stats/base/dists/beta/mean":"@stdlib/stats-base-dists-beta-mean","@stdlib/stats/base/dists/beta/median":"@stdlib/stats-base-dists-beta-median","@stdlib/stats/base/dists/beta/mgf":"@stdlib/stats-base-dists-beta-mgf","@stdlib/stats/base/dists/beta/mode":"@stdlib/stats-base-dists-beta-mode","@stdlib/stats/base/dists/beta/pdf":"@stdlib/stats-base-dists-beta-pdf","@stdlib/stats/base/dists/beta/quantile":"@stdlib/stats-base-dists-beta-quantile","@stdlib/stats/base/dists/beta/skewness":"@stdlib/stats-base-dists-beta-skewness","@stdlib/stats/base/dists/beta/stdev":"@stdlib/stats-base-dists-beta-stdev","@stdlib/stats/base/dists/beta/variance":"@stdlib/stats-base-dists-beta-variance","@stdlib/stats/base/dists/betaprime/ctor":"@stdlib/stats-base-dists-betaprime-ctor","@stdlib/stats/base/dists/betaprime/cdf":"@stdlib/stats-base-dists-betaprime-cdf","@stdlib/stats/base/dists/betaprime/kurtosis":"@stdlib/stats-base-dists-betaprime-kurtosis","@stdlib/stats/base/dists/betaprime/logcdf":"@stdlib/stats-base-dists-betaprime-logcdf","@stdlib/stats/base/dists/betaprime/logpdf":"@stdlib/stats-base-dists-betaprime-logpdf","@stdlib/stats/base/dists/betaprime/mean":"@stdlib/stats-base-dists-betaprime-mean","@stdlib/stats/base/dists/betaprime/mode":"@stdlib/stats-base-dists-betaprime-mode","@stdlib/stats/base/dists/betaprime/pdf":"@stdlib/stats-base-dists-betaprime-pdf","@stdlib/stats/base/dists/betaprime/quantile":"@stdlib/stats-base-dists-betaprime-quantile","@stdlib/stats/base/dists/betaprime/skewness":"@stdlib/stats-base-dists-betaprime-skewness","@stdlib/stats/base/dists/betaprime/stdev":"@stdlib/stats-base-dists-betaprime-stdev","@stdlib/stats/base/dists/betaprime/variance":"@stdlib/stats-base-dists-betaprime-variance","@stdlib/stats/base/dists/binomial/ctor":"@stdlib/stats-base-dists-binomial-ctor","@stdlib/stats/base/dists/binomial/cdf":"@stdlib/stats-base-dists-binomial-cdf","@stdlib/stats/base/dists/binomial/entropy":"@stdlib/stats-base-dists-binomial-entropy","@stdlib/stats/base/dists/binomial/kurtosis":"@stdlib/stats-base-dists-binomial-kurtosis","@stdlib/stats/base/dists/binomial/logpmf":"@stdlib/stats-base-dists-binomial-logpmf","@stdlib/stats/base/dists/binomial/mean":"@stdlib/stats-base-dists-binomial-mean","@stdlib/stats/base/dists/binomial/median":"@stdlib/stats-base-dists-binomial-median","@stdlib/stats/base/dists/binomial/mgf":"@stdlib/stats-base-dists-binomial-mgf","@stdlib/stats/base/dists/binomial/mode":"@stdlib/stats-base-dists-binomial-mode","@stdlib/stats/base/dists/binomial/pmf":"@stdlib/stats-base-dists-binomial-pmf","@stdlib/stats/base/dists/binomial/quantile":"@stdlib/stats-base-dists-binomial-quantile","@stdlib/stats/base/dists/binomial/skewness":"@stdlib/stats-base-dists-binomial-skewness","@stdlib/stats/base/dists/binomial/stdev":"@stdlib/stats-base-dists-binomial-stdev","@stdlib/stats/base/dists/binomial/variance":"@stdlib/stats-base-dists-binomial-variance","@stdlib/stats/base/dists/cauchy/ctor":"@stdlib/stats-base-dists-cauchy-ctor","@stdlib/stats/base/dists/cauchy/cdf":"@stdlib/stats-base-dists-cauchy-cdf","@stdlib/stats/base/dists/cauchy/entropy":"@stdlib/stats-base-dists-cauchy-entropy","@stdlib/stats/base/dists/cauchy/logcdf":"@stdlib/stats-base-dists-cauchy-logcdf","@stdlib/stats/base/dists/cauchy/logpdf":"@stdlib/stats-base-dists-cauchy-logpdf","@stdlib/stats/base/dists/cauchy/median":"@stdlib/stats-base-dists-cauchy-median","@stdlib/stats/base/dists/cauchy/mode":"@stdlib/stats-base-dists-cauchy-mode","@stdlib/stats/base/dists/cauchy/pdf":"@stdlib/stats-base-dists-cauchy-pdf","@stdlib/stats/base/dists/cauchy/quantile":"@stdlib/stats-base-dists-cauchy-quantile","@stdlib/stats/base/dists/chi/cdf":"@stdlib/stats-base-dists-chi-cdf","@stdlib/stats/base/dists/chi/ctor":"@stdlib/stats-base-dists-chi-ctor","@stdlib/stats/base/dists/chi/entropy":"@stdlib/stats-base-dists-chi-entropy","@stdlib/stats/base/dists/chi/kurtosis":"@stdlib/stats-base-dists-chi-kurtosis","@stdlib/stats/base/dists/chi/logpdf":"@stdlib/stats-base-dists-chi-logpdf","@stdlib/stats/base/dists/chi/mean":"@stdlib/stats-base-dists-chi-mean","@stdlib/stats/base/dists/chi/mode":"@stdlib/stats-base-dists-chi-mode","@stdlib/stats/base/dists/chi/pdf":"@stdlib/stats-base-dists-chi-pdf","@stdlib/stats/base/dists/chi/quantile":"@stdlib/stats-base-dists-chi-quantile","@stdlib/stats/base/dists/chi/skewness":"@stdlib/stats-base-dists-chi-skewness","@stdlib/stats/base/dists/chi/stdev":"@stdlib/stats-base-dists-chi-stdev","@stdlib/stats/base/dists/chi/variance":"@stdlib/stats-base-dists-chi-variance","@stdlib/stats/base/dists/chisquare/cdf":"@stdlib/stats-base-dists-chisquare-cdf","@stdlib/stats/base/dists/chisquare/ctor":"@stdlib/stats-base-dists-chisquare-ctor","@stdlib/stats/base/dists/chisquare/entropy":"@stdlib/stats-base-dists-chisquare-entropy","@stdlib/stats/base/dists/chisquare/kurtosis":"@stdlib/stats-base-dists-chisquare-kurtosis","@stdlib/stats/base/dists/chisquare/logpdf":"@stdlib/stats-base-dists-chisquare-logpdf","@stdlib/stats/base/dists/chisquare/mean":"@stdlib/stats-base-dists-chisquare-mean","@stdlib/stats/base/dists/chisquare/median":"@stdlib/stats-base-dists-chisquare-median","@stdlib/stats/base/dists/chisquare/mgf":"@stdlib/stats-base-dists-chisquare-mgf","@stdlib/stats/base/dists/chisquare/mode":"@stdlib/stats-base-dists-chisquare-mode","@stdlib/stats/base/dists/chisquare/pdf":"@stdlib/stats-base-dists-chisquare-pdf","@stdlib/stats/base/dists/chisquare/quantile":"@stdlib/stats-base-dists-chisquare-quantile","@stdlib/stats/base/dists/chisquare/skewness":"@stdlib/stats-base-dists-chisquare-skewness","@stdlib/stats/base/dists/chisquare/stdev":"@stdlib/stats-base-dists-chisquare-stdev","@stdlib/stats/base/dists/chisquare/variance":"@stdlib/stats-base-dists-chisquare-variance","@stdlib/stats/base/dists/cosine/cdf":"@stdlib/stats-base-dists-cosine-cdf","@stdlib/stats/base/dists/cosine/ctor":"@stdlib/stats-base-dists-cosine-ctor","@stdlib/stats/base/dists/cosine/kurtosis":"@stdlib/stats-base-dists-cosine-kurtosis","@stdlib/stats/base/dists/cosine/logcdf":"@stdlib/stats-base-dists-cosine-logcdf","@stdlib/stats/base/dists/cosine/logpdf":"@stdlib/stats-base-dists-cosine-logpdf","@stdlib/stats/base/dists/cosine/mean":"@stdlib/stats-base-dists-cosine-mean","@stdlib/stats/base/dists/cosine/median":"@stdlib/stats-base-dists-cosine-median","@stdlib/stats/base/dists/cosine/mgf":"@stdlib/stats-base-dists-cosine-mgf","@stdlib/stats/base/dists/cosine/mode":"@stdlib/stats-base-dists-cosine-mode","@stdlib/stats/base/dists/cosine/pdf":"@stdlib/stats-base-dists-cosine-pdf","@stdlib/stats/base/dists/cosine/quantile":"@stdlib/stats-base-dists-cosine-quantile","@stdlib/stats/base/dists/cosine/skewness":"@stdlib/stats-base-dists-cosine-skewness","@stdlib/stats/base/dists/cosine/stdev":"@stdlib/stats-base-dists-cosine-stdev","@stdlib/stats/base/dists/cosine/variance":"@stdlib/stats-base-dists-cosine-variance","@stdlib/stats/base/dists/degenerate/cdf":"@stdlib/stats-base-dists-degenerate-cdf","@stdlib/stats/base/dists/degenerate/ctor":"@stdlib/stats-base-dists-degenerate-ctor","@stdlib/stats/base/dists/degenerate/entropy":"@stdlib/stats-base-dists-degenerate-entropy","@stdlib/stats/base/dists/degenerate/logcdf":"@stdlib/stats-base-dists-degenerate-logcdf","@stdlib/stats/base/dists/degenerate/logpdf":"@stdlib/stats-base-dists-degenerate-logpdf","@stdlib/stats/base/dists/degenerate/logpmf":"@stdlib/stats-base-dists-degenerate-logpmf","@stdlib/stats/base/dists/degenerate/mean":"@stdlib/stats-base-dists-degenerate-mean","@stdlib/stats/base/dists/degenerate/median":"@stdlib/stats-base-dists-degenerate-median","@stdlib/stats/base/dists/degenerate/mgf":"@stdlib/stats-base-dists-degenerate-mgf","@stdlib/stats/base/dists/degenerate/mode":"@stdlib/stats-base-dists-degenerate-mode","@stdlib/stats/base/dists/degenerate/pdf":"@stdlib/stats-base-dists-degenerate-pdf","@stdlib/stats/base/dists/degenerate/pmf":"@stdlib/stats-base-dists-degenerate-pmf","@stdlib/stats/base/dists/degenerate/quantile":"@stdlib/stats-base-dists-degenerate-quantile","@stdlib/stats/base/dists/degenerate/stdev":"@stdlib/stats-base-dists-degenerate-stdev","@stdlib/stats/base/dists/degenerate/variance":"@stdlib/stats-base-dists-degenerate-variance","@stdlib/stats/base/dists/discrete-uniform/cdf":"@stdlib/stats-base-dists-discrete-uniform-cdf","@stdlib/stats/base/dists/discrete-uniform/ctor":"@stdlib/stats-base-dists-discrete-uniform-ctor","@stdlib/stats/base/dists/discrete-uniform/entropy":"@stdlib/stats-base-dists-discrete-uniform-entropy","@stdlib/stats/base/dists/discrete-uniform/kurtosis":"@stdlib/stats-base-dists-discrete-uniform-kurtosis","@stdlib/stats/base/dists/discrete-uniform/logcdf":"@stdlib/stats-base-dists-discrete-uniform-logcdf","@stdlib/stats/base/dists/discrete-uniform/logpmf":"@stdlib/stats-base-dists-discrete-uniform-logpmf","@stdlib/stats/base/dists/discrete-uniform/mean":"@stdlib/stats-base-dists-discrete-uniform-mean","@stdlib/stats/base/dists/discrete-uniform/median":"@stdlib/stats-base-dists-discrete-uniform-median","@stdlib/stats/base/dists/discrete-uniform/mgf":"@stdlib/stats-base-dists-discrete-uniform-mgf","@stdlib/stats/base/dists/discrete-uniform/pmf":"@stdlib/stats-base-dists-discrete-uniform-pmf","@stdlib/stats/base/dists/discrete-uniform/quantile":"@stdlib/stats-base-dists-discrete-uniform-quantile","@stdlib/stats/base/dists/discrete-uniform/skewness":"@stdlib/stats-base-dists-discrete-uniform-skewness","@stdlib/stats/base/dists/discrete-uniform/stdev":"@stdlib/stats-base-dists-discrete-uniform-stdev","@stdlib/stats/base/dists/discrete-uniform/variance":"@stdlib/stats-base-dists-discrete-uniform-variance","@stdlib/stats/base/dists/erlang/cdf":"@stdlib/stats-base-dists-erlang-cdf","@stdlib/stats/base/dists/erlang/entropy":"@stdlib/stats-base-dists-erlang-entropy","@stdlib/stats/base/dists/erlang/ctor":"@stdlib/stats-base-dists-erlang-ctor","@stdlib/stats/base/dists/erlang/kurtosis":"@stdlib/stats-base-dists-erlang-kurtosis","@stdlib/stats/base/dists/erlang/logpdf":"@stdlib/stats-base-dists-erlang-logpdf","@stdlib/stats/base/dists/erlang/mean":"@stdlib/stats-base-dists-erlang-mean","@stdlib/stats/base/dists/erlang/mgf":"@stdlib/stats-base-dists-erlang-mgf","@stdlib/stats/base/dists/erlang/mode":"@stdlib/stats-base-dists-erlang-mode","@stdlib/stats/base/dists/erlang/pdf":"@stdlib/stats-base-dists-erlang-pdf","@stdlib/stats/base/dists/erlang/quantile":"@stdlib/stats-base-dists-erlang-quantile","@stdlib/stats/base/dists/erlang/skewness":"@stdlib/stats-base-dists-erlang-skewness","@stdlib/stats/base/dists/erlang/stdev":"@stdlib/stats-base-dists-erlang-stdev","@stdlib/stats/base/dists/erlang/variance":"@stdlib/stats-base-dists-erlang-variance","@stdlib/stats/base/dists/exponential/cdf":"@stdlib/stats-base-dists-exponential-cdf","@stdlib/stats/base/dists/exponential/entropy":"@stdlib/stats-base-dists-exponential-entropy","@stdlib/stats/base/dists/exponential/ctor":"@stdlib/stats-base-dists-exponential-ctor","@stdlib/stats/base/dists/exponential/kurtosis":"@stdlib/stats-base-dists-exponential-kurtosis","@stdlib/stats/base/dists/exponential/logcdf":"@stdlib/stats-base-dists-exponential-logcdf","@stdlib/stats/base/dists/exponential/logpdf":"@stdlib/stats-base-dists-exponential-logpdf","@stdlib/stats/base/dists/exponential/mean":"@stdlib/stats-base-dists-exponential-mean","@stdlib/stats/base/dists/exponential/median":"@stdlib/stats-base-dists-exponential-median","@stdlib/stats/base/dists/exponential/mgf":"@stdlib/stats-base-dists-exponential-mgf","@stdlib/stats/base/dists/exponential/mode":"@stdlib/stats-base-dists-exponential-mode","@stdlib/stats/base/dists/exponential/pdf":"@stdlib/stats-base-dists-exponential-pdf","@stdlib/stats/base/dists/exponential/quantile":"@stdlib/stats-base-dists-exponential-quantile","@stdlib/stats/base/dists/exponential/skewness":"@stdlib/stats-base-dists-exponential-skewness","@stdlib/stats/base/dists/exponential/stdev":"@stdlib/stats-base-dists-exponential-stdev","@stdlib/stats/base/dists/exponential/variance":"@stdlib/stats-base-dists-exponential-variance","@stdlib/stats/base/dists/f/cdf":"@stdlib/stats-base-dists-f-cdf","@stdlib/stats/base/dists/f/entropy":"@stdlib/stats-base-dists-f-entropy","@stdlib/stats/base/dists/f/ctor":"@stdlib/stats-base-dists-f-ctor","@stdlib/stats/base/dists/f/kurtosis":"@stdlib/stats-base-dists-f-kurtosis","@stdlib/stats/base/dists/f/mean":"@stdlib/stats-base-dists-f-mean","@stdlib/stats/base/dists/f/mode":"@stdlib/stats-base-dists-f-mode","@stdlib/stats/base/dists/f/pdf":"@stdlib/stats-base-dists-f-pdf","@stdlib/stats/base/dists/f/quantile":"@stdlib/stats-base-dists-f-quantile","@stdlib/stats/base/dists/f/skewness":"@stdlib/stats-base-dists-f-skewness","@stdlib/stats/base/dists/f/stdev":"@stdlib/stats-base-dists-f-stdev","@stdlib/stats/base/dists/f/variance":"@stdlib/stats-base-dists-f-variance","@stdlib/stats/base/dists/frechet/cdf":"@stdlib/stats-base-dists-frechet-cdf","@stdlib/stats/base/dists/frechet/entropy":"@stdlib/stats-base-dists-frechet-entropy","@stdlib/stats/base/dists/frechet/ctor":"@stdlib/stats-base-dists-frechet-ctor","@stdlib/stats/base/dists/frechet/kurtosis":"@stdlib/stats-base-dists-frechet-kurtosis","@stdlib/stats/base/dists/frechet/logcdf":"@stdlib/stats-base-dists-frechet-logcdf","@stdlib/stats/base/dists/frechet/logpdf":"@stdlib/stats-base-dists-frechet-logpdf","@stdlib/stats/base/dists/frechet/mean":"@stdlib/stats-base-dists-frechet-mean","@stdlib/stats/base/dists/frechet/median":"@stdlib/stats-base-dists-frechet-median","@stdlib/stats/base/dists/frechet/mode":"@stdlib/stats-base-dists-frechet-mode","@stdlib/stats/base/dists/frechet/pdf":"@stdlib/stats-base-dists-frechet-pdf","@stdlib/stats/base/dists/frechet/quantile":"@stdlib/stats-base-dists-frechet-quantile","@stdlib/stats/base/dists/frechet/skewness":"@stdlib/stats-base-dists-frechet-skewness","@stdlib/stats/base/dists/frechet/stdev":"@stdlib/stats-base-dists-frechet-stdev","@stdlib/stats/base/dists/frechet/variance":"@stdlib/stats-base-dists-frechet-variance","@stdlib/stats/base/dists/gamma/cdf":"@stdlib/stats-base-dists-gamma-cdf","@stdlib/stats/base/dists/gamma/entropy":"@stdlib/stats-base-dists-gamma-entropy","@stdlib/stats/base/dists/gamma/ctor":"@stdlib/stats-base-dists-gamma-ctor","@stdlib/stats/base/dists/gamma/kurtosis":"@stdlib/stats-base-dists-gamma-kurtosis","@stdlib/stats/base/dists/gamma/logcdf":"@stdlib/stats-base-dists-gamma-logcdf","@stdlib/stats/base/dists/gamma/logpdf":"@stdlib/stats-base-dists-gamma-logpdf","@stdlib/stats/base/dists/gamma/mean":"@stdlib/stats-base-dists-gamma-mean","@stdlib/stats/base/dists/gamma/mgf":"@stdlib/stats-base-dists-gamma-mgf","@stdlib/stats/base/dists/gamma/mode":"@stdlib/stats-base-dists-gamma-mode","@stdlib/stats/base/dists/gamma/pdf":"@stdlib/stats-base-dists-gamma-pdf","@stdlib/stats/base/dists/gamma/quantile":"@stdlib/stats-base-dists-gamma-quantile","@stdlib/stats/base/dists/gamma/skewness":"@stdlib/stats-base-dists-gamma-skewness","@stdlib/stats/base/dists/gamma/stdev":"@stdlib/stats-base-dists-gamma-stdev","@stdlib/stats/base/dists/gamma/variance":"@stdlib/stats-base-dists-gamma-variance","@stdlib/stats/base/dists/geometric/cdf":"@stdlib/stats-base-dists-geometric-cdf","@stdlib/stats/base/dists/geometric/entropy":"@stdlib/stats-base-dists-geometric-entropy","@stdlib/stats/base/dists/geometric/ctor":"@stdlib/stats-base-dists-geometric-ctor","@stdlib/stats/base/dists/geometric/kurtosis":"@stdlib/stats-base-dists-geometric-kurtosis","@stdlib/stats/base/dists/geometric/logcdf":"@stdlib/stats-base-dists-geometric-logcdf","@stdlib/stats/base/dists/geometric/logpmf":"@stdlib/stats-base-dists-geometric-logpmf","@stdlib/stats/base/dists/geometric/mean":"@stdlib/stats-base-dists-geometric-mean","@stdlib/stats/base/dists/geometric/median":"@stdlib/stats-base-dists-geometric-median","@stdlib/stats/base/dists/geometric/mgf":"@stdlib/stats-base-dists-geometric-mgf","@stdlib/stats/base/dists/geometric/mode":"@stdlib/stats-base-dists-geometric-mode","@stdlib/stats/base/dists/geometric/pmf":"@stdlib/stats-base-dists-geometric-pmf","@stdlib/stats/base/dists/geometric/quantile":"@stdlib/stats-base-dists-geometric-quantile","@stdlib/stats/base/dists/geometric/skewness":"@stdlib/stats-base-dists-geometric-skewness","@stdlib/stats/base/dists/geometric/stdev":"@stdlib/stats-base-dists-geometric-stdev","@stdlib/stats/base/dists/geometric/variance":"@stdlib/stats-base-dists-geometric-variance","@stdlib/stats/base/dists/gumbel/cdf":"@stdlib/stats-base-dists-gumbel-cdf","@stdlib/stats/base/dists/gumbel/entropy":"@stdlib/stats-base-dists-gumbel-entropy","@stdlib/stats/base/dists/gumbel/ctor":"@stdlib/stats-base-dists-gumbel-ctor","@stdlib/stats/base/dists/gumbel/kurtosis":"@stdlib/stats-base-dists-gumbel-kurtosis","@stdlib/stats/base/dists/gumbel/logcdf":"@stdlib/stats-base-dists-gumbel-logcdf","@stdlib/stats/base/dists/gumbel/logpdf":"@stdlib/stats-base-dists-gumbel-logpdf","@stdlib/stats/base/dists/gumbel/mean":"@stdlib/stats-base-dists-gumbel-mean","@stdlib/stats/base/dists/gumbel/median":"@stdlib/stats-base-dists-gumbel-median","@stdlib/stats/base/dists/gumbel/mgf":"@stdlib/stats-base-dists-gumbel-mgf","@stdlib/stats/base/dists/gumbel/mode":"@stdlib/stats-base-dists-gumbel-mode","@stdlib/stats/base/dists/gumbel/pdf":"@stdlib/stats-base-dists-gumbel-pdf","@stdlib/stats/base/dists/gumbel/quantile":"@stdlib/stats-base-dists-gumbel-quantile","@stdlib/stats/base/dists/gumbel/skewness":"@stdlib/stats-base-dists-gumbel-skewness","@stdlib/stats/base/dists/gumbel/stdev":"@stdlib/stats-base-dists-gumbel-stdev","@stdlib/stats/base/dists/gumbel/variance":"@stdlib/stats-base-dists-gumbel-variance","@stdlib/stats/base/dists/hypergeometric/cdf":"@stdlib/stats-base-dists-hypergeometric-cdf","@stdlib/stats/base/dists/hypergeometric/ctor":"@stdlib/stats-base-dists-hypergeometric-ctor","@stdlib/stats/base/dists/hypergeometric/kurtosis":"@stdlib/stats-base-dists-hypergeometric-kurtosis","@stdlib/stats/base/dists/hypergeometric/logpmf":"@stdlib/stats-base-dists-hypergeometric-logpmf","@stdlib/stats/base/dists/hypergeometric/mean":"@stdlib/stats-base-dists-hypergeometric-mean","@stdlib/stats/base/dists/hypergeometric/mode":"@stdlib/stats-base-dists-hypergeometric-mode","@stdlib/stats/base/dists/hypergeometric/pmf":"@stdlib/stats-base-dists-hypergeometric-pmf","@stdlib/stats/base/dists/hypergeometric/quantile":"@stdlib/stats-base-dists-hypergeometric-quantile","@stdlib/stats/base/dists/hypergeometric/skewness":"@stdlib/stats-base-dists-hypergeometric-skewness","@stdlib/stats/base/dists/hypergeometric/stdev":"@stdlib/stats-base-dists-hypergeometric-stdev","@stdlib/stats/base/dists/hypergeometric/variance":"@stdlib/stats-base-dists-hypergeometric-variance","@stdlib/stats/base/dists/invgamma/cdf":"@stdlib/stats-base-dists-invgamma-cdf","@stdlib/stats/base/dists/invgamma/entropy":"@stdlib/stats-base-dists-invgamma-entropy","@stdlib/stats/base/dists/invgamma/ctor":"@stdlib/stats-base-dists-invgamma-ctor","@stdlib/stats/base/dists/invgamma/kurtosis":"@stdlib/stats-base-dists-invgamma-kurtosis","@stdlib/stats/base/dists/invgamma/logpdf":"@stdlib/stats-base-dists-invgamma-logpdf","@stdlib/stats/base/dists/invgamma/mean":"@stdlib/stats-base-dists-invgamma-mean","@stdlib/stats/base/dists/invgamma/mode":"@stdlib/stats-base-dists-invgamma-mode","@stdlib/stats/base/dists/invgamma/pdf":"@stdlib/stats-base-dists-invgamma-pdf","@stdlib/stats/base/dists/invgamma/quantile":"@stdlib/stats-base-dists-invgamma-quantile","@stdlib/stats/base/dists/invgamma/skewness":"@stdlib/stats-base-dists-invgamma-skewness","@stdlib/stats/base/dists/invgamma/stdev":"@stdlib/stats-base-dists-invgamma-stdev","@stdlib/stats/base/dists/invgamma/variance":"@stdlib/stats-base-dists-invgamma-variance","@stdlib/stats/base/dists/kumaraswamy/cdf":"@stdlib/stats-base-dists-kumaraswamy-cdf","@stdlib/stats/base/dists/kumaraswamy/ctor":"@stdlib/stats-base-dists-kumaraswamy-ctor","@stdlib/stats/base/dists/kumaraswamy/kurtosis":"@stdlib/stats-base-dists-kumaraswamy-kurtosis","@stdlib/stats/base/dists/kumaraswamy/logcdf":"@stdlib/stats-base-dists-kumaraswamy-logcdf","@stdlib/stats/base/dists/kumaraswamy/logpdf":"@stdlib/stats-base-dists-kumaraswamy-logpdf","@stdlib/stats/base/dists/kumaraswamy/mean":"@stdlib/stats-base-dists-kumaraswamy-mean","@stdlib/stats/base/dists/kumaraswamy/median":"@stdlib/stats-base-dists-kumaraswamy-median","@stdlib/stats/base/dists/kumaraswamy/mode":"@stdlib/stats-base-dists-kumaraswamy-mode","@stdlib/stats/base/dists/kumaraswamy/pdf":"@stdlib/stats-base-dists-kumaraswamy-pdf","@stdlib/stats/base/dists/kumaraswamy/quantile":"@stdlib/stats-base-dists-kumaraswamy-quantile","@stdlib/stats/base/dists/kumaraswamy/skewness":"@stdlib/stats-base-dists-kumaraswamy-skewness","@stdlib/stats/base/dists/kumaraswamy/stdev":"@stdlib/stats-base-dists-kumaraswamy-stdev","@stdlib/stats/base/dists/kumaraswamy/variance":"@stdlib/stats-base-dists-kumaraswamy-variance","@stdlib/stats/base/dists/laplace/cdf":"@stdlib/stats-base-dists-laplace-cdf","@stdlib/stats/base/dists/laplace/entropy":"@stdlib/stats-base-dists-laplace-entropy","@stdlib/stats/base/dists/laplace/kurtosis":"@stdlib/stats-base-dists-laplace-kurtosis","@stdlib/stats/base/dists/laplace/ctor":"@stdlib/stats-base-dists-laplace-ctor","@stdlib/stats/base/dists/laplace/logcdf":"@stdlib/stats-base-dists-laplace-logcdf","@stdlib/stats/base/dists/laplace/logpdf":"@stdlib/stats-base-dists-laplace-logpdf","@stdlib/stats/base/dists/laplace/mean":"@stdlib/stats-base-dists-laplace-mean","@stdlib/stats/base/dists/laplace/median":"@stdlib/stats-base-dists-laplace-median","@stdlib/stats/base/dists/laplace/mgf":"@stdlib/stats-base-dists-laplace-mgf","@stdlib/stats/base/dists/laplace/mode":"@stdlib/stats-base-dists-laplace-mode","@stdlib/stats/base/dists/laplace/pdf":"@stdlib/stats-base-dists-laplace-pdf","@stdlib/stats/base/dists/laplace/quantile":"@stdlib/stats-base-dists-laplace-quantile","@stdlib/stats/base/dists/laplace/skewness":"@stdlib/stats-base-dists-laplace-skewness","@stdlib/stats/base/dists/laplace/stdev":"@stdlib/stats-base-dists-laplace-stdev","@stdlib/stats/base/dists/laplace/variance":"@stdlib/stats-base-dists-laplace-variance","@stdlib/stats/base/dists/levy/cdf":"@stdlib/stats-base-dists-levy-cdf","@stdlib/stats/base/dists/levy/entropy":"@stdlib/stats-base-dists-levy-entropy","@stdlib/stats/base/dists/levy/ctor":"@stdlib/stats-base-dists-levy-ctor","@stdlib/stats/base/dists/levy/logcdf":"@stdlib/stats-base-dists-levy-logcdf","@stdlib/stats/base/dists/levy/logpdf":"@stdlib/stats-base-dists-levy-logpdf","@stdlib/stats/base/dists/levy/mean":"@stdlib/stats-base-dists-levy-mean","@stdlib/stats/base/dists/levy/median":"@stdlib/stats-base-dists-levy-median","@stdlib/stats/base/dists/levy/mode":"@stdlib/stats-base-dists-levy-mode","@stdlib/stats/base/dists/levy/pdf":"@stdlib/stats-base-dists-levy-pdf","@stdlib/stats/base/dists/levy/quantile":"@stdlib/stats-base-dists-levy-quantile","@stdlib/stats/base/dists/levy/stdev":"@stdlib/stats-base-dists-levy-stdev","@stdlib/stats/base/dists/levy/variance":"@stdlib/stats-base-dists-levy-variance","@stdlib/stats/base/dists/logistic/cdf":"@stdlib/stats-base-dists-logistic-cdf","@stdlib/stats/base/dists/logistic/entropy":"@stdlib/stats-base-dists-logistic-entropy","@stdlib/stats/base/dists/logistic/kurtosis":"@stdlib/stats-base-dists-logistic-kurtosis","@stdlib/stats/base/dists/logistic/logcdf":"@stdlib/stats-base-dists-logistic-logcdf","@stdlib/stats/base/dists/logistic/ctor":"@stdlib/stats-base-dists-logistic-ctor","@stdlib/stats/base/dists/logistic/logpdf":"@stdlib/stats-base-dists-logistic-logpdf","@stdlib/stats/base/dists/logistic/mean":"@stdlib/stats-base-dists-logistic-mean","@stdlib/stats/base/dists/logistic/median":"@stdlib/stats-base-dists-logistic-median","@stdlib/stats/base/dists/logistic/mgf":"@stdlib/stats-base-dists-logistic-mgf","@stdlib/stats/base/dists/logistic/mode":"@stdlib/stats-base-dists-logistic-mode","@stdlib/stats/base/dists/logistic/pdf":"@stdlib/stats-base-dists-logistic-pdf","@stdlib/stats/base/dists/logistic/quantile":"@stdlib/stats-base-dists-logistic-quantile","@stdlib/stats/base/dists/logistic/skewness":"@stdlib/stats-base-dists-logistic-skewness","@stdlib/stats/base/dists/logistic/stdev":"@stdlib/stats-base-dists-logistic-stdev","@stdlib/stats/base/dists/logistic/variance":"@stdlib/stats-base-dists-logistic-variance","@stdlib/stats/base/dists/lognormal/cdf":"@stdlib/stats-base-dists-lognormal-cdf","@stdlib/stats/base/dists/lognormal/entropy":"@stdlib/stats-base-dists-lognormal-entropy","@stdlib/stats/base/dists/lognormal/kurtosis":"@stdlib/stats-base-dists-lognormal-kurtosis","@stdlib/stats/base/dists/lognormal/ctor":"@stdlib/stats-base-dists-lognormal-ctor","@stdlib/stats/base/dists/lognormal/logcdf":"@stdlib/stats-base-dists-lognormal-logcdf","@stdlib/stats/base/dists/lognormal/logpdf":"@stdlib/stats-base-dists-lognormal-logpdf","@stdlib/stats/base/dists/lognormal/mean":"@stdlib/stats-base-dists-lognormal-mean","@stdlib/stats/base/dists/lognormal/median":"@stdlib/stats-base-dists-lognormal-median","@stdlib/stats/base/dists/lognormal/mode":"@stdlib/stats-base-dists-lognormal-mode","@stdlib/stats/base/dists/lognormal/pdf":"@stdlib/stats-base-dists-lognormal-pdf","@stdlib/stats/base/dists/lognormal/quantile":"@stdlib/stats-base-dists-lognormal-quantile","@stdlib/stats/base/dists/lognormal/skewness":"@stdlib/stats-base-dists-lognormal-skewness","@stdlib/stats/base/dists/lognormal/stdev":"@stdlib/stats-base-dists-lognormal-stdev","@stdlib/stats/base/dists/lognormal/variance":"@stdlib/stats-base-dists-lognormal-variance","@stdlib/stats/base/dists/negative-binomial/cdf":"@stdlib/stats-base-dists-negative-binomial-cdf","@stdlib/stats/base/dists/negative-binomial/kurtosis":"@stdlib/stats-base-dists-negative-binomial-kurtosis","@stdlib/stats/base/dists/negative-binomial/logpmf":"@stdlib/stats-base-dists-negative-binomial-logpmf","@stdlib/stats/base/dists/negative-binomial/mean":"@stdlib/stats-base-dists-negative-binomial-mean","@stdlib/stats/base/dists/negative-binomial/mgf":"@stdlib/stats-base-dists-negative-binomial-mgf","@stdlib/stats/base/dists/negative-binomial/mode":"@stdlib/stats-base-dists-negative-binomial-mode","@stdlib/stats/base/dists/negative-binomial/ctor":"@stdlib/stats-base-dists-negative-binomial-ctor","@stdlib/stats/base/dists/negative-binomial/pmf":"@stdlib/stats-base-dists-negative-binomial-pmf","@stdlib/stats/base/dists/negative-binomial/quantile":"@stdlib/stats-base-dists-negative-binomial-quantile","@stdlib/stats/base/dists/negative-binomial/skewness":"@stdlib/stats-base-dists-negative-binomial-skewness","@stdlib/stats/base/dists/negative-binomial/stdev":"@stdlib/stats-base-dists-negative-binomial-stdev","@stdlib/stats/base/dists/negative-binomial/variance":"@stdlib/stats-base-dists-negative-binomial-variance","@stdlib/stats/base/dists/normal/cdf":"@stdlib/stats-base-dists-normal-cdf","@stdlib/stats/base/dists/normal/entropy":"@stdlib/stats-base-dists-normal-entropy","@stdlib/stats/base/dists/normal/kurtosis":"@stdlib/stats-base-dists-normal-kurtosis","@stdlib/stats/base/dists/normal/logcdf":"@stdlib/stats-base-dists-normal-logcdf","@stdlib/stats/base/dists/normal/logpdf":"@stdlib/stats-base-dists-normal-logpdf","@stdlib/stats/base/dists/normal/mean":"@stdlib/stats-base-dists-normal-mean","@stdlib/stats/base/dists/normal/median":"@stdlib/stats-base-dists-normal-median","@stdlib/stats/base/dists/normal/mgf":"@stdlib/stats-base-dists-normal-mgf","@stdlib/stats/base/dists/normal/mode":"@stdlib/stats-base-dists-normal-mode","@stdlib/stats/base/dists/normal/ctor":"@stdlib/stats-base-dists-normal-ctor","@stdlib/stats/base/dists/normal/pdf":"@stdlib/stats-base-dists-normal-pdf","@stdlib/stats/base/dists/normal/quantile":"@stdlib/stats-base-dists-normal-quantile","@stdlib/stats/base/dists/normal/skewness":"@stdlib/stats-base-dists-normal-skewness","@stdlib/stats/base/dists/normal/stdev":"@stdlib/stats-base-dists-normal-stdev","@stdlib/stats/base/dists/normal/variance":"@stdlib/stats-base-dists-normal-variance","@stdlib/stats/base/dists/pareto-type1/cdf":"@stdlib/stats-base-dists-pareto-type1-cdf","@stdlib/stats/base/dists/pareto-type1/entropy":"@stdlib/stats-base-dists-pareto-type1-entropy","@stdlib/stats/base/dists/pareto-type1/kurtosis":"@stdlib/stats-base-dists-pareto-type1-kurtosis","@stdlib/stats/base/dists/pareto-type1/logcdf":"@stdlib/stats-base-dists-pareto-type1-logcdf","@stdlib/stats/base/dists/pareto-type1/logpdf":"@stdlib/stats-base-dists-pareto-type1-logpdf","@stdlib/stats/base/dists/pareto-type1/mean":"@stdlib/stats-base-dists-pareto-type1-mean","@stdlib/stats/base/dists/pareto-type1/median":"@stdlib/stats-base-dists-pareto-type1-median","@stdlib/stats/base/dists/pareto-type1/mode":"@stdlib/stats-base-dists-pareto-type1-mode","@stdlib/stats/base/dists/pareto-type1/ctor":"@stdlib/stats-base-dists-pareto-type1-ctor","@stdlib/stats/base/dists/pareto-type1/pdf":"@stdlib/stats-base-dists-pareto-type1-pdf","@stdlib/stats/base/dists/pareto-type1/quantile":"@stdlib/stats-base-dists-pareto-type1-quantile","@stdlib/stats/base/dists/pareto-type1/skewness":"@stdlib/stats-base-dists-pareto-type1-skewness","@stdlib/stats/base/dists/pareto-type1/stdev":"@stdlib/stats-base-dists-pareto-type1-stdev","@stdlib/stats/base/dists/pareto-type1/variance":"@stdlib/stats-base-dists-pareto-type1-variance","@stdlib/stats/base/dists/poisson/cdf":"@stdlib/stats-base-dists-poisson-cdf","@stdlib/stats/base/dists/poisson/entropy":"@stdlib/stats-base-dists-poisson-entropy","@stdlib/stats/base/dists/poisson/kurtosis":"@stdlib/stats-base-dists-poisson-kurtosis","@stdlib/stats/base/dists/poisson/logpmf":"@stdlib/stats-base-dists-poisson-logpmf","@stdlib/stats/base/dists/poisson/mean":"@stdlib/stats-base-dists-poisson-mean","@stdlib/stats/base/dists/poisson/median":"@stdlib/stats-base-dists-poisson-median","@stdlib/stats/base/dists/poisson/mgf":"@stdlib/stats-base-dists-poisson-mgf","@stdlib/stats/base/dists/poisson/mode":"@stdlib/stats-base-dists-poisson-mode","@stdlib/stats/base/dists/poisson/pmf":"@stdlib/stats-base-dists-poisson-pmf","@stdlib/stats/base/dists/poisson/ctor":"@stdlib/stats-base-dists-poisson-ctor","@stdlib/stats/base/dists/poisson/quantile":"@stdlib/stats-base-dists-poisson-quantile","@stdlib/stats/base/dists/poisson/skewness":"@stdlib/stats-base-dists-poisson-skewness","@stdlib/stats/base/dists/poisson/stdev":"@stdlib/stats-base-dists-poisson-stdev","@stdlib/stats/base/dists/poisson/variance":"@stdlib/stats-base-dists-poisson-variance","@stdlib/stats/base/dists/rayleigh/cdf":"@stdlib/stats-base-dists-rayleigh-cdf","@stdlib/stats/base/dists/rayleigh/entropy":"@stdlib/stats-base-dists-rayleigh-entropy","@stdlib/stats/base/dists/rayleigh/kurtosis":"@stdlib/stats-base-dists-rayleigh-kurtosis","@stdlib/stats/base/dists/rayleigh/logcdf":"@stdlib/stats-base-dists-rayleigh-logcdf","@stdlib/stats/base/dists/rayleigh/logpdf":"@stdlib/stats-base-dists-rayleigh-logpdf","@stdlib/stats/base/dists/rayleigh/mean":"@stdlib/stats-base-dists-rayleigh-mean","@stdlib/stats/base/dists/rayleigh/median":"@stdlib/stats-base-dists-rayleigh-median","@stdlib/stats/base/dists/rayleigh/mgf":"@stdlib/stats-base-dists-rayleigh-mgf","@stdlib/stats/base/dists/rayleigh/mode":"@stdlib/stats-base-dists-rayleigh-mode","@stdlib/stats/base/dists/rayleigh/pdf":"@stdlib/stats-base-dists-rayleigh-pdf","@stdlib/stats/base/dists/rayleigh/quantile":"@stdlib/stats-base-dists-rayleigh-quantile","@stdlib/stats/base/dists/rayleigh/ctor":"@stdlib/stats-base-dists-rayleigh-ctor","@stdlib/stats/base/dists/rayleigh/skewness":"@stdlib/stats-base-dists-rayleigh-skewness","@stdlib/stats/base/dists/rayleigh/stdev":"@stdlib/stats-base-dists-rayleigh-stdev","@stdlib/stats/base/dists/rayleigh/variance":"@stdlib/stats-base-dists-rayleigh-variance","@stdlib/stats/base/dists/signrank/cdf":"@stdlib/stats-base-dists-signrank-cdf","@stdlib/stats/base/dists/signrank/pdf":"@stdlib/stats-base-dists-signrank-pdf","@stdlib/stats/base/dists/signrank/quantile":"@stdlib/stats-base-dists-signrank-quantile","@stdlib/stats/base/dists/studentized-range/cdf":"@stdlib/stats-base-dists-studentized-range-cdf","@stdlib/stats/base/dists/studentized-range/quantile":"@stdlib/stats-base-dists-studentized-range-quantile","@stdlib/stats/base/dists/t/cdf":"@stdlib/stats-base-dists-t-cdf","@stdlib/stats/base/dists/t/entropy":"@stdlib/stats-base-dists-t-entropy","@stdlib/stats/base/dists/t/kurtosis":"@stdlib/stats-base-dists-t-kurtosis","@stdlib/stats/base/dists/t/logcdf":"@stdlib/stats-base-dists-t-logcdf","@stdlib/stats/base/dists/t/logpdf":"@stdlib/stats-base-dists-t-logpdf","@stdlib/stats/base/dists/t/mean":"@stdlib/stats-base-dists-t-mean","@stdlib/stats/base/dists/t/median":"@stdlib/stats-base-dists-t-median","@stdlib/stats/base/dists/t/mode":"@stdlib/stats-base-dists-t-mode","@stdlib/stats/base/dists/t/pdf":"@stdlib/stats-base-dists-t-pdf","@stdlib/stats/base/dists/t/quantile":"@stdlib/stats-base-dists-t-quantile","@stdlib/stats/base/dists/t/skewness":"@stdlib/stats-base-dists-t-skewness","@stdlib/stats/base/dists/t/stdev":"@stdlib/stats-base-dists-t-stdev","@stdlib/stats/base/dists/t/ctor":"@stdlib/stats-base-dists-t-ctor","@stdlib/stats/base/dists/t/variance":"@stdlib/stats-base-dists-t-variance","@stdlib/stats/base/dists/triangular/cdf":"@stdlib/stats-base-dists-triangular-cdf","@stdlib/stats/base/dists/triangular/entropy":"@stdlib/stats-base-dists-triangular-entropy","@stdlib/stats/base/dists/triangular/kurtosis":"@stdlib/stats-base-dists-triangular-kurtosis","@stdlib/stats/base/dists/triangular/logcdf":"@stdlib/stats-base-dists-triangular-logcdf","@stdlib/stats/base/dists/triangular/logpdf":"@stdlib/stats-base-dists-triangular-logpdf","@stdlib/stats/base/dists/triangular/mean":"@stdlib/stats-base-dists-triangular-mean","@stdlib/stats/base/dists/triangular/median":"@stdlib/stats-base-dists-triangular-median","@stdlib/stats/base/dists/triangular/mgf":"@stdlib/stats-base-dists-triangular-mgf","@stdlib/stats/base/dists/triangular/mode":"@stdlib/stats-base-dists-triangular-mode","@stdlib/stats/base/dists/triangular/pdf":"@stdlib/stats-base-dists-triangular-pdf","@stdlib/stats/base/dists/triangular/quantile":"@stdlib/stats-base-dists-triangular-quantile","@stdlib/stats/base/dists/triangular/skewness":"@stdlib/stats-base-dists-triangular-skewness","@stdlib/stats/base/dists/triangular/stdev":"@stdlib/stats-base-dists-triangular-stdev","@stdlib/stats/base/dists/triangular/ctor":"@stdlib/stats-base-dists-triangular-ctor","@stdlib/stats/base/dists/triangular/variance":"@stdlib/stats-base-dists-triangular-variance","@stdlib/stats/base/dists/truncated-normal/pdf":"@stdlib/stats-base-dists-truncated-normal-pdf","@stdlib/stats/base/dists/uniform/cdf":"@stdlib/stats-base-dists-uniform-cdf","@stdlib/stats/base/dists/uniform/entropy":"@stdlib/stats-base-dists-uniform-entropy","@stdlib/stats/base/dists/uniform/kurtosis":"@stdlib/stats-base-dists-uniform-kurtosis","@stdlib/stats/base/dists/uniform/logcdf":"@stdlib/stats-base-dists-uniform-logcdf","@stdlib/stats/base/dists/uniform/logpdf":"@stdlib/stats-base-dists-uniform-logpdf","@stdlib/stats/base/dists/uniform/mean":"@stdlib/stats-base-dists-uniform-mean","@stdlib/stats/base/dists/uniform/median":"@stdlib/stats-base-dists-uniform-median","@stdlib/stats/base/dists/uniform/mgf":"@stdlib/stats-base-dists-uniform-mgf","@stdlib/stats/base/dists/uniform/pdf":"@stdlib/stats-base-dists-uniform-pdf","@stdlib/stats/base/dists/uniform/quantile":"@stdlib/stats-base-dists-uniform-quantile","@stdlib/stats/base/dists/uniform/skewness":"@stdlib/stats-base-dists-uniform-skewness","@stdlib/stats/base/dists/uniform/stdev":"@stdlib/stats-base-dists-uniform-stdev","@stdlib/stats/base/dists/uniform/ctor":"@stdlib/stats-base-dists-uniform-ctor","@stdlib/stats/base/dists/uniform/variance":"@stdlib/stats-base-dists-uniform-variance","@stdlib/stats/base/dists/weibull/cdf":"@stdlib/stats-base-dists-weibull-cdf","@stdlib/stats/base/dists/weibull/entropy":"@stdlib/stats-base-dists-weibull-entropy","@stdlib/stats/base/dists/weibull/kurtosis":"@stdlib/stats-base-dists-weibull-kurtosis","@stdlib/stats/base/dists/weibull/logcdf":"@stdlib/stats-base-dists-weibull-logcdf","@stdlib/stats/base/dists/weibull/logpdf":"@stdlib/stats-base-dists-weibull-logpdf","@stdlib/stats/base/dists/weibull/mean":"@stdlib/stats-base-dists-weibull-mean","@stdlib/stats/base/dists/weibull/median":"@stdlib/stats-base-dists-weibull-median","@stdlib/stats/base/dists/weibull/mgf":"@stdlib/stats-base-dists-weibull-mgf","@stdlib/stats/base/dists/weibull/mode":"@stdlib/stats-base-dists-weibull-mode","@stdlib/stats/base/dists/weibull/pdf":"@stdlib/stats-base-dists-weibull-pdf","@stdlib/stats/base/dists/weibull/quantile":"@stdlib/stats-base-dists-weibull-quantile","@stdlib/stats/base/dists/weibull/skewness":"@stdlib/stats-base-dists-weibull-skewness","@stdlib/stats/base/dists/weibull/stdev":"@stdlib/stats-base-dists-weibull-stdev","@stdlib/stats/base/dists/weibull/variance":"@stdlib/stats-base-dists-weibull-variance","@stdlib/stats/base/dists/weibull/ctor":"@stdlib/stats-base-dists-weibull-ctor","@stdlib/math/base/special/ellipe":"@stdlib/math-base-special-ellipe","@stdlib/math/base/special/ellipj":"@stdlib/math-base-special-ellipj","@stdlib/math/base/special/ellipk":"@stdlib/math-base-special-ellipk","@stdlib/string/base/ends-with":"@stdlib/string-base-ends-with","@stdlib/math/base/utils/float64-epsilon-difference":"@stdlib/math-base-utils-float64-epsilon-difference","@stdlib/math/base/special/erf":"@stdlib/math-base-special-erf","@stdlib/math/base/special/erfc":"@stdlib/math-base-special-erfc","@stdlib/math/base/special/erfcinv":"@stdlib/math-base-special-erfcinv","@stdlib/math/base/special/erfcx":"@stdlib/math-base-special-erfcx","@stdlib/math/base/special/erfinv":"@stdlib/math-base-special-erfinv","@stdlib/math/base/special/dirichlet-eta":"@stdlib/math-base-special-dirichlet-eta","@stdlib/math/base/tools/evalpoly":"@stdlib/math-base-tools-evalpoly","@stdlib/math/base/tools/evalrational":"@stdlib/math-base-tools-evalrational","@stdlib/math/base/special/exp":"@stdlib/math-base-special-exp","@stdlib/math/base/special/exp2":"@stdlib/math-base-special-exp2","@stdlib/math/base/special/exp10":"@stdlib/math-base-special-exp10","@stdlib/math/base/special/expit":"@stdlib/math-base-special-expit","@stdlib/math/base/special/expm1":"@stdlib/math-base-special-expm1","@stdlib/math/base/special/expm1rel":"@stdlib/math-base-special-expm1rel","@stdlib/number/float64/base/exponent":"@stdlib/number-float64-base-exponent","@stdlib/number/float32/base/exponent":"@stdlib/number-float32-base-exponent","@stdlib/math/base/special/factorial":"@stdlib/math-base-special-factorial","@stdlib/math/base/special/factorial2":"@stdlib/math-base-special-factorial2","@stdlib/math/base/special/factorialln":"@stdlib/math-base-special-factorialln","@stdlib/math/base/special/falling-factorial":"@stdlib/math-base-special-falling-factorial","@stdlib/math/base/special/fibonacci":"@stdlib/math-base-special-fibonacci","@stdlib/math/base/special/fibonacci-index":"@stdlib/math-base-special-fibonacci-index","@stdlib/math/base/tools/fibpoly":"@stdlib/math-base-tools-fibpoly","@stdlib/string/base/first-code-point":"@stdlib/string-base-first-code-point","@stdlib/string/base/first":"@stdlib/string-base-first","@stdlib/string/base/first-grapheme-cluster":"@stdlib/string-base-first-grapheme-cluster","@stdlib/math/base/special/flipsign":"@stdlib/math-base-special-flipsign","@stdlib/math/base/special/flipsignf":"@stdlib/math-base-special-flipsignf","@stdlib/number/float32/base/to-int32":"@stdlib/number-float32-base-to-int32","@stdlib/number/float32/base/to-uint32":"@stdlib/number-float32-base-to-uint32","@stdlib/number/float64/base/to-float32":"@stdlib/number-float64-base-to-float32","@stdlib/number/float64/base/to-int32":"@stdlib/number-float64-base-to-int32","@stdlib/number/float64/base/to-int64-bytes":"@stdlib/number-float64-base-to-int64-bytes","@stdlib/number/float64/base/to-uint32":"@stdlib/number-float64-base-to-uint32","@stdlib/math/base/special/floor":"@stdlib/math-base-special-floor","@stdlib/math/base/special/floor2":"@stdlib/math-base-special-floor2","@stdlib/math/base/special/floor10":"@stdlib/math-base-special-floor10","@stdlib/math/base/special/floorb":"@stdlib/math-base-special-floorb","@stdlib/math/base/special/floorf":"@stdlib/math-base-special-floorf","@stdlib/math/base/special/floorn":"@stdlib/math-base-special-floorn","@stdlib/math/base/special/floorsd":"@stdlib/math-base-special-floorsd","@stdlib/string/base/for-each":"@stdlib/string-base-for-each","@stdlib/string/base/for-each-code-point":"@stdlib/string-base-for-each-code-point","@stdlib/string/base/for-each-code-point-right":"@stdlib/string-base-for-each-code-point-right","@stdlib/string/base/for-each-grapheme-cluster":"@stdlib/string-base-for-each-grapheme-cluster","@stdlib/string/base/for-each-right":"@stdlib/string-base-for-each-right","@stdlib/string/base/format-interpolate":"@stdlib/string-base-format-interpolate","@stdlib/string/base/format-tokenize":"@stdlib/string-base-format-tokenize","@stdlib/math/base/special/fresnel":"@stdlib/math-base-special-fresnel","@stdlib/math/base/special/fresnelc":"@stdlib/math-base-special-fresnelc","@stdlib/math/base/special/fresnels":"@stdlib/math-base-special-fresnels","@stdlib/math/base/special/frexp":"@stdlib/math-base-special-frexp","@stdlib/number/float64/base/from-binary-string":"@stdlib/number-float64-base-from-binary-string","@stdlib/number/float32/base/from-binary-string":"@stdlib/number-float32-base-from-binary-string","@stdlib/number/uint8/base/from-binary-string":"@stdlib/number-uint8-base-from-binary-string","@stdlib/number/uint16/base/from-binary-string":"@stdlib/number-uint16-base-from-binary-string","@stdlib/number/uint32/base/from-binary-string":"@stdlib/number-uint32-base-from-binary-string","@stdlib/number/float64/base/from-int64-bytes":"@stdlib/number-float64-base-from-int64-bytes","@stdlib/number/float32/base/from-word":"@stdlib/number-float32-base-from-word","@stdlib/number/float64/base/from-words":"@stdlib/number-float64-base-from-words","@stdlib/math/base/special/gamma":"@stdlib/math-base-special-gamma","@stdlib/math/base/special/gamma1pm1":"@stdlib/math-base-special-gamma1pm1","@stdlib/math/base/special/gamma-delta-ratio":"@stdlib/math-base-special-gamma-delta-ratio","@stdlib/math/base/special/gammainc":"@stdlib/math-base-special-gammainc","@stdlib/math/base/special/gammaincinv":"@stdlib/math-base-special-gammaincinv","@stdlib/math/base/special/gamma-lanczos-sum":"@stdlib/math-base-special-gamma-lanczos-sum","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":"@stdlib/math-base-special-gamma-lanczos-sum-expg-scaled","@stdlib/math/base/special/gammaln":"@stdlib/math-base-special-gammaln","@stdlib/math/base/special/gammasgn":"@stdlib/math-base-special-gammasgn","@stdlib/math/base/special/gcd":"@stdlib/math-base-special-gcd","@stdlib/number/float64/base/get-high-word":"@stdlib/number-float64-base-get-high-word","@stdlib/number/float64/base/get-low-word":"@stdlib/number-float64-base-get-low-word","@stdlib/math/base/special/hacovercos":"@stdlib/math-base-special-hacovercos","@stdlib/math/base/special/hacoversin":"@stdlib/math-base-special-hacoversin","@stdlib/math/base/special/havercos":"@stdlib/math-base-special-havercos","@stdlib/math/base/special/haversin":"@stdlib/math-base-special-haversin","@stdlib/string/base/headercase":"@stdlib/string-base-headercase","@stdlib/math/base/special/heaviside":"@stdlib/math-base-special-heaviside","@stdlib/math/base/tools/hermitepoly":"@stdlib/math-base-tools-hermitepoly","@stdlib/math/base/special/hypot":"@stdlib/math-base-special-hypot","@stdlib/math/base/special/hypotf":"@stdlib/math-base-special-hypotf","@stdlib/math/base/special/identity":"@stdlib/math-base-special-identity","@stdlib/math/base/special/identityf":"@stdlib/math-base-special-identityf","@stdlib/math/base/ops/imul":"@stdlib/math-base-ops-imul","@stdlib/math/base/ops/imuldw":"@stdlib/math-base-ops-imuldw","@stdlib/slice/base/int2slice":"@stdlib/slice-base-int2slice","@stdlib/number/int32/base/to-uint32":"@stdlib/number-int32-base-to-uint32","@stdlib/math/base/special/inv":"@stdlib/math-base-special-inv","@stdlib/string/base/invcase":"@stdlib/string-base-invcase","@stdlib/math/base/special/invf":"@stdlib/math-base-special-invf","@stdlib/math/base/assert/is-composite":"@stdlib/math-base-assert-is-composite","@stdlib/math/base/assert/is-coprime":"@stdlib/math-base-assert-is-coprime","@stdlib/math/base/assert/is-even":"@stdlib/math-base-assert-is-even","@stdlib/math/base/assert/int32-is-even":"@stdlib/math-base-assert-int32-is-even","@stdlib/math/base/assert/is-finite":"@stdlib/math-base-assert-is-finite","@stdlib/math/base/assert/is-finitef":"@stdlib/math-base-assert-is-finitef","@stdlib/math/base/assert/is-infinite":"@stdlib/math-base-assert-is-infinite","@stdlib/math/base/assert/is-infinitef":"@stdlib/math-base-assert-is-infinitef","@stdlib/math/base/assert/is-integer":"@stdlib/math-base-assert-is-integer","@stdlib/math/base/assert/is-nan":"@stdlib/math-base-assert-is-nan","@stdlib/math/base/assert/is-nanf":"@stdlib/math-base-assert-is-nanf","@stdlib/math/base/assert/is-negative-finite":"@stdlib/math-base-assert-is-negative-finite","@stdlib/math/base/assert/is-negative-integer":"@stdlib/math-base-assert-is-negative-integer","@stdlib/math/base/assert/is-negative-zero":"@stdlib/math-base-assert-is-negative-zero","@stdlib/math/base/assert/is-negative-zerof":"@stdlib/math-base-assert-is-negative-zerof","@stdlib/math/base/assert/is-nonnegative-finite":"@stdlib/math-base-assert-is-nonnegative-finite","@stdlib/math/base/assert/is-nonnegative-integer":"@stdlib/math-base-assert-is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-finite":"@stdlib/math-base-assert-is-nonpositive-finite","@stdlib/math/base/assert/is-nonpositive-integer":"@stdlib/math-base-assert-is-nonpositive-integer","@stdlib/math/base/assert/is-odd":"@stdlib/math-base-assert-is-odd","@stdlib/math/base/assert/int32-is-odd":"@stdlib/math-base-assert-int32-is-odd","@stdlib/math/base/assert/is-positive-finite":"@stdlib/math-base-assert-is-positive-finite","@stdlib/math/base/assert/is-positive-integer":"@stdlib/math-base-assert-is-positive-integer","@stdlib/math/base/assert/is-positive-zero":"@stdlib/math-base-assert-is-positive-zero","@stdlib/math/base/assert/is-positive-zerof":"@stdlib/math-base-assert-is-positive-zerof","@stdlib/math/base/assert/uint32-is-pow2":"@stdlib/math-base-assert-uint32-is-pow2","@stdlib/math/base/assert/is-prime":"@stdlib/math-base-assert-is-prime","@stdlib/math/base/assert/is-probability":"@stdlib/math-base-assert-is-probability","@stdlib/math/base/assert/is-safe-integer":"@stdlib/math-base-assert-is-safe-integer","@stdlib/string/base/kebabcase":"@stdlib/string-base-kebabcase","@stdlib/math/base/special/kernel-betainc":"@stdlib/math-base-special-kernel-betainc","@stdlib/math/base/special/kernel-betaincinv":"@stdlib/math-base-special-kernel-betaincinv","@stdlib/math/base/special/kernel-cos":"@stdlib/math-base-special-kernel-cos","@stdlib/math/base/special/kernel-log1p":"@stdlib/math-base-special-kernel-log1p","@stdlib/math/base/special/kernel-sin":"@stdlib/math-base-special-kernel-sin","@stdlib/math/base/special/kernel-tan":"@stdlib/math-base-special-kernel-tan","@stdlib/math/base/special/kronecker-delta":"@stdlib/math-base-special-kronecker-delta","@stdlib/math/base/special/kronecker-deltaf":"@stdlib/math-base-special-kronecker-deltaf","@stdlib/math/base/special/labs":"@stdlib/math-base-special-labs","@stdlib/string/base/last":"@stdlib/string-base-last","@stdlib/string/base/last-code-point":"@stdlib/string-base-last-code-point","@stdlib/string/base/last-grapheme-cluster":"@stdlib/string-base-last-grapheme-cluster","@stdlib/math/base/special/lcm":"@stdlib/math-base-special-lcm","@stdlib/math/base/special/ldexp":"@stdlib/math-base-special-ldexp","@stdlib/string/base/left-pad":"@stdlib/string-base-left-pad","@stdlib/string/base/left-trim":"@stdlib/string-base-left-trim","@stdlib/math/base/special/ln":"@stdlib/math-base-special-ln","@stdlib/math/base/special/log":"@stdlib/math-base-special-log","@stdlib/math/base/special/log1mexp":"@stdlib/math-base-special-log1mexp","@stdlib/math/base/special/log1p":"@stdlib/math-base-special-log1p","@stdlib/math/base/special/log1pexp":"@stdlib/math-base-special-log1pexp","@stdlib/math/base/special/log1pmx":"@stdlib/math-base-special-log1pmx","@stdlib/math/base/special/log2":"@stdlib/math-base-special-log2","@stdlib/math/base/special/log10":"@stdlib/math-base-special-log10","@stdlib/math/base/special/logaddexp":"@stdlib/math-base-special-logaddexp","@stdlib/math/base/special/logit":"@stdlib/math-base-special-logit","@stdlib/string/base/lowercase":"@stdlib/string-base-lowercase","@stdlib/math/base/special/lucas":"@stdlib/math-base-special-lucas","@stdlib/math/base/tools/lucaspoly":"@stdlib/math-base-tools-lucaspoly","@stdlib/math/base/special/max":"@stdlib/math-base-special-max","@stdlib/math/base/special/maxabs":"@stdlib/math-base-special-maxabs","@stdlib/math/base/special/maxabsn":"@stdlib/math-base-special-maxabsn","@stdlib/math/base/special/maxn":"@stdlib/math-base-special-maxn","@stdlib/math/base/special/min":"@stdlib/math-base-special-min","@stdlib/math/base/special/minabs":"@stdlib/math-base-special-minabs","@stdlib/math/base/special/minabsn":"@stdlib/math-base-special-minabsn","@stdlib/math/base/special/minmax":"@stdlib/math-base-special-minmax","@stdlib/math/base/special/minmaxabs":"@stdlib/math-base-special-minmaxabs","@stdlib/math/base/special/minmaxabsn":"@stdlib/math-base-special-minmaxabsn","@stdlib/math/base/special/minmaxn":"@stdlib/math-base-special-minmaxn","@stdlib/math/base/special/minn":"@stdlib/math-base-special-minn","@stdlib/math/base/special/modf":"@stdlib/math-base-special-modf","@stdlib/number/float64/base/mul":"@stdlib/number-float64-base-mul","@stdlib/number/float32/base/mul":"@stdlib/number-float32-base-mul","@stdlib/ndarray/base/ctor":"@stdlib/ndarray-base-ctor","@stdlib/ndarray/base/unary":"@stdlib/ndarray-base-unary","@stdlib/ndarray/base/zeros":"@stdlib/ndarray-base-zeros","@stdlib/ndarray/base/zeros-like":"@stdlib/ndarray-base-zeros-like","@stdlib/math/base/special/negafibonacci":"@stdlib/math-base-special-negafibonacci","@stdlib/math/base/special/negalucas":"@stdlib/math-base-special-negalucas","@stdlib/math/base/special/nonfibonacci":"@stdlib/math-base-special-nonfibonacci","@stdlib/number/float64/base/normalize":"@stdlib/number-float64-base-normalize","@stdlib/number/float32/base/normalize":"@stdlib/number-float32-base-normalize","@stdlib/slice/base/normalize-multi-slice":"@stdlib/slice-base-normalize-multi-slice","@stdlib/slice/base/normalize-slice":"@stdlib/slice-base-normalize-slice","@stdlib/math/base/tools/normhermitepoly":"@stdlib/math-base-tools-normhermitepoly","@stdlib/string/base/pascalcase":"@stdlib/string-base-pascalcase","@stdlib/math/base/special/pdiff":"@stdlib/math-base-special-pdiff","@stdlib/math/base/special/pdifff":"@stdlib/math-base-special-pdifff","@stdlib/string/base/percent-encode":"@stdlib/string-base-percent-encode","@stdlib/math/base/special/polygamma":"@stdlib/math-base-special-polygamma","@stdlib/math/base/special/pow":"@stdlib/math-base-special-pow","@stdlib/math/base/special/powm1":"@stdlib/math-base-special-powm1","@stdlib/math/base/special/rad2deg":"@stdlib/math-base-special-rad2deg","@stdlib/math/base/special/rad2degf":"@stdlib/math-base-special-rad2degf","@stdlib/math/base/special/ramp":"@stdlib/math-base-special-ramp","@stdlib/math/base/special/rampf":"@stdlib/math-base-special-rampf","@stdlib/random/base/arcsine":"@stdlib/random-base-arcsine","@stdlib/random/base/bernoulli":"@stdlib/random-base-bernoulli","@stdlib/random/base/beta":"@stdlib/random-base-beta","@stdlib/random/base/betaprime":"@stdlib/random-base-betaprime","@stdlib/random/base/binomial":"@stdlib/random-base-binomial","@stdlib/random/base/box-muller":"@stdlib/random-base-box-muller","@stdlib/random/base/cauchy":"@stdlib/random-base-cauchy","@stdlib/random/base/chi":"@stdlib/random-base-chi","@stdlib/random/base/chisquare":"@stdlib/random-base-chisquare","@stdlib/random/base/cosine":"@stdlib/random-base-cosine","@stdlib/random/base/discrete-uniform":"@stdlib/random-base-discrete-uniform","@stdlib/random/base/erlang":"@stdlib/random-base-erlang","@stdlib/random/base/exponential":"@stdlib/random-base-exponential","@stdlib/random/base/f":"@stdlib/random-base-f","@stdlib/random/base/frechet":"@stdlib/random-base-frechet","@stdlib/random/base/gamma":"@stdlib/random-base-gamma","@stdlib/random/base/geometric":"@stdlib/random-base-geometric","@stdlib/random/base/gumbel":"@stdlib/random-base-gumbel","@stdlib/random/base/hypergeometric":"@stdlib/random-base-hypergeometric","@stdlib/random/base/improved-ziggurat":"@stdlib/random-base-improved-ziggurat","@stdlib/random/base/invgamma":"@stdlib/random-base-invgamma","@stdlib/random/base/kumaraswamy":"@stdlib/random-base-kumaraswamy","@stdlib/random/base/laplace":"@stdlib/random-base-laplace","@stdlib/random/base/levy":"@stdlib/random-base-levy","@stdlib/random/base/logistic":"@stdlib/random-base-logistic","@stdlib/random/base/lognormal":"@stdlib/random-base-lognormal","@stdlib/random/base/minstd":"@stdlib/random-base-minstd","@stdlib/random/base/minstd-shuffle":"@stdlib/random-base-minstd-shuffle","@stdlib/random/base/mt19937":"@stdlib/random-base-mt19937","@stdlib/random/base/negative-binomial":"@stdlib/random-base-negative-binomial","@stdlib/random/base/normal":"@stdlib/random-base-normal","@stdlib/random/base/pareto-type1":"@stdlib/random-base-pareto-type1","@stdlib/random/base/poisson":"@stdlib/random-base-poisson","@stdlib/random/base/randi":"@stdlib/random-base-randi","@stdlib/random/base/randn":"@stdlib/random-base-randn","@stdlib/random/base/randu":"@stdlib/random-base-randu","@stdlib/random/base/rayleigh":"@stdlib/random-base-rayleigh","@stdlib/random/base/t":"@stdlib/random-base-t","@stdlib/random/base/triangular":"@stdlib/random-base-triangular","@stdlib/random/base/uniform":"@stdlib/random-base-uniform","@stdlib/random/base/weibull":"@stdlib/random-base-weibull","@stdlib/math/base/special/rcbrt":"@stdlib/math-base-special-rcbrt","@stdlib/math/base/special/rcbrtf":"@stdlib/math-base-special-rcbrtf","@stdlib/math/base/utils/relative-difference":"@stdlib/math-base-utils-relative-difference","@stdlib/string/base/remove-first":"@stdlib/string-base-remove-first","@stdlib/string/base/remove-first-code-point":"@stdlib/string-base-remove-first-code-point","@stdlib/string/base/remove-first-grapheme-cluster":"@stdlib/string-base-remove-first-grapheme-cluster","@stdlib/string/base/remove-last":"@stdlib/string-base-remove-last","@stdlib/string/base/remove-last-code-point":"@stdlib/string-base-remove-last-code-point","@stdlib/string/base/remove-last-grapheme-cluster":"@stdlib/string-base-remove-last-grapheme-cluster","@stdlib/math/base/special/rempio2":"@stdlib/math-base-special-rempio2","@stdlib/string/base/repeat":"@stdlib/string-base-repeat","@stdlib/string/base/replace":"@stdlib/string-base-replace","@stdlib/string/base/replace-after":"@stdlib/string-base-replace-after","@stdlib/string/base/replace-after-last":"@stdlib/string-base-replace-after-last","@stdlib/string/base/replace-before":"@stdlib/string-base-replace-before","@stdlib/string/base/replace-before-last":"@stdlib/string-base-replace-before-last","@stdlib/string/base/reverse":"@stdlib/string-base-reverse","@stdlib/string/base/reverse-code-points":"@stdlib/string-base-reverse-code-points","@stdlib/string/base/reverse-grapheme-clusters":"@stdlib/string-base-reverse-grapheme-clusters","@stdlib/string/base/right-pad":"@stdlib/string-base-right-pad","@stdlib/string/base/right-trim":"@stdlib/string-base-right-trim","@stdlib/math/base/special/rising-factorial":"@stdlib/math-base-special-rising-factorial","@stdlib/number/uint32/base/rotl":"@stdlib/number-uint32-base-rotl","@stdlib/number/uint32/base/rotr":"@stdlib/number-uint32-base-rotr","@stdlib/math/base/special/round":"@stdlib/math-base-special-round","@stdlib/math/base/special/round2":"@stdlib/math-base-special-round2","@stdlib/math/base/special/round10":"@stdlib/math-base-special-round10","@stdlib/math/base/special/roundb":"@stdlib/math-base-special-roundb","@stdlib/math/base/special/roundn":"@stdlib/math-base-special-roundn","@stdlib/math/base/special/roundsd":"@stdlib/math-base-special-roundsd","@stdlib/math/base/special/rsqrt":"@stdlib/math-base-special-rsqrt","@stdlib/math/base/special/rsqrtf":"@stdlib/math-base-special-rsqrtf","@stdlib/slice/base/sargs2multislice":"@stdlib/slice-base-sargs2multislice","@stdlib/ndarray/base/from-scalar":"@stdlib/ndarray-base-from-scalar","@stdlib/math/base/special/secd":"@stdlib/math-base-special-secd","@stdlib/slice/base/seq2multislice":"@stdlib/slice-base-seq2multislice","@stdlib/slice/base/seq2slice":"@stdlib/slice-base-seq2slice","@stdlib/number/float64/base/set-high-word":"@stdlib/number-float64-base-set-high-word","@stdlib/number/float64/base/set-low-word":"@stdlib/number-float64-base-set-low-word","@stdlib/math/base/special/sici":"@stdlib/math-base-special-sici","@stdlib/number/float64/base/signbit":"@stdlib/number-float64-base-signbit","@stdlib/number/float32/base/signbit":"@stdlib/number-float32-base-signbit","@stdlib/number/float32/base/significand":"@stdlib/number-float32-base-significand","@stdlib/math/base/special/signum":"@stdlib/math-base-special-signum","@stdlib/math/base/special/signumf":"@stdlib/math-base-special-signumf","@stdlib/math/base/special/sin":"@stdlib/math-base-special-sin","@stdlib/math/base/special/sinc":"@stdlib/math-base-special-sinc","@stdlib/math/base/special/sincos":"@stdlib/math-base-special-sincos","@stdlib/math/base/special/sincospi":"@stdlib/math-base-special-sincospi","@stdlib/math/base/special/sinh":"@stdlib/math-base-special-sinh","@stdlib/math/base/special/sinpi":"@stdlib/math-base-special-sinpi","@stdlib/slice/base/slice2seq":"@stdlib/slice-base-slice2seq","@stdlib/slice/base/length":"@stdlib/slice-base-length","@stdlib/slice/base/nonreduced-dimensions":"@stdlib/slice-base-nonreduced-dimensions","@stdlib/slice/base/reduced-dimensions":"@stdlib/slice-base-reduced-dimensions","@stdlib/slice/base/shape":"@stdlib/slice-base-shape","@stdlib/string/base/snakecase":"@stdlib/string-base-snakecase","@stdlib/math/base/special/spence":"@stdlib/math-base-special-spence","@stdlib/math/base/special/sqrt":"@stdlib/math-base-special-sqrt","@stdlib/math/base/special/sqrt1pm1":"@stdlib/math-base-special-sqrt1pm1","@stdlib/math/base/special/sqrtf":"@stdlib/math-base-special-sqrtf","@stdlib/math/base/special/sqrtpi":"@stdlib/math-base-special-sqrtpi","@stdlib/string/base/startcase":"@stdlib/string-base-startcase","@stdlib/string/base/starts-with":"@stdlib/string-base-starts-with","@stdlib/string/base/stickycase":"@stdlib/string-base-stickycase","@stdlib/strided/base/binary":"@stdlib/strided-base-binary","@stdlib/strided/base/binary-dtype-signatures":"@stdlib/strided-base-binary-dtype-signatures","@stdlib/strided/base/binary-signature-callbacks":"@stdlib/strided-base-binary-signature-callbacks","@stdlib/blas/base/ccopy":"@stdlib/blas-base-ccopy","@stdlib/strided/base/cmap":"@stdlib/strided-base-cmap","@stdlib/blas/base/cswap":"@stdlib/blas-base-cswap","@stdlib/stats/base/cumax":"@stdlib/stats-base-cumax","@stdlib/stats/base/cumaxabs":"@stdlib/stats-base-cumaxabs","@stdlib/stats/base/cumin":"@stdlib/stats-base-cumin","@stdlib/stats/base/cuminabs":"@stdlib/stats-base-cuminabs","@stdlib/math/strided/special/dabs":"@stdlib/math-strided-special-dabs","@stdlib/math/strided/special/dabs2":"@stdlib/math-strided-special-dabs2","@stdlib/blas/ext/base/dapx":"@stdlib/blas-ext-base-dapx","@stdlib/blas/ext/base/dapxsum":"@stdlib/blas-ext-base-dapxsum","@stdlib/blas/ext/base/dapxsumkbn":"@stdlib/blas-ext-base-dapxsumkbn","@stdlib/blas/ext/base/dapxsumkbn2":"@stdlib/blas-ext-base-dapxsumkbn2","@stdlib/blas/ext/base/dapxsumors":"@stdlib/blas-ext-base-dapxsumors","@stdlib/blas/ext/base/dapxsumpw":"@stdlib/blas-ext-base-dapxsumpw","@stdlib/blas/base/dasum":"@stdlib/blas-base-dasum","@stdlib/blas/ext/base/dasumpw":"@stdlib/blas-ext-base-dasumpw","@stdlib/blas/base/daxpy":"@stdlib/blas-base-daxpy","@stdlib/math/strided/special/dcbrt":"@stdlib/math-strided-special-dcbrt","@stdlib/math/strided/special/dceil":"@stdlib/math-strided-special-dceil","@stdlib/blas/base/dcopy":"@stdlib/blas-base-dcopy","@stdlib/stats/strided/dcumax":"@stdlib/stats-strided-dcumax","@stdlib/stats/strided/dcumaxabs":"@stdlib/stats-strided-dcumaxabs","@stdlib/stats/base/dcumin":"@stdlib/stats-base-dcumin","@stdlib/stats/strided/dcuminabs":"@stdlib/stats-strided-dcuminabs","@stdlib/blas/ext/base/dcusum":"@stdlib/blas-ext-base-dcusum","@stdlib/blas/ext/base/dcusumkbn":"@stdlib/blas-ext-base-dcusumkbn","@stdlib/blas/ext/base/dcusumkbn2":"@stdlib/blas-ext-base-dcusumkbn2","@stdlib/blas/ext/base/dcusumors":"@stdlib/blas-ext-base-dcusumors","@stdlib/blas/ext/base/dcusumpw":"@stdlib/blas-ext-base-dcusumpw","@stdlib/math/strided/special/ddeg2rad":"@stdlib/math-strided-special-ddeg2rad","@stdlib/blas/base/ddot":"@stdlib/blas-base-ddot","@stdlib/blas/ext/base/dfill":"@stdlib/blas-ext-base-dfill","@stdlib/math/strided/special/dfloor":"@stdlib/math-strided-special-dfloor","@stdlib/math/strided/special/dinv":"@stdlib/math-strided-special-dinv","@stdlib/strided/base/dmap":"@stdlib/strided-base-dmap","@stdlib/strided/base/dmap2":"@stdlib/strided-base-dmap2","@stdlib/stats/strided/dmax":"@stdlib/stats-strided-dmax","@stdlib/stats/strided/dmaxabs":"@stdlib/stats-strided-dmaxabs","@stdlib/stats/strided/dmaxabssorted":"@stdlib/stats-strided-dmaxabssorted","@stdlib/stats/strided/dmaxsorted":"@stdlib/stats-strided-dmaxsorted","@stdlib/stats/base/dmean":"@stdlib/stats-base-dmean","@stdlib/stats/strided/dmeankbn":"@stdlib/stats-strided-dmeankbn","@stdlib/stats/strided/dmeankbn2":"@stdlib/stats-strided-dmeankbn2","@stdlib/stats/strided/dmeanli":"@stdlib/stats-strided-dmeanli","@stdlib/stats/strided/dmeanlipw":"@stdlib/stats-strided-dmeanlipw","@stdlib/stats/strided/dmeanors":"@stdlib/stats-strided-dmeanors","@stdlib/stats/base/dmeanpn":"@stdlib/stats-base-dmeanpn","@stdlib/stats/strided/dmeanpw":"@stdlib/stats-strided-dmeanpw","@stdlib/stats/base/dmeanstdev":"@stdlib/stats-base-dmeanstdev","@stdlib/stats/base/dmeanstdevpn":"@stdlib/stats-base-dmeanstdevpn","@stdlib/stats/base/dmeanvar":"@stdlib/stats-base-dmeanvar","@stdlib/stats/base/dmeanvarpn":"@stdlib/stats-base-dmeanvarpn","@stdlib/stats/strided/dmeanwd":"@stdlib/stats-strided-dmeanwd","@stdlib/stats/strided/dmediansorted":"@stdlib/stats-strided-dmediansorted","@stdlib/stats/strided/dmidrange":"@stdlib/stats-strided-dmidrange","@stdlib/stats/strided/dmin":"@stdlib/stats-strided-dmin","@stdlib/stats/strided/dminabs":"@stdlib/stats-strided-dminabs","@stdlib/stats/strided/dminsorted":"@stdlib/stats-strided-dminsorted","@stdlib/math/strided/special/dmskabs":"@stdlib/math-strided-special-dmskabs","@stdlib/math/strided/special/dmskabs2":"@stdlib/math-strided-special-dmskabs2","@stdlib/math/strided/special/dmskcbrt":"@stdlib/math-strided-special-dmskcbrt","@stdlib/math/strided/special/dmskceil":"@stdlib/math-strided-special-dmskceil","@stdlib/math/strided/special/dmskdeg2rad":"@stdlib/math-strided-special-dmskdeg2rad","@stdlib/math/strided/special/dmskfloor":"@stdlib/math-strided-special-dmskfloor","@stdlib/math/strided/special/dmskinv":"@stdlib/math-strided-special-dmskinv","@stdlib/strided/base/dmskmap":"@stdlib/strided-base-dmskmap","@stdlib/strided/base/dmskmap2":"@stdlib/strided-base-dmskmap2","@stdlib/stats/base/dmskmax":"@stdlib/stats-base-dmskmax","@stdlib/stats/base/dmskmin":"@stdlib/stats-base-dmskmin","@stdlib/math/strided/special/dmskramp":"@stdlib/math-strided-special-dmskramp","@stdlib/stats/base/dmskrange":"@stdlib/stats-base-dmskrange","@stdlib/math/strided/special/dmskrsqrt":"@stdlib/math-strided-special-dmskrsqrt","@stdlib/math/strided/special/dmsksqrt":"@stdlib/math-strided-special-dmsksqrt","@stdlib/math/strided/special/dmsktrunc":"@stdlib/math-strided-special-dmsktrunc","@stdlib/blas/ext/base/dnanasum":"@stdlib/blas-ext-base-dnanasum","@stdlib/blas/ext/base/dnanasumors":"@stdlib/blas-ext-base-dnanasumors","@stdlib/stats/strided/dnanmax":"@stdlib/stats-strided-dnanmax","@stdlib/stats/strided/dnanmaxabs":"@stdlib/stats-strided-dnanmaxabs","@stdlib/stats/strided/dnanmean":"@stdlib/stats-strided-dnanmean","@stdlib/stats/base/dnanmeanors":"@stdlib/stats-base-dnanmeanors","@stdlib/stats/base/dnanmeanpn":"@stdlib/stats-base-dnanmeanpn","@stdlib/stats/base/dnanmeanpw":"@stdlib/stats-base-dnanmeanpw","@stdlib/stats/base/dnanmeanwd":"@stdlib/stats-base-dnanmeanwd","@stdlib/stats/base/dnanmin":"@stdlib/stats-base-dnanmin","@stdlib/stats/base/dnanminabs":"@stdlib/stats-base-dnanminabs","@stdlib/stats/base/dnanmskmax":"@stdlib/stats-base-dnanmskmax","@stdlib/stats/base/dnanmskmin":"@stdlib/stats-base-dnanmskmin","@stdlib/stats/base/dnanmskrange":"@stdlib/stats-base-dnanmskrange","@stdlib/blas/ext/base/dnannsum":"@stdlib/blas-ext-base-dnannsum","@stdlib/blas/ext/base/dnannsumkbn":"@stdlib/blas-ext-base-dnannsumkbn","@stdlib/blas/ext/base/dnannsumkbn2":"@stdlib/blas-ext-base-dnannsumkbn2","@stdlib/blas/ext/base/dnannsumors":"@stdlib/blas-ext-base-dnannsumors","@stdlib/blas/ext/base/dnannsumpw":"@stdlib/blas-ext-base-dnannsumpw","@stdlib/stats/base/dnanrange":"@stdlib/stats-base-dnanrange","@stdlib/stats/base/dnanstdev":"@stdlib/stats-base-dnanstdev","@stdlib/stats/base/dnanstdevch":"@stdlib/stats-base-dnanstdevch","@stdlib/stats/base/dnanstdevpn":"@stdlib/stats-base-dnanstdevpn","@stdlib/stats/base/dnanstdevtk":"@stdlib/stats-base-dnanstdevtk","@stdlib/stats/base/dnanstdevwd":"@stdlib/stats-base-dnanstdevwd","@stdlib/stats/base/dnanstdevyc":"@stdlib/stats-base-dnanstdevyc","@stdlib/blas/ext/base/dnansum":"@stdlib/blas-ext-base-dnansum","@stdlib/blas/ext/base/dnansumkbn":"@stdlib/blas-ext-base-dnansumkbn","@stdlib/blas/ext/base/dnansumkbn2":"@stdlib/blas-ext-base-dnansumkbn2","@stdlib/blas/ext/base/dnansumors":"@stdlib/blas-ext-base-dnansumors","@stdlib/blas/ext/base/dnansumpw":"@stdlib/blas-ext-base-dnansumpw","@stdlib/stats/base/dnanvariance":"@stdlib/stats-base-dnanvariance","@stdlib/stats/base/dnanvariancech":"@stdlib/stats-base-dnanvariancech","@stdlib/stats/base/dnanvariancepn":"@stdlib/stats-base-dnanvariancepn","@stdlib/stats/base/dnanvariancetk":"@stdlib/stats-base-dnanvariancetk","@stdlib/stats/base/dnanvariancewd":"@stdlib/stats-base-dnanvariancewd","@stdlib/stats/base/dnanvarianceyc":"@stdlib/stats-base-dnanvarianceyc","@stdlib/blas/base/dnrm2":"@stdlib/blas-base-dnrm2","@stdlib/math/strided/special/dramp":"@stdlib/math-strided-special-dramp","@stdlib/stats/base/drange":"@stdlib/stats-base-drange","@stdlib/blas/ext/base/drev":"@stdlib/blas-ext-base-drev","@stdlib/math/strided/special/drsqrt":"@stdlib/math-strided-special-drsqrt","@stdlib/blas/ext/base/dsapxsum":"@stdlib/blas-ext-base-dsapxsum","@stdlib/blas/ext/base/dsapxsumpw":"@stdlib/blas-ext-base-dsapxsumpw","@stdlib/blas/base/dscal":"@stdlib/blas-base-dscal","@stdlib/blas/base/dsdot":"@stdlib/blas-base-dsdot","@stdlib/stats/base/dsem":"@stdlib/stats-base-dsem","@stdlib/stats/base/dsemch":"@stdlib/stats-base-dsemch","@stdlib/stats/base/dsempn":"@stdlib/stats-base-dsempn","@stdlib/stats/base/dsemtk":"@stdlib/stats-base-dsemtk","@stdlib/stats/base/dsemwd":"@stdlib/stats-base-dsemwd","@stdlib/stats/base/dsemyc":"@stdlib/stats-base-dsemyc","@stdlib/stats/base/dsmean":"@stdlib/stats-base-dsmean","@stdlib/stats/base/dsmeanors":"@stdlib/stats-base-dsmeanors","@stdlib/stats/base/dsmeanpn":"@stdlib/stats-base-dsmeanpn","@stdlib/stats/base/dsmeanpw":"@stdlib/stats-base-dsmeanpw","@stdlib/stats/base/dsmeanwd":"@stdlib/stats-base-dsmeanwd","@stdlib/stats/base/dsnanmean":"@stdlib/stats-base-dsnanmean","@stdlib/stats/base/dsnanmeanors":"@stdlib/stats-base-dsnanmeanors","@stdlib/stats/base/dsnanmeanpn":"@stdlib/stats-base-dsnanmeanpn","@stdlib/stats/base/dsnanmeanwd":"@stdlib/stats-base-dsnanmeanwd","@stdlib/blas/ext/base/dsnannsumors":"@stdlib/blas-ext-base-dsnannsumors","@stdlib/blas/ext/base/dsnansum":"@stdlib/blas-ext-base-dsnansum","@stdlib/blas/ext/base/dsnansumors":"@stdlib/blas-ext-base-dsnansumors","@stdlib/blas/ext/base/dsnansumpw":"@stdlib/blas-ext-base-dsnansumpw","@stdlib/blas/ext/base/dsort2hp":"@stdlib/blas-ext-base-dsort2hp","@stdlib/blas/ext/base/dsort2ins":"@stdlib/blas-ext-base-dsort2ins","@stdlib/blas/ext/base/dsort2sh":"@stdlib/blas-ext-base-dsort2sh","@stdlib/blas/ext/base/dsorthp":"@stdlib/blas-ext-base-dsorthp","@stdlib/blas/ext/base/dsortins":"@stdlib/blas-ext-base-dsortins","@stdlib/blas/ext/base/dsortsh":"@stdlib/blas-ext-base-dsortsh","@stdlib/math/strided/special/dsqrt":"@stdlib/math-strided-special-dsqrt","@stdlib/blas/ext/base/dssum":"@stdlib/blas-ext-base-dssum","@stdlib/blas/ext/base/dssumors":"@stdlib/blas-ext-base-dssumors","@stdlib/blas/ext/base/dssumpw":"@stdlib/blas-ext-base-dssumpw","@stdlib/stats/base/dstdev":"@stdlib/stats-base-dstdev","@stdlib/stats/base/dstdevch":"@stdlib/stats-base-dstdevch","@stdlib/stats/base/dstdevpn":"@stdlib/stats-base-dstdevpn","@stdlib/stats/base/dstdevtk":"@stdlib/stats-base-dstdevtk","@stdlib/stats/base/dstdevwd":"@stdlib/stats-base-dstdevwd","@stdlib/stats/base/dstdevyc":"@stdlib/stats-base-dstdevyc","@stdlib/blas/ext/base/dsum":"@stdlib/blas-ext-base-dsum","@stdlib/blas/ext/base/dsumkbn":"@stdlib/blas-ext-base-dsumkbn","@stdlib/blas/ext/base/dsumkbn2":"@stdlib/blas-ext-base-dsumkbn2","@stdlib/blas/ext/base/dsumors":"@stdlib/blas-ext-base-dsumors","@stdlib/blas/ext/base/dsumpw":"@stdlib/blas-ext-base-dsumpw","@stdlib/stats/base/dsvariance":"@stdlib/stats-base-dsvariance","@stdlib/stats/base/dsvariancepn":"@stdlib/stats-base-dsvariancepn","@stdlib/blas/base/dswap":"@stdlib/blas-base-dswap","@stdlib/math/strided/special/dtrunc":"@stdlib/math-strided-special-dtrunc","@stdlib/strided/base/dtype-enum2str":"@stdlib/strided-base-dtype-enum2str","@stdlib/strided/base/dtype-resolve-enum":"@stdlib/strided-base-dtype-resolve-enum","@stdlib/strided/base/dtype-resolve-str":"@stdlib/strided-base-dtype-resolve-str","@stdlib/strided/base/dtype-str2enum":"@stdlib/strided-base-dtype-str2enum","@stdlib/stats/base/dvariance":"@stdlib/stats-base-dvariance","@stdlib/stats/base/dvariancech":"@stdlib/stats-base-dvariancech","@stdlib/stats/base/dvariancepn":"@stdlib/stats-base-dvariancepn","@stdlib/stats/base/dvariancetk":"@stdlib/stats-base-dvariancetk","@stdlib/stats/base/dvariancewd":"@stdlib/stats-base-dvariancewd","@stdlib/stats/base/dvarianceyc":"@stdlib/stats-base-dvarianceyc","@stdlib/stats/base/dvarm":"@stdlib/stats-base-dvarm","@stdlib/stats/base/dvarmpn":"@stdlib/stats-base-dvarmpn","@stdlib/stats/base/dvarmtk":"@stdlib/stats-base-dvarmtk","@stdlib/strided/base/function-object":"@stdlib/strided-base-function-object","@stdlib/blas/ext/base/gapx":"@stdlib/blas-ext-base-gapx","@stdlib/blas/ext/base/gapxsum":"@stdlib/blas-ext-base-gapxsum","@stdlib/blas/ext/base/gapxsumkbn":"@stdlib/blas-ext-base-gapxsumkbn","@stdlib/blas/ext/base/gapxsumkbn2":"@stdlib/blas-ext-base-gapxsumkbn2","@stdlib/blas/ext/base/gapxsumors":"@stdlib/blas-ext-base-gapxsumors","@stdlib/blas/ext/base/gapxsumpw":"@stdlib/blas-ext-base-gapxsumpw","@stdlib/blas/base/gasum":"@stdlib/blas-base-gasum","@stdlib/blas/ext/base/gasumpw":"@stdlib/blas-ext-base-gasumpw","@stdlib/blas/base/gaxpy":"@stdlib/blas-base-gaxpy","@stdlib/blas/base/gcopy":"@stdlib/blas-base-gcopy","@stdlib/blas/ext/base/gcusum":"@stdlib/blas-ext-base-gcusum","@stdlib/blas/ext/base/gcusumkbn":"@stdlib/blas-ext-base-gcusumkbn","@stdlib/blas/ext/base/gcusumkbn2":"@stdlib/blas-ext-base-gcusumkbn2","@stdlib/blas/ext/base/gcusumors":"@stdlib/blas-ext-base-gcusumors","@stdlib/blas/ext/base/gcusumpw":"@stdlib/blas-ext-base-gcusumpw","@stdlib/blas/base/gdot":"@stdlib/blas-base-gdot","@stdlib/blas/ext/base/gfill":"@stdlib/blas-ext-base-gfill","@stdlib/blas/ext/base/gfill-by":"@stdlib/blas-ext-base-gfill-by","@stdlib/blas/ext/base/gnannsumkbn":"@stdlib/blas-ext-base-gnannsumkbn","@stdlib/blas/ext/base/gnansum":"@stdlib/blas-ext-base-gnansum","@stdlib/blas/ext/base/gnansumkbn":"@stdlib/blas-ext-base-gnansumkbn","@stdlib/blas/ext/base/gnansumkbn2":"@stdlib/blas-ext-base-gnansumkbn2","@stdlib/blas/ext/base/gnansumors":"@stdlib/blas-ext-base-gnansumors","@stdlib/blas/ext/base/gnansumpw":"@stdlib/blas-ext-base-gnansumpw","@stdlib/blas/base/gnrm2":"@stdlib/blas-base-gnrm2","@stdlib/blas/ext/base/grev":"@stdlib/blas-ext-base-grev","@stdlib/blas/base/gscal":"@stdlib/blas-base-gscal","@stdlib/blas/ext/base/gsort2hp":"@stdlib/blas-ext-base-gsort2hp","@stdlib/blas/ext/base/gsort2ins":"@stdlib/blas-ext-base-gsort2ins","@stdlib/blas/ext/base/gsort2sh":"@stdlib/blas-ext-base-gsort2sh","@stdlib/blas/ext/base/gsorthp":"@stdlib/blas-ext-base-gsorthp","@stdlib/blas/ext/base/gsortins":"@stdlib/blas-ext-base-gsortins","@stdlib/blas/ext/base/gsortsh":"@stdlib/blas-ext-base-gsortsh","@stdlib/blas/ext/base/gsum":"@stdlib/blas-ext-base-gsum","@stdlib/blas/ext/base/gsumkbn":"@stdlib/blas-ext-base-gsumkbn","@stdlib/blas/ext/base/gsumkbn2":"@stdlib/blas-ext-base-gsumkbn2","@stdlib/blas/ext/base/gsumors":"@stdlib/blas-ext-base-gsumors","@stdlib/blas/ext/base/gsumpw":"@stdlib/blas-ext-base-gsumpw","@stdlib/blas/base/gswap":"@stdlib/blas-base-gswap","@stdlib/strided/base/map-by":"@stdlib/strided-base-map-by","@stdlib/strided/base/map-by2":"@stdlib/strided-base-map-by2","@stdlib/stats/base/max":"@stdlib/stats-base-max","@stdlib/stats/base/maxabs":"@stdlib/stats-base-maxabs","@stdlib/stats/base/max-by":"@stdlib/stats-base-max-by","@stdlib/stats/base/maxsorted":"@stdlib/stats-base-maxsorted","@stdlib/strided/base/max-view-buffer-index":"@stdlib/strided-base-max-view-buffer-index","@stdlib/stats/base/mean":"@stdlib/stats-base-mean","@stdlib/stats/base/meankbn":"@stdlib/stats-base-meankbn","@stdlib/stats/base/meankbn2":"@stdlib/stats-base-meankbn2","@stdlib/stats/base/meanors":"@stdlib/stats-base-meanors","@stdlib/stats/base/meanpn":"@stdlib/stats-base-meanpn","@stdlib/stats/base/meanpw":"@stdlib/stats-base-meanpw","@stdlib/stats/base/meanwd":"@stdlib/stats-base-meanwd","@stdlib/stats/base/mediansorted":"@stdlib/stats-base-mediansorted","@stdlib/strided/base/meta-data-props":"@stdlib/strided-base-meta-data-props","@stdlib/stats/base/min":"@stdlib/stats-base-min","@stdlib/stats/base/minabs":"@stdlib/stats-base-minabs","@stdlib/stats/base/min-by":"@stdlib/stats-base-min-by","@stdlib/stats/base/minsorted":"@stdlib/stats-base-minsorted","@stdlib/strided/base/min-view-buffer-index":"@stdlib/strided-base-min-view-buffer-index","@stdlib/stats/base/mskmax":"@stdlib/stats-base-mskmax","@stdlib/stats/base/mskmin":"@stdlib/stats-base-mskmin","@stdlib/stats/base/mskrange":"@stdlib/stats-base-mskrange","@stdlib/strided/base/mskunary":"@stdlib/strided-base-mskunary","@stdlib/strided/base/mskunary-dtype-signatures":"@stdlib/strided-base-mskunary-dtype-signatures","@stdlib/strided/base/mskunary-signature-callbacks":"@stdlib/strided-base-mskunary-signature-callbacks","@stdlib/stats/base/nanmax":"@stdlib/stats-base-nanmax","@stdlib/stats/base/nanmaxabs":"@stdlib/stats-base-nanmaxabs","@stdlib/stats/base/nanmax-by":"@stdlib/stats-base-nanmax-by","@stdlib/stats/base/nanmean":"@stdlib/stats-base-nanmean","@stdlib/stats/base/nanmeanors":"@stdlib/stats-base-nanmeanors","@stdlib/stats/base/nanmeanpn":"@stdlib/stats-base-nanmeanpn","@stdlib/stats/base/nanmeanwd":"@stdlib/stats-base-nanmeanwd","@stdlib/stats/base/nanmin":"@stdlib/stats-base-nanmin","@stdlib/stats/base/nanminabs":"@stdlib/stats-base-nanminabs","@stdlib/stats/base/nanmin-by":"@stdlib/stats-base-nanmin-by","@stdlib/stats/base/nanmskmax":"@stdlib/stats-base-nanmskmax","@stdlib/stats/base/nanmskmin":"@stdlib/stats-base-nanmskmin","@stdlib/stats/base/nanmskrange":"@stdlib/stats-base-nanmskrange","@stdlib/stats/base/nanrange":"@stdlib/stats-base-nanrange","@stdlib/stats/base/nanrange-by":"@stdlib/stats-base-nanrange-by","@stdlib/stats/base/nanstdev":"@stdlib/stats-base-nanstdev","@stdlib/stats/base/nanstdevch":"@stdlib/stats-base-nanstdevch","@stdlib/stats/base/nanstdevpn":"@stdlib/stats-base-nanstdevpn","@stdlib/stats/base/nanstdevtk":"@stdlib/stats-base-nanstdevtk","@stdlib/stats/base/nanstdevwd":"@stdlib/stats-base-nanstdevwd","@stdlib/stats/base/nanstdevyc":"@stdlib/stats-base-nanstdevyc","@stdlib/stats/base/nanvariance":"@stdlib/stats-base-nanvariance","@stdlib/stats/base/nanvariancech":"@stdlib/stats-base-nanvariancech","@stdlib/stats/base/nanvariancepn":"@stdlib/stats-base-nanvariancepn","@stdlib/stats/base/nanvariancetk":"@stdlib/stats-base-nanvariancetk","@stdlib/stats/base/nanvariancewd":"@stdlib/stats-base-nanvariancewd","@stdlib/stats/base/nanvarianceyc":"@stdlib/stats-base-nanvarianceyc","@stdlib/strided/base/nullary":"@stdlib/strided-base-nullary","@stdlib/strided/base/offset-view":"@stdlib/strided-base-offset-view","@stdlib/strided/base/quaternary":"@stdlib/strided-base-quaternary","@stdlib/strided/base/quinary":"@stdlib/strided-base-quinary","@stdlib/stats/base/range":"@stdlib/stats-base-range","@stdlib/stats/base/range-by":"@stdlib/stats-base-range-by","@stdlib/strided/base/reinterpret-complex":"@stdlib/strided-base-reinterpret-complex","@stdlib/strided/base/reinterpret-complex64":"@stdlib/strided-base-reinterpret-complex64","@stdlib/strided/base/reinterpret-complex128":"@stdlib/strided-base-reinterpret-complex128","@stdlib/math/strided/special/sabs":"@stdlib/math-strided-special-sabs","@stdlib/math/strided/special/sabs2":"@stdlib/math-strided-special-sabs2","@stdlib/blas/ext/base/sapx":"@stdlib/blas-ext-base-sapx","@stdlib/blas/ext/base/sapxsum":"@stdlib/blas-ext-base-sapxsum","@stdlib/blas/ext/base/sapxsumkbn":"@stdlib/blas-ext-base-sapxsumkbn","@stdlib/blas/ext/base/sapxsumkbn2":"@stdlib/blas-ext-base-sapxsumkbn2","@stdlib/blas/ext/base/sapxsumors":"@stdlib/blas-ext-base-sapxsumors","@stdlib/blas/ext/base/sapxsumpw":"@stdlib/blas-ext-base-sapxsumpw","@stdlib/blas/base/sasum":"@stdlib/blas-base-sasum","@stdlib/blas/ext/base/sasumpw":"@stdlib/blas-ext-base-sasumpw","@stdlib/blas/base/saxpy":"@stdlib/blas-base-saxpy","@stdlib/math/strided/special/scbrt":"@stdlib/math-strided-special-scbrt","@stdlib/math/strided/special/sceil":"@stdlib/math-strided-special-sceil","@stdlib/blas/base/scopy":"@stdlib/blas-base-scopy","@stdlib/stats/base/scumax":"@stdlib/stats-base-scumax","@stdlib/stats/base/scumaxabs":"@stdlib/stats-base-scumaxabs","@stdlib/stats/base/scumin":"@stdlib/stats-base-scumin","@stdlib/stats/base/scuminabs":"@stdlib/stats-base-scuminabs","@stdlib/blas/ext/base/scusum":"@stdlib/blas-ext-base-scusum","@stdlib/blas/ext/base/scusumkbn":"@stdlib/blas-ext-base-scusumkbn","@stdlib/blas/ext/base/scusumkbn2":"@stdlib/blas-ext-base-scusumkbn2","@stdlib/blas/ext/base/scusumors":"@stdlib/blas-ext-base-scusumors","@stdlib/blas/ext/base/scusumpw":"@stdlib/blas-ext-base-scusumpw","@stdlib/math/strided/special/sdeg2rad":"@stdlib/math-strided-special-sdeg2rad","@stdlib/blas/base/sdot":"@stdlib/blas-base-sdot","@stdlib/blas/ext/base/sdsapxsum":"@stdlib/blas-ext-base-sdsapxsum","@stdlib/blas/ext/base/sdsapxsumpw":"@stdlib/blas-ext-base-sdsapxsumpw","@stdlib/blas/base/sdsdot":"@stdlib/blas-base-sdsdot","@stdlib/stats/base/sdsmean":"@stdlib/stats-base-sdsmean","@stdlib/stats/base/sdsmeanors":"@stdlib/stats-base-sdsmeanors","@stdlib/stats/base/sdsnanmean":"@stdlib/stats-base-sdsnanmean","@stdlib/stats/base/sdsnanmeanors":"@stdlib/stats-base-sdsnanmeanors","@stdlib/blas/ext/base/sdsnansum":"@stdlib/blas-ext-base-sdsnansum","@stdlib/blas/ext/base/sdsnansumpw":"@stdlib/blas-ext-base-sdsnansumpw","@stdlib/blas/ext/base/sdssum":"@stdlib/blas-ext-base-sdssum","@stdlib/blas/ext/base/sdssumpw":"@stdlib/blas-ext-base-sdssumpw","@stdlib/blas/ext/base/sfill":"@stdlib/blas-ext-base-sfill","@stdlib/math/strided/special/sfloor":"@stdlib/math-strided-special-sfloor","@stdlib/math/strided/special/sinv":"@stdlib/math-strided-special-sinv","@stdlib/strided/base/smap":"@stdlib/strided-base-smap","@stdlib/strided/base/smap2":"@stdlib/strided-base-smap2","@stdlib/stats/base/smax":"@stdlib/stats-base-smax","@stdlib/stats/base/smaxabs":"@stdlib/stats-base-smaxabs","@stdlib/stats/base/smaxabssorted":"@stdlib/stats-base-smaxabssorted","@stdlib/stats/base/smaxsorted":"@stdlib/stats-base-smaxsorted","@stdlib/stats/base/smean":"@stdlib/stats-base-smean","@stdlib/stats/base/smeankbn":"@stdlib/stats-base-smeankbn","@stdlib/stats/base/smeankbn2":"@stdlib/stats-base-smeankbn2","@stdlib/stats/base/smeanli":"@stdlib/stats-base-smeanli","@stdlib/stats/base/smeanlipw":"@stdlib/stats-base-smeanlipw","@stdlib/stats/base/smeanors":"@stdlib/stats-base-smeanors","@stdlib/stats/base/smeanpn":"@stdlib/stats-base-smeanpn","@stdlib/stats/base/smeanpw":"@stdlib/stats-base-smeanpw","@stdlib/stats/base/smeanwd":"@stdlib/stats-base-smeanwd","@stdlib/stats/base/smediansorted":"@stdlib/stats-base-smediansorted","@stdlib/stats/base/smidrange":"@stdlib/stats-base-smidrange","@stdlib/stats/base/smin":"@stdlib/stats-base-smin","@stdlib/stats/base/sminabs":"@stdlib/stats-base-sminabs","@stdlib/stats/base/sminsorted":"@stdlib/stats-base-sminsorted","@stdlib/math/strided/special/smskabs":"@stdlib/math-strided-special-smskabs","@stdlib/math/strided/special/smskabs2":"@stdlib/math-strided-special-smskabs2","@stdlib/math/strided/special/smskcbrt":"@stdlib/math-strided-special-smskcbrt","@stdlib/math/strided/special/smskceil":"@stdlib/math-strided-special-smskceil","@stdlib/math/strided/special/smskdeg2rad":"@stdlib/math-strided-special-smskdeg2rad","@stdlib/math/strided/special/smskfloor":"@stdlib/math-strided-special-smskfloor","@stdlib/math/strided/special/smskinv":"@stdlib/math-strided-special-smskinv","@stdlib/strided/base/smskmap":"@stdlib/strided-base-smskmap","@stdlib/strided/base/smskmap2":"@stdlib/strided-base-smskmap2","@stdlib/stats/base/smskmax":"@stdlib/stats-base-smskmax","@stdlib/stats/base/smskmin":"@stdlib/stats-base-smskmin","@stdlib/math/strided/special/smskramp":"@stdlib/math-strided-special-smskramp","@stdlib/stats/base/smskrange":"@stdlib/stats-base-smskrange","@stdlib/math/strided/special/smskrsqrt":"@stdlib/math-strided-special-smskrsqrt","@stdlib/math/strided/special/smsksqrt":"@stdlib/math-strided-special-smsksqrt","@stdlib/math/strided/special/smsktrunc":"@stdlib/math-strided-special-smsktrunc","@stdlib/stats/base/snanmax":"@stdlib/stats-base-snanmax","@stdlib/stats/base/snanmaxabs":"@stdlib/stats-base-snanmaxabs","@stdlib/stats/base/snanmean":"@stdlib/stats-base-snanmean","@stdlib/stats/base/snanmeanors":"@stdlib/stats-base-snanmeanors","@stdlib/stats/base/snanmeanpn":"@stdlib/stats-base-snanmeanpn","@stdlib/stats/base/snanmeanwd":"@stdlib/stats-base-snanmeanwd","@stdlib/stats/base/snanmin":"@stdlib/stats-base-snanmin","@stdlib/stats/base/snanminabs":"@stdlib/stats-base-snanminabs","@stdlib/stats/base/snanmskmax":"@stdlib/stats-base-snanmskmax","@stdlib/stats/base/snanmskmin":"@stdlib/stats-base-snanmskmin","@stdlib/stats/base/snanmskrange":"@stdlib/stats-base-snanmskrange","@stdlib/stats/base/snanrange":"@stdlib/stats-base-snanrange","@stdlib/stats/base/snanstdev":"@stdlib/stats-base-snanstdev","@stdlib/stats/base/snanstdevch":"@stdlib/stats-base-snanstdevch","@stdlib/stats/base/snanstdevpn":"@stdlib/stats-base-snanstdevpn","@stdlib/stats/base/snanstdevtk":"@stdlib/stats-base-snanstdevtk","@stdlib/stats/base/snanstdevwd":"@stdlib/stats-base-snanstdevwd","@stdlib/stats/base/snanstdevyc":"@stdlib/stats-base-snanstdevyc","@stdlib/blas/ext/base/snansum":"@stdlib/blas-ext-base-snansum","@stdlib/blas/ext/base/snansumkbn":"@stdlib/blas-ext-base-snansumkbn","@stdlib/blas/ext/base/snansumkbn2":"@stdlib/blas-ext-base-snansumkbn2","@stdlib/blas/ext/base/snansumors":"@stdlib/blas-ext-base-snansumors","@stdlib/blas/ext/base/snansumpw":"@stdlib/blas-ext-base-snansumpw","@stdlib/stats/base/snanvariance":"@stdlib/stats-base-snanvariance","@stdlib/stats/base/snanvariancech":"@stdlib/stats-base-snanvariancech","@stdlib/stats/base/snanvariancepn":"@stdlib/stats-base-snanvariancepn","@stdlib/stats/base/snanvariancetk":"@stdlib/stats-base-snanvariancetk","@stdlib/stats/base/snanvariancewd":"@stdlib/stats-base-snanvariancewd","@stdlib/stats/base/snanvarianceyc":"@stdlib/stats-base-snanvarianceyc","@stdlib/blas/base/snrm2":"@stdlib/blas-base-snrm2","@stdlib/math/strided/special/sramp":"@stdlib/math-strided-special-sramp","@stdlib/stats/base/srange":"@stdlib/stats-base-srange","@stdlib/blas/ext/base/srev":"@stdlib/blas-ext-base-srev","@stdlib/math/strided/special/srsqrt":"@stdlib/math-strided-special-srsqrt","@stdlib/blas/base/sscal":"@stdlib/blas-base-sscal","@stdlib/blas/ext/base/ssort2hp":"@stdlib/blas-ext-base-ssort2hp","@stdlib/blas/ext/base/ssort2ins":"@stdlib/blas-ext-base-ssort2ins","@stdlib/blas/ext/base/ssort2sh":"@stdlib/blas-ext-base-ssort2sh","@stdlib/blas/ext/base/ssorthp":"@stdlib/blas-ext-base-ssorthp","@stdlib/blas/ext/base/ssortins":"@stdlib/blas-ext-base-ssortins","@stdlib/blas/ext/base/ssortsh":"@stdlib/blas-ext-base-ssortsh","@stdlib/math/strided/special/ssqrt":"@stdlib/math-strided-special-ssqrt","@stdlib/stats/base/sstdev":"@stdlib/stats-base-sstdev","@stdlib/stats/base/sstdevch":"@stdlib/stats-base-sstdevch","@stdlib/stats/base/sstdevpn":"@stdlib/stats-base-sstdevpn","@stdlib/stats/base/sstdevtk":"@stdlib/stats-base-sstdevtk","@stdlib/stats/base/sstdevwd":"@stdlib/stats-base-sstdevwd","@stdlib/stats/base/sstdevyc":"@stdlib/stats-base-sstdevyc","@stdlib/blas/ext/base/ssum":"@stdlib/blas-ext-base-ssum","@stdlib/blas/ext/base/ssumkbn":"@stdlib/blas-ext-base-ssumkbn","@stdlib/blas/ext/base/ssumkbn2":"@stdlib/blas-ext-base-ssumkbn2","@stdlib/blas/ext/base/ssumors":"@stdlib/blas-ext-base-ssumors","@stdlib/blas/ext/base/ssumpw":"@stdlib/blas-ext-base-ssumpw","@stdlib/blas/base/sswap":"@stdlib/blas-base-sswap","@stdlib/stats/base/stdev":"@stdlib/stats-base-stdev","@stdlib/stats/base/stdevch":"@stdlib/stats-base-stdevch","@stdlib/stats/base/stdevpn":"@stdlib/stats-base-stdevpn","@stdlib/stats/base/stdevtk":"@stdlib/stats-base-stdevtk","@stdlib/stats/base/stdevwd":"@stdlib/stats-base-stdevwd","@stdlib/stats/base/stdevyc":"@stdlib/stats-base-stdevyc","@stdlib/math/strided/special/strunc":"@stdlib/math-strided-special-strunc","@stdlib/stats/base/svariance":"@stdlib/stats-base-svariance","@stdlib/stats/base/svariancech":"@stdlib/stats-base-svariancech","@stdlib/stats/base/svariancepn":"@stdlib/stats-base-svariancepn","@stdlib/stats/base/svariancetk":"@stdlib/stats-base-svariancetk","@stdlib/stats/base/svariancewd":"@stdlib/stats-base-svariancewd","@stdlib/stats/base/svarianceyc":"@stdlib/stats-base-svarianceyc","@stdlib/strided/base/ternary":"@stdlib/strided-base-ternary","@stdlib/strided/base/unary":"@stdlib/strided-base-unary","@stdlib/strided/base/unary-by":"@stdlib/strided-base-unary-by","@stdlib/strided/base/unary-dtype-signatures":"@stdlib/strided-base-unary-dtype-signatures","@stdlib/strided/base/unary-signature-callbacks":"@stdlib/strided-base-unary-signature-callbacks","@stdlib/stats/base/variance":"@stdlib/stats-base-variance","@stdlib/stats/base/variancech":"@stdlib/stats-base-variancech","@stdlib/stats/base/variancepn":"@stdlib/stats-base-variancepn","@stdlib/stats/base/variancetk":"@stdlib/stats-base-variancetk","@stdlib/stats/base/variancewd":"@stdlib/stats-base-variancewd","@stdlib/stats/base/varianceyc":"@stdlib/stats-base-varianceyc","@stdlib/strided/base/zmap":"@stdlib/strided-base-zmap","@stdlib/slice/base/str2multislice":"@stdlib/slice-base-str2multislice","@stdlib/slice/base/str2slice":"@stdlib/slice-base-str2slice","@stdlib/number/float64/base/sub":"@stdlib/number-float64-base-sub","@stdlib/math/base/ops/subf":"@stdlib/math-base-ops-subf","@stdlib/math/base/tools/sum-series":"@stdlib/math-base-tools-sum-series","@stdlib/math/base/special/tan":"@stdlib/math-base-special-tan","@stdlib/math/base/special/tand":"@stdlib/math-base-special-tand","@stdlib/math/base/special/tanh":"@stdlib/math-base-special-tanh","@stdlib/number/float64/base/to-binary-string":"@stdlib/number-float64-base-to-binary-string","@stdlib/number/float32/base/to-binary-string":"@stdlib/number-float32-base-to-binary-string","@stdlib/number/uint8/base/to-binary-string":"@stdlib/number-uint8-base-to-binary-string","@stdlib/number/uint16/base/to-binary-string":"@stdlib/number-uint16-base-to-binary-string","@stdlib/number/uint32/base/to-binary-string":"@stdlib/number-uint32-base-to-binary-string","@stdlib/number/float32/base/to-word":"@stdlib/number-float32-base-to-word","@stdlib/number/float64/base/to-words":"@stdlib/number-float64-base-to-words","@stdlib/ndarray/base/transpose":"@stdlib/ndarray-base-transpose","@stdlib/math/base/special/tribonacci":"@stdlib/math-base-special-tribonacci","@stdlib/math/base/special/trigamma":"@stdlib/math-base-special-trigamma","@stdlib/string/base/trim":"@stdlib/string-base-trim","@stdlib/math/base/special/trunc":"@stdlib/math-base-special-trunc","@stdlib/math/base/special/trunc2":"@stdlib/math-base-special-trunc2","@stdlib/math/base/special/trunc10":"@stdlib/math-base-special-trunc10","@stdlib/string/base/truncate-middle":"@stdlib/string-base-truncate-middle","@stdlib/math/base/special/truncb":"@stdlib/math-base-special-truncb","@stdlib/math/base/special/truncf":"@stdlib/math-base-special-truncf","@stdlib/math/base/special/truncn":"@stdlib/math-base-special-truncn","@stdlib/math/base/special/truncsd":"@stdlib/math-base-special-truncsd","@stdlib/number/uint32/base/to-int32":"@stdlib/number-uint32-base-to-int32","@stdlib/number/uint32/base/mul":"@stdlib/math-base-ops-umul","@stdlib/math/base/ops/umuldw":"@stdlib/math-base-ops-umuldw","@stdlib/string/base/uncapitalize":"@stdlib/string-base-uncapitalize","@stdlib/string/base/uppercase":"@stdlib/string-base-uppercase","@stdlib/math/base/special/vercos":"@stdlib/math-base-special-vercos","@stdlib/math/base/special/versin":"@stdlib/math-base-special-versin","@stdlib/math/base/special/wrap":"@stdlib/math-base-special-wrap","@stdlib/math/base/special/xlog1py":"@stdlib/math-base-special-xlog1py","@stdlib/math/base/special/xlogy":"@stdlib/math-base-special-xlogy","@stdlib/math/base/special/riemann-zeta":"@stdlib/math-base-special-riemann-zeta","@stdlib/bench":"@stdlib/bench","@stdlib/datasets/berndt-cps-wages-1985":"@stdlib/datasets-berndt-cps-wages-1985","@stdlib/utils/bifurcate":"@stdlib/utils-bifurcate","@stdlib/utils/bifurcate-by":"@stdlib/utils-bifurcate-by","@stdlib/utils/async/bifurcate-by":"@stdlib/utils-async-bifurcate-by","@stdlib/utils/bifurcate-in":"@stdlib/utils-bifurcate-in","@stdlib/utils/bifurcate-own":"@stdlib/utils-bifurcate-own","@stdlib/bigint/ctor":"@stdlib/bigint-ctor","@stdlib/stats/binomial-test":"@stdlib/stats-binomial-test","@stdlib/boolean/ctor":"@stdlib/boolean-ctor","@stdlib/array/bool":"@stdlib/array-bool","@stdlib/ndarray/broadcast-array":"@stdlib/ndarray-broadcast-array","@stdlib/ndarray/broadcast-arrays":"@stdlib/ndarray-broadcast-arrays","@stdlib/buffer/ctor":"@stdlib/buffer-ctor","@stdlib/buffer/to-json":"@stdlib/buffer-to-json","@stdlib/os/byte-order":"@stdlib/os-byte-order","@stdlib/string/camelcase":"@stdlib/string-camelcase","@stdlib/string/capitalize":"@stdlib/string-capitalize","@stdlib/utils/capitalize-keys":"@stdlib/utils-capitalize-keys","@stdlib/constants/float64/catalan":"@stdlib/constants-float64-catalan","@stdlib/constants/float64/cbrt-eps":"@stdlib/constants-float64-cbrt-eps","@stdlib/datasets/cdc-nchs-us-births-1969-1988":"@stdlib/datasets-cdc-nchs-us-births-1969-1988","@stdlib/datasets/cdc-nchs-us-births-1994-2003":"@stdlib/datasets-cdc-nchs-us-births-1994-2003","@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013":"@stdlib/datasets-cdc-nchs-us-infant-mortality-bw-1915-2013","@stdlib/process/chdir":"@stdlib/process-chdir","@stdlib/stats/chi2gof":"@stdlib/stats-chi2gof","@stdlib/stats/chi2test":"@stdlib/stats-chi2test","@stdlib/array/to-circular-iterator":"@stdlib/array-to-circular-iterator","@stdlib/streams/node/from-circular-array":"@stdlib/streams-node-from-circular-array","@stdlib/dstructs/circular-buffer":"@stdlib/dstructs-circular-buffer","@stdlib/fs/close":"@stdlib/fs-close","@stdlib/datasets/cmudict":"@stdlib/datasets-cmudict","@stdlib/string/code-point-at":"@stdlib/string-code-point-at","@stdlib/utils/common-keys":"@stdlib/utils-common-keys","@stdlib/utils/common-keys-in":"@stdlib/utils-common-keys-in","@stdlib/complex/cmplx":"@stdlib/complex-cmplx","@stdlib/complex/float32/ctor":"@stdlib/complex-float32-ctor","@stdlib/constants/complex64/nan":"@stdlib/constants-complex64-nan","@stdlib/constants/complex64/num-bytes":"@stdlib/constants-complex64-num-bytes","@stdlib/constants/complex64/zero":"@stdlib/constants-complex64-zero","@stdlib/array/complex64":"@stdlib/array-complex64","@stdlib/complex/float64/ctor":"@stdlib/complex-float64-ctor","@stdlib/constants/complex128/nan":"@stdlib/constants-complex128-nan","@stdlib/constants/complex128/num-bytes":"@stdlib/constants-complex128-num-bytes","@stdlib/constants/complex128/zero":"@stdlib/constants-complex128-zero","@stdlib/array/complex128":"@stdlib/array-complex128","@stdlib/array/typed-complex":"@stdlib/array-typed-complex","@stdlib/array/typed-complex-ctors":"@stdlib/array-typed-complex-ctors","@stdlib/array/typed-complex-dtypes":"@stdlib/array-typed-complex-dtypes","@stdlib/complex/ctors":"@stdlib/complex-ctors","@stdlib/complex/dtype":"@stdlib/complex-dtype","@stdlib/complex/dtypes":"@stdlib/complex-dtypes","@stdlib/complex/promotion-rules":"@stdlib/complex-promotion-rules","@stdlib/utils/compose":"@stdlib/utils-compose","@stdlib/utils/async/compose":"@stdlib/utils-async-compose","@stdlib/os/configdir":"@stdlib/os-configdir","@stdlib/complex/float64/conj":"@stdlib/complex-float64-conj","@stdlib/complex/float32/conj":"@stdlib/complex-float32-conj","@stdlib/string/constantcase":"@stdlib/string-constantcase","@stdlib/utils/constant-function":"@stdlib/utils-constant-function","@stdlib/streams/node/from-constant":"@stdlib/streams-node-from-constant","@stdlib/utils/constructor-name":"@stdlib/utils-constructor-name","@stdlib/assert/contains":"@stdlib/assert-contains","@stdlib/array/convert":"@stdlib/array-convert","@stdlib/array/convert-same":"@stdlib/array-convert-same","@stdlib/utils/convert-path":"@stdlib/utils-convert-path","@stdlib/utils/copy":"@stdlib/utils-copy","@stdlib/buffer/from-buffer":"@stdlib/buffer-from-buffer","@stdlib/utils/count-by":"@stdlib/utils-count-by","@stdlib/utils/async/count-by":"@stdlib/utils-async-count-by","@stdlib/time/current-year":"@stdlib/time-current-year","@stdlib/utils/curry":"@stdlib/utils-curry","@stdlib/utils/curry-right":"@stdlib/utils-curry-right","@stdlib/process/cwd":"@stdlib/process-cwd","@stdlib/datasets/dale-chall-new":"@stdlib/datasets-dale-chall-new","@stdlib/datasets":"@stdlib/datasets","@stdlib/array/dataview":"@stdlib/array-dataview","@stdlib/array/datespace":"@stdlib/array-datespace","@stdlib/time/day-of-quarter":"@stdlib/time-day-of-quarter","@stdlib/time/day-of-year":"@stdlib/time-day-of-year","@stdlib/time/days-in-month":"@stdlib/time-days-in-month","@stdlib/time/days-in-year":"@stdlib/time-days-in-year","@stdlib/blas/ddot":"@stdlib/blas-ddot","@stdlib/streams/node/debug-sink":"@stdlib/streams-node-debug-sink","@stdlib/streams/node/debug":"@stdlib/streams-node-debug","@stdlib/utils/decorate-after":"@stdlib/utils-decorate-after","@stdlib/assert/deep-equal":"@stdlib/assert-deep-equal","@stdlib/utils/deep-get":"@stdlib/utils-deep-get","@stdlib/assert/deep-has-own-property":"@stdlib/assert-deep-has-own-property","@stdlib/assert/deep-has-property":"@stdlib/assert-deep-has-property","@stdlib/utils/deep-pluck":"@stdlib/utils-deep-pluck","@stdlib/utils/deep-set":"@stdlib/utils-deep-set","@stdlib/utils/define-memoized-property":"@stdlib/utils-define-memoized-property","@stdlib/utils/define-properties":"@stdlib/utils-define-properties","@stdlib/utils/define-property":"@stdlib/utils-define-property","@stdlib/utils/dirname":"@stdlib/utils-dirname","@stdlib/string/dotcase":"@stdlib/string-dotcase","@stdlib/dstructs/doubly-linked-list":"@stdlib/dstructs-doubly-linked-list","@stdlib/utils/do-until":"@stdlib/utils-do-until","@stdlib/utils/async/do-until":"@stdlib/utils-async-do-until","@stdlib/utils/do-until-each":"@stdlib/utils-do-until-each","@stdlib/utils/do-until-each-right":"@stdlib/utils-do-until-each-right","@stdlib/utils/do-while":"@stdlib/utils-do-while","@stdlib/utils/async/do-while":"@stdlib/utils-async-do-while","@stdlib/utils/do-while-each":"@stdlib/utils-do-while-each","@stdlib/utils/do-while-each-right":"@stdlib/utils-do-while-each-right","@stdlib/blas/dswap":"@stdlib/blas-dswap","@stdlib/constants/float64/e":"@stdlib/constants-float64-e","@stdlib/datasets/emoji":"@stdlib/datasets-emoji","@stdlib/datasets/emoji-code-picto":"@stdlib/datasets-emoji-code-picto","@stdlib/datasets/emoji-picto-code":"@stdlib/datasets-emoji-picto-code","@stdlib/streams/node/empty":"@stdlib/streams-node-empty","@stdlib/string/ends-with":"@stdlib/string-ends-with","@stdlib/utils/enumerable-properties":"@stdlib/utils-enumerable-properties","@stdlib/utils/enumerable-properties-in":"@stdlib/utils-enumerable-properties-in","@stdlib/utils/enumerable-property-symbols":"@stdlib/utils-enumerable-property-symbols","@stdlib/utils/enumerable-property-symbols-in":"@stdlib/utils-enumerable-property-symbols-in","@stdlib/process/env":"@stdlib/process-env","@stdlib/constants/float64/eps":"@stdlib/constants-float64-eps","@stdlib/error/to-json":"@stdlib/error-to-json","@stdlib/constants/float64/eulergamma":"@stdlib/constants-float64-eulergamma","@stdlib/utils/every":"@stdlib/utils-every","@stdlib/utils/every-by":"@stdlib/utils-every-by","@stdlib/utils/async/every-by":"@stdlib/utils-async-every-by","@stdlib/utils/every-by-right":"@stdlib/utils-every-by-right","@stdlib/utils/async/every-by-right":"@stdlib/utils-async-every-by-right","@stdlib/utils/every-in-by":"@stdlib/utils-every-in-by","@stdlib/utils/every-own-by":"@stdlib/utils-every-own-by","@stdlib/utils/eval":"@stdlib/utils-eval","@stdlib/process/exec-path":"@stdlib/process-exec-path","@stdlib/fs/exists":"@stdlib/fs-exists","@stdlib/nlp/expand-acronyms":"@stdlib/nlp-expand-acronyms","@stdlib/nlp/expand-contractions":"@stdlib/nlp-expand-contractions","@stdlib/utils/extname":"@stdlib/utils-extname","@stdlib/ndarray/fancy":"@stdlib/ndarray-fancy","@stdlib/math/base/special/fast/abs":"@stdlib/math-base-special-fast-abs","@stdlib/math/base/special/fast/acosh":"@stdlib/math-base-special-fast-acosh","@stdlib/math/base/special/fast/alpha-max-plus-beta-min":"@stdlib/math-base-special-fast-alpha-max-plus-beta-min","@stdlib/math/base/special/fast/asinh":"@stdlib/math-base-special-fast-asinh","@stdlib/math/base/special/fast/atanh":"@stdlib/math-base-special-fast-atanh","@stdlib/math/base/special/fast/hypot":"@stdlib/math-base-special-fast-hypot","@stdlib/math/base/special/fast/uint32-log2":"@stdlib/math-base-special-fast-uint32-log2","@stdlib/math/base/special/fast/max":"@stdlib/math-base-special-fast-max","@stdlib/math/base/special/fast/min":"@stdlib/math-base-special-fast-min","@stdlib/math/base/special/fast/pow-int":"@stdlib/math-base-special-fast-pow-int","@stdlib/math/base/special/fast/uint32-sqrt":"@stdlib/math-base-special-fast-uint32-sqrt","@stdlib/datasets/female-first-names-en":"@stdlib/datasets-female-first-names-en","@stdlib/dstructs/fifo":"@stdlib/dstructs-fifo","@stdlib/array/filled":"@stdlib/array-filled","@stdlib/array/filled-by":"@stdlib/array-filled-by","@stdlib/utils/filter-arguments":"@stdlib/utils-filter-arguments","@stdlib/utils/find":"@stdlib/utils-find","@stdlib/string/first":"@stdlib/string-first","@stdlib/datasets/fivethirtyeight-ffq":"@stdlib/datasets-fivethirtyeight-ffq","@stdlib/utils/flatten-array":"@stdlib/utils-flatten-array","@stdlib/utils/flatten-object":"@stdlib/utils-flatten-object","@stdlib/stats/fligner-test":"@stdlib/stats-fligner-test","@stdlib/os/float-word-order":"@stdlib/os-float-word-order","@stdlib/constants/float16/cbrt-eps":"@stdlib/constants-float16-cbrt-eps","@stdlib/constants/float16/eps":"@stdlib/constants-float16-eps","@stdlib/constants/float16/exponent-bias":"@stdlib/constants-float16-exponent-bias","@stdlib/constants/float16/max":"@stdlib/constants-float16-max","@stdlib/constants/float16/max-safe-integer":"@stdlib/constants-float16-max-safe-integer","@stdlib/constants/float16/min-safe-integer":"@stdlib/constants-float16-min-safe-integer","@stdlib/constants/float16/ninf":"@stdlib/constants-float16-ninf","@stdlib/constants/float16/num-bytes":"@stdlib/constants-float16-num-bytes","@stdlib/constants/float16/pinf":"@stdlib/constants-float16-pinf","@stdlib/constants/float16/precision":"@stdlib/constants-float16-precision","@stdlib/constants/float16/smallest-normal":"@stdlib/constants-float16-smallest-normal","@stdlib/constants/float16/smallest-subnormal":"@stdlib/constants-float16-smallest-subnormal","@stdlib/constants/float16/sqrt-eps":"@stdlib/constants-float16-sqrt-eps","@stdlib/constants/float32/abs-mask":"@stdlib/constants-float32-abs-mask","@stdlib/constants/float32/cbrt-eps":"@stdlib/constants-float32-cbrt-eps","@stdlib/constants/float32/e":"@stdlib/constants-float32-e","@stdlib/constants/float32/eps":"@stdlib/constants-float32-eps","@stdlib/constants/float32/exponent-bias":"@stdlib/constants-float32-exponent-bias","@stdlib/constants/float32/exponent-mask":"@stdlib/constants-float32-exponent-mask","@stdlib/constants/float32/fourth-pi":"@stdlib/constants-float32-fourth-pi","@stdlib/constants/float32/half-ln-two":"@stdlib/constants-float32-half-ln-two","@stdlib/constants/float32/half-pi":"@stdlib/constants-float32-half-pi","@stdlib/constants/float32/ln-half":"@stdlib/constants-float32-ln-half","@stdlib/constants/float32/ln-pi":"@stdlib/constants-float32-ln-pi","@stdlib/constants/float32/ln-ten":"@stdlib/constants-float32-ln-ten","@stdlib/constants/float32/ln-two":"@stdlib/constants-float32-ln-two","@stdlib/constants/float32/max":"@stdlib/constants-float32-max","@stdlib/constants/float32/max-base2-exponent":"@stdlib/constants-float32-max-base2-exponent","@stdlib/constants/float32/max-base2-exponent-subnormal":"@stdlib/constants-float32-max-base2-exponent-subnormal","@stdlib/constants/float32/max-base10-exponent":"@stdlib/constants-float32-max-base10-exponent","@stdlib/constants/float32/max-base10-exponent-subnormal":"@stdlib/constants-float32-max-base10-exponent-subnormal","@stdlib/constants/float32/max-safe-fibonacci":"@stdlib/constants-float32-max-safe-fibonacci","@stdlib/constants/float32/max-safe-integer":"@stdlib/constants-float32-max-safe-integer","@stdlib/constants/float32/max-safe-nth-factorial":"@stdlib/constants-float32-max-safe-nth-factorial","@stdlib/constants/float32/max-safe-nth-fibonacci":"@stdlib/constants-float32-max-safe-nth-fibonacci","@stdlib/constants/float32/max-safe-nth-lucas":"@stdlib/constants-float32-max-safe-nth-lucas","@stdlib/constants/float32/min-base2-exponent":"@stdlib/constants-float32-min-base2-exponent","@stdlib/constants/float32/min-base2-exponent-subnormal":"@stdlib/constants-float32-min-base2-exponent-subnormal","@stdlib/constants/float32/min-base10-exponent":"@stdlib/constants-float32-min-base10-exponent","@stdlib/constants/float32/min-base10-exponent-subnormal":"@stdlib/constants-float32-min-base10-exponent-subnormal","@stdlib/constants/float32/min-safe-integer":"@stdlib/constants-float32-min-safe-integer","@stdlib/constants/float32/nan":"@stdlib/constants-float32-nan","@stdlib/constants/float32/ninf":"@stdlib/constants-float32-ninf","@stdlib/constants/float32/num-bytes":"@stdlib/constants-float32-num-bytes","@stdlib/constants/float32/phi":"@stdlib/constants-float32-phi","@stdlib/constants/float32/pi":"@stdlib/constants-float32-pi","@stdlib/constants/float32/pinf":"@stdlib/constants-float32-pinf","@stdlib/constants/float32/precision":"@stdlib/constants-float32-precision","@stdlib/constants/float32/sign-mask":"@stdlib/constants-float32-sign-mask","@stdlib/constants/float32/significand-mask":"@stdlib/constants-float32-significand-mask","@stdlib/constants/float32/smallest-normal":"@stdlib/constants-float32-smallest-normal","@stdlib/constants/float32/smallest-subnormal":"@stdlib/constants-float32-smallest-subnormal","@stdlib/constants/float32/sqrt-eps":"@stdlib/constants-float32-sqrt-eps","@stdlib/constants/float32/sqrt-half":"@stdlib/constants-float32-sqrt-half","@stdlib/constants/float32/sqrt-half-pi":"@stdlib/constants-float32-sqrt-half-pi","@stdlib/constants/float32/sqrt-phi":"@stdlib/constants-float32-sqrt-phi","@stdlib/constants/float32/sqrt-pi":"@stdlib/constants-float32-sqrt-pi","@stdlib/constants/float32/sqrt-three":"@stdlib/constants-float32-sqrt-three","@stdlib/constants/float32/sqrt-two":"@stdlib/constants-float32-sqrt-two","@stdlib/constants/float32/sqrt-two-pi":"@stdlib/constants-float32-sqrt-two-pi","@stdlib/constants/float32/two-pi":"@stdlib/constants-float32-two-pi","@stdlib/array/float32":"@stdlib/array-float32","@stdlib/array/fixed-endian-float32":"@stdlib/array-fixed-endian-float32","@stdlib/array/little-endian-float32":"@stdlib/array-little-endian-float32","@stdlib/constants/float64/exponent-bias":"@stdlib/constants-float64-exponent-bias","@stdlib/constants/float64/high-word-abs-mask":"@stdlib/constants-float64-high-word-abs-mask","@stdlib/constants/float64/high-word-exponent-mask":"@stdlib/constants-float64-high-word-exponent-mask","@stdlib/constants/float64/high-word-sign-mask":"@stdlib/constants-float64-high-word-sign-mask","@stdlib/constants/float64/high-word-significand-mask":"@stdlib/constants-float64-high-word-significand-mask","@stdlib/constants/float64/max":"@stdlib/constants-float64-max","@stdlib/constants/float64/max-base2-exponent":"@stdlib/constants-float64-max-base2-exponent","@stdlib/constants/float64/max-base2-exponent-subnormal":"@stdlib/constants-float64-max-base2-exponent-subnormal","@stdlib/constants/float64/max-base10-exponent":"@stdlib/constants-float64-max-base10-exponent","@stdlib/constants/float64/max-base10-exponent-subnormal":"@stdlib/constants-float64-max-base10-exponent-subnormal","@stdlib/constants/float64/max-ln":"@stdlib/constants-float64-max-ln","@stdlib/constants/float64/max-safe-fibonacci":"@stdlib/constants-float64-max-safe-fibonacci","@stdlib/constants/float64/max-safe-integer":"@stdlib/constants-float64-max-safe-integer","@stdlib/constants/float64/max-safe-lucas":"@stdlib/constants-float64-max-safe-lucas","@stdlib/constants/float64/max-safe-nth-fibonacci":"@stdlib/constants-float64-max-safe-nth-fibonacci","@stdlib/constants/float64/max-safe-nth-lucas":"@stdlib/constants-float64-max-safe-nth-lucas","@stdlib/constants/float64/min-base2-exponent":"@stdlib/constants-float64-min-base2-exponent","@stdlib/constants/float64/min-base2-exponent-subnormal":"@stdlib/constants-float64-min-base2-exponent-subnormal","@stdlib/constants/float64/min-base10-exponent":"@stdlib/constants-float64-min-base10-exponent","@stdlib/constants/float64/min-base10-exponent-subnormal":"@stdlib/constants-float64-min-base10-exponent-subnormal","@stdlib/constants/float64/min-ln":"@stdlib/constants-float64-min-ln","@stdlib/constants/float64/min-safe-integer":"@stdlib/constants-float64-min-safe-integer","@stdlib/constants/float64/num-bytes":"@stdlib/constants-float64-num-bytes","@stdlib/constants/float64/precision":"@stdlib/constants-float64-precision","@stdlib/constants/float64/smallest-normal":"@stdlib/constants-float64-smallest-normal","@stdlib/constants/float64/smallest-subnormal":"@stdlib/constants-float64-smallest-subnormal","@stdlib/array/float64":"@stdlib/array-float64","@stdlib/array/fixed-endian-float64":"@stdlib/array-fixed-endian-float64","@stdlib/array/little-endian-float64":"@stdlib/array-little-endian-float64","@stdlib/utils/for-each":"@stdlib/utils-for-each","@stdlib/utils/async/for-each":"@stdlib/utils-async-for-each","@stdlib/string/for-each":"@stdlib/string-for-each","@stdlib/utils/for-each-right":"@stdlib/utils-for-each-right","@stdlib/utils/async/for-each-right":"@stdlib/utils-async-for-each-right","@stdlib/utils/for-in":"@stdlib/utils-for-in","@stdlib/string/format":"@stdlib/string-format","@stdlib/utils/for-own":"@stdlib/utils-for-own","@stdlib/constants/float64/fourth-pi":"@stdlib/constants-float64-fourth-pi","@stdlib/constants/float64/fourth-root-eps":"@stdlib/constants-float64-fourth-root-eps","@stdlib/datasets/frb-sf-wage-rigidity":"@stdlib/datasets-frb-sf-wage-rigidity","@stdlib/string/from-code-point":"@stdlib/string-from-code-point","@stdlib/function/ctor":"@stdlib/function-ctor","@stdlib/function/to-string":"@stdlib/function-to-string","@stdlib/utils/function-name":"@stdlib/utils-function-name","@stdlib/utils/function-sequence":"@stdlib/utils-function-sequence","@stdlib/utils/async/function-sequence":"@stdlib/utils-async-function-sequence","@stdlib/constants/float64/gamma-lanczos-g":"@stdlib/constants-float64-gamma-lanczos-g","@stdlib/blas/gdot":"@stdlib/blas-gdot","@stdlib/process/getegid":"@stdlib/process-getegid","@stdlib/process/geteuid":"@stdlib/process-geteuid","@stdlib/process/getgid":"@stdlib/process-getgid","@stdlib/utils/global":"@stdlib/utils-global","@stdlib/utils/get-prototype-of":"@stdlib/utils-get-prototype-of","@stdlib/process/getuid":"@stdlib/process-getuid","@stdlib/constants/float64/glaisher-kinkelin":"@stdlib/constants-float64-glaisher-kinkelin","@stdlib/string/to-grapheme-cluster-iterator":"@stdlib/string-to-grapheme-cluster-iterator","@stdlib/string/to-grapheme-cluster-iterator-right":"@stdlib/string-to-grapheme-cluster-iterator-right","@stdlib/utils/group":"@stdlib/utils-group","@stdlib/utils/group-by":"@stdlib/utils-group-by","@stdlib/utils/async/group-by":"@stdlib/utils-async-group-by","@stdlib/utils/group-in":"@stdlib/utils-group-in","@stdlib/utils/group-own":"@stdlib/utils-group-own","@stdlib/blas/gswap":"@stdlib/blas-gswap","@stdlib/constants/float64/half-ln-two":"@stdlib/constants-float64-half-ln-two","@stdlib/constants/float64/half-pi":"@stdlib/constants-float64-half-pi","@stdlib/datasets/harrison-boston-house-prices":"@stdlib/datasets-harrison-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices-corrected":"@stdlib/datasets-harrison-boston-house-prices-corrected","@stdlib/assert/has-arraybuffer-support":"@stdlib/assert-has-arraybuffer-support","@stdlib/assert/has-arrow-function-support":"@stdlib/assert-has-arrow-function-support","@stdlib/assert/has-async-await-support":"@stdlib/assert-has-async-await-support","@stdlib/assert/has-async-iterator-symbol-support":"@stdlib/assert-has-async-iterator-symbol-support","@stdlib/assert/has-atob-support":"@stdlib/assert-has-atob-support","@stdlib/assert/has-bigint64array-support":"@stdlib/assert-has-bigint64array-support","@stdlib/assert/has-bigint-support":"@stdlib/assert-has-bigint-support","@stdlib/assert/has-biguint64array-support":"@stdlib/assert-has-biguint64array-support","@stdlib/assert/has-btoa-support":"@stdlib/assert-has-btoa-support","@stdlib/assert/has-class-support":"@stdlib/assert-has-class-support","@stdlib/assert/has-dataview-support":"@stdlib/assert-has-dataview-support","@stdlib/assert/has-define-properties-support":"@stdlib/assert-has-define-properties-support","@stdlib/assert/has-define-property-support":"@stdlib/assert-has-define-property-support","@stdlib/assert/has-float32array-support":"@stdlib/assert-has-float32array-support","@stdlib/assert/has-float64array-support":"@stdlib/assert-has-float64array-support","@stdlib/assert/has-function-name-support":"@stdlib/assert-has-function-name-support","@stdlib/assert/has-generator-support":"@stdlib/assert-has-generator-support","@stdlib/assert/has-globalthis-support":"@stdlib/assert-has-globalthis-support","@stdlib/assert/has-int8array-support":"@stdlib/assert-has-int8array-support","@stdlib/assert/has-int16array-support":"@stdlib/assert-has-int16array-support","@stdlib/assert/has-int32array-support":"@stdlib/assert-has-int32array-support","@stdlib/assert/has-iterator-symbol-support":"@stdlib/assert-has-iterator-symbol-support","@stdlib/assert/has-map-support":"@stdlib/assert-has-map-support","@stdlib/assert/has-node-buffer-support":"@stdlib/assert-has-node-buffer-support","@stdlib/assert/has-own-property":"@stdlib/assert-has-own-property","@stdlib/assert/has-property":"@stdlib/assert-has-property","@stdlib/assert/has-proxy-support":"@stdlib/assert-has-proxy-support","@stdlib/assert/has-set-support":"@stdlib/assert-has-set-support","@stdlib/assert/has-sharedarraybuffer-support":"@stdlib/assert-has-sharedarraybuffer-support","@stdlib/assert/has-symbol-support":"@stdlib/assert-has-symbol-support","@stdlib/assert/has-tostringtag-support":"@stdlib/assert-has-tostringtag-support","@stdlib/assert/has-uint8array-support":"@stdlib/assert-has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support":"@stdlib/assert-has-uint8clampedarray-support","@stdlib/assert/has-uint16array-support":"@stdlib/assert-has-uint16array-support","@stdlib/assert/has-uint32array-support":"@stdlib/assert-has-uint32array-support","@stdlib/assert/has-utf16-surrogate-pair-at":"@stdlib/assert-has-utf16-surrogate-pair-at","@stdlib/assert/has-weakmap-support":"@stdlib/assert-has-weakmap-support","@stdlib/assert/has-weakset-support":"@stdlib/assert-has-weakset-support","@stdlib/assert/has-wasm-support":"@stdlib/assert-has-wasm-support","@stdlib/string/headercase":"@stdlib/string-headercase","@stdlib/datasets/herndon-venus-semidiameters":"@stdlib/datasets-herndon-venus-semidiameters","@stdlib/os/homedir":"@stdlib/os-homedir","@stdlib/constants/time/hours-in-day":"@stdlib/constants-time-hours-in-day","@stdlib/constants/time/hours-in-week":"@stdlib/constants-time-hours-in-week","@stdlib/time/hours-in-month":"@stdlib/time-hours-in-month","@stdlib/time/hours-in-year":"@stdlib/time-hours-in-year","@stdlib/net/http-server":"@stdlib/net-http-server","@stdlib/utils/identity-function":"@stdlib/utils-identity-function","@stdlib/utils/if-else":"@stdlib/utils-if-else","@stdlib/utils/async/if-else":"@stdlib/utils-async-if-else","@stdlib/utils/if-then":"@stdlib/utils-if-then","@stdlib/utils/async/if-then":"@stdlib/utils-async-if-then","@stdlib/complex/float64/imag":"@stdlib/complex-float64-imag","@stdlib/complex/float32/imag":"@stdlib/complex-float32-imag","@stdlib/datasets/img-acanthus-mollis":"@stdlib/datasets-img-acanthus-mollis","@stdlib/datasets/img-airplane-from-above":"@stdlib/datasets-img-airplane-from-above","@stdlib/datasets/img-allium-oreophilum":"@stdlib/datasets-img-allium-oreophilum","@stdlib/datasets/img-black-canyon":"@stdlib/datasets-img-black-canyon","@stdlib/datasets/img-dust-bowl-home":"@stdlib/datasets-img-dust-bowl-home","@stdlib/datasets/img-french-alpine-landscape":"@stdlib/datasets-img-french-alpine-landscape","@stdlib/datasets/img-locomotion-house-cat":"@stdlib/datasets-img-locomotion-house-cat","@stdlib/datasets/img-locomotion-nude-male":"@stdlib/datasets-img-locomotion-nude-male","@stdlib/datasets/img-march-pastoral":"@stdlib/datasets-img-march-pastoral","@stdlib/datasets/img-nagasaki-boats":"@stdlib/datasets-img-nagasaki-boats","@stdlib/stats/incr/apcorr":"@stdlib/stats-incr-apcorr","@stdlib/ml/incr/binary-classification":"@stdlib/ml-incr-binary-classification","@stdlib/stats/incr/count":"@stdlib/stats-incr-count","@stdlib/stats/incr/covariance":"@stdlib/stats-incr-covariance","@stdlib/stats/incr/covmat":"@stdlib/stats-incr-covmat","@stdlib/stats/incr/cv":"@stdlib/stats-incr-cv","@stdlib/stats/incr/ewmean":"@stdlib/stats-incr-ewmean","@stdlib/stats/incr/ewstdev":"@stdlib/stats-incr-ewstdev","@stdlib/stats/incr/ewvariance":"@stdlib/stats-incr-ewvariance","@stdlib/stats/incr/gmean":"@stdlib/stats-incr-gmean","@stdlib/stats/incr/grubbs":"@stdlib/stats-incr-grubbs","@stdlib/stats/incr/hmean":"@stdlib/stats-incr-hmean","@stdlib/ml/incr/kmeans":"@stdlib/ml-incr-kmeans","@stdlib/stats/incr/kurtosis":"@stdlib/stats-incr-kurtosis","@stdlib/stats/incr/maape":"@stdlib/stats-incr-maape","@stdlib/stats/incr/mae":"@stdlib/stats-incr-mae","@stdlib/stats/incr/mapcorr":"@stdlib/stats-incr-mapcorr","@stdlib/stats/incr/mape":"@stdlib/stats-incr-mape","@stdlib/stats/incr/max":"@stdlib/stats-incr-max","@stdlib/stats/incr/maxabs":"@stdlib/stats-incr-maxabs","@stdlib/stats/incr/mcovariance":"@stdlib/stats-incr-mcovariance","@stdlib/stats/incr/mcv":"@stdlib/stats-incr-mcv","@stdlib/stats/incr/mda":"@stdlib/stats-incr-mda","@stdlib/stats/incr/me":"@stdlib/stats-incr-me","@stdlib/stats/incr/mean":"@stdlib/stats-incr-mean","@stdlib/stats/incr/meanabs":"@stdlib/stats-incr-meanabs","@stdlib/stats/incr/meanabs2":"@stdlib/stats-incr-meanabs2","@stdlib/stats/incr/meanstdev":"@stdlib/stats-incr-meanstdev","@stdlib/stats/incr/meanvar":"@stdlib/stats-incr-meanvar","@stdlib/stats/incr/mgmean":"@stdlib/stats-incr-mgmean","@stdlib/stats/incr/mgrubbs":"@stdlib/stats-incr-mgrubbs","@stdlib/stats/incr/mhmean":"@stdlib/stats-incr-mhmean","@stdlib/stats/incr/midrange":"@stdlib/stats-incr-midrange","@stdlib/stats/incr/min":"@stdlib/stats-incr-min","@stdlib/stats/incr/minabs":"@stdlib/stats-incr-minabs","@stdlib/stats/incr/minmax":"@stdlib/stats-incr-minmax","@stdlib/stats/incr/minmaxabs":"@stdlib/stats-incr-minmaxabs","@stdlib/stats/incr/mmaape":"@stdlib/stats-incr-mmaape","@stdlib/stats/incr/mmae":"@stdlib/stats-incr-mmae","@stdlib/stats/incr/mmape":"@stdlib/stats-incr-mmape","@stdlib/stats/incr/mmax":"@stdlib/stats-incr-mmax","@stdlib/stats/incr/mmaxabs":"@stdlib/stats-incr-mmaxabs","@stdlib/stats/incr/mmda":"@stdlib/stats-incr-mmda","@stdlib/stats/incr/mme":"@stdlib/stats-incr-mme","@stdlib/stats/incr/mmean":"@stdlib/stats-incr-mmean","@stdlib/stats/incr/mmeanabs":"@stdlib/stats-incr-mmeanabs","@stdlib/stats/incr/mmeanabs2":"@stdlib/stats-incr-mmeanabs2","@stdlib/stats/incr/mmeanstdev":"@stdlib/stats-incr-mmeanstdev","@stdlib/stats/incr/mmeanvar":"@stdlib/stats-incr-mmeanvar","@stdlib/stats/incr/mmidrange":"@stdlib/stats-incr-mmidrange","@stdlib/stats/incr/mmin":"@stdlib/stats-incr-mmin","@stdlib/stats/incr/mminabs":"@stdlib/stats-incr-mminabs","@stdlib/stats/incr/mminmax":"@stdlib/stats-incr-mminmax","@stdlib/stats/incr/mminmaxabs":"@stdlib/stats-incr-mminmaxabs","@stdlib/stats/incr/mmpe":"@stdlib/stats-incr-mmpe","@stdlib/stats/incr/mmse":"@stdlib/stats-incr-mmse","@stdlib/stats/incr/mpcorr":"@stdlib/stats-incr-mpcorr","@stdlib/stats/incr/mpcorr2":"@stdlib/stats-incr-mpcorr2","@stdlib/stats/incr/mpcorrdist":"@stdlib/stats-incr-mpcorrdist","@stdlib/stats/incr/mpe":"@stdlib/stats-incr-mpe","@stdlib/stats/incr/mprod":"@stdlib/stats-incr-mprod","@stdlib/stats/incr/mrange":"@stdlib/stats-incr-mrange","@stdlib/stats/incr/mrmse":"@stdlib/stats-incr-mrmse","@stdlib/stats/incr/mrss":"@stdlib/stats-incr-mrss","@stdlib/stats/incr/mse":"@stdlib/stats-incr-mse","@stdlib/stats/incr/mstdev":"@stdlib/stats-incr-mstdev","@stdlib/stats/incr/msum":"@stdlib/stats-incr-msum","@stdlib/stats/incr/msumabs":"@stdlib/stats-incr-msumabs","@stdlib/stats/incr/msumabs2":"@stdlib/stats-incr-msumabs2","@stdlib/stats/incr/msummary":"@stdlib/stats-incr-msummary","@stdlib/stats/incr/msumprod":"@stdlib/stats-incr-msumprod","@stdlib/stats/incr/mvariance":"@stdlib/stats-incr-mvariance","@stdlib/stats/incr/mvmr":"@stdlib/stats-incr-mvmr","@stdlib/stats/incr/nancount":"@stdlib/stats-incr-nancount","@stdlib/stats/incr/nansum":"@stdlib/stats-incr-nansum","@stdlib/stats/incr/nansumabs":"@stdlib/stats-incr-nansumabs","@stdlib/stats/incr/nansumabs2":"@stdlib/stats-incr-nansumabs2","@stdlib/stats/incr/pcorr":"@stdlib/stats-incr-pcorr","@stdlib/stats/incr/pcorr2":"@stdlib/stats-incr-pcorr2","@stdlib/stats/incr/pcorrdist":"@stdlib/stats-incr-pcorrdist","@stdlib/stats/incr/pcorrdistmat":"@stdlib/stats-incr-pcorrdistmat","@stdlib/stats/incr/pcorrmat":"@stdlib/stats-incr-pcorrmat","@stdlib/stats/incr/prod":"@stdlib/stats-incr-prod","@stdlib/stats/incr/range":"@stdlib/stats-incr-range","@stdlib/stats/incr/rmse":"@stdlib/stats-incr-rmse","@stdlib/stats/incr/rss":"@stdlib/stats-incr-rss","@stdlib/ml/incr/sgd-regression":"@stdlib/ml-incr-sgd-regression","@stdlib/stats/incr/skewness":"@stdlib/stats-incr-skewness","@stdlib/array/incrspace":"@stdlib/array-incrspace","@stdlib/stats/incr/stdev":"@stdlib/stats-incr-stdev","@stdlib/stats/incr/sum":"@stdlib/stats-incr-sum","@stdlib/stats/incr/sumabs":"@stdlib/stats-incr-sumabs","@stdlib/stats/incr/sumabs2":"@stdlib/stats-incr-sumabs2","@stdlib/stats/incr/summary":"@stdlib/stats-incr-summary","@stdlib/stats/incr/sumprod":"@stdlib/stats-incr-sumprod","@stdlib/stats/incr/variance":"@stdlib/stats-incr-variance","@stdlib/stats/incr/vmr":"@stdlib/stats-incr-vmr","@stdlib/stats/incr/wmean":"@stdlib/stats-incr-wmean","@stdlib/ndarray/ind2sub":"@stdlib/ndarray-ind2sub","@stdlib/utils/index-of":"@stdlib/utils-index-of","@stdlib/utils/inherit":"@stdlib/utils-inherit","@stdlib/utils/inherited-enumerable-properties":"@stdlib/utils-inherited-enumerable-properties","@stdlib/utils/inherited-enumerable-property-symbols":"@stdlib/utils-inherited-enumerable-property-symbols","@stdlib/utils/inherited-keys":"@stdlib/utils-inherited-keys","@stdlib/utils/inherited-nonenumerable-properties":"@stdlib/utils-inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names":"@stdlib/utils-inherited-nonenumerable-property-names","@stdlib/utils/inherited-nonenumerable-property-symbols":"@stdlib/utils-inherited-nonenumerable-property-symbols","@stdlib/utils/inherited-properties":"@stdlib/utils-inherited-properties","@stdlib/utils/inherited-property-descriptor":"@stdlib/utils-inherited-property-descriptor","@stdlib/utils/inherited-property-descriptors":"@stdlib/utils-inherited-property-descriptors","@stdlib/utils/inherited-property-names":"@stdlib/utils-inherited-property-names","@stdlib/utils/inherited-property-symbols":"@stdlib/utils-inherited-property-symbols","@stdlib/utils/inherited-writable-properties":"@stdlib/utils-inherited-writable-properties","@stdlib/utils/inherited-writable-property-names":"@stdlib/utils-inherited-writable-property-names","@stdlib/utils/inherited-writable-property-symbols":"@stdlib/utils-inherited-writable-property-symbols","@stdlib/utils/inmap":"@stdlib/utils-inmap","@stdlib/utils/async/inmap":"@stdlib/utils-async-inmap","@stdlib/utils/inmap-right":"@stdlib/utils-inmap-right","@stdlib/utils/async/inmap-right":"@stdlib/utils-async-inmap-right","@stdlib/streams/node/inspect-sink":"@stdlib/streams-node-inspect-sink","@stdlib/streams/node/inspect":"@stdlib/streams-node-inspect","@stdlib/assert/instance-of":"@stdlib/assert-instance-of","@stdlib/constants/int8/max":"@stdlib/constants-int8-max","@stdlib/constants/int8/min":"@stdlib/constants-int8-min","@stdlib/constants/int8/num-bytes":"@stdlib/constants-int8-num-bytes","@stdlib/array/int8":"@stdlib/array-int8","@stdlib/constants/int16/max":"@stdlib/constants-int16-max","@stdlib/constants/int16/min":"@stdlib/constants-int16-min","@stdlib/constants/int16/num-bytes":"@stdlib/constants-int16-num-bytes","@stdlib/array/int16":"@stdlib/array-int16","@stdlib/constants/int32/max":"@stdlib/constants-int32-max","@stdlib/constants/int32/min":"@stdlib/constants-int32-min","@stdlib/constants/int32/num-bytes":"@stdlib/constants-int32-num-bytes","@stdlib/array/int32":"@stdlib/array-int32","@stdlib/assert/is-big-endian":"@stdlib/assert-is-big-endian","@stdlib/assert/is-browser":"@stdlib/assert-is-browser","@stdlib/assert/is-darwin":"@stdlib/assert-is-darwin","@stdlib/assert/is-docker":"@stdlib/assert-is-docker","@stdlib/assert/is-electron":"@stdlib/assert-is-electron","@stdlib/assert/is-electron-main":"@stdlib/assert-is-electron-main","@stdlib/assert/is-electron-renderer":"@stdlib/assert-is-electron-renderer","@stdlib/assert/is-little-endian":"@stdlib/assert-is-little-endian","@stdlib/assert/is-mobile":"@stdlib/assert-is-mobile","@stdlib/assert/is-node":"@stdlib/assert-is-node","@stdlib/assert/is-touch-device":"@stdlib/assert-is-touch-device","@stdlib/assert/is-web-worker":"@stdlib/assert-is-web-worker","@stdlib/assert/is-windows":"@stdlib/assert-is-windows","@stdlib/assert/is-absolute-http-uri":"@stdlib/assert-is-absolute-http-uri","@stdlib/assert/is-absolute-path":"@stdlib/assert-is-absolute-path","@stdlib/assert/is-absolute-uri":"@stdlib/assert-is-absolute-uri","@stdlib/assert/is-accessor-array":"@stdlib/assert-is-accessor-array","@stdlib/assert/is-accessor-property":"@stdlib/assert-is-accessor-property","@stdlib/assert/is-accessor-property-in":"@stdlib/assert-is-accessor-property-in","@stdlib/assert/is-alphagram":"@stdlib/assert-is-alphagram","@stdlib/assert/is-alphanumeric":"@stdlib/assert-is-alphanumeric","@stdlib/assert/is-anagram":"@stdlib/assert-is-anagram","@stdlib/assert/is-arguments":"@stdlib/assert-is-arguments","@stdlib/assert/is-array":"@stdlib/assert-is-array","@stdlib/assert/is-array-array":"@stdlib/assert-is-array-array","@stdlib/assert/is-arraybuffer":"@stdlib/assert-is-arraybuffer","@stdlib/assert/is-arraybuffer-view":"@stdlib/assert-is-arraybuffer-view","@stdlib/assert/is-array-length":"@stdlib/assert-is-array-length","@stdlib/assert/is-array-like":"@stdlib/assert-is-array-like","@stdlib/assert/is-array-like-object":"@stdlib/assert-is-array-like-object","@stdlib/assert/is-arrow-function":"@stdlib/assert-is-arrow-function","@stdlib/assert/is-ascii":"@stdlib/assert-is-ascii","@stdlib/assert/is-between":"@stdlib/assert-is-between","@stdlib/assert/is-between-array":"@stdlib/assert-is-between-array","@stdlib/assert/is-bigint":"@stdlib/assert-is-bigint","@stdlib/assert/is-bigint64array":"@stdlib/assert-is-bigint64array","@stdlib/assert/is-biguint64array":"@stdlib/assert-is-biguint64array","@stdlib/assert/is-binary-string":"@stdlib/assert-is-binary-string","@stdlib/assert/is-blank-string":"@stdlib/assert-is-blank-string","@stdlib/assert/is-boolean":"@stdlib/assert-is-boolean","@stdlib/assert/is-boolean-array":"@stdlib/assert-is-boolean-array","@stdlib/assert/is-boxed-primitive":"@stdlib/assert-is-boxed-primitive","@stdlib/assert/is-buffer":"@stdlib/assert-is-buffer","@stdlib/assert/is-camelcase":"@stdlib/assert-is-camelcase","@stdlib/assert/is-capitalized":"@stdlib/assert-is-capitalized","@stdlib/assert/is-centrosymmetric-matrix":"@stdlib/assert-is-centrosymmetric-matrix","@stdlib/assert/is-circular":"@stdlib/assert-is-circular","@stdlib/assert/is-circular-array":"@stdlib/assert-is-circular-array","@stdlib/assert/is-circular-plain-object":"@stdlib/assert-is-circular-plain-object","@stdlib/assert/is-class":"@stdlib/assert-is-class","@stdlib/assert/is-collection":"@stdlib/assert-is-collection","@stdlib/assert/is-complex":"@stdlib/assert-is-complex","@stdlib/assert/is-complex64":"@stdlib/assert-is-complex64","@stdlib/assert/is-complex64array":"@stdlib/assert-is-complex64array","@stdlib/assert/is-complex64matrix-like":"@stdlib/assert-is-complex64matrix-like","@stdlib/assert/is-complex64ndarray-like":"@stdlib/assert-is-complex64ndarray-like","@stdlib/assert/is-complex64vector-like":"@stdlib/assert-is-complex64vector-like","@stdlib/assert/is-complex128":"@stdlib/assert-is-complex128","@stdlib/assert/is-complex128array":"@stdlib/assert-is-complex128array","@stdlib/assert/is-complex128matrix-like":"@stdlib/assert-is-complex128matrix-like","@stdlib/assert/is-complex128ndarray-like":"@stdlib/assert-is-complex128ndarray-like","@stdlib/assert/is-complex128vector-like":"@stdlib/assert-is-complex128vector-like","@stdlib/assert/is-complex-like":"@stdlib/assert-is-complex-like","@stdlib/assert/is-complex-typed-array":"@stdlib/assert-is-complex-typed-array","@stdlib/assert/is-complex-typed-array-like":"@stdlib/assert-is-complex-typed-array-like","@stdlib/assert/is-composite":"@stdlib/assert-is-composite","@stdlib/assert/is-configurable-property":"@stdlib/assert-is-configurable-property","@stdlib/assert/is-configurable-property-in":"@stdlib/assert-is-configurable-property-in","@stdlib/assert/is-constantcase":"@stdlib/assert-is-constantcase","@stdlib/assert/is-cube-number":"@stdlib/assert-is-cube-number","@stdlib/assert/is-current-year":"@stdlib/assert-is-current-year","@stdlib/assert/is-data-property":"@stdlib/assert-is-data-property","@stdlib/assert/is-data-property-in":"@stdlib/assert-is-data-property-in","@stdlib/assert/is-dataview":"@stdlib/assert-is-dataview","@stdlib/assert/is-date-object":"@stdlib/assert-is-date-object","@stdlib/assert/is-date-object-array":"@stdlib/assert-is-date-object-array","@stdlib/assert/is-digit-string":"@stdlib/assert-is-digit-string","@stdlib/assert/is-domain-name":"@stdlib/assert-is-domain-name","@stdlib/assert/is-duration-string":"@stdlib/assert-is-duration-string","@stdlib/assert/is-email-address":"@stdlib/assert-is-email-address","@stdlib/assert/is-empty-array":"@stdlib/assert-is-empty-array","@stdlib/assert/is-empty-array-like-object":"@stdlib/assert-is-empty-array-like-object","@stdlib/assert/is-empty-collection":"@stdlib/assert-is-empty-collection","@stdlib/assert/is-empty-object":"@stdlib/assert-is-empty-object","@stdlib/assert/is-empty-string":"@stdlib/assert-is-empty-string","@stdlib/assert/is-enumerable-property":"@stdlib/assert-is-enumerable-property","@stdlib/assert/is-enumerable-property-in":"@stdlib/assert-is-enumerable-property-in","@stdlib/assert/is-equal-array":"@stdlib/assert-is-equal-array","@stdlib/assert/is-error":"@stdlib/assert-is-error","@stdlib/assert/is-eval-error":"@stdlib/assert-is-eval-error","@stdlib/assert/is-even":"@stdlib/assert-is-even","@stdlib/assert/is-falsy":"@stdlib/assert-is-falsy","@stdlib/assert/is-falsy-array":"@stdlib/assert-is-falsy-array","@stdlib/assert/is-finite":"@stdlib/assert-is-finite","@stdlib/assert/is-finite-array":"@stdlib/assert-is-finite-array","@stdlib/assert/is-float32array":"@stdlib/assert-is-float32array","@stdlib/assert/is-float32matrix-like":"@stdlib/assert-is-float32matrix-like","@stdlib/assert/is-float32ndarray-like":"@stdlib/assert-is-float32ndarray-like","@stdlib/assert/is-float32vector-like":"@stdlib/assert-is-float32vector-like","@stdlib/assert/is-float64array":"@stdlib/assert-is-float64array","@stdlib/assert/is-float64matrix-like":"@stdlib/assert-is-float64matrix-like","@stdlib/assert/is-float64ndarray-like":"@stdlib/assert-is-float64ndarray-like","@stdlib/assert/is-float64vector-like":"@stdlib/assert-is-float64vector-like","@stdlib/assert/is-function":"@stdlib/assert-is-function","@stdlib/assert/is-function-array":"@stdlib/assert-is-function-array","@stdlib/assert/is-generator-object":"@stdlib/assert-is-generator-object","@stdlib/assert/is-generator-object-like":"@stdlib/assert-is-generator-object-like","@stdlib/assert/is-gzip-buffer":"@stdlib/assert-is-gzip-buffer","@stdlib/assert/is-hex-string":"@stdlib/assert-is-hex-string","@stdlib/assert/is-infinite":"@stdlib/assert-is-infinite","@stdlib/assert/is-inherited-property":"@stdlib/assert-is-inherited-property","@stdlib/assert/is-int8array":"@stdlib/assert-is-int8array","@stdlib/assert/is-int16array":"@stdlib/assert-is-int16array","@stdlib/assert/is-int32array":"@stdlib/assert-is-int32array","@stdlib/assert/is-integer":"@stdlib/assert-is-integer","@stdlib/assert/is-integer-array":"@stdlib/assert-is-integer-array","@stdlib/assert/is-iterable-like":"@stdlib/assert-is-iterable-like","@stdlib/assert/is-iterator-like":"@stdlib/assert-is-iterator-like","@stdlib/assert/is-json":"@stdlib/assert-is-json","@stdlib/assert/is-kebabcase":"@stdlib/assert-is-kebabcase","@stdlib/assert/is-leap-year":"@stdlib/assert-is-leap-year","@stdlib/assert/is-localhost":"@stdlib/assert-is-localhost","@stdlib/assert/is-lowercase":"@stdlib/assert-is-lowercase","@stdlib/assert/is-matrix-like":"@stdlib/assert-is-matrix-like","@stdlib/assert/is-method":"@stdlib/assert-is-method","@stdlib/assert/is-method-in":"@stdlib/assert-is-method-in","@stdlib/assert/is-multi-slice":"@stdlib/assert-is-multi-slice","@stdlib/assert/is-named-typed-tuple-like":"@stdlib/assert-is-named-typed-tuple-like","@stdlib/assert/is-nan":"@stdlib/assert-is-nan","@stdlib/assert/is-nan-array":"@stdlib/assert-is-nan-array","@stdlib/assert/is-native-function":"@stdlib/assert-is-native-function","@stdlib/assert/is-ndarray-like":"@stdlib/assert-is-ndarray-like","@stdlib/assert/is-ndarray-like-with-data-type":"@stdlib/assert-is-ndarray-like-with-data-type","@stdlib/assert/is-negative-finite":"@stdlib/assert-is-negative-finite","@stdlib/assert/is-negative-integer":"@stdlib/assert-is-negative-integer","@stdlib/assert/is-negative-integer-array":"@stdlib/assert-is-negative-integer-array","@stdlib/assert/is-negative-number":"@stdlib/assert-is-negative-number","@stdlib/assert/is-negative-number-array":"@stdlib/assert-is-negative-number-array","@stdlib/assert/is-negative-zero":"@stdlib/assert-is-negative-zero","@stdlib/assert/is-node-builtin":"@stdlib/assert-is-node-builtin","@stdlib/assert/is-node-duplex-stream-like":"@stdlib/assert-is-node-duplex-stream-like","@stdlib/assert/is-node-readable-stream-like":"@stdlib/assert-is-node-readable-stream-like","@stdlib/assert/is-node-repl":"@stdlib/assert-is-node-repl","@stdlib/assert/is-node-stream-like":"@stdlib/assert-is-node-stream-like","@stdlib/assert/is-node-transform-stream-like":"@stdlib/assert-is-node-transform-stream-like","@stdlib/assert/is-node-writable-stream-like":"@stdlib/assert-is-node-writable-stream-like","@stdlib/assert/is-nonconfigurable-property":"@stdlib/assert-is-nonconfigurable-property","@stdlib/assert/is-nonconfigurable-property-in":"@stdlib/assert-is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property":"@stdlib/assert-is-nonenumerable-property","@stdlib/assert/is-nonenumerable-property-in":"@stdlib/assert-is-nonenumerable-property-in","@stdlib/assert/is-nonnegative-finite":"@stdlib/assert-is-nonnegative-finite","@stdlib/assert/is-nonnegative-integer":"@stdlib/assert-is-nonnegative-integer","@stdlib/assert/is-nonnegative-integer-array":"@stdlib/assert-is-nonnegative-integer-array","@stdlib/assert/is-nonnegative-number":"@stdlib/assert-is-nonnegative-number","@stdlib/assert/is-nonnegative-number-array":"@stdlib/assert-is-nonnegative-number-array","@stdlib/assert/is-nonpositive-finite":"@stdlib/assert-is-nonpositive-finite","@stdlib/assert/is-nonpositive-integer":"@stdlib/assert-is-nonpositive-integer","@stdlib/assert/is-nonpositive-integer-array":"@stdlib/assert-is-nonpositive-integer-array","@stdlib/assert/is-nonpositive-number":"@stdlib/assert-is-nonpositive-number","@stdlib/assert/is-nonpositive-number-array":"@stdlib/assert-is-nonpositive-number-array","@stdlib/assert/is-nonsymmetric-matrix":"@stdlib/assert-is-nonsymmetric-matrix","@stdlib/assert/is-null":"@stdlib/assert-is-null","@stdlib/assert/is-null-array":"@stdlib/assert-is-null-array","@stdlib/assert/is-number":"@stdlib/assert-is-number","@stdlib/assert/is-number-array":"@stdlib/assert-is-number-array","@stdlib/assert/is-numeric-array":"@stdlib/assert-is-numeric-array","@stdlib/assert/is-object":"@stdlib/assert-is-object","@stdlib/assert/is-object-array":"@stdlib/assert-is-object-array","@stdlib/assert/is-object-like":"@stdlib/assert-is-object-like","@stdlib/assert/is-odd":"@stdlib/assert-is-odd","@stdlib/time/iso-weeks-in-year":"@stdlib/time-iso-weeks-in-year","@stdlib/assert/is-pascalcase":"@stdlib/assert-is-pascalcase","@stdlib/assert/is-persymmetric-matrix":"@stdlib/assert-is-persymmetric-matrix","@stdlib/assert/is-plain-object":"@stdlib/assert-is-plain-object","@stdlib/assert/is-plain-object-array":"@stdlib/assert-is-plain-object-array","@stdlib/assert/is-positive-finite":"@stdlib/assert-is-positive-finite","@stdlib/assert/is-positive-integer":"@stdlib/assert-is-positive-integer","@stdlib/assert/is-positive-integer-array":"@stdlib/assert-is-positive-integer-array","@stdlib/assert/is-positive-number":"@stdlib/assert-is-positive-number","@stdlib/assert/is-positive-number-array":"@stdlib/assert-is-positive-number-array","@stdlib/assert/is-positive-zero":"@stdlib/assert-is-positive-zero","@stdlib/assert/is-prime":"@stdlib/assert-is-prime","@stdlib/assert/is-primitive":"@stdlib/assert-is-primitive","@stdlib/assert/is-primitive-array":"@stdlib/assert-is-primitive-array","@stdlib/assert/is-prng-like":"@stdlib/assert-is-prng-like","@stdlib/assert/is-probability":"@stdlib/assert-is-probability","@stdlib/assert/is-probability-array":"@stdlib/assert-is-probability-array","@stdlib/assert/is-property-key":"@stdlib/assert-is-property-key","@stdlib/assert/is-prototype-of":"@stdlib/assert-is-prototype-of","@stdlib/assert/is-ragged-nested-array":"@stdlib/assert-is-ragged-nested-array","@stdlib/assert/is-range-error":"@stdlib/assert-is-range-error","@stdlib/assert/is-readable-property":"@stdlib/assert-is-readable-property","@stdlib/assert/is-readable-property-in":"@stdlib/assert-is-readable-property-in","@stdlib/assert/is-read-only-property":"@stdlib/assert-is-read-only-property","@stdlib/assert/is-read-only-property-in":"@stdlib/assert-is-read-only-property-in","@stdlib/assert/is-read-write-property":"@stdlib/assert-is-read-write-property","@stdlib/assert/is-read-write-property-in":"@stdlib/assert-is-read-write-property-in","@stdlib/assert/is-reference-error":"@stdlib/assert-is-reference-error","@stdlib/assert/is-regexp":"@stdlib/assert-is-regexp","@stdlib/assert/is-regexp-string":"@stdlib/assert-is-regexp-string","@stdlib/assert/is-relative-path":"@stdlib/assert-is-relative-path","@stdlib/assert/is-relative-uri":"@stdlib/assert-is-relative-uri","@stdlib/assert/is-safe-integer":"@stdlib/assert-is-safe-integer","@stdlib/assert/is-safe-integer-array":"@stdlib/assert-is-safe-integer-array","@stdlib/assert/is-same-array":"@stdlib/assert-is-same-array","@stdlib/assert/is-same-array-like":"@stdlib/assert-is-same-array-like","@stdlib/assert/is-same-complex64":"@stdlib/assert-is-same-complex64","@stdlib/assert/is-same-complex64array":"@stdlib/assert-is-same-complex64array","@stdlib/assert/is-same-complex128":"@stdlib/assert-is-same-complex128","@stdlib/assert/is-same-complex128array":"@stdlib/assert-is-same-complex128array","@stdlib/assert/is-same-date-object":"@stdlib/assert-is-same-date-object","@stdlib/assert/is-same-float32array":"@stdlib/assert-is-same-float32array","@stdlib/assert/is-same-float64array":"@stdlib/assert-is-same-float64array","@stdlib/assert/is-same-native-class":"@stdlib/assert-is-same-native-class","@stdlib/assert/is-same-type":"@stdlib/assert-is-same-type","@stdlib/assert/is-same-value":"@stdlib/assert-is-same-value","@stdlib/assert/is-same-value-zero":"@stdlib/assert-is-same-value-zero","@stdlib/assert/is-semver":"@stdlib/assert-is-semver","@stdlib/assert/is-sharedarraybuffer":"@stdlib/assert-is-sharedarraybuffer","@stdlib/assert/is-skew-centrosymmetric-matrix":"@stdlib/assert-is-skew-centrosymmetric-matrix","@stdlib/assert/is-skew-persymmetric-matrix":"@stdlib/assert-is-skew-persymmetric-matrix","@stdlib/assert/is-skew-symmetric-matrix":"@stdlib/assert-is-skew-symmetric-matrix","@stdlib/assert/is-slice":"@stdlib/assert-is-slice","@stdlib/assert/is-snakecase":"@stdlib/assert-is-snakecase","@stdlib/assert/is-square-matrix":"@stdlib/assert-is-square-matrix","@stdlib/assert/is-square-number":"@stdlib/assert-is-square-number","@stdlib/assert/is-square-triangular-number":"@stdlib/assert-is-square-triangular-number","@stdlib/assert/is-startcase":"@stdlib/assert-is-startcase","@stdlib/assert/is-strict-equal":"@stdlib/assert-is-strict-equal","@stdlib/assert/is-string":"@stdlib/assert-is-string","@stdlib/assert/is-string-array":"@stdlib/assert-is-string-array","@stdlib/assert/is-symbol":"@stdlib/assert-is-symbol","@stdlib/assert/is-symbol-array":"@stdlib/assert-is-symbol-array","@stdlib/assert/is-symmetric-matrix":"@stdlib/assert-is-symmetric-matrix","@stdlib/assert/is-syntax-error":"@stdlib/assert-is-syntax-error","@stdlib/assert/is-triangular-number":"@stdlib/assert-is-triangular-number","@stdlib/assert/is-truthy":"@stdlib/assert-is-truthy","@stdlib/assert/is-truthy-array":"@stdlib/assert-is-truthy-array","@stdlib/assert/is-typed-array":"@stdlib/assert-is-typed-array","@stdlib/assert/is-typed-array-length":"@stdlib/assert-is-typed-array-length","@stdlib/assert/is-typed-array-like":"@stdlib/assert-is-typed-array-like","@stdlib/assert/is-type-error":"@stdlib/assert-is-type-error","@stdlib/assert/is-uint8array":"@stdlib/assert-is-uint8array","@stdlib/assert/is-uint8clampedarray":"@stdlib/assert-is-uint8clampedarray","@stdlib/assert/is-uint16array":"@stdlib/assert-is-uint16array","@stdlib/assert/is-uint32array":"@stdlib/assert-is-uint32array","@stdlib/assert/is-unc-path":"@stdlib/assert-is-unc-path","@stdlib/assert/is-undefined":"@stdlib/assert-is-undefined","@stdlib/assert/is-undefined-or-null":"@stdlib/assert-is-undefined-or-null","@stdlib/assert/is-unity-probability-array":"@stdlib/assert-is-unity-probability-array","@stdlib/assert/is-uppercase":"@stdlib/assert-is-uppercase","@stdlib/assert/is-uri":"@stdlib/assert-is-uri","@stdlib/assert/is-uri-error":"@stdlib/assert-is-uri-error","@stdlib/assert/is-vector-like":"@stdlib/assert-is-vector-like","@stdlib/assert/is-wasm-memory":"@stdlib/assert-is-wasm-memory","@stdlib/assert/is-well-formed-string":"@stdlib/assert-is-well-formed-string","@stdlib/assert/is-whitespace":"@stdlib/assert-is-whitespace","@stdlib/assert/is-writable-property":"@stdlib/assert-is-writable-property","@stdlib/assert/is-writable-property-in":"@stdlib/assert-is-writable-property-in","@stdlib/assert/is-write-only-property":"@stdlib/assert-is-write-only-property","@stdlib/assert/is-write-only-property-in":"@stdlib/assert-is-write-only-property-in","@stdlib/math/iter/special/abs":"@stdlib/math-iter-special-abs","@stdlib/math/iter/special/abs2":"@stdlib/math-iter-special-abs2","@stdlib/math/iter/special/acos":"@stdlib/math-iter-special-acos","@stdlib/math/iter/special/acosh":"@stdlib/math-iter-special-acosh","@stdlib/math/iter/special/acot":"@stdlib/math-iter-special-acot","@stdlib/math/iter/special/acoth":"@stdlib/math-iter-special-acoth","@stdlib/math/iter/special/acovercos":"@stdlib/math-iter-special-acovercos","@stdlib/math/iter/special/acoversin":"@stdlib/math-iter-special-acoversin","@stdlib/math/iter/ops/add":"@stdlib/math-iter-ops-add","@stdlib/iter/advance":"@stdlib/iter-advance","@stdlib/math/iter/special/ahavercos":"@stdlib/math-iter-special-ahavercos","@stdlib/math/iter/special/ahaversin":"@stdlib/math-iter-special-ahaversin","@stdlib/iter/any":"@stdlib/iter-any","@stdlib/iter/any-by":"@stdlib/iter-any-by","@stdlib/math/iter/special/asin":"@stdlib/math-iter-special-asin","@stdlib/math/iter/special/asinh":"@stdlib/math-iter-special-asinh","@stdlib/math/iter/special/atan":"@stdlib/math-iter-special-atan","@stdlib/math/iter/special/atan2":"@stdlib/math-iter-special-atan2","@stdlib/math/iter/special/atanh":"@stdlib/math-iter-special-atanh","@stdlib/array/from-iterator":"@stdlib/array-from-iterator","@stdlib/iter/to-array-view":"@stdlib/iter-to-array-view","@stdlib/iter/to-array-view-right":"@stdlib/iter-to-array-view-right","@stdlib/streams/node/from-iterator":"@stdlib/streams-node-from-iterator","@stdlib/symbol/iterator":"@stdlib/symbol-iterator","@stdlib/math/iter/special/avercos":"@stdlib/math-iter-special-avercos","@stdlib/math/iter/special/aversin":"@stdlib/math-iter-special-aversin","@stdlib/simulate/iter/awgn":"@stdlib/simulate-iter-awgn","@stdlib/simulate/iter/awln":"@stdlib/simulate-iter-awln","@stdlib/simulate/iter/awun":"@stdlib/simulate-iter-awun","@stdlib/simulate/iter/bartlett-hann-pulse":"@stdlib/simulate-iter-bartlett-hann-pulse","@stdlib/simulate/iter/bartlett-pulse":"@stdlib/simulate-iter-bartlett-pulse","@stdlib/math/iter/special/besselj0":"@stdlib/math-iter-special-besselj0","@stdlib/math/iter/special/besselj1":"@stdlib/math-iter-special-besselj1","@stdlib/math/iter/special/bessely0":"@stdlib/math-iter-special-bessely0","@stdlib/math/iter/special/bessely1":"@stdlib/math-iter-special-bessely1","@stdlib/math/iter/special/beta":"@stdlib/math-iter-special-beta","@stdlib/math/iter/special/betaln":"@stdlib/math-iter-special-betaln","@stdlib/math/iter/special/binet":"@stdlib/math-iter-special-binet","@stdlib/math/iter/special/cbrt":"@stdlib/math-iter-special-cbrt","@stdlib/math/iter/special/ceil":"@stdlib/math-iter-special-ceil","@stdlib/math/iter/special/ceil2":"@stdlib/math-iter-special-ceil2","@stdlib/math/iter/special/ceil10":"@stdlib/math-iter-special-ceil10","@stdlib/math/iter/sequences/composites":"@stdlib/math-iter-sequences-composites","@stdlib/iter/concat":"@stdlib/iter-concat","@stdlib/iter/constant":"@stdlib/iter-constant","@stdlib/math/iter/utils/continued-fraction":"@stdlib/math-iter-utils-continued-fraction","@stdlib/math/iter/sequences/continued-fraction":"@stdlib/math-iter-sequences-continued-fraction","@stdlib/math/iter/special/cos":"@stdlib/math-iter-special-cos","@stdlib/math/iter/special/cosh":"@stdlib/math-iter-special-cosh","@stdlib/simulate/iter/cosine-wave":"@stdlib/simulate-iter-cosine-wave","@stdlib/math/iter/special/cosm1":"@stdlib/math-iter-special-cosm1","@stdlib/math/iter/special/cospi":"@stdlib/math-iter-special-cospi","@stdlib/iter/counter":"@stdlib/iter-counter","@stdlib/math/iter/special/covercos":"@stdlib/math-iter-special-covercos","@stdlib/math/iter/special/coversin":"@stdlib/math-iter-special-coversin","@stdlib/math/iter/sequences/cubes":"@stdlib/math-iter-sequences-cubes","@stdlib/stats/iter/cugmean":"@stdlib/stats-iter-cugmean","@stdlib/stats/iter/cuhmean":"@stdlib/stats-iter-cuhmean","@stdlib/stats/iter/cumax":"@stdlib/stats-iter-cumax","@stdlib/stats/iter/cumaxabs":"@stdlib/stats-iter-cumaxabs","@stdlib/stats/iter/cumean":"@stdlib/stats-iter-cumean","@stdlib/stats/iter/cumeanabs":"@stdlib/stats-iter-cumeanabs","@stdlib/stats/iter/cumeanabs2":"@stdlib/stats-iter-cumeanabs2","@stdlib/stats/iter/cumidrange":"@stdlib/stats-iter-cumidrange","@stdlib/stats/iter/cumin":"@stdlib/stats-iter-cumin","@stdlib/stats/iter/cuminabs":"@stdlib/stats-iter-cuminabs","@stdlib/stats/iter/cuprod":"@stdlib/stats-iter-cuprod","@stdlib/stats/iter/curange":"@stdlib/stats-iter-curange","@stdlib/stats/iter/cusum":"@stdlib/stats-iter-cusum","@stdlib/stats/iter/cusumabs":"@stdlib/stats-iter-cusumabs","@stdlib/stats/iter/cusumabs2":"@stdlib/stats-iter-cusumabs2","@stdlib/iter/datespace":"@stdlib/iter-datespace","@stdlib/iter/dedupe":"@stdlib/iter-dedupe","@stdlib/iter/dedupe-by":"@stdlib/iter-dedupe-by","@stdlib/math/iter/special/deg2rad":"@stdlib/math-iter-special-deg2rad","@stdlib/math/iter/special/digamma":"@stdlib/math-iter-special-digamma","@stdlib/simulate/iter/dirac-comb":"@stdlib/simulate-iter-dirac-comb","@stdlib/math/iter/special/dirac-delta":"@stdlib/math-iter-special-dirac-delta","@stdlib/math/iter/ops/divide":"@stdlib/math-iter-ops-divide","@stdlib/iter/do-until-each":"@stdlib/iter-do-until-each","@stdlib/iter/do-while-each":"@stdlib/iter-do-while-each","@stdlib/math/iter/special/ellipe":"@stdlib/math-iter-special-ellipe","@stdlib/math/iter/special/ellipk":"@stdlib/math-iter-special-ellipk","@stdlib/iter/empty":"@stdlib/iter-empty","@stdlib/math/iter/special/erf":"@stdlib/math-iter-special-erf","@stdlib/math/iter/special/erfc":"@stdlib/math-iter-special-erfc","@stdlib/math/iter/special/erfcinv":"@stdlib/math-iter-special-erfcinv","@stdlib/math/iter/special/erfinv":"@stdlib/math-iter-special-erfinv","@stdlib/math/iter/special/dirichlet-eta":"@stdlib/math-iter-special-dirichlet-eta","@stdlib/math/iter/sequences/even-integers":"@stdlib/math-iter-sequences-even-integers","@stdlib/iter/every":"@stdlib/iter-every","@stdlib/iter/every-by":"@stdlib/iter-every-by","@stdlib/math/iter/special/exp":"@stdlib/math-iter-special-exp","@stdlib/math/iter/special/exp2":"@stdlib/math-iter-special-exp2","@stdlib/math/iter/special/exp10":"@stdlib/math-iter-special-exp10","@stdlib/math/iter/special/expit":"@stdlib/math-iter-special-expit","@stdlib/math/iter/special/expm1":"@stdlib/math-iter-special-expm1","@stdlib/math/iter/special/expm1rel":"@stdlib/math-iter-special-expm1rel","@stdlib/math/iter/special/factorial":"@stdlib/math-iter-special-factorial","@stdlib/math/iter/special/factorialln":"@stdlib/math-iter-special-factorialln","@stdlib/math/iter/sequences/factorials":"@stdlib/math-iter-sequences-factorials","@stdlib/math/iter/sequences/fibonacci":"@stdlib/math-iter-sequences-fibonacci","@stdlib/math/iter/sequences/fifth-powers":"@stdlib/math-iter-sequences-fifth-powers","@stdlib/iter/fill":"@stdlib/iter-fill","@stdlib/iter/filter":"@stdlib/iter-filter","@stdlib/iter/filter-map":"@stdlib/iter-filter-map","@stdlib/iter/first":"@stdlib/iter-first","@stdlib/simulate/iter/flat-top-pulse":"@stdlib/simulate-iter-flat-top-pulse","@stdlib/math/iter/special/floor":"@stdlib/math-iter-special-floor","@stdlib/math/iter/special/floor2":"@stdlib/math-iter-special-floor2","@stdlib/math/iter/special/floor10":"@stdlib/math-iter-special-floor10","@stdlib/iter/flow":"@stdlib/iter-flow","@stdlib/iter/for-each":"@stdlib/iter-for-each","@stdlib/math/iter/sequences/fourth-powers":"@stdlib/math-iter-sequences-fourth-powers","@stdlib/math/iter/special/fresnelc":"@stdlib/math-iter-special-fresnelc","@stdlib/math/iter/special/fresnels":"@stdlib/math-iter-special-fresnels","@stdlib/math/iter/special/gamma":"@stdlib/math-iter-special-gamma","@stdlib/math/iter/special/gamma1pm1":"@stdlib/math-iter-special-gamma1pm1","@stdlib/math/iter/special/gammaln":"@stdlib/math-iter-special-gammaln","@stdlib/math/iter/special/hacovercos":"@stdlib/math-iter-special-hacovercos","@stdlib/math/iter/special/hacoversin":"@stdlib/math-iter-special-hacoversin","@stdlib/simulate/iter/hann-pulse":"@stdlib/simulate-iter-hann-pulse","@stdlib/math/iter/special/havercos":"@stdlib/math-iter-special-havercos","@stdlib/math/iter/special/haversin":"@stdlib/math-iter-special-haversin","@stdlib/iter/head":"@stdlib/iter-head","@stdlib/iter/incrspace":"@stdlib/iter-incrspace","@stdlib/math/iter/sequences/integers":"@stdlib/math-iter-sequences-integers","@stdlib/iter/intersection":"@stdlib/iter-intersection","@stdlib/iter/intersection-by-hash":"@stdlib/iter-intersection-by-hash","@stdlib/math/iter/special/inv":"@stdlib/math-iter-special-inv","@stdlib/simulate/iter/lanczos-pulse":"@stdlib/simulate-iter-lanczos-pulse","@stdlib/iter/last":"@stdlib/iter-last","@stdlib/iter/length":"@stdlib/iter-length","@stdlib/iter/linspace":"@stdlib/iter-linspace","@stdlib/math/iter/special/ln":"@stdlib/math-iter-special-ln","@stdlib/math/iter/special/log":"@stdlib/math-iter-special-log","@stdlib/math/iter/special/log1mexp":"@stdlib/math-iter-special-log1mexp","@stdlib/math/iter/special/log1p":"@stdlib/math-iter-special-log1p","@stdlib/math/iter/special/log1pexp":"@stdlib/math-iter-special-log1pexp","@stdlib/math/iter/special/log2":"@stdlib/math-iter-special-log2","@stdlib/math/iter/special/log10":"@stdlib/math-iter-special-log10","@stdlib/math/iter/special/logit":"@stdlib/math-iter-special-logit","@stdlib/iter/logspace":"@stdlib/iter-logspace","@stdlib/math/iter/sequences/lucas":"@stdlib/math-iter-sequences-lucas","@stdlib/iter/map":"@stdlib/iter-map","@stdlib/iter/mapn":"@stdlib/iter-mapn","@stdlib/stats/iter/max":"@stdlib/stats-iter-max","@stdlib/stats/iter/maxabs":"@stdlib/stats-iter-maxabs","@stdlib/stats/iter/mean":"@stdlib/stats-iter-mean","@stdlib/stats/iter/meanabs":"@stdlib/stats-iter-meanabs","@stdlib/stats/iter/meanabs2":"@stdlib/stats-iter-meanabs2","@stdlib/stats/iter/midrange":"@stdlib/stats-iter-midrange","@stdlib/stats/iter/min":"@stdlib/stats-iter-min","@stdlib/stats/iter/minabs":"@stdlib/stats-iter-minabs","@stdlib/stats/iter/mmax":"@stdlib/stats-iter-mmax","@stdlib/stats/iter/mmaxabs":"@stdlib/stats-iter-mmaxabs","@stdlib/stats/iter/mmean":"@stdlib/stats-iter-mmean","@stdlib/stats/iter/mmeanabs":"@stdlib/stats-iter-mmeanabs","@stdlib/stats/iter/mmeanabs2":"@stdlib/stats-iter-mmeanabs2","@stdlib/stats/iter/mmidrange":"@stdlib/stats-iter-mmidrange","@stdlib/stats/iter/mmin":"@stdlib/stats-iter-mmin","@stdlib/stats/iter/mminabs":"@stdlib/stats-iter-mminabs","@stdlib/math/iter/ops/mod":"@stdlib/math-iter-ops-mod","@stdlib/stats/iter/mprod":"@stdlib/stats-iter-mprod","@stdlib/stats/iter/mrange":"@stdlib/stats-iter-mrange","@stdlib/stats/iter/msum":"@stdlib/stats-iter-msum","@stdlib/stats/iter/msumabs":"@stdlib/stats-iter-msumabs","@stdlib/stats/iter/msumabs2":"@stdlib/stats-iter-msumabs2","@stdlib/math/iter/ops/multiply":"@stdlib/math-iter-ops-multiply","@stdlib/math/iter/sequences/negafibonacci":"@stdlib/math-iter-sequences-negafibonacci","@stdlib/math/iter/sequences/negalucas":"@stdlib/math-iter-sequences-negalucas","@stdlib/math/iter/sequences/negative-even-integers":"@stdlib/math-iter-sequences-negative-even-integers","@stdlib/math/iter/sequences/negative-integers":"@stdlib/math-iter-sequences-negative-integers","@stdlib/math/iter/sequences/negative-odd-integers":"@stdlib/math-iter-sequences-negative-odd-integers","@stdlib/iter/none":"@stdlib/iter-none","@stdlib/iter/none-by":"@stdlib/iter-none-by","@stdlib/math/iter/sequences/nonfibonacci":"@stdlib/math-iter-sequences-nonfibonacci","@stdlib/math/iter/sequences/nonnegative-even-integers":"@stdlib/math-iter-sequences-nonnegative-even-integers","@stdlib/math/iter/sequences/nonnegative-integers":"@stdlib/math-iter-sequences-nonnegative-integers","@stdlib/math/iter/sequences/nonpositive-even-integers":"@stdlib/math-iter-sequences-nonpositive-even-integers","@stdlib/math/iter/sequences/nonpositive-integers":"@stdlib/math-iter-sequences-nonpositive-integers","@stdlib/math/iter/sequences/nonsquares":"@stdlib/math-iter-sequences-nonsquares","@stdlib/iter/nth":"@stdlib/iter-nth","@stdlib/math/iter/sequences/odd-integers":"@stdlib/math-iter-sequences-odd-integers","@stdlib/simulate/iter/periodic-sinc":"@stdlib/simulate-iter-periodic-sinc","@stdlib/iter/pipeline":"@stdlib/iter-pipeline","@stdlib/iter/pop":"@stdlib/iter-pop","@stdlib/math/iter/sequences/positive-even-integers":"@stdlib/math-iter-sequences-positive-even-integers","@stdlib/math/iter/sequences/positive-integers":"@stdlib/math-iter-sequences-positive-integers","@stdlib/math/iter/sequences/positive-odd-integers":"@stdlib/math-iter-sequences-positive-odd-integers","@stdlib/math/iter/special/pow":"@stdlib/math-iter-special-pow","@stdlib/math/iter/sequences/primes":"@stdlib/math-iter-sequences-primes","@stdlib/stats/iter/prod":"@stdlib/stats-iter-prod","@stdlib/simulate/iter/pulse":"@stdlib/simulate-iter-pulse","@stdlib/iter/push":"@stdlib/iter-push","@stdlib/math/iter/special/rad2deg":"@stdlib/math-iter-special-rad2deg","@stdlib/math/iter/special/ramp":"@stdlib/math-iter-special-ramp","@stdlib/stats/iter/range":"@stdlib/stats-iter-range","@stdlib/iter/reject":"@stdlib/iter-reject","@stdlib/iter/replicate":"@stdlib/iter-replicate","@stdlib/iter/replicate-by":"@stdlib/iter-replicate-by","@stdlib/math/iter/special/round":"@stdlib/math-iter-special-round","@stdlib/math/iter/special/round2":"@stdlib/math-iter-special-round2","@stdlib/math/iter/special/round10":"@stdlib/math-iter-special-round10","@stdlib/math/iter/special/rsqrt":"@stdlib/math-iter-special-rsqrt","@stdlib/simulate/iter/sawtooth-wave":"@stdlib/simulate-iter-sawtooth-wave","@stdlib/iter/shift":"@stdlib/iter-shift","@stdlib/math/iter/special/signum":"@stdlib/math-iter-special-signum","@stdlib/math/iter/special/sin":"@stdlib/math-iter-special-sin","@stdlib/math/iter/special/sinc":"@stdlib/math-iter-special-sinc","@stdlib/simulate/iter/sine-wave":"@stdlib/simulate-iter-sine-wave","@stdlib/math/iter/special/sinh":"@stdlib/math-iter-special-sinh","@stdlib/math/iter/special/sinpi":"@stdlib/math-iter-special-sinpi","@stdlib/iter/slice":"@stdlib/iter-slice","@stdlib/iter/some":"@stdlib/iter-some","@stdlib/iter/some-by":"@stdlib/iter-some-by","@stdlib/math/iter/special/spence":"@stdlib/math-iter-special-spence","@stdlib/math/iter/special/sqrt":"@stdlib/math-iter-special-sqrt","@stdlib/math/iter/special/sqrt1pm1":"@stdlib/math-iter-special-sqrt1pm1","@stdlib/math/iter/sequences/squared-triangular":"@stdlib/math-iter-sequences-squared-triangular","@stdlib/math/iter/sequences/squares":"@stdlib/math-iter-sequences-squares","@stdlib/simulate/iter/square-wave":"@stdlib/simulate-iter-square-wave","@stdlib/stats/iter/stdev":"@stdlib/stats-iter-stdev","@stdlib/iter/step":"@stdlib/iter-step","@stdlib/iter/strided":"@stdlib/iter-strided","@stdlib/iter/strided-by":"@stdlib/iter-strided-by","@stdlib/math/iter/ops/subtract":"@stdlib/math-iter-ops-subtract","@stdlib/stats/iter/sum":"@stdlib/stats-iter-sum","@stdlib/stats/iter/sumabs":"@stdlib/stats-iter-sumabs","@stdlib/stats/iter/sumabs2":"@stdlib/stats-iter-sumabs2","@stdlib/math/iter/special/tan":"@stdlib/math-iter-special-tan","@stdlib/math/iter/special/tanh":"@stdlib/math-iter-special-tanh","@stdlib/iter/pipeline-thunk":"@stdlib/iter-pipeline-thunk","@stdlib/simulate/iter/triangle-wave":"@stdlib/simulate-iter-triangle-wave","@stdlib/math/iter/sequences/triangular":"@stdlib/math-iter-sequences-triangular","@stdlib/math/iter/sequences/tribonacci":"@stdlib/math-iter-sequences-tribonacci","@stdlib/math/iter/special/trigamma":"@stdlib/math-iter-special-trigamma","@stdlib/math/iter/special/trunc":"@stdlib/math-iter-special-trunc","@stdlib/math/iter/special/trunc2":"@stdlib/math-iter-special-trunc2","@stdlib/math/iter/special/trunc10":"@stdlib/math-iter-special-trunc10","@stdlib/iter/union":"@stdlib/iter-union","@stdlib/iter/unique":"@stdlib/iter-unique","@stdlib/iter/unique-by":"@stdlib/iter-unique-by","@stdlib/iter/unique-by-hash":"@stdlib/iter-unique-by-hash","@stdlib/iter/unitspace":"@stdlib/iter-unitspace","@stdlib/iter/unshift":"@stdlib/iter-unshift","@stdlib/iter/until-each":"@stdlib/iter-until-each","@stdlib/stats/iter/variance":"@stdlib/stats-iter-variance","@stdlib/math/iter/special/vercos":"@stdlib/math-iter-special-vercos","@stdlib/math/iter/special/versin":"@stdlib/math-iter-special-versin","@stdlib/iter/while-each":"@stdlib/iter-while-each","@stdlib/math/iter/special/riemann-zeta":"@stdlib/math-iter-special-riemann-zeta","@stdlib/streams/node/join":"@stdlib/streams-node-join","@stdlib/stats/kde2d":"@stdlib/stats-kde2d","@stdlib/string/kebabcase":"@stdlib/string-kebabcase","@stdlib/utils/key-by":"@stdlib/utils-key-by","@stdlib/utils/key-by-right":"@stdlib/utils-key-by-right","@stdlib/utils/keys-in":"@stdlib/utils-keys-in","@stdlib/stats/kruskal-test":"@stdlib/stats-kruskal-test","@stdlib/stats/kstest":"@stdlib/stats-kstest","@stdlib/string/last":"@stdlib/string-last","@stdlib/nlp/lda":"@stdlib/nlp-lda","@stdlib/stats/levene-test":"@stdlib/stats-levene-test","@stdlib/dstructs/linked-list":"@stdlib/dstructs-linked-list","@stdlib/array/linspace":"@stdlib/array-linspace","@stdlib/datasets/liu-negative-opinion-words-en":"@stdlib/datasets-liu-negative-opinion-words-en","@stdlib/datasets/liu-positive-opinion-words-en":"@stdlib/datasets-liu-positive-opinion-words-en","@stdlib/constants/float64/ln-half":"@stdlib/constants-float64-ln-half","@stdlib/constants/float64/ln-pi":"@stdlib/constants-float64-ln-pi","@stdlib/constants/float64/ln-sqrt-two-pi":"@stdlib/constants-float64-ln-sqrt-two-pi","@stdlib/constants/float64/ln-two-pi":"@stdlib/constants-float64-ln-two-pi","@stdlib/constants/float64/ln-two":"@stdlib/constants-float64-ln-two","@stdlib/constants/float64/ln-ten":"@stdlib/constants-float64-ln-ten","@stdlib/constants/float64/log2-e":"@stdlib/constants-float64-log2-e","@stdlib/constants/float64/log10-e":"@stdlib/constants-float64-log10-e","@stdlib/array/logspace":"@stdlib/array-logspace","@stdlib/string/lowercase":"@stdlib/string-lowercase","@stdlib/utils/lowercase-keys":"@stdlib/utils-lowercase-keys","@stdlib/stats/lowess":"@stdlib/stats-lowess","@stdlib/string/left-pad":"@stdlib/string-left-pad","@stdlib/string/left-trim":"@stdlib/string-left-trim","@stdlib/string/left-trim-n":"@stdlib/string-left-trim-n","@stdlib/datasets/male-first-names-en":"@stdlib/datasets-male-first-names-en","@stdlib/utils/map":"@stdlib/utils-map","@stdlib/utils/map2":"@stdlib/utils-map2","@stdlib/utils/map2d":"@stdlib/utils-map2d","@stdlib/utils/map2-right":"@stdlib/utils-map2-right","@stdlib/utils/map3d":"@stdlib/utils-map3d","@stdlib/utils/map4d":"@stdlib/utils-map4d","@stdlib/utils/map5d":"@stdlib/utils-map5d","@stdlib/utils/map-arguments":"@stdlib/utils-map-arguments","@stdlib/utils/map-function":"@stdlib/utils-map-function","@stdlib/utils/async/map-function":"@stdlib/utils-async-map-function","@stdlib/utils/map-keys":"@stdlib/utils-map-keys","@stdlib/utils/async/map-keys":"@stdlib/utils-async-map-keys","@stdlib/utils/map-reduce":"@stdlib/utils-map-reduce","@stdlib/utils/map-reduce-right":"@stdlib/utils-map-reduce-right","@stdlib/utils/map-right":"@stdlib/utils-map-right","@stdlib/utils/map-values":"@stdlib/utils-map-values","@stdlib/utils/async/map-values":"@stdlib/utils-async-map-values","@stdlib/utils/mask-arguments":"@stdlib/utils-mask-arguments","@stdlib/constants/array/max-array-length":"@stdlib/constants-array-max-array-length","@stdlib/constants/array/max-typed-array-length":"@stdlib/constants-array-max-typed-array-length","@stdlib/ndarray/maybe-broadcast-array":"@stdlib/ndarray-maybe-broadcast-array","@stdlib/ndarray/maybe-broadcast-arrays":"@stdlib/ndarray-maybe-broadcast-arrays","@stdlib/utils/memoize":"@stdlib/utils-memoize","@stdlib/utils/merge":"@stdlib/utils-merge","@stdlib/constants/time/milliseconds-in-day":"@stdlib/constants-time-milliseconds-in-day","@stdlib/constants/time/milliseconds-in-hour":"@stdlib/constants-time-milliseconds-in-hour","@stdlib/constants/time/milliseconds-in-minute":"@stdlib/constants-time-milliseconds-in-minute","@stdlib/constants/time/milliseconds-in-second":"@stdlib/constants-time-milliseconds-in-second","@stdlib/constants/time/milliseconds-in-week":"@stdlib/constants-time-milliseconds-in-week","@stdlib/datasets/minard-napoleons-march":"@stdlib/datasets-minard-napoleons-march","@stdlib/constants/time/minutes-in-day":"@stdlib/constants-time-minutes-in-day","@stdlib/constants/time/minutes-in-hour":"@stdlib/constants-time-minutes-in-hour","@stdlib/constants/time/minutes-in-week":"@stdlib/constants-time-minutes-in-week","@stdlib/time/minutes-in-month":"@stdlib/time-minutes-in-month","@stdlib/time/minutes-in-year":"@stdlib/time-minutes-in-year","@stdlib/datasets/moby-dick":"@stdlib/datasets-moby-dick","@stdlib/datasets/month-names-en":"@stdlib/datasets-month-names-en","@stdlib/constants/time/months-in-year":"@stdlib/constants-time-months-in-year","@stdlib/utils/move-property":"@stdlib/utils-move-property","@stdlib/slice/multi":"@stdlib/slice-multi","@stdlib/dstructs/named-typed-tuple":"@stdlib/dstructs-named-typed-tuple","@stdlib/constants/float64/nan":"@stdlib/constants-float64-nan","@stdlib/utils/nary-function":"@stdlib/utils-nary-function","@stdlib/utils/native-class":"@stdlib/utils-native-class","@stdlib/ndarray/ctor":"@stdlib/ndarray-ctor","@stdlib/ndarray/to-array":"@stdlib/ndarray-to-array","@stdlib/ndarray/to-fancy":"@stdlib/ndarray-to-fancy","@stdlib/ndarray/to-json":"@stdlib/ndarray-to-json","@stdlib/ndarray/casting-modes":"@stdlib/ndarray-casting-modes","@stdlib/ndarray/data-buffer":"@stdlib/ndarray-data-buffer","@stdlib/ndarray/dtype":"@stdlib/ndarray-dtype","@stdlib/ndarray/dtypes":"@stdlib/ndarray-dtypes","@stdlib/ndarray/dispatch":"@stdlib/ndarray-dispatch","@stdlib/ndarray/flag":"@stdlib/ndarray-flag","@stdlib/ndarray/flags":"@stdlib/ndarray-flags","@stdlib/ndarray/index-modes":"@stdlib/ndarray-index-modes","@stdlib/ndarray/ndarraylike2ndarray":"@stdlib/ndarray-ndarraylike2ndarray","@stdlib/ndarray/min-dtype":"@stdlib/ndarray-min-dtype","@stdlib/ndarray/mostly-safe-casts":"@stdlib/ndarray-mostly-safe-casts","@stdlib/ndarray/next-dtype":"@stdlib/ndarray-next-dtype","@stdlib/ndarray/offset":"@stdlib/ndarray-offset","@stdlib/ndarray/order":"@stdlib/ndarray-order","@stdlib/ndarray/orders":"@stdlib/ndarray-orders","@stdlib/ndarray/promotion-rules":"@stdlib/ndarray-promotion-rules","@stdlib/ndarray/safe-casts":"@stdlib/ndarray-safe-casts","@stdlib/ndarray/same-kind-casts":"@stdlib/ndarray-same-kind-casts","@stdlib/ndarray/shape":"@stdlib/ndarray-shape","@stdlib/ndarray/stride":"@stdlib/ndarray-stride","@stdlib/ndarray/strides":"@stdlib/ndarray-strides","@stdlib/ndarray/at":"@stdlib/ndarray-at","@stdlib/ndarray/empty":"@stdlib/ndarray-empty","@stdlib/ndarray/empty-like":"@stdlib/ndarray-empty-like","@stdlib/ndarray/filter":"@stdlib/ndarray-filter","@stdlib/ndarray/filter-map":"@stdlib/ndarray-filter-map","@stdlib/ndarray/for-each":"@stdlib/ndarray-for-each","@stdlib/ndarray/ndims":"@stdlib/ndarray-ndims","@stdlib/ndarray/index":"@stdlib/ndarray-index","@stdlib/ndarray/iter/to-array-each":"@stdlib/ndarray-iter-to-array-each","@stdlib/ndarray/iter/column-entries":"@stdlib/ndarray-iter-column-entries","@stdlib/ndarray/iter/columns":"@stdlib/ndarray-iter-columns","@stdlib/ndarray/iter/entries":"@stdlib/ndarray-iter-entries","@stdlib/ndarray/iter/indices":"@stdlib/ndarray-iter-indices","@stdlib/ndarray/iter/interleave-subarrays":"@stdlib/ndarray-iter-interleave-subarrays","@stdlib/ndarray/iter/matrices":"@stdlib/ndarray-iter-matrices","@stdlib/ndarray/iter/matrix-entries":"@stdlib/ndarray-iter-matrix-entries","@stdlib/ndarray/iter/row-entries":"@stdlib/ndarray-iter-row-entries","@stdlib/ndarray/iter/rows":"@stdlib/ndarray-iter-rows","@stdlib/ndarray/iter/select-dimension":"@stdlib/ndarray-iter-select-dimension","@stdlib/ndarray/iter/stacks":"@stdlib/ndarray-iter-stacks","@stdlib/ndarray/iter/subarrays":"@stdlib/ndarray-iter-subarrays","@stdlib/ndarray/iter/values":"@stdlib/ndarray-iter-values","@stdlib/ndarray/map":"@stdlib/ndarray-map","@stdlib/ndarray/reject":"@stdlib/ndarray-reject","@stdlib/ndarray/slice":"@stdlib/ndarray-slice","@stdlib/ndarray/slice-assign":"@stdlib/ndarray-slice-assign","@stdlib/ndarray/slice-dimension":"@stdlib/ndarray-slice-dimension","@stdlib/ndarray/slice-dimension-from":"@stdlib/ndarray-slice-dimension-from","@stdlib/ndarray/slice-dimension-to":"@stdlib/ndarray-slice-dimension-to","@stdlib/ndarray/slice-from":"@stdlib/ndarray-slice-from","@stdlib/ndarray/slice-to":"@stdlib/ndarray-slice-to","@stdlib/ndarray/zeros":"@stdlib/ndarray-zeros","@stdlib/ndarray/zeros-like":"@stdlib/ndarray-zeros-like","@stdlib/string/next-grapheme-cluster-break":"@stdlib/string-next-grapheme-cluster-break","@stdlib/utils/next-tick":"@stdlib/utils-next-tick","@stdlib/datasets/nightingales-rose":"@stdlib/datasets-nightingales-rose","@stdlib/constants/float64/ninf":"@stdlib/constants-float64-ninf","@stdlib/process/node-version":"@stdlib/process-node-version","@stdlib/utils/none":"@stdlib/utils-none","@stdlib/utils/none-by":"@stdlib/utils-none-by","@stdlib/utils/async/none-by":"@stdlib/utils-async-none-by","@stdlib/utils/none-by-right":"@stdlib/utils-none-by-right","@stdlib/utils/async/none-by-right":"@stdlib/utils-async-none-by-right","@stdlib/utils/none-in-by":"@stdlib/utils-none-in-by","@stdlib/utils/nonenumerable-properties":"@stdlib/utils-nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in":"@stdlib/utils-nonenumerable-properties-in","@stdlib/utils/nonenumerable-property-names":"@stdlib/utils-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in":"@stdlib/utils-nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols":"@stdlib/utils-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in":"@stdlib/utils-nonenumerable-property-symbols-in","@stdlib/utils/none-own-by":"@stdlib/utils-none-own-by","@stdlib/utils/nonindex-keys":"@stdlib/utils-nonindex-keys","@stdlib/utils/noop":"@stdlib/utils-noop","@stdlib/time/now":"@stdlib/time-now","@stdlib/os/num-cpus":"@stdlib/os-num-cpus","@stdlib/string/num2words":"@stdlib/string-num2words","@stdlib/number/ctor":"@stdlib/number-ctor","@stdlib/ndarray/numel":"@stdlib/ndarray-numel","@stdlib/ndarray/numel-dimension":"@stdlib/ndarray-numel-dimension","@stdlib/string/num-grapheme-clusters":"@stdlib/string-num-grapheme-clusters","@stdlib/object/ctor":"@stdlib/object-ctor","@stdlib/utils/entries":"@stdlib/utils-entries","@stdlib/utils/entries-in":"@stdlib/utils-entries-in","@stdlib/utils/from-entries":"@stdlib/utils-from-entries","@stdlib/utils/object-inverse":"@stdlib/utils-object-inverse","@stdlib/utils/object-inverse-by":"@stdlib/utils-object-inverse-by","@stdlib/utils/keys":"@stdlib/utils-keys","@stdlib/utils/values":"@stdlib/utils-values","@stdlib/utils/values-in":"@stdlib/utils-values-in","@stdlib/utils/omit":"@stdlib/utils-omit","@stdlib/utils/omit-by":"@stdlib/utils-omit-by","@stdlib/fs/open":"@stdlib/fs-open","@stdlib/utils/open-url":"@stdlib/utils-open-url","@stdlib/nlp/ordinalize":"@stdlib/nlp-ordinalize","@stdlib/datasets/pace-boston-house-prices":"@stdlib/datasets-pace-boston-house-prices","@stdlib/string/pad":"@stdlib/string-pad","@stdlib/stats/padjust":"@stdlib/stats-padjust","@stdlib/utils/papply":"@stdlib/utils-papply","@stdlib/utils/papply-right":"@stdlib/utils-papply-right","@stdlib/utils/parallel":"@stdlib/utils-parallel","@stdlib/utils/parse-json":"@stdlib/utils-parse-json","@stdlib/string/pascalcase":"@stdlib/string-pascalcase","@stdlib/constants/path/delimiter":"@stdlib/constants-path-delimiter","@stdlib/constants/path/delimiter-posix":"@stdlib/constants-path-delimiter-posix","@stdlib/constants/path/delimiter-win32":"@stdlib/constants-path-delimiter-win32","@stdlib/constants/path/sep":"@stdlib/constants-path-sep","@stdlib/constants/path/sep-posix":"@stdlib/constants-path-sep-posix","@stdlib/constants/path/sep-win32":"@stdlib/constants-path-sep-win32","@stdlib/stats/pcorrtest":"@stdlib/stats-pcorrtest","@stdlib/string/percent-encode":"@stdlib/string-percent-encode","@stdlib/constants/float64/phi":"@stdlib/constants-float64-phi","@stdlib/constants/float64/pi":"@stdlib/constants-float64-pi","@stdlib/constants/float64/pi-squared":"@stdlib/constants-float64-pi-squared","@stdlib/utils/pick":"@stdlib/utils-pick","@stdlib/utils/pick-arguments":"@stdlib/utils-pick-arguments","@stdlib/utils/pick-by":"@stdlib/utils-pick-by","@stdlib/constants/float64/pinf":"@stdlib/constants-float64-pinf","@stdlib/namespace/pkg2alias":"@stdlib/namespace-pkg2alias","@stdlib/namespace/pkg2related":"@stdlib/namespace-pkg2related","@stdlib/namespace/pkg2standalone":"@stdlib/namespace-pkg2standalone","@stdlib/os/platform":"@stdlib/os-platform","@stdlib/plot":"@stdlib/plot","@stdlib/plot/ctor":"@stdlib/plot-ctor","@stdlib/utils/pluck":"@stdlib/utils-pluck","@stdlib/utils/pop":"@stdlib/utils-pop","@stdlib/nlp/porter-stemmer":"@stdlib/nlp-porter-stemmer","@stdlib/utils/prepend":"@stdlib/utils-prepend","@stdlib/string/prev-grapheme-cluster-break":"@stdlib/string-prev-grapheme-cluster-break","@stdlib/datasets/primes-100k":"@stdlib/datasets-primes-100k","@stdlib/utils/properties":"@stdlib/utils-properties","@stdlib/utils/properties-in":"@stdlib/utils-properties-in","@stdlib/utils/property-descriptor":"@stdlib/utils-property-descriptor","@stdlib/utils/property-descriptor-in":"@stdlib/utils-property-descriptor-in","@stdlib/utils/property-descriptors":"@stdlib/utils-property-descriptors","@stdlib/utils/property-descriptors-in":"@stdlib/utils-property-descriptors-in","@stdlib/utils/property-names":"@stdlib/utils-property-names","@stdlib/utils/property-names-in":"@stdlib/utils-property-names-in","@stdlib/utils/property-symbols":"@stdlib/utils-property-symbols","@stdlib/utils/property-symbols-in":"@stdlib/utils-property-symbols-in","@stdlib/proxy/ctor":"@stdlib/proxy-ctor","@stdlib/utils/push":"@stdlib/utils-push","@stdlib/time/quarter-of-year":"@stdlib/time-quarter-of-year","@stdlib/random/array/arcsine":"@stdlib/random-array-arcsine","@stdlib/random/array/bernoulli":"@stdlib/random-array-bernoulli","@stdlib/random/array/beta":"@stdlib/random-array-beta","@stdlib/random/array/betaprime":"@stdlib/random-array-betaprime","@stdlib/random/array/binomial":"@stdlib/random-array-binomial","@stdlib/random/array/cauchy":"@stdlib/random-array-cauchy","@stdlib/random/array/chi":"@stdlib/random-array-chi","@stdlib/random/array/chisquare":"@stdlib/random-array-chisquare","@stdlib/random/array/cosine":"@stdlib/random-array-cosine","@stdlib/random/array/discrete-uniform":"@stdlib/random-array-discrete-uniform","@stdlib/random/array/erlang":"@stdlib/random-array-erlang","@stdlib/random/array/exponential":"@stdlib/random-array-exponential","@stdlib/random/array/f":"@stdlib/random-array-f","@stdlib/random/array/frechet":"@stdlib/random-array-frechet","@stdlib/random/array/gamma":"@stdlib/random-array-gamma","@stdlib/random/array/geometric":"@stdlib/random-array-geometric","@stdlib/random/array/gumbel":"@stdlib/random-array-gumbel","@stdlib/random/array/hypergeometric":"@stdlib/random-array-hypergeometric","@stdlib/random/array/invgamma":"@stdlib/random-array-invgamma","@stdlib/random/array/kumaraswamy":"@stdlib/random-array-kumaraswamy","@stdlib/random/array/laplace":"@stdlib/random-array-laplace","@stdlib/random/array/levy":"@stdlib/random-array-levy","@stdlib/random/array/logistic":"@stdlib/random-array-logistic","@stdlib/random/array/lognormal":"@stdlib/random-array-lognormal","@stdlib/random/array/minstd":"@stdlib/random-array-minstd","@stdlib/random/array/minstd-shuffle":"@stdlib/random-array-minstd-shuffle","@stdlib/random/array/mt19937":"@stdlib/random-array-mt19937","@stdlib/random/array/negative-binomial":"@stdlib/random-array-negative-binomial","@stdlib/random/array/normal":"@stdlib/random-array-normal","@stdlib/random/array/pareto-type1":"@stdlib/random-array-pareto-type1","@stdlib/random/array/poisson":"@stdlib/random-array-poisson","@stdlib/random/array/randu":"@stdlib/random-array-randu","@stdlib/random/array/rayleigh":"@stdlib/random-array-rayleigh","@stdlib/random/array/t":"@stdlib/random-array-t","@stdlib/random/array/triangular":"@stdlib/random-array-triangular","@stdlib/random/array/uniform":"@stdlib/random-array-uniform","@stdlib/random/array/weibull":"@stdlib/random-array-weibull","@stdlib/random/iter/arcsine":"@stdlib/random-iter-arcsine","@stdlib/random/iter/bernoulli":"@stdlib/random-iter-bernoulli","@stdlib/random/iter/beta":"@stdlib/random-iter-beta","@stdlib/random/iter/betaprime":"@stdlib/random-iter-betaprime","@stdlib/random/iter/binomial":"@stdlib/random-iter-binomial","@stdlib/random/iter/box-muller":"@stdlib/random-iter-box-muller","@stdlib/random/iter/cauchy":"@stdlib/random-iter-cauchy","@stdlib/random/iter/chi":"@stdlib/random-iter-chi","@stdlib/random/iter/chisquare":"@stdlib/random-iter-chisquare","@stdlib/random/iter/cosine":"@stdlib/random-iter-cosine","@stdlib/random/iter/discrete-uniform":"@stdlib/random-iter-discrete-uniform","@stdlib/random/iter/erlang":"@stdlib/random-iter-erlang","@stdlib/random/iter/exponential":"@stdlib/random-iter-exponential","@stdlib/random/iter/f":"@stdlib/random-iter-f","@stdlib/random/iter/frechet":"@stdlib/random-iter-frechet","@stdlib/random/iter/gamma":"@stdlib/random-iter-gamma","@stdlib/random/iter/geometric":"@stdlib/random-iter-geometric","@stdlib/random/iter/gumbel":"@stdlib/random-iter-gumbel","@stdlib/random/iter/hypergeometric":"@stdlib/random-iter-hypergeometric","@stdlib/random/iter/improved-ziggurat":"@stdlib/random-iter-improved-ziggurat","@stdlib/random/iter/invgamma":"@stdlib/random-iter-invgamma","@stdlib/random/iter/kumaraswamy":"@stdlib/random-iter-kumaraswamy","@stdlib/random/iter/laplace":"@stdlib/random-iter-laplace","@stdlib/random/iter/levy":"@stdlib/random-iter-levy","@stdlib/random/iter/logistic":"@stdlib/random-iter-logistic","@stdlib/random/iter/lognormal":"@stdlib/random-iter-lognormal","@stdlib/random/iter/minstd":"@stdlib/random-iter-minstd","@stdlib/random/iter/minstd-shuffle":"@stdlib/random-iter-minstd-shuffle","@stdlib/random/iter/mt19937":"@stdlib/random-iter-mt19937","@stdlib/random/iter/negative-binomial":"@stdlib/random-iter-negative-binomial","@stdlib/random/iter/normal":"@stdlib/random-iter-normal","@stdlib/random/iter/pareto-type1":"@stdlib/random-iter-pareto-type1","@stdlib/random/iter/poisson":"@stdlib/random-iter-poisson","@stdlib/random/iter/randi":"@stdlib/random-iter-randi","@stdlib/random/iter/randn":"@stdlib/random-iter-randn","@stdlib/random/iter/randu":"@stdlib/random-iter-randu","@stdlib/random/iter/rayleigh":"@stdlib/random-iter-rayleigh","@stdlib/random/iter/t":"@stdlib/random-iter-t","@stdlib/random/iter/triangular":"@stdlib/random-iter-triangular","@stdlib/random/iter/uniform":"@stdlib/random-iter-uniform","@stdlib/random/iter/weibull":"@stdlib/random-iter-weibull","@stdlib/random/streams/arcsine":"@stdlib/random-streams-arcsine","@stdlib/random/streams/bernoulli":"@stdlib/random-streams-bernoulli","@stdlib/random/streams/beta":"@stdlib/random-streams-beta","@stdlib/random/streams/betaprime":"@stdlib/random-streams-betaprime","@stdlib/random/streams/binomial":"@stdlib/random-streams-binomial","@stdlib/random/streams/box-muller":"@stdlib/random-streams-box-muller","@stdlib/random/streams/cauchy":"@stdlib/random-streams-cauchy","@stdlib/random/streams/chi":"@stdlib/random-streams-chi","@stdlib/random/streams/chisquare":"@stdlib/random-streams-chisquare","@stdlib/random/streams/cosine":"@stdlib/random-streams-cosine","@stdlib/random/streams/discrete-uniform":"@stdlib/random-streams-discrete-uniform","@stdlib/random/streams/erlang":"@stdlib/random-streams-erlang","@stdlib/random/streams/exponential":"@stdlib/random-streams-exponential","@stdlib/random/streams/f":"@stdlib/random-streams-f","@stdlib/random/streams/frechet":"@stdlib/random-streams-frechet","@stdlib/random/streams/gamma":"@stdlib/random-streams-gamma","@stdlib/random/streams/geometric":"@stdlib/random-streams-geometric","@stdlib/random/streams/gumbel":"@stdlib/random-streams-gumbel","@stdlib/random/streams/hypergeometric":"@stdlib/random-streams-hypergeometric","@stdlib/random/streams/improved-ziggurat":"@stdlib/random-streams-improved-ziggurat","@stdlib/random/streams/invgamma":"@stdlib/random-streams-invgamma","@stdlib/random/streams/kumaraswamy":"@stdlib/random-streams-kumaraswamy","@stdlib/random/streams/laplace":"@stdlib/random-streams-laplace","@stdlib/random/streams/levy":"@stdlib/random-streams-levy","@stdlib/random/streams/logistic":"@stdlib/random-streams-logistic","@stdlib/random/streams/lognormal":"@stdlib/random-streams-lognormal","@stdlib/random/streams/minstd":"@stdlib/random-streams-minstd","@stdlib/random/streams/minstd-shuffle":"@stdlib/random-streams-minstd-shuffle","@stdlib/random/streams/mt19937":"@stdlib/random-streams-mt19937","@stdlib/random/streams/negative-binomial":"@stdlib/random-streams-negative-binomial","@stdlib/random/streams/normal":"@stdlib/random-streams-normal","@stdlib/random/streams/pareto-type1":"@stdlib/random-streams-pareto-type1","@stdlib/random/streams/poisson":"@stdlib/random-streams-poisson","@stdlib/random/streams/randi":"@stdlib/random-streams-randi","@stdlib/random/streams/randn":"@stdlib/random-streams-randn","@stdlib/random/streams/randu":"@stdlib/random-streams-randu","@stdlib/random/streams/rayleigh":"@stdlib/random-streams-rayleigh","@stdlib/random/streams/t":"@stdlib/random-streams-t","@stdlib/random/streams/triangular":"@stdlib/random-streams-triangular","@stdlib/random/streams/uniform":"@stdlib/random-streams-uniform","@stdlib/random/streams/weibull":"@stdlib/random-streams-weibull","@stdlib/random/strided/arcsine":"@stdlib/random-strided-arcsine","@stdlib/random/strided/bernoulli":"@stdlib/random-strided-bernoulli","@stdlib/random/strided/beta":"@stdlib/random-strided-beta","@stdlib/random/strided/betaprime":"@stdlib/random-strided-betaprime","@stdlib/random/strided/chi":"@stdlib/random-strided-chi","@stdlib/random/strided/chisquare":"@stdlib/random-strided-chisquare","@stdlib/random/strided/cosine":"@stdlib/random-strided-cosine","@stdlib/random/strided/discrete-uniform":"@stdlib/random-strided-discrete-uniform","@stdlib/random/strided/exponential":"@stdlib/random-strided-exponential","@stdlib/random/strided/gamma":"@stdlib/random-strided-gamma","@stdlib/random/strided/geometric":"@stdlib/random-strided-geometric","@stdlib/random/strided/invgamma":"@stdlib/random-strided-invgamma","@stdlib/random/strided/lognormal":"@stdlib/random-strided-lognormal","@stdlib/random/strided/minstd":"@stdlib/random-strided-minstd","@stdlib/random/strided/minstd-shuffle":"@stdlib/random-strided-minstd-shuffle","@stdlib/random/strided/mt19937":"@stdlib/random-strided-mt19937","@stdlib/random/strided/normal":"@stdlib/random-strided-normal","@stdlib/random/strided/poisson":"@stdlib/random-strided-poisson","@stdlib/random/strided/randu":"@stdlib/random-strided-randu","@stdlib/random/strided/rayleigh":"@stdlib/random-strided-rayleigh","@stdlib/random/strided/t":"@stdlib/random-strided-t","@stdlib/random/strided/uniform":"@stdlib/random-strided-uniform","@stdlib/random/strided/weibull":"@stdlib/random-strided-weibull","@stdlib/stats/ranks":"@stdlib/stats-ranks","@stdlib/fs/read-dir":"@stdlib/fs-read-dir","@stdlib/fs/read-file":"@stdlib/fs-read-file","@stdlib/fs/read-file-list":"@stdlib/fs-read-file-list","@stdlib/fs/read-json":"@stdlib/fs-read-json","@stdlib/fs/read-wasm":"@stdlib/fs-read-wasm","@stdlib/complex/float64/real":"@stdlib/complex-float64-real","@stdlib/array/typed-real":"@stdlib/array-typed-real","@stdlib/array/typed-real-ctors":"@stdlib/array-typed-real-ctors","@stdlib/array/typed-real-dtypes":"@stdlib/array-typed-real-dtypes","@stdlib/complex/float32/real":"@stdlib/complex-float32-real","@stdlib/utils/real-max":"@stdlib/utils-real-max","@stdlib/utils/real-min":"@stdlib/utils-real-min","@stdlib/regexp/basename":"@stdlib/regexp-basename","@stdlib/regexp/basename-posix":"@stdlib/regexp-basename-posix","@stdlib/regexp/basename-windows":"@stdlib/regexp-basename-windows","@stdlib/regexp/color-hexadecimal":"@stdlib/regexp-color-hexadecimal","@stdlib/regexp/decimal-number":"@stdlib/regexp-decimal-number","@stdlib/regexp/dirname":"@stdlib/regexp-dirname","@stdlib/regexp/dirname-posix":"@stdlib/regexp-dirname-posix","@stdlib/regexp/dirname-windows":"@stdlib/regexp-dirname-windows","@stdlib/utils/reduce":"@stdlib/utils-reduce","@stdlib/utils/reduce2d":"@stdlib/utils-reduce2d","@stdlib/utils/async/reduce":"@stdlib/utils-async-reduce","@stdlib/utils/reduce-right":"@stdlib/utils-reduce-right","@stdlib/utils/async/reduce-right":"@stdlib/utils-async-reduce-right","@stdlib/regexp/duration-string":"@stdlib/regexp-duration-string","@stdlib/regexp/eol":"@stdlib/regexp-eol","@stdlib/regexp/extended-length-path":"@stdlib/regexp-extended-length-path","@stdlib/regexp/extname":"@stdlib/regexp-extname","@stdlib/regexp/extname-posix":"@stdlib/regexp-extname-posix","@stdlib/regexp/extname-windows":"@stdlib/regexp-extname-windows","@stdlib/regexp/filename":"@stdlib/regexp-filename","@stdlib/regexp/filename-posix":"@stdlib/regexp-filename-posix","@stdlib/regexp/filename-windows":"@stdlib/regexp-filename-windows","@stdlib/utils/regexp-from-string":"@stdlib/utils-regexp-from-string","@stdlib/regexp/function-name":"@stdlib/regexp-function-name","@stdlib/regexp/to-json":"@stdlib/regexp-to-json","@stdlib/complex/float64/reim":"@stdlib/complex-float64-reim","@stdlib/complex/float32/reim":"@stdlib/complex-float32-reim","@stdlib/utils/reject-arguments":"@stdlib/utils-reject-arguments","@stdlib/string/remove-first":"@stdlib/string-remove-first","@stdlib/string/remove-last":"@stdlib/string-remove-last","@stdlib/string/remove-punctuation":"@stdlib/string-remove-punctuation","@stdlib/string/remove-utf8-bom":"@stdlib/string-remove-utf8-bom","@stdlib/string/remove-words":"@stdlib/string-remove-words","@stdlib/fs/rename":"@stdlib/fs-rename","@stdlib/regexp/native-function":"@stdlib/regexp-native-function","@stdlib/utils/reorder-arguments":"@stdlib/utils-reorder-arguments","@stdlib/string/repeat":"@stdlib/string-repeat","@stdlib/string/replace":"@stdlib/string-replace","@stdlib/string/replace-before":"@stdlib/string-replace-before","@stdlib/regexp/regexp":"@stdlib/regexp-regexp","@stdlib/utils/escape-regexp-string":"@stdlib/utils-escape-regexp-string","@stdlib/regexp/semver":"@stdlib/regexp-semver","@stdlib/fs/resolve-parent-path":"@stdlib/fs-resolve-parent-path","@stdlib/fs/resolve-parent-path-by":"@stdlib/fs-resolve-parent-path-by","@stdlib/regexp/unc-path":"@stdlib/regexp-unc-path","@stdlib/regexp/utf16-surrogate-pair":"@stdlib/regexp-utf16-surrogate-pair","@stdlib/regexp/utf16-unpaired-surrogate":"@stdlib/regexp-utf16-unpaired-surrogate","@stdlib/utils/reverse-arguments":"@stdlib/utils-reverse-arguments","@stdlib/string/reverse":"@stdlib/string-reverse","@stdlib/random/base/reviver":"@stdlib/random-base-reviver","@stdlib/buffer/reviver":"@stdlib/buffer-reviver","@stdlib/complex/reviver":"@stdlib/complex-reviver","@stdlib/complex/float32/reviver":"@stdlib/complex-float32-reviver","@stdlib/complex/float64/reviver":"@stdlib/complex-float64-reviver","@stdlib/error/reviver":"@stdlib/error-reviver","@stdlib/regexp/reviver":"@stdlib/regexp-reviver","@stdlib/array/reviver":"@stdlib/array-reviver","@stdlib/regexp/whitespace":"@stdlib/regexp-whitespace","@stdlib/string/right-pad":"@stdlib/string-right-pad","@stdlib/string/right-trim":"@stdlib/string-right-trim","@stdlib/string/right-trim-n":"@stdlib/string-right-trim-n","@stdlib/utils/safe-int-max":"@stdlib/utils-safe-int-max","@stdlib/utils/safe-int-min":"@stdlib/utils-safe-int-min","@stdlib/random/sample":"@stdlib/random-sample","@stdlib/datasets/savoy-stopwords-fin":"@stdlib/datasets-savoy-stopwords-fin","@stdlib/datasets/savoy-stopwords-fr":"@stdlib/datasets-savoy-stopwords-fr","@stdlib/datasets/savoy-stopwords-ger":"@stdlib/datasets-savoy-stopwords-ger","@stdlib/datasets/savoy-stopwords-it":"@stdlib/datasets-savoy-stopwords-it","@stdlib/datasets/savoy-stopwords-por":"@stdlib/datasets-savoy-stopwords-por","@stdlib/datasets/savoy-stopwords-sp":"@stdlib/datasets-savoy-stopwords-sp","@stdlib/datasets/savoy-stopwords-swe":"@stdlib/datasets-savoy-stopwords-swe","@stdlib/array/from-scalar":"@stdlib/array-from-scalar","@stdlib/ndarray/from-scalar":"@stdlib/ndarray-from-scalar","@stdlib/blas/sdot":"@stdlib/blas-sdot","@stdlib/constants/time/seconds-in-day":"@stdlib/constants-time-seconds-in-day","@stdlib/constants/time/seconds-in-hour":"@stdlib/constants-time-seconds-in-hour","@stdlib/constants/time/seconds-in-minute":"@stdlib/constants-time-seconds-in-minute","@stdlib/constants/time/seconds-in-week":"@stdlib/constants-time-seconds-in-week","@stdlib/time/seconds-in-month":"@stdlib/time-seconds-in-month","@stdlib/time/seconds-in-year":"@stdlib/time-seconds-in-year","@stdlib/nlp/sentencize":"@stdlib/nlp-sentencize","@stdlib/slice/seq2slice":"@stdlib/slice-seq2slice","@stdlib/utils/define-configurable-read-only-property":"@stdlib/utils-define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor":"@stdlib/utils-define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor":"@stdlib/utils-define-configurable-read-write-accessor","@stdlib/utils/define-configurable-write-only-accessor":"@stdlib/utils-define-configurable-write-only-accessor","@stdlib/utils/define-memoized-configurable-read-only-property":"@stdlib/utils-define-memoized-configurable-read-only-property","@stdlib/utils/define-memoized-read-only-property":"@stdlib/utils-define-memoized-read-only-property","@stdlib/utils/define-nonenumerable-property":"@stdlib/utils-define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-property":"@stdlib/utils-define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-only-accessor":"@stdlib/utils-define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-write-accessor":"@stdlib/utils-define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor":"@stdlib/utils-define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property":"@stdlib/utils-define-read-only-property","@stdlib/utils/define-read-only-accessor":"@stdlib/utils-define-read-only-accessor","@stdlib/utils/define-read-write-accessor":"@stdlib/utils-define-read-write-accessor","@stdlib/utils/define-write-only-accessor":"@stdlib/utils-define-write-only-accessor","@stdlib/array/shared-buffer":"@stdlib/array-shared-buffer","@stdlib/utils/shift":"@stdlib/utils-shift","@stdlib/random/shuffle":"@stdlib/random-shuffle","@stdlib/utils/size-of":"@stdlib/utils-size-of","@stdlib/slice/ctor":"@stdlib/slice-ctor","@stdlib/string/snakecase":"@stdlib/string-snakecase","@stdlib/utils/some":"@stdlib/utils-some","@stdlib/utils/some-by":"@stdlib/utils-some-by","@stdlib/utils/async/some-by":"@stdlib/utils-async-some-by","@stdlib/utils/some-by-right":"@stdlib/utils-some-by-right","@stdlib/utils/async/some-by-right":"@stdlib/utils-async-some-by-right","@stdlib/utils/some-in-by":"@stdlib/utils-some-in-by","@stdlib/utils/some-own-by":"@stdlib/utils-some-own-by","@stdlib/datasets/sotu":"@stdlib/datasets-sotu","@stdlib/datasets/spache-revised":"@stdlib/datasets-spache-revised","@stdlib/datasets/spam-assassin":"@stdlib/datasets-spam-assassin","@stdlib/plot/sparklines/base/ctor":"@stdlib/plot-sparklines-base-ctor","@stdlib/array/to-sparse-iterator":"@stdlib/array-to-sparse-iterator","@stdlib/array/to-sparse-iterator-right":"@stdlib/array-to-sparse-iterator-right","@stdlib/streams/node/split":"@stdlib/streams-node-split","@stdlib/constants/float64/sqrt-eps":"@stdlib/constants-float64-sqrt-eps","@stdlib/constants/float64/sqrt-half":"@stdlib/constants-float64-sqrt-half","@stdlib/constants/float64/sqrt-half-pi":"@stdlib/constants-float64-sqrt-half-pi","@stdlib/constants/float64/sqrt-phi":"@stdlib/constants-float64-sqrt-phi","@stdlib/constants/float64/sqrt-pi":"@stdlib/constants-float64-sqrt-pi","@stdlib/constants/float64/sqrt-three":"@stdlib/constants-float64-sqrt-three","@stdlib/constants/float64/sqrt-two":"@stdlib/constants-float64-sqrt-two","@stdlib/constants/float64/sqrt-two-pi":"@stdlib/constants-float64-sqrt-two-pi","@stdlib/datasets/ssa-us-births-2000-2014":"@stdlib/datasets-ssa-us-births-2000-2014","@stdlib/blas/sswap":"@stdlib/blas-sswap","@stdlib/dstructs/stack":"@stdlib/dstructs-stack","@stdlib/namespace/standalone2pkg":"@stdlib/namespace-standalone2pkg","@stdlib/datasets/standard-card-deck":"@stdlib/datasets-standard-card-deck","@stdlib/string/startcase":"@stdlib/string-startcase","@stdlib/string/starts-with":"@stdlib/string-starts-with","@stdlib/datasets/stopwords-en":"@stdlib/datasets-stopwords-en","@stdlib/math/strided/special/abs":"@stdlib/math-strided-special-abs","@stdlib/math/strided/special/abs2":"@stdlib/math-strided-special-abs2","@stdlib/math/strided/special/abs2-by":"@stdlib/math-strided-special-abs2-by","@stdlib/math/strided/special/abs-by":"@stdlib/math-strided-special-abs-by","@stdlib/math/strided/special/acos-by":"@stdlib/math-strided-special-acos-by","@stdlib/math/strided/special/acosh-by":"@stdlib/math-strided-special-acosh-by","@stdlib/math/strided/special/acot-by":"@stdlib/math-strided-special-acot-by","@stdlib/math/strided/special/acoth-by":"@stdlib/math-strided-special-acoth-by","@stdlib/math/strided/special/acovercos-by":"@stdlib/math-strided-special-acovercos-by","@stdlib/math/strided/special/acoversin-by":"@stdlib/math-strided-special-acoversin-by","@stdlib/math/strided/ops/add":"@stdlib/math-strided-ops-add","@stdlib/math/strided/ops/add-by":"@stdlib/math-strided-ops-add-by","@stdlib/math/strided/special/ahavercos-by":"@stdlib/math-strided-special-ahavercos-by","@stdlib/math/strided/special/ahaversin-by":"@stdlib/math-strided-special-ahaversin-by","@stdlib/math/strided/special/asin-by":"@stdlib/math-strided-special-asin-by","@stdlib/math/strided/special/asinh-by":"@stdlib/math-strided-special-asinh-by","@stdlib/math/strided/special/atan-by":"@stdlib/math-strided-special-atan-by","@stdlib/math/strided/special/atanh-by":"@stdlib/math-strided-special-atanh-by","@stdlib/math/strided/special/avercos-by":"@stdlib/math-strided-special-avercos-by","@stdlib/math/strided/special/aversin-by":"@stdlib/math-strided-special-aversin-by","@stdlib/math/strided/special/besselj0-by":"@stdlib/math-strided-special-besselj0-by","@stdlib/math/strided/special/besselj1-by":"@stdlib/math-strided-special-besselj1-by","@stdlib/math/strided/special/bessely0-by":"@stdlib/math-strided-special-bessely0-by","@stdlib/math/strided/special/bessely1-by":"@stdlib/math-strided-special-bessely1-by","@stdlib/math/strided/special/binet-by":"@stdlib/math-strided-special-binet-by","@stdlib/math/strided/special/cbrt":"@stdlib/math-strided-special-cbrt","@stdlib/math/strided/special/cbrt-by":"@stdlib/math-strided-special-cbrt-by","@stdlib/math/strided/special/ceil":"@stdlib/math-strided-special-ceil","@stdlib/math/strided/special/cos-by":"@stdlib/math-strided-special-cos-by","@stdlib/math/strided/special/deg2rad":"@stdlib/math-strided-special-deg2rad","@stdlib/strided/dtypes":"@stdlib/strided-dtypes","@stdlib/math/strided/special/dcbrt-by":"@stdlib/math-strided-special-dcbrt-by","@stdlib/strided/dispatch":"@stdlib/strided-dispatch","@stdlib/strided/dispatch-by":"@stdlib/strided-dispatch-by","@stdlib/math/strided/special/floor":"@stdlib/math-strided-special-floor","@stdlib/math/strided/special/inv":"@stdlib/math-strided-special-inv","@stdlib/math/strided/ops/mul":"@stdlib/math-strided-ops-mul","@stdlib/math/strided/ops/mul-by":"@stdlib/math-strided-ops-mul-by","@stdlib/math/strided/special/ramp":"@stdlib/math-strided-special-ramp","@stdlib/math/strided/special/rsqrt":"@stdlib/math-strided-special-rsqrt","@stdlib/math/strided/special/sin-by":"@stdlib/math-strided-special-sin-by","@stdlib/math/strided/special/sqrt":"@stdlib/math-strided-special-sqrt","@stdlib/math/strided/special/sqrt-by":"@stdlib/math-strided-special-sqrt-by","@stdlib/math/strided/ops/sub":"@stdlib/math-strided-ops-sub","@stdlib/math/strided/ops/sub-by":"@stdlib/math-strided-ops-sub-by","@stdlib/math/strided/special/trunc":"@stdlib/math-strided-special-trunc","@stdlib/array/to-strided-iterator":"@stdlib/array-to-strided-iterator","@stdlib/streams/node/from-strided-array":"@stdlib/streams-node-from-strided-array","@stdlib/buffer/from-string":"@stdlib/buffer-from-string","@stdlib/ndarray/sub2ind":"@stdlib/ndarray-sub2ind","@stdlib/string/substring-after":"@stdlib/string-substring-after","@stdlib/string/substring-after-last":"@stdlib/string-substring-after-last","@stdlib/string/substring-before":"@stdlib/string-substring-before","@stdlib/string/substring-before-last":"@stdlib/string-substring-before-last","@stdlib/datasets/suthaharan-multi-hop-sensor-network":"@stdlib/datasets-suthaharan-multi-hop-sensor-network","@stdlib/datasets/suthaharan-single-hop-sensor-network":"@stdlib/datasets-suthaharan-single-hop-sensor-network","@stdlib/symbol/ctor":"@stdlib/symbol-ctor","@stdlib/utils/tabulate":"@stdlib/utils-tabulate","@stdlib/utils/tabulate-by":"@stdlib/utils-tabulate-by","@stdlib/utils/async/tabulate-by":"@stdlib/utils-async-tabulate-by","@stdlib/function/thunk":"@stdlib/function-thunk","@stdlib/time/tic":"@stdlib/time-tic","@stdlib/utils/timeit":"@stdlib/utils-timeit","@stdlib/os/tmpdir":"@stdlib/os-tmpdir","@stdlib/time/toc":"@stdlib/time-toc","@stdlib/nlp/tokenize":"@stdlib/nlp-tokenize","@stdlib/streams/node/transform":"@stdlib/streams-node-transform","@stdlib/string/trim":"@stdlib/string-trim","@stdlib/string/truncate":"@stdlib/string-truncate","@stdlib/string/truncate-middle":"@stdlib/string-truncate-middle","@stdlib/utils/try-catch":"@stdlib/utils-try-catch","@stdlib/utils/async/try-catch":"@stdlib/utils-async-try-catch","@stdlib/utils/try-function":"@stdlib/utils-try-function","@stdlib/utils/try-require":"@stdlib/utils-try-require","@stdlib/utils/try-then":"@stdlib/utils-try-then","@stdlib/utils/async/try-then":"@stdlib/utils-async-try-then","@stdlib/stats/ttest":"@stdlib/stats-ttest","@stdlib/stats/ttest2":"@stdlib/stats-ttest2","@stdlib/constants/float64/two-pi":"@stdlib/constants-float64-two-pi","@stdlib/array/typed":"@stdlib/array-typed","@stdlib/array/to-json":"@stdlib/array-to-json","@stdlib/array/typed-ctors":"@stdlib/array-typed-ctors","@stdlib/array/typed-dtypes":"@stdlib/array-typed-dtypes","@stdlib/array/pool":"@stdlib/array-pool","@stdlib/utils/type-max":"@stdlib/utils-type-max","@stdlib/utils/type-min":"@stdlib/utils-type-min","@stdlib/utils/type-of":"@stdlib/utils-type-of","@stdlib/constants/uint8/max":"@stdlib/constants-uint8-max","@stdlib/constants/uint8/num-bytes":"@stdlib/constants-uint8-num-bytes","@stdlib/array/uint8":"@stdlib/array-uint8","@stdlib/array/uint8c":"@stdlib/array-uint8c","@stdlib/constants/uint16/max":"@stdlib/constants-uint16-max","@stdlib/constants/uint16/num-bytes":"@stdlib/constants-uint16-num-bytes","@stdlib/array/uint16":"@stdlib/array-uint16","@stdlib/constants/uint32/max":"@stdlib/constants-uint32-max","@stdlib/constants/uint32/num-bytes":"@stdlib/constants-uint32-num-bytes","@stdlib/array/uint32":"@stdlib/array-uint32","@stdlib/process/umask":"@stdlib/process-umask","@stdlib/string/uncapitalize":"@stdlib/string-uncapitalize","@stdlib/utils/uncapitalize-keys":"@stdlib/utils-uncapitalize-keys","@stdlib/utils/uncurry":"@stdlib/utils-uncurry","@stdlib/utils/uncurry-right":"@stdlib/utils-uncurry-right","@stdlib/constants/unicode/max":"@stdlib/constants-unicode-max","@stdlib/constants/unicode/max-bmp":"@stdlib/constants-unicode-max-bmp","@stdlib/plot/sparklines/unicode/column":"@stdlib/plot-sparklines-unicode-column","@stdlib/plot/sparklines/unicode/line":"@stdlib/plot-sparklines-unicode-line","@stdlib/plot/sparklines/unicode":"@stdlib/plot-sparklines-unicode","@stdlib/plot/sparklines/unicode/tristate":"@stdlib/plot-sparklines-unicode-tristate","@stdlib/plot/sparklines/unicode/up-down":"@stdlib/plot-sparklines-unicode-up-down","@stdlib/plot/sparklines/unicode/win-loss":"@stdlib/plot-sparklines-unicode-win-loss","@stdlib/fs/unlink":"@stdlib/fs-unlink","@stdlib/utils/unshift":"@stdlib/utils-unshift","@stdlib/utils/until":"@stdlib/utils-until","@stdlib/utils/async/until":"@stdlib/utils-async-until","@stdlib/utils/until-each":"@stdlib/utils-until-each","@stdlib/utils/until-each-right":"@stdlib/utils-until-each-right","@stdlib/utils/unzip":"@stdlib/utils-unzip","@stdlib/string/uppercase":"@stdlib/string-uppercase","@stdlib/utils/uppercase-keys":"@stdlib/utils-uppercase-keys","@stdlib/datasets/us-states-abbr":"@stdlib/datasets-us-states-abbr","@stdlib/datasets/us-states-capitals":"@stdlib/datasets-us-states-capitals","@stdlib/datasets/us-states-capitals-names":"@stdlib/datasets-us-states-capitals-names","@stdlib/datasets/us-states-names":"@stdlib/datasets-us-states-names","@stdlib/datasets/us-states-names-capitals":"@stdlib/datasets-us-states-names-capitals","@stdlib/string/utf16-to-utf8-array":"@stdlib/string-utf16-to-utf8-array","@stdlib/stats/vartest":"@stdlib/stats-vartest","@stdlib/utils/async/series-waterfall":"@stdlib/utils-async-series-waterfall","@stdlib/wasm/memory":"@stdlib/wasm-memory","@stdlib/utils/async/while":"@stdlib/utils-async-while","@stdlib/utils/while-each":"@stdlib/utils-while-each","@stdlib/utils/while-each-right":"@stdlib/utils-while-each-right","@stdlib/utils/while":"@stdlib/utils-while","@stdlib/stats/wilcoxon":"@stdlib/stats-wilcoxon","@stdlib/utils/writable-properties":"@stdlib/utils-writable-properties","@stdlib/utils/writable-properties-in":"@stdlib/utils-writable-properties-in","@stdlib/utils/writable-property-names":"@stdlib/utils-writable-property-names","@stdlib/utils/writable-property-names-in":"@stdlib/utils-writable-property-names-in","@stdlib/utils/writable-property-symbols":"@stdlib/utils-writable-property-symbols","@stdlib/utils/writable-property-symbols-in":"@stdlib/utils-writable-property-symbols-in","@stdlib/fs/write-file":"@stdlib/fs-write-file","@stdlib/utils/zip":"@stdlib/utils-zip","@stdlib/stats/ztest":"@stdlib/stats-ztest","@stdlib/stats/ztest2":"@stdlib/stats-ztest2"} diff --git a/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.csv b/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.csv index 5b9c48f9f6e2..eb5347767638 100644 --- a/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.csv +++ b/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.csv @@ -1480,7 +1480,7 @@ "@stdlib/math-base-special-truncn","@stdlib/math/base/special/truncn" "@stdlib/math-base-special-truncsd","@stdlib/math/base/special/truncsd" "@stdlib/number-uint32-base-to-int32","@stdlib/number/uint32/base/to-int32" -"@stdlib/math-base-ops-umul","@stdlib/math/base/ops/umul" +"@stdlib/math-base-ops-umul","@stdlib/number/uint32/base/mul" "@stdlib/math-base-ops-umuldw","@stdlib/math/base/ops/umuldw" "@stdlib/string-base-uncapitalize","@stdlib/string/base/uncapitalize" "@stdlib/string-base-uppercase","@stdlib/string/base/uppercase" diff --git a/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.json b/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.json index 33c3a1a6edf6..7aaa4b53d3ff 100644 --- a/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.json +++ b/lib/node_modules/@stdlib/namespace/standalone2pkg/data/data.json @@ -1 +1 @@ -{"@stdlib/math-special-abs":"@stdlib/math/special/abs","@stdlib/array-cartesian-power":"@stdlib/array/cartesian-power","@stdlib/array-cartesian-product":"@stdlib/array/cartesian-product","@stdlib/array-cartesian-square":"@stdlib/array/cartesian-square","@stdlib/string-acronym":"@stdlib/string/acronym","@stdlib/array-empty":"@stdlib/array/empty","@stdlib/array-empty-like":"@stdlib/array/empty-like","@stdlib/datasets-afinn-96":"@stdlib/datasets/afinn-96","@stdlib/datasets-afinn-111":"@stdlib/datasets/afinn-111","@stdlib/array-full":"@stdlib/array/full","@stdlib/array-full-like":"@stdlib/array/full-like","@stdlib/namespace-alias2pkg":"@stdlib/namespace/alias2pkg","@stdlib/namespace-alias2related":"@stdlib/namespace/alias2related","@stdlib/namespace-alias2standalone":"@stdlib/namespace/alias2standalone","@stdlib/namespace-aliases":"@stdlib/namespace/aliases","@stdlib/buffer-alloc-unsafe":"@stdlib/buffer/alloc-unsafe","@stdlib/array-mskfilter":"@stdlib/array/mskfilter","@stdlib/array-mskput":"@stdlib/array/mskput","@stdlib/array-mskreject":"@stdlib/array/mskreject","@stdlib/array-nans":"@stdlib/array/nans","@stdlib/array-nans-like":"@stdlib/array/nans-like","@stdlib/stats-anova1":"@stdlib/stats/anova1","@stdlib/datasets-anscombes-quartet":"@stdlib/datasets/anscombes-quartet","@stdlib/utils-any":"@stdlib/utils/any","@stdlib/utils-any-by":"@stdlib/utils/any-by","@stdlib/utils-async-any-by":"@stdlib/utils/async/any-by","@stdlib/utils-any-by-right":"@stdlib/utils/any-by-right","@stdlib/utils-async-any-by-right":"@stdlib/utils/async/any-by-right","@stdlib/utils-any-in-by":"@stdlib/utils/any-in-by","@stdlib/utils-any-own-by":"@stdlib/utils/any-own-by","@stdlib/array-ones":"@stdlib/array/ones","@stdlib/array-ones-like":"@stdlib/array/ones-like","@stdlib/array-one-to":"@stdlib/array/one-to","@stdlib/array-one-to-like":"@stdlib/array/one-to-like","@stdlib/constants-float64-apery":"@stdlib/constants/float64/apery","@stdlib/array-place":"@stdlib/array/place","@stdlib/utils-append":"@stdlib/utils/append","@stdlib/array-put":"@stdlib/array/put","@stdlib/os-arch":"@stdlib/os/arch","@stdlib/utils-argument-function":"@stdlib/utils/argument-function","@stdlib/process-argv":"@stdlib/process/argv","@stdlib/ndarray-array":"@stdlib/ndarray/array","@stdlib/buffer-from-array":"@stdlib/buffer/from-array","@stdlib/array-to-fancy":"@stdlib/array/to-fancy","@stdlib/array-to-iterator":"@stdlib/array/to-iterator","@stdlib/array-to-iterator-right":"@stdlib/array/to-iterator-right","@stdlib/array-buffer":"@stdlib/array/buffer","@stdlib/buffer-from-arraybuffer":"@stdlib/buffer/from-arraybuffer","@stdlib/array-ctors":"@stdlib/array/ctors","@stdlib/array-dtype":"@stdlib/array/dtype","@stdlib/array-dtypes":"@stdlib/array/dtypes","@stdlib/array-index":"@stdlib/array/index","@stdlib/array-min-dtype":"@stdlib/array/min-dtype","@stdlib/array-mostly-safe-casts":"@stdlib/array/mostly-safe-casts","@stdlib/array-next-dtype":"@stdlib/array/next-dtype","@stdlib/array-promotion-rules":"@stdlib/array/promotion-rules","@stdlib/array-safe-casts":"@stdlib/array/safe-casts","@stdlib/array-same-kind-casts":"@stdlib/array/same-kind-casts","@stdlib/array-shape":"@stdlib/array/shape","@stdlib/streams-node-from-array":"@stdlib/streams/node/from-array","@stdlib/array-to-view-iterator":"@stdlib/array/to-view-iterator","@stdlib/array-to-view-iterator-right":"@stdlib/array/to-view-iterator-right","@stdlib/array-slice":"@stdlib/array/slice","@stdlib/symbol-async-iterator":"@stdlib/symbol/async-iterator","@stdlib/array-take":"@stdlib/array/take","@stdlib/array-zeros":"@stdlib/array/zeros","@stdlib/array-zeros-like":"@stdlib/array/zeros-like","@stdlib/array-zero-to":"@stdlib/array/zero-to","@stdlib/array-zero-to-like":"@stdlib/array/zero-to-like","@stdlib/stats-bartlett-test":"@stdlib/stats/bartlett-test","@stdlib/math-base-special-abs":"@stdlib/math/base/special/abs","@stdlib/math-base-special-abs2":"@stdlib/math/base/special/abs2","@stdlib/math-base-special-abs2f":"@stdlib/math/base/special/abs2f","@stdlib/math-base-utils-absolute-difference":"@stdlib/math/base/utils/absolute-difference","@stdlib/math-base-special-absf":"@stdlib/math/base/special/absf","@stdlib/array-base-cartesian-power":"@stdlib/array/base/cartesian-power","@stdlib/array-base-cartesian-product":"@stdlib/array/base/cartesian-product","@stdlib/array-base-cartesian-square":"@stdlib/array/base/cartesian-square","@stdlib/math-base-special-acos":"@stdlib/math/base/special/acos","@stdlib/math-base-special-acosd":"@stdlib/math/base/special/acosd","@stdlib/math-base-special-acosf":"@stdlib/math/base/special/acosf","@stdlib/math-base-special-acosh":"@stdlib/math/base/special/acosh","@stdlib/math-base-special-acot":"@stdlib/math/base/special/acot","@stdlib/math-base-special-acotd":"@stdlib/math/base/special/acotd","@stdlib/math-base-special-acotf":"@stdlib/math/base/special/acotf","@stdlib/math-base-special-acoth":"@stdlib/math/base/special/acoth","@stdlib/math-base-special-acovercos":"@stdlib/math/base/special/acovercos","@stdlib/math-base-special-acoversin":"@stdlib/math/base/special/acoversin","@stdlib/math-base-special-acsc":"@stdlib/math/base/special/acsc","@stdlib/math-base-special-acscd":"@stdlib/math/base/special/acscd","@stdlib/math-base-special-acscdf":"@stdlib/math/base/special/acscdf","@stdlib/math-base-special-acscf":"@stdlib/math/base/special/acscf","@stdlib/math-base-special-acsch":"@stdlib/math/base/special/acsch","@stdlib/number-float64-base-add":"@stdlib/number/float64/base/add","@stdlib/number-float64-base-add3":"@stdlib/number/float64/base/add3","@stdlib/number-float64-base-add4":"@stdlib/number/float64/base/add4","@stdlib/number-float64-base-add5":"@stdlib/number/float64/base/add5","@stdlib/number-float32-base-add":"@stdlib/number/float32/base/add","@stdlib/array-base-filled":"@stdlib/array/base/filled","@stdlib/array-base-filled2d":"@stdlib/array/base/filled2d","@stdlib/array-base-filled2d-by":"@stdlib/array/base/filled2d-by","@stdlib/array-base-filled3d":"@stdlib/array/base/filled3d","@stdlib/array-base-filled3d-by":"@stdlib/array/base/filled3d-by","@stdlib/array-base-filled4d":"@stdlib/array/base/filled4d","@stdlib/array-base-filled4d-by":"@stdlib/array/base/filled4d-by","@stdlib/array-base-filled5d":"@stdlib/array/base/filled5d","@stdlib/array-base-filled5d-by":"@stdlib/array/base/filled5d-by","@stdlib/array-base-filled-by":"@stdlib/array/base/filled-by","@stdlib/array-base-fillednd":"@stdlib/array/base/fillednd","@stdlib/array-base-fillednd-by":"@stdlib/array/base/fillednd-by","@stdlib/array-base-filter":"@stdlib/array/base/filter","@stdlib/array-base-first":"@stdlib/array/base/first","@stdlib/array-base-flatten":"@stdlib/array/base/flatten","@stdlib/array-base-flatten2d":"@stdlib/array/base/flatten2d","@stdlib/array-base-flatten2d-by":"@stdlib/array/base/flatten2d-by","@stdlib/array-base-flatten3d":"@stdlib/array/base/flatten3d","@stdlib/array-base-flatten3d-by":"@stdlib/array/base/flatten3d-by","@stdlib/array-base-flatten4d":"@stdlib/array/base/flatten4d","@stdlib/array-base-flatten4d-by":"@stdlib/array/base/flatten4d-by","@stdlib/array-base-flatten5d":"@stdlib/array/base/flatten5d","@stdlib/array-base-flatten5d-by":"@stdlib/array/base/flatten5d-by","@stdlib/array-base-flatten-by":"@stdlib/array/base/flatten-by","@stdlib/array-base-fliplr2d":"@stdlib/array/base/fliplr2d","@stdlib/array-base-fliplr3d":"@stdlib/array/base/fliplr3d","@stdlib/array-base-fliplr4d":"@stdlib/array/base/fliplr4d","@stdlib/array-base-fliplr5d":"@stdlib/array/base/fliplr5d","@stdlib/array-base-flipud2d":"@stdlib/array/base/flipud2d","@stdlib/array-base-flipud3d":"@stdlib/array/base/flipud3d","@stdlib/array-base-flipud4d":"@stdlib/array/base/flipud4d","@stdlib/array-base-flipud5d":"@stdlib/array/base/flipud5d","@stdlib/math-base-special-ahavercos":"@stdlib/math/base/special/ahavercos","@stdlib/math-base-special-ahaversin":"@stdlib/math/base/special/ahaversin","@stdlib/string-base-altcase":"@stdlib/string/base/altcase","@stdlib/array-base-ones":"@stdlib/array/base/ones","@stdlib/array-base-ones2d":"@stdlib/array/base/ones2d","@stdlib/array-base-ones3d":"@stdlib/array/base/ones3d","@stdlib/array-base-ones4d":"@stdlib/array/base/ones4d","@stdlib/array-base-ones5d":"@stdlib/array/base/ones5d","@stdlib/array-base-onesnd":"@stdlib/array/base/onesnd","@stdlib/array-base-one-to":"@stdlib/array/base/one-to","@stdlib/slice-base-args2multislice":"@stdlib/slice/base/args2multislice","@stdlib/math-base-special-asec":"@stdlib/math/base/special/asec","@stdlib/math-base-special-asecd":"@stdlib/math/base/special/asecd","@stdlib/math-base-special-asecdf":"@stdlib/math/base/special/asecdf","@stdlib/math-base-special-asecf":"@stdlib/math/base/special/asecf","@stdlib/math-base-special-asech":"@stdlib/math/base/special/asech","@stdlib/math-base-special-asin":"@stdlib/math/base/special/asin","@stdlib/math-base-special-asind":"@stdlib/math/base/special/asind","@stdlib/math-base-special-asindf":"@stdlib/math/base/special/asindf","@stdlib/math-base-special-asinf":"@stdlib/math/base/special/asinf","@stdlib/math-base-special-asinh":"@stdlib/math/base/special/asinh","@stdlib/math-base-special-atan":"@stdlib/math/base/special/atan","@stdlib/math-base-special-atan2":"@stdlib/math/base/special/atan2","@stdlib/math-base-special-atand":"@stdlib/math/base/special/atand","@stdlib/math-base-special-atanf":"@stdlib/math/base/special/atanf","@stdlib/math-base-special-atanh":"@stdlib/math/base/special/atanh","@stdlib/math-base-special-avercos":"@stdlib/math/base/special/avercos","@stdlib/math-base-special-aversin":"@stdlib/math/base/special/aversin","@stdlib/array-base-zeros":"@stdlib/array/base/zeros","@stdlib/array-base-zeros2d":"@stdlib/array/base/zeros2d","@stdlib/array-base-zeros3d":"@stdlib/array/base/zeros3d","@stdlib/array-base-zeros4d":"@stdlib/array/base/zeros4d","@stdlib/array-base-zeros5d":"@stdlib/array/base/zeros5d","@stdlib/array-base-zerosnd":"@stdlib/array/base/zerosnd","@stdlib/array-base-zero-to":"@stdlib/array/base/zero-to","@stdlib/math-base-special-bernoulli":"@stdlib/math/base/special/bernoulli","@stdlib/math-base-special-besselj0":"@stdlib/math/base/special/besselj0","@stdlib/math-base-special-besselj1":"@stdlib/math/base/special/besselj1","@stdlib/math-base-special-bessely0":"@stdlib/math/base/special/bessely0","@stdlib/math-base-special-bessely1":"@stdlib/math/base/special/bessely1","@stdlib/math-base-special-beta":"@stdlib/math/base/special/beta","@stdlib/math-base-special-betainc":"@stdlib/math/base/special/betainc","@stdlib/math-base-special-betaincinv":"@stdlib/math/base/special/betaincinv","@stdlib/math-base-special-betaln":"@stdlib/math/base/special/betaln","@stdlib/math-base-special-binet":"@stdlib/math/base/special/binet","@stdlib/math-base-special-binomcoef":"@stdlib/math/base/special/binomcoef","@stdlib/math-base-special-binomcoefln":"@stdlib/math/base/special/binomcoefln","@stdlib/math-base-special-boxcox":"@stdlib/math/base/special/boxcox","@stdlib/math-base-special-boxcox1p":"@stdlib/math/base/special/boxcox1p","@stdlib/math-base-special-boxcox1pinv":"@stdlib/math/base/special/boxcox1pinv","@stdlib/math-base-special-boxcoxinv":"@stdlib/math/base/special/boxcoxinv","@stdlib/math-base-special-cabs":"@stdlib/math/base/special/cabs","@stdlib/math-base-special-cabs2":"@stdlib/math/base/special/cabs2","@stdlib/math-base-special-cabs2f":"@stdlib/math/base/special/cabs2f","@stdlib/math-base-special-cabsf":"@stdlib/math/base/special/cabsf","@stdlib/complex-float64-base-add":"@stdlib/complex/float64/base/add","@stdlib/complex-float32-base-add":"@stdlib/complex/float32/base/add","@stdlib/string-base-camelcase":"@stdlib/string/base/camelcase","@stdlib/string-base-capitalize":"@stdlib/string/base/capitalize","@stdlib/math-base-special-cbrt":"@stdlib/math/base/special/cbrt","@stdlib/math-base-special-cbrtf":"@stdlib/math/base/special/cbrtf","@stdlib/math-base-special-cceil":"@stdlib/math/base/special/cceil","@stdlib/math-base-special-cceilf":"@stdlib/math/base/special/cceilf","@stdlib/math-base-special-cceiln":"@stdlib/math/base/special/cceiln","@stdlib/math-base-special-ccis":"@stdlib/math/base/special/ccis","@stdlib/math-base-ops-cdiv":"@stdlib/math/base/ops/cdiv","@stdlib/math-base-special-ceil":"@stdlib/math/base/special/ceil","@stdlib/math-base-special-ceil2":"@stdlib/math/base/special/ceil2","@stdlib/math-base-special-ceil10":"@stdlib/math/base/special/ceil10","@stdlib/math-base-special-ceilb":"@stdlib/math/base/special/ceilb","@stdlib/math-base-special-ceilf":"@stdlib/math/base/special/ceilf","@stdlib/math-base-special-ceiln":"@stdlib/math/base/special/ceiln","@stdlib/math-base-special-ceilsd":"@stdlib/math/base/special/ceilsd","@stdlib/math-base-special-cexp":"@stdlib/math/base/special/cexp","@stdlib/math-base-special-cflipsign":"@stdlib/math/base/special/cflipsign","@stdlib/math-base-special-cflipsignf":"@stdlib/math/base/special/cflipsignf","@stdlib/math-base-special-cfloor":"@stdlib/math/base/special/cfloor","@stdlib/math-base-special-cfloorn":"@stdlib/math/base/special/cfloorn","@stdlib/math-base-special-cidentity":"@stdlib/math/base/special/cidentity","@stdlib/math-base-special-cidentityf":"@stdlib/math/base/special/cidentityf","@stdlib/math-base-special-cinv":"@stdlib/math/base/special/cinv","@stdlib/math-base-special-clamp":"@stdlib/math/base/special/clamp","@stdlib/math-base-special-clampf":"@stdlib/math/base/special/clampf","@stdlib/complex-float64-base-mul":"@stdlib/complex/float64/base/mul","@stdlib/complex-float32-base-mul":"@stdlib/complex/float32/base/mul","@stdlib/math-base-ops-cneg":"@stdlib/math/base/ops/cneg","@stdlib/math-base-ops-cnegf":"@stdlib/math/base/ops/cnegf","@stdlib/string-base-code-point-at":"@stdlib/string/base/code-point-at","@stdlib/string-base-constantcase":"@stdlib/string/base/constantcase","@stdlib/math-base-tools-continued-fraction":"@stdlib/math/base/tools/continued-fraction","@stdlib/math-base-special-copysign":"@stdlib/math/base/special/copysign","@stdlib/math-base-special-copysignf":"@stdlib/math/base/special/copysignf","@stdlib/math-base-special-cos":"@stdlib/math/base/special/cos","@stdlib/math-base-special-cosd":"@stdlib/math/base/special/cosd","@stdlib/math-base-special-cosh":"@stdlib/math/base/special/cosh","@stdlib/math-base-special-cosm1":"@stdlib/math/base/special/cosm1","@stdlib/math-base-special-cospi":"@stdlib/math/base/special/cospi","@stdlib/math-base-special-cot":"@stdlib/math/base/special/cot","@stdlib/math-base-special-cotd":"@stdlib/math/base/special/cotd","@stdlib/math-base-special-coth":"@stdlib/math/base/special/coth","@stdlib/math-base-special-covercos":"@stdlib/math/base/special/covercos","@stdlib/math-base-special-coversin":"@stdlib/math/base/special/coversin","@stdlib/math-base-special-cphase":"@stdlib/math/base/special/cphase","@stdlib/math-base-special-cpolar":"@stdlib/math/base/special/cpolar","@stdlib/math-base-special-cround":"@stdlib/math/base/special/cround","@stdlib/math-base-special-croundn":"@stdlib/math/base/special/croundn","@stdlib/math-base-special-csc":"@stdlib/math/base/special/csc","@stdlib/math-base-special-cscd":"@stdlib/math/base/special/cscd","@stdlib/math-base-special-csch":"@stdlib/math/base/special/csch","@stdlib/math-base-special-csignum":"@stdlib/math/base/special/csignum","@stdlib/math-base-ops-csub":"@stdlib/math/base/ops/csub","@stdlib/math-base-ops-csubf":"@stdlib/math/base/ops/csubf","@stdlib/math-base-special-deg2rad":"@stdlib/math/base/special/deg2rad","@stdlib/math-base-special-deg2radf":"@stdlib/math/base/special/deg2radf","@stdlib/math-base-special-digamma":"@stdlib/math/base/special/digamma","@stdlib/math-base-special-dirac-delta":"@stdlib/math/base/special/dirac-delta","@stdlib/number-float64-base-div":"@stdlib/number/float64/base/div","@stdlib/number-float32-base-div":"@stdlib/number/float32/base/div","@stdlib/string-base-dotcase":"@stdlib/string/base/dotcase","@stdlib/stats-base-dists-arcsine-ctor":"@stdlib/stats/base/dists/arcsine/ctor","@stdlib/stats-base-dists-arcsine-cdf":"@stdlib/stats/base/dists/arcsine/cdf","@stdlib/stats-base-dists-arcsine-entropy":"@stdlib/stats/base/dists/arcsine/entropy","@stdlib/stats-base-dists-arcsine-kurtosis":"@stdlib/stats/base/dists/arcsine/kurtosis","@stdlib/stats-base-dists-arcsine-logcdf":"@stdlib/stats/base/dists/arcsine/logcdf","@stdlib/stats-base-dists-arcsine-logpdf":"@stdlib/stats/base/dists/arcsine/logpdf","@stdlib/stats-base-dists-arcsine-mean":"@stdlib/stats/base/dists/arcsine/mean","@stdlib/stats-base-dists-arcsine-median":"@stdlib/stats/base/dists/arcsine/median","@stdlib/stats-base-dists-arcsine-mode":"@stdlib/stats/base/dists/arcsine/mode","@stdlib/stats-base-dists-arcsine-pdf":"@stdlib/stats/base/dists/arcsine/pdf","@stdlib/stats-base-dists-arcsine-quantile":"@stdlib/stats/base/dists/arcsine/quantile","@stdlib/stats-base-dists-arcsine-skewness":"@stdlib/stats/base/dists/arcsine/skewness","@stdlib/stats-base-dists-arcsine-stdev":"@stdlib/stats/base/dists/arcsine/stdev","@stdlib/stats-base-dists-arcsine-variance":"@stdlib/stats/base/dists/arcsine/variance","@stdlib/stats-base-dists-bernoulli-ctor":"@stdlib/stats/base/dists/bernoulli/ctor","@stdlib/stats-base-dists-bernoulli-cdf":"@stdlib/stats/base/dists/bernoulli/cdf","@stdlib/stats-base-dists-bernoulli-entropy":"@stdlib/stats/base/dists/bernoulli/entropy","@stdlib/stats-base-dists-bernoulli-kurtosis":"@stdlib/stats/base/dists/bernoulli/kurtosis","@stdlib/stats-base-dists-bernoulli-mean":"@stdlib/stats/base/dists/bernoulli/mean","@stdlib/stats-base-dists-bernoulli-median":"@stdlib/stats/base/dists/bernoulli/median","@stdlib/stats-base-dists-bernoulli-mgf":"@stdlib/stats/base/dists/bernoulli/mgf","@stdlib/stats-base-dists-bernoulli-mode":"@stdlib/stats/base/dists/bernoulli/mode","@stdlib/stats-base-dists-bernoulli-pmf":"@stdlib/stats/base/dists/bernoulli/pmf","@stdlib/stats-base-dists-bernoulli-quantile":"@stdlib/stats/base/dists/bernoulli/quantile","@stdlib/stats-base-dists-bernoulli-skewness":"@stdlib/stats/base/dists/bernoulli/skewness","@stdlib/stats-base-dists-bernoulli-stdev":"@stdlib/stats/base/dists/bernoulli/stdev","@stdlib/stats-base-dists-bernoulli-variance":"@stdlib/stats/base/dists/bernoulli/variance","@stdlib/stats-base-dists-beta-ctor":"@stdlib/stats/base/dists/beta/ctor","@stdlib/stats-base-dists-beta-cdf":"@stdlib/stats/base/dists/beta/cdf","@stdlib/stats-base-dists-beta-entropy":"@stdlib/stats/base/dists/beta/entropy","@stdlib/stats-base-dists-beta-kurtosis":"@stdlib/stats/base/dists/beta/kurtosis","@stdlib/stats-base-dists-beta-logcdf":"@stdlib/stats/base/dists/beta/logcdf","@stdlib/stats-base-dists-beta-logpdf":"@stdlib/stats/base/dists/beta/logpdf","@stdlib/stats-base-dists-beta-mean":"@stdlib/stats/base/dists/beta/mean","@stdlib/stats-base-dists-beta-median":"@stdlib/stats/base/dists/beta/median","@stdlib/stats-base-dists-beta-mgf":"@stdlib/stats/base/dists/beta/mgf","@stdlib/stats-base-dists-beta-mode":"@stdlib/stats/base/dists/beta/mode","@stdlib/stats-base-dists-beta-pdf":"@stdlib/stats/base/dists/beta/pdf","@stdlib/stats-base-dists-beta-quantile":"@stdlib/stats/base/dists/beta/quantile","@stdlib/stats-base-dists-beta-skewness":"@stdlib/stats/base/dists/beta/skewness","@stdlib/stats-base-dists-beta-stdev":"@stdlib/stats/base/dists/beta/stdev","@stdlib/stats-base-dists-beta-variance":"@stdlib/stats/base/dists/beta/variance","@stdlib/stats-base-dists-betaprime-ctor":"@stdlib/stats/base/dists/betaprime/ctor","@stdlib/stats-base-dists-betaprime-cdf":"@stdlib/stats/base/dists/betaprime/cdf","@stdlib/stats-base-dists-betaprime-kurtosis":"@stdlib/stats/base/dists/betaprime/kurtosis","@stdlib/stats-base-dists-betaprime-logcdf":"@stdlib/stats/base/dists/betaprime/logcdf","@stdlib/stats-base-dists-betaprime-logpdf":"@stdlib/stats/base/dists/betaprime/logpdf","@stdlib/stats-base-dists-betaprime-mean":"@stdlib/stats/base/dists/betaprime/mean","@stdlib/stats-base-dists-betaprime-mode":"@stdlib/stats/base/dists/betaprime/mode","@stdlib/stats-base-dists-betaprime-pdf":"@stdlib/stats/base/dists/betaprime/pdf","@stdlib/stats-base-dists-betaprime-quantile":"@stdlib/stats/base/dists/betaprime/quantile","@stdlib/stats-base-dists-betaprime-skewness":"@stdlib/stats/base/dists/betaprime/skewness","@stdlib/stats-base-dists-betaprime-stdev":"@stdlib/stats/base/dists/betaprime/stdev","@stdlib/stats-base-dists-betaprime-variance":"@stdlib/stats/base/dists/betaprime/variance","@stdlib/stats-base-dists-binomial-ctor":"@stdlib/stats/base/dists/binomial/ctor","@stdlib/stats-base-dists-binomial-cdf":"@stdlib/stats/base/dists/binomial/cdf","@stdlib/stats-base-dists-binomial-entropy":"@stdlib/stats/base/dists/binomial/entropy","@stdlib/stats-base-dists-binomial-kurtosis":"@stdlib/stats/base/dists/binomial/kurtosis","@stdlib/stats-base-dists-binomial-logpmf":"@stdlib/stats/base/dists/binomial/logpmf","@stdlib/stats-base-dists-binomial-mean":"@stdlib/stats/base/dists/binomial/mean","@stdlib/stats-base-dists-binomial-median":"@stdlib/stats/base/dists/binomial/median","@stdlib/stats-base-dists-binomial-mgf":"@stdlib/stats/base/dists/binomial/mgf","@stdlib/stats-base-dists-binomial-mode":"@stdlib/stats/base/dists/binomial/mode","@stdlib/stats-base-dists-binomial-pmf":"@stdlib/stats/base/dists/binomial/pmf","@stdlib/stats-base-dists-binomial-quantile":"@stdlib/stats/base/dists/binomial/quantile","@stdlib/stats-base-dists-binomial-skewness":"@stdlib/stats/base/dists/binomial/skewness","@stdlib/stats-base-dists-binomial-stdev":"@stdlib/stats/base/dists/binomial/stdev","@stdlib/stats-base-dists-binomial-variance":"@stdlib/stats/base/dists/binomial/variance","@stdlib/stats-base-dists-cauchy-ctor":"@stdlib/stats/base/dists/cauchy/ctor","@stdlib/stats-base-dists-cauchy-cdf":"@stdlib/stats/base/dists/cauchy/cdf","@stdlib/stats-base-dists-cauchy-entropy":"@stdlib/stats/base/dists/cauchy/entropy","@stdlib/stats-base-dists-cauchy-logcdf":"@stdlib/stats/base/dists/cauchy/logcdf","@stdlib/stats-base-dists-cauchy-logpdf":"@stdlib/stats/base/dists/cauchy/logpdf","@stdlib/stats-base-dists-cauchy-median":"@stdlib/stats/base/dists/cauchy/median","@stdlib/stats-base-dists-cauchy-mode":"@stdlib/stats/base/dists/cauchy/mode","@stdlib/stats-base-dists-cauchy-pdf":"@stdlib/stats/base/dists/cauchy/pdf","@stdlib/stats-base-dists-cauchy-quantile":"@stdlib/stats/base/dists/cauchy/quantile","@stdlib/stats-base-dists-chi-cdf":"@stdlib/stats/base/dists/chi/cdf","@stdlib/stats-base-dists-chi-ctor":"@stdlib/stats/base/dists/chi/ctor","@stdlib/stats-base-dists-chi-entropy":"@stdlib/stats/base/dists/chi/entropy","@stdlib/stats-base-dists-chi-kurtosis":"@stdlib/stats/base/dists/chi/kurtosis","@stdlib/stats-base-dists-chi-logpdf":"@stdlib/stats/base/dists/chi/logpdf","@stdlib/stats-base-dists-chi-mean":"@stdlib/stats/base/dists/chi/mean","@stdlib/stats-base-dists-chi-mode":"@stdlib/stats/base/dists/chi/mode","@stdlib/stats-base-dists-chi-pdf":"@stdlib/stats/base/dists/chi/pdf","@stdlib/stats-base-dists-chi-quantile":"@stdlib/stats/base/dists/chi/quantile","@stdlib/stats-base-dists-chi-skewness":"@stdlib/stats/base/dists/chi/skewness","@stdlib/stats-base-dists-chi-stdev":"@stdlib/stats/base/dists/chi/stdev","@stdlib/stats-base-dists-chi-variance":"@stdlib/stats/base/dists/chi/variance","@stdlib/stats-base-dists-chisquare-cdf":"@stdlib/stats/base/dists/chisquare/cdf","@stdlib/stats-base-dists-chisquare-ctor":"@stdlib/stats/base/dists/chisquare/ctor","@stdlib/stats-base-dists-chisquare-entropy":"@stdlib/stats/base/dists/chisquare/entropy","@stdlib/stats-base-dists-chisquare-kurtosis":"@stdlib/stats/base/dists/chisquare/kurtosis","@stdlib/stats-base-dists-chisquare-logpdf":"@stdlib/stats/base/dists/chisquare/logpdf","@stdlib/stats-base-dists-chisquare-mean":"@stdlib/stats/base/dists/chisquare/mean","@stdlib/stats-base-dists-chisquare-median":"@stdlib/stats/base/dists/chisquare/median","@stdlib/stats-base-dists-chisquare-mgf":"@stdlib/stats/base/dists/chisquare/mgf","@stdlib/stats-base-dists-chisquare-mode":"@stdlib/stats/base/dists/chisquare/mode","@stdlib/stats-base-dists-chisquare-pdf":"@stdlib/stats/base/dists/chisquare/pdf","@stdlib/stats-base-dists-chisquare-quantile":"@stdlib/stats/base/dists/chisquare/quantile","@stdlib/stats-base-dists-chisquare-skewness":"@stdlib/stats/base/dists/chisquare/skewness","@stdlib/stats-base-dists-chisquare-stdev":"@stdlib/stats/base/dists/chisquare/stdev","@stdlib/stats-base-dists-chisquare-variance":"@stdlib/stats/base/dists/chisquare/variance","@stdlib/stats-base-dists-cosine-cdf":"@stdlib/stats/base/dists/cosine/cdf","@stdlib/stats-base-dists-cosine-ctor":"@stdlib/stats/base/dists/cosine/ctor","@stdlib/stats-base-dists-cosine-kurtosis":"@stdlib/stats/base/dists/cosine/kurtosis","@stdlib/stats-base-dists-cosine-logcdf":"@stdlib/stats/base/dists/cosine/logcdf","@stdlib/stats-base-dists-cosine-logpdf":"@stdlib/stats/base/dists/cosine/logpdf","@stdlib/stats-base-dists-cosine-mean":"@stdlib/stats/base/dists/cosine/mean","@stdlib/stats-base-dists-cosine-median":"@stdlib/stats/base/dists/cosine/median","@stdlib/stats-base-dists-cosine-mgf":"@stdlib/stats/base/dists/cosine/mgf","@stdlib/stats-base-dists-cosine-mode":"@stdlib/stats/base/dists/cosine/mode","@stdlib/stats-base-dists-cosine-pdf":"@stdlib/stats/base/dists/cosine/pdf","@stdlib/stats-base-dists-cosine-quantile":"@stdlib/stats/base/dists/cosine/quantile","@stdlib/stats-base-dists-cosine-skewness":"@stdlib/stats/base/dists/cosine/skewness","@stdlib/stats-base-dists-cosine-stdev":"@stdlib/stats/base/dists/cosine/stdev","@stdlib/stats-base-dists-cosine-variance":"@stdlib/stats/base/dists/cosine/variance","@stdlib/stats-base-dists-degenerate-cdf":"@stdlib/stats/base/dists/degenerate/cdf","@stdlib/stats-base-dists-degenerate-ctor":"@stdlib/stats/base/dists/degenerate/ctor","@stdlib/stats-base-dists-degenerate-entropy":"@stdlib/stats/base/dists/degenerate/entropy","@stdlib/stats-base-dists-degenerate-logcdf":"@stdlib/stats/base/dists/degenerate/logcdf","@stdlib/stats-base-dists-degenerate-logpdf":"@stdlib/stats/base/dists/degenerate/logpdf","@stdlib/stats-base-dists-degenerate-logpmf":"@stdlib/stats/base/dists/degenerate/logpmf","@stdlib/stats-base-dists-degenerate-mean":"@stdlib/stats/base/dists/degenerate/mean","@stdlib/stats-base-dists-degenerate-median":"@stdlib/stats/base/dists/degenerate/median","@stdlib/stats-base-dists-degenerate-mgf":"@stdlib/stats/base/dists/degenerate/mgf","@stdlib/stats-base-dists-degenerate-mode":"@stdlib/stats/base/dists/degenerate/mode","@stdlib/stats-base-dists-degenerate-pdf":"@stdlib/stats/base/dists/degenerate/pdf","@stdlib/stats-base-dists-degenerate-pmf":"@stdlib/stats/base/dists/degenerate/pmf","@stdlib/stats-base-dists-degenerate-quantile":"@stdlib/stats/base/dists/degenerate/quantile","@stdlib/stats-base-dists-degenerate-stdev":"@stdlib/stats/base/dists/degenerate/stdev","@stdlib/stats-base-dists-degenerate-variance":"@stdlib/stats/base/dists/degenerate/variance","@stdlib/stats-base-dists-discrete-uniform-cdf":"@stdlib/stats/base/dists/discrete-uniform/cdf","@stdlib/stats-base-dists-discrete-uniform-ctor":"@stdlib/stats/base/dists/discrete-uniform/ctor","@stdlib/stats-base-dists-discrete-uniform-entropy":"@stdlib/stats/base/dists/discrete-uniform/entropy","@stdlib/stats-base-dists-discrete-uniform-kurtosis":"@stdlib/stats/base/dists/discrete-uniform/kurtosis","@stdlib/stats-base-dists-discrete-uniform-logcdf":"@stdlib/stats/base/dists/discrete-uniform/logcdf","@stdlib/stats-base-dists-discrete-uniform-logpmf":"@stdlib/stats/base/dists/discrete-uniform/logpmf","@stdlib/stats-base-dists-discrete-uniform-mean":"@stdlib/stats/base/dists/discrete-uniform/mean","@stdlib/stats-base-dists-discrete-uniform-median":"@stdlib/stats/base/dists/discrete-uniform/median","@stdlib/stats-base-dists-discrete-uniform-mgf":"@stdlib/stats/base/dists/discrete-uniform/mgf","@stdlib/stats-base-dists-discrete-uniform-pmf":"@stdlib/stats/base/dists/discrete-uniform/pmf","@stdlib/stats-base-dists-discrete-uniform-quantile":"@stdlib/stats/base/dists/discrete-uniform/quantile","@stdlib/stats-base-dists-discrete-uniform-skewness":"@stdlib/stats/base/dists/discrete-uniform/skewness","@stdlib/stats-base-dists-discrete-uniform-stdev":"@stdlib/stats/base/dists/discrete-uniform/stdev","@stdlib/stats-base-dists-discrete-uniform-variance":"@stdlib/stats/base/dists/discrete-uniform/variance","@stdlib/stats-base-dists-erlang-cdf":"@stdlib/stats/base/dists/erlang/cdf","@stdlib/stats-base-dists-erlang-entropy":"@stdlib/stats/base/dists/erlang/entropy","@stdlib/stats-base-dists-erlang-ctor":"@stdlib/stats/base/dists/erlang/ctor","@stdlib/stats-base-dists-erlang-kurtosis":"@stdlib/stats/base/dists/erlang/kurtosis","@stdlib/stats-base-dists-erlang-logpdf":"@stdlib/stats/base/dists/erlang/logpdf","@stdlib/stats-base-dists-erlang-mean":"@stdlib/stats/base/dists/erlang/mean","@stdlib/stats-base-dists-erlang-mgf":"@stdlib/stats/base/dists/erlang/mgf","@stdlib/stats-base-dists-erlang-mode":"@stdlib/stats/base/dists/erlang/mode","@stdlib/stats-base-dists-erlang-pdf":"@stdlib/stats/base/dists/erlang/pdf","@stdlib/stats-base-dists-erlang-quantile":"@stdlib/stats/base/dists/erlang/quantile","@stdlib/stats-base-dists-erlang-skewness":"@stdlib/stats/base/dists/erlang/skewness","@stdlib/stats-base-dists-erlang-stdev":"@stdlib/stats/base/dists/erlang/stdev","@stdlib/stats-base-dists-erlang-variance":"@stdlib/stats/base/dists/erlang/variance","@stdlib/stats-base-dists-exponential-cdf":"@stdlib/stats/base/dists/exponential/cdf","@stdlib/stats-base-dists-exponential-entropy":"@stdlib/stats/base/dists/exponential/entropy","@stdlib/stats-base-dists-exponential-ctor":"@stdlib/stats/base/dists/exponential/ctor","@stdlib/stats-base-dists-exponential-kurtosis":"@stdlib/stats/base/dists/exponential/kurtosis","@stdlib/stats-base-dists-exponential-logcdf":"@stdlib/stats/base/dists/exponential/logcdf","@stdlib/stats-base-dists-exponential-logpdf":"@stdlib/stats/base/dists/exponential/logpdf","@stdlib/stats-base-dists-exponential-mean":"@stdlib/stats/base/dists/exponential/mean","@stdlib/stats-base-dists-exponential-median":"@stdlib/stats/base/dists/exponential/median","@stdlib/stats-base-dists-exponential-mgf":"@stdlib/stats/base/dists/exponential/mgf","@stdlib/stats-base-dists-exponential-mode":"@stdlib/stats/base/dists/exponential/mode","@stdlib/stats-base-dists-exponential-pdf":"@stdlib/stats/base/dists/exponential/pdf","@stdlib/stats-base-dists-exponential-quantile":"@stdlib/stats/base/dists/exponential/quantile","@stdlib/stats-base-dists-exponential-skewness":"@stdlib/stats/base/dists/exponential/skewness","@stdlib/stats-base-dists-exponential-stdev":"@stdlib/stats/base/dists/exponential/stdev","@stdlib/stats-base-dists-exponential-variance":"@stdlib/stats/base/dists/exponential/variance","@stdlib/stats-base-dists-f-cdf":"@stdlib/stats/base/dists/f/cdf","@stdlib/stats-base-dists-f-entropy":"@stdlib/stats/base/dists/f/entropy","@stdlib/stats-base-dists-f-ctor":"@stdlib/stats/base/dists/f/ctor","@stdlib/stats-base-dists-f-kurtosis":"@stdlib/stats/base/dists/f/kurtosis","@stdlib/stats-base-dists-f-mean":"@stdlib/stats/base/dists/f/mean","@stdlib/stats-base-dists-f-mode":"@stdlib/stats/base/dists/f/mode","@stdlib/stats-base-dists-f-pdf":"@stdlib/stats/base/dists/f/pdf","@stdlib/stats-base-dists-f-quantile":"@stdlib/stats/base/dists/f/quantile","@stdlib/stats-base-dists-f-skewness":"@stdlib/stats/base/dists/f/skewness","@stdlib/stats-base-dists-f-stdev":"@stdlib/stats/base/dists/f/stdev","@stdlib/stats-base-dists-f-variance":"@stdlib/stats/base/dists/f/variance","@stdlib/stats-base-dists-frechet-cdf":"@stdlib/stats/base/dists/frechet/cdf","@stdlib/stats-base-dists-frechet-entropy":"@stdlib/stats/base/dists/frechet/entropy","@stdlib/stats-base-dists-frechet-ctor":"@stdlib/stats/base/dists/frechet/ctor","@stdlib/stats-base-dists-frechet-kurtosis":"@stdlib/stats/base/dists/frechet/kurtosis","@stdlib/stats-base-dists-frechet-logcdf":"@stdlib/stats/base/dists/frechet/logcdf","@stdlib/stats-base-dists-frechet-logpdf":"@stdlib/stats/base/dists/frechet/logpdf","@stdlib/stats-base-dists-frechet-mean":"@stdlib/stats/base/dists/frechet/mean","@stdlib/stats-base-dists-frechet-median":"@stdlib/stats/base/dists/frechet/median","@stdlib/stats-base-dists-frechet-mode":"@stdlib/stats/base/dists/frechet/mode","@stdlib/stats-base-dists-frechet-pdf":"@stdlib/stats/base/dists/frechet/pdf","@stdlib/stats-base-dists-frechet-quantile":"@stdlib/stats/base/dists/frechet/quantile","@stdlib/stats-base-dists-frechet-skewness":"@stdlib/stats/base/dists/frechet/skewness","@stdlib/stats-base-dists-frechet-stdev":"@stdlib/stats/base/dists/frechet/stdev","@stdlib/stats-base-dists-frechet-variance":"@stdlib/stats/base/dists/frechet/variance","@stdlib/stats-base-dists-gamma-cdf":"@stdlib/stats/base/dists/gamma/cdf","@stdlib/stats-base-dists-gamma-entropy":"@stdlib/stats/base/dists/gamma/entropy","@stdlib/stats-base-dists-gamma-ctor":"@stdlib/stats/base/dists/gamma/ctor","@stdlib/stats-base-dists-gamma-kurtosis":"@stdlib/stats/base/dists/gamma/kurtosis","@stdlib/stats-base-dists-gamma-logcdf":"@stdlib/stats/base/dists/gamma/logcdf","@stdlib/stats-base-dists-gamma-logpdf":"@stdlib/stats/base/dists/gamma/logpdf","@stdlib/stats-base-dists-gamma-mean":"@stdlib/stats/base/dists/gamma/mean","@stdlib/stats-base-dists-gamma-mgf":"@stdlib/stats/base/dists/gamma/mgf","@stdlib/stats-base-dists-gamma-mode":"@stdlib/stats/base/dists/gamma/mode","@stdlib/stats-base-dists-gamma-pdf":"@stdlib/stats/base/dists/gamma/pdf","@stdlib/stats-base-dists-gamma-quantile":"@stdlib/stats/base/dists/gamma/quantile","@stdlib/stats-base-dists-gamma-skewness":"@stdlib/stats/base/dists/gamma/skewness","@stdlib/stats-base-dists-gamma-stdev":"@stdlib/stats/base/dists/gamma/stdev","@stdlib/stats-base-dists-gamma-variance":"@stdlib/stats/base/dists/gamma/variance","@stdlib/stats-base-dists-geometric-cdf":"@stdlib/stats/base/dists/geometric/cdf","@stdlib/stats-base-dists-geometric-entropy":"@stdlib/stats/base/dists/geometric/entropy","@stdlib/stats-base-dists-geometric-ctor":"@stdlib/stats/base/dists/geometric/ctor","@stdlib/stats-base-dists-geometric-kurtosis":"@stdlib/stats/base/dists/geometric/kurtosis","@stdlib/stats-base-dists-geometric-logcdf":"@stdlib/stats/base/dists/geometric/logcdf","@stdlib/stats-base-dists-geometric-logpmf":"@stdlib/stats/base/dists/geometric/logpmf","@stdlib/stats-base-dists-geometric-mean":"@stdlib/stats/base/dists/geometric/mean","@stdlib/stats-base-dists-geometric-median":"@stdlib/stats/base/dists/geometric/median","@stdlib/stats-base-dists-geometric-mgf":"@stdlib/stats/base/dists/geometric/mgf","@stdlib/stats-base-dists-geometric-mode":"@stdlib/stats/base/dists/geometric/mode","@stdlib/stats-base-dists-geometric-pmf":"@stdlib/stats/base/dists/geometric/pmf","@stdlib/stats-base-dists-geometric-quantile":"@stdlib/stats/base/dists/geometric/quantile","@stdlib/stats-base-dists-geometric-skewness":"@stdlib/stats/base/dists/geometric/skewness","@stdlib/stats-base-dists-geometric-stdev":"@stdlib/stats/base/dists/geometric/stdev","@stdlib/stats-base-dists-geometric-variance":"@stdlib/stats/base/dists/geometric/variance","@stdlib/stats-base-dists-gumbel-cdf":"@stdlib/stats/base/dists/gumbel/cdf","@stdlib/stats-base-dists-gumbel-entropy":"@stdlib/stats/base/dists/gumbel/entropy","@stdlib/stats-base-dists-gumbel-ctor":"@stdlib/stats/base/dists/gumbel/ctor","@stdlib/stats-base-dists-gumbel-kurtosis":"@stdlib/stats/base/dists/gumbel/kurtosis","@stdlib/stats-base-dists-gumbel-logcdf":"@stdlib/stats/base/dists/gumbel/logcdf","@stdlib/stats-base-dists-gumbel-logpdf":"@stdlib/stats/base/dists/gumbel/logpdf","@stdlib/stats-base-dists-gumbel-mean":"@stdlib/stats/base/dists/gumbel/mean","@stdlib/stats-base-dists-gumbel-median":"@stdlib/stats/base/dists/gumbel/median","@stdlib/stats-base-dists-gumbel-mgf":"@stdlib/stats/base/dists/gumbel/mgf","@stdlib/stats-base-dists-gumbel-mode":"@stdlib/stats/base/dists/gumbel/mode","@stdlib/stats-base-dists-gumbel-pdf":"@stdlib/stats/base/dists/gumbel/pdf","@stdlib/stats-base-dists-gumbel-quantile":"@stdlib/stats/base/dists/gumbel/quantile","@stdlib/stats-base-dists-gumbel-skewness":"@stdlib/stats/base/dists/gumbel/skewness","@stdlib/stats-base-dists-gumbel-stdev":"@stdlib/stats/base/dists/gumbel/stdev","@stdlib/stats-base-dists-gumbel-variance":"@stdlib/stats/base/dists/gumbel/variance","@stdlib/stats-base-dists-hypergeometric-cdf":"@stdlib/stats/base/dists/hypergeometric/cdf","@stdlib/stats-base-dists-hypergeometric-ctor":"@stdlib/stats/base/dists/hypergeometric/ctor","@stdlib/stats-base-dists-hypergeometric-kurtosis":"@stdlib/stats/base/dists/hypergeometric/kurtosis","@stdlib/stats-base-dists-hypergeometric-logpmf":"@stdlib/stats/base/dists/hypergeometric/logpmf","@stdlib/stats-base-dists-hypergeometric-mean":"@stdlib/stats/base/dists/hypergeometric/mean","@stdlib/stats-base-dists-hypergeometric-mode":"@stdlib/stats/base/dists/hypergeometric/mode","@stdlib/stats-base-dists-hypergeometric-pmf":"@stdlib/stats/base/dists/hypergeometric/pmf","@stdlib/stats-base-dists-hypergeometric-quantile":"@stdlib/stats/base/dists/hypergeometric/quantile","@stdlib/stats-base-dists-hypergeometric-skewness":"@stdlib/stats/base/dists/hypergeometric/skewness","@stdlib/stats-base-dists-hypergeometric-stdev":"@stdlib/stats/base/dists/hypergeometric/stdev","@stdlib/stats-base-dists-hypergeometric-variance":"@stdlib/stats/base/dists/hypergeometric/variance","@stdlib/stats-base-dists-invgamma-cdf":"@stdlib/stats/base/dists/invgamma/cdf","@stdlib/stats-base-dists-invgamma-entropy":"@stdlib/stats/base/dists/invgamma/entropy","@stdlib/stats-base-dists-invgamma-ctor":"@stdlib/stats/base/dists/invgamma/ctor","@stdlib/stats-base-dists-invgamma-kurtosis":"@stdlib/stats/base/dists/invgamma/kurtosis","@stdlib/stats-base-dists-invgamma-logpdf":"@stdlib/stats/base/dists/invgamma/logpdf","@stdlib/stats-base-dists-invgamma-mean":"@stdlib/stats/base/dists/invgamma/mean","@stdlib/stats-base-dists-invgamma-mode":"@stdlib/stats/base/dists/invgamma/mode","@stdlib/stats-base-dists-invgamma-pdf":"@stdlib/stats/base/dists/invgamma/pdf","@stdlib/stats-base-dists-invgamma-quantile":"@stdlib/stats/base/dists/invgamma/quantile","@stdlib/stats-base-dists-invgamma-skewness":"@stdlib/stats/base/dists/invgamma/skewness","@stdlib/stats-base-dists-invgamma-stdev":"@stdlib/stats/base/dists/invgamma/stdev","@stdlib/stats-base-dists-invgamma-variance":"@stdlib/stats/base/dists/invgamma/variance","@stdlib/stats-base-dists-kumaraswamy-cdf":"@stdlib/stats/base/dists/kumaraswamy/cdf","@stdlib/stats-base-dists-kumaraswamy-ctor":"@stdlib/stats/base/dists/kumaraswamy/ctor","@stdlib/stats-base-dists-kumaraswamy-kurtosis":"@stdlib/stats/base/dists/kumaraswamy/kurtosis","@stdlib/stats-base-dists-kumaraswamy-logcdf":"@stdlib/stats/base/dists/kumaraswamy/logcdf","@stdlib/stats-base-dists-kumaraswamy-logpdf":"@stdlib/stats/base/dists/kumaraswamy/logpdf","@stdlib/stats-base-dists-kumaraswamy-mean":"@stdlib/stats/base/dists/kumaraswamy/mean","@stdlib/stats-base-dists-kumaraswamy-median":"@stdlib/stats/base/dists/kumaraswamy/median","@stdlib/stats-base-dists-kumaraswamy-mode":"@stdlib/stats/base/dists/kumaraswamy/mode","@stdlib/stats-base-dists-kumaraswamy-pdf":"@stdlib/stats/base/dists/kumaraswamy/pdf","@stdlib/stats-base-dists-kumaraswamy-quantile":"@stdlib/stats/base/dists/kumaraswamy/quantile","@stdlib/stats-base-dists-kumaraswamy-skewness":"@stdlib/stats/base/dists/kumaraswamy/skewness","@stdlib/stats-base-dists-kumaraswamy-stdev":"@stdlib/stats/base/dists/kumaraswamy/stdev","@stdlib/stats-base-dists-kumaraswamy-variance":"@stdlib/stats/base/dists/kumaraswamy/variance","@stdlib/stats-base-dists-laplace-cdf":"@stdlib/stats/base/dists/laplace/cdf","@stdlib/stats-base-dists-laplace-entropy":"@stdlib/stats/base/dists/laplace/entropy","@stdlib/stats-base-dists-laplace-kurtosis":"@stdlib/stats/base/dists/laplace/kurtosis","@stdlib/stats-base-dists-laplace-ctor":"@stdlib/stats/base/dists/laplace/ctor","@stdlib/stats-base-dists-laplace-logcdf":"@stdlib/stats/base/dists/laplace/logcdf","@stdlib/stats-base-dists-laplace-logpdf":"@stdlib/stats/base/dists/laplace/logpdf","@stdlib/stats-base-dists-laplace-mean":"@stdlib/stats/base/dists/laplace/mean","@stdlib/stats-base-dists-laplace-median":"@stdlib/stats/base/dists/laplace/median","@stdlib/stats-base-dists-laplace-mgf":"@stdlib/stats/base/dists/laplace/mgf","@stdlib/stats-base-dists-laplace-mode":"@stdlib/stats/base/dists/laplace/mode","@stdlib/stats-base-dists-laplace-pdf":"@stdlib/stats/base/dists/laplace/pdf","@stdlib/stats-base-dists-laplace-quantile":"@stdlib/stats/base/dists/laplace/quantile","@stdlib/stats-base-dists-laplace-skewness":"@stdlib/stats/base/dists/laplace/skewness","@stdlib/stats-base-dists-laplace-stdev":"@stdlib/stats/base/dists/laplace/stdev","@stdlib/stats-base-dists-laplace-variance":"@stdlib/stats/base/dists/laplace/variance","@stdlib/stats-base-dists-levy-cdf":"@stdlib/stats/base/dists/levy/cdf","@stdlib/stats-base-dists-levy-entropy":"@stdlib/stats/base/dists/levy/entropy","@stdlib/stats-base-dists-levy-ctor":"@stdlib/stats/base/dists/levy/ctor","@stdlib/stats-base-dists-levy-logcdf":"@stdlib/stats/base/dists/levy/logcdf","@stdlib/stats-base-dists-levy-logpdf":"@stdlib/stats/base/dists/levy/logpdf","@stdlib/stats-base-dists-levy-mean":"@stdlib/stats/base/dists/levy/mean","@stdlib/stats-base-dists-levy-median":"@stdlib/stats/base/dists/levy/median","@stdlib/stats-base-dists-levy-mode":"@stdlib/stats/base/dists/levy/mode","@stdlib/stats-base-dists-levy-pdf":"@stdlib/stats/base/dists/levy/pdf","@stdlib/stats-base-dists-levy-quantile":"@stdlib/stats/base/dists/levy/quantile","@stdlib/stats-base-dists-levy-stdev":"@stdlib/stats/base/dists/levy/stdev","@stdlib/stats-base-dists-levy-variance":"@stdlib/stats/base/dists/levy/variance","@stdlib/stats-base-dists-logistic-cdf":"@stdlib/stats/base/dists/logistic/cdf","@stdlib/stats-base-dists-logistic-entropy":"@stdlib/stats/base/dists/logistic/entropy","@stdlib/stats-base-dists-logistic-kurtosis":"@stdlib/stats/base/dists/logistic/kurtosis","@stdlib/stats-base-dists-logistic-logcdf":"@stdlib/stats/base/dists/logistic/logcdf","@stdlib/stats-base-dists-logistic-ctor":"@stdlib/stats/base/dists/logistic/ctor","@stdlib/stats-base-dists-logistic-logpdf":"@stdlib/stats/base/dists/logistic/logpdf","@stdlib/stats-base-dists-logistic-mean":"@stdlib/stats/base/dists/logistic/mean","@stdlib/stats-base-dists-logistic-median":"@stdlib/stats/base/dists/logistic/median","@stdlib/stats-base-dists-logistic-mgf":"@stdlib/stats/base/dists/logistic/mgf","@stdlib/stats-base-dists-logistic-mode":"@stdlib/stats/base/dists/logistic/mode","@stdlib/stats-base-dists-logistic-pdf":"@stdlib/stats/base/dists/logistic/pdf","@stdlib/stats-base-dists-logistic-quantile":"@stdlib/stats/base/dists/logistic/quantile","@stdlib/stats-base-dists-logistic-skewness":"@stdlib/stats/base/dists/logistic/skewness","@stdlib/stats-base-dists-logistic-stdev":"@stdlib/stats/base/dists/logistic/stdev","@stdlib/stats-base-dists-logistic-variance":"@stdlib/stats/base/dists/logistic/variance","@stdlib/stats-base-dists-lognormal-cdf":"@stdlib/stats/base/dists/lognormal/cdf","@stdlib/stats-base-dists-lognormal-entropy":"@stdlib/stats/base/dists/lognormal/entropy","@stdlib/stats-base-dists-lognormal-kurtosis":"@stdlib/stats/base/dists/lognormal/kurtosis","@stdlib/stats-base-dists-lognormal-ctor":"@stdlib/stats/base/dists/lognormal/ctor","@stdlib/stats-base-dists-lognormal-logcdf":"@stdlib/stats/base/dists/lognormal/logcdf","@stdlib/stats-base-dists-lognormal-logpdf":"@stdlib/stats/base/dists/lognormal/logpdf","@stdlib/stats-base-dists-lognormal-mean":"@stdlib/stats/base/dists/lognormal/mean","@stdlib/stats-base-dists-lognormal-median":"@stdlib/stats/base/dists/lognormal/median","@stdlib/stats-base-dists-lognormal-mode":"@stdlib/stats/base/dists/lognormal/mode","@stdlib/stats-base-dists-lognormal-pdf":"@stdlib/stats/base/dists/lognormal/pdf","@stdlib/stats-base-dists-lognormal-quantile":"@stdlib/stats/base/dists/lognormal/quantile","@stdlib/stats-base-dists-lognormal-skewness":"@stdlib/stats/base/dists/lognormal/skewness","@stdlib/stats-base-dists-lognormal-stdev":"@stdlib/stats/base/dists/lognormal/stdev","@stdlib/stats-base-dists-lognormal-variance":"@stdlib/stats/base/dists/lognormal/variance","@stdlib/stats-base-dists-negative-binomial-cdf":"@stdlib/stats/base/dists/negative-binomial/cdf","@stdlib/stats-base-dists-negative-binomial-kurtosis":"@stdlib/stats/base/dists/negative-binomial/kurtosis","@stdlib/stats-base-dists-negative-binomial-logpmf":"@stdlib/stats/base/dists/negative-binomial/logpmf","@stdlib/stats-base-dists-negative-binomial-mean":"@stdlib/stats/base/dists/negative-binomial/mean","@stdlib/stats-base-dists-negative-binomial-mgf":"@stdlib/stats/base/dists/negative-binomial/mgf","@stdlib/stats-base-dists-negative-binomial-mode":"@stdlib/stats/base/dists/negative-binomial/mode","@stdlib/stats-base-dists-negative-binomial-ctor":"@stdlib/stats/base/dists/negative-binomial/ctor","@stdlib/stats-base-dists-negative-binomial-pmf":"@stdlib/stats/base/dists/negative-binomial/pmf","@stdlib/stats-base-dists-negative-binomial-quantile":"@stdlib/stats/base/dists/negative-binomial/quantile","@stdlib/stats-base-dists-negative-binomial-skewness":"@stdlib/stats/base/dists/negative-binomial/skewness","@stdlib/stats-base-dists-negative-binomial-stdev":"@stdlib/stats/base/dists/negative-binomial/stdev","@stdlib/stats-base-dists-negative-binomial-variance":"@stdlib/stats/base/dists/negative-binomial/variance","@stdlib/stats-base-dists-normal-cdf":"@stdlib/stats/base/dists/normal/cdf","@stdlib/stats-base-dists-normal-entropy":"@stdlib/stats/base/dists/normal/entropy","@stdlib/stats-base-dists-normal-kurtosis":"@stdlib/stats/base/dists/normal/kurtosis","@stdlib/stats-base-dists-normal-logcdf":"@stdlib/stats/base/dists/normal/logcdf","@stdlib/stats-base-dists-normal-logpdf":"@stdlib/stats/base/dists/normal/logpdf","@stdlib/stats-base-dists-normal-mean":"@stdlib/stats/base/dists/normal/mean","@stdlib/stats-base-dists-normal-median":"@stdlib/stats/base/dists/normal/median","@stdlib/stats-base-dists-normal-mgf":"@stdlib/stats/base/dists/normal/mgf","@stdlib/stats-base-dists-normal-mode":"@stdlib/stats/base/dists/normal/mode","@stdlib/stats-base-dists-normal-ctor":"@stdlib/stats/base/dists/normal/ctor","@stdlib/stats-base-dists-normal-pdf":"@stdlib/stats/base/dists/normal/pdf","@stdlib/stats-base-dists-normal-quantile":"@stdlib/stats/base/dists/normal/quantile","@stdlib/stats-base-dists-normal-skewness":"@stdlib/stats/base/dists/normal/skewness","@stdlib/stats-base-dists-normal-stdev":"@stdlib/stats/base/dists/normal/stdev","@stdlib/stats-base-dists-normal-variance":"@stdlib/stats/base/dists/normal/variance","@stdlib/stats-base-dists-pareto-type1-cdf":"@stdlib/stats/base/dists/pareto-type1/cdf","@stdlib/stats-base-dists-pareto-type1-entropy":"@stdlib/stats/base/dists/pareto-type1/entropy","@stdlib/stats-base-dists-pareto-type1-kurtosis":"@stdlib/stats/base/dists/pareto-type1/kurtosis","@stdlib/stats-base-dists-pareto-type1-logcdf":"@stdlib/stats/base/dists/pareto-type1/logcdf","@stdlib/stats-base-dists-pareto-type1-logpdf":"@stdlib/stats/base/dists/pareto-type1/logpdf","@stdlib/stats-base-dists-pareto-type1-mean":"@stdlib/stats/base/dists/pareto-type1/mean","@stdlib/stats-base-dists-pareto-type1-median":"@stdlib/stats/base/dists/pareto-type1/median","@stdlib/stats-base-dists-pareto-type1-mode":"@stdlib/stats/base/dists/pareto-type1/mode","@stdlib/stats-base-dists-pareto-type1-ctor":"@stdlib/stats/base/dists/pareto-type1/ctor","@stdlib/stats-base-dists-pareto-type1-pdf":"@stdlib/stats/base/dists/pareto-type1/pdf","@stdlib/stats-base-dists-pareto-type1-quantile":"@stdlib/stats/base/dists/pareto-type1/quantile","@stdlib/stats-base-dists-pareto-type1-skewness":"@stdlib/stats/base/dists/pareto-type1/skewness","@stdlib/stats-base-dists-pareto-type1-stdev":"@stdlib/stats/base/dists/pareto-type1/stdev","@stdlib/stats-base-dists-pareto-type1-variance":"@stdlib/stats/base/dists/pareto-type1/variance","@stdlib/stats-base-dists-poisson-cdf":"@stdlib/stats/base/dists/poisson/cdf","@stdlib/stats-base-dists-poisson-entropy":"@stdlib/stats/base/dists/poisson/entropy","@stdlib/stats-base-dists-poisson-kurtosis":"@stdlib/stats/base/dists/poisson/kurtosis","@stdlib/stats-base-dists-poisson-logpmf":"@stdlib/stats/base/dists/poisson/logpmf","@stdlib/stats-base-dists-poisson-mean":"@stdlib/stats/base/dists/poisson/mean","@stdlib/stats-base-dists-poisson-median":"@stdlib/stats/base/dists/poisson/median","@stdlib/stats-base-dists-poisson-mgf":"@stdlib/stats/base/dists/poisson/mgf","@stdlib/stats-base-dists-poisson-mode":"@stdlib/stats/base/dists/poisson/mode","@stdlib/stats-base-dists-poisson-pmf":"@stdlib/stats/base/dists/poisson/pmf","@stdlib/stats-base-dists-poisson-ctor":"@stdlib/stats/base/dists/poisson/ctor","@stdlib/stats-base-dists-poisson-quantile":"@stdlib/stats/base/dists/poisson/quantile","@stdlib/stats-base-dists-poisson-skewness":"@stdlib/stats/base/dists/poisson/skewness","@stdlib/stats-base-dists-poisson-stdev":"@stdlib/stats/base/dists/poisson/stdev","@stdlib/stats-base-dists-poisson-variance":"@stdlib/stats/base/dists/poisson/variance","@stdlib/stats-base-dists-rayleigh-cdf":"@stdlib/stats/base/dists/rayleigh/cdf","@stdlib/stats-base-dists-rayleigh-entropy":"@stdlib/stats/base/dists/rayleigh/entropy","@stdlib/stats-base-dists-rayleigh-kurtosis":"@stdlib/stats/base/dists/rayleigh/kurtosis","@stdlib/stats-base-dists-rayleigh-logcdf":"@stdlib/stats/base/dists/rayleigh/logcdf","@stdlib/stats-base-dists-rayleigh-logpdf":"@stdlib/stats/base/dists/rayleigh/logpdf","@stdlib/stats-base-dists-rayleigh-mean":"@stdlib/stats/base/dists/rayleigh/mean","@stdlib/stats-base-dists-rayleigh-median":"@stdlib/stats/base/dists/rayleigh/median","@stdlib/stats-base-dists-rayleigh-mgf":"@stdlib/stats/base/dists/rayleigh/mgf","@stdlib/stats-base-dists-rayleigh-mode":"@stdlib/stats/base/dists/rayleigh/mode","@stdlib/stats-base-dists-rayleigh-pdf":"@stdlib/stats/base/dists/rayleigh/pdf","@stdlib/stats-base-dists-rayleigh-quantile":"@stdlib/stats/base/dists/rayleigh/quantile","@stdlib/stats-base-dists-rayleigh-ctor":"@stdlib/stats/base/dists/rayleigh/ctor","@stdlib/stats-base-dists-rayleigh-skewness":"@stdlib/stats/base/dists/rayleigh/skewness","@stdlib/stats-base-dists-rayleigh-stdev":"@stdlib/stats/base/dists/rayleigh/stdev","@stdlib/stats-base-dists-rayleigh-variance":"@stdlib/stats/base/dists/rayleigh/variance","@stdlib/stats-base-dists-signrank-cdf":"@stdlib/stats/base/dists/signrank/cdf","@stdlib/stats-base-dists-signrank-pdf":"@stdlib/stats/base/dists/signrank/pdf","@stdlib/stats-base-dists-signrank-quantile":"@stdlib/stats/base/dists/signrank/quantile","@stdlib/stats-base-dists-studentized-range-cdf":"@stdlib/stats/base/dists/studentized-range/cdf","@stdlib/stats-base-dists-studentized-range-quantile":"@stdlib/stats/base/dists/studentized-range/quantile","@stdlib/stats-base-dists-t-cdf":"@stdlib/stats/base/dists/t/cdf","@stdlib/stats-base-dists-t-entropy":"@stdlib/stats/base/dists/t/entropy","@stdlib/stats-base-dists-t-kurtosis":"@stdlib/stats/base/dists/t/kurtosis","@stdlib/stats-base-dists-t-logcdf":"@stdlib/stats/base/dists/t/logcdf","@stdlib/stats-base-dists-t-logpdf":"@stdlib/stats/base/dists/t/logpdf","@stdlib/stats-base-dists-t-mean":"@stdlib/stats/base/dists/t/mean","@stdlib/stats-base-dists-t-median":"@stdlib/stats/base/dists/t/median","@stdlib/stats-base-dists-t-mode":"@stdlib/stats/base/dists/t/mode","@stdlib/stats-base-dists-t-pdf":"@stdlib/stats/base/dists/t/pdf","@stdlib/stats-base-dists-t-quantile":"@stdlib/stats/base/dists/t/quantile","@stdlib/stats-base-dists-t-skewness":"@stdlib/stats/base/dists/t/skewness","@stdlib/stats-base-dists-t-stdev":"@stdlib/stats/base/dists/t/stdev","@stdlib/stats-base-dists-t-ctor":"@stdlib/stats/base/dists/t/ctor","@stdlib/stats-base-dists-t-variance":"@stdlib/stats/base/dists/t/variance","@stdlib/stats-base-dists-triangular-cdf":"@stdlib/stats/base/dists/triangular/cdf","@stdlib/stats-base-dists-triangular-entropy":"@stdlib/stats/base/dists/triangular/entropy","@stdlib/stats-base-dists-triangular-kurtosis":"@stdlib/stats/base/dists/triangular/kurtosis","@stdlib/stats-base-dists-triangular-logcdf":"@stdlib/stats/base/dists/triangular/logcdf","@stdlib/stats-base-dists-triangular-logpdf":"@stdlib/stats/base/dists/triangular/logpdf","@stdlib/stats-base-dists-triangular-mean":"@stdlib/stats/base/dists/triangular/mean","@stdlib/stats-base-dists-triangular-median":"@stdlib/stats/base/dists/triangular/median","@stdlib/stats-base-dists-triangular-mgf":"@stdlib/stats/base/dists/triangular/mgf","@stdlib/stats-base-dists-triangular-mode":"@stdlib/stats/base/dists/triangular/mode","@stdlib/stats-base-dists-triangular-pdf":"@stdlib/stats/base/dists/triangular/pdf","@stdlib/stats-base-dists-triangular-quantile":"@stdlib/stats/base/dists/triangular/quantile","@stdlib/stats-base-dists-triangular-skewness":"@stdlib/stats/base/dists/triangular/skewness","@stdlib/stats-base-dists-triangular-stdev":"@stdlib/stats/base/dists/triangular/stdev","@stdlib/stats-base-dists-triangular-ctor":"@stdlib/stats/base/dists/triangular/ctor","@stdlib/stats-base-dists-triangular-variance":"@stdlib/stats/base/dists/triangular/variance","@stdlib/stats-base-dists-truncated-normal-pdf":"@stdlib/stats/base/dists/truncated-normal/pdf","@stdlib/stats-base-dists-uniform-cdf":"@stdlib/stats/base/dists/uniform/cdf","@stdlib/stats-base-dists-uniform-entropy":"@stdlib/stats/base/dists/uniform/entropy","@stdlib/stats-base-dists-uniform-kurtosis":"@stdlib/stats/base/dists/uniform/kurtosis","@stdlib/stats-base-dists-uniform-logcdf":"@stdlib/stats/base/dists/uniform/logcdf","@stdlib/stats-base-dists-uniform-logpdf":"@stdlib/stats/base/dists/uniform/logpdf","@stdlib/stats-base-dists-uniform-mean":"@stdlib/stats/base/dists/uniform/mean","@stdlib/stats-base-dists-uniform-median":"@stdlib/stats/base/dists/uniform/median","@stdlib/stats-base-dists-uniform-mgf":"@stdlib/stats/base/dists/uniform/mgf","@stdlib/stats-base-dists-uniform-pdf":"@stdlib/stats/base/dists/uniform/pdf","@stdlib/stats-base-dists-uniform-quantile":"@stdlib/stats/base/dists/uniform/quantile","@stdlib/stats-base-dists-uniform-skewness":"@stdlib/stats/base/dists/uniform/skewness","@stdlib/stats-base-dists-uniform-stdev":"@stdlib/stats/base/dists/uniform/stdev","@stdlib/stats-base-dists-uniform-ctor":"@stdlib/stats/base/dists/uniform/ctor","@stdlib/stats-base-dists-uniform-variance":"@stdlib/stats/base/dists/uniform/variance","@stdlib/stats-base-dists-weibull-cdf":"@stdlib/stats/base/dists/weibull/cdf","@stdlib/stats-base-dists-weibull-entropy":"@stdlib/stats/base/dists/weibull/entropy","@stdlib/stats-base-dists-weibull-kurtosis":"@stdlib/stats/base/dists/weibull/kurtosis","@stdlib/stats-base-dists-weibull-logcdf":"@stdlib/stats/base/dists/weibull/logcdf","@stdlib/stats-base-dists-weibull-logpdf":"@stdlib/stats/base/dists/weibull/logpdf","@stdlib/stats-base-dists-weibull-mean":"@stdlib/stats/base/dists/weibull/mean","@stdlib/stats-base-dists-weibull-median":"@stdlib/stats/base/dists/weibull/median","@stdlib/stats-base-dists-weibull-mgf":"@stdlib/stats/base/dists/weibull/mgf","@stdlib/stats-base-dists-weibull-mode":"@stdlib/stats/base/dists/weibull/mode","@stdlib/stats-base-dists-weibull-pdf":"@stdlib/stats/base/dists/weibull/pdf","@stdlib/stats-base-dists-weibull-quantile":"@stdlib/stats/base/dists/weibull/quantile","@stdlib/stats-base-dists-weibull-skewness":"@stdlib/stats/base/dists/weibull/skewness","@stdlib/stats-base-dists-weibull-stdev":"@stdlib/stats/base/dists/weibull/stdev","@stdlib/stats-base-dists-weibull-variance":"@stdlib/stats/base/dists/weibull/variance","@stdlib/stats-base-dists-weibull-ctor":"@stdlib/stats/base/dists/weibull/ctor","@stdlib/math-base-special-ellipe":"@stdlib/math/base/special/ellipe","@stdlib/math-base-special-ellipj":"@stdlib/math/base/special/ellipj","@stdlib/math-base-special-ellipk":"@stdlib/math/base/special/ellipk","@stdlib/string-base-ends-with":"@stdlib/string/base/ends-with","@stdlib/math-base-utils-float64-epsilon-difference":"@stdlib/math/base/utils/float64-epsilon-difference","@stdlib/math-base-special-erf":"@stdlib/math/base/special/erf","@stdlib/math-base-special-erfc":"@stdlib/math/base/special/erfc","@stdlib/math-base-special-erfcinv":"@stdlib/math/base/special/erfcinv","@stdlib/math-base-special-erfcx":"@stdlib/math/base/special/erfcx","@stdlib/math-base-special-erfinv":"@stdlib/math/base/special/erfinv","@stdlib/math-base-special-dirichlet-eta":"@stdlib/math/base/special/dirichlet-eta","@stdlib/math-base-tools-evalpoly":"@stdlib/math/base/tools/evalpoly","@stdlib/math-base-tools-evalrational":"@stdlib/math/base/tools/evalrational","@stdlib/math-base-special-exp":"@stdlib/math/base/special/exp","@stdlib/math-base-special-exp2":"@stdlib/math/base/special/exp2","@stdlib/math-base-special-exp10":"@stdlib/math/base/special/exp10","@stdlib/math-base-special-expit":"@stdlib/math/base/special/expit","@stdlib/math-base-special-expm1":"@stdlib/math/base/special/expm1","@stdlib/math-base-special-expm1rel":"@stdlib/math/base/special/expm1rel","@stdlib/number-float64-base-exponent":"@stdlib/number/float64/base/exponent","@stdlib/number-float32-base-exponent":"@stdlib/number/float32/base/exponent","@stdlib/math-base-special-factorial":"@stdlib/math/base/special/factorial","@stdlib/math-base-special-factorial2":"@stdlib/math/base/special/factorial2","@stdlib/math-base-special-factorialln":"@stdlib/math/base/special/factorialln","@stdlib/math-base-special-falling-factorial":"@stdlib/math/base/special/falling-factorial","@stdlib/math-base-special-fibonacci":"@stdlib/math/base/special/fibonacci","@stdlib/math-base-special-fibonacci-index":"@stdlib/math/base/special/fibonacci-index","@stdlib/math-base-tools-fibpoly":"@stdlib/math/base/tools/fibpoly","@stdlib/string-base-first-code-point":"@stdlib/string/base/first-code-point","@stdlib/string-base-first":"@stdlib/string/base/first","@stdlib/string-base-first-grapheme-cluster":"@stdlib/string/base/first-grapheme-cluster","@stdlib/math-base-special-flipsign":"@stdlib/math/base/special/flipsign","@stdlib/math-base-special-flipsignf":"@stdlib/math/base/special/flipsignf","@stdlib/number-float32-base-to-int32":"@stdlib/number/float32/base/to-int32","@stdlib/number-float32-base-to-uint32":"@stdlib/number/float32/base/to-uint32","@stdlib/number-float64-base-to-float32":"@stdlib/number/float64/base/to-float32","@stdlib/number-float64-base-to-int32":"@stdlib/number/float64/base/to-int32","@stdlib/number-float64-base-to-int64-bytes":"@stdlib/number/float64/base/to-int64-bytes","@stdlib/number-float64-base-to-uint32":"@stdlib/number/float64/base/to-uint32","@stdlib/math-base-special-floor":"@stdlib/math/base/special/floor","@stdlib/math-base-special-floor2":"@stdlib/math/base/special/floor2","@stdlib/math-base-special-floor10":"@stdlib/math/base/special/floor10","@stdlib/math-base-special-floorb":"@stdlib/math/base/special/floorb","@stdlib/math-base-special-floorf":"@stdlib/math/base/special/floorf","@stdlib/math-base-special-floorn":"@stdlib/math/base/special/floorn","@stdlib/math-base-special-floorsd":"@stdlib/math/base/special/floorsd","@stdlib/string-base-for-each":"@stdlib/string/base/for-each","@stdlib/string-base-for-each-code-point":"@stdlib/string/base/for-each-code-point","@stdlib/string-base-for-each-code-point-right":"@stdlib/string/base/for-each-code-point-right","@stdlib/string-base-for-each-grapheme-cluster":"@stdlib/string/base/for-each-grapheme-cluster","@stdlib/string-base-for-each-right":"@stdlib/string/base/for-each-right","@stdlib/string-base-format-interpolate":"@stdlib/string/base/format-interpolate","@stdlib/string-base-format-tokenize":"@stdlib/string/base/format-tokenize","@stdlib/math-base-special-fresnel":"@stdlib/math/base/special/fresnel","@stdlib/math-base-special-fresnelc":"@stdlib/math/base/special/fresnelc","@stdlib/math-base-special-fresnels":"@stdlib/math/base/special/fresnels","@stdlib/math-base-special-frexp":"@stdlib/math/base/special/frexp","@stdlib/number-float64-base-from-binary-string":"@stdlib/number/float64/base/from-binary-string","@stdlib/number-float32-base-from-binary-string":"@stdlib/number/float32/base/from-binary-string","@stdlib/number-uint8-base-from-binary-string":"@stdlib/number/uint8/base/from-binary-string","@stdlib/number-uint16-base-from-binary-string":"@stdlib/number/uint16/base/from-binary-string","@stdlib/number-uint32-base-from-binary-string":"@stdlib/number/uint32/base/from-binary-string","@stdlib/number-float64-base-from-int64-bytes":"@stdlib/number/float64/base/from-int64-bytes","@stdlib/number-float32-base-from-word":"@stdlib/number/float32/base/from-word","@stdlib/number-float64-base-from-words":"@stdlib/number/float64/base/from-words","@stdlib/math-base-special-gamma":"@stdlib/math/base/special/gamma","@stdlib/math-base-special-gamma1pm1":"@stdlib/math/base/special/gamma1pm1","@stdlib/math-base-special-gamma-delta-ratio":"@stdlib/math/base/special/gamma-delta-ratio","@stdlib/math-base-special-gammainc":"@stdlib/math/base/special/gammainc","@stdlib/math-base-special-gammaincinv":"@stdlib/math/base/special/gammaincinv","@stdlib/math-base-special-gamma-lanczos-sum":"@stdlib/math/base/special/gamma-lanczos-sum","@stdlib/math-base-special-gamma-lanczos-sum-expg-scaled":"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled","@stdlib/math-base-special-gammaln":"@stdlib/math/base/special/gammaln","@stdlib/math-base-special-gammasgn":"@stdlib/math/base/special/gammasgn","@stdlib/math-base-special-gcd":"@stdlib/math/base/special/gcd","@stdlib/number-float64-base-get-high-word":"@stdlib/number/float64/base/get-high-word","@stdlib/number-float64-base-get-low-word":"@stdlib/number/float64/base/get-low-word","@stdlib/math-base-special-hacovercos":"@stdlib/math/base/special/hacovercos","@stdlib/math-base-special-hacoversin":"@stdlib/math/base/special/hacoversin","@stdlib/math-base-special-havercos":"@stdlib/math/base/special/havercos","@stdlib/math-base-special-haversin":"@stdlib/math/base/special/haversin","@stdlib/string-base-headercase":"@stdlib/string/base/headercase","@stdlib/math-base-special-heaviside":"@stdlib/math/base/special/heaviside","@stdlib/math-base-tools-hermitepoly":"@stdlib/math/base/tools/hermitepoly","@stdlib/math-base-special-hypot":"@stdlib/math/base/special/hypot","@stdlib/math-base-special-hypotf":"@stdlib/math/base/special/hypotf","@stdlib/math-base-special-identity":"@stdlib/math/base/special/identity","@stdlib/math-base-special-identityf":"@stdlib/math/base/special/identityf","@stdlib/math-base-ops-imul":"@stdlib/math/base/ops/imul","@stdlib/math-base-ops-imuldw":"@stdlib/math/base/ops/imuldw","@stdlib/slice-base-int2slice":"@stdlib/slice/base/int2slice","@stdlib/number-int32-base-to-uint32":"@stdlib/number/int32/base/to-uint32","@stdlib/math-base-special-inv":"@stdlib/math/base/special/inv","@stdlib/string-base-invcase":"@stdlib/string/base/invcase","@stdlib/math-base-special-invf":"@stdlib/math/base/special/invf","@stdlib/math-base-assert-is-composite":"@stdlib/math/base/assert/is-composite","@stdlib/math-base-assert-is-coprime":"@stdlib/math/base/assert/is-coprime","@stdlib/math-base-assert-is-even":"@stdlib/math/base/assert/is-even","@stdlib/math-base-assert-int32-is-even":"@stdlib/math/base/assert/int32-is-even","@stdlib/math-base-assert-is-finite":"@stdlib/math/base/assert/is-finite","@stdlib/math-base-assert-is-finitef":"@stdlib/math/base/assert/is-finitef","@stdlib/math-base-assert-is-infinite":"@stdlib/math/base/assert/is-infinite","@stdlib/math-base-assert-is-infinitef":"@stdlib/math/base/assert/is-infinitef","@stdlib/math-base-assert-is-integer":"@stdlib/math/base/assert/is-integer","@stdlib/math-base-assert-is-nan":"@stdlib/math/base/assert/is-nan","@stdlib/math-base-assert-is-nanf":"@stdlib/math/base/assert/is-nanf","@stdlib/math-base-assert-is-negative-finite":"@stdlib/math/base/assert/is-negative-finite","@stdlib/math-base-assert-is-negative-integer":"@stdlib/math/base/assert/is-negative-integer","@stdlib/math-base-assert-is-negative-zero":"@stdlib/math/base/assert/is-negative-zero","@stdlib/math-base-assert-is-negative-zerof":"@stdlib/math/base/assert/is-negative-zerof","@stdlib/math-base-assert-is-nonnegative-finite":"@stdlib/math/base/assert/is-nonnegative-finite","@stdlib/math-base-assert-is-nonnegative-integer":"@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math-base-assert-is-nonpositive-finite":"@stdlib/math/base/assert/is-nonpositive-finite","@stdlib/math-base-assert-is-nonpositive-integer":"@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math-base-assert-is-odd":"@stdlib/math/base/assert/is-odd","@stdlib/math-base-assert-int32-is-odd":"@stdlib/math/base/assert/int32-is-odd","@stdlib/math-base-assert-is-positive-finite":"@stdlib/math/base/assert/is-positive-finite","@stdlib/math-base-assert-is-positive-integer":"@stdlib/math/base/assert/is-positive-integer","@stdlib/math-base-assert-is-positive-zero":"@stdlib/math/base/assert/is-positive-zero","@stdlib/math-base-assert-is-positive-zerof":"@stdlib/math/base/assert/is-positive-zerof","@stdlib/math-base-assert-uint32-is-pow2":"@stdlib/math/base/assert/uint32-is-pow2","@stdlib/math-base-assert-is-prime":"@stdlib/math/base/assert/is-prime","@stdlib/math-base-assert-is-probability":"@stdlib/math/base/assert/is-probability","@stdlib/math-base-assert-is-safe-integer":"@stdlib/math/base/assert/is-safe-integer","@stdlib/string-base-kebabcase":"@stdlib/string/base/kebabcase","@stdlib/math-base-special-kernel-betainc":"@stdlib/math/base/special/kernel-betainc","@stdlib/math-base-special-kernel-betaincinv":"@stdlib/math/base/special/kernel-betaincinv","@stdlib/math-base-special-kernel-cos":"@stdlib/math/base/special/kernel-cos","@stdlib/math-base-special-kernel-log1p":"@stdlib/math/base/special/kernel-log1p","@stdlib/math-base-special-kernel-sin":"@stdlib/math/base/special/kernel-sin","@stdlib/math-base-special-kernel-tan":"@stdlib/math/base/special/kernel-tan","@stdlib/math-base-special-kronecker-delta":"@stdlib/math/base/special/kronecker-delta","@stdlib/math-base-special-kronecker-deltaf":"@stdlib/math/base/special/kronecker-deltaf","@stdlib/math-base-special-labs":"@stdlib/math/base/special/labs","@stdlib/string-base-last":"@stdlib/string/base/last","@stdlib/string-base-last-code-point":"@stdlib/string/base/last-code-point","@stdlib/string-base-last-grapheme-cluster":"@stdlib/string/base/last-grapheme-cluster","@stdlib/math-base-special-lcm":"@stdlib/math/base/special/lcm","@stdlib/math-base-special-ldexp":"@stdlib/math/base/special/ldexp","@stdlib/string-base-left-pad":"@stdlib/string/base/left-pad","@stdlib/string-base-left-trim":"@stdlib/string/base/left-trim","@stdlib/math-base-special-ln":"@stdlib/math/base/special/ln","@stdlib/math-base-special-log":"@stdlib/math/base/special/log","@stdlib/math-base-special-log1mexp":"@stdlib/math/base/special/log1mexp","@stdlib/math-base-special-log1p":"@stdlib/math/base/special/log1p","@stdlib/math-base-special-log1pexp":"@stdlib/math/base/special/log1pexp","@stdlib/math-base-special-log1pmx":"@stdlib/math/base/special/log1pmx","@stdlib/math-base-special-log2":"@stdlib/math/base/special/log2","@stdlib/math-base-special-log10":"@stdlib/math/base/special/log10","@stdlib/math-base-special-logaddexp":"@stdlib/math/base/special/logaddexp","@stdlib/math-base-special-logit":"@stdlib/math/base/special/logit","@stdlib/string-base-lowercase":"@stdlib/string/base/lowercase","@stdlib/math-base-special-lucas":"@stdlib/math/base/special/lucas","@stdlib/math-base-tools-lucaspoly":"@stdlib/math/base/tools/lucaspoly","@stdlib/math-base-special-max":"@stdlib/math/base/special/max","@stdlib/math-base-special-maxabs":"@stdlib/math/base/special/maxabs","@stdlib/math-base-special-maxabsn":"@stdlib/math/base/special/maxabsn","@stdlib/math-base-special-maxn":"@stdlib/math/base/special/maxn","@stdlib/math-base-special-min":"@stdlib/math/base/special/min","@stdlib/math-base-special-minabs":"@stdlib/math/base/special/minabs","@stdlib/math-base-special-minabsn":"@stdlib/math/base/special/minabsn","@stdlib/math-base-special-minmax":"@stdlib/math/base/special/minmax","@stdlib/math-base-special-minmaxabs":"@stdlib/math/base/special/minmaxabs","@stdlib/math-base-special-minmaxabsn":"@stdlib/math/base/special/minmaxabsn","@stdlib/math-base-special-minmaxn":"@stdlib/math/base/special/minmaxn","@stdlib/math-base-special-minn":"@stdlib/math/base/special/minn","@stdlib/math-base-special-modf":"@stdlib/math/base/special/modf","@stdlib/number-float64-base-mul":"@stdlib/number/float64/base/mul","@stdlib/number-float32-base-mul":"@stdlib/number/float32/base/mul","@stdlib/ndarray-base-ctor":"@stdlib/ndarray/base/ctor","@stdlib/ndarray-base-unary":"@stdlib/ndarray/base/unary","@stdlib/ndarray-base-zeros":"@stdlib/ndarray/base/zeros","@stdlib/ndarray-base-zeros-like":"@stdlib/ndarray/base/zeros-like","@stdlib/math-base-special-negafibonacci":"@stdlib/math/base/special/negafibonacci","@stdlib/math-base-special-negalucas":"@stdlib/math/base/special/negalucas","@stdlib/math-base-special-nonfibonacci":"@stdlib/math/base/special/nonfibonacci","@stdlib/number-float64-base-normalize":"@stdlib/number/float64/base/normalize","@stdlib/number-float32-base-normalize":"@stdlib/number/float32/base/normalize","@stdlib/slice-base-normalize-multi-slice":"@stdlib/slice/base/normalize-multi-slice","@stdlib/slice-base-normalize-slice":"@stdlib/slice/base/normalize-slice","@stdlib/math-base-tools-normhermitepoly":"@stdlib/math/base/tools/normhermitepoly","@stdlib/string-base-pascalcase":"@stdlib/string/base/pascalcase","@stdlib/math-base-special-pdiff":"@stdlib/math/base/special/pdiff","@stdlib/math-base-special-pdifff":"@stdlib/math/base/special/pdifff","@stdlib/string-base-percent-encode":"@stdlib/string/base/percent-encode","@stdlib/math-base-special-polygamma":"@stdlib/math/base/special/polygamma","@stdlib/math-base-special-pow":"@stdlib/math/base/special/pow","@stdlib/math-base-special-powm1":"@stdlib/math/base/special/powm1","@stdlib/math-base-special-rad2deg":"@stdlib/math/base/special/rad2deg","@stdlib/math-base-special-rad2degf":"@stdlib/math/base/special/rad2degf","@stdlib/math-base-special-ramp":"@stdlib/math/base/special/ramp","@stdlib/math-base-special-rampf":"@stdlib/math/base/special/rampf","@stdlib/random-base-arcsine":"@stdlib/random/base/arcsine","@stdlib/random-base-bernoulli":"@stdlib/random/base/bernoulli","@stdlib/random-base-beta":"@stdlib/random/base/beta","@stdlib/random-base-betaprime":"@stdlib/random/base/betaprime","@stdlib/random-base-binomial":"@stdlib/random/base/binomial","@stdlib/random-base-box-muller":"@stdlib/random/base/box-muller","@stdlib/random-base-cauchy":"@stdlib/random/base/cauchy","@stdlib/random-base-chi":"@stdlib/random/base/chi","@stdlib/random-base-chisquare":"@stdlib/random/base/chisquare","@stdlib/random-base-cosine":"@stdlib/random/base/cosine","@stdlib/random-base-discrete-uniform":"@stdlib/random/base/discrete-uniform","@stdlib/random-base-erlang":"@stdlib/random/base/erlang","@stdlib/random-base-exponential":"@stdlib/random/base/exponential","@stdlib/random-base-f":"@stdlib/random/base/f","@stdlib/random-base-frechet":"@stdlib/random/base/frechet","@stdlib/random-base-gamma":"@stdlib/random/base/gamma","@stdlib/random-base-geometric":"@stdlib/random/base/geometric","@stdlib/random-base-gumbel":"@stdlib/random/base/gumbel","@stdlib/random-base-hypergeometric":"@stdlib/random/base/hypergeometric","@stdlib/random-base-improved-ziggurat":"@stdlib/random/base/improved-ziggurat","@stdlib/random-base-invgamma":"@stdlib/random/base/invgamma","@stdlib/random-base-kumaraswamy":"@stdlib/random/base/kumaraswamy","@stdlib/random-base-laplace":"@stdlib/random/base/laplace","@stdlib/random-base-levy":"@stdlib/random/base/levy","@stdlib/random-base-logistic":"@stdlib/random/base/logistic","@stdlib/random-base-lognormal":"@stdlib/random/base/lognormal","@stdlib/random-base-minstd":"@stdlib/random/base/minstd","@stdlib/random-base-minstd-shuffle":"@stdlib/random/base/minstd-shuffle","@stdlib/random-base-mt19937":"@stdlib/random/base/mt19937","@stdlib/random-base-negative-binomial":"@stdlib/random/base/negative-binomial","@stdlib/random-base-normal":"@stdlib/random/base/normal","@stdlib/random-base-pareto-type1":"@stdlib/random/base/pareto-type1","@stdlib/random-base-poisson":"@stdlib/random/base/poisson","@stdlib/random-base-randi":"@stdlib/random/base/randi","@stdlib/random-base-randn":"@stdlib/random/base/randn","@stdlib/random-base-randu":"@stdlib/random/base/randu","@stdlib/random-base-rayleigh":"@stdlib/random/base/rayleigh","@stdlib/random-base-t":"@stdlib/random/base/t","@stdlib/random-base-triangular":"@stdlib/random/base/triangular","@stdlib/random-base-uniform":"@stdlib/random/base/uniform","@stdlib/random-base-weibull":"@stdlib/random/base/weibull","@stdlib/math-base-special-rcbrt":"@stdlib/math/base/special/rcbrt","@stdlib/math-base-special-rcbrtf":"@stdlib/math/base/special/rcbrtf","@stdlib/math-base-utils-relative-difference":"@stdlib/math/base/utils/relative-difference","@stdlib/string-base-remove-first":"@stdlib/string/base/remove-first","@stdlib/string-base-remove-first-code-point":"@stdlib/string/base/remove-first-code-point","@stdlib/string-base-remove-first-grapheme-cluster":"@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string-base-remove-last":"@stdlib/string/base/remove-last","@stdlib/string-base-remove-last-code-point":"@stdlib/string/base/remove-last-code-point","@stdlib/string-base-remove-last-grapheme-cluster":"@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/math-base-special-rempio2":"@stdlib/math/base/special/rempio2","@stdlib/string-base-repeat":"@stdlib/string/base/repeat","@stdlib/string-base-replace":"@stdlib/string/base/replace","@stdlib/string-base-replace-after":"@stdlib/string/base/replace-after","@stdlib/string-base-replace-after-last":"@stdlib/string/base/replace-after-last","@stdlib/string-base-replace-before":"@stdlib/string/base/replace-before","@stdlib/string-base-replace-before-last":"@stdlib/string/base/replace-before-last","@stdlib/string-base-reverse":"@stdlib/string/base/reverse","@stdlib/string-base-reverse-code-points":"@stdlib/string/base/reverse-code-points","@stdlib/string-base-reverse-grapheme-clusters":"@stdlib/string/base/reverse-grapheme-clusters","@stdlib/string-base-right-pad":"@stdlib/string/base/right-pad","@stdlib/string-base-right-trim":"@stdlib/string/base/right-trim","@stdlib/math-base-special-rising-factorial":"@stdlib/math/base/special/rising-factorial","@stdlib/number-uint32-base-rotl":"@stdlib/number/uint32/base/rotl","@stdlib/number-uint32-base-rotr":"@stdlib/number/uint32/base/rotr","@stdlib/math-base-special-round":"@stdlib/math/base/special/round","@stdlib/math-base-special-round2":"@stdlib/math/base/special/round2","@stdlib/math-base-special-round10":"@stdlib/math/base/special/round10","@stdlib/math-base-special-roundb":"@stdlib/math/base/special/roundb","@stdlib/math-base-special-roundn":"@stdlib/math/base/special/roundn","@stdlib/math-base-special-roundsd":"@stdlib/math/base/special/roundsd","@stdlib/math-base-special-rsqrt":"@stdlib/math/base/special/rsqrt","@stdlib/math-base-special-rsqrtf":"@stdlib/math/base/special/rsqrtf","@stdlib/slice-base-sargs2multislice":"@stdlib/slice/base/sargs2multislice","@stdlib/ndarray-base-from-scalar":"@stdlib/ndarray/base/from-scalar","@stdlib/math-base-special-secd":"@stdlib/math/base/special/secd","@stdlib/slice-base-seq2multislice":"@stdlib/slice/base/seq2multislice","@stdlib/slice-base-seq2slice":"@stdlib/slice/base/seq2slice","@stdlib/number-float64-base-set-high-word":"@stdlib/number/float64/base/set-high-word","@stdlib/number-float64-base-set-low-word":"@stdlib/number/float64/base/set-low-word","@stdlib/math-base-special-sici":"@stdlib/math/base/special/sici","@stdlib/number-float64-base-signbit":"@stdlib/number/float64/base/signbit","@stdlib/number-float32-base-signbit":"@stdlib/number/float32/base/signbit","@stdlib/number-float32-base-significand":"@stdlib/number/float32/base/significand","@stdlib/math-base-special-signum":"@stdlib/math/base/special/signum","@stdlib/math-base-special-signumf":"@stdlib/math/base/special/signumf","@stdlib/math-base-special-sin":"@stdlib/math/base/special/sin","@stdlib/math-base-special-sinc":"@stdlib/math/base/special/sinc","@stdlib/math-base-special-sincos":"@stdlib/math/base/special/sincos","@stdlib/math-base-special-sincospi":"@stdlib/math/base/special/sincospi","@stdlib/math-base-special-sinh":"@stdlib/math/base/special/sinh","@stdlib/math-base-special-sinpi":"@stdlib/math/base/special/sinpi","@stdlib/slice-base-slice2seq":"@stdlib/slice/base/slice2seq","@stdlib/slice-base-length":"@stdlib/slice/base/length","@stdlib/slice-base-nonreduced-dimensions":"@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice-base-reduced-dimensions":"@stdlib/slice/base/reduced-dimensions","@stdlib/slice-base-shape":"@stdlib/slice/base/shape","@stdlib/string-base-snakecase":"@stdlib/string/base/snakecase","@stdlib/math-base-special-spence":"@stdlib/math/base/special/spence","@stdlib/math-base-special-sqrt":"@stdlib/math/base/special/sqrt","@stdlib/math-base-special-sqrt1pm1":"@stdlib/math/base/special/sqrt1pm1","@stdlib/math-base-special-sqrtf":"@stdlib/math/base/special/sqrtf","@stdlib/math-base-special-sqrtpi":"@stdlib/math/base/special/sqrtpi","@stdlib/string-base-startcase":"@stdlib/string/base/startcase","@stdlib/string-base-starts-with":"@stdlib/string/base/starts-with","@stdlib/string-base-stickycase":"@stdlib/string/base/stickycase","@stdlib/strided-base-binary":"@stdlib/strided/base/binary","@stdlib/strided-base-binary-dtype-signatures":"@stdlib/strided/base/binary-dtype-signatures","@stdlib/strided-base-binary-signature-callbacks":"@stdlib/strided/base/binary-signature-callbacks","@stdlib/blas-base-ccopy":"@stdlib/blas/base/ccopy","@stdlib/strided-base-cmap":"@stdlib/strided/base/cmap","@stdlib/blas-base-cswap":"@stdlib/blas/base/cswap","@stdlib/stats-base-cumax":"@stdlib/stats/base/cumax","@stdlib/stats-base-cumaxabs":"@stdlib/stats/base/cumaxabs","@stdlib/stats-base-cumin":"@stdlib/stats/base/cumin","@stdlib/stats-base-cuminabs":"@stdlib/stats/base/cuminabs","@stdlib/math-strided-special-dabs":"@stdlib/math/strided/special/dabs","@stdlib/math-strided-special-dabs2":"@stdlib/math/strided/special/dabs2","@stdlib/blas-ext-base-dapx":"@stdlib/blas/ext/base/dapx","@stdlib/blas-ext-base-dapxsum":"@stdlib/blas/ext/base/dapxsum","@stdlib/blas-ext-base-dapxsumkbn":"@stdlib/blas/ext/base/dapxsumkbn","@stdlib/blas-ext-base-dapxsumkbn2":"@stdlib/blas/ext/base/dapxsumkbn2","@stdlib/blas-ext-base-dapxsumors":"@stdlib/blas/ext/base/dapxsumors","@stdlib/blas-ext-base-dapxsumpw":"@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas-base-dasum":"@stdlib/blas/base/dasum","@stdlib/blas-ext-base-dasumpw":"@stdlib/blas/ext/base/dasumpw","@stdlib/blas-base-daxpy":"@stdlib/blas/base/daxpy","@stdlib/math-strided-special-dcbrt":"@stdlib/math/strided/special/dcbrt","@stdlib/math-strided-special-dceil":"@stdlib/math/strided/special/dceil","@stdlib/blas-base-dcopy":"@stdlib/blas/base/dcopy","@stdlib/stats-strided-dcumax":"@stdlib/stats/strided/dcumax","@stdlib/stats-strided-dcumaxabs":"@stdlib/stats/strided/dcumaxabs","@stdlib/stats-base-dcumin":"@stdlib/stats/base/dcumin","@stdlib/stats-strided-dcuminabs":"@stdlib/stats/strided/dcuminabs","@stdlib/blas-ext-base-dcusum":"@stdlib/blas/ext/base/dcusum","@stdlib/blas-ext-base-dcusumkbn":"@stdlib/blas/ext/base/dcusumkbn","@stdlib/blas-ext-base-dcusumkbn2":"@stdlib/blas/ext/base/dcusumkbn2","@stdlib/blas-ext-base-dcusumors":"@stdlib/blas/ext/base/dcusumors","@stdlib/blas-ext-base-dcusumpw":"@stdlib/blas/ext/base/dcusumpw","@stdlib/math-strided-special-ddeg2rad":"@stdlib/math/strided/special/ddeg2rad","@stdlib/blas-base-ddot":"@stdlib/blas/base/ddot","@stdlib/blas-ext-base-dfill":"@stdlib/blas/ext/base/dfill","@stdlib/math-strided-special-dfloor":"@stdlib/math/strided/special/dfloor","@stdlib/math-strided-special-dinv":"@stdlib/math/strided/special/dinv","@stdlib/strided-base-dmap":"@stdlib/strided/base/dmap","@stdlib/strided-base-dmap2":"@stdlib/strided/base/dmap2","@stdlib/stats-strided-dmax":"@stdlib/stats/strided/dmax","@stdlib/stats-strided-dmaxabs":"@stdlib/stats/strided/dmaxabs","@stdlib/stats-strided-dmaxabssorted":"@stdlib/stats/strided/dmaxabssorted","@stdlib/stats-strided-dmaxsorted":"@stdlib/stats/strided/dmaxsorted","@stdlib/stats-base-dmean":"@stdlib/stats/base/dmean","@stdlib/stats-strided-dmeankbn":"@stdlib/stats/strided/dmeankbn","@stdlib/stats-strided-dmeankbn2":"@stdlib/stats/strided/dmeankbn2","@stdlib/stats-strided-dmeanli":"@stdlib/stats/strided/dmeanli","@stdlib/stats-strided-dmeanlipw":"@stdlib/stats/strided/dmeanlipw","@stdlib/stats-strided-dmeanors":"@stdlib/stats/strided/dmeanors","@stdlib/stats-base-dmeanpn":"@stdlib/stats/base/dmeanpn","@stdlib/stats-strided-dmeanpw":"@stdlib/stats/strided/dmeanpw","@stdlib/stats-base-dmeanstdev":"@stdlib/stats/base/dmeanstdev","@stdlib/stats-base-dmeanstdevpn":"@stdlib/stats/base/dmeanstdevpn","@stdlib/stats-base-dmeanvar":"@stdlib/stats/base/dmeanvar","@stdlib/stats-base-dmeanvarpn":"@stdlib/stats/base/dmeanvarpn","@stdlib/stats-strided-dmeanwd":"@stdlib/stats/strided/dmeanwd","@stdlib/stats-strided-dmediansorted":"@stdlib/stats/strided/dmediansorted","@stdlib/stats-strided-dmidrange":"@stdlib/stats/strided/dmidrange","@stdlib/stats-strided-dmin":"@stdlib/stats/strided/dmin","@stdlib/stats-strided-dminabs":"@stdlib/stats/strided/dminabs","@stdlib/stats-strided-dminsorted":"@stdlib/stats/strided/dminsorted","@stdlib/math-strided-special-dmskabs":"@stdlib/math/strided/special/dmskabs","@stdlib/math-strided-special-dmskabs2":"@stdlib/math/strided/special/dmskabs2","@stdlib/math-strided-special-dmskcbrt":"@stdlib/math/strided/special/dmskcbrt","@stdlib/math-strided-special-dmskceil":"@stdlib/math/strided/special/dmskceil","@stdlib/math-strided-special-dmskdeg2rad":"@stdlib/math/strided/special/dmskdeg2rad","@stdlib/math-strided-special-dmskfloor":"@stdlib/math/strided/special/dmskfloor","@stdlib/math-strided-special-dmskinv":"@stdlib/math/strided/special/dmskinv","@stdlib/strided-base-dmskmap":"@stdlib/strided/base/dmskmap","@stdlib/strided-base-dmskmap2":"@stdlib/strided/base/dmskmap2","@stdlib/stats-base-dmskmax":"@stdlib/stats/base/dmskmax","@stdlib/stats-base-dmskmin":"@stdlib/stats/base/dmskmin","@stdlib/math-strided-special-dmskramp":"@stdlib/math/strided/special/dmskramp","@stdlib/stats-base-dmskrange":"@stdlib/stats/base/dmskrange","@stdlib/math-strided-special-dmskrsqrt":"@stdlib/math/strided/special/dmskrsqrt","@stdlib/math-strided-special-dmsksqrt":"@stdlib/math/strided/special/dmsksqrt","@stdlib/math-strided-special-dmsktrunc":"@stdlib/math/strided/special/dmsktrunc","@stdlib/blas-ext-base-dnanasum":"@stdlib/blas/ext/base/dnanasum","@stdlib/blas-ext-base-dnanasumors":"@stdlib/blas/ext/base/dnanasumors","@stdlib/stats-strided-dnanmax":"@stdlib/stats/strided/dnanmax","@stdlib/stats-strided-dnanmaxabs":"@stdlib/stats/strided/dnanmaxabs","@stdlib/stats-strided-dnanmean":"@stdlib/stats/strided/dnanmean","@stdlib/stats-base-dnanmeanors":"@stdlib/stats/base/dnanmeanors","@stdlib/stats-base-dnanmeanpn":"@stdlib/stats/base/dnanmeanpn","@stdlib/stats-base-dnanmeanpw":"@stdlib/stats/base/dnanmeanpw","@stdlib/stats-base-dnanmeanwd":"@stdlib/stats/base/dnanmeanwd","@stdlib/stats-base-dnanmin":"@stdlib/stats/base/dnanmin","@stdlib/stats-base-dnanminabs":"@stdlib/stats/base/dnanminabs","@stdlib/stats-base-dnanmskmax":"@stdlib/stats/base/dnanmskmax","@stdlib/stats-base-dnanmskmin":"@stdlib/stats/base/dnanmskmin","@stdlib/stats-base-dnanmskrange":"@stdlib/stats/base/dnanmskrange","@stdlib/blas-ext-base-dnannsum":"@stdlib/blas/ext/base/dnannsum","@stdlib/blas-ext-base-dnannsumkbn":"@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas-ext-base-dnannsumkbn2":"@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas-ext-base-dnannsumors":"@stdlib/blas/ext/base/dnannsumors","@stdlib/blas-ext-base-dnannsumpw":"@stdlib/blas/ext/base/dnannsumpw","@stdlib/stats-base-dnanrange":"@stdlib/stats/base/dnanrange","@stdlib/stats-base-dnanstdev":"@stdlib/stats/base/dnanstdev","@stdlib/stats-base-dnanstdevch":"@stdlib/stats/base/dnanstdevch","@stdlib/stats-base-dnanstdevpn":"@stdlib/stats/base/dnanstdevpn","@stdlib/stats-base-dnanstdevtk":"@stdlib/stats/base/dnanstdevtk","@stdlib/stats-base-dnanstdevwd":"@stdlib/stats/base/dnanstdevwd","@stdlib/stats-base-dnanstdevyc":"@stdlib/stats/base/dnanstdevyc","@stdlib/blas-ext-base-dnansum":"@stdlib/blas/ext/base/dnansum","@stdlib/blas-ext-base-dnansumkbn":"@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas-ext-base-dnansumkbn2":"@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas-ext-base-dnansumors":"@stdlib/blas/ext/base/dnansumors","@stdlib/blas-ext-base-dnansumpw":"@stdlib/blas/ext/base/dnansumpw","@stdlib/stats-base-dnanvariance":"@stdlib/stats/base/dnanvariance","@stdlib/stats-base-dnanvariancech":"@stdlib/stats/base/dnanvariancech","@stdlib/stats-base-dnanvariancepn":"@stdlib/stats/base/dnanvariancepn","@stdlib/stats-base-dnanvariancetk":"@stdlib/stats/base/dnanvariancetk","@stdlib/stats-base-dnanvariancewd":"@stdlib/stats/base/dnanvariancewd","@stdlib/stats-base-dnanvarianceyc":"@stdlib/stats/base/dnanvarianceyc","@stdlib/blas-base-dnrm2":"@stdlib/blas/base/dnrm2","@stdlib/math-strided-special-dramp":"@stdlib/math/strided/special/dramp","@stdlib/stats-base-drange":"@stdlib/stats/base/drange","@stdlib/blas-ext-base-drev":"@stdlib/blas/ext/base/drev","@stdlib/math-strided-special-drsqrt":"@stdlib/math/strided/special/drsqrt","@stdlib/blas-ext-base-dsapxsum":"@stdlib/blas/ext/base/dsapxsum","@stdlib/blas-ext-base-dsapxsumpw":"@stdlib/blas/ext/base/dsapxsumpw","@stdlib/blas-base-dscal":"@stdlib/blas/base/dscal","@stdlib/blas-base-dsdot":"@stdlib/blas/base/dsdot","@stdlib/stats-base-dsem":"@stdlib/stats/base/dsem","@stdlib/stats-base-dsemch":"@stdlib/stats/base/dsemch","@stdlib/stats-base-dsempn":"@stdlib/stats/base/dsempn","@stdlib/stats-base-dsemtk":"@stdlib/stats/base/dsemtk","@stdlib/stats-base-dsemwd":"@stdlib/stats/base/dsemwd","@stdlib/stats-base-dsemyc":"@stdlib/stats/base/dsemyc","@stdlib/stats-base-dsmean":"@stdlib/stats/base/dsmean","@stdlib/stats-base-dsmeanors":"@stdlib/stats/base/dsmeanors","@stdlib/stats-base-dsmeanpn":"@stdlib/stats/base/dsmeanpn","@stdlib/stats-base-dsmeanpw":"@stdlib/stats/base/dsmeanpw","@stdlib/stats-base-dsmeanwd":"@stdlib/stats/base/dsmeanwd","@stdlib/stats-base-dsnanmean":"@stdlib/stats/base/dsnanmean","@stdlib/stats-base-dsnanmeanors":"@stdlib/stats/base/dsnanmeanors","@stdlib/stats-base-dsnanmeanpn":"@stdlib/stats/base/dsnanmeanpn","@stdlib/stats-base-dsnanmeanwd":"@stdlib/stats/base/dsnanmeanwd","@stdlib/blas-ext-base-dsnannsumors":"@stdlib/blas/ext/base/dsnannsumors","@stdlib/blas-ext-base-dsnansum":"@stdlib/blas/ext/base/dsnansum","@stdlib/blas-ext-base-dsnansumors":"@stdlib/blas/ext/base/dsnansumors","@stdlib/blas-ext-base-dsnansumpw":"@stdlib/blas/ext/base/dsnansumpw","@stdlib/blas-ext-base-dsort2hp":"@stdlib/blas/ext/base/dsort2hp","@stdlib/blas-ext-base-dsort2ins":"@stdlib/blas/ext/base/dsort2ins","@stdlib/blas-ext-base-dsort2sh":"@stdlib/blas/ext/base/dsort2sh","@stdlib/blas-ext-base-dsorthp":"@stdlib/blas/ext/base/dsorthp","@stdlib/blas-ext-base-dsortins":"@stdlib/blas/ext/base/dsortins","@stdlib/blas-ext-base-dsortsh":"@stdlib/blas/ext/base/dsortsh","@stdlib/math-strided-special-dsqrt":"@stdlib/math/strided/special/dsqrt","@stdlib/blas-ext-base-dssum":"@stdlib/blas/ext/base/dssum","@stdlib/blas-ext-base-dssumors":"@stdlib/blas/ext/base/dssumors","@stdlib/blas-ext-base-dssumpw":"@stdlib/blas/ext/base/dssumpw","@stdlib/stats-base-dstdev":"@stdlib/stats/base/dstdev","@stdlib/stats-base-dstdevch":"@stdlib/stats/base/dstdevch","@stdlib/stats-base-dstdevpn":"@stdlib/stats/base/dstdevpn","@stdlib/stats-base-dstdevtk":"@stdlib/stats/base/dstdevtk","@stdlib/stats-base-dstdevwd":"@stdlib/stats/base/dstdevwd","@stdlib/stats-base-dstdevyc":"@stdlib/stats/base/dstdevyc","@stdlib/blas-ext-base-dsum":"@stdlib/blas/ext/base/dsum","@stdlib/blas-ext-base-dsumkbn":"@stdlib/blas/ext/base/dsumkbn","@stdlib/blas-ext-base-dsumkbn2":"@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas-ext-base-dsumors":"@stdlib/blas/ext/base/dsumors","@stdlib/blas-ext-base-dsumpw":"@stdlib/blas/ext/base/dsumpw","@stdlib/stats-base-dsvariance":"@stdlib/stats/base/dsvariance","@stdlib/stats-base-dsvariancepn":"@stdlib/stats/base/dsvariancepn","@stdlib/blas-base-dswap":"@stdlib/blas/base/dswap","@stdlib/math-strided-special-dtrunc":"@stdlib/math/strided/special/dtrunc","@stdlib/strided-base-dtype-enum2str":"@stdlib/strided/base/dtype-enum2str","@stdlib/strided-base-dtype-resolve-enum":"@stdlib/strided/base/dtype-resolve-enum","@stdlib/strided-base-dtype-resolve-str":"@stdlib/strided/base/dtype-resolve-str","@stdlib/strided-base-dtype-str2enum":"@stdlib/strided/base/dtype-str2enum","@stdlib/stats-base-dvariance":"@stdlib/stats/base/dvariance","@stdlib/stats-base-dvariancech":"@stdlib/stats/base/dvariancech","@stdlib/stats-base-dvariancepn":"@stdlib/stats/base/dvariancepn","@stdlib/stats-base-dvariancetk":"@stdlib/stats/base/dvariancetk","@stdlib/stats-base-dvariancewd":"@stdlib/stats/base/dvariancewd","@stdlib/stats-base-dvarianceyc":"@stdlib/stats/base/dvarianceyc","@stdlib/stats-base-dvarm":"@stdlib/stats/base/dvarm","@stdlib/stats-base-dvarmpn":"@stdlib/stats/base/dvarmpn","@stdlib/stats-base-dvarmtk":"@stdlib/stats/base/dvarmtk","@stdlib/strided-base-function-object":"@stdlib/strided/base/function-object","@stdlib/blas-ext-base-gapx":"@stdlib/blas/ext/base/gapx","@stdlib/blas-ext-base-gapxsum":"@stdlib/blas/ext/base/gapxsum","@stdlib/blas-ext-base-gapxsumkbn":"@stdlib/blas/ext/base/gapxsumkbn","@stdlib/blas-ext-base-gapxsumkbn2":"@stdlib/blas/ext/base/gapxsumkbn2","@stdlib/blas-ext-base-gapxsumors":"@stdlib/blas/ext/base/gapxsumors","@stdlib/blas-ext-base-gapxsumpw":"@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas-base-gasum":"@stdlib/blas/base/gasum","@stdlib/blas-ext-base-gasumpw":"@stdlib/blas/ext/base/gasumpw","@stdlib/blas-base-gaxpy":"@stdlib/blas/base/gaxpy","@stdlib/blas-base-gcopy":"@stdlib/blas/base/gcopy","@stdlib/blas-ext-base-gcusum":"@stdlib/blas/ext/base/gcusum","@stdlib/blas-ext-base-gcusumkbn":"@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas-ext-base-gcusumkbn2":"@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas-ext-base-gcusumors":"@stdlib/blas/ext/base/gcusumors","@stdlib/blas-ext-base-gcusumpw":"@stdlib/blas/ext/base/gcusumpw","@stdlib/blas-base-gdot":"@stdlib/blas/base/gdot","@stdlib/blas-ext-base-gfill":"@stdlib/blas/ext/base/gfill","@stdlib/blas-ext-base-gfill-by":"@stdlib/blas/ext/base/gfill-by","@stdlib/blas-ext-base-gnannsumkbn":"@stdlib/blas/ext/base/gnannsumkbn","@stdlib/blas-ext-base-gnansum":"@stdlib/blas/ext/base/gnansum","@stdlib/blas-ext-base-gnansumkbn":"@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas-ext-base-gnansumkbn2":"@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas-ext-base-gnansumors":"@stdlib/blas/ext/base/gnansumors","@stdlib/blas-ext-base-gnansumpw":"@stdlib/blas/ext/base/gnansumpw","@stdlib/blas-base-gnrm2":"@stdlib/blas/base/gnrm2","@stdlib/blas-ext-base-grev":"@stdlib/blas/ext/base/grev","@stdlib/blas-base-gscal":"@stdlib/blas/base/gscal","@stdlib/blas-ext-base-gsort2hp":"@stdlib/blas/ext/base/gsort2hp","@stdlib/blas-ext-base-gsort2ins":"@stdlib/blas/ext/base/gsort2ins","@stdlib/blas-ext-base-gsort2sh":"@stdlib/blas/ext/base/gsort2sh","@stdlib/blas-ext-base-gsorthp":"@stdlib/blas/ext/base/gsorthp","@stdlib/blas-ext-base-gsortins":"@stdlib/blas/ext/base/gsortins","@stdlib/blas-ext-base-gsortsh":"@stdlib/blas/ext/base/gsortsh","@stdlib/blas-ext-base-gsum":"@stdlib/blas/ext/base/gsum","@stdlib/blas-ext-base-gsumkbn":"@stdlib/blas/ext/base/gsumkbn","@stdlib/blas-ext-base-gsumkbn2":"@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas-ext-base-gsumors":"@stdlib/blas/ext/base/gsumors","@stdlib/blas-ext-base-gsumpw":"@stdlib/blas/ext/base/gsumpw","@stdlib/blas-base-gswap":"@stdlib/blas/base/gswap","@stdlib/strided-base-map-by":"@stdlib/strided/base/map-by","@stdlib/strided-base-map-by2":"@stdlib/strided/base/map-by2","@stdlib/stats-base-max":"@stdlib/stats/base/max","@stdlib/stats-base-maxabs":"@stdlib/stats/base/maxabs","@stdlib/stats-base-max-by":"@stdlib/stats/base/max-by","@stdlib/stats-base-maxsorted":"@stdlib/stats/base/maxsorted","@stdlib/strided-base-max-view-buffer-index":"@stdlib/strided/base/max-view-buffer-index","@stdlib/stats-base-mean":"@stdlib/stats/base/mean","@stdlib/stats-base-meankbn":"@stdlib/stats/base/meankbn","@stdlib/stats-base-meankbn2":"@stdlib/stats/base/meankbn2","@stdlib/stats-base-meanors":"@stdlib/stats/base/meanors","@stdlib/stats-base-meanpn":"@stdlib/stats/base/meanpn","@stdlib/stats-base-meanpw":"@stdlib/stats/base/meanpw","@stdlib/stats-base-meanwd":"@stdlib/stats/base/meanwd","@stdlib/stats-base-mediansorted":"@stdlib/stats/base/mediansorted","@stdlib/strided-base-meta-data-props":"@stdlib/strided/base/meta-data-props","@stdlib/stats-base-min":"@stdlib/stats/base/min","@stdlib/stats-base-minabs":"@stdlib/stats/base/minabs","@stdlib/stats-base-min-by":"@stdlib/stats/base/min-by","@stdlib/stats-base-minsorted":"@stdlib/stats/base/minsorted","@stdlib/strided-base-min-view-buffer-index":"@stdlib/strided/base/min-view-buffer-index","@stdlib/stats-base-mskmax":"@stdlib/stats/base/mskmax","@stdlib/stats-base-mskmin":"@stdlib/stats/base/mskmin","@stdlib/stats-base-mskrange":"@stdlib/stats/base/mskrange","@stdlib/strided-base-mskunary":"@stdlib/strided/base/mskunary","@stdlib/strided-base-mskunary-dtype-signatures":"@stdlib/strided/base/mskunary-dtype-signatures","@stdlib/strided-base-mskunary-signature-callbacks":"@stdlib/strided/base/mskunary-signature-callbacks","@stdlib/stats-base-nanmax":"@stdlib/stats/base/nanmax","@stdlib/stats-base-nanmaxabs":"@stdlib/stats/base/nanmaxabs","@stdlib/stats-base-nanmax-by":"@stdlib/stats/base/nanmax-by","@stdlib/stats-base-nanmean":"@stdlib/stats/base/nanmean","@stdlib/stats-base-nanmeanors":"@stdlib/stats/base/nanmeanors","@stdlib/stats-base-nanmeanpn":"@stdlib/stats/base/nanmeanpn","@stdlib/stats-base-nanmeanwd":"@stdlib/stats/base/nanmeanwd","@stdlib/stats-base-nanmin":"@stdlib/stats/base/nanmin","@stdlib/stats-base-nanminabs":"@stdlib/stats/base/nanminabs","@stdlib/stats-base-nanmin-by":"@stdlib/stats/base/nanmin-by","@stdlib/stats-base-nanmskmax":"@stdlib/stats/base/nanmskmax","@stdlib/stats-base-nanmskmin":"@stdlib/stats/base/nanmskmin","@stdlib/stats-base-nanmskrange":"@stdlib/stats/base/nanmskrange","@stdlib/stats-base-nanrange":"@stdlib/stats/base/nanrange","@stdlib/stats-base-nanrange-by":"@stdlib/stats/base/nanrange-by","@stdlib/stats-base-nanstdev":"@stdlib/stats/base/nanstdev","@stdlib/stats-base-nanstdevch":"@stdlib/stats/base/nanstdevch","@stdlib/stats-base-nanstdevpn":"@stdlib/stats/base/nanstdevpn","@stdlib/stats-base-nanstdevtk":"@stdlib/stats/base/nanstdevtk","@stdlib/stats-base-nanstdevwd":"@stdlib/stats/base/nanstdevwd","@stdlib/stats-base-nanstdevyc":"@stdlib/stats/base/nanstdevyc","@stdlib/stats-base-nanvariance":"@stdlib/stats/base/nanvariance","@stdlib/stats-base-nanvariancech":"@stdlib/stats/base/nanvariancech","@stdlib/stats-base-nanvariancepn":"@stdlib/stats/base/nanvariancepn","@stdlib/stats-base-nanvariancetk":"@stdlib/stats/base/nanvariancetk","@stdlib/stats-base-nanvariancewd":"@stdlib/stats/base/nanvariancewd","@stdlib/stats-base-nanvarianceyc":"@stdlib/stats/base/nanvarianceyc","@stdlib/strided-base-nullary":"@stdlib/strided/base/nullary","@stdlib/strided-base-offset-view":"@stdlib/strided/base/offset-view","@stdlib/strided-base-quaternary":"@stdlib/strided/base/quaternary","@stdlib/strided-base-quinary":"@stdlib/strided/base/quinary","@stdlib/stats-base-range":"@stdlib/stats/base/range","@stdlib/stats-base-range-by":"@stdlib/stats/base/range-by","@stdlib/strided-base-reinterpret-complex":"@stdlib/strided/base/reinterpret-complex","@stdlib/strided-base-reinterpret-complex64":"@stdlib/strided/base/reinterpret-complex64","@stdlib/strided-base-reinterpret-complex128":"@stdlib/strided/base/reinterpret-complex128","@stdlib/math-strided-special-sabs":"@stdlib/math/strided/special/sabs","@stdlib/math-strided-special-sabs2":"@stdlib/math/strided/special/sabs2","@stdlib/blas-ext-base-sapx":"@stdlib/blas/ext/base/sapx","@stdlib/blas-ext-base-sapxsum":"@stdlib/blas/ext/base/sapxsum","@stdlib/blas-ext-base-sapxsumkbn":"@stdlib/blas/ext/base/sapxsumkbn","@stdlib/blas-ext-base-sapxsumkbn2":"@stdlib/blas/ext/base/sapxsumkbn2","@stdlib/blas-ext-base-sapxsumors":"@stdlib/blas/ext/base/sapxsumors","@stdlib/blas-ext-base-sapxsumpw":"@stdlib/blas/ext/base/sapxsumpw","@stdlib/blas-base-sasum":"@stdlib/blas/base/sasum","@stdlib/blas-ext-base-sasumpw":"@stdlib/blas/ext/base/sasumpw","@stdlib/blas-base-saxpy":"@stdlib/blas/base/saxpy","@stdlib/math-strided-special-scbrt":"@stdlib/math/strided/special/scbrt","@stdlib/math-strided-special-sceil":"@stdlib/math/strided/special/sceil","@stdlib/blas-base-scopy":"@stdlib/blas/base/scopy","@stdlib/stats-base-scumax":"@stdlib/stats/base/scumax","@stdlib/stats-base-scumaxabs":"@stdlib/stats/base/scumaxabs","@stdlib/stats-base-scumin":"@stdlib/stats/base/scumin","@stdlib/stats-base-scuminabs":"@stdlib/stats/base/scuminabs","@stdlib/blas-ext-base-scusum":"@stdlib/blas/ext/base/scusum","@stdlib/blas-ext-base-scusumkbn":"@stdlib/blas/ext/base/scusumkbn","@stdlib/blas-ext-base-scusumkbn2":"@stdlib/blas/ext/base/scusumkbn2","@stdlib/blas-ext-base-scusumors":"@stdlib/blas/ext/base/scusumors","@stdlib/blas-ext-base-scusumpw":"@stdlib/blas/ext/base/scusumpw","@stdlib/math-strided-special-sdeg2rad":"@stdlib/math/strided/special/sdeg2rad","@stdlib/blas-base-sdot":"@stdlib/blas/base/sdot","@stdlib/blas-ext-base-sdsapxsum":"@stdlib/blas/ext/base/sdsapxsum","@stdlib/blas-ext-base-sdsapxsumpw":"@stdlib/blas/ext/base/sdsapxsumpw","@stdlib/blas-base-sdsdot":"@stdlib/blas/base/sdsdot","@stdlib/stats-base-sdsmean":"@stdlib/stats/base/sdsmean","@stdlib/stats-base-sdsmeanors":"@stdlib/stats/base/sdsmeanors","@stdlib/stats-base-sdsnanmean":"@stdlib/stats/base/sdsnanmean","@stdlib/stats-base-sdsnanmeanors":"@stdlib/stats/base/sdsnanmeanors","@stdlib/blas-ext-base-sdsnansum":"@stdlib/blas/ext/base/sdsnansum","@stdlib/blas-ext-base-sdsnansumpw":"@stdlib/blas/ext/base/sdsnansumpw","@stdlib/blas-ext-base-sdssum":"@stdlib/blas/ext/base/sdssum","@stdlib/blas-ext-base-sdssumpw":"@stdlib/blas/ext/base/sdssumpw","@stdlib/blas-ext-base-sfill":"@stdlib/blas/ext/base/sfill","@stdlib/math-strided-special-sfloor":"@stdlib/math/strided/special/sfloor","@stdlib/math-strided-special-sinv":"@stdlib/math/strided/special/sinv","@stdlib/strided-base-smap":"@stdlib/strided/base/smap","@stdlib/strided-base-smap2":"@stdlib/strided/base/smap2","@stdlib/stats-base-smax":"@stdlib/stats/base/smax","@stdlib/stats-base-smaxabs":"@stdlib/stats/base/smaxabs","@stdlib/stats-base-smaxabssorted":"@stdlib/stats/base/smaxabssorted","@stdlib/stats-base-smaxsorted":"@stdlib/stats/base/smaxsorted","@stdlib/stats-base-smean":"@stdlib/stats/base/smean","@stdlib/stats-base-smeankbn":"@stdlib/stats/base/smeankbn","@stdlib/stats-base-smeankbn2":"@stdlib/stats/base/smeankbn2","@stdlib/stats-base-smeanli":"@stdlib/stats/base/smeanli","@stdlib/stats-base-smeanlipw":"@stdlib/stats/base/smeanlipw","@stdlib/stats-base-smeanors":"@stdlib/stats/base/smeanors","@stdlib/stats-base-smeanpn":"@stdlib/stats/base/smeanpn","@stdlib/stats-base-smeanpw":"@stdlib/stats/base/smeanpw","@stdlib/stats-base-smeanwd":"@stdlib/stats/base/smeanwd","@stdlib/stats-base-smediansorted":"@stdlib/stats/base/smediansorted","@stdlib/stats-base-smidrange":"@stdlib/stats/base/smidrange","@stdlib/stats-base-smin":"@stdlib/stats/base/smin","@stdlib/stats-base-sminabs":"@stdlib/stats/base/sminabs","@stdlib/stats-base-sminsorted":"@stdlib/stats/base/sminsorted","@stdlib/math-strided-special-smskabs":"@stdlib/math/strided/special/smskabs","@stdlib/math-strided-special-smskabs2":"@stdlib/math/strided/special/smskabs2","@stdlib/math-strided-special-smskcbrt":"@stdlib/math/strided/special/smskcbrt","@stdlib/math-strided-special-smskceil":"@stdlib/math/strided/special/smskceil","@stdlib/math-strided-special-smskdeg2rad":"@stdlib/math/strided/special/smskdeg2rad","@stdlib/math-strided-special-smskfloor":"@stdlib/math/strided/special/smskfloor","@stdlib/math-strided-special-smskinv":"@stdlib/math/strided/special/smskinv","@stdlib/strided-base-smskmap":"@stdlib/strided/base/smskmap","@stdlib/strided-base-smskmap2":"@stdlib/strided/base/smskmap2","@stdlib/stats-base-smskmax":"@stdlib/stats/base/smskmax","@stdlib/stats-base-smskmin":"@stdlib/stats/base/smskmin","@stdlib/math-strided-special-smskramp":"@stdlib/math/strided/special/smskramp","@stdlib/stats-base-smskrange":"@stdlib/stats/base/smskrange","@stdlib/math-strided-special-smskrsqrt":"@stdlib/math/strided/special/smskrsqrt","@stdlib/math-strided-special-smsksqrt":"@stdlib/math/strided/special/smsksqrt","@stdlib/math-strided-special-smsktrunc":"@stdlib/math/strided/special/smsktrunc","@stdlib/stats-base-snanmax":"@stdlib/stats/base/snanmax","@stdlib/stats-base-snanmaxabs":"@stdlib/stats/base/snanmaxabs","@stdlib/stats-base-snanmean":"@stdlib/stats/base/snanmean","@stdlib/stats-base-snanmeanors":"@stdlib/stats/base/snanmeanors","@stdlib/stats-base-snanmeanpn":"@stdlib/stats/base/snanmeanpn","@stdlib/stats-base-snanmeanwd":"@stdlib/stats/base/snanmeanwd","@stdlib/stats-base-snanmin":"@stdlib/stats/base/snanmin","@stdlib/stats-base-snanminabs":"@stdlib/stats/base/snanminabs","@stdlib/stats-base-snanmskmax":"@stdlib/stats/base/snanmskmax","@stdlib/stats-base-snanmskmin":"@stdlib/stats/base/snanmskmin","@stdlib/stats-base-snanmskrange":"@stdlib/stats/base/snanmskrange","@stdlib/stats-base-snanrange":"@stdlib/stats/base/snanrange","@stdlib/stats-base-snanstdev":"@stdlib/stats/base/snanstdev","@stdlib/stats-base-snanstdevch":"@stdlib/stats/base/snanstdevch","@stdlib/stats-base-snanstdevpn":"@stdlib/stats/base/snanstdevpn","@stdlib/stats-base-snanstdevtk":"@stdlib/stats/base/snanstdevtk","@stdlib/stats-base-snanstdevwd":"@stdlib/stats/base/snanstdevwd","@stdlib/stats-base-snanstdevyc":"@stdlib/stats/base/snanstdevyc","@stdlib/blas-ext-base-snansum":"@stdlib/blas/ext/base/snansum","@stdlib/blas-ext-base-snansumkbn":"@stdlib/blas/ext/base/snansumkbn","@stdlib/blas-ext-base-snansumkbn2":"@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas-ext-base-snansumors":"@stdlib/blas/ext/base/snansumors","@stdlib/blas-ext-base-snansumpw":"@stdlib/blas/ext/base/snansumpw","@stdlib/stats-base-snanvariance":"@stdlib/stats/base/snanvariance","@stdlib/stats-base-snanvariancech":"@stdlib/stats/base/snanvariancech","@stdlib/stats-base-snanvariancepn":"@stdlib/stats/base/snanvariancepn","@stdlib/stats-base-snanvariancetk":"@stdlib/stats/base/snanvariancetk","@stdlib/stats-base-snanvariancewd":"@stdlib/stats/base/snanvariancewd","@stdlib/stats-base-snanvarianceyc":"@stdlib/stats/base/snanvarianceyc","@stdlib/blas-base-snrm2":"@stdlib/blas/base/snrm2","@stdlib/math-strided-special-sramp":"@stdlib/math/strided/special/sramp","@stdlib/stats-base-srange":"@stdlib/stats/base/srange","@stdlib/blas-ext-base-srev":"@stdlib/blas/ext/base/srev","@stdlib/math-strided-special-srsqrt":"@stdlib/math/strided/special/srsqrt","@stdlib/blas-base-sscal":"@stdlib/blas/base/sscal","@stdlib/blas-ext-base-ssort2hp":"@stdlib/blas/ext/base/ssort2hp","@stdlib/blas-ext-base-ssort2ins":"@stdlib/blas/ext/base/ssort2ins","@stdlib/blas-ext-base-ssort2sh":"@stdlib/blas/ext/base/ssort2sh","@stdlib/blas-ext-base-ssorthp":"@stdlib/blas/ext/base/ssorthp","@stdlib/blas-ext-base-ssortins":"@stdlib/blas/ext/base/ssortins","@stdlib/blas-ext-base-ssortsh":"@stdlib/blas/ext/base/ssortsh","@stdlib/math-strided-special-ssqrt":"@stdlib/math/strided/special/ssqrt","@stdlib/stats-base-sstdev":"@stdlib/stats/base/sstdev","@stdlib/stats-base-sstdevch":"@stdlib/stats/base/sstdevch","@stdlib/stats-base-sstdevpn":"@stdlib/stats/base/sstdevpn","@stdlib/stats-base-sstdevtk":"@stdlib/stats/base/sstdevtk","@stdlib/stats-base-sstdevwd":"@stdlib/stats/base/sstdevwd","@stdlib/stats-base-sstdevyc":"@stdlib/stats/base/sstdevyc","@stdlib/blas-ext-base-ssum":"@stdlib/blas/ext/base/ssum","@stdlib/blas-ext-base-ssumkbn":"@stdlib/blas/ext/base/ssumkbn","@stdlib/blas-ext-base-ssumkbn2":"@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas-ext-base-ssumors":"@stdlib/blas/ext/base/ssumors","@stdlib/blas-ext-base-ssumpw":"@stdlib/blas/ext/base/ssumpw","@stdlib/blas-base-sswap":"@stdlib/blas/base/sswap","@stdlib/stats-base-stdev":"@stdlib/stats/base/stdev","@stdlib/stats-base-stdevch":"@stdlib/stats/base/stdevch","@stdlib/stats-base-stdevpn":"@stdlib/stats/base/stdevpn","@stdlib/stats-base-stdevtk":"@stdlib/stats/base/stdevtk","@stdlib/stats-base-stdevwd":"@stdlib/stats/base/stdevwd","@stdlib/stats-base-stdevyc":"@stdlib/stats/base/stdevyc","@stdlib/math-strided-special-strunc":"@stdlib/math/strided/special/strunc","@stdlib/stats-base-svariance":"@stdlib/stats/base/svariance","@stdlib/stats-base-svariancech":"@stdlib/stats/base/svariancech","@stdlib/stats-base-svariancepn":"@stdlib/stats/base/svariancepn","@stdlib/stats-base-svariancetk":"@stdlib/stats/base/svariancetk","@stdlib/stats-base-svariancewd":"@stdlib/stats/base/svariancewd","@stdlib/stats-base-svarianceyc":"@stdlib/stats/base/svarianceyc","@stdlib/strided-base-ternary":"@stdlib/strided/base/ternary","@stdlib/strided-base-unary":"@stdlib/strided/base/unary","@stdlib/strided-base-unary-by":"@stdlib/strided/base/unary-by","@stdlib/strided-base-unary-dtype-signatures":"@stdlib/strided/base/unary-dtype-signatures","@stdlib/strided-base-unary-signature-callbacks":"@stdlib/strided/base/unary-signature-callbacks","@stdlib/stats-base-variance":"@stdlib/stats/base/variance","@stdlib/stats-base-variancech":"@stdlib/stats/base/variancech","@stdlib/stats-base-variancepn":"@stdlib/stats/base/variancepn","@stdlib/stats-base-variancetk":"@stdlib/stats/base/variancetk","@stdlib/stats-base-variancewd":"@stdlib/stats/base/variancewd","@stdlib/stats-base-varianceyc":"@stdlib/stats/base/varianceyc","@stdlib/strided-base-zmap":"@stdlib/strided/base/zmap","@stdlib/slice-base-str2multislice":"@stdlib/slice/base/str2multislice","@stdlib/slice-base-str2slice":"@stdlib/slice/base/str2slice","@stdlib/number-float64-base-sub":"@stdlib/number/float64/base/sub","@stdlib/math-base-ops-subf":"@stdlib/math/base/ops/subf","@stdlib/math-base-tools-sum-series":"@stdlib/math/base/tools/sum-series","@stdlib/math-base-special-tan":"@stdlib/math/base/special/tan","@stdlib/math-base-special-tand":"@stdlib/math/base/special/tand","@stdlib/math-base-special-tanh":"@stdlib/math/base/special/tanh","@stdlib/number-float64-base-to-binary-string":"@stdlib/number/float64/base/to-binary-string","@stdlib/number-float32-base-to-binary-string":"@stdlib/number/float32/base/to-binary-string","@stdlib/number-uint8-base-to-binary-string":"@stdlib/number/uint8/base/to-binary-string","@stdlib/number-uint16-base-to-binary-string":"@stdlib/number/uint16/base/to-binary-string","@stdlib/number-uint32-base-to-binary-string":"@stdlib/number/uint32/base/to-binary-string","@stdlib/number-float32-base-to-word":"@stdlib/number/float32/base/to-word","@stdlib/number-float64-base-to-words":"@stdlib/number/float64/base/to-words","@stdlib/ndarray-base-transpose":"@stdlib/ndarray/base/transpose","@stdlib/math-base-special-tribonacci":"@stdlib/math/base/special/tribonacci","@stdlib/math-base-special-trigamma":"@stdlib/math/base/special/trigamma","@stdlib/string-base-trim":"@stdlib/string/base/trim","@stdlib/math-base-special-trunc":"@stdlib/math/base/special/trunc","@stdlib/math-base-special-trunc2":"@stdlib/math/base/special/trunc2","@stdlib/math-base-special-trunc10":"@stdlib/math/base/special/trunc10","@stdlib/string-base-truncate-middle":"@stdlib/string/base/truncate-middle","@stdlib/math-base-special-truncb":"@stdlib/math/base/special/truncb","@stdlib/math-base-special-truncf":"@stdlib/math/base/special/truncf","@stdlib/math-base-special-truncn":"@stdlib/math/base/special/truncn","@stdlib/math-base-special-truncsd":"@stdlib/math/base/special/truncsd","@stdlib/number-uint32-base-to-int32":"@stdlib/number/uint32/base/to-int32","@stdlib/math-base-ops-umul":"@stdlib/math/base/ops/umul","@stdlib/math-base-ops-umuldw":"@stdlib/math/base/ops/umuldw","@stdlib/string-base-uncapitalize":"@stdlib/string/base/uncapitalize","@stdlib/string-base-uppercase":"@stdlib/string/base/uppercase","@stdlib/math-base-special-vercos":"@stdlib/math/base/special/vercos","@stdlib/math-base-special-versin":"@stdlib/math/base/special/versin","@stdlib/math-base-special-wrap":"@stdlib/math/base/special/wrap","@stdlib/math-base-special-xlog1py":"@stdlib/math/base/special/xlog1py","@stdlib/math-base-special-xlogy":"@stdlib/math/base/special/xlogy","@stdlib/math-base-special-riemann-zeta":"@stdlib/math/base/special/riemann-zeta","@stdlib/bench":"@stdlib/bench","@stdlib/datasets-berndt-cps-wages-1985":"@stdlib/datasets/berndt-cps-wages-1985","@stdlib/utils-bifurcate":"@stdlib/utils/bifurcate","@stdlib/utils-bifurcate-by":"@stdlib/utils/bifurcate-by","@stdlib/utils-async-bifurcate-by":"@stdlib/utils/async/bifurcate-by","@stdlib/utils-bifurcate-in":"@stdlib/utils/bifurcate-in","@stdlib/utils-bifurcate-own":"@stdlib/utils/bifurcate-own","@stdlib/bigint-ctor":"@stdlib/bigint/ctor","@stdlib/stats-binomial-test":"@stdlib/stats/binomial-test","@stdlib/boolean-ctor":"@stdlib/boolean/ctor","@stdlib/array-bool":"@stdlib/array/bool","@stdlib/ndarray-broadcast-array":"@stdlib/ndarray/broadcast-array","@stdlib/ndarray-broadcast-arrays":"@stdlib/ndarray/broadcast-arrays","@stdlib/buffer-ctor":"@stdlib/buffer/ctor","@stdlib/buffer-to-json":"@stdlib/buffer/to-json","@stdlib/os-byte-order":"@stdlib/os/byte-order","@stdlib/string-camelcase":"@stdlib/string/camelcase","@stdlib/string-capitalize":"@stdlib/string/capitalize","@stdlib/utils-capitalize-keys":"@stdlib/utils/capitalize-keys","@stdlib/constants-float64-catalan":"@stdlib/constants/float64/catalan","@stdlib/constants-float64-cbrt-eps":"@stdlib/constants/float64/cbrt-eps","@stdlib/datasets-cdc-nchs-us-births-1969-1988":"@stdlib/datasets/cdc-nchs-us-births-1969-1988","@stdlib/datasets-cdc-nchs-us-births-1994-2003":"@stdlib/datasets/cdc-nchs-us-births-1994-2003","@stdlib/datasets-cdc-nchs-us-infant-mortality-bw-1915-2013":"@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013","@stdlib/process-chdir":"@stdlib/process/chdir","@stdlib/stats-chi2gof":"@stdlib/stats/chi2gof","@stdlib/stats-chi2test":"@stdlib/stats/chi2test","@stdlib/array-to-circular-iterator":"@stdlib/array/to-circular-iterator","@stdlib/streams-node-from-circular-array":"@stdlib/streams/node/from-circular-array","@stdlib/dstructs-circular-buffer":"@stdlib/dstructs/circular-buffer","@stdlib/fs-close":"@stdlib/fs/close","@stdlib/datasets-cmudict":"@stdlib/datasets/cmudict","@stdlib/string-code-point-at":"@stdlib/string/code-point-at","@stdlib/utils-common-keys":"@stdlib/utils/common-keys","@stdlib/utils-common-keys-in":"@stdlib/utils/common-keys-in","@stdlib/complex-cmplx":"@stdlib/complex/cmplx","@stdlib/complex-float32-ctor":"@stdlib/complex/float32/ctor","@stdlib/constants-complex64-nan":"@stdlib/constants/complex64/nan","@stdlib/constants-complex64-num-bytes":"@stdlib/constants/complex64/num-bytes","@stdlib/constants-complex64-zero":"@stdlib/constants/complex64/zero","@stdlib/array-complex64":"@stdlib/array/complex64","@stdlib/complex-float64-ctor":"@stdlib/complex/float64/ctor","@stdlib/constants-complex128-nan":"@stdlib/constants/complex128/nan","@stdlib/constants-complex128-num-bytes":"@stdlib/constants/complex128/num-bytes","@stdlib/constants-complex128-zero":"@stdlib/constants/complex128/zero","@stdlib/array-complex128":"@stdlib/array/complex128","@stdlib/array-typed-complex":"@stdlib/array/typed-complex","@stdlib/array-typed-complex-ctors":"@stdlib/array/typed-complex-ctors","@stdlib/array-typed-complex-dtypes":"@stdlib/array/typed-complex-dtypes","@stdlib/complex-ctors":"@stdlib/complex/ctors","@stdlib/complex-dtype":"@stdlib/complex/dtype","@stdlib/complex-dtypes":"@stdlib/complex/dtypes","@stdlib/complex-promotion-rules":"@stdlib/complex/promotion-rules","@stdlib/utils-compose":"@stdlib/utils/compose","@stdlib/utils-async-compose":"@stdlib/utils/async/compose","@stdlib/os-configdir":"@stdlib/os/configdir","@stdlib/complex-float64-conj":"@stdlib/complex/float64/conj","@stdlib/complex-float32-conj":"@stdlib/complex/float32/conj","@stdlib/string-constantcase":"@stdlib/string/constantcase","@stdlib/utils-constant-function":"@stdlib/utils/constant-function","@stdlib/streams-node-from-constant":"@stdlib/streams/node/from-constant","@stdlib/utils-constructor-name":"@stdlib/utils/constructor-name","@stdlib/assert-contains":"@stdlib/assert/contains","@stdlib/array-convert":"@stdlib/array/convert","@stdlib/array-convert-same":"@stdlib/array/convert-same","@stdlib/utils-convert-path":"@stdlib/utils/convert-path","@stdlib/utils-copy":"@stdlib/utils/copy","@stdlib/buffer-from-buffer":"@stdlib/buffer/from-buffer","@stdlib/utils-count-by":"@stdlib/utils/count-by","@stdlib/utils-async-count-by":"@stdlib/utils/async/count-by","@stdlib/time-current-year":"@stdlib/time/current-year","@stdlib/utils-curry":"@stdlib/utils/curry","@stdlib/utils-curry-right":"@stdlib/utils/curry-right","@stdlib/process-cwd":"@stdlib/process/cwd","@stdlib/datasets-dale-chall-new":"@stdlib/datasets/dale-chall-new","@stdlib/datasets":"@stdlib/datasets","@stdlib/array-dataview":"@stdlib/array/dataview","@stdlib/array-datespace":"@stdlib/array/datespace","@stdlib/time-day-of-quarter":"@stdlib/time/day-of-quarter","@stdlib/time-day-of-year":"@stdlib/time/day-of-year","@stdlib/time-days-in-month":"@stdlib/time/days-in-month","@stdlib/time-days-in-year":"@stdlib/time/days-in-year","@stdlib/blas-ddot":"@stdlib/blas/ddot","@stdlib/streams-node-debug-sink":"@stdlib/streams/node/debug-sink","@stdlib/streams-node-debug":"@stdlib/streams/node/debug","@stdlib/utils-decorate-after":"@stdlib/utils/decorate-after","@stdlib/assert-deep-equal":"@stdlib/assert/deep-equal","@stdlib/utils-deep-get":"@stdlib/utils/deep-get","@stdlib/assert-deep-has-own-property":"@stdlib/assert/deep-has-own-property","@stdlib/assert-deep-has-property":"@stdlib/assert/deep-has-property","@stdlib/utils-deep-pluck":"@stdlib/utils/deep-pluck","@stdlib/utils-deep-set":"@stdlib/utils/deep-set","@stdlib/utils-define-memoized-property":"@stdlib/utils/define-memoized-property","@stdlib/utils-define-properties":"@stdlib/utils/define-properties","@stdlib/utils-define-property":"@stdlib/utils/define-property","@stdlib/utils-dirname":"@stdlib/utils/dirname","@stdlib/string-dotcase":"@stdlib/string/dotcase","@stdlib/dstructs-doubly-linked-list":"@stdlib/dstructs/doubly-linked-list","@stdlib/utils-do-until":"@stdlib/utils/do-until","@stdlib/utils-async-do-until":"@stdlib/utils/async/do-until","@stdlib/utils-do-until-each":"@stdlib/utils/do-until-each","@stdlib/utils-do-until-each-right":"@stdlib/utils/do-until-each-right","@stdlib/utils-do-while":"@stdlib/utils/do-while","@stdlib/utils-async-do-while":"@stdlib/utils/async/do-while","@stdlib/utils-do-while-each":"@stdlib/utils/do-while-each","@stdlib/utils-do-while-each-right":"@stdlib/utils/do-while-each-right","@stdlib/blas-dswap":"@stdlib/blas/dswap","@stdlib/constants-float64-e":"@stdlib/constants/float64/e","@stdlib/datasets-emoji":"@stdlib/datasets/emoji","@stdlib/datasets-emoji-code-picto":"@stdlib/datasets/emoji-code-picto","@stdlib/datasets-emoji-picto-code":"@stdlib/datasets/emoji-picto-code","@stdlib/streams-node-empty":"@stdlib/streams/node/empty","@stdlib/string-ends-with":"@stdlib/string/ends-with","@stdlib/utils-enumerable-properties":"@stdlib/utils/enumerable-properties","@stdlib/utils-enumerable-properties-in":"@stdlib/utils/enumerable-properties-in","@stdlib/utils-enumerable-property-symbols":"@stdlib/utils/enumerable-property-symbols","@stdlib/utils-enumerable-property-symbols-in":"@stdlib/utils/enumerable-property-symbols-in","@stdlib/process-env":"@stdlib/process/env","@stdlib/constants-float64-eps":"@stdlib/constants/float64/eps","@stdlib/error-to-json":"@stdlib/error/to-json","@stdlib/constants-float64-eulergamma":"@stdlib/constants/float64/eulergamma","@stdlib/utils-every":"@stdlib/utils/every","@stdlib/utils-every-by":"@stdlib/utils/every-by","@stdlib/utils-async-every-by":"@stdlib/utils/async/every-by","@stdlib/utils-every-by-right":"@stdlib/utils/every-by-right","@stdlib/utils-async-every-by-right":"@stdlib/utils/async/every-by-right","@stdlib/utils-every-in-by":"@stdlib/utils/every-in-by","@stdlib/utils-every-own-by":"@stdlib/utils/every-own-by","@stdlib/utils-eval":"@stdlib/utils/eval","@stdlib/process-exec-path":"@stdlib/process/exec-path","@stdlib/fs-exists":"@stdlib/fs/exists","@stdlib/nlp-expand-acronyms":"@stdlib/nlp/expand-acronyms","@stdlib/nlp-expand-contractions":"@stdlib/nlp/expand-contractions","@stdlib/utils-extname":"@stdlib/utils/extname","@stdlib/ndarray-fancy":"@stdlib/ndarray/fancy","@stdlib/math-base-special-fast-abs":"@stdlib/math/base/special/fast/abs","@stdlib/math-base-special-fast-acosh":"@stdlib/math/base/special/fast/acosh","@stdlib/math-base-special-fast-alpha-max-plus-beta-min":"@stdlib/math/base/special/fast/alpha-max-plus-beta-min","@stdlib/math-base-special-fast-asinh":"@stdlib/math/base/special/fast/asinh","@stdlib/math-base-special-fast-atanh":"@stdlib/math/base/special/fast/atanh","@stdlib/math-base-special-fast-hypot":"@stdlib/math/base/special/fast/hypot","@stdlib/math-base-special-fast-uint32-log2":"@stdlib/math/base/special/fast/uint32-log2","@stdlib/math-base-special-fast-max":"@stdlib/math/base/special/fast/max","@stdlib/math-base-special-fast-min":"@stdlib/math/base/special/fast/min","@stdlib/math-base-special-fast-pow-int":"@stdlib/math/base/special/fast/pow-int","@stdlib/math-base-special-fast-uint32-sqrt":"@stdlib/math/base/special/fast/uint32-sqrt","@stdlib/datasets-female-first-names-en":"@stdlib/datasets/female-first-names-en","@stdlib/dstructs-fifo":"@stdlib/dstructs/fifo","@stdlib/array-filled":"@stdlib/array/filled","@stdlib/array-filled-by":"@stdlib/array/filled-by","@stdlib/utils-filter-arguments":"@stdlib/utils/filter-arguments","@stdlib/utils-find":"@stdlib/utils/find","@stdlib/string-first":"@stdlib/string/first","@stdlib/datasets-fivethirtyeight-ffq":"@stdlib/datasets/fivethirtyeight-ffq","@stdlib/utils-flatten-array":"@stdlib/utils/flatten-array","@stdlib/utils-flatten-object":"@stdlib/utils/flatten-object","@stdlib/stats-fligner-test":"@stdlib/stats/fligner-test","@stdlib/os-float-word-order":"@stdlib/os/float-word-order","@stdlib/constants-float16-cbrt-eps":"@stdlib/constants/float16/cbrt-eps","@stdlib/constants-float16-eps":"@stdlib/constants/float16/eps","@stdlib/constants-float16-exponent-bias":"@stdlib/constants/float16/exponent-bias","@stdlib/constants-float16-max":"@stdlib/constants/float16/max","@stdlib/constants-float16-max-safe-integer":"@stdlib/constants/float16/max-safe-integer","@stdlib/constants-float16-min-safe-integer":"@stdlib/constants/float16/min-safe-integer","@stdlib/constants-float16-ninf":"@stdlib/constants/float16/ninf","@stdlib/constants-float16-num-bytes":"@stdlib/constants/float16/num-bytes","@stdlib/constants-float16-pinf":"@stdlib/constants/float16/pinf","@stdlib/constants-float16-precision":"@stdlib/constants/float16/precision","@stdlib/constants-float16-smallest-normal":"@stdlib/constants/float16/smallest-normal","@stdlib/constants-float16-smallest-subnormal":"@stdlib/constants/float16/smallest-subnormal","@stdlib/constants-float16-sqrt-eps":"@stdlib/constants/float16/sqrt-eps","@stdlib/constants-float32-abs-mask":"@stdlib/constants/float32/abs-mask","@stdlib/constants-float32-cbrt-eps":"@stdlib/constants/float32/cbrt-eps","@stdlib/constants-float32-e":"@stdlib/constants/float32/e","@stdlib/constants-float32-eps":"@stdlib/constants/float32/eps","@stdlib/constants-float32-exponent-bias":"@stdlib/constants/float32/exponent-bias","@stdlib/constants-float32-exponent-mask":"@stdlib/constants/float32/exponent-mask","@stdlib/constants-float32-fourth-pi":"@stdlib/constants/float32/fourth-pi","@stdlib/constants-float32-half-ln-two":"@stdlib/constants/float32/half-ln-two","@stdlib/constants-float32-half-pi":"@stdlib/constants/float32/half-pi","@stdlib/constants-float32-ln-half":"@stdlib/constants/float32/ln-half","@stdlib/constants-float32-ln-pi":"@stdlib/constants/float32/ln-pi","@stdlib/constants-float32-ln-ten":"@stdlib/constants/float32/ln-ten","@stdlib/constants-float32-ln-two":"@stdlib/constants/float32/ln-two","@stdlib/constants-float32-max":"@stdlib/constants/float32/max","@stdlib/constants-float32-max-base2-exponent":"@stdlib/constants/float32/max-base2-exponent","@stdlib/constants-float32-max-base2-exponent-subnormal":"@stdlib/constants/float32/max-base2-exponent-subnormal","@stdlib/constants-float32-max-base10-exponent":"@stdlib/constants/float32/max-base10-exponent","@stdlib/constants-float32-max-base10-exponent-subnormal":"@stdlib/constants/float32/max-base10-exponent-subnormal","@stdlib/constants-float32-max-safe-fibonacci":"@stdlib/constants/float32/max-safe-fibonacci","@stdlib/constants-float32-max-safe-integer":"@stdlib/constants/float32/max-safe-integer","@stdlib/constants-float32-max-safe-nth-factorial":"@stdlib/constants/float32/max-safe-nth-factorial","@stdlib/constants-float32-max-safe-nth-fibonacci":"@stdlib/constants/float32/max-safe-nth-fibonacci","@stdlib/constants-float32-max-safe-nth-lucas":"@stdlib/constants/float32/max-safe-nth-lucas","@stdlib/constants-float32-min-base2-exponent":"@stdlib/constants/float32/min-base2-exponent","@stdlib/constants-float32-min-base2-exponent-subnormal":"@stdlib/constants/float32/min-base2-exponent-subnormal","@stdlib/constants-float32-min-base10-exponent":"@stdlib/constants/float32/min-base10-exponent","@stdlib/constants-float32-min-base10-exponent-subnormal":"@stdlib/constants/float32/min-base10-exponent-subnormal","@stdlib/constants-float32-min-safe-integer":"@stdlib/constants/float32/min-safe-integer","@stdlib/constants-float32-nan":"@stdlib/constants/float32/nan","@stdlib/constants-float32-ninf":"@stdlib/constants/float32/ninf","@stdlib/constants-float32-num-bytes":"@stdlib/constants/float32/num-bytes","@stdlib/constants-float32-phi":"@stdlib/constants/float32/phi","@stdlib/constants-float32-pi":"@stdlib/constants/float32/pi","@stdlib/constants-float32-pinf":"@stdlib/constants/float32/pinf","@stdlib/constants-float32-precision":"@stdlib/constants/float32/precision","@stdlib/constants-float32-sign-mask":"@stdlib/constants/float32/sign-mask","@stdlib/constants-float32-significand-mask":"@stdlib/constants/float32/significand-mask","@stdlib/constants-float32-smallest-normal":"@stdlib/constants/float32/smallest-normal","@stdlib/constants-float32-smallest-subnormal":"@stdlib/constants/float32/smallest-subnormal","@stdlib/constants-float32-sqrt-eps":"@stdlib/constants/float32/sqrt-eps","@stdlib/constants-float32-sqrt-half":"@stdlib/constants/float32/sqrt-half","@stdlib/constants-float32-sqrt-half-pi":"@stdlib/constants/float32/sqrt-half-pi","@stdlib/constants-float32-sqrt-phi":"@stdlib/constants/float32/sqrt-phi","@stdlib/constants-float32-sqrt-pi":"@stdlib/constants/float32/sqrt-pi","@stdlib/constants-float32-sqrt-three":"@stdlib/constants/float32/sqrt-three","@stdlib/constants-float32-sqrt-two":"@stdlib/constants/float32/sqrt-two","@stdlib/constants-float32-sqrt-two-pi":"@stdlib/constants/float32/sqrt-two-pi","@stdlib/constants-float32-two-pi":"@stdlib/constants/float32/two-pi","@stdlib/array-float32":"@stdlib/array/float32","@stdlib/array-fixed-endian-float32":"@stdlib/array/fixed-endian-float32","@stdlib/array-little-endian-float32":"@stdlib/array/little-endian-float32","@stdlib/constants-float64-exponent-bias":"@stdlib/constants/float64/exponent-bias","@stdlib/constants-float64-high-word-abs-mask":"@stdlib/constants/float64/high-word-abs-mask","@stdlib/constants-float64-high-word-exponent-mask":"@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants-float64-high-word-sign-mask":"@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants-float64-high-word-significand-mask":"@stdlib/constants/float64/high-word-significand-mask","@stdlib/constants-float64-max":"@stdlib/constants/float64/max","@stdlib/constants-float64-max-base2-exponent":"@stdlib/constants/float64/max-base2-exponent","@stdlib/constants-float64-max-base2-exponent-subnormal":"@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants-float64-max-base10-exponent":"@stdlib/constants/float64/max-base10-exponent","@stdlib/constants-float64-max-base10-exponent-subnormal":"@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants-float64-max-ln":"@stdlib/constants/float64/max-ln","@stdlib/constants-float64-max-safe-fibonacci":"@stdlib/constants/float64/max-safe-fibonacci","@stdlib/constants-float64-max-safe-integer":"@stdlib/constants/float64/max-safe-integer","@stdlib/constants-float64-max-safe-lucas":"@stdlib/constants/float64/max-safe-lucas","@stdlib/constants-float64-max-safe-nth-fibonacci":"@stdlib/constants/float64/max-safe-nth-fibonacci","@stdlib/constants-float64-max-safe-nth-lucas":"@stdlib/constants/float64/max-safe-nth-lucas","@stdlib/constants-float64-min-base2-exponent":"@stdlib/constants/float64/min-base2-exponent","@stdlib/constants-float64-min-base2-exponent-subnormal":"@stdlib/constants/float64/min-base2-exponent-subnormal","@stdlib/constants-float64-min-base10-exponent":"@stdlib/constants/float64/min-base10-exponent","@stdlib/constants-float64-min-base10-exponent-subnormal":"@stdlib/constants/float64/min-base10-exponent-subnormal","@stdlib/constants-float64-min-ln":"@stdlib/constants/float64/min-ln","@stdlib/constants-float64-min-safe-integer":"@stdlib/constants/float64/min-safe-integer","@stdlib/constants-float64-num-bytes":"@stdlib/constants/float64/num-bytes","@stdlib/constants-float64-precision":"@stdlib/constants/float64/precision","@stdlib/constants-float64-smallest-normal":"@stdlib/constants/float64/smallest-normal","@stdlib/constants-float64-smallest-subnormal":"@stdlib/constants/float64/smallest-subnormal","@stdlib/array-float64":"@stdlib/array/float64","@stdlib/array-fixed-endian-float64":"@stdlib/array/fixed-endian-float64","@stdlib/array-little-endian-float64":"@stdlib/array/little-endian-float64","@stdlib/utils-for-each":"@stdlib/utils/for-each","@stdlib/utils-async-for-each":"@stdlib/utils/async/for-each","@stdlib/string-for-each":"@stdlib/string/for-each","@stdlib/utils-for-each-right":"@stdlib/utils/for-each-right","@stdlib/utils-async-for-each-right":"@stdlib/utils/async/for-each-right","@stdlib/utils-for-in":"@stdlib/utils/for-in","@stdlib/string-format":"@stdlib/string/format","@stdlib/utils-for-own":"@stdlib/utils/for-own","@stdlib/constants-float64-fourth-pi":"@stdlib/constants/float64/fourth-pi","@stdlib/constants-float64-fourth-root-eps":"@stdlib/constants/float64/fourth-root-eps","@stdlib/datasets-frb-sf-wage-rigidity":"@stdlib/datasets/frb-sf-wage-rigidity","@stdlib/string-from-code-point":"@stdlib/string/from-code-point","@stdlib/function-ctor":"@stdlib/function/ctor","@stdlib/function-to-string":"@stdlib/function/to-string","@stdlib/utils-function-name":"@stdlib/utils/function-name","@stdlib/utils-function-sequence":"@stdlib/utils/function-sequence","@stdlib/utils-async-function-sequence":"@stdlib/utils/async/function-sequence","@stdlib/constants-float64-gamma-lanczos-g":"@stdlib/constants/float64/gamma-lanczos-g","@stdlib/blas-gdot":"@stdlib/blas/gdot","@stdlib/process-getegid":"@stdlib/process/getegid","@stdlib/process-geteuid":"@stdlib/process/geteuid","@stdlib/process-getgid":"@stdlib/process/getgid","@stdlib/utils-global":"@stdlib/utils/global","@stdlib/utils-get-prototype-of":"@stdlib/utils/get-prototype-of","@stdlib/process-getuid":"@stdlib/process/getuid","@stdlib/constants-float64-glaisher-kinkelin":"@stdlib/constants/float64/glaisher-kinkelin","@stdlib/string-to-grapheme-cluster-iterator":"@stdlib/string/to-grapheme-cluster-iterator","@stdlib/string-to-grapheme-cluster-iterator-right":"@stdlib/string/to-grapheme-cluster-iterator-right","@stdlib/utils-group":"@stdlib/utils/group","@stdlib/utils-group-by":"@stdlib/utils/group-by","@stdlib/utils-async-group-by":"@stdlib/utils/async/group-by","@stdlib/utils-group-in":"@stdlib/utils/group-in","@stdlib/utils-group-own":"@stdlib/utils/group-own","@stdlib/blas-gswap":"@stdlib/blas/gswap","@stdlib/constants-float64-half-ln-two":"@stdlib/constants/float64/half-ln-two","@stdlib/constants-float64-half-pi":"@stdlib/constants/float64/half-pi","@stdlib/datasets-harrison-boston-house-prices":"@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets-harrison-boston-house-prices-corrected":"@stdlib/datasets/harrison-boston-house-prices-corrected","@stdlib/assert-has-arraybuffer-support":"@stdlib/assert/has-arraybuffer-support","@stdlib/assert-has-arrow-function-support":"@stdlib/assert/has-arrow-function-support","@stdlib/assert-has-async-await-support":"@stdlib/assert/has-async-await-support","@stdlib/assert-has-async-iterator-symbol-support":"@stdlib/assert/has-async-iterator-symbol-support","@stdlib/assert-has-atob-support":"@stdlib/assert/has-atob-support","@stdlib/assert-has-bigint64array-support":"@stdlib/assert/has-bigint64array-support","@stdlib/assert-has-bigint-support":"@stdlib/assert/has-bigint-support","@stdlib/assert-has-biguint64array-support":"@stdlib/assert/has-biguint64array-support","@stdlib/assert-has-btoa-support":"@stdlib/assert/has-btoa-support","@stdlib/assert-has-class-support":"@stdlib/assert/has-class-support","@stdlib/assert-has-dataview-support":"@stdlib/assert/has-dataview-support","@stdlib/assert-has-define-properties-support":"@stdlib/assert/has-define-properties-support","@stdlib/assert-has-define-property-support":"@stdlib/assert/has-define-property-support","@stdlib/assert-has-float32array-support":"@stdlib/assert/has-float32array-support","@stdlib/assert-has-float64array-support":"@stdlib/assert/has-float64array-support","@stdlib/assert-has-function-name-support":"@stdlib/assert/has-function-name-support","@stdlib/assert-has-generator-support":"@stdlib/assert/has-generator-support","@stdlib/assert-has-globalthis-support":"@stdlib/assert/has-globalthis-support","@stdlib/assert-has-int8array-support":"@stdlib/assert/has-int8array-support","@stdlib/assert-has-int16array-support":"@stdlib/assert/has-int16array-support","@stdlib/assert-has-int32array-support":"@stdlib/assert/has-int32array-support","@stdlib/assert-has-iterator-symbol-support":"@stdlib/assert/has-iterator-symbol-support","@stdlib/assert-has-map-support":"@stdlib/assert/has-map-support","@stdlib/assert-has-node-buffer-support":"@stdlib/assert/has-node-buffer-support","@stdlib/assert-has-own-property":"@stdlib/assert/has-own-property","@stdlib/assert-has-property":"@stdlib/assert/has-property","@stdlib/assert-has-proxy-support":"@stdlib/assert/has-proxy-support","@stdlib/assert-has-set-support":"@stdlib/assert/has-set-support","@stdlib/assert-has-sharedarraybuffer-support":"@stdlib/assert/has-sharedarraybuffer-support","@stdlib/assert-has-symbol-support":"@stdlib/assert/has-symbol-support","@stdlib/assert-has-tostringtag-support":"@stdlib/assert/has-tostringtag-support","@stdlib/assert-has-uint8array-support":"@stdlib/assert/has-uint8array-support","@stdlib/assert-has-uint8clampedarray-support":"@stdlib/assert/has-uint8clampedarray-support","@stdlib/assert-has-uint16array-support":"@stdlib/assert/has-uint16array-support","@stdlib/assert-has-uint32array-support":"@stdlib/assert/has-uint32array-support","@stdlib/assert-has-utf16-surrogate-pair-at":"@stdlib/assert/has-utf16-surrogate-pair-at","@stdlib/assert-has-weakmap-support":"@stdlib/assert/has-weakmap-support","@stdlib/assert-has-weakset-support":"@stdlib/assert/has-weakset-support","@stdlib/assert-has-wasm-support":"@stdlib/assert/has-wasm-support","@stdlib/string-headercase":"@stdlib/string/headercase","@stdlib/datasets-herndon-venus-semidiameters":"@stdlib/datasets/herndon-venus-semidiameters","@stdlib/os-homedir":"@stdlib/os/homedir","@stdlib/constants-time-hours-in-day":"@stdlib/constants/time/hours-in-day","@stdlib/constants-time-hours-in-week":"@stdlib/constants/time/hours-in-week","@stdlib/time-hours-in-month":"@stdlib/time/hours-in-month","@stdlib/time-hours-in-year":"@stdlib/time/hours-in-year","@stdlib/net-http-server":"@stdlib/net/http-server","@stdlib/utils-identity-function":"@stdlib/utils/identity-function","@stdlib/utils-if-else":"@stdlib/utils/if-else","@stdlib/utils-async-if-else":"@stdlib/utils/async/if-else","@stdlib/utils-if-then":"@stdlib/utils/if-then","@stdlib/utils-async-if-then":"@stdlib/utils/async/if-then","@stdlib/complex-float64-imag":"@stdlib/complex/float64/imag","@stdlib/complex-float32-imag":"@stdlib/complex/float32/imag","@stdlib/datasets-img-acanthus-mollis":"@stdlib/datasets/img-acanthus-mollis","@stdlib/datasets-img-airplane-from-above":"@stdlib/datasets/img-airplane-from-above","@stdlib/datasets-img-allium-oreophilum":"@stdlib/datasets/img-allium-oreophilum","@stdlib/datasets-img-black-canyon":"@stdlib/datasets/img-black-canyon","@stdlib/datasets-img-dust-bowl-home":"@stdlib/datasets/img-dust-bowl-home","@stdlib/datasets-img-french-alpine-landscape":"@stdlib/datasets/img-french-alpine-landscape","@stdlib/datasets-img-locomotion-house-cat":"@stdlib/datasets/img-locomotion-house-cat","@stdlib/datasets-img-locomotion-nude-male":"@stdlib/datasets/img-locomotion-nude-male","@stdlib/datasets-img-march-pastoral":"@stdlib/datasets/img-march-pastoral","@stdlib/datasets-img-nagasaki-boats":"@stdlib/datasets/img-nagasaki-boats","@stdlib/stats-incr-apcorr":"@stdlib/stats/incr/apcorr","@stdlib/ml-incr-binary-classification":"@stdlib/ml/incr/binary-classification","@stdlib/stats-incr-count":"@stdlib/stats/incr/count","@stdlib/stats-incr-covariance":"@stdlib/stats/incr/covariance","@stdlib/stats-incr-covmat":"@stdlib/stats/incr/covmat","@stdlib/stats-incr-cv":"@stdlib/stats/incr/cv","@stdlib/stats-incr-ewmean":"@stdlib/stats/incr/ewmean","@stdlib/stats-incr-ewstdev":"@stdlib/stats/incr/ewstdev","@stdlib/stats-incr-ewvariance":"@stdlib/stats/incr/ewvariance","@stdlib/stats-incr-gmean":"@stdlib/stats/incr/gmean","@stdlib/stats-incr-grubbs":"@stdlib/stats/incr/grubbs","@stdlib/stats-incr-hmean":"@stdlib/stats/incr/hmean","@stdlib/ml-incr-kmeans":"@stdlib/ml/incr/kmeans","@stdlib/stats-incr-kurtosis":"@stdlib/stats/incr/kurtosis","@stdlib/stats-incr-maape":"@stdlib/stats/incr/maape","@stdlib/stats-incr-mae":"@stdlib/stats/incr/mae","@stdlib/stats-incr-mapcorr":"@stdlib/stats/incr/mapcorr","@stdlib/stats-incr-mape":"@stdlib/stats/incr/mape","@stdlib/stats-incr-max":"@stdlib/stats/incr/max","@stdlib/stats-incr-maxabs":"@stdlib/stats/incr/maxabs","@stdlib/stats-incr-mcovariance":"@stdlib/stats/incr/mcovariance","@stdlib/stats-incr-mcv":"@stdlib/stats/incr/mcv","@stdlib/stats-incr-mda":"@stdlib/stats/incr/mda","@stdlib/stats-incr-me":"@stdlib/stats/incr/me","@stdlib/stats-incr-mean":"@stdlib/stats/incr/mean","@stdlib/stats-incr-meanabs":"@stdlib/stats/incr/meanabs","@stdlib/stats-incr-meanabs2":"@stdlib/stats/incr/meanabs2","@stdlib/stats-incr-meanstdev":"@stdlib/stats/incr/meanstdev","@stdlib/stats-incr-meanvar":"@stdlib/stats/incr/meanvar","@stdlib/stats-incr-mgmean":"@stdlib/stats/incr/mgmean","@stdlib/stats-incr-mgrubbs":"@stdlib/stats/incr/mgrubbs","@stdlib/stats-incr-mhmean":"@stdlib/stats/incr/mhmean","@stdlib/stats-incr-midrange":"@stdlib/stats/incr/midrange","@stdlib/stats-incr-min":"@stdlib/stats/incr/min","@stdlib/stats-incr-minabs":"@stdlib/stats/incr/minabs","@stdlib/stats-incr-minmax":"@stdlib/stats/incr/minmax","@stdlib/stats-incr-minmaxabs":"@stdlib/stats/incr/minmaxabs","@stdlib/stats-incr-mmaape":"@stdlib/stats/incr/mmaape","@stdlib/stats-incr-mmae":"@stdlib/stats/incr/mmae","@stdlib/stats-incr-mmape":"@stdlib/stats/incr/mmape","@stdlib/stats-incr-mmax":"@stdlib/stats/incr/mmax","@stdlib/stats-incr-mmaxabs":"@stdlib/stats/incr/mmaxabs","@stdlib/stats-incr-mmda":"@stdlib/stats/incr/mmda","@stdlib/stats-incr-mme":"@stdlib/stats/incr/mme","@stdlib/stats-incr-mmean":"@stdlib/stats/incr/mmean","@stdlib/stats-incr-mmeanabs":"@stdlib/stats/incr/mmeanabs","@stdlib/stats-incr-mmeanabs2":"@stdlib/stats/incr/mmeanabs2","@stdlib/stats-incr-mmeanstdev":"@stdlib/stats/incr/mmeanstdev","@stdlib/stats-incr-mmeanvar":"@stdlib/stats/incr/mmeanvar","@stdlib/stats-incr-mmidrange":"@stdlib/stats/incr/mmidrange","@stdlib/stats-incr-mmin":"@stdlib/stats/incr/mmin","@stdlib/stats-incr-mminabs":"@stdlib/stats/incr/mminabs","@stdlib/stats-incr-mminmax":"@stdlib/stats/incr/mminmax","@stdlib/stats-incr-mminmaxabs":"@stdlib/stats/incr/mminmaxabs","@stdlib/stats-incr-mmpe":"@stdlib/stats/incr/mmpe","@stdlib/stats-incr-mmse":"@stdlib/stats/incr/mmse","@stdlib/stats-incr-mpcorr":"@stdlib/stats/incr/mpcorr","@stdlib/stats-incr-mpcorr2":"@stdlib/stats/incr/mpcorr2","@stdlib/stats-incr-mpcorrdist":"@stdlib/stats/incr/mpcorrdist","@stdlib/stats-incr-mpe":"@stdlib/stats/incr/mpe","@stdlib/stats-incr-mprod":"@stdlib/stats/incr/mprod","@stdlib/stats-incr-mrange":"@stdlib/stats/incr/mrange","@stdlib/stats-incr-mrmse":"@stdlib/stats/incr/mrmse","@stdlib/stats-incr-mrss":"@stdlib/stats/incr/mrss","@stdlib/stats-incr-mse":"@stdlib/stats/incr/mse","@stdlib/stats-incr-mstdev":"@stdlib/stats/incr/mstdev","@stdlib/stats-incr-msum":"@stdlib/stats/incr/msum","@stdlib/stats-incr-msumabs":"@stdlib/stats/incr/msumabs","@stdlib/stats-incr-msumabs2":"@stdlib/stats/incr/msumabs2","@stdlib/stats-incr-msummary":"@stdlib/stats/incr/msummary","@stdlib/stats-incr-msumprod":"@stdlib/stats/incr/msumprod","@stdlib/stats-incr-mvariance":"@stdlib/stats/incr/mvariance","@stdlib/stats-incr-mvmr":"@stdlib/stats/incr/mvmr","@stdlib/stats-incr-nancount":"@stdlib/stats/incr/nancount","@stdlib/stats-incr-nansum":"@stdlib/stats/incr/nansum","@stdlib/stats-incr-nansumabs":"@stdlib/stats/incr/nansumabs","@stdlib/stats-incr-nansumabs2":"@stdlib/stats/incr/nansumabs2","@stdlib/stats-incr-pcorr":"@stdlib/stats/incr/pcorr","@stdlib/stats-incr-pcorr2":"@stdlib/stats/incr/pcorr2","@stdlib/stats-incr-pcorrdist":"@stdlib/stats/incr/pcorrdist","@stdlib/stats-incr-pcorrdistmat":"@stdlib/stats/incr/pcorrdistmat","@stdlib/stats-incr-pcorrmat":"@stdlib/stats/incr/pcorrmat","@stdlib/stats-incr-prod":"@stdlib/stats/incr/prod","@stdlib/stats-incr-range":"@stdlib/stats/incr/range","@stdlib/stats-incr-rmse":"@stdlib/stats/incr/rmse","@stdlib/stats-incr-rss":"@stdlib/stats/incr/rss","@stdlib/ml-incr-sgd-regression":"@stdlib/ml/incr/sgd-regression","@stdlib/stats-incr-skewness":"@stdlib/stats/incr/skewness","@stdlib/array-incrspace":"@stdlib/array/incrspace","@stdlib/stats-incr-stdev":"@stdlib/stats/incr/stdev","@stdlib/stats-incr-sum":"@stdlib/stats/incr/sum","@stdlib/stats-incr-sumabs":"@stdlib/stats/incr/sumabs","@stdlib/stats-incr-sumabs2":"@stdlib/stats/incr/sumabs2","@stdlib/stats-incr-summary":"@stdlib/stats/incr/summary","@stdlib/stats-incr-sumprod":"@stdlib/stats/incr/sumprod","@stdlib/stats-incr-variance":"@stdlib/stats/incr/variance","@stdlib/stats-incr-vmr":"@stdlib/stats/incr/vmr","@stdlib/stats-incr-wmean":"@stdlib/stats/incr/wmean","@stdlib/ndarray-ind2sub":"@stdlib/ndarray/ind2sub","@stdlib/utils-index-of":"@stdlib/utils/index-of","@stdlib/utils-inherit":"@stdlib/utils/inherit","@stdlib/utils-inherited-enumerable-properties":"@stdlib/utils/inherited-enumerable-properties","@stdlib/utils-inherited-enumerable-property-symbols":"@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils-inherited-keys":"@stdlib/utils/inherited-keys","@stdlib/utils-inherited-nonenumerable-properties":"@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils-inherited-nonenumerable-property-names":"@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils-inherited-nonenumerable-property-symbols":"@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils-inherited-properties":"@stdlib/utils/inherited-properties","@stdlib/utils-inherited-property-descriptor":"@stdlib/utils/inherited-property-descriptor","@stdlib/utils-inherited-property-descriptors":"@stdlib/utils/inherited-property-descriptors","@stdlib/utils-inherited-property-names":"@stdlib/utils/inherited-property-names","@stdlib/utils-inherited-property-symbols":"@stdlib/utils/inherited-property-symbols","@stdlib/utils-inherited-writable-properties":"@stdlib/utils/inherited-writable-properties","@stdlib/utils-inherited-writable-property-names":"@stdlib/utils/inherited-writable-property-names","@stdlib/utils-inherited-writable-property-symbols":"@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils-inmap":"@stdlib/utils/inmap","@stdlib/utils-async-inmap":"@stdlib/utils/async/inmap","@stdlib/utils-inmap-right":"@stdlib/utils/inmap-right","@stdlib/utils-async-inmap-right":"@stdlib/utils/async/inmap-right","@stdlib/streams-node-inspect-sink":"@stdlib/streams/node/inspect-sink","@stdlib/streams-node-inspect":"@stdlib/streams/node/inspect","@stdlib/assert-instance-of":"@stdlib/assert/instance-of","@stdlib/constants-int8-max":"@stdlib/constants/int8/max","@stdlib/constants-int8-min":"@stdlib/constants/int8/min","@stdlib/constants-int8-num-bytes":"@stdlib/constants/int8/num-bytes","@stdlib/array-int8":"@stdlib/array/int8","@stdlib/constants-int16-max":"@stdlib/constants/int16/max","@stdlib/constants-int16-min":"@stdlib/constants/int16/min","@stdlib/constants-int16-num-bytes":"@stdlib/constants/int16/num-bytes","@stdlib/array-int16":"@stdlib/array/int16","@stdlib/constants-int32-max":"@stdlib/constants/int32/max","@stdlib/constants-int32-min":"@stdlib/constants/int32/min","@stdlib/constants-int32-num-bytes":"@stdlib/constants/int32/num-bytes","@stdlib/array-int32":"@stdlib/array/int32","@stdlib/assert-is-big-endian":"@stdlib/assert/is-big-endian","@stdlib/assert-is-browser":"@stdlib/assert/is-browser","@stdlib/assert-is-darwin":"@stdlib/assert/is-darwin","@stdlib/assert-is-docker":"@stdlib/assert/is-docker","@stdlib/assert-is-electron":"@stdlib/assert/is-electron","@stdlib/assert-is-electron-main":"@stdlib/assert/is-electron-main","@stdlib/assert-is-electron-renderer":"@stdlib/assert/is-electron-renderer","@stdlib/assert-is-little-endian":"@stdlib/assert/is-little-endian","@stdlib/assert-is-mobile":"@stdlib/assert/is-mobile","@stdlib/assert-is-node":"@stdlib/assert/is-node","@stdlib/assert-is-touch-device":"@stdlib/assert/is-touch-device","@stdlib/assert-is-web-worker":"@stdlib/assert/is-web-worker","@stdlib/assert-is-windows":"@stdlib/assert/is-windows","@stdlib/assert-is-absolute-http-uri":"@stdlib/assert/is-absolute-http-uri","@stdlib/assert-is-absolute-path":"@stdlib/assert/is-absolute-path","@stdlib/assert-is-absolute-uri":"@stdlib/assert/is-absolute-uri","@stdlib/assert-is-accessor-array":"@stdlib/assert/is-accessor-array","@stdlib/assert-is-accessor-property":"@stdlib/assert/is-accessor-property","@stdlib/assert-is-accessor-property-in":"@stdlib/assert/is-accessor-property-in","@stdlib/assert-is-alphagram":"@stdlib/assert/is-alphagram","@stdlib/assert-is-alphanumeric":"@stdlib/assert/is-alphanumeric","@stdlib/assert-is-anagram":"@stdlib/assert/is-anagram","@stdlib/assert-is-arguments":"@stdlib/assert/is-arguments","@stdlib/assert-is-array":"@stdlib/assert/is-array","@stdlib/assert-is-array-array":"@stdlib/assert/is-array-array","@stdlib/assert-is-arraybuffer":"@stdlib/assert/is-arraybuffer","@stdlib/assert-is-arraybuffer-view":"@stdlib/assert/is-arraybuffer-view","@stdlib/assert-is-array-length":"@stdlib/assert/is-array-length","@stdlib/assert-is-array-like":"@stdlib/assert/is-array-like","@stdlib/assert-is-array-like-object":"@stdlib/assert/is-array-like-object","@stdlib/assert-is-arrow-function":"@stdlib/assert/is-arrow-function","@stdlib/assert-is-ascii":"@stdlib/assert/is-ascii","@stdlib/assert-is-between":"@stdlib/assert/is-between","@stdlib/assert-is-between-array":"@stdlib/assert/is-between-array","@stdlib/assert-is-bigint":"@stdlib/assert/is-bigint","@stdlib/assert-is-bigint64array":"@stdlib/assert/is-bigint64array","@stdlib/assert-is-biguint64array":"@stdlib/assert/is-biguint64array","@stdlib/assert-is-binary-string":"@stdlib/assert/is-binary-string","@stdlib/assert-is-blank-string":"@stdlib/assert/is-blank-string","@stdlib/assert-is-boolean":"@stdlib/assert/is-boolean","@stdlib/assert-is-boolean-array":"@stdlib/assert/is-boolean-array","@stdlib/assert-is-boxed-primitive":"@stdlib/assert/is-boxed-primitive","@stdlib/assert-is-buffer":"@stdlib/assert/is-buffer","@stdlib/assert-is-camelcase":"@stdlib/assert/is-camelcase","@stdlib/assert-is-capitalized":"@stdlib/assert/is-capitalized","@stdlib/assert-is-centrosymmetric-matrix":"@stdlib/assert/is-centrosymmetric-matrix","@stdlib/assert-is-circular":"@stdlib/assert/is-circular","@stdlib/assert-is-circular-array":"@stdlib/assert/is-circular-array","@stdlib/assert-is-circular-plain-object":"@stdlib/assert/is-circular-plain-object","@stdlib/assert-is-class":"@stdlib/assert/is-class","@stdlib/assert-is-collection":"@stdlib/assert/is-collection","@stdlib/assert-is-complex":"@stdlib/assert/is-complex","@stdlib/assert-is-complex64":"@stdlib/assert/is-complex64","@stdlib/assert-is-complex64array":"@stdlib/assert/is-complex64array","@stdlib/assert-is-complex64matrix-like":"@stdlib/assert/is-complex64matrix-like","@stdlib/assert-is-complex64ndarray-like":"@stdlib/assert/is-complex64ndarray-like","@stdlib/assert-is-complex64vector-like":"@stdlib/assert/is-complex64vector-like","@stdlib/assert-is-complex128":"@stdlib/assert/is-complex128","@stdlib/assert-is-complex128array":"@stdlib/assert/is-complex128array","@stdlib/assert-is-complex128matrix-like":"@stdlib/assert/is-complex128matrix-like","@stdlib/assert-is-complex128ndarray-like":"@stdlib/assert/is-complex128ndarray-like","@stdlib/assert-is-complex128vector-like":"@stdlib/assert/is-complex128vector-like","@stdlib/assert-is-complex-like":"@stdlib/assert/is-complex-like","@stdlib/assert-is-complex-typed-array":"@stdlib/assert/is-complex-typed-array","@stdlib/assert-is-complex-typed-array-like":"@stdlib/assert/is-complex-typed-array-like","@stdlib/assert-is-composite":"@stdlib/assert/is-composite","@stdlib/assert-is-configurable-property":"@stdlib/assert/is-configurable-property","@stdlib/assert-is-configurable-property-in":"@stdlib/assert/is-configurable-property-in","@stdlib/assert-is-constantcase":"@stdlib/assert/is-constantcase","@stdlib/assert-is-cube-number":"@stdlib/assert/is-cube-number","@stdlib/assert-is-current-year":"@stdlib/assert/is-current-year","@stdlib/assert-is-data-property":"@stdlib/assert/is-data-property","@stdlib/assert-is-data-property-in":"@stdlib/assert/is-data-property-in","@stdlib/assert-is-dataview":"@stdlib/assert/is-dataview","@stdlib/assert-is-date-object":"@stdlib/assert/is-date-object","@stdlib/assert-is-date-object-array":"@stdlib/assert/is-date-object-array","@stdlib/assert-is-digit-string":"@stdlib/assert/is-digit-string","@stdlib/assert-is-domain-name":"@stdlib/assert/is-domain-name","@stdlib/assert-is-duration-string":"@stdlib/assert/is-duration-string","@stdlib/assert-is-email-address":"@stdlib/assert/is-email-address","@stdlib/assert-is-empty-array":"@stdlib/assert/is-empty-array","@stdlib/assert-is-empty-array-like-object":"@stdlib/assert/is-empty-array-like-object","@stdlib/assert-is-empty-collection":"@stdlib/assert/is-empty-collection","@stdlib/assert-is-empty-object":"@stdlib/assert/is-empty-object","@stdlib/assert-is-empty-string":"@stdlib/assert/is-empty-string","@stdlib/assert-is-enumerable-property":"@stdlib/assert/is-enumerable-property","@stdlib/assert-is-enumerable-property-in":"@stdlib/assert/is-enumerable-property-in","@stdlib/assert-is-equal-array":"@stdlib/assert/is-equal-array","@stdlib/assert-is-error":"@stdlib/assert/is-error","@stdlib/assert-is-eval-error":"@stdlib/assert/is-eval-error","@stdlib/assert-is-even":"@stdlib/assert/is-even","@stdlib/assert-is-falsy":"@stdlib/assert/is-falsy","@stdlib/assert-is-falsy-array":"@stdlib/assert/is-falsy-array","@stdlib/assert-is-finite":"@stdlib/assert/is-finite","@stdlib/assert-is-finite-array":"@stdlib/assert/is-finite-array","@stdlib/assert-is-float32array":"@stdlib/assert/is-float32array","@stdlib/assert-is-float32matrix-like":"@stdlib/assert/is-float32matrix-like","@stdlib/assert-is-float32ndarray-like":"@stdlib/assert/is-float32ndarray-like","@stdlib/assert-is-float32vector-like":"@stdlib/assert/is-float32vector-like","@stdlib/assert-is-float64array":"@stdlib/assert/is-float64array","@stdlib/assert-is-float64matrix-like":"@stdlib/assert/is-float64matrix-like","@stdlib/assert-is-float64ndarray-like":"@stdlib/assert/is-float64ndarray-like","@stdlib/assert-is-float64vector-like":"@stdlib/assert/is-float64vector-like","@stdlib/assert-is-function":"@stdlib/assert/is-function","@stdlib/assert-is-function-array":"@stdlib/assert/is-function-array","@stdlib/assert-is-generator-object":"@stdlib/assert/is-generator-object","@stdlib/assert-is-generator-object-like":"@stdlib/assert/is-generator-object-like","@stdlib/assert-is-gzip-buffer":"@stdlib/assert/is-gzip-buffer","@stdlib/assert-is-hex-string":"@stdlib/assert/is-hex-string","@stdlib/assert-is-infinite":"@stdlib/assert/is-infinite","@stdlib/assert-is-inherited-property":"@stdlib/assert/is-inherited-property","@stdlib/assert-is-int8array":"@stdlib/assert/is-int8array","@stdlib/assert-is-int16array":"@stdlib/assert/is-int16array","@stdlib/assert-is-int32array":"@stdlib/assert/is-int32array","@stdlib/assert-is-integer":"@stdlib/assert/is-integer","@stdlib/assert-is-integer-array":"@stdlib/assert/is-integer-array","@stdlib/assert-is-iterable-like":"@stdlib/assert/is-iterable-like","@stdlib/assert-is-iterator-like":"@stdlib/assert/is-iterator-like","@stdlib/assert-is-json":"@stdlib/assert/is-json","@stdlib/assert-is-kebabcase":"@stdlib/assert/is-kebabcase","@stdlib/assert-is-leap-year":"@stdlib/assert/is-leap-year","@stdlib/assert-is-localhost":"@stdlib/assert/is-localhost","@stdlib/assert-is-lowercase":"@stdlib/assert/is-lowercase","@stdlib/assert-is-matrix-like":"@stdlib/assert/is-matrix-like","@stdlib/assert-is-method":"@stdlib/assert/is-method","@stdlib/assert-is-method-in":"@stdlib/assert/is-method-in","@stdlib/assert-is-multi-slice":"@stdlib/assert/is-multi-slice","@stdlib/assert-is-named-typed-tuple-like":"@stdlib/assert/is-named-typed-tuple-like","@stdlib/assert-is-nan":"@stdlib/assert/is-nan","@stdlib/assert-is-nan-array":"@stdlib/assert/is-nan-array","@stdlib/assert-is-native-function":"@stdlib/assert/is-native-function","@stdlib/assert-is-ndarray-like":"@stdlib/assert/is-ndarray-like","@stdlib/assert-is-ndarray-like-with-data-type":"@stdlib/assert/is-ndarray-like-with-data-type","@stdlib/assert-is-negative-finite":"@stdlib/assert/is-negative-finite","@stdlib/assert-is-negative-integer":"@stdlib/assert/is-negative-integer","@stdlib/assert-is-negative-integer-array":"@stdlib/assert/is-negative-integer-array","@stdlib/assert-is-negative-number":"@stdlib/assert/is-negative-number","@stdlib/assert-is-negative-number-array":"@stdlib/assert/is-negative-number-array","@stdlib/assert-is-negative-zero":"@stdlib/assert/is-negative-zero","@stdlib/assert-is-node-builtin":"@stdlib/assert/is-node-builtin","@stdlib/assert-is-node-duplex-stream-like":"@stdlib/assert/is-node-duplex-stream-like","@stdlib/assert-is-node-readable-stream-like":"@stdlib/assert/is-node-readable-stream-like","@stdlib/assert-is-node-repl":"@stdlib/assert/is-node-repl","@stdlib/assert-is-node-stream-like":"@stdlib/assert/is-node-stream-like","@stdlib/assert-is-node-transform-stream-like":"@stdlib/assert/is-node-transform-stream-like","@stdlib/assert-is-node-writable-stream-like":"@stdlib/assert/is-node-writable-stream-like","@stdlib/assert-is-nonconfigurable-property":"@stdlib/assert/is-nonconfigurable-property","@stdlib/assert-is-nonconfigurable-property-in":"@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert-is-nonenumerable-property":"@stdlib/assert/is-nonenumerable-property","@stdlib/assert-is-nonenumerable-property-in":"@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert-is-nonnegative-finite":"@stdlib/assert/is-nonnegative-finite","@stdlib/assert-is-nonnegative-integer":"@stdlib/assert/is-nonnegative-integer","@stdlib/assert-is-nonnegative-integer-array":"@stdlib/assert/is-nonnegative-integer-array","@stdlib/assert-is-nonnegative-number":"@stdlib/assert/is-nonnegative-number","@stdlib/assert-is-nonnegative-number-array":"@stdlib/assert/is-nonnegative-number-array","@stdlib/assert-is-nonpositive-finite":"@stdlib/assert/is-nonpositive-finite","@stdlib/assert-is-nonpositive-integer":"@stdlib/assert/is-nonpositive-integer","@stdlib/assert-is-nonpositive-integer-array":"@stdlib/assert/is-nonpositive-integer-array","@stdlib/assert-is-nonpositive-number":"@stdlib/assert/is-nonpositive-number","@stdlib/assert-is-nonpositive-number-array":"@stdlib/assert/is-nonpositive-number-array","@stdlib/assert-is-nonsymmetric-matrix":"@stdlib/assert/is-nonsymmetric-matrix","@stdlib/assert-is-null":"@stdlib/assert/is-null","@stdlib/assert-is-null-array":"@stdlib/assert/is-null-array","@stdlib/assert-is-number":"@stdlib/assert/is-number","@stdlib/assert-is-number-array":"@stdlib/assert/is-number-array","@stdlib/assert-is-numeric-array":"@stdlib/assert/is-numeric-array","@stdlib/assert-is-object":"@stdlib/assert/is-object","@stdlib/assert-is-object-array":"@stdlib/assert/is-object-array","@stdlib/assert-is-object-like":"@stdlib/assert/is-object-like","@stdlib/assert-is-odd":"@stdlib/assert/is-odd","@stdlib/time-iso-weeks-in-year":"@stdlib/time/iso-weeks-in-year","@stdlib/assert-is-pascalcase":"@stdlib/assert/is-pascalcase","@stdlib/assert-is-persymmetric-matrix":"@stdlib/assert/is-persymmetric-matrix","@stdlib/assert-is-plain-object":"@stdlib/assert/is-plain-object","@stdlib/assert-is-plain-object-array":"@stdlib/assert/is-plain-object-array","@stdlib/assert-is-positive-finite":"@stdlib/assert/is-positive-finite","@stdlib/assert-is-positive-integer":"@stdlib/assert/is-positive-integer","@stdlib/assert-is-positive-integer-array":"@stdlib/assert/is-positive-integer-array","@stdlib/assert-is-positive-number":"@stdlib/assert/is-positive-number","@stdlib/assert-is-positive-number-array":"@stdlib/assert/is-positive-number-array","@stdlib/assert-is-positive-zero":"@stdlib/assert/is-positive-zero","@stdlib/assert-is-prime":"@stdlib/assert/is-prime","@stdlib/assert-is-primitive":"@stdlib/assert/is-primitive","@stdlib/assert-is-primitive-array":"@stdlib/assert/is-primitive-array","@stdlib/assert-is-prng-like":"@stdlib/assert/is-prng-like","@stdlib/assert-is-probability":"@stdlib/assert/is-probability","@stdlib/assert-is-probability-array":"@stdlib/assert/is-probability-array","@stdlib/assert-is-property-key":"@stdlib/assert/is-property-key","@stdlib/assert-is-prototype-of":"@stdlib/assert/is-prototype-of","@stdlib/assert-is-ragged-nested-array":"@stdlib/assert/is-ragged-nested-array","@stdlib/assert-is-range-error":"@stdlib/assert/is-range-error","@stdlib/assert-is-readable-property":"@stdlib/assert/is-readable-property","@stdlib/assert-is-readable-property-in":"@stdlib/assert/is-readable-property-in","@stdlib/assert-is-read-only-property":"@stdlib/assert/is-read-only-property","@stdlib/assert-is-read-only-property-in":"@stdlib/assert/is-read-only-property-in","@stdlib/assert-is-read-write-property":"@stdlib/assert/is-read-write-property","@stdlib/assert-is-read-write-property-in":"@stdlib/assert/is-read-write-property-in","@stdlib/assert-is-reference-error":"@stdlib/assert/is-reference-error","@stdlib/assert-is-regexp":"@stdlib/assert/is-regexp","@stdlib/assert-is-regexp-string":"@stdlib/assert/is-regexp-string","@stdlib/assert-is-relative-path":"@stdlib/assert/is-relative-path","@stdlib/assert-is-relative-uri":"@stdlib/assert/is-relative-uri","@stdlib/assert-is-safe-integer":"@stdlib/assert/is-safe-integer","@stdlib/assert-is-safe-integer-array":"@stdlib/assert/is-safe-integer-array","@stdlib/assert-is-same-array":"@stdlib/assert/is-same-array","@stdlib/assert-is-same-array-like":"@stdlib/assert/is-same-array-like","@stdlib/assert-is-same-complex64":"@stdlib/assert/is-same-complex64","@stdlib/assert-is-same-complex64array":"@stdlib/assert/is-same-complex64array","@stdlib/assert-is-same-complex128":"@stdlib/assert/is-same-complex128","@stdlib/assert-is-same-complex128array":"@stdlib/assert/is-same-complex128array","@stdlib/assert-is-same-date-object":"@stdlib/assert/is-same-date-object","@stdlib/assert-is-same-float32array":"@stdlib/assert/is-same-float32array","@stdlib/assert-is-same-float64array":"@stdlib/assert/is-same-float64array","@stdlib/assert-is-same-native-class":"@stdlib/assert/is-same-native-class","@stdlib/assert-is-same-type":"@stdlib/assert/is-same-type","@stdlib/assert-is-same-value":"@stdlib/assert/is-same-value","@stdlib/assert-is-same-value-zero":"@stdlib/assert/is-same-value-zero","@stdlib/assert-is-semver":"@stdlib/assert/is-semver","@stdlib/assert-is-sharedarraybuffer":"@stdlib/assert/is-sharedarraybuffer","@stdlib/assert-is-skew-centrosymmetric-matrix":"@stdlib/assert/is-skew-centrosymmetric-matrix","@stdlib/assert-is-skew-persymmetric-matrix":"@stdlib/assert/is-skew-persymmetric-matrix","@stdlib/assert-is-skew-symmetric-matrix":"@stdlib/assert/is-skew-symmetric-matrix","@stdlib/assert-is-slice":"@stdlib/assert/is-slice","@stdlib/assert-is-snakecase":"@stdlib/assert/is-snakecase","@stdlib/assert-is-square-matrix":"@stdlib/assert/is-square-matrix","@stdlib/assert-is-square-number":"@stdlib/assert/is-square-number","@stdlib/assert-is-square-triangular-number":"@stdlib/assert/is-square-triangular-number","@stdlib/assert-is-startcase":"@stdlib/assert/is-startcase","@stdlib/assert-is-strict-equal":"@stdlib/assert/is-strict-equal","@stdlib/assert-is-string":"@stdlib/assert/is-string","@stdlib/assert-is-string-array":"@stdlib/assert/is-string-array","@stdlib/assert-is-symbol":"@stdlib/assert/is-symbol","@stdlib/assert-is-symbol-array":"@stdlib/assert/is-symbol-array","@stdlib/assert-is-symmetric-matrix":"@stdlib/assert/is-symmetric-matrix","@stdlib/assert-is-syntax-error":"@stdlib/assert/is-syntax-error","@stdlib/assert-is-triangular-number":"@stdlib/assert/is-triangular-number","@stdlib/assert-is-truthy":"@stdlib/assert/is-truthy","@stdlib/assert-is-truthy-array":"@stdlib/assert/is-truthy-array","@stdlib/assert-is-typed-array":"@stdlib/assert/is-typed-array","@stdlib/assert-is-typed-array-length":"@stdlib/assert/is-typed-array-length","@stdlib/assert-is-typed-array-like":"@stdlib/assert/is-typed-array-like","@stdlib/assert-is-type-error":"@stdlib/assert/is-type-error","@stdlib/assert-is-uint8array":"@stdlib/assert/is-uint8array","@stdlib/assert-is-uint8clampedarray":"@stdlib/assert/is-uint8clampedarray","@stdlib/assert-is-uint16array":"@stdlib/assert/is-uint16array","@stdlib/assert-is-uint32array":"@stdlib/assert/is-uint32array","@stdlib/assert-is-unc-path":"@stdlib/assert/is-unc-path","@stdlib/assert-is-undefined":"@stdlib/assert/is-undefined","@stdlib/assert-is-undefined-or-null":"@stdlib/assert/is-undefined-or-null","@stdlib/assert-is-unity-probability-array":"@stdlib/assert/is-unity-probability-array","@stdlib/assert-is-uppercase":"@stdlib/assert/is-uppercase","@stdlib/assert-is-uri":"@stdlib/assert/is-uri","@stdlib/assert-is-uri-error":"@stdlib/assert/is-uri-error","@stdlib/assert-is-vector-like":"@stdlib/assert/is-vector-like","@stdlib/assert-is-wasm-memory":"@stdlib/assert/is-wasm-memory","@stdlib/assert-is-well-formed-string":"@stdlib/assert/is-well-formed-string","@stdlib/assert-is-whitespace":"@stdlib/assert/is-whitespace","@stdlib/assert-is-writable-property":"@stdlib/assert/is-writable-property","@stdlib/assert-is-writable-property-in":"@stdlib/assert/is-writable-property-in","@stdlib/assert-is-write-only-property":"@stdlib/assert/is-write-only-property","@stdlib/assert-is-write-only-property-in":"@stdlib/assert/is-write-only-property-in","@stdlib/math-iter-special-abs":"@stdlib/math/iter/special/abs","@stdlib/math-iter-special-abs2":"@stdlib/math/iter/special/abs2","@stdlib/math-iter-special-acos":"@stdlib/math/iter/special/acos","@stdlib/math-iter-special-acosh":"@stdlib/math/iter/special/acosh","@stdlib/math-iter-special-acot":"@stdlib/math/iter/special/acot","@stdlib/math-iter-special-acoth":"@stdlib/math/iter/special/acoth","@stdlib/math-iter-special-acovercos":"@stdlib/math/iter/special/acovercos","@stdlib/math-iter-special-acoversin":"@stdlib/math/iter/special/acoversin","@stdlib/math-iter-ops-add":"@stdlib/math/iter/ops/add","@stdlib/iter-advance":"@stdlib/iter/advance","@stdlib/math-iter-special-ahavercos":"@stdlib/math/iter/special/ahavercos","@stdlib/math-iter-special-ahaversin":"@stdlib/math/iter/special/ahaversin","@stdlib/iter-any":"@stdlib/iter/any","@stdlib/iter-any-by":"@stdlib/iter/any-by","@stdlib/math-iter-special-asin":"@stdlib/math/iter/special/asin","@stdlib/math-iter-special-asinh":"@stdlib/math/iter/special/asinh","@stdlib/math-iter-special-atan":"@stdlib/math/iter/special/atan","@stdlib/math-iter-special-atan2":"@stdlib/math/iter/special/atan2","@stdlib/math-iter-special-atanh":"@stdlib/math/iter/special/atanh","@stdlib/array-from-iterator":"@stdlib/array/from-iterator","@stdlib/iter-to-array-view":"@stdlib/iter/to-array-view","@stdlib/iter-to-array-view-right":"@stdlib/iter/to-array-view-right","@stdlib/streams-node-from-iterator":"@stdlib/streams/node/from-iterator","@stdlib/symbol-iterator":"@stdlib/symbol/iterator","@stdlib/math-iter-special-avercos":"@stdlib/math/iter/special/avercos","@stdlib/math-iter-special-aversin":"@stdlib/math/iter/special/aversin","@stdlib/simulate-iter-awgn":"@stdlib/simulate/iter/awgn","@stdlib/simulate-iter-awln":"@stdlib/simulate/iter/awln","@stdlib/simulate-iter-awun":"@stdlib/simulate/iter/awun","@stdlib/simulate-iter-bartlett-hann-pulse":"@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate-iter-bartlett-pulse":"@stdlib/simulate/iter/bartlett-pulse","@stdlib/math-iter-special-besselj0":"@stdlib/math/iter/special/besselj0","@stdlib/math-iter-special-besselj1":"@stdlib/math/iter/special/besselj1","@stdlib/math-iter-special-bessely0":"@stdlib/math/iter/special/bessely0","@stdlib/math-iter-special-bessely1":"@stdlib/math/iter/special/bessely1","@stdlib/math-iter-special-beta":"@stdlib/math/iter/special/beta","@stdlib/math-iter-special-betaln":"@stdlib/math/iter/special/betaln","@stdlib/math-iter-special-binet":"@stdlib/math/iter/special/binet","@stdlib/math-iter-special-cbrt":"@stdlib/math/iter/special/cbrt","@stdlib/math-iter-special-ceil":"@stdlib/math/iter/special/ceil","@stdlib/math-iter-special-ceil2":"@stdlib/math/iter/special/ceil2","@stdlib/math-iter-special-ceil10":"@stdlib/math/iter/special/ceil10","@stdlib/math-iter-sequences-composites":"@stdlib/math/iter/sequences/composites","@stdlib/iter-concat":"@stdlib/iter/concat","@stdlib/iter-constant":"@stdlib/iter/constant","@stdlib/math-iter-utils-continued-fraction":"@stdlib/math/iter/utils/continued-fraction","@stdlib/math-iter-sequences-continued-fraction":"@stdlib/math/iter/sequences/continued-fraction","@stdlib/math-iter-special-cos":"@stdlib/math/iter/special/cos","@stdlib/math-iter-special-cosh":"@stdlib/math/iter/special/cosh","@stdlib/simulate-iter-cosine-wave":"@stdlib/simulate/iter/cosine-wave","@stdlib/math-iter-special-cosm1":"@stdlib/math/iter/special/cosm1","@stdlib/math-iter-special-cospi":"@stdlib/math/iter/special/cospi","@stdlib/iter-counter":"@stdlib/iter/counter","@stdlib/math-iter-special-covercos":"@stdlib/math/iter/special/covercos","@stdlib/math-iter-special-coversin":"@stdlib/math/iter/special/coversin","@stdlib/math-iter-sequences-cubes":"@stdlib/math/iter/sequences/cubes","@stdlib/stats-iter-cugmean":"@stdlib/stats/iter/cugmean","@stdlib/stats-iter-cuhmean":"@stdlib/stats/iter/cuhmean","@stdlib/stats-iter-cumax":"@stdlib/stats/iter/cumax","@stdlib/stats-iter-cumaxabs":"@stdlib/stats/iter/cumaxabs","@stdlib/stats-iter-cumean":"@stdlib/stats/iter/cumean","@stdlib/stats-iter-cumeanabs":"@stdlib/stats/iter/cumeanabs","@stdlib/stats-iter-cumeanabs2":"@stdlib/stats/iter/cumeanabs2","@stdlib/stats-iter-cumidrange":"@stdlib/stats/iter/cumidrange","@stdlib/stats-iter-cumin":"@stdlib/stats/iter/cumin","@stdlib/stats-iter-cuminabs":"@stdlib/stats/iter/cuminabs","@stdlib/stats-iter-cuprod":"@stdlib/stats/iter/cuprod","@stdlib/stats-iter-curange":"@stdlib/stats/iter/curange","@stdlib/stats-iter-cusum":"@stdlib/stats/iter/cusum","@stdlib/stats-iter-cusumabs":"@stdlib/stats/iter/cusumabs","@stdlib/stats-iter-cusumabs2":"@stdlib/stats/iter/cusumabs2","@stdlib/iter-datespace":"@stdlib/iter/datespace","@stdlib/iter-dedupe":"@stdlib/iter/dedupe","@stdlib/iter-dedupe-by":"@stdlib/iter/dedupe-by","@stdlib/math-iter-special-deg2rad":"@stdlib/math/iter/special/deg2rad","@stdlib/math-iter-special-digamma":"@stdlib/math/iter/special/digamma","@stdlib/simulate-iter-dirac-comb":"@stdlib/simulate/iter/dirac-comb","@stdlib/math-iter-special-dirac-delta":"@stdlib/math/iter/special/dirac-delta","@stdlib/math-iter-ops-divide":"@stdlib/math/iter/ops/divide","@stdlib/iter-do-until-each":"@stdlib/iter/do-until-each","@stdlib/iter-do-while-each":"@stdlib/iter/do-while-each","@stdlib/math-iter-special-ellipe":"@stdlib/math/iter/special/ellipe","@stdlib/math-iter-special-ellipk":"@stdlib/math/iter/special/ellipk","@stdlib/iter-empty":"@stdlib/iter/empty","@stdlib/math-iter-special-erf":"@stdlib/math/iter/special/erf","@stdlib/math-iter-special-erfc":"@stdlib/math/iter/special/erfc","@stdlib/math-iter-special-erfcinv":"@stdlib/math/iter/special/erfcinv","@stdlib/math-iter-special-erfinv":"@stdlib/math/iter/special/erfinv","@stdlib/math-iter-special-dirichlet-eta":"@stdlib/math/iter/special/dirichlet-eta","@stdlib/math-iter-sequences-even-integers":"@stdlib/math/iter/sequences/even-integers","@stdlib/iter-every":"@stdlib/iter/every","@stdlib/iter-every-by":"@stdlib/iter/every-by","@stdlib/math-iter-special-exp":"@stdlib/math/iter/special/exp","@stdlib/math-iter-special-exp2":"@stdlib/math/iter/special/exp2","@stdlib/math-iter-special-exp10":"@stdlib/math/iter/special/exp10","@stdlib/math-iter-special-expit":"@stdlib/math/iter/special/expit","@stdlib/math-iter-special-expm1":"@stdlib/math/iter/special/expm1","@stdlib/math-iter-special-expm1rel":"@stdlib/math/iter/special/expm1rel","@stdlib/math-iter-special-factorial":"@stdlib/math/iter/special/factorial","@stdlib/math-iter-special-factorialln":"@stdlib/math/iter/special/factorialln","@stdlib/math-iter-sequences-factorials":"@stdlib/math/iter/sequences/factorials","@stdlib/math-iter-sequences-fibonacci":"@stdlib/math/iter/sequences/fibonacci","@stdlib/math-iter-sequences-fifth-powers":"@stdlib/math/iter/sequences/fifth-powers","@stdlib/iter-fill":"@stdlib/iter/fill","@stdlib/iter-filter":"@stdlib/iter/filter","@stdlib/iter-filter-map":"@stdlib/iter/filter-map","@stdlib/iter-first":"@stdlib/iter/first","@stdlib/simulate-iter-flat-top-pulse":"@stdlib/simulate/iter/flat-top-pulse","@stdlib/math-iter-special-floor":"@stdlib/math/iter/special/floor","@stdlib/math-iter-special-floor2":"@stdlib/math/iter/special/floor2","@stdlib/math-iter-special-floor10":"@stdlib/math/iter/special/floor10","@stdlib/iter-flow":"@stdlib/iter/flow","@stdlib/iter-for-each":"@stdlib/iter/for-each","@stdlib/math-iter-sequences-fourth-powers":"@stdlib/math/iter/sequences/fourth-powers","@stdlib/math-iter-special-fresnelc":"@stdlib/math/iter/special/fresnelc","@stdlib/math-iter-special-fresnels":"@stdlib/math/iter/special/fresnels","@stdlib/math-iter-special-gamma":"@stdlib/math/iter/special/gamma","@stdlib/math-iter-special-gamma1pm1":"@stdlib/math/iter/special/gamma1pm1","@stdlib/math-iter-special-gammaln":"@stdlib/math/iter/special/gammaln","@stdlib/math-iter-special-hacovercos":"@stdlib/math/iter/special/hacovercos","@stdlib/math-iter-special-hacoversin":"@stdlib/math/iter/special/hacoversin","@stdlib/simulate-iter-hann-pulse":"@stdlib/simulate/iter/hann-pulse","@stdlib/math-iter-special-havercos":"@stdlib/math/iter/special/havercos","@stdlib/math-iter-special-haversin":"@stdlib/math/iter/special/haversin","@stdlib/iter-head":"@stdlib/iter/head","@stdlib/iter-incrspace":"@stdlib/iter/incrspace","@stdlib/math-iter-sequences-integers":"@stdlib/math/iter/sequences/integers","@stdlib/iter-intersection":"@stdlib/iter/intersection","@stdlib/iter-intersection-by-hash":"@stdlib/iter/intersection-by-hash","@stdlib/math-iter-special-inv":"@stdlib/math/iter/special/inv","@stdlib/simulate-iter-lanczos-pulse":"@stdlib/simulate/iter/lanczos-pulse","@stdlib/iter-last":"@stdlib/iter/last","@stdlib/iter-length":"@stdlib/iter/length","@stdlib/iter-linspace":"@stdlib/iter/linspace","@stdlib/math-iter-special-ln":"@stdlib/math/iter/special/ln","@stdlib/math-iter-special-log":"@stdlib/math/iter/special/log","@stdlib/math-iter-special-log1mexp":"@stdlib/math/iter/special/log1mexp","@stdlib/math-iter-special-log1p":"@stdlib/math/iter/special/log1p","@stdlib/math-iter-special-log1pexp":"@stdlib/math/iter/special/log1pexp","@stdlib/math-iter-special-log2":"@stdlib/math/iter/special/log2","@stdlib/math-iter-special-log10":"@stdlib/math/iter/special/log10","@stdlib/math-iter-special-logit":"@stdlib/math/iter/special/logit","@stdlib/iter-logspace":"@stdlib/iter/logspace","@stdlib/math-iter-sequences-lucas":"@stdlib/math/iter/sequences/lucas","@stdlib/iter-map":"@stdlib/iter/map","@stdlib/iter-mapn":"@stdlib/iter/mapn","@stdlib/stats-iter-max":"@stdlib/stats/iter/max","@stdlib/stats-iter-maxabs":"@stdlib/stats/iter/maxabs","@stdlib/stats-iter-mean":"@stdlib/stats/iter/mean","@stdlib/stats-iter-meanabs":"@stdlib/stats/iter/meanabs","@stdlib/stats-iter-meanabs2":"@stdlib/stats/iter/meanabs2","@stdlib/stats-iter-midrange":"@stdlib/stats/iter/midrange","@stdlib/stats-iter-min":"@stdlib/stats/iter/min","@stdlib/stats-iter-minabs":"@stdlib/stats/iter/minabs","@stdlib/stats-iter-mmax":"@stdlib/stats/iter/mmax","@stdlib/stats-iter-mmaxabs":"@stdlib/stats/iter/mmaxabs","@stdlib/stats-iter-mmean":"@stdlib/stats/iter/mmean","@stdlib/stats-iter-mmeanabs":"@stdlib/stats/iter/mmeanabs","@stdlib/stats-iter-mmeanabs2":"@stdlib/stats/iter/mmeanabs2","@stdlib/stats-iter-mmidrange":"@stdlib/stats/iter/mmidrange","@stdlib/stats-iter-mmin":"@stdlib/stats/iter/mmin","@stdlib/stats-iter-mminabs":"@stdlib/stats/iter/mminabs","@stdlib/math-iter-ops-mod":"@stdlib/math/iter/ops/mod","@stdlib/stats-iter-mprod":"@stdlib/stats/iter/mprod","@stdlib/stats-iter-mrange":"@stdlib/stats/iter/mrange","@stdlib/stats-iter-msum":"@stdlib/stats/iter/msum","@stdlib/stats-iter-msumabs":"@stdlib/stats/iter/msumabs","@stdlib/stats-iter-msumabs2":"@stdlib/stats/iter/msumabs2","@stdlib/math-iter-ops-multiply":"@stdlib/math/iter/ops/multiply","@stdlib/math-iter-sequences-negafibonacci":"@stdlib/math/iter/sequences/negafibonacci","@stdlib/math-iter-sequences-negalucas":"@stdlib/math/iter/sequences/negalucas","@stdlib/math-iter-sequences-negative-even-integers":"@stdlib/math/iter/sequences/negative-even-integers","@stdlib/math-iter-sequences-negative-integers":"@stdlib/math/iter/sequences/negative-integers","@stdlib/math-iter-sequences-negative-odd-integers":"@stdlib/math/iter/sequences/negative-odd-integers","@stdlib/iter-none":"@stdlib/iter/none","@stdlib/iter-none-by":"@stdlib/iter/none-by","@stdlib/math-iter-sequences-nonfibonacci":"@stdlib/math/iter/sequences/nonfibonacci","@stdlib/math-iter-sequences-nonnegative-even-integers":"@stdlib/math/iter/sequences/nonnegative-even-integers","@stdlib/math-iter-sequences-nonnegative-integers":"@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math-iter-sequences-nonpositive-even-integers":"@stdlib/math/iter/sequences/nonpositive-even-integers","@stdlib/math-iter-sequences-nonpositive-integers":"@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math-iter-sequences-nonsquares":"@stdlib/math/iter/sequences/nonsquares","@stdlib/iter-nth":"@stdlib/iter/nth","@stdlib/math-iter-sequences-odd-integers":"@stdlib/math/iter/sequences/odd-integers","@stdlib/simulate-iter-periodic-sinc":"@stdlib/simulate/iter/periodic-sinc","@stdlib/iter-pipeline":"@stdlib/iter/pipeline","@stdlib/iter-pop":"@stdlib/iter/pop","@stdlib/math-iter-sequences-positive-even-integers":"@stdlib/math/iter/sequences/positive-even-integers","@stdlib/math-iter-sequences-positive-integers":"@stdlib/math/iter/sequences/positive-integers","@stdlib/math-iter-sequences-positive-odd-integers":"@stdlib/math/iter/sequences/positive-odd-integers","@stdlib/math-iter-special-pow":"@stdlib/math/iter/special/pow","@stdlib/math-iter-sequences-primes":"@stdlib/math/iter/sequences/primes","@stdlib/stats-iter-prod":"@stdlib/stats/iter/prod","@stdlib/simulate-iter-pulse":"@stdlib/simulate/iter/pulse","@stdlib/iter-push":"@stdlib/iter/push","@stdlib/math-iter-special-rad2deg":"@stdlib/math/iter/special/rad2deg","@stdlib/math-iter-special-ramp":"@stdlib/math/iter/special/ramp","@stdlib/stats-iter-range":"@stdlib/stats/iter/range","@stdlib/iter-reject":"@stdlib/iter/reject","@stdlib/iter-replicate":"@stdlib/iter/replicate","@stdlib/iter-replicate-by":"@stdlib/iter/replicate-by","@stdlib/math-iter-special-round":"@stdlib/math/iter/special/round","@stdlib/math-iter-special-round2":"@stdlib/math/iter/special/round2","@stdlib/math-iter-special-round10":"@stdlib/math/iter/special/round10","@stdlib/math-iter-special-rsqrt":"@stdlib/math/iter/special/rsqrt","@stdlib/simulate-iter-sawtooth-wave":"@stdlib/simulate/iter/sawtooth-wave","@stdlib/iter-shift":"@stdlib/iter/shift","@stdlib/math-iter-special-signum":"@stdlib/math/iter/special/signum","@stdlib/math-iter-special-sin":"@stdlib/math/iter/special/sin","@stdlib/math-iter-special-sinc":"@stdlib/math/iter/special/sinc","@stdlib/simulate-iter-sine-wave":"@stdlib/simulate/iter/sine-wave","@stdlib/math-iter-special-sinh":"@stdlib/math/iter/special/sinh","@stdlib/math-iter-special-sinpi":"@stdlib/math/iter/special/sinpi","@stdlib/iter-slice":"@stdlib/iter/slice","@stdlib/iter-some":"@stdlib/iter/some","@stdlib/iter-some-by":"@stdlib/iter/some-by","@stdlib/math-iter-special-spence":"@stdlib/math/iter/special/spence","@stdlib/math-iter-special-sqrt":"@stdlib/math/iter/special/sqrt","@stdlib/math-iter-special-sqrt1pm1":"@stdlib/math/iter/special/sqrt1pm1","@stdlib/math-iter-sequences-squared-triangular":"@stdlib/math/iter/sequences/squared-triangular","@stdlib/math-iter-sequences-squares":"@stdlib/math/iter/sequences/squares","@stdlib/simulate-iter-square-wave":"@stdlib/simulate/iter/square-wave","@stdlib/stats-iter-stdev":"@stdlib/stats/iter/stdev","@stdlib/iter-step":"@stdlib/iter/step","@stdlib/iter-strided":"@stdlib/iter/strided","@stdlib/iter-strided-by":"@stdlib/iter/strided-by","@stdlib/math-iter-ops-subtract":"@stdlib/math/iter/ops/subtract","@stdlib/stats-iter-sum":"@stdlib/stats/iter/sum","@stdlib/stats-iter-sumabs":"@stdlib/stats/iter/sumabs","@stdlib/stats-iter-sumabs2":"@stdlib/stats/iter/sumabs2","@stdlib/math-iter-special-tan":"@stdlib/math/iter/special/tan","@stdlib/math-iter-special-tanh":"@stdlib/math/iter/special/tanh","@stdlib/iter-pipeline-thunk":"@stdlib/iter/pipeline-thunk","@stdlib/simulate-iter-triangle-wave":"@stdlib/simulate/iter/triangle-wave","@stdlib/math-iter-sequences-triangular":"@stdlib/math/iter/sequences/triangular","@stdlib/math-iter-sequences-tribonacci":"@stdlib/math/iter/sequences/tribonacci","@stdlib/math-iter-special-trigamma":"@stdlib/math/iter/special/trigamma","@stdlib/math-iter-special-trunc":"@stdlib/math/iter/special/trunc","@stdlib/math-iter-special-trunc2":"@stdlib/math/iter/special/trunc2","@stdlib/math-iter-special-trunc10":"@stdlib/math/iter/special/trunc10","@stdlib/iter-union":"@stdlib/iter/union","@stdlib/iter-unique":"@stdlib/iter/unique","@stdlib/iter-unique-by":"@stdlib/iter/unique-by","@stdlib/iter-unique-by-hash":"@stdlib/iter/unique-by-hash","@stdlib/iter-unitspace":"@stdlib/iter/unitspace","@stdlib/iter-unshift":"@stdlib/iter/unshift","@stdlib/iter-until-each":"@stdlib/iter/until-each","@stdlib/stats-iter-variance":"@stdlib/stats/iter/variance","@stdlib/math-iter-special-vercos":"@stdlib/math/iter/special/vercos","@stdlib/math-iter-special-versin":"@stdlib/math/iter/special/versin","@stdlib/iter-while-each":"@stdlib/iter/while-each","@stdlib/math-iter-special-riemann-zeta":"@stdlib/math/iter/special/riemann-zeta","@stdlib/streams-node-join":"@stdlib/streams/node/join","@stdlib/stats-kde2d":"@stdlib/stats/kde2d","@stdlib/string-kebabcase":"@stdlib/string/kebabcase","@stdlib/utils-key-by":"@stdlib/utils/key-by","@stdlib/utils-key-by-right":"@stdlib/utils/key-by-right","@stdlib/utils-keys-in":"@stdlib/utils/keys-in","@stdlib/stats-kruskal-test":"@stdlib/stats/kruskal-test","@stdlib/stats-kstest":"@stdlib/stats/kstest","@stdlib/string-last":"@stdlib/string/last","@stdlib/nlp-lda":"@stdlib/nlp/lda","@stdlib/stats-levene-test":"@stdlib/stats/levene-test","@stdlib/dstructs-linked-list":"@stdlib/dstructs/linked-list","@stdlib/array-linspace":"@stdlib/array/linspace","@stdlib/datasets-liu-negative-opinion-words-en":"@stdlib/datasets/liu-negative-opinion-words-en","@stdlib/datasets-liu-positive-opinion-words-en":"@stdlib/datasets/liu-positive-opinion-words-en","@stdlib/constants-float64-ln-half":"@stdlib/constants/float64/ln-half","@stdlib/constants-float64-ln-pi":"@stdlib/constants/float64/ln-pi","@stdlib/constants-float64-ln-sqrt-two-pi":"@stdlib/constants/float64/ln-sqrt-two-pi","@stdlib/constants-float64-ln-two-pi":"@stdlib/constants/float64/ln-two-pi","@stdlib/constants-float64-ln-two":"@stdlib/constants/float64/ln-two","@stdlib/constants-float64-ln-ten":"@stdlib/constants/float64/ln-ten","@stdlib/constants-float64-log2-e":"@stdlib/constants/float64/log2-e","@stdlib/constants-float64-log10-e":"@stdlib/constants/float64/log10-e","@stdlib/array-logspace":"@stdlib/array/logspace","@stdlib/string-lowercase":"@stdlib/string/lowercase","@stdlib/utils-lowercase-keys":"@stdlib/utils/lowercase-keys","@stdlib/stats-lowess":"@stdlib/stats/lowess","@stdlib/string-left-pad":"@stdlib/string/left-pad","@stdlib/string-left-trim":"@stdlib/string/left-trim","@stdlib/string-left-trim-n":"@stdlib/string/left-trim-n","@stdlib/datasets-male-first-names-en":"@stdlib/datasets/male-first-names-en","@stdlib/utils-map":"@stdlib/utils/map","@stdlib/utils-map2":"@stdlib/utils/map2","@stdlib/utils-map2d":"@stdlib/utils/map2d","@stdlib/utils-map2-right":"@stdlib/utils/map2-right","@stdlib/utils-map3d":"@stdlib/utils/map3d","@stdlib/utils-map4d":"@stdlib/utils/map4d","@stdlib/utils-map5d":"@stdlib/utils/map5d","@stdlib/utils-map-arguments":"@stdlib/utils/map-arguments","@stdlib/utils-map-function":"@stdlib/utils/map-function","@stdlib/utils-async-map-function":"@stdlib/utils/async/map-function","@stdlib/utils-map-keys":"@stdlib/utils/map-keys","@stdlib/utils-async-map-keys":"@stdlib/utils/async/map-keys","@stdlib/utils-map-reduce":"@stdlib/utils/map-reduce","@stdlib/utils-map-reduce-right":"@stdlib/utils/map-reduce-right","@stdlib/utils-map-right":"@stdlib/utils/map-right","@stdlib/utils-map-values":"@stdlib/utils/map-values","@stdlib/utils-async-map-values":"@stdlib/utils/async/map-values","@stdlib/utils-mask-arguments":"@stdlib/utils/mask-arguments","@stdlib/constants-array-max-array-length":"@stdlib/constants/array/max-array-length","@stdlib/constants-array-max-typed-array-length":"@stdlib/constants/array/max-typed-array-length","@stdlib/ndarray-maybe-broadcast-array":"@stdlib/ndarray/maybe-broadcast-array","@stdlib/ndarray-maybe-broadcast-arrays":"@stdlib/ndarray/maybe-broadcast-arrays","@stdlib/utils-memoize":"@stdlib/utils/memoize","@stdlib/utils-merge":"@stdlib/utils/merge","@stdlib/constants-time-milliseconds-in-day":"@stdlib/constants/time/milliseconds-in-day","@stdlib/constants-time-milliseconds-in-hour":"@stdlib/constants/time/milliseconds-in-hour","@stdlib/constants-time-milliseconds-in-minute":"@stdlib/constants/time/milliseconds-in-minute","@stdlib/constants-time-milliseconds-in-second":"@stdlib/constants/time/milliseconds-in-second","@stdlib/constants-time-milliseconds-in-week":"@stdlib/constants/time/milliseconds-in-week","@stdlib/datasets-minard-napoleons-march":"@stdlib/datasets/minard-napoleons-march","@stdlib/constants-time-minutes-in-day":"@stdlib/constants/time/minutes-in-day","@stdlib/constants-time-minutes-in-hour":"@stdlib/constants/time/minutes-in-hour","@stdlib/constants-time-minutes-in-week":"@stdlib/constants/time/minutes-in-week","@stdlib/time-minutes-in-month":"@stdlib/time/minutes-in-month","@stdlib/time-minutes-in-year":"@stdlib/time/minutes-in-year","@stdlib/datasets-moby-dick":"@stdlib/datasets/moby-dick","@stdlib/datasets-month-names-en":"@stdlib/datasets/month-names-en","@stdlib/constants-time-months-in-year":"@stdlib/constants/time/months-in-year","@stdlib/utils-move-property":"@stdlib/utils/move-property","@stdlib/slice-multi":"@stdlib/slice/multi","@stdlib/dstructs-named-typed-tuple":"@stdlib/dstructs/named-typed-tuple","@stdlib/constants-float64-nan":"@stdlib/constants/float64/nan","@stdlib/utils-nary-function":"@stdlib/utils/nary-function","@stdlib/utils-native-class":"@stdlib/utils/native-class","@stdlib/ndarray-ctor":"@stdlib/ndarray/ctor","@stdlib/ndarray-to-array":"@stdlib/ndarray/to-array","@stdlib/ndarray-to-fancy":"@stdlib/ndarray/to-fancy","@stdlib/ndarray-to-json":"@stdlib/ndarray/to-json","@stdlib/ndarray-casting-modes":"@stdlib/ndarray/casting-modes","@stdlib/ndarray-data-buffer":"@stdlib/ndarray/data-buffer","@stdlib/ndarray-dtype":"@stdlib/ndarray/dtype","@stdlib/ndarray-dtypes":"@stdlib/ndarray/dtypes","@stdlib/ndarray-dispatch":"@stdlib/ndarray/dispatch","@stdlib/ndarray-flag":"@stdlib/ndarray/flag","@stdlib/ndarray-flags":"@stdlib/ndarray/flags","@stdlib/ndarray-index-modes":"@stdlib/ndarray/index-modes","@stdlib/ndarray-ndarraylike2ndarray":"@stdlib/ndarray/ndarraylike2ndarray","@stdlib/ndarray-min-dtype":"@stdlib/ndarray/min-dtype","@stdlib/ndarray-mostly-safe-casts":"@stdlib/ndarray/mostly-safe-casts","@stdlib/ndarray-next-dtype":"@stdlib/ndarray/next-dtype","@stdlib/ndarray-offset":"@stdlib/ndarray/offset","@stdlib/ndarray-order":"@stdlib/ndarray/order","@stdlib/ndarray-orders":"@stdlib/ndarray/orders","@stdlib/ndarray-promotion-rules":"@stdlib/ndarray/promotion-rules","@stdlib/ndarray-safe-casts":"@stdlib/ndarray/safe-casts","@stdlib/ndarray-same-kind-casts":"@stdlib/ndarray/same-kind-casts","@stdlib/ndarray-shape":"@stdlib/ndarray/shape","@stdlib/ndarray-stride":"@stdlib/ndarray/stride","@stdlib/ndarray-strides":"@stdlib/ndarray/strides","@stdlib/ndarray-at":"@stdlib/ndarray/at","@stdlib/ndarray-empty":"@stdlib/ndarray/empty","@stdlib/ndarray-empty-like":"@stdlib/ndarray/empty-like","@stdlib/ndarray-filter":"@stdlib/ndarray/filter","@stdlib/ndarray-filter-map":"@stdlib/ndarray/filter-map","@stdlib/ndarray-for-each":"@stdlib/ndarray/for-each","@stdlib/ndarray-ndims":"@stdlib/ndarray/ndims","@stdlib/ndarray-index":"@stdlib/ndarray/index","@stdlib/ndarray-iter-to-array-each":"@stdlib/ndarray/iter/to-array-each","@stdlib/ndarray-iter-column-entries":"@stdlib/ndarray/iter/column-entries","@stdlib/ndarray-iter-columns":"@stdlib/ndarray/iter/columns","@stdlib/ndarray-iter-entries":"@stdlib/ndarray/iter/entries","@stdlib/ndarray-iter-indices":"@stdlib/ndarray/iter/indices","@stdlib/ndarray-iter-interleave-subarrays":"@stdlib/ndarray/iter/interleave-subarrays","@stdlib/ndarray-iter-matrices":"@stdlib/ndarray/iter/matrices","@stdlib/ndarray-iter-matrix-entries":"@stdlib/ndarray/iter/matrix-entries","@stdlib/ndarray-iter-row-entries":"@stdlib/ndarray/iter/row-entries","@stdlib/ndarray-iter-rows":"@stdlib/ndarray/iter/rows","@stdlib/ndarray-iter-select-dimension":"@stdlib/ndarray/iter/select-dimension","@stdlib/ndarray-iter-stacks":"@stdlib/ndarray/iter/stacks","@stdlib/ndarray-iter-subarrays":"@stdlib/ndarray/iter/subarrays","@stdlib/ndarray-iter-values":"@stdlib/ndarray/iter/values","@stdlib/ndarray-map":"@stdlib/ndarray/map","@stdlib/ndarray-reject":"@stdlib/ndarray/reject","@stdlib/ndarray-slice":"@stdlib/ndarray/slice","@stdlib/ndarray-slice-assign":"@stdlib/ndarray/slice-assign","@stdlib/ndarray-slice-dimension":"@stdlib/ndarray/slice-dimension","@stdlib/ndarray-slice-dimension-from":"@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray-slice-dimension-to":"@stdlib/ndarray/slice-dimension-to","@stdlib/ndarray-slice-from":"@stdlib/ndarray/slice-from","@stdlib/ndarray-slice-to":"@stdlib/ndarray/slice-to","@stdlib/ndarray-zeros":"@stdlib/ndarray/zeros","@stdlib/ndarray-zeros-like":"@stdlib/ndarray/zeros-like","@stdlib/string-next-grapheme-cluster-break":"@stdlib/string/next-grapheme-cluster-break","@stdlib/utils-next-tick":"@stdlib/utils/next-tick","@stdlib/datasets-nightingales-rose":"@stdlib/datasets/nightingales-rose","@stdlib/constants-float64-ninf":"@stdlib/constants/float64/ninf","@stdlib/process-node-version":"@stdlib/process/node-version","@stdlib/utils-none":"@stdlib/utils/none","@stdlib/utils-none-by":"@stdlib/utils/none-by","@stdlib/utils-async-none-by":"@stdlib/utils/async/none-by","@stdlib/utils-none-by-right":"@stdlib/utils/none-by-right","@stdlib/utils-async-none-by-right":"@stdlib/utils/async/none-by-right","@stdlib/utils-none-in-by":"@stdlib/utils/none-in-by","@stdlib/utils-nonenumerable-properties":"@stdlib/utils/nonenumerable-properties","@stdlib/utils-nonenumerable-properties-in":"@stdlib/utils/nonenumerable-properties-in","@stdlib/utils-nonenumerable-property-names":"@stdlib/utils/nonenumerable-property-names","@stdlib/utils-nonenumerable-property-names-in":"@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils-nonenumerable-property-symbols":"@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils-nonenumerable-property-symbols-in":"@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils-none-own-by":"@stdlib/utils/none-own-by","@stdlib/utils-nonindex-keys":"@stdlib/utils/nonindex-keys","@stdlib/utils-noop":"@stdlib/utils/noop","@stdlib/time-now":"@stdlib/time/now","@stdlib/os-num-cpus":"@stdlib/os/num-cpus","@stdlib/string-num2words":"@stdlib/string/num2words","@stdlib/number-ctor":"@stdlib/number/ctor","@stdlib/ndarray-numel":"@stdlib/ndarray/numel","@stdlib/ndarray-numel-dimension":"@stdlib/ndarray/numel-dimension","@stdlib/string-num-grapheme-clusters":"@stdlib/string/num-grapheme-clusters","@stdlib/object-ctor":"@stdlib/object/ctor","@stdlib/utils-entries":"@stdlib/utils/entries","@stdlib/utils-entries-in":"@stdlib/utils/entries-in","@stdlib/utils-from-entries":"@stdlib/utils/from-entries","@stdlib/utils-object-inverse":"@stdlib/utils/object-inverse","@stdlib/utils-object-inverse-by":"@stdlib/utils/object-inverse-by","@stdlib/utils-keys":"@stdlib/utils/keys","@stdlib/utils-values":"@stdlib/utils/values","@stdlib/utils-values-in":"@stdlib/utils/values-in","@stdlib/utils-omit":"@stdlib/utils/omit","@stdlib/utils-omit-by":"@stdlib/utils/omit-by","@stdlib/fs-open":"@stdlib/fs/open","@stdlib/utils-open-url":"@stdlib/utils/open-url","@stdlib/nlp-ordinalize":"@stdlib/nlp/ordinalize","@stdlib/datasets-pace-boston-house-prices":"@stdlib/datasets/pace-boston-house-prices","@stdlib/string-pad":"@stdlib/string/pad","@stdlib/stats-padjust":"@stdlib/stats/padjust","@stdlib/utils-papply":"@stdlib/utils/papply","@stdlib/utils-papply-right":"@stdlib/utils/papply-right","@stdlib/utils-parallel":"@stdlib/utils/parallel","@stdlib/utils-parse-json":"@stdlib/utils/parse-json","@stdlib/string-pascalcase":"@stdlib/string/pascalcase","@stdlib/constants-path-delimiter":"@stdlib/constants/path/delimiter","@stdlib/constants-path-delimiter-posix":"@stdlib/constants/path/delimiter-posix","@stdlib/constants-path-delimiter-win32":"@stdlib/constants/path/delimiter-win32","@stdlib/constants-path-sep":"@stdlib/constants/path/sep","@stdlib/constants-path-sep-posix":"@stdlib/constants/path/sep-posix","@stdlib/constants-path-sep-win32":"@stdlib/constants/path/sep-win32","@stdlib/stats-pcorrtest":"@stdlib/stats/pcorrtest","@stdlib/string-percent-encode":"@stdlib/string/percent-encode","@stdlib/constants-float64-phi":"@stdlib/constants/float64/phi","@stdlib/constants-float64-pi":"@stdlib/constants/float64/pi","@stdlib/constants-float64-pi-squared":"@stdlib/constants/float64/pi-squared","@stdlib/utils-pick":"@stdlib/utils/pick","@stdlib/utils-pick-arguments":"@stdlib/utils/pick-arguments","@stdlib/utils-pick-by":"@stdlib/utils/pick-by","@stdlib/constants-float64-pinf":"@stdlib/constants/float64/pinf","@stdlib/namespace-pkg2alias":"@stdlib/namespace/pkg2alias","@stdlib/namespace-pkg2related":"@stdlib/namespace/pkg2related","@stdlib/namespace-pkg2standalone":"@stdlib/namespace/pkg2standalone","@stdlib/os-platform":"@stdlib/os/platform","@stdlib/plot":"@stdlib/plot","@stdlib/plot-ctor":"@stdlib/plot/ctor","@stdlib/utils-pluck":"@stdlib/utils/pluck","@stdlib/utils-pop":"@stdlib/utils/pop","@stdlib/nlp-porter-stemmer":"@stdlib/nlp/porter-stemmer","@stdlib/utils-prepend":"@stdlib/utils/prepend","@stdlib/string-prev-grapheme-cluster-break":"@stdlib/string/prev-grapheme-cluster-break","@stdlib/datasets-primes-100k":"@stdlib/datasets/primes-100k","@stdlib/utils-properties":"@stdlib/utils/properties","@stdlib/utils-properties-in":"@stdlib/utils/properties-in","@stdlib/utils-property-descriptor":"@stdlib/utils/property-descriptor","@stdlib/utils-property-descriptor-in":"@stdlib/utils/property-descriptor-in","@stdlib/utils-property-descriptors":"@stdlib/utils/property-descriptors","@stdlib/utils-property-descriptors-in":"@stdlib/utils/property-descriptors-in","@stdlib/utils-property-names":"@stdlib/utils/property-names","@stdlib/utils-property-names-in":"@stdlib/utils/property-names-in","@stdlib/utils-property-symbols":"@stdlib/utils/property-symbols","@stdlib/utils-property-symbols-in":"@stdlib/utils/property-symbols-in","@stdlib/proxy-ctor":"@stdlib/proxy/ctor","@stdlib/utils-push":"@stdlib/utils/push","@stdlib/time-quarter-of-year":"@stdlib/time/quarter-of-year","@stdlib/random-array-arcsine":"@stdlib/random/array/arcsine","@stdlib/random-array-bernoulli":"@stdlib/random/array/bernoulli","@stdlib/random-array-beta":"@stdlib/random/array/beta","@stdlib/random-array-betaprime":"@stdlib/random/array/betaprime","@stdlib/random-array-binomial":"@stdlib/random/array/binomial","@stdlib/random-array-cauchy":"@stdlib/random/array/cauchy","@stdlib/random-array-chi":"@stdlib/random/array/chi","@stdlib/random-array-chisquare":"@stdlib/random/array/chisquare","@stdlib/random-array-cosine":"@stdlib/random/array/cosine","@stdlib/random-array-discrete-uniform":"@stdlib/random/array/discrete-uniform","@stdlib/random-array-erlang":"@stdlib/random/array/erlang","@stdlib/random-array-exponential":"@stdlib/random/array/exponential","@stdlib/random-array-f":"@stdlib/random/array/f","@stdlib/random-array-frechet":"@stdlib/random/array/frechet","@stdlib/random-array-gamma":"@stdlib/random/array/gamma","@stdlib/random-array-geometric":"@stdlib/random/array/geometric","@stdlib/random-array-gumbel":"@stdlib/random/array/gumbel","@stdlib/random-array-hypergeometric":"@stdlib/random/array/hypergeometric","@stdlib/random-array-invgamma":"@stdlib/random/array/invgamma","@stdlib/random-array-kumaraswamy":"@stdlib/random/array/kumaraswamy","@stdlib/random-array-laplace":"@stdlib/random/array/laplace","@stdlib/random-array-levy":"@stdlib/random/array/levy","@stdlib/random-array-logistic":"@stdlib/random/array/logistic","@stdlib/random-array-lognormal":"@stdlib/random/array/lognormal","@stdlib/random-array-minstd":"@stdlib/random/array/minstd","@stdlib/random-array-minstd-shuffle":"@stdlib/random/array/minstd-shuffle","@stdlib/random-array-mt19937":"@stdlib/random/array/mt19937","@stdlib/random-array-negative-binomial":"@stdlib/random/array/negative-binomial","@stdlib/random-array-normal":"@stdlib/random/array/normal","@stdlib/random-array-pareto-type1":"@stdlib/random/array/pareto-type1","@stdlib/random-array-poisson":"@stdlib/random/array/poisson","@stdlib/random-array-randu":"@stdlib/random/array/randu","@stdlib/random-array-rayleigh":"@stdlib/random/array/rayleigh","@stdlib/random-array-t":"@stdlib/random/array/t","@stdlib/random-array-triangular":"@stdlib/random/array/triangular","@stdlib/random-array-uniform":"@stdlib/random/array/uniform","@stdlib/random-array-weibull":"@stdlib/random/array/weibull","@stdlib/random-iter-arcsine":"@stdlib/random/iter/arcsine","@stdlib/random-iter-bernoulli":"@stdlib/random/iter/bernoulli","@stdlib/random-iter-beta":"@stdlib/random/iter/beta","@stdlib/random-iter-betaprime":"@stdlib/random/iter/betaprime","@stdlib/random-iter-binomial":"@stdlib/random/iter/binomial","@stdlib/random-iter-box-muller":"@stdlib/random/iter/box-muller","@stdlib/random-iter-cauchy":"@stdlib/random/iter/cauchy","@stdlib/random-iter-chi":"@stdlib/random/iter/chi","@stdlib/random-iter-chisquare":"@stdlib/random/iter/chisquare","@stdlib/random-iter-cosine":"@stdlib/random/iter/cosine","@stdlib/random-iter-discrete-uniform":"@stdlib/random/iter/discrete-uniform","@stdlib/random-iter-erlang":"@stdlib/random/iter/erlang","@stdlib/random-iter-exponential":"@stdlib/random/iter/exponential","@stdlib/random-iter-f":"@stdlib/random/iter/f","@stdlib/random-iter-frechet":"@stdlib/random/iter/frechet","@stdlib/random-iter-gamma":"@stdlib/random/iter/gamma","@stdlib/random-iter-geometric":"@stdlib/random/iter/geometric","@stdlib/random-iter-gumbel":"@stdlib/random/iter/gumbel","@stdlib/random-iter-hypergeometric":"@stdlib/random/iter/hypergeometric","@stdlib/random-iter-improved-ziggurat":"@stdlib/random/iter/improved-ziggurat","@stdlib/random-iter-invgamma":"@stdlib/random/iter/invgamma","@stdlib/random-iter-kumaraswamy":"@stdlib/random/iter/kumaraswamy","@stdlib/random-iter-laplace":"@stdlib/random/iter/laplace","@stdlib/random-iter-levy":"@stdlib/random/iter/levy","@stdlib/random-iter-logistic":"@stdlib/random/iter/logistic","@stdlib/random-iter-lognormal":"@stdlib/random/iter/lognormal","@stdlib/random-iter-minstd":"@stdlib/random/iter/minstd","@stdlib/random-iter-minstd-shuffle":"@stdlib/random/iter/minstd-shuffle","@stdlib/random-iter-mt19937":"@stdlib/random/iter/mt19937","@stdlib/random-iter-negative-binomial":"@stdlib/random/iter/negative-binomial","@stdlib/random-iter-normal":"@stdlib/random/iter/normal","@stdlib/random-iter-pareto-type1":"@stdlib/random/iter/pareto-type1","@stdlib/random-iter-poisson":"@stdlib/random/iter/poisson","@stdlib/random-iter-randi":"@stdlib/random/iter/randi","@stdlib/random-iter-randn":"@stdlib/random/iter/randn","@stdlib/random-iter-randu":"@stdlib/random/iter/randu","@stdlib/random-iter-rayleigh":"@stdlib/random/iter/rayleigh","@stdlib/random-iter-t":"@stdlib/random/iter/t","@stdlib/random-iter-triangular":"@stdlib/random/iter/triangular","@stdlib/random-iter-uniform":"@stdlib/random/iter/uniform","@stdlib/random-iter-weibull":"@stdlib/random/iter/weibull","@stdlib/random-streams-arcsine":"@stdlib/random/streams/arcsine","@stdlib/random-streams-bernoulli":"@stdlib/random/streams/bernoulli","@stdlib/random-streams-beta":"@stdlib/random/streams/beta","@stdlib/random-streams-betaprime":"@stdlib/random/streams/betaprime","@stdlib/random-streams-binomial":"@stdlib/random/streams/binomial","@stdlib/random-streams-box-muller":"@stdlib/random/streams/box-muller","@stdlib/random-streams-cauchy":"@stdlib/random/streams/cauchy","@stdlib/random-streams-chi":"@stdlib/random/streams/chi","@stdlib/random-streams-chisquare":"@stdlib/random/streams/chisquare","@stdlib/random-streams-cosine":"@stdlib/random/streams/cosine","@stdlib/random-streams-discrete-uniform":"@stdlib/random/streams/discrete-uniform","@stdlib/random-streams-erlang":"@stdlib/random/streams/erlang","@stdlib/random-streams-exponential":"@stdlib/random/streams/exponential","@stdlib/random-streams-f":"@stdlib/random/streams/f","@stdlib/random-streams-frechet":"@stdlib/random/streams/frechet","@stdlib/random-streams-gamma":"@stdlib/random/streams/gamma","@stdlib/random-streams-geometric":"@stdlib/random/streams/geometric","@stdlib/random-streams-gumbel":"@stdlib/random/streams/gumbel","@stdlib/random-streams-hypergeometric":"@stdlib/random/streams/hypergeometric","@stdlib/random-streams-improved-ziggurat":"@stdlib/random/streams/improved-ziggurat","@stdlib/random-streams-invgamma":"@stdlib/random/streams/invgamma","@stdlib/random-streams-kumaraswamy":"@stdlib/random/streams/kumaraswamy","@stdlib/random-streams-laplace":"@stdlib/random/streams/laplace","@stdlib/random-streams-levy":"@stdlib/random/streams/levy","@stdlib/random-streams-logistic":"@stdlib/random/streams/logistic","@stdlib/random-streams-lognormal":"@stdlib/random/streams/lognormal","@stdlib/random-streams-minstd":"@stdlib/random/streams/minstd","@stdlib/random-streams-minstd-shuffle":"@stdlib/random/streams/minstd-shuffle","@stdlib/random-streams-mt19937":"@stdlib/random/streams/mt19937","@stdlib/random-streams-negative-binomial":"@stdlib/random/streams/negative-binomial","@stdlib/random-streams-normal":"@stdlib/random/streams/normal","@stdlib/random-streams-pareto-type1":"@stdlib/random/streams/pareto-type1","@stdlib/random-streams-poisson":"@stdlib/random/streams/poisson","@stdlib/random-streams-randi":"@stdlib/random/streams/randi","@stdlib/random-streams-randn":"@stdlib/random/streams/randn","@stdlib/random-streams-randu":"@stdlib/random/streams/randu","@stdlib/random-streams-rayleigh":"@stdlib/random/streams/rayleigh","@stdlib/random-streams-t":"@stdlib/random/streams/t","@stdlib/random-streams-triangular":"@stdlib/random/streams/triangular","@stdlib/random-streams-uniform":"@stdlib/random/streams/uniform","@stdlib/random-streams-weibull":"@stdlib/random/streams/weibull","@stdlib/random-strided-arcsine":"@stdlib/random/strided/arcsine","@stdlib/random-strided-bernoulli":"@stdlib/random/strided/bernoulli","@stdlib/random-strided-beta":"@stdlib/random/strided/beta","@stdlib/random-strided-betaprime":"@stdlib/random/strided/betaprime","@stdlib/random-strided-chi":"@stdlib/random/strided/chi","@stdlib/random-strided-chisquare":"@stdlib/random/strided/chisquare","@stdlib/random-strided-cosine":"@stdlib/random/strided/cosine","@stdlib/random-strided-discrete-uniform":"@stdlib/random/strided/discrete-uniform","@stdlib/random-strided-exponential":"@stdlib/random/strided/exponential","@stdlib/random-strided-gamma":"@stdlib/random/strided/gamma","@stdlib/random-strided-geometric":"@stdlib/random/strided/geometric","@stdlib/random-strided-invgamma":"@stdlib/random/strided/invgamma","@stdlib/random-strided-lognormal":"@stdlib/random/strided/lognormal","@stdlib/random-strided-minstd":"@stdlib/random/strided/minstd","@stdlib/random-strided-minstd-shuffle":"@stdlib/random/strided/minstd-shuffle","@stdlib/random-strided-mt19937":"@stdlib/random/strided/mt19937","@stdlib/random-strided-normal":"@stdlib/random/strided/normal","@stdlib/random-strided-poisson":"@stdlib/random/strided/poisson","@stdlib/random-strided-randu":"@stdlib/random/strided/randu","@stdlib/random-strided-rayleigh":"@stdlib/random/strided/rayleigh","@stdlib/random-strided-t":"@stdlib/random/strided/t","@stdlib/random-strided-uniform":"@stdlib/random/strided/uniform","@stdlib/random-strided-weibull":"@stdlib/random/strided/weibull","@stdlib/stats-ranks":"@stdlib/stats/ranks","@stdlib/fs-read-dir":"@stdlib/fs/read-dir","@stdlib/fs-read-file":"@stdlib/fs/read-file","@stdlib/fs-read-file-list":"@stdlib/fs/read-file-list","@stdlib/fs-read-json":"@stdlib/fs/read-json","@stdlib/fs-read-wasm":"@stdlib/fs/read-wasm","@stdlib/complex-float64-real":"@stdlib/complex/float64/real","@stdlib/array-typed-real":"@stdlib/array/typed-real","@stdlib/array-typed-real-ctors":"@stdlib/array/typed-real-ctors","@stdlib/array-typed-real-dtypes":"@stdlib/array/typed-real-dtypes","@stdlib/complex-float32-real":"@stdlib/complex/float32/real","@stdlib/utils-real-max":"@stdlib/utils/real-max","@stdlib/utils-real-min":"@stdlib/utils/real-min","@stdlib/regexp-basename":"@stdlib/regexp/basename","@stdlib/regexp-basename-posix":"@stdlib/regexp/basename-posix","@stdlib/regexp-basename-windows":"@stdlib/regexp/basename-windows","@stdlib/regexp-color-hexadecimal":"@stdlib/regexp/color-hexadecimal","@stdlib/regexp-decimal-number":"@stdlib/regexp/decimal-number","@stdlib/regexp-dirname":"@stdlib/regexp/dirname","@stdlib/regexp-dirname-posix":"@stdlib/regexp/dirname-posix","@stdlib/regexp-dirname-windows":"@stdlib/regexp/dirname-windows","@stdlib/utils-reduce":"@stdlib/utils/reduce","@stdlib/utils-reduce2d":"@stdlib/utils/reduce2d","@stdlib/utils-async-reduce":"@stdlib/utils/async/reduce","@stdlib/utils-reduce-right":"@stdlib/utils/reduce-right","@stdlib/utils-async-reduce-right":"@stdlib/utils/async/reduce-right","@stdlib/regexp-duration-string":"@stdlib/regexp/duration-string","@stdlib/regexp-eol":"@stdlib/regexp/eol","@stdlib/regexp-extended-length-path":"@stdlib/regexp/extended-length-path","@stdlib/regexp-extname":"@stdlib/regexp/extname","@stdlib/regexp-extname-posix":"@stdlib/regexp/extname-posix","@stdlib/regexp-extname-windows":"@stdlib/regexp/extname-windows","@stdlib/regexp-filename":"@stdlib/regexp/filename","@stdlib/regexp-filename-posix":"@stdlib/regexp/filename-posix","@stdlib/regexp-filename-windows":"@stdlib/regexp/filename-windows","@stdlib/utils-regexp-from-string":"@stdlib/utils/regexp-from-string","@stdlib/regexp-function-name":"@stdlib/regexp/function-name","@stdlib/regexp-to-json":"@stdlib/regexp/to-json","@stdlib/complex-float64-reim":"@stdlib/complex/float64/reim","@stdlib/complex-float32-reim":"@stdlib/complex/float32/reim","@stdlib/utils-reject-arguments":"@stdlib/utils/reject-arguments","@stdlib/string-remove-first":"@stdlib/string/remove-first","@stdlib/string-remove-last":"@stdlib/string/remove-last","@stdlib/string-remove-punctuation":"@stdlib/string/remove-punctuation","@stdlib/string-remove-utf8-bom":"@stdlib/string/remove-utf8-bom","@stdlib/string-remove-words":"@stdlib/string/remove-words","@stdlib/fs-rename":"@stdlib/fs/rename","@stdlib/regexp-native-function":"@stdlib/regexp/native-function","@stdlib/utils-reorder-arguments":"@stdlib/utils/reorder-arguments","@stdlib/string-repeat":"@stdlib/string/repeat","@stdlib/string-replace":"@stdlib/string/replace","@stdlib/string-replace-before":"@stdlib/string/replace-before","@stdlib/regexp-regexp":"@stdlib/regexp/regexp","@stdlib/utils-escape-regexp-string":"@stdlib/utils/escape-regexp-string","@stdlib/regexp-semver":"@stdlib/regexp/semver","@stdlib/fs-resolve-parent-path":"@stdlib/fs/resolve-parent-path","@stdlib/fs-resolve-parent-path-by":"@stdlib/fs/resolve-parent-path-by","@stdlib/regexp-unc-path":"@stdlib/regexp/unc-path","@stdlib/regexp-utf16-surrogate-pair":"@stdlib/regexp/utf16-surrogate-pair","@stdlib/regexp-utf16-unpaired-surrogate":"@stdlib/regexp/utf16-unpaired-surrogate","@stdlib/utils-reverse-arguments":"@stdlib/utils/reverse-arguments","@stdlib/string-reverse":"@stdlib/string/reverse","@stdlib/random-base-reviver":"@stdlib/random/base/reviver","@stdlib/buffer-reviver":"@stdlib/buffer/reviver","@stdlib/complex-reviver":"@stdlib/complex/reviver","@stdlib/complex-float32-reviver":"@stdlib/complex/float32/reviver","@stdlib/complex-float64-reviver":"@stdlib/complex/float64/reviver","@stdlib/error-reviver":"@stdlib/error/reviver","@stdlib/regexp-reviver":"@stdlib/regexp/reviver","@stdlib/array-reviver":"@stdlib/array/reviver","@stdlib/regexp-whitespace":"@stdlib/regexp/whitespace","@stdlib/string-right-pad":"@stdlib/string/right-pad","@stdlib/string-right-trim":"@stdlib/string/right-trim","@stdlib/string-right-trim-n":"@stdlib/string/right-trim-n","@stdlib/utils-safe-int-max":"@stdlib/utils/safe-int-max","@stdlib/utils-safe-int-min":"@stdlib/utils/safe-int-min","@stdlib/random-sample":"@stdlib/random/sample","@stdlib/datasets-savoy-stopwords-fin":"@stdlib/datasets/savoy-stopwords-fin","@stdlib/datasets-savoy-stopwords-fr":"@stdlib/datasets/savoy-stopwords-fr","@stdlib/datasets-savoy-stopwords-ger":"@stdlib/datasets/savoy-stopwords-ger","@stdlib/datasets-savoy-stopwords-it":"@stdlib/datasets/savoy-stopwords-it","@stdlib/datasets-savoy-stopwords-por":"@stdlib/datasets/savoy-stopwords-por","@stdlib/datasets-savoy-stopwords-sp":"@stdlib/datasets/savoy-stopwords-sp","@stdlib/datasets-savoy-stopwords-swe":"@stdlib/datasets/savoy-stopwords-swe","@stdlib/array-from-scalar":"@stdlib/array/from-scalar","@stdlib/ndarray-from-scalar":"@stdlib/ndarray/from-scalar","@stdlib/blas-sdot":"@stdlib/blas/sdot","@stdlib/constants-time-seconds-in-day":"@stdlib/constants/time/seconds-in-day","@stdlib/constants-time-seconds-in-hour":"@stdlib/constants/time/seconds-in-hour","@stdlib/constants-time-seconds-in-minute":"@stdlib/constants/time/seconds-in-minute","@stdlib/constants-time-seconds-in-week":"@stdlib/constants/time/seconds-in-week","@stdlib/time-seconds-in-month":"@stdlib/time/seconds-in-month","@stdlib/time-seconds-in-year":"@stdlib/time/seconds-in-year","@stdlib/nlp-sentencize":"@stdlib/nlp/sentencize","@stdlib/slice-seq2slice":"@stdlib/slice/seq2slice","@stdlib/utils-define-configurable-read-only-property":"@stdlib/utils/define-configurable-read-only-property","@stdlib/utils-define-configurable-read-only-accessor":"@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils-define-configurable-read-write-accessor":"@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils-define-configurable-write-only-accessor":"@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils-define-memoized-configurable-read-only-property":"@stdlib/utils/define-memoized-configurable-read-only-property","@stdlib/utils-define-memoized-read-only-property":"@stdlib/utils/define-memoized-read-only-property","@stdlib/utils-define-nonenumerable-property":"@stdlib/utils/define-nonenumerable-property","@stdlib/utils-define-nonenumerable-read-only-property":"@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils-define-nonenumerable-read-only-accessor":"@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils-define-nonenumerable-read-write-accessor":"@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils-define-nonenumerable-write-only-accessor":"@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils-define-read-only-property":"@stdlib/utils/define-read-only-property","@stdlib/utils-define-read-only-accessor":"@stdlib/utils/define-read-only-accessor","@stdlib/utils-define-read-write-accessor":"@stdlib/utils/define-read-write-accessor","@stdlib/utils-define-write-only-accessor":"@stdlib/utils/define-write-only-accessor","@stdlib/array-shared-buffer":"@stdlib/array/shared-buffer","@stdlib/utils-shift":"@stdlib/utils/shift","@stdlib/random-shuffle":"@stdlib/random/shuffle","@stdlib/utils-size-of":"@stdlib/utils/size-of","@stdlib/slice-ctor":"@stdlib/slice/ctor","@stdlib/string-snakecase":"@stdlib/string/snakecase","@stdlib/utils-some":"@stdlib/utils/some","@stdlib/utils-some-by":"@stdlib/utils/some-by","@stdlib/utils-async-some-by":"@stdlib/utils/async/some-by","@stdlib/utils-some-by-right":"@stdlib/utils/some-by-right","@stdlib/utils-async-some-by-right":"@stdlib/utils/async/some-by-right","@stdlib/utils-some-in-by":"@stdlib/utils/some-in-by","@stdlib/utils-some-own-by":"@stdlib/utils/some-own-by","@stdlib/datasets-sotu":"@stdlib/datasets/sotu","@stdlib/datasets-spache-revised":"@stdlib/datasets/spache-revised","@stdlib/datasets-spam-assassin":"@stdlib/datasets/spam-assassin","@stdlib/plot-sparklines-base-ctor":"@stdlib/plot/sparklines/base/ctor","@stdlib/array-to-sparse-iterator":"@stdlib/array/to-sparse-iterator","@stdlib/array-to-sparse-iterator-right":"@stdlib/array/to-sparse-iterator-right","@stdlib/streams-node-split":"@stdlib/streams/node/split","@stdlib/constants-float64-sqrt-eps":"@stdlib/constants/float64/sqrt-eps","@stdlib/constants-float64-sqrt-half":"@stdlib/constants/float64/sqrt-half","@stdlib/constants-float64-sqrt-half-pi":"@stdlib/constants/float64/sqrt-half-pi","@stdlib/constants-float64-sqrt-phi":"@stdlib/constants/float64/sqrt-phi","@stdlib/constants-float64-sqrt-pi":"@stdlib/constants/float64/sqrt-pi","@stdlib/constants-float64-sqrt-three":"@stdlib/constants/float64/sqrt-three","@stdlib/constants-float64-sqrt-two":"@stdlib/constants/float64/sqrt-two","@stdlib/constants-float64-sqrt-two-pi":"@stdlib/constants/float64/sqrt-two-pi","@stdlib/datasets-ssa-us-births-2000-2014":"@stdlib/datasets/ssa-us-births-2000-2014","@stdlib/blas-sswap":"@stdlib/blas/sswap","@stdlib/dstructs-stack":"@stdlib/dstructs/stack","@stdlib/namespace-standalone2pkg":"@stdlib/namespace/standalone2pkg","@stdlib/datasets-standard-card-deck":"@stdlib/datasets/standard-card-deck","@stdlib/string-startcase":"@stdlib/string/startcase","@stdlib/string-starts-with":"@stdlib/string/starts-with","@stdlib/datasets-stopwords-en":"@stdlib/datasets/stopwords-en","@stdlib/math-strided-special-abs":"@stdlib/math/strided/special/abs","@stdlib/math-strided-special-abs2":"@stdlib/math/strided/special/abs2","@stdlib/math-strided-special-abs2-by":"@stdlib/math/strided/special/abs2-by","@stdlib/math-strided-special-abs-by":"@stdlib/math/strided/special/abs-by","@stdlib/math-strided-special-acos-by":"@stdlib/math/strided/special/acos-by","@stdlib/math-strided-special-acosh-by":"@stdlib/math/strided/special/acosh-by","@stdlib/math-strided-special-acot-by":"@stdlib/math/strided/special/acot-by","@stdlib/math-strided-special-acoth-by":"@stdlib/math/strided/special/acoth-by","@stdlib/math-strided-special-acovercos-by":"@stdlib/math/strided/special/acovercos-by","@stdlib/math-strided-special-acoversin-by":"@stdlib/math/strided/special/acoversin-by","@stdlib/math-strided-ops-add":"@stdlib/math/strided/ops/add","@stdlib/math-strided-ops-add-by":"@stdlib/math/strided/ops/add-by","@stdlib/math-strided-special-ahavercos-by":"@stdlib/math/strided/special/ahavercos-by","@stdlib/math-strided-special-ahaversin-by":"@stdlib/math/strided/special/ahaversin-by","@stdlib/math-strided-special-asin-by":"@stdlib/math/strided/special/asin-by","@stdlib/math-strided-special-asinh-by":"@stdlib/math/strided/special/asinh-by","@stdlib/math-strided-special-atan-by":"@stdlib/math/strided/special/atan-by","@stdlib/math-strided-special-atanh-by":"@stdlib/math/strided/special/atanh-by","@stdlib/math-strided-special-avercos-by":"@stdlib/math/strided/special/avercos-by","@stdlib/math-strided-special-aversin-by":"@stdlib/math/strided/special/aversin-by","@stdlib/math-strided-special-besselj0-by":"@stdlib/math/strided/special/besselj0-by","@stdlib/math-strided-special-besselj1-by":"@stdlib/math/strided/special/besselj1-by","@stdlib/math-strided-special-bessely0-by":"@stdlib/math/strided/special/bessely0-by","@stdlib/math-strided-special-bessely1-by":"@stdlib/math/strided/special/bessely1-by","@stdlib/math-strided-special-binet-by":"@stdlib/math/strided/special/binet-by","@stdlib/math-strided-special-cbrt":"@stdlib/math/strided/special/cbrt","@stdlib/math-strided-special-cbrt-by":"@stdlib/math/strided/special/cbrt-by","@stdlib/math-strided-special-ceil":"@stdlib/math/strided/special/ceil","@stdlib/math-strided-special-cos-by":"@stdlib/math/strided/special/cos-by","@stdlib/math-strided-special-deg2rad":"@stdlib/math/strided/special/deg2rad","@stdlib/strided-dtypes":"@stdlib/strided/dtypes","@stdlib/math-strided-special-dcbrt-by":"@stdlib/math/strided/special/dcbrt-by","@stdlib/strided-dispatch":"@stdlib/strided/dispatch","@stdlib/strided-dispatch-by":"@stdlib/strided/dispatch-by","@stdlib/math-strided-special-floor":"@stdlib/math/strided/special/floor","@stdlib/math-strided-special-inv":"@stdlib/math/strided/special/inv","@stdlib/math-strided-ops-mul":"@stdlib/math/strided/ops/mul","@stdlib/math-strided-ops-mul-by":"@stdlib/math/strided/ops/mul-by","@stdlib/math-strided-special-ramp":"@stdlib/math/strided/special/ramp","@stdlib/math-strided-special-rsqrt":"@stdlib/math/strided/special/rsqrt","@stdlib/math-strided-special-sin-by":"@stdlib/math/strided/special/sin-by","@stdlib/math-strided-special-sqrt":"@stdlib/math/strided/special/sqrt","@stdlib/math-strided-special-sqrt-by":"@stdlib/math/strided/special/sqrt-by","@stdlib/math-strided-ops-sub":"@stdlib/math/strided/ops/sub","@stdlib/math-strided-ops-sub-by":"@stdlib/math/strided/ops/sub-by","@stdlib/math-strided-special-trunc":"@stdlib/math/strided/special/trunc","@stdlib/array-to-strided-iterator":"@stdlib/array/to-strided-iterator","@stdlib/streams-node-from-strided-array":"@stdlib/streams/node/from-strided-array","@stdlib/buffer-from-string":"@stdlib/buffer/from-string","@stdlib/ndarray-sub2ind":"@stdlib/ndarray/sub2ind","@stdlib/string-substring-after":"@stdlib/string/substring-after","@stdlib/string-substring-after-last":"@stdlib/string/substring-after-last","@stdlib/string-substring-before":"@stdlib/string/substring-before","@stdlib/string-substring-before-last":"@stdlib/string/substring-before-last","@stdlib/datasets-suthaharan-multi-hop-sensor-network":"@stdlib/datasets/suthaharan-multi-hop-sensor-network","@stdlib/datasets-suthaharan-single-hop-sensor-network":"@stdlib/datasets/suthaharan-single-hop-sensor-network","@stdlib/symbol-ctor":"@stdlib/symbol/ctor","@stdlib/utils-tabulate":"@stdlib/utils/tabulate","@stdlib/utils-tabulate-by":"@stdlib/utils/tabulate-by","@stdlib/utils-async-tabulate-by":"@stdlib/utils/async/tabulate-by","@stdlib/function-thunk":"@stdlib/function/thunk","@stdlib/time-tic":"@stdlib/time/tic","@stdlib/utils-timeit":"@stdlib/utils/timeit","@stdlib/os-tmpdir":"@stdlib/os/tmpdir","@stdlib/time-toc":"@stdlib/time/toc","@stdlib/nlp-tokenize":"@stdlib/nlp/tokenize","@stdlib/streams-node-transform":"@stdlib/streams/node/transform","@stdlib/string-trim":"@stdlib/string/trim","@stdlib/string-truncate":"@stdlib/string/truncate","@stdlib/string-truncate-middle":"@stdlib/string/truncate-middle","@stdlib/utils-try-catch":"@stdlib/utils/try-catch","@stdlib/utils-async-try-catch":"@stdlib/utils/async/try-catch","@stdlib/utils-try-function":"@stdlib/utils/try-function","@stdlib/utils-try-require":"@stdlib/utils/try-require","@stdlib/utils-try-then":"@stdlib/utils/try-then","@stdlib/utils-async-try-then":"@stdlib/utils/async/try-then","@stdlib/stats-ttest":"@stdlib/stats/ttest","@stdlib/stats-ttest2":"@stdlib/stats/ttest2","@stdlib/constants-float64-two-pi":"@stdlib/constants/float64/two-pi","@stdlib/array-typed":"@stdlib/array/typed","@stdlib/array-to-json":"@stdlib/array/to-json","@stdlib/array-typed-ctors":"@stdlib/array/typed-ctors","@stdlib/array-typed-dtypes":"@stdlib/array/typed-dtypes","@stdlib/array-pool":"@stdlib/array/pool","@stdlib/utils-type-max":"@stdlib/utils/type-max","@stdlib/utils-type-min":"@stdlib/utils/type-min","@stdlib/utils-type-of":"@stdlib/utils/type-of","@stdlib/constants-uint8-max":"@stdlib/constants/uint8/max","@stdlib/constants-uint8-num-bytes":"@stdlib/constants/uint8/num-bytes","@stdlib/array-uint8":"@stdlib/array/uint8","@stdlib/array-uint8c":"@stdlib/array/uint8c","@stdlib/constants-uint16-max":"@stdlib/constants/uint16/max","@stdlib/constants-uint16-num-bytes":"@stdlib/constants/uint16/num-bytes","@stdlib/array-uint16":"@stdlib/array/uint16","@stdlib/constants-uint32-max":"@stdlib/constants/uint32/max","@stdlib/constants-uint32-num-bytes":"@stdlib/constants/uint32/num-bytes","@stdlib/array-uint32":"@stdlib/array/uint32","@stdlib/process-umask":"@stdlib/process/umask","@stdlib/string-uncapitalize":"@stdlib/string/uncapitalize","@stdlib/utils-uncapitalize-keys":"@stdlib/utils/uncapitalize-keys","@stdlib/utils-uncurry":"@stdlib/utils/uncurry","@stdlib/utils-uncurry-right":"@stdlib/utils/uncurry-right","@stdlib/constants-unicode-max":"@stdlib/constants/unicode/max","@stdlib/constants-unicode-max-bmp":"@stdlib/constants/unicode/max-bmp","@stdlib/plot-sparklines-unicode-column":"@stdlib/plot/sparklines/unicode/column","@stdlib/plot-sparklines-unicode-line":"@stdlib/plot/sparklines/unicode/line","@stdlib/plot-sparklines-unicode":"@stdlib/plot/sparklines/unicode","@stdlib/plot-sparklines-unicode-tristate":"@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot-sparklines-unicode-up-down":"@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot-sparklines-unicode-win-loss":"@stdlib/plot/sparklines/unicode/win-loss","@stdlib/fs-unlink":"@stdlib/fs/unlink","@stdlib/utils-unshift":"@stdlib/utils/unshift","@stdlib/utils-until":"@stdlib/utils/until","@stdlib/utils-async-until":"@stdlib/utils/async/until","@stdlib/utils-until-each":"@stdlib/utils/until-each","@stdlib/utils-until-each-right":"@stdlib/utils/until-each-right","@stdlib/utils-unzip":"@stdlib/utils/unzip","@stdlib/string-uppercase":"@stdlib/string/uppercase","@stdlib/utils-uppercase-keys":"@stdlib/utils/uppercase-keys","@stdlib/datasets-us-states-abbr":"@stdlib/datasets/us-states-abbr","@stdlib/datasets-us-states-capitals":"@stdlib/datasets/us-states-capitals","@stdlib/datasets-us-states-capitals-names":"@stdlib/datasets/us-states-capitals-names","@stdlib/datasets-us-states-names":"@stdlib/datasets/us-states-names","@stdlib/datasets-us-states-names-capitals":"@stdlib/datasets/us-states-names-capitals","@stdlib/string-utf16-to-utf8-array":"@stdlib/string/utf16-to-utf8-array","@stdlib/stats-vartest":"@stdlib/stats/vartest","@stdlib/utils-async-series-waterfall":"@stdlib/utils/async/series-waterfall","@stdlib/wasm-memory":"@stdlib/wasm/memory","@stdlib/utils-async-while":"@stdlib/utils/async/while","@stdlib/utils-while-each":"@stdlib/utils/while-each","@stdlib/utils-while-each-right":"@stdlib/utils/while-each-right","@stdlib/utils-while":"@stdlib/utils/while","@stdlib/stats-wilcoxon":"@stdlib/stats/wilcoxon","@stdlib/utils-writable-properties":"@stdlib/utils/writable-properties","@stdlib/utils-writable-properties-in":"@stdlib/utils/writable-properties-in","@stdlib/utils-writable-property-names":"@stdlib/utils/writable-property-names","@stdlib/utils-writable-property-names-in":"@stdlib/utils/writable-property-names-in","@stdlib/utils-writable-property-symbols":"@stdlib/utils/writable-property-symbols","@stdlib/utils-writable-property-symbols-in":"@stdlib/utils/writable-property-symbols-in","@stdlib/fs-write-file":"@stdlib/fs/write-file","@stdlib/utils-zip":"@stdlib/utils/zip","@stdlib/stats-ztest":"@stdlib/stats/ztest","@stdlib/stats-ztest2":"@stdlib/stats/ztest2"} +{"@stdlib/math-special-abs":"@stdlib/math/special/abs","@stdlib/array-cartesian-power":"@stdlib/array/cartesian-power","@stdlib/array-cartesian-product":"@stdlib/array/cartesian-product","@stdlib/array-cartesian-square":"@stdlib/array/cartesian-square","@stdlib/string-acronym":"@stdlib/string/acronym","@stdlib/array-empty":"@stdlib/array/empty","@stdlib/array-empty-like":"@stdlib/array/empty-like","@stdlib/datasets-afinn-96":"@stdlib/datasets/afinn-96","@stdlib/datasets-afinn-111":"@stdlib/datasets/afinn-111","@stdlib/array-full":"@stdlib/array/full","@stdlib/array-full-like":"@stdlib/array/full-like","@stdlib/namespace-alias2pkg":"@stdlib/namespace/alias2pkg","@stdlib/namespace-alias2related":"@stdlib/namespace/alias2related","@stdlib/namespace-alias2standalone":"@stdlib/namespace/alias2standalone","@stdlib/namespace-aliases":"@stdlib/namespace/aliases","@stdlib/buffer-alloc-unsafe":"@stdlib/buffer/alloc-unsafe","@stdlib/array-mskfilter":"@stdlib/array/mskfilter","@stdlib/array-mskput":"@stdlib/array/mskput","@stdlib/array-mskreject":"@stdlib/array/mskreject","@stdlib/array-nans":"@stdlib/array/nans","@stdlib/array-nans-like":"@stdlib/array/nans-like","@stdlib/stats-anova1":"@stdlib/stats/anova1","@stdlib/datasets-anscombes-quartet":"@stdlib/datasets/anscombes-quartet","@stdlib/utils-any":"@stdlib/utils/any","@stdlib/utils-any-by":"@stdlib/utils/any-by","@stdlib/utils-async-any-by":"@stdlib/utils/async/any-by","@stdlib/utils-any-by-right":"@stdlib/utils/any-by-right","@stdlib/utils-async-any-by-right":"@stdlib/utils/async/any-by-right","@stdlib/utils-any-in-by":"@stdlib/utils/any-in-by","@stdlib/utils-any-own-by":"@stdlib/utils/any-own-by","@stdlib/array-ones":"@stdlib/array/ones","@stdlib/array-ones-like":"@stdlib/array/ones-like","@stdlib/array-one-to":"@stdlib/array/one-to","@stdlib/array-one-to-like":"@stdlib/array/one-to-like","@stdlib/constants-float64-apery":"@stdlib/constants/float64/apery","@stdlib/array-place":"@stdlib/array/place","@stdlib/utils-append":"@stdlib/utils/append","@stdlib/array-put":"@stdlib/array/put","@stdlib/os-arch":"@stdlib/os/arch","@stdlib/utils-argument-function":"@stdlib/utils/argument-function","@stdlib/process-argv":"@stdlib/process/argv","@stdlib/ndarray-array":"@stdlib/ndarray/array","@stdlib/buffer-from-array":"@stdlib/buffer/from-array","@stdlib/array-to-fancy":"@stdlib/array/to-fancy","@stdlib/array-to-iterator":"@stdlib/array/to-iterator","@stdlib/array-to-iterator-right":"@stdlib/array/to-iterator-right","@stdlib/array-buffer":"@stdlib/array/buffer","@stdlib/buffer-from-arraybuffer":"@stdlib/buffer/from-arraybuffer","@stdlib/array-ctors":"@stdlib/array/ctors","@stdlib/array-dtype":"@stdlib/array/dtype","@stdlib/array-dtypes":"@stdlib/array/dtypes","@stdlib/array-index":"@stdlib/array/index","@stdlib/array-min-dtype":"@stdlib/array/min-dtype","@stdlib/array-mostly-safe-casts":"@stdlib/array/mostly-safe-casts","@stdlib/array-next-dtype":"@stdlib/array/next-dtype","@stdlib/array-promotion-rules":"@stdlib/array/promotion-rules","@stdlib/array-safe-casts":"@stdlib/array/safe-casts","@stdlib/array-same-kind-casts":"@stdlib/array/same-kind-casts","@stdlib/array-shape":"@stdlib/array/shape","@stdlib/streams-node-from-array":"@stdlib/streams/node/from-array","@stdlib/array-to-view-iterator":"@stdlib/array/to-view-iterator","@stdlib/array-to-view-iterator-right":"@stdlib/array/to-view-iterator-right","@stdlib/array-slice":"@stdlib/array/slice","@stdlib/symbol-async-iterator":"@stdlib/symbol/async-iterator","@stdlib/array-take":"@stdlib/array/take","@stdlib/array-zeros":"@stdlib/array/zeros","@stdlib/array-zeros-like":"@stdlib/array/zeros-like","@stdlib/array-zero-to":"@stdlib/array/zero-to","@stdlib/array-zero-to-like":"@stdlib/array/zero-to-like","@stdlib/stats-bartlett-test":"@stdlib/stats/bartlett-test","@stdlib/math-base-special-abs":"@stdlib/math/base/special/abs","@stdlib/math-base-special-abs2":"@stdlib/math/base/special/abs2","@stdlib/math-base-special-abs2f":"@stdlib/math/base/special/abs2f","@stdlib/math-base-utils-absolute-difference":"@stdlib/math/base/utils/absolute-difference","@stdlib/math-base-special-absf":"@stdlib/math/base/special/absf","@stdlib/array-base-cartesian-power":"@stdlib/array/base/cartesian-power","@stdlib/array-base-cartesian-product":"@stdlib/array/base/cartesian-product","@stdlib/array-base-cartesian-square":"@stdlib/array/base/cartesian-square","@stdlib/math-base-special-acos":"@stdlib/math/base/special/acos","@stdlib/math-base-special-acosd":"@stdlib/math/base/special/acosd","@stdlib/math-base-special-acosf":"@stdlib/math/base/special/acosf","@stdlib/math-base-special-acosh":"@stdlib/math/base/special/acosh","@stdlib/math-base-special-acot":"@stdlib/math/base/special/acot","@stdlib/math-base-special-acotd":"@stdlib/math/base/special/acotd","@stdlib/math-base-special-acotf":"@stdlib/math/base/special/acotf","@stdlib/math-base-special-acoth":"@stdlib/math/base/special/acoth","@stdlib/math-base-special-acovercos":"@stdlib/math/base/special/acovercos","@stdlib/math-base-special-acoversin":"@stdlib/math/base/special/acoversin","@stdlib/math-base-special-acsc":"@stdlib/math/base/special/acsc","@stdlib/math-base-special-acscd":"@stdlib/math/base/special/acscd","@stdlib/math-base-special-acscdf":"@stdlib/math/base/special/acscdf","@stdlib/math-base-special-acscf":"@stdlib/math/base/special/acscf","@stdlib/math-base-special-acsch":"@stdlib/math/base/special/acsch","@stdlib/number-float64-base-add":"@stdlib/number/float64/base/add","@stdlib/number-float64-base-add3":"@stdlib/number/float64/base/add3","@stdlib/number-float64-base-add4":"@stdlib/number/float64/base/add4","@stdlib/number-float64-base-add5":"@stdlib/number/float64/base/add5","@stdlib/number-float32-base-add":"@stdlib/number/float32/base/add","@stdlib/array-base-filled":"@stdlib/array/base/filled","@stdlib/array-base-filled2d":"@stdlib/array/base/filled2d","@stdlib/array-base-filled2d-by":"@stdlib/array/base/filled2d-by","@stdlib/array-base-filled3d":"@stdlib/array/base/filled3d","@stdlib/array-base-filled3d-by":"@stdlib/array/base/filled3d-by","@stdlib/array-base-filled4d":"@stdlib/array/base/filled4d","@stdlib/array-base-filled4d-by":"@stdlib/array/base/filled4d-by","@stdlib/array-base-filled5d":"@stdlib/array/base/filled5d","@stdlib/array-base-filled5d-by":"@stdlib/array/base/filled5d-by","@stdlib/array-base-filled-by":"@stdlib/array/base/filled-by","@stdlib/array-base-fillednd":"@stdlib/array/base/fillednd","@stdlib/array-base-fillednd-by":"@stdlib/array/base/fillednd-by","@stdlib/array-base-filter":"@stdlib/array/base/filter","@stdlib/array-base-first":"@stdlib/array/base/first","@stdlib/array-base-flatten":"@stdlib/array/base/flatten","@stdlib/array-base-flatten2d":"@stdlib/array/base/flatten2d","@stdlib/array-base-flatten2d-by":"@stdlib/array/base/flatten2d-by","@stdlib/array-base-flatten3d":"@stdlib/array/base/flatten3d","@stdlib/array-base-flatten3d-by":"@stdlib/array/base/flatten3d-by","@stdlib/array-base-flatten4d":"@stdlib/array/base/flatten4d","@stdlib/array-base-flatten4d-by":"@stdlib/array/base/flatten4d-by","@stdlib/array-base-flatten5d":"@stdlib/array/base/flatten5d","@stdlib/array-base-flatten5d-by":"@stdlib/array/base/flatten5d-by","@stdlib/array-base-flatten-by":"@stdlib/array/base/flatten-by","@stdlib/array-base-fliplr2d":"@stdlib/array/base/fliplr2d","@stdlib/array-base-fliplr3d":"@stdlib/array/base/fliplr3d","@stdlib/array-base-fliplr4d":"@stdlib/array/base/fliplr4d","@stdlib/array-base-fliplr5d":"@stdlib/array/base/fliplr5d","@stdlib/array-base-flipud2d":"@stdlib/array/base/flipud2d","@stdlib/array-base-flipud3d":"@stdlib/array/base/flipud3d","@stdlib/array-base-flipud4d":"@stdlib/array/base/flipud4d","@stdlib/array-base-flipud5d":"@stdlib/array/base/flipud5d","@stdlib/math-base-special-ahavercos":"@stdlib/math/base/special/ahavercos","@stdlib/math-base-special-ahaversin":"@stdlib/math/base/special/ahaversin","@stdlib/string-base-altcase":"@stdlib/string/base/altcase","@stdlib/array-base-ones":"@stdlib/array/base/ones","@stdlib/array-base-ones2d":"@stdlib/array/base/ones2d","@stdlib/array-base-ones3d":"@stdlib/array/base/ones3d","@stdlib/array-base-ones4d":"@stdlib/array/base/ones4d","@stdlib/array-base-ones5d":"@stdlib/array/base/ones5d","@stdlib/array-base-onesnd":"@stdlib/array/base/onesnd","@stdlib/array-base-one-to":"@stdlib/array/base/one-to","@stdlib/slice-base-args2multislice":"@stdlib/slice/base/args2multislice","@stdlib/math-base-special-asec":"@stdlib/math/base/special/asec","@stdlib/math-base-special-asecd":"@stdlib/math/base/special/asecd","@stdlib/math-base-special-asecdf":"@stdlib/math/base/special/asecdf","@stdlib/math-base-special-asecf":"@stdlib/math/base/special/asecf","@stdlib/math-base-special-asech":"@stdlib/math/base/special/asech","@stdlib/math-base-special-asin":"@stdlib/math/base/special/asin","@stdlib/math-base-special-asind":"@stdlib/math/base/special/asind","@stdlib/math-base-special-asindf":"@stdlib/math/base/special/asindf","@stdlib/math-base-special-asinf":"@stdlib/math/base/special/asinf","@stdlib/math-base-special-asinh":"@stdlib/math/base/special/asinh","@stdlib/math-base-special-atan":"@stdlib/math/base/special/atan","@stdlib/math-base-special-atan2":"@stdlib/math/base/special/atan2","@stdlib/math-base-special-atand":"@stdlib/math/base/special/atand","@stdlib/math-base-special-atanf":"@stdlib/math/base/special/atanf","@stdlib/math-base-special-atanh":"@stdlib/math/base/special/atanh","@stdlib/math-base-special-avercos":"@stdlib/math/base/special/avercos","@stdlib/math-base-special-aversin":"@stdlib/math/base/special/aversin","@stdlib/array-base-zeros":"@stdlib/array/base/zeros","@stdlib/array-base-zeros2d":"@stdlib/array/base/zeros2d","@stdlib/array-base-zeros3d":"@stdlib/array/base/zeros3d","@stdlib/array-base-zeros4d":"@stdlib/array/base/zeros4d","@stdlib/array-base-zeros5d":"@stdlib/array/base/zeros5d","@stdlib/array-base-zerosnd":"@stdlib/array/base/zerosnd","@stdlib/array-base-zero-to":"@stdlib/array/base/zero-to","@stdlib/math-base-special-bernoulli":"@stdlib/math/base/special/bernoulli","@stdlib/math-base-special-besselj0":"@stdlib/math/base/special/besselj0","@stdlib/math-base-special-besselj1":"@stdlib/math/base/special/besselj1","@stdlib/math-base-special-bessely0":"@stdlib/math/base/special/bessely0","@stdlib/math-base-special-bessely1":"@stdlib/math/base/special/bessely1","@stdlib/math-base-special-beta":"@stdlib/math/base/special/beta","@stdlib/math-base-special-betainc":"@stdlib/math/base/special/betainc","@stdlib/math-base-special-betaincinv":"@stdlib/math/base/special/betaincinv","@stdlib/math-base-special-betaln":"@stdlib/math/base/special/betaln","@stdlib/math-base-special-binet":"@stdlib/math/base/special/binet","@stdlib/math-base-special-binomcoef":"@stdlib/math/base/special/binomcoef","@stdlib/math-base-special-binomcoefln":"@stdlib/math/base/special/binomcoefln","@stdlib/math-base-special-boxcox":"@stdlib/math/base/special/boxcox","@stdlib/math-base-special-boxcox1p":"@stdlib/math/base/special/boxcox1p","@stdlib/math-base-special-boxcox1pinv":"@stdlib/math/base/special/boxcox1pinv","@stdlib/math-base-special-boxcoxinv":"@stdlib/math/base/special/boxcoxinv","@stdlib/math-base-special-cabs":"@stdlib/math/base/special/cabs","@stdlib/math-base-special-cabs2":"@stdlib/math/base/special/cabs2","@stdlib/math-base-special-cabs2f":"@stdlib/math/base/special/cabs2f","@stdlib/math-base-special-cabsf":"@stdlib/math/base/special/cabsf","@stdlib/complex-float64-base-add":"@stdlib/complex/float64/base/add","@stdlib/complex-float32-base-add":"@stdlib/complex/float32/base/add","@stdlib/string-base-camelcase":"@stdlib/string/base/camelcase","@stdlib/string-base-capitalize":"@stdlib/string/base/capitalize","@stdlib/math-base-special-cbrt":"@stdlib/math/base/special/cbrt","@stdlib/math-base-special-cbrtf":"@stdlib/math/base/special/cbrtf","@stdlib/math-base-special-cceil":"@stdlib/math/base/special/cceil","@stdlib/math-base-special-cceilf":"@stdlib/math/base/special/cceilf","@stdlib/math-base-special-cceiln":"@stdlib/math/base/special/cceiln","@stdlib/math-base-special-ccis":"@stdlib/math/base/special/ccis","@stdlib/math-base-ops-cdiv":"@stdlib/math/base/ops/cdiv","@stdlib/math-base-special-ceil":"@stdlib/math/base/special/ceil","@stdlib/math-base-special-ceil2":"@stdlib/math/base/special/ceil2","@stdlib/math-base-special-ceil10":"@stdlib/math/base/special/ceil10","@stdlib/math-base-special-ceilb":"@stdlib/math/base/special/ceilb","@stdlib/math-base-special-ceilf":"@stdlib/math/base/special/ceilf","@stdlib/math-base-special-ceiln":"@stdlib/math/base/special/ceiln","@stdlib/math-base-special-ceilsd":"@stdlib/math/base/special/ceilsd","@stdlib/math-base-special-cexp":"@stdlib/math/base/special/cexp","@stdlib/math-base-special-cflipsign":"@stdlib/math/base/special/cflipsign","@stdlib/math-base-special-cflipsignf":"@stdlib/math/base/special/cflipsignf","@stdlib/math-base-special-cfloor":"@stdlib/math/base/special/cfloor","@stdlib/math-base-special-cfloorn":"@stdlib/math/base/special/cfloorn","@stdlib/math-base-special-cidentity":"@stdlib/math/base/special/cidentity","@stdlib/math-base-special-cidentityf":"@stdlib/math/base/special/cidentityf","@stdlib/math-base-special-cinv":"@stdlib/math/base/special/cinv","@stdlib/math-base-special-clamp":"@stdlib/math/base/special/clamp","@stdlib/math-base-special-clampf":"@stdlib/math/base/special/clampf","@stdlib/complex-float64-base-mul":"@stdlib/complex/float64/base/mul","@stdlib/complex-float32-base-mul":"@stdlib/complex/float32/base/mul","@stdlib/math-base-ops-cneg":"@stdlib/math/base/ops/cneg","@stdlib/math-base-ops-cnegf":"@stdlib/math/base/ops/cnegf","@stdlib/string-base-code-point-at":"@stdlib/string/base/code-point-at","@stdlib/string-base-constantcase":"@stdlib/string/base/constantcase","@stdlib/math-base-tools-continued-fraction":"@stdlib/math/base/tools/continued-fraction","@stdlib/math-base-special-copysign":"@stdlib/math/base/special/copysign","@stdlib/math-base-special-copysignf":"@stdlib/math/base/special/copysignf","@stdlib/math-base-special-cos":"@stdlib/math/base/special/cos","@stdlib/math-base-special-cosd":"@stdlib/math/base/special/cosd","@stdlib/math-base-special-cosh":"@stdlib/math/base/special/cosh","@stdlib/math-base-special-cosm1":"@stdlib/math/base/special/cosm1","@stdlib/math-base-special-cospi":"@stdlib/math/base/special/cospi","@stdlib/math-base-special-cot":"@stdlib/math/base/special/cot","@stdlib/math-base-special-cotd":"@stdlib/math/base/special/cotd","@stdlib/math-base-special-coth":"@stdlib/math/base/special/coth","@stdlib/math-base-special-covercos":"@stdlib/math/base/special/covercos","@stdlib/math-base-special-coversin":"@stdlib/math/base/special/coversin","@stdlib/math-base-special-cphase":"@stdlib/math/base/special/cphase","@stdlib/math-base-special-cpolar":"@stdlib/math/base/special/cpolar","@stdlib/math-base-special-cround":"@stdlib/math/base/special/cround","@stdlib/math-base-special-croundn":"@stdlib/math/base/special/croundn","@stdlib/math-base-special-csc":"@stdlib/math/base/special/csc","@stdlib/math-base-special-cscd":"@stdlib/math/base/special/cscd","@stdlib/math-base-special-csch":"@stdlib/math/base/special/csch","@stdlib/math-base-special-csignum":"@stdlib/math/base/special/csignum","@stdlib/math-base-ops-csub":"@stdlib/math/base/ops/csub","@stdlib/math-base-ops-csubf":"@stdlib/math/base/ops/csubf","@stdlib/math-base-special-deg2rad":"@stdlib/math/base/special/deg2rad","@stdlib/math-base-special-deg2radf":"@stdlib/math/base/special/deg2radf","@stdlib/math-base-special-digamma":"@stdlib/math/base/special/digamma","@stdlib/math-base-special-dirac-delta":"@stdlib/math/base/special/dirac-delta","@stdlib/number-float64-base-div":"@stdlib/number/float64/base/div","@stdlib/number-float32-base-div":"@stdlib/number/float32/base/div","@stdlib/string-base-dotcase":"@stdlib/string/base/dotcase","@stdlib/stats-base-dists-arcsine-ctor":"@stdlib/stats/base/dists/arcsine/ctor","@stdlib/stats-base-dists-arcsine-cdf":"@stdlib/stats/base/dists/arcsine/cdf","@stdlib/stats-base-dists-arcsine-entropy":"@stdlib/stats/base/dists/arcsine/entropy","@stdlib/stats-base-dists-arcsine-kurtosis":"@stdlib/stats/base/dists/arcsine/kurtosis","@stdlib/stats-base-dists-arcsine-logcdf":"@stdlib/stats/base/dists/arcsine/logcdf","@stdlib/stats-base-dists-arcsine-logpdf":"@stdlib/stats/base/dists/arcsine/logpdf","@stdlib/stats-base-dists-arcsine-mean":"@stdlib/stats/base/dists/arcsine/mean","@stdlib/stats-base-dists-arcsine-median":"@stdlib/stats/base/dists/arcsine/median","@stdlib/stats-base-dists-arcsine-mode":"@stdlib/stats/base/dists/arcsine/mode","@stdlib/stats-base-dists-arcsine-pdf":"@stdlib/stats/base/dists/arcsine/pdf","@stdlib/stats-base-dists-arcsine-quantile":"@stdlib/stats/base/dists/arcsine/quantile","@stdlib/stats-base-dists-arcsine-skewness":"@stdlib/stats/base/dists/arcsine/skewness","@stdlib/stats-base-dists-arcsine-stdev":"@stdlib/stats/base/dists/arcsine/stdev","@stdlib/stats-base-dists-arcsine-variance":"@stdlib/stats/base/dists/arcsine/variance","@stdlib/stats-base-dists-bernoulli-ctor":"@stdlib/stats/base/dists/bernoulli/ctor","@stdlib/stats-base-dists-bernoulli-cdf":"@stdlib/stats/base/dists/bernoulli/cdf","@stdlib/stats-base-dists-bernoulli-entropy":"@stdlib/stats/base/dists/bernoulli/entropy","@stdlib/stats-base-dists-bernoulli-kurtosis":"@stdlib/stats/base/dists/bernoulli/kurtosis","@stdlib/stats-base-dists-bernoulli-mean":"@stdlib/stats/base/dists/bernoulli/mean","@stdlib/stats-base-dists-bernoulli-median":"@stdlib/stats/base/dists/bernoulli/median","@stdlib/stats-base-dists-bernoulli-mgf":"@stdlib/stats/base/dists/bernoulli/mgf","@stdlib/stats-base-dists-bernoulli-mode":"@stdlib/stats/base/dists/bernoulli/mode","@stdlib/stats-base-dists-bernoulli-pmf":"@stdlib/stats/base/dists/bernoulli/pmf","@stdlib/stats-base-dists-bernoulli-quantile":"@stdlib/stats/base/dists/bernoulli/quantile","@stdlib/stats-base-dists-bernoulli-skewness":"@stdlib/stats/base/dists/bernoulli/skewness","@stdlib/stats-base-dists-bernoulli-stdev":"@stdlib/stats/base/dists/bernoulli/stdev","@stdlib/stats-base-dists-bernoulli-variance":"@stdlib/stats/base/dists/bernoulli/variance","@stdlib/stats-base-dists-beta-ctor":"@stdlib/stats/base/dists/beta/ctor","@stdlib/stats-base-dists-beta-cdf":"@stdlib/stats/base/dists/beta/cdf","@stdlib/stats-base-dists-beta-entropy":"@stdlib/stats/base/dists/beta/entropy","@stdlib/stats-base-dists-beta-kurtosis":"@stdlib/stats/base/dists/beta/kurtosis","@stdlib/stats-base-dists-beta-logcdf":"@stdlib/stats/base/dists/beta/logcdf","@stdlib/stats-base-dists-beta-logpdf":"@stdlib/stats/base/dists/beta/logpdf","@stdlib/stats-base-dists-beta-mean":"@stdlib/stats/base/dists/beta/mean","@stdlib/stats-base-dists-beta-median":"@stdlib/stats/base/dists/beta/median","@stdlib/stats-base-dists-beta-mgf":"@stdlib/stats/base/dists/beta/mgf","@stdlib/stats-base-dists-beta-mode":"@stdlib/stats/base/dists/beta/mode","@stdlib/stats-base-dists-beta-pdf":"@stdlib/stats/base/dists/beta/pdf","@stdlib/stats-base-dists-beta-quantile":"@stdlib/stats/base/dists/beta/quantile","@stdlib/stats-base-dists-beta-skewness":"@stdlib/stats/base/dists/beta/skewness","@stdlib/stats-base-dists-beta-stdev":"@stdlib/stats/base/dists/beta/stdev","@stdlib/stats-base-dists-beta-variance":"@stdlib/stats/base/dists/beta/variance","@stdlib/stats-base-dists-betaprime-ctor":"@stdlib/stats/base/dists/betaprime/ctor","@stdlib/stats-base-dists-betaprime-cdf":"@stdlib/stats/base/dists/betaprime/cdf","@stdlib/stats-base-dists-betaprime-kurtosis":"@stdlib/stats/base/dists/betaprime/kurtosis","@stdlib/stats-base-dists-betaprime-logcdf":"@stdlib/stats/base/dists/betaprime/logcdf","@stdlib/stats-base-dists-betaprime-logpdf":"@stdlib/stats/base/dists/betaprime/logpdf","@stdlib/stats-base-dists-betaprime-mean":"@stdlib/stats/base/dists/betaprime/mean","@stdlib/stats-base-dists-betaprime-mode":"@stdlib/stats/base/dists/betaprime/mode","@stdlib/stats-base-dists-betaprime-pdf":"@stdlib/stats/base/dists/betaprime/pdf","@stdlib/stats-base-dists-betaprime-quantile":"@stdlib/stats/base/dists/betaprime/quantile","@stdlib/stats-base-dists-betaprime-skewness":"@stdlib/stats/base/dists/betaprime/skewness","@stdlib/stats-base-dists-betaprime-stdev":"@stdlib/stats/base/dists/betaprime/stdev","@stdlib/stats-base-dists-betaprime-variance":"@stdlib/stats/base/dists/betaprime/variance","@stdlib/stats-base-dists-binomial-ctor":"@stdlib/stats/base/dists/binomial/ctor","@stdlib/stats-base-dists-binomial-cdf":"@stdlib/stats/base/dists/binomial/cdf","@stdlib/stats-base-dists-binomial-entropy":"@stdlib/stats/base/dists/binomial/entropy","@stdlib/stats-base-dists-binomial-kurtosis":"@stdlib/stats/base/dists/binomial/kurtosis","@stdlib/stats-base-dists-binomial-logpmf":"@stdlib/stats/base/dists/binomial/logpmf","@stdlib/stats-base-dists-binomial-mean":"@stdlib/stats/base/dists/binomial/mean","@stdlib/stats-base-dists-binomial-median":"@stdlib/stats/base/dists/binomial/median","@stdlib/stats-base-dists-binomial-mgf":"@stdlib/stats/base/dists/binomial/mgf","@stdlib/stats-base-dists-binomial-mode":"@stdlib/stats/base/dists/binomial/mode","@stdlib/stats-base-dists-binomial-pmf":"@stdlib/stats/base/dists/binomial/pmf","@stdlib/stats-base-dists-binomial-quantile":"@stdlib/stats/base/dists/binomial/quantile","@stdlib/stats-base-dists-binomial-skewness":"@stdlib/stats/base/dists/binomial/skewness","@stdlib/stats-base-dists-binomial-stdev":"@stdlib/stats/base/dists/binomial/stdev","@stdlib/stats-base-dists-binomial-variance":"@stdlib/stats/base/dists/binomial/variance","@stdlib/stats-base-dists-cauchy-ctor":"@stdlib/stats/base/dists/cauchy/ctor","@stdlib/stats-base-dists-cauchy-cdf":"@stdlib/stats/base/dists/cauchy/cdf","@stdlib/stats-base-dists-cauchy-entropy":"@stdlib/stats/base/dists/cauchy/entropy","@stdlib/stats-base-dists-cauchy-logcdf":"@stdlib/stats/base/dists/cauchy/logcdf","@stdlib/stats-base-dists-cauchy-logpdf":"@stdlib/stats/base/dists/cauchy/logpdf","@stdlib/stats-base-dists-cauchy-median":"@stdlib/stats/base/dists/cauchy/median","@stdlib/stats-base-dists-cauchy-mode":"@stdlib/stats/base/dists/cauchy/mode","@stdlib/stats-base-dists-cauchy-pdf":"@stdlib/stats/base/dists/cauchy/pdf","@stdlib/stats-base-dists-cauchy-quantile":"@stdlib/stats/base/dists/cauchy/quantile","@stdlib/stats-base-dists-chi-cdf":"@stdlib/stats/base/dists/chi/cdf","@stdlib/stats-base-dists-chi-ctor":"@stdlib/stats/base/dists/chi/ctor","@stdlib/stats-base-dists-chi-entropy":"@stdlib/stats/base/dists/chi/entropy","@stdlib/stats-base-dists-chi-kurtosis":"@stdlib/stats/base/dists/chi/kurtosis","@stdlib/stats-base-dists-chi-logpdf":"@stdlib/stats/base/dists/chi/logpdf","@stdlib/stats-base-dists-chi-mean":"@stdlib/stats/base/dists/chi/mean","@stdlib/stats-base-dists-chi-mode":"@stdlib/stats/base/dists/chi/mode","@stdlib/stats-base-dists-chi-pdf":"@stdlib/stats/base/dists/chi/pdf","@stdlib/stats-base-dists-chi-quantile":"@stdlib/stats/base/dists/chi/quantile","@stdlib/stats-base-dists-chi-skewness":"@stdlib/stats/base/dists/chi/skewness","@stdlib/stats-base-dists-chi-stdev":"@stdlib/stats/base/dists/chi/stdev","@stdlib/stats-base-dists-chi-variance":"@stdlib/stats/base/dists/chi/variance","@stdlib/stats-base-dists-chisquare-cdf":"@stdlib/stats/base/dists/chisquare/cdf","@stdlib/stats-base-dists-chisquare-ctor":"@stdlib/stats/base/dists/chisquare/ctor","@stdlib/stats-base-dists-chisquare-entropy":"@stdlib/stats/base/dists/chisquare/entropy","@stdlib/stats-base-dists-chisquare-kurtosis":"@stdlib/stats/base/dists/chisquare/kurtosis","@stdlib/stats-base-dists-chisquare-logpdf":"@stdlib/stats/base/dists/chisquare/logpdf","@stdlib/stats-base-dists-chisquare-mean":"@stdlib/stats/base/dists/chisquare/mean","@stdlib/stats-base-dists-chisquare-median":"@stdlib/stats/base/dists/chisquare/median","@stdlib/stats-base-dists-chisquare-mgf":"@stdlib/stats/base/dists/chisquare/mgf","@stdlib/stats-base-dists-chisquare-mode":"@stdlib/stats/base/dists/chisquare/mode","@stdlib/stats-base-dists-chisquare-pdf":"@stdlib/stats/base/dists/chisquare/pdf","@stdlib/stats-base-dists-chisquare-quantile":"@stdlib/stats/base/dists/chisquare/quantile","@stdlib/stats-base-dists-chisquare-skewness":"@stdlib/stats/base/dists/chisquare/skewness","@stdlib/stats-base-dists-chisquare-stdev":"@stdlib/stats/base/dists/chisquare/stdev","@stdlib/stats-base-dists-chisquare-variance":"@stdlib/stats/base/dists/chisquare/variance","@stdlib/stats-base-dists-cosine-cdf":"@stdlib/stats/base/dists/cosine/cdf","@stdlib/stats-base-dists-cosine-ctor":"@stdlib/stats/base/dists/cosine/ctor","@stdlib/stats-base-dists-cosine-kurtosis":"@stdlib/stats/base/dists/cosine/kurtosis","@stdlib/stats-base-dists-cosine-logcdf":"@stdlib/stats/base/dists/cosine/logcdf","@stdlib/stats-base-dists-cosine-logpdf":"@stdlib/stats/base/dists/cosine/logpdf","@stdlib/stats-base-dists-cosine-mean":"@stdlib/stats/base/dists/cosine/mean","@stdlib/stats-base-dists-cosine-median":"@stdlib/stats/base/dists/cosine/median","@stdlib/stats-base-dists-cosine-mgf":"@stdlib/stats/base/dists/cosine/mgf","@stdlib/stats-base-dists-cosine-mode":"@stdlib/stats/base/dists/cosine/mode","@stdlib/stats-base-dists-cosine-pdf":"@stdlib/stats/base/dists/cosine/pdf","@stdlib/stats-base-dists-cosine-quantile":"@stdlib/stats/base/dists/cosine/quantile","@stdlib/stats-base-dists-cosine-skewness":"@stdlib/stats/base/dists/cosine/skewness","@stdlib/stats-base-dists-cosine-stdev":"@stdlib/stats/base/dists/cosine/stdev","@stdlib/stats-base-dists-cosine-variance":"@stdlib/stats/base/dists/cosine/variance","@stdlib/stats-base-dists-degenerate-cdf":"@stdlib/stats/base/dists/degenerate/cdf","@stdlib/stats-base-dists-degenerate-ctor":"@stdlib/stats/base/dists/degenerate/ctor","@stdlib/stats-base-dists-degenerate-entropy":"@stdlib/stats/base/dists/degenerate/entropy","@stdlib/stats-base-dists-degenerate-logcdf":"@stdlib/stats/base/dists/degenerate/logcdf","@stdlib/stats-base-dists-degenerate-logpdf":"@stdlib/stats/base/dists/degenerate/logpdf","@stdlib/stats-base-dists-degenerate-logpmf":"@stdlib/stats/base/dists/degenerate/logpmf","@stdlib/stats-base-dists-degenerate-mean":"@stdlib/stats/base/dists/degenerate/mean","@stdlib/stats-base-dists-degenerate-median":"@stdlib/stats/base/dists/degenerate/median","@stdlib/stats-base-dists-degenerate-mgf":"@stdlib/stats/base/dists/degenerate/mgf","@stdlib/stats-base-dists-degenerate-mode":"@stdlib/stats/base/dists/degenerate/mode","@stdlib/stats-base-dists-degenerate-pdf":"@stdlib/stats/base/dists/degenerate/pdf","@stdlib/stats-base-dists-degenerate-pmf":"@stdlib/stats/base/dists/degenerate/pmf","@stdlib/stats-base-dists-degenerate-quantile":"@stdlib/stats/base/dists/degenerate/quantile","@stdlib/stats-base-dists-degenerate-stdev":"@stdlib/stats/base/dists/degenerate/stdev","@stdlib/stats-base-dists-degenerate-variance":"@stdlib/stats/base/dists/degenerate/variance","@stdlib/stats-base-dists-discrete-uniform-cdf":"@stdlib/stats/base/dists/discrete-uniform/cdf","@stdlib/stats-base-dists-discrete-uniform-ctor":"@stdlib/stats/base/dists/discrete-uniform/ctor","@stdlib/stats-base-dists-discrete-uniform-entropy":"@stdlib/stats/base/dists/discrete-uniform/entropy","@stdlib/stats-base-dists-discrete-uniform-kurtosis":"@stdlib/stats/base/dists/discrete-uniform/kurtosis","@stdlib/stats-base-dists-discrete-uniform-logcdf":"@stdlib/stats/base/dists/discrete-uniform/logcdf","@stdlib/stats-base-dists-discrete-uniform-logpmf":"@stdlib/stats/base/dists/discrete-uniform/logpmf","@stdlib/stats-base-dists-discrete-uniform-mean":"@stdlib/stats/base/dists/discrete-uniform/mean","@stdlib/stats-base-dists-discrete-uniform-median":"@stdlib/stats/base/dists/discrete-uniform/median","@stdlib/stats-base-dists-discrete-uniform-mgf":"@stdlib/stats/base/dists/discrete-uniform/mgf","@stdlib/stats-base-dists-discrete-uniform-pmf":"@stdlib/stats/base/dists/discrete-uniform/pmf","@stdlib/stats-base-dists-discrete-uniform-quantile":"@stdlib/stats/base/dists/discrete-uniform/quantile","@stdlib/stats-base-dists-discrete-uniform-skewness":"@stdlib/stats/base/dists/discrete-uniform/skewness","@stdlib/stats-base-dists-discrete-uniform-stdev":"@stdlib/stats/base/dists/discrete-uniform/stdev","@stdlib/stats-base-dists-discrete-uniform-variance":"@stdlib/stats/base/dists/discrete-uniform/variance","@stdlib/stats-base-dists-erlang-cdf":"@stdlib/stats/base/dists/erlang/cdf","@stdlib/stats-base-dists-erlang-entropy":"@stdlib/stats/base/dists/erlang/entropy","@stdlib/stats-base-dists-erlang-ctor":"@stdlib/stats/base/dists/erlang/ctor","@stdlib/stats-base-dists-erlang-kurtosis":"@stdlib/stats/base/dists/erlang/kurtosis","@stdlib/stats-base-dists-erlang-logpdf":"@stdlib/stats/base/dists/erlang/logpdf","@stdlib/stats-base-dists-erlang-mean":"@stdlib/stats/base/dists/erlang/mean","@stdlib/stats-base-dists-erlang-mgf":"@stdlib/stats/base/dists/erlang/mgf","@stdlib/stats-base-dists-erlang-mode":"@stdlib/stats/base/dists/erlang/mode","@stdlib/stats-base-dists-erlang-pdf":"@stdlib/stats/base/dists/erlang/pdf","@stdlib/stats-base-dists-erlang-quantile":"@stdlib/stats/base/dists/erlang/quantile","@stdlib/stats-base-dists-erlang-skewness":"@stdlib/stats/base/dists/erlang/skewness","@stdlib/stats-base-dists-erlang-stdev":"@stdlib/stats/base/dists/erlang/stdev","@stdlib/stats-base-dists-erlang-variance":"@stdlib/stats/base/dists/erlang/variance","@stdlib/stats-base-dists-exponential-cdf":"@stdlib/stats/base/dists/exponential/cdf","@stdlib/stats-base-dists-exponential-entropy":"@stdlib/stats/base/dists/exponential/entropy","@stdlib/stats-base-dists-exponential-ctor":"@stdlib/stats/base/dists/exponential/ctor","@stdlib/stats-base-dists-exponential-kurtosis":"@stdlib/stats/base/dists/exponential/kurtosis","@stdlib/stats-base-dists-exponential-logcdf":"@stdlib/stats/base/dists/exponential/logcdf","@stdlib/stats-base-dists-exponential-logpdf":"@stdlib/stats/base/dists/exponential/logpdf","@stdlib/stats-base-dists-exponential-mean":"@stdlib/stats/base/dists/exponential/mean","@stdlib/stats-base-dists-exponential-median":"@stdlib/stats/base/dists/exponential/median","@stdlib/stats-base-dists-exponential-mgf":"@stdlib/stats/base/dists/exponential/mgf","@stdlib/stats-base-dists-exponential-mode":"@stdlib/stats/base/dists/exponential/mode","@stdlib/stats-base-dists-exponential-pdf":"@stdlib/stats/base/dists/exponential/pdf","@stdlib/stats-base-dists-exponential-quantile":"@stdlib/stats/base/dists/exponential/quantile","@stdlib/stats-base-dists-exponential-skewness":"@stdlib/stats/base/dists/exponential/skewness","@stdlib/stats-base-dists-exponential-stdev":"@stdlib/stats/base/dists/exponential/stdev","@stdlib/stats-base-dists-exponential-variance":"@stdlib/stats/base/dists/exponential/variance","@stdlib/stats-base-dists-f-cdf":"@stdlib/stats/base/dists/f/cdf","@stdlib/stats-base-dists-f-entropy":"@stdlib/stats/base/dists/f/entropy","@stdlib/stats-base-dists-f-ctor":"@stdlib/stats/base/dists/f/ctor","@stdlib/stats-base-dists-f-kurtosis":"@stdlib/stats/base/dists/f/kurtosis","@stdlib/stats-base-dists-f-mean":"@stdlib/stats/base/dists/f/mean","@stdlib/stats-base-dists-f-mode":"@stdlib/stats/base/dists/f/mode","@stdlib/stats-base-dists-f-pdf":"@stdlib/stats/base/dists/f/pdf","@stdlib/stats-base-dists-f-quantile":"@stdlib/stats/base/dists/f/quantile","@stdlib/stats-base-dists-f-skewness":"@stdlib/stats/base/dists/f/skewness","@stdlib/stats-base-dists-f-stdev":"@stdlib/stats/base/dists/f/stdev","@stdlib/stats-base-dists-f-variance":"@stdlib/stats/base/dists/f/variance","@stdlib/stats-base-dists-frechet-cdf":"@stdlib/stats/base/dists/frechet/cdf","@stdlib/stats-base-dists-frechet-entropy":"@stdlib/stats/base/dists/frechet/entropy","@stdlib/stats-base-dists-frechet-ctor":"@stdlib/stats/base/dists/frechet/ctor","@stdlib/stats-base-dists-frechet-kurtosis":"@stdlib/stats/base/dists/frechet/kurtosis","@stdlib/stats-base-dists-frechet-logcdf":"@stdlib/stats/base/dists/frechet/logcdf","@stdlib/stats-base-dists-frechet-logpdf":"@stdlib/stats/base/dists/frechet/logpdf","@stdlib/stats-base-dists-frechet-mean":"@stdlib/stats/base/dists/frechet/mean","@stdlib/stats-base-dists-frechet-median":"@stdlib/stats/base/dists/frechet/median","@stdlib/stats-base-dists-frechet-mode":"@stdlib/stats/base/dists/frechet/mode","@stdlib/stats-base-dists-frechet-pdf":"@stdlib/stats/base/dists/frechet/pdf","@stdlib/stats-base-dists-frechet-quantile":"@stdlib/stats/base/dists/frechet/quantile","@stdlib/stats-base-dists-frechet-skewness":"@stdlib/stats/base/dists/frechet/skewness","@stdlib/stats-base-dists-frechet-stdev":"@stdlib/stats/base/dists/frechet/stdev","@stdlib/stats-base-dists-frechet-variance":"@stdlib/stats/base/dists/frechet/variance","@stdlib/stats-base-dists-gamma-cdf":"@stdlib/stats/base/dists/gamma/cdf","@stdlib/stats-base-dists-gamma-entropy":"@stdlib/stats/base/dists/gamma/entropy","@stdlib/stats-base-dists-gamma-ctor":"@stdlib/stats/base/dists/gamma/ctor","@stdlib/stats-base-dists-gamma-kurtosis":"@stdlib/stats/base/dists/gamma/kurtosis","@stdlib/stats-base-dists-gamma-logcdf":"@stdlib/stats/base/dists/gamma/logcdf","@stdlib/stats-base-dists-gamma-logpdf":"@stdlib/stats/base/dists/gamma/logpdf","@stdlib/stats-base-dists-gamma-mean":"@stdlib/stats/base/dists/gamma/mean","@stdlib/stats-base-dists-gamma-mgf":"@stdlib/stats/base/dists/gamma/mgf","@stdlib/stats-base-dists-gamma-mode":"@stdlib/stats/base/dists/gamma/mode","@stdlib/stats-base-dists-gamma-pdf":"@stdlib/stats/base/dists/gamma/pdf","@stdlib/stats-base-dists-gamma-quantile":"@stdlib/stats/base/dists/gamma/quantile","@stdlib/stats-base-dists-gamma-skewness":"@stdlib/stats/base/dists/gamma/skewness","@stdlib/stats-base-dists-gamma-stdev":"@stdlib/stats/base/dists/gamma/stdev","@stdlib/stats-base-dists-gamma-variance":"@stdlib/stats/base/dists/gamma/variance","@stdlib/stats-base-dists-geometric-cdf":"@stdlib/stats/base/dists/geometric/cdf","@stdlib/stats-base-dists-geometric-entropy":"@stdlib/stats/base/dists/geometric/entropy","@stdlib/stats-base-dists-geometric-ctor":"@stdlib/stats/base/dists/geometric/ctor","@stdlib/stats-base-dists-geometric-kurtosis":"@stdlib/stats/base/dists/geometric/kurtosis","@stdlib/stats-base-dists-geometric-logcdf":"@stdlib/stats/base/dists/geometric/logcdf","@stdlib/stats-base-dists-geometric-logpmf":"@stdlib/stats/base/dists/geometric/logpmf","@stdlib/stats-base-dists-geometric-mean":"@stdlib/stats/base/dists/geometric/mean","@stdlib/stats-base-dists-geometric-median":"@stdlib/stats/base/dists/geometric/median","@stdlib/stats-base-dists-geometric-mgf":"@stdlib/stats/base/dists/geometric/mgf","@stdlib/stats-base-dists-geometric-mode":"@stdlib/stats/base/dists/geometric/mode","@stdlib/stats-base-dists-geometric-pmf":"@stdlib/stats/base/dists/geometric/pmf","@stdlib/stats-base-dists-geometric-quantile":"@stdlib/stats/base/dists/geometric/quantile","@stdlib/stats-base-dists-geometric-skewness":"@stdlib/stats/base/dists/geometric/skewness","@stdlib/stats-base-dists-geometric-stdev":"@stdlib/stats/base/dists/geometric/stdev","@stdlib/stats-base-dists-geometric-variance":"@stdlib/stats/base/dists/geometric/variance","@stdlib/stats-base-dists-gumbel-cdf":"@stdlib/stats/base/dists/gumbel/cdf","@stdlib/stats-base-dists-gumbel-entropy":"@stdlib/stats/base/dists/gumbel/entropy","@stdlib/stats-base-dists-gumbel-ctor":"@stdlib/stats/base/dists/gumbel/ctor","@stdlib/stats-base-dists-gumbel-kurtosis":"@stdlib/stats/base/dists/gumbel/kurtosis","@stdlib/stats-base-dists-gumbel-logcdf":"@stdlib/stats/base/dists/gumbel/logcdf","@stdlib/stats-base-dists-gumbel-logpdf":"@stdlib/stats/base/dists/gumbel/logpdf","@stdlib/stats-base-dists-gumbel-mean":"@stdlib/stats/base/dists/gumbel/mean","@stdlib/stats-base-dists-gumbel-median":"@stdlib/stats/base/dists/gumbel/median","@stdlib/stats-base-dists-gumbel-mgf":"@stdlib/stats/base/dists/gumbel/mgf","@stdlib/stats-base-dists-gumbel-mode":"@stdlib/stats/base/dists/gumbel/mode","@stdlib/stats-base-dists-gumbel-pdf":"@stdlib/stats/base/dists/gumbel/pdf","@stdlib/stats-base-dists-gumbel-quantile":"@stdlib/stats/base/dists/gumbel/quantile","@stdlib/stats-base-dists-gumbel-skewness":"@stdlib/stats/base/dists/gumbel/skewness","@stdlib/stats-base-dists-gumbel-stdev":"@stdlib/stats/base/dists/gumbel/stdev","@stdlib/stats-base-dists-gumbel-variance":"@stdlib/stats/base/dists/gumbel/variance","@stdlib/stats-base-dists-hypergeometric-cdf":"@stdlib/stats/base/dists/hypergeometric/cdf","@stdlib/stats-base-dists-hypergeometric-ctor":"@stdlib/stats/base/dists/hypergeometric/ctor","@stdlib/stats-base-dists-hypergeometric-kurtosis":"@stdlib/stats/base/dists/hypergeometric/kurtosis","@stdlib/stats-base-dists-hypergeometric-logpmf":"@stdlib/stats/base/dists/hypergeometric/logpmf","@stdlib/stats-base-dists-hypergeometric-mean":"@stdlib/stats/base/dists/hypergeometric/mean","@stdlib/stats-base-dists-hypergeometric-mode":"@stdlib/stats/base/dists/hypergeometric/mode","@stdlib/stats-base-dists-hypergeometric-pmf":"@stdlib/stats/base/dists/hypergeometric/pmf","@stdlib/stats-base-dists-hypergeometric-quantile":"@stdlib/stats/base/dists/hypergeometric/quantile","@stdlib/stats-base-dists-hypergeometric-skewness":"@stdlib/stats/base/dists/hypergeometric/skewness","@stdlib/stats-base-dists-hypergeometric-stdev":"@stdlib/stats/base/dists/hypergeometric/stdev","@stdlib/stats-base-dists-hypergeometric-variance":"@stdlib/stats/base/dists/hypergeometric/variance","@stdlib/stats-base-dists-invgamma-cdf":"@stdlib/stats/base/dists/invgamma/cdf","@stdlib/stats-base-dists-invgamma-entropy":"@stdlib/stats/base/dists/invgamma/entropy","@stdlib/stats-base-dists-invgamma-ctor":"@stdlib/stats/base/dists/invgamma/ctor","@stdlib/stats-base-dists-invgamma-kurtosis":"@stdlib/stats/base/dists/invgamma/kurtosis","@stdlib/stats-base-dists-invgamma-logpdf":"@stdlib/stats/base/dists/invgamma/logpdf","@stdlib/stats-base-dists-invgamma-mean":"@stdlib/stats/base/dists/invgamma/mean","@stdlib/stats-base-dists-invgamma-mode":"@stdlib/stats/base/dists/invgamma/mode","@stdlib/stats-base-dists-invgamma-pdf":"@stdlib/stats/base/dists/invgamma/pdf","@stdlib/stats-base-dists-invgamma-quantile":"@stdlib/stats/base/dists/invgamma/quantile","@stdlib/stats-base-dists-invgamma-skewness":"@stdlib/stats/base/dists/invgamma/skewness","@stdlib/stats-base-dists-invgamma-stdev":"@stdlib/stats/base/dists/invgamma/stdev","@stdlib/stats-base-dists-invgamma-variance":"@stdlib/stats/base/dists/invgamma/variance","@stdlib/stats-base-dists-kumaraswamy-cdf":"@stdlib/stats/base/dists/kumaraswamy/cdf","@stdlib/stats-base-dists-kumaraswamy-ctor":"@stdlib/stats/base/dists/kumaraswamy/ctor","@stdlib/stats-base-dists-kumaraswamy-kurtosis":"@stdlib/stats/base/dists/kumaraswamy/kurtosis","@stdlib/stats-base-dists-kumaraswamy-logcdf":"@stdlib/stats/base/dists/kumaraswamy/logcdf","@stdlib/stats-base-dists-kumaraswamy-logpdf":"@stdlib/stats/base/dists/kumaraswamy/logpdf","@stdlib/stats-base-dists-kumaraswamy-mean":"@stdlib/stats/base/dists/kumaraswamy/mean","@stdlib/stats-base-dists-kumaraswamy-median":"@stdlib/stats/base/dists/kumaraswamy/median","@stdlib/stats-base-dists-kumaraswamy-mode":"@stdlib/stats/base/dists/kumaraswamy/mode","@stdlib/stats-base-dists-kumaraswamy-pdf":"@stdlib/stats/base/dists/kumaraswamy/pdf","@stdlib/stats-base-dists-kumaraswamy-quantile":"@stdlib/stats/base/dists/kumaraswamy/quantile","@stdlib/stats-base-dists-kumaraswamy-skewness":"@stdlib/stats/base/dists/kumaraswamy/skewness","@stdlib/stats-base-dists-kumaraswamy-stdev":"@stdlib/stats/base/dists/kumaraswamy/stdev","@stdlib/stats-base-dists-kumaraswamy-variance":"@stdlib/stats/base/dists/kumaraswamy/variance","@stdlib/stats-base-dists-laplace-cdf":"@stdlib/stats/base/dists/laplace/cdf","@stdlib/stats-base-dists-laplace-entropy":"@stdlib/stats/base/dists/laplace/entropy","@stdlib/stats-base-dists-laplace-kurtosis":"@stdlib/stats/base/dists/laplace/kurtosis","@stdlib/stats-base-dists-laplace-ctor":"@stdlib/stats/base/dists/laplace/ctor","@stdlib/stats-base-dists-laplace-logcdf":"@stdlib/stats/base/dists/laplace/logcdf","@stdlib/stats-base-dists-laplace-logpdf":"@stdlib/stats/base/dists/laplace/logpdf","@stdlib/stats-base-dists-laplace-mean":"@stdlib/stats/base/dists/laplace/mean","@stdlib/stats-base-dists-laplace-median":"@stdlib/stats/base/dists/laplace/median","@stdlib/stats-base-dists-laplace-mgf":"@stdlib/stats/base/dists/laplace/mgf","@stdlib/stats-base-dists-laplace-mode":"@stdlib/stats/base/dists/laplace/mode","@stdlib/stats-base-dists-laplace-pdf":"@stdlib/stats/base/dists/laplace/pdf","@stdlib/stats-base-dists-laplace-quantile":"@stdlib/stats/base/dists/laplace/quantile","@stdlib/stats-base-dists-laplace-skewness":"@stdlib/stats/base/dists/laplace/skewness","@stdlib/stats-base-dists-laplace-stdev":"@stdlib/stats/base/dists/laplace/stdev","@stdlib/stats-base-dists-laplace-variance":"@stdlib/stats/base/dists/laplace/variance","@stdlib/stats-base-dists-levy-cdf":"@stdlib/stats/base/dists/levy/cdf","@stdlib/stats-base-dists-levy-entropy":"@stdlib/stats/base/dists/levy/entropy","@stdlib/stats-base-dists-levy-ctor":"@stdlib/stats/base/dists/levy/ctor","@stdlib/stats-base-dists-levy-logcdf":"@stdlib/stats/base/dists/levy/logcdf","@stdlib/stats-base-dists-levy-logpdf":"@stdlib/stats/base/dists/levy/logpdf","@stdlib/stats-base-dists-levy-mean":"@stdlib/stats/base/dists/levy/mean","@stdlib/stats-base-dists-levy-median":"@stdlib/stats/base/dists/levy/median","@stdlib/stats-base-dists-levy-mode":"@stdlib/stats/base/dists/levy/mode","@stdlib/stats-base-dists-levy-pdf":"@stdlib/stats/base/dists/levy/pdf","@stdlib/stats-base-dists-levy-quantile":"@stdlib/stats/base/dists/levy/quantile","@stdlib/stats-base-dists-levy-stdev":"@stdlib/stats/base/dists/levy/stdev","@stdlib/stats-base-dists-levy-variance":"@stdlib/stats/base/dists/levy/variance","@stdlib/stats-base-dists-logistic-cdf":"@stdlib/stats/base/dists/logistic/cdf","@stdlib/stats-base-dists-logistic-entropy":"@stdlib/stats/base/dists/logistic/entropy","@stdlib/stats-base-dists-logistic-kurtosis":"@stdlib/stats/base/dists/logistic/kurtosis","@stdlib/stats-base-dists-logistic-logcdf":"@stdlib/stats/base/dists/logistic/logcdf","@stdlib/stats-base-dists-logistic-ctor":"@stdlib/stats/base/dists/logistic/ctor","@stdlib/stats-base-dists-logistic-logpdf":"@stdlib/stats/base/dists/logistic/logpdf","@stdlib/stats-base-dists-logistic-mean":"@stdlib/stats/base/dists/logistic/mean","@stdlib/stats-base-dists-logistic-median":"@stdlib/stats/base/dists/logistic/median","@stdlib/stats-base-dists-logistic-mgf":"@stdlib/stats/base/dists/logistic/mgf","@stdlib/stats-base-dists-logistic-mode":"@stdlib/stats/base/dists/logistic/mode","@stdlib/stats-base-dists-logistic-pdf":"@stdlib/stats/base/dists/logistic/pdf","@stdlib/stats-base-dists-logistic-quantile":"@stdlib/stats/base/dists/logistic/quantile","@stdlib/stats-base-dists-logistic-skewness":"@stdlib/stats/base/dists/logistic/skewness","@stdlib/stats-base-dists-logistic-stdev":"@stdlib/stats/base/dists/logistic/stdev","@stdlib/stats-base-dists-logistic-variance":"@stdlib/stats/base/dists/logistic/variance","@stdlib/stats-base-dists-lognormal-cdf":"@stdlib/stats/base/dists/lognormal/cdf","@stdlib/stats-base-dists-lognormal-entropy":"@stdlib/stats/base/dists/lognormal/entropy","@stdlib/stats-base-dists-lognormal-kurtosis":"@stdlib/stats/base/dists/lognormal/kurtosis","@stdlib/stats-base-dists-lognormal-ctor":"@stdlib/stats/base/dists/lognormal/ctor","@stdlib/stats-base-dists-lognormal-logcdf":"@stdlib/stats/base/dists/lognormal/logcdf","@stdlib/stats-base-dists-lognormal-logpdf":"@stdlib/stats/base/dists/lognormal/logpdf","@stdlib/stats-base-dists-lognormal-mean":"@stdlib/stats/base/dists/lognormal/mean","@stdlib/stats-base-dists-lognormal-median":"@stdlib/stats/base/dists/lognormal/median","@stdlib/stats-base-dists-lognormal-mode":"@stdlib/stats/base/dists/lognormal/mode","@stdlib/stats-base-dists-lognormal-pdf":"@stdlib/stats/base/dists/lognormal/pdf","@stdlib/stats-base-dists-lognormal-quantile":"@stdlib/stats/base/dists/lognormal/quantile","@stdlib/stats-base-dists-lognormal-skewness":"@stdlib/stats/base/dists/lognormal/skewness","@stdlib/stats-base-dists-lognormal-stdev":"@stdlib/stats/base/dists/lognormal/stdev","@stdlib/stats-base-dists-lognormal-variance":"@stdlib/stats/base/dists/lognormal/variance","@stdlib/stats-base-dists-negative-binomial-cdf":"@stdlib/stats/base/dists/negative-binomial/cdf","@stdlib/stats-base-dists-negative-binomial-kurtosis":"@stdlib/stats/base/dists/negative-binomial/kurtosis","@stdlib/stats-base-dists-negative-binomial-logpmf":"@stdlib/stats/base/dists/negative-binomial/logpmf","@stdlib/stats-base-dists-negative-binomial-mean":"@stdlib/stats/base/dists/negative-binomial/mean","@stdlib/stats-base-dists-negative-binomial-mgf":"@stdlib/stats/base/dists/negative-binomial/mgf","@stdlib/stats-base-dists-negative-binomial-mode":"@stdlib/stats/base/dists/negative-binomial/mode","@stdlib/stats-base-dists-negative-binomial-ctor":"@stdlib/stats/base/dists/negative-binomial/ctor","@stdlib/stats-base-dists-negative-binomial-pmf":"@stdlib/stats/base/dists/negative-binomial/pmf","@stdlib/stats-base-dists-negative-binomial-quantile":"@stdlib/stats/base/dists/negative-binomial/quantile","@stdlib/stats-base-dists-negative-binomial-skewness":"@stdlib/stats/base/dists/negative-binomial/skewness","@stdlib/stats-base-dists-negative-binomial-stdev":"@stdlib/stats/base/dists/negative-binomial/stdev","@stdlib/stats-base-dists-negative-binomial-variance":"@stdlib/stats/base/dists/negative-binomial/variance","@stdlib/stats-base-dists-normal-cdf":"@stdlib/stats/base/dists/normal/cdf","@stdlib/stats-base-dists-normal-entropy":"@stdlib/stats/base/dists/normal/entropy","@stdlib/stats-base-dists-normal-kurtosis":"@stdlib/stats/base/dists/normal/kurtosis","@stdlib/stats-base-dists-normal-logcdf":"@stdlib/stats/base/dists/normal/logcdf","@stdlib/stats-base-dists-normal-logpdf":"@stdlib/stats/base/dists/normal/logpdf","@stdlib/stats-base-dists-normal-mean":"@stdlib/stats/base/dists/normal/mean","@stdlib/stats-base-dists-normal-median":"@stdlib/stats/base/dists/normal/median","@stdlib/stats-base-dists-normal-mgf":"@stdlib/stats/base/dists/normal/mgf","@stdlib/stats-base-dists-normal-mode":"@stdlib/stats/base/dists/normal/mode","@stdlib/stats-base-dists-normal-ctor":"@stdlib/stats/base/dists/normal/ctor","@stdlib/stats-base-dists-normal-pdf":"@stdlib/stats/base/dists/normal/pdf","@stdlib/stats-base-dists-normal-quantile":"@stdlib/stats/base/dists/normal/quantile","@stdlib/stats-base-dists-normal-skewness":"@stdlib/stats/base/dists/normal/skewness","@stdlib/stats-base-dists-normal-stdev":"@stdlib/stats/base/dists/normal/stdev","@stdlib/stats-base-dists-normal-variance":"@stdlib/stats/base/dists/normal/variance","@stdlib/stats-base-dists-pareto-type1-cdf":"@stdlib/stats/base/dists/pareto-type1/cdf","@stdlib/stats-base-dists-pareto-type1-entropy":"@stdlib/stats/base/dists/pareto-type1/entropy","@stdlib/stats-base-dists-pareto-type1-kurtosis":"@stdlib/stats/base/dists/pareto-type1/kurtosis","@stdlib/stats-base-dists-pareto-type1-logcdf":"@stdlib/stats/base/dists/pareto-type1/logcdf","@stdlib/stats-base-dists-pareto-type1-logpdf":"@stdlib/stats/base/dists/pareto-type1/logpdf","@stdlib/stats-base-dists-pareto-type1-mean":"@stdlib/stats/base/dists/pareto-type1/mean","@stdlib/stats-base-dists-pareto-type1-median":"@stdlib/stats/base/dists/pareto-type1/median","@stdlib/stats-base-dists-pareto-type1-mode":"@stdlib/stats/base/dists/pareto-type1/mode","@stdlib/stats-base-dists-pareto-type1-ctor":"@stdlib/stats/base/dists/pareto-type1/ctor","@stdlib/stats-base-dists-pareto-type1-pdf":"@stdlib/stats/base/dists/pareto-type1/pdf","@stdlib/stats-base-dists-pareto-type1-quantile":"@stdlib/stats/base/dists/pareto-type1/quantile","@stdlib/stats-base-dists-pareto-type1-skewness":"@stdlib/stats/base/dists/pareto-type1/skewness","@stdlib/stats-base-dists-pareto-type1-stdev":"@stdlib/stats/base/dists/pareto-type1/stdev","@stdlib/stats-base-dists-pareto-type1-variance":"@stdlib/stats/base/dists/pareto-type1/variance","@stdlib/stats-base-dists-poisson-cdf":"@stdlib/stats/base/dists/poisson/cdf","@stdlib/stats-base-dists-poisson-entropy":"@stdlib/stats/base/dists/poisson/entropy","@stdlib/stats-base-dists-poisson-kurtosis":"@stdlib/stats/base/dists/poisson/kurtosis","@stdlib/stats-base-dists-poisson-logpmf":"@stdlib/stats/base/dists/poisson/logpmf","@stdlib/stats-base-dists-poisson-mean":"@stdlib/stats/base/dists/poisson/mean","@stdlib/stats-base-dists-poisson-median":"@stdlib/stats/base/dists/poisson/median","@stdlib/stats-base-dists-poisson-mgf":"@stdlib/stats/base/dists/poisson/mgf","@stdlib/stats-base-dists-poisson-mode":"@stdlib/stats/base/dists/poisson/mode","@stdlib/stats-base-dists-poisson-pmf":"@stdlib/stats/base/dists/poisson/pmf","@stdlib/stats-base-dists-poisson-ctor":"@stdlib/stats/base/dists/poisson/ctor","@stdlib/stats-base-dists-poisson-quantile":"@stdlib/stats/base/dists/poisson/quantile","@stdlib/stats-base-dists-poisson-skewness":"@stdlib/stats/base/dists/poisson/skewness","@stdlib/stats-base-dists-poisson-stdev":"@stdlib/stats/base/dists/poisson/stdev","@stdlib/stats-base-dists-poisson-variance":"@stdlib/stats/base/dists/poisson/variance","@stdlib/stats-base-dists-rayleigh-cdf":"@stdlib/stats/base/dists/rayleigh/cdf","@stdlib/stats-base-dists-rayleigh-entropy":"@stdlib/stats/base/dists/rayleigh/entropy","@stdlib/stats-base-dists-rayleigh-kurtosis":"@stdlib/stats/base/dists/rayleigh/kurtosis","@stdlib/stats-base-dists-rayleigh-logcdf":"@stdlib/stats/base/dists/rayleigh/logcdf","@stdlib/stats-base-dists-rayleigh-logpdf":"@stdlib/stats/base/dists/rayleigh/logpdf","@stdlib/stats-base-dists-rayleigh-mean":"@stdlib/stats/base/dists/rayleigh/mean","@stdlib/stats-base-dists-rayleigh-median":"@stdlib/stats/base/dists/rayleigh/median","@stdlib/stats-base-dists-rayleigh-mgf":"@stdlib/stats/base/dists/rayleigh/mgf","@stdlib/stats-base-dists-rayleigh-mode":"@stdlib/stats/base/dists/rayleigh/mode","@stdlib/stats-base-dists-rayleigh-pdf":"@stdlib/stats/base/dists/rayleigh/pdf","@stdlib/stats-base-dists-rayleigh-quantile":"@stdlib/stats/base/dists/rayleigh/quantile","@stdlib/stats-base-dists-rayleigh-ctor":"@stdlib/stats/base/dists/rayleigh/ctor","@stdlib/stats-base-dists-rayleigh-skewness":"@stdlib/stats/base/dists/rayleigh/skewness","@stdlib/stats-base-dists-rayleigh-stdev":"@stdlib/stats/base/dists/rayleigh/stdev","@stdlib/stats-base-dists-rayleigh-variance":"@stdlib/stats/base/dists/rayleigh/variance","@stdlib/stats-base-dists-signrank-cdf":"@stdlib/stats/base/dists/signrank/cdf","@stdlib/stats-base-dists-signrank-pdf":"@stdlib/stats/base/dists/signrank/pdf","@stdlib/stats-base-dists-signrank-quantile":"@stdlib/stats/base/dists/signrank/quantile","@stdlib/stats-base-dists-studentized-range-cdf":"@stdlib/stats/base/dists/studentized-range/cdf","@stdlib/stats-base-dists-studentized-range-quantile":"@stdlib/stats/base/dists/studentized-range/quantile","@stdlib/stats-base-dists-t-cdf":"@stdlib/stats/base/dists/t/cdf","@stdlib/stats-base-dists-t-entropy":"@stdlib/stats/base/dists/t/entropy","@stdlib/stats-base-dists-t-kurtosis":"@stdlib/stats/base/dists/t/kurtosis","@stdlib/stats-base-dists-t-logcdf":"@stdlib/stats/base/dists/t/logcdf","@stdlib/stats-base-dists-t-logpdf":"@stdlib/stats/base/dists/t/logpdf","@stdlib/stats-base-dists-t-mean":"@stdlib/stats/base/dists/t/mean","@stdlib/stats-base-dists-t-median":"@stdlib/stats/base/dists/t/median","@stdlib/stats-base-dists-t-mode":"@stdlib/stats/base/dists/t/mode","@stdlib/stats-base-dists-t-pdf":"@stdlib/stats/base/dists/t/pdf","@stdlib/stats-base-dists-t-quantile":"@stdlib/stats/base/dists/t/quantile","@stdlib/stats-base-dists-t-skewness":"@stdlib/stats/base/dists/t/skewness","@stdlib/stats-base-dists-t-stdev":"@stdlib/stats/base/dists/t/stdev","@stdlib/stats-base-dists-t-ctor":"@stdlib/stats/base/dists/t/ctor","@stdlib/stats-base-dists-t-variance":"@stdlib/stats/base/dists/t/variance","@stdlib/stats-base-dists-triangular-cdf":"@stdlib/stats/base/dists/triangular/cdf","@stdlib/stats-base-dists-triangular-entropy":"@stdlib/stats/base/dists/triangular/entropy","@stdlib/stats-base-dists-triangular-kurtosis":"@stdlib/stats/base/dists/triangular/kurtosis","@stdlib/stats-base-dists-triangular-logcdf":"@stdlib/stats/base/dists/triangular/logcdf","@stdlib/stats-base-dists-triangular-logpdf":"@stdlib/stats/base/dists/triangular/logpdf","@stdlib/stats-base-dists-triangular-mean":"@stdlib/stats/base/dists/triangular/mean","@stdlib/stats-base-dists-triangular-median":"@stdlib/stats/base/dists/triangular/median","@stdlib/stats-base-dists-triangular-mgf":"@stdlib/stats/base/dists/triangular/mgf","@stdlib/stats-base-dists-triangular-mode":"@stdlib/stats/base/dists/triangular/mode","@stdlib/stats-base-dists-triangular-pdf":"@stdlib/stats/base/dists/triangular/pdf","@stdlib/stats-base-dists-triangular-quantile":"@stdlib/stats/base/dists/triangular/quantile","@stdlib/stats-base-dists-triangular-skewness":"@stdlib/stats/base/dists/triangular/skewness","@stdlib/stats-base-dists-triangular-stdev":"@stdlib/stats/base/dists/triangular/stdev","@stdlib/stats-base-dists-triangular-ctor":"@stdlib/stats/base/dists/triangular/ctor","@stdlib/stats-base-dists-triangular-variance":"@stdlib/stats/base/dists/triangular/variance","@stdlib/stats-base-dists-truncated-normal-pdf":"@stdlib/stats/base/dists/truncated-normal/pdf","@stdlib/stats-base-dists-uniform-cdf":"@stdlib/stats/base/dists/uniform/cdf","@stdlib/stats-base-dists-uniform-entropy":"@stdlib/stats/base/dists/uniform/entropy","@stdlib/stats-base-dists-uniform-kurtosis":"@stdlib/stats/base/dists/uniform/kurtosis","@stdlib/stats-base-dists-uniform-logcdf":"@stdlib/stats/base/dists/uniform/logcdf","@stdlib/stats-base-dists-uniform-logpdf":"@stdlib/stats/base/dists/uniform/logpdf","@stdlib/stats-base-dists-uniform-mean":"@stdlib/stats/base/dists/uniform/mean","@stdlib/stats-base-dists-uniform-median":"@stdlib/stats/base/dists/uniform/median","@stdlib/stats-base-dists-uniform-mgf":"@stdlib/stats/base/dists/uniform/mgf","@stdlib/stats-base-dists-uniform-pdf":"@stdlib/stats/base/dists/uniform/pdf","@stdlib/stats-base-dists-uniform-quantile":"@stdlib/stats/base/dists/uniform/quantile","@stdlib/stats-base-dists-uniform-skewness":"@stdlib/stats/base/dists/uniform/skewness","@stdlib/stats-base-dists-uniform-stdev":"@stdlib/stats/base/dists/uniform/stdev","@stdlib/stats-base-dists-uniform-ctor":"@stdlib/stats/base/dists/uniform/ctor","@stdlib/stats-base-dists-uniform-variance":"@stdlib/stats/base/dists/uniform/variance","@stdlib/stats-base-dists-weibull-cdf":"@stdlib/stats/base/dists/weibull/cdf","@stdlib/stats-base-dists-weibull-entropy":"@stdlib/stats/base/dists/weibull/entropy","@stdlib/stats-base-dists-weibull-kurtosis":"@stdlib/stats/base/dists/weibull/kurtosis","@stdlib/stats-base-dists-weibull-logcdf":"@stdlib/stats/base/dists/weibull/logcdf","@stdlib/stats-base-dists-weibull-logpdf":"@stdlib/stats/base/dists/weibull/logpdf","@stdlib/stats-base-dists-weibull-mean":"@stdlib/stats/base/dists/weibull/mean","@stdlib/stats-base-dists-weibull-median":"@stdlib/stats/base/dists/weibull/median","@stdlib/stats-base-dists-weibull-mgf":"@stdlib/stats/base/dists/weibull/mgf","@stdlib/stats-base-dists-weibull-mode":"@stdlib/stats/base/dists/weibull/mode","@stdlib/stats-base-dists-weibull-pdf":"@stdlib/stats/base/dists/weibull/pdf","@stdlib/stats-base-dists-weibull-quantile":"@stdlib/stats/base/dists/weibull/quantile","@stdlib/stats-base-dists-weibull-skewness":"@stdlib/stats/base/dists/weibull/skewness","@stdlib/stats-base-dists-weibull-stdev":"@stdlib/stats/base/dists/weibull/stdev","@stdlib/stats-base-dists-weibull-variance":"@stdlib/stats/base/dists/weibull/variance","@stdlib/stats-base-dists-weibull-ctor":"@stdlib/stats/base/dists/weibull/ctor","@stdlib/math-base-special-ellipe":"@stdlib/math/base/special/ellipe","@stdlib/math-base-special-ellipj":"@stdlib/math/base/special/ellipj","@stdlib/math-base-special-ellipk":"@stdlib/math/base/special/ellipk","@stdlib/string-base-ends-with":"@stdlib/string/base/ends-with","@stdlib/math-base-utils-float64-epsilon-difference":"@stdlib/math/base/utils/float64-epsilon-difference","@stdlib/math-base-special-erf":"@stdlib/math/base/special/erf","@stdlib/math-base-special-erfc":"@stdlib/math/base/special/erfc","@stdlib/math-base-special-erfcinv":"@stdlib/math/base/special/erfcinv","@stdlib/math-base-special-erfcx":"@stdlib/math/base/special/erfcx","@stdlib/math-base-special-erfinv":"@stdlib/math/base/special/erfinv","@stdlib/math-base-special-dirichlet-eta":"@stdlib/math/base/special/dirichlet-eta","@stdlib/math-base-tools-evalpoly":"@stdlib/math/base/tools/evalpoly","@stdlib/math-base-tools-evalrational":"@stdlib/math/base/tools/evalrational","@stdlib/math-base-special-exp":"@stdlib/math/base/special/exp","@stdlib/math-base-special-exp2":"@stdlib/math/base/special/exp2","@stdlib/math-base-special-exp10":"@stdlib/math/base/special/exp10","@stdlib/math-base-special-expit":"@stdlib/math/base/special/expit","@stdlib/math-base-special-expm1":"@stdlib/math/base/special/expm1","@stdlib/math-base-special-expm1rel":"@stdlib/math/base/special/expm1rel","@stdlib/number-float64-base-exponent":"@stdlib/number/float64/base/exponent","@stdlib/number-float32-base-exponent":"@stdlib/number/float32/base/exponent","@stdlib/math-base-special-factorial":"@stdlib/math/base/special/factorial","@stdlib/math-base-special-factorial2":"@stdlib/math/base/special/factorial2","@stdlib/math-base-special-factorialln":"@stdlib/math/base/special/factorialln","@stdlib/math-base-special-falling-factorial":"@stdlib/math/base/special/falling-factorial","@stdlib/math-base-special-fibonacci":"@stdlib/math/base/special/fibonacci","@stdlib/math-base-special-fibonacci-index":"@stdlib/math/base/special/fibonacci-index","@stdlib/math-base-tools-fibpoly":"@stdlib/math/base/tools/fibpoly","@stdlib/string-base-first-code-point":"@stdlib/string/base/first-code-point","@stdlib/string-base-first":"@stdlib/string/base/first","@stdlib/string-base-first-grapheme-cluster":"@stdlib/string/base/first-grapheme-cluster","@stdlib/math-base-special-flipsign":"@stdlib/math/base/special/flipsign","@stdlib/math-base-special-flipsignf":"@stdlib/math/base/special/flipsignf","@stdlib/number-float32-base-to-int32":"@stdlib/number/float32/base/to-int32","@stdlib/number-float32-base-to-uint32":"@stdlib/number/float32/base/to-uint32","@stdlib/number-float64-base-to-float32":"@stdlib/number/float64/base/to-float32","@stdlib/number-float64-base-to-int32":"@stdlib/number/float64/base/to-int32","@stdlib/number-float64-base-to-int64-bytes":"@stdlib/number/float64/base/to-int64-bytes","@stdlib/number-float64-base-to-uint32":"@stdlib/number/float64/base/to-uint32","@stdlib/math-base-special-floor":"@stdlib/math/base/special/floor","@stdlib/math-base-special-floor2":"@stdlib/math/base/special/floor2","@stdlib/math-base-special-floor10":"@stdlib/math/base/special/floor10","@stdlib/math-base-special-floorb":"@stdlib/math/base/special/floorb","@stdlib/math-base-special-floorf":"@stdlib/math/base/special/floorf","@stdlib/math-base-special-floorn":"@stdlib/math/base/special/floorn","@stdlib/math-base-special-floorsd":"@stdlib/math/base/special/floorsd","@stdlib/string-base-for-each":"@stdlib/string/base/for-each","@stdlib/string-base-for-each-code-point":"@stdlib/string/base/for-each-code-point","@stdlib/string-base-for-each-code-point-right":"@stdlib/string/base/for-each-code-point-right","@stdlib/string-base-for-each-grapheme-cluster":"@stdlib/string/base/for-each-grapheme-cluster","@stdlib/string-base-for-each-right":"@stdlib/string/base/for-each-right","@stdlib/string-base-format-interpolate":"@stdlib/string/base/format-interpolate","@stdlib/string-base-format-tokenize":"@stdlib/string/base/format-tokenize","@stdlib/math-base-special-fresnel":"@stdlib/math/base/special/fresnel","@stdlib/math-base-special-fresnelc":"@stdlib/math/base/special/fresnelc","@stdlib/math-base-special-fresnels":"@stdlib/math/base/special/fresnels","@stdlib/math-base-special-frexp":"@stdlib/math/base/special/frexp","@stdlib/number-float64-base-from-binary-string":"@stdlib/number/float64/base/from-binary-string","@stdlib/number-float32-base-from-binary-string":"@stdlib/number/float32/base/from-binary-string","@stdlib/number-uint8-base-from-binary-string":"@stdlib/number/uint8/base/from-binary-string","@stdlib/number-uint16-base-from-binary-string":"@stdlib/number/uint16/base/from-binary-string","@stdlib/number-uint32-base-from-binary-string":"@stdlib/number/uint32/base/from-binary-string","@stdlib/number-float64-base-from-int64-bytes":"@stdlib/number/float64/base/from-int64-bytes","@stdlib/number-float32-base-from-word":"@stdlib/number/float32/base/from-word","@stdlib/number-float64-base-from-words":"@stdlib/number/float64/base/from-words","@stdlib/math-base-special-gamma":"@stdlib/math/base/special/gamma","@stdlib/math-base-special-gamma1pm1":"@stdlib/math/base/special/gamma1pm1","@stdlib/math-base-special-gamma-delta-ratio":"@stdlib/math/base/special/gamma-delta-ratio","@stdlib/math-base-special-gammainc":"@stdlib/math/base/special/gammainc","@stdlib/math-base-special-gammaincinv":"@stdlib/math/base/special/gammaincinv","@stdlib/math-base-special-gamma-lanczos-sum":"@stdlib/math/base/special/gamma-lanczos-sum","@stdlib/math-base-special-gamma-lanczos-sum-expg-scaled":"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled","@stdlib/math-base-special-gammaln":"@stdlib/math/base/special/gammaln","@stdlib/math-base-special-gammasgn":"@stdlib/math/base/special/gammasgn","@stdlib/math-base-special-gcd":"@stdlib/math/base/special/gcd","@stdlib/number-float64-base-get-high-word":"@stdlib/number/float64/base/get-high-word","@stdlib/number-float64-base-get-low-word":"@stdlib/number/float64/base/get-low-word","@stdlib/math-base-special-hacovercos":"@stdlib/math/base/special/hacovercos","@stdlib/math-base-special-hacoversin":"@stdlib/math/base/special/hacoversin","@stdlib/math-base-special-havercos":"@stdlib/math/base/special/havercos","@stdlib/math-base-special-haversin":"@stdlib/math/base/special/haversin","@stdlib/string-base-headercase":"@stdlib/string/base/headercase","@stdlib/math-base-special-heaviside":"@stdlib/math/base/special/heaviside","@stdlib/math-base-tools-hermitepoly":"@stdlib/math/base/tools/hermitepoly","@stdlib/math-base-special-hypot":"@stdlib/math/base/special/hypot","@stdlib/math-base-special-hypotf":"@stdlib/math/base/special/hypotf","@stdlib/math-base-special-identity":"@stdlib/math/base/special/identity","@stdlib/math-base-special-identityf":"@stdlib/math/base/special/identityf","@stdlib/math-base-ops-imul":"@stdlib/math/base/ops/imul","@stdlib/math-base-ops-imuldw":"@stdlib/math/base/ops/imuldw","@stdlib/slice-base-int2slice":"@stdlib/slice/base/int2slice","@stdlib/number-int32-base-to-uint32":"@stdlib/number/int32/base/to-uint32","@stdlib/math-base-special-inv":"@stdlib/math/base/special/inv","@stdlib/string-base-invcase":"@stdlib/string/base/invcase","@stdlib/math-base-special-invf":"@stdlib/math/base/special/invf","@stdlib/math-base-assert-is-composite":"@stdlib/math/base/assert/is-composite","@stdlib/math-base-assert-is-coprime":"@stdlib/math/base/assert/is-coprime","@stdlib/math-base-assert-is-even":"@stdlib/math/base/assert/is-even","@stdlib/math-base-assert-int32-is-even":"@stdlib/math/base/assert/int32-is-even","@stdlib/math-base-assert-is-finite":"@stdlib/math/base/assert/is-finite","@stdlib/math-base-assert-is-finitef":"@stdlib/math/base/assert/is-finitef","@stdlib/math-base-assert-is-infinite":"@stdlib/math/base/assert/is-infinite","@stdlib/math-base-assert-is-infinitef":"@stdlib/math/base/assert/is-infinitef","@stdlib/math-base-assert-is-integer":"@stdlib/math/base/assert/is-integer","@stdlib/math-base-assert-is-nan":"@stdlib/math/base/assert/is-nan","@stdlib/math-base-assert-is-nanf":"@stdlib/math/base/assert/is-nanf","@stdlib/math-base-assert-is-negative-finite":"@stdlib/math/base/assert/is-negative-finite","@stdlib/math-base-assert-is-negative-integer":"@stdlib/math/base/assert/is-negative-integer","@stdlib/math-base-assert-is-negative-zero":"@stdlib/math/base/assert/is-negative-zero","@stdlib/math-base-assert-is-negative-zerof":"@stdlib/math/base/assert/is-negative-zerof","@stdlib/math-base-assert-is-nonnegative-finite":"@stdlib/math/base/assert/is-nonnegative-finite","@stdlib/math-base-assert-is-nonnegative-integer":"@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math-base-assert-is-nonpositive-finite":"@stdlib/math/base/assert/is-nonpositive-finite","@stdlib/math-base-assert-is-nonpositive-integer":"@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math-base-assert-is-odd":"@stdlib/math/base/assert/is-odd","@stdlib/math-base-assert-int32-is-odd":"@stdlib/math/base/assert/int32-is-odd","@stdlib/math-base-assert-is-positive-finite":"@stdlib/math/base/assert/is-positive-finite","@stdlib/math-base-assert-is-positive-integer":"@stdlib/math/base/assert/is-positive-integer","@stdlib/math-base-assert-is-positive-zero":"@stdlib/math/base/assert/is-positive-zero","@stdlib/math-base-assert-is-positive-zerof":"@stdlib/math/base/assert/is-positive-zerof","@stdlib/math-base-assert-uint32-is-pow2":"@stdlib/math/base/assert/uint32-is-pow2","@stdlib/math-base-assert-is-prime":"@stdlib/math/base/assert/is-prime","@stdlib/math-base-assert-is-probability":"@stdlib/math/base/assert/is-probability","@stdlib/math-base-assert-is-safe-integer":"@stdlib/math/base/assert/is-safe-integer","@stdlib/string-base-kebabcase":"@stdlib/string/base/kebabcase","@stdlib/math-base-special-kernel-betainc":"@stdlib/math/base/special/kernel-betainc","@stdlib/math-base-special-kernel-betaincinv":"@stdlib/math/base/special/kernel-betaincinv","@stdlib/math-base-special-kernel-cos":"@stdlib/math/base/special/kernel-cos","@stdlib/math-base-special-kernel-log1p":"@stdlib/math/base/special/kernel-log1p","@stdlib/math-base-special-kernel-sin":"@stdlib/math/base/special/kernel-sin","@stdlib/math-base-special-kernel-tan":"@stdlib/math/base/special/kernel-tan","@stdlib/math-base-special-kronecker-delta":"@stdlib/math/base/special/kronecker-delta","@stdlib/math-base-special-kronecker-deltaf":"@stdlib/math/base/special/kronecker-deltaf","@stdlib/math-base-special-labs":"@stdlib/math/base/special/labs","@stdlib/string-base-last":"@stdlib/string/base/last","@stdlib/string-base-last-code-point":"@stdlib/string/base/last-code-point","@stdlib/string-base-last-grapheme-cluster":"@stdlib/string/base/last-grapheme-cluster","@stdlib/math-base-special-lcm":"@stdlib/math/base/special/lcm","@stdlib/math-base-special-ldexp":"@stdlib/math/base/special/ldexp","@stdlib/string-base-left-pad":"@stdlib/string/base/left-pad","@stdlib/string-base-left-trim":"@stdlib/string/base/left-trim","@stdlib/math-base-special-ln":"@stdlib/math/base/special/ln","@stdlib/math-base-special-log":"@stdlib/math/base/special/log","@stdlib/math-base-special-log1mexp":"@stdlib/math/base/special/log1mexp","@stdlib/math-base-special-log1p":"@stdlib/math/base/special/log1p","@stdlib/math-base-special-log1pexp":"@stdlib/math/base/special/log1pexp","@stdlib/math-base-special-log1pmx":"@stdlib/math/base/special/log1pmx","@stdlib/math-base-special-log2":"@stdlib/math/base/special/log2","@stdlib/math-base-special-log10":"@stdlib/math/base/special/log10","@stdlib/math-base-special-logaddexp":"@stdlib/math/base/special/logaddexp","@stdlib/math-base-special-logit":"@stdlib/math/base/special/logit","@stdlib/string-base-lowercase":"@stdlib/string/base/lowercase","@stdlib/math-base-special-lucas":"@stdlib/math/base/special/lucas","@stdlib/math-base-tools-lucaspoly":"@stdlib/math/base/tools/lucaspoly","@stdlib/math-base-special-max":"@stdlib/math/base/special/max","@stdlib/math-base-special-maxabs":"@stdlib/math/base/special/maxabs","@stdlib/math-base-special-maxabsn":"@stdlib/math/base/special/maxabsn","@stdlib/math-base-special-maxn":"@stdlib/math/base/special/maxn","@stdlib/math-base-special-min":"@stdlib/math/base/special/min","@stdlib/math-base-special-minabs":"@stdlib/math/base/special/minabs","@stdlib/math-base-special-minabsn":"@stdlib/math/base/special/minabsn","@stdlib/math-base-special-minmax":"@stdlib/math/base/special/minmax","@stdlib/math-base-special-minmaxabs":"@stdlib/math/base/special/minmaxabs","@stdlib/math-base-special-minmaxabsn":"@stdlib/math/base/special/minmaxabsn","@stdlib/math-base-special-minmaxn":"@stdlib/math/base/special/minmaxn","@stdlib/math-base-special-minn":"@stdlib/math/base/special/minn","@stdlib/math-base-special-modf":"@stdlib/math/base/special/modf","@stdlib/number-float64-base-mul":"@stdlib/number/float64/base/mul","@stdlib/number-float32-base-mul":"@stdlib/number/float32/base/mul","@stdlib/ndarray-base-ctor":"@stdlib/ndarray/base/ctor","@stdlib/ndarray-base-unary":"@stdlib/ndarray/base/unary","@stdlib/ndarray-base-zeros":"@stdlib/ndarray/base/zeros","@stdlib/ndarray-base-zeros-like":"@stdlib/ndarray/base/zeros-like","@stdlib/math-base-special-negafibonacci":"@stdlib/math/base/special/negafibonacci","@stdlib/math-base-special-negalucas":"@stdlib/math/base/special/negalucas","@stdlib/math-base-special-nonfibonacci":"@stdlib/math/base/special/nonfibonacci","@stdlib/number-float64-base-normalize":"@stdlib/number/float64/base/normalize","@stdlib/number-float32-base-normalize":"@stdlib/number/float32/base/normalize","@stdlib/slice-base-normalize-multi-slice":"@stdlib/slice/base/normalize-multi-slice","@stdlib/slice-base-normalize-slice":"@stdlib/slice/base/normalize-slice","@stdlib/math-base-tools-normhermitepoly":"@stdlib/math/base/tools/normhermitepoly","@stdlib/string-base-pascalcase":"@stdlib/string/base/pascalcase","@stdlib/math-base-special-pdiff":"@stdlib/math/base/special/pdiff","@stdlib/math-base-special-pdifff":"@stdlib/math/base/special/pdifff","@stdlib/string-base-percent-encode":"@stdlib/string/base/percent-encode","@stdlib/math-base-special-polygamma":"@stdlib/math/base/special/polygamma","@stdlib/math-base-special-pow":"@stdlib/math/base/special/pow","@stdlib/math-base-special-powm1":"@stdlib/math/base/special/powm1","@stdlib/math-base-special-rad2deg":"@stdlib/math/base/special/rad2deg","@stdlib/math-base-special-rad2degf":"@stdlib/math/base/special/rad2degf","@stdlib/math-base-special-ramp":"@stdlib/math/base/special/ramp","@stdlib/math-base-special-rampf":"@stdlib/math/base/special/rampf","@stdlib/random-base-arcsine":"@stdlib/random/base/arcsine","@stdlib/random-base-bernoulli":"@stdlib/random/base/bernoulli","@stdlib/random-base-beta":"@stdlib/random/base/beta","@stdlib/random-base-betaprime":"@stdlib/random/base/betaprime","@stdlib/random-base-binomial":"@stdlib/random/base/binomial","@stdlib/random-base-box-muller":"@stdlib/random/base/box-muller","@stdlib/random-base-cauchy":"@stdlib/random/base/cauchy","@stdlib/random-base-chi":"@stdlib/random/base/chi","@stdlib/random-base-chisquare":"@stdlib/random/base/chisquare","@stdlib/random-base-cosine":"@stdlib/random/base/cosine","@stdlib/random-base-discrete-uniform":"@stdlib/random/base/discrete-uniform","@stdlib/random-base-erlang":"@stdlib/random/base/erlang","@stdlib/random-base-exponential":"@stdlib/random/base/exponential","@stdlib/random-base-f":"@stdlib/random/base/f","@stdlib/random-base-frechet":"@stdlib/random/base/frechet","@stdlib/random-base-gamma":"@stdlib/random/base/gamma","@stdlib/random-base-geometric":"@stdlib/random/base/geometric","@stdlib/random-base-gumbel":"@stdlib/random/base/gumbel","@stdlib/random-base-hypergeometric":"@stdlib/random/base/hypergeometric","@stdlib/random-base-improved-ziggurat":"@stdlib/random/base/improved-ziggurat","@stdlib/random-base-invgamma":"@stdlib/random/base/invgamma","@stdlib/random-base-kumaraswamy":"@stdlib/random/base/kumaraswamy","@stdlib/random-base-laplace":"@stdlib/random/base/laplace","@stdlib/random-base-levy":"@stdlib/random/base/levy","@stdlib/random-base-logistic":"@stdlib/random/base/logistic","@stdlib/random-base-lognormal":"@stdlib/random/base/lognormal","@stdlib/random-base-minstd":"@stdlib/random/base/minstd","@stdlib/random-base-minstd-shuffle":"@stdlib/random/base/minstd-shuffle","@stdlib/random-base-mt19937":"@stdlib/random/base/mt19937","@stdlib/random-base-negative-binomial":"@stdlib/random/base/negative-binomial","@stdlib/random-base-normal":"@stdlib/random/base/normal","@stdlib/random-base-pareto-type1":"@stdlib/random/base/pareto-type1","@stdlib/random-base-poisson":"@stdlib/random/base/poisson","@stdlib/random-base-randi":"@stdlib/random/base/randi","@stdlib/random-base-randn":"@stdlib/random/base/randn","@stdlib/random-base-randu":"@stdlib/random/base/randu","@stdlib/random-base-rayleigh":"@stdlib/random/base/rayleigh","@stdlib/random-base-t":"@stdlib/random/base/t","@stdlib/random-base-triangular":"@stdlib/random/base/triangular","@stdlib/random-base-uniform":"@stdlib/random/base/uniform","@stdlib/random-base-weibull":"@stdlib/random/base/weibull","@stdlib/math-base-special-rcbrt":"@stdlib/math/base/special/rcbrt","@stdlib/math-base-special-rcbrtf":"@stdlib/math/base/special/rcbrtf","@stdlib/math-base-utils-relative-difference":"@stdlib/math/base/utils/relative-difference","@stdlib/string-base-remove-first":"@stdlib/string/base/remove-first","@stdlib/string-base-remove-first-code-point":"@stdlib/string/base/remove-first-code-point","@stdlib/string-base-remove-first-grapheme-cluster":"@stdlib/string/base/remove-first-grapheme-cluster","@stdlib/string-base-remove-last":"@stdlib/string/base/remove-last","@stdlib/string-base-remove-last-code-point":"@stdlib/string/base/remove-last-code-point","@stdlib/string-base-remove-last-grapheme-cluster":"@stdlib/string/base/remove-last-grapheme-cluster","@stdlib/math-base-special-rempio2":"@stdlib/math/base/special/rempio2","@stdlib/string-base-repeat":"@stdlib/string/base/repeat","@stdlib/string-base-replace":"@stdlib/string/base/replace","@stdlib/string-base-replace-after":"@stdlib/string/base/replace-after","@stdlib/string-base-replace-after-last":"@stdlib/string/base/replace-after-last","@stdlib/string-base-replace-before":"@stdlib/string/base/replace-before","@stdlib/string-base-replace-before-last":"@stdlib/string/base/replace-before-last","@stdlib/string-base-reverse":"@stdlib/string/base/reverse","@stdlib/string-base-reverse-code-points":"@stdlib/string/base/reverse-code-points","@stdlib/string-base-reverse-grapheme-clusters":"@stdlib/string/base/reverse-grapheme-clusters","@stdlib/string-base-right-pad":"@stdlib/string/base/right-pad","@stdlib/string-base-right-trim":"@stdlib/string/base/right-trim","@stdlib/math-base-special-rising-factorial":"@stdlib/math/base/special/rising-factorial","@stdlib/number-uint32-base-rotl":"@stdlib/number/uint32/base/rotl","@stdlib/number-uint32-base-rotr":"@stdlib/number/uint32/base/rotr","@stdlib/math-base-special-round":"@stdlib/math/base/special/round","@stdlib/math-base-special-round2":"@stdlib/math/base/special/round2","@stdlib/math-base-special-round10":"@stdlib/math/base/special/round10","@stdlib/math-base-special-roundb":"@stdlib/math/base/special/roundb","@stdlib/math-base-special-roundn":"@stdlib/math/base/special/roundn","@stdlib/math-base-special-roundsd":"@stdlib/math/base/special/roundsd","@stdlib/math-base-special-rsqrt":"@stdlib/math/base/special/rsqrt","@stdlib/math-base-special-rsqrtf":"@stdlib/math/base/special/rsqrtf","@stdlib/slice-base-sargs2multislice":"@stdlib/slice/base/sargs2multislice","@stdlib/ndarray-base-from-scalar":"@stdlib/ndarray/base/from-scalar","@stdlib/math-base-special-secd":"@stdlib/math/base/special/secd","@stdlib/slice-base-seq2multislice":"@stdlib/slice/base/seq2multislice","@stdlib/slice-base-seq2slice":"@stdlib/slice/base/seq2slice","@stdlib/number-float64-base-set-high-word":"@stdlib/number/float64/base/set-high-word","@stdlib/number-float64-base-set-low-word":"@stdlib/number/float64/base/set-low-word","@stdlib/math-base-special-sici":"@stdlib/math/base/special/sici","@stdlib/number-float64-base-signbit":"@stdlib/number/float64/base/signbit","@stdlib/number-float32-base-signbit":"@stdlib/number/float32/base/signbit","@stdlib/number-float32-base-significand":"@stdlib/number/float32/base/significand","@stdlib/math-base-special-signum":"@stdlib/math/base/special/signum","@stdlib/math-base-special-signumf":"@stdlib/math/base/special/signumf","@stdlib/math-base-special-sin":"@stdlib/math/base/special/sin","@stdlib/math-base-special-sinc":"@stdlib/math/base/special/sinc","@stdlib/math-base-special-sincos":"@stdlib/math/base/special/sincos","@stdlib/math-base-special-sincospi":"@stdlib/math/base/special/sincospi","@stdlib/math-base-special-sinh":"@stdlib/math/base/special/sinh","@stdlib/math-base-special-sinpi":"@stdlib/math/base/special/sinpi","@stdlib/slice-base-slice2seq":"@stdlib/slice/base/slice2seq","@stdlib/slice-base-length":"@stdlib/slice/base/length","@stdlib/slice-base-nonreduced-dimensions":"@stdlib/slice/base/nonreduced-dimensions","@stdlib/slice-base-reduced-dimensions":"@stdlib/slice/base/reduced-dimensions","@stdlib/slice-base-shape":"@stdlib/slice/base/shape","@stdlib/string-base-snakecase":"@stdlib/string/base/snakecase","@stdlib/math-base-special-spence":"@stdlib/math/base/special/spence","@stdlib/math-base-special-sqrt":"@stdlib/math/base/special/sqrt","@stdlib/math-base-special-sqrt1pm1":"@stdlib/math/base/special/sqrt1pm1","@stdlib/math-base-special-sqrtf":"@stdlib/math/base/special/sqrtf","@stdlib/math-base-special-sqrtpi":"@stdlib/math/base/special/sqrtpi","@stdlib/string-base-startcase":"@stdlib/string/base/startcase","@stdlib/string-base-starts-with":"@stdlib/string/base/starts-with","@stdlib/string-base-stickycase":"@stdlib/string/base/stickycase","@stdlib/strided-base-binary":"@stdlib/strided/base/binary","@stdlib/strided-base-binary-dtype-signatures":"@stdlib/strided/base/binary-dtype-signatures","@stdlib/strided-base-binary-signature-callbacks":"@stdlib/strided/base/binary-signature-callbacks","@stdlib/blas-base-ccopy":"@stdlib/blas/base/ccopy","@stdlib/strided-base-cmap":"@stdlib/strided/base/cmap","@stdlib/blas-base-cswap":"@stdlib/blas/base/cswap","@stdlib/stats-base-cumax":"@stdlib/stats/base/cumax","@stdlib/stats-base-cumaxabs":"@stdlib/stats/base/cumaxabs","@stdlib/stats-base-cumin":"@stdlib/stats/base/cumin","@stdlib/stats-base-cuminabs":"@stdlib/stats/base/cuminabs","@stdlib/math-strided-special-dabs":"@stdlib/math/strided/special/dabs","@stdlib/math-strided-special-dabs2":"@stdlib/math/strided/special/dabs2","@stdlib/blas-ext-base-dapx":"@stdlib/blas/ext/base/dapx","@stdlib/blas-ext-base-dapxsum":"@stdlib/blas/ext/base/dapxsum","@stdlib/blas-ext-base-dapxsumkbn":"@stdlib/blas/ext/base/dapxsumkbn","@stdlib/blas-ext-base-dapxsumkbn2":"@stdlib/blas/ext/base/dapxsumkbn2","@stdlib/blas-ext-base-dapxsumors":"@stdlib/blas/ext/base/dapxsumors","@stdlib/blas-ext-base-dapxsumpw":"@stdlib/blas/ext/base/dapxsumpw","@stdlib/blas-base-dasum":"@stdlib/blas/base/dasum","@stdlib/blas-ext-base-dasumpw":"@stdlib/blas/ext/base/dasumpw","@stdlib/blas-base-daxpy":"@stdlib/blas/base/daxpy","@stdlib/math-strided-special-dcbrt":"@stdlib/math/strided/special/dcbrt","@stdlib/math-strided-special-dceil":"@stdlib/math/strided/special/dceil","@stdlib/blas-base-dcopy":"@stdlib/blas/base/dcopy","@stdlib/stats-strided-dcumax":"@stdlib/stats/strided/dcumax","@stdlib/stats-strided-dcumaxabs":"@stdlib/stats/strided/dcumaxabs","@stdlib/stats-base-dcumin":"@stdlib/stats/base/dcumin","@stdlib/stats-strided-dcuminabs":"@stdlib/stats/strided/dcuminabs","@stdlib/blas-ext-base-dcusum":"@stdlib/blas/ext/base/dcusum","@stdlib/blas-ext-base-dcusumkbn":"@stdlib/blas/ext/base/dcusumkbn","@stdlib/blas-ext-base-dcusumkbn2":"@stdlib/blas/ext/base/dcusumkbn2","@stdlib/blas-ext-base-dcusumors":"@stdlib/blas/ext/base/dcusumors","@stdlib/blas-ext-base-dcusumpw":"@stdlib/blas/ext/base/dcusumpw","@stdlib/math-strided-special-ddeg2rad":"@stdlib/math/strided/special/ddeg2rad","@stdlib/blas-base-ddot":"@stdlib/blas/base/ddot","@stdlib/blas-ext-base-dfill":"@stdlib/blas/ext/base/dfill","@stdlib/math-strided-special-dfloor":"@stdlib/math/strided/special/dfloor","@stdlib/math-strided-special-dinv":"@stdlib/math/strided/special/dinv","@stdlib/strided-base-dmap":"@stdlib/strided/base/dmap","@stdlib/strided-base-dmap2":"@stdlib/strided/base/dmap2","@stdlib/stats-strided-dmax":"@stdlib/stats/strided/dmax","@stdlib/stats-strided-dmaxabs":"@stdlib/stats/strided/dmaxabs","@stdlib/stats-strided-dmaxabssorted":"@stdlib/stats/strided/dmaxabssorted","@stdlib/stats-strided-dmaxsorted":"@stdlib/stats/strided/dmaxsorted","@stdlib/stats-base-dmean":"@stdlib/stats/base/dmean","@stdlib/stats-strided-dmeankbn":"@stdlib/stats/strided/dmeankbn","@stdlib/stats-strided-dmeankbn2":"@stdlib/stats/strided/dmeankbn2","@stdlib/stats-strided-dmeanli":"@stdlib/stats/strided/dmeanli","@stdlib/stats-strided-dmeanlipw":"@stdlib/stats/strided/dmeanlipw","@stdlib/stats-strided-dmeanors":"@stdlib/stats/strided/dmeanors","@stdlib/stats-base-dmeanpn":"@stdlib/stats/base/dmeanpn","@stdlib/stats-strided-dmeanpw":"@stdlib/stats/strided/dmeanpw","@stdlib/stats-base-dmeanstdev":"@stdlib/stats/base/dmeanstdev","@stdlib/stats-base-dmeanstdevpn":"@stdlib/stats/base/dmeanstdevpn","@stdlib/stats-base-dmeanvar":"@stdlib/stats/base/dmeanvar","@stdlib/stats-base-dmeanvarpn":"@stdlib/stats/base/dmeanvarpn","@stdlib/stats-strided-dmeanwd":"@stdlib/stats/strided/dmeanwd","@stdlib/stats-strided-dmediansorted":"@stdlib/stats/strided/dmediansorted","@stdlib/stats-strided-dmidrange":"@stdlib/stats/strided/dmidrange","@stdlib/stats-strided-dmin":"@stdlib/stats/strided/dmin","@stdlib/stats-strided-dminabs":"@stdlib/stats/strided/dminabs","@stdlib/stats-strided-dminsorted":"@stdlib/stats/strided/dminsorted","@stdlib/math-strided-special-dmskabs":"@stdlib/math/strided/special/dmskabs","@stdlib/math-strided-special-dmskabs2":"@stdlib/math/strided/special/dmskabs2","@stdlib/math-strided-special-dmskcbrt":"@stdlib/math/strided/special/dmskcbrt","@stdlib/math-strided-special-dmskceil":"@stdlib/math/strided/special/dmskceil","@stdlib/math-strided-special-dmskdeg2rad":"@stdlib/math/strided/special/dmskdeg2rad","@stdlib/math-strided-special-dmskfloor":"@stdlib/math/strided/special/dmskfloor","@stdlib/math-strided-special-dmskinv":"@stdlib/math/strided/special/dmskinv","@stdlib/strided-base-dmskmap":"@stdlib/strided/base/dmskmap","@stdlib/strided-base-dmskmap2":"@stdlib/strided/base/dmskmap2","@stdlib/stats-base-dmskmax":"@stdlib/stats/base/dmskmax","@stdlib/stats-base-dmskmin":"@stdlib/stats/base/dmskmin","@stdlib/math-strided-special-dmskramp":"@stdlib/math/strided/special/dmskramp","@stdlib/stats-base-dmskrange":"@stdlib/stats/base/dmskrange","@stdlib/math-strided-special-dmskrsqrt":"@stdlib/math/strided/special/dmskrsqrt","@stdlib/math-strided-special-dmsksqrt":"@stdlib/math/strided/special/dmsksqrt","@stdlib/math-strided-special-dmsktrunc":"@stdlib/math/strided/special/dmsktrunc","@stdlib/blas-ext-base-dnanasum":"@stdlib/blas/ext/base/dnanasum","@stdlib/blas-ext-base-dnanasumors":"@stdlib/blas/ext/base/dnanasumors","@stdlib/stats-strided-dnanmax":"@stdlib/stats/strided/dnanmax","@stdlib/stats-strided-dnanmaxabs":"@stdlib/stats/strided/dnanmaxabs","@stdlib/stats-strided-dnanmean":"@stdlib/stats/strided/dnanmean","@stdlib/stats-base-dnanmeanors":"@stdlib/stats/base/dnanmeanors","@stdlib/stats-base-dnanmeanpn":"@stdlib/stats/base/dnanmeanpn","@stdlib/stats-base-dnanmeanpw":"@stdlib/stats/base/dnanmeanpw","@stdlib/stats-base-dnanmeanwd":"@stdlib/stats/base/dnanmeanwd","@stdlib/stats-base-dnanmin":"@stdlib/stats/base/dnanmin","@stdlib/stats-base-dnanminabs":"@stdlib/stats/base/dnanminabs","@stdlib/stats-base-dnanmskmax":"@stdlib/stats/base/dnanmskmax","@stdlib/stats-base-dnanmskmin":"@stdlib/stats/base/dnanmskmin","@stdlib/stats-base-dnanmskrange":"@stdlib/stats/base/dnanmskrange","@stdlib/blas-ext-base-dnannsum":"@stdlib/blas/ext/base/dnannsum","@stdlib/blas-ext-base-dnannsumkbn":"@stdlib/blas/ext/base/dnannsumkbn","@stdlib/blas-ext-base-dnannsumkbn2":"@stdlib/blas/ext/base/dnannsumkbn2","@stdlib/blas-ext-base-dnannsumors":"@stdlib/blas/ext/base/dnannsumors","@stdlib/blas-ext-base-dnannsumpw":"@stdlib/blas/ext/base/dnannsumpw","@stdlib/stats-base-dnanrange":"@stdlib/stats/base/dnanrange","@stdlib/stats-base-dnanstdev":"@stdlib/stats/base/dnanstdev","@stdlib/stats-base-dnanstdevch":"@stdlib/stats/base/dnanstdevch","@stdlib/stats-base-dnanstdevpn":"@stdlib/stats/base/dnanstdevpn","@stdlib/stats-base-dnanstdevtk":"@stdlib/stats/base/dnanstdevtk","@stdlib/stats-base-dnanstdevwd":"@stdlib/stats/base/dnanstdevwd","@stdlib/stats-base-dnanstdevyc":"@stdlib/stats/base/dnanstdevyc","@stdlib/blas-ext-base-dnansum":"@stdlib/blas/ext/base/dnansum","@stdlib/blas-ext-base-dnansumkbn":"@stdlib/blas/ext/base/dnansumkbn","@stdlib/blas-ext-base-dnansumkbn2":"@stdlib/blas/ext/base/dnansumkbn2","@stdlib/blas-ext-base-dnansumors":"@stdlib/blas/ext/base/dnansumors","@stdlib/blas-ext-base-dnansumpw":"@stdlib/blas/ext/base/dnansumpw","@stdlib/stats-base-dnanvariance":"@stdlib/stats/base/dnanvariance","@stdlib/stats-base-dnanvariancech":"@stdlib/stats/base/dnanvariancech","@stdlib/stats-base-dnanvariancepn":"@stdlib/stats/base/dnanvariancepn","@stdlib/stats-base-dnanvariancetk":"@stdlib/stats/base/dnanvariancetk","@stdlib/stats-base-dnanvariancewd":"@stdlib/stats/base/dnanvariancewd","@stdlib/stats-base-dnanvarianceyc":"@stdlib/stats/base/dnanvarianceyc","@stdlib/blas-base-dnrm2":"@stdlib/blas/base/dnrm2","@stdlib/math-strided-special-dramp":"@stdlib/math/strided/special/dramp","@stdlib/stats-base-drange":"@stdlib/stats/base/drange","@stdlib/blas-ext-base-drev":"@stdlib/blas/ext/base/drev","@stdlib/math-strided-special-drsqrt":"@stdlib/math/strided/special/drsqrt","@stdlib/blas-ext-base-dsapxsum":"@stdlib/blas/ext/base/dsapxsum","@stdlib/blas-ext-base-dsapxsumpw":"@stdlib/blas/ext/base/dsapxsumpw","@stdlib/blas-base-dscal":"@stdlib/blas/base/dscal","@stdlib/blas-base-dsdot":"@stdlib/blas/base/dsdot","@stdlib/stats-base-dsem":"@stdlib/stats/base/dsem","@stdlib/stats-base-dsemch":"@stdlib/stats/base/dsemch","@stdlib/stats-base-dsempn":"@stdlib/stats/base/dsempn","@stdlib/stats-base-dsemtk":"@stdlib/stats/base/dsemtk","@stdlib/stats-base-dsemwd":"@stdlib/stats/base/dsemwd","@stdlib/stats-base-dsemyc":"@stdlib/stats/base/dsemyc","@stdlib/stats-base-dsmean":"@stdlib/stats/base/dsmean","@stdlib/stats-base-dsmeanors":"@stdlib/stats/base/dsmeanors","@stdlib/stats-base-dsmeanpn":"@stdlib/stats/base/dsmeanpn","@stdlib/stats-base-dsmeanpw":"@stdlib/stats/base/dsmeanpw","@stdlib/stats-base-dsmeanwd":"@stdlib/stats/base/dsmeanwd","@stdlib/stats-base-dsnanmean":"@stdlib/stats/base/dsnanmean","@stdlib/stats-base-dsnanmeanors":"@stdlib/stats/base/dsnanmeanors","@stdlib/stats-base-dsnanmeanpn":"@stdlib/stats/base/dsnanmeanpn","@stdlib/stats-base-dsnanmeanwd":"@stdlib/stats/base/dsnanmeanwd","@stdlib/blas-ext-base-dsnannsumors":"@stdlib/blas/ext/base/dsnannsumors","@stdlib/blas-ext-base-dsnansum":"@stdlib/blas/ext/base/dsnansum","@stdlib/blas-ext-base-dsnansumors":"@stdlib/blas/ext/base/dsnansumors","@stdlib/blas-ext-base-dsnansumpw":"@stdlib/blas/ext/base/dsnansumpw","@stdlib/blas-ext-base-dsort2hp":"@stdlib/blas/ext/base/dsort2hp","@stdlib/blas-ext-base-dsort2ins":"@stdlib/blas/ext/base/dsort2ins","@stdlib/blas-ext-base-dsort2sh":"@stdlib/blas/ext/base/dsort2sh","@stdlib/blas-ext-base-dsorthp":"@stdlib/blas/ext/base/dsorthp","@stdlib/blas-ext-base-dsortins":"@stdlib/blas/ext/base/dsortins","@stdlib/blas-ext-base-dsortsh":"@stdlib/blas/ext/base/dsortsh","@stdlib/math-strided-special-dsqrt":"@stdlib/math/strided/special/dsqrt","@stdlib/blas-ext-base-dssum":"@stdlib/blas/ext/base/dssum","@stdlib/blas-ext-base-dssumors":"@stdlib/blas/ext/base/dssumors","@stdlib/blas-ext-base-dssumpw":"@stdlib/blas/ext/base/dssumpw","@stdlib/stats-base-dstdev":"@stdlib/stats/base/dstdev","@stdlib/stats-base-dstdevch":"@stdlib/stats/base/dstdevch","@stdlib/stats-base-dstdevpn":"@stdlib/stats/base/dstdevpn","@stdlib/stats-base-dstdevtk":"@stdlib/stats/base/dstdevtk","@stdlib/stats-base-dstdevwd":"@stdlib/stats/base/dstdevwd","@stdlib/stats-base-dstdevyc":"@stdlib/stats/base/dstdevyc","@stdlib/blas-ext-base-dsum":"@stdlib/blas/ext/base/dsum","@stdlib/blas-ext-base-dsumkbn":"@stdlib/blas/ext/base/dsumkbn","@stdlib/blas-ext-base-dsumkbn2":"@stdlib/blas/ext/base/dsumkbn2","@stdlib/blas-ext-base-dsumors":"@stdlib/blas/ext/base/dsumors","@stdlib/blas-ext-base-dsumpw":"@stdlib/blas/ext/base/dsumpw","@stdlib/stats-base-dsvariance":"@stdlib/stats/base/dsvariance","@stdlib/stats-base-dsvariancepn":"@stdlib/stats/base/dsvariancepn","@stdlib/blas-base-dswap":"@stdlib/blas/base/dswap","@stdlib/math-strided-special-dtrunc":"@stdlib/math/strided/special/dtrunc","@stdlib/strided-base-dtype-enum2str":"@stdlib/strided/base/dtype-enum2str","@stdlib/strided-base-dtype-resolve-enum":"@stdlib/strided/base/dtype-resolve-enum","@stdlib/strided-base-dtype-resolve-str":"@stdlib/strided/base/dtype-resolve-str","@stdlib/strided-base-dtype-str2enum":"@stdlib/strided/base/dtype-str2enum","@stdlib/stats-base-dvariance":"@stdlib/stats/base/dvariance","@stdlib/stats-base-dvariancech":"@stdlib/stats/base/dvariancech","@stdlib/stats-base-dvariancepn":"@stdlib/stats/base/dvariancepn","@stdlib/stats-base-dvariancetk":"@stdlib/stats/base/dvariancetk","@stdlib/stats-base-dvariancewd":"@stdlib/stats/base/dvariancewd","@stdlib/stats-base-dvarianceyc":"@stdlib/stats/base/dvarianceyc","@stdlib/stats-base-dvarm":"@stdlib/stats/base/dvarm","@stdlib/stats-base-dvarmpn":"@stdlib/stats/base/dvarmpn","@stdlib/stats-base-dvarmtk":"@stdlib/stats/base/dvarmtk","@stdlib/strided-base-function-object":"@stdlib/strided/base/function-object","@stdlib/blas-ext-base-gapx":"@stdlib/blas/ext/base/gapx","@stdlib/blas-ext-base-gapxsum":"@stdlib/blas/ext/base/gapxsum","@stdlib/blas-ext-base-gapxsumkbn":"@stdlib/blas/ext/base/gapxsumkbn","@stdlib/blas-ext-base-gapxsumkbn2":"@stdlib/blas/ext/base/gapxsumkbn2","@stdlib/blas-ext-base-gapxsumors":"@stdlib/blas/ext/base/gapxsumors","@stdlib/blas-ext-base-gapxsumpw":"@stdlib/blas/ext/base/gapxsumpw","@stdlib/blas-base-gasum":"@stdlib/blas/base/gasum","@stdlib/blas-ext-base-gasumpw":"@stdlib/blas/ext/base/gasumpw","@stdlib/blas-base-gaxpy":"@stdlib/blas/base/gaxpy","@stdlib/blas-base-gcopy":"@stdlib/blas/base/gcopy","@stdlib/blas-ext-base-gcusum":"@stdlib/blas/ext/base/gcusum","@stdlib/blas-ext-base-gcusumkbn":"@stdlib/blas/ext/base/gcusumkbn","@stdlib/blas-ext-base-gcusumkbn2":"@stdlib/blas/ext/base/gcusumkbn2","@stdlib/blas-ext-base-gcusumors":"@stdlib/blas/ext/base/gcusumors","@stdlib/blas-ext-base-gcusumpw":"@stdlib/blas/ext/base/gcusumpw","@stdlib/blas-base-gdot":"@stdlib/blas/base/gdot","@stdlib/blas-ext-base-gfill":"@stdlib/blas/ext/base/gfill","@stdlib/blas-ext-base-gfill-by":"@stdlib/blas/ext/base/gfill-by","@stdlib/blas-ext-base-gnannsumkbn":"@stdlib/blas/ext/base/gnannsumkbn","@stdlib/blas-ext-base-gnansum":"@stdlib/blas/ext/base/gnansum","@stdlib/blas-ext-base-gnansumkbn":"@stdlib/blas/ext/base/gnansumkbn","@stdlib/blas-ext-base-gnansumkbn2":"@stdlib/blas/ext/base/gnansumkbn2","@stdlib/blas-ext-base-gnansumors":"@stdlib/blas/ext/base/gnansumors","@stdlib/blas-ext-base-gnansumpw":"@stdlib/blas/ext/base/gnansumpw","@stdlib/blas-base-gnrm2":"@stdlib/blas/base/gnrm2","@stdlib/blas-ext-base-grev":"@stdlib/blas/ext/base/grev","@stdlib/blas-base-gscal":"@stdlib/blas/base/gscal","@stdlib/blas-ext-base-gsort2hp":"@stdlib/blas/ext/base/gsort2hp","@stdlib/blas-ext-base-gsort2ins":"@stdlib/blas/ext/base/gsort2ins","@stdlib/blas-ext-base-gsort2sh":"@stdlib/blas/ext/base/gsort2sh","@stdlib/blas-ext-base-gsorthp":"@stdlib/blas/ext/base/gsorthp","@stdlib/blas-ext-base-gsortins":"@stdlib/blas/ext/base/gsortins","@stdlib/blas-ext-base-gsortsh":"@stdlib/blas/ext/base/gsortsh","@stdlib/blas-ext-base-gsum":"@stdlib/blas/ext/base/gsum","@stdlib/blas-ext-base-gsumkbn":"@stdlib/blas/ext/base/gsumkbn","@stdlib/blas-ext-base-gsumkbn2":"@stdlib/blas/ext/base/gsumkbn2","@stdlib/blas-ext-base-gsumors":"@stdlib/blas/ext/base/gsumors","@stdlib/blas-ext-base-gsumpw":"@stdlib/blas/ext/base/gsumpw","@stdlib/blas-base-gswap":"@stdlib/blas/base/gswap","@stdlib/strided-base-map-by":"@stdlib/strided/base/map-by","@stdlib/strided-base-map-by2":"@stdlib/strided/base/map-by2","@stdlib/stats-base-max":"@stdlib/stats/base/max","@stdlib/stats-base-maxabs":"@stdlib/stats/base/maxabs","@stdlib/stats-base-max-by":"@stdlib/stats/base/max-by","@stdlib/stats-base-maxsorted":"@stdlib/stats/base/maxsorted","@stdlib/strided-base-max-view-buffer-index":"@stdlib/strided/base/max-view-buffer-index","@stdlib/stats-base-mean":"@stdlib/stats/base/mean","@stdlib/stats-base-meankbn":"@stdlib/stats/base/meankbn","@stdlib/stats-base-meankbn2":"@stdlib/stats/base/meankbn2","@stdlib/stats-base-meanors":"@stdlib/stats/base/meanors","@stdlib/stats-base-meanpn":"@stdlib/stats/base/meanpn","@stdlib/stats-base-meanpw":"@stdlib/stats/base/meanpw","@stdlib/stats-base-meanwd":"@stdlib/stats/base/meanwd","@stdlib/stats-base-mediansorted":"@stdlib/stats/base/mediansorted","@stdlib/strided-base-meta-data-props":"@stdlib/strided/base/meta-data-props","@stdlib/stats-base-min":"@stdlib/stats/base/min","@stdlib/stats-base-minabs":"@stdlib/stats/base/minabs","@stdlib/stats-base-min-by":"@stdlib/stats/base/min-by","@stdlib/stats-base-minsorted":"@stdlib/stats/base/minsorted","@stdlib/strided-base-min-view-buffer-index":"@stdlib/strided/base/min-view-buffer-index","@stdlib/stats-base-mskmax":"@stdlib/stats/base/mskmax","@stdlib/stats-base-mskmin":"@stdlib/stats/base/mskmin","@stdlib/stats-base-mskrange":"@stdlib/stats/base/mskrange","@stdlib/strided-base-mskunary":"@stdlib/strided/base/mskunary","@stdlib/strided-base-mskunary-dtype-signatures":"@stdlib/strided/base/mskunary-dtype-signatures","@stdlib/strided-base-mskunary-signature-callbacks":"@stdlib/strided/base/mskunary-signature-callbacks","@stdlib/stats-base-nanmax":"@stdlib/stats/base/nanmax","@stdlib/stats-base-nanmaxabs":"@stdlib/stats/base/nanmaxabs","@stdlib/stats-base-nanmax-by":"@stdlib/stats/base/nanmax-by","@stdlib/stats-base-nanmean":"@stdlib/stats/base/nanmean","@stdlib/stats-base-nanmeanors":"@stdlib/stats/base/nanmeanors","@stdlib/stats-base-nanmeanpn":"@stdlib/stats/base/nanmeanpn","@stdlib/stats-base-nanmeanwd":"@stdlib/stats/base/nanmeanwd","@stdlib/stats-base-nanmin":"@stdlib/stats/base/nanmin","@stdlib/stats-base-nanminabs":"@stdlib/stats/base/nanminabs","@stdlib/stats-base-nanmin-by":"@stdlib/stats/base/nanmin-by","@stdlib/stats-base-nanmskmax":"@stdlib/stats/base/nanmskmax","@stdlib/stats-base-nanmskmin":"@stdlib/stats/base/nanmskmin","@stdlib/stats-base-nanmskrange":"@stdlib/stats/base/nanmskrange","@stdlib/stats-base-nanrange":"@stdlib/stats/base/nanrange","@stdlib/stats-base-nanrange-by":"@stdlib/stats/base/nanrange-by","@stdlib/stats-base-nanstdev":"@stdlib/stats/base/nanstdev","@stdlib/stats-base-nanstdevch":"@stdlib/stats/base/nanstdevch","@stdlib/stats-base-nanstdevpn":"@stdlib/stats/base/nanstdevpn","@stdlib/stats-base-nanstdevtk":"@stdlib/stats/base/nanstdevtk","@stdlib/stats-base-nanstdevwd":"@stdlib/stats/base/nanstdevwd","@stdlib/stats-base-nanstdevyc":"@stdlib/stats/base/nanstdevyc","@stdlib/stats-base-nanvariance":"@stdlib/stats/base/nanvariance","@stdlib/stats-base-nanvariancech":"@stdlib/stats/base/nanvariancech","@stdlib/stats-base-nanvariancepn":"@stdlib/stats/base/nanvariancepn","@stdlib/stats-base-nanvariancetk":"@stdlib/stats/base/nanvariancetk","@stdlib/stats-base-nanvariancewd":"@stdlib/stats/base/nanvariancewd","@stdlib/stats-base-nanvarianceyc":"@stdlib/stats/base/nanvarianceyc","@stdlib/strided-base-nullary":"@stdlib/strided/base/nullary","@stdlib/strided-base-offset-view":"@stdlib/strided/base/offset-view","@stdlib/strided-base-quaternary":"@stdlib/strided/base/quaternary","@stdlib/strided-base-quinary":"@stdlib/strided/base/quinary","@stdlib/stats-base-range":"@stdlib/stats/base/range","@stdlib/stats-base-range-by":"@stdlib/stats/base/range-by","@stdlib/strided-base-reinterpret-complex":"@stdlib/strided/base/reinterpret-complex","@stdlib/strided-base-reinterpret-complex64":"@stdlib/strided/base/reinterpret-complex64","@stdlib/strided-base-reinterpret-complex128":"@stdlib/strided/base/reinterpret-complex128","@stdlib/math-strided-special-sabs":"@stdlib/math/strided/special/sabs","@stdlib/math-strided-special-sabs2":"@stdlib/math/strided/special/sabs2","@stdlib/blas-ext-base-sapx":"@stdlib/blas/ext/base/sapx","@stdlib/blas-ext-base-sapxsum":"@stdlib/blas/ext/base/sapxsum","@stdlib/blas-ext-base-sapxsumkbn":"@stdlib/blas/ext/base/sapxsumkbn","@stdlib/blas-ext-base-sapxsumkbn2":"@stdlib/blas/ext/base/sapxsumkbn2","@stdlib/blas-ext-base-sapxsumors":"@stdlib/blas/ext/base/sapxsumors","@stdlib/blas-ext-base-sapxsumpw":"@stdlib/blas/ext/base/sapxsumpw","@stdlib/blas-base-sasum":"@stdlib/blas/base/sasum","@stdlib/blas-ext-base-sasumpw":"@stdlib/blas/ext/base/sasumpw","@stdlib/blas-base-saxpy":"@stdlib/blas/base/saxpy","@stdlib/math-strided-special-scbrt":"@stdlib/math/strided/special/scbrt","@stdlib/math-strided-special-sceil":"@stdlib/math/strided/special/sceil","@stdlib/blas-base-scopy":"@stdlib/blas/base/scopy","@stdlib/stats-base-scumax":"@stdlib/stats/base/scumax","@stdlib/stats-base-scumaxabs":"@stdlib/stats/base/scumaxabs","@stdlib/stats-base-scumin":"@stdlib/stats/base/scumin","@stdlib/stats-base-scuminabs":"@stdlib/stats/base/scuminabs","@stdlib/blas-ext-base-scusum":"@stdlib/blas/ext/base/scusum","@stdlib/blas-ext-base-scusumkbn":"@stdlib/blas/ext/base/scusumkbn","@stdlib/blas-ext-base-scusumkbn2":"@stdlib/blas/ext/base/scusumkbn2","@stdlib/blas-ext-base-scusumors":"@stdlib/blas/ext/base/scusumors","@stdlib/blas-ext-base-scusumpw":"@stdlib/blas/ext/base/scusumpw","@stdlib/math-strided-special-sdeg2rad":"@stdlib/math/strided/special/sdeg2rad","@stdlib/blas-base-sdot":"@stdlib/blas/base/sdot","@stdlib/blas-ext-base-sdsapxsum":"@stdlib/blas/ext/base/sdsapxsum","@stdlib/blas-ext-base-sdsapxsumpw":"@stdlib/blas/ext/base/sdsapxsumpw","@stdlib/blas-base-sdsdot":"@stdlib/blas/base/sdsdot","@stdlib/stats-base-sdsmean":"@stdlib/stats/base/sdsmean","@stdlib/stats-base-sdsmeanors":"@stdlib/stats/base/sdsmeanors","@stdlib/stats-base-sdsnanmean":"@stdlib/stats/base/sdsnanmean","@stdlib/stats-base-sdsnanmeanors":"@stdlib/stats/base/sdsnanmeanors","@stdlib/blas-ext-base-sdsnansum":"@stdlib/blas/ext/base/sdsnansum","@stdlib/blas-ext-base-sdsnansumpw":"@stdlib/blas/ext/base/sdsnansumpw","@stdlib/blas-ext-base-sdssum":"@stdlib/blas/ext/base/sdssum","@stdlib/blas-ext-base-sdssumpw":"@stdlib/blas/ext/base/sdssumpw","@stdlib/blas-ext-base-sfill":"@stdlib/blas/ext/base/sfill","@stdlib/math-strided-special-sfloor":"@stdlib/math/strided/special/sfloor","@stdlib/math-strided-special-sinv":"@stdlib/math/strided/special/sinv","@stdlib/strided-base-smap":"@stdlib/strided/base/smap","@stdlib/strided-base-smap2":"@stdlib/strided/base/smap2","@stdlib/stats-base-smax":"@stdlib/stats/base/smax","@stdlib/stats-base-smaxabs":"@stdlib/stats/base/smaxabs","@stdlib/stats-base-smaxabssorted":"@stdlib/stats/base/smaxabssorted","@stdlib/stats-base-smaxsorted":"@stdlib/stats/base/smaxsorted","@stdlib/stats-base-smean":"@stdlib/stats/base/smean","@stdlib/stats-base-smeankbn":"@stdlib/stats/base/smeankbn","@stdlib/stats-base-smeankbn2":"@stdlib/stats/base/smeankbn2","@stdlib/stats-base-smeanli":"@stdlib/stats/base/smeanli","@stdlib/stats-base-smeanlipw":"@stdlib/stats/base/smeanlipw","@stdlib/stats-base-smeanors":"@stdlib/stats/base/smeanors","@stdlib/stats-base-smeanpn":"@stdlib/stats/base/smeanpn","@stdlib/stats-base-smeanpw":"@stdlib/stats/base/smeanpw","@stdlib/stats-base-smeanwd":"@stdlib/stats/base/smeanwd","@stdlib/stats-base-smediansorted":"@stdlib/stats/base/smediansorted","@stdlib/stats-base-smidrange":"@stdlib/stats/base/smidrange","@stdlib/stats-base-smin":"@stdlib/stats/base/smin","@stdlib/stats-base-sminabs":"@stdlib/stats/base/sminabs","@stdlib/stats-base-sminsorted":"@stdlib/stats/base/sminsorted","@stdlib/math-strided-special-smskabs":"@stdlib/math/strided/special/smskabs","@stdlib/math-strided-special-smskabs2":"@stdlib/math/strided/special/smskabs2","@stdlib/math-strided-special-smskcbrt":"@stdlib/math/strided/special/smskcbrt","@stdlib/math-strided-special-smskceil":"@stdlib/math/strided/special/smskceil","@stdlib/math-strided-special-smskdeg2rad":"@stdlib/math/strided/special/smskdeg2rad","@stdlib/math-strided-special-smskfloor":"@stdlib/math/strided/special/smskfloor","@stdlib/math-strided-special-smskinv":"@stdlib/math/strided/special/smskinv","@stdlib/strided-base-smskmap":"@stdlib/strided/base/smskmap","@stdlib/strided-base-smskmap2":"@stdlib/strided/base/smskmap2","@stdlib/stats-base-smskmax":"@stdlib/stats/base/smskmax","@stdlib/stats-base-smskmin":"@stdlib/stats/base/smskmin","@stdlib/math-strided-special-smskramp":"@stdlib/math/strided/special/smskramp","@stdlib/stats-base-smskrange":"@stdlib/stats/base/smskrange","@stdlib/math-strided-special-smskrsqrt":"@stdlib/math/strided/special/smskrsqrt","@stdlib/math-strided-special-smsksqrt":"@stdlib/math/strided/special/smsksqrt","@stdlib/math-strided-special-smsktrunc":"@stdlib/math/strided/special/smsktrunc","@stdlib/stats-base-snanmax":"@stdlib/stats/base/snanmax","@stdlib/stats-base-snanmaxabs":"@stdlib/stats/base/snanmaxabs","@stdlib/stats-base-snanmean":"@stdlib/stats/base/snanmean","@stdlib/stats-base-snanmeanors":"@stdlib/stats/base/snanmeanors","@stdlib/stats-base-snanmeanpn":"@stdlib/stats/base/snanmeanpn","@stdlib/stats-base-snanmeanwd":"@stdlib/stats/base/snanmeanwd","@stdlib/stats-base-snanmin":"@stdlib/stats/base/snanmin","@stdlib/stats-base-snanminabs":"@stdlib/stats/base/snanminabs","@stdlib/stats-base-snanmskmax":"@stdlib/stats/base/snanmskmax","@stdlib/stats-base-snanmskmin":"@stdlib/stats/base/snanmskmin","@stdlib/stats-base-snanmskrange":"@stdlib/stats/base/snanmskrange","@stdlib/stats-base-snanrange":"@stdlib/stats/base/snanrange","@stdlib/stats-base-snanstdev":"@stdlib/stats/base/snanstdev","@stdlib/stats-base-snanstdevch":"@stdlib/stats/base/snanstdevch","@stdlib/stats-base-snanstdevpn":"@stdlib/stats/base/snanstdevpn","@stdlib/stats-base-snanstdevtk":"@stdlib/stats/base/snanstdevtk","@stdlib/stats-base-snanstdevwd":"@stdlib/stats/base/snanstdevwd","@stdlib/stats-base-snanstdevyc":"@stdlib/stats/base/snanstdevyc","@stdlib/blas-ext-base-snansum":"@stdlib/blas/ext/base/snansum","@stdlib/blas-ext-base-snansumkbn":"@stdlib/blas/ext/base/snansumkbn","@stdlib/blas-ext-base-snansumkbn2":"@stdlib/blas/ext/base/snansumkbn2","@stdlib/blas-ext-base-snansumors":"@stdlib/blas/ext/base/snansumors","@stdlib/blas-ext-base-snansumpw":"@stdlib/blas/ext/base/snansumpw","@stdlib/stats-base-snanvariance":"@stdlib/stats/base/snanvariance","@stdlib/stats-base-snanvariancech":"@stdlib/stats/base/snanvariancech","@stdlib/stats-base-snanvariancepn":"@stdlib/stats/base/snanvariancepn","@stdlib/stats-base-snanvariancetk":"@stdlib/stats/base/snanvariancetk","@stdlib/stats-base-snanvariancewd":"@stdlib/stats/base/snanvariancewd","@stdlib/stats-base-snanvarianceyc":"@stdlib/stats/base/snanvarianceyc","@stdlib/blas-base-snrm2":"@stdlib/blas/base/snrm2","@stdlib/math-strided-special-sramp":"@stdlib/math/strided/special/sramp","@stdlib/stats-base-srange":"@stdlib/stats/base/srange","@stdlib/blas-ext-base-srev":"@stdlib/blas/ext/base/srev","@stdlib/math-strided-special-srsqrt":"@stdlib/math/strided/special/srsqrt","@stdlib/blas-base-sscal":"@stdlib/blas/base/sscal","@stdlib/blas-ext-base-ssort2hp":"@stdlib/blas/ext/base/ssort2hp","@stdlib/blas-ext-base-ssort2ins":"@stdlib/blas/ext/base/ssort2ins","@stdlib/blas-ext-base-ssort2sh":"@stdlib/blas/ext/base/ssort2sh","@stdlib/blas-ext-base-ssorthp":"@stdlib/blas/ext/base/ssorthp","@stdlib/blas-ext-base-ssortins":"@stdlib/blas/ext/base/ssortins","@stdlib/blas-ext-base-ssortsh":"@stdlib/blas/ext/base/ssortsh","@stdlib/math-strided-special-ssqrt":"@stdlib/math/strided/special/ssqrt","@stdlib/stats-base-sstdev":"@stdlib/stats/base/sstdev","@stdlib/stats-base-sstdevch":"@stdlib/stats/base/sstdevch","@stdlib/stats-base-sstdevpn":"@stdlib/stats/base/sstdevpn","@stdlib/stats-base-sstdevtk":"@stdlib/stats/base/sstdevtk","@stdlib/stats-base-sstdevwd":"@stdlib/stats/base/sstdevwd","@stdlib/stats-base-sstdevyc":"@stdlib/stats/base/sstdevyc","@stdlib/blas-ext-base-ssum":"@stdlib/blas/ext/base/ssum","@stdlib/blas-ext-base-ssumkbn":"@stdlib/blas/ext/base/ssumkbn","@stdlib/blas-ext-base-ssumkbn2":"@stdlib/blas/ext/base/ssumkbn2","@stdlib/blas-ext-base-ssumors":"@stdlib/blas/ext/base/ssumors","@stdlib/blas-ext-base-ssumpw":"@stdlib/blas/ext/base/ssumpw","@stdlib/blas-base-sswap":"@stdlib/blas/base/sswap","@stdlib/stats-base-stdev":"@stdlib/stats/base/stdev","@stdlib/stats-base-stdevch":"@stdlib/stats/base/stdevch","@stdlib/stats-base-stdevpn":"@stdlib/stats/base/stdevpn","@stdlib/stats-base-stdevtk":"@stdlib/stats/base/stdevtk","@stdlib/stats-base-stdevwd":"@stdlib/stats/base/stdevwd","@stdlib/stats-base-stdevyc":"@stdlib/stats/base/stdevyc","@stdlib/math-strided-special-strunc":"@stdlib/math/strided/special/strunc","@stdlib/stats-base-svariance":"@stdlib/stats/base/svariance","@stdlib/stats-base-svariancech":"@stdlib/stats/base/svariancech","@stdlib/stats-base-svariancepn":"@stdlib/stats/base/svariancepn","@stdlib/stats-base-svariancetk":"@stdlib/stats/base/svariancetk","@stdlib/stats-base-svariancewd":"@stdlib/stats/base/svariancewd","@stdlib/stats-base-svarianceyc":"@stdlib/stats/base/svarianceyc","@stdlib/strided-base-ternary":"@stdlib/strided/base/ternary","@stdlib/strided-base-unary":"@stdlib/strided/base/unary","@stdlib/strided-base-unary-by":"@stdlib/strided/base/unary-by","@stdlib/strided-base-unary-dtype-signatures":"@stdlib/strided/base/unary-dtype-signatures","@stdlib/strided-base-unary-signature-callbacks":"@stdlib/strided/base/unary-signature-callbacks","@stdlib/stats-base-variance":"@stdlib/stats/base/variance","@stdlib/stats-base-variancech":"@stdlib/stats/base/variancech","@stdlib/stats-base-variancepn":"@stdlib/stats/base/variancepn","@stdlib/stats-base-variancetk":"@stdlib/stats/base/variancetk","@stdlib/stats-base-variancewd":"@stdlib/stats/base/variancewd","@stdlib/stats-base-varianceyc":"@stdlib/stats/base/varianceyc","@stdlib/strided-base-zmap":"@stdlib/strided/base/zmap","@stdlib/slice-base-str2multislice":"@stdlib/slice/base/str2multislice","@stdlib/slice-base-str2slice":"@stdlib/slice/base/str2slice","@stdlib/number-float64-base-sub":"@stdlib/number/float64/base/sub","@stdlib/math-base-ops-subf":"@stdlib/math/base/ops/subf","@stdlib/math-base-tools-sum-series":"@stdlib/math/base/tools/sum-series","@stdlib/math-base-special-tan":"@stdlib/math/base/special/tan","@stdlib/math-base-special-tand":"@stdlib/math/base/special/tand","@stdlib/math-base-special-tanh":"@stdlib/math/base/special/tanh","@stdlib/number-float64-base-to-binary-string":"@stdlib/number/float64/base/to-binary-string","@stdlib/number-float32-base-to-binary-string":"@stdlib/number/float32/base/to-binary-string","@stdlib/number-uint8-base-to-binary-string":"@stdlib/number/uint8/base/to-binary-string","@stdlib/number-uint16-base-to-binary-string":"@stdlib/number/uint16/base/to-binary-string","@stdlib/number-uint32-base-to-binary-string":"@stdlib/number/uint32/base/to-binary-string","@stdlib/number-float32-base-to-word":"@stdlib/number/float32/base/to-word","@stdlib/number-float64-base-to-words":"@stdlib/number/float64/base/to-words","@stdlib/ndarray-base-transpose":"@stdlib/ndarray/base/transpose","@stdlib/math-base-special-tribonacci":"@stdlib/math/base/special/tribonacci","@stdlib/math-base-special-trigamma":"@stdlib/math/base/special/trigamma","@stdlib/string-base-trim":"@stdlib/string/base/trim","@stdlib/math-base-special-trunc":"@stdlib/math/base/special/trunc","@stdlib/math-base-special-trunc2":"@stdlib/math/base/special/trunc2","@stdlib/math-base-special-trunc10":"@stdlib/math/base/special/trunc10","@stdlib/string-base-truncate-middle":"@stdlib/string/base/truncate-middle","@stdlib/math-base-special-truncb":"@stdlib/math/base/special/truncb","@stdlib/math-base-special-truncf":"@stdlib/math/base/special/truncf","@stdlib/math-base-special-truncn":"@stdlib/math/base/special/truncn","@stdlib/math-base-special-truncsd":"@stdlib/math/base/special/truncsd","@stdlib/number-uint32-base-to-int32":"@stdlib/number/uint32/base/to-int32","@stdlib/math-base-ops-umul":"@stdlib/number/uint32/base/mul","@stdlib/math-base-ops-umuldw":"@stdlib/math/base/ops/umuldw","@stdlib/string-base-uncapitalize":"@stdlib/string/base/uncapitalize","@stdlib/string-base-uppercase":"@stdlib/string/base/uppercase","@stdlib/math-base-special-vercos":"@stdlib/math/base/special/vercos","@stdlib/math-base-special-versin":"@stdlib/math/base/special/versin","@stdlib/math-base-special-wrap":"@stdlib/math/base/special/wrap","@stdlib/math-base-special-xlog1py":"@stdlib/math/base/special/xlog1py","@stdlib/math-base-special-xlogy":"@stdlib/math/base/special/xlogy","@stdlib/math-base-special-riemann-zeta":"@stdlib/math/base/special/riemann-zeta","@stdlib/bench":"@stdlib/bench","@stdlib/datasets-berndt-cps-wages-1985":"@stdlib/datasets/berndt-cps-wages-1985","@stdlib/utils-bifurcate":"@stdlib/utils/bifurcate","@stdlib/utils-bifurcate-by":"@stdlib/utils/bifurcate-by","@stdlib/utils-async-bifurcate-by":"@stdlib/utils/async/bifurcate-by","@stdlib/utils-bifurcate-in":"@stdlib/utils/bifurcate-in","@stdlib/utils-bifurcate-own":"@stdlib/utils/bifurcate-own","@stdlib/bigint-ctor":"@stdlib/bigint/ctor","@stdlib/stats-binomial-test":"@stdlib/stats/binomial-test","@stdlib/boolean-ctor":"@stdlib/boolean/ctor","@stdlib/array-bool":"@stdlib/array/bool","@stdlib/ndarray-broadcast-array":"@stdlib/ndarray/broadcast-array","@stdlib/ndarray-broadcast-arrays":"@stdlib/ndarray/broadcast-arrays","@stdlib/buffer-ctor":"@stdlib/buffer/ctor","@stdlib/buffer-to-json":"@stdlib/buffer/to-json","@stdlib/os-byte-order":"@stdlib/os/byte-order","@stdlib/string-camelcase":"@stdlib/string/camelcase","@stdlib/string-capitalize":"@stdlib/string/capitalize","@stdlib/utils-capitalize-keys":"@stdlib/utils/capitalize-keys","@stdlib/constants-float64-catalan":"@stdlib/constants/float64/catalan","@stdlib/constants-float64-cbrt-eps":"@stdlib/constants/float64/cbrt-eps","@stdlib/datasets-cdc-nchs-us-births-1969-1988":"@stdlib/datasets/cdc-nchs-us-births-1969-1988","@stdlib/datasets-cdc-nchs-us-births-1994-2003":"@stdlib/datasets/cdc-nchs-us-births-1994-2003","@stdlib/datasets-cdc-nchs-us-infant-mortality-bw-1915-2013":"@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013","@stdlib/process-chdir":"@stdlib/process/chdir","@stdlib/stats-chi2gof":"@stdlib/stats/chi2gof","@stdlib/stats-chi2test":"@stdlib/stats/chi2test","@stdlib/array-to-circular-iterator":"@stdlib/array/to-circular-iterator","@stdlib/streams-node-from-circular-array":"@stdlib/streams/node/from-circular-array","@stdlib/dstructs-circular-buffer":"@stdlib/dstructs/circular-buffer","@stdlib/fs-close":"@stdlib/fs/close","@stdlib/datasets-cmudict":"@stdlib/datasets/cmudict","@stdlib/string-code-point-at":"@stdlib/string/code-point-at","@stdlib/utils-common-keys":"@stdlib/utils/common-keys","@stdlib/utils-common-keys-in":"@stdlib/utils/common-keys-in","@stdlib/complex-cmplx":"@stdlib/complex/cmplx","@stdlib/complex-float32-ctor":"@stdlib/complex/float32/ctor","@stdlib/constants-complex64-nan":"@stdlib/constants/complex64/nan","@stdlib/constants-complex64-num-bytes":"@stdlib/constants/complex64/num-bytes","@stdlib/constants-complex64-zero":"@stdlib/constants/complex64/zero","@stdlib/array-complex64":"@stdlib/array/complex64","@stdlib/complex-float64-ctor":"@stdlib/complex/float64/ctor","@stdlib/constants-complex128-nan":"@stdlib/constants/complex128/nan","@stdlib/constants-complex128-num-bytes":"@stdlib/constants/complex128/num-bytes","@stdlib/constants-complex128-zero":"@stdlib/constants/complex128/zero","@stdlib/array-complex128":"@stdlib/array/complex128","@stdlib/array-typed-complex":"@stdlib/array/typed-complex","@stdlib/array-typed-complex-ctors":"@stdlib/array/typed-complex-ctors","@stdlib/array-typed-complex-dtypes":"@stdlib/array/typed-complex-dtypes","@stdlib/complex-ctors":"@stdlib/complex/ctors","@stdlib/complex-dtype":"@stdlib/complex/dtype","@stdlib/complex-dtypes":"@stdlib/complex/dtypes","@stdlib/complex-promotion-rules":"@stdlib/complex/promotion-rules","@stdlib/utils-compose":"@stdlib/utils/compose","@stdlib/utils-async-compose":"@stdlib/utils/async/compose","@stdlib/os-configdir":"@stdlib/os/configdir","@stdlib/complex-float64-conj":"@stdlib/complex/float64/conj","@stdlib/complex-float32-conj":"@stdlib/complex/float32/conj","@stdlib/string-constantcase":"@stdlib/string/constantcase","@stdlib/utils-constant-function":"@stdlib/utils/constant-function","@stdlib/streams-node-from-constant":"@stdlib/streams/node/from-constant","@stdlib/utils-constructor-name":"@stdlib/utils/constructor-name","@stdlib/assert-contains":"@stdlib/assert/contains","@stdlib/array-convert":"@stdlib/array/convert","@stdlib/array-convert-same":"@stdlib/array/convert-same","@stdlib/utils-convert-path":"@stdlib/utils/convert-path","@stdlib/utils-copy":"@stdlib/utils/copy","@stdlib/buffer-from-buffer":"@stdlib/buffer/from-buffer","@stdlib/utils-count-by":"@stdlib/utils/count-by","@stdlib/utils-async-count-by":"@stdlib/utils/async/count-by","@stdlib/time-current-year":"@stdlib/time/current-year","@stdlib/utils-curry":"@stdlib/utils/curry","@stdlib/utils-curry-right":"@stdlib/utils/curry-right","@stdlib/process-cwd":"@stdlib/process/cwd","@stdlib/datasets-dale-chall-new":"@stdlib/datasets/dale-chall-new","@stdlib/datasets":"@stdlib/datasets","@stdlib/array-dataview":"@stdlib/array/dataview","@stdlib/array-datespace":"@stdlib/array/datespace","@stdlib/time-day-of-quarter":"@stdlib/time/day-of-quarter","@stdlib/time-day-of-year":"@stdlib/time/day-of-year","@stdlib/time-days-in-month":"@stdlib/time/days-in-month","@stdlib/time-days-in-year":"@stdlib/time/days-in-year","@stdlib/blas-ddot":"@stdlib/blas/ddot","@stdlib/streams-node-debug-sink":"@stdlib/streams/node/debug-sink","@stdlib/streams-node-debug":"@stdlib/streams/node/debug","@stdlib/utils-decorate-after":"@stdlib/utils/decorate-after","@stdlib/assert-deep-equal":"@stdlib/assert/deep-equal","@stdlib/utils-deep-get":"@stdlib/utils/deep-get","@stdlib/assert-deep-has-own-property":"@stdlib/assert/deep-has-own-property","@stdlib/assert-deep-has-property":"@stdlib/assert/deep-has-property","@stdlib/utils-deep-pluck":"@stdlib/utils/deep-pluck","@stdlib/utils-deep-set":"@stdlib/utils/deep-set","@stdlib/utils-define-memoized-property":"@stdlib/utils/define-memoized-property","@stdlib/utils-define-properties":"@stdlib/utils/define-properties","@stdlib/utils-define-property":"@stdlib/utils/define-property","@stdlib/utils-dirname":"@stdlib/utils/dirname","@stdlib/string-dotcase":"@stdlib/string/dotcase","@stdlib/dstructs-doubly-linked-list":"@stdlib/dstructs/doubly-linked-list","@stdlib/utils-do-until":"@stdlib/utils/do-until","@stdlib/utils-async-do-until":"@stdlib/utils/async/do-until","@stdlib/utils-do-until-each":"@stdlib/utils/do-until-each","@stdlib/utils-do-until-each-right":"@stdlib/utils/do-until-each-right","@stdlib/utils-do-while":"@stdlib/utils/do-while","@stdlib/utils-async-do-while":"@stdlib/utils/async/do-while","@stdlib/utils-do-while-each":"@stdlib/utils/do-while-each","@stdlib/utils-do-while-each-right":"@stdlib/utils/do-while-each-right","@stdlib/blas-dswap":"@stdlib/blas/dswap","@stdlib/constants-float64-e":"@stdlib/constants/float64/e","@stdlib/datasets-emoji":"@stdlib/datasets/emoji","@stdlib/datasets-emoji-code-picto":"@stdlib/datasets/emoji-code-picto","@stdlib/datasets-emoji-picto-code":"@stdlib/datasets/emoji-picto-code","@stdlib/streams-node-empty":"@stdlib/streams/node/empty","@stdlib/string-ends-with":"@stdlib/string/ends-with","@stdlib/utils-enumerable-properties":"@stdlib/utils/enumerable-properties","@stdlib/utils-enumerable-properties-in":"@stdlib/utils/enumerable-properties-in","@stdlib/utils-enumerable-property-symbols":"@stdlib/utils/enumerable-property-symbols","@stdlib/utils-enumerable-property-symbols-in":"@stdlib/utils/enumerable-property-symbols-in","@stdlib/process-env":"@stdlib/process/env","@stdlib/constants-float64-eps":"@stdlib/constants/float64/eps","@stdlib/error-to-json":"@stdlib/error/to-json","@stdlib/constants-float64-eulergamma":"@stdlib/constants/float64/eulergamma","@stdlib/utils-every":"@stdlib/utils/every","@stdlib/utils-every-by":"@stdlib/utils/every-by","@stdlib/utils-async-every-by":"@stdlib/utils/async/every-by","@stdlib/utils-every-by-right":"@stdlib/utils/every-by-right","@stdlib/utils-async-every-by-right":"@stdlib/utils/async/every-by-right","@stdlib/utils-every-in-by":"@stdlib/utils/every-in-by","@stdlib/utils-every-own-by":"@stdlib/utils/every-own-by","@stdlib/utils-eval":"@stdlib/utils/eval","@stdlib/process-exec-path":"@stdlib/process/exec-path","@stdlib/fs-exists":"@stdlib/fs/exists","@stdlib/nlp-expand-acronyms":"@stdlib/nlp/expand-acronyms","@stdlib/nlp-expand-contractions":"@stdlib/nlp/expand-contractions","@stdlib/utils-extname":"@stdlib/utils/extname","@stdlib/ndarray-fancy":"@stdlib/ndarray/fancy","@stdlib/math-base-special-fast-abs":"@stdlib/math/base/special/fast/abs","@stdlib/math-base-special-fast-acosh":"@stdlib/math/base/special/fast/acosh","@stdlib/math-base-special-fast-alpha-max-plus-beta-min":"@stdlib/math/base/special/fast/alpha-max-plus-beta-min","@stdlib/math-base-special-fast-asinh":"@stdlib/math/base/special/fast/asinh","@stdlib/math-base-special-fast-atanh":"@stdlib/math/base/special/fast/atanh","@stdlib/math-base-special-fast-hypot":"@stdlib/math/base/special/fast/hypot","@stdlib/math-base-special-fast-uint32-log2":"@stdlib/math/base/special/fast/uint32-log2","@stdlib/math-base-special-fast-max":"@stdlib/math/base/special/fast/max","@stdlib/math-base-special-fast-min":"@stdlib/math/base/special/fast/min","@stdlib/math-base-special-fast-pow-int":"@stdlib/math/base/special/fast/pow-int","@stdlib/math-base-special-fast-uint32-sqrt":"@stdlib/math/base/special/fast/uint32-sqrt","@stdlib/datasets-female-first-names-en":"@stdlib/datasets/female-first-names-en","@stdlib/dstructs-fifo":"@stdlib/dstructs/fifo","@stdlib/array-filled":"@stdlib/array/filled","@stdlib/array-filled-by":"@stdlib/array/filled-by","@stdlib/utils-filter-arguments":"@stdlib/utils/filter-arguments","@stdlib/utils-find":"@stdlib/utils/find","@stdlib/string-first":"@stdlib/string/first","@stdlib/datasets-fivethirtyeight-ffq":"@stdlib/datasets/fivethirtyeight-ffq","@stdlib/utils-flatten-array":"@stdlib/utils/flatten-array","@stdlib/utils-flatten-object":"@stdlib/utils/flatten-object","@stdlib/stats-fligner-test":"@stdlib/stats/fligner-test","@stdlib/os-float-word-order":"@stdlib/os/float-word-order","@stdlib/constants-float16-cbrt-eps":"@stdlib/constants/float16/cbrt-eps","@stdlib/constants-float16-eps":"@stdlib/constants/float16/eps","@stdlib/constants-float16-exponent-bias":"@stdlib/constants/float16/exponent-bias","@stdlib/constants-float16-max":"@stdlib/constants/float16/max","@stdlib/constants-float16-max-safe-integer":"@stdlib/constants/float16/max-safe-integer","@stdlib/constants-float16-min-safe-integer":"@stdlib/constants/float16/min-safe-integer","@stdlib/constants-float16-ninf":"@stdlib/constants/float16/ninf","@stdlib/constants-float16-num-bytes":"@stdlib/constants/float16/num-bytes","@stdlib/constants-float16-pinf":"@stdlib/constants/float16/pinf","@stdlib/constants-float16-precision":"@stdlib/constants/float16/precision","@stdlib/constants-float16-smallest-normal":"@stdlib/constants/float16/smallest-normal","@stdlib/constants-float16-smallest-subnormal":"@stdlib/constants/float16/smallest-subnormal","@stdlib/constants-float16-sqrt-eps":"@stdlib/constants/float16/sqrt-eps","@stdlib/constants-float32-abs-mask":"@stdlib/constants/float32/abs-mask","@stdlib/constants-float32-cbrt-eps":"@stdlib/constants/float32/cbrt-eps","@stdlib/constants-float32-e":"@stdlib/constants/float32/e","@stdlib/constants-float32-eps":"@stdlib/constants/float32/eps","@stdlib/constants-float32-exponent-bias":"@stdlib/constants/float32/exponent-bias","@stdlib/constants-float32-exponent-mask":"@stdlib/constants/float32/exponent-mask","@stdlib/constants-float32-fourth-pi":"@stdlib/constants/float32/fourth-pi","@stdlib/constants-float32-half-ln-two":"@stdlib/constants/float32/half-ln-two","@stdlib/constants-float32-half-pi":"@stdlib/constants/float32/half-pi","@stdlib/constants-float32-ln-half":"@stdlib/constants/float32/ln-half","@stdlib/constants-float32-ln-pi":"@stdlib/constants/float32/ln-pi","@stdlib/constants-float32-ln-ten":"@stdlib/constants/float32/ln-ten","@stdlib/constants-float32-ln-two":"@stdlib/constants/float32/ln-two","@stdlib/constants-float32-max":"@stdlib/constants/float32/max","@stdlib/constants-float32-max-base2-exponent":"@stdlib/constants/float32/max-base2-exponent","@stdlib/constants-float32-max-base2-exponent-subnormal":"@stdlib/constants/float32/max-base2-exponent-subnormal","@stdlib/constants-float32-max-base10-exponent":"@stdlib/constants/float32/max-base10-exponent","@stdlib/constants-float32-max-base10-exponent-subnormal":"@stdlib/constants/float32/max-base10-exponent-subnormal","@stdlib/constants-float32-max-safe-fibonacci":"@stdlib/constants/float32/max-safe-fibonacci","@stdlib/constants-float32-max-safe-integer":"@stdlib/constants/float32/max-safe-integer","@stdlib/constants-float32-max-safe-nth-factorial":"@stdlib/constants/float32/max-safe-nth-factorial","@stdlib/constants-float32-max-safe-nth-fibonacci":"@stdlib/constants/float32/max-safe-nth-fibonacci","@stdlib/constants-float32-max-safe-nth-lucas":"@stdlib/constants/float32/max-safe-nth-lucas","@stdlib/constants-float32-min-base2-exponent":"@stdlib/constants/float32/min-base2-exponent","@stdlib/constants-float32-min-base2-exponent-subnormal":"@stdlib/constants/float32/min-base2-exponent-subnormal","@stdlib/constants-float32-min-base10-exponent":"@stdlib/constants/float32/min-base10-exponent","@stdlib/constants-float32-min-base10-exponent-subnormal":"@stdlib/constants/float32/min-base10-exponent-subnormal","@stdlib/constants-float32-min-safe-integer":"@stdlib/constants/float32/min-safe-integer","@stdlib/constants-float32-nan":"@stdlib/constants/float32/nan","@stdlib/constants-float32-ninf":"@stdlib/constants/float32/ninf","@stdlib/constants-float32-num-bytes":"@stdlib/constants/float32/num-bytes","@stdlib/constants-float32-phi":"@stdlib/constants/float32/phi","@stdlib/constants-float32-pi":"@stdlib/constants/float32/pi","@stdlib/constants-float32-pinf":"@stdlib/constants/float32/pinf","@stdlib/constants-float32-precision":"@stdlib/constants/float32/precision","@stdlib/constants-float32-sign-mask":"@stdlib/constants/float32/sign-mask","@stdlib/constants-float32-significand-mask":"@stdlib/constants/float32/significand-mask","@stdlib/constants-float32-smallest-normal":"@stdlib/constants/float32/smallest-normal","@stdlib/constants-float32-smallest-subnormal":"@stdlib/constants/float32/smallest-subnormal","@stdlib/constants-float32-sqrt-eps":"@stdlib/constants/float32/sqrt-eps","@stdlib/constants-float32-sqrt-half":"@stdlib/constants/float32/sqrt-half","@stdlib/constants-float32-sqrt-half-pi":"@stdlib/constants/float32/sqrt-half-pi","@stdlib/constants-float32-sqrt-phi":"@stdlib/constants/float32/sqrt-phi","@stdlib/constants-float32-sqrt-pi":"@stdlib/constants/float32/sqrt-pi","@stdlib/constants-float32-sqrt-three":"@stdlib/constants/float32/sqrt-three","@stdlib/constants-float32-sqrt-two":"@stdlib/constants/float32/sqrt-two","@stdlib/constants-float32-sqrt-two-pi":"@stdlib/constants/float32/sqrt-two-pi","@stdlib/constants-float32-two-pi":"@stdlib/constants/float32/two-pi","@stdlib/array-float32":"@stdlib/array/float32","@stdlib/array-fixed-endian-float32":"@stdlib/array/fixed-endian-float32","@stdlib/array-little-endian-float32":"@stdlib/array/little-endian-float32","@stdlib/constants-float64-exponent-bias":"@stdlib/constants/float64/exponent-bias","@stdlib/constants-float64-high-word-abs-mask":"@stdlib/constants/float64/high-word-abs-mask","@stdlib/constants-float64-high-word-exponent-mask":"@stdlib/constants/float64/high-word-exponent-mask","@stdlib/constants-float64-high-word-sign-mask":"@stdlib/constants/float64/high-word-sign-mask","@stdlib/constants-float64-high-word-significand-mask":"@stdlib/constants/float64/high-word-significand-mask","@stdlib/constants-float64-max":"@stdlib/constants/float64/max","@stdlib/constants-float64-max-base2-exponent":"@stdlib/constants/float64/max-base2-exponent","@stdlib/constants-float64-max-base2-exponent-subnormal":"@stdlib/constants/float64/max-base2-exponent-subnormal","@stdlib/constants-float64-max-base10-exponent":"@stdlib/constants/float64/max-base10-exponent","@stdlib/constants-float64-max-base10-exponent-subnormal":"@stdlib/constants/float64/max-base10-exponent-subnormal","@stdlib/constants-float64-max-ln":"@stdlib/constants/float64/max-ln","@stdlib/constants-float64-max-safe-fibonacci":"@stdlib/constants/float64/max-safe-fibonacci","@stdlib/constants-float64-max-safe-integer":"@stdlib/constants/float64/max-safe-integer","@stdlib/constants-float64-max-safe-lucas":"@stdlib/constants/float64/max-safe-lucas","@stdlib/constants-float64-max-safe-nth-fibonacci":"@stdlib/constants/float64/max-safe-nth-fibonacci","@stdlib/constants-float64-max-safe-nth-lucas":"@stdlib/constants/float64/max-safe-nth-lucas","@stdlib/constants-float64-min-base2-exponent":"@stdlib/constants/float64/min-base2-exponent","@stdlib/constants-float64-min-base2-exponent-subnormal":"@stdlib/constants/float64/min-base2-exponent-subnormal","@stdlib/constants-float64-min-base10-exponent":"@stdlib/constants/float64/min-base10-exponent","@stdlib/constants-float64-min-base10-exponent-subnormal":"@stdlib/constants/float64/min-base10-exponent-subnormal","@stdlib/constants-float64-min-ln":"@stdlib/constants/float64/min-ln","@stdlib/constants-float64-min-safe-integer":"@stdlib/constants/float64/min-safe-integer","@stdlib/constants-float64-num-bytes":"@stdlib/constants/float64/num-bytes","@stdlib/constants-float64-precision":"@stdlib/constants/float64/precision","@stdlib/constants-float64-smallest-normal":"@stdlib/constants/float64/smallest-normal","@stdlib/constants-float64-smallest-subnormal":"@stdlib/constants/float64/smallest-subnormal","@stdlib/array-float64":"@stdlib/array/float64","@stdlib/array-fixed-endian-float64":"@stdlib/array/fixed-endian-float64","@stdlib/array-little-endian-float64":"@stdlib/array/little-endian-float64","@stdlib/utils-for-each":"@stdlib/utils/for-each","@stdlib/utils-async-for-each":"@stdlib/utils/async/for-each","@stdlib/string-for-each":"@stdlib/string/for-each","@stdlib/utils-for-each-right":"@stdlib/utils/for-each-right","@stdlib/utils-async-for-each-right":"@stdlib/utils/async/for-each-right","@stdlib/utils-for-in":"@stdlib/utils/for-in","@stdlib/string-format":"@stdlib/string/format","@stdlib/utils-for-own":"@stdlib/utils/for-own","@stdlib/constants-float64-fourth-pi":"@stdlib/constants/float64/fourth-pi","@stdlib/constants-float64-fourth-root-eps":"@stdlib/constants/float64/fourth-root-eps","@stdlib/datasets-frb-sf-wage-rigidity":"@stdlib/datasets/frb-sf-wage-rigidity","@stdlib/string-from-code-point":"@stdlib/string/from-code-point","@stdlib/function-ctor":"@stdlib/function/ctor","@stdlib/function-to-string":"@stdlib/function/to-string","@stdlib/utils-function-name":"@stdlib/utils/function-name","@stdlib/utils-function-sequence":"@stdlib/utils/function-sequence","@stdlib/utils-async-function-sequence":"@stdlib/utils/async/function-sequence","@stdlib/constants-float64-gamma-lanczos-g":"@stdlib/constants/float64/gamma-lanczos-g","@stdlib/blas-gdot":"@stdlib/blas/gdot","@stdlib/process-getegid":"@stdlib/process/getegid","@stdlib/process-geteuid":"@stdlib/process/geteuid","@stdlib/process-getgid":"@stdlib/process/getgid","@stdlib/utils-global":"@stdlib/utils/global","@stdlib/utils-get-prototype-of":"@stdlib/utils/get-prototype-of","@stdlib/process-getuid":"@stdlib/process/getuid","@stdlib/constants-float64-glaisher-kinkelin":"@stdlib/constants/float64/glaisher-kinkelin","@stdlib/string-to-grapheme-cluster-iterator":"@stdlib/string/to-grapheme-cluster-iterator","@stdlib/string-to-grapheme-cluster-iterator-right":"@stdlib/string/to-grapheme-cluster-iterator-right","@stdlib/utils-group":"@stdlib/utils/group","@stdlib/utils-group-by":"@stdlib/utils/group-by","@stdlib/utils-async-group-by":"@stdlib/utils/async/group-by","@stdlib/utils-group-in":"@stdlib/utils/group-in","@stdlib/utils-group-own":"@stdlib/utils/group-own","@stdlib/blas-gswap":"@stdlib/blas/gswap","@stdlib/constants-float64-half-ln-two":"@stdlib/constants/float64/half-ln-two","@stdlib/constants-float64-half-pi":"@stdlib/constants/float64/half-pi","@stdlib/datasets-harrison-boston-house-prices":"@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets-harrison-boston-house-prices-corrected":"@stdlib/datasets/harrison-boston-house-prices-corrected","@stdlib/assert-has-arraybuffer-support":"@stdlib/assert/has-arraybuffer-support","@stdlib/assert-has-arrow-function-support":"@stdlib/assert/has-arrow-function-support","@stdlib/assert-has-async-await-support":"@stdlib/assert/has-async-await-support","@stdlib/assert-has-async-iterator-symbol-support":"@stdlib/assert/has-async-iterator-symbol-support","@stdlib/assert-has-atob-support":"@stdlib/assert/has-atob-support","@stdlib/assert-has-bigint64array-support":"@stdlib/assert/has-bigint64array-support","@stdlib/assert-has-bigint-support":"@stdlib/assert/has-bigint-support","@stdlib/assert-has-biguint64array-support":"@stdlib/assert/has-biguint64array-support","@stdlib/assert-has-btoa-support":"@stdlib/assert/has-btoa-support","@stdlib/assert-has-class-support":"@stdlib/assert/has-class-support","@stdlib/assert-has-dataview-support":"@stdlib/assert/has-dataview-support","@stdlib/assert-has-define-properties-support":"@stdlib/assert/has-define-properties-support","@stdlib/assert-has-define-property-support":"@stdlib/assert/has-define-property-support","@stdlib/assert-has-float32array-support":"@stdlib/assert/has-float32array-support","@stdlib/assert-has-float64array-support":"@stdlib/assert/has-float64array-support","@stdlib/assert-has-function-name-support":"@stdlib/assert/has-function-name-support","@stdlib/assert-has-generator-support":"@stdlib/assert/has-generator-support","@stdlib/assert-has-globalthis-support":"@stdlib/assert/has-globalthis-support","@stdlib/assert-has-int8array-support":"@stdlib/assert/has-int8array-support","@stdlib/assert-has-int16array-support":"@stdlib/assert/has-int16array-support","@stdlib/assert-has-int32array-support":"@stdlib/assert/has-int32array-support","@stdlib/assert-has-iterator-symbol-support":"@stdlib/assert/has-iterator-symbol-support","@stdlib/assert-has-map-support":"@stdlib/assert/has-map-support","@stdlib/assert-has-node-buffer-support":"@stdlib/assert/has-node-buffer-support","@stdlib/assert-has-own-property":"@stdlib/assert/has-own-property","@stdlib/assert-has-property":"@stdlib/assert/has-property","@stdlib/assert-has-proxy-support":"@stdlib/assert/has-proxy-support","@stdlib/assert-has-set-support":"@stdlib/assert/has-set-support","@stdlib/assert-has-sharedarraybuffer-support":"@stdlib/assert/has-sharedarraybuffer-support","@stdlib/assert-has-symbol-support":"@stdlib/assert/has-symbol-support","@stdlib/assert-has-tostringtag-support":"@stdlib/assert/has-tostringtag-support","@stdlib/assert-has-uint8array-support":"@stdlib/assert/has-uint8array-support","@stdlib/assert-has-uint8clampedarray-support":"@stdlib/assert/has-uint8clampedarray-support","@stdlib/assert-has-uint16array-support":"@stdlib/assert/has-uint16array-support","@stdlib/assert-has-uint32array-support":"@stdlib/assert/has-uint32array-support","@stdlib/assert-has-utf16-surrogate-pair-at":"@stdlib/assert/has-utf16-surrogate-pair-at","@stdlib/assert-has-weakmap-support":"@stdlib/assert/has-weakmap-support","@stdlib/assert-has-weakset-support":"@stdlib/assert/has-weakset-support","@stdlib/assert-has-wasm-support":"@stdlib/assert/has-wasm-support","@stdlib/string-headercase":"@stdlib/string/headercase","@stdlib/datasets-herndon-venus-semidiameters":"@stdlib/datasets/herndon-venus-semidiameters","@stdlib/os-homedir":"@stdlib/os/homedir","@stdlib/constants-time-hours-in-day":"@stdlib/constants/time/hours-in-day","@stdlib/constants-time-hours-in-week":"@stdlib/constants/time/hours-in-week","@stdlib/time-hours-in-month":"@stdlib/time/hours-in-month","@stdlib/time-hours-in-year":"@stdlib/time/hours-in-year","@stdlib/net-http-server":"@stdlib/net/http-server","@stdlib/utils-identity-function":"@stdlib/utils/identity-function","@stdlib/utils-if-else":"@stdlib/utils/if-else","@stdlib/utils-async-if-else":"@stdlib/utils/async/if-else","@stdlib/utils-if-then":"@stdlib/utils/if-then","@stdlib/utils-async-if-then":"@stdlib/utils/async/if-then","@stdlib/complex-float64-imag":"@stdlib/complex/float64/imag","@stdlib/complex-float32-imag":"@stdlib/complex/float32/imag","@stdlib/datasets-img-acanthus-mollis":"@stdlib/datasets/img-acanthus-mollis","@stdlib/datasets-img-airplane-from-above":"@stdlib/datasets/img-airplane-from-above","@stdlib/datasets-img-allium-oreophilum":"@stdlib/datasets/img-allium-oreophilum","@stdlib/datasets-img-black-canyon":"@stdlib/datasets/img-black-canyon","@stdlib/datasets-img-dust-bowl-home":"@stdlib/datasets/img-dust-bowl-home","@stdlib/datasets-img-french-alpine-landscape":"@stdlib/datasets/img-french-alpine-landscape","@stdlib/datasets-img-locomotion-house-cat":"@stdlib/datasets/img-locomotion-house-cat","@stdlib/datasets-img-locomotion-nude-male":"@stdlib/datasets/img-locomotion-nude-male","@stdlib/datasets-img-march-pastoral":"@stdlib/datasets/img-march-pastoral","@stdlib/datasets-img-nagasaki-boats":"@stdlib/datasets/img-nagasaki-boats","@stdlib/stats-incr-apcorr":"@stdlib/stats/incr/apcorr","@stdlib/ml-incr-binary-classification":"@stdlib/ml/incr/binary-classification","@stdlib/stats-incr-count":"@stdlib/stats/incr/count","@stdlib/stats-incr-covariance":"@stdlib/stats/incr/covariance","@stdlib/stats-incr-covmat":"@stdlib/stats/incr/covmat","@stdlib/stats-incr-cv":"@stdlib/stats/incr/cv","@stdlib/stats-incr-ewmean":"@stdlib/stats/incr/ewmean","@stdlib/stats-incr-ewstdev":"@stdlib/stats/incr/ewstdev","@stdlib/stats-incr-ewvariance":"@stdlib/stats/incr/ewvariance","@stdlib/stats-incr-gmean":"@stdlib/stats/incr/gmean","@stdlib/stats-incr-grubbs":"@stdlib/stats/incr/grubbs","@stdlib/stats-incr-hmean":"@stdlib/stats/incr/hmean","@stdlib/ml-incr-kmeans":"@stdlib/ml/incr/kmeans","@stdlib/stats-incr-kurtosis":"@stdlib/stats/incr/kurtosis","@stdlib/stats-incr-maape":"@stdlib/stats/incr/maape","@stdlib/stats-incr-mae":"@stdlib/stats/incr/mae","@stdlib/stats-incr-mapcorr":"@stdlib/stats/incr/mapcorr","@stdlib/stats-incr-mape":"@stdlib/stats/incr/mape","@stdlib/stats-incr-max":"@stdlib/stats/incr/max","@stdlib/stats-incr-maxabs":"@stdlib/stats/incr/maxabs","@stdlib/stats-incr-mcovariance":"@stdlib/stats/incr/mcovariance","@stdlib/stats-incr-mcv":"@stdlib/stats/incr/mcv","@stdlib/stats-incr-mda":"@stdlib/stats/incr/mda","@stdlib/stats-incr-me":"@stdlib/stats/incr/me","@stdlib/stats-incr-mean":"@stdlib/stats/incr/mean","@stdlib/stats-incr-meanabs":"@stdlib/stats/incr/meanabs","@stdlib/stats-incr-meanabs2":"@stdlib/stats/incr/meanabs2","@stdlib/stats-incr-meanstdev":"@stdlib/stats/incr/meanstdev","@stdlib/stats-incr-meanvar":"@stdlib/stats/incr/meanvar","@stdlib/stats-incr-mgmean":"@stdlib/stats/incr/mgmean","@stdlib/stats-incr-mgrubbs":"@stdlib/stats/incr/mgrubbs","@stdlib/stats-incr-mhmean":"@stdlib/stats/incr/mhmean","@stdlib/stats-incr-midrange":"@stdlib/stats/incr/midrange","@stdlib/stats-incr-min":"@stdlib/stats/incr/min","@stdlib/stats-incr-minabs":"@stdlib/stats/incr/minabs","@stdlib/stats-incr-minmax":"@stdlib/stats/incr/minmax","@stdlib/stats-incr-minmaxabs":"@stdlib/stats/incr/minmaxabs","@stdlib/stats-incr-mmaape":"@stdlib/stats/incr/mmaape","@stdlib/stats-incr-mmae":"@stdlib/stats/incr/mmae","@stdlib/stats-incr-mmape":"@stdlib/stats/incr/mmape","@stdlib/stats-incr-mmax":"@stdlib/stats/incr/mmax","@stdlib/stats-incr-mmaxabs":"@stdlib/stats/incr/mmaxabs","@stdlib/stats-incr-mmda":"@stdlib/stats/incr/mmda","@stdlib/stats-incr-mme":"@stdlib/stats/incr/mme","@stdlib/stats-incr-mmean":"@stdlib/stats/incr/mmean","@stdlib/stats-incr-mmeanabs":"@stdlib/stats/incr/mmeanabs","@stdlib/stats-incr-mmeanabs2":"@stdlib/stats/incr/mmeanabs2","@stdlib/stats-incr-mmeanstdev":"@stdlib/stats/incr/mmeanstdev","@stdlib/stats-incr-mmeanvar":"@stdlib/stats/incr/mmeanvar","@stdlib/stats-incr-mmidrange":"@stdlib/stats/incr/mmidrange","@stdlib/stats-incr-mmin":"@stdlib/stats/incr/mmin","@stdlib/stats-incr-mminabs":"@stdlib/stats/incr/mminabs","@stdlib/stats-incr-mminmax":"@stdlib/stats/incr/mminmax","@stdlib/stats-incr-mminmaxabs":"@stdlib/stats/incr/mminmaxabs","@stdlib/stats-incr-mmpe":"@stdlib/stats/incr/mmpe","@stdlib/stats-incr-mmse":"@stdlib/stats/incr/mmse","@stdlib/stats-incr-mpcorr":"@stdlib/stats/incr/mpcorr","@stdlib/stats-incr-mpcorr2":"@stdlib/stats/incr/mpcorr2","@stdlib/stats-incr-mpcorrdist":"@stdlib/stats/incr/mpcorrdist","@stdlib/stats-incr-mpe":"@stdlib/stats/incr/mpe","@stdlib/stats-incr-mprod":"@stdlib/stats/incr/mprod","@stdlib/stats-incr-mrange":"@stdlib/stats/incr/mrange","@stdlib/stats-incr-mrmse":"@stdlib/stats/incr/mrmse","@stdlib/stats-incr-mrss":"@stdlib/stats/incr/mrss","@stdlib/stats-incr-mse":"@stdlib/stats/incr/mse","@stdlib/stats-incr-mstdev":"@stdlib/stats/incr/mstdev","@stdlib/stats-incr-msum":"@stdlib/stats/incr/msum","@stdlib/stats-incr-msumabs":"@stdlib/stats/incr/msumabs","@stdlib/stats-incr-msumabs2":"@stdlib/stats/incr/msumabs2","@stdlib/stats-incr-msummary":"@stdlib/stats/incr/msummary","@stdlib/stats-incr-msumprod":"@stdlib/stats/incr/msumprod","@stdlib/stats-incr-mvariance":"@stdlib/stats/incr/mvariance","@stdlib/stats-incr-mvmr":"@stdlib/stats/incr/mvmr","@stdlib/stats-incr-nancount":"@stdlib/stats/incr/nancount","@stdlib/stats-incr-nansum":"@stdlib/stats/incr/nansum","@stdlib/stats-incr-nansumabs":"@stdlib/stats/incr/nansumabs","@stdlib/stats-incr-nansumabs2":"@stdlib/stats/incr/nansumabs2","@stdlib/stats-incr-pcorr":"@stdlib/stats/incr/pcorr","@stdlib/stats-incr-pcorr2":"@stdlib/stats/incr/pcorr2","@stdlib/stats-incr-pcorrdist":"@stdlib/stats/incr/pcorrdist","@stdlib/stats-incr-pcorrdistmat":"@stdlib/stats/incr/pcorrdistmat","@stdlib/stats-incr-pcorrmat":"@stdlib/stats/incr/pcorrmat","@stdlib/stats-incr-prod":"@stdlib/stats/incr/prod","@stdlib/stats-incr-range":"@stdlib/stats/incr/range","@stdlib/stats-incr-rmse":"@stdlib/stats/incr/rmse","@stdlib/stats-incr-rss":"@stdlib/stats/incr/rss","@stdlib/ml-incr-sgd-regression":"@stdlib/ml/incr/sgd-regression","@stdlib/stats-incr-skewness":"@stdlib/stats/incr/skewness","@stdlib/array-incrspace":"@stdlib/array/incrspace","@stdlib/stats-incr-stdev":"@stdlib/stats/incr/stdev","@stdlib/stats-incr-sum":"@stdlib/stats/incr/sum","@stdlib/stats-incr-sumabs":"@stdlib/stats/incr/sumabs","@stdlib/stats-incr-sumabs2":"@stdlib/stats/incr/sumabs2","@stdlib/stats-incr-summary":"@stdlib/stats/incr/summary","@stdlib/stats-incr-sumprod":"@stdlib/stats/incr/sumprod","@stdlib/stats-incr-variance":"@stdlib/stats/incr/variance","@stdlib/stats-incr-vmr":"@stdlib/stats/incr/vmr","@stdlib/stats-incr-wmean":"@stdlib/stats/incr/wmean","@stdlib/ndarray-ind2sub":"@stdlib/ndarray/ind2sub","@stdlib/utils-index-of":"@stdlib/utils/index-of","@stdlib/utils-inherit":"@stdlib/utils/inherit","@stdlib/utils-inherited-enumerable-properties":"@stdlib/utils/inherited-enumerable-properties","@stdlib/utils-inherited-enumerable-property-symbols":"@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils-inherited-keys":"@stdlib/utils/inherited-keys","@stdlib/utils-inherited-nonenumerable-properties":"@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils-inherited-nonenumerable-property-names":"@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils-inherited-nonenumerable-property-symbols":"@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils-inherited-properties":"@stdlib/utils/inherited-properties","@stdlib/utils-inherited-property-descriptor":"@stdlib/utils/inherited-property-descriptor","@stdlib/utils-inherited-property-descriptors":"@stdlib/utils/inherited-property-descriptors","@stdlib/utils-inherited-property-names":"@stdlib/utils/inherited-property-names","@stdlib/utils-inherited-property-symbols":"@stdlib/utils/inherited-property-symbols","@stdlib/utils-inherited-writable-properties":"@stdlib/utils/inherited-writable-properties","@stdlib/utils-inherited-writable-property-names":"@stdlib/utils/inherited-writable-property-names","@stdlib/utils-inherited-writable-property-symbols":"@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils-inmap":"@stdlib/utils/inmap","@stdlib/utils-async-inmap":"@stdlib/utils/async/inmap","@stdlib/utils-inmap-right":"@stdlib/utils/inmap-right","@stdlib/utils-async-inmap-right":"@stdlib/utils/async/inmap-right","@stdlib/streams-node-inspect-sink":"@stdlib/streams/node/inspect-sink","@stdlib/streams-node-inspect":"@stdlib/streams/node/inspect","@stdlib/assert-instance-of":"@stdlib/assert/instance-of","@stdlib/constants-int8-max":"@stdlib/constants/int8/max","@stdlib/constants-int8-min":"@stdlib/constants/int8/min","@stdlib/constants-int8-num-bytes":"@stdlib/constants/int8/num-bytes","@stdlib/array-int8":"@stdlib/array/int8","@stdlib/constants-int16-max":"@stdlib/constants/int16/max","@stdlib/constants-int16-min":"@stdlib/constants/int16/min","@stdlib/constants-int16-num-bytes":"@stdlib/constants/int16/num-bytes","@stdlib/array-int16":"@stdlib/array/int16","@stdlib/constants-int32-max":"@stdlib/constants/int32/max","@stdlib/constants-int32-min":"@stdlib/constants/int32/min","@stdlib/constants-int32-num-bytes":"@stdlib/constants/int32/num-bytes","@stdlib/array-int32":"@stdlib/array/int32","@stdlib/assert-is-big-endian":"@stdlib/assert/is-big-endian","@stdlib/assert-is-browser":"@stdlib/assert/is-browser","@stdlib/assert-is-darwin":"@stdlib/assert/is-darwin","@stdlib/assert-is-docker":"@stdlib/assert/is-docker","@stdlib/assert-is-electron":"@stdlib/assert/is-electron","@stdlib/assert-is-electron-main":"@stdlib/assert/is-electron-main","@stdlib/assert-is-electron-renderer":"@stdlib/assert/is-electron-renderer","@stdlib/assert-is-little-endian":"@stdlib/assert/is-little-endian","@stdlib/assert-is-mobile":"@stdlib/assert/is-mobile","@stdlib/assert-is-node":"@stdlib/assert/is-node","@stdlib/assert-is-touch-device":"@stdlib/assert/is-touch-device","@stdlib/assert-is-web-worker":"@stdlib/assert/is-web-worker","@stdlib/assert-is-windows":"@stdlib/assert/is-windows","@stdlib/assert-is-absolute-http-uri":"@stdlib/assert/is-absolute-http-uri","@stdlib/assert-is-absolute-path":"@stdlib/assert/is-absolute-path","@stdlib/assert-is-absolute-uri":"@stdlib/assert/is-absolute-uri","@stdlib/assert-is-accessor-array":"@stdlib/assert/is-accessor-array","@stdlib/assert-is-accessor-property":"@stdlib/assert/is-accessor-property","@stdlib/assert-is-accessor-property-in":"@stdlib/assert/is-accessor-property-in","@stdlib/assert-is-alphagram":"@stdlib/assert/is-alphagram","@stdlib/assert-is-alphanumeric":"@stdlib/assert/is-alphanumeric","@stdlib/assert-is-anagram":"@stdlib/assert/is-anagram","@stdlib/assert-is-arguments":"@stdlib/assert/is-arguments","@stdlib/assert-is-array":"@stdlib/assert/is-array","@stdlib/assert-is-array-array":"@stdlib/assert/is-array-array","@stdlib/assert-is-arraybuffer":"@stdlib/assert/is-arraybuffer","@stdlib/assert-is-arraybuffer-view":"@stdlib/assert/is-arraybuffer-view","@stdlib/assert-is-array-length":"@stdlib/assert/is-array-length","@stdlib/assert-is-array-like":"@stdlib/assert/is-array-like","@stdlib/assert-is-array-like-object":"@stdlib/assert/is-array-like-object","@stdlib/assert-is-arrow-function":"@stdlib/assert/is-arrow-function","@stdlib/assert-is-ascii":"@stdlib/assert/is-ascii","@stdlib/assert-is-between":"@stdlib/assert/is-between","@stdlib/assert-is-between-array":"@stdlib/assert/is-between-array","@stdlib/assert-is-bigint":"@stdlib/assert/is-bigint","@stdlib/assert-is-bigint64array":"@stdlib/assert/is-bigint64array","@stdlib/assert-is-biguint64array":"@stdlib/assert/is-biguint64array","@stdlib/assert-is-binary-string":"@stdlib/assert/is-binary-string","@stdlib/assert-is-blank-string":"@stdlib/assert/is-blank-string","@stdlib/assert-is-boolean":"@stdlib/assert/is-boolean","@stdlib/assert-is-boolean-array":"@stdlib/assert/is-boolean-array","@stdlib/assert-is-boxed-primitive":"@stdlib/assert/is-boxed-primitive","@stdlib/assert-is-buffer":"@stdlib/assert/is-buffer","@stdlib/assert-is-camelcase":"@stdlib/assert/is-camelcase","@stdlib/assert-is-capitalized":"@stdlib/assert/is-capitalized","@stdlib/assert-is-centrosymmetric-matrix":"@stdlib/assert/is-centrosymmetric-matrix","@stdlib/assert-is-circular":"@stdlib/assert/is-circular","@stdlib/assert-is-circular-array":"@stdlib/assert/is-circular-array","@stdlib/assert-is-circular-plain-object":"@stdlib/assert/is-circular-plain-object","@stdlib/assert-is-class":"@stdlib/assert/is-class","@stdlib/assert-is-collection":"@stdlib/assert/is-collection","@stdlib/assert-is-complex":"@stdlib/assert/is-complex","@stdlib/assert-is-complex64":"@stdlib/assert/is-complex64","@stdlib/assert-is-complex64array":"@stdlib/assert/is-complex64array","@stdlib/assert-is-complex64matrix-like":"@stdlib/assert/is-complex64matrix-like","@stdlib/assert-is-complex64ndarray-like":"@stdlib/assert/is-complex64ndarray-like","@stdlib/assert-is-complex64vector-like":"@stdlib/assert/is-complex64vector-like","@stdlib/assert-is-complex128":"@stdlib/assert/is-complex128","@stdlib/assert-is-complex128array":"@stdlib/assert/is-complex128array","@stdlib/assert-is-complex128matrix-like":"@stdlib/assert/is-complex128matrix-like","@stdlib/assert-is-complex128ndarray-like":"@stdlib/assert/is-complex128ndarray-like","@stdlib/assert-is-complex128vector-like":"@stdlib/assert/is-complex128vector-like","@stdlib/assert-is-complex-like":"@stdlib/assert/is-complex-like","@stdlib/assert-is-complex-typed-array":"@stdlib/assert/is-complex-typed-array","@stdlib/assert-is-complex-typed-array-like":"@stdlib/assert/is-complex-typed-array-like","@stdlib/assert-is-composite":"@stdlib/assert/is-composite","@stdlib/assert-is-configurable-property":"@stdlib/assert/is-configurable-property","@stdlib/assert-is-configurable-property-in":"@stdlib/assert/is-configurable-property-in","@stdlib/assert-is-constantcase":"@stdlib/assert/is-constantcase","@stdlib/assert-is-cube-number":"@stdlib/assert/is-cube-number","@stdlib/assert-is-current-year":"@stdlib/assert/is-current-year","@stdlib/assert-is-data-property":"@stdlib/assert/is-data-property","@stdlib/assert-is-data-property-in":"@stdlib/assert/is-data-property-in","@stdlib/assert-is-dataview":"@stdlib/assert/is-dataview","@stdlib/assert-is-date-object":"@stdlib/assert/is-date-object","@stdlib/assert-is-date-object-array":"@stdlib/assert/is-date-object-array","@stdlib/assert-is-digit-string":"@stdlib/assert/is-digit-string","@stdlib/assert-is-domain-name":"@stdlib/assert/is-domain-name","@stdlib/assert-is-duration-string":"@stdlib/assert/is-duration-string","@stdlib/assert-is-email-address":"@stdlib/assert/is-email-address","@stdlib/assert-is-empty-array":"@stdlib/assert/is-empty-array","@stdlib/assert-is-empty-array-like-object":"@stdlib/assert/is-empty-array-like-object","@stdlib/assert-is-empty-collection":"@stdlib/assert/is-empty-collection","@stdlib/assert-is-empty-object":"@stdlib/assert/is-empty-object","@stdlib/assert-is-empty-string":"@stdlib/assert/is-empty-string","@stdlib/assert-is-enumerable-property":"@stdlib/assert/is-enumerable-property","@stdlib/assert-is-enumerable-property-in":"@stdlib/assert/is-enumerable-property-in","@stdlib/assert-is-equal-array":"@stdlib/assert/is-equal-array","@stdlib/assert-is-error":"@stdlib/assert/is-error","@stdlib/assert-is-eval-error":"@stdlib/assert/is-eval-error","@stdlib/assert-is-even":"@stdlib/assert/is-even","@stdlib/assert-is-falsy":"@stdlib/assert/is-falsy","@stdlib/assert-is-falsy-array":"@stdlib/assert/is-falsy-array","@stdlib/assert-is-finite":"@stdlib/assert/is-finite","@stdlib/assert-is-finite-array":"@stdlib/assert/is-finite-array","@stdlib/assert-is-float32array":"@stdlib/assert/is-float32array","@stdlib/assert-is-float32matrix-like":"@stdlib/assert/is-float32matrix-like","@stdlib/assert-is-float32ndarray-like":"@stdlib/assert/is-float32ndarray-like","@stdlib/assert-is-float32vector-like":"@stdlib/assert/is-float32vector-like","@stdlib/assert-is-float64array":"@stdlib/assert/is-float64array","@stdlib/assert-is-float64matrix-like":"@stdlib/assert/is-float64matrix-like","@stdlib/assert-is-float64ndarray-like":"@stdlib/assert/is-float64ndarray-like","@stdlib/assert-is-float64vector-like":"@stdlib/assert/is-float64vector-like","@stdlib/assert-is-function":"@stdlib/assert/is-function","@stdlib/assert-is-function-array":"@stdlib/assert/is-function-array","@stdlib/assert-is-generator-object":"@stdlib/assert/is-generator-object","@stdlib/assert-is-generator-object-like":"@stdlib/assert/is-generator-object-like","@stdlib/assert-is-gzip-buffer":"@stdlib/assert/is-gzip-buffer","@stdlib/assert-is-hex-string":"@stdlib/assert/is-hex-string","@stdlib/assert-is-infinite":"@stdlib/assert/is-infinite","@stdlib/assert-is-inherited-property":"@stdlib/assert/is-inherited-property","@stdlib/assert-is-int8array":"@stdlib/assert/is-int8array","@stdlib/assert-is-int16array":"@stdlib/assert/is-int16array","@stdlib/assert-is-int32array":"@stdlib/assert/is-int32array","@stdlib/assert-is-integer":"@stdlib/assert/is-integer","@stdlib/assert-is-integer-array":"@stdlib/assert/is-integer-array","@stdlib/assert-is-iterable-like":"@stdlib/assert/is-iterable-like","@stdlib/assert-is-iterator-like":"@stdlib/assert/is-iterator-like","@stdlib/assert-is-json":"@stdlib/assert/is-json","@stdlib/assert-is-kebabcase":"@stdlib/assert/is-kebabcase","@stdlib/assert-is-leap-year":"@stdlib/assert/is-leap-year","@stdlib/assert-is-localhost":"@stdlib/assert/is-localhost","@stdlib/assert-is-lowercase":"@stdlib/assert/is-lowercase","@stdlib/assert-is-matrix-like":"@stdlib/assert/is-matrix-like","@stdlib/assert-is-method":"@stdlib/assert/is-method","@stdlib/assert-is-method-in":"@stdlib/assert/is-method-in","@stdlib/assert-is-multi-slice":"@stdlib/assert/is-multi-slice","@stdlib/assert-is-named-typed-tuple-like":"@stdlib/assert/is-named-typed-tuple-like","@stdlib/assert-is-nan":"@stdlib/assert/is-nan","@stdlib/assert-is-nan-array":"@stdlib/assert/is-nan-array","@stdlib/assert-is-native-function":"@stdlib/assert/is-native-function","@stdlib/assert-is-ndarray-like":"@stdlib/assert/is-ndarray-like","@stdlib/assert-is-ndarray-like-with-data-type":"@stdlib/assert/is-ndarray-like-with-data-type","@stdlib/assert-is-negative-finite":"@stdlib/assert/is-negative-finite","@stdlib/assert-is-negative-integer":"@stdlib/assert/is-negative-integer","@stdlib/assert-is-negative-integer-array":"@stdlib/assert/is-negative-integer-array","@stdlib/assert-is-negative-number":"@stdlib/assert/is-negative-number","@stdlib/assert-is-negative-number-array":"@stdlib/assert/is-negative-number-array","@stdlib/assert-is-negative-zero":"@stdlib/assert/is-negative-zero","@stdlib/assert-is-node-builtin":"@stdlib/assert/is-node-builtin","@stdlib/assert-is-node-duplex-stream-like":"@stdlib/assert/is-node-duplex-stream-like","@stdlib/assert-is-node-readable-stream-like":"@stdlib/assert/is-node-readable-stream-like","@stdlib/assert-is-node-repl":"@stdlib/assert/is-node-repl","@stdlib/assert-is-node-stream-like":"@stdlib/assert/is-node-stream-like","@stdlib/assert-is-node-transform-stream-like":"@stdlib/assert/is-node-transform-stream-like","@stdlib/assert-is-node-writable-stream-like":"@stdlib/assert/is-node-writable-stream-like","@stdlib/assert-is-nonconfigurable-property":"@stdlib/assert/is-nonconfigurable-property","@stdlib/assert-is-nonconfigurable-property-in":"@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert-is-nonenumerable-property":"@stdlib/assert/is-nonenumerable-property","@stdlib/assert-is-nonenumerable-property-in":"@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert-is-nonnegative-finite":"@stdlib/assert/is-nonnegative-finite","@stdlib/assert-is-nonnegative-integer":"@stdlib/assert/is-nonnegative-integer","@stdlib/assert-is-nonnegative-integer-array":"@stdlib/assert/is-nonnegative-integer-array","@stdlib/assert-is-nonnegative-number":"@stdlib/assert/is-nonnegative-number","@stdlib/assert-is-nonnegative-number-array":"@stdlib/assert/is-nonnegative-number-array","@stdlib/assert-is-nonpositive-finite":"@stdlib/assert/is-nonpositive-finite","@stdlib/assert-is-nonpositive-integer":"@stdlib/assert/is-nonpositive-integer","@stdlib/assert-is-nonpositive-integer-array":"@stdlib/assert/is-nonpositive-integer-array","@stdlib/assert-is-nonpositive-number":"@stdlib/assert/is-nonpositive-number","@stdlib/assert-is-nonpositive-number-array":"@stdlib/assert/is-nonpositive-number-array","@stdlib/assert-is-nonsymmetric-matrix":"@stdlib/assert/is-nonsymmetric-matrix","@stdlib/assert-is-null":"@stdlib/assert/is-null","@stdlib/assert-is-null-array":"@stdlib/assert/is-null-array","@stdlib/assert-is-number":"@stdlib/assert/is-number","@stdlib/assert-is-number-array":"@stdlib/assert/is-number-array","@stdlib/assert-is-numeric-array":"@stdlib/assert/is-numeric-array","@stdlib/assert-is-object":"@stdlib/assert/is-object","@stdlib/assert-is-object-array":"@stdlib/assert/is-object-array","@stdlib/assert-is-object-like":"@stdlib/assert/is-object-like","@stdlib/assert-is-odd":"@stdlib/assert/is-odd","@stdlib/time-iso-weeks-in-year":"@stdlib/time/iso-weeks-in-year","@stdlib/assert-is-pascalcase":"@stdlib/assert/is-pascalcase","@stdlib/assert-is-persymmetric-matrix":"@stdlib/assert/is-persymmetric-matrix","@stdlib/assert-is-plain-object":"@stdlib/assert/is-plain-object","@stdlib/assert-is-plain-object-array":"@stdlib/assert/is-plain-object-array","@stdlib/assert-is-positive-finite":"@stdlib/assert/is-positive-finite","@stdlib/assert-is-positive-integer":"@stdlib/assert/is-positive-integer","@stdlib/assert-is-positive-integer-array":"@stdlib/assert/is-positive-integer-array","@stdlib/assert-is-positive-number":"@stdlib/assert/is-positive-number","@stdlib/assert-is-positive-number-array":"@stdlib/assert/is-positive-number-array","@stdlib/assert-is-positive-zero":"@stdlib/assert/is-positive-zero","@stdlib/assert-is-prime":"@stdlib/assert/is-prime","@stdlib/assert-is-primitive":"@stdlib/assert/is-primitive","@stdlib/assert-is-primitive-array":"@stdlib/assert/is-primitive-array","@stdlib/assert-is-prng-like":"@stdlib/assert/is-prng-like","@stdlib/assert-is-probability":"@stdlib/assert/is-probability","@stdlib/assert-is-probability-array":"@stdlib/assert/is-probability-array","@stdlib/assert-is-property-key":"@stdlib/assert/is-property-key","@stdlib/assert-is-prototype-of":"@stdlib/assert/is-prototype-of","@stdlib/assert-is-ragged-nested-array":"@stdlib/assert/is-ragged-nested-array","@stdlib/assert-is-range-error":"@stdlib/assert/is-range-error","@stdlib/assert-is-readable-property":"@stdlib/assert/is-readable-property","@stdlib/assert-is-readable-property-in":"@stdlib/assert/is-readable-property-in","@stdlib/assert-is-read-only-property":"@stdlib/assert/is-read-only-property","@stdlib/assert-is-read-only-property-in":"@stdlib/assert/is-read-only-property-in","@stdlib/assert-is-read-write-property":"@stdlib/assert/is-read-write-property","@stdlib/assert-is-read-write-property-in":"@stdlib/assert/is-read-write-property-in","@stdlib/assert-is-reference-error":"@stdlib/assert/is-reference-error","@stdlib/assert-is-regexp":"@stdlib/assert/is-regexp","@stdlib/assert-is-regexp-string":"@stdlib/assert/is-regexp-string","@stdlib/assert-is-relative-path":"@stdlib/assert/is-relative-path","@stdlib/assert-is-relative-uri":"@stdlib/assert/is-relative-uri","@stdlib/assert-is-safe-integer":"@stdlib/assert/is-safe-integer","@stdlib/assert-is-safe-integer-array":"@stdlib/assert/is-safe-integer-array","@stdlib/assert-is-same-array":"@stdlib/assert/is-same-array","@stdlib/assert-is-same-array-like":"@stdlib/assert/is-same-array-like","@stdlib/assert-is-same-complex64":"@stdlib/assert/is-same-complex64","@stdlib/assert-is-same-complex64array":"@stdlib/assert/is-same-complex64array","@stdlib/assert-is-same-complex128":"@stdlib/assert/is-same-complex128","@stdlib/assert-is-same-complex128array":"@stdlib/assert/is-same-complex128array","@stdlib/assert-is-same-date-object":"@stdlib/assert/is-same-date-object","@stdlib/assert-is-same-float32array":"@stdlib/assert/is-same-float32array","@stdlib/assert-is-same-float64array":"@stdlib/assert/is-same-float64array","@stdlib/assert-is-same-native-class":"@stdlib/assert/is-same-native-class","@stdlib/assert-is-same-type":"@stdlib/assert/is-same-type","@stdlib/assert-is-same-value":"@stdlib/assert/is-same-value","@stdlib/assert-is-same-value-zero":"@stdlib/assert/is-same-value-zero","@stdlib/assert-is-semver":"@stdlib/assert/is-semver","@stdlib/assert-is-sharedarraybuffer":"@stdlib/assert/is-sharedarraybuffer","@stdlib/assert-is-skew-centrosymmetric-matrix":"@stdlib/assert/is-skew-centrosymmetric-matrix","@stdlib/assert-is-skew-persymmetric-matrix":"@stdlib/assert/is-skew-persymmetric-matrix","@stdlib/assert-is-skew-symmetric-matrix":"@stdlib/assert/is-skew-symmetric-matrix","@stdlib/assert-is-slice":"@stdlib/assert/is-slice","@stdlib/assert-is-snakecase":"@stdlib/assert/is-snakecase","@stdlib/assert-is-square-matrix":"@stdlib/assert/is-square-matrix","@stdlib/assert-is-square-number":"@stdlib/assert/is-square-number","@stdlib/assert-is-square-triangular-number":"@stdlib/assert/is-square-triangular-number","@stdlib/assert-is-startcase":"@stdlib/assert/is-startcase","@stdlib/assert-is-strict-equal":"@stdlib/assert/is-strict-equal","@stdlib/assert-is-string":"@stdlib/assert/is-string","@stdlib/assert-is-string-array":"@stdlib/assert/is-string-array","@stdlib/assert-is-symbol":"@stdlib/assert/is-symbol","@stdlib/assert-is-symbol-array":"@stdlib/assert/is-symbol-array","@stdlib/assert-is-symmetric-matrix":"@stdlib/assert/is-symmetric-matrix","@stdlib/assert-is-syntax-error":"@stdlib/assert/is-syntax-error","@stdlib/assert-is-triangular-number":"@stdlib/assert/is-triangular-number","@stdlib/assert-is-truthy":"@stdlib/assert/is-truthy","@stdlib/assert-is-truthy-array":"@stdlib/assert/is-truthy-array","@stdlib/assert-is-typed-array":"@stdlib/assert/is-typed-array","@stdlib/assert-is-typed-array-length":"@stdlib/assert/is-typed-array-length","@stdlib/assert-is-typed-array-like":"@stdlib/assert/is-typed-array-like","@stdlib/assert-is-type-error":"@stdlib/assert/is-type-error","@stdlib/assert-is-uint8array":"@stdlib/assert/is-uint8array","@stdlib/assert-is-uint8clampedarray":"@stdlib/assert/is-uint8clampedarray","@stdlib/assert-is-uint16array":"@stdlib/assert/is-uint16array","@stdlib/assert-is-uint32array":"@stdlib/assert/is-uint32array","@stdlib/assert-is-unc-path":"@stdlib/assert/is-unc-path","@stdlib/assert-is-undefined":"@stdlib/assert/is-undefined","@stdlib/assert-is-undefined-or-null":"@stdlib/assert/is-undefined-or-null","@stdlib/assert-is-unity-probability-array":"@stdlib/assert/is-unity-probability-array","@stdlib/assert-is-uppercase":"@stdlib/assert/is-uppercase","@stdlib/assert-is-uri":"@stdlib/assert/is-uri","@stdlib/assert-is-uri-error":"@stdlib/assert/is-uri-error","@stdlib/assert-is-vector-like":"@stdlib/assert/is-vector-like","@stdlib/assert-is-wasm-memory":"@stdlib/assert/is-wasm-memory","@stdlib/assert-is-well-formed-string":"@stdlib/assert/is-well-formed-string","@stdlib/assert-is-whitespace":"@stdlib/assert/is-whitespace","@stdlib/assert-is-writable-property":"@stdlib/assert/is-writable-property","@stdlib/assert-is-writable-property-in":"@stdlib/assert/is-writable-property-in","@stdlib/assert-is-write-only-property":"@stdlib/assert/is-write-only-property","@stdlib/assert-is-write-only-property-in":"@stdlib/assert/is-write-only-property-in","@stdlib/math-iter-special-abs":"@stdlib/math/iter/special/abs","@stdlib/math-iter-special-abs2":"@stdlib/math/iter/special/abs2","@stdlib/math-iter-special-acos":"@stdlib/math/iter/special/acos","@stdlib/math-iter-special-acosh":"@stdlib/math/iter/special/acosh","@stdlib/math-iter-special-acot":"@stdlib/math/iter/special/acot","@stdlib/math-iter-special-acoth":"@stdlib/math/iter/special/acoth","@stdlib/math-iter-special-acovercos":"@stdlib/math/iter/special/acovercos","@stdlib/math-iter-special-acoversin":"@stdlib/math/iter/special/acoversin","@stdlib/math-iter-ops-add":"@stdlib/math/iter/ops/add","@stdlib/iter-advance":"@stdlib/iter/advance","@stdlib/math-iter-special-ahavercos":"@stdlib/math/iter/special/ahavercos","@stdlib/math-iter-special-ahaversin":"@stdlib/math/iter/special/ahaversin","@stdlib/iter-any":"@stdlib/iter/any","@stdlib/iter-any-by":"@stdlib/iter/any-by","@stdlib/math-iter-special-asin":"@stdlib/math/iter/special/asin","@stdlib/math-iter-special-asinh":"@stdlib/math/iter/special/asinh","@stdlib/math-iter-special-atan":"@stdlib/math/iter/special/atan","@stdlib/math-iter-special-atan2":"@stdlib/math/iter/special/atan2","@stdlib/math-iter-special-atanh":"@stdlib/math/iter/special/atanh","@stdlib/array-from-iterator":"@stdlib/array/from-iterator","@stdlib/iter-to-array-view":"@stdlib/iter/to-array-view","@stdlib/iter-to-array-view-right":"@stdlib/iter/to-array-view-right","@stdlib/streams-node-from-iterator":"@stdlib/streams/node/from-iterator","@stdlib/symbol-iterator":"@stdlib/symbol/iterator","@stdlib/math-iter-special-avercos":"@stdlib/math/iter/special/avercos","@stdlib/math-iter-special-aversin":"@stdlib/math/iter/special/aversin","@stdlib/simulate-iter-awgn":"@stdlib/simulate/iter/awgn","@stdlib/simulate-iter-awln":"@stdlib/simulate/iter/awln","@stdlib/simulate-iter-awun":"@stdlib/simulate/iter/awun","@stdlib/simulate-iter-bartlett-hann-pulse":"@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate-iter-bartlett-pulse":"@stdlib/simulate/iter/bartlett-pulse","@stdlib/math-iter-special-besselj0":"@stdlib/math/iter/special/besselj0","@stdlib/math-iter-special-besselj1":"@stdlib/math/iter/special/besselj1","@stdlib/math-iter-special-bessely0":"@stdlib/math/iter/special/bessely0","@stdlib/math-iter-special-bessely1":"@stdlib/math/iter/special/bessely1","@stdlib/math-iter-special-beta":"@stdlib/math/iter/special/beta","@stdlib/math-iter-special-betaln":"@stdlib/math/iter/special/betaln","@stdlib/math-iter-special-binet":"@stdlib/math/iter/special/binet","@stdlib/math-iter-special-cbrt":"@stdlib/math/iter/special/cbrt","@stdlib/math-iter-special-ceil":"@stdlib/math/iter/special/ceil","@stdlib/math-iter-special-ceil2":"@stdlib/math/iter/special/ceil2","@stdlib/math-iter-special-ceil10":"@stdlib/math/iter/special/ceil10","@stdlib/math-iter-sequences-composites":"@stdlib/math/iter/sequences/composites","@stdlib/iter-concat":"@stdlib/iter/concat","@stdlib/iter-constant":"@stdlib/iter/constant","@stdlib/math-iter-utils-continued-fraction":"@stdlib/math/iter/utils/continued-fraction","@stdlib/math-iter-sequences-continued-fraction":"@stdlib/math/iter/sequences/continued-fraction","@stdlib/math-iter-special-cos":"@stdlib/math/iter/special/cos","@stdlib/math-iter-special-cosh":"@stdlib/math/iter/special/cosh","@stdlib/simulate-iter-cosine-wave":"@stdlib/simulate/iter/cosine-wave","@stdlib/math-iter-special-cosm1":"@stdlib/math/iter/special/cosm1","@stdlib/math-iter-special-cospi":"@stdlib/math/iter/special/cospi","@stdlib/iter-counter":"@stdlib/iter/counter","@stdlib/math-iter-special-covercos":"@stdlib/math/iter/special/covercos","@stdlib/math-iter-special-coversin":"@stdlib/math/iter/special/coversin","@stdlib/math-iter-sequences-cubes":"@stdlib/math/iter/sequences/cubes","@stdlib/stats-iter-cugmean":"@stdlib/stats/iter/cugmean","@stdlib/stats-iter-cuhmean":"@stdlib/stats/iter/cuhmean","@stdlib/stats-iter-cumax":"@stdlib/stats/iter/cumax","@stdlib/stats-iter-cumaxabs":"@stdlib/stats/iter/cumaxabs","@stdlib/stats-iter-cumean":"@stdlib/stats/iter/cumean","@stdlib/stats-iter-cumeanabs":"@stdlib/stats/iter/cumeanabs","@stdlib/stats-iter-cumeanabs2":"@stdlib/stats/iter/cumeanabs2","@stdlib/stats-iter-cumidrange":"@stdlib/stats/iter/cumidrange","@stdlib/stats-iter-cumin":"@stdlib/stats/iter/cumin","@stdlib/stats-iter-cuminabs":"@stdlib/stats/iter/cuminabs","@stdlib/stats-iter-cuprod":"@stdlib/stats/iter/cuprod","@stdlib/stats-iter-curange":"@stdlib/stats/iter/curange","@stdlib/stats-iter-cusum":"@stdlib/stats/iter/cusum","@stdlib/stats-iter-cusumabs":"@stdlib/stats/iter/cusumabs","@stdlib/stats-iter-cusumabs2":"@stdlib/stats/iter/cusumabs2","@stdlib/iter-datespace":"@stdlib/iter/datespace","@stdlib/iter-dedupe":"@stdlib/iter/dedupe","@stdlib/iter-dedupe-by":"@stdlib/iter/dedupe-by","@stdlib/math-iter-special-deg2rad":"@stdlib/math/iter/special/deg2rad","@stdlib/math-iter-special-digamma":"@stdlib/math/iter/special/digamma","@stdlib/simulate-iter-dirac-comb":"@stdlib/simulate/iter/dirac-comb","@stdlib/math-iter-special-dirac-delta":"@stdlib/math/iter/special/dirac-delta","@stdlib/math-iter-ops-divide":"@stdlib/math/iter/ops/divide","@stdlib/iter-do-until-each":"@stdlib/iter/do-until-each","@stdlib/iter-do-while-each":"@stdlib/iter/do-while-each","@stdlib/math-iter-special-ellipe":"@stdlib/math/iter/special/ellipe","@stdlib/math-iter-special-ellipk":"@stdlib/math/iter/special/ellipk","@stdlib/iter-empty":"@stdlib/iter/empty","@stdlib/math-iter-special-erf":"@stdlib/math/iter/special/erf","@stdlib/math-iter-special-erfc":"@stdlib/math/iter/special/erfc","@stdlib/math-iter-special-erfcinv":"@stdlib/math/iter/special/erfcinv","@stdlib/math-iter-special-erfinv":"@stdlib/math/iter/special/erfinv","@stdlib/math-iter-special-dirichlet-eta":"@stdlib/math/iter/special/dirichlet-eta","@stdlib/math-iter-sequences-even-integers":"@stdlib/math/iter/sequences/even-integers","@stdlib/iter-every":"@stdlib/iter/every","@stdlib/iter-every-by":"@stdlib/iter/every-by","@stdlib/math-iter-special-exp":"@stdlib/math/iter/special/exp","@stdlib/math-iter-special-exp2":"@stdlib/math/iter/special/exp2","@stdlib/math-iter-special-exp10":"@stdlib/math/iter/special/exp10","@stdlib/math-iter-special-expit":"@stdlib/math/iter/special/expit","@stdlib/math-iter-special-expm1":"@stdlib/math/iter/special/expm1","@stdlib/math-iter-special-expm1rel":"@stdlib/math/iter/special/expm1rel","@stdlib/math-iter-special-factorial":"@stdlib/math/iter/special/factorial","@stdlib/math-iter-special-factorialln":"@stdlib/math/iter/special/factorialln","@stdlib/math-iter-sequences-factorials":"@stdlib/math/iter/sequences/factorials","@stdlib/math-iter-sequences-fibonacci":"@stdlib/math/iter/sequences/fibonacci","@stdlib/math-iter-sequences-fifth-powers":"@stdlib/math/iter/sequences/fifth-powers","@stdlib/iter-fill":"@stdlib/iter/fill","@stdlib/iter-filter":"@stdlib/iter/filter","@stdlib/iter-filter-map":"@stdlib/iter/filter-map","@stdlib/iter-first":"@stdlib/iter/first","@stdlib/simulate-iter-flat-top-pulse":"@stdlib/simulate/iter/flat-top-pulse","@stdlib/math-iter-special-floor":"@stdlib/math/iter/special/floor","@stdlib/math-iter-special-floor2":"@stdlib/math/iter/special/floor2","@stdlib/math-iter-special-floor10":"@stdlib/math/iter/special/floor10","@stdlib/iter-flow":"@stdlib/iter/flow","@stdlib/iter-for-each":"@stdlib/iter/for-each","@stdlib/math-iter-sequences-fourth-powers":"@stdlib/math/iter/sequences/fourth-powers","@stdlib/math-iter-special-fresnelc":"@stdlib/math/iter/special/fresnelc","@stdlib/math-iter-special-fresnels":"@stdlib/math/iter/special/fresnels","@stdlib/math-iter-special-gamma":"@stdlib/math/iter/special/gamma","@stdlib/math-iter-special-gamma1pm1":"@stdlib/math/iter/special/gamma1pm1","@stdlib/math-iter-special-gammaln":"@stdlib/math/iter/special/gammaln","@stdlib/math-iter-special-hacovercos":"@stdlib/math/iter/special/hacovercos","@stdlib/math-iter-special-hacoversin":"@stdlib/math/iter/special/hacoversin","@stdlib/simulate-iter-hann-pulse":"@stdlib/simulate/iter/hann-pulse","@stdlib/math-iter-special-havercos":"@stdlib/math/iter/special/havercos","@stdlib/math-iter-special-haversin":"@stdlib/math/iter/special/haversin","@stdlib/iter-head":"@stdlib/iter/head","@stdlib/iter-incrspace":"@stdlib/iter/incrspace","@stdlib/math-iter-sequences-integers":"@stdlib/math/iter/sequences/integers","@stdlib/iter-intersection":"@stdlib/iter/intersection","@stdlib/iter-intersection-by-hash":"@stdlib/iter/intersection-by-hash","@stdlib/math-iter-special-inv":"@stdlib/math/iter/special/inv","@stdlib/simulate-iter-lanczos-pulse":"@stdlib/simulate/iter/lanczos-pulse","@stdlib/iter-last":"@stdlib/iter/last","@stdlib/iter-length":"@stdlib/iter/length","@stdlib/iter-linspace":"@stdlib/iter/linspace","@stdlib/math-iter-special-ln":"@stdlib/math/iter/special/ln","@stdlib/math-iter-special-log":"@stdlib/math/iter/special/log","@stdlib/math-iter-special-log1mexp":"@stdlib/math/iter/special/log1mexp","@stdlib/math-iter-special-log1p":"@stdlib/math/iter/special/log1p","@stdlib/math-iter-special-log1pexp":"@stdlib/math/iter/special/log1pexp","@stdlib/math-iter-special-log2":"@stdlib/math/iter/special/log2","@stdlib/math-iter-special-log10":"@stdlib/math/iter/special/log10","@stdlib/math-iter-special-logit":"@stdlib/math/iter/special/logit","@stdlib/iter-logspace":"@stdlib/iter/logspace","@stdlib/math-iter-sequences-lucas":"@stdlib/math/iter/sequences/lucas","@stdlib/iter-map":"@stdlib/iter/map","@stdlib/iter-mapn":"@stdlib/iter/mapn","@stdlib/stats-iter-max":"@stdlib/stats/iter/max","@stdlib/stats-iter-maxabs":"@stdlib/stats/iter/maxabs","@stdlib/stats-iter-mean":"@stdlib/stats/iter/mean","@stdlib/stats-iter-meanabs":"@stdlib/stats/iter/meanabs","@stdlib/stats-iter-meanabs2":"@stdlib/stats/iter/meanabs2","@stdlib/stats-iter-midrange":"@stdlib/stats/iter/midrange","@stdlib/stats-iter-min":"@stdlib/stats/iter/min","@stdlib/stats-iter-minabs":"@stdlib/stats/iter/minabs","@stdlib/stats-iter-mmax":"@stdlib/stats/iter/mmax","@stdlib/stats-iter-mmaxabs":"@stdlib/stats/iter/mmaxabs","@stdlib/stats-iter-mmean":"@stdlib/stats/iter/mmean","@stdlib/stats-iter-mmeanabs":"@stdlib/stats/iter/mmeanabs","@stdlib/stats-iter-mmeanabs2":"@stdlib/stats/iter/mmeanabs2","@stdlib/stats-iter-mmidrange":"@stdlib/stats/iter/mmidrange","@stdlib/stats-iter-mmin":"@stdlib/stats/iter/mmin","@stdlib/stats-iter-mminabs":"@stdlib/stats/iter/mminabs","@stdlib/math-iter-ops-mod":"@stdlib/math/iter/ops/mod","@stdlib/stats-iter-mprod":"@stdlib/stats/iter/mprod","@stdlib/stats-iter-mrange":"@stdlib/stats/iter/mrange","@stdlib/stats-iter-msum":"@stdlib/stats/iter/msum","@stdlib/stats-iter-msumabs":"@stdlib/stats/iter/msumabs","@stdlib/stats-iter-msumabs2":"@stdlib/stats/iter/msumabs2","@stdlib/math-iter-ops-multiply":"@stdlib/math/iter/ops/multiply","@stdlib/math-iter-sequences-negafibonacci":"@stdlib/math/iter/sequences/negafibonacci","@stdlib/math-iter-sequences-negalucas":"@stdlib/math/iter/sequences/negalucas","@stdlib/math-iter-sequences-negative-even-integers":"@stdlib/math/iter/sequences/negative-even-integers","@stdlib/math-iter-sequences-negative-integers":"@stdlib/math/iter/sequences/negative-integers","@stdlib/math-iter-sequences-negative-odd-integers":"@stdlib/math/iter/sequences/negative-odd-integers","@stdlib/iter-none":"@stdlib/iter/none","@stdlib/iter-none-by":"@stdlib/iter/none-by","@stdlib/math-iter-sequences-nonfibonacci":"@stdlib/math/iter/sequences/nonfibonacci","@stdlib/math-iter-sequences-nonnegative-even-integers":"@stdlib/math/iter/sequences/nonnegative-even-integers","@stdlib/math-iter-sequences-nonnegative-integers":"@stdlib/math/iter/sequences/nonnegative-integers","@stdlib/math-iter-sequences-nonpositive-even-integers":"@stdlib/math/iter/sequences/nonpositive-even-integers","@stdlib/math-iter-sequences-nonpositive-integers":"@stdlib/math/iter/sequences/nonpositive-integers","@stdlib/math-iter-sequences-nonsquares":"@stdlib/math/iter/sequences/nonsquares","@stdlib/iter-nth":"@stdlib/iter/nth","@stdlib/math-iter-sequences-odd-integers":"@stdlib/math/iter/sequences/odd-integers","@stdlib/simulate-iter-periodic-sinc":"@stdlib/simulate/iter/periodic-sinc","@stdlib/iter-pipeline":"@stdlib/iter/pipeline","@stdlib/iter-pop":"@stdlib/iter/pop","@stdlib/math-iter-sequences-positive-even-integers":"@stdlib/math/iter/sequences/positive-even-integers","@stdlib/math-iter-sequences-positive-integers":"@stdlib/math/iter/sequences/positive-integers","@stdlib/math-iter-sequences-positive-odd-integers":"@stdlib/math/iter/sequences/positive-odd-integers","@stdlib/math-iter-special-pow":"@stdlib/math/iter/special/pow","@stdlib/math-iter-sequences-primes":"@stdlib/math/iter/sequences/primes","@stdlib/stats-iter-prod":"@stdlib/stats/iter/prod","@stdlib/simulate-iter-pulse":"@stdlib/simulate/iter/pulse","@stdlib/iter-push":"@stdlib/iter/push","@stdlib/math-iter-special-rad2deg":"@stdlib/math/iter/special/rad2deg","@stdlib/math-iter-special-ramp":"@stdlib/math/iter/special/ramp","@stdlib/stats-iter-range":"@stdlib/stats/iter/range","@stdlib/iter-reject":"@stdlib/iter/reject","@stdlib/iter-replicate":"@stdlib/iter/replicate","@stdlib/iter-replicate-by":"@stdlib/iter/replicate-by","@stdlib/math-iter-special-round":"@stdlib/math/iter/special/round","@stdlib/math-iter-special-round2":"@stdlib/math/iter/special/round2","@stdlib/math-iter-special-round10":"@stdlib/math/iter/special/round10","@stdlib/math-iter-special-rsqrt":"@stdlib/math/iter/special/rsqrt","@stdlib/simulate-iter-sawtooth-wave":"@stdlib/simulate/iter/sawtooth-wave","@stdlib/iter-shift":"@stdlib/iter/shift","@stdlib/math-iter-special-signum":"@stdlib/math/iter/special/signum","@stdlib/math-iter-special-sin":"@stdlib/math/iter/special/sin","@stdlib/math-iter-special-sinc":"@stdlib/math/iter/special/sinc","@stdlib/simulate-iter-sine-wave":"@stdlib/simulate/iter/sine-wave","@stdlib/math-iter-special-sinh":"@stdlib/math/iter/special/sinh","@stdlib/math-iter-special-sinpi":"@stdlib/math/iter/special/sinpi","@stdlib/iter-slice":"@stdlib/iter/slice","@stdlib/iter-some":"@stdlib/iter/some","@stdlib/iter-some-by":"@stdlib/iter/some-by","@stdlib/math-iter-special-spence":"@stdlib/math/iter/special/spence","@stdlib/math-iter-special-sqrt":"@stdlib/math/iter/special/sqrt","@stdlib/math-iter-special-sqrt1pm1":"@stdlib/math/iter/special/sqrt1pm1","@stdlib/math-iter-sequences-squared-triangular":"@stdlib/math/iter/sequences/squared-triangular","@stdlib/math-iter-sequences-squares":"@stdlib/math/iter/sequences/squares","@stdlib/simulate-iter-square-wave":"@stdlib/simulate/iter/square-wave","@stdlib/stats-iter-stdev":"@stdlib/stats/iter/stdev","@stdlib/iter-step":"@stdlib/iter/step","@stdlib/iter-strided":"@stdlib/iter/strided","@stdlib/iter-strided-by":"@stdlib/iter/strided-by","@stdlib/math-iter-ops-subtract":"@stdlib/math/iter/ops/subtract","@stdlib/stats-iter-sum":"@stdlib/stats/iter/sum","@stdlib/stats-iter-sumabs":"@stdlib/stats/iter/sumabs","@stdlib/stats-iter-sumabs2":"@stdlib/stats/iter/sumabs2","@stdlib/math-iter-special-tan":"@stdlib/math/iter/special/tan","@stdlib/math-iter-special-tanh":"@stdlib/math/iter/special/tanh","@stdlib/iter-pipeline-thunk":"@stdlib/iter/pipeline-thunk","@stdlib/simulate-iter-triangle-wave":"@stdlib/simulate/iter/triangle-wave","@stdlib/math-iter-sequences-triangular":"@stdlib/math/iter/sequences/triangular","@stdlib/math-iter-sequences-tribonacci":"@stdlib/math/iter/sequences/tribonacci","@stdlib/math-iter-special-trigamma":"@stdlib/math/iter/special/trigamma","@stdlib/math-iter-special-trunc":"@stdlib/math/iter/special/trunc","@stdlib/math-iter-special-trunc2":"@stdlib/math/iter/special/trunc2","@stdlib/math-iter-special-trunc10":"@stdlib/math/iter/special/trunc10","@stdlib/iter-union":"@stdlib/iter/union","@stdlib/iter-unique":"@stdlib/iter/unique","@stdlib/iter-unique-by":"@stdlib/iter/unique-by","@stdlib/iter-unique-by-hash":"@stdlib/iter/unique-by-hash","@stdlib/iter-unitspace":"@stdlib/iter/unitspace","@stdlib/iter-unshift":"@stdlib/iter/unshift","@stdlib/iter-until-each":"@stdlib/iter/until-each","@stdlib/stats-iter-variance":"@stdlib/stats/iter/variance","@stdlib/math-iter-special-vercos":"@stdlib/math/iter/special/vercos","@stdlib/math-iter-special-versin":"@stdlib/math/iter/special/versin","@stdlib/iter-while-each":"@stdlib/iter/while-each","@stdlib/math-iter-special-riemann-zeta":"@stdlib/math/iter/special/riemann-zeta","@stdlib/streams-node-join":"@stdlib/streams/node/join","@stdlib/stats-kde2d":"@stdlib/stats/kde2d","@stdlib/string-kebabcase":"@stdlib/string/kebabcase","@stdlib/utils-key-by":"@stdlib/utils/key-by","@stdlib/utils-key-by-right":"@stdlib/utils/key-by-right","@stdlib/utils-keys-in":"@stdlib/utils/keys-in","@stdlib/stats-kruskal-test":"@stdlib/stats/kruskal-test","@stdlib/stats-kstest":"@stdlib/stats/kstest","@stdlib/string-last":"@stdlib/string/last","@stdlib/nlp-lda":"@stdlib/nlp/lda","@stdlib/stats-levene-test":"@stdlib/stats/levene-test","@stdlib/dstructs-linked-list":"@stdlib/dstructs/linked-list","@stdlib/array-linspace":"@stdlib/array/linspace","@stdlib/datasets-liu-negative-opinion-words-en":"@stdlib/datasets/liu-negative-opinion-words-en","@stdlib/datasets-liu-positive-opinion-words-en":"@stdlib/datasets/liu-positive-opinion-words-en","@stdlib/constants-float64-ln-half":"@stdlib/constants/float64/ln-half","@stdlib/constants-float64-ln-pi":"@stdlib/constants/float64/ln-pi","@stdlib/constants-float64-ln-sqrt-two-pi":"@stdlib/constants/float64/ln-sqrt-two-pi","@stdlib/constants-float64-ln-two-pi":"@stdlib/constants/float64/ln-two-pi","@stdlib/constants-float64-ln-two":"@stdlib/constants/float64/ln-two","@stdlib/constants-float64-ln-ten":"@stdlib/constants/float64/ln-ten","@stdlib/constants-float64-log2-e":"@stdlib/constants/float64/log2-e","@stdlib/constants-float64-log10-e":"@stdlib/constants/float64/log10-e","@stdlib/array-logspace":"@stdlib/array/logspace","@stdlib/string-lowercase":"@stdlib/string/lowercase","@stdlib/utils-lowercase-keys":"@stdlib/utils/lowercase-keys","@stdlib/stats-lowess":"@stdlib/stats/lowess","@stdlib/string-left-pad":"@stdlib/string/left-pad","@stdlib/string-left-trim":"@stdlib/string/left-trim","@stdlib/string-left-trim-n":"@stdlib/string/left-trim-n","@stdlib/datasets-male-first-names-en":"@stdlib/datasets/male-first-names-en","@stdlib/utils-map":"@stdlib/utils/map","@stdlib/utils-map2":"@stdlib/utils/map2","@stdlib/utils-map2d":"@stdlib/utils/map2d","@stdlib/utils-map2-right":"@stdlib/utils/map2-right","@stdlib/utils-map3d":"@stdlib/utils/map3d","@stdlib/utils-map4d":"@stdlib/utils/map4d","@stdlib/utils-map5d":"@stdlib/utils/map5d","@stdlib/utils-map-arguments":"@stdlib/utils/map-arguments","@stdlib/utils-map-function":"@stdlib/utils/map-function","@stdlib/utils-async-map-function":"@stdlib/utils/async/map-function","@stdlib/utils-map-keys":"@stdlib/utils/map-keys","@stdlib/utils-async-map-keys":"@stdlib/utils/async/map-keys","@stdlib/utils-map-reduce":"@stdlib/utils/map-reduce","@stdlib/utils-map-reduce-right":"@stdlib/utils/map-reduce-right","@stdlib/utils-map-right":"@stdlib/utils/map-right","@stdlib/utils-map-values":"@stdlib/utils/map-values","@stdlib/utils-async-map-values":"@stdlib/utils/async/map-values","@stdlib/utils-mask-arguments":"@stdlib/utils/mask-arguments","@stdlib/constants-array-max-array-length":"@stdlib/constants/array/max-array-length","@stdlib/constants-array-max-typed-array-length":"@stdlib/constants/array/max-typed-array-length","@stdlib/ndarray-maybe-broadcast-array":"@stdlib/ndarray/maybe-broadcast-array","@stdlib/ndarray-maybe-broadcast-arrays":"@stdlib/ndarray/maybe-broadcast-arrays","@stdlib/utils-memoize":"@stdlib/utils/memoize","@stdlib/utils-merge":"@stdlib/utils/merge","@stdlib/constants-time-milliseconds-in-day":"@stdlib/constants/time/milliseconds-in-day","@stdlib/constants-time-milliseconds-in-hour":"@stdlib/constants/time/milliseconds-in-hour","@stdlib/constants-time-milliseconds-in-minute":"@stdlib/constants/time/milliseconds-in-minute","@stdlib/constants-time-milliseconds-in-second":"@stdlib/constants/time/milliseconds-in-second","@stdlib/constants-time-milliseconds-in-week":"@stdlib/constants/time/milliseconds-in-week","@stdlib/datasets-minard-napoleons-march":"@stdlib/datasets/minard-napoleons-march","@stdlib/constants-time-minutes-in-day":"@stdlib/constants/time/minutes-in-day","@stdlib/constants-time-minutes-in-hour":"@stdlib/constants/time/minutes-in-hour","@stdlib/constants-time-minutes-in-week":"@stdlib/constants/time/minutes-in-week","@stdlib/time-minutes-in-month":"@stdlib/time/minutes-in-month","@stdlib/time-minutes-in-year":"@stdlib/time/minutes-in-year","@stdlib/datasets-moby-dick":"@stdlib/datasets/moby-dick","@stdlib/datasets-month-names-en":"@stdlib/datasets/month-names-en","@stdlib/constants-time-months-in-year":"@stdlib/constants/time/months-in-year","@stdlib/utils-move-property":"@stdlib/utils/move-property","@stdlib/slice-multi":"@stdlib/slice/multi","@stdlib/dstructs-named-typed-tuple":"@stdlib/dstructs/named-typed-tuple","@stdlib/constants-float64-nan":"@stdlib/constants/float64/nan","@stdlib/utils-nary-function":"@stdlib/utils/nary-function","@stdlib/utils-native-class":"@stdlib/utils/native-class","@stdlib/ndarray-ctor":"@stdlib/ndarray/ctor","@stdlib/ndarray-to-array":"@stdlib/ndarray/to-array","@stdlib/ndarray-to-fancy":"@stdlib/ndarray/to-fancy","@stdlib/ndarray-to-json":"@stdlib/ndarray/to-json","@stdlib/ndarray-casting-modes":"@stdlib/ndarray/casting-modes","@stdlib/ndarray-data-buffer":"@stdlib/ndarray/data-buffer","@stdlib/ndarray-dtype":"@stdlib/ndarray/dtype","@stdlib/ndarray-dtypes":"@stdlib/ndarray/dtypes","@stdlib/ndarray-dispatch":"@stdlib/ndarray/dispatch","@stdlib/ndarray-flag":"@stdlib/ndarray/flag","@stdlib/ndarray-flags":"@stdlib/ndarray/flags","@stdlib/ndarray-index-modes":"@stdlib/ndarray/index-modes","@stdlib/ndarray-ndarraylike2ndarray":"@stdlib/ndarray/ndarraylike2ndarray","@stdlib/ndarray-min-dtype":"@stdlib/ndarray/min-dtype","@stdlib/ndarray-mostly-safe-casts":"@stdlib/ndarray/mostly-safe-casts","@stdlib/ndarray-next-dtype":"@stdlib/ndarray/next-dtype","@stdlib/ndarray-offset":"@stdlib/ndarray/offset","@stdlib/ndarray-order":"@stdlib/ndarray/order","@stdlib/ndarray-orders":"@stdlib/ndarray/orders","@stdlib/ndarray-promotion-rules":"@stdlib/ndarray/promotion-rules","@stdlib/ndarray-safe-casts":"@stdlib/ndarray/safe-casts","@stdlib/ndarray-same-kind-casts":"@stdlib/ndarray/same-kind-casts","@stdlib/ndarray-shape":"@stdlib/ndarray/shape","@stdlib/ndarray-stride":"@stdlib/ndarray/stride","@stdlib/ndarray-strides":"@stdlib/ndarray/strides","@stdlib/ndarray-at":"@stdlib/ndarray/at","@stdlib/ndarray-empty":"@stdlib/ndarray/empty","@stdlib/ndarray-empty-like":"@stdlib/ndarray/empty-like","@stdlib/ndarray-filter":"@stdlib/ndarray/filter","@stdlib/ndarray-filter-map":"@stdlib/ndarray/filter-map","@stdlib/ndarray-for-each":"@stdlib/ndarray/for-each","@stdlib/ndarray-ndims":"@stdlib/ndarray/ndims","@stdlib/ndarray-index":"@stdlib/ndarray/index","@stdlib/ndarray-iter-to-array-each":"@stdlib/ndarray/iter/to-array-each","@stdlib/ndarray-iter-column-entries":"@stdlib/ndarray/iter/column-entries","@stdlib/ndarray-iter-columns":"@stdlib/ndarray/iter/columns","@stdlib/ndarray-iter-entries":"@stdlib/ndarray/iter/entries","@stdlib/ndarray-iter-indices":"@stdlib/ndarray/iter/indices","@stdlib/ndarray-iter-interleave-subarrays":"@stdlib/ndarray/iter/interleave-subarrays","@stdlib/ndarray-iter-matrices":"@stdlib/ndarray/iter/matrices","@stdlib/ndarray-iter-matrix-entries":"@stdlib/ndarray/iter/matrix-entries","@stdlib/ndarray-iter-row-entries":"@stdlib/ndarray/iter/row-entries","@stdlib/ndarray-iter-rows":"@stdlib/ndarray/iter/rows","@stdlib/ndarray-iter-select-dimension":"@stdlib/ndarray/iter/select-dimension","@stdlib/ndarray-iter-stacks":"@stdlib/ndarray/iter/stacks","@stdlib/ndarray-iter-subarrays":"@stdlib/ndarray/iter/subarrays","@stdlib/ndarray-iter-values":"@stdlib/ndarray/iter/values","@stdlib/ndarray-map":"@stdlib/ndarray/map","@stdlib/ndarray-reject":"@stdlib/ndarray/reject","@stdlib/ndarray-slice":"@stdlib/ndarray/slice","@stdlib/ndarray-slice-assign":"@stdlib/ndarray/slice-assign","@stdlib/ndarray-slice-dimension":"@stdlib/ndarray/slice-dimension","@stdlib/ndarray-slice-dimension-from":"@stdlib/ndarray/slice-dimension-from","@stdlib/ndarray-slice-dimension-to":"@stdlib/ndarray/slice-dimension-to","@stdlib/ndarray-slice-from":"@stdlib/ndarray/slice-from","@stdlib/ndarray-slice-to":"@stdlib/ndarray/slice-to","@stdlib/ndarray-zeros":"@stdlib/ndarray/zeros","@stdlib/ndarray-zeros-like":"@stdlib/ndarray/zeros-like","@stdlib/string-next-grapheme-cluster-break":"@stdlib/string/next-grapheme-cluster-break","@stdlib/utils-next-tick":"@stdlib/utils/next-tick","@stdlib/datasets-nightingales-rose":"@stdlib/datasets/nightingales-rose","@stdlib/constants-float64-ninf":"@stdlib/constants/float64/ninf","@stdlib/process-node-version":"@stdlib/process/node-version","@stdlib/utils-none":"@stdlib/utils/none","@stdlib/utils-none-by":"@stdlib/utils/none-by","@stdlib/utils-async-none-by":"@stdlib/utils/async/none-by","@stdlib/utils-none-by-right":"@stdlib/utils/none-by-right","@stdlib/utils-async-none-by-right":"@stdlib/utils/async/none-by-right","@stdlib/utils-none-in-by":"@stdlib/utils/none-in-by","@stdlib/utils-nonenumerable-properties":"@stdlib/utils/nonenumerable-properties","@stdlib/utils-nonenumerable-properties-in":"@stdlib/utils/nonenumerable-properties-in","@stdlib/utils-nonenumerable-property-names":"@stdlib/utils/nonenumerable-property-names","@stdlib/utils-nonenumerable-property-names-in":"@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils-nonenumerable-property-symbols":"@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils-nonenumerable-property-symbols-in":"@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils-none-own-by":"@stdlib/utils/none-own-by","@stdlib/utils-nonindex-keys":"@stdlib/utils/nonindex-keys","@stdlib/utils-noop":"@stdlib/utils/noop","@stdlib/time-now":"@stdlib/time/now","@stdlib/os-num-cpus":"@stdlib/os/num-cpus","@stdlib/string-num2words":"@stdlib/string/num2words","@stdlib/number-ctor":"@stdlib/number/ctor","@stdlib/ndarray-numel":"@stdlib/ndarray/numel","@stdlib/ndarray-numel-dimension":"@stdlib/ndarray/numel-dimension","@stdlib/string-num-grapheme-clusters":"@stdlib/string/num-grapheme-clusters","@stdlib/object-ctor":"@stdlib/object/ctor","@stdlib/utils-entries":"@stdlib/utils/entries","@stdlib/utils-entries-in":"@stdlib/utils/entries-in","@stdlib/utils-from-entries":"@stdlib/utils/from-entries","@stdlib/utils-object-inverse":"@stdlib/utils/object-inverse","@stdlib/utils-object-inverse-by":"@stdlib/utils/object-inverse-by","@stdlib/utils-keys":"@stdlib/utils/keys","@stdlib/utils-values":"@stdlib/utils/values","@stdlib/utils-values-in":"@stdlib/utils/values-in","@stdlib/utils-omit":"@stdlib/utils/omit","@stdlib/utils-omit-by":"@stdlib/utils/omit-by","@stdlib/fs-open":"@stdlib/fs/open","@stdlib/utils-open-url":"@stdlib/utils/open-url","@stdlib/nlp-ordinalize":"@stdlib/nlp/ordinalize","@stdlib/datasets-pace-boston-house-prices":"@stdlib/datasets/pace-boston-house-prices","@stdlib/string-pad":"@stdlib/string/pad","@stdlib/stats-padjust":"@stdlib/stats/padjust","@stdlib/utils-papply":"@stdlib/utils/papply","@stdlib/utils-papply-right":"@stdlib/utils/papply-right","@stdlib/utils-parallel":"@stdlib/utils/parallel","@stdlib/utils-parse-json":"@stdlib/utils/parse-json","@stdlib/string-pascalcase":"@stdlib/string/pascalcase","@stdlib/constants-path-delimiter":"@stdlib/constants/path/delimiter","@stdlib/constants-path-delimiter-posix":"@stdlib/constants/path/delimiter-posix","@stdlib/constants-path-delimiter-win32":"@stdlib/constants/path/delimiter-win32","@stdlib/constants-path-sep":"@stdlib/constants/path/sep","@stdlib/constants-path-sep-posix":"@stdlib/constants/path/sep-posix","@stdlib/constants-path-sep-win32":"@stdlib/constants/path/sep-win32","@stdlib/stats-pcorrtest":"@stdlib/stats/pcorrtest","@stdlib/string-percent-encode":"@stdlib/string/percent-encode","@stdlib/constants-float64-phi":"@stdlib/constants/float64/phi","@stdlib/constants-float64-pi":"@stdlib/constants/float64/pi","@stdlib/constants-float64-pi-squared":"@stdlib/constants/float64/pi-squared","@stdlib/utils-pick":"@stdlib/utils/pick","@stdlib/utils-pick-arguments":"@stdlib/utils/pick-arguments","@stdlib/utils-pick-by":"@stdlib/utils/pick-by","@stdlib/constants-float64-pinf":"@stdlib/constants/float64/pinf","@stdlib/namespace-pkg2alias":"@stdlib/namespace/pkg2alias","@stdlib/namespace-pkg2related":"@stdlib/namespace/pkg2related","@stdlib/namespace-pkg2standalone":"@stdlib/namespace/pkg2standalone","@stdlib/os-platform":"@stdlib/os/platform","@stdlib/plot":"@stdlib/plot","@stdlib/plot-ctor":"@stdlib/plot/ctor","@stdlib/utils-pluck":"@stdlib/utils/pluck","@stdlib/utils-pop":"@stdlib/utils/pop","@stdlib/nlp-porter-stemmer":"@stdlib/nlp/porter-stemmer","@stdlib/utils-prepend":"@stdlib/utils/prepend","@stdlib/string-prev-grapheme-cluster-break":"@stdlib/string/prev-grapheme-cluster-break","@stdlib/datasets-primes-100k":"@stdlib/datasets/primes-100k","@stdlib/utils-properties":"@stdlib/utils/properties","@stdlib/utils-properties-in":"@stdlib/utils/properties-in","@stdlib/utils-property-descriptor":"@stdlib/utils/property-descriptor","@stdlib/utils-property-descriptor-in":"@stdlib/utils/property-descriptor-in","@stdlib/utils-property-descriptors":"@stdlib/utils/property-descriptors","@stdlib/utils-property-descriptors-in":"@stdlib/utils/property-descriptors-in","@stdlib/utils-property-names":"@stdlib/utils/property-names","@stdlib/utils-property-names-in":"@stdlib/utils/property-names-in","@stdlib/utils-property-symbols":"@stdlib/utils/property-symbols","@stdlib/utils-property-symbols-in":"@stdlib/utils/property-symbols-in","@stdlib/proxy-ctor":"@stdlib/proxy/ctor","@stdlib/utils-push":"@stdlib/utils/push","@stdlib/time-quarter-of-year":"@stdlib/time/quarter-of-year","@stdlib/random-array-arcsine":"@stdlib/random/array/arcsine","@stdlib/random-array-bernoulli":"@stdlib/random/array/bernoulli","@stdlib/random-array-beta":"@stdlib/random/array/beta","@stdlib/random-array-betaprime":"@stdlib/random/array/betaprime","@stdlib/random-array-binomial":"@stdlib/random/array/binomial","@stdlib/random-array-cauchy":"@stdlib/random/array/cauchy","@stdlib/random-array-chi":"@stdlib/random/array/chi","@stdlib/random-array-chisquare":"@stdlib/random/array/chisquare","@stdlib/random-array-cosine":"@stdlib/random/array/cosine","@stdlib/random-array-discrete-uniform":"@stdlib/random/array/discrete-uniform","@stdlib/random-array-erlang":"@stdlib/random/array/erlang","@stdlib/random-array-exponential":"@stdlib/random/array/exponential","@stdlib/random-array-f":"@stdlib/random/array/f","@stdlib/random-array-frechet":"@stdlib/random/array/frechet","@stdlib/random-array-gamma":"@stdlib/random/array/gamma","@stdlib/random-array-geometric":"@stdlib/random/array/geometric","@stdlib/random-array-gumbel":"@stdlib/random/array/gumbel","@stdlib/random-array-hypergeometric":"@stdlib/random/array/hypergeometric","@stdlib/random-array-invgamma":"@stdlib/random/array/invgamma","@stdlib/random-array-kumaraswamy":"@stdlib/random/array/kumaraswamy","@stdlib/random-array-laplace":"@stdlib/random/array/laplace","@stdlib/random-array-levy":"@stdlib/random/array/levy","@stdlib/random-array-logistic":"@stdlib/random/array/logistic","@stdlib/random-array-lognormal":"@stdlib/random/array/lognormal","@stdlib/random-array-minstd":"@stdlib/random/array/minstd","@stdlib/random-array-minstd-shuffle":"@stdlib/random/array/minstd-shuffle","@stdlib/random-array-mt19937":"@stdlib/random/array/mt19937","@stdlib/random-array-negative-binomial":"@stdlib/random/array/negative-binomial","@stdlib/random-array-normal":"@stdlib/random/array/normal","@stdlib/random-array-pareto-type1":"@stdlib/random/array/pareto-type1","@stdlib/random-array-poisson":"@stdlib/random/array/poisson","@stdlib/random-array-randu":"@stdlib/random/array/randu","@stdlib/random-array-rayleigh":"@stdlib/random/array/rayleigh","@stdlib/random-array-t":"@stdlib/random/array/t","@stdlib/random-array-triangular":"@stdlib/random/array/triangular","@stdlib/random-array-uniform":"@stdlib/random/array/uniform","@stdlib/random-array-weibull":"@stdlib/random/array/weibull","@stdlib/random-iter-arcsine":"@stdlib/random/iter/arcsine","@stdlib/random-iter-bernoulli":"@stdlib/random/iter/bernoulli","@stdlib/random-iter-beta":"@stdlib/random/iter/beta","@stdlib/random-iter-betaprime":"@stdlib/random/iter/betaprime","@stdlib/random-iter-binomial":"@stdlib/random/iter/binomial","@stdlib/random-iter-box-muller":"@stdlib/random/iter/box-muller","@stdlib/random-iter-cauchy":"@stdlib/random/iter/cauchy","@stdlib/random-iter-chi":"@stdlib/random/iter/chi","@stdlib/random-iter-chisquare":"@stdlib/random/iter/chisquare","@stdlib/random-iter-cosine":"@stdlib/random/iter/cosine","@stdlib/random-iter-discrete-uniform":"@stdlib/random/iter/discrete-uniform","@stdlib/random-iter-erlang":"@stdlib/random/iter/erlang","@stdlib/random-iter-exponential":"@stdlib/random/iter/exponential","@stdlib/random-iter-f":"@stdlib/random/iter/f","@stdlib/random-iter-frechet":"@stdlib/random/iter/frechet","@stdlib/random-iter-gamma":"@stdlib/random/iter/gamma","@stdlib/random-iter-geometric":"@stdlib/random/iter/geometric","@stdlib/random-iter-gumbel":"@stdlib/random/iter/gumbel","@stdlib/random-iter-hypergeometric":"@stdlib/random/iter/hypergeometric","@stdlib/random-iter-improved-ziggurat":"@stdlib/random/iter/improved-ziggurat","@stdlib/random-iter-invgamma":"@stdlib/random/iter/invgamma","@stdlib/random-iter-kumaraswamy":"@stdlib/random/iter/kumaraswamy","@stdlib/random-iter-laplace":"@stdlib/random/iter/laplace","@stdlib/random-iter-levy":"@stdlib/random/iter/levy","@stdlib/random-iter-logistic":"@stdlib/random/iter/logistic","@stdlib/random-iter-lognormal":"@stdlib/random/iter/lognormal","@stdlib/random-iter-minstd":"@stdlib/random/iter/minstd","@stdlib/random-iter-minstd-shuffle":"@stdlib/random/iter/minstd-shuffle","@stdlib/random-iter-mt19937":"@stdlib/random/iter/mt19937","@stdlib/random-iter-negative-binomial":"@stdlib/random/iter/negative-binomial","@stdlib/random-iter-normal":"@stdlib/random/iter/normal","@stdlib/random-iter-pareto-type1":"@stdlib/random/iter/pareto-type1","@stdlib/random-iter-poisson":"@stdlib/random/iter/poisson","@stdlib/random-iter-randi":"@stdlib/random/iter/randi","@stdlib/random-iter-randn":"@stdlib/random/iter/randn","@stdlib/random-iter-randu":"@stdlib/random/iter/randu","@stdlib/random-iter-rayleigh":"@stdlib/random/iter/rayleigh","@stdlib/random-iter-t":"@stdlib/random/iter/t","@stdlib/random-iter-triangular":"@stdlib/random/iter/triangular","@stdlib/random-iter-uniform":"@stdlib/random/iter/uniform","@stdlib/random-iter-weibull":"@stdlib/random/iter/weibull","@stdlib/random-streams-arcsine":"@stdlib/random/streams/arcsine","@stdlib/random-streams-bernoulli":"@stdlib/random/streams/bernoulli","@stdlib/random-streams-beta":"@stdlib/random/streams/beta","@stdlib/random-streams-betaprime":"@stdlib/random/streams/betaprime","@stdlib/random-streams-binomial":"@stdlib/random/streams/binomial","@stdlib/random-streams-box-muller":"@stdlib/random/streams/box-muller","@stdlib/random-streams-cauchy":"@stdlib/random/streams/cauchy","@stdlib/random-streams-chi":"@stdlib/random/streams/chi","@stdlib/random-streams-chisquare":"@stdlib/random/streams/chisquare","@stdlib/random-streams-cosine":"@stdlib/random/streams/cosine","@stdlib/random-streams-discrete-uniform":"@stdlib/random/streams/discrete-uniform","@stdlib/random-streams-erlang":"@stdlib/random/streams/erlang","@stdlib/random-streams-exponential":"@stdlib/random/streams/exponential","@stdlib/random-streams-f":"@stdlib/random/streams/f","@stdlib/random-streams-frechet":"@stdlib/random/streams/frechet","@stdlib/random-streams-gamma":"@stdlib/random/streams/gamma","@stdlib/random-streams-geometric":"@stdlib/random/streams/geometric","@stdlib/random-streams-gumbel":"@stdlib/random/streams/gumbel","@stdlib/random-streams-hypergeometric":"@stdlib/random/streams/hypergeometric","@stdlib/random-streams-improved-ziggurat":"@stdlib/random/streams/improved-ziggurat","@stdlib/random-streams-invgamma":"@stdlib/random/streams/invgamma","@stdlib/random-streams-kumaraswamy":"@stdlib/random/streams/kumaraswamy","@stdlib/random-streams-laplace":"@stdlib/random/streams/laplace","@stdlib/random-streams-levy":"@stdlib/random/streams/levy","@stdlib/random-streams-logistic":"@stdlib/random/streams/logistic","@stdlib/random-streams-lognormal":"@stdlib/random/streams/lognormal","@stdlib/random-streams-minstd":"@stdlib/random/streams/minstd","@stdlib/random-streams-minstd-shuffle":"@stdlib/random/streams/minstd-shuffle","@stdlib/random-streams-mt19937":"@stdlib/random/streams/mt19937","@stdlib/random-streams-negative-binomial":"@stdlib/random/streams/negative-binomial","@stdlib/random-streams-normal":"@stdlib/random/streams/normal","@stdlib/random-streams-pareto-type1":"@stdlib/random/streams/pareto-type1","@stdlib/random-streams-poisson":"@stdlib/random/streams/poisson","@stdlib/random-streams-randi":"@stdlib/random/streams/randi","@stdlib/random-streams-randn":"@stdlib/random/streams/randn","@stdlib/random-streams-randu":"@stdlib/random/streams/randu","@stdlib/random-streams-rayleigh":"@stdlib/random/streams/rayleigh","@stdlib/random-streams-t":"@stdlib/random/streams/t","@stdlib/random-streams-triangular":"@stdlib/random/streams/triangular","@stdlib/random-streams-uniform":"@stdlib/random/streams/uniform","@stdlib/random-streams-weibull":"@stdlib/random/streams/weibull","@stdlib/random-strided-arcsine":"@stdlib/random/strided/arcsine","@stdlib/random-strided-bernoulli":"@stdlib/random/strided/bernoulli","@stdlib/random-strided-beta":"@stdlib/random/strided/beta","@stdlib/random-strided-betaprime":"@stdlib/random/strided/betaprime","@stdlib/random-strided-chi":"@stdlib/random/strided/chi","@stdlib/random-strided-chisquare":"@stdlib/random/strided/chisquare","@stdlib/random-strided-cosine":"@stdlib/random/strided/cosine","@stdlib/random-strided-discrete-uniform":"@stdlib/random/strided/discrete-uniform","@stdlib/random-strided-exponential":"@stdlib/random/strided/exponential","@stdlib/random-strided-gamma":"@stdlib/random/strided/gamma","@stdlib/random-strided-geometric":"@stdlib/random/strided/geometric","@stdlib/random-strided-invgamma":"@stdlib/random/strided/invgamma","@stdlib/random-strided-lognormal":"@stdlib/random/strided/lognormal","@stdlib/random-strided-minstd":"@stdlib/random/strided/minstd","@stdlib/random-strided-minstd-shuffle":"@stdlib/random/strided/minstd-shuffle","@stdlib/random-strided-mt19937":"@stdlib/random/strided/mt19937","@stdlib/random-strided-normal":"@stdlib/random/strided/normal","@stdlib/random-strided-poisson":"@stdlib/random/strided/poisson","@stdlib/random-strided-randu":"@stdlib/random/strided/randu","@stdlib/random-strided-rayleigh":"@stdlib/random/strided/rayleigh","@stdlib/random-strided-t":"@stdlib/random/strided/t","@stdlib/random-strided-uniform":"@stdlib/random/strided/uniform","@stdlib/random-strided-weibull":"@stdlib/random/strided/weibull","@stdlib/stats-ranks":"@stdlib/stats/ranks","@stdlib/fs-read-dir":"@stdlib/fs/read-dir","@stdlib/fs-read-file":"@stdlib/fs/read-file","@stdlib/fs-read-file-list":"@stdlib/fs/read-file-list","@stdlib/fs-read-json":"@stdlib/fs/read-json","@stdlib/fs-read-wasm":"@stdlib/fs/read-wasm","@stdlib/complex-float64-real":"@stdlib/complex/float64/real","@stdlib/array-typed-real":"@stdlib/array/typed-real","@stdlib/array-typed-real-ctors":"@stdlib/array/typed-real-ctors","@stdlib/array-typed-real-dtypes":"@stdlib/array/typed-real-dtypes","@stdlib/complex-float32-real":"@stdlib/complex/float32/real","@stdlib/utils-real-max":"@stdlib/utils/real-max","@stdlib/utils-real-min":"@stdlib/utils/real-min","@stdlib/regexp-basename":"@stdlib/regexp/basename","@stdlib/regexp-basename-posix":"@stdlib/regexp/basename-posix","@stdlib/regexp-basename-windows":"@stdlib/regexp/basename-windows","@stdlib/regexp-color-hexadecimal":"@stdlib/regexp/color-hexadecimal","@stdlib/regexp-decimal-number":"@stdlib/regexp/decimal-number","@stdlib/regexp-dirname":"@stdlib/regexp/dirname","@stdlib/regexp-dirname-posix":"@stdlib/regexp/dirname-posix","@stdlib/regexp-dirname-windows":"@stdlib/regexp/dirname-windows","@stdlib/utils-reduce":"@stdlib/utils/reduce","@stdlib/utils-reduce2d":"@stdlib/utils/reduce2d","@stdlib/utils-async-reduce":"@stdlib/utils/async/reduce","@stdlib/utils-reduce-right":"@stdlib/utils/reduce-right","@stdlib/utils-async-reduce-right":"@stdlib/utils/async/reduce-right","@stdlib/regexp-duration-string":"@stdlib/regexp/duration-string","@stdlib/regexp-eol":"@stdlib/regexp/eol","@stdlib/regexp-extended-length-path":"@stdlib/regexp/extended-length-path","@stdlib/regexp-extname":"@stdlib/regexp/extname","@stdlib/regexp-extname-posix":"@stdlib/regexp/extname-posix","@stdlib/regexp-extname-windows":"@stdlib/regexp/extname-windows","@stdlib/regexp-filename":"@stdlib/regexp/filename","@stdlib/regexp-filename-posix":"@stdlib/regexp/filename-posix","@stdlib/regexp-filename-windows":"@stdlib/regexp/filename-windows","@stdlib/utils-regexp-from-string":"@stdlib/utils/regexp-from-string","@stdlib/regexp-function-name":"@stdlib/regexp/function-name","@stdlib/regexp-to-json":"@stdlib/regexp/to-json","@stdlib/complex-float64-reim":"@stdlib/complex/float64/reim","@stdlib/complex-float32-reim":"@stdlib/complex/float32/reim","@stdlib/utils-reject-arguments":"@stdlib/utils/reject-arguments","@stdlib/string-remove-first":"@stdlib/string/remove-first","@stdlib/string-remove-last":"@stdlib/string/remove-last","@stdlib/string-remove-punctuation":"@stdlib/string/remove-punctuation","@stdlib/string-remove-utf8-bom":"@stdlib/string/remove-utf8-bom","@stdlib/string-remove-words":"@stdlib/string/remove-words","@stdlib/fs-rename":"@stdlib/fs/rename","@stdlib/regexp-native-function":"@stdlib/regexp/native-function","@stdlib/utils-reorder-arguments":"@stdlib/utils/reorder-arguments","@stdlib/string-repeat":"@stdlib/string/repeat","@stdlib/string-replace":"@stdlib/string/replace","@stdlib/string-replace-before":"@stdlib/string/replace-before","@stdlib/regexp-regexp":"@stdlib/regexp/regexp","@stdlib/utils-escape-regexp-string":"@stdlib/utils/escape-regexp-string","@stdlib/regexp-semver":"@stdlib/regexp/semver","@stdlib/fs-resolve-parent-path":"@stdlib/fs/resolve-parent-path","@stdlib/fs-resolve-parent-path-by":"@stdlib/fs/resolve-parent-path-by","@stdlib/regexp-unc-path":"@stdlib/regexp/unc-path","@stdlib/regexp-utf16-surrogate-pair":"@stdlib/regexp/utf16-surrogate-pair","@stdlib/regexp-utf16-unpaired-surrogate":"@stdlib/regexp/utf16-unpaired-surrogate","@stdlib/utils-reverse-arguments":"@stdlib/utils/reverse-arguments","@stdlib/string-reverse":"@stdlib/string/reverse","@stdlib/random-base-reviver":"@stdlib/random/base/reviver","@stdlib/buffer-reviver":"@stdlib/buffer/reviver","@stdlib/complex-reviver":"@stdlib/complex/reviver","@stdlib/complex-float32-reviver":"@stdlib/complex/float32/reviver","@stdlib/complex-float64-reviver":"@stdlib/complex/float64/reviver","@stdlib/error-reviver":"@stdlib/error/reviver","@stdlib/regexp-reviver":"@stdlib/regexp/reviver","@stdlib/array-reviver":"@stdlib/array/reviver","@stdlib/regexp-whitespace":"@stdlib/regexp/whitespace","@stdlib/string-right-pad":"@stdlib/string/right-pad","@stdlib/string-right-trim":"@stdlib/string/right-trim","@stdlib/string-right-trim-n":"@stdlib/string/right-trim-n","@stdlib/utils-safe-int-max":"@stdlib/utils/safe-int-max","@stdlib/utils-safe-int-min":"@stdlib/utils/safe-int-min","@stdlib/random-sample":"@stdlib/random/sample","@stdlib/datasets-savoy-stopwords-fin":"@stdlib/datasets/savoy-stopwords-fin","@stdlib/datasets-savoy-stopwords-fr":"@stdlib/datasets/savoy-stopwords-fr","@stdlib/datasets-savoy-stopwords-ger":"@stdlib/datasets/savoy-stopwords-ger","@stdlib/datasets-savoy-stopwords-it":"@stdlib/datasets/savoy-stopwords-it","@stdlib/datasets-savoy-stopwords-por":"@stdlib/datasets/savoy-stopwords-por","@stdlib/datasets-savoy-stopwords-sp":"@stdlib/datasets/savoy-stopwords-sp","@stdlib/datasets-savoy-stopwords-swe":"@stdlib/datasets/savoy-stopwords-swe","@stdlib/array-from-scalar":"@stdlib/array/from-scalar","@stdlib/ndarray-from-scalar":"@stdlib/ndarray/from-scalar","@stdlib/blas-sdot":"@stdlib/blas/sdot","@stdlib/constants-time-seconds-in-day":"@stdlib/constants/time/seconds-in-day","@stdlib/constants-time-seconds-in-hour":"@stdlib/constants/time/seconds-in-hour","@stdlib/constants-time-seconds-in-minute":"@stdlib/constants/time/seconds-in-minute","@stdlib/constants-time-seconds-in-week":"@stdlib/constants/time/seconds-in-week","@stdlib/time-seconds-in-month":"@stdlib/time/seconds-in-month","@stdlib/time-seconds-in-year":"@stdlib/time/seconds-in-year","@stdlib/nlp-sentencize":"@stdlib/nlp/sentencize","@stdlib/slice-seq2slice":"@stdlib/slice/seq2slice","@stdlib/utils-define-configurable-read-only-property":"@stdlib/utils/define-configurable-read-only-property","@stdlib/utils-define-configurable-read-only-accessor":"@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils-define-configurable-read-write-accessor":"@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils-define-configurable-write-only-accessor":"@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils-define-memoized-configurable-read-only-property":"@stdlib/utils/define-memoized-configurable-read-only-property","@stdlib/utils-define-memoized-read-only-property":"@stdlib/utils/define-memoized-read-only-property","@stdlib/utils-define-nonenumerable-property":"@stdlib/utils/define-nonenumerable-property","@stdlib/utils-define-nonenumerable-read-only-property":"@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils-define-nonenumerable-read-only-accessor":"@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils-define-nonenumerable-read-write-accessor":"@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils-define-nonenumerable-write-only-accessor":"@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils-define-read-only-property":"@stdlib/utils/define-read-only-property","@stdlib/utils-define-read-only-accessor":"@stdlib/utils/define-read-only-accessor","@stdlib/utils-define-read-write-accessor":"@stdlib/utils/define-read-write-accessor","@stdlib/utils-define-write-only-accessor":"@stdlib/utils/define-write-only-accessor","@stdlib/array-shared-buffer":"@stdlib/array/shared-buffer","@stdlib/utils-shift":"@stdlib/utils/shift","@stdlib/random-shuffle":"@stdlib/random/shuffle","@stdlib/utils-size-of":"@stdlib/utils/size-of","@stdlib/slice-ctor":"@stdlib/slice/ctor","@stdlib/string-snakecase":"@stdlib/string/snakecase","@stdlib/utils-some":"@stdlib/utils/some","@stdlib/utils-some-by":"@stdlib/utils/some-by","@stdlib/utils-async-some-by":"@stdlib/utils/async/some-by","@stdlib/utils-some-by-right":"@stdlib/utils/some-by-right","@stdlib/utils-async-some-by-right":"@stdlib/utils/async/some-by-right","@stdlib/utils-some-in-by":"@stdlib/utils/some-in-by","@stdlib/utils-some-own-by":"@stdlib/utils/some-own-by","@stdlib/datasets-sotu":"@stdlib/datasets/sotu","@stdlib/datasets-spache-revised":"@stdlib/datasets/spache-revised","@stdlib/datasets-spam-assassin":"@stdlib/datasets/spam-assassin","@stdlib/plot-sparklines-base-ctor":"@stdlib/plot/sparklines/base/ctor","@stdlib/array-to-sparse-iterator":"@stdlib/array/to-sparse-iterator","@stdlib/array-to-sparse-iterator-right":"@stdlib/array/to-sparse-iterator-right","@stdlib/streams-node-split":"@stdlib/streams/node/split","@stdlib/constants-float64-sqrt-eps":"@stdlib/constants/float64/sqrt-eps","@stdlib/constants-float64-sqrt-half":"@stdlib/constants/float64/sqrt-half","@stdlib/constants-float64-sqrt-half-pi":"@stdlib/constants/float64/sqrt-half-pi","@stdlib/constants-float64-sqrt-phi":"@stdlib/constants/float64/sqrt-phi","@stdlib/constants-float64-sqrt-pi":"@stdlib/constants/float64/sqrt-pi","@stdlib/constants-float64-sqrt-three":"@stdlib/constants/float64/sqrt-three","@stdlib/constants-float64-sqrt-two":"@stdlib/constants/float64/sqrt-two","@stdlib/constants-float64-sqrt-two-pi":"@stdlib/constants/float64/sqrt-two-pi","@stdlib/datasets-ssa-us-births-2000-2014":"@stdlib/datasets/ssa-us-births-2000-2014","@stdlib/blas-sswap":"@stdlib/blas/sswap","@stdlib/dstructs-stack":"@stdlib/dstructs/stack","@stdlib/namespace-standalone2pkg":"@stdlib/namespace/standalone2pkg","@stdlib/datasets-standard-card-deck":"@stdlib/datasets/standard-card-deck","@stdlib/string-startcase":"@stdlib/string/startcase","@stdlib/string-starts-with":"@stdlib/string/starts-with","@stdlib/datasets-stopwords-en":"@stdlib/datasets/stopwords-en","@stdlib/math-strided-special-abs":"@stdlib/math/strided/special/abs","@stdlib/math-strided-special-abs2":"@stdlib/math/strided/special/abs2","@stdlib/math-strided-special-abs2-by":"@stdlib/math/strided/special/abs2-by","@stdlib/math-strided-special-abs-by":"@stdlib/math/strided/special/abs-by","@stdlib/math-strided-special-acos-by":"@stdlib/math/strided/special/acos-by","@stdlib/math-strided-special-acosh-by":"@stdlib/math/strided/special/acosh-by","@stdlib/math-strided-special-acot-by":"@stdlib/math/strided/special/acot-by","@stdlib/math-strided-special-acoth-by":"@stdlib/math/strided/special/acoth-by","@stdlib/math-strided-special-acovercos-by":"@stdlib/math/strided/special/acovercos-by","@stdlib/math-strided-special-acoversin-by":"@stdlib/math/strided/special/acoversin-by","@stdlib/math-strided-ops-add":"@stdlib/math/strided/ops/add","@stdlib/math-strided-ops-add-by":"@stdlib/math/strided/ops/add-by","@stdlib/math-strided-special-ahavercos-by":"@stdlib/math/strided/special/ahavercos-by","@stdlib/math-strided-special-ahaversin-by":"@stdlib/math/strided/special/ahaversin-by","@stdlib/math-strided-special-asin-by":"@stdlib/math/strided/special/asin-by","@stdlib/math-strided-special-asinh-by":"@stdlib/math/strided/special/asinh-by","@stdlib/math-strided-special-atan-by":"@stdlib/math/strided/special/atan-by","@stdlib/math-strided-special-atanh-by":"@stdlib/math/strided/special/atanh-by","@stdlib/math-strided-special-avercos-by":"@stdlib/math/strided/special/avercos-by","@stdlib/math-strided-special-aversin-by":"@stdlib/math/strided/special/aversin-by","@stdlib/math-strided-special-besselj0-by":"@stdlib/math/strided/special/besselj0-by","@stdlib/math-strided-special-besselj1-by":"@stdlib/math/strided/special/besselj1-by","@stdlib/math-strided-special-bessely0-by":"@stdlib/math/strided/special/bessely0-by","@stdlib/math-strided-special-bessely1-by":"@stdlib/math/strided/special/bessely1-by","@stdlib/math-strided-special-binet-by":"@stdlib/math/strided/special/binet-by","@stdlib/math-strided-special-cbrt":"@stdlib/math/strided/special/cbrt","@stdlib/math-strided-special-cbrt-by":"@stdlib/math/strided/special/cbrt-by","@stdlib/math-strided-special-ceil":"@stdlib/math/strided/special/ceil","@stdlib/math-strided-special-cos-by":"@stdlib/math/strided/special/cos-by","@stdlib/math-strided-special-deg2rad":"@stdlib/math/strided/special/deg2rad","@stdlib/strided-dtypes":"@stdlib/strided/dtypes","@stdlib/math-strided-special-dcbrt-by":"@stdlib/math/strided/special/dcbrt-by","@stdlib/strided-dispatch":"@stdlib/strided/dispatch","@stdlib/strided-dispatch-by":"@stdlib/strided/dispatch-by","@stdlib/math-strided-special-floor":"@stdlib/math/strided/special/floor","@stdlib/math-strided-special-inv":"@stdlib/math/strided/special/inv","@stdlib/math-strided-ops-mul":"@stdlib/math/strided/ops/mul","@stdlib/math-strided-ops-mul-by":"@stdlib/math/strided/ops/mul-by","@stdlib/math-strided-special-ramp":"@stdlib/math/strided/special/ramp","@stdlib/math-strided-special-rsqrt":"@stdlib/math/strided/special/rsqrt","@stdlib/math-strided-special-sin-by":"@stdlib/math/strided/special/sin-by","@stdlib/math-strided-special-sqrt":"@stdlib/math/strided/special/sqrt","@stdlib/math-strided-special-sqrt-by":"@stdlib/math/strided/special/sqrt-by","@stdlib/math-strided-ops-sub":"@stdlib/math/strided/ops/sub","@stdlib/math-strided-ops-sub-by":"@stdlib/math/strided/ops/sub-by","@stdlib/math-strided-special-trunc":"@stdlib/math/strided/special/trunc","@stdlib/array-to-strided-iterator":"@stdlib/array/to-strided-iterator","@stdlib/streams-node-from-strided-array":"@stdlib/streams/node/from-strided-array","@stdlib/buffer-from-string":"@stdlib/buffer/from-string","@stdlib/ndarray-sub2ind":"@stdlib/ndarray/sub2ind","@stdlib/string-substring-after":"@stdlib/string/substring-after","@stdlib/string-substring-after-last":"@stdlib/string/substring-after-last","@stdlib/string-substring-before":"@stdlib/string/substring-before","@stdlib/string-substring-before-last":"@stdlib/string/substring-before-last","@stdlib/datasets-suthaharan-multi-hop-sensor-network":"@stdlib/datasets/suthaharan-multi-hop-sensor-network","@stdlib/datasets-suthaharan-single-hop-sensor-network":"@stdlib/datasets/suthaharan-single-hop-sensor-network","@stdlib/symbol-ctor":"@stdlib/symbol/ctor","@stdlib/utils-tabulate":"@stdlib/utils/tabulate","@stdlib/utils-tabulate-by":"@stdlib/utils/tabulate-by","@stdlib/utils-async-tabulate-by":"@stdlib/utils/async/tabulate-by","@stdlib/function-thunk":"@stdlib/function/thunk","@stdlib/time-tic":"@stdlib/time/tic","@stdlib/utils-timeit":"@stdlib/utils/timeit","@stdlib/os-tmpdir":"@stdlib/os/tmpdir","@stdlib/time-toc":"@stdlib/time/toc","@stdlib/nlp-tokenize":"@stdlib/nlp/tokenize","@stdlib/streams-node-transform":"@stdlib/streams/node/transform","@stdlib/string-trim":"@stdlib/string/trim","@stdlib/string-truncate":"@stdlib/string/truncate","@stdlib/string-truncate-middle":"@stdlib/string/truncate-middle","@stdlib/utils-try-catch":"@stdlib/utils/try-catch","@stdlib/utils-async-try-catch":"@stdlib/utils/async/try-catch","@stdlib/utils-try-function":"@stdlib/utils/try-function","@stdlib/utils-try-require":"@stdlib/utils/try-require","@stdlib/utils-try-then":"@stdlib/utils/try-then","@stdlib/utils-async-try-then":"@stdlib/utils/async/try-then","@stdlib/stats-ttest":"@stdlib/stats/ttest","@stdlib/stats-ttest2":"@stdlib/stats/ttest2","@stdlib/constants-float64-two-pi":"@stdlib/constants/float64/two-pi","@stdlib/array-typed":"@stdlib/array/typed","@stdlib/array-to-json":"@stdlib/array/to-json","@stdlib/array-typed-ctors":"@stdlib/array/typed-ctors","@stdlib/array-typed-dtypes":"@stdlib/array/typed-dtypes","@stdlib/array-pool":"@stdlib/array/pool","@stdlib/utils-type-max":"@stdlib/utils/type-max","@stdlib/utils-type-min":"@stdlib/utils/type-min","@stdlib/utils-type-of":"@stdlib/utils/type-of","@stdlib/constants-uint8-max":"@stdlib/constants/uint8/max","@stdlib/constants-uint8-num-bytes":"@stdlib/constants/uint8/num-bytes","@stdlib/array-uint8":"@stdlib/array/uint8","@stdlib/array-uint8c":"@stdlib/array/uint8c","@stdlib/constants-uint16-max":"@stdlib/constants/uint16/max","@stdlib/constants-uint16-num-bytes":"@stdlib/constants/uint16/num-bytes","@stdlib/array-uint16":"@stdlib/array/uint16","@stdlib/constants-uint32-max":"@stdlib/constants/uint32/max","@stdlib/constants-uint32-num-bytes":"@stdlib/constants/uint32/num-bytes","@stdlib/array-uint32":"@stdlib/array/uint32","@stdlib/process-umask":"@stdlib/process/umask","@stdlib/string-uncapitalize":"@stdlib/string/uncapitalize","@stdlib/utils-uncapitalize-keys":"@stdlib/utils/uncapitalize-keys","@stdlib/utils-uncurry":"@stdlib/utils/uncurry","@stdlib/utils-uncurry-right":"@stdlib/utils/uncurry-right","@stdlib/constants-unicode-max":"@stdlib/constants/unicode/max","@stdlib/constants-unicode-max-bmp":"@stdlib/constants/unicode/max-bmp","@stdlib/plot-sparklines-unicode-column":"@stdlib/plot/sparklines/unicode/column","@stdlib/plot-sparklines-unicode-line":"@stdlib/plot/sparklines/unicode/line","@stdlib/plot-sparklines-unicode":"@stdlib/plot/sparklines/unicode","@stdlib/plot-sparklines-unicode-tristate":"@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot-sparklines-unicode-up-down":"@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot-sparklines-unicode-win-loss":"@stdlib/plot/sparklines/unicode/win-loss","@stdlib/fs-unlink":"@stdlib/fs/unlink","@stdlib/utils-unshift":"@stdlib/utils/unshift","@stdlib/utils-until":"@stdlib/utils/until","@stdlib/utils-async-until":"@stdlib/utils/async/until","@stdlib/utils-until-each":"@stdlib/utils/until-each","@stdlib/utils-until-each-right":"@stdlib/utils/until-each-right","@stdlib/utils-unzip":"@stdlib/utils/unzip","@stdlib/string-uppercase":"@stdlib/string/uppercase","@stdlib/utils-uppercase-keys":"@stdlib/utils/uppercase-keys","@stdlib/datasets-us-states-abbr":"@stdlib/datasets/us-states-abbr","@stdlib/datasets-us-states-capitals":"@stdlib/datasets/us-states-capitals","@stdlib/datasets-us-states-capitals-names":"@stdlib/datasets/us-states-capitals-names","@stdlib/datasets-us-states-names":"@stdlib/datasets/us-states-names","@stdlib/datasets-us-states-names-capitals":"@stdlib/datasets/us-states-names-capitals","@stdlib/string-utf16-to-utf8-array":"@stdlib/string/utf16-to-utf8-array","@stdlib/stats-vartest":"@stdlib/stats/vartest","@stdlib/utils-async-series-waterfall":"@stdlib/utils/async/series-waterfall","@stdlib/wasm-memory":"@stdlib/wasm/memory","@stdlib/utils-async-while":"@stdlib/utils/async/while","@stdlib/utils-while-each":"@stdlib/utils/while-each","@stdlib/utils-while-each-right":"@stdlib/utils/while-each-right","@stdlib/utils-while":"@stdlib/utils/while","@stdlib/stats-wilcoxon":"@stdlib/stats/wilcoxon","@stdlib/utils-writable-properties":"@stdlib/utils/writable-properties","@stdlib/utils-writable-properties-in":"@stdlib/utils/writable-properties-in","@stdlib/utils-writable-property-names":"@stdlib/utils/writable-property-names","@stdlib/utils-writable-property-names-in":"@stdlib/utils/writable-property-names-in","@stdlib/utils-writable-property-symbols":"@stdlib/utils/writable-property-symbols","@stdlib/utils-writable-property-symbols-in":"@stdlib/utils/writable-property-symbols-in","@stdlib/fs-write-file":"@stdlib/fs/write-file","@stdlib/utils-zip":"@stdlib/utils/zip","@stdlib/stats-ztest":"@stdlib/stats/ztest","@stdlib/stats-ztest2":"@stdlib/stats/ztest2"} diff --git a/lib/node_modules/@stdlib/random/base/mt19937/lib/factory.js b/lib/node_modules/@stdlib/random/base/mt19937/lib/factory.js index cbe53cdc9bf8..1173c5d781f2 100644 --- a/lib/node_modules/@stdlib/random/base/mt19937/lib/factory.js +++ b/lib/node_modules/@stdlib/random/base/mt19937/lib/factory.js @@ -74,7 +74,7 @@ var FLOAT64_MAX_SAFE_INTEGER = require( '@stdlib/constants/float64/max-safe-inte var UINT32_MAX = require( '@stdlib/constants/uint32/max' ); var Uint32Array = require( '@stdlib/array/uint32' ); var max = require( '@stdlib/math/base/special/max' ); -var umul = require( '@stdlib/math/base/ops/umul' ); +var umul = require( '@stdlib/number/uint32/base/mul' ); var gcopy = require( '@stdlib/blas/base/gcopy' ); var typedarray2json = require( '@stdlib/array/to-json' ); var format = require( '@stdlib/string/format' ); From 4997905f59f45a7870286807212ffa406cc3c64a Mon Sep 17 00:00:00 2001 From: gururaj1512 Date: Thu, 27 Feb 2025 20:41:27 +0000 Subject: [PATCH 4/4] remove: remove `math/base/ops/umul` This commit removes `@stdlib/math/base/ops/umul` in favor of `@stdlib/number/uint32/base/mul`. BREAKING CHANGE: remove `math/base/ops/umul` To migrate, users should update their require/import paths to use `@stdlib/number/uint32/base/mul` which provides the same API and implementation. Ref: https://github.com/stdlib-js/stdlib/issues/2261 --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../@stdlib/math/base/ops/umul/README.md | 124 ------- .../math/base/ops/umul/benchmark/benchmark.js | 72 ---- .../@stdlib/math/base/ops/umul/docs/repl.txt | 25 -- .../math/base/ops/umul/docs/types/index.d.ts | 37 -- .../math/base/ops/umul/docs/types/test.ts | 56 --- .../math/base/ops/umul/examples/index.js | 38 -- .../@stdlib/math/base/ops/umul/lib/index.js | 40 --- .../@stdlib/math/base/ops/umul/lib/main.js | 132 ------- .../@stdlib/math/base/ops/umul/package.json | 73 ---- .../base/ops/umul/test/fixtures/c/Makefile | 131 ------- .../base/ops/umul/test/fixtures/c/data.json | 1 - .../base/ops/umul/test/fixtures/c/runner.c | 327 ------------------ .../@stdlib/math/base/ops/umul/test/test.js | 55 --- 13 files changed, 1111 deletions(-) delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/README.md delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/benchmark/benchmark.js delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/docs/repl.txt delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/docs/types/index.d.ts delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/docs/types/test.ts delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/examples/index.js delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/lib/index.js delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/lib/main.js delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/package.json delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/Makefile delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/data.json delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/runner.c delete mode 100644 lib/node_modules/@stdlib/math/base/ops/umul/test/test.js diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/README.md b/lib/node_modules/@stdlib/math/base/ops/umul/README.md deleted file mode 100644 index c4abbba4f5fd..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/README.md +++ /dev/null @@ -1,124 +0,0 @@ - - -# umul - -> Perform C-like multiplication of two unsigned 32-bit integers. - -
- -
- - - -
- -## Usage - -```javascript -var umul = require( '@stdlib/math/base/ops/umul' ); -``` - -#### umul( a, b ) - -Performs C-like multiplication of two unsigned 32-bit integers. - -```javascript -var v = umul( 10>>>0, 4>>>0 ); -// returns 40 - -v = umul( 2147483648>>>0, 5>>>0 ); // 2^31 * 5 = 10737418240 => 32-bit integer overflow -// returns 2147483648 -``` - -
- - - - - -
- -## Notes - -- The function emulates C-like multiplication of two unsigned 32-bit integers. - -
- - - -
- -## Examples - - - -```javascript -var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory; -var UINT32_MAX = require( '@stdlib/constants/uint32/max' ); -var umul = require( '@stdlib/math/base/ops/umul' ); - -var randi; -var a; -var b; -var y; -var i; - -randi = discreteUniform( 0, UINT32_MAX ); - -for ( i = 0; i < 100; i++ ) { - a = randi()>>>0; - b = randi()>>>0; - y = umul( a, b ); - console.log( '%d x %d = %d', a, b, y ); -} -``` - -
- - - - - -
- -* * * - -## See Also - -- [`@stdlib/math/base/ops/imul`][@stdlib/math/base/ops/imul]: perform C-like multiplication of two signed 32-bit integers. - -
- - - - - -
- - - -[@stdlib/math/base/ops/imul]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/ops/imul - - - -
- - diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/ops/umul/benchmark/benchmark.js deleted file mode 100644 index ad8c3194065e..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/benchmark/benchmark.js +++ /dev/null @@ -1,72 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2018 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var bench = require( '@stdlib/bench' ); -var minstd = require( '@stdlib/random/base/minstd' ); -var isnan = require( '@stdlib/math/base/assert/is-nan' ); -var pkg = require( './../package.json' ).name; -var umul = require( './../lib' ); - - -// MAIN // - -bench( pkg, function benchmark( b ) { - var x; - var y; - var i; - - b.tic(); - for ( i = 0; i < b.iterations; i++ ) { - x = minstd(); - y = umul( x>>>0, x>>>0 ); - if ( isnan( y ) ) { - b.fail( 'should not return NaN' ); - } - } - b.toc(); - if ( isnan( y ) ) { - b.fail( 'should not return NaN' ); - } - b.pass( 'benchmark finished' ); - b.end(); -}); - -bench( pkg+'::naive_multiplication', function benchmark( b ) { - var x; - var y; - var i; - - b.tic(); - for ( i = 0; i < b.iterations; i++ ) { - x = minstd(); - y = ( x>>>0 ) * ( x>>>0 ); - if ( isnan( y ) ) { - b.fail( 'should not return NaN' ); - } - } - b.toc(); - if ( isnan( y ) ) { - b.fail( 'should not return NaN' ); - } - b.pass( 'benchmark finished' ); - b.end(); -}); diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/docs/repl.txt b/lib/node_modules/@stdlib/math/base/ops/umul/docs/repl.txt deleted file mode 100644 index f83d70e84b8f..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/docs/repl.txt +++ /dev/null @@ -1,25 +0,0 @@ - -{{alias}}( a, b ) - Performs C-like multiplication of two unsigned 32-bit integers. - - Parameters - ---------- - a: integer - Unsigned 32-bit integer. - - b: integer - Unsigned 32-bit integer. - - Returns - ------- - out: integer - Product. - - Examples - -------- - > var v = {{alias}}( 10>>>0, 4>>>0 ) - 40 - - See Also - -------- - diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/ops/umul/docs/types/index.d.ts deleted file mode 100644 index 141bd9ede6d9..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/docs/types/index.d.ts +++ /dev/null @@ -1,37 +0,0 @@ -/* -* @license Apache-2.0 -* -* Copyright (c) 2019 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -// TypeScript Version: 4.1 - -/** -* Performs C-like multiplication of two unsigned 32-bit integers. -* -* @param a - unsigned 32-bit integer -* @param b - Unsigned 32-bit integer -* @returns product -* -* @example -* var v = umul( 10>>>0, 4>>>0 ); -* // returns 40 -*/ -declare function umul( a: number, b: number ): number; - - -// EXPORTS // - -export = umul; diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/docs/types/test.ts b/lib/node_modules/@stdlib/math/base/ops/umul/docs/types/test.ts deleted file mode 100644 index 08a0d81fbdf9..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/docs/types/test.ts +++ /dev/null @@ -1,56 +0,0 @@ -/* -* @license Apache-2.0 -* -* Copyright (c) 2019 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -import umul = require( './index' ); - - -// TESTS // - -// The function returns a number... -{ - umul( 10, 4 ); // $ExpectType number -} - -// The compiler throws an error if the function is provided values other than two numbers... -{ - umul( true, 4 ); // $ExpectError - umul( false, 4 ); // $ExpectError - umul( '5', 4 ); // $ExpectError - umul( [], 4 ); // $ExpectError - umul( {}, 4 ); // $ExpectError - umul( ( x: number ): number => x, 4 ); // $ExpectError - - umul( 10, true ); // $ExpectError - umul( 10, false ); // $ExpectError - umul( 10, '5' ); // $ExpectError - umul( 10, [] ); // $ExpectError - umul( 10, {} ); // $ExpectError - umul( 10, ( x: number ): number => x ); // $ExpectError - - umul( [], true ); // $ExpectError - umul( {}, false ); // $ExpectError - umul( false, '5' ); // $ExpectError - umul( {}, [] ); // $ExpectError - umul( '5', ( x: number ): number => x ); // $ExpectError -} - -// The compiler throws an error if the function is provided insufficient arguments... -{ - umul(); // $ExpectError - umul( 10 ); // $ExpectError -} diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/examples/index.js b/lib/node_modules/@stdlib/math/base/ops/umul/examples/index.js deleted file mode 100644 index 9e2730b93b31..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/examples/index.js +++ /dev/null @@ -1,38 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2018 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory; -var UINT32_MAX = require( '@stdlib/constants/uint32/max' ); -var umul = require( './../lib' ); - -var randi; -var a; -var b; -var y; -var i; - -randi = discreteUniform( 0, UINT32_MAX ); - -for ( i = 0; i < 100; i++ ) { - a = randi()>>>0; - b = randi()>>>0; - y = umul( a, b ); - console.log( '%d x %d = %d', a, b, y ); -} diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/lib/index.js b/lib/node_modules/@stdlib/math/base/ops/umul/lib/index.js deleted file mode 100644 index 379123c7d571..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/lib/index.js +++ /dev/null @@ -1,40 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2018 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -/** -* Perform C-like multiplication of two unsigned 32-bit integers. -* -* @module @stdlib/math/base/ops/umul -* -* @example -* var umul = require( '@stdlib/math/base/ops/umul' ); -* -* var v = umul( 10>>>0, 4>>>0 ); -* // returns 40 -*/ - -// MODULES // - -var main = require( './main.js' ); - - -// EXPORTS // - -module.exports = main; diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/lib/main.js b/lib/node_modules/@stdlib/math/base/ops/umul/lib/main.js deleted file mode 100644 index ec2bb94aa1bf..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/lib/main.js +++ /dev/null @@ -1,132 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2018 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// VARIABLES // - -// Define a mask for the least significant 16 bits (low word): 65535 => 0x0000ffff => 00000000000000001111111111111111 -var LOW_WORD_MASK = 0x0000ffff>>>0; // asm type annotation - - -// MAIN // - -/** -* Performs C-like multiplication of two unsigned 32-bit integers. -* -* ## Method -* -* - To emulate C-like multiplication without the aid of 64-bit integers, we recognize that a 32-bit integer can be split into two 16-bit words -* -* ```tex -* a = w_h*2^{16} + w_l -* ``` -* -* where \\( w_h \\) is the most significant 16 bits and \\( w_l \\) is the least significant 16 bits. For example, consider the maximum unsigned 32-bit integer \\( 2^{32}-1 \\) -* -* ```binarystring -* 11111111111111111111111111111111 -* ``` -* -* The 16-bit high word is then -* -* ```binarystring -* 1111111111111111 -* ``` -* -* and the 16-bit low word -* -* ```binarystring -* 1111111111111111 -* ``` -* -* If we cast the high word to 32-bit precision and multiply by \\( 2^{16} \\) (equivalent to a 16-bit left shift), then the bit sequence is -* -* ```binarystring -* 11111111111111110000000000000000 -* ``` -* -* Similarly, upon casting the low word to 32-bit precision, the bit sequence is -* -* ```binarystring -* 00000000000000001111111111111111 -* ``` -* -* From the rules of binary addition, we recognize that adding the two 32-bit values for the high and low words will return our original value \\( 2^{32}-1 \\). -* -* - Accordingly, the multiplication of two 32-bit integers can be expressed -* -* ```tex -* \begin{align*} -* a \cdot b &= ( a_h \cdot 2^{16} + a_l) \cdot ( b_h \cdot 2^{16} + b_l) \\ -* &= a_l \cdot b_l + a_h \cdot b_l \cdot 2^{16} + a_l \cdot b_h \cdot 2^{16} + (a_h \cdot b_h) \cdot 2^{32} \\ -* &= a_l \cdot b_l + (a_h \cdot b_l + a_l \cdot b_h) \cdot 2^{16} + (a_h \cdot b_h) \cdot 2^{32} -* \end{align*} -* ``` -* -* - We note that multiplying (dividing) an integer by \\( 2^n \\) is equivalent to performing a left (right) shift of \\( n \\) bits. -* -* - Further, as we want to return an integer of the same precision, for a 32-bit integer, the return value will be modulo \\( 2^{32} \\). Stated another way, we only care about the low word of a 64-bit result. -* -* - Accordingly, the last term, being evenly divisible by \\( 2^{32} \\), drops from the equation leaving the remaining two terms as the remainder. -* -* ```tex -* a \cdot b = a_l \cdot b_l + (a_h \cdot b_l + a_l \cdot b_h) << 16 -* ``` -* -* - Lastly, the second term in the above equation contributes to the middle bits and may cause the product to "overflow". However, we can disregard (`>>>0`) overflow bits due to modulo arithmetic, as discussed earlier with regard to the term involving the partial product of high words. -* -* @param {uinteger32} a - integer -* @param {uinteger32} b - integer -* @returns {uinteger32} product -* -* @example -* var v = umul( 10>>>0, 4>>>0 ); -* // returns 40 -*/ -function umul( a, b ) { - var lbits; - var mbits; - var ha; - var hb; - var la; - var lb; - - a >>>= 0; // asm type annotation - b >>>= 0; // asm type annotation - - // Isolate the most significant 16-bits: - ha = ( a>>>16 )>>>0; // asm type annotation - hb = ( b>>>16 )>>>0; // asm type annotation - - // Isolate the least significant 16-bits: - la = ( a&LOW_WORD_MASK )>>>0; // asm type annotation - lb = ( b&LOW_WORD_MASK )>>>0; // asm type annotation - - // Compute partial sums: - lbits = ( la*lb )>>>0; // asm type annotation; no integer overflow possible - mbits = ( ((ha*lb) + (la*hb))<<16 )>>>0; // asm type annotation; possible integer overflow - - // The final `>>>0` converts the intermediate sum to an unsigned integer (possible integer overflow during sum): - return ( lbits + mbits )>>>0; // asm type annotation -} - - -// EXPORTS // - -module.exports = umul; diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/package.json b/lib/node_modules/@stdlib/math/base/ops/umul/package.json deleted file mode 100644 index f30b4640eb0c..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/package.json +++ /dev/null @@ -1,73 +0,0 @@ -{ - "name": "@stdlib/math/base/ops/umul", - "version": "0.0.0", - "description": "Perform C-like multiplication of two unsigned 32-bit integers.", - "license": "Apache-2.0", - "author": { - "name": "The Stdlib Authors", - "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" - }, - "contributors": [ - { - "name": "The Stdlib Authors", - "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" - } - ], - "main": "./lib", - "directories": { - "benchmark": "./benchmark", - "doc": "./docs", - "example": "./examples", - "lib": "./lib", - "test": "./test" - }, - "types": "./docs/types", - "scripts": {}, - "homepage": "https://github.com/stdlib-js/stdlib", - "repository": { - "type": "git", - "url": "git://github.com/stdlib-js/stdlib.git" - }, - "bugs": { - "url": "https://github.com/stdlib-js/stdlib/issues" - }, - "dependencies": {}, - "devDependencies": {}, - "engines": { - "node": ">=0.10.0", - "npm": ">2.7.0" - }, - "os": [ - "aix", - "darwin", - "freebsd", - "linux", - "macos", - "openbsd", - "sunos", - "win32", - "windows" - ], - "keywords": [ - "stdlib", - "stdmath", - "mathematics", - "math", - "math.imul", - "imul", - "umul", - "multiplication", - "multiply", - "mult", - "integer", - "unsigned", - "uint", - "uint32", - "32-bit", - "32bit", - "long", - "c", - "emulate", - "emulation" - ] -} diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/Makefile b/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/Makefile deleted file mode 100644 index 5c9bf0c69840..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/Makefile +++ /dev/null @@ -1,131 +0,0 @@ -#/ -# @license Apache-2.0 -# -# Copyright (c) 2018 The Stdlib Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -#/ - -# VARIABLES # - -ifndef VERBOSE - QUIET := @ -endif - -# Determine the OS: -# -# [1]: https://en.wikipedia.org/wiki/Uname#Examples -# [2]: http://stackoverflow.com/a/27776822/2225624 -OS ?= $(shell uname) -ifneq (, $(findstring MINGW,$(OS))) - OS := WINNT -else -ifneq (, $(findstring MSYS,$(OS))) - OS := WINNT -else -ifneq (, $(findstring CYGWIN,$(OS))) - OS := WINNT -endif -endif -endif - -# Define the program used for compiling C source files: -ifdef C_COMPILER - CC := $(C_COMPILER) -else - CC := gcc -endif - -# Define the command-line options when compiling C files: -CFLAGS ?= \ - -std=c99 \ - -O3 \ - -Wall \ - -pedantic - -# Determine whether to generate [position independent code][1]: -# -# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options -# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option -ifeq ($(OS), WINNT) - fPIC ?= -else - fPIC ?= -fPIC -endif - -# List of C targets: -c_targets := runner.out - - -# RULES # - -#/ -# Compiles C source files. -# -# @param {string} [C_COMPILER] - C compiler -# @param {string} [CFLAGS] - C compiler flags -# @param {(string|void)} [fPIC] - flag indicating whether to generate position independent code -# -# @example -# make -# -# @example -# make all -#/ -all: $(c_targets) - -.PHONY: all - -#/ -# Compiles C source files. -# -# @private -# @param {string} CC - C compiler -# @param {string} CFLAGS - C compiler flags -# @param {(string|void)} fPIC - flag indicating whether to generate position independent code -#/ -$(c_targets): %.out: %.c - $(QUIET) $(CC) $(CFLAGS) $(fPIC) -o $@ $< -lm - -#/ -# Generates test fixtures. -# -# @example -# make run -#/ -run: $(c_targets) - $(QUIET) ./$< - -.PHONY: run - -#/ -# Removes generated files. -# -# @example -# make clean -#/ -clean: - $(QUIET) -rm -f *.o *.out - -.PHONY: clean - -#/ -# Removes generated test fixtures. -# -# @example -# make clean-fixtures -#/ -clean-fixtures: - $(QUIET) -rm -f *.json - -.PHONY: clean-fixtures diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/data.json b/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/data.json deleted file mode 100644 index 5124ce359874..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/data.json +++ /dev/null @@ -1 +0,0 @@ -{"a":[33613,564950497,3245300145,1969887315,2288217859,940422543,202055087,2915701755,2917555845,4014475417,1647128879,2230876329,3568968983,148486083,229615973,2275045005,2882564653,33063457,1646757679,287085223,1793088605,2949666337,2529635417,3996194313,3634259119,2263141865,394986197,2808560555,1786703631,3011590669,3909798193,3273615651,1127227023,203858533,3161447619,1409755265,2717161957,3248758297,4256473157,1569117641,1061023933,4220021343,3103802785,3235638671,2798250969,312183489,2712850455,3799788181,1171280387,1874372713,3292070001,2051842305,1021233415,1180715887,1543031335,715142979,2089576247,3855404391,3905019059,260121805,3885455443,2166909331,2217457097,1370236047,4237595601,2121613705,1143081953,389694815,4070616455,316749865,2150520595,1649877961,1190057269,3924816025,2275247729,1994779627,4041478125,215109071,3270678849,3308003337,3555448229,538440187,68151257,2956893001,3729093033,2703868389,3162060209,3115620807,4292638901,3816388595,1001564375,1315642245,1507599009,2204493763,2538813503,3633463131,1769873431,3614260673,1156708875,1784106287,2307703001,2009689793,1233567741,765911655,660222273,2455238715,3446306353,141964793,2295444587,2140955807,4103243217,3213892461,2381919489,3825688349,2683707269,3616532595,686196283,913760797,3069655935,560180823,390800519,1179347113,12883187,1779376015,115432789,3048651935,4028238225,1030409059,776942011,1363821923,3809595883,2800570729,645684163,2926359703,1657061533,1665267641,2146371389,633649423,2521947341,3631719801,2534497179,4103449661,2388629475,636306113,4223263231,1755639579,609111279,2426221357,1082874669,2098154011,1992995943,4127872195,541298189,857950637,1371166907,2702690445,544224577,2797113519,2669897809,3449172251,1064472245,2046259011,1672091625,872953539,121870475,3872658187,1831792439,609975687,4069424731,1762281067,563450451,3803830787,395882725,696637475,305215687,1569119179,1086873099,580290317,3363617245,1955529893,1501194769,1942614433,3474390543,4001511077,2798798493,924484769,2918826991,3903789769,1074281245,3697364839,2024056287,2173063935,2578671469,3511399829,3246323249,1985327067,4086092083,2717592021,1886909357,3542048303,2959150487,3015954589,4239757635,4099180791,3656175383,1242603629,2308225981,2209480065,444245337,1778238793,2476979105,3764821093,1889951649,3134242419,3733459323,3073660421,3439067615,3034546753,3185645521,82001249,3805474669,2254803735,1989955989,280005551,3064125533,2099994877,2867659747,2929378661,857081111,3936912601,3718937743,3822601119,2336240187,597837967,1934227509,4249279577,925702813,1915656029,1356060385,2210445537,3786031359,1888606909,2008033709,3464535011,1568341925,908467003,4291173351,659726215,2707926497,2647204661,2555687,3775275,3321521615,3123879993,1370857301,1794109697,2931290405,2922991461,881593061,3592396027,3044790837,3559273549,406084017,351060359,3281375857,2703990445,918488107,917176519,348153473,1669983089,4089494633,4069675049,1674408399,1156268511,2972843127,1219921193,3336613295,3366675407,1814451099,1211850299,833083951,48602823,823877107,4222965593,1048205007,3520696761,586069495,1710014129,2581318755,759695397,3557756417,677450257,4243157105,1104530965,1003300893,436529213,942361545,2726090643,2989328609,3413510351,2990340105,3233854447,2875569259,2720560731,242410799,2569320887,974990739,1369140569,3005766031,504387795,3275216309,2259682265,2379031113,2525393151,1415906355,3019316531,614374713,694443421,2084455755,3694641227,3492949637,2391591473,3173966265,1357241181,581247439,2270097523,1334613265,2525952393,2225152061,1850477175,1111721177,1590109745,1687997753,1919274607,2043958715,1665722399,1199554507,336137919,1588029829,1090587893,2885290959,2904415459,2207339909,3129349091,3095674213,4057682475,1978679999,4037969851,1381090069,1977549713,2221122225,2840500227,1725859185,2601202719,4236996707,645936835,2878050713,1476685169,2326627457,2245442029,3561553125,64212203,1177721833,2761573285,2345638837,3942125933,1145095493,4166490537,1059710789,3624846605,2980808945,1957438205,3509423495,94848769,690411315,3036326917,3040090811,1875347859,2501479647,3228570263,4258601945,2987919205,1200493793,3237815839,735207899,18270461,2128976959,343240405,700427799,3879649039,3362925065,3206962515,1874434005,27237351,2511641899,2226847867,287117559,2336559757,1673883663,926965147,1656867097,2692349083,2830612497,3046505541,2313532619,1203831757,3504401965,1597339939,2946784079,1332165445,40147299,445805941,2237506457,3332380635,947835491,237420597,303374459,688371241,3108541551,1275700247,217336487,2052153915,1963495391,2233333541,1917658127,645583119,1228113195,3580637501,2987739879,2481529005,2925579101,1422385601,246854409,4238630159,2329560835,7118547,3677319297,126080825,1621566639,2103038049,2474644023,3173803565,2917709575,2303248233,152848015,526163099,4180530647,808638389,1508902513,2637649021,2609671379,540877331,2374524819,4097521185,1532981105,3599619129,4184381919,1112457483,1080302805,1822508703,3492014613,3856512281,1050489819,3266826399,2984385597,1940686253,1132240341,2858315573,500668827,900063249,488233281,2349239033,26110695,755803683,2574228629,1855031947,354362889,2952422745,1611944439,3591479821,531018477,4180490107,127282609,345113857,2122764505,3304708377,4011630331,1074408711,1544718607,3303319719,2147291795,3218011183,2885803439,2927732231,3250303159,156197733,990298703,952053877,2416357395,2802989801,2648321621,1595433231,965513781,1003697341,2804663455,712653341,3195903321,686154089,204606239,2843240479,536634315,4076598905,2079539253,2667370699,3925707421,77071125,2549259187,3100415065,2132803453,230615653,1896797589,2229839061,3315474883,280703031,1901770011,4196957029,2008933847,1413285201,1915254193,3192337321,881934205,736068647,1599960215,4036089871,4144004561,1095034029,302087419,531926431,2260603809,687551945,2223535561,451765439,3614541581,1582962337,1820595729,1405431653,3064659071,2477233455,3744714249,3256640767,3593160333,3005579897,1671000951,4016832091,2601043151,1555137331,2317154933,1954521039,1725254767,1032683981,356850419,1810666515,2028856421,1244537487,450839035,929371435,3444643867,2265333649,2872561533,3709317377,1046899635,3056146027,1132423649,1644205835,347916055,1974666057,1000156067,3416013453,2110302479,13867507,1142973079,2854816791,1826181869,802406165,4138096095,575693729,3418174021,4063230503,735106127,2602755751,274034473,1492465349,1256140489,2188965419,3546940829,3583456383,3120049419,1414909493,3444926073,2713402597,194736893,177899429,658483385,3294519157,265134257,2230390327,3990667957,947107001,878591049,382220577,3005149915,3034228065,2124423599,1124330177,3056175339,1625070433,861761691,999042075,1873019085,2016480675,3698771871,4197206641,1909195437,147072991,2249582493,135887575,3234856717,2540851973,3534290069,1415530469,996767823,2304371367,1849491977,1733367567,4240527467,4152845333,3653001037,3725945229,1338334089,637331951,4284653321,2746731649,2010365637,4002543261,2966845805,3502145395,2325873595,2460185277,683828007,4059819005,3527601357,667497529,176414781,1475808213,472529847,414628729,2228114241,96228907,2411554211,3680254899,2220103405,2897061663,3166142063,2999864281,97923307,824563953,2881884433,1485507799,284714577,604346929,3956169493,952007243,1632579757,2516918633,718603031,113128095,2968365523,3274242057,3065298077,332105415,2533211805,3975005313,3993021521,1848751503,2173122931,3570217241,3948089113,2584013991,3108853909,2230533859,2108042987,693291109,4192384441,2466858623,1173604585,2282462853,3000284463,2864954887,418469581,2356804395,2623098303,2868889711,2126547139,2454928605,2529254877,1895425827,649471597,2157253531,3141183669,135963841,221692085,2242245503,1377148171,150579437,1052878299,460336819,1644837245,2370089337,2564819209,2624699885,4016874621,3315844861,2203955983,2090279631,2792277397,2993573941,1750361277,2091002739,2060651671,3051359781,2294365713,1188189665,2600766655,1203036353,3020948819,2278435365,4029770351,1011046977,1775944181,2566140867,3362969421,3952453807,2926982051,3526929781,2265221579,989001043,617118727,3863413779,1079849767,2798233625,20682881,4019814253,1182632357,3688371567,1197989073,4090659739,2176775121,528065161,1788748329,3017091603,1874715463,462734663,3290695707,428919517,1895219693,1479944753,1275880923,3253958019,1453887637,1420596299,238826753,2461801881,2084287671,869653439,491664597,4184792223,3713469517,2112439911,1577948779,3457072303,696660095,685390027,247918087,641029835,2010480299,1634700201,3795482589,1821639641,1770591461,2797289001,1324256489,258309921,3497892113,3855407019,3949187855,3870701609,3307324345,733564273,2458619337,134878191,3450009005,2242894841,3700637349,1190557035,3734448599,2520552977,1671480523,3487064107,2257736525,4036717285,1804049777,2490490499,3217553469,3782938829,1452062727,814104987,3191701925,3087735515,3775971303,312970183,3049914631,3775533427,1543522839,385916119,691614899,1790126735,414157481,2897783693,2416398391,3492009573,3771805001,3304376467,2728186255,3850541141,3772754895,2089375749,485634505,1621283741,1643338657,2953124585,522867437,329946941,615477639,2051451527,3043362157,1022285259,1679188819,4191376159,2700532225,2925726683,3902796275,1556496763,3690292087,3411397655,1841996785,315727149,2141601959,2078217999,1935891191,2146011893,3181534739,4006532173,1289013085,627905465,472525703,344980521,4176753647,1753108799,1023964759,4136741555,3579743713,850746845,556118995,843134027,1456505689,2472523323,1890937017,2515453219,1859193697,1581418435,1642038579,2577550109,1844571485,639037109,2878472769,4275213067,2998172549,1729754641,3647622301,3519842451,3407550501,1607388917,41265565,2060633427,2744732873,2776675757,2769815395,3431828199,1620766273,1536188569,1672891755,1435836567,2978940683,622329829,1252091919,2864126133,3669470279,1351621413,619087131,2586641455,24001123,3954932725,1640483937,2218485779,1479425245,1134444555,1249834625,3580491521,534254019,2725669679,209153955,1967291999,1618414787,669469013,3246375311,2860333101,49523571,3413986861,2409109087,1239761477,1784817551,1377015167,2210148503,3088748215,3616551027,995982907,1997190037,1603566055,214933341,317184739,869513325,2431735893,3571368047,1814849085,3605833707,1258612015,778229961,1535561103,4011972575,2531536325,1585016717,1988822037,2696510757,4056390711,1742838921,216816973,1910616705,2559487797,3213971575,3711588487,562739759,449164931,2857476565,3579330547,2496600471,2828637817,4217797133,81243667,3957695877,836139367,4156339301,2246579097,1197418531,3091494933,2536000219,3595239177,3584972653,2834195545,3137251161,2761778589,1501215871,2297275747,2852490869,1389116461,3733133943,1899966055,3942639595,1188278139,4087749173,503532593,1786738177,3592205291,4134058179,1429916221,2259933223,2301914925,3513744223,3993847561,2847103901,1044658459,4043406641,2562906425,541310255,1060743899,3808457199,842577917,699899507,3590579983,2587310387,2676806659,3602097263,2884707117,1681717553,3742135557,2866237263,496526543,172765,2903678161,2700474305,1952265243,2466797041,138595911,1509219635,3672551181,1592733799,2840800391,2475748239,257525407,3197467197,1200414257,1901054287,757718349,394281739,3853636831,4262409197,2551894159,141749235,2967528575,2092558903,2445296255,3847105599,1866175323,2957489679,872558297,2068972769,1170133165,4067849029,1049261317,4094229755,2048491917,545837121,4129336763,3681456095,933768107,30098879,3360702761,216437539,4123404055,2754680501,2462735087,588811737,554235189,3541744937,2155445419,2817016343,2169211845,2261104249,508512437,3878597699,2872922861,1192222485,1660895691,1681451737,3569533339,1043682787,530189219,3128052783,2783462127,864219047,3645118721,96879037,453387239,807363123,1550343321,3348607449,3088958867,2862011897,2495244179,1508274643,674972519,1254520185,726319855,960770243,2883432761,1738452731,3807532935,2488342045,1468225443,1877933277,3004927033,3583217585,3401538727,3646718355,1212123911,1136713541,729976681,2291502709,314321671,4289536977,3221959455,524934239,706949803,1825820623,3320879231,917266693,1863707891,142065701,3991405343,455451621,1143693045,2070383471,3404965209,1106059213,918761265,1213175731,1634783105,893882823,3987995849,3281628079,2648118305,2473268513,1530443465,3899176589,849976277,490084501,3397922515,2998585387,78388319,3212502275,491899857,3843839749,2811609195,1485588583,1642451265,923629123,1422886551,76386471,3927181291,3373567745,1689858927,3135254967,3571484383,3770108237,556667683,1474998655,4046157717,1555600523,1512088289,346411431,2456254253,3334584343,3625817495,2118687999,3510348739,2760522795,1869922583,1513179089,1499617855,1209224599,3947584285,2689304383,3197947125,676629565,3334688543,1082139601,2628768017,3670492441,1351228971,2613249025,540831537,1604865061,572490713,1124691637,541298971,871093711,3223479631,304728507,1971019507,4137099627,1007925229,848333073,2937525931,349294593,3668917753,655251519,516154823,3475160381,4055276461,195508347,258824925,3563629753,606360647,3440989567,977055665,1714613499,2573519053,2814089997,230754857,4236399217,3488824287,1776310727,136744901,464065623,4185303957,3724248267,2882264813,3583587165,1023135199,3079228517,2532776619,955801505,978231781,6758641,1923346449,1759930505,4007227857,96472191,2205461105,1617061321,3691569715,3409654981,2617645925,1425085839,2680081535,2808363373,2767633051,1112910943,111670437,4239311281,892276407,2758765901,2406576183,1618916889,518362739,1928898947,591483923,2515992351,2330450633,2077051651,3807916825,350446687,1557325141,432971957,1285102069,3614936257,3921314575,3555919695,4167401955,3493011233,3426835445,3606895675,1927239015,2757777857,2980389851,3503659935,2010943611,831650397,1724664509,3997119657,2006646551,1625406975,2223055791,978205637,3862323727,4234182273,588384831,1969160635,2959808981,1198361365,1757836795,3177982239,134239495,1305379921,827411301,3492622035,1180551953,3082759891,1755037321,3371862955,3102224455,2478450125,2718450469,3429943011,1182615,2696357935,1487911357,2026608237,2114014645,2274699353,1368158783,3684757905,592713955,1714303705,1661778589,3635416541,241096949,1962280407,3287933923,1256256063,4131417637,4294967061,4291068069,3185218935,1502304935,3421305219,854700467,2580134539,2331413555,1081012529,865938089,2472286557,2206578149,3211350653,2611425373,4250450725,3429318073,2382751531,629949067,459606165,2249637349,1057852367,2455119109,1436088311,2915034797,297927327,3627704185,3763515771,1426241265,624489847,3195776093,2842800387,1729942659,2512673533,2385651329,2122213819,2639263363,3972113609,2636792627,1101159303,170352481,2665947169,1475275181,103795611,736129519,2623035919,1820401823,2441420805,3136926859,1606202169,1570428399,1616097169,371968933,2504460967,1796007975,475910399,1396991371,2942760199,2422290989,3744656397,2284322203,4185608855,258734365,2041587833,473014271,4261375603,2360148977,3000913155,546479449,2040041577,254893443,1911721189,3942681209,1887684637,3687277381,4282841441,2359235547,533797027,3634939723,817151411,2853342565,2818669251,4179832837,1965447601,684388659,597795287,1216904749,4178846515,2568202923,3660206261,270093471,3975521439,4077616615,2004322047,1212173893,1976761015,1850376821,3720038793,853111999,1652556627,3260723791,3497067997,2889391289,3099185065,2935029923,1348561077,723627507,2955117641,3955388571,711953071,16400019,757229323,765156345,850628985,2870213269,2896749975,2222569141,1389013675,2005609641,1377929781,402196825,3738501119,1911779913,634688183,2800517485,4045779549,3789665535,2838660825,875800829,731633271,69039781,710446693,468508737,1551309663,2410048267,4139657855,1054390285,102481757,129021811,3806078107,3806851613,3922265073,2351070405,741208841,2091854893,3497902067,4022703897,2504238831,2357535517,2026163875,3235557099,1427270365,740704371,2203162191,1633919369,3556941047,4153395843,20520725,1294458361,1952346023,3824466501,3622944403,1075270989,3152123071,3605866907,1816604415,3042893959,1743216061,2260441659,2257264189,393133427,1733826223,3359224271,1137259873,1322244017,794431369,3249685837,2665768761,2771739219,1405799815,662423217,791798877,1955065733,2289992237,697622531,3976149997,1756889039,133949029,718485153,2426919843,4232394283,602407959,1432671761,1327653769,1521820059,699512649,1383624871,1630293987,2754687889,2586905203,161846465,1439256959,335926911,2336585667,2109353033,1236397761,1085417561,1886866915,2828725609,1398349983,7148319,4177697301,433232401,1367417083,4103907887,1500099269,710415109,4232643743,500114885,179894643,4127274025,3372756881,946569561,435771557,1093339035,1879094319,1043723457,1213729909,2358918163,3789458727,3657806063,2879638625,2394918389,3254868655,3874045007,3665239709,3262875421,1004807761,4287623219,1122199807,1610785101,1286355231,3201993521,4259897727,3291290809,1840864243,2755930225,1992009885,440097271,781170235,3708105987,2161904375,3998507485,3857035277,1250549003,2702140685,4189310139,2336672437,3567696423,235406633,814419863,4188855563,3286548193,3736095717,138894145,2226671179,1612489637,4164688019,829561821,981706029,2563869955,3850457083,2359992089,364096539,3337121123,3311806015,3042547965,223062197,3794881417,307676425,4272037099,1159285901,2146509329,2952007003,3214503233,4057229905,2962270597,3916035831,735415167,3501823737,1214734883,2069647005,3912083029,3020148657,1715014513,723426763,3876180527,902218703,2355210307,1601065051,1130232053,3464757509,1012898517,2830005903,1441414771,2242534843,1945118257,2606487571,2865191097,93483757,3518458395,1620557779,2326997205,4164829371,3205264885,3407137653,3258587169,1946600395,1746977173,1048941633,3016268061,918346951,2839734921,1748263125,1187100427,1473812765,1294773663,2956659443,4098651021,3342265581,3875365741,93012283,4184329465,230863105,1760756059,702444759,3418957407,49729829,2585597773,3957674219,472133361,2340823115,313697571,2390222865,1646608079,2067725317,1679043871,1755235123,2401353875,4041899507,3002309051,2532467051,47859423,1214455189,1663797241,3203162353,2429620681,2380738315,1153566107,503212039,694154393,1521729453,3471664901,1141318923,823220663,1780045873,2783801607,2274892113,312908809,2018401813,1627599885,424588515,2118513077,570434685,928767393,1882444561,1516665929,4268362913,3831751209,1502980233,1886136823,3442971247,4218380367,1293722917,2476640597,2370484431,615229479,2175593701,2146775691,3133785843,354753785,932277229,742716097,1654502721,1608987297,1135434461,707315591,3678652245,1054101391,3836974887,3397990499,4141192475,1076944861,1220118717,2361431869,3087642529,2213155601,2089436773,1511264873,3687127895,1770430239,87630847,3932847787,4121085549,2442255805,4285869977,1720232571,2523981689,3463268285,1753314513,186432663,2342626521,558771155,2468314207,4162768403,2926314061,889956439,2421769371,3567757259,1257877285,1314524733,4200411295,4230207687,2506994633,1429659497,2240140249,353882545,3469215725,2927690831,2554493359,876830695,860721957,704101913,1205973627,848105409,3406144377,3744466613,3389589809,389749053,687227227,1060967429,3270358615,2220797793,1682738897,3727994989,1428912057,2562818051,3350975731,4237968795,4098917969,3533893323,3337355035,2948197705,3616141157,2697232405,3300226765,1703621445,2513661117,1804106441,3442842347,2051958067,2966845349,3494481403,2366178871,1266126557,2521085829,2037189499,3859626025,1843577699,1116344983,1993005895,168165,2826365961,394451693,2415086415,2916465411,2867420355,3200884611,2802316533,4217608227,1201267819,3361968939,22254715,372857233,254249891,3980444607,921955311,3355899325,1089467273,1230899795,3170383467,1270697311,2032337015,3908306023,3964518225,3830192559,1076553447,3231558207,2937369225,2010504145,2035479923,896585957,2174928753,3855896537,3586582293,4117611261,4179439505,3944651265,638677477,1129105039,1702902387,3313355193,3309778847,3331673741,1951969915,1798186639,2732977895,2779256035,3186874801,3562641033,1168812783,3351025225,774847159,515382711,3383175879,4259977187,331807735,1825071339,3612564925,2721043297,4057930267,1848352849,4062879741,3429783781,1619971299,1059962433,3559260019,178685307,981833049,403727801,3699810987,186792783,4100196067,3540049939,3732385091,2198912373,3221672241,4287663129,1792967177,908825941,1733909729,467742319,1555024219,416081549,875856217,1662539387,3537246645,3862063067,4148236947,3509268827,1790310987,3510880845,3113693749,1969346153,1782842713,2545651253,2591410443,2866971147,4240980343,3174397677,18048077,2686336365,559108833,3848701059,2911267779,1410165211,1017189791,1939004023,2923771789,1111663875,627035031,3023010641,2571739367,2967678453,316591155,3778048919,871723943,930886973,3146487269,3374223161,4115501051,3072878387,3180324059,838502589,925338515,87866837,3604164423,3267726885,938984623,1804737411,1162653255,2907053185,3589927851,216862451,2674965451,2721685465,1965945961,470390591,3114858783,75236121,1773118017,2311442753,439192247,2750301043,1871628479,119402103,1041435629,1416910359,2713742583,1613914301,2339212103,3302189945,339049353,3275860833,207295251,792824929,2020052521,3601245477,1453641697,1582050013,3667035437,3378904859,1196420751,3501675649,3020787161,3856416653,3738237317,1773026993,781602385,2381316449,2280329657,1507397643,3115102695,4174665105,1010721757,604938935,1021112453,3442674847,3531752861,1722348553,3727552811,2587160999,166042543,3243263201,2094707859,4203061395,1525798153,3134829097,708854587,3774754253,1332847303,2910200117,645839153,1236309339,3894276301,95214447,2541394167,4057010039,3561950029,2440010437,907708353,130477389,2500173789,2755851327,665971199,293190235,1320810233,2466627445,1583163233,902087507,150199135,3251077173,280149149,1182609825,3309676243,1607208313,1300821431,1522281163,4154320283,2672681923,2997136015,1488596879,663274609,2216242339,2428634811,2991090401,2959177437,3468903239,1970705923,3161660633,694914269,1408063503,53521787,1892526469,3459569219,4007621661,2420168725,2435503701,2472407693,4242510901,3128682219,477491097,2193978893,1909052467,2039143495,2340698445,2513336175,637773541,3116521863,2256817917,1482574511,2524550689,141549403,3903919445,3253745777,2181703637,1757254987,1989469771,698074213,2977634783,148904999,2975369891,737570801,1076858729,4067465487,3193005511,3522268947,1239995833,1428671549,2815567389,3586445731,1822413727,1895752981,1852981581,253599879,1645627511,2767188117,2224839793,897156193,3168950617,2958591125,2204692043,1576338169,2157353797,531387037,1784943439,3492814783,125100295,2321668105,497991551,3147725751,2714553665,2360867593,2193790385,3035765805,2199416015,3096448747,4190373531,3029232605,4065073259,1641535161,2706538371,791807449,2099135337,1306272849,2949950315,3007486369,3648304797,2105650841,3438166227,769820519,1931990111,1005069743,100820105,2266407705,3744351549,1455709161,1970179109,2897432323,805890095,2562965489,1533998903,3525880939,1817203261,222796799,3629304525,595659093,3968597837,3676754739,3522456401,95567917,4187197163,1183623157,3160877991,425952057,3560727001,3359415311,53101859,3424731161,2599932839,73992723,2350164301,2692188089,124786339,1339976907,2478370313,1377050185,2798696029,3497339615,3159507721,3165627931,2948782345,557283755,3239386171,1357974059,13826103,447096051,2445548757,3795939419,909646863,2646243901,1034931543,3771886601,380860373,1619037757,2549791215,3452275073,1673994071,2782592403,3426636955,270874245,4213088175,2542165147,4129969017,1422847191,3709830245,1076737523,2030356245,682275691,3739847757,3069888309,170723347,309157443,3393702861,798337313,177409941,1021593157,2931932387,827881053,2797809311,1479172071,1174316431,1361556693,97613625,4209673167,980700513,2844031719,950103113,3989605199,265202471,3376863025,1239055065,2797052949,1651897819,778072323,3181106531,1104607611,2291490215,104335013,1211924345,2077575073,4015135791,4156100109,2521446447,3803128931,1484690815,3733533665,28159121,823961113,1339887141,969673151,2190752227,3513051827,946682577,2335231469,824183717,786225275,2768817387,3838176919,2125705853,1200336685,597301683,1510836909,789304241,2977391421,353687159,185363223,1548417617,1048071379,1274810965,2451043089,1649896875,1507944867,3722361875,1242445527,3945972961,1377585679,3208809099,2845200235,3409482349,4011187195,2216556547,3414561373,3474997683,1320811175,2482459639,1386875563,430099609,254189467,2964898439,837536091,1861275805,2215669239,1386477699,2333133949,4225870723,2630084683,29894139,4214604875,2263538283,2762616229,2694529469,821654353,1224877467,737364533,1905079747,3989115159,619034779,1706761391,3747126011,841451761,3247432085,3441664543,3731442709,3540167275,1409483949,2452121239,2590494749,361803971,3460636393,468778609,1792081073,3195945189,1389829565,2833370989,2163840351,2176717765,3859050163,754999653,1945798301,1151085197,1756230609,1952617901,4098952753,4118508011,2071247579,748159189,2942236791,2215307321,3893656461,2562465449,1719761211,3191768757,4210980939,1485588047,1633442713,4135718243,3560808105,427562945,570150559,448429005,3373670165,3411231867,3350565163,1632519713,1507759125,600596081,1045209273,416035657,104549373,519705571,3023039901,3063512187,381423243,2489259259,3998939259,2523926307,2532463011,4274926437,2475749433,277592965,1170498277,1614351825,1102743383,1024181277,3480792287,4221440135,1179636165,576012857,191823729,2755959609,2485866773,2816001879,2298984573,1507958393,3949693357,3776739135,333020725,736957799,3659035997,2076302893,4108443001,412348975,2566994409,528580639,1862452487,517327143,1703506151,575914859,2839738637,1810717937,2893105975,1107403257,2033272303,2447822263,3352049115,803497213,1000503361,663049123,2721466431,2579608817,2085538489,417315095,133227369,1474447415,3371401625,3938585733,1774496209,3999879227,1142099307,1054232669,1748396939,3436112325,609627957,2520093915,2545960077,3486848117,2922559889,2218097045,3535907495,2829805487,2367990353,1646933473,3241654981,835158083,548800995,2403559553,2458024007,3014068763,2609451111,1133800349,3307566265,504546419,1646242583,219801339,529248539,202945905,707810705,3410098655,1484540255,1203071745,3615782163,958587541,558498599,2182432809,1127546909,1285215241,1222050767,473657867,2193391693,629916655,4209824975,3532137569,3893168615,2953172315,1325065547,971245845,2853216521,700247743,853447847,3002186669,475592777,353685711,161026687,546149995,797875493,1005535789,3638687933,3683774765,1248949151,1583231885,2055921671,863661073,2857184291,2962048723,186999513,3279739883,977979191,56445805,3791856761,1011890561,3069158587,791187575,270847607,3765383309,2749181373,233203965,2448884433,4024071129,4008470585,3803132511,1544859875,1382643701,2319638973,754108379,4146025359,698847663,3092107051,4233932857,691417413,2765946827,2837315233,4030239849,311965275,3340295051,821439089,1901902713,2132312249,564884613,2137987757,1463867101,1641723281,1573303917,2700287961,3115348929,4018152649,3320824987,5587785,3719606127,2171229125,1805790857,1688051001,2814213743,2310553879,2679756105,1633828657,2032344463,4033484559,3306198717,3289970947,1132780079,3339757551,377611177,2844375407,2431500035,3902269935,1300234971,255582531,608321323,2034332747,3090835395,41079641,3230776053,2676608829,277168453,2625659681,2968296817,2119500315,4278041869,3297207529,2498929521,3318275521,106385663,1317460543,2002962437,4131012387,1778897605,664730507,915716261,1575401031,3586744607,2550655365,796174947,2489230225,3510964821,230111087,2006491415,3313003517,1694127609,1864549343,1399447583,1274642343,3911980429,1295750457,2193767025,2643154285,647362959,1077113017,4046316609,4226098367,2161130097,3870119021,2105702417,10036765,1184201695,4294431569,3880988613,107341519,202663159,250665977,3875144125,663279465,2297857131,4033877169,1314860399,1252015169,1574188883,394042347,4125142781,1912677325,2832589785,1919046605,2506896395,4073540725,2220315521,2167127981,1597340353,2953742177,2312801593,1802379657,190587423,3452201137,431351719,4118533061,2492262929,2942013421,2756095025,466836191,3505600099,259541607,2724002245,2249361775,721247443,1608087639,3194751631,2804536729,2877736753,494926743,3177105223,2574100759,4000888151,919215799,262594081,2487325235,1558568949,4157783837,755091885,3495941525,1136645561,3882404115,2422847163,207370933,2064812303,4259625101,3004232921,507211789,3493443233,2097524857,8739253,851753981,303184571,1791890919,26911,452309983,4176758001,1826286477,2560552821,3933960767,1352103939,138967025,3451565339,2630396615,977567969,1734972239,1145478713,2017334489,868954593,1631061757,2773696397,4235319403,2520259565,1035072333,1843176837,2968991937,917480273,1158379657,4095135597,93109235,1518834435,2059737609,573621629,2952127673,947636629,1190114257,587646047,2437319829,2931299931,3083094943,3091288991,3369700319,1114539555,1713948557,4282740741,666770647,844610889,508321559,670511153,3581753115,263027907,1188704229,2659109215,2513899241,1511289215,4096243889,1540303703,2116472189,628968421,1157758019,2237200319,2482086563,3706521819,1306596563,4095644219,51584601,3693979719,964919269,3896636039,1100625367,4081392011,1032893209,3873345415,497131553,1578641247,2210480097,71913985,1772553087,1406598831,1206583247,2504054161,3548754121,3994683969,4019711275,3746848405,470695013,3936312043,2215294025,3670190589,572969701,585108365,2736171395,617835713,3028895599,2695980711,3737842177,3721843601,1121748997,2623956019,104653347,2267196589,4118223055,1576959381,4008129293,2362005161,4133026585,1271785039,3133912335,2480704829,1958554951,803737047,736426105,3312789527,2392564973,2355711589,1436177037,111285385,2062709611,3279419009,4174984461,2083170755,3572482697,3368902459,589808417,125566773,1571829263,3685581947,1557485967,3135974539,2780429105,1427825821,1486318775,1029886327,581319875,3487529375,1487561213,436705323,3902242315,836025631,2244778349,997017953,2213338983,876570753,786844057,283784579,2153739719,4214087501,2157968053,2265253041,1517782877,1566071479,1403786727,1188191553,2632498271,1940362009,4272606021,2131223367,3738881309,4006665949,3537386317,1914563077,166685297,1161127797,3038484343,645243947,4117583979,3720910931,2626233483,4022252443,3506586041,3945366919,4076739667,150358893,1641162585,739620833,1172008201,1221840729,1238516495,2335241547,993564663,8468775,600797529,135978515,468318003,2640610619,845641437,648872619,680164873,2623067983,2359301471,1641781695,2555068015,1945139499,2963501865,3135120637,1313800073,610985263,3857499387,460911185,2708272019,4159425621,2578751809,566706915,2700646413,549917105,3982151147,3833969327,128183813,2606747603,2940581627,166769737,2580310877,1000159027,3465762173,718417189,1284648895,293408133,688054625,2082143733,3491193119,2934564505,2116215339,607057765,2272549911,3897192735,1867080451,990106799,2021690643,1068390873,3482130397,941251141,1243399791,2804418833,896258681,969368315,1362340869,392357775,1582344941,33955745,3758540213,3701383839,851912583,2968808385,2127489103,1106648377,2230906025,4068069655,462355205,1208112395,2434640833,855087099,488323975,3873533091,3651402085,2622162729,29599375,3555473621,965203531,84292885,3666295275,3823904007,2759042333,2757601513,16576243,3719026091,1012498661,404593405,1068148239,3699148053,1929762927,2227493901,2555076409,2086217457,3238795683,23576831,1118824375,714474299,3735973369,2377558603,3546721345,4189556089,2175386793,2964240229,2659902503,2961788775,113020771,1164571055,779779433,1807733243,4268961445,1006376651,591186391,1810339321,824674157,439115767,1464901683,1850073779,2921779193,1981841255,1334624621,2716812685,1673511087,3255014903,2037067849,1815054475,2762856143,2431796773,299610913,1858963029,1999548653,2590119521,2645281563,2040785953,4175686287,993858455,651263625,2211097069,1851427801,4203990477,4255977445,1827620645,3509077927,2876821981,2300222915,845935917,1303230685,3359907495,4030271053,836410903,130110265,624888015,1297851081,3139216241,1429139797,2095476937,4244053459,3284650761,1910727151,120786425,2832899013,2821274307,718368795,471290937,1067104829,3342425359,2265787293,1907021653,2266990949,662031575,2799406371,2551155727,615824493,3586059411,3919468075,2586565253,3038241403,857118661,273048157,2095321513,1631842291,3007229453,3625284879,1756945475,1082468881,3868009683,1013797003,750990929,3290650737,3968076021,3496527815,2400487003,2357283685,2088590745,176974159,2287339671,3360586003,2549053127,3932131939,679762801,160411173,3086108079,2193458215,1747951909,251460409,47293573,294148827,251996801,472499329,4196679997,1647824317,1034200913,82122779,1553062085,1798233763,3524990963,4039245805,1351212477,2336034367,1433588521,3850737207,2773068863,2278290053,1587511567,970093047,658009711,3923414827,200149413,951809895,2610719215,971987807,2438469973,786933669,1789893463,788522271,2719723513,3351157049,2990413127,166167907,1055288655,2316484465,3570867245,1987804459,2773946487,4143614739,3133230263,3902022607,1438360569,2450169357,4144952327,4139235309,2542594251,2751985357,115122819,2133953439,2378561179,3217147001,1246398447,1663222697,2136735933,1899297603,1297901419,3985247007,31513525,1366854319,3235467927,4223523855,1840979853,404020201,24243199,3728536763,1944573087,2033749969,1886020137,1481829645,2890489709,85493535,2370783355,1344277853,1749925737,3360816547,2128838841,2316858473,1266885113,2385234639,3708839577,1606449623,1434420483,653653365,3720751603,4243375081,473086303,1177050133,62245973,2491032575,3738290213,2662050065,401157663,3453174561,3906787005,4204186463,3254946853,893351499,3647967969,739549939,4275460037,2854030045,1488243729,3317817147,992428433,2386687635,2359539585,1348796399,383717067,2386853581,853626713,1713420237,3993201089,571783585,2124893223,427366157,1557701937,2470815035,3244511659,1602704995,2922967097,472107313,1903034379,3972353535,2374261615,3968818851,3096369743,2862553303,3004720233,107529985,3370211221,1111334881,3687567461,568281413,3393430535,516321525,1981953601,3222823843,2167801473,31818515,2197853955,2612710091,72902387,1204756325,1863747165,802143819,4023814167,3984677545,3345467573,1856670463,2123097537,312042613,345147523,2688588967,4058852295,165008269,3040089259,1849263395,2186557187,1726491251,339434099,1152352267,1577039629,1061890135,1598409181,3737665197,747340741,2071483137,412215201,318654791,4101840819,1118625745,1671067183,835026021,2624202255,4243141799,847283023,2469204757,1950373077,729934137,1576465701,5816827,3274147727,1479893767,418959221,1996249287,2972249981,4135818253,946708881,2777322797,759714793,3883744989,3484080011,3643642581,1057197821,44099075,2438795763,1967518905,1137056635,2201390245,1917594005,3862851959,227275615,1595353745,3924559873,2265068359,2708799797,144888585,4190976497,278380285,1518083635,2325943891,3641650149,1930131549,4127956561,1959237551,3686260659,79696669,3727104255,3638214895,28392393,449596323,1517947321,34914493,2692348673,2823721627,3195770389,2746933259,1103857613,2571175711,2084246649,180196685,613759331,3236620029,2112065699,3878502283,1269266149,3748601045,4157511729,476740023,2455580057,593306759,3087625945,1934428313,3329225111,3747518445,3142122705,3033440011,1764501903,3529302751,3493022723,3619947875,2252232421,1723554531,2521588587,1897108617,3162319363,3176254791,1165792017,4120618591,3184027287,2949113469,1827517529,1776007315,3627234005,156167805,487298807,3823403691,2940165909,1769731899,1235532349,3720307253,1070151925,3015360303,2841527421,1810039567,81675973,2633528231,2071030553,1395570501,537034579,2213901365,1738590439,1827023997,2071149579,3396040483,1432044621,3672213671,215170523,8535319,1719202537,2392069427,2617004555,3530482131,1840025913,1551019797,1833237699,3425624037,426630595,2080013285,2044491935,2037616351,2443793001,56752091,349670975,1404835439,1634024961,1036658497,2732031421,4051736693,832169687,1862436951,256213591,2624612155,2542396511,3723536471,3804011323,3430151277,3501509277,224572957,3416420973,369556531,613926199,1746203211,925864181,332800711,1334149795,3326346691,2614553739,994323265,4168358001,2381407179,3805228767,2416896115,3267322253,2728269187,949411971,963516193,1789974177,2145082469,445607453,3196485935,1888212999,3977522927,3356887079,510779575,3327680419,3555683765,202126445,4115015661,3504863245,760138311,2411877427,522611623,325448337,2316851503,1149740323,627769761,2486715869,4201856469,2749443341,341132847,3933406139,620405731,3273515185,3733662255,2189371251,1777824665,4106664397,584122605,3348372251,3430953375,4097468481,647184977,2380736837,1128725361,3911588829,3304063845,1768915595,400812903,1953760535,1828365921,3150029777,2783613001,3399958365,2855377985,2668234839,1269439225,2362522083,4231000051,2939354499,1017265911,3218352863,38484611,2565779783,1589197927,3542941803,796335811,897904179,2855449437,3869128603,2639616267,1313436549,3091171983,1403146863,3318899187,1998405537,557638085,604675893,895132853,3522413589,3670993927,1189769585,3384678331,3741884187,2936428967,3387457115,3200266641,1006029331,3343713739,2444753483,3314671183,3952786307,4220342257,4202437089,3917989093,3499118543,2993179559,3711917591,1799023393,3911400491,138667079,2705340211,2129168799,3567495285,1149847561,2430118827,2163143549,3350468433,6778603,2258847783,1238794021,2704653735,3476468549,271852273,3470935595,1768774863,2330497473,2864291531,2154347171,1538631383,4074561007,2188325919,1388798917,2691139229,3971432789,4079152769,2052658561,1855146125,2273352535,207025127,547818155,3064836849,1170181007,576962229,3263017051,3385183171,3636795479,1942071445,2938325815,908043099,1461586117,1959930839,2453450193,3451388157,3947466035,701876633,2460398313,4264324059,375241441,1670928101,2792442141,1467459055,1882152043,895283197,1754277903,3493226511,2750045497,1871634151,214731407,1218247295,973213373,1561721265,1304184027,2202857313,804802117,1457188419,1062264551,3596251599,3420880031,2298500339,1959372143,1653381109,4232890883,358829571,714535827,475107171,782040257,1150696565,3814427173,2395683173,3223691461,3864955317,1218675169,3869524397,701791437,1028509141,3204758537,3486881405,3482031305,3570779191,507880881,1853970595,3991056295,3178936473,3287148451,939730041,1448075855,2526223987,2494865125,3727448653,836577493,2929988395,2514945861,1921962379,4267669779,772182659,2977771445,2445783233,3441810257,1885490613,1172054365,1997719077,1905206747,1828636865,3408818291,1440298977,669254261,3932005741,2853720309,577478071,3342838957,627194291,1404726167,4092457751,2331191747,1648052767,578792769,3964131773,1630061089,3135338497,680405799,2377343971,4234368615,3720234825,4147821823,827247053,732105899,3717531283,1659064369,967193941,3472342697,3943101707,365059935,2349048519,1119109191,1206409517,3879141345,3420046595,1175843369,1254999895,198871237,944342333,1657456207,4003586265,3316744857,150319579,980412187,2293103931,1456256061,2571992821,2932512537,1988527515,2041446797,2397589513,903809489,3321746845,2614353309,1920663549,3913070439,2435679351,1129589949,1262850169,3289407535,253449183,3407847133,2297915647,722388287,3602383571,3401718379,2371162225,3416978649,1152482475,3765445485,3794173405,1293020623,3558087221,1942305791,2582011743,3816810125,3791251791,3729061653,2176464729,3901241405,1193600437,3345298485,3309775741,3279471199,757174497,4138663057,1514689475,1114871593,2999543929,3303701831,4274480885,3577291557,2587033893,2324739295,575874353,2158954295,1661153159,1713749119,930786275,1454055983,4249987521,4234183033,601158151,1901985175,3518251083,2431232289,3697230207,4056263557,3900728937,1170485349,1397070929,4279891505,24301429,412241079,753586337,3962000053,161981401,3707126311,2876359019,3109155169,2998843385,119593411,4256749185,1913352943,1302799629,410116597,3702123009,390240891,363613905,3815426073,2004326297,1283603643,4200694239,395712907,2137473643,1413087691,2890670917,3131056391,1725494255,762791503,4054402431,2685555313,316869751,4165444597,660466385,2263061805,3344385071,842928525,2297600869,4021849029,1021374237,3547511241,285468985,398780303,2151590687,2455045029,191025751,2229245245,1925143959,1905910017,763593873,359965845,2632023769,2555341483,2246348881,1623145513,2869369603,1602157395,2309388485,272848323,3031678769,2228078667,3793303983,3860514245,3886989357,2177598165,1476063787,472994771,3933639103,240864385,2348544553,1238887217,4270998907,890262133,3264601135,4239079195,1286574299,2588902103,3658973707,1029394863,911219015,3299598801,4034332379,375640281,4079264687,3933664387,665812573,1922130347,2795740661,1071109873,1935723163,3616932591,3113961761,2178856543,1150786363,1028694865,2031254511,2894530471,3574071059,4294698829,4077860139,1802262621,2518530665,2042221091,2526246889,2879779039,459889193,2711521651,2941415823,1302200027,3217507665,3013111001,3692214353,1359183965,3168847069,1218259889,1184880731,2822087739,1504818537,2717741093,97395167,538049561,2092834663,2785027281,1399958561,1272715001,1583914493,643612445,2466733629,3367797721,3497313321,2717584463,1759882051,3192861479,1101523123,1990107927,2833627517,2180339153,299208869,3691744109,2045727645,1331357851,3646784117,2317385845,1540491729,981657877,1754579291,4263687333,2558689441,2680904165,3749403901,471243345,267226085,3028005171,615459197,1741496833,3430147721,3441743585,764934309,1413837227,2603220587,3791565831,417197345,2449170413,240602401,2240346759,3824696115,3187099607,3045988181,2208197687,366154761,3569919925,3246066395,1963349183,4070982979,2181951439,1627095907,544164857,1793399479,3879558361,1838899919,4101275109,200672363,1151095957,1937073929,549452989,476720829,2132986499,3307069775,749973577,3371884849,3470196913,2238648371,1049692763,2755608089,872837427,2465343385,1476803283,16802161,3221062623,2631747991,2215307931,3903908731,3073675579,3693828121,2711978977,2037759317,551655269,3130702437,71556671,62143983,776886645,433285561,2260877203,987517609,1454847253,368993235,4031512209,221683325,2095016183,795128275,2077683097,1535727865,2519774215,1467729471,2132066461,728892991,1257794055,4210645417,141437087,2016224433,3687079871,963290871,2297954617,1377357077,3661662579,3271593627,1502808007,3286501735,2955276111,2323826567,2415524033,1681576549,1372281329,4252911823,1843319219,1067038917,2234642375,2440394695,3070965265,1091253663,1189985467,2718039811,822981299,2052022419,4048409413,745149549,3898824839,3528048615,3889595441,3028379013,2603654397,2492675913,1293100921,612688413,2417570379,1714775419,999941199,4099694271,3696299155,1292974475,2782477785,1500252229,3281213829,4275753143,3485295293,2594050685,4291845501,3366616677,827375989,2899133251,3623583227,3222051369,2069732837,1059694159,3345346195,4111637711,2566232417,606682977,268455289,2212400329,2280482151,4070364301,373764881,2624187945,4002633629,190693487,939851491,3489286005,946470565,3066913079,1705640265,2084230505,4203831771,1588605703,2179367623,1150573335,1743300563,3680666773,552535135,738741123,3566591407,3138239191,2187729623,4251753927,3857397617,3045430089,1418280031,4258983417,809384521,1164241155,3825084721,1128466061,3848501023,3844230021,780976111,445463919,784109997,1577078393,1713396683,3597329011,54107045,3139023087,2477767813,4135734567,3835165573,3053621159,1646640113,2606120755,995081879,4033481617,3256752523,1176476131,3299896241,443471871,1663497613,2462281851,1561208873,1282346271,247912211,542271903,43292659,1770263933,1587493199,661382071,473127231,1864927029,3452248891,1233953197,2949303353,723930623,3754620959,2254991271,846906247,431697819,1345501173,835428507,798849869,202004045,2057838861,3021102345,563779553,745113513,3293167787,3322462431,1756305329,3208436941,885308023,1605252951,2796790649,1538389013,1048417,440892149,1255782899,473917583,2263471211,1635337125,1615362375,907188057,4270764399,1243853471,1839484005,1033106629,3165328061,2203834549,49338393,301700215,2614123391,2351399017,1969223431,4015221353,1299173349,3887738047,1875929113,3680681037,792270183,1286371087,3468485313,3536558229,881789943,2606424507,1805274449,1598716333,310034273,950715495,1397007591,3215369739,1440727071,3569262825,792121283,3078776081,3518619355,30845205,3019301961,369496723,3903700437,3867845615,2551273421,2593907551,1886192363,81464733,3378184845,1980047335,1248982239,2139341901,2748128839,4018101497,2461113323,3396595247,2166028581,299593729,1570151541,1257912057,1898937737,3839568145,4033204765,2898668253,103329135,1486001975,396021,2360974459,3989887247,710615913,3312589277,3321930517,1406361319,1509686357,2926813247,689840953,2040187371,2705253201,666791729,1198936063,2826851493,4259820723,1997084581,4126134357,1398225981,2218013999,2140153373,3501636861,2368877245,3668025435,2837932069,1512500619,2981474447,257628437,634125113,1926934583,1936156527,2310546751,2559955809,2489914671,2129546861,1331648731,4240636983,1698513451,2562951839,1304583353,324394807,1790041969,3284462613,3043491009,3187900823,3627123611,2595743141,2672182435,3192175787,2461999561,1111728137,1707086465,620710141,4094766761,2484017171,1794512123,1104929599,3408175237,3517392281,882248957,1731138217,1131580369,356100757,2095999163,136203959,4257355311,3510578037,2319366987,477806971,3207905917,550322243,2201370925,1592882765,1049504659,3889111455,3483960899,1641727197,1639120129,771801193,861439677,4176887365,4000507225,3106927105,4206477383,3103733647,2073636305,2240771425,2372122989,2384670021,2809239439,311805137,648855685,395555135,3780766933,3603712301,4258847019,2811910629,2256822527,1560054781,3360358497,3020327079,418785773,3376076045,897184087,3637765075,1058202241,4040484133,688954703,29885503,4069459623,2348710911,4034866123,756341101,3016678367,3519392599,141855231,454036053,3122045433,602178439,1870096415,139806219,376029721,2034648179,4097333725,2677308179,3441209315,375393007,4218297863,4202045483,1631234345,1379415619,3899839621,3403620513,4275557305,193846027,2384983743,3786997799,951694813,676536041,1762830675,1210777519,4277706961,1963376067,227855073,2744369763,968853281,1296099019,3757081265,655681273,3444063007,1092754217,639992781,1760582897,2087078319,527434141,4068097071,923135917,1723507897,1737810949,1611037449,1232600773,1693949655,3168643759,2096196013,3444661909,2568565543,1164826013,769891245,3120681993,3456646123,2123787423,3317022027,513748475,1686375191,418678837,1578802693,628935725,608236347,606141115,4046282537,3653450263,2686152023,1755840133,3979822357,3348701443,373748731,2352754895,3282628507,2282442525,2658631767,3079365293,536603557,3559649199,2424666273,716381645,1432999239,2536609221,945833909,956570275,1014047289,662580437,3434195417,2751893553,2867140285,2788715415,3256884583,3396008551,895363497,3103880003,238474303,833142025,1024652541,2811391747,2125907341,291778207,3358659401,233424371,1858280781,3417908399,3893888843,2173142429,3897920127,1207455913,4286049741,446558825,2006325963,532251753,3433323369,980284699,150413115,2552471739,1259201707,2099248817,3213531209,605324419,3204974747,2825755581,3020696915,2339652131,2107805953,1004427965,2199359141,2140567429,1870741465,2391226981,1342916515,344754441,377027087,1617509365,2631910635,653898345,3543163169,221866879,885040967,1411810053,2892245521,3825622055,1569504011,3259777229,473102345,1446668027,339695261,1246734707,3019777223,4062257863,1567814823,639398277,358688757,2642842223,3992471513,1194701635,378296801,1482756093,1281432069,2062788373,308204649,264995985,4201420117,4005609865,2967651705,4162004813,2977558813,3167044503,987304185,2162797379,1827356537,3365182065,2485655869,3566305645,2630404551,1110948321,1485620835,2184510629,1689729297,956563557,901137863,1369401603,3097997175,150031869,439837511,710351209,3158676443,2079240467,1940641691,383286807,3745408349,2037477585,111552839,2262841695,3939963595,3457386373,1680267291,842418593,2317108333,1171314839,2453407477,2733460345,2297858597,4058516231,3106715209,645141311,2392580727,2620489067,1965133199,3990168833,1148264521,1593769311,3064781399,238232857,1070126397,2586311207,3063457575,3758526653,3473480919,1598362391,2951265667,3639770963,411423505,4192489295,4229139801,1738903807,2798832679,1499048871,236245099,2021616043,4109555967,1938099361,604019437,2746978743,1868307201,133257579,1982186885,2848660737,1440597347,1388991557,1633872415,2767785169,3669558169,2828788643,2457762421,2912560155,1656292173,1619536003,2333877149,3831931241,233810763,4057403831,1590477585,3575317339,3766090319,1746996561,1374795749,3563095823,222533725,3502787101,226124455,3722644095,1690749773,927834513,3383399577,3724702179,1921229209,535216177,1716790009,499416977,1335056769,1389989533,1226985871,1813572209,3620215245,2450952717,131014671,2940337775,363316467,3111352901,1281419463,1850919331,4248069775,2067397069,457147029,3868611537,2539222593,1919104173,3474441771,567532779,3696040779,1245416337,2336769103,897394591,2880738509,3700799601,3917526399,17587779,3540042467,3606803187,372793199,3472997747,2067625175,4290924571,773448049,2770344705,3738006781,2193375735,361710549,1890492839,3640088161,1447602997,3168834169,1001449589,3681401237,11769701,244885989,1220166277,3160772789,2952789337,3478288889,801535595,2391327987,3040524357,572020893,1818361485,2509198391,4108481851,1065300925,3088981889,3248942651,3059943541,532732037,2915521969,4190859837,2612642959,3239582157,356943467,3374524251,585986093,308276715,1476209247,2917740991,2831256945,992841195,734043981,1931137105,3848467077,3273699599,2538141059,921631411,2207079319,3044580255,20021875,1500220999,2756331219,141581455,147650115,3359370973,3602880387,3161770303,2538137959,869529711,2707135395,2236055229,416428109,2405522843,1095300685,488807517,3410488897,3748370255,278624199,1322578939,2128498129,885479183,186971777,2813580931,264817183,1196294903,1386548313,3519943447,810022979,3304870173,2435968409,1692820461,1370149377,2780932911,1305358675,470329779,2092791499,2059569933,2050458391,3531594581,3357103887,4154671631,4282820465,2006691915,2387839723,247846131,3726632637,6698463,911934803,2444945835,2252563953,3000645561,343994385,487667777,1434747893,1861465941,1116317697,1534410093,1846816681,4014307929,3127125357,81115227,1799004797,3598857519,4268904531,49823053,4152413541,690840187,1654444033,622618081,1801775989,2929641229,975094193,3107891947,3242707701,1348353947,1537360891,4196238433,2816392757,278536531,4144110157,2869786001,10623993,2463808103,1443122473,879111299,536127739,4152510661,2323136027,3694520135,1457756393,2018268981,3690059755,3801561025,902698437,1828165057,4069075823,193151605,3598735071,2210920995,3187119377,3378262571,3286388217,1047379085,2524327589,686874997,3730972407,4225736149,368299465,961254407,2430842521,1441366725,1435025721,2235953843,3007400901,2211844121,1522228883,3275650323,964220975,750343369,997044405,2657917747,3963733035,3518406111,741820591,3783602555,4017371021,3068905073,825345071,3125232777,2632261519,2256238439,333222353,4125719595,3017255635,336633993,1335610959,2114326275,3217297469,3775314123,2152647805,3042158079,2260182783,2201302551,443720947,1554750651,113191467,4033458727,2872040293,3538771285,3716883783,3661433751,3720648725,2514304535,4028098179,2971623231,2191965591,2431224105,3559681719,2971229913,4171404553,2045199115,1038288729,66569587,2143569075,779798259,2124141825,683521853,3209256021,1766683701,1544076091,1094487895,4008115163,2124522251,2782374341,4056636215,1574057355,2478418545,2187685409,3508649229,4261629283,2328781443,4087746379,456573835,2824874567,1098396499,980545887,245232537,2749631219,3498798393,1907385803,4092292705,3852230919,2108082683,1360461781,3170264111,3559648313,2409775271,3846381377,2579078051,1754888915,877603313,961210801,1697956479,1791858023,3742111133,2455743095,3333486425,2352978845,2751588863,2041182749,2254702071,281289141,3162586193,3365899307,1655440281,186689041,2356604273,3554615143,3716632961,3740835691,2494225871,1573441263,713694889,3521331381,2662193247,2807617537,3117269281,1933770361,860960435,417234365,3071365553,3523926785,3333475335,2166589215,1132234779,2764835039,1331363493,3741609211,2609874629,3956900081,346097877,1481319469,2905896265,1325442587,3013189831,722142869,3772610539,3958151751,4203046391,1273625925,4008912279,2636748981,367600981,2106735701,196571777,952023759,1910164169,3543649833,4106261433,2401441245,1215359803,3982742857,893937415,610556299,942868733,2660464771,3821892463,3310760677,2653421375,1407652829,1741258457,3718729583,324055999,390663207,3166511623,621124613,2470863077,4051953553,181968413,326420769,1480646951,192820827,2334316519,2626488243,4009036469,429043017,3970884193,3448834385,3975892971,1732020351,3072704625,259906125,260521683,2016270401,164696753,2099407141,1579515383,4017181967,4186441789,1372954221,2677305785,3400973357,2734479353,2244456877,4183972637,2823589497,975061479,2558067749,822061309,3769619665,935172667,2161702329,602720363,2388278495,3327319841,1790416613,991169733,2706553205,1041122487,448900059,2700740155,2125438899,1008608101,3735428189,1804652931,4037765189,2236303129,287916115,2872988567,2296543227,3425929111,1259042019,3710339895,1052490485,2532281509,1224422323,1677693913,541327487,1350362123,929036571,2111551913,3833235569,680814989,664665713,4121690797,4024724353,2102304471,3030300459,537658967,4118055893,3062434941,3750986191,1294987611,2257516185,333462905,3873709765,2325794709,1134348275,3926623959,2596423409,1220544829,933161665,2722530067,3276269893,2787399377,2613070387,1833429965,2362071405,951422199,389679837,3818881209,4240222227,3317643947,2376423327,1646006789,551778875,913181185,1918051639,2964372009,579761669,3068564897,3697941627,3128197615,922686257,2756006865,3280098365,2708018871,4199734479,1444895763,618025271,1919829611,2781976355,1662652807,1148529291,1748791407,1476001413,3719642247,2778297965,4264461487,2684993837,3765044501,1349802611,115252975,26518037,3307033383,138333233,1389357783,3494065503,3966082159,50460239,1976696761,770459843,4087173991,3721350601,1425832585,2345739675,1341942905,1161160347,3585552193,3984589737,1869678517,1706129121,1710498709,2135720227,2008196037,1897814413,2139730853],"b":[695310515,3772802731,2893355401,1004538745,4061238601,1616947565,1779672623,805556151,1245335975,986124969,3818550537,2977585217,3610816531,3400556397,21599927,2252737199,1617423789,1193634803,3922887847,4228098435,1416534621,693681311,2160574867,3128302999,2693875145,2709332767,512580787,3535879445,2358369137,3151913333,80800341,801683089,575292351,967181269,3259364393,2124502281,2446738551,2317970707,2780332775,4103774805,3558357389,2188052073,1081236489,335066515,760811977,849280007,1672776493,3793595427,168878965,3670367521,3546665825,3256431449,75152707,371178919,2111597551,305306141,3089379557,1342614139,3852655597,655711241,3947735183,930479775,597677777,3536881473,2019584557,31141823,3709593393,1390933253,4203186029,3620521791,3308104045,953080291,2487428317,3291068123,2393147935,3563619335,431265321,2666441875,1199864335,1248449821,1780927163,415773461,4287755789,3350303797,1534708645,2569612851,1587062393,2010760217,2044314733,3354349631,813563979,2688915057,949512337,2650367555,1621707617,177488001,2333547577,2587781931,2012112079,3290222897,1072336435,1075714227,2011689549,483728481,3946476725,1254412639,3213761527,181311751,2174804417,1766181385,1691585667,2091803089,2627232239,3628475359,3839735307,2547729205,3155811355,1170346685,3361512375,938718155,1621177029,4144797367,1534822589,189702365,1461933213,3498606017,2969089665,2559994769,3144715391,3659040673,2154892425,2112780773,3011849119,3958600049,3147656289,1547105831,475720547,2501116101,1413419935,4179728531,212376659,296703305,235435607,1301385881,2419057725,942795877,1435973979,993456873,2491809539,3911822279,2932690701,687962569,534958541,1681669051,2926962443,3197378125,3998348447,1184083611,2309793781,2789690901,2472008609,1830073407,1782975921,489510815,2345916501,18890193,3954878095,722317527,2413120251,4230885415,1012667247,3238018307,4138087575,432498089,1910737181,289360635,1381232443,75462237,1278482335,4026216563,1412074177,3036410295,146457563,496018685,54537947,1791258413,2254400451,3801896389,2244193891,4058934229,1542073007,1788393459,1347758807,124777499,1191403027,773166967,2341166825,1795464247,4222375785,4020203833,3435336123,448902825,2747228317,1767930125,1017887789,785354527,1019057633,3267053459,2505615723,4024122891,583467225,923335179,777537037,2774489317,382056667,250314545,2263593795,3695606413,2534961563,3318416961,2483567743,2830910315,3756965373,3002851723,3063220767,4073461891,895352483,2918767705,2907369967,324148337,1942587973,3029677323,2949514097,4265905031,1176834081,726027303,338816073,3650091167,2064400373,1631284885,2228841399,3727638825,4032798297,362127871,314489105,2808632921,3002958993,571140363,4199162951,429159255,1629528965,2781865017,4086362335,2964750091,2639218549,3218924711,1059599359,1752042595,284143307,3887913921,536876137,3845933965,3649359155,2646376571,3264716233,1878563987,720368121,4009191961,3042397061,1981785963,405331977,596425961,3972446431,3935564687,2539383615,330433633,205375495,2887224189,1036473717,3921401255,717783161,3513442181,3212394961,2983240753,4174129615,600675915,2386979311,2966770823,2241922921,250479791,745916023,3896051475,4160760101,3532520699,1742499937,3109447473,3616629419,2313517251,945541781,341742273,1291127039,1797391991,2262230841,2263275005,2632670177,534618857,267567357,173829087,967722095,3759092387,96870375,307805005,2138113865,3583364257,1571687737,1306954465,1520968545,3567986027,807813767,534382441,589090939,951815909,2711796513,3266054163,2890317027,1478194455,1923393495,2550632627,414017381,543122993,1462660407,2835653693,1874540833,1822695547,2337334427,1808860471,1739445971,3321048439,3761145549,244625757,1141414347,2427011831,1483469305,383484271,2769218503,1989798943,1935500723,4173350805,396118127,358071595,860135077,3725311635,3574421613,1596525319,2140367621,2807535703,1741885243,1368220003,418715151,2189132091,2053229839,2866680883,3657480589,1704364401,2115620727,3498315763,2385757981,3914713983,4288919595,1435554769,2537728991,2585939123,1104809081,1382629211,2076105543,791581551,2597434945,1041561205,3527466191,2690729861,1386152107,1155876499,679264737,379384113,2577339701,2603211523,3639227183,4157014927,716923397,1948290515,88052955,2437282355,2301474413,405026333,4049401841,245017769,3434992737,3267548911,2242742899,1146948155,944442419,3339601609,2051661277,2273663113,1131942279,2143754833,3901832965,2546014769,111089267,3061521679,1286693639,299682189,3056898761,898722105,3717429837,4249028741,1004869455,1029546983,3467899855,2286700211,1203116371,70844051,970041525,4087046751,1582827921,3856433311,4018208323,4256537905,2657337277,2797708333,4077002119,266422363,2404751399,1014543259,408413639,850311667,1832016937,88146279,4005778823,1512361517,643587133,2041314845,179872249,3750898067,4108854837,3039109333,2559516289,3692836619,3227674039,2080667059,147569671,2007348665,540935091,3345297139,3287153519,1024907917,2808528885,1254425941,3437328241,3865658993,160455819,3836473401,3559449885,3369763169,2170859505,4183522105,3841432761,1012067525,1748425241,3911784039,2289991021,677185219,4083630733,4388217,738335927,1051429529,1880663193,1641985011,1677232733,1380209815,68022617,794840521,1536368913,408966069,1545068089,587129105,2339010223,4204160079,2811510965,4129604267,3882428529,2833173261,3135593149,665374669,3152212407,812369765,4092596829,373708399,1674894971,744149527,4271324261,2063519517,4006607269,2551151557,545739303,2485309637,2042151715,1360244457,3812666937,2876167779,4189951783,235881263,201591685,3717238929,1040437985,1829376827,2960457743,3512169711,3300828141,3221013289,1802591453,3750242795,1685632921,828248829,389085955,2427441023,106964661,2458745341,2252627419,4067318623,724662263,3166392557,2914949645,3161744957,2112147737,962347655,3625192481,204012289,1450657417,2964863581,251677685,3699051305,303719291,2188995371,4050344093,3196545251,2885137011,317011423,2251558607,3283664515,2514759805,3089886481,1272551219,3126197713,1670071695,1283728381,2002198511,4176609987,3633582473,3775654425,3577136225,4271336263,2265237131,1250383507,4215616707,2089529531,3070248579,1930813943,2712050637,3242148937,547141987,290415861,1936546649,277392617,2098216735,3047198211,1070335427,1804511123,1654398133,4146144075,2694107475,2319135783,886928637,3073108685,2755975251,2748761867,1772501211,534718899,1948973251,2972862319,1542481137,57899781,2459027629,2702074541,3077627931,1401531481,1938977677,2480974567,2197074223,2392656249,3889787321,1958338879,1467182237,1524639211,836360079,3570878591,2178496681,3692520317,2206553619,2799074943,1275812625,2106073533,1952416083,706997627,2629598591,450080483,1065289853,2902894785,2419175755,2926526087,158510127,1199999015,3512016581,727172231,2401751793,2139772745,1399389359,296071575,2502851379,513466223,1237533121,2987543905,3482761281,2954583941,3575427259,1318548465,3107798315,1669034677,1034436031,4033751005,3489389345,2683305945,1166447421,2251091737,4026915013,266021445,4256457161,1300272869,892534217,2796811277,1885083809,2924834125,1786475851,3478259503,307645093,3745440175,2572377167,802281171,2037321937,1790544197,3135474021,2958157667,3509498025,1347474479,3936011391,1457203155,1309932503,33245683,414462767,3733758201,3801935673,2904440079,2621128249,4117930485,954702685,3985200511,3545022547,1407661867,1893160123,1224490115,2817074057,3139211043,1341777011,2667947183,729772127,3148530925,3362211201,4093952149,1677735169,1234717079,2902966245,3620203975,2261537827,3500690589,3644752917,2538745797,2495528389,1990024819,1436831361,2518574265,2775006291,480904097,3721695071,2920372581,4110717135,4273980761,3761642077,4294804559,1559896955,707776915,2842190125,63203813,1409580279,4071139549,518456135,3498605519,2960719779,3621241469,2518830309,2783370505,3619295387,4170768487,4239739735,3798335491,2525723321,2670106251,2657489651,1063690857,1798372777,1566431967,3167541249,746179619,4031342153,1658519427,398288335,2473019099,1633509661,965945985,3972782675,996883007,4240268855,4101320743,967643001,2429759529,419389357,635610451,1121206585,2097572123,803138915,3568523463,1250566031,2988330281,3814480831,3297513179,3341021777,150621089,1752923463,2203989901,2660339457,1715740065,32877345,2813740589,2948189189,3473012745,2319696561,1721989895,1994555099,267836029,394432097,2085736443,3744327973,1059467329,3827981679,2572998933,2662367745,1445438129,1143636045,1112384471,4148157415,2172574503,2942722433,1787557827,188193665,1875016077,1220186867,3506828919,3732450171,3292711933,4250858841,1698589097,3834334161,1964981557,1441521739,4040346019,2662639999,1726243813,475710927,2339432761,2715821657,2197172667,4047204557,1969971227,3698526843,79021045,961826275,3452293409,1982167223,2518201503,804962651,4155283357,1679197465,41722187,1145144793,700108343,2805519341,2212627461,1802922381,722215103,691680083,2885674223,755998919,1560592787,3812690751,3276409677,841781771,203975567,833470763,2254784813,1671933935,2517625003,4000629033,859186867,673648047,468955751,474339373,762561153,182909981,3266452263,991249139,4041129847,2951535313,3876743991,1782423563,4090931791,2454185791,2929681861,1657996217,194632453,2717543643,1073820311,245414395,1511151331,1778827501,3781459873,2365052999,3818432323,990762519,157474801,979144109,2455353455,1079774239,1528834529,2627593001,1101867705,3486530307,1876094513,2165591543,1544230651,3692177815,745089799,2894606589,558418991,844461153,2286675901,794538201,750243967,3621362285,254417527,2502935565,1928380325,464938557,1676836519,3310975705,1972429677,2068023053,2388125529,756420279,52455719,1154990769,2972669803,2601832019,1928739925,2213768463,3799873819,2610598253,3233946767,132224205,1794139243,3427870027,3815246173,3275714291,2039331151,1199665543,2202319971,363629711,4081077515,42126231,3640945007,2963711837,2369152747,4003420255,526614787,3182116275,895505843,1201321931,4271429323,3829296551,3197216167,1276320341,2049321757,1608056119,2664994991,2651888711,1417972745,3389394909,1409032047,3446938913,2183466125,1314619745,1502310685,3517945469,1589745085,4149091721,695586269,4112432915,3046324163,3560079867,1072968761,3113282721,3651133145,2397055443,517629587,2491715165,2325678461,3475535433,1768840837,3439322491,3023280391,2810460323,3651333349,1466916777,1358020285,790746485,1447382565,3759000839,2853190433,261786727,1803028439,2504731909,2054762875,2862613171,4010921709,2049500639,319558599,2112272699,3062583989,1961068633,101517481,1102304255,2233691569,3640067429,1099160273,932393623,2698950055,2103999257,1449797703,1400552265,2661163541,2681217971,433606755,3364217467,3453526459,1231202103,3956306729,3258532695,1031055877,3058077549,3530742845,1926878817,998897365,3735845409,226934883,163638315,1490108851,305184249,1040740713,2622359029,3328813475,1124119487,3810075803,2276651581,4114483721,3154482253,306965841,919186399,4063435575,4181751231,4143124501,3483734785,2136396493,489296817,3044219409,2545217741,3895308847,269345893,912581,2452863791,2185664331,3900129635,3982918517,3846255035,455648057,150225603,3695924849,3591948121,4106769283,2346941607,67977559,37550715,4049658887,270222597,1850774827,1819391047,2633177749,475446873,2196444477,398449815,892046165,3184055901,3430028967,1445845107,3688747997,3229680789,1448375957,3275071007,4112558845,867862379,454090235,4032682307,2707651235,2315843521,1388456025,1223120679,1275799675,1888422883,3210076021,2663521819,3662090671,1876601283,2092940345,266257361,3926530079,1018582249,3867209159,444292017,2562789553,2872009845,3027031749,1435024819,2220793929,1617796649,3165325529,2161279225,2081546023,2035415737,4112779149,275544413,1100223165,1616550291,3692623093,3933909851,496358727,1474656547,2591315855,1277230631,168696611,605543843,2597866621,4001772443,2896609561,4157598337,1932360679,2938238825,3740969463,447564581,1730197879,2507188779,397704025,1242455517,4113874891,1511811031,4276470813,2662273101,4149723715,2727574839,2164407017,3110738639,3842419911,423228399,733879935,3468983277,3315904589,3207804479,3140421071,203881137,3541353047,4158884777,2078721289,1804751633,1401682409,180657279,4059995395,2197220793,561090945,2802319091,4260600533,2218449369,867482375,2657297595,2130772959,463841347,415897225,2072890043,2583247873,3117610565,3374763255,307959027,431794325,2967477515,1234393483,1759255567,1253479479,415043289,605689573,752183437,1858296223,3677442093,2189913197,2296376499,623731615,3337072751,2498817811,1440765551,4215996185,4172448983,2419064949,1064209645,1927708105,2051838899,963988773,1142691649,2419790075,366500445,789896325,43645327,3402587715,4097190495,270041569,3103204525,1770617439,3233901247,3662136859,2652882999,949101985,48548785,4210627735,4139223007,2335834537,2370013005,1281907285,1459809097,2158326757,3999023875,3946067419,2965141285,624081519,627974691,1636007085,4285445507,3176099869,2856985257,3911851579,3425135801,810782731,3189120155,2645600065,3098881773,2132568573,577954787,2765070181,988427793,3867407859,3783842917,3762167861,246754365,2557190651,3260544399,482026653,1113657293,4065640299,2581841853,961468895,1740775043,4183925073,2024181349,4274980969,3392268757,2465155149,2608088125,3995898411,2956001499,1630520801,2271783493,3900907291,4168081027,2021272455,2629839745,208188467,2920204359,1283409981,945817005,672464747,2056069121,3341853223,1239832129,2972265715,105292297,121127357,4267975843,1621233013,790753161,1559586097,4073121097,3757562313,150720421,3422396387,2014091867,2204781461,3079186495,1826512865,2070488643,877623719,1304174443,2041779025,3686378215,2055460361,1700358491,3507768061,2336740589,418159793,1445164773,844309047,4025197653,1467122983,528757233,535500551,2201296533,342576421,2425750593,1760678709,3697390603,2457071835,4190783135,1323512445,638064295,3708257047,405802501,4209555535,3298626783,582527735,2313195925,4134950287,3538673495,2073327253,1341501755,2336686885,3810523959,1218874885,2931183915,1133214031,2043254227,2710294465,3790937191,2736546747,2631409483,820971269,2629186561,2115026861,2107144489,2772104399,3248412781,2744353039,687773013,1644058143,2160623905,3952484665,3445612457,1364556603,3272460761,3191827263,899323987,948358729,441547075,3673189593,3732589695,1342724507,1412643279,4011373021,1044766835,1569914779,1573620417,3724736167,2492465525,2052077099,672448879,1789375645,675489733,1357401295,3272283437,211542795,3461820233,3185708313,1137346393,2776385657,2189071989,1043095525,3544978667,670170707,2154844487,1307086807,3745240539,3512062209,1494042027,1985563871,3771089617,4165819461,2665838339,3941136665,1698337393,3898912327,703492137,3842370277,3883997055,3425585979,4081957083,1940123725,267766833,3526422219,2324561633,1884876413,3734096847,903624407,211073671,4167187753,4187885513,4162787019,3239193173,2409223967,3170549637,4063516501,1246907219,1624219113,3733495627,3683821749,2038609239,1951392441,682515709,3478862989,1860499707,2056692035,926266939,2806987123,1111835771,3516091103,488186781,1567713533,3231984541,1512830175,4225354845,2549657725,1208708643,3865846381,3309885935,836534463,2206783185,2362423411,2572619747,584355937,2975015881,3377659319,1737466441,115858787,1618465733,1525718435,1795008671,860477247,886228237,4186387767,465006467,2818199889,586232997,163024949,4066168371,2867213369,4017038203,1770200241,517021755,865817329,442673237,1125757857,1281389335,1344558035,2163977317,183738033,3653051,1267302847,816155389,3293069987,1678737831,906588137,2777843547,922025455,239842239,2349205907,3764329307,2214438935,2183594841,3477949557,3688317259,285234517,753043921,3435548929,4025533267,2812820187,363894657,4239057643,924349835,650991253,1928308159,3547011889,482794509,1134111203,4237122149,2754240529,3658060271,2857145187,2304827795,930742785,723119553,3007869351,1495148683,3405262087,1800720465,2369318537,2494885491,4069740015,2766291961,48047783,85254415,2646860809,2813369711,1009809937,2459849371,3628190453,3346287459,2751592583,2103704789,795641321,2110512631,3545892171,3138530553,2789683463,2346998143,1018178111,1369829087,1692786175,793904575,2985793667,4131282273,2019904313,1110313621,3703119817,4258691065,190791751,2591374539,2263532619,2667421381,482552501,1361650041,1666513461,1610031659,1508157419,2999756045,2573768149,2705679175,3531169453,506944885,3302554999,2179544637,4125647633,1807790301,932967957,3761847005,3444062161,1078535495,2184100591,3388155219,2048398687,3273887805,1406352007,1353179573,1037278487,267301469,16765,281786161,2926066745,1028283721,3711091891,806385375,2297201861,1610688867,3963917687,2326884981,2278680603,3856518123,1148676313,4219790161,3513294205,725362329,2047499937,1053498437,2293061597,744748523,1453748151,3371222391,926199895,1680178615,3647008355,1791186617,1047725079,4044481453,3447402533,1385592877,346832477,942839787,2173969349,616095391,3844074803,2467194479,2523369083,1757133831,4248168173,3721172255,2723338657,3981340141,3088293367,266887985,1640525765,2921488975,1399114623,4268518211,2146877401,548258519,1876100009,2257962815,3545006021,1129909385,2336643727,3085167453,3564226209,2041062051,226130785,3829032405,3052681639,3035996649,1784243829,324404101,1946246227,89442891,28132943,383987467,2636499087,462599817,1024338985,1836423349,1132268765,3336037741,2283273917,3746935229,1929945981,1009115185,3668054389,3324561947,2683132389,2544459023,4028437303,81345711,1377782091,2214938289,1986302931,3307569155,553118649,1955926333,3869194555,3748071531,3847904519,2408721881,3321924823,1310662261,3708353801,2031946979,1647938265,2949324949,1086894595,941573589,2367816033,3012104527,3956275011,2725448269,782883379,2436146137,384927663,1258504083,3259184131,3389806141,4025640977,328134863,224653751,479358437,3513591215,1422242105,2130084431,1776653133,1596595249,3315681131,3747113167,625582653,87730065,1305437419,1793780187,1688183129,739921745,1934468891,4011219557,2760464681,893200585,1111556371,3115182597,1222610725,1294937385,1413367803,3303546007,1655546917,1978920293,3781623815,825458899,743372679,4099741807,200269413,2968649895,3758714967,2343507023,2472466387,934013665,4157192185,3696098603,2217264305,2424948197,1159711019,701532967,979371145,1976180213,678772195,691165307,2823768579,3984892653,2665820435,3640224137,3732951629,3130781951,1407948469,2415112643,3357279407,2809668977,3236083009,1676305147,2970141089,3051408761,3117572573,2736231711,1631566725,2670758985,743088107,3611907497,261585489,2715788667,1642709737,972800733,3216415373,1834828533,98000017,2113828923,3448236993,2525460215,2543051003,1838681633,432542307,2653909107,1015029965,4293514087,1345770521,1067393049,3891571605,1882029009,3122418053,2569835485,1033904737,3694227335,831634087,1450542339,1030747635,2172421549,372024555,3439299921,2643946401,1075554689,3625301677,2039269461,162841713,986520919,1883347599,3809123713,3454744127,221711709,2572066071,4163625287,148094273,2234399891,2659933401,3481091461,659722965,2653303747,3725646327,609655469,2982488099,114208425,3945602657,3743820939,1127681479,3546933231,3455756797,61787223,3370755913,1676038737,2787555513,942280845,1369765743,628163567,515478723,701882269,2555122565,2861961349,1645683943,3715640741,4244463327,1583367649,42739925,1070398183,2859251215,3341102039,1499584523,649013675,3050893065,3040204489,3785934005,252378231,2588226045,886401489,2803266837,3009498379,3104418515,699310899,2287779915,2169832323,4099543407,1160727907,612500407,3552720831,1943702235,282242287,2002241839,609856389,2064383245,1343414589,125949571,3710547955,254387611,2000137353,3894465833,3280678771,3872967925,2742591711,1149904375,3384991725,419162557,1118750145,3761857983,3628569407,1125432749,112266473,1371986451,3591864571,2702544433,2385168187,2591980813,3863245149,2540652651,184285215,610206337,3650991987,24612937,1352788741,3058499651,2035076571,2707383481,2110669337,1884682619,477001089,2548349025,688224213,637441955,1838523255,2065650555,1168257289,2604772155,4098965443,36821547,384466899,2104378123,3522431271,3968175301,870159481,406777903,3423267773,3774574487,2606487435,2862905345,331555539,1881380461,812206405,1347005309,345638495,2350420783,2707913769,2433285165,3840178787,1411362977,3968173777,844545613,3706195121,110750571,1664025301,2741199479,3520464915,984401067,614733387,2427710045,333450121,3658849077,3229705747,1867845063,956038801,671498359,2993855181,2182194663,1419994381,3007292809,395141877,1130107021,1363344685,83624111,1016145245,1563188577,195493047,1677825,2429417817,3266170361,548289519,2397117009,1552369349,3040321693,1460814339,1873559875,2515603617,91965589,3772412583,631105259,2711855933,4264726103,2837427655,1624749109,4051203811,465956501,1605552151,3530477755,1766478481,2389910845,697455233,1164372511,1737817719,1724820839,2329590673,508605813,1153000837,3887621031,4204208495,3625238677,980428461,2566621049,2843453707,4120357311,3087661621,2534034845,627969417,1547366967,569666005,894464515,879591411,15435535,1727015911,567460131,2475045843,1337257717,4021584217,865646247,1862265357,1667200527,272648039,3960472875,264504519,236318349,3252728793,2269122725,2131052455,866363325,1029293421,3501250615,172208017,3787169663,3840213061,1987406095,373610033,21657609,3222198573,248823171,2967874741,3615603571,2251959091,1424664515,4188823655,2750270437,1357233437,451094031,920121913,2606750197,2984178985,2763125663,2666652119,438467949,3461926439,675745261,1357093097,2387366945,891800873,3356400551,923638067,1573208359,1094244655,4214947777,3731724903,3988034539,3931890909,923738885,3267656485,4050739117,1245779031,4137599867,825524321,1842920233,2951215803,2801706715,2558331689,963133595,3949584179,1941784489,2410423617,1858230717,2576482751,1085354755,831286473,4198128429,221817177,49699453,2075068341,539196713,4193149151,2434437711,1736182939,18877143,3735546745,3797223623,1018427021,1258292163,3992411985,194214539,4283597633,2183652609,153889039,842784291,4168427325,3546535647,1068529803,1522159613,2111429433,1774714209,3368837933,3800287229,968845535,1165911997,1842155157,2977485353,1932402283,3637477253,515745181,885274581,1043193257,892593097,3786407437,3914382561,3013677335,325688009,2050051513,988163329,3717528705,1615735923,2890441999,3578598859,3084022137,1494769373,1325166211,2663105693,963228283,1246038101,4196822063,4035527579,3283497505,4002790029,2819308287,2035209007,638268039,2837615161,481195157,23605903,1607437479,857447099,1498138329,2112634881,559842275,3290758871,1490516865,2867708253,3744619003,1655841245,2630723695,2179834235,402986631,4127868679,482204777,4107387361,4145043965,1384427881,2241581175,3096689357,3939338507,1541466945,192244013,1229738209,827476741,297504821,821613137,532160155,1893835783,3990373147,287202625,3766264019,371405167,1619180393,652107173,3503706423,2792267427,2826008151,2970673611,3411571427,467615495,3718460545,97301627,3260890075,1996835891,4241368821,1113612835,3318434693,2781589467,3750160779,307190009,391810681,977270671,1033252047,1314401093,2122393815,1369488841,269238947,2498438453,3654830233,109504049,2188566517,1137562209,2108637875,2101639137,437966509,3624158947,13275527,4078467101,3413538367,3461205017,1435707589,811207437,1737219309,257278557,3343626541,979216697,3675339971,1219287095,1269262797,3692263981,2193281761,3077256825,3754287527,945966941,3192439099,2592517051,4285862627,1596701121,800104541,4109407173,3732285897,531758815,3738448991,1035664617,3207759437,2383400177,2941807801,3595206979,3043820867,141889641,1032364923,3584377201,1416368369,2194451241,1257870715,1204102743,3763896373,3528051785,3942873631,826753897,1033567595,2322849035,3166012885,828769635,552337809,1717250335,3941148765,1901702093,3055459203,2473874563,3126391227,627494199,2150312629,2449560693,2505071067,3460024087,3062653549,3130163553,3899435165,900895815,1596268161,2113280409,2819296783,1841861279,2333245101,1799035093,4108042391,2269231293,3955754831,2572717597,2228920887,768626347,3336377777,3703291675,2852141177,4101777605,56188047,3754685349,3337194001,241699267,3495504445,2380576589,2730404519,2478198543,2785079089,2270695617,2796844535,2444051015,98226095,1618554575,3018885929,1967181487,4056006897,3882011611,120999729,2122932047,1825619477,4235185703,273163665,4036664469,916371265,3994118671,3108682377,3642562829,89675133,3931424237,1670317169,1114442605,84509907,3018816735,804237929,564815291,972892903,470549269,1486792635,404116759,1647093505,1636345511,1383436701,2762688091,3902314103,2042566547,4037358587,3992477903,1302098365,1508874431,2165674847,2944320979,2884516685,2776094223,1585908045,4084469851,1222542561,149305037,1108873969,981725123,2884782813,2953940225,1346427035,3511489259,454405965,749221829,3622158095,744694315,542674295,2511327709,1241223831,592797465,3117856275,3209443931,629919777,4262296429,656602383,1745289601,2750690087,4115323693,92022481,433629133,3740324513,2492791813,3241032221,3253332645,3828128701,749030393,404693243,2746125505,412838017,2196388715,3756225175,3447245819,3046667973,748559949,1087875523,248161309,433894695,3908657753,1286109747,3371111227,3352833841,1107485213,3410706795,3115614647,4189107781,3230608825,4160975127,2851495387,1837919663,511014399,2979400093,4048666405,769446799,4240812659,356132689,2632680287,704537627,4234051531,2685971331,3013916983,58484651,3699003131,3789026167,682737437,2910478191,1024461577,3896827093,16702651,1548598053,4080659231,1601961631,3314150231,3787080631,2343852237,3979510791,2407178975,3160107445,360287317,3740036379,1945090969,2147858155,4146889115,2331092873,4281244743,1293336025,269114047,399244153,1357583049,2032055621,3473884359,4084011177,2103543231,2375303309,1733439,3364122315,1854306795,1051635107,1040845345,85941759,1314149535,2189425803,2694680129,3353796973,114975561,3953955527,2396586327,1223131563,1458727063,1152450495,3227957625,2551929667,738532191,55071283,2165101977,1906029477,2771358093,3590149721,3945831541,3295707033,3049897013,3479427701,2761679703,4134206163,3917083309,1160508737,1223877511,1110973217,1904047907,3826849455,723579341,2145591679,413965335,3963353165,1428898315,2331856257,4226537749,955888783,2445113127,769273303,1324865387,1902124019,1556834897,783375637,2119591755,1519906655,2900669973,3681466117,1102207861,613597611,518591989,1486936403,2820425535,3632926967,1348499671,3986544159,357910719,2451259439,991124031,1938439691,2028978453,3295529311,62923359,990957195,3429394333,3664453351,2931458397,1451465711,3664958957,2839243851,2084784223,625268315,3394585887,2754453413,2941034365,3480970009,2913446495,3668106671,4203265521,661576541,3741584521,2194909799,374920433,570713939,1327222077,2856307203,1105732589,4019126285,2504856063,4141419153,591754713,2772192587,435621203,2861306651,3527076539,436815991,1467272097,3034916231,805527679,766807071,2824577103,393886345,1503217167,1573319267,2958275411,1193454139,886467999,3921100407,4251365413,1622610113,2460836391,3037166417,4264665429,1817679737,3935961637,620987677,169379725,3496706253,1104527175,939602363,3597159003,1491749883,2116205309,438483555,3724216481,2348037511,1306966911,1730148467,1676721295,1374405937,1306492833,2352254109,3455852793,1675191995,1441264601,4013594947,4028938765,4214450251,3959740009,832127539,1154055515,138757707,4228525007,4290962931,1418164569,2318413583,1633815119,1804811297,2404455257,332251959,701209519,4133115197,2761086923,2761287291,1833904973,1755596273,4176234631,1619941475,558710465,1448297377,1954376947,3598467817,2014150311,3187049769,2208360915,3109527757,670995313,3129095647,3131008199,915531311,2761913675,3771606273,4259322265,2209435563,3991267517,2433977333,2588544481,1943388047,3591619159,2872872243,341485759,1274863535,3334587079,3671801447,1876856343,2084766471,326910451,1120797737,3815998375,3033071423,4159577975,844398193,1228507181,1612425615,3088670265,2306445377,2347639695,3210807987,2080772499,1919699751,599419335,2742475721,3495427739,1091378847,3293952955,3633879125,171550001,1317829339,3906349515,1146259327,2252212105,1382103519,1830734687,12206999,3299586181,3822228039,360851921,344433925,3580049263,1691158401,3500678015,3433421699,2632917009,388156987,3994145023,3551580441,4252003975,3764987059,384374917,558436649,1141239159,3777594409,1822708961,2562783525,2770697249,1073279201,4035880507,625223813,2646640773,3410191953,3052599741,1659536963,320146711,3406736495,811291957,3157746949,3637103985,2832164493,3361098549,2573479161,2143625153,1722301205,2931774975,2477224863,3600308505,2885822469,3247569441,1455239541,2667210357,1230839427,2155778491,4119990153,1211804409,61810721,3765686799,3554970509,1099334735,3864576457,3441109737,2996752855,3638761347,622676569,2784783805,1602824723,640268299,2096246629,397727,2389647201,561357819,2992703115,4294257871,961646327,427907373,2063984661,3234347889,2578914365,3298785607,3251882703,933789977,397667969,636462325,2553751021,1285257811,1937524757,3831551891,2448009901,2210713687,3997861115,1583429275,1078488107,1387650475,569143711,706203845,2173406399,4039496623,1271743309,2432556225,178818795,3225365865,1941892287,4222184603,807007959,4171036561,155324865,3499875403,2828823697,3046914999,605358637,3780076673,592447069,1523717997,2533385557,2600287883,1746249937,1711188063,836791023,2223819811,934187895,2790508501,3328509927,317355545,3740249767,1236535791,3405287771,2232391453,3263854287,276739447,4005290427,1893824533,3801294397,716448935,2563942269,770871187,2410698011,2175003381,815202039,155018419,2644404775,189511919,2556074585,1682692313,2945057701,2381701457,161224525,3871213261,3316724921,4110222521,255970557,2834907011,2209958341,4187662775,419229453,2243071217,2370021487,1424464259,823121063,106068673,284776907,1651927239,1272534263,2841218221,908282461,1189575957,130372535,737892611,2190552105,149601373,1794425827,3949520021,863480983,4125378955,1587086449,2415069409,2630645569,866770553,3578607123,3222915185,3702986467,2017477615,3274473275,2656411709,126588839,1569823349,36956407,2651058919,356560483,1232679457,3016391643,2995389625,2201791207,66627751,3121131423,2420281545,36702147,2672678393,2937807305,783380117,2194887115,4288637739,993368271,1002675725,2814232519,2626122111,2150423239,13615669,1205299107,2396349651,1540285325,1807593143,1914300745,52638667,4229797805,4208042447,3637960531,48263939,3718188307,4111732149,4153451883,962385005,4252933931,2214888375,1147398333,4215616771,2090605179,3968795339,2701203559,1323935339,3450676459,575892337,2461211383,749722373,3444866515,1712411291,4215714843,3738901283,47401673,2110985527,2903920655,2481103669,71924243,1944959293,4229746917,3352767831,4293022437,1672543559,4173640983,978172479,3305037221,948576851,4107523529,2138652247,4042015943,664281609,1961022163,3615463485,4192500983,130612723,479765033,1757315599,3008175655,2348232717,292826859,3803484389,3163906127,4075193575,4229961707,2667776067,2148792809,2675749717,3017942245,3286553675,3828231691,2479983323,2717105491,2299734235,1222625745,1547378525,763921311,1568249017,3641929541,2330905599,1133730625,2135714997,1920295427,2021011279,2535222007,3400731975,2972539373,409695009,911460787,3068093511,70324419,826521089,1415730833,69318277,1096161671,2074497337,3827234367,2897828031,3161587157,3754970431,3833599881,2508839479,2371215161,11706707,3481113125,1023829813,1868704133,2509526409,1031545789,2702093945,3403750959,2172995933,1435761855,1723256099,1800809257,3861645681,1428197739,3442177307,3759532669,3201722655,4002420159,897870491,2289255221,1195496501,852707781,3448799289,3386034499,765195999,1517093763,2869034363,262746009,745811837,2144997373,3310366275,319674255,4056103091,1203776875,2582000191,3622655661,517351489,2112689373,1475689319,2769245683,2446613203,211246871,2783192859,633599065,1675580435,3674808387,874889395,2593031209,42414251,4186729853,1919478575,1177081597,591061421,4004935825,228996013,445311873,2523640169,2018308939,66666567,3773511935,1928045147,3421536499,446856133,2708214225,3188081863,2374895597,1739252443,68423343,3234875109,2849966317,1908643937,3762914373,4203446961,3711038621,4206043779,111118513,3553059201,3335719531,1230085741,2373479771,3713268625,3031015361,3963082293,1171319905,2538551739,3528962877,2075727699,3031092031,956707689,3323564387,3097010645,749291335,495378143,2173850435,2912475087,226554297,2357064001,2691329051,2866803849,1429202857,3155326357,1608919887,2474591,2935762097,769307613,1901513557,4181701945,3314774699,1397612425,495912895,2571492711,3117098355,3355984373,2518869009,3433801405,424701163,4011788013,3724570085,3996092645,1925525043,4015821511,2796094267,2719198621,3119231793,557971193,1908254755,1516899793,3903947867,3731434331,3399358229,1358826821,1461295155,1364699799,1384188639,2515608175,168571895,2804409325,736457725,3844226867,727966833,2871725725,2546794203,326134623,966358423,2314693553,3535780319,692358455,1402170545,4089791737,473167389,2539862535,4084674779,371800163,3962910871,2585197645,1527690217,575010393,523280457,2976606787,51245403,2288046227,2350770813,933391,2802617461,685370535,4215283337,781547235,1454410399,1616722645,2294409477,1923731213,3931691759,1871592129,3803434947,2332934433,872605311,2859137067,1422616603,4129305023,3148001915,3061074719,2364571507,20963573,147470109,334010131,186035265,4253492923,3019932331,2374190725,2777370621,1563492761,1012946241,3632103171,387862181,3334307875,3274187113,2141854269,2023824875,2578689745,3818564561,3213286585,788896145,413489243,256642215,1238561135,3085506027,664704839,484314185,905501971,1702520761,1194334305,2794516079,1964396669,201243711,2163807205,1619632943,3963147729,2271102757,1049711927,3077697437,2569718823,3368133797,555808065,4207268105,3508496419,1693351613,1707286453,3981908457,4050045791,2477950831,2916750799,3368969177,1711137843,4287710777,2593787113,4156958191,4058328739,4250504459,37458117,2493364301,4272903449,2835128469,1637035653,97751413,2230508789,1686691497,1439866485,1990295805,1696325769,154318817,3771095843,4270459843,420148073,502448381,744256269,1770369761,3366144395,1479667003,902703967,1921107767,2789107777,1261378129,23667725,2646479833,705273373,3714832671,3548132719,2140715143,58403369,2332896557,236023379,2590135297,2910428795,194263005,803198401,273337371,2661173917,2855607403,2229095871,3709582435,1206762147,1215859167,3785619017,3548309503,816956537,3873062541,37835529,246593197,4143407369,3942929967,1773593049,1705370989,1853476067,4269458787,775269057,3311255103,2373304569,768648611,3710568825,605149701,268489321,2784376153,3341352147,1408182385,2051571561,765806301,3184504889,2386235695,3353718593,3092610195,4100339477,1655374515,3376327173,822925089,1107300949,313781747,3804968897,2344228319,1710386377,247756303,2216893441,486804243,4101201131,3252291411,3507978039,1570873541,507664175,2506760147,1783620589,2734511303,2781440527,1246926199,1943215973,699571441,2371742015,276607297,1784245377,350421337,1131267691,3690856199,7526157,1938085979,379108163,2234415345,2919668779,871851509,3074888735,2608504543,2404701149,169991509,894058059,2638220007,3616298493,1046611263,2504445117,1529617025,2894101391,657490793,3791894589,1647665757,2664250287,3020550465,4173234275,2732565711,146646841,3677214031,2651842457,640581767,3069736011,1906018155,2581069239,861047279,1876821473,1498706381,3069950257,1211883383,1389126739,3905876289,1782684533,4182087287,1201283105,3618880741,1496780459,765750261,2242640609,3722727419,3091176241,1474711069,3507667109,640040325,2559654905,1727588437,1599970025,4200966541,677325327,2143458595,3217928193,1490990509,2238308373,3925280965,1499559721,232166461,2191423881,1916638723,692329267,911607829,1244461111,3462154897,220471573,3203936789,2560664651,1518520283,1074752239,3023426409,969617555,1256350255,1419535287,3881234539,4240619801,1409735577,2386265741,3858701715,3488568705,1775711347,2947867123,2355016777,2643373635,39011115,2824797923,4105208085,1877690585,3220969883,1073066811,466241777,2105218589,468274157,1903690897,2121549679,66996971,736677375,3240917123,1318880559,99367585,3623707829,1021269889,1793734405,918725055,604594261,3818111123,4182288707,291581751,56823409,1548312601,3578034761,2193161639,1058366371,2504049749,3474601637,3254400641,303101003,387363543,3543633597,3833382981,3158368473,1198155971,2600747131,874896485,2712192839,1337170657,2558366797,1553193751,4011144225,1494359757,3030684687,2700411669,899541991,317384663,4229635993,1488468163,2794912091,30235765,1366378469,3827791565,3672720229,138956241,3270318651,1549122845,15936493,1556682429,2515813255,3615351455,2309612773,4042456739,3777772687,524060013,3193702597,2353291467,3710859523,1195943693,4073696431,542298969,498190921,2203570047,4193787867,284435641,211236871,2615122859,1969588517,1561287167,2598233529,1578460611,3469498139,3379255635,2796945689,4144146293,3477123753,2693931313,3653348343,973182583,1044233735,1200037667,4161640745,1153635231,1664979107,1591947745,2514492695,2895536005,3294211821,3689672693,1591177285,2450273357,1597913033,3988840349,295270403,1922455457,3964897137,1608631955,3753136055,3068013507,3020664485,1794601121,2600718985,401846663,2148295679,2910420395,53084205,3128020383,2238915327,1241454961,182432081,3824321551,1186769753,211142141,1022995749,735492367,504356843,2755006045,3639185801,3461507653,2227143547,961644025,389217659,346022857,220458329,2981344881,2374979969,3157292647,296617565,3089370721,1194107487,3277353247,3815460879,2589310739,1936984371,3339218977,4210699841,1056141255,3761230783,1677153595,50137449,846532525,2740486753,131613621,121988543,1562059769,2698453461,2347678487,3862785131,3399064713,720670703,504753047,824072085,3204993545,3141693567,115884939,2058002397,1474684603,3062853047,2188159145,2880795593,365243095,1132451345,2109692507,2646969985,353323449,2662423841,2388243601,2740856383,2049017737,793359273,2410837541,225116797,3966805265,3613768193,1469532103,2364131427,1214473601,1973247725,2932053907,2870267693,3811454143,3967575491,3674054693,1092456219,4221474983,1765326501,208452161,3057142123,693939945,2212469211,3438181925,1033656805,3822201505,4209862277,4159072283,935167337,2072121019,2543163387,3727519521,2027655969,2543377193,3025989669,1100655435,291777593,3348339903,2887280539,1983548167,4252890841,1490674745,1226230119,1996550227,3735181267,1949602171,658218877,3143900495,2847985483,2976505251,2639697145,2672753095,4193323819,1075115493,538701799,170096847,2664473825,2482586337,3516288849,3811703803,3868643817,3081752553,2004576731,1197680587,3200902831,3108540073,1250859501,3625713277,367096073,2210681533,3457448837,2730099739,1650728377,2598097099,3580448895,4112806131,729030887,3575412127,1064224941,2184787977,2056149839,403513355,95617065,718260305,2942866801,4213950803,4155452061,219638299,2084002553,372642507,940317303,2728253701,689138769,3123482765,3284580893,736455675,3809772517,1474291073,743761631,2046923483,4249937941,3400891973,1366658465,4238717043,3789820223,1143534747,3704836279,3042496841,3658788423,2210293969,1238627983,4209020363,2893925567,1997384119,570534935,2613669143,3306787469,300223929,3571988353,3650397439,2916946583,2364543571,3846410515,3068800417,3361358973,2655458035,1278059097,1207822791,1862233699,1135124521,4088088599,1913298081,380733995,3789970005,3660920821,3689768803,3206498055,2658189373,4233983923,1549683675,851871715,2281939909,2801099243,938484373,1986970249,1638280899,3846731759,4172981031,2771261097,1959937949,2572947963,1805714955,412366087,2854595793,2406835777,1686945953,1421541183,3234590259,2357459661,751252083,3384898721,3151011623,2105629547,3080277969,2991047207,2233215879,4235080187,2794723547,1156344051,4242443907,2002714061,4251524249,4292166765,176166137,1591815799,296876273,3142508783,932318369,1434156077,504749017,756339875,2996072985,802120845,3637690149,4093888253,603835097,3943743657,2564378997,3815991389,2915657721,2177476407,3724644375,949717381,1801574769,3842703983,902659209,1168860061,4145626571,2586352335,3754695871,3514037255,328901797,229611607,2201665643,2251240897,2238879839,645008145,154459765,1845041585,4245040515,2694231777,113312203,1767701385,1468421903,884869203,2819939799,4059096603,4271092825,2468741959,2762061679,1964142207,219468171,3519628551,4107500495,1751519809,87613593,3642859809,786050699,4129685849,958609909,934437575,2691912967,4090745473,3617706459,3235459355,4079454251,2824699241,2446659711,992906827,1837121005,4267838569,3609036189,3543119461,3782233817,2487827925,1417345191,1432029419,3416713657,993729225,2774262309,861700505,4265656267,1290824827,1013082201,1622215597,125173273,3548209351,3428669167,66522977,1360194805,2978165773,483319341,1365028039,2605951025,2437397063,4229371769,1342622689,3996355447,2047470963,566532419,4062859435,3088500839,3753869889,2516659663,661061535,3675813267,584038379,1932785869,1494472567,631715063,75929879,548206841,1007547863,3095877299,3175981583,868952455,1595128391,137035195,1048069587,1244692821,3061537573,1553824097,1720467565,2178558553,437435727,3293240461,248927055,418885835,762850785,755787711,2305787225,4170980913,3515016223,3897515091,2989950449,979873349,1826788253,2403967465,723866403,2675275419,3636350347,3050672509,3628287091,675515031,1782584781,2505555423,3010660791,1166240529,3068825187,3777668363,3065653839,2016430055,2848001531,3246223987,317030633,2574421077,794538189,750042283,231659297,2257453121,3568513551,1083975047,3412337881,464505991,2996634345,1646963777,3750974309,1095286837,256064181,113478285,264074265,1594973959,1836463865,1813221177,2015387715,2509262327,888086909,1065349719,3909062647,3796195911,925540613,3484527923,2581764977,3964381257,1528171383,72032767,3768922161,2097124821,1875268789,1172550157,1740560633,580336203,4134823247,1403512215,869435663,1126470659,376550667,2200253013,4278972251,1754268627,3337324779,2439685113,4029922473,3567761431,1327996089,2980225005,733093213,3131448505,4020786959,351032923,2820259005,834057257,3522054883,1937189479,2491501839,3035275673,2551702079,1208427969,3443525757,653128055,3481801021,3995363297,2552275089,2249072451,153546269,3671783489,1575036237,1750619143,2129989307,177904065,736400637,2884748851,2383140891,2878955293,3795059347,3298145935,1090849987,2995337523,1326112893,1394120891,1943243073,1155041141,3819272007,2218429625,535644967,333528951,688777593,1348165027,2657149745,3940825303,760243553,4180679721,3314125107,3364821563,721666049,53664093,4284263411,488481573,2227315383,3849691677,2380715329,767240405,1517687053,4250524805,379413339,3068541083,3297699729,2181400333,954591953,2124127787,447585187,2076522921,3511486303,404724473,3271008115,252042411,1239066599,2990904887,4136210933,3251514347,3332765273,3117479063,1164609141,1419890835,1266995187,4235248357,1326189443,2680696741,263228733,269019517,3105445737,783961877,3382592847,3050892951,3038288491,1648526677,4248830845,1973798677,3601969583,738789357,82292951,118175595,1902352143,1095947671,2772766631,1493644123,3887925931,738728207,3349512195,1115155713,3479781475,117624733,1233949097,2880394653,2216579103,3793660065,1255249831,104578295,1005797625,3744398291,2241301955,2698806111,3979699743,1287927945,3864793955,2801631329,1291319187,731856133,3814681415,2373761173,4147824745,876357107,1491063029,3457152013,2036346065,2568932669,3040145401,2792841989,3892737097,4290583877,3637338579,2480018557,3309283329,3593437303,3365647393,1716488977,4029906741,3303353707,2718528111,439904811,1841462309,4217690899,2590736123,123609495,3035596269,3644991757,2257962383,3537745397,3654653343,1431481113,2791269303,3230407259,773255365,3826872011,1102678033,4220811121,3492699749,2486691151,3786421043,4143058603,2376187099,1970690087,2895504981,2772791453,1910827477,1806965507,4250524375,372186329,1863268245,1342869967,3857389499,2908990863,1796743645,4250381501,2265870305,3302204337,580935697,1325617023,1649968389,2709880665,1131167885,2013416757,3743109573,2056654999,303802887,3593993343,4121077085,2300001357,1417177905,2915420911,2492378031,581565441,3319789843,4082759047,2533830791,1493401133,4098960295,4245266405,2195797713,2413189149,1093886807,2495563735,2584085041,8023965,1714810447,1588656795,3038070867,2285887403,427154197,2290257511,861115355,3020974805,2715182067,37518125,3501918757,2811736023,3617186779,3091132183,734228263,733397385,3948700015,4261509317,312512881,3953974505,2715549573,1919224173,1196314477,1715528531,772592701,1279412751,2483849099,3264693313,1493347547,3198340393,2991317547,2481852965,4075407527,3530885677,32488947,580902697,770986023,45779369,614725963,2302934877,3476208311,192999501,1042323143,3448456275,1915965495,2262288153,3226517789,4122409779,3223752945,603349611,79147749,3091340403,4233781803,2447620129,4249750271,246722283,2017988477,3270596321,1920955241,225603295,3553442563,1188950077,2496109257,3162738707,1634234811,268640153,1024442283,3572552835,252744531,154695557,1513030435,3296157371,2028793191,181830877,2309820511,3238942011,2482911527,391822591,1177442041,2354076435,4018914817,3245680681,4070588573,4143104385,3145645173,2106017571,1011862749,2601722303,84743113,2643342683,3813768145,4204301459,892717331,1579440981,2766707553,2737935233,197889921,1631233497,1365163283,584029639,1785892689,2266990357,652081831,3077783429,4014986367,1644730941,583438009,432301867,2907801321,3278947721,549014339,1694264867,4171444549,2717411887,3154364513,2623076955,2510093875,1979012263,1032396311,4111915317,2936989165,4212770313,1494825807,2273652449,952712431,599772591,89714725,301879687,1335542001,955349169,1965755217,1559523477,3020666757,1832786625,139390613,1980874267,2262326481,3870696485,3221205277,734366475,3056326469,4165112343,3666207995,2356989047,1431577173,110782429,2199462707,3881201191,3680139965,288407667,2544568443,1572491949,1938443667,2095803085,1135688307,678738019,116769275,4036135667,618730639,890047705,3955677033,1265166611,3567142583,3811919635,3201164947,3218956391,1592045119,4151057513,3669881355,3965608451,678784471,897488039,156351751,3578879229,3501233433,4178397437,3610483565,2099364129,856612699,359279411,3980029413,2533724341,3999263277,3674729539,3844658353,3684984741,110179313,652826683,2711609111,116388749,1935602479,1588596603,2026423923,3311216541,1725193035,4290121551,161992791,3898558041,3338941923,3849220557,3052536077,589536115,4138921647,1565844311,1880741445,2957166375,4028722557,580642395,691057603,1013587451,1524017759,3276518197,2665677411,1236419769,1455306017,3784472489,1458482583,1338442429,2458202331,1716192937,3349329755,2343853927,4007914621,3048980151,954629949,2762726559,253878485,2033191259,1085715755,2603646179,2354555987,3488810693,1547836369,4163938125,1110995245,2274272503,2784025421,1741566717,309720815,4272361477,2316139653,2070579255,2400539603,3241331885,3994818199,1980747591,133282949,2408580475,945314181,811436367,1289878525,2288453663,608613077,2642874931,247227575,1920496533,1106032527,470249663,746281887,1455193135,1887264715,924615621,823089261,3866539753,2078487257,2166343103,1290797689,556973835,2325528025,947157581,1728689109,2919095153,4115821209,4158806599,764783643,3176561059,2018270999,3723976281,2605963405,2645467723,874609779,2188492391,4186693821,1313888751,2101396409,653404307,3829801091,3087085359,1438733999,136472779,185478463,3485256297,1938644913,1183177313,4257512471,1856998863,3347549043,2480198401,2036954143,4198965027,1397617881,587611887,1863192709,73336415,4204497627,4189712907,516059625,1875167595,3766749893,4242522191,3318433249,2757320159,3877794153,2252627121,4062310137,2446383941,653007731,1459515553,1519700043,3723109383,920910601,2977327531,3574855223,294274001,2355796219,2858553447,203649851,3949096539,2335953597,76087131,3191141205,2253649063,4058220155,2425533171,2401434449,1101139431,4131331071,2840052299,2787467877,3764349887,2560326995,138503185,4245741047,1583171219,1036308209,1139708299,3818234153,1955086623,2641090467,320512185,959323425,41599105,3371472913,841755855,4063372649,3124153949,1680268499,862721449,4244792899,2827516959,2559405903,1837579117,3377392365,1545737857,3253985293,1912281755,479212089,1053920379,794706203,3573853581,639546083,2842864199,2802430943,1845529803,3860585853,795537719,369273817,157319295,2660522061,489798199,2881012095,4003992209,1549511077,2245984423,4087634495,2871106741,733464703,785146347,1815143667,4261906087,2686058977,192016011,1692675889,3235295067,1318265835,2652603199,541470679,3756990067,3417883781,3480134117,1749511533,694257213,3249825193,712957759,4017289353,1696310997,4201013107,1459960089,401082007,2181624169,421636311,4040427977,4040108105,2958986695,263102445,2441464395,3869543989,1031074181,3365712877,2817078565,3214976999,3429880479,3245174585,4154567689,2535867271,1360782141,4259587337,2369533373,1810666849,2034469959,1101990185,1250084373,3483038863,3324937321,402108619,2256022877,1005239113,2947421695,3458642969,1325039793,538398367,3660249811,1002038321,691318079,1096440289,2462262769,1240497699,1273598823,3553408965,624268491,3770413095,1385448795,2220213597,454091313,4050800253,2273291783,3480933557,2300797731,1916933841,1357410199,3421932965,2815292901,3268093209,2800824797,620837745,1944439895,4090159319,2356150769,227540709,1755821309,3663447389,3204124239,1416169507,3147144901,1542142303,2953051331,3586654753,1040479187,2521858841,2144300301,184611759,1803464051,1236128205,849957163,168835503,2939901687,1623920039,3001926203,392908009,2240193191,1243678739,3197730575,1332041009,2243718741,368055473,1155448157,2070055331,2184883523,3661991461,209178813,2385080405,1116628739,2467125693,1367282781,1846694173,1955315973,2200808623,732207639,1132508169,3064733475,3727741483,1463204009,3382037919,2314152643,3034640537,466905915,382484073,3138759893,2349233549,4228908401,2144731301,3133461465,3492867327,1008207303,1294183497,1627674069,1671399003,2116957467,195101179,2005486937,3610610947,4240273403,4177758979,1469854547,3488480441,292258299,2837631057,748359229,2009341777,3974397417,2366048037,3362166813,3347923033,175913743,1644797135,1695960567,2606303391,4064645131,3035922453,537231657,1231224017,29648033,78301333,1750528573,607779317,1514772493,2510155119,3008340171,818285835,444770263,2010735487,1628677623,1358261905,556686531,1791776991,2380206309,802075853,2881509605,3775708191,185814093,536255119,1998419027,784364515,1559795125,3291287399,1783552373,1588004991,673135627,446647399,3494989181,2310469129,1255362855,2004172663,2996444299,2747827949,3256010561,1591222679,3213210315,3801993549,3877162011,218151115,2858704829,2747927125,627894299,284858741,3027311277,1838084621,3283463505,3431352029,2207711671,787618437,413887357,2652776919,3461182719,1060945103,2895125533,690376211,2446333989,4108431761,223438295,1526025915,2667857737,3521420499,4159999473,3633547785,3192653209,1896096527,3331991909,3004452197,4192583521,1517828889,2339395163,2083912071,3146878827,1365203879,1266326611,1588426113,3455965787,3574282153,3547588393,1582162649,1265141395,3143337271,1971814303,315366823,380570171,1036580037,1413354201,3074937193,3422938149,2529551213,2580977685,3617266495,135951701,17655105,376623255,3420239529,123517813,1494696895,107028465,3531099169,3620648991,1150987151,108371487,333466159,3928399743,2377254039,2722881491,592718473,1790237731,2279667253,3259275497,630427209,4200771465,1693650289,2432166691,2221855445,2278826885,2020112403,312714957,3055298543,4068629237,1277315291,1591577231,582231191,1624148211,2541845713,3056209073,2192037771,3644353365,118442627,2095391673,2811021411,196637483,2056344501,3675197589,3121240115,4247067989,2410248943,3217452093,2079112397,4083136495,287664739,2943079429,3492622305,1185089843,2041665829,1783893043,3018678387,2773990387,586474745,4226083585,1912689023,3029198071,3484660321,512010869,2547202207,2888490557,845484223,2301544215,1578188547,3191885785,1882903241,635766101,3737216135,1789890295,735277695,1191331833,3871576703,835160027,581473803,1779629977,88804829,2189126791,1964152739,396479495,2136616277,4183206505,2832110855,2459604683,3810686531,3951222489,3707056895,1709684307,1332967695,638661167,854982869,3031497659,3479130191,2056396427,252950577,3617710679,3306384895,2124097299,4230140665,1380555879,1589352971,1853799017,1107344849,1051609047,602854925,354894735,3301223879,1282247267,2878919277,3189738435,152130143,1345790277,1399432141,1015108649,1320988781,1172516387,1172988243,513537447,2434594889,82906291,1836646387,585901137,3175388517,3786194075,328407427,510669605,1479414629,956021443,379762453,346165493,2617741581,3032776231,3493253325,3200708395,4135621515,1935100609,1743602101,158681351,4077760783,132386329,223990017,2208882981,3293956431,3692300257,2802972493,2357426065,186604111,929185763,324054563,366528355,1258979695,2662860427,1136009915,1789036381,3563414273,1279755581,3950825615,1331762871,1864020669,1103958253,4262632191,2004787023,437090937,1793322225,2581150383,2224834487,807978251,3298865029,291760963,3068839493,4018109305,2592342379,1350150323,1664281265,2748219133,1240705461,470487463,448019193,780927175,3917963861,3075044319,928437537,633522063,381407821,2230061705,2762485297,493955345,4030688213,3552651729,782304921,1303937119,2348041851,1379909291,3607050337,231675955,2537424127,1757057169,2959709939,3828729765,2261178453,1755659065,936612481,590852463,492978719,501436913,924382769,1204512991,2068999921,1626476829,3024222793,1469541561,2523092033,1395721775,3079496697,2745110585,534946753,1483548135,1708380081,887677783,2779103625,625319931,4262095999,1582942667,1490002039,2804962259,1439684875,3232943829,455714415,1265504509,656259681,280464381,2185746755,990462509,3705141319,3874336827,4274891155,1882764859,2604947121,2744651711,1412586023,3049071429,2488739295,3849838899,560108189,3465008175,930874685,2939962853,2651937001,2229582775,3303043375,1797745481,3908369977,744425809,324861247,1039564461,32960841,4217057861,541201045,3520218723,1141619417,1578656027,2458887557,347884437,1443262331,3229704705,1850332169,2969572629,2087236129],"expected":[2555283159,973759307,1312704697,2010189883,4180305627,2689709283,356969761,3985456493,827440579,1612148481,1582773671,2249898729,827887797,3287587591,1755333939,3278967907,3853242729,3003928659,353069993,3127134837,4278681545,368949887,3053228059,3231253583,748632167,2980104759,4035479279,2526716935,872962719,3612636401,2018219845,1776381651,2352757169,1519013129,316880699,1272201609,2617400691,2348802267,1375184963,2415406525,3043994905,287759095,3686420137,4240933917,2158270049,4092905287,3096908043,3229019743,3743294559,2127092361,2760592849,1137716313,1376700373,2901616745,2655455081,3061485719,3366888499,1781995133,462189239,882177845,1903677021,638086221,3564924697,2251075919,1370654141,2042039351,1089948945,1061176795,1646072699,3888165143,411934231,3562544187,1124631233,1641060579,619721135,1097244525,2373937909,3246113245,365163727,3394772485,3965141383,4215528087,4135734277,3409271325,532956397,2262156959,2368939689,1125015663,2612459793,3510465741,3878254333,3930067893,458818865,28203529,2040120543,3760499931,2812848415,3873901163,3633281765,232596735,660392251,3738732787,1464854809,816975111,2228242165,997804261,2321364039,165366479,596316075,968884119,929809907,1864413437,223730927,509268291,2211244215,4194449615,3681410105,3164928361,358968521,1518801917,853309923,1713821391,4060352359,3310984819,3497337121,2639648479,1952704529,1619104787,2739662789,429185091,2199608003,1919054829,3488988957,34037159,1024997245,1075741487,478595991,1083074699,179198547,1552735355,4029359937,999382629,2610380837,3610244953,1986196931,27933095,317689845,1676811765,4090815623,3736445949,242348603,2683287579,4153105769,1431154783,1351191817,3576420457,1610876767,1385401333,3579554949,3234152759,1436784341,911965565,2408013081,3539814429,2780294695,1745693435,3075164601,2080259169,4176687417,3909012045,3012205309,874530057,2977749779,2782297627,2523590027,1085746697,25883017,643960249,386812739,3320120863,1832984785,4272900887,3138831317,2407642385,4241661519,1685004109,3117818893,4146092461,1936953911,3521715635,1587149169,3577549069,3956588171,178858679,1952793507,1401285581,2813075819,2294794435,1010744565,985642871,4140889165,452023717,466630167,145208203,4010953483,2411941939,1669792285,3955120147,2885868851,4028770339,703218553,1867209303,66117933,2849957087,815684665,1145565685,1291348573,2633217997,3580144779,3792559009,1982485267,3738664861,1144889665,3711280901,2253182275,2447792503,1731965833,810118173,1879009145,2876006345,2942281867,3084243669,4167490827,267774057,3652538069,3532389775,2893173445,1870994115,2854880341,1534544117,235277129,513344837,4247405349,3997436445,1851733749,761088387,920906199,218413517,1430183271,2177877507,2493015107,2311772307,4127244113,909060467,57500889,1359420327,1997247195,893939727,1446988183,1047794235,3157613501,761879913,109353795,1487436765,894994361,3679816023,81561811,3875961199,819203077,736829243,2131394481,2876576081,1943858001,2013100177,1834704457,146741385,2391308233,377102611,331590871,205164413,2418384951,3154171491,3205326435,3673865225,3519502433,4064614195,1225273497,3350176599,385911195,2898535755,3393800311,343658051,1757370709,3205413527,2385830653,232717997,3553071427,3416530169,4005838069,486846991,2132302071,3901308441,3269703891,3828920047,2425889615,468571535,49957447,3541332871,477810945,706659417,3175137619,2857937733,1688716753,3154330719,1298040411,4106233811,3338689945,1515835807,3956662413,2919099331,326396391,98765781,3523165145,208023527,1339752077,538782037,2503166023,3709110987,2831368977,719481543,2584735647,464485805,2173379929,3285454677,861566009,931232169,30262865,3793382857,3274775937,989534721,718148645,1016964357,1081434973,4116251245,1202548867,1728157493,1303840397,1903811799,1948089883,2371790427,1285888533,2937357241,375040285,2458042841,3700134639,123429957,1187874115,3211469747,4043495823,3138143903,3616485995,285093585,2794143829,4059637973,655735843,514977143,2809002961,2154511831,3056758935,3100153501,3456582895,2254017255,3441440975,2656599131,3703066661,1029535019,1575402363,769729071,2860026961,2056817011,1528863219,1193991423,1184496321,641432303,4271520087,3770272247,64896145,2021156859,573584499,3587357789,4281215411,3055986057,828904369,1853055787,689992315,1204024627,3899324823,2883071907,3309071549,1825349817,609958907,2824058803,3612971949,785692909,3645624845,4124050909,511621601,2683092403,2529087101,3773450763,1770289845,1450151537,518436129,3178832579,3024188871,1057129353,3782677237,3772152319,3526517441,3161458197,1916306213,1696199137,2038894763,2703351995,1528689535,1655920721,18646081,1292424621,3857687947,693539433,3385771787,338462619,824155743,127784213,2604130901,256589129,221864105,1281085679,446657353,3055267597,3788774171,7813401,1434283215,2912703051,1391187355,3842551031,172028759,575875015,878784455,356594791,1142091205,1350831803,353602761,2045988691,1866603775,3300683109,2210571115,1231179687,147635461,3719734831,1416602983,1138213521,761906895,1194076991,3422439533,1864557189,2982075117,875196361,3784179235,850894039,2031369645,884126123,3673255739,989857163,3105045123,3196304147,349405025,3149491835,3352882363,1124522411,3111014757,2706411155,75487681,3678198965,3567234641,1697932201,3267780501,4107575593,3238700955,4261885325,1290218211,1910877027,417017907,2561252507,3709180369,3721181657,305013939,590041275,681775905,3101715695,336802697,4011859891,1353369897,3539035249,209642041,2065713233,3808382507,1815774865,4285762535,2733387261,3727618285,2631592759,1442226825,2019097339,1231199741,1729447127,537272189,1299567383,1662131641,3062528301,2085940641,1612541063,621580939,3985933403,2779879505,4293321243,335637251,929991181,1147272043,3764862647,1653890203,2746648603,2733883819,1503819155,2699553385,3782553915,4020822107,3144118943,1257080617,2783581189,2551880797,253646743,202893887,4105181195,783442029,1465716367,1709751053,300461809,3757840199,1002762365,2532303577,2174398217,395063733,3284244299,3763780257,2863309415,4096065083,1445222573,174409319,474353413,3591586323,28705349,2087002327,2810372637,3005038129,1203570281,2316744657,516605415,241161753,2802105673,646185273,1746485351,3921398329,2245844227,2756363465,1468762075,1568042025,1042127351,2759928731,2036159281,3863559669,1912767361,3337836601,4106237393,4221435725,3262934763,2476153095,2811570245,1320435757,1975014249,2303306137,2006563033,389588437,4216639759,3234330511,500012071,2335358991,4055647187,3688593719,1695864125,3297560021,930899611,2538833269,2395834727,2631559647,1002865993,2445353341,2281818453,942407531,17339743,1489697163,3980761501,2329221821,2509862843,1728686997,3224155395,34198447,692123739,2430007567,4141394677,3283843633,4067516215,2596230433,3485516441,780719309,3639154767,1636312547,923692275,1154214063,2863834955,3174875791,3026461767,1329200201,2202307531,1530089001,1187882693,3484572399,3420678833,1106702391,3886767187,2123772713,3874478169,404591601,578398293,2594203873,1218590719,2870659283,686842129,2369479839,1990139865,1274422509,3081632293,1500353247,3974627099,1240818419,1308459191,4171894031,1750988657,1286023699,3190415935,3147358337,2848168445,318818119,780116183,504639637,3530130851,3898015815,544440085,586214367,1520277929,851894957,3122071909,2085272709,716046973,1510083675,3376474081,4027600745,1347065987,3687074479,2023791573,1723824389,3999394979,495881315,2299902145,190685613,4180121637,2465945753,888601907,4037292437,3660632805,2048281911,1549944707,856394827,1626730467,2584059677,212166489,1280647211,1509945125,3328389965,3410841107,33945837,3354155727,777235805,3953973297,2744858035,3269216811,185665433,1363933397,3338784247,1362963411,3626792145,2291001243,3138902429,2078956697,4282618045,1430111165,2120097175,3030866453,3158884621,350438997,1054959535,289042379,1978154777,306145389,2786904749,1472371399,3229542759,1523882027,571771567,3467170875,2259392017,2391411139,920075383,600392131,1314196765,3234278311,2822774163,3071419585,1147044975,2337532669,4220749707,3613950633,2467034379,319338429,912814895,1193937129,2616026255,3382393089,2973229845,906314607,1733021455,1135554933,4259535131,2545575925,1848471585,1632710011,1181592567,1094186101,1726744873,4259290355,138262823,412227451,3685526663,2826582469,2627251933,3539186263,101903449,2664689399,616263285,3503884937,186552869,2466657241,814732889,2809392555,2626838229,2742822895,2448896809,28882305,3208987533,214594473,3902312191,2403213217,1423781511,205308111,2720186961,777736591,2512401967,3477528693,3736956061,420010513,1519144249,3645714133,576043003,1627952353,1432787825,859576237,1827970967,2687375145,577773793,1389842069,1926851465,3390870339,2874182471,1442177127,1898693797,3966253361,2541933853,1896478389,2734860639,3776881,2696942857,3888157537,2952142005,2196214283,4001112955,1199289351,3139114209,3202902373,3355393253,3407985353,3675532401,3703289865,3692574889,219310507,1783060913,3610675937,2319102819,2181192905,260734041,1076280695,397953457,2767196361,1688241089,3039126579,856873827,1093149829,1158119365,38390763,1456765907,1736530255,4054287741,874970395,766066893,1525040553,1580970195,3778583607,985710587,2881692827,1562307291,9946157,747295809,3060883985,1200641323,1630585719,1728958423,3827072455,930507009,1289274911,1510114283,1531992123,568739917,3966299309,3940836581,1041537713,2469830549,1822384601,619249305,1888096965,1896856657,4245863397,613705565,3108001683,2413018867,441206879,4172252785,1220040517,1108205765,1455501637,958584813,2163998127,1956056871,1380009451,2475001301,2352882193,2275238989,2896235475,2620625427,1342272919,3966300813,3907258993,4045052415,1100620633,2502150451,856033985,1621985941,4091439011,1267082823,2818263693,3764662795,1073772693,2309256849,2143104409,1578340813,537403791,438654049,1686929607,2986404577,3543265803,2819946447,1005031717,3111563965,3613911263,473040083,624432201,3793632831,3633183417,1057340199,702858919,3120870335,2590312787,1703219973,3852782321,1929076245,2534412285,3875240307,4184133251,3270582483,439298761,4054538495,2310010577,1054612179,1429686723,1345919951,3151544059,1347642761,2167854065,2467702807,2046693487,1322055037,1951818859,1969911511,2452199119,1222998611,3274248393,2694460419,2263110507,3516986771,2433160681,1908488957,1207471417,3081959189,426678657,3064658665,1480938995,1417280703,449365485,805789159,1316460675,517504339,2747883485,483691741,1301963079,774341003,1824308965,2917336269,545072525,4110308997,952730251,3257630331,3809463095,2993431769,3547548137,1074823845,3754372787,1994295395,3328189311,1233489173,1641024845,3493867067,3927399351,2119937797,1294144081,216657443,894294581,16393073,3166195203,2109998095,3590620239,4240784405,892238533,2673258529,1879823329,1529531585,2571232679,282200303,3405543029,403434731,1862937531,484450595,3489226585,3099928237,606330113,329913123,3633630795,3894731825,2533242459,2200553165,2315248699,1794015795,4289870951,1419701695,2261575677,2347072573,3062363627,546809387,1639409483,1769624979,2987997243,3317551267,2718212439,1723525131,407839439,321364953,2473632445,2473583823,309825045,4201639497,1152261897,2877115727,3726489431,3810933131,837156079,4019278861,3016526795,4184929125,2193911059,2648375381,2198983467,1330384891,1789938393,3901098061,795948687,3055825595,2349943373,4085675327,1254563065,1299026135,2954235111,3019503793,2894180039,337360897,976723459,2331358201,2834871081,3639545181,2936897213,2081791665,2557362105,1250150623,3861300023,340138281,3710167403,9281105,1314535405,3189825255,1971122997,651864397,2317762889,592806361,3478570389,153792605,3943046419,382397713,4288447389,2185084683,1075174855,3579569171,844773491,3055578085,169402869,3280110895,2869307409,2522056697,353876087,2444322319,3690103833,304165515,3352049351,363197377,2221161487,3510160377,2636233385,3727107323,2895027967,886166343,3787931329,1342044383,3412117675,692229065,2634725427,2937709735,234904299,1986603319,274575573,2584979667,908349585,718803611,1113073265,1848431391,3146645089,2667489523,3958885743,1295175153,2228668849,3333158517,704621717,2955997037,2590570263,826089781,953989629,1750192145,2760934667,3553281061,1270253745,2264242409,1680031829,2001879215,3253124223,3826386133,1991764927,4096339875,3282638737,2939263743,3529279445,2993540649,2366067093,1815633105,3348028235,2564369953,4249375611,1450812747,1316762365,3605659983,3072967973,3023330023,968103625,2534251867,2697691919,2803100083,1131273969,2407816793,3349427085,3061360227,4222466923,1273925033,1959634713,3503786159,994951081,2062056645,3294478977,490589911,673717005,3384454819,869781583,2842717957,1376647941,3894931599,2228424799,3500518155,3790053827,349765121,3674348503,1495058715,586300799,3173219969,462595335,333733831,3825866083,1242020685,2869962053,4029525389,692612125,1344383775,3646142745,1971134443,2163430209,3185273489,3484802615,4210081985,701924825,2089336377,1778926441,193379513,3223239091,2394968613,2658281607,2773165945,2705182457,421668369,239541297,4202462793,4252562021,3136282395,291798949,1649712079,1841876479,3365539139,2093219621,906077053,3615582005,450951403,1954232731,1658165893,2162818853,1535507991,1027135285,1594122593,2329191443,4173727761,3625648313,3125464763,1069318981,278129397,839868619,2280999963,2959286327,3944718591,3254610051,3385672383,1225342503,1625981473,935005751,2103833999,608798041,3635098285,202949921,3893439831,2520089297,3181787059,2718893219,1083793717,1587490183,1448888865,884972363,1992765039,4260125145,1639536133,944060925,794258877,1925787641,140533469,1161021299,1153373863,2360173957,2731617319,1472865671,3134849045,1285094231,2722243981,3407208549,3418698439,632817441,3769135381,1078934877,4208783279,2649489501,1636736545,1325442641,1709507305,4294821059,82408949,1099601589,1633746267,2365706067,131701799,211167401,1476608679,3601207483,3134333771,71074605,358514187,2141508073,1053591175,1249210313,616082849,3517353077,2978541653,2207299245,2379780281,2584048873,2908911863,2426178021,1902106965,1898830925,3475928773,1626721201,819444333,288067153,2697824065,1253731569,3084333757,1171314765,742207245,3925956355,4199949949,1940120461,3679003631,3094648401,1628687975,419402267,3407227855,2095805709,1635867941,3824044943,2211589117,1555419745,173525349,797854471,3843438851,2265525075,2748989725,1254995555,2395287585,3629694367,628361739,3496341109,1761833239,3189969509,4158503729,2734897111,2363547399,162848381,3134682591,1432399813,3371850923,3429977661,1934264297,826633763,1015462657,1013822747,4114279569,1931134851,2324166655,2583090783,1125681067,814449999,1068195163,4172622587,2423481495,3181601255,3099628873,1538271681,3541823205,3406645013,2480067285,3819495379,3754433781,1240163385,3474002713,3248924595,1862529343,109630867,1388311569,3746593087,3377072439,3687544633,2732622163,193386099,71587265,3589464439,512492533,2407498853,2114388595,3833821003,1548474389,3521223465,2036936695,860128773,3221180147,1048370249,293226183,1516905819,2051660271,1795189531,2585277309,3958544239,2865462519,1888622165,110005767,1495038545,3109327529,2155355169,1335674175,4074206477,863427207,1382286903,2084582201,470801099,1676746013,3837585577,4060712791,4002618197,3553103675,329393903,795660201,977493451,2289772789,1235001353,172470393,3678628351,756460401,153059917,3034209451,3090956363,1368985079,799594755,2521930963,1224124395,654959643,746398579,1786852093,3034745147,3359158461,1256666885,609300557,4189947403,578935039,4071162267,1201724819,3872921857,3810818213,1305335591,3654052745,3471386263,1119434255,3339819753,657747057,2564839329,1124928477,455945673,128601461,1294430529,243743949,64360553,590631679,135163375,3946735743,3499255791,1485584037,4262291085,117329725,3914149807,1300696205,194301693,2359940829,2761476523,2888886845,2375900445,3466047459,3639989837,1821937151,466090533,769441535,2306265169,3569755381,2120251213,138132077,3521758063,3451277769,755957869,3452029117,1789090845,3206299045,740826967,1054335389,3943837489,3168668225,4257482419,2897466843,1788002225,367141943,252017577,3385078815,1144594063,1446110807,3897000115,2309955719,2110232697,3979602727,1771706473,1839959073,1473849965,3693971653,40362197,3049328879,3136843173,2765857209,653199829,3267482379,945173735,1404354013,3143211163,3255982837,792472823,2581073983,833647323,1175124415,2033010023,2341388135,812483537,2870127267,1753064043,1116049751,2383009433,2095324295,1235375383,3731427225,2463086327,2438149603,3211205465,1811310041,2204845191,3274801455,934610931,3191671477,840525853,2960528471,3795598527,3243003181,3416147853,2639896083,870706527,612629865,3505997145,4145654821,2967592857,440119301,685702215,2837063247,65144911,3161174565,1798098817,2293545381,3608829305,2468219899,2982337243,1686237415,4095299001,1272547911,3327701483,2165839603,2906279445,2584554323,4054072629,735690001,206475765,3214794627,67475253,1260750229,723329649,2021568705,533473177,161735315,2157467371,2084378121,3404347245,1475922853,612116739,4091890087,1716877545,3276108513,3263540153,2304001875,2998927593,3252588917,3207907577,2909473451,1509376627,3160035417,3912040675,1840071377,1577143161,4219656567,3277219477,3461443159,2262612385,3877029129,1823062379,2866336675,1572744837,2620075279,868503423,3791640499,2229775209,777274181,3385168849,2675579435,1031339715,1913888469,4161745943,2317708301,1035119065,1475383723,211715349,2384526821,1023976729,2403032705,3484706465,2735042795,2854019311,1791460111,1740335853,2494349075,273743745,3428844841,2880100439,2913697563,2280697695,3591982161,1126656499,963902489,3343740557,1838943447,1318173663,3461271897,863847809,4189709989,701787391,3240829325,3984470727,907401647,2405798567,1130825039,1800692001,3244833257,3620609935,4123765373,1945458379,2720848129,3640572035,310530339,845460183,2920796237,2828482155,546928349,1894031057,3786817489,220163485,1008866233,3019342123,914711827,3574205715,2938474699,2005962155,3043039693,3863430487,410955721,67510495,3706450207,4083056115,3969134825,2224566665,4244093577,1265183293,174958231,3913361579,480734157,3321230901,3743292611,1715113935,2483475403,2327457419,4245275921,981344215,3593129641,2326849325,3962799361,1978499341,3398650503,3830447355,152197499,925094713,1676878807,1069864027,2514314035,908804501,3629039859,3273119985,4102001461,1101159689,284988027,325712685,557152331,3853248389,459360143,1934806077,2827067653,1425945267,2196296391,1320840999,1958097185,3080373513,186827179,3126387017,2457997805,1070260445,2400966237,4190637171,2391914107,3637738687,1362896971,3128504303,2568000893,313723355,3147764443,1565483825,3193197327,1851340075,2948711595,512201337,472756199,4117806771,757877873,2547570253,715989885,3456355631,2149959385,1692977067,1723076183,4199786693,1816798971,2882288791,3286763317,3794578179,1800315245,3996009175,1808830143,1287999079,3042091861,219201467,3517763281,4140320583,3899565175,316046885,1326456191,2040707351,519765037,1112145245,135858519,3517308419,2991622089,4165650443,2092791725,1940111213,409813387,2666099581,891107729,2809868319,877358269,2082681771,1312989947,3336365559,3476557977,3625761917,2246868145,3809587623,596888157,3275934901,897983411,1305888639,2693696007,1832048365,255080483,1409433225,810205843,1409919141,2739077441,2671449439,2339055045,674598613,1085234199,963905961,2206634223,118286725,794793225,1892379181,2950519173,1705254611,2848754019,3650275085,1264746175,655933643,2629034863,1402762861,740641101,3757213289,730173349,3845809611,84149233,1307190245,4184983525,1868385511,1386797405,530352343,1745147069,2490043613,115251823,4185415761,2164700747,2190939921,4160405483,1653589929,3281592929,302230781,1713650995,3809072935,4057194497,345742007,3189954877,3062221227,257983231,3749252043,3350898313,1911198935,961441753,1243433133,1049208427,536453819,1313745935,2515105449,2421528001,3849456411,3615264487,2924555833,3111827799,955114127,1399968785,275552049,3139994089,3927986651,321306491,2715406353,4198603757,3405682687,1686839889,767211045,1261135225,3254322631,2903406635,2644765981,2572397141,2668421781,4212064779,1147118743,2201249623,2299283569,1241787771,1471867483,3001071045,2630851351,3873159827,3923107901,2744913021,1913402299,3038280081,1979203571,1161841593,2456149849,1753153681,755745681,3071626597,2794077879,3876070795,1297506715,3424383017,383981063,2170480783,1195327915,4283060439,3439752593,2877893339,4100654597,1955261135,1196544581,678066899,3998059663,582856419,3911814371,1376604297,2472721033,2683829635,3551568061,2273299619,2661088357,3156092891,2187012935,3543320767,138566563,1836811251,2500064563,4053287085,2559996085,364657695,3051658259,776126179,3470053361,4265782527,109217425,3556133471,2826724125,532822415,3686588465,711085057,1926128181,2032253591,474514743,1463629777,3282577967,3641250525,2644210945,1850123495,1966009563,2849612815,4049315703,3479187855,1868399239,2079344555,2411394035,1707255249,1524883915,68290687,1297313251,2867262599,3501007159,2647701905,1621172529,1977827397,2430662517,24532499,315464209,254798475,2758221035,1516319189,1453470875,438798663,4262113813,4221418283,2587298439,3178333215,3412998651,663722975,3803132983,582059813,2741745551,4007061017,523933345,2735001607,3420371681,3183930911,1087948509,2991813541,35727159,2491218457,2947801817,53108389,2299193865,1564856429,3308731719,1847443931,2060462157,4187395939,2524829139,728788783,886713019,2659993519,4167744369,598446711,2879017357,3486554441,2712923729,331312913,3451823513,1103699131,1188739541,347167337,1214453813,223973921,15685667,133163397,3850614951,2164460719,2110445001,895771195,2640336603,3902125183,4155990687,2630818871,3853544385,2084104523,2450850917,3043167063,2875454501,4238167163,381487369,583431137,3409827447,262286047,4061784485,2619114569,1618099783,872952099,3186811977,2224953751,439541559,2794191625,2817485443,920010985,2353592273,938325055,3629085557,591063977,2844049087,1285861199,2615126067,475061695,4039351381,3017269077,1402325827,4149098815,2166018815,607165511,3967627535,3623908199,1032505551,2845167405,300870531,4186370897,2674119833,2633767881,3894020571,119020873,2789803273,3041935401,2921361997,605415225,926436739,2332971491,2949656353,1893826815,2810715777,2009458683,736322089,1052443753,1897129103,514911333,4290158877,3939411635,4127225301,2988543241,4232007785,3006235779,677227287,431691409,4029902025,2418279693,2832801077,2165179453,607377055,2270216791,419038355,1127863475,4130442989,2541499787,4136288363,2970394805,1699586791,489332999,1117596411,2040452521,2130592823,1565626781,3446358739,3461941965,1400946563,1674409589,131534829,1715415869,1095051685,1051009291,2793768405,3935035323,3697543135,1535198485,1187113083,3841638187,4115466829,2487324669,2813410301,3471514543,3548861847,2303244165,172762057,3945297267,1273855577,3354734919,3415634695,4118839853,1776288751,1789575449,3567776883,1878023601,662356953,1943016983,3296331001,3966817613,3796582359,3096651231,74331945,1309063813,2932867111,266410263,2573937047,2234102445,1736260209,3021643153,572433761,2895244109,1095924157,3093027137,1372123115,1147774471,170907213,1021534059,3549639899,156738973,4125907881,2240183559,4096022271,3230323477,3080170481,1304988863,2102980703,191308933,2761114163,1672911443,192172375,3590110513,1814152975,883445155,1935703189,1087425861,4134063599,1557156497,887689913,3045685519,2638885881,6547649,253000551,3854457529,842508839,526181933,1749079003,2075914997,181122675,1182867533,2086377645,4103742667,3870859363,632914217,720291045,494590395,813526665,252598183,856256137,2143050647,2316536181,3421831603,2320962533,143716709,509993345,3651651227,321473725,1071225319,2014854375,141505675,1653584621,657327549,2504813197,1789794327,3161843695,554797269,2079681489,1340237841,1321914505,2092896849,2029590637,1308990739,1517170025,383917443,4210202231,678690307,2459754477,741821651,3950138229,698955519,491190905,718801535,1074621319,3673343233,1270023147,302605541,480570919,882433407,1161349593,3552766579,443159593,2093217147,3660567277,872068373,2678642081,1284222717,2408290433,301955265,120962167,2961547355,1053140715,155260119,2411961693,4267498821,672616401,3585472253,3236385333,1283714557,4210555353,569881353,1135522369,1129819355,948291977,956410333,666109813,3673657919,1720099371,2770081123,2138220339,1262740151,4022103557,3053496289,35339743,607506155,3910692927,4198598989,1877176107,4108607481,2522983651,1696427707,3129886153,3722736509,2755263271,1477663017,2963268307,2398719165,2810757079,3547650831,2871844567,703348645,3688554805,1021960441,966119809,4039587407,2261599183,153503051,2086828685,3971660113,3327815237,1565359369,1278338989,3719486845,2975378983,51805017,334515987,3116846797,124871141,680950127,1218974479,2918768275,2194442649,603523453,2718877175,3415280635,3773880505,2593325639,1285345509,135324579,1635040393,3720807995,1710207409,1260941817,368459193,4179618171,1629877941,3343301419,2007626225,1762077995,564077451,3266644565,2485788367,3382343109,2685248953,3103290853,3466686861,444412309,990115945,3571369565,3318934875,2248253993,1833412093,1171754475,362189637,3794695307,2421739499,1204889671,3362902361,854740379,2671834735,237377129,4049040645,2691293935,3614893309,1153023519,3916872647,3851885451,3131721775,1377898331,4096916273,495476113,2598245029,400056917,3839475239,463148267,1716935987,2068546751,1079816881,1995343487,1613315747,804730475,130056995,1197827067,2628857247,4025061985,1915877087,2060543357,1387428017,2301306295,20316041,1654762753,3401808955,2367107665,3466522677,941583153,1468835845,1974294989,3066147025,631118949,2430321869,3835014963,2656579115,1645603865,3493770397,3614632647,3238724409,1765765341,879492321,3404836945,1496282121,3220742469,920835003,934180539,4202334505,1089264161,577109501,1343987317,3554399579,3868118471,108742043,3402308873,3561886813,531558839,3639797411,1393304717,3970383929,1873920367,512299097,197191823,2296293853,1145482809,2622016025,3526240963,3517897695,116673999,2698566337,490375569,2406621135,2467284867,295112781,2990888769,597716829,1820622545,2636743065,243956287,3540523043,276212221,4057839185,850696025,4218320815,1371283641,3486805603,3121688143,765767143,879152899,3067212393,4187299033,4245400459,1376502597,4284035019,2730233383,411311143,3369216343,3025625003,3613280323,561726737,3762217411,812896539,346990125,4081299797,3126718131,1574284235,2922650851,2728958099,3883989553,2848276915,3472839245,1617079909,1630657533,3742715469,1399278035,3146148895,1993290913,521687961,938430455,193958253,466429641,1540625449,2353585741,2254299667,456121809,47343241,547428713,1250826119,3886445559,1201049199,3177214839,1457827357,328684811,3814162731,100835421,2064374195,402021249,2056187845,139165825,4230891061,2187887409,3608594945,2672118697,911359249,2934496491,1300466531,1226366463,561888933,3274904123,2387900323,2612742287,2199219107,3820827937,1750502991,969554875,561389377,3775331283,3568646385,394897043,4261734861,2019956729,3611803881,624141639,684702269,542950697,1179935659,3391907763,3445141785,146925415,1354535945,2302569109,1319290643,986862805,3492017143,2859801965,2572264379,2199038293,279166805,589620657,2091067885,5304585,4090568469,2839377001,984685597,1128304411,670742473,2376052753,336726953,571750467,2783543129,2844323699,936201637,2888444533,3702166283,2303343929,1496998781,2593079845,3678760171,2235245351,1359417543,2400483987,191589037,2648055437,3701795943,2456837205,487608555,1368185389,566058575,863528765,4016863583,2440494343,1472786647,2505016033,3577003447,779112309,1948243933,2407785509,785454001,1278512481,3739259351,3815337475,3701993979,779179805,2391789383,46212635,1206766705,3560261915,1819494423,3990267671,323932475,3733176043,3765502933,937448447,655978313,3131767847,465240693,3166504045,4198520615,4021546965,1553640847,3017003635,2396227101,681858469,141505965,540559011,2329162489,3316641697,543272407,1463405771,1961207501,3762540023,3166736849,3090205869,492148299,549792307,1336709835,3616117771,3131455475,2712714269,4134050871,3409557265,3694817771,1630679753,1983467537,3183347775,1471294581,1926816993,3445166071,2755731571,3639693753,926645047,4074614111,3565056281,1224572741,2956288431,2200007507,1009418381,2112828047,2740339785,1379956519,759720957,130783481,341787285,1497523897,4032026337,4130047681,4087974489,156043959,2647208561,3454786343,3496212503,2967126755,1917504861,1345810087,4192525859,1828744249,3542957627,2689687635,2475890109,969435031,2705608591,90532001,4134816379,1063749575,3329977799,1724323833,2972297969,3886539565,3815990247,2385981777,3297478247,828587303,1135783497,2611192777,2985750953,2440335715,637302231,2385897965,108673553,200884421,1399595103,2106821183,2264722857,1176464675,3792298255,3901578729,178390715,3168435905,3389980799,1388629329,322873231,2284810251,3413382513,3708004053,2598610147,41914529,405411183,573752597,2465623083,3979512135,3441828201,2664888971,2357104861,2424275765,4068868929,730851199,2144794439,96690665,853836241,2287832729,2767160177,3193937001,3427869255,1279078051,2841946075,1373441865,832861867,929740235,1234454003,1656527199,3333612703,1274210949,3349666807,474114449,467866047,3067085125,2586458175,1273828775,736423253,1915719361,2553293471,2745542769,2173560457,885671833,1158289305,1741757667,1391572427,1391587399,787023077,1711702933,2979954217,155844687,332369063,3287522655,1682386631,2058383047,2287270989,576361835,2348944949,2427659577,153229337,3495644223,667019829,613376093,837424021,3322146145,755835265,4293175637,242349167,1223554425,3903121509,1258269597,3731938273,2842814553,3682554927,815098701,2730162789,120764907,3955322213,2750038065,1242992997,1207921635,3811491779,3075668939,1991552257,23322145,959869175,3800247389,316527645,4156763009,2627705893,4023329907,969915113,3904469639,2912922333,765656669,3638578805,4081116221,4251028821,3244472085,342308159,1665313,2649299159,727886509,442813173,2269754793,90548711,1455293127,664421845,4111274671,1550486245,2418715893,549932291,1401591155,1707421435,4089250667,2787984583,2532123813,2283690411,4165441421,593408609,3575795725,2947747701,3985918251,3968246497,646686915,1529852737,1256307091,2497689809,3734518351,2293737719,2415539309,1039712511,864626215,1981867689,1118477959,2610832197,340285221,2204195077,4079790485,3249531019,3176228553,437300825,1076736837,3157701611,3236102893,3656935693,620652299,1579197285,2687447887,1663618787,1236133851,2648821797,1767795341,565715609,3255552059,2420033573,1701479815,2238327467,125986611,1248003723,1946469237,3095361457,1382225397,235118215,478522073,2340567315,514570415,4152711795,1974986383,3763464775,2163572433,2188633563,2861758771,845589957,1877446643,2642453705,52423079,3160728759,1820827583,4260393231,3512267657,387760981,2252978215,3967016105,2206941365,3464827451,3038896255,169215431,3264293375,2944155247,450631359,446418583,2621805291,3807289123,2558234183,614121511,1534494621,1538935007,3103504917,3665750699,2500969395,2073463107,28525741,3916239775,706312297,2855453073,3123878703,1578634713,3149970891,3788768057,4018644183,268377935,138021529,48707809,5717115,3374854077,2655297521,2257580249,3025563913,54583017,1276382829,3490741871,562329853,3777960063,2399343081,511834505,3370327013,3569038599,2081416655,2572839839,2110075329,1433694703,4136497069,793731953,997744977,3335583589,2999056653,493108429,1606987277,3617572299,3816851887,2037312813,743617427,555871575,2698097745,3149279085,2750886555,3332056029,3469385283,2651308601,3912625641,1224455437,2809815137,3948034445,1214426195,290450913,3109878885,537318605,2865232937,2625605723,1448278473,1174168247,1710295825,1857615517,1367174719,1555357539,3294485971,3938558793,3525021215,36998307,2815136087,3935432773,3867475291,3742944251,149991927,528836755,654779367,3531674895,2773948263,2458561033,3437178487,2159710053,55626125,1309590681,1301947193,3699959125,3728532195,1578855385,3744462429,3187843797,2021800817,1884882385,3589050239,894424337,2475723139,3574881279,878438671,600985867,1339530319,69997945,3878672853,3869730387,432266505,1886935681,3557246327,216929903,3120854111,4031541977,3035075897,720726971,3393749509,1832220521,3835639009,360615951,4182356921,3383415603,3796100785,3476762287,633393137,3119245581,1804395881,3323136821,2395564601,3888919731,1022724313,4074150193,302379845,2514647663,3939642807,2031843607,1638487383,1027131649,699743359,3042703451,2093342149,1171584107,3993074161,2418217719,4182572017,593206509,3015355037,558577225,630660617,2291671871,4216907915,3920411879,1335341445,1648666059,2983446385,2816680865,3910262263,2105661441,3033711121,3123980429,309036767,1255883693,3460445603,1437821557,49803671,753577157,2728643487,3342733385,1139352743,1991052403,2913710187,3728120813,3165414179,1014790843,1957488825,1191132649,3734680709,2838431829,537441829,3360099507,1318083443,3976717227,2404008883,3032382301,1189420871,2347557005,1180976721,4200928799,3299713329,2813027705,2758230577,4157720511,686648961,2468375275,93836647,2422882487,2459086307,1186768513,1571785101,3793921555,2437807239,3475041719,2437937477,3433040171,145174291,4202871207,1621677541,131842897,135279185,121134221,2314415347,1905768597,3374666207,595757875,4039938121,3493283699,3924205391,3524253765,3697712837,747312559,3390173367,2524499257,3873640717,144817893,946693243,3626734223,971286467,3748696221,19393679,391753633,2686190907,3901365033,703679773,830979977,13004703,2174001815,2850190033,1701584795,3378821455,3425360113,2047842965,2026895311,2733476135,959819501,4130898063,746226705,1238207139,1987081477,3742224963,2466844323,2587193329,109482941,2405362173,686850001,3876867223,1996803747,1752093865,1845128097,3911830903,1192502973,1771154929,2258448225,3761886833,3451845139,1215734369,528056599,2344861517,3621709465,2973547797,1576815249,688654785,1984577835,3925268925,3103674847,3071430545,39513839,41978335,3152923563,2589404601,2149818817,1222268847,3913604761,1306058181,3924679807,3225228661,1447428491,468639327,1756031647,1745139723,3677735621,2110090679,1457073185,2450630255,2509723909,4235886641,2785310751,2891761867,3183441911,934848925,4123949281,1798501767,4194779549,2880444591,4204622763,714675543,1193909997,2821326557,3625741773,473658133,2679661131,1577740455,2744320685,3950568871,2018041565,1073190241,1102859901,643837639,3875629147,140333073,2522892047,471867789,3264887929,4011875207,4185126123,3399494829,1033060965,3884883277,4033448095,196735751,439191625,1399566125,538890171,2654533591,167920135,3640006737,1781210131,4173684129,181630903,2798257075,3239198761,2478911429,795907595,542703433,634711465,1820019315,3622144113,1879487021,2473376729,2833366047,756067651,175824661,3646777509,3253483529,2040906537,2167877381,2428601127,3665869171,1848852813,2867335885,1146809203,2758769233,1880147709,3751259473,4001234279,2377506761,3258636267,2192394471,67703897,2477853509,2183714539,2715623183,3145751821,1077789001,2384043611,2921922675,1114848735,3195624697,3771020485,216567393,4186657771,3952950599,2405359209,1722115311,1147403397,1670868027,410824483,88570247,1879319449,1018530901,3736661965,1475631421,2492094683,476004237,338320053,1859297939,3006068831,4155303597,3854032539,4194192529,3252284023,4291862309,2979966921,2409807657,998209641,3627668937,3492307537,1982894399,2652834795,2610178579,3240929905,599316291,962300851,3293872663,2932219375,2121162757,2543145325,734279111,2276578421,3836239609,914319577,2078831645,4107124843,430640023,2216262611,3354954489,3285187495,2701041635,651448321,411876579,2495407601,740749235,4119742111,4196432917,1901167355,2496368085,2479537445,3910017769,4148781687,4043266791,1408720735,2680013089,3239697409,465399643,793628079,3390226137,3965276617,1955328553,4226048591,2991016861,261757687,2175207541,1102412277,3141553391,3401165993,3006243719,4198680443,810363057,337284189,585668991,1860119363,4167139923,904627445,2175389627,1648881911,3407106055,4091040325,113248391,2981541265,2322756037,660581159,1946011565,2700115325,3508278417,3834004627,2775956927,267458093,3759905793,2689831429,905870517,1748345229,1860502311,34013709,1300553827,779894357,2387336737,3866394873,2503828643,3653338267,3277278213,159125389,3053578593,3058905799,1543075563,1185057437,4095601691,3868005095,2335133777,3332987331,461189043,927774189,213748167,1535830451,2592529007,4251009401,4223729495,321385815,1366225441,2332885001,2417345883,3556345671,3096025831,1264385039,663228695,3864541687,1504421073,3905578203,4001767597,2120542471,369336707,1397709771,1052485769,2619097877,1460088313,2625750489,2909102715,2747971261,3448344219,3960558285,4246923085,3842584959,2402907331,1567861285,2850529637,2653121815,3059520679,632765951,122431201,2688859109,225814099,1118438285,2413242031,2595389279,201767445,2139680209,2536197851,3866771339,543096201,2454962583,2585677435,2689600599,1145410957,4095601057,3404044851,3152138557,3357562425,3348927869,2414427397,898983873,1625551239,2338222109,3987670449,689187519,337132421,1926111059,426655155,3660809277,107535863,3533406499,577093983,1098316789,354516141,828164813,474366707,1216228085,223214967,246624401,4136619697,921049025,3177815257,2403321211,1333993877,2510941905,2168767021,3221872771,385294363,96239439,2405960505,1613402075,4036429239,1029467605,2414104607,1528634867,301663123,1054178789,4216520933,608456865,762797595,3094225895,3615220315,3520446119,1515093941,1027040471,369665609,2139350745,3157148733,2844642775,1790483441,1646846495,427686737,3187230737,2658794731,327337301,2188614777,965404757,3177179957,4180671223,3821891773,3167611387,644840845,2257363897,2869460473,2199545427,3489829933,3334629591,990697731,1141538357,1510938003,3592080159,2046587111,3570601189,534760763,1782999483,817264263,2243899207,1648458861,1066954355,1347687621,4048683547,403307993,2476175603,260568183,2753945749,1385381841,4129780839,1475429783,1340789631,660994467,401616977,972326173,1741452539,3362105455,1057821895,1915049107,224802497,1737519603,1744852047,3155936485,1437543521,4133606895,1800848269,2213329939,560197927,1248124873,1619909619,3587531659,1515983757,3054159863,2551429627,1938585179,1935676125,1406532637,4155236303,4097296921,1422855435,4130663969,1454580973,2440047679,3185945559,1342512523,2348519141,3987306563,606228415,1167617377,2965814093,4186274815,1824612619,2078500595,4077954517,3909358141,3374525981,3922724499,574866377,2511882779,2077416993,741828003,4082488007,146499205,3084974149,1526986021,991334237,2873849491,754498549,2431416081,322081,2166233373,35887985,652911611,1299848575,2469885595,199764253,2734269923,1831554129,664464981,1298066767,3351973831,1349808825,551459265,1921335501,3851289641,1566617255,4049650637,3684766521,2212779447,1066468359,782220253,2795679157,892733967,374619083,401168799,112640679,1649978537,965063305,1763089665,989866383,880878393,2845032789,3641632327,1622197919,1576009479,2603415965,2927961333,4060870317,2895777775,1446024305,2941996925,2591444153,1643327437,2458055553,644382365,666984591,631962925,3492332899,3786907237,471838729,2622427435,1478888877,4160640065,3147975479,1309149849,1478380115,835968507,1681027481,1200876483,1455454579,2303573671,3519248397,168952241,1915631459,3065263067,3001923975,3758573525,15372769,2034766247,3199119623,928081895,2023815699,2867284539,1581849775,588148761,855789805,2273661273,518296937,3715126351,874498841,220503213,431463541,2587374973,303504797,1753271983,2550607909,3842207573,2579561409,641441109,3977834745,367234157,1740078281,3619906531,1308557415,1257495683,4173740995,579865121,18090097,751319189,2405509641,1885879827,3504405745,3187539067,188761735,359001165,2498649739,3142256969,4129026741,1402784007,2834001749,4076464671,3653305231,329075843,1496007551,2907895529,2506806949,1370122193,30332141,3318369007,2899671237,3574843723,714712239,694086781,1054528373,3690741847,4245263747,1652477019,154263469,3236329183,3365076157,3630264965,1602124121,1278687927,494780491,4137272851,99879513,1123426509,1557471271,2410965889,4040380339,1065292949,1253520491,3020976873,2478979243,253890131,3583184727,3846121627,2287856981,1419831943,1761701467,2416980741,2314836313,1567906185,1474946547,2013235511,2251495003,1730665183,1621379153,61310201,808573383,1790407589,479709203,1643560357,2186493869,826937781,1650908295,3923608103,2346854769,3156158083,3909826069,2264203141,2730443619,204956823,2388853537,264451405,1145222959,1640994493,3464679947,2348777161,851418625,956507089,3439610977,1444160793,3685421859,3676907585,3157664533,697759587,548037595,819899527,2347327797,4279885987,2744218777,3926517643,747813327,2204528913,4157382143,475591667,944813529,953705025,3260447029,1503279239,3341178239,2865960253,1104238295,1426716707,1589657661,4276382849,2810894895,4272907593,218861757,2238087611,54951299,1691353809,3604292457,4215276863,3135718245,3112212049,373193351,2486049573,57815771,240766573,1611975871,4161983259,1572569243,376553813,2391173183,3844730539,1648539297,1085016917,2550564305,2885542337,2340265717,3224277889,3479286325,3027946373,1096916329,4171092885,3014538965,1584359025,4051407643,1190426811,1658817653,4027310053,41256541,3593043153,284808891,3296530951,1538382657,3946797753,2845963591,875126725,3359045923,2852961011,3399506219,3780304273,1428454353,1995161373,3313155227,1285156031,4287096683,3454790193,2555757621,1395681841,1028551001,1939841203,4232701165,1579352587,3177456573,1079008951,1094331635,1728673729,4089758383,1388731427,4134999447,2201061761,4225120241,3084073,3597885293,66913067,497593801,941429981,3749151649,3953434649,1574970059,3249306153,3097222401,1179222761,3500641875,4055365685,1713162607,2409151615,3309286709,2706490735,2663110943,856540803,4020058735,3064075279,460961549,2141088389,659676235,1195235789,676467221,3556685649,1394571581,354581911,1445752945,1319129849,1433459419,3483185451,3543050833,12153885,278231415,4203200489,3390748443,231456405,4190547727,1585488373,3765038993,2197554565,1844720011,352003975,2041881651,1840603749,3119672107,2619355153,3829267197,1400229175,2626490161,2911183007,2587598599,4259947989,160347431,855717133,642060651,4289770631,1290660799,2848297301,1782225885,2596488101,2549801597,2105534889,998897601,2866022789,2067071915,2221000357,2223508427,3358725123,33084769,2737345709,4065231449,4009490505,2005829809,2933236639,3353262407,1188005267,2860937367,3374913821,3684632971,1295165935,1059047729,4144988535,311107931,1419190861,2282925295,3354923159,495660105,1064657161,3234266585,2075885073,3094728767,2285875059,4005080859,3485217321,687783357,2925654537,736139249,3317466575,3708606777,2955955923,1116082613,2304514819,2278106115,2050824389,2563466179,1862037513,144707303,142530945,1711310405,1059857967,3792251735,1599811791,2292696641,3065268965,553238251,3570117123,755875689,109216405,67977035,1883928813,2732424209,2540121219,2076492907,3423627579,2383448715,2151734073,3750884433,77616197,2238115365,3071196259,250322939,3704726099,2554398527,1832999317,1316750281,743765523,1262582087,1247473605,1315683831,1979476767,117098421,4270483915,1772666829,151388271,3662452199,3516266293,3579745283,2589593479,3052628219,1095179855,1516989891,979244193,3170100317,3489080229,2607342995,4146892013,886783561,3259754649,1568485825,2789330691,2633801123,3926063867,4005759259,523034519,3799548113,4187156333,2493007151,1395386643,2072891747,592721865,778796759,37500819,2123300599,710832713,1242850465,3711333753,3839308857,2979971465,40159231,2685933335,3729748979,3930203337,3716537659,2375821321,1658199585,4054599351,2777402815,4246800719,1813348429,1655174293,201143941,625033323,2899229679,521699077,686182417,941654509,2078555165,3070923431,2933161329,542714149,1406637791,2463248161,2323030609,1034761527,4155958205,283223695,2456134619,3051690883,1647279369,3306202447,1851174587,3150544237,4111607181,103445305,570441413,2574430119,3361220619,2864913285,2884633413,3752037647,4118825385,1174285619,1571024387,2161169719,1126507597,3929368537,552229907,2991117645,1109059383,1474537683,3293776701,3584440059,3109559607,2702225989,2793081393,2801073385,3674412665,3596980471,3083507069,1110642353,2910858911,1730341503,2652367077,1356380691,3987742123,2765901257,3462751483,1913678921,1957027715,923920093,4045151309,737555055,2922199251,2151843375,3634975497,1644471067,2229390623,3567201069,3260559081,3751240223,97640243,1428524935,2964624747,1954254149,1312703009,149366099,2181012261,2735546355,3029054923,4151952565,1944466969,3859840719,4173916427,1721654011,2705144629,1788941689,1307222025,643581177,1887498043,1909161435,2696355747,446218615,1814119071,4172114077,406928715,957563655,3972292479,3017386729,598316827,1601342303,2403836611,3677417489,3484589753,1594344973,1381068405,913377269,1761660799,1975758677,1230407621,1738778653,1784604239,2555960379,2547343561,1920006009,2438070435,522364057,3150398095,2621845871,159947583,2941856253,1427543439,302314625,12227719,2973221483,766679865,2151202267,3630304747,3130758149,1697968535,2889753459,2766161573,2433976495,2002797665,117647271,1352911695,3740449795,3177966689,3062082435,1762650261,453180915,3198420539,1408539823,3764308089,2953996353,4045146927,2478192707,2404609435,2679995391,1012241373,415197545,3065009613,2210719039,2237556413,313135233,2954796009,3098806069,4170551327,2143556911,2395742545,1060845267,456254537,3837672597,3612249887,867614969,1743125725,3565878789,3530983481,734617645,1729878141,3367692063,783832609,3512970469,1365637061,3547300005,2824923495,4142011207,3707296001,1071551249,1975639561,275891727,1501556509,2287026529,3196295563,2336541697,1988865307,3677968657,4026006287,2257547099,2134866557,3693316299,3521787187,883027775,2010581369,4095927107,280749367,3337644155,3775629887,4079741459,4106094591,1464474843,3541079969,2322769541,549674843,2522529035,824265105,3613745983,3790208375,954808255,885306715,1662342661,1380259409,1736486131,2686117765,1521233015,1053423475,760444873,13467329,937893161,1861523963,3306805171,1256261317,2760257139,640542865,747894071,4142273863,4079723447,23653571,808125799,2610277223,3363126569,2498622539,3058523763,721688805,1395512021,3765640481,2227217705,3529190151,487113173,43790731,1031931729,386716209,265377589,3344872845,3777622401,3356452729,3143735081,3722658633,3805049679,1527296533,434613517,2560241103,87469073,1533530159,2940044341,904537485,3103935297,1283409253,530314667,2604691905,1468448623,2759088909,3117448013,1899835851,1995701661,2700212777,4101359853,2056986823,604224455,3418499057,958762069,3695648839,1619000399,396105573,4078860669,3975535909,3004806677,906054199,2211919425,1433028715,1635797259,4120951995,3892606625,3460350859,690756599,4222781119,2378410341,1231363459,1961478231,353698297,1394496385,3971142863,2416405493,2510294711,3099367755,3626089891,478534431,1118542739,1026335867,3718824909,2398813963,2942556043,3027230511,3242860527,1755726111,2525702919,2827495513,2511045671,3133674437,1827094509,2481567959,4043790079,938581217,3959171099,2019207759,3699111565,4005666751,1311410787,2845252683,2392596855,2363370749,3968963841,1448351067,3017730721,3011583025,1441087693,1919863577,3025911809,3469406445,124206507,1682871127,838240253,2425595063,3494439965,162876161,365028715,2591721761,560955455,722713087,732943017,1415806481,837930219,2341500649,2269534237,2560768431,1417989837,2241791959,477170893,3719343467,2391304259,419929613,3808972933,3344754121,3414369543,3878129851,2011911051,2631499897,1001760339,954825207,1359820543,4086900343,4274268623,1622172647,2395736235,3618226079,2368334133,4088763693,3660108837,746092685,142706181,104784591,1463467629,1458946711,4145081835,805115923,3940267943,313950119,236091843,601872125,1759173291,1269405577,1885483249,1738151917,1874834667,43846545,460318181,1866262569,2621253425,2238297753,2795390325,1191151387,295443085,1401615503,3542516809,3957622883,3758471417,3782981987,1027913179,3089019849,1175578801,1272267391,3332935927,3293478891,1034614895,3647460413,856861185,2749255523,869795797,1002384175,3056865629,2511259735,2161634439,1715978477,1544763403,2014010157,3440329245,1611439297,1025019069,1528929465,655647113,1112696463,2040865103,3269673599,2795602989,1601757055,304689087,701924731,2557647177,1482468161,1432578531,1454079093,2425923355,2742590101,2914430733,3195850463,3598177835,4074323979,3177325599,4242712459,691985405,444151277,319248813,1152237037,778285577,1305822981,2182267429,4039423365,4067149795,942920803,551797551,1265053823,298156685,730544733,1925644181,2115202803,8540103,2531372731,312407791,1595852509,179024349,2377362261,805333945,666396095,763324933,528848379,2436317123,3427412485,964981675,3482993959,582256441,3487706571,2060690861,144477617,665512167,3465667045,3773066609,2658212969,4045585277,1838320741,3993068315,1358453429,2684687699,339171747,4185099383,2015318995,1690066839,4029434969,4232095697,2905655865,219706299,2064748191,1664274877,776364167,2006272561,3785702683,1352306867,2232669327,2202359577,463364845,1547123305,809822863,1746185463,2666647263,3204834965,3636486377,2252955135,3662887411,3471356857,447749271,2850280003,4206836055,4035020373,1627859625,1117940799,3039268005,1593797833,907007095,1379594013,3739649393,3739143,1118185745,315209881,2822763503,1176416933,3842806067,4262320039,1252575341,2903750123,3820004249,3860343775,507059989,4167876135,2070945751,2945900609,3939887229,3377864081,1593346481,3177444741,3817738525,1909983211,699968701,4200828135,1302445841,108411705,709529705,3692883973,861313117,600971787,1505288009,730554105,1058513395,3953753875,1183048683,2402642999,1051538259,2835633097,3811435639,3287068961,3187477359,3243276177,4192682007,2185002749,2702779315,8423563,1264713447,3070008799,4075018329,1696554633,4136906985,609706293,3048963343,2419257415,3230879877,2858561547,387043503,552698305,272982065,2232819597,3921967807,2387069567,3796001211,541882421,1328109595,4245476751,982038201,1139067989,731320981,3120471243,2655639827,3458535361,2931042113,1977570103,448980045,3957034235,393954729,3777564993,370042133,3454141537,3808948265,2289419625,3126082721,3681069145,1674754147,2924381607,1652281567,3879970483,594090985,3761361985,3784455047,2905294787,302293357,2810213321,3292183887,1520241141,3860317293,2122213563,944961359,235818907,511105117,2462543499,3178186125,525687595,1786556899,1353050155,977403711,2485334953,2872312501,1222131495,1573233915,3208102887,958581369,337287057,508566601,1489211869,860873331,2242847639,3877841735,1130144653,2477540925,3560444397,674029927,4063134105,4025213319,2642486899,95270883,4221050375,3964972569,1349434597,4027268831,2721944791,1630854753,1605365251,2524622199,1152658909,2821897915,202041285,2156560725,3417990197,1267216629,3369623385,4042477365,79427701,1224358381,1937592833,324310725,215565167,279918175,2947340123,1932955977,973236693,1788885267,3308762423,989203809,3716037543,3214582497,569992801,1389075107,3040175221,1184047435,2237026203,1455888051,2167382697,3231576897,508511947,2542247377,3248696317,4028245925,3155363671,1219062447,2011387899,2139939169,709060157,2258108217,110006243,4252292247,638802851,2736877823,2795406749,1052341587,2422361799,1841969195,1484035369,258230173,3175174007,4121510399,4026845425,161393927,827180647,1069338179,3331981075,208060269,921544335,854709859,1820886427,175608139,437869517,2453925301,1405793843,1777516161,36271049,3101338895,812998307,2468443513,581978513,1202898887,1522833759,4264367887,1257654929,2502408271,4059842889,1882868847,1308243013,3365964919,3051921749,1245508891,1251765947,3235765521,3673591757,1622473047,4113791999,2680935159,3149193739,2824069389,2305305589,2723071455,3003777033,2464037381,1428653631,2396646467,3092006779,3959318675,3251057157,2810022077,3692206077,1962448077,1351760689,2973811765,3629122639,172125155,2332139987,2168288921,298763119,2910108679,2842002439,1065085429,1635478389,285629523,3624686673,597434415,614157599,3236018567,2787928777,1033618677,3136583119,303042741,3425012419,2548206633,470562687,625425149,671807573,551959843,2498493315,1605428483,4240404689,355904355,1855728901,2323124573,3394383419,1161545443,4199672593,3367230127,1608362091,1193014065,3735918889,2077161049,66959977,4115104333,2243538907,74529575,2578031685,1217317847,3823318833,2111089643,4124518369,893463407,1612178047,3796064563,1425540505,2367911905,4230790671,3748084819,2103391445,4075846125,3932915073,3668943357,1036658947,55060861,2551531747,3928389015,4044946587,3643664629,377584287,3997916771,466452569,170715719,548063571,3391404375,2644142311,3940179165,2528406425,1069325097,886622413,2261510627,1708173989,1882729447,2799426931,1174138679,1164205993,277908081,714194507,3006087537,1883749417,2228543681,4063648481,3490718709,1427217261,3570403517,4145309411,93692121,2432392201,1961301613,1297973591,3598338261,602715919,95618263,2443483039,4193787913,195301411,208354271,601848287,4258418653,353589739,2517831379,803751265,3574336875,2276584741,1964020021,3711224219,2509205013,1976530323,1182079397,2036503543,1230374653,3203466937,511267251,1563774627,1290617629,755151545,3366536967,3585235489,1758879145,385785029,699004945,743465657,3448827303,2939428741,3096611785,2602831391,725117289,866751609,2213517597,2488519825,3317106147,1767140635,235721727,3997328395,4083625487,298866501,932928379,1615886459,2409701255,2074492309,1684232303,1154073759,1138961763,3706738345,3864031677,3501079215,681231693,1085304565,3271128065,3323353709,3467710973,3420872281,3995428975,3370259893,1330078457,657870205,3621728595,2282451559,1510786245,3775713853,1073658289,2048486065,878282993,3847475687,2580424415,692332681,3047081497,2544219235,4261790459,3718458561,295338841,396568723,3186536755,1144528987,1245323521,2416547623,2039915633,2565824009,3956332221,3735565991,4253037399,1126678099,1776925865,3879942177,2906224203,891426793,3551118995,3214288347,847287115,2813451477,574465455,2091092969,500479841,948650375,4224679473,1521410227,220746073,2441510613,872409617,3754977479,1690149997,923570161,2355578905,4089146323,1204529673,257563637,3141055383,459204387,2115233261,1104538001,380691013]} diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/runner.c b/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/runner.c deleted file mode 100644 index 5db586da8d00..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/test/fixtures/c/runner.c +++ /dev/null @@ -1,327 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2018 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -/** -* Generate C test fixtures. -* -* ## Notes -* -* - Run this script from the directory in which fixtures should be written. -* -*/ - -#include -#include - -/** -* Generates a linearly spaced numeric array of doubles. -* -* ## Notes -* -* - Assumes that the output array has at least 2 elements. -* - Output array is guaranteed to include both the start and end values. -* -* -* @param out output array -* @param len array length -* @param start first value -* @param end last value -*/ -void linspace_f64( double *out, const unsigned int len, const double start, const double end ) { - unsigned int i; - double incr; - - incr = (end-start) / (len-1); - for ( i = 0; i < len-1; i++ ) { - out[ i ] = start + (incr*i); - } - out[ i ] = end; -} - -/** -* Generates a linearly spaced numeric array of integers. -* -* ## Notes -* -* - Assumes that the output array has at least 2 elements. -* - Output array is guaranteed to include both the start and end values. -* -* -* @param out output array -* @param len array length -* @param start first value -* @param end last value -*/ -void linspace_ui32( unsigned int *out, const unsigned int len, const unsigned int start, const unsigned int end ) { - unsigned int incr; - unsigned int i; - - incr = (end-start) / (len-1); - for ( i = 0; i < len-1; i++ ) { - out[ i ] = start + (incr*i); - } - out[ i ] = end; -} - -/** -* Generates a random number on the interval [0,1]. -* -* @return random number -*/ -double rand_double() { - int r = rand(); - return (double)r / ( (double)RAND_MAX + 1.0 ); -} - -/** -* Generates an array of pseudorandom doubles drawn from a uniform distribution. -* -* @param out output array -* @param len array length -* @param a lower bound (inclusive) -* @param b upper bound (exclusive) -*/ -void rand_array_f64( double *out, const unsigned int len, const double a, const double b ) { - unsigned int i; - double delta; - - delta = b - a; - - for ( i = 0; i < len; i++ ) { - out[ i ] = a + ( rand_double()*delta ); - } -} - -/** -* Generates an array of pseudorandom integers drawn from a uniform distribution. -* -* ## Notes -* -* - WARNING: the method used here is not particularly robust, as some integer values may be sampled more frequently than others. -* -* -* @param out output array -* @param len array length -* @param a lower bound (inclusive) -* @param b upper bound (exclusive) -*/ -void rand_array_ui32( unsigned int *out, const unsigned int len, const unsigned int a, const unsigned int b ) { - unsigned int i; - unsigned int r; - double delta; - - delta = (double)b - (double)a; - - for ( i = 0; i < len; i++ ) { - r = (unsigned int)( delta * rand_double() ); // truncation - out[ i ] = a + r; - } -} - -/** -* Casts an array of integers to an array of doubles. -* -* @param out output array -* @param x input array -* @param len array length -*/ -void ui32_to_f64( double *out, unsigned int *x, unsigned int len ) { - unsigned int i; - - for ( i = 0; i < len; i++ ) { - out[ i ] = (double) x[ i ]; - } -} - -/** -* Casts an array of doubles to an array of integers. -* -* @param out output array -* @param x input array -* @param len array length -*/ -void f64_to_ui32( unsigned int *out, double *x, unsigned int len ) { - unsigned int i; - - for ( i = 0; i < len; i++ ) { - out[ i ] = (unsigned int) x[ i ]; - } -} - -/** -* Writes an array of doubles to a file as a series of comma-separated values. -* -* @param f file to write to -* @param x array of doubles -* @param len array length -*/ -void write_array_f64( FILE *f, const double *x, const unsigned int len ) { - unsigned int i; - - for ( i = 0; i < len; i++ ) { - fprintf( f, "%.17g", x[ i ] ); - if ( i < len-1 ) { - fprintf( f, "," ); - } - } -} - -/** -* Writes an array of integers to a file as a series of comma-separated values. -* -* @param f file to write to -* @param x array of integers -* @param len array length -*/ -void write_array_ui32( FILE *f, const unsigned int *x, const unsigned int len ) { - unsigned int i; - - for ( i = 0; i < len; i++ ) { - fprintf( f, "%u", x[ i ] ); - if ( i < len-1 ) { - fprintf( f, "," ); - } - } -} - -/** -* Writes a named array of doubles to a file as JSON. -* -* @param f file to write to -* @param name array name -* @param x data -* @param len array length -*/ -void write_named_array_f64( FILE *f, const char *name, const double *x, const unsigned int len ) { - fprintf( f, "\"%s\":[", name ); - write_array_f64( f, x, len ); - fprintf( f, "]" ); -} - -/** -* Writes a named array of integers to a file as JSON. -* -* @param f file to write to -* @param name array name -* @param x data -* @param len array length -*/ -void write_named_array_ui32( FILE *f, const char *name, const unsigned int *x, const unsigned int len ) { - fprintf( f, "\"%s\":[", name ); - write_array_ui32( f, x, len ); - fprintf( f, "]" ); -} - -/** -* Writes data to a file as JSON. -* -* ## Notes -* -* - This function SHOULD be tailored to the input data (e.g., input types, output types, number of arguments, etc) and may vary from use case to use case. -* -* -* @param f file to write to -* @param a domain -* @param b domain -* @param y results -* @param len array length -*/ -void write_data_as_json( FILE *f, const unsigned int *a, const unsigned int *b, const unsigned int *y, const unsigned int len ) { - fprintf( f, "{" ); - write_named_array_ui32( f, "a", a, len ); - fprintf( f, "," ); - write_named_array_ui32( f, "b", b, len ); - fprintf( f, "," ); - write_named_array_ui32( f, "expected", y, len ); - fprintf( f, "}" ); -} - -/** -* Generates test fixtures. -* -* @param a domain -* @param b domain -* @param len number of values in the domain -* @param name output filename -*/ -void generate( unsigned int *a, unsigned int *b, const unsigned int len, const char *name ) { - unsigned int i; - unsigned int *y; - FILE *f; - - // Allocate an output array: - y = (unsigned int*) malloc( len * sizeof(unsigned int) ); - if ( y == NULL ) { - printf( "Error allocating memory.\n" ); - exit( 1 ); - } - - // Generate fixture data: - for ( i = 0; i < len; i++ ) { - y[ i ] = a[ i ] * b[ i ]; - } - // Open a new file: - f = fopen( name, "w" ); - if ( f == NULL ) { - printf( "Error opening file.\n" ); - exit( 1 ); - } - // Write data as JSON: - write_data_as_json( f, a, b, y, len ); - - // Close the file: - fclose( f ); - - // Free allocated memory: - free( y ); -} - -/** -* Main execution sequence. -*/ -int main( void ) { - unsigned int len; - unsigned int *a; - unsigned int *b; - - // Define the array length: - len = 5000; - - // Allocate arrays: - a = (unsigned int*) malloc( len * sizeof(unsigned int) ); - if ( a == NULL ) { - printf( "Error allocating memory.\n" ); - exit( 1 ); - } - b = (unsigned int*) malloc( len * sizeof(unsigned int) ); - if ( b == NULL ) { - printf( "Error allocating memory.\n" ); - exit( 1 ); - } - - // Generate fixture data: - rand_array_ui32( a, len, 0, 4294967295 ); - rand_array_ui32( b, len, 0, 4294967295 ); - generate( a, b, len, "data.json" ); - - // Free allocated memory: - free( a ); - free( b ); - - return 0; -} diff --git a/lib/node_modules/@stdlib/math/base/ops/umul/test/test.js b/lib/node_modules/@stdlib/math/base/ops/umul/test/test.js deleted file mode 100644 index cc4e0b3fb00f..000000000000 --- a/lib/node_modules/@stdlib/math/base/ops/umul/test/test.js +++ /dev/null @@ -1,55 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2018 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var tape = require( 'tape' ); -var umul = require( './../lib' ); - - -// FIXTURES // - -var data = require( './fixtures/c/data.json' ); - - -// TESTS // - -tape( 'main export is a function', function test( t ) { - t.ok( true, __filename ); - t.strictEqual( typeof umul, 'function', 'main export is a function' ); - t.end(); -}); - -tape( 'the function emulates C-like multiplication of two unsigned 32-bit integers', function test( t ) { - var expected; - var actual; - var a; - var b; - var i; - - a = data.a; - b = data.b; - expected = data.expected; - for ( i = 0; i < expected.length; i++ ) { - actual = umul( a[ i ], b[ i ] ); - t.strictEqual( actual, expected[ i ], 'returns expected value. a: '+a[i]+'. b: '+b[i]+'. expected: '+expected[i]+'. actual: '+actual+'.' ); - } - t.end(); -});