From e62ac29f1d08c870b270b4955041ff10d0d83321 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 14 Feb 2025 00:04:58 -0300 Subject: [PATCH 01/96] initial implementation --- README.md | 88 +++++++ script/DSPCDeploy.s.sol | 61 +++++ script/input/1/README.md | 25 ++ script/input/1/template-dspc-deploy.json | 3 + script/output/1/README.md | 1 + src/DSPC.sol | 290 ++++++++++++++++++++++ src/DSPC.t.sol | 291 +++++++++++++++++++++++ src/DSPCMom.sol | 97 ++++++++ src/DSPCMom.t.sol | 161 +++++++++++++ src/deployment/DSPCDeploy.sol | 42 ++++ src/deployment/DSPCInit.sol | 39 +++ src/deployment/DSPCInstance.sol | 25 ++ src/mocks/AuthorityMock.sol | 77 ++++++ src/mocks/ConvMock.sol | 103 ++++++++ 14 files changed, 1303 insertions(+) create mode 100644 README.md create mode 100644 script/DSPCDeploy.s.sol create mode 100644 script/input/1/README.md create mode 100644 script/input/1/template-dspc-deploy.json create mode 100644 script/output/1/README.md create mode 100644 src/DSPC.sol create mode 100644 src/DSPC.t.sol create mode 100644 src/DSPCMom.sol create mode 100644 src/DSPCMom.t.sol create mode 100644 src/deployment/DSPCDeploy.sol create mode 100644 src/deployment/DSPCInit.sol create mode 100644 src/deployment/DSPCInstance.sol create mode 100644 src/mocks/AuthorityMock.sol create mode 100644 src/mocks/ConvMock.sol diff --git a/README.md b/README.md new file mode 100644 index 0000000..51553e0 --- /dev/null +++ b/README.md @@ -0,0 +1,88 @@ +# Direct Stability Parameters Change Module (DSPC) + +A module for MakerDAO that enables direct changes to stability parameters (duty, dsr, ssr) through a simple, secure interface with proper constraints and timelocks. + +## Overview + +The DSPC module provides a streamlined way to modify stability parameters in the Maker Protocol, including: +- Stability fees (duty) for different collateral types via the Jug contract +- Dai Savings Rate (DSR) via the Pot contract +- Staked Dai Savings Rate (SSR) via the sUSD contract + +## Features + +- Batch updates for multiple rate changes +- Two-level access control: + - Admins can configure the module + - Facilitators can propose and execute rate changes +- Rate change constraints: + - Min/max caps per rate + - Maximum change (gap) per update +- Event emission for all actions +- Simple, auditable implementation + +## Installation + +```bash +forge install +``` + +## Testing + +```bash +forge test +``` + +## Usage + +1. Deploy the contract with the required addresses: +```solidity +DSPC dspc = new DSPC( + jugAddress, // For stability fees + potAddress, // For DSR + susdsAddress, // For SSR + convAddress // For rate conversions +); +``` + +2. Configure the module parameters: +```solidity +// Set timelock duration +dspc.file("lag", 1 days); + +// Configure constraints for a collateral type +dspc.file("ETH-A", "min", 1); // Min rate: 0.01% +dspc.file("ETH-A", "max", 1000); // Max rate: 10% +dspc.file("ETH-A", "step", 100); // Max change: 1% + +// Configure constraints for DSR +dspc.file("DSR", "min", 1); // Min rate: 0.01% +dspc.file("DSR", "max", 800); // Max rate: 8% +dspc.file("DSR", "step", 50); // Max change: 0.5% +``` + +3. Add facilitators who can propose and execute rate changes: +```solidity +dspc.kiss(facilitatorAddress); +``` + +4. Execute a batch of rate changes: +```solidity +DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); +updates[0] = DSPC.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% +updates[1] = DSPC.ParamChange("DSR", 75); // Set DSR to 0.75% +dspc.put(updates); +``` + +## Security + +The module implements a robust security model: +- Two-level access control (admins and facilitators) +- Rate constraints to prevent extreme changes +- Disabling without GSM delay via DSPCMom contract +- Circuit breaker (halt) functionality +- All actions emit events for transparency + +## License + +AGPL-3.0-or-later diff --git a/script/DSPCDeploy.s.sol b/script/DSPCDeploy.s.sol new file mode 100644 index 0000000..41ca71f --- /dev/null +++ b/script/DSPCDeploy.s.sol @@ -0,0 +1,61 @@ +// SPDX-FileCopyrightText: © 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +pragma solidity ^0.8.24; + +import {Script} from "forge-std/Script.sol"; +import {stdJson} from "forge-std/StdJson.sol"; +import {MCD, DssInstance} from "dss-test/MCD.sol"; +import {ScriptTools} from "dss-test/ScriptTools.sol"; +import {DSPCDeploy, DSPCDeployParams} from "src/deployment/DSPCDeploy.sol"; +import {DSPCInstance} from "src/deployment/DSPCInstance.sol"; + +contract DSPCDeployScript is Script { + using stdJson for string; + using ScriptTools for string; + + string constant NAME = "dspc-deploy"; + string config; + + address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; + DssInstance dss = MCD.loadFromChainlog(CHAINLOG); + address pauseProxy = dss.chainlog.getAddress("MCD_PAUSE_PROXY"); + address conv; + DSPCInstance inst; + + function run() external { + config = ScriptTools.loadConfig(); + conv = config.readAddress(".conv", "FOUNDRY_CONV"); + + vm.startBroadcast(); + + inst = DSPCDeploy.deploy( + DSPCDeployParams({ + deployer: msg.sender, + owner: pauseProxy, + jug: address(dss.jug), + pot: address(dss.pot), + susds: dss.chainlog.getAddress("SUSDS"), + conv: conv + }) + ); + + vm.stopBroadcast(); + + ScriptTools.exportContract(NAME, "dspc", address(inst.dspc)); + ScriptTools.exportContract(NAME, "mom", address(inst.mom)); + ScriptTools.exportContract(NAME, "conv", conv); + } +} diff --git a/script/input/1/README.md b/script/input/1/README.md new file mode 100644 index 0000000..35031d9 --- /dev/null +++ b/script/input/1/README.md @@ -0,0 +1,25 @@ +# Network 1 (Ethereum Mainnet) Deployment Configuration + +This directory contains the configuration files for deploying DSPC on Ethereum Mainnet. + +## Files + +### dspc-deploy.json +Configuration for deploying DSPC and DSPCMom contracts: +- `conv`: Address of the converter contract that handles rate conversions between basis points and ray format + +## Usage + +1. Copy `template-dspc-deploy.json` into a new file (i.e.: `dspc-deploy.json`) +2. Edit the new file with the correct `conv` address +3. Run the deployment script: +```bash +FOUNDRY_SCRIPT_CONFIG=dspc-deploy forge script script/DSPCDeploy.s.sol:DSPCDeployScript \ + --rpc-url $ETH_RPC_URL \ + --broadcast + +The deployment script will: +1. Load system addresses from chainlog (jug, pot, susds) +2. Deploy DSPC and DSPCMom contracts +3. Set up permissions (mom owned by pause proxy, mom has authority over DSPC) +4. Export addresses to `/script/output/1/dspc-deploy.json` diff --git a/script/input/1/template-dspc-deploy.json b/script/input/1/template-dspc-deploy.json new file mode 100644 index 0000000..daceed2 --- /dev/null +++ b/script/input/1/template-dspc-deploy.json @@ -0,0 +1,3 @@ +{ + "conv": "address: the address of the rate conversion contract." +} diff --git a/script/output/1/README.md b/script/output/1/README.md new file mode 100644 index 0000000..d279227 --- /dev/null +++ b/script/output/1/README.md @@ -0,0 +1 @@ +Outputs for Mainnet scripts. \ No newline at end of file diff --git a/src/DSPC.sol b/src/DSPC.sol new file mode 100644 index 0000000..3ae1df3 --- /dev/null +++ b/src/DSPC.sol @@ -0,0 +1,290 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +interface JugLike { + function file(bytes32 ilk, bytes32 what, uint256 data) external; + function ilks(bytes32 ilk) external view returns (uint256 duty, uint256 rho); + function drip(bytes32 ilk) external; +} + +interface PotLike { + function file(bytes32 what, uint256 data) external; + function dsr() external view returns (uint256); + function drip() external; +} + +interface SUSDSLike { + function file(bytes32 what, uint256 data) external; + function ssr() external view returns (uint256); + function drip() external; +} + +interface ConvLike { + function btor(uint256 bps) external pure returns (uint256 ray); + function rtob(uint256 ray) external pure returns (uint256 bps); +} + +/// @title Direct Stability Parameters Change Module +/// @notice A module that allows direct changes to stability parameters with constraints +/// @dev This contract manages stability parameters for ilks, DSR, and SSR with configurable limits +/// @custom:authors [Oddaf] +/// @custom:reviewers [] +/// @custom:auditors [] +/// @custom:bounties [] +contract DSPC { + // --- Structs --- + struct Cfg { + uint16 min; // Minimum rate in basis points + uint16 max; // Maximum rate in basis points + uint16 step; // Maximum rate change in basis points + } + + struct ParamChange { + bytes32 id; // Identifier (ilk | "DSR" | "SSR") + uint256 bps; // New rate in basis points + } + + // --- Immutables --- + /// @notice Stability fee rates + JugLike public immutable jug; + /// @notice DSR rate + PotLike public immutable pot; + /// @notice SSR rate + SUSDSLike public immutable susds; + /// @notice Rate conversion utility + ConvLike public immutable conv; + + // --- Storage Variables --- + /// @notice Mapping of admin addresses + mapping(address => uint256) public wards; + /// @notice Mapping of addresses that can operate this module + mapping(address => uint256) public buds; + /// @notice Mapping of rate constraints + mapping(bytes32 => Cfg) private _cfgs; + /// @notice Circuit breaker flag + uint256 public bad; + + // --- Events --- + /** + * @notice `usr` was granted admin access. + * @param usr The user address. + */ + event Rely(address indexed usr); + /** + * @notice `usr` admin access was revoked. + * @param usr The user address. + */ + event Deny(address indexed usr); + /** + * @notice `usr` was granted permission to change rates (call put()). + * @param usr The user address. + */ + event Kiss(address indexed usr); + /** + * @notice Permission revoked for `usr` to change rates (call put()). + * @param usr The user address. + */ + event Diss(address indexed usr); + /** + * @notice A contract parameter was updated. + * @param what The changed parameter name. ["bad"]. + * @param data The new value of the parameter. + */ + event File(bytes32 indexed what, uint256 data); + /** + * @notice A Ilk/DSR/SSR parameter was updated. + * @param id The Ilk/DSR/SSR identifier. + * @param what The changed parameter name. ["bad"]. + * @param data The new value of the parameter. + */ + event File(bytes32 indexed id, bytes32 indexed what, uint256 data); + /** + * @notice A batch of rate changes was executed. + * @param updates Array of rate updates. + */ + event Put(ParamChange[] updates); + + // --- Modifiers --- + modifier auth() { + require(wards[msg.sender] == 1, "DSPC/not-authorized"); + _; + } + + modifier toll() { + require(buds[msg.sender] == 1, "DSPC/not-facilitator"); + _; + } + + modifier good() { + require(bad == 0, "DSPC/module-halted"); + _; + } + + /// @notice Constructor sets the core contracts + /// @param _jug The Jug contract for managing stability fees + /// @param _pot The Pot contract for managing DSR + /// @param _susds The SUSDS contract for managing SSR + /// @param _conv The conversion utility contract for rate calculations + constructor(address _jug, address _pot, address _susds, address _conv) { + jug = JugLike(_jug); + pot = PotLike(_pot); + susds = SUSDSLike(_susds); + conv = ConvLike(_conv); + + wards[msg.sender] = 1; + emit Rely(msg.sender); + } + + // --- Administration --- + /// @notice Grant authorization to an address + /// @param usr The address to be authorized + /// @dev Sets wards[usr] to 1 and emits Rely event + function rely(address usr) external auth { + wards[usr] = 1; + emit Rely(usr); + } + + /// @notice Revoke authorization from an address + /// @param usr The address to be deauthorized + /// @dev Sets wards[usr] to 0 and emits Deny event + function deny(address usr) external auth { + wards[usr] = 0; + emit Deny(usr); + } + + /// @notice Add a facilitator + /// @param usr The address to add as a facilitator + /// @dev Sets buds[usr] to 1 and emits Kiss event. Facilitators can propose rate updates but cannot modify system parameters + function kiss(address usr) external auth { + buds[usr] = 1; + emit Kiss(usr); + } + + /// @notice Remove a facilitator + /// @param usr The address to remove as a facilitator + /// @dev Sets buds[usr] to 0 and emits Diss event + function diss(address usr) external auth { + buds[usr] = 0; + emit Diss(usr); + } + + /// @notice Configure module parameters + /// @param what The parameter to configure (only "bad" is supported) + /// @param data The value to set (must be 0 or 1 for "bad") + /// @dev Emits File event after successful configuration + function file(bytes32 what, uint256 data) external auth { + if (what == "bad") { + require(data <= 1, "DSPC/invalid-bad-value"); + bad = data; + } else { + revert("DSPC/file-unrecognized-param"); + } + + emit File(what, data); + } + + /// @notice Configure constraints for a rate + /// @param id The rate identifier (ilk name, "DSR", or "SSR") + /// @param what The parameter to configure ("min", "max", or "step") + /// @param data The value to set (must be greater than 0) + /// @dev Emits File event after successful configuration + function file(bytes32 id, bytes32 what, uint256 data) external auth { + if (what == "min") { + _cfgs[id].min = uint16(data); + } else if (what == "max") { + require(data > 0, "DSPC/invalid-max"); + _cfgs[id].max = uint16(data); + } else if (what == "step") { + require(data > 0, "DSPC/invalid-step"); + _cfgs[id].step = uint16(data); + } else { + revert("DSPC/file-unrecognized-param"); + } + + emit File(id, what, data); + } + + /// @notice Apply rate updates + /// @param updates Array of rate updates to apply + /// @dev Each update is validated against configured constraints before being applied + /// @dev Emits Put event after all updates are successfully applied + /// @dev Reverts if: + /// - Empty updates array + /// - Rate below configured minimum + /// - Rate above configured maximum + /// - Rate change exceeds configured step size + function put(ParamChange[] calldata updates) external toll good { + require(updates.length > 0, "DSPC/empty-batch"); + + // Validate all updates in the batch + for (uint256 i = 0; i < updates.length; i++) { + bytes32 id = updates[i].id; + uint256 bps = updates[i].bps; + Cfg memory cfg = _cfgs[id]; + + require(bps >= cfg.min, "DSPC/below-min"); + require(bps <= cfg.max, "DSPC/above-max"); + + // Check rate change is within allowed gap + uint256 oldBps; + if (id == "DSR") { + oldBps = conv.rtob(PotLike(pot).dsr()); + } else if (id == "SSR") { + oldBps = conv.rtob(SUSDSLike(susds).ssr()); + } else { + (uint256 duty,) = JugLike(jug).ilks(id); + oldBps = conv.rtob(duty); + } + + uint256 delta = _absDiff(bps, oldBps); + require(delta <= cfg.step, "DSPC/delta-above-step"); + + // Execute the update + uint256 ray = conv.btor(bps); + if (id == "DSR") { + pot.drip(); + pot.file("dsr", ray); + } else if (id == "SSR") { + susds.drip(); + susds.file("ssr", ray); + } else { + jug.drip(id); + jug.file(id, "duty", ray); + } + } + + emit Put(updates); + } + + /// @notice Calculates absolute difference between two uint256 values + /// @param a The first uint256 value + /// @param b The second uint256 value + /// @return delta The absolute difference between the parameters + function _absDiff(uint256 a, uint256 b) internal pure returns (uint256 delta) { + delta = a > b ? a - b : b - a; + } + + // --- Getters --- + /// @notice Get configuration for a rate + /// @param id The rate identifier (ilk name, "DSR", or "SSR") + /// @return The configuration struct containing min, max, and step values + /// @dev Returns a Cfg struct with min, max, and step values for the specified rate + function cfgs(bytes32 id) external view returns (Cfg memory) { + return _cfgs[id]; + } +} diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol new file mode 100644 index 0000000..76f5d1e --- /dev/null +++ b/src/DSPC.t.sol @@ -0,0 +1,291 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +pragma solidity ^0.8.24; + +import "dss-test/DssTest.sol"; +import {DSPC} from "./DSPC.sol"; +import {DSPCMom} from "./DSPCMom.sol"; +import {ConvMock} from "./mocks/ConvMock.sol"; +import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; +import {DSPCInit} from "./deployment/DSPCInit.sol"; +import {DSPCInstance} from "./deployment/DSPCInstance.sol"; + +interface ConvLike { + function btor(uint256 bps) external pure returns (uint256 ray); + function rtob(uint256 ray) external pure returns (uint256 bps); +} + +interface SUSDSLike { + function wards(address usr) external view returns (uint256); + function ssr() external view returns (uint256); +} + +interface ProxyLike { + function exec(address usr, bytes memory fax) external returns (bytes memory out); +} + +contract InitCaller { + function init(DssInstance memory dss, DSPCInstance memory inst) external { + DSPCInit.init(dss, inst); + } +} + +contract DSPCTest is DssTest { + address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; + + DssInstance dss; + DSPC dspc; + DSPCMom mom; + ConvLike conv; + SUSDSLike susds; + address pause; + ProxyLike pauseProxy; + InitCaller caller; + address bud = address(0xb0d); + + bytes32 constant ILK = "ETH-A"; + bytes32 constant DSR = "DSR"; + bytes32 constant SSR = "SSR"; + + event Kiss(address indexed usr); + event Diss(address indexed usr); + event File(bytes32 indexed id, bytes32 indexed what, uint256 data); + event Put(DSPC.ParamChange[] updates); + + function setUp() public { + vm.createSelectFork("mainnet"); + dss = MCD.loadFromChainlog(CHAINLOG); + pause = dss.chainlog.getAddress("MCD_PAUSE"); + pauseProxy = ProxyLike(dss.chainlog.getAddress("MCD_PAUSE_PROXY")); + susds = SUSDSLike(dss.chainlog.getAddress("SUSDS")); + MCD.giveAdminAccess(dss); + + caller = new InitCaller(); + + conv = ConvLike(address(new ConvMock())); + + DSPCInstance memory inst = DSPCDeploy.deploy( + DSPCDeployParams({ + deployer: address(this), + owner: address(pauseProxy), + jug: address(dss.jug), + pot: address(dss.pot), + susds: address(susds), + conv: address(conv) + }) + ); + dspc = inst.dspc; + mom = inst.mom; + + // Simulate a spell casting + vm.prank(pause); + pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst))); + + // The init script does not cover setting ilk specific parameters + vm.startPrank(address(pauseProxy)); + { + dspc.file(ILK, "min", 1); + dspc.file(ILK, "max", 30000); + dspc.file(ILK, "step", 50); + dspc.file(DSR, "min", 1); + dspc.file(DSR, "max", 30000); + dspc.file(DSR, "step", 50); + dspc.file(SSR, "min", 1); + dspc.file(SSR, "max", 30000); + dspc.file(SSR, "step", 50); + dspc.kiss(bud); + } + vm.stopPrank(); + } + + function test_constructor() public view { + assertEq(address(dspc.jug()), address(dss.jug)); + assertEq(address(dspc.pot()), address(dss.pot)); + assertEq(address(dspc.susds()), address(susds)); + assertEq(address(dspc.conv()), address(conv)); + + // init + assertEq(dspc.wards(address(this)), 0); + assertEq(dspc.wards(address(pauseProxy)), 1); + assertEq(dspc.wards(address(mom)), 1); + assertEq(mom.authority(), dss.chainlog.getAddress("MCD_ADM")); + assertEq(dss.jug.wards(address(dspc)), 1); + assertEq(dss.pot.wards(address(dspc)), 1); + assertEq(SUSDSLike(dss.chainlog.getAddress("SUSDS")).wards(address(dspc)), 1); + } + + function test_auth() public { + checkAuth(address(dspc), "DSPC"); + } + + function test_file_bad() public { + vm.startPrank(address(pauseProxy)); + + assertEq(dspc.bad(), 0); + dspc.file("bad", 1); + assertEq(dspc.bad(), 1); + + vm.expectRevert("DSPC/invalid-bad-value"); + dspc.file("bad", 2); + + vm.expectRevert("DSPC/file-unrecognized-param"); + dspc.file("unknown", 1); + + vm.stopPrank(); + } + + function test_file_ilk() public { + assertEq(dspc.cfgs(ILK).min, 1); + assertEq(dspc.cfgs(ILK).max, 30000); + assertEq(dspc.cfgs(ILK).step, 50); + + vm.startPrank(address(pauseProxy)); + dspc.file(ILK, "min", 100); + dspc.file(ILK, "max", 3000); + dspc.file(ILK, "step", 100); + vm.stopPrank(); + + assertEq(dspc.cfgs(ILK).min, 100); + assertEq(dspc.cfgs(ILK).max, 3000); + assertEq(dspc.cfgs(ILK).step, 100); + } + + function test_file_ilk_invalid() public { + vm.startPrank(address(pauseProxy)); + + vm.expectRevert("DSPC/invalid-max"); + dspc.file(ILK, "max", 0); + + vm.expectRevert("DSPC/invalid-step"); + dspc.file(ILK, "step", 0); + + vm.expectRevert("DSPC/file-unrecognized-param"); + dspc.file(ILK, "unknown", 100); + + vm.stopPrank(); + } + + function test_put_ilk() public { + (uint256 duty,) = dss.jug.ilks(ILK); + uint256 target = conv.rtob(duty) + 50; + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, target); + + vm.prank(bud); + dspc.put(updates); + + (duty,) = dss.jug.ilks(ILK); + assertEq(duty, conv.btor(target)); + } + + function test_put_dsr() public { + uint256 target = conv.rtob(dss.pot.dsr()) + 50; + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(DSR, target); + + vm.prank(bud); + dspc.put(updates); + + assertEq(dss.pot.dsr(), conv.btor(target)); + } + + function test_put_ssr() public { + vm.prank(bud); + uint256 target = conv.rtob(susds.ssr()) - 50; + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(SSR, target); + + vm.prank(bud); + dspc.put(updates); + + assertEq(susds.ssr(), conv.btor(target)); + } + + function test_put_multiple() public { + (uint256 duty,) = dss.jug.ilks(ILK); + uint256 ilkTarget = conv.rtob(duty) - 50; + uint256 dsrTarget = conv.rtob(dss.pot.dsr()) - 50; + uint256 ssrTarget = conv.rtob(susds.ssr()) + 50; + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](3); + updates[0] = DSPC.ParamChange(ILK, ilkTarget); + updates[1] = DSPC.ParamChange(DSR, dsrTarget); + updates[2] = DSPC.ParamChange(SSR, ssrTarget); + + vm.prank(bud); + dspc.put(updates); + + (duty,) = dss.jug.ilks(ILK); + assertEq(duty, conv.btor(ilkTarget)); + assertEq(dss.pot.dsr(), conv.btor(dsrTarget)); + assertEq(susds.ssr(), conv.btor(ssrTarget)); + } + + function test_put_empty() public { + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); + + vm.expectRevert("DSPC/empty-batch"); + vm.prank(bud); + dspc.put(updates); + } + + function test_put_unauthorized() public { + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 100); + + vm.expectRevert("DSPC/not-facilitator"); + dspc.put(updates); + } + + function test_put_below_min() public { + vm.prank(address(pauseProxy)); + dspc.file(ILK, "min", 100); + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 50); + + vm.expectRevert("DSPC/below-min"); + vm.prank(bud); + dspc.put(updates); + } + + function test_put_above_max() public { + vm.prank(address(pauseProxy)); + dspc.file(ILK, "max", 100); + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 150); + + vm.expectRevert("DSPC/above-max"); + vm.prank(bud); + dspc.put(updates); + } + + function test_put_above_step() public { + vm.prank(address(pauseProxy)); + dspc.file(ILK, "step", 50); + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 100); + + vm.expectRevert("DSPC/delta-above-step"); + vm.prank(bud); + dspc.put(updates); + } +} diff --git a/src/DSPCMom.sol b/src/DSPCMom.sol new file mode 100644 index 0000000..32cc4da --- /dev/null +++ b/src/DSPCMom.sol @@ -0,0 +1,97 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +interface AuthorityLike { + function canCall(address src, address dst, bytes4 sig) external view returns (bool); +} + +interface DSPCLike { + function file(bytes32 what, uint256 data) external; +} + +/// @title DSPC Mom - Emergency shutdown for DSPC +/// @notice A contract that can halt the DSPC module in case of emergency +/// @custom:authors [Oddaf] +/// @custom:reviewers [] +/// @custom:auditors [] +/// @custom:bounties [] +contract DSPCMom { + // --- Auth --- + address public owner; // Owner address + address public authority; // Authorization contract + + // --- Events --- + event SetOwner(address indexed owner); + event SetAuthority(address indexed authority); + event Halt(address indexed dspc); + + // --- Modifiers --- + modifier onlyOwner() { + require(msg.sender == owner, "DSPCMom/not-owner"); + _; + } + + modifier auth() { + require(isAuthorized(msg.sender, msg.sig), "DSPCMom/not-authorized"); + _; + } + + /// @notice Constructor sets initial owner + constructor() { + owner = msg.sender; + emit SetOwner(msg.sender); + } + + // --- Administration --- + /// @notice Set a new owner + /// @param owner_ The new owner address + function setOwner(address owner_) external onlyOwner { + owner = owner_; + emit SetOwner(owner_); + } + + /// @notice Set the authority contract + /// @param authority_ The new authority contract + function setAuthority(address authority_) external onlyOwner { + authority = authority_; + emit SetAuthority(authority_); + } + + // --- Internal Functions --- + /// @notice Check if an address is authorized to call a function + /// @param src The source address making the call + /// @param sig The function signature being called + /// @return Whether the address is authorized + function isAuthorized(address src, bytes4 sig) internal view returns (bool) { + if (src == owner || src == address(this)) { + return true; + } else if (authority != address(0)) { + return AuthorityLike(authority).canCall(src, address(this), sig); + } else { + return false; + } + } + + // --- Emergency Actions --- + /// @notice Halt the DSPC module without enforcing the GSM delay + /// @param dspc The DSPC contract to halt + function halt(address dspc) external auth { + DSPCLike(dspc).file("bad", 1); + emit Halt(dspc); + } +} diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol new file mode 100644 index 0000000..5521436 --- /dev/null +++ b/src/DSPCMom.t.sol @@ -0,0 +1,161 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +import "dss-test/DssTest.sol"; +import {DSPC} from "./DSPC.sol"; +import {DSPCMom} from "./DSPCMom.sol"; +import {ConvMock} from "./mocks/ConvMock.sol"; +import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; +import {DSPCInit} from "./deployment/DSPCInit.sol"; +import {DSPCInstance} from "./deployment/DSPCInstance.sol"; + +interface ChiefLike { + function hat() external view returns (address); +} + +interface ConvLike { + function turn(uint256 bps) external pure returns (uint256 ray); + function back(uint256 ray) external pure returns (uint256 bps); +} + +interface SUSDSLike { + function ssr() external view returns (uint256); + function drip() external; +} + +interface ProxyLike { + function exec(address usr, bytes memory fax) external returns (bytes memory out); +} + +contract InitCaller { + function init(DssInstance memory dss, DSPCInstance memory inst) external { + DSPCInit.init(dss, inst); + } +} + +contract DSPCMomIntegrationTest is DssTest { + address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; + + // --- Events --- + event SetOwner(address indexed owner); + event SetAuthority(address indexed authority); + event Halt(address indexed dspc); + + DssInstance dss; + ChiefLike chief; + DSPC dspc; + DSPCMom mom; + ConvLike conv; + SUSDSLike susds; + address pause; + ProxyLike pauseProxy; + InitCaller caller; + + bytes32 constant ILK = "ETH-A"; + bytes32 constant DSR = "DSR"; + bytes32 constant SSR = "SSR"; + + function setUp() public { + vm.createSelectFork("mainnet"); + dss = MCD.loadFromChainlog(CHAINLOG); + chief = ChiefLike(dss.chainlog.getAddress("MCD_ADM")); + pause = dss.chainlog.getAddress("MCD_PAUSE"); + pauseProxy = ProxyLike(dss.chainlog.getAddress("MCD_PAUSE_PROXY")); + susds = SUSDSLike(dss.chainlog.getAddress("SUSDS")); + MCD.giveAdminAccess(dss); + + caller = new InitCaller(); + + conv = ConvLike(address(new ConvMock())); + + DSPCInstance memory inst = DSPCDeploy.deploy( + DSPCDeployParams({ + deployer: address(this), + owner: address(pauseProxy), + jug: address(dss.jug), + pot: address(dss.pot), + susds: address(susds), + conv: address(conv) + }) + ); + dspc = inst.dspc; + mom = inst.mom; + + // Simulate a spell casting + vm.prank(pause); + pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst))); + + // The init script does not cover setting ilk specific parameters + vm.startPrank(address(pauseProxy)); + { + dspc.file(ILK, "min", 1); + dspc.file(ILK, "max", 30000); + dspc.file(ILK, "step", 50); + dspc.file(DSR, "min", 1); + dspc.file(DSR, "max", 30000); + dspc.file(DSR, "step", 50); + dspc.file(SSR, "min", 1); + dspc.file(SSR, "max", 30000); + dspc.file(SSR, "step", 50); + } + vm.stopPrank(); + } + + function test_constructor() public view { + assertEq(mom.owner(), address(pauseProxy)); + } + + function test_setOwner() public { + vm.prank(address(pauseProxy)); + mom.setOwner(address(0x1234)); + assertEq(mom.owner(), address(0x1234)); + } + + function test_setOwner_unauthorized() public { + vm.expectRevert("DSPCMom/not-owner"); + mom.setOwner(address(0x123)); + } + + function test_setAuthority() public { + vm.prank(address(pauseProxy)); + mom.setAuthority(address(0x123)); + assertEq(address(mom.authority()), address(0x123)); + } + + function test_setAuthority_unauthorized() public { + vm.expectRevert("DSPCMom/not-owner"); + mom.setAuthority(address(0x123)); + } + + function test_halt_unauthorized() public { + vm.expectRevert("DSPCMom/not-authorized"); + mom.halt(address(dspc)); + } + + function test_halt_owner() public { + vm.prank(address(pauseProxy)); + mom.halt(address(dspc)); + assertEq(dspc.bad(), 1); + } + + function test_halt_hat() public { + vm.prank(chief.hat()); + mom.halt(address(dspc)); + assertEq(dspc.bad(), 1); + } +} diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol new file mode 100644 index 0000000..a0ab343 --- /dev/null +++ b/src/deployment/DSPCDeploy.sol @@ -0,0 +1,42 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +import {ScriptTools} from "dss-test/ScriptTools.sol"; +import {DSPC} from "../DSPC.sol"; +import {DSPCMom} from "../DSPCMom.sol"; +import {DSPCInstance} from "./DSPCInstance.sol"; + +struct DSPCDeployParams { + address deployer; + address owner; + address jug; + address pot; + address susds; + address conv; +} + +library DSPCDeploy { + function deploy(DSPCDeployParams memory params) internal returns (DSPCInstance memory inst) { + inst.dspc = new DSPC(params.jug, params.pot, params.susds, params.conv); + + inst.mom = new DSPCMom(); + + ScriptTools.switchOwner(address(inst.dspc), params.deployer, params.owner); + inst.mom.setOwner(params.owner); + } +} diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol new file mode 100644 index 0000000..ad3238f --- /dev/null +++ b/src/deployment/DSPCInit.sol @@ -0,0 +1,39 @@ +// SPDX-FileCopyrightText: © 2023 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +pragma solidity ^0.8.24; + +import {DssInstance} from "dss-test/MCD.sol"; +import {DSPCInstance} from "./DSPCInstance.sol"; + +interface SUSDSLike { + function rely(address usr) external; +} + +library DSPCInit { + /** + * @dev Initializes a DSPC instance. + * @param dss The DSS instance. + * @param inst The DSCP instance. + */ + function init(DssInstance memory dss, DSPCInstance memory inst) internal { + inst.dspc.rely(address(inst.mom)); + inst.mom.setAuthority(dss.chainlog.getAddress("MCD_ADM")); + + dss.jug.rely(address(inst.dspc)); + dss.pot.rely(address(inst.dspc)); + SUSDSLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); + } +} diff --git a/src/deployment/DSPCInstance.sol b/src/deployment/DSPCInstance.sol new file mode 100644 index 0000000..0f7d96f --- /dev/null +++ b/src/deployment/DSPCInstance.sol @@ -0,0 +1,25 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +import {DSPC} from "../DSPC.sol"; +import {DSPCMom} from "../DSPCMom.sol"; + +struct DSPCInstance { + DSPC dspc; + DSPCMom mom; +} diff --git a/src/mocks/AuthorityMock.sol b/src/mocks/AuthorityMock.sol new file mode 100644 index 0000000..efa6636 --- /dev/null +++ b/src/mocks/AuthorityMock.sol @@ -0,0 +1,77 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +/// @title Authority Mock - Mock implementation of DSAuthority for testing +contract AuthorityMock { + // --- Auth --- + mapping(address => uint256) public wards; // Admins + + // --- Access Control --- + mapping(address => mapping(address => mapping(bytes4 => uint256))) private _canCall; // src -> dst -> sig -> enabled + + // --- Events --- + event Rely(address indexed usr); + event Deny(address indexed usr); + event SetCanCall(address indexed src, address indexed dst, bytes4 indexed sig, bool enabled); + + // --- Modifiers --- + modifier auth() { + require(wards[msg.sender] == 1, "AuthorityMock/not-authorized"); + _; + } + + constructor() { + wards[msg.sender] = 1; + emit Rely(msg.sender); + } + + // --- Administration --- + /// @notice Add an admin + /// @param usr The address to add as an admin + function rely(address usr) external auth { + wards[usr] = 1; + emit Rely(usr); + } + + /// @notice Remove an admin + /// @param usr The address to remove as an admin + function deny(address usr) external auth { + wards[usr] = 0; + emit Deny(usr); + } + + // --- Permission Management --- + /// @notice Set whether a source address can call a specific function on a target contract + /// @param src The source address that wants to make the call + /// @param dst The target contract address + /// @param sig The function signature + /// @param enabled Whether to enable or disable the permission + function setCanCall(address src, address dst, bytes4 sig, bool enabled) external auth { + _canCall[src][dst][sig] = enabled ? 1 : 0; + emit SetCanCall(src, dst, sig, enabled); + } + + /// @notice Check if a source address can call a specific function on a target contract + /// @param src The source address that wants to make the call + /// @param dst The target contract address + /// @param sig The function signature + /// @return Whether the call is permitted + function canCall(address src, address dst, bytes4 sig) external view returns (bool) { + return _canCall[src][dst][sig] == 1; + } +} diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol new file mode 100644 index 0000000..a68ea5b --- /dev/null +++ b/src/mocks/ConvMock.sol @@ -0,0 +1,103 @@ +// SPDX-FileCopyrightText: © 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity 0.8.24; + +contract ConvMock { + /// @notice The max bps supported in bps -> rate conversion. + uint256 public constant MAX = 50_00; + /// @dev `ray` precision + uint256 internal constant RAY = 10 ** 27; + /// @dev `bps` precision + uint256 internal constant BPS = 100_00; + + // Each rate takes 8 bytes (64 bits), total of 5001 rates + // Each storage word (32 bytes) contains exactly 4 rates + // Total size = 5001 * 8 = 40008 bytes + bytes internal RATES; + + constructor() { + RATES = + hex"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"; + } + + /// @notice Fetches the rate for a given basis points value + /// @param bps The basis points value to get the rate for + /// @return ray The annual rate value + function btor(uint256 bps) public view returns (uint256 ray) { + require(bps <= MAX); + + assembly { + let offset := mul(bps, 8) // Each rate is 8 bytes + let wordPos := div(offset, 32) // Which 32-byte word to read + let bytePos := mod(offset, 32) // Position within the word + + let dataSlot := keccak256(RATES.slot, 0x20) + + let value := sload(add(dataSlot, wordPos)) + + let shifted := shr(mul(sub(24, bytePos), 8), value) + + ray := add(and(shifted, 0xFFFFFFFFFFFFFFFF), RAY) + } + } + + /// @notice Fetches the yearly bps rate for a given per second rate + /// @param ray The per second rate to get the rate for + /// @return bps The annual rate value + function rtob(uint256 ray) public pure returns (uint256 bps) { + // Convert per-second rate to per-year rate using rpow + uint256 yearlyRate = _rpow(ray, 365 days); + // Subtract RAY to get the yearly rate delta and convert to basis points + // Add RAY/2 for rounding: ensures values are rounded up when >= 0.5 and down when < 0.5 + return ((yearlyRate - RAY) * BPS + RAY / 2) / RAY; + } + + /// @notice Exponentiate `x` (RAY, 27 decimal places) to `n` () by squaring + /// @param x The base (RAY, 27 decimal places) + /// @param n The exponent (integer, 0 decimal places) + /// @return z The result + function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { + assembly { + switch x + case 0 { + switch n + case 0 { z := RAY } + default { z := 0 } + } + default { + switch mod(n, 2) + case 0 { z := RAY } + default { z := x } + let half := div(RAY, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n, 2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0, 0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0, 0) } + x := div(xxRound, RAY) + if mod(n, 2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0, 0) } + z := div(zxRound, RAY) + } + } + } + } + } +} From 13e9d959bdf9f3429eafab5c6cb0df8f0fd2fa09 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Feb 2025 23:45:03 -0300 Subject: [PATCH 02/96] Update script/input/1/README.md Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- script/input/1/README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/script/input/1/README.md b/script/input/1/README.md index 35031d9..cb44384 100644 --- a/script/input/1/README.md +++ b/script/input/1/README.md @@ -21,5 +21,4 @@ FOUNDRY_SCRIPT_CONFIG=dspc-deploy forge script script/DSPCDeploy.s.sol:DSPCDeplo The deployment script will: 1. Load system addresses from chainlog (jug, pot, susds) 2. Deploy DSPC and DSPCMom contracts -3. Set up permissions (mom owned by pause proxy, mom has authority over DSPC) 4. Export addresses to `/script/output/1/dspc-deploy.json` From 2d4ff02f17ffe550a3c7c8d5d020064440bfffbb Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Feb 2025 23:50:24 -0300 Subject: [PATCH 03/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 3ae1df3..b789bcc 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -117,7 +117,7 @@ contract DSPC { * @notice A batch of rate changes was executed. * @param updates Array of rate updates. */ - event Put(ParamChange[] updates); + event Set(ParamChange[] updates); // --- Modifiers --- modifier auth() { From 2bccdbec86d82e6746d63aef2d01566f49a9e3f9 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Feb 2025 23:50:37 -0300 Subject: [PATCH 04/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index b789bcc..74bff91 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -222,7 +222,7 @@ contract DSPC { /// @notice Apply rate updates /// @param updates Array of rate updates to apply /// @dev Each update is validated against configured constraints before being applied - /// @dev Emits Put event after all updates are successfully applied + /// @dev Emits Set event after all updates are successfully applied /// @dev Reverts if: /// - Empty updates array /// - Rate below configured minimum From 2c3f886a26d26cfbd8d770b6cb00f93365c45aaf Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Feb 2025 23:50:44 -0300 Subject: [PATCH 05/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 74bff91..143aa6e 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -228,7 +228,7 @@ contract DSPC { /// - Rate below configured minimum /// - Rate above configured maximum /// - Rate change exceeds configured step size - function put(ParamChange[] calldata updates) external toll good { + function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); // Validate all updates in the batch From 3c60b1fb2426799452835b430845fd06ac94ad31 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Feb 2025 23:50:52 -0300 Subject: [PATCH 06/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 143aa6e..c8c3eaa 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -268,7 +268,7 @@ contract DSPC { } } - emit Put(updates); + emit Set(updates); } /// @notice Calculates absolute difference between two uint256 values From 52a59f79069e81e1cefff8ee72ba2df27c53c7e9 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Feb 2025 00:08:19 -0300 Subject: [PATCH 07/96] refactor: rename function put to set --- README.md | 2 +- src/DSPC.t.sol | 38 +++++++++++++++++++------------------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 51553e0..25b6d20 100644 --- a/README.md +++ b/README.md @@ -71,7 +71,7 @@ dspc.kiss(facilitatorAddress); DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); updates[0] = DSPC.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% updates[1] = DSPC.ParamChange("DSR", 75); // Set DSR to 0.75% -dspc.put(updates); +dspc.set(updates); ``` ## Security diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 76f5d1e..4c5430b 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -63,7 +63,7 @@ contract DSPCTest is DssTest { event Kiss(address indexed usr); event Diss(address indexed usr); event File(bytes32 indexed id, bytes32 indexed what, uint256 data); - event Put(DSPC.ParamChange[] updates); + event Set(DSPC.ParamChange[] updates); function setUp() public { vm.createSelectFork("mainnet"); @@ -178,7 +178,7 @@ contract DSPCTest is DssTest { vm.stopPrank(); } - function test_put_ilk() public { + function test_set_ilk() public { (uint256 duty,) = dss.jug.ilks(ILK); uint256 target = conv.rtob(duty) + 50; @@ -186,25 +186,25 @@ contract DSPCTest is DssTest { updates[0] = DSPC.ParamChange(ILK, target); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(target)); } - function test_put_dsr() public { + function test_set_dsr() public { uint256 target = conv.rtob(dss.pot.dsr()) + 50; DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); updates[0] = DSPC.ParamChange(DSR, target); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); assertEq(dss.pot.dsr(), conv.btor(target)); } - function test_put_ssr() public { + function test_set_ssr() public { vm.prank(bud); uint256 target = conv.rtob(susds.ssr()) - 50; @@ -212,12 +212,12 @@ contract DSPCTest is DssTest { updates[0] = DSPC.ParamChange(SSR, target); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); assertEq(susds.ssr(), conv.btor(target)); } - function test_put_multiple() public { + function test_set_multiple() public { (uint256 duty,) = dss.jug.ilks(ILK); uint256 ilkTarget = conv.rtob(duty) - 50; uint256 dsrTarget = conv.rtob(dss.pot.dsr()) - 50; @@ -229,7 +229,7 @@ contract DSPCTest is DssTest { updates[2] = DSPC.ParamChange(SSR, ssrTarget); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(ilkTarget)); @@ -237,23 +237,23 @@ contract DSPCTest is DssTest { assertEq(susds.ssr(), conv.btor(ssrTarget)); } - function test_put_empty() public { + function test_set_empty() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); vm.expectRevert("DSPC/empty-batch"); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); } - function test_put_unauthorized() public { + function test_set_unauthorized() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); updates[0] = DSPC.ParamChange(ILK, 100); vm.expectRevert("DSPC/not-facilitator"); - dspc.put(updates); + dspc.set(updates); } - function test_put_below_min() public { + function test_set_below_min() public { vm.prank(address(pauseProxy)); dspc.file(ILK, "min", 100); @@ -262,10 +262,10 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/below-min"); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); } - function test_put_above_max() public { + function test_set_above_max() public { vm.prank(address(pauseProxy)); dspc.file(ILK, "max", 100); @@ -274,10 +274,10 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/above-max"); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); } - function test_put_above_step() public { + function test_set_above_step() public { vm.prank(address(pauseProxy)); dspc.file(ILK, "step", 50); @@ -286,6 +286,6 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/delta-above-step"); vm.prank(bud); - dspc.put(updates); + dspc.set(updates); } } From c04ef6c2f6015a1c7569d497802e6f1e7d59c6da Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Feb 2025 00:12:15 -0300 Subject: [PATCH 08/96] fix: add check if data can be safely cast to uint16 in file() --- src/DSPC.sol | 5 +++-- src/DSPC.t.sol | 5 ++++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index c8c3eaa..6a117ea 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -91,12 +91,12 @@ contract DSPC { */ event Deny(address indexed usr); /** - * @notice `usr` was granted permission to change rates (call put()). + * @notice `usr` was granted permission to change rates (call set()). * @param usr The user address. */ event Kiss(address indexed usr); /** - * @notice Permission revoked for `usr` to change rates (call put()). + * @notice Permission revoked for `usr` to change rates (call set()). * @param usr The user address. */ event Diss(address indexed usr); @@ -204,6 +204,7 @@ contract DSPC { /// @param data The value to set (must be greater than 0) /// @dev Emits File event after successful configuration function file(bytes32 id, bytes32 what, uint256 data) external auth { + require(data <= type(uint16).max, "DSPC/invalid-value"); if (what == "min") { _cfgs[id].min = uint16(data); } else if (what == "max") { diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 4c5430b..503161b 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -142,7 +142,7 @@ contract DSPCTest is DssTest { dspc.file("bad", 2); vm.expectRevert("DSPC/file-unrecognized-param"); - dspc.file("unknown", 1); + dspc.file("unknown", 1); vm.stopPrank(); } @@ -175,6 +175,9 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/file-unrecognized-param"); dspc.file(ILK, "unknown", 100); + vm.expectRevert("DSPC/invalid-value"); + dspc.file(ILK, "max", uint256(type(uint16).max) + 1); + vm.stopPrank(); } From d6ff178a357cd7ded3f642e3263d205487304ec3 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Feb 2025 00:19:42 -0300 Subject: [PATCH 09/96] refactor: remove step restriction --- README.md | 3 --- src/DSPC.sol | 25 +++---------------------- src/DSPC.t.sol | 21 --------------------- src/DSPCMom.t.sol | 3 --- 4 files changed, 3 insertions(+), 49 deletions(-) diff --git a/README.md b/README.md index 25b6d20..7c93ae1 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,6 @@ The DSPC module provides a streamlined way to modify stability parameters in the - Facilitators can propose and execute rate changes - Rate change constraints: - Min/max caps per rate - - Maximum change (gap) per update - Event emission for all actions - Simple, auditable implementation @@ -53,12 +52,10 @@ dspc.file("lag", 1 days); // Configure constraints for a collateral type dspc.file("ETH-A", "min", 1); // Min rate: 0.01% dspc.file("ETH-A", "max", 1000); // Max rate: 10% -dspc.file("ETH-A", "step", 100); // Max change: 1% // Configure constraints for DSR dspc.file("DSR", "min", 1); // Min rate: 0.01% dspc.file("DSR", "max", 800); // Max rate: 8% -dspc.file("DSR", "step", 50); // Max change: 0.5% ``` 3. Add facilitators who can propose and execute rate changes: diff --git a/src/DSPC.sol b/src/DSPC.sol index 6a117ea..7fb9725 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -51,7 +51,6 @@ contract DSPC { struct Cfg { uint16 min; // Minimum rate in basis points uint16 max; // Maximum rate in basis points - uint16 step; // Maximum rate change in basis points } struct ParamChange { @@ -200,7 +199,7 @@ contract DSPC { /// @notice Configure constraints for a rate /// @param id The rate identifier (ilk name, "DSR", or "SSR") - /// @param what The parameter to configure ("min", "max", or "step") + /// @param what The parameter to configure ("min", "max") /// @param data The value to set (must be greater than 0) /// @dev Emits File event after successful configuration function file(bytes32 id, bytes32 what, uint256 data) external auth { @@ -210,9 +209,6 @@ contract DSPC { } else if (what == "max") { require(data > 0, "DSPC/invalid-max"); _cfgs[id].max = uint16(data); - } else if (what == "step") { - require(data > 0, "DSPC/invalid-step"); - _cfgs[id].step = uint16(data); } else { revert("DSPC/file-unrecognized-param"); } @@ -228,7 +224,6 @@ contract DSPC { /// - Empty updates array /// - Rate below configured minimum /// - Rate above configured maximum - /// - Rate change exceeds configured step size function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); @@ -241,20 +236,6 @@ contract DSPC { require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); - // Check rate change is within allowed gap - uint256 oldBps; - if (id == "DSR") { - oldBps = conv.rtob(PotLike(pot).dsr()); - } else if (id == "SSR") { - oldBps = conv.rtob(SUSDSLike(susds).ssr()); - } else { - (uint256 duty,) = JugLike(jug).ilks(id); - oldBps = conv.rtob(duty); - } - - uint256 delta = _absDiff(bps, oldBps); - require(delta <= cfg.step, "DSPC/delta-above-step"); - // Execute the update uint256 ray = conv.btor(bps); if (id == "DSR") { @@ -283,8 +264,8 @@ contract DSPC { // --- Getters --- /// @notice Get configuration for a rate /// @param id The rate identifier (ilk name, "DSR", or "SSR") - /// @return The configuration struct containing min, max, and step values - /// @dev Returns a Cfg struct with min, max, and step values for the specified rate + /// @return The configuration struct containing min and max values + /// @dev Returns a Cfg struct with min and max values for the specified rate function cfgs(bytes32 id) external view returns (Cfg memory) { return _cfgs[id]; } diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 503161b..8b6e010 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -99,13 +99,10 @@ contract DSPCTest is DssTest { { dspc.file(ILK, "min", 1); dspc.file(ILK, "max", 30000); - dspc.file(ILK, "step", 50); dspc.file(DSR, "min", 1); dspc.file(DSR, "max", 30000); - dspc.file(DSR, "step", 50); dspc.file(SSR, "min", 1); dspc.file(SSR, "max", 30000); - dspc.file(SSR, "step", 50); dspc.kiss(bud); } vm.stopPrank(); @@ -150,17 +147,14 @@ contract DSPCTest is DssTest { function test_file_ilk() public { assertEq(dspc.cfgs(ILK).min, 1); assertEq(dspc.cfgs(ILK).max, 30000); - assertEq(dspc.cfgs(ILK).step, 50); vm.startPrank(address(pauseProxy)); dspc.file(ILK, "min", 100); dspc.file(ILK, "max", 3000); - dspc.file(ILK, "step", 100); vm.stopPrank(); assertEq(dspc.cfgs(ILK).min, 100); assertEq(dspc.cfgs(ILK).max, 3000); - assertEq(dspc.cfgs(ILK).step, 100); } function test_file_ilk_invalid() public { @@ -169,9 +163,6 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/invalid-max"); dspc.file(ILK, "max", 0); - vm.expectRevert("DSPC/invalid-step"); - dspc.file(ILK, "step", 0); - vm.expectRevert("DSPC/file-unrecognized-param"); dspc.file(ILK, "unknown", 100); @@ -279,16 +270,4 @@ contract DSPCTest is DssTest { vm.prank(bud); dspc.set(updates); } - - function test_set_above_step() public { - vm.prank(address(pauseProxy)); - dspc.file(ILK, "step", 50); - - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 100); - - vm.expectRevert("DSPC/delta-above-step"); - vm.prank(bud); - dspc.set(updates); - } } diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index 5521436..3f5af5f 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -105,13 +105,10 @@ contract DSPCMomIntegrationTest is DssTest { { dspc.file(ILK, "min", 1); dspc.file(ILK, "max", 30000); - dspc.file(ILK, "step", 50); dspc.file(DSR, "min", 1); dspc.file(DSR, "max", 30000); - dspc.file(DSR, "step", 50); dspc.file(SSR, "min", 1); dspc.file(SSR, "max", 30000); - dspc.file(SSR, "step", 50); } vm.stopPrank(); } From b34125508df5a72030576cd0537d477e01230096 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Feb 2025 00:21:25 -0300 Subject: [PATCH 10/96] chore: forge fmt --- src/DSPC.t.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 8b6e010..f6f1105 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -139,7 +139,7 @@ contract DSPCTest is DssTest { dspc.file("bad", 2); vm.expectRevert("DSPC/file-unrecognized-param"); - dspc.file("unknown", 1); + dspc.file("unknown", 1); vm.stopPrank(); } @@ -167,7 +167,7 @@ contract DSPCTest is DssTest { dspc.file(ILK, "unknown", 100); vm.expectRevert("DSPC/invalid-value"); - dspc.file(ILK, "max", uint256(type(uint16).max) + 1); + dspc.file(ILK, "max", uint256(type(uint16).max) + 1); vm.stopPrank(); } From 917eb4d92eaced1fca43d1b84a3d32adc07a5fd5 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Feb 2025 00:25:00 -0300 Subject: [PATCH 11/96] refactor: Update Set event to be emitted for each rate update --- src/DSPC.sol | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 7fb9725..43da249 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -113,10 +113,11 @@ contract DSPC { */ event File(bytes32 indexed id, bytes32 indexed what, uint256 data); /** - * @notice A batch of rate changes was executed. - * @param updates Array of rate updates. + * @notice Rate change was executed. + * @param id The Ilk/DSR/SSR identifier. + * @param bps The new value of the rate in basis points. */ - event Set(ParamChange[] updates); + event Set(bytes32 indexed id, uint256 bps); // --- Modifiers --- modifier auth() { @@ -248,9 +249,8 @@ contract DSPC { jug.drip(id); jug.file(id, "duty", ray); } + emit Set(id, bps); } - - emit Set(updates); } /// @notice Calculates absolute difference between two uint256 values From def70fa4b5c213ffba68e430b98704debbcd041c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:46:27 -0300 Subject: [PATCH 12/96] Update src/deployment/DSPCInstance.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCInstance.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/deployment/DSPCInstance.sol b/src/deployment/DSPCInstance.sol index 0f7d96f..9a0d8c3 100644 --- a/src/deployment/DSPCInstance.sol +++ b/src/deployment/DSPCInstance.sol @@ -20,6 +20,6 @@ import {DSPC} from "../DSPC.sol"; import {DSPCMom} from "../DSPCMom.sol"; struct DSPCInstance { - DSPC dspc; - DSPCMom mom; + address dspc; + address mom; } From 9c2898dc43d23c915ef8b723e3ee1e914b7405f2 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:46:37 -0300 Subject: [PATCH 13/96] Update src/deployment/DSPCInit.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCInit.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index ad3238f..82b6af8 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -29,8 +29,8 @@ library DSPCInit { * @param inst The DSCP instance. */ function init(DssInstance memory dss, DSPCInstance memory inst) internal { - inst.dspc.rely(address(inst.mom)); - inst.mom.setAuthority(dss.chainlog.getAddress("MCD_ADM")); + RelyLike(inst.dspc).rely(address(inst.mom)); + MomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); dss.jug.rely(address(inst.dspc)); dss.pot.rely(address(inst.dspc)); From b6c57c030b059501897032a985d655e800c5af3a Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:46:46 -0300 Subject: [PATCH 14/96] Update src/deployment/DSPCInit.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCInit.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index 82b6af8..4e82a59 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -34,6 +34,6 @@ library DSPCInit { dss.jug.rely(address(inst.dspc)); dss.pot.rely(address(inst.dspc)); - SUSDSLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); + RelyLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); } } From 253af3659c5ac21cc3cea21056cee085a765c1fe Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:47:01 -0300 Subject: [PATCH 15/96] Update src/deployment/DSPCDeploy.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCDeploy.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index a0ab343..2d8b68f 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -32,9 +32,9 @@ struct DSPCDeployParams { library DSPCDeploy { function deploy(DSPCDeployParams memory params) internal returns (DSPCInstance memory inst) { - inst.dspc = new DSPC(params.jug, params.pot, params.susds, params.conv); + inst.dspc = address(new DSPC(params.jug, params.pot, params.susds, params.conv)); - inst.mom = new DSPCMom(); + inst.mom = address(new DSPCMom()); ScriptTools.switchOwner(address(inst.dspc), params.deployer, params.owner); inst.mom.setOwner(params.owner); From 45a1834884aa751bc5d0ec9ab56ac0d40fe32a3f Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:47:10 -0300 Subject: [PATCH 16/96] Update src/deployment/DSPCDeploy.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCDeploy.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index 2d8b68f..323950f 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -37,6 +37,6 @@ library DSPCDeploy { inst.mom = address(new DSPCMom()); ScriptTools.switchOwner(address(inst.dspc), params.deployer, params.owner); - inst.mom.setOwner(params.owner); + MomLike(inst.mom).setOwner(params.owner); } } From cec6dc40a62ea063e3a747a5db87ff66e3dbc41f Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:47:27 -0300 Subject: [PATCH 17/96] Update src/deployment/DSPCDeploy.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCDeploy.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index 323950f..09c85b7 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -36,7 +36,7 @@ library DSPCDeploy { inst.mom = address(new DSPCMom()); - ScriptTools.switchOwner(address(inst.dspc), params.deployer, params.owner); + ScriptTools.switchOwner(inst.dspc, params.deployer, params.owner); MomLike(inst.mom).setOwner(params.owner); } } From 48b668aae589e5ac4519a879ac476d0823c74d2d Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:47:38 -0300 Subject: [PATCH 18/96] Update src/deployment/DSPCInit.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCInit.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index 4e82a59..b635f43 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -18,7 +18,7 @@ pragma solidity ^0.8.24; import {DssInstance} from "dss-test/MCD.sol"; import {DSPCInstance} from "./DSPCInstance.sol"; -interface SUSDSLike { +interface RelyLike { function rely(address usr) external; } From b9482c316ecb6774a091c4847f5d0211a130f7f1 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 15:28:55 -0300 Subject: [PATCH 19/96] refactor: use addresses instead of interfaces in DSPCInstance to ease casting --- src/DSPC.t.sol | 4 ++-- src/DSPCMom.t.sol | 4 ++-- src/deployment/DSPCDeploy.sol | 4 ++++ src/deployment/DSPCInit.sol | 10 +++++++--- src/deployment/DSPCInstance.sol | 3 --- 5 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index f6f1105..b6aabc4 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -87,8 +87,8 @@ contract DSPCTest is DssTest { conv: address(conv) }) ); - dspc = inst.dspc; - mom = inst.mom; + dspc = DSPC(inst.dspc); + mom = DSPCMom(inst.mom); // Simulate a spell casting vm.prank(pause); diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index 3f5af5f..bc66ca8 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -93,8 +93,8 @@ contract DSPCMomIntegrationTest is DssTest { conv: address(conv) }) ); - dspc = inst.dspc; - mom = inst.mom; + dspc = DSPC(inst.dspc); + mom = DSPCMom(inst.mom); // Simulate a spell casting vm.prank(pause); diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index 09c85b7..3c4013b 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -21,6 +21,10 @@ import {DSPC} from "../DSPC.sol"; import {DSPCMom} from "../DSPCMom.sol"; import {DSPCInstance} from "./DSPCInstance.sol"; +interface MomLike { + function setOwner(address owner) external; +} + struct DSPCDeployParams { address deployer; address owner; diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index b635f43..489dd5b 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -18,7 +18,11 @@ pragma solidity ^0.8.24; import {DssInstance} from "dss-test/MCD.sol"; import {DSPCInstance} from "./DSPCInstance.sol"; -interface RelyLike { +interface MomLike { + function setAuthority(address authority) external; +} + +interface RelayLike { function rely(address usr) external; } @@ -29,11 +33,11 @@ library DSPCInit { * @param inst The DSCP instance. */ function init(DssInstance memory dss, DSPCInstance memory inst) internal { - RelyLike(inst.dspc).rely(address(inst.mom)); + RelayLike(inst.dspc).rely(address(inst.mom)); MomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); dss.jug.rely(address(inst.dspc)); dss.pot.rely(address(inst.dspc)); - RelyLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); + RelayLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); } } diff --git a/src/deployment/DSPCInstance.sol b/src/deployment/DSPCInstance.sol index 9a0d8c3..ba575d5 100644 --- a/src/deployment/DSPCInstance.sol +++ b/src/deployment/DSPCInstance.sol @@ -16,9 +16,6 @@ pragma solidity ^0.8.24; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; - struct DSPCInstance { address dspc; address mom; From 2274abea14dca71fa7b103a190b3b867df13c153 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Feb 2025 15:53:53 -0300 Subject: [PATCH 20/96] fix: enforce min < max and max > min on file() --- src/DSPC.sol | 3 ++- src/DSPC.t.sol | 14 +++++++++----- src/DSPCMom.t.sol | 6 +++--- 3 files changed, 14 insertions(+), 9 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 43da249..b46cff4 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -206,9 +206,10 @@ contract DSPC { function file(bytes32 id, bytes32 what, uint256 data) external auth { require(data <= type(uint16).max, "DSPC/invalid-value"); if (what == "min") { + require(data <= _cfgs[id].max, "DSPC/min-too-high"); _cfgs[id].min = uint16(data); } else if (what == "max") { - require(data > 0, "DSPC/invalid-max"); + require(data >= _cfgs[id].min, "DSPC/max-too-low"); _cfgs[id].max = uint16(data); } else { revert("DSPC/file-unrecognized-param"); diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index b6aabc4..c87ff4d 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -97,12 +97,12 @@ contract DSPCTest is DssTest { // The init script does not cover setting ilk specific parameters vm.startPrank(address(pauseProxy)); { - dspc.file(ILK, "min", 1); dspc.file(ILK, "max", 30000); - dspc.file(DSR, "min", 1); + dspc.file(ILK, "min", 1); dspc.file(DSR, "max", 30000); - dspc.file(SSR, "min", 1); + dspc.file(DSR, "min", 1); dspc.file(SSR, "max", 30000); + dspc.file(SSR, "min", 1); dspc.kiss(bud); } vm.stopPrank(); @@ -159,9 +159,13 @@ contract DSPCTest is DssTest { function test_file_ilk_invalid() public { vm.startPrank(address(pauseProxy)); + DSPC.Cfg memory cfg = dspc.cfgs(ILK); + + vm.expectRevert("DSPC/min-too-high"); + dspc.file(ILK, "min", cfg.max + 1); - vm.expectRevert("DSPC/invalid-max"); - dspc.file(ILK, "max", 0); + vm.expectRevert("DSPC/max-too-low"); + dspc.file(ILK, "max", cfg.min - 1); vm.expectRevert("DSPC/file-unrecognized-param"); dspc.file(ILK, "unknown", 100); diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index bc66ca8..b0ab5f0 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -103,12 +103,12 @@ contract DSPCMomIntegrationTest is DssTest { // The init script does not cover setting ilk specific parameters vm.startPrank(address(pauseProxy)); { - dspc.file(ILK, "min", 1); dspc.file(ILK, "max", 30000); - dspc.file(DSR, "min", 1); + dspc.file(ILK, "min", 1); dspc.file(DSR, "max", 30000); - dspc.file(SSR, "min", 1); + dspc.file(DSR, "min", 1); dspc.file(SSR, "max", 30000); + dspc.file(SSR, "min", 1); } vm.stopPrank(); } From 75211eda0b921e129dff9254ff806cfa8c6ba8c4 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 21 Feb 2025 12:48:07 -0300 Subject: [PATCH 21/96] fix: typo in RelyLike --- src/deployment/DSPCInit.sol | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index 489dd5b..bf754cd 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -22,7 +22,7 @@ interface MomLike { function setAuthority(address authority) external; } -interface RelayLike { +interface RelyLike { function rely(address usr) external; } @@ -33,11 +33,11 @@ library DSPCInit { * @param inst The DSCP instance. */ function init(DssInstance memory dss, DSPCInstance memory inst) internal { - RelayLike(inst.dspc).rely(address(inst.mom)); + RelyLike(inst.dspc).rely(address(inst.mom)); MomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); dss.jug.rely(address(inst.dspc)); dss.pot.rely(address(inst.dspc)); - RelayLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); + RelyLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); } } From 3d3a5153429c2a504154f8e16a4c28adecf60f6c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 21 Feb 2025 12:49:09 -0300 Subject: [PATCH 22/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 1 - 1 file changed, 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index b46cff4..999d106 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -36,7 +36,6 @@ interface SUSDSLike { interface ConvLike { function btor(uint256 bps) external pure returns (uint256 ray); - function rtob(uint256 ray) external pure returns (uint256 bps); } /// @title Direct Stability Parameters Change Module From b7dadb5c66143f9cf6de604fe458892a4ef22609 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 24 Feb 2025 14:23:18 -0300 Subject: [PATCH 23/96] feat: dspc cooldown + step --- src/DSPC.sol | 36 ++++++++++++++++++++++++++++++++---- src/DSPC.t.sol | 42 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 73 insertions(+), 5 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 999d106..bac8a7a 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -36,6 +36,7 @@ interface SUSDSLike { interface ConvLike { function btor(uint256 bps) external pure returns (uint256 ray); + function rtob(uint256 ray) external pure returns (uint256 bps); } /// @title Direct Stability Parameters Change Module @@ -50,6 +51,7 @@ contract DSPC { struct Cfg { uint16 min; // Minimum rate in basis points uint16 max; // Maximum rate in basis points + uint16 step; // Maximum rate change in basis points } struct ParamChange { @@ -76,6 +78,10 @@ contract DSPC { mapping(bytes32 => Cfg) private _cfgs; /// @notice Circuit breaker flag uint256 public bad; + /// @notice Cooldown period between rate changes in seconds + uint256 public tau; + /// @notice Last time when rates were updated (Unix timestamp) + uint256 public toc; // --- Events --- /** @@ -183,13 +189,15 @@ contract DSPC { } /// @notice Configure module parameters - /// @param what The parameter to configure (only "bad" is supported) - /// @param data The value to set (must be 0 or 1 for "bad") + /// @param what The parameter to configure + /// @param data The value to set /// @dev Emits File event after successful configuration function file(bytes32 what, uint256 data) external auth { if (what == "bad") { require(data <= 1, "DSPC/invalid-bad-value"); bad = data; + } else if (what == "tau") { + tau = data; } else { revert("DSPC/file-unrecognized-param"); } @@ -199,8 +207,8 @@ contract DSPC { /// @notice Configure constraints for a rate /// @param id The rate identifier (ilk name, "DSR", or "SSR") - /// @param what The parameter to configure ("min", "max") - /// @param data The value to set (must be greater than 0) + /// @param what The parameter to configure ("min", "max" or "step") + /// @param data The value to set /// @dev Emits File event after successful configuration function file(bytes32 id, bytes32 what, uint256 data) external auth { require(data <= type(uint16).max, "DSPC/invalid-value"); @@ -210,6 +218,8 @@ contract DSPC { } else if (what == "max") { require(data >= _cfgs[id].min, "DSPC/max-too-low"); _cfgs[id].max = uint16(data); + } else if (what == "step") { + _cfgs[id].step = uint16(data); } else { revert("DSPC/file-unrecognized-param"); } @@ -223,10 +233,14 @@ contract DSPC { /// @dev Emits Set event after all updates are successfully applied /// @dev Reverts if: /// - Empty updates array + /// - Cooldown not expired /// - Rate below configured minimum /// - Rate above configured maximum + /// - Rate change above configured step function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); + require(block.timestamp >= tau + toc, "DSPC/cooldown-not-expired"); + toc = block.timestamp; // Validate all updates in the batch for (uint256 i = 0; i < updates.length; i++) { @@ -237,6 +251,20 @@ contract DSPC { require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); + // Check rate change is within allowed gap + uint256 oldBps; + if (id == "DSR") { + oldBps = conv.rtob(PotLike(pot).dsr()); + } else if (id == "SSR") { + oldBps = conv.rtob(SUSDSLike(susds).ssr()); + } else { + (uint256 duty,) = JugLike(jug).ilks(id); + oldBps = conv.rtob(duty); + } + + uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; + require(delta <= cfg.step, "DSPC/delta-above-step"); + // Execute the update uint256 ray = conv.btor(bps); if (id == "DSR") { diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index c87ff4d..c72f72d 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -99,10 +99,13 @@ contract DSPCTest is DssTest { { dspc.file(ILK, "max", 30000); dspc.file(ILK, "min", 1); + dspc.file(ILK, "step", 100); dspc.file(DSR, "max", 30000); dspc.file(DSR, "min", 1); + dspc.file(DSR, "step", 100); dspc.file(SSR, "max", 30000); dspc.file(SSR, "min", 1); + dspc.file(SSR, "step", 100); dspc.kiss(bud); } vm.stopPrank(); @@ -128,7 +131,7 @@ contract DSPCTest is DssTest { checkAuth(address(dspc), "DSPC"); } - function test_file_bad() public { + function test_file() public { vm.startPrank(address(pauseProxy)); assertEq(dspc.bad(), 0); @@ -141,20 +144,27 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/file-unrecognized-param"); dspc.file("unknown", 1); + assertEq(dspc.tau(), 0); + dspc.file("tau", 1 days); + assertEq(dspc.tau(), 1 days); + vm.stopPrank(); } function test_file_ilk() public { assertEq(dspc.cfgs(ILK).min, 1); assertEq(dspc.cfgs(ILK).max, 30000); + assertEq(dspc.cfgs(ILK).step, 100); vm.startPrank(address(pauseProxy)); dspc.file(ILK, "min", 100); dspc.file(ILK, "max", 3000); + dspc.file(ILK, "step", 420); vm.stopPrank(); assertEq(dspc.cfgs(ILK).min, 100); assertEq(dspc.cfgs(ILK).max, 3000); + assertEq(dspc.cfgs(ILK).step, 420); } function test_file_ilk_invalid() public { @@ -274,4 +284,34 @@ contract DSPCTest is DssTest { vm.prank(bud); dspc.set(updates); } + + function test_set_delta_above_step() public { + vm.prank(address(pauseProxy)); + dspc.file(ILK, "step", 100); + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 100); + + vm.expectRevert("DSPC/delta-above-step"); + vm.prank(bud); + dspc.set(updates); + } + + function test_set_before_cooldown() public { + vm.prank(address(pauseProxy)); + dspc.file("tau", 100); + uint256 currentDSR = conv.rtob(dss.pot.dsr()); + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(DSR, currentDSR + 1); + vm.prank(bud); + dspc.set(updates); + + vm.warp(block.timestamp + 99); + + updates[0] = DSPC.ParamChange(DSR, currentDSR + 2); + vm.prank(bud); + vm.expectRevert("DSPC/cooldown-not-expired"); + dspc.set(updates); + } } From 0582668e64889b24f3f14e7b004205fe06b2ca0e Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 24 Feb 2025 14:24:00 -0300 Subject: [PATCH 24/96] remove unnecessary setup from dspcMom test --- src/DSPCMom.t.sol | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index b0ab5f0..4a6de7f 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -99,18 +99,6 @@ contract DSPCMomIntegrationTest is DssTest { // Simulate a spell casting vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst))); - - // The init script does not cover setting ilk specific parameters - vm.startPrank(address(pauseProxy)); - { - dspc.file(ILK, "max", 30000); - dspc.file(ILK, "min", 1); - dspc.file(DSR, "max", 30000); - dspc.file(DSR, "min", 1); - dspc.file(SSR, "max", 30000); - dspc.file(SSR, "min", 1); - } - vm.stopPrank(); } function test_constructor() public view { From e03048f2be6f546d3a212372d175c98cca212f01 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 24 Feb 2025 14:24:22 -0300 Subject: [PATCH 25/96] chore: forge fmt --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index bac8a7a..9984c67 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -263,7 +263,7 @@ contract DSPC { } uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; - require(delta <= cfg.step, "DSPC/delta-above-step"); + require(delta <= cfg.step, "DSPC/delta-above-step"); // Execute the update uint256 ray = conv.btor(bps); From d6858196ee459a2b702acf209d0009a2ea7374a4 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 24 Feb 2025 20:11:47 -0300 Subject: [PATCH 26/96] Apply suggestions from code review Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- README.md | 3 ++- src/DSPC.sol | 10 ++-------- 2 files changed, 4 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 7c93ae1..a965c20 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ The DSPC module provides a streamlined way to modify stability parameters in the - Facilitators can propose and execute rate changes - Rate change constraints: - Min/max caps per rate + - Max update delta - Event emission for all actions - Simple, auditable implementation @@ -47,7 +48,7 @@ DSPC dspc = new DSPC( 2. Configure the module parameters: ```solidity // Set timelock duration -dspc.file("lag", 1 days); +dspc.file("tau", 1 days); // Configure constraints for a collateral type dspc.file("ETH-A", "min", 1); // Min rate: 0.01% diff --git a/src/DSPC.sol b/src/DSPC.sol index 9984c67..a366346 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -239,7 +239,7 @@ contract DSPC { /// - Rate change above configured step function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); - require(block.timestamp >= tau + toc, "DSPC/cooldown-not-expired"); + require(block.timestamp >= tau + toc, "DSPC/too-early"); toc = block.timestamp; // Validate all updates in the batch @@ -262,6 +262,7 @@ contract DSPC { oldBps = conv.rtob(duty); } + // Calculates absolute difference between the old and the new rate uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; require(delta <= cfg.step, "DSPC/delta-above-step"); @@ -281,13 +282,6 @@ contract DSPC { } } - /// @notice Calculates absolute difference between two uint256 values - /// @param a The first uint256 value - /// @param b The second uint256 value - /// @return delta The absolute difference between the parameters - function _absDiff(uint256 a, uint256 b) internal pure returns (uint256 delta) { - delta = a > b ? a - b : b - a; - } // --- Getters --- /// @notice Get configuration for a rate From 9dcf622ed82ecc7817bc93689daf2c323326fb26 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 24 Feb 2025 20:25:12 -0300 Subject: [PATCH 27/96] fix: revert message in test --- src/DSPC.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index c72f72d..00f62cd 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -311,7 +311,7 @@ contract DSPCTest is DssTest { updates[0] = DSPC.ParamChange(DSR, currentDSR + 2); vm.prank(bud); - vm.expectRevert("DSPC/cooldown-not-expired"); + vm.expectRevert("DSPC/too-early"); dspc.set(updates); } } From 0a7913946591267447b9ff5d8b5b892ff3951c1c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 24 Feb 2025 20:25:32 -0300 Subject: [PATCH 28/96] chore: forge fmt --- src/DSPC.sol | 1 - 1 file changed, 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index a366346..0d10704 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -282,7 +282,6 @@ contract DSPC { } } - // --- Getters --- /// @notice Get configuration for a rate /// @param id The rate identifier (ilk name, "DSR", or "SSR") From a47d4ffeb671bdbf5b3fcf3c1dddd45b8f08c8c8 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 26 Feb 2025 20:41:04 -0300 Subject: [PATCH 29/96] feat: improvements to initialization script --- src/DSPC.t.sol | 58 ++++++++----- src/DSPCMom.t.sol | 14 +-- src/deployment/DSPCDeploy.sol | 21 +++++ src/deployment/DSPCDeploy.t.sol | 71 +++++++++++++++ src/deployment/DSPCInit.sol | 82 ++++++++++++++---- src/deployment/DSPCInit.t.sol | 148 ++++++++++++++++++++++++++++++++ 6 files changed, 352 insertions(+), 42 deletions(-) create mode 100644 src/deployment/DSPCDeploy.t.sol create mode 100644 src/deployment/DSPCInit.t.sol diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 00f62cd..7b31bfa 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -20,7 +20,7 @@ import {DSPC} from "./DSPC.sol"; import {DSPCMom} from "./DSPCMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit} from "./deployment/DSPCInit.sol"; +import {DSPCInit, DSPCConfig, DSPCIlkConfig} from "./deployment/DSPCInit.sol"; import {DSPCInstance} from "./deployment/DSPCInstance.sol"; interface ConvLike { @@ -38,8 +38,8 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst) external { - DSPCInit.init(dss, inst); + function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { + DSPCInit.init(dss, inst, cfg); } } @@ -90,25 +90,43 @@ contract DSPCTest is DssTest { dspc = DSPC(inst.dspc); mom = DSPCMom(inst.mom); - // Simulate a spell casting + // Initialize deployment + DSPCIlkConfig[] memory ilks = new DSPCIlkConfig[](3); // ETH-A, DSR, SSR + + // Configure ETH-A + ilks[0] = DSPCIlkConfig({ + ilk: ILK, // Use the constant bytes32 ILK + min: uint16(1), + max: uint16(30000), + step: uint16(100) + }); + + // Configure DSR + ilks[1] = DSPCIlkConfig({ + ilk: DSR, // Use the constant bytes32 DSR + min: uint16(1), + max: uint16(30000), + step: uint16(100) + }); + + // Configure SSR + ilks[2] = DSPCIlkConfig({ + ilk: SSR, // Use the constant bytes32 SSR + min: uint16(1), + max: uint16(30000), + step: uint16(100) + }); + + DSPCConfig memory cfg = DSPCConfig({ + tau: 0, // Start with tau = 0 for tests + ilks: ilks + }); vm.prank(pause); - pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst))); + pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); - // The init script does not cover setting ilk specific parameters - vm.startPrank(address(pauseProxy)); - { - dspc.file(ILK, "max", 30000); - dspc.file(ILK, "min", 1); - dspc.file(ILK, "step", 100); - dspc.file(DSR, "max", 30000); - dspc.file(DSR, "min", 1); - dspc.file(DSR, "step", 100); - dspc.file(SSR, "max", 30000); - dspc.file(SSR, "min", 1); - dspc.file(SSR, "step", 100); - dspc.kiss(bud); - } - vm.stopPrank(); + // Kiss the bud address + vm.prank(address(pauseProxy)); + dspc.kiss(bud); } function test_constructor() public view { diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index 4a6de7f..1f8252f 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -21,7 +21,7 @@ import {DSPC} from "./DSPC.sol"; import {DSPCMom} from "./DSPCMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit} from "./deployment/DSPCInit.sol"; +import {DSPCInit, DSPCConfig, DSPCIlkConfig} from "./deployment/DSPCInit.sol"; import {DSPCInstance} from "./deployment/DSPCInstance.sol"; interface ChiefLike { @@ -43,8 +43,8 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst) external { - DSPCInit.init(dss, inst); + function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { + DSPCInit.init(dss, inst, cfg); } } @@ -96,9 +96,13 @@ contract DSPCMomIntegrationTest is DssTest { dspc = DSPC(inst.dspc); mom = DSPCMom(inst.mom); - // Simulate a spell casting + // Initialize deployment + DSPCConfig memory cfg = DSPCConfig({ + tau: 0, // Start with tau = 0 for tests + ilks: new DSPCIlkConfig[](0) // No ilks for this test + }); vm.prank(pause); - pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst))); + pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); } function test_constructor() public view { diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index 3c4013b..40ea790 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -25,21 +25,42 @@ interface MomLike { function setOwner(address owner) external; } +/// @title DSPC Deployment Parameters +/// @notice Parameters required for deploying the DSPC system +/// @dev Used to configure the initial setup of DSPC and DSPCMom contracts struct DSPCDeployParams { address deployer; + /// @dev Address deploying the contracts address owner; + /// @dev Final owner address after deployment address jug; + /// @dev MakerDAO Jug contract address address pot; + /// @dev MakerDAO Pot contract address address susds; + /// @dev SUSDS contract address address conv; } +/// @dev Rate converter contract address +/// @title DSPC Deployment Library +/// @notice Handles deployment of DSPC system contracts +/// @dev Deploys and configures DSPC and DSPCMom contracts with proper permissions library DSPCDeploy { + /// @notice Deploy DSPC system contracts + /// @dev Deploys DSPC and DSPCMom, sets up initial permissions + /// @param params Configuration parameters for deployment + /// @return inst Instance containing addresses of deployed contracts function deploy(DSPCDeployParams memory params) internal returns (DSPCInstance memory inst) { + // Deploy DSPC with core contract references inst.dspc = address(new DSPC(params.jug, params.pot, params.susds, params.conv)); + // Deploy DSPCMom for governance inst.mom = address(new DSPCMom()); + // First set authority for DSPCMom + DSPCMom(inst.mom).setAuthority(params.owner); + // Then switch owners ScriptTools.switchOwner(inst.dspc, params.deployer, params.owner); MomLike(inst.mom).setOwner(params.owner); } diff --git a/src/deployment/DSPCDeploy.t.sol b/src/deployment/DSPCDeploy.t.sol new file mode 100644 index 0000000..78fbd23 --- /dev/null +++ b/src/deployment/DSPCDeploy.t.sol @@ -0,0 +1,71 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later + +pragma solidity ^0.8.24; + +import "dss-test/DssTest.sol"; +import {DSPC} from "../DSPC.sol"; +import {DSPCMom} from "../DSPCMom.sol"; +import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; +import {DSPCInstance} from "./DSPCInstance.sol"; +import {ConvMock} from "../mocks/ConvMock.sol"; + +interface JugLike { + function wards(address) external view returns (uint256); +} + +interface PotLike { + function wards(address) external view returns (uint256); +} + +interface SUSDSLike { + function wards(address) external view returns (uint256); +} + +contract DSPCDeployTest is DssTest { + address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; + address susds; + address deployer = address(0xDE9); + address owner = address(0x123); + + DssInstance dss; + ConvMock conv; + DSPCInstance inst; + + function setUp() public { + vm.createSelectFork("mainnet"); + dss = MCD.loadFromChainlog(CHAINLOG); + susds = dss.chainlog.getAddress("SUSDS"); + conv = new ConvMock(); + } + + function test_deploy() public { + vm.startPrank(deployer); + inst = DSPCDeploy.deploy( + DSPCDeployParams({ + deployer: deployer, + owner: owner, + jug: address(dss.jug), + pot: address(dss.pot), + susds: susds, + conv: address(conv) + }) + ); + vm.stopPrank(); + + // Verify DSPC deployment + assertTrue(inst.dspc != address(0), "DSPC not deployed"); + assertEq(address(DSPC(inst.dspc).jug()), address(dss.jug), "Wrong jug"); + assertEq(address(DSPC(inst.dspc).pot()), address(dss.pot), "Wrong pot"); + assertEq(address(DSPC(inst.dspc).susds()), susds, "Wrong susds"); + assertEq(address(DSPC(inst.dspc).conv()), address(conv), "Wrong conv"); + + // Verify DSPCMom deployment + assertTrue(inst.mom != address(0), "DSPCMom not deployed"); + assertEq(DSPCMom(inst.mom).owner(), owner, "Wrong mom owner"); + + // Verify ownership transfer + assertEq(DSPC(inst.dspc).wards(owner), 1, "Owner not authorized in DSPC"); + assertEq(DSPC(inst.dspc).wards(deployer), 0, "Deployer still authorized in DSPC"); + } +} diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index bf754cd..b643d82 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: © 2023 Dai Foundation +// SPDX-FileCopyrightText: 2025 Dai Foundation // SPDX-License-Identifier: AGPL-3.0-or-later // // This program is free software: you can redistribute it and/or modify @@ -13,31 +13,79 @@ // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see . + pragma solidity ^0.8.24; import {DssInstance} from "dss-test/MCD.sol"; import {DSPCInstance} from "./DSPCInstance.sol"; -interface MomLike { - function setAuthority(address authority) external; +interface DSPCLike { + function rely(address usr) external; + function file(bytes32 what, uint256 data) external; + function file(bytes32 ilk, bytes32 what, uint256 data) external; + function kiss(address usr) external; } -interface RelyLike { - function rely(address usr) external; +interface DSPCMomLike { + function setAuthority(address usr) external; +} + +/// @title Configuration parameters for a collateral type in DSPC +/// @dev Used to configure rate parameters for a specific collateral +struct DSPCIlkConfig { + bytes32 ilk; + /// @dev Collateral identifier + uint16 min; + /// @dev Minimum rate in basis points [0-65535] + uint16 max; + /// @dev Maximum rate in basis points [0-65535] + uint16 step; +} +/// @dev Step size in basis points [0-65535] + +/// @title Global configuration parameters for DSPC +/// @dev Used to configure global parameters and collateral-specific settings +struct DSPCConfig { + uint256 tau; + /// @dev Time delay between rate updates + DSPCIlkConfig[] ilks; } +/// @dev Array of collateral configurations +/// @title Dynamic Stability Parameter Controller Initialization +/// @notice Handles initialization and configuration of the DSPC contract +/// @dev Sets up permissions and configures parameters for the DSPC system library DSPCInit { - /** - * @dev Initializes a DSPC instance. - * @param dss The DSS instance. - * @param inst The DSCP instance. - */ - function init(DssInstance memory dss, DSPCInstance memory inst) internal { - RelyLike(inst.dspc).rely(address(inst.mom)); - MomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); - - dss.jug.rely(address(inst.dspc)); - dss.pot.rely(address(inst.dspc)); - RelyLike(dss.chainlog.getAddress("SUSDS")).rely(address(inst.dspc)); + /// @notice Initializes a DSPC instance with the specified configuration + /// @dev Sets up permissions between DSPC and core contracts, and configures parameters + /// @param dss The DSS (MakerDAO) instance containing core contract references + /// @param inst The DSPC instance containing contract addresses + /// @param cfg The configuration parameters for DSPC + function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) internal { + // Set up permissions + DSPCLike dspc = DSPCLike(inst.dspc); + DSPCMomLike mom = DSPCMomLike(inst.mom); + + // Authorize DSPCMom in DSPC + dspc.rely(inst.mom); + + // Set DSPCMom authority to MCD_ADM + mom.setAuthority(dss.chainlog.getAddress("MCD_ADM")); + + // Authorize DSPC in core contracts + dss.jug.rely(inst.dspc); + dss.pot.rely(inst.dspc); + DSPCLike(dss.chainlog.getAddress("SUSDS")).rely(inst.dspc); + + // Configure global parameters + dspc.file("tau", cfg.tau); + + // Configure ilks + for (uint256 i = 0; i < cfg.ilks.length; i++) { + DSPCIlkConfig memory ilk = cfg.ilks[i]; + dspc.file(ilk.ilk, "max", uint256(ilk.max)); + dspc.file(ilk.ilk, "min", uint256(ilk.min)); + dspc.file(ilk.ilk, "step", uint256(ilk.step)); + } } } diff --git a/src/deployment/DSPCInit.t.sol b/src/deployment/DSPCInit.t.sol new file mode 100644 index 0000000..e4fbc29 --- /dev/null +++ b/src/deployment/DSPCInit.t.sol @@ -0,0 +1,148 @@ +// SPDX-FileCopyrightText: 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity ^0.8.24; + +import {DssTest, MCD} from "dss-test/DssTest.sol"; +import {DssInstance} from "dss-test/MCD.sol"; +import {DSPC} from "../DSPC.sol"; +import {DSPCMom} from "../DSPCMom.sol"; +import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; +import {DSPCInit, DSPCConfig, DSPCIlkConfig} from "./DSPCInit.sol"; +import {DSPCInstance} from "./DSPCInstance.sol"; +import {ConvMock} from "../mocks/ConvMock.sol"; + +interface RelyLike { + function rely(address usr) external; +} + +interface JugLike is RelyLike { + function wards(address) external view returns (uint256); + function ilks(bytes32) external view returns (uint256 duty, uint256 rho); +} + +interface PotLike is RelyLike { + function wards(address) external view returns (uint256); + function dsr() external view returns (uint256); +} + +interface SUSDSLike is RelyLike { + function wards(address) external view returns (uint256); + function ssr() external view returns (uint256); +} + +interface ConvLike { + function rtob(uint256 ray) external pure returns (uint256 bps); +} + +interface ProxyLike { + function exec(address usr, bytes memory fax) external returns (bytes memory out); +} + +contract InitCaller { + function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { + DSPCInit.init(dss, inst, cfg); + } +} + +contract DSPCInitTest is DssTest { + address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; + address deployer = address(0xDE9); + address owner = address(0x123); + address pause; + address susds; + ProxyLike pauseProxy; + InitCaller caller; + + DssInstance dss; + ConvMock conv; + DSPCInstance inst; + + function setUp() public { + vm.createSelectFork("mainnet"); + dss = MCD.loadFromChainlog(CHAINLOG); + pauseProxy = ProxyLike(dss.chainlog.getAddress("MCD_PAUSE_PROXY")); + pause = dss.chainlog.getAddress("MCD_PAUSE"); + conv = new ConvMock(); + susds = dss.chainlog.getAddress("SUSDS"); + caller = new InitCaller(); + + vm.startPrank(deployer); + inst = DSPCDeploy.deploy( + DSPCDeployParams({ + deployer: deployer, + owner: address(pauseProxy), + jug: address(dss.jug), + pot: address(dss.pot), + susds: susds, + conv: address(conv) + }) + ); + vm.stopPrank(); + } + + function test_init() public { + // Create test configuration + DSPCIlkConfig[] memory ilks = new DSPCIlkConfig[](2); + + // Configure ETH-A + ilks[0] = DSPCIlkConfig({ + ilk: "ETH-A", + min: uint16(0), // 0% + max: uint16(1000), // 10% + step: uint16(50) // 0.5% + }); + + // Configure WBTC-A + ilks[1] = DSPCIlkConfig({ + ilk: "WBTC-A", + min: uint16(0), // 0% + max: uint16(1500), // 15% + step: uint16(100) // 1% + }); + + DSPCConfig memory cfg = DSPCConfig({tau: 1 days, ilks: ilks}); + + vm.prank(pause); + pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); + + // Verify DSPCMom authority + assertEq(DSPCMom(inst.mom).authority(), dss.chainlog.getAddress("MCD_ADM"), "Wrong authority"); + + // Verify DSPC permissions + assertEq(DSPC(inst.dspc).wards(inst.mom), 1, "Mom not authorized in DSPC"); + + // Verify core contract permissions + assertEq(JugLike(address(dss.jug)).wards(inst.dspc), 1, "DSPC not authorized in Jug"); + assertEq(PotLike(address(dss.pot)).wards(inst.dspc), 1, "DSPC not authorized in Pot"); + assertEq(SUSDSLike(susds).wards(inst.dspc), 1, "DSPC not authorized in SUSDS"); + + // Verify configuration + assertEq(DSPC(inst.dspc).tau(), cfg.tau, "Wrong tau"); + + // Verify ETH-A config + DSPC.Cfg memory ethCfg = DSPC(inst.dspc).cfgs("ETH-A"); + assertEq(ethCfg.min, ilks[0].min, "Wrong ETH-A min"); + assertEq(ethCfg.max, ilks[0].max, "Wrong ETH-A max"); + assertEq(ethCfg.step, ilks[0].step, "Wrong ETH-A step"); + + // Verify WBTC-A config + DSPC.Cfg memory wbtcCfg = DSPC(inst.dspc).cfgs("WBTC-A"); + assertEq(wbtcCfg.min, ilks[1].min, "Wrong WBTC-A min"); + assertEq(wbtcCfg.max, ilks[1].max, "Wrong WBTC-A max"); + assertEq(wbtcCfg.step, ilks[1].step, "Wrong WBTC-A step"); + } +} From 4077e06323ae638ac2ed25c8d0b867cb7445fdca Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 6 Mar 2025 12:00:42 -0300 Subject: [PATCH 30/96] Apply suggestions from code review Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/deployment/DSPCInit.sol | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index b643d82..d5be321 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -19,8 +19,11 @@ pragma solidity ^0.8.24; import {DssInstance} from "dss-test/MCD.sol"; import {DSPCInstance} from "./DSPCInstance.sol"; -interface DSPCLike { +interface RelyLike { function rely(address usr) external; +} + +interface DSPCLike is RelyLike { function file(bytes32 what, uint256 data) external; function file(bytes32 ilk, bytes32 what, uint256 data) external; function kiss(address usr) external; @@ -30,15 +33,15 @@ interface DSPCMomLike { function setAuthority(address usr) external; } -/// @title Configuration parameters for a collateral type in DSPC -/// @dev Used to configure rate parameters for a specific collateral -struct DSPCIlkConfig { - bytes32 ilk; - /// @dev Collateral identifier +/// @title Configuration parameters for a rate in DSPC +/// @dev Used to configure rate parameters for a specific rate +struct DSPCRateConfig { + bytes32 id; + /// @dev Rate identifier uint16 min; - /// @dev Minimum rate in basis points [0-65535] + /// @dev Minimum rate in basis points uint16 max; - /// @dev Maximum rate in basis points [0-65535] + /// @dev Maximum rate in basis points uint16 step; } /// @dev Step size in basis points [0-65535] @@ -46,8 +49,8 @@ struct DSPCIlkConfig { /// @title Global configuration parameters for DSPC /// @dev Used to configure global parameters and collateral-specific settings struct DSPCConfig { - uint256 tau; /// @dev Time delay between rate updates + uint256 tau; DSPCIlkConfig[] ilks; } /// @dev Array of collateral configurations @@ -63,29 +66,27 @@ library DSPCInit { /// @param cfg The configuration parameters for DSPC function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) internal { // Set up permissions - DSPCLike dspc = DSPCLike(inst.dspc); - DSPCMomLike mom = DSPCMomLike(inst.mom); // Authorize DSPCMom in DSPC - dspc.rely(inst.mom); + RelyLike(inst.dspc).rely(inst.mom); // Set DSPCMom authority to MCD_ADM - mom.setAuthority(dss.chainlog.getAddress("MCD_ADM")); + MomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); // Authorize DSPC in core contracts dss.jug.rely(inst.dspc); dss.pot.rely(inst.dspc); - DSPCLike(dss.chainlog.getAddress("SUSDS")).rely(inst.dspc); + RelyLike(dss.chainlog.getAddress("SUSDS")).rely(inst.dspc); // Configure global parameters - dspc.file("tau", cfg.tau); + DSPCLike(inst.dspc).file("tau", cfg.tau); // Configure ilks for (uint256 i = 0; i < cfg.ilks.length; i++) { DSPCIlkConfig memory ilk = cfg.ilks[i]; - dspc.file(ilk.ilk, "max", uint256(ilk.max)); - dspc.file(ilk.ilk, "min", uint256(ilk.min)); - dspc.file(ilk.ilk, "step", uint256(ilk.step)); + DSPCLike(inst.dspc).file(ilk.ilk, "max", uint256(ilk.max)); + DSPCLike(inst.dspc).file(ilk.ilk, "min", uint256(ilk.min)); + DSPCLike(inst.dspc).file(ilk.ilk, "step", uint256(ilk.step)); } } } From 117aa005fbe4236ca8bf296ec13652903824df27 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 6 Mar 2025 18:48:58 -0300 Subject: [PATCH 31/96] chore: adjust tests for new var names --- src/DSPC.t.sol | 16 ++++++++-------- src/DSPCMom.t.sol | 4 ++-- src/deployment/DSPCInit.sol | 12 ++++++------ src/deployment/DSPCInit.t.sol | 12 ++++++------ 4 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 7b31bfa..847cc2a 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -20,7 +20,7 @@ import {DSPC} from "./DSPC.sol"; import {DSPCMom} from "./DSPCMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCIlkConfig} from "./deployment/DSPCInit.sol"; +import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./deployment/DSPCInit.sol"; import {DSPCInstance} from "./deployment/DSPCInstance.sol"; interface ConvLike { @@ -91,27 +91,27 @@ contract DSPCTest is DssTest { mom = DSPCMom(inst.mom); // Initialize deployment - DSPCIlkConfig[] memory ilks = new DSPCIlkConfig[](3); // ETH-A, DSR, SSR + DSPCRateConfig[] memory ilks = new DSPCRateConfig[](3); // ETH-A, DSR, SSR // Configure ETH-A - ilks[0] = DSPCIlkConfig({ - ilk: ILK, // Use the constant bytes32 ILK + ilks[0] = DSPCRateConfig({ + id: ILK, // Use the constant bytes32 ILK min: uint16(1), max: uint16(30000), step: uint16(100) }); // Configure DSR - ilks[1] = DSPCIlkConfig({ - ilk: DSR, // Use the constant bytes32 DSR + ilks[1] = DSPCRateConfig({ + id: DSR, // Use the constant bytes32 DSR min: uint16(1), max: uint16(30000), step: uint16(100) }); // Configure SSR - ilks[2] = DSPCIlkConfig({ - ilk: SSR, // Use the constant bytes32 SSR + ilks[2] = DSPCRateConfig({ + id: SSR, // Use the constant bytes32 SSR min: uint16(1), max: uint16(30000), step: uint16(100) diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index 1f8252f..ef4929b 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -21,7 +21,7 @@ import {DSPC} from "./DSPC.sol"; import {DSPCMom} from "./DSPCMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCIlkConfig} from "./deployment/DSPCInit.sol"; +import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./deployment/DSPCInit.sol"; import {DSPCInstance} from "./deployment/DSPCInstance.sol"; interface ChiefLike { @@ -99,7 +99,7 @@ contract DSPCMomIntegrationTest is DssTest { // Initialize deployment DSPCConfig memory cfg = DSPCConfig({ tau: 0, // Start with tau = 0 for tests - ilks: new DSPCIlkConfig[](0) // No ilks for this test + ilks: new DSPCRateConfig[](0) // No ilks for this test }); vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index d5be321..2462bc1 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -51,7 +51,7 @@ struct DSPCRateConfig { struct DSPCConfig { /// @dev Time delay between rate updates uint256 tau; - DSPCIlkConfig[] ilks; + DSPCRateConfig[] ilks; } /// @dev Array of collateral configurations @@ -71,7 +71,7 @@ library DSPCInit { RelyLike(inst.dspc).rely(inst.mom); // Set DSPCMom authority to MCD_ADM - MomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); + DSPCMomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); // Authorize DSPC in core contracts dss.jug.rely(inst.dspc); @@ -83,10 +83,10 @@ library DSPCInit { // Configure ilks for (uint256 i = 0; i < cfg.ilks.length; i++) { - DSPCIlkConfig memory ilk = cfg.ilks[i]; - DSPCLike(inst.dspc).file(ilk.ilk, "max", uint256(ilk.max)); - DSPCLike(inst.dspc).file(ilk.ilk, "min", uint256(ilk.min)); - DSPCLike(inst.dspc).file(ilk.ilk, "step", uint256(ilk.step)); + DSPCRateConfig memory ilk = cfg.ilks[i]; + DSPCLike(inst.dspc).file(ilk.id, "max", uint256(ilk.max)); + DSPCLike(inst.dspc).file(ilk.id, "min", uint256(ilk.min)); + DSPCLike(inst.dspc).file(ilk.id, "step", uint256(ilk.step)); } } } diff --git a/src/deployment/DSPCInit.t.sol b/src/deployment/DSPCInit.t.sol index e4fbc29..6e96e6d 100644 --- a/src/deployment/DSPCInit.t.sol +++ b/src/deployment/DSPCInit.t.sol @@ -21,7 +21,7 @@ import {DssInstance} from "dss-test/MCD.sol"; import {DSPC} from "../DSPC.sol"; import {DSPCMom} from "../DSPCMom.sol"; import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCIlkConfig} from "./DSPCInit.sol"; +import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./DSPCInit.sol"; import {DSPCInstance} from "./DSPCInstance.sol"; import {ConvMock} from "../mocks/ConvMock.sol"; @@ -96,19 +96,19 @@ contract DSPCInitTest is DssTest { function test_init() public { // Create test configuration - DSPCIlkConfig[] memory ilks = new DSPCIlkConfig[](2); + DSPCRateConfig[] memory ilks = new DSPCRateConfig[](2); // Configure ETH-A - ilks[0] = DSPCIlkConfig({ - ilk: "ETH-A", + ilks[0] = DSPCRateConfig({ + id: "ETH-A", min: uint16(0), // 0% max: uint16(1000), // 10% step: uint16(50) // 0.5% }); // Configure WBTC-A - ilks[1] = DSPCIlkConfig({ - ilk: "WBTC-A", + ilks[1] = DSPCRateConfig({ + id: "WBTC-A", min: uint16(0), // 0% max: uint16(1500), // 15% step: uint16(100) // 1% From a1b8da73c7c8a01f82aa1e10f45cf0d83da837a7 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 6 Mar 2025 18:51:56 -0300 Subject: [PATCH 32/96] chore: improve DSPCInit natspec --- src/deployment/DSPCInit.sol | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index 2462bc1..f1f53ef 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -36,12 +36,13 @@ interface DSPCMomLike { /// @title Configuration parameters for a rate in DSPC /// @dev Used to configure rate parameters for a specific rate struct DSPCRateConfig { - bytes32 id; /// @dev Rate identifier - uint16 min; + bytes32 id; /// @dev Minimum rate in basis points - uint16 max; + uint16 min; /// @dev Maximum rate in basis points + uint16 max; + /// @dev Maximum step size in basis points uint16 step; } /// @dev Step size in basis points [0-65535] @@ -51,6 +52,7 @@ struct DSPCRateConfig { struct DSPCConfig { /// @dev Time delay between rate updates uint256 tau; + /// @dev Collateral-specific settings DSPCRateConfig[] ilks; } /// @dev Array of collateral configurations From 12d2bfdfbb44b773275ed242d5ffa591548c32b0 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 6 Mar 2025 19:03:54 -0300 Subject: [PATCH 33/96] feat: add bud address to DSPCConfig --- src/DSPC.t.sol | 7 ++----- src/DSPCMom.t.sol | 3 ++- src/deployment/DSPCInit.sol | 5 +++++ src/deployment/DSPCInit.t.sol | 3 ++- 4 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 847cc2a..47ed51e 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -119,14 +119,11 @@ contract DSPCTest is DssTest { DSPCConfig memory cfg = DSPCConfig({ tau: 0, // Start with tau = 0 for tests - ilks: ilks + ilks: ilks, + bud: bud }); vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); - - // Kiss the bud address - vm.prank(address(pauseProxy)); - dspc.kiss(bud); } function test_constructor() public view { diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index ef4929b..441457b 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -99,7 +99,8 @@ contract DSPCMomIntegrationTest is DssTest { // Initialize deployment DSPCConfig memory cfg = DSPCConfig({ tau: 0, // Start with tau = 0 for tests - ilks: new DSPCRateConfig[](0) // No ilks for this test + ilks: new DSPCRateConfig[](0), // No ilks for this test + bud: address(0) // No bud for this test }); vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); diff --git a/src/deployment/DSPCInit.sol b/src/deployment/DSPCInit.sol index f1f53ef..1086d7c 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/DSPCInit.sol @@ -54,6 +54,8 @@ struct DSPCConfig { uint256 tau; /// @dev Collateral-specific settings DSPCRateConfig[] ilks; + /// @dev Bud to be authed within setup + address bud; } /// @dev Array of collateral configurations @@ -90,5 +92,8 @@ library DSPCInit { DSPCLike(inst.dspc).file(ilk.id, "min", uint256(ilk.min)); DSPCLike(inst.dspc).file(ilk.id, "step", uint256(ilk.step)); } + + // Authorize bud + DSPCLike(inst.dspc).kiss(cfg.bud); } } diff --git a/src/deployment/DSPCInit.t.sol b/src/deployment/DSPCInit.t.sol index 6e96e6d..bbfa8db 100644 --- a/src/deployment/DSPCInit.t.sol +++ b/src/deployment/DSPCInit.t.sol @@ -114,7 +114,7 @@ contract DSPCInitTest is DssTest { step: uint16(100) // 1% }); - DSPCConfig memory cfg = DSPCConfig({tau: 1 days, ilks: ilks}); + DSPCConfig memory cfg = DSPCConfig({tau: 1 days, ilks: ilks, bud: address(0x0ddaf)}); vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); @@ -132,6 +132,7 @@ contract DSPCInitTest is DssTest { // Verify configuration assertEq(DSPC(inst.dspc).tau(), cfg.tau, "Wrong tau"); + assertEq(DSPC(inst.dspc).buds(cfg.bud), 1, "Wrong bud"); // Verify ETH-A config DSPC.Cfg memory ethCfg = DSPC(inst.dspc).cfgs("ETH-A"); From c64ce03e2d49e0e5e8482d6c9021dc56718943a2 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 6 Mar 2025 19:11:00 -0300 Subject: [PATCH 34/96] fix: Remove setAuthority from deploy script in favor of only executing it in the init script --- src/deployment/DSPCDeploy.sol | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index 40ea790..db3f813 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -58,9 +58,7 @@ library DSPCDeploy { // Deploy DSPCMom for governance inst.mom = address(new DSPCMom()); - // First set authority for DSPCMom - DSPCMom(inst.mom).setAuthority(params.owner); - // Then switch owners + // Switch owners ScriptTools.switchOwner(inst.dspc, params.deployer, params.owner); MomLike(inst.mom).setOwner(params.owner); } From 4f5bd78aa46a2656aab1f4c95017f87c2c35be4d Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 7 Mar 2025 11:30:30 -0300 Subject: [PATCH 35/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 0d10704..aa51026 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -77,11 +77,11 @@ contract DSPC { /// @notice Mapping of rate constraints mapping(bytes32 => Cfg) private _cfgs; /// @notice Circuit breaker flag - uint256 public bad; + uint8 public bad; /// @notice Cooldown period between rate changes in seconds - uint256 public tau; + uint64 public tau; /// @notice Last time when rates were updated (Unix timestamp) - uint256 public toc; + uint128 public toc; // --- Events --- /** From bfc5de0095002db7974b8320747675cced7518ba Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 7 Mar 2025 11:32:08 -0300 Subject: [PATCH 36/96] refactor: optimize storage layout --- src/DSPC.sol | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index aa51026..bef34d1 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -195,9 +195,9 @@ contract DSPC { function file(bytes32 what, uint256 data) external auth { if (what == "bad") { require(data <= 1, "DSPC/invalid-bad-value"); - bad = data; + bad = uint8(data); } else if (what == "tau") { - tau = data; + tau = uint64(data); } else { revert("DSPC/file-unrecognized-param"); } @@ -240,7 +240,7 @@ contract DSPC { function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); require(block.timestamp >= tau + toc, "DSPC/too-early"); - toc = block.timestamp; + toc = uint128(block.timestamp); // Validate all updates in the batch for (uint256 i = 0; i < updates.length; i++) { From f6c7987a69cbf2051e05cb4a21f54ded41b43b59 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 7 Mar 2025 11:54:35 -0300 Subject: [PATCH 37/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 1 + 1 file changed, 1 insertion(+) diff --git a/src/DSPC.sol b/src/DSPC.sol index bef34d1..8f78be1 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -197,6 +197,7 @@ contract DSPC { require(data <= 1, "DSPC/invalid-bad-value"); bad = uint8(data); } else if (what == "tau") { + require(data <= type(uint64).max, "DSPC/invalid-tau-value"); tau = uint64(data); } else { revert("DSPC/file-unrecognized-param"); From 1d08161538f7ae9869de535803b5229e99fd6112 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 7 Mar 2025 12:03:13 -0300 Subject: [PATCH 38/96] chore: test case for tau overflow in file() --- src/DSPC.t.sol | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 47ed51e..476badb 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -163,6 +163,9 @@ contract DSPCTest is DssTest { dspc.file("tau", 1 days); assertEq(dspc.tau(), 1 days); + vm.expectRevert("DSPC/invalid-tau-value"); + dspc.file("tau", uint256(type(uint64).max) + 1); + vm.stopPrank(); } From 43ed724deff84ea66b92e95b03a5efbe04b7ba7c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 10 Mar 2025 14:32:49 -0300 Subject: [PATCH 39/96] fix: prevent duplicate ilks --- src/DSPC.sol | 3 ++- src/DSPC.t.sol | 16 ++++++++++++++-- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 8f78be1..677dcbf 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -229,7 +229,7 @@ contract DSPC { } /// @notice Apply rate updates - /// @param updates Array of rate updates to apply + /// @param updates Array of rate updates to apply (strictly ordered by id) /// @dev Each update is validated against configured constraints before being applied /// @dev Emits Set event after all updates are successfully applied /// @dev Reverts if: @@ -249,6 +249,7 @@ contract DSPC { uint256 bps = updates[i].bps; Cfg memory cfg = _cfgs[id]; + if (i > 0) require(id > updates[i - 1].id, "DSPC/updates-out-of-order"); require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 476badb..6364e43 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -250,8 +250,8 @@ contract DSPCTest is DssTest { uint256 ssrTarget = conv.rtob(susds.ssr()) + 50; DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](3); - updates[0] = DSPC.ParamChange(ILK, ilkTarget); - updates[1] = DSPC.ParamChange(DSR, dsrTarget); + updates[0] = DSPC.ParamChange(DSR, dsrTarget); + updates[1] = DSPC.ParamChange(ILK, ilkTarget); updates[2] = DSPC.ParamChange(SSR, ssrTarget); vm.prank(bud); @@ -263,6 +263,18 @@ contract DSPCTest is DssTest { assertEq(susds.ssr(), conv.btor(ssrTarget)); } + function test_set_duplicate() public { + (uint256 duty,) = dss.jug.ilks(ILK); + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); + updates[0] = DSPC.ParamChange(ILK, conv.rtob(duty) - 100); + updates[1] = DSPC.ParamChange(ILK, conv.rtob(duty) - 200); // duplicate, pushing rate beyond step + + vm.prank(bud); + vm.expectRevert("DSPC/updates-out-of-order"); + dspc.set(updates); + } + function test_set_empty() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); From c81e89531c4a5faae87a661cf023dae0f7ba0e65 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 10 Mar 2025 19:44:06 -0300 Subject: [PATCH 40/96] chore: fix natspec --- src/DSPC.sol | 10 +++++----- src/DSPC.t.sol | 16 ++++++++-------- src/deployment/DSPCDeploy.sol | 12 ++++++------ 3 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 677dcbf..1237454 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -106,14 +106,14 @@ contract DSPC { event Diss(address indexed usr); /** * @notice A contract parameter was updated. - * @param what The changed parameter name. ["bad"]. + * @param what The changed parameter name. * @param data The new value of the parameter. */ event File(bytes32 indexed what, uint256 data); /** * @notice A Ilk/DSR/SSR parameter was updated. * @param id The Ilk/DSR/SSR identifier. - * @param what The changed parameter name. ["bad"]. + * @param what The changed parameter name. * @param data The new value of the parameter. */ event File(bytes32 indexed id, bytes32 indexed what, uint256 data); @@ -231,7 +231,7 @@ contract DSPC { /// @notice Apply rate updates /// @param updates Array of rate updates to apply (strictly ordered by id) /// @dev Each update is validated against configured constraints before being applied - /// @dev Emits Set event after all updates are successfully applied + /// @dev Emits Set event for each update. /// @dev Reverts if: /// - Empty updates array /// - Cooldown not expired @@ -287,8 +287,8 @@ contract DSPC { // --- Getters --- /// @notice Get configuration for a rate /// @param id The rate identifier (ilk name, "DSR", or "SSR") - /// @return The configuration struct containing min and max values - /// @dev Returns a Cfg struct with min and max values for the specified rate + /// @return The configuration struct containing min, max and step values + /// @dev Returns a Cfg struct with min, max and step values for the specified rate function cfgs(bytes32 id) external view returns (Cfg memory) { return _cfgs[id]; } diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 6364e43..90f3703 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -185,7 +185,7 @@ contract DSPCTest is DssTest { assertEq(dspc.cfgs(ILK).step, 420); } - function test_file_ilk_invalid() public { + function test_revert_file_ilk_invalid() public { vm.startPrank(address(pauseProxy)); DSPC.Cfg memory cfg = dspc.cfgs(ILK); @@ -263,7 +263,7 @@ contract DSPCTest is DssTest { assertEq(susds.ssr(), conv.btor(ssrTarget)); } - function test_set_duplicate() public { + function test_revert_set_duplicate() public { (uint256 duty,) = dss.jug.ilks(ILK); DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); @@ -275,7 +275,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_set_empty() public { + function test_revert_set_empty() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); vm.expectRevert("DSPC/empty-batch"); @@ -283,7 +283,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_set_unauthorized() public { + function test_revert_set_unauthorized() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); updates[0] = DSPC.ParamChange(ILK, 100); @@ -291,7 +291,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_set_below_min() public { + function test_revert_set_below_min() public { vm.prank(address(pauseProxy)); dspc.file(ILK, "min", 100); @@ -303,7 +303,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_set_above_max() public { + function test_revert_set_above_max() public { vm.prank(address(pauseProxy)); dspc.file(ILK, "max", 100); @@ -315,7 +315,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_set_delta_above_step() public { + function test_revert_set_delta_above_step() public { vm.prank(address(pauseProxy)); dspc.file(ILK, "step", 100); @@ -327,7 +327,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_set_before_cooldown() public { + function test_revert_set_before_cooldown() public { vm.prank(address(pauseProxy)); dspc.file("tau", 100); uint256 currentDSR = conv.rtob(dss.pot.dsr()); diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/DSPCDeploy.sol index db3f813..42b229f 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/DSPCDeploy.sol @@ -29,19 +29,19 @@ interface MomLike { /// @notice Parameters required for deploying the DSPC system /// @dev Used to configure the initial setup of DSPC and DSPCMom contracts struct DSPCDeployParams { - address deployer; /// @dev Address deploying the contracts - address owner; + address deployer; /// @dev Final owner address after deployment - address jug; + address owner; /// @dev MakerDAO Jug contract address - address pot; + address jug; /// @dev MakerDAO Pot contract address - address susds; + address pot; /// @dev SUSDS contract address + address susds; + /// @dev Rate converter contract address address conv; } -/// @dev Rate converter contract address /// @title DSPC Deployment Library /// @notice Handles deployment of DSPC system contracts From 4fc314a50fd74fe9b87f4a0dd2ce1681da1b889a Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 10 Mar 2025 19:45:09 -0300 Subject: [PATCH 41/96] chore: fix readme reference to SUSDS --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a965c20..8f0edc3 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ A module for MakerDAO that enables direct changes to stability parameters (duty, The DSPC module provides a streamlined way to modify stability parameters in the Maker Protocol, including: - Stability fees (duty) for different collateral types via the Jug contract - Dai Savings Rate (DSR) via the Pot contract -- Staked Dai Savings Rate (SSR) via the sUSD contract +- Sky Savings Rate (SSR) via the sUSDS contract ## Features From cfe098af9fd3603b807fe7a1149ae77b2d4fdf89 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 10 Mar 2025 19:59:36 -0300 Subject: [PATCH 42/96] refactor: fisibility of _cfgs to public --- src/DSPC.sol | 23 +++++++---------------- src/DSPC.t.sol | 20 +++++++++++--------- src/deployment/DSPCInit.t.sol | 16 ++++++++-------- 3 files changed, 26 insertions(+), 33 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 1237454..dd17381 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -75,7 +75,7 @@ contract DSPC { /// @notice Mapping of addresses that can operate this module mapping(address => uint256) public buds; /// @notice Mapping of rate constraints - mapping(bytes32 => Cfg) private _cfgs; + mapping(bytes32 => Cfg) public cfgs; /// @notice Circuit breaker flag uint8 public bad; /// @notice Cooldown period between rate changes in seconds @@ -214,13 +214,13 @@ contract DSPC { function file(bytes32 id, bytes32 what, uint256 data) external auth { require(data <= type(uint16).max, "DSPC/invalid-value"); if (what == "min") { - require(data <= _cfgs[id].max, "DSPC/min-too-high"); - _cfgs[id].min = uint16(data); + require(data <= cfgs[id].max, "DSPC/min-too-high"); + cfgs[id].min = uint16(data); } else if (what == "max") { - require(data >= _cfgs[id].min, "DSPC/max-too-low"); - _cfgs[id].max = uint16(data); + require(data >= cfgs[id].min, "DSPC/max-too-low"); + cfgs[id].max = uint16(data); } else if (what == "step") { - _cfgs[id].step = uint16(data); + cfgs[id].step = uint16(data); } else { revert("DSPC/file-unrecognized-param"); } @@ -247,7 +247,7 @@ contract DSPC { for (uint256 i = 0; i < updates.length; i++) { bytes32 id = updates[i].id; uint256 bps = updates[i].bps; - Cfg memory cfg = _cfgs[id]; + Cfg memory cfg = cfgs[id]; if (i > 0) require(id > updates[i - 1].id, "DSPC/updates-out-of-order"); require(bps >= cfg.min, "DSPC/below-min"); @@ -283,13 +283,4 @@ contract DSPC { emit Set(id, bps); } } - - // --- Getters --- - /// @notice Get configuration for a rate - /// @param id The rate identifier (ilk name, "DSR", or "SSR") - /// @return The configuration struct containing min, max and step values - /// @dev Returns a Cfg struct with min, max and step values for the specified rate - function cfgs(bytes32 id) external view returns (Cfg memory) { - return _cfgs[id]; - } } diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 90f3703..b240547 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -170,9 +170,10 @@ contract DSPCTest is DssTest { } function test_file_ilk() public { - assertEq(dspc.cfgs(ILK).min, 1); - assertEq(dspc.cfgs(ILK).max, 30000); - assertEq(dspc.cfgs(ILK).step, 100); + (uint16 min, uint16 max, uint16 step) = dspc.cfgs(ILK); + assertEq(min, 1); + assertEq(max, 30000); + assertEq(step, 100); vm.startPrank(address(pauseProxy)); dspc.file(ILK, "min", 100); @@ -180,20 +181,21 @@ contract DSPCTest is DssTest { dspc.file(ILK, "step", 420); vm.stopPrank(); - assertEq(dspc.cfgs(ILK).min, 100); - assertEq(dspc.cfgs(ILK).max, 3000); - assertEq(dspc.cfgs(ILK).step, 420); + (min, max, step) = dspc.cfgs(ILK); + assertEq(min, 100); + assertEq(max, 3000); + assertEq(step, 420); } function test_revert_file_ilk_invalid() public { vm.startPrank(address(pauseProxy)); - DSPC.Cfg memory cfg = dspc.cfgs(ILK); + (uint16 min, uint16 max,) = dspc.cfgs(ILK); vm.expectRevert("DSPC/min-too-high"); - dspc.file(ILK, "min", cfg.max + 1); + dspc.file(ILK, "min", max + 1); vm.expectRevert("DSPC/max-too-low"); - dspc.file(ILK, "max", cfg.min - 1); + dspc.file(ILK, "max", min - 1); vm.expectRevert("DSPC/file-unrecognized-param"); dspc.file(ILK, "unknown", 100); diff --git a/src/deployment/DSPCInit.t.sol b/src/deployment/DSPCInit.t.sol index bbfa8db..abc82f7 100644 --- a/src/deployment/DSPCInit.t.sol +++ b/src/deployment/DSPCInit.t.sol @@ -135,15 +135,15 @@ contract DSPCInitTest is DssTest { assertEq(DSPC(inst.dspc).buds(cfg.bud), 1, "Wrong bud"); // Verify ETH-A config - DSPC.Cfg memory ethCfg = DSPC(inst.dspc).cfgs("ETH-A"); - assertEq(ethCfg.min, ilks[0].min, "Wrong ETH-A min"); - assertEq(ethCfg.max, ilks[0].max, "Wrong ETH-A max"); - assertEq(ethCfg.step, ilks[0].step, "Wrong ETH-A step"); + (uint16 min, uint16 max, uint16 step) = DSPC(inst.dspc).cfgs("ETH-A"); + assertEq(min, ilks[0].min, "Wrong ETH-A min"); + assertEq(max, ilks[0].max, "Wrong ETH-A max"); + assertEq(step, ilks[0].step, "Wrong ETH-A step"); // Verify WBTC-A config - DSPC.Cfg memory wbtcCfg = DSPC(inst.dspc).cfgs("WBTC-A"); - assertEq(wbtcCfg.min, ilks[1].min, "Wrong WBTC-A min"); - assertEq(wbtcCfg.max, ilks[1].max, "Wrong WBTC-A max"); - assertEq(wbtcCfg.step, ilks[1].step, "Wrong WBTC-A step"); + (min, max, step) = DSPC(inst.dspc).cfgs("WBTC-A"); + assertEq(min, ilks[1].min, "Wrong WBTC-A min"); + assertEq(max, ilks[1].max, "Wrong WBTC-A max"); + assertEq(step, ilks[1].step, "Wrong WBTC-A step"); } } From d45a82d4424026f90a46c5bd80fc7ae539da7510 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 10 Mar 2025 20:22:39 -0300 Subject: [PATCH 43/96] fix: check if ilk setup on set() --- src/DSPC.sol | 1 + src/DSPC.t.sol | 9 +++++++++ 2 files changed, 10 insertions(+) diff --git a/src/DSPC.sol b/src/DSPC.sol index dd17381..109fa51 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -249,6 +249,7 @@ contract DSPC { uint256 bps = updates[i].bps; Cfg memory cfg = cfgs[id]; + require(cfg.step > 0, "DSPC/ilk-not-configured"); if (i > 0) require(id > updates[i - 1].id, "DSPC/updates-out-of-order"); require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index b240547..86c158a 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -277,6 +277,15 @@ contract DSPCTest is DssTest { dspc.set(updates); } + function test_revert_set_unexisting_ilk() public { + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange("PEPE-A", 10000); + + vm.prank(bud); + vm.expectRevert("DSPC/ilk-not-configured"); + dspc.set(updates); + } + function test_revert_set_empty() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); From f6d6d67e8f90423f36f3493a91a55a6e6a542588 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 10 Mar 2025 20:31:05 -0300 Subject: [PATCH 44/96] chore: Add comment to file function (ilks) mentioned order of calls may impact execution depending on previous values --- src/DSPC.sol | 1 + 1 file changed, 1 insertion(+) diff --git a/src/DSPC.sol b/src/DSPC.sol index 109fa51..d02fdda 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -211,6 +211,7 @@ contract DSPC { /// @param what The parameter to configure ("min", "max" or "step") /// @param data The value to set /// @dev Emits File event after successful configuration + /// @dev Note that ordering may be relevant if setting min and max in the same transaction, as the transaction may revert if the new max is lower than the old min (or vice versa). function file(bytes32 id, bytes32 what, uint256 data) external auth { require(data <= type(uint16).max, "DSPC/invalid-value"); if (what == "min") { From 827b25f3a36f0c45df856038db866e204ed28bcd Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 04:02:33 -0300 Subject: [PATCH 45/96] Update src/DSPC.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index d02fdda..b6df128 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -250,7 +250,7 @@ contract DSPC { uint256 bps = updates[i].bps; Cfg memory cfg = cfgs[id]; - require(cfg.step > 0, "DSPC/ilk-not-configured"); + require(cfg.step > 0, "DSPC/rate-not-configured"); if (i > 0) require(id > updates[i - 1].id, "DSPC/updates-out-of-order"); require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); From 7342217207f5ef066992b537ee97fe2fd0bd4b86 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 04:02:46 -0300 Subject: [PATCH 46/96] Update src/DSPC.t.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 86c158a..2be7603 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -277,7 +277,7 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_revert_set_unexisting_ilk() public { + function test_revert_set_not_configured_rate() public { DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); updates[0] = DSPC.ParamChange("PEPE-A", 10000); From 15e83c34a36174cbb378b391ee4d029aa9aa9a05 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 04:05:09 -0300 Subject: [PATCH 47/96] fix: update revert reason in test_revert_set_not_configured_rate --- src/DSPC.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 2be7603..e7e95c0 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -282,7 +282,7 @@ contract DSPCTest is DssTest { updates[0] = DSPC.ParamChange("PEPE-A", 10000); vm.prank(bud); - vm.expectRevert("DSPC/ilk-not-configured"); + vm.expectRevert("DSPC/rate-not-configured"); dspc.set(updates); } From 990ac84e141e0f1a6b8b87edae8e11375a14a5ea Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 17:18:18 -0300 Subject: [PATCH 48/96] fix: prevent setup of unexisting Ilks --- src/DSPC.sol | 4 ++++ src/DSPC.t.sol | 3 +++ 2 files changed, 7 insertions(+) diff --git a/src/DSPC.sol b/src/DSPC.sol index b6df128..6689269 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -213,6 +213,10 @@ contract DSPC { /// @dev Emits File event after successful configuration /// @dev Note that ordering may be relevant if setting min and max in the same transaction, as the transaction may revert if the new max is lower than the old min (or vice versa). function file(bytes32 id, bytes32 what, uint256 data) external auth { + if (id != "DSR" && id != "SSR") { + (, uint256 rho) = jug.ilks(id); + require(rho > 0, "DSPC/ilk-not-initialized"); + } require(data <= type(uint16).max, "DSPC/invalid-value"); if (what == "min") { require(data <= cfgs[id].max, "DSPC/min-too-high"); diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index e7e95c0..c422655 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -203,6 +203,9 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/invalid-value"); dspc.file(ILK, "max", uint256(type(uint16).max) + 1); + vm.expectRevert("DSPC/ilk-not-initialized"); + dspc.file("MOG-A", "min", 100); + vm.stopPrank(); } From 94af8f051fe6ec0978ffb7d45ec0e2f888093c8a Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 17:31:56 -0300 Subject: [PATCH 49/96] refactor: ordering of ilks check --- src/DSPC.sol | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 6689269..343f1e1 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -248,14 +248,14 @@ contract DSPC { require(block.timestamp >= tau + toc, "DSPC/too-early"); toc = uint128(block.timestamp); - // Validate all updates in the batch + bytes32 last; for (uint256 i = 0; i < updates.length; i++) { bytes32 id = updates[i].id; uint256 bps = updates[i].bps; Cfg memory cfg = cfgs[id]; require(cfg.step > 0, "DSPC/rate-not-configured"); - if (i > 0) require(id > updates[i - 1].id, "DSPC/updates-out-of-order"); + require(id > last, "DSPC/updates-out-of-order"); require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); @@ -274,6 +274,8 @@ contract DSPC { uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; require(delta <= cfg.step, "DSPC/delta-above-step"); + last = id; + // Execute the update uint256 ray = conv.btor(bps); if (id == "DSR") { From a67531bb621a105fd4d24609febd302d91c1ab5e Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 17:34:51 -0300 Subject: [PATCH 50/96] refactor: improve invalid bad check --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 343f1e1..62d3fb7 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -194,7 +194,7 @@ contract DSPC { /// @dev Emits File event after successful configuration function file(bytes32 what, uint256 data) external auth { if (what == "bad") { - require(data <= 1, "DSPC/invalid-bad-value"); + require(data == 0 || data == 1, "DSPC/invalid-bad-value"); bad = uint8(data); } else if (what == "tau") { require(data <= type(uint64).max, "DSPC/invalid-tau-value"); From e5177a90267a1745828cb1235a2899a60161a3b4 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 18:11:51 -0300 Subject: [PATCH 51/96] chore: improve natspec dos for file(what, data) --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 62d3fb7..377a2f8 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -189,7 +189,7 @@ contract DSPC { } /// @notice Configure module parameters - /// @param what The parameter to configure + /// @param what The parameter to configure ("bad" or "tau") /// @param data The value to set /// @dev Emits File event after successful configuration function file(bytes32 what, uint256 data) external auth { From ea0b5f375ab05e5ad9cfe4bcf53fd5a4eb5066d7 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 11 Mar 2025 18:44:30 -0300 Subject: [PATCH 52/96] refactor: order of checks on set() --- src/DSPC.sol | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 377a2f8..84d46a7 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -251,11 +251,14 @@ contract DSPC { bytes32 last; for (uint256 i = 0; i < updates.length; i++) { bytes32 id = updates[i].id; + + require(id > last, "DSPC/updates-out-of-order"); + last = id; + uint256 bps = updates[i].bps; Cfg memory cfg = cfgs[id]; require(cfg.step > 0, "DSPC/rate-not-configured"); - require(id > last, "DSPC/updates-out-of-order"); require(bps >= cfg.min, "DSPC/below-min"); require(bps <= cfg.max, "DSPC/above-max"); @@ -274,8 +277,6 @@ contract DSPC { uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; require(delta <= cfg.step, "DSPC/delta-above-step"); - last = id; - // Execute the update uint256 ray = conv.btor(bps); if (id == "DSR") { From a72e855d926db6490dd47b6e4679081f08cee0d5 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 12 Mar 2025 15:48:33 -0300 Subject: [PATCH 53/96] fix: ilk initialization verification --- src/DSPC.sol | 4 ++-- src/DSPC.t.sol | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 84d46a7..01392cd 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -214,8 +214,8 @@ contract DSPC { /// @dev Note that ordering may be relevant if setting min and max in the same transaction, as the transaction may revert if the new max is lower than the old min (or vice versa). function file(bytes32 id, bytes32 what, uint256 data) external auth { if (id != "DSR" && id != "SSR") { - (, uint256 rho) = jug.ilks(id); - require(rho > 0, "DSPC/ilk-not-initialized"); + (uint256 duty,) = jug.ilks(id); + require(duty > 0, "DSPC/ilk-not-initialized"); } require(data <= type(uint16).max, "DSPC/invalid-value"); if (what == "min") { diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index c422655..4efc079 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -203,6 +203,7 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/invalid-value"); dspc.file(ILK, "max", uint256(type(uint16).max) + 1); + dss.jug.drip("MOG-A"); vm.expectRevert("DSPC/ilk-not-initialized"); dspc.file("MOG-A", "min", 100); From 6d0cf285670d0a8ddebe9cfe8dd37b3942cadbeb Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 12 Mar 2025 21:21:37 -0300 Subject: [PATCH 54/96] feat: allow ward to edit toc --- src/DSPC.sol | 5 ++++- src/DSPC.t.sol | 7 +++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 01392cd..dea7151 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -198,7 +198,10 @@ contract DSPC { bad = uint8(data); } else if (what == "tau") { require(data <= type(uint64).max, "DSPC/invalid-tau-value"); - tau = uint64(data); + tau = uint64(data); + } else if (what == "toc") { + require(data <= type(uint128).max, "DSPC/invalid-toc-value"); + toc = uint128(data); } else { revert("DSPC/file-unrecognized-param"); } diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 4efc079..69eef77 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -166,6 +166,13 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/invalid-tau-value"); dspc.file("tau", uint256(type(uint64).max) + 1); + assertEq(dspc.toc(), 0); + dspc.file("toc", block.timestamp); + assertEq(dspc.toc(), block.timestamp); + + vm.expectRevert("DSPC/invalid-toc-value"); + dspc.file("toc", uint256(type(uint128).max) + 1); + vm.stopPrank(); } From 61c6c883dab0dd31a8b12973c0c348c426458c32 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 12 Mar 2025 21:41:53 -0300 Subject: [PATCH 55/96] feat: revert if current rate outside range --- src/DSPC.sol | 4 +++- src/DSPC.t.sol | 24 ++++++++++++++++++++---- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index dea7151..d336841 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -198,7 +198,7 @@ contract DSPC { bad = uint8(data); } else if (what == "tau") { require(data <= type(uint64).max, "DSPC/invalid-tau-value"); - tau = uint64(data); + tau = uint64(data); } else if (what == "toc") { require(data <= type(uint128).max, "DSPC/invalid-toc-value"); toc = uint128(data); @@ -280,6 +280,8 @@ contract DSPC { uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; require(delta <= cfg.step, "DSPC/delta-above-step"); + require(oldBps >= cfg.min && oldBps <= cfg.max, "DSPC/rate-out-of-bounds"); + // Execute the update uint256 ray = conv.btor(bps); if (id == "DSR") { diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 69eef77..e9c1beb 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -97,7 +97,7 @@ contract DSPCTest is DssTest { ilks[0] = DSPCRateConfig({ id: ILK, // Use the constant bytes32 ILK min: uint16(1), - max: uint16(30000), + max: uint16(3000), step: uint16(100) }); @@ -105,7 +105,7 @@ contract DSPCTest is DssTest { ilks[1] = DSPCRateConfig({ id: DSR, // Use the constant bytes32 DSR min: uint16(1), - max: uint16(30000), + max: uint16(3000), step: uint16(100) }); @@ -113,7 +113,7 @@ contract DSPCTest is DssTest { ilks[2] = DSPCRateConfig({ id: SSR, // Use the constant bytes32 SSR min: uint16(1), - max: uint16(30000), + max: uint16(3000), step: uint16(100) }); @@ -179,7 +179,7 @@ contract DSPCTest is DssTest { function test_file_ilk() public { (uint16 min, uint16 max, uint16 step) = dspc.cfgs(ILK); assertEq(min, 1); - assertEq(max, 30000); + assertEq(max, 3000); assertEq(step, 100); vm.startPrank(address(pauseProxy)); @@ -366,4 +366,20 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/too-early"); dspc.set(updates); } + + function test_revert_set_rate_outside_range() public { + dss.jug.drip(ILK); + uint256 rate = conv.btor(3050); + vm.prank(address(pauseProxy)); + dss.jug.file(ILK, "duty", rate); // outside range but within step + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 2999); + + vm.expectRevert("DSPC/rate-out-of-bounds"); + vm.prank(bud); + dspc.set(updates); + } } + +// 1000000008441243084037259619 From 7145e554bd05cd104a88c27f5599e5b49ea2694d Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 18:55:17 -0300 Subject: [PATCH 56/96] Apply suggestions from code review Co-authored-by: telome <130504305+telome@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 4 ++-- src/DSPC.t.sol | 18 ++---------------- 2 files changed, 4 insertions(+), 18 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index d336841..08a4a47 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -276,12 +276,12 @@ contract DSPC { oldBps = conv.rtob(duty); } + require(oldBps >= cfg.min && oldBps <= cfg.max, "DSPC/rate-out-of-bounds"); + // Calculates absolute difference between the old and the new rate uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; require(delta <= cfg.step, "DSPC/delta-above-step"); - require(oldBps >= cfg.min && oldBps <= cfg.max, "DSPC/rate-out-of-bounds"); - // Execute the update uint256 ray = conv.btor(bps); if (id == "DSR") { diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index e9c1beb..c8fae1c 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -147,29 +147,16 @@ contract DSPCTest is DssTest { } function test_file() public { + checkFileUint(address(dspc), "DSPC", ["bad", "tau", "toc"]); + vm.startPrank(address(pauseProxy)); - assertEq(dspc.bad(), 0); - dspc.file("bad", 1); - assertEq(dspc.bad(), 1); - vm.expectRevert("DSPC/invalid-bad-value"); dspc.file("bad", 2); - vm.expectRevert("DSPC/file-unrecognized-param"); - dspc.file("unknown", 1); - - assertEq(dspc.tau(), 0); - dspc.file("tau", 1 days); - assertEq(dspc.tau(), 1 days); - vm.expectRevert("DSPC/invalid-tau-value"); dspc.file("tau", uint256(type(uint64).max) + 1); - assertEq(dspc.toc(), 0); - dspc.file("toc", block.timestamp); - assertEq(dspc.toc(), block.timestamp); - vm.expectRevert("DSPC/invalid-toc-value"); dspc.file("toc", uint256(type(uint128).max) + 1); @@ -382,4 +369,3 @@ contract DSPCTest is DssTest { } } -// 1000000008441243084037259619 From aec447ac7e46b694819601b6e34d03d8f7bf57c7 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 18:56:04 -0300 Subject: [PATCH 57/96] Update src/mocks/ConvMock.sol Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/mocks/ConvMock.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index a68ea5b..43d6566 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -14,7 +14,7 @@ // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see . -pragma solidity 0.8.24; +pragma solidity ^0.8.24; contract ConvMock { /// @notice The max bps supported in bps -> rate conversion. From d9d9b5a08d9e9bd5cdfd9a97dba598bf05b645ac Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 19:05:40 -0300 Subject: [PATCH 58/96] chore: update natspec of set() to include all cases where it reverts --- src/DSPC.sol | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/DSPC.sol b/src/DSPC.sol index 08a4a47..dea6511 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -243,8 +243,11 @@ contract DSPC { /// @dev Reverts if: /// - Empty updates array /// - Cooldown not expired + /// - Ilks out of order + /// - Rate (ilk) not configured /// - Rate below configured minimum /// - Rate above configured maximum + /// - Current system rate out of bounds (not between configured minimum and maximum) /// - Rate change above configured step function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); From 1d678cb38435a23faef0764a320d90838e02748c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 21:23:24 -0300 Subject: [PATCH 59/96] chore: improve tests --- src/DSPC.t.sol | 62 ++++++++++++++++++++++++++++++++++++++++++++--- src/DSPCMom.t.sol | 41 +++++++++++++++++-------------- 2 files changed, 82 insertions(+), 21 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index c8fae1c..6b952a2 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -63,7 +63,7 @@ contract DSPCTest is DssTest { event Kiss(address indexed usr); event Diss(address indexed usr); event File(bytes32 indexed id, bytes32 indexed what, uint256 data); - event Set(DSPC.ParamChange[] updates); + event Set(bytes32 indexed id, uint256 bps); function setUp() public { vm.createSelectFork("mainnet"); @@ -146,9 +146,54 @@ contract DSPCTest is DssTest { checkAuth(address(dspc), "DSPC"); } + function test_auth_methods() public { + checkModifier( + address(dspc), + "DSPC/not-authorized", + [DSPC.kiss.selector, DSPC.diss.selector, DSPC.rely.selector, DSPC.deny.selector] + ); + } + + function test_toll_methods() public { + checkModifier(address(dspc), "DSPC/not-facilitator", [DSPC.set.selector]); + } + + function test_good_methods() public { + vm.startPrank(address(pauseProxy)); + dspc.file("bad", 1); + dspc.kiss(address(this)); + vm.stopPrank(); + + checkModifier(address(dspc), "DSPC/module-halted", [DSPC.set.selector]); + } + + function test_kiss() public { + address who = address(0x0ddaf); + assertEq(dspc.buds(who), 0); + + vm.prank(address(pauseProxy)); + vm.expectEmit(true, true, true, true); + emit Kiss(who); + dspc.kiss(who); + assertEq(dspc.buds(who), 1); + } + + function test_diss() public { + address who = address(0x0ddaf); + vm.prank(address(pauseProxy)); + dspc.kiss(who); + assertEq(dspc.buds(who), 1); + + vm.prank(address(pauseProxy)); + vm.expectEmit(true, true, true, true); + emit Diss(who); + dspc.diss(who); + assertEq(dspc.buds(who), 0); + } + function test_file() public { checkFileUint(address(dspc), "DSPC", ["bad", "tau", "toc"]); - + vm.startPrank(address(pauseProxy)); vm.expectRevert("DSPC/invalid-bad-value"); @@ -161,6 +206,9 @@ contract DSPCTest is DssTest { dspc.file("toc", uint256(type(uint128).max) + 1); vm.stopPrank(); + + vm.expectRevert("DSPC/not-authorized"); + dspc.file("bad", 1); } function test_file_ilk() public { @@ -170,6 +218,9 @@ contract DSPCTest is DssTest { assertEq(step, 100); vm.startPrank(address(pauseProxy)); + + vm.expectEmit(true, true, true, true); + emit File(ILK, "min", 100); dspc.file(ILK, "min", 100); dspc.file(ILK, "max", 3000); dspc.file(ILK, "step", 420); @@ -202,6 +253,9 @@ contract DSPCTest is DssTest { dspc.file("MOG-A", "min", 100); vm.stopPrank(); + + vm.expectRevert("DSPC/not-authorized"); + dspc.file(ILK, "min", 100); } function test_set_ilk() public { @@ -238,6 +292,9 @@ contract DSPCTest is DssTest { updates[0] = DSPC.ParamChange(SSR, target); vm.prank(bud); + + vm.expectEmit(true, true, true, true); + emit Set(SSR, target); dspc.set(updates); assertEq(susds.ssr(), conv.btor(target)); @@ -368,4 +425,3 @@ contract DSPCTest is DssTest { dspc.set(updates); } } - diff --git a/src/DSPCMom.t.sol b/src/DSPCMom.t.sol index 441457b..f84add2 100644 --- a/src/DSPCMom.t.sol +++ b/src/DSPCMom.t.sol @@ -110,42 +110,47 @@ contract DSPCMomIntegrationTest is DssTest { assertEq(mom.owner(), address(pauseProxy)); } + function test_only_owner_methods() public { + checkModifier(address(mom), "DSPCMom/not-owner", [DSPCMom.setOwner.selector, DSPCMom.setAuthority.selector]); + } + + function test_auth_methods() public { + checkModifier(address(mom), "DSPCMom/not-authorized", [DSPCMom.halt.selector]); + + vm.prank(address(pauseProxy)); + mom.setAuthority(address(0)); + checkModifier(address(mom), "DSPCMom/not-authorized", [DSPCMom.halt.selector]); + } + function test_setOwner() public { vm.prank(address(pauseProxy)); + vm.expectEmit(true, true, true, true); + emit SetOwner(address(0x1234)); mom.setOwner(address(0x1234)); assertEq(mom.owner(), address(0x1234)); } - function test_setOwner_unauthorized() public { - vm.expectRevert("DSPCMom/not-owner"); - mom.setOwner(address(0x123)); - } - function test_setAuthority() public { vm.prank(address(pauseProxy)); + vm.expectEmit(true, true, true, true); + emit SetAuthority(address(0x123)); mom.setAuthority(address(0x123)); assertEq(address(mom.authority()), address(0x123)); } - function test_setAuthority_unauthorized() public { - vm.expectRevert("DSPCMom/not-owner"); - mom.setAuthority(address(0x123)); - } - - function test_halt_unauthorized() public { - vm.expectRevert("DSPCMom/not-authorized"); + function check_halt(address who) internal { + vm.prank(who); + vm.expectEmit(true, true, true, true); + emit Halt(address(dspc)); mom.halt(address(dspc)); + assertEq(dspc.bad(), 1); } function test_halt_owner() public { - vm.prank(address(pauseProxy)); - mom.halt(address(dspc)); - assertEq(dspc.bad(), 1); + check_halt(address(pauseProxy)); } function test_halt_hat() public { - vm.prank(chief.hat()); - mom.halt(address(dspc)); - assertEq(dspc.bad(), 1); + check_halt(chief.hat()); } } From d9612a6d9f5b0c6166f4c78933fa87272f1b6590 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 22:35:06 -0300 Subject: [PATCH 60/96] chore: natspec --- src/DSPC.sol | 99 ++++++++++++++++++++++++++++++------------------- src/DSPCMom.sol | 39 +++++++++++-------- 2 files changed, 84 insertions(+), 54 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index dea6511..6f42298 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -39,24 +39,32 @@ interface ConvLike { function rtob(uint256 ray) external pure returns (uint256 bps); } -/// @title Direct Stability Parameters Change Module -/// @notice A module that allows direct changes to stability parameters with constraints -/// @dev This contract manages stability parameters for ilks, DSR, and SSR with configurable limits +/// @title Direct Stability Parameters Change Module (DSPC) +/// @notice A module for managing protocol stability parameters with configurable constraints and safety checks +/// @dev Provides controlled access to modify stability parameters (ilk stability fees, DSR, SSR) with: +/// - Configurable min/max bounds and step sizes for each parameter +/// - Cooldown periods between updates +/// - Ordered batch updates +/// - Emergency circuit breaker /// @custom:authors [Oddaf] /// @custom:reviewers [] /// @custom:auditors [] /// @custom:bounties [] contract DSPC { // --- Structs --- + /// @notice Configuration for a rate parameter's constraints + /// @dev All values are in basis points (1 bp = 0.01%) struct Cfg { - uint16 min; // Minimum rate in basis points - uint16 max; // Maximum rate in basis points - uint16 step; // Maximum rate change in basis points + uint16 min; // Minimum allowed rate + uint16 max; // Maximum allowed rate + uint16 step; // Maximum allowed rate change per update } + /// @notice A rate parameter update request + /// @dev Used in batch updates to modify multiple rates atomically struct ParamChange { - bytes32 id; // Identifier (ilk | "DSR" | "SSR") - uint256 bps; // New rate in basis points + bytes32 id; // Rate identifier (ilk, "DSR", or "SSR") + uint256 bps; // New rate value in bps } // --- Immutables --- @@ -111,16 +119,16 @@ contract DSPC { */ event File(bytes32 indexed what, uint256 data); /** - * @notice A Ilk/DSR/SSR parameter was updated. - * @param id The Ilk/DSR/SSR identifier. + * @notice A parameter was updated for an ilk, DSR, SSR. + * @param id The identifier (ilk, DSR, or SSR). * @param what The changed parameter name. * @param data The new value of the parameter. */ event File(bytes32 indexed id, bytes32 indexed what, uint256 data); /** * @notice Rate change was executed. - * @param id The Ilk/DSR/SSR identifier. - * @param bps The new value of the rate in basis points. + * @param id The identifier (ilk, DSR, or SSR). + * @param bps The new rate in basis points. */ event Set(bytes32 indexed id, uint256 bps); @@ -140,11 +148,11 @@ contract DSPC { _; } - /// @notice Constructor sets the core contracts - /// @param _jug The Jug contract for managing stability fees - /// @param _pot The Pot contract for managing DSR - /// @param _susds The SUSDS contract for managing SSR - /// @param _conv The conversion utility contract for rate calculations + /// @notice Initialize the DSPC module with core system contracts + /// @param _jug Jug contract for stability fee management + /// @param _pot Pot contract for Dai Savings Rate (DSR) + /// @param _susds SUSDS contract for Sky Savings Rate (SSR) + /// @param _conv Utility contract for rate conversions between basis points and ray constructor(address _jug, address _pot, address _susds, address _conv) { jug = JugLike(_jug); pot = PotLike(_pot); @@ -188,10 +196,13 @@ contract DSPC { emit Diss(usr); } - /// @notice Configure module parameters - /// @param what The parameter to configure ("bad" or "tau") - /// @param data The value to set - /// @dev Emits File event after successful configuration + /// @notice Configure global module parameters + /// @param what Parameter name ("bad": circuit breaker, "tau": cooldown period, "toc": last update timestamp) + /// @param data New parameter value + /// @dev Configures critical module parameters: + /// - bad: Emergency circuit breaker (0: normal, 1: halted) + /// - tau: Minimum time between rate updates in seconds + /// - toc: Last update timestamp (set automatically) function file(bytes32 what, uint256 data) external auth { if (what == "bad") { require(data == 0 || data == 1, "DSPC/invalid-bad-value"); @@ -209,12 +220,17 @@ contract DSPC { emit File(what, data); } - /// @notice Configure constraints for a rate - /// @param id The rate identifier (ilk name, "DSR", or "SSR") - /// @param what The parameter to configure ("min", "max" or "step") - /// @param data The value to set - /// @dev Emits File event after successful configuration - /// @dev Note that ordering may be relevant if setting min and max in the same transaction, as the transaction may revert if the new max is lower than the old min (or vice versa). + /// @notice Configure constraints for a specific rate parameter + /// @param id Rate identifier (ilk for collateral types, "DSR" for Dai Savings Rate, "SSR" for Sky Savings Rate) + /// @param what Parameter to configure: + /// - "min": Minimum allowed rate in basis points + /// - "max": Maximum allowed rate in basis points + /// - "step": Maximum allowed rate change in basis points + /// @param data New parameter value in basis points + /// @dev Important considerations: + /// - For ilks, verifies the collateral type is initialized in the system + /// - All values must be <= uint16 max (65535 basis points) + /// - When setting both min and max, set min first to avoid invalid state function file(bytes32 id, bytes32 what, uint256 data) external auth { if (id != "DSR" && id != "SSR") { (uint256 duty,) = jug.ilks(id); @@ -236,19 +252,24 @@ contract DSPC { emit File(id, what, data); } - /// @notice Apply rate updates - /// @param updates Array of rate updates to apply (strictly ordered by id) - /// @dev Each update is validated against configured constraints before being applied - /// @dev Emits Set event for each update. + /// @notice Execute a batch of rate updates + /// @param updates Array of rate changes to apply, must be ordered by id (DSR < ilks < SSR) + /// @dev Executes multiple rate updates in a single transaction with safety checks: + /// 1. Verifies cooldown period has elapsed + /// 2. Checks each rate is configured and within bounds + /// 3. Validates rate changes don't exceed max step size + /// 4. Ensures updates are properly ordered to prevent duplicates + /// 5. Calls drip() before each update to accrue fees /// @dev Reverts if: - /// - Empty updates array - /// - Cooldown not expired - /// - Ilks out of order - /// - Rate (ilk) not configured - /// - Rate below configured minimum - /// - Rate above configured maximum - /// - Current system rate out of bounds (not between configured minimum and maximum) - /// - Rate change above configured step + /// - Empty updates array (DSPC/empty-batch) + /// - Cooldown period not elapsed (DSPC/too-early) + /// - Rate not configured, step = 0 (DSPC/rate-not-configured) + /// - New rate < min (DSPC/below-min) + /// - New rate > max (DSPC/above-max) + /// - Rate change > step (DSPC/delta-above-step) + /// - Updates not ordered by id (DSPC/updates-out-of-order) + /// - Current rate outside bounds (DSPC/rate-out-of-bounds) + /// - Module halted, bad = 1 (DSPC/module-halted) function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); require(block.timestamp >= tau + toc, "DSPC/too-early"); diff --git a/src/DSPCMom.sol b/src/DSPCMom.sol index 32cc4da..09e940f 100644 --- a/src/DSPCMom.sol +++ b/src/DSPCMom.sol @@ -24,20 +24,28 @@ interface DSPCLike { function file(bytes32 what, uint256 data) external; } -/// @title DSPC Mom - Emergency shutdown for DSPC -/// @notice A contract that can halt the DSPC module in case of emergency +/// @title DSPC Mom - Shutdown DSPC bypassing GSM delay. +/// @notice Governance contract for halting DSPC module operations +/// @dev Provides: +/// - Owner/authority-based access control +/// - Emergency halt without delay /// @custom:authors [Oddaf] /// @custom:reviewers [] /// @custom:auditors [] /// @custom:bounties [] contract DSPCMom { // --- Auth --- - address public owner; // Owner address - address public authority; // Authorization contract + /// @notice Owner with full admin rights + address public owner; + /// @notice Optional authority contract for additional access control + address public authority; // --- Events --- + /// @notice Owner address changed event SetOwner(address indexed owner); + /// @notice Authority contract changed event SetAuthority(address indexed authority); + /// @notice DSPC module halted event Halt(address indexed dspc); // --- Modifiers --- @@ -51,32 +59,32 @@ contract DSPCMom { _; } - /// @notice Constructor sets initial owner + /// @notice Initialize contract with msg.sender as owner constructor() { owner = msg.sender; emit SetOwner(msg.sender); } // --- Administration --- - /// @notice Set a new owner - /// @param owner_ The new owner address + /// @notice Transfer ownership to a new address + /// @param owner_ New owner address with full admin rights function setOwner(address owner_) external onlyOwner { owner = owner_; emit SetOwner(owner_); } - /// @notice Set the authority contract - /// @param authority_ The new authority contract + /// @notice Set authority contract for additional access control + /// @param authority_ New authority contract address (0x0 to disable) function setAuthority(address authority_) external onlyOwner { authority = authority_; emit SetAuthority(authority_); } // --- Internal Functions --- - /// @notice Check if an address is authorized to call a function - /// @param src The source address making the call - /// @param sig The function signature being called - /// @return Whether the address is authorized + /// @notice Check caller authorization + /// @param src Caller address + /// @param sig Function signature + /// @return True if authorized (owner, self, or approved by authority) function isAuthorized(address src, bytes4 sig) internal view returns (bool) { if (src == owner || src == address(this)) { return true; @@ -88,8 +96,9 @@ contract DSPCMom { } // --- Emergency Actions --- - /// @notice Halt the DSPC module without enforcing the GSM delay - /// @param dspc The DSPC contract to halt + /// @notice Emergency halt of DSPC module + /// @param dspc Target DSPC contract + /// @dev Sets bad=1 to immediately halt operations function halt(address dspc) external auth { DSPCLike(dspc).file("bad", 1); emit Halt(dspc); From 31512e2b6dbb86105bdce7fdc84ca6c3d82b9233 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 23:26:01 -0300 Subject: [PATCH 61/96] chore: add step to readme.md instructions --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 8f0edc3..b09036b 100644 --- a/README.md +++ b/README.md @@ -53,10 +53,12 @@ dspc.file("tau", 1 days); // Configure constraints for a collateral type dspc.file("ETH-A", "min", 1); // Min rate: 0.01% dspc.file("ETH-A", "max", 1000); // Max rate: 10% +dspc.file("ETH-A", "step", 100); // Max change: 1% // Configure constraints for DSR dspc.file("DSR", "min", 1); // Min rate: 0.01% dspc.file("DSR", "max", 800); // Max rate: 8% +dspc.file("DSR", "step", 100); // Max change: 1% ``` 3. Add facilitators who can propose and execute rate changes: From 2af4fe2f4623541617db8391a61e1c340772644c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 23:27:13 -0300 Subject: [PATCH 62/96] Update README.md Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b09036b..b4fac6f 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Direct Stability Parameters Change Module (DSPC) -A module for MakerDAO that enables direct changes to stability parameters (duty, dsr, ssr) through a simple, secure interface with proper constraints and timelocks. +A module for the Sky Protocol that enables direct changes to stability parameters (duty, dsr, ssr) through a simple, secure interface with proper constraints and timelocks. ## Overview From afc6f5590111731c310191c006f7ea1058d20858 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 23:28:32 -0300 Subject: [PATCH 63/96] Apply suggestions from code review Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 6f42298..00368ac 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -253,7 +253,7 @@ contract DSPC { } /// @notice Execute a batch of rate updates - /// @param updates Array of rate changes to apply, must be ordered by id (DSR < ilks < SSR) + /// @param updates Array of rate changes to apply, must be ordered alphabetically by id /// @dev Executes multiple rate updates in a single transaction with safety checks: /// 1. Verifies cooldown period has elapsed /// 2. Checks each rate is configured and within bounds From 8c0131b5d631ded56f34ff62cc7566b103c98091 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 23:37:54 -0300 Subject: [PATCH 64/96] Update README.md Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b4fac6f..8c65ffd 100644 --- a/README.md +++ b/README.md @@ -69,8 +69,8 @@ dspc.kiss(facilitatorAddress); 4. Execute a batch of rate changes: ```solidity DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); -updates[0] = DSPC.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% -updates[1] = DSPC.ParamChange("DSR", 75); // Set DSR to 0.75% +updates[0] = DSPC.ParamChange("DSR", 75); // Set DSR to 0.75% +updates[1] = DSPC.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% dspc.set(updates); ``` From 50fd0d4af80a3d00f262fa0c1e7f465c91ae241e Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Thu, 13 Mar 2025 23:43:50 -0300 Subject: [PATCH 65/96] chore: order of operations in readme instructions --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b09036b..8f6427e 100644 --- a/README.md +++ b/README.md @@ -51,14 +51,14 @@ DSPC dspc = new DSPC( dspc.file("tau", 1 days); // Configure constraints for a collateral type -dspc.file("ETH-A", "min", 1); // Min rate: 0.01% dspc.file("ETH-A", "max", 1000); // Max rate: 10% +dspc.file("ETH-A", "min", 1); // Min rate: 0.01% dspc.file("ETH-A", "step", 100); // Max change: 1% // Configure constraints for DSR -dspc.file("DSR", "min", 1); // Min rate: 0.01% dspc.file("DSR", "max", 800); // Max rate: 8% -dspc.file("DSR", "step", 100); // Max change: 1% +dspc.file("DSR", "min", 1); // Min rate: 0.01% +dspc.file("DSR", "step", 100); // Max change: 1% ``` 3. Add facilitators who can propose and execute rate changes: From 13bc3b4b7c5dad4e80fa12e112f82b0ad16fdb10 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 14 Mar 2025 10:44:37 -0300 Subject: [PATCH 66/96] chore: order natspec revert reasons --- src/DSPC.sol | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 00368ac..5792ee5 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -261,15 +261,16 @@ contract DSPC { /// 4. Ensures updates are properly ordered to prevent duplicates /// 5. Calls drip() before each update to accrue fees /// @dev Reverts if: + /// - Caller not authorized (DSPC/not-facilitator) + /// - Module halted, bad = 1 (DSPC/module-halted) /// - Empty updates array (DSPC/empty-batch) /// - Cooldown period not elapsed (DSPC/too-early) + /// - Updates not ordered alphabetically by id (DSPC/updates-out-of-order) /// - Rate not configured, step = 0 (DSPC/rate-not-configured) /// - New rate < min (DSPC/below-min) /// - New rate > max (DSPC/above-max) - /// - Rate change > step (DSPC/delta-above-step) - /// - Updates not ordered by id (DSPC/updates-out-of-order) /// - Current rate outside bounds (DSPC/rate-out-of-bounds) - /// - Module halted, bad = 1 (DSPC/module-halted) + /// - Rate change > step (DSPC/delta-above-step) function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); require(block.timestamp >= tau + toc, "DSPC/too-early"); From 473fffb0cd833988d7433856cfdb77d9a0d95113 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 14 Mar 2025 10:46:03 -0300 Subject: [PATCH 67/96] chore: update foundry.toml --- foundry.toml | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/foundry.toml b/foundry.toml index 11cc98e..096611e 100644 --- a/foundry.toml +++ b/foundry.toml @@ -5,13 +5,7 @@ libs = ["lib"] solc = "0.8.24" optimizer = true optimizer_runs = 200 -verbosity = 3 - -# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options - -[profile.test] -verbosity = 3 - +no_match_coverage = "(script|test|mocks)" fs_permissions = [ { access = "read", path = "./out/" }, { access = "read", path = "./script/input/" }, @@ -19,6 +13,4 @@ fs_permissions = [ ] [rpc_endpoints] -mainnet = "${ETH_RPC_URL}" - -no_match_coverage = "test" +mainnet = "${ETH_RPC_URL}" \ No newline at end of file From 45873233c8a656e9c53250e22269e400e3027dc4 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 14 Mar 2025 10:51:02 -0300 Subject: [PATCH 68/96] chore: formatting --- src/DSPC.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 5792ee5..1c36646 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -262,10 +262,10 @@ contract DSPC { /// 5. Calls drip() before each update to accrue fees /// @dev Reverts if: /// - Caller not authorized (DSPC/not-facilitator) - /// - Module halted, bad = 1 (DSPC/module-halted) + /// - Module halted, bad = 1 (DSPC/module-halted) /// - Empty updates array (DSPC/empty-batch) /// - Cooldown period not elapsed (DSPC/too-early) - /// - Updates not ordered alphabetically by id (DSPC/updates-out-of-order) + /// - Updates not ordered alphabetically by id (DSPC/updates-out-of-order) /// - Rate not configured, step = 0 (DSPC/rate-not-configured) /// - New rate < min (DSPC/below-min) /// - New rate > max (DSPC/above-max) From b7d6a98f3733d89c1abb7f10e7b0255c7d19b41e Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 14 Mar 2025 10:54:25 -0300 Subject: [PATCH 69/96] chore: remove redundant selectors from test_auth_methods --- src/DSPC.t.sol | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 6b952a2..c944163 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -147,11 +147,7 @@ contract DSPCTest is DssTest { } function test_auth_methods() public { - checkModifier( - address(dspc), - "DSPC/not-authorized", - [DSPC.kiss.selector, DSPC.diss.selector, DSPC.rely.selector, DSPC.deny.selector] - ); + checkModifier(address(dspc), "DSPC/not-authorized", [DSPC.kiss.selector, DSPC.diss.selector]); } function test_toll_methods() public { From aae64b8137ec062afab3fc52df36ced2f9c52e8c Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Mar 2025 17:52:53 -0300 Subject: [PATCH 70/96] chore: add .editorconfig --- .editorconfig | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 .editorconfig diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..577b42a --- /dev/null +++ b/.editorconfig @@ -0,0 +1,27 @@ +# EditorConfig for Sky Protocol Projects + +# EditorConfig is awesome: https://EditorConfig.org + +# top-most EditorConfig file +root = true + +[*] +charset = utf-8 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true + +[*.{sol,sh,js,py}] +indent_style = space +indent_size = 4 + +[*.{diff,md}] +trim_trailing_whitespace = false + +[{package.json,.travis.yml}] +indent_style = space +indent_size = 2 + +[foundry.toml] +indent_style = space +indent_size = 4 From 1f8b03c72a1ed99ec9557412b4dbfc9ce70f54ad Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Mar 2025 17:54:28 -0300 Subject: [PATCH 71/96] Apply suggestions from code review Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- foundry.toml | 2 +- src/DSPC.sol | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/foundry.toml b/foundry.toml index 096611e..e901538 100644 --- a/foundry.toml +++ b/foundry.toml @@ -13,4 +13,4 @@ fs_permissions = [ ] [rpc_endpoints] -mainnet = "${ETH_RPC_URL}" \ No newline at end of file +mainnet = "${ETH_RPC_URL}" diff --git a/src/DSPC.sol b/src/DSPC.sol index 1c36646..1a937da 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -309,6 +309,7 @@ contract DSPC { // Execute the update uint256 ray = conv.btor(bps); + require(ray >= RAY, "DSPC/invalid-rate-conv"); if (id == "DSR") { pot.drip(); pot.file("dsr", ray); From 5650c3f9224f099afeab26b526fa5c40b3667c11 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Mar 2025 18:20:24 -0300 Subject: [PATCH 72/96] feat: rate covnersion check --- src/DSPC.sol | 4 ++++ src/DSPC.t.sol | 21 +++++++++++++++++++++ src/mocks/ConvMock.sol | 2 +- 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 1a937da..41c928c 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -67,6 +67,9 @@ contract DSPC { uint256 bps; // New rate value in bps } + // --- Constants --- + uint256 public constant RAY = 10**27; + // --- Immutables --- /// @notice Stability fee rates JugLike public immutable jug; @@ -271,6 +274,7 @@ contract DSPC { /// - New rate > max (DSPC/above-max) /// - Current rate outside bounds (DSPC/rate-out-of-bounds) /// - Rate change > step (DSPC/delta-above-step) + /// - Rate conversion failed (DSPC/invalid-rate-conv) function set(ParamChange[] calldata updates) external toll good { require(updates.length > 0, "DSPC/empty-batch"); require(block.timestamp >= tau + toc, "DSPC/too-early"); diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index c944163..a226ba1 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -43,6 +43,12 @@ contract InitCaller { } } +contract MockBrokenConv is ConvMock { + function btor(uint256 /* bps */) public view override returns (uint256) { + return 0; + } +} + contract DSPCTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; @@ -420,4 +426,19 @@ contract DSPCTest is DssTest { vm.prank(bud); dspc.set(updates); } + + function test_revert_set_malfunctioning_conv() public { + bytes memory code = address(new MockBrokenConv()).code; + vm.etch(address(conv), code); + + (uint256 duty,) = dss.jug.ilks(ILK); + uint256 target = conv.rtob(duty) + 50; + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, target); + + vm.expectRevert("DSPC/invalid-rate-conv"); + vm.prank(bud); + dspc.set(updates); + } } diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index 43d6566..1e594b1 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -37,7 +37,7 @@ contract ConvMock { /// @notice Fetches the rate for a given basis points value /// @param bps The basis points value to get the rate for /// @return ray The annual rate value - function btor(uint256 bps) public view returns (uint256 ray) { + function btor(uint256 bps) public virtual view returns (uint256 ray) { require(bps <= MAX); assembly { From 4da6795741a4b1a76ce44f750a31291cf45aca00 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Mon, 17 Mar 2025 18:21:46 -0300 Subject: [PATCH 73/96] chore: forge fmt --- src/DSPC.sol | 2 +- src/DSPC.t.sol | 4 ++-- src/mocks/ConvMock.sol | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 41c928c..5498aea 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -68,7 +68,7 @@ contract DSPC { } // --- Constants --- - uint256 public constant RAY = 10**27; + uint256 public constant RAY = 10 ** 27; // --- Immutables --- /// @notice Stability fee rates diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index a226ba1..119026c 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -44,7 +44,7 @@ contract InitCaller { } contract MockBrokenConv is ConvMock { - function btor(uint256 /* bps */) public view override returns (uint256) { + function btor(uint256 /* bps */ ) public view override returns (uint256) { return 0; } } @@ -440,5 +440,5 @@ contract DSPCTest is DssTest { vm.expectRevert("DSPC/invalid-rate-conv"); vm.prank(bud); dspc.set(updates); - } + } } diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index 1e594b1..b2ae523 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -37,7 +37,7 @@ contract ConvMock { /// @notice Fetches the rate for a given basis points value /// @param bps The basis points value to get the rate for /// @return ray The annual rate value - function btor(uint256 bps) public virtual view returns (uint256 ray) { + function btor(uint256 bps) public view virtual returns (uint256 ray) { require(bps <= MAX); assembly { From e8c317b18e36dbfa8a80fdd4dabc11604272f4ae Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Mar 2025 00:08:53 -0300 Subject: [PATCH 74/96] refactor: allow setting rates when current rate out of bounds --- src/DSPC.sol | 7 +++++-- src/DSPC.t.sol | 32 +++++++++++++++++--------------- 2 files changed, 22 insertions(+), 17 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index 5498aea..ce61d12 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -272,7 +272,6 @@ contract DSPC { /// - Rate not configured, step = 0 (DSPC/rate-not-configured) /// - New rate < min (DSPC/below-min) /// - New rate > max (DSPC/above-max) - /// - Current rate outside bounds (DSPC/rate-out-of-bounds) /// - Rate change > step (DSPC/delta-above-step) /// - Rate conversion failed (DSPC/invalid-rate-conv) function set(ParamChange[] calldata updates) external toll good { @@ -305,7 +304,11 @@ contract DSPC { oldBps = conv.rtob(duty); } - require(oldBps >= cfg.min && oldBps <= cfg.max, "DSPC/rate-out-of-bounds"); + if (oldBps < cfg.min) { + oldBps = cfg.min; + } else if (oldBps > cfg.max) { + oldBps = cfg.max; + } // Calculates absolute difference between the old and the new rate uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 119026c..db927de 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -44,7 +44,7 @@ contract InitCaller { } contract MockBrokenConv is ConvMock { - function btor(uint256 /* bps */ ) public view override returns (uint256) { + function btor(uint256 /* bps */ ) public pure override returns (uint256) { return 0; } } @@ -322,6 +322,22 @@ contract DSPCTest is DssTest { assertEq(susds.ssr(), conv.btor(ssrTarget)); } + function test_set_rate_outside_range() public { + dss.jug.drip(ILK); + uint256 rate = conv.btor(3050); + vm.prank(address(pauseProxy)); + dss.jug.file(ILK, "duty", rate); // outside range + + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0] = DSPC.ParamChange(ILK, 2999); + + vm.prank(bud); + dspc.set(updates); + + (uint256 duty,) = dss.jug.ilks(ILK); + assertEq(duty, conv.btor(2999)); + } + function test_revert_set_duplicate() public { (uint256 duty,) = dss.jug.ilks(ILK); @@ -413,20 +429,6 @@ contract DSPCTest is DssTest { dspc.set(updates); } - function test_revert_set_rate_outside_range() public { - dss.jug.drip(ILK); - uint256 rate = conv.btor(3050); - vm.prank(address(pauseProxy)); - dss.jug.file(ILK, "duty", rate); // outside range but within step - - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 2999); - - vm.expectRevert("DSPC/rate-out-of-bounds"); - vm.prank(bud); - dspc.set(updates); - } - function test_revert_set_malfunctioning_conv() public { bytes memory code = address(new MockBrokenConv()).code; vm.etch(address(conv), code); From 84e5e3bf7ed4664a8899f6f9195233ebc96f4ee3 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Mar 2025 00:13:32 -0300 Subject: [PATCH 75/96] chore: test rates below min bound --- src/DSPC.t.sol | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index db927de..6752774 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -323,10 +323,10 @@ contract DSPCTest is DssTest { } function test_set_rate_outside_range() public { + // rate above max dss.jug.drip(ILK); - uint256 rate = conv.btor(3050); vm.prank(address(pauseProxy)); - dss.jug.file(ILK, "duty", rate); // outside range + dss.jug.file(ILK, "duty", conv.btor(3050)); // outside range DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); updates[0] = DSPC.ParamChange(ILK, 2999); @@ -336,6 +336,19 @@ contract DSPCTest is DssTest { (uint256 duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(2999)); + + // rate below min + dss.jug.drip(ILK); + vm.prank(address(pauseProxy)); + dss.jug.file(ILK, "duty", conv.btor(0)); // outside range + + updates[0] = DSPC.ParamChange(ILK, 50); + + vm.prank(bud); + dspc.set(updates); + + (duty,) = dss.jug.ilks(ILK); + assertEq(duty, conv.btor(50)); } function test_revert_set_duplicate() public { From 54dacb430df233558e01ad5a1e9cf74911e3fbef Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Tue, 18 Mar 2025 00:46:06 -0300 Subject: [PATCH 76/96] chore: formatting --- src/DSPC.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DSPC.t.sol b/src/DSPC.t.sol index 6752774..8933425 100644 --- a/src/DSPC.t.sol +++ b/src/DSPC.t.sol @@ -340,7 +340,7 @@ contract DSPCTest is DssTest { // rate below min dss.jug.drip(ILK); vm.prank(address(pauseProxy)); - dss.jug.file(ILK, "duty", conv.btor(0)); // outside range + dss.jug.file(ILK, "duty", conv.btor(0)); // outside range updates[0] = DSPC.ParamChange(ILK, 50); From c9dfdfb5c40f15885c425ab64188f3544412c1c8 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Wed, 19 Mar 2025 19:14:03 -0300 Subject: [PATCH 77/96] Apply suggestions from code review Co-authored-by: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Signed-off-by: oddaf <106770775+oddaf@users.noreply.github.com> --- src/DSPC.sol | 4 ---- src/DSPCMom.sol | 4 ---- 2 files changed, 8 deletions(-) diff --git a/src/DSPC.sol b/src/DSPC.sol index ce61d12..29d59b3 100644 --- a/src/DSPC.sol +++ b/src/DSPC.sol @@ -46,10 +46,6 @@ interface ConvLike { /// - Cooldown periods between updates /// - Ordered batch updates /// - Emergency circuit breaker -/// @custom:authors [Oddaf] -/// @custom:reviewers [] -/// @custom:auditors [] -/// @custom:bounties [] contract DSPC { // --- Structs --- /// @notice Configuration for a rate parameter's constraints diff --git a/src/DSPCMom.sol b/src/DSPCMom.sol index 09e940f..14f284c 100644 --- a/src/DSPCMom.sol +++ b/src/DSPCMom.sol @@ -29,10 +29,6 @@ interface DSPCLike { /// @dev Provides: /// - Owner/authority-based access control /// - Emergency halt without delay -/// @custom:authors [Oddaf] -/// @custom:reviewers [] -/// @custom:auditors [] -/// @custom:bounties [] contract DSPCMom { // --- Auth --- /// @notice Owner with full admin rights From 6f00f00c6ffd85d7b5b509735c786f757d56aa88 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Wed, 19 Mar 2025 21:10:48 -0300 Subject: [PATCH 78/96] feat: add initial spec [WIP] --- .gitignore | 5 +- Makefile | 3 + certora/DSPC.conf | 46 ++ certora/DSPC.spec | 294 +++++++ certora/mocks/Conv.sol | 66 ++ certora/mocks/ERC1967Proxy.sol | 608 ++++++++++++++ certora/mocks/Jug.sol | 161 ++++ certora/mocks/Pot.sol | 215 +++++ certora/mocks/SUsds.sol | 1379 ++++++++++++++++++++++++++++++++ certora/mocks/Vat.sol | 271 +++++++ 10 files changed, 3047 insertions(+), 1 deletion(-) create mode 100644 Makefile create mode 100644 certora/DSPC.conf create mode 100644 certora/DSPC.spec create mode 100644 certora/mocks/Conv.sol create mode 100644 certora/mocks/ERC1967Proxy.sol create mode 100644 certora/mocks/Jug.sol create mode 100644 certora/mocks/Pot.sol create mode 100644 certora/mocks/SUsds.sol create mode 100644 certora/mocks/Vat.sol diff --git a/.gitignore b/.gitignore index 05db85e..65d4abc 100644 --- a/.gitignore +++ b/.gitignore @@ -16,4 +16,7 @@ docs/ # Ignores script config /script/input/**/*.json !/script/input/**/template-*.json -/script/output/**/*.json \ No newline at end of file +/script/output/**/*.json + +# Certora +.certora_internal/ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..6a44cd8 --- /dev/null +++ b/Makefile @@ -0,0 +1,3 @@ +PATH := ~/.solc-select/artifacts/solc-0.8.24:~/.solc-select/artifacts/solc-0.8.21:~/.solc-select/artifacts/solc-0.5.12:~/.solc-select/artifacts:$(PATH) +certora-dspc:; PATH=${PATH} certoraRun certora/DSPC.conf$(if $(rule), --rule $(rule),) + diff --git a/certora/DSPC.conf b/certora/DSPC.conf new file mode 100644 index 0000000..38038db --- /dev/null +++ b/certora/DSPC.conf @@ -0,0 +1,46 @@ +{ + "files": [ + "src/DSPC.sol", + "certora/mocks/Conv.sol", + "certora/mocks/ERC1967Proxy.sol", + "certora/mocks/Jug.sol", + "certora/mocks/Pot.sol", + "certora/mocks/SUsds.sol", + "certora/mocks/Vat.sol" + ], + "link": [ + "DSPC:jug=Jug", + "DSPC:pot=Pot", + "DSPC:susds=ERC1967Proxy", + "DSPC:conv=Conv", + "ERC1967Proxy:0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc=SUsds", + "Jug:vat=Vat", + "Pot:vat=Vat" + ], + "rule_sanity": "basic", + "solc_map": { + "Conv": "solc-0.8.24", + "DSPC": "solc-0.8.24", + "ERC1967Proxy": "solc-0.8.21", + "Jug": "solc-0.5.12", + "Pot": "solc-0.5.12", + "SUsds": "solc-0.8.21", + "Vat": "solc-0.5.12" + }, + "solc_optimize_map": { + "Conv": "200", + "DSPC": "200", + "ERC1967Proxy": "200", + "Jug": "0", + "Pot": "0", + "SUsds": "200", + "Vat": "0" + }, + "verify": "DSPC:certora/DSPC.spec", + "parametric_contracts": [ + "DSPC" + ], + "loop_iter": 20, + "multi_assert_check": true, + "wait_for_results": "all" +} diff --git a/certora/DSPC.spec b/certora/DSPC.spec new file mode 100644 index 0000000..e5f5f81 --- /dev/null +++ b/certora/DSPC.spec @@ -0,0 +1,294 @@ +// DSPC.spec + +using Conv as conv; +using Jug as jug; +using Pot as pot; +using ERC1967Proxy as susds; +using SUsds as susdsImp; +using Vat as vat; + +methods { + function wards(address) external returns (uint256) envfree; + function buds(address) external returns (uint256) envfree; + function cfgs(bytes32) external returns (uint16, uint16, uint16) envfree; + function bad() external returns (uint8) envfree; + function tau() external returns (uint64) envfree; + function toc() external returns (uint128) envfree; + + function conv.rtob(uint256) external returns (uint256) envfree; + function conv.btor(uint256) external returns (uint256) envfree; + + function jug.ilks(bytes32) external returns (uint256, uint256) envfree; + + function pot.dsr() external returns (uint256) envfree; + + function susdsImp.ssr() external returns (uint256) envfree; + + function vat.live() external returns (uint256) envfree; + function vat.can(address, address) external returns (uint256) envfree; + function vat.dai(address) external returns (uint256) envfree; + function vat.debt() external returns (uint256) envfree; + function vat.Line() external returns (uint256) envfree; + function vat.ilks(bytes32) external returns (uint256, uint256, uint256, uint256, uint256) envfree; + function vat.urns(bytes32, address) external returns (uint256, uint256) envfree; +} + +definition TAU() returns bytes32 = to_bytes32(0x7461750000000000000000000000000000000000000000000000000000000000); +definition TOC() returns bytes32 = to_bytes32(0x746f630000000000000000000000000000000000000000000000000000000000); +definition BAD() returns bytes32 = to_bytes32(0x6261640000000000000000000000000000000000000000000000000000000000); +definition MIN() returns bytes32 = to_bytes32(0x6d696e0000000000000000000000000000000000000000000000000000000000); +definition MAX() returns bytes32 = to_bytes32(0x6d61780000000000000000000000000000000000000000000000000000000000); +definition STEP() returns bytes32 = to_bytes32(0x7374657000000000000000000000000000000000000000000000000000000000); +definition SSR() returns bytes32 = to_bytes32(0x5353520000000000000000000000000000000000000000000000000000000000); +definition DSR() returns bytes32 = to_bytes32(0x4453520000000000000000000000000000000000000000000000000000000000); + +// Verify that each storage variable is only modified in the expected functions +rule storageAffected(method f) { + env e; + address anyAddr; + bytes32 anyId; + + mathint wardsBefore = wards(anyAddr); + mathint budsBefore = buds(anyAddr); + mathint minBefore; mathint maxBefore; mathint stepBefore; + minBefore, maxBefore, stepBefore = cfgs(anyId); + mathint badBefore = bad(); + mathint tauBefore = tau(); + mathint tocBefore = toc(); + + calldataarg args; + f(e, args); + + mathint wardsAfter = wards(anyAddr); + mathint budsAfter = buds(anyAddr); + mathint minAfter; mathint maxAfter; mathint stepAfter; + minAfter, maxAfter, stepAfter = cfgs(anyId); + mathint badAfter = bad(); + mathint tauAfter = tau(); + mathint tocAfter = toc(); + + assert wardsAfter != wardsBefore => f.selector == sig:rely(address).selector || f.selector == sig:deny(address).selector, "wards[x] changed in an unexpected function"; + assert budsAfter != budsBefore => f.selector == sig:kiss(address).selector || f.selector == sig:diss(address).selector, "buds[x] changed in an unexpected function"; + assert minAfter != minBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "min[x] changed in an unexpected function"; + assert maxAfter != maxBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "max[x] changed in an unexpected function"; + assert stepAfter != stepBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "step[x] changed in an unexpected function"; + assert badAfter != badBefore => f.selector == sig:file(bytes32, uint256).selector, "bad[x] changed in an unexpected function"; + assert tauAfter != tauBefore => f.selector == sig:file(bytes32, uint256).selector, "tau[x] changed in an unexpected function"; + assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(DSPC.ParamChange[] calldata).selector, "toc[x] changed in an unexpected function"; +} + +// Verify that the correct storage changes for non-reverting rely +rule rely(address usr) { + env e; + + address other; + require other != usr; + + mathint wardsOtherBefore = wards(other); + + rely(e, usr); + + mathint wardsOtherAfter = wards(other); + mathint wardsUsrAfter = wards(usr); + + assert wardsUsrAfter == 1, "rely did not set wards[usr]"; + assert wardsOtherAfter == wardsOtherBefore, "rely unexpectedly changed other wards[x]"; +} + +// Verify revert rules on rely +rule rely_revert(address usr) { + env e; + + mathint wardsSender = wards(e.msg.sender); + + rely@withrevert(e, usr); + + bool revert1 = e.msg.value > 0; + bool revert2 = wardsSender != 1; + assert lastReverted <=> revert1 || revert2, "rely revert rules failed"; +} + +// Verify that the correct storage changes for non-reverting deny +rule deny(address usr) { + env e; + + address other; + require other != usr; + + mathint wardsOtherBefore = wards(other); + + deny(e, usr); + + mathint wardsOtherAfter = wards(other); + mathint wardsUsrAfter = wards(usr); + + assert wardsUsrAfter == 0, "deny did not set wards[usr]"; + assert wardsOtherAfter == wardsOtherBefore, "deny unexpectedly changed other wards[x]"; +} + +// Verify revert rules on deny +rule deny_revert(address usr) { + env e; + + mathint wardsSender = wards(e.msg.sender); + + deny@withrevert(e, usr); + + bool revert1 = e.msg.value > 0; + bool revert2 = wardsSender != 1; + assert lastReverted <=> revert1 || revert2, "deny revert rules failed"; +} + +// Verify that the correct storage changes for non-reverting kiss +rule kiss(address usr) { + env e; + + address other; + require other != usr; + + mathint budsOtherBefore = buds(other); + + kiss(e, usr); + + mathint budsOtherAfter = buds(other); + mathint budsUsrAfter = buds(usr); + + assert budsUsrAfter == 1, "kiss did not set buds[usr]"; + assert budsOtherAfter == budsOtherBefore, "kiss unexpectedly changed other buds[x]"; +} + +// Verify revert rules on kiss +rule kiss_revert(address usr) { + env e; + + mathint wardsSender = wards(e.msg.sender); + + kiss@withrevert(e, usr); + + bool revert1 = e.msg.value > 0; + bool revert2 = wardsSender != 1; + + assert lastReverted <=> revert1 || revert2, "kiss revert rules failed"; +} + +// Verify that the correct storage changes for non-reverting diss +rule diss(address usr) { + env e; + + address other; + require other != usr; + + mathint budsOtherBefore = buds(other); + + diss(e, usr); + + mathint budsOtherAfter = buds(other); + mathint budsUsrAfter = buds(usr); + + assert budsUsrAfter == 0, "diss did not set buds[usr]"; + assert budsOtherAfter == budsOtherBefore, "diss unexpectedly changed other buds[x]"; +} + +// Verify revert rules on diss +rule diss_revert(address usr) { + env e; + + mathint wardsSender = wards(e.msg.sender); + + diss@withrevert(e, usr); + + bool revert1 = e.msg.value > 0; + bool revert2 = wardsSender != 1; + + assert lastReverted <=> revert1 || revert2, "diss revert rules failed"; +} + +// Verify correct storage changes for non-reverting file for global parameters +rule file_global(bytes32 what, uint256 data) { + env e; + + mathint badBefore = bad(); + mathint tauBefore = tau(); + mathint tocBefore = toc(); + + file(e, what, data); + + mathint badAfter = bad(); + mathint tauAfter = tau(); + mathint tocAfter = toc(); + + assert what == BAD() => badAfter == to_mathint(data), "file did not set bad"; + assert what != BAD() => badAfter == badBefore, "file did keep unchanged bad"; + assert what == TAU() => tauAfter == to_mathint(data), "file did not set tau"; + assert what != TAU() => tauAfter == tauBefore, "file did keep unchanged tau"; + assert what == TOC() => tocAfter == to_mathint(data), "file did not set toc"; + assert what != TOC() => tocAfter == tocBefore, "file did keep unchanged toc"; +} + +// Verify revert rules on file for global parameters +rule file_global_revert(bytes32 what, uint256 data) { + env e; + + mathint wardsSender = wards(e.msg.sender); + + file@withrevert(e, what, data); + + bool revert1 = e.msg.value > 0; + bool revert2 = wardsSender != 1; + bool revert3 = what != BAD() && what != TAU() && what != TOC(); + bool revert4 = what == BAD() && to_mathint(data) != 0 && to_mathint(data) != 1; + bool revert5 = what == TAU() && to_mathint(data) > max_uint64; + bool revert6 = what == TOC() && to_mathint(data) > max_uint128; + + assert lastReverted <=> revert1 || revert2 || revert3 || + revert4 || revert5 || revert6, + "file revert rules failed"; +} + +// Verify correct storage changes for non-reverting file for individual rate parameters +rule file_per_id(bytes32 id, bytes32 what, uint256 data) { + env e; + + mathint minBefore; mathint maxBefore; mathint stepBefore; + minBefore, maxBefore, stepBefore = cfgs(id); + + file(e, id, what, data); + + mathint minAfter; mathint maxAfter; mathint stepAfter; + minAfter, maxAfter, stepAfter = cfgs(id); + + assert what == MIN() => minAfter == to_mathint(data), "file did not set min"; + assert what != MIN() => minAfter == minBefore, "file did keep unchanged min"; + assert what == MAX() => maxAfter == to_mathint(data), "file did not set max"; + assert what != MAX() => maxAfter == maxBefore, "file did keep unchanged max"; + assert what == STEP() => stepAfter == to_mathint(data), "file did not set step"; + assert what != STEP() => stepAfter == stepBefore, "file did keep unchanged step"; +} + +// Verify revert rules on file for individual rate parameters +rule file_per_id_revert(bytes32 id, bytes32 what, uint256 data) { + env e; + + mathint wardsSender = wards(e.msg.sender); + mathint minBefore; mathint maxBefore; mathint stepBefore; + minBefore, maxBefore, stepBefore = cfgs(id); + mathint duty; mathint _rate; + duty, _rate = jug.ilks(id); + + file@withrevert(e, id, what, data); + + bool revert1 = e.msg.value > 0; + bool revert2 = wardsSender != 1; + bool revert3 = id != DSR() && id != SSR() && duty == 0; + bool revert4 = what != MIN() && what != MAX() && what != STEP(); + bool revert5 = what == MIN() && to_mathint(data) > max_uint16; + bool revert6 = what == MAX() && to_mathint(data) > max_uint16; + bool revert7 = what == STEP() && to_mathint(data) > max_uint16; + bool revert8 = what == MIN() && to_mathint(data) > maxBefore; + bool revert9 = what == MAX() && to_mathint(data) < minBefore; + + assert lastReverted <=> revert1 || revert2 || revert3 || + revert4 || revert5 || revert6 || + revert7 || revert8 || revert9, + "file revert rules failed"; +} diff --git a/certora/mocks/Conv.sol b/certora/mocks/Conv.sol new file mode 100644 index 0000000..c3645d6 --- /dev/null +++ b/certora/mocks/Conv.sol @@ -0,0 +1,66 @@ + +pragma solidity ^0.8.24; + +contract Conv { + uint256 public constant MAX_BPS_IN = 50_00; + uint256 internal constant RAY = 10 ** 27; + uint256 internal constant BPS = 100_00; + + bytes internal RATES = + hex"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"; + + function btor(uint256 bps) external view returns (uint256 ray) { + require(bps <= MAX_BPS_IN, "Conv/bps-too-high"); + + uint256 offset = bps * 8; // Each rate is 8 bytes + (uint256 wordPos, uint256 bytePos) = (offset / 32, offset % 32); + + bytes32 value; + assembly { + let dataSlot := keccak256(RATES.slot, 0x20) + value := sload(add(dataSlot, wordPos)) + } + + uint256 shifted = uint256(value) >> ((24 - bytePos) * 8); + ray = (shifted & 0xFFFFFFFFFFFFFFFF) + RAY; + } + + function rtob(uint256 ray) external pure returns (uint256 bps) { + require(ray >= RAY, "Conv/ray-too-low"); + + uint256 yearlyRate = _rpow(ray, 365 days); + return ((yearlyRate - RAY) * BPS + RAY / 2) / RAY; + } + + function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { + assembly { + switch x + case 0 { + switch n + case 0 { z := RAY } + default { z := 0 } + } + default { + switch mod(n, 2) + case 0 { z := RAY } + default { z := x } + let half := div(RAY, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n, 2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0, 0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0, 0) } + x := div(xxRound, RAY) + if mod(n, 2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0, 0) } + z := div(zxRound, RAY) + } + } + } + } + } +} + diff --git a/certora/mocks/ERC1967Proxy.sol b/certora/mocks/ERC1967Proxy.sol new file mode 100644 index 0000000..3d5c2c9 --- /dev/null +++ b/certora/mocks/ERC1967Proxy.sol @@ -0,0 +1,608 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Proxy.sol) + +/** + * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM + * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to + * be specified by overriding the virtual {_implementation} function. + * + * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a + * different contract through the {_delegate} function. + * + * The success and return data of the delegated call will be returned back to the caller of the proxy. + */ +abstract contract Proxy { + /** + * @dev Delegates the current call to `implementation`. + * + * This function does not return to its internal call site, it will return directly to the external caller. + */ + function _delegate(address implementation) internal virtual { + assembly { + // Copy msg.data. We take full control of memory in this inline assembly + // block because it will not return to Solidity code. We overwrite the + // Solidity scratch pad at memory position 0. + calldatacopy(0, 0, calldatasize()) + + // Call the implementation. + // out and outsize are 0 because we don't know the size yet. + let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) + + // Copy the returned data. + returndatacopy(0, 0, returndatasize()) + + switch result + // delegatecall returns 0 on error. + case 0 { + revert(0, returndatasize()) + } + default { + return(0, returndatasize()) + } + } + } + + /** + * @dev This is a virtual function that should be overridden so it returns the address to which the fallback + * function and {_fallback} should delegate. + */ + function _implementation() internal view virtual returns (address); + + /** + * @dev Delegates the current call to the address returned by `_implementation()`. + * + * This function does not return to its internal call site, it will return directly to the external caller. + */ + function _fallback() internal virtual { + _delegate(_implementation()); + } + + /** + * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other + * function in the contract matches the call data. + */ + fallback() external payable virtual { + _fallback(); + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol) + +/** + * @dev This is the interface that {BeaconProxy} expects of its beacon. + */ +interface IBeacon { + /** + * @dev Must return an address that can be used as a delegate call target. + * + * {UpgradeableBeacon} will check that this address is a contract. + */ + function implementation() external view returns (address); +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) + +/** + * @dev Collection of functions related to the address type + */ +library Address { + /** + * @dev The ETH balance of the account is not enough to perform the operation. + */ + error AddressInsufficientBalance(address account); + + /** + * @dev There's no code at `target` (it is not a contract). + */ + error AddressEmptyCode(address target); + + /** + * @dev A call to an address target failed. The target may have reverted. + */ + error FailedInnerCall(); + + /** + * @dev Replacement for Solidity's `transfer`: sends `amount` wei to + * `recipient`, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by `transfer`, making them unable to receive funds via + * `transfer`. {sendValue} removes this limitation. + * + * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to `recipient`, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. + */ + function sendValue(address payable recipient, uint256 amount) internal { + if (address(this).balance < amount) { + revert AddressInsufficientBalance(address(this)); + } + + (bool success, ) = recipient.call{value: amount}(""); + if (!success) { + revert FailedInnerCall(); + } + } + + /** + * @dev Performs a Solidity function call using a low level `call`. A + * plain `call` is an unsafe replacement for a function call: use this + * function instead. + * + * If `target` reverts with a revert reason or custom error, it is bubbled + * up by this function (like regular Solidity function calls). However, if + * the call reverted with no returned reason, this function reverts with a + * {FailedInnerCall} error. + * + * Returns the raw returned data. To convert to the expected return value, + * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. + * + * Requirements: + * + * - `target` must be a contract. + * - calling `target` with `data` must not revert. + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but also transferring `value` wei to `target`. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least `value`. + * - the called Solidity function must be `payable`. + */ + function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { + if (address(this).balance < value) { + revert AddressInsufficientBalance(address(this)); + } + (bool success, bytes memory returndata) = target.call{value: value}(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a static call. + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + (bool success, bytes memory returndata) = target.staticcall(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a delegate call. + */ + function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { + (bool success, bytes memory returndata) = target.delegatecall(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target + * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an + * unsuccessful call. + */ + function verifyCallResultFromTarget( + address target, + bool success, + bytes memory returndata + ) internal view returns (bytes memory) { + if (!success) { + _revert(returndata); + } else { + // only check if target is a contract if the call was successful and the return data is empty + // otherwise we already know that it was a contract + if (returndata.length == 0 && target.code.length == 0) { + revert AddressEmptyCode(target); + } + return returndata; + } + } + + /** + * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the + * revert reason or with a default {FailedInnerCall} error. + */ + function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { + if (!success) { + _revert(returndata); + } else { + return returndata; + } + } + + /** + * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. + */ + function _revert(bytes memory returndata) private pure { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + /// @solidity memory-safe-assembly + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert FailedInnerCall(); + } + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) +// This file was procedurally generated from scripts/generate/templates/StorageSlot.js. + +/** + * @dev Library for reading and writing primitive types to specific storage slots. + * + * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. + * This library helps with reading and writing to such slots without the need for inline assembly. + * + * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. + * + * Example usage to set ERC1967 implementation slot: + * ```solidity + * contract ERC1967 { + * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; + * + * function _getImplementation() internal view returns (address) { + * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; + * } + * + * function _setImplementation(address newImplementation) internal { + * require(newImplementation.code.length > 0); + * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; + * } + * } + * ``` + */ +library StorageSlot { + struct AddressSlot { + address value; + } + + struct BooleanSlot { + bool value; + } + + struct Bytes32Slot { + bytes32 value; + } + + struct Uint256Slot { + uint256 value; + } + + struct StringSlot { + string value; + } + + struct BytesSlot { + bytes value; + } + + /** + * @dev Returns an `AddressSlot` with member `value` located at `slot`. + */ + function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `BooleanSlot` with member `value` located at `slot`. + */ + function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. + */ + function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `Uint256Slot` with member `value` located at `slot`. + */ + function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `StringSlot` with member `value` located at `slot`. + */ + function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `StringSlot` representation of the string storage pointer `store`. + */ + function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := store.slot + } + } + + /** + * @dev Returns an `BytesSlot` with member `value` located at `slot`. + */ + function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. + */ + function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := store.slot + } + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol) + +/** + * @dev This abstract contract provides getters and event emitting update functions for + * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. + */ +library ERC1967Utils { + // We re-declare ERC-1967 events here because they can't be used directly from IERC1967. + // This will be fixed in Solidity 0.8.21. At that point we should remove these events. + /** + * @dev Emitted when the implementation is upgraded. + */ + event Upgraded(address indexed implementation); + + /** + * @dev Emitted when the admin account has changed. + */ + event AdminChanged(address previousAdmin, address newAdmin); + + /** + * @dev Emitted when the beacon is changed. + */ + event BeaconUpgraded(address indexed beacon); + + /** + * @dev Storage slot with the address of the current implementation. + * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1. + */ + // solhint-disable-next-line private-vars-leading-underscore + bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; + + /** + * @dev The `implementation` of the proxy is invalid. + */ + error ERC1967InvalidImplementation(address implementation); + + /** + * @dev The `admin` of the proxy is invalid. + */ + error ERC1967InvalidAdmin(address admin); + + /** + * @dev The `beacon` of the proxy is invalid. + */ + error ERC1967InvalidBeacon(address beacon); + + /** + * @dev An upgrade function sees `msg.value > 0` that may be lost. + */ + error ERC1967NonPayable(); + + /** + * @dev Returns the current implementation address. + */ + function getImplementation() internal view returns (address) { + return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value; + } + + /** + * @dev Stores a new address in the EIP1967 implementation slot. + */ + function _setImplementation(address newImplementation) private { + if (newImplementation.code.length == 0) { + revert ERC1967InvalidImplementation(newImplementation); + } + StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation; + } + + /** + * @dev Performs implementation upgrade with additional setup call if data is nonempty. + * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected + * to avoid stuck value in the contract. + * + * Emits an {IERC1967-Upgraded} event. + */ + function upgradeToAndCall(address newImplementation, bytes memory data) internal { + _setImplementation(newImplementation); + emit Upgraded(newImplementation); + + if (data.length > 0) { + Address.functionDelegateCall(newImplementation, data); + } else { + _checkNonPayable(); + } + } + + /** + * @dev Storage slot with the admin of the contract. + * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1. + */ + // solhint-disable-next-line private-vars-leading-underscore + bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; + + /** + * @dev Returns the current admin. + * + * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using + * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. + * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103` + */ + function getAdmin() internal view returns (address) { + return StorageSlot.getAddressSlot(ADMIN_SLOT).value; + } + + /** + * @dev Stores a new address in the EIP1967 admin slot. + */ + function _setAdmin(address newAdmin) private { + if (newAdmin == address(0)) { + revert ERC1967InvalidAdmin(address(0)); + } + StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin; + } + + /** + * @dev Changes the admin of the proxy. + * + * Emits an {IERC1967-AdminChanged} event. + */ + function changeAdmin(address newAdmin) internal { + emit AdminChanged(getAdmin(), newAdmin); + _setAdmin(newAdmin); + } + + /** + * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. + * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1. + */ + // solhint-disable-next-line private-vars-leading-underscore + bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; + + /** + * @dev Returns the current beacon. + */ + function getBeacon() internal view returns (address) { + return StorageSlot.getAddressSlot(BEACON_SLOT).value; + } + + /** + * @dev Stores a new beacon in the EIP1967 beacon slot. + */ + function _setBeacon(address newBeacon) private { + if (newBeacon.code.length == 0) { + revert ERC1967InvalidBeacon(newBeacon); + } + + StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon; + + address beaconImplementation = IBeacon(newBeacon).implementation(); + if (beaconImplementation.code.length == 0) { + revert ERC1967InvalidImplementation(beaconImplementation); + } + } + + /** + * @dev Change the beacon and trigger a setup call if data is nonempty. + * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected + * to avoid stuck value in the contract. + * + * Emits an {IERC1967-BeaconUpgraded} event. + * + * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since + * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for + * efficiency. + */ + function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal { + _setBeacon(newBeacon); + emit BeaconUpgraded(newBeacon); + + if (data.length > 0) { + Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); + } else { + _checkNonPayable(); + } + } + + /** + * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract + * if an upgrade doesn't perform an initialization call. + */ + function _checkNonPayable() private { + if (msg.value > 0) { + revert ERC1967NonPayable(); + } + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Proxy.sol) + +/** + * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an + * implementation address that can be changed. This address is stored in storage in the location specified by + * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the + * implementation behind the proxy. + */ +contract ERC1967Proxy is Proxy { + /** + * @dev Initializes the upgradeable proxy with an initial implementation specified by `implementation`. + * + * If `_data` is nonempty, it's used as data in a delegate call to `implementation`. This will typically be an + * encoded function call, and allows initializing the storage of the proxy like a Solidity constructor. + * + * Requirements: + * + * - If `data` is empty, `msg.value` must be zero. + */ + constructor(address implementation, bytes memory _data) payable { + ERC1967Utils.upgradeToAndCall(implementation, _data); + } + + /** + * @dev Returns the current implementation address. + * + * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using + * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. + * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc` + */ + function _implementation() internal view virtual override returns (address) { + return ERC1967Utils.getImplementation(); + } +} + diff --git a/certora/mocks/Jug.sol b/certora/mocks/Jug.sol new file mode 100644 index 0000000..99fe253 --- /dev/null +++ b/certora/mocks/Jug.sol @@ -0,0 +1,161 @@ +/** + *Submitted for verification at Etherscan.io on 2019-11-14 +*/ + +// hevm: flattened sources of /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/jug.sol +pragma solidity =0.5.12; + +////// /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/lib.sol +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +/* pragma solidity 0.5.12; */ + +contract LibNote { + event LogNote( + bytes4 indexed sig, + address indexed usr, + bytes32 indexed arg1, + bytes32 indexed arg2, + bytes data + ) anonymous; + + modifier note { + _; + assembly { + // log an 'anonymous' event with a constant 6 words of calldata + // and four indexed topics: selector, caller, arg1 and arg2 + let mark := msize // end of memory ensures zero + mstore(0x40, add(mark, 288)) // update free memory pointer + mstore(mark, 0x20) // bytes type data offset + mstore(add(mark, 0x20), 224) // bytes size (padded) + calldatacopy(add(mark, 0x40), 0, 224) // bytes payload + log4(mark, 288, // calldata + shl(224, shr(224, calldataload(0))), // msg.sig + caller, // msg.sender + calldataload(4), // arg1 + calldataload(36) // arg2 + ) + } + } +} + +////// /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/jug.sol +/* pragma solidity 0.5.12; */ + +/* import "./lib.sol"; */ + +contract VatLike { + function ilks(bytes32) external returns ( + uint256 Art, // wad + uint256 rate // ray + ); + function fold(bytes32,address,int) external; +} + +contract Jug is LibNote { + // --- Auth --- + mapping (address => uint) public wards; + function rely(address usr) external note auth { wards[usr] = 1; } + function deny(address usr) external note auth { wards[usr] = 0; } + modifier auth { + require(wards[msg.sender] == 1, "Jug/not-authorized"); + _; + } + + // --- Data --- + struct Ilk { + uint256 duty; + uint256 rho; + } + + mapping (bytes32 => Ilk) public ilks; + VatLike public vat; + address public vow; + uint256 public base; + + // --- Init --- + constructor(address vat_) public { + wards[msg.sender] = 1; + vat = VatLike(vat_); + } + + // --- Math --- + function rpow(uint x, uint n, uint b) internal pure returns (uint z) { + assembly { + switch x case 0 {switch n case 0 {z := b} default {z := 0}} + default { + switch mod(n, 2) case 0 { z := b } default { z := x } + let half := div(b, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n,2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0,0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0,0) } + x := div(xxRound, b) + if mod(n,2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0,0) } + z := div(zxRound, b) + } + } + } + } + } + uint256 constant ONE = 10 ** 27; + function add(uint x, uint y) internal pure returns (uint z) { + z = x + y; + require(z >= x); + } + function diff(uint x, uint y) internal pure returns (int z) { + z = int(x) - int(y); + require(int(x) >= 0 && int(y) >= 0); + } + function rmul(uint x, uint y) internal pure returns (uint z) { + z = x * y; + require(y == 0 || z / y == x); + z = z / ONE; + } + + // --- Administration --- + function init(bytes32 ilk) external note auth { + Ilk storage i = ilks[ilk]; + require(i.duty == 0, "Jug/ilk-already-init"); + i.duty = ONE; + i.rho = now; + } + function file(bytes32 ilk, bytes32 what, uint data) external note auth { + require(now == ilks[ilk].rho, "Jug/rho-not-updated"); + if (what == "duty") ilks[ilk].duty = data; + else revert("Jug/file-unrecognized-param"); + } + function file(bytes32 what, uint data) external note auth { + if (what == "base") base = data; + else revert("Jug/file-unrecognized-param"); + } + function file(bytes32 what, address data) external note auth { + if (what == "vow") vow = data; + else revert("Jug/file-unrecognized-param"); + } + + // --- Stability Fee Collection --- + function drip(bytes32 ilk) external note returns (uint rate) { + require(now >= ilks[ilk].rho, "Jug/invalid-now"); + (, uint prev) = vat.ilks(ilk); + rate = rmul(rpow(add(base, ilks[ilk].duty), now - ilks[ilk].rho, ONE), prev); + vat.fold(ilk, vow, diff(rate, prev)); + ilks[ilk].rho = now; + } +} diff --git a/certora/mocks/Pot.sol b/certora/mocks/Pot.sol new file mode 100644 index 0000000..936d842 --- /dev/null +++ b/certora/mocks/Pot.sol @@ -0,0 +1,215 @@ +/** + *Submitted for verification at Etherscan.io on 2019-11-14 +*/ + +// hevm: flattened sources of /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/pot.sol +pragma solidity =0.5.12; + +////// /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/lib.sol +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +/* pragma solidity 0.5.12; */ + +contract LibNote { + event LogNote( + bytes4 indexed sig, + address indexed usr, + bytes32 indexed arg1, + bytes32 indexed arg2, + bytes data + ) anonymous; + + modifier note { + _; + assembly { + // log an 'anonymous' event with a constant 6 words of calldata + // and four indexed topics: selector, caller, arg1 and arg2 + let mark := msize // end of memory ensures zero + mstore(0x40, add(mark, 288)) // update free memory pointer + mstore(mark, 0x20) // bytes type data offset + mstore(add(mark, 0x20), 224) // bytes size (padded) + calldatacopy(add(mark, 0x40), 0, 224) // bytes payload + log4(mark, 288, // calldata + shl(224, shr(224, calldataload(0))), // msg.sig + caller, // msg.sender + calldataload(4), // arg1 + calldataload(36) // arg2 + ) + } + } +} + +////// /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/pot.sol +/// pot.sol -- Dai Savings Rate + +// Copyright (C) 2018 Rain +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +/* pragma solidity 0.5.12; */ + +/* import "./lib.sol"; */ + +/* + "Savings Dai" is obtained when Dai is deposited into + this contract. Each "Savings Dai" accrues Dai interest + at the "Dai Savings Rate". + + This contract does not implement a user tradeable token + and is intended to be used with adapters. + + --- `save` your `dai` in the `pot` --- + + - `dsr`: the Dai Savings Rate + - `pie`: user balance of Savings Dai + + - `join`: start saving some dai + - `exit`: remove some dai + - `drip`: perform rate collection + +*/ + +contract VatLike { + function move(address,address,uint256) external; + function suck(address,address,uint256) external; +} + +contract Pot is LibNote { + // --- Auth --- + mapping (address => uint) public wards; + function rely(address guy) external note auth { wards[guy] = 1; } + function deny(address guy) external note auth { wards[guy] = 0; } + modifier auth { + require(wards[msg.sender] == 1, "Pot/not-authorized"); + _; + } + + // --- Data --- + mapping (address => uint256) public pie; // user Savings Dai + + uint256 public Pie; // total Savings Dai + uint256 public dsr; // the Dai Savings Rate + uint256 public chi; // the Rate Accumulator + + VatLike public vat; // CDP engine + address public vow; // debt engine + uint256 public rho; // time of last drip + + uint256 public live; // Access Flag + + // --- Init --- + constructor(address vat_) public { + wards[msg.sender] = 1; + vat = VatLike(vat_); + dsr = ONE; + chi = ONE; + rho = now; + live = 1; + } + + // --- Math --- + uint256 constant ONE = 10 ** 27; + function rpow(uint x, uint n, uint base) internal pure returns (uint z) { + assembly { + switch x case 0 {switch n case 0 {z := base} default {z := 0}} + default { + switch mod(n, 2) case 0 { z := base } default { z := x } + let half := div(base, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n,2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0,0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0,0) } + x := div(xxRound, base) + if mod(n,2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0,0) } + z := div(zxRound, base) + } + } + } + } + } + + function rmul(uint x, uint y) internal pure returns (uint z) { + z = mul(x, y) / ONE; + } + + function add(uint x, uint y) internal pure returns (uint z) { + require((z = x + y) >= x); + } + + function sub(uint x, uint y) internal pure returns (uint z) { + require((z = x - y) <= x); + } + + function mul(uint x, uint y) internal pure returns (uint z) { + require(y == 0 || (z = x * y) / y == x); + } + + // --- Administration --- + function file(bytes32 what, uint256 data) external note auth { + require(live == 1, "Pot/not-live"); + require(now == rho, "Pot/rho-not-updated"); + if (what == "dsr") dsr = data; + else revert("Pot/file-unrecognized-param"); + } + + function file(bytes32 what, address addr) external note auth { + if (what == "vow") vow = addr; + else revert("Pot/file-unrecognized-param"); + } + + function cage() external note auth { + live = 0; + dsr = ONE; + } + + // --- Savings Rate Accumulation --- + function drip() external note returns (uint tmp) { + require(now >= rho, "Pot/invalid-now"); + tmp = rmul(rpow(dsr, now - rho, ONE), chi); + uint chi_ = sub(tmp, chi); + chi = tmp; + rho = now; + vat.suck(address(vow), address(this), mul(Pie, chi_)); + } + + // --- Savings Dai Management --- + function join(uint wad) external note { + require(now == rho, "Pot/rho-not-updated"); + pie[msg.sender] = add(pie[msg.sender], wad); + Pie = add(Pie, wad); + vat.move(msg.sender, address(this), mul(chi, wad)); + } + + function exit(uint wad) external note { + pie[msg.sender] = sub(pie[msg.sender], wad); + Pie = sub(Pie, wad); + vat.move(address(this), msg.sender, mul(chi, wad)); + } +} diff --git a/certora/mocks/SUsds.sol b/certora/mocks/SUsds.sol new file mode 100644 index 0000000..1389be4 --- /dev/null +++ b/certora/mocks/SUsds.sol @@ -0,0 +1,1379 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.20 ^0.8.21; + +// lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol) + +/** + * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed + * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an + * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer + * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. + * + * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be + * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in + * case an upgrade adds a module that needs to be initialized. + * + * For example: + * + * [.hljs-theme-light.nopadding] + * ```solidity + * contract MyToken is ERC20Upgradeable { + * function initialize() initializer public { + * __ERC20_init("MyToken", "MTK"); + * } + * } + * + * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { + * function initializeV2() reinitializer(2) public { + * __ERC20Permit_init("MyToken"); + * } + * } + * ``` + * + * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as + * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. + * + * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure + * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. + * + * [CAUTION] + * ==== + * Avoid leaving a contract uninitialized. + * + * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation + * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke + * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: + * + * [.hljs-theme-light.nopadding] + * ``` + * /// @custom:oz-upgrades-unsafe-allow constructor + * constructor() { + * _disableInitializers(); + * } + * ``` + * ==== + */ +abstract contract Initializable { + /** + * @dev Storage of the initializable contract. + * + * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions + * when using with upgradeable contracts. + * + * @custom:storage-location erc7201:openzeppelin.storage.Initializable + */ + struct InitializableStorage { + /** + * @dev Indicates that the contract has been initialized. + */ + uint64 _initialized; + /** + * @dev Indicates that the contract is in the process of being initialized. + */ + bool _initializing; + } + + // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff)) + bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00; + + /** + * @dev The contract is already initialized. + */ + error InvalidInitialization(); + + /** + * @dev The contract is not initializing. + */ + error NotInitializing(); + + /** + * @dev Triggered when the contract has been initialized or reinitialized. + */ + event Initialized(uint64 version); + + /** + * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, + * `onlyInitializing` functions can be used to initialize parent contracts. + * + * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any + * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in + * production. + * + * Emits an {Initialized} event. + */ + modifier initializer() { + // solhint-disable-next-line var-name-mixedcase + InitializableStorage storage $ = _getInitializableStorage(); + + // Cache values to avoid duplicated sloads + bool isTopLevelCall = !$._initializing; + uint64 initialized = $._initialized; + + // Allowed calls: + // - initialSetup: the contract is not in the initializing state and no previous version was + // initialized + // - construction: the contract is initialized at version 1 (no reininitialization) and the + // current contract is just being deployed + bool initialSetup = initialized == 0 && isTopLevelCall; + bool construction = initialized == 1 && address(this).code.length == 0; + + if (!initialSetup && !construction) { + revert InvalidInitialization(); + } + $._initialized = 1; + if (isTopLevelCall) { + $._initializing = true; + } + _; + if (isTopLevelCall) { + $._initializing = false; + emit Initialized(1); + } + } + + /** + * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the + * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be + * used to initialize parent contracts. + * + * A reinitializer may be used after the original initialization step. This is essential to configure modules that + * are added through upgrades and that require initialization. + * + * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` + * cannot be nested. If one is invoked in the context of another, execution will revert. + * + * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in + * a contract, executing them in the right order is up to the developer or operator. + * + * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization. + * + * Emits an {Initialized} event. + */ + modifier reinitializer(uint64 version) { + // solhint-disable-next-line var-name-mixedcase + InitializableStorage storage $ = _getInitializableStorage(); + + if ($._initializing || $._initialized >= version) { + revert InvalidInitialization(); + } + $._initialized = version; + $._initializing = true; + _; + $._initializing = false; + emit Initialized(version); + } + + /** + * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the + * {initializer} and {reinitializer} modifiers, directly or indirectly. + */ + modifier onlyInitializing() { + _checkInitializing(); + _; + } + + /** + * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}. + */ + function _checkInitializing() internal view virtual { + if (!_isInitializing()) { + revert NotInitializing(); + } + } + + /** + * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. + * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized + * to any version. It is recommended to use this to lock implementation contracts that are designed to be called + * through proxies. + * + * Emits an {Initialized} event the first time it is successfully executed. + */ + function _disableInitializers() internal virtual { + // solhint-disable-next-line var-name-mixedcase + InitializableStorage storage $ = _getInitializableStorage(); + + if ($._initializing) { + revert InvalidInitialization(); + } + if ($._initialized != type(uint64).max) { + $._initialized = type(uint64).max; + emit Initialized(type(uint64).max); + } + } + + /** + * @dev Returns the highest version that has been initialized. See {reinitializer}. + */ + function _getInitializedVersion() internal view returns (uint64) { + return _getInitializableStorage()._initialized; + } + + /** + * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. + */ + function _isInitializing() internal view returns (bool) { + return _getInitializableStorage()._initializing; + } + + /** + * @dev Returns a pointer to the storage namespace. + */ + // solhint-disable-next-line var-name-mixedcase + function _getInitializableStorage() private pure returns (InitializableStorage storage $) { + assembly { + $.slot := INITIALIZABLE_STORAGE + } + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol) + +/** + * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified + * proxy whose upgrades are fully controlled by the current implementation. + */ +interface IERC1822Proxiable { + /** + * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation + * address. + * + * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks + * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this + * function revert if invoked through a proxy. + */ + function proxiableUUID() external view returns (bytes32); +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol) + +/** + * @dev This is the interface that {BeaconProxy} expects of its beacon. + */ +interface IBeacon { + /** + * @dev Must return an address that can be used as a delegate call target. + * + * {UpgradeableBeacon} will check that this address is a contract. + */ + function implementation() external view returns (address); +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) + +/** + * @dev Collection of functions related to the address type + */ +library Address { + /** + * @dev The ETH balance of the account is not enough to perform the operation. + */ + error AddressInsufficientBalance(address account); + + /** + * @dev There's no code at `target` (it is not a contract). + */ + error AddressEmptyCode(address target); + + /** + * @dev A call to an address target failed. The target may have reverted. + */ + error FailedInnerCall(); + + /** + * @dev Replacement for Solidity's `transfer`: sends `amount` wei to + * `recipient`, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by `transfer`, making them unable to receive funds via + * `transfer`. {sendValue} removes this limitation. + * + * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to `recipient`, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. + */ + function sendValue(address payable recipient, uint256 amount) internal { + if (address(this).balance < amount) { + revert AddressInsufficientBalance(address(this)); + } + + (bool success, ) = recipient.call{value: amount}(""); + if (!success) { + revert FailedInnerCall(); + } + } + + /** + * @dev Performs a Solidity function call using a low level `call`. A + * plain `call` is an unsafe replacement for a function call: use this + * function instead. + * + * If `target` reverts with a revert reason or custom error, it is bubbled + * up by this function (like regular Solidity function calls). However, if + * the call reverted with no returned reason, this function reverts with a + * {FailedInnerCall} error. + * + * Returns the raw returned data. To convert to the expected return value, + * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. + * + * Requirements: + * + * - `target` must be a contract. + * - calling `target` with `data` must not revert. + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but also transferring `value` wei to `target`. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least `value`. + * - the called Solidity function must be `payable`. + */ + function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { + if (address(this).balance < value) { + revert AddressInsufficientBalance(address(this)); + } + (bool success, bytes memory returndata) = target.call{value: value}(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a static call. + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + (bool success, bytes memory returndata) = target.staticcall(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a delegate call. + */ + function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { + (bool success, bytes memory returndata) = target.delegatecall(data); + return verifyCallResultFromTarget(target, success, returndata); + } + + /** + * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target + * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an + * unsuccessful call. + */ + function verifyCallResultFromTarget( + address target, + bool success, + bytes memory returndata + ) internal view returns (bytes memory) { + if (!success) { + _revert(returndata); + } else { + // only check if target is a contract if the call was successful and the return data is empty + // otherwise we already know that it was a contract + if (returndata.length == 0 && target.code.length == 0) { + revert AddressEmptyCode(target); + } + return returndata; + } + } + + /** + * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the + * revert reason or with a default {FailedInnerCall} error. + */ + function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { + if (!success) { + _revert(returndata); + } else { + return returndata; + } + } + + /** + * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. + */ + function _revert(bytes memory returndata) private pure { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + /// @solidity memory-safe-assembly + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert FailedInnerCall(); + } + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) +// This file was procedurally generated from scripts/generate/templates/StorageSlot.js. + +/** + * @dev Library for reading and writing primitive types to specific storage slots. + * + * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. + * This library helps with reading and writing to such slots without the need for inline assembly. + * + * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. + * + * Example usage to set ERC1967 implementation slot: + * ```solidity + * contract ERC1967 { + * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; + * + * function _getImplementation() internal view returns (address) { + * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; + * } + * + * function _setImplementation(address newImplementation) internal { + * require(newImplementation.code.length > 0); + * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; + * } + * } + * ``` + */ +library StorageSlot { + struct AddressSlot { + address value; + } + + struct BooleanSlot { + bool value; + } + + struct Bytes32Slot { + bytes32 value; + } + + struct Uint256Slot { + uint256 value; + } + + struct StringSlot { + string value; + } + + struct BytesSlot { + bytes value; + } + + /** + * @dev Returns an `AddressSlot` with member `value` located at `slot`. + */ + function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `BooleanSlot` with member `value` located at `slot`. + */ + function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. + */ + function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `Uint256Slot` with member `value` located at `slot`. + */ + function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `StringSlot` with member `value` located at `slot`. + */ + function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `StringSlot` representation of the string storage pointer `store`. + */ + function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := store.slot + } + } + + /** + * @dev Returns an `BytesSlot` with member `value` located at `slot`. + */ + function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. + */ + function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := store.slot + } + } +} + +// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol) + +/** + * @dev This abstract contract provides getters and event emitting update functions for + * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. + */ +library ERC1967Utils { + // We re-declare ERC-1967 events here because they can't be used directly from IERC1967. + // This will be fixed in Solidity 0.8.21. At that point we should remove these events. + /** + * @dev Emitted when the implementation is upgraded. + */ + event Upgraded(address indexed implementation); + + /** + * @dev Emitted when the admin account has changed. + */ + event AdminChanged(address previousAdmin, address newAdmin); + + /** + * @dev Emitted when the beacon is changed. + */ + event BeaconUpgraded(address indexed beacon); + + /** + * @dev Storage slot with the address of the current implementation. + * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1. + */ + // solhint-disable-next-line private-vars-leading-underscore + bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; + + /** + * @dev The `implementation` of the proxy is invalid. + */ + error ERC1967InvalidImplementation(address implementation); + + /** + * @dev The `admin` of the proxy is invalid. + */ + error ERC1967InvalidAdmin(address admin); + + /** + * @dev The `beacon` of the proxy is invalid. + */ + error ERC1967InvalidBeacon(address beacon); + + /** + * @dev An upgrade function sees `msg.value > 0` that may be lost. + */ + error ERC1967NonPayable(); + + /** + * @dev Returns the current implementation address. + */ + function getImplementation() internal view returns (address) { + return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value; + } + + /** + * @dev Stores a new address in the EIP1967 implementation slot. + */ + function _setImplementation(address newImplementation) private { + if (newImplementation.code.length == 0) { + revert ERC1967InvalidImplementation(newImplementation); + } + StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation; + } + + /** + * @dev Performs implementation upgrade with additional setup call if data is nonempty. + * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected + * to avoid stuck value in the contract. + * + * Emits an {IERC1967-Upgraded} event. + */ + function upgradeToAndCall(address newImplementation, bytes memory data) internal { + _setImplementation(newImplementation); + emit Upgraded(newImplementation); + + if (data.length > 0) { + Address.functionDelegateCall(newImplementation, data); + } else { + _checkNonPayable(); + } + } + + /** + * @dev Storage slot with the admin of the contract. + * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1. + */ + // solhint-disable-next-line private-vars-leading-underscore + bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; + + /** + * @dev Returns the current admin. + * + * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using + * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. + * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103` + */ + function getAdmin() internal view returns (address) { + return StorageSlot.getAddressSlot(ADMIN_SLOT).value; + } + + /** + * @dev Stores a new address in the EIP1967 admin slot. + */ + function _setAdmin(address newAdmin) private { + if (newAdmin == address(0)) { + revert ERC1967InvalidAdmin(address(0)); + } + StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin; + } + + /** + * @dev Changes the admin of the proxy. + * + * Emits an {IERC1967-AdminChanged} event. + */ + function changeAdmin(address newAdmin) internal { + emit AdminChanged(getAdmin(), newAdmin); + _setAdmin(newAdmin); + } + + /** + * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. + * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1. + */ + // solhint-disable-next-line private-vars-leading-underscore + bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; + + /** + * @dev Returns the current beacon. + */ + function getBeacon() internal view returns (address) { + return StorageSlot.getAddressSlot(BEACON_SLOT).value; + } + + /** + * @dev Stores a new beacon in the EIP1967 beacon slot. + */ + function _setBeacon(address newBeacon) private { + if (newBeacon.code.length == 0) { + revert ERC1967InvalidBeacon(newBeacon); + } + + StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon; + + address beaconImplementation = IBeacon(newBeacon).implementation(); + if (beaconImplementation.code.length == 0) { + revert ERC1967InvalidImplementation(beaconImplementation); + } + } + + /** + * @dev Change the beacon and trigger a setup call if data is nonempty. + * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected + * to avoid stuck value in the contract. + * + * Emits an {IERC1967-BeaconUpgraded} event. + * + * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since + * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for + * efficiency. + */ + function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal { + _setBeacon(newBeacon); + emit BeaconUpgraded(newBeacon); + + if (data.length > 0) { + Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); + } else { + _checkNonPayable(); + } + } + + /** + * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract + * if an upgrade doesn't perform an initialization call. + */ + function _checkNonPayable() private { + if (msg.value > 0) { + revert ERC1967NonPayable(); + } + } +} + +// lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol + +// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol) + +/** + * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an + * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. + * + * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is + * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing + * `UUPSUpgradeable` with a custom implementation of upgrades. + * + * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. + */ +abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { + /// @custom:oz-upgrades-unsafe-allow state-variable-immutable + address private immutable __self = address(this); + + /** + * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)` + * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called, + * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string. + * If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must + * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function + * during an upgrade. + */ + string public constant UPGRADE_INTERFACE_VERSION = "5.0.0"; + + /** + * @dev The call is from an unauthorized context. + */ + error UUPSUnauthorizedCallContext(); + + /** + * @dev The storage `slot` is unsupported as a UUID. + */ + error UUPSUnsupportedProxiableUUID(bytes32 slot); + + /** + * @dev Check that the execution is being performed through a delegatecall call and that the execution context is + * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case + * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a + * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to + * fail. + */ + modifier onlyProxy() { + _checkProxy(); + _; + } + + /** + * @dev Check that the execution is not being performed through a delegate call. This allows a function to be + * callable on the implementing contract but not through proxies. + */ + modifier notDelegated() { + _checkNotDelegated(); + _; + } + + function __UUPSUpgradeable_init() internal onlyInitializing { + } + + function __UUPSUpgradeable_init_unchained() internal onlyInitializing { + } + /** + * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the + * implementation. It is used to validate the implementation's compatibility when performing an upgrade. + * + * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks + * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this + * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. + */ + function proxiableUUID() external view virtual notDelegated returns (bytes32) { + return ERC1967Utils.IMPLEMENTATION_SLOT; + } + + /** + * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call + * encoded in `data`. + * + * Calls {_authorizeUpgrade}. + * + * Emits an {Upgraded} event. + * + * @custom:oz-upgrades-unsafe-allow-reachable delegatecall + */ + function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy { + _authorizeUpgrade(newImplementation); + _upgradeToAndCallUUPS(newImplementation, data); + } + + /** + * @dev Reverts if the execution is not performed via delegatecall or the execution + * context is not of a proxy with an ERC1967-compliant implementation pointing to self. + * See {_onlyProxy}. + */ + function _checkProxy() internal view virtual { + if ( + address(this) == __self || // Must be called through delegatecall + ERC1967Utils.getImplementation() != __self // Must be called through an active proxy + ) { + revert UUPSUnauthorizedCallContext(); + } + } + + /** + * @dev Reverts if the execution is performed via delegatecall. + * See {notDelegated}. + */ + function _checkNotDelegated() internal view virtual { + if (address(this) != __self) { + // Must not be called through delegatecall + revert UUPSUnauthorizedCallContext(); + } + } + + /** + * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by + * {upgradeToAndCall}. + * + * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. + * + * ```solidity + * function _authorizeUpgrade(address) internal onlyOwner {} + * ``` + */ + function _authorizeUpgrade(address newImplementation) internal virtual; + + /** + * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call. + * + * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value + * is expected to be the implementation slot in ERC1967. + * + * Emits an {IERC1967-Upgraded} event. + */ + function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private { + try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) { + if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) { + revert UUPSUnsupportedProxiableUUID(slot); + } + ERC1967Utils.upgradeToAndCall(newImplementation, data); + } catch { + // The implementation is not UUPS + revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation); + } + } +} + +// src/SUsds.sol + +/// SUsds.sol + +// Copyright (C) 2017, 2018, 2019 dbrock, rain, mrchico +// Copyright (C) 2021 Dai Foundation +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +interface IERC1271 { + function isValidSignature( + bytes32, + bytes memory + ) external view returns (bytes4); +} + +interface VatLike { + function hope(address) external; + function suck(address, address, uint256) external; +} + +interface UsdsJoinLike { + function vat() external view returns (address); + function usds() external view returns (address); + function exit(address, uint256) external; +} + +interface UsdsLike { + function transfer(address, uint256) external; + function transferFrom(address, address, uint256) external; +} + +contract SUsds is UUPSUpgradeable { + + // --- Storage Variables --- + + // Admin + mapping (address => uint256) public wards; + // ERC20 + uint256 public totalSupply; + mapping (address => uint256) public balanceOf; + mapping (address => mapping (address => uint256)) public allowance; + mapping (address => uint256) public nonces; + // Savings yield + uint192 public chi; // The Rate Accumulator [ray] + uint64 public rho; // Time of last drip [unix epoch time] + uint256 public ssr; // The USDS Savings Rate [ray] + + // --- Constants --- + + // ERC20 + string public constant name = "Savings USDS"; + string public constant symbol = "sUSDS"; + string public constant version = "1"; + uint8 public constant decimals = 18; + // Math + uint256 private constant RAY = 10 ** 27; + + // --- Immutables --- + + // EIP712 + bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); + // Savings yield + UsdsJoinLike public immutable usdsJoin; + VatLike public immutable vat; + UsdsLike public immutable usds; + address public immutable vow; + + // --- Events --- + + // Admin + event Rely(address indexed usr); + event Deny(address indexed usr); + event File(bytes32 indexed what, uint256 data); + // ERC20 + event Approval(address indexed owner, address indexed spender, uint256 value); + event Transfer(address indexed from, address indexed to, uint256 value); + // ERC4626 + event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares); + event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares); + // Referral + event Referral(uint16 indexed referral, address indexed owner, uint256 assets, uint256 shares); + // Savings yield + event Drip(uint256 chi, uint256 diff); + + // --- Modifiers --- + + modifier auth { + require(wards[msg.sender] == 1, "SUsds/not-authorized"); + _; + } + + // --- Constructor --- + + constructor(address usdsJoin_, address vow_) { + _disableInitializers(); // Avoid initializing in the context of the implementation + + usdsJoin = UsdsJoinLike(usdsJoin_); + vat = VatLike(UsdsJoinLike(usdsJoin_).vat()); + usds = UsdsLike(UsdsJoinLike(usdsJoin_).usds()); + vow = vow_; + } + + // --- Upgradability --- + + function initialize() initializer external { + __UUPSUpgradeable_init(); + + chi = uint192(RAY); + rho = uint64(block.timestamp); + ssr = RAY; + vat.hope(address(usdsJoin)); + wards[msg.sender] = 1; + emit Rely(msg.sender); + } + + function _authorizeUpgrade(address newImplementation) internal override auth {} + + function getImplementation() external view returns (address) { + return ERC1967Utils.getImplementation(); + } + + // --- Internals --- + + // EIP712 + + function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) { + return keccak256( + abi.encode( + keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), + keccak256(bytes(name)), + keccak256(bytes(version)), + chainId, + address(this) + ) + ); + } + + function DOMAIN_SEPARATOR() external view returns (bytes32) { + return _calculateDomainSeparator(block.chainid); + } + + // Math + + function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { + assembly { + switch x case 0 {switch n case 0 {z := RAY} default {z := 0}} + default { + switch mod(n, 2) case 0 { z := RAY } default { z := x } + let half := div(RAY, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n,2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0,0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0,0) } + x := div(xxRound, RAY) + if mod(n,2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0,0) } + z := div(zxRound, RAY) + } + } + } + } + } + + function _divup(uint256 x, uint256 y) internal pure returns (uint256 z) { + // Note: _divup(0,0) will return 0 differing from natural solidity division + unchecked { + z = x != 0 ? ((x - 1) / y) + 1 : 0; + } + } + + // --- Admin external functions --- + + function rely(address usr) external auth { + wards[usr] = 1; + emit Rely(usr); + } + + function deny(address usr) external auth { + wards[usr] = 0; + emit Deny(usr); + } + + function file(bytes32 what, uint256 data) external auth { + if (what == "ssr") { + require(data >= RAY, "SUsds/wrong-ssr-value"); + require(rho == block.timestamp, "SUsds/chi-not-up-to-date"); + ssr = data; + } else revert("SUsds/file-unrecognized-param"); + emit File(what, data); + } + + // --- Savings Rate Accumulation external/internal function --- + + function drip() public returns (uint256 nChi) { + (uint256 chi_, uint256 rho_) = (chi, rho); + uint256 diff; + if (block.timestamp > rho_) { + nChi = _rpow(ssr, block.timestamp - rho_) * chi_ / RAY; + uint256 totalSupply_ = totalSupply; + diff = totalSupply_ * nChi / RAY - totalSupply_ * chi_ / RAY; + vat.suck(address(vow), address(this), diff * RAY); + usdsJoin.exit(address(this), diff); + chi = uint192(nChi); // safe as nChi is limited to maxUint256/RAY (which is < maxUint192) + rho = uint64(block.timestamp); + } else { + nChi = chi_; + } + emit Drip(nChi, diff); + } + + // --- ERC20 Mutations --- + + function transfer(address to, uint256 value) external returns (bool) { + require(to != address(0) && to != address(this), "SUsds/invalid-address"); + uint256 balance = balanceOf[msg.sender]; + require(balance >= value, "SUsds/insufficient-balance"); + + unchecked { + balanceOf[msg.sender] = balance - value; + balanceOf[to] += value; // note: we don't need an overflow check here b/c sum of all balances == totalSupply + } + + emit Transfer(msg.sender, to, value); + + return true; + } + + function transferFrom(address from, address to, uint256 value) external returns (bool) { + require(to != address(0) && to != address(this), "SUsds/invalid-address"); + uint256 balance = balanceOf[from]; + require(balance >= value, "SUsds/insufficient-balance"); + + if (from != msg.sender) { + uint256 allowed = allowance[from][msg.sender]; + if (allowed != type(uint256).max) { + require(allowed >= value, "SUsds/insufficient-allowance"); + + unchecked { + allowance[from][msg.sender] = allowed - value; + } + } + } + + unchecked { + balanceOf[from] = balance - value; + balanceOf[to] += value; // note: we don't need an overflow check here b/c sum of all balances == totalSupply + } + + emit Transfer(from, to, value); + + return true; + } + + function approve(address spender, uint256 value) external returns (bool) { + allowance[msg.sender][spender] = value; + + emit Approval(msg.sender, spender, value); + + return true; + } + + // --- Mint/Burn Internal --- + + function _mint(uint256 assets, uint256 shares, address receiver) internal { + require(receiver != address(0) && receiver != address(this), "SUsds/invalid-address"); + + usds.transferFrom(msg.sender, address(this), assets); + + unchecked { + balanceOf[receiver] = balanceOf[receiver] + shares; // note: we don't need an overflow check here b/c balanceOf[receiver] <= totalSupply + totalSupply = totalSupply + shares; // note: we don't need an overflow check here b/c shares totalSupply will always be <= usds totalSupply + } + + emit Deposit(msg.sender, receiver, assets, shares); + emit Transfer(address(0), receiver, shares); + } + + function _burn(uint256 assets, uint256 shares, address receiver, address owner) internal { + uint256 balance = balanceOf[owner]; + require(balance >= shares, "SUsds/insufficient-balance"); + + if (owner != msg.sender) { + uint256 allowed = allowance[owner][msg.sender]; + if (allowed != type(uint256).max) { + require(allowed >= shares, "SUsds/insufficient-allowance"); + + unchecked { + allowance[owner][msg.sender] = allowed - shares; + } + } + } + + unchecked { + balanceOf[owner] = balance - shares; // note: we don't need overflow checks b/c require(balance >= shares) and balance <= totalSupply + totalSupply = totalSupply - shares; + } + + usds.transfer(receiver, assets); + + emit Transfer(owner, address(0), shares); + emit Withdraw(msg.sender, receiver, owner, assets, shares); + } + + // --- ERC-4626 --- + + function asset() external view returns (address) { + return address(usds); + } + + function totalAssets() external view returns (uint256) { + return convertToAssets(totalSupply); + } + + function convertToShares(uint256 assets) public view returns (uint256) { + uint256 chi_ = (block.timestamp > rho) ? _rpow(ssr, block.timestamp - rho) * chi / RAY : chi; + return assets * RAY / chi_; + } + + function convertToAssets(uint256 shares) public view returns (uint256) { + uint256 chi_ = (block.timestamp > rho) ? _rpow(ssr, block.timestamp - rho) * chi / RAY : chi; + return shares * chi_ / RAY; + } + + function maxDeposit(address) external pure returns (uint256) { + return type(uint256).max; + } + + function previewDeposit(uint256 assets) external view returns (uint256) { + return convertToShares(assets); + } + + function deposit(uint256 assets, address receiver) public returns (uint256 shares) { + shares = assets * RAY / drip(); + _mint(assets, shares, receiver); + } + + function deposit(uint256 assets, address receiver, uint16 referral) external returns (uint256 shares) { + shares = deposit(assets, receiver); + emit Referral(referral, receiver, assets, shares); + } + + function maxMint(address) external pure returns (uint256) { + return type(uint256).max; + } + + function previewMint(uint256 shares) external view returns (uint256) { + uint256 chi_ = (block.timestamp > rho) ? _rpow(ssr, block.timestamp - rho) * chi / RAY : chi; + return _divup(shares * chi_, RAY); + } + + function mint(uint256 shares, address receiver) public returns (uint256 assets) { + assets = _divup(shares * drip(), RAY); + _mint(assets, shares, receiver); + } + + function mint(uint256 shares, address receiver, uint16 referral) external returns (uint256 assets) { + assets = mint(shares, receiver); + emit Referral(referral, receiver, assets, shares); + } + + function maxWithdraw(address owner) external view returns (uint256) { + return convertToAssets(balanceOf[owner]); + } + + function previewWithdraw(uint256 assets) external view returns (uint256) { + uint256 chi_ = (block.timestamp > rho) ? _rpow(ssr, block.timestamp - rho) * chi / RAY : chi; + return _divup(assets * RAY, chi_); + } + + function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares) { + shares = _divup(assets * RAY, drip()); + _burn(assets, shares, receiver, owner); + } + + function maxRedeem(address owner) external view returns (uint256) { + return balanceOf[owner]; + } + + function previewRedeem(uint256 shares) external view returns (uint256) { + return convertToAssets(shares); + } + + function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets) { + assets = shares * drip() / RAY; + _burn(assets, shares, receiver, owner); + } + + // --- Approve by signature --- + + function _isValidSignature( + address signer, + bytes32 digest, + bytes memory signature + ) internal view returns (bool valid) { + if (signature.length == 65) { + bytes32 r; + bytes32 s; + uint8 v; + assembly { + r := mload(add(signature, 0x20)) + s := mload(add(signature, 0x40)) + v := byte(0, mload(add(signature, 0x60))) + } + if (signer == ecrecover(digest, v, r, s)) { + return true; + } + } + + if (signer.code.length > 0) { + (bool success, bytes memory result) = signer.staticcall( + abi.encodeCall(IERC1271.isValidSignature, (digest, signature)) + ); + valid = (success && + result.length == 32 && + abi.decode(result, (bytes4)) == IERC1271.isValidSignature.selector); + } + } + + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + bytes memory signature + ) public { + require(block.timestamp <= deadline, "SUsds/permit-expired"); + require(owner != address(0), "SUsds/invalid-owner"); + + uint256 nonce; + unchecked { nonce = nonces[owner]++; } + + bytes32 digest = + keccak256(abi.encodePacked( + "\x19\x01", + _calculateDomainSeparator(block.chainid), + keccak256(abi.encode( + PERMIT_TYPEHASH, + owner, + spender, + value, + nonce, + deadline + )) + )); + + require(_isValidSignature(owner, digest, signature), "SUsds/invalid-permit"); + + allowance[owner][spender] = value; + emit Approval(owner, spender, value); + } + + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external { + permit(owner, spender, value, deadline, abi.encodePacked(r, s, v)); + } +} + diff --git a/certora/mocks/Vat.sol b/certora/mocks/Vat.sol new file mode 100644 index 0000000..00e1ed6 --- /dev/null +++ b/certora/mocks/Vat.sol @@ -0,0 +1,271 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +/// vat.sol -- Dai CDP database + +// Copyright (C) 2018 Rain +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +pragma solidity >=0.5.12; + +contract Vat { + // --- Auth --- + mapping (address => uint) public wards; + function rely(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 1; } + function deny(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 0; } + modifier auth { + require(wards[msg.sender] == 1, "Vat/not-authorized"); + _; + } + + mapping(address => mapping (address => uint)) public can; + function hope(address usr) external note { can[msg.sender][usr] = 1; } + function nope(address usr) external note { can[msg.sender][usr] = 0; } + function wish(address bit, address usr) internal view returns (bool) { + return either(bit == usr, can[bit][usr] == 1); + } + + // --- Data --- + struct Ilk { + uint256 Art; // Total Normalised Debt [wad] + uint256 rate; // Accumulated Rates [ray] + uint256 spot; // Price with Safety Margin [ray] + uint256 line; // Debt Ceiling [rad] + uint256 dust; // Urn Debt Floor [rad] + } + struct Urn { + uint256 ink; // Locked Collateral [wad] + uint256 art; // Normalised Debt [wad] + } + + mapping (bytes32 => Ilk) public ilks; + mapping (bytes32 => mapping (address => Urn )) public urns; + mapping (bytes32 => mapping (address => uint)) public gem; // [wad] + mapping (address => uint256) public dai; // [rad] + mapping (address => uint256) public sin; // [rad] + + uint256 public debt; // Total Dai Issued [rad] + uint256 public vice; // Total Unbacked Dai [rad] + uint256 public Line; // Total Debt Ceiling [rad] + uint256 public live; // Active Flag + + // --- Logs --- + event LogNote( + bytes4 indexed sig, + bytes32 indexed arg1, + bytes32 indexed arg2, + bytes32 indexed arg3, + bytes data + ) anonymous; + + modifier note { + _; + assembly { + // log an 'anonymous' event with a constant 6 words of calldata + // and four indexed topics: the selector and the first three args + let mark := msize() // end of memory ensures zero + mstore(0x40, add(mark, 288)) // update free memory pointer + mstore(mark, 0x20) // bytes type data offset + mstore(add(mark, 0x20), 224) // bytes size (padded) + calldatacopy(add(mark, 0x40), 0, 224) // bytes payload + log4(mark, 288, // calldata + shl(224, shr(224, calldataload(0))), // msg.sig + calldataload(4), // arg1 + calldataload(36), // arg2 + calldataload(68) // arg3 + ) + } + } + + // --- Init --- + constructor() public { + wards[msg.sender] = 1; + live = 1; + } + + // --- Math --- + function add(uint x, int y) internal pure returns (uint z) { + z = x + uint(y); + require(y >= 0 || z <= x); + require(y <= 0 || z >= x); + } + function sub(uint x, int y) internal pure returns (uint z) { + z = x - uint(y); + require(y <= 0 || z <= x); + require(y >= 0 || z >= x); + } + function mul(uint x, int y) internal pure returns (int z) { + z = int(x) * y; + require(int(x) >= 0); + require(y == 0 || z / y == int(x)); + } + function add(uint x, uint y) internal pure returns (uint z) { + require((z = x + y) >= x); + } + function sub(uint x, uint y) internal pure returns (uint z) { + require((z = x - y) <= x); + } + function mul(uint x, uint y) internal pure returns (uint z) { + require(y == 0 || (z = x * y) / y == x); + } + + // --- Administration --- + function init(bytes32 ilk) external note auth { + require(ilks[ilk].rate == 0, "Vat/ilk-already-init"); + ilks[ilk].rate = 10 ** 27; + } + function file(bytes32 what, uint data) external note auth { + require(live == 1, "Vat/not-live"); + if (what == "Line") Line = data; + else revert("Vat/file-unrecognized-param"); + } + function file(bytes32 ilk, bytes32 what, uint data) external note auth { + require(live == 1, "Vat/not-live"); + if (what == "spot") ilks[ilk].spot = data; + else if (what == "line") ilks[ilk].line = data; + else if (what == "dust") ilks[ilk].dust = data; + else revert("Vat/file-unrecognized-param"); + } + function cage() external note auth { + live = 0; + } + + // --- Fungibility --- + function slip(bytes32 ilk, address usr, int256 wad) external note auth { + gem[ilk][usr] = add(gem[ilk][usr], wad); + } + function flux(bytes32 ilk, address src, address dst, uint256 wad) external note { + require(wish(src, msg.sender), "Vat/not-allowed"); + gem[ilk][src] = sub(gem[ilk][src], wad); + gem[ilk][dst] = add(gem[ilk][dst], wad); + } + function move(address src, address dst, uint256 rad) external note { + require(wish(src, msg.sender), "Vat/not-allowed"); + dai[src] = sub(dai[src], rad); + dai[dst] = add(dai[dst], rad); + } + + function either(bool x, bool y) internal pure returns (bool z) { + assembly{ z := or(x, y)} + } + function both(bool x, bool y) internal pure returns (bool z) { + assembly{ z := and(x, y)} + } + + // --- CDP Manipulation --- + function frob(bytes32 i, address u, address v, address w, int dink, int dart) external note { + // system is live + require(live == 1, "Vat/not-live"); + + Urn memory urn = urns[i][u]; + Ilk memory ilk = ilks[i]; + // ilk has been initialised + require(ilk.rate != 0, "Vat/ilk-not-init"); + + urn.ink = add(urn.ink, dink); + urn.art = add(urn.art, dart); + ilk.Art = add(ilk.Art, dart); + + int dtab = mul(ilk.rate, dart); + uint tab = mul(ilk.rate, urn.art); + debt = add(debt, dtab); + + // either debt has decreased, or debt ceilings are not exceeded + require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded"); + // urn is either less risky than before, or it is safe + require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe"); + + // urn is either more safe, or the owner consents + require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u"); + // collateral src consents + require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v"); + // debt dst consents + require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w"); + + // urn has no debt, or a non-dusty amount + require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust"); + + gem[i][v] = sub(gem[i][v], dink); + dai[w] = add(dai[w], dtab); + + urns[i][u] = urn; + ilks[i] = ilk; + } + // --- CDP Fungibility --- + function fork(bytes32 ilk, address src, address dst, int dink, int dart) external note { + Urn storage u = urns[ilk][src]; + Urn storage v = urns[ilk][dst]; + Ilk storage i = ilks[ilk]; + + u.ink = sub(u.ink, dink); + u.art = sub(u.art, dart); + v.ink = add(v.ink, dink); + v.art = add(v.art, dart); + + uint utab = mul(u.art, i.rate); + uint vtab = mul(v.art, i.rate); + + // both sides consent + require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed"); + + // both sides safe + require(utab <= mul(u.ink, i.spot), "Vat/not-safe-src"); + require(vtab <= mul(v.ink, i.spot), "Vat/not-safe-dst"); + + // both sides non-dusty + require(either(utab >= i.dust, u.art == 0), "Vat/dust-src"); + require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst"); + } + // --- CDP Confiscation --- + function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note auth { + Urn storage urn = urns[i][u]; + Ilk storage ilk = ilks[i]; + + urn.ink = add(urn.ink, dink); + urn.art = add(urn.art, dart); + ilk.Art = add(ilk.Art, dart); + + int dtab = mul(ilk.rate, dart); + + gem[i][v] = sub(gem[i][v], dink); + sin[w] = sub(sin[w], dtab); + vice = sub(vice, dtab); + } + + // --- Settlement --- + function heal(uint rad) external note { + address u = msg.sender; + sin[u] = sub(sin[u], rad); + dai[u] = sub(dai[u], rad); + vice = sub(vice, rad); + debt = sub(debt, rad); + } + function suck(address u, address v, uint rad) external note auth { + sin[u] = add(sin[u], rad); + dai[v] = add(dai[v], rad); + vice = add(vice, rad); + debt = add(debt, rad); + } + + // --- Rates --- + function fold(bytes32 i, address u, int rate) external note auth { + require(live == 1, "Vat/not-live"); + Ilk storage ilk = ilks[i]; + ilk.rate = add(ilk.rate, rate); + int rad = mul(ilk.Art, rate); + dai[u] = add(dai[u], rad); + debt = add(debt, rad); + } +} + From abd5b5e0c4376840cd1f0b494991e2b9881ed130 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 20 Mar 2025 17:02:42 -0300 Subject: [PATCH 79/96] feat: include additional rules and harness --- certora/DSPC.conf | 14 +++- certora/DSPC.spec | 124 +++++++++++++++++++++++++----- certora/harnesses/DSPCHarness.sol | 14 ++++ 3 files changed, 128 insertions(+), 24 deletions(-) create mode 100644 certora/harnesses/DSPCHarness.sol diff --git a/certora/DSPC.conf b/certora/DSPC.conf index 38038db..1da50fa 100644 --- a/certora/DSPC.conf +++ b/certora/DSPC.conf @@ -1,6 +1,7 @@ { "files": [ "src/DSPC.sol", + "certora/harnesses/DSPCHarness.sol", "certora/mocks/Conv.sol", "certora/mocks/ERC1967Proxy.sol", "certora/mocks/Jug.sol", @@ -13,6 +14,10 @@ "DSPC:pot=Pot", "DSPC:susds=ERC1967Proxy", "DSPC:conv=Conv", + "DSPCHarness:jug=Jug", + "DSPCHarness:pot=Pot", + "DSPCHarness:susds=ERC1967Proxy", + "DSPCHarness:conv=Conv", "ERC1967Proxy:0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc=SUsds", "Jug:vat=Vat", "Pot:vat=Vat" @@ -21,6 +26,7 @@ "solc_map": { "Conv": "solc-0.8.24", "DSPC": "solc-0.8.24", + "DSPCHarness": "solc-0.8.24", "ERC1967Proxy": "solc-0.8.21", "Jug": "solc-0.5.12", "Pot": "solc-0.5.12", @@ -30,17 +36,19 @@ "solc_optimize_map": { "Conv": "200", "DSPC": "200", + "DSPCHarness": "200", "ERC1967Proxy": "200", "Jug": "0", "Pot": "0", "SUsds": "200", "Vat": "0" }, - "verify": "DSPC:certora/DSPC.spec", + "verify": "DSPCHarness:certora/DSPC.spec", "parametric_contracts": [ - "DSPC" + "DSPCHarness" ], - "loop_iter": 20, + "loop_iter": "3", + "optimistic_loop": true, "multi_assert_check": true, "wait_for_results": "all" } diff --git a/certora/DSPC.spec b/certora/DSPC.spec index e5f5f81..633e354 100644 --- a/certora/DSPC.spec +++ b/certora/DSPC.spec @@ -8,15 +8,17 @@ using SUsds as susdsImp; using Vat as vat; methods { - function wards(address) external returns (uint256) envfree; + function RAY() external returns (uint256) envfree; + function bad() external returns (uint8) envfree; function buds(address) external returns (uint256) envfree; function cfgs(bytes32) external returns (uint16, uint16, uint16) envfree; - function bad() external returns (uint8) envfree; function tau() external returns (uint64) envfree; function toc() external returns (uint128) envfree; + function wards(address) external returns (uint256) envfree; function conv.rtob(uint256) external returns (uint256) envfree; function conv.btor(uint256) external returns (uint256) envfree; + function conv.MAX_BPS_IN() external returns (uint256) envfree; function jug.ilks(bytes32) external returns (uint256, uint256) envfree; @@ -43,7 +45,7 @@ definition SSR() returns bytes32 = to_bytes32(0x53535200000000000000000000000000 definition DSR() returns bytes32 = to_bytes32(0x4453520000000000000000000000000000000000000000000000000000000000); // Verify that each storage variable is only modified in the expected functions -rule storageAffected(method f) { +rule storage_affected(method f) { env e; address anyAddr; bytes32 anyId; @@ -67,14 +69,15 @@ rule storageAffected(method f) { mathint tauAfter = tau(); mathint tocAfter = toc(); + assert wardsAfter != wardsBefore => f.selector == sig:rely(address).selector || f.selector == sig:deny(address).selector, "wards[x] changed in an unexpected function"; assert budsAfter != budsBefore => f.selector == sig:kiss(address).selector || f.selector == sig:diss(address).selector, "buds[x] changed in an unexpected function"; assert minAfter != minBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "min[x] changed in an unexpected function"; assert maxAfter != maxBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "max[x] changed in an unexpected function"; assert stepAfter != stepBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "step[x] changed in an unexpected function"; assert badAfter != badBefore => f.selector == sig:file(bytes32, uint256).selector, "bad[x] changed in an unexpected function"; - assert tauAfter != tauBefore => f.selector == sig:file(bytes32, uint256).selector, "tau[x] changed in an unexpected function"; - assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(DSPC.ParamChange[] calldata).selector, "toc[x] changed in an unexpected function"; + assert tauAfter != tauBefore => f.selector == sig:file(bytes32, uint256).selector, "tau changed in an unexpected function"; + assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(bytes32, uint256).selector, "toc changed in an unexpected function"; } // Verify that the correct storage changes for non-reverting rely @@ -101,10 +104,11 @@ rule rely_revert(address usr) { mathint wardsSender = wards(e.msg.sender); - rely@withrevert(e, usr); - bool revert1 = e.msg.value > 0; bool revert2 = wardsSender != 1; + + rely@withrevert(e, usr); + assert lastReverted <=> revert1 || revert2, "rely revert rules failed"; } @@ -132,10 +136,11 @@ rule deny_revert(address usr) { mathint wardsSender = wards(e.msg.sender); - deny@withrevert(e, usr); - bool revert1 = e.msg.value > 0; bool revert2 = wardsSender != 1; + + deny@withrevert(e, usr); + assert lastReverted <=> revert1 || revert2, "deny revert rules failed"; } @@ -163,11 +168,11 @@ rule kiss_revert(address usr) { mathint wardsSender = wards(e.msg.sender); - kiss@withrevert(e, usr); - bool revert1 = e.msg.value > 0; bool revert2 = wardsSender != 1; + kiss@withrevert(e, usr); + assert lastReverted <=> revert1 || revert2, "kiss revert rules failed"; } @@ -231,8 +236,6 @@ rule file_global_revert(bytes32 what, uint256 data) { mathint wardsSender = wards(e.msg.sender); - file@withrevert(e, what, data); - bool revert1 = e.msg.value > 0; bool revert2 = wardsSender != 1; bool revert3 = what != BAD() && what != TAU() && what != TOC(); @@ -240,6 +243,8 @@ rule file_global_revert(bytes32 what, uint256 data) { bool revert5 = what == TAU() && to_mathint(data) > max_uint64; bool revert6 = what == TOC() && to_mathint(data) > max_uint128; + file@withrevert(e, what, data); + assert lastReverted <=> revert1 || revert2 || revert3 || revert4 || revert5 || revert6, "file revert rules failed"; @@ -275,20 +280,97 @@ rule file_per_id_revert(bytes32 id, bytes32 what, uint256 data) { mathint duty; mathint _rate; duty, _rate = jug.ilks(id); - file@withrevert(e, id, what, data); - bool revert1 = e.msg.value > 0; bool revert2 = wardsSender != 1; bool revert3 = id != DSR() && id != SSR() && duty == 0; bool revert4 = what != MIN() && what != MAX() && what != STEP(); - bool revert5 = what == MIN() && to_mathint(data) > max_uint16; - bool revert6 = what == MAX() && to_mathint(data) > max_uint16; - bool revert7 = what == STEP() && to_mathint(data) > max_uint16; - bool revert8 = what == MIN() && to_mathint(data) > maxBefore; - bool revert9 = what == MAX() && to_mathint(data) < minBefore; + bool revert5 = to_mathint(data) > max_uint16; + bool revert6 = what == MIN() && to_mathint(data) > maxBefore; + bool revert7 = what == MAX() && to_mathint(data) < minBefore; + + file@withrevert(e, id, what, data); assert lastReverted <=> revert1 || revert2 || revert3 || revert4 || revert5 || revert6 || - revert7 || revert8 || revert9, + revert7, "file revert rules failed"; } + +// Verify correct storage changes for non-reverting set for a single rate. +rule set_single(bytes32 id, uint256 bps) { + env e; + bytes32 ilk; + require ilk != DSR() && ilk != SSR(); + + mathint ray = conv.btor(bps); + + mathint dsrBefore = pot.dsr(); + mathint ssrBefore = susdsImp.ssr(); + mathint dutyBefore; mathint _rho; + dutyBefore, _rho = jug.ilks(ilk); + + set(e, id, bps); + + mathint dsrAfter = pot.dsr(); + mathint ssrAfter = susdsImp.ssr(); + mathint dutyAfter; + dutyAfter, _rho = jug.ilks(ilk); + + assert id == DSR() => dsrAfter == ray, "set did not set dsr"; + assert id != DSR() => dsrAfter == dsrBefore, "set did keep unchanged dsr"; + + assert id == SSR() => ssrAfter == ray, "set did not set ssr"; + assert id != SSR() => ssrAfter == ssrBefore, "set did keep unchanged ssr"; + + assert id == ilk => dutyAfter == ray, "set did not set duty"; + assert id != ilk => dutyAfter == dutyBefore, "set did keep unchanged duty"; +} + +// Verify revert rules for set for a single rate +rule set_single_revert(bytes32 id, uint256 bps) { + env e; + + mathint tau = tau(); + mathint toc = toc(); + mathint min; mathint max; mathint step; + min, max, step = cfgs(id); + + mathint oldBps; + if (id == DSR()) { + oldBps = conv.rtob(pot.dsr()); + } else if (id == SSR()) { + oldBps = conv.rtob(susdsImp.ssr()); + } else { + uint256 duty; mathint _rate; + duty, _rate = jug.ilks(id); + oldBps = conv.rtob(duty); + } + + // We need a second variable because it's not possible to reassign variables in CVL + mathint actualOldBps; + if (oldBps < min) { + actualOldBps = min; + } else if (oldBps > max) { + actualOldBps = max; + } else { + actualOldBps = oldBps; + } + + mathint delta = bps > actualOldBps ? bps - actualOldBps : actualOldBps - bps; + mathint ray = conv.btor(bps); + + bool revert1 = e.msg.value > 0; + bool revert2 = e.block.timestamp < tau + toc; + bool revert3 = step == 0; + bool revert4 = to_mathint(bps) > max; + bool revert5 = to_mathint(bps) < min; + bool revert6 = delta > step; + bool revert7 = ray < RAY(); + + set@withrevert(e, id, bps); + + assert lastReverted <=> revert1 || revert2 || revert3 || + revert4 || revert5 || revert6 || + revert7, + "set revert rules failed"; +} diff --git a/certora/harnesses/DSPCHarness.sol b/certora/harnesses/DSPCHarness.sol new file mode 100644 index 0000000..d2e2bba --- /dev/null +++ b/certora/harnesses/DSPCHarness.sol @@ -0,0 +1,14 @@ +pragma solidity ^0.8.24; + +import {DSPC} from "src/DSPC.sol"; + +contract DSPCHarness is DSPC { + constructor(address _jug, address _pot, address _susds, address _conv) DSPC(_jug, _pot, _susds, _conv) {} + + function set(bytes32 id, uint256 bps) external { + DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); + updates[0].id = id; + updates[0].bps = bps; + this.set(updates); + } +} From 7bcf21559efe74320abbfce2af1af8e668ae477d Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 27 Mar 2025 15:57:57 -0300 Subject: [PATCH 80/96] WIP: checkpoint for rules implementation --- .gitattributes | 3 + certora/DSPC.conf | 41 +- certora/DSPC.spec | 237 +- certora/harnesses/DSPCHarness.sol | 49 +- certora/mocks/Conv.sol | 51 +- certora/mocks/ERC1967Proxy.sol | 608 - certora/mocks/Jug.sol | 15 +- certora/mocks/Pot.sol | 16 +- certora/mocks/SUsds.sol | 20 +- certora/mocks/Usds.sol | 79 + certora/mocks/UsdsJoin.sol | 44 + certora/mocks/Vat.sol | 26 +- src/mocks/ConvMock.sol | 20104 +++++++++++++++++++++++++++- 13 files changed, 20428 insertions(+), 865 deletions(-) create mode 100644 .gitattributes delete mode 100644 certora/mocks/ERC1967Proxy.sol create mode 100644 certora/mocks/Usds.sol create mode 100644 certora/mocks/UsdsJoin.sol diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..2cfc1d2 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +*.spec linguist-language=Solidity +*.conf linguist-detectable +*.conf linguist-language=JSON5 diff --git a/certora/DSPC.conf b/certora/DSPC.conf index 1da50fa..210a83f 100644 --- a/certora/DSPC.conf +++ b/certora/DSPC.conf @@ -1,54 +1,57 @@ { "files": [ "src/DSPC.sol", - "certora/harnesses/DSPCHarness.sol", "certora/mocks/Conv.sol", - "certora/mocks/ERC1967Proxy.sol", "certora/mocks/Jug.sol", "certora/mocks/Pot.sol", "certora/mocks/SUsds.sol", + "certora/mocks/Usds.sol", + "certora/mocks/UsdsJoin.sol", "certora/mocks/Vat.sol" ], "link": [ + "Jug:vat=Vat", + "Pot:vat=Vat", + "SUsds:vat=Vat", + "UsdsJoin:usds=Usds", + "UsdsJoin:vat=Vat", "DSPC:jug=Jug", "DSPC:pot=Pot", - "DSPC:susds=ERC1967Proxy", - "DSPC:conv=Conv", - "DSPCHarness:jug=Jug", - "DSPCHarness:pot=Pot", - "DSPCHarness:susds=ERC1967Proxy", - "DSPCHarness:conv=Conv", - "ERC1967Proxy:0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc=SUsds", - "Jug:vat=Vat", - "Pot:vat=Vat" + "DSPC:susds=SUsds", + "DSPC:conv=Conv" ], - "rule_sanity": "basic", "solc_map": { "Conv": "solc-0.8.24", "DSPC": "solc-0.8.24", - "DSPCHarness": "solc-0.8.24", - "ERC1967Proxy": "solc-0.8.21", "Jug": "solc-0.5.12", "Pot": "solc-0.5.12", "SUsds": "solc-0.8.21", + "Usds": "solc-0.8.21", + "UsdsJoin": "solc-0.8.21", "Vat": "solc-0.5.12" }, "solc_optimize_map": { "Conv": "200", "DSPC": "200", - "DSPCHarness": "200", - "ERC1967Proxy": "200", "Jug": "0", "Pot": "0", "SUsds": "200", + "Usds": "200", + "UsdsJoin": "200", "Vat": "0" }, - "verify": "DSPCHarness:certora/DSPC.spec", + "verify": "DSPC:certora/DSPC.spec", "parametric_contracts": [ - "DSPCHarness" + "DSPC" ], + "build_cache": true, "loop_iter": "3", - "optimistic_loop": true, "multi_assert_check": true, + "optimistic_loop": true, + "process": "emv", + "prover_args": [ + " -rewriteMSizeAllocations true" + ], + "rule_sanity": "basic", "wait_for_results": "all" } diff --git a/certora/DSPC.spec b/certora/DSPC.spec index 633e354..d03b672 100644 --- a/certora/DSPC.spec +++ b/certora/DSPC.spec @@ -1,10 +1,10 @@ // DSPC.spec +using DSPC as dspc; using Conv as conv; using Jug as jug; using Pot as pot; -using ERC1967Proxy as susds; -using SUsds as susdsImp; +using SUsds as susds; using Vat as vat; methods { @@ -21,20 +21,31 @@ methods { function conv.MAX_BPS_IN() external returns (uint256) envfree; function jug.ilks(bytes32) external returns (uint256, uint256) envfree; + function jug.wards(address) external returns (uint256) envfree; function pot.dsr() external returns (uint256) envfree; + function pot.rho() external returns (uint256) envfree; + function pot.wards(address) external returns (uint256) envfree; - function susdsImp.ssr() external returns (uint256) envfree; + function susds.ssr() external returns (uint256) envfree; + function susds.rho() external returns (uint64) envfree; + function susds.wards(address) external returns (uint256) envfree; - function vat.live() external returns (uint256) envfree; + function vat.Line() external returns (uint256) envfree; function vat.can(address, address) external returns (uint256) envfree; function vat.dai(address) external returns (uint256) envfree; function vat.debt() external returns (uint256) envfree; - function vat.Line() external returns (uint256) envfree; function vat.ilks(bytes32) external returns (uint256, uint256, uint256, uint256, uint256) envfree; + function vat.live() external returns (uint256) envfree; function vat.urns(bytes32, address) external returns (uint256, uint256) envfree; + + function _.ilks(bytes32) external => DISPATCHER(true); + function _.suck(address, address, uint256) external => DISPATCHER(true); + function _.fold(bytes32, address, int256) external => DISPATCHER(true); + function _.exit(address, uint256) external => DISPATCHER(true); } +definition EMPTY_BYTES32() returns bytes32 = to_bytes32(0x0000000000000000000000000000000000000000000000000000000000000000); definition TAU() returns bytes32 = to_bytes32(0x7461750000000000000000000000000000000000000000000000000000000000); definition TOC() returns bytes32 = to_bytes32(0x746f630000000000000000000000000000000000000000000000000000000000); definition BAD() returns bytes32 = to_bytes32(0x6261640000000000000000000000000000000000000000000000000000000000); @@ -75,9 +86,9 @@ rule storage_affected(method f) { assert minAfter != minBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "min[x] changed in an unexpected function"; assert maxAfter != maxBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "max[x] changed in an unexpected function"; assert stepAfter != stepBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "step[x] changed in an unexpected function"; - assert badAfter != badBefore => f.selector == sig:file(bytes32, uint256).selector, "bad[x] changed in an unexpected function"; + assert badAfter != badBefore => f.selector == sig:file(bytes32, uint256).selector, "bad changed in an unexpected function"; assert tauAfter != tauBefore => f.selector == sig:file(bytes32, uint256).selector, "tau changed in an unexpected function"; - assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(bytes32, uint256).selector, "toc changed in an unexpected function"; + assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(DSPC.ParamChange[] calldata).selector, "toc changed in an unexpected function"; } // Verify that the correct storage changes for non-reverting rely @@ -245,9 +256,10 @@ rule file_global_revert(bytes32 what, uint256 data) { file@withrevert(e, what, data); - assert lastReverted <=> revert1 || revert2 || revert3 || - revert4 || revert5 || revert6, - "file revert rules failed"; + assert lastReverted <=> + revert1 || revert2 || revert3 || + revert4 || revert5 || revert6, + "file revert rules failed"; } // Verify correct storage changes for non-reverting file for individual rate parameters @@ -277,8 +289,8 @@ rule file_per_id_revert(bytes32 id, bytes32 what, uint256 data) { mathint wardsSender = wards(e.msg.sender); mathint minBefore; mathint maxBefore; mathint stepBefore; minBefore, maxBefore, stepBefore = cfgs(id); - mathint duty; mathint _rate; - duty, _rate = jug.ilks(id); + mathint duty; mathint _rho; + duty, _rho = jug.ilks(id); bool revert1 = e.msg.value > 0; bool revert2 = wardsSender != 1; @@ -290,59 +302,183 @@ rule file_per_id_revert(bytes32 id, bytes32 what, uint256 data) { file@withrevert(e, id, what, data); - assert lastReverted <=> revert1 || revert2 || revert3 || - revert4 || revert5 || revert6 || - revert7, - "file revert rules failed"; + assert lastReverted <=> + revert1 || revert2 || revert3 || + revert4 || revert5 || revert6 || + revert7, + "file revert rules failed"; +} + +ghost mapping(uint256 => uint256) bps_to_ray { + init_state axiom forall uint256 i. bps_to_ray[i] == 0; } -// Verify correct storage changes for non-reverting set for a single rate. -rule set_single(bytes32 id, uint256 bps) { +// Verify correct storage changes for non-reverting set +rule set(DSPC.ParamChange[] updates) { env e; bytes32 ilk; require ilk != DSR() && ilk != SSR(); - - mathint ray = conv.btor(bps); + require updates.length > 0 && updates.length < 4; mathint dsrBefore = pot.dsr(); - mathint ssrBefore = susdsImp.ssr(); + mathint ssrBefore = susds.ssr(); mathint dutyBefore; mathint _rho; dutyBefore, _rho = jug.ilks(ilk); - set(e, id, bps); + set(e, updates); mathint dsrAfter = pot.dsr(); - mathint ssrAfter = susdsImp.ssr(); + mathint ssrAfter = susds.ssr(); mathint dutyAfter; dutyAfter, _rho = jug.ilks(ilk); - assert id == DSR() => dsrAfter == ray, "set did not set dsr"; - assert id != DSR() => dsrAfter == dsrBefore, "set did keep unchanged dsr"; + // Manually convert all BPS values to RAY after the function call + // Store in the ghost mapping for use in the assertions + if (updates.length > 0) { + bps_to_ray[updates[0].bps] = conv.btor(updates[0].bps); + } + if (updates.length > 1) { + bps_to_ray[updates[1].bps] = conv.btor(updates[1].bps); + } + if (updates.length > 2) { + bps_to_ray[updates[2].bps] = conv.btor(updates[2].bps); + } - assert id == SSR() => ssrAfter == ray, "set did not set ssr"; - assert id != SSR() => ssrAfter == ssrBefore, "set did keep unchanged ssr"; + // If DSR is in updates, then its value should match the converted input value + assert exists uint256 i. i < updates.length => updates[i].id == DSR() => + dsrAfter == to_mathint(bps_to_ray[updates[i].bps]), "DSR in updates; dsr not set correctly"; + // If DSR is not in updates, then the value should not change + assert (forall uint256 i. i < updates.length => updates[i].id != DSR()) => + dsrAfter == dsrBefore, "DSR not in updates; dsr changed unexpectedly"; + // If the value of DSR changed, then it should be in updates + assert dsrAfter != dsrBefore => + (exists uint256 i. i < updates.length => updates[i].id == DSR()), "dsr changed; DSR not in updates"; + // If the value of DSR did not change, then it should either NOT be in updates or be in updates with the same value + assert dsrAfter == dsrBefore => ( + (forall uint256 i. i < updates.length => updates[i].id != DSR()) || + (exists uint256 i. i < updates.length => (updates[i].id == DSR() && to_mathint(bps_to_ray[updates[i].bps]) == dsrBefore)) + ), "dsr not changed; DSR in updates with different value"; + + + // If SSR is in updates, then its value should match the converted input value + assert exists uint256 i. i < updates.length => updates[i].id == SSR() => + ssrAfter == to_mathint(bps_to_ray[updates[i].bps]), "SSR in updates; ssr not set correctly"; + // If SSR is not in updates, then the value should not change + assert (forall uint256 i. i < updates.length => updates[i].id != SSR()) => + ssrAfter == ssrBefore, "SSR not in updates; ssr changed unexpectedly"; + // If the value of SSR changed, then it should be in updates + assert ssrAfter != ssrBefore => ( + exists uint256 i. i < updates.length => updates[i].id == SSR() + ), "ssr changed; SSR not in updates"; + // If the value of SSR did not change, then it should either NOT be in updates or be in updates with the same value + assert ssrAfter == ssrBefore => ( + (forall uint256 i. i < updates.length => updates[i].id != SSR()) || + (exists uint256 i. i < updates.length => (updates[i].id == SSR() && to_mathint(bps_to_ray[updates[i].bps]) == ssrBefore)) + ), "ssr not changed; SSR in updates with different value"; + + + // If ilk is in updates, then its duty value should match the converted input value + assert exists uint256 i. i < updates.length => updates[i].id == ilk => + dutyAfter == to_mathint(bps_to_ray[updates[i].bps]), "ilk in updates; duty not set correctly"; + // If ilk is not in updates, then the value should not change + assert (forall uint256 i. i < updates.length => updates[i].id != ilk) => + dutyAfter == dutyBefore, "ilk not in updates; duty changed unexpectedly"; + // If the value of ilk duty changed, then it should be in updates + assert dutyAfter != dutyBefore => + (exists uint256 i. i < updates.length => updates[i].id == ilk), "duty changed; ilk not in updates"; + // If the value of ilk duty did not change, then it should either NOT be in updates or be in updates with the same value + assert dutyAfter == dutyBefore => ( + (forall uint256 i. i < updates.length => updates[i].id != ilk) || + (exists uint256 i. i < updates.length => (updates[i].id == ilk && to_mathint(bps_to_ray[updates[i].bps]) == dutyBefore)) + ), "duty not changed; ilk in updates with different value"; +} - assert id == ilk => dutyAfter == ray, "set did not set duty"; - assert id != ilk => dutyAfter == dutyBefore, "set did keep unchanged duty"; +ghost mapping(bytes32 => bool) set_item_reverted { + init_state axiom forall bytes32 i. set_item_reverted[i] == false; } -// Verify revert rules for set for a single rate -rule set_single_revert(bytes32 id, uint256 bps) { +rule set_revert(DSPC.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss) { env e; + bytes32 ilk; - mathint tau = tau(); - mathint toc = toc(); + require ilk != DSR() && ilk != SSR(); + require updates.length < 4; + require updates.length == bpss.length; + require idsAsUints.length == bpss.length; + // ID cannot be bytes32(0) + require forall uint256 i. i < updates.length => ( + updates[i].id != EMPTY_BYTES32() && + updates[i].id == to_bytes32(idsAsUints[i]) && + updates[i].bps == to_mathint(bpss[i]) + ); + // It is impossible for `toc` to be greater than block.timestamp + require toc() <= e.block.timestamp; + // Required because `toc` is a `uint128` and `toc = block.timestamp` in the implementation + require e.block.timestamp <= max_uint128; + + bool revert1 = e.msg.value > 0; + bool revert2 = buds(e.msg.sender) != 1; + bool revert3 = bad() != 0; + bool revert4 = e.block.timestamp < tau() + toc(); + // No updates + bool revert5 = updates.length == 0; + // Sorted elements + bool revert6 = idsAsUints.length == 2 ? idsAsUints[0] >= idsAsUints[1] : false; + bool revert7 = idsAsUints.length == 3 ? ( + idsAsUints[0] >= idsAsUints[1] || + idsAsUints[0] >= idsAsUints[2] || + idsAsUints[1] >= idsAsUints[2] + ) : false; + + if (updates.length > 0) { + set_item_reverted[updates[0].id] = check_item_revert(e, updates[0].id, updates[0].bps); + } + if (updates.length > 1) { + set_item_reverted[updates[1].id] = check_item_revert(e, updates[1].id, updates[1].bps); + } + if (updates.length > 2) { + set_item_reverted[updates[2].id] = check_item_revert(e, updates[2].id, updates[2].bps); + } + + bool revert8 = exists uint256 i. i < updates.length => set_item_reverted[updates[i].id] == true; + + set@withrevert(e, updates); + + assert lastReverted => + revert1 || revert2 || revert3 || + revert4 || revert5 || revert6 || + revert7 || revert8, + "set reverted due to unknown reason"; + + assert + revert1 || revert2 || revert3 || + revert4 || revert5 || revert6 || + revert7 || revert8 => + lastReverted, + "set did not revert when expected"; +} + +function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { mathint min; mathint max; mathint step; min, max, step = cfgs(id); + // min <= max is enforced in the implementation + require min <= max; + mathint oldBps; if (id == DSR()) { + // IF block.timestamp < rho, drip will revert + require(e.block.timestamp >= pot.rho()); oldBps = conv.rtob(pot.dsr()); } else if (id == SSR()) { - oldBps = conv.rtob(susdsImp.ssr()); + // IF block.timestamp <= rho, drip will not update rho and file will revert + require(e.block.timestamp > pot.rho()); + oldBps = conv.rtob(susds.ssr()); } else { - uint256 duty; mathint _rate; - duty, _rate = jug.ilks(id); + uint256 duty; mathint rho; + duty, rho = jug.ilks(id); + // IF rho >= block.timestamp, drip will revert + require(e.block.timestamp >= rho); oldBps = conv.rtob(duty); } @@ -359,18 +495,19 @@ rule set_single_revert(bytes32 id, uint256 bps) { mathint delta = bps > actualOldBps ? bps - actualOldBps : actualOldBps - bps; mathint ray = conv.btor(bps); - bool revert1 = e.msg.value > 0; - bool revert2 = e.block.timestamp < tau + toc; - bool revert3 = step == 0; - bool revert4 = to_mathint(bps) > max; - bool revert5 = to_mathint(bps) < min; - bool revert6 = delta > step; - bool revert7 = ray < RAY(); - - set@withrevert(e, id, bps); - - assert lastReverted <=> revert1 || revert2 || revert3 || - revert4 || revert5 || revert6 || - revert7, - "set revert rules failed"; + bool revertA = step == 0; + bool revertB = to_mathint(bps) > max; + bool revertC = to_mathint(bps) < min; + bool revertD = delta > step; + bool revertE = ray < RAY(); + bool revertF = bps > conv.MAX_BPS_IN(); + bool revertG = id == DSR() && pot.wards(currentContract) != 1; + bool revertH = id == SSR() && susds.wards(currentContract) != 1; + bool revertI = id != DSR() && id != SSR() && jug.wards(currentContract) != 1; + + return + revertA || revertB || revertC || + revertD || revertE || revertF || + revertG || revertH || revertI; + } diff --git a/certora/harnesses/DSPCHarness.sol b/certora/harnesses/DSPCHarness.sol index d2e2bba..3ffd480 100644 --- a/certora/harnesses/DSPCHarness.sol +++ b/certora/harnesses/DSPCHarness.sol @@ -1,14 +1,51 @@ pragma solidity ^0.8.24; -import {DSPC} from "src/DSPC.sol"; +import "src/DSPC.sol"; contract DSPCHarness is DSPC { constructor(address _jug, address _pot, address _susds, address _conv) DSPC(_jug, _pot, _susds, _conv) {} - function set(bytes32 id, uint256 bps) external { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0].id = id; - updates[0].bps = bps; - this.set(updates); + function set(bytes32 id, uint256 bps) external toll good { + Cfg memory cfg = cfgs[id]; + + require(cfg.step > 0, "DSPC/rate-not-configured"); + require(bps >= cfg.min, "DSPC/below-min"); + require(bps <= cfg.max, "DSPC/above-max"); + + // Check rate change is within allowed gap + uint256 oldBps; + if (id == "DSR") { + oldBps = conv.rtob(PotLike(pot).dsr()); + } else if (id == "SSR") { + oldBps = conv.rtob(SUSDSLike(susds).ssr()); + } else { + (uint256 duty,) = JugLike(jug).ilks(id); + oldBps = conv.rtob(duty); + } + + if (oldBps < cfg.min) { + oldBps = cfg.min; + } else if (oldBps > cfg.max) { + oldBps = cfg.max; + } + + // Calculates absolute difference between the old and the new rate + uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; + require(delta <= cfg.step, "DSPC/delta-above-step"); + + // Execute the update + uint256 ray = conv.btor(bps); + require(ray >= RAY, "DSPC/invalid-rate-conv"); + if (id == "DSR") { + pot.drip(); + pot.file("dsr", ray); + } else if (id == "SSR") { + susds.drip(); + susds.file("ssr", ray); + } else { + jug.drip(id); + jug.file(id, "duty", ray); + } + emit Set(id, bps); } } diff --git a/certora/mocks/Conv.sol b/certora/mocks/Conv.sol index c3645d6..6b31edc 100644 --- a/certora/mocks/Conv.sol +++ b/certora/mocks/Conv.sol @@ -6,61 +6,18 @@ contract Conv { uint256 internal constant RAY = 10 ** 27; uint256 internal constant BPS = 100_00; - bytes internal RATES = - hex"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"; - function btor(uint256 bps) external view returns (uint256 ray) { require(bps <= MAX_BPS_IN, "Conv/bps-too-high"); - uint256 offset = bps * 8; // Each rate is 8 bytes - (uint256 wordPos, uint256 bytePos) = (offset / 32, offset % 32); - - bytes32 value; - assembly { - let dataSlot := keccak256(RATES.slot, 0x20) - value := sload(add(dataSlot, wordPos)) - } - - uint256 shifted = uint256(value) >> ((24 - bytePos) * 8); - ray = (shifted & 0xFFFFFFFFFFFFFFFF) + RAY; + // Deliberately wrong implementation + return (bps * RAY + BPS / 2) / BPS / 365 days + RAY; } function rtob(uint256 ray) external pure returns (uint256 bps) { require(ray >= RAY, "Conv/ray-too-low"); - uint256 yearlyRate = _rpow(ray, 365 days); - return ((yearlyRate - RAY) * BPS + RAY / 2) / RAY; - } - - function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { - assembly { - switch x - case 0 { - switch n - case 0 { z := RAY } - default { z := 0 } - } - default { - switch mod(n, 2) - case 0 { z := RAY } - default { z := x } - let half := div(RAY, 2) // for rounding. - for { n := div(n, 2) } n { n := div(n, 2) } { - let xx := mul(x, x) - if iszero(eq(div(xx, x), x)) { revert(0, 0) } - let xxRound := add(xx, half) - if lt(xxRound, xx) { revert(0, 0) } - x := div(xxRound, RAY) - if mod(n, 2) { - let zx := mul(z, x) - if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } - let zxRound := add(zx, half) - if lt(zxRound, zx) { revert(0, 0) } - z := div(zxRound, RAY) - } - } - } - } + // Deliberately wrong implementation + return ((ray - RAY) * BPS * 365 days + RAY/2) / RAY; } } diff --git a/certora/mocks/ERC1967Proxy.sol b/certora/mocks/ERC1967Proxy.sol deleted file mode 100644 index 3d5c2c9..0000000 --- a/certora/mocks/ERC1967Proxy.sol +++ /dev/null @@ -1,608 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.20; - -// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol - -// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Proxy.sol) - -/** - * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM - * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to - * be specified by overriding the virtual {_implementation} function. - * - * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a - * different contract through the {_delegate} function. - * - * The success and return data of the delegated call will be returned back to the caller of the proxy. - */ -abstract contract Proxy { - /** - * @dev Delegates the current call to `implementation`. - * - * This function does not return to its internal call site, it will return directly to the external caller. - */ - function _delegate(address implementation) internal virtual { - assembly { - // Copy msg.data. We take full control of memory in this inline assembly - // block because it will not return to Solidity code. We overwrite the - // Solidity scratch pad at memory position 0. - calldatacopy(0, 0, calldatasize()) - - // Call the implementation. - // out and outsize are 0 because we don't know the size yet. - let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) - - // Copy the returned data. - returndatacopy(0, 0, returndatasize()) - - switch result - // delegatecall returns 0 on error. - case 0 { - revert(0, returndatasize()) - } - default { - return(0, returndatasize()) - } - } - } - - /** - * @dev This is a virtual function that should be overridden so it returns the address to which the fallback - * function and {_fallback} should delegate. - */ - function _implementation() internal view virtual returns (address); - - /** - * @dev Delegates the current call to the address returned by `_implementation()`. - * - * This function does not return to its internal call site, it will return directly to the external caller. - */ - function _fallback() internal virtual { - _delegate(_implementation()); - } - - /** - * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other - * function in the contract matches the call data. - */ - fallback() external payable virtual { - _fallback(); - } -} - -// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol - -// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol) - -/** - * @dev This is the interface that {BeaconProxy} expects of its beacon. - */ -interface IBeacon { - /** - * @dev Must return an address that can be used as a delegate call target. - * - * {UpgradeableBeacon} will check that this address is a contract. - */ - function implementation() external view returns (address); -} - -// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol - -// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) - -/** - * @dev Collection of functions related to the address type - */ -library Address { - /** - * @dev The ETH balance of the account is not enough to perform the operation. - */ - error AddressInsufficientBalance(address account); - - /** - * @dev There's no code at `target` (it is not a contract). - */ - error AddressEmptyCode(address target); - - /** - * @dev A call to an address target failed. The target may have reverted. - */ - error FailedInnerCall(); - - /** - * @dev Replacement for Solidity's `transfer`: sends `amount` wei to - * `recipient`, forwarding all available gas and reverting on errors. - * - * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost - * of certain opcodes, possibly making contracts go over the 2300 gas limit - * imposed by `transfer`, making them unable to receive funds via - * `transfer`. {sendValue} removes this limitation. - * - * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. - * - * IMPORTANT: because control is transferred to `recipient`, care must be - * taken to not create reentrancy vulnerabilities. Consider using - * {ReentrancyGuard} or the - * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. - */ - function sendValue(address payable recipient, uint256 amount) internal { - if (address(this).balance < amount) { - revert AddressInsufficientBalance(address(this)); - } - - (bool success, ) = recipient.call{value: amount}(""); - if (!success) { - revert FailedInnerCall(); - } - } - - /** - * @dev Performs a Solidity function call using a low level `call`. A - * plain `call` is an unsafe replacement for a function call: use this - * function instead. - * - * If `target` reverts with a revert reason or custom error, it is bubbled - * up by this function (like regular Solidity function calls). However, if - * the call reverted with no returned reason, this function reverts with a - * {FailedInnerCall} error. - * - * Returns the raw returned data. To convert to the expected return value, - * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. - * - * Requirements: - * - * - `target` must be a contract. - * - calling `target` with `data` must not revert. - */ - function functionCall(address target, bytes memory data) internal returns (bytes memory) { - return functionCallWithValue(target, data, 0); - } - - /** - * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], - * but also transferring `value` wei to `target`. - * - * Requirements: - * - * - the calling contract must have an ETH balance of at least `value`. - * - the called Solidity function must be `payable`. - */ - function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { - if (address(this).balance < value) { - revert AddressInsufficientBalance(address(this)); - } - (bool success, bytes memory returndata) = target.call{value: value}(data); - return verifyCallResultFromTarget(target, success, returndata); - } - - /** - * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], - * but performing a static call. - */ - function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { - (bool success, bytes memory returndata) = target.staticcall(data); - return verifyCallResultFromTarget(target, success, returndata); - } - - /** - * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], - * but performing a delegate call. - */ - function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { - (bool success, bytes memory returndata) = target.delegatecall(data); - return verifyCallResultFromTarget(target, success, returndata); - } - - /** - * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target - * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an - * unsuccessful call. - */ - function verifyCallResultFromTarget( - address target, - bool success, - bytes memory returndata - ) internal view returns (bytes memory) { - if (!success) { - _revert(returndata); - } else { - // only check if target is a contract if the call was successful and the return data is empty - // otherwise we already know that it was a contract - if (returndata.length == 0 && target.code.length == 0) { - revert AddressEmptyCode(target); - } - return returndata; - } - } - - /** - * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the - * revert reason or with a default {FailedInnerCall} error. - */ - function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { - if (!success) { - _revert(returndata); - } else { - return returndata; - } - } - - /** - * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. - */ - function _revert(bytes memory returndata) private pure { - // Look for revert reason and bubble it up if present - if (returndata.length > 0) { - // The easiest way to bubble the revert reason is using memory via assembly - /// @solidity memory-safe-assembly - assembly { - let returndata_size := mload(returndata) - revert(add(32, returndata), returndata_size) - } - } else { - revert FailedInnerCall(); - } - } -} - -// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol - -// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) -// This file was procedurally generated from scripts/generate/templates/StorageSlot.js. - -/** - * @dev Library for reading and writing primitive types to specific storage slots. - * - * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. - * This library helps with reading and writing to such slots without the need for inline assembly. - * - * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. - * - * Example usage to set ERC1967 implementation slot: - * ```solidity - * contract ERC1967 { - * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; - * - * function _getImplementation() internal view returns (address) { - * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; - * } - * - * function _setImplementation(address newImplementation) internal { - * require(newImplementation.code.length > 0); - * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; - * } - * } - * ``` - */ -library StorageSlot { - struct AddressSlot { - address value; - } - - struct BooleanSlot { - bool value; - } - - struct Bytes32Slot { - bytes32 value; - } - - struct Uint256Slot { - uint256 value; - } - - struct StringSlot { - string value; - } - - struct BytesSlot { - bytes value; - } - - /** - * @dev Returns an `AddressSlot` with member `value` located at `slot`. - */ - function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := slot - } - } - - /** - * @dev Returns an `BooleanSlot` with member `value` located at `slot`. - */ - function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := slot - } - } - - /** - * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. - */ - function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := slot - } - } - - /** - * @dev Returns an `Uint256Slot` with member `value` located at `slot`. - */ - function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := slot - } - } - - /** - * @dev Returns an `StringSlot` with member `value` located at `slot`. - */ - function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := slot - } - } - - /** - * @dev Returns an `StringSlot` representation of the string storage pointer `store`. - */ - function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := store.slot - } - } - - /** - * @dev Returns an `BytesSlot` with member `value` located at `slot`. - */ - function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := slot - } - } - - /** - * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. - */ - function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { - /// @solidity memory-safe-assembly - assembly { - r.slot := store.slot - } - } -} - -// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol - -// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol) - -/** - * @dev This abstract contract provides getters and event emitting update functions for - * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. - */ -library ERC1967Utils { - // We re-declare ERC-1967 events here because they can't be used directly from IERC1967. - // This will be fixed in Solidity 0.8.21. At that point we should remove these events. - /** - * @dev Emitted when the implementation is upgraded. - */ - event Upgraded(address indexed implementation); - - /** - * @dev Emitted when the admin account has changed. - */ - event AdminChanged(address previousAdmin, address newAdmin); - - /** - * @dev Emitted when the beacon is changed. - */ - event BeaconUpgraded(address indexed beacon); - - /** - * @dev Storage slot with the address of the current implementation. - * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1. - */ - // solhint-disable-next-line private-vars-leading-underscore - bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; - - /** - * @dev The `implementation` of the proxy is invalid. - */ - error ERC1967InvalidImplementation(address implementation); - - /** - * @dev The `admin` of the proxy is invalid. - */ - error ERC1967InvalidAdmin(address admin); - - /** - * @dev The `beacon` of the proxy is invalid. - */ - error ERC1967InvalidBeacon(address beacon); - - /** - * @dev An upgrade function sees `msg.value > 0` that may be lost. - */ - error ERC1967NonPayable(); - - /** - * @dev Returns the current implementation address. - */ - function getImplementation() internal view returns (address) { - return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value; - } - - /** - * @dev Stores a new address in the EIP1967 implementation slot. - */ - function _setImplementation(address newImplementation) private { - if (newImplementation.code.length == 0) { - revert ERC1967InvalidImplementation(newImplementation); - } - StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation; - } - - /** - * @dev Performs implementation upgrade with additional setup call if data is nonempty. - * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected - * to avoid stuck value in the contract. - * - * Emits an {IERC1967-Upgraded} event. - */ - function upgradeToAndCall(address newImplementation, bytes memory data) internal { - _setImplementation(newImplementation); - emit Upgraded(newImplementation); - - if (data.length > 0) { - Address.functionDelegateCall(newImplementation, data); - } else { - _checkNonPayable(); - } - } - - /** - * @dev Storage slot with the admin of the contract. - * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1. - */ - // solhint-disable-next-line private-vars-leading-underscore - bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; - - /** - * @dev Returns the current admin. - * - * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using - * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. - * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103` - */ - function getAdmin() internal view returns (address) { - return StorageSlot.getAddressSlot(ADMIN_SLOT).value; - } - - /** - * @dev Stores a new address in the EIP1967 admin slot. - */ - function _setAdmin(address newAdmin) private { - if (newAdmin == address(0)) { - revert ERC1967InvalidAdmin(address(0)); - } - StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin; - } - - /** - * @dev Changes the admin of the proxy. - * - * Emits an {IERC1967-AdminChanged} event. - */ - function changeAdmin(address newAdmin) internal { - emit AdminChanged(getAdmin(), newAdmin); - _setAdmin(newAdmin); - } - - /** - * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. - * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1. - */ - // solhint-disable-next-line private-vars-leading-underscore - bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; - - /** - * @dev Returns the current beacon. - */ - function getBeacon() internal view returns (address) { - return StorageSlot.getAddressSlot(BEACON_SLOT).value; - } - - /** - * @dev Stores a new beacon in the EIP1967 beacon slot. - */ - function _setBeacon(address newBeacon) private { - if (newBeacon.code.length == 0) { - revert ERC1967InvalidBeacon(newBeacon); - } - - StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon; - - address beaconImplementation = IBeacon(newBeacon).implementation(); - if (beaconImplementation.code.length == 0) { - revert ERC1967InvalidImplementation(beaconImplementation); - } - } - - /** - * @dev Change the beacon and trigger a setup call if data is nonempty. - * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected - * to avoid stuck value in the contract. - * - * Emits an {IERC1967-BeaconUpgraded} event. - * - * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since - * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for - * efficiency. - */ - function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal { - _setBeacon(newBeacon); - emit BeaconUpgraded(newBeacon); - - if (data.length > 0) { - Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); - } else { - _checkNonPayable(); - } - } - - /** - * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract - * if an upgrade doesn't perform an initialization call. - */ - function _checkNonPayable() private { - if (msg.value > 0) { - revert ERC1967NonPayable(); - } - } -} - -// lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol - -// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Proxy.sol) - -/** - * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an - * implementation address that can be changed. This address is stored in storage in the location specified by - * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the - * implementation behind the proxy. - */ -contract ERC1967Proxy is Proxy { - /** - * @dev Initializes the upgradeable proxy with an initial implementation specified by `implementation`. - * - * If `_data` is nonempty, it's used as data in a delegate call to `implementation`. This will typically be an - * encoded function call, and allows initializing the storage of the proxy like a Solidity constructor. - * - * Requirements: - * - * - If `data` is empty, `msg.value` must be zero. - */ - constructor(address implementation, bytes memory _data) payable { - ERC1967Utils.upgradeToAndCall(implementation, _data); - } - - /** - * @dev Returns the current implementation address. - * - * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using - * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. - * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc` - */ - function _implementation() internal view virtual override returns (address) { - return ERC1967Utils.getImplementation(); - } -} - diff --git a/certora/mocks/Jug.sol b/certora/mocks/Jug.sol index 99fe253..cd803c1 100644 --- a/certora/mocks/Jug.sol +++ b/certora/mocks/Jug.sol @@ -130,22 +130,22 @@ contract Jug is LibNote { } // --- Administration --- - function init(bytes32 ilk) external note auth { + function init(bytes32 ilk) external note { Ilk storage i = ilks[ilk]; require(i.duty == 0, "Jug/ilk-already-init"); i.duty = ONE; i.rho = now; } - function file(bytes32 ilk, bytes32 what, uint data) external note auth { + function file(bytes32 ilk, bytes32 what, uint data) external auth note { require(now == ilks[ilk].rho, "Jug/rho-not-updated"); if (what == "duty") ilks[ilk].duty = data; else revert("Jug/file-unrecognized-param"); } - function file(bytes32 what, uint data) external note auth { + function file(bytes32 what, uint data) external auth note { if (what == "base") base = data; else revert("Jug/file-unrecognized-param"); } - function file(bytes32 what, address data) external note auth { + function file(bytes32 what, address data) external auth note { if (what == "vow") vow = data; else revert("Jug/file-unrecognized-param"); } @@ -153,9 +153,10 @@ contract Jug is LibNote { // --- Stability Fee Collection --- function drip(bytes32 ilk) external note returns (uint rate) { require(now >= ilks[ilk].rho, "Jug/invalid-now"); - (, uint prev) = vat.ilks(ilk); - rate = rmul(rpow(add(base, ilks[ilk].duty), now - ilks[ilk].rho, ONE), prev); - vat.fold(ilk, vow, diff(rate, prev)); + // (, uint prev) = vat.ilks(ilk); + // Note: ignoring rpow for Certora + // rate = rmul(rpow(add(base, ilks[ilk].duty), now - ilks[ilk].rho, ONE), prev); + // vat.fold(ilk, vow, diff(rate, prev)); ilks[ilk].rho = now; } } diff --git a/certora/mocks/Pot.sol b/certora/mocks/Pot.sol index 936d842..2273100 100644 --- a/certora/mocks/Pot.sol +++ b/certora/mocks/Pot.sol @@ -172,19 +172,18 @@ contract Pot is LibNote { } // --- Administration --- - function file(bytes32 what, uint256 data) external note auth { - require(live == 1, "Pot/not-live"); + function file(bytes32 what, uint256 data) external auth note { require(now == rho, "Pot/rho-not-updated"); if (what == "dsr") dsr = data; else revert("Pot/file-unrecognized-param"); } - function file(bytes32 what, address addr) external note auth { + function file(bytes32 what, address addr) external auth note { if (what == "vow") vow = addr; else revert("Pot/file-unrecognized-param"); } - function cage() external note auth { + function cage() external note { live = 0; dsr = ONE; } @@ -192,11 +191,12 @@ contract Pot is LibNote { // --- Savings Rate Accumulation --- function drip() external note returns (uint tmp) { require(now >= rho, "Pot/invalid-now"); - tmp = rmul(rpow(dsr, now - rho, ONE), chi); - uint chi_ = sub(tmp, chi); - chi = tmp; + // Note: ignoring rpow for Certora + // tmp = rmul(rpow(dsr, now - rho, ONE), chi); + // uint chi_ = sub(tmp, chi); + // chi = tmp; rho = now; - vat.suck(address(vow), address(this), mul(Pie, chi_)); + // vat.suck(address(vow), address(this), mul(Pie, chi)); } // --- Savings Dai Management --- diff --git a/certora/mocks/SUsds.sol b/certora/mocks/SUsds.sol index 1389be4..cbcd353 100644 --- a/certora/mocks/SUsds.sol +++ b/certora/mocks/SUsds.sol @@ -1024,7 +1024,7 @@ contract SUsds is UUPSUpgradeable { emit Rely(msg.sender); } - function _authorizeUpgrade(address newImplementation) internal override auth {} + function _authorizeUpgrade(address newImplementation) internal override {} function getImplementation() external view returns (address) { return ERC1967Utils.getImplementation(); @@ -1085,12 +1085,12 @@ contract SUsds is UUPSUpgradeable { // --- Admin external functions --- - function rely(address usr) external auth { + function rely(address usr) external { wards[usr] = 1; emit Rely(usr); } - function deny(address usr) external auth { + function deny(address usr) external { wards[usr] = 0; emit Deny(usr); } @@ -1108,18 +1108,8 @@ contract SUsds is UUPSUpgradeable { function drip() public returns (uint256 nChi) { (uint256 chi_, uint256 rho_) = (chi, rho); - uint256 diff; - if (block.timestamp > rho_) { - nChi = _rpow(ssr, block.timestamp - rho_) * chi_ / RAY; - uint256 totalSupply_ = totalSupply; - diff = totalSupply_ * nChi / RAY - totalSupply_ * chi_ / RAY; - vat.suck(address(vow), address(this), diff * RAY); - usdsJoin.exit(address(this), diff); - chi = uint192(nChi); // safe as nChi is limited to maxUint256/RAY (which is < maxUint192) - rho = uint64(block.timestamp); - } else { - nChi = chi_; - } + uint256 diff = 0; + rho = uint64(block.timestamp); emit Drip(nChi, diff); } diff --git a/certora/mocks/Usds.sol b/certora/mocks/Usds.sol new file mode 100644 index 0000000..48680b7 --- /dev/null +++ b/certora/mocks/Usds.sol @@ -0,0 +1,79 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.21; + +contract Usds { + mapping (address => uint256) public balanceOf; + mapping (address => mapping (address => uint256)) public allowance; + + uint256 public totalSupply; + + constructor(uint256 initialSupply) { + mint(msg.sender, initialSupply); + } + + function approve(address spender, uint256 value) external returns (bool) { + allowance[msg.sender][spender] = value; + return true; + } + + function transfer(address to, uint256 value) external returns (bool) { + uint256 balance = balanceOf[msg.sender]; + require(balance >= value, "Gem/insufficient-balance"); + + unchecked { + balanceOf[msg.sender] = balance - value; + balanceOf[to] += value; + } + return true; + } + + function transferFrom(address from, address to, uint256 value) external returns (bool) { + uint256 balance = balanceOf[from]; + require(balance >= value, "Gem/insufficient-balance"); + + if (from != msg.sender) { + uint256 allowed = allowance[from][msg.sender]; + if (allowed != type(uint256).max) { + require(allowed >= value, "Gem/insufficient-allowance"); + + unchecked { + allowance[from][msg.sender] = allowed - value; + } + } + } + + unchecked { + balanceOf[from] = balance - value; + balanceOf[to] += value; + } + return true; + } + + function mint(address to, uint256 value) public { + unchecked { + balanceOf[to] = balanceOf[to] + value; + } + totalSupply = totalSupply + value; + } + + function burn(address from, uint256 value) external { + uint256 balance = balanceOf[from]; + require(balance >= value, "Gem/insufficient-balance"); + + if (from != msg.sender) { + uint256 allowed = allowance[from][msg.sender]; + if (allowed != type(uint256).max) { + require(allowed >= value, "Gem/insufficient-allowance"); + + unchecked { + allowance[from][msg.sender] = allowed - value; + } + } + } + + unchecked { + balanceOf[from] = balance - value; + totalSupply = totalSupply - value; + } + } +} diff --git a/certora/mocks/UsdsJoin.sol b/certora/mocks/UsdsJoin.sol new file mode 100644 index 0000000..158ac79 --- /dev/null +++ b/certora/mocks/UsdsJoin.sol @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.21; + +interface UsdsLike { + function burn(address,uint256) external; + function mint(address,uint256) external; +} + +interface VatLike { + function move(address,address,uint256) external; +} + +contract UsdsJoin { + VatLike public immutable vat; // CDP Engine + UsdsLike public immutable usds; // Stablecoin Token + + uint256 constant RAY = 10 ** 27; + + // --- Events --- + event Join(address indexed caller, address indexed usr, uint256 wad); + event Exit(address indexed caller, address indexed usr, uint256 wad); + + constructor(address vat_, address usds_) { + vat = VatLike(vat_); + usds = UsdsLike(usds_); + } + + function join(address usr, uint256 wad) external { + vat.move(address(this), usr, RAY * wad); + usds.burn(msg.sender, wad); + emit Join(msg.sender, usr, wad); + } + + function exit(address usr, uint256 wad) external { + vat.move(msg.sender, address(this), RAY * wad); + usds.mint(usr, wad); + emit Exit(msg.sender, usr, wad); + } + + // To fully cover daiJoin abi + function dai() external view returns (address) { + return address(usds); + } +} diff --git a/certora/mocks/Vat.sol b/certora/mocks/Vat.sol index 00e1ed6..e078fd3 100644 --- a/certora/mocks/Vat.sol +++ b/certora/mocks/Vat.sol @@ -22,8 +22,8 @@ pragma solidity >=0.5.12; contract Vat { // --- Auth --- mapping (address => uint) public wards; - function rely(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 1; } - function deny(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 0; } + function rely(address usr) external note auth { wards[usr] = 1; } + function deny(address usr) external note auth { wards[usr] = 0; } modifier auth { require(wards[msg.sender] == 1, "Vat/not-authorized"); _; @@ -121,28 +121,26 @@ contract Vat { } // --- Administration --- - function init(bytes32 ilk) external note auth { + function init(bytes32 ilk) external note { require(ilks[ilk].rate == 0, "Vat/ilk-already-init"); ilks[ilk].rate = 10 ** 27; } - function file(bytes32 what, uint data) external note auth { - require(live == 1, "Vat/not-live"); + function file(bytes32 what, uint data) external note { if (what == "Line") Line = data; else revert("Vat/file-unrecognized-param"); } - function file(bytes32 ilk, bytes32 what, uint data) external note auth { - require(live == 1, "Vat/not-live"); + function file(bytes32 ilk, bytes32 what, uint data) external note { if (what == "spot") ilks[ilk].spot = data; else if (what == "line") ilks[ilk].line = data; else if (what == "dust") ilks[ilk].dust = data; else revert("Vat/file-unrecognized-param"); } - function cage() external note auth { + function cage() external note { live = 0; } // --- Fungibility --- - function slip(bytes32 ilk, address usr, int256 wad) external note auth { + function slip(bytes32 ilk, address usr, int256 wad) external note { gem[ilk][usr] = add(gem[ilk][usr], wad); } function flux(bytes32 ilk, address src, address dst, uint256 wad) external note { @@ -165,9 +163,6 @@ contract Vat { // --- CDP Manipulation --- function frob(bytes32 i, address u, address v, address w, int dink, int dart) external note { - // system is live - require(live == 1, "Vat/not-live"); - Urn memory urn = urns[i][u]; Ilk memory ilk = ilks[i]; // ilk has been initialised @@ -228,7 +223,7 @@ contract Vat { require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst"); } // --- CDP Confiscation --- - function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note auth { + function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note { Urn storage urn = urns[i][u]; Ilk storage ilk = ilks[i]; @@ -251,7 +246,7 @@ contract Vat { vice = sub(vice, rad); debt = sub(debt, rad); } - function suck(address u, address v, uint rad) external note auth { + function suck(address u, address v, uint rad) external note { sin[u] = add(sin[u], rad); dai[v] = add(dai[v], rad); vice = add(vice, rad); @@ -259,8 +254,7 @@ contract Vat { } // --- Rates --- - function fold(bytes32 i, address u, int rate) external note auth { - require(live == 1, "Vat/not-live"); + function fold(bytes32 i, address u, int rate) external note { Ilk storage ilk = ilks[i]; ilk.rate = add(ilk.rate, rate); int rad = mul(ilk.Art, rate); diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index b2ae523..e64da66 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -1,103 +1,20029 @@ -// SPDX-FileCopyrightText: © 2025 Dai Foundation -// SPDX-License-Identifier: AGPL-3.0-or-later -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Affero General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Affero General Public License for more details. -// -// You should have received a copy of the GNU Affero General Public License -// along with this program. If not, see . - pragma solidity ^0.8.24; contract ConvMock { - /// @notice The max bps supported in bps -> rate conversion. - uint256 public constant MAX = 50_00; - /// @dev `ray` precision - uint256 internal constant RAY = 10 ** 27; - /// @dev `bps` precision + uint256 public constant MAX_BPS_IN = 50_00; uint256 internal constant BPS = 100_00; + uint256 internal constant RAY = 10 ** 27; - // Each rate takes 8 bytes (64 bits), total of 5001 rates - // Each storage word (32 bytes) contains exactly 4 rates - // Total size = 5001 * 8 = 40008 bytes - bytes internal RATES; + mapping(uint256 => uint256) internal bpsToRay; + mapping(uint256 => uint256) internal rayToBps; constructor() { - RATES = - hex"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"; - } - - /// @notice Fetches the rate for a given basis points value - /// @param bps The basis points value to get the rate for - /// @return ray The annual rate value - function btor(uint256 bps) public view virtual returns (uint256 ray) { - require(bps <= MAX); - - assembly { - let offset := mul(bps, 8) // Each rate is 8 bytes - let wordPos := div(offset, 32) // Which 32-byte word to read - let bytePos := mod(offset, 32) // Position within the word - - let dataSlot := keccak256(RATES.slot, 0x20) - - let value := sload(add(dataSlot, wordPos)) - - let shifted := shr(mul(sub(24, bytePos), 8), value) + bpsToRay[0] = 1000000000000000000000000000; + bpsToRay[1] = 1000000000003170820659990704; + bpsToRay[2] = 1000000000006341324285480111; + bpsToRay[3] = 1000000000009511510939859271; + bpsToRay[4] = 1000000000012681380686500226; + bpsToRay[5] = 1000000000015850933588756013; + bpsToRay[6] = 1000000000019020169709960675; + bpsToRay[7] = 1000000000022189089113429267; + bpsToRay[8] = 1000000000025357691862457863; + bpsToRay[9] = 1000000000028525978020323563; + bpsToRay[10] = 1000000000031693947650284507; + bpsToRay[11] = 1000000000034861600815579870; + bpsToRay[12] = 1000000000038028937579429884; + bpsToRay[13] = 1000000000041195958005035834; + bpsToRay[14] = 1000000000044362662155580072; + bpsToRay[15] = 1000000000047529050094226024; + bpsToRay[16] = 1000000000050695121884118193; + bpsToRay[17] = 1000000000053860877588382173; + bpsToRay[18] = 1000000000057026317270124651; + bpsToRay[19] = 1000000000060191440992433418; + bpsToRay[20] = 1000000000063356248818377377; + bpsToRay[21] = 1000000000066520740811006546; + bpsToRay[22] = 1000000000069684917033352071; + bpsToRay[23] = 1000000000072848777548426231; + bpsToRay[24] = 1000000000076012322419222442; + bpsToRay[25] = 1000000000079175551708715274; + bpsToRay[26] = 1000000000082338465479860449; + bpsToRay[27] = 1000000000085501063795594852; + bpsToRay[28] = 1000000000088663346718836541; + bpsToRay[29] = 1000000000091825314312484750; + bpsToRay[30] = 1000000000094986966639419899; + bpsToRay[31] = 1000000000098148303762503603; + bpsToRay[32] = 1000000000101309325744578677; + bpsToRay[33] = 1000000000104470032648469142; + bpsToRay[34] = 1000000000107630424536980239; + bpsToRay[35] = 1000000000110790501472898427; + bpsToRay[36] = 1000000000113950263518991400; + bpsToRay[37] = 1000000000117109710738008089; + bpsToRay[38] = 1000000000120268843192678669; + bpsToRay[39] = 1000000000123427660945714570; + bpsToRay[40] = 1000000000126586164059808482; + bpsToRay[41] = 1000000000129744352597634363; + bpsToRay[42] = 1000000000132902226621847447; + bpsToRay[43] = 1000000000136059786195084249; + bpsToRay[44] = 1000000000139217031379962578; + bpsToRay[45] = 1000000000142373962239081538; + bpsToRay[46] = 1000000000145530578835021538; + bpsToRay[47] = 1000000000148686881230344303; + bpsToRay[48] = 1000000000151842869487592874; + bpsToRay[49] = 1000000000154998543669291624; + bpsToRay[50] = 1000000000158153903837946257; + bpsToRay[51] = 1000000000161308950056043822; + bpsToRay[52] = 1000000000164463682386052718; + bpsToRay[53] = 1000000000167618100890422700; + bpsToRay[54] = 1000000000170772205631584889; + bpsToRay[55] = 1000000000173925996671951777; + bpsToRay[56] = 1000000000177079474073917237; + bpsToRay[57] = 1000000000180232637899856526; + bpsToRay[58] = 1000000000183385488212126301; + bpsToRay[59] = 1000000000186538025073064615; + bpsToRay[60] = 1000000000189690248544990934; + bpsToRay[61] = 1000000000192842158690206138; + bpsToRay[62] = 1000000000195993755570992533; + bpsToRay[63] = 1000000000199145039249613856; + bpsToRay[64] = 1000000000202296009788315281; + bpsToRay[65] = 1000000000205446667249323430; + bpsToRay[66] = 1000000000208597011694846379; + bpsToRay[67] = 1000000000211747043187073663; + bpsToRay[68] = 1000000000214896761788176285; + bpsToRay[69] = 1000000000218046167560306726; + bpsToRay[70] = 1000000000221195260565598948; + bpsToRay[71] = 1000000000224344040866168404; + bpsToRay[72] = 1000000000227492508524112044; + bpsToRay[73] = 1000000000230640663601508324; + bpsToRay[74] = 1000000000233788506160417212; + bpsToRay[75] = 1000000000236936036262880196; + bpsToRay[76] = 1000000000240083253970920290; + bpsToRay[77] = 1000000000243230159346542043; + bpsToRay[78] = 1000000000246376752451731545; + bpsToRay[79] = 1000000000249523033348456436; + bpsToRay[80] = 1000000000252669002098665913; + bpsToRay[81] = 1000000000255814658764290734; + bpsToRay[82] = 1000000000258960003407243230; + bpsToRay[83] = 1000000000262105036089417311; + bpsToRay[84] = 1000000000265249756872688471; + bpsToRay[85] = 1000000000268394165818913798; + bpsToRay[86] = 1000000000271538262989931978; + bpsToRay[87] = 1000000000274682048447563305; + bpsToRay[88] = 1000000000277825522253609693; + bpsToRay[89] = 1000000000280968684469854670; + bpsToRay[90] = 1000000000284111535158063399; + bpsToRay[91] = 1000000000287254074379982678; + bpsToRay[92] = 1000000000290396302197340948; + bpsToRay[93] = 1000000000293538218671848302; + bpsToRay[94] = 1000000000296679823865196492; + bpsToRay[95] = 1000000000299821117839058936; + bpsToRay[96] = 1000000000302962100655090723; + bpsToRay[97] = 1000000000306102772374928623; + bpsToRay[98] = 1000000000309243133060191095; + bpsToRay[99] = 1000000000312383182772478292; + bpsToRay[100] = 1000000000315522921573372069; + bpsToRay[101] = 1000000000318662349524435988; + bpsToRay[102] = 1000000000321801466687215330; + bpsToRay[103] = 1000000000324940273123237102; + bpsToRay[104] = 1000000000328078768894010037; + bpsToRay[105] = 1000000000331216954061024608; + bpsToRay[106] = 1000000000334354828685753035; + bpsToRay[107] = 1000000000337492392829649290; + bpsToRay[108] = 1000000000340629646554149104; + bpsToRay[109] = 1000000000343766589920669975; + bpsToRay[110] = 1000000000346903222990611176; + bpsToRay[111] = 1000000000350039545825353762; + bpsToRay[112] = 1000000000353175558486260576; + bpsToRay[113] = 1000000000356311261034676258; + bpsToRay[114] = 1000000000359446653531927249; + bpsToRay[115] = 1000000000362581736039321802; + bpsToRay[116] = 1000000000365716508618149987; + bpsToRay[117] = 1000000000368850971329683699; + bpsToRay[118] = 1000000000371985124235176666; + bpsToRay[119] = 1000000000375118967395864451; + bpsToRay[120] = 1000000000378252500872964469; + bpsToRay[121] = 1000000000381385724727675984; + bpsToRay[122] = 1000000000384518639021180123; + bpsToRay[123] = 1000000000387651243814639879; + bpsToRay[124] = 1000000000390783539169200122; + bpsToRay[125] = 1000000000393915525145987602; + bpsToRay[126] = 1000000000397047201806110961; + bpsToRay[127] = 1000000000400178569210660733; + bpsToRay[128] = 1000000000403309627420709360; + bpsToRay[129] = 1000000000406440376497311193; + bpsToRay[130] = 1000000000409570816501502501; + bpsToRay[131] = 1000000000412700947494301478; + bpsToRay[132] = 1000000000415830769536708248; + bpsToRay[133] = 1000000000418960282689704878; + bpsToRay[134] = 1000000000422089487014255380; + bpsToRay[135] = 1000000000425218382571305718; + bpsToRay[136] = 1000000000428346969421783819; + bpsToRay[137] = 1000000000431475247626599574; + bpsToRay[138] = 1000000000434603217246644855; + bpsToRay[139] = 1000000000437730878342793510; + bpsToRay[140] = 1000000000440858230975901380; + bpsToRay[141] = 1000000000443985275206806300; + bpsToRay[142] = 1000000000447112011096328109; + bpsToRay[143] = 1000000000450238438705268656; + bpsToRay[144] = 1000000000453364558094411809; + bpsToRay[145] = 1000000000456490369324523458; + bpsToRay[146] = 1000000000459615872456351529; + bpsToRay[147] = 1000000000462741067550625980; + bpsToRay[148] = 1000000000465865954668058822; + bpsToRay[149] = 1000000000468990533869344115; + bpsToRay[150] = 1000000000472114805215157978; + bpsToRay[151] = 1000000000475238768766158601; + bpsToRay[152] = 1000000000478362424582986244; + bpsToRay[153] = 1000000000481485772726263252; + bpsToRay[154] = 1000000000484608813256594054; + bpsToRay[155] = 1000000000487731546234565179; + bpsToRay[156] = 1000000000490853971720745253; + bpsToRay[157] = 1000000000493976089775685018; + bpsToRay[158] = 1000000000497097900459917326; + bpsToRay[159] = 1000000000500219403833957155; + bpsToRay[160] = 1000000000503340599958301616; + bpsToRay[161] = 1000000000506461488893429953; + bpsToRay[162] = 1000000000509582070699803560; + bpsToRay[163] = 1000000000512702345437865976; + bpsToRay[164] = 1000000000515822313168042905; + bpsToRay[165] = 1000000000518941973950742212; + bpsToRay[166] = 1000000000522061327846353937; + bpsToRay[167] = 1000000000525180374915250300; + bpsToRay[168] = 1000000000528299115217785706; + bpsToRay[169] = 1000000000531417548814296756; + bpsToRay[170] = 1000000000534535675765102249; + bpsToRay[171] = 1000000000537653496130503193; + bpsToRay[172] = 1000000000540771009970782812; + bpsToRay[173] = 1000000000543888217346206550; + bpsToRay[174] = 1000000000547005118317022080; + bpsToRay[175] = 1000000000550121712943459312; + bpsToRay[176] = 1000000000553238001285730395; + bpsToRay[177] = 1000000000556353983404029733; + bpsToRay[178] = 1000000000559469659358533982; + bpsToRay[179] = 1000000000562585029209402065; + bpsToRay[180] = 1000000000565700093016775172; + bpsToRay[181] = 1000000000568814850840776775; + bpsToRay[182] = 1000000000571929302741512626; + bpsToRay[183] = 1000000000575043448779070771; + bpsToRay[184] = 1000000000578157289013521555; + bpsToRay[185] = 1000000000581270823504917627; + bpsToRay[186] = 1000000000584384052313293946; + bpsToRay[187] = 1000000000587496975498667797; + bpsToRay[188] = 1000000000590609593121038783; + bpsToRay[189] = 1000000000593721905240388847; + bpsToRay[190] = 1000000000596833911916682269; + bpsToRay[191] = 1000000000599945613209865674; + bpsToRay[192] = 1000000000603057009179868046; + bpsToRay[193] = 1000000000606168099886600725; + bpsToRay[194] = 1000000000609278885389957423; + bpsToRay[195] = 1000000000612389365749814222; + bpsToRay[196] = 1000000000615499541026029589; + bpsToRay[197] = 1000000000618609411278444380; + bpsToRay[198] = 1000000000621718976566881844; + bpsToRay[199] = 1000000000624828236951147633; + bpsToRay[200] = 1000000000627937192491029810; + bpsToRay[201] = 1000000000631045843246298852; + bpsToRay[202] = 1000000000634154189276707659; + bpsToRay[203] = 1000000000637262230641991564; + bpsToRay[204] = 1000000000640369967401868332; + bpsToRay[205] = 1000000000643477399616038176; + bpsToRay[206] = 1000000000646584527344183758; + bpsToRay[207] = 1000000000649691350645970197; + bpsToRay[208] = 1000000000652797869581045076; + bpsToRay[209] = 1000000000655904084209038450; + bpsToRay[210] = 1000000000659009994589562852; + bpsToRay[211] = 1000000000662115600782213301; + bpsToRay[212] = 1000000000665220902846567304; + bpsToRay[213] = 1000000000668325900842184872; + bpsToRay[214] = 1000000000671430594828608518; + bpsToRay[215] = 1000000000674534984865363268; + bpsToRay[216] = 1000000000677639071011956667; + bpsToRay[217] = 1000000000680742853327878787; + bpsToRay[218] = 1000000000683846331872602231; + bpsToRay[219] = 1000000000686949506705582145; + bpsToRay[220] = 1000000000690052377886256219; + bpsToRay[221] = 1000000000693154945474044696; + bpsToRay[222] = 1000000000696257209528350379; + bpsToRay[223] = 1000000000699359170108558644; + bpsToRay[224] = 1000000000702460827274037431; + bpsToRay[225] = 1000000000705562181084137268; + bpsToRay[226] = 1000000000708663231598191269; + bpsToRay[227] = 1000000000711763978875515140; + bpsToRay[228] = 1000000000714864422975407191; + bpsToRay[229] = 1000000000717964563957148338; + bpsToRay[230] = 1000000000721064401880002111; + bpsToRay[231] = 1000000000724163936803214665; + bpsToRay[232] = 1000000000727263168786014781; + bpsToRay[233] = 1000000000730362097887613873; + bpsToRay[234] = 1000000000733460724167206002; + bpsToRay[235] = 1000000000736559047683967873; + bpsToRay[236] = 1000000000739657068497058849; + bpsToRay[237] = 1000000000742754786665620954; + bpsToRay[238] = 1000000000745852202248778881; + bpsToRay[239] = 1000000000748949315305640001; + bpsToRay[240] = 1000000000752046125895294364; + bpsToRay[241] = 1000000000755142634076814712; + bpsToRay[242] = 1000000000758238839909256483; + bpsToRay[243] = 1000000000761334743451657815; + bpsToRay[244] = 1000000000764430344763039558; + bpsToRay[245] = 1000000000767525643902405280; + bpsToRay[246] = 1000000000770620640928741268; + bpsToRay[247] = 1000000000773715335901016542; + bpsToRay[248] = 1000000000776809728878182856; + bpsToRay[249] = 1000000000779903819919174710; + bpsToRay[250] = 1000000000782997609082909351; + bpsToRay[251] = 1000000000786091096428286786; + bpsToRay[252] = 1000000000789184282014189785; + bpsToRay[253] = 1000000000792277165899483884; + bpsToRay[254] = 1000000000795369748143017402; + bpsToRay[255] = 1000000000798462028803621438; + bpsToRay[256] = 1000000000801554007940109881; + bpsToRay[257] = 1000000000804645685611279421; + bpsToRay[258] = 1000000000807737061875909546; + bpsToRay[259] = 1000000000810828136792762559; + bpsToRay[260] = 1000000000813918910420583580; + bpsToRay[261] = 1000000000817009382818100549; + bpsToRay[262] = 1000000000820099554044024241; + bpsToRay[263] = 1000000000823189424157048266; + bpsToRay[264] = 1000000000826278993215849080; + bpsToRay[265] = 1000000000829368261279085986; + bpsToRay[266] = 1000000000832457228405401147; + bpsToRay[267] = 1000000000835545894653419590; + bpsToRay[268] = 1000000000838634260081749213; + bpsToRay[269] = 1000000000841722324748980791; + bpsToRay[270] = 1000000000844810088713687981; + bpsToRay[271] = 1000000000847897552034427333; + bpsToRay[272] = 1000000000850984714769738294; + bpsToRay[273] = 1000000000854071576978143215; + bpsToRay[274] = 1000000000857158138718147357; + bpsToRay[275] = 1000000000860244400048238898; + bpsToRay[276] = 1000000000863330361026888943; + bpsToRay[277] = 1000000000866416021712551525; + bpsToRay[278] = 1000000000869501382163663613; + bpsToRay[279] = 1000000000872586442438645123; + bpsToRay[280] = 1000000000875671202595898921; + bpsToRay[281] = 1000000000878755662693810828; + bpsToRay[282] = 1000000000881839822790749630; + bpsToRay[283] = 1000000000884923682945067084; + bpsToRay[284] = 1000000000888007243215097924; + bpsToRay[285] = 1000000000891090503659159869; + bpsToRay[286] = 1000000000894173464335553624; + bpsToRay[287] = 1000000000897256125302562895; + bpsToRay[288] = 1000000000900338486618454391; + bpsToRay[289] = 1000000000903420548341477830; + bpsToRay[290] = 1000000000906502310529865946; + bpsToRay[291] = 1000000000909583773241834499; + bpsToRay[292] = 1000000000912664936535582274; + bpsToRay[293] = 1000000000915745800469291101; + bpsToRay[294] = 1000000000918826365101125845; + bpsToRay[295] = 1000000000921906630489234425; + bpsToRay[296] = 1000000000924986596691747814; + bpsToRay[297] = 1000000000928066263766780050; + bpsToRay[298] = 1000000000931145631772428239; + bpsToRay[299] = 1000000000934224700766772564; + bpsToRay[300] = 1000000000937303470807876289; + bpsToRay[301] = 1000000000940381941953785771; + bpsToRay[302] = 1000000000943460114262530457; + bpsToRay[303] = 1000000000946537987792122901; + bpsToRay[304] = 1000000000949615562600558765; + bpsToRay[305] = 1000000000952692838745816824; + bpsToRay[306] = 1000000000955769816285858978; + bpsToRay[307] = 1000000000958846495278630254; + bpsToRay[308] = 1000000000961922875782058814; + bpsToRay[309] = 1000000000964998957854055963; + bpsToRay[310] = 1000000000968074741552516152; + bpsToRay[311] = 1000000000971150226935316988; + bpsToRay[312] = 1000000000974225414060319240; + bpsToRay[313] = 1000000000977300302985366843; + bpsToRay[314] = 1000000000980374893768286908; + bpsToRay[315] = 1000000000983449186466889726; + bpsToRay[316] = 1000000000986523181138968776; + bpsToRay[317] = 1000000000989596877842300728; + bpsToRay[318] = 1000000000992670276634645456; + bpsToRay[319] = 1000000000995743377573746041; + bpsToRay[320] = 1000000000998816180717328774; + bpsToRay[321] = 1000000001001888686123103168; + bpsToRay[322] = 1000000001004960893848761962; + bpsToRay[323] = 1000000001008032803951981130; + bpsToRay[324] = 1000000001011104416490419883; + bpsToRay[325] = 1000000001014175731521720677; + bpsToRay[326] = 1000000001017246749103509223; + bpsToRay[327] = 1000000001020317469293394491; + bpsToRay[328] = 1000000001023387892148968714; + bpsToRay[329] = 1000000001026458017727807397; + bpsToRay[330] = 1000000001029527846087469327; + bpsToRay[331] = 1000000001032597377285496570; + bpsToRay[332] = 1000000001035666611379414489; + bpsToRay[333] = 1000000001038735548426731741; + bpsToRay[334] = 1000000001041804188484940289; + bpsToRay[335] = 1000000001044872531611515405; + bpsToRay[336] = 1000000001047940577863915679; + bpsToRay[337] = 1000000001051008327299583027; + bpsToRay[338] = 1000000001054075779975942691; + bpsToRay[339] = 1000000001057142935950403252; + bpsToRay[340] = 1000000001060209795280356633; + bpsToRay[341] = 1000000001063276358023178106; + bpsToRay[342] = 1000000001066342624236226300; + bpsToRay[343] = 1000000001069408593976843206; + bpsToRay[344] = 1000000001072474267302354182; + bpsToRay[345] = 1000000001075539644270067964; + bpsToRay[346] = 1000000001078604724937276668; + bpsToRay[347] = 1000000001081669509361255798; + bpsToRay[348] = 1000000001084733997599264251; + bpsToRay[349] = 1000000001087798189708544327; + bpsToRay[350] = 1000000001090862085746321732; + bpsToRay[351] = 1000000001093925685769805588; + bpsToRay[352] = 1000000001096988989836188433; + bpsToRay[353] = 1000000001100051998002646234; + bpsToRay[354] = 1000000001103114710326338391; + bpsToRay[355] = 1000000001106177126864407743; + bpsToRay[356] = 1000000001109239247673980573; + bpsToRay[357] = 1000000001112301072812166619; + bpsToRay[358] = 1000000001115362602336059074; + bpsToRay[359] = 1000000001118423836302734600; + bpsToRay[360] = 1000000001121484774769253326; + bpsToRay[361] = 1000000001124545417792658861; + bpsToRay[362] = 1000000001127605765429978297; + bpsToRay[363] = 1000000001130665817738222219; + bpsToRay[364] = 1000000001133725574774384703; + bpsToRay[365] = 1000000001136785036595443334; + bpsToRay[366] = 1000000001139844203258359204; + bpsToRay[367] = 1000000001142903074820076919; + bpsToRay[368] = 1000000001145961651337524612; + bpsToRay[369] = 1000000001149019932867613939; + bpsToRay[370] = 1000000001152077919467240095; + bpsToRay[371] = 1000000001155135611193281814; + bpsToRay[372] = 1000000001158193008102601379; + bpsToRay[373] = 1000000001161250110252044625; + bpsToRay[374] = 1000000001164306917698440949; + bpsToRay[375] = 1000000001167363430498603315; + bpsToRay[376] = 1000000001170419648709328258; + bpsToRay[377] = 1000000001173475572387395894; + bpsToRay[378] = 1000000001176531201589569924; + bpsToRay[379] = 1000000001179586536372597640; + bpsToRay[380] = 1000000001182641576793209935; + bpsToRay[381] = 1000000001185696322908121302; + bpsToRay[382] = 1000000001188750774774029849; + bpsToRay[383] = 1000000001191804932447617301; + bpsToRay[384] = 1000000001194858795985549004; + bpsToRay[385] = 1000000001197912365444473936; + bpsToRay[386] = 1000000001200965640881024708; + bpsToRay[387] = 1000000001204018622351817579; + bpsToRay[388] = 1000000001207071309913452452; + bpsToRay[389] = 1000000001210123703622512886; + bpsToRay[390] = 1000000001213175803535566102; + bpsToRay[391] = 1000000001216227609709162989; + bpsToRay[392] = 1000000001219279122199838110; + bpsToRay[393] = 1000000001222330341064109706; + bpsToRay[394] = 1000000001225381266358479708; + bpsToRay[395] = 1000000001228431898139433735; + bpsToRay[396] = 1000000001231482236463441109; + bpsToRay[397] = 1000000001234532281386954858; + bpsToRay[398] = 1000000001237582032966411716; + bpsToRay[399] = 1000000001240631491258232141; + bpsToRay[400] = 1000000001243680656318820312; + bpsToRay[401] = 1000000001246729528204564139; + bpsToRay[402] = 1000000001249778106971835268; + bpsToRay[403] = 1000000001252826392676989088; + bpsToRay[404] = 1000000001255874385376364739; + bpsToRay[405] = 1000000001258922085126285113; + bpsToRay[406] = 1000000001261969491983056866; + bpsToRay[407] = 1000000001265016606002970422; + bpsToRay[408] = 1000000001268063427242299977; + bpsToRay[409] = 1000000001271109955757303509; + bpsToRay[410] = 1000000001274156191604222783; + bpsToRay[411] = 1000000001277202134839283355; + bpsToRay[412] = 1000000001280247785518694582; + bpsToRay[413] = 1000000001283293143698649624; + bpsToRay[414] = 1000000001286338209435325454; + bpsToRay[415] = 1000000001289382982784882863; + bpsToRay[416] = 1000000001292427463803466464; + bpsToRay[417] = 1000000001295471652547204702; + bpsToRay[418] = 1000000001298515549072209857; + bpsToRay[419] = 1000000001301559153434578054; + bpsToRay[420] = 1000000001304602465690389263; + bpsToRay[421] = 1000000001307645485895707309; + bpsToRay[422] = 1000000001310688214106579884; + bpsToRay[423] = 1000000001313730650379038540; + bpsToRay[424] = 1000000001316772794769098706; + bpsToRay[425] = 1000000001319814647332759691; + bpsToRay[426] = 1000000001322856208126004689; + bpsToRay[427] = 1000000001325897477204800787; + bpsToRay[428] = 1000000001328938454625098968; + bpsToRay[429] = 1000000001331979140442834120; + bpsToRay[430] = 1000000001335019534713925045; + bpsToRay[431] = 1000000001338059637494274457; + bpsToRay[432] = 1000000001341099448839768997; + bpsToRay[433] = 1000000001344138968806279230; + bpsToRay[434] = 1000000001347178197449659663; + bpsToRay[435] = 1000000001350217134825748738; + bpsToRay[436] = 1000000001353255780990368849; + bpsToRay[437] = 1000000001356294135999326341; + bpsToRay[438] = 1000000001359332199908411521; + bpsToRay[439] = 1000000001362369972773398659; + bpsToRay[440] = 1000000001365407454650046000; + bpsToRay[441] = 1000000001368444645594095767; + bpsToRay[442] = 1000000001371481545661274166; + bpsToRay[443] = 1000000001374518154907291394; + bpsToRay[444] = 1000000001377554473387841645; + bpsToRay[445] = 1000000001380590501158603116; + bpsToRay[446] = 1000000001383626238275238013; + bpsToRay[447] = 1000000001386661684793392556; + bpsToRay[448] = 1000000001389696840768696987; + bpsToRay[449] = 1000000001392731706256765577; + bpsToRay[450] = 1000000001395766281313196627; + bpsToRay[451] = 1000000001398800565993572478; + bpsToRay[452] = 1000000001401834560353459521; + bpsToRay[453] = 1000000001404868264448408194; + bpsToRay[454] = 1000000001407901678333952993; + bpsToRay[455] = 1000000001410934802065612482; + bpsToRay[456] = 1000000001413967635698889291; + bpsToRay[457] = 1000000001417000179289270128; + bpsToRay[458] = 1000000001420032432892225782; + bpsToRay[459] = 1000000001423064396563211131; + bpsToRay[460] = 1000000001426096070357665149; + bpsToRay[461] = 1000000001429127454331010908; + bpsToRay[462] = 1000000001432158548538655588; + bpsToRay[463] = 1000000001435189353035990479; + bpsToRay[464] = 1000000001438219867878390995; + bpsToRay[465] = 1000000001441250093121216670; + bpsToRay[466] = 1000000001444280028819811170; + bpsToRay[467] = 1000000001447309675029502300; + bpsToRay[468] = 1000000001450339031805602006; + bpsToRay[469] = 1000000001453368099203406382; + bpsToRay[470] = 1000000001456396877278195681; + bpsToRay[471] = 1000000001459425366085234312; + bpsToRay[472] = 1000000001462453565679770855; + bpsToRay[473] = 1000000001465481476117038063; + bpsToRay[474] = 1000000001468509097452252866; + bpsToRay[475] = 1000000001471536429740616381; + bpsToRay[476] = 1000000001474563473037313917; + bpsToRay[477] = 1000000001477590227397514978; + bpsToRay[478] = 1000000001480616692876373275; + bpsToRay[479] = 1000000001483642869529026724; + bpsToRay[480] = 1000000001486668757410597461; + bpsToRay[481] = 1000000001489694356576191838; + bpsToRay[482] = 1000000001492719667080900443; + bpsToRay[483] = 1000000001495744688979798088; + bpsToRay[484] = 1000000001498769422327943831; + bpsToRay[485] = 1000000001501793867180380974; + bpsToRay[486] = 1000000001504818023592137069; + bpsToRay[487] = 1000000001507841891618223927; + bpsToRay[488] = 1000000001510865471313637625; + bpsToRay[489] = 1000000001513888762733358503; + bpsToRay[490] = 1000000001516911765932351183; + bpsToRay[491] = 1000000001519934480965564567; + bpsToRay[492] = 1000000001522956907887931841; + bpsToRay[493] = 1000000001525979046754370490; + bpsToRay[494] = 1000000001529000897619782295; + bpsToRay[495] = 1000000001532022460539053343; + bpsToRay[496] = 1000000001535043735567054034; + bpsToRay[497] = 1000000001538064722758639085; + bpsToRay[498] = 1000000001541085422168647535; + bpsToRay[499] = 1000000001544105833851902754; + bpsToRay[500] = 1000000001547125957863212448; + bpsToRay[501] = 1000000001550145794257368662; + bpsToRay[502] = 1000000001553165343089147790; + bpsToRay[503] = 1000000001556184604413310579; + bpsToRay[504] = 1000000001559203578284602136; + bpsToRay[505] = 1000000001562222264757751932; + bpsToRay[506] = 1000000001565240663887473810; + bpsToRay[507] = 1000000001568258775728465991; + bpsToRay[508] = 1000000001571276600335411077; + bpsToRay[509] = 1000000001574294137762976059; + bpsToRay[510] = 1000000001577311388065812327; + bpsToRay[511] = 1000000001580328351298555666; + bpsToRay[512] = 1000000001583345027515826272; + bpsToRay[513] = 1000000001586361416772228753; + bpsToRay[514] = 1000000001589377519122352136; + bpsToRay[515] = 1000000001592393334620769870; + bpsToRay[516] = 1000000001595408863322039839; + bpsToRay[517] = 1000000001598424105280704358; + bpsToRay[518] = 1000000001601439060551290189; + bpsToRay[519] = 1000000001604453729188308543; + bpsToRay[520] = 1000000001607468111246255079; + bpsToRay[521] = 1000000001610482206779609923; + bpsToRay[522] = 1000000001613496015842837664; + bpsToRay[523] = 1000000001616509538490387361; + bpsToRay[524] = 1000000001619522774776692555; + bpsToRay[525] = 1000000001622535724756171269; + bpsToRay[526] = 1000000001625548388483226015; + bpsToRay[527] = 1000000001628560766012243800; + bpsToRay[528] = 1000000001631572857397596136; + bpsToRay[529] = 1000000001634584662693639037; + bpsToRay[530] = 1000000001637596181954713035; + bpsToRay[531] = 1000000001640607415235143177; + bpsToRay[532] = 1000000001643618362589239040; + bpsToRay[533] = 1000000001646629024071294727; + bpsToRay[534] = 1000000001649639399735588881; + bpsToRay[535] = 1000000001652649489636384685; + bpsToRay[536] = 1000000001655659293827929873; + bpsToRay[537] = 1000000001658668812364456731; + bpsToRay[538] = 1000000001661678045300182106; + bpsToRay[539] = 1000000001664686992689307414; + bpsToRay[540] = 1000000001667695654586018638; + bpsToRay[541] = 1000000001670704031044486342; + bpsToRay[542] = 1000000001673712122118865672; + bpsToRay[543] = 1000000001676719927863296364; + bpsToRay[544] = 1000000001679727448331902751; + bpsToRay[545] = 1000000001682734683578793766; + bpsToRay[546] = 1000000001685741633658062946; + bpsToRay[547] = 1000000001688748298623788446; + bpsToRay[548] = 1000000001691754678530033036; + bpsToRay[549] = 1000000001694760773430844112; + bpsToRay[550] = 1000000001697766583380253701; + bpsToRay[551] = 1000000001700772108432278464; + bpsToRay[552] = 1000000001703777348640919706; + bpsToRay[553] = 1000000001706782304060163379; + bpsToRay[554] = 1000000001709786974743980088; + bpsToRay[555] = 1000000001712791360746325100; + bpsToRay[556] = 1000000001715795462121138343; + bpsToRay[557] = 1000000001718799278922344419; + bpsToRay[558] = 1000000001721802811203852608; + bpsToRay[559] = 1000000001724806059019556870; + bpsToRay[560] = 1000000001727809022423335855; + bpsToRay[561] = 1000000001730811701469052906; + bpsToRay[562] = 1000000001733814096210556068; + bpsToRay[563] = 1000000001736816206701678090; + bpsToRay[564] = 1000000001739818032996236434; + bpsToRay[565] = 1000000001742819575148033278; + bpsToRay[566] = 1000000001745820833210855527; + bpsToRay[567] = 1000000001748821807238474808; + bpsToRay[568] = 1000000001751822497284647491; + bpsToRay[569] = 1000000001754822903403114680; + bpsToRay[570] = 1000000001757823025647602229; + bpsToRay[571] = 1000000001760822864071820743; + bpsToRay[572] = 1000000001763822418729465585; + bpsToRay[573] = 1000000001766821689674216882; + bpsToRay[574] = 1000000001769820676959739530; + bpsToRay[575] = 1000000001772819380639683201; + bpsToRay[576] = 1000000001775817800767682345; + bpsToRay[577] = 1000000001778815937397356203; + bpsToRay[578] = 1000000001781813790582308807; + bpsToRay[579] = 1000000001784811360376128985; + bpsToRay[580] = 1000000001787808646832390371; + bpsToRay[581] = 1000000001790805650004651410; + bpsToRay[582] = 1000000001793802369946455358; + bpsToRay[583] = 1000000001796798806711330296; + bpsToRay[584] = 1000000001799794960352789133; + bpsToRay[585] = 1000000001802790830924329607; + bpsToRay[586] = 1000000001805786418479434295; + bpsToRay[587] = 1000000001808781723071570620; + bpsToRay[588] = 1000000001811776744754190855; + bpsToRay[589] = 1000000001814771483580732126; + bpsToRay[590] = 1000000001817765939604616422; + bpsToRay[591] = 1000000001820760112879250599; + bpsToRay[592] = 1000000001823754003458026386; + bpsToRay[593] = 1000000001826747611394320388; + bpsToRay[594] = 1000000001829740936741494099; + bpsToRay[595] = 1000000001832733979552893898; + bpsToRay[596] = 1000000001835726739881851062; + bpsToRay[597] = 1000000001838719217781681769; + bpsToRay[598] = 1000000001841711413305687103; + bpsToRay[599] = 1000000001844703326507153063; + bpsToRay[600] = 1000000001847694957439350562; + bpsToRay[601] = 1000000001850686306155535442; + bpsToRay[602] = 1000000001853677372708948472; + bpsToRay[603] = 1000000001856668157152815356; + bpsToRay[604] = 1000000001859658659540346741; + bpsToRay[605] = 1000000001862648879924738219; + bpsToRay[606] = 1000000001865638818359170337; + bpsToRay[607] = 1000000001868628474896808595; + bpsToRay[608] = 1000000001871617849590803463; + bpsToRay[609] = 1000000001874606942494290377; + bpsToRay[610] = 1000000001877595753660389747; + bpsToRay[611] = 1000000001880584283142206967; + bpsToRay[612] = 1000000001883572530992832417; + bpsToRay[613] = 1000000001886560497265341466; + bpsToRay[614] = 1000000001889548182012794484; + bpsToRay[615] = 1000000001892535585288236844; + bpsToRay[616] = 1000000001895522707144698926; + bpsToRay[617] = 1000000001898509547635196126; + bpsToRay[618] = 1000000001901496106812728862; + bpsToRay[619] = 1000000001904482384730282575; + bpsToRay[620] = 1000000001907468381440827740; + bpsToRay[621] = 1000000001910454096997319869; + bpsToRay[622] = 1000000001913439531452699514; + bpsToRay[623] = 1000000001916424684859892282; + bpsToRay[624] = 1000000001919409557271808825; + bpsToRay[625] = 1000000001922394148741344865; + bpsToRay[626] = 1000000001925378459321381181; + bpsToRay[627] = 1000000001928362489064783628; + bpsToRay[628] = 1000000001931346238024403135; + bpsToRay[629] = 1000000001934329706253075715; + bpsToRay[630] = 1000000001937312893803622469; + bpsToRay[631] = 1000000001940295800728849590; + bpsToRay[632] = 1000000001943278427081548373; + bpsToRay[633] = 1000000001946260772914495212; + bpsToRay[634] = 1000000001949242838280451618; + bpsToRay[635] = 1000000001952224623232164215; + bpsToRay[636] = 1000000001955206127822364746; + bpsToRay[637] = 1000000001958187352103770087; + bpsToRay[638] = 1000000001961168296129082241; + bpsToRay[639] = 1000000001964148959950988353; + bpsToRay[640] = 1000000001967129343622160710; + bpsToRay[641] = 1000000001970109447195256751; + bpsToRay[642] = 1000000001973089270722919065; + bpsToRay[643] = 1000000001976068814257775407; + bpsToRay[644] = 1000000001979048077852438695; + bpsToRay[645] = 1000000001982027061559507021; + bpsToRay[646] = 1000000001985005765431563653; + bpsToRay[647] = 1000000001987984189521177042; + bpsToRay[648] = 1000000001990962333880900827; + bpsToRay[649] = 1000000001993940198563273844; + bpsToRay[650] = 1000000001996917783620820123; + bpsToRay[651] = 1000000001999895089106048906; + bpsToRay[652] = 1000000002002872115071454639; + bpsToRay[653] = 1000000002005848861569516991; + bpsToRay[654] = 1000000002008825328652700847; + bpsToRay[655] = 1000000002011801516373456324; + bpsToRay[656] = 1000000002014777424784218768; + bpsToRay[657] = 1000000002017753053937408767; + bpsToRay[658] = 1000000002020728403885432150; + bpsToRay[659] = 1000000002023703474680679997; + bpsToRay[660] = 1000000002026678266375528644; + bpsToRay[661] = 1000000002029652779022339687; + bpsToRay[662] = 1000000002032627012673459986; + bpsToRay[663] = 1000000002035600967381221676; + bpsToRay[664] = 1000000002038574643197942168; + bpsToRay[665] = 1000000002041548040175924154; + bpsToRay[666] = 1000000002044521158367455616; + bpsToRay[667] = 1000000002047493997824809831; + bpsToRay[668] = 1000000002050466558600245373; + bpsToRay[669] = 1000000002053438840746006121; + bpsToRay[670] = 1000000002056410844314321266; + bpsToRay[671] = 1000000002059382569357405313; + bpsToRay[672] = 1000000002062354015927458089; + bpsToRay[673] = 1000000002065325184076664749; + bpsToRay[674] = 1000000002068296073857195778; + bpsToRay[675] = 1000000002071266685321207000; + bpsToRay[676] = 1000000002074237018520839584; + bpsToRay[677] = 1000000002077207073508220045; + bpsToRay[678] = 1000000002080176850335460252; + bpsToRay[679] = 1000000002083146349054657437; + bpsToRay[680] = 1000000002086115569717894196; + bpsToRay[681] = 1000000002089084512377238493; + bpsToRay[682] = 1000000002092053177084743673; + bpsToRay[683] = 1000000002095021563892448458; + bpsToRay[684] = 1000000002097989672852376961; + bpsToRay[685] = 1000000002100957504016538685; + bpsToRay[686] = 1000000002103925057436928532; + bpsToRay[687] = 1000000002106892333165526808; + bpsToRay[688] = 1000000002109859331254299227; + bpsToRay[689] = 1000000002112826051755196920; + bpsToRay[690] = 1000000002115792494720156434; + bpsToRay[691] = 1000000002118758660201099744; + bpsToRay[692] = 1000000002121724548249934257; + bpsToRay[693] = 1000000002124690158918552812; + bpsToRay[694] = 1000000002127655492258833695; + bpsToRay[695] = 1000000002130620548322640635; + bpsToRay[696] = 1000000002133585327161822816; + bpsToRay[697] = 1000000002136549828828214880; + bpsToRay[698] = 1000000002139514053373636932; + bpsToRay[699] = 1000000002142478000849894543; + bpsToRay[700] = 1000000002145441671308778766; + bpsToRay[701] = 1000000002148405064802066124; + bpsToRay[702] = 1000000002151368181381518635; + bpsToRay[703] = 1000000002154331021098883800; + bpsToRay[704] = 1000000002157293584005894622; + bpsToRay[705] = 1000000002160255870154269599; + bpsToRay[706] = 1000000002163217879595712742; + bpsToRay[707] = 1000000002166179612381913573; + bpsToRay[708] = 1000000002169141068564547128; + bpsToRay[709] = 1000000002172102248195273969; + bpsToRay[710] = 1000000002175063151325740189; + bpsToRay[711] = 1000000002178023778007577411; + bpsToRay[712] = 1000000002180984128292402799; + bpsToRay[713] = 1000000002183944202231819060; + bpsToRay[714] = 1000000002186903999877414455; + bpsToRay[715] = 1000000002189863521280762799; + bpsToRay[716] = 1000000002192822766493423465; + bpsToRay[717] = 1000000002195781735566941395; + bpsToRay[718] = 1000000002198740428552847104; + bpsToRay[719] = 1000000002201698845502656681; + bpsToRay[720] = 1000000002204656986467871801; + bpsToRay[721] = 1000000002207614851499979723; + bpsToRay[722] = 1000000002210572440650453302; + bpsToRay[723] = 1000000002213529753970750991; + bpsToRay[724] = 1000000002216486791512316847; + bpsToRay[725] = 1000000002219443553326580536; + bpsToRay[726] = 1000000002222400039464957340; + bpsToRay[727] = 1000000002225356249978848158; + bpsToRay[728] = 1000000002228312184919639519; + bpsToRay[729] = 1000000002231267844338703579; + bpsToRay[730] = 1000000002234223228287398132; + bpsToRay[731] = 1000000002237178336817066613; + bpsToRay[732] = 1000000002240133169979038105; + bpsToRay[733] = 1000000002243087727824627342; + bpsToRay[734] = 1000000002246042010405134715; + bpsToRay[735] = 1000000002248996017771846281; + bpsToRay[736] = 1000000002251949749976033760; + bpsToRay[737] = 1000000002254903207068954551; + bpsToRay[738] = 1000000002257856389101851730; + bpsToRay[739] = 1000000002260809296125954056; + bpsToRay[740] = 1000000002263761928192475979; + bpsToRay[741] = 1000000002266714285352617643; + bpsToRay[742] = 1000000002269666367657564895; + bpsToRay[743] = 1000000002272618175158489283; + bpsToRay[744] = 1000000002275569707906548069; + bpsToRay[745] = 1000000002278520965952884232; + bpsToRay[746] = 1000000002281471949348626470; + bpsToRay[747] = 1000000002284422658144889210; + bpsToRay[748] = 1000000002287373092392772609; + bpsToRay[749] = 1000000002290323252143362564; + bpsToRay[750] = 1000000002293273137447730714; + bpsToRay[751] = 1000000002296222748356934445; + bpsToRay[752] = 1000000002299172084922016896; + bpsToRay[753] = 1000000002302121147194006968; + bpsToRay[754] = 1000000002305069935223919323; + bpsToRay[755] = 1000000002308018449062754392; + bpsToRay[756] = 1000000002310966688761498383; + bpsToRay[757] = 1000000002313914654371123283; + bpsToRay[758] = 1000000002316862345942586863; + bpsToRay[759] = 1000000002319809763526832687; + bpsToRay[760] = 1000000002322756907174790110; + bpsToRay[761] = 1000000002325703776937374294; + bpsToRay[762] = 1000000002328650372865486203; + bpsToRay[763] = 1000000002331596695010012613; + bpsToRay[764] = 1000000002334542743421826121; + bpsToRay[765] = 1000000002337488518151785139; + bpsToRay[766] = 1000000002340434019250733913; + bpsToRay[767] = 1000000002343379246769502519; + bpsToRay[768] = 1000000002346324200758906870; + bpsToRay[769] = 1000000002349268881269748722; + bpsToRay[770] = 1000000002352213288352815683; + bpsToRay[771] = 1000000002355157422058881210; + bpsToRay[772] = 1000000002358101282438704622; + bpsToRay[773] = 1000000002361044869543031102; + bpsToRay[774] = 1000000002363988183422591701; + bpsToRay[775] = 1000000002366931224128103346; + bpsToRay[776] = 1000000002369873991710268842; + bpsToRay[777] = 1000000002372816486219776883; + bpsToRay[778] = 1000000002375758707707302048; + bpsToRay[779] = 1000000002378700656223504817; + bpsToRay[780] = 1000000002381642331819031568; + bpsToRay[781] = 1000000002384583734544514586; + bpsToRay[782] = 1000000002387524864450572064; + bpsToRay[783] = 1000000002390465721587808119; + bpsToRay[784] = 1000000002393406306006812783; + bpsToRay[785] = 1000000002396346617758162017; + bpsToRay[786] = 1000000002399286656892417716; + bpsToRay[787] = 1000000002402226423460127711; + bpsToRay[788] = 1000000002405165917511825773; + bpsToRay[789] = 1000000002408105139098031627; + bpsToRay[790] = 1000000002411044088269250946; + bpsToRay[791] = 1000000002413982765075975363; + bpsToRay[792] = 1000000002416921169568682475; + bpsToRay[793] = 1000000002419859301797835847; + bpsToRay[794] = 1000000002422797161813885017; + bpsToRay[795] = 1000000002425734749667265506; + bpsToRay[796] = 1000000002428672065408398813; + bpsToRay[797] = 1000000002431609109087692432; + bpsToRay[798] = 1000000002434545880755539850; + bpsToRay[799] = 1000000002437482380462320552; + bpsToRay[800] = 1000000002440418608258400030; + bpsToRay[801] = 1000000002443354564194129787; + bpsToRay[802] = 1000000002446290248319847339; + bpsToRay[803] = 1000000002449225660685876223; + bpsToRay[804] = 1000000002452160801342526004; + bpsToRay[805] = 1000000002455095670340092277; + bpsToRay[806] = 1000000002458030267728856671; + bpsToRay[807] = 1000000002460964593559086859; + bpsToRay[808] = 1000000002463898647881036558; + bpsToRay[809] = 1000000002466832430744945540; + bpsToRay[810] = 1000000002469765942201039630; + bpsToRay[811] = 1000000002472699182299530718; + bpsToRay[812] = 1000000002475632151090616757; + bpsToRay[813] = 1000000002478564848624481779; + bpsToRay[814] = 1000000002481497274951295886; + bpsToRay[815] = 1000000002484429430121215269; + bpsToRay[816] = 1000000002487361314184382201; + bpsToRay[817] = 1000000002490292927190925051; + bpsToRay[818] = 1000000002493224269190958287; + bpsToRay[819] = 1000000002496155340234582476; + bpsToRay[820] = 1000000002499086140371884298; + bpsToRay[821] = 1000000002502016669652936543; + bpsToRay[822] = 1000000002504946928127798122; + bpsToRay[823] = 1000000002507876915846514067; + bpsToRay[824] = 1000000002510806632859115540; + bpsToRay[825] = 1000000002513736079215619839; + bpsToRay[826] = 1000000002516665254966030398; + bpsToRay[827] = 1000000002519594160160336795; + bpsToRay[828] = 1000000002522522794848514761; + bpsToRay[829] = 1000000002525451159080526178; + bpsToRay[830] = 1000000002528379252906319086; + bpsToRay[831] = 1000000002531307076375827697; + bpsToRay[832] = 1000000002534234629538972383; + bpsToRay[833] = 1000000002537161912445659699; + bpsToRay[834] = 1000000002540088925145782374; + bpsToRay[835] = 1000000002543015667689219327; + bpsToRay[836] = 1000000002545942140125835662; + bpsToRay[837] = 1000000002548868342505482685; + bpsToRay[838] = 1000000002551794274877997894; + bpsToRay[839] = 1000000002554719937293204998; + bpsToRay[840] = 1000000002557645329800913916; + bpsToRay[841] = 1000000002560570452450920783; + bpsToRay[842] = 1000000002563495305293007952; + bpsToRay[843] = 1000000002566419888376944003; + bpsToRay[844] = 1000000002569344201752483747; + bpsToRay[845] = 1000000002572268245469368232; + bpsToRay[846] = 1000000002575192019577324747; + bpsToRay[847] = 1000000002578115524126066824; + bpsToRay[848] = 1000000002581038759165294249; + bpsToRay[849] = 1000000002583961724744693064; + bpsToRay[850] = 1000000002586884420913935572; + bpsToRay[851] = 1000000002589806847722680342; + bpsToRay[852] = 1000000002592729005220572215; + bpsToRay[853] = 1000000002595650893457242308; + bpsToRay[854] = 1000000002598572512482308019; + bpsToRay[855] = 1000000002601493862345373033; + bpsToRay[856] = 1000000002604414943096027328; + bpsToRay[857] = 1000000002607335754783847177; + bpsToRay[858] = 1000000002610256297458395155; + bpsToRay[859] = 1000000002613176571169220145; + bpsToRay[860] = 1000000002616096575965857340; + bpsToRay[861] = 1000000002619016311897828252; + bpsToRay[862] = 1000000002621935779014640712; + bpsToRay[863] = 1000000002624854977365788881; + bpsToRay[864] = 1000000002627773907000753250; + bpsToRay[865] = 1000000002630692567969000648; + bpsToRay[866] = 1000000002633610960319984247; + bpsToRay[867] = 1000000002636529084103143562; + bpsToRay[868] = 1000000002639446939367904465; + bpsToRay[869] = 1000000002642364526163679182; + bpsToRay[870] = 1000000002645281844539866303; + bpsToRay[871] = 1000000002648198894545850784; + bpsToRay[872] = 1000000002651115676231003954; + bpsToRay[873] = 1000000002654032189644683517; + bpsToRay[874] = 1000000002656948434836233563; + bpsToRay[875] = 1000000002659864411854984565; + bpsToRay[876] = 1000000002662780120750253393; + bpsToRay[877] = 1000000002665695561571343309; + bpsToRay[878] = 1000000002668610734367543981; + bpsToRay[879] = 1000000002671525639188131484; + bpsToRay[880] = 1000000002674440276082368302; + bpsToRay[881] = 1000000002677354645099503340; + bpsToRay[882] = 1000000002680268746288771923; + bpsToRay[883] = 1000000002683182579699395804; + bpsToRay[884] = 1000000002686096145380583168; + bpsToRay[885] = 1000000002689009443381528638; + bpsToRay[886] = 1000000002691922473751413277; + bpsToRay[887] = 1000000002694835236539404598; + bpsToRay[888] = 1000000002697747731794656564; + bpsToRay[889] = 1000000002700659959566309596; + bpsToRay[890] = 1000000002703571919903490575; + bpsToRay[891] = 1000000002706483612855312853; + bpsToRay[892] = 1000000002709395038470876252; + bpsToRay[893] = 1000000002712306196799267069; + bpsToRay[894] = 1000000002715217087889558088; + bpsToRay[895] = 1000000002718127711790808573; + bpsToRay[896] = 1000000002721038068552064286; + bpsToRay[897] = 1000000002723948158222357482; + bpsToRay[898] = 1000000002726857980850706921; + bpsToRay[899] = 1000000002729767536486117866; + bpsToRay[900] = 1000000002732676825177582095; + bpsToRay[901] = 1000000002735585846974077901; + bpsToRay[902] = 1000000002738494601924570098; + bpsToRay[903] = 1000000002741403090078010029; + bpsToRay[904] = 1000000002744311311483335565; + bpsToRay[905] = 1000000002747219266189471117; + bpsToRay[906] = 1000000002750126954245327636; + bpsToRay[907] = 1000000002753034375699802616; + bpsToRay[908] = 1000000002755941530601780109; + bpsToRay[909] = 1000000002758848419000130717; + bpsToRay[910] = 1000000002761755040943711607; + bpsToRay[911] = 1000000002764661396481366508; + bpsToRay[912] = 1000000002767567485661925724; + bpsToRay[913] = 1000000002770473308534206134; + bpsToRay[914] = 1000000002773378865147011196; + bpsToRay[915] = 1000000002776284155549130955; + bpsToRay[916] = 1000000002779189179789342046; + bpsToRay[917] = 1000000002782093937916407701; + bpsToRay[918] = 1000000002784998429979077750; + bpsToRay[919] = 1000000002787902656026088630; + bpsToRay[920] = 1000000002790806616106163389; + bpsToRay[921] = 1000000002793710310268011687; + bpsToRay[922] = 1000000002796613738560329808; + bpsToRay[923] = 1000000002799516901031800659; + bpsToRay[924] = 1000000002802419797731093776; + bpsToRay[925] = 1000000002805322428706865331; + bpsToRay[926] = 1000000002808224794007758136; + bpsToRay[927] = 1000000002811126893682401646; + bpsToRay[928] = 1000000002814028727779411968; + bpsToRay[929] = 1000000002816930296347391860; + bpsToRay[930] = 1000000002819831599434930742; + bpsToRay[931] = 1000000002822732637090604696; + bpsToRay[932] = 1000000002825633409362976474; + bpsToRay[933] = 1000000002828533916300595503; + bpsToRay[934] = 1000000002831434157951997885; + bpsToRay[935] = 1000000002834334134365706412; + bpsToRay[936] = 1000000002837233845590230556; + bpsToRay[937] = 1000000002840133291674066490; + bpsToRay[938] = 1000000002843032472665697081; + bpsToRay[939] = 1000000002845931388613591900; + bpsToRay[940] = 1000000002848830039566207226; + bpsToRay[941] = 1000000002851728425571986050; + bpsToRay[942] = 1000000002854626546679358084; + bpsToRay[943] = 1000000002857524402936739757; + bpsToRay[944] = 1000000002860421994392534231; + bpsToRay[945] = 1000000002863319321095131394; + bpsToRay[946] = 1000000002866216383092907878; + bpsToRay[947] = 1000000002869113180434227051; + bpsToRay[948] = 1000000002872009713167439031; + bpsToRay[949] = 1000000002874905981340880687; + bpsToRay[950] = 1000000002877801985002875644; + bpsToRay[951] = 1000000002880697724201734289; + bpsToRay[952] = 1000000002883593198985753772; + bpsToRay[953] = 1000000002886488409403218019; + bpsToRay[954] = 1000000002889383355502397729; + bpsToRay[955] = 1000000002892278037331550380; + bpsToRay[956] = 1000000002895172454938920238; + bpsToRay[957] = 1000000002898066608372738360; + bpsToRay[958] = 1000000002900960497681222594; + bpsToRay[959] = 1000000002903854122912577591; + bpsToRay[960] = 1000000002906747484114994807; + bpsToRay[961] = 1000000002909640581336652506; + bpsToRay[962] = 1000000002912533414625715766; + bpsToRay[963] = 1000000002915425984030336485; + bpsToRay[964] = 1000000002918318289598653387; + bpsToRay[965] = 1000000002921210331378792020; + bpsToRay[966] = 1000000002924102109418864770; + bpsToRay[967] = 1000000002926993623766970860; + bpsToRay[968] = 1000000002929884874471196354; + bpsToRay[969] = 1000000002932775861579614167; + bpsToRay[970] = 1000000002935666585140284065; + bpsToRay[971] = 1000000002938557045201252671; + bpsToRay[972] = 1000000002941447241810553473; + bpsToRay[973] = 1000000002944337175016206824; + bpsToRay[974] = 1000000002947226844866219949; + bpsToRay[975] = 1000000002950116251408586949; + bpsToRay[976] = 1000000002953005394691288810; + bpsToRay[977] = 1000000002955894274762293401; + bpsToRay[978] = 1000000002958782891669555482; + bpsToRay[979] = 1000000002961671245461016710; + bpsToRay[980] = 1000000002964559336184605642; + bpsToRay[981] = 1000000002967447163888237741; + bpsToRay[982] = 1000000002970334728619815381; + bpsToRay[983] = 1000000002973222030427227847; + bpsToRay[984] = 1000000002976109069358351348; + bpsToRay[985] = 1000000002978995845461049016; + bpsToRay[986] = 1000000002981882358783170911; + bpsToRay[987] = 1000000002984768609372554028; + bpsToRay[988] = 1000000002987654597277022302; + bpsToRay[989] = 1000000002990540322544386608; + bpsToRay[990] = 1000000002993425785222444772; + bpsToRay[991] = 1000000002996310985358981573; + bpsToRay[992] = 1000000002999195923001768747; + bpsToRay[993] = 1000000003002080598198564991; + bpsToRay[994] = 1000000003004965010997115971; + bpsToRay[995] = 1000000003007849161445154325; + bpsToRay[996] = 1000000003010733049590399667; + bpsToRay[997] = 1000000003013616675480558594; + bpsToRay[998] = 1000000003016500039163324684; + bpsToRay[999] = 1000000003019383140686378514; + bpsToRay[1000] = 1000000003022265980097387650; + bpsToRay[1001] = 1000000003025148557444006661; + bpsToRay[1002] = 1000000003028030872773877120; + bpsToRay[1003] = 1000000003030912926134627612; + bpsToRay[1004] = 1000000003033794717573873734; + bpsToRay[1005] = 1000000003036676247139218104; + bpsToRay[1006] = 1000000003039557514878250362; + bpsToRay[1007] = 1000000003042438520838547180; + bpsToRay[1008] = 1000000003045319265067672258; + bpsToRay[1009] = 1000000003048199747613176340; + bpsToRay[1010] = 1000000003051079968522597209; + bpsToRay[1011] = 1000000003053959927843459697; + bpsToRay[1012] = 1000000003056839625623275688; + bpsToRay[1013] = 1000000003059719061909544123; + bpsToRay[1014] = 1000000003062598236749751004; + bpsToRay[1015] = 1000000003065477150191369400; + bpsToRay[1016] = 1000000003068355802281859451; + bpsToRay[1017] = 1000000003071234193068668372; + bpsToRay[1018] = 1000000003074112322599230459; + bpsToRay[1019] = 1000000003076990190920967093; + bpsToRay[1020] = 1000000003079867798081286746; + bpsToRay[1021] = 1000000003082745144127584981; + bpsToRay[1022] = 1000000003085622229107244463; + bpsToRay[1023] = 1000000003088499053067634962; + bpsToRay[1024] = 1000000003091375616056113353; + bpsToRay[1025] = 1000000003094251918120023627; + bpsToRay[1026] = 1000000003097127959306696891; + bpsToRay[1027] = 1000000003100003739663451375; + bpsToRay[1028] = 1000000003102879259237592437; + bpsToRay[1029] = 1000000003105754518076412567; + bpsToRay[1030] = 1000000003108629516227191390; + bpsToRay[1031] = 1000000003111504253737195675; + bpsToRay[1032] = 1000000003114378730653679332; + bpsToRay[1033] = 1000000003117252947023883428; + bpsToRay[1034] = 1000000003120126902895036179; + bpsToRay[1035] = 1000000003123000598314352966; + bpsToRay[1036] = 1000000003125874033329036329; + bpsToRay[1037] = 1000000003128747207986275984; + bpsToRay[1038] = 1000000003131620122333248815; + bpsToRay[1039] = 1000000003134492776417118886; + bpsToRay[1040] = 1000000003137365170285037445; + bpsToRay[1041] = 1000000003140237303984142929; + bpsToRay[1042] = 1000000003143109177561560964; + bpsToRay[1043] = 1000000003145980791064404376; + bpsToRay[1044] = 1000000003148852144539773190; + bpsToRay[1045] = 1000000003151723238034754641; + bpsToRay[1046] = 1000000003154594071596423170; + bpsToRay[1047] = 1000000003157464645271840438; + bpsToRay[1048] = 1000000003160334959108055323; + bpsToRay[1049] = 1000000003163205013152103932; + bpsToRay[1050] = 1000000003166074807451009595; + bpsToRay[1051] = 1000000003168944342051782881; + bpsToRay[1052] = 1000000003171813617001421599; + bpsToRay[1053] = 1000000003174682632346910796; + bpsToRay[1054] = 1000000003177551388135222770; + bpsToRay[1055] = 1000000003180419884413317071; + bpsToRay[1056] = 1000000003183288121228140507; + bpsToRay[1057] = 1000000003186156098626627147; + bpsToRay[1058] = 1000000003189023816655698326; + bpsToRay[1059] = 1000000003191891275362262652; + bpsToRay[1060] = 1000000003194758474793216004; + bpsToRay[1061] = 1000000003197625414995441546; + bpsToRay[1062] = 1000000003200492096015809725; + bpsToRay[1063] = 1000000003203358517901178277; + bpsToRay[1064] = 1000000003206224680698392232; + bpsToRay[1065] = 1000000003209090584454283919; + bpsToRay[1066] = 1000000003211956229215672970; + bpsToRay[1067] = 1000000003214821615029366324; + bpsToRay[1068] = 1000000003217686741942158234; + bpsToRay[1069] = 1000000003220551610000830269; + bpsToRay[1070] = 1000000003223416219252151318; + bpsToRay[1071] = 1000000003226280569742877599; + bpsToRay[1072] = 1000000003229144661519752659; + bpsToRay[1073] = 1000000003232008494629507379; + bpsToRay[1074] = 1000000003234872069118859983; + bpsToRay[1075] = 1000000003237735385034516037; + bpsToRay[1076] = 1000000003240598442423168457; + bpsToRay[1077] = 1000000003243461241331497510; + bpsToRay[1078] = 1000000003246323781806170825; + bpsToRay[1079] = 1000000003249186063893843391; + bpsToRay[1080] = 1000000003252048087641157566; + bpsToRay[1081] = 1000000003254909853094743078; + bpsToRay[1082] = 1000000003257771360301217032; + bpsToRay[1083] = 1000000003260632609307183913; + bpsToRay[1084] = 1000000003263493600159235596; + bpsToRay[1085] = 1000000003266354332903951338; + bpsToRay[1086] = 1000000003269214807587897798; + bpsToRay[1087] = 1000000003272075024257629030; + bpsToRay[1088] = 1000000003274934982959686493; + bpsToRay[1089] = 1000000003277794683740599053; + bpsToRay[1090] = 1000000003280654126646882991; + bpsToRay[1091] = 1000000003283513311725042002; + bpsToRay[1092] = 1000000003286372239021567206; + bpsToRay[1093] = 1000000003289230908582937149; + bpsToRay[1094] = 1000000003292089320455617805; + bpsToRay[1095] = 1000000003294947474686062586; + bpsToRay[1096] = 1000000003297805371320712343; + bpsToRay[1097] = 1000000003300663010405995372; + bpsToRay[1098] = 1000000003303520391988327418; + bpsToRay[1099] = 1000000003306377516114111677; + bpsToRay[1100] = 1000000003309234382829738808; + bpsToRay[1101] = 1000000003312090992181586929; + bpsToRay[1102] = 1000000003314947344216021625; + bpsToRay[1103] = 1000000003317803438979395953; + bpsToRay[1104] = 1000000003320659276518050449; + bpsToRay[1105] = 1000000003323514856878313124; + bpsToRay[1106] = 1000000003326370180106499479; + bpsToRay[1107] = 1000000003329225246248912502; + bpsToRay[1108] = 1000000003332080055351842678; + bpsToRay[1109] = 1000000003334934607461567985; + bpsToRay[1110] = 1000000003337788902624353911; + bpsToRay[1111] = 1000000003340642940886453447; + bpsToRay[1112] = 1000000003343496722294107097; + bpsToRay[1113] = 1000000003346350246893542883; + bpsToRay[1114] = 1000000003349203514730976348; + bpsToRay[1115] = 1000000003352056525852610558; + bpsToRay[1116] = 1000000003354909280304636111; + bpsToRay[1117] = 1000000003357761778133231141; + bpsToRay[1118] = 1000000003360614019384561319; + bpsToRay[1119] = 1000000003363466004104779860; + bpsToRay[1120] = 1000000003366317732340027527; + bpsToRay[1121] = 1000000003369169204136432636; + bpsToRay[1122] = 1000000003372020419540111060; + bpsToRay[1123] = 1000000003374871378597166232; + bpsToRay[1124] = 1000000003377722081353689153; + bpsToRay[1125] = 1000000003380572527855758393; + bpsToRay[1126] = 1000000003383422718149440098; + bpsToRay[1127] = 1000000003386272652280787992; + bpsToRay[1128] = 1000000003389122330295843384; + bpsToRay[1129] = 1000000003391971752240635171; + bpsToRay[1130] = 1000000003394820918161179843; + bpsToRay[1131] = 1000000003397669828103481484; + bpsToRay[1132] = 1000000003400518482113531785; + bpsToRay[1133] = 1000000003403366880237310040; + bpsToRay[1134] = 1000000003406215022520783154; + bpsToRay[1135] = 1000000003409062909009905646; + bpsToRay[1136] = 1000000003411910539750619657; + bpsToRay[1137] = 1000000003414757914788854950; + bpsToRay[1138] = 1000000003417605034170528915; + bpsToRay[1139] = 1000000003420451897941546578; + bpsToRay[1140] = 1000000003423298506147800601; + bpsToRay[1141] = 1000000003426144858835171287; + bpsToRay[1142] = 1000000003428990956049526585; + bpsToRay[1143] = 1000000003431836797836722098; + bpsToRay[1144] = 1000000003434682384242601076; + bpsToRay[1145] = 1000000003437527715312994437; + bpsToRay[1146] = 1000000003440372791093720759; + bpsToRay[1147] = 1000000003443217611630586286; + bpsToRay[1148] = 1000000003446062176969384941; + bpsToRay[1149] = 1000000003448906487155898317; + bpsToRay[1150] = 1000000003451750542235895695; + bpsToRay[1151] = 1000000003454594342255134037; + bpsToRay[1152] = 1000000003457437887259357996; + bpsToRay[1153] = 1000000003460281177294299923; + bpsToRay[1154] = 1000000003463124212405679865; + bpsToRay[1155] = 1000000003465966992639205574; + bpsToRay[1156] = 1000000003468809518040572510; + bpsToRay[1157] = 1000000003471651788655463845; + bpsToRay[1158] = 1000000003474493804529550469; + bpsToRay[1159] = 1000000003477335565708490991; + bpsToRay[1160] = 1000000003480177072237931747; + bpsToRay[1161] = 1000000003483018324163506803; + bpsToRay[1162] = 1000000003485859321530837959; + bpsToRay[1163] = 1000000003488700064385534755; + bpsToRay[1164] = 1000000003491540552773194473; + bpsToRay[1165] = 1000000003494380786739402144; + bpsToRay[1166] = 1000000003497220766329730547; + bpsToRay[1167] = 1000000003500060491589740224; + bpsToRay[1168] = 1000000003502899962564979471; + bpsToRay[1169] = 1000000003505739179300984355; + bpsToRay[1170] = 1000000003508578141843278707; + bpsToRay[1171] = 1000000003511416850237374137; + bpsToRay[1172] = 1000000003514255304528770030; + bpsToRay[1173] = 1000000003517093504762953555; + bpsToRay[1174] = 1000000003519931450985399667; + bpsToRay[1175] = 1000000003522769143241571114; + bpsToRay[1176] = 1000000003525606581576918439; + bpsToRay[1177] = 1000000003528443766036879984; + bpsToRay[1178] = 1000000003531280696666881897; + bpsToRay[1179] = 1000000003534117373512338136; + bpsToRay[1180] = 1000000003536953796618650468; + bpsToRay[1181] = 1000000003539789966031208483; + bpsToRay[1182] = 1000000003542625881795389588; + bpsToRay[1183] = 1000000003545461543956559019; + bpsToRay[1184] = 1000000003548296952560069844; + bpsToRay[1185] = 1000000003551132107651262963; + bpsToRay[1186] = 1000000003553967009275467116; + bpsToRay[1187] = 1000000003556801657477998888; + bpsToRay[1188] = 1000000003559636052304162712; + bpsToRay[1189] = 1000000003562470193799250871; + bpsToRay[1190] = 1000000003565304082008543509; + bpsToRay[1191] = 1000000003568137716977308627; + bpsToRay[1192] = 1000000003570971098750802094; + bpsToRay[1193] = 1000000003573804227374267648; + bpsToRay[1194] = 1000000003576637102892936900; + bpsToRay[1195] = 1000000003579469725352029341; + bpsToRay[1196] = 1000000003582302094796752344; + bpsToRay[1197] = 1000000003585134211272301170; + bpsToRay[1198] = 1000000003587966074823858969; + bpsToRay[1199] = 1000000003590797685496596791; + bpsToRay[1200] = 1000000003593629043335673582; + bpsToRay[1201] = 1000000003596460148386236193; + bpsToRay[1202] = 1000000003599291000693419387; + bpsToRay[1203] = 1000000003602121600302345836; + bpsToRay[1204] = 1000000003604951947258126131; + bpsToRay[1205] = 1000000003607782041605858785; + bpsToRay[1206] = 1000000003610611883390630237; + bpsToRay[1207] = 1000000003613441472657514856; + bpsToRay[1208] = 1000000003616270809451574945; + bpsToRay[1209] = 1000000003619099893817860747; + bpsToRay[1210] = 1000000003621928725801410447; + bpsToRay[1211] = 1000000003624757305447250178; + bpsToRay[1212] = 1000000003627585632800394025; + bpsToRay[1213] = 1000000003630413707905844031; + bpsToRay[1214] = 1000000003633241530808590194; + bpsToRay[1215] = 1000000003636069101553610482; + bpsToRay[1216] = 1000000003638896420185870830; + bpsToRay[1217] = 1000000003641723486750325145; + bpsToRay[1218] = 1000000003644550301291915316; + bpsToRay[1219] = 1000000003647376863855571208; + bpsToRay[1220] = 1000000003650203174486210676; + bpsToRay[1221] = 1000000003653029233228739563; + bpsToRay[1222] = 1000000003655855040128051709; + bpsToRay[1223] = 1000000003658680595229028953; + bpsToRay[1224] = 1000000003661505898576541135; + bpsToRay[1225] = 1000000003664330950215446102; + bpsToRay[1226] = 1000000003667155750190589718; + bpsToRay[1227] = 1000000003669980298546805858; + bpsToRay[1228] = 1000000003672804595328916419; + bpsToRay[1229] = 1000000003675628640581731322; + bpsToRay[1230] = 1000000003678452434350048518; + bpsToRay[1231] = 1000000003681275976678653990; + bpsToRay[1232] = 1000000003684099267612321761; + bpsToRay[1233] = 1000000003686922307195813890; + bpsToRay[1234] = 1000000003689745095473880490; + bpsToRay[1235] = 1000000003692567632491259715; + bpsToRay[1236] = 1000000003695389918292677782; + bpsToRay[1237] = 1000000003698211952922848960; + bpsToRay[1238] = 1000000003701033736426475586; + bpsToRay[1239] = 1000000003703855268848248061; + bpsToRay[1240] = 1000000003706676550232844859; + bpsToRay[1241] = 1000000003709497580624932527; + bpsToRay[1242] = 1000000003712318360069165696; + bpsToRay[1243] = 1000000003715138888610187078; + bpsToRay[1244] = 1000000003717959166292627475; + bpsToRay[1245] = 1000000003720779193161105781; + bpsToRay[1246] = 1000000003723598969260228987; + bpsToRay[1247] = 1000000003726418494634592186; + bpsToRay[1248] = 1000000003729237769328778574; + bpsToRay[1249] = 1000000003732056793387359459; + bpsToRay[1250] = 1000000003734875566854894261; + bpsToRay[1251] = 1000000003737694089775930518; + bpsToRay[1252] = 1000000003740512362195003894; + bpsToRay[1253] = 1000000003743330384156638173; + bpsToRay[1254] = 1000000003746148155705345276; + bpsToRay[1255] = 1000000003748965676885625255; + bpsToRay[1256] = 1000000003751782947741966301; + bpsToRay[1257] = 1000000003754599968318844752; + bpsToRay[1258] = 1000000003757416738660725089; + bpsToRay[1259] = 1000000003760233258812059948; + bpsToRay[1260] = 1000000003763049528817290119; + bpsToRay[1261] = 1000000003765865548720844553; + bpsToRay[1262] = 1000000003768681318567140366; + bpsToRay[1263] = 1000000003771496838400582842; + bpsToRay[1264] = 1000000003774312108265565437; + bpsToRay[1265] = 1000000003777127128206469785; + bpsToRay[1266] = 1000000003779941898267665701; + bpsToRay[1267] = 1000000003782756418493511185; + bpsToRay[1268] = 1000000003785570688928352427; + bpsToRay[1269] = 1000000003788384709616523810; + bpsToRay[1270] = 1000000003791198480602347918; + bpsToRay[1271] = 1000000003794012001930135532; + bpsToRay[1272] = 1000000003796825273644185643; + bpsToRay[1273] = 1000000003799638295788785451; + bpsToRay[1274] = 1000000003802451068408210371; + bpsToRay[1275] = 1000000003805263591546724039; + bpsToRay[1276] = 1000000003808075865248578310; + bpsToRay[1277] = 1000000003810887889558013269; + bpsToRay[1278] = 1000000003813699664519257234; + bpsToRay[1279] = 1000000003816511190176526753; + bpsToRay[1280] = 1000000003819322466574026619; + bpsToRay[1281] = 1000000003822133493755949867; + bpsToRay[1282] = 1000000003824944271766477781; + bpsToRay[1283] = 1000000003827754800649779894; + bpsToRay[1284] = 1000000003830565080450014001; + bpsToRay[1285] = 1000000003833375111211326151; + bpsToRay[1286] = 1000000003836184892977850664; + bpsToRay[1287] = 1000000003838994425793710125; + bpsToRay[1288] = 1000000003841803709703015394; + bpsToRay[1289] = 1000000003844612744749865606; + bpsToRay[1290] = 1000000003847421530978348180; + bpsToRay[1291] = 1000000003850230068432538818; + bpsToRay[1292] = 1000000003853038357156501515; + bpsToRay[1293] = 1000000003855846397194288557; + bpsToRay[1294] = 1000000003858654188589940528; + bpsToRay[1295] = 1000000003861461731387486315; + bpsToRay[1296] = 1000000003864269025630943112; + bpsToRay[1297] = 1000000003867076071364316422; + bpsToRay[1298] = 1000000003869882868631600065; + bpsToRay[1299] = 1000000003872689417476776174; + bpsToRay[1300] = 1000000003875495717943815211; + bpsToRay[1301] = 1000000003878301770076675963; + bpsToRay[1302] = 1000000003881107573919305546; + bpsToRay[1303] = 1000000003883913129515639415; + bpsToRay[1304] = 1000000003886718436909601359; + bpsToRay[1305] = 1000000003889523496145103516; + bpsToRay[1306] = 1000000003892328307266046370; + bpsToRay[1307] = 1000000003895132870316318753; + bpsToRay[1308] = 1000000003897937185339797857; + bpsToRay[1309] = 1000000003900741252380349234; + bpsToRay[1310] = 1000000003903545071481826796; + bpsToRay[1311] = 1000000003906348642688072829; + bpsToRay[1312] = 1000000003909151966042917985; + bpsToRay[1313] = 1000000003911955041590181299; + bpsToRay[1314] = 1000000003914757869373670180; + bpsToRay[1315] = 1000000003917560449437180427; + bpsToRay[1316] = 1000000003920362781824496225; + bpsToRay[1317] = 1000000003923164866579390151; + bpsToRay[1318] = 1000000003925966703745623181; + bpsToRay[1319] = 1000000003928768293366944691; + bpsToRay[1320] = 1000000003931569635487092463; + bpsToRay[1321] = 1000000003934370730149792686; + bpsToRay[1322] = 1000000003937171577398759967; + bpsToRay[1323] = 1000000003939972177277697324; + bpsToRay[1324] = 1000000003942772529830296202; + bpsToRay[1325] = 1000000003945572635100236468; + bpsToRay[1326] = 1000000003948372493131186422; + bpsToRay[1327] = 1000000003951172103966802794; + bpsToRay[1328] = 1000000003953971467650730754; + bpsToRay[1329] = 1000000003956770584226603915; + bpsToRay[1330] = 1000000003959569453738044333; + bpsToRay[1331] = 1000000003962368076228662518; + bpsToRay[1332] = 1000000003965166451742057429; + bpsToRay[1333] = 1000000003967964580321816489; + bpsToRay[1334] = 1000000003970762462011515578; + bpsToRay[1335] = 1000000003973560096854719047; + bpsToRay[1336] = 1000000003976357484894979715; + bpsToRay[1337] = 1000000003979154626175838876; + bpsToRay[1338] = 1000000003981951520740826302; + bpsToRay[1339] = 1000000003984748168633460248; + bpsToRay[1340] = 1000000003987544569897247457; + bpsToRay[1341] = 1000000003990340724575683160; + bpsToRay[1342] = 1000000003993136632712251086; + bpsToRay[1343] = 1000000003995932294350423462; + bpsToRay[1344] = 1000000003998727709533661015; + bpsToRay[1345] = 1000000004001522878305412984; + bpsToRay[1346] = 1000000004004317800709117115; + bpsToRay[1347] = 1000000004007112476788199671; + bpsToRay[1348] = 1000000004009906906586075434; + bpsToRay[1349] = 1000000004012701090146147709; + bpsToRay[1350] = 1000000004015495027511808328; + bpsToRay[1351] = 1000000004018288718726437654; + bpsToRay[1352] = 1000000004021082163833404588; + bpsToRay[1353] = 1000000004023875362876066566; + bpsToRay[1354] = 1000000004026668315897769570; + bpsToRay[1355] = 1000000004029461022941848130; + bpsToRay[1356] = 1000000004032253484051625326; + bpsToRay[1357] = 1000000004035045699270412795; + bpsToRay[1358] = 1000000004037837668641510732; + bpsToRay[1359] = 1000000004040629392208207896; + bpsToRay[1360] = 1000000004043420870013781614; + bpsToRay[1361] = 1000000004046212102101497785; + bpsToRay[1362] = 1000000004049003088514610884; + bpsToRay[1363] = 1000000004051793829296363962; + bpsToRay[1364] = 1000000004054584324489988659; + bpsToRay[1365] = 1000000004057374574138705201; + bpsToRay[1366] = 1000000004060164578285722402; + bpsToRay[1367] = 1000000004062954336974237676; + bpsToRay[1368] = 1000000004065743850247437036; + bpsToRay[1369] = 1000000004068533118148495099; + bpsToRay[1370] = 1000000004071322140720575088; + bpsToRay[1371] = 1000000004074110918006828838; + bpsToRay[1372] = 1000000004076899450050396802; + bpsToRay[1373] = 1000000004079687736894408050; + bpsToRay[1374] = 1000000004082475778581980279; + bpsToRay[1375] = 1000000004085263575156219812; + bpsToRay[1376] = 1000000004088051126660221602; + bpsToRay[1377] = 1000000004090838433137069242; + bpsToRay[1378] = 1000000004093625494629834960; + bpsToRay[1379] = 1000000004096412311181579631; + bpsToRay[1380] = 1000000004099198882835352777; + bpsToRay[1381] = 1000000004101985209634192573; + bpsToRay[1382] = 1000000004104771291621125847; + bpsToRay[1383] = 1000000004107557128839168089; + bpsToRay[1384] = 1000000004110342721331323451; + bpsToRay[1385] = 1000000004113128069140584754; + bpsToRay[1386] = 1000000004115913172309933491; + bpsToRay[1387] = 1000000004118698030882339831; + bpsToRay[1388] = 1000000004121482644900762619; + bpsToRay[1389] = 1000000004124267014408149388; + bpsToRay[1390] = 1000000004127051139447436357; + bpsToRay[1391] = 1000000004129835020061548436; + bpsToRay[1392] = 1000000004132618656293399231; + bpsToRay[1393] = 1000000004135402048185891048; + bpsToRay[1394] = 1000000004138185195781914895; + bpsToRay[1395] = 1000000004140968099124350490; + bpsToRay[1396] = 1000000004143750758256066259; + bpsToRay[1397] = 1000000004146533173219919347; + bpsToRay[1398] = 1000000004149315344058755615; + bpsToRay[1399] = 1000000004152097270815409650; + bpsToRay[1400] = 1000000004154878953532704765; + bpsToRay[1401] = 1000000004157660392253453003; + bpsToRay[1402] = 1000000004160441587020455146; + bpsToRay[1403] = 1000000004163222537876500710; + bpsToRay[1404] = 1000000004166003244864367958; + bpsToRay[1405] = 1000000004168783708026823899; + bpsToRay[1406] = 1000000004171563927406624291; + bpsToRay[1407] = 1000000004174343903046513649; + bpsToRay[1408] = 1000000004177123634989225246; + bpsToRay[1409] = 1000000004179903123277481120; + bpsToRay[1410] = 1000000004182682367953992073; + bpsToRay[1411] = 1000000004185461369061457677; + bpsToRay[1412] = 1000000004188240126642566281; + bpsToRay[1413] = 1000000004191018640739995012; + bpsToRay[1414] = 1000000004193796911396409779; + bpsToRay[1415] = 1000000004196574938654465277; + bpsToRay[1416] = 1000000004199352722556804991; + bpsToRay[1417] = 1000000004202130263146061203; + bpsToRay[1418] = 1000000004204907560464854990; + bpsToRay[1419] = 1000000004207684614555796231; + bpsToRay[1420] = 1000000004210461425461483615; + bpsToRay[1421] = 1000000004213237993224504637; + bpsToRay[1422] = 1000000004216014317887435608; + bpsToRay[1423] = 1000000004218790399492841653; + bpsToRay[1424] = 1000000004221566238083276725; + bpsToRay[1425] = 1000000004224341833701283597; + bpsToRay[1426] = 1000000004227117186389393875; + bpsToRay[1427] = 1000000004229892296190127996; + bpsToRay[1428] = 1000000004232667163145995236; + bpsToRay[1429] = 1000000004235441787299493712; + bpsToRay[1430] = 1000000004238216168693110386; + bpsToRay[1431] = 1000000004240990307369321069; + bpsToRay[1432] = 1000000004243764203370590423; + bpsToRay[1433] = 1000000004246537856739371971; + bpsToRay[1434] = 1000000004249311267518108094; + bpsToRay[1435] = 1000000004252084435749230038; + bpsToRay[1436] = 1000000004254857361475157917; + bpsToRay[1437] = 1000000004257630044738300719; + bpsToRay[1438] = 1000000004260402485581056307; + bpsToRay[1439] = 1000000004263174684045811425; + bpsToRay[1440] = 1000000004265946640174941701; + bpsToRay[1441] = 1000000004268718354010811651; + bpsToRay[1442] = 1000000004271489825595774681; + bpsToRay[1443] = 1000000004274261054972173095; + bpsToRay[1444] = 1000000004277032042182338097; + bpsToRay[1445] = 1000000004279802787268589794; + bpsToRay[1446] = 1000000004282573290273237200; + bpsToRay[1447] = 1000000004285343551238578238; + bpsToRay[1448] = 1000000004288113570206899751; + bpsToRay[1449] = 1000000004290883347220477497; + bpsToRay[1450] = 1000000004293652882321576158; + bpsToRay[1451] = 1000000004296422175552449345; + bpsToRay[1452] = 1000000004299191226955339597; + bpsToRay[1453] = 1000000004301960036572478387; + bpsToRay[1454] = 1000000004304728604446086130; + bpsToRay[1455] = 1000000004307496930618372179; + bpsToRay[1456] = 1000000004310265015131534834; + bpsToRay[1457] = 1000000004313032858027761349; + bpsToRay[1458] = 1000000004315800459349227927; + bpsToRay[1459] = 1000000004318567819138099730; + bpsToRay[1460] = 1000000004321334937436530883; + bpsToRay[1461] = 1000000004324101814286664475; + bpsToRay[1462] = 1000000004326868449730632563; + bpsToRay[1463] = 1000000004329634843810556180; + bpsToRay[1464] = 1000000004332400996568545334; + bpsToRay[1465] = 1000000004335166908046699016; + bpsToRay[1466] = 1000000004337932578287105196; + bpsToRay[1467] = 1000000004340698007331840840; + bpsToRay[1468] = 1000000004343463195222971901; + bpsToRay[1469] = 1000000004346228142002553329; + bpsToRay[1470] = 1000000004348992847712629077; + bpsToRay[1471] = 1000000004351757312395232098; + bpsToRay[1472] = 1000000004354521536092384354; + bpsToRay[1473] = 1000000004357285518846096818; + bpsToRay[1474] = 1000000004360049260698369481; + bpsToRay[1475] = 1000000004362812761691191350; + bpsToRay[1476] = 1000000004365576021866540454; + bpsToRay[1477] = 1000000004368339041266383854; + bpsToRay[1478] = 1000000004371101819932677638; + bpsToRay[1479] = 1000000004373864357907366926; + bpsToRay[1480] = 1000000004376626655232385882; + bpsToRay[1481] = 1000000004379388711949657709; + bpsToRay[1482] = 1000000004382150528101094654; + bpsToRay[1483] = 1000000004384912103728598017; + bpsToRay[1484] = 1000000004387673438874058150; + bpsToRay[1485] = 1000000004390434533579354464; + bpsToRay[1486] = 1000000004393195387886355428; + bpsToRay[1487] = 1000000004395956001836918578; + bpsToRay[1488] = 1000000004398716375472890520; + bpsToRay[1489] = 1000000004401476508836106929; + bpsToRay[1490] = 1000000004404236401968392559; + bpsToRay[1491] = 1000000004406996054911561245; + bpsToRay[1492] = 1000000004409755467707415902; + bpsToRay[1493] = 1000000004412514640397748538; + bpsToRay[1494] = 1000000004415273573024340248; + bpsToRay[1495] = 1000000004418032265628961226; + bpsToRay[1496] = 1000000004420790718253370761; + bpsToRay[1497] = 1000000004423548930939317250; + bpsToRay[1498] = 1000000004426306903728538193; + bpsToRay[1499] = 1000000004429064636662760200; + bpsToRay[1500] = 1000000004431822129783699001; + bpsToRay[1501] = 1000000004434579383133059436; + bpsToRay[1502] = 1000000004437336396752535473; + bpsToRay[1503] = 1000000004440093170683810203; + bpsToRay[1504] = 1000000004442849704968555849; + bpsToRay[1505] = 1000000004445605999648433763; + bpsToRay[1506] = 1000000004448362054765094438; + bpsToRay[1507] = 1000000004451117870360177505; + bpsToRay[1508] = 1000000004453873446475311742; + bpsToRay[1509] = 1000000004456628783152115072; + bpsToRay[1510] = 1000000004459383880432194574; + bpsToRay[1511] = 1000000004462138738357146482; + bpsToRay[1512] = 1000000004464893356968556186; + bpsToRay[1513] = 1000000004467647736307998245; + bpsToRay[1514] = 1000000004470401876417036380; + bpsToRay[1515] = 1000000004473155777337223487; + bpsToRay[1516] = 1000000004475909439110101633; + bpsToRay[1517] = 1000000004478662861777202067; + bpsToRay[1518] = 1000000004481416045380045219; + bpsToRay[1519] = 1000000004484168989960140704; + bpsToRay[1520] = 1000000004486921695558987326; + bpsToRay[1521] = 1000000004489674162218073087; + bpsToRay[1522] = 1000000004492426389978875180; + bpsToRay[1523] = 1000000004495178378882860004; + bpsToRay[1524] = 1000000004497930128971483160; + bpsToRay[1525] = 1000000004500681640286189459; + bpsToRay[1526] = 1000000004503432912868412922; + bpsToRay[1527] = 1000000004506183946759576791; + bpsToRay[1528] = 1000000004508934742001093521; + bpsToRay[1529] = 1000000004511685298634364794; + bpsToRay[1530] = 1000000004514435616700781520; + bpsToRay[1531] = 1000000004517185696241723838; + bpsToRay[1532] = 1000000004519935537298561123; + bpsToRay[1533] = 1000000004522685139912651989; + bpsToRay[1534] = 1000000004525434504125344289; + bpsToRay[1535] = 1000000004528183629977975125; + bpsToRay[1536] = 1000000004530932517511870847; + bpsToRay[1537] = 1000000004533681166768347059; + bpsToRay[1538] = 1000000004536429577788708623; + bpsToRay[1539] = 1000000004539177750614249659; + bpsToRay[1540] = 1000000004541925685286253554; + bpsToRay[1541] = 1000000004544673381845992962; + bpsToRay[1542] = 1000000004547420840334729810; + bpsToRay[1543] = 1000000004550168060793715299; + bpsToRay[1544] = 1000000004552915043264189911; + bpsToRay[1545] = 1000000004555661787787383409; + bpsToRay[1546] = 1000000004558408294404514847; + bpsToRay[1547] = 1000000004561154563156792564; + bpsToRay[1548] = 1000000004563900594085414197; + bpsToRay[1549] = 1000000004566646387231566680; + bpsToRay[1550] = 1000000004569391942636426248; + bpsToRay[1551] = 1000000004572137260341158442; + bpsToRay[1552] = 1000000004574882340386918113; + bpsToRay[1553] = 1000000004577627182814849422; + bpsToRay[1554] = 1000000004580371787666085848; + bpsToRay[1555] = 1000000004583116154981750191; + bpsToRay[1556] = 1000000004585860284802954574; + bpsToRay[1557] = 1000000004588604177170800448; + bpsToRay[1558] = 1000000004591347832126378593; + bpsToRay[1559] = 1000000004594091249710769128; + bpsToRay[1560] = 1000000004596834429965041505; + bpsToRay[1561] = 1000000004599577372930254526; + bpsToRay[1562] = 1000000004602320078647456331; + bpsToRay[1563] = 1000000004605062547157684415; + bpsToRay[1564] = 1000000004607804778501965623; + bpsToRay[1565] = 1000000004610546772721316162; + bpsToRay[1566] = 1000000004613288529856741593; + bpsToRay[1567] = 1000000004616030049949236846; + bpsToRay[1568] = 1000000004618771333039786217; + bpsToRay[1569] = 1000000004621512379169363376; + bpsToRay[1570] = 1000000004624253188378931367; + bpsToRay[1571] = 1000000004626993760709442611; + bpsToRay[1572] = 1000000004629734096201838917; + bpsToRay[1573] = 1000000004632474194897051476; + bpsToRay[1574] = 1000000004635214056836000869; + bpsToRay[1575] = 1000000004637953682059597074; + bpsToRay[1576] = 1000000004640693070608739463; + bpsToRay[1577] = 1000000004643432222524316813; + bpsToRay[1578] = 1000000004646171137847207302; + bpsToRay[1579] = 1000000004648909816618278519; + bpsToRay[1580] = 1000000004651648258878387462; + bpsToRay[1581] = 1000000004654386464668380549; + bpsToRay[1582] = 1000000004657124434029093614; + bpsToRay[1583] = 1000000004659862167001351915; + bpsToRay[1584] = 1000000004662599663625970138; + bpsToRay[1585] = 1000000004665336923943752398; + bpsToRay[1586] = 1000000004668073947995492244; + bpsToRay[1587] = 1000000004670810735821972662; + bpsToRay[1588] = 1000000004673547287463966083; + bpsToRay[1589] = 1000000004676283602962234377; + bpsToRay[1590] = 1000000004679019682357528867; + bpsToRay[1591] = 1000000004681755525690590328; + bpsToRay[1592] = 1000000004684491133002148989; + bpsToRay[1593] = 1000000004687226504332924539; + bpsToRay[1594] = 1000000004689961639723626131; + bpsToRay[1595] = 1000000004692696539214952384; + bpsToRay[1596] = 1000000004695431202847591388; + bpsToRay[1597] = 1000000004698165630662220707; + bpsToRay[1598] = 1000000004700899822699507381; + bpsToRay[1599] = 1000000004703633779000107935; + bpsToRay[1600] = 1000000004706367499604668374; + bpsToRay[1601] = 1000000004709100984553824197; + bpsToRay[1602] = 1000000004711834233888200390; + bpsToRay[1603] = 1000000004714567247648411439; + bpsToRay[1604] = 1000000004717300025875061327; + bpsToRay[1605] = 1000000004720032568608743539; + bpsToRay[1606] = 1000000004722764875890041071; + bpsToRay[1607] = 1000000004725496947759526424; + bpsToRay[1608] = 1000000004728228784257761617; + bpsToRay[1609] = 1000000004730960385425298185; + bpsToRay[1610] = 1000000004733691751302677184; + bpsToRay[1611] = 1000000004736422881930429194; + bpsToRay[1612] = 1000000004739153777349074326; + bpsToRay[1613] = 1000000004741884437599122219; + bpsToRay[1614] = 1000000004744614862721072050; + bpsToRay[1615] = 1000000004747345052755412536; + bpsToRay[1616] = 1000000004750075007742621934; + bpsToRay[1617] = 1000000004752804727723168051; + bpsToRay[1618] = 1000000004755534212737508240; + bpsToRay[1619] = 1000000004758263462826089409; + bpsToRay[1620] = 1000000004760992478029348025; + bpsToRay[1621] = 1000000004763721258387710114; + bpsToRay[1622] = 1000000004766449803941591267; + bpsToRay[1623] = 1000000004769178114731396642; + bpsToRay[1624] = 1000000004771906190797520968; + bpsToRay[1625] = 1000000004774634032180348552; + bpsToRay[1626] = 1000000004777361638920253278; + bpsToRay[1627] = 1000000004780089011057598610; + bpsToRay[1628] = 1000000004782816148632737601; + bpsToRay[1629] = 1000000004785543051686012893; + bpsToRay[1630] = 1000000004788269720257756721; + bpsToRay[1631] = 1000000004790996154388290915; + bpsToRay[1632] = 1000000004793722354117926905; + bpsToRay[1633] = 1000000004796448319486965728; + bpsToRay[1634] = 1000000004799174050535698027; + bpsToRay[1635] = 1000000004801899547304404054; + bpsToRay[1636] = 1000000004804624809833353677; + bpsToRay[1637] = 1000000004807349838162806381; + bpsToRay[1638] = 1000000004810074632333011275; + bpsToRay[1639] = 1000000004812799192384207089; + bpsToRay[1640] = 1000000004815523518356622187; + bpsToRay[1641] = 1000000004818247610290474561; + bpsToRay[1642] = 1000000004820971468225971842; + bpsToRay[1643] = 1000000004823695092203311297; + bpsToRay[1644] = 1000000004826418482262679840; + bpsToRay[1645] = 1000000004829141638444254028; + bpsToRay[1646] = 1000000004831864560788200070; + bpsToRay[1647] = 1000000004834587249334673829; + bpsToRay[1648] = 1000000004837309704123820822; + bpsToRay[1649] = 1000000004840031925195776232; + bpsToRay[1650] = 1000000004842753912590664903; + bpsToRay[1651] = 1000000004845475666348601346; + bpsToRay[1652] = 1000000004848197186509689746; + bpsToRay[1653] = 1000000004850918473114023962; + bpsToRay[1654] = 1000000004853639526201687531; + bpsToRay[1655] = 1000000004856360345812753672; + bpsToRay[1656] = 1000000004859080931987285289; + bpsToRay[1657] = 1000000004861801284765334978; + bpsToRay[1658] = 1000000004864521404186945026; + bpsToRay[1659] = 1000000004867241290292147414; + bpsToRay[1660] = 1000000004869960943120963825; + bpsToRay[1661] = 1000000004872680362713405646; + bpsToRay[1662] = 1000000004875399549109473969; + bpsToRay[1663] = 1000000004878118502349159596; + bpsToRay[1664] = 1000000004880837222472443046; + bpsToRay[1665] = 1000000004883555709519294552; + bpsToRay[1666] = 1000000004886273963529674069; + bpsToRay[1667] = 1000000004888991984543531278; + bpsToRay[1668] = 1000000004891709772600805585; + bpsToRay[1669] = 1000000004894427327741426131; + bpsToRay[1670] = 1000000004897144650005311787; + bpsToRay[1671] = 1000000004899861739432371169; + bpsToRay[1672] = 1000000004902578596062502630; + bpsToRay[1673] = 1000000004905295219935594269; + bpsToRay[1674] = 1000000004908011611091523937; + bpsToRay[1675] = 1000000004910727769570159235; + bpsToRay[1676] = 1000000004913443695411357522; + bpsToRay[1677] = 1000000004916159388654965915; + bpsToRay[1678] = 1000000004918874849340821294; + bpsToRay[1679] = 1000000004921590077508750306; + bpsToRay[1680] = 1000000004924305073198569369; + bpsToRay[1681] = 1000000004927019836450084674; + bpsToRay[1682] = 1000000004929734367303092189; + bpsToRay[1683] = 1000000004932448665797377662; + bpsToRay[1684] = 1000000004935162731972716627; + bpsToRay[1685] = 1000000004937876565868874403; + bpsToRay[1686] = 1000000004940590167525606103; + bpsToRay[1687] = 1000000004943303536982656633; + bpsToRay[1688] = 1000000004946016674279760695; + bpsToRay[1689] = 1000000004948729579456642798; + bpsToRay[1690] = 1000000004951442252553017251; + bpsToRay[1691] = 1000000004954154693608588174; + bpsToRay[1692] = 1000000004956866902663049499; + bpsToRay[1693] = 1000000004959578879756084972; + bpsToRay[1694] = 1000000004962290624927368160; + bpsToRay[1695] = 1000000004965002138216562451; + bpsToRay[1696] = 1000000004967713419663321060; + bpsToRay[1697] = 1000000004970424469307287030; + bpsToRay[1698] = 1000000004973135287188093241; + bpsToRay[1699] = 1000000004975845873345362402; + bpsToRay[1700] = 1000000004978556227818707070; + bpsToRay[1701] = 1000000004981266350647729640; + bpsToRay[1702] = 1000000004983976241872022356; + bpsToRay[1703] = 1000000004986685901531167312; + bpsToRay[1704] = 1000000004989395329664736455; + bpsToRay[1705] = 1000000004992104526312291591; + bpsToRay[1706] = 1000000004994813491513384383; + bpsToRay[1707] = 1000000004997522225307556365; + bpsToRay[1708] = 1000000005000230727734338930; + bpsToRay[1709] = 1000000005002938998833253350; + bpsToRay[1710] = 1000000005005647038643810765; + bpsToRay[1711] = 1000000005008354847205512199; + bpsToRay[1712] = 1000000005011062424557848553; + bpsToRay[1713] = 1000000005013769770740300614; + bpsToRay[1714] = 1000000005016476885792339060; + bpsToRay[1715] = 1000000005019183769753424457; + bpsToRay[1716] = 1000000005021890422663007268; + bpsToRay[1717] = 1000000005024596844560527854; + bpsToRay[1718] = 1000000005027303035485416482; + bpsToRay[1719] = 1000000005030008995477093319; + bpsToRay[1720] = 1000000005032714724574968444; + bpsToRay[1721] = 1000000005035420222818441850; + bpsToRay[1722] = 1000000005038125490246903442; + bpsToRay[1723] = 1000000005040830526899733047; + bpsToRay[1724] = 1000000005043535332816300415; + bpsToRay[1725] = 1000000005046239908035965222; + bpsToRay[1726] = 1000000005048944252598077073; + bpsToRay[1727] = 1000000005051648366541975506; + bpsToRay[1728] = 1000000005054352249906989998; + bpsToRay[1729] = 1000000005057055902732439961; + bpsToRay[1730] = 1000000005059759325057634757; + bpsToRay[1731] = 1000000005062462516921873690; + bpsToRay[1732] = 1000000005065165478364446016; + bpsToRay[1733] = 1000000005067868209424630945; + bpsToRay[1734] = 1000000005070570710141697643; + bpsToRay[1735] = 1000000005073272980554905239; + bpsToRay[1736] = 1000000005075975020703502822; + bpsToRay[1737] = 1000000005078676830626729453; + bpsToRay[1738] = 1000000005081378410363814160; + bpsToRay[1739] = 1000000005084079759953975947; + bpsToRay[1740] = 1000000005086780879436423797; + bpsToRay[1741] = 1000000005089481768850356672; + bpsToRay[1742] = 1000000005092182428234963519; + bpsToRay[1743] = 1000000005094882857629423273; + bpsToRay[1744] = 1000000005097583057072904861; + bpsToRay[1745] = 1000000005100283026604567203; + bpsToRay[1746] = 1000000005102982766263559220; + bpsToRay[1747] = 1000000005105682276089019831; + bpsToRay[1748] = 1000000005108381556120077964; + bpsToRay[1749] = 1000000005111080606395852551; + bpsToRay[1750] = 1000000005113779426955452540; + bpsToRay[1751] = 1000000005116478017837976890; + bpsToRay[1752] = 1000000005119176379082514583; + bpsToRay[1753] = 1000000005121874510728144619; + bpsToRay[1754] = 1000000005124572412813936025; + bpsToRay[1755] = 1000000005127270085378947858; + bpsToRay[1756] = 1000000005129967528462229205; + bpsToRay[1757] = 1000000005132664742102819189; + bpsToRay[1758] = 1000000005135361726339746974; + bpsToRay[1759] = 1000000005138058481212031762; + bpsToRay[1760] = 1000000005140755006758682806; + bpsToRay[1761] = 1000000005143451303018699404; + bpsToRay[1762] = 1000000005146147370031070909; + bpsToRay[1763] = 1000000005148843207834776727; + bpsToRay[1764] = 1000000005151538816468786327; + bpsToRay[1765] = 1000000005154234195972059237; + bpsToRay[1766] = 1000000005156929346383545054; + bpsToRay[1767] = 1000000005159624267742183441; + bpsToRay[1768] = 1000000005162318960086904137; + bpsToRay[1769] = 1000000005165013423456626957; + bpsToRay[1770] = 1000000005167707657890261792; + bpsToRay[1771] = 1000000005170401663426708619; + bpsToRay[1772] = 1000000005173095440104857501; + bpsToRay[1773] = 1000000005175788987963588589; + bpsToRay[1774] = 1000000005178482307041772129; + bpsToRay[1775] = 1000000005181175397378268462; + bpsToRay[1776] = 1000000005183868259011928028; + bpsToRay[1777] = 1000000005186560891981591373; + bpsToRay[1778] = 1000000005189253296326089147; + bpsToRay[1779] = 1000000005191945472084242108; + bpsToRay[1780] = 1000000005194637419294861132; + bpsToRay[1781] = 1000000005197329137996747207; + bpsToRay[1782] = 1000000005200020628228691445; + bpsToRay[1783] = 1000000005202711890029475077; + bpsToRay[1784] = 1000000005205402923437869462; + bpsToRay[1785] = 1000000005208093728492636093; + bpsToRay[1786] = 1000000005210784305232526588; + bpsToRay[1787] = 1000000005213474653696282710; + bpsToRay[1788] = 1000000005216164773922636357; + bpsToRay[1789] = 1000000005218854665950309569; + bpsToRay[1790] = 1000000005221544329818014540; + bpsToRay[1791] = 1000000005224233765564453606; + bpsToRay[1792] = 1000000005226922973228319260; + bpsToRay[1793] = 1000000005229611952848294151; + bpsToRay[1794] = 1000000005232300704463051089; + bpsToRay[1795] = 1000000005234989228111253046; + bpsToRay[1796] = 1000000005237677523831553161; + bpsToRay[1797] = 1000000005240365591662594745; + bpsToRay[1798] = 1000000005243053431643011277; + bpsToRay[1799] = 1000000005245741043811426420; + bpsToRay[1800] = 1000000005248428428206454010; + bpsToRay[1801] = 1000000005251115584866698073; + bpsToRay[1802] = 1000000005253802513830752815; + bpsToRay[1803] = 1000000005256489215137202638; + bpsToRay[1804] = 1000000005259175688824622133; + bpsToRay[1805] = 1000000005261861934931576089; + bpsToRay[1806] = 1000000005264547953496619496; + bpsToRay[1807] = 1000000005267233744558297546; + bpsToRay[1808] = 1000000005269919308155145638; + bpsToRay[1809] = 1000000005272604644325689381; + bpsToRay[1810] = 1000000005275289753108444598; + bpsToRay[1811] = 1000000005277974634541917328; + bpsToRay[1812] = 1000000005280659288664603827; + bpsToRay[1813] = 1000000005283343715514990579; + bpsToRay[1814] = 1000000005286027915131554292; + bpsToRay[1815] = 1000000005288711887552761904; + bpsToRay[1816] = 1000000005291395632817070587; + bpsToRay[1817] = 1000000005294079150962927745; + bpsToRay[1818] = 1000000005296762442028771030; + bpsToRay[1819] = 1000000005299445506053028330; + bpsToRay[1820] = 1000000005302128343074117781; + bpsToRay[1821] = 1000000005304810953130447770; + bpsToRay[1822] = 1000000005307493336260416936; + bpsToRay[1823] = 1000000005310175492502414174; + bpsToRay[1824] = 1000000005312857421894818640; + bpsToRay[1825] = 1000000005315539124475999751; + bpsToRay[1826] = 1000000005318220600284317191; + bpsToRay[1827] = 1000000005320901849358120913; + bpsToRay[1828] = 1000000005323582871735751141; + bpsToRay[1829] = 1000000005326263667455538381; + bpsToRay[1830] = 1000000005328944236555803409; + bpsToRay[1831] = 1000000005331624579074857293; + bpsToRay[1832] = 1000000005334304695051001381; + bpsToRay[1833] = 1000000005336984584522527310; + bpsToRay[1834] = 1000000005339664247527717012; + bpsToRay[1835] = 1000000005342343684104842714; + bpsToRay[1836] = 1000000005345022894292166942; + bpsToRay[1837] = 1000000005347701878127942522; + bpsToRay[1838] = 1000000005350380635650412590; + bpsToRay[1839] = 1000000005353059166897810586; + bpsToRay[1840] = 1000000005355737471908360264; + bpsToRay[1841] = 1000000005358415550720275695; + bpsToRay[1842] = 1000000005361093403371761268; + bpsToRay[1843] = 1000000005363771029901011690; + bpsToRay[1844] = 1000000005366448430346211998; + bpsToRay[1845] = 1000000005369125604745537555; + bpsToRay[1846] = 1000000005371802553137154057; + bpsToRay[1847] = 1000000005374479275559217533; + bpsToRay[1848] = 1000000005377155772049874353; + bpsToRay[1849] = 1000000005379832042647261225; + bpsToRay[1850] = 1000000005382508087389505206; + bpsToRay[1851] = 1000000005385183906314723696; + bpsToRay[1852] = 1000000005387859499461024450; + bpsToRay[1853] = 1000000005390534866866505578; + bpsToRay[1854] = 1000000005393210008569255543; + bpsToRay[1855] = 1000000005395884924607353174; + bpsToRay[1856] = 1000000005398559615018867662; + bpsToRay[1857] = 1000000005401234079841858566; + bpsToRay[1858] = 1000000005403908319114375815; + bpsToRay[1859] = 1000000005406582332874459714; + bpsToRay[1860] = 1000000005409256121160140942; + bpsToRay[1861] = 1000000005411929684009440562; + bpsToRay[1862] = 1000000005414603021460370019; + bpsToRay[1863] = 1000000005417276133550931144; + bpsToRay[1864] = 1000000005419949020319116161; + bpsToRay[1865] = 1000000005422621681802907685; + bpsToRay[1866] = 1000000005425294118040278729; + bpsToRay[1867] = 1000000005427966329069192704; + bpsToRay[1868] = 1000000005430638314927603428; + bpsToRay[1869] = 1000000005433310075653455121; + bpsToRay[1870] = 1000000005435981611284682417; + bpsToRay[1871] = 1000000005438652921859210358; + bpsToRay[1872] = 1000000005441324007414954408; + bpsToRay[1873] = 1000000005443994867989820443; + bpsToRay[1874] = 1000000005446665503621704769; + bpsToRay[1875] = 1000000005449335914348494113; + bpsToRay[1876] = 1000000005452006100208065634; + bpsToRay[1877] = 1000000005454676061238286919; + bpsToRay[1878] = 1000000005457345797477015996; + bpsToRay[1879] = 1000000005460015308962101327; + bpsToRay[1880] = 1000000005462684595731381818; + bpsToRay[1881] = 1000000005465353657822686822; + bpsToRay[1882] = 1000000005468022495273836134; + bpsToRay[1883] = 1000000005470691108122640009; + bpsToRay[1884] = 1000000005473359496406899150; + bpsToRay[1885] = 1000000005476027660164404723; + bpsToRay[1886] = 1000000005478695599432938350; + bpsToRay[1887] = 1000000005481363314250272121; + bpsToRay[1888] = 1000000005484030804654168594; + bpsToRay[1889] = 1000000005486698070682380795; + bpsToRay[1890] = 1000000005489365112372652227; + bpsToRay[1891] = 1000000005492031929762716867; + bpsToRay[1892] = 1000000005494698522890299176; + bpsToRay[1893] = 1000000005497364891793114096; + bpsToRay[1894] = 1000000005500031036508867056; + bpsToRay[1895] = 1000000005502696957075253978; + bpsToRay[1896] = 1000000005505362653529961273; + bpsToRay[1897] = 1000000005508028125910665852; + bpsToRay[1898] = 1000000005510693374255035122; + bpsToRay[1899] = 1000000005513358398600726996; + bpsToRay[1900] = 1000000005516023198985389892; + bpsToRay[1901] = 1000000005518687775446662738; + bpsToRay[1902] = 1000000005521352128022174972; + bpsToRay[1903] = 1000000005524016256749546550; + bpsToRay[1904] = 1000000005526680161666387944; + bpsToRay[1905] = 1000000005529343842810300151; + bpsToRay[1906] = 1000000005532007300218874693; + bpsToRay[1907] = 1000000005534670533929693618; + bpsToRay[1908] = 1000000005537333543980329507; + bpsToRay[1909] = 1000000005539996330408345474; + bpsToRay[1910] = 1000000005542658893251295174; + bpsToRay[1911] = 1000000005545321232546722802; + bpsToRay[1912] = 1000000005547983348332163094; + bpsToRay[1913] = 1000000005550645240645141338; + bpsToRay[1914] = 1000000005553306909523173370; + bpsToRay[1915] = 1000000005555968355003765580; + bpsToRay[1916] = 1000000005558629577124414915; + bpsToRay[1917] = 1000000005561290575922608882; + bpsToRay[1918] = 1000000005563951351435825552; + bpsToRay[1919] = 1000000005566611903701533560; + bpsToRay[1920] = 1000000005569272232757192116; + bpsToRay[1921] = 1000000005571932338640250996; + bpsToRay[1922] = 1000000005574592221388150557; + bpsToRay[1923] = 1000000005577251881038321732; + bpsToRay[1924] = 1000000005579911317628186037; + bpsToRay[1925] = 1000000005582570531195155575; + bpsToRay[1926] = 1000000005585229521776633037; + bpsToRay[1927] = 1000000005587888289410011703; + bpsToRay[1928] = 1000000005590546834132675450; + bpsToRay[1929] = 1000000005593205155981998754; + bpsToRay[1930] = 1000000005595863254995346690; + bpsToRay[1931] = 1000000005598521131210074940; + bpsToRay[1932] = 1000000005601178784663529791; + bpsToRay[1933] = 1000000005603836215393048140; + bpsToRay[1934] = 1000000005606493423435957501; + bpsToRay[1935] = 1000000005609150408829576003; + bpsToRay[1936] = 1000000005611807171611212394; + bpsToRay[1937] = 1000000005614463711818166047; + bpsToRay[1938] = 1000000005617120029487726961; + bpsToRay[1939] = 1000000005619776124657175764; + bpsToRay[1940] = 1000000005622431997363783716; + bpsToRay[1941] = 1000000005625087647644812714; + bpsToRay[1942] = 1000000005627743075537515294; + bpsToRay[1943] = 1000000005630398281079134633; + bpsToRay[1944] = 1000000005633053264306904553; + bpsToRay[1945] = 1000000005635708025258049526; + bpsToRay[1946] = 1000000005638362563969784673; + bpsToRay[1947] = 1000000005641016880479315773; + bpsToRay[1948] = 1000000005643670974823839258; + bpsToRay[1949] = 1000000005646324847040542225; + bpsToRay[1950] = 1000000005648978497166602432; + bpsToRay[1951] = 1000000005651631925239188307; + bpsToRay[1952] = 1000000005654285131295458945; + bpsToRay[1953] = 1000000005656938115372564118; + bpsToRay[1954] = 1000000005659590877507644269; + bpsToRay[1955] = 1000000005662243417737830528; + bpsToRay[1956] = 1000000005664895736100244700; + bpsToRay[1957] = 1000000005667547832631999280; + bpsToRay[1958] = 1000000005670199707370197452; + bpsToRay[1959] = 1000000005672851360351933092; + bpsToRay[1960] = 1000000005675502791614290768; + bpsToRay[1961] = 1000000005678154001194345751; + bpsToRay[1962] = 1000000005680804989129164009; + bpsToRay[1963] = 1000000005683455755455802217; + bpsToRay[1964] = 1000000005686106300211307757; + bpsToRay[1965] = 1000000005688756623432718721; + bpsToRay[1966] = 1000000005691406725157063918; + bpsToRay[1967] = 1000000005694056605421362868; + bpsToRay[1968] = 1000000005696706264262625816; + bpsToRay[1969] = 1000000005699355701717853726; + bpsToRay[1970] = 1000000005702004917824038294; + bpsToRay[1971] = 1000000005704653912618161941; + bpsToRay[1972] = 1000000005707302686137197819; + bpsToRay[1973] = 1000000005709951238418109820; + bpsToRay[1974] = 1000000005712599569497852572; + bpsToRay[1975] = 1000000005715247679413371444; + bpsToRay[1976] = 1000000005717895568201602551; + bpsToRay[1977] = 1000000005720543235899472755; + bpsToRay[1978] = 1000000005723190682543899670; + bpsToRay[1979] = 1000000005725837908171791664; + bpsToRay[1980] = 1000000005728484912820047862; + bpsToRay[1981] = 1000000005731131696525558147; + bpsToRay[1982] = 1000000005733778259325203169; + bpsToRay[1983] = 1000000005736424601255854342; + bpsToRay[1984] = 1000000005739070722354373849; + bpsToRay[1985] = 1000000005741716622657614647; + bpsToRay[1986] = 1000000005744362302202420469; + bpsToRay[1987] = 1000000005747007761025625824; + bpsToRay[1988] = 1000000005749652999164056007; + bpsToRay[1989] = 1000000005752298016654527093; + bpsToRay[1990] = 1000000005754942813533845949; + bpsToRay[1991] = 1000000005757587389838810231; + bpsToRay[1992] = 1000000005760231745606208388; + bpsToRay[1993] = 1000000005762875880872819670; + bpsToRay[1994] = 1000000005765519795675414123; + bpsToRay[1995] = 1000000005768163490050752599; + bpsToRay[1996] = 1000000005770806964035586754; + bpsToRay[1997] = 1000000005773450217666659055; + bpsToRay[1998] = 1000000005776093250980702782; + bpsToRay[1999] = 1000000005778736064014442030; + bpsToRay[2000] = 1000000005781378656804591712; + bpsToRay[2001] = 1000000005784021029387857563; + bpsToRay[2002] = 1000000005786663181800936142; + bpsToRay[2003] = 1000000005789305114080514838; + bpsToRay[2004] = 1000000005791946826263271867; + bpsToRay[2005] = 1000000005794588318385876283; + bpsToRay[2006] = 1000000005797229590484987975; + bpsToRay[2007] = 1000000005799870642597257672; + bpsToRay[2008] = 1000000005802511474759326946; + bpsToRay[2009] = 1000000005805152087007828215; + bpsToRay[2010] = 1000000005807792479379384747; + bpsToRay[2011] = 1000000005810432651910610661; + bpsToRay[2012] = 1000000005813072604638110932; + bpsToRay[2013] = 1000000005815712337598481393; + bpsToRay[2014] = 1000000005818351850828308739; + bpsToRay[2015] = 1000000005820991144364170528; + bpsToRay[2016] = 1000000005823630218242635187; + bpsToRay[2017] = 1000000005826269072500262012; + bpsToRay[2018] = 1000000005828907707173601173; + bpsToRay[2019] = 1000000005831546122299193718; + bpsToRay[2020] = 1000000005834184317913571571; + bpsToRay[2021] = 1000000005836822294053257542; + bpsToRay[2022] = 1000000005839460050754765326; + bpsToRay[2023] = 1000000005842097588054599505; + bpsToRay[2024] = 1000000005844734905989255555; + bpsToRay[2025] = 1000000005847372004595219844; + bpsToRay[2026] = 1000000005850008883908969641; + bpsToRay[2027] = 1000000005852645543966973112; + bpsToRay[2028] = 1000000005855281984805689330; + bpsToRay[2029] = 1000000005857918206461568274; + bpsToRay[2030] = 1000000005860554208971050832; + bpsToRay[2031] = 1000000005863189992370568806; + bpsToRay[2032] = 1000000005865825556696544911; + bpsToRay[2033] = 1000000005868460901985392786; + bpsToRay[2034] = 1000000005871096028273516989; + bpsToRay[2035] = 1000000005873730935597313001; + bpsToRay[2036] = 1000000005876365623993167233; + bpsToRay[2037] = 1000000005879000093497457030; + bpsToRay[2038] = 1000000005881634344146550666; + bpsToRay[2039] = 1000000005884268375976807354; + bpsToRay[2040] = 1000000005886902189024577248; + bpsToRay[2041] = 1000000005889535783326201442; + bpsToRay[2042] = 1000000005892169158918011981; + bpsToRay[2043] = 1000000005894802315836331854; + bpsToRay[2044] = 1000000005897435254117475004; + bpsToRay[2045] = 1000000005900067973797746332; + bpsToRay[2046] = 1000000005902700474913441692; + bpsToRay[2047] = 1000000005905332757500847901; + bpsToRay[2048] = 1000000005907964821596242742; + bpsToRay[2049] = 1000000005910596667235894964; + bpsToRay[2050] = 1000000005913228294456064283; + bpsToRay[2051] = 1000000005915859703293001393; + bpsToRay[2052] = 1000000005918490893782947960; + bpsToRay[2053] = 1000000005921121865962136632; + bpsToRay[2054] = 1000000005923752619866791038; + bpsToRay[2055] = 1000000005926383155533125790; + bpsToRay[2056] = 1000000005929013472997346492; + bpsToRay[2057] = 1000000005931643572295649735; + bpsToRay[2058] = 1000000005934273453464223108; + bpsToRay[2059] = 1000000005936903116539245192; + bpsToRay[2060] = 1000000005939532561556885575; + bpsToRay[2061] = 1000000005942161788553304839; + bpsToRay[2062] = 1000000005944790797564654580; + bpsToRay[2063] = 1000000005947419588627077399; + bpsToRay[2064] = 1000000005950048161776706909; + bpsToRay[2065] = 1000000005952676517049667739; + bpsToRay[2066] = 1000000005955304654482075535; + bpsToRay[2067] = 1000000005957932574110036965; + bpsToRay[2068] = 1000000005960560275969649719; + bpsToRay[2069] = 1000000005963187760097002515; + bpsToRay[2070] = 1000000005965815026528175101; + bpsToRay[2071] = 1000000005968442075299238258; + bpsToRay[2072] = 1000000005971068906446253801; + bpsToRay[2073] = 1000000005973695520005274585; + bpsToRay[2074] = 1000000005976321916012344506; + bpsToRay[2075] = 1000000005978948094503498507; + bpsToRay[2076] = 1000000005981574055514762574; + bpsToRay[2077] = 1000000005984199799082153748; + bpsToRay[2078] = 1000000005986825325241680120; + bpsToRay[2079] = 1000000005989450634029340842; + bpsToRay[2080] = 1000000005992075725481126120; + bpsToRay[2081] = 1000000005994700599633017225; + bpsToRay[2082] = 1000000005997325256520986496; + bpsToRay[2083] = 1000000005999949696180997335; + bpsToRay[2084] = 1000000006002573918649004220; + bpsToRay[2085] = 1000000006005197923960952699; + bpsToRay[2086] = 1000000006007821712152779401; + bpsToRay[2087] = 1000000006010445283260412034; + bpsToRay[2088] = 1000000006013068637319769388; + bpsToRay[2089] = 1000000006015691774366761338; + bpsToRay[2090] = 1000000006018314694437288852; + bpsToRay[2091] = 1000000006020937397567243987; + bpsToRay[2092] = 1000000006023559883792509896; + bpsToRay[2093] = 1000000006026182153148960829; + bpsToRay[2094] = 1000000006028804205672462137; + bpsToRay[2095] = 1000000006031426041398870273; + bpsToRay[2096] = 1000000006034047660364032802; + bpsToRay[2097] = 1000000006036669062603788392; + bpsToRay[2098] = 1000000006039290248153966829; + bpsToRay[2099] = 1000000006041911217050389011; + bpsToRay[2100] = 1000000006044531969328866955; + bpsToRay[2101] = 1000000006047152505025203801; + bpsToRay[2102] = 1000000006049772824175193813; + bpsToRay[2103] = 1000000006052392926814622379; + bpsToRay[2104] = 1000000006055012812979266021; + bpsToRay[2105] = 1000000006057632482704892392; + bpsToRay[2106] = 1000000006060251936027260282; + bpsToRay[2107] = 1000000006062871172982119621; + bpsToRay[2108] = 1000000006065490193605211477; + bpsToRay[2109] = 1000000006068108997932268067; + bpsToRay[2110] = 1000000006070727585999012755; + bpsToRay[2111] = 1000000006073345957841160052; + bpsToRay[2112] = 1000000006075964113494415626; + bpsToRay[2113] = 1000000006078582052994476301; + bpsToRay[2114] = 1000000006081199776377030061; + bpsToRay[2115] = 1000000006083817283677756050; + bpsToRay[2116] = 1000000006086434574932324580; + bpsToRay[2117] = 1000000006089051650176397130; + bpsToRay[2118] = 1000000006091668509445626349; + bpsToRay[2119] = 1000000006094285152775656060; + bpsToRay[2120] = 1000000006096901580202121266; + bpsToRay[2121] = 1000000006099517791760648147; + bpsToRay[2122] = 1000000006102133787486854066; + bpsToRay[2123] = 1000000006104749567416347572; + bpsToRay[2124] = 1000000006107365131584728403; + bpsToRay[2125] = 1000000006109980480027587488; + bpsToRay[2126] = 1000000006112595612780506950; + bpsToRay[2127] = 1000000006115210529879060111; + bpsToRay[2128] = 1000000006117825231358811489; + bpsToRay[2129] = 1000000006120439717255316811; + bpsToRay[2130] = 1000000006123053987604123006; + bpsToRay[2131] = 1000000006125668042440768211; + bpsToRay[2132] = 1000000006128281881800781778; + bpsToRay[2133] = 1000000006130895505719684273; + bpsToRay[2134] = 1000000006133508914232987477; + bpsToRay[2135] = 1000000006136122107376194395; + bpsToRay[2136] = 1000000006138735085184799252; + bpsToRay[2137] = 1000000006141347847694287501; + bpsToRay[2138] = 1000000006143960394940135825; + bpsToRay[2139] = 1000000006146572726957812137; + bpsToRay[2140] = 1000000006149184843782775586; + bpsToRay[2141] = 1000000006151796745450476560; + bpsToRay[2142] = 1000000006154408431996356685; + bpsToRay[2143] = 1000000006157019903455848831; + bpsToRay[2144] = 1000000006159631159864377117; + bpsToRay[2145] = 1000000006162242201257356911; + bpsToRay[2146] = 1000000006164853027670194829; + bpsToRay[2147] = 1000000006167463639138288746; + bpsToRay[2148] = 1000000006170074035697027796; + bpsToRay[2149] = 1000000006172684217381792370; + bpsToRay[2150] = 1000000006175294184227954125; + bpsToRay[2151] = 1000000006177903936270875985; + bpsToRay[2152] = 1000000006180513473545912141; + bpsToRay[2153] = 1000000006183122796088408060; + bpsToRay[2154] = 1000000006185731903933700483; + bpsToRay[2155] = 1000000006188340797117117427; + bpsToRay[2156] = 1000000006190949475673978192; + bpsToRay[2157] = 1000000006193557939639593360; + bpsToRay[2158] = 1000000006196166189049264802; + bpsToRay[2159] = 1000000006198774223938285679; + bpsToRay[2160] = 1000000006201382044341940442; + bpsToRay[2161] = 1000000006203989650295504837; + bpsToRay[2162] = 1000000006206597041834245913; + bpsToRay[2163] = 1000000006209204218993422012; + bpsToRay[2164] = 1000000006211811181808282789; + bpsToRay[2165] = 1000000006214417930314069199; + bpsToRay[2166] = 1000000006217024464546013508; + bpsToRay[2167] = 1000000006219630784539339297; + bpsToRay[2168] = 1000000006222236890329261461; + bpsToRay[2169] = 1000000006224842781950986211; + bpsToRay[2170] = 1000000006227448459439711081; + bpsToRay[2171] = 1000000006230053922830624932; + bpsToRay[2172] = 1000000006232659172158907945; + bpsToRay[2173] = 1000000006235264207459731635; + bpsToRay[2174] = 1000000006237869028768258850; + bpsToRay[2175] = 1000000006240473636119643770; + bpsToRay[2176] = 1000000006243078029549031916; + bpsToRay[2177] = 1000000006245682209091560148; + bpsToRay[2178] = 1000000006248286174782356672; + bpsToRay[2179] = 1000000006250889926656541039; + bpsToRay[2180] = 1000000006253493464749224150; + bpsToRay[2181] = 1000000006256096789095508257; + bpsToRay[2182] = 1000000006258699899730486971; + bpsToRay[2183] = 1000000006261302796689245258; + bpsToRay[2184] = 1000000006263905480006859443; + bpsToRay[2185] = 1000000006266507949718397218; + bpsToRay[2186] = 1000000006269110205858917643; + bpsToRay[2187] = 1000000006271712248463471143; + bpsToRay[2188] = 1000000006274314077567099518; + bpsToRay[2189] = 1000000006276915693204835941; + bpsToRay[2190] = 1000000006279517095411704965; + bpsToRay[2191] = 1000000006282118284222722523; + bpsToRay[2192] = 1000000006284719259672895930; + bpsToRay[2193] = 1000000006287320021797223891; + bpsToRay[2194] = 1000000006289920570630696496; + bpsToRay[2195] = 1000000006292520906208295229; + bpsToRay[2196] = 1000000006295121028564992969; + bpsToRay[2197] = 1000000006297720937735753993; + bpsToRay[2198] = 1000000006300320633755533977; + bpsToRay[2199] = 1000000006302920116659280001; + bpsToRay[2200] = 1000000006305519386481930552; + bpsToRay[2201] = 1000000006308118443258415523; + bpsToRay[2202] = 1000000006310717287023656222; + bpsToRay[2203] = 1000000006313315917812565372; + bpsToRay[2204] = 1000000006315914335660047109; + bpsToRay[2205] = 1000000006318512540600996994; + bpsToRay[2206] = 1000000006321110532670302007; + bpsToRay[2207] = 1000000006323708311902840558; + bpsToRay[2208] = 1000000006326305878333482482; + bpsToRay[2209] = 1000000006328903231997089047; + bpsToRay[2210] = 1000000006331500372928512954; + bpsToRay[2211] = 1000000006334097301162598344; + bpsToRay[2212] = 1000000006336694016734180794; + bpsToRay[2213] = 1000000006339290519678087326; + bpsToRay[2214] = 1000000006341886810029136408; + bpsToRay[2215] = 1000000006344482887822137953; + bpsToRay[2216] = 1000000006347078753091893329; + bpsToRay[2217] = 1000000006349674405873195356; + bpsToRay[2218] = 1000000006352269846200828311; + bpsToRay[2219] = 1000000006354865074109567928; + bpsToRay[2220] = 1000000006357460089634181406; + bpsToRay[2221] = 1000000006360054892809427412; + bpsToRay[2222] = 1000000006362649483670056072; + bpsToRay[2223] = 1000000006365243862250808991; + bpsToRay[2224] = 1000000006367838028586419244; + bpsToRay[2225] = 1000000006370431982711611382; + bpsToRay[2226] = 1000000006373025724661101435; + bpsToRay[2227] = 1000000006375619254469596916; + bpsToRay[2228] = 1000000006378212572171796821; + bpsToRay[2229] = 1000000006380805677802391636; + bpsToRay[2230] = 1000000006383398571396063332; + bpsToRay[2231] = 1000000006385991252987485379; + bpsToRay[2232] = 1000000006388583722611322739; + bpsToRay[2233] = 1000000006391175980302231873; + bpsToRay[2234] = 1000000006393768026094860743; + bpsToRay[2235] = 1000000006396359860023848818; + bpsToRay[2236] = 1000000006398951482123827069; + bpsToRay[2237] = 1000000006401542892429417980; + bpsToRay[2238] = 1000000006404134090975235547; + bpsToRay[2239] = 1000000006406725077795885279; + bpsToRay[2240] = 1000000006409315852925964206; + bpsToRay[2241] = 1000000006411906416400060876; + bpsToRay[2242] = 1000000006414496768252755361; + bpsToRay[2243] = 1000000006417086908518619263; + bpsToRay[2244] = 1000000006419676837232215707; + bpsToRay[2245] = 1000000006422266554428099352; + bpsToRay[2246] = 1000000006424856060140816394; + bpsToRay[2247] = 1000000006427445354404904564; + bpsToRay[2248] = 1000000006430034437254893132; + bpsToRay[2249] = 1000000006432623308725302915; + bpsToRay[2250] = 1000000006435211968850646270; + bpsToRay[2251] = 1000000006437800417665427105; + bpsToRay[2252] = 1000000006440388655204140882; + bpsToRay[2253] = 1000000006442976681501274614; + bpsToRay[2254] = 1000000006445564496591306867; + bpsToRay[2255] = 1000000006448152100508707774; + bpsToRay[2256] = 1000000006450739493287939023; + bpsToRay[2257] = 1000000006453326674963453873; + bpsToRay[2258] = 1000000006455913645569697146; + bpsToRay[2259] = 1000000006458500405141105236; + bpsToRay[2260] = 1000000006461086953712106112; + bpsToRay[2261] = 1000000006463673291317119316; + bpsToRay[2262] = 1000000006466259417990555969; + bpsToRay[2263] = 1000000006468845333766818775; + bpsToRay[2264] = 1000000006471431038680302021; + bpsToRay[2265] = 1000000006474016532765391581; + bpsToRay[2266] = 1000000006476601816056464920; + bpsToRay[2267] = 1000000006479186888587891091; + bpsToRay[2268] = 1000000006481771750394030749; + bpsToRay[2269] = 1000000006484356401509236141; + bpsToRay[2270] = 1000000006486940841967851116; + bpsToRay[2271] = 1000000006489525071804211128; + bpsToRay[2272] = 1000000006492109091052643236; + bpsToRay[2273] = 1000000006494692899747466107; + bpsToRay[2274] = 1000000006497276497922990021; + bpsToRay[2275] = 1000000006499859885613516871; + bpsToRay[2276] = 1000000006502443062853340168; + bpsToRay[2277] = 1000000006505026029676745041; + bpsToRay[2278] = 1000000006507608786118008244; + bpsToRay[2279] = 1000000006510191332211398155; + bpsToRay[2280] = 1000000006512773667991174779; + bpsToRay[2281] = 1000000006515355793491589751; + bpsToRay[2282] = 1000000006517937708746886344; + bpsToRay[2283] = 1000000006520519413791299462; + bpsToRay[2284] = 1000000006523100908659055649; + bpsToRay[2285] = 1000000006525682193384373092; + bpsToRay[2286] = 1000000006528263268001461622; + bpsToRay[2287] = 1000000006530844132544522714; + bpsToRay[2288] = 1000000006533424787047749499; + bpsToRay[2289] = 1000000006536005231545326753; + bpsToRay[2290] = 1000000006538585466071430912; + bpsToRay[2291] = 1000000006541165490660230067; + bpsToRay[2292] = 1000000006543745305345883975; + bpsToRay[2293] = 1000000006546324910162544048; + bpsToRay[2294] = 1000000006548904305144353370; + bpsToRay[2295] = 1000000006551483490325446691; + bpsToRay[2296] = 1000000006554062465739950435; + bpsToRay[2297] = 1000000006556641231421982697; + bpsToRay[2298] = 1000000006559219787405653252; + bpsToRay[2299] = 1000000006561798133725063551; + bpsToRay[2300] = 1000000006564376270414306730; + bpsToRay[2301] = 1000000006566954197507467608; + bpsToRay[2302] = 1000000006569531915038622694; + bpsToRay[2303] = 1000000006572109423041840185; + bpsToRay[2304] = 1000000006574686721551179973; + bpsToRay[2305] = 1000000006577263810600693644; + bpsToRay[2306] = 1000000006579840690224424483; + bpsToRay[2307] = 1000000006582417360456407476; + bpsToRay[2308] = 1000000006584993821330669316; + bpsToRay[2309] = 1000000006587570072881228396; + bpsToRay[2310] = 1000000006590146115142094824; + bpsToRay[2311] = 1000000006592721948147270418; + bpsToRay[2312] = 1000000006595297571930748710; + bpsToRay[2313] = 1000000006597872986526514949; + bpsToRay[2314] = 1000000006600448191968546107; + bpsToRay[2315] = 1000000006603023188290810875; + bpsToRay[2316] = 1000000006605597975527269671; + bpsToRay[2317] = 1000000006608172553711874641; + bpsToRay[2318] = 1000000006610746922878569662; + bpsToRay[2319] = 1000000006613321083061290345; + bpsToRay[2320] = 1000000006615895034293964035; + bpsToRay[2321] = 1000000006618468776610509817; + bpsToRay[2322] = 1000000006621042310044838519; + bpsToRay[2323] = 1000000006623615634630852711; + bpsToRay[2324] = 1000000006626188750402446710; + bpsToRay[2325] = 1000000006628761657393506584; + bpsToRay[2326] = 1000000006631334355637910151; + bpsToRay[2327] = 1000000006633906845169526987; + bpsToRay[2328] = 1000000006636479126022218423; + bpsToRay[2329] = 1000000006639051198229837551; + bpsToRay[2330] = 1000000006641623061826229226; + bpsToRay[2331] = 1000000006644194716845230068; + bpsToRay[2332] = 1000000006646766163320668467; + bpsToRay[2333] = 1000000006649337401286364581; + bpsToRay[2334] = 1000000006651908430776130344; + bpsToRay[2335] = 1000000006654479251823769466; + bpsToRay[2336] = 1000000006657049864463077435; + bpsToRay[2337] = 1000000006659620268727841521; + bpsToRay[2338] = 1000000006662190464651840778; + bpsToRay[2339] = 1000000006664760452268846047; + bpsToRay[2340] = 1000000006667330231612619959; + bpsToRay[2341] = 1000000006669899802716916939; + bpsToRay[2342] = 1000000006672469165615483202; + bpsToRay[2343] = 1000000006675038320342056763; + bpsToRay[2344] = 1000000006677607266930367441; + bpsToRay[2345] = 1000000006680176005414136851; + bpsToRay[2346] = 1000000006682744535827078420; + bpsToRay[2347] = 1000000006685312858202897378; + bpsToRay[2348] = 1000000006687880972575290769; + bpsToRay[2349] = 1000000006690448878977947450; + bpsToRay[2350] = 1000000006693016577444548094; + bpsToRay[2351] = 1000000006695584068008765190; + bpsToRay[2352] = 1000000006698151350704263054; + bpsToRay[2353] = 1000000006700718425564697821; + bpsToRay[2354] = 1000000006703285292623717455; + bpsToRay[2355] = 1000000006705851951914961750; + bpsToRay[2356] = 1000000006708418403472062331; + bpsToRay[2357] = 1000000006710984647328642657; + bpsToRay[2358] = 1000000006713550683518318027; + bpsToRay[2359] = 1000000006716116512074695575; + bpsToRay[2360] = 1000000006718682133031374284; + bpsToRay[2361] = 1000000006721247546421944976; + bpsToRay[2362] = 1000000006723812752279990327; + bpsToRay[2363] = 1000000006726377750639084858; + bpsToRay[2364] = 1000000006728942541532794947; + bpsToRay[2365] = 1000000006731507124994678824; + bpsToRay[2366] = 1000000006734071501058286581; + bpsToRay[2367] = 1000000006736635669757160171; + bpsToRay[2368] = 1000000006739199631124833408; + bpsToRay[2369] = 1000000006741763385194831973; + bpsToRay[2370] = 1000000006744326932000673419; + bpsToRay[2371] = 1000000006746890271575867167; + bpsToRay[2372] = 1000000006749453403953914514; + bpsToRay[2373] = 1000000006752016329168308632; + bpsToRay[2374] = 1000000006754579047252534575; + bpsToRay[2375] = 1000000006757141558240069277; + bpsToRay[2376] = 1000000006759703862164381559; + bpsToRay[2377] = 1000000006762265959058932126; + bpsToRay[2378] = 1000000006764827848957173576; + bpsToRay[2379] = 1000000006767389531892550399; + bpsToRay[2380] = 1000000006769951007898498979; + bpsToRay[2381] = 1000000006772512277008447597; + bpsToRay[2382] = 1000000006775073339255816438; + bpsToRay[2383] = 1000000006777634194674017587; + bpsToRay[2384] = 1000000006780194843296455036; + bpsToRay[2385] = 1000000006782755285156524684; + bpsToRay[2386] = 1000000006785315520287614342; + bpsToRay[2387] = 1000000006787875548723103735; + bpsToRay[2388] = 1000000006790435370496364503; + bpsToRay[2389] = 1000000006792994985640760203; + bpsToRay[2390] = 1000000006795554394189646319; + bpsToRay[2391] = 1000000006798113596176370253; + bpsToRay[2392] = 1000000006800672591634271336; + bpsToRay[2393] = 1000000006803231380596680829; + bpsToRay[2394] = 1000000006805789963096921922; + bpsToRay[2395] = 1000000006808348339168309744; + bpsToRay[2396] = 1000000006810906508844151355; + bpsToRay[2397] = 1000000006813464472157745761; + bpsToRay[2398] = 1000000006816022229142383903; + bpsToRay[2399] = 1000000006818579779831348674; + bpsToRay[2400] = 1000000006821137124257914908; + bpsToRay[2401] = 1000000006823694262455349394; + bpsToRay[2402] = 1000000006826251194456910871; + bpsToRay[2403] = 1000000006828807920295850033; + bpsToRay[2404] = 1000000006831364440005409534; + bpsToRay[2405] = 1000000006833920753618823984; + bpsToRay[2406] = 1000000006836476861169319962; + bpsToRay[2407] = 1000000006839032762690116006; + bpsToRay[2408] = 1000000006841588458214422628; + bpsToRay[2409] = 1000000006844143947775442306; + bpsToRay[2410] = 1000000006846699231406369494; + bpsToRay[2411] = 1000000006849254309140390621; + bpsToRay[2412] = 1000000006851809181010684095; + bpsToRay[2413] = 1000000006854363847050420305; + bpsToRay[2414] = 1000000006856918307292761621; + bpsToRay[2415] = 1000000006859472561770862405; + bpsToRay[2416] = 1000000006862026610517869003; + bpsToRay[2417] = 1000000006864580453566919751; + bpsToRay[2418] = 1000000006867134090951144986; + bpsToRay[2419] = 1000000006869687522703667035; + bpsToRay[2420] = 1000000006872240748857600225; + bpsToRay[2421] = 1000000006874793769446050889; + bpsToRay[2422] = 1000000006877346584502117360; + bpsToRay[2423] = 1000000006879899194058889978; + bpsToRay[2424] = 1000000006882451598149451095; + bpsToRay[2425] = 1000000006885003796806875073; + bpsToRay[2426] = 1000000006887555790064228288; + bpsToRay[2427] = 1000000006890107577954569136; + bpsToRay[2428] = 1000000006892659160510948030; + bpsToRay[2429] = 1000000006895210537766407406; + bpsToRay[2430] = 1000000006897761709753981726; + bpsToRay[2431] = 1000000006900312676506697478; + bpsToRay[2432] = 1000000006902863438057573180; + bpsToRay[2433] = 1000000006905413994439619383; + bpsToRay[2434] = 1000000006907964345685838672; + bpsToRay[2435] = 1000000006910514491829225673; + bpsToRay[2436] = 1000000006913064432902767049; + bpsToRay[2437] = 1000000006915614168939441505; + bpsToRay[2438] = 1000000006918163699972219795; + bpsToRay[2439] = 1000000006920713026034064718; + bpsToRay[2440] = 1000000006923262147157931125; + bpsToRay[2441] = 1000000006925811063376765919; + bpsToRay[2442] = 1000000006928359774723508058; + bpsToRay[2443] = 1000000006930908281231088560; + bpsToRay[2444] = 1000000006933456582932430503; + bpsToRay[2445] = 1000000006936004679860449027; + bpsToRay[2446] = 1000000006938552572048051340; + bpsToRay[2447] = 1000000006941100259528136715; + bpsToRay[2448] = 1000000006943647742333596500; + bpsToRay[2449] = 1000000006946195020497314113; + bpsToRay[2450] = 1000000006948742094052165050; + bpsToRay[2451] = 1000000006951288963031016884; + bpsToRay[2452] = 1000000006953835627466729271; + bpsToRay[2453] = 1000000006956382087392153949; + bpsToRay[2454] = 1000000006958928342840134742; + bpsToRay[2455] = 1000000006961474393843507563; + bpsToRay[2456] = 1000000006964020240435100419; + bpsToRay[2457] = 1000000006966565882647733404; + bpsToRay[2458] = 1000000006969111320514218717; + bpsToRay[2459] = 1000000006971656554067360648; + bpsToRay[2460] = 1000000006974201583339955595; + bpsToRay[2461] = 1000000006976746408364792054; + bpsToRay[2462] = 1000000006979291029174650631; + bpsToRay[2463] = 1000000006981835445802304040; + bpsToRay[2464] = 1000000006984379658280517107; + bpsToRay[2465] = 1000000006986923666642046773; + bpsToRay[2466] = 1000000006989467470919642091; + bpsToRay[2467] = 1000000006992011071146044239; + bpsToRay[2468] = 1000000006994554467353986513; + bpsToRay[2469] = 1000000006997097659576194335; + bpsToRay[2470] = 1000000006999640647845385252; + bpsToRay[2471] = 1000000007002183432194268941; + bpsToRay[2472] = 1000000007004726012655547211; + bpsToRay[2473] = 1000000007007268389261914006; + bpsToRay[2474] = 1000000007009810562046055406; + bpsToRay[2475] = 1000000007012352531040649627; + bpsToRay[2476] = 1000000007014894296278367034; + bpsToRay[2477] = 1000000007017435857791870130; + bpsToRay[2478] = 1000000007019977215613813568; + bpsToRay[2479] = 1000000007022518369776844150; + bpsToRay[2480] = 1000000007025059320313600828; + bpsToRay[2481] = 1000000007027600067256714710; + bpsToRay[2482] = 1000000007030140610638809063; + bpsToRay[2483] = 1000000007032680950492499310; + bpsToRay[2484] = 1000000007035221086850393037; + bpsToRay[2485] = 1000000007037761019745089994; + bpsToRay[2486] = 1000000007040300749209182100; + bpsToRay[2487] = 1000000007042840275275253441; + bpsToRay[2488] = 1000000007045379597975880277; + bpsToRay[2489] = 1000000007047918717343631040; + bpsToRay[2490] = 1000000007050457633411066343; + bpsToRay[2491] = 1000000007052996346210738974; + bpsToRay[2492] = 1000000007055534855775193908; + bpsToRay[2493] = 1000000007058073162136968298; + bpsToRay[2494] = 1000000007060611265328591490; + bpsToRay[2495] = 1000000007063149165382585017; + bpsToRay[2496] = 1000000007065686862331462604; + bpsToRay[2497] = 1000000007068224356207730171; + bpsToRay[2498] = 1000000007070761647043885833; + bpsToRay[2499] = 1000000007073298734872419909; + bpsToRay[2500] = 1000000007075835619725814915; + bpsToRay[2501] = 1000000007078372301636545575; + bpsToRay[2502] = 1000000007080908780637078819; + bpsToRay[2503] = 1000000007083445056759873785; + bpsToRay[2504] = 1000000007085981130037381827; + bpsToRay[2505] = 1000000007088517000502046507; + bpsToRay[2506] = 1000000007091052668186303610; + bpsToRay[2507] = 1000000007093588133122581138; + bpsToRay[2508] = 1000000007096123395343299315; + bpsToRay[2509] = 1000000007098658454880870590; + bpsToRay[2510] = 1000000007101193311767699638; + bpsToRay[2511] = 1000000007103727966036183363; + bpsToRay[2512] = 1000000007106262417718710904; + bpsToRay[2513] = 1000000007108796666847663630; + bpsToRay[2514] = 1000000007111330713455415150; + bpsToRay[2515] = 1000000007113864557574331311; + bpsToRay[2516] = 1000000007116398199236770202; + bpsToRay[2517] = 1000000007118931638475082158; + bpsToRay[2518] = 1000000007121464875321609757; + bpsToRay[2519] = 1000000007123997909808687830; + bpsToRay[2520] = 1000000007126530741968643458; + bpsToRay[2521] = 1000000007129063371833795977; + bpsToRay[2522] = 1000000007131595799436456977; + bpsToRay[2523] = 1000000007134128024808930311; + bpsToRay[2524] = 1000000007136660047983512092; + bpsToRay[2525] = 1000000007139191868992490695; + bpsToRay[2526] = 1000000007141723487868146766; + bpsToRay[2527] = 1000000007144254904642753216; + bpsToRay[2528] = 1000000007146786119348575230; + bpsToRay[2529] = 1000000007149317132017870265; + bpsToRay[2530] = 1000000007151847942682888056; + bpsToRay[2531] = 1000000007154378551375870618; + bpsToRay[2532] = 1000000007156908958129052243; + bpsToRay[2533] = 1000000007159439162974659510; + bpsToRay[2534] = 1000000007161969165944911286; + bpsToRay[2535] = 1000000007164498967072018724; + bpsToRay[2536] = 1000000007167028566388185266; + bpsToRay[2537] = 1000000007169557963925606655; + bpsToRay[2538] = 1000000007172087159716470922; + bpsToRay[2539] = 1000000007174616153792958402; + bpsToRay[2540] = 1000000007177144946187241729; + bpsToRay[2541] = 1000000007179673536931485840; + bpsToRay[2542] = 1000000007182201926057847980; + bpsToRay[2543] = 1000000007184730113598477700; + bpsToRay[2544] = 1000000007187258099585516865; + bpsToRay[2545] = 1000000007189785884051099650; + bpsToRay[2546] = 1000000007192313467027352546; + bpsToRay[2547] = 1000000007194840848546394365; + bpsToRay[2548] = 1000000007197368028640336238; + bpsToRay[2549] = 1000000007199895007341281618; + bpsToRay[2550] = 1000000007202421784681326287; + bpsToRay[2551] = 1000000007204948360692558350; + bpsToRay[2552] = 1000000007207474735407058245; + bpsToRay[2553] = 1000000007210000908856898746; + bpsToRay[2554] = 1000000007212526881074144958; + bpsToRay[2555] = 1000000007215052652090854324; + bpsToRay[2556] = 1000000007217578221939076629; + bpsToRay[2557] = 1000000007220103590650854001; + bpsToRay[2558] = 1000000007222628758258220911; + bpsToRay[2559] = 1000000007225153724793204178; + bpsToRay[2560] = 1000000007227678490287822975; + bpsToRay[2561] = 1000000007230203054774088820; + bpsToRay[2562] = 1000000007232727418284005593; + bpsToRay[2563] = 1000000007235251580849569527; + bpsToRay[2564] = 1000000007237775542502769216; + bpsToRay[2565] = 1000000007240299303275585616; + bpsToRay[2566] = 1000000007242822863199992048; + bpsToRay[2567] = 1000000007245346222307954199; + bpsToRay[2568] = 1000000007247869380631430127; + bpsToRay[2569] = 1000000007250392338202370260; + bpsToRay[2570] = 1000000007252915095052717402; + bpsToRay[2571] = 1000000007255437651214406734; + bpsToRay[2572] = 1000000007257960006719365813; + bpsToRay[2573] = 1000000007260482161599514580; + bpsToRay[2574] = 1000000007263004115886765361; + bpsToRay[2575] = 1000000007265525869613022867; + bpsToRay[2576] = 1000000007268047422810184197; + bpsToRay[2577] = 1000000007270568775510138843; + bpsToRay[2578] = 1000000007273089927744768690; + bpsToRay[2579] = 1000000007275610879545948018; + bpsToRay[2580] = 1000000007278131630945543509; + bpsToRay[2581] = 1000000007280652181975414240; + bpsToRay[2582] = 1000000007283172532667411698; + bpsToRay[2583] = 1000000007285692683053379771; + bpsToRay[2584] = 1000000007288212633165154756; + bpsToRay[2585] = 1000000007290732383034565363; + bpsToRay[2586] = 1000000007293251932693432712; + bpsToRay[2587] = 1000000007295771282173570341; + bpsToRay[2588] = 1000000007298290431506784204; + bpsToRay[2589] = 1000000007300809380724872677; + bpsToRay[2590] = 1000000007303328129859626555; + bpsToRay[2591] = 1000000007305846678942829063; + bpsToRay[2592] = 1000000007308365028006255850; + bpsToRay[2593] = 1000000007310883177081674995; + bpsToRay[2594] = 1000000007313401126200847011; + bpsToRay[2595] = 1000000007315918875395524846; + bpsToRay[2596] = 1000000007318436424697453882; + bpsToRay[2597] = 1000000007320953774138371943; + bpsToRay[2598] = 1000000007323470923750009295; + bpsToRay[2599] = 1000000007325987873564088646; + bpsToRay[2600] = 1000000007328504623612325153; + bpsToRay[2601] = 1000000007331021173926426421; + bpsToRay[2602] = 1000000007333537524538092508; + bpsToRay[2603] = 1000000007336053675479015924; + bpsToRay[2604] = 1000000007338569626780881634; + bpsToRay[2605] = 1000000007341085378475367066; + bpsToRay[2606] = 1000000007343600930594142104; + bpsToRay[2607] = 1000000007346116283168869100; + bpsToRay[2608] = 1000000007348631436231202869; + bpsToRay[2609] = 1000000007351146389812790696; + bpsToRay[2610] = 1000000007353661143945272335; + bpsToRay[2611] = 1000000007356175698660280013; + bpsToRay[2612] = 1000000007358690053989438434; + bpsToRay[2613] = 1000000007361204209964364778; + bpsToRay[2614] = 1000000007363718166616668706; + bpsToRay[2615] = 1000000007366231923977952362; + bpsToRay[2616] = 1000000007368745482079810375; + bpsToRay[2617] = 1000000007371258840953829859; + bpsToRay[2618] = 1000000007373772000631590422; + bpsToRay[2619] = 1000000007376284961144664159; + bpsToRay[2620] = 1000000007378797722524615662; + bpsToRay[2621] = 1000000007381310284803002021; + bpsToRay[2622] = 1000000007383822648011372824; + bpsToRay[2623] = 1000000007386334812181270160; + bpsToRay[2624] = 1000000007388846777344228623; + bpsToRay[2625] = 1000000007391358543531775311; + bpsToRay[2626] = 1000000007393870110775429835; + bpsToRay[2627] = 1000000007396381479106704315; + bpsToRay[2628] = 1000000007398892648557103381; + bpsToRay[2629] = 1000000007401403619158124184; + bpsToRay[2630] = 1000000007403914390941256391; + bpsToRay[2631] = 1000000007406424963937982190; + bpsToRay[2632] = 1000000007408935338179776291; + bpsToRay[2633] = 1000000007411445513698105929; + bpsToRay[2634] = 1000000007413955490524430869; + bpsToRay[2635] = 1000000007416465268690203405; + bpsToRay[2636] = 1000000007418974848226868363; + bpsToRay[2637] = 1000000007421484229165863101; + bpsToRay[2638] = 1000000007423993411538617520; + bpsToRay[2639] = 1000000007426502395376554056; + bpsToRay[2640] = 1000000007429011180711087689; + bpsToRay[2641] = 1000000007431519767573625942; + bpsToRay[2642] = 1000000007434028155995568885; + bpsToRay[2643] = 1000000007436536346008309136; + bpsToRay[2644] = 1000000007439044337643231867; + bpsToRay[2645] = 1000000007441552130931714802; + bpsToRay[2646] = 1000000007444059725905128218; + bpsToRay[2647] = 1000000007446567122594834957; + bpsToRay[2648] = 1000000007449074321032190415; + bpsToRay[2649] = 1000000007451581321248542554; + bpsToRay[2650] = 1000000007454088123275231904; + bpsToRay[2651] = 1000000007456594727143591558; + bpsToRay[2652] = 1000000007459101132884947181; + bpsToRay[2653] = 1000000007461607340530617012; + bpsToRay[2654] = 1000000007464113350111911864; + bpsToRay[2655] = 1000000007466619161660135123; + bpsToRay[2656] = 1000000007469124775206582763; + bpsToRay[2657] = 1000000007471630190782543332; + bpsToRay[2658] = 1000000007474135408419297966; + bpsToRay[2659] = 1000000007476640428148120386; + bpsToRay[2660] = 1000000007479145250000276903; + bpsToRay[2661] = 1000000007481649874007026420; + bpsToRay[2662] = 1000000007484154300199620430; + bpsToRay[2663] = 1000000007486658528609303027; + bpsToRay[2664] = 1000000007489162559267310898; + bpsToRay[2665] = 1000000007491666392204873334; + bpsToRay[2666] = 1000000007494170027453212228; + bpsToRay[2667] = 1000000007496673465043542080; + bpsToRay[2668] = 1000000007499176705007069991; + bpsToRay[2669] = 1000000007501679747374995682; + bpsToRay[2670] = 1000000007504182592178511478; + bpsToRay[2671] = 1000000007506685239448802322; + bpsToRay[2672] = 1000000007509187689217045773; + bpsToRay[2673] = 1000000007511689941514412011; + bpsToRay[2674] = 1000000007514191996372063835; + bpsToRay[2675] = 1000000007516693853821156670; + bpsToRay[2676] = 1000000007519195513892838566; + bpsToRay[2677] = 1000000007521696976618250202; + bpsToRay[2678] = 1000000007524198242028524886; + bpsToRay[2679] = 1000000007526699310154788564; + bpsToRay[2680] = 1000000007529200181028159813; + bpsToRay[2681] = 1000000007531700854679749850; + bpsToRay[2682] = 1000000007534201331140662531; + bpsToRay[2683] = 1000000007536701610441994354; + bpsToRay[2684] = 1000000007539201692614834466; + bpsToRay[2685] = 1000000007541701577690264654; + bpsToRay[2686] = 1000000007544201265699359361; + bpsToRay[2687] = 1000000007546700756673185679; + bpsToRay[2688] = 1000000007549200050642803353; + bpsToRay[2689] = 1000000007551699147639264788; + bpsToRay[2690] = 1000000007554198047693615043; + bpsToRay[2691] = 1000000007556696750836891842; + bpsToRay[2692] = 1000000007559195257100125570; + bpsToRay[2693] = 1000000007561693566514339279; + bpsToRay[2694] = 1000000007564191679110548687; + bpsToRay[2695] = 1000000007566689594919762187; + bpsToRay[2696] = 1000000007569187313972980838; + bpsToRay[2697] = 1000000007571684836301198378; + bpsToRay[2698] = 1000000007574182161935401222; + bpsToRay[2699] = 1000000007576679290906568463; + bpsToRay[2700] = 1000000007579176223245671878; + bpsToRay[2701] = 1000000007581672958983675926; + bpsToRay[2702] = 1000000007584169498151537752; + bpsToRay[2703] = 1000000007586665840780207194; + bpsToRay[2704] = 1000000007589161986900626776; + bpsToRay[2705] = 1000000007591657936543731717; + bpsToRay[2706] = 1000000007594153689740449933; + bpsToRay[2707] = 1000000007596649246521702037; + bpsToRay[2708] = 1000000007599144606918401342; + bpsToRay[2709] = 1000000007601639770961453862; + bpsToRay[2710] = 1000000007604134738681758320; + bpsToRay[2711] = 1000000007606629510110206142; + bpsToRay[2712] = 1000000007609124085277681464; + bpsToRay[2713] = 1000000007611618464215061138; + bpsToRay[2714] = 1000000007614112646953214725; + bpsToRay[2715] = 1000000007616606633523004503; + bpsToRay[2716] = 1000000007619100423955285470; + bpsToRay[2717] = 1000000007621594018280905346; + bpsToRay[2718] = 1000000007624087416530704571; + bpsToRay[2719] = 1000000007626580618735516314; + bpsToRay[2720] = 1000000007629073624926166467; + bpsToRay[2721] = 1000000007631566435133473656; + bpsToRay[2722] = 1000000007634059049388249240; + bpsToRay[2723] = 1000000007636551467721297309; + bpsToRay[2724] = 1000000007639043690163414692; + bpsToRay[2725] = 1000000007641535716745390957; + bpsToRay[2726] = 1000000007644027547498008412; + bpsToRay[2727] = 1000000007646519182452042112; + bpsToRay[2728] = 1000000007649010621638259855; + bpsToRay[2729] = 1000000007651501865087422189; + bpsToRay[2730] = 1000000007653992912830282410; + bpsToRay[2731] = 1000000007656483764897586571; + bpsToRay[2732] = 1000000007658974421320073477; + bpsToRay[2733] = 1000000007661464882128474691; + bpsToRay[2734] = 1000000007663955147353514535; + bpsToRay[2735] = 1000000007666445217025910095; + bpsToRay[2736] = 1000000007668935091176371220; + bpsToRay[2737] = 1000000007671424769835600527; + bpsToRay[2738] = 1000000007673914253034293397; + bpsToRay[2739] = 1000000007676403540803137988; + bpsToRay[2740] = 1000000007678892633172815227; + bpsToRay[2741] = 1000000007681381530173998820; + bpsToRay[2742] = 1000000007683870231837355249; + bpsToRay[2743] = 1000000007686358738193543774; + bpsToRay[2744] = 1000000007688847049273216443; + bpsToRay[2745] = 1000000007691335165107018082; + bpsToRay[2746] = 1000000007693823085725586308; + bpsToRay[2747] = 1000000007696310811159551528; + bpsToRay[2748] = 1000000007698798341439536935; + bpsToRay[2749] = 1000000007701285676596158525; + bpsToRay[2750] = 1000000007703772816660025079; + bpsToRay[2751] = 1000000007706259761661738185; + bpsToRay[2752] = 1000000007708746511631892227; + bpsToRay[2753] = 1000000007711233066601074392; + bpsToRay[2754] = 1000000007713719426599864675; + bpsToRay[2755] = 1000000007716205591658835874; + bpsToRay[2756] = 1000000007718691561808553598; + bpsToRay[2757] = 1000000007721177337079576270; + bpsToRay[2758] = 1000000007723662917502455126; + bpsToRay[2759] = 1000000007726148303107734216; + bpsToRay[2760] = 1000000007728633493925950409; + bpsToRay[2761] = 1000000007731118489987633399; + bpsToRay[2762] = 1000000007733603291323305697; + bpsToRay[2763] = 1000000007736087897963482645; + bpsToRay[2764] = 1000000007738572309938672406; + bpsToRay[2765] = 1000000007741056527279375980; + bpsToRay[2766] = 1000000007743540550016087193; + bpsToRay[2767] = 1000000007746024378179292708; + bpsToRay[2768] = 1000000007748508011799472026; + bpsToRay[2769] = 1000000007750991450907097483; + bpsToRay[2770] = 1000000007753474695532634259; + bpsToRay[2771] = 1000000007755957745706540376; + bpsToRay[2772] = 1000000007758440601459266700; + bpsToRay[2773] = 1000000007760923262821256948; + bpsToRay[2774] = 1000000007763405729822947685; + bpsToRay[2775] = 1000000007765888002494768329; + bpsToRay[2776] = 1000000007768370080867141151; + bpsToRay[2777] = 1000000007770851964970481280; + bpsToRay[2778] = 1000000007773333654835196703; + bpsToRay[2779] = 1000000007775815150491688269; + bpsToRay[2780] = 1000000007778296451970349690; + bpsToRay[2781] = 1000000007780777559301567543; + bpsToRay[2782] = 1000000007783258472515721274; + bpsToRay[2783] = 1000000007785739191643183199; + bpsToRay[2784] = 1000000007788219716714318505; + bpsToRay[2785] = 1000000007790700047759485254; + bpsToRay[2786] = 1000000007793180184809034386; + bpsToRay[2787] = 1000000007795660127893309718; + bpsToRay[2788] = 1000000007798139877042647950; + bpsToRay[2789] = 1000000007800619432287378665; + bpsToRay[2790] = 1000000007803098793657824331; + bpsToRay[2791] = 1000000007805577961184300304; + bpsToRay[2792] = 1000000007808056934897114831; + bpsToRay[2793] = 1000000007810535714826569051; + bpsToRay[2794] = 1000000007813014301002956995; + bpsToRay[2795] = 1000000007815492693456565596; + bpsToRay[2796] = 1000000007817970892217674682; + bpsToRay[2797] = 1000000007820448897316556983; + bpsToRay[2798] = 1000000007822926708783478132; + bpsToRay[2799] = 1000000007825404326648696672; + bpsToRay[2800] = 1000000007827881750942464045; + bpsToRay[2801] = 1000000007830358981695024613; + bpsToRay[2802] = 1000000007832836018936615642; + bpsToRay[2803] = 1000000007835312862697467319; + bpsToRay[2804] = 1000000007837789513007802744; + bpsToRay[2805] = 1000000007840265969897837937; + bpsToRay[2806] = 1000000007842742233397781838; + bpsToRay[2807] = 1000000007845218303537836314; + bpsToRay[2808] = 1000000007847694180348196153; + bpsToRay[2809] = 1000000007850169863859049072; + bpsToRay[2810] = 1000000007852645354100575721; + bpsToRay[2811] = 1000000007855120651102949679; + bpsToRay[2812] = 1000000007857595754896337460; + bpsToRay[2813] = 1000000007860070665510898517; + bpsToRay[2814] = 1000000007862545382976785237; + bpsToRay[2815] = 1000000007865019907324142954; + bpsToRay[2816] = 1000000007867494238583109939; + bpsToRay[2817] = 1000000007869968376783817414; + bpsToRay[2818] = 1000000007872442321956389545; + bpsToRay[2819] = 1000000007874916074130943450; + bpsToRay[2820] = 1000000007877389633337589198; + bpsToRay[2821] = 1000000007879862999606429812; + bpsToRay[2822] = 1000000007882336172967561271; + bpsToRay[2823] = 1000000007884809153451072514; + bpsToRay[2824] = 1000000007887281941087045441; + bpsToRay[2825] = 1000000007889754535905554913; + bpsToRay[2826] = 1000000007892226937936668759; + bpsToRay[2827] = 1000000007894699147210447772; + bpsToRay[2828] = 1000000007897171163756945718; + bpsToRay[2829] = 1000000007899642987606209333; + bpsToRay[2830] = 1000000007902114618788278327; + bpsToRay[2831] = 1000000007904586057333185387; + bpsToRay[2832] = 1000000007907057303270956176; + bpsToRay[2833] = 1000000007909528356631609343; + bpsToRay[2834] = 1000000007911999217445156512; + bpsToRay[2835] = 1000000007914469885741602299; + bpsToRay[2836] = 1000000007916940361550944303; + bpsToRay[2837] = 1000000007919410644903173113; + bpsToRay[2838] = 1000000007921880735828272312; + bpsToRay[2839] = 1000000007924350634356218473; + bpsToRay[2840] = 1000000007926820340516981166; + bpsToRay[2841] = 1000000007929289854340522961; + bpsToRay[2842] = 1000000007931759175856799426; + bpsToRay[2843] = 1000000007934228305095759133; + bpsToRay[2844] = 1000000007936697242087343656; + bpsToRay[2845] = 1000000007939165986861487579; + bpsToRay[2846] = 1000000007941634539448118494; + bpsToRay[2847] = 1000000007944102899877157001; + bpsToRay[2848] = 1000000007946571068178516718; + bpsToRay[2849] = 1000000007949039044382104276; + bpsToRay[2850] = 1000000007951506828517819323; + bpsToRay[2851] = 1000000007953974420615554529; + bpsToRay[2852] = 1000000007956441820705195583; + bpsToRay[2853] = 1000000007958909028816621201; + bpsToRay[2854] = 1000000007961376044979703124; + bpsToRay[2855] = 1000000007963842869224306123; + bpsToRay[2856] = 1000000007966309501580287995; + bpsToRay[2857] = 1000000007968775942077499577; + bpsToRay[2858] = 1000000007971242190745784735; + bpsToRay[2859] = 1000000007973708247614980375; + bpsToRay[2860] = 1000000007976174112714916441; + bpsToRay[2861] = 1000000007978639786075415919; + bpsToRay[2862] = 1000000007981105267726294840; + bpsToRay[2863] = 1000000007983570557697362280; + bpsToRay[2864] = 1000000007986035656018420361; + bpsToRay[2865] = 1000000007988500562719264258; + bpsToRay[2866] = 1000000007990965277829682196; + bpsToRay[2867] = 1000000007993429801379455456; + bpsToRay[2868] = 1000000007995894133398358376; + bpsToRay[2869] = 1000000007998358273916158351; + bpsToRay[2870] = 1000000008000822222962615839; + bpsToRay[2871] = 1000000008003285980567484358; + bpsToRay[2872] = 1000000008005749546760510496; + bpsToRay[2873] = 1000000008008212921571433904; + bpsToRay[2874] = 1000000008010676105029987304; + bpsToRay[2875] = 1000000008013139097165896490; + bpsToRay[2876] = 1000000008015601898008880332; + bpsToRay[2877] = 1000000008018064507588650772; + bpsToRay[2878] = 1000000008020526925934912831; + bpsToRay[2879] = 1000000008022989153077364614; + bpsToRay[2880] = 1000000008025451189045697303; + bpsToRay[2881] = 1000000008027913033869595170; + bpsToRay[2882] = 1000000008030374687578735570; + bpsToRay[2883] = 1000000008032836150202788948; + bpsToRay[2884] = 1000000008035297421771418841; + bpsToRay[2885] = 1000000008037758502314281877; + bpsToRay[2886] = 1000000008040219391861027783; + bpsToRay[2887] = 1000000008042680090441299379; + bpsToRay[2888] = 1000000008045140598084732587; + bpsToRay[2889] = 1000000008047600914820956433; + bpsToRay[2890] = 1000000008050061040679593042; + bpsToRay[2891] = 1000000008052520975690257649; + bpsToRay[2892] = 1000000008054980719882558595; + bpsToRay[2893] = 1000000008057440273286097333; + bpsToRay[2894] = 1000000008059899635930468427; + bpsToRay[2895] = 1000000008062358807845259556; + bpsToRay[2896] = 1000000008064817789060051517; + bpsToRay[2897] = 1000000008067276579604418223; + bpsToRay[2898] = 1000000008069735179507926713; + bpsToRay[2899] = 1000000008072193588800137143; + bpsToRay[2900] = 1000000008074651807510602798; + bpsToRay[2901] = 1000000008077109835668870091; + bpsToRay[2902] = 1000000008079567673304478561; + bpsToRay[2903] = 1000000008082025320446960884; + bpsToRay[2904] = 1000000008084482777125842863; + bpsToRay[2905] = 1000000008086940043370643444; + bpsToRay[2906] = 1000000008089397119210874706; + bpsToRay[2907] = 1000000008091854004676041869; + bpsToRay[2908] = 1000000008094310699795643299; + bpsToRay[2909] = 1000000008096767204599170500; + bpsToRay[2910] = 1000000008099223519116108130; + bpsToRay[2911] = 1000000008101679643375933989; + bpsToRay[2912] = 1000000008104135577408119032; + bpsToRay[2913] = 1000000008106591321242127364; + bpsToRay[2914] = 1000000008109046874907416248; + bpsToRay[2915] = 1000000008111502238433436104; + bpsToRay[2916] = 1000000008113957411849630507; + bpsToRay[2917] = 1000000008116412395185436200; + bpsToRay[2918] = 1000000008118867188470283082; + bpsToRay[2919] = 1000000008121321791733594224; + bpsToRay[2920] = 1000000008123776205004785863; + bpsToRay[2921] = 1000000008126230428313267405; + bpsToRay[2922] = 1000000008128684461688441426; + bpsToRay[2923] = 1000000008131138305159703681; + bpsToRay[2924] = 1000000008133591958756443098; + bpsToRay[2925] = 1000000008136045422508041783; + bpsToRay[2926] = 1000000008138498696443875023; + bpsToRay[2927] = 1000000008140951780593311289; + bpsToRay[2928] = 1000000008143404674985712235; + bpsToRay[2929] = 1000000008145857379650432701; + bpsToRay[2930] = 1000000008148309894616820721; + bpsToRay[2931] = 1000000008150762219914217511; + bpsToRay[2932] = 1000000008153214355571957489; + bpsToRay[2933] = 1000000008155666301619368262; + bpsToRay[2934] = 1000000008158118058085770639; + bpsToRay[2935] = 1000000008160569625000478625; + bpsToRay[2936] = 1000000008163021002392799426; + bpsToRay[2937] = 1000000008165472190292033455; + bpsToRay[2938] = 1000000008167923188727474329; + bpsToRay[2939] = 1000000008170373997728408871; + bpsToRay[2940] = 1000000008172824617324117117; + bpsToRay[2941] = 1000000008175275047543872314; + bpsToRay[2942] = 1000000008177725288416940921; + bpsToRay[2943] = 1000000008180175339972582615; + bpsToRay[2944] = 1000000008182625202240050293; + bpsToRay[2945] = 1000000008185074875248590068; + bpsToRay[2946] = 1000000008187524359027441281; + bpsToRay[2947] = 1000000008189973653605836492; + bpsToRay[2948] = 1000000008192422759013001491; + bpsToRay[2949] = 1000000008194871675278155297; + bpsToRay[2950] = 1000000008197320402430510158; + bpsToRay[2951] = 1000000008199768940499271556; + bpsToRay[2952] = 1000000008202217289513638208; + bpsToRay[2953] = 1000000008204665449502802068; + bpsToRay[2954] = 1000000008207113420495948328; + bpsToRay[2955] = 1000000008209561202522255424; + bpsToRay[2956] = 1000000008212008795610895033; + bpsToRay[2957] = 1000000008214456199791032080; + bpsToRay[2958] = 1000000008216903415091824734; + bpsToRay[2959] = 1000000008219350441542424416; + bpsToRay[2960] = 1000000008221797279171975799; + bpsToRay[2961] = 1000000008224243928009616809; + bpsToRay[2962] = 1000000008226690388084478627; + bpsToRay[2963] = 1000000008229136659425685693; + bpsToRay[2964] = 1000000008231582742062355709; + bpsToRay[2965] = 1000000008234028636023599636; + bpsToRay[2966] = 1000000008236474341338521699; + bpsToRay[2967] = 1000000008238919858036219393; + bpsToRay[2968] = 1000000008241365186145783477; + bpsToRay[2969] = 1000000008243810325696297983; + bpsToRay[2970] = 1000000008246255276716840215; + bpsToRay[2971] = 1000000008248700039236480752; + bpsToRay[2972] = 1000000008251144613284283449; + bpsToRay[2973] = 1000000008253588998889305439; + bpsToRay[2974] = 1000000008256033196080597139; + bpsToRay[2975] = 1000000008258477204887202245; + bpsToRay[2976] = 1000000008260921025338157740; + bpsToRay[2977] = 1000000008263364657462493893; + bpsToRay[2978] = 1000000008265808101289234264; + bpsToRay[2979] = 1000000008268251356847395701; + bpsToRay[2980] = 1000000008270694424165988349; + bpsToRay[2981] = 1000000008273137303274015646; + bpsToRay[2982] = 1000000008275579994200474327; + bpsToRay[2983] = 1000000008278022496974354428; + bpsToRay[2984] = 1000000008280464811624639285; + bpsToRay[2985] = 1000000008282906938180305537; + bpsToRay[2986] = 1000000008285348876670323134; + bpsToRay[2987] = 1000000008287790627123655325; + bpsToRay[2988] = 1000000008290232189569258676; + bpsToRay[2989] = 1000000008292673564036083061; + bpsToRay[2990] = 1000000008295114750553071670; + bpsToRay[2991] = 1000000008297555749149161005; + bpsToRay[2992] = 1000000008299996559853280893; + bpsToRay[2993] = 1000000008302437182694354473; + bpsToRay[2994] = 1000000008304877617701298212; + bpsToRay[2995] = 1000000008307317864903021899; + bpsToRay[2996] = 1000000008309757924328428649; + bpsToRay[2997] = 1000000008312197796006414905; + bpsToRay[2998] = 1000000008314637479965870443; + bpsToRay[2999] = 1000000008317076976235678365; + bpsToRay[3000] = 1000000008319516284844715115; + bpsToRay[3001] = 1000000008321955405821850471; + bpsToRay[3002] = 1000000008324394339195947545; + bpsToRay[3003] = 1000000008326833084995862796; + bpsToRay[3004] = 1000000008329271643250446021; + bpsToRay[3005] = 1000000008331710013988540364; + bpsToRay[3006] = 1000000008334148197238982316; + bpsToRay[3007] = 1000000008336586193030601715; + bpsToRay[3008] = 1000000008339024001392221751; + bpsToRay[3009] = 1000000008341461622352658967; + bpsToRay[3010] = 1000000008343899055940723259; + bpsToRay[3011] = 1000000008346336302185217882; + bpsToRay[3012] = 1000000008348773361114939450; + bpsToRay[3013] = 1000000008351210232758677936; + bpsToRay[3014] = 1000000008353646917145216679; + bpsToRay[3015] = 1000000008356083414303332380; + bpsToRay[3016] = 1000000008358519724261795110; + bpsToRay[3017] = 1000000008360955847049368306; + bpsToRay[3018] = 1000000008363391782694808779; + bpsToRay[3019] = 1000000008365827531226866712; + bpsToRay[3020] = 1000000008368263092674285664; + bpsToRay[3021] = 1000000008370698467065802570; + bpsToRay[3022] = 1000000008373133654430147746; + bpsToRay[3023] = 1000000008375568654796044887; + bpsToRay[3024] = 1000000008378003468192211075; + bpsToRay[3025] = 1000000008380438094647356774; + bpsToRay[3026] = 1000000008382872534190185837; + bpsToRay[3027] = 1000000008385306786849395508; + bpsToRay[3028] = 1000000008387740852653676418; + bpsToRay[3029] = 1000000008390174731631712596; + bpsToRay[3030] = 1000000008392608423812181466; + bpsToRay[3031] = 1000000008395041929223753848; + bpsToRay[3032] = 1000000008397475247895093962; + bpsToRay[3033] = 1000000008399908379854859430; + bpsToRay[3034] = 1000000008402341325131701278; + bpsToRay[3035] = 1000000008404774083754263937; + bpsToRay[3036] = 1000000008407206655751185247; + bpsToRay[3037] = 1000000008409639041151096456; + bpsToRay[3038] = 1000000008412071239982622226; + bpsToRay[3039] = 1000000008414503252274380631; + bpsToRay[3040] = 1000000008416935078054983162; + bpsToRay[3041] = 1000000008419366717353034726; + bpsToRay[3042] = 1000000008421798170197133652; + bpsToRay[3043] = 1000000008424229436615871690; + bpsToRay[3044] = 1000000008426660516637834013; + bpsToRay[3045] = 1000000008429091410291599222; + bpsToRay[3046] = 1000000008431522117605739346; + bpsToRay[3047] = 1000000008433952638608819840; + bpsToRay[3048] = 1000000008436382973329399595; + bpsToRay[3049] = 1000000008438813121796030934; + bpsToRay[3050] = 1000000008441243084037259619; + bpsToRay[3051] = 1000000008443672860081624846; + bpsToRay[3052] = 1000000008446102449957659252; + bpsToRay[3053] = 1000000008448531853693888919; + bpsToRay[3054] = 1000000008450961071318833369; + bpsToRay[3055] = 1000000008453390102861005572; + bpsToRay[3056] = 1000000008455818948348911946; + bpsToRay[3057] = 1000000008458247607811052360; + bpsToRay[3058] = 1000000008460676081275920133; + bpsToRay[3059] = 1000000008463104368772002040; + bpsToRay[3060] = 1000000008465532470327778310; + bpsToRay[3061] = 1000000008467960385971722632; + bpsToRay[3062] = 1000000008470388115732302154; + bpsToRay[3063] = 1000000008472815659637977489; + bpsToRay[3064] = 1000000008475243017717202707; + bpsToRay[3065] = 1000000008477670189998425353; + bpsToRay[3066] = 1000000008480097176510086432; + bpsToRay[3067] = 1000000008482523977280620426; + bpsToRay[3068] = 1000000008484950592338455283; + bpsToRay[3069] = 1000000008487377021712012431; + bpsToRay[3070] = 1000000008489803265429706768; + bpsToRay[3071] = 1000000008492229323519946677; + bpsToRay[3072] = 1000000008494655196011134014; + bpsToRay[3073] = 1000000008497080882931664122; + bpsToRay[3074] = 1000000008499506384309925825; + bpsToRay[3075] = 1000000008501931700174301437; + bpsToRay[3076] = 1000000008504356830553166755; + bpsToRay[3077] = 1000000008506781775474891069; + bpsToRay[3078] = 1000000008509206534967837162; + bpsToRay[3079] = 1000000008511631109060361308; + bpsToRay[3080] = 1000000008514055497780813280; + bpsToRay[3081] = 1000000008516479701157536348; + bpsToRay[3082] = 1000000008518903719218867280; + bpsToRay[3083] = 1000000008521327551993136348; + bpsToRay[3084] = 1000000008523751199508667330; + bpsToRay[3085] = 1000000008526174661793777504; + bpsToRay[3086] = 1000000008528597938876777661; + bpsToRay[3087] = 1000000008531021030785972101; + bpsToRay[3088] = 1000000008533443937549658636; + bpsToRay[3089] = 1000000008535866659196128590; + bpsToRay[3090] = 1000000008538289195753666803; + bpsToRay[3091] = 1000000008540711547250551637; + bpsToRay[3092] = 1000000008543133713715054969; + bpsToRay[3093] = 1000000008545555695175442199; + bpsToRay[3094] = 1000000008547977491659972252; + bpsToRay[3095] = 1000000008550399103196897579; + bpsToRay[3096] = 1000000008552820529814464158; + bpsToRay[3097] = 1000000008555241771540911495; + bpsToRay[3098] = 1000000008557662828404472630; + bpsToRay[3099] = 1000000008560083700433374138; + bpsToRay[3100] = 1000000008562504387655836125; + bpsToRay[3101] = 1000000008564924890100072238; + bpsToRay[3102] = 1000000008567345207794289664; + bpsToRay[3103] = 1000000008569765340766689130; + bpsToRay[3104] = 1000000008572185289045464906; + bpsToRay[3105] = 1000000008574605052658804811; + bpsToRay[3106] = 1000000008577024631634890207; + bpsToRay[3107] = 1000000008579444026001896008; + bpsToRay[3108] = 1000000008581863235787990679; + bpsToRay[3109] = 1000000008584282261021336238; + bpsToRay[3110] = 1000000008586701101730088259; + bpsToRay[3111] = 1000000008589119757942395872; + bpsToRay[3112] = 1000000008591538229686401769; + bpsToRay[3113] = 1000000008593956516990242201; + bpsToRay[3114] = 1000000008596374619882046982; + bpsToRay[3115] = 1000000008598792538389939493; + bpsToRay[3116] = 1000000008601210272542036680; + bpsToRay[3117] = 1000000008603627822366449059; + bpsToRay[3118] = 1000000008606045187891280718; + bpsToRay[3119] = 1000000008608462369144629317; + bpsToRay[3120] = 1000000008610879366154586092; + bpsToRay[3121] = 1000000008613296178949235855; + bpsToRay[3122] = 1000000008615712807556656995; + bpsToRay[3123] = 1000000008618129252004921486; + bpsToRay[3124] = 1000000008620545512322094883; + bpsToRay[3125] = 1000000008622961588536236324; + bpsToRay[3126] = 1000000008625377480675398538; + bpsToRay[3127] = 1000000008627793188767627836; + bpsToRay[3128] = 1000000008630208712840964127; + bpsToRay[3129] = 1000000008632624052923440907; + bpsToRay[3130] = 1000000008635039209043085270; + bpsToRay[3131] = 1000000008637454181227917904; + bpsToRay[3132] = 1000000008639868969505953098; + bpsToRay[3133] = 1000000008642283573905198739; + bpsToRay[3134] = 1000000008644697994453656318; + bpsToRay[3135] = 1000000008647112231179320929; + bpsToRay[3136] = 1000000008649526284110181275; + bpsToRay[3137] = 1000000008651940153274219662; + bpsToRay[3138] = 1000000008654353838699412010; + bpsToRay[3139] = 1000000008656767340413727852; + bpsToRay[3140] = 1000000008659180658445130332; + bpsToRay[3141] = 1000000008661593792821576212; + bpsToRay[3142] = 1000000008664006743571015870; + bpsToRay[3143] = 1000000008666419510721393305; + bpsToRay[3144] = 1000000008668832094300646140; + bpsToRay[3145] = 1000000008671244494336705617; + bpsToRay[3146] = 1000000008673656710857496608; + bpsToRay[3147] = 1000000008676068743890937609; + bpsToRay[3148] = 1000000008678480593464940750; + bpsToRay[3149] = 1000000008680892259607411787; + bpsToRay[3150] = 1000000008683303742346250114; + bpsToRay[3151] = 1000000008685715041709348759; + bpsToRay[3152] = 1000000008688126157724594385; + bpsToRay[3153] = 1000000008690537090419867299; + bpsToRay[3154] = 1000000008692947839823041443; + bpsToRay[3155] = 1000000008695358405961984408; + bpsToRay[3156] = 1000000008697768788864557426; + bpsToRay[3157] = 1000000008700178988558615379; + bpsToRay[3158] = 1000000008702589005072006795; + bpsToRay[3159] = 1000000008704998838432573855; + bpsToRay[3160] = 1000000008707408488668152392; + bpsToRay[3161] = 1000000008709817955806571893; + bpsToRay[3162] = 1000000008712227239875655502; + bpsToRay[3163] = 1000000008714636340903220022; + bpsToRay[3164] = 1000000008717045258917075917; + bpsToRay[3165] = 1000000008719453993945027311; + bpsToRay[3166] = 1000000008721862546014871996; + bpsToRay[3167] = 1000000008724270915154401427; + bpsToRay[3168] = 1000000008726679101391400728; + bpsToRay[3169] = 1000000008729087104753648695; + bpsToRay[3170] = 1000000008731494925268917794; + bpsToRay[3171] = 1000000008733902562964974164; + bpsToRay[3172] = 1000000008736310017869577622; + bpsToRay[3173] = 1000000008738717290010481663; + bpsToRay[3174] = 1000000008741124379415433461; + bpsToRay[3175] = 1000000008743531286112173869; + bpsToRay[3176] = 1000000008745938010128437428; + bpsToRay[3177] = 1000000008748344551491952362; + bpsToRay[3178] = 1000000008750750910230440583; + bpsToRay[3179] = 1000000008753157086371617690; + bpsToRay[3180] = 1000000008755563079943192978; + bpsToRay[3181] = 1000000008757968890972869430; + bpsToRay[3182] = 1000000008760374519488343729; + bpsToRay[3183] = 1000000008762779965517306250; + bpsToRay[3184] = 1000000008765185229087441070; + bpsToRay[3185] = 1000000008767590310226425966; + bpsToRay[3186] = 1000000008769995208961932417; + bpsToRay[3187] = 1000000008772399925321625609; + bpsToRay[3188] = 1000000008774804459333164431; + bpsToRay[3189] = 1000000008777208811024201482; + bpsToRay[3190] = 1000000008779612980422383073; + bpsToRay[3191] = 1000000008782016967555349225; + bpsToRay[3192] = 1000000008784420772450733672; + bpsToRay[3193] = 1000000008786824395136163869; + bpsToRay[3194] = 1000000008789227835639260984; + bpsToRay[3195] = 1000000008791631093987639905; + bpsToRay[3196] = 1000000008794034170208909246; + bpsToRay[3197] = 1000000008796437064330671341; + bpsToRay[3198] = 1000000008798839776380522251; + bpsToRay[3199] = 1000000008801242306386051763; + bpsToRay[3200] = 1000000008803644654374843395; + bpsToRay[3201] = 1000000008806046820374474396; + bpsToRay[3202] = 1000000008808448804412515748; + bpsToRay[3203] = 1000000008810850606516532167; + bpsToRay[3204] = 1000000008813252226714082106; + bpsToRay[3205] = 1000000008815653665032717760; + bpsToRay[3206] = 1000000008818054921499985060; + bpsToRay[3207] = 1000000008820455996143423684; + bpsToRay[3208] = 1000000008822856888990567050; + bpsToRay[3209] = 1000000008825257600068942328; + bpsToRay[3210] = 1000000008827658129406070432; + bpsToRay[3211] = 1000000008830058477029466028; + bpsToRay[3212] = 1000000008832458642966637533; + bpsToRay[3213] = 1000000008834858627245087117; + bpsToRay[3214] = 1000000008837258429892310711; + bpsToRay[3215] = 1000000008839658050935797999; + bpsToRay[3216] = 1000000008842057490403032425; + bpsToRay[3217] = 1000000008844456748321491195; + bpsToRay[3218] = 1000000008846855824718645282; + bpsToRay[3219] = 1000000008849254719621959420; + bpsToRay[3220] = 1000000008851653433058892110; + bpsToRay[3221] = 1000000008854051965056895625; + bpsToRay[3222] = 1000000008856450315643416008; + bpsToRay[3223] = 1000000008858848484845893073; + bpsToRay[3224] = 1000000008861246472691760412; + bpsToRay[3225] = 1000000008863644279208445392; + bpsToRay[3226] = 1000000008866041904423369157; + bpsToRay[3227] = 1000000008868439348363946634; + bpsToRay[3228] = 1000000008870836611057586530; + bpsToRay[3229] = 1000000008873233692531691339; + bpsToRay[3230] = 1000000008875630592813657337; + bpsToRay[3231] = 1000000008878027311930874594; + bpsToRay[3232] = 1000000008880423849910726963; + bpsToRay[3233] = 1000000008882820206780592093; + bpsToRay[3234] = 1000000008885216382567841425; + bpsToRay[3235] = 1000000008887612377299840196; + bpsToRay[3236] = 1000000008890008191003947440; + bpsToRay[3237] = 1000000008892403823707515991; + bpsToRay[3238] = 1000000008894799275437892482; + bpsToRay[3239] = 1000000008897194546222417351; + bpsToRay[3240] = 1000000008899589636088424841; + bpsToRay[3241] = 1000000008901984545063242999; + bpsToRay[3242] = 1000000008904379273174193682; + bpsToRay[3243] = 1000000008906773820448592561; + bpsToRay[3244] = 1000000008909168186913749112; + bpsToRay[3245] = 1000000008911562372596966632; + bpsToRay[3246] = 1000000008913956377525542231; + bpsToRay[3247] = 1000000008916350201726766834; + bpsToRay[3248] = 1000000008918743845227925192; + bpsToRay[3249] = 1000000008921137308056295874; + bpsToRay[3250] = 1000000008923530590239151272; + bpsToRay[3251] = 1000000008925923691803757605; + bpsToRay[3252] = 1000000008928316612777374918; + bpsToRay[3253] = 1000000008930709353187257086; + bpsToRay[3254] = 1000000008933101913060651814; + bpsToRay[3255] = 1000000008935494292424800641; + bpsToRay[3256] = 1000000008937886491306938939; + bpsToRay[3257] = 1000000008940278509734295919; + bpsToRay[3258] = 1000000008942670347734094627; + bpsToRay[3259] = 1000000008945062005333551953; + bpsToRay[3260] = 1000000008947453482559878626; + bpsToRay[3261] = 1000000008949844779440279220; + bpsToRay[3262] = 1000000008952235896001952156; + bpsToRay[3263] = 1000000008954626832272089702; + bpsToRay[3264] = 1000000008957017588277877973; + bpsToRay[3265] = 1000000008959408164046496940; + bpsToRay[3266] = 1000000008961798559605120424; + bpsToRay[3267] = 1000000008964188774980916101; + bpsToRay[3268] = 1000000008966578810201045506; + bpsToRay[3269] = 1000000008968968665292664032; + bpsToRay[3270] = 1000000008971358340282920931; + bpsToRay[3271] = 1000000008973747835198959319; + bpsToRay[3272] = 1000000008976137150067916177; + bpsToRay[3273] = 1000000008978526284916922351; + bpsToRay[3274] = 1000000008980915239773102555; + bpsToRay[3275] = 1000000008983304014663575373; + bpsToRay[3276] = 1000000008985692609615453262; + bpsToRay[3277] = 1000000008988081024655842550; + bpsToRay[3278] = 1000000008990469259811843445; + bpsToRay[3279] = 1000000008992857315110550026; + bpsToRay[3280] = 1000000008995245190579050256; + bpsToRay[3281] = 1000000008997632886244425977; + bpsToRay[3282] = 1000000009000020402133752914; + bpsToRay[3283] = 1000000009002407738274100677; + bpsToRay[3284] = 1000000009004794894692532763; + bpsToRay[3285] = 1000000009007181871416106556; + bpsToRay[3286] = 1000000009009568668471873331; + bpsToRay[3287] = 1000000009011955285886878254; + bpsToRay[3288] = 1000000009014341723688160386; + bpsToRay[3289] = 1000000009016727981902752684; + bpsToRay[3290] = 1000000009019114060557682002; + bpsToRay[3291] = 1000000009021499959679969092; + bpsToRay[3292] = 1000000009023885679296628609; + bpsToRay[3293] = 1000000009026271219434669112; + bpsToRay[3294] = 1000000009028656580121093060; + bpsToRay[3295] = 1000000009031041761382896825; + bpsToRay[3296] = 1000000009033426763247070684; + bpsToRay[3297] = 1000000009035811585740598824; + bpsToRay[3298] = 1000000009038196228890459345; + bpsToRay[3299] = 1000000009040580692723624262; + bpsToRay[3300] = 1000000009042964977267059505; + bpsToRay[3301] = 1000000009045349082547724920; + bpsToRay[3302] = 1000000009047733008592574277; + bpsToRay[3303] = 1000000009050116755428555263; + bpsToRay[3304] = 1000000009052500323082609490; + bpsToRay[3305] = 1000000009054883711581672494; + bpsToRay[3306] = 1000000009057266920952673739; + bpsToRay[3307] = 1000000009059649951222536617; + bpsToRay[3308] = 1000000009062032802418178451; + bpsToRay[3309] = 1000000009064415474566510497; + bpsToRay[3310] = 1000000009066797967694437943; + bpsToRay[3311] = 1000000009069180281828859914; + bpsToRay[3312] = 1000000009071562416996669472; + bpsToRay[3313] = 1000000009073944373224753622; + bpsToRay[3314] = 1000000009076326150539993305; + bpsToRay[3315] = 1000000009078707748969263409; + bpsToRay[3316] = 1000000009081089168539432766; + bpsToRay[3317] = 1000000009083470409277364157; + bpsToRay[3318] = 1000000009085851471209914307; + bpsToRay[3319] = 1000000009088232354363933896; + bpsToRay[3320] = 1000000009090613058766267552; + bpsToRay[3321] = 1000000009092993584443753863; + bpsToRay[3322] = 1000000009095373931423225367; + bpsToRay[3323] = 1000000009097754099731508564; + bpsToRay[3324] = 1000000009100134089395423911; + bpsToRay[3325] = 1000000009102513900441785827; + bpsToRay[3326] = 1000000009104893532897402697; + bpsToRay[3327] = 1000000009107272986789076865; + bpsToRay[3328] = 1000000009109652262143604647; + bpsToRay[3329] = 1000000009112031358987776327; + bpsToRay[3330] = 1000000009114410277348376157; + bpsToRay[3331] = 1000000009116789017252182363; + bpsToRay[3332] = 1000000009119167578725967147; + bpsToRay[3333] = 1000000009121545961796496682; + bpsToRay[3334] = 1000000009123924166490531122; + bpsToRay[3335] = 1000000009126302192834824601; + bpsToRay[3336] = 1000000009128680040856125232; + bpsToRay[3337] = 1000000009131057710581175113; + bpsToRay[3338] = 1000000009133435202036710325; + bpsToRay[3339] = 1000000009135812515249460939; + bpsToRay[3340] = 1000000009138189650246151012; + bpsToRay[3341] = 1000000009140566607053498590; + bpsToRay[3342] = 1000000009142943385698215714; + bpsToRay[3343] = 1000000009145319986207008418; + bpsToRay[3344] = 1000000009147696408606576730; + bpsToRay[3345] = 1000000009150072652923614679; + bpsToRay[3346] = 1000000009152448719184810291; + bpsToRay[3347] = 1000000009154824607416845592; + bpsToRay[3348] = 1000000009157200317646396614; + bpsToRay[3349] = 1000000009159575849900133392; + bpsToRay[3350] = 1000000009161951204204719966; + bpsToRay[3351] = 1000000009164326380586814388; + bpsToRay[3352] = 1000000009166701379073068717; + bpsToRay[3353] = 1000000009169076199690129024; + bpsToRay[3354] = 1000000009171450842464635396; + bpsToRay[3355] = 1000000009173825307423221934; + bpsToRay[3356] = 1000000009176199594592516756; + bpsToRay[3357] = 1000000009178573703999141999; + bpsToRay[3358] = 1000000009180947635669713821; + bpsToRay[3359] = 1000000009183321389630842403; + bpsToRay[3360] = 1000000009185694965909131953; + bpsToRay[3361] = 1000000009188068364531180699; + bpsToRay[3362] = 1000000009190441585523580901; + bpsToRay[3363] = 1000000009192814628912918850; + bpsToRay[3364] = 1000000009195187494725774868; + bpsToRay[3365] = 1000000009197560182988723306; + bpsToRay[3366] = 1000000009199932693728332556; + bpsToRay[3367] = 1000000009202305026971165043; + bpsToRay[3368] = 1000000009204677182743777234; + bpsToRay[3369] = 1000000009207049161072719633; + bpsToRay[3370] = 1000000009209420961984536788; + bpsToRay[3371] = 1000000009211792585505767292; + bpsToRay[3372] = 1000000009214164031662943783; + bpsToRay[3373] = 1000000009216535300482592946; + bpsToRay[3374] = 1000000009218906391991235515; + bpsToRay[3375] = 1000000009221277306215386279; + bpsToRay[3376] = 1000000009223648043181554075; + bpsToRay[3377] = 1000000009226018602916241797; + bpsToRay[3378] = 1000000009228388985445946397; + bpsToRay[3379] = 1000000009230759190797158882; + bpsToRay[3380] = 1000000009233129218996364321; + bpsToRay[3381] = 1000000009235499070070041847; + bpsToRay[3382] = 1000000009237868744044664652; + bpsToRay[3383] = 1000000009240238240946699996; + bpsToRay[3384] = 1000000009242607560802609207; + bpsToRay[3385] = 1000000009244976703638847681; + bpsToRay[3386] = 1000000009247345669481864883; + bpsToRay[3387] = 1000000009249714458358104354; + bpsToRay[3388] = 1000000009252083070294003707; + bpsToRay[3389] = 1000000009254451505315994632; + bpsToRay[3390] = 1000000009256819763450502896; + bpsToRay[3391] = 1000000009259187844723948345; + bpsToRay[3392] = 1000000009261555749162744907; + bpsToRay[3393] = 1000000009263923476793300595; + bpsToRay[3394] = 1000000009266291027642017505; + bpsToRay[3395] = 1000000009268658401735291819; + bpsToRay[3396] = 1000000009271025599099513809; + bpsToRay[3397] = 1000000009273392619761067837; + bpsToRay[3398] = 1000000009275759463746332356; + bpsToRay[3399] = 1000000009278126131081679912; + bpsToRay[3400] = 1000000009280492621793477151; + bpsToRay[3401] = 1000000009282858935908084809; + bpsToRay[3402] = 1000000009285225073451857728; + bpsToRay[3403] = 1000000009287591034451144845; + bpsToRay[3404] = 1000000009289956818932289205; + bpsToRay[3405] = 1000000009292322426921627953; + bpsToRay[3406] = 1000000009294687858445492342; + bpsToRay[3407] = 1000000009297053113530207732; + bpsToRay[3408] = 1000000009299418192202093592; + bpsToRay[3409] = 1000000009301783094487463505; + bpsToRay[3410] = 1000000009304147820412625165; + bpsToRay[3411] = 1000000009306512370003880380; + bpsToRay[3412] = 1000000009308876743287525076; + bpsToRay[3413] = 1000000009311240940289849298; + bpsToRay[3414] = 1000000009313604961037137210; + bpsToRay[3415] = 1000000009315968805555667098; + bpsToRay[3416] = 1000000009318332473871711372; + bpsToRay[3417] = 1000000009320695966011536564; + bpsToRay[3418] = 1000000009323059282001403339; + bpsToRay[3419] = 1000000009325422421867566487; + bpsToRay[3420] = 1000000009327785385636274930; + bpsToRay[3421] = 1000000009330148173333771722; + bpsToRay[3422] = 1000000009332510784986294051; + bpsToRay[3423] = 1000000009334873220620073239; + bpsToRay[3424] = 1000000009337235480261334748; + bpsToRay[3425] = 1000000009339597563936298181; + bpsToRay[3426] = 1000000009341959471671177278; + bpsToRay[3427] = 1000000009344321203492179924; + bpsToRay[3428] = 1000000009346682759425508147; + bpsToRay[3429] = 1000000009349044139497358124; + bpsToRay[3430] = 1000000009351405343733920179; + bpsToRay[3431] = 1000000009353766372161378785; + bpsToRay[3432] = 1000000009356127224805912567; + bpsToRay[3433] = 1000000009358487901693694303; + bpsToRay[3434] = 1000000009360848402850890927; + bpsToRay[3435] = 1000000009363208728303663528; + bpsToRay[3436] = 1000000009365568878078167356; + bpsToRay[3437] = 1000000009367928852200551818; + bpsToRay[3438] = 1000000009370288650696960487; + bpsToRay[3439] = 1000000009372648273593531096; + bpsToRay[3440] = 1000000009375007720916395546; + bpsToRay[3441] = 1000000009377366992691679904; + bpsToRay[3442] = 1000000009379726088945504406; + bpsToRay[3443] = 1000000009382085009703983460; + bpsToRay[3444] = 1000000009384443754993225643; + bpsToRay[3445] = 1000000009386802324839333712; + bpsToRay[3446] = 1000000009389160719268404592; + bpsToRay[3447] = 1000000009391518938306529393; + bpsToRay[3448] = 1000000009393876981979793400; + bpsToRay[3449] = 1000000009396234850314276081; + bpsToRay[3450] = 1000000009398592543336051086; + bpsToRay[3451] = 1000000009400950061071186249; + bpsToRay[3452] = 1000000009403307403545743592; + bpsToRay[3453] = 1000000009405664570785779323; + bpsToRay[3454] = 1000000009408021562817343841; + bpsToRay[3455] = 1000000009410378379666481736; + bpsToRay[3456] = 1000000009412735021359231792; + bpsToRay[3457] = 1000000009415091487921626986; + bpsToRay[3458] = 1000000009417447779379694494; + bpsToRay[3459] = 1000000009419803895759455687; + bpsToRay[3460] = 1000000009422159837086926140; + bpsToRay[3461] = 1000000009424515603388115629; + bpsToRay[3462] = 1000000009426871194689028130; + bpsToRay[3463] = 1000000009429226611015661829; + bpsToRay[3464] = 1000000009431581852394009115; + bpsToRay[3465] = 1000000009433936918850056588; + bpsToRay[3466] = 1000000009436291810409785058; + bpsToRay[3467] = 1000000009438646527099169546; + bpsToRay[3468] = 1000000009441001068944179290; + bpsToRay[3469] = 1000000009443355435970777739; + bpsToRay[3470] = 1000000009445709628204922563; + bpsToRay[3471] = 1000000009448063645672565649; + bpsToRay[3472] = 1000000009450417488399653106; + bpsToRay[3473] = 1000000009452771156412125264; + bpsToRay[3474] = 1000000009455124649735916678; + bpsToRay[3475] = 1000000009457477968396956129; + bpsToRay[3476] = 1000000009459831112421166625; + bpsToRay[3477] = 1000000009462184081834465404; + bpsToRay[3478] = 1000000009464536876662763935; + bpsToRay[3479] = 1000000009466889496931967919; + bpsToRay[3480] = 1000000009469241942667977291; + bpsToRay[3481] = 1000000009471594213896686225; + bpsToRay[3482] = 1000000009473946310643983128; + bpsToRay[3483] = 1000000009476298232935750651; + bpsToRay[3484] = 1000000009478649980797865683; + bpsToRay[3485] = 1000000009481001554256199359; + bpsToRay[3486] = 1000000009483352953336617058; + bpsToRay[3487] = 1000000009485704178064978403; + bpsToRay[3488] = 1000000009488055228467137266; + bpsToRay[3489] = 1000000009490406104568941771; + bpsToRay[3490] = 1000000009492756806396234293; + bpsToRay[3491] = 1000000009495107333974851456; + bpsToRay[3492] = 1000000009497457687330624144; + bpsToRay[3493] = 1000000009499807866489377496; + bpsToRay[3494] = 1000000009502157871476930909; + bpsToRay[3495] = 1000000009504507702319098038; + bpsToRay[3496] = 1000000009506857359041686805; + bpsToRay[3497] = 1000000009509206841670499389; + bpsToRay[3498] = 1000000009511556150231332239; + bpsToRay[3499] = 1000000009513905284749976069; + bpsToRay[3500] = 1000000009516254245252215861; + bpsToRay[3501] = 1000000009518603031763830869; + bpsToRay[3502] = 1000000009520951644310594617; + bpsToRay[3503] = 1000000009523300082918274904; + bpsToRay[3504] = 1000000009525648347612633803; + bpsToRay[3505] = 1000000009527996438419427664; + bpsToRay[3506] = 1000000009530344355364407118; + bpsToRay[3507] = 1000000009532692098473317073; + bpsToRay[3508] = 1000000009535039667771896723; + bpsToRay[3509] = 1000000009537387063285879541; + bpsToRay[3510] = 1000000009539734285040993291; + bpsToRay[3511] = 1000000009542081333062960018; + bpsToRay[3512] = 1000000009544428207377496063; + bpsToRay[3513] = 1000000009546774908010312050; + bpsToRay[3514] = 1000000009549121434987112901; + bpsToRay[3515] = 1000000009551467788333597830; + bpsToRay[3516] = 1000000009553813968075460344; + bpsToRay[3517] = 1000000009556159974238388253; + bpsToRay[3518] = 1000000009558505806848063661; + bpsToRay[3519] = 1000000009560851465930162975; + bpsToRay[3520] = 1000000009563196951510356903; + bpsToRay[3521] = 1000000009565542263614310457; + bpsToRay[3522] = 1000000009567887402267682959; + bpsToRay[3523] = 1000000009570232367496128031; + bpsToRay[3524] = 1000000009572577159325293611; + bpsToRay[3525] = 1000000009574921777780821942; + bpsToRay[3526] = 1000000009577266222888349586; + bpsToRay[3527] = 1000000009579610494673507411; + bpsToRay[3528] = 1000000009581954593161920610; + bpsToRay[3529] = 1000000009584298518379208685; + bpsToRay[3530] = 1000000009586642270350985464; + bpsToRay[3531] = 1000000009588985849102859090; + bpsToRay[3532] = 1000000009591329254660432033; + bpsToRay[3533] = 1000000009593672487049301086; + bpsToRay[3534] = 1000000009596015546295057365; + bpsToRay[3535] = 1000000009598358432423286320; + bpsToRay[3536] = 1000000009600701145459567724; + bpsToRay[3537] = 1000000009603043685429475683; + bpsToRay[3538] = 1000000009605386052358578639; + bpsToRay[3539] = 1000000009607728246272439360; + bpsToRay[3540] = 1000000009610070267196614960; + bpsToRay[3541] = 1000000009612412115156656882; + bpsToRay[3542] = 1000000009614753790178110915; + bpsToRay[3543] = 1000000009617095292286517185; + bpsToRay[3544] = 1000000009619436621507410162; + bpsToRay[3545] = 1000000009621777777866318660; + bpsToRay[3546] = 1000000009624118761388765837; + bpsToRay[3547] = 1000000009626459572100269204; + bpsToRay[3548] = 1000000009628800210026340615; + bpsToRay[3549] = 1000000009631140675192486280; + bpsToRay[3550] = 1000000009633480967624206760; + bpsToRay[3551] = 1000000009635821087346996968; + bpsToRay[3552] = 1000000009638161034386346176; + bpsToRay[3553] = 1000000009640500808767738013; + bpsToRay[3554] = 1000000009642840410516650466; + bpsToRay[3555] = 1000000009645179839658555885; + bpsToRay[3556] = 1000000009647519096218920981; + bpsToRay[3557] = 1000000009649858180223206829; + bpsToRay[3558] = 1000000009652197091696868873; + bpsToRay[3559] = 1000000009654535830665356921; + bpsToRay[3560] = 1000000009656874397154115153; + bpsToRay[3561] = 1000000009659212791188582117; + bpsToRay[3562] = 1000000009661551012794190737; + bpsToRay[3563] = 1000000009663889061996368309; + bpsToRay[3564] = 1000000009666226938820536506; + bpsToRay[3565] = 1000000009668564643292111378; + bpsToRay[3566] = 1000000009670902175436503355; + bpsToRay[3567] = 1000000009673239535279117247; + bpsToRay[3568] = 1000000009675576722845352247; + bpsToRay[3569] = 1000000009677913738160601933; + bpsToRay[3570] = 1000000009680250581250254266; + bpsToRay[3571] = 1000000009682587252139691600; + bpsToRay[3572] = 1000000009684923750854290672; + bpsToRay[3573] = 1000000009687260077419422613; + bpsToRay[3574] = 1000000009689596231860452947; + bpsToRay[3575] = 1000000009691932214202741592; + bpsToRay[3576] = 1000000009694268024471642861; + bpsToRay[3577] = 1000000009696603662692505463; + bpsToRay[3578] = 1000000009698939128890672509; + bpsToRay[3579] = 1000000009701274423091481510; + bpsToRay[3580] = 1000000009703609545320264378; + bpsToRay[3581] = 1000000009705944495602347430; + bpsToRay[3582] = 1000000009708279273963051388; + bpsToRay[3583] = 1000000009710613880427691383; + bpsToRay[3584] = 1000000009712948315021576954; + bpsToRay[3585] = 1000000009715282577770012051; + bpsToRay[3586] = 1000000009717616668698295034; + bpsToRay[3587] = 1000000009719950587831718681; + bpsToRay[3588] = 1000000009722284335195570182; + bpsToRay[3589] = 1000000009724617910815131148; + bpsToRay[3590] = 1000000009726951314715677603; + bpsToRay[3591] = 1000000009729284546922479998; + bpsToRay[3592] = 1000000009731617607460803201; + bpsToRay[3593] = 1000000009733950496355906508; + bpsToRay[3594] = 1000000009736283213633043637; + bpsToRay[3595] = 1000000009738615759317462734; + bpsToRay[3596] = 1000000009740948133434406377; + bpsToRay[3597] = 1000000009743280336009111568; + bpsToRay[3598] = 1000000009745612367066809747; + bpsToRay[3599] = 1000000009747944226632726785; + bpsToRay[3600] = 1000000009750275914732082986; + bpsToRay[3601] = 1000000009752607431390093096; + bpsToRay[3602] = 1000000009754938776631966296; + bpsToRay[3603] = 1000000009757269950482906208; + bpsToRay[3604] = 1000000009759600952968110896; + bpsToRay[3605] = 1000000009761931784112772867; + bpsToRay[3606] = 1000000009764262443942079074; + bpsToRay[3607] = 1000000009766592932481210915; + bpsToRay[3608] = 1000000009768923249755344240; + bpsToRay[3609] = 1000000009771253395789649342; + bpsToRay[3610] = 1000000009773583370609290973; + bpsToRay[3611] = 1000000009775913174239428335; + bpsToRay[3612] = 1000000009778242806705215085; + bpsToRay[3613] = 1000000009780572268031799336; + bpsToRay[3614] = 1000000009782901558244323661; + bpsToRay[3615] = 1000000009785230677367925089; + bpsToRay[3616] = 1000000009787559625427735116; + bpsToRay[3617] = 1000000009789888402448879695; + bpsToRay[3618] = 1000000009792217008456479248; + bpsToRay[3619] = 1000000009794545443475648661; + bpsToRay[3620] = 1000000009796873707531497290; + bpsToRay[3621] = 1000000009799201800649128958; + bpsToRay[3622] = 1000000009801529722853641960; + bpsToRay[3623] = 1000000009803857474170129064; + bpsToRay[3624] = 1000000009806185054623677514; + bpsToRay[3625] = 1000000009808512464239369028; + bpsToRay[3626] = 1000000009810839703042279800; + bpsToRay[3627] = 1000000009813166771057480507; + bpsToRay[3628] = 1000000009815493668310036305; + bpsToRay[3629] = 1000000009817820394825006832; + bpsToRay[3630] = 1000000009820146950627446211; + bpsToRay[3631] = 1000000009822473335742403050; + bpsToRay[3632] = 1000000009824799550194920446; + bpsToRay[3633] = 1000000009827125594010035982; + bpsToRay[3634] = 1000000009829451467212781736; + bpsToRay[3635] = 1000000009831777169828184273; + bpsToRay[3636] = 1000000009834102701881264655; + bpsToRay[3637] = 1000000009836428063397038439; + bpsToRay[3638] = 1000000009838753254400515679; + bpsToRay[3639] = 1000000009841078274916700926; + bpsToRay[3640] = 1000000009843403124970593235; + bpsToRay[3641] = 1000000009845727804587186159; + bpsToRay[3642] = 1000000009848052313791467756; + bpsToRay[3643] = 1000000009850376652608420590; + bpsToRay[3644] = 1000000009852700821063021729; + bpsToRay[3645] = 1000000009855024819180242754; + bpsToRay[3646] = 1000000009857348646985049751; + bpsToRay[3647] = 1000000009859672304502403321; + bpsToRay[3648] = 1000000009861995791757258575; + bpsToRay[3649] = 1000000009864319108774565142; + bpsToRay[3650] = 1000000009866642255579267166; + bpsToRay[3651] = 1000000009868965232196303308; + bpsToRay[3652] = 1000000009871288038650606750; + bpsToRay[3653] = 1000000009873610674967105195; + bpsToRay[3654] = 1000000009875933141170720867; + bpsToRay[3655] = 1000000009878255437286370517; + bpsToRay[3656] = 1000000009880577563338965422; + bpsToRay[3657] = 1000000009882899519353411383; + bpsToRay[3658] = 1000000009885221305354608733; + bpsToRay[3659] = 1000000009887542921367452338; + bpsToRay[3660] = 1000000009889864367416831591; + bpsToRay[3661] = 1000000009892185643527630423; + bpsToRay[3662] = 1000000009894506749724727299; + bpsToRay[3663] = 1000000009896827686032995223; + bpsToRay[3664] = 1000000009899148452477301734; + bpsToRay[3665] = 1000000009901469049082508916; + bpsToRay[3666] = 1000000009903789475873473393; + bpsToRay[3667] = 1000000009906109732875046331; + bpsToRay[3668] = 1000000009908429820112073443; + bpsToRay[3669] = 1000000009910749737609394990; + bpsToRay[3670] = 1000000009913069485391845778; + bpsToRay[3671] = 1000000009915389063484255166; + bpsToRay[3672] = 1000000009917708471911447063; + bpsToRay[3673] = 1000000009920027710698239932; + bpsToRay[3674] = 1000000009922346779869446790; + bpsToRay[3675] = 1000000009924665679449875210; + bpsToRay[3676] = 1000000009926984409464327325; + bpsToRay[3677] = 1000000009929302969937599826; + bpsToRay[3678] = 1000000009931621360894483965; + bpsToRay[3679] = 1000000009933939582359765557; + bpsToRay[3680] = 1000000009936257634358224982; + bpsToRay[3681] = 1000000009938575516914637184; + bpsToRay[3682] = 1000000009940893230053771678; + bpsToRay[3683] = 1000000009943210773800392543; + bpsToRay[3684] = 1000000009945528148179258435; + bpsToRay[3685] = 1000000009947845353215122576; + bpsToRay[3686] = 1000000009950162388932732765; + bpsToRay[3687] = 1000000009952479255356831378; + bpsToRay[3688] = 1000000009954795952512155365; + bpsToRay[3689] = 1000000009957112480423436255; + bpsToRay[3690] = 1000000009959428839115400159; + bpsToRay[3691] = 1000000009961745028612767768; + bpsToRay[3692] = 1000000009964061048940254356; + bpsToRay[3693] = 1000000009966376900122569785; + bpsToRay[3694] = 1000000009968692582184418500; + bpsToRay[3695] = 1000000009971008095150499537; + bpsToRay[3696] = 1000000009973323439045506518; + bpsToRay[3697] = 1000000009975638613894127660; + bpsToRay[3698] = 1000000009977953619721045772; + bpsToRay[3699] = 1000000009980268456550938255; + bpsToRay[3700] = 1000000009982583124408477109; + bpsToRay[3701] = 1000000009984897623318328929; + bpsToRay[3702] = 1000000009987211953305154911; + bpsToRay[3703] = 1000000009989526114393610852; + bpsToRay[3704] = 1000000009991840106608347149; + bpsToRay[3705] = 1000000009994153929974008806; + bpsToRay[3706] = 1000000009996467584515235430; + bpsToRay[3707] = 1000000009998781070256661235; + bpsToRay[3708] = 1000000010001094387222915045; + bpsToRay[3709] = 1000000010003407535438620294; + bpsToRay[3710] = 1000000010005720514928395027; + bpsToRay[3711] = 1000000010008033325716851902; + bpsToRay[3712] = 1000000010010345967828598194; + bpsToRay[3713] = 1000000010012658441288235791; + bpsToRay[3714] = 1000000010014970746120361202; + bpsToRay[3715] = 1000000010017282882349565556; + bpsToRay[3716] = 1000000010019594850000434599; + bpsToRay[3717] = 1000000010021906649097548706; + bpsToRay[3718] = 1000000010024218279665482869; + bpsToRay[3719] = 1000000010026529741728806711; + bpsToRay[3720] = 1000000010028841035312084483; + bpsToRay[3721] = 1000000010031152160439875061; + bpsToRay[3722] = 1000000010033463117136731955; + bpsToRay[3723] = 1000000010035773905427203304; + bpsToRay[3724] = 1000000010038084525335831885; + bpsToRay[3725] = 1000000010040394976887155106; + bpsToRay[3726] = 1000000010042705260105705014; + bpsToRay[3727] = 1000000010045015375016008294; + bpsToRay[3728] = 1000000010047325321642586271; + bpsToRay[3729] = 1000000010049635100009954912; + bpsToRay[3730] = 1000000010051944710142624825; + bpsToRay[3731] = 1000000010054254152065101266; + bpsToRay[3732] = 1000000010056563425801884135; + bpsToRay[3733] = 1000000010058872531377467979; + bpsToRay[3734] = 1000000010061181468816341997; + bpsToRay[3735] = 1000000010063490238142990036; + bpsToRay[3736] = 1000000010065798839381890598; + bpsToRay[3737] = 1000000010068107272557516837; + bpsToRay[3738] = 1000000010070415537694336563; + bpsToRay[3739] = 1000000010072723634816812244; + bpsToRay[3740] = 1000000010075031563949401005; + bpsToRay[3741] = 1000000010077339325116554633; + bpsToRay[3742] = 1000000010079646918342719577; + bpsToRay[3743] = 1000000010081954343652336947; + bpsToRay[3744] = 1000000010084261601069842519; + bpsToRay[3745] = 1000000010086568690619666737; + bpsToRay[3746] = 1000000010088875612326234711; + bpsToRay[3747] = 1000000010091182366213966220; + bpsToRay[3748] = 1000000010093488952307275716; + bpsToRay[3749] = 1000000010095795370630572323; + bpsToRay[3750] = 1000000010098101621208259840; + bpsToRay[3751] = 1000000010100407704064736739; + bpsToRay[3752] = 1000000010102713619224396172; + bpsToRay[3753] = 1000000010105019366711625969; + bpsToRay[3754] = 1000000010107324946550808639; + bpsToRay[3755] = 1000000010109630358766321376; + bpsToRay[3756] = 1000000010111935603382536054; + bpsToRay[3757] = 1000000010114240680423819234; + bpsToRay[3758] = 1000000010116545589914532164; + bpsToRay[3759] = 1000000010118850331879030779; + bpsToRay[3760] = 1000000010121154906341665703; + bpsToRay[3761] = 1000000010123459313326782253; + bpsToRay[3762] = 1000000010125763552858720438; + bpsToRay[3763] = 1000000010128067624961814960; + bpsToRay[3764] = 1000000010130371529660395218; + bpsToRay[3765] = 1000000010132675266978785311; + bpsToRay[3766] = 1000000010134978836941304031; + bpsToRay[3767] = 1000000010137282239572264876; + bpsToRay[3768] = 1000000010139585474895976041; + bpsToRay[3769] = 1000000010141888542936740429; + bpsToRay[3770] = 1000000010144191443718855647; + bpsToRay[3771] = 1000000010146494177266614006; + bpsToRay[3772] = 1000000010148796743604302527; + bpsToRay[3773] = 1000000010151099142756202942; + bpsToRay[3774] = 1000000010153401374746591692; + bpsToRay[3775] = 1000000010155703439599739931; + bpsToRay[3776] = 1000000010158005337339913529; + bpsToRay[3777] = 1000000010160307067991373070; + bpsToRay[3778] = 1000000010162608631578373856; + bpsToRay[3779] = 1000000010164910028125165907; + bpsToRay[3780] = 1000000010167211257655993967; + bpsToRay[3781] = 1000000010169512320195097496; + bpsToRay[3782] = 1000000010171813215766710684; + bpsToRay[3783] = 1000000010174113944395062439; + bpsToRay[3784] = 1000000010176414506104376402; + bpsToRay[3785] = 1000000010178714900918870939; + bpsToRay[3786] = 1000000010181015128862759145; + bpsToRay[3787] = 1000000010183315189960248848; + bpsToRay[3788] = 1000000010185615084235542606; + bpsToRay[3789] = 1000000010187914811712837715; + bpsToRay[3790] = 1000000010190214372416326204; + bpsToRay[3791] = 1000000010192513766370194839; + bpsToRay[3792] = 1000000010194812993598625127; + bpsToRay[3793] = 1000000010197112054125793313; + bpsToRay[3794] = 1000000010199410947975870385; + bpsToRay[3795] = 1000000010201709675173022073; + bpsToRay[3796] = 1000000010204008235741408855; + bpsToRay[3797] = 1000000010206306629705185952; + bpsToRay[3798] = 1000000010208604857088503334; + bpsToRay[3799] = 1000000010210902917915505722; + bpsToRay[3800] = 1000000010213200812210332586; + bpsToRay[3801] = 1000000010215498539997118147; + bpsToRay[3802] = 1000000010217796101299991387; + bpsToRay[3803] = 1000000010220093496143076034; + bpsToRay[3804] = 1000000010222390724550490579; + bpsToRay[3805] = 1000000010224687786546348272; + bpsToRay[3806] = 1000000010226984682154757119; + bpsToRay[3807] = 1000000010229281411399819892; + bpsToRay[3808] = 1000000010231577974305634122; + bpsToRay[3809] = 1000000010233874370896292108; + bpsToRay[3810] = 1000000010236170601195880913; + bpsToRay[3811] = 1000000010238466665228482369; + bpsToRay[3812] = 1000000010240762563018173077; + bpsToRay[3813] = 1000000010243058294589024407; + bpsToRay[3814] = 1000000010245353859965102504; + bpsToRay[3815] = 1000000010247649259170468285; + bpsToRay[3816] = 1000000010249944492229177442; + bpsToRay[3817] = 1000000010252239559165280445; + bpsToRay[3818] = 1000000010254534460002822540; + bpsToRay[3819] = 1000000010256829194765843755; + bpsToRay[3820] = 1000000010259123763478378900; + bpsToRay[3821] = 1000000010261418166164457564; + bpsToRay[3822] = 1000000010263712402848104124; + bpsToRay[3823] = 1000000010266006473553337741; + bpsToRay[3824] = 1000000010268300378304172365; + bpsToRay[3825] = 1000000010270594117124616733; + bpsToRay[3826] = 1000000010272887690038674371; + bpsToRay[3827] = 1000000010275181097070343602; + bpsToRay[3828] = 1000000010277474338243617536; + bpsToRay[3829] = 1000000010279767413582484084; + bpsToRay[3830] = 1000000010282060323110925948; + bpsToRay[3831] = 1000000010284353066852920632; + bpsToRay[3832] = 1000000010286645644832440436; + bpsToRay[3833] = 1000000010288938057073452464; + bpsToRay[3834] = 1000000010291230303599918619; + bpsToRay[3835] = 1000000010293522384435795611; + bpsToRay[3836] = 1000000010295814299605034955; + bpsToRay[3837] = 1000000010298106049131582970; + bpsToRay[3838] = 1000000010300397633039380787; + bpsToRay[3839] = 1000000010302689051352364343; + bpsToRay[3840] = 1000000010304980304094464392; + bpsToRay[3841] = 1000000010307271391289606494; + bpsToRay[3842] = 1000000010309562312961711031; + bpsToRay[3843] = 1000000010311853069134693193; + bpsToRay[3844] = 1000000010314143659832462993; + bpsToRay[3845] = 1000000010316434085078925260; + bpsToRay[3846] = 1000000010318724344897979646; + bpsToRay[3847] = 1000000010321014439313520622; + bpsToRay[3848] = 1000000010323304368349437485; + bpsToRay[3849] = 1000000010325594132029614354; + bpsToRay[3850] = 1000000010327883730377930177; + bpsToRay[3851] = 1000000010330173163418258729; + bpsToRay[3852] = 1000000010332462431174468613; + bpsToRay[3853] = 1000000010334751533670423264; + bpsToRay[3854] = 1000000010337040470929980950; + bpsToRay[3855] = 1000000010339329242976994772; + bpsToRay[3856] = 1000000010341617849835312667; + bpsToRay[3857] = 1000000010343906291528777406; + bpsToRay[3858] = 1000000010346194568081226603; + bpsToRay[3859] = 1000000010348482679516492707; + bpsToRay[3860] = 1000000010350770625858403013; + bpsToRay[3861] = 1000000010353058407130779655; + bpsToRay[3862] = 1000000010355346023357439613; + bpsToRay[3863] = 1000000010357633474562194712; + bpsToRay[3864] = 1000000010359920760768851624; + bpsToRay[3865] = 1000000010362207882001211872; + bpsToRay[3866] = 1000000010364494838283071825; + bpsToRay[3867] = 1000000010366781629638222707; + bpsToRay[3868] = 1000000010369068256090450597; + bpsToRay[3869] = 1000000010371354717663536422; + bpsToRay[3870] = 1000000010373641014381255972; + bpsToRay[3871] = 1000000010375927146267379890; + bpsToRay[3872] = 1000000010378213113345673681; + bpsToRay[3873] = 1000000010380498915639897708; + bpsToRay[3874] = 1000000010382784553173807199; + bpsToRay[3875] = 1000000010385070025971152244; + bpsToRay[3876] = 1000000010387355334055677797; + bpsToRay[3877] = 1000000010389640477451123680; + bpsToRay[3878] = 1000000010391925456181224583; + bpsToRay[3879] = 1000000010394210270269710063; + bpsToRay[3880] = 1000000010396494919740304554; + bpsToRay[3881] = 1000000010398779404616727355; + bpsToRay[3882] = 1000000010401063724922692643; + bpsToRay[3883] = 1000000010403347880681909471; + bpsToRay[3884] = 1000000010405631871918081767; + bpsToRay[3885] = 1000000010407915698654908337; + bpsToRay[3886] = 1000000010410199360916082867; + bpsToRay[3887] = 1000000010412482858725293929; + bpsToRay[3888] = 1000000010414766192106224969; + bpsToRay[3889] = 1000000010417049361082554324; + bpsToRay[3890] = 1000000010419332365677955216; + bpsToRay[3891] = 1000000010421615205916095750; + bpsToRay[3892] = 1000000010423897881820638924; + bpsToRay[3893] = 1000000010426180393415242626; + bpsToRay[3894] = 1000000010428462740723559632; + bpsToRay[3895] = 1000000010430744923769237614; + bpsToRay[3896] = 1000000010433026942575919138; + bpsToRay[3897] = 1000000010435308797167241666; + bpsToRay[3898] = 1000000010437590487566837557; + bpsToRay[3899] = 1000000010439872013798334068; + bpsToRay[3900] = 1000000010442153375885353361; + bpsToRay[3901] = 1000000010444434573851512493; + bpsToRay[3902] = 1000000010446715607720423430; + bpsToRay[3903] = 1000000010448996477515693040; + bpsToRay[3904] = 1000000010451277183260923098; + bpsToRay[3905] = 1000000010453557724979710285; + bpsToRay[3906] = 1000000010455838102695646196; + bpsToRay[3907] = 1000000010458118316432317331; + bpsToRay[3908] = 1000000010460398366213305107; + bpsToRay[3909] = 1000000010462678252062185850; + bpsToRay[3910] = 1000000010464957974002530804; + bpsToRay[3911] = 1000000010467237532057906130; + bpsToRay[3912] = 1000000010469516926251872906; + bpsToRay[3913] = 1000000010471796156607987127; + bpsToRay[3914] = 1000000010474075223149799712; + bpsToRay[3915] = 1000000010476354125900856503; + bpsToRay[3916] = 1000000010478632864884698262; + bpsToRay[3917] = 1000000010480911440124860682; + bpsToRay[3918] = 1000000010483189851644874376; + bpsToRay[3919] = 1000000010485468099468264892; + bpsToRay[3920] = 1000000010487746183618552701; + bpsToRay[3921] = 1000000010490024104119253210; + bpsToRay[3922] = 1000000010492301860993876758; + bpsToRay[3923] = 1000000010494579454265928614; + bpsToRay[3924] = 1000000010496856883958908988; + bpsToRay[3925] = 1000000010499134150096313024; + bpsToRay[3926] = 1000000010501411252701630804; + bpsToRay[3927] = 1000000010503688191798347350; + bpsToRay[3928] = 1000000010505964967409942629; + bpsToRay[3929] = 1000000010508241579559891545; + bpsToRay[3930] = 1000000010510518028271663949; + bpsToRay[3931] = 1000000010512794313568724638; + bpsToRay[3932] = 1000000010515070435474533356; + bpsToRay[3933] = 1000000010517346394012544796; + bpsToRay[3934] = 1000000010519622189206208597; + bpsToRay[3935] = 1000000010521897821078969357; + bpsToRay[3936] = 1000000010524173289654266619; + bpsToRay[3937] = 1000000010526448594955534886; + bpsToRay[3938] = 1000000010528723737006203614; + bpsToRay[3939] = 1000000010530998715829697217; + bpsToRay[3940] = 1000000010533273531449435067; + bpsToRay[3941] = 1000000010535548183888831498; + bpsToRay[3942] = 1000000010537822673171295805; + bpsToRay[3943] = 1000000010540096999320232244; + bpsToRay[3944] = 1000000010542371162359040036; + bpsToRay[3945] = 1000000010544645162311113372; + bpsToRay[3946] = 1000000010546918999199841404; + bpsToRay[3947] = 1000000010549192673048608259; + bpsToRay[3948] = 1000000010551466183880793029; + bpsToRay[3949] = 1000000010553739531719769780; + bpsToRay[3950] = 1000000010556012716588907553; + bpsToRay[3951] = 1000000010558285738511570360; + bpsToRay[3952] = 1000000010560558597511117192; + bpsToRay[3953] = 1000000010562831293610902015; + bpsToRay[3954] = 1000000010565103826834273775; + bpsToRay[3955] = 1000000010567376197204576401; + bpsToRay[3956] = 1000000010569648404745148797; + bpsToRay[3957] = 1000000010571920449479324858; + bpsToRay[3958] = 1000000010574192331430433458; + bpsToRay[3959] = 1000000010576464050621798460; + bpsToRay[3960] = 1000000010578735607076738714; + bpsToRay[3961] = 1000000010581007000818568058; + bpsToRay[3962] = 1000000010583278231870595322; + bpsToRay[3963] = 1000000010585549300256124326; + bpsToRay[3964] = 1000000010587820205998453884; + bpsToRay[3965] = 1000000010590090949120877806; + bpsToRay[3966] = 1000000010592361529646684896; + bpsToRay[3967] = 1000000010594631947599158957; + bpsToRay[3968] = 1000000010596902203001578791; + bpsToRay[3969] = 1000000010599172295877218198; + bpsToRay[3970] = 1000000010601442226249345986; + bpsToRay[3971] = 1000000010603711994141225957; + bpsToRay[3972] = 1000000010605981599576116928; + bpsToRay[3973] = 1000000010608251042577272714; + bpsToRay[3974] = 1000000010610520323167942140; + bpsToRay[3975] = 1000000010612789441371369043; + bpsToRay[3976] = 1000000010615058397210792268; + bpsToRay[3977] = 1000000010617327190709445671; + bpsToRay[3978] = 1000000010619595821890558121; + bpsToRay[3979] = 1000000010621864290777353506; + bpsToRay[3980] = 1000000010624132597393050726; + bpsToRay[3981] = 1000000010626400741760863700; + bpsToRay[3982] = 1000000010628668723904001364; + bpsToRay[3983] = 1000000010630936543845667679; + bpsToRay[3984] = 1000000010633204201609061622; + bpsToRay[3985] = 1000000010635471697217377200; + bpsToRay[3986] = 1000000010637739030693803438; + bpsToRay[3987] = 1000000010640006202061524391; + bpsToRay[3988] = 1000000010642273211343719142; + bpsToRay[3989] = 1000000010644540058563561801; + bpsToRay[3990] = 1000000010646806743744221508; + bpsToRay[3991] = 1000000010649073266908862437; + bpsToRay[3992] = 1000000010651339628080643794; + bpsToRay[3993] = 1000000010653605827282719820; + bpsToRay[3994] = 1000000010655871864538239791; + bpsToRay[3995] = 1000000010658137739870348023; + bpsToRay[3996] = 1000000010660403453302183867; + bpsToRay[3997] = 1000000010662669004856881719; + bpsToRay[3998] = 1000000010664934394557571013; + bpsToRay[3999] = 1000000010667199622427376228; + bpsToRay[4000] = 1000000010669464688489416886; + bpsToRay[4001] = 1000000010671729592766807558; + bpsToRay[4002] = 1000000010673994335282657858; + bpsToRay[4003] = 1000000010676258916060072453; + bpsToRay[4004] = 1000000010678523335122151059; + bpsToRay[4005] = 1000000010680787592491988442; + bpsToRay[4006] = 1000000010683051688192674423; + bpsToRay[4007] = 1000000010685315622247293876; + bpsToRay[4008] = 1000000010687579394678926732; + bpsToRay[4009] = 1000000010689843005510647981; + bpsToRay[4010] = 1000000010692106454765527665; + bpsToRay[4011] = 1000000010694369742466630895; + bpsToRay[4012] = 1000000010696632868637017837; + bpsToRay[4013] = 1000000010698895833299743723; + bpsToRay[4014] = 1000000010701158636477858849; + bpsToRay[4015] = 1000000010703421278194408576; + bpsToRay[4016] = 1000000010705683758472433332; + bpsToRay[4017] = 1000000010707946077334968615; + bpsToRay[4018] = 1000000010710208234805044991; + bpsToRay[4019] = 1000000010712470230905688100; + bpsToRay[4020] = 1000000010714732065659918652; + bpsToRay[4021] = 1000000010716993739090752433; + bpsToRay[4022] = 1000000010719255251221200304; + bpsToRay[4023] = 1000000010721516602074268204; + bpsToRay[4024] = 1000000010723777791672957148; + bpsToRay[4025] = 1000000010726038820040263233; + bpsToRay[4026] = 1000000010728299687199177636; + bpsToRay[4027] = 1000000010730560393172686618; + bpsToRay[4028] = 1000000010732820937983771524; + bpsToRay[4029] = 1000000010735081321655408782; + bpsToRay[4030] = 1000000010737341544210569909; + bpsToRay[4031] = 1000000010739601605672221510; + bpsToRay[4032] = 1000000010741861506063325280; + bpsToRay[4033] = 1000000010744121245406838002; + bpsToRay[4034] = 1000000010746380823725711557; + bpsToRay[4035] = 1000000010748640241042892914; + bpsToRay[4036] = 1000000010750899497381324142; + bpsToRay[4037] = 1000000010753158592763942403; + bpsToRay[4038] = 1000000010755417527213679959; + bpsToRay[4039] = 1000000010757676300753464170; + bpsToRay[4040] = 1000000010759934913406217501; + bpsToRay[4041] = 1000000010762193365194857512; + bpsToRay[4042] = 1000000010764451656142296872; + bpsToRay[4043] = 1000000010766709786271443355; + bpsToRay[4044] = 1000000010768967755605199839; + bpsToRay[4045] = 1000000010771225564166464310; + bpsToRay[4046] = 1000000010773483211978129865; + bpsToRay[4047] = 1000000010775740699063084710; + bpsToRay[4048] = 1000000010777998025444212163; + bpsToRay[4049] = 1000000010780255191144390658; + bpsToRay[4050] = 1000000010782512196186493739; + bpsToRay[4051] = 1000000010784769040593390070; + bpsToRay[4052] = 1000000010787025724387943431; + bpsToRay[4053] = 1000000010789282247593012723; + bpsToRay[4054] = 1000000010791538610231451963; + bpsToRay[4055] = 1000000010793794812326110293; + bpsToRay[4056] = 1000000010796050853899831977; + bpsToRay[4057] = 1000000010798306734975456405; + bpsToRay[4058] = 1000000010800562455575818091; + bpsToRay[4059] = 1000000010802818015723746677; + bpsToRay[4060] = 1000000010805073415442066933; + bpsToRay[4061] = 1000000010807328654753598760; + bpsToRay[4062] = 1000000010809583733681157190; + bpsToRay[4063] = 1000000010811838652247552387; + bpsToRay[4064] = 1000000010814093410475589652; + bpsToRay[4065] = 1000000010816348008388069418; + bpsToRay[4066] = 1000000010818602446007787257; + bpsToRay[4067] = 1000000010820856723357533878; + bpsToRay[4068] = 1000000010823110840460095130; + bpsToRay[4069] = 1000000010825364797338252005; + bpsToRay[4070] = 1000000010827618594014780637; + bpsToRay[4071] = 1000000010829872230512452300; + bpsToRay[4072] = 1000000010832125706854033418; + bpsToRay[4073] = 1000000010834379023062285559; + bpsToRay[4074] = 1000000010836632179159965442; + bpsToRay[4075] = 1000000010838885175169824929; + bpsToRay[4076] = 1000000010841138011114611041; + bpsToRay[4077] = 1000000010843390687017065944; + bpsToRay[4078] = 1000000010845643202899926963; + bpsToRay[4079] = 1000000010847895558785926572; + bpsToRay[4080] = 1000000010850147754697792408; + bpsToRay[4081] = 1000000010852399790658247262; + bpsToRay[4082] = 1000000010854651666690009082; + bpsToRay[4083] = 1000000010856903382815790981; + bpsToRay[4084] = 1000000010859154939058301230; + bpsToRay[4085] = 1000000010861406335440243265; + bpsToRay[4086] = 1000000010863657571984315686; + bpsToRay[4087] = 1000000010865908648713212260; + bpsToRay[4088] = 1000000010868159565649621919; + bpsToRay[4089] = 1000000010870410322816228766; + bpsToRay[4090] = 1000000010872660920235712071; + bpsToRay[4091] = 1000000010874911357930746279; + bpsToRay[4092] = 1000000010877161635924001006; + bpsToRay[4093] = 1000000010879411754238141040; + bpsToRay[4094] = 1000000010881661712895826350; + bpsToRay[4095] = 1000000010883911511919712075; + bpsToRay[4096] = 1000000010886161151332448538; + bpsToRay[4097] = 1000000010888410631156681239; + bpsToRay[4098] = 1000000010890659951415050857; + bpsToRay[4099] = 1000000010892909112130193257; + bpsToRay[4100] = 1000000010895158113324739488; + bpsToRay[4101] = 1000000010897406955021315779; + bpsToRay[4102] = 1000000010899655637242543550; + bpsToRay[4103] = 1000000010901904160011039408; + bpsToRay[4104] = 1000000010904152523349415148; + bpsToRay[4105] = 1000000010906400727280277756; + bpsToRay[4106] = 1000000010908648771826229410; + bpsToRay[4107] = 1000000010910896657009867483; + bpsToRay[4108] = 1000000010913144382853784538; + bpsToRay[4109] = 1000000010915391949380568338; + bpsToRay[4110] = 1000000010917639356612801842; + bpsToRay[4111] = 1000000010919886604573063209; + bpsToRay[4112] = 1000000010922133693283925795; + bpsToRay[4113] = 1000000010924380622767958161; + bpsToRay[4114] = 1000000010926627393047724068; + bpsToRay[4115] = 1000000010928874004145782483; + bpsToRay[4116] = 1000000010931120456084687576; + bpsToRay[4117] = 1000000010933366748886988728; + bpsToRay[4118] = 1000000010935612882575230523; + bpsToRay[4119] = 1000000010937858857171952760; + bpsToRay[4120] = 1000000010940104672699690444; + bpsToRay[4121] = 1000000010942350329180973795; + bpsToRay[4122] = 1000000010944595826638328248; + bpsToRay[4123] = 1000000010946841165094274449; + bpsToRay[4124] = 1000000010949086344571328262; + bpsToRay[4125] = 1000000010951331365092000772; + bpsToRay[4126] = 1000000010953576226678798278; + bpsToRay[4127] = 1000000010955820929354222302; + bpsToRay[4128] = 1000000010958065473140769588; + bpsToRay[4129] = 1000000010960309858060932102; + bpsToRay[4130] = 1000000010962554084137197035; + bpsToRay[4131] = 1000000010964798151392046803; + bpsToRay[4132] = 1000000010967042059847959052; + bpsToRay[4133] = 1000000010969285809527406653; + bpsToRay[4134] = 1000000010971529400452857709; + bpsToRay[4135] = 1000000010973772832646775552; + bpsToRay[4136] = 1000000010976016106131618751; + bpsToRay[4137] = 1000000010978259220929841103; + bpsToRay[4138] = 1000000010980502177063891645; + bpsToRay[4139] = 1000000010982744974556214650; + bpsToRay[4140] = 1000000010984987613429249625; + bpsToRay[4141] = 1000000010987230093705431322; + bpsToRay[4142] = 1000000010989472415407189730; + bpsToRay[4143] = 1000000010991714578556950080; + bpsToRay[4144] = 1000000010993956583177132848; + bpsToRay[4145] = 1000000010996198429290153754; + bpsToRay[4146] = 1000000010998440116918423764; + bpsToRay[4147] = 1000000011000681646084349091; + bpsToRay[4148] = 1000000011002923016810331196; + bpsToRay[4149] = 1000000011005164229118766794; + bpsToRay[4150] = 1000000011007405283032047846; + bpsToRay[4151] = 1000000011009646178572561570; + bpsToRay[4152] = 1000000011011886915762690435; + bpsToRay[4153] = 1000000011014127494624812168; + bpsToRay[4154] = 1000000011016367915181299751; + bpsToRay[4155] = 1000000011018608177454521425; + bpsToRay[4156] = 1000000011020848281466840690; + bpsToRay[4157] = 1000000011023088227240616307; + bpsToRay[4158] = 1000000011025328014798202299; + bpsToRay[4159] = 1000000011027567644161947953; + bpsToRay[4160] = 1000000011029807115354197820; + bpsToRay[4161] = 1000000011032046428397291718; + bpsToRay[4162] = 1000000011034285583313564733; + bpsToRay[4163] = 1000000011036524580125347217; + bpsToRay[4164] = 1000000011038763418854964795; + bpsToRay[4165] = 1000000011041002099524738363; + bpsToRay[4166] = 1000000011043240622156984088; + bpsToRay[4167] = 1000000011045478986774013414; + bpsToRay[4168] = 1000000011047717193398133058; + bpsToRay[4169] = 1000000011049955242051645015; + bpsToRay[4170] = 1000000011052193132756846559; + bpsToRay[4171] = 1000000011054430865536030243; + bpsToRay[4172] = 1000000011056668440411483899; + bpsToRay[4173] = 1000000011058905857405490642; + bpsToRay[4174] = 1000000011061143116540328874; + bpsToRay[4175] = 1000000011063380217838272275; + bpsToRay[4176] = 1000000011065617161321589818; + bpsToRay[4177] = 1000000011067853947012545760; + bpsToRay[4178] = 1000000011070090574933399646; + bpsToRay[4179] = 1000000011072327045106406314; + bpsToRay[4180] = 1000000011074563357553815892; + bpsToRay[4181] = 1000000011076799512297873799; + bpsToRay[4182] = 1000000011079035509360820752; + bpsToRay[4183] = 1000000011081271348764892760; + bpsToRay[4184] = 1000000011083507030532321133; + bpsToRay[4185] = 1000000011085742554685332472; + bpsToRay[4186] = 1000000011087977921246148683; + bpsToRay[4187] = 1000000011090213130236986974; + bpsToRay[4188] = 1000000011092448181680059850; + bpsToRay[4189] = 1000000011094683075597575122; + bpsToRay[4190] = 1000000011096917812011735908; + bpsToRay[4191] = 1000000011099152390944740628; + bpsToRay[4192] = 1000000011101386812418783011; + bpsToRay[4193] = 1000000011103621076456052096; + bpsToRay[4194] = 1000000011105855183078732230; + bpsToRay[4195] = 1000000011108089132309003072; + bpsToRay[4196] = 1000000011110322924169039595; + bpsToRay[4197] = 1000000011112556558681012085; + bpsToRay[4198] = 1000000011114790035867086142; + bpsToRay[4199] = 1000000011117023355749422684; + bpsToRay[4200] = 1000000011119256518350177948; + bpsToRay[4201] = 1000000011121489523691503488; + bpsToRay[4202] = 1000000011123722371795546180; + bpsToRay[4203] = 1000000011125955062684448222; + bpsToRay[4204] = 1000000011128187596380347134; + bpsToRay[4205] = 1000000011130419972905375761; + bpsToRay[4206] = 1000000011132652192281662277; + bpsToRay[4207] = 1000000011134884254531330177; + bpsToRay[4208] = 1000000011137116159676498289; + bpsToRay[4209] = 1000000011139347907739280771; + bpsToRay[4210] = 1000000011141579498741787109; + bpsToRay[4211] = 1000000011143810932706122123; + bpsToRay[4212] = 1000000011146042209654385969; + bpsToRay[4213] = 1000000011148273329608674134; + bpsToRay[4214] = 1000000011150504292591077445; + bpsToRay[4215] = 1000000011152735098623682064; + bpsToRay[4216] = 1000000011154965747728569493; + bpsToRay[4217] = 1000000011157196239927816576; + bpsToRay[4218] = 1000000011159426575243495495; + bpsToRay[4219] = 1000000011161656753697673778; + bpsToRay[4220] = 1000000011163886775312414296; + bpsToRay[4221] = 1000000011166116640109775265; + bpsToRay[4222] = 1000000011168346348111810249; + bpsToRay[4223] = 1000000011170575899340568161; + bpsToRay[4224] = 1000000011172805293818093260; + bpsToRay[4225] = 1000000011175034531566425160; + bpsToRay[4226] = 1000000011177263612607598825; + bpsToRay[4227] = 1000000011179492536963644571; + bpsToRay[4228] = 1000000011181721304656588071; + bpsToRay[4229] = 1000000011183949915708450354; + bpsToRay[4230] = 1000000011186178370141247803; + bpsToRay[4231] = 1000000011188406667976992166; + bpsToRay[4232] = 1000000011190634809237690543; + bpsToRay[4233] = 1000000011192862793945345402; + bpsToRay[4234] = 1000000011195090622121954571; + bpsToRay[4235] = 1000000011197318293789511240; + bpsToRay[4236] = 1000000011199545808970003967; + bpsToRay[4237] = 1000000011201773167685416674; + bpsToRay[4238] = 1000000011204000369957728654; + bpsToRay[4239] = 1000000011206227415808914565; + bpsToRay[4240] = 1000000011208454305260944438; + bpsToRay[4241] = 1000000011210681038335783676; + bpsToRay[4242] = 1000000011212907615055393052; + bpsToRay[4243] = 1000000011215134035441728718; + bpsToRay[4244] = 1000000011217360299516742197; + bpsToRay[4245] = 1000000011219586407302380389; + bpsToRay[4246] = 1000000011221812358820585577; + bpsToRay[4247] = 1000000011224038154093295418; + bpsToRay[4248] = 1000000011226263793142442953; + bpsToRay[4249] = 1000000011228489275989956604; + bpsToRay[4250] = 1000000011230714602657760176; + bpsToRay[4251] = 1000000011232939773167772858; + bpsToRay[4252] = 1000000011235164787541909226; + bpsToRay[4253] = 1000000011237389645802079244; + bpsToRay[4254] = 1000000011239614347970188264; + bpsToRay[4255] = 1000000011241838894068137026; + bpsToRay[4256] = 1000000011244063284117821662; + bpsToRay[4257] = 1000000011246287518141133699; + bpsToRay[4258] = 1000000011248511596159960053; + bpsToRay[4259] = 1000000011250735518196183039; + bpsToRay[4260] = 1000000011252959284271680367; + bpsToRay[4261] = 1000000011255182894408325144; + bpsToRay[4262] = 1000000011257406348627985874; + bpsToRay[4263] = 1000000011259629646952526467; + bpsToRay[4264] = 1000000011261852789403806228; + bpsToRay[4265] = 1000000011264075776003679869; + bpsToRay[4266] = 1000000011266298606773997503; + bpsToRay[4267] = 1000000011268521281736604652; + bpsToRay[4268] = 1000000011270743800913342239; + bpsToRay[4269] = 1000000011272966164326046602; + bpsToRay[4270] = 1000000011275188371996549481; + bpsToRay[4271] = 1000000011277410423946678031; + bpsToRay[4272] = 1000000011279632320198254820; + bpsToRay[4273] = 1000000011281854060773097822; + bpsToRay[4274] = 1000000011284075645693020433; + bpsToRay[4275] = 1000000011286297074979831462; + bpsToRay[4276] = 1000000011288518348655335131; + bpsToRay[4277] = 1000000011290739466741331087; + bpsToRay[4278] = 1000000011292960429259614390; + bpsToRay[4279] = 1000000011295181236231975526; + bpsToRay[4280] = 1000000011297401887680200399; + bpsToRay[4281] = 1000000011299622383626070339; + bpsToRay[4282] = 1000000011301842724091362099; + bpsToRay[4283] = 1000000011304062909097847859; + bpsToRay[4284] = 1000000011306282938667295224; + bpsToRay[4285] = 1000000011308502812821467231; + bpsToRay[4286] = 1000000011310722531582122343; + bpsToRay[4287] = 1000000011312942094971014457; + bpsToRay[4288] = 1000000011315161503009892899; + bpsToRay[4289] = 1000000011317380755720502432; + bpsToRay[4290] = 1000000011319599853124583251; + bpsToRay[4291] = 1000000011321818795243870989; + bpsToRay[4292] = 1000000011324037582100096715; + bpsToRay[4293] = 1000000011326256213714986939; + bpsToRay[4294] = 1000000011328474690110263606; + bpsToRay[4295] = 1000000011330693011307644108; + bpsToRay[4296] = 1000000011332911177328841276; + bpsToRay[4297] = 1000000011335129188195563387; + bpsToRay[4298] = 1000000011337347043929514159; + bpsToRay[4299] = 1000000011339564744552392760; + bpsToRay[4300] = 1000000011341782290085893805; + bpsToRay[4301] = 1000000011343999680551707357; + bpsToRay[4302] = 1000000011346216915971518931; + bpsToRay[4303] = 1000000011348433996367009488; + bpsToRay[4304] = 1000000011350650921759855449; + bpsToRay[4305] = 1000000011352867692171728685; + bpsToRay[4306] = 1000000011355084307624296520; + bpsToRay[4307] = 1000000011357300768139221740; + bpsToRay[4308] = 1000000011359517073738162585; + bpsToRay[4309] = 1000000011361733224442772754; + bpsToRay[4310] = 1000000011363949220274701408; + bpsToRay[4311] = 1000000011366165061255593168; + bpsToRay[4312] = 1000000011368380747407088120; + bpsToRay[4313] = 1000000011370596278750821810; + bpsToRay[4314] = 1000000011372811655308425254; + bpsToRay[4315] = 1000000011375026877101524932; + bpsToRay[4316] = 1000000011377241944151742792; + bpsToRay[4317] = 1000000011379456856480696254; + bpsToRay[4318] = 1000000011381671614109998202; + bpsToRay[4319] = 1000000011383886217061256998; + bpsToRay[4320] = 1000000011386100665356076475; + bpsToRay[4321] = 1000000011388314959016055939; + bpsToRay[4322] = 1000000011390529098062790173; + bpsToRay[4323] = 1000000011392743082517869435; + bpsToRay[4324] = 1000000011394956912402879463; + bpsToRay[4325] = 1000000011397170587739401474; + bpsToRay[4326] = 1000000011399384108549012164; + bpsToRay[4327] = 1000000011401597474853283711; + bpsToRay[4328] = 1000000011403810686673783778; + bpsToRay[4329] = 1000000011406023744032075511; + bpsToRay[4330] = 1000000011408236646949717541; + bpsToRay[4331] = 1000000011410449395448263986; + bpsToRay[4332] = 1000000011412661989549264455; + bpsToRay[4333] = 1000000011414874429274264041; + bpsToRay[4334] = 1000000011417086714644803332; + bpsToRay[4335] = 1000000011419298845682418407; + bpsToRay[4336] = 1000000011421510822408640836; + bpsToRay[4337] = 1000000011423722644844997686; + bpsToRay[4338] = 1000000011425934313013011518; + bpsToRay[4339] = 1000000011428145826934200391; + bpsToRay[4340] = 1000000011430357186630077862; + bpsToRay[4341] = 1000000011432568392122152986; + bpsToRay[4342] = 1000000011434779443431930319; + bpsToRay[4343] = 1000000011436990340580909922; + bpsToRay[4344] = 1000000011439201083590587356; + bpsToRay[4345] = 1000000011441411672482453687; + bpsToRay[4346] = 1000000011443622107277995486; + bpsToRay[4347] = 1000000011445832387998694833; + bpsToRay[4348] = 1000000011448042514666029315; + bpsToRay[4349] = 1000000011450252487301472028; + bpsToRay[4350] = 1000000011452462305926491579; + bpsToRay[4351] = 1000000011454671970562552089; + bpsToRay[4352] = 1000000011456881481231113188; + bpsToRay[4353] = 1000000011459090837953630024; + bpsToRay[4354] = 1000000011461300040751553259; + bpsToRay[4355] = 1000000011463509089646329073; + bpsToRay[4356] = 1000000011465717984659399163; + bpsToRay[4357] = 1000000011467926725812200747; + bpsToRay[4358] = 1000000011470135313126166561; + bpsToRay[4359] = 1000000011472343746622724867; + bpsToRay[4360] = 1000000011474552026323299446; + bpsToRay[4361] = 1000000011476760152249309607; + bpsToRay[4362] = 1000000011478968124422170181; + bpsToRay[4363] = 1000000011481175942863291530; + bpsToRay[4364] = 1000000011483383607594079540; + bpsToRay[4365] = 1000000011485591118635935631; + bpsToRay[4366] = 1000000011487798476010256750; + bpsToRay[4367] = 1000000011490005679738435376; + bpsToRay[4368] = 1000000011492212729841859524; + bpsToRay[4369] = 1000000011494419626341912740; + bpsToRay[4370] = 1000000011496626369259974109; + bpsToRay[4371] = 1000000011498832958617418250; + bpsToRay[4372] = 1000000011501039394435615322; + bpsToRay[4373] = 1000000011503245676735931022; + bpsToRay[4374] = 1000000011505451805539726589; + bpsToRay[4375] = 1000000011507657780868358802; + bpsToRay[4376] = 1000000011509863602743179986; + bpsToRay[4377] = 1000000011512069271185538006; + bpsToRay[4378] = 1000000011514274786216776278; + bpsToRay[4379] = 1000000011516480147858233760; + bpsToRay[4380] = 1000000011518685356131244960; + bpsToRay[4381] = 1000000011520890411057139937; + bpsToRay[4382] = 1000000011523095312657244296; + bpsToRay[4383] = 1000000011525300060952879198; + bpsToRay[4384] = 1000000011527504655965361356; + bpsToRay[4385] = 1000000011529709097716003036; + bpsToRay[4386] = 1000000011531913386226112060; + bpsToRay[4387] = 1000000011534117521516991808; + bpsToRay[4388] = 1000000011536321503609941215; + bpsToRay[4389] = 1000000011538525332526254779; + bpsToRay[4390] = 1000000011540729008287222556; + bpsToRay[4391] = 1000000011542932530914130163; + bpsToRay[4392] = 1000000011545135900428258782; + bpsToRay[4393] = 1000000011547339116850885159; + bpsToRay[4394] = 1000000011549542180203281602; + bpsToRay[4395] = 1000000011551745090506715989; + bpsToRay[4396] = 1000000011553947847782451765; + bpsToRay[4397] = 1000000011556150452051747944; + bpsToRay[4398] = 1000000011558352903335859111; + bpsToRay[4399] = 1000000011560555201656035419; + bpsToRay[4400] = 1000000011562757347033522598; + bpsToRay[4401] = 1000000011564959339489561951; + bpsToRay[4402] = 1000000011567161179045390355; + bpsToRay[4403] = 1000000011569362865722240263; + bpsToRay[4404] = 1000000011571564399541339706; + bpsToRay[4405] = 1000000011573765780523912298; + bpsToRay[4406] = 1000000011575967008691177226; + bpsToRay[4407] = 1000000011578168084064349263; + bpsToRay[4408] = 1000000011580369006664638762; + bpsToRay[4409] = 1000000011582569776513251664; + bpsToRay[4410] = 1000000011584770393631389491; + bpsToRay[4411] = 1000000011586970858040249351; + bpsToRay[4412] = 1000000011589171169761023944; + bpsToRay[4413] = 1000000011591371328814901553; + bpsToRay[4414] = 1000000011593571335223066054; + bpsToRay[4415] = 1000000011595771189006696913; + bpsToRay[4416] = 1000000011597970890186969190; + bpsToRay[4417] = 1000000011600170438785053539; + bpsToRay[4418] = 1000000011602369834822116205; + bpsToRay[4419] = 1000000011604569078319319032; + bpsToRay[4420] = 1000000011606768169297819461; + bpsToRay[4421] = 1000000011608967107778770531; + bpsToRay[4422] = 1000000011611165893783320880; + bpsToRay[4423] = 1000000011613364527332614750; + bpsToRay[4424] = 1000000011615563008447791980; + bpsToRay[4425] = 1000000011617761337149988016; + bpsToRay[4426] = 1000000011619959513460333909; + bpsToRay[4427] = 1000000011622157537399956313; + bpsToRay[4428] = 1000000011624355408989977491; + bpsToRay[4429] = 1000000011626553128251515315; + bpsToRay[4430] = 1000000011628750695205683263; + bpsToRay[4431] = 1000000011630948109873590427; + bpsToRay[4432] = 1000000011633145372276341510; + bpsToRay[4433] = 1000000011635342482435036828; + bpsToRay[4434] = 1000000011637539440370772309; + bpsToRay[4435] = 1000000011639736246104639501; + bpsToRay[4436] = 1000000011641932899657725566; + bpsToRay[4437] = 1000000011644129401051113283; + bpsToRay[4438] = 1000000011646325750305881052; + bpsToRay[4439] = 1000000011648521947443102894; + bpsToRay[4440] = 1000000011650717992483848450; + bpsToRay[4441] = 1000000011652913885449182982; + bpsToRay[4442] = 1000000011655109626360167380; + bpsToRay[4443] = 1000000011657305215237858159; + bpsToRay[4444] = 1000000011659500652103307456; + bpsToRay[4445] = 1000000011661695936977563040; + bpsToRay[4446] = 1000000011663891069881668309; + bpsToRay[4447] = 1000000011666086050836662286; + bpsToRay[4448] = 1000000011668280879863579631; + bpsToRay[4449] = 1000000011670475556983450634; + bpsToRay[4450] = 1000000011672670082217301219; + bpsToRay[4451] = 1000000011674864455586152944; + bpsToRay[4452] = 1000000011677058677111023005; + bpsToRay[4453] = 1000000011679252746812924234; + bpsToRay[4454] = 1000000011681446664712865102; + bpsToRay[4455] = 1000000011683640430831849720; + bpsToRay[4456] = 1000000011685834045190877838; + bpsToRay[4457] = 1000000011688027507810944851; + bpsToRay[4458] = 1000000011690220818713041795; + bpsToRay[4459] = 1000000011692413977918155352; + bpsToRay[4460] = 1000000011694606985447267850; + bpsToRay[4461] = 1000000011696799841321357263; + bpsToRay[4462] = 1000000011698992545561397213; + bpsToRay[4463] = 1000000011701185098188356972; + bpsToRay[4464] = 1000000011703377499223201464; + bpsToRay[4465] = 1000000011705569748686891261; + bpsToRay[4466] = 1000000011707761846600382591; + bpsToRay[4467] = 1000000011709953792984627335; + bpsToRay[4468] = 1000000011712145587860573032; + bpsToRay[4469] = 1000000011714337231249162871; + bpsToRay[4470] = 1000000011716528723171335709; + bpsToRay[4471] = 1000000011718720063648026051; + bpsToRay[4472] = 1000000011720911252700164071; + bpsToRay[4473] = 1000000011723102290348675597; + bpsToRay[4474] = 1000000011725293176614482128; + bpsToRay[4475] = 1000000011727483911518500818; + bpsToRay[4476] = 1000000011729674495081644493; + bpsToRay[4477] = 1000000011731864927324821641; + bpsToRay[4478] = 1000000011734055208268936418; + bpsToRay[4479] = 1000000011736245337934888652; + bpsToRay[4480] = 1000000011738435316343573834; + bpsToRay[4481] = 1000000011740625143515883134; + bpsToRay[4482] = 1000000011742814819472703388; + bpsToRay[4483] = 1000000011745004344234917107; + bpsToRay[4484] = 1000000011747193717823402479; + bpsToRay[4485] = 1000000011749382940259033365; + bpsToRay[4486] = 1000000011751572011562679304; + bpsToRay[4487] = 1000000011753760931755205513; + bpsToRay[4488] = 1000000011755949700857472887; + bpsToRay[4489] = 1000000011758138318890338005; + bpsToRay[4490] = 1000000011760326785874653124; + bpsToRay[4491] = 1000000011762515101831266185; + bpsToRay[4492] = 1000000011764703266781020815; + bpsToRay[4493] = 1000000011766891280744756325; + bpsToRay[4494] = 1000000011769079143743307711; + bpsToRay[4495] = 1000000011771266855797505659; + bpsToRay[4496] = 1000000011773454416928176542; + bpsToRay[4497] = 1000000011775641827156142425; + bpsToRay[4498] = 1000000011777829086502221061; + bpsToRay[4499] = 1000000011780016194987225901; + bpsToRay[4500] = 1000000011782203152631966084; + bpsToRay[4501] = 1000000011784389959457246446; + bpsToRay[4502] = 1000000011786576615483867520; + bpsToRay[4503] = 1000000011788763120732625534; + bpsToRay[4504] = 1000000011790949475224312417; + bpsToRay[4505] = 1000000011793135678979715794; + bpsToRay[4506] = 1000000011795321732019618995; + bpsToRay[4507] = 1000000011797507634364801050; + bpsToRay[4508] = 1000000011799693386036036690; + bpsToRay[4509] = 1000000011801878987054096353; + bpsToRay[4510] = 1000000011804064437439746183; + bpsToRay[4511] = 1000000011806249737213748028; + bpsToRay[4512] = 1000000011808434886396859445; + bpsToRay[4513] = 1000000011810619885009833701; + bpsToRay[4514] = 1000000011812804733073419772; + bpsToRay[4515] = 1000000011814989430608362346; + bpsToRay[4516] = 1000000011817173977635401824; + bpsToRay[4517] = 1000000011819358374175274320; + bpsToRay[4518] = 1000000011821542620248711663; + bpsToRay[4519] = 1000000011823726715876441397; + bpsToRay[4520] = 1000000011825910661079186786; + bpsToRay[4521] = 1000000011828094455877666811; + bpsToRay[4522] = 1000000011830278100292596173; + bpsToRay[4523] = 1000000011832461594344685292; + bpsToRay[4524] = 1000000011834644938054640314; + bpsToRay[4525] = 1000000011836828131443163102; + bpsToRay[4526] = 1000000011839011174530951252; + bpsToRay[4527] = 1000000011841194067338698076; + bpsToRay[4528] = 1000000011843376809887092621; + bpsToRay[4529] = 1000000011845559402196819657; + bpsToRay[4530] = 1000000011847741844288559684; + bpsToRay[4531] = 1000000011849924136182988931; + bpsToRay[4532] = 1000000011852106277900779365; + bpsToRay[4533] = 1000000011854288269462598676; + bpsToRay[4534] = 1000000011856470110889110294; + bpsToRay[4535] = 1000000011858651802200973384; + bpsToRay[4536] = 1000000011860833343418842843; + bpsToRay[4537] = 1000000011863014734563369310; + bpsToRay[4538] = 1000000011865195975655199159; + bpsToRay[4539] = 1000000011867377066714974505; + bpsToRay[4540] = 1000000011869558007763333206; + bpsToRay[4541] = 1000000011871738798820908856; + bpsToRay[4542] = 1000000011873919439908330799; + bpsToRay[4543] = 1000000011876099931046224119; + bpsToRay[4544] = 1000000011878280272255209648; + bpsToRay[4545] = 1000000011880460463555903962; + bpsToRay[4546] = 1000000011882640504968919386; + bpsToRay[4547] = 1000000011884820396514863997; + bpsToRay[4548] = 1000000011887000138214341617; + bpsToRay[4549] = 1000000011889179730087951822; + bpsToRay[4550] = 1000000011891359172156289942; + bpsToRay[4551] = 1000000011893538464439947057; + bpsToRay[4552] = 1000000011895717606959510007; + bpsToRay[4553] = 1000000011897896599735561381; + bpsToRay[4554] = 1000000011900075442788679533; + bpsToRay[4555] = 1000000011902254136139438568; + bpsToRay[4556] = 1000000011904432679808408357; + bpsToRay[4557] = 1000000011906611073816154526; + bpsToRay[4558] = 1000000011908789318183238468; + bpsToRay[4559] = 1000000011910967412930217335; + bpsToRay[4560] = 1000000011913145358077644046; + bpsToRay[4561] = 1000000011915323153646067283; + bpsToRay[4562] = 1000000011917500799656031495; + bpsToRay[4563] = 1000000011919678296128076901; + bpsToRay[4564] = 1000000011921855643082739486; + bpsToRay[4565] = 1000000011924032840540551006; + bpsToRay[4566] = 1000000011926209888522038989; + bpsToRay[4567] = 1000000011928386787047726732; + bpsToRay[4568] = 1000000011930563536138133312; + bpsToRay[4569] = 1000000011932740135813773575; + bpsToRay[4570] = 1000000011934916586095158143; + bpsToRay[4571] = 1000000011937092887002793418; + bpsToRay[4572] = 1000000011939269038557181578; + bpsToRay[4573] = 1000000011941445040778820581; + bpsToRay[4574] = 1000000011943620893688204164; + bpsToRay[4575] = 1000000011945796597305821848; + bpsToRay[4576] = 1000000011947972151652158936; + bpsToRay[4577] = 1000000011950147556747696515; + bpsToRay[4578] = 1000000011952322812612911454; + bpsToRay[4579] = 1000000011954497919268276412; + bpsToRay[4580] = 1000000011956672876734259834; + bpsToRay[4581] = 1000000011958847685031325954; + bpsToRay[4582] = 1000000011961022344179934796; + bpsToRay[4583] = 1000000011963196854200542173; + bpsToRay[4584] = 1000000011965371215113599692; + bpsToRay[4585] = 1000000011967545426939554751; + bpsToRay[4586] = 1000000011969719489698850545; + bpsToRay[4587] = 1000000011971893403411926063; + bpsToRay[4588] = 1000000011974067168099216089; + bpsToRay[4589] = 1000000011976240783781151209; + bpsToRay[4590] = 1000000011978414250478157804; + bpsToRay[4591] = 1000000011980587568210658056; + bpsToRay[4592] = 1000000011982760736999069949; + bpsToRay[4593] = 1000000011984933756863807269; + bpsToRay[4594] = 1000000011987106627825279606; + bpsToRay[4595] = 1000000011989279349903892354; + bpsToRay[4596] = 1000000011991451923120046712; + bpsToRay[4597] = 1000000011993624347494139689; + bpsToRay[4598] = 1000000011995796623046564099; + bpsToRay[4599] = 1000000011997968749797708565; + bpsToRay[4600] = 1000000012000140727767957524; + bpsToRay[4601] = 1000000012002312556977691222; + bpsToRay[4602] = 1000000012004484237447285716; + bpsToRay[4603] = 1000000012006655769197112882; + bpsToRay[4604] = 1000000012008827152247540405; + bpsToRay[4605] = 1000000012010998386618931791; + bpsToRay[4606] = 1000000012013169472331646360; + bpsToRay[4607] = 1000000012015340409406039253; + bpsToRay[4608] = 1000000012017511197862461428; + bpsToRay[4609] = 1000000012019681837721259668; + bpsToRay[4610] = 1000000012021852329002776572; + bpsToRay[4611] = 1000000012024022671727350564; + bpsToRay[4612] = 1000000012026192865915315897; + bpsToRay[4613] = 1000000012028362911587002643; + bpsToRay[4614] = 1000000012030532808762736703; + bpsToRay[4615] = 1000000012032702557462839807; + bpsToRay[4616] = 1000000012034872157707629511; + bpsToRay[4617] = 1000000012037041609517419201; + bpsToRay[4618] = 1000000012039210912912518097; + bpsToRay[4619] = 1000000012041380067913231248; + bpsToRay[4620] = 1000000012043549074539859539; + bpsToRay[4621] = 1000000012045717932812699686; + bpsToRay[4622] = 1000000012047886642752044245; + bpsToRay[4623] = 1000000012050055204378181605; + bpsToRay[4624] = 1000000012052223617711395993; + bpsToRay[4625] = 1000000012054391882771967477; + bpsToRay[4626] = 1000000012056559999580171966; + bpsToRay[4627] = 1000000012058727968156281206; + bpsToRay[4628] = 1000000012060895788520562788; + bpsToRay[4629] = 1000000012063063460693280149; + bpsToRay[4630] = 1000000012065230984694692566; + bpsToRay[4631] = 1000000012067398360545055164; + bpsToRay[4632] = 1000000012069565588264618915; + bpsToRay[4633] = 1000000012071732667873630640; + bpsToRay[4634] = 1000000012073899599392333007; + bpsToRay[4635] = 1000000012076066382840964537; + bpsToRay[4636] = 1000000012078233018239759599; + bpsToRay[4637] = 1000000012080399505608948418; + bpsToRay[4638] = 1000000012082565844968757072; + bpsToRay[4639] = 1000000012084732036339407491; + bpsToRay[4640] = 1000000012086898079741117465; + bpsToRay[4641] = 1000000012089063975194100640; + bpsToRay[4642] = 1000000012091229722718566519; + bpsToRay[4643] = 1000000012093395322334720465; + bpsToRay[4644] = 1000000012095560774062763701; + bpsToRay[4645] = 1000000012097726077922893315; + bpsToRay[4646] = 1000000012099891233935302252; + bpsToRay[4647] = 1000000012102056242120179326; + bpsToRay[4648] = 1000000012104221102497709214; + bpsToRay[4649] = 1000000012106385815088072459; + bpsToRay[4650] = 1000000012108550379911445472; + bpsToRay[4651] = 1000000012110714796988000533; + bpsToRay[4652] = 1000000012112879066337905789; + bpsToRay[4653] = 1000000012115043187981325261; + bpsToRay[4654] = 1000000012117207161938418839; + bpsToRay[4655] = 1000000012119370988229342288; + bpsToRay[4656] = 1000000012121534666874247247; + bpsToRay[4657] = 1000000012123698197893281228; + bpsToRay[4658] = 1000000012125861581306587623; + bpsToRay[4659] = 1000000012128024817134305697; + bpsToRay[4660] = 1000000012130187905396570598; + bpsToRay[4661] = 1000000012132350846113513350; + bpsToRay[4662] = 1000000012134513639305260860; + bpsToRay[4663] = 1000000012136676284991935918; + bpsToRay[4664] = 1000000012138838783193657193; + bpsToRay[4665] = 1000000012141001133930539244; + bpsToRay[4666] = 1000000012143163337222692509; + bpsToRay[4667] = 1000000012145325393090223317; + bpsToRay[4668] = 1000000012147487301553233883; + bpsToRay[4669] = 1000000012149649062631822311; + bpsToRay[4670] = 1000000012151810676346082594; + bpsToRay[4671] = 1000000012153972142716104618; + bpsToRay[4672] = 1000000012156133461761974158; + bpsToRay[4673] = 1000000012158294633503772885; + bpsToRay[4674] = 1000000012160455657961578363; + bpsToRay[4675] = 1000000012162616535155464050; + bpsToRay[4676] = 1000000012164777265105499304; + bpsToRay[4677] = 1000000012166937847831749378; + bpsToRay[4678] = 1000000012169098283354275425; + bpsToRay[4679] = 1000000012171258571693134496; + bpsToRay[4680] = 1000000012173418712868379547; + bpsToRay[4681] = 1000000012175578706900059431; + bpsToRay[4682] = 1000000012177738553808218907; + bpsToRay[4683] = 1000000012179898253612898639; + bpsToRay[4684] = 1000000012182057806334135196; + bpsToRay[4685] = 1000000012184217211991961053; + bpsToRay[4686] = 1000000012186376470606404593; + bpsToRay[4687] = 1000000012188535582197490106; + bpsToRay[4688] = 1000000012190694546785237795; + bpsToRay[4689] = 1000000012192853364389663774; + bpsToRay[4690] = 1000000012195012035030780065; + bpsToRay[4691] = 1000000012197170558728594608; + bpsToRay[4692] = 1000000012199328935503111256; + bpsToRay[4693] = 1000000012201487165374329775; + bpsToRay[4694] = 1000000012203645248362245852; + bpsToRay[4695] = 1000000012205803184486851087; + bpsToRay[4696] = 1000000012207960973768133003; + bpsToRay[4697] = 1000000012210118616226075039; + bpsToRay[4698] = 1000000012212276111880656560; + bpsToRay[4699] = 1000000012214433460751852848; + bpsToRay[4700] = 1000000012216590662859635112; + bpsToRay[4701] = 1000000012218747718223970482; + bpsToRay[4702] = 1000000012220904626864822019; + bpsToRay[4703] = 1000000012223061388802148704; + bpsToRay[4704] = 1000000012225218004055905450; + bpsToRay[4705] = 1000000012227374472646043097; + bpsToRay[4706] = 1000000012229530794592508416; + bpsToRay[4707] = 1000000012231686969915244108; + bpsToRay[4708] = 1000000012233842998634188809; + bpsToRay[4709] = 1000000012235998880769277082; + bpsToRay[4710] = 1000000012238154616340439431; + bpsToRay[4711] = 1000000012240310205367602293; + bpsToRay[4712] = 1000000012242465647870688040; + bpsToRay[4713] = 1000000012244620943869614982; + bpsToRay[4714] = 1000000012246776093384297371; + bpsToRay[4715] = 1000000012248931096434645396; + bpsToRay[4716] = 1000000012251085953040565187; + bpsToRay[4717] = 1000000012253240663221958817; + bpsToRay[4718] = 1000000012255395226998724301; + bpsToRay[4719] = 1000000012257549644390755600; + bpsToRay[4720] = 1000000012259703915417942619; + bpsToRay[4721] = 1000000012261858040100171212; + bpsToRay[4722] = 1000000012264012018457323175; + bpsToRay[4723] = 1000000012266165850509276259; + bpsToRay[4724] = 1000000012268319536275904161; + bpsToRay[4725] = 1000000012270473075777076530; + bpsToRay[4726] = 1000000012272626469032658968; + bpsToRay[4727] = 1000000012274779716062513028; + bpsToRay[4728] = 1000000012276932816886496218; + bpsToRay[4729] = 1000000012279085771524462002; + bpsToRay[4730] = 1000000012281238579996259799; + bpsToRay[4731] = 1000000012283391242321734988; + bpsToRay[4732] = 1000000012285543758520728905; + bpsToRay[4733] = 1000000012287696128613078844; + bpsToRay[4734] = 1000000012289848352618618062; + bpsToRay[4735] = 1000000012292000430557175778; + bpsToRay[4736] = 1000000012294152362448577173; + bpsToRay[4737] = 1000000012296304148312643392; + bpsToRay[4738] = 1000000012298455788169191545; + bpsToRay[4739] = 1000000012300607282038034711; + bpsToRay[4740] = 1000000012302758629938981931; + bpsToRay[4741] = 1000000012304909831891838220; + bpsToRay[4742] = 1000000012307060887916404559; + bpsToRay[4743] = 1000000012309211798032477901; + bpsToRay[4744] = 1000000012311362562259851171; + bpsToRay[4745] = 1000000012313513180618313265; + bpsToRay[4746] = 1000000012315663653127649055; + bpsToRay[4747] = 1000000012317813979807639387; + bpsToRay[4748] = 1000000012319964160678061084; + bpsToRay[4749] = 1000000012322114195758686945; + bpsToRay[4750] = 1000000012324264085069285747; + bpsToRay[4751] = 1000000012326413828629622247; + bpsToRay[4752] = 1000000012328563426459457184; + bpsToRay[4753] = 1000000012330712878578547277; + bpsToRay[4754] = 1000000012332862185006645225; + bpsToRay[4755] = 1000000012335011345763499718; + bpsToRay[4756] = 1000000012337160360868855422; + bpsToRay[4757] = 1000000012339309230342452997; + bpsToRay[4758] = 1000000012341457954204029084; + bpsToRay[4759] = 1000000012343606532473316314; + bpsToRay[4760] = 1000000012345754965170043307; + bpsToRay[4761] = 1000000012347903252313934676; + bpsToRay[4762] = 1000000012350051393924711022; + bpsToRay[4763] = 1000000012352199390022088940; + bpsToRay[4764] = 1000000012354347240625781016; + bpsToRay[4765] = 1000000012356494945755495834; + bpsToRay[4766] = 1000000012358642505430937972; + bpsToRay[4767] = 1000000012360789919671808004; + bpsToRay[4768] = 1000000012362937188497802506; + bpsToRay[4769] = 1000000012365084311928614047; + bpsToRay[4770] = 1000000012367231289983931199; + bpsToRay[4771] = 1000000012369378122683438536; + bpsToRay[4772] = 1000000012371524810046816632; + bpsToRay[4773] = 1000000012373671352093742067; + bpsToRay[4774] = 1000000012375817748843887422; + bpsToRay[4775] = 1000000012377964000316921287; + bpsToRay[4776] = 1000000012380110106532508255; + bpsToRay[4777] = 1000000012382256067510308928; + bpsToRay[4778] = 1000000012384401883269979920; + bpsToRay[4779] = 1000000012386547553831173848; + bpsToRay[4780] = 1000000012388693079213539345; + bpsToRay[4781] = 1000000012390838459436721054; + bpsToRay[4782] = 1000000012392983694520359633; + bpsToRay[4783] = 1000000012395128784484091752; + bpsToRay[4784] = 1000000012397273729347550096; + bpsToRay[4785] = 1000000012399418529130363366; + bpsToRay[4786] = 1000000012401563183852156283; + bpsToRay[4787] = 1000000012403707693532549584; + bpsToRay[4788] = 1000000012405852058191160026; + bpsToRay[4789] = 1000000012407996277847600385; + bpsToRay[4790] = 1000000012410140352521479464; + bpsToRay[4791] = 1000000012412284282232402082; + bpsToRay[4792] = 1000000012414428066999969084; + bpsToRay[4793] = 1000000012416571706843777343; + bpsToRay[4794] = 1000000012418715201783419755; + bpsToRay[4795] = 1000000012420858551838485241; + bpsToRay[4796] = 1000000012423001757028558755; + bpsToRay[4797] = 1000000012425144817373221276; + bpsToRay[4798] = 1000000012427287732892049817; + bpsToRay[4799] = 1000000012429430503604617418; + bpsToRay[4800] = 1000000012431573129530493155; + bpsToRay[4801] = 1000000012433715610689242134; + bpsToRay[4802] = 1000000012435857947100425498; + bpsToRay[4803] = 1000000012438000138783600426; + bpsToRay[4804] = 1000000012440142185758320132; + bpsToRay[4805] = 1000000012442284088044133868; + bpsToRay[4806] = 1000000012444425845660586926; + bpsToRay[4807] = 1000000012446567458627220637; + bpsToRay[4808] = 1000000012448708926963572372; + bpsToRay[4809] = 1000000012450850250689175545; + bpsToRay[4810] = 1000000012452991429823559613; + bpsToRay[4811] = 1000000012455132464386250078; + bpsToRay[4812] = 1000000012457273354396768485; + bpsToRay[4813] = 1000000012459414099874632428; + bpsToRay[4814] = 1000000012461554700839355545; + bpsToRay[4815] = 1000000012463695157310447527; + bpsToRay[4816] = 1000000012465835469307414110; + bpsToRay[4817] = 1000000012467975636849757081; + bpsToRay[4818] = 1000000012470115659956974282; + bpsToRay[4819] = 1000000012472255538648559605; + bpsToRay[4820] = 1000000012474395272944002997; + bpsToRay[4821] = 1000000012476534862862790458; + bpsToRay[4822] = 1000000012478674308424404046; + bpsToRay[4823] = 1000000012480813609648321873; + bpsToRay[4824] = 1000000012482952766554018113; + bpsToRay[4825] = 1000000012485091779160962996; + bpsToRay[4826] = 1000000012487230647488622814; + bpsToRay[4827] = 1000000012489369371556459918; + bpsToRay[4828] = 1000000012491507951383932723; + bpsToRay[4829] = 1000000012493646386990495707; + bpsToRay[4830] = 1000000012495784678395599413; + bpsToRay[4831] = 1000000012497922825618690446; + bpsToRay[4832] = 1000000012500060828679211483; + bpsToRay[4833] = 1000000012502198687596601264; + bpsToRay[4834] = 1000000012504336402390294600; + bpsToRay[4835] = 1000000012506473973079722370; + bpsToRay[4836] = 1000000012508611399684311526; + bpsToRay[4837] = 1000000012510748682223485091; + bpsToRay[4838] = 1000000012512885820716662158; + bpsToRay[4839] = 1000000012515022815183257897; + bpsToRay[4840] = 1000000012517159665642683553; + bpsToRay[4841] = 1000000012519296372114346446; + bpsToRay[4842] = 1000000012521432934617649973; + bpsToRay[4843] = 1000000012523569353171993611; + bpsToRay[4844] = 1000000012525705627796772912; + bpsToRay[4845] = 1000000012527841758511379512; + bpsToRay[4846] = 1000000012529977745335201128; + bpsToRay[4847] = 1000000012532113588287621558; + bpsToRay[4848] = 1000000012534249287388020684; + bpsToRay[4849] = 1000000012536384842655774473; + bpsToRay[4850] = 1000000012538520254110254976; + bpsToRay[4851] = 1000000012540655521770830332; + bpsToRay[4852] = 1000000012542790645656864768; + bpsToRay[4853] = 1000000012544925625787718599; + bpsToRay[4854] = 1000000012547060462182748227; + bpsToRay[4855] = 1000000012549195154861306151; + bpsToRay[4856] = 1000000012551329703842740957; + bpsToRay[4857] = 1000000012553464109146397324; + bpsToRay[4858] = 1000000012555598370791616028; + bpsToRay[4859] = 1000000012557732488797733936; + bpsToRay[4860] = 1000000012559866463184084017; + bpsToRay[4861] = 1000000012562000293969995331; + bpsToRay[4862] = 1000000012564133981174793037; + bpsToRay[4863] = 1000000012566267524817798398; + bpsToRay[4864] = 1000000012568400924918328770; + bpsToRay[4865] = 1000000012570534181495697619; + bpsToRay[4866] = 1000000012572667294569214506; + bpsToRay[4867] = 1000000012574800264158185098; + bpsToRay[4868] = 1000000012576933090281911168; + bpsToRay[4869] = 1000000012579065772959690591; + bpsToRay[4870] = 1000000012581198312210817352; + bpsToRay[4871] = 1000000012583330708054581542; + bpsToRay[4872] = 1000000012585462960510269361; + bpsToRay[4873] = 1000000012587595069597163118; + bpsToRay[4874] = 1000000012589727035334541233; + bpsToRay[4875] = 1000000012591858857741678240; + bpsToRay[4876] = 1000000012593990536837844781; + bpsToRay[4877] = 1000000012596122072642307617; + bpsToRay[4878] = 1000000012598253465174329620; + bpsToRay[4879] = 1000000012600384714453169781; + bpsToRay[4880] = 1000000012602515820498083206; + bpsToRay[4881] = 1000000012604646783328321121; + bpsToRay[4882] = 1000000012606777602963130868; + bpsToRay[4883] = 1000000012608908279421755911; + bpsToRay[4884] = 1000000012611038812723435837; + bpsToRay[4885] = 1000000012613169202887406351; + bpsToRay[4886] = 1000000012615299449932899285; + bpsToRay[4887] = 1000000012617429553879142594; + bpsToRay[4888] = 1000000012619559514745360358; + bpsToRay[4889] = 1000000012621689332550772783; + bpsToRay[4890] = 1000000012623819007314596205; + bpsToRay[4891] = 1000000012625948539056043084; + bpsToRay[4892] = 1000000012628077927794322013; + bpsToRay[4893] = 1000000012630207173548637715; + bpsToRay[4894] = 1000000012632336276338191046; + bpsToRay[4895] = 1000000012634465236182178989; + bpsToRay[4896] = 1000000012636594053099794667; + bpsToRay[4897] = 1000000012638722727110227335; + bpsToRay[4898] = 1000000012640851258232662384; + bpsToRay[4899] = 1000000012642979646486281341; + bpsToRay[4900] = 1000000012645107891890261872; + bpsToRay[4901] = 1000000012647235994463777781; + bpsToRay[4902] = 1000000012649363954225999014; + bpsToRay[4903] = 1000000012651491771196091654; + bpsToRay[4904] = 1000000012653619445393217929; + bpsToRay[4905] = 1000000012655746976836536210; + bpsToRay[4906] = 1000000012657874365545201009; + bpsToRay[4907] = 1000000012660001611538362988; + bpsToRay[4908] = 1000000012662128714835168951; + bpsToRay[4909] = 1000000012664255675454761851; + bpsToRay[4910] = 1000000012666382493416280789; + bpsToRay[4911] = 1000000012668509168738861013; + bpsToRay[4912] = 1000000012670635701441633926; + bpsToRay[4913] = 1000000012672762091543727077; + bpsToRay[4914] = 1000000012674888339064264171; + bpsToRay[4915] = 1000000012677014444022365063; + bpsToRay[4916] = 1000000012679140406437145768; + bpsToRay[4917] = 1000000012681266226327718450; + bpsToRay[4918] = 1000000012683391903713191434; + bpsToRay[4919] = 1000000012685517438612669200; + bpsToRay[4920] = 1000000012687642831045252386; + bpsToRay[4921] = 1000000012689768081030037793; + bpsToRay[4922] = 1000000012691893188586118377; + bpsToRay[4923] = 1000000012694018153732583262; + bpsToRay[4924] = 1000000012696142976488517730; + bpsToRay[4925] = 1000000012698267656873003228; + bpsToRay[4926] = 1000000012700392194905117369; + bpsToRay[4927] = 1000000012702516590603933928; + bpsToRay[4928] = 1000000012704640843988522851; + bpsToRay[4929] = 1000000012706764955077950249; + bpsToRay[4930] = 1000000012708888923891278404; + bpsToRay[4931] = 1000000012711012750447565765; + bpsToRay[4932] = 1000000012713136434765866954; + bpsToRay[4933] = 1000000012715259976865232764; + bpsToRay[4934] = 1000000012717383376764710160; + bpsToRay[4935] = 1000000012719506634483342283; + bpsToRay[4936] = 1000000012721629750040168448; + bpsToRay[4937] = 1000000012723752723454224145; + bpsToRay[4938] = 1000000012725875554744541042; + bpsToRay[4939] = 1000000012727998243930146984; + bpsToRay[4940] = 1000000012730120791030065998; + bpsToRay[4941] = 1000000012732243196063318286; + bpsToRay[4942] = 1000000012734365459048920235; + bpsToRay[4943] = 1000000012736487580005884415; + bpsToRay[4944] = 1000000012738609558953219573; + bpsToRay[4945] = 1000000012740731395909930647; + bpsToRay[4946] = 1000000012742853090895018757; + bpsToRay[4947] = 1000000012744974643927481210; + bpsToRay[4948] = 1000000012747096055026311497; + bpsToRay[4949] = 1000000012749217324210499303; + bpsToRay[4950] = 1000000012751338451499030498; + bpsToRay[4951] = 1000000012753459436910887143; + bpsToRay[4952] = 1000000012755580280465047490; + bpsToRay[4953] = 1000000012757700982180485986; + bpsToRay[4954] = 1000000012759821542076173268; + bpsToRay[4955] = 1000000012761941960171076169; + bpsToRay[4956] = 1000000012764062236484157718; + bpsToRay[4957] = 1000000012766182371034377136; + bpsToRay[4958] = 1000000012768302363840689849; + bpsToRay[4959] = 1000000012770422214922047473; + bpsToRay[4960] = 1000000012772541924297397831; + bpsToRay[4961] = 1000000012774661491985684940; + bpsToRay[4962] = 1000000012776780918005849024; + bpsToRay[4963] = 1000000012778900202376826505; + bpsToRay[4964] = 1000000012781019345117550012; + bpsToRay[4965] = 1000000012783138346246948375; + bpsToRay[4966] = 1000000012785257205783946632; + bpsToRay[4967] = 1000000012787375923747466027; + bpsToRay[4968] = 1000000012789494500156424011; + bpsToRay[4969] = 1000000012791612935029734245; + bpsToRay[4970] = 1000000012793731228386306598; + bpsToRay[4971] = 1000000012795849380245047149; + bpsToRay[4972] = 1000000012797967390624858191; + bpsToRay[4973] = 1000000012800085259544638227; + bpsToRay[4974] = 1000000012802202987023281977; + bpsToRay[4975] = 1000000012804320573079680371; + bpsToRay[4976] = 1000000012806438017732720558; + bpsToRay[4977] = 1000000012808555321001285904; + bpsToRay[4978] = 1000000012810672482904255989; + bpsToRay[4979] = 1000000012812789503460506616; + bpsToRay[4980] = 1000000012814906382688909806; + bpsToRay[4981] = 1000000012817023120608333799; + bpsToRay[4982] = 1000000012819139717237643058; + bpsToRay[4983] = 1000000012821256172595698271; + bpsToRay[4984] = 1000000012823372486701356345; + bpsToRay[4985] = 1000000012825488659573470415; + bpsToRay[4986] = 1000000012827604691230889842; + bpsToRay[4987] = 1000000012829720581692460212; + bpsToRay[4988] = 1000000012831836330977023339; + bpsToRay[4989] = 1000000012833951939103417266; + bpsToRay[4990] = 1000000012836067406090476267; + bpsToRay[4991] = 1000000012838182731957030847; + bpsToRay[4992] = 1000000012840297916721907738; + bpsToRay[4993] = 1000000012842412960403929910; + bpsToRay[4994] = 1000000012844527863021916565; + bpsToRay[4995] = 1000000012846642624594683140; + bpsToRay[4996] = 1000000012848757245141041307; + bpsToRay[4997] = 1000000012850871724679798976; + bpsToRay[4998] = 1000000012852986063229760294; + bpsToRay[4999] = 1000000012855100260809725646; + bpsToRay[5000] = 1000000012857214317438491659; + bpsToRay[5001] = 1000000012859328233134851198; + bpsToRay[5002] = 1000000012861442007917593374; + bpsToRay[5003] = 1000000012863555641805503536; + bpsToRay[5004] = 1000000012865669134817363279; + bpsToRay[5005] = 1000000012867782486971950443; + bpsToRay[5006] = 1000000012869895698288039115; + bpsToRay[5007] = 1000000012872008768784399625; + bpsToRay[5008] = 1000000012874121698479798555; + bpsToRay[5009] = 1000000012876234487392998733; + bpsToRay[5010] = 1000000012878347135542759238; + bpsToRay[5011] = 1000000012880459642947835401; + bpsToRay[5012] = 1000000012882572009626978801; + bpsToRay[5013] = 1000000012884684235598937274; + bpsToRay[5014] = 1000000012886796320882454907; + bpsToRay[5015] = 1000000012888908265496272044; + bpsToRay[5016] = 1000000012891020069459125282; + bpsToRay[5017] = 1000000012893131732789747478; + bpsToRay[5018] = 1000000012895243255506867744; + bpsToRay[5019] = 1000000012897354637629211454; + bpsToRay[5020] = 1000000012899465879175500237; + bpsToRay[5021] = 1000000012901576980164451988; + bpsToRay[5022] = 1000000012903687940614780860; + bpsToRay[5023] = 1000000012905798760545197270; + bpsToRay[5024] = 1000000012907909439974407900; + bpsToRay[5025] = 1000000012910019978921115695; + bpsToRay[5026] = 1000000012912130377404019867; + bpsToRay[5027] = 1000000012914240635441815894; + bpsToRay[5028] = 1000000012916350753053195521; + bpsToRay[5029] = 1000000012918460730256846763; + bpsToRay[5030] = 1000000012920570567071453907; + bpsToRay[5031] = 1000000012922680263515697504; + bpsToRay[5032] = 1000000012924789819608254383; + bpsToRay[5033] = 1000000012926899235367797644; + bpsToRay[5034] = 1000000012929008510812996659; + bpsToRay[5035] = 1000000012931117645962517078; + bpsToRay[5036] = 1000000012933226640835020822; + bpsToRay[5037] = 1000000012935335495449166093; + bpsToRay[5038] = 1000000012937444209823607369; + bpsToRay[5039] = 1000000012939552783976995406; + bpsToRay[5040] = 1000000012941661217927977241; + bpsToRay[5041] = 1000000012943769511695196190; + bpsToRay[5042] = 1000000012945877665297291852; + bpsToRay[5043] = 1000000012947985678752900108; + bpsToRay[5044] = 1000000012950093552080653122; + bpsToRay[5045] = 1000000012952201285299179347; + bpsToRay[5046] = 1000000012954308878427103514; + bpsToRay[5047] = 1000000012956416331483046645; + bpsToRay[5048] = 1000000012958523644485626051; + bpsToRay[5049] = 1000000012960630817453455327; + bpsToRay[5050] = 1000000012962737850405144363; + bpsToRay[5051] = 1000000012964844743359299334; + bpsToRay[5052] = 1000000012966951496334522711; + bpsToRay[5053] = 1000000012969058109349413254; + bpsToRay[5054] = 1000000012971164582422566020; + bpsToRay[5055] = 1000000012973270915572572357; + bpsToRay[5056] = 1000000012975377108818019910; + bpsToRay[5057] = 1000000012977483162177492621; + bpsToRay[5058] = 1000000012979589075669570729; + bpsToRay[5059] = 1000000012981694849312830772; + bpsToRay[5060] = 1000000012983800483125845583; + bpsToRay[5061] = 1000000012985905977127184302; + bpsToRay[5062] = 1000000012988011331335412367; + bpsToRay[5063] = 1000000012990116545769091518; + bpsToRay[5064] = 1000000012992221620446779799; + bpsToRay[5065] = 1000000012994326555387031557; + bpsToRay[5066] = 1000000012996431350608397447; + bpsToRay[5067] = 1000000012998536006129424429; + bpsToRay[5068] = 1000000013000640521968655768; + bpsToRay[5069] = 1000000013002744898144631040; + bpsToRay[5070] = 1000000013004849134675886130; + bpsToRay[5071] = 1000000013006953231580953231; + bpsToRay[5072] = 1000000013009057188878360849; + bpsToRay[5073] = 1000000013011161006586633804; + bpsToRay[5074] = 1000000013013264684724293223; + bpsToRay[5075] = 1000000013015368223309856554; + bpsToRay[5076] = 1000000013017471622361837555; + bpsToRay[5077] = 1000000013019574881898746303; + bpsToRay[5078] = 1000000013021678001939089190; + bpsToRay[5079] = 1000000013023780982501368928; + bpsToRay[5080] = 1000000013025883823604084547; + bpsToRay[5081] = 1000000013027986525265731396; + bpsToRay[5082] = 1000000013030089087504801146; + bpsToRay[5083] = 1000000013032191510339781792; + bpsToRay[5084] = 1000000013034293793789157646; + bpsToRay[5085] = 1000000013036395937871409348; + bpsToRay[5086] = 1000000013038497942605013865; + bpsToRay[5087] = 1000000013040599808008444486; + bpsToRay[5088] = 1000000013042701534100170826; + bpsToRay[5089] = 1000000013044803120898658830; + bpsToRay[5090] = 1000000013046904568422370773; + bpsToRay[5091] = 1000000013049005876689765257; + bpsToRay[5092] = 1000000013051107045719297215; + bpsToRay[5093] = 1000000013053208075529417914; + bpsToRay[5094] = 1000000013055308966138574949; + bpsToRay[5095] = 1000000013057409717565212254; + bpsToRay[5096] = 1000000013059510329827770095; + bpsToRay[5097] = 1000000013061610802944685072; + bpsToRay[5098] = 1000000013063711136934390123; + bpsToRay[5099] = 1000000013065811331815314524; + bpsToRay[5100] = 1000000013067911387605883890; + bpsToRay[5101] = 1000000013070011304324520173; + bpsToRay[5102] = 1000000013072111081989641667; + bpsToRay[5103] = 1000000013074210720619663007; + bpsToRay[5104] = 1000000013076310220232995171; + bpsToRay[5105] = 1000000013078409580848045479; + bpsToRay[5106] = 1000000013080508802483217595; + bpsToRay[5107] = 1000000013082607885156911531; + bpsToRay[5108] = 1000000013084706828887523642; + bpsToRay[5109] = 1000000013086805633693446631; + bpsToRay[5110] = 1000000013088904299593069551; + bpsToRay[5111] = 1000000013091002826604777801; + bpsToRay[5112] = 1000000013093101214746953133; + bpsToRay[5113] = 1000000013095199464037973648; + bpsToRay[5114] = 1000000013097297574496213800; + bpsToRay[5115] = 1000000013099395546140044395; + bpsToRay[5116] = 1000000013101493378987832595; + bpsToRay[5117] = 1000000013103591073057941913; + bpsToRay[5118] = 1000000013105688628368732223; + bpsToRay[5119] = 1000000013107786044938559751; + bpsToRay[5120] = 1000000013109883322785777084; + bpsToRay[5121] = 1000000013111980461928733165; + bpsToRay[5122] = 1000000013114077462385773300; + bpsToRay[5123] = 1000000013116174324175239154; + bpsToRay[5124] = 1000000013118271047315468752; + bpsToRay[5125] = 1000000013120367631824796485; + bpsToRay[5126] = 1000000013122464077721553103; + bpsToRay[5127] = 1000000013124560385024065726; + bpsToRay[5128] = 1000000013126656553750657835; + bpsToRay[5129] = 1000000013128752583919649280; + bpsToRay[5130] = 1000000013130848475549356277; + bpsToRay[5131] = 1000000013132944228658091410; + bpsToRay[5132] = 1000000013135039843264163635; + bpsToRay[5133] = 1000000013137135319385878275; + bpsToRay[5134] = 1000000013139230657041537026; + bpsToRay[5135] = 1000000013141325856249437956; + bpsToRay[5136] = 1000000013143420917027875507; + bpsToRay[5137] = 1000000013145515839395140491; + bpsToRay[5138] = 1000000013147610623369520102; + bpsToRay[5139] = 1000000013149705268969297904; + bpsToRay[5140] = 1000000013151799776212753840; + bpsToRay[5141] = 1000000013153894145118164231; + bpsToRay[5142] = 1000000013155988375703801779; + bpsToRay[5143] = 1000000013158082467987935562; + bpsToRay[5144] = 1000000013160176421988831041; + bpsToRay[5145] = 1000000013162270237724750059; + bpsToRay[5146] = 1000000013164363915213950840; + bpsToRay[5147] = 1000000013166457454474687994; + bpsToRay[5148] = 1000000013168550855525212514; + bpsToRay[5149] = 1000000013170644118383771778; + bpsToRay[5150] = 1000000013172737243068609553; + bpsToRay[5151] = 1000000013174830229597965992; + bpsToRay[5152] = 1000000013176923077990077635; + bpsToRay[5153] = 1000000013179015788263177415; + bpsToRay[5154] = 1000000013181108360435494653; + bpsToRay[5155] = 1000000013183200794525255059; + bpsToRay[5156] = 1000000013185293090550680741; + bpsToRay[5157] = 1000000013187385248529990196; + bpsToRay[5158] = 1000000013189477268481398315; + bpsToRay[5159] = 1000000013191569150423116386; + bpsToRay[5160] = 1000000013193660894373352093; + bpsToRay[5161] = 1000000013195752500350309515; + bpsToRay[5162] = 1000000013197843968372189132; + bpsToRay[5163] = 1000000013199935298457187821; + bpsToRay[5164] = 1000000013202026490623498857; + bpsToRay[5165] = 1000000013204117544889311921; + bpsToRay[5166] = 1000000013206208461272813091; + bpsToRay[5167] = 1000000013208299239792184850; + bpsToRay[5168] = 1000000013210389880465606084; + bpsToRay[5169] = 1000000013212480383311252082; + bpsToRay[5170] = 1000000013214570748347294544; + bpsToRay[5171] = 1000000013216660975591901569; + bpsToRay[5172] = 1000000013218751065063237670; + bpsToRay[5173] = 1000000013220841016779463763; + bpsToRay[5174] = 1000000013222930830758737177; + bpsToRay[5175] = 1000000013225020507019211652; + bpsToRay[5176] = 1000000013227110045579037336; + bpsToRay[5177] = 1000000013229199446456360791; + bpsToRay[5178] = 1000000013231288709669324991; + bpsToRay[5179] = 1000000013233377835236069326; + bpsToRay[5180] = 1000000013235466823174729599; + bpsToRay[5181] = 1000000013237555673503438031; + bpsToRay[5182] = 1000000013239644386240323257; + bpsToRay[5183] = 1000000013241732961403510334; + bpsToRay[5184] = 1000000013243821399011120734; + bpsToRay[5185] = 1000000013245909699081272350; + bpsToRay[5186] = 1000000013247997861632079496; + bpsToRay[5187] = 1000000013250085886681652909; + bpsToRay[5188] = 1000000013252173774248099746; + bpsToRay[5189] = 1000000013254261524349523588; + bpsToRay[5190] = 1000000013256349137004024442; + bpsToRay[5191] = 1000000013258436612229698739; + bpsToRay[5192] = 1000000013260523950044639336; + bpsToRay[5193] = 1000000013262611150466935520; + bpsToRay[5194] = 1000000013264698213514673002; + bpsToRay[5195] = 1000000013266785139205933927; + bpsToRay[5196] = 1000000013268871927558796866; + bpsToRay[5197] = 1000000013270958578591336822; + bpsToRay[5198] = 1000000013273045092321625231; + bpsToRay[5199] = 1000000013275131468767729963; + bpsToRay[5200] = 1000000013277217707947715318; + bpsToRay[5201] = 1000000013279303809879642035; + bpsToRay[5202] = 1000000013281389774581567286; + bpsToRay[5203] = 1000000013283475602071544681; + bpsToRay[5204] = 1000000013285561292367624266; + bpsToRay[5205] = 1000000013287646845487852528; + bpsToRay[5206] = 1000000013289732261450272392; + bpsToRay[5207] = 1000000013291817540272923222; + bpsToRay[5208] = 1000000013293902681973840827; + bpsToRay[5209] = 1000000013295987686571057456; + bpsToRay[5210] = 1000000013298072554082601799; + bpsToRay[5211] = 1000000013300157284526498996; + bpsToRay[5212] = 1000000013302241877920770626; + bpsToRay[5213] = 1000000013304326334283434719; + bpsToRay[5214] = 1000000013306410653632505749; + bpsToRay[5215] = 1000000013308494835985994637; + bpsToRay[5216] = 1000000013310578881361908756; + bpsToRay[5217] = 1000000013312662789778251927; + bpsToRay[5218] = 1000000013314746561253024422; + bpsToRay[5219] = 1000000013316830195804222964; + bpsToRay[5220] = 1000000013318913693449840730; + bpsToRay[5221] = 1000000013320997054207867349; + bpsToRay[5222] = 1000000013323080278096288904; + bpsToRay[5223] = 1000000013325163365133087937; + bpsToRay[5224] = 1000000013327246315336243441; + bpsToRay[5225] = 1000000013329329128723730871; + bpsToRay[5226] = 1000000013331411805313522137; + bpsToRay[5227] = 1000000013333494345123585609; + bpsToRay[5228] = 1000000013335576748171886118; + bpsToRay[5229] = 1000000013337659014476384955; + bpsToRay[5230] = 1000000013339741144055039872; + bpsToRay[5231] = 1000000013341823136925805086; + bpsToRay[5232] = 1000000013343904993106631276; + bpsToRay[5233] = 1000000013345986712615465587; + bpsToRay[5234] = 1000000013348068295470251626; + bpsToRay[5235] = 1000000013350149741688929473; + bpsToRay[5236] = 1000000013352231051289435670; + bpsToRay[5237] = 1000000013354312224289703229; + bpsToRay[5238] = 1000000013356393260707661631; + bpsToRay[5239] = 1000000013358474160561236828; + bpsToRay[5240] = 1000000013360554923868351244; + bpsToRay[5241] = 1000000013362635550646923773; + bpsToRay[5242] = 1000000013364716040914869783; + bpsToRay[5243] = 1000000013366796394690101115; + bpsToRay[5244] = 1000000013368876611990526086; + bpsToRay[5245] = 1000000013370956692834049490; + bpsToRay[5246] = 1000000013373036637238572595; + bpsToRay[5247] = 1000000013375116445221993147; + bpsToRay[5248] = 1000000013377196116802205372; + bpsToRay[5249] = 1000000013379275651997099976; + bpsToRay[5250] = 1000000013381355050824564143; + bpsToRay[5251] = 1000000013383434313302481540; + bpsToRay[5252] = 1000000013385513439448732314; + bpsToRay[5253] = 1000000013387592429281193100; + bpsToRay[5254] = 1000000013389671282817737012; + bpsToRay[5255] = 1000000013391750000076233652; + bpsToRay[5256] = 1000000013393828581074549107; + bpsToRay[5257] = 1000000013395907025830545951; + bpsToRay[5258] = 1000000013397985334362083244; + bpsToRay[5259] = 1000000013400063506687016538; + bpsToRay[5260] = 1000000013402141542823197873; + bpsToRay[5261] = 1000000013404219442788475779; + bpsToRay[5262] = 1000000013406297206600695278; + bpsToRay[5263] = 1000000013408374834277697885; + bpsToRay[5264] = 1000000013410452325837321606; + bpsToRay[5265] = 1000000013412529681297400945; + bpsToRay[5266] = 1000000013414606900675766898; + bpsToRay[5267] = 1000000013416683983990246957; + bpsToRay[5268] = 1000000013418760931258665113; + bpsToRay[5269] = 1000000013420837742498841855; + bpsToRay[5270] = 1000000013422914417728594168; + bpsToRay[5271] = 1000000013424990956965735539; + bpsToRay[5272] = 1000000013427067360228075956; + bpsToRay[5273] = 1000000013429143627533421906; + bpsToRay[5274] = 1000000013431219758899576381; + bpsToRay[5275] = 1000000013433295754344338876; + bpsToRay[5276] = 1000000013435371613885505389; + bpsToRay[5277] = 1000000013437447337540868424; + bpsToRay[5278] = 1000000013439522925328216993; + bpsToRay[5279] = 1000000013441598377265336611; + bpsToRay[5280] = 1000000013443673693370009304; + bpsToRay[5281] = 1000000013445748873660013605; + bpsToRay[5282] = 1000000013447823918153124560; + bpsToRay[5283] = 1000000013449898826867113722; + bpsToRay[5284] = 1000000013451973599819749157; + bpsToRay[5285] = 1000000013454048237028795446; + bpsToRay[5286] = 1000000013456122738512013678; + bpsToRay[5287] = 1000000013458197104287161462; + bpsToRay[5288] = 1000000013460271334371992918; + bpsToRay[5289] = 1000000013462345428784258685; + bpsToRay[5290] = 1000000013464419387541705919; + bpsToRay[5291] = 1000000013466493210662078291; + bpsToRay[5292] = 1000000013468566898163115994; + bpsToRay[5293] = 1000000013470640450062555739; + bpsToRay[5294] = 1000000013472713866378130761; + bpsToRay[5295] = 1000000013474787147127570811; + bpsToRay[5296] = 1000000013476860292328602168; + bpsToRay[5297] = 1000000013478933301998947631; + bpsToRay[5298] = 1000000013481006176156326525; + bpsToRay[5299] = 1000000013483078914818454700; + bpsToRay[5300] = 1000000013485151518003044532; + bpsToRay[5301] = 1000000013487223985727804923; + bpsToRay[5302] = 1000000013489296318010441307; + bpsToRay[5303] = 1000000013491368514868655641; + bpsToRay[5304] = 1000000013493440576320146417; + bpsToRay[5305] = 1000000013495512502382608654; + bpsToRay[5306] = 1000000013497584293073733906; + bpsToRay[5307] = 1000000013499655948411210256; + bpsToRay[5308] = 1000000013501727468412722324; + bpsToRay[5309] = 1000000013503798853095951261; + bpsToRay[5310] = 1000000013505870102478574756; + bpsToRay[5311] = 1000000013507941216578267032; + bpsToRay[5312] = 1000000013510012195412698851; + bpsToRay[5313] = 1000000013512083038999537512; + bpsToRay[5314] = 1000000013514153747356446852; + bpsToRay[5315] = 1000000013516224320501087249; + bpsToRay[5316] = 1000000013518294758451115623; + bpsToRay[5317] = 1000000013520365061224185433; + bpsToRay[5318] = 1000000013522435228837946681; + bpsToRay[5319] = 1000000013524505261310045913; + bpsToRay[5320] = 1000000013526575158658126219; + bpsToRay[5321] = 1000000013528644920899827235; + bpsToRay[5322] = 1000000013530714548052785142; + bpsToRay[5323] = 1000000013532784040134632670; + bpsToRay[5324] = 1000000013534853397162999093; + bpsToRay[5325] = 1000000013536922619155510237; + bpsToRay[5326] = 1000000013538991706129788478; + bpsToRay[5327] = 1000000013541060658103452740; + bpsToRay[5328] = 1000000013543129475094118502; + bpsToRay[5329] = 1000000013545198157119397791; + bpsToRay[5330] = 1000000013547266704196899191; + bpsToRay[5331] = 1000000013549335116344227839; + bpsToRay[5332] = 1000000013551403393578985427; + bpsToRay[5333] = 1000000013553471535918770203; + bpsToRay[5334] = 1000000013555539543381176971; + bpsToRay[5335] = 1000000013557607415983797096; + bpsToRay[5336] = 1000000013559675153744218497; + bpsToRay[5337] = 1000000013561742756680025656; + bpsToRay[5338] = 1000000013563810224808799615; + bpsToRay[5339] = 1000000013565877558148117977; + bpsToRay[5340] = 1000000013567944756715554906; + bpsToRay[5341] = 1000000013570011820528681131; + bpsToRay[5342] = 1000000013572078749605063945; + bpsToRay[5343] = 1000000013574145543962267205; + bpsToRay[5344] = 1000000013576212203617851334; + bpsToRay[5345] = 1000000013578278728589373323; + bpsToRay[5346] = 1000000013580345118894386729; + bpsToRay[5347] = 1000000013582411374550441678; + bpsToRay[5348] = 1000000013584477495575084867; + bpsToRay[5349] = 1000000013586543481985859560; + bpsToRay[5350] = 1000000013588609333800305597; + bpsToRay[5351] = 1000000013590675051035959386; + bpsToRay[5352] = 1000000013592740633710353909; + bpsToRay[5353] = 1000000013594806081841018723; + bpsToRay[5354] = 1000000013596871395445479960; + bpsToRay[5355] = 1000000013598936574541260325; + bpsToRay[5356] = 1000000013601001619145879103; + bpsToRay[5357] = 1000000013603066529276852154; + bpsToRay[5358] = 1000000013605131304951691920; + bpsToRay[5359] = 1000000013607195946187907415; + bpsToRay[5360] = 1000000013609260453003004241; + bpsToRay[5361] = 1000000013611324825414484577; + bpsToRay[5362] = 1000000013613389063439847186; + bpsToRay[5363] = 1000000013615453167096587411; + bpsToRay[5364] = 1000000013617517136402197181; + bpsToRay[5365] = 1000000013619580971374165008; + bpsToRay[5366] = 1000000013621644672029975992; + bpsToRay[5367] = 1000000013623708238387111817; + bpsToRay[5368] = 1000000013625771670463050755; + bpsToRay[5369] = 1000000013627834968275267666; + bpsToRay[5370] = 1000000013629898131841234000; + bpsToRay[5371] = 1000000013631961161178417796; + bpsToRay[5372] = 1000000013634024056304283684; + bpsToRay[5373] = 1000000013636086817236292885; + bpsToRay[5374] = 1000000013638149443991903215; + bpsToRay[5375] = 1000000013640211936588569081; + bpsToRay[5376] = 1000000013642274295043741485; + bpsToRay[5377] = 1000000013644336519374868025; + bpsToRay[5378] = 1000000013646398609599392894; + bpsToRay[5379] = 1000000013648460565734756883; + bpsToRay[5380] = 1000000013650522387798397382; + bpsToRay[5381] = 1000000013652584075807748376; + bpsToRay[5382] = 1000000013654645629780240453; + bpsToRay[5383] = 1000000013656707049733300801; + bpsToRay[5384] = 1000000013658768335684353209; + bpsToRay[5385] = 1000000013660829487650818068; + bpsToRay[5386] = 1000000013662890505650112373; + bpsToRay[5387] = 1000000013664951389699649722; + bpsToRay[5388] = 1000000013667012139816840321; + bpsToRay[5389] = 1000000013669072756019090977; + bpsToRay[5390] = 1000000013671133238323805108; + bpsToRay[5391] = 1000000013673193586748382737; + bpsToRay[5392] = 1000000013675253801310220496; + bpsToRay[5393] = 1000000013677313882026711628; + bpsToRay[5394] = 1000000013679373828915245986; + bpsToRay[5395] = 1000000013681433641993210032; + bpsToRay[5396] = 1000000013683493321277986841; + bpsToRay[5397] = 1000000013685552866786956102; + bpsToRay[5398] = 1000000013687612278537494116; + bpsToRay[5399] = 1000000013689671556546973802; + bpsToRay[5400] = 1000000013691730700832764691; + bpsToRay[5401] = 1000000013693789711412232932; + bpsToRay[5402] = 1000000013695848588302741289; + bpsToRay[5403] = 1000000013697907331521649149; + bpsToRay[5404] = 1000000013699965941086312515; + bpsToRay[5405] = 1000000013702024417014084009; + bpsToRay[5406] = 1000000013704082759322312876; + bpsToRay[5407] = 1000000013706140968028344981; + bpsToRay[5408] = 1000000013708199043149522812; + bpsToRay[5409] = 1000000013710256984703185483; + bpsToRay[5410] = 1000000013712314792706668728; + bpsToRay[5411] = 1000000013714372467177304910; + bpsToRay[5412] = 1000000013716430008132423015; + bpsToRay[5413] = 1000000013718487415589348659; + bpsToRay[5414] = 1000000013720544689565404082; + bpsToRay[5415] = 1000000013722601830077908157; + bpsToRay[5416] = 1000000013724658837144176384; + bpsToRay[5417] = 1000000013726715710781520893; + bpsToRay[5418] = 1000000013728772451007250448; + bpsToRay[5419] = 1000000013730829057838670442; + bpsToRay[5420] = 1000000013732885531293082904; + bpsToRay[5421] = 1000000013734941871387786495; + bpsToRay[5422] = 1000000013736998078140076511; + bpsToRay[5423] = 1000000013739054151567244885; + bpsToRay[5424] = 1000000013741110091686580185; + bpsToRay[5425] = 1000000013743165898515367617; + bpsToRay[5426] = 1000000013745221572070889027; + bpsToRay[5427] = 1000000013747277112370422896; + bpsToRay[5428] = 1000000013749332519431244349; + bpsToRay[5429] = 1000000013751387793270625152; + bpsToRay[5430] = 1000000013753442933905833710; + bpsToRay[5431] = 1000000013755497941354135072; + bpsToRay[5432] = 1000000013757552815632790932; + bpsToRay[5433] = 1000000013759607556759059626; + bpsToRay[5434] = 1000000013761662164750196136; + bpsToRay[5435] = 1000000013763716639623452091; + bpsToRay[5436] = 1000000013765770981396075767; + bpsToRay[5437] = 1000000013767825190085312088; + bpsToRay[5438] = 1000000013769879265708402624; + bpsToRay[5439] = 1000000013771933208282585599; + bpsToRay[5440] = 1000000013773987017825095883; + bpsToRay[5441] = 1000000013776040694353165002; + bpsToRay[5442] = 1000000013778094237884021131; + bpsToRay[5443] = 1000000013780147648434889099; + bpsToRay[5444] = 1000000013782200926022990388; + bpsToRay[5445] = 1000000013784254070665543138; + bpsToRay[5446] = 1000000013786307082379762141; + bpsToRay[5447] = 1000000013788359961182858847; + bpsToRay[5448] = 1000000013790412707092041364; + bpsToRay[5449] = 1000000013792465320124514458; + bpsToRay[5450] = 1000000013794517800297479554; + bpsToRay[5451] = 1000000013796570147628134736; + bpsToRay[5452] = 1000000013798622362133674751; + bpsToRay[5453] = 1000000013800674443831291006; + bpsToRay[5454] = 1000000013802726392738171571; + bpsToRay[5455] = 1000000013804778208871501181; + bpsToRay[5456] = 1000000013806829892248461232; + bpsToRay[5457] = 1000000013808881442886229789; + bpsToRay[5458] = 1000000013810932860801981581; + bpsToRay[5459] = 1000000013812984146012888004; + bpsToRay[5460] = 1000000013815035298536117122; + bpsToRay[5461] = 1000000013817086318388833668; + bpsToRay[5462] = 1000000013819137205588199044; + bpsToRay[5463] = 1000000013821187960151371324; + bpsToRay[5464] = 1000000013823238582095505250; + bpsToRay[5465] = 1000000013825289071437752239; + bpsToRay[5466] = 1000000013827339428195260380; + bpsToRay[5467] = 1000000013829389652385174435; + bpsToRay[5468] = 1000000013831439744024635842; + bpsToRay[5469] = 1000000013833489703130782714; + bpsToRay[5470] = 1000000013835539529720749841; + bpsToRay[5471] = 1000000013837589223811668689; + bpsToRay[5472] = 1000000013839638785420667403; + bpsToRay[5473] = 1000000013841688214564870807; + bpsToRay[5474] = 1000000013843737511261400404; + bpsToRay[5475] = 1000000013845786675527374380; + bpsToRay[5476] = 1000000013847835707379907599; + bpsToRay[5477] = 1000000013849884606836111609; + bpsToRay[5478] = 1000000013851933373913094644; + bpsToRay[5479] = 1000000013853982008627961619; + bpsToRay[5480] = 1000000013856030510997814133; + bpsToRay[5481] = 1000000013858078881039750473; + bpsToRay[5482] = 1000000013860127118770865614; + bpsToRay[5483] = 1000000013862175224208251215; + bpsToRay[5484] = 1000000013864223197368995626; + bpsToRay[5485] = 1000000013866271038270183886; + bpsToRay[5486] = 1000000013868318746928897723; + bpsToRay[5487] = 1000000013870366323362215556; + bpsToRay[5488] = 1000000013872413767587212497; + bpsToRay[5489] = 1000000013874461079620960351; + bpsToRay[5490] = 1000000013876508259480527614; + bpsToRay[5491] = 1000000013878555307182979479; + bpsToRay[5492] = 1000000013880602222745377833; + bpsToRay[5493] = 1000000013882649006184781260; + bpsToRay[5494] = 1000000013884695657518245039; + bpsToRay[5495] = 1000000013886742176762821150; + bpsToRay[5496] = 1000000013888788563935558267; + bpsToRay[5497] = 1000000013890834819053501770; + bpsToRay[5498] = 1000000013892880942133693733; + bpsToRay[5499] = 1000000013894926933193172935; + bpsToRay[5500] = 1000000013896972792248974855; + bpsToRay[5501] = 1000000013899018519318131677; + bpsToRay[5502] = 1000000013901064114417672287; + bpsToRay[5503] = 1000000013903109577564622276; + bpsToRay[5504] = 1000000013905154908776003941; + bpsToRay[5505] = 1000000013907200108068836286; + bpsToRay[5506] = 1000000013909245175460135020; + bpsToRay[5507] = 1000000013911290110966912561; + bpsToRay[5508] = 1000000013913334914606178038; + bpsToRay[5509] = 1000000013915379586394937285; + bpsToRay[5510] = 1000000013917424126350192852; + bpsToRay[5511] = 1000000013919468534488943996; + bpsToRay[5512] = 1000000013921512810828186689; + bpsToRay[5513] = 1000000013923556955384913616; + bpsToRay[5514] = 1000000013925600968176114173; + bpsToRay[5515] = 1000000013927644849218774474; + bpsToRay[5516] = 1000000013929688598529877347; + bpsToRay[5517] = 1000000013931732216126402338; + bpsToRay[5518] = 1000000013933775702025325709; + bpsToRay[5519] = 1000000013935819056243620441; + bpsToRay[5520] = 1000000013937862278798256232; + bpsToRay[5521] = 1000000013939905369706199504; + bpsToRay[5522] = 1000000013941948328984413395; + bpsToRay[5523] = 1000000013943991156649857768; + bpsToRay[5524] = 1000000013946033852719489207; + bpsToRay[5525] = 1000000013948076417210261020; + bpsToRay[5526] = 1000000013950118850139123237; + bpsToRay[5527] = 1000000013952161151523022616; + bpsToRay[5528] = 1000000013954203321378902639; + bpsToRay[5529] = 1000000013956245359723703515; + bpsToRay[5530] = 1000000013958287266574362180; + bpsToRay[5531] = 1000000013960329041947812299; + bpsToRay[5532] = 1000000013962370685860984266; + bpsToRay[5533] = 1000000013964412198330805204; + bpsToRay[5534] = 1000000013966453579374198970; + bpsToRay[5535] = 1000000013968494829008086149; + bpsToRay[5536] = 1000000013970535947249384059; + bpsToRay[5537] = 1000000013972576934115006754; + bpsToRay[5538] = 1000000013974617789621865021; + bpsToRay[5539] = 1000000013976658513786866380; + bpsToRay[5540] = 1000000013978699106626915089; + bpsToRay[5541] = 1000000013980739568158912143; + bpsToRay[5542] = 1000000013982779898399755273; + bpsToRay[5543] = 1000000013984820097366338950; + bpsToRay[5544] = 1000000013986860165075554382; + bpsToRay[5545] = 1000000013988900101544289521; + bpsToRay[5546] = 1000000013990939906789429055; + bpsToRay[5547] = 1000000013992979580827854418; + bpsToRay[5548] = 1000000013995019123676443785; + bpsToRay[5549] = 1000000013997058535352072073; + bpsToRay[5550] = 1000000013999097815871610946; + bpsToRay[5551] = 1000000014001136965251928811; + bpsToRay[5552] = 1000000014003175983509890823; + bpsToRay[5553] = 1000000014005214870662358881; + bpsToRay[5554] = 1000000014007253626726191632; + bpsToRay[5555] = 1000000014009292251718244476; + bpsToRay[5556] = 1000000014011330745655369557; + bpsToRay[5557] = 1000000014013369108554415771; + bpsToRay[5558] = 1000000014015407340432228765; + bpsToRay[5559] = 1000000014017445441305650938; + bpsToRay[5560] = 1000000014019483411191521442; + bpsToRay[5561] = 1000000014021521250106676181; + bpsToRay[5562] = 1000000014023558958067947815; + bpsToRay[5563] = 1000000014025596535092165759; + bpsToRay[5564] = 1000000014027633981196156184; + bpsToRay[5565] = 1000000014029671296396742013; + bpsToRay[5566] = 1000000014031708480710742936; + bpsToRay[5567] = 1000000014033745534154975394; + bpsToRay[5568] = 1000000014035782456746252590; + bpsToRay[5569] = 1000000014037819248501384486; + bpsToRay[5570] = 1000000014039855909437177808; + bpsToRay[5571] = 1000000014041892439570436040; + bpsToRay[5572] = 1000000014043928838917959430; + bpsToRay[5573] = 1000000014045965107496544991; + bpsToRay[5574] = 1000000014048001245322986499; + bpsToRay[5575] = 1000000014050037252414074493; + bpsToRay[5576] = 1000000014052073128786596283; + bpsToRay[5577] = 1000000014054108874457335942; + bpsToRay[5578] = 1000000014056144489443074311; + bpsToRay[5579] = 1000000014058179973760589001; + bpsToRay[5580] = 1000000014060215327426654391; + bpsToRay[5581] = 1000000014062250550458041631; + bpsToRay[5582] = 1000000014064285642871518639; + bpsToRay[5583] = 1000000014066320604683850111; + bpsToRay[5584] = 1000000014068355435911797509; + bpsToRay[5585] = 1000000014070390136572119073; + bpsToRay[5586] = 1000000014072424706681569814; + bpsToRay[5587] = 1000000014074459146256901521; + bpsToRay[5588] = 1000000014076493455314862758; + bpsToRay[5589] = 1000000014078527633872198862; + bpsToRay[5590] = 1000000014080561681945651954; + bpsToRay[5591] = 1000000014082595599551960930; + bpsToRay[5592] = 1000000014084629386707861464; + bpsToRay[5593] = 1000000014086663043430086012; + bpsToRay[5594] = 1000000014088696569735363811; + bpsToRay[5595] = 1000000014090729965640420880; + bpsToRay[5596] = 1000000014092763231161980018; + bpsToRay[5597] = 1000000014094796366316760809; + bpsToRay[5598] = 1000000014096829371121479623; + bpsToRay[5599] = 1000000014098862245592849610; + bpsToRay[5600] = 1000000014100894989747580713; + bpsToRay[5601] = 1000000014102927603602379655; + bpsToRay[5602] = 1000000014104960087173949949; + bpsToRay[5603] = 1000000014106992440478991899; + bpsToRay[5604] = 1000000014109024663534202592; + bpsToRay[5605] = 1000000014111056756356275911; + bpsToRay[5606] = 1000000014113088718961902527; + bpsToRay[5607] = 1000000014115120551367769903; + bpsToRay[5608] = 1000000014117152253590562293; + bpsToRay[5609] = 1000000014119183825646960746; + bpsToRay[5610] = 1000000014121215267553643106; + bpsToRay[5611] = 1000000014123246579327284009; + bpsToRay[5612] = 1000000014125277760984554889; + bpsToRay[5613] = 1000000014127308812542123975; + bpsToRay[5614] = 1000000014129339734016656294; + bpsToRay[5615] = 1000000014131370525424813672; + bpsToRay[5616] = 1000000014133401186783254733; + bpsToRay[5617] = 1000000014135431718108634901; + bpsToRay[5618] = 1000000014137462119417606400; + bpsToRay[5619] = 1000000014139492390726818256; + bpsToRay[5620] = 1000000014141522532052916298; + bpsToRay[5621] = 1000000014143552543412543158; + bpsToRay[5622] = 1000000014145582424822338270; + bpsToRay[5623] = 1000000014147612176298937873; + bpsToRay[5624] = 1000000014149641797858975016; + bpsToRay[5625] = 1000000014151671289519079548; + bpsToRay[5626] = 1000000014153700651295878130; + bpsToRay[5627] = 1000000014155729883205994226; + bpsToRay[5628] = 1000000014157758985266048116; + bpsToRay[5629] = 1000000014159787957492656883; + bpsToRay[5630] = 1000000014161816799902434423; + bpsToRay[5631] = 1000000014163845512511991443; + bpsToRay[5632] = 1000000014165874095337935463; + bpsToRay[5633] = 1000000014167902548396870816; + bpsToRay[5634] = 1000000014169930871705398646; + bpsToRay[5635] = 1000000014171959065280116914; + bpsToRay[5636] = 1000000014173987129137620396; + bpsToRay[5637] = 1000000014176015063294500683; + bpsToRay[5638] = 1000000014178042867767346186; + bpsToRay[5639] = 1000000014180070542572742128; + bpsToRay[5640] = 1000000014182098087727270558; + bpsToRay[5641] = 1000000014184125503247510337; + bpsToRay[5642] = 1000000014186152789150037153; + bpsToRay[5643] = 1000000014188179945451423510; + bpsToRay[5644] = 1000000014190206972168238736; + bpsToRay[5645] = 1000000014192233869317048980; + bpsToRay[5646] = 1000000014194260636914417219; + bpsToRay[5647] = 1000000014196287274976903248; + bpsToRay[5648] = 1000000014198313783521063691; + bpsToRay[5649] = 1000000014200340162563451997; + bpsToRay[5650] = 1000000014202366412120618444; + bpsToRay[5651] = 1000000014204392532209110132; + bpsToRay[5652] = 1000000014206418522845470993; + bpsToRay[5653] = 1000000014208444384046241790; + bpsToRay[5654] = 1000000014210470115827960111; + bpsToRay[5655] = 1000000014212495718207160381; + bpsToRay[5656] = 1000000014214521191200373850; + bpsToRay[5657] = 1000000014216546534824128603; + bpsToRay[5658] = 1000000014218571749094949561; + bpsToRay[5659] = 1000000014220596834029358476; + bpsToRay[5660] = 1000000014222621789643873935; + bpsToRay[5661] = 1000000014224646615955011361; + bpsToRay[5662] = 1000000014226671312979283014; + bpsToRay[5663] = 1000000014228695880733197990; + bpsToRay[5664] = 1000000014230720319233262225; + bpsToRay[5665] = 1000000014232744628495978491; + bpsToRay[5666] = 1000000014234768808537846403; + bpsToRay[5667] = 1000000014236792859375362413; + bpsToRay[5668] = 1000000014238816781025019818; + bpsToRay[5669] = 1000000014240840573503308754; + bpsToRay[5670] = 1000000014242864236826716200; + bpsToRay[5671] = 1000000014244887771011725981; + bpsToRay[5672] = 1000000014246911176074818766; + bpsToRay[5673] = 1000000014248934452032472066; + bpsToRay[5674] = 1000000014250957598901160243; + bpsToRay[5675] = 1000000014252980616697354502; + bpsToRay[5676] = 1000000014255003505437522899; + bpsToRay[5677] = 1000000014257026265138130334; + bpsToRay[5678] = 1000000014259048895815638562; + bpsToRay[5679] = 1000000014261071397486506182; + bpsToRay[5680] = 1000000014263093770167188651; + bpsToRay[5681] = 1000000014265116013874138270; + bpsToRay[5682] = 1000000014267138128623804199; + bpsToRay[5683] = 1000000014269160114432632448; + bpsToRay[5684] = 1000000014271181971317065881; + bpsToRay[5685] = 1000000014273203699293544220; + bpsToRay[5686] = 1000000014275225298378504039; + bpsToRay[5687] = 1000000014277246768588378769; + bpsToRay[5688] = 1000000014279268109939598702; + bpsToRay[5689] = 1000000014281289322448590984; + bpsToRay[5690] = 1000000014283310406131779623; + bpsToRay[5691] = 1000000014285331361005585484; + bpsToRay[5692] = 1000000014287352187086426294; + bpsToRay[5693] = 1000000014289372884390716643; + bpsToRay[5694] = 1000000014291393452934867978; + bpsToRay[5695] = 1000000014293413892735288616; + bpsToRay[5696] = 1000000014295434203808383731; + bpsToRay[5697] = 1000000014297454386170555368; + bpsToRay[5698] = 1000000014299474439838202432; + bpsToRay[5699] = 1000000014301494364827720695; + bpsToRay[5700] = 1000000014303514161155502800; + bpsToRay[5701] = 1000000014305533828837938253; + bpsToRay[5702] = 1000000014307553367891413431; + bpsToRay[5703] = 1000000014309572778332311579; + bpsToRay[5704] = 1000000014311592060177012815; + bpsToRay[5705] = 1000000014313611213441894123; + bpsToRay[5706] = 1000000014315630238143329364; + bpsToRay[5707] = 1000000014317649134297689268; + bpsToRay[5708] = 1000000014319667901921341438; + bpsToRay[5709] = 1000000014321686541030650356; + bpsToRay[5710] = 1000000014323705051641977373; + bpsToRay[5711] = 1000000014325723433771680719; + bpsToRay[5712] = 1000000014327741687436115500; + bpsToRay[5713] = 1000000014329759812651633698; + bpsToRay[5714] = 1000000014331777809434584175; + bpsToRay[5715] = 1000000014333795677801312670; + bpsToRay[5716] = 1000000014335813417768161804; + bpsToRay[5717] = 1000000014337831029351471077; + bpsToRay[5718] = 1000000014339848512567576870; + bpsToRay[5719] = 1000000014341865867432812447; + bpsToRay[5720] = 1000000014343883093963507953; + bpsToRay[5721] = 1000000014345900192175990420; + bpsToRay[5722] = 1000000014347917162086583762; + bpsToRay[5723] = 1000000014349934003711608778; + bpsToRay[5724] = 1000000014351950717067383155; + bpsToRay[5725] = 1000000014353967302170221464; + bpsToRay[5726] = 1000000014355983759036435166; + bpsToRay[5727] = 1000000014358000087682332611; + bpsToRay[5728] = 1000000014360016288124219035; + bpsToRay[5729] = 1000000014362032360378396567; + bpsToRay[5730] = 1000000014364048304461164225; + bpsToRay[5731] = 1000000014366064120388817920; + bpsToRay[5732] = 1000000014368079808177650454; + bpsToRay[5733] = 1000000014370095367843951523; + bpsToRay[5734] = 1000000014372110799404007716; + bpsToRay[5735] = 1000000014374126102874102518; + bpsToRay[5736] = 1000000014376141278270516310; + bpsToRay[5737] = 1000000014378156325609526367; + bpsToRay[5738] = 1000000014380171244907406862; + bpsToRay[5739] = 1000000014382186036180428868; + bpsToRay[5740] = 1000000014384200699444860352; + bpsToRay[5741] = 1000000014386215234716966187; + bpsToRay[5742] = 1000000014388229642013008140; + bpsToRay[5743] = 1000000014390243921349244884; + bpsToRay[5744] = 1000000014392258072741931989; + bpsToRay[5745] = 1000000014394272096207321932; + bpsToRay[5746] = 1000000014396285991761664091; + bpsToRay[5747] = 1000000014398299759421204750; + bpsToRay[5748] = 1000000014400313399202187095; + bpsToRay[5749] = 1000000014402326911120851219; + bpsToRay[5750] = 1000000014404340295193434124; + bpsToRay[5751] = 1000000014406353551436169717; + bpsToRay[5752] = 1000000014408366679865288813; + bpsToRay[5753] = 1000000014410379680497019136; + bpsToRay[5754] = 1000000014412392553347585321; + bpsToRay[5755] = 1000000014414405298433208913; + bpsToRay[5756] = 1000000014416417915770108367; + bpsToRay[5757] = 1000000014418430405374499050; + bpsToRay[5758] = 1000000014420442767262593245; + bpsToRay[5759] = 1000000014422455001450600144; + bpsToRay[5760] = 1000000014424467107954725858; + bpsToRay[5761] = 1000000014426479086791173409; + bpsToRay[5762] = 1000000014428490937976142739; + bpsToRay[5763] = 1000000014430502661525830703; + bpsToRay[5764] = 1000000014432514257456431075; + bpsToRay[5765] = 1000000014434525725784134548; + bpsToRay[5766] = 1000000014436537066525128734; + bpsToRay[5767] = 1000000014438548279695598164; + bpsToRay[5768] = 1000000014440559365311724289; + bpsToRay[5769] = 1000000014442570323389685485; + bpsToRay[5770] = 1000000014444581153945657045; + bpsToRay[5771] = 1000000014446591856995811191; + bpsToRay[5772] = 1000000014448602432556317062; + bpsToRay[5773] = 1000000014450612880643340727; + bpsToRay[5774] = 1000000014452623201273045178; + bpsToRay[5775] = 1000000014454633394461590334; + bpsToRay[5776] = 1000000014456643460225133039; + bpsToRay[5777] = 1000000014458653398579827068; + bpsToRay[5778] = 1000000014460663209541823120; + bpsToRay[5779] = 1000000014462672893127268829; + bpsToRay[5780] = 1000000014464682449352308754; + bpsToRay[5781] = 1000000014466691878233084386; + bpsToRay[5782] = 1000000014468701179785734150; + bpsToRay[5783] = 1000000014470710354026393400; + bpsToRay[5784] = 1000000014472719400971194424; + bpsToRay[5785] = 1000000014474728320636266446; + bpsToRay[5786] = 1000000014476737113037735623; + bpsToRay[5787] = 1000000014478745778191725047; + bpsToRay[5788] = 1000000014480754316114354747; + bpsToRay[5789] = 1000000014482762726821741689; + bpsToRay[5790] = 1000000014484771010329999776; + bpsToRay[5791] = 1000000014486779166655239853; + bpsToRay[5792] = 1000000014488787195813569697; + bpsToRay[5793] = 1000000014490795097821094034; + bpsToRay[5794] = 1000000014492802872693914523; + bpsToRay[5795] = 1000000014494810520448129771; + bpsToRay[5796] = 1000000014496818041099835323; + bpsToRay[5797] = 1000000014498825434665123670; + bpsToRay[5798] = 1000000014500832701160084244; + bpsToRay[5799] = 1000000014502839840600803425; + bpsToRay[5800] = 1000000014504846853003364537; + bpsToRay[5801] = 1000000014506853738383847849; + bpsToRay[5802] = 1000000014508860496758330582; + bpsToRay[5803] = 1000000014510867128142886896; + bpsToRay[5804] = 1000000014512873632553587910; + bpsToRay[5805] = 1000000014514880010006501685; + bpsToRay[5806] = 1000000014516886260517693233; + bpsToRay[5807] = 1000000014518892384103224522; + bpsToRay[5808] = 1000000014520898380779154465; + bpsToRay[5809] = 1000000014522904250561538932; + bpsToRay[5810] = 1000000014524909993466430745; + bpsToRay[5811] = 1000000014526915609509879680; + bpsToRay[5812] = 1000000014528921098707932466; + bpsToRay[5813] = 1000000014530926461076632791; + bpsToRay[5814] = 1000000014532931696632021298; + bpsToRay[5815] = 1000000014534936805390135584; + bpsToRay[5816] = 1000000014536941787367010209; + bpsToRay[5817] = 1000000014538946642578676689; + bpsToRay[5818] = 1000000014540951371041163498; + bpsToRay[5819] = 1000000014542955972770496074; + bpsToRay[5820] = 1000000014544960447782696812; + bpsToRay[5821] = 1000000014546964796093785070; + bpsToRay[5822] = 1000000014548969017719777170; + bpsToRay[5823] = 1000000014550973112676686396; + bpsToRay[5824] = 1000000014552977080980522997; + bpsToRay[5825] = 1000000014554980922647294184; + bpsToRay[5826] = 1000000014556984637693004137; + bpsToRay[5827] = 1000000014558988226133654001; + bpsToRay[5828] = 1000000014560991687985241886; + bpsToRay[5829] = 1000000014562995023263762875; + bpsToRay[5830] = 1000000014564998231985209012; + bpsToRay[5831] = 1000000014567001314165569320; + bpsToRay[5832] = 1000000014569004269820829782; + bpsToRay[5833] = 1000000014571007098966973360; + bpsToRay[5834] = 1000000014573009801619979984; + bpsToRay[5835] = 1000000014575012377795826556; + bpsToRay[5836] = 1000000014577014827510486953; + bpsToRay[5837] = 1000000014579017150779932024; + bpsToRay[5838] = 1000000014581019347620129595; + bpsToRay[5839] = 1000000014583021418047044467; + bpsToRay[5840] = 1000000014585023362076638415; + bpsToRay[5841] = 1000000014587025179724870195; + bpsToRay[5842] = 1000000014589026871007695536; + bpsToRay[5843] = 1000000014591028435941067149; + bpsToRay[5844] = 1000000014593029874540934724; + bpsToRay[5845] = 1000000014595031186823244930; + bpsToRay[5846] = 1000000014597032372803941418; + bpsToRay[5847] = 1000000014599033432498964818; + bpsToRay[5848] = 1000000014601034365924252746; + bpsToRay[5849] = 1000000014603035173095739799; + bpsToRay[5850] = 1000000014605035854029357558; + bpsToRay[5851] = 1000000014607036408741034590; + bpsToRay[5852] = 1000000014609036837246696444; + bpsToRay[5853] = 1000000014611037139562265661; + bpsToRay[5854] = 1000000014613037315703661762; + bpsToRay[5855] = 1000000014615037365686801262; + bpsToRay[5856] = 1000000014617037289527597660; + bpsToRay[5857] = 1000000014619037087241961446; + bpsToRay[5858] = 1000000014621036758845800100; + bpsToRay[5859] = 1000000014623036304355018094; + bpsToRay[5860] = 1000000014625035723785516888; + bpsToRay[5861] = 1000000014627035017153194937; + bpsToRay[5862] = 1000000014629034184473947689; + bpsToRay[5863] = 1000000014631033225763667584; + bpsToRay[5864] = 1000000014633032141038244058; + bpsToRay[5865] = 1000000014635030930313563542; + bpsToRay[5866] = 1000000014637029593605509464; + bpsToRay[5867] = 1000000014639028130929962246; + bpsToRay[5868] = 1000000014641026542302799310; + bpsToRay[5869] = 1000000014643024827739895076; + bpsToRay[5870] = 1000000014645022987257120962; + bpsToRay[5871] = 1000000014647021020870345387; + bpsToRay[5872] = 1000000014649018928595433770; + bpsToRay[5873] = 1000000014651016710448248531; + bpsToRay[5874] = 1000000014653014366444649093; + bpsToRay[5875] = 1000000014655011896600491882; + bpsToRay[5876] = 1000000014657009300931630326; + bpsToRay[5877] = 1000000014659006579453914859; + bpsToRay[5878] = 1000000014661003732183192919; + bpsToRay[5879] = 1000000014663000759135308949; + bpsToRay[5880] = 1000000014664997660326104403; + bpsToRay[5881] = 1000000014666994435771417736; + bpsToRay[5882] = 1000000014668991085487084417; + bpsToRay[5883] = 1000000014670987609488936922; + bpsToRay[5884] = 1000000014672984007792804732; + bpsToRay[5885] = 1000000014674980280414514346; + bpsToRay[5886] = 1000000014676976427369889269; + bpsToRay[5887] = 1000000014678972448674750021; + bpsToRay[5888] = 1000000014680968344344914131; + bpsToRay[5889] = 1000000014682964114396196144; + bpsToRay[5890] = 1000000014684959758844407618; + bpsToRay[5891] = 1000000014686955277705357128; + bpsToRay[5892] = 1000000014688950670994850263; + bpsToRay[5893] = 1000000014690945938728689628; + bpsToRay[5894] = 1000000014692941080922674845; + bpsToRay[5895] = 1000000014694936097592602556; + bpsToRay[5896] = 1000000014696930988754266420; + bpsToRay[5897] = 1000000014698925754423457115; + bpsToRay[5898] = 1000000014700920394615962341; + bpsToRay[5899] = 1000000014702914909347566817; + bpsToRay[5900] = 1000000014704909298634052283; + bpsToRay[5901] = 1000000014706903562491197505; + bpsToRay[5902] = 1000000014708897700934778270; + bpsToRay[5903] = 1000000014710891713980567389; + bpsToRay[5904] = 1000000014712885601644334694; + bpsToRay[5905] = 1000000014714879363941847051; + bpsToRay[5906] = 1000000014716873000888868344; + bpsToRay[5907] = 1000000014718866512501159488; + bpsToRay[5908] = 1000000014720859898794478424; + bpsToRay[5909] = 1000000014722853159784580123; + bpsToRay[5910] = 1000000014724846295487216583; + bpsToRay[5911] = 1000000014726839305918136834; + bpsToRay[5912] = 1000000014728832191093086935; + bpsToRay[5913] = 1000000014730824951027809978; + bpsToRay[5914] = 1000000014732817585738046086; + bpsToRay[5915] = 1000000014734810095239532414; + bpsToRay[5916] = 1000000014736802479548003151; + bpsToRay[5917] = 1000000014738794738679189525; + bpsToRay[5918] = 1000000014740786872648819790; + bpsToRay[5919] = 1000000014742778881472619245; + bpsToRay[5920] = 1000000014744770765166310220; + bpsToRay[5921] = 1000000014746762523745612083; + bpsToRay[5922] = 1000000014748754157226241244; + bpsToRay[5923] = 1000000014750745665623911146; + bpsToRay[5924] = 1000000014752737048954332275; + bpsToRay[5925] = 1000000014754728307233212158; + bpsToRay[5926] = 1000000014756719440476255360; + bpsToRay[5927] = 1000000014758710448699163491; + bpsToRay[5928] = 1000000014760701331917635202; + bpsToRay[5929] = 1000000014762692090147366186; + bpsToRay[5930] = 1000000014764682723404049184; + bpsToRay[5931] = 1000000014766673231703373978; + bpsToRay[5932] = 1000000014768663615061027396; + bpsToRay[5933] = 1000000014770653873492693314; + bpsToRay[5934] = 1000000014772644007014052654; + bpsToRay[5935] = 1000000014774634015640783386; + bpsToRay[5936] = 1000000014776623899388560526; + bpsToRay[5937] = 1000000014778613658273056145; + bpsToRay[5938] = 1000000014780603292309939358; + bpsToRay[5939] = 1000000014782592801514876334; + bpsToRay[5940] = 1000000014784582185903530293; + bpsToRay[5941] = 1000000014786571445491561506; + bpsToRay[5942] = 1000000014788560580294627298; + bpsToRay[5943] = 1000000014790549590328382048; + bpsToRay[5944] = 1000000014792538475608477188; + bpsToRay[5945] = 1000000014794527236150561205; + bpsToRay[5946] = 1000000014796515871970279644; + bpsToRay[5947] = 1000000014798504383083275106; + bpsToRay[5948] = 1000000014800492769505187248; + bpsToRay[5949] = 1000000014802481031251652786; + bpsToRay[5950] = 1000000014804469168338305494; + bpsToRay[5951] = 1000000014806457180780776207; + bpsToRay[5952] = 1000000014808445068594692819; + bpsToRay[5953] = 1000000014810432831795680286; + bpsToRay[5954] = 1000000014812420470399360626; + bpsToRay[5955] = 1000000014814407984421352919; + bpsToRay[5956] = 1000000014816395373877273307; + bpsToRay[5957] = 1000000014818382638782734998; + bpsToRay[5958] = 1000000014820369779153348262; + bpsToRay[5959] = 1000000014822356795004720439; + bpsToRay[5960] = 1000000014824343686352455932; + bpsToRay[5961] = 1000000014826330453212156210; + bpsToRay[5962] = 1000000014828317095599419813; + bpsToRay[5963] = 1000000014830303613529842346; + bpsToRay[5964] = 1000000014832290007019016486; + bpsToRay[5965] = 1000000014834276276082531977; + bpsToRay[5966] = 1000000014836262420735975636; + bpsToRay[5967] = 1000000014838248440994931352; + bpsToRay[5968] = 1000000014840234336874980083; + bpsToRay[5969] = 1000000014842220108391699861; + bpsToRay[5970] = 1000000014844205755560665792; + bpsToRay[5971] = 1000000014846191278397450058; + bpsToRay[5972] = 1000000014848176676917621912; + bpsToRay[5973] = 1000000014850161951136747686; + bpsToRay[5974] = 1000000014852147101070390787; + bpsToRay[5975] = 1000000014854132126734111701; + bpsToRay[5976] = 1000000014856117028143467990; + bpsToRay[5977] = 1000000014858101805314014293; + bpsToRay[5978] = 1000000014860086458261302333; + bpsToRay[5979] = 1000000014862070987000880911; + bpsToRay[5980] = 1000000014864055391548295906; + bpsToRay[5981] = 1000000014866039671919090284; + bpsToRay[5982] = 1000000014868023828128804090; + bpsToRay[5983] = 1000000014870007860192974452; + bpsToRay[5984] = 1000000014871991768127135581; + bpsToRay[5985] = 1000000014873975551946818776; + bpsToRay[5986] = 1000000014875959211667552419; + bpsToRay[5987] = 1000000014877942747304861976; + bpsToRay[5988] = 1000000014879926158874270004; + bpsToRay[5989] = 1000000014881909446391296144; + bpsToRay[5990] = 1000000014883892609871457128; + bpsToRay[5991] = 1000000014885875649330266773; + bpsToRay[5992] = 1000000014887858564783235989; + bpsToRay[5993] = 1000000014889841356245872775; + bpsToRay[5994] = 1000000014891824023733682222; + bpsToRay[5995] = 1000000014893806567262166511; + bpsToRay[5996] = 1000000014895788986846824917; + bpsToRay[5997] = 1000000014897771282503153808; + bpsToRay[5998] = 1000000014899753454246646646; + bpsToRay[5999] = 1000000014901735502092793986; + bpsToRay[6000] = 1000000014903717426057083481; + bpsToRay[6001] = 1000000014905699226154999880; + bpsToRay[6002] = 1000000014907680902402025027; + bpsToRay[6003] = 1000000014909662454813637865; + bpsToRay[6004] = 1000000014911643883405314435; + bpsToRay[6005] = 1000000014913625188192527876; + bpsToRay[6006] = 1000000014915606369190748429; + bpsToRay[6007] = 1000000014917587426415443433; + bpsToRay[6008] = 1000000014919568359882077330; + bpsToRay[6009] = 1000000014921549169606111665; + bpsToRay[6010] = 1000000014923529855603005082; + bpsToRay[6011] = 1000000014925510417888213331; + bpsToRay[6012] = 1000000014927490856477189267; + bpsToRay[6013] = 1000000014929471171385382847; + bpsToRay[6014] = 1000000014931451362628241136; + bpsToRay[6015] = 1000000014933431430221208304; + bpsToRay[6016] = 1000000014935411374179725629; + bpsToRay[6017] = 1000000014937391194519231495; + bpsToRay[6018] = 1000000014939370891255161396; + bpsToRay[6019] = 1000000014941350464402947936; + bpsToRay[6020] = 1000000014943329913978020826; + bpsToRay[6021] = 1000000014945309239995806891; + bpsToRay[6022] = 1000000014947288442471730065; + bpsToRay[6023] = 1000000014949267521421211394; + bpsToRay[6024] = 1000000014951246476859669038; + bpsToRay[6025] = 1000000014953225308802518272; + bpsToRay[6026] = 1000000014955204017265171481; + bpsToRay[6027] = 1000000014957182602263038168; + bpsToRay[6028] = 1000000014959161063811524950; + bpsToRay[6029] = 1000000014961139401926035563; + bpsToRay[6030] = 1000000014963117616621970858; + bpsToRay[6031] = 1000000014965095707914728804; + bpsToRay[6032] = 1000000014967073675819704489; + bpsToRay[6033] = 1000000014969051520352290120; + bpsToRay[6034] = 1000000014971029241527875024; + bpsToRay[6035] = 1000000014973006839361845649; + bpsToRay[6036] = 1000000014974984313869585565; + bpsToRay[6037] = 1000000014976961665066475462; + bpsToRay[6038] = 1000000014978938892967893156; + bpsToRay[6039] = 1000000014980915997589213583; + bpsToRay[6040] = 1000000014982892978945808807; + bpsToRay[6041] = 1000000014984869837053048013; + bpsToRay[6042] = 1000000014986846571926297515; + bpsToRay[6043] = 1000000014988823183580920752; + bpsToRay[6044] = 1000000014990799672032278292; + bpsToRay[6045] = 1000000014992776037295727828; + bpsToRay[6046] = 1000000014994752279386624184; + bpsToRay[6047] = 1000000014996728398320319311; + bpsToRay[6048] = 1000000014998704394112162292; + bpsToRay[6049] = 1000000015000680266777499339; + bpsToRay[6050] = 1000000015002656016331673799; + bpsToRay[6051] = 1000000015004631642790026146; + bpsToRay[6052] = 1000000015006607146167893992; + bpsToRay[6053] = 1000000015008582526480612079; + bpsToRay[6054] = 1000000015010557783743512285; + bpsToRay[6055] = 1000000015012532917971923621; + bpsToRay[6056] = 1000000015014507929181172237; + bpsToRay[6057] = 1000000015016482817386581417; + bpsToRay[6058] = 1000000015018457582603471584; + bpsToRay[6059] = 1000000015020432224847160297; + bpsToRay[6060] = 1000000015022406744132962253; + bpsToRay[6061] = 1000000015024381140476189292; + bpsToRay[6062] = 1000000015026355413892150391; + bpsToRay[6063] = 1000000015028329564396151668; + bpsToRay[6064] = 1000000015030303592003496384; + bpsToRay[6065] = 1000000015032277496729484940; + bpsToRay[6066] = 1000000015034251278589414882; + bpsToRay[6067] = 1000000015036224937598580896; + bpsToRay[6068] = 1000000015038198473772274819; + bpsToRay[6069] = 1000000015040171887125785626; + bpsToRay[6070] = 1000000015042145177674399441; + bpsToRay[6071] = 1000000015044118345433399534; + bpsToRay[6072] = 1000000015046091390418066323; + bpsToRay[6073] = 1000000015048064312643677371; + bpsToRay[6074] = 1000000015050037112125507393; + bpsToRay[6075] = 1000000015052009788878828253; + bpsToRay[6076] = 1000000015053982342918908961; + bpsToRay[6077] = 1000000015055954774261015682; + bpsToRay[6078] = 1000000015057927082920411731; + bpsToRay[6079] = 1000000015059899268912357574; + bpsToRay[6080] = 1000000015061871332252110832; + bpsToRay[6081] = 1000000015063843272954926277; + bpsToRay[6082] = 1000000015065815091036055837; + bpsToRay[6083] = 1000000015067786786510748595; + bpsToRay[6084] = 1000000015069758359394250789; + bpsToRay[6085] = 1000000015071729809701805813; + bpsToRay[6086] = 1000000015073701137448654217; + bpsToRay[6087] = 1000000015075672342650033713; + bpsToRay[6088] = 1000000015077643425321179167; + bpsToRay[6089] = 1000000015079614385477322606; + bpsToRay[6090] = 1000000015081585223133693217; + bpsToRay[6091] = 1000000015083555938305517348; + bpsToRay[6092] = 1000000015085526531008018506; + bpsToRay[6093] = 1000000015087497001256417364; + bpsToRay[6094] = 1000000015089467349065931754; + bpsToRay[6095] = 1000000015091437574451776672; + bpsToRay[6096] = 1000000015093407677429164279; + bpsToRay[6097] = 1000000015095377658013303902; + bpsToRay[6098] = 1000000015097347516219402031; + bpsToRay[6099] = 1000000015099317252062662325; + bpsToRay[6100] = 1000000015101286865558285606; + bpsToRay[6101] = 1000000015103256356721469870; + bpsToRay[6102] = 1000000015105225725567410272; + bpsToRay[6103] = 1000000015107194972111299145; + bpsToRay[6104] = 1000000015109164096368325987; + bpsToRay[6105] = 1000000015111133098353677468; + bpsToRay[6106] = 1000000015113101978082537430; + bpsToRay[6107] = 1000000015115070735570086883; + bpsToRay[6108] = 1000000015117039370831504013; + bpsToRay[6109] = 1000000015119007883881964179; + bpsToRay[6110] = 1000000015120976274736639914; + bpsToRay[6111] = 1000000015122944543410700923; + bpsToRay[6112] = 1000000015124912689919314090; + bpsToRay[6113] = 1000000015126880714277643473; + bpsToRay[6114] = 1000000015128848616500850307; + bpsToRay[6115] = 1000000015130816396604093005; + bpsToRay[6116] = 1000000015132784054602527158; + bpsToRay[6117] = 1000000015134751590511305536; + bpsToRay[6118] = 1000000015136719004345578088; + bpsToRay[6119] = 1000000015138686296120491942; + bpsToRay[6120] = 1000000015140653465851191411; + bpsToRay[6121] = 1000000015142620513552817987; + bpsToRay[6122] = 1000000015144587439240510342; + bpsToRay[6123] = 1000000015146554242929404336; + bpsToRay[6124] = 1000000015148520924634633011; + bpsToRay[6125] = 1000000015150487484371326590; + bpsToRay[6126] = 1000000015152453922154612487; + bpsToRay[6127] = 1000000015154420237999615297; + bpsToRay[6128] = 1000000015156386431921456805; + bpsToRay[6129] = 1000000015158352503935255979; + bpsToRay[6130] = 1000000015160318454056128981; + bpsToRay[6131] = 1000000015162284282299189156; + bpsToRay[6132] = 1000000015164249988679547042; + bpsToRay[6133] = 1000000015166215573212310364; + bpsToRay[6134] = 1000000015168181035912584041; + bpsToRay[6135] = 1000000015170146376795470181; + bpsToRay[6136] = 1000000015172111595876068086; + bpsToRay[6137] = 1000000015174076693169474249; + bpsToRay[6138] = 1000000015176041668690782357; + bpsToRay[6139] = 1000000015178006522455083294; + bpsToRay[6140] = 1000000015179971254477465133; + bpsToRay[6141] = 1000000015181935864773013148; + bpsToRay[6142] = 1000000015183900353356809808; + bpsToRay[6143] = 1000000015185864720243934777; + bpsToRay[6144] = 1000000015187828965449464919; + bpsToRay[6145] = 1000000015189793088988474295; + bpsToRay[6146] = 1000000015191757090876034166; + bpsToRay[6147] = 1000000015193720971127212993; + bpsToRay[6148] = 1000000015195684729757076435; + bpsToRay[6149] = 1000000015197648366780687356; + bpsToRay[6150] = 1000000015199611882213105818; + bpsToRay[6151] = 1000000015201575276069389089; + bpsToRay[6152] = 1000000015203538548364591637; + bpsToRay[6153] = 1000000015205501699113765138; + bpsToRay[6154] = 1000000015207464728331958468; + bpsToRay[6155] = 1000000015209427636034217712; + bpsToRay[6156] = 1000000015211390422235586158; + bpsToRay[6157] = 1000000015213353086951104304; + bpsToRay[6158] = 1000000015215315630195809853; + bpsToRay[6159] = 1000000015217278051984737717; + bpsToRay[6160] = 1000000015219240352332920015; + bpsToRay[6161] = 1000000015221202531255386080; + bpsToRay[6162] = 1000000015223164588767162449; + bpsToRay[6163] = 1000000015225126524883272874; + bpsToRay[6164] = 1000000015227088339618738319; + bpsToRay[6165] = 1000000015229050032988576957; + bpsToRay[6166] = 1000000015231011605007804177; + bpsToRay[6167] = 1000000015232973055691432580; + bpsToRay[6168] = 1000000015234934385054471980; + bpsToRay[6169] = 1000000015236895593111929410; + bpsToRay[6170] = 1000000015238856679878809116; + bpsToRay[6171] = 1000000015240817645370112558; + bpsToRay[6172] = 1000000015242778489600838420; + bpsToRay[6173] = 1000000015244739212585982595; + bpsToRay[6174] = 1000000015246699814340538201; + bpsToRay[6175] = 1000000015248660294879495575; + bpsToRay[6176] = 1000000015250620654217842268; + bpsToRay[6177] = 1000000015252580892370563058; + bpsToRay[6178] = 1000000015254541009352639939; + bpsToRay[6179] = 1000000015256501005179052132; + bpsToRay[6180] = 1000000015258460879864776078; + bpsToRay[6181] = 1000000015260420633424785438; + bpsToRay[6182] = 1000000015262380265874051103; + bpsToRay[6183] = 1000000015264339777227541185; + bpsToRay[6184] = 1000000015266299167500221022; + bpsToRay[6185] = 1000000015268258436707053177; + bpsToRay[6186] = 1000000015270217584862997442; + bpsToRay[6187] = 1000000015272176611983010835; + bpsToRay[6188] = 1000000015274135518082047600; + bpsToRay[6189] = 1000000015276094303175059215; + bpsToRay[6190] = 1000000015278052967276994381; + bpsToRay[6191] = 1000000015280011510402799035; + bpsToRay[6192] = 1000000015281969932567416340; + bpsToRay[6193] = 1000000015283928233785786694; + bpsToRay[6194] = 1000000015285886414072847725; + bpsToRay[6195] = 1000000015287844473443534295; + bpsToRay[6196] = 1000000015289802411912778498; + bpsToRay[6197] = 1000000015291760229495509665; + bpsToRay[6198] = 1000000015293717926206654358; + bpsToRay[6199] = 1000000015295675502061136378; + bpsToRay[6200] = 1000000015297632957073876761; + bpsToRay[6201] = 1000000015299590291259793780; + bpsToRay[6202] = 1000000015301547504633802945; + bpsToRay[6203] = 1000000015303504597210817004; + bpsToRay[6204] = 1000000015305461569005745947; + bpsToRay[6205] = 1000000015307418420033496998; + bpsToRay[6206] = 1000000015309375150308974628; + bpsToRay[6207] = 1000000015311331759847080545; + bpsToRay[6208] = 1000000015313288248662713699; + bpsToRay[6209] = 1000000015315244616770770282; + bpsToRay[6210] = 1000000015317200864186143732; + bpsToRay[6211] = 1000000015319156990923724726; + bpsToRay[6212] = 1000000015321112996998401190; + bpsToRay[6213] = 1000000015323068882425058294; + bpsToRay[6214] = 1000000015325024647218578451; + bpsToRay[6215] = 1000000015326980291393841323; + bpsToRay[6216] = 1000000015328935814965723819; + bpsToRay[6217] = 1000000015330891217949100095; + bpsToRay[6218] = 1000000015332846500358841555; + bpsToRay[6219] = 1000000015334801662209816855; + bpsToRay[6220] = 1000000015336756703516891898; + bpsToRay[6221] = 1000000015338711624294929839; + bpsToRay[6222] = 1000000015340666424558791082; + bpsToRay[6223] = 1000000015342621104323333287; + bpsToRay[6224] = 1000000015344575663603411362; + bpsToRay[6225] = 1000000015346530102413877471; + bpsToRay[6226] = 1000000015348484420769581033; + bpsToRay[6227] = 1000000015350438618685368717; + bpsToRay[6228] = 1000000015352392696176084451; + bpsToRay[6229] = 1000000015354346653256569420; + bpsToRay[6230] = 1000000015356300489941662062; + bpsToRay[6231] = 1000000015358254206246198075; + bpsToRay[6232] = 1000000015360207802185010413; + bpsToRay[6233] = 1000000015362161277772929290; + bpsToRay[6234] = 1000000015364114633024782180; + bpsToRay[6235] = 1000000015366067867955393814; + bpsToRay[6236] = 1000000015368020982579586188; + bpsToRay[6237] = 1000000015369973976912178557; + bpsToRay[6238] = 1000000015371926850967987435; + bpsToRay[6239] = 1000000015373879604761826606; + bpsToRay[6240] = 1000000015375832238308507110; + bpsToRay[6241] = 1000000015377784751622837256; + bpsToRay[6242] = 1000000015379737144719622615; + bpsToRay[6243] = 1000000015381689417613666024; + bpsToRay[6244] = 1000000015383641570319767589; + bpsToRay[6245] = 1000000015385593602852724678; + bpsToRay[6246] = 1000000015387545515227331928; + bpsToRay[6247] = 1000000015389497307458381246; + bpsToRay[6248] = 1000000015391448979560661806; + bpsToRay[6249] = 1000000015393400531548960052; + bpsToRay[6250] = 1000000015395351963438059699; + bpsToRay[6251] = 1000000015397303275242741731; + bpsToRay[6252] = 1000000015399254466977784403; + bpsToRay[6253] = 1000000015401205538657963245; + bpsToRay[6254] = 1000000015403156490298051058; + bpsToRay[6255] = 1000000015405107321912817917; + bpsToRay[6256] = 1000000015407058033517031169; + bpsToRay[6257] = 1000000015409008625125455440; + bpsToRay[6258] = 1000000015410959096752852627; + bpsToRay[6259] = 1000000015412909448413981907; + bpsToRay[6260] = 1000000015414859680123599731; + bpsToRay[6261] = 1000000015416809791896459828; + bpsToRay[6262] = 1000000015418759783747313206; + bpsToRay[6263] = 1000000015420709655690908154; + bpsToRay[6264] = 1000000015422659407741990234; + bpsToRay[6265] = 1000000015424609039915302295; + bpsToRay[6266] = 1000000015426558552225584464; + bpsToRay[6267] = 1000000015428507944687574148; + bpsToRay[6268] = 1000000015430457217316006040; + bpsToRay[6269] = 1000000015432406370125612111; + bpsToRay[6270] = 1000000015434355403131121619; + bpsToRay[6271] = 1000000015436304316347261106; + bpsToRay[6272] = 1000000015438253109788754397; + bpsToRay[6273] = 1000000015440201783470322605; + bpsToRay[6274] = 1000000015442150337406684127; + bpsToRay[6275] = 1000000015444098771612554646; + bpsToRay[6276] = 1000000015446047086102647137; + bpsToRay[6277] = 1000000015447995280891671860; + bpsToRay[6278] = 1000000015449943355994336362; + bpsToRay[6279] = 1000000015451891311425345484; + bpsToRay[6280] = 1000000015453839147199401353; + bpsToRay[6281] = 1000000015455786863331203391; + bpsToRay[6282] = 1000000015457734459835448307; + bpsToRay[6283] = 1000000015459681936726830105; + bpsToRay[6284] = 1000000015461629294020040082; + bpsToRay[6285] = 1000000015463576531729766828; + bpsToRay[6286] = 1000000015465523649870696226; + bpsToRay[6287] = 1000000015467470648457511454; + bpsToRay[6288] = 1000000015469417527504892989; + bpsToRay[6289] = 1000000015471364287027518599; + bpsToRay[6290] = 1000000015473310927040063352; + bpsToRay[6291] = 1000000015475257447557199613; + bpsToRay[6292] = 1000000015477203848593597045; + bpsToRay[6293] = 1000000015479150130163922609; + bpsToRay[6294] = 1000000015481096292282840567; + bpsToRay[6295] = 1000000015483042334965012479; + bpsToRay[6296] = 1000000015484988258225097210; + bpsToRay[6297] = 1000000015486934062077750921; + bpsToRay[6298] = 1000000015488879746537627079; + bpsToRay[6299] = 1000000015490825311619376452; + bpsToRay[6300] = 1000000015492770757337647112; + bpsToRay[6301] = 1000000015494716083707084436; + bpsToRay[6302] = 1000000015496661290742331104; + bpsToRay[6303] = 1000000015498606378458027103; + bpsToRay[6304] = 1000000015500551346868809725; + bpsToRay[6305] = 1000000015502496195989313568; + bpsToRay[6306] = 1000000015504440925834170541; + bpsToRay[6307] = 1000000015506385536418009859; + bpsToRay[6308] = 1000000015508330027755458043; + bpsToRay[6309] = 1000000015510274399861138927; + bpsToRay[6310] = 1000000015512218652749673656; + bpsToRay[6311] = 1000000015514162786435680680; + bpsToRay[6312] = 1000000015516106800933775766; + bpsToRay[6313] = 1000000015518050696258571992; + bpsToRay[6314] = 1000000015519994472424679745; + bpsToRay[6315] = 1000000015521938129446706731; + bpsToRay[6316] = 1000000015523881667339257966; + bpsToRay[6317] = 1000000015525825086116935783; + bpsToRay[6318] = 1000000015527768385794339827; + bpsToRay[6319] = 1000000015529711566386067064; + bpsToRay[6320] = 1000000015531654627906711771; + bpsToRay[6321] = 1000000015533597570370865546; + bpsToRay[6322] = 1000000015535540393793117305; + bpsToRay[6323] = 1000000015537483098188053282; + bpsToRay[6324] = 1000000015539425683570257029; + bpsToRay[6325] = 1000000015541368149954309419; + bpsToRay[6326] = 1000000015543310497354788646; + bpsToRay[6327] = 1000000015545252725786270226; + bpsToRay[6328] = 1000000015547194835263326993; + bpsToRay[6329] = 1000000015549136825800529108; + bpsToRay[6330] = 1000000015551078697412444053; + bpsToRay[6331] = 1000000015553020450113636636; + bpsToRay[6332] = 1000000015554962083918668986; + bpsToRay[6333] = 1000000015556903598842100559; + bpsToRay[6334] = 1000000015558844994898488139; + bpsToRay[6335] = 1000000015560786272102385832; + bpsToRay[6336] = 1000000015562727430468345075; + bpsToRay[6337] = 1000000015564668470010914631; + bpsToRay[6338] = 1000000015566609390744640592; + bpsToRay[6339] = 1000000015568550192684066380; + bpsToRay[6340] = 1000000015570490875843732744; + bpsToRay[6341] = 1000000015572431440238177765; + bpsToRay[6342] = 1000000015574371885881936857; + bpsToRay[6343] = 1000000015576312212789542763; + bpsToRay[6344] = 1000000015578252420975525559; + bpsToRay[6345] = 1000000015580192510454412655; + bpsToRay[6346] = 1000000015582132481240728794; + bpsToRay[6347] = 1000000015584072333348996053; + bpsToRay[6348] = 1000000015586012066793733846; + bpsToRay[6349] = 1000000015587951681589458919; + bpsToRay[6350] = 1000000015589891177750685357; + bpsToRay[6351] = 1000000015591830555291924580; + bpsToRay[6352] = 1000000015593769814227685350; + bpsToRay[6353] = 1000000015595708954572473762; + bpsToRay[6354] = 1000000015597647976340793253; + bpsToRay[6355] = 1000000015599586879547144596; + bpsToRay[6356] = 1000000015601525664206025911; + bpsToRay[6357] = 1000000015603464330331932651; + bpsToRay[6358] = 1000000015605402877939357616; + bpsToRay[6359] = 1000000015607341307042790947; + bpsToRay[6360] = 1000000015609279617656720124; + bpsToRay[6361] = 1000000015611217809795629977; + bpsToRay[6362] = 1000000015613155883474002675; + bpsToRay[6363] = 1000000015615093838706317732; + bpsToRay[6364] = 1000000015617031675507052012; + bpsToRay[6365] = 1000000015618969393890679720; + bpsToRay[6366] = 1000000015620906993871672410; + bpsToRay[6367] = 1000000015622844475464498982; + bpsToRay[6368] = 1000000015624781838683625685; + bpsToRay[6369] = 1000000015626719083543516119; + bpsToRay[6370] = 1000000015628656210058631227; + bpsToRay[6371] = 1000000015630593218243429309; + bpsToRay[6372] = 1000000015632530108112366010; + bpsToRay[6373] = 1000000015634466879679894331; + bpsToRay[6374] = 1000000015636403532960464619; + bpsToRay[6375] = 1000000015638340067968524580; + bpsToRay[6376] = 1000000015640276484718519269; + bpsToRay[6377] = 1000000015642212783224891098; + bpsToRay[6378] = 1000000015644148963502079827; + bpsToRay[6379] = 1000000015646085025564522580; + bpsToRay[6380] = 1000000015648020969426653830; + bpsToRay[6381] = 1000000015649956795102905409; + bpsToRay[6382] = 1000000015651892502607706506; + bpsToRay[6383] = 1000000015653828091955483667; + bpsToRay[6384] = 1000000015655763563160660798; + bpsToRay[6385] = 1000000015657698916237659162; + bpsToRay[6386] = 1000000015659634151200897382; + bpsToRay[6387] = 1000000015661569268064791442; + bpsToRay[6388] = 1000000015663504266843754688; + bpsToRay[6389] = 1000000015665439147552197824; + bpsToRay[6390] = 1000000015667373910204528920; + bpsToRay[6391] = 1000000015669308554815153405; + bpsToRay[6392] = 1000000015671243081398474077; + bpsToRay[6393] = 1000000015673177489968891092; + bpsToRay[6394] = 1000000015675111780540801975; + bpsToRay[6395] = 1000000015677045953128601614; + bpsToRay[6396] = 1000000015678980007746682266; + bpsToRay[6397] = 1000000015680913944409433552; + bpsToRay[6398] = 1000000015682847763131242461; + bpsToRay[6399] = 1000000015684781463926493350; + bpsToRay[6400] = 1000000015686715046809567945; + bpsToRay[6401] = 1000000015688648511794845341; + bpsToRay[6402] = 1000000015690581858896702002; + bpsToRay[6403] = 1000000015692515088129511766; + bpsToRay[6404] = 1000000015694448199507645837; + bpsToRay[6405] = 1000000015696381193045472797; + bpsToRay[6406] = 1000000015698314068757358594; + bpsToRay[6407] = 1000000015700246826657666553; + bpsToRay[6408] = 1000000015702179466760757373; + bpsToRay[6409] = 1000000015704111989080989125; + bpsToRay[6410] = 1000000015706044393632717258; + bpsToRay[6411] = 1000000015707976680430294594; + bpsToRay[6412] = 1000000015709908849488071333; + bpsToRay[6413] = 1000000015711840900820395051; + bpsToRay[6414] = 1000000015713772834441610701; + bpsToRay[6415] = 1000000015715704650366060617; + bpsToRay[6416] = 1000000015717636348608084511; + bpsToRay[6417] = 1000000015719567929182019470; + bpsToRay[6418] = 1000000015721499392102199968; + bpsToRay[6419] = 1000000015723430737382957855; + bpsToRay[6420] = 1000000015725361965038622365; + bpsToRay[6421] = 1000000015727293075083520113; + bpsToRay[6422] = 1000000015729224067531975096; + bpsToRay[6423] = 1000000015731154942398308695; + bpsToRay[6424] = 1000000015733085699696839676; + bpsToRay[6425] = 1000000015735016339441884188; + bpsToRay[6426] = 1000000015736946861647755768; + bpsToRay[6427] = 1000000015738877266328765334; + bpsToRay[6428] = 1000000015740807553499221196; + bpsToRay[6429] = 1000000015742737723173429047; + bpsToRay[6430] = 1000000015744667775365691970; + bpsToRay[6431] = 1000000015746597710090310436; + bpsToRay[6432] = 1000000015748527527361582305; + bpsToRay[6433] = 1000000015750457227193802825; + bpsToRay[6434] = 1000000015752386809601264637; + bpsToRay[6435] = 1000000015754316274598257774; + bpsToRay[6436] = 1000000015756245622199069656; + bpsToRay[6437] = 1000000015758174852417985099; + bpsToRay[6438] = 1000000015760103965269286310; + bpsToRay[6439] = 1000000015762032960767252891; + bpsToRay[6440] = 1000000015763961838926161836; + bpsToRay[6441] = 1000000015765890599760287538; + bpsToRay[6442] = 1000000015767819243283901779; + bpsToRay[6443] = 1000000015769747769511273744; + bpsToRay[6444] = 1000000015771676178456670009; + bpsToRay[6445] = 1000000015773604470134354550; + bpsToRay[6446] = 1000000015775532644558588743; + bpsToRay[6447] = 1000000015777460701743631357; + bpsToRay[6448] = 1000000015779388641703738565; + bpsToRay[6449] = 1000000015781316464453163938; + bpsToRay[6450] = 1000000015783244170006158447; + bpsToRay[6451] = 1000000015785171758376970467; + bpsToRay[6452] = 1000000015787099229579845770; + bpsToRay[6453] = 1000000015789026583629027536; + bpsToRay[6454] = 1000000015790953820538756342; + bpsToRay[6455] = 1000000015792880940323270174; + bpsToRay[6456] = 1000000015794807942996804419; + bpsToRay[6457] = 1000000015796734828573591870; + bpsToRay[6458] = 1000000015798661597067862724; + bpsToRay[6459] = 1000000015800588248493844588; + bpsToRay[6460] = 1000000015802514782865762472; + bpsToRay[6461] = 1000000015804441200197838795; + bpsToRay[6462] = 1000000015806367500504293384; + bpsToRay[6463] = 1000000015808293683799343474; + bpsToRay[6464] = 1000000015810219750097203710; + bpsToRay[6465] = 1000000015812145699412086147; + bpsToRay[6466] = 1000000015814071531758200252; + bpsToRay[6467] = 1000000015815997247149752899; + bpsToRay[6468] = 1000000015817922845600948377; + bpsToRay[6469] = 1000000015819848327125988387; + bpsToRay[6470] = 1000000015821773691739072044; + bpsToRay[6471] = 1000000015823698939454395875; + bpsToRay[6472] = 1000000015825624070286153821; + bpsToRay[6473] = 1000000015827549084248537241; + bpsToRay[6474] = 1000000015829473981355734906; + bpsToRay[6475] = 1000000015831398761621933006; + bpsToRay[6476] = 1000000015833323425061315145; + bpsToRay[6477] = 1000000015835247971688062347; + bpsToRay[6478] = 1000000015837172401516353055; + bpsToRay[6479] = 1000000015839096714560363128; + bpsToRay[6480] = 1000000015841020910834265843; + bpsToRay[6481] = 1000000015842944990352231903; + bpsToRay[6482] = 1000000015844868953128429425; + bpsToRay[6483] = 1000000015846792799177023953; + bpsToRay[6484] = 1000000015848716528512178448; + bpsToRay[6485] = 1000000015850640141148053296; + bpsToRay[6486] = 1000000015852563637098806307; + bpsToRay[6487] = 1000000015854487016378592712; + bpsToRay[6488] = 1000000015856410279001565169; + bpsToRay[6489] = 1000000015858333424981873758; + bpsToRay[6490] = 1000000015860256454333665989; + bpsToRay[6491] = 1000000015862179367071086794; + bpsToRay[6492] = 1000000015864102163208278534; + bpsToRay[6493] = 1000000015866024842759380997; + bpsToRay[6494] = 1000000015867947405738531398; + bpsToRay[6495] = 1000000015869869852159864384; + bpsToRay[6496] = 1000000015871792182037512030; + bpsToRay[6497] = 1000000015873714395385603836; + bpsToRay[6498] = 1000000015875636492218266741; + bpsToRay[6499] = 1000000015877558472549625110; + bpsToRay[6500] = 1000000015879480336393800741; + bpsToRay[6501] = 1000000015881402083764912862; + bpsToRay[6502] = 1000000015883323714677078140; + bpsToRay[6503] = 1000000015885245229144410671; + bpsToRay[6504] = 1000000015887166627181021987; + bpsToRay[6505] = 1000000015889087908801021053; + bpsToRay[6506] = 1000000015891009074018514273; + bpsToRay[6507] = 1000000015892930122847605485; + bpsToRay[6508] = 1000000015894851055302395963; + bpsToRay[6509] = 1000000015896771871396984421; + bpsToRay[6510] = 1000000015898692571145467010; + bpsToRay[6511] = 1000000015900613154561937317; + bpsToRay[6512] = 1000000015902533621660486374; + bpsToRay[6513] = 1000000015904453972455202647; + bpsToRay[6514] = 1000000015906374206960172047; + bpsToRay[6515] = 1000000015908294325189477924; + bpsToRay[6516] = 1000000015910214327157201069; + bpsToRay[6517] = 1000000015912134212877419719; + bpsToRay[6518] = 1000000015914053982364209549; + bpsToRay[6519] = 1000000015915973635631643682; + bpsToRay[6520] = 1000000015917893172693792683; + bpsToRay[6521] = 1000000015919812593564724562; + bpsToRay[6522] = 1000000015921731898258504776; + bpsToRay[6523] = 1000000015923651086789196227; + bpsToRay[6524] = 1000000015925570159170859262; + bpsToRay[6525] = 1000000015927489115417551681; + bpsToRay[6526] = 1000000015929407955543328724; + bpsToRay[6527] = 1000000015931326679562243086; + bpsToRay[6528] = 1000000015933245287488344910; + bpsToRay[6529] = 1000000015935163779335681785; + bpsToRay[6530] = 1000000015937082155118298755; + bpsToRay[6531] = 1000000015939000414850238313; + bpsToRay[6532] = 1000000015940918558545540404; + bpsToRay[6533] = 1000000015942836586218242426; + bpsToRay[6534] = 1000000015944754497882379228; + bpsToRay[6535] = 1000000015946672293551983115; + bpsToRay[6536] = 1000000015948589973241083845; + bpsToRay[6537] = 1000000015950507536963708629; + bpsToRay[6538] = 1000000015952424984733882136; + bpsToRay[6539] = 1000000015954342316565626492; + bpsToRay[6540] = 1000000015956259532472961274; + bpsToRay[6541] = 1000000015958176632469903523; + bpsToRay[6542] = 1000000015960093616570467734; + bpsToRay[6543] = 1000000015962010484788665860; + bpsToRay[6544] = 1000000015963927237138507317; + bpsToRay[6545] = 1000000015965843873633998974; + bpsToRay[6546] = 1000000015967760394289145167; + bpsToRay[6547] = 1000000015969676799117947690; + bpsToRay[6548] = 1000000015971593088134405798; + bpsToRay[6549] = 1000000015973509261352516209; + bpsToRay[6550] = 1000000015975425318786273105; + bpsToRay[6551] = 1000000015977341260449668127; + bpsToRay[6552] = 1000000015979257086356690385; + bpsToRay[6553] = 1000000015981172796521326452; + bpsToRay[6554] = 1000000015983088390957560365; + bpsToRay[6555] = 1000000015985003869679373628; + bpsToRay[6556] = 1000000015986919232700745209; + bpsToRay[6557] = 1000000015988834480035651548; + bpsToRay[6558] = 1000000015990749611698066548; + bpsToRay[6559] = 1000000015992664627701961582; + bpsToRay[6560] = 1000000015994579528061305491; + bpsToRay[6561] = 1000000015996494312790064590; + bpsToRay[6562] = 1000000015998408981902202656; + bpsToRay[6563] = 1000000016000323535411680943; + bpsToRay[6564] = 1000000016002237973332458175; + bpsToRay[6565] = 1000000016004152295678490547; + bpsToRay[6566] = 1000000016006066502463731726; + bpsToRay[6567] = 1000000016007980593702132855; + bpsToRay[6568] = 1000000016009894569407642547; + bpsToRay[6569] = 1000000016011808429594206893; + bpsToRay[6570] = 1000000016013722174275769455; + bpsToRay[6571] = 1000000016015635803466271275; + bpsToRay[6572] = 1000000016017549317179650868; + bpsToRay[6573] = 1000000016019462715429844226; + bpsToRay[6574] = 1000000016021375998230784820; + bpsToRay[6575] = 1000000016023289165596403599; + bpsToRay[6576] = 1000000016025202217540628989; + bpsToRay[6577] = 1000000016027115154077386896; + bpsToRay[6578] = 1000000016029027975220600708; + bpsToRay[6579] = 1000000016030940680984191289; + bpsToRay[6580] = 1000000016032853271382076987; + bpsToRay[6581] = 1000000016034765746428173632; + bpsToRay[6582] = 1000000016036678106136394535; + bpsToRay[6583] = 1000000016038590350520650490; + bpsToRay[6584] = 1000000016040502479594849776; + bpsToRay[6585] = 1000000016042414493372898155; + bpsToRay[6586] = 1000000016044326391868698872; + bpsToRay[6587] = 1000000016046238175096152661; + bpsToRay[6588] = 1000000016048149843069157739; + bpsToRay[6589] = 1000000016050061395801609810; + bpsToRay[6590] = 1000000016051972833307402066; + bpsToRay[6591] = 1000000016053884155600425188; + bpsToRay[6592] = 1000000016055795362694567342; + bpsToRay[6593] = 1000000016057706454603714184; + bpsToRay[6594] = 1000000016059617431341748863; + bpsToRay[6595] = 1000000016061528292922552013; + bpsToRay[6596] = 1000000016063439039360001761; + bpsToRay[6597] = 1000000016065349670667973728; + bpsToRay[6598] = 1000000016067260186860341022; + bpsToRay[6599] = 1000000016069170587950974247; + bpsToRay[6600] = 1000000016071080873953741499; + bpsToRay[6601] = 1000000016072991044882508369; + bpsToRay[6602] = 1000000016074901100751137941; + bpsToRay[6603] = 1000000016076811041573490795; + bpsToRay[6604] = 1000000016078720867363425005; + bpsToRay[6605] = 1000000016080630578134796143; + bpsToRay[6606] = 1000000016082540173901457278; + bpsToRay[6607] = 1000000016084449654677258973; + bpsToRay[6608] = 1000000016086359020476049294; + bpsToRay[6609] = 1000000016088268271311673802; + bpsToRay[6610] = 1000000016090177407197975559; + bpsToRay[6611] = 1000000016092086428148795125; + bpsToRay[6612] = 1000000016093995334177970563; + bpsToRay[6613] = 1000000016095904125299337436; + bpsToRay[6614] = 1000000016097812801526728807; + bpsToRay[6615] = 1000000016099721362873975244; + bpsToRay[6616] = 1000000016101629809354904814; + bpsToRay[6617] = 1000000016103538140983343092; + bpsToRay[6618] = 1000000016105446357773113153; + bpsToRay[6619] = 1000000016107354459738035580; + bpsToRay[6620] = 1000000016109262446891928459; + bpsToRay[6621] = 1000000016111170319248607383; + bpsToRay[6622] = 1000000016113078076821885451; + bpsToRay[6623] = 1000000016114985719625573268; + bpsToRay[6624] = 1000000016116893247673478948; + bpsToRay[6625] = 1000000016118800660979408115; + bpsToRay[6626] = 1000000016120707959557163897; + bpsToRay[6627] = 1000000016122615143420546934; + bpsToRay[6628] = 1000000016124522212583355378; + bpsToRay[6629] = 1000000016126429167059384889; + bpsToRay[6630] = 1000000016128336006862428639; + bpsToRay[6631] = 1000000016130242732006277312; + bpsToRay[6632] = 1000000016132149342504719104; + bpsToRay[6633] = 1000000016134055838371539725; + bpsToRay[6634] = 1000000016135962219620522398; + bpsToRay[6635] = 1000000016137868486265447859; + bpsToRay[6636] = 1000000016139774638320094360; + bpsToRay[6637] = 1000000016141680675798237669; + bpsToRay[6638] = 1000000016143586598713651070; + bpsToRay[6639] = 1000000016145492407080105363; + bpsToRay[6640] = 1000000016147398100911368865; + bpsToRay[6641] = 1000000016149303680221207410; + bpsToRay[6642] = 1000000016151209145023384352; + bpsToRay[6643] = 1000000016153114495331660565; + bpsToRay[6644] = 1000000016155019731159794439; + bpsToRay[6645] = 1000000016156924852521541888; + bpsToRay[6646] = 1000000016158829859430656342; + bpsToRay[6647] = 1000000016160734751900888759; + bpsToRay[6648] = 1000000016162639529945987614; + bpsToRay[6649] = 1000000016164544193579698905; + bpsToRay[6650] = 1000000016166448742815766155; + bpsToRay[6651] = 1000000016168353177667930410; + bpsToRay[6652] = 1000000016170257498149930239; + bpsToRay[6653] = 1000000016172161704275501740; + bpsToRay[6654] = 1000000016174065796058378532; + bpsToRay[6655] = 1000000016175969773512291760; + bpsToRay[6656] = 1000000016177873636650970102; + bpsToRay[6657] = 1000000016179777385488139756; + bpsToRay[6658] = 1000000016181681020037524450; + bpsToRay[6659] = 1000000016183584540312845443; + bpsToRay[6660] = 1000000016185487946327821522; + bpsToRay[6661] = 1000000016187391238096169003; + bpsToRay[6662] = 1000000016189294415631601732; + bpsToRay[6663] = 1000000016191197478947831086; + bpsToRay[6664] = 1000000016193100428058565975; + bpsToRay[6665] = 1000000016195003262977512839; + bpsToRay[6666] = 1000000016196905983718375652; + bpsToRay[6667] = 1000000016198808590294855920; + bpsToRay[6668] = 1000000016200711082720652686; + bpsToRay[6669] = 1000000016202613461009462523; + bpsToRay[6670] = 1000000016204515725174979542; + bpsToRay[6671] = 1000000016206417875230895389; + bpsToRay[6672] = 1000000016208319911190899247; + bpsToRay[6673] = 1000000016210221833068677832; + bpsToRay[6674] = 1000000016212123640877915404; + bpsToRay[6675] = 1000000016214025334632293755; + bpsToRay[6676] = 1000000016215926914345492218; + bpsToRay[6677] = 1000000016217828380031187665; + bpsToRay[6678] = 1000000016219729731703054508; + bpsToRay[6679] = 1000000016221630969374764700; + bpsToRay[6680] = 1000000016223532093059987732; + bpsToRay[6681] = 1000000016225433102772390641; + bpsToRay[6682] = 1000000016227333998525638003; + bpsToRay[6683] = 1000000016229234780333391936; + bpsToRay[6684] = 1000000016231135448209312105; + bpsToRay[6685] = 1000000016233036002167055714; + bpsToRay[6686] = 1000000016234936442220277518; + bpsToRay[6687] = 1000000016236836768382629809; + bpsToRay[6688] = 1000000016238736980667762431; + bpsToRay[6689] = 1000000016240637079089322772; + bpsToRay[6690] = 1000000016242537063660955766; + bpsToRay[6691] = 1000000016244436934396303896; + bpsToRay[6692] = 1000000016246336691309007193; + bpsToRay[6693] = 1000000016248236334412703235; + bpsToRay[6694] = 1000000016250135863721027150; + bpsToRay[6695] = 1000000016252035279247611617; + bpsToRay[6696] = 1000000016253934581006086862; + bpsToRay[6697] = 1000000016255833769010080666; + bpsToRay[6698] = 1000000016257732843273218361; + bpsToRay[6699] = 1000000016259631803809122826; + bpsToRay[6700] = 1000000016261530650631414500; + bpsToRay[6701] = 1000000016263429383753711370; + bpsToRay[6702] = 1000000016265328003189628979; + bpsToRay[6703] = 1000000016267226508952780424; + bpsToRay[6704] = 1000000016269124901056776358; + bpsToRay[6705] = 1000000016271023179515224989; + bpsToRay[6706] = 1000000016272921344341732080; + bpsToRay[6707] = 1000000016274819395549900951; + bpsToRay[6708] = 1000000016276717333153332483; + bpsToRay[6709] = 1000000016278615157165625110; + bpsToRay[6710] = 1000000016280512867600374827; + bpsToRay[6711] = 1000000016282410464471175189; + bpsToRay[6712] = 1000000016284307947791617308; + bpsToRay[6713] = 1000000016286205317575289861; + bpsToRay[6714] = 1000000016288102573835779079; + bpsToRay[6715] = 1000000016289999716586668760; + bpsToRay[6716] = 1000000016291896745841540263; + bpsToRay[6717] = 1000000016293793661613972507; + bpsToRay[6718] = 1000000016295690463917541979; + bpsToRay[6719] = 1000000016297587152765822726; + bpsToRay[6720] = 1000000016299483728172386359; + bpsToRay[6721] = 1000000016301380190150802056; + bpsToRay[6722] = 1000000016303276538714636561; + bpsToRay[6723] = 1000000016305172773877454184; + bpsToRay[6724] = 1000000016307068895652816797; + bpsToRay[6725] = 1000000016308964904054283846; + bpsToRay[6726] = 1000000016310860799095412343; + bpsToRay[6727] = 1000000016312756580789756865; + bpsToRay[6728] = 1000000016314652249150869561; + bpsToRay[6729] = 1000000016316547804192300151; + bpsToRay[6730] = 1000000016318443245927595921; + bpsToRay[6731] = 1000000016320338574370301732; + bpsToRay[6732] = 1000000016322233789533960012; + bpsToRay[6733] = 1000000016324128891432110768; + bpsToRay[6734] = 1000000016326023880078291569; + bpsToRay[6735] = 1000000016327918755486037569; + bpsToRay[6736] = 1000000016329813517668881487; + bpsToRay[6737] = 1000000016331708166640353619; + bpsToRay[6738] = 1000000016333602702413981835; + bpsToRay[6739] = 1000000016335497125003291584; + bpsToRay[6740] = 1000000016337391434421805887; + bpsToRay[6741] = 1000000016339285630683045343; + bpsToRay[6742] = 1000000016341179713800528128; + bpsToRay[6743] = 1000000016343073683787769996; + bpsToRay[6744] = 1000000016344967540658284281; + bpsToRay[6745] = 1000000016346861284425581891; + bpsToRay[6746] = 1000000016348754915103171319; + bpsToRay[6747] = 1000000016350648432704558634; + bpsToRay[6748] = 1000000016352541837243247489; + bpsToRay[6749] = 1000000016354435128732739115; + bpsToRay[6750] = 1000000016356328307186532328; + bpsToRay[6751] = 1000000016358221372618123524; + bpsToRay[6752] = 1000000016360114325041006682; + bpsToRay[6753] = 1000000016362007164468673366; + bpsToRay[6754] = 1000000016363899890914612724; + bpsToRay[6755] = 1000000016365792504392311486; + bpsToRay[6756] = 1000000016367685004915253971; + bpsToRay[6757] = 1000000016369577392496922081; + bpsToRay[6758] = 1000000016371469667150795306; + bpsToRay[6759] = 1000000016373361828890350723; + bpsToRay[6760] = 1000000016375253877729062995; + bpsToRay[6761] = 1000000016377145813680404375; + bpsToRay[6762] = 1000000016379037636757844703; + bpsToRay[6763] = 1000000016380929346974851411; + bpsToRay[6764] = 1000000016382820944344889517; + bpsToRay[6765] = 1000000016384712428881421632; + bpsToRay[6766] = 1000000016386603800597907959; + bpsToRay[6767] = 1000000016388495059507806289; + bpsToRay[6768] = 1000000016390386205624572010; + bpsToRay[6769] = 1000000016392277238961658097; + bpsToRay[6770] = 1000000016394168159532515122; + bpsToRay[6771] = 1000000016396058967350591252; + bpsToRay[6772] = 1000000016397949662429332245; + bpsToRay[6773] = 1000000016399840244782181456; + bpsToRay[6774] = 1000000016401730714422579836; + bpsToRay[6775] = 1000000016403621071363965932; + bpsToRay[6776] = 1000000016405511315619775885; + bpsToRay[6777] = 1000000016407401447203443437; + bpsToRay[6778] = 1000000016409291466128399927; + bpsToRay[6779] = 1000000016411181372408074291; + bpsToRay[6780] = 1000000016413071166055893066; + bpsToRay[6781] = 1000000016414960847085280386; + bpsToRay[6782] = 1000000016416850415509657988; + bpsToRay[6783] = 1000000016418739871342445209; + bpsToRay[6784] = 1000000016420629214597058985; + bpsToRay[6785] = 1000000016422518445286913858; + bpsToRay[6786] = 1000000016424407563425421969; + bpsToRay[6787] = 1000000016426296569025993065; + bpsToRay[6788] = 1000000016428185462102034492; + bpsToRay[6789] = 1000000016430074242666951206; + bpsToRay[6790] = 1000000016431962910734145763; + bpsToRay[6791] = 1000000016433851466317018328; + bpsToRay[6792] = 1000000016435739909428966668; + bpsToRay[6793] = 1000000016437628240083386160; + bpsToRay[6794] = 1000000016439516458293669787; + bpsToRay[6795] = 1000000016441404564073208138; + bpsToRay[6796] = 1000000016443292557435389412; + bpsToRay[6797] = 1000000016445180438393599417; + bpsToRay[6798] = 1000000016447068206961221569; + bpsToRay[6799] = 1000000016448955863151636894; + bpsToRay[6800] = 1000000016450843406978224029; + bpsToRay[6801] = 1000000016452730838454359222; + bpsToRay[6802] = 1000000016454618157593416334; + bpsToRay[6803] = 1000000016456505364408766833; + bpsToRay[6804] = 1000000016458392458913779807; + bpsToRay[6805] = 1000000016460279441121821953; + bpsToRay[6806] = 1000000016462166311046257581; + bpsToRay[6807] = 1000000016464053068700448618; + bpsToRay[6808] = 1000000016465939714097754606; + bpsToRay[6809] = 1000000016467826247251532699; + bpsToRay[6810] = 1000000016469712668175137672; + bpsToRay[6811] = 1000000016471598976881921914; + bpsToRay[6812] = 1000000016473485173385235432; + bpsToRay[6813] = 1000000016475371257698425850; + bpsToRay[6814] = 1000000016477257229834838411; + bpsToRay[6815] = 1000000016479143089807815977; + bpsToRay[6816] = 1000000016481028837630699030; + bpsToRay[6817] = 1000000016482914473316825670; + bpsToRay[6818] = 1000000016484799996879531621; + bpsToRay[6819] = 1000000016486685408332150226; + bpsToRay[6820] = 1000000016488570707688012450; + bpsToRay[6821] = 1000000016490455894960446883; + bpsToRay[6822] = 1000000016492340970162779731; + bpsToRay[6823] = 1000000016494225933308334832; + bpsToRay[6824] = 1000000016496110784410433643; + bpsToRay[6825] = 1000000016497995523482395247; + bpsToRay[6826] = 1000000016499880150537536351; + bpsToRay[6827] = 1000000016501764665589171290; + bpsToRay[6828] = 1000000016503649068650612025; + bpsToRay[6829] = 1000000016505533359735168140; + bpsToRay[6830] = 1000000016507417538856146852; + bpsToRay[6831] = 1000000016509301606026853003; + bpsToRay[6832] = 1000000016511185561260589063; + bpsToRay[6833] = 1000000016513069404570655134; + bpsToRay[6834] = 1000000016514953135970348945; + bpsToRay[6835] = 1000000016516836755472965855; + bpsToRay[6836] = 1000000016518720263091798857; + bpsToRay[6837] = 1000000016520603658840138572; + bpsToRay[6838] = 1000000016522486942731273255; + bpsToRay[6839] = 1000000016524370114778488794; + bpsToRay[6840] = 1000000016526253174995068707; + bpsToRay[6841] = 1000000016528136123394294149; + bpsToRay[6842] = 1000000016530018959989443907; + bpsToRay[6843] = 1000000016531901684793794404; + bpsToRay[6844] = 1000000016533784297820619698; + bpsToRay[6845] = 1000000016535666799083191483; + bpsToRay[6846] = 1000000016537549188594779088; + bpsToRay[6847] = 1000000016539431466368649483; + bpsToRay[6848] = 1000000016541313632418067271; + bpsToRay[6849] = 1000000016543195686756294694; + bpsToRay[6850] = 1000000016545077629396591637; + bpsToRay[6851] = 1000000016546959460352215619; + bpsToRay[6852] = 1000000016548841179636421799; + bpsToRay[6853] = 1000000016550722787262462982; + bpsToRay[6854] = 1000000016552604283243589608; + bpsToRay[6855] = 1000000016554485667593049761; + bpsToRay[6856] = 1000000016556366940324089165; + bpsToRay[6857] = 1000000016558248101449951192; + bpsToRay[6858] = 1000000016560129150983876850; + bpsToRay[6859] = 1000000016562010088939104796; + bpsToRay[6860] = 1000000016563890915328871330; + bpsToRay[6861] = 1000000016565771630166410395; + bpsToRay[6862] = 1000000016567652233464953581; + bpsToRay[6863] = 1000000016569532725237730125; + bpsToRay[6864] = 1000000016571413105497966909; + bpsToRay[6865] = 1000000016573293374258888461; + bpsToRay[6866] = 1000000016575173531533716960; + bpsToRay[6867] = 1000000016577053577335672229; + bpsToRay[6868] = 1000000016578933511677971744; + bpsToRay[6869] = 1000000016580813334573830628; + bpsToRay[6870] = 1000000016582693046036461653; + bpsToRay[6871] = 1000000016584572646079075244; + bpsToRay[6872] = 1000000016586452134714879475; + bpsToRay[6873] = 1000000016588331511957080072; + bpsToRay[6874] = 1000000016590210777818880415; + bpsToRay[6875] = 1000000016592089932313481533; + bpsToRay[6876] = 1000000016593968975454082111; + bpsToRay[6877] = 1000000016595847907253878486; + bpsToRay[6878] = 1000000016597726727726064651; + bpsToRay[6879] = 1000000016599605436883832255; + bpsToRay[6880] = 1000000016601484034740370597; + bpsToRay[6881] = 1000000016603362521308866639; + bpsToRay[6882] = 1000000016605240896602504994; + bpsToRay[6883] = 1000000016607119160634467936; + bpsToRay[6884] = 1000000016608997313417935393; + bpsToRay[6885] = 1000000016610875354966084955; + bpsToRay[6886] = 1000000016612753285292091867; + bpsToRay[6887] = 1000000016614631104409129037; + bpsToRay[6888] = 1000000016616508812330367032; + bpsToRay[6889] = 1000000016618386409068974076; + bpsToRay[6890] = 1000000016620263894638116058; + bpsToRay[6891] = 1000000016622141269050956527; + bpsToRay[6892] = 1000000016624018532320656694; + bpsToRay[6893] = 1000000016625895684460375433; + bpsToRay[6894] = 1000000016627772725483269281; + bpsToRay[6895] = 1000000016629649655402492440; + bpsToRay[6896] = 1000000016631526474231196774; + bpsToRay[6897] = 1000000016633403181982531813; + bpsToRay[6898] = 1000000016635279778669644752; + bpsToRay[6899] = 1000000016637156264305680454; + bpsToRay[6900] = 1000000016639032638903781446; + bpsToRay[6901] = 1000000016640908902477087924; + bpsToRay[6902] = 1000000016642785055038737748; + bpsToRay[6903] = 1000000016644661096601866452; + bpsToRay[6904] = 1000000016646537027179607234; + bpsToRay[6905] = 1000000016648412846785090963; + bpsToRay[6906] = 1000000016650288555431446177; + bpsToRay[6907] = 1000000016652164153131799087; + bpsToRay[6908] = 1000000016654039639899273571; + bpsToRay[6909] = 1000000016655915015746991182; + bpsToRay[6910] = 1000000016657790280688071142; + bpsToRay[6911] = 1000000016659665434735630349; + bpsToRay[6912] = 1000000016661540477902783371; + bpsToRay[6913] = 1000000016663415410202642451; + bpsToRay[6914] = 1000000016665290231648317506; + bpsToRay[6915] = 1000000016667164942252916129; + bpsToRay[6916] = 1000000016669039542029543587; + bpsToRay[6917] = 1000000016670914030991302822; + bpsToRay[6918] = 1000000016672788409151294456; + bpsToRay[6919] = 1000000016674662676522616783; + bpsToRay[6920] = 1000000016676536833118365780; + bpsToRay[6921] = 1000000016678410878951635096; + bpsToRay[6922] = 1000000016680284814035516064; + bpsToRay[6923] = 1000000016682158638383097695; + bpsToRay[6924] = 1000000016684032352007466677; + bpsToRay[6925] = 1000000016685905954921707380; + bpsToRay[6926] = 1000000016687779447138901857; + bpsToRay[6927] = 1000000016689652828672129838; + bpsToRay[6928] = 1000000016691526099534468738; + bpsToRay[6929] = 1000000016693399259738993654; + bpsToRay[6930] = 1000000016695272309298777366; + bpsToRay[6931] = 1000000016697145248226890337; + bpsToRay[6932] = 1000000016699018076536400715; + bpsToRay[6933] = 1000000016700890794240374330; + bpsToRay[6934] = 1000000016702763401351874702; + bpsToRay[6935] = 1000000016704635897883963033; + bpsToRay[6936] = 1000000016706508283849698211; + bpsToRay[6937] = 1000000016708380559262136815; + bpsToRay[6938] = 1000000016710252724134333106; + bpsToRay[6939] = 1000000016712124778479339037; + bpsToRay[6940] = 1000000016713996722310204248; + bpsToRay[6941] = 1000000016715868555639976067; + bpsToRay[6942] = 1000000016717740278481699513; + bpsToRay[6943] = 1000000016719611890848417297; + bpsToRay[6944] = 1000000016721483392753169815; + bpsToRay[6945] = 1000000016723354784208995160; + bpsToRay[6946] = 1000000016725226065228929112; + bpsToRay[6947] = 1000000016727097235826005150; + bpsToRay[6948] = 1000000016728968296013254437; + bpsToRay[6949] = 1000000016730839245803705837; + bpsToRay[6950] = 1000000016732710085210385903; + bpsToRay[6951] = 1000000016734580814246318886; + bpsToRay[6952] = 1000000016736451432924526729; + bpsToRay[6953] = 1000000016738321941258029073; + bpsToRay[6954] = 1000000016740192339259843253; + bpsToRay[6955] = 1000000016742062626942984304; + bpsToRay[6956] = 1000000016743932804320464954; + bpsToRay[6957] = 1000000016745802871405295631; + bpsToRay[6958] = 1000000016747672828210484461; + bpsToRay[6959] = 1000000016749542674749037270; + bpsToRay[6960] = 1000000016751412411033957580; + bpsToRay[6961] = 1000000016753282037078246617; + bpsToRay[6962] = 1000000016755151552894903305; + bpsToRay[6963] = 1000000016757020958496924269; + bpsToRay[6964] = 1000000016758890253897303837; + bpsToRay[6965] = 1000000016760759439109034038; + bpsToRay[6966] = 1000000016762628514145104603; + bpsToRay[6967] = 1000000016764497479018502969; + bpsToRay[6968] = 1000000016766366333742214272; + bpsToRay[6969] = 1000000016768235078329221357; + bpsToRay[6970] = 1000000016770103712792504771; + bpsToRay[6971] = 1000000016771972237145042768; + bpsToRay[6972] = 1000000016773840651399811306; + bpsToRay[6973] = 1000000016775708955569784050; + bpsToRay[6974] = 1000000016777577149667932373; + bpsToRay[6975] = 1000000016779445233707225354; + bpsToRay[6976] = 1000000016781313207700629783; + bpsToRay[6977] = 1000000016783181071661110154; + bpsToRay[6978] = 1000000016785048825601628673; + bpsToRay[6979] = 1000000016786916469535145257; + bpsToRay[6980] = 1000000016788784003474617530; + bpsToRay[6981] = 1000000016790651427433000828; + bpsToRay[6982] = 1000000016792518741423248199; + bpsToRay[6983] = 1000000016794385945458310402; + bpsToRay[6984] = 1000000016796253039551135908; + bpsToRay[6985] = 1000000016798120023714670903; + bpsToRay[6986] = 1000000016799986897961859283; + bpsToRay[6987] = 1000000016801853662305642661; + bpsToRay[6988] = 1000000016803720316758960363; + bpsToRay[6989] = 1000000016805586861334749431; + bpsToRay[6990] = 1000000016807453296045944621; + bpsToRay[6991] = 1000000016809319620905478407; + bpsToRay[6992] = 1000000016811185835926280979; + bpsToRay[6993] = 1000000016813051941121280243; + bpsToRay[6994] = 1000000016814917936503401823; + bpsToRay[6995] = 1000000016816783822085569065; + bpsToRay[6996] = 1000000016818649597880703028; + bpsToRay[6997] = 1000000016820515263901722494; + bpsToRay[6998] = 1000000016822380820161543963; + bpsToRay[6999] = 1000000016824246266673081659; + bpsToRay[7000] = 1000000016826111603449247521; + bpsToRay[7001] = 1000000016827976830502951216; + bpsToRay[7002] = 1000000016829841947847100128; + bpsToRay[7003] = 1000000016831706955494599366; + bpsToRay[7004] = 1000000016833571853458351761; + bpsToRay[7005] = 1000000016835436641751257869; + bpsToRay[7006] = 1000000016837301320386215969; + bpsToRay[7007] = 1000000016839165889376122066; + bpsToRay[7008] = 1000000016841030348733869887; + bpsToRay[7009] = 1000000016842894698472350889; + bpsToRay[7010] = 1000000016844758938604454252; + bpsToRay[7011] = 1000000016846623069143066886; + bpsToRay[7012] = 1000000016848487090101073424; + bpsToRay[7013] = 1000000016850351001491356231; + bpsToRay[7014] = 1000000016852214803326795400; + bpsToRay[7015] = 1000000016854078495620268751; + bpsToRay[7016] = 1000000016855942078384651834; + bpsToRay[7017] = 1000000016857805551632817929; + bpsToRay[7018] = 1000000016859668915377638048; + bpsToRay[7019] = 1000000016861532169631980933; + bpsToRay[7020] = 1000000016863395314408713059; + bpsToRay[7021] = 1000000016865258349720698630; + bpsToRay[7022] = 1000000016867121275580799585; + bpsToRay[7023] = 1000000016868984092001875597; + bpsToRay[7024] = 1000000016870846798996784070; + bpsToRay[7025] = 1000000016872709396578380147; + bpsToRay[7026] = 1000000016874571884759516701; + bpsToRay[7027] = 1000000016876434263553044341; + bpsToRay[7028] = 1000000016878296532971811416; + bpsToRay[7029] = 1000000016880158693028664007; + bpsToRay[7030] = 1000000016882020743736445934; + bpsToRay[7031] = 1000000016883882685107998752; + bpsToRay[7032] = 1000000016885744517156161760; + bpsToRay[7033] = 1000000016887606239893771989; + bpsToRay[7034] = 1000000016889467853333664213; + bpsToRay[7035] = 1000000016891329357488670944; + bpsToRay[7036] = 1000000016893190752371622434; + bpsToRay[7037] = 1000000016895052037995346676; + bpsToRay[7038] = 1000000016896913214372669406; + bpsToRay[7039] = 1000000016898774281516414100; + bpsToRay[7040] = 1000000016900635239439401976; + bpsToRay[7041] = 1000000016902496088154451995; + bpsToRay[7042] = 1000000016904356827674380861; + bpsToRay[7043] = 1000000016906217458012003025; + bpsToRay[7044] = 1000000016908077979180130677; + bpsToRay[7045] = 1000000016909938391191573757; + bpsToRay[7046] = 1000000016911798694059139947; + bpsToRay[7047] = 1000000016913658887795634678; + bpsToRay[7048] = 1000000016915518972413861124; + bpsToRay[7049] = 1000000016917378947926620208; + bpsToRay[7050] = 1000000016919238814346710603; + bpsToRay[7051] = 1000000016921098571686928723; + bpsToRay[7052] = 1000000016922958219960068739; + bpsToRay[7053] = 1000000016924817759178922565; + bpsToRay[7054] = 1000000016926677189356279869; + bpsToRay[7055] = 1000000016928536510504928066; + bpsToRay[7056] = 1000000016930395722637652322; + bpsToRay[7057] = 1000000016932254825767235558; + bpsToRay[7058] = 1000000016934113819906458442; + bpsToRay[7059] = 1000000016935972705068099396; + bpsToRay[7060] = 1000000016937831481264934596; + bpsToRay[7061] = 1000000016939690148509737971; + bpsToRay[7062] = 1000000016941548706815281202; + bpsToRay[7063] = 1000000016943407156194333727; + bpsToRay[7064] = 1000000016945265496659662739; + bpsToRay[7065] = 1000000016947123728224033182; + bpsToRay[7066] = 1000000016948981850900207763; + bpsToRay[7067] = 1000000016950839864700946939; + bpsToRay[7068] = 1000000016952697769639008929; + bpsToRay[7069] = 1000000016954555565727149706; + bpsToRay[7070] = 1000000016956413252978123003; + bpsToRay[7071] = 1000000016958270831404680312; + bpsToRay[7072] = 1000000016960128301019570884; + bpsToRay[7073] = 1000000016961985661835541727; + bpsToRay[7074] = 1000000016963842913865337612; + bpsToRay[7075] = 1000000016965700057121701072; + bpsToRay[7076] = 1000000016967557091617372397; + bpsToRay[7077] = 1000000016969414017365089642; + bpsToRay[7078] = 1000000016971270834377588623; + bpsToRay[7079] = 1000000016973127542667602920; + bpsToRay[7080] = 1000000016974984142247863875; + bpsToRay[7081] = 1000000016976840633131100595; + bpsToRay[7082] = 1000000016978697015330039950; + bpsToRay[7083] = 1000000016980553288857406577; + bpsToRay[7084] = 1000000016982409453725922877; + bpsToRay[7085] = 1000000016984265509948309016; + bpsToRay[7086] = 1000000016986121457537282929; + bpsToRay[7087] = 1000000016987977296505560317; + bpsToRay[7088] = 1000000016989833026865854647; + bpsToRay[7089] = 1000000016991688648630877157; + bpsToRay[7090] = 1000000016993544161813336850; + bpsToRay[7091] = 1000000016995399566425940502; + bpsToRay[7092] = 1000000016997254862481392657; + bpsToRay[7093] = 1000000016999110049992395626; + bpsToRay[7094] = 1000000017000965128971649496; + bpsToRay[7095] = 1000000017002820099431852122; + bpsToRay[7096] = 1000000017004674961385699132; + bpsToRay[7097] = 1000000017006529714845883924; + bpsToRay[7098] = 1000000017008384359825097672; + bpsToRay[7099] = 1000000017010238896336029322; + bpsToRay[7100] = 1000000017012093324391365593; + bpsToRay[7101] = 1000000017013947644003790979; + bpsToRay[7102] = 1000000017015801855185987748; + bpsToRay[7103] = 1000000017017655957950635945; + bpsToRay[7104] = 1000000017019509952310413390; + bpsToRay[7105] = 1000000017021363838277995678; + bpsToRay[7106] = 1000000017023217615866056185; + bpsToRay[7107] = 1000000017025071285087266058; + bpsToRay[7108] = 1000000017026924845954294229; + bpsToRay[7109] = 1000000017028778298479807404; + bpsToRay[7110] = 1000000017030631642676470068; + bpsToRay[7111] = 1000000017032484878556944490; + bpsToRay[7112] = 1000000017034338006133890711; + bpsToRay[7113] = 1000000017036191025419966563; + bpsToRay[7114] = 1000000017038043936427827649; + bpsToRay[7115] = 1000000017039896739170127359; + bpsToRay[7116] = 1000000017041749433659516866; + bpsToRay[7117] = 1000000017043602019908645121; + bpsToRay[7118] = 1000000017045454497930158862; + bpsToRay[7119] = 1000000017047306867736702611; + bpsToRay[7120] = 1000000017049159129340918671; + bpsToRay[7121] = 1000000017051011282755447132; + bpsToRay[7122] = 1000000017052863327992925869; + bpsToRay[7123] = 1000000017054715265065990543; + bpsToRay[7124] = 1000000017056567093987274599; + bpsToRay[7125] = 1000000017058418814769409273; + bpsToRay[7126] = 1000000017060270427425023583; + bpsToRay[7127] = 1000000017062121931966744339; + bpsToRay[7128] = 1000000017063973328407196139; + bpsToRay[7129] = 1000000017065824616759001367; + bpsToRay[7130] = 1000000017067675797034780199; + bpsToRay[7131] = 1000000017069526869247150599; + bpsToRay[7132] = 1000000017071377833408728323; + bpsToRay[7133] = 1000000017073228689532126918; + bpsToRay[7134] = 1000000017075079437629957721; + bpsToRay[7135] = 1000000017076930077714829862; + bpsToRay[7136] = 1000000017078780609799350263; + bpsToRay[7137] = 1000000017080631033896123639; + bpsToRay[7138] = 1000000017082481350017752499; + bpsToRay[7139] = 1000000017084331558176837145; + bpsToRay[7140] = 1000000017086181658385975674; + bpsToRay[7141] = 1000000017088031650657763979; + bpsToRay[7142] = 1000000017089881535004795747; + bpsToRay[7143] = 1000000017091731311439662461; + bpsToRay[7144] = 1000000017093580979974953404; + bpsToRay[7145] = 1000000017095430540623255651; + bpsToRay[7146] = 1000000017097279993397154077; + bpsToRay[7147] = 1000000017099129338309231355; + bpsToRay[7148] = 1000000017100978575372067958; + bpsToRay[7149] = 1000000017102827704598242158; + bpsToRay[7150] = 1000000017104676726000330021; + bpsToRay[7151] = 1000000017106525639590905422; + bpsToRay[7152] = 1000000017108374445382540031; + bpsToRay[7153] = 1000000017110223143387803320; + bpsToRay[7154] = 1000000017112071733619262563; + bpsToRay[7155] = 1000000017113920216089482839; + bpsToRay[7156] = 1000000017115768590811027024; + bpsToRay[7157] = 1000000017117616857796455803; + bpsToRay[7158] = 1000000017119465017058327660; + bpsToRay[7159] = 1000000017121313068609198888; + bpsToRay[7160] = 1000000017123161012461623580; + bpsToRay[7161] = 1000000017125008848628153638; + bpsToRay[7162] = 1000000017126856577121338769; + bpsToRay[7163] = 1000000017128704197953726483; + bpsToRay[7164] = 1000000017130551711137862102; + bpsToRay[7165] = 1000000017132399116686288751; + bpsToRay[7166] = 1000000017134246414611547366; + bpsToRay[7167] = 1000000017136093604926176691; + bpsToRay[7168] = 1000000017137940687642713275; + bpsToRay[7169] = 1000000017139787662773691483; + bpsToRay[7170] = 1000000017141634530331643482; + bpsToRay[7171] = 1000000017143481290329099258; + bpsToRay[7172] = 1000000017145327942778586600; + bpsToRay[7173] = 1000000017147174487692631114; + bpsToRay[7174] = 1000000017149020925083756215; + bpsToRay[7175] = 1000000017150867254964483131; + bpsToRay[7176] = 1000000017152713477347330904; + bpsToRay[7177] = 1000000017154559592244816389; + bpsToRay[7178] = 1000000017156405599669454253; + bpsToRay[7179] = 1000000017158251499633756981; + bpsToRay[7180] = 1000000017160097292150234871; + bpsToRay[7181] = 1000000017161942977231396035; + bpsToRay[7182] = 1000000017163788554889746405; + bpsToRay[7183] = 1000000017165634025137789725; + bpsToRay[7184] = 1000000017167479387988027559; + bpsToRay[7185] = 1000000017169324643452959289; + bpsToRay[7186] = 1000000017171169791545082111; + bpsToRay[7187] = 1000000017173014832276891044; + bpsToRay[7188] = 1000000017174859765660878925; + bpsToRay[7189] = 1000000017176704591709536409; + bpsToRay[7190] = 1000000017178549310435351971; + bpsToRay[7191] = 1000000017180393921850811909; + bpsToRay[7192] = 1000000017182238425968400340; + bpsToRay[7193] = 1000000017184082822800599204; + bpsToRay[7194] = 1000000017185927112359888261; + bpsToRay[7195] = 1000000017187771294658745097; + bpsToRay[7196] = 1000000017189615369709645117; + bpsToRay[7197] = 1000000017191459337525061551; + bpsToRay[7198] = 1000000017193303198117465456; + bpsToRay[7199] = 1000000017195146951499325710; + bpsToRay[7200] = 1000000017196990597683109018; + bpsToRay[7201] = 1000000017198834136681279909; + bpsToRay[7202] = 1000000017200677568506300742; + bpsToRay[7203] = 1000000017202520893170631697; + bpsToRay[7204] = 1000000017204364110686730786; + bpsToRay[7205] = 1000000017206207221067053846; + bpsToRay[7206] = 1000000017208050224324054541; + bpsToRay[7207] = 1000000017209893120470184369; + bpsToRay[7208] = 1000000017211735909517892653; + bpsToRay[7209] = 1000000017213578591479626545; + bpsToRay[7210] = 1000000017215421166367831029; + bpsToRay[7211] = 1000000017217263634194948920; + bpsToRay[7212] = 1000000017219105994973420864; + bpsToRay[7213] = 1000000017220948248715685336; + bpsToRay[7214] = 1000000017222790395434178647; + bpsToRay[7215] = 1000000017224632435141334939; + bpsToRay[7216] = 1000000017226474367849586187; + bpsToRay[7217] = 1000000017228316193571362200; + bpsToRay[7218] = 1000000017230157912319090621; + bpsToRay[7219] = 1000000017231999524105196929; + bpsToRay[7220] = 1000000017233841028942104436; + bpsToRay[7221] = 1000000017235682426842234291; + bpsToRay[7222] = 1000000017237523717818005480; + bpsToRay[7223] = 1000000017239364901881834825; + bpsToRay[7224] = 1000000017241205979046136983; + bpsToRay[7225] = 1000000017243046949323324453; + bpsToRay[7226] = 1000000017244887812725807569; + bpsToRay[7227] = 1000000017246728569265994504; + bpsToRay[7228] = 1000000017248569218956291274; + bpsToRay[7229] = 1000000017250409761809101729; + bpsToRay[7230] = 1000000017252250197836827562; + bpsToRay[7231] = 1000000017254090527051868307; + bpsToRay[7232] = 1000000017255930749466621341; + bpsToRay[7233] = 1000000017257770865093481878; + bpsToRay[7234] = 1000000017259610873944842979; + bpsToRay[7235] = 1000000017261450776033095544; + bpsToRay[7236] = 1000000017263290571370628319; + bpsToRay[7237] = 1000000017265130259969827893; + bpsToRay[7238] = 1000000017266969841843078698; + bpsToRay[7239] = 1000000017268809317002763012; + bpsToRay[7240] = 1000000017270648685461260960; + bpsToRay[7241] = 1000000017272487947230950506; + bpsToRay[7242] = 1000000017274327102324207470; + bpsToRay[7243] = 1000000017276166150753405511; + bpsToRay[7244] = 1000000017278005092530916139; + bpsToRay[7245] = 1000000017279843927669108709; + bpsToRay[7246] = 1000000017281682656180350428; + bpsToRay[7247] = 1000000017283521278077006348; + bpsToRay[7248] = 1000000017285359793371439374; + bpsToRay[7249] = 1000000017287198202076010256; + bpsToRay[7250] = 1000000017289036504203077600; + bpsToRay[7251] = 1000000017290874699764997857; + bpsToRay[7252] = 1000000017292712788774125333; + bpsToRay[7253] = 1000000017294550771242812185; + bpsToRay[7254] = 1000000017296388647183408421; + bpsToRay[7255] = 1000000017298226416608261903; + bpsToRay[7256] = 1000000017300064079529718345; + bpsToRay[7257] = 1000000017301901635960121318; + bpsToRay[7258] = 1000000017303739085911812243; + bpsToRay[7259] = 1000000017305576429397130398; + bpsToRay[7260] = 1000000017307413666428412915; + bpsToRay[7261] = 1000000017309250797017994782; + bpsToRay[7262] = 1000000017311087821178208846; + bpsToRay[7263] = 1000000017312924738921385806; + bpsToRay[7264] = 1000000017314761550259854221; + bpsToRay[7265] = 1000000017316598255205940510; + bpsToRay[7266] = 1000000017318434853771968943; + bpsToRay[7267] = 1000000017320271345970261657; + bpsToRay[7268] = 1000000017322107731813138642; + bpsToRay[7269] = 1000000017323944011312917751; + bpsToRay[7270] = 1000000017325780184481914696; + bpsToRay[7271] = 1000000017327616251332443050; + bpsToRay[7272] = 1000000017329452211876814248; + bpsToRay[7273] = 1000000017331288066127337584; + bpsToRay[7274] = 1000000017333123814096320217; + bpsToRay[7275] = 1000000017334959455796067168; + bpsToRay[7276] = 1000000017336794991238881320; + bpsToRay[7277] = 1000000017338630420437063420; + bpsToRay[7278] = 1000000017340465743402912081; + bpsToRay[7279] = 1000000017342300960148723777; + bpsToRay[7280] = 1000000017344136070686792852; + bpsToRay[7281] = 1000000017345971075029411511; + bpsToRay[7282] = 1000000017347805973188869827; + bpsToRay[7283] = 1000000017349640765177455741; + bpsToRay[7284] = 1000000017351475451007455060; + bpsToRay[7285] = 1000000017353310030691151455; + bpsToRay[7286] = 1000000017355144504240826473; + bpsToRay[7287] = 1000000017356978871668759522; + bpsToRay[7288] = 1000000017358813132987227884; + bpsToRay[7289] = 1000000017360647288208506708; + bpsToRay[7290] = 1000000017362481337344869013; + bpsToRay[7291] = 1000000017364315280408585691; + bpsToRay[7292] = 1000000017366149117411925502; + bpsToRay[7293] = 1000000017367982848367155079; + bpsToRay[7294] = 1000000017369816473286538927; + bpsToRay[7295] = 1000000017371649992182339426; + bpsToRay[7296] = 1000000017373483405066816824; + bpsToRay[7297] = 1000000017375316711952229244; + bpsToRay[7298] = 1000000017377149912850832687; + bpsToRay[7299] = 1000000017378983007774881025; + bpsToRay[7300] = 1000000017380815996736626004; + bpsToRay[7301] = 1000000017382648879748317248; + bpsToRay[7302] = 1000000017384481656822202255; + bpsToRay[7303] = 1000000017386314327970526403; + bpsToRay[7304] = 1000000017388146893205532943; + bpsToRay[7305] = 1000000017389979352539463003; + bpsToRay[7306] = 1000000017391811705984555594; + bpsToRay[7307] = 1000000017393643953553047601; + bpsToRay[7308] = 1000000017395476095257173788; + bpsToRay[7309] = 1000000017397308131109166801; + bpsToRay[7310] = 1000000017399140061121257164; + bpsToRay[7311] = 1000000017400971885305673282; + bpsToRay[7312] = 1000000017402803603674641440; + bpsToRay[7313] = 1000000017404635216240385805; + bpsToRay[7314] = 1000000017406466723015128428; + bpsToRay[7315] = 1000000017408298124011089238; + bpsToRay[7316] = 1000000017410129419240486051; + bpsToRay[7317] = 1000000017411960608715534563; + bpsToRay[7318] = 1000000017413791692448448355; + bpsToRay[7319] = 1000000017415622670451438895; + bpsToRay[7320] = 1000000017417453542736715530; + bpsToRay[7321] = 1000000017419284309316485497; + bpsToRay[7322] = 1000000017421114970202953919; + bpsToRay[7323] = 1000000017422945525408323801; + bpsToRay[7324] = 1000000017424775974944796039; + bpsToRay[7325] = 1000000017426606318824569415; + bpsToRay[7326] = 1000000017428436557059840598; + bpsToRay[7327] = 1000000017430266689662804144; + bpsToRay[7328] = 1000000017432096716645652500; + bpsToRay[7329] = 1000000017433926638020576003; + bpsToRay[7330] = 1000000017435756453799762877; + bpsToRay[7331] = 1000000017437586163995399235; + bpsToRay[7332] = 1000000017439415768619669087; + bpsToRay[7333] = 1000000017441245267684754328; + bpsToRay[7334] = 1000000017443074661202834746; + bpsToRay[7335] = 1000000017444903949186088022; + bpsToRay[7336] = 1000000017446733131646689731; + bpsToRay[7337] = 1000000017448562208596813336; + bpsToRay[7338] = 1000000017450391180048630201; + bpsToRay[7339] = 1000000017452220046014309577; + bpsToRay[7340] = 1000000017454048806506018613; + bpsToRay[7341] = 1000000017455877461535922354; + bpsToRay[7342] = 1000000017457706011116183737; + bpsToRay[7343] = 1000000017459534455258963600; + bpsToRay[7344] = 1000000017461362793976420670; + bpsToRay[7345] = 1000000017463191027280711580; + bpsToRay[7346] = 1000000017465019155183990853; + bpsToRay[7347] = 1000000017466847177698410915; + bpsToRay[7348] = 1000000017468675094836122086; + bpsToRay[7349] = 1000000017470502906609272589; + bpsToRay[7350] = 1000000017472330613030008543; + bpsToRay[7351] = 1000000017474158214110473970; + bpsToRay[7352] = 1000000017475985709862810789; + bpsToRay[7353] = 1000000017477813100299158823; + bpsToRay[7354] = 1000000017479640385431655794; + bpsToRay[7355] = 1000000017481467565272437328; + bpsToRay[7356] = 1000000017483294639833636950; + bpsToRay[7357] = 1000000017485121609127386092; + bpsToRay[7358] = 1000000017486948473165814085; + bpsToRay[7359] = 1000000017488775231961048167; + bpsToRay[7360] = 1000000017490601885525213478; + bpsToRay[7361] = 1000000017492428433870433064; + bpsToRay[7362] = 1000000017494254877008827878; + bpsToRay[7363] = 1000000017496081214952516772; + bpsToRay[7364] = 1000000017497907447713616513; + bpsToRay[7365] = 1000000017499733575304241768; + bpsToRay[7366] = 1000000017501559597736505115; + bpsToRay[7367] = 1000000017503385515022517037; + bpsToRay[7368] = 1000000017505211327174385925; + bpsToRay[7369] = 1000000017507037034204218081; + bpsToRay[7370] = 1000000017508862636124117716; + bpsToRay[7371] = 1000000017510688132946186946; + bpsToRay[7372] = 1000000017512513524682525802; + bpsToRay[7373] = 1000000017514338811345232225; + bpsToRay[7374] = 1000000017516163992946402063; + bpsToRay[7375] = 1000000017517989069498129080; + bpsToRay[7376] = 1000000017519814041012504950; + bpsToRay[7377] = 1000000017521638907501619258; + bpsToRay[7378] = 1000000017523463668977559505; + bpsToRay[7379] = 1000000017525288325452411102; + bpsToRay[7380] = 1000000017527112876938257378; + bpsToRay[7381] = 1000000017528937323447179572; + bpsToRay[7382] = 1000000017530761664991256840; + bpsToRay[7383] = 1000000017532585901582566253; + bpsToRay[7384] = 1000000017534410033233182798; + bpsToRay[7385] = 1000000017536234059955179379; + bpsToRay[7386] = 1000000017538057981760626814; + bpsToRay[7387] = 1000000017539881798661593840; + bpsToRay[7388] = 1000000017541705510670147114; + bpsToRay[7389] = 1000000017543529117798351206; + bpsToRay[7390] = 1000000017545352620058268609; + bpsToRay[7391] = 1000000017547176017461959733; + bpsToRay[7392] = 1000000017548999310021482909; + bpsToRay[7393] = 1000000017550822497748894386; + bpsToRay[7394] = 1000000017552645580656248336; + bpsToRay[7395] = 1000000017554468558755596849; + bpsToRay[7396] = 1000000017556291432058989941; + bpsToRay[7397] = 1000000017558114200578475546; + bpsToRay[7398] = 1000000017559936864326099522; + bpsToRay[7399] = 1000000017561759423313905650; + bpsToRay[7400] = 1000000017563581877553935633; + bpsToRay[7401] = 1000000017565404227058229101; + bpsToRay[7402] = 1000000017567226471838823606; + bpsToRay[7403] = 1000000017569048611907754624; + bpsToRay[7404] = 1000000017570870647277055559; + bpsToRay[7405] = 1000000017572692577958757738; + bpsToRay[7406] = 1000000017574514403964890419; + bpsToRay[7407] = 1000000017576336125307480780; + bpsToRay[7408] = 1000000017578157741998553932; + bpsToRay[7409] = 1000000017579979254050132911; + bpsToRay[7410] = 1000000017581800661474238681; + bpsToRay[7411] = 1000000017583621964282890136; + bpsToRay[7412] = 1000000017585443162488104098; + bpsToRay[7413] = 1000000017587264256101895320; + bpsToRay[7414] = 1000000017589085245136276485; + bpsToRay[7415] = 1000000017590906129603258203; + bpsToRay[7416] = 1000000017592726909514849021; + bpsToRay[7417] = 1000000017594547584883055411; + bpsToRay[7418] = 1000000017596368155719881784; + bpsToRay[7419] = 1000000017598188622037330478; + bpsToRay[7420] = 1000000017600008983847401766; + bpsToRay[7421] = 1000000017601829241162093854; + bpsToRay[7422] = 1000000017603649393993402882; + bpsToRay[7423] = 1000000017605469442353322925; + bpsToRay[7424] = 1000000017607289386253845993; + bpsToRay[7425] = 1000000017609109225706962029; + bpsToRay[7426] = 1000000017610928960724658915; + bpsToRay[7427] = 1000000017612748591318922467; + bpsToRay[7428] = 1000000017614568117501736438; + bpsToRay[7429] = 1000000017616387539285082519; + bpsToRay[7430] = 1000000017618206856680940339; + bpsToRay[7431] = 1000000017620026069701287465; + bpsToRay[7432] = 1000000017621845178358099399; + bpsToRay[7433] = 1000000017623664182663349590; + bpsToRay[7434] = 1000000017625483082629009418; + bpsToRay[7435] = 1000000017627301878267048209; + bpsToRay[7436] = 1000000017629120569589433226; + bpsToRay[7437] = 1000000017630939156608129676; + bpsToRay[7438] = 1000000017632757639335100704; + bpsToRay[7439] = 1000000017634576017782307401; + bpsToRay[7440] = 1000000017636394291961708797; + bpsToRay[7441] = 1000000017638212461885261865; + bpsToRay[7442] = 1000000017640030527564921525; + bpsToRay[7443] = 1000000017641848489012640637; + bpsToRay[7444] = 1000000017643666346240370005; + bpsToRay[7445] = 1000000017645484099260058384; + bpsToRay[7446] = 1000000017647301748083652465; + bpsToRay[7447] = 1000000017649119292723096891; + bpsToRay[7448] = 1000000017650936733190334250; + bpsToRay[7449] = 1000000017652754069497305076; + bpsToRay[7450] = 1000000017654571301655947851; + bpsToRay[7451] = 1000000017656388429678199002; + bpsToRay[7452] = 1000000017658205453575992908; + bpsToRay[7453] = 1000000017660022373361261892; + bpsToRay[7454] = 1000000017661839189045936232; + bpsToRay[7455] = 1000000017663655900641944150; + bpsToRay[7456] = 1000000017665472508161211819; + bpsToRay[7457] = 1000000017667289011615663365; + bpsToRay[7458] = 1000000017669105411017220864; + bpsToRay[7459] = 1000000017670921706377804340; + bpsToRay[7460] = 1000000017672737897709331773; + bpsToRay[7461] = 1000000017674553985023719095; + bpsToRay[7462] = 1000000017676369968332880187; + bpsToRay[7463] = 1000000017678185847648726887; + bpsToRay[7464] = 1000000017680001622983168986; + bpsToRay[7465] = 1000000017681817294348114228; + bpsToRay[7466] = 1000000017683632861755468312; + bpsToRay[7467] = 1000000017685448325217134893; + bpsToRay[7468] = 1000000017687263684745015581; + bpsToRay[7469] = 1000000017689078940351009940; + bpsToRay[7470] = 1000000017690894092047015496; + bpsToRay[7471] = 1000000017692709139844927726; + bpsToRay[7472] = 1000000017694524083756640068; + bpsToRay[7473] = 1000000017696338923794043916; + bpsToRay[7474] = 1000000017698153659969028624; + bpsToRay[7475] = 1000000017699968292293481503; + bpsToRay[7476] = 1000000017701782820779287826; + bpsToRay[7477] = 1000000017703597245438330823; + bpsToRay[7478] = 1000000017705411566282491686; + bpsToRay[7479] = 1000000017707225783323649568; + bpsToRay[7480] = 1000000017709039896573681579; + bpsToRay[7481] = 1000000017710853906044462798; + bpsToRay[7482] = 1000000017712667811747866261; + bpsToRay[7483] = 1000000017714481613695762967; + bpsToRay[7484] = 1000000017716295311900021878; + bpsToRay[7485] = 1000000017718108906372509921; + bpsToRay[7486] = 1000000017719922397125091988; + bpsToRay[7487] = 1000000017721735784169630931; + bpsToRay[7488] = 1000000017723549067517987571; + bpsToRay[7489] = 1000000017725362247182020693; + bpsToRay[7490] = 1000000017727175323173587048; + bpsToRay[7491] = 1000000017728988295504541353; + bpsToRay[7492] = 1000000017730801164186736290; + bpsToRay[7493] = 1000000017732613929232022514; + bpsToRay[7494] = 1000000017734426590652248641; + bpsToRay[7495] = 1000000017736239148459261259; + bpsToRay[7496] = 1000000017738051602664904924; + bpsToRay[7497] = 1000000017739863953281022159; + bpsToRay[7498] = 1000000017741676200319453460; + bpsToRay[7499] = 1000000017743488343792037292; + bpsToRay[7500] = 1000000017745300383710610088; + bpsToRay[7501] = 1000000017747112320087006255; + bpsToRay[7502] = 1000000017748924152933058170; + bpsToRay[7503] = 1000000017750735882260596182; + bpsToRay[7504] = 1000000017752547508081448613; + bpsToRay[7505] = 1000000017754359030407441756; + bpsToRay[7506] = 1000000017756170449250399880; + bpsToRay[7507] = 1000000017757981764622145224; + bpsToRay[7508] = 1000000017759792976534498007; + bpsToRay[7509] = 1000000017761604084999276416; + bpsToRay[7510] = 1000000017763415090028296618; + bpsToRay[7511] = 1000000017765225991633372753; + bpsToRay[7512] = 1000000017767036789826316939; + bpsToRay[7513] = 1000000017768847484618939268; + bpsToRay[7514] = 1000000017770658076023047811; + bpsToRay[7515] = 1000000017772468564050448615; + bpsToRay[7516] = 1000000017774278948712945708; + bpsToRay[7517] = 1000000017776089230022341092; + bpsToRay[7518] = 1000000017777899407990434751; + bpsToRay[7519] = 1000000017779709482629024645; + bpsToRay[7520] = 1000000017781519453949906719; + bpsToRay[7521] = 1000000017783329321964874894; + bpsToRay[7522] = 1000000017785139086685721072; + bpsToRay[7523] = 1000000017786948748124235137; + bpsToRay[7524] = 1000000017788758306292204955; + bpsToRay[7525] = 1000000017790567761201416374; + bpsToRay[7526] = 1000000017792377112863653223; + bpsToRay[7527] = 1000000017794186361290697316; + bpsToRay[7528] = 1000000017795995506494328448; + bpsToRay[7529] = 1000000017797804548486324401; + bpsToRay[7530] = 1000000017799613487278460940; + bpsToRay[7531] = 1000000017801422322882511813; + bpsToRay[7532] = 1000000017803231055310248755; + bpsToRay[7533] = 1000000017805039684573441487; + bpsToRay[7534] = 1000000017806848210683857715; + bpsToRay[7535] = 1000000017808656633653263133; + bpsToRay[7536] = 1000000017810464953493421421; + bpsToRay[7537] = 1000000017812273170216094248; + bpsToRay[7538] = 1000000017814081283833041270; + bpsToRay[7539] = 1000000017815889294356020130; + bpsToRay[7540] = 1000000017817697201796786462; + bpsToRay[7541] = 1000000017819505006167093890; + bpsToRay[7542] = 1000000017821312707478694026; + bpsToRay[7543] = 1000000017823120305743336473; + bpsToRay[7544] = 1000000017824927800972768824; + bpsToRay[7545] = 1000000017826735193178736665; + bpsToRay[7546] = 1000000017828542482372983573; + bpsToRay[7547] = 1000000017830349668567251118; + bpsToRay[7548] = 1000000017832156751773278858; + bpsToRay[7549] = 1000000017833963732002804350; + bpsToRay[7550] = 1000000017835770609267563142; + bpsToRay[7551] = 1000000017837577383579288776; + bpsToRay[7552] = 1000000017839384054949712789; + bpsToRay[7553] = 1000000017841190623390564711; + bpsToRay[7554] = 1000000017842997088913572069; + bpsToRay[7555] = 1000000017844803451530460387; + bpsToRay[7556] = 1000000017846609711252953183; + bpsToRay[7557] = 1000000017848415868092771972; + bpsToRay[7558] = 1000000017850221922061636268; + bpsToRay[7559] = 1000000017852027873171263580; + bpsToRay[7560] = 1000000017853833721433369417; + bpsToRay[7561] = 1000000017855639466859667286; + bpsToRay[7562] = 1000000017857445109461868694; + bpsToRay[7563] = 1000000017859250649251683144; + bpsToRay[7564] = 1000000017861056086240818144; + bpsToRay[7565] = 1000000017862861420440979199; + bpsToRay[7566] = 1000000017864666651863869815; + bpsToRay[7567] = 1000000017866471780521191500; + bpsToRay[7568] = 1000000017868276806424643763; + bpsToRay[7569] = 1000000017870081729585924118; + bpsToRay[7570] = 1000000017871886550016728077; + bpsToRay[7571] = 1000000017873691267728749159; + bpsToRay[7572] = 1000000017875495882733678884; + bpsToRay[7573] = 1000000017877300395043206778; + bpsToRay[7574] = 1000000017879104804669020371; + bpsToRay[7575] = 1000000017880909111622805195; + bpsToRay[7576] = 1000000017882713315916244793; + bpsToRay[7577] = 1000000017884517417561020708; + bpsToRay[7578] = 1000000017886321416568812494; + bpsToRay[7579] = 1000000017888125312951297708; + bpsToRay[7580] = 1000000017889929106720151917; + bpsToRay[7581] = 1000000017891732797887048694; + bpsToRay[7582] = 1000000017893536386463659622; + bpsToRay[7583] = 1000000017895339872461654288; + bpsToRay[7584] = 1000000017897143255892700294; + bpsToRay[7585] = 1000000017898946536768463247; + bpsToRay[7586] = 1000000017900749715100606767; + bpsToRay[7587] = 1000000017902552790900792481; + bpsToRay[7588] = 1000000017904355764180680030; + bpsToRay[7589] = 1000000017906158634951927065; + bpsToRay[7590] = 1000000017907961403226189248; + bpsToRay[7591] = 1000000017909764069015120253; + bpsToRay[7592] = 1000000017911566632330371770; + bpsToRay[7593] = 1000000017913369093183593497; + bpsToRay[7594] = 1000000017915171451586433149; + bpsToRay[7595] = 1000000017916973707550536454; + bpsToRay[7596] = 1000000017918775861087547154; + bpsToRay[7597] = 1000000017920577912209107007; + bpsToRay[7598] = 1000000017922379860926855785; + bpsToRay[7599] = 1000000017924181707252431276; + bpsToRay[7600] = 1000000017925983451197469286; + bpsToRay[7601] = 1000000017927785092773603635; + bpsToRay[7602] = 1000000017929586631992466162; + bpsToRay[7603] = 1000000017931388068865686724; + bpsToRay[7604] = 1000000017933189403404893193; + bpsToRay[7605] = 1000000017934990635621711463; + bpsToRay[7606] = 1000000017936791765527765445; + bpsToRay[7607] = 1000000017938592793134677070; + bpsToRay[7608] = 1000000017940393718454066288; + bpsToRay[7609] = 1000000017942194541497551072; + bpsToRay[7610] = 1000000017943995262276747410; + bpsToRay[7611] = 1000000017945795880803269319; + bpsToRay[7612] = 1000000017947596397088728831; + bpsToRay[7613] = 1000000017949396811144736003; + bpsToRay[7614] = 1000000017951197122982898913; + bpsToRay[7615] = 1000000017952997332614823666; + bpsToRay[7616] = 1000000017954797440052114387; + bpsToRay[7617] = 1000000017956597445306373223; + bpsToRay[7618] = 1000000017958397348389200349; + bpsToRay[7619] = 1000000017960197149312193963; + bpsToRay[7620] = 1000000017961996848086950291; + bpsToRay[7621] = 1000000017963796444725063580; + bpsToRay[7622] = 1000000017965595939238126106; + bpsToRay[7623] = 1000000017967395331637728171; + bpsToRay[7624] = 1000000017969194621935458105; + bpsToRay[7625] = 1000000017970993810142902264; + bpsToRay[7626] = 1000000017972792896271645032; + bpsToRay[7627] = 1000000017974591880333268823; + bpsToRay[7628] = 1000000017976390762339354077; + bpsToRay[7629] = 1000000017978189542301479266; + bpsToRay[7630] = 1000000017979988220231220891; + bpsToRay[7631] = 1000000017981786796140153482; + bpsToRay[7632] = 1000000017983585270039849600; + bpsToRay[7633] = 1000000017985383641941879838; + bpsToRay[7634] = 1000000017987181911857812820; + bpsToRay[7635] = 1000000017988980079799215201; + bpsToRay[7636] = 1000000017990778145777651670; + bpsToRay[7637] = 1000000017992576109804684946; + bpsToRay[7638] = 1000000017994373971891875786; + bpsToRay[7639] = 1000000017996171732050782977; + bpsToRay[7640] = 1000000017997969390292963342; + bpsToRay[7641] = 1000000017999766946629971735; + bpsToRay[7642] = 1000000018001564401073361051; + bpsToRay[7643] = 1000000018003361753634682215; + bpsToRay[7644] = 1000000018005159004325484191; + bpsToRay[7645] = 1000000018006956153157313979; + bpsToRay[7646] = 1000000018008753200141716615; + bpsToRay[7647] = 1000000018010550145290235173; + bpsToRay[7648] = 1000000018012346988614410765; + bpsToRay[7649] = 1000000018014143730125782540; + bpsToRay[7650] = 1000000018015940369835887686; + bpsToRay[7651] = 1000000018017736907756261431; + bpsToRay[7652] = 1000000018019533343898437042; + bpsToRay[7653] = 1000000018021329678273945825; + bpsToRay[7654] = 1000000018023125910894317128; + bpsToRay[7655] = 1000000018024922041771078339; + bpsToRay[7656] = 1000000018026718070915754887; + bpsToRay[7657] = 1000000018028513998339870242; + bpsToRay[7658] = 1000000018030309824054945918; + bpsToRay[7659] = 1000000018032105548072501472; + bpsToRay[7660] = 1000000018033901170404054502; + bpsToRay[7661] = 1000000018035696691061120650; + bpsToRay[7662] = 1000000018037492110055213602; + bpsToRay[7663] = 1000000018039287427397845090; + bpsToRay[7664] = 1000000018041082643100524888; + bpsToRay[7665] = 1000000018042877757174760818; + bpsToRay[7666] = 1000000018044672769632058746; + bpsToRay[7667] = 1000000018046467680483922585; + bpsToRay[7668] = 1000000018048262489741854293; + bpsToRay[7669] = 1000000018050057197417353878; + bpsToRay[7670] = 1000000018051851803521919393; + bpsToRay[7671] = 1000000018053646308067046939; + bpsToRay[7672] = 1000000018055440711064230668; + bpsToRay[7673] = 1000000018057235012524962777; + bpsToRay[7674] = 1000000018059029212460733515; + bpsToRay[7675] = 1000000018060823310883031179; + bpsToRay[7676] = 1000000018062617307803342118; + bpsToRay[7677] = 1000000018064411203233150730; + bpsToRay[7678] = 1000000018066204997183939464; + bpsToRay[7679] = 1000000018067998689667188822; + bpsToRay[7680] = 1000000018069792280694377358; + bpsToRay[7681] = 1000000018071585770276981673; + bpsToRay[7682] = 1000000018073379158426476430; + bpsToRay[7683] = 1000000018075172445154334336; + bpsToRay[7684] = 1000000018076965630472026159; + bpsToRay[7685] = 1000000018078758714391020716; + bpsToRay[7686] = 1000000018080551696922784882; + bpsToRay[7687] = 1000000018082344578078783584; + bpsToRay[7688] = 1000000018084137357870479807; + bpsToRay[7689] = 1000000018085930036309334591; + bpsToRay[7690] = 1000000018087722613406807031; + bpsToRay[7691] = 1000000018089515089174354279; + bpsToRay[7692] = 1000000018091307463623431547; + bpsToRay[7693] = 1000000018093099736765492103; + bpsToRay[7694] = 1000000018094891908611987271; + bpsToRay[7695] = 1000000018096683979174366435; + bpsToRay[7696] = 1000000018098475948464077039; + bpsToRay[7697] = 1000000018100267816492564585; + bpsToRay[7698] = 1000000018102059583271272636; + bpsToRay[7699] = 1000000018103851248811642814; + bpsToRay[7700] = 1000000018105642813125114801; + bpsToRay[7701] = 1000000018107434276223126344; + bpsToRay[7702] = 1000000018109225638117113246; + bpsToRay[7703] = 1000000018111016898818509377; + bpsToRay[7704] = 1000000018112808058338746667; + bpsToRay[7705] = 1000000018114599116689255107; + bpsToRay[7706] = 1000000018116390073881462757; + bpsToRay[7707] = 1000000018118180929926795735; + bpsToRay[7708] = 1000000018119971684836678225; + bpsToRay[7709] = 1000000018121762338622532479; + bpsToRay[7710] = 1000000018123552891295778807; + bpsToRay[7711] = 1000000018125343342867835592; + bpsToRay[7712] = 1000000018127133693350119278; + bpsToRay[7713] = 1000000018128923942754044379; + bpsToRay[7714] = 1000000018130714091091023470; + bpsToRay[7715] = 1000000018132504138372467200; + bpsToRay[7716] = 1000000018134294084609784283; + bpsToRay[7717] = 1000000018136083929814381499; + bpsToRay[7718] = 1000000018137873673997663698; + bpsToRay[7719] = 1000000018139663317171033802; + bpsToRay[7720] = 1000000018141452859345892798; + bpsToRay[7721] = 1000000018143242300533639746; + bpsToRay[7722] = 1000000018145031640745671772; + bpsToRay[7723] = 1000000018146820879993384079; + bpsToRay[7724] = 1000000018148610018288169936; + bpsToRay[7725] = 1000000018150399055641420686; + bpsToRay[7726] = 1000000018152187992064525743; + bpsToRay[7727] = 1000000018153976827568872596; + bpsToRay[7728] = 1000000018155765562165846803; + bpsToRay[7729] = 1000000018157554195866831997; + bpsToRay[7730] = 1000000018159342728683209886; + bpsToRay[7731] = 1000000018161131160626360252; + bpsToRay[7732] = 1000000018162919491707660948; + bpsToRay[7733] = 1000000018164707721938487908; + bpsToRay[7734] = 1000000018166495851330215138; + bpsToRay[7735] = 1000000018168283879894214720; + bpsToRay[7736] = 1000000018170071807641856811; + bpsToRay[7737] = 1000000018171859634584509651; + bpsToRay[7738] = 1000000018173647360733539548; + bpsToRay[7739] = 1000000018175434986100310896; + bpsToRay[7740] = 1000000018177222510696186163; + bpsToRay[7741] = 1000000018179009934532525896; + bpsToRay[7742] = 1000000018180797257620688721; + bpsToRay[7743] = 1000000018182584479972031343; + bpsToRay[7744] = 1000000018184371601597908550; + bpsToRay[7745] = 1000000018186158622509673205; + bpsToRay[7746] = 1000000018187945542718676256; + bpsToRay[7747] = 1000000018189732362236266731; + bpsToRay[7748] = 1000000018191519081073791739; + bpsToRay[7749] = 1000000018193305699242596471; + bpsToRay[7750] = 1000000018195092216754024201; + bpsToRay[7751] = 1000000018196878633619416285; + bpsToRay[7752] = 1000000018198664949850112165; + bpsToRay[7753] = 1000000018200451165457449362; + bpsToRay[7754] = 1000000018202237280452763485; + bpsToRay[7755] = 1000000018204023294847388227; + bpsToRay[7756] = 1000000018205809208652655365; + bpsToRay[7757] = 1000000018207595021879894762; + bpsToRay[7758] = 1000000018209380734540434368; + bpsToRay[7759] = 1000000018211166346645600216; + bpsToRay[7760] = 1000000018212951858206716428; + bpsToRay[7761] = 1000000018214737269235105217; + bpsToRay[7762] = 1000000018216522579742086876; + bpsToRay[7763] = 1000000018218307789738979791; + bpsToRay[7764] = 1000000018220092899237100435; + bpsToRay[7765] = 1000000018221877908247763371; + bpsToRay[7766] = 1000000018223662816782281250; + bpsToRay[7767] = 1000000018225447624851964814; + bpsToRay[7768] = 1000000018227232332468122895; + bpsToRay[7769] = 1000000018229016939642062413; + bpsToRay[7770] = 1000000018230801446385088385; + bpsToRay[7771] = 1000000018232585852708503911; + bpsToRay[7772] = 1000000018234370158623610192; + bpsToRay[7773] = 1000000018236154364141706515; + bpsToRay[7774] = 1000000018237938469274090263; + bpsToRay[7775] = 1000000018239722474032056911; + bpsToRay[7776] = 1000000018241506378426900026; + bpsToRay[7777] = 1000000018243290182469911273; + bpsToRay[7778] = 1000000018245073886172380408; + bpsToRay[7779] = 1000000018246857489545595283; + bpsToRay[7780] = 1000000018248640992600841846; + bpsToRay[7781] = 1000000018250424395349404142; + bpsToRay[7782] = 1000000018252207697802564308; + bpsToRay[7783] = 1000000018253990899971602583; + bpsToRay[7784] = 1000000018255774001867797298; + bpsToRay[7785] = 1000000018257557003502424884; + bpsToRay[7786] = 1000000018259339904886759871; + bpsToRay[7787] = 1000000018261122706032074886; + bpsToRay[7788] = 1000000018262905406949640654; + bpsToRay[7789] = 1000000018264688007650726000; + bpsToRay[7790] = 1000000018266470508146597849; + bpsToRay[7791] = 1000000018268252908448521228; + bpsToRay[7792] = 1000000018270035208567759259; + bpsToRay[7793] = 1000000018271817408515573169; + bpsToRay[7794] = 1000000018273599508303222287; + bpsToRay[7795] = 1000000018275381507941964042; + bpsToRay[7796] = 1000000018277163407443053964; + bpsToRay[7797] = 1000000018278945206817745690; + bpsToRay[7798] = 1000000018280726906077290954; + bpsToRay[7799] = 1000000018282508505232939599; + bpsToRay[7800] = 1000000018284290004295939569; + bpsToRay[7801] = 1000000018286071403277536912; + bpsToRay[7802] = 1000000018287852702188975783; + bpsToRay[7803] = 1000000018289633901041498440; + bpsToRay[7804] = 1000000018291414999846345249; + bpsToRay[7805] = 1000000018293195998614754679; + bpsToRay[7806] = 1000000018294976897357963307; + bpsToRay[7807] = 1000000018296757696087205817; + bpsToRay[7808] = 1000000018298538394813715001; + bpsToRay[7809] = 1000000018300318993548721757; + bpsToRay[7810] = 1000000018302099492303455093; + bpsToRay[7811] = 1000000018303879891089142124; + bpsToRay[7812] = 1000000018305660189917008076; + bpsToRay[7813] = 1000000018307440388798276281; + bpsToRay[7814] = 1000000018309220487744168184; + bpsToRay[7815] = 1000000018311000486765903339; + bpsToRay[7816] = 1000000018312780385874699412; + bpsToRay[7817] = 1000000018314560185081772178; + bpsToRay[7818] = 1000000018316339884398335526; + bpsToRay[7819] = 1000000018318119483835601454; + bpsToRay[7820] = 1000000018319898983404780074; + bpsToRay[7821] = 1000000018321678383117079613; + bpsToRay[7822] = 1000000018323457682983706407; + bpsToRay[7823] = 1000000018325236883015864909; + bpsToRay[7824] = 1000000018327015983224757684; + bpsToRay[7825] = 1000000018328794983621585414; + bpsToRay[7826] = 1000000018330573884217546893; + bpsToRay[7827] = 1000000018332352685023839031; + bpsToRay[7828] = 1000000018334131386051656857; + bpsToRay[7829] = 1000000018335909987312193512; + bpsToRay[7830] = 1000000018337688488816640255; + bpsToRay[7831] = 1000000018339466890576186465; + bpsToRay[7832] = 1000000018341245192602019632; + bpsToRay[7833] = 1000000018343023394905325372; + bpsToRay[7834] = 1000000018344801497497287412; + bpsToRay[7835] = 1000000018346579500389087603; + bpsToRay[7836] = 1000000018348357403591905911; + bpsToRay[7837] = 1000000018350135207116920426; + bpsToRay[7838] = 1000000018351912910975307354; + bpsToRay[7839] = 1000000018353690515178241024; + bpsToRay[7840] = 1000000018355468019736893884; + bpsToRay[7841] = 1000000018357245424662436505; + bpsToRay[7842] = 1000000018359022729966037580; + bpsToRay[7843] = 1000000018360799935658863920; + bpsToRay[7844] = 1000000018362577041752080465; + bpsToRay[7845] = 1000000018364354048256850272; + bpsToRay[7846] = 1000000018366130955184334526; + bpsToRay[7847] = 1000000018367907762545692533; + bpsToRay[7848] = 1000000018369684470352081722; + bpsToRay[7849] = 1000000018371461078614657652; + bpsToRay[7850] = 1000000018373237587344574003; + bpsToRay[7851] = 1000000018375013996552982578; + bpsToRay[7852] = 1000000018376790306251033313; + bpsToRay[7853] = 1000000018378566516449874264; + bpsToRay[7854] = 1000000018380342627160651618; + bpsToRay[7855] = 1000000018382118638394509685; + bpsToRay[7856] = 1000000018383894550162590906; + bpsToRay[7857] = 1000000018385670362476035850; + bpsToRay[7858] = 1000000018387446075345983212; + bpsToRay[7859] = 1000000018389221688783569817; + bpsToRay[7860] = 1000000018390997202799930621; + bpsToRay[7861] = 1000000018392772617406198706; + bpsToRay[7862] = 1000000018394547932613505288; + bpsToRay[7863] = 1000000018396323148432979711; + bpsToRay[7864] = 1000000018398098264875749451; + bpsToRay[7865] = 1000000018399873281952940114; + bpsToRay[7866] = 1000000018401648199675675439; + bpsToRay[7867] = 1000000018403423018055077298; + bpsToRay[7868] = 1000000018405197737102265694; + bpsToRay[7869] = 1000000018406972356828358763; + bpsToRay[7870] = 1000000018408746877244472776; + bpsToRay[7871] = 1000000018410521298361722136; + bpsToRay[7872] = 1000000018412295620191219382; + bpsToRay[7873] = 1000000018414069842744075188; + bpsToRay[7874] = 1000000018415843966031398359; + bpsToRay[7875] = 1000000018417617990064295840; + bpsToRay[7876] = 1000000018419391914853872712; + bpsToRay[7877] = 1000000018421165740411232189; + bpsToRay[7878] = 1000000018422939466747475623; + bpsToRay[7879] = 1000000018424713093873702506; + bpsToRay[7880] = 1000000018426486621801010465; + bpsToRay[7881] = 1000000018428260050540495264; + bpsToRay[7882] = 1000000018430033380103250808; + bpsToRay[7883] = 1000000018431806610500369140; + bpsToRay[7884] = 1000000018433579741742940441; + bpsToRay[7885] = 1000000018435352773842053034; + bpsToRay[7886] = 1000000018437125706808793381; + bpsToRay[7887] = 1000000018438898540654246083; + bpsToRay[7888] = 1000000018440671275389493885; + bpsToRay[7889] = 1000000018442443911025617670; + bpsToRay[7890] = 1000000018444216447573696466; + bpsToRay[7891] = 1000000018445988885044807442; + bpsToRay[7892] = 1000000018447761223450025908; + bpsToRay[7893] = 1000000018449533462800425319; + bpsToRay[7894] = 1000000018451305603107077273; + bpsToRay[7895] = 1000000018453077644381051511; + bpsToRay[7896] = 1000000018454849586633415920; + bpsToRay[7897] = 1000000018456621429875236530; + bpsToRay[7898] = 1000000018458393174117577515; + bpsToRay[7899] = 1000000018460164819371501200; + bpsToRay[7900] = 1000000018461936365648068049; + bpsToRay[7901] = 1000000018463707812958336676; + bpsToRay[7902] = 1000000018465479161313363842; + bpsToRay[7903] = 1000000018467250410724204454; + bpsToRay[7904] = 1000000018469021561201911568; + bpsToRay[7905] = 1000000018470792612757536386; + bpsToRay[7906] = 1000000018472563565402128258; + bpsToRay[7907] = 1000000018474334419146734687; + bpsToRay[7908] = 1000000018476105174002401321; + bpsToRay[7909] = 1000000018477875829980171960; + bpsToRay[7910] = 1000000018479646387091088551; + bpsToRay[7911] = 1000000018481416845346191196; + bpsToRay[7912] = 1000000018483187204756518145; + bpsToRay[7913] = 1000000018484957465333105800; + bpsToRay[7914] = 1000000018486727627086988714; + bpsToRay[7915] = 1000000018488497690029199592; + bpsToRay[7916] = 1000000018490267654170769294; + bpsToRay[7917] = 1000000018492037519522726829; + bpsToRay[7918] = 1000000018493807286096099365; + bpsToRay[7919] = 1000000018495576953901912217; + bpsToRay[7920] = 1000000018497346522951188860; + bpsToRay[7921] = 1000000018499115993254950919; + bpsToRay[7922] = 1000000018500885364824218178; + bpsToRay[7923] = 1000000018502654637670008573; + bpsToRay[7924] = 1000000018504423811803338199; + bpsToRay[7925] = 1000000018506192887235221305; + bpsToRay[7926] = 1000000018507961863976670296; + bpsToRay[7927] = 1000000018509730742038695738; + bpsToRay[7928] = 1000000018511499521432306350; + bpsToRay[7929] = 1000000018513268202168509012; + bpsToRay[7930] = 1000000018515036784258308760; + bpsToRay[7931] = 1000000018516805267712708791; + bpsToRay[7932] = 1000000018518573652542710459; + bpsToRay[7933] = 1000000018520341938759313279; + bpsToRay[7934] = 1000000018522110126373514925; + bpsToRay[7935] = 1000000018523878215396311232; + bpsToRay[7936] = 1000000018525646205838696196; + bpsToRay[7937] = 1000000018527414097711661974; + bpsToRay[7938] = 1000000018529181891026198882; + bpsToRay[7939] = 1000000018530949585793295404; + bpsToRay[7940] = 1000000018532717182023938179; + bpsToRay[7941] = 1000000018534484679729112016; + bpsToRay[7942] = 1000000018536252078919799882; + bpsToRay[7943] = 1000000018538019379606982909; + bpsToRay[7944] = 1000000018539786581801640396; + bpsToRay[7945] = 1000000018541553685514749800; + bpsToRay[7946] = 1000000018543320690757286750; + bpsToRay[7947] = 1000000018545087597540225037; + bpsToRay[7948] = 1000000018546854405874536615; + bpsToRay[7949] = 1000000018548621115771191610; + bpsToRay[7950] = 1000000018550387727241158310; + bpsToRay[7951] = 1000000018552154240295403172; + bpsToRay[7952] = 1000000018553920654944890818; + bpsToRay[7953] = 1000000018555686971200584040; + bpsToRay[7954] = 1000000018557453189073443800; + bpsToRay[7955] = 1000000018559219308574429223; + bpsToRay[7956] = 1000000018560985329714497605; + bpsToRay[7957] = 1000000018562751252504604416; + bpsToRay[7958] = 1000000018564517076955703290; + bpsToRay[7959] = 1000000018566282803078746033; + bpsToRay[7960] = 1000000018568048430884682622; + bpsToRay[7961] = 1000000018569813960384461207; + bpsToRay[7962] = 1000000018571579391589028103; + bpsToRay[7963] = 1000000018573344724509327805; + bpsToRay[7964] = 1000000018575109959156302976; + bpsToRay[7965] = 1000000018576875095540894448; + bpsToRay[7966] = 1000000018578640133674041234; + bpsToRay[7967] = 1000000018580405073566680515; + bpsToRay[7968] = 1000000018582169915229747647; + bpsToRay[7969] = 1000000018583934658674176160; + bpsToRay[7970] = 1000000018585699303910897760; + bpsToRay[7971] = 1000000018587463850950842326; + bpsToRay[7972] = 1000000018589228299804937915; + bpsToRay[7973] = 1000000018590992650484110758; + bpsToRay[7974] = 1000000018592756902999285262; + bpsToRay[7975] = 1000000018594521057361384012; + bpsToRay[7976] = 1000000018596285113581327769; + bpsToRay[7977] = 1000000018598049071670035472; + bpsToRay[7978] = 1000000018599812931638424240; + bpsToRay[7979] = 1000000018601576693497409365; + bpsToRay[7980] = 1000000018603340357257904322; + bpsToRay[7981] = 1000000018605103922930820766; + bpsToRay[7982] = 1000000018606867390527068528; + bpsToRay[7983] = 1000000018608630760057555620; + bpsToRay[7984] = 1000000018610394031533188235; + bpsToRay[7985] = 1000000018612157204964870748; + bpsToRay[7986] = 1000000018613920280363505711; + bpsToRay[7987] = 1000000018615683257739993862; + bpsToRay[7988] = 1000000018617446137105234120; + bpsToRay[7989] = 1000000018619208918470123584; + bpsToRay[7990] = 1000000018620971601845557538; + bpsToRay[7991] = 1000000018622734187242429447; + bpsToRay[7992] = 1000000018624496674671630963; + bpsToRay[7993] = 1000000018626259064144051920; + bpsToRay[7994] = 1000000018628021355670580334; + bpsToRay[7995] = 1000000018629783549262102411; + bpsToRay[7996] = 1000000018631545644929502537; + bpsToRay[7997] = 1000000018633307642683663287; + bpsToRay[7998] = 1000000018635069542535465422; + bpsToRay[7999] = 1000000018636831344495787885; + bpsToRay[8000] = 1000000018638593048575507813; + bpsToRay[8001] = 1000000018640354654785500524; + bpsToRay[8002] = 1000000018642116163136639525; + bpsToRay[8003] = 1000000018643877573639796513; + bpsToRay[8004] = 1000000018645638886305841373; + bpsToRay[8005] = 1000000018647400101145642177; + bpsToRay[8006] = 1000000018649161218170065187; + bpsToRay[8007] = 1000000018650922237389974856; + bpsToRay[8008] = 1000000018652683158816233826; + bpsToRay[8009] = 1000000018654443982459702927; + bpsToRay[8010] = 1000000018656204708331241185; + bpsToRay[8011] = 1000000018657965336441705812; + bpsToRay[8012] = 1000000018659725866801952216; + bpsToRay[8013] = 1000000018661486299422833994; + bpsToRay[8014] = 1000000018663246634315202936; + bpsToRay[8015] = 1000000018665006871489909025; + bpsToRay[8016] = 1000000018666767010957800439; + bpsToRay[8017] = 1000000018668527052729723547; + bpsToRay[8018] = 1000000018670286996816522913; + bpsToRay[8019] = 1000000018672046843229041295; + bpsToRay[8020] = 1000000018673806591978119648; + bpsToRay[8021] = 1000000018675566243074597119; + bpsToRay[8022] = 1000000018677325796529311054; + bpsToRay[8023] = 1000000018679085252353096991; + bpsToRay[8024] = 1000000018680844610556788668; + bpsToRay[8025] = 1000000018682603871151218019; + bpsToRay[8026] = 1000000018684363034147215174; + bpsToRay[8027] = 1000000018686122099555608460; + bpsToRay[8028] = 1000000018687881067387224406; + bpsToRay[8029] = 1000000018689639937652887737; + bpsToRay[8030] = 1000000018691398710363421374; + bpsToRay[8031] = 1000000018693157385529646441; + bpsToRay[8032] = 1000000018694915963162382261; + bpsToRay[8033] = 1000000018696674443272446357; + bpsToRay[8034] = 1000000018698432825870654450; + bpsToRay[8035] = 1000000018700191110967820466; + bpsToRay[8036] = 1000000018701949298574756529; + bpsToRay[8037] = 1000000018703707388702272967; + bpsToRay[8038] = 1000000018705465381361178307; + bpsToRay[8039] = 1000000018707223276562279280; + bpsToRay[8040] = 1000000018708981074316380821; + bpsToRay[8041] = 1000000018710738774634286066; + bpsToRay[8042] = 1000000018712496377526796358; + bpsToRay[8043] = 1000000018714253883004711240; + bpsToRay[8044] = 1000000018716011291078828461; + bpsToRay[8045] = 1000000018717768601759943976; + bpsToRay[8046] = 1000000018719525815058851943; + bpsToRay[8047] = 1000000018721282930986344728; + bpsToRay[8048] = 1000000018723039949553212902; + bpsToRay[8049] = 1000000018724796870770245242; + bpsToRay[8050] = 1000000018726553694648228732; + bpsToRay[8051] = 1000000018728310421197948562; + bpsToRay[8052] = 1000000018730067050430188132; + bpsToRay[8053] = 1000000018731823582355729050; + bpsToRay[8054] = 1000000018733580016985351129; + bpsToRay[8055] = 1000000018735336354329832394; + bpsToRay[8056] = 1000000018737092594399949079; + bpsToRay[8057] = 1000000018738848737206475625; + bpsToRay[8058] = 1000000018740604782760184687; + bpsToRay[8059] = 1000000018742360731071847127; + bpsToRay[8060] = 1000000018744116582152232018; + bpsToRay[8061] = 1000000018745872336012106646; + bpsToRay[8062] = 1000000018747627992662236508; + bpsToRay[8063] = 1000000018749383552113385312; + bpsToRay[8064] = 1000000018751139014376314979; + bpsToRay[8065] = 1000000018752894379461785643; + bpsToRay[8066] = 1000000018754649647380555651; + bpsToRay[8067] = 1000000018756404818143381562; + bpsToRay[8068] = 1000000018758159891761018152; + bpsToRay[8069] = 1000000018759914868244218410; + bpsToRay[8070] = 1000000018761669747603733537; + bpsToRay[8071] = 1000000018763424529850312954; + bpsToRay[8072] = 1000000018765179214994704293; + bpsToRay[8073] = 1000000018766933803047653406; + bpsToRay[8074] = 1000000018768688294019904359; + bpsToRay[8075] = 1000000018770442687922199432; + bpsToRay[8076] = 1000000018772196984765279129; + bpsToRay[8077] = 1000000018773951184559882166; + bpsToRay[8078] = 1000000018775705287316745477; + bpsToRay[8079] = 1000000018777459293046604218; + bpsToRay[8080] = 1000000018779213201760191760; + bpsToRay[8081] = 1000000018780967013468239695; + bpsToRay[8082] = 1000000018782720728181477833; + bpsToRay[8083] = 1000000018784474345910634206; + bpsToRay[8084] = 1000000018786227866666435065; + bpsToRay[8085] = 1000000018787981290459604881; + bpsToRay[8086] = 1000000018789734617300866347; + bpsToRay[8087] = 1000000018791487847200940377; + bpsToRay[8088] = 1000000018793240980170546107; + bpsToRay[8089] = 1000000018794994016220400896; + bpsToRay[8090] = 1000000018796746955361220324; + bpsToRay[8091] = 1000000018798499797603718194; + bpsToRay[8092] = 1000000018800252542958606535; + bpsToRay[8093] = 1000000018802005191436595596; + bpsToRay[8094] = 1000000018803757743048393855; + bpsToRay[8095] = 1000000018805510197804708009; + bpsToRay[8096] = 1000000018807262555716242984; + bpsToRay[8097] = 1000000018809014816793701930; + bpsToRay[8098] = 1000000018810766981047786222; + bpsToRay[8099] = 1000000018812519048489195463; + bpsToRay[8100] = 1000000018814271019128627481; + bpsToRay[8101] = 1000000018816022892976778332; + bpsToRay[8102] = 1000000018817774670044342299; + bpsToRay[8103] = 1000000018819526350342011891; + bpsToRay[8104] = 1000000018821277933880477847; + bpsToRay[8105] = 1000000018823029420670429136; + bpsToRay[8106] = 1000000018824780810722552952; + bpsToRay[8107] = 1000000018826532104047534720; + bpsToRay[8108] = 1000000018828283300656058095; + bpsToRay[8109] = 1000000018830034400558804964; + bpsToRay[8110] = 1000000018831785403766455440; + bpsToRay[8111] = 1000000018833536310289687871; + bpsToRay[8112] = 1000000018835287120139178833; + bpsToRay[8113] = 1000000018837037833325603137; + bpsToRay[8114] = 1000000018838788449859633821; + bpsToRay[8115] = 1000000018840538969751942163; + bpsToRay[8116] = 1000000018842289393013197665; + bpsToRay[8117] = 1000000018844039719654068068; + bpsToRay[8118] = 1000000018845789949685219346; + bpsToRay[8119] = 1000000018847540083117315706; + bpsToRay[8120] = 1000000018849290119961019588; + bpsToRay[8121] = 1000000018851040060226991670; + bpsToRay[8122] = 1000000018852789903925890862; + bpsToRay[8123] = 1000000018854539651068374310; + bpsToRay[8124] = 1000000018856289301665097399; + bpsToRay[8125] = 1000000018858038855726713746; + bpsToRay[8126] = 1000000018859788313263875208; + bpsToRay[8127] = 1000000018861537674287231877; + bpsToRay[8128] = 1000000018863286938807432083; + bpsToRay[8129] = 1000000018865036106835122396; + bpsToRay[8130] = 1000000018866785178380947620; + bpsToRay[8131] = 1000000018868534153455550800; + bpsToRay[8132] = 1000000018870283032069573223; + bpsToRay[8133] = 1000000018872031814233654409; + bpsToRay[8134] = 1000000018873780499958432124; + bpsToRay[8135] = 1000000018875529089254542368; + bpsToRay[8136] = 1000000018877277582132619389; + bpsToRay[8137] = 1000000018879025978603295669; + bpsToRay[8138] = 1000000018880774278677201936; + bpsToRay[8139] = 1000000018882522482364967158; + bpsToRay[8140] = 1000000018884270589677218543; + bpsToRay[8141] = 1000000018886018600624581547; + bpsToRay[8142] = 1000000018887766515217679862; + bpsToRay[8143] = 1000000018889514333467135430; + bpsToRay[8144] = 1000000018891262055383568433; + bpsToRay[8145] = 1000000018893009680977597295; + bpsToRay[8146] = 1000000018894757210259838691; + bpsToRay[8147] = 1000000018896504643240907534; + bpsToRay[8148] = 1000000018898251979931416987; + bpsToRay[8149] = 1000000018899999220341978457; + bpsToRay[8150] = 1000000018901746364483201594; + bpsToRay[8151] = 1000000018903493412365694300; + bpsToRay[8152] = 1000000018905240364000062719; + bpsToRay[8153] = 1000000018906987219396911245; + bpsToRay[8154] = 1000000018908733978566842519; + bpsToRay[8155] = 1000000018910480641520457429; + bpsToRay[8156] = 1000000018912227208268355112; + bpsToRay[8157] = 1000000018913973678821132954; + bpsToRay[8158] = 1000000018915720053189386589; + bpsToRay[8159] = 1000000018917466331383709901; + bpsToRay[8160] = 1000000018919212513414695026; + bpsToRay[8161] = 1000000018920958599292932347; + bpsToRay[8162] = 1000000018922704589029010497; + bpsToRay[8163] = 1000000018924450482633516364; + bpsToRay[8164] = 1000000018926196280117035085; + bpsToRay[8165] = 1000000018927941981490150050; + bpsToRay[8166] = 1000000018929687586763442899; + bpsToRay[8167] = 1000000018931433095947493526; + bpsToRay[8168] = 1000000018933178509052880078; + bpsToRay[8169] = 1000000018934923826090178954; + bpsToRay[8170] = 1000000018936669047069964810; + bpsToRay[8171] = 1000000018938414172002810552; + bpsToRay[8172] = 1000000018940159200899287344; + bpsToRay[8173] = 1000000018941904133769964603; + bpsToRay[8174] = 1000000018943648970625410000; + bpsToRay[8175] = 1000000018945393711476189463; + bpsToRay[8176] = 1000000018947138356332867178; + bpsToRay[8177] = 1000000018948882905206005585; + bpsToRay[8178] = 1000000018950627358106165381; + bpsToRay[8179] = 1000000018952371715043905520; + bpsToRay[8180] = 1000000018954115976029783215; + bpsToRay[8181] = 1000000018955860141074353935; + bpsToRay[8182] = 1000000018957604210188171410; + bpsToRay[8183] = 1000000018959348183381787625; + bpsToRay[8184] = 1000000018961092060665752828; + bpsToRay[8185] = 1000000018962835842050615522; + bpsToRay[8186] = 1000000018964579527546922474; + bpsToRay[8187] = 1000000018966323117165218711; + bpsToRay[8188] = 1000000018968066610916047517; + bpsToRay[8189] = 1000000018969810008809950439; + bpsToRay[8190] = 1000000018971553310857467288; + bpsToRay[8191] = 1000000018973296517069136132; + bpsToRay[8192] = 1000000018975039627455493305; + bpsToRay[8193] = 1000000018976782642027073402; + bpsToRay[8194] = 1000000018978525560794409280; + bpsToRay[8195] = 1000000018980268383768032061; + bpsToRay[8196] = 1000000018982011110958471130; + bpsToRay[8197] = 1000000018983753742376254135; + bpsToRay[8198] = 1000000018985496278031906990; + bpsToRay[8199] = 1000000018987238717935953874; + bpsToRay[8200] = 1000000018988981062098917230; + bpsToRay[8201] = 1000000018990723310531317765; + bpsToRay[8202] = 1000000018992465463243674457; + bpsToRay[8203] = 1000000018994207520246504546; + bpsToRay[8204] = 1000000018995949481550323540; + bpsToRay[8205] = 1000000018997691347165645214; + bpsToRay[8206] = 1000000018999433117102981611; + bpsToRay[8207] = 1000000019001174791372843041; + bpsToRay[8208] = 1000000019002916369985738082; + bpsToRay[8209] = 1000000019004657852952173583; + bpsToRay[8210] = 1000000019006399240282654660; + bpsToRay[8211] = 1000000019008140531987684699; + bpsToRay[8212] = 1000000019009881728077765354; + bpsToRay[8213] = 1000000019011622828563396552; + bpsToRay[8214] = 1000000019013363833455076488; + bpsToRay[8215] = 1000000019015104742763301630; + bpsToRay[8216] = 1000000019016845556498566716; + bpsToRay[8217] = 1000000019018586274671364757; + bpsToRay[8218] = 1000000019020326897292187034; + bpsToRay[8219] = 1000000019022067424371523101; + bpsToRay[8220] = 1000000019023807855919860787; + bpsToRay[8221] = 1000000019025548191947686191; + bpsToRay[8222] = 1000000019027288432465483687; + bpsToRay[8223] = 1000000019029028577483735925; + bpsToRay[8224] = 1000000019030768627012923824; + bpsToRay[8225] = 1000000019032508581063526585; + bpsToRay[8226] = 1000000019034248439646021677; + bpsToRay[8227] = 1000000019035988202770884848; + bpsToRay[8228] = 1000000019037727870448590123; + bpsToRay[8229] = 1000000019039467442689609800; + bpsToRay[8230] = 1000000019041206919504414455; + bpsToRay[8231] = 1000000019042946300903472942; + bpsToRay[8232] = 1000000019044685586897252392; + bpsToRay[8233] = 1000000019046424777496218212; + bpsToRay[8234] = 1000000019048163872710834089; + bpsToRay[8235] = 1000000019049902872551561987; + bpsToRay[8236] = 1000000019051641777028862150; + bpsToRay[8237] = 1000000019053380586153193101; + bpsToRay[8238] = 1000000019055119299935011644; + bpsToRay[8239] = 1000000019056857918384772859; + bpsToRay[8240] = 1000000019058596441512930110; + bpsToRay[8241] = 1000000019060334869329935041; + bpsToRay[8242] = 1000000019062073201846237576; + bpsToRay[8243] = 1000000019063811439072285921; + bpsToRay[8244] = 1000000019065549581018526566; + bpsToRay[8245] = 1000000019067287627695404278; + bpsToRay[8246] = 1000000019069025579113362113; + bpsToRay[8247] = 1000000019070763435282841406; + bpsToRay[8248] = 1000000019072501196214281776; + bpsToRay[8249] = 1000000019074238861918121125; + bpsToRay[8250] = 1000000019075976432404795643; + bpsToRay[8251] = 1000000019077713907684739801; + bpsToRay[8252] = 1000000019079451287768386354; + bpsToRay[8253] = 1000000019081188572666166345; + bpsToRay[8254] = 1000000019082925762388509101; + bpsToRay[8255] = 1000000019084662856945842236; + bpsToRay[8256] = 1000000019086399856348591650; + bpsToRay[8257] = 1000000019088136760607181530; + bpsToRay[8258] = 1000000019089873569732034349; + bpsToRay[8259] = 1000000019091610283733570869; + bpsToRay[8260] = 1000000019093346902622210139; + bpsToRay[8261] = 1000000019095083426408369496; + bpsToRay[8262] = 1000000019096819855102464568; + bpsToRay[8263] = 1000000019098556188714909268; + bpsToRay[8264] = 1000000019100292427256115802; + bpsToRay[8265] = 1000000019102028570736494664; + bpsToRay[8266] = 1000000019103764619166454637; + bpsToRay[8267] = 1000000019105500572556402798; + bpsToRay[8268] = 1000000019107236430916744512; + bpsToRay[8269] = 1000000019108972194257883436; + bpsToRay[8270] = 1000000019110707862590221519; + bpsToRay[8271] = 1000000019112443435924159001; + bpsToRay[8272] = 1000000019114178914270094416; + bpsToRay[8273] = 1000000019115914297638424590; + bpsToRay[8274] = 1000000019117649586039544643; + bpsToRay[8275] = 1000000019119384779483847985; + bpsToRay[8276] = 1000000019121119877981726323; + bpsToRay[8277] = 1000000019122854881543569660; + bpsToRay[8278] = 1000000019124589790179766288; + bpsToRay[8279] = 1000000019126324603900702800; + bpsToRay[8280] = 1000000019128059322716764080; + bpsToRay[8281] = 1000000019129793946638333310; + bpsToRay[8282] = 1000000019131528475675791968; + bpsToRay[8283] = 1000000019133262909839519827; + bpsToRay[8284] = 1000000019134997249139894958; + bpsToRay[8285] = 1000000019136731493587293730; + bpsToRay[8286] = 1000000019138465643192090809; + bpsToRay[8287] = 1000000019140199697964659157; + bpsToRay[8288] = 1000000019141933657915370038; + bpsToRay[8289] = 1000000019143667523054593010; + bpsToRay[8290] = 1000000019145401293392695935; + bpsToRay[8291] = 1000000019147134968940044972; + bpsToRay[8292] = 1000000019148868549707004581; + bpsToRay[8293] = 1000000019150602035703937519; + bpsToRay[8294] = 1000000019152335426941204848; + bpsToRay[8295] = 1000000019154068723429165929; + bpsToRay[8296] = 1000000019155801925178178423; + bpsToRay[8297] = 1000000019157535032198598294; + bpsToRay[8298] = 1000000019159268044500779809; + bpsToRay[8299] = 1000000019161000962095075535; + bpsToRay[8300] = 1000000019162733784991836346; + bpsToRay[8301] = 1000000019164466513201411414; + bpsToRay[8302] = 1000000019166199146734148217; + bpsToRay[8303] = 1000000019167931685600392538; + bpsToRay[8304] = 1000000019169664129810488463; + bpsToRay[8305] = 1000000019171396479374778382; + bpsToRay[8306] = 1000000019173128734303602993; + bpsToRay[8307] = 1000000019174860894607301295; + bpsToRay[8308] = 1000000019176592960296210597; + bpsToRay[8309] = 1000000019178324931380666510; + bpsToRay[8310] = 1000000019180056807871002956; + bpsToRay[8311] = 1000000019181788589777552160; + bpsToRay[8312] = 1000000019183520277110644657; + bpsToRay[8313] = 1000000019185251869880609289; + bpsToRay[8314] = 1000000019186983368097773204; + bpsToRay[8315] = 1000000019188714771772461861; + bpsToRay[8316] = 1000000019190446080914999025; + bpsToRay[8317] = 1000000019192177295535706774; + bpsToRay[8318] = 1000000019193908415644905492; + bpsToRay[8319] = 1000000019195639441252913873; + bpsToRay[8320] = 1000000019197370372370048924; + bpsToRay[8321] = 1000000019199101209006625961; + bpsToRay[8322] = 1000000019200831951172958609; + bpsToRay[8323] = 1000000019202562598879358809; + bpsToRay[8324] = 1000000019204293152136136807; + bpsToRay[8325] = 1000000019206023610953601168; + bpsToRay[8326] = 1000000019207753975342058765; + bpsToRay[8327] = 1000000019209484245311814785; + bpsToRay[8328] = 1000000019211214420873172728; + bpsToRay[8329] = 1000000019212944502036434409; + bpsToRay[8330] = 1000000019214674488811899953; + bpsToRay[8331] = 1000000019216404381209867805; + bpsToRay[8332] = 1000000019218134179240634720; + bpsToRay[8333] = 1000000019219863882914495771; + bpsToRay[8334] = 1000000019221593492241744342; + bpsToRay[8335] = 1000000019223323007232672138; + bpsToRay[8336] = 1000000019225052427897569177; + bpsToRay[8337] = 1000000019226781754246723793; + bpsToRay[8338] = 1000000019228510986290422641; + bpsToRay[8339] = 1000000019230240124038950687; + bpsToRay[8340] = 1000000019231969167502591220; + bpsToRay[8341] = 1000000019233698116691625845; + bpsToRay[8342] = 1000000019235426971616334484; + bpsToRay[8343] = 1000000019237155732286995379; + bpsToRay[8344] = 1000000019238884398713885090; + bpsToRay[8345] = 1000000019240612970907278498; + bpsToRay[8346] = 1000000019242341448877448803; + bpsToRay[8347] = 1000000019244069832634667526; + bpsToRay[8348] = 1000000019245798122189204505; + bpsToRay[8349] = 1000000019247526317551327904; + bpsToRay[8350] = 1000000019249254418731304205; + bpsToRay[8351] = 1000000019250982425739398211; + bpsToRay[8352] = 1000000019252710338585873049; + bpsToRay[8353] = 1000000019254438157280990169; + bpsToRay[8354] = 1000000019256165881835009342; + bpsToRay[8355] = 1000000019257893512258188661; + bpsToRay[8356] = 1000000019259621048560784543; + bpsToRay[8357] = 1000000019261348490753051732; + bpsToRay[8358] = 1000000019263075838845243292; + bpsToRay[8359] = 1000000019264803092847610615; + bpsToRay[8360] = 1000000019266530252770403415; + bpsToRay[8361] = 1000000019268257318623869732; + bpsToRay[8362] = 1000000019269984290418255933; + bpsToRay[8363] = 1000000019271711168163806709; + bpsToRay[8364] = 1000000019273437951870765080; + bpsToRay[8365] = 1000000019275164641549372390; + bpsToRay[8366] = 1000000019276891237209868311; + bpsToRay[8367] = 1000000019278617738862490844; + bpsToRay[8368] = 1000000019280344146517476314; + bpsToRay[8369] = 1000000019282070460185059378; + bpsToRay[8370] = 1000000019283796679875473021; + bpsToRay[8371] = 1000000019285522805598948554; + bpsToRay[8372] = 1000000019287248837365715621; + bpsToRay[8373] = 1000000019288974775186002193; + bpsToRay[8374] = 1000000019290700619070034572; + bpsToRay[8375] = 1000000019292426369028037391; + bpsToRay[8376] = 1000000019294152025070233613; + bpsToRay[8377] = 1000000019295877587206844530; + bpsToRay[8378] = 1000000019297603055448089770; + bpsToRay[8379] = 1000000019299328429804187289; + bpsToRay[8380] = 1000000019301053710285353377; + bpsToRay[8381] = 1000000019302778896901802656; + bpsToRay[8382] = 1000000019304503989663748081; + bpsToRay[8383] = 1000000019306228988581400940; + bpsToRay[8384] = 1000000019307953893664970854; + bpsToRay[8385] = 1000000019309678704924665780; + bpsToRay[8386] = 1000000019311403422370692008; + bpsToRay[8387] = 1000000019313128046013254162; + bpsToRay[8388] = 1000000019314852575862555202; + bpsToRay[8389] = 1000000019316577011928796425; + bpsToRay[8390] = 1000000019318301354222177460; + bpsToRay[8391] = 1000000019320025602752896275; + bpsToRay[8392] = 1000000019321749757531149174; + bpsToRay[8393] = 1000000019323473818567130798; + bpsToRay[8394] = 1000000019325197785871034125; + bpsToRay[8395] = 1000000019326921659453050469; + bpsToRay[8396] = 1000000019328645439323369486; + bpsToRay[8397] = 1000000019330369125492179166; + bpsToRay[8398] = 1000000019332092717969665839; + bpsToRay[8399] = 1000000019333816216766014177; + bpsToRay[8400] = 1000000019335539621891407188; + bpsToRay[8401] = 1000000019337262933356026219; + bpsToRay[8402] = 1000000019338986151170050961; + bpsToRay[8403] = 1000000019340709275343659442; + bpsToRay[8404] = 1000000019342432305887028033; + bpsToRay[8405] = 1000000019344155242810331446; + bpsToRay[8406] = 1000000019345878086123742733; + bpsToRay[8407] = 1000000019347600835837433289; + bpsToRay[8408] = 1000000019349323491961572852; + bpsToRay[8409] = 1000000019351046054506329501; + bpsToRay[8410] = 1000000019352768523481869660; + bpsToRay[8411] = 1000000019354490898898358095; + bpsToRay[8412] = 1000000019356213180765957915; + bpsToRay[8413] = 1000000019357935369094830575; + bpsToRay[8414] = 1000000019359657463895135874; + bpsToRay[8415] = 1000000019361379465177031955; + bpsToRay[8416] = 1000000019363101372950675305; + bpsToRay[8417] = 1000000019364823187226220761; + bpsToRay[8418] = 1000000019366544908013821502; + bpsToRay[8419] = 1000000019368266535323629053; + bpsToRay[8420] = 1000000019369988069165793289; + bpsToRay[8421] = 1000000019371709509550462428; + bpsToRay[8422] = 1000000019373430856487783037; + bpsToRay[8423] = 1000000019375152109987900033; + bpsToRay[8424] = 1000000019376873270060956677; + bpsToRay[8425] = 1000000019378594336717094581; + bpsToRay[8426] = 1000000019380315309966453706; + bpsToRay[8427] = 1000000019382036189819172359; + bpsToRay[8428] = 1000000019383756976285387201; + bpsToRay[8429] = 1000000019385477669375233239; + bpsToRay[8430] = 1000000019387198269098843832; + bpsToRay[8431] = 1000000019388918775466350690; + bpsToRay[8432] = 1000000019390639188487883872; + bpsToRay[8433] = 1000000019392359508173571791; + bpsToRay[8434] = 1000000019394079734533541209; + bpsToRay[8435] = 1000000019395799867577917242; + bpsToRay[8436] = 1000000019397519907316823356; + bpsToRay[8437] = 1000000019399239853760381372; + bpsToRay[8438] = 1000000019400959706918711464; + bpsToRay[8439] = 1000000019402679466801932157; + bpsToRay[8440] = 1000000019404399133420160333; + bpsToRay[8441] = 1000000019406118706783511225; + bpsToRay[8442] = 1000000019407838186902098423; + bpsToRay[8443] = 1000000019409557573786033870; + bpsToRay[8444] = 1000000019411276867445427867; + bpsToRay[8445] = 1000000019412996067890389067; + bpsToRay[8446] = 1000000019414715175131024480; + bpsToRay[8447] = 1000000019416434189177439474; + bpsToRay[8448] = 1000000019418153110039737771; + bpsToRay[8449] = 1000000019419871937728021454; + bpsToRay[8450] = 1000000019421590672252390959; + bpsToRay[8451] = 1000000019423309313622945081; + bpsToRay[8452] = 1000000019425027861849780974; + bpsToRay[8453] = 1000000019426746316942994151; + bpsToRay[8454] = 1000000019428464678912678481; + bpsToRay[8455] = 1000000019430182947768926195; + bpsToRay[8456] = 1000000019431901123521827882; + bpsToRay[8457] = 1000000019433619206181472490; + bpsToRay[8458] = 1000000019435337195757947331; + bpsToRay[8459] = 1000000019437055092261338072; + bpsToRay[8460] = 1000000019438772895701728744; + bpsToRay[8461] = 1000000019440490606089201741; + bpsToRay[8462] = 1000000019442208223433837815; + bpsToRay[8463] = 1000000019443925747745716082; + bpsToRay[8464] = 1000000019445643179034914020; + bpsToRay[8465] = 1000000019447360517311507470; + bpsToRay[8466] = 1000000019449077762585570634; + bpsToRay[8467] = 1000000019450794914867176081; + bpsToRay[8468] = 1000000019452511974166394739; + bpsToRay[8469] = 1000000019454228940493295906; + bpsToRay[8470] = 1000000019455945813857947238; + bpsToRay[8471] = 1000000019457662594270414762; + bpsToRay[8472] = 1000000019459379281740762866; + bpsToRay[8473] = 1000000019461095876279054304; + bpsToRay[8474] = 1000000019462812377895350198; + bpsToRay[8475] = 1000000019464528786599710033; + bpsToRay[8476] = 1000000019466245102402191663; + bpsToRay[8477] = 1000000019467961325312851309; + bpsToRay[8478] = 1000000019469677455341743557; + bpsToRay[8479] = 1000000019471393492498921365; + bpsToRay[8480] = 1000000019473109436794436053; + bpsToRay[8481] = 1000000019474825288238337314; + bpsToRay[8482] = 1000000019476541046840673208; + bpsToRay[8483] = 1000000019478256712611490164; + bpsToRay[8484] = 1000000019479972285560832982; + bpsToRay[8485] = 1000000019481687765698744828; + bpsToRay[8486] = 1000000019483403153035267242; + bpsToRay[8487] = 1000000019485118447580440132; + bpsToRay[8488] = 1000000019486833649344301778; + bpsToRay[8489] = 1000000019488548758336888832; + bpsToRay[8490] = 1000000019490263774568236316; + bpsToRay[8491] = 1000000019491978698048377623; + bpsToRay[8492] = 1000000019493693528787344519; + bpsToRay[8493] = 1000000019495408266795167146; + bpsToRay[8494] = 1000000019497122912081874013; + bpsToRay[8495] = 1000000019498837464657492007; + bpsToRay[8496] = 1000000019500551924532046386; + bpsToRay[8497] = 1000000019502266291715560784; + bpsToRay[8498] = 1000000019503980566218057206; + bpsToRay[8499] = 1000000019505694748049556036; + bpsToRay[8500] = 1000000019507408837220076029; + bpsToRay[8501] = 1000000019509122833739634318; + bpsToRay[8502] = 1000000019510836737618246412; + bpsToRay[8503] = 1000000019512550548865926194; + bpsToRay[8504] = 1000000019514264267492685924; + bpsToRay[8505] = 1000000019515977893508536240; + bpsToRay[8506] = 1000000019517691426923486156; + bpsToRay[8507] = 1000000019519404867747543065; + bpsToRay[8508] = 1000000019521118215990712736; + bpsToRay[8509] = 1000000019522831471662999316; + bpsToRay[8510] = 1000000019524544634774405332; + bpsToRay[8511] = 1000000019526257705334931690; + bpsToRay[8512] = 1000000019527970683354577675; + bpsToRay[8513] = 1000000019529683568843340950; + bpsToRay[8514] = 1000000019531396361811217559; + bpsToRay[8515] = 1000000019533109062268201927; + bpsToRay[8516] = 1000000019534821670224286859; + bpsToRay[8517] = 1000000019536534185689463541; + bpsToRay[8518] = 1000000019538246608673721540; + bpsToRay[8519] = 1000000019539958939187048805; + bpsToRay[8520] = 1000000019541671177239431669; + bpsToRay[8521] = 1000000019543383322840854842; + bpsToRay[8522] = 1000000019545095376001301423; + bpsToRay[8523] = 1000000019546807336730752891; + bpsToRay[8524] = 1000000019548519205039189107; + bpsToRay[8525] = 1000000019550230980936588320; + bpsToRay[8526] = 1000000019551942664432927159; + bpsToRay[8527] = 1000000019553654255538180638; + bpsToRay[8528] = 1000000019555365754262322160; + bpsToRay[8529] = 1000000019557077160615323508; + bpsToRay[8530] = 1000000019558788474607154854; + bpsToRay[8531] = 1000000019560499696247784753; + bpsToRay[8532] = 1000000019562210825547180149; + bpsToRay[8533] = 1000000019563921862515306371; + bpsToRay[8534] = 1000000019565632807162127135; + bpsToRay[8535] = 1000000019567343659497604546; + bpsToRay[8536] = 1000000019569054419531699092; + bpsToRay[8537] = 1000000019570765087274369656; + bpsToRay[8538] = 1000000019572475662735573501; + bpsToRay[8539] = 1000000019574186145925266288; + bpsToRay[8540] = 1000000019575896536853402059; + bpsToRay[8541] = 1000000019577606835529933249; + bpsToRay[8542] = 1000000019579317041964810682; + bpsToRay[8543] = 1000000019581027156167983573; + bpsToRay[8544] = 1000000019582737178149399527; + bpsToRay[8545] = 1000000019584447107919004537; + bpsToRay[8546] = 1000000019586156945486742993; + bpsToRay[8547] = 1000000019587866690862557669; + bpsToRay[8548] = 1000000019589576344056389737; + bpsToRay[8549] = 1000000019591285905078178759; + bpsToRay[8550] = 1000000019592995373937862689; + bpsToRay[8551] = 1000000019594704750645377873; + bpsToRay[8552] = 1000000019596414035210659053; + bpsToRay[8553] = 1000000019598123227643639361; + bpsToRay[8554] = 1000000019599832327954250327; + bpsToRay[8555] = 1000000019601541336152421872; + bpsToRay[8556] = 1000000019603250252248082310; + bpsToRay[8557] = 1000000019604959076251158355; + bpsToRay[8558] = 1000000019606667808171575114; + bpsToRay[8559] = 1000000019608376448019256087; + bpsToRay[8560] = 1000000019610084995804123174; + bpsToRay[8561] = 1000000019611793451536096669; + bpsToRay[8562] = 1000000019613501815225095263; + bpsToRay[8563] = 1000000019615210086881036044; + bpsToRay[8564] = 1000000019616918266513834497; + bpsToRay[8565] = 1000000019618626354133404505; + bpsToRay[8566] = 1000000019620334349749658350; + bpsToRay[8567] = 1000000019622042253372506711; + bpsToRay[8568] = 1000000019623750065011858666; + bpsToRay[8569] = 1000000019625457784677621692; + bpsToRay[8570] = 1000000019627165412379701666; + bpsToRay[8571] = 1000000019628872948128002863; + bpsToRay[8572] = 1000000019630580391932427962; + bpsToRay[8573] = 1000000019632287743802878037; + bpsToRay[8574] = 1000000019633995003749252568; + bpsToRay[8575] = 1000000019635702171781449432; + bpsToRay[8576] = 1000000019637409247909364910; + bpsToRay[8577] = 1000000019639116232142893683; + bpsToRay[8578] = 1000000019640823124491928838; + bpsToRay[8579] = 1000000019642529924966361858; + bpsToRay[8580] = 1000000019644236633576082635; + bpsToRay[8581] = 1000000019645943250330979460; + bpsToRay[8582] = 1000000019647649775240939030; + bpsToRay[8583] = 1000000019649356208315846444; + bpsToRay[8584] = 1000000019651062549565585208; + bpsToRay[8585] = 1000000019652768799000037231; + bpsToRay[8586] = 1000000019654474956629082825; + bpsToRay[8587] = 1000000019656181022462600710; + bpsToRay[8588] = 1000000019657886996510468009; + bpsToRay[8589] = 1000000019659592878782560255; + bpsToRay[8590] = 1000000019661298669288751384; + bpsToRay[8591] = 1000000019663004368038913738; + bpsToRay[8592] = 1000000019664709975042918068; + bpsToRay[8593] = 1000000019666415490310633533; + bpsToRay[8594] = 1000000019668120913851927696; + bpsToRay[8595] = 1000000019669826245676666531; + bpsToRay[8596] = 1000000019671531485794714421; + bpsToRay[8597] = 1000000019673236634215934155; + bpsToRay[8598] = 1000000019674941690950186933; + bpsToRay[8599] = 1000000019676646656007332363; + bpsToRay[8600] = 1000000019678351529397228463; + bpsToRay[8601] = 1000000019680056311129731662; + bpsToRay[8602] = 1000000019681761001214696799; + bpsToRay[8603] = 1000000019683465599661977123; + bpsToRay[8604] = 1000000019685170106481424294; + bpsToRay[8605] = 1000000019686874521682888385; + bpsToRay[8606] = 1000000019688578845276217880; + bpsToRay[8607] = 1000000019690283077271259672; + bpsToRay[8608] = 1000000019691987217677859074; + bpsToRay[8609] = 1000000019693691266505859802; + bpsToRay[8610] = 1000000019695395223765103993; + bpsToRay[8611] = 1000000019697099089465432194; + bpsToRay[8612] = 1000000019698802863616683367; + bpsToRay[8613] = 1000000019700506546228694886; + bpsToRay[8614] = 1000000019702210137311302542; + bpsToRay[8615] = 1000000019703913636874340539; + bpsToRay[8616] = 1000000019705617044927641498; + bpsToRay[8617] = 1000000019707320361481036453; + bpsToRay[8618] = 1000000019709023586544354858; + bpsToRay[8619] = 1000000019710726720127424577; + bpsToRay[8620] = 1000000019712429762240071896; + bpsToRay[8621] = 1000000019714132712892121515; + bpsToRay[8622] = 1000000019715835572093396554; + bpsToRay[8623] = 1000000019717538339853718546; + bpsToRay[8624] = 1000000019719241016182907446; + bpsToRay[8625] = 1000000019720943601090781625; + bpsToRay[8626] = 1000000019722646094587157873; + bpsToRay[8627] = 1000000019724348496681851400; + bpsToRay[8628] = 1000000019726050807384675834; + bpsToRay[8629] = 1000000019727753026705443223; + bpsToRay[8630] = 1000000019729455154653964034; + bpsToRay[8631] = 1000000019731157191240047158; + bpsToRay[8632] = 1000000019732859136473499900; + bpsToRay[8633] = 1000000019734560990364127992; + bpsToRay[8634] = 1000000019736262752921735584; + bpsToRay[8635] = 1000000019737964424156125249; + bpsToRay[8636] = 1000000019739666004077097982; + bpsToRay[8637] = 1000000019741367492694453198; + bpsToRay[8638] = 1000000019743068890017988738; + bpsToRay[8639] = 1000000019744770196057500864; + bpsToRay[8640] = 1000000019746471410822784262; + bpsToRay[8641] = 1000000019748172534323632041; + bpsToRay[8642] = 1000000019749873566569835734; + bpsToRay[8643] = 1000000019751574507571185299; + bpsToRay[8644] = 1000000019753275357337469119; + bpsToRay[8645] = 1000000019754976115878473999; + bpsToRay[8646] = 1000000019756676783203985175; + bpsToRay[8647] = 1000000019758377359323786302; + bpsToRay[8648] = 1000000019760077844247659467; + bpsToRay[8649] = 1000000019761778237985385179; + bpsToRay[8650] = 1000000019763478540546742376; + bpsToRay[8651] = 1000000019765178751941508423; + bpsToRay[8652] = 1000000019766878872179459110; + bpsToRay[8653] = 1000000019768578901270368657; + bpsToRay[8654] = 1000000019770278839224009713; + bpsToRay[8655] = 1000000019771978686050153352; + bpsToRay[8656] = 1000000019773678441758569079; + bpsToRay[8657] = 1000000019775378106359024828; + bpsToRay[8658] = 1000000019777077679861286963; + bpsToRay[8659] = 1000000019778777162275120275; + bpsToRay[8660] = 1000000019780476553610287987; + bpsToRay[8661] = 1000000019782175853876551752; + bpsToRay[8662] = 1000000019783875063083671655; + bpsToRay[8663] = 1000000019785574181241406209; + bpsToRay[8664] = 1000000019787273208359512363; + bpsToRay[8665] = 1000000019788972144447745493; + bpsToRay[8666] = 1000000019790670989515859410; + bpsToRay[8667] = 1000000019792369743573606356; + bpsToRay[8668] = 1000000019794068406630737008; + bpsToRay[8669] = 1000000019795766978697000471; + bpsToRay[8670] = 1000000019797465459782144290; + bpsToRay[8671] = 1000000019799163849895914439; + bpsToRay[8672] = 1000000019800862149048055328; + bpsToRay[8673] = 1000000019802560357248309801; + bpsToRay[8674] = 1000000019804258474506419137; + bpsToRay[8675] = 1000000019805956500832123050; + bpsToRay[8676] = 1000000019807654436235159689; + bpsToRay[8677] = 1000000019809352280725265639; + bpsToRay[8678] = 1000000019811050034312175922; + bpsToRay[8679] = 1000000019812747697005623995; + bpsToRay[8680] = 1000000019814445268815341752; + bpsToRay[8681] = 1000000019816142749751059525; + bpsToRay[8682] = 1000000019817840139822506084; + bpsToRay[8683] = 1000000019819537439039408634; + bpsToRay[8684] = 1000000019821234647411492821; + bpsToRay[8685] = 1000000019822931764948482727; + bpsToRay[8686] = 1000000019824628791660100876; + bpsToRay[8687] = 1000000019826325727556068227; + bpsToRay[8688] = 1000000019828022572646104182; + bpsToRay[8689] = 1000000019829719326939926581; + bpsToRay[8690] = 1000000019831415990447251705; + bpsToRay[8691] = 1000000019833112563177794274; + bpsToRay[8692] = 1000000019834809045141267450; + bpsToRay[8693] = 1000000019836505436347382837; + bpsToRay[8694] = 1000000019838201736805850477; + bpsToRay[8695] = 1000000019839897946526378859; + bpsToRay[8696] = 1000000019841594065518674908; + bpsToRay[8697] = 1000000019843290093792443997; + bpsToRay[8698] = 1000000019844986031357389939; + bpsToRay[8699] = 1000000019846681878223214989; + bpsToRay[8700] = 1000000019848377634399619849; + bpsToRay[8701] = 1000000019850073299896303661; + bpsToRay[8702] = 1000000019851768874722964014; + bpsToRay[8703] = 1000000019853464358889296941; + bpsToRay[8704] = 1000000019855159752404996917; + bpsToRay[8705] = 1000000019856855055279756866; + bpsToRay[8706] = 1000000019858550267523268155; + bpsToRay[8707] = 1000000019860245389145220596; + bpsToRay[8708] = 1000000019861940420155302451; + bpsToRay[8709] = 1000000019863635360563200425; + bpsToRay[8710] = 1000000019865330210378599670; + bpsToRay[8711] = 1000000019867024969611183786; + bpsToRay[8712] = 1000000019868719638270634821; + bpsToRay[8713] = 1000000019870414216366633269; + bpsToRay[8714] = 1000000019872108703908858076; + bpsToRay[8715] = 1000000019873803100906986629; + bpsToRay[8716] = 1000000019875497407370694772; + bpsToRay[8717] = 1000000019877191623309656793; + bpsToRay[8718] = 1000000019878885748733545431; + bpsToRay[8719] = 1000000019880579783652031874; + bpsToRay[8720] = 1000000019882273728074785762; + bpsToRay[8721] = 1000000019883967582011475183; + bpsToRay[8722] = 1000000019885661345471766678; + bpsToRay[8723] = 1000000019887355018465325236; + bpsToRay[8724] = 1000000019889048601001814301; + bpsToRay[8725] = 1000000019890742093090895767; + bpsToRay[8726] = 1000000019892435494742229981; + bpsToRay[8727] = 1000000019894128805965475739; + bpsToRay[8728] = 1000000019895822026770290295; + bpsToRay[8729] = 1000000019897515157166329351; + bpsToRay[8730] = 1000000019899208197163247067; + bpsToRay[8731] = 1000000019900901146770696053; + bpsToRay[8732] = 1000000019902594005998327375; + bpsToRay[8733] = 1000000019904286774855790554; + bpsToRay[8734] = 1000000019905979453352733562; + bpsToRay[8735] = 1000000019907672041498802832; + bpsToRay[8736] = 1000000019909364539303643246; + bpsToRay[8737] = 1000000019911056946776898148; + bpsToRay[8738] = 1000000019912749263928209333; + bpsToRay[8739] = 1000000019914441490767217054; + bpsToRay[8740] = 1000000019916133627303560021; + bpsToRay[8741] = 1000000019917825673546875400; + bpsToRay[8742] = 1000000019919517629506798819; + bpsToRay[8743] = 1000000019921209495192964356; + bpsToRay[8744] = 1000000019922901270615004553; + bpsToRay[8745] = 1000000019924592955782550408; + bpsToRay[8746] = 1000000019926284550705231377; + bpsToRay[8747] = 1000000019927976055392675377; + bpsToRay[8748] = 1000000019929667469854508782; + bpsToRay[8749] = 1000000019931358794100356430; + bpsToRay[8750] = 1000000019933050028139841613; + bpsToRay[8751] = 1000000019934741171982586087; + bpsToRay[8752] = 1000000019936432225638210068; + bpsToRay[8753] = 1000000019938123189116332234; + bpsToRay[8754] = 1000000019939814062426569721; + bpsToRay[8755] = 1000000019941504845578538131; + bpsToRay[8756] = 1000000019943195538581851525; + bpsToRay[8757] = 1000000019944886141446122425; + bpsToRay[8758] = 1000000019946576654180961822; + bpsToRay[8759] = 1000000019948267076795979161; + bpsToRay[8760] = 1000000019949957409300782358; + bpsToRay[8761] = 1000000019951647651704977788; + bpsToRay[8762] = 1000000019953337804018170292; + bpsToRay[8763] = 1000000019955027866249963174; + bpsToRay[8764] = 1000000019956717838409958205; + bpsToRay[8765] = 1000000019958407720507755616; + bpsToRay[8766] = 1000000019960097512552954109; + bpsToRay[8767] = 1000000019961787214555150849; + bpsToRay[8768] = 1000000019963476826523941464; + bpsToRay[8769] = 1000000019965166348468920054; + bpsToRay[8770] = 1000000019966855780399679180; + bpsToRay[8771] = 1000000019968545122325809875; + bpsToRay[8772] = 1000000019970234374256901634; + bpsToRay[8773] = 1000000019971923536202542425; + bpsToRay[8774] = 1000000019973612608172318678; + bpsToRay[8775] = 1000000019975301590175815296; + bpsToRay[8776] = 1000000019976990482222615648; + bpsToRay[8777] = 1000000019978679284322301573; + bpsToRay[8778] = 1000000019980367996484453378; + bpsToRay[8779] = 1000000019982056618718649841; + bpsToRay[8780] = 1000000019983745151034468208; + bpsToRay[8781] = 1000000019985433593441484196; + bpsToRay[8782] = 1000000019987121945949271992; + bpsToRay[8783] = 1000000019988810208567404255; + bpsToRay[8784] = 1000000019990498381305452115; + bpsToRay[8785] = 1000000019992186464172985172; + bpsToRay[8786] = 1000000019993874457179571499; + bpsToRay[8787] = 1000000019995562360334777640; + bpsToRay[8788] = 1000000019997250173648168612; + bpsToRay[8789] = 1000000019998937897129307905; + bpsToRay[8790] = 1000000020000625530787757482; + bpsToRay[8791] = 1000000020002313074633077780; + bpsToRay[8792] = 1000000020004000528674827707; + bpsToRay[8793] = 1000000020005687892922564648; + bpsToRay[8794] = 1000000020007375167385844462; + bpsToRay[8795] = 1000000020009062352074221481; + bpsToRay[8796] = 1000000020010749446997248514; + bpsToRay[8797] = 1000000020012436452164476843; + bpsToRay[8798] = 1000000020014123367585456228; + bpsToRay[8799] = 1000000020015810193269734903; + bpsToRay[8800] = 1000000020017496929226859581; + bpsToRay[8801] = 1000000020019183575466375447; + bpsToRay[8802] = 1000000020020870131997826170; + bpsToRay[8803] = 1000000020022556598830753888; + bpsToRay[8804] = 1000000020024242975974699224; + bpsToRay[8805] = 1000000020025929263439201274; + bpsToRay[8806] = 1000000020027615461233797613; + bpsToRay[8807] = 1000000020029301569368024297; + bpsToRay[8808] = 1000000020030987587851415860; + bpsToRay[8809] = 1000000020032673516693505313; + bpsToRay[8810] = 1000000020034359355903824149; + bpsToRay[8811] = 1000000020036045105491902339; + bpsToRay[8812] = 1000000020037730765467268337; + bpsToRay[8813] = 1000000020039416335839449075; + bpsToRay[8814] = 1000000020041101816617969965; + bpsToRay[8815] = 1000000020042787207812354904; + bpsToRay[8816] = 1000000020044472509432126266; + bpsToRay[8817] = 1000000020046157721486804911; + bpsToRay[8818] = 1000000020047842843985910178; + bpsToRay[8819] = 1000000020049527876938959890; + bpsToRay[8820] = 1000000020051212820355470352; + bpsToRay[8821] = 1000000020052897674244956352; + bpsToRay[8822] = 1000000020054582438616931164; + bpsToRay[8823] = 1000000020056267113480906541; + bpsToRay[8824] = 1000000020057951698846392724; + bpsToRay[8825] = 1000000020059636194722898437; + bpsToRay[8826] = 1000000020061320601119930888; + bpsToRay[8827] = 1000000020063004918046995771; + bpsToRay[8828] = 1000000020064689145513597267; + bpsToRay[8829] = 1000000020066373283529238037; + bpsToRay[8830] = 1000000020068057332103419236; + bpsToRay[8831] = 1000000020069741291245640498; + bpsToRay[8832] = 1000000020071425160965399947; + bpsToRay[8833] = 1000000020073108941272194197; + bpsToRay[8834] = 1000000020074792632175518341; + bpsToRay[8835] = 1000000020076476233684865968; + bpsToRay[8836] = 1000000020078159745809729151; + bpsToRay[8837] = 1000000020079843168559598451; + bpsToRay[8838] = 1000000020081526501943962918; + bpsToRay[8839] = 1000000020083209745972310093; + bpsToRay[8840] = 1000000020084892900654126002; + bpsToRay[8841] = 1000000020086575965998895164; + bpsToRay[8842] = 1000000020088258942016100588; + bpsToRay[8843] = 1000000020089941828715223770; + bpsToRay[8844] = 1000000020091624626105744699; + bpsToRay[8845] = 1000000020093307334197141855; + bpsToRay[8846] = 1000000020094989952998892207; + bpsToRay[8847] = 1000000020096672482520471219; + bpsToRay[8848] = 1000000020098354922771352842; + bpsToRay[8849] = 1000000020100037273761009523; + bpsToRay[8850] = 1000000020101719535498912200; + bpsToRay[8851] = 1000000020103401707994530304; + bpsToRay[8852] = 1000000020105083791257331758; + bpsToRay[8853] = 1000000020106765785296782980; + bpsToRay[8854] = 1000000020108447690122348881; + bpsToRay[8855] = 1000000020110129505743492865; + bpsToRay[8856] = 1000000020111811232169676833; + bpsToRay[8857] = 1000000020113492869410361176; + bpsToRay[8858] = 1000000020115174417475004786; + bpsToRay[8859] = 1000000020116855876373065045; + bpsToRay[8860] = 1000000020118537246113997834; + bpsToRay[8861] = 1000000020120218526707257528; + bpsToRay[8862] = 1000000020121899718162296998; + bpsToRay[8863] = 1000000020123580820488567614; + bpsToRay[8864] = 1000000020125261833695519242; + bpsToRay[8865] = 1000000020126942757792600241; + bpsToRay[8866] = 1000000020128623592789257476; + bpsToRay[8867] = 1000000020130304338694936301; + bpsToRay[8868] = 1000000020131984995519080574; + bpsToRay[8869] = 1000000020133665563271132648; + bpsToRay[8870] = 1000000020135346041960533378; + bpsToRay[8871] = 1000000020137026431596722116; + bpsToRay[8872] = 1000000020138706732189136713; + bpsToRay[8873] = 1000000020140386943747213521; + bpsToRay[8874] = 1000000020142067066280387392; + bpsToRay[8875] = 1000000020143747099798091677; + bpsToRay[8876] = 1000000020145427044309758231; + bpsToRay[8877] = 1000000020147106899824817406; + bpsToRay[8878] = 1000000020148786666352698057; + bpsToRay[8879] = 1000000020150466343902827542; + bpsToRay[8880] = 1000000020152145932484631718; + bpsToRay[8881] = 1000000020153825432107534947; + bpsToRay[8882] = 1000000020155504842780960093; + bpsToRay[8883] = 1000000020157184164514328522; + bpsToRay[8884] = 1000000020158863397317060104; + bpsToRay[8885] = 1000000020160542541198573211; + bpsToRay[8886] = 1000000020162221596168284722; + bpsToRay[8887] = 1000000020163900562235610018; + bpsToRay[8888] = 1000000020165579439409962985; + bpsToRay[8889] = 1000000020167258227700756012; + bpsToRay[8890] = 1000000020168936927117399997; + bpsToRay[8891] = 1000000020170615537669304340; + bpsToRay[8892] = 1000000020172294059365876949; + bpsToRay[8893] = 1000000020173972492216524237; + bpsToRay[8894] = 1000000020175650836230651123; + bpsToRay[8895] = 1000000020177329091417661033; + bpsToRay[8896] = 1000000020179007257786955901; + bpsToRay[8897] = 1000000020180685335347936169; + bpsToRay[8898] = 1000000020182363324110000782; + bpsToRay[8899] = 1000000020184041224082547200; + bpsToRay[8900] = 1000000020185719035274971385; + bpsToRay[8901] = 1000000020187396757696667812; + bpsToRay[8902] = 1000000020189074391357029461; + bpsToRay[8903] = 1000000020190751936265447827; + bpsToRay[8904] = 1000000020192429392431312906; + bpsToRay[8905] = 1000000020194106759864013214; + bpsToRay[8906] = 1000000020195784038572935769; + bpsToRay[8907] = 1000000020197461228567466103; + bpsToRay[8908] = 1000000020199138329856988259; + bpsToRay[8909] = 1000000020200815342450884791; + bpsToRay[8910] = 1000000020202492266358536762; + bpsToRay[8911] = 1000000020204169101589323750; + bpsToRay[8912] = 1000000020205845848152623845; + bpsToRay[8913] = 1000000020207522506057813646; + bpsToRay[8914] = 1000000020209199075314268269; + bpsToRay[8915] = 1000000020210875555931361340; + bpsToRay[8916] = 1000000020212551947918465000; + bpsToRay[8917] = 1000000020214228251284949901; + bpsToRay[8918] = 1000000020215904466040185214; + bpsToRay[8919] = 1000000020217580592193538618; + bpsToRay[8920] = 1000000020219256629754376312; + bpsToRay[8921] = 1000000020220932578732063007; + bpsToRay[8922] = 1000000020222608439135961931; + bpsToRay[8923] = 1000000020224284210975434825; + bpsToRay[8924] = 1000000020225959894259841949; + bpsToRay[8925] = 1000000020227635488998542076; + bpsToRay[8926] = 1000000020229310995200892497; + bpsToRay[8927] = 1000000020230986412876249021; + bpsToRay[8928] = 1000000020232661742033965972; + bpsToRay[8929] = 1000000020234336982683396194; + bpsToRay[8930] = 1000000020236012134833891045; + bpsToRay[8931] = 1000000020237687198494800405; + bpsToRay[8932] = 1000000020239362173675472669; + bpsToRay[8933] = 1000000020241037060385254751; + bpsToRay[8934] = 1000000020242711858633492088; + bpsToRay[8935] = 1000000020244386568429528633; + bpsToRay[8936] = 1000000020246061189782706857; + bpsToRay[8937] = 1000000020247735722702367756; + bpsToRay[8938] = 1000000020249410167197850841; + bpsToRay[8939] = 1000000020251084523278494145; + bpsToRay[8940] = 1000000020252758790953634225; + bpsToRay[8941] = 1000000020254432970232606156; + bpsToRay[8942] = 1000000020256107061124743535; + bpsToRay[8943] = 1000000020257781063639378482; + bpsToRay[8944] = 1000000020259454977785841636; + bpsToRay[8945] = 1000000020261128803573462164; + bpsToRay[8946] = 1000000020262802541011567749; + bpsToRay[8947] = 1000000020264476190109484603; + bpsToRay[8948] = 1000000020266149750876537457; + bpsToRay[8949] = 1000000020267823223322049569; + bpsToRay[8950] = 1000000020269496607455342719; + bpsToRay[8951] = 1000000020271169903285737212; + bpsToRay[8952] = 1000000020272843110822551875; + bpsToRay[8953] = 1000000020274516230075104065; + bpsToRay[8954] = 1000000020276189261052709662; + bpsToRay[8955] = 1000000020277862203764683069; + bpsToRay[8956] = 1000000020279535058220337216; + bpsToRay[8957] = 1000000020281207824428983564; + bpsToRay[8958] = 1000000020282880502399932092; + bpsToRay[8959] = 1000000020284553092142491314; + bpsToRay[8960] = 1000000020286225593665968266; + bpsToRay[8961] = 1000000020287898006979668513; + bpsToRay[8962] = 1000000020289570332092896147; + bpsToRay[8963] = 1000000020291242569014953788; + bpsToRay[8964] = 1000000020292914717755142587; + bpsToRay[8965] = 1000000020294586778322762220; + bpsToRay[8966] = 1000000020296258750727110894; + bpsToRay[8967] = 1000000020297930634977485344; + bpsToRay[8968] = 1000000020299602431083180836; + bpsToRay[8969] = 1000000020301274139053491166; + bpsToRay[8970] = 1000000020302945758897708658; + bpsToRay[8971] = 1000000020304617290625124169; + bpsToRay[8972] = 1000000020306288734245027087; + bpsToRay[8973] = 1000000020307960089766705327; + bpsToRay[8974] = 1000000020309631357199445340; + bpsToRay[8975] = 1000000020311302536552532106; + bpsToRay[8976] = 1000000020312973627835249139; + bpsToRay[8977] = 1000000020314644631056878485; + bpsToRay[8978] = 1000000020316315546226700722; + bpsToRay[8979] = 1000000020317986373353994961; + bpsToRay[8980] = 1000000020319657112448038846; + bpsToRay[8981] = 1000000020321327763518108555; + bpsToRay[8982] = 1000000020322998326573478801; + bpsToRay[8983] = 1000000020324668801623422830; + bpsToRay[8984] = 1000000020326339188677212422; + bpsToRay[8985] = 1000000020328009487744117892; + bpsToRay[8986] = 1000000020329679698833408092; + bpsToRay[8987] = 1000000020331349821954350409; + bpsToRay[8988] = 1000000020333019857116210763; + bpsToRay[8989] = 1000000020334689804328253614; + bpsToRay[8990] = 1000000020336359663599741954; + bpsToRay[8991] = 1000000020338029434939937316; + bpsToRay[8992] = 1000000020339699118358099767; + bpsToRay[8993] = 1000000020341368713863487913; + bpsToRay[8994] = 1000000020343038221465358897; + bpsToRay[8995] = 1000000020344707641172968400; + bpsToRay[8996] = 1000000020346376972995570640; + bpsToRay[8997] = 1000000020348046216942418378; + bpsToRay[8998] = 1000000020349715373022762906; + bpsToRay[8999] = 1000000020351384441245854063; + bpsToRay[9000] = 1000000020353053421620940223; + bpsToRay[9001] = 1000000020354722314157268302; + bpsToRay[9002] = 1000000020356391118864083753; + bpsToRay[9003] = 1000000020358059835750630572; + bpsToRay[9004] = 1000000020359728464826151296; + bpsToRay[9005] = 1000000020361397006099887003; + bpsToRay[9006] = 1000000020363065459581077309; + bpsToRay[9007] = 1000000020364733825278960375; + bpsToRay[9008] = 1000000020366402103202772903; + bpsToRay[9009] = 1000000020368070293361750138; + bpsToRay[9010] = 1000000020369738395765125865; + bpsToRay[9011] = 1000000020371406410422132415; + bpsToRay[9012] = 1000000020373074337342000659; + bpsToRay[9013] = 1000000020374742176533960015; + bpsToRay[9014] = 1000000020376409928007238443; + bpsToRay[9015] = 1000000020378077591771062444; + bpsToRay[9016] = 1000000020379745167834657070; + bpsToRay[9017] = 1000000020381412656207245911; + bpsToRay[9018] = 1000000020383080056898051107; + bpsToRay[9019] = 1000000020384747369916293340; + bpsToRay[9020] = 1000000020386414595271191839; + bpsToRay[9021] = 1000000020388081732971964381; + bpsToRay[9022] = 1000000020389748783027827283; + bpsToRay[9023] = 1000000020391415745447995416; + bpsToRay[9024] = 1000000020393082620241682192; + bpsToRay[9025] = 1000000020394749407418099573; + bpsToRay[9026] = 1000000020396416106986458070; + bpsToRay[9027] = 1000000020398082718955966736; + bpsToRay[9028] = 1000000020399749243335833178; + bpsToRay[9029] = 1000000020401415680135263548; + bpsToRay[9030] = 1000000020403082029363462548; + bpsToRay[9031] = 1000000020404748291029633429; + bpsToRay[9032] = 1000000020406414465142977990; + bpsToRay[9033] = 1000000020408080551712696581; + bpsToRay[9034] = 1000000020409746550747988100; + bpsToRay[9035] = 1000000020411412462258049999; + bpsToRay[9036] = 1000000020413078286252078275; + bpsToRay[9037] = 1000000020414744022739267481; + bpsToRay[9038] = 1000000020416409671728810718; + bpsToRay[9039] = 1000000020418075233229899639; + bpsToRay[9040] = 1000000020419740707251724448; + bpsToRay[9041] = 1000000020421406093803473905; + bpsToRay[9042] = 1000000020423071392894335315; + bpsToRay[9043] = 1000000020424736604533494543; + bpsToRay[9044] = 1000000020426401728730136002; + bpsToRay[9045] = 1000000020428066765493442661; + bpsToRay[9046] = 1000000020429731714832596040; + bpsToRay[9047] = 1000000020431396576756776217; + bpsToRay[9048] = 1000000020433061351275161818; + bpsToRay[9049] = 1000000020434726038396930030; + bpsToRay[9050] = 1000000020436390638131256590; + bpsToRay[9051] = 1000000020438055150487315791; + bpsToRay[9052] = 1000000020439719575474280483; + bpsToRay[9053] = 1000000020441383913101322070; + bpsToRay[9054] = 1000000020443048163377610514; + bpsToRay[9055] = 1000000020444712326312314329; + bpsToRay[9056] = 1000000020446376401914600591; + bpsToRay[9057] = 1000000020448040390193634929; + bpsToRay[9058] = 1000000020449704291158581532; + bpsToRay[9059] = 1000000020451368104818603142; + bpsToRay[9060] = 1000000020453031831182861063; + bpsToRay[9061] = 1000000020454695470260515157; + bpsToRay[9062] = 1000000020456359022060723842; + bpsToRay[9063] = 1000000020458022486592644094; + bpsToRay[9064] = 1000000020459685863865431454; + bpsToRay[9065] = 1000000020461349153888240014; + bpsToRay[9066] = 1000000020463012356670222430; + bpsToRay[9067] = 1000000020464675472220529919; + bpsToRay[9068] = 1000000020466338500548312257; + bpsToRay[9069] = 1000000020468001441662717778; + bpsToRay[9070] = 1000000020469664295572893381; + bpsToRay[9071] = 1000000020471327062287984523; + bpsToRay[9072] = 1000000020472989741817135223; + bpsToRay[9073] = 1000000020474652334169488064; + bpsToRay[9074] = 1000000020476314839354184187; + bpsToRay[9075] = 1000000020477977257380363298; + bpsToRay[9076] = 1000000020479639588257163666; + bpsToRay[9077] = 1000000020481301831993722120; + bpsToRay[9078] = 1000000020482963988599174056; + bpsToRay[9079] = 1000000020484626058082653431; + bpsToRay[9080] = 1000000020486288040453292766; + bpsToRay[9081] = 1000000020487949935720223147; + bpsToRay[9082] = 1000000020489611743892574223; + bpsToRay[9083] = 1000000020491273464979474210; + bpsToRay[9084] = 1000000020492935098990049887; + bpsToRay[9085] = 1000000020494596645933426599; + bpsToRay[9086] = 1000000020496258105818728257; + bpsToRay[9087] = 1000000020497919478655077336; + bpsToRay[9088] = 1000000020499580764451594880; + bpsToRay[9089] = 1000000020501241963217400498; + bpsToRay[9090] = 1000000020502903074961612367; + bpsToRay[9091] = 1000000020504564099693347229; + bpsToRay[9092] = 1000000020506225037421720394; + bpsToRay[9093] = 1000000020507885888155845741; + bpsToRay[9094] = 1000000020509546651904835716; + bpsToRay[9095] = 1000000020511207328677801335; + bpsToRay[9096] = 1000000020512867918483852179; + bpsToRay[9097] = 1000000020514528421332096402; + bpsToRay[9098] = 1000000020516188837231640723; + bpsToRay[9099] = 1000000020517849166191590436; + bpsToRay[9100] = 1000000020519509408221049399; + bpsToRay[9101] = 1000000020521169563329120043; + bpsToRay[9102] = 1000000020522829631524903371; + bpsToRay[9103] = 1000000020524489612817498954; + bpsToRay[9104] = 1000000020526149507216004934; + bpsToRay[9105] = 1000000020527809314729518026; + bpsToRay[9106] = 1000000020529469035367133516; + bpsToRay[9107] = 1000000020531128669137945262; + bpsToRay[9108] = 1000000020532788216051045693; + bpsToRay[9109] = 1000000020534447676115525812; + bpsToRay[9110] = 1000000020536107049340475193; + bpsToRay[9111] = 1000000020537766335734981987; + bpsToRay[9112] = 1000000020539425535308132912; + bpsToRay[9113] = 1000000020541084648069013267; + bpsToRay[9114] = 1000000020542743674026706920; + bpsToRay[9115] = 1000000020544402613190296315; + bpsToRay[9116] = 1000000020546061465568862469; + bpsToRay[9117] = 1000000020547720231171484977; + bpsToRay[9118] = 1000000020549378910007242007; + bpsToRay[9119] = 1000000020551037502085210301; + bpsToRay[9120] = 1000000020552696007414465182; + bpsToRay[9121] = 1000000020554354426004080544; + bpsToRay[9122] = 1000000020556012757863128859; + bpsToRay[9123] = 1000000020557671003000681175; + bpsToRay[9124] = 1000000020559329161425807120; + bpsToRay[9125] = 1000000020560987233147574896; + bpsToRay[9126] = 1000000020562645218175051284; + bpsToRay[9127] = 1000000020564303116517301641; + bpsToRay[9128] = 1000000020565960928183389906; + bpsToRay[9129] = 1000000020567618653182378593; + bpsToRay[9130] = 1000000020569276291523328795; + bpsToRay[9131] = 1000000020570933843215300187; + bpsToRay[9132] = 1000000020572591308267351020; + bpsToRay[9133] = 1000000020574248686688538126; + bpsToRay[9134] = 1000000020575905978487916919; + bpsToRay[9135] = 1000000020577563183674541388; + bpsToRay[9136] = 1000000020579220302257464108; + bpsToRay[9137] = 1000000020580877334245736232; + bpsToRay[9138] = 1000000020582534279648407494; + bpsToRay[9139] = 1000000020584191138474526212; + bpsToRay[9140] = 1000000020585847910733139281; + bpsToRay[9141] = 1000000020587504596433292185; + bpsToRay[9142] = 1000000020589161195584028982; + bpsToRay[9143] = 1000000020590817708194392321; + bpsToRay[9144] = 1000000020592474134273423425; + bpsToRay[9145] = 1000000020594130473830162110; + bpsToRay[9146] = 1000000020595786726873646766; + bpsToRay[9147] = 1000000020597442893412914374; + bpsToRay[9148] = 1000000020599098973457000497; + bpsToRay[9149] = 1000000020600754967014939281; + bpsToRay[9150] = 1000000020602410874095763456; + bpsToRay[9151] = 1000000020604066694708504340; + bpsToRay[9152] = 1000000020605722428862191834; + bpsToRay[9153] = 1000000020607378076565854427; + bpsToRay[9154] = 1000000020609033637828519190; + bpsToRay[9155] = 1000000020610689112659211784; + bpsToRay[9156] = 1000000020612344501066956455; + bpsToRay[9157] = 1000000020613999803060776034; + bpsToRay[9158] = 1000000020615655018649691942; + bpsToRay[9159] = 1000000020617310147842724185; + bpsToRay[9160] = 1000000020618965190648891360; + bpsToRay[9161] = 1000000020620620147077210647; + bpsToRay[9162] = 1000000020622275017136697818; + bpsToRay[9163] = 1000000020623929800836367232; + bpsToRay[9164] = 1000000020625584498185231838; + bpsToRay[9165] = 1000000020627239109192303172; + bpsToRay[9166] = 1000000020628893633866591362; + bpsToRay[9167] = 1000000020630548072217105124; + bpsToRay[9168] = 1000000020632202424252851765; + bpsToRay[9169] = 1000000020633856689982837180; + bpsToRay[9170] = 1000000020635510869416065857; + bpsToRay[9171] = 1000000020637164962561540876; + bpsToRay[9172] = 1000000020638818969428263904; + bpsToRay[9173] = 1000000020640472890025235203; + bpsToRay[9174] = 1000000020642126724361453626; + bpsToRay[9175] = 1000000020643780472445916617; + bpsToRay[9176] = 1000000020645434134287620214; + bpsToRay[9177] = 1000000020647087709895559046; + bpsToRay[9178] = 1000000020648741199278726334; + bpsToRay[9179] = 1000000020650394602446113896; + bpsToRay[9180] = 1000000020652047919406712141; + bpsToRay[9181] = 1000000020653701150169510072; + bpsToRay[9182] = 1000000020655354294743495287; + bpsToRay[9183] = 1000000020657007353137653976; + bpsToRay[9184] = 1000000020658660325360970928; + bpsToRay[9185] = 1000000020660313211422429521; + bpsToRay[9186] = 1000000020661966011331011735; + bpsToRay[9187] = 1000000020663618725095698141; + bpsToRay[9188] = 1000000020665271352725467906; + bpsToRay[9189] = 1000000020666923894229298796; + bpsToRay[9190] = 1000000020668576349616167171; + bpsToRay[9191] = 1000000020670228718895047988; + bpsToRay[9192] = 1000000020671881002074914804; + bpsToRay[9193] = 1000000020673533199164739768; + bpsToRay[9194] = 1000000020675185310173493631; + bpsToRay[9195] = 1000000020676837335110145740; + bpsToRay[9196] = 1000000020678489273983664040; + bpsToRay[9197] = 1000000020680141126803015078; + bpsToRay[9198] = 1000000020681792893577163993; + bpsToRay[9199] = 1000000020683444574315074529; + bpsToRay[9200] = 1000000020685096169025709028; + bpsToRay[9201] = 1000000020686747677718028431; + bpsToRay[9202] = 1000000020688399100400992278; + bpsToRay[9203] = 1000000020690050437083558711; + bpsToRay[9204] = 1000000020691701687774684471; + bpsToRay[9205] = 1000000020693352852483324902; + bpsToRay[9206] = 1000000020695003931218433948; + bpsToRay[9207] = 1000000020696654923988964153; + bpsToRay[9208] = 1000000020698305830803866663; + bpsToRay[9209] = 1000000020699956651672091229; + bpsToRay[9210] = 1000000020701607386602586203; + bpsToRay[9211] = 1000000020703258035604298536; + bpsToRay[9212] = 1000000020704908598686173787; + bpsToRay[9213] = 1000000020706559075857156114; + bpsToRay[9214] = 1000000020708209467126188282; + bpsToRay[9215] = 1000000020709859772502211657; + bpsToRay[9216] = 1000000020711509991994166211; + bpsToRay[9217] = 1000000020713160125610990519; + bpsToRay[9218] = 1000000020714810173361621761; + bpsToRay[9219] = 1000000020716460135254995722; + bpsToRay[9220] = 1000000020718110011300046791; + bpsToRay[9221] = 1000000020719759801505707966; + bpsToRay[9222] = 1000000020721409505880910848; + bpsToRay[9223] = 1000000020723059124434585643; + bpsToRay[9224] = 1000000020724708657175661166; + bpsToRay[9225] = 1000000020726358104113064837; + bpsToRay[9226] = 1000000020728007465255722684; + bpsToRay[9227] = 1000000020729656740612559341; + bpsToRay[9228] = 1000000020731305930192498050; + bpsToRay[9229] = 1000000020732955034004460663; + bpsToRay[9230] = 1000000020734604052057367636; + bpsToRay[9231] = 1000000020736252984360138036; + bpsToRay[9232] = 1000000020737901830921689539; + bpsToRay[9233] = 1000000020739550591750938429; + bpsToRay[9234] = 1000000020741199266856799598; + bpsToRay[9235] = 1000000020742847856248186551; + bpsToRay[9236] = 1000000020744496359934011399; + bpsToRay[9237] = 1000000020746144777923184866; + bpsToRay[9238] = 1000000020747793110224616286; + bpsToRay[9239] = 1000000020749441356847213601; + bpsToRay[9240] = 1000000020751089517799883368; + bpsToRay[9241] = 1000000020752737593091530752; + bpsToRay[9242] = 1000000020754385582731059532; + bpsToRay[9243] = 1000000020756033486727372097; + bpsToRay[9244] = 1000000020757681305089369449; + bpsToRay[9245] = 1000000020759329037825951202; + bpsToRay[9246] = 1000000020760976684946015583; + bpsToRay[9247] = 1000000020762624246458459433; + bpsToRay[9248] = 1000000020764271722372178205; + bpsToRay[9249] = 1000000020765919112696065965; + bpsToRay[9250] = 1000000020767566417439015395; + bpsToRay[9251] = 1000000020769213636609917790; + bpsToRay[9252] = 1000000020770860770217663058; + bpsToRay[9253] = 1000000020772507818271139726; + bpsToRay[9254] = 1000000020774154780779234930; + bpsToRay[9255] = 1000000020775801657750834425; + bpsToRay[9256] = 1000000020777448449194822584; + bpsToRay[9257] = 1000000020779095155120082390; + bpsToRay[9258] = 1000000020780741775535495446; + bpsToRay[9259] = 1000000020782388310449941971; + bpsToRay[9260] = 1000000020784034759872300801; + bpsToRay[9261] = 1000000020785681123811449386; + bpsToRay[9262] = 1000000020787327402276263798; + bpsToRay[9263] = 1000000020788973595275618725; + bpsToRay[9264] = 1000000020790619702818387471; + bpsToRay[9265] = 1000000020792265724913441958; + bpsToRay[9266] = 1000000020793911661569652730; + bpsToRay[9267] = 1000000020795557512795888949; + bpsToRay[9268] = 1000000020797203278601018391; + bpsToRay[9269] = 1000000020798848958993907458; + bpsToRay[9270] = 1000000020800494553983421168; + bpsToRay[9271] = 1000000020802140063578423159; + bpsToRay[9272] = 1000000020803785487787775690; + bpsToRay[9273] = 1000000020805430826620339641; + bpsToRay[9274] = 1000000020807076080084974512; + bpsToRay[9275] = 1000000020808721248190538424; + bpsToRay[9276] = 1000000020810366330945888118; + bpsToRay[9277] = 1000000020812011328359878961; + bpsToRay[9278] = 1000000020813656240441364936; + bpsToRay[9279] = 1000000020815301067199198652; + bpsToRay[9280] = 1000000020816945808642231341; + bpsToRay[9281] = 1000000020818590464779312857; + bpsToRay[9282] = 1000000020820235035619291673; + bpsToRay[9283] = 1000000020821879521171014892; + bpsToRay[9284] = 1000000020823523921443328236; + bpsToRay[9285] = 1000000020825168236445076054; + bpsToRay[9286] = 1000000020826812466185101315; + bpsToRay[9287] = 1000000020828456610672245618; + bpsToRay[9288] = 1000000020830100669915349181; + bpsToRay[9289] = 1000000020831744643923250852; + bpsToRay[9290] = 1000000020833388532704788101; + bpsToRay[9291] = 1000000020835032336268797025; + bpsToRay[9292] = 1000000020836676054624112349; + bpsToRay[9293] = 1000000020838319687779567417; + bpsToRay[9294] = 1000000020839963235743994210; + bpsToRay[9295] = 1000000020841606698526223327; + bpsToRay[9296] = 1000000020843250076135083997; + bpsToRay[9297] = 1000000020844893368579404078; + bpsToRay[9298] = 1000000020846536575868010053; + bpsToRay[9299] = 1000000020848179698009727036; + bpsToRay[9300] = 1000000020849822735013378765; + bpsToRay[9301] = 1000000020851465686887787610; + bpsToRay[9302] = 1000000020853108553641774569; + bpsToRay[9303] = 1000000020854751335284159266; + bpsToRay[9304] = 1000000020856394031823759960; + bpsToRay[9305] = 1000000020858036643269393535; + bpsToRay[9306] = 1000000020859679169629875506; + bpsToRay[9307] = 1000000020861321610914020019; + bpsToRay[9308] = 1000000020862963967130639850; + bpsToRay[9309] = 1000000020864606238288546406; + bpsToRay[9310] = 1000000020866248424396549724; + bpsToRay[9311] = 1000000020867890525463458474; + bpsToRay[9312] = 1000000020869532541498079955; + bpsToRay[9313] = 1000000020871174472509220102; + bpsToRay[9314] = 1000000020872816318505683477; + bpsToRay[9315] = 1000000020874458079496273280; + bpsToRay[9316] = 1000000020876099755489791338; + bpsToRay[9317] = 1000000020877741346495038117; + bpsToRay[9318] = 1000000020879382852520812709; + bpsToRay[9319] = 1000000020881024273575912848; + bpsToRay[9320] = 1000000020882665609669134895; + bpsToRay[9321] = 1000000020884306860809273848; + bpsToRay[9322] = 1000000020885948027005123340; + bpsToRay[9323] = 1000000020887589108265475638; + bpsToRay[9324] = 1000000020889230104599121642; + bpsToRay[9325] = 1000000020890871016014850891; + bpsToRay[9326] = 1000000020892511842521451557; + bpsToRay[9327] = 1000000020894152584127710448; + bpsToRay[9328] = 1000000020895793240842413010; + bpsToRay[9329] = 1000000020897433812674343323; + bpsToRay[9330] = 1000000020899074299632284105; + bpsToRay[9331] = 1000000020900714701725016711; + bpsToRay[9332] = 1000000020902355018961321132; + bpsToRay[9333] = 1000000020903995251349975997; + bpsToRay[9334] = 1000000020905635398899758575; + bpsToRay[9335] = 1000000020907275461619444770; + bpsToRay[9336] = 1000000020908915439517809128; + bpsToRay[9337] = 1000000020910555332603624828; + bpsToRay[9338] = 1000000020912195140885663693; + bpsToRay[9339] = 1000000020913834864372696184; + bpsToRay[9340] = 1000000020915474503073491401; + bpsToRay[9341] = 1000000020917114056996817083; + bpsToRay[9342] = 1000000020918753526151439610; + bpsToRay[9343] = 1000000020920392910546124003; + bpsToRay[9344] = 1000000020922032210189633922; + bpsToRay[9345] = 1000000020923671425090731669; + bpsToRay[9346] = 1000000020925310555258178187; + bpsToRay[9347] = 1000000020926949600700733061; + bpsToRay[9348] = 1000000020928588561427154516; + bpsToRay[9349] = 1000000020930227437446199421; + bpsToRay[9350] = 1000000020931866228766623286; + bpsToRay[9351] = 1000000020933504935397180265; + bpsToRay[9352] = 1000000020935143557346623152; + bpsToRay[9353] = 1000000020936782094623703389; + bpsToRay[9354] = 1000000020938420547237171057; + bpsToRay[9355] = 1000000020940058915195774882; + bpsToRay[9356] = 1000000020941697198508262234; + bpsToRay[9357] = 1000000020943335397183379129; + bpsToRay[9358] = 1000000020944973511229870225; + bpsToRay[9359] = 1000000020946611540656478827; + bpsToRay[9360] = 1000000020948249485471946881; + bpsToRay[9361] = 1000000020949887345685014985; + bpsToRay[9362] = 1000000020951525121304422378; + bpsToRay[9363] = 1000000020953162812338906945; + bpsToRay[9364] = 1000000020954800418797205219; + bpsToRay[9365] = 1000000020956437940688052380; + bpsToRay[9366] = 1000000020958075378020182251; + bpsToRay[9367] = 1000000020959712730802327307; + bpsToRay[9368] = 1000000020961349999043218668; + bpsToRay[9369] = 1000000020962987182751586100; + bpsToRay[9370] = 1000000020964624281936158019; + bpsToRay[9371] = 1000000020966261296605661489; + bpsToRay[9372] = 1000000020967898226768822224; + bpsToRay[9373] = 1000000020969535072434364582; + bpsToRay[9374] = 1000000020971171833611011575; + bpsToRay[9375] = 1000000020972808510307484860; + bpsToRay[9376] = 1000000020974445102532504749; + bpsToRay[9377] = 1000000020976081610294790199; + bpsToRay[9378] = 1000000020977718033603058819; + bpsToRay[9379] = 1000000020979354372466026869; + bpsToRay[9380] = 1000000020980990626892409258; + bpsToRay[9381] = 1000000020982626796890919548; + bpsToRay[9382] = 1000000020984262882470269951; + bpsToRay[9383] = 1000000020985898883639171329; + bpsToRay[9384] = 1000000020987534800406333200; + bpsToRay[9385] = 1000000020989170632780463731; + bpsToRay[9386] = 1000000020990806380770269742; + bpsToRay[9387] = 1000000020992442044384456705; + bpsToRay[9388] = 1000000020994077623631728747; + bpsToRay[9389] = 1000000020995713118520788645; + bpsToRay[9390] = 1000000020997348529060337833; + bpsToRay[9391] = 1000000020998983855259076396; + bpsToRay[9392] = 1000000021000619097125703075; + bpsToRay[9393] = 1000000021002254254668915262; + bpsToRay[9394] = 1000000021003889327897409010; + bpsToRay[9395] = 1000000021005524316819879020; + bpsToRay[9396] = 1000000021007159221445018652; + bpsToRay[9397] = 1000000021008794041781519920; + bpsToRay[9398] = 1000000021010428777838073494; + bpsToRay[9399] = 1000000021012063429623368701; + bpsToRay[9400] = 1000000021013697997146093523; + bpsToRay[9401] = 1000000021015332480414934599; + bpsToRay[9402] = 1000000021016966879438577225; + bpsToRay[9403] = 1000000021018601194225705352; + bpsToRay[9404] = 1000000021020235424785001592; + bpsToRay[9405] = 1000000021021869571125147213; + bpsToRay[9406] = 1000000021023503633254822139; + bpsToRay[9407] = 1000000021025137611182704955; + bpsToRay[9408] = 1000000021026771504917472904; + bpsToRay[9409] = 1000000021028405314467801886; + bpsToRay[9410] = 1000000021030039039842366461; + bpsToRay[9411] = 1000000021031672681049839850; + bpsToRay[9412] = 1000000021033306238098893931; + bpsToRay[9413] = 1000000021034939710998199243; + bpsToRay[9414] = 1000000021036573099756424985; + bpsToRay[9415] = 1000000021038206404382239016; + bpsToRay[9416] = 1000000021039839624884307857; + bpsToRay[9417] = 1000000021041472761271296689; + bpsToRay[9418] = 1000000021043105813551869354; + bpsToRay[9419] = 1000000021044738781734688354; + bpsToRay[9420] = 1000000021046371665828414857; + bpsToRay[9421] = 1000000021048004465841708690; + bpsToRay[9422] = 1000000021049637181783228343; + bpsToRay[9423] = 1000000021051269813661630969; + bpsToRay[9424] = 1000000021052902361485572381; + bpsToRay[9425] = 1000000021054534825263707061; + bpsToRay[9426] = 1000000021056167205004688149; + bpsToRay[9427] = 1000000021057799500717167451; + bpsToRay[9428] = 1000000021059431712409795437; + bpsToRay[9429] = 1000000021061063840091221242; + bpsToRay[9430] = 1000000021062695883770092662; + bpsToRay[9431] = 1000000021064327843455056162; + bpsToRay[9432] = 1000000021065959719154756872; + bpsToRay[9433] = 1000000021067591510877838582; + bpsToRay[9434] = 1000000021069223218632943755; + bpsToRay[9435] = 1000000021070854842428713514; + bpsToRay[9436] = 1000000021072486382273787653; + bpsToRay[9437] = 1000000021074117838176804627; + bpsToRay[9438] = 1000000021075749210146401562; + bpsToRay[9439] = 1000000021077380498191214251; + bpsToRay[9440] = 1000000021079011702319877152; + bpsToRay[9441] = 1000000021080642822541023391; + bpsToRay[9442] = 1000000021082273858863284763; + bpsToRay[9443] = 1000000021083904811295291730; + bpsToRay[9444] = 1000000021085535679845673424; + bpsToRay[9445] = 1000000021087166464523057642; + bpsToRay[9446] = 1000000021088797165336070856; + bpsToRay[9447] = 1000000021090427782293338202; + bpsToRay[9448] = 1000000021092058315403483486; + bpsToRay[9449] = 1000000021093688764675129185; + bpsToRay[9450] = 1000000021095319130116896449; + bpsToRay[9451] = 1000000021096949411737405092; + bpsToRay[9452] = 1000000021098579609545273603; + bpsToRay[9453] = 1000000021100209723549119140; + bpsToRay[9454] = 1000000021101839753757557533; + bpsToRay[9455] = 1000000021103469700179203284; + bpsToRay[9456] = 1000000021105099562822669564; + bpsToRay[9457] = 1000000021106729341696568219; + bpsToRay[9458] = 1000000021108359036809509766; + bpsToRay[9459] = 1000000021109988648170103394; + bpsToRay[9460] = 1000000021111618175786956964; + bpsToRay[9461] = 1000000021113247619668677013; + bpsToRay[9462] = 1000000021114876979823868748; + bpsToRay[9463] = 1000000021116506256261136053; + bpsToRay[9464] = 1000000021118135448989081482; + bpsToRay[9465] = 1000000021119764558016306265; + bpsToRay[9466] = 1000000021121393583351410308; + bpsToRay[9467] = 1000000021123022525002992189; + bpsToRay[9468] = 1000000021124651382979649161; + bpsToRay[9469] = 1000000021126280157289977155; + bpsToRay[9470] = 1000000021127908847942570774; + bpsToRay[9471] = 1000000021129537454946023301; + bpsToRay[9472] = 1000000021131165978308926689; + bpsToRay[9473] = 1000000021132794418039871573; + bpsToRay[9474] = 1000000021134422774147447262; + bpsToRay[9475] = 1000000021136051046640241741; + bpsToRay[9476] = 1000000021137679235526841675; + bpsToRay[9477] = 1000000021139307340815832403; + bpsToRay[9478] = 1000000021140935362515797945; + bpsToRay[9479] = 1000000021142563300635320996; + bpsToRay[9480] = 1000000021144191155182982930; + bpsToRay[9481] = 1000000021145818926167363800; + bpsToRay[9482] = 1000000021147446613597042338; + bpsToRay[9483] = 1000000021149074217480595956; + bpsToRay[9484] = 1000000021150701737826600742; + bpsToRay[9485] = 1000000021152329174643631465; + bpsToRay[9486] = 1000000021153956527940261575; + bpsToRay[9487] = 1000000021155583797725063203; + bpsToRay[9488] = 1000000021157210984006607157; + bpsToRay[9489] = 1000000021158838086793462926; + bpsToRay[9490] = 1000000021160465106094198684; + bpsToRay[9491] = 1000000021162092041917381283; + bpsToRay[9492] = 1000000021163718894271576256; + bpsToRay[9493] = 1000000021165345663165347819; + bpsToRay[9494] = 1000000021166972348607258868; + bpsToRay[9495] = 1000000021168598950605870985; + bpsToRay[9496] = 1000000021170225469169744432; + bpsToRay[9497] = 1000000021171851904307438154; + bpsToRay[9498] = 1000000021173478256027509779; + bpsToRay[9499] = 1000000021175104524338515618; + bpsToRay[9500] = 1000000021176730709249010667; + bpsToRay[9501] = 1000000021178356810767548605; + bpsToRay[9502] = 1000000021179982828902681797; + bpsToRay[9503] = 1000000021181608763662961287; + bpsToRay[9504] = 1000000021183234615056936809; + bpsToRay[9505] = 1000000021184860383093156782; + bpsToRay[9506] = 1000000021186486067780168307; + bpsToRay[9507] = 1000000021188111669126517170; + bpsToRay[9508] = 1000000021189737187140747849; + bpsToRay[9509] = 1000000021191362621831403501; + bpsToRay[9510] = 1000000021192987973207025974; + bpsToRay[9511] = 1000000021194613241276155799; + bpsToRay[9512] = 1000000021196238426047332195; + bpsToRay[9513] = 1000000021197863527529093071; + bpsToRay[9514] = 1000000021199488545729975021; + bpsToRay[9515] = 1000000021201113480658513324; + bpsToRay[9516] = 1000000021202738332323241953; + bpsToRay[9517] = 1000000021204363100732693562; + bpsToRay[9518] = 1000000021205987785895399502; + bpsToRay[9519] = 1000000021207612387819889804; + bpsToRay[9520] = 1000000021209236906514693195; + bpsToRay[9521] = 1000000021210861341988337085; + bpsToRay[9522] = 1000000021212485694249347580; + bpsToRay[9523] = 1000000021214109963306249471; + bpsToRay[9524] = 1000000021215734149167566241; + bpsToRay[9525] = 1000000021217358251841820063; + bpsToRay[9526] = 1000000021218982271337531802; + bpsToRay[9527] = 1000000021220606207663221010; + bpsToRay[9528] = 1000000021222230060827405935; + bpsToRay[9529] = 1000000021223853830838603512; + bpsToRay[9530] = 1000000021225477517705329371; + bpsToRay[9531] = 1000000021227101121436097833; + bpsToRay[9532] = 1000000021228724642039421911; + bpsToRay[9533] = 1000000021230348079523813310; + bpsToRay[9534] = 1000000021231971433897782427; + bpsToRay[9535] = 1000000021233594705169838355; + bpsToRay[9536] = 1000000021235217893348488878; + bpsToRay[9537] = 1000000021236840998442240473; + bpsToRay[9538] = 1000000021238464020459598314; + bpsToRay[9539] = 1000000021240086959409066265; + bpsToRay[9540] = 1000000021241709815299146887; + bpsToRay[9541] = 1000000021243332588138341436; + bpsToRay[9542] = 1000000021244955277935149860; + bpsToRay[9543] = 1000000021246577884698070805; + bpsToRay[9544] = 1000000021248200408435601610; + bpsToRay[9545] = 1000000021249822849156238313; + bpsToRay[9546] = 1000000021251445206868475647; + bpsToRay[9547] = 1000000021253067481580807036; + bpsToRay[9548] = 1000000021254689673301724609; + bpsToRay[9549] = 1000000021256311782039719186; + bpsToRay[9550] = 1000000021257933807803280285; + bpsToRay[9551] = 1000000021259555750600896123; + bpsToRay[9552] = 1000000021261177610441053612; + bpsToRay[9553] = 1000000021262799387332238365; + bpsToRay[9554] = 1000000021264421081282934690; + bpsToRay[9555] = 1000000021266042692301625596; + bpsToRay[9556] = 1000000021267664220396792789; + bpsToRay[9557] = 1000000021269285665576916672; + bpsToRay[9558] = 1000000021270907027850476352; + bpsToRay[9559] = 1000000021272528307225949633; + bpsToRay[9560] = 1000000021274149503711813016; + bpsToRay[9561] = 1000000021275770617316541707; + bpsToRay[9562] = 1000000021277391648048609609; + bpsToRay[9563] = 1000000021279012595916489324; + bpsToRay[9564] = 1000000021280633460928652160; + bpsToRay[9565] = 1000000021282254243093568122; + bpsToRay[9566] = 1000000021283874942419705916; + bpsToRay[9567] = 1000000021285495558915532952; + bpsToRay[9568] = 1000000021287116092589515341; + bpsToRay[9569] = 1000000021288736543450117894; + bpsToRay[9570] = 1000000021290356911505804127; + bpsToRay[9571] = 1000000021291977196765036258; + bpsToRay[9572] = 1000000021293597399236275207; + bpsToRay[9573] = 1000000021295217518927980598; + bpsToRay[9574] = 1000000021296837555848610757; + bpsToRay[9575] = 1000000021298457510006622716; + bpsToRay[9576] = 1000000021300077381410472209; + bpsToRay[9577] = 1000000021301697170068613676; + bpsToRay[9578] = 1000000021303316875989500258; + bpsToRay[9579] = 1000000021304936499181583805; + bpsToRay[9580] = 1000000021306556039653314870; + bpsToRay[9581] = 1000000021308175497413142711; + bpsToRay[9582] = 1000000021309794872469515290; + bpsToRay[9583] = 1000000021311414164830879280; + bpsToRay[9584] = 1000000021313033374505680055; + bpsToRay[9585] = 1000000021314652501502361696; + bpsToRay[9586] = 1000000021316271545829366993; + bpsToRay[9587] = 1000000021317890507495137440; + bpsToRay[9588] = 1000000021319509386508113242; + bpsToRay[9589] = 1000000021321128182876733306; + bpsToRay[9590] = 1000000021322746896609435252; + bpsToRay[9591] = 1000000021324365527714655404; + bpsToRay[9592] = 1000000021325984076200828797; + bpsToRay[9593] = 1000000021327602542076389171; + bpsToRay[9594] = 1000000021329220925349768978; + bpsToRay[9595] = 1000000021330839226029399378; + bpsToRay[9596] = 1000000021332457444123710238; + bpsToRay[9597] = 1000000021334075579641130140; + bpsToRay[9598] = 1000000021335693632590086368; + bpsToRay[9599] = 1000000021337311602979004923; + bpsToRay[9600] = 1000000021338929490816310513; + bpsToRay[9601] = 1000000021340547296110426556; + bpsToRay[9602] = 1000000021342165018869775181; + bpsToRay[9603] = 1000000021343782659102777232; + bpsToRay[9604] = 1000000021345400216817852259; + bpsToRay[9605] = 1000000021347017692023418526; + bpsToRay[9606] = 1000000021348635084727893008; + bpsToRay[9607] = 1000000021350252394939691393; + bpsToRay[9608] = 1000000021351869622667228081; + bpsToRay[9609] = 1000000021353486767918916187; + bpsToRay[9610] = 1000000021355103830703167533; + bpsToRay[9611] = 1000000021356720811028392661; + bpsToRay[9612] = 1000000021358337708903000822; + bpsToRay[9613] = 1000000021359954524335399980; + bpsToRay[9614] = 1000000021361571257333996817; + bpsToRay[9615] = 1000000021363187907907196727; + bpsToRay[9616] = 1000000021364804476063403818; + bpsToRay[9617] = 1000000021366420961811020914; + bpsToRay[9618] = 1000000021368037365158449552; + bpsToRay[9619] = 1000000021369653686114089987; + bpsToRay[9620] = 1000000021371269924686341187; + bpsToRay[9621] = 1000000021372886080883600836; + bpsToRay[9622] = 1000000021374502154714265338; + bpsToRay[9623] = 1000000021376118146186729808; + bpsToRay[9624] = 1000000021377734055309388080; + bpsToRay[9625] = 1000000021379349882090632705; + bpsToRay[9626] = 1000000021380965626538854950; + bpsToRay[9627] = 1000000021382581288662444801; + bpsToRay[9628] = 1000000021384196868469790961; + bpsToRay[9629] = 1000000021385812365969280848; + bpsToRay[9630] = 1000000021387427781169300605; + bpsToRay[9631] = 1000000021389043114078235086; + bpsToRay[9632] = 1000000021390658364704467867; + bpsToRay[9633] = 1000000021392273533056381244; + bpsToRay[9634] = 1000000021393888619142356230; + bpsToRay[9635] = 1000000021395503622970772558; + bpsToRay[9636] = 1000000021397118544550008682; + bpsToRay[9637] = 1000000021398733383888441774; + bpsToRay[9638] = 1000000021400348140994447728; + bpsToRay[9639] = 1000000021401962815876401158; + bpsToRay[9640] = 1000000021403577408542675398; + bpsToRay[9641] = 1000000021405191919001642503; + bpsToRay[9642] = 1000000021406806347261673250; + bpsToRay[9643] = 1000000021408420693331137139; + bpsToRay[9644] = 1000000021410034957218402388; + bpsToRay[9645] = 1000000021411649138931835939; + bpsToRay[9646] = 1000000021413263238479803458; + bpsToRay[9647] = 1000000021414877255870669331; + bpsToRay[9648] = 1000000021416491191112796669; + bpsToRay[9649] = 1000000021418105044214547303; + bpsToRay[9650] = 1000000021419718815184281790; + bpsToRay[9651] = 1000000021421332504030359411; + bpsToRay[9652] = 1000000021422946110761138169; + bpsToRay[9653] = 1000000021424559635384974793; + bpsToRay[9654] = 1000000021426173077910224732; + bpsToRay[9655] = 1000000021427786438345242167; + bpsToRay[9656] = 1000000021429399716698379997; + bpsToRay[9657] = 1000000021431012912977989851; + bpsToRay[9658] = 1000000021432626027192422079; + bpsToRay[9659] = 1000000021434239059350025762; + bpsToRay[9660] = 1000000021435852009459148702; + bpsToRay[9661] = 1000000021437464877528137431; + bpsToRay[9662] = 1000000021439077663565337204; + bpsToRay[9663] = 1000000021440690367579092006; + bpsToRay[9664] = 1000000021442302989577744547; + bpsToRay[9665] = 1000000021443915529569636263; + bpsToRay[9666] = 1000000021445527987563107323; + bpsToRay[9667] = 1000000021447140363566496615; + bpsToRay[9668] = 1000000021448752657588141766; + bpsToRay[9669] = 1000000021450364869636379120; + bpsToRay[9670] = 1000000021451976999719543756; + bpsToRay[9671] = 1000000021453589047845969483; + bpsToRay[9672] = 1000000021455201014023988834; + bpsToRay[9673] = 1000000021456812898261933077; + bpsToRay[9674] = 1000000021458424700568132203; + bpsToRay[9675] = 1000000021460036420950914938; + bpsToRay[9676] = 1000000021461648059418608738; + bpsToRay[9677] = 1000000021463259615979539784; + bpsToRay[9678] = 1000000021464871090642032996; + bpsToRay[9679] = 1000000021466482483414412017; + bpsToRay[9680] = 1000000021468093794304999225; + bpsToRay[9681] = 1000000021469705023322115729; + bpsToRay[9682] = 1000000021471316170474081370; + bpsToRay[9683] = 1000000021472927235769214720; + bpsToRay[9684] = 1000000021474538219215833083; + bpsToRay[9685] = 1000000021476149120822252496; + bpsToRay[9686] = 1000000021477759940596787728; + bpsToRay[9687] = 1000000021479370678547752283; + bpsToRay[9688] = 1000000021480981334683458396; + bpsToRay[9689] = 1000000021482591909012217035; + bpsToRay[9690] = 1000000021484202401542337904; + bpsToRay[9691] = 1000000021485812812282129439; + bpsToRay[9692] = 1000000021487423141239898812; + bpsToRay[9693] = 1000000021489033388423951926; + bpsToRay[9694] = 1000000021490643553842593424; + bpsToRay[9695] = 1000000021492253637504126680; + bpsToRay[9696] = 1000000021493863639416853802; + bpsToRay[9697] = 1000000021495473559589075640; + bpsToRay[9698] = 1000000021497083398029091773; + bpsToRay[9699] = 1000000021498693154745200519; + bpsToRay[9700] = 1000000021500302829745698932; + bpsToRay[9701] = 1000000021501912423038882802; + bpsToRay[9702] = 1000000021503521934633046657; + bpsToRay[9703] = 1000000021505131364536483760; + bpsToRay[9704] = 1000000021506740712757486113; + bpsToRay[9705] = 1000000021508349979304344456; + bpsToRay[9706] = 1000000021509959164185348265; + bpsToRay[9707] = 1000000021511568267408785753; + bpsToRay[9708] = 1000000021513177288982943876; + bpsToRay[9709] = 1000000021514786228916108326; + bpsToRay[9710] = 1000000021516395087216563531; + bpsToRay[9711] = 1000000021518003863892592663; + bpsToRay[9712] = 1000000021519612558952477629; + bpsToRay[9713] = 1000000021521221172404499080; + bpsToRay[9714] = 1000000021522829704256936402; + bpsToRay[9715] = 1000000021524438154518067725; + bpsToRay[9716] = 1000000021526046523196169918; + bpsToRay[9717] = 1000000021527654810299518591; + bpsToRay[9718] = 1000000021529263015836388092; + bpsToRay[9719] = 1000000021530871139815051515; + bpsToRay[9720] = 1000000021532479182243780693; + bpsToRay[9721] = 1000000021534087143130846199; + bpsToRay[9722] = 1000000021535695022484517350; + bpsToRay[9723] = 1000000021537302820313062204; + bpsToRay[9724] = 1000000021538910536624747565; + bpsToRay[9725] = 1000000021540518171427838973; + bpsToRay[9726] = 1000000021542125724730600717; + bpsToRay[9727] = 1000000021543733196541295825; + bpsToRay[9728] = 1000000021545340586868186072; + bpsToRay[9729] = 1000000021546947895719531973; + bpsToRay[9730] = 1000000021548555123103592792; + bpsToRay[9731] = 1000000021550162269028626530; + bpsToRay[9732] = 1000000021551769333502889939; + bpsToRay[9733] = 1000000021553376316534638512; + bpsToRay[9734] = 1000000021554983218132126488; + bpsToRay[9735] = 1000000021556590038303606853; + bpsToRay[9736] = 1000000021558196777057331335; + bpsToRay[9737] = 1000000021559803434401550410; + bpsToRay[9738] = 1000000021561410010344513300; + bpsToRay[9739] = 1000000021563016504894467972; + bpsToRay[9740] = 1000000021564622918059661140; + bpsToRay[9741] = 1000000021566229249848338266; + bpsToRay[9742] = 1000000021567835500268743557; + bpsToRay[9743] = 1000000021569441669329119967; + bpsToRay[9744] = 1000000021571047757037709200; + bpsToRay[9745] = 1000000021572653763402751707; + bpsToRay[9746] = 1000000021574259688432486685; + bpsToRay[9747] = 1000000021575865532135152081; + bpsToRay[9748] = 1000000021577471294518984591; + bpsToRay[9749] = 1000000021579076975592219657; + bpsToRay[9750] = 1000000021580682575363091474; + bpsToRay[9751] = 1000000021582288093839832982; + bpsToRay[9752] = 1000000021583893531030675874; + bpsToRay[9753] = 1000000021585498886943850592; + bpsToRay[9754] = 1000000021587104161587586327; + bpsToRay[9755] = 1000000021588709354970111019; + bpsToRay[9756] = 1000000021590314467099651363; + bpsToRay[9757] = 1000000021591919497984432801; + bpsToRay[9758] = 1000000021593524447632679526; + bpsToRay[9759] = 1000000021595129316052614485; + bpsToRay[9760] = 1000000021596734103252459374; + bpsToRay[9761] = 1000000021598338809240434642; + bpsToRay[9762] = 1000000021599943434024759490; + bpsToRay[9763] = 1000000021601547977613651871; + bpsToRay[9764] = 1000000021603152440015328491; + bpsToRay[9765] = 1000000021604756821238004808; + bpsToRay[9766] = 1000000021606361121289895034; + bpsToRay[9767] = 1000000021607965340179212134; + bpsToRay[9768] = 1000000021609569477914167825; + bpsToRay[9769] = 1000000021611173534502972580; + bpsToRay[9770] = 1000000021612777509953835627; + bpsToRay[9771] = 1000000021614381404274964943; + bpsToRay[9772] = 1000000021615985217474567267; + bpsToRay[9773] = 1000000021617588949560848087; + bpsToRay[9774] = 1000000021619192600542011648; + bpsToRay[9775] = 1000000021620796170426260951; + bpsToRay[9776] = 1000000021622399659221797752; + bpsToRay[9777] = 1000000021624003066936822564; + bpsToRay[9778] = 1000000021625606393579534651; + bpsToRay[9779] = 1000000021627209639158132043; + bpsToRay[9780] = 1000000021628812803680811515; + bpsToRay[9781] = 1000000021630415887155768610; + bpsToRay[9782] = 1000000021632018889591197618; + bpsToRay[9783] = 1000000021633621810995291595; + bpsToRay[9784] = 1000000021635224651376242349; + bpsToRay[9785] = 1000000021636827410742240447; + bpsToRay[9786] = 1000000021638430089101475216; + bpsToRay[9787] = 1000000021640032686462134738; + bpsToRay[9788] = 1000000021641635202832405858; + bpsToRay[9789] = 1000000021643237638220474177; + bpsToRay[9790] = 1000000021644839992634524055; + bpsToRay[9791] = 1000000021646442266082738611; + bpsToRay[9792] = 1000000021648044458573299725; + bpsToRay[9793] = 1000000021649646570114388037; + bpsToRay[9794] = 1000000021651248600714182947; + bpsToRay[9795] = 1000000021652850550380862614; + bpsToRay[9796] = 1000000021654452419122603958; + bpsToRay[9797] = 1000000021656054206947582660; + bpsToRay[9798] = 1000000021657655913863973164; + bpsToRay[9799] = 1000000021659257539879948673; + bpsToRay[9800] = 1000000021660859085003681151; + bpsToRay[9801] = 1000000021662460549243341328; + bpsToRay[9802] = 1000000021664061932607098690; + bpsToRay[9803] = 1000000021665663235103121490; + bpsToRay[9804] = 1000000021667264456739576744; + bpsToRay[9805] = 1000000021668865597524630226; + bpsToRay[9806] = 1000000021670466657466446478; + bpsToRay[9807] = 1000000021672067636573188805; + bpsToRay[9808] = 1000000021673668534853019271; + bpsToRay[9809] = 1000000021675269352314098709; + bpsToRay[9810] = 1000000021676870088964586713; + bpsToRay[9811] = 1000000021678470744812641643; + bpsToRay[9812] = 1000000021680071319866420625; + bpsToRay[9813] = 1000000021681671814134079545; + bpsToRay[9814] = 1000000021683272227623773058; + bpsToRay[9815] = 1000000021684872560343654583; + bpsToRay[9816] = 1000000021686472812301876306; + bpsToRay[9817] = 1000000021688072983506589178; + bpsToRay[9818] = 1000000021689673073965942915; + bpsToRay[9819] = 1000000021691273083688086000; + bpsToRay[9820] = 1000000021692873012681165684; + bpsToRay[9821] = 1000000021694472860953327982; + bpsToRay[9822] = 1000000021696072628512717681; + bpsToRay[9823] = 1000000021697672315367478329; + bpsToRay[9824] = 1000000021699271921525752246; + bpsToRay[9825] = 1000000021700871446995680519; + bpsToRay[9826] = 1000000021702470891785403001; + bpsToRay[9827] = 1000000021704070255903058316; + bpsToRay[9828] = 1000000021705669539356783857; + bpsToRay[9829] = 1000000021707268742154715782; + bpsToRay[9830] = 1000000021708867864304989022; + bpsToRay[9831] = 1000000021710466905815737276; + bpsToRay[9832] = 1000000021712065866695093012; + bpsToRay[9833] = 1000000021713664746951187467; + bpsToRay[9834] = 1000000021715263546592150652; + bpsToRay[9835] = 1000000021716862265626111344; + bpsToRay[9836] = 1000000021718460904061197091; + bpsToRay[9837] = 1000000021720059461905534215; + bpsToRay[9838] = 1000000021721657939167247807; + bpsToRay[9839] = 1000000021723256335854461729; + bpsToRay[9840] = 1000000021724854651975298614; + bpsToRay[9841] = 1000000021726452887537879870; + bpsToRay[9842] = 1000000021728051042550325673; + bpsToRay[9843] = 1000000021729649117020754974; + bpsToRay[9844] = 1000000021731247110957285495; + bpsToRay[9845] = 1000000021732845024368033733; + bpsToRay[9846] = 1000000021734442857261114954; + bpsToRay[9847] = 1000000021736040609644643201; + bpsToRay[9848] = 1000000021737638281526731291; + bpsToRay[9849] = 1000000021739235872915490812; + bpsToRay[9850] = 1000000021740833383819032127; + bpsToRay[9851] = 1000000021742430814245464373; + bpsToRay[9852] = 1000000021744028164202895462; + bpsToRay[9853] = 1000000021745625433699432083; + bpsToRay[9854] = 1000000021747222622743179696; + bpsToRay[9855] = 1000000021748819731342242539; + bpsToRay[9856] = 1000000021750416759504723623; + bpsToRay[9857] = 1000000021752013707238724737; + bpsToRay[9858] = 1000000021753610574552346447; + bpsToRay[9859] = 1000000021755207361453688091; + bpsToRay[9860] = 1000000021756804067950847789; + bpsToRay[9861] = 1000000021758400694051922433; + bpsToRay[9862] = 1000000021759997239765007694; + bpsToRay[9863] = 1000000021761593705098198022; + bpsToRay[9864] = 1000000021763190090059586640; + bpsToRay[9865] = 1000000021764786394657265553; + bpsToRay[9866] = 1000000021766382618899325542; + bpsToRay[9867] = 1000000021767978762793856166; + bpsToRay[9868] = 1000000021769574826348945765; + bpsToRay[9869] = 1000000021771170809572681453; + bpsToRay[9870] = 1000000021772766712473149127; + bpsToRay[9871] = 1000000021774362535058433462; + bpsToRay[9872] = 1000000021775958277336617913; + bpsToRay[9873] = 1000000021777553939315784714; + bpsToRay[9874] = 1000000021779149521004014877; + bpsToRay[9875] = 1000000021780745022409388199; + bpsToRay[9876] = 1000000021782340443539983254; + bpsToRay[9877] = 1000000021783935784403877396; + bpsToRay[9878] = 1000000021785531045009146762; + bpsToRay[9879] = 1000000021787126225363866271; + bpsToRay[9880] = 1000000021788721325476109620; + bpsToRay[9881] = 1000000021790316345353949290; + bpsToRay[9882] = 1000000021791911285005456544; + bpsToRay[9883] = 1000000021793506144438701426; + bpsToRay[9884] = 1000000021795100923661752763; + bpsToRay[9885] = 1000000021796695622682678165; + bpsToRay[9886] = 1000000021798290241509544024; + bpsToRay[9887] = 1000000021799884780150415518; + bpsToRay[9888] = 1000000021801479238613356603; + bpsToRay[9889] = 1000000021803073616906430024; + bpsToRay[9890] = 1000000021804667915037697306; + bpsToRay[9891] = 1000000021806262133015218760; + bpsToRay[9892] = 1000000021807856270847053482; + bpsToRay[9893] = 1000000021809450328541259351; + bpsToRay[9894] = 1000000021811044306105893031; + bpsToRay[9895] = 1000000021812638203549009974; + bpsToRay[9896] = 1000000021814232020878664411; + bpsToRay[9897] = 1000000021815825758102909365; + bpsToRay[9898] = 1000000021817419415229796642; + bpsToRay[9899] = 1000000021819012992267376834; + bpsToRay[9900] = 1000000021820606489223699321; + bpsToRay[9901] = 1000000021822199906106812267; + bpsToRay[9902] = 1000000021823793242924762624; + bpsToRay[9903] = 1000000021825386499685596130; + bpsToRay[9904] = 1000000021826979676397357315; + bpsToRay[9905] = 1000000021828572773068089490; + bpsToRay[9906] = 1000000021830165789705834758; + bpsToRay[9907] = 1000000021831758726318634008; + bpsToRay[9908] = 1000000021833351582914526918; + bpsToRay[9909] = 1000000021834944359501551955; + bpsToRay[9910] = 1000000021836537056087746374; + bpsToRay[9911] = 1000000021838129672681146219; + bpsToRay[9912] = 1000000021839722209289786324; + bpsToRay[9913] = 1000000021841314665921700311; + bpsToRay[9914] = 1000000021842907042584920594; + bpsToRay[9915] = 1000000021844499339287478375; + bpsToRay[9916] = 1000000021846091556037403647; + bpsToRay[9917] = 1000000021847683692842725193; + bpsToRay[9918] = 1000000021849275749711470586; + bpsToRay[9919] = 1000000021850867726651666193; + bpsToRay[9920] = 1000000021852459623671337169; + bpsToRay[9921] = 1000000021854051440778507461; + bpsToRay[9922] = 1000000021855643177981199810; + bpsToRay[9923] = 1000000021857234835287435745; + bpsToRay[9924] = 1000000021858826412705235591; + bpsToRay[9925] = 1000000021860417910242618463; + bpsToRay[9926] = 1000000021862009327907602268; + bpsToRay[9927] = 1000000021863600665708203710; + bpsToRay[9928] = 1000000021865191923652438280; + bpsToRay[9929] = 1000000021866783101748320269; + bpsToRay[9930] = 1000000021868374200003862755; + bpsToRay[9931] = 1000000021869965218427077615; + bpsToRay[9932] = 1000000021871556157025975518; + bpsToRay[9933] = 1000000021873147015808565927; + bpsToRay[9934] = 1000000021874737794782857101; + bpsToRay[9935] = 1000000021876328493956856091; + bpsToRay[9936] = 1000000021877919113338568748; + bpsToRay[9937] = 1000000021879509652935999713; + bpsToRay[9938] = 1000000021881100112757152424; + bpsToRay[9939] = 1000000021882690492810029118; + bpsToRay[9940] = 1000000021884280793102630824; + bpsToRay[9941] = 1000000021885871013642957370; + bpsToRay[9942] = 1000000021887461154439007378; + bpsToRay[9943] = 1000000021889051215498778269; + bpsToRay[9944] = 1000000021890641196830266260; + bpsToRay[9945] = 1000000021892231098441466365; + bpsToRay[9946] = 1000000021893820920340372396; + bpsToRay[9947] = 1000000021895410662534976963; + bpsToRay[9948] = 1000000021897000325033271473; + bpsToRay[9949] = 1000000021898589907843246131; + bpsToRay[9950] = 1000000021900179410972889943; + bpsToRay[9951] = 1000000021901768834430190709; + bpsToRay[9952] = 1000000021903358178223135034; + bpsToRay[9953] = 1000000021904947442359708315; + bpsToRay[9954] = 1000000021906536626847894756; + bpsToRay[9955] = 1000000021908125731695677355; + bpsToRay[9956] = 1000000021909714756911037912; + bpsToRay[9957] = 1000000021911303702501957027; + bpsToRay[9958] = 1000000021912892568476414100; + bpsToRay[9959] = 1000000021914481354842387331; + bpsToRay[9960] = 1000000021916070061607853724; + bpsToRay[9961] = 1000000021917658688780789081; + bpsToRay[9962] = 1000000021919247236369168005; + bpsToRay[9963] = 1000000021920835704380963901; + bpsToRay[9964] = 1000000021922424092824148978; + bpsToRay[9965] = 1000000021924012401706694246; + bpsToRay[9966] = 1000000021925600631036569516; + bpsToRay[9967] = 1000000021927188780821743402; + bpsToRay[9968] = 1000000021928776851070183322; + bpsToRay[9969] = 1000000021930364841789855494; + bpsToRay[9970] = 1000000021931952752988724944; + bpsToRay[9971] = 1000000021933540584674755497; + bpsToRay[9972] = 1000000021935128336855909784; + bpsToRay[9973] = 1000000021936716009540149239; + bpsToRay[9974] = 1000000021938303602735434102; + bpsToRay[9975] = 1000000021939891116449723415; + bpsToRay[9976] = 1000000021941478550690975027; + bpsToRay[9977] = 1000000021943065905467145588; + bpsToRay[9978] = 1000000021944653180786190559; + bpsToRay[9979] = 1000000021946240376656064202; + bpsToRay[9980] = 1000000021947827493084719585; + bpsToRay[9981] = 1000000021949414530080108585; + bpsToRay[9982] = 1000000021951001487650181881; + bpsToRay[9983] = 1000000021952588365802888961; + bpsToRay[9984] = 1000000021954175164546178118; + bpsToRay[9985] = 1000000021955761883887996454; + bpsToRay[9986] = 1000000021957348523836289875; + bpsToRay[9987] = 1000000021958935084399003098; + bpsToRay[9988] = 1000000021960521565584079645; + bpsToRay[9989] = 1000000021962107967399461846; + bpsToRay[9990] = 1000000021963694289853090839; + bpsToRay[9991] = 1000000021965280532952906572; + bpsToRay[9992] = 1000000021966866696706847799; + bpsToRay[9993] = 1000000021968452781122852084; + bpsToRay[9994] = 1000000021970038786208855800; + bpsToRay[9995] = 1000000021971624711972794130; + bpsToRay[9996] = 1000000021973210558422601065; + bpsToRay[9997] = 1000000021974796325566209405; + bpsToRay[9998] = 1000000021976382013411550763; + bpsToRay[9999] = 1000000021977967621966555560; + bpsToRay[10000] = 1000000021979553151239153027; - ray := add(and(shifted, 0xFFFFFFFFFFFFFFFF), RAY) - } + rayToBps[1000000000000000000000000000] = 0; + rayToBps[1000000000003170820659990704] = 1; + rayToBps[1000000000006341324285480111] = 2; + rayToBps[1000000000009511510939859271] = 3; + rayToBps[1000000000012681380686500226] = 4; + rayToBps[1000000000015850933588756013] = 5; + rayToBps[1000000000019020169709960675] = 6; + rayToBps[1000000000022189089113429267] = 7; + rayToBps[1000000000025357691862457863] = 8; + rayToBps[1000000000028525978020323563] = 9; + rayToBps[1000000000031693947650284507] = 10; + rayToBps[1000000000034861600815579870] = 11; + rayToBps[1000000000038028937579429884] = 12; + rayToBps[1000000000041195958005035834] = 13; + rayToBps[1000000000044362662155580072] = 14; + rayToBps[1000000000047529050094226024] = 15; + rayToBps[1000000000050695121884118193] = 16; + rayToBps[1000000000053860877588382173] = 17; + rayToBps[1000000000057026317270124651] = 18; + rayToBps[1000000000060191440992433418] = 19; + rayToBps[1000000000063356248818377377] = 20; + rayToBps[1000000000066520740811006546] = 21; + rayToBps[1000000000069684917033352071] = 22; + rayToBps[1000000000072848777548426231] = 23; + rayToBps[1000000000076012322419222442] = 24; + rayToBps[1000000000079175551708715274] = 25; + rayToBps[1000000000082338465479860449] = 26; + rayToBps[1000000000085501063795594852] = 27; + rayToBps[1000000000088663346718836541] = 28; + rayToBps[1000000000091825314312484750] = 29; + rayToBps[1000000000094986966639419899] = 30; + rayToBps[1000000000098148303762503603] = 31; + rayToBps[1000000000101309325744578677] = 32; + rayToBps[1000000000104470032648469142] = 33; + rayToBps[1000000000107630424536980239] = 34; + rayToBps[1000000000110790501472898427] = 35; + rayToBps[1000000000113950263518991400] = 36; + rayToBps[1000000000117109710738008089] = 37; + rayToBps[1000000000120268843192678669] = 38; + rayToBps[1000000000123427660945714570] = 39; + rayToBps[1000000000126586164059808482] = 40; + rayToBps[1000000000129744352597634363] = 41; + rayToBps[1000000000132902226621847447] = 42; + rayToBps[1000000000136059786195084249] = 43; + rayToBps[1000000000139217031379962578] = 44; + rayToBps[1000000000142373962239081538] = 45; + rayToBps[1000000000145530578835021538] = 46; + rayToBps[1000000000148686881230344303] = 47; + rayToBps[1000000000151842869487592874] = 48; + rayToBps[1000000000154998543669291624] = 49; + rayToBps[1000000000158153903837946257] = 50; + rayToBps[1000000000161308950056043822] = 51; + rayToBps[1000000000164463682386052718] = 52; + rayToBps[1000000000167618100890422700] = 53; + rayToBps[1000000000170772205631584889] = 54; + rayToBps[1000000000173925996671951777] = 55; + rayToBps[1000000000177079474073917237] = 56; + rayToBps[1000000000180232637899856526] = 57; + rayToBps[1000000000183385488212126301] = 58; + rayToBps[1000000000186538025073064615] = 59; + rayToBps[1000000000189690248544990934] = 60; + rayToBps[1000000000192842158690206138] = 61; + rayToBps[1000000000195993755570992533] = 62; + rayToBps[1000000000199145039249613856] = 63; + rayToBps[1000000000202296009788315281] = 64; + rayToBps[1000000000205446667249323430] = 65; + rayToBps[1000000000208597011694846379] = 66; + rayToBps[1000000000211747043187073663] = 67; + rayToBps[1000000000214896761788176285] = 68; + rayToBps[1000000000218046167560306726] = 69; + rayToBps[1000000000221195260565598948] = 70; + rayToBps[1000000000224344040866168404] = 71; + rayToBps[1000000000227492508524112044] = 72; + rayToBps[1000000000230640663601508324] = 73; + rayToBps[1000000000233788506160417212] = 74; + rayToBps[1000000000236936036262880196] = 75; + rayToBps[1000000000240083253970920290] = 76; + rayToBps[1000000000243230159346542043] = 77; + rayToBps[1000000000246376752451731545] = 78; + rayToBps[1000000000249523033348456436] = 79; + rayToBps[1000000000252669002098665913] = 80; + rayToBps[1000000000255814658764290734] = 81; + rayToBps[1000000000258960003407243230] = 82; + rayToBps[1000000000262105036089417311] = 83; + rayToBps[1000000000265249756872688471] = 84; + rayToBps[1000000000268394165818913798] = 85; + rayToBps[1000000000271538262989931978] = 86; + rayToBps[1000000000274682048447563305] = 87; + rayToBps[1000000000277825522253609693] = 88; + rayToBps[1000000000280968684469854670] = 89; + rayToBps[1000000000284111535158063399] = 90; + rayToBps[1000000000287254074379982678] = 91; + rayToBps[1000000000290396302197340948] = 92; + rayToBps[1000000000293538218671848302] = 93; + rayToBps[1000000000296679823865196492] = 94; + rayToBps[1000000000299821117839058936] = 95; + rayToBps[1000000000302962100655090723] = 96; + rayToBps[1000000000306102772374928623] = 97; + rayToBps[1000000000309243133060191095] = 98; + rayToBps[1000000000312383182772478292] = 99; + rayToBps[1000000000315522921573372069] = 100; + rayToBps[1000000000318662349524435988] = 101; + rayToBps[1000000000321801466687215330] = 102; + rayToBps[1000000000324940273123237102] = 103; + rayToBps[1000000000328078768894010037] = 104; + rayToBps[1000000000331216954061024608] = 105; + rayToBps[1000000000334354828685753035] = 106; + rayToBps[1000000000337492392829649290] = 107; + rayToBps[1000000000340629646554149104] = 108; + rayToBps[1000000000343766589920669975] = 109; + rayToBps[1000000000346903222990611176] = 110; + rayToBps[1000000000350039545825353762] = 111; + rayToBps[1000000000353175558486260576] = 112; + rayToBps[1000000000356311261034676258] = 113; + rayToBps[1000000000359446653531927249] = 114; + rayToBps[1000000000362581736039321802] = 115; + rayToBps[1000000000365716508618149987] = 116; + rayToBps[1000000000368850971329683699] = 117; + rayToBps[1000000000371985124235176666] = 118; + rayToBps[1000000000375118967395864451] = 119; + rayToBps[1000000000378252500872964469] = 120; + rayToBps[1000000000381385724727675984] = 121; + rayToBps[1000000000384518639021180123] = 122; + rayToBps[1000000000387651243814639879] = 123; + rayToBps[1000000000390783539169200122] = 124; + rayToBps[1000000000393915525145987602] = 125; + rayToBps[1000000000397047201806110961] = 126; + rayToBps[1000000000400178569210660733] = 127; + rayToBps[1000000000403309627420709360] = 128; + rayToBps[1000000000406440376497311193] = 129; + rayToBps[1000000000409570816501502501] = 130; + rayToBps[1000000000412700947494301478] = 131; + rayToBps[1000000000415830769536708248] = 132; + rayToBps[1000000000418960282689704878] = 133; + rayToBps[1000000000422089487014255380] = 134; + rayToBps[1000000000425218382571305718] = 135; + rayToBps[1000000000428346969421783819] = 136; + rayToBps[1000000000431475247626599574] = 137; + rayToBps[1000000000434603217246644855] = 138; + rayToBps[1000000000437730878342793510] = 139; + rayToBps[1000000000440858230975901380] = 140; + rayToBps[1000000000443985275206806300] = 141; + rayToBps[1000000000447112011096328109] = 142; + rayToBps[1000000000450238438705268656] = 143; + rayToBps[1000000000453364558094411809] = 144; + rayToBps[1000000000456490369324523458] = 145; + rayToBps[1000000000459615872456351529] = 146; + rayToBps[1000000000462741067550625980] = 147; + rayToBps[1000000000465865954668058822] = 148; + rayToBps[1000000000468990533869344115] = 149; + rayToBps[1000000000472114805215157978] = 150; + rayToBps[1000000000475238768766158601] = 151; + rayToBps[1000000000478362424582986244] = 152; + rayToBps[1000000000481485772726263252] = 153; + rayToBps[1000000000484608813256594054] = 154; + rayToBps[1000000000487731546234565179] = 155; + rayToBps[1000000000490853971720745253] = 156; + rayToBps[1000000000493976089775685018] = 157; + rayToBps[1000000000497097900459917326] = 158; + rayToBps[1000000000500219403833957155] = 159; + rayToBps[1000000000503340599958301616] = 160; + rayToBps[1000000000506461488893429953] = 161; + rayToBps[1000000000509582070699803560] = 162; + rayToBps[1000000000512702345437865976] = 163; + rayToBps[1000000000515822313168042905] = 164; + rayToBps[1000000000518941973950742212] = 165; + rayToBps[1000000000522061327846353937] = 166; + rayToBps[1000000000525180374915250300] = 167; + rayToBps[1000000000528299115217785706] = 168; + rayToBps[1000000000531417548814296756] = 169; + rayToBps[1000000000534535675765102249] = 170; + rayToBps[1000000000537653496130503193] = 171; + rayToBps[1000000000540771009970782812] = 172; + rayToBps[1000000000543888217346206550] = 173; + rayToBps[1000000000547005118317022080] = 174; + rayToBps[1000000000550121712943459312] = 175; + rayToBps[1000000000553238001285730395] = 176; + rayToBps[1000000000556353983404029733] = 177; + rayToBps[1000000000559469659358533982] = 178; + rayToBps[1000000000562585029209402065] = 179; + rayToBps[1000000000565700093016775172] = 180; + rayToBps[1000000000568814850840776775] = 181; + rayToBps[1000000000571929302741512626] = 182; + rayToBps[1000000000575043448779070771] = 183; + rayToBps[1000000000578157289013521555] = 184; + rayToBps[1000000000581270823504917627] = 185; + rayToBps[1000000000584384052313293946] = 186; + rayToBps[1000000000587496975498667797] = 187; + rayToBps[1000000000590609593121038783] = 188; + rayToBps[1000000000593721905240388847] = 189; + rayToBps[1000000000596833911916682269] = 190; + rayToBps[1000000000599945613209865674] = 191; + rayToBps[1000000000603057009179868046] = 192; + rayToBps[1000000000606168099886600725] = 193; + rayToBps[1000000000609278885389957423] = 194; + rayToBps[1000000000612389365749814222] = 195; + rayToBps[1000000000615499541026029589] = 196; + rayToBps[1000000000618609411278444380] = 197; + rayToBps[1000000000621718976566881844] = 198; + rayToBps[1000000000624828236951147633] = 199; + rayToBps[1000000000627937192491029810] = 200; + rayToBps[1000000000631045843246298852] = 201; + rayToBps[1000000000634154189276707659] = 202; + rayToBps[1000000000637262230641991564] = 203; + rayToBps[1000000000640369967401868332] = 204; + rayToBps[1000000000643477399616038176] = 205; + rayToBps[1000000000646584527344183758] = 206; + rayToBps[1000000000649691350645970197] = 207; + rayToBps[1000000000652797869581045076] = 208; + rayToBps[1000000000655904084209038450] = 209; + rayToBps[1000000000659009994589562852] = 210; + rayToBps[1000000000662115600782213301] = 211; + rayToBps[1000000000665220902846567304] = 212; + rayToBps[1000000000668325900842184872] = 213; + rayToBps[1000000000671430594828608518] = 214; + rayToBps[1000000000674534984865363268] = 215; + rayToBps[1000000000677639071011956667] = 216; + rayToBps[1000000000680742853327878787] = 217; + rayToBps[1000000000683846331872602231] = 218; + rayToBps[1000000000686949506705582145] = 219; + rayToBps[1000000000690052377886256219] = 220; + rayToBps[1000000000693154945474044696] = 221; + rayToBps[1000000000696257209528350379] = 222; + rayToBps[1000000000699359170108558644] = 223; + rayToBps[1000000000702460827274037431] = 224; + rayToBps[1000000000705562181084137268] = 225; + rayToBps[1000000000708663231598191269] = 226; + rayToBps[1000000000711763978875515140] = 227; + rayToBps[1000000000714864422975407191] = 228; + rayToBps[1000000000717964563957148338] = 229; + rayToBps[1000000000721064401880002111] = 230; + rayToBps[1000000000724163936803214665] = 231; + rayToBps[1000000000727263168786014781] = 232; + rayToBps[1000000000730362097887613873] = 233; + rayToBps[1000000000733460724167206002] = 234; + rayToBps[1000000000736559047683967873] = 235; + rayToBps[1000000000739657068497058849] = 236; + rayToBps[1000000000742754786665620954] = 237; + rayToBps[1000000000745852202248778881] = 238; + rayToBps[1000000000748949315305640001] = 239; + rayToBps[1000000000752046125895294364] = 240; + rayToBps[1000000000755142634076814712] = 241; + rayToBps[1000000000758238839909256483] = 242; + rayToBps[1000000000761334743451657815] = 243; + rayToBps[1000000000764430344763039558] = 244; + rayToBps[1000000000767525643902405280] = 245; + rayToBps[1000000000770620640928741268] = 246; + rayToBps[1000000000773715335901016542] = 247; + rayToBps[1000000000776809728878182856] = 248; + rayToBps[1000000000779903819919174710] = 249; + rayToBps[1000000000782997609082909351] = 250; + rayToBps[1000000000786091096428286786] = 251; + rayToBps[1000000000789184282014189785] = 252; + rayToBps[1000000000792277165899483884] = 253; + rayToBps[1000000000795369748143017402] = 254; + rayToBps[1000000000798462028803621438] = 255; + rayToBps[1000000000801554007940109881] = 256; + rayToBps[1000000000804645685611279421] = 257; + rayToBps[1000000000807737061875909546] = 258; + rayToBps[1000000000810828136792762559] = 259; + rayToBps[1000000000813918910420583580] = 260; + rayToBps[1000000000817009382818100549] = 261; + rayToBps[1000000000820099554044024241] = 262; + rayToBps[1000000000823189424157048266] = 263; + rayToBps[1000000000826278993215849080] = 264; + rayToBps[1000000000829368261279085986] = 265; + rayToBps[1000000000832457228405401147] = 266; + rayToBps[1000000000835545894653419590] = 267; + rayToBps[1000000000838634260081749213] = 268; + rayToBps[1000000000841722324748980791] = 269; + rayToBps[1000000000844810088713687981] = 270; + rayToBps[1000000000847897552034427333] = 271; + rayToBps[1000000000850984714769738294] = 272; + rayToBps[1000000000854071576978143215] = 273; + rayToBps[1000000000857158138718147357] = 274; + rayToBps[1000000000860244400048238898] = 275; + rayToBps[1000000000863330361026888943] = 276; + rayToBps[1000000000866416021712551525] = 277; + rayToBps[1000000000869501382163663613] = 278; + rayToBps[1000000000872586442438645123] = 279; + rayToBps[1000000000875671202595898921] = 280; + rayToBps[1000000000878755662693810828] = 281; + rayToBps[1000000000881839822790749630] = 282; + rayToBps[1000000000884923682945067084] = 283; + rayToBps[1000000000888007243215097924] = 284; + rayToBps[1000000000891090503659159869] = 285; + rayToBps[1000000000894173464335553624] = 286; + rayToBps[1000000000897256125302562895] = 287; + rayToBps[1000000000900338486618454391] = 288; + rayToBps[1000000000903420548341477830] = 289; + rayToBps[1000000000906502310529865946] = 290; + rayToBps[1000000000909583773241834499] = 291; + rayToBps[1000000000912664936535582274] = 292; + rayToBps[1000000000915745800469291101] = 293; + rayToBps[1000000000918826365101125845] = 294; + rayToBps[1000000000921906630489234425] = 295; + rayToBps[1000000000924986596691747814] = 296; + rayToBps[1000000000928066263766780050] = 297; + rayToBps[1000000000931145631772428239] = 298; + rayToBps[1000000000934224700766772564] = 299; + rayToBps[1000000000937303470807876289] = 300; + rayToBps[1000000000940381941953785771] = 301; + rayToBps[1000000000943460114262530457] = 302; + rayToBps[1000000000946537987792122901] = 303; + rayToBps[1000000000949615562600558765] = 304; + rayToBps[1000000000952692838745816824] = 305; + rayToBps[1000000000955769816285858978] = 306; + rayToBps[1000000000958846495278630254] = 307; + rayToBps[1000000000961922875782058814] = 308; + rayToBps[1000000000964998957854055963] = 309; + rayToBps[1000000000968074741552516152] = 310; + rayToBps[1000000000971150226935316988] = 311; + rayToBps[1000000000974225414060319240] = 312; + rayToBps[1000000000977300302985366843] = 313; + rayToBps[1000000000980374893768286908] = 314; + rayToBps[1000000000983449186466889726] = 315; + rayToBps[1000000000986523181138968776] = 316; + rayToBps[1000000000989596877842300728] = 317; + rayToBps[1000000000992670276634645456] = 318; + rayToBps[1000000000995743377573746041] = 319; + rayToBps[1000000000998816180717328774] = 320; + rayToBps[1000000001001888686123103168] = 321; + rayToBps[1000000001004960893848761962] = 322; + rayToBps[1000000001008032803951981130] = 323; + rayToBps[1000000001011104416490419883] = 324; + rayToBps[1000000001014175731521720677] = 325; + rayToBps[1000000001017246749103509223] = 326; + rayToBps[1000000001020317469293394491] = 327; + rayToBps[1000000001023387892148968714] = 328; + rayToBps[1000000001026458017727807397] = 329; + rayToBps[1000000001029527846087469327] = 330; + rayToBps[1000000001032597377285496570] = 331; + rayToBps[1000000001035666611379414489] = 332; + rayToBps[1000000001038735548426731741] = 333; + rayToBps[1000000001041804188484940289] = 334; + rayToBps[1000000001044872531611515405] = 335; + rayToBps[1000000001047940577863915679] = 336; + rayToBps[1000000001051008327299583027] = 337; + rayToBps[1000000001054075779975942691] = 338; + rayToBps[1000000001057142935950403252] = 339; + rayToBps[1000000001060209795280356633] = 340; + rayToBps[1000000001063276358023178106] = 341; + rayToBps[1000000001066342624236226300] = 342; + rayToBps[1000000001069408593976843206] = 343; + rayToBps[1000000001072474267302354182] = 344; + rayToBps[1000000001075539644270067964] = 345; + rayToBps[1000000001078604724937276668] = 346; + rayToBps[1000000001081669509361255798] = 347; + rayToBps[1000000001084733997599264251] = 348; + rayToBps[1000000001087798189708544327] = 349; + rayToBps[1000000001090862085746321732] = 350; + rayToBps[1000000001093925685769805588] = 351; + rayToBps[1000000001096988989836188433] = 352; + rayToBps[1000000001100051998002646234] = 353; + rayToBps[1000000001103114710326338391] = 354; + rayToBps[1000000001106177126864407743] = 355; + rayToBps[1000000001109239247673980573] = 356; + rayToBps[1000000001112301072812166619] = 357; + rayToBps[1000000001115362602336059074] = 358; + rayToBps[1000000001118423836302734600] = 359; + rayToBps[1000000001121484774769253326] = 360; + rayToBps[1000000001124545417792658861] = 361; + rayToBps[1000000001127605765429978297] = 362; + rayToBps[1000000001130665817738222219] = 363; + rayToBps[1000000001133725574774384703] = 364; + rayToBps[1000000001136785036595443334] = 365; + rayToBps[1000000001139844203258359204] = 366; + rayToBps[1000000001142903074820076919] = 367; + rayToBps[1000000001145961651337524612] = 368; + rayToBps[1000000001149019932867613939] = 369; + rayToBps[1000000001152077919467240095] = 370; + rayToBps[1000000001155135611193281814] = 371; + rayToBps[1000000001158193008102601379] = 372; + rayToBps[1000000001161250110252044625] = 373; + rayToBps[1000000001164306917698440949] = 374; + rayToBps[1000000001167363430498603315] = 375; + rayToBps[1000000001170419648709328258] = 376; + rayToBps[1000000001173475572387395894] = 377; + rayToBps[1000000001176531201589569924] = 378; + rayToBps[1000000001179586536372597640] = 379; + rayToBps[1000000001182641576793209935] = 380; + rayToBps[1000000001185696322908121302] = 381; + rayToBps[1000000001188750774774029849] = 382; + rayToBps[1000000001191804932447617301] = 383; + rayToBps[1000000001194858795985549004] = 384; + rayToBps[1000000001197912365444473936] = 385; + rayToBps[1000000001200965640881024708] = 386; + rayToBps[1000000001204018622351817579] = 387; + rayToBps[1000000001207071309913452452] = 388; + rayToBps[1000000001210123703622512886] = 389; + rayToBps[1000000001213175803535566102] = 390; + rayToBps[1000000001216227609709162989] = 391; + rayToBps[1000000001219279122199838110] = 392; + rayToBps[1000000001222330341064109706] = 393; + rayToBps[1000000001225381266358479708] = 394; + rayToBps[1000000001228431898139433735] = 395; + rayToBps[1000000001231482236463441109] = 396; + rayToBps[1000000001234532281386954858] = 397; + rayToBps[1000000001237582032966411716] = 398; + rayToBps[1000000001240631491258232141] = 399; + rayToBps[1000000001243680656318820312] = 400; + rayToBps[1000000001246729528204564139] = 401; + rayToBps[1000000001249778106971835268] = 402; + rayToBps[1000000001252826392676989088] = 403; + rayToBps[1000000001255874385376364739] = 404; + rayToBps[1000000001258922085126285113] = 405; + rayToBps[1000000001261969491983056866] = 406; + rayToBps[1000000001265016606002970422] = 407; + rayToBps[1000000001268063427242299977] = 408; + rayToBps[1000000001271109955757303509] = 409; + rayToBps[1000000001274156191604222783] = 410; + rayToBps[1000000001277202134839283355] = 411; + rayToBps[1000000001280247785518694582] = 412; + rayToBps[1000000001283293143698649624] = 413; + rayToBps[1000000001286338209435325454] = 414; + rayToBps[1000000001289382982784882863] = 415; + rayToBps[1000000001292427463803466464] = 416; + rayToBps[1000000001295471652547204702] = 417; + rayToBps[1000000001298515549072209857] = 418; + rayToBps[1000000001301559153434578054] = 419; + rayToBps[1000000001304602465690389263] = 420; + rayToBps[1000000001307645485895707309] = 421; + rayToBps[1000000001310688214106579884] = 422; + rayToBps[1000000001313730650379038540] = 423; + rayToBps[1000000001316772794769098706] = 424; + rayToBps[1000000001319814647332759691] = 425; + rayToBps[1000000001322856208126004689] = 426; + rayToBps[1000000001325897477204800787] = 427; + rayToBps[1000000001328938454625098968] = 428; + rayToBps[1000000001331979140442834120] = 429; + rayToBps[1000000001335019534713925045] = 430; + rayToBps[1000000001338059637494274457] = 431; + rayToBps[1000000001341099448839768997] = 432; + rayToBps[1000000001344138968806279230] = 433; + rayToBps[1000000001347178197449659663] = 434; + rayToBps[1000000001350217134825748738] = 435; + rayToBps[1000000001353255780990368849] = 436; + rayToBps[1000000001356294135999326341] = 437; + rayToBps[1000000001359332199908411521] = 438; + rayToBps[1000000001362369972773398659] = 439; + rayToBps[1000000001365407454650046000] = 440; + rayToBps[1000000001368444645594095767] = 441; + rayToBps[1000000001371481545661274166] = 442; + rayToBps[1000000001374518154907291394] = 443; + rayToBps[1000000001377554473387841645] = 444; + rayToBps[1000000001380590501158603116] = 445; + rayToBps[1000000001383626238275238013] = 446; + rayToBps[1000000001386661684793392556] = 447; + rayToBps[1000000001389696840768696987] = 448; + rayToBps[1000000001392731706256765577] = 449; + rayToBps[1000000001395766281313196627] = 450; + rayToBps[1000000001398800565993572478] = 451; + rayToBps[1000000001401834560353459521] = 452; + rayToBps[1000000001404868264448408194] = 453; + rayToBps[1000000001407901678333952993] = 454; + rayToBps[1000000001410934802065612482] = 455; + rayToBps[1000000001413967635698889291] = 456; + rayToBps[1000000001417000179289270128] = 457; + rayToBps[1000000001420032432892225782] = 458; + rayToBps[1000000001423064396563211131] = 459; + rayToBps[1000000001426096070357665149] = 460; + rayToBps[1000000001429127454331010908] = 461; + rayToBps[1000000001432158548538655588] = 462; + rayToBps[1000000001435189353035990479] = 463; + rayToBps[1000000001438219867878390995] = 464; + rayToBps[1000000001441250093121216670] = 465; + rayToBps[1000000001444280028819811170] = 466; + rayToBps[1000000001447309675029502300] = 467; + rayToBps[1000000001450339031805602006] = 468; + rayToBps[1000000001453368099203406382] = 469; + rayToBps[1000000001456396877278195681] = 470; + rayToBps[1000000001459425366085234312] = 471; + rayToBps[1000000001462453565679770855] = 472; + rayToBps[1000000001465481476117038063] = 473; + rayToBps[1000000001468509097452252866] = 474; + rayToBps[1000000001471536429740616381] = 475; + rayToBps[1000000001474563473037313917] = 476; + rayToBps[1000000001477590227397514978] = 477; + rayToBps[1000000001480616692876373275] = 478; + rayToBps[1000000001483642869529026724] = 479; + rayToBps[1000000001486668757410597461] = 480; + rayToBps[1000000001489694356576191838] = 481; + rayToBps[1000000001492719667080900443] = 482; + rayToBps[1000000001495744688979798088] = 483; + rayToBps[1000000001498769422327943831] = 484; + rayToBps[1000000001501793867180380974] = 485; + rayToBps[1000000001504818023592137069] = 486; + rayToBps[1000000001507841891618223927] = 487; + rayToBps[1000000001510865471313637625] = 488; + rayToBps[1000000001513888762733358503] = 489; + rayToBps[1000000001516911765932351183] = 490; + rayToBps[1000000001519934480965564567] = 491; + rayToBps[1000000001522956907887931841] = 492; + rayToBps[1000000001525979046754370490] = 493; + rayToBps[1000000001529000897619782295] = 494; + rayToBps[1000000001532022460539053343] = 495; + rayToBps[1000000001535043735567054034] = 496; + rayToBps[1000000001538064722758639085] = 497; + rayToBps[1000000001541085422168647535] = 498; + rayToBps[1000000001544105833851902754] = 499; + rayToBps[1000000001547125957863212448] = 500; + rayToBps[1000000001550145794257368662] = 501; + rayToBps[1000000001553165343089147790] = 502; + rayToBps[1000000001556184604413310579] = 503; + rayToBps[1000000001559203578284602136] = 504; + rayToBps[1000000001562222264757751932] = 505; + rayToBps[1000000001565240663887473810] = 506; + rayToBps[1000000001568258775728465991] = 507; + rayToBps[1000000001571276600335411077] = 508; + rayToBps[1000000001574294137762976059] = 509; + rayToBps[1000000001577311388065812327] = 510; + rayToBps[1000000001580328351298555666] = 511; + rayToBps[1000000001583345027515826272] = 512; + rayToBps[1000000001586361416772228753] = 513; + rayToBps[1000000001589377519122352136] = 514; + rayToBps[1000000001592393334620769870] = 515; + rayToBps[1000000001595408863322039839] = 516; + rayToBps[1000000001598424105280704358] = 517; + rayToBps[1000000001601439060551290189] = 518; + rayToBps[1000000001604453729188308543] = 519; + rayToBps[1000000001607468111246255079] = 520; + rayToBps[1000000001610482206779609923] = 521; + rayToBps[1000000001613496015842837664] = 522; + rayToBps[1000000001616509538490387361] = 523; + rayToBps[1000000001619522774776692555] = 524; + rayToBps[1000000001622535724756171269] = 525; + rayToBps[1000000001625548388483226015] = 526; + rayToBps[1000000001628560766012243800] = 527; + rayToBps[1000000001631572857397596136] = 528; + rayToBps[1000000001634584662693639037] = 529; + rayToBps[1000000001637596181954713035] = 530; + rayToBps[1000000001640607415235143177] = 531; + rayToBps[1000000001643618362589239040] = 532; + rayToBps[1000000001646629024071294727] = 533; + rayToBps[1000000001649639399735588881] = 534; + rayToBps[1000000001652649489636384685] = 535; + rayToBps[1000000001655659293827929873] = 536; + rayToBps[1000000001658668812364456731] = 537; + rayToBps[1000000001661678045300182106] = 538; + rayToBps[1000000001664686992689307414] = 539; + rayToBps[1000000001667695654586018638] = 540; + rayToBps[1000000001670704031044486342] = 541; + rayToBps[1000000001673712122118865672] = 542; + rayToBps[1000000001676719927863296364] = 543; + rayToBps[1000000001679727448331902751] = 544; + rayToBps[1000000001682734683578793766] = 545; + rayToBps[1000000001685741633658062946] = 546; + rayToBps[1000000001688748298623788446] = 547; + rayToBps[1000000001691754678530033036] = 548; + rayToBps[1000000001694760773430844112] = 549; + rayToBps[1000000001697766583380253701] = 550; + rayToBps[1000000001700772108432278464] = 551; + rayToBps[1000000001703777348640919706] = 552; + rayToBps[1000000001706782304060163379] = 553; + rayToBps[1000000001709786974743980088] = 554; + rayToBps[1000000001712791360746325100] = 555; + rayToBps[1000000001715795462121138343] = 556; + rayToBps[1000000001718799278922344419] = 557; + rayToBps[1000000001721802811203852608] = 558; + rayToBps[1000000001724806059019556870] = 559; + rayToBps[1000000001727809022423335855] = 560; + rayToBps[1000000001730811701469052906] = 561; + rayToBps[1000000001733814096210556068] = 562; + rayToBps[1000000001736816206701678090] = 563; + rayToBps[1000000001739818032996236434] = 564; + rayToBps[1000000001742819575148033278] = 565; + rayToBps[1000000001745820833210855527] = 566; + rayToBps[1000000001748821807238474808] = 567; + rayToBps[1000000001751822497284647491] = 568; + rayToBps[1000000001754822903403114680] = 569; + rayToBps[1000000001757823025647602229] = 570; + rayToBps[1000000001760822864071820743] = 571; + rayToBps[1000000001763822418729465585] = 572; + rayToBps[1000000001766821689674216882] = 573; + rayToBps[1000000001769820676959739530] = 574; + rayToBps[1000000001772819380639683201] = 575; + rayToBps[1000000001775817800767682345] = 576; + rayToBps[1000000001778815937397356203] = 577; + rayToBps[1000000001781813790582308807] = 578; + rayToBps[1000000001784811360376128985] = 579; + rayToBps[1000000001787808646832390371] = 580; + rayToBps[1000000001790805650004651410] = 581; + rayToBps[1000000001793802369946455358] = 582; + rayToBps[1000000001796798806711330296] = 583; + rayToBps[1000000001799794960352789133] = 584; + rayToBps[1000000001802790830924329607] = 585; + rayToBps[1000000001805786418479434295] = 586; + rayToBps[1000000001808781723071570620] = 587; + rayToBps[1000000001811776744754190855] = 588; + rayToBps[1000000001814771483580732126] = 589; + rayToBps[1000000001817765939604616422] = 590; + rayToBps[1000000001820760112879250599] = 591; + rayToBps[1000000001823754003458026386] = 592; + rayToBps[1000000001826747611394320388] = 593; + rayToBps[1000000001829740936741494099] = 594; + rayToBps[1000000001832733979552893898] = 595; + rayToBps[1000000001835726739881851062] = 596; + rayToBps[1000000001838719217781681769] = 597; + rayToBps[1000000001841711413305687103] = 598; + rayToBps[1000000001844703326507153063] = 599; + rayToBps[1000000001847694957439350562] = 600; + rayToBps[1000000001850686306155535442] = 601; + rayToBps[1000000001853677372708948472] = 602; + rayToBps[1000000001856668157152815356] = 603; + rayToBps[1000000001859658659540346741] = 604; + rayToBps[1000000001862648879924738219] = 605; + rayToBps[1000000001865638818359170337] = 606; + rayToBps[1000000001868628474896808595] = 607; + rayToBps[1000000001871617849590803463] = 608; + rayToBps[1000000001874606942494290377] = 609; + rayToBps[1000000001877595753660389747] = 610; + rayToBps[1000000001880584283142206967] = 611; + rayToBps[1000000001883572530992832417] = 612; + rayToBps[1000000001886560497265341466] = 613; + rayToBps[1000000001889548182012794484] = 614; + rayToBps[1000000001892535585288236844] = 615; + rayToBps[1000000001895522707144698926] = 616; + rayToBps[1000000001898509547635196126] = 617; + rayToBps[1000000001901496106812728862] = 618; + rayToBps[1000000001904482384730282575] = 619; + rayToBps[1000000001907468381440827740] = 620; + rayToBps[1000000001910454096997319869] = 621; + rayToBps[1000000001913439531452699514] = 622; + rayToBps[1000000001916424684859892282] = 623; + rayToBps[1000000001919409557271808825] = 624; + rayToBps[1000000001922394148741344865] = 625; + rayToBps[1000000001925378459321381181] = 626; + rayToBps[1000000001928362489064783628] = 627; + rayToBps[1000000001931346238024403135] = 628; + rayToBps[1000000001934329706253075715] = 629; + rayToBps[1000000001937312893803622469] = 630; + rayToBps[1000000001940295800728849590] = 631; + rayToBps[1000000001943278427081548373] = 632; + rayToBps[1000000001946260772914495212] = 633; + rayToBps[1000000001949242838280451618] = 634; + rayToBps[1000000001952224623232164215] = 635; + rayToBps[1000000001955206127822364746] = 636; + rayToBps[1000000001958187352103770087] = 637; + rayToBps[1000000001961168296129082241] = 638; + rayToBps[1000000001964148959950988353] = 639; + rayToBps[1000000001967129343622160710] = 640; + rayToBps[1000000001970109447195256751] = 641; + rayToBps[1000000001973089270722919065] = 642; + rayToBps[1000000001976068814257775407] = 643; + rayToBps[1000000001979048077852438695] = 644; + rayToBps[1000000001982027061559507021] = 645; + rayToBps[1000000001985005765431563653] = 646; + rayToBps[1000000001987984189521177042] = 647; + rayToBps[1000000001990962333880900827] = 648; + rayToBps[1000000001993940198563273844] = 649; + rayToBps[1000000001996917783620820123] = 650; + rayToBps[1000000001999895089106048906] = 651; + rayToBps[1000000002002872115071454639] = 652; + rayToBps[1000000002005848861569516991] = 653; + rayToBps[1000000002008825328652700847] = 654; + rayToBps[1000000002011801516373456324] = 655; + rayToBps[1000000002014777424784218768] = 656; + rayToBps[1000000002017753053937408767] = 657; + rayToBps[1000000002020728403885432150] = 658; + rayToBps[1000000002023703474680679997] = 659; + rayToBps[1000000002026678266375528644] = 660; + rayToBps[1000000002029652779022339687] = 661; + rayToBps[1000000002032627012673459986] = 662; + rayToBps[1000000002035600967381221676] = 663; + rayToBps[1000000002038574643197942168] = 664; + rayToBps[1000000002041548040175924154] = 665; + rayToBps[1000000002044521158367455616] = 666; + rayToBps[1000000002047493997824809831] = 667; + rayToBps[1000000002050466558600245373] = 668; + rayToBps[1000000002053438840746006121] = 669; + rayToBps[1000000002056410844314321266] = 670; + rayToBps[1000000002059382569357405313] = 671; + rayToBps[1000000002062354015927458089] = 672; + rayToBps[1000000002065325184076664749] = 673; + rayToBps[1000000002068296073857195778] = 674; + rayToBps[1000000002071266685321207000] = 675; + rayToBps[1000000002074237018520839584] = 676; + rayToBps[1000000002077207073508220045] = 677; + rayToBps[1000000002080176850335460252] = 678; + rayToBps[1000000002083146349054657437] = 679; + rayToBps[1000000002086115569717894196] = 680; + rayToBps[1000000002089084512377238493] = 681; + rayToBps[1000000002092053177084743673] = 682; + rayToBps[1000000002095021563892448458] = 683; + rayToBps[1000000002097989672852376961] = 684; + rayToBps[1000000002100957504016538685] = 685; + rayToBps[1000000002103925057436928532] = 686; + rayToBps[1000000002106892333165526808] = 687; + rayToBps[1000000002109859331254299227] = 688; + rayToBps[1000000002112826051755196920] = 689; + rayToBps[1000000002115792494720156434] = 690; + rayToBps[1000000002118758660201099744] = 691; + rayToBps[1000000002121724548249934257] = 692; + rayToBps[1000000002124690158918552812] = 693; + rayToBps[1000000002127655492258833695] = 694; + rayToBps[1000000002130620548322640635] = 695; + rayToBps[1000000002133585327161822816] = 696; + rayToBps[1000000002136549828828214880] = 697; + rayToBps[1000000002139514053373636932] = 698; + rayToBps[1000000002142478000849894543] = 699; + rayToBps[1000000002145441671308778766] = 700; + rayToBps[1000000002148405064802066124] = 701; + rayToBps[1000000002151368181381518635] = 702; + rayToBps[1000000002154331021098883800] = 703; + rayToBps[1000000002157293584005894622] = 704; + rayToBps[1000000002160255870154269599] = 705; + rayToBps[1000000002163217879595712742] = 706; + rayToBps[1000000002166179612381913573] = 707; + rayToBps[1000000002169141068564547128] = 708; + rayToBps[1000000002172102248195273969] = 709; + rayToBps[1000000002175063151325740189] = 710; + rayToBps[1000000002178023778007577411] = 711; + rayToBps[1000000002180984128292402799] = 712; + rayToBps[1000000002183944202231819060] = 713; + rayToBps[1000000002186903999877414455] = 714; + rayToBps[1000000002189863521280762799] = 715; + rayToBps[1000000002192822766493423465] = 716; + rayToBps[1000000002195781735566941395] = 717; + rayToBps[1000000002198740428552847104] = 718; + rayToBps[1000000002201698845502656681] = 719; + rayToBps[1000000002204656986467871801] = 720; + rayToBps[1000000002207614851499979723] = 721; + rayToBps[1000000002210572440650453302] = 722; + rayToBps[1000000002213529753970750991] = 723; + rayToBps[1000000002216486791512316847] = 724; + rayToBps[1000000002219443553326580536] = 725; + rayToBps[1000000002222400039464957340] = 726; + rayToBps[1000000002225356249978848158] = 727; + rayToBps[1000000002228312184919639519] = 728; + rayToBps[1000000002231267844338703579] = 729; + rayToBps[1000000002234223228287398132] = 730; + rayToBps[1000000002237178336817066613] = 731; + rayToBps[1000000002240133169979038105] = 732; + rayToBps[1000000002243087727824627342] = 733; + rayToBps[1000000002246042010405134715] = 734; + rayToBps[1000000002248996017771846281] = 735; + rayToBps[1000000002251949749976033760] = 736; + rayToBps[1000000002254903207068954551] = 737; + rayToBps[1000000002257856389101851730] = 738; + rayToBps[1000000002260809296125954056] = 739; + rayToBps[1000000002263761928192475979] = 740; + rayToBps[1000000002266714285352617643] = 741; + rayToBps[1000000002269666367657564895] = 742; + rayToBps[1000000002272618175158489283] = 743; + rayToBps[1000000002275569707906548069] = 744; + rayToBps[1000000002278520965952884232] = 745; + rayToBps[1000000002281471949348626470] = 746; + rayToBps[1000000002284422658144889210] = 747; + rayToBps[1000000002287373092392772609] = 748; + rayToBps[1000000002290323252143362564] = 749; + rayToBps[1000000002293273137447730714] = 750; + rayToBps[1000000002296222748356934445] = 751; + rayToBps[1000000002299172084922016896] = 752; + rayToBps[1000000002302121147194006968] = 753; + rayToBps[1000000002305069935223919323] = 754; + rayToBps[1000000002308018449062754392] = 755; + rayToBps[1000000002310966688761498383] = 756; + rayToBps[1000000002313914654371123283] = 757; + rayToBps[1000000002316862345942586863] = 758; + rayToBps[1000000002319809763526832687] = 759; + rayToBps[1000000002322756907174790110] = 760; + rayToBps[1000000002325703776937374294] = 761; + rayToBps[1000000002328650372865486203] = 762; + rayToBps[1000000002331596695010012613] = 763; + rayToBps[1000000002334542743421826121] = 764; + rayToBps[1000000002337488518151785139] = 765; + rayToBps[1000000002340434019250733913] = 766; + rayToBps[1000000002343379246769502519] = 767; + rayToBps[1000000002346324200758906870] = 768; + rayToBps[1000000002349268881269748722] = 769; + rayToBps[1000000002352213288352815683] = 770; + rayToBps[1000000002355157422058881210] = 771; + rayToBps[1000000002358101282438704622] = 772; + rayToBps[1000000002361044869543031102] = 773; + rayToBps[1000000002363988183422591701] = 774; + rayToBps[1000000002366931224128103346] = 775; + rayToBps[1000000002369873991710268842] = 776; + rayToBps[1000000002372816486219776883] = 777; + rayToBps[1000000002375758707707302048] = 778; + rayToBps[1000000002378700656223504817] = 779; + rayToBps[1000000002381642331819031568] = 780; + rayToBps[1000000002384583734544514586] = 781; + rayToBps[1000000002387524864450572064] = 782; + rayToBps[1000000002390465721587808119] = 783; + rayToBps[1000000002393406306006812783] = 784; + rayToBps[1000000002396346617758162017] = 785; + rayToBps[1000000002399286656892417716] = 786; + rayToBps[1000000002402226423460127711] = 787; + rayToBps[1000000002405165917511825773] = 788; + rayToBps[1000000002408105139098031627] = 789; + rayToBps[1000000002411044088269250946] = 790; + rayToBps[1000000002413982765075975363] = 791; + rayToBps[1000000002416921169568682475] = 792; + rayToBps[1000000002419859301797835847] = 793; + rayToBps[1000000002422797161813885017] = 794; + rayToBps[1000000002425734749667265506] = 795; + rayToBps[1000000002428672065408398813] = 796; + rayToBps[1000000002431609109087692432] = 797; + rayToBps[1000000002434545880755539850] = 798; + rayToBps[1000000002437482380462320552] = 799; + rayToBps[1000000002440418608258400030] = 800; + rayToBps[1000000002443354564194129787] = 801; + rayToBps[1000000002446290248319847339] = 802; + rayToBps[1000000002449225660685876223] = 803; + rayToBps[1000000002452160801342526004] = 804; + rayToBps[1000000002455095670340092277] = 805; + rayToBps[1000000002458030267728856671] = 806; + rayToBps[1000000002460964593559086859] = 807; + rayToBps[1000000002463898647881036558] = 808; + rayToBps[1000000002466832430744945540] = 809; + rayToBps[1000000002469765942201039630] = 810; + rayToBps[1000000002472699182299530718] = 811; + rayToBps[1000000002475632151090616757] = 812; + rayToBps[1000000002478564848624481779] = 813; + rayToBps[1000000002481497274951295886] = 814; + rayToBps[1000000002484429430121215269] = 815; + rayToBps[1000000002487361314184382201] = 816; + rayToBps[1000000002490292927190925051] = 817; + rayToBps[1000000002493224269190958287] = 818; + rayToBps[1000000002496155340234582476] = 819; + rayToBps[1000000002499086140371884298] = 820; + rayToBps[1000000002502016669652936543] = 821; + rayToBps[1000000002504946928127798122] = 822; + rayToBps[1000000002507876915846514067] = 823; + rayToBps[1000000002510806632859115540] = 824; + rayToBps[1000000002513736079215619839] = 825; + rayToBps[1000000002516665254966030398] = 826; + rayToBps[1000000002519594160160336795] = 827; + rayToBps[1000000002522522794848514761] = 828; + rayToBps[1000000002525451159080526178] = 829; + rayToBps[1000000002528379252906319086] = 830; + rayToBps[1000000002531307076375827697] = 831; + rayToBps[1000000002534234629538972383] = 832; + rayToBps[1000000002537161912445659699] = 833; + rayToBps[1000000002540088925145782374] = 834; + rayToBps[1000000002543015667689219327] = 835; + rayToBps[1000000002545942140125835662] = 836; + rayToBps[1000000002548868342505482685] = 837; + rayToBps[1000000002551794274877997894] = 838; + rayToBps[1000000002554719937293204998] = 839; + rayToBps[1000000002557645329800913916] = 840; + rayToBps[1000000002560570452450920783] = 841; + rayToBps[1000000002563495305293007952] = 842; + rayToBps[1000000002566419888376944003] = 843; + rayToBps[1000000002569344201752483747] = 844; + rayToBps[1000000002572268245469368232] = 845; + rayToBps[1000000002575192019577324747] = 846; + rayToBps[1000000002578115524126066824] = 847; + rayToBps[1000000002581038759165294249] = 848; + rayToBps[1000000002583961724744693064] = 849; + rayToBps[1000000002586884420913935572] = 850; + rayToBps[1000000002589806847722680342] = 851; + rayToBps[1000000002592729005220572215] = 852; + rayToBps[1000000002595650893457242308] = 853; + rayToBps[1000000002598572512482308019] = 854; + rayToBps[1000000002601493862345373033] = 855; + rayToBps[1000000002604414943096027328] = 856; + rayToBps[1000000002607335754783847177] = 857; + rayToBps[1000000002610256297458395155] = 858; + rayToBps[1000000002613176571169220145] = 859; + rayToBps[1000000002616096575965857340] = 860; + rayToBps[1000000002619016311897828252] = 861; + rayToBps[1000000002621935779014640712] = 862; + rayToBps[1000000002624854977365788881] = 863; + rayToBps[1000000002627773907000753250] = 864; + rayToBps[1000000002630692567969000648] = 865; + rayToBps[1000000002633610960319984247] = 866; + rayToBps[1000000002636529084103143562] = 867; + rayToBps[1000000002639446939367904465] = 868; + rayToBps[1000000002642364526163679182] = 869; + rayToBps[1000000002645281844539866303] = 870; + rayToBps[1000000002648198894545850784] = 871; + rayToBps[1000000002651115676231003954] = 872; + rayToBps[1000000002654032189644683517] = 873; + rayToBps[1000000002656948434836233563] = 874; + rayToBps[1000000002659864411854984565] = 875; + rayToBps[1000000002662780120750253393] = 876; + rayToBps[1000000002665695561571343309] = 877; + rayToBps[1000000002668610734367543981] = 878; + rayToBps[1000000002671525639188131484] = 879; + rayToBps[1000000002674440276082368302] = 880; + rayToBps[1000000002677354645099503340] = 881; + rayToBps[1000000002680268746288771923] = 882; + rayToBps[1000000002683182579699395804] = 883; + rayToBps[1000000002686096145380583168] = 884; + rayToBps[1000000002689009443381528638] = 885; + rayToBps[1000000002691922473751413277] = 886; + rayToBps[1000000002694835236539404598] = 887; + rayToBps[1000000002697747731794656564] = 888; + rayToBps[1000000002700659959566309596] = 889; + rayToBps[1000000002703571919903490575] = 890; + rayToBps[1000000002706483612855312853] = 891; + rayToBps[1000000002709395038470876252] = 892; + rayToBps[1000000002712306196799267069] = 893; + rayToBps[1000000002715217087889558088] = 894; + rayToBps[1000000002718127711790808573] = 895; + rayToBps[1000000002721038068552064286] = 896; + rayToBps[1000000002723948158222357482] = 897; + rayToBps[1000000002726857980850706921] = 898; + rayToBps[1000000002729767536486117866] = 899; + rayToBps[1000000002732676825177582095] = 900; + rayToBps[1000000002735585846974077901] = 901; + rayToBps[1000000002738494601924570098] = 902; + rayToBps[1000000002741403090078010029] = 903; + rayToBps[1000000002744311311483335565] = 904; + rayToBps[1000000002747219266189471117] = 905; + rayToBps[1000000002750126954245327636] = 906; + rayToBps[1000000002753034375699802616] = 907; + rayToBps[1000000002755941530601780109] = 908; + rayToBps[1000000002758848419000130717] = 909; + rayToBps[1000000002761755040943711607] = 910; + rayToBps[1000000002764661396481366508] = 911; + rayToBps[1000000002767567485661925724] = 912; + rayToBps[1000000002770473308534206134] = 913; + rayToBps[1000000002773378865147011196] = 914; + rayToBps[1000000002776284155549130955] = 915; + rayToBps[1000000002779189179789342046] = 916; + rayToBps[1000000002782093937916407701] = 917; + rayToBps[1000000002784998429979077750] = 918; + rayToBps[1000000002787902656026088630] = 919; + rayToBps[1000000002790806616106163389] = 920; + rayToBps[1000000002793710310268011687] = 921; + rayToBps[1000000002796613738560329808] = 922; + rayToBps[1000000002799516901031800659] = 923; + rayToBps[1000000002802419797731093776] = 924; + rayToBps[1000000002805322428706865331] = 925; + rayToBps[1000000002808224794007758136] = 926; + rayToBps[1000000002811126893682401646] = 927; + rayToBps[1000000002814028727779411968] = 928; + rayToBps[1000000002816930296347391860] = 929; + rayToBps[1000000002819831599434930742] = 930; + rayToBps[1000000002822732637090604696] = 931; + rayToBps[1000000002825633409362976474] = 932; + rayToBps[1000000002828533916300595503] = 933; + rayToBps[1000000002831434157951997885] = 934; + rayToBps[1000000002834334134365706412] = 935; + rayToBps[1000000002837233845590230556] = 936; + rayToBps[1000000002840133291674066490] = 937; + rayToBps[1000000002843032472665697081] = 938; + rayToBps[1000000002845931388613591900] = 939; + rayToBps[1000000002848830039566207226] = 940; + rayToBps[1000000002851728425571986050] = 941; + rayToBps[1000000002854626546679358084] = 942; + rayToBps[1000000002857524402936739757] = 943; + rayToBps[1000000002860421994392534231] = 944; + rayToBps[1000000002863319321095131394] = 945; + rayToBps[1000000002866216383092907878] = 946; + rayToBps[1000000002869113180434227051] = 947; + rayToBps[1000000002872009713167439031] = 948; + rayToBps[1000000002874905981340880687] = 949; + rayToBps[1000000002877801985002875644] = 950; + rayToBps[1000000002880697724201734289] = 951; + rayToBps[1000000002883593198985753772] = 952; + rayToBps[1000000002886488409403218019] = 953; + rayToBps[1000000002889383355502397729] = 954; + rayToBps[1000000002892278037331550380] = 955; + rayToBps[1000000002895172454938920238] = 956; + rayToBps[1000000002898066608372738360] = 957; + rayToBps[1000000002900960497681222594] = 958; + rayToBps[1000000002903854122912577591] = 959; + rayToBps[1000000002906747484114994807] = 960; + rayToBps[1000000002909640581336652506] = 961; + rayToBps[1000000002912533414625715766] = 962; + rayToBps[1000000002915425984030336485] = 963; + rayToBps[1000000002918318289598653387] = 964; + rayToBps[1000000002921210331378792020] = 965; + rayToBps[1000000002924102109418864770] = 966; + rayToBps[1000000002926993623766970860] = 967; + rayToBps[1000000002929884874471196354] = 968; + rayToBps[1000000002932775861579614167] = 969; + rayToBps[1000000002935666585140284065] = 970; + rayToBps[1000000002938557045201252671] = 971; + rayToBps[1000000002941447241810553473] = 972; + rayToBps[1000000002944337175016206824] = 973; + rayToBps[1000000002947226844866219949] = 974; + rayToBps[1000000002950116251408586949] = 975; + rayToBps[1000000002953005394691288810] = 976; + rayToBps[1000000002955894274762293401] = 977; + rayToBps[1000000002958782891669555482] = 978; + rayToBps[1000000002961671245461016710] = 979; + rayToBps[1000000002964559336184605642] = 980; + rayToBps[1000000002967447163888237741] = 981; + rayToBps[1000000002970334728619815381] = 982; + rayToBps[1000000002973222030427227847] = 983; + rayToBps[1000000002976109069358351348] = 984; + rayToBps[1000000002978995845461049016] = 985; + rayToBps[1000000002981882358783170911] = 986; + rayToBps[1000000002984768609372554028] = 987; + rayToBps[1000000002987654597277022302] = 988; + rayToBps[1000000002990540322544386608] = 989; + rayToBps[1000000002993425785222444772] = 990; + rayToBps[1000000002996310985358981573] = 991; + rayToBps[1000000002999195923001768747] = 992; + rayToBps[1000000003002080598198564991] = 993; + rayToBps[1000000003004965010997115971] = 994; + rayToBps[1000000003007849161445154325] = 995; + rayToBps[1000000003010733049590399667] = 996; + rayToBps[1000000003013616675480558594] = 997; + rayToBps[1000000003016500039163324684] = 998; + rayToBps[1000000003019383140686378514] = 999; + rayToBps[1000000003022265980097387650] = 1000; + rayToBps[1000000003025148557444006661] = 1001; + rayToBps[1000000003028030872773877120] = 1002; + rayToBps[1000000003030912926134627612] = 1003; + rayToBps[1000000003033794717573873734] = 1004; + rayToBps[1000000003036676247139218104] = 1005; + rayToBps[1000000003039557514878250362] = 1006; + rayToBps[1000000003042438520838547180] = 1007; + rayToBps[1000000003045319265067672258] = 1008; + rayToBps[1000000003048199747613176340] = 1009; + rayToBps[1000000003051079968522597209] = 1010; + rayToBps[1000000003053959927843459697] = 1011; + rayToBps[1000000003056839625623275688] = 1012; + rayToBps[1000000003059719061909544123] = 1013; + rayToBps[1000000003062598236749751004] = 1014; + rayToBps[1000000003065477150191369400] = 1015; + rayToBps[1000000003068355802281859451] = 1016; + rayToBps[1000000003071234193068668372] = 1017; + rayToBps[1000000003074112322599230459] = 1018; + rayToBps[1000000003076990190920967093] = 1019; + rayToBps[1000000003079867798081286746] = 1020; + rayToBps[1000000003082745144127584981] = 1021; + rayToBps[1000000003085622229107244463] = 1022; + rayToBps[1000000003088499053067634962] = 1023; + rayToBps[1000000003091375616056113353] = 1024; + rayToBps[1000000003094251918120023627] = 1025; + rayToBps[1000000003097127959306696891] = 1026; + rayToBps[1000000003100003739663451375] = 1027; + rayToBps[1000000003102879259237592437] = 1028; + rayToBps[1000000003105754518076412567] = 1029; + rayToBps[1000000003108629516227191390] = 1030; + rayToBps[1000000003111504253737195675] = 1031; + rayToBps[1000000003114378730653679332] = 1032; + rayToBps[1000000003117252947023883428] = 1033; + rayToBps[1000000003120126902895036179] = 1034; + rayToBps[1000000003123000598314352966] = 1035; + rayToBps[1000000003125874033329036329] = 1036; + rayToBps[1000000003128747207986275984] = 1037; + rayToBps[1000000003131620122333248815] = 1038; + rayToBps[1000000003134492776417118886] = 1039; + rayToBps[1000000003137365170285037445] = 1040; + rayToBps[1000000003140237303984142929] = 1041; + rayToBps[1000000003143109177561560964] = 1042; + rayToBps[1000000003145980791064404376] = 1043; + rayToBps[1000000003148852144539773190] = 1044; + rayToBps[1000000003151723238034754641] = 1045; + rayToBps[1000000003154594071596423170] = 1046; + rayToBps[1000000003157464645271840438] = 1047; + rayToBps[1000000003160334959108055323] = 1048; + rayToBps[1000000003163205013152103932] = 1049; + rayToBps[1000000003166074807451009595] = 1050; + rayToBps[1000000003168944342051782881] = 1051; + rayToBps[1000000003171813617001421599] = 1052; + rayToBps[1000000003174682632346910796] = 1053; + rayToBps[1000000003177551388135222770] = 1054; + rayToBps[1000000003180419884413317071] = 1055; + rayToBps[1000000003183288121228140507] = 1056; + rayToBps[1000000003186156098626627147] = 1057; + rayToBps[1000000003189023816655698326] = 1058; + rayToBps[1000000003191891275362262652] = 1059; + rayToBps[1000000003194758474793216004] = 1060; + rayToBps[1000000003197625414995441546] = 1061; + rayToBps[1000000003200492096015809725] = 1062; + rayToBps[1000000003203358517901178277] = 1063; + rayToBps[1000000003206224680698392232] = 1064; + rayToBps[1000000003209090584454283919] = 1065; + rayToBps[1000000003211956229215672970] = 1066; + rayToBps[1000000003214821615029366324] = 1067; + rayToBps[1000000003217686741942158234] = 1068; + rayToBps[1000000003220551610000830269] = 1069; + rayToBps[1000000003223416219252151318] = 1070; + rayToBps[1000000003226280569742877599] = 1071; + rayToBps[1000000003229144661519752659] = 1072; + rayToBps[1000000003232008494629507379] = 1073; + rayToBps[1000000003234872069118859983] = 1074; + rayToBps[1000000003237735385034516037] = 1075; + rayToBps[1000000003240598442423168457] = 1076; + rayToBps[1000000003243461241331497510] = 1077; + rayToBps[1000000003246323781806170825] = 1078; + rayToBps[1000000003249186063893843391] = 1079; + rayToBps[1000000003252048087641157566] = 1080; + rayToBps[1000000003254909853094743078] = 1081; + rayToBps[1000000003257771360301217032] = 1082; + rayToBps[1000000003260632609307183913] = 1083; + rayToBps[1000000003263493600159235596] = 1084; + rayToBps[1000000003266354332903951338] = 1085; + rayToBps[1000000003269214807587897798] = 1086; + rayToBps[1000000003272075024257629030] = 1087; + rayToBps[1000000003274934982959686493] = 1088; + rayToBps[1000000003277794683740599053] = 1089; + rayToBps[1000000003280654126646882991] = 1090; + rayToBps[1000000003283513311725042002] = 1091; + rayToBps[1000000003286372239021567206] = 1092; + rayToBps[1000000003289230908582937149] = 1093; + rayToBps[1000000003292089320455617805] = 1094; + rayToBps[1000000003294947474686062586] = 1095; + rayToBps[1000000003297805371320712343] = 1096; + rayToBps[1000000003300663010405995372] = 1097; + rayToBps[1000000003303520391988327418] = 1098; + rayToBps[1000000003306377516114111677] = 1099; + rayToBps[1000000003309234382829738808] = 1100; + rayToBps[1000000003312090992181586929] = 1101; + rayToBps[1000000003314947344216021625] = 1102; + rayToBps[1000000003317803438979395953] = 1103; + rayToBps[1000000003320659276518050449] = 1104; + rayToBps[1000000003323514856878313124] = 1105; + rayToBps[1000000003326370180106499479] = 1106; + rayToBps[1000000003329225246248912502] = 1107; + rayToBps[1000000003332080055351842678] = 1108; + rayToBps[1000000003334934607461567985] = 1109; + rayToBps[1000000003337788902624353911] = 1110; + rayToBps[1000000003340642940886453447] = 1111; + rayToBps[1000000003343496722294107097] = 1112; + rayToBps[1000000003346350246893542883] = 1113; + rayToBps[1000000003349203514730976348] = 1114; + rayToBps[1000000003352056525852610558] = 1115; + rayToBps[1000000003354909280304636111] = 1116; + rayToBps[1000000003357761778133231141] = 1117; + rayToBps[1000000003360614019384561319] = 1118; + rayToBps[1000000003363466004104779860] = 1119; + rayToBps[1000000003366317732340027527] = 1120; + rayToBps[1000000003369169204136432636] = 1121; + rayToBps[1000000003372020419540111060] = 1122; + rayToBps[1000000003374871378597166232] = 1123; + rayToBps[1000000003377722081353689153] = 1124; + rayToBps[1000000003380572527855758393] = 1125; + rayToBps[1000000003383422718149440098] = 1126; + rayToBps[1000000003386272652280787992] = 1127; + rayToBps[1000000003389122330295843384] = 1128; + rayToBps[1000000003391971752240635171] = 1129; + rayToBps[1000000003394820918161179843] = 1130; + rayToBps[1000000003397669828103481484] = 1131; + rayToBps[1000000003400518482113531785] = 1132; + rayToBps[1000000003403366880237310040] = 1133; + rayToBps[1000000003406215022520783154] = 1134; + rayToBps[1000000003409062909009905646] = 1135; + rayToBps[1000000003411910539750619657] = 1136; + rayToBps[1000000003414757914788854950] = 1137; + rayToBps[1000000003417605034170528915] = 1138; + rayToBps[1000000003420451897941546578] = 1139; + rayToBps[1000000003423298506147800601] = 1140; + rayToBps[1000000003426144858835171287] = 1141; + rayToBps[1000000003428990956049526585] = 1142; + rayToBps[1000000003431836797836722098] = 1143; + rayToBps[1000000003434682384242601076] = 1144; + rayToBps[1000000003437527715312994437] = 1145; + rayToBps[1000000003440372791093720759] = 1146; + rayToBps[1000000003443217611630586286] = 1147; + rayToBps[1000000003446062176969384941] = 1148; + rayToBps[1000000003448906487155898317] = 1149; + rayToBps[1000000003451750542235895695] = 1150; + rayToBps[1000000003454594342255134037] = 1151; + rayToBps[1000000003457437887259357996] = 1152; + rayToBps[1000000003460281177294299923] = 1153; + rayToBps[1000000003463124212405679865] = 1154; + rayToBps[1000000003465966992639205574] = 1155; + rayToBps[1000000003468809518040572510] = 1156; + rayToBps[1000000003471651788655463845] = 1157; + rayToBps[1000000003474493804529550469] = 1158; + rayToBps[1000000003477335565708490991] = 1159; + rayToBps[1000000003480177072237931747] = 1160; + rayToBps[1000000003483018324163506803] = 1161; + rayToBps[1000000003485859321530837959] = 1162; + rayToBps[1000000003488700064385534755] = 1163; + rayToBps[1000000003491540552773194473] = 1164; + rayToBps[1000000003494380786739402144] = 1165; + rayToBps[1000000003497220766329730547] = 1166; + rayToBps[1000000003500060491589740224] = 1167; + rayToBps[1000000003502899962564979471] = 1168; + rayToBps[1000000003505739179300984355] = 1169; + rayToBps[1000000003508578141843278707] = 1170; + rayToBps[1000000003511416850237374137] = 1171; + rayToBps[1000000003514255304528770030] = 1172; + rayToBps[1000000003517093504762953555] = 1173; + rayToBps[1000000003519931450985399667] = 1174; + rayToBps[1000000003522769143241571114] = 1175; + rayToBps[1000000003525606581576918439] = 1176; + rayToBps[1000000003528443766036879984] = 1177; + rayToBps[1000000003531280696666881897] = 1178; + rayToBps[1000000003534117373512338136] = 1179; + rayToBps[1000000003536953796618650468] = 1180; + rayToBps[1000000003539789966031208483] = 1181; + rayToBps[1000000003542625881795389588] = 1182; + rayToBps[1000000003545461543956559019] = 1183; + rayToBps[1000000003548296952560069844] = 1184; + rayToBps[1000000003551132107651262963] = 1185; + rayToBps[1000000003553967009275467116] = 1186; + rayToBps[1000000003556801657477998888] = 1187; + rayToBps[1000000003559636052304162712] = 1188; + rayToBps[1000000003562470193799250871] = 1189; + rayToBps[1000000003565304082008543509] = 1190; + rayToBps[1000000003568137716977308627] = 1191; + rayToBps[1000000003570971098750802094] = 1192; + rayToBps[1000000003573804227374267648] = 1193; + rayToBps[1000000003576637102892936900] = 1194; + rayToBps[1000000003579469725352029341] = 1195; + rayToBps[1000000003582302094796752344] = 1196; + rayToBps[1000000003585134211272301170] = 1197; + rayToBps[1000000003587966074823858969] = 1198; + rayToBps[1000000003590797685496596791] = 1199; + rayToBps[1000000003593629043335673582] = 1200; + rayToBps[1000000003596460148386236193] = 1201; + rayToBps[1000000003599291000693419387] = 1202; + rayToBps[1000000003602121600302345836] = 1203; + rayToBps[1000000003604951947258126131] = 1204; + rayToBps[1000000003607782041605858785] = 1205; + rayToBps[1000000003610611883390630237] = 1206; + rayToBps[1000000003613441472657514856] = 1207; + rayToBps[1000000003616270809451574945] = 1208; + rayToBps[1000000003619099893817860747] = 1209; + rayToBps[1000000003621928725801410447] = 1210; + rayToBps[1000000003624757305447250178] = 1211; + rayToBps[1000000003627585632800394025] = 1212; + rayToBps[1000000003630413707905844031] = 1213; + rayToBps[1000000003633241530808590194] = 1214; + rayToBps[1000000003636069101553610482] = 1215; + rayToBps[1000000003638896420185870830] = 1216; + rayToBps[1000000003641723486750325145] = 1217; + rayToBps[1000000003644550301291915316] = 1218; + rayToBps[1000000003647376863855571208] = 1219; + rayToBps[1000000003650203174486210676] = 1220; + rayToBps[1000000003653029233228739563] = 1221; + rayToBps[1000000003655855040128051709] = 1222; + rayToBps[1000000003658680595229028953] = 1223; + rayToBps[1000000003661505898576541135] = 1224; + rayToBps[1000000003664330950215446102] = 1225; + rayToBps[1000000003667155750190589718] = 1226; + rayToBps[1000000003669980298546805858] = 1227; + rayToBps[1000000003672804595328916419] = 1228; + rayToBps[1000000003675628640581731322] = 1229; + rayToBps[1000000003678452434350048518] = 1230; + rayToBps[1000000003681275976678653990] = 1231; + rayToBps[1000000003684099267612321761] = 1232; + rayToBps[1000000003686922307195813890] = 1233; + rayToBps[1000000003689745095473880490] = 1234; + rayToBps[1000000003692567632491259715] = 1235; + rayToBps[1000000003695389918292677782] = 1236; + rayToBps[1000000003698211952922848960] = 1237; + rayToBps[1000000003701033736426475586] = 1238; + rayToBps[1000000003703855268848248061] = 1239; + rayToBps[1000000003706676550232844859] = 1240; + rayToBps[1000000003709497580624932527] = 1241; + rayToBps[1000000003712318360069165696] = 1242; + rayToBps[1000000003715138888610187078] = 1243; + rayToBps[1000000003717959166292627475] = 1244; + rayToBps[1000000003720779193161105781] = 1245; + rayToBps[1000000003723598969260228987] = 1246; + rayToBps[1000000003726418494634592186] = 1247; + rayToBps[1000000003729237769328778574] = 1248; + rayToBps[1000000003732056793387359459] = 1249; + rayToBps[1000000003734875566854894261] = 1250; + rayToBps[1000000003737694089775930518] = 1251; + rayToBps[1000000003740512362195003894] = 1252; + rayToBps[1000000003743330384156638173] = 1253; + rayToBps[1000000003746148155705345276] = 1254; + rayToBps[1000000003748965676885625255] = 1255; + rayToBps[1000000003751782947741966301] = 1256; + rayToBps[1000000003754599968318844752] = 1257; + rayToBps[1000000003757416738660725089] = 1258; + rayToBps[1000000003760233258812059948] = 1259; + rayToBps[1000000003763049528817290119] = 1260; + rayToBps[1000000003765865548720844553] = 1261; + rayToBps[1000000003768681318567140366] = 1262; + rayToBps[1000000003771496838400582842] = 1263; + rayToBps[1000000003774312108265565437] = 1264; + rayToBps[1000000003777127128206469785] = 1265; + rayToBps[1000000003779941898267665701] = 1266; + rayToBps[1000000003782756418493511185] = 1267; + rayToBps[1000000003785570688928352427] = 1268; + rayToBps[1000000003788384709616523810] = 1269; + rayToBps[1000000003791198480602347918] = 1270; + rayToBps[1000000003794012001930135532] = 1271; + rayToBps[1000000003796825273644185643] = 1272; + rayToBps[1000000003799638295788785451] = 1273; + rayToBps[1000000003802451068408210371] = 1274; + rayToBps[1000000003805263591546724039] = 1275; + rayToBps[1000000003808075865248578310] = 1276; + rayToBps[1000000003810887889558013269] = 1277; + rayToBps[1000000003813699664519257234] = 1278; + rayToBps[1000000003816511190176526753] = 1279; + rayToBps[1000000003819322466574026619] = 1280; + rayToBps[1000000003822133493755949867] = 1281; + rayToBps[1000000003824944271766477781] = 1282; + rayToBps[1000000003827754800649779894] = 1283; + rayToBps[1000000003830565080450014001] = 1284; + rayToBps[1000000003833375111211326151] = 1285; + rayToBps[1000000003836184892977850664] = 1286; + rayToBps[1000000003838994425793710125] = 1287; + rayToBps[1000000003841803709703015394] = 1288; + rayToBps[1000000003844612744749865606] = 1289; + rayToBps[1000000003847421530978348180] = 1290; + rayToBps[1000000003850230068432538818] = 1291; + rayToBps[1000000003853038357156501515] = 1292; + rayToBps[1000000003855846397194288557] = 1293; + rayToBps[1000000003858654188589940528] = 1294; + rayToBps[1000000003861461731387486315] = 1295; + rayToBps[1000000003864269025630943112] = 1296; + rayToBps[1000000003867076071364316422] = 1297; + rayToBps[1000000003869882868631600065] = 1298; + rayToBps[1000000003872689417476776174] = 1299; + rayToBps[1000000003875495717943815211] = 1300; + rayToBps[1000000003878301770076675963] = 1301; + rayToBps[1000000003881107573919305546] = 1302; + rayToBps[1000000003883913129515639415] = 1303; + rayToBps[1000000003886718436909601359] = 1304; + rayToBps[1000000003889523496145103516] = 1305; + rayToBps[1000000003892328307266046370] = 1306; + rayToBps[1000000003895132870316318753] = 1307; + rayToBps[1000000003897937185339797857] = 1308; + rayToBps[1000000003900741252380349234] = 1309; + rayToBps[1000000003903545071481826796] = 1310; + rayToBps[1000000003906348642688072829] = 1311; + rayToBps[1000000003909151966042917985] = 1312; + rayToBps[1000000003911955041590181299] = 1313; + rayToBps[1000000003914757869373670180] = 1314; + rayToBps[1000000003917560449437180427] = 1315; + rayToBps[1000000003920362781824496225] = 1316; + rayToBps[1000000003923164866579390151] = 1317; + rayToBps[1000000003925966703745623181] = 1318; + rayToBps[1000000003928768293366944691] = 1319; + rayToBps[1000000003931569635487092463] = 1320; + rayToBps[1000000003934370730149792686] = 1321; + rayToBps[1000000003937171577398759967] = 1322; + rayToBps[1000000003939972177277697324] = 1323; + rayToBps[1000000003942772529830296202] = 1324; + rayToBps[1000000003945572635100236468] = 1325; + rayToBps[1000000003948372493131186422] = 1326; + rayToBps[1000000003951172103966802794] = 1327; + rayToBps[1000000003953971467650730754] = 1328; + rayToBps[1000000003956770584226603915] = 1329; + rayToBps[1000000003959569453738044333] = 1330; + rayToBps[1000000003962368076228662518] = 1331; + rayToBps[1000000003965166451742057429] = 1332; + rayToBps[1000000003967964580321816489] = 1333; + rayToBps[1000000003970762462011515578] = 1334; + rayToBps[1000000003973560096854719047] = 1335; + rayToBps[1000000003976357484894979715] = 1336; + rayToBps[1000000003979154626175838876] = 1337; + rayToBps[1000000003981951520740826302] = 1338; + rayToBps[1000000003984748168633460248] = 1339; + rayToBps[1000000003987544569897247457] = 1340; + rayToBps[1000000003990340724575683160] = 1341; + rayToBps[1000000003993136632712251086] = 1342; + rayToBps[1000000003995932294350423462] = 1343; + rayToBps[1000000003998727709533661015] = 1344; + rayToBps[1000000004001522878305412984] = 1345; + rayToBps[1000000004004317800709117115] = 1346; + rayToBps[1000000004007112476788199671] = 1347; + rayToBps[1000000004009906906586075434] = 1348; + rayToBps[1000000004012701090146147709] = 1349; + rayToBps[1000000004015495027511808328] = 1350; + rayToBps[1000000004018288718726437654] = 1351; + rayToBps[1000000004021082163833404588] = 1352; + rayToBps[1000000004023875362876066566] = 1353; + rayToBps[1000000004026668315897769570] = 1354; + rayToBps[1000000004029461022941848130] = 1355; + rayToBps[1000000004032253484051625326] = 1356; + rayToBps[1000000004035045699270412795] = 1357; + rayToBps[1000000004037837668641510732] = 1358; + rayToBps[1000000004040629392208207896] = 1359; + rayToBps[1000000004043420870013781614] = 1360; + rayToBps[1000000004046212102101497785] = 1361; + rayToBps[1000000004049003088514610884] = 1362; + rayToBps[1000000004051793829296363962] = 1363; + rayToBps[1000000004054584324489988659] = 1364; + rayToBps[1000000004057374574138705201] = 1365; + rayToBps[1000000004060164578285722402] = 1366; + rayToBps[1000000004062954336974237676] = 1367; + rayToBps[1000000004065743850247437036] = 1368; + rayToBps[1000000004068533118148495099] = 1369; + rayToBps[1000000004071322140720575088] = 1370; + rayToBps[1000000004074110918006828838] = 1371; + rayToBps[1000000004076899450050396802] = 1372; + rayToBps[1000000004079687736894408050] = 1373; + rayToBps[1000000004082475778581980279] = 1374; + rayToBps[1000000004085263575156219812] = 1375; + rayToBps[1000000004088051126660221602] = 1376; + rayToBps[1000000004090838433137069242] = 1377; + rayToBps[1000000004093625494629834960] = 1378; + rayToBps[1000000004096412311181579631] = 1379; + rayToBps[1000000004099198882835352777] = 1380; + rayToBps[1000000004101985209634192573] = 1381; + rayToBps[1000000004104771291621125847] = 1382; + rayToBps[1000000004107557128839168089] = 1383; + rayToBps[1000000004110342721331323451] = 1384; + rayToBps[1000000004113128069140584754] = 1385; + rayToBps[1000000004115913172309933491] = 1386; + rayToBps[1000000004118698030882339831] = 1387; + rayToBps[1000000004121482644900762619] = 1388; + rayToBps[1000000004124267014408149388] = 1389; + rayToBps[1000000004127051139447436357] = 1390; + rayToBps[1000000004129835020061548436] = 1391; + rayToBps[1000000004132618656293399231] = 1392; + rayToBps[1000000004135402048185891048] = 1393; + rayToBps[1000000004138185195781914895] = 1394; + rayToBps[1000000004140968099124350490] = 1395; + rayToBps[1000000004143750758256066259] = 1396; + rayToBps[1000000004146533173219919347] = 1397; + rayToBps[1000000004149315344058755615] = 1398; + rayToBps[1000000004152097270815409650] = 1399; + rayToBps[1000000004154878953532704765] = 1400; + rayToBps[1000000004157660392253453003] = 1401; + rayToBps[1000000004160441587020455146] = 1402; + rayToBps[1000000004163222537876500710] = 1403; + rayToBps[1000000004166003244864367958] = 1404; + rayToBps[1000000004168783708026823899] = 1405; + rayToBps[1000000004171563927406624291] = 1406; + rayToBps[1000000004174343903046513649] = 1407; + rayToBps[1000000004177123634989225246] = 1408; + rayToBps[1000000004179903123277481120] = 1409; + rayToBps[1000000004182682367953992073] = 1410; + rayToBps[1000000004185461369061457677] = 1411; + rayToBps[1000000004188240126642566281] = 1412; + rayToBps[1000000004191018640739995012] = 1413; + rayToBps[1000000004193796911396409779] = 1414; + rayToBps[1000000004196574938654465277] = 1415; + rayToBps[1000000004199352722556804991] = 1416; + rayToBps[1000000004202130263146061203] = 1417; + rayToBps[1000000004204907560464854990] = 1418; + rayToBps[1000000004207684614555796231] = 1419; + rayToBps[1000000004210461425461483615] = 1420; + rayToBps[1000000004213237993224504637] = 1421; + rayToBps[1000000004216014317887435608] = 1422; + rayToBps[1000000004218790399492841653] = 1423; + rayToBps[1000000004221566238083276725] = 1424; + rayToBps[1000000004224341833701283597] = 1425; + rayToBps[1000000004227117186389393875] = 1426; + rayToBps[1000000004229892296190127996] = 1427; + rayToBps[1000000004232667163145995236] = 1428; + rayToBps[1000000004235441787299493712] = 1429; + rayToBps[1000000004238216168693110386] = 1430; + rayToBps[1000000004240990307369321069] = 1431; + rayToBps[1000000004243764203370590423] = 1432; + rayToBps[1000000004246537856739371971] = 1433; + rayToBps[1000000004249311267518108094] = 1434; + rayToBps[1000000004252084435749230038] = 1435; + rayToBps[1000000004254857361475157917] = 1436; + rayToBps[1000000004257630044738300719] = 1437; + rayToBps[1000000004260402485581056307] = 1438; + rayToBps[1000000004263174684045811425] = 1439; + rayToBps[1000000004265946640174941701] = 1440; + rayToBps[1000000004268718354010811651] = 1441; + rayToBps[1000000004271489825595774681] = 1442; + rayToBps[1000000004274261054972173095] = 1443; + rayToBps[1000000004277032042182338097] = 1444; + rayToBps[1000000004279802787268589794] = 1445; + rayToBps[1000000004282573290273237200] = 1446; + rayToBps[1000000004285343551238578238] = 1447; + rayToBps[1000000004288113570206899751] = 1448; + rayToBps[1000000004290883347220477497] = 1449; + rayToBps[1000000004293652882321576158] = 1450; + rayToBps[1000000004296422175552449345] = 1451; + rayToBps[1000000004299191226955339597] = 1452; + rayToBps[1000000004301960036572478387] = 1453; + rayToBps[1000000004304728604446086130] = 1454; + rayToBps[1000000004307496930618372179] = 1455; + rayToBps[1000000004310265015131534834] = 1456; + rayToBps[1000000004313032858027761349] = 1457; + rayToBps[1000000004315800459349227927] = 1458; + rayToBps[1000000004318567819138099730] = 1459; + rayToBps[1000000004321334937436530883] = 1460; + rayToBps[1000000004324101814286664475] = 1461; + rayToBps[1000000004326868449730632563] = 1462; + rayToBps[1000000004329634843810556180] = 1463; + rayToBps[1000000004332400996568545334] = 1464; + rayToBps[1000000004335166908046699016] = 1465; + rayToBps[1000000004337932578287105196] = 1466; + rayToBps[1000000004340698007331840840] = 1467; + rayToBps[1000000004343463195222971901] = 1468; + rayToBps[1000000004346228142002553329] = 1469; + rayToBps[1000000004348992847712629077] = 1470; + rayToBps[1000000004351757312395232098] = 1471; + rayToBps[1000000004354521536092384354] = 1472; + rayToBps[1000000004357285518846096818] = 1473; + rayToBps[1000000004360049260698369481] = 1474; + rayToBps[1000000004362812761691191350] = 1475; + rayToBps[1000000004365576021866540454] = 1476; + rayToBps[1000000004368339041266383854] = 1477; + rayToBps[1000000004371101819932677638] = 1478; + rayToBps[1000000004373864357907366926] = 1479; + rayToBps[1000000004376626655232385882] = 1480; + rayToBps[1000000004379388711949657709] = 1481; + rayToBps[1000000004382150528101094654] = 1482; + rayToBps[1000000004384912103728598017] = 1483; + rayToBps[1000000004387673438874058150] = 1484; + rayToBps[1000000004390434533579354464] = 1485; + rayToBps[1000000004393195387886355428] = 1486; + rayToBps[1000000004395956001836918578] = 1487; + rayToBps[1000000004398716375472890520] = 1488; + rayToBps[1000000004401476508836106929] = 1489; + rayToBps[1000000004404236401968392559] = 1490; + rayToBps[1000000004406996054911561245] = 1491; + rayToBps[1000000004409755467707415902] = 1492; + rayToBps[1000000004412514640397748538] = 1493; + rayToBps[1000000004415273573024340248] = 1494; + rayToBps[1000000004418032265628961226] = 1495; + rayToBps[1000000004420790718253370761] = 1496; + rayToBps[1000000004423548930939317250] = 1497; + rayToBps[1000000004426306903728538193] = 1498; + rayToBps[1000000004429064636662760200] = 1499; + rayToBps[1000000004431822129783699001] = 1500; + rayToBps[1000000004434579383133059436] = 1501; + rayToBps[1000000004437336396752535473] = 1502; + rayToBps[1000000004440093170683810203] = 1503; + rayToBps[1000000004442849704968555849] = 1504; + rayToBps[1000000004445605999648433763] = 1505; + rayToBps[1000000004448362054765094438] = 1506; + rayToBps[1000000004451117870360177505] = 1507; + rayToBps[1000000004453873446475311742] = 1508; + rayToBps[1000000004456628783152115072] = 1509; + rayToBps[1000000004459383880432194574] = 1510; + rayToBps[1000000004462138738357146482] = 1511; + rayToBps[1000000004464893356968556186] = 1512; + rayToBps[1000000004467647736307998245] = 1513; + rayToBps[1000000004470401876417036380] = 1514; + rayToBps[1000000004473155777337223487] = 1515; + rayToBps[1000000004475909439110101633] = 1516; + rayToBps[1000000004478662861777202067] = 1517; + rayToBps[1000000004481416045380045219] = 1518; + rayToBps[1000000004484168989960140704] = 1519; + rayToBps[1000000004486921695558987326] = 1520; + rayToBps[1000000004489674162218073087] = 1521; + rayToBps[1000000004492426389978875180] = 1522; + rayToBps[1000000004495178378882860004] = 1523; + rayToBps[1000000004497930128971483160] = 1524; + rayToBps[1000000004500681640286189459] = 1525; + rayToBps[1000000004503432912868412922] = 1526; + rayToBps[1000000004506183946759576791] = 1527; + rayToBps[1000000004508934742001093521] = 1528; + rayToBps[1000000004511685298634364794] = 1529; + rayToBps[1000000004514435616700781520] = 1530; + rayToBps[1000000004517185696241723838] = 1531; + rayToBps[1000000004519935537298561123] = 1532; + rayToBps[1000000004522685139912651989] = 1533; + rayToBps[1000000004525434504125344289] = 1534; + rayToBps[1000000004528183629977975125] = 1535; + rayToBps[1000000004530932517511870847] = 1536; + rayToBps[1000000004533681166768347059] = 1537; + rayToBps[1000000004536429577788708623] = 1538; + rayToBps[1000000004539177750614249659] = 1539; + rayToBps[1000000004541925685286253554] = 1540; + rayToBps[1000000004544673381845992962] = 1541; + rayToBps[1000000004547420840334729810] = 1542; + rayToBps[1000000004550168060793715299] = 1543; + rayToBps[1000000004552915043264189911] = 1544; + rayToBps[1000000004555661787787383409] = 1545; + rayToBps[1000000004558408294404514847] = 1546; + rayToBps[1000000004561154563156792564] = 1547; + rayToBps[1000000004563900594085414197] = 1548; + rayToBps[1000000004566646387231566680] = 1549; + rayToBps[1000000004569391942636426248] = 1550; + rayToBps[1000000004572137260341158442] = 1551; + rayToBps[1000000004574882340386918113] = 1552; + rayToBps[1000000004577627182814849422] = 1553; + rayToBps[1000000004580371787666085848] = 1554; + rayToBps[1000000004583116154981750191] = 1555; + rayToBps[1000000004585860284802954574] = 1556; + rayToBps[1000000004588604177170800448] = 1557; + rayToBps[1000000004591347832126378593] = 1558; + rayToBps[1000000004594091249710769128] = 1559; + rayToBps[1000000004596834429965041505] = 1560; + rayToBps[1000000004599577372930254526] = 1561; + rayToBps[1000000004602320078647456331] = 1562; + rayToBps[1000000004605062547157684415] = 1563; + rayToBps[1000000004607804778501965623] = 1564; + rayToBps[1000000004610546772721316162] = 1565; + rayToBps[1000000004613288529856741593] = 1566; + rayToBps[1000000004616030049949236846] = 1567; + rayToBps[1000000004618771333039786217] = 1568; + rayToBps[1000000004621512379169363376] = 1569; + rayToBps[1000000004624253188378931367] = 1570; + rayToBps[1000000004626993760709442611] = 1571; + rayToBps[1000000004629734096201838917] = 1572; + rayToBps[1000000004632474194897051476] = 1573; + rayToBps[1000000004635214056836000869] = 1574; + rayToBps[1000000004637953682059597074] = 1575; + rayToBps[1000000004640693070608739463] = 1576; + rayToBps[1000000004643432222524316813] = 1577; + rayToBps[1000000004646171137847207302] = 1578; + rayToBps[1000000004648909816618278519] = 1579; + rayToBps[1000000004651648258878387462] = 1580; + rayToBps[1000000004654386464668380549] = 1581; + rayToBps[1000000004657124434029093614] = 1582; + rayToBps[1000000004659862167001351915] = 1583; + rayToBps[1000000004662599663625970138] = 1584; + rayToBps[1000000004665336923943752398] = 1585; + rayToBps[1000000004668073947995492244] = 1586; + rayToBps[1000000004670810735821972662] = 1587; + rayToBps[1000000004673547287463966083] = 1588; + rayToBps[1000000004676283602962234377] = 1589; + rayToBps[1000000004679019682357528867] = 1590; + rayToBps[1000000004681755525690590328] = 1591; + rayToBps[1000000004684491133002148989] = 1592; + rayToBps[1000000004687226504332924539] = 1593; + rayToBps[1000000004689961639723626131] = 1594; + rayToBps[1000000004692696539214952384] = 1595; + rayToBps[1000000004695431202847591388] = 1596; + rayToBps[1000000004698165630662220707] = 1597; + rayToBps[1000000004700899822699507381] = 1598; + rayToBps[1000000004703633779000107935] = 1599; + rayToBps[1000000004706367499604668374] = 1600; + rayToBps[1000000004709100984553824197] = 1601; + rayToBps[1000000004711834233888200390] = 1602; + rayToBps[1000000004714567247648411439] = 1603; + rayToBps[1000000004717300025875061327] = 1604; + rayToBps[1000000004720032568608743539] = 1605; + rayToBps[1000000004722764875890041071] = 1606; + rayToBps[1000000004725496947759526424] = 1607; + rayToBps[1000000004728228784257761617] = 1608; + rayToBps[1000000004730960385425298185] = 1609; + rayToBps[1000000004733691751302677184] = 1610; + rayToBps[1000000004736422881930429194] = 1611; + rayToBps[1000000004739153777349074326] = 1612; + rayToBps[1000000004741884437599122219] = 1613; + rayToBps[1000000004744614862721072050] = 1614; + rayToBps[1000000004747345052755412536] = 1615; + rayToBps[1000000004750075007742621934] = 1616; + rayToBps[1000000004752804727723168051] = 1617; + rayToBps[1000000004755534212737508240] = 1618; + rayToBps[1000000004758263462826089409] = 1619; + rayToBps[1000000004760992478029348025] = 1620; + rayToBps[1000000004763721258387710114] = 1621; + rayToBps[1000000004766449803941591267] = 1622; + rayToBps[1000000004769178114731396642] = 1623; + rayToBps[1000000004771906190797520968] = 1624; + rayToBps[1000000004774634032180348552] = 1625; + rayToBps[1000000004777361638920253278] = 1626; + rayToBps[1000000004780089011057598610] = 1627; + rayToBps[1000000004782816148632737601] = 1628; + rayToBps[1000000004785543051686012893] = 1629; + rayToBps[1000000004788269720257756721] = 1630; + rayToBps[1000000004790996154388290915] = 1631; + rayToBps[1000000004793722354117926905] = 1632; + rayToBps[1000000004796448319486965728] = 1633; + rayToBps[1000000004799174050535698027] = 1634; + rayToBps[1000000004801899547304404054] = 1635; + rayToBps[1000000004804624809833353677] = 1636; + rayToBps[1000000004807349838162806381] = 1637; + rayToBps[1000000004810074632333011275] = 1638; + rayToBps[1000000004812799192384207089] = 1639; + rayToBps[1000000004815523518356622187] = 1640; + rayToBps[1000000004818247610290474561] = 1641; + rayToBps[1000000004820971468225971842] = 1642; + rayToBps[1000000004823695092203311297] = 1643; + rayToBps[1000000004826418482262679840] = 1644; + rayToBps[1000000004829141638444254028] = 1645; + rayToBps[1000000004831864560788200070] = 1646; + rayToBps[1000000004834587249334673829] = 1647; + rayToBps[1000000004837309704123820822] = 1648; + rayToBps[1000000004840031925195776232] = 1649; + rayToBps[1000000004842753912590664903] = 1650; + rayToBps[1000000004845475666348601346] = 1651; + rayToBps[1000000004848197186509689746] = 1652; + rayToBps[1000000004850918473114023962] = 1653; + rayToBps[1000000004853639526201687531] = 1654; + rayToBps[1000000004856360345812753672] = 1655; + rayToBps[1000000004859080931987285289] = 1656; + rayToBps[1000000004861801284765334978] = 1657; + rayToBps[1000000004864521404186945026] = 1658; + rayToBps[1000000004867241290292147414] = 1659; + rayToBps[1000000004869960943120963825] = 1660; + rayToBps[1000000004872680362713405646] = 1661; + rayToBps[1000000004875399549109473969] = 1662; + rayToBps[1000000004878118502349159596] = 1663; + rayToBps[1000000004880837222472443046] = 1664; + rayToBps[1000000004883555709519294552] = 1665; + rayToBps[1000000004886273963529674069] = 1666; + rayToBps[1000000004888991984543531278] = 1667; + rayToBps[1000000004891709772600805585] = 1668; + rayToBps[1000000004894427327741426131] = 1669; + rayToBps[1000000004897144650005311787] = 1670; + rayToBps[1000000004899861739432371169] = 1671; + rayToBps[1000000004902578596062502630] = 1672; + rayToBps[1000000004905295219935594269] = 1673; + rayToBps[1000000004908011611091523937] = 1674; + rayToBps[1000000004910727769570159235] = 1675; + rayToBps[1000000004913443695411357522] = 1676; + rayToBps[1000000004916159388654965915] = 1677; + rayToBps[1000000004918874849340821294] = 1678; + rayToBps[1000000004921590077508750306] = 1679; + rayToBps[1000000004924305073198569369] = 1680; + rayToBps[1000000004927019836450084674] = 1681; + rayToBps[1000000004929734367303092189] = 1682; + rayToBps[1000000004932448665797377662] = 1683; + rayToBps[1000000004935162731972716627] = 1684; + rayToBps[1000000004937876565868874403] = 1685; + rayToBps[1000000004940590167525606103] = 1686; + rayToBps[1000000004943303536982656633] = 1687; + rayToBps[1000000004946016674279760695] = 1688; + rayToBps[1000000004948729579456642798] = 1689; + rayToBps[1000000004951442252553017251] = 1690; + rayToBps[1000000004954154693608588174] = 1691; + rayToBps[1000000004956866902663049499] = 1692; + rayToBps[1000000004959578879756084972] = 1693; + rayToBps[1000000004962290624927368160] = 1694; + rayToBps[1000000004965002138216562451] = 1695; + rayToBps[1000000004967713419663321060] = 1696; + rayToBps[1000000004970424469307287030] = 1697; + rayToBps[1000000004973135287188093241] = 1698; + rayToBps[1000000004975845873345362402] = 1699; + rayToBps[1000000004978556227818707070] = 1700; + rayToBps[1000000004981266350647729640] = 1701; + rayToBps[1000000004983976241872022356] = 1702; + rayToBps[1000000004986685901531167312] = 1703; + rayToBps[1000000004989395329664736455] = 1704; + rayToBps[1000000004992104526312291591] = 1705; + rayToBps[1000000004994813491513384383] = 1706; + rayToBps[1000000004997522225307556365] = 1707; + rayToBps[1000000005000230727734338930] = 1708; + rayToBps[1000000005002938998833253350] = 1709; + rayToBps[1000000005005647038643810765] = 1710; + rayToBps[1000000005008354847205512199] = 1711; + rayToBps[1000000005011062424557848553] = 1712; + rayToBps[1000000005013769770740300614] = 1713; + rayToBps[1000000005016476885792339060] = 1714; + rayToBps[1000000005019183769753424457] = 1715; + rayToBps[1000000005021890422663007268] = 1716; + rayToBps[1000000005024596844560527854] = 1717; + rayToBps[1000000005027303035485416482] = 1718; + rayToBps[1000000005030008995477093319] = 1719; + rayToBps[1000000005032714724574968444] = 1720; + rayToBps[1000000005035420222818441850] = 1721; + rayToBps[1000000005038125490246903442] = 1722; + rayToBps[1000000005040830526899733047] = 1723; + rayToBps[1000000005043535332816300415] = 1724; + rayToBps[1000000005046239908035965222] = 1725; + rayToBps[1000000005048944252598077073] = 1726; + rayToBps[1000000005051648366541975506] = 1727; + rayToBps[1000000005054352249906989998] = 1728; + rayToBps[1000000005057055902732439961] = 1729; + rayToBps[1000000005059759325057634757] = 1730; + rayToBps[1000000005062462516921873690] = 1731; + rayToBps[1000000005065165478364446016] = 1732; + rayToBps[1000000005067868209424630945] = 1733; + rayToBps[1000000005070570710141697643] = 1734; + rayToBps[1000000005073272980554905239] = 1735; + rayToBps[1000000005075975020703502822] = 1736; + rayToBps[1000000005078676830626729453] = 1737; + rayToBps[1000000005081378410363814160] = 1738; + rayToBps[1000000005084079759953975947] = 1739; + rayToBps[1000000005086780879436423797] = 1740; + rayToBps[1000000005089481768850356672] = 1741; + rayToBps[1000000005092182428234963519] = 1742; + rayToBps[1000000005094882857629423273] = 1743; + rayToBps[1000000005097583057072904861] = 1744; + rayToBps[1000000005100283026604567203] = 1745; + rayToBps[1000000005102982766263559220] = 1746; + rayToBps[1000000005105682276089019831] = 1747; + rayToBps[1000000005108381556120077964] = 1748; + rayToBps[1000000005111080606395852551] = 1749; + rayToBps[1000000005113779426955452540] = 1750; + rayToBps[1000000005116478017837976890] = 1751; + rayToBps[1000000005119176379082514583] = 1752; + rayToBps[1000000005121874510728144619] = 1753; + rayToBps[1000000005124572412813936025] = 1754; + rayToBps[1000000005127270085378947858] = 1755; + rayToBps[1000000005129967528462229205] = 1756; + rayToBps[1000000005132664742102819189] = 1757; + rayToBps[1000000005135361726339746974] = 1758; + rayToBps[1000000005138058481212031762] = 1759; + rayToBps[1000000005140755006758682806] = 1760; + rayToBps[1000000005143451303018699404] = 1761; + rayToBps[1000000005146147370031070909] = 1762; + rayToBps[1000000005148843207834776727] = 1763; + rayToBps[1000000005151538816468786327] = 1764; + rayToBps[1000000005154234195972059237] = 1765; + rayToBps[1000000005156929346383545054] = 1766; + rayToBps[1000000005159624267742183441] = 1767; + rayToBps[1000000005162318960086904137] = 1768; + rayToBps[1000000005165013423456626957] = 1769; + rayToBps[1000000005167707657890261792] = 1770; + rayToBps[1000000005170401663426708619] = 1771; + rayToBps[1000000005173095440104857501] = 1772; + rayToBps[1000000005175788987963588589] = 1773; + rayToBps[1000000005178482307041772129] = 1774; + rayToBps[1000000005181175397378268462] = 1775; + rayToBps[1000000005183868259011928028] = 1776; + rayToBps[1000000005186560891981591373] = 1777; + rayToBps[1000000005189253296326089147] = 1778; + rayToBps[1000000005191945472084242108] = 1779; + rayToBps[1000000005194637419294861132] = 1780; + rayToBps[1000000005197329137996747207] = 1781; + rayToBps[1000000005200020628228691445] = 1782; + rayToBps[1000000005202711890029475077] = 1783; + rayToBps[1000000005205402923437869462] = 1784; + rayToBps[1000000005208093728492636093] = 1785; + rayToBps[1000000005210784305232526588] = 1786; + rayToBps[1000000005213474653696282710] = 1787; + rayToBps[1000000005216164773922636357] = 1788; + rayToBps[1000000005218854665950309569] = 1789; + rayToBps[1000000005221544329818014540] = 1790; + rayToBps[1000000005224233765564453606] = 1791; + rayToBps[1000000005226922973228319260] = 1792; + rayToBps[1000000005229611952848294151] = 1793; + rayToBps[1000000005232300704463051089] = 1794; + rayToBps[1000000005234989228111253046] = 1795; + rayToBps[1000000005237677523831553161] = 1796; + rayToBps[1000000005240365591662594745] = 1797; + rayToBps[1000000005243053431643011277] = 1798; + rayToBps[1000000005245741043811426420] = 1799; + rayToBps[1000000005248428428206454010] = 1800; + rayToBps[1000000005251115584866698073] = 1801; + rayToBps[1000000005253802513830752815] = 1802; + rayToBps[1000000005256489215137202638] = 1803; + rayToBps[1000000005259175688824622133] = 1804; + rayToBps[1000000005261861934931576089] = 1805; + rayToBps[1000000005264547953496619496] = 1806; + rayToBps[1000000005267233744558297546] = 1807; + rayToBps[1000000005269919308155145638] = 1808; + rayToBps[1000000005272604644325689381] = 1809; + rayToBps[1000000005275289753108444598] = 1810; + rayToBps[1000000005277974634541917328] = 1811; + rayToBps[1000000005280659288664603827] = 1812; + rayToBps[1000000005283343715514990579] = 1813; + rayToBps[1000000005286027915131554292] = 1814; + rayToBps[1000000005288711887552761904] = 1815; + rayToBps[1000000005291395632817070587] = 1816; + rayToBps[1000000005294079150962927745] = 1817; + rayToBps[1000000005296762442028771030] = 1818; + rayToBps[1000000005299445506053028330] = 1819; + rayToBps[1000000005302128343074117781] = 1820; + rayToBps[1000000005304810953130447770] = 1821; + rayToBps[1000000005307493336260416936] = 1822; + rayToBps[1000000005310175492502414174] = 1823; + rayToBps[1000000005312857421894818640] = 1824; + rayToBps[1000000005315539124475999751] = 1825; + rayToBps[1000000005318220600284317191] = 1826; + rayToBps[1000000005320901849358120913] = 1827; + rayToBps[1000000005323582871735751141] = 1828; + rayToBps[1000000005326263667455538381] = 1829; + rayToBps[1000000005328944236555803409] = 1830; + rayToBps[1000000005331624579074857293] = 1831; + rayToBps[1000000005334304695051001381] = 1832; + rayToBps[1000000005336984584522527310] = 1833; + rayToBps[1000000005339664247527717012] = 1834; + rayToBps[1000000005342343684104842714] = 1835; + rayToBps[1000000005345022894292166942] = 1836; + rayToBps[1000000005347701878127942522] = 1837; + rayToBps[1000000005350380635650412590] = 1838; + rayToBps[1000000005353059166897810586] = 1839; + rayToBps[1000000005355737471908360264] = 1840; + rayToBps[1000000005358415550720275695] = 1841; + rayToBps[1000000005361093403371761268] = 1842; + rayToBps[1000000005363771029901011690] = 1843; + rayToBps[1000000005366448430346211998] = 1844; + rayToBps[1000000005369125604745537555] = 1845; + rayToBps[1000000005371802553137154057] = 1846; + rayToBps[1000000005374479275559217533] = 1847; + rayToBps[1000000005377155772049874353] = 1848; + rayToBps[1000000005379832042647261225] = 1849; + rayToBps[1000000005382508087389505206] = 1850; + rayToBps[1000000005385183906314723696] = 1851; + rayToBps[1000000005387859499461024450] = 1852; + rayToBps[1000000005390534866866505578] = 1853; + rayToBps[1000000005393210008569255543] = 1854; + rayToBps[1000000005395884924607353174] = 1855; + rayToBps[1000000005398559615018867662] = 1856; + rayToBps[1000000005401234079841858566] = 1857; + rayToBps[1000000005403908319114375815] = 1858; + rayToBps[1000000005406582332874459714] = 1859; + rayToBps[1000000005409256121160140942] = 1860; + rayToBps[1000000005411929684009440562] = 1861; + rayToBps[1000000005414603021460370019] = 1862; + rayToBps[1000000005417276133550931144] = 1863; + rayToBps[1000000005419949020319116161] = 1864; + rayToBps[1000000005422621681802907685] = 1865; + rayToBps[1000000005425294118040278729] = 1866; + rayToBps[1000000005427966329069192704] = 1867; + rayToBps[1000000005430638314927603428] = 1868; + rayToBps[1000000005433310075653455121] = 1869; + rayToBps[1000000005435981611284682417] = 1870; + rayToBps[1000000005438652921859210358] = 1871; + rayToBps[1000000005441324007414954408] = 1872; + rayToBps[1000000005443994867989820443] = 1873; + rayToBps[1000000005446665503621704769] = 1874; + rayToBps[1000000005449335914348494113] = 1875; + rayToBps[1000000005452006100208065634] = 1876; + rayToBps[1000000005454676061238286919] = 1877; + rayToBps[1000000005457345797477015996] = 1878; + rayToBps[1000000005460015308962101327] = 1879; + rayToBps[1000000005462684595731381818] = 1880; + rayToBps[1000000005465353657822686822] = 1881; + rayToBps[1000000005468022495273836134] = 1882; + rayToBps[1000000005470691108122640009] = 1883; + rayToBps[1000000005473359496406899150] = 1884; + rayToBps[1000000005476027660164404723] = 1885; + rayToBps[1000000005478695599432938350] = 1886; + rayToBps[1000000005481363314250272121] = 1887; + rayToBps[1000000005484030804654168594] = 1888; + rayToBps[1000000005486698070682380795] = 1889; + rayToBps[1000000005489365112372652227] = 1890; + rayToBps[1000000005492031929762716867] = 1891; + rayToBps[1000000005494698522890299176] = 1892; + rayToBps[1000000005497364891793114096] = 1893; + rayToBps[1000000005500031036508867056] = 1894; + rayToBps[1000000005502696957075253978] = 1895; + rayToBps[1000000005505362653529961273] = 1896; + rayToBps[1000000005508028125910665852] = 1897; + rayToBps[1000000005510693374255035122] = 1898; + rayToBps[1000000005513358398600726996] = 1899; + rayToBps[1000000005516023198985389892] = 1900; + rayToBps[1000000005518687775446662738] = 1901; + rayToBps[1000000005521352128022174972] = 1902; + rayToBps[1000000005524016256749546550] = 1903; + rayToBps[1000000005526680161666387944] = 1904; + rayToBps[1000000005529343842810300151] = 1905; + rayToBps[1000000005532007300218874693] = 1906; + rayToBps[1000000005534670533929693618] = 1907; + rayToBps[1000000005537333543980329507] = 1908; + rayToBps[1000000005539996330408345474] = 1909; + rayToBps[1000000005542658893251295174] = 1910; + rayToBps[1000000005545321232546722802] = 1911; + rayToBps[1000000005547983348332163094] = 1912; + rayToBps[1000000005550645240645141338] = 1913; + rayToBps[1000000005553306909523173370] = 1914; + rayToBps[1000000005555968355003765580] = 1915; + rayToBps[1000000005558629577124414915] = 1916; + rayToBps[1000000005561290575922608882] = 1917; + rayToBps[1000000005563951351435825552] = 1918; + rayToBps[1000000005566611903701533560] = 1919; + rayToBps[1000000005569272232757192116] = 1920; + rayToBps[1000000005571932338640250996] = 1921; + rayToBps[1000000005574592221388150557] = 1922; + rayToBps[1000000005577251881038321732] = 1923; + rayToBps[1000000005579911317628186037] = 1924; + rayToBps[1000000005582570531195155575] = 1925; + rayToBps[1000000005585229521776633037] = 1926; + rayToBps[1000000005587888289410011703] = 1927; + rayToBps[1000000005590546834132675450] = 1928; + rayToBps[1000000005593205155981998754] = 1929; + rayToBps[1000000005595863254995346690] = 1930; + rayToBps[1000000005598521131210074940] = 1931; + rayToBps[1000000005601178784663529791] = 1932; + rayToBps[1000000005603836215393048140] = 1933; + rayToBps[1000000005606493423435957501] = 1934; + rayToBps[1000000005609150408829576003] = 1935; + rayToBps[1000000005611807171611212394] = 1936; + rayToBps[1000000005614463711818166047] = 1937; + rayToBps[1000000005617120029487726961] = 1938; + rayToBps[1000000005619776124657175764] = 1939; + rayToBps[1000000005622431997363783716] = 1940; + rayToBps[1000000005625087647644812714] = 1941; + rayToBps[1000000005627743075537515294] = 1942; + rayToBps[1000000005630398281079134633] = 1943; + rayToBps[1000000005633053264306904553] = 1944; + rayToBps[1000000005635708025258049526] = 1945; + rayToBps[1000000005638362563969784673] = 1946; + rayToBps[1000000005641016880479315773] = 1947; + rayToBps[1000000005643670974823839258] = 1948; + rayToBps[1000000005646324847040542225] = 1949; + rayToBps[1000000005648978497166602432] = 1950; + rayToBps[1000000005651631925239188307] = 1951; + rayToBps[1000000005654285131295458945] = 1952; + rayToBps[1000000005656938115372564118] = 1953; + rayToBps[1000000005659590877507644269] = 1954; + rayToBps[1000000005662243417737830528] = 1955; + rayToBps[1000000005664895736100244700] = 1956; + rayToBps[1000000005667547832631999280] = 1957; + rayToBps[1000000005670199707370197452] = 1958; + rayToBps[1000000005672851360351933092] = 1959; + rayToBps[1000000005675502791614290768] = 1960; + rayToBps[1000000005678154001194345751] = 1961; + rayToBps[1000000005680804989129164009] = 1962; + rayToBps[1000000005683455755455802217] = 1963; + rayToBps[1000000005686106300211307757] = 1964; + rayToBps[1000000005688756623432718721] = 1965; + rayToBps[1000000005691406725157063918] = 1966; + rayToBps[1000000005694056605421362868] = 1967; + rayToBps[1000000005696706264262625816] = 1968; + rayToBps[1000000005699355701717853726] = 1969; + rayToBps[1000000005702004917824038294] = 1970; + rayToBps[1000000005704653912618161941] = 1971; + rayToBps[1000000005707302686137197819] = 1972; + rayToBps[1000000005709951238418109820] = 1973; + rayToBps[1000000005712599569497852572] = 1974; + rayToBps[1000000005715247679413371444] = 1975; + rayToBps[1000000005717895568201602551] = 1976; + rayToBps[1000000005720543235899472755] = 1977; + rayToBps[1000000005723190682543899670] = 1978; + rayToBps[1000000005725837908171791664] = 1979; + rayToBps[1000000005728484912820047862] = 1980; + rayToBps[1000000005731131696525558147] = 1981; + rayToBps[1000000005733778259325203169] = 1982; + rayToBps[1000000005736424601255854342] = 1983; + rayToBps[1000000005739070722354373849] = 1984; + rayToBps[1000000005741716622657614647] = 1985; + rayToBps[1000000005744362302202420469] = 1986; + rayToBps[1000000005747007761025625824] = 1987; + rayToBps[1000000005749652999164056007] = 1988; + rayToBps[1000000005752298016654527093] = 1989; + rayToBps[1000000005754942813533845949] = 1990; + rayToBps[1000000005757587389838810231] = 1991; + rayToBps[1000000005760231745606208388] = 1992; + rayToBps[1000000005762875880872819670] = 1993; + rayToBps[1000000005765519795675414123] = 1994; + rayToBps[1000000005768163490050752599] = 1995; + rayToBps[1000000005770806964035586754] = 1996; + rayToBps[1000000005773450217666659055] = 1997; + rayToBps[1000000005776093250980702782] = 1998; + rayToBps[1000000005778736064014442030] = 1999; + rayToBps[1000000005781378656804591712] = 2000; + rayToBps[1000000005784021029387857563] = 2001; + rayToBps[1000000005786663181800936142] = 2002; + rayToBps[1000000005789305114080514838] = 2003; + rayToBps[1000000005791946826263271867] = 2004; + rayToBps[1000000005794588318385876283] = 2005; + rayToBps[1000000005797229590484987975] = 2006; + rayToBps[1000000005799870642597257672] = 2007; + rayToBps[1000000005802511474759326946] = 2008; + rayToBps[1000000005805152087007828215] = 2009; + rayToBps[1000000005807792479379384747] = 2010; + rayToBps[1000000005810432651910610661] = 2011; + rayToBps[1000000005813072604638110932] = 2012; + rayToBps[1000000005815712337598481393] = 2013; + rayToBps[1000000005818351850828308739] = 2014; + rayToBps[1000000005820991144364170528] = 2015; + rayToBps[1000000005823630218242635187] = 2016; + rayToBps[1000000005826269072500262012] = 2017; + rayToBps[1000000005828907707173601173] = 2018; + rayToBps[1000000005831546122299193718] = 2019; + rayToBps[1000000005834184317913571571] = 2020; + rayToBps[1000000005836822294053257542] = 2021; + rayToBps[1000000005839460050754765326] = 2022; + rayToBps[1000000005842097588054599505] = 2023; + rayToBps[1000000005844734905989255555] = 2024; + rayToBps[1000000005847372004595219844] = 2025; + rayToBps[1000000005850008883908969641] = 2026; + rayToBps[1000000005852645543966973112] = 2027; + rayToBps[1000000005855281984805689330] = 2028; + rayToBps[1000000005857918206461568274] = 2029; + rayToBps[1000000005860554208971050832] = 2030; + rayToBps[1000000005863189992370568806] = 2031; + rayToBps[1000000005865825556696544911] = 2032; + rayToBps[1000000005868460901985392786] = 2033; + rayToBps[1000000005871096028273516989] = 2034; + rayToBps[1000000005873730935597313001] = 2035; + rayToBps[1000000005876365623993167233] = 2036; + rayToBps[1000000005879000093497457030] = 2037; + rayToBps[1000000005881634344146550666] = 2038; + rayToBps[1000000005884268375976807354] = 2039; + rayToBps[1000000005886902189024577248] = 2040; + rayToBps[1000000005889535783326201442] = 2041; + rayToBps[1000000005892169158918011981] = 2042; + rayToBps[1000000005894802315836331854] = 2043; + rayToBps[1000000005897435254117475004] = 2044; + rayToBps[1000000005900067973797746332] = 2045; + rayToBps[1000000005902700474913441692] = 2046; + rayToBps[1000000005905332757500847901] = 2047; + rayToBps[1000000005907964821596242742] = 2048; + rayToBps[1000000005910596667235894964] = 2049; + rayToBps[1000000005913228294456064283] = 2050; + rayToBps[1000000005915859703293001393] = 2051; + rayToBps[1000000005918490893782947960] = 2052; + rayToBps[1000000005921121865962136632] = 2053; + rayToBps[1000000005923752619866791038] = 2054; + rayToBps[1000000005926383155533125790] = 2055; + rayToBps[1000000005929013472997346492] = 2056; + rayToBps[1000000005931643572295649735] = 2057; + rayToBps[1000000005934273453464223108] = 2058; + rayToBps[1000000005936903116539245192] = 2059; + rayToBps[1000000005939532561556885575] = 2060; + rayToBps[1000000005942161788553304839] = 2061; + rayToBps[1000000005944790797564654580] = 2062; + rayToBps[1000000005947419588627077399] = 2063; + rayToBps[1000000005950048161776706909] = 2064; + rayToBps[1000000005952676517049667739] = 2065; + rayToBps[1000000005955304654482075535] = 2066; + rayToBps[1000000005957932574110036965] = 2067; + rayToBps[1000000005960560275969649719] = 2068; + rayToBps[1000000005963187760097002515] = 2069; + rayToBps[1000000005965815026528175101] = 2070; + rayToBps[1000000005968442075299238258] = 2071; + rayToBps[1000000005971068906446253801] = 2072; + rayToBps[1000000005973695520005274585] = 2073; + rayToBps[1000000005976321916012344506] = 2074; + rayToBps[1000000005978948094503498507] = 2075; + rayToBps[1000000005981574055514762574] = 2076; + rayToBps[1000000005984199799082153748] = 2077; + rayToBps[1000000005986825325241680120] = 2078; + rayToBps[1000000005989450634029340842] = 2079; + rayToBps[1000000005992075725481126120] = 2080; + rayToBps[1000000005994700599633017225] = 2081; + rayToBps[1000000005997325256520986496] = 2082; + rayToBps[1000000005999949696180997335] = 2083; + rayToBps[1000000006002573918649004220] = 2084; + rayToBps[1000000006005197923960952699] = 2085; + rayToBps[1000000006007821712152779401] = 2086; + rayToBps[1000000006010445283260412034] = 2087; + rayToBps[1000000006013068637319769388] = 2088; + rayToBps[1000000006015691774366761338] = 2089; + rayToBps[1000000006018314694437288852] = 2090; + rayToBps[1000000006020937397567243987] = 2091; + rayToBps[1000000006023559883792509896] = 2092; + rayToBps[1000000006026182153148960829] = 2093; + rayToBps[1000000006028804205672462137] = 2094; + rayToBps[1000000006031426041398870273] = 2095; + rayToBps[1000000006034047660364032802] = 2096; + rayToBps[1000000006036669062603788392] = 2097; + rayToBps[1000000006039290248153966829] = 2098; + rayToBps[1000000006041911217050389011] = 2099; + rayToBps[1000000006044531969328866955] = 2100; + rayToBps[1000000006047152505025203801] = 2101; + rayToBps[1000000006049772824175193813] = 2102; + rayToBps[1000000006052392926814622379] = 2103; + rayToBps[1000000006055012812979266021] = 2104; + rayToBps[1000000006057632482704892392] = 2105; + rayToBps[1000000006060251936027260282] = 2106; + rayToBps[1000000006062871172982119621] = 2107; + rayToBps[1000000006065490193605211477] = 2108; + rayToBps[1000000006068108997932268067] = 2109; + rayToBps[1000000006070727585999012755] = 2110; + rayToBps[1000000006073345957841160052] = 2111; + rayToBps[1000000006075964113494415626] = 2112; + rayToBps[1000000006078582052994476301] = 2113; + rayToBps[1000000006081199776377030061] = 2114; + rayToBps[1000000006083817283677756050] = 2115; + rayToBps[1000000006086434574932324580] = 2116; + rayToBps[1000000006089051650176397130] = 2117; + rayToBps[1000000006091668509445626349] = 2118; + rayToBps[1000000006094285152775656060] = 2119; + rayToBps[1000000006096901580202121266] = 2120; + rayToBps[1000000006099517791760648147] = 2121; + rayToBps[1000000006102133787486854066] = 2122; + rayToBps[1000000006104749567416347572] = 2123; + rayToBps[1000000006107365131584728403] = 2124; + rayToBps[1000000006109980480027587488] = 2125; + rayToBps[1000000006112595612780506950] = 2126; + rayToBps[1000000006115210529879060111] = 2127; + rayToBps[1000000006117825231358811489] = 2128; + rayToBps[1000000006120439717255316811] = 2129; + rayToBps[1000000006123053987604123006] = 2130; + rayToBps[1000000006125668042440768211] = 2131; + rayToBps[1000000006128281881800781778] = 2132; + rayToBps[1000000006130895505719684273] = 2133; + rayToBps[1000000006133508914232987477] = 2134; + rayToBps[1000000006136122107376194395] = 2135; + rayToBps[1000000006138735085184799252] = 2136; + rayToBps[1000000006141347847694287501] = 2137; + rayToBps[1000000006143960394940135825] = 2138; + rayToBps[1000000006146572726957812137] = 2139; + rayToBps[1000000006149184843782775586] = 2140; + rayToBps[1000000006151796745450476560] = 2141; + rayToBps[1000000006154408431996356685] = 2142; + rayToBps[1000000006157019903455848831] = 2143; + rayToBps[1000000006159631159864377117] = 2144; + rayToBps[1000000006162242201257356911] = 2145; + rayToBps[1000000006164853027670194829] = 2146; + rayToBps[1000000006167463639138288746] = 2147; + rayToBps[1000000006170074035697027796] = 2148; + rayToBps[1000000006172684217381792370] = 2149; + rayToBps[1000000006175294184227954125] = 2150; + rayToBps[1000000006177903936270875985] = 2151; + rayToBps[1000000006180513473545912141] = 2152; + rayToBps[1000000006183122796088408060] = 2153; + rayToBps[1000000006185731903933700483] = 2154; + rayToBps[1000000006188340797117117427] = 2155; + rayToBps[1000000006190949475673978192] = 2156; + rayToBps[1000000006193557939639593360] = 2157; + rayToBps[1000000006196166189049264802] = 2158; + rayToBps[1000000006198774223938285679] = 2159; + rayToBps[1000000006201382044341940442] = 2160; + rayToBps[1000000006203989650295504837] = 2161; + rayToBps[1000000006206597041834245913] = 2162; + rayToBps[1000000006209204218993422012] = 2163; + rayToBps[1000000006211811181808282789] = 2164; + rayToBps[1000000006214417930314069199] = 2165; + rayToBps[1000000006217024464546013508] = 2166; + rayToBps[1000000006219630784539339297] = 2167; + rayToBps[1000000006222236890329261461] = 2168; + rayToBps[1000000006224842781950986211] = 2169; + rayToBps[1000000006227448459439711081] = 2170; + rayToBps[1000000006230053922830624932] = 2171; + rayToBps[1000000006232659172158907945] = 2172; + rayToBps[1000000006235264207459731635] = 2173; + rayToBps[1000000006237869028768258850] = 2174; + rayToBps[1000000006240473636119643770] = 2175; + rayToBps[1000000006243078029549031916] = 2176; + rayToBps[1000000006245682209091560148] = 2177; + rayToBps[1000000006248286174782356672] = 2178; + rayToBps[1000000006250889926656541039] = 2179; + rayToBps[1000000006253493464749224150] = 2180; + rayToBps[1000000006256096789095508257] = 2181; + rayToBps[1000000006258699899730486971] = 2182; + rayToBps[1000000006261302796689245258] = 2183; + rayToBps[1000000006263905480006859443] = 2184; + rayToBps[1000000006266507949718397218] = 2185; + rayToBps[1000000006269110205858917643] = 2186; + rayToBps[1000000006271712248463471143] = 2187; + rayToBps[1000000006274314077567099518] = 2188; + rayToBps[1000000006276915693204835941] = 2189; + rayToBps[1000000006279517095411704965] = 2190; + rayToBps[1000000006282118284222722523] = 2191; + rayToBps[1000000006284719259672895930] = 2192; + rayToBps[1000000006287320021797223891] = 2193; + rayToBps[1000000006289920570630696496] = 2194; + rayToBps[1000000006292520906208295229] = 2195; + rayToBps[1000000006295121028564992969] = 2196; + rayToBps[1000000006297720937735753993] = 2197; + rayToBps[1000000006300320633755533977] = 2198; + rayToBps[1000000006302920116659280001] = 2199; + rayToBps[1000000006305519386481930552] = 2200; + rayToBps[1000000006308118443258415523] = 2201; + rayToBps[1000000006310717287023656222] = 2202; + rayToBps[1000000006313315917812565372] = 2203; + rayToBps[1000000006315914335660047109] = 2204; + rayToBps[1000000006318512540600996994] = 2205; + rayToBps[1000000006321110532670302007] = 2206; + rayToBps[1000000006323708311902840558] = 2207; + rayToBps[1000000006326305878333482482] = 2208; + rayToBps[1000000006328903231997089047] = 2209; + rayToBps[1000000006331500372928512954] = 2210; + rayToBps[1000000006334097301162598344] = 2211; + rayToBps[1000000006336694016734180794] = 2212; + rayToBps[1000000006339290519678087326] = 2213; + rayToBps[1000000006341886810029136408] = 2214; + rayToBps[1000000006344482887822137953] = 2215; + rayToBps[1000000006347078753091893329] = 2216; + rayToBps[1000000006349674405873195356] = 2217; + rayToBps[1000000006352269846200828311] = 2218; + rayToBps[1000000006354865074109567928] = 2219; + rayToBps[1000000006357460089634181406] = 2220; + rayToBps[1000000006360054892809427412] = 2221; + rayToBps[1000000006362649483670056072] = 2222; + rayToBps[1000000006365243862250808991] = 2223; + rayToBps[1000000006367838028586419244] = 2224; + rayToBps[1000000006370431982711611382] = 2225; + rayToBps[1000000006373025724661101435] = 2226; + rayToBps[1000000006375619254469596916] = 2227; + rayToBps[1000000006378212572171796821] = 2228; + rayToBps[1000000006380805677802391636] = 2229; + rayToBps[1000000006383398571396063332] = 2230; + rayToBps[1000000006385991252987485379] = 2231; + rayToBps[1000000006388583722611322739] = 2232; + rayToBps[1000000006391175980302231873] = 2233; + rayToBps[1000000006393768026094860743] = 2234; + rayToBps[1000000006396359860023848818] = 2235; + rayToBps[1000000006398951482123827069] = 2236; + rayToBps[1000000006401542892429417980] = 2237; + rayToBps[1000000006404134090975235547] = 2238; + rayToBps[1000000006406725077795885279] = 2239; + rayToBps[1000000006409315852925964206] = 2240; + rayToBps[1000000006411906416400060876] = 2241; + rayToBps[1000000006414496768252755361] = 2242; + rayToBps[1000000006417086908518619263] = 2243; + rayToBps[1000000006419676837232215707] = 2244; + rayToBps[1000000006422266554428099352] = 2245; + rayToBps[1000000006424856060140816394] = 2246; + rayToBps[1000000006427445354404904564] = 2247; + rayToBps[1000000006430034437254893132] = 2248; + rayToBps[1000000006432623308725302915] = 2249; + rayToBps[1000000006435211968850646270] = 2250; + rayToBps[1000000006437800417665427105] = 2251; + rayToBps[1000000006440388655204140882] = 2252; + rayToBps[1000000006442976681501274614] = 2253; + rayToBps[1000000006445564496591306867] = 2254; + rayToBps[1000000006448152100508707774] = 2255; + rayToBps[1000000006450739493287939023] = 2256; + rayToBps[1000000006453326674963453873] = 2257; + rayToBps[1000000006455913645569697146] = 2258; + rayToBps[1000000006458500405141105236] = 2259; + rayToBps[1000000006461086953712106112] = 2260; + rayToBps[1000000006463673291317119316] = 2261; + rayToBps[1000000006466259417990555969] = 2262; + rayToBps[1000000006468845333766818775] = 2263; + rayToBps[1000000006471431038680302021] = 2264; + rayToBps[1000000006474016532765391581] = 2265; + rayToBps[1000000006476601816056464920] = 2266; + rayToBps[1000000006479186888587891091] = 2267; + rayToBps[1000000006481771750394030749] = 2268; + rayToBps[1000000006484356401509236141] = 2269; + rayToBps[1000000006486940841967851116] = 2270; + rayToBps[1000000006489525071804211128] = 2271; + rayToBps[1000000006492109091052643236] = 2272; + rayToBps[1000000006494692899747466107] = 2273; + rayToBps[1000000006497276497922990021] = 2274; + rayToBps[1000000006499859885613516871] = 2275; + rayToBps[1000000006502443062853340168] = 2276; + rayToBps[1000000006505026029676745041] = 2277; + rayToBps[1000000006507608786118008244] = 2278; + rayToBps[1000000006510191332211398155] = 2279; + rayToBps[1000000006512773667991174779] = 2280; + rayToBps[1000000006515355793491589751] = 2281; + rayToBps[1000000006517937708746886344] = 2282; + rayToBps[1000000006520519413791299462] = 2283; + rayToBps[1000000006523100908659055649] = 2284; + rayToBps[1000000006525682193384373092] = 2285; + rayToBps[1000000006528263268001461622] = 2286; + rayToBps[1000000006530844132544522714] = 2287; + rayToBps[1000000006533424787047749499] = 2288; + rayToBps[1000000006536005231545326753] = 2289; + rayToBps[1000000006538585466071430912] = 2290; + rayToBps[1000000006541165490660230067] = 2291; + rayToBps[1000000006543745305345883975] = 2292; + rayToBps[1000000006546324910162544048] = 2293; + rayToBps[1000000006548904305144353370] = 2294; + rayToBps[1000000006551483490325446691] = 2295; + rayToBps[1000000006554062465739950435] = 2296; + rayToBps[1000000006556641231421982697] = 2297; + rayToBps[1000000006559219787405653252] = 2298; + rayToBps[1000000006561798133725063551] = 2299; + rayToBps[1000000006564376270414306730] = 2300; + rayToBps[1000000006566954197507467608] = 2301; + rayToBps[1000000006569531915038622694] = 2302; + rayToBps[1000000006572109423041840185] = 2303; + rayToBps[1000000006574686721551179973] = 2304; + rayToBps[1000000006577263810600693644] = 2305; + rayToBps[1000000006579840690224424483] = 2306; + rayToBps[1000000006582417360456407476] = 2307; + rayToBps[1000000006584993821330669316] = 2308; + rayToBps[1000000006587570072881228396] = 2309; + rayToBps[1000000006590146115142094824] = 2310; + rayToBps[1000000006592721948147270418] = 2311; + rayToBps[1000000006595297571930748710] = 2312; + rayToBps[1000000006597872986526514949] = 2313; + rayToBps[1000000006600448191968546107] = 2314; + rayToBps[1000000006603023188290810875] = 2315; + rayToBps[1000000006605597975527269671] = 2316; + rayToBps[1000000006608172553711874641] = 2317; + rayToBps[1000000006610746922878569662] = 2318; + rayToBps[1000000006613321083061290345] = 2319; + rayToBps[1000000006615895034293964035] = 2320; + rayToBps[1000000006618468776610509817] = 2321; + rayToBps[1000000006621042310044838519] = 2322; + rayToBps[1000000006623615634630852711] = 2323; + rayToBps[1000000006626188750402446710] = 2324; + rayToBps[1000000006628761657393506584] = 2325; + rayToBps[1000000006631334355637910151] = 2326; + rayToBps[1000000006633906845169526987] = 2327; + rayToBps[1000000006636479126022218423] = 2328; + rayToBps[1000000006639051198229837551] = 2329; + rayToBps[1000000006641623061826229226] = 2330; + rayToBps[1000000006644194716845230068] = 2331; + rayToBps[1000000006646766163320668467] = 2332; + rayToBps[1000000006649337401286364581] = 2333; + rayToBps[1000000006651908430776130344] = 2334; + rayToBps[1000000006654479251823769466] = 2335; + rayToBps[1000000006657049864463077435] = 2336; + rayToBps[1000000006659620268727841521] = 2337; + rayToBps[1000000006662190464651840778] = 2338; + rayToBps[1000000006664760452268846047] = 2339; + rayToBps[1000000006667330231612619959] = 2340; + rayToBps[1000000006669899802716916939] = 2341; + rayToBps[1000000006672469165615483202] = 2342; + rayToBps[1000000006675038320342056763] = 2343; + rayToBps[1000000006677607266930367441] = 2344; + rayToBps[1000000006680176005414136851] = 2345; + rayToBps[1000000006682744535827078420] = 2346; + rayToBps[1000000006685312858202897378] = 2347; + rayToBps[1000000006687880972575290769] = 2348; + rayToBps[1000000006690448878977947450] = 2349; + rayToBps[1000000006693016577444548094] = 2350; + rayToBps[1000000006695584068008765190] = 2351; + rayToBps[1000000006698151350704263054] = 2352; + rayToBps[1000000006700718425564697821] = 2353; + rayToBps[1000000006703285292623717455] = 2354; + rayToBps[1000000006705851951914961750] = 2355; + rayToBps[1000000006708418403472062331] = 2356; + rayToBps[1000000006710984647328642657] = 2357; + rayToBps[1000000006713550683518318027] = 2358; + rayToBps[1000000006716116512074695575] = 2359; + rayToBps[1000000006718682133031374284] = 2360; + rayToBps[1000000006721247546421944976] = 2361; + rayToBps[1000000006723812752279990327] = 2362; + rayToBps[1000000006726377750639084858] = 2363; + rayToBps[1000000006728942541532794947] = 2364; + rayToBps[1000000006731507124994678824] = 2365; + rayToBps[1000000006734071501058286581] = 2366; + rayToBps[1000000006736635669757160171] = 2367; + rayToBps[1000000006739199631124833408] = 2368; + rayToBps[1000000006741763385194831973] = 2369; + rayToBps[1000000006744326932000673419] = 2370; + rayToBps[1000000006746890271575867167] = 2371; + rayToBps[1000000006749453403953914514] = 2372; + rayToBps[1000000006752016329168308632] = 2373; + rayToBps[1000000006754579047252534575] = 2374; + rayToBps[1000000006757141558240069277] = 2375; + rayToBps[1000000006759703862164381559] = 2376; + rayToBps[1000000006762265959058932126] = 2377; + rayToBps[1000000006764827848957173576] = 2378; + rayToBps[1000000006767389531892550399] = 2379; + rayToBps[1000000006769951007898498979] = 2380; + rayToBps[1000000006772512277008447597] = 2381; + rayToBps[1000000006775073339255816438] = 2382; + rayToBps[1000000006777634194674017587] = 2383; + rayToBps[1000000006780194843296455036] = 2384; + rayToBps[1000000006782755285156524684] = 2385; + rayToBps[1000000006785315520287614342] = 2386; + rayToBps[1000000006787875548723103735] = 2387; + rayToBps[1000000006790435370496364503] = 2388; + rayToBps[1000000006792994985640760203] = 2389; + rayToBps[1000000006795554394189646319] = 2390; + rayToBps[1000000006798113596176370253] = 2391; + rayToBps[1000000006800672591634271336] = 2392; + rayToBps[1000000006803231380596680829] = 2393; + rayToBps[1000000006805789963096921922] = 2394; + rayToBps[1000000006808348339168309744] = 2395; + rayToBps[1000000006810906508844151355] = 2396; + rayToBps[1000000006813464472157745761] = 2397; + rayToBps[1000000006816022229142383903] = 2398; + rayToBps[1000000006818579779831348674] = 2399; + rayToBps[1000000006821137124257914908] = 2400; + rayToBps[1000000006823694262455349394] = 2401; + rayToBps[1000000006826251194456910871] = 2402; + rayToBps[1000000006828807920295850033] = 2403; + rayToBps[1000000006831364440005409534] = 2404; + rayToBps[1000000006833920753618823984] = 2405; + rayToBps[1000000006836476861169319962] = 2406; + rayToBps[1000000006839032762690116006] = 2407; + rayToBps[1000000006841588458214422628] = 2408; + rayToBps[1000000006844143947775442306] = 2409; + rayToBps[1000000006846699231406369494] = 2410; + rayToBps[1000000006849254309140390621] = 2411; + rayToBps[1000000006851809181010684095] = 2412; + rayToBps[1000000006854363847050420305] = 2413; + rayToBps[1000000006856918307292761621] = 2414; + rayToBps[1000000006859472561770862405] = 2415; + rayToBps[1000000006862026610517869003] = 2416; + rayToBps[1000000006864580453566919751] = 2417; + rayToBps[1000000006867134090951144986] = 2418; + rayToBps[1000000006869687522703667035] = 2419; + rayToBps[1000000006872240748857600225] = 2420; + rayToBps[1000000006874793769446050889] = 2421; + rayToBps[1000000006877346584502117360] = 2422; + rayToBps[1000000006879899194058889978] = 2423; + rayToBps[1000000006882451598149451095] = 2424; + rayToBps[1000000006885003796806875073] = 2425; + rayToBps[1000000006887555790064228288] = 2426; + rayToBps[1000000006890107577954569136] = 2427; + rayToBps[1000000006892659160510948030] = 2428; + rayToBps[1000000006895210537766407406] = 2429; + rayToBps[1000000006897761709753981726] = 2430; + rayToBps[1000000006900312676506697478] = 2431; + rayToBps[1000000006902863438057573180] = 2432; + rayToBps[1000000006905413994439619383] = 2433; + rayToBps[1000000006907964345685838672] = 2434; + rayToBps[1000000006910514491829225673] = 2435; + rayToBps[1000000006913064432902767049] = 2436; + rayToBps[1000000006915614168939441505] = 2437; + rayToBps[1000000006918163699972219795] = 2438; + rayToBps[1000000006920713026034064718] = 2439; + rayToBps[1000000006923262147157931125] = 2440; + rayToBps[1000000006925811063376765919] = 2441; + rayToBps[1000000006928359774723508058] = 2442; + rayToBps[1000000006930908281231088560] = 2443; + rayToBps[1000000006933456582932430503] = 2444; + rayToBps[1000000006936004679860449027] = 2445; + rayToBps[1000000006938552572048051340] = 2446; + rayToBps[1000000006941100259528136715] = 2447; + rayToBps[1000000006943647742333596500] = 2448; + rayToBps[1000000006946195020497314113] = 2449; + rayToBps[1000000006948742094052165050] = 2450; + rayToBps[1000000006951288963031016884] = 2451; + rayToBps[1000000006953835627466729271] = 2452; + rayToBps[1000000006956382087392153949] = 2453; + rayToBps[1000000006958928342840134742] = 2454; + rayToBps[1000000006961474393843507563] = 2455; + rayToBps[1000000006964020240435100419] = 2456; + rayToBps[1000000006966565882647733404] = 2457; + rayToBps[1000000006969111320514218717] = 2458; + rayToBps[1000000006971656554067360648] = 2459; + rayToBps[1000000006974201583339955595] = 2460; + rayToBps[1000000006976746408364792054] = 2461; + rayToBps[1000000006979291029174650631] = 2462; + rayToBps[1000000006981835445802304040] = 2463; + rayToBps[1000000006984379658280517107] = 2464; + rayToBps[1000000006986923666642046773] = 2465; + rayToBps[1000000006989467470919642091] = 2466; + rayToBps[1000000006992011071146044239] = 2467; + rayToBps[1000000006994554467353986513] = 2468; + rayToBps[1000000006997097659576194335] = 2469; + rayToBps[1000000006999640647845385252] = 2470; + rayToBps[1000000007002183432194268941] = 2471; + rayToBps[1000000007004726012655547211] = 2472; + rayToBps[1000000007007268389261914006] = 2473; + rayToBps[1000000007009810562046055406] = 2474; + rayToBps[1000000007012352531040649627] = 2475; + rayToBps[1000000007014894296278367034] = 2476; + rayToBps[1000000007017435857791870130] = 2477; + rayToBps[1000000007019977215613813568] = 2478; + rayToBps[1000000007022518369776844150] = 2479; + rayToBps[1000000007025059320313600828] = 2480; + rayToBps[1000000007027600067256714710] = 2481; + rayToBps[1000000007030140610638809063] = 2482; + rayToBps[1000000007032680950492499310] = 2483; + rayToBps[1000000007035221086850393037] = 2484; + rayToBps[1000000007037761019745089994] = 2485; + rayToBps[1000000007040300749209182100] = 2486; + rayToBps[1000000007042840275275253441] = 2487; + rayToBps[1000000007045379597975880277] = 2488; + rayToBps[1000000007047918717343631040] = 2489; + rayToBps[1000000007050457633411066343] = 2490; + rayToBps[1000000007052996346210738974] = 2491; + rayToBps[1000000007055534855775193908] = 2492; + rayToBps[1000000007058073162136968298] = 2493; + rayToBps[1000000007060611265328591490] = 2494; + rayToBps[1000000007063149165382585017] = 2495; + rayToBps[1000000007065686862331462604] = 2496; + rayToBps[1000000007068224356207730171] = 2497; + rayToBps[1000000007070761647043885833] = 2498; + rayToBps[1000000007073298734872419909] = 2499; + rayToBps[1000000007075835619725814915] = 2500; + rayToBps[1000000007078372301636545575] = 2501; + rayToBps[1000000007080908780637078819] = 2502; + rayToBps[1000000007083445056759873785] = 2503; + rayToBps[1000000007085981130037381827] = 2504; + rayToBps[1000000007088517000502046507] = 2505; + rayToBps[1000000007091052668186303610] = 2506; + rayToBps[1000000007093588133122581138] = 2507; + rayToBps[1000000007096123395343299315] = 2508; + rayToBps[1000000007098658454880870590] = 2509; + rayToBps[1000000007101193311767699638] = 2510; + rayToBps[1000000007103727966036183363] = 2511; + rayToBps[1000000007106262417718710904] = 2512; + rayToBps[1000000007108796666847663630] = 2513; + rayToBps[1000000007111330713455415150] = 2514; + rayToBps[1000000007113864557574331311] = 2515; + rayToBps[1000000007116398199236770202] = 2516; + rayToBps[1000000007118931638475082158] = 2517; + rayToBps[1000000007121464875321609757] = 2518; + rayToBps[1000000007123997909808687830] = 2519; + rayToBps[1000000007126530741968643458] = 2520; + rayToBps[1000000007129063371833795977] = 2521; + rayToBps[1000000007131595799436456977] = 2522; + rayToBps[1000000007134128024808930311] = 2523; + rayToBps[1000000007136660047983512092] = 2524; + rayToBps[1000000007139191868992490695] = 2525; + rayToBps[1000000007141723487868146766] = 2526; + rayToBps[1000000007144254904642753216] = 2527; + rayToBps[1000000007146786119348575230] = 2528; + rayToBps[1000000007149317132017870265] = 2529; + rayToBps[1000000007151847942682888056] = 2530; + rayToBps[1000000007154378551375870618] = 2531; + rayToBps[1000000007156908958129052243] = 2532; + rayToBps[1000000007159439162974659510] = 2533; + rayToBps[1000000007161969165944911286] = 2534; + rayToBps[1000000007164498967072018724] = 2535; + rayToBps[1000000007167028566388185266] = 2536; + rayToBps[1000000007169557963925606655] = 2537; + rayToBps[1000000007172087159716470922] = 2538; + rayToBps[1000000007174616153792958402] = 2539; + rayToBps[1000000007177144946187241729] = 2540; + rayToBps[1000000007179673536931485840] = 2541; + rayToBps[1000000007182201926057847980] = 2542; + rayToBps[1000000007184730113598477700] = 2543; + rayToBps[1000000007187258099585516865] = 2544; + rayToBps[1000000007189785884051099650] = 2545; + rayToBps[1000000007192313467027352546] = 2546; + rayToBps[1000000007194840848546394365] = 2547; + rayToBps[1000000007197368028640336238] = 2548; + rayToBps[1000000007199895007341281618] = 2549; + rayToBps[1000000007202421784681326287] = 2550; + rayToBps[1000000007204948360692558350] = 2551; + rayToBps[1000000007207474735407058245] = 2552; + rayToBps[1000000007210000908856898746] = 2553; + rayToBps[1000000007212526881074144958] = 2554; + rayToBps[1000000007215052652090854324] = 2555; + rayToBps[1000000007217578221939076629] = 2556; + rayToBps[1000000007220103590650854001] = 2557; + rayToBps[1000000007222628758258220911] = 2558; + rayToBps[1000000007225153724793204178] = 2559; + rayToBps[1000000007227678490287822975] = 2560; + rayToBps[1000000007230203054774088820] = 2561; + rayToBps[1000000007232727418284005593] = 2562; + rayToBps[1000000007235251580849569527] = 2563; + rayToBps[1000000007237775542502769216] = 2564; + rayToBps[1000000007240299303275585616] = 2565; + rayToBps[1000000007242822863199992048] = 2566; + rayToBps[1000000007245346222307954199] = 2567; + rayToBps[1000000007247869380631430127] = 2568; + rayToBps[1000000007250392338202370260] = 2569; + rayToBps[1000000007252915095052717402] = 2570; + rayToBps[1000000007255437651214406734] = 2571; + rayToBps[1000000007257960006719365813] = 2572; + rayToBps[1000000007260482161599514580] = 2573; + rayToBps[1000000007263004115886765361] = 2574; + rayToBps[1000000007265525869613022867] = 2575; + rayToBps[1000000007268047422810184197] = 2576; + rayToBps[1000000007270568775510138843] = 2577; + rayToBps[1000000007273089927744768690] = 2578; + rayToBps[1000000007275610879545948018] = 2579; + rayToBps[1000000007278131630945543509] = 2580; + rayToBps[1000000007280652181975414240] = 2581; + rayToBps[1000000007283172532667411698] = 2582; + rayToBps[1000000007285692683053379771] = 2583; + rayToBps[1000000007288212633165154756] = 2584; + rayToBps[1000000007290732383034565363] = 2585; + rayToBps[1000000007293251932693432712] = 2586; + rayToBps[1000000007295771282173570341] = 2587; + rayToBps[1000000007298290431506784204] = 2588; + rayToBps[1000000007300809380724872677] = 2589; + rayToBps[1000000007303328129859626555] = 2590; + rayToBps[1000000007305846678942829063] = 2591; + rayToBps[1000000007308365028006255850] = 2592; + rayToBps[1000000007310883177081674995] = 2593; + rayToBps[1000000007313401126200847011] = 2594; + rayToBps[1000000007315918875395524846] = 2595; + rayToBps[1000000007318436424697453882] = 2596; + rayToBps[1000000007320953774138371943] = 2597; + rayToBps[1000000007323470923750009295] = 2598; + rayToBps[1000000007325987873564088646] = 2599; + rayToBps[1000000007328504623612325153] = 2600; + rayToBps[1000000007331021173926426421] = 2601; + rayToBps[1000000007333537524538092508] = 2602; + rayToBps[1000000007336053675479015924] = 2603; + rayToBps[1000000007338569626780881634] = 2604; + rayToBps[1000000007341085378475367066] = 2605; + rayToBps[1000000007343600930594142104] = 2606; + rayToBps[1000000007346116283168869100] = 2607; + rayToBps[1000000007348631436231202869] = 2608; + rayToBps[1000000007351146389812790696] = 2609; + rayToBps[1000000007353661143945272335] = 2610; + rayToBps[1000000007356175698660280013] = 2611; + rayToBps[1000000007358690053989438434] = 2612; + rayToBps[1000000007361204209964364778] = 2613; + rayToBps[1000000007363718166616668706] = 2614; + rayToBps[1000000007366231923977952362] = 2615; + rayToBps[1000000007368745482079810375] = 2616; + rayToBps[1000000007371258840953829859] = 2617; + rayToBps[1000000007373772000631590422] = 2618; + rayToBps[1000000007376284961144664159] = 2619; + rayToBps[1000000007378797722524615662] = 2620; + rayToBps[1000000007381310284803002021] = 2621; + rayToBps[1000000007383822648011372824] = 2622; + rayToBps[1000000007386334812181270160] = 2623; + rayToBps[1000000007388846777344228623] = 2624; + rayToBps[1000000007391358543531775311] = 2625; + rayToBps[1000000007393870110775429835] = 2626; + rayToBps[1000000007396381479106704315] = 2627; + rayToBps[1000000007398892648557103381] = 2628; + rayToBps[1000000007401403619158124184] = 2629; + rayToBps[1000000007403914390941256391] = 2630; + rayToBps[1000000007406424963937982190] = 2631; + rayToBps[1000000007408935338179776291] = 2632; + rayToBps[1000000007411445513698105929] = 2633; + rayToBps[1000000007413955490524430869] = 2634; + rayToBps[1000000007416465268690203405] = 2635; + rayToBps[1000000007418974848226868363] = 2636; + rayToBps[1000000007421484229165863101] = 2637; + rayToBps[1000000007423993411538617520] = 2638; + rayToBps[1000000007426502395376554056] = 2639; + rayToBps[1000000007429011180711087689] = 2640; + rayToBps[1000000007431519767573625942] = 2641; + rayToBps[1000000007434028155995568885] = 2642; + rayToBps[1000000007436536346008309136] = 2643; + rayToBps[1000000007439044337643231867] = 2644; + rayToBps[1000000007441552130931714802] = 2645; + rayToBps[1000000007444059725905128218] = 2646; + rayToBps[1000000007446567122594834957] = 2647; + rayToBps[1000000007449074321032190415] = 2648; + rayToBps[1000000007451581321248542554] = 2649; + rayToBps[1000000007454088123275231904] = 2650; + rayToBps[1000000007456594727143591558] = 2651; + rayToBps[1000000007459101132884947181] = 2652; + rayToBps[1000000007461607340530617012] = 2653; + rayToBps[1000000007464113350111911864] = 2654; + rayToBps[1000000007466619161660135123] = 2655; + rayToBps[1000000007469124775206582763] = 2656; + rayToBps[1000000007471630190782543332] = 2657; + rayToBps[1000000007474135408419297966] = 2658; + rayToBps[1000000007476640428148120386] = 2659; + rayToBps[1000000007479145250000276903] = 2660; + rayToBps[1000000007481649874007026420] = 2661; + rayToBps[1000000007484154300199620430] = 2662; + rayToBps[1000000007486658528609303027] = 2663; + rayToBps[1000000007489162559267310898] = 2664; + rayToBps[1000000007491666392204873334] = 2665; + rayToBps[1000000007494170027453212228] = 2666; + rayToBps[1000000007496673465043542080] = 2667; + rayToBps[1000000007499176705007069991] = 2668; + rayToBps[1000000007501679747374995682] = 2669; + rayToBps[1000000007504182592178511478] = 2670; + rayToBps[1000000007506685239448802322] = 2671; + rayToBps[1000000007509187689217045773] = 2672; + rayToBps[1000000007511689941514412011] = 2673; + rayToBps[1000000007514191996372063835] = 2674; + rayToBps[1000000007516693853821156670] = 2675; + rayToBps[1000000007519195513892838566] = 2676; + rayToBps[1000000007521696976618250202] = 2677; + rayToBps[1000000007524198242028524886] = 2678; + rayToBps[1000000007526699310154788564] = 2679; + rayToBps[1000000007529200181028159813] = 2680; + rayToBps[1000000007531700854679749850] = 2681; + rayToBps[1000000007534201331140662531] = 2682; + rayToBps[1000000007536701610441994354] = 2683; + rayToBps[1000000007539201692614834466] = 2684; + rayToBps[1000000007541701577690264654] = 2685; + rayToBps[1000000007544201265699359361] = 2686; + rayToBps[1000000007546700756673185679] = 2687; + rayToBps[1000000007549200050642803353] = 2688; + rayToBps[1000000007551699147639264788] = 2689; + rayToBps[1000000007554198047693615043] = 2690; + rayToBps[1000000007556696750836891842] = 2691; + rayToBps[1000000007559195257100125570] = 2692; + rayToBps[1000000007561693566514339279] = 2693; + rayToBps[1000000007564191679110548687] = 2694; + rayToBps[1000000007566689594919762187] = 2695; + rayToBps[1000000007569187313972980838] = 2696; + rayToBps[1000000007571684836301198378] = 2697; + rayToBps[1000000007574182161935401222] = 2698; + rayToBps[1000000007576679290906568463] = 2699; + rayToBps[1000000007579176223245671878] = 2700; + rayToBps[1000000007581672958983675926] = 2701; + rayToBps[1000000007584169498151537752] = 2702; + rayToBps[1000000007586665840780207194] = 2703; + rayToBps[1000000007589161986900626776] = 2704; + rayToBps[1000000007591657936543731717] = 2705; + rayToBps[1000000007594153689740449933] = 2706; + rayToBps[1000000007596649246521702037] = 2707; + rayToBps[1000000007599144606918401342] = 2708; + rayToBps[1000000007601639770961453862] = 2709; + rayToBps[1000000007604134738681758320] = 2710; + rayToBps[1000000007606629510110206142] = 2711; + rayToBps[1000000007609124085277681464] = 2712; + rayToBps[1000000007611618464215061138] = 2713; + rayToBps[1000000007614112646953214725] = 2714; + rayToBps[1000000007616606633523004503] = 2715; + rayToBps[1000000007619100423955285470] = 2716; + rayToBps[1000000007621594018280905346] = 2717; + rayToBps[1000000007624087416530704571] = 2718; + rayToBps[1000000007626580618735516314] = 2719; + rayToBps[1000000007629073624926166467] = 2720; + rayToBps[1000000007631566435133473656] = 2721; + rayToBps[1000000007634059049388249240] = 2722; + rayToBps[1000000007636551467721297309] = 2723; + rayToBps[1000000007639043690163414692] = 2724; + rayToBps[1000000007641535716745390957] = 2725; + rayToBps[1000000007644027547498008412] = 2726; + rayToBps[1000000007646519182452042112] = 2727; + rayToBps[1000000007649010621638259855] = 2728; + rayToBps[1000000007651501865087422189] = 2729; + rayToBps[1000000007653992912830282410] = 2730; + rayToBps[1000000007656483764897586571] = 2731; + rayToBps[1000000007658974421320073477] = 2732; + rayToBps[1000000007661464882128474691] = 2733; + rayToBps[1000000007663955147353514535] = 2734; + rayToBps[1000000007666445217025910095] = 2735; + rayToBps[1000000007668935091176371220] = 2736; + rayToBps[1000000007671424769835600527] = 2737; + rayToBps[1000000007673914253034293397] = 2738; + rayToBps[1000000007676403540803137988] = 2739; + rayToBps[1000000007678892633172815227] = 2740; + rayToBps[1000000007681381530173998820] = 2741; + rayToBps[1000000007683870231837355249] = 2742; + rayToBps[1000000007686358738193543774] = 2743; + rayToBps[1000000007688847049273216443] = 2744; + rayToBps[1000000007691335165107018082] = 2745; + rayToBps[1000000007693823085725586308] = 2746; + rayToBps[1000000007696310811159551528] = 2747; + rayToBps[1000000007698798341439536935] = 2748; + rayToBps[1000000007701285676596158525] = 2749; + rayToBps[1000000007703772816660025079] = 2750; + rayToBps[1000000007706259761661738185] = 2751; + rayToBps[1000000007708746511631892227] = 2752; + rayToBps[1000000007711233066601074392] = 2753; + rayToBps[1000000007713719426599864675] = 2754; + rayToBps[1000000007716205591658835874] = 2755; + rayToBps[1000000007718691561808553598] = 2756; + rayToBps[1000000007721177337079576270] = 2757; + rayToBps[1000000007723662917502455126] = 2758; + rayToBps[1000000007726148303107734216] = 2759; + rayToBps[1000000007728633493925950409] = 2760; + rayToBps[1000000007731118489987633399] = 2761; + rayToBps[1000000007733603291323305697] = 2762; + rayToBps[1000000007736087897963482645] = 2763; + rayToBps[1000000007738572309938672406] = 2764; + rayToBps[1000000007741056527279375980] = 2765; + rayToBps[1000000007743540550016087193] = 2766; + rayToBps[1000000007746024378179292708] = 2767; + rayToBps[1000000007748508011799472026] = 2768; + rayToBps[1000000007750991450907097483] = 2769; + rayToBps[1000000007753474695532634259] = 2770; + rayToBps[1000000007755957745706540376] = 2771; + rayToBps[1000000007758440601459266700] = 2772; + rayToBps[1000000007760923262821256948] = 2773; + rayToBps[1000000007763405729822947685] = 2774; + rayToBps[1000000007765888002494768329] = 2775; + rayToBps[1000000007768370080867141151] = 2776; + rayToBps[1000000007770851964970481280] = 2777; + rayToBps[1000000007773333654835196703] = 2778; + rayToBps[1000000007775815150491688269] = 2779; + rayToBps[1000000007778296451970349690] = 2780; + rayToBps[1000000007780777559301567543] = 2781; + rayToBps[1000000007783258472515721274] = 2782; + rayToBps[1000000007785739191643183199] = 2783; + rayToBps[1000000007788219716714318505] = 2784; + rayToBps[1000000007790700047759485254] = 2785; + rayToBps[1000000007793180184809034386] = 2786; + rayToBps[1000000007795660127893309718] = 2787; + rayToBps[1000000007798139877042647950] = 2788; + rayToBps[1000000007800619432287378665] = 2789; + rayToBps[1000000007803098793657824331] = 2790; + rayToBps[1000000007805577961184300304] = 2791; + rayToBps[1000000007808056934897114831] = 2792; + rayToBps[1000000007810535714826569051] = 2793; + rayToBps[1000000007813014301002956995] = 2794; + rayToBps[1000000007815492693456565596] = 2795; + rayToBps[1000000007817970892217674682] = 2796; + rayToBps[1000000007820448897316556983] = 2797; + rayToBps[1000000007822926708783478132] = 2798; + rayToBps[1000000007825404326648696672] = 2799; + rayToBps[1000000007827881750942464045] = 2800; + rayToBps[1000000007830358981695024613] = 2801; + rayToBps[1000000007832836018936615642] = 2802; + rayToBps[1000000007835312862697467319] = 2803; + rayToBps[1000000007837789513007802744] = 2804; + rayToBps[1000000007840265969897837937] = 2805; + rayToBps[1000000007842742233397781838] = 2806; + rayToBps[1000000007845218303537836314] = 2807; + rayToBps[1000000007847694180348196153] = 2808; + rayToBps[1000000007850169863859049072] = 2809; + rayToBps[1000000007852645354100575721] = 2810; + rayToBps[1000000007855120651102949679] = 2811; + rayToBps[1000000007857595754896337460] = 2812; + rayToBps[1000000007860070665510898517] = 2813; + rayToBps[1000000007862545382976785237] = 2814; + rayToBps[1000000007865019907324142954] = 2815; + rayToBps[1000000007867494238583109939] = 2816; + rayToBps[1000000007869968376783817414] = 2817; + rayToBps[1000000007872442321956389545] = 2818; + rayToBps[1000000007874916074130943450] = 2819; + rayToBps[1000000007877389633337589198] = 2820; + rayToBps[1000000007879862999606429812] = 2821; + rayToBps[1000000007882336172967561271] = 2822; + rayToBps[1000000007884809153451072514] = 2823; + rayToBps[1000000007887281941087045441] = 2824; + rayToBps[1000000007889754535905554913] = 2825; + rayToBps[1000000007892226937936668759] = 2826; + rayToBps[1000000007894699147210447772] = 2827; + rayToBps[1000000007897171163756945718] = 2828; + rayToBps[1000000007899642987606209333] = 2829; + rayToBps[1000000007902114618788278327] = 2830; + rayToBps[1000000007904586057333185387] = 2831; + rayToBps[1000000007907057303270956176] = 2832; + rayToBps[1000000007909528356631609343] = 2833; + rayToBps[1000000007911999217445156512] = 2834; + rayToBps[1000000007914469885741602299] = 2835; + rayToBps[1000000007916940361550944303] = 2836; + rayToBps[1000000007919410644903173113] = 2837; + rayToBps[1000000007921880735828272312] = 2838; + rayToBps[1000000007924350634356218473] = 2839; + rayToBps[1000000007926820340516981166] = 2840; + rayToBps[1000000007929289854340522961] = 2841; + rayToBps[1000000007931759175856799426] = 2842; + rayToBps[1000000007934228305095759133] = 2843; + rayToBps[1000000007936697242087343656] = 2844; + rayToBps[1000000007939165986861487579] = 2845; + rayToBps[1000000007941634539448118494] = 2846; + rayToBps[1000000007944102899877157001] = 2847; + rayToBps[1000000007946571068178516718] = 2848; + rayToBps[1000000007949039044382104276] = 2849; + rayToBps[1000000007951506828517819323] = 2850; + rayToBps[1000000007953974420615554529] = 2851; + rayToBps[1000000007956441820705195583] = 2852; + rayToBps[1000000007958909028816621201] = 2853; + rayToBps[1000000007961376044979703124] = 2854; + rayToBps[1000000007963842869224306123] = 2855; + rayToBps[1000000007966309501580287995] = 2856; + rayToBps[1000000007968775942077499577] = 2857; + rayToBps[1000000007971242190745784735] = 2858; + rayToBps[1000000007973708247614980375] = 2859; + rayToBps[1000000007976174112714916441] = 2860; + rayToBps[1000000007978639786075415919] = 2861; + rayToBps[1000000007981105267726294840] = 2862; + rayToBps[1000000007983570557697362280] = 2863; + rayToBps[1000000007986035656018420361] = 2864; + rayToBps[1000000007988500562719264258] = 2865; + rayToBps[1000000007990965277829682196] = 2866; + rayToBps[1000000007993429801379455456] = 2867; + rayToBps[1000000007995894133398358376] = 2868; + rayToBps[1000000007998358273916158351] = 2869; + rayToBps[1000000008000822222962615839] = 2870; + rayToBps[1000000008003285980567484358] = 2871; + rayToBps[1000000008005749546760510496] = 2872; + rayToBps[1000000008008212921571433904] = 2873; + rayToBps[1000000008010676105029987304] = 2874; + rayToBps[1000000008013139097165896490] = 2875; + rayToBps[1000000008015601898008880332] = 2876; + rayToBps[1000000008018064507588650772] = 2877; + rayToBps[1000000008020526925934912831] = 2878; + rayToBps[1000000008022989153077364614] = 2879; + rayToBps[1000000008025451189045697303] = 2880; + rayToBps[1000000008027913033869595170] = 2881; + rayToBps[1000000008030374687578735570] = 2882; + rayToBps[1000000008032836150202788948] = 2883; + rayToBps[1000000008035297421771418841] = 2884; + rayToBps[1000000008037758502314281877] = 2885; + rayToBps[1000000008040219391861027783] = 2886; + rayToBps[1000000008042680090441299379] = 2887; + rayToBps[1000000008045140598084732587] = 2888; + rayToBps[1000000008047600914820956433] = 2889; + rayToBps[1000000008050061040679593042] = 2890; + rayToBps[1000000008052520975690257649] = 2891; + rayToBps[1000000008054980719882558595] = 2892; + rayToBps[1000000008057440273286097333] = 2893; + rayToBps[1000000008059899635930468427] = 2894; + rayToBps[1000000008062358807845259556] = 2895; + rayToBps[1000000008064817789060051517] = 2896; + rayToBps[1000000008067276579604418223] = 2897; + rayToBps[1000000008069735179507926713] = 2898; + rayToBps[1000000008072193588800137143] = 2899; + rayToBps[1000000008074651807510602798] = 2900; + rayToBps[1000000008077109835668870091] = 2901; + rayToBps[1000000008079567673304478561] = 2902; + rayToBps[1000000008082025320446960884] = 2903; + rayToBps[1000000008084482777125842863] = 2904; + rayToBps[1000000008086940043370643444] = 2905; + rayToBps[1000000008089397119210874706] = 2906; + rayToBps[1000000008091854004676041869] = 2907; + rayToBps[1000000008094310699795643299] = 2908; + rayToBps[1000000008096767204599170500] = 2909; + rayToBps[1000000008099223519116108130] = 2910; + rayToBps[1000000008101679643375933989] = 2911; + rayToBps[1000000008104135577408119032] = 2912; + rayToBps[1000000008106591321242127364] = 2913; + rayToBps[1000000008109046874907416248] = 2914; + rayToBps[1000000008111502238433436104] = 2915; + rayToBps[1000000008113957411849630507] = 2916; + rayToBps[1000000008116412395185436200] = 2917; + rayToBps[1000000008118867188470283082] = 2918; + rayToBps[1000000008121321791733594224] = 2919; + rayToBps[1000000008123776205004785863] = 2920; + rayToBps[1000000008126230428313267405] = 2921; + rayToBps[1000000008128684461688441426] = 2922; + rayToBps[1000000008131138305159703681] = 2923; + rayToBps[1000000008133591958756443098] = 2924; + rayToBps[1000000008136045422508041783] = 2925; + rayToBps[1000000008138498696443875023] = 2926; + rayToBps[1000000008140951780593311289] = 2927; + rayToBps[1000000008143404674985712235] = 2928; + rayToBps[1000000008145857379650432701] = 2929; + rayToBps[1000000008148309894616820721] = 2930; + rayToBps[1000000008150762219914217511] = 2931; + rayToBps[1000000008153214355571957489] = 2932; + rayToBps[1000000008155666301619368262] = 2933; + rayToBps[1000000008158118058085770639] = 2934; + rayToBps[1000000008160569625000478625] = 2935; + rayToBps[1000000008163021002392799426] = 2936; + rayToBps[1000000008165472190292033455] = 2937; + rayToBps[1000000008167923188727474329] = 2938; + rayToBps[1000000008170373997728408871] = 2939; + rayToBps[1000000008172824617324117117] = 2940; + rayToBps[1000000008175275047543872314] = 2941; + rayToBps[1000000008177725288416940921] = 2942; + rayToBps[1000000008180175339972582615] = 2943; + rayToBps[1000000008182625202240050293] = 2944; + rayToBps[1000000008185074875248590068] = 2945; + rayToBps[1000000008187524359027441281] = 2946; + rayToBps[1000000008189973653605836492] = 2947; + rayToBps[1000000008192422759013001491] = 2948; + rayToBps[1000000008194871675278155297] = 2949; + rayToBps[1000000008197320402430510158] = 2950; + rayToBps[1000000008199768940499271556] = 2951; + rayToBps[1000000008202217289513638208] = 2952; + rayToBps[1000000008204665449502802068] = 2953; + rayToBps[1000000008207113420495948328] = 2954; + rayToBps[1000000008209561202522255424] = 2955; + rayToBps[1000000008212008795610895033] = 2956; + rayToBps[1000000008214456199791032080] = 2957; + rayToBps[1000000008216903415091824734] = 2958; + rayToBps[1000000008219350441542424416] = 2959; + rayToBps[1000000008221797279171975799] = 2960; + rayToBps[1000000008224243928009616809] = 2961; + rayToBps[1000000008226690388084478627] = 2962; + rayToBps[1000000008229136659425685693] = 2963; + rayToBps[1000000008231582742062355709] = 2964; + rayToBps[1000000008234028636023599636] = 2965; + rayToBps[1000000008236474341338521699] = 2966; + rayToBps[1000000008238919858036219393] = 2967; + rayToBps[1000000008241365186145783477] = 2968; + rayToBps[1000000008243810325696297983] = 2969; + rayToBps[1000000008246255276716840215] = 2970; + rayToBps[1000000008248700039236480752] = 2971; + rayToBps[1000000008251144613284283449] = 2972; + rayToBps[1000000008253588998889305439] = 2973; + rayToBps[1000000008256033196080597139] = 2974; + rayToBps[1000000008258477204887202245] = 2975; + rayToBps[1000000008260921025338157740] = 2976; + rayToBps[1000000008263364657462493893] = 2977; + rayToBps[1000000008265808101289234264] = 2978; + rayToBps[1000000008268251356847395701] = 2979; + rayToBps[1000000008270694424165988349] = 2980; + rayToBps[1000000008273137303274015646] = 2981; + rayToBps[1000000008275579994200474327] = 2982; + rayToBps[1000000008278022496974354428] = 2983; + rayToBps[1000000008280464811624639285] = 2984; + rayToBps[1000000008282906938180305537] = 2985; + rayToBps[1000000008285348876670323134] = 2986; + rayToBps[1000000008287790627123655325] = 2987; + rayToBps[1000000008290232189569258676] = 2988; + rayToBps[1000000008292673564036083061] = 2989; + rayToBps[1000000008295114750553071670] = 2990; + rayToBps[1000000008297555749149161005] = 2991; + rayToBps[1000000008299996559853280893] = 2992; + rayToBps[1000000008302437182694354473] = 2993; + rayToBps[1000000008304877617701298212] = 2994; + rayToBps[1000000008307317864903021899] = 2995; + rayToBps[1000000008309757924328428649] = 2996; + rayToBps[1000000008312197796006414905] = 2997; + rayToBps[1000000008314637479965870443] = 2998; + rayToBps[1000000008317076976235678365] = 2999; + rayToBps[1000000008319516284844715115] = 3000; + rayToBps[1000000008321955405821850471] = 3001; + rayToBps[1000000008324394339195947545] = 3002; + rayToBps[1000000008326833084995862796] = 3003; + rayToBps[1000000008329271643250446021] = 3004; + rayToBps[1000000008331710013988540364] = 3005; + rayToBps[1000000008334148197238982316] = 3006; + rayToBps[1000000008336586193030601715] = 3007; + rayToBps[1000000008339024001392221751] = 3008; + rayToBps[1000000008341461622352658967] = 3009; + rayToBps[1000000008343899055940723259] = 3010; + rayToBps[1000000008346336302185217882] = 3011; + rayToBps[1000000008348773361114939450] = 3012; + rayToBps[1000000008351210232758677936] = 3013; + rayToBps[1000000008353646917145216679] = 3014; + rayToBps[1000000008356083414303332380] = 3015; + rayToBps[1000000008358519724261795110] = 3016; + rayToBps[1000000008360955847049368306] = 3017; + rayToBps[1000000008363391782694808779] = 3018; + rayToBps[1000000008365827531226866712] = 3019; + rayToBps[1000000008368263092674285664] = 3020; + rayToBps[1000000008370698467065802570] = 3021; + rayToBps[1000000008373133654430147746] = 3022; + rayToBps[1000000008375568654796044887] = 3023; + rayToBps[1000000008378003468192211075] = 3024; + rayToBps[1000000008380438094647356774] = 3025; + rayToBps[1000000008382872534190185837] = 3026; + rayToBps[1000000008385306786849395508] = 3027; + rayToBps[1000000008387740852653676418] = 3028; + rayToBps[1000000008390174731631712596] = 3029; + rayToBps[1000000008392608423812181466] = 3030; + rayToBps[1000000008395041929223753848] = 3031; + rayToBps[1000000008397475247895093962] = 3032; + rayToBps[1000000008399908379854859430] = 3033; + rayToBps[1000000008402341325131701278] = 3034; + rayToBps[1000000008404774083754263937] = 3035; + rayToBps[1000000008407206655751185247] = 3036; + rayToBps[1000000008409639041151096456] = 3037; + rayToBps[1000000008412071239982622226] = 3038; + rayToBps[1000000008414503252274380631] = 3039; + rayToBps[1000000008416935078054983162] = 3040; + rayToBps[1000000008419366717353034726] = 3041; + rayToBps[1000000008421798170197133652] = 3042; + rayToBps[1000000008424229436615871690] = 3043; + rayToBps[1000000008426660516637834013] = 3044; + rayToBps[1000000008429091410291599222] = 3045; + rayToBps[1000000008431522117605739346] = 3046; + rayToBps[1000000008433952638608819840] = 3047; + rayToBps[1000000008436382973329399595] = 3048; + rayToBps[1000000008438813121796030934] = 3049; + rayToBps[1000000008441243084037259619] = 3050; + rayToBps[1000000008443672860081624846] = 3051; + rayToBps[1000000008446102449957659252] = 3052; + rayToBps[1000000008448531853693888919] = 3053; + rayToBps[1000000008450961071318833369] = 3054; + rayToBps[1000000008453390102861005572] = 3055; + rayToBps[1000000008455818948348911946] = 3056; + rayToBps[1000000008458247607811052360] = 3057; + rayToBps[1000000008460676081275920133] = 3058; + rayToBps[1000000008463104368772002040] = 3059; + rayToBps[1000000008465532470327778310] = 3060; + rayToBps[1000000008467960385971722632] = 3061; + rayToBps[1000000008470388115732302154] = 3062; + rayToBps[1000000008472815659637977489] = 3063; + rayToBps[1000000008475243017717202707] = 3064; + rayToBps[1000000008477670189998425353] = 3065; + rayToBps[1000000008480097176510086432] = 3066; + rayToBps[1000000008482523977280620426] = 3067; + rayToBps[1000000008484950592338455283] = 3068; + rayToBps[1000000008487377021712012431] = 3069; + rayToBps[1000000008489803265429706768] = 3070; + rayToBps[1000000008492229323519946677] = 3071; + rayToBps[1000000008494655196011134014] = 3072; + rayToBps[1000000008497080882931664122] = 3073; + rayToBps[1000000008499506384309925825] = 3074; + rayToBps[1000000008501931700174301437] = 3075; + rayToBps[1000000008504356830553166755] = 3076; + rayToBps[1000000008506781775474891069] = 3077; + rayToBps[1000000008509206534967837162] = 3078; + rayToBps[1000000008511631109060361308] = 3079; + rayToBps[1000000008514055497780813280] = 3080; + rayToBps[1000000008516479701157536348] = 3081; + rayToBps[1000000008518903719218867280] = 3082; + rayToBps[1000000008521327551993136348] = 3083; + rayToBps[1000000008523751199508667330] = 3084; + rayToBps[1000000008526174661793777504] = 3085; + rayToBps[1000000008528597938876777661] = 3086; + rayToBps[1000000008531021030785972101] = 3087; + rayToBps[1000000008533443937549658636] = 3088; + rayToBps[1000000008535866659196128590] = 3089; + rayToBps[1000000008538289195753666803] = 3090; + rayToBps[1000000008540711547250551637] = 3091; + rayToBps[1000000008543133713715054969] = 3092; + rayToBps[1000000008545555695175442199] = 3093; + rayToBps[1000000008547977491659972252] = 3094; + rayToBps[1000000008550399103196897579] = 3095; + rayToBps[1000000008552820529814464158] = 3096; + rayToBps[1000000008555241771540911495] = 3097; + rayToBps[1000000008557662828404472630] = 3098; + rayToBps[1000000008560083700433374138] = 3099; + rayToBps[1000000008562504387655836125] = 3100; + rayToBps[1000000008564924890100072238] = 3101; + rayToBps[1000000008567345207794289664] = 3102; + rayToBps[1000000008569765340766689130] = 3103; + rayToBps[1000000008572185289045464906] = 3104; + rayToBps[1000000008574605052658804811] = 3105; + rayToBps[1000000008577024631634890207] = 3106; + rayToBps[1000000008579444026001896008] = 3107; + rayToBps[1000000008581863235787990679] = 3108; + rayToBps[1000000008584282261021336238] = 3109; + rayToBps[1000000008586701101730088259] = 3110; + rayToBps[1000000008589119757942395872] = 3111; + rayToBps[1000000008591538229686401769] = 3112; + rayToBps[1000000008593956516990242201] = 3113; + rayToBps[1000000008596374619882046982] = 3114; + rayToBps[1000000008598792538389939493] = 3115; + rayToBps[1000000008601210272542036680] = 3116; + rayToBps[1000000008603627822366449059] = 3117; + rayToBps[1000000008606045187891280718] = 3118; + rayToBps[1000000008608462369144629317] = 3119; + rayToBps[1000000008610879366154586092] = 3120; + rayToBps[1000000008613296178949235855] = 3121; + rayToBps[1000000008615712807556656995] = 3122; + rayToBps[1000000008618129252004921486] = 3123; + rayToBps[1000000008620545512322094883] = 3124; + rayToBps[1000000008622961588536236324] = 3125; + rayToBps[1000000008625377480675398538] = 3126; + rayToBps[1000000008627793188767627836] = 3127; + rayToBps[1000000008630208712840964127] = 3128; + rayToBps[1000000008632624052923440907] = 3129; + rayToBps[1000000008635039209043085270] = 3130; + rayToBps[1000000008637454181227917904] = 3131; + rayToBps[1000000008639868969505953098] = 3132; + rayToBps[1000000008642283573905198739] = 3133; + rayToBps[1000000008644697994453656318] = 3134; + rayToBps[1000000008647112231179320929] = 3135; + rayToBps[1000000008649526284110181275] = 3136; + rayToBps[1000000008651940153274219662] = 3137; + rayToBps[1000000008654353838699412010] = 3138; + rayToBps[1000000008656767340413727852] = 3139; + rayToBps[1000000008659180658445130332] = 3140; + rayToBps[1000000008661593792821576212] = 3141; + rayToBps[1000000008664006743571015870] = 3142; + rayToBps[1000000008666419510721393305] = 3143; + rayToBps[1000000008668832094300646140] = 3144; + rayToBps[1000000008671244494336705617] = 3145; + rayToBps[1000000008673656710857496608] = 3146; + rayToBps[1000000008676068743890937609] = 3147; + rayToBps[1000000008678480593464940750] = 3148; + rayToBps[1000000008680892259607411787] = 3149; + rayToBps[1000000008683303742346250114] = 3150; + rayToBps[1000000008685715041709348759] = 3151; + rayToBps[1000000008688126157724594385] = 3152; + rayToBps[1000000008690537090419867299] = 3153; + rayToBps[1000000008692947839823041443] = 3154; + rayToBps[1000000008695358405961984408] = 3155; + rayToBps[1000000008697768788864557426] = 3156; + rayToBps[1000000008700178988558615379] = 3157; + rayToBps[1000000008702589005072006795] = 3158; + rayToBps[1000000008704998838432573855] = 3159; + rayToBps[1000000008707408488668152392] = 3160; + rayToBps[1000000008709817955806571893] = 3161; + rayToBps[1000000008712227239875655502] = 3162; + rayToBps[1000000008714636340903220022] = 3163; + rayToBps[1000000008717045258917075917] = 3164; + rayToBps[1000000008719453993945027311] = 3165; + rayToBps[1000000008721862546014871996] = 3166; + rayToBps[1000000008724270915154401427] = 3167; + rayToBps[1000000008726679101391400728] = 3168; + rayToBps[1000000008729087104753648695] = 3169; + rayToBps[1000000008731494925268917794] = 3170; + rayToBps[1000000008733902562964974164] = 3171; + rayToBps[1000000008736310017869577622] = 3172; + rayToBps[1000000008738717290010481663] = 3173; + rayToBps[1000000008741124379415433461] = 3174; + rayToBps[1000000008743531286112173869] = 3175; + rayToBps[1000000008745938010128437428] = 3176; + rayToBps[1000000008748344551491952362] = 3177; + rayToBps[1000000008750750910230440583] = 3178; + rayToBps[1000000008753157086371617690] = 3179; + rayToBps[1000000008755563079943192978] = 3180; + rayToBps[1000000008757968890972869430] = 3181; + rayToBps[1000000008760374519488343729] = 3182; + rayToBps[1000000008762779965517306250] = 3183; + rayToBps[1000000008765185229087441070] = 3184; + rayToBps[1000000008767590310226425966] = 3185; + rayToBps[1000000008769995208961932417] = 3186; + rayToBps[1000000008772399925321625609] = 3187; + rayToBps[1000000008774804459333164431] = 3188; + rayToBps[1000000008777208811024201482] = 3189; + rayToBps[1000000008779612980422383073] = 3190; + rayToBps[1000000008782016967555349225] = 3191; + rayToBps[1000000008784420772450733672] = 3192; + rayToBps[1000000008786824395136163869] = 3193; + rayToBps[1000000008789227835639260984] = 3194; + rayToBps[1000000008791631093987639905] = 3195; + rayToBps[1000000008794034170208909246] = 3196; + rayToBps[1000000008796437064330671341] = 3197; + rayToBps[1000000008798839776380522251] = 3198; + rayToBps[1000000008801242306386051763] = 3199; + rayToBps[1000000008803644654374843395] = 3200; + rayToBps[1000000008806046820374474396] = 3201; + rayToBps[1000000008808448804412515748] = 3202; + rayToBps[1000000008810850606516532167] = 3203; + rayToBps[1000000008813252226714082106] = 3204; + rayToBps[1000000008815653665032717760] = 3205; + rayToBps[1000000008818054921499985060] = 3206; + rayToBps[1000000008820455996143423684] = 3207; + rayToBps[1000000008822856888990567050] = 3208; + rayToBps[1000000008825257600068942328] = 3209; + rayToBps[1000000008827658129406070432] = 3210; + rayToBps[1000000008830058477029466028] = 3211; + rayToBps[1000000008832458642966637533] = 3212; + rayToBps[1000000008834858627245087117] = 3213; + rayToBps[1000000008837258429892310711] = 3214; + rayToBps[1000000008839658050935797999] = 3215; + rayToBps[1000000008842057490403032425] = 3216; + rayToBps[1000000008844456748321491195] = 3217; + rayToBps[1000000008846855824718645282] = 3218; + rayToBps[1000000008849254719621959420] = 3219; + rayToBps[1000000008851653433058892110] = 3220; + rayToBps[1000000008854051965056895625] = 3221; + rayToBps[1000000008856450315643416008] = 3222; + rayToBps[1000000008858848484845893073] = 3223; + rayToBps[1000000008861246472691760412] = 3224; + rayToBps[1000000008863644279208445392] = 3225; + rayToBps[1000000008866041904423369157] = 3226; + rayToBps[1000000008868439348363946634] = 3227; + rayToBps[1000000008870836611057586530] = 3228; + rayToBps[1000000008873233692531691339] = 3229; + rayToBps[1000000008875630592813657337] = 3230; + rayToBps[1000000008878027311930874594] = 3231; + rayToBps[1000000008880423849910726963] = 3232; + rayToBps[1000000008882820206780592093] = 3233; + rayToBps[1000000008885216382567841425] = 3234; + rayToBps[1000000008887612377299840196] = 3235; + rayToBps[1000000008890008191003947440] = 3236; + rayToBps[1000000008892403823707515991] = 3237; + rayToBps[1000000008894799275437892482] = 3238; + rayToBps[1000000008897194546222417351] = 3239; + rayToBps[1000000008899589636088424841] = 3240; + rayToBps[1000000008901984545063242999] = 3241; + rayToBps[1000000008904379273174193682] = 3242; + rayToBps[1000000008906773820448592561] = 3243; + rayToBps[1000000008909168186913749112] = 3244; + rayToBps[1000000008911562372596966632] = 3245; + rayToBps[1000000008913956377525542231] = 3246; + rayToBps[1000000008916350201726766834] = 3247; + rayToBps[1000000008918743845227925192] = 3248; + rayToBps[1000000008921137308056295874] = 3249; + rayToBps[1000000008923530590239151272] = 3250; + rayToBps[1000000008925923691803757605] = 3251; + rayToBps[1000000008928316612777374918] = 3252; + rayToBps[1000000008930709353187257086] = 3253; + rayToBps[1000000008933101913060651814] = 3254; + rayToBps[1000000008935494292424800641] = 3255; + rayToBps[1000000008937886491306938939] = 3256; + rayToBps[1000000008940278509734295919] = 3257; + rayToBps[1000000008942670347734094627] = 3258; + rayToBps[1000000008945062005333551953] = 3259; + rayToBps[1000000008947453482559878626] = 3260; + rayToBps[1000000008949844779440279220] = 3261; + rayToBps[1000000008952235896001952156] = 3262; + rayToBps[1000000008954626832272089702] = 3263; + rayToBps[1000000008957017588277877973] = 3264; + rayToBps[1000000008959408164046496940] = 3265; + rayToBps[1000000008961798559605120424] = 3266; + rayToBps[1000000008964188774980916101] = 3267; + rayToBps[1000000008966578810201045506] = 3268; + rayToBps[1000000008968968665292664032] = 3269; + rayToBps[1000000008971358340282920931] = 3270; + rayToBps[1000000008973747835198959319] = 3271; + rayToBps[1000000008976137150067916177] = 3272; + rayToBps[1000000008978526284916922351] = 3273; + rayToBps[1000000008980915239773102555] = 3274; + rayToBps[1000000008983304014663575373] = 3275; + rayToBps[1000000008985692609615453262] = 3276; + rayToBps[1000000008988081024655842550] = 3277; + rayToBps[1000000008990469259811843445] = 3278; + rayToBps[1000000008992857315110550026] = 3279; + rayToBps[1000000008995245190579050256] = 3280; + rayToBps[1000000008997632886244425977] = 3281; + rayToBps[1000000009000020402133752914] = 3282; + rayToBps[1000000009002407738274100677] = 3283; + rayToBps[1000000009004794894692532763] = 3284; + rayToBps[1000000009007181871416106556] = 3285; + rayToBps[1000000009009568668471873331] = 3286; + rayToBps[1000000009011955285886878254] = 3287; + rayToBps[1000000009014341723688160386] = 3288; + rayToBps[1000000009016727981902752684] = 3289; + rayToBps[1000000009019114060557682002] = 3290; + rayToBps[1000000009021499959679969092] = 3291; + rayToBps[1000000009023885679296628609] = 3292; + rayToBps[1000000009026271219434669112] = 3293; + rayToBps[1000000009028656580121093060] = 3294; + rayToBps[1000000009031041761382896825] = 3295; + rayToBps[1000000009033426763247070684] = 3296; + rayToBps[1000000009035811585740598824] = 3297; + rayToBps[1000000009038196228890459345] = 3298; + rayToBps[1000000009040580692723624262] = 3299; + rayToBps[1000000009042964977267059505] = 3300; + rayToBps[1000000009045349082547724920] = 3301; + rayToBps[1000000009047733008592574277] = 3302; + rayToBps[1000000009050116755428555263] = 3303; + rayToBps[1000000009052500323082609490] = 3304; + rayToBps[1000000009054883711581672494] = 3305; + rayToBps[1000000009057266920952673739] = 3306; + rayToBps[1000000009059649951222536617] = 3307; + rayToBps[1000000009062032802418178451] = 3308; + rayToBps[1000000009064415474566510497] = 3309; + rayToBps[1000000009066797967694437943] = 3310; + rayToBps[1000000009069180281828859914] = 3311; + rayToBps[1000000009071562416996669472] = 3312; + rayToBps[1000000009073944373224753622] = 3313; + rayToBps[1000000009076326150539993305] = 3314; + rayToBps[1000000009078707748969263409] = 3315; + rayToBps[1000000009081089168539432766] = 3316; + rayToBps[1000000009083470409277364157] = 3317; + rayToBps[1000000009085851471209914307] = 3318; + rayToBps[1000000009088232354363933896] = 3319; + rayToBps[1000000009090613058766267552] = 3320; + rayToBps[1000000009092993584443753863] = 3321; + rayToBps[1000000009095373931423225367] = 3322; + rayToBps[1000000009097754099731508564] = 3323; + rayToBps[1000000009100134089395423911] = 3324; + rayToBps[1000000009102513900441785827] = 3325; + rayToBps[1000000009104893532897402697] = 3326; + rayToBps[1000000009107272986789076865] = 3327; + rayToBps[1000000009109652262143604647] = 3328; + rayToBps[1000000009112031358987776327] = 3329; + rayToBps[1000000009114410277348376157] = 3330; + rayToBps[1000000009116789017252182363] = 3331; + rayToBps[1000000009119167578725967147] = 3332; + rayToBps[1000000009121545961796496682] = 3333; + rayToBps[1000000009123924166490531122] = 3334; + rayToBps[1000000009126302192834824601] = 3335; + rayToBps[1000000009128680040856125232] = 3336; + rayToBps[1000000009131057710581175113] = 3337; + rayToBps[1000000009133435202036710325] = 3338; + rayToBps[1000000009135812515249460939] = 3339; + rayToBps[1000000009138189650246151012] = 3340; + rayToBps[1000000009140566607053498590] = 3341; + rayToBps[1000000009142943385698215714] = 3342; + rayToBps[1000000009145319986207008418] = 3343; + rayToBps[1000000009147696408606576730] = 3344; + rayToBps[1000000009150072652923614679] = 3345; + rayToBps[1000000009152448719184810291] = 3346; + rayToBps[1000000009154824607416845592] = 3347; + rayToBps[1000000009157200317646396614] = 3348; + rayToBps[1000000009159575849900133392] = 3349; + rayToBps[1000000009161951204204719966] = 3350; + rayToBps[1000000009164326380586814388] = 3351; + rayToBps[1000000009166701379073068717] = 3352; + rayToBps[1000000009169076199690129024] = 3353; + rayToBps[1000000009171450842464635396] = 3354; + rayToBps[1000000009173825307423221934] = 3355; + rayToBps[1000000009176199594592516756] = 3356; + rayToBps[1000000009178573703999141999] = 3357; + rayToBps[1000000009180947635669713821] = 3358; + rayToBps[1000000009183321389630842403] = 3359; + rayToBps[1000000009185694965909131953] = 3360; + rayToBps[1000000009188068364531180699] = 3361; + rayToBps[1000000009190441585523580901] = 3362; + rayToBps[1000000009192814628912918850] = 3363; + rayToBps[1000000009195187494725774868] = 3364; + rayToBps[1000000009197560182988723306] = 3365; + rayToBps[1000000009199932693728332556] = 3366; + rayToBps[1000000009202305026971165043] = 3367; + rayToBps[1000000009204677182743777234] = 3368; + rayToBps[1000000009207049161072719633] = 3369; + rayToBps[1000000009209420961984536788] = 3370; + rayToBps[1000000009211792585505767292] = 3371; + rayToBps[1000000009214164031662943783] = 3372; + rayToBps[1000000009216535300482592946] = 3373; + rayToBps[1000000009218906391991235515] = 3374; + rayToBps[1000000009221277306215386279] = 3375; + rayToBps[1000000009223648043181554075] = 3376; + rayToBps[1000000009226018602916241797] = 3377; + rayToBps[1000000009228388985445946397] = 3378; + rayToBps[1000000009230759190797158882] = 3379; + rayToBps[1000000009233129218996364321] = 3380; + rayToBps[1000000009235499070070041847] = 3381; + rayToBps[1000000009237868744044664652] = 3382; + rayToBps[1000000009240238240946699996] = 3383; + rayToBps[1000000009242607560802609207] = 3384; + rayToBps[1000000009244976703638847681] = 3385; + rayToBps[1000000009247345669481864883] = 3386; + rayToBps[1000000009249714458358104354] = 3387; + rayToBps[1000000009252083070294003707] = 3388; + rayToBps[1000000009254451505315994632] = 3389; + rayToBps[1000000009256819763450502896] = 3390; + rayToBps[1000000009259187844723948345] = 3391; + rayToBps[1000000009261555749162744907] = 3392; + rayToBps[1000000009263923476793300595] = 3393; + rayToBps[1000000009266291027642017505] = 3394; + rayToBps[1000000009268658401735291819] = 3395; + rayToBps[1000000009271025599099513809] = 3396; + rayToBps[1000000009273392619761067837] = 3397; + rayToBps[1000000009275759463746332356] = 3398; + rayToBps[1000000009278126131081679912] = 3399; + rayToBps[1000000009280492621793477151] = 3400; + rayToBps[1000000009282858935908084809] = 3401; + rayToBps[1000000009285225073451857728] = 3402; + rayToBps[1000000009287591034451144845] = 3403; + rayToBps[1000000009289956818932289205] = 3404; + rayToBps[1000000009292322426921627953] = 3405; + rayToBps[1000000009294687858445492342] = 3406; + rayToBps[1000000009297053113530207732] = 3407; + rayToBps[1000000009299418192202093592] = 3408; + rayToBps[1000000009301783094487463505] = 3409; + rayToBps[1000000009304147820412625165] = 3410; + rayToBps[1000000009306512370003880380] = 3411; + rayToBps[1000000009308876743287525076] = 3412; + rayToBps[1000000009311240940289849298] = 3413; + rayToBps[1000000009313604961037137210] = 3414; + rayToBps[1000000009315968805555667098] = 3415; + rayToBps[1000000009318332473871711372] = 3416; + rayToBps[1000000009320695966011536564] = 3417; + rayToBps[1000000009323059282001403339] = 3418; + rayToBps[1000000009325422421867566487] = 3419; + rayToBps[1000000009327785385636274930] = 3420; + rayToBps[1000000009330148173333771722] = 3421; + rayToBps[1000000009332510784986294051] = 3422; + rayToBps[1000000009334873220620073239] = 3423; + rayToBps[1000000009337235480261334748] = 3424; + rayToBps[1000000009339597563936298181] = 3425; + rayToBps[1000000009341959471671177278] = 3426; + rayToBps[1000000009344321203492179924] = 3427; + rayToBps[1000000009346682759425508147] = 3428; + rayToBps[1000000009349044139497358124] = 3429; + rayToBps[1000000009351405343733920179] = 3430; + rayToBps[1000000009353766372161378785] = 3431; + rayToBps[1000000009356127224805912567] = 3432; + rayToBps[1000000009358487901693694303] = 3433; + rayToBps[1000000009360848402850890927] = 3434; + rayToBps[1000000009363208728303663528] = 3435; + rayToBps[1000000009365568878078167356] = 3436; + rayToBps[1000000009367928852200551818] = 3437; + rayToBps[1000000009370288650696960487] = 3438; + rayToBps[1000000009372648273593531096] = 3439; + rayToBps[1000000009375007720916395546] = 3440; + rayToBps[1000000009377366992691679904] = 3441; + rayToBps[1000000009379726088945504406] = 3442; + rayToBps[1000000009382085009703983460] = 3443; + rayToBps[1000000009384443754993225643] = 3444; + rayToBps[1000000009386802324839333712] = 3445; + rayToBps[1000000009389160719268404592] = 3446; + rayToBps[1000000009391518938306529393] = 3447; + rayToBps[1000000009393876981979793400] = 3448; + rayToBps[1000000009396234850314276081] = 3449; + rayToBps[1000000009398592543336051086] = 3450; + rayToBps[1000000009400950061071186249] = 3451; + rayToBps[1000000009403307403545743592] = 3452; + rayToBps[1000000009405664570785779323] = 3453; + rayToBps[1000000009408021562817343841] = 3454; + rayToBps[1000000009410378379666481736] = 3455; + rayToBps[1000000009412735021359231792] = 3456; + rayToBps[1000000009415091487921626986] = 3457; + rayToBps[1000000009417447779379694494] = 3458; + rayToBps[1000000009419803895759455687] = 3459; + rayToBps[1000000009422159837086926140] = 3460; + rayToBps[1000000009424515603388115629] = 3461; + rayToBps[1000000009426871194689028130] = 3462; + rayToBps[1000000009429226611015661829] = 3463; + rayToBps[1000000009431581852394009115] = 3464; + rayToBps[1000000009433936918850056588] = 3465; + rayToBps[1000000009436291810409785058] = 3466; + rayToBps[1000000009438646527099169546] = 3467; + rayToBps[1000000009441001068944179290] = 3468; + rayToBps[1000000009443355435970777739] = 3469; + rayToBps[1000000009445709628204922563] = 3470; + rayToBps[1000000009448063645672565649] = 3471; + rayToBps[1000000009450417488399653106] = 3472; + rayToBps[1000000009452771156412125264] = 3473; + rayToBps[1000000009455124649735916678] = 3474; + rayToBps[1000000009457477968396956129] = 3475; + rayToBps[1000000009459831112421166625] = 3476; + rayToBps[1000000009462184081834465404] = 3477; + rayToBps[1000000009464536876662763935] = 3478; + rayToBps[1000000009466889496931967919] = 3479; + rayToBps[1000000009469241942667977291] = 3480; + rayToBps[1000000009471594213896686225] = 3481; + rayToBps[1000000009473946310643983128] = 3482; + rayToBps[1000000009476298232935750651] = 3483; + rayToBps[1000000009478649980797865683] = 3484; + rayToBps[1000000009481001554256199359] = 3485; + rayToBps[1000000009483352953336617058] = 3486; + rayToBps[1000000009485704178064978403] = 3487; + rayToBps[1000000009488055228467137266] = 3488; + rayToBps[1000000009490406104568941771] = 3489; + rayToBps[1000000009492756806396234293] = 3490; + rayToBps[1000000009495107333974851456] = 3491; + rayToBps[1000000009497457687330624144] = 3492; + rayToBps[1000000009499807866489377496] = 3493; + rayToBps[1000000009502157871476930909] = 3494; + rayToBps[1000000009504507702319098038] = 3495; + rayToBps[1000000009506857359041686805] = 3496; + rayToBps[1000000009509206841670499389] = 3497; + rayToBps[1000000009511556150231332239] = 3498; + rayToBps[1000000009513905284749976069] = 3499; + rayToBps[1000000009516254245252215861] = 3500; + rayToBps[1000000009518603031763830869] = 3501; + rayToBps[1000000009520951644310594617] = 3502; + rayToBps[1000000009523300082918274904] = 3503; + rayToBps[1000000009525648347612633803] = 3504; + rayToBps[1000000009527996438419427664] = 3505; + rayToBps[1000000009530344355364407118] = 3506; + rayToBps[1000000009532692098473317073] = 3507; + rayToBps[1000000009535039667771896723] = 3508; + rayToBps[1000000009537387063285879541] = 3509; + rayToBps[1000000009539734285040993291] = 3510; + rayToBps[1000000009542081333062960018] = 3511; + rayToBps[1000000009544428207377496063] = 3512; + rayToBps[1000000009546774908010312050] = 3513; + rayToBps[1000000009549121434987112901] = 3514; + rayToBps[1000000009551467788333597830] = 3515; + rayToBps[1000000009553813968075460344] = 3516; + rayToBps[1000000009556159974238388253] = 3517; + rayToBps[1000000009558505806848063661] = 3518; + rayToBps[1000000009560851465930162975] = 3519; + rayToBps[1000000009563196951510356903] = 3520; + rayToBps[1000000009565542263614310457] = 3521; + rayToBps[1000000009567887402267682959] = 3522; + rayToBps[1000000009570232367496128031] = 3523; + rayToBps[1000000009572577159325293611] = 3524; + rayToBps[1000000009574921777780821942] = 3525; + rayToBps[1000000009577266222888349586] = 3526; + rayToBps[1000000009579610494673507411] = 3527; + rayToBps[1000000009581954593161920610] = 3528; + rayToBps[1000000009584298518379208685] = 3529; + rayToBps[1000000009586642270350985464] = 3530; + rayToBps[1000000009588985849102859090] = 3531; + rayToBps[1000000009591329254660432033] = 3532; + rayToBps[1000000009593672487049301086] = 3533; + rayToBps[1000000009596015546295057365] = 3534; + rayToBps[1000000009598358432423286320] = 3535; + rayToBps[1000000009600701145459567724] = 3536; + rayToBps[1000000009603043685429475683] = 3537; + rayToBps[1000000009605386052358578639] = 3538; + rayToBps[1000000009607728246272439360] = 3539; + rayToBps[1000000009610070267196614960] = 3540; + rayToBps[1000000009612412115156656882] = 3541; + rayToBps[1000000009614753790178110915] = 3542; + rayToBps[1000000009617095292286517185] = 3543; + rayToBps[1000000009619436621507410162] = 3544; + rayToBps[1000000009621777777866318660] = 3545; + rayToBps[1000000009624118761388765837] = 3546; + rayToBps[1000000009626459572100269204] = 3547; + rayToBps[1000000009628800210026340615] = 3548; + rayToBps[1000000009631140675192486280] = 3549; + rayToBps[1000000009633480967624206760] = 3550; + rayToBps[1000000009635821087346996968] = 3551; + rayToBps[1000000009638161034386346176] = 3552; + rayToBps[1000000009640500808767738013] = 3553; + rayToBps[1000000009642840410516650466] = 3554; + rayToBps[1000000009645179839658555885] = 3555; + rayToBps[1000000009647519096218920981] = 3556; + rayToBps[1000000009649858180223206829] = 3557; + rayToBps[1000000009652197091696868873] = 3558; + rayToBps[1000000009654535830665356921] = 3559; + rayToBps[1000000009656874397154115153] = 3560; + rayToBps[1000000009659212791188582117] = 3561; + rayToBps[1000000009661551012794190737] = 3562; + rayToBps[1000000009663889061996368309] = 3563; + rayToBps[1000000009666226938820536506] = 3564; + rayToBps[1000000009668564643292111378] = 3565; + rayToBps[1000000009670902175436503355] = 3566; + rayToBps[1000000009673239535279117247] = 3567; + rayToBps[1000000009675576722845352247] = 3568; + rayToBps[1000000009677913738160601933] = 3569; + rayToBps[1000000009680250581250254266] = 3570; + rayToBps[1000000009682587252139691600] = 3571; + rayToBps[1000000009684923750854290672] = 3572; + rayToBps[1000000009687260077419422613] = 3573; + rayToBps[1000000009689596231860452947] = 3574; + rayToBps[1000000009691932214202741592] = 3575; + rayToBps[1000000009694268024471642861] = 3576; + rayToBps[1000000009696603662692505463] = 3577; + rayToBps[1000000009698939128890672509] = 3578; + rayToBps[1000000009701274423091481510] = 3579; + rayToBps[1000000009703609545320264378] = 3580; + rayToBps[1000000009705944495602347430] = 3581; + rayToBps[1000000009708279273963051388] = 3582; + rayToBps[1000000009710613880427691383] = 3583; + rayToBps[1000000009712948315021576954] = 3584; + rayToBps[1000000009715282577770012051] = 3585; + rayToBps[1000000009717616668698295034] = 3586; + rayToBps[1000000009719950587831718681] = 3587; + rayToBps[1000000009722284335195570182] = 3588; + rayToBps[1000000009724617910815131148] = 3589; + rayToBps[1000000009726951314715677603] = 3590; + rayToBps[1000000009729284546922479998] = 3591; + rayToBps[1000000009731617607460803201] = 3592; + rayToBps[1000000009733950496355906508] = 3593; + rayToBps[1000000009736283213633043637] = 3594; + rayToBps[1000000009738615759317462734] = 3595; + rayToBps[1000000009740948133434406377] = 3596; + rayToBps[1000000009743280336009111568] = 3597; + rayToBps[1000000009745612367066809747] = 3598; + rayToBps[1000000009747944226632726785] = 3599; + rayToBps[1000000009750275914732082986] = 3600; + rayToBps[1000000009752607431390093096] = 3601; + rayToBps[1000000009754938776631966296] = 3602; + rayToBps[1000000009757269950482906208] = 3603; + rayToBps[1000000009759600952968110896] = 3604; + rayToBps[1000000009761931784112772867] = 3605; + rayToBps[1000000009764262443942079074] = 3606; + rayToBps[1000000009766592932481210915] = 3607; + rayToBps[1000000009768923249755344240] = 3608; + rayToBps[1000000009771253395789649342] = 3609; + rayToBps[1000000009773583370609290973] = 3610; + rayToBps[1000000009775913174239428335] = 3611; + rayToBps[1000000009778242806705215085] = 3612; + rayToBps[1000000009780572268031799336] = 3613; + rayToBps[1000000009782901558244323661] = 3614; + rayToBps[1000000009785230677367925089] = 3615; + rayToBps[1000000009787559625427735116] = 3616; + rayToBps[1000000009789888402448879695] = 3617; + rayToBps[1000000009792217008456479248] = 3618; + rayToBps[1000000009794545443475648661] = 3619; + rayToBps[1000000009796873707531497290] = 3620; + rayToBps[1000000009799201800649128958] = 3621; + rayToBps[1000000009801529722853641960] = 3622; + rayToBps[1000000009803857474170129064] = 3623; + rayToBps[1000000009806185054623677514] = 3624; + rayToBps[1000000009808512464239369028] = 3625; + rayToBps[1000000009810839703042279800] = 3626; + rayToBps[1000000009813166771057480507] = 3627; + rayToBps[1000000009815493668310036305] = 3628; + rayToBps[1000000009817820394825006832] = 3629; + rayToBps[1000000009820146950627446211] = 3630; + rayToBps[1000000009822473335742403050] = 3631; + rayToBps[1000000009824799550194920446] = 3632; + rayToBps[1000000009827125594010035982] = 3633; + rayToBps[1000000009829451467212781736] = 3634; + rayToBps[1000000009831777169828184273] = 3635; + rayToBps[1000000009834102701881264655] = 3636; + rayToBps[1000000009836428063397038439] = 3637; + rayToBps[1000000009838753254400515679] = 3638; + rayToBps[1000000009841078274916700926] = 3639; + rayToBps[1000000009843403124970593235] = 3640; + rayToBps[1000000009845727804587186159] = 3641; + rayToBps[1000000009848052313791467756] = 3642; + rayToBps[1000000009850376652608420590] = 3643; + rayToBps[1000000009852700821063021729] = 3644; + rayToBps[1000000009855024819180242754] = 3645; + rayToBps[1000000009857348646985049751] = 3646; + rayToBps[1000000009859672304502403321] = 3647; + rayToBps[1000000009861995791757258575] = 3648; + rayToBps[1000000009864319108774565142] = 3649; + rayToBps[1000000009866642255579267166] = 3650; + rayToBps[1000000009868965232196303308] = 3651; + rayToBps[1000000009871288038650606750] = 3652; + rayToBps[1000000009873610674967105195] = 3653; + rayToBps[1000000009875933141170720867] = 3654; + rayToBps[1000000009878255437286370517] = 3655; + rayToBps[1000000009880577563338965422] = 3656; + rayToBps[1000000009882899519353411383] = 3657; + rayToBps[1000000009885221305354608733] = 3658; + rayToBps[1000000009887542921367452338] = 3659; + rayToBps[1000000009889864367416831591] = 3660; + rayToBps[1000000009892185643527630423] = 3661; + rayToBps[1000000009894506749724727299] = 3662; + rayToBps[1000000009896827686032995223] = 3663; + rayToBps[1000000009899148452477301734] = 3664; + rayToBps[1000000009901469049082508916] = 3665; + rayToBps[1000000009903789475873473393] = 3666; + rayToBps[1000000009906109732875046331] = 3667; + rayToBps[1000000009908429820112073443] = 3668; + rayToBps[1000000009910749737609394990] = 3669; + rayToBps[1000000009913069485391845778] = 3670; + rayToBps[1000000009915389063484255166] = 3671; + rayToBps[1000000009917708471911447063] = 3672; + rayToBps[1000000009920027710698239932] = 3673; + rayToBps[1000000009922346779869446790] = 3674; + rayToBps[1000000009924665679449875210] = 3675; + rayToBps[1000000009926984409464327325] = 3676; + rayToBps[1000000009929302969937599826] = 3677; + rayToBps[1000000009931621360894483965] = 3678; + rayToBps[1000000009933939582359765557] = 3679; + rayToBps[1000000009936257634358224982] = 3680; + rayToBps[1000000009938575516914637184] = 3681; + rayToBps[1000000009940893230053771678] = 3682; + rayToBps[1000000009943210773800392543] = 3683; + rayToBps[1000000009945528148179258435] = 3684; + rayToBps[1000000009947845353215122576] = 3685; + rayToBps[1000000009950162388932732765] = 3686; + rayToBps[1000000009952479255356831378] = 3687; + rayToBps[1000000009954795952512155365] = 3688; + rayToBps[1000000009957112480423436255] = 3689; + rayToBps[1000000009959428839115400159] = 3690; + rayToBps[1000000009961745028612767768] = 3691; + rayToBps[1000000009964061048940254356] = 3692; + rayToBps[1000000009966376900122569785] = 3693; + rayToBps[1000000009968692582184418500] = 3694; + rayToBps[1000000009971008095150499537] = 3695; + rayToBps[1000000009973323439045506518] = 3696; + rayToBps[1000000009975638613894127660] = 3697; + rayToBps[1000000009977953619721045772] = 3698; + rayToBps[1000000009980268456550938255] = 3699; + rayToBps[1000000009982583124408477109] = 3700; + rayToBps[1000000009984897623318328929] = 3701; + rayToBps[1000000009987211953305154911] = 3702; + rayToBps[1000000009989526114393610852] = 3703; + rayToBps[1000000009991840106608347149] = 3704; + rayToBps[1000000009994153929974008806] = 3705; + rayToBps[1000000009996467584515235430] = 3706; + rayToBps[1000000009998781070256661235] = 3707; + rayToBps[1000000010001094387222915045] = 3708; + rayToBps[1000000010003407535438620294] = 3709; + rayToBps[1000000010005720514928395027] = 3710; + rayToBps[1000000010008033325716851902] = 3711; + rayToBps[1000000010010345967828598194] = 3712; + rayToBps[1000000010012658441288235791] = 3713; + rayToBps[1000000010014970746120361202] = 3714; + rayToBps[1000000010017282882349565556] = 3715; + rayToBps[1000000010019594850000434599] = 3716; + rayToBps[1000000010021906649097548706] = 3717; + rayToBps[1000000010024218279665482869] = 3718; + rayToBps[1000000010026529741728806711] = 3719; + rayToBps[1000000010028841035312084483] = 3720; + rayToBps[1000000010031152160439875061] = 3721; + rayToBps[1000000010033463117136731955] = 3722; + rayToBps[1000000010035773905427203304] = 3723; + rayToBps[1000000010038084525335831885] = 3724; + rayToBps[1000000010040394976887155106] = 3725; + rayToBps[1000000010042705260105705014] = 3726; + rayToBps[1000000010045015375016008294] = 3727; + rayToBps[1000000010047325321642586271] = 3728; + rayToBps[1000000010049635100009954912] = 3729; + rayToBps[1000000010051944710142624825] = 3730; + rayToBps[1000000010054254152065101266] = 3731; + rayToBps[1000000010056563425801884135] = 3732; + rayToBps[1000000010058872531377467979] = 3733; + rayToBps[1000000010061181468816341997] = 3734; + rayToBps[1000000010063490238142990036] = 3735; + rayToBps[1000000010065798839381890598] = 3736; + rayToBps[1000000010068107272557516837] = 3737; + rayToBps[1000000010070415537694336563] = 3738; + rayToBps[1000000010072723634816812244] = 3739; + rayToBps[1000000010075031563949401005] = 3740; + rayToBps[1000000010077339325116554633] = 3741; + rayToBps[1000000010079646918342719577] = 3742; + rayToBps[1000000010081954343652336947] = 3743; + rayToBps[1000000010084261601069842519] = 3744; + rayToBps[1000000010086568690619666737] = 3745; + rayToBps[1000000010088875612326234711] = 3746; + rayToBps[1000000010091182366213966220] = 3747; + rayToBps[1000000010093488952307275716] = 3748; + rayToBps[1000000010095795370630572323] = 3749; + rayToBps[1000000010098101621208259840] = 3750; + rayToBps[1000000010100407704064736739] = 3751; + rayToBps[1000000010102713619224396172] = 3752; + rayToBps[1000000010105019366711625969] = 3753; + rayToBps[1000000010107324946550808639] = 3754; + rayToBps[1000000010109630358766321376] = 3755; + rayToBps[1000000010111935603382536054] = 3756; + rayToBps[1000000010114240680423819234] = 3757; + rayToBps[1000000010116545589914532164] = 3758; + rayToBps[1000000010118850331879030779] = 3759; + rayToBps[1000000010121154906341665703] = 3760; + rayToBps[1000000010123459313326782253] = 3761; + rayToBps[1000000010125763552858720438] = 3762; + rayToBps[1000000010128067624961814960] = 3763; + rayToBps[1000000010130371529660395218] = 3764; + rayToBps[1000000010132675266978785311] = 3765; + rayToBps[1000000010134978836941304031] = 3766; + rayToBps[1000000010137282239572264876] = 3767; + rayToBps[1000000010139585474895976041] = 3768; + rayToBps[1000000010141888542936740429] = 3769; + rayToBps[1000000010144191443718855647] = 3770; + rayToBps[1000000010146494177266614006] = 3771; + rayToBps[1000000010148796743604302527] = 3772; + rayToBps[1000000010151099142756202942] = 3773; + rayToBps[1000000010153401374746591692] = 3774; + rayToBps[1000000010155703439599739931] = 3775; + rayToBps[1000000010158005337339913529] = 3776; + rayToBps[1000000010160307067991373070] = 3777; + rayToBps[1000000010162608631578373856] = 3778; + rayToBps[1000000010164910028125165907] = 3779; + rayToBps[1000000010167211257655993967] = 3780; + rayToBps[1000000010169512320195097496] = 3781; + rayToBps[1000000010171813215766710684] = 3782; + rayToBps[1000000010174113944395062439] = 3783; + rayToBps[1000000010176414506104376402] = 3784; + rayToBps[1000000010178714900918870939] = 3785; + rayToBps[1000000010181015128862759145] = 3786; + rayToBps[1000000010183315189960248848] = 3787; + rayToBps[1000000010185615084235542606] = 3788; + rayToBps[1000000010187914811712837715] = 3789; + rayToBps[1000000010190214372416326204] = 3790; + rayToBps[1000000010192513766370194839] = 3791; + rayToBps[1000000010194812993598625127] = 3792; + rayToBps[1000000010197112054125793313] = 3793; + rayToBps[1000000010199410947975870385] = 3794; + rayToBps[1000000010201709675173022073] = 3795; + rayToBps[1000000010204008235741408855] = 3796; + rayToBps[1000000010206306629705185952] = 3797; + rayToBps[1000000010208604857088503334] = 3798; + rayToBps[1000000010210902917915505722] = 3799; + rayToBps[1000000010213200812210332586] = 3800; + rayToBps[1000000010215498539997118147] = 3801; + rayToBps[1000000010217796101299991387] = 3802; + rayToBps[1000000010220093496143076034] = 3803; + rayToBps[1000000010222390724550490579] = 3804; + rayToBps[1000000010224687786546348272] = 3805; + rayToBps[1000000010226984682154757119] = 3806; + rayToBps[1000000010229281411399819892] = 3807; + rayToBps[1000000010231577974305634122] = 3808; + rayToBps[1000000010233874370896292108] = 3809; + rayToBps[1000000010236170601195880913] = 3810; + rayToBps[1000000010238466665228482369] = 3811; + rayToBps[1000000010240762563018173077] = 3812; + rayToBps[1000000010243058294589024407] = 3813; + rayToBps[1000000010245353859965102504] = 3814; + rayToBps[1000000010247649259170468285] = 3815; + rayToBps[1000000010249944492229177442] = 3816; + rayToBps[1000000010252239559165280445] = 3817; + rayToBps[1000000010254534460002822540] = 3818; + rayToBps[1000000010256829194765843755] = 3819; + rayToBps[1000000010259123763478378900] = 3820; + rayToBps[1000000010261418166164457564] = 3821; + rayToBps[1000000010263712402848104124] = 3822; + rayToBps[1000000010266006473553337741] = 3823; + rayToBps[1000000010268300378304172365] = 3824; + rayToBps[1000000010270594117124616733] = 3825; + rayToBps[1000000010272887690038674371] = 3826; + rayToBps[1000000010275181097070343602] = 3827; + rayToBps[1000000010277474338243617536] = 3828; + rayToBps[1000000010279767413582484084] = 3829; + rayToBps[1000000010282060323110925948] = 3830; + rayToBps[1000000010284353066852920632] = 3831; + rayToBps[1000000010286645644832440436] = 3832; + rayToBps[1000000010288938057073452464] = 3833; + rayToBps[1000000010291230303599918619] = 3834; + rayToBps[1000000010293522384435795611] = 3835; + rayToBps[1000000010295814299605034955] = 3836; + rayToBps[1000000010298106049131582970] = 3837; + rayToBps[1000000010300397633039380787] = 3838; + rayToBps[1000000010302689051352364343] = 3839; + rayToBps[1000000010304980304094464392] = 3840; + rayToBps[1000000010307271391289606494] = 3841; + rayToBps[1000000010309562312961711031] = 3842; + rayToBps[1000000010311853069134693193] = 3843; + rayToBps[1000000010314143659832462993] = 3844; + rayToBps[1000000010316434085078925260] = 3845; + rayToBps[1000000010318724344897979646] = 3846; + rayToBps[1000000010321014439313520622] = 3847; + rayToBps[1000000010323304368349437485] = 3848; + rayToBps[1000000010325594132029614354] = 3849; + rayToBps[1000000010327883730377930177] = 3850; + rayToBps[1000000010330173163418258729] = 3851; + rayToBps[1000000010332462431174468613] = 3852; + rayToBps[1000000010334751533670423264] = 3853; + rayToBps[1000000010337040470929980950] = 3854; + rayToBps[1000000010339329242976994772] = 3855; + rayToBps[1000000010341617849835312667] = 3856; + rayToBps[1000000010343906291528777406] = 3857; + rayToBps[1000000010346194568081226603] = 3858; + rayToBps[1000000010348482679516492707] = 3859; + rayToBps[1000000010350770625858403013] = 3860; + rayToBps[1000000010353058407130779655] = 3861; + rayToBps[1000000010355346023357439613] = 3862; + rayToBps[1000000010357633474562194712] = 3863; + rayToBps[1000000010359920760768851624] = 3864; + rayToBps[1000000010362207882001211872] = 3865; + rayToBps[1000000010364494838283071825] = 3866; + rayToBps[1000000010366781629638222707] = 3867; + rayToBps[1000000010369068256090450597] = 3868; + rayToBps[1000000010371354717663536422] = 3869; + rayToBps[1000000010373641014381255972] = 3870; + rayToBps[1000000010375927146267379890] = 3871; + rayToBps[1000000010378213113345673681] = 3872; + rayToBps[1000000010380498915639897708] = 3873; + rayToBps[1000000010382784553173807199] = 3874; + rayToBps[1000000010385070025971152244] = 3875; + rayToBps[1000000010387355334055677797] = 3876; + rayToBps[1000000010389640477451123680] = 3877; + rayToBps[1000000010391925456181224583] = 3878; + rayToBps[1000000010394210270269710063] = 3879; + rayToBps[1000000010396494919740304554] = 3880; + rayToBps[1000000010398779404616727355] = 3881; + rayToBps[1000000010401063724922692643] = 3882; + rayToBps[1000000010403347880681909471] = 3883; + rayToBps[1000000010405631871918081767] = 3884; + rayToBps[1000000010407915698654908337] = 3885; + rayToBps[1000000010410199360916082867] = 3886; + rayToBps[1000000010412482858725293929] = 3887; + rayToBps[1000000010414766192106224969] = 3888; + rayToBps[1000000010417049361082554324] = 3889; + rayToBps[1000000010419332365677955216] = 3890; + rayToBps[1000000010421615205916095750] = 3891; + rayToBps[1000000010423897881820638924] = 3892; + rayToBps[1000000010426180393415242626] = 3893; + rayToBps[1000000010428462740723559632] = 3894; + rayToBps[1000000010430744923769237614] = 3895; + rayToBps[1000000010433026942575919138] = 3896; + rayToBps[1000000010435308797167241666] = 3897; + rayToBps[1000000010437590487566837557] = 3898; + rayToBps[1000000010439872013798334068] = 3899; + rayToBps[1000000010442153375885353361] = 3900; + rayToBps[1000000010444434573851512493] = 3901; + rayToBps[1000000010446715607720423430] = 3902; + rayToBps[1000000010448996477515693040] = 3903; + rayToBps[1000000010451277183260923098] = 3904; + rayToBps[1000000010453557724979710285] = 3905; + rayToBps[1000000010455838102695646196] = 3906; + rayToBps[1000000010458118316432317331] = 3907; + rayToBps[1000000010460398366213305107] = 3908; + rayToBps[1000000010462678252062185850] = 3909; + rayToBps[1000000010464957974002530804] = 3910; + rayToBps[1000000010467237532057906130] = 3911; + rayToBps[1000000010469516926251872906] = 3912; + rayToBps[1000000010471796156607987127] = 3913; + rayToBps[1000000010474075223149799712] = 3914; + rayToBps[1000000010476354125900856503] = 3915; + rayToBps[1000000010478632864884698262] = 3916; + rayToBps[1000000010480911440124860682] = 3917; + rayToBps[1000000010483189851644874376] = 3918; + rayToBps[1000000010485468099468264892] = 3919; + rayToBps[1000000010487746183618552701] = 3920; + rayToBps[1000000010490024104119253210] = 3921; + rayToBps[1000000010492301860993876758] = 3922; + rayToBps[1000000010494579454265928614] = 3923; + rayToBps[1000000010496856883958908988] = 3924; + rayToBps[1000000010499134150096313024] = 3925; + rayToBps[1000000010501411252701630804] = 3926; + rayToBps[1000000010503688191798347350] = 3927; + rayToBps[1000000010505964967409942629] = 3928; + rayToBps[1000000010508241579559891545] = 3929; + rayToBps[1000000010510518028271663949] = 3930; + rayToBps[1000000010512794313568724638] = 3931; + rayToBps[1000000010515070435474533356] = 3932; + rayToBps[1000000010517346394012544796] = 3933; + rayToBps[1000000010519622189206208597] = 3934; + rayToBps[1000000010521897821078969357] = 3935; + rayToBps[1000000010524173289654266619] = 3936; + rayToBps[1000000010526448594955534886] = 3937; + rayToBps[1000000010528723737006203614] = 3938; + rayToBps[1000000010530998715829697217] = 3939; + rayToBps[1000000010533273531449435067] = 3940; + rayToBps[1000000010535548183888831498] = 3941; + rayToBps[1000000010537822673171295805] = 3942; + rayToBps[1000000010540096999320232244] = 3943; + rayToBps[1000000010542371162359040036] = 3944; + rayToBps[1000000010544645162311113372] = 3945; + rayToBps[1000000010546918999199841404] = 3946; + rayToBps[1000000010549192673048608259] = 3947; + rayToBps[1000000010551466183880793029] = 3948; + rayToBps[1000000010553739531719769780] = 3949; + rayToBps[1000000010556012716588907553] = 3950; + rayToBps[1000000010558285738511570360] = 3951; + rayToBps[1000000010560558597511117192] = 3952; + rayToBps[1000000010562831293610902015] = 3953; + rayToBps[1000000010565103826834273775] = 3954; + rayToBps[1000000010567376197204576401] = 3955; + rayToBps[1000000010569648404745148797] = 3956; + rayToBps[1000000010571920449479324858] = 3957; + rayToBps[1000000010574192331430433458] = 3958; + rayToBps[1000000010576464050621798460] = 3959; + rayToBps[1000000010578735607076738714] = 3960; + rayToBps[1000000010581007000818568058] = 3961; + rayToBps[1000000010583278231870595322] = 3962; + rayToBps[1000000010585549300256124326] = 3963; + rayToBps[1000000010587820205998453884] = 3964; + rayToBps[1000000010590090949120877806] = 3965; + rayToBps[1000000010592361529646684896] = 3966; + rayToBps[1000000010594631947599158957] = 3967; + rayToBps[1000000010596902203001578791] = 3968; + rayToBps[1000000010599172295877218198] = 3969; + rayToBps[1000000010601442226249345986] = 3970; + rayToBps[1000000010603711994141225957] = 3971; + rayToBps[1000000010605981599576116928] = 3972; + rayToBps[1000000010608251042577272714] = 3973; + rayToBps[1000000010610520323167942140] = 3974; + rayToBps[1000000010612789441371369043] = 3975; + rayToBps[1000000010615058397210792268] = 3976; + rayToBps[1000000010617327190709445671] = 3977; + rayToBps[1000000010619595821890558121] = 3978; + rayToBps[1000000010621864290777353506] = 3979; + rayToBps[1000000010624132597393050726] = 3980; + rayToBps[1000000010626400741760863700] = 3981; + rayToBps[1000000010628668723904001364] = 3982; + rayToBps[1000000010630936543845667679] = 3983; + rayToBps[1000000010633204201609061622] = 3984; + rayToBps[1000000010635471697217377200] = 3985; + rayToBps[1000000010637739030693803438] = 3986; + rayToBps[1000000010640006202061524391] = 3987; + rayToBps[1000000010642273211343719142] = 3988; + rayToBps[1000000010644540058563561801] = 3989; + rayToBps[1000000010646806743744221508] = 3990; + rayToBps[1000000010649073266908862437] = 3991; + rayToBps[1000000010651339628080643794] = 3992; + rayToBps[1000000010653605827282719820] = 3993; + rayToBps[1000000010655871864538239791] = 3994; + rayToBps[1000000010658137739870348023] = 3995; + rayToBps[1000000010660403453302183867] = 3996; + rayToBps[1000000010662669004856881719] = 3997; + rayToBps[1000000010664934394557571013] = 3998; + rayToBps[1000000010667199622427376228] = 3999; + rayToBps[1000000010669464688489416886] = 4000; + rayToBps[1000000010671729592766807558] = 4001; + rayToBps[1000000010673994335282657858] = 4002; + rayToBps[1000000010676258916060072453] = 4003; + rayToBps[1000000010678523335122151059] = 4004; + rayToBps[1000000010680787592491988442] = 4005; + rayToBps[1000000010683051688192674423] = 4006; + rayToBps[1000000010685315622247293876] = 4007; + rayToBps[1000000010687579394678926732] = 4008; + rayToBps[1000000010689843005510647981] = 4009; + rayToBps[1000000010692106454765527665] = 4010; + rayToBps[1000000010694369742466630895] = 4011; + rayToBps[1000000010696632868637017837] = 4012; + rayToBps[1000000010698895833299743723] = 4013; + rayToBps[1000000010701158636477858849] = 4014; + rayToBps[1000000010703421278194408576] = 4015; + rayToBps[1000000010705683758472433332] = 4016; + rayToBps[1000000010707946077334968615] = 4017; + rayToBps[1000000010710208234805044991] = 4018; + rayToBps[1000000010712470230905688100] = 4019; + rayToBps[1000000010714732065659918652] = 4020; + rayToBps[1000000010716993739090752433] = 4021; + rayToBps[1000000010719255251221200304] = 4022; + rayToBps[1000000010721516602074268204] = 4023; + rayToBps[1000000010723777791672957148] = 4024; + rayToBps[1000000010726038820040263233] = 4025; + rayToBps[1000000010728299687199177636] = 4026; + rayToBps[1000000010730560393172686618] = 4027; + rayToBps[1000000010732820937983771524] = 4028; + rayToBps[1000000010735081321655408782] = 4029; + rayToBps[1000000010737341544210569909] = 4030; + rayToBps[1000000010739601605672221510] = 4031; + rayToBps[1000000010741861506063325280] = 4032; + rayToBps[1000000010744121245406838002] = 4033; + rayToBps[1000000010746380823725711557] = 4034; + rayToBps[1000000010748640241042892914] = 4035; + rayToBps[1000000010750899497381324142] = 4036; + rayToBps[1000000010753158592763942403] = 4037; + rayToBps[1000000010755417527213679959] = 4038; + rayToBps[1000000010757676300753464170] = 4039; + rayToBps[1000000010759934913406217501] = 4040; + rayToBps[1000000010762193365194857512] = 4041; + rayToBps[1000000010764451656142296872] = 4042; + rayToBps[1000000010766709786271443355] = 4043; + rayToBps[1000000010768967755605199839] = 4044; + rayToBps[1000000010771225564166464310] = 4045; + rayToBps[1000000010773483211978129865] = 4046; + rayToBps[1000000010775740699063084710] = 4047; + rayToBps[1000000010777998025444212163] = 4048; + rayToBps[1000000010780255191144390658] = 4049; + rayToBps[1000000010782512196186493739] = 4050; + rayToBps[1000000010784769040593390070] = 4051; + rayToBps[1000000010787025724387943431] = 4052; + rayToBps[1000000010789282247593012723] = 4053; + rayToBps[1000000010791538610231451963] = 4054; + rayToBps[1000000010793794812326110293] = 4055; + rayToBps[1000000010796050853899831977] = 4056; + rayToBps[1000000010798306734975456405] = 4057; + rayToBps[1000000010800562455575818091] = 4058; + rayToBps[1000000010802818015723746677] = 4059; + rayToBps[1000000010805073415442066933] = 4060; + rayToBps[1000000010807328654753598760] = 4061; + rayToBps[1000000010809583733681157190] = 4062; + rayToBps[1000000010811838652247552387] = 4063; + rayToBps[1000000010814093410475589652] = 4064; + rayToBps[1000000010816348008388069418] = 4065; + rayToBps[1000000010818602446007787257] = 4066; + rayToBps[1000000010820856723357533878] = 4067; + rayToBps[1000000010823110840460095130] = 4068; + rayToBps[1000000010825364797338252005] = 4069; + rayToBps[1000000010827618594014780637] = 4070; + rayToBps[1000000010829872230512452300] = 4071; + rayToBps[1000000010832125706854033418] = 4072; + rayToBps[1000000010834379023062285559] = 4073; + rayToBps[1000000010836632179159965442] = 4074; + rayToBps[1000000010838885175169824929] = 4075; + rayToBps[1000000010841138011114611041] = 4076; + rayToBps[1000000010843390687017065944] = 4077; + rayToBps[1000000010845643202899926963] = 4078; + rayToBps[1000000010847895558785926572] = 4079; + rayToBps[1000000010850147754697792408] = 4080; + rayToBps[1000000010852399790658247262] = 4081; + rayToBps[1000000010854651666690009082] = 4082; + rayToBps[1000000010856903382815790981] = 4083; + rayToBps[1000000010859154939058301230] = 4084; + rayToBps[1000000010861406335440243265] = 4085; + rayToBps[1000000010863657571984315686] = 4086; + rayToBps[1000000010865908648713212260] = 4087; + rayToBps[1000000010868159565649621919] = 4088; + rayToBps[1000000010870410322816228766] = 4089; + rayToBps[1000000010872660920235712071] = 4090; + rayToBps[1000000010874911357930746279] = 4091; + rayToBps[1000000010877161635924001006] = 4092; + rayToBps[1000000010879411754238141040] = 4093; + rayToBps[1000000010881661712895826350] = 4094; + rayToBps[1000000010883911511919712075] = 4095; + rayToBps[1000000010886161151332448538] = 4096; + rayToBps[1000000010888410631156681239] = 4097; + rayToBps[1000000010890659951415050857] = 4098; + rayToBps[1000000010892909112130193257] = 4099; + rayToBps[1000000010895158113324739488] = 4100; + rayToBps[1000000010897406955021315779] = 4101; + rayToBps[1000000010899655637242543550] = 4102; + rayToBps[1000000010901904160011039408] = 4103; + rayToBps[1000000010904152523349415148] = 4104; + rayToBps[1000000010906400727280277756] = 4105; + rayToBps[1000000010908648771826229410] = 4106; + rayToBps[1000000010910896657009867483] = 4107; + rayToBps[1000000010913144382853784538] = 4108; + rayToBps[1000000010915391949380568338] = 4109; + rayToBps[1000000010917639356612801842] = 4110; + rayToBps[1000000010919886604573063209] = 4111; + rayToBps[1000000010922133693283925795] = 4112; + rayToBps[1000000010924380622767958161] = 4113; + rayToBps[1000000010926627393047724068] = 4114; + rayToBps[1000000010928874004145782483] = 4115; + rayToBps[1000000010931120456084687576] = 4116; + rayToBps[1000000010933366748886988728] = 4117; + rayToBps[1000000010935612882575230523] = 4118; + rayToBps[1000000010937858857171952760] = 4119; + rayToBps[1000000010940104672699690444] = 4120; + rayToBps[1000000010942350329180973795] = 4121; + rayToBps[1000000010944595826638328248] = 4122; + rayToBps[1000000010946841165094274449] = 4123; + rayToBps[1000000010949086344571328262] = 4124; + rayToBps[1000000010951331365092000772] = 4125; + rayToBps[1000000010953576226678798278] = 4126; + rayToBps[1000000010955820929354222302] = 4127; + rayToBps[1000000010958065473140769588] = 4128; + rayToBps[1000000010960309858060932102] = 4129; + rayToBps[1000000010962554084137197035] = 4130; + rayToBps[1000000010964798151392046803] = 4131; + rayToBps[1000000010967042059847959052] = 4132; + rayToBps[1000000010969285809527406653] = 4133; + rayToBps[1000000010971529400452857709] = 4134; + rayToBps[1000000010973772832646775552] = 4135; + rayToBps[1000000010976016106131618751] = 4136; + rayToBps[1000000010978259220929841103] = 4137; + rayToBps[1000000010980502177063891645] = 4138; + rayToBps[1000000010982744974556214650] = 4139; + rayToBps[1000000010984987613429249625] = 4140; + rayToBps[1000000010987230093705431322] = 4141; + rayToBps[1000000010989472415407189730] = 4142; + rayToBps[1000000010991714578556950080] = 4143; + rayToBps[1000000010993956583177132848] = 4144; + rayToBps[1000000010996198429290153754] = 4145; + rayToBps[1000000010998440116918423764] = 4146; + rayToBps[1000000011000681646084349091] = 4147; + rayToBps[1000000011002923016810331196] = 4148; + rayToBps[1000000011005164229118766794] = 4149; + rayToBps[1000000011007405283032047846] = 4150; + rayToBps[1000000011009646178572561570] = 4151; + rayToBps[1000000011011886915762690435] = 4152; + rayToBps[1000000011014127494624812168] = 4153; + rayToBps[1000000011016367915181299751] = 4154; + rayToBps[1000000011018608177454521425] = 4155; + rayToBps[1000000011020848281466840690] = 4156; + rayToBps[1000000011023088227240616307] = 4157; + rayToBps[1000000011025328014798202299] = 4158; + rayToBps[1000000011027567644161947953] = 4159; + rayToBps[1000000011029807115354197820] = 4160; + rayToBps[1000000011032046428397291718] = 4161; + rayToBps[1000000011034285583313564733] = 4162; + rayToBps[1000000011036524580125347217] = 4163; + rayToBps[1000000011038763418854964795] = 4164; + rayToBps[1000000011041002099524738363] = 4165; + rayToBps[1000000011043240622156984088] = 4166; + rayToBps[1000000011045478986774013414] = 4167; + rayToBps[1000000011047717193398133058] = 4168; + rayToBps[1000000011049955242051645015] = 4169; + rayToBps[1000000011052193132756846559] = 4170; + rayToBps[1000000011054430865536030243] = 4171; + rayToBps[1000000011056668440411483899] = 4172; + rayToBps[1000000011058905857405490642] = 4173; + rayToBps[1000000011061143116540328874] = 4174; + rayToBps[1000000011063380217838272275] = 4175; + rayToBps[1000000011065617161321589818] = 4176; + rayToBps[1000000011067853947012545760] = 4177; + rayToBps[1000000011070090574933399646] = 4178; + rayToBps[1000000011072327045106406314] = 4179; + rayToBps[1000000011074563357553815892] = 4180; + rayToBps[1000000011076799512297873799] = 4181; + rayToBps[1000000011079035509360820752] = 4182; + rayToBps[1000000011081271348764892760] = 4183; + rayToBps[1000000011083507030532321133] = 4184; + rayToBps[1000000011085742554685332472] = 4185; + rayToBps[1000000011087977921246148683] = 4186; + rayToBps[1000000011090213130236986974] = 4187; + rayToBps[1000000011092448181680059850] = 4188; + rayToBps[1000000011094683075597575122] = 4189; + rayToBps[1000000011096917812011735908] = 4190; + rayToBps[1000000011099152390944740628] = 4191; + rayToBps[1000000011101386812418783011] = 4192; + rayToBps[1000000011103621076456052096] = 4193; + rayToBps[1000000011105855183078732230] = 4194; + rayToBps[1000000011108089132309003072] = 4195; + rayToBps[1000000011110322924169039595] = 4196; + rayToBps[1000000011112556558681012085] = 4197; + rayToBps[1000000011114790035867086142] = 4198; + rayToBps[1000000011117023355749422684] = 4199; + rayToBps[1000000011119256518350177948] = 4200; + rayToBps[1000000011121489523691503488] = 4201; + rayToBps[1000000011123722371795546180] = 4202; + rayToBps[1000000011125955062684448222] = 4203; + rayToBps[1000000011128187596380347134] = 4204; + rayToBps[1000000011130419972905375761] = 4205; + rayToBps[1000000011132652192281662277] = 4206; + rayToBps[1000000011134884254531330177] = 4207; + rayToBps[1000000011137116159676498289] = 4208; + rayToBps[1000000011139347907739280771] = 4209; + rayToBps[1000000011141579498741787109] = 4210; + rayToBps[1000000011143810932706122123] = 4211; + rayToBps[1000000011146042209654385969] = 4212; + rayToBps[1000000011148273329608674134] = 4213; + rayToBps[1000000011150504292591077445] = 4214; + rayToBps[1000000011152735098623682064] = 4215; + rayToBps[1000000011154965747728569493] = 4216; + rayToBps[1000000011157196239927816576] = 4217; + rayToBps[1000000011159426575243495495] = 4218; + rayToBps[1000000011161656753697673778] = 4219; + rayToBps[1000000011163886775312414296] = 4220; + rayToBps[1000000011166116640109775265] = 4221; + rayToBps[1000000011168346348111810249] = 4222; + rayToBps[1000000011170575899340568161] = 4223; + rayToBps[1000000011172805293818093260] = 4224; + rayToBps[1000000011175034531566425160] = 4225; + rayToBps[1000000011177263612607598825] = 4226; + rayToBps[1000000011179492536963644571] = 4227; + rayToBps[1000000011181721304656588071] = 4228; + rayToBps[1000000011183949915708450354] = 4229; + rayToBps[1000000011186178370141247803] = 4230; + rayToBps[1000000011188406667976992166] = 4231; + rayToBps[1000000011190634809237690543] = 4232; + rayToBps[1000000011192862793945345402] = 4233; + rayToBps[1000000011195090622121954571] = 4234; + rayToBps[1000000011197318293789511240] = 4235; + rayToBps[1000000011199545808970003967] = 4236; + rayToBps[1000000011201773167685416674] = 4237; + rayToBps[1000000011204000369957728654] = 4238; + rayToBps[1000000011206227415808914565] = 4239; + rayToBps[1000000011208454305260944438] = 4240; + rayToBps[1000000011210681038335783676] = 4241; + rayToBps[1000000011212907615055393052] = 4242; + rayToBps[1000000011215134035441728718] = 4243; + rayToBps[1000000011217360299516742197] = 4244; + rayToBps[1000000011219586407302380389] = 4245; + rayToBps[1000000011221812358820585577] = 4246; + rayToBps[1000000011224038154093295418] = 4247; + rayToBps[1000000011226263793142442953] = 4248; + rayToBps[1000000011228489275989956604] = 4249; + rayToBps[1000000011230714602657760176] = 4250; + rayToBps[1000000011232939773167772858] = 4251; + rayToBps[1000000011235164787541909226] = 4252; + rayToBps[1000000011237389645802079244] = 4253; + rayToBps[1000000011239614347970188264] = 4254; + rayToBps[1000000011241838894068137026] = 4255; + rayToBps[1000000011244063284117821662] = 4256; + rayToBps[1000000011246287518141133699] = 4257; + rayToBps[1000000011248511596159960053] = 4258; + rayToBps[1000000011250735518196183039] = 4259; + rayToBps[1000000011252959284271680367] = 4260; + rayToBps[1000000011255182894408325144] = 4261; + rayToBps[1000000011257406348627985874] = 4262; + rayToBps[1000000011259629646952526467] = 4263; + rayToBps[1000000011261852789403806228] = 4264; + rayToBps[1000000011264075776003679869] = 4265; + rayToBps[1000000011266298606773997503] = 4266; + rayToBps[1000000011268521281736604652] = 4267; + rayToBps[1000000011270743800913342239] = 4268; + rayToBps[1000000011272966164326046602] = 4269; + rayToBps[1000000011275188371996549481] = 4270; + rayToBps[1000000011277410423946678031] = 4271; + rayToBps[1000000011279632320198254820] = 4272; + rayToBps[1000000011281854060773097822] = 4273; + rayToBps[1000000011284075645693020433] = 4274; + rayToBps[1000000011286297074979831462] = 4275; + rayToBps[1000000011288518348655335131] = 4276; + rayToBps[1000000011290739466741331087] = 4277; + rayToBps[1000000011292960429259614390] = 4278; + rayToBps[1000000011295181236231975526] = 4279; + rayToBps[1000000011297401887680200399] = 4280; + rayToBps[1000000011299622383626070339] = 4281; + rayToBps[1000000011301842724091362099] = 4282; + rayToBps[1000000011304062909097847859] = 4283; + rayToBps[1000000011306282938667295224] = 4284; + rayToBps[1000000011308502812821467231] = 4285; + rayToBps[1000000011310722531582122343] = 4286; + rayToBps[1000000011312942094971014457] = 4287; + rayToBps[1000000011315161503009892899] = 4288; + rayToBps[1000000011317380755720502432] = 4289; + rayToBps[1000000011319599853124583251] = 4290; + rayToBps[1000000011321818795243870989] = 4291; + rayToBps[1000000011324037582100096715] = 4292; + rayToBps[1000000011326256213714986939] = 4293; + rayToBps[1000000011328474690110263606] = 4294; + rayToBps[1000000011330693011307644108] = 4295; + rayToBps[1000000011332911177328841276] = 4296; + rayToBps[1000000011335129188195563387] = 4297; + rayToBps[1000000011337347043929514159] = 4298; + rayToBps[1000000011339564744552392760] = 4299; + rayToBps[1000000011341782290085893805] = 4300; + rayToBps[1000000011343999680551707357] = 4301; + rayToBps[1000000011346216915971518931] = 4302; + rayToBps[1000000011348433996367009488] = 4303; + rayToBps[1000000011350650921759855449] = 4304; + rayToBps[1000000011352867692171728685] = 4305; + rayToBps[1000000011355084307624296520] = 4306; + rayToBps[1000000011357300768139221740] = 4307; + rayToBps[1000000011359517073738162585] = 4308; + rayToBps[1000000011361733224442772754] = 4309; + rayToBps[1000000011363949220274701408] = 4310; + rayToBps[1000000011366165061255593168] = 4311; + rayToBps[1000000011368380747407088120] = 4312; + rayToBps[1000000011370596278750821810] = 4313; + rayToBps[1000000011372811655308425254] = 4314; + rayToBps[1000000011375026877101524932] = 4315; + rayToBps[1000000011377241944151742792] = 4316; + rayToBps[1000000011379456856480696254] = 4317; + rayToBps[1000000011381671614109998202] = 4318; + rayToBps[1000000011383886217061256998] = 4319; + rayToBps[1000000011386100665356076475] = 4320; + rayToBps[1000000011388314959016055939] = 4321; + rayToBps[1000000011390529098062790173] = 4322; + rayToBps[1000000011392743082517869435] = 4323; + rayToBps[1000000011394956912402879463] = 4324; + rayToBps[1000000011397170587739401474] = 4325; + rayToBps[1000000011399384108549012164] = 4326; + rayToBps[1000000011401597474853283711] = 4327; + rayToBps[1000000011403810686673783778] = 4328; + rayToBps[1000000011406023744032075511] = 4329; + rayToBps[1000000011408236646949717541] = 4330; + rayToBps[1000000011410449395448263986] = 4331; + rayToBps[1000000011412661989549264455] = 4332; + rayToBps[1000000011414874429274264041] = 4333; + rayToBps[1000000011417086714644803332] = 4334; + rayToBps[1000000011419298845682418407] = 4335; + rayToBps[1000000011421510822408640836] = 4336; + rayToBps[1000000011423722644844997686] = 4337; + rayToBps[1000000011425934313013011518] = 4338; + rayToBps[1000000011428145826934200391] = 4339; + rayToBps[1000000011430357186630077862] = 4340; + rayToBps[1000000011432568392122152986] = 4341; + rayToBps[1000000011434779443431930319] = 4342; + rayToBps[1000000011436990340580909922] = 4343; + rayToBps[1000000011439201083590587356] = 4344; + rayToBps[1000000011441411672482453687] = 4345; + rayToBps[1000000011443622107277995486] = 4346; + rayToBps[1000000011445832387998694833] = 4347; + rayToBps[1000000011448042514666029315] = 4348; + rayToBps[1000000011450252487301472028] = 4349; + rayToBps[1000000011452462305926491579] = 4350; + rayToBps[1000000011454671970562552089] = 4351; + rayToBps[1000000011456881481231113188] = 4352; + rayToBps[1000000011459090837953630024] = 4353; + rayToBps[1000000011461300040751553259] = 4354; + rayToBps[1000000011463509089646329073] = 4355; + rayToBps[1000000011465717984659399163] = 4356; + rayToBps[1000000011467926725812200747] = 4357; + rayToBps[1000000011470135313126166561] = 4358; + rayToBps[1000000011472343746622724867] = 4359; + rayToBps[1000000011474552026323299446] = 4360; + rayToBps[1000000011476760152249309607] = 4361; + rayToBps[1000000011478968124422170181] = 4362; + rayToBps[1000000011481175942863291530] = 4363; + rayToBps[1000000011483383607594079540] = 4364; + rayToBps[1000000011485591118635935631] = 4365; + rayToBps[1000000011487798476010256750] = 4366; + rayToBps[1000000011490005679738435376] = 4367; + rayToBps[1000000011492212729841859524] = 4368; + rayToBps[1000000011494419626341912740] = 4369; + rayToBps[1000000011496626369259974109] = 4370; + rayToBps[1000000011498832958617418250] = 4371; + rayToBps[1000000011501039394435615322] = 4372; + rayToBps[1000000011503245676735931022] = 4373; + rayToBps[1000000011505451805539726589] = 4374; + rayToBps[1000000011507657780868358802] = 4375; + rayToBps[1000000011509863602743179986] = 4376; + rayToBps[1000000011512069271185538006] = 4377; + rayToBps[1000000011514274786216776278] = 4378; + rayToBps[1000000011516480147858233760] = 4379; + rayToBps[1000000011518685356131244960] = 4380; + rayToBps[1000000011520890411057139937] = 4381; + rayToBps[1000000011523095312657244296] = 4382; + rayToBps[1000000011525300060952879198] = 4383; + rayToBps[1000000011527504655965361356] = 4384; + rayToBps[1000000011529709097716003036] = 4385; + rayToBps[1000000011531913386226112060] = 4386; + rayToBps[1000000011534117521516991808] = 4387; + rayToBps[1000000011536321503609941215] = 4388; + rayToBps[1000000011538525332526254779] = 4389; + rayToBps[1000000011540729008287222556] = 4390; + rayToBps[1000000011542932530914130163] = 4391; + rayToBps[1000000011545135900428258782] = 4392; + rayToBps[1000000011547339116850885159] = 4393; + rayToBps[1000000011549542180203281602] = 4394; + rayToBps[1000000011551745090506715989] = 4395; + rayToBps[1000000011553947847782451765] = 4396; + rayToBps[1000000011556150452051747944] = 4397; + rayToBps[1000000011558352903335859111] = 4398; + rayToBps[1000000011560555201656035419] = 4399; + rayToBps[1000000011562757347033522598] = 4400; + rayToBps[1000000011564959339489561951] = 4401; + rayToBps[1000000011567161179045390355] = 4402; + rayToBps[1000000011569362865722240263] = 4403; + rayToBps[1000000011571564399541339706] = 4404; + rayToBps[1000000011573765780523912298] = 4405; + rayToBps[1000000011575967008691177226] = 4406; + rayToBps[1000000011578168084064349263] = 4407; + rayToBps[1000000011580369006664638762] = 4408; + rayToBps[1000000011582569776513251664] = 4409; + rayToBps[1000000011584770393631389491] = 4410; + rayToBps[1000000011586970858040249351] = 4411; + rayToBps[1000000011589171169761023944] = 4412; + rayToBps[1000000011591371328814901553] = 4413; + rayToBps[1000000011593571335223066054] = 4414; + rayToBps[1000000011595771189006696913] = 4415; + rayToBps[1000000011597970890186969190] = 4416; + rayToBps[1000000011600170438785053539] = 4417; + rayToBps[1000000011602369834822116205] = 4418; + rayToBps[1000000011604569078319319032] = 4419; + rayToBps[1000000011606768169297819461] = 4420; + rayToBps[1000000011608967107778770531] = 4421; + rayToBps[1000000011611165893783320880] = 4422; + rayToBps[1000000011613364527332614750] = 4423; + rayToBps[1000000011615563008447791980] = 4424; + rayToBps[1000000011617761337149988016] = 4425; + rayToBps[1000000011619959513460333909] = 4426; + rayToBps[1000000011622157537399956313] = 4427; + rayToBps[1000000011624355408989977491] = 4428; + rayToBps[1000000011626553128251515315] = 4429; + rayToBps[1000000011628750695205683263] = 4430; + rayToBps[1000000011630948109873590427] = 4431; + rayToBps[1000000011633145372276341510] = 4432; + rayToBps[1000000011635342482435036828] = 4433; + rayToBps[1000000011637539440370772309] = 4434; + rayToBps[1000000011639736246104639501] = 4435; + rayToBps[1000000011641932899657725566] = 4436; + rayToBps[1000000011644129401051113283] = 4437; + rayToBps[1000000011646325750305881052] = 4438; + rayToBps[1000000011648521947443102894] = 4439; + rayToBps[1000000011650717992483848450] = 4440; + rayToBps[1000000011652913885449182982] = 4441; + rayToBps[1000000011655109626360167380] = 4442; + rayToBps[1000000011657305215237858159] = 4443; + rayToBps[1000000011659500652103307456] = 4444; + rayToBps[1000000011661695936977563040] = 4445; + rayToBps[1000000011663891069881668309] = 4446; + rayToBps[1000000011666086050836662286] = 4447; + rayToBps[1000000011668280879863579631] = 4448; + rayToBps[1000000011670475556983450634] = 4449; + rayToBps[1000000011672670082217301219] = 4450; + rayToBps[1000000011674864455586152944] = 4451; + rayToBps[1000000011677058677111023005] = 4452; + rayToBps[1000000011679252746812924234] = 4453; + rayToBps[1000000011681446664712865102] = 4454; + rayToBps[1000000011683640430831849720] = 4455; + rayToBps[1000000011685834045190877838] = 4456; + rayToBps[1000000011688027507810944851] = 4457; + rayToBps[1000000011690220818713041795] = 4458; + rayToBps[1000000011692413977918155352] = 4459; + rayToBps[1000000011694606985447267850] = 4460; + rayToBps[1000000011696799841321357263] = 4461; + rayToBps[1000000011698992545561397213] = 4462; + rayToBps[1000000011701185098188356972] = 4463; + rayToBps[1000000011703377499223201464] = 4464; + rayToBps[1000000011705569748686891261] = 4465; + rayToBps[1000000011707761846600382591] = 4466; + rayToBps[1000000011709953792984627335] = 4467; + rayToBps[1000000011712145587860573032] = 4468; + rayToBps[1000000011714337231249162871] = 4469; + rayToBps[1000000011716528723171335709] = 4470; + rayToBps[1000000011718720063648026051] = 4471; + rayToBps[1000000011720911252700164071] = 4472; + rayToBps[1000000011723102290348675597] = 4473; + rayToBps[1000000011725293176614482128] = 4474; + rayToBps[1000000011727483911518500818] = 4475; + rayToBps[1000000011729674495081644493] = 4476; + rayToBps[1000000011731864927324821641] = 4477; + rayToBps[1000000011734055208268936418] = 4478; + rayToBps[1000000011736245337934888652] = 4479; + rayToBps[1000000011738435316343573834] = 4480; + rayToBps[1000000011740625143515883134] = 4481; + rayToBps[1000000011742814819472703388] = 4482; + rayToBps[1000000011745004344234917107] = 4483; + rayToBps[1000000011747193717823402479] = 4484; + rayToBps[1000000011749382940259033365] = 4485; + rayToBps[1000000011751572011562679304] = 4486; + rayToBps[1000000011753760931755205513] = 4487; + rayToBps[1000000011755949700857472887] = 4488; + rayToBps[1000000011758138318890338005] = 4489; + rayToBps[1000000011760326785874653124] = 4490; + rayToBps[1000000011762515101831266185] = 4491; + rayToBps[1000000011764703266781020815] = 4492; + rayToBps[1000000011766891280744756325] = 4493; + rayToBps[1000000011769079143743307711] = 4494; + rayToBps[1000000011771266855797505659] = 4495; + rayToBps[1000000011773454416928176542] = 4496; + rayToBps[1000000011775641827156142425] = 4497; + rayToBps[1000000011777829086502221061] = 4498; + rayToBps[1000000011780016194987225901] = 4499; + rayToBps[1000000011782203152631966084] = 4500; + rayToBps[1000000011784389959457246446] = 4501; + rayToBps[1000000011786576615483867520] = 4502; + rayToBps[1000000011788763120732625534] = 4503; + rayToBps[1000000011790949475224312417] = 4504; + rayToBps[1000000011793135678979715794] = 4505; + rayToBps[1000000011795321732019618995] = 4506; + rayToBps[1000000011797507634364801050] = 4507; + rayToBps[1000000011799693386036036690] = 4508; + rayToBps[1000000011801878987054096353] = 4509; + rayToBps[1000000011804064437439746183] = 4510; + rayToBps[1000000011806249737213748028] = 4511; + rayToBps[1000000011808434886396859445] = 4512; + rayToBps[1000000011810619885009833701] = 4513; + rayToBps[1000000011812804733073419772] = 4514; + rayToBps[1000000011814989430608362346] = 4515; + rayToBps[1000000011817173977635401824] = 4516; + rayToBps[1000000011819358374175274320] = 4517; + rayToBps[1000000011821542620248711663] = 4518; + rayToBps[1000000011823726715876441397] = 4519; + rayToBps[1000000011825910661079186786] = 4520; + rayToBps[1000000011828094455877666811] = 4521; + rayToBps[1000000011830278100292596173] = 4522; + rayToBps[1000000011832461594344685292] = 4523; + rayToBps[1000000011834644938054640314] = 4524; + rayToBps[1000000011836828131443163102] = 4525; + rayToBps[1000000011839011174530951252] = 4526; + rayToBps[1000000011841194067338698076] = 4527; + rayToBps[1000000011843376809887092621] = 4528; + rayToBps[1000000011845559402196819657] = 4529; + rayToBps[1000000011847741844288559684] = 4530; + rayToBps[1000000011849924136182988931] = 4531; + rayToBps[1000000011852106277900779365] = 4532; + rayToBps[1000000011854288269462598676] = 4533; + rayToBps[1000000011856470110889110294] = 4534; + rayToBps[1000000011858651802200973384] = 4535; + rayToBps[1000000011860833343418842843] = 4536; + rayToBps[1000000011863014734563369310] = 4537; + rayToBps[1000000011865195975655199159] = 4538; + rayToBps[1000000011867377066714974505] = 4539; + rayToBps[1000000011869558007763333206] = 4540; + rayToBps[1000000011871738798820908856] = 4541; + rayToBps[1000000011873919439908330799] = 4542; + rayToBps[1000000011876099931046224119] = 4543; + rayToBps[1000000011878280272255209648] = 4544; + rayToBps[1000000011880460463555903962] = 4545; + rayToBps[1000000011882640504968919386] = 4546; + rayToBps[1000000011884820396514863997] = 4547; + rayToBps[1000000011887000138214341617] = 4548; + rayToBps[1000000011889179730087951822] = 4549; + rayToBps[1000000011891359172156289942] = 4550; + rayToBps[1000000011893538464439947057] = 4551; + rayToBps[1000000011895717606959510007] = 4552; + rayToBps[1000000011897896599735561381] = 4553; + rayToBps[1000000011900075442788679533] = 4554; + rayToBps[1000000011902254136139438568] = 4555; + rayToBps[1000000011904432679808408357] = 4556; + rayToBps[1000000011906611073816154526] = 4557; + rayToBps[1000000011908789318183238468] = 4558; + rayToBps[1000000011910967412930217335] = 4559; + rayToBps[1000000011913145358077644046] = 4560; + rayToBps[1000000011915323153646067283] = 4561; + rayToBps[1000000011917500799656031495] = 4562; + rayToBps[1000000011919678296128076901] = 4563; + rayToBps[1000000011921855643082739486] = 4564; + rayToBps[1000000011924032840540551006] = 4565; + rayToBps[1000000011926209888522038989] = 4566; + rayToBps[1000000011928386787047726732] = 4567; + rayToBps[1000000011930563536138133312] = 4568; + rayToBps[1000000011932740135813773575] = 4569; + rayToBps[1000000011934916586095158143] = 4570; + rayToBps[1000000011937092887002793418] = 4571; + rayToBps[1000000011939269038557181578] = 4572; + rayToBps[1000000011941445040778820581] = 4573; + rayToBps[1000000011943620893688204164] = 4574; + rayToBps[1000000011945796597305821848] = 4575; + rayToBps[1000000011947972151652158936] = 4576; + rayToBps[1000000011950147556747696515] = 4577; + rayToBps[1000000011952322812612911454] = 4578; + rayToBps[1000000011954497919268276412] = 4579; + rayToBps[1000000011956672876734259834] = 4580; + rayToBps[1000000011958847685031325954] = 4581; + rayToBps[1000000011961022344179934796] = 4582; + rayToBps[1000000011963196854200542173] = 4583; + rayToBps[1000000011965371215113599692] = 4584; + rayToBps[1000000011967545426939554751] = 4585; + rayToBps[1000000011969719489698850545] = 4586; + rayToBps[1000000011971893403411926063] = 4587; + rayToBps[1000000011974067168099216089] = 4588; + rayToBps[1000000011976240783781151209] = 4589; + rayToBps[1000000011978414250478157804] = 4590; + rayToBps[1000000011980587568210658056] = 4591; + rayToBps[1000000011982760736999069949] = 4592; + rayToBps[1000000011984933756863807269] = 4593; + rayToBps[1000000011987106627825279606] = 4594; + rayToBps[1000000011989279349903892354] = 4595; + rayToBps[1000000011991451923120046712] = 4596; + rayToBps[1000000011993624347494139689] = 4597; + rayToBps[1000000011995796623046564099] = 4598; + rayToBps[1000000011997968749797708565] = 4599; + rayToBps[1000000012000140727767957524] = 4600; + rayToBps[1000000012002312556977691222] = 4601; + rayToBps[1000000012004484237447285716] = 4602; + rayToBps[1000000012006655769197112882] = 4603; + rayToBps[1000000012008827152247540405] = 4604; + rayToBps[1000000012010998386618931791] = 4605; + rayToBps[1000000012013169472331646360] = 4606; + rayToBps[1000000012015340409406039253] = 4607; + rayToBps[1000000012017511197862461428] = 4608; + rayToBps[1000000012019681837721259668] = 4609; + rayToBps[1000000012021852329002776572] = 4610; + rayToBps[1000000012024022671727350564] = 4611; + rayToBps[1000000012026192865915315897] = 4612; + rayToBps[1000000012028362911587002643] = 4613; + rayToBps[1000000012030532808762736703] = 4614; + rayToBps[1000000012032702557462839807] = 4615; + rayToBps[1000000012034872157707629511] = 4616; + rayToBps[1000000012037041609517419201] = 4617; + rayToBps[1000000012039210912912518097] = 4618; + rayToBps[1000000012041380067913231248] = 4619; + rayToBps[1000000012043549074539859539] = 4620; + rayToBps[1000000012045717932812699686] = 4621; + rayToBps[1000000012047886642752044245] = 4622; + rayToBps[1000000012050055204378181605] = 4623; + rayToBps[1000000012052223617711395993] = 4624; + rayToBps[1000000012054391882771967477] = 4625; + rayToBps[1000000012056559999580171966] = 4626; + rayToBps[1000000012058727968156281206] = 4627; + rayToBps[1000000012060895788520562788] = 4628; + rayToBps[1000000012063063460693280149] = 4629; + rayToBps[1000000012065230984694692566] = 4630; + rayToBps[1000000012067398360545055164] = 4631; + rayToBps[1000000012069565588264618915] = 4632; + rayToBps[1000000012071732667873630640] = 4633; + rayToBps[1000000012073899599392333007] = 4634; + rayToBps[1000000012076066382840964537] = 4635; + rayToBps[1000000012078233018239759599] = 4636; + rayToBps[1000000012080399505608948418] = 4637; + rayToBps[1000000012082565844968757072] = 4638; + rayToBps[1000000012084732036339407491] = 4639; + rayToBps[1000000012086898079741117465] = 4640; + rayToBps[1000000012089063975194100640] = 4641; + rayToBps[1000000012091229722718566519] = 4642; + rayToBps[1000000012093395322334720465] = 4643; + rayToBps[1000000012095560774062763701] = 4644; + rayToBps[1000000012097726077922893315] = 4645; + rayToBps[1000000012099891233935302252] = 4646; + rayToBps[1000000012102056242120179326] = 4647; + rayToBps[1000000012104221102497709214] = 4648; + rayToBps[1000000012106385815088072459] = 4649; + rayToBps[1000000012108550379911445472] = 4650; + rayToBps[1000000012110714796988000533] = 4651; + rayToBps[1000000012112879066337905789] = 4652; + rayToBps[1000000012115043187981325261] = 4653; + rayToBps[1000000012117207161938418839] = 4654; + rayToBps[1000000012119370988229342288] = 4655; + rayToBps[1000000012121534666874247247] = 4656; + rayToBps[1000000012123698197893281228] = 4657; + rayToBps[1000000012125861581306587623] = 4658; + rayToBps[1000000012128024817134305697] = 4659; + rayToBps[1000000012130187905396570598] = 4660; + rayToBps[1000000012132350846113513350] = 4661; + rayToBps[1000000012134513639305260860] = 4662; + rayToBps[1000000012136676284991935918] = 4663; + rayToBps[1000000012138838783193657193] = 4664; + rayToBps[1000000012141001133930539244] = 4665; + rayToBps[1000000012143163337222692509] = 4666; + rayToBps[1000000012145325393090223317] = 4667; + rayToBps[1000000012147487301553233883] = 4668; + rayToBps[1000000012149649062631822311] = 4669; + rayToBps[1000000012151810676346082594] = 4670; + rayToBps[1000000012153972142716104618] = 4671; + rayToBps[1000000012156133461761974158] = 4672; + rayToBps[1000000012158294633503772885] = 4673; + rayToBps[1000000012160455657961578363] = 4674; + rayToBps[1000000012162616535155464050] = 4675; + rayToBps[1000000012164777265105499304] = 4676; + rayToBps[1000000012166937847831749378] = 4677; + rayToBps[1000000012169098283354275425] = 4678; + rayToBps[1000000012171258571693134496] = 4679; + rayToBps[1000000012173418712868379547] = 4680; + rayToBps[1000000012175578706900059431] = 4681; + rayToBps[1000000012177738553808218907] = 4682; + rayToBps[1000000012179898253612898639] = 4683; + rayToBps[1000000012182057806334135196] = 4684; + rayToBps[1000000012184217211991961053] = 4685; + rayToBps[1000000012186376470606404593] = 4686; + rayToBps[1000000012188535582197490106] = 4687; + rayToBps[1000000012190694546785237795] = 4688; + rayToBps[1000000012192853364389663774] = 4689; + rayToBps[1000000012195012035030780065] = 4690; + rayToBps[1000000012197170558728594608] = 4691; + rayToBps[1000000012199328935503111256] = 4692; + rayToBps[1000000012201487165374329775] = 4693; + rayToBps[1000000012203645248362245852] = 4694; + rayToBps[1000000012205803184486851087] = 4695; + rayToBps[1000000012207960973768133003] = 4696; + rayToBps[1000000012210118616226075039] = 4697; + rayToBps[1000000012212276111880656560] = 4698; + rayToBps[1000000012214433460751852848] = 4699; + rayToBps[1000000012216590662859635112] = 4700; + rayToBps[1000000012218747718223970482] = 4701; + rayToBps[1000000012220904626864822019] = 4702; + rayToBps[1000000012223061388802148704] = 4703; + rayToBps[1000000012225218004055905450] = 4704; + rayToBps[1000000012227374472646043097] = 4705; + rayToBps[1000000012229530794592508416] = 4706; + rayToBps[1000000012231686969915244108] = 4707; + rayToBps[1000000012233842998634188809] = 4708; + rayToBps[1000000012235998880769277082] = 4709; + rayToBps[1000000012238154616340439431] = 4710; + rayToBps[1000000012240310205367602293] = 4711; + rayToBps[1000000012242465647870688040] = 4712; + rayToBps[1000000012244620943869614982] = 4713; + rayToBps[1000000012246776093384297371] = 4714; + rayToBps[1000000012248931096434645396] = 4715; + rayToBps[1000000012251085953040565187] = 4716; + rayToBps[1000000012253240663221958817] = 4717; + rayToBps[1000000012255395226998724301] = 4718; + rayToBps[1000000012257549644390755600] = 4719; + rayToBps[1000000012259703915417942619] = 4720; + rayToBps[1000000012261858040100171212] = 4721; + rayToBps[1000000012264012018457323175] = 4722; + rayToBps[1000000012266165850509276259] = 4723; + rayToBps[1000000012268319536275904161] = 4724; + rayToBps[1000000012270473075777076530] = 4725; + rayToBps[1000000012272626469032658968] = 4726; + rayToBps[1000000012274779716062513028] = 4727; + rayToBps[1000000012276932816886496218] = 4728; + rayToBps[1000000012279085771524462002] = 4729; + rayToBps[1000000012281238579996259799] = 4730; + rayToBps[1000000012283391242321734988] = 4731; + rayToBps[1000000012285543758520728905] = 4732; + rayToBps[1000000012287696128613078844] = 4733; + rayToBps[1000000012289848352618618062] = 4734; + rayToBps[1000000012292000430557175778] = 4735; + rayToBps[1000000012294152362448577173] = 4736; + rayToBps[1000000012296304148312643392] = 4737; + rayToBps[1000000012298455788169191545] = 4738; + rayToBps[1000000012300607282038034711] = 4739; + rayToBps[1000000012302758629938981931] = 4740; + rayToBps[1000000012304909831891838220] = 4741; + rayToBps[1000000012307060887916404559] = 4742; + rayToBps[1000000012309211798032477901] = 4743; + rayToBps[1000000012311362562259851171] = 4744; + rayToBps[1000000012313513180618313265] = 4745; + rayToBps[1000000012315663653127649055] = 4746; + rayToBps[1000000012317813979807639387] = 4747; + rayToBps[1000000012319964160678061084] = 4748; + rayToBps[1000000012322114195758686945] = 4749; + rayToBps[1000000012324264085069285747] = 4750; + rayToBps[1000000012326413828629622247] = 4751; + rayToBps[1000000012328563426459457184] = 4752; + rayToBps[1000000012330712878578547277] = 4753; + rayToBps[1000000012332862185006645225] = 4754; + rayToBps[1000000012335011345763499718] = 4755; + rayToBps[1000000012337160360868855422] = 4756; + rayToBps[1000000012339309230342452997] = 4757; + rayToBps[1000000012341457954204029084] = 4758; + rayToBps[1000000012343606532473316314] = 4759; + rayToBps[1000000012345754965170043307] = 4760; + rayToBps[1000000012347903252313934676] = 4761; + rayToBps[1000000012350051393924711022] = 4762; + rayToBps[1000000012352199390022088940] = 4763; + rayToBps[1000000012354347240625781016] = 4764; + rayToBps[1000000012356494945755495834] = 4765; + rayToBps[1000000012358642505430937972] = 4766; + rayToBps[1000000012360789919671808004] = 4767; + rayToBps[1000000012362937188497802506] = 4768; + rayToBps[1000000012365084311928614047] = 4769; + rayToBps[1000000012367231289983931199] = 4770; + rayToBps[1000000012369378122683438536] = 4771; + rayToBps[1000000012371524810046816632] = 4772; + rayToBps[1000000012373671352093742067] = 4773; + rayToBps[1000000012375817748843887422] = 4774; + rayToBps[1000000012377964000316921287] = 4775; + rayToBps[1000000012380110106532508255] = 4776; + rayToBps[1000000012382256067510308928] = 4777; + rayToBps[1000000012384401883269979920] = 4778; + rayToBps[1000000012386547553831173848] = 4779; + rayToBps[1000000012388693079213539345] = 4780; + rayToBps[1000000012390838459436721054] = 4781; + rayToBps[1000000012392983694520359633] = 4782; + rayToBps[1000000012395128784484091752] = 4783; + rayToBps[1000000012397273729347550096] = 4784; + rayToBps[1000000012399418529130363366] = 4785; + rayToBps[1000000012401563183852156283] = 4786; + rayToBps[1000000012403707693532549584] = 4787; + rayToBps[1000000012405852058191160026] = 4788; + rayToBps[1000000012407996277847600385] = 4789; + rayToBps[1000000012410140352521479464] = 4790; + rayToBps[1000000012412284282232402082] = 4791; + rayToBps[1000000012414428066999969084] = 4792; + rayToBps[1000000012416571706843777343] = 4793; + rayToBps[1000000012418715201783419755] = 4794; + rayToBps[1000000012420858551838485241] = 4795; + rayToBps[1000000012423001757028558755] = 4796; + rayToBps[1000000012425144817373221276] = 4797; + rayToBps[1000000012427287732892049817] = 4798; + rayToBps[1000000012429430503604617418] = 4799; + rayToBps[1000000012431573129530493155] = 4800; + rayToBps[1000000012433715610689242134] = 4801; + rayToBps[1000000012435857947100425498] = 4802; + rayToBps[1000000012438000138783600426] = 4803; + rayToBps[1000000012440142185758320132] = 4804; + rayToBps[1000000012442284088044133868] = 4805; + rayToBps[1000000012444425845660586926] = 4806; + rayToBps[1000000012446567458627220637] = 4807; + rayToBps[1000000012448708926963572372] = 4808; + rayToBps[1000000012450850250689175545] = 4809; + rayToBps[1000000012452991429823559613] = 4810; + rayToBps[1000000012455132464386250078] = 4811; + rayToBps[1000000012457273354396768485] = 4812; + rayToBps[1000000012459414099874632428] = 4813; + rayToBps[1000000012461554700839355545] = 4814; + rayToBps[1000000012463695157310447527] = 4815; + rayToBps[1000000012465835469307414110] = 4816; + rayToBps[1000000012467975636849757081] = 4817; + rayToBps[1000000012470115659956974282] = 4818; + rayToBps[1000000012472255538648559605] = 4819; + rayToBps[1000000012474395272944002997] = 4820; + rayToBps[1000000012476534862862790458] = 4821; + rayToBps[1000000012478674308424404046] = 4822; + rayToBps[1000000012480813609648321873] = 4823; + rayToBps[1000000012482952766554018113] = 4824; + rayToBps[1000000012485091779160962996] = 4825; + rayToBps[1000000012487230647488622814] = 4826; + rayToBps[1000000012489369371556459918] = 4827; + rayToBps[1000000012491507951383932723] = 4828; + rayToBps[1000000012493646386990495707] = 4829; + rayToBps[1000000012495784678395599413] = 4830; + rayToBps[1000000012497922825618690446] = 4831; + rayToBps[1000000012500060828679211483] = 4832; + rayToBps[1000000012502198687596601264] = 4833; + rayToBps[1000000012504336402390294600] = 4834; + rayToBps[1000000012506473973079722370] = 4835; + rayToBps[1000000012508611399684311526] = 4836; + rayToBps[1000000012510748682223485091] = 4837; + rayToBps[1000000012512885820716662158] = 4838; + rayToBps[1000000012515022815183257897] = 4839; + rayToBps[1000000012517159665642683553] = 4840; + rayToBps[1000000012519296372114346446] = 4841; + rayToBps[1000000012521432934617649973] = 4842; + rayToBps[1000000012523569353171993611] = 4843; + rayToBps[1000000012525705627796772912] = 4844; + rayToBps[1000000012527841758511379512] = 4845; + rayToBps[1000000012529977745335201128] = 4846; + rayToBps[1000000012532113588287621558] = 4847; + rayToBps[1000000012534249287388020684] = 4848; + rayToBps[1000000012536384842655774473] = 4849; + rayToBps[1000000012538520254110254976] = 4850; + rayToBps[1000000012540655521770830332] = 4851; + rayToBps[1000000012542790645656864768] = 4852; + rayToBps[1000000012544925625787718599] = 4853; + rayToBps[1000000012547060462182748227] = 4854; + rayToBps[1000000012549195154861306151] = 4855; + rayToBps[1000000012551329703842740957] = 4856; + rayToBps[1000000012553464109146397324] = 4857; + rayToBps[1000000012555598370791616028] = 4858; + rayToBps[1000000012557732488797733936] = 4859; + rayToBps[1000000012559866463184084017] = 4860; + rayToBps[1000000012562000293969995331] = 4861; + rayToBps[1000000012564133981174793037] = 4862; + rayToBps[1000000012566267524817798398] = 4863; + rayToBps[1000000012568400924918328770] = 4864; + rayToBps[1000000012570534181495697619] = 4865; + rayToBps[1000000012572667294569214506] = 4866; + rayToBps[1000000012574800264158185098] = 4867; + rayToBps[1000000012576933090281911168] = 4868; + rayToBps[1000000012579065772959690591] = 4869; + rayToBps[1000000012581198312210817352] = 4870; + rayToBps[1000000012583330708054581542] = 4871; + rayToBps[1000000012585462960510269361] = 4872; + rayToBps[1000000012587595069597163118] = 4873; + rayToBps[1000000012589727035334541233] = 4874; + rayToBps[1000000012591858857741678240] = 4875; + rayToBps[1000000012593990536837844781] = 4876; + rayToBps[1000000012596122072642307617] = 4877; + rayToBps[1000000012598253465174329620] = 4878; + rayToBps[1000000012600384714453169781] = 4879; + rayToBps[1000000012602515820498083206] = 4880; + rayToBps[1000000012604646783328321121] = 4881; + rayToBps[1000000012606777602963130868] = 4882; + rayToBps[1000000012608908279421755911] = 4883; + rayToBps[1000000012611038812723435837] = 4884; + rayToBps[1000000012613169202887406351] = 4885; + rayToBps[1000000012615299449932899285] = 4886; + rayToBps[1000000012617429553879142594] = 4887; + rayToBps[1000000012619559514745360358] = 4888; + rayToBps[1000000012621689332550772783] = 4889; + rayToBps[1000000012623819007314596205] = 4890; + rayToBps[1000000012625948539056043084] = 4891; + rayToBps[1000000012628077927794322013] = 4892; + rayToBps[1000000012630207173548637715] = 4893; + rayToBps[1000000012632336276338191046] = 4894; + rayToBps[1000000012634465236182178989] = 4895; + rayToBps[1000000012636594053099794667] = 4896; + rayToBps[1000000012638722727110227335] = 4897; + rayToBps[1000000012640851258232662384] = 4898; + rayToBps[1000000012642979646486281341] = 4899; + rayToBps[1000000012645107891890261872] = 4900; + rayToBps[1000000012647235994463777781] = 4901; + rayToBps[1000000012649363954225999014] = 4902; + rayToBps[1000000012651491771196091654] = 4903; + rayToBps[1000000012653619445393217929] = 4904; + rayToBps[1000000012655746976836536210] = 4905; + rayToBps[1000000012657874365545201009] = 4906; + rayToBps[1000000012660001611538362988] = 4907; + rayToBps[1000000012662128714835168951] = 4908; + rayToBps[1000000012664255675454761851] = 4909; + rayToBps[1000000012666382493416280789] = 4910; + rayToBps[1000000012668509168738861013] = 4911; + rayToBps[1000000012670635701441633926] = 4912; + rayToBps[1000000012672762091543727077] = 4913; + rayToBps[1000000012674888339064264171] = 4914; + rayToBps[1000000012677014444022365063] = 4915; + rayToBps[1000000012679140406437145768] = 4916; + rayToBps[1000000012681266226327718450] = 4917; + rayToBps[1000000012683391903713191434] = 4918; + rayToBps[1000000012685517438612669200] = 4919; + rayToBps[1000000012687642831045252386] = 4920; + rayToBps[1000000012689768081030037793] = 4921; + rayToBps[1000000012691893188586118377] = 4922; + rayToBps[1000000012694018153732583262] = 4923; + rayToBps[1000000012696142976488517730] = 4924; + rayToBps[1000000012698267656873003228] = 4925; + rayToBps[1000000012700392194905117369] = 4926; + rayToBps[1000000012702516590603933928] = 4927; + rayToBps[1000000012704640843988522851] = 4928; + rayToBps[1000000012706764955077950249] = 4929; + rayToBps[1000000012708888923891278404] = 4930; + rayToBps[1000000012711012750447565765] = 4931; + rayToBps[1000000012713136434765866954] = 4932; + rayToBps[1000000012715259976865232764] = 4933; + rayToBps[1000000012717383376764710160] = 4934; + rayToBps[1000000012719506634483342283] = 4935; + rayToBps[1000000012721629750040168448] = 4936; + rayToBps[1000000012723752723454224145] = 4937; + rayToBps[1000000012725875554744541042] = 4938; + rayToBps[1000000012727998243930146984] = 4939; + rayToBps[1000000012730120791030065998] = 4940; + rayToBps[1000000012732243196063318286] = 4941; + rayToBps[1000000012734365459048920235] = 4942; + rayToBps[1000000012736487580005884415] = 4943; + rayToBps[1000000012738609558953219573] = 4944; + rayToBps[1000000012740731395909930647] = 4945; + rayToBps[1000000012742853090895018757] = 4946; + rayToBps[1000000012744974643927481210] = 4947; + rayToBps[1000000012747096055026311497] = 4948; + rayToBps[1000000012749217324210499303] = 4949; + rayToBps[1000000012751338451499030498] = 4950; + rayToBps[1000000012753459436910887143] = 4951; + rayToBps[1000000012755580280465047490] = 4952; + rayToBps[1000000012757700982180485986] = 4953; + rayToBps[1000000012759821542076173268] = 4954; + rayToBps[1000000012761941960171076169] = 4955; + rayToBps[1000000012764062236484157718] = 4956; + rayToBps[1000000012766182371034377136] = 4957; + rayToBps[1000000012768302363840689849] = 4958; + rayToBps[1000000012770422214922047473] = 4959; + rayToBps[1000000012772541924297397831] = 4960; + rayToBps[1000000012774661491985684940] = 4961; + rayToBps[1000000012776780918005849024] = 4962; + rayToBps[1000000012778900202376826505] = 4963; + rayToBps[1000000012781019345117550012] = 4964; + rayToBps[1000000012783138346246948375] = 4965; + rayToBps[1000000012785257205783946632] = 4966; + rayToBps[1000000012787375923747466027] = 4967; + rayToBps[1000000012789494500156424011] = 4968; + rayToBps[1000000012791612935029734245] = 4969; + rayToBps[1000000012793731228386306598] = 4970; + rayToBps[1000000012795849380245047149] = 4971; + rayToBps[1000000012797967390624858191] = 4972; + rayToBps[1000000012800085259544638227] = 4973; + rayToBps[1000000012802202987023281977] = 4974; + rayToBps[1000000012804320573079680371] = 4975; + rayToBps[1000000012806438017732720558] = 4976; + rayToBps[1000000012808555321001285904] = 4977; + rayToBps[1000000012810672482904255989] = 4978; + rayToBps[1000000012812789503460506616] = 4979; + rayToBps[1000000012814906382688909806] = 4980; + rayToBps[1000000012817023120608333799] = 4981; + rayToBps[1000000012819139717237643058] = 4982; + rayToBps[1000000012821256172595698271] = 4983; + rayToBps[1000000012823372486701356345] = 4984; + rayToBps[1000000012825488659573470415] = 4985; + rayToBps[1000000012827604691230889842] = 4986; + rayToBps[1000000012829720581692460212] = 4987; + rayToBps[1000000012831836330977023339] = 4988; + rayToBps[1000000012833951939103417266] = 4989; + rayToBps[1000000012836067406090476267] = 4990; + rayToBps[1000000012838182731957030847] = 4991; + rayToBps[1000000012840297916721907738] = 4992; + rayToBps[1000000012842412960403929910] = 4993; + rayToBps[1000000012844527863021916565] = 4994; + rayToBps[1000000012846642624594683140] = 4995; + rayToBps[1000000012848757245141041307] = 4996; + rayToBps[1000000012850871724679798976] = 4997; + rayToBps[1000000012852986063229760294] = 4998; + rayToBps[1000000012855100260809725646] = 4999; + rayToBps[1000000012857214317438491659] = 5000; + rayToBps[1000000012859328233134851198] = 5001; + rayToBps[1000000012861442007917593374] = 5002; + rayToBps[1000000012863555641805503536] = 5003; + rayToBps[1000000012865669134817363279] = 5004; + rayToBps[1000000012867782486971950443] = 5005; + rayToBps[1000000012869895698288039115] = 5006; + rayToBps[1000000012872008768784399625] = 5007; + rayToBps[1000000012874121698479798555] = 5008; + rayToBps[1000000012876234487392998733] = 5009; + rayToBps[1000000012878347135542759238] = 5010; + rayToBps[1000000012880459642947835401] = 5011; + rayToBps[1000000012882572009626978801] = 5012; + rayToBps[1000000012884684235598937274] = 5013; + rayToBps[1000000012886796320882454907] = 5014; + rayToBps[1000000012888908265496272044] = 5015; + rayToBps[1000000012891020069459125282] = 5016; + rayToBps[1000000012893131732789747478] = 5017; + rayToBps[1000000012895243255506867744] = 5018; + rayToBps[1000000012897354637629211454] = 5019; + rayToBps[1000000012899465879175500237] = 5020; + rayToBps[1000000012901576980164451988] = 5021; + rayToBps[1000000012903687940614780860] = 5022; + rayToBps[1000000012905798760545197270] = 5023; + rayToBps[1000000012907909439974407900] = 5024; + rayToBps[1000000012910019978921115695] = 5025; + rayToBps[1000000012912130377404019867] = 5026; + rayToBps[1000000012914240635441815894] = 5027; + rayToBps[1000000012916350753053195521] = 5028; + rayToBps[1000000012918460730256846763] = 5029; + rayToBps[1000000012920570567071453907] = 5030; + rayToBps[1000000012922680263515697504] = 5031; + rayToBps[1000000012924789819608254383] = 5032; + rayToBps[1000000012926899235367797644] = 5033; + rayToBps[1000000012929008510812996659] = 5034; + rayToBps[1000000012931117645962517078] = 5035; + rayToBps[1000000012933226640835020822] = 5036; + rayToBps[1000000012935335495449166093] = 5037; + rayToBps[1000000012937444209823607369] = 5038; + rayToBps[1000000012939552783976995406] = 5039; + rayToBps[1000000012941661217927977241] = 5040; + rayToBps[1000000012943769511695196190] = 5041; + rayToBps[1000000012945877665297291852] = 5042; + rayToBps[1000000012947985678752900108] = 5043; + rayToBps[1000000012950093552080653122] = 5044; + rayToBps[1000000012952201285299179347] = 5045; + rayToBps[1000000012954308878427103514] = 5046; + rayToBps[1000000012956416331483046645] = 5047; + rayToBps[1000000012958523644485626051] = 5048; + rayToBps[1000000012960630817453455327] = 5049; + rayToBps[1000000012962737850405144363] = 5050; + rayToBps[1000000012964844743359299334] = 5051; + rayToBps[1000000012966951496334522711] = 5052; + rayToBps[1000000012969058109349413254] = 5053; + rayToBps[1000000012971164582422566020] = 5054; + rayToBps[1000000012973270915572572357] = 5055; + rayToBps[1000000012975377108818019910] = 5056; + rayToBps[1000000012977483162177492621] = 5057; + rayToBps[1000000012979589075669570729] = 5058; + rayToBps[1000000012981694849312830772] = 5059; + rayToBps[1000000012983800483125845583] = 5060; + rayToBps[1000000012985905977127184302] = 5061; + rayToBps[1000000012988011331335412367] = 5062; + rayToBps[1000000012990116545769091518] = 5063; + rayToBps[1000000012992221620446779799] = 5064; + rayToBps[1000000012994326555387031557] = 5065; + rayToBps[1000000012996431350608397447] = 5066; + rayToBps[1000000012998536006129424429] = 5067; + rayToBps[1000000013000640521968655768] = 5068; + rayToBps[1000000013002744898144631040] = 5069; + rayToBps[1000000013004849134675886130] = 5070; + rayToBps[1000000013006953231580953231] = 5071; + rayToBps[1000000013009057188878360849] = 5072; + rayToBps[1000000013011161006586633804] = 5073; + rayToBps[1000000013013264684724293223] = 5074; + rayToBps[1000000013015368223309856554] = 5075; + rayToBps[1000000013017471622361837555] = 5076; + rayToBps[1000000013019574881898746303] = 5077; + rayToBps[1000000013021678001939089190] = 5078; + rayToBps[1000000013023780982501368928] = 5079; + rayToBps[1000000013025883823604084547] = 5080; + rayToBps[1000000013027986525265731396] = 5081; + rayToBps[1000000013030089087504801146] = 5082; + rayToBps[1000000013032191510339781792] = 5083; + rayToBps[1000000013034293793789157646] = 5084; + rayToBps[1000000013036395937871409348] = 5085; + rayToBps[1000000013038497942605013865] = 5086; + rayToBps[1000000013040599808008444486] = 5087; + rayToBps[1000000013042701534100170826] = 5088; + rayToBps[1000000013044803120898658830] = 5089; + rayToBps[1000000013046904568422370773] = 5090; + rayToBps[1000000013049005876689765257] = 5091; + rayToBps[1000000013051107045719297215] = 5092; + rayToBps[1000000013053208075529417914] = 5093; + rayToBps[1000000013055308966138574949] = 5094; + rayToBps[1000000013057409717565212254] = 5095; + rayToBps[1000000013059510329827770095] = 5096; + rayToBps[1000000013061610802944685072] = 5097; + rayToBps[1000000013063711136934390123] = 5098; + rayToBps[1000000013065811331815314524] = 5099; + rayToBps[1000000013067911387605883890] = 5100; + rayToBps[1000000013070011304324520173] = 5101; + rayToBps[1000000013072111081989641667] = 5102; + rayToBps[1000000013074210720619663007] = 5103; + rayToBps[1000000013076310220232995171] = 5104; + rayToBps[1000000013078409580848045479] = 5105; + rayToBps[1000000013080508802483217595] = 5106; + rayToBps[1000000013082607885156911531] = 5107; + rayToBps[1000000013084706828887523642] = 5108; + rayToBps[1000000013086805633693446631] = 5109; + rayToBps[1000000013088904299593069551] = 5110; + rayToBps[1000000013091002826604777801] = 5111; + rayToBps[1000000013093101214746953133] = 5112; + rayToBps[1000000013095199464037973648] = 5113; + rayToBps[1000000013097297574496213800] = 5114; + rayToBps[1000000013099395546140044395] = 5115; + rayToBps[1000000013101493378987832595] = 5116; + rayToBps[1000000013103591073057941913] = 5117; + rayToBps[1000000013105688628368732223] = 5118; + rayToBps[1000000013107786044938559751] = 5119; + rayToBps[1000000013109883322785777084] = 5120; + rayToBps[1000000013111980461928733165] = 5121; + rayToBps[1000000013114077462385773300] = 5122; + rayToBps[1000000013116174324175239154] = 5123; + rayToBps[1000000013118271047315468752] = 5124; + rayToBps[1000000013120367631824796485] = 5125; + rayToBps[1000000013122464077721553103] = 5126; + rayToBps[1000000013124560385024065726] = 5127; + rayToBps[1000000013126656553750657835] = 5128; + rayToBps[1000000013128752583919649280] = 5129; + rayToBps[1000000013130848475549356277] = 5130; + rayToBps[1000000013132944228658091410] = 5131; + rayToBps[1000000013135039843264163635] = 5132; + rayToBps[1000000013137135319385878275] = 5133; + rayToBps[1000000013139230657041537026] = 5134; + rayToBps[1000000013141325856249437956] = 5135; + rayToBps[1000000013143420917027875507] = 5136; + rayToBps[1000000013145515839395140491] = 5137; + rayToBps[1000000013147610623369520102] = 5138; + rayToBps[1000000013149705268969297904] = 5139; + rayToBps[1000000013151799776212753840] = 5140; + rayToBps[1000000013153894145118164231] = 5141; + rayToBps[1000000013155988375703801779] = 5142; + rayToBps[1000000013158082467987935562] = 5143; + rayToBps[1000000013160176421988831041] = 5144; + rayToBps[1000000013162270237724750059] = 5145; + rayToBps[1000000013164363915213950840] = 5146; + rayToBps[1000000013166457454474687994] = 5147; + rayToBps[1000000013168550855525212514] = 5148; + rayToBps[1000000013170644118383771778] = 5149; + rayToBps[1000000013172737243068609553] = 5150; + rayToBps[1000000013174830229597965992] = 5151; + rayToBps[1000000013176923077990077635] = 5152; + rayToBps[1000000013179015788263177415] = 5153; + rayToBps[1000000013181108360435494653] = 5154; + rayToBps[1000000013183200794525255059] = 5155; + rayToBps[1000000013185293090550680741] = 5156; + rayToBps[1000000013187385248529990196] = 5157; + rayToBps[1000000013189477268481398315] = 5158; + rayToBps[1000000013191569150423116386] = 5159; + rayToBps[1000000013193660894373352093] = 5160; + rayToBps[1000000013195752500350309515] = 5161; + rayToBps[1000000013197843968372189132] = 5162; + rayToBps[1000000013199935298457187821] = 5163; + rayToBps[1000000013202026490623498857] = 5164; + rayToBps[1000000013204117544889311921] = 5165; + rayToBps[1000000013206208461272813091] = 5166; + rayToBps[1000000013208299239792184850] = 5167; + rayToBps[1000000013210389880465606084] = 5168; + rayToBps[1000000013212480383311252082] = 5169; + rayToBps[1000000013214570748347294544] = 5170; + rayToBps[1000000013216660975591901569] = 5171; + rayToBps[1000000013218751065063237670] = 5172; + rayToBps[1000000013220841016779463763] = 5173; + rayToBps[1000000013222930830758737177] = 5174; + rayToBps[1000000013225020507019211652] = 5175; + rayToBps[1000000013227110045579037336] = 5176; + rayToBps[1000000013229199446456360791] = 5177; + rayToBps[1000000013231288709669324991] = 5178; + rayToBps[1000000013233377835236069326] = 5179; + rayToBps[1000000013235466823174729599] = 5180; + rayToBps[1000000013237555673503438031] = 5181; + rayToBps[1000000013239644386240323257] = 5182; + rayToBps[1000000013241732961403510334] = 5183; + rayToBps[1000000013243821399011120734] = 5184; + rayToBps[1000000013245909699081272350] = 5185; + rayToBps[1000000013247997861632079496] = 5186; + rayToBps[1000000013250085886681652909] = 5187; + rayToBps[1000000013252173774248099746] = 5188; + rayToBps[1000000013254261524349523588] = 5189; + rayToBps[1000000013256349137004024442] = 5190; + rayToBps[1000000013258436612229698739] = 5191; + rayToBps[1000000013260523950044639336] = 5192; + rayToBps[1000000013262611150466935520] = 5193; + rayToBps[1000000013264698213514673002] = 5194; + rayToBps[1000000013266785139205933927] = 5195; + rayToBps[1000000013268871927558796866] = 5196; + rayToBps[1000000013270958578591336822] = 5197; + rayToBps[1000000013273045092321625231] = 5198; + rayToBps[1000000013275131468767729963] = 5199; + rayToBps[1000000013277217707947715318] = 5200; + rayToBps[1000000013279303809879642035] = 5201; + rayToBps[1000000013281389774581567286] = 5202; + rayToBps[1000000013283475602071544681] = 5203; + rayToBps[1000000013285561292367624266] = 5204; + rayToBps[1000000013287646845487852528] = 5205; + rayToBps[1000000013289732261450272392] = 5206; + rayToBps[1000000013291817540272923222] = 5207; + rayToBps[1000000013293902681973840827] = 5208; + rayToBps[1000000013295987686571057456] = 5209; + rayToBps[1000000013298072554082601799] = 5210; + rayToBps[1000000013300157284526498996] = 5211; + rayToBps[1000000013302241877920770626] = 5212; + rayToBps[1000000013304326334283434719] = 5213; + rayToBps[1000000013306410653632505749] = 5214; + rayToBps[1000000013308494835985994637] = 5215; + rayToBps[1000000013310578881361908756] = 5216; + rayToBps[1000000013312662789778251927] = 5217; + rayToBps[1000000013314746561253024422] = 5218; + rayToBps[1000000013316830195804222964] = 5219; + rayToBps[1000000013318913693449840730] = 5220; + rayToBps[1000000013320997054207867349] = 5221; + rayToBps[1000000013323080278096288904] = 5222; + rayToBps[1000000013325163365133087937] = 5223; + rayToBps[1000000013327246315336243441] = 5224; + rayToBps[1000000013329329128723730871] = 5225; + rayToBps[1000000013331411805313522137] = 5226; + rayToBps[1000000013333494345123585609] = 5227; + rayToBps[1000000013335576748171886118] = 5228; + rayToBps[1000000013337659014476384955] = 5229; + rayToBps[1000000013339741144055039872] = 5230; + rayToBps[1000000013341823136925805086] = 5231; + rayToBps[1000000013343904993106631276] = 5232; + rayToBps[1000000013345986712615465587] = 5233; + rayToBps[1000000013348068295470251626] = 5234; + rayToBps[1000000013350149741688929473] = 5235; + rayToBps[1000000013352231051289435670] = 5236; + rayToBps[1000000013354312224289703229] = 5237; + rayToBps[1000000013356393260707661631] = 5238; + rayToBps[1000000013358474160561236828] = 5239; + rayToBps[1000000013360554923868351244] = 5240; + rayToBps[1000000013362635550646923773] = 5241; + rayToBps[1000000013364716040914869783] = 5242; + rayToBps[1000000013366796394690101115] = 5243; + rayToBps[1000000013368876611990526086] = 5244; + rayToBps[1000000013370956692834049490] = 5245; + rayToBps[1000000013373036637238572595] = 5246; + rayToBps[1000000013375116445221993147] = 5247; + rayToBps[1000000013377196116802205372] = 5248; + rayToBps[1000000013379275651997099976] = 5249; + rayToBps[1000000013381355050824564143] = 5250; + rayToBps[1000000013383434313302481540] = 5251; + rayToBps[1000000013385513439448732314] = 5252; + rayToBps[1000000013387592429281193100] = 5253; + rayToBps[1000000013389671282817737012] = 5254; + rayToBps[1000000013391750000076233652] = 5255; + rayToBps[1000000013393828581074549107] = 5256; + rayToBps[1000000013395907025830545951] = 5257; + rayToBps[1000000013397985334362083244] = 5258; + rayToBps[1000000013400063506687016538] = 5259; + rayToBps[1000000013402141542823197873] = 5260; + rayToBps[1000000013404219442788475779] = 5261; + rayToBps[1000000013406297206600695278] = 5262; + rayToBps[1000000013408374834277697885] = 5263; + rayToBps[1000000013410452325837321606] = 5264; + rayToBps[1000000013412529681297400945] = 5265; + rayToBps[1000000013414606900675766898] = 5266; + rayToBps[1000000013416683983990246957] = 5267; + rayToBps[1000000013418760931258665113] = 5268; + rayToBps[1000000013420837742498841855] = 5269; + rayToBps[1000000013422914417728594168] = 5270; + rayToBps[1000000013424990956965735539] = 5271; + rayToBps[1000000013427067360228075956] = 5272; + rayToBps[1000000013429143627533421906] = 5273; + rayToBps[1000000013431219758899576381] = 5274; + rayToBps[1000000013433295754344338876] = 5275; + rayToBps[1000000013435371613885505389] = 5276; + rayToBps[1000000013437447337540868424] = 5277; + rayToBps[1000000013439522925328216993] = 5278; + rayToBps[1000000013441598377265336611] = 5279; + rayToBps[1000000013443673693370009304] = 5280; + rayToBps[1000000013445748873660013605] = 5281; + rayToBps[1000000013447823918153124560] = 5282; + rayToBps[1000000013449898826867113722] = 5283; + rayToBps[1000000013451973599819749157] = 5284; + rayToBps[1000000013454048237028795446] = 5285; + rayToBps[1000000013456122738512013678] = 5286; + rayToBps[1000000013458197104287161462] = 5287; + rayToBps[1000000013460271334371992918] = 5288; + rayToBps[1000000013462345428784258685] = 5289; + rayToBps[1000000013464419387541705919] = 5290; + rayToBps[1000000013466493210662078291] = 5291; + rayToBps[1000000013468566898163115994] = 5292; + rayToBps[1000000013470640450062555739] = 5293; + rayToBps[1000000013472713866378130761] = 5294; + rayToBps[1000000013474787147127570811] = 5295; + rayToBps[1000000013476860292328602168] = 5296; + rayToBps[1000000013478933301998947631] = 5297; + rayToBps[1000000013481006176156326525] = 5298; + rayToBps[1000000013483078914818454700] = 5299; + rayToBps[1000000013485151518003044532] = 5300; + rayToBps[1000000013487223985727804923] = 5301; + rayToBps[1000000013489296318010441307] = 5302; + rayToBps[1000000013491368514868655641] = 5303; + rayToBps[1000000013493440576320146417] = 5304; + rayToBps[1000000013495512502382608654] = 5305; + rayToBps[1000000013497584293073733906] = 5306; + rayToBps[1000000013499655948411210256] = 5307; + rayToBps[1000000013501727468412722324] = 5308; + rayToBps[1000000013503798853095951261] = 5309; + rayToBps[1000000013505870102478574756] = 5310; + rayToBps[1000000013507941216578267032] = 5311; + rayToBps[1000000013510012195412698851] = 5312; + rayToBps[1000000013512083038999537512] = 5313; + rayToBps[1000000013514153747356446852] = 5314; + rayToBps[1000000013516224320501087249] = 5315; + rayToBps[1000000013518294758451115623] = 5316; + rayToBps[1000000013520365061224185433] = 5317; + rayToBps[1000000013522435228837946681] = 5318; + rayToBps[1000000013524505261310045913] = 5319; + rayToBps[1000000013526575158658126219] = 5320; + rayToBps[1000000013528644920899827235] = 5321; + rayToBps[1000000013530714548052785142] = 5322; + rayToBps[1000000013532784040134632670] = 5323; + rayToBps[1000000013534853397162999093] = 5324; + rayToBps[1000000013536922619155510237] = 5325; + rayToBps[1000000013538991706129788478] = 5326; + rayToBps[1000000013541060658103452740] = 5327; + rayToBps[1000000013543129475094118502] = 5328; + rayToBps[1000000013545198157119397791] = 5329; + rayToBps[1000000013547266704196899191] = 5330; + rayToBps[1000000013549335116344227839] = 5331; + rayToBps[1000000013551403393578985427] = 5332; + rayToBps[1000000013553471535918770203] = 5333; + rayToBps[1000000013555539543381176971] = 5334; + rayToBps[1000000013557607415983797096] = 5335; + rayToBps[1000000013559675153744218497] = 5336; + rayToBps[1000000013561742756680025656] = 5337; + rayToBps[1000000013563810224808799615] = 5338; + rayToBps[1000000013565877558148117977] = 5339; + rayToBps[1000000013567944756715554906] = 5340; + rayToBps[1000000013570011820528681131] = 5341; + rayToBps[1000000013572078749605063945] = 5342; + rayToBps[1000000013574145543962267205] = 5343; + rayToBps[1000000013576212203617851334] = 5344; + rayToBps[1000000013578278728589373323] = 5345; + rayToBps[1000000013580345118894386729] = 5346; + rayToBps[1000000013582411374550441678] = 5347; + rayToBps[1000000013584477495575084867] = 5348; + rayToBps[1000000013586543481985859560] = 5349; + rayToBps[1000000013588609333800305597] = 5350; + rayToBps[1000000013590675051035959386] = 5351; + rayToBps[1000000013592740633710353909] = 5352; + rayToBps[1000000013594806081841018723] = 5353; + rayToBps[1000000013596871395445479960] = 5354; + rayToBps[1000000013598936574541260325] = 5355; + rayToBps[1000000013601001619145879103] = 5356; + rayToBps[1000000013603066529276852154] = 5357; + rayToBps[1000000013605131304951691920] = 5358; + rayToBps[1000000013607195946187907415] = 5359; + rayToBps[1000000013609260453003004241] = 5360; + rayToBps[1000000013611324825414484577] = 5361; + rayToBps[1000000013613389063439847186] = 5362; + rayToBps[1000000013615453167096587411] = 5363; + rayToBps[1000000013617517136402197181] = 5364; + rayToBps[1000000013619580971374165008] = 5365; + rayToBps[1000000013621644672029975992] = 5366; + rayToBps[1000000013623708238387111817] = 5367; + rayToBps[1000000013625771670463050755] = 5368; + rayToBps[1000000013627834968275267666] = 5369; + rayToBps[1000000013629898131841234000] = 5370; + rayToBps[1000000013631961161178417796] = 5371; + rayToBps[1000000013634024056304283684] = 5372; + rayToBps[1000000013636086817236292885] = 5373; + rayToBps[1000000013638149443991903215] = 5374; + rayToBps[1000000013640211936588569081] = 5375; + rayToBps[1000000013642274295043741485] = 5376; + rayToBps[1000000013644336519374868025] = 5377; + rayToBps[1000000013646398609599392894] = 5378; + rayToBps[1000000013648460565734756883] = 5379; + rayToBps[1000000013650522387798397382] = 5380; + rayToBps[1000000013652584075807748376] = 5381; + rayToBps[1000000013654645629780240453] = 5382; + rayToBps[1000000013656707049733300801] = 5383; + rayToBps[1000000013658768335684353209] = 5384; + rayToBps[1000000013660829487650818068] = 5385; + rayToBps[1000000013662890505650112373] = 5386; + rayToBps[1000000013664951389699649722] = 5387; + rayToBps[1000000013667012139816840321] = 5388; + rayToBps[1000000013669072756019090977] = 5389; + rayToBps[1000000013671133238323805108] = 5390; + rayToBps[1000000013673193586748382737] = 5391; + rayToBps[1000000013675253801310220496] = 5392; + rayToBps[1000000013677313882026711628] = 5393; + rayToBps[1000000013679373828915245986] = 5394; + rayToBps[1000000013681433641993210032] = 5395; + rayToBps[1000000013683493321277986841] = 5396; + rayToBps[1000000013685552866786956102] = 5397; + rayToBps[1000000013687612278537494116] = 5398; + rayToBps[1000000013689671556546973802] = 5399; + rayToBps[1000000013691730700832764691] = 5400; + rayToBps[1000000013693789711412232932] = 5401; + rayToBps[1000000013695848588302741289] = 5402; + rayToBps[1000000013697907331521649149] = 5403; + rayToBps[1000000013699965941086312515] = 5404; + rayToBps[1000000013702024417014084009] = 5405; + rayToBps[1000000013704082759322312876] = 5406; + rayToBps[1000000013706140968028344981] = 5407; + rayToBps[1000000013708199043149522812] = 5408; + rayToBps[1000000013710256984703185483] = 5409; + rayToBps[1000000013712314792706668728] = 5410; + rayToBps[1000000013714372467177304910] = 5411; + rayToBps[1000000013716430008132423015] = 5412; + rayToBps[1000000013718487415589348659] = 5413; + rayToBps[1000000013720544689565404082] = 5414; + rayToBps[1000000013722601830077908157] = 5415; + rayToBps[1000000013724658837144176384] = 5416; + rayToBps[1000000013726715710781520893] = 5417; + rayToBps[1000000013728772451007250448] = 5418; + rayToBps[1000000013730829057838670442] = 5419; + rayToBps[1000000013732885531293082904] = 5420; + rayToBps[1000000013734941871387786495] = 5421; + rayToBps[1000000013736998078140076511] = 5422; + rayToBps[1000000013739054151567244885] = 5423; + rayToBps[1000000013741110091686580185] = 5424; + rayToBps[1000000013743165898515367617] = 5425; + rayToBps[1000000013745221572070889027] = 5426; + rayToBps[1000000013747277112370422896] = 5427; + rayToBps[1000000013749332519431244349] = 5428; + rayToBps[1000000013751387793270625152] = 5429; + rayToBps[1000000013753442933905833710] = 5430; + rayToBps[1000000013755497941354135072] = 5431; + rayToBps[1000000013757552815632790932] = 5432; + rayToBps[1000000013759607556759059626] = 5433; + rayToBps[1000000013761662164750196136] = 5434; + rayToBps[1000000013763716639623452091] = 5435; + rayToBps[1000000013765770981396075767] = 5436; + rayToBps[1000000013767825190085312088] = 5437; + rayToBps[1000000013769879265708402624] = 5438; + rayToBps[1000000013771933208282585599] = 5439; + rayToBps[1000000013773987017825095883] = 5440; + rayToBps[1000000013776040694353165002] = 5441; + rayToBps[1000000013778094237884021131] = 5442; + rayToBps[1000000013780147648434889099] = 5443; + rayToBps[1000000013782200926022990388] = 5444; + rayToBps[1000000013784254070665543138] = 5445; + rayToBps[1000000013786307082379762141] = 5446; + rayToBps[1000000013788359961182858847] = 5447; + rayToBps[1000000013790412707092041364] = 5448; + rayToBps[1000000013792465320124514458] = 5449; + rayToBps[1000000013794517800297479554] = 5450; + rayToBps[1000000013796570147628134736] = 5451; + rayToBps[1000000013798622362133674751] = 5452; + rayToBps[1000000013800674443831291006] = 5453; + rayToBps[1000000013802726392738171571] = 5454; + rayToBps[1000000013804778208871501181] = 5455; + rayToBps[1000000013806829892248461232] = 5456; + rayToBps[1000000013808881442886229789] = 5457; + rayToBps[1000000013810932860801981581] = 5458; + rayToBps[1000000013812984146012888004] = 5459; + rayToBps[1000000013815035298536117122] = 5460; + rayToBps[1000000013817086318388833668] = 5461; + rayToBps[1000000013819137205588199044] = 5462; + rayToBps[1000000013821187960151371324] = 5463; + rayToBps[1000000013823238582095505250] = 5464; + rayToBps[1000000013825289071437752239] = 5465; + rayToBps[1000000013827339428195260380] = 5466; + rayToBps[1000000013829389652385174435] = 5467; + rayToBps[1000000013831439744024635842] = 5468; + rayToBps[1000000013833489703130782714] = 5469; + rayToBps[1000000013835539529720749841] = 5470; + rayToBps[1000000013837589223811668689] = 5471; + rayToBps[1000000013839638785420667403] = 5472; + rayToBps[1000000013841688214564870807] = 5473; + rayToBps[1000000013843737511261400404] = 5474; + rayToBps[1000000013845786675527374380] = 5475; + rayToBps[1000000013847835707379907599] = 5476; + rayToBps[1000000013849884606836111609] = 5477; + rayToBps[1000000013851933373913094644] = 5478; + rayToBps[1000000013853982008627961619] = 5479; + rayToBps[1000000013856030510997814133] = 5480; + rayToBps[1000000013858078881039750473] = 5481; + rayToBps[1000000013860127118770865614] = 5482; + rayToBps[1000000013862175224208251215] = 5483; + rayToBps[1000000013864223197368995626] = 5484; + rayToBps[1000000013866271038270183886] = 5485; + rayToBps[1000000013868318746928897723] = 5486; + rayToBps[1000000013870366323362215556] = 5487; + rayToBps[1000000013872413767587212497] = 5488; + rayToBps[1000000013874461079620960351] = 5489; + rayToBps[1000000013876508259480527614] = 5490; + rayToBps[1000000013878555307182979479] = 5491; + rayToBps[1000000013880602222745377833] = 5492; + rayToBps[1000000013882649006184781260] = 5493; + rayToBps[1000000013884695657518245039] = 5494; + rayToBps[1000000013886742176762821150] = 5495; + rayToBps[1000000013888788563935558267] = 5496; + rayToBps[1000000013890834819053501770] = 5497; + rayToBps[1000000013892880942133693733] = 5498; + rayToBps[1000000013894926933193172935] = 5499; + rayToBps[1000000013896972792248974855] = 5500; + rayToBps[1000000013899018519318131677] = 5501; + rayToBps[1000000013901064114417672287] = 5502; + rayToBps[1000000013903109577564622276] = 5503; + rayToBps[1000000013905154908776003941] = 5504; + rayToBps[1000000013907200108068836286] = 5505; + rayToBps[1000000013909245175460135020] = 5506; + rayToBps[1000000013911290110966912561] = 5507; + rayToBps[1000000013913334914606178038] = 5508; + rayToBps[1000000013915379586394937285] = 5509; + rayToBps[1000000013917424126350192852] = 5510; + rayToBps[1000000013919468534488943996] = 5511; + rayToBps[1000000013921512810828186689] = 5512; + rayToBps[1000000013923556955384913616] = 5513; + rayToBps[1000000013925600968176114173] = 5514; + rayToBps[1000000013927644849218774474] = 5515; + rayToBps[1000000013929688598529877347] = 5516; + rayToBps[1000000013931732216126402338] = 5517; + rayToBps[1000000013933775702025325709] = 5518; + rayToBps[1000000013935819056243620441] = 5519; + rayToBps[1000000013937862278798256232] = 5520; + rayToBps[1000000013939905369706199504] = 5521; + rayToBps[1000000013941948328984413395] = 5522; + rayToBps[1000000013943991156649857768] = 5523; + rayToBps[1000000013946033852719489207] = 5524; + rayToBps[1000000013948076417210261020] = 5525; + rayToBps[1000000013950118850139123237] = 5526; + rayToBps[1000000013952161151523022616] = 5527; + rayToBps[1000000013954203321378902639] = 5528; + rayToBps[1000000013956245359723703515] = 5529; + rayToBps[1000000013958287266574362180] = 5530; + rayToBps[1000000013960329041947812299] = 5531; + rayToBps[1000000013962370685860984266] = 5532; + rayToBps[1000000013964412198330805204] = 5533; + rayToBps[1000000013966453579374198970] = 5534; + rayToBps[1000000013968494829008086149] = 5535; + rayToBps[1000000013970535947249384059] = 5536; + rayToBps[1000000013972576934115006754] = 5537; + rayToBps[1000000013974617789621865021] = 5538; + rayToBps[1000000013976658513786866380] = 5539; + rayToBps[1000000013978699106626915089] = 5540; + rayToBps[1000000013980739568158912143] = 5541; + rayToBps[1000000013982779898399755273] = 5542; + rayToBps[1000000013984820097366338950] = 5543; + rayToBps[1000000013986860165075554382] = 5544; + rayToBps[1000000013988900101544289521] = 5545; + rayToBps[1000000013990939906789429055] = 5546; + rayToBps[1000000013992979580827854418] = 5547; + rayToBps[1000000013995019123676443785] = 5548; + rayToBps[1000000013997058535352072073] = 5549; + rayToBps[1000000013999097815871610946] = 5550; + rayToBps[1000000014001136965251928811] = 5551; + rayToBps[1000000014003175983509890823] = 5552; + rayToBps[1000000014005214870662358881] = 5553; + rayToBps[1000000014007253626726191632] = 5554; + rayToBps[1000000014009292251718244476] = 5555; + rayToBps[1000000014011330745655369557] = 5556; + rayToBps[1000000014013369108554415771] = 5557; + rayToBps[1000000014015407340432228765] = 5558; + rayToBps[1000000014017445441305650938] = 5559; + rayToBps[1000000014019483411191521442] = 5560; + rayToBps[1000000014021521250106676181] = 5561; + rayToBps[1000000014023558958067947815] = 5562; + rayToBps[1000000014025596535092165759] = 5563; + rayToBps[1000000014027633981196156184] = 5564; + rayToBps[1000000014029671296396742013] = 5565; + rayToBps[1000000014031708480710742936] = 5566; + rayToBps[1000000014033745534154975394] = 5567; + rayToBps[1000000014035782456746252590] = 5568; + rayToBps[1000000014037819248501384486] = 5569; + rayToBps[1000000014039855909437177808] = 5570; + rayToBps[1000000014041892439570436040] = 5571; + rayToBps[1000000014043928838917959430] = 5572; + rayToBps[1000000014045965107496544991] = 5573; + rayToBps[1000000014048001245322986499] = 5574; + rayToBps[1000000014050037252414074493] = 5575; + rayToBps[1000000014052073128786596283] = 5576; + rayToBps[1000000014054108874457335942] = 5577; + rayToBps[1000000014056144489443074311] = 5578; + rayToBps[1000000014058179973760589001] = 5579; + rayToBps[1000000014060215327426654391] = 5580; + rayToBps[1000000014062250550458041631] = 5581; + rayToBps[1000000014064285642871518639] = 5582; + rayToBps[1000000014066320604683850111] = 5583; + rayToBps[1000000014068355435911797509] = 5584; + rayToBps[1000000014070390136572119073] = 5585; + rayToBps[1000000014072424706681569814] = 5586; + rayToBps[1000000014074459146256901521] = 5587; + rayToBps[1000000014076493455314862758] = 5588; + rayToBps[1000000014078527633872198862] = 5589; + rayToBps[1000000014080561681945651954] = 5590; + rayToBps[1000000014082595599551960930] = 5591; + rayToBps[1000000014084629386707861464] = 5592; + rayToBps[1000000014086663043430086012] = 5593; + rayToBps[1000000014088696569735363811] = 5594; + rayToBps[1000000014090729965640420880] = 5595; + rayToBps[1000000014092763231161980018] = 5596; + rayToBps[1000000014094796366316760809] = 5597; + rayToBps[1000000014096829371121479623] = 5598; + rayToBps[1000000014098862245592849610] = 5599; + rayToBps[1000000014100894989747580713] = 5600; + rayToBps[1000000014102927603602379655] = 5601; + rayToBps[1000000014104960087173949949] = 5602; + rayToBps[1000000014106992440478991899] = 5603; + rayToBps[1000000014109024663534202592] = 5604; + rayToBps[1000000014111056756356275911] = 5605; + rayToBps[1000000014113088718961902527] = 5606; + rayToBps[1000000014115120551367769903] = 5607; + rayToBps[1000000014117152253590562293] = 5608; + rayToBps[1000000014119183825646960746] = 5609; + rayToBps[1000000014121215267553643106] = 5610; + rayToBps[1000000014123246579327284009] = 5611; + rayToBps[1000000014125277760984554889] = 5612; + rayToBps[1000000014127308812542123975] = 5613; + rayToBps[1000000014129339734016656294] = 5614; + rayToBps[1000000014131370525424813672] = 5615; + rayToBps[1000000014133401186783254733] = 5616; + rayToBps[1000000014135431718108634901] = 5617; + rayToBps[1000000014137462119417606400] = 5618; + rayToBps[1000000014139492390726818256] = 5619; + rayToBps[1000000014141522532052916298] = 5620; + rayToBps[1000000014143552543412543158] = 5621; + rayToBps[1000000014145582424822338270] = 5622; + rayToBps[1000000014147612176298937873] = 5623; + rayToBps[1000000014149641797858975016] = 5624; + rayToBps[1000000014151671289519079548] = 5625; + rayToBps[1000000014153700651295878130] = 5626; + rayToBps[1000000014155729883205994226] = 5627; + rayToBps[1000000014157758985266048116] = 5628; + rayToBps[1000000014159787957492656883] = 5629; + rayToBps[1000000014161816799902434423] = 5630; + rayToBps[1000000014163845512511991443] = 5631; + rayToBps[1000000014165874095337935463] = 5632; + rayToBps[1000000014167902548396870816] = 5633; + rayToBps[1000000014169930871705398646] = 5634; + rayToBps[1000000014171959065280116914] = 5635; + rayToBps[1000000014173987129137620396] = 5636; + rayToBps[1000000014176015063294500683] = 5637; + rayToBps[1000000014178042867767346186] = 5638; + rayToBps[1000000014180070542572742128] = 5639; + rayToBps[1000000014182098087727270558] = 5640; + rayToBps[1000000014184125503247510337] = 5641; + rayToBps[1000000014186152789150037153] = 5642; + rayToBps[1000000014188179945451423510] = 5643; + rayToBps[1000000014190206972168238736] = 5644; + rayToBps[1000000014192233869317048980] = 5645; + rayToBps[1000000014194260636914417219] = 5646; + rayToBps[1000000014196287274976903248] = 5647; + rayToBps[1000000014198313783521063691] = 5648; + rayToBps[1000000014200340162563451997] = 5649; + rayToBps[1000000014202366412120618444] = 5650; + rayToBps[1000000014204392532209110132] = 5651; + rayToBps[1000000014206418522845470993] = 5652; + rayToBps[1000000014208444384046241790] = 5653; + rayToBps[1000000014210470115827960111] = 5654; + rayToBps[1000000014212495718207160381] = 5655; + rayToBps[1000000014214521191200373850] = 5656; + rayToBps[1000000014216546534824128603] = 5657; + rayToBps[1000000014218571749094949561] = 5658; + rayToBps[1000000014220596834029358476] = 5659; + rayToBps[1000000014222621789643873935] = 5660; + rayToBps[1000000014224646615955011361] = 5661; + rayToBps[1000000014226671312979283014] = 5662; + rayToBps[1000000014228695880733197990] = 5663; + rayToBps[1000000014230720319233262225] = 5664; + rayToBps[1000000014232744628495978491] = 5665; + rayToBps[1000000014234768808537846403] = 5666; + rayToBps[1000000014236792859375362413] = 5667; + rayToBps[1000000014238816781025019818] = 5668; + rayToBps[1000000014240840573503308754] = 5669; + rayToBps[1000000014242864236826716200] = 5670; + rayToBps[1000000014244887771011725981] = 5671; + rayToBps[1000000014246911176074818766] = 5672; + rayToBps[1000000014248934452032472066] = 5673; + rayToBps[1000000014250957598901160243] = 5674; + rayToBps[1000000014252980616697354502] = 5675; + rayToBps[1000000014255003505437522899] = 5676; + rayToBps[1000000014257026265138130334] = 5677; + rayToBps[1000000014259048895815638562] = 5678; + rayToBps[1000000014261071397486506182] = 5679; + rayToBps[1000000014263093770167188651] = 5680; + rayToBps[1000000014265116013874138270] = 5681; + rayToBps[1000000014267138128623804199] = 5682; + rayToBps[1000000014269160114432632448] = 5683; + rayToBps[1000000014271181971317065881] = 5684; + rayToBps[1000000014273203699293544220] = 5685; + rayToBps[1000000014275225298378504039] = 5686; + rayToBps[1000000014277246768588378769] = 5687; + rayToBps[1000000014279268109939598702] = 5688; + rayToBps[1000000014281289322448590984] = 5689; + rayToBps[1000000014283310406131779623] = 5690; + rayToBps[1000000014285331361005585484] = 5691; + rayToBps[1000000014287352187086426294] = 5692; + rayToBps[1000000014289372884390716643] = 5693; + rayToBps[1000000014291393452934867978] = 5694; + rayToBps[1000000014293413892735288616] = 5695; + rayToBps[1000000014295434203808383731] = 5696; + rayToBps[1000000014297454386170555368] = 5697; + rayToBps[1000000014299474439838202432] = 5698; + rayToBps[1000000014301494364827720695] = 5699; + rayToBps[1000000014303514161155502800] = 5700; + rayToBps[1000000014305533828837938253] = 5701; + rayToBps[1000000014307553367891413431] = 5702; + rayToBps[1000000014309572778332311579] = 5703; + rayToBps[1000000014311592060177012815] = 5704; + rayToBps[1000000014313611213441894123] = 5705; + rayToBps[1000000014315630238143329364] = 5706; + rayToBps[1000000014317649134297689268] = 5707; + rayToBps[1000000014319667901921341438] = 5708; + rayToBps[1000000014321686541030650356] = 5709; + rayToBps[1000000014323705051641977373] = 5710; + rayToBps[1000000014325723433771680719] = 5711; + rayToBps[1000000014327741687436115500] = 5712; + rayToBps[1000000014329759812651633698] = 5713; + rayToBps[1000000014331777809434584175] = 5714; + rayToBps[1000000014333795677801312670] = 5715; + rayToBps[1000000014335813417768161804] = 5716; + rayToBps[1000000014337831029351471077] = 5717; + rayToBps[1000000014339848512567576870] = 5718; + rayToBps[1000000014341865867432812447] = 5719; + rayToBps[1000000014343883093963507953] = 5720; + rayToBps[1000000014345900192175990420] = 5721; + rayToBps[1000000014347917162086583762] = 5722; + rayToBps[1000000014349934003711608778] = 5723; + rayToBps[1000000014351950717067383155] = 5724; + rayToBps[1000000014353967302170221464] = 5725; + rayToBps[1000000014355983759036435166] = 5726; + rayToBps[1000000014358000087682332611] = 5727; + rayToBps[1000000014360016288124219035] = 5728; + rayToBps[1000000014362032360378396567] = 5729; + rayToBps[1000000014364048304461164225] = 5730; + rayToBps[1000000014366064120388817920] = 5731; + rayToBps[1000000014368079808177650454] = 5732; + rayToBps[1000000014370095367843951523] = 5733; + rayToBps[1000000014372110799404007716] = 5734; + rayToBps[1000000014374126102874102518] = 5735; + rayToBps[1000000014376141278270516310] = 5736; + rayToBps[1000000014378156325609526367] = 5737; + rayToBps[1000000014380171244907406862] = 5738; + rayToBps[1000000014382186036180428868] = 5739; + rayToBps[1000000014384200699444860352] = 5740; + rayToBps[1000000014386215234716966187] = 5741; + rayToBps[1000000014388229642013008140] = 5742; + rayToBps[1000000014390243921349244884] = 5743; + rayToBps[1000000014392258072741931989] = 5744; + rayToBps[1000000014394272096207321932] = 5745; + rayToBps[1000000014396285991761664091] = 5746; + rayToBps[1000000014398299759421204750] = 5747; + rayToBps[1000000014400313399202187095] = 5748; + rayToBps[1000000014402326911120851219] = 5749; + rayToBps[1000000014404340295193434124] = 5750; + rayToBps[1000000014406353551436169717] = 5751; + rayToBps[1000000014408366679865288813] = 5752; + rayToBps[1000000014410379680497019136] = 5753; + rayToBps[1000000014412392553347585321] = 5754; + rayToBps[1000000014414405298433208913] = 5755; + rayToBps[1000000014416417915770108367] = 5756; + rayToBps[1000000014418430405374499050] = 5757; + rayToBps[1000000014420442767262593245] = 5758; + rayToBps[1000000014422455001450600144] = 5759; + rayToBps[1000000014424467107954725858] = 5760; + rayToBps[1000000014426479086791173409] = 5761; + rayToBps[1000000014428490937976142739] = 5762; + rayToBps[1000000014430502661525830703] = 5763; + rayToBps[1000000014432514257456431075] = 5764; + rayToBps[1000000014434525725784134548] = 5765; + rayToBps[1000000014436537066525128734] = 5766; + rayToBps[1000000014438548279695598164] = 5767; + rayToBps[1000000014440559365311724289] = 5768; + rayToBps[1000000014442570323389685485] = 5769; + rayToBps[1000000014444581153945657045] = 5770; + rayToBps[1000000014446591856995811191] = 5771; + rayToBps[1000000014448602432556317062] = 5772; + rayToBps[1000000014450612880643340727] = 5773; + rayToBps[1000000014452623201273045178] = 5774; + rayToBps[1000000014454633394461590334] = 5775; + rayToBps[1000000014456643460225133039] = 5776; + rayToBps[1000000014458653398579827068] = 5777; + rayToBps[1000000014460663209541823120] = 5778; + rayToBps[1000000014462672893127268829] = 5779; + rayToBps[1000000014464682449352308754] = 5780; + rayToBps[1000000014466691878233084386] = 5781; + rayToBps[1000000014468701179785734150] = 5782; + rayToBps[1000000014470710354026393400] = 5783; + rayToBps[1000000014472719400971194424] = 5784; + rayToBps[1000000014474728320636266446] = 5785; + rayToBps[1000000014476737113037735623] = 5786; + rayToBps[1000000014478745778191725047] = 5787; + rayToBps[1000000014480754316114354747] = 5788; + rayToBps[1000000014482762726821741689] = 5789; + rayToBps[1000000014484771010329999776] = 5790; + rayToBps[1000000014486779166655239853] = 5791; + rayToBps[1000000014488787195813569697] = 5792; + rayToBps[1000000014490795097821094034] = 5793; + rayToBps[1000000014492802872693914523] = 5794; + rayToBps[1000000014494810520448129771] = 5795; + rayToBps[1000000014496818041099835323] = 5796; + rayToBps[1000000014498825434665123670] = 5797; + rayToBps[1000000014500832701160084244] = 5798; + rayToBps[1000000014502839840600803425] = 5799; + rayToBps[1000000014504846853003364537] = 5800; + rayToBps[1000000014506853738383847849] = 5801; + rayToBps[1000000014508860496758330582] = 5802; + rayToBps[1000000014510867128142886896] = 5803; + rayToBps[1000000014512873632553587910] = 5804; + rayToBps[1000000014514880010006501685] = 5805; + rayToBps[1000000014516886260517693233] = 5806; + rayToBps[1000000014518892384103224522] = 5807; + rayToBps[1000000014520898380779154465] = 5808; + rayToBps[1000000014522904250561538932] = 5809; + rayToBps[1000000014524909993466430745] = 5810; + rayToBps[1000000014526915609509879680] = 5811; + rayToBps[1000000014528921098707932466] = 5812; + rayToBps[1000000014530926461076632791] = 5813; + rayToBps[1000000014532931696632021298] = 5814; + rayToBps[1000000014534936805390135584] = 5815; + rayToBps[1000000014536941787367010209] = 5816; + rayToBps[1000000014538946642578676689] = 5817; + rayToBps[1000000014540951371041163498] = 5818; + rayToBps[1000000014542955972770496074] = 5819; + rayToBps[1000000014544960447782696812] = 5820; + rayToBps[1000000014546964796093785070] = 5821; + rayToBps[1000000014548969017719777170] = 5822; + rayToBps[1000000014550973112676686396] = 5823; + rayToBps[1000000014552977080980522997] = 5824; + rayToBps[1000000014554980922647294184] = 5825; + rayToBps[1000000014556984637693004137] = 5826; + rayToBps[1000000014558988226133654001] = 5827; + rayToBps[1000000014560991687985241886] = 5828; + rayToBps[1000000014562995023263762875] = 5829; + rayToBps[1000000014564998231985209012] = 5830; + rayToBps[1000000014567001314165569320] = 5831; + rayToBps[1000000014569004269820829782] = 5832; + rayToBps[1000000014571007098966973360] = 5833; + rayToBps[1000000014573009801619979984] = 5834; + rayToBps[1000000014575012377795826556] = 5835; + rayToBps[1000000014577014827510486953] = 5836; + rayToBps[1000000014579017150779932024] = 5837; + rayToBps[1000000014581019347620129595] = 5838; + rayToBps[1000000014583021418047044467] = 5839; + rayToBps[1000000014585023362076638415] = 5840; + rayToBps[1000000014587025179724870195] = 5841; + rayToBps[1000000014589026871007695536] = 5842; + rayToBps[1000000014591028435941067149] = 5843; + rayToBps[1000000014593029874540934724] = 5844; + rayToBps[1000000014595031186823244930] = 5845; + rayToBps[1000000014597032372803941418] = 5846; + rayToBps[1000000014599033432498964818] = 5847; + rayToBps[1000000014601034365924252746] = 5848; + rayToBps[1000000014603035173095739799] = 5849; + rayToBps[1000000014605035854029357558] = 5850; + rayToBps[1000000014607036408741034590] = 5851; + rayToBps[1000000014609036837246696444] = 5852; + rayToBps[1000000014611037139562265661] = 5853; + rayToBps[1000000014613037315703661762] = 5854; + rayToBps[1000000014615037365686801262] = 5855; + rayToBps[1000000014617037289527597660] = 5856; + rayToBps[1000000014619037087241961446] = 5857; + rayToBps[1000000014621036758845800100] = 5858; + rayToBps[1000000014623036304355018094] = 5859; + rayToBps[1000000014625035723785516888] = 5860; + rayToBps[1000000014627035017153194937] = 5861; + rayToBps[1000000014629034184473947689] = 5862; + rayToBps[1000000014631033225763667584] = 5863; + rayToBps[1000000014633032141038244058] = 5864; + rayToBps[1000000014635030930313563542] = 5865; + rayToBps[1000000014637029593605509464] = 5866; + rayToBps[1000000014639028130929962246] = 5867; + rayToBps[1000000014641026542302799310] = 5868; + rayToBps[1000000014643024827739895076] = 5869; + rayToBps[1000000014645022987257120962] = 5870; + rayToBps[1000000014647021020870345387] = 5871; + rayToBps[1000000014649018928595433770] = 5872; + rayToBps[1000000014651016710448248531] = 5873; + rayToBps[1000000014653014366444649093] = 5874; + rayToBps[1000000014655011896600491882] = 5875; + rayToBps[1000000014657009300931630326] = 5876; + rayToBps[1000000014659006579453914859] = 5877; + rayToBps[1000000014661003732183192919] = 5878; + rayToBps[1000000014663000759135308949] = 5879; + rayToBps[1000000014664997660326104403] = 5880; + rayToBps[1000000014666994435771417736] = 5881; + rayToBps[1000000014668991085487084417] = 5882; + rayToBps[1000000014670987609488936922] = 5883; + rayToBps[1000000014672984007792804732] = 5884; + rayToBps[1000000014674980280414514346] = 5885; + rayToBps[1000000014676976427369889269] = 5886; + rayToBps[1000000014678972448674750021] = 5887; + rayToBps[1000000014680968344344914131] = 5888; + rayToBps[1000000014682964114396196144] = 5889; + rayToBps[1000000014684959758844407618] = 5890; + rayToBps[1000000014686955277705357128] = 5891; + rayToBps[1000000014688950670994850263] = 5892; + rayToBps[1000000014690945938728689628] = 5893; + rayToBps[1000000014692941080922674845] = 5894; + rayToBps[1000000014694936097592602556] = 5895; + rayToBps[1000000014696930988754266420] = 5896; + rayToBps[1000000014698925754423457115] = 5897; + rayToBps[1000000014700920394615962341] = 5898; + rayToBps[1000000014702914909347566817] = 5899; + rayToBps[1000000014704909298634052283] = 5900; + rayToBps[1000000014706903562491197505] = 5901; + rayToBps[1000000014708897700934778270] = 5902; + rayToBps[1000000014710891713980567389] = 5903; + rayToBps[1000000014712885601644334694] = 5904; + rayToBps[1000000014714879363941847051] = 5905; + rayToBps[1000000014716873000888868344] = 5906; + rayToBps[1000000014718866512501159488] = 5907; + rayToBps[1000000014720859898794478424] = 5908; + rayToBps[1000000014722853159784580123] = 5909; + rayToBps[1000000014724846295487216583] = 5910; + rayToBps[1000000014726839305918136834] = 5911; + rayToBps[1000000014728832191093086935] = 5912; + rayToBps[1000000014730824951027809978] = 5913; + rayToBps[1000000014732817585738046086] = 5914; + rayToBps[1000000014734810095239532414] = 5915; + rayToBps[1000000014736802479548003151] = 5916; + rayToBps[1000000014738794738679189525] = 5917; + rayToBps[1000000014740786872648819790] = 5918; + rayToBps[1000000014742778881472619245] = 5919; + rayToBps[1000000014744770765166310220] = 5920; + rayToBps[1000000014746762523745612083] = 5921; + rayToBps[1000000014748754157226241244] = 5922; + rayToBps[1000000014750745665623911146] = 5923; + rayToBps[1000000014752737048954332275] = 5924; + rayToBps[1000000014754728307233212158] = 5925; + rayToBps[1000000014756719440476255360] = 5926; + rayToBps[1000000014758710448699163491] = 5927; + rayToBps[1000000014760701331917635202] = 5928; + rayToBps[1000000014762692090147366186] = 5929; + rayToBps[1000000014764682723404049184] = 5930; + rayToBps[1000000014766673231703373978] = 5931; + rayToBps[1000000014768663615061027396] = 5932; + rayToBps[1000000014770653873492693314] = 5933; + rayToBps[1000000014772644007014052654] = 5934; + rayToBps[1000000014774634015640783386] = 5935; + rayToBps[1000000014776623899388560526] = 5936; + rayToBps[1000000014778613658273056145] = 5937; + rayToBps[1000000014780603292309939358] = 5938; + rayToBps[1000000014782592801514876334] = 5939; + rayToBps[1000000014784582185903530293] = 5940; + rayToBps[1000000014786571445491561506] = 5941; + rayToBps[1000000014788560580294627298] = 5942; + rayToBps[1000000014790549590328382048] = 5943; + rayToBps[1000000014792538475608477188] = 5944; + rayToBps[1000000014794527236150561205] = 5945; + rayToBps[1000000014796515871970279644] = 5946; + rayToBps[1000000014798504383083275106] = 5947; + rayToBps[1000000014800492769505187248] = 5948; + rayToBps[1000000014802481031251652786] = 5949; + rayToBps[1000000014804469168338305494] = 5950; + rayToBps[1000000014806457180780776207] = 5951; + rayToBps[1000000014808445068594692819] = 5952; + rayToBps[1000000014810432831795680286] = 5953; + rayToBps[1000000014812420470399360626] = 5954; + rayToBps[1000000014814407984421352919] = 5955; + rayToBps[1000000014816395373877273307] = 5956; + rayToBps[1000000014818382638782734998] = 5957; + rayToBps[1000000014820369779153348262] = 5958; + rayToBps[1000000014822356795004720439] = 5959; + rayToBps[1000000014824343686352455932] = 5960; + rayToBps[1000000014826330453212156210] = 5961; + rayToBps[1000000014828317095599419813] = 5962; + rayToBps[1000000014830303613529842346] = 5963; + rayToBps[1000000014832290007019016486] = 5964; + rayToBps[1000000014834276276082531977] = 5965; + rayToBps[1000000014836262420735975636] = 5966; + rayToBps[1000000014838248440994931352] = 5967; + rayToBps[1000000014840234336874980083] = 5968; + rayToBps[1000000014842220108391699861] = 5969; + rayToBps[1000000014844205755560665792] = 5970; + rayToBps[1000000014846191278397450058] = 5971; + rayToBps[1000000014848176676917621912] = 5972; + rayToBps[1000000014850161951136747686] = 5973; + rayToBps[1000000014852147101070390787] = 5974; + rayToBps[1000000014854132126734111701] = 5975; + rayToBps[1000000014856117028143467990] = 5976; + rayToBps[1000000014858101805314014293] = 5977; + rayToBps[1000000014860086458261302333] = 5978; + rayToBps[1000000014862070987000880911] = 5979; + rayToBps[1000000014864055391548295906] = 5980; + rayToBps[1000000014866039671919090284] = 5981; + rayToBps[1000000014868023828128804090] = 5982; + rayToBps[1000000014870007860192974452] = 5983; + rayToBps[1000000014871991768127135581] = 5984; + rayToBps[1000000014873975551946818776] = 5985; + rayToBps[1000000014875959211667552419] = 5986; + rayToBps[1000000014877942747304861976] = 5987; + rayToBps[1000000014879926158874270004] = 5988; + rayToBps[1000000014881909446391296144] = 5989; + rayToBps[1000000014883892609871457128] = 5990; + rayToBps[1000000014885875649330266773] = 5991; + rayToBps[1000000014887858564783235989] = 5992; + rayToBps[1000000014889841356245872775] = 5993; + rayToBps[1000000014891824023733682222] = 5994; + rayToBps[1000000014893806567262166511] = 5995; + rayToBps[1000000014895788986846824917] = 5996; + rayToBps[1000000014897771282503153808] = 5997; + rayToBps[1000000014899753454246646646] = 5998; + rayToBps[1000000014901735502092793986] = 5999; + rayToBps[1000000014903717426057083481] = 6000; + rayToBps[1000000014905699226154999880] = 6001; + rayToBps[1000000014907680902402025027] = 6002; + rayToBps[1000000014909662454813637865] = 6003; + rayToBps[1000000014911643883405314435] = 6004; + rayToBps[1000000014913625188192527876] = 6005; + rayToBps[1000000014915606369190748429] = 6006; + rayToBps[1000000014917587426415443433] = 6007; + rayToBps[1000000014919568359882077330] = 6008; + rayToBps[1000000014921549169606111665] = 6009; + rayToBps[1000000014923529855603005082] = 6010; + rayToBps[1000000014925510417888213331] = 6011; + rayToBps[1000000014927490856477189267] = 6012; + rayToBps[1000000014929471171385382847] = 6013; + rayToBps[1000000014931451362628241136] = 6014; + rayToBps[1000000014933431430221208304] = 6015; + rayToBps[1000000014935411374179725629] = 6016; + rayToBps[1000000014937391194519231495] = 6017; + rayToBps[1000000014939370891255161396] = 6018; + rayToBps[1000000014941350464402947936] = 6019; + rayToBps[1000000014943329913978020826] = 6020; + rayToBps[1000000014945309239995806891] = 6021; + rayToBps[1000000014947288442471730065] = 6022; + rayToBps[1000000014949267521421211394] = 6023; + rayToBps[1000000014951246476859669038] = 6024; + rayToBps[1000000014953225308802518272] = 6025; + rayToBps[1000000014955204017265171481] = 6026; + rayToBps[1000000014957182602263038168] = 6027; + rayToBps[1000000014959161063811524950] = 6028; + rayToBps[1000000014961139401926035563] = 6029; + rayToBps[1000000014963117616621970858] = 6030; + rayToBps[1000000014965095707914728804] = 6031; + rayToBps[1000000014967073675819704489] = 6032; + rayToBps[1000000014969051520352290120] = 6033; + rayToBps[1000000014971029241527875024] = 6034; + rayToBps[1000000014973006839361845649] = 6035; + rayToBps[1000000014974984313869585565] = 6036; + rayToBps[1000000014976961665066475462] = 6037; + rayToBps[1000000014978938892967893156] = 6038; + rayToBps[1000000014980915997589213583] = 6039; + rayToBps[1000000014982892978945808807] = 6040; + rayToBps[1000000014984869837053048013] = 6041; + rayToBps[1000000014986846571926297515] = 6042; + rayToBps[1000000014988823183580920752] = 6043; + rayToBps[1000000014990799672032278292] = 6044; + rayToBps[1000000014992776037295727828] = 6045; + rayToBps[1000000014994752279386624184] = 6046; + rayToBps[1000000014996728398320319311] = 6047; + rayToBps[1000000014998704394112162292] = 6048; + rayToBps[1000000015000680266777499339] = 6049; + rayToBps[1000000015002656016331673799] = 6050; + rayToBps[1000000015004631642790026146] = 6051; + rayToBps[1000000015006607146167893992] = 6052; + rayToBps[1000000015008582526480612079] = 6053; + rayToBps[1000000015010557783743512285] = 6054; + rayToBps[1000000015012532917971923621] = 6055; + rayToBps[1000000015014507929181172237] = 6056; + rayToBps[1000000015016482817386581417] = 6057; + rayToBps[1000000015018457582603471584] = 6058; + rayToBps[1000000015020432224847160297] = 6059; + rayToBps[1000000015022406744132962253] = 6060; + rayToBps[1000000015024381140476189292] = 6061; + rayToBps[1000000015026355413892150391] = 6062; + rayToBps[1000000015028329564396151668] = 6063; + rayToBps[1000000015030303592003496384] = 6064; + rayToBps[1000000015032277496729484940] = 6065; + rayToBps[1000000015034251278589414882] = 6066; + rayToBps[1000000015036224937598580896] = 6067; + rayToBps[1000000015038198473772274819] = 6068; + rayToBps[1000000015040171887125785626] = 6069; + rayToBps[1000000015042145177674399441] = 6070; + rayToBps[1000000015044118345433399534] = 6071; + rayToBps[1000000015046091390418066323] = 6072; + rayToBps[1000000015048064312643677371] = 6073; + rayToBps[1000000015050037112125507393] = 6074; + rayToBps[1000000015052009788878828253] = 6075; + rayToBps[1000000015053982342918908961] = 6076; + rayToBps[1000000015055954774261015682] = 6077; + rayToBps[1000000015057927082920411731] = 6078; + rayToBps[1000000015059899268912357574] = 6079; + rayToBps[1000000015061871332252110832] = 6080; + rayToBps[1000000015063843272954926277] = 6081; + rayToBps[1000000015065815091036055837] = 6082; + rayToBps[1000000015067786786510748595] = 6083; + rayToBps[1000000015069758359394250789] = 6084; + rayToBps[1000000015071729809701805813] = 6085; + rayToBps[1000000015073701137448654217] = 6086; + rayToBps[1000000015075672342650033713] = 6087; + rayToBps[1000000015077643425321179167] = 6088; + rayToBps[1000000015079614385477322606] = 6089; + rayToBps[1000000015081585223133693217] = 6090; + rayToBps[1000000015083555938305517348] = 6091; + rayToBps[1000000015085526531008018506] = 6092; + rayToBps[1000000015087497001256417364] = 6093; + rayToBps[1000000015089467349065931754] = 6094; + rayToBps[1000000015091437574451776672] = 6095; + rayToBps[1000000015093407677429164279] = 6096; + rayToBps[1000000015095377658013303902] = 6097; + rayToBps[1000000015097347516219402031] = 6098; + rayToBps[1000000015099317252062662325] = 6099; + rayToBps[1000000015101286865558285606] = 6100; + rayToBps[1000000015103256356721469870] = 6101; + rayToBps[1000000015105225725567410272] = 6102; + rayToBps[1000000015107194972111299145] = 6103; + rayToBps[1000000015109164096368325987] = 6104; + rayToBps[1000000015111133098353677468] = 6105; + rayToBps[1000000015113101978082537430] = 6106; + rayToBps[1000000015115070735570086883] = 6107; + rayToBps[1000000015117039370831504013] = 6108; + rayToBps[1000000015119007883881964179] = 6109; + rayToBps[1000000015120976274736639914] = 6110; + rayToBps[1000000015122944543410700923] = 6111; + rayToBps[1000000015124912689919314090] = 6112; + rayToBps[1000000015126880714277643473] = 6113; + rayToBps[1000000015128848616500850307] = 6114; + rayToBps[1000000015130816396604093005] = 6115; + rayToBps[1000000015132784054602527158] = 6116; + rayToBps[1000000015134751590511305536] = 6117; + rayToBps[1000000015136719004345578088] = 6118; + rayToBps[1000000015138686296120491942] = 6119; + rayToBps[1000000015140653465851191411] = 6120; + rayToBps[1000000015142620513552817987] = 6121; + rayToBps[1000000015144587439240510342] = 6122; + rayToBps[1000000015146554242929404336] = 6123; + rayToBps[1000000015148520924634633011] = 6124; + rayToBps[1000000015150487484371326590] = 6125; + rayToBps[1000000015152453922154612487] = 6126; + rayToBps[1000000015154420237999615297] = 6127; + rayToBps[1000000015156386431921456805] = 6128; + rayToBps[1000000015158352503935255979] = 6129; + rayToBps[1000000015160318454056128981] = 6130; + rayToBps[1000000015162284282299189156] = 6131; + rayToBps[1000000015164249988679547042] = 6132; + rayToBps[1000000015166215573212310364] = 6133; + rayToBps[1000000015168181035912584041] = 6134; + rayToBps[1000000015170146376795470181] = 6135; + rayToBps[1000000015172111595876068086] = 6136; + rayToBps[1000000015174076693169474249] = 6137; + rayToBps[1000000015176041668690782357] = 6138; + rayToBps[1000000015178006522455083294] = 6139; + rayToBps[1000000015179971254477465133] = 6140; + rayToBps[1000000015181935864773013148] = 6141; + rayToBps[1000000015183900353356809808] = 6142; + rayToBps[1000000015185864720243934777] = 6143; + rayToBps[1000000015187828965449464919] = 6144; + rayToBps[1000000015189793088988474295] = 6145; + rayToBps[1000000015191757090876034166] = 6146; + rayToBps[1000000015193720971127212993] = 6147; + rayToBps[1000000015195684729757076435] = 6148; + rayToBps[1000000015197648366780687356] = 6149; + rayToBps[1000000015199611882213105818] = 6150; + rayToBps[1000000015201575276069389089] = 6151; + rayToBps[1000000015203538548364591637] = 6152; + rayToBps[1000000015205501699113765138] = 6153; + rayToBps[1000000015207464728331958468] = 6154; + rayToBps[1000000015209427636034217712] = 6155; + rayToBps[1000000015211390422235586158] = 6156; + rayToBps[1000000015213353086951104304] = 6157; + rayToBps[1000000015215315630195809853] = 6158; + rayToBps[1000000015217278051984737717] = 6159; + rayToBps[1000000015219240352332920015] = 6160; + rayToBps[1000000015221202531255386080] = 6161; + rayToBps[1000000015223164588767162449] = 6162; + rayToBps[1000000015225126524883272874] = 6163; + rayToBps[1000000015227088339618738319] = 6164; + rayToBps[1000000015229050032988576957] = 6165; + rayToBps[1000000015231011605007804177] = 6166; + rayToBps[1000000015232973055691432580] = 6167; + rayToBps[1000000015234934385054471980] = 6168; + rayToBps[1000000015236895593111929410] = 6169; + rayToBps[1000000015238856679878809116] = 6170; + rayToBps[1000000015240817645370112558] = 6171; + rayToBps[1000000015242778489600838420] = 6172; + rayToBps[1000000015244739212585982595] = 6173; + rayToBps[1000000015246699814340538201] = 6174; + rayToBps[1000000015248660294879495575] = 6175; + rayToBps[1000000015250620654217842268] = 6176; + rayToBps[1000000015252580892370563058] = 6177; + rayToBps[1000000015254541009352639939] = 6178; + rayToBps[1000000015256501005179052132] = 6179; + rayToBps[1000000015258460879864776078] = 6180; + rayToBps[1000000015260420633424785438] = 6181; + rayToBps[1000000015262380265874051103] = 6182; + rayToBps[1000000015264339777227541185] = 6183; + rayToBps[1000000015266299167500221022] = 6184; + rayToBps[1000000015268258436707053177] = 6185; + rayToBps[1000000015270217584862997442] = 6186; + rayToBps[1000000015272176611983010835] = 6187; + rayToBps[1000000015274135518082047600] = 6188; + rayToBps[1000000015276094303175059215] = 6189; + rayToBps[1000000015278052967276994381] = 6190; + rayToBps[1000000015280011510402799035] = 6191; + rayToBps[1000000015281969932567416340] = 6192; + rayToBps[1000000015283928233785786694] = 6193; + rayToBps[1000000015285886414072847725] = 6194; + rayToBps[1000000015287844473443534295] = 6195; + rayToBps[1000000015289802411912778498] = 6196; + rayToBps[1000000015291760229495509665] = 6197; + rayToBps[1000000015293717926206654358] = 6198; + rayToBps[1000000015295675502061136378] = 6199; + rayToBps[1000000015297632957073876761] = 6200; + rayToBps[1000000015299590291259793780] = 6201; + rayToBps[1000000015301547504633802945] = 6202; + rayToBps[1000000015303504597210817004] = 6203; + rayToBps[1000000015305461569005745947] = 6204; + rayToBps[1000000015307418420033496998] = 6205; + rayToBps[1000000015309375150308974628] = 6206; + rayToBps[1000000015311331759847080545] = 6207; + rayToBps[1000000015313288248662713699] = 6208; + rayToBps[1000000015315244616770770282] = 6209; + rayToBps[1000000015317200864186143732] = 6210; + rayToBps[1000000015319156990923724726] = 6211; + rayToBps[1000000015321112996998401190] = 6212; + rayToBps[1000000015323068882425058294] = 6213; + rayToBps[1000000015325024647218578451] = 6214; + rayToBps[1000000015326980291393841323] = 6215; + rayToBps[1000000015328935814965723819] = 6216; + rayToBps[1000000015330891217949100095] = 6217; + rayToBps[1000000015332846500358841555] = 6218; + rayToBps[1000000015334801662209816855] = 6219; + rayToBps[1000000015336756703516891898] = 6220; + rayToBps[1000000015338711624294929839] = 6221; + rayToBps[1000000015340666424558791082] = 6222; + rayToBps[1000000015342621104323333287] = 6223; + rayToBps[1000000015344575663603411362] = 6224; + rayToBps[1000000015346530102413877471] = 6225; + rayToBps[1000000015348484420769581033] = 6226; + rayToBps[1000000015350438618685368717] = 6227; + rayToBps[1000000015352392696176084451] = 6228; + rayToBps[1000000015354346653256569420] = 6229; + rayToBps[1000000015356300489941662062] = 6230; + rayToBps[1000000015358254206246198075] = 6231; + rayToBps[1000000015360207802185010413] = 6232; + rayToBps[1000000015362161277772929290] = 6233; + rayToBps[1000000015364114633024782180] = 6234; + rayToBps[1000000015366067867955393814] = 6235; + rayToBps[1000000015368020982579586188] = 6236; + rayToBps[1000000015369973976912178557] = 6237; + rayToBps[1000000015371926850967987435] = 6238; + rayToBps[1000000015373879604761826606] = 6239; + rayToBps[1000000015375832238308507110] = 6240; + rayToBps[1000000015377784751622837256] = 6241; + rayToBps[1000000015379737144719622615] = 6242; + rayToBps[1000000015381689417613666024] = 6243; + rayToBps[1000000015383641570319767589] = 6244; + rayToBps[1000000015385593602852724678] = 6245; + rayToBps[1000000015387545515227331928] = 6246; + rayToBps[1000000015389497307458381246] = 6247; + rayToBps[1000000015391448979560661806] = 6248; + rayToBps[1000000015393400531548960052] = 6249; + rayToBps[1000000015395351963438059699] = 6250; + rayToBps[1000000015397303275242741731] = 6251; + rayToBps[1000000015399254466977784403] = 6252; + rayToBps[1000000015401205538657963245] = 6253; + rayToBps[1000000015403156490298051058] = 6254; + rayToBps[1000000015405107321912817917] = 6255; + rayToBps[1000000015407058033517031169] = 6256; + rayToBps[1000000015409008625125455440] = 6257; + rayToBps[1000000015410959096752852627] = 6258; + rayToBps[1000000015412909448413981907] = 6259; + rayToBps[1000000015414859680123599731] = 6260; + rayToBps[1000000015416809791896459828] = 6261; + rayToBps[1000000015418759783747313206] = 6262; + rayToBps[1000000015420709655690908154] = 6263; + rayToBps[1000000015422659407741990234] = 6264; + rayToBps[1000000015424609039915302295] = 6265; + rayToBps[1000000015426558552225584464] = 6266; + rayToBps[1000000015428507944687574148] = 6267; + rayToBps[1000000015430457217316006040] = 6268; + rayToBps[1000000015432406370125612111] = 6269; + rayToBps[1000000015434355403131121619] = 6270; + rayToBps[1000000015436304316347261106] = 6271; + rayToBps[1000000015438253109788754397] = 6272; + rayToBps[1000000015440201783470322605] = 6273; + rayToBps[1000000015442150337406684127] = 6274; + rayToBps[1000000015444098771612554646] = 6275; + rayToBps[1000000015446047086102647137] = 6276; + rayToBps[1000000015447995280891671860] = 6277; + rayToBps[1000000015449943355994336362] = 6278; + rayToBps[1000000015451891311425345484] = 6279; + rayToBps[1000000015453839147199401353] = 6280; + rayToBps[1000000015455786863331203391] = 6281; + rayToBps[1000000015457734459835448307] = 6282; + rayToBps[1000000015459681936726830105] = 6283; + rayToBps[1000000015461629294020040082] = 6284; + rayToBps[1000000015463576531729766828] = 6285; + rayToBps[1000000015465523649870696226] = 6286; + rayToBps[1000000015467470648457511454] = 6287; + rayToBps[1000000015469417527504892989] = 6288; + rayToBps[1000000015471364287027518599] = 6289; + rayToBps[1000000015473310927040063352] = 6290; + rayToBps[1000000015475257447557199613] = 6291; + rayToBps[1000000015477203848593597045] = 6292; + rayToBps[1000000015479150130163922609] = 6293; + rayToBps[1000000015481096292282840567] = 6294; + rayToBps[1000000015483042334965012479] = 6295; + rayToBps[1000000015484988258225097210] = 6296; + rayToBps[1000000015486934062077750921] = 6297; + rayToBps[1000000015488879746537627079] = 6298; + rayToBps[1000000015490825311619376452] = 6299; + rayToBps[1000000015492770757337647112] = 6300; + rayToBps[1000000015494716083707084436] = 6301; + rayToBps[1000000015496661290742331104] = 6302; + rayToBps[1000000015498606378458027103] = 6303; + rayToBps[1000000015500551346868809725] = 6304; + rayToBps[1000000015502496195989313568] = 6305; + rayToBps[1000000015504440925834170541] = 6306; + rayToBps[1000000015506385536418009859] = 6307; + rayToBps[1000000015508330027755458043] = 6308; + rayToBps[1000000015510274399861138927] = 6309; + rayToBps[1000000015512218652749673656] = 6310; + rayToBps[1000000015514162786435680680] = 6311; + rayToBps[1000000015516106800933775766] = 6312; + rayToBps[1000000015518050696258571992] = 6313; + rayToBps[1000000015519994472424679745] = 6314; + rayToBps[1000000015521938129446706731] = 6315; + rayToBps[1000000015523881667339257966] = 6316; + rayToBps[1000000015525825086116935783] = 6317; + rayToBps[1000000015527768385794339827] = 6318; + rayToBps[1000000015529711566386067064] = 6319; + rayToBps[1000000015531654627906711771] = 6320; + rayToBps[1000000015533597570370865546] = 6321; + rayToBps[1000000015535540393793117305] = 6322; + rayToBps[1000000015537483098188053282] = 6323; + rayToBps[1000000015539425683570257029] = 6324; + rayToBps[1000000015541368149954309419] = 6325; + rayToBps[1000000015543310497354788646] = 6326; + rayToBps[1000000015545252725786270226] = 6327; + rayToBps[1000000015547194835263326993] = 6328; + rayToBps[1000000015549136825800529108] = 6329; + rayToBps[1000000015551078697412444053] = 6330; + rayToBps[1000000015553020450113636636] = 6331; + rayToBps[1000000015554962083918668986] = 6332; + rayToBps[1000000015556903598842100559] = 6333; + rayToBps[1000000015558844994898488139] = 6334; + rayToBps[1000000015560786272102385832] = 6335; + rayToBps[1000000015562727430468345075] = 6336; + rayToBps[1000000015564668470010914631] = 6337; + rayToBps[1000000015566609390744640592] = 6338; + rayToBps[1000000015568550192684066380] = 6339; + rayToBps[1000000015570490875843732744] = 6340; + rayToBps[1000000015572431440238177765] = 6341; + rayToBps[1000000015574371885881936857] = 6342; + rayToBps[1000000015576312212789542763] = 6343; + rayToBps[1000000015578252420975525559] = 6344; + rayToBps[1000000015580192510454412655] = 6345; + rayToBps[1000000015582132481240728794] = 6346; + rayToBps[1000000015584072333348996053] = 6347; + rayToBps[1000000015586012066793733846] = 6348; + rayToBps[1000000015587951681589458919] = 6349; + rayToBps[1000000015589891177750685357] = 6350; + rayToBps[1000000015591830555291924580] = 6351; + rayToBps[1000000015593769814227685350] = 6352; + rayToBps[1000000015595708954572473762] = 6353; + rayToBps[1000000015597647976340793253] = 6354; + rayToBps[1000000015599586879547144596] = 6355; + rayToBps[1000000015601525664206025911] = 6356; + rayToBps[1000000015603464330331932651] = 6357; + rayToBps[1000000015605402877939357616] = 6358; + rayToBps[1000000015607341307042790947] = 6359; + rayToBps[1000000015609279617656720124] = 6360; + rayToBps[1000000015611217809795629977] = 6361; + rayToBps[1000000015613155883474002675] = 6362; + rayToBps[1000000015615093838706317732] = 6363; + rayToBps[1000000015617031675507052012] = 6364; + rayToBps[1000000015618969393890679720] = 6365; + rayToBps[1000000015620906993871672410] = 6366; + rayToBps[1000000015622844475464498982] = 6367; + rayToBps[1000000015624781838683625685] = 6368; + rayToBps[1000000015626719083543516119] = 6369; + rayToBps[1000000015628656210058631227] = 6370; + rayToBps[1000000015630593218243429309] = 6371; + rayToBps[1000000015632530108112366010] = 6372; + rayToBps[1000000015634466879679894331] = 6373; + rayToBps[1000000015636403532960464619] = 6374; + rayToBps[1000000015638340067968524580] = 6375; + rayToBps[1000000015640276484718519269] = 6376; + rayToBps[1000000015642212783224891098] = 6377; + rayToBps[1000000015644148963502079827] = 6378; + rayToBps[1000000015646085025564522580] = 6379; + rayToBps[1000000015648020969426653830] = 6380; + rayToBps[1000000015649956795102905409] = 6381; + rayToBps[1000000015651892502607706506] = 6382; + rayToBps[1000000015653828091955483667] = 6383; + rayToBps[1000000015655763563160660798] = 6384; + rayToBps[1000000015657698916237659162] = 6385; + rayToBps[1000000015659634151200897382] = 6386; + rayToBps[1000000015661569268064791442] = 6387; + rayToBps[1000000015663504266843754688] = 6388; + rayToBps[1000000015665439147552197824] = 6389; + rayToBps[1000000015667373910204528920] = 6390; + rayToBps[1000000015669308554815153405] = 6391; + rayToBps[1000000015671243081398474077] = 6392; + rayToBps[1000000015673177489968891092] = 6393; + rayToBps[1000000015675111780540801975] = 6394; + rayToBps[1000000015677045953128601614] = 6395; + rayToBps[1000000015678980007746682266] = 6396; + rayToBps[1000000015680913944409433552] = 6397; + rayToBps[1000000015682847763131242461] = 6398; + rayToBps[1000000015684781463926493350] = 6399; + rayToBps[1000000015686715046809567945] = 6400; + rayToBps[1000000015688648511794845341] = 6401; + rayToBps[1000000015690581858896702002] = 6402; + rayToBps[1000000015692515088129511766] = 6403; + rayToBps[1000000015694448199507645837] = 6404; + rayToBps[1000000015696381193045472797] = 6405; + rayToBps[1000000015698314068757358594] = 6406; + rayToBps[1000000015700246826657666553] = 6407; + rayToBps[1000000015702179466760757373] = 6408; + rayToBps[1000000015704111989080989125] = 6409; + rayToBps[1000000015706044393632717258] = 6410; + rayToBps[1000000015707976680430294594] = 6411; + rayToBps[1000000015709908849488071333] = 6412; + rayToBps[1000000015711840900820395051] = 6413; + rayToBps[1000000015713772834441610701] = 6414; + rayToBps[1000000015715704650366060617] = 6415; + rayToBps[1000000015717636348608084511] = 6416; + rayToBps[1000000015719567929182019470] = 6417; + rayToBps[1000000015721499392102199968] = 6418; + rayToBps[1000000015723430737382957855] = 6419; + rayToBps[1000000015725361965038622365] = 6420; + rayToBps[1000000015727293075083520113] = 6421; + rayToBps[1000000015729224067531975096] = 6422; + rayToBps[1000000015731154942398308695] = 6423; + rayToBps[1000000015733085699696839676] = 6424; + rayToBps[1000000015735016339441884188] = 6425; + rayToBps[1000000015736946861647755768] = 6426; + rayToBps[1000000015738877266328765334] = 6427; + rayToBps[1000000015740807553499221196] = 6428; + rayToBps[1000000015742737723173429047] = 6429; + rayToBps[1000000015744667775365691970] = 6430; + rayToBps[1000000015746597710090310436] = 6431; + rayToBps[1000000015748527527361582305] = 6432; + rayToBps[1000000015750457227193802825] = 6433; + rayToBps[1000000015752386809601264637] = 6434; + rayToBps[1000000015754316274598257774] = 6435; + rayToBps[1000000015756245622199069656] = 6436; + rayToBps[1000000015758174852417985099] = 6437; + rayToBps[1000000015760103965269286310] = 6438; + rayToBps[1000000015762032960767252891] = 6439; + rayToBps[1000000015763961838926161836] = 6440; + rayToBps[1000000015765890599760287538] = 6441; + rayToBps[1000000015767819243283901779] = 6442; + rayToBps[1000000015769747769511273744] = 6443; + rayToBps[1000000015771676178456670009] = 6444; + rayToBps[1000000015773604470134354550] = 6445; + rayToBps[1000000015775532644558588743] = 6446; + rayToBps[1000000015777460701743631357] = 6447; + rayToBps[1000000015779388641703738565] = 6448; + rayToBps[1000000015781316464453163938] = 6449; + rayToBps[1000000015783244170006158447] = 6450; + rayToBps[1000000015785171758376970467] = 6451; + rayToBps[1000000015787099229579845770] = 6452; + rayToBps[1000000015789026583629027536] = 6453; + rayToBps[1000000015790953820538756342] = 6454; + rayToBps[1000000015792880940323270174] = 6455; + rayToBps[1000000015794807942996804419] = 6456; + rayToBps[1000000015796734828573591870] = 6457; + rayToBps[1000000015798661597067862724] = 6458; + rayToBps[1000000015800588248493844588] = 6459; + rayToBps[1000000015802514782865762472] = 6460; + rayToBps[1000000015804441200197838795] = 6461; + rayToBps[1000000015806367500504293384] = 6462; + rayToBps[1000000015808293683799343474] = 6463; + rayToBps[1000000015810219750097203710] = 6464; + rayToBps[1000000015812145699412086147] = 6465; + rayToBps[1000000015814071531758200252] = 6466; + rayToBps[1000000015815997247149752899] = 6467; + rayToBps[1000000015817922845600948377] = 6468; + rayToBps[1000000015819848327125988387] = 6469; + rayToBps[1000000015821773691739072044] = 6470; + rayToBps[1000000015823698939454395875] = 6471; + rayToBps[1000000015825624070286153821] = 6472; + rayToBps[1000000015827549084248537241] = 6473; + rayToBps[1000000015829473981355734906] = 6474; + rayToBps[1000000015831398761621933006] = 6475; + rayToBps[1000000015833323425061315145] = 6476; + rayToBps[1000000015835247971688062347] = 6477; + rayToBps[1000000015837172401516353055] = 6478; + rayToBps[1000000015839096714560363128] = 6479; + rayToBps[1000000015841020910834265843] = 6480; + rayToBps[1000000015842944990352231903] = 6481; + rayToBps[1000000015844868953128429425] = 6482; + rayToBps[1000000015846792799177023953] = 6483; + rayToBps[1000000015848716528512178448] = 6484; + rayToBps[1000000015850640141148053296] = 6485; + rayToBps[1000000015852563637098806307] = 6486; + rayToBps[1000000015854487016378592712] = 6487; + rayToBps[1000000015856410279001565169] = 6488; + rayToBps[1000000015858333424981873758] = 6489; + rayToBps[1000000015860256454333665989] = 6490; + rayToBps[1000000015862179367071086794] = 6491; + rayToBps[1000000015864102163208278534] = 6492; + rayToBps[1000000015866024842759380997] = 6493; + rayToBps[1000000015867947405738531398] = 6494; + rayToBps[1000000015869869852159864384] = 6495; + rayToBps[1000000015871792182037512030] = 6496; + rayToBps[1000000015873714395385603836] = 6497; + rayToBps[1000000015875636492218266741] = 6498; + rayToBps[1000000015877558472549625110] = 6499; + rayToBps[1000000015879480336393800741] = 6500; + rayToBps[1000000015881402083764912862] = 6501; + rayToBps[1000000015883323714677078140] = 6502; + rayToBps[1000000015885245229144410671] = 6503; + rayToBps[1000000015887166627181021987] = 6504; + rayToBps[1000000015889087908801021053] = 6505; + rayToBps[1000000015891009074018514273] = 6506; + rayToBps[1000000015892930122847605485] = 6507; + rayToBps[1000000015894851055302395963] = 6508; + rayToBps[1000000015896771871396984421] = 6509; + rayToBps[1000000015898692571145467010] = 6510; + rayToBps[1000000015900613154561937317] = 6511; + rayToBps[1000000015902533621660486374] = 6512; + rayToBps[1000000015904453972455202647] = 6513; + rayToBps[1000000015906374206960172047] = 6514; + rayToBps[1000000015908294325189477924] = 6515; + rayToBps[1000000015910214327157201069] = 6516; + rayToBps[1000000015912134212877419719] = 6517; + rayToBps[1000000015914053982364209549] = 6518; + rayToBps[1000000015915973635631643682] = 6519; + rayToBps[1000000015917893172693792683] = 6520; + rayToBps[1000000015919812593564724562] = 6521; + rayToBps[1000000015921731898258504776] = 6522; + rayToBps[1000000015923651086789196227] = 6523; + rayToBps[1000000015925570159170859262] = 6524; + rayToBps[1000000015927489115417551681] = 6525; + rayToBps[1000000015929407955543328724] = 6526; + rayToBps[1000000015931326679562243086] = 6527; + rayToBps[1000000015933245287488344910] = 6528; + rayToBps[1000000015935163779335681785] = 6529; + rayToBps[1000000015937082155118298755] = 6530; + rayToBps[1000000015939000414850238313] = 6531; + rayToBps[1000000015940918558545540404] = 6532; + rayToBps[1000000015942836586218242426] = 6533; + rayToBps[1000000015944754497882379228] = 6534; + rayToBps[1000000015946672293551983115] = 6535; + rayToBps[1000000015948589973241083845] = 6536; + rayToBps[1000000015950507536963708629] = 6537; + rayToBps[1000000015952424984733882136] = 6538; + rayToBps[1000000015954342316565626492] = 6539; + rayToBps[1000000015956259532472961274] = 6540; + rayToBps[1000000015958176632469903523] = 6541; + rayToBps[1000000015960093616570467734] = 6542; + rayToBps[1000000015962010484788665860] = 6543; + rayToBps[1000000015963927237138507317] = 6544; + rayToBps[1000000015965843873633998974] = 6545; + rayToBps[1000000015967760394289145167] = 6546; + rayToBps[1000000015969676799117947690] = 6547; + rayToBps[1000000015971593088134405798] = 6548; + rayToBps[1000000015973509261352516209] = 6549; + rayToBps[1000000015975425318786273105] = 6550; + rayToBps[1000000015977341260449668127] = 6551; + rayToBps[1000000015979257086356690385] = 6552; + rayToBps[1000000015981172796521326452] = 6553; + rayToBps[1000000015983088390957560365] = 6554; + rayToBps[1000000015985003869679373628] = 6555; + rayToBps[1000000015986919232700745209] = 6556; + rayToBps[1000000015988834480035651548] = 6557; + rayToBps[1000000015990749611698066548] = 6558; + rayToBps[1000000015992664627701961582] = 6559; + rayToBps[1000000015994579528061305491] = 6560; + rayToBps[1000000015996494312790064590] = 6561; + rayToBps[1000000015998408981902202656] = 6562; + rayToBps[1000000016000323535411680943] = 6563; + rayToBps[1000000016002237973332458175] = 6564; + rayToBps[1000000016004152295678490547] = 6565; + rayToBps[1000000016006066502463731726] = 6566; + rayToBps[1000000016007980593702132855] = 6567; + rayToBps[1000000016009894569407642547] = 6568; + rayToBps[1000000016011808429594206893] = 6569; + rayToBps[1000000016013722174275769455] = 6570; + rayToBps[1000000016015635803466271275] = 6571; + rayToBps[1000000016017549317179650868] = 6572; + rayToBps[1000000016019462715429844226] = 6573; + rayToBps[1000000016021375998230784820] = 6574; + rayToBps[1000000016023289165596403599] = 6575; + rayToBps[1000000016025202217540628989] = 6576; + rayToBps[1000000016027115154077386896] = 6577; + rayToBps[1000000016029027975220600708] = 6578; + rayToBps[1000000016030940680984191289] = 6579; + rayToBps[1000000016032853271382076987] = 6580; + rayToBps[1000000016034765746428173632] = 6581; + rayToBps[1000000016036678106136394535] = 6582; + rayToBps[1000000016038590350520650490] = 6583; + rayToBps[1000000016040502479594849776] = 6584; + rayToBps[1000000016042414493372898155] = 6585; + rayToBps[1000000016044326391868698872] = 6586; + rayToBps[1000000016046238175096152661] = 6587; + rayToBps[1000000016048149843069157739] = 6588; + rayToBps[1000000016050061395801609810] = 6589; + rayToBps[1000000016051972833307402066] = 6590; + rayToBps[1000000016053884155600425188] = 6591; + rayToBps[1000000016055795362694567342] = 6592; + rayToBps[1000000016057706454603714184] = 6593; + rayToBps[1000000016059617431341748863] = 6594; + rayToBps[1000000016061528292922552013] = 6595; + rayToBps[1000000016063439039360001761] = 6596; + rayToBps[1000000016065349670667973728] = 6597; + rayToBps[1000000016067260186860341022] = 6598; + rayToBps[1000000016069170587950974247] = 6599; + rayToBps[1000000016071080873953741499] = 6600; + rayToBps[1000000016072991044882508369] = 6601; + rayToBps[1000000016074901100751137941] = 6602; + rayToBps[1000000016076811041573490795] = 6603; + rayToBps[1000000016078720867363425005] = 6604; + rayToBps[1000000016080630578134796143] = 6605; + rayToBps[1000000016082540173901457278] = 6606; + rayToBps[1000000016084449654677258973] = 6607; + rayToBps[1000000016086359020476049294] = 6608; + rayToBps[1000000016088268271311673802] = 6609; + rayToBps[1000000016090177407197975559] = 6610; + rayToBps[1000000016092086428148795125] = 6611; + rayToBps[1000000016093995334177970563] = 6612; + rayToBps[1000000016095904125299337436] = 6613; + rayToBps[1000000016097812801526728807] = 6614; + rayToBps[1000000016099721362873975244] = 6615; + rayToBps[1000000016101629809354904814] = 6616; + rayToBps[1000000016103538140983343092] = 6617; + rayToBps[1000000016105446357773113153] = 6618; + rayToBps[1000000016107354459738035580] = 6619; + rayToBps[1000000016109262446891928459] = 6620; + rayToBps[1000000016111170319248607383] = 6621; + rayToBps[1000000016113078076821885451] = 6622; + rayToBps[1000000016114985719625573268] = 6623; + rayToBps[1000000016116893247673478948] = 6624; + rayToBps[1000000016118800660979408115] = 6625; + rayToBps[1000000016120707959557163897] = 6626; + rayToBps[1000000016122615143420546934] = 6627; + rayToBps[1000000016124522212583355378] = 6628; + rayToBps[1000000016126429167059384889] = 6629; + rayToBps[1000000016128336006862428639] = 6630; + rayToBps[1000000016130242732006277312] = 6631; + rayToBps[1000000016132149342504719104] = 6632; + rayToBps[1000000016134055838371539725] = 6633; + rayToBps[1000000016135962219620522398] = 6634; + rayToBps[1000000016137868486265447859] = 6635; + rayToBps[1000000016139774638320094360] = 6636; + rayToBps[1000000016141680675798237669] = 6637; + rayToBps[1000000016143586598713651070] = 6638; + rayToBps[1000000016145492407080105363] = 6639; + rayToBps[1000000016147398100911368865] = 6640; + rayToBps[1000000016149303680221207410] = 6641; + rayToBps[1000000016151209145023384352] = 6642; + rayToBps[1000000016153114495331660565] = 6643; + rayToBps[1000000016155019731159794439] = 6644; + rayToBps[1000000016156924852521541888] = 6645; + rayToBps[1000000016158829859430656342] = 6646; + rayToBps[1000000016160734751900888759] = 6647; + rayToBps[1000000016162639529945987614] = 6648; + rayToBps[1000000016164544193579698905] = 6649; + rayToBps[1000000016166448742815766155] = 6650; + rayToBps[1000000016168353177667930410] = 6651; + rayToBps[1000000016170257498149930239] = 6652; + rayToBps[1000000016172161704275501740] = 6653; + rayToBps[1000000016174065796058378532] = 6654; + rayToBps[1000000016175969773512291760] = 6655; + rayToBps[1000000016177873636650970102] = 6656; + rayToBps[1000000016179777385488139756] = 6657; + rayToBps[1000000016181681020037524450] = 6658; + rayToBps[1000000016183584540312845443] = 6659; + rayToBps[1000000016185487946327821522] = 6660; + rayToBps[1000000016187391238096169003] = 6661; + rayToBps[1000000016189294415631601732] = 6662; + rayToBps[1000000016191197478947831086] = 6663; + rayToBps[1000000016193100428058565975] = 6664; + rayToBps[1000000016195003262977512839] = 6665; + rayToBps[1000000016196905983718375652] = 6666; + rayToBps[1000000016198808590294855920] = 6667; + rayToBps[1000000016200711082720652686] = 6668; + rayToBps[1000000016202613461009462523] = 6669; + rayToBps[1000000016204515725174979542] = 6670; + rayToBps[1000000016206417875230895389] = 6671; + rayToBps[1000000016208319911190899247] = 6672; + rayToBps[1000000016210221833068677832] = 6673; + rayToBps[1000000016212123640877915404] = 6674; + rayToBps[1000000016214025334632293755] = 6675; + rayToBps[1000000016215926914345492218] = 6676; + rayToBps[1000000016217828380031187665] = 6677; + rayToBps[1000000016219729731703054508] = 6678; + rayToBps[1000000016221630969374764700] = 6679; + rayToBps[1000000016223532093059987732] = 6680; + rayToBps[1000000016225433102772390641] = 6681; + rayToBps[1000000016227333998525638003] = 6682; + rayToBps[1000000016229234780333391936] = 6683; + rayToBps[1000000016231135448209312105] = 6684; + rayToBps[1000000016233036002167055714] = 6685; + rayToBps[1000000016234936442220277518] = 6686; + rayToBps[1000000016236836768382629809] = 6687; + rayToBps[1000000016238736980667762431] = 6688; + rayToBps[1000000016240637079089322772] = 6689; + rayToBps[1000000016242537063660955766] = 6690; + rayToBps[1000000016244436934396303896] = 6691; + rayToBps[1000000016246336691309007193] = 6692; + rayToBps[1000000016248236334412703235] = 6693; + rayToBps[1000000016250135863721027150] = 6694; + rayToBps[1000000016252035279247611617] = 6695; + rayToBps[1000000016253934581006086862] = 6696; + rayToBps[1000000016255833769010080666] = 6697; + rayToBps[1000000016257732843273218361] = 6698; + rayToBps[1000000016259631803809122826] = 6699; + rayToBps[1000000016261530650631414500] = 6700; + rayToBps[1000000016263429383753711370] = 6701; + rayToBps[1000000016265328003189628979] = 6702; + rayToBps[1000000016267226508952780424] = 6703; + rayToBps[1000000016269124901056776358] = 6704; + rayToBps[1000000016271023179515224989] = 6705; + rayToBps[1000000016272921344341732080] = 6706; + rayToBps[1000000016274819395549900951] = 6707; + rayToBps[1000000016276717333153332483] = 6708; + rayToBps[1000000016278615157165625110] = 6709; + rayToBps[1000000016280512867600374827] = 6710; + rayToBps[1000000016282410464471175189] = 6711; + rayToBps[1000000016284307947791617308] = 6712; + rayToBps[1000000016286205317575289861] = 6713; + rayToBps[1000000016288102573835779079] = 6714; + rayToBps[1000000016289999716586668760] = 6715; + rayToBps[1000000016291896745841540263] = 6716; + rayToBps[1000000016293793661613972507] = 6717; + rayToBps[1000000016295690463917541979] = 6718; + rayToBps[1000000016297587152765822726] = 6719; + rayToBps[1000000016299483728172386359] = 6720; + rayToBps[1000000016301380190150802056] = 6721; + rayToBps[1000000016303276538714636561] = 6722; + rayToBps[1000000016305172773877454184] = 6723; + rayToBps[1000000016307068895652816797] = 6724; + rayToBps[1000000016308964904054283846] = 6725; + rayToBps[1000000016310860799095412343] = 6726; + rayToBps[1000000016312756580789756865] = 6727; + rayToBps[1000000016314652249150869561] = 6728; + rayToBps[1000000016316547804192300151] = 6729; + rayToBps[1000000016318443245927595921] = 6730; + rayToBps[1000000016320338574370301732] = 6731; + rayToBps[1000000016322233789533960012] = 6732; + rayToBps[1000000016324128891432110768] = 6733; + rayToBps[1000000016326023880078291569] = 6734; + rayToBps[1000000016327918755486037569] = 6735; + rayToBps[1000000016329813517668881487] = 6736; + rayToBps[1000000016331708166640353619] = 6737; + rayToBps[1000000016333602702413981835] = 6738; + rayToBps[1000000016335497125003291584] = 6739; + rayToBps[1000000016337391434421805887] = 6740; + rayToBps[1000000016339285630683045343] = 6741; + rayToBps[1000000016341179713800528128] = 6742; + rayToBps[1000000016343073683787769996] = 6743; + rayToBps[1000000016344967540658284281] = 6744; + rayToBps[1000000016346861284425581891] = 6745; + rayToBps[1000000016348754915103171319] = 6746; + rayToBps[1000000016350648432704558634] = 6747; + rayToBps[1000000016352541837243247489] = 6748; + rayToBps[1000000016354435128732739115] = 6749; + rayToBps[1000000016356328307186532328] = 6750; + rayToBps[1000000016358221372618123524] = 6751; + rayToBps[1000000016360114325041006682] = 6752; + rayToBps[1000000016362007164468673366] = 6753; + rayToBps[1000000016363899890914612724] = 6754; + rayToBps[1000000016365792504392311486] = 6755; + rayToBps[1000000016367685004915253971] = 6756; + rayToBps[1000000016369577392496922081] = 6757; + rayToBps[1000000016371469667150795306] = 6758; + rayToBps[1000000016373361828890350723] = 6759; + rayToBps[1000000016375253877729062995] = 6760; + rayToBps[1000000016377145813680404375] = 6761; + rayToBps[1000000016379037636757844703] = 6762; + rayToBps[1000000016380929346974851411] = 6763; + rayToBps[1000000016382820944344889517] = 6764; + rayToBps[1000000016384712428881421632] = 6765; + rayToBps[1000000016386603800597907959] = 6766; + rayToBps[1000000016388495059507806289] = 6767; + rayToBps[1000000016390386205624572010] = 6768; + rayToBps[1000000016392277238961658097] = 6769; + rayToBps[1000000016394168159532515122] = 6770; + rayToBps[1000000016396058967350591252] = 6771; + rayToBps[1000000016397949662429332245] = 6772; + rayToBps[1000000016399840244782181456] = 6773; + rayToBps[1000000016401730714422579836] = 6774; + rayToBps[1000000016403621071363965932] = 6775; + rayToBps[1000000016405511315619775885] = 6776; + rayToBps[1000000016407401447203443437] = 6777; + rayToBps[1000000016409291466128399927] = 6778; + rayToBps[1000000016411181372408074291] = 6779; + rayToBps[1000000016413071166055893066] = 6780; + rayToBps[1000000016414960847085280386] = 6781; + rayToBps[1000000016416850415509657988] = 6782; + rayToBps[1000000016418739871342445209] = 6783; + rayToBps[1000000016420629214597058985] = 6784; + rayToBps[1000000016422518445286913858] = 6785; + rayToBps[1000000016424407563425421969] = 6786; + rayToBps[1000000016426296569025993065] = 6787; + rayToBps[1000000016428185462102034492] = 6788; + rayToBps[1000000016430074242666951206] = 6789; + rayToBps[1000000016431962910734145763] = 6790; + rayToBps[1000000016433851466317018328] = 6791; + rayToBps[1000000016435739909428966668] = 6792; + rayToBps[1000000016437628240083386160] = 6793; + rayToBps[1000000016439516458293669787] = 6794; + rayToBps[1000000016441404564073208138] = 6795; + rayToBps[1000000016443292557435389412] = 6796; + rayToBps[1000000016445180438393599417] = 6797; + rayToBps[1000000016447068206961221569] = 6798; + rayToBps[1000000016448955863151636894] = 6799; + rayToBps[1000000016450843406978224029] = 6800; + rayToBps[1000000016452730838454359222] = 6801; + rayToBps[1000000016454618157593416334] = 6802; + rayToBps[1000000016456505364408766833] = 6803; + rayToBps[1000000016458392458913779807] = 6804; + rayToBps[1000000016460279441121821953] = 6805; + rayToBps[1000000016462166311046257581] = 6806; + rayToBps[1000000016464053068700448618] = 6807; + rayToBps[1000000016465939714097754606] = 6808; + rayToBps[1000000016467826247251532699] = 6809; + rayToBps[1000000016469712668175137672] = 6810; + rayToBps[1000000016471598976881921914] = 6811; + rayToBps[1000000016473485173385235432] = 6812; + rayToBps[1000000016475371257698425850] = 6813; + rayToBps[1000000016477257229834838411] = 6814; + rayToBps[1000000016479143089807815977] = 6815; + rayToBps[1000000016481028837630699030] = 6816; + rayToBps[1000000016482914473316825670] = 6817; + rayToBps[1000000016484799996879531621] = 6818; + rayToBps[1000000016486685408332150226] = 6819; + rayToBps[1000000016488570707688012450] = 6820; + rayToBps[1000000016490455894960446883] = 6821; + rayToBps[1000000016492340970162779731] = 6822; + rayToBps[1000000016494225933308334832] = 6823; + rayToBps[1000000016496110784410433643] = 6824; + rayToBps[1000000016497995523482395247] = 6825; + rayToBps[1000000016499880150537536351] = 6826; + rayToBps[1000000016501764665589171290] = 6827; + rayToBps[1000000016503649068650612025] = 6828; + rayToBps[1000000016505533359735168140] = 6829; + rayToBps[1000000016507417538856146852] = 6830; + rayToBps[1000000016509301606026853003] = 6831; + rayToBps[1000000016511185561260589063] = 6832; + rayToBps[1000000016513069404570655134] = 6833; + rayToBps[1000000016514953135970348945] = 6834; + rayToBps[1000000016516836755472965855] = 6835; + rayToBps[1000000016518720263091798857] = 6836; + rayToBps[1000000016520603658840138572] = 6837; + rayToBps[1000000016522486942731273255] = 6838; + rayToBps[1000000016524370114778488794] = 6839; + rayToBps[1000000016526253174995068707] = 6840; + rayToBps[1000000016528136123394294149] = 6841; + rayToBps[1000000016530018959989443907] = 6842; + rayToBps[1000000016531901684793794404] = 6843; + rayToBps[1000000016533784297820619698] = 6844; + rayToBps[1000000016535666799083191483] = 6845; + rayToBps[1000000016537549188594779088] = 6846; + rayToBps[1000000016539431466368649483] = 6847; + rayToBps[1000000016541313632418067271] = 6848; + rayToBps[1000000016543195686756294694] = 6849; + rayToBps[1000000016545077629396591637] = 6850; + rayToBps[1000000016546959460352215619] = 6851; + rayToBps[1000000016548841179636421799] = 6852; + rayToBps[1000000016550722787262462982] = 6853; + rayToBps[1000000016552604283243589608] = 6854; + rayToBps[1000000016554485667593049761] = 6855; + rayToBps[1000000016556366940324089165] = 6856; + rayToBps[1000000016558248101449951192] = 6857; + rayToBps[1000000016560129150983876850] = 6858; + rayToBps[1000000016562010088939104796] = 6859; + rayToBps[1000000016563890915328871330] = 6860; + rayToBps[1000000016565771630166410395] = 6861; + rayToBps[1000000016567652233464953581] = 6862; + rayToBps[1000000016569532725237730125] = 6863; + rayToBps[1000000016571413105497966909] = 6864; + rayToBps[1000000016573293374258888461] = 6865; + rayToBps[1000000016575173531533716960] = 6866; + rayToBps[1000000016577053577335672229] = 6867; + rayToBps[1000000016578933511677971744] = 6868; + rayToBps[1000000016580813334573830628] = 6869; + rayToBps[1000000016582693046036461653] = 6870; + rayToBps[1000000016584572646079075244] = 6871; + rayToBps[1000000016586452134714879475] = 6872; + rayToBps[1000000016588331511957080072] = 6873; + rayToBps[1000000016590210777818880415] = 6874; + rayToBps[1000000016592089932313481533] = 6875; + rayToBps[1000000016593968975454082111] = 6876; + rayToBps[1000000016595847907253878486] = 6877; + rayToBps[1000000016597726727726064651] = 6878; + rayToBps[1000000016599605436883832255] = 6879; + rayToBps[1000000016601484034740370597] = 6880; + rayToBps[1000000016603362521308866639] = 6881; + rayToBps[1000000016605240896602504994] = 6882; + rayToBps[1000000016607119160634467936] = 6883; + rayToBps[1000000016608997313417935393] = 6884; + rayToBps[1000000016610875354966084955] = 6885; + rayToBps[1000000016612753285292091867] = 6886; + rayToBps[1000000016614631104409129037] = 6887; + rayToBps[1000000016616508812330367032] = 6888; + rayToBps[1000000016618386409068974076] = 6889; + rayToBps[1000000016620263894638116058] = 6890; + rayToBps[1000000016622141269050956527] = 6891; + rayToBps[1000000016624018532320656694] = 6892; + rayToBps[1000000016625895684460375433] = 6893; + rayToBps[1000000016627772725483269281] = 6894; + rayToBps[1000000016629649655402492440] = 6895; + rayToBps[1000000016631526474231196774] = 6896; + rayToBps[1000000016633403181982531813] = 6897; + rayToBps[1000000016635279778669644752] = 6898; + rayToBps[1000000016637156264305680454] = 6899; + rayToBps[1000000016639032638903781446] = 6900; + rayToBps[1000000016640908902477087924] = 6901; + rayToBps[1000000016642785055038737748] = 6902; + rayToBps[1000000016644661096601866452] = 6903; + rayToBps[1000000016646537027179607234] = 6904; + rayToBps[1000000016648412846785090963] = 6905; + rayToBps[1000000016650288555431446177] = 6906; + rayToBps[1000000016652164153131799087] = 6907; + rayToBps[1000000016654039639899273571] = 6908; + rayToBps[1000000016655915015746991182] = 6909; + rayToBps[1000000016657790280688071142] = 6910; + rayToBps[1000000016659665434735630349] = 6911; + rayToBps[1000000016661540477902783371] = 6912; + rayToBps[1000000016663415410202642451] = 6913; + rayToBps[1000000016665290231648317506] = 6914; + rayToBps[1000000016667164942252916129] = 6915; + rayToBps[1000000016669039542029543587] = 6916; + rayToBps[1000000016670914030991302822] = 6917; + rayToBps[1000000016672788409151294456] = 6918; + rayToBps[1000000016674662676522616783] = 6919; + rayToBps[1000000016676536833118365780] = 6920; + rayToBps[1000000016678410878951635096] = 6921; + rayToBps[1000000016680284814035516064] = 6922; + rayToBps[1000000016682158638383097695] = 6923; + rayToBps[1000000016684032352007466677] = 6924; + rayToBps[1000000016685905954921707380] = 6925; + rayToBps[1000000016687779447138901857] = 6926; + rayToBps[1000000016689652828672129838] = 6927; + rayToBps[1000000016691526099534468738] = 6928; + rayToBps[1000000016693399259738993654] = 6929; + rayToBps[1000000016695272309298777366] = 6930; + rayToBps[1000000016697145248226890337] = 6931; + rayToBps[1000000016699018076536400715] = 6932; + rayToBps[1000000016700890794240374330] = 6933; + rayToBps[1000000016702763401351874702] = 6934; + rayToBps[1000000016704635897883963033] = 6935; + rayToBps[1000000016706508283849698211] = 6936; + rayToBps[1000000016708380559262136815] = 6937; + rayToBps[1000000016710252724134333106] = 6938; + rayToBps[1000000016712124778479339037] = 6939; + rayToBps[1000000016713996722310204248] = 6940; + rayToBps[1000000016715868555639976067] = 6941; + rayToBps[1000000016717740278481699513] = 6942; + rayToBps[1000000016719611890848417297] = 6943; + rayToBps[1000000016721483392753169815] = 6944; + rayToBps[1000000016723354784208995160] = 6945; + rayToBps[1000000016725226065228929112] = 6946; + rayToBps[1000000016727097235826005150] = 6947; + rayToBps[1000000016728968296013254437] = 6948; + rayToBps[1000000016730839245803705837] = 6949; + rayToBps[1000000016732710085210385903] = 6950; + rayToBps[1000000016734580814246318886] = 6951; + rayToBps[1000000016736451432924526729] = 6952; + rayToBps[1000000016738321941258029073] = 6953; + rayToBps[1000000016740192339259843253] = 6954; + rayToBps[1000000016742062626942984304] = 6955; + rayToBps[1000000016743932804320464954] = 6956; + rayToBps[1000000016745802871405295631] = 6957; + rayToBps[1000000016747672828210484461] = 6958; + rayToBps[1000000016749542674749037270] = 6959; + rayToBps[1000000016751412411033957580] = 6960; + rayToBps[1000000016753282037078246617] = 6961; + rayToBps[1000000016755151552894903305] = 6962; + rayToBps[1000000016757020958496924269] = 6963; + rayToBps[1000000016758890253897303837] = 6964; + rayToBps[1000000016760759439109034038] = 6965; + rayToBps[1000000016762628514145104603] = 6966; + rayToBps[1000000016764497479018502969] = 6967; + rayToBps[1000000016766366333742214272] = 6968; + rayToBps[1000000016768235078329221357] = 6969; + rayToBps[1000000016770103712792504771] = 6970; + rayToBps[1000000016771972237145042768] = 6971; + rayToBps[1000000016773840651399811306] = 6972; + rayToBps[1000000016775708955569784050] = 6973; + rayToBps[1000000016777577149667932373] = 6974; + rayToBps[1000000016779445233707225354] = 6975; + rayToBps[1000000016781313207700629783] = 6976; + rayToBps[1000000016783181071661110154] = 6977; + rayToBps[1000000016785048825601628673] = 6978; + rayToBps[1000000016786916469535145257] = 6979; + rayToBps[1000000016788784003474617530] = 6980; + rayToBps[1000000016790651427433000828] = 6981; + rayToBps[1000000016792518741423248199] = 6982; + rayToBps[1000000016794385945458310402] = 6983; + rayToBps[1000000016796253039551135908] = 6984; + rayToBps[1000000016798120023714670903] = 6985; + rayToBps[1000000016799986897961859283] = 6986; + rayToBps[1000000016801853662305642661] = 6987; + rayToBps[1000000016803720316758960363] = 6988; + rayToBps[1000000016805586861334749431] = 6989; + rayToBps[1000000016807453296045944621] = 6990; + rayToBps[1000000016809319620905478407] = 6991; + rayToBps[1000000016811185835926280979] = 6992; + rayToBps[1000000016813051941121280243] = 6993; + rayToBps[1000000016814917936503401823] = 6994; + rayToBps[1000000016816783822085569065] = 6995; + rayToBps[1000000016818649597880703028] = 6996; + rayToBps[1000000016820515263901722494] = 6997; + rayToBps[1000000016822380820161543963] = 6998; + rayToBps[1000000016824246266673081659] = 6999; + rayToBps[1000000016826111603449247521] = 7000; + rayToBps[1000000016827976830502951216] = 7001; + rayToBps[1000000016829841947847100128] = 7002; + rayToBps[1000000016831706955494599366] = 7003; + rayToBps[1000000016833571853458351761] = 7004; + rayToBps[1000000016835436641751257869] = 7005; + rayToBps[1000000016837301320386215969] = 7006; + rayToBps[1000000016839165889376122066] = 7007; + rayToBps[1000000016841030348733869887] = 7008; + rayToBps[1000000016842894698472350889] = 7009; + rayToBps[1000000016844758938604454252] = 7010; + rayToBps[1000000016846623069143066886] = 7011; + rayToBps[1000000016848487090101073424] = 7012; + rayToBps[1000000016850351001491356231] = 7013; + rayToBps[1000000016852214803326795400] = 7014; + rayToBps[1000000016854078495620268751] = 7015; + rayToBps[1000000016855942078384651834] = 7016; + rayToBps[1000000016857805551632817929] = 7017; + rayToBps[1000000016859668915377638048] = 7018; + rayToBps[1000000016861532169631980933] = 7019; + rayToBps[1000000016863395314408713059] = 7020; + rayToBps[1000000016865258349720698630] = 7021; + rayToBps[1000000016867121275580799585] = 7022; + rayToBps[1000000016868984092001875597] = 7023; + rayToBps[1000000016870846798996784070] = 7024; + rayToBps[1000000016872709396578380147] = 7025; + rayToBps[1000000016874571884759516701] = 7026; + rayToBps[1000000016876434263553044341] = 7027; + rayToBps[1000000016878296532971811416] = 7028; + rayToBps[1000000016880158693028664007] = 7029; + rayToBps[1000000016882020743736445934] = 7030; + rayToBps[1000000016883882685107998752] = 7031; + rayToBps[1000000016885744517156161760] = 7032; + rayToBps[1000000016887606239893771989] = 7033; + rayToBps[1000000016889467853333664213] = 7034; + rayToBps[1000000016891329357488670944] = 7035; + rayToBps[1000000016893190752371622434] = 7036; + rayToBps[1000000016895052037995346676] = 7037; + rayToBps[1000000016896913214372669406] = 7038; + rayToBps[1000000016898774281516414100] = 7039; + rayToBps[1000000016900635239439401976] = 7040; + rayToBps[1000000016902496088154451995] = 7041; + rayToBps[1000000016904356827674380861] = 7042; + rayToBps[1000000016906217458012003025] = 7043; + rayToBps[1000000016908077979180130677] = 7044; + rayToBps[1000000016909938391191573757] = 7045; + rayToBps[1000000016911798694059139947] = 7046; + rayToBps[1000000016913658887795634678] = 7047; + rayToBps[1000000016915518972413861124] = 7048; + rayToBps[1000000016917378947926620208] = 7049; + rayToBps[1000000016919238814346710603] = 7050; + rayToBps[1000000016921098571686928723] = 7051; + rayToBps[1000000016922958219960068739] = 7052; + rayToBps[1000000016924817759178922565] = 7053; + rayToBps[1000000016926677189356279869] = 7054; + rayToBps[1000000016928536510504928066] = 7055; + rayToBps[1000000016930395722637652322] = 7056; + rayToBps[1000000016932254825767235558] = 7057; + rayToBps[1000000016934113819906458442] = 7058; + rayToBps[1000000016935972705068099396] = 7059; + rayToBps[1000000016937831481264934596] = 7060; + rayToBps[1000000016939690148509737971] = 7061; + rayToBps[1000000016941548706815281202] = 7062; + rayToBps[1000000016943407156194333727] = 7063; + rayToBps[1000000016945265496659662739] = 7064; + rayToBps[1000000016947123728224033182] = 7065; + rayToBps[1000000016948981850900207763] = 7066; + rayToBps[1000000016950839864700946939] = 7067; + rayToBps[1000000016952697769639008929] = 7068; + rayToBps[1000000016954555565727149706] = 7069; + rayToBps[1000000016956413252978123003] = 7070; + rayToBps[1000000016958270831404680312] = 7071; + rayToBps[1000000016960128301019570884] = 7072; + rayToBps[1000000016961985661835541727] = 7073; + rayToBps[1000000016963842913865337612] = 7074; + rayToBps[1000000016965700057121701072] = 7075; + rayToBps[1000000016967557091617372397] = 7076; + rayToBps[1000000016969414017365089642] = 7077; + rayToBps[1000000016971270834377588623] = 7078; + rayToBps[1000000016973127542667602920] = 7079; + rayToBps[1000000016974984142247863875] = 7080; + rayToBps[1000000016976840633131100595] = 7081; + rayToBps[1000000016978697015330039950] = 7082; + rayToBps[1000000016980553288857406577] = 7083; + rayToBps[1000000016982409453725922877] = 7084; + rayToBps[1000000016984265509948309016] = 7085; + rayToBps[1000000016986121457537282929] = 7086; + rayToBps[1000000016987977296505560317] = 7087; + rayToBps[1000000016989833026865854647] = 7088; + rayToBps[1000000016991688648630877157] = 7089; + rayToBps[1000000016993544161813336850] = 7090; + rayToBps[1000000016995399566425940502] = 7091; + rayToBps[1000000016997254862481392657] = 7092; + rayToBps[1000000016999110049992395626] = 7093; + rayToBps[1000000017000965128971649496] = 7094; + rayToBps[1000000017002820099431852122] = 7095; + rayToBps[1000000017004674961385699132] = 7096; + rayToBps[1000000017006529714845883924] = 7097; + rayToBps[1000000017008384359825097672] = 7098; + rayToBps[1000000017010238896336029322] = 7099; + rayToBps[1000000017012093324391365593] = 7100; + rayToBps[1000000017013947644003790979] = 7101; + rayToBps[1000000017015801855185987748] = 7102; + rayToBps[1000000017017655957950635945] = 7103; + rayToBps[1000000017019509952310413390] = 7104; + rayToBps[1000000017021363838277995678] = 7105; + rayToBps[1000000017023217615866056185] = 7106; + rayToBps[1000000017025071285087266058] = 7107; + rayToBps[1000000017026924845954294229] = 7108; + rayToBps[1000000017028778298479807404] = 7109; + rayToBps[1000000017030631642676470068] = 7110; + rayToBps[1000000017032484878556944490] = 7111; + rayToBps[1000000017034338006133890711] = 7112; + rayToBps[1000000017036191025419966563] = 7113; + rayToBps[1000000017038043936427827649] = 7114; + rayToBps[1000000017039896739170127359] = 7115; + rayToBps[1000000017041749433659516866] = 7116; + rayToBps[1000000017043602019908645121] = 7117; + rayToBps[1000000017045454497930158862] = 7118; + rayToBps[1000000017047306867736702611] = 7119; + rayToBps[1000000017049159129340918671] = 7120; + rayToBps[1000000017051011282755447132] = 7121; + rayToBps[1000000017052863327992925869] = 7122; + rayToBps[1000000017054715265065990543] = 7123; + rayToBps[1000000017056567093987274599] = 7124; + rayToBps[1000000017058418814769409273] = 7125; + rayToBps[1000000017060270427425023583] = 7126; + rayToBps[1000000017062121931966744339] = 7127; + rayToBps[1000000017063973328407196139] = 7128; + rayToBps[1000000017065824616759001367] = 7129; + rayToBps[1000000017067675797034780199] = 7130; + rayToBps[1000000017069526869247150599] = 7131; + rayToBps[1000000017071377833408728323] = 7132; + rayToBps[1000000017073228689532126918] = 7133; + rayToBps[1000000017075079437629957721] = 7134; + rayToBps[1000000017076930077714829862] = 7135; + rayToBps[1000000017078780609799350263] = 7136; + rayToBps[1000000017080631033896123639] = 7137; + rayToBps[1000000017082481350017752499] = 7138; + rayToBps[1000000017084331558176837145] = 7139; + rayToBps[1000000017086181658385975674] = 7140; + rayToBps[1000000017088031650657763979] = 7141; + rayToBps[1000000017089881535004795747] = 7142; + rayToBps[1000000017091731311439662461] = 7143; + rayToBps[1000000017093580979974953404] = 7144; + rayToBps[1000000017095430540623255651] = 7145; + rayToBps[1000000017097279993397154077] = 7146; + rayToBps[1000000017099129338309231355] = 7147; + rayToBps[1000000017100978575372067958] = 7148; + rayToBps[1000000017102827704598242158] = 7149; + rayToBps[1000000017104676726000330021] = 7150; + rayToBps[1000000017106525639590905422] = 7151; + rayToBps[1000000017108374445382540031] = 7152; + rayToBps[1000000017110223143387803320] = 7153; + rayToBps[1000000017112071733619262563] = 7154; + rayToBps[1000000017113920216089482839] = 7155; + rayToBps[1000000017115768590811027024] = 7156; + rayToBps[1000000017117616857796455803] = 7157; + rayToBps[1000000017119465017058327660] = 7158; + rayToBps[1000000017121313068609198888] = 7159; + rayToBps[1000000017123161012461623580] = 7160; + rayToBps[1000000017125008848628153638] = 7161; + rayToBps[1000000017126856577121338769] = 7162; + rayToBps[1000000017128704197953726483] = 7163; + rayToBps[1000000017130551711137862102] = 7164; + rayToBps[1000000017132399116686288751] = 7165; + rayToBps[1000000017134246414611547366] = 7166; + rayToBps[1000000017136093604926176691] = 7167; + rayToBps[1000000017137940687642713275] = 7168; + rayToBps[1000000017139787662773691483] = 7169; + rayToBps[1000000017141634530331643482] = 7170; + rayToBps[1000000017143481290329099258] = 7171; + rayToBps[1000000017145327942778586600] = 7172; + rayToBps[1000000017147174487692631114] = 7173; + rayToBps[1000000017149020925083756215] = 7174; + rayToBps[1000000017150867254964483131] = 7175; + rayToBps[1000000017152713477347330904] = 7176; + rayToBps[1000000017154559592244816389] = 7177; + rayToBps[1000000017156405599669454253] = 7178; + rayToBps[1000000017158251499633756981] = 7179; + rayToBps[1000000017160097292150234871] = 7180; + rayToBps[1000000017161942977231396035] = 7181; + rayToBps[1000000017163788554889746405] = 7182; + rayToBps[1000000017165634025137789725] = 7183; + rayToBps[1000000017167479387988027559] = 7184; + rayToBps[1000000017169324643452959289] = 7185; + rayToBps[1000000017171169791545082111] = 7186; + rayToBps[1000000017173014832276891044] = 7187; + rayToBps[1000000017174859765660878925] = 7188; + rayToBps[1000000017176704591709536409] = 7189; + rayToBps[1000000017178549310435351971] = 7190; + rayToBps[1000000017180393921850811909] = 7191; + rayToBps[1000000017182238425968400340] = 7192; + rayToBps[1000000017184082822800599204] = 7193; + rayToBps[1000000017185927112359888261] = 7194; + rayToBps[1000000017187771294658745097] = 7195; + rayToBps[1000000017189615369709645117] = 7196; + rayToBps[1000000017191459337525061551] = 7197; + rayToBps[1000000017193303198117465456] = 7198; + rayToBps[1000000017195146951499325710] = 7199; + rayToBps[1000000017196990597683109018] = 7200; + rayToBps[1000000017198834136681279909] = 7201; + rayToBps[1000000017200677568506300742] = 7202; + rayToBps[1000000017202520893170631697] = 7203; + rayToBps[1000000017204364110686730786] = 7204; + rayToBps[1000000017206207221067053846] = 7205; + rayToBps[1000000017208050224324054541] = 7206; + rayToBps[1000000017209893120470184369] = 7207; + rayToBps[1000000017211735909517892653] = 7208; + rayToBps[1000000017213578591479626545] = 7209; + rayToBps[1000000017215421166367831029] = 7210; + rayToBps[1000000017217263634194948920] = 7211; + rayToBps[1000000017219105994973420864] = 7212; + rayToBps[1000000017220948248715685336] = 7213; + rayToBps[1000000017222790395434178647] = 7214; + rayToBps[1000000017224632435141334939] = 7215; + rayToBps[1000000017226474367849586187] = 7216; + rayToBps[1000000017228316193571362200] = 7217; + rayToBps[1000000017230157912319090621] = 7218; + rayToBps[1000000017231999524105196929] = 7219; + rayToBps[1000000017233841028942104436] = 7220; + rayToBps[1000000017235682426842234291] = 7221; + rayToBps[1000000017237523717818005480] = 7222; + rayToBps[1000000017239364901881834825] = 7223; + rayToBps[1000000017241205979046136983] = 7224; + rayToBps[1000000017243046949323324453] = 7225; + rayToBps[1000000017244887812725807569] = 7226; + rayToBps[1000000017246728569265994504] = 7227; + rayToBps[1000000017248569218956291274] = 7228; + rayToBps[1000000017250409761809101729] = 7229; + rayToBps[1000000017252250197836827562] = 7230; + rayToBps[1000000017254090527051868307] = 7231; + rayToBps[1000000017255930749466621341] = 7232; + rayToBps[1000000017257770865093481878] = 7233; + rayToBps[1000000017259610873944842979] = 7234; + rayToBps[1000000017261450776033095544] = 7235; + rayToBps[1000000017263290571370628319] = 7236; + rayToBps[1000000017265130259969827893] = 7237; + rayToBps[1000000017266969841843078698] = 7238; + rayToBps[1000000017268809317002763012] = 7239; + rayToBps[1000000017270648685461260960] = 7240; + rayToBps[1000000017272487947230950506] = 7241; + rayToBps[1000000017274327102324207470] = 7242; + rayToBps[1000000017276166150753405511] = 7243; + rayToBps[1000000017278005092530916139] = 7244; + rayToBps[1000000017279843927669108709] = 7245; + rayToBps[1000000017281682656180350428] = 7246; + rayToBps[1000000017283521278077006348] = 7247; + rayToBps[1000000017285359793371439374] = 7248; + rayToBps[1000000017287198202076010256] = 7249; + rayToBps[1000000017289036504203077600] = 7250; + rayToBps[1000000017290874699764997857] = 7251; + rayToBps[1000000017292712788774125333] = 7252; + rayToBps[1000000017294550771242812185] = 7253; + rayToBps[1000000017296388647183408421] = 7254; + rayToBps[1000000017298226416608261903] = 7255; + rayToBps[1000000017300064079529718345] = 7256; + rayToBps[1000000017301901635960121318] = 7257; + rayToBps[1000000017303739085911812243] = 7258; + rayToBps[1000000017305576429397130398] = 7259; + rayToBps[1000000017307413666428412915] = 7260; + rayToBps[1000000017309250797017994782] = 7261; + rayToBps[1000000017311087821178208846] = 7262; + rayToBps[1000000017312924738921385806] = 7263; + rayToBps[1000000017314761550259854221] = 7264; + rayToBps[1000000017316598255205940510] = 7265; + rayToBps[1000000017318434853771968943] = 7266; + rayToBps[1000000017320271345970261657] = 7267; + rayToBps[1000000017322107731813138642] = 7268; + rayToBps[1000000017323944011312917751] = 7269; + rayToBps[1000000017325780184481914696] = 7270; + rayToBps[1000000017327616251332443050] = 7271; + rayToBps[1000000017329452211876814248] = 7272; + rayToBps[1000000017331288066127337584] = 7273; + rayToBps[1000000017333123814096320217] = 7274; + rayToBps[1000000017334959455796067168] = 7275; + rayToBps[1000000017336794991238881320] = 7276; + rayToBps[1000000017338630420437063420] = 7277; + rayToBps[1000000017340465743402912081] = 7278; + rayToBps[1000000017342300960148723777] = 7279; + rayToBps[1000000017344136070686792852] = 7280; + rayToBps[1000000017345971075029411511] = 7281; + rayToBps[1000000017347805973188869827] = 7282; + rayToBps[1000000017349640765177455741] = 7283; + rayToBps[1000000017351475451007455060] = 7284; + rayToBps[1000000017353310030691151455] = 7285; + rayToBps[1000000017355144504240826473] = 7286; + rayToBps[1000000017356978871668759522] = 7287; + rayToBps[1000000017358813132987227884] = 7288; + rayToBps[1000000017360647288208506708] = 7289; + rayToBps[1000000017362481337344869013] = 7290; + rayToBps[1000000017364315280408585691] = 7291; + rayToBps[1000000017366149117411925502] = 7292; + rayToBps[1000000017367982848367155079] = 7293; + rayToBps[1000000017369816473286538927] = 7294; + rayToBps[1000000017371649992182339426] = 7295; + rayToBps[1000000017373483405066816824] = 7296; + rayToBps[1000000017375316711952229244] = 7297; + rayToBps[1000000017377149912850832687] = 7298; + rayToBps[1000000017378983007774881025] = 7299; + rayToBps[1000000017380815996736626004] = 7300; + rayToBps[1000000017382648879748317248] = 7301; + rayToBps[1000000017384481656822202255] = 7302; + rayToBps[1000000017386314327970526403] = 7303; + rayToBps[1000000017388146893205532943] = 7304; + rayToBps[1000000017389979352539463003] = 7305; + rayToBps[1000000017391811705984555594] = 7306; + rayToBps[1000000017393643953553047601] = 7307; + rayToBps[1000000017395476095257173788] = 7308; + rayToBps[1000000017397308131109166801] = 7309; + rayToBps[1000000017399140061121257164] = 7310; + rayToBps[1000000017400971885305673282] = 7311; + rayToBps[1000000017402803603674641440] = 7312; + rayToBps[1000000017404635216240385805] = 7313; + rayToBps[1000000017406466723015128428] = 7314; + rayToBps[1000000017408298124011089238] = 7315; + rayToBps[1000000017410129419240486051] = 7316; + rayToBps[1000000017411960608715534563] = 7317; + rayToBps[1000000017413791692448448355] = 7318; + rayToBps[1000000017415622670451438895] = 7319; + rayToBps[1000000017417453542736715530] = 7320; + rayToBps[1000000017419284309316485497] = 7321; + rayToBps[1000000017421114970202953919] = 7322; + rayToBps[1000000017422945525408323801] = 7323; + rayToBps[1000000017424775974944796039] = 7324; + rayToBps[1000000017426606318824569415] = 7325; + rayToBps[1000000017428436557059840598] = 7326; + rayToBps[1000000017430266689662804144] = 7327; + rayToBps[1000000017432096716645652500] = 7328; + rayToBps[1000000017433926638020576003] = 7329; + rayToBps[1000000017435756453799762877] = 7330; + rayToBps[1000000017437586163995399235] = 7331; + rayToBps[1000000017439415768619669087] = 7332; + rayToBps[1000000017441245267684754328] = 7333; + rayToBps[1000000017443074661202834746] = 7334; + rayToBps[1000000017444903949186088022] = 7335; + rayToBps[1000000017446733131646689731] = 7336; + rayToBps[1000000017448562208596813336] = 7337; + rayToBps[1000000017450391180048630201] = 7338; + rayToBps[1000000017452220046014309577] = 7339; + rayToBps[1000000017454048806506018613] = 7340; + rayToBps[1000000017455877461535922354] = 7341; + rayToBps[1000000017457706011116183737] = 7342; + rayToBps[1000000017459534455258963600] = 7343; + rayToBps[1000000017461362793976420670] = 7344; + rayToBps[1000000017463191027280711580] = 7345; + rayToBps[1000000017465019155183990853] = 7346; + rayToBps[1000000017466847177698410915] = 7347; + rayToBps[1000000017468675094836122086] = 7348; + rayToBps[1000000017470502906609272589] = 7349; + rayToBps[1000000017472330613030008543] = 7350; + rayToBps[1000000017474158214110473970] = 7351; + rayToBps[1000000017475985709862810789] = 7352; + rayToBps[1000000017477813100299158823] = 7353; + rayToBps[1000000017479640385431655794] = 7354; + rayToBps[1000000017481467565272437328] = 7355; + rayToBps[1000000017483294639833636950] = 7356; + rayToBps[1000000017485121609127386092] = 7357; + rayToBps[1000000017486948473165814085] = 7358; + rayToBps[1000000017488775231961048167] = 7359; + rayToBps[1000000017490601885525213478] = 7360; + rayToBps[1000000017492428433870433064] = 7361; + rayToBps[1000000017494254877008827878] = 7362; + rayToBps[1000000017496081214952516772] = 7363; + rayToBps[1000000017497907447713616513] = 7364; + rayToBps[1000000017499733575304241768] = 7365; + rayToBps[1000000017501559597736505115] = 7366; + rayToBps[1000000017503385515022517037] = 7367; + rayToBps[1000000017505211327174385925] = 7368; + rayToBps[1000000017507037034204218081] = 7369; + rayToBps[1000000017508862636124117716] = 7370; + rayToBps[1000000017510688132946186946] = 7371; + rayToBps[1000000017512513524682525802] = 7372; + rayToBps[1000000017514338811345232225] = 7373; + rayToBps[1000000017516163992946402063] = 7374; + rayToBps[1000000017517989069498129080] = 7375; + rayToBps[1000000017519814041012504950] = 7376; + rayToBps[1000000017521638907501619258] = 7377; + rayToBps[1000000017523463668977559505] = 7378; + rayToBps[1000000017525288325452411102] = 7379; + rayToBps[1000000017527112876938257378] = 7380; + rayToBps[1000000017528937323447179572] = 7381; + rayToBps[1000000017530761664991256840] = 7382; + rayToBps[1000000017532585901582566253] = 7383; + rayToBps[1000000017534410033233182798] = 7384; + rayToBps[1000000017536234059955179379] = 7385; + rayToBps[1000000017538057981760626814] = 7386; + rayToBps[1000000017539881798661593840] = 7387; + rayToBps[1000000017541705510670147114] = 7388; + rayToBps[1000000017543529117798351206] = 7389; + rayToBps[1000000017545352620058268609] = 7390; + rayToBps[1000000017547176017461959733] = 7391; + rayToBps[1000000017548999310021482909] = 7392; + rayToBps[1000000017550822497748894386] = 7393; + rayToBps[1000000017552645580656248336] = 7394; + rayToBps[1000000017554468558755596849] = 7395; + rayToBps[1000000017556291432058989941] = 7396; + rayToBps[1000000017558114200578475546] = 7397; + rayToBps[1000000017559936864326099522] = 7398; + rayToBps[1000000017561759423313905650] = 7399; + rayToBps[1000000017563581877553935633] = 7400; + rayToBps[1000000017565404227058229101] = 7401; + rayToBps[1000000017567226471838823606] = 7402; + rayToBps[1000000017569048611907754624] = 7403; + rayToBps[1000000017570870647277055559] = 7404; + rayToBps[1000000017572692577958757738] = 7405; + rayToBps[1000000017574514403964890419] = 7406; + rayToBps[1000000017576336125307480780] = 7407; + rayToBps[1000000017578157741998553932] = 7408; + rayToBps[1000000017579979254050132911] = 7409; + rayToBps[1000000017581800661474238681] = 7410; + rayToBps[1000000017583621964282890136] = 7411; + rayToBps[1000000017585443162488104098] = 7412; + rayToBps[1000000017587264256101895320] = 7413; + rayToBps[1000000017589085245136276485] = 7414; + rayToBps[1000000017590906129603258203] = 7415; + rayToBps[1000000017592726909514849021] = 7416; + rayToBps[1000000017594547584883055411] = 7417; + rayToBps[1000000017596368155719881784] = 7418; + rayToBps[1000000017598188622037330478] = 7419; + rayToBps[1000000017600008983847401766] = 7420; + rayToBps[1000000017601829241162093854] = 7421; + rayToBps[1000000017603649393993402882] = 7422; + rayToBps[1000000017605469442353322925] = 7423; + rayToBps[1000000017607289386253845993] = 7424; + rayToBps[1000000017609109225706962029] = 7425; + rayToBps[1000000017610928960724658915] = 7426; + rayToBps[1000000017612748591318922467] = 7427; + rayToBps[1000000017614568117501736438] = 7428; + rayToBps[1000000017616387539285082519] = 7429; + rayToBps[1000000017618206856680940339] = 7430; + rayToBps[1000000017620026069701287465] = 7431; + rayToBps[1000000017621845178358099399] = 7432; + rayToBps[1000000017623664182663349590] = 7433; + rayToBps[1000000017625483082629009418] = 7434; + rayToBps[1000000017627301878267048209] = 7435; + rayToBps[1000000017629120569589433226] = 7436; + rayToBps[1000000017630939156608129676] = 7437; + rayToBps[1000000017632757639335100704] = 7438; + rayToBps[1000000017634576017782307401] = 7439; + rayToBps[1000000017636394291961708797] = 7440; + rayToBps[1000000017638212461885261865] = 7441; + rayToBps[1000000017640030527564921525] = 7442; + rayToBps[1000000017641848489012640637] = 7443; + rayToBps[1000000017643666346240370005] = 7444; + rayToBps[1000000017645484099260058384] = 7445; + rayToBps[1000000017647301748083652465] = 7446; + rayToBps[1000000017649119292723096891] = 7447; + rayToBps[1000000017650936733190334250] = 7448; + rayToBps[1000000017652754069497305076] = 7449; + rayToBps[1000000017654571301655947851] = 7450; + rayToBps[1000000017656388429678199002] = 7451; + rayToBps[1000000017658205453575992908] = 7452; + rayToBps[1000000017660022373361261892] = 7453; + rayToBps[1000000017661839189045936232] = 7454; + rayToBps[1000000017663655900641944150] = 7455; + rayToBps[1000000017665472508161211819] = 7456; + rayToBps[1000000017667289011615663365] = 7457; + rayToBps[1000000017669105411017220864] = 7458; + rayToBps[1000000017670921706377804340] = 7459; + rayToBps[1000000017672737897709331773] = 7460; + rayToBps[1000000017674553985023719095] = 7461; + rayToBps[1000000017676369968332880187] = 7462; + rayToBps[1000000017678185847648726887] = 7463; + rayToBps[1000000017680001622983168986] = 7464; + rayToBps[1000000017681817294348114228] = 7465; + rayToBps[1000000017683632861755468312] = 7466; + rayToBps[1000000017685448325217134893] = 7467; + rayToBps[1000000017687263684745015581] = 7468; + rayToBps[1000000017689078940351009940] = 7469; + rayToBps[1000000017690894092047015496] = 7470; + rayToBps[1000000017692709139844927726] = 7471; + rayToBps[1000000017694524083756640068] = 7472; + rayToBps[1000000017696338923794043916] = 7473; + rayToBps[1000000017698153659969028624] = 7474; + rayToBps[1000000017699968292293481503] = 7475; + rayToBps[1000000017701782820779287826] = 7476; + rayToBps[1000000017703597245438330823] = 7477; + rayToBps[1000000017705411566282491686] = 7478; + rayToBps[1000000017707225783323649568] = 7479; + rayToBps[1000000017709039896573681579] = 7480; + rayToBps[1000000017710853906044462798] = 7481; + rayToBps[1000000017712667811747866261] = 7482; + rayToBps[1000000017714481613695762967] = 7483; + rayToBps[1000000017716295311900021878] = 7484; + rayToBps[1000000017718108906372509921] = 7485; + rayToBps[1000000017719922397125091988] = 7486; + rayToBps[1000000017721735784169630931] = 7487; + rayToBps[1000000017723549067517987571] = 7488; + rayToBps[1000000017725362247182020693] = 7489; + rayToBps[1000000017727175323173587048] = 7490; + rayToBps[1000000017728988295504541353] = 7491; + rayToBps[1000000017730801164186736290] = 7492; + rayToBps[1000000017732613929232022514] = 7493; + rayToBps[1000000017734426590652248641] = 7494; + rayToBps[1000000017736239148459261259] = 7495; + rayToBps[1000000017738051602664904924] = 7496; + rayToBps[1000000017739863953281022159] = 7497; + rayToBps[1000000017741676200319453460] = 7498; + rayToBps[1000000017743488343792037292] = 7499; + rayToBps[1000000017745300383710610088] = 7500; + rayToBps[1000000017747112320087006255] = 7501; + rayToBps[1000000017748924152933058170] = 7502; + rayToBps[1000000017750735882260596182] = 7503; + rayToBps[1000000017752547508081448613] = 7504; + rayToBps[1000000017754359030407441756] = 7505; + rayToBps[1000000017756170449250399880] = 7506; + rayToBps[1000000017757981764622145224] = 7507; + rayToBps[1000000017759792976534498007] = 7508; + rayToBps[1000000017761604084999276416] = 7509; + rayToBps[1000000017763415090028296618] = 7510; + rayToBps[1000000017765225991633372753] = 7511; + rayToBps[1000000017767036789826316939] = 7512; + rayToBps[1000000017768847484618939268] = 7513; + rayToBps[1000000017770658076023047811] = 7514; + rayToBps[1000000017772468564050448615] = 7515; + rayToBps[1000000017774278948712945708] = 7516; + rayToBps[1000000017776089230022341092] = 7517; + rayToBps[1000000017777899407990434751] = 7518; + rayToBps[1000000017779709482629024645] = 7519; + rayToBps[1000000017781519453949906719] = 7520; + rayToBps[1000000017783329321964874894] = 7521; + rayToBps[1000000017785139086685721072] = 7522; + rayToBps[1000000017786948748124235137] = 7523; + rayToBps[1000000017788758306292204955] = 7524; + rayToBps[1000000017790567761201416374] = 7525; + rayToBps[1000000017792377112863653223] = 7526; + rayToBps[1000000017794186361290697316] = 7527; + rayToBps[1000000017795995506494328448] = 7528; + rayToBps[1000000017797804548486324401] = 7529; + rayToBps[1000000017799613487278460940] = 7530; + rayToBps[1000000017801422322882511813] = 7531; + rayToBps[1000000017803231055310248755] = 7532; + rayToBps[1000000017805039684573441487] = 7533; + rayToBps[1000000017806848210683857715] = 7534; + rayToBps[1000000017808656633653263133] = 7535; + rayToBps[1000000017810464953493421421] = 7536; + rayToBps[1000000017812273170216094248] = 7537; + rayToBps[1000000017814081283833041270] = 7538; + rayToBps[1000000017815889294356020130] = 7539; + rayToBps[1000000017817697201796786462] = 7540; + rayToBps[1000000017819505006167093890] = 7541; + rayToBps[1000000017821312707478694026] = 7542; + rayToBps[1000000017823120305743336473] = 7543; + rayToBps[1000000017824927800972768824] = 7544; + rayToBps[1000000017826735193178736665] = 7545; + rayToBps[1000000017828542482372983573] = 7546; + rayToBps[1000000017830349668567251118] = 7547; + rayToBps[1000000017832156751773278858] = 7548; + rayToBps[1000000017833963732002804350] = 7549; + rayToBps[1000000017835770609267563142] = 7550; + rayToBps[1000000017837577383579288776] = 7551; + rayToBps[1000000017839384054949712789] = 7552; + rayToBps[1000000017841190623390564711] = 7553; + rayToBps[1000000017842997088913572069] = 7554; + rayToBps[1000000017844803451530460387] = 7555; + rayToBps[1000000017846609711252953183] = 7556; + rayToBps[1000000017848415868092771972] = 7557; + rayToBps[1000000017850221922061636268] = 7558; + rayToBps[1000000017852027873171263580] = 7559; + rayToBps[1000000017853833721433369417] = 7560; + rayToBps[1000000017855639466859667286] = 7561; + rayToBps[1000000017857445109461868694] = 7562; + rayToBps[1000000017859250649251683144] = 7563; + rayToBps[1000000017861056086240818144] = 7564; + rayToBps[1000000017862861420440979199] = 7565; + rayToBps[1000000017864666651863869815] = 7566; + rayToBps[1000000017866471780521191500] = 7567; + rayToBps[1000000017868276806424643763] = 7568; + rayToBps[1000000017870081729585924118] = 7569; + rayToBps[1000000017871886550016728077] = 7570; + rayToBps[1000000017873691267728749159] = 7571; + rayToBps[1000000017875495882733678884] = 7572; + rayToBps[1000000017877300395043206778] = 7573; + rayToBps[1000000017879104804669020371] = 7574; + rayToBps[1000000017880909111622805195] = 7575; + rayToBps[1000000017882713315916244793] = 7576; + rayToBps[1000000017884517417561020708] = 7577; + rayToBps[1000000017886321416568812494] = 7578; + rayToBps[1000000017888125312951297708] = 7579; + rayToBps[1000000017889929106720151917] = 7580; + rayToBps[1000000017891732797887048694] = 7581; + rayToBps[1000000017893536386463659622] = 7582; + rayToBps[1000000017895339872461654288] = 7583; + rayToBps[1000000017897143255892700294] = 7584; + rayToBps[1000000017898946536768463247] = 7585; + rayToBps[1000000017900749715100606767] = 7586; + rayToBps[1000000017902552790900792481] = 7587; + rayToBps[1000000017904355764180680030] = 7588; + rayToBps[1000000017906158634951927065] = 7589; + rayToBps[1000000017907961403226189248] = 7590; + rayToBps[1000000017909764069015120253] = 7591; + rayToBps[1000000017911566632330371770] = 7592; + rayToBps[1000000017913369093183593497] = 7593; + rayToBps[1000000017915171451586433149] = 7594; + rayToBps[1000000017916973707550536454] = 7595; + rayToBps[1000000017918775861087547154] = 7596; + rayToBps[1000000017920577912209107007] = 7597; + rayToBps[1000000017922379860926855785] = 7598; + rayToBps[1000000017924181707252431276] = 7599; + rayToBps[1000000017925983451197469286] = 7600; + rayToBps[1000000017927785092773603635] = 7601; + rayToBps[1000000017929586631992466162] = 7602; + rayToBps[1000000017931388068865686724] = 7603; + rayToBps[1000000017933189403404893193] = 7604; + rayToBps[1000000017934990635621711463] = 7605; + rayToBps[1000000017936791765527765445] = 7606; + rayToBps[1000000017938592793134677070] = 7607; + rayToBps[1000000017940393718454066288] = 7608; + rayToBps[1000000017942194541497551072] = 7609; + rayToBps[1000000017943995262276747410] = 7610; + rayToBps[1000000017945795880803269319] = 7611; + rayToBps[1000000017947596397088728831] = 7612; + rayToBps[1000000017949396811144736003] = 7613; + rayToBps[1000000017951197122982898913] = 7614; + rayToBps[1000000017952997332614823666] = 7615; + rayToBps[1000000017954797440052114387] = 7616; + rayToBps[1000000017956597445306373223] = 7617; + rayToBps[1000000017958397348389200349] = 7618; + rayToBps[1000000017960197149312193963] = 7619; + rayToBps[1000000017961996848086950291] = 7620; + rayToBps[1000000017963796444725063580] = 7621; + rayToBps[1000000017965595939238126106] = 7622; + rayToBps[1000000017967395331637728171] = 7623; + rayToBps[1000000017969194621935458105] = 7624; + rayToBps[1000000017970993810142902264] = 7625; + rayToBps[1000000017972792896271645032] = 7626; + rayToBps[1000000017974591880333268823] = 7627; + rayToBps[1000000017976390762339354077] = 7628; + rayToBps[1000000017978189542301479266] = 7629; + rayToBps[1000000017979988220231220891] = 7630; + rayToBps[1000000017981786796140153482] = 7631; + rayToBps[1000000017983585270039849600] = 7632; + rayToBps[1000000017985383641941879838] = 7633; + rayToBps[1000000017987181911857812820] = 7634; + rayToBps[1000000017988980079799215201] = 7635; + rayToBps[1000000017990778145777651670] = 7636; + rayToBps[1000000017992576109804684946] = 7637; + rayToBps[1000000017994373971891875786] = 7638; + rayToBps[1000000017996171732050782977] = 7639; + rayToBps[1000000017997969390292963342] = 7640; + rayToBps[1000000017999766946629971735] = 7641; + rayToBps[1000000018001564401073361051] = 7642; + rayToBps[1000000018003361753634682215] = 7643; + rayToBps[1000000018005159004325484191] = 7644; + rayToBps[1000000018006956153157313979] = 7645; + rayToBps[1000000018008753200141716615] = 7646; + rayToBps[1000000018010550145290235173] = 7647; + rayToBps[1000000018012346988614410765] = 7648; + rayToBps[1000000018014143730125782540] = 7649; + rayToBps[1000000018015940369835887686] = 7650; + rayToBps[1000000018017736907756261431] = 7651; + rayToBps[1000000018019533343898437042] = 7652; + rayToBps[1000000018021329678273945825] = 7653; + rayToBps[1000000018023125910894317128] = 7654; + rayToBps[1000000018024922041771078339] = 7655; + rayToBps[1000000018026718070915754887] = 7656; + rayToBps[1000000018028513998339870242] = 7657; + rayToBps[1000000018030309824054945918] = 7658; + rayToBps[1000000018032105548072501472] = 7659; + rayToBps[1000000018033901170404054502] = 7660; + rayToBps[1000000018035696691061120650] = 7661; + rayToBps[1000000018037492110055213602] = 7662; + rayToBps[1000000018039287427397845090] = 7663; + rayToBps[1000000018041082643100524888] = 7664; + rayToBps[1000000018042877757174760818] = 7665; + rayToBps[1000000018044672769632058746] = 7666; + rayToBps[1000000018046467680483922585] = 7667; + rayToBps[1000000018048262489741854293] = 7668; + rayToBps[1000000018050057197417353878] = 7669; + rayToBps[1000000018051851803521919393] = 7670; + rayToBps[1000000018053646308067046939] = 7671; + rayToBps[1000000018055440711064230668] = 7672; + rayToBps[1000000018057235012524962777] = 7673; + rayToBps[1000000018059029212460733515] = 7674; + rayToBps[1000000018060823310883031179] = 7675; + rayToBps[1000000018062617307803342118] = 7676; + rayToBps[1000000018064411203233150730] = 7677; + rayToBps[1000000018066204997183939464] = 7678; + rayToBps[1000000018067998689667188822] = 7679; + rayToBps[1000000018069792280694377358] = 7680; + rayToBps[1000000018071585770276981673] = 7681; + rayToBps[1000000018073379158426476430] = 7682; + rayToBps[1000000018075172445154334336] = 7683; + rayToBps[1000000018076965630472026159] = 7684; + rayToBps[1000000018078758714391020716] = 7685; + rayToBps[1000000018080551696922784882] = 7686; + rayToBps[1000000018082344578078783584] = 7687; + rayToBps[1000000018084137357870479807] = 7688; + rayToBps[1000000018085930036309334591] = 7689; + rayToBps[1000000018087722613406807031] = 7690; + rayToBps[1000000018089515089174354279] = 7691; + rayToBps[1000000018091307463623431547] = 7692; + rayToBps[1000000018093099736765492103] = 7693; + rayToBps[1000000018094891908611987271] = 7694; + rayToBps[1000000018096683979174366435] = 7695; + rayToBps[1000000018098475948464077039] = 7696; + rayToBps[1000000018100267816492564585] = 7697; + rayToBps[1000000018102059583271272636] = 7698; + rayToBps[1000000018103851248811642814] = 7699; + rayToBps[1000000018105642813125114801] = 7700; + rayToBps[1000000018107434276223126344] = 7701; + rayToBps[1000000018109225638117113246] = 7702; + rayToBps[1000000018111016898818509377] = 7703; + rayToBps[1000000018112808058338746667] = 7704; + rayToBps[1000000018114599116689255107] = 7705; + rayToBps[1000000018116390073881462757] = 7706; + rayToBps[1000000018118180929926795735] = 7707; + rayToBps[1000000018119971684836678225] = 7708; + rayToBps[1000000018121762338622532479] = 7709; + rayToBps[1000000018123552891295778807] = 7710; + rayToBps[1000000018125343342867835592] = 7711; + rayToBps[1000000018127133693350119278] = 7712; + rayToBps[1000000018128923942754044379] = 7713; + rayToBps[1000000018130714091091023470] = 7714; + rayToBps[1000000018132504138372467200] = 7715; + rayToBps[1000000018134294084609784283] = 7716; + rayToBps[1000000018136083929814381499] = 7717; + rayToBps[1000000018137873673997663698] = 7718; + rayToBps[1000000018139663317171033802] = 7719; + rayToBps[1000000018141452859345892798] = 7720; + rayToBps[1000000018143242300533639746] = 7721; + rayToBps[1000000018145031640745671772] = 7722; + rayToBps[1000000018146820879993384079] = 7723; + rayToBps[1000000018148610018288169936] = 7724; + rayToBps[1000000018150399055641420686] = 7725; + rayToBps[1000000018152187992064525743] = 7726; + rayToBps[1000000018153976827568872596] = 7727; + rayToBps[1000000018155765562165846803] = 7728; + rayToBps[1000000018157554195866831997] = 7729; + rayToBps[1000000018159342728683209886] = 7730; + rayToBps[1000000018161131160626360252] = 7731; + rayToBps[1000000018162919491707660948] = 7732; + rayToBps[1000000018164707721938487908] = 7733; + rayToBps[1000000018166495851330215138] = 7734; + rayToBps[1000000018168283879894214720] = 7735; + rayToBps[1000000018170071807641856811] = 7736; + rayToBps[1000000018171859634584509651] = 7737; + rayToBps[1000000018173647360733539548] = 7738; + rayToBps[1000000018175434986100310896] = 7739; + rayToBps[1000000018177222510696186163] = 7740; + rayToBps[1000000018179009934532525896] = 7741; + rayToBps[1000000018180797257620688721] = 7742; + rayToBps[1000000018182584479972031343] = 7743; + rayToBps[1000000018184371601597908550] = 7744; + rayToBps[1000000018186158622509673205] = 7745; + rayToBps[1000000018187945542718676256] = 7746; + rayToBps[1000000018189732362236266731] = 7747; + rayToBps[1000000018191519081073791739] = 7748; + rayToBps[1000000018193305699242596471] = 7749; + rayToBps[1000000018195092216754024201] = 7750; + rayToBps[1000000018196878633619416285] = 7751; + rayToBps[1000000018198664949850112165] = 7752; + rayToBps[1000000018200451165457449362] = 7753; + rayToBps[1000000018202237280452763485] = 7754; + rayToBps[1000000018204023294847388227] = 7755; + rayToBps[1000000018205809208652655365] = 7756; + rayToBps[1000000018207595021879894762] = 7757; + rayToBps[1000000018209380734540434368] = 7758; + rayToBps[1000000018211166346645600216] = 7759; + rayToBps[1000000018212951858206716428] = 7760; + rayToBps[1000000018214737269235105217] = 7761; + rayToBps[1000000018216522579742086876] = 7762; + rayToBps[1000000018218307789738979791] = 7763; + rayToBps[1000000018220092899237100435] = 7764; + rayToBps[1000000018221877908247763371] = 7765; + rayToBps[1000000018223662816782281250] = 7766; + rayToBps[1000000018225447624851964814] = 7767; + rayToBps[1000000018227232332468122895] = 7768; + rayToBps[1000000018229016939642062413] = 7769; + rayToBps[1000000018230801446385088385] = 7770; + rayToBps[1000000018232585852708503911] = 7771; + rayToBps[1000000018234370158623610192] = 7772; + rayToBps[1000000018236154364141706515] = 7773; + rayToBps[1000000018237938469274090263] = 7774; + rayToBps[1000000018239722474032056911] = 7775; + rayToBps[1000000018241506378426900026] = 7776; + rayToBps[1000000018243290182469911273] = 7777; + rayToBps[1000000018245073886172380408] = 7778; + rayToBps[1000000018246857489545595283] = 7779; + rayToBps[1000000018248640992600841846] = 7780; + rayToBps[1000000018250424395349404142] = 7781; + rayToBps[1000000018252207697802564308] = 7782; + rayToBps[1000000018253990899971602583] = 7783; + rayToBps[1000000018255774001867797298] = 7784; + rayToBps[1000000018257557003502424884] = 7785; + rayToBps[1000000018259339904886759871] = 7786; + rayToBps[1000000018261122706032074886] = 7787; + rayToBps[1000000018262905406949640654] = 7788; + rayToBps[1000000018264688007650726000] = 7789; + rayToBps[1000000018266470508146597849] = 7790; + rayToBps[1000000018268252908448521228] = 7791; + rayToBps[1000000018270035208567759259] = 7792; + rayToBps[1000000018271817408515573169] = 7793; + rayToBps[1000000018273599508303222287] = 7794; + rayToBps[1000000018275381507941964042] = 7795; + rayToBps[1000000018277163407443053964] = 7796; + rayToBps[1000000018278945206817745690] = 7797; + rayToBps[1000000018280726906077290954] = 7798; + rayToBps[1000000018282508505232939599] = 7799; + rayToBps[1000000018284290004295939569] = 7800; + rayToBps[1000000018286071403277536912] = 7801; + rayToBps[1000000018287852702188975783] = 7802; + rayToBps[1000000018289633901041498440] = 7803; + rayToBps[1000000018291414999846345249] = 7804; + rayToBps[1000000018293195998614754679] = 7805; + rayToBps[1000000018294976897357963307] = 7806; + rayToBps[1000000018296757696087205817] = 7807; + rayToBps[1000000018298538394813715001] = 7808; + rayToBps[1000000018300318993548721757] = 7809; + rayToBps[1000000018302099492303455093] = 7810; + rayToBps[1000000018303879891089142124] = 7811; + rayToBps[1000000018305660189917008076] = 7812; + rayToBps[1000000018307440388798276281] = 7813; + rayToBps[1000000018309220487744168184] = 7814; + rayToBps[1000000018311000486765903339] = 7815; + rayToBps[1000000018312780385874699412] = 7816; + rayToBps[1000000018314560185081772178] = 7817; + rayToBps[1000000018316339884398335526] = 7818; + rayToBps[1000000018318119483835601454] = 7819; + rayToBps[1000000018319898983404780074] = 7820; + rayToBps[1000000018321678383117079613] = 7821; + rayToBps[1000000018323457682983706407] = 7822; + rayToBps[1000000018325236883015864909] = 7823; + rayToBps[1000000018327015983224757684] = 7824; + rayToBps[1000000018328794983621585414] = 7825; + rayToBps[1000000018330573884217546893] = 7826; + rayToBps[1000000018332352685023839031] = 7827; + rayToBps[1000000018334131386051656857] = 7828; + rayToBps[1000000018335909987312193512] = 7829; + rayToBps[1000000018337688488816640255] = 7830; + rayToBps[1000000018339466890576186465] = 7831; + rayToBps[1000000018341245192602019632] = 7832; + rayToBps[1000000018343023394905325372] = 7833; + rayToBps[1000000018344801497497287412] = 7834; + rayToBps[1000000018346579500389087603] = 7835; + rayToBps[1000000018348357403591905911] = 7836; + rayToBps[1000000018350135207116920426] = 7837; + rayToBps[1000000018351912910975307354] = 7838; + rayToBps[1000000018353690515178241024] = 7839; + rayToBps[1000000018355468019736893884] = 7840; + rayToBps[1000000018357245424662436505] = 7841; + rayToBps[1000000018359022729966037580] = 7842; + rayToBps[1000000018360799935658863920] = 7843; + rayToBps[1000000018362577041752080465] = 7844; + rayToBps[1000000018364354048256850272] = 7845; + rayToBps[1000000018366130955184334526] = 7846; + rayToBps[1000000018367907762545692533] = 7847; + rayToBps[1000000018369684470352081722] = 7848; + rayToBps[1000000018371461078614657652] = 7849; + rayToBps[1000000018373237587344574003] = 7850; + rayToBps[1000000018375013996552982578] = 7851; + rayToBps[1000000018376790306251033313] = 7852; + rayToBps[1000000018378566516449874264] = 7853; + rayToBps[1000000018380342627160651618] = 7854; + rayToBps[1000000018382118638394509685] = 7855; + rayToBps[1000000018383894550162590906] = 7856; + rayToBps[1000000018385670362476035850] = 7857; + rayToBps[1000000018387446075345983212] = 7858; + rayToBps[1000000018389221688783569817] = 7859; + rayToBps[1000000018390997202799930621] = 7860; + rayToBps[1000000018392772617406198706] = 7861; + rayToBps[1000000018394547932613505288] = 7862; + rayToBps[1000000018396323148432979711] = 7863; + rayToBps[1000000018398098264875749451] = 7864; + rayToBps[1000000018399873281952940114] = 7865; + rayToBps[1000000018401648199675675439] = 7866; + rayToBps[1000000018403423018055077298] = 7867; + rayToBps[1000000018405197737102265694] = 7868; + rayToBps[1000000018406972356828358763] = 7869; + rayToBps[1000000018408746877244472776] = 7870; + rayToBps[1000000018410521298361722136] = 7871; + rayToBps[1000000018412295620191219382] = 7872; + rayToBps[1000000018414069842744075188] = 7873; + rayToBps[1000000018415843966031398359] = 7874; + rayToBps[1000000018417617990064295840] = 7875; + rayToBps[1000000018419391914853872712] = 7876; + rayToBps[1000000018421165740411232189] = 7877; + rayToBps[1000000018422939466747475623] = 7878; + rayToBps[1000000018424713093873702506] = 7879; + rayToBps[1000000018426486621801010465] = 7880; + rayToBps[1000000018428260050540495264] = 7881; + rayToBps[1000000018430033380103250808] = 7882; + rayToBps[1000000018431806610500369140] = 7883; + rayToBps[1000000018433579741742940441] = 7884; + rayToBps[1000000018435352773842053034] = 7885; + rayToBps[1000000018437125706808793381] = 7886; + rayToBps[1000000018438898540654246083] = 7887; + rayToBps[1000000018440671275389493885] = 7888; + rayToBps[1000000018442443911025617670] = 7889; + rayToBps[1000000018444216447573696466] = 7890; + rayToBps[1000000018445988885044807442] = 7891; + rayToBps[1000000018447761223450025908] = 7892; + rayToBps[1000000018449533462800425319] = 7893; + rayToBps[1000000018451305603107077273] = 7894; + rayToBps[1000000018453077644381051511] = 7895; + rayToBps[1000000018454849586633415920] = 7896; + rayToBps[1000000018456621429875236530] = 7897; + rayToBps[1000000018458393174117577515] = 7898; + rayToBps[1000000018460164819371501200] = 7899; + rayToBps[1000000018461936365648068049] = 7900; + rayToBps[1000000018463707812958336676] = 7901; + rayToBps[1000000018465479161313363842] = 7902; + rayToBps[1000000018467250410724204454] = 7903; + rayToBps[1000000018469021561201911568] = 7904; + rayToBps[1000000018470792612757536386] = 7905; + rayToBps[1000000018472563565402128258] = 7906; + rayToBps[1000000018474334419146734687] = 7907; + rayToBps[1000000018476105174002401321] = 7908; + rayToBps[1000000018477875829980171960] = 7909; + rayToBps[1000000018479646387091088551] = 7910; + rayToBps[1000000018481416845346191196] = 7911; + rayToBps[1000000018483187204756518145] = 7912; + rayToBps[1000000018484957465333105800] = 7913; + rayToBps[1000000018486727627086988714] = 7914; + rayToBps[1000000018488497690029199592] = 7915; + rayToBps[1000000018490267654170769294] = 7916; + rayToBps[1000000018492037519522726829] = 7917; + rayToBps[1000000018493807286096099365] = 7918; + rayToBps[1000000018495576953901912217] = 7919; + rayToBps[1000000018497346522951188860] = 7920; + rayToBps[1000000018499115993254950919] = 7921; + rayToBps[1000000018500885364824218178] = 7922; + rayToBps[1000000018502654637670008573] = 7923; + rayToBps[1000000018504423811803338199] = 7924; + rayToBps[1000000018506192887235221305] = 7925; + rayToBps[1000000018507961863976670296] = 7926; + rayToBps[1000000018509730742038695738] = 7927; + rayToBps[1000000018511499521432306350] = 7928; + rayToBps[1000000018513268202168509012] = 7929; + rayToBps[1000000018515036784258308760] = 7930; + rayToBps[1000000018516805267712708791] = 7931; + rayToBps[1000000018518573652542710459] = 7932; + rayToBps[1000000018520341938759313279] = 7933; + rayToBps[1000000018522110126373514925] = 7934; + rayToBps[1000000018523878215396311232] = 7935; + rayToBps[1000000018525646205838696196] = 7936; + rayToBps[1000000018527414097711661974] = 7937; + rayToBps[1000000018529181891026198882] = 7938; + rayToBps[1000000018530949585793295404] = 7939; + rayToBps[1000000018532717182023938179] = 7940; + rayToBps[1000000018534484679729112016] = 7941; + rayToBps[1000000018536252078919799882] = 7942; + rayToBps[1000000018538019379606982909] = 7943; + rayToBps[1000000018539786581801640396] = 7944; + rayToBps[1000000018541553685514749800] = 7945; + rayToBps[1000000018543320690757286750] = 7946; + rayToBps[1000000018545087597540225037] = 7947; + rayToBps[1000000018546854405874536615] = 7948; + rayToBps[1000000018548621115771191610] = 7949; + rayToBps[1000000018550387727241158310] = 7950; + rayToBps[1000000018552154240295403172] = 7951; + rayToBps[1000000018553920654944890818] = 7952; + rayToBps[1000000018555686971200584040] = 7953; + rayToBps[1000000018557453189073443800] = 7954; + rayToBps[1000000018559219308574429223] = 7955; + rayToBps[1000000018560985329714497605] = 7956; + rayToBps[1000000018562751252504604416] = 7957; + rayToBps[1000000018564517076955703290] = 7958; + rayToBps[1000000018566282803078746033] = 7959; + rayToBps[1000000018568048430884682622] = 7960; + rayToBps[1000000018569813960384461207] = 7961; + rayToBps[1000000018571579391589028103] = 7962; + rayToBps[1000000018573344724509327805] = 7963; + rayToBps[1000000018575109959156302976] = 7964; + rayToBps[1000000018576875095540894448] = 7965; + rayToBps[1000000018578640133674041234] = 7966; + rayToBps[1000000018580405073566680515] = 7967; + rayToBps[1000000018582169915229747647] = 7968; + rayToBps[1000000018583934658674176160] = 7969; + rayToBps[1000000018585699303910897760] = 7970; + rayToBps[1000000018587463850950842326] = 7971; + rayToBps[1000000018589228299804937915] = 7972; + rayToBps[1000000018590992650484110758] = 7973; + rayToBps[1000000018592756902999285262] = 7974; + rayToBps[1000000018594521057361384012] = 7975; + rayToBps[1000000018596285113581327769] = 7976; + rayToBps[1000000018598049071670035472] = 7977; + rayToBps[1000000018599812931638424240] = 7978; + rayToBps[1000000018601576693497409365] = 7979; + rayToBps[1000000018603340357257904322] = 7980; + rayToBps[1000000018605103922930820766] = 7981; + rayToBps[1000000018606867390527068528] = 7982; + rayToBps[1000000018608630760057555620] = 7983; + rayToBps[1000000018610394031533188235] = 7984; + rayToBps[1000000018612157204964870748] = 7985; + rayToBps[1000000018613920280363505711] = 7986; + rayToBps[1000000018615683257739993862] = 7987; + rayToBps[1000000018617446137105234120] = 7988; + rayToBps[1000000018619208918470123584] = 7989; + rayToBps[1000000018620971601845557538] = 7990; + rayToBps[1000000018622734187242429447] = 7991; + rayToBps[1000000018624496674671630963] = 7992; + rayToBps[1000000018626259064144051920] = 7993; + rayToBps[1000000018628021355670580334] = 7994; + rayToBps[1000000018629783549262102411] = 7995; + rayToBps[1000000018631545644929502537] = 7996; + rayToBps[1000000018633307642683663287] = 7997; + rayToBps[1000000018635069542535465422] = 7998; + rayToBps[1000000018636831344495787885] = 7999; + rayToBps[1000000018638593048575507813] = 8000; + rayToBps[1000000018640354654785500524] = 8001; + rayToBps[1000000018642116163136639525] = 8002; + rayToBps[1000000018643877573639796513] = 8003; + rayToBps[1000000018645638886305841373] = 8004; + rayToBps[1000000018647400101145642177] = 8005; + rayToBps[1000000018649161218170065187] = 8006; + rayToBps[1000000018650922237389974856] = 8007; + rayToBps[1000000018652683158816233826] = 8008; + rayToBps[1000000018654443982459702927] = 8009; + rayToBps[1000000018656204708331241185] = 8010; + rayToBps[1000000018657965336441705812] = 8011; + rayToBps[1000000018659725866801952216] = 8012; + rayToBps[1000000018661486299422833994] = 8013; + rayToBps[1000000018663246634315202936] = 8014; + rayToBps[1000000018665006871489909025] = 8015; + rayToBps[1000000018666767010957800439] = 8016; + rayToBps[1000000018668527052729723547] = 8017; + rayToBps[1000000018670286996816522913] = 8018; + rayToBps[1000000018672046843229041295] = 8019; + rayToBps[1000000018673806591978119648] = 8020; + rayToBps[1000000018675566243074597119] = 8021; + rayToBps[1000000018677325796529311054] = 8022; + rayToBps[1000000018679085252353096991] = 8023; + rayToBps[1000000018680844610556788668] = 8024; + rayToBps[1000000018682603871151218019] = 8025; + rayToBps[1000000018684363034147215174] = 8026; + rayToBps[1000000018686122099555608460] = 8027; + rayToBps[1000000018687881067387224406] = 8028; + rayToBps[1000000018689639937652887737] = 8029; + rayToBps[1000000018691398710363421374] = 8030; + rayToBps[1000000018693157385529646441] = 8031; + rayToBps[1000000018694915963162382261] = 8032; + rayToBps[1000000018696674443272446357] = 8033; + rayToBps[1000000018698432825870654450] = 8034; + rayToBps[1000000018700191110967820466] = 8035; + rayToBps[1000000018701949298574756529] = 8036; + rayToBps[1000000018703707388702272967] = 8037; + rayToBps[1000000018705465381361178307] = 8038; + rayToBps[1000000018707223276562279280] = 8039; + rayToBps[1000000018708981074316380821] = 8040; + rayToBps[1000000018710738774634286066] = 8041; + rayToBps[1000000018712496377526796358] = 8042; + rayToBps[1000000018714253883004711240] = 8043; + rayToBps[1000000018716011291078828461] = 8044; + rayToBps[1000000018717768601759943976] = 8045; + rayToBps[1000000018719525815058851943] = 8046; + rayToBps[1000000018721282930986344728] = 8047; + rayToBps[1000000018723039949553212902] = 8048; + rayToBps[1000000018724796870770245242] = 8049; + rayToBps[1000000018726553694648228732] = 8050; + rayToBps[1000000018728310421197948562] = 8051; + rayToBps[1000000018730067050430188132] = 8052; + rayToBps[1000000018731823582355729050] = 8053; + rayToBps[1000000018733580016985351129] = 8054; + rayToBps[1000000018735336354329832394] = 8055; + rayToBps[1000000018737092594399949079] = 8056; + rayToBps[1000000018738848737206475625] = 8057; + rayToBps[1000000018740604782760184687] = 8058; + rayToBps[1000000018742360731071847127] = 8059; + rayToBps[1000000018744116582152232018] = 8060; + rayToBps[1000000018745872336012106646] = 8061; + rayToBps[1000000018747627992662236508] = 8062; + rayToBps[1000000018749383552113385312] = 8063; + rayToBps[1000000018751139014376314979] = 8064; + rayToBps[1000000018752894379461785643] = 8065; + rayToBps[1000000018754649647380555651] = 8066; + rayToBps[1000000018756404818143381562] = 8067; + rayToBps[1000000018758159891761018152] = 8068; + rayToBps[1000000018759914868244218410] = 8069; + rayToBps[1000000018761669747603733537] = 8070; + rayToBps[1000000018763424529850312954] = 8071; + rayToBps[1000000018765179214994704293] = 8072; + rayToBps[1000000018766933803047653406] = 8073; + rayToBps[1000000018768688294019904359] = 8074; + rayToBps[1000000018770442687922199432] = 8075; + rayToBps[1000000018772196984765279129] = 8076; + rayToBps[1000000018773951184559882166] = 8077; + rayToBps[1000000018775705287316745477] = 8078; + rayToBps[1000000018777459293046604218] = 8079; + rayToBps[1000000018779213201760191760] = 8080; + rayToBps[1000000018780967013468239695] = 8081; + rayToBps[1000000018782720728181477833] = 8082; + rayToBps[1000000018784474345910634206] = 8083; + rayToBps[1000000018786227866666435065] = 8084; + rayToBps[1000000018787981290459604881] = 8085; + rayToBps[1000000018789734617300866347] = 8086; + rayToBps[1000000018791487847200940377] = 8087; + rayToBps[1000000018793240980170546107] = 8088; + rayToBps[1000000018794994016220400896] = 8089; + rayToBps[1000000018796746955361220324] = 8090; + rayToBps[1000000018798499797603718194] = 8091; + rayToBps[1000000018800252542958606535] = 8092; + rayToBps[1000000018802005191436595596] = 8093; + rayToBps[1000000018803757743048393855] = 8094; + rayToBps[1000000018805510197804708009] = 8095; + rayToBps[1000000018807262555716242984] = 8096; + rayToBps[1000000018809014816793701930] = 8097; + rayToBps[1000000018810766981047786222] = 8098; + rayToBps[1000000018812519048489195463] = 8099; + rayToBps[1000000018814271019128627481] = 8100; + rayToBps[1000000018816022892976778332] = 8101; + rayToBps[1000000018817774670044342299] = 8102; + rayToBps[1000000018819526350342011891] = 8103; + rayToBps[1000000018821277933880477847] = 8104; + rayToBps[1000000018823029420670429136] = 8105; + rayToBps[1000000018824780810722552952] = 8106; + rayToBps[1000000018826532104047534720] = 8107; + rayToBps[1000000018828283300656058095] = 8108; + rayToBps[1000000018830034400558804964] = 8109; + rayToBps[1000000018831785403766455440] = 8110; + rayToBps[1000000018833536310289687871] = 8111; + rayToBps[1000000018835287120139178833] = 8112; + rayToBps[1000000018837037833325603137] = 8113; + rayToBps[1000000018838788449859633821] = 8114; + rayToBps[1000000018840538969751942163] = 8115; + rayToBps[1000000018842289393013197665] = 8116; + rayToBps[1000000018844039719654068068] = 8117; + rayToBps[1000000018845789949685219346] = 8118; + rayToBps[1000000018847540083117315706] = 8119; + rayToBps[1000000018849290119961019588] = 8120; + rayToBps[1000000018851040060226991670] = 8121; + rayToBps[1000000018852789903925890862] = 8122; + rayToBps[1000000018854539651068374310] = 8123; + rayToBps[1000000018856289301665097399] = 8124; + rayToBps[1000000018858038855726713746] = 8125; + rayToBps[1000000018859788313263875208] = 8126; + rayToBps[1000000018861537674287231877] = 8127; + rayToBps[1000000018863286938807432083] = 8128; + rayToBps[1000000018865036106835122396] = 8129; + rayToBps[1000000018866785178380947620] = 8130; + rayToBps[1000000018868534153455550800] = 8131; + rayToBps[1000000018870283032069573223] = 8132; + rayToBps[1000000018872031814233654409] = 8133; + rayToBps[1000000018873780499958432124] = 8134; + rayToBps[1000000018875529089254542368] = 8135; + rayToBps[1000000018877277582132619389] = 8136; + rayToBps[1000000018879025978603295669] = 8137; + rayToBps[1000000018880774278677201936] = 8138; + rayToBps[1000000018882522482364967158] = 8139; + rayToBps[1000000018884270589677218543] = 8140; + rayToBps[1000000018886018600624581547] = 8141; + rayToBps[1000000018887766515217679862] = 8142; + rayToBps[1000000018889514333467135430] = 8143; + rayToBps[1000000018891262055383568433] = 8144; + rayToBps[1000000018893009680977597295] = 8145; + rayToBps[1000000018894757210259838691] = 8146; + rayToBps[1000000018896504643240907534] = 8147; + rayToBps[1000000018898251979931416987] = 8148; + rayToBps[1000000018899999220341978457] = 8149; + rayToBps[1000000018901746364483201594] = 8150; + rayToBps[1000000018903493412365694300] = 8151; + rayToBps[1000000018905240364000062719] = 8152; + rayToBps[1000000018906987219396911245] = 8153; + rayToBps[1000000018908733978566842519] = 8154; + rayToBps[1000000018910480641520457429] = 8155; + rayToBps[1000000018912227208268355112] = 8156; + rayToBps[1000000018913973678821132954] = 8157; + rayToBps[1000000018915720053189386589] = 8158; + rayToBps[1000000018917466331383709901] = 8159; + rayToBps[1000000018919212513414695026] = 8160; + rayToBps[1000000018920958599292932347] = 8161; + rayToBps[1000000018922704589029010497] = 8162; + rayToBps[1000000018924450482633516364] = 8163; + rayToBps[1000000018926196280117035085] = 8164; + rayToBps[1000000018927941981490150050] = 8165; + rayToBps[1000000018929687586763442899] = 8166; + rayToBps[1000000018931433095947493526] = 8167; + rayToBps[1000000018933178509052880078] = 8168; + rayToBps[1000000018934923826090178954] = 8169; + rayToBps[1000000018936669047069964810] = 8170; + rayToBps[1000000018938414172002810552] = 8171; + rayToBps[1000000018940159200899287344] = 8172; + rayToBps[1000000018941904133769964603] = 8173; + rayToBps[1000000018943648970625410000] = 8174; + rayToBps[1000000018945393711476189463] = 8175; + rayToBps[1000000018947138356332867178] = 8176; + rayToBps[1000000018948882905206005585] = 8177; + rayToBps[1000000018950627358106165381] = 8178; + rayToBps[1000000018952371715043905520] = 8179; + rayToBps[1000000018954115976029783215] = 8180; + rayToBps[1000000018955860141074353935] = 8181; + rayToBps[1000000018957604210188171410] = 8182; + rayToBps[1000000018959348183381787625] = 8183; + rayToBps[1000000018961092060665752828] = 8184; + rayToBps[1000000018962835842050615522] = 8185; + rayToBps[1000000018964579527546922474] = 8186; + rayToBps[1000000018966323117165218711] = 8187; + rayToBps[1000000018968066610916047517] = 8188; + rayToBps[1000000018969810008809950439] = 8189; + rayToBps[1000000018971553310857467288] = 8190; + rayToBps[1000000018973296517069136132] = 8191; + rayToBps[1000000018975039627455493305] = 8192; + rayToBps[1000000018976782642027073402] = 8193; + rayToBps[1000000018978525560794409280] = 8194; + rayToBps[1000000018980268383768032061] = 8195; + rayToBps[1000000018982011110958471130] = 8196; + rayToBps[1000000018983753742376254135] = 8197; + rayToBps[1000000018985496278031906990] = 8198; + rayToBps[1000000018987238717935953874] = 8199; + rayToBps[1000000018988981062098917230] = 8200; + rayToBps[1000000018990723310531317765] = 8201; + rayToBps[1000000018992465463243674457] = 8202; + rayToBps[1000000018994207520246504546] = 8203; + rayToBps[1000000018995949481550323540] = 8204; + rayToBps[1000000018997691347165645214] = 8205; + rayToBps[1000000018999433117102981611] = 8206; + rayToBps[1000000019001174791372843041] = 8207; + rayToBps[1000000019002916369985738082] = 8208; + rayToBps[1000000019004657852952173583] = 8209; + rayToBps[1000000019006399240282654660] = 8210; + rayToBps[1000000019008140531987684699] = 8211; + rayToBps[1000000019009881728077765354] = 8212; + rayToBps[1000000019011622828563396552] = 8213; + rayToBps[1000000019013363833455076488] = 8214; + rayToBps[1000000019015104742763301630] = 8215; + rayToBps[1000000019016845556498566716] = 8216; + rayToBps[1000000019018586274671364757] = 8217; + rayToBps[1000000019020326897292187034] = 8218; + rayToBps[1000000019022067424371523101] = 8219; + rayToBps[1000000019023807855919860787] = 8220; + rayToBps[1000000019025548191947686191] = 8221; + rayToBps[1000000019027288432465483687] = 8222; + rayToBps[1000000019029028577483735925] = 8223; + rayToBps[1000000019030768627012923824] = 8224; + rayToBps[1000000019032508581063526585] = 8225; + rayToBps[1000000019034248439646021677] = 8226; + rayToBps[1000000019035988202770884848] = 8227; + rayToBps[1000000019037727870448590123] = 8228; + rayToBps[1000000019039467442689609800] = 8229; + rayToBps[1000000019041206919504414455] = 8230; + rayToBps[1000000019042946300903472942] = 8231; + rayToBps[1000000019044685586897252392] = 8232; + rayToBps[1000000019046424777496218212] = 8233; + rayToBps[1000000019048163872710834089] = 8234; + rayToBps[1000000019049902872551561987] = 8235; + rayToBps[1000000019051641777028862150] = 8236; + rayToBps[1000000019053380586153193101] = 8237; + rayToBps[1000000019055119299935011644] = 8238; + rayToBps[1000000019056857918384772859] = 8239; + rayToBps[1000000019058596441512930110] = 8240; + rayToBps[1000000019060334869329935041] = 8241; + rayToBps[1000000019062073201846237576] = 8242; + rayToBps[1000000019063811439072285921] = 8243; + rayToBps[1000000019065549581018526566] = 8244; + rayToBps[1000000019067287627695404278] = 8245; + rayToBps[1000000019069025579113362113] = 8246; + rayToBps[1000000019070763435282841406] = 8247; + rayToBps[1000000019072501196214281776] = 8248; + rayToBps[1000000019074238861918121125] = 8249; + rayToBps[1000000019075976432404795643] = 8250; + rayToBps[1000000019077713907684739801] = 8251; + rayToBps[1000000019079451287768386354] = 8252; + rayToBps[1000000019081188572666166345] = 8253; + rayToBps[1000000019082925762388509101] = 8254; + rayToBps[1000000019084662856945842236] = 8255; + rayToBps[1000000019086399856348591650] = 8256; + rayToBps[1000000019088136760607181530] = 8257; + rayToBps[1000000019089873569732034349] = 8258; + rayToBps[1000000019091610283733570869] = 8259; + rayToBps[1000000019093346902622210139] = 8260; + rayToBps[1000000019095083426408369496] = 8261; + rayToBps[1000000019096819855102464568] = 8262; + rayToBps[1000000019098556188714909268] = 8263; + rayToBps[1000000019100292427256115802] = 8264; + rayToBps[1000000019102028570736494664] = 8265; + rayToBps[1000000019103764619166454637] = 8266; + rayToBps[1000000019105500572556402798] = 8267; + rayToBps[1000000019107236430916744512] = 8268; + rayToBps[1000000019108972194257883436] = 8269; + rayToBps[1000000019110707862590221519] = 8270; + rayToBps[1000000019112443435924159001] = 8271; + rayToBps[1000000019114178914270094416] = 8272; + rayToBps[1000000019115914297638424590] = 8273; + rayToBps[1000000019117649586039544643] = 8274; + rayToBps[1000000019119384779483847985] = 8275; + rayToBps[1000000019121119877981726323] = 8276; + rayToBps[1000000019122854881543569660] = 8277; + rayToBps[1000000019124589790179766288] = 8278; + rayToBps[1000000019126324603900702800] = 8279; + rayToBps[1000000019128059322716764080] = 8280; + rayToBps[1000000019129793946638333310] = 8281; + rayToBps[1000000019131528475675791968] = 8282; + rayToBps[1000000019133262909839519827] = 8283; + rayToBps[1000000019134997249139894958] = 8284; + rayToBps[1000000019136731493587293730] = 8285; + rayToBps[1000000019138465643192090809] = 8286; + rayToBps[1000000019140199697964659157] = 8287; + rayToBps[1000000019141933657915370038] = 8288; + rayToBps[1000000019143667523054593010] = 8289; + rayToBps[1000000019145401293392695935] = 8290; + rayToBps[1000000019147134968940044972] = 8291; + rayToBps[1000000019148868549707004581] = 8292; + rayToBps[1000000019150602035703937519] = 8293; + rayToBps[1000000019152335426941204848] = 8294; + rayToBps[1000000019154068723429165929] = 8295; + rayToBps[1000000019155801925178178423] = 8296; + rayToBps[1000000019157535032198598294] = 8297; + rayToBps[1000000019159268044500779809] = 8298; + rayToBps[1000000019161000962095075535] = 8299; + rayToBps[1000000019162733784991836346] = 8300; + rayToBps[1000000019164466513201411414] = 8301; + rayToBps[1000000019166199146734148217] = 8302; + rayToBps[1000000019167931685600392538] = 8303; + rayToBps[1000000019169664129810488463] = 8304; + rayToBps[1000000019171396479374778382] = 8305; + rayToBps[1000000019173128734303602993] = 8306; + rayToBps[1000000019174860894607301295] = 8307; + rayToBps[1000000019176592960296210597] = 8308; + rayToBps[1000000019178324931380666510] = 8309; + rayToBps[1000000019180056807871002956] = 8310; + rayToBps[1000000019181788589777552160] = 8311; + rayToBps[1000000019183520277110644657] = 8312; + rayToBps[1000000019185251869880609289] = 8313; + rayToBps[1000000019186983368097773204] = 8314; + rayToBps[1000000019188714771772461861] = 8315; + rayToBps[1000000019190446080914999025] = 8316; + rayToBps[1000000019192177295535706774] = 8317; + rayToBps[1000000019193908415644905492] = 8318; + rayToBps[1000000019195639441252913873] = 8319; + rayToBps[1000000019197370372370048924] = 8320; + rayToBps[1000000019199101209006625961] = 8321; + rayToBps[1000000019200831951172958609] = 8322; + rayToBps[1000000019202562598879358809] = 8323; + rayToBps[1000000019204293152136136807] = 8324; + rayToBps[1000000019206023610953601168] = 8325; + rayToBps[1000000019207753975342058765] = 8326; + rayToBps[1000000019209484245311814785] = 8327; + rayToBps[1000000019211214420873172728] = 8328; + rayToBps[1000000019212944502036434409] = 8329; + rayToBps[1000000019214674488811899953] = 8330; + rayToBps[1000000019216404381209867805] = 8331; + rayToBps[1000000019218134179240634720] = 8332; + rayToBps[1000000019219863882914495771] = 8333; + rayToBps[1000000019221593492241744342] = 8334; + rayToBps[1000000019223323007232672138] = 8335; + rayToBps[1000000019225052427897569177] = 8336; + rayToBps[1000000019226781754246723793] = 8337; + rayToBps[1000000019228510986290422641] = 8338; + rayToBps[1000000019230240124038950687] = 8339; + rayToBps[1000000019231969167502591220] = 8340; + rayToBps[1000000019233698116691625845] = 8341; + rayToBps[1000000019235426971616334484] = 8342; + rayToBps[1000000019237155732286995379] = 8343; + rayToBps[1000000019238884398713885090] = 8344; + rayToBps[1000000019240612970907278498] = 8345; + rayToBps[1000000019242341448877448803] = 8346; + rayToBps[1000000019244069832634667526] = 8347; + rayToBps[1000000019245798122189204505] = 8348; + rayToBps[1000000019247526317551327904] = 8349; + rayToBps[1000000019249254418731304205] = 8350; + rayToBps[1000000019250982425739398211] = 8351; + rayToBps[1000000019252710338585873049] = 8352; + rayToBps[1000000019254438157280990169] = 8353; + rayToBps[1000000019256165881835009342] = 8354; + rayToBps[1000000019257893512258188661] = 8355; + rayToBps[1000000019259621048560784543] = 8356; + rayToBps[1000000019261348490753051732] = 8357; + rayToBps[1000000019263075838845243292] = 8358; + rayToBps[1000000019264803092847610615] = 8359; + rayToBps[1000000019266530252770403415] = 8360; + rayToBps[1000000019268257318623869732] = 8361; + rayToBps[1000000019269984290418255933] = 8362; + rayToBps[1000000019271711168163806709] = 8363; + rayToBps[1000000019273437951870765080] = 8364; + rayToBps[1000000019275164641549372390] = 8365; + rayToBps[1000000019276891237209868311] = 8366; + rayToBps[1000000019278617738862490844] = 8367; + rayToBps[1000000019280344146517476314] = 8368; + rayToBps[1000000019282070460185059378] = 8369; + rayToBps[1000000019283796679875473021] = 8370; + rayToBps[1000000019285522805598948554] = 8371; + rayToBps[1000000019287248837365715621] = 8372; + rayToBps[1000000019288974775186002193] = 8373; + rayToBps[1000000019290700619070034572] = 8374; + rayToBps[1000000019292426369028037391] = 8375; + rayToBps[1000000019294152025070233613] = 8376; + rayToBps[1000000019295877587206844530] = 8377; + rayToBps[1000000019297603055448089770] = 8378; + rayToBps[1000000019299328429804187289] = 8379; + rayToBps[1000000019301053710285353377] = 8380; + rayToBps[1000000019302778896901802656] = 8381; + rayToBps[1000000019304503989663748081] = 8382; + rayToBps[1000000019306228988581400940] = 8383; + rayToBps[1000000019307953893664970854] = 8384; + rayToBps[1000000019309678704924665780] = 8385; + rayToBps[1000000019311403422370692008] = 8386; + rayToBps[1000000019313128046013254162] = 8387; + rayToBps[1000000019314852575862555202] = 8388; + rayToBps[1000000019316577011928796425] = 8389; + rayToBps[1000000019318301354222177460] = 8390; + rayToBps[1000000019320025602752896275] = 8391; + rayToBps[1000000019321749757531149174] = 8392; + rayToBps[1000000019323473818567130798] = 8393; + rayToBps[1000000019325197785871034125] = 8394; + rayToBps[1000000019326921659453050469] = 8395; + rayToBps[1000000019328645439323369486] = 8396; + rayToBps[1000000019330369125492179166] = 8397; + rayToBps[1000000019332092717969665839] = 8398; + rayToBps[1000000019333816216766014177] = 8399; + rayToBps[1000000019335539621891407188] = 8400; + rayToBps[1000000019337262933356026219] = 8401; + rayToBps[1000000019338986151170050961] = 8402; + rayToBps[1000000019340709275343659442] = 8403; + rayToBps[1000000019342432305887028033] = 8404; + rayToBps[1000000019344155242810331446] = 8405; + rayToBps[1000000019345878086123742733] = 8406; + rayToBps[1000000019347600835837433289] = 8407; + rayToBps[1000000019349323491961572852] = 8408; + rayToBps[1000000019351046054506329501] = 8409; + rayToBps[1000000019352768523481869660] = 8410; + rayToBps[1000000019354490898898358095] = 8411; + rayToBps[1000000019356213180765957915] = 8412; + rayToBps[1000000019357935369094830575] = 8413; + rayToBps[1000000019359657463895135874] = 8414; + rayToBps[1000000019361379465177031955] = 8415; + rayToBps[1000000019363101372950675305] = 8416; + rayToBps[1000000019364823187226220761] = 8417; + rayToBps[1000000019366544908013821502] = 8418; + rayToBps[1000000019368266535323629053] = 8419; + rayToBps[1000000019369988069165793289] = 8420; + rayToBps[1000000019371709509550462428] = 8421; + rayToBps[1000000019373430856487783037] = 8422; + rayToBps[1000000019375152109987900033] = 8423; + rayToBps[1000000019376873270060956677] = 8424; + rayToBps[1000000019378594336717094581] = 8425; + rayToBps[1000000019380315309966453706] = 8426; + rayToBps[1000000019382036189819172359] = 8427; + rayToBps[1000000019383756976285387201] = 8428; + rayToBps[1000000019385477669375233239] = 8429; + rayToBps[1000000019387198269098843832] = 8430; + rayToBps[1000000019388918775466350690] = 8431; + rayToBps[1000000019390639188487883872] = 8432; + rayToBps[1000000019392359508173571791] = 8433; + rayToBps[1000000019394079734533541209] = 8434; + rayToBps[1000000019395799867577917242] = 8435; + rayToBps[1000000019397519907316823356] = 8436; + rayToBps[1000000019399239853760381372] = 8437; + rayToBps[1000000019400959706918711464] = 8438; + rayToBps[1000000019402679466801932157] = 8439; + rayToBps[1000000019404399133420160333] = 8440; + rayToBps[1000000019406118706783511225] = 8441; + rayToBps[1000000019407838186902098423] = 8442; + rayToBps[1000000019409557573786033870] = 8443; + rayToBps[1000000019411276867445427867] = 8444; + rayToBps[1000000019412996067890389067] = 8445; + rayToBps[1000000019414715175131024480] = 8446; + rayToBps[1000000019416434189177439474] = 8447; + rayToBps[1000000019418153110039737771] = 8448; + rayToBps[1000000019419871937728021454] = 8449; + rayToBps[1000000019421590672252390959] = 8450; + rayToBps[1000000019423309313622945081] = 8451; + rayToBps[1000000019425027861849780974] = 8452; + rayToBps[1000000019426746316942994151] = 8453; + rayToBps[1000000019428464678912678481] = 8454; + rayToBps[1000000019430182947768926195] = 8455; + rayToBps[1000000019431901123521827882] = 8456; + rayToBps[1000000019433619206181472490] = 8457; + rayToBps[1000000019435337195757947331] = 8458; + rayToBps[1000000019437055092261338072] = 8459; + rayToBps[1000000019438772895701728744] = 8460; + rayToBps[1000000019440490606089201741] = 8461; + rayToBps[1000000019442208223433837815] = 8462; + rayToBps[1000000019443925747745716082] = 8463; + rayToBps[1000000019445643179034914020] = 8464; + rayToBps[1000000019447360517311507470] = 8465; + rayToBps[1000000019449077762585570634] = 8466; + rayToBps[1000000019450794914867176081] = 8467; + rayToBps[1000000019452511974166394739] = 8468; + rayToBps[1000000019454228940493295906] = 8469; + rayToBps[1000000019455945813857947238] = 8470; + rayToBps[1000000019457662594270414762] = 8471; + rayToBps[1000000019459379281740762866] = 8472; + rayToBps[1000000019461095876279054304] = 8473; + rayToBps[1000000019462812377895350198] = 8474; + rayToBps[1000000019464528786599710033] = 8475; + rayToBps[1000000019466245102402191663] = 8476; + rayToBps[1000000019467961325312851309] = 8477; + rayToBps[1000000019469677455341743557] = 8478; + rayToBps[1000000019471393492498921365] = 8479; + rayToBps[1000000019473109436794436053] = 8480; + rayToBps[1000000019474825288238337314] = 8481; + rayToBps[1000000019476541046840673208] = 8482; + rayToBps[1000000019478256712611490164] = 8483; + rayToBps[1000000019479972285560832982] = 8484; + rayToBps[1000000019481687765698744828] = 8485; + rayToBps[1000000019483403153035267242] = 8486; + rayToBps[1000000019485118447580440132] = 8487; + rayToBps[1000000019486833649344301778] = 8488; + rayToBps[1000000019488548758336888832] = 8489; + rayToBps[1000000019490263774568236316] = 8490; + rayToBps[1000000019491978698048377623] = 8491; + rayToBps[1000000019493693528787344519] = 8492; + rayToBps[1000000019495408266795167146] = 8493; + rayToBps[1000000019497122912081874013] = 8494; + rayToBps[1000000019498837464657492007] = 8495; + rayToBps[1000000019500551924532046386] = 8496; + rayToBps[1000000019502266291715560784] = 8497; + rayToBps[1000000019503980566218057206] = 8498; + rayToBps[1000000019505694748049556036] = 8499; + rayToBps[1000000019507408837220076029] = 8500; + rayToBps[1000000019509122833739634318] = 8501; + rayToBps[1000000019510836737618246412] = 8502; + rayToBps[1000000019512550548865926194] = 8503; + rayToBps[1000000019514264267492685924] = 8504; + rayToBps[1000000019515977893508536240] = 8505; + rayToBps[1000000019517691426923486156] = 8506; + rayToBps[1000000019519404867747543065] = 8507; + rayToBps[1000000019521118215990712736] = 8508; + rayToBps[1000000019522831471662999316] = 8509; + rayToBps[1000000019524544634774405332] = 8510; + rayToBps[1000000019526257705334931690] = 8511; + rayToBps[1000000019527970683354577675] = 8512; + rayToBps[1000000019529683568843340950] = 8513; + rayToBps[1000000019531396361811217559] = 8514; + rayToBps[1000000019533109062268201927] = 8515; + rayToBps[1000000019534821670224286859] = 8516; + rayToBps[1000000019536534185689463541] = 8517; + rayToBps[1000000019538246608673721540] = 8518; + rayToBps[1000000019539958939187048805] = 8519; + rayToBps[1000000019541671177239431669] = 8520; + rayToBps[1000000019543383322840854842] = 8521; + rayToBps[1000000019545095376001301423] = 8522; + rayToBps[1000000019546807336730752891] = 8523; + rayToBps[1000000019548519205039189107] = 8524; + rayToBps[1000000019550230980936588320] = 8525; + rayToBps[1000000019551942664432927159] = 8526; + rayToBps[1000000019553654255538180638] = 8527; + rayToBps[1000000019555365754262322160] = 8528; + rayToBps[1000000019557077160615323508] = 8529; + rayToBps[1000000019558788474607154854] = 8530; + rayToBps[1000000019560499696247784753] = 8531; + rayToBps[1000000019562210825547180149] = 8532; + rayToBps[1000000019563921862515306371] = 8533; + rayToBps[1000000019565632807162127135] = 8534; + rayToBps[1000000019567343659497604546] = 8535; + rayToBps[1000000019569054419531699092] = 8536; + rayToBps[1000000019570765087274369656] = 8537; + rayToBps[1000000019572475662735573501] = 8538; + rayToBps[1000000019574186145925266288] = 8539; + rayToBps[1000000019575896536853402059] = 8540; + rayToBps[1000000019577606835529933249] = 8541; + rayToBps[1000000019579317041964810682] = 8542; + rayToBps[1000000019581027156167983573] = 8543; + rayToBps[1000000019582737178149399527] = 8544; + rayToBps[1000000019584447107919004537] = 8545; + rayToBps[1000000019586156945486742993] = 8546; + rayToBps[1000000019587866690862557669] = 8547; + rayToBps[1000000019589576344056389737] = 8548; + rayToBps[1000000019591285905078178759] = 8549; + rayToBps[1000000019592995373937862689] = 8550; + rayToBps[1000000019594704750645377873] = 8551; + rayToBps[1000000019596414035210659053] = 8552; + rayToBps[1000000019598123227643639361] = 8553; + rayToBps[1000000019599832327954250327] = 8554; + rayToBps[1000000019601541336152421872] = 8555; + rayToBps[1000000019603250252248082310] = 8556; + rayToBps[1000000019604959076251158355] = 8557; + rayToBps[1000000019606667808171575114] = 8558; + rayToBps[1000000019608376448019256087] = 8559; + rayToBps[1000000019610084995804123174] = 8560; + rayToBps[1000000019611793451536096669] = 8561; + rayToBps[1000000019613501815225095263] = 8562; + rayToBps[1000000019615210086881036044] = 8563; + rayToBps[1000000019616918266513834497] = 8564; + rayToBps[1000000019618626354133404505] = 8565; + rayToBps[1000000019620334349749658350] = 8566; + rayToBps[1000000019622042253372506711] = 8567; + rayToBps[1000000019623750065011858666] = 8568; + rayToBps[1000000019625457784677621692] = 8569; + rayToBps[1000000019627165412379701666] = 8570; + rayToBps[1000000019628872948128002863] = 8571; + rayToBps[1000000019630580391932427962] = 8572; + rayToBps[1000000019632287743802878037] = 8573; + rayToBps[1000000019633995003749252568] = 8574; + rayToBps[1000000019635702171781449432] = 8575; + rayToBps[1000000019637409247909364910] = 8576; + rayToBps[1000000019639116232142893683] = 8577; + rayToBps[1000000019640823124491928838] = 8578; + rayToBps[1000000019642529924966361858] = 8579; + rayToBps[1000000019644236633576082635] = 8580; + rayToBps[1000000019645943250330979460] = 8581; + rayToBps[1000000019647649775240939030] = 8582; + rayToBps[1000000019649356208315846444] = 8583; + rayToBps[1000000019651062549565585208] = 8584; + rayToBps[1000000019652768799000037231] = 8585; + rayToBps[1000000019654474956629082825] = 8586; + rayToBps[1000000019656181022462600710] = 8587; + rayToBps[1000000019657886996510468009] = 8588; + rayToBps[1000000019659592878782560255] = 8589; + rayToBps[1000000019661298669288751384] = 8590; + rayToBps[1000000019663004368038913738] = 8591; + rayToBps[1000000019664709975042918068] = 8592; + rayToBps[1000000019666415490310633533] = 8593; + rayToBps[1000000019668120913851927696] = 8594; + rayToBps[1000000019669826245676666531] = 8595; + rayToBps[1000000019671531485794714421] = 8596; + rayToBps[1000000019673236634215934155] = 8597; + rayToBps[1000000019674941690950186933] = 8598; + rayToBps[1000000019676646656007332363] = 8599; + rayToBps[1000000019678351529397228463] = 8600; + rayToBps[1000000019680056311129731662] = 8601; + rayToBps[1000000019681761001214696799] = 8602; + rayToBps[1000000019683465599661977123] = 8603; + rayToBps[1000000019685170106481424294] = 8604; + rayToBps[1000000019686874521682888385] = 8605; + rayToBps[1000000019688578845276217880] = 8606; + rayToBps[1000000019690283077271259672] = 8607; + rayToBps[1000000019691987217677859074] = 8608; + rayToBps[1000000019693691266505859802] = 8609; + rayToBps[1000000019695395223765103993] = 8610; + rayToBps[1000000019697099089465432194] = 8611; + rayToBps[1000000019698802863616683367] = 8612; + rayToBps[1000000019700506546228694886] = 8613; + rayToBps[1000000019702210137311302542] = 8614; + rayToBps[1000000019703913636874340539] = 8615; + rayToBps[1000000019705617044927641498] = 8616; + rayToBps[1000000019707320361481036453] = 8617; + rayToBps[1000000019709023586544354858] = 8618; + rayToBps[1000000019710726720127424577] = 8619; + rayToBps[1000000019712429762240071896] = 8620; + rayToBps[1000000019714132712892121515] = 8621; + rayToBps[1000000019715835572093396554] = 8622; + rayToBps[1000000019717538339853718546] = 8623; + rayToBps[1000000019719241016182907446] = 8624; + rayToBps[1000000019720943601090781625] = 8625; + rayToBps[1000000019722646094587157873] = 8626; + rayToBps[1000000019724348496681851400] = 8627; + rayToBps[1000000019726050807384675834] = 8628; + rayToBps[1000000019727753026705443223] = 8629; + rayToBps[1000000019729455154653964034] = 8630; + rayToBps[1000000019731157191240047158] = 8631; + rayToBps[1000000019732859136473499900] = 8632; + rayToBps[1000000019734560990364127992] = 8633; + rayToBps[1000000019736262752921735584] = 8634; + rayToBps[1000000019737964424156125249] = 8635; + rayToBps[1000000019739666004077097982] = 8636; + rayToBps[1000000019741367492694453198] = 8637; + rayToBps[1000000019743068890017988738] = 8638; + rayToBps[1000000019744770196057500864] = 8639; + rayToBps[1000000019746471410822784262] = 8640; + rayToBps[1000000019748172534323632041] = 8641; + rayToBps[1000000019749873566569835734] = 8642; + rayToBps[1000000019751574507571185299] = 8643; + rayToBps[1000000019753275357337469119] = 8644; + rayToBps[1000000019754976115878473999] = 8645; + rayToBps[1000000019756676783203985175] = 8646; + rayToBps[1000000019758377359323786302] = 8647; + rayToBps[1000000019760077844247659467] = 8648; + rayToBps[1000000019761778237985385179] = 8649; + rayToBps[1000000019763478540546742376] = 8650; + rayToBps[1000000019765178751941508423] = 8651; + rayToBps[1000000019766878872179459110] = 8652; + rayToBps[1000000019768578901270368657] = 8653; + rayToBps[1000000019770278839224009713] = 8654; + rayToBps[1000000019771978686050153352] = 8655; + rayToBps[1000000019773678441758569079] = 8656; + rayToBps[1000000019775378106359024828] = 8657; + rayToBps[1000000019777077679861286963] = 8658; + rayToBps[1000000019778777162275120275] = 8659; + rayToBps[1000000019780476553610287987] = 8660; + rayToBps[1000000019782175853876551752] = 8661; + rayToBps[1000000019783875063083671655] = 8662; + rayToBps[1000000019785574181241406209] = 8663; + rayToBps[1000000019787273208359512363] = 8664; + rayToBps[1000000019788972144447745493] = 8665; + rayToBps[1000000019790670989515859410] = 8666; + rayToBps[1000000019792369743573606356] = 8667; + rayToBps[1000000019794068406630737008] = 8668; + rayToBps[1000000019795766978697000471] = 8669; + rayToBps[1000000019797465459782144290] = 8670; + rayToBps[1000000019799163849895914439] = 8671; + rayToBps[1000000019800862149048055328] = 8672; + rayToBps[1000000019802560357248309801] = 8673; + rayToBps[1000000019804258474506419137] = 8674; + rayToBps[1000000019805956500832123050] = 8675; + rayToBps[1000000019807654436235159689] = 8676; + rayToBps[1000000019809352280725265639] = 8677; + rayToBps[1000000019811050034312175922] = 8678; + rayToBps[1000000019812747697005623995] = 8679; + rayToBps[1000000019814445268815341752] = 8680; + rayToBps[1000000019816142749751059525] = 8681; + rayToBps[1000000019817840139822506084] = 8682; + rayToBps[1000000019819537439039408634] = 8683; + rayToBps[1000000019821234647411492821] = 8684; + rayToBps[1000000019822931764948482727] = 8685; + rayToBps[1000000019824628791660100876] = 8686; + rayToBps[1000000019826325727556068227] = 8687; + rayToBps[1000000019828022572646104182] = 8688; + rayToBps[1000000019829719326939926581] = 8689; + rayToBps[1000000019831415990447251705] = 8690; + rayToBps[1000000019833112563177794274] = 8691; + rayToBps[1000000019834809045141267450] = 8692; + rayToBps[1000000019836505436347382837] = 8693; + rayToBps[1000000019838201736805850477] = 8694; + rayToBps[1000000019839897946526378859] = 8695; + rayToBps[1000000019841594065518674908] = 8696; + rayToBps[1000000019843290093792443997] = 8697; + rayToBps[1000000019844986031357389939] = 8698; + rayToBps[1000000019846681878223214989] = 8699; + rayToBps[1000000019848377634399619849] = 8700; + rayToBps[1000000019850073299896303661] = 8701; + rayToBps[1000000019851768874722964014] = 8702; + rayToBps[1000000019853464358889296941] = 8703; + rayToBps[1000000019855159752404996917] = 8704; + rayToBps[1000000019856855055279756866] = 8705; + rayToBps[1000000019858550267523268155] = 8706; + rayToBps[1000000019860245389145220596] = 8707; + rayToBps[1000000019861940420155302451] = 8708; + rayToBps[1000000019863635360563200425] = 8709; + rayToBps[1000000019865330210378599670] = 8710; + rayToBps[1000000019867024969611183786] = 8711; + rayToBps[1000000019868719638270634821] = 8712; + rayToBps[1000000019870414216366633269] = 8713; + rayToBps[1000000019872108703908858076] = 8714; + rayToBps[1000000019873803100906986629] = 8715; + rayToBps[1000000019875497407370694772] = 8716; + rayToBps[1000000019877191623309656793] = 8717; + rayToBps[1000000019878885748733545431] = 8718; + rayToBps[1000000019880579783652031874] = 8719; + rayToBps[1000000019882273728074785762] = 8720; + rayToBps[1000000019883967582011475183] = 8721; + rayToBps[1000000019885661345471766678] = 8722; + rayToBps[1000000019887355018465325236] = 8723; + rayToBps[1000000019889048601001814301] = 8724; + rayToBps[1000000019890742093090895767] = 8725; + rayToBps[1000000019892435494742229981] = 8726; + rayToBps[1000000019894128805965475739] = 8727; + rayToBps[1000000019895822026770290295] = 8728; + rayToBps[1000000019897515157166329351] = 8729; + rayToBps[1000000019899208197163247067] = 8730; + rayToBps[1000000019900901146770696053] = 8731; + rayToBps[1000000019902594005998327375] = 8732; + rayToBps[1000000019904286774855790554] = 8733; + rayToBps[1000000019905979453352733562] = 8734; + rayToBps[1000000019907672041498802832] = 8735; + rayToBps[1000000019909364539303643246] = 8736; + rayToBps[1000000019911056946776898148] = 8737; + rayToBps[1000000019912749263928209333] = 8738; + rayToBps[1000000019914441490767217054] = 8739; + rayToBps[1000000019916133627303560021] = 8740; + rayToBps[1000000019917825673546875400] = 8741; + rayToBps[1000000019919517629506798819] = 8742; + rayToBps[1000000019921209495192964356] = 8743; + rayToBps[1000000019922901270615004553] = 8744; + rayToBps[1000000019924592955782550408] = 8745; + rayToBps[1000000019926284550705231377] = 8746; + rayToBps[1000000019927976055392675377] = 8747; + rayToBps[1000000019929667469854508782] = 8748; + rayToBps[1000000019931358794100356430] = 8749; + rayToBps[1000000019933050028139841613] = 8750; + rayToBps[1000000019934741171982586087] = 8751; + rayToBps[1000000019936432225638210068] = 8752; + rayToBps[1000000019938123189116332234] = 8753; + rayToBps[1000000019939814062426569721] = 8754; + rayToBps[1000000019941504845578538131] = 8755; + rayToBps[1000000019943195538581851525] = 8756; + rayToBps[1000000019944886141446122425] = 8757; + rayToBps[1000000019946576654180961822] = 8758; + rayToBps[1000000019948267076795979161] = 8759; + rayToBps[1000000019949957409300782358] = 8760; + rayToBps[1000000019951647651704977788] = 8761; + rayToBps[1000000019953337804018170292] = 8762; + rayToBps[1000000019955027866249963174] = 8763; + rayToBps[1000000019956717838409958205] = 8764; + rayToBps[1000000019958407720507755616] = 8765; + rayToBps[1000000019960097512552954109] = 8766; + rayToBps[1000000019961787214555150849] = 8767; + rayToBps[1000000019963476826523941464] = 8768; + rayToBps[1000000019965166348468920054] = 8769; + rayToBps[1000000019966855780399679180] = 8770; + rayToBps[1000000019968545122325809875] = 8771; + rayToBps[1000000019970234374256901634] = 8772; + rayToBps[1000000019971923536202542425] = 8773; + rayToBps[1000000019973612608172318678] = 8774; + rayToBps[1000000019975301590175815296] = 8775; + rayToBps[1000000019976990482222615648] = 8776; + rayToBps[1000000019978679284322301573] = 8777; + rayToBps[1000000019980367996484453378] = 8778; + rayToBps[1000000019982056618718649841] = 8779; + rayToBps[1000000019983745151034468208] = 8780; + rayToBps[1000000019985433593441484196] = 8781; + rayToBps[1000000019987121945949271992] = 8782; + rayToBps[1000000019988810208567404255] = 8783; + rayToBps[1000000019990498381305452115] = 8784; + rayToBps[1000000019992186464172985172] = 8785; + rayToBps[1000000019993874457179571499] = 8786; + rayToBps[1000000019995562360334777640] = 8787; + rayToBps[1000000019997250173648168612] = 8788; + rayToBps[1000000019998937897129307905] = 8789; + rayToBps[1000000020000625530787757482] = 8790; + rayToBps[1000000020002313074633077780] = 8791; + rayToBps[1000000020004000528674827707] = 8792; + rayToBps[1000000020005687892922564648] = 8793; + rayToBps[1000000020007375167385844462] = 8794; + rayToBps[1000000020009062352074221481] = 8795; + rayToBps[1000000020010749446997248514] = 8796; + rayToBps[1000000020012436452164476843] = 8797; + rayToBps[1000000020014123367585456228] = 8798; + rayToBps[1000000020015810193269734903] = 8799; + rayToBps[1000000020017496929226859581] = 8800; + rayToBps[1000000020019183575466375447] = 8801; + rayToBps[1000000020020870131997826170] = 8802; + rayToBps[1000000020022556598830753888] = 8803; + rayToBps[1000000020024242975974699224] = 8804; + rayToBps[1000000020025929263439201274] = 8805; + rayToBps[1000000020027615461233797613] = 8806; + rayToBps[1000000020029301569368024297] = 8807; + rayToBps[1000000020030987587851415860] = 8808; + rayToBps[1000000020032673516693505313] = 8809; + rayToBps[1000000020034359355903824149] = 8810; + rayToBps[1000000020036045105491902339] = 8811; + rayToBps[1000000020037730765467268337] = 8812; + rayToBps[1000000020039416335839449075] = 8813; + rayToBps[1000000020041101816617969965] = 8814; + rayToBps[1000000020042787207812354904] = 8815; + rayToBps[1000000020044472509432126266] = 8816; + rayToBps[1000000020046157721486804911] = 8817; + rayToBps[1000000020047842843985910178] = 8818; + rayToBps[1000000020049527876938959890] = 8819; + rayToBps[1000000020051212820355470352] = 8820; + rayToBps[1000000020052897674244956352] = 8821; + rayToBps[1000000020054582438616931164] = 8822; + rayToBps[1000000020056267113480906541] = 8823; + rayToBps[1000000020057951698846392724] = 8824; + rayToBps[1000000020059636194722898437] = 8825; + rayToBps[1000000020061320601119930888] = 8826; + rayToBps[1000000020063004918046995771] = 8827; + rayToBps[1000000020064689145513597267] = 8828; + rayToBps[1000000020066373283529238037] = 8829; + rayToBps[1000000020068057332103419236] = 8830; + rayToBps[1000000020069741291245640498] = 8831; + rayToBps[1000000020071425160965399947] = 8832; + rayToBps[1000000020073108941272194197] = 8833; + rayToBps[1000000020074792632175518341] = 8834; + rayToBps[1000000020076476233684865968] = 8835; + rayToBps[1000000020078159745809729151] = 8836; + rayToBps[1000000020079843168559598451] = 8837; + rayToBps[1000000020081526501943962918] = 8838; + rayToBps[1000000020083209745972310093] = 8839; + rayToBps[1000000020084892900654126002] = 8840; + rayToBps[1000000020086575965998895164] = 8841; + rayToBps[1000000020088258942016100588] = 8842; + rayToBps[1000000020089941828715223770] = 8843; + rayToBps[1000000020091624626105744699] = 8844; + rayToBps[1000000020093307334197141855] = 8845; + rayToBps[1000000020094989952998892207] = 8846; + rayToBps[1000000020096672482520471219] = 8847; + rayToBps[1000000020098354922771352842] = 8848; + rayToBps[1000000020100037273761009523] = 8849; + rayToBps[1000000020101719535498912200] = 8850; + rayToBps[1000000020103401707994530304] = 8851; + rayToBps[1000000020105083791257331758] = 8852; + rayToBps[1000000020106765785296782980] = 8853; + rayToBps[1000000020108447690122348881] = 8854; + rayToBps[1000000020110129505743492865] = 8855; + rayToBps[1000000020111811232169676833] = 8856; + rayToBps[1000000020113492869410361176] = 8857; + rayToBps[1000000020115174417475004786] = 8858; + rayToBps[1000000020116855876373065045] = 8859; + rayToBps[1000000020118537246113997834] = 8860; + rayToBps[1000000020120218526707257528] = 8861; + rayToBps[1000000020121899718162296998] = 8862; + rayToBps[1000000020123580820488567614] = 8863; + rayToBps[1000000020125261833695519242] = 8864; + rayToBps[1000000020126942757792600241] = 8865; + rayToBps[1000000020128623592789257476] = 8866; + rayToBps[1000000020130304338694936301] = 8867; + rayToBps[1000000020131984995519080574] = 8868; + rayToBps[1000000020133665563271132648] = 8869; + rayToBps[1000000020135346041960533378] = 8870; + rayToBps[1000000020137026431596722116] = 8871; + rayToBps[1000000020138706732189136713] = 8872; + rayToBps[1000000020140386943747213521] = 8873; + rayToBps[1000000020142067066280387392] = 8874; + rayToBps[1000000020143747099798091677] = 8875; + rayToBps[1000000020145427044309758231] = 8876; + rayToBps[1000000020147106899824817406] = 8877; + rayToBps[1000000020148786666352698057] = 8878; + rayToBps[1000000020150466343902827542] = 8879; + rayToBps[1000000020152145932484631718] = 8880; + rayToBps[1000000020153825432107534947] = 8881; + rayToBps[1000000020155504842780960093] = 8882; + rayToBps[1000000020157184164514328522] = 8883; + rayToBps[1000000020158863397317060104] = 8884; + rayToBps[1000000020160542541198573211] = 8885; + rayToBps[1000000020162221596168284722] = 8886; + rayToBps[1000000020163900562235610018] = 8887; + rayToBps[1000000020165579439409962985] = 8888; + rayToBps[1000000020167258227700756012] = 8889; + rayToBps[1000000020168936927117399997] = 8890; + rayToBps[1000000020170615537669304340] = 8891; + rayToBps[1000000020172294059365876949] = 8892; + rayToBps[1000000020173972492216524237] = 8893; + rayToBps[1000000020175650836230651123] = 8894; + rayToBps[1000000020177329091417661033] = 8895; + rayToBps[1000000020179007257786955901] = 8896; + rayToBps[1000000020180685335347936169] = 8897; + rayToBps[1000000020182363324110000782] = 8898; + rayToBps[1000000020184041224082547200] = 8899; + rayToBps[1000000020185719035274971385] = 8900; + rayToBps[1000000020187396757696667812] = 8901; + rayToBps[1000000020189074391357029461] = 8902; + rayToBps[1000000020190751936265447827] = 8903; + rayToBps[1000000020192429392431312906] = 8904; + rayToBps[1000000020194106759864013214] = 8905; + rayToBps[1000000020195784038572935769] = 8906; + rayToBps[1000000020197461228567466103] = 8907; + rayToBps[1000000020199138329856988259] = 8908; + rayToBps[1000000020200815342450884791] = 8909; + rayToBps[1000000020202492266358536762] = 8910; + rayToBps[1000000020204169101589323750] = 8911; + rayToBps[1000000020205845848152623845] = 8912; + rayToBps[1000000020207522506057813646] = 8913; + rayToBps[1000000020209199075314268269] = 8914; + rayToBps[1000000020210875555931361340] = 8915; + rayToBps[1000000020212551947918465000] = 8916; + rayToBps[1000000020214228251284949901] = 8917; + rayToBps[1000000020215904466040185214] = 8918; + rayToBps[1000000020217580592193538618] = 8919; + rayToBps[1000000020219256629754376312] = 8920; + rayToBps[1000000020220932578732063007] = 8921; + rayToBps[1000000020222608439135961931] = 8922; + rayToBps[1000000020224284210975434825] = 8923; + rayToBps[1000000020225959894259841949] = 8924; + rayToBps[1000000020227635488998542076] = 8925; + rayToBps[1000000020229310995200892497] = 8926; + rayToBps[1000000020230986412876249021] = 8927; + rayToBps[1000000020232661742033965972] = 8928; + rayToBps[1000000020234336982683396194] = 8929; + rayToBps[1000000020236012134833891045] = 8930; + rayToBps[1000000020237687198494800405] = 8931; + rayToBps[1000000020239362173675472669] = 8932; + rayToBps[1000000020241037060385254751] = 8933; + rayToBps[1000000020242711858633492088] = 8934; + rayToBps[1000000020244386568429528633] = 8935; + rayToBps[1000000020246061189782706857] = 8936; + rayToBps[1000000020247735722702367756] = 8937; + rayToBps[1000000020249410167197850841] = 8938; + rayToBps[1000000020251084523278494145] = 8939; + rayToBps[1000000020252758790953634225] = 8940; + rayToBps[1000000020254432970232606156] = 8941; + rayToBps[1000000020256107061124743535] = 8942; + rayToBps[1000000020257781063639378482] = 8943; + rayToBps[1000000020259454977785841636] = 8944; + rayToBps[1000000020261128803573462164] = 8945; + rayToBps[1000000020262802541011567749] = 8946; + rayToBps[1000000020264476190109484603] = 8947; + rayToBps[1000000020266149750876537457] = 8948; + rayToBps[1000000020267823223322049569] = 8949; + rayToBps[1000000020269496607455342719] = 8950; + rayToBps[1000000020271169903285737212] = 8951; + rayToBps[1000000020272843110822551875] = 8952; + rayToBps[1000000020274516230075104065] = 8953; + rayToBps[1000000020276189261052709662] = 8954; + rayToBps[1000000020277862203764683069] = 8955; + rayToBps[1000000020279535058220337216] = 8956; + rayToBps[1000000020281207824428983564] = 8957; + rayToBps[1000000020282880502399932092] = 8958; + rayToBps[1000000020284553092142491314] = 8959; + rayToBps[1000000020286225593665968266] = 8960; + rayToBps[1000000020287898006979668513] = 8961; + rayToBps[1000000020289570332092896147] = 8962; + rayToBps[1000000020291242569014953788] = 8963; + rayToBps[1000000020292914717755142587] = 8964; + rayToBps[1000000020294586778322762220] = 8965; + rayToBps[1000000020296258750727110894] = 8966; + rayToBps[1000000020297930634977485344] = 8967; + rayToBps[1000000020299602431083180836] = 8968; + rayToBps[1000000020301274139053491166] = 8969; + rayToBps[1000000020302945758897708658] = 8970; + rayToBps[1000000020304617290625124169] = 8971; + rayToBps[1000000020306288734245027087] = 8972; + rayToBps[1000000020307960089766705327] = 8973; + rayToBps[1000000020309631357199445340] = 8974; + rayToBps[1000000020311302536552532106] = 8975; + rayToBps[1000000020312973627835249139] = 8976; + rayToBps[1000000020314644631056878485] = 8977; + rayToBps[1000000020316315546226700722] = 8978; + rayToBps[1000000020317986373353994961] = 8979; + rayToBps[1000000020319657112448038846] = 8980; + rayToBps[1000000020321327763518108555] = 8981; + rayToBps[1000000020322998326573478801] = 8982; + rayToBps[1000000020324668801623422830] = 8983; + rayToBps[1000000020326339188677212422] = 8984; + rayToBps[1000000020328009487744117892] = 8985; + rayToBps[1000000020329679698833408092] = 8986; + rayToBps[1000000020331349821954350409] = 8987; + rayToBps[1000000020333019857116210763] = 8988; + rayToBps[1000000020334689804328253614] = 8989; + rayToBps[1000000020336359663599741954] = 8990; + rayToBps[1000000020338029434939937316] = 8991; + rayToBps[1000000020339699118358099767] = 8992; + rayToBps[1000000020341368713863487913] = 8993; + rayToBps[1000000020343038221465358897] = 8994; + rayToBps[1000000020344707641172968400] = 8995; + rayToBps[1000000020346376972995570640] = 8996; + rayToBps[1000000020348046216942418378] = 8997; + rayToBps[1000000020349715373022762906] = 8998; + rayToBps[1000000020351384441245854063] = 8999; + rayToBps[1000000020353053421620940223] = 9000; + rayToBps[1000000020354722314157268302] = 9001; + rayToBps[1000000020356391118864083753] = 9002; + rayToBps[1000000020358059835750630572] = 9003; + rayToBps[1000000020359728464826151296] = 9004; + rayToBps[1000000020361397006099887003] = 9005; + rayToBps[1000000020363065459581077309] = 9006; + rayToBps[1000000020364733825278960375] = 9007; + rayToBps[1000000020366402103202772903] = 9008; + rayToBps[1000000020368070293361750138] = 9009; + rayToBps[1000000020369738395765125865] = 9010; + rayToBps[1000000020371406410422132415] = 9011; + rayToBps[1000000020373074337342000659] = 9012; + rayToBps[1000000020374742176533960015] = 9013; + rayToBps[1000000020376409928007238443] = 9014; + rayToBps[1000000020378077591771062444] = 9015; + rayToBps[1000000020379745167834657070] = 9016; + rayToBps[1000000020381412656207245911] = 9017; + rayToBps[1000000020383080056898051107] = 9018; + rayToBps[1000000020384747369916293340] = 9019; + rayToBps[1000000020386414595271191839] = 9020; + rayToBps[1000000020388081732971964381] = 9021; + rayToBps[1000000020389748783027827283] = 9022; + rayToBps[1000000020391415745447995416] = 9023; + rayToBps[1000000020393082620241682192] = 9024; + rayToBps[1000000020394749407418099573] = 9025; + rayToBps[1000000020396416106986458070] = 9026; + rayToBps[1000000020398082718955966736] = 9027; + rayToBps[1000000020399749243335833178] = 9028; + rayToBps[1000000020401415680135263548] = 9029; + rayToBps[1000000020403082029363462548] = 9030; + rayToBps[1000000020404748291029633429] = 9031; + rayToBps[1000000020406414465142977990] = 9032; + rayToBps[1000000020408080551712696581] = 9033; + rayToBps[1000000020409746550747988100] = 9034; + rayToBps[1000000020411412462258049999] = 9035; + rayToBps[1000000020413078286252078275] = 9036; + rayToBps[1000000020414744022739267481] = 9037; + rayToBps[1000000020416409671728810718] = 9038; + rayToBps[1000000020418075233229899639] = 9039; + rayToBps[1000000020419740707251724448] = 9040; + rayToBps[1000000020421406093803473905] = 9041; + rayToBps[1000000020423071392894335315] = 9042; + rayToBps[1000000020424736604533494543] = 9043; + rayToBps[1000000020426401728730136002] = 9044; + rayToBps[1000000020428066765493442661] = 9045; + rayToBps[1000000020429731714832596040] = 9046; + rayToBps[1000000020431396576756776217] = 9047; + rayToBps[1000000020433061351275161818] = 9048; + rayToBps[1000000020434726038396930030] = 9049; + rayToBps[1000000020436390638131256590] = 9050; + rayToBps[1000000020438055150487315791] = 9051; + rayToBps[1000000020439719575474280483] = 9052; + rayToBps[1000000020441383913101322070] = 9053; + rayToBps[1000000020443048163377610514] = 9054; + rayToBps[1000000020444712326312314329] = 9055; + rayToBps[1000000020446376401914600591] = 9056; + rayToBps[1000000020448040390193634929] = 9057; + rayToBps[1000000020449704291158581532] = 9058; + rayToBps[1000000020451368104818603142] = 9059; + rayToBps[1000000020453031831182861063] = 9060; + rayToBps[1000000020454695470260515157] = 9061; + rayToBps[1000000020456359022060723842] = 9062; + rayToBps[1000000020458022486592644094] = 9063; + rayToBps[1000000020459685863865431454] = 9064; + rayToBps[1000000020461349153888240014] = 9065; + rayToBps[1000000020463012356670222430] = 9066; + rayToBps[1000000020464675472220529919] = 9067; + rayToBps[1000000020466338500548312257] = 9068; + rayToBps[1000000020468001441662717778] = 9069; + rayToBps[1000000020469664295572893381] = 9070; + rayToBps[1000000020471327062287984523] = 9071; + rayToBps[1000000020472989741817135223] = 9072; + rayToBps[1000000020474652334169488064] = 9073; + rayToBps[1000000020476314839354184187] = 9074; + rayToBps[1000000020477977257380363298] = 9075; + rayToBps[1000000020479639588257163666] = 9076; + rayToBps[1000000020481301831993722120] = 9077; + rayToBps[1000000020482963988599174056] = 9078; + rayToBps[1000000020484626058082653431] = 9079; + rayToBps[1000000020486288040453292766] = 9080; + rayToBps[1000000020487949935720223147] = 9081; + rayToBps[1000000020489611743892574223] = 9082; + rayToBps[1000000020491273464979474210] = 9083; + rayToBps[1000000020492935098990049887] = 9084; + rayToBps[1000000020494596645933426599] = 9085; + rayToBps[1000000020496258105818728257] = 9086; + rayToBps[1000000020497919478655077336] = 9087; + rayToBps[1000000020499580764451594880] = 9088; + rayToBps[1000000020501241963217400498] = 9089; + rayToBps[1000000020502903074961612367] = 9090; + rayToBps[1000000020504564099693347229] = 9091; + rayToBps[1000000020506225037421720394] = 9092; + rayToBps[1000000020507885888155845741] = 9093; + rayToBps[1000000020509546651904835716] = 9094; + rayToBps[1000000020511207328677801335] = 9095; + rayToBps[1000000020512867918483852179] = 9096; + rayToBps[1000000020514528421332096402] = 9097; + rayToBps[1000000020516188837231640723] = 9098; + rayToBps[1000000020517849166191590436] = 9099; + rayToBps[1000000020519509408221049399] = 9100; + rayToBps[1000000020521169563329120043] = 9101; + rayToBps[1000000020522829631524903371] = 9102; + rayToBps[1000000020524489612817498954] = 9103; + rayToBps[1000000020526149507216004934] = 9104; + rayToBps[1000000020527809314729518026] = 9105; + rayToBps[1000000020529469035367133516] = 9106; + rayToBps[1000000020531128669137945262] = 9107; + rayToBps[1000000020532788216051045693] = 9108; + rayToBps[1000000020534447676115525812] = 9109; + rayToBps[1000000020536107049340475193] = 9110; + rayToBps[1000000020537766335734981987] = 9111; + rayToBps[1000000020539425535308132912] = 9112; + rayToBps[1000000020541084648069013267] = 9113; + rayToBps[1000000020542743674026706920] = 9114; + rayToBps[1000000020544402613190296315] = 9115; + rayToBps[1000000020546061465568862469] = 9116; + rayToBps[1000000020547720231171484977] = 9117; + rayToBps[1000000020549378910007242007] = 9118; + rayToBps[1000000020551037502085210301] = 9119; + rayToBps[1000000020552696007414465182] = 9120; + rayToBps[1000000020554354426004080544] = 9121; + rayToBps[1000000020556012757863128859] = 9122; + rayToBps[1000000020557671003000681175] = 9123; + rayToBps[1000000020559329161425807120] = 9124; + rayToBps[1000000020560987233147574896] = 9125; + rayToBps[1000000020562645218175051284] = 9126; + rayToBps[1000000020564303116517301641] = 9127; + rayToBps[1000000020565960928183389906] = 9128; + rayToBps[1000000020567618653182378593] = 9129; + rayToBps[1000000020569276291523328795] = 9130; + rayToBps[1000000020570933843215300187] = 9131; + rayToBps[1000000020572591308267351020] = 9132; + rayToBps[1000000020574248686688538126] = 9133; + rayToBps[1000000020575905978487916919] = 9134; + rayToBps[1000000020577563183674541388] = 9135; + rayToBps[1000000020579220302257464108] = 9136; + rayToBps[1000000020580877334245736232] = 9137; + rayToBps[1000000020582534279648407494] = 9138; + rayToBps[1000000020584191138474526212] = 9139; + rayToBps[1000000020585847910733139281] = 9140; + rayToBps[1000000020587504596433292185] = 9141; + rayToBps[1000000020589161195584028982] = 9142; + rayToBps[1000000020590817708194392321] = 9143; + rayToBps[1000000020592474134273423425] = 9144; + rayToBps[1000000020594130473830162110] = 9145; + rayToBps[1000000020595786726873646766] = 9146; + rayToBps[1000000020597442893412914374] = 9147; + rayToBps[1000000020599098973457000497] = 9148; + rayToBps[1000000020600754967014939281] = 9149; + rayToBps[1000000020602410874095763456] = 9150; + rayToBps[1000000020604066694708504340] = 9151; + rayToBps[1000000020605722428862191834] = 9152; + rayToBps[1000000020607378076565854427] = 9153; + rayToBps[1000000020609033637828519190] = 9154; + rayToBps[1000000020610689112659211784] = 9155; + rayToBps[1000000020612344501066956455] = 9156; + rayToBps[1000000020613999803060776034] = 9157; + rayToBps[1000000020615655018649691942] = 9158; + rayToBps[1000000020617310147842724185] = 9159; + rayToBps[1000000020618965190648891360] = 9160; + rayToBps[1000000020620620147077210647] = 9161; + rayToBps[1000000020622275017136697818] = 9162; + rayToBps[1000000020623929800836367232] = 9163; + rayToBps[1000000020625584498185231838] = 9164; + rayToBps[1000000020627239109192303172] = 9165; + rayToBps[1000000020628893633866591362] = 9166; + rayToBps[1000000020630548072217105124] = 9167; + rayToBps[1000000020632202424252851765] = 9168; + rayToBps[1000000020633856689982837180] = 9169; + rayToBps[1000000020635510869416065857] = 9170; + rayToBps[1000000020637164962561540876] = 9171; + rayToBps[1000000020638818969428263904] = 9172; + rayToBps[1000000020640472890025235203] = 9173; + rayToBps[1000000020642126724361453626] = 9174; + rayToBps[1000000020643780472445916617] = 9175; + rayToBps[1000000020645434134287620214] = 9176; + rayToBps[1000000020647087709895559046] = 9177; + rayToBps[1000000020648741199278726334] = 9178; + rayToBps[1000000020650394602446113896] = 9179; + rayToBps[1000000020652047919406712141] = 9180; + rayToBps[1000000020653701150169510072] = 9181; + rayToBps[1000000020655354294743495287] = 9182; + rayToBps[1000000020657007353137653976] = 9183; + rayToBps[1000000020658660325360970928] = 9184; + rayToBps[1000000020660313211422429521] = 9185; + rayToBps[1000000020661966011331011735] = 9186; + rayToBps[1000000020663618725095698141] = 9187; + rayToBps[1000000020665271352725467906] = 9188; + rayToBps[1000000020666923894229298796] = 9189; + rayToBps[1000000020668576349616167171] = 9190; + rayToBps[1000000020670228718895047988] = 9191; + rayToBps[1000000020671881002074914804] = 9192; + rayToBps[1000000020673533199164739768] = 9193; + rayToBps[1000000020675185310173493631] = 9194; + rayToBps[1000000020676837335110145740] = 9195; + rayToBps[1000000020678489273983664040] = 9196; + rayToBps[1000000020680141126803015078] = 9197; + rayToBps[1000000020681792893577163993] = 9198; + rayToBps[1000000020683444574315074529] = 9199; + rayToBps[1000000020685096169025709028] = 9200; + rayToBps[1000000020686747677718028431] = 9201; + rayToBps[1000000020688399100400992278] = 9202; + rayToBps[1000000020690050437083558711] = 9203; + rayToBps[1000000020691701687774684471] = 9204; + rayToBps[1000000020693352852483324902] = 9205; + rayToBps[1000000020695003931218433948] = 9206; + rayToBps[1000000020696654923988964153] = 9207; + rayToBps[1000000020698305830803866663] = 9208; + rayToBps[1000000020699956651672091229] = 9209; + rayToBps[1000000020701607386602586203] = 9210; + rayToBps[1000000020703258035604298536] = 9211; + rayToBps[1000000020704908598686173787] = 9212; + rayToBps[1000000020706559075857156114] = 9213; + rayToBps[1000000020708209467126188282] = 9214; + rayToBps[1000000020709859772502211657] = 9215; + rayToBps[1000000020711509991994166211] = 9216; + rayToBps[1000000020713160125610990519] = 9217; + rayToBps[1000000020714810173361621761] = 9218; + rayToBps[1000000020716460135254995722] = 9219; + rayToBps[1000000020718110011300046791] = 9220; + rayToBps[1000000020719759801505707966] = 9221; + rayToBps[1000000020721409505880910848] = 9222; + rayToBps[1000000020723059124434585643] = 9223; + rayToBps[1000000020724708657175661166] = 9224; + rayToBps[1000000020726358104113064837] = 9225; + rayToBps[1000000020728007465255722684] = 9226; + rayToBps[1000000020729656740612559341] = 9227; + rayToBps[1000000020731305930192498050] = 9228; + rayToBps[1000000020732955034004460663] = 9229; + rayToBps[1000000020734604052057367636] = 9230; + rayToBps[1000000020736252984360138036] = 9231; + rayToBps[1000000020737901830921689539] = 9232; + rayToBps[1000000020739550591750938429] = 9233; + rayToBps[1000000020741199266856799598] = 9234; + rayToBps[1000000020742847856248186551] = 9235; + rayToBps[1000000020744496359934011399] = 9236; + rayToBps[1000000020746144777923184866] = 9237; + rayToBps[1000000020747793110224616286] = 9238; + rayToBps[1000000020749441356847213601] = 9239; + rayToBps[1000000020751089517799883368] = 9240; + rayToBps[1000000020752737593091530752] = 9241; + rayToBps[1000000020754385582731059532] = 9242; + rayToBps[1000000020756033486727372097] = 9243; + rayToBps[1000000020757681305089369449] = 9244; + rayToBps[1000000020759329037825951202] = 9245; + rayToBps[1000000020760976684946015583] = 9246; + rayToBps[1000000020762624246458459433] = 9247; + rayToBps[1000000020764271722372178205] = 9248; + rayToBps[1000000020765919112696065965] = 9249; + rayToBps[1000000020767566417439015395] = 9250; + rayToBps[1000000020769213636609917790] = 9251; + rayToBps[1000000020770860770217663058] = 9252; + rayToBps[1000000020772507818271139726] = 9253; + rayToBps[1000000020774154780779234930] = 9254; + rayToBps[1000000020775801657750834425] = 9255; + rayToBps[1000000020777448449194822584] = 9256; + rayToBps[1000000020779095155120082390] = 9257; + rayToBps[1000000020780741775535495446] = 9258; + rayToBps[1000000020782388310449941971] = 9259; + rayToBps[1000000020784034759872300801] = 9260; + rayToBps[1000000020785681123811449386] = 9261; + rayToBps[1000000020787327402276263798] = 9262; + rayToBps[1000000020788973595275618725] = 9263; + rayToBps[1000000020790619702818387471] = 9264; + rayToBps[1000000020792265724913441958] = 9265; + rayToBps[1000000020793911661569652730] = 9266; + rayToBps[1000000020795557512795888949] = 9267; + rayToBps[1000000020797203278601018391] = 9268; + rayToBps[1000000020798848958993907458] = 9269; + rayToBps[1000000020800494553983421168] = 9270; + rayToBps[1000000020802140063578423159] = 9271; + rayToBps[1000000020803785487787775690] = 9272; + rayToBps[1000000020805430826620339641] = 9273; + rayToBps[1000000020807076080084974512] = 9274; + rayToBps[1000000020808721248190538424] = 9275; + rayToBps[1000000020810366330945888118] = 9276; + rayToBps[1000000020812011328359878961] = 9277; + rayToBps[1000000020813656240441364936] = 9278; + rayToBps[1000000020815301067199198652] = 9279; + rayToBps[1000000020816945808642231341] = 9280; + rayToBps[1000000020818590464779312857] = 9281; + rayToBps[1000000020820235035619291673] = 9282; + rayToBps[1000000020821879521171014892] = 9283; + rayToBps[1000000020823523921443328236] = 9284; + rayToBps[1000000020825168236445076054] = 9285; + rayToBps[1000000020826812466185101315] = 9286; + rayToBps[1000000020828456610672245618] = 9287; + rayToBps[1000000020830100669915349181] = 9288; + rayToBps[1000000020831744643923250852] = 9289; + rayToBps[1000000020833388532704788101] = 9290; + rayToBps[1000000020835032336268797025] = 9291; + rayToBps[1000000020836676054624112349] = 9292; + rayToBps[1000000020838319687779567417] = 9293; + rayToBps[1000000020839963235743994210] = 9294; + rayToBps[1000000020841606698526223327] = 9295; + rayToBps[1000000020843250076135083997] = 9296; + rayToBps[1000000020844893368579404078] = 9297; + rayToBps[1000000020846536575868010053] = 9298; + rayToBps[1000000020848179698009727036] = 9299; + rayToBps[1000000020849822735013378765] = 9300; + rayToBps[1000000020851465686887787610] = 9301; + rayToBps[1000000020853108553641774569] = 9302; + rayToBps[1000000020854751335284159266] = 9303; + rayToBps[1000000020856394031823759960] = 9304; + rayToBps[1000000020858036643269393535] = 9305; + rayToBps[1000000020859679169629875506] = 9306; + rayToBps[1000000020861321610914020019] = 9307; + rayToBps[1000000020862963967130639850] = 9308; + rayToBps[1000000020864606238288546406] = 9309; + rayToBps[1000000020866248424396549724] = 9310; + rayToBps[1000000020867890525463458474] = 9311; + rayToBps[1000000020869532541498079955] = 9312; + rayToBps[1000000020871174472509220102] = 9313; + rayToBps[1000000020872816318505683477] = 9314; + rayToBps[1000000020874458079496273280] = 9315; + rayToBps[1000000020876099755489791338] = 9316; + rayToBps[1000000020877741346495038117] = 9317; + rayToBps[1000000020879382852520812709] = 9318; + rayToBps[1000000020881024273575912848] = 9319; + rayToBps[1000000020882665609669134895] = 9320; + rayToBps[1000000020884306860809273848] = 9321; + rayToBps[1000000020885948027005123340] = 9322; + rayToBps[1000000020887589108265475638] = 9323; + rayToBps[1000000020889230104599121642] = 9324; + rayToBps[1000000020890871016014850891] = 9325; + rayToBps[1000000020892511842521451557] = 9326; + rayToBps[1000000020894152584127710448] = 9327; + rayToBps[1000000020895793240842413010] = 9328; + rayToBps[1000000020897433812674343323] = 9329; + rayToBps[1000000020899074299632284105] = 9330; + rayToBps[1000000020900714701725016711] = 9331; + rayToBps[1000000020902355018961321132] = 9332; + rayToBps[1000000020903995251349975997] = 9333; + rayToBps[1000000020905635398899758575] = 9334; + rayToBps[1000000020907275461619444770] = 9335; + rayToBps[1000000020908915439517809128] = 9336; + rayToBps[1000000020910555332603624828] = 9337; + rayToBps[1000000020912195140885663693] = 9338; + rayToBps[1000000020913834864372696184] = 9339; + rayToBps[1000000020915474503073491401] = 9340; + rayToBps[1000000020917114056996817083] = 9341; + rayToBps[1000000020918753526151439610] = 9342; + rayToBps[1000000020920392910546124003] = 9343; + rayToBps[1000000020922032210189633922] = 9344; + rayToBps[1000000020923671425090731669] = 9345; + rayToBps[1000000020925310555258178187] = 9346; + rayToBps[1000000020926949600700733061] = 9347; + rayToBps[1000000020928588561427154516] = 9348; + rayToBps[1000000020930227437446199421] = 9349; + rayToBps[1000000020931866228766623286] = 9350; + rayToBps[1000000020933504935397180265] = 9351; + rayToBps[1000000020935143557346623152] = 9352; + rayToBps[1000000020936782094623703389] = 9353; + rayToBps[1000000020938420547237171057] = 9354; + rayToBps[1000000020940058915195774882] = 9355; + rayToBps[1000000020941697198508262234] = 9356; + rayToBps[1000000020943335397183379129] = 9357; + rayToBps[1000000020944973511229870225] = 9358; + rayToBps[1000000020946611540656478827] = 9359; + rayToBps[1000000020948249485471946881] = 9360; + rayToBps[1000000020949887345685014985] = 9361; + rayToBps[1000000020951525121304422378] = 9362; + rayToBps[1000000020953162812338906945] = 9363; + rayToBps[1000000020954800418797205219] = 9364; + rayToBps[1000000020956437940688052380] = 9365; + rayToBps[1000000020958075378020182251] = 9366; + rayToBps[1000000020959712730802327307] = 9367; + rayToBps[1000000020961349999043218668] = 9368; + rayToBps[1000000020962987182751586100] = 9369; + rayToBps[1000000020964624281936158019] = 9370; + rayToBps[1000000020966261296605661489] = 9371; + rayToBps[1000000020967898226768822224] = 9372; + rayToBps[1000000020969535072434364582] = 9373; + rayToBps[1000000020971171833611011575] = 9374; + rayToBps[1000000020972808510307484860] = 9375; + rayToBps[1000000020974445102532504749] = 9376; + rayToBps[1000000020976081610294790199] = 9377; + rayToBps[1000000020977718033603058819] = 9378; + rayToBps[1000000020979354372466026869] = 9379; + rayToBps[1000000020980990626892409258] = 9380; + rayToBps[1000000020982626796890919548] = 9381; + rayToBps[1000000020984262882470269951] = 9382; + rayToBps[1000000020985898883639171329] = 9383; + rayToBps[1000000020987534800406333200] = 9384; + rayToBps[1000000020989170632780463731] = 9385; + rayToBps[1000000020990806380770269742] = 9386; + rayToBps[1000000020992442044384456705] = 9387; + rayToBps[1000000020994077623631728747] = 9388; + rayToBps[1000000020995713118520788645] = 9389; + rayToBps[1000000020997348529060337833] = 9390; + rayToBps[1000000020998983855259076396] = 9391; + rayToBps[1000000021000619097125703075] = 9392; + rayToBps[1000000021002254254668915262] = 9393; + rayToBps[1000000021003889327897409010] = 9394; + rayToBps[1000000021005524316819879020] = 9395; + rayToBps[1000000021007159221445018652] = 9396; + rayToBps[1000000021008794041781519920] = 9397; + rayToBps[1000000021010428777838073494] = 9398; + rayToBps[1000000021012063429623368701] = 9399; + rayToBps[1000000021013697997146093523] = 9400; + rayToBps[1000000021015332480414934599] = 9401; + rayToBps[1000000021016966879438577225] = 9402; + rayToBps[1000000021018601194225705352] = 9403; + rayToBps[1000000021020235424785001592] = 9404; + rayToBps[1000000021021869571125147213] = 9405; + rayToBps[1000000021023503633254822139] = 9406; + rayToBps[1000000021025137611182704955] = 9407; + rayToBps[1000000021026771504917472904] = 9408; + rayToBps[1000000021028405314467801886] = 9409; + rayToBps[1000000021030039039842366461] = 9410; + rayToBps[1000000021031672681049839850] = 9411; + rayToBps[1000000021033306238098893931] = 9412; + rayToBps[1000000021034939710998199243] = 9413; + rayToBps[1000000021036573099756424985] = 9414; + rayToBps[1000000021038206404382239016] = 9415; + rayToBps[1000000021039839624884307857] = 9416; + rayToBps[1000000021041472761271296689] = 9417; + rayToBps[1000000021043105813551869354] = 9418; + rayToBps[1000000021044738781734688354] = 9419; + rayToBps[1000000021046371665828414857] = 9420; + rayToBps[1000000021048004465841708690] = 9421; + rayToBps[1000000021049637181783228343] = 9422; + rayToBps[1000000021051269813661630969] = 9423; + rayToBps[1000000021052902361485572381] = 9424; + rayToBps[1000000021054534825263707061] = 9425; + rayToBps[1000000021056167205004688149] = 9426; + rayToBps[1000000021057799500717167451] = 9427; + rayToBps[1000000021059431712409795437] = 9428; + rayToBps[1000000021061063840091221242] = 9429; + rayToBps[1000000021062695883770092662] = 9430; + rayToBps[1000000021064327843455056162] = 9431; + rayToBps[1000000021065959719154756872] = 9432; + rayToBps[1000000021067591510877838582] = 9433; + rayToBps[1000000021069223218632943755] = 9434; + rayToBps[1000000021070854842428713514] = 9435; + rayToBps[1000000021072486382273787653] = 9436; + rayToBps[1000000021074117838176804627] = 9437; + rayToBps[1000000021075749210146401562] = 9438; + rayToBps[1000000021077380498191214251] = 9439; + rayToBps[1000000021079011702319877152] = 9440; + rayToBps[1000000021080642822541023391] = 9441; + rayToBps[1000000021082273858863284763] = 9442; + rayToBps[1000000021083904811295291730] = 9443; + rayToBps[1000000021085535679845673424] = 9444; + rayToBps[1000000021087166464523057642] = 9445; + rayToBps[1000000021088797165336070856] = 9446; + rayToBps[1000000021090427782293338202] = 9447; + rayToBps[1000000021092058315403483486] = 9448; + rayToBps[1000000021093688764675129185] = 9449; + rayToBps[1000000021095319130116896449] = 9450; + rayToBps[1000000021096949411737405092] = 9451; + rayToBps[1000000021098579609545273603] = 9452; + rayToBps[1000000021100209723549119140] = 9453; + rayToBps[1000000021101839753757557533] = 9454; + rayToBps[1000000021103469700179203284] = 9455; + rayToBps[1000000021105099562822669564] = 9456; + rayToBps[1000000021106729341696568219] = 9457; + rayToBps[1000000021108359036809509766] = 9458; + rayToBps[1000000021109988648170103394] = 9459; + rayToBps[1000000021111618175786956964] = 9460; + rayToBps[1000000021113247619668677013] = 9461; + rayToBps[1000000021114876979823868748] = 9462; + rayToBps[1000000021116506256261136053] = 9463; + rayToBps[1000000021118135448989081482] = 9464; + rayToBps[1000000021119764558016306265] = 9465; + rayToBps[1000000021121393583351410308] = 9466; + rayToBps[1000000021123022525002992189] = 9467; + rayToBps[1000000021124651382979649161] = 9468; + rayToBps[1000000021126280157289977155] = 9469; + rayToBps[1000000021127908847942570774] = 9470; + rayToBps[1000000021129537454946023301] = 9471; + rayToBps[1000000021131165978308926689] = 9472; + rayToBps[1000000021132794418039871573] = 9473; + rayToBps[1000000021134422774147447262] = 9474; + rayToBps[1000000021136051046640241741] = 9475; + rayToBps[1000000021137679235526841675] = 9476; + rayToBps[1000000021139307340815832403] = 9477; + rayToBps[1000000021140935362515797945] = 9478; + rayToBps[1000000021142563300635320996] = 9479; + rayToBps[1000000021144191155182982930] = 9480; + rayToBps[1000000021145818926167363800] = 9481; + rayToBps[1000000021147446613597042338] = 9482; + rayToBps[1000000021149074217480595956] = 9483; + rayToBps[1000000021150701737826600742] = 9484; + rayToBps[1000000021152329174643631465] = 9485; + rayToBps[1000000021153956527940261575] = 9486; + rayToBps[1000000021155583797725063203] = 9487; + rayToBps[1000000021157210984006607157] = 9488; + rayToBps[1000000021158838086793462926] = 9489; + rayToBps[1000000021160465106094198684] = 9490; + rayToBps[1000000021162092041917381283] = 9491; + rayToBps[1000000021163718894271576256] = 9492; + rayToBps[1000000021165345663165347819] = 9493; + rayToBps[1000000021166972348607258868] = 9494; + rayToBps[1000000021168598950605870985] = 9495; + rayToBps[1000000021170225469169744432] = 9496; + rayToBps[1000000021171851904307438154] = 9497; + rayToBps[1000000021173478256027509779] = 9498; + rayToBps[1000000021175104524338515618] = 9499; + rayToBps[1000000021176730709249010667] = 9500; + rayToBps[1000000021178356810767548605] = 9501; + rayToBps[1000000021179982828902681797] = 9502; + rayToBps[1000000021181608763662961287] = 9503; + rayToBps[1000000021183234615056936809] = 9504; + rayToBps[1000000021184860383093156782] = 9505; + rayToBps[1000000021186486067780168307] = 9506; + rayToBps[1000000021188111669126517170] = 9507; + rayToBps[1000000021189737187140747849] = 9508; + rayToBps[1000000021191362621831403501] = 9509; + rayToBps[1000000021192987973207025974] = 9510; + rayToBps[1000000021194613241276155799] = 9511; + rayToBps[1000000021196238426047332195] = 9512; + rayToBps[1000000021197863527529093071] = 9513; + rayToBps[1000000021199488545729975021] = 9514; + rayToBps[1000000021201113480658513324] = 9515; + rayToBps[1000000021202738332323241953] = 9516; + rayToBps[1000000021204363100732693562] = 9517; + rayToBps[1000000021205987785895399502] = 9518; + rayToBps[1000000021207612387819889804] = 9519; + rayToBps[1000000021209236906514693195] = 9520; + rayToBps[1000000021210861341988337085] = 9521; + rayToBps[1000000021212485694249347580] = 9522; + rayToBps[1000000021214109963306249471] = 9523; + rayToBps[1000000021215734149167566241] = 9524; + rayToBps[1000000021217358251841820063] = 9525; + rayToBps[1000000021218982271337531802] = 9526; + rayToBps[1000000021220606207663221010] = 9527; + rayToBps[1000000021222230060827405935] = 9528; + rayToBps[1000000021223853830838603512] = 9529; + rayToBps[1000000021225477517705329371] = 9530; + rayToBps[1000000021227101121436097833] = 9531; + rayToBps[1000000021228724642039421911] = 9532; + rayToBps[1000000021230348079523813310] = 9533; + rayToBps[1000000021231971433897782427] = 9534; + rayToBps[1000000021233594705169838355] = 9535; + rayToBps[1000000021235217893348488878] = 9536; + rayToBps[1000000021236840998442240473] = 9537; + rayToBps[1000000021238464020459598314] = 9538; + rayToBps[1000000021240086959409066265] = 9539; + rayToBps[1000000021241709815299146887] = 9540; + rayToBps[1000000021243332588138341436] = 9541; + rayToBps[1000000021244955277935149860] = 9542; + rayToBps[1000000021246577884698070805] = 9543; + rayToBps[1000000021248200408435601610] = 9544; + rayToBps[1000000021249822849156238313] = 9545; + rayToBps[1000000021251445206868475647] = 9546; + rayToBps[1000000021253067481580807036] = 9547; + rayToBps[1000000021254689673301724609] = 9548; + rayToBps[1000000021256311782039719186] = 9549; + rayToBps[1000000021257933807803280285] = 9550; + rayToBps[1000000021259555750600896123] = 9551; + rayToBps[1000000021261177610441053612] = 9552; + rayToBps[1000000021262799387332238365] = 9553; + rayToBps[1000000021264421081282934690] = 9554; + rayToBps[1000000021266042692301625596] = 9555; + rayToBps[1000000021267664220396792789] = 9556; + rayToBps[1000000021269285665576916672] = 9557; + rayToBps[1000000021270907027850476352] = 9558; + rayToBps[1000000021272528307225949633] = 9559; + rayToBps[1000000021274149503711813016] = 9560; + rayToBps[1000000021275770617316541707] = 9561; + rayToBps[1000000021277391648048609609] = 9562; + rayToBps[1000000021279012595916489324] = 9563; + rayToBps[1000000021280633460928652160] = 9564; + rayToBps[1000000021282254243093568122] = 9565; + rayToBps[1000000021283874942419705916] = 9566; + rayToBps[1000000021285495558915532952] = 9567; + rayToBps[1000000021287116092589515341] = 9568; + rayToBps[1000000021288736543450117894] = 9569; + rayToBps[1000000021290356911505804127] = 9570; + rayToBps[1000000021291977196765036258] = 9571; + rayToBps[1000000021293597399236275207] = 9572; + rayToBps[1000000021295217518927980598] = 9573; + rayToBps[1000000021296837555848610757] = 9574; + rayToBps[1000000021298457510006622716] = 9575; + rayToBps[1000000021300077381410472209] = 9576; + rayToBps[1000000021301697170068613676] = 9577; + rayToBps[1000000021303316875989500258] = 9578; + rayToBps[1000000021304936499181583805] = 9579; + rayToBps[1000000021306556039653314870] = 9580; + rayToBps[1000000021308175497413142711] = 9581; + rayToBps[1000000021309794872469515290] = 9582; + rayToBps[1000000021311414164830879280] = 9583; + rayToBps[1000000021313033374505680055] = 9584; + rayToBps[1000000021314652501502361696] = 9585; + rayToBps[1000000021316271545829366993] = 9586; + rayToBps[1000000021317890507495137440] = 9587; + rayToBps[1000000021319509386508113242] = 9588; + rayToBps[1000000021321128182876733306] = 9589; + rayToBps[1000000021322746896609435252] = 9590; + rayToBps[1000000021324365527714655404] = 9591; + rayToBps[1000000021325984076200828797] = 9592; + rayToBps[1000000021327602542076389171] = 9593; + rayToBps[1000000021329220925349768978] = 9594; + rayToBps[1000000021330839226029399378] = 9595; + rayToBps[1000000021332457444123710238] = 9596; + rayToBps[1000000021334075579641130140] = 9597; + rayToBps[1000000021335693632590086368] = 9598; + rayToBps[1000000021337311602979004923] = 9599; + rayToBps[1000000021338929490816310513] = 9600; + rayToBps[1000000021340547296110426556] = 9601; + rayToBps[1000000021342165018869775181] = 9602; + rayToBps[1000000021343782659102777232] = 9603; + rayToBps[1000000021345400216817852259] = 9604; + rayToBps[1000000021347017692023418526] = 9605; + rayToBps[1000000021348635084727893008] = 9606; + rayToBps[1000000021350252394939691393] = 9607; + rayToBps[1000000021351869622667228081] = 9608; + rayToBps[1000000021353486767918916187] = 9609; + rayToBps[1000000021355103830703167533] = 9610; + rayToBps[1000000021356720811028392661] = 9611; + rayToBps[1000000021358337708903000822] = 9612; + rayToBps[1000000021359954524335399980] = 9613; + rayToBps[1000000021361571257333996817] = 9614; + rayToBps[1000000021363187907907196727] = 9615; + rayToBps[1000000021364804476063403818] = 9616; + rayToBps[1000000021366420961811020914] = 9617; + rayToBps[1000000021368037365158449552] = 9618; + rayToBps[1000000021369653686114089987] = 9619; + rayToBps[1000000021371269924686341187] = 9620; + rayToBps[1000000021372886080883600836] = 9621; + rayToBps[1000000021374502154714265338] = 9622; + rayToBps[1000000021376118146186729808] = 9623; + rayToBps[1000000021377734055309388080] = 9624; + rayToBps[1000000021379349882090632705] = 9625; + rayToBps[1000000021380965626538854950] = 9626; + rayToBps[1000000021382581288662444801] = 9627; + rayToBps[1000000021384196868469790961] = 9628; + rayToBps[1000000021385812365969280848] = 9629; + rayToBps[1000000021387427781169300605] = 9630; + rayToBps[1000000021389043114078235086] = 9631; + rayToBps[1000000021390658364704467867] = 9632; + rayToBps[1000000021392273533056381244] = 9633; + rayToBps[1000000021393888619142356230] = 9634; + rayToBps[1000000021395503622970772558] = 9635; + rayToBps[1000000021397118544550008682] = 9636; + rayToBps[1000000021398733383888441774] = 9637; + rayToBps[1000000021400348140994447728] = 9638; + rayToBps[1000000021401962815876401158] = 9639; + rayToBps[1000000021403577408542675398] = 9640; + rayToBps[1000000021405191919001642503] = 9641; + rayToBps[1000000021406806347261673250] = 9642; + rayToBps[1000000021408420693331137139] = 9643; + rayToBps[1000000021410034957218402388] = 9644; + rayToBps[1000000021411649138931835939] = 9645; + rayToBps[1000000021413263238479803458] = 9646; + rayToBps[1000000021414877255870669331] = 9647; + rayToBps[1000000021416491191112796669] = 9648; + rayToBps[1000000021418105044214547303] = 9649; + rayToBps[1000000021419718815184281790] = 9650; + rayToBps[1000000021421332504030359411] = 9651; + rayToBps[1000000021422946110761138169] = 9652; + rayToBps[1000000021424559635384974793] = 9653; + rayToBps[1000000021426173077910224732] = 9654; + rayToBps[1000000021427786438345242167] = 9655; + rayToBps[1000000021429399716698379997] = 9656; + rayToBps[1000000021431012912977989851] = 9657; + rayToBps[1000000021432626027192422079] = 9658; + rayToBps[1000000021434239059350025762] = 9659; + rayToBps[1000000021435852009459148702] = 9660; + rayToBps[1000000021437464877528137431] = 9661; + rayToBps[1000000021439077663565337204] = 9662; + rayToBps[1000000021440690367579092006] = 9663; + rayToBps[1000000021442302989577744547] = 9664; + rayToBps[1000000021443915529569636263] = 9665; + rayToBps[1000000021445527987563107323] = 9666; + rayToBps[1000000021447140363566496615] = 9667; + rayToBps[1000000021448752657588141766] = 9668; + rayToBps[1000000021450364869636379120] = 9669; + rayToBps[1000000021451976999719543756] = 9670; + rayToBps[1000000021453589047845969483] = 9671; + rayToBps[1000000021455201014023988834] = 9672; + rayToBps[1000000021456812898261933077] = 9673; + rayToBps[1000000021458424700568132203] = 9674; + rayToBps[1000000021460036420950914938] = 9675; + rayToBps[1000000021461648059418608738] = 9676; + rayToBps[1000000021463259615979539784] = 9677; + rayToBps[1000000021464871090642032996] = 9678; + rayToBps[1000000021466482483414412017] = 9679; + rayToBps[1000000021468093794304999225] = 9680; + rayToBps[1000000021469705023322115729] = 9681; + rayToBps[1000000021471316170474081370] = 9682; + rayToBps[1000000021472927235769214720] = 9683; + rayToBps[1000000021474538219215833083] = 9684; + rayToBps[1000000021476149120822252496] = 9685; + rayToBps[1000000021477759940596787728] = 9686; + rayToBps[1000000021479370678547752283] = 9687; + rayToBps[1000000021480981334683458396] = 9688; + rayToBps[1000000021482591909012217035] = 9689; + rayToBps[1000000021484202401542337904] = 9690; + rayToBps[1000000021485812812282129439] = 9691; + rayToBps[1000000021487423141239898812] = 9692; + rayToBps[1000000021489033388423951926] = 9693; + rayToBps[1000000021490643553842593424] = 9694; + rayToBps[1000000021492253637504126680] = 9695; + rayToBps[1000000021493863639416853802] = 9696; + rayToBps[1000000021495473559589075640] = 9697; + rayToBps[1000000021497083398029091773] = 9698; + rayToBps[1000000021498693154745200519] = 9699; + rayToBps[1000000021500302829745698932] = 9700; + rayToBps[1000000021501912423038882802] = 9701; + rayToBps[1000000021503521934633046657] = 9702; + rayToBps[1000000021505131364536483760] = 9703; + rayToBps[1000000021506740712757486113] = 9704; + rayToBps[1000000021508349979304344456] = 9705; + rayToBps[1000000021509959164185348265] = 9706; + rayToBps[1000000021511568267408785753] = 9707; + rayToBps[1000000021513177288982943876] = 9708; + rayToBps[1000000021514786228916108326] = 9709; + rayToBps[1000000021516395087216563531] = 9710; + rayToBps[1000000021518003863892592663] = 9711; + rayToBps[1000000021519612558952477629] = 9712; + rayToBps[1000000021521221172404499080] = 9713; + rayToBps[1000000021522829704256936402] = 9714; + rayToBps[1000000021524438154518067725] = 9715; + rayToBps[1000000021526046523196169918] = 9716; + rayToBps[1000000021527654810299518591] = 9717; + rayToBps[1000000021529263015836388092] = 9718; + rayToBps[1000000021530871139815051515] = 9719; + rayToBps[1000000021532479182243780693] = 9720; + rayToBps[1000000021534087143130846199] = 9721; + rayToBps[1000000021535695022484517350] = 9722; + rayToBps[1000000021537302820313062204] = 9723; + rayToBps[1000000021538910536624747565] = 9724; + rayToBps[1000000021540518171427838973] = 9725; + rayToBps[1000000021542125724730600717] = 9726; + rayToBps[1000000021543733196541295825] = 9727; + rayToBps[1000000021545340586868186072] = 9728; + rayToBps[1000000021546947895719531973] = 9729; + rayToBps[1000000021548555123103592792] = 9730; + rayToBps[1000000021550162269028626530] = 9731; + rayToBps[1000000021551769333502889939] = 9732; + rayToBps[1000000021553376316534638512] = 9733; + rayToBps[1000000021554983218132126488] = 9734; + rayToBps[1000000021556590038303606853] = 9735; + rayToBps[1000000021558196777057331335] = 9736; + rayToBps[1000000021559803434401550410] = 9737; + rayToBps[1000000021561410010344513300] = 9738; + rayToBps[1000000021563016504894467972] = 9739; + rayToBps[1000000021564622918059661140] = 9740; + rayToBps[1000000021566229249848338266] = 9741; + rayToBps[1000000021567835500268743557] = 9742; + rayToBps[1000000021569441669329119967] = 9743; + rayToBps[1000000021571047757037709200] = 9744; + rayToBps[1000000021572653763402751707] = 9745; + rayToBps[1000000021574259688432486685] = 9746; + rayToBps[1000000021575865532135152081] = 9747; + rayToBps[1000000021577471294518984591] = 9748; + rayToBps[1000000021579076975592219657] = 9749; + rayToBps[1000000021580682575363091474] = 9750; + rayToBps[1000000021582288093839832982] = 9751; + rayToBps[1000000021583893531030675874] = 9752; + rayToBps[1000000021585498886943850592] = 9753; + rayToBps[1000000021587104161587586327] = 9754; + rayToBps[1000000021588709354970111019] = 9755; + rayToBps[1000000021590314467099651363] = 9756; + rayToBps[1000000021591919497984432801] = 9757; + rayToBps[1000000021593524447632679526] = 9758; + rayToBps[1000000021595129316052614485] = 9759; + rayToBps[1000000021596734103252459374] = 9760; + rayToBps[1000000021598338809240434642] = 9761; + rayToBps[1000000021599943434024759490] = 9762; + rayToBps[1000000021601547977613651871] = 9763; + rayToBps[1000000021603152440015328491] = 9764; + rayToBps[1000000021604756821238004808] = 9765; + rayToBps[1000000021606361121289895034] = 9766; + rayToBps[1000000021607965340179212134] = 9767; + rayToBps[1000000021609569477914167825] = 9768; + rayToBps[1000000021611173534502972580] = 9769; + rayToBps[1000000021612777509953835627] = 9770; + rayToBps[1000000021614381404274964943] = 9771; + rayToBps[1000000021615985217474567267] = 9772; + rayToBps[1000000021617588949560848087] = 9773; + rayToBps[1000000021619192600542011648] = 9774; + rayToBps[1000000021620796170426260951] = 9775; + rayToBps[1000000021622399659221797752] = 9776; + rayToBps[1000000021624003066936822564] = 9777; + rayToBps[1000000021625606393579534651] = 9778; + rayToBps[1000000021627209639158132043] = 9779; + rayToBps[1000000021628812803680811515] = 9780; + rayToBps[1000000021630415887155768610] = 9781; + rayToBps[1000000021632018889591197618] = 9782; + rayToBps[1000000021633621810995291595] = 9783; + rayToBps[1000000021635224651376242349] = 9784; + rayToBps[1000000021636827410742240447] = 9785; + rayToBps[1000000021638430089101475216] = 9786; + rayToBps[1000000021640032686462134738] = 9787; + rayToBps[1000000021641635202832405858] = 9788; + rayToBps[1000000021643237638220474177] = 9789; + rayToBps[1000000021644839992634524055] = 9790; + rayToBps[1000000021646442266082738611] = 9791; + rayToBps[1000000021648044458573299725] = 9792; + rayToBps[1000000021649646570114388037] = 9793; + rayToBps[1000000021651248600714182947] = 9794; + rayToBps[1000000021652850550380862614] = 9795; + rayToBps[1000000021654452419122603958] = 9796; + rayToBps[1000000021656054206947582660] = 9797; + rayToBps[1000000021657655913863973164] = 9798; + rayToBps[1000000021659257539879948673] = 9799; + rayToBps[1000000021660859085003681151] = 9800; + rayToBps[1000000021662460549243341328] = 9801; + rayToBps[1000000021664061932607098690] = 9802; + rayToBps[1000000021665663235103121490] = 9803; + rayToBps[1000000021667264456739576744] = 9804; + rayToBps[1000000021668865597524630226] = 9805; + rayToBps[1000000021670466657466446478] = 9806; + rayToBps[1000000021672067636573188805] = 9807; + rayToBps[1000000021673668534853019271] = 9808; + rayToBps[1000000021675269352314098709] = 9809; + rayToBps[1000000021676870088964586713] = 9810; + rayToBps[1000000021678470744812641643] = 9811; + rayToBps[1000000021680071319866420625] = 9812; + rayToBps[1000000021681671814134079545] = 9813; + rayToBps[1000000021683272227623773058] = 9814; + rayToBps[1000000021684872560343654583] = 9815; + rayToBps[1000000021686472812301876306] = 9816; + rayToBps[1000000021688072983506589178] = 9817; + rayToBps[1000000021689673073965942915] = 9818; + rayToBps[1000000021691273083688086000] = 9819; + rayToBps[1000000021692873012681165684] = 9820; + rayToBps[1000000021694472860953327982] = 9821; + rayToBps[1000000021696072628512717681] = 9822; + rayToBps[1000000021697672315367478329] = 9823; + rayToBps[1000000021699271921525752246] = 9824; + rayToBps[1000000021700871446995680519] = 9825; + rayToBps[1000000021702470891785403001] = 9826; + rayToBps[1000000021704070255903058316] = 9827; + rayToBps[1000000021705669539356783857] = 9828; + rayToBps[1000000021707268742154715782] = 9829; + rayToBps[1000000021708867864304989022] = 9830; + rayToBps[1000000021710466905815737276] = 9831; + rayToBps[1000000021712065866695093012] = 9832; + rayToBps[1000000021713664746951187467] = 9833; + rayToBps[1000000021715263546592150652] = 9834; + rayToBps[1000000021716862265626111344] = 9835; + rayToBps[1000000021718460904061197091] = 9836; + rayToBps[1000000021720059461905534215] = 9837; + rayToBps[1000000021721657939167247807] = 9838; + rayToBps[1000000021723256335854461729] = 9839; + rayToBps[1000000021724854651975298614] = 9840; + rayToBps[1000000021726452887537879870] = 9841; + rayToBps[1000000021728051042550325673] = 9842; + rayToBps[1000000021729649117020754974] = 9843; + rayToBps[1000000021731247110957285495] = 9844; + rayToBps[1000000021732845024368033733] = 9845; + rayToBps[1000000021734442857261114954] = 9846; + rayToBps[1000000021736040609644643201] = 9847; + rayToBps[1000000021737638281526731291] = 9848; + rayToBps[1000000021739235872915490812] = 9849; + rayToBps[1000000021740833383819032127] = 9850; + rayToBps[1000000021742430814245464373] = 9851; + rayToBps[1000000021744028164202895462] = 9852; + rayToBps[1000000021745625433699432083] = 9853; + rayToBps[1000000021747222622743179696] = 9854; + rayToBps[1000000021748819731342242539] = 9855; + rayToBps[1000000021750416759504723623] = 9856; + rayToBps[1000000021752013707238724737] = 9857; + rayToBps[1000000021753610574552346447] = 9858; + rayToBps[1000000021755207361453688091] = 9859; + rayToBps[1000000021756804067950847789] = 9860; + rayToBps[1000000021758400694051922433] = 9861; + rayToBps[1000000021759997239765007694] = 9862; + rayToBps[1000000021761593705098198022] = 9863; + rayToBps[1000000021763190090059586640] = 9864; + rayToBps[1000000021764786394657265553] = 9865; + rayToBps[1000000021766382618899325542] = 9866; + rayToBps[1000000021767978762793856166] = 9867; + rayToBps[1000000021769574826348945765] = 9868; + rayToBps[1000000021771170809572681453] = 9869; + rayToBps[1000000021772766712473149127] = 9870; + rayToBps[1000000021774362535058433462] = 9871; + rayToBps[1000000021775958277336617913] = 9872; + rayToBps[1000000021777553939315784714] = 9873; + rayToBps[1000000021779149521004014877] = 9874; + rayToBps[1000000021780745022409388199] = 9875; + rayToBps[1000000021782340443539983254] = 9876; + rayToBps[1000000021783935784403877396] = 9877; + rayToBps[1000000021785531045009146762] = 9878; + rayToBps[1000000021787126225363866271] = 9879; + rayToBps[1000000021788721325476109620] = 9880; + rayToBps[1000000021790316345353949290] = 9881; + rayToBps[1000000021791911285005456544] = 9882; + rayToBps[1000000021793506144438701426] = 9883; + rayToBps[1000000021795100923661752763] = 9884; + rayToBps[1000000021796695622682678165] = 9885; + rayToBps[1000000021798290241509544024] = 9886; + rayToBps[1000000021799884780150415518] = 9887; + rayToBps[1000000021801479238613356603] = 9888; + rayToBps[1000000021803073616906430024] = 9889; + rayToBps[1000000021804667915037697306] = 9890; + rayToBps[1000000021806262133015218760] = 9891; + rayToBps[1000000021807856270847053482] = 9892; + rayToBps[1000000021809450328541259351] = 9893; + rayToBps[1000000021811044306105893031] = 9894; + rayToBps[1000000021812638203549009974] = 9895; + rayToBps[1000000021814232020878664411] = 9896; + rayToBps[1000000021815825758102909365] = 9897; + rayToBps[1000000021817419415229796642] = 9898; + rayToBps[1000000021819012992267376834] = 9899; + rayToBps[1000000021820606489223699321] = 9900; + rayToBps[1000000021822199906106812267] = 9901; + rayToBps[1000000021823793242924762624] = 9902; + rayToBps[1000000021825386499685596130] = 9903; + rayToBps[1000000021826979676397357315] = 9904; + rayToBps[1000000021828572773068089490] = 9905; + rayToBps[1000000021830165789705834758] = 9906; + rayToBps[1000000021831758726318634008] = 9907; + rayToBps[1000000021833351582914526918] = 9908; + rayToBps[1000000021834944359501551955] = 9909; + rayToBps[1000000021836537056087746374] = 9910; + rayToBps[1000000021838129672681146219] = 9911; + rayToBps[1000000021839722209289786324] = 9912; + rayToBps[1000000021841314665921700311] = 9913; + rayToBps[1000000021842907042584920594] = 9914; + rayToBps[1000000021844499339287478375] = 9915; + rayToBps[1000000021846091556037403647] = 9916; + rayToBps[1000000021847683692842725193] = 9917; + rayToBps[1000000021849275749711470586] = 9918; + rayToBps[1000000021850867726651666193] = 9919; + rayToBps[1000000021852459623671337169] = 9920; + rayToBps[1000000021854051440778507461] = 9921; + rayToBps[1000000021855643177981199810] = 9922; + rayToBps[1000000021857234835287435745] = 9923; + rayToBps[1000000021858826412705235591] = 9924; + rayToBps[1000000021860417910242618463] = 9925; + rayToBps[1000000021862009327907602268] = 9926; + rayToBps[1000000021863600665708203710] = 9927; + rayToBps[1000000021865191923652438280] = 9928; + rayToBps[1000000021866783101748320269] = 9929; + rayToBps[1000000021868374200003862755] = 9930; + rayToBps[1000000021869965218427077615] = 9931; + rayToBps[1000000021871556157025975518] = 9932; + rayToBps[1000000021873147015808565927] = 9933; + rayToBps[1000000021874737794782857101] = 9934; + rayToBps[1000000021876328493956856091] = 9935; + rayToBps[1000000021877919113338568748] = 9936; + rayToBps[1000000021879509652935999713] = 9937; + rayToBps[1000000021881100112757152424] = 9938; + rayToBps[1000000021882690492810029118] = 9939; + rayToBps[1000000021884280793102630824] = 9940; + rayToBps[1000000021885871013642957370] = 9941; + rayToBps[1000000021887461154439007378] = 9942; + rayToBps[1000000021889051215498778269] = 9943; + rayToBps[1000000021890641196830266260] = 9944; + rayToBps[1000000021892231098441466365] = 9945; + rayToBps[1000000021893820920340372396] = 9946; + rayToBps[1000000021895410662534976963] = 9947; + rayToBps[1000000021897000325033271473] = 9948; + rayToBps[1000000021898589907843246131] = 9949; + rayToBps[1000000021900179410972889943] = 9950; + rayToBps[1000000021901768834430190709] = 9951; + rayToBps[1000000021903358178223135034] = 9952; + rayToBps[1000000021904947442359708315] = 9953; + rayToBps[1000000021906536626847894756] = 9954; + rayToBps[1000000021908125731695677355] = 9955; + rayToBps[1000000021909714756911037912] = 9956; + rayToBps[1000000021911303702501957027] = 9957; + rayToBps[1000000021912892568476414100] = 9958; + rayToBps[1000000021914481354842387331] = 9959; + rayToBps[1000000021916070061607853724] = 9960; + rayToBps[1000000021917658688780789081] = 9961; + rayToBps[1000000021919247236369168005] = 9962; + rayToBps[1000000021920835704380963901] = 9963; + rayToBps[1000000021922424092824148978] = 9964; + rayToBps[1000000021924012401706694246] = 9965; + rayToBps[1000000021925600631036569516] = 9966; + rayToBps[1000000021927188780821743402] = 9967; + rayToBps[1000000021928776851070183322] = 9968; + rayToBps[1000000021930364841789855494] = 9969; + rayToBps[1000000021931952752988724944] = 9970; + rayToBps[1000000021933540584674755497] = 9971; + rayToBps[1000000021935128336855909784] = 9972; + rayToBps[1000000021936716009540149239] = 9973; + rayToBps[1000000021938303602735434102] = 9974; + rayToBps[1000000021939891116449723415] = 9975; + rayToBps[1000000021941478550690975027] = 9976; + rayToBps[1000000021943065905467145588] = 9977; + rayToBps[1000000021944653180786190559] = 9978; + rayToBps[1000000021946240376656064202] = 9979; + rayToBps[1000000021947827493084719585] = 9980; + rayToBps[1000000021949414530080108585] = 9981; + rayToBps[1000000021951001487650181881] = 9982; + rayToBps[1000000021952588365802888961] = 9983; + rayToBps[1000000021954175164546178118] = 9984; + rayToBps[1000000021955761883887996454] = 9985; + rayToBps[1000000021957348523836289875] = 9986; + rayToBps[1000000021958935084399003098] = 9987; + rayToBps[1000000021960521565584079645] = 9988; + rayToBps[1000000021962107967399461846] = 9989; + rayToBps[1000000021963694289853090839] = 9990; + rayToBps[1000000021965280532952906572] = 9991; + rayToBps[1000000021966866696706847799] = 9992; + rayToBps[1000000021968452781122852084] = 9993; + rayToBps[1000000021970038786208855800] = 9994; + rayToBps[1000000021971624711972794130] = 9995; + rayToBps[1000000021973210558422601065] = 9996; + rayToBps[1000000021974796325566209405] = 9997; + rayToBps[1000000021976382013411550763] = 9998; + rayToBps[1000000021977967621966555560] = 9999; + rayToBps[1000000021979553151239153027] = 10000; } - /// @notice Fetches the yearly bps rate for a given per second rate - /// @param ray The per second rate to get the rate for - /// @return bps The annual rate value - function rtob(uint256 ray) public pure returns (uint256 bps) { - // Convert per-second rate to per-year rate using rpow - uint256 yearlyRate = _rpow(ray, 365 days); - // Subtract RAY to get the yearly rate delta and convert to basis points - // Add RAY/2 for rounding: ensures values are rounded up when >= 0.5 and down when < 0.5 - return ((yearlyRate - RAY) * BPS + RAY / 2) / RAY; + function btor(uint256 bps) public virtual view returns (uint256 ray) { + require(bps <= MAX_BPS_IN, "DSPC/bps-too-high"); + ray = bpsToRay[bps]; + require(ray != 0, "DSPC/out-of-bounds"); } - /// @notice Exponentiate `x` (RAY, 27 decimal places) to `n` () by squaring - /// @param x The base (RAY, 27 decimal places) - /// @param n The exponent (integer, 0 decimal places) - /// @return z The result - function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { - assembly { - switch x - case 0 { - switch n - case 0 { z := RAY } - default { z := 0 } - } - default { - switch mod(n, 2) - case 0 { z := RAY } - default { z := x } - let half := div(RAY, 2) // for rounding. - for { n := div(n, 2) } n { n := div(n, 2) } { - let xx := mul(x, x) - if iszero(eq(div(xx, x), x)) { revert(0, 0) } - let xxRound := add(xx, half) - if lt(xxRound, xx) { revert(0, 0) } - x := div(xxRound, RAY) - if mod(n, 2) { - let zx := mul(z, x) - if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } - let zxRound := add(zx, half) - if lt(zxRound, zx) { revert(0, 0) } - z := div(zxRound, RAY) - } - } - } - } + function rtob(uint256 ray) public virtual view returns (uint256 bps) { + require(ray >= RAY, "DSPC/ray-too-low"); + bps = rayToBps[ray]; + // Check if it's in range + require(bpsToRay[bps] == ray, "DSPC/out-of-bounds"); } } From 25a3475cf1ae0cafe204a89702f59003686e3810 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 27 Mar 2025 16:36:18 -0300 Subject: [PATCH 81/96] fix: mocks and specs to allow rule passing --- certora/DSPC.spec | 33 +++++++++++++++++++++------------ certora/mocks/SUsds.sol | 10 +++++----- 2 files changed, 26 insertions(+), 17 deletions(-) diff --git a/certora/DSPC.spec b/certora/DSPC.spec index d03b672..d58a8cf 100644 --- a/certora/DSPC.spec +++ b/certora/DSPC.spec @@ -28,7 +28,7 @@ methods { function pot.wards(address) external returns (uint256) envfree; function susds.ssr() external returns (uint256) envfree; - function susds.rho() external returns (uint64) envfree; + function susds.rho() external returns (uint256) envfree; function susds.wards(address) external returns (uint256) envfree; function vat.Line() external returns (uint256) envfree; @@ -440,22 +440,31 @@ rule set_revert(DSPC.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss set_item_reverted[updates[2].id] = check_item_revert(e, updates[2].id, updates[2].bps); } - bool revert8 = exists uint256 i. i < updates.length => set_item_reverted[updates[i].id] == true; + /* bool revert8 = exists uint256 i. i < updates.length => set_item_reverted[updates[i].id] == true; */ - set@withrevert(e, updates); + bool revert8 = updates.length > 0 ? set_item_reverted[updates[0].id] : false; + bool revert9 = updates.length > 1 + ? set_item_reverted[updates[0].id] || set_item_reverted[updates[1].id] + : false; + bool revert10 = updates.length > 2 + ? set_item_reverted[updates[0].id] || set_item_reverted[updates[1].id] || set_item_reverted[updates[2].id] + : false; - assert lastReverted => - revert1 || revert2 || revert3 || - revert4 || revert5 || revert6 || - revert7 || revert8, - "set reverted due to unknown reason"; + set@withrevert(e, updates); - assert + assert lastReverted <=> revert1 || revert2 || revert3 || revert4 || revert5 || revert6 || - revert7 || revert8 => - lastReverted, - "set did not revert when expected"; + revert7 || revert8 || revert9 || + revert10, + "set revert conditions failed"; + + /* assert */ + /* revert1 || revert2 || revert3 || */ + /* revert4 || revert5 || revert6 || */ + /* revert7 || revert8 => */ + /* lastReverted, */ + /* "set did not revert when expected"; */ } function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { diff --git a/certora/mocks/SUsds.sol b/certora/mocks/SUsds.sol index cbcd353..f3f8a45 100644 --- a/certora/mocks/SUsds.sol +++ b/certora/mocks/SUsds.sol @@ -952,8 +952,8 @@ contract SUsds is UUPSUpgradeable { mapping (address => mapping (address => uint256)) public allowance; mapping (address => uint256) public nonces; // Savings yield - uint192 public chi; // The Rate Accumulator [ray] - uint64 public rho; // Time of last drip [unix epoch time] + uint256 public chi; // The Rate Accumulator [ray] + uint256 public rho; // Time of last drip [unix epoch time] uint256 public ssr; // The USDS Savings Rate [ray] // --- Constants --- @@ -1016,8 +1016,8 @@ contract SUsds is UUPSUpgradeable { function initialize() initializer external { __UUPSUpgradeable_init(); - chi = uint192(RAY); - rho = uint64(block.timestamp); + chi = RAY; + rho = block.timestamp; ssr = RAY; vat.hope(address(usdsJoin)); wards[msg.sender] = 1; @@ -1109,7 +1109,7 @@ contract SUsds is UUPSUpgradeable { function drip() public returns (uint256 nChi) { (uint256 chi_, uint256 rho_) = (chi, rho); uint256 diff = 0; - rho = uint64(block.timestamp); + rho = block.timestamp; emit Drip(nChi, diff); } From a808a50008eb777623190089eeaab65fc401ce17 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 27 Mar 2025 17:18:44 -0300 Subject: [PATCH 82/96] refactor: clean up mocks and spec --- certora/DSPC.spec | 16 +--------------- certora/mocks/SUsds.sol | 2 +- 2 files changed, 2 insertions(+), 16 deletions(-) diff --git a/certora/DSPC.spec b/certora/DSPC.spec index d58a8cf..376d519 100644 --- a/certora/DSPC.spec +++ b/certora/DSPC.spec @@ -38,11 +38,6 @@ methods { function vat.ilks(bytes32) external returns (uint256, uint256, uint256, uint256, uint256) envfree; function vat.live() external returns (uint256) envfree; function vat.urns(bytes32, address) external returns (uint256, uint256) envfree; - - function _.ilks(bytes32) external => DISPATCHER(true); - function _.suck(address, address, uint256) external => DISPATCHER(true); - function _.fold(bytes32, address, int256) external => DISPATCHER(true); - function _.exit(address, uint256) external => DISPATCHER(true); } definition EMPTY_BYTES32() returns bytes32 = to_bytes32(0x0000000000000000000000000000000000000000000000000000000000000000); @@ -440,8 +435,6 @@ rule set_revert(DSPC.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss set_item_reverted[updates[2].id] = check_item_revert(e, updates[2].id, updates[2].bps); } - /* bool revert8 = exists uint256 i. i < updates.length => set_item_reverted[updates[i].id] == true; */ - bool revert8 = updates.length > 0 ? set_item_reverted[updates[0].id] : false; bool revert9 = updates.length > 1 ? set_item_reverted[updates[0].id] || set_item_reverted[updates[1].id] @@ -457,14 +450,7 @@ rule set_revert(DSPC.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss revert4 || revert5 || revert6 || revert7 || revert8 || revert9 || revert10, - "set revert conditions failed"; - - /* assert */ - /* revert1 || revert2 || revert3 || */ - /* revert4 || revert5 || revert6 || */ - /* revert7 || revert8 => */ - /* lastReverted, */ - /* "set did not revert when expected"; */ + "set revert rules failed"; } function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { diff --git a/certora/mocks/SUsds.sol b/certora/mocks/SUsds.sol index f3f8a45..e780f3f 100644 --- a/certora/mocks/SUsds.sol +++ b/certora/mocks/SUsds.sol @@ -953,7 +953,7 @@ contract SUsds is UUPSUpgradeable { mapping (address => uint256) public nonces; // Savings yield uint256 public chi; // The Rate Accumulator [ray] - uint256 public rho; // Time of last drip [unix epoch time] + uint256 public rho; // Time of last drip [unix epoch time] uint256 public ssr; // The USDS Savings Rate [ray] // --- Constants --- From 832413acd09500a9b6975878717f2b39de1bac67 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 27 Mar 2025 18:29:15 -0300 Subject: [PATCH 83/96] feat: add remaining rules for edge cases --- certora/DSPC.spec | 74 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/certora/DSPC.spec b/certora/DSPC.spec index 376d519..4ae46f7 100644 --- a/certora/DSPC.spec +++ b/certora/DSPC.spec @@ -506,3 +506,77 @@ function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { revertG || revertH || revertI; } + +rule set_current_higher_than_max(DSPC.ParamChange[] updates) { + env e; + + require updates.length == 1; + bytes32 id = updates[0].id; + uint256 bps = updates[0].bps; + + bytes32 ilk; + require ilk != DSR() && ilk != SSR(); + + uint256 min; uint256 max; uint256 step; + min, max, step = cfgs(id); + require bps >= min && bps <= max; + bps_to_ray[bps] = conv.btor(bps); + bps_to_ray[max] = conv.btor(max); + + uint256 dsrBefore = pot.dsr(); + uint256 ssrBefore = susds.ssr(); + uint256 dutyBefore; mathint _rho; + dutyBefore, _rho = jug.ilks(ilk); + + require id == DSR() => dsrBefore > bps_to_ray[max]; + require id == SSR() => ssrBefore > bps_to_ray[max]; + require id != DSR() && id != SSR() => dutyBefore > bps_to_ray[max]; + + set(e, updates); + + uint256 dsrAfter = pot.dsr(); + uint256 ssrAfter = susds.ssr(); + uint256 dutyAfter; + dutyAfter, _rho = jug.ilks(ilk); + + assert id == DSR() => dsrAfter == bps_to_ray[bps] && bps >= max - step && bps <= max, "dsr not within bounds"; + assert id == SSR() => ssrAfter == bps_to_ray[bps] && bps >= max - step && bps <= max, "ssr not within bounds"; + assert id == ilk => dutyAfter == bps_to_ray[bps] && bps >= max - step && bps <= max, "ilk duty not within bounds"; +} + +rule set_current_lower_than_min(DSPC.ParamChange[] updates) { + env e; + + require updates.length == 1; + bytes32 id = updates[0].id; + uint256 bps = updates[0].bps; + + bytes32 ilk; + require ilk != DSR() && ilk != SSR(); + + uint256 min; uint256 max; uint256 step; + min, max, step = cfgs(id); + require bps >= min && bps <= max; + bps_to_ray[bps] = conv.btor(bps); + bps_to_ray[min] = conv.btor(min); + + uint256 dsrBefore = pot.dsr(); + uint256 ssrBefore = susds.ssr(); + uint256 dutyBefore; mathint _rho; + dutyBefore, _rho = jug.ilks(ilk); + + require id == DSR() => dsrBefore < bps_to_ray[min]; + require id == SSR() => ssrBefore < bps_to_ray[min]; + require id != DSR() && id != SSR() => dutyBefore < bps_to_ray[min]; + + set(e, updates); + + uint256 dsrAfter = pot.dsr(); + uint256 ssrAfter = susds.ssr(); + uint256 dutyAfter; + dutyAfter, _rho = jug.ilks(ilk); + + assert id == DSR() => dsrAfter == bps_to_ray[bps] && bps >= min && bps <= min + step, "dsr not within bounds"; + assert id == SSR() => ssrAfter == bps_to_ray[bps] && bps >= min && bps <= min + step, "ssr not within bounds"; + assert id == ilk => dutyAfter == bps_to_ray[bps] && bps >= min && bps <= min + step, "ilk duty not within bounds"; +} From e78be14e04fa34a924a3229164a0f5bd4c510009 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Fri, 28 Mar 2025 09:09:10 -0300 Subject: [PATCH 84/96] chore: formatting --- src/mocks/ConvMock.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index e64da66..ca19a39 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -20014,13 +20014,13 @@ contract ConvMock { rayToBps[1000000021979553151239153027] = 10000; } - function btor(uint256 bps) public virtual view returns (uint256 ray) { + function btor(uint256 bps) public view virtual returns (uint256 ray) { require(bps <= MAX_BPS_IN, "DSPC/bps-too-high"); ray = bpsToRay[bps]; require(ray != 0, "DSPC/out-of-bounds"); } - function rtob(uint256 ray) public virtual view returns (uint256 bps) { + function rtob(uint256 ray) public view virtual returns (uint256 bps) { require(ray >= RAY, "DSPC/ray-too-low"); bps = rayToBps[ray]; // Check if it's in range From b156c666b02646f938159063f4e994281e894b38 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Fri, 28 Mar 2025 09:13:32 -0300 Subject: [PATCH 85/96] refactor: formatting and cleanup --- certora/harnesses/DSPCHarness.sol | 51 -------- certora/mocks/Conv.sol | 4 +- certora/mocks/Jug.sol | 147 +++++++++++++---------- certora/mocks/Pot.sol | 118 ++++++++++--------- certora/mocks/SUsds.sol | 162 ++++++++++++------------- certora/mocks/Usds.sol | 6 +- certora/mocks/UsdsJoin.sol | 10 +- certora/mocks/Vat.sol | 188 +++++++++++++++++------------- 8 files changed, 344 insertions(+), 342 deletions(-) delete mode 100644 certora/harnesses/DSPCHarness.sol diff --git a/certora/harnesses/DSPCHarness.sol b/certora/harnesses/DSPCHarness.sol deleted file mode 100644 index 3ffd480..0000000 --- a/certora/harnesses/DSPCHarness.sol +++ /dev/null @@ -1,51 +0,0 @@ -pragma solidity ^0.8.24; - -import "src/DSPC.sol"; - -contract DSPCHarness is DSPC { - constructor(address _jug, address _pot, address _susds, address _conv) DSPC(_jug, _pot, _susds, _conv) {} - - function set(bytes32 id, uint256 bps) external toll good { - Cfg memory cfg = cfgs[id]; - - require(cfg.step > 0, "DSPC/rate-not-configured"); - require(bps >= cfg.min, "DSPC/below-min"); - require(bps <= cfg.max, "DSPC/above-max"); - - // Check rate change is within allowed gap - uint256 oldBps; - if (id == "DSR") { - oldBps = conv.rtob(PotLike(pot).dsr()); - } else if (id == "SSR") { - oldBps = conv.rtob(SUSDSLike(susds).ssr()); - } else { - (uint256 duty,) = JugLike(jug).ilks(id); - oldBps = conv.rtob(duty); - } - - if (oldBps < cfg.min) { - oldBps = cfg.min; - } else if (oldBps > cfg.max) { - oldBps = cfg.max; - } - - // Calculates absolute difference between the old and the new rate - uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; - require(delta <= cfg.step, "DSPC/delta-above-step"); - - // Execute the update - uint256 ray = conv.btor(bps); - require(ray >= RAY, "DSPC/invalid-rate-conv"); - if (id == "DSR") { - pot.drip(); - pot.file("dsr", ray); - } else if (id == "SSR") { - susds.drip(); - susds.file("ssr", ray); - } else { - jug.drip(id); - jug.file(id, "duty", ray); - } - emit Set(id, bps); - } -} diff --git a/certora/mocks/Conv.sol b/certora/mocks/Conv.sol index 6b31edc..ba209b4 100644 --- a/certora/mocks/Conv.sol +++ b/certora/mocks/Conv.sol @@ -1,4 +1,3 @@ - pragma solidity ^0.8.24; contract Conv { @@ -17,7 +16,6 @@ contract Conv { require(ray >= RAY, "Conv/ray-too-low"); // Deliberately wrong implementation - return ((ray - RAY) * BPS * 365 days + RAY/2) / RAY; + return ((ray - RAY) * BPS * 365 days + RAY / 2) / RAY; } } - diff --git a/certora/mocks/Jug.sol b/certora/mocks/Jug.sol index cd803c1..146d67d 100644 --- a/certora/mocks/Jug.sol +++ b/certora/mocks/Jug.sol @@ -1,6 +1,6 @@ /** - *Submitted for verification at Etherscan.io on 2019-11-14 -*/ + * Submitted for verification at Etherscan.io on 2019-11-14 + */ // hevm: flattened sources of /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/jug.sol pragma solidity =0.5.12; @@ -23,29 +23,28 @@ pragma solidity =0.5.12; contract LibNote { event LogNote( - bytes4 indexed sig, - address indexed usr, - bytes32 indexed arg1, - bytes32 indexed arg2, - bytes data + bytes4 indexed sig, address indexed usr, bytes32 indexed arg1, bytes32 indexed arg2, bytes data ) anonymous; - modifier note { + modifier note( // end of memory ensures zero + ) { _; assembly { // log an 'anonymous' event with a constant 6 words of calldata // and four indexed topics: selector, caller, arg1 and arg2 - let mark := msize // end of memory ensures zero - mstore(0x40, add(mark, 288)) // update free memory pointer - mstore(mark, 0x20) // bytes type data offset - mstore(add(mark, 0x20), 224) // bytes size (padded) - calldatacopy(add(mark, 0x40), 0, 224) // bytes payload - log4(mark, 288, // calldata - shl(224, shr(224, calldataload(0))), // msg.sig - caller, // msg.sender - calldataload(4), // arg1 - calldataload(36) // arg2 - ) + let mark := msize + mstore(0x40, add(mark, 288)) // update free memory pointer + mstore(mark, 0x20) // bytes type data offset + mstore(add(mark, 0x20), 224) // bytes size (padded) + calldatacopy(add(mark, 0x40), 0, 224) // bytes payload + log4( + mark, + 288, // calldata + shl(224, shr(224, calldataload(0))), // msg.sig + caller, // msg.sender + calldataload(4), // arg1 + calldataload(36) // arg2 + ) } } } @@ -56,19 +55,29 @@ contract LibNote { /* import "./lib.sol"; */ contract VatLike { - function ilks(bytes32) external returns ( - uint256 Art, // wad - uint256 rate // ray - ); - function fold(bytes32,address,int) external; + function ilks(bytes32) + external + returns ( + uint256 Art, // wad + uint256 rate + ); // ray + + function fold(bytes32, address, int256) external; } contract Jug is LibNote { // --- Auth --- - mapping (address => uint) public wards; - function rely(address usr) external note auth { wards[usr] = 1; } - function deny(address usr) external note auth { wards[usr] = 0; } - modifier auth { + mapping(address => uint256) public wards; + + function rely(address usr) external note auth { + wards[usr] = 1; + } + + function deny(address usr) external note auth { + wards[usr] = 0; + } + + modifier auth() { require(wards[msg.sender] == 1, "Jug/not-authorized"); _; } @@ -76,13 +85,13 @@ contract Jug is LibNote { // --- Data --- struct Ilk { uint256 duty; - uint256 rho; + uint256 rho; } - mapping (bytes32 => Ilk) public ilks; - VatLike public vat; - address public vow; - uint256 public base; + mapping(bytes32 => Ilk) public ilks; + VatLike public vat; + address public vow; + uint256 public base; // --- Init --- constructor(address vat_) public { @@ -91,39 +100,50 @@ contract Jug is LibNote { } // --- Math --- - function rpow(uint x, uint n, uint b) internal pure returns (uint z) { - assembly { - switch x case 0 {switch n case 0 {z := b} default {z := 0}} - default { - switch mod(n, 2) case 0 { z := b } default { z := x } - let half := div(b, 2) // for rounding. - for { n := div(n, 2) } n { n := div(n,2) } { - let xx := mul(x, x) - if iszero(eq(div(xx, x), x)) { revert(0,0) } - let xxRound := add(xx, half) - if lt(xxRound, xx) { revert(0,0) } - x := div(xxRound, b) - if mod(n,2) { - let zx := mul(z, x) - if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) } - let zxRound := add(zx, half) - if lt(zxRound, zx) { revert(0,0) } - z := div(zxRound, b) + function rpow(uint256 x, uint256 n, uint256 b) internal pure returns (uint256 z) { + assembly { + switch x + case 0 { + switch n + case 0 { z := b } + default { z := 0 } + } + default { + switch mod(n, 2) + case 0 { z := b } + default { z := x } + let half := div(b, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n, 2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0, 0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0, 0) } + x := div(xxRound, b) + if mod(n, 2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0, 0) } + z := div(zxRound, b) + } + } } - } } - } } + uint256 constant ONE = 10 ** 27; - function add(uint x, uint y) internal pure returns (uint z) { + + function add(uint256 x, uint256 y) internal pure returns (uint256 z) { z = x + y; require(z >= x); } - function diff(uint x, uint y) internal pure returns (int z) { - z = int(x) - int(y); - require(int(x) >= 0 && int(y) >= 0); + + function diff(uint256 x, uint256 y) internal pure returns (int256 z) { + z = int256(x) - int256(y); + require(int256(x) >= 0 && int256(y) >= 0); } - function rmul(uint x, uint y) internal pure returns (uint z) { + + function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) { z = x * y; require(y == 0 || z / y == x); z = z / ONE; @@ -134,24 +154,27 @@ contract Jug is LibNote { Ilk storage i = ilks[ilk]; require(i.duty == 0, "Jug/ilk-already-init"); i.duty = ONE; - i.rho = now; + i.rho = now; } - function file(bytes32 ilk, bytes32 what, uint data) external auth note { + + function file(bytes32 ilk, bytes32 what, uint256 data) external auth note { require(now == ilks[ilk].rho, "Jug/rho-not-updated"); if (what == "duty") ilks[ilk].duty = data; else revert("Jug/file-unrecognized-param"); } - function file(bytes32 what, uint data) external auth note { + + function file(bytes32 what, uint256 data) external auth note { if (what == "base") base = data; else revert("Jug/file-unrecognized-param"); } + function file(bytes32 what, address data) external auth note { if (what == "vow") vow = data; else revert("Jug/file-unrecognized-param"); } // --- Stability Fee Collection --- - function drip(bytes32 ilk) external note returns (uint rate) { + function drip(bytes32 ilk) external note returns (uint256 rate) { require(now >= ilks[ilk].rho, "Jug/invalid-now"); // (, uint prev) = vat.ilks(ilk); // Note: ignoring rpow for Certora diff --git a/certora/mocks/Pot.sol b/certora/mocks/Pot.sol index 2273100..a1218c8 100644 --- a/certora/mocks/Pot.sol +++ b/certora/mocks/Pot.sol @@ -1,6 +1,6 @@ /** - *Submitted for verification at Etherscan.io on 2019-11-14 -*/ + * Submitted for verification at Etherscan.io on 2019-11-14 + */ // hevm: flattened sources of /nix/store/8xb41r4qd0cjb63wcrxf1qmfg88p0961-dss-6fd7de0/src/pot.sol pragma solidity =0.5.12; @@ -23,29 +23,28 @@ pragma solidity =0.5.12; contract LibNote { event LogNote( - bytes4 indexed sig, - address indexed usr, - bytes32 indexed arg1, - bytes32 indexed arg2, - bytes data + bytes4 indexed sig, address indexed usr, bytes32 indexed arg1, bytes32 indexed arg2, bytes data ) anonymous; - modifier note { + modifier note( // end of memory ensures zero + ) { _; assembly { // log an 'anonymous' event with a constant 6 words of calldata // and four indexed topics: selector, caller, arg1 and arg2 - let mark := msize // end of memory ensures zero - mstore(0x40, add(mark, 288)) // update free memory pointer - mstore(mark, 0x20) // bytes type data offset - mstore(add(mark, 0x20), 224) // bytes size (padded) - calldatacopy(add(mark, 0x40), 0, 224) // bytes payload - log4(mark, 288, // calldata - shl(224, shr(224, calldataload(0))), // msg.sig - caller, // msg.sender - calldataload(4), // arg1 - calldataload(36) // arg2 - ) + let mark := msize + mstore(0x40, add(mark, 288)) // update free memory pointer + mstore(mark, 0x20) // bytes type data offset + mstore(add(mark, 0x20), 224) // bytes size (padded) + calldatacopy(add(mark, 0x40), 0, 224) // bytes payload + log4( + mark, + 288, // calldata + shl(224, shr(224, calldataload(0))), // msg.sig + caller, // msg.sender + calldataload(4), // arg1 + calldataload(36) // arg2 + ) } } } @@ -92,32 +91,39 @@ contract LibNote { */ contract VatLike { - function move(address,address,uint256) external; - function suck(address,address,uint256) external; + function move(address, address, uint256) external; + function suck(address, address, uint256) external; } contract Pot is LibNote { // --- Auth --- - mapping (address => uint) public wards; - function rely(address guy) external note auth { wards[guy] = 1; } - function deny(address guy) external note auth { wards[guy] = 0; } - modifier auth { + mapping(address => uint256) public wards; + + function rely(address guy) external note auth { + wards[guy] = 1; + } + + function deny(address guy) external note auth { + wards[guy] = 0; + } + + modifier auth() { require(wards[msg.sender] == 1, "Pot/not-authorized"); _; } // --- Data --- - mapping (address => uint256) public pie; // user Savings Dai + mapping(address => uint256) public pie; // user Savings Dai - uint256 public Pie; // total Savings Dai - uint256 public dsr; // the Dai Savings Rate - uint256 public chi; // the Rate Accumulator + uint256 public Pie; // total Savings Dai + uint256 public dsr; // the Dai Savings Rate + uint256 public chi; // the Rate Accumulator - VatLike public vat; // CDP engine - address public vow; // debt engine - uint256 public rho; // time of last drip + VatLike public vat; // CDP engine + address public vow; // debt engine + uint256 public rho; // time of last drip - uint256 public live; // Access Flag + uint256 public live; // Access Flag // --- Init --- constructor(address vat_) public { @@ -131,23 +137,31 @@ contract Pot is LibNote { // --- Math --- uint256 constant ONE = 10 ** 27; - function rpow(uint x, uint n, uint base) internal pure returns (uint z) { + + function rpow(uint256 x, uint256 n, uint256 base) internal pure returns (uint256 z) { assembly { - switch x case 0 {switch n case 0 {z := base} default {z := 0}} + switch x + case 0 { + switch n + case 0 { z := base } + default { z := 0 } + } default { - switch mod(n, 2) case 0 { z := base } default { z := x } - let half := div(base, 2) // for rounding. - for { n := div(n, 2) } n { n := div(n,2) } { + switch mod(n, 2) + case 0 { z := base } + default { z := x } + let half := div(base, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n, 2) } { let xx := mul(x, x) - if iszero(eq(div(xx, x), x)) { revert(0,0) } + if iszero(eq(div(xx, x), x)) { revert(0, 0) } let xxRound := add(xx, half) - if lt(xxRound, xx) { revert(0,0) } + if lt(xxRound, xx) { revert(0, 0) } x := div(xxRound, base) - if mod(n,2) { + if mod(n, 2) { let zx := mul(z, x) - if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) } + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } let zxRound := add(zx, half) - if lt(zxRound, zx) { revert(0,0) } + if lt(zxRound, zx) { revert(0, 0) } z := div(zxRound, base) } } @@ -155,19 +169,19 @@ contract Pot is LibNote { } } - function rmul(uint x, uint y) internal pure returns (uint z) { + function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) { z = mul(x, y) / ONE; } - function add(uint x, uint y) internal pure returns (uint z) { + function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } - function sub(uint x, uint y) internal pure returns (uint z) { + function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } - function mul(uint x, uint y) internal pure returns (uint z) { + function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(y == 0 || (z = x * y) / y == x); } @@ -189,7 +203,7 @@ contract Pot is LibNote { } // --- Savings Rate Accumulation --- - function drip() external note returns (uint tmp) { + function drip() external note returns (uint256 tmp) { require(now >= rho, "Pot/invalid-now"); // Note: ignoring rpow for Certora // tmp = rmul(rpow(dsr, now - rho, ONE), chi); @@ -200,16 +214,16 @@ contract Pot is LibNote { } // --- Savings Dai Management --- - function join(uint wad) external note { + function join(uint256 wad) external note { require(now == rho, "Pot/rho-not-updated"); pie[msg.sender] = add(pie[msg.sender], wad); - Pie = add(Pie, wad); + Pie = add(Pie, wad); vat.move(msg.sender, address(this), mul(chi, wad)); } - function exit(uint wad) external note { + function exit(uint256 wad) external note { pie[msg.sender] = sub(pie[msg.sender], wad); - Pie = sub(Pie, wad); + Pie = sub(Pie, wad); vat.move(address(this), msg.sender, mul(chi, wad)); } } diff --git a/certora/mocks/SUsds.sol b/certora/mocks/SUsds.sol index e780f3f..a448a0b 100644 --- a/certora/mocks/SUsds.sol +++ b/certora/mocks/SUsds.sol @@ -309,7 +309,7 @@ library Address { revert AddressInsufficientBalance(address(this)); } - (bool success, ) = recipient.call{value: amount}(""); + (bool success,) = recipient.call{value: amount}(""); if (!success) { revert FailedInnerCall(); } @@ -377,11 +377,11 @@ library Address { * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an * unsuccessful call. */ - function verifyCallResultFromTarget( - address target, - bool success, - bytes memory returndata - ) internal view returns (bytes memory) { + function verifyCallResultFromTarget(address target, bool success, bytes memory returndata) + internal + view + returns (bytes memory) + { if (!success) { _revert(returndata); } else { @@ -807,11 +807,9 @@ abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { _; } - function __UUPSUpgradeable_init() internal onlyInitializing { - } + function __UUPSUpgradeable_init() internal onlyInitializing {} - function __UUPSUpgradeable_init_unchained() internal onlyInitializing { - } + function __UUPSUpgradeable_init_unchained() internal onlyInitializing {} /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate the implementation's compatibility when performing an upgrade. @@ -820,6 +818,7 @@ abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ + function proxiableUUID() external view virtual notDelegated returns (bytes32) { return ERC1967Utils.IMPLEMENTATION_SLOT; } @@ -846,8 +845,8 @@ abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { */ function _checkProxy() internal view virtual { if ( - address(this) == __self || // Must be called through delegatecall - ERC1967Utils.getImplementation() != __self // Must be called through an active proxy + address(this) == __self // Must be called through delegatecall + || ERC1967Utils.getImplementation() != __self // Must be called through an active proxy ) { revert UUPSUnauthorizedCallContext(); } @@ -918,10 +917,7 @@ abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { // along with this program. If not, see . interface IERC1271 { - function isValidSignature( - bytes32, - bytes memory - ) external view returns (bytes4); + function isValidSignature(bytes32, bytes memory) external view returns (bytes4); } interface VatLike { @@ -941,40 +937,40 @@ interface UsdsLike { } contract SUsds is UUPSUpgradeable { - // --- Storage Variables --- // Admin - mapping (address => uint256) public wards; + mapping(address => uint256) public wards; // ERC20 - uint256 public totalSupply; - mapping (address => uint256) public balanceOf; - mapping (address => mapping (address => uint256)) public allowance; - mapping (address => uint256) public nonces; + uint256 public totalSupply; + mapping(address => uint256) public balanceOf; + mapping(address => mapping(address => uint256)) public allowance; + mapping(address => uint256) public nonces; // Savings yield - uint256 public chi; // The Rate Accumulator [ray] - uint256 public rho; // Time of last drip [unix epoch time] - uint256 public ssr; // The USDS Savings Rate [ray] + uint256 public chi; // The Rate Accumulator [ray] + uint256 public rho; // Time of last drip [unix epoch time] + uint256 public ssr; // The USDS Savings Rate [ray] // --- Constants --- // ERC20 - string public constant name = "Savings USDS"; - string public constant symbol = "sUSDS"; - string public constant version = "1"; - uint8 public constant decimals = 18; + string public constant name = "Savings USDS"; + string public constant symbol = "sUSDS"; + string public constant version = "1"; + uint8 public constant decimals = 18; // Math uint256 private constant RAY = 10 ** 27; // --- Immutables --- // EIP712 - bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); + bytes32 public constant PERMIT_TYPEHASH = + keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); // Savings yield UsdsJoinLike public immutable usdsJoin; - VatLike public immutable vat; - UsdsLike public immutable usds; - address public immutable vow; + VatLike public immutable vat; + UsdsLike public immutable usds; + address public immutable vow; // --- Events --- @@ -987,7 +983,9 @@ contract SUsds is UUPSUpgradeable { event Transfer(address indexed from, address indexed to, uint256 value); // ERC4626 event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares); - event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares); + event Withdraw( + address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares + ); // Referral event Referral(uint16 indexed referral, address indexed owner, uint256 assets, uint256 shares); // Savings yield @@ -995,7 +993,7 @@ contract SUsds is UUPSUpgradeable { // --- Modifiers --- - modifier auth { + modifier auth() { require(wards[msg.sender] == 1, "SUsds/not-authorized"); _; } @@ -1013,7 +1011,7 @@ contract SUsds is UUPSUpgradeable { // --- Upgradability --- - function initialize() initializer external { + function initialize() external initializer { __UUPSUpgradeable_init(); chi = RAY; @@ -1054,21 +1052,28 @@ contract SUsds is UUPSUpgradeable { function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { assembly { - switch x case 0 {switch n case 0 {z := RAY} default {z := 0}} + switch x + case 0 { + switch n + case 0 { z := RAY } + default { z := 0 } + } default { - switch mod(n, 2) case 0 { z := RAY } default { z := x } - let half := div(RAY, 2) // for rounding. - for { n := div(n, 2) } n { n := div(n,2) } { + switch mod(n, 2) + case 0 { z := RAY } + default { z := x } + let half := div(RAY, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n, 2) } { let xx := mul(x, x) - if iszero(eq(div(xx, x), x)) { revert(0,0) } + if iszero(eq(div(xx, x), x)) { revert(0, 0) } let xxRound := add(xx, half) - if lt(xxRound, xx) { revert(0,0) } + if lt(xxRound, xx) { revert(0, 0) } x := div(xxRound, RAY) - if mod(n,2) { + if mod(n, 2) { let zx := mul(z, x) - if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) } + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } let zxRound := add(zx, half) - if lt(zxRound, zx) { revert(0,0) } + if lt(zxRound, zx) { revert(0, 0) } z := div(zxRound, RAY) } } @@ -1100,7 +1105,9 @@ contract SUsds is UUPSUpgradeable { require(data >= RAY, "SUsds/wrong-ssr-value"); require(rho == block.timestamp, "SUsds/chi-not-up-to-date"); ssr = data; - } else revert("SUsds/file-unrecognized-param"); + } else { + revert("SUsds/file-unrecognized-param"); + } emit File(what, data); } @@ -1197,7 +1204,7 @@ contract SUsds is UUPSUpgradeable { unchecked { balanceOf[owner] = balance - shares; // note: we don't need overflow checks b/c require(balance >= shares) and balance <= totalSupply - totalSupply = totalSupply - shares; + totalSupply = totalSupply - shares; } usds.transfer(receiver, assets); @@ -1292,11 +1299,11 @@ contract SUsds is UUPSUpgradeable { // --- Approve by signature --- - function _isValidSignature( - address signer, - bytes32 digest, - bytes memory signature - ) internal view returns (bool valid) { + function _isValidSignature(address signer, bytes32 digest, bytes memory signature) + internal + view + returns (bool valid) + { if (signature.length == 65) { bytes32 r; bytes32 s; @@ -1312,41 +1319,29 @@ contract SUsds is UUPSUpgradeable { } if (signer.code.length > 0) { - (bool success, bytes memory result) = signer.staticcall( - abi.encodeCall(IERC1271.isValidSignature, (digest, signature)) - ); - valid = (success && - result.length == 32 && - abi.decode(result, (bytes4)) == IERC1271.isValidSignature.selector); + (bool success, bytes memory result) = + signer.staticcall(abi.encodeCall(IERC1271.isValidSignature, (digest, signature))); + valid = + (success && result.length == 32 && abi.decode(result, (bytes4)) == IERC1271.isValidSignature.selector); } } - function permit( - address owner, - address spender, - uint256 value, - uint256 deadline, - bytes memory signature - ) public { + function permit(address owner, address spender, uint256 value, uint256 deadline, bytes memory signature) public { require(block.timestamp <= deadline, "SUsds/permit-expired"); require(owner != address(0), "SUsds/invalid-owner"); uint256 nonce; - unchecked { nonce = nonces[owner]++; } + unchecked { + nonce = nonces[owner]++; + } - bytes32 digest = - keccak256(abi.encodePacked( + bytes32 digest = keccak256( + abi.encodePacked( "\x19\x01", _calculateDomainSeparator(block.chainid), - keccak256(abi.encode( - PERMIT_TYPEHASH, - owner, - spender, - value, - nonce, - deadline - )) - )); + keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonce, deadline)) + ) + ); require(_isValidSignature(owner, digest, signature), "SUsds/invalid-permit"); @@ -1354,16 +1349,9 @@ contract SUsds is UUPSUpgradeable { emit Approval(owner, spender, value); } - function permit( - address owner, - address spender, - uint256 value, - uint256 deadline, - uint8 v, - bytes32 r, - bytes32 s - ) external { + function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) + external + { permit(owner, spender, value, deadline, abi.encodePacked(r, s, v)); } } - diff --git a/certora/mocks/Usds.sol b/certora/mocks/Usds.sol index 48680b7..2a762b3 100644 --- a/certora/mocks/Usds.sol +++ b/certora/mocks/Usds.sol @@ -2,8 +2,8 @@ pragma solidity ^0.8.21; contract Usds { - mapping (address => uint256) public balanceOf; - mapping (address => mapping (address => uint256)) public allowance; + mapping(address => uint256) public balanceOf; + mapping(address => mapping(address => uint256)) public allowance; uint256 public totalSupply; @@ -73,7 +73,7 @@ contract Usds { unchecked { balanceOf[from] = balance - value; - totalSupply = totalSupply - value; + totalSupply = totalSupply - value; } } } diff --git a/certora/mocks/UsdsJoin.sol b/certora/mocks/UsdsJoin.sol index 158ac79..39fa848 100644 --- a/certora/mocks/UsdsJoin.sol +++ b/certora/mocks/UsdsJoin.sol @@ -2,16 +2,16 @@ pragma solidity ^0.8.21; interface UsdsLike { - function burn(address,uint256) external; - function mint(address,uint256) external; + function burn(address, uint256) external; + function mint(address, uint256) external; } interface VatLike { - function move(address,address,uint256) external; + function move(address, address, uint256) external; } contract UsdsJoin { - VatLike public immutable vat; // CDP Engine + VatLike public immutable vat; // CDP Engine UsdsLike public immutable usds; // Stablecoin Token uint256 constant RAY = 10 ** 27; @@ -21,7 +21,7 @@ contract UsdsJoin { event Exit(address indexed caller, address indexed usr, uint256 wad); constructor(address vat_, address usds_) { - vat = VatLike(vat_); + vat = VatLike(vat_); usds = UsdsLike(usds_); } diff --git a/certora/mocks/Vat.sol b/certora/mocks/Vat.sol index e078fd3..858fdf2 100644 --- a/certora/mocks/Vat.sol +++ b/certora/mocks/Vat.sol @@ -21,70 +21,83 @@ pragma solidity >=0.5.12; contract Vat { // --- Auth --- - mapping (address => uint) public wards; - function rely(address usr) external note auth { wards[usr] = 1; } - function deny(address usr) external note auth { wards[usr] = 0; } - modifier auth { + mapping(address => uint256) public wards; + + function rely(address usr) external note auth { + wards[usr] = 1; + } + + function deny(address usr) external note auth { + wards[usr] = 0; + } + + modifier auth() { require(wards[msg.sender] == 1, "Vat/not-authorized"); _; } - mapping(address => mapping (address => uint)) public can; - function hope(address usr) external note { can[msg.sender][usr] = 1; } - function nope(address usr) external note { can[msg.sender][usr] = 0; } + mapping(address => mapping(address => uint256)) public can; + + function hope(address usr) external note { + can[msg.sender][usr] = 1; + } + + function nope(address usr) external note { + can[msg.sender][usr] = 0; + } + function wish(address bit, address usr) internal view returns (bool) { return either(bit == usr, can[bit][usr] == 1); } // --- Data --- struct Ilk { - uint256 Art; // Total Normalised Debt [wad] - uint256 rate; // Accumulated Rates [ray] - uint256 spot; // Price with Safety Margin [ray] - uint256 line; // Debt Ceiling [rad] - uint256 dust; // Urn Debt Floor [rad] + uint256 Art; // Total Normalised Debt [wad] + uint256 rate; // Accumulated Rates [ray] + uint256 spot; // Price with Safety Margin [ray] + uint256 line; // Debt Ceiling [rad] + uint256 dust; // Urn Debt Floor [rad] } + struct Urn { - uint256 ink; // Locked Collateral [wad] - uint256 art; // Normalised Debt [wad] + uint256 ink; // Locked Collateral [wad] + uint256 art; // Normalised Debt [wad] } - mapping (bytes32 => Ilk) public ilks; - mapping (bytes32 => mapping (address => Urn )) public urns; - mapping (bytes32 => mapping (address => uint)) public gem; // [wad] - mapping (address => uint256) public dai; // [rad] - mapping (address => uint256) public sin; // [rad] + mapping(bytes32 => Ilk) public ilks; + mapping(bytes32 => mapping(address => Urn)) public urns; + mapping(bytes32 => mapping(address => uint256)) public gem; // [wad] + mapping(address => uint256) public dai; // [rad] + mapping(address => uint256) public sin; // [rad] - uint256 public debt; // Total Dai Issued [rad] - uint256 public vice; // Total Unbacked Dai [rad] - uint256 public Line; // Total Debt Ceiling [rad] - uint256 public live; // Active Flag + uint256 public debt; // Total Dai Issued [rad] + uint256 public vice; // Total Unbacked Dai [rad] + uint256 public Line; // Total Debt Ceiling [rad] + uint256 public live; // Active Flag // --- Logs --- event LogNote( - bytes4 indexed sig, - bytes32 indexed arg1, - bytes32 indexed arg2, - bytes32 indexed arg3, - bytes data + bytes4 indexed sig, bytes32 indexed arg1, bytes32 indexed arg2, bytes32 indexed arg3, bytes data ) anonymous; - modifier note { + modifier note() { _; assembly { // log an 'anonymous' event with a constant 6 words of calldata // and four indexed topics: the selector and the first three args - let mark := msize() // end of memory ensures zero - mstore(0x40, add(mark, 288)) // update free memory pointer - mstore(mark, 0x20) // bytes type data offset - mstore(add(mark, 0x20), 224) // bytes size (padded) - calldatacopy(add(mark, 0x40), 0, 224) // bytes payload - log4(mark, 288, // calldata - shl(224, shr(224, calldataload(0))), // msg.sig - calldataload(4), // arg1 - calldataload(36), // arg2 - calldataload(68) // arg3 - ) + let mark := msize() // end of memory ensures zero + mstore(0x40, add(mark, 288)) // update free memory pointer + mstore(mark, 0x20) // bytes type data offset + mstore(add(mark, 0x20), 224) // bytes size (padded) + calldatacopy(add(mark, 0x40), 0, 224) // bytes payload + log4( + mark, + 288, // calldata + shl(224, shr(224, calldataload(0))), // msg.sig + calldataload(4), // arg1 + calldataload(36), // arg2 + calldataload(68) // arg3 + ) } } @@ -95,28 +108,33 @@ contract Vat { } // --- Math --- - function add(uint x, int y) internal pure returns (uint z) { - z = x + uint(y); + function add(uint256 x, int256 y) internal pure returns (uint256 z) { + z = x + uint256(y); require(y >= 0 || z <= x); require(y <= 0 || z >= x); } - function sub(uint x, int y) internal pure returns (uint z) { - z = x - uint(y); + + function sub(uint256 x, int256 y) internal pure returns (uint256 z) { + z = x - uint256(y); require(y <= 0 || z <= x); require(y >= 0 || z >= x); } - function mul(uint x, int y) internal pure returns (int z) { - z = int(x) * y; - require(int(x) >= 0); - require(y == 0 || z / y == int(x)); + + function mul(uint256 x, int256 y) internal pure returns (int256 z) { + z = int256(x) * y; + require(int256(x) >= 0); + require(y == 0 || z / y == int256(x)); } - function add(uint x, uint y) internal pure returns (uint z) { + + function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } - function sub(uint x, uint y) internal pure returns (uint z) { + + function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } - function mul(uint x, uint y) internal pure returns (uint z) { + + function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(y == 0 || (z = x * y) / y == x); } @@ -125,16 +143,19 @@ contract Vat { require(ilks[ilk].rate == 0, "Vat/ilk-already-init"); ilks[ilk].rate = 10 ** 27; } - function file(bytes32 what, uint data) external note { + + function file(bytes32 what, uint256 data) external note { if (what == "Line") Line = data; else revert("Vat/file-unrecognized-param"); } - function file(bytes32 ilk, bytes32 what, uint data) external note { + + function file(bytes32 ilk, bytes32 what, uint256 data) external note { if (what == "spot") ilks[ilk].spot = data; else if (what == "line") ilks[ilk].line = data; else if (what == "dust") ilks[ilk].dust = data; else revert("Vat/file-unrecognized-param"); } + function cage() external note { live = 0; } @@ -143,11 +164,13 @@ contract Vat { function slip(bytes32 ilk, address usr, int256 wad) external note { gem[ilk][usr] = add(gem[ilk][usr], wad); } + function flux(bytes32 ilk, address src, address dst, uint256 wad) external note { require(wish(src, msg.sender), "Vat/not-allowed"); gem[ilk][src] = sub(gem[ilk][src], wad); gem[ilk][dst] = add(gem[ilk][dst], wad); } + function move(address src, address dst, uint256 rad) external note { require(wish(src, msg.sender), "Vat/not-allowed"); dai[src] = sub(dai[src], rad); @@ -155,14 +178,19 @@ contract Vat { } function either(bool x, bool y) internal pure returns (bool z) { - assembly{ z := or(x, y)} + assembly { + z := or(x, y) + } } + function both(bool x, bool y) internal pure returns (bool z) { - assembly{ z := and(x, y)} + assembly { + z := and(x, y) + } } // --- CDP Manipulation --- - function frob(bytes32 i, address u, address v, address w, int dink, int dart) external note { + function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note { Urn memory urn = urns[i][u]; Ilk memory ilk = ilks[i]; // ilk has been initialised @@ -172,9 +200,9 @@ contract Vat { urn.art = add(urn.art, dart); ilk.Art = add(ilk.Art, dart); - int dtab = mul(ilk.rate, dart); - uint tab = mul(ilk.rate, urn.art); - debt = add(debt, dtab); + int256 dtab = mul(ilk.rate, dart); + uint256 tab = mul(ilk.rate, urn.art); + debt = add(debt, dtab); // either debt has decreased, or debt ceilings are not exceeded require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded"); @@ -192,13 +220,14 @@ contract Vat { require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust"); gem[i][v] = sub(gem[i][v], dink); - dai[w] = add(dai[w], dtab); + dai[w] = add(dai[w], dtab); urns[i][u] = urn; - ilks[i] = ilk; + ilks[i] = ilk; } // --- CDP Fungibility --- - function fork(bytes32 ilk, address src, address dst, int dink, int dart) external note { + + function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note { Urn storage u = urns[ilk][src]; Urn storage v = urns[ilk][dst]; Ilk storage i = ilks[ilk]; @@ -208,8 +237,8 @@ contract Vat { v.ink = add(v.ink, dink); v.art = add(v.art, dart); - uint utab = mul(u.art, i.rate); - uint vtab = mul(v.art, i.rate); + uint256 utab = mul(u.art, i.rate); + uint256 vtab = mul(v.art, i.rate); // both sides consent require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed"); @@ -223,7 +252,8 @@ contract Vat { require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst"); } // --- CDP Confiscation --- - function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note { + + function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note { Urn storage urn = urns[i][u]; Ilk storage ilk = ilks[i]; @@ -231,35 +261,35 @@ contract Vat { urn.art = add(urn.art, dart); ilk.Art = add(ilk.Art, dart); - int dtab = mul(ilk.rate, dart); + int256 dtab = mul(ilk.rate, dart); gem[i][v] = sub(gem[i][v], dink); - sin[w] = sub(sin[w], dtab); - vice = sub(vice, dtab); + sin[w] = sub(sin[w], dtab); + vice = sub(vice, dtab); } // --- Settlement --- - function heal(uint rad) external note { + function heal(uint256 rad) external note { address u = msg.sender; sin[u] = sub(sin[u], rad); dai[u] = sub(dai[u], rad); - vice = sub(vice, rad); - debt = sub(debt, rad); + vice = sub(vice, rad); + debt = sub(debt, rad); } - function suck(address u, address v, uint rad) external note { + + function suck(address u, address v, uint256 rad) external note { sin[u] = add(sin[u], rad); dai[v] = add(dai[v], rad); - vice = add(vice, rad); - debt = add(debt, rad); + vice = add(vice, rad); + debt = add(debt, rad); } // --- Rates --- - function fold(bytes32 i, address u, int rate) external note { + function fold(bytes32 i, address u, int256 rate) external note { Ilk storage ilk = ilks[i]; ilk.rate = add(ilk.rate, rate); - int rad = mul(ilk.Art, rate); - dai[u] = add(dai[u], rad); - debt = add(debt, rad); + int256 rad = mul(ilk.Art, rate); + dai[u] = add(dai[u], rad); + debt = add(debt, rad); } } - From 57f95dc7754727c2466137ee83576acebfe5937c Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Fri, 28 Mar 2025 09:23:51 -0300 Subject: [PATCH 86/96] feat: add Certora CI action --- .github/workflows/certora.yml | 46 +++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 .github/workflows/certora.yml diff --git a/.github/workflows/certora.yml b/.github/workflows/certora.yml new file mode 100644 index 0000000..65504d9 --- /dev/null +++ b/.github/workflows/certora.yml @@ -0,0 +1,46 @@ +name: Certora + +on: [push, pull_request] + +jobs: + certora: + name: Certora + runs-on: ubuntu-latest + strategy: + fail-fast: false + + steps: + - name: Checkout + uses: actions/checkout@v3 + + - uses: actions/setup-java@v3 + with: + distribution: 'zulu' + java-version: '11' + java-package: jre + + - name: Set up Python 3.13 + uses: actions/setup-python@v4 + with: + python-version: 3.13 + + - name: Install solc-select + run: pip3 install solc-select + + - name: Solc Select 0.8.24 + run: solc-select install 0.8.24 + + - name: Solc Select 0.8.21 + run: solc-select install 0.8.21 + + - name: Solc Select 0.5.12 + run: solc-select install 0.5.12 + + - name: Install Certora + run: pip3 install certora-cli-beta + + - name: Certora verify DSPC + run: make certora-dspc + env: + CERTORAKEY: ${{ secrets.CERTORAKEY }} + From 4e7a435682bf0a4fb9f19070f5ff34ffbdee6d9d Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 28 Mar 2025 09:50:31 -0300 Subject: [PATCH 87/96] Rename module (DSPC -> SPBEAM) (#9) * refactor: rename module (DSPC -> SPBEAM) * chore: formatting --- README.md | 32 +-- .../{DSPCDeploy.s.sol => SPBEAMDeploy.s.sol} | 16 +- script/input/1/README.md | 14 +- ...eploy.json => template-spbeam-deploy.json} | 0 src/{DSPC.sol => SPBEAM.sol} | 66 ++--- src/{DSPC.t.sol => SPBEAM.t.sol} | 260 +++++++++--------- src/{DSPCMom.sol => SPBEAMMom.sol} | 26 +- src/{DSPCMom.t.sol => SPBEAMMom.t.sol} | 48 ++-- .../{DSPCDeploy.sol => SPBEAMDeploy.sol} | 38 +-- .../{DSPCDeploy.t.sol => SPBEAMDeploy.t.sol} | 38 +-- .../{DSPCInit.sol => SPBEAMInit.sol} | 60 ++-- .../{DSPCInit.t.sol => SPBEAMInit.t.sol} | 52 ++-- .../{DSPCInstance.sol => SPBEAMInstance.sol} | 4 +- 13 files changed, 328 insertions(+), 326 deletions(-) rename script/{DSPCDeploy.s.sol => SPBEAMDeploy.s.sol} (82%) rename script/input/1/{template-dspc-deploy.json => template-spbeam-deploy.json} (100%) rename src/{DSPC.sol => SPBEAM.sol} (83%) rename src/{DSPC.t.sol => SPBEAM.t.sol} (55%) rename src/{DSPCMom.sol => SPBEAMMom.sol} (83%) rename src/{DSPCMom.t.sol => SPBEAMMom.t.sol} (75%) rename src/deployment/{DSPCDeploy.sol => SPBEAMDeploy.sol} (58%) rename src/deployment/{DSPCDeploy.t.sol => SPBEAMDeploy.t.sol} (52%) rename src/deployment/{DSPCInit.sol => SPBEAMInit.sol} (55%) rename src/deployment/{DSPCInit.t.sol => SPBEAMInit.t.sol} (69%) rename src/deployment/{DSPCInstance.sol => SPBEAMInstance.sol} (94%) diff --git a/README.md b/README.md index f410442..a0a3365 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,10 @@ -# Direct Stability Parameters Change Module (DSPC) +# Stability Parameter Bounded External Access Module (SP-BEAM) A module for the Sky Protocol that enables direct changes to stability parameters (duty, dsr, ssr) through a simple, secure interface with proper constraints and timelocks. ## Overview -The DSPC module provides a streamlined way to modify stability parameters in the Maker Protocol, including: +The SP-BEAM module provides a streamlined way to modify stability parameters in the Maker Protocol, including: - Stability fees (duty) for different collateral types via the Jug contract - Dai Savings Rate (DSR) via the Pot contract - Sky Savings Rate (SSR) via the sUSDS contract @@ -37,7 +37,7 @@ forge test 1. Deploy the contract with the required addresses: ```solidity -DSPC dspc = new DSPC( +SPBEAM beam = new SPBEAM( jugAddress, // For stability fees potAddress, // For DSR susdsAddress, // For SSR @@ -48,30 +48,30 @@ DSPC dspc = new DSPC( 2. Configure the module parameters: ```solidity // Set timelock duration -dspc.file("tau", 1 days); +beam.file("tau", 1 days); // Configure constraints for a collateral type -dspc.file("ETH-A", "max", 1000); // Max rate: 10% -dspc.file("ETH-A", "min", 1); // Min rate: 0.01% -dspc.file("ETH-A", "step", 100); // Max change: 1% +beam.file("ETH-A", "max", 1000); // Max rate: 10% +beam.file("ETH-A", "min", 1); // Min rate: 0.01% +beam.file("ETH-A", "step", 100); // Max change: 1% // Configure constraints for DSR -dspc.file("DSR", "max", 800); // Max rate: 8% -dspc.file("DSR", "min", 1); // Min rate: 0.01% -dspc.file("DSR", "step", 100); // Max change: 1% +beam.file("DSR", "max", 800); // Max rate: 8% +beam.file("DSR", "min", 1); // Min rate: 0.01% +beam.file("DSR", "step", 100); // Max change: 1% ``` 3. Add facilitators who can propose and execute rate changes: ```solidity -dspc.kiss(facilitatorAddress); +beam.kiss(facilitatorAddress); ``` 4. Execute a batch of rate changes: ```solidity -DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); -updates[0] = DSPC.ParamChange("DSR", 75); // Set DSR to 0.75% -updates[1] = DSPC.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% -dspc.set(updates); +SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](2); +updates[0] = SPBEAM.ParamChange("DSR", 75); // Set DSR to 0.75% +updates[1] = SPBEAM.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% +beam.set(updates); ``` ## Security @@ -79,7 +79,7 @@ dspc.set(updates); The module implements a robust security model: - Two-level access control (admins and facilitators) - Rate constraints to prevent extreme changes -- Disabling without GSM delay via DSPCMom contract +- Disabling without GSM delay via SPBEAMMom contract - Circuit breaker (halt) functionality - All actions emit events for transparency diff --git a/script/DSPCDeploy.s.sol b/script/SPBEAMDeploy.s.sol similarity index 82% rename from script/DSPCDeploy.s.sol rename to script/SPBEAMDeploy.s.sol index 41ca71f..54974e5 100644 --- a/script/DSPCDeploy.s.sol +++ b/script/SPBEAMDeploy.s.sol @@ -19,21 +19,21 @@ import {Script} from "forge-std/Script.sol"; import {stdJson} from "forge-std/StdJson.sol"; import {MCD, DssInstance} from "dss-test/MCD.sol"; import {ScriptTools} from "dss-test/ScriptTools.sol"; -import {DSPCDeploy, DSPCDeployParams} from "src/deployment/DSPCDeploy.sol"; -import {DSPCInstance} from "src/deployment/DSPCInstance.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "src/deployment/SPBEAMDeploy.sol"; +import {SPBEAMInstance} from "src/deployment/SPBEAMInstance.sol"; -contract DSPCDeployScript is Script { +contract SPBEAMDeployScript is Script { using stdJson for string; using ScriptTools for string; - string constant NAME = "dspc-deploy"; + string constant NAME = "spbeam-deploy"; string config; address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; DssInstance dss = MCD.loadFromChainlog(CHAINLOG); address pauseProxy = dss.chainlog.getAddress("MCD_PAUSE_PROXY"); address conv; - DSPCInstance inst; + SPBEAMInstance inst; function run() external { config = ScriptTools.loadConfig(); @@ -41,8 +41,8 @@ contract DSPCDeployScript is Script { vm.startBroadcast(); - inst = DSPCDeploy.deploy( - DSPCDeployParams({ + inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: msg.sender, owner: pauseProxy, jug: address(dss.jug), @@ -54,7 +54,7 @@ contract DSPCDeployScript is Script { vm.stopBroadcast(); - ScriptTools.exportContract(NAME, "dspc", address(inst.dspc)); + ScriptTools.exportContract(NAME, "spbeam", address(inst.spbeam)); ScriptTools.exportContract(NAME, "mom", address(inst.mom)); ScriptTools.exportContract(NAME, "conv", conv); } diff --git a/script/input/1/README.md b/script/input/1/README.md index cb44384..57ba3ea 100644 --- a/script/input/1/README.md +++ b/script/input/1/README.md @@ -1,24 +1,24 @@ # Network 1 (Ethereum Mainnet) Deployment Configuration -This directory contains the configuration files for deploying DSPC on Ethereum Mainnet. +This directory contains the configuration files for deploying SPBEAM on Ethereum Mainnet. ## Files -### dspc-deploy.json -Configuration for deploying DSPC and DSPCMom contracts: +### spbeam-deploy.json +Configuration for deploying SPBEAM and SPBEAMMom contracts: - `conv`: Address of the converter contract that handles rate conversions between basis points and ray format ## Usage -1. Copy `template-dspc-deploy.json` into a new file (i.e.: `dspc-deploy.json`) +1. Copy `template-spbeam-deploy.json` into a new file (i.e.: `spbeam-deploy.json`) 2. Edit the new file with the correct `conv` address 3. Run the deployment script: ```bash -FOUNDRY_SCRIPT_CONFIG=dspc-deploy forge script script/DSPCDeploy.s.sol:DSPCDeployScript \ +FOUNDRY_SCRIPT_CONFIG=spbeam-deploy forge script script/SPBEAMDeploy.s.sol:SPBEAMDeployScript \ --rpc-url $ETH_RPC_URL \ --broadcast The deployment script will: 1. Load system addresses from chainlog (jug, pot, susds) -2. Deploy DSPC and DSPCMom contracts -4. Export addresses to `/script/output/1/dspc-deploy.json` +2. Deploy SPBEAM and SPBEAMMom contracts +4. Export addresses to `/script/output/1/spbeam-deploy.json` diff --git a/script/input/1/template-dspc-deploy.json b/script/input/1/template-spbeam-deploy.json similarity index 100% rename from script/input/1/template-dspc-deploy.json rename to script/input/1/template-spbeam-deploy.json diff --git a/src/DSPC.sol b/src/SPBEAM.sol similarity index 83% rename from src/DSPC.sol rename to src/SPBEAM.sol index 29d59b3..37c2a79 100644 --- a/src/DSPC.sol +++ b/src/SPBEAM.sol @@ -39,14 +39,14 @@ interface ConvLike { function rtob(uint256 ray) external pure returns (uint256 bps); } -/// @title Direct Stability Parameters Change Module (DSPC) +/// @title Stability Parameter Bounded External Access Module (SP-BEAM) /// @notice A module for managing protocol stability parameters with configurable constraints and safety checks /// @dev Provides controlled access to modify stability parameters (ilk stability fees, DSR, SSR) with: /// - Configurable min/max bounds and step sizes for each parameter /// - Cooldown periods between updates /// - Ordered batch updates /// - Emergency circuit breaker -contract DSPC { +contract SPBEAM { // --- Structs --- /// @notice Configuration for a rate parameter's constraints /// @dev All values are in basis points (1 bp = 0.01%) @@ -133,21 +133,21 @@ contract DSPC { // --- Modifiers --- modifier auth() { - require(wards[msg.sender] == 1, "DSPC/not-authorized"); + require(wards[msg.sender] == 1, "SPBEAM/not-authorized"); _; } modifier toll() { - require(buds[msg.sender] == 1, "DSPC/not-facilitator"); + require(buds[msg.sender] == 1, "SPBEAM/not-facilitator"); _; } modifier good() { - require(bad == 0, "DSPC/module-halted"); + require(bad == 0, "SPBEAM/module-halted"); _; } - /// @notice Initialize the DSPC module with core system contracts + /// @notice Initialize the SPBEAM module with core system contracts /// @param _jug Jug contract for stability fee management /// @param _pot Pot contract for Dai Savings Rate (DSR) /// @param _susds SUSDS contract for Sky Savings Rate (SSR) @@ -204,16 +204,16 @@ contract DSPC { /// - toc: Last update timestamp (set automatically) function file(bytes32 what, uint256 data) external auth { if (what == "bad") { - require(data == 0 || data == 1, "DSPC/invalid-bad-value"); + require(data == 0 || data == 1, "SPBEAM/invalid-bad-value"); bad = uint8(data); } else if (what == "tau") { - require(data <= type(uint64).max, "DSPC/invalid-tau-value"); + require(data <= type(uint64).max, "SPBEAM/invalid-tau-value"); tau = uint64(data); } else if (what == "toc") { - require(data <= type(uint128).max, "DSPC/invalid-toc-value"); + require(data <= type(uint128).max, "SPBEAM/invalid-toc-value"); toc = uint128(data); } else { - revert("DSPC/file-unrecognized-param"); + revert("SPBEAM/file-unrecognized-param"); } emit File(what, data); @@ -233,19 +233,19 @@ contract DSPC { function file(bytes32 id, bytes32 what, uint256 data) external auth { if (id != "DSR" && id != "SSR") { (uint256 duty,) = jug.ilks(id); - require(duty > 0, "DSPC/ilk-not-initialized"); + require(duty > 0, "SPBEAM/ilk-not-initialized"); } - require(data <= type(uint16).max, "DSPC/invalid-value"); + require(data <= type(uint16).max, "SPBEAM/invalid-value"); if (what == "min") { - require(data <= cfgs[id].max, "DSPC/min-too-high"); + require(data <= cfgs[id].max, "SPBEAM/min-too-high"); cfgs[id].min = uint16(data); } else if (what == "max") { - require(data >= cfgs[id].min, "DSPC/max-too-low"); + require(data >= cfgs[id].min, "SPBEAM/max-too-low"); cfgs[id].max = uint16(data); } else if (what == "step") { cfgs[id].step = uint16(data); } else { - revert("DSPC/file-unrecognized-param"); + revert("SPBEAM/file-unrecognized-param"); } emit File(id, what, data); @@ -260,34 +260,34 @@ contract DSPC { /// 4. Ensures updates are properly ordered to prevent duplicates /// 5. Calls drip() before each update to accrue fees /// @dev Reverts if: - /// - Caller not authorized (DSPC/not-facilitator) - /// - Module halted, bad = 1 (DSPC/module-halted) - /// - Empty updates array (DSPC/empty-batch) - /// - Cooldown period not elapsed (DSPC/too-early) - /// - Updates not ordered alphabetically by id (DSPC/updates-out-of-order) - /// - Rate not configured, step = 0 (DSPC/rate-not-configured) - /// - New rate < min (DSPC/below-min) - /// - New rate > max (DSPC/above-max) - /// - Rate change > step (DSPC/delta-above-step) - /// - Rate conversion failed (DSPC/invalid-rate-conv) + /// - Caller not authorized (SPBEAM/not-facilitator) + /// - Module halted, bad = 1 (SPBEAM/module-halted) + /// - Empty updates array (SPBEAM/empty-batch) + /// - Cooldown period not elapsed (SPBEAM/too-early) + /// - Updates not ordered alphabetically by id (SPBEAM/updates-out-of-order) + /// - Rate not configured, step = 0 (SPBEAM/rate-not-configured) + /// - New rate < min (SPBEAM/below-min) + /// - New rate > max (SPBEAM/above-max) + /// - Rate change > step (SPBEAM/delta-above-step) + /// - Rate conversion failed (SPBEAM/invalid-rate-conv) function set(ParamChange[] calldata updates) external toll good { - require(updates.length > 0, "DSPC/empty-batch"); - require(block.timestamp >= tau + toc, "DSPC/too-early"); + require(updates.length > 0, "SPBEAM/empty-batch"); + require(block.timestamp >= tau + toc, "SPBEAM/too-early"); toc = uint128(block.timestamp); bytes32 last; for (uint256 i = 0; i < updates.length; i++) { bytes32 id = updates[i].id; - require(id > last, "DSPC/updates-out-of-order"); + require(id > last, "SPBEAM/updates-out-of-order"); last = id; uint256 bps = updates[i].bps; Cfg memory cfg = cfgs[id]; - require(cfg.step > 0, "DSPC/rate-not-configured"); - require(bps >= cfg.min, "DSPC/below-min"); - require(bps <= cfg.max, "DSPC/above-max"); + require(cfg.step > 0, "SPBEAM/rate-not-configured"); + require(bps >= cfg.min, "SPBEAM/below-min"); + require(bps <= cfg.max, "SPBEAM/above-max"); // Check rate change is within allowed gap uint256 oldBps; @@ -308,11 +308,11 @@ contract DSPC { // Calculates absolute difference between the old and the new rate uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; - require(delta <= cfg.step, "DSPC/delta-above-step"); + require(delta <= cfg.step, "SPBEAM/delta-above-step"); // Execute the update uint256 ray = conv.btor(bps); - require(ray >= RAY, "DSPC/invalid-rate-conv"); + require(ray >= RAY, "SPBEAM/invalid-rate-conv"); if (id == "DSR") { pot.drip(); pot.file("dsr", ray); diff --git a/src/DSPC.t.sol b/src/SPBEAM.t.sol similarity index 55% rename from src/DSPC.t.sol rename to src/SPBEAM.t.sol index 8933425..318b1af 100644 --- a/src/DSPC.t.sol +++ b/src/SPBEAM.t.sol @@ -16,12 +16,12 @@ pragma solidity ^0.8.24; import "dss-test/DssTest.sol"; -import {DSPC} from "./DSPC.sol"; -import {DSPCMom} from "./DSPCMom.sol"; +import {SPBEAM} from "./SPBEAM.sol"; +import {SPBEAMMom} from "./SPBEAMMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./deployment/DSPCInit.sol"; -import {DSPCInstance} from "./deployment/DSPCInstance.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./deployment/SPBEAMDeploy.sol"; +import {SPBEAMInit, SPBEAMConfig, SPBEAMRateConfig} from "./deployment/SPBEAMInit.sol"; +import {SPBEAMInstance} from "./deployment/SPBEAMInstance.sol"; interface ConvLike { function btor(uint256 bps) external pure returns (uint256 ray); @@ -38,8 +38,8 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { - DSPCInit.init(dss, inst, cfg); + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) external { + SPBEAMInit.init(dss, inst, cfg); } } @@ -49,12 +49,12 @@ contract MockBrokenConv is ConvMock { } } -contract DSPCTest is DssTest { +contract SPBEAMTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; DssInstance dss; - DSPC dspc; - DSPCMom mom; + SPBEAM beam; + SPBEAMMom mom; ConvLike conv; SUSDSLike susds; address pause; @@ -83,8 +83,8 @@ contract DSPCTest is DssTest { conv = ConvLike(address(new ConvMock())); - DSPCInstance memory inst = DSPCDeploy.deploy( - DSPCDeployParams({ + SPBEAMInstance memory inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: address(this), owner: address(pauseProxy), jug: address(dss.jug), @@ -93,14 +93,14 @@ contract DSPCTest is DssTest { conv: address(conv) }) ); - dspc = DSPC(inst.dspc); - mom = DSPCMom(inst.mom); + beam = SPBEAM(inst.spbeam); + mom = SPBEAMMom(inst.mom); // Initialize deployment - DSPCRateConfig[] memory ilks = new DSPCRateConfig[](3); // ETH-A, DSR, SSR + SPBEAMRateConfig[] memory ilks = new SPBEAMRateConfig[](3); // ETH-A, DSR, SSR // Configure ETH-A - ilks[0] = DSPCRateConfig({ + ilks[0] = SPBEAMRateConfig({ id: ILK, // Use the constant bytes32 ILK min: uint16(1), max: uint16(3000), @@ -108,7 +108,7 @@ contract DSPCTest is DssTest { }); // Configure DSR - ilks[1] = DSPCRateConfig({ + ilks[1] = SPBEAMRateConfig({ id: DSR, // Use the constant bytes32 DSR min: uint16(1), max: uint16(3000), @@ -116,14 +116,14 @@ contract DSPCTest is DssTest { }); // Configure SSR - ilks[2] = DSPCRateConfig({ + ilks[2] = SPBEAMRateConfig({ id: SSR, // Use the constant bytes32 SSR min: uint16(1), max: uint16(3000), step: uint16(100) }); - DSPCConfig memory cfg = DSPCConfig({ + SPBEAMConfig memory cfg = SPBEAMConfig({ tau: 0, // Start with tau = 0 for tests ilks: ilks, bud: bud @@ -133,88 +133,88 @@ contract DSPCTest is DssTest { } function test_constructor() public view { - assertEq(address(dspc.jug()), address(dss.jug)); - assertEq(address(dspc.pot()), address(dss.pot)); - assertEq(address(dspc.susds()), address(susds)); - assertEq(address(dspc.conv()), address(conv)); + assertEq(address(beam.jug()), address(dss.jug)); + assertEq(address(beam.pot()), address(dss.pot)); + assertEq(address(beam.susds()), address(susds)); + assertEq(address(beam.conv()), address(conv)); // init - assertEq(dspc.wards(address(this)), 0); - assertEq(dspc.wards(address(pauseProxy)), 1); - assertEq(dspc.wards(address(mom)), 1); + assertEq(beam.wards(address(this)), 0); + assertEq(beam.wards(address(pauseProxy)), 1); + assertEq(beam.wards(address(mom)), 1); assertEq(mom.authority(), dss.chainlog.getAddress("MCD_ADM")); - assertEq(dss.jug.wards(address(dspc)), 1); - assertEq(dss.pot.wards(address(dspc)), 1); - assertEq(SUSDSLike(dss.chainlog.getAddress("SUSDS")).wards(address(dspc)), 1); + assertEq(dss.jug.wards(address(beam)), 1); + assertEq(dss.pot.wards(address(beam)), 1); + assertEq(SUSDSLike(dss.chainlog.getAddress("SUSDS")).wards(address(beam)), 1); } function test_auth() public { - checkAuth(address(dspc), "DSPC"); + checkAuth(address(beam), "SPBEAM"); } function test_auth_methods() public { - checkModifier(address(dspc), "DSPC/not-authorized", [DSPC.kiss.selector, DSPC.diss.selector]); + checkModifier(address(beam), "SPBEAM/not-authorized", [SPBEAM.kiss.selector, SPBEAM.diss.selector]); } function test_toll_methods() public { - checkModifier(address(dspc), "DSPC/not-facilitator", [DSPC.set.selector]); + checkModifier(address(beam), "SPBEAM/not-facilitator", [SPBEAM.set.selector]); } function test_good_methods() public { vm.startPrank(address(pauseProxy)); - dspc.file("bad", 1); - dspc.kiss(address(this)); + beam.file("bad", 1); + beam.kiss(address(this)); vm.stopPrank(); - checkModifier(address(dspc), "DSPC/module-halted", [DSPC.set.selector]); + checkModifier(address(beam), "SPBEAM/module-halted", [SPBEAM.set.selector]); } function test_kiss() public { address who = address(0x0ddaf); - assertEq(dspc.buds(who), 0); + assertEq(beam.buds(who), 0); vm.prank(address(pauseProxy)); vm.expectEmit(true, true, true, true); emit Kiss(who); - dspc.kiss(who); - assertEq(dspc.buds(who), 1); + beam.kiss(who); + assertEq(beam.buds(who), 1); } function test_diss() public { address who = address(0x0ddaf); vm.prank(address(pauseProxy)); - dspc.kiss(who); - assertEq(dspc.buds(who), 1); + beam.kiss(who); + assertEq(beam.buds(who), 1); vm.prank(address(pauseProxy)); vm.expectEmit(true, true, true, true); emit Diss(who); - dspc.diss(who); - assertEq(dspc.buds(who), 0); + beam.diss(who); + assertEq(beam.buds(who), 0); } function test_file() public { - checkFileUint(address(dspc), "DSPC", ["bad", "tau", "toc"]); + checkFileUint(address(beam), "SPBEAM", ["bad", "tau", "toc"]); vm.startPrank(address(pauseProxy)); - vm.expectRevert("DSPC/invalid-bad-value"); - dspc.file("bad", 2); + vm.expectRevert("SPBEAM/invalid-bad-value"); + beam.file("bad", 2); - vm.expectRevert("DSPC/invalid-tau-value"); - dspc.file("tau", uint256(type(uint64).max) + 1); + vm.expectRevert("SPBEAM/invalid-tau-value"); + beam.file("tau", uint256(type(uint64).max) + 1); - vm.expectRevert("DSPC/invalid-toc-value"); - dspc.file("toc", uint256(type(uint128).max) + 1); + vm.expectRevert("SPBEAM/invalid-toc-value"); + beam.file("toc", uint256(type(uint128).max) + 1); vm.stopPrank(); - vm.expectRevert("DSPC/not-authorized"); - dspc.file("bad", 1); + vm.expectRevert("SPBEAM/not-authorized"); + beam.file("bad", 1); } function test_file_ilk() public { - (uint16 min, uint16 max, uint16 step) = dspc.cfgs(ILK); + (uint16 min, uint16 max, uint16 step) = beam.cfgs(ILK); assertEq(min, 1); assertEq(max, 3000); assertEq(step, 100); @@ -223,12 +223,12 @@ contract DSPCTest is DssTest { vm.expectEmit(true, true, true, true); emit File(ILK, "min", 100); - dspc.file(ILK, "min", 100); - dspc.file(ILK, "max", 3000); - dspc.file(ILK, "step", 420); + beam.file(ILK, "min", 100); + beam.file(ILK, "max", 3000); + beam.file(ILK, "step", 420); vm.stopPrank(); - (min, max, step) = dspc.cfgs(ILK); + (min, max, step) = beam.cfgs(ILK); assertEq(min, 100); assertEq(max, 3000); assertEq(step, 420); @@ -236,39 +236,39 @@ contract DSPCTest is DssTest { function test_revert_file_ilk_invalid() public { vm.startPrank(address(pauseProxy)); - (uint16 min, uint16 max,) = dspc.cfgs(ILK); + (uint16 min, uint16 max,) = beam.cfgs(ILK); - vm.expectRevert("DSPC/min-too-high"); - dspc.file(ILK, "min", max + 1); + vm.expectRevert("SPBEAM/min-too-high"); + beam.file(ILK, "min", max + 1); - vm.expectRevert("DSPC/max-too-low"); - dspc.file(ILK, "max", min - 1); + vm.expectRevert("SPBEAM/max-too-low"); + beam.file(ILK, "max", min - 1); - vm.expectRevert("DSPC/file-unrecognized-param"); - dspc.file(ILK, "unknown", 100); + vm.expectRevert("SPBEAM/file-unrecognized-param"); + beam.file(ILK, "unknown", 100); - vm.expectRevert("DSPC/invalid-value"); - dspc.file(ILK, "max", uint256(type(uint16).max) + 1); + vm.expectRevert("SPBEAM/invalid-value"); + beam.file(ILK, "max", uint256(type(uint16).max) + 1); dss.jug.drip("MOG-A"); - vm.expectRevert("DSPC/ilk-not-initialized"); - dspc.file("MOG-A", "min", 100); + vm.expectRevert("SPBEAM/ilk-not-initialized"); + beam.file("MOG-A", "min", 100); vm.stopPrank(); - vm.expectRevert("DSPC/not-authorized"); - dspc.file(ILK, "min", 100); + vm.expectRevert("SPBEAM/not-authorized"); + beam.file(ILK, "min", 100); } function test_set_ilk() public { (uint256 duty,) = dss.jug.ilks(ILK); uint256 target = conv.rtob(duty) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, target); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(target)); @@ -277,11 +277,11 @@ contract DSPCTest is DssTest { function test_set_dsr() public { uint256 target = conv.rtob(dss.pot.dsr()) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(DSR, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(DSR, target); vm.prank(bud); - dspc.set(updates); + beam.set(updates); assertEq(dss.pot.dsr(), conv.btor(target)); } @@ -290,14 +290,14 @@ contract DSPCTest is DssTest { vm.prank(bud); uint256 target = conv.rtob(susds.ssr()) - 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(SSR, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(SSR, target); vm.prank(bud); vm.expectEmit(true, true, true, true); emit Set(SSR, target); - dspc.set(updates); + beam.set(updates); assertEq(susds.ssr(), conv.btor(target)); } @@ -308,13 +308,13 @@ contract DSPCTest is DssTest { uint256 dsrTarget = conv.rtob(dss.pot.dsr()) - 50; uint256 ssrTarget = conv.rtob(susds.ssr()) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](3); - updates[0] = DSPC.ParamChange(DSR, dsrTarget); - updates[1] = DSPC.ParamChange(ILK, ilkTarget); - updates[2] = DSPC.ParamChange(SSR, ssrTarget); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](3); + updates[0] = SPBEAM.ParamChange(DSR, dsrTarget); + updates[1] = SPBEAM.ParamChange(ILK, ilkTarget); + updates[2] = SPBEAM.ParamChange(SSR, ssrTarget); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(ilkTarget)); @@ -328,11 +328,11 @@ contract DSPCTest is DssTest { vm.prank(address(pauseProxy)); dss.jug.file(ILK, "duty", conv.btor(3050)); // outside range - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 2999); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 2999); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (uint256 duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(2999)); @@ -342,10 +342,10 @@ contract DSPCTest is DssTest { vm.prank(address(pauseProxy)); dss.jug.file(ILK, "duty", conv.btor(0)); // outside range - updates[0] = DSPC.ParamChange(ILK, 50); + updates[0] = SPBEAM.ParamChange(ILK, 50); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(50)); @@ -354,92 +354,92 @@ contract DSPCTest is DssTest { function test_revert_set_duplicate() public { (uint256 duty,) = dss.jug.ilks(ILK); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); - updates[0] = DSPC.ParamChange(ILK, conv.rtob(duty) - 100); - updates[1] = DSPC.ParamChange(ILK, conv.rtob(duty) - 200); // duplicate, pushing rate beyond step + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](2); + updates[0] = SPBEAM.ParamChange(ILK, conv.rtob(duty) - 100); + updates[1] = SPBEAM.ParamChange(ILK, conv.rtob(duty) - 200); // duplicate, pushing rate beyond step vm.prank(bud); - vm.expectRevert("DSPC/updates-out-of-order"); - dspc.set(updates); + vm.expectRevert("SPBEAM/updates-out-of-order"); + beam.set(updates); } function test_revert_set_not_configured_rate() public { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange("PEPE-A", 10000); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange("PEPE-A", 10000); vm.prank(bud); - vm.expectRevert("DSPC/rate-not-configured"); - dspc.set(updates); + vm.expectRevert("SPBEAM/rate-not-configured"); + beam.set(updates); } function test_revert_set_empty() public { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](0); - vm.expectRevert("DSPC/empty-batch"); + vm.expectRevert("SPBEAM/empty-batch"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_unauthorized() public { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 100); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 100); - vm.expectRevert("DSPC/not-facilitator"); - dspc.set(updates); + vm.expectRevert("SPBEAM/not-facilitator"); + beam.set(updates); } function test_revert_set_below_min() public { vm.prank(address(pauseProxy)); - dspc.file(ILK, "min", 100); + beam.file(ILK, "min", 100); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 50); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 50); - vm.expectRevert("DSPC/below-min"); + vm.expectRevert("SPBEAM/below-min"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_above_max() public { vm.prank(address(pauseProxy)); - dspc.file(ILK, "max", 100); + beam.file(ILK, "max", 100); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 150); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 150); - vm.expectRevert("DSPC/above-max"); + vm.expectRevert("SPBEAM/above-max"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_delta_above_step() public { vm.prank(address(pauseProxy)); - dspc.file(ILK, "step", 100); + beam.file(ILK, "step", 100); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 100); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 100); - vm.expectRevert("DSPC/delta-above-step"); + vm.expectRevert("SPBEAM/delta-above-step"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_before_cooldown() public { vm.prank(address(pauseProxy)); - dspc.file("tau", 100); + beam.file("tau", 100); uint256 currentDSR = conv.rtob(dss.pot.dsr()); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(DSR, currentDSR + 1); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(DSR, currentDSR + 1); vm.prank(bud); - dspc.set(updates); + beam.set(updates); vm.warp(block.timestamp + 99); - updates[0] = DSPC.ParamChange(DSR, currentDSR + 2); + updates[0] = SPBEAM.ParamChange(DSR, currentDSR + 2); vm.prank(bud); - vm.expectRevert("DSPC/too-early"); - dspc.set(updates); + vm.expectRevert("SPBEAM/too-early"); + beam.set(updates); } function test_revert_set_malfunctioning_conv() public { @@ -449,11 +449,11 @@ contract DSPCTest is DssTest { (uint256 duty,) = dss.jug.ilks(ILK); uint256 target = conv.rtob(duty) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, target); - vm.expectRevert("DSPC/invalid-rate-conv"); + vm.expectRevert("SPBEAM/invalid-rate-conv"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } } diff --git a/src/DSPCMom.sol b/src/SPBEAMMom.sol similarity index 83% rename from src/DSPCMom.sol rename to src/SPBEAMMom.sol index 14f284c..53ca233 100644 --- a/src/DSPCMom.sol +++ b/src/SPBEAMMom.sol @@ -20,16 +20,16 @@ interface AuthorityLike { function canCall(address src, address dst, bytes4 sig) external view returns (bool); } -interface DSPCLike { +interface SPBEAMLike { function file(bytes32 what, uint256 data) external; } -/// @title DSPC Mom - Shutdown DSPC bypassing GSM delay. -/// @notice Governance contract for halting DSPC module operations +/// @title SPBEAM Mom - Shutdown SPBEAM bypassing GSM delay. +/// @notice Governance contract for halting SPBEAM module operations /// @dev Provides: /// - Owner/authority-based access control /// - Emergency halt without delay -contract DSPCMom { +contract SPBEAMMom { // --- Auth --- /// @notice Owner with full admin rights address public owner; @@ -41,17 +41,17 @@ contract DSPCMom { event SetOwner(address indexed owner); /// @notice Authority contract changed event SetAuthority(address indexed authority); - /// @notice DSPC module halted - event Halt(address indexed dspc); + /// @notice SPBEAM module halted + event Halt(address indexed spbeam); // --- Modifiers --- modifier onlyOwner() { - require(msg.sender == owner, "DSPCMom/not-owner"); + require(msg.sender == owner, "SPBEAMMom/not-owner"); _; } modifier auth() { - require(isAuthorized(msg.sender, msg.sig), "DSPCMom/not-authorized"); + require(isAuthorized(msg.sender, msg.sig), "SPBEAMMom/not-authorized"); _; } @@ -92,11 +92,11 @@ contract DSPCMom { } // --- Emergency Actions --- - /// @notice Emergency halt of DSPC module - /// @param dspc Target DSPC contract + /// @notice Emergency halt of SPBEAM module + /// @param spbeam Target SPBEAM contract /// @dev Sets bad=1 to immediately halt operations - function halt(address dspc) external auth { - DSPCLike(dspc).file("bad", 1); - emit Halt(dspc); + function halt(address spbeam) external auth { + SPBEAMLike(spbeam).file("bad", 1); + emit Halt(spbeam); } } diff --git a/src/DSPCMom.t.sol b/src/SPBEAMMom.t.sol similarity index 75% rename from src/DSPCMom.t.sol rename to src/SPBEAMMom.t.sol index f84add2..c21f0e7 100644 --- a/src/DSPCMom.t.sol +++ b/src/SPBEAMMom.t.sol @@ -17,12 +17,12 @@ pragma solidity ^0.8.24; import "dss-test/DssTest.sol"; -import {DSPC} from "./DSPC.sol"; -import {DSPCMom} from "./DSPCMom.sol"; +import {SPBEAM} from "./SPBEAM.sol"; +import {SPBEAMMom} from "./SPBEAMMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./deployment/DSPCInit.sol"; -import {DSPCInstance} from "./deployment/DSPCInstance.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./deployment/SPBEAMDeploy.sol"; +import {SPBEAMInit, SPBEAMConfig, SPBEAMRateConfig} from "./deployment/SPBEAMInit.sol"; +import {SPBEAMInstance} from "./deployment/SPBEAMInstance.sol"; interface ChiefLike { function hat() external view returns (address); @@ -43,23 +43,23 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { - DSPCInit.init(dss, inst, cfg); + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) external { + SPBEAMInit.init(dss, inst, cfg); } } -contract DSPCMomIntegrationTest is DssTest { +contract SPBEAMMomIntegrationTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; // --- Events --- event SetOwner(address indexed owner); event SetAuthority(address indexed authority); - event Halt(address indexed dspc); + event Halt(address indexed spbeam); DssInstance dss; ChiefLike chief; - DSPC dspc; - DSPCMom mom; + SPBEAM spbeam; + SPBEAMMom mom; ConvLike conv; SUSDSLike susds; address pause; @@ -83,8 +83,8 @@ contract DSPCMomIntegrationTest is DssTest { conv = ConvLike(address(new ConvMock())); - DSPCInstance memory inst = DSPCDeploy.deploy( - DSPCDeployParams({ + SPBEAMInstance memory inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: address(this), owner: address(pauseProxy), jug: address(dss.jug), @@ -93,13 +93,13 @@ contract DSPCMomIntegrationTest is DssTest { conv: address(conv) }) ); - dspc = DSPC(inst.dspc); - mom = DSPCMom(inst.mom); + spbeam = SPBEAM(inst.spbeam); + mom = SPBEAMMom(inst.mom); // Initialize deployment - DSPCConfig memory cfg = DSPCConfig({ + SPBEAMConfig memory cfg = SPBEAMConfig({ tau: 0, // Start with tau = 0 for tests - ilks: new DSPCRateConfig[](0), // No ilks for this test + ilks: new SPBEAMRateConfig[](0), // No ilks for this test bud: address(0) // No bud for this test }); vm.prank(pause); @@ -111,15 +111,17 @@ contract DSPCMomIntegrationTest is DssTest { } function test_only_owner_methods() public { - checkModifier(address(mom), "DSPCMom/not-owner", [DSPCMom.setOwner.selector, DSPCMom.setAuthority.selector]); + checkModifier( + address(mom), "SPBEAMMom/not-owner", [SPBEAMMom.setOwner.selector, SPBEAMMom.setAuthority.selector] + ); } function test_auth_methods() public { - checkModifier(address(mom), "DSPCMom/not-authorized", [DSPCMom.halt.selector]); + checkModifier(address(mom), "SPBEAMMom/not-authorized", [SPBEAMMom.halt.selector]); vm.prank(address(pauseProxy)); mom.setAuthority(address(0)); - checkModifier(address(mom), "DSPCMom/not-authorized", [DSPCMom.halt.selector]); + checkModifier(address(mom), "SPBEAMMom/not-authorized", [SPBEAMMom.halt.selector]); } function test_setOwner() public { @@ -141,9 +143,9 @@ contract DSPCMomIntegrationTest is DssTest { function check_halt(address who) internal { vm.prank(who); vm.expectEmit(true, true, true, true); - emit Halt(address(dspc)); - mom.halt(address(dspc)); - assertEq(dspc.bad(), 1); + emit Halt(address(spbeam)); + mom.halt(address(spbeam)); + assertEq(spbeam.bad(), 1); } function test_halt_owner() public { diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/SPBEAMDeploy.sol similarity index 58% rename from src/deployment/DSPCDeploy.sol rename to src/deployment/SPBEAMDeploy.sol index 42b229f..926e345 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/SPBEAMDeploy.sol @@ -17,18 +17,18 @@ pragma solidity ^0.8.24; import {ScriptTools} from "dss-test/ScriptTools.sol"; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAM} from "../SPBEAM.sol"; +import {SPBEAMMom} from "../SPBEAMMom.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; interface MomLike { function setOwner(address owner) external; } -/// @title DSPC Deployment Parameters -/// @notice Parameters required for deploying the DSPC system -/// @dev Used to configure the initial setup of DSPC and DSPCMom contracts -struct DSPCDeployParams { +/// @title SPBEAM Deployment Parameters +/// @notice Parameters required for deploying the SPBEAM system +/// @dev Used to configure the initial setup of SPBEAM and SPBEAMMom contracts +struct SPBEAMDeployParams { /// @dev Address deploying the contracts address deployer; /// @dev Final owner address after deployment @@ -43,23 +43,23 @@ struct DSPCDeployParams { address conv; } -/// @title DSPC Deployment Library -/// @notice Handles deployment of DSPC system contracts -/// @dev Deploys and configures DSPC and DSPCMom contracts with proper permissions -library DSPCDeploy { - /// @notice Deploy DSPC system contracts - /// @dev Deploys DSPC and DSPCMom, sets up initial permissions +/// @title SPBEAM Deployment Library +/// @notice Handles deployment of SPBEAM system contracts +/// @dev Deploys and configures SPBEAM and SPBEAMMom contracts with proper permissions +library SPBEAMDeploy { + /// @notice Deploy SPBEAM system contracts + /// @dev Deploys SPBEAM and SPBEAMMom, sets up initial permissions /// @param params Configuration parameters for deployment /// @return inst Instance containing addresses of deployed contracts - function deploy(DSPCDeployParams memory params) internal returns (DSPCInstance memory inst) { - // Deploy DSPC with core contract references - inst.dspc = address(new DSPC(params.jug, params.pot, params.susds, params.conv)); + function deploy(SPBEAMDeployParams memory params) internal returns (SPBEAMInstance memory inst) { + // Deploy SPBEAM with core contract references + inst.spbeam = address(new SPBEAM(params.jug, params.pot, params.susds, params.conv)); - // Deploy DSPCMom for governance - inst.mom = address(new DSPCMom()); + // Deploy SPBEAMMom for governance + inst.mom = address(new SPBEAMMom()); // Switch owners - ScriptTools.switchOwner(inst.dspc, params.deployer, params.owner); + ScriptTools.switchOwner(inst.spbeam, params.deployer, params.owner); MomLike(inst.mom).setOwner(params.owner); } } diff --git a/src/deployment/DSPCDeploy.t.sol b/src/deployment/SPBEAMDeploy.t.sol similarity index 52% rename from src/deployment/DSPCDeploy.t.sol rename to src/deployment/SPBEAMDeploy.t.sol index 78fbd23..cf2549e 100644 --- a/src/deployment/DSPCDeploy.t.sol +++ b/src/deployment/SPBEAMDeploy.t.sol @@ -4,10 +4,10 @@ pragma solidity ^0.8.24; import "dss-test/DssTest.sol"; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAM} from "../SPBEAM.sol"; +import {SPBEAMMom} from "../SPBEAMMom.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./SPBEAMDeploy.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; import {ConvMock} from "../mocks/ConvMock.sol"; interface JugLike { @@ -22,7 +22,7 @@ interface SUSDSLike { function wards(address) external view returns (uint256); } -contract DSPCDeployTest is DssTest { +contract SPBEAMDeployTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; address susds; address deployer = address(0xDE9); @@ -30,7 +30,7 @@ contract DSPCDeployTest is DssTest { DssInstance dss; ConvMock conv; - DSPCInstance inst; + SPBEAMInstance inst; function setUp() public { vm.createSelectFork("mainnet"); @@ -41,8 +41,8 @@ contract DSPCDeployTest is DssTest { function test_deploy() public { vm.startPrank(deployer); - inst = DSPCDeploy.deploy( - DSPCDeployParams({ + inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: deployer, owner: owner, jug: address(dss.jug), @@ -53,19 +53,19 @@ contract DSPCDeployTest is DssTest { ); vm.stopPrank(); - // Verify DSPC deployment - assertTrue(inst.dspc != address(0), "DSPC not deployed"); - assertEq(address(DSPC(inst.dspc).jug()), address(dss.jug), "Wrong jug"); - assertEq(address(DSPC(inst.dspc).pot()), address(dss.pot), "Wrong pot"); - assertEq(address(DSPC(inst.dspc).susds()), susds, "Wrong susds"); - assertEq(address(DSPC(inst.dspc).conv()), address(conv), "Wrong conv"); + // Verify SPBEAM deployment + assertTrue(inst.spbeam != address(0), "SPBEAM not deployed"); + assertEq(address(SPBEAM(inst.spbeam).jug()), address(dss.jug), "Wrong jug"); + assertEq(address(SPBEAM(inst.spbeam).pot()), address(dss.pot), "Wrong pot"); + assertEq(address(SPBEAM(inst.spbeam).susds()), susds, "Wrong susds"); + assertEq(address(SPBEAM(inst.spbeam).conv()), address(conv), "Wrong conv"); - // Verify DSPCMom deployment - assertTrue(inst.mom != address(0), "DSPCMom not deployed"); - assertEq(DSPCMom(inst.mom).owner(), owner, "Wrong mom owner"); + // Verify SPBEAMMom deployment + assertTrue(inst.mom != address(0), "SPBEAMMom not deployed"); + assertEq(SPBEAMMom(inst.mom).owner(), owner, "Wrong mom owner"); // Verify ownership transfer - assertEq(DSPC(inst.dspc).wards(owner), 1, "Owner not authorized in DSPC"); - assertEq(DSPC(inst.dspc).wards(deployer), 0, "Deployer still authorized in DSPC"); + assertEq(SPBEAM(inst.spbeam).wards(owner), 1, "Owner not authorized in SPBEAM"); + assertEq(SPBEAM(inst.spbeam).wards(deployer), 0, "Deployer still authorized in SPBEAM"); } } diff --git a/src/deployment/DSPCInit.sol b/src/deployment/SPBEAMInit.sol similarity index 55% rename from src/deployment/DSPCInit.sol rename to src/deployment/SPBEAMInit.sol index 1086d7c..046f6c9 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/SPBEAMInit.sol @@ -17,25 +17,25 @@ pragma solidity ^0.8.24; import {DssInstance} from "dss-test/MCD.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; interface RelyLike { function rely(address usr) external; } -interface DSPCLike is RelyLike { +interface SPBEAMLike is RelyLike { function file(bytes32 what, uint256 data) external; function file(bytes32 ilk, bytes32 what, uint256 data) external; function kiss(address usr) external; } -interface DSPCMomLike { +interface SPBEAMMomLike { function setAuthority(address usr) external; } -/// @title Configuration parameters for a rate in DSPC +/// @title Configuration parameters for a rate in SPBEAM /// @dev Used to configure rate parameters for a specific rate -struct DSPCRateConfig { +struct SPBEAMRateConfig { /// @dev Rate identifier bytes32 id; /// @dev Minimum rate in basis points @@ -47,53 +47,53 @@ struct DSPCRateConfig { } /// @dev Step size in basis points [0-65535] -/// @title Global configuration parameters for DSPC +/// @title Global configuration parameters for SPBEAM /// @dev Used to configure global parameters and collateral-specific settings -struct DSPCConfig { +struct SPBEAMConfig { /// @dev Time delay between rate updates uint256 tau; /// @dev Collateral-specific settings - DSPCRateConfig[] ilks; + SPBEAMRateConfig[] ilks; /// @dev Bud to be authed within setup address bud; } /// @dev Array of collateral configurations /// @title Dynamic Stability Parameter Controller Initialization -/// @notice Handles initialization and configuration of the DSPC contract -/// @dev Sets up permissions and configures parameters for the DSPC system -library DSPCInit { - /// @notice Initializes a DSPC instance with the specified configuration - /// @dev Sets up permissions between DSPC and core contracts, and configures parameters +/// @notice Handles initialization and configuration of the SPBEAM contract +/// @dev Sets up permissions and configures parameters for the SPBEAM system +library SPBEAMInit { + /// @notice Initializes a SPBEAM instance with the specified configuration + /// @dev Sets up permissions between SPBEAM and core contracts, and configures parameters /// @param dss The DSS (MakerDAO) instance containing core contract references - /// @param inst The DSPC instance containing contract addresses - /// @param cfg The configuration parameters for DSPC - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) internal { + /// @param inst The SPBEAM instance containing contract addresses + /// @param cfg The configuration parameters for SPBEAM + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) internal { // Set up permissions - // Authorize DSPCMom in DSPC - RelyLike(inst.dspc).rely(inst.mom); + // Authorize SPBEAMMom in SPBEAM + RelyLike(inst.spbeam).rely(inst.mom); - // Set DSPCMom authority to MCD_ADM - DSPCMomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); + // Set SPBEAMMom authority to MCD_ADM + SPBEAMMomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); - // Authorize DSPC in core contracts - dss.jug.rely(inst.dspc); - dss.pot.rely(inst.dspc); - RelyLike(dss.chainlog.getAddress("SUSDS")).rely(inst.dspc); + // Authorize SPBEAM in core contracts + dss.jug.rely(inst.spbeam); + dss.pot.rely(inst.spbeam); + RelyLike(dss.chainlog.getAddress("SUSDS")).rely(inst.spbeam); // Configure global parameters - DSPCLike(inst.dspc).file("tau", cfg.tau); + SPBEAMLike(inst.spbeam).file("tau", cfg.tau); // Configure ilks for (uint256 i = 0; i < cfg.ilks.length; i++) { - DSPCRateConfig memory ilk = cfg.ilks[i]; - DSPCLike(inst.dspc).file(ilk.id, "max", uint256(ilk.max)); - DSPCLike(inst.dspc).file(ilk.id, "min", uint256(ilk.min)); - DSPCLike(inst.dspc).file(ilk.id, "step", uint256(ilk.step)); + SPBEAMRateConfig memory ilk = cfg.ilks[i]; + SPBEAMLike(inst.spbeam).file(ilk.id, "max", uint256(ilk.max)); + SPBEAMLike(inst.spbeam).file(ilk.id, "min", uint256(ilk.min)); + SPBEAMLike(inst.spbeam).file(ilk.id, "step", uint256(ilk.step)); } // Authorize bud - DSPCLike(inst.dspc).kiss(cfg.bud); + SPBEAMLike(inst.spbeam).kiss(cfg.bud); } } diff --git a/src/deployment/DSPCInit.t.sol b/src/deployment/SPBEAMInit.t.sol similarity index 69% rename from src/deployment/DSPCInit.t.sol rename to src/deployment/SPBEAMInit.t.sol index abc82f7..0725a9c 100644 --- a/src/deployment/DSPCInit.t.sol +++ b/src/deployment/SPBEAMInit.t.sol @@ -18,11 +18,11 @@ pragma solidity ^0.8.24; import {DssTest, MCD} from "dss-test/DssTest.sol"; import {DssInstance} from "dss-test/MCD.sol"; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./DSPCInit.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAM} from "../SPBEAM.sol"; +import {SPBEAMMom} from "../SPBEAMMom.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./SPBEAMDeploy.sol"; +import {SPBEAMInit, SPBEAMConfig, SPBEAMRateConfig} from "./SPBEAMInit.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; import {ConvMock} from "../mocks/ConvMock.sol"; interface RelyLike { @@ -53,12 +53,12 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { - DSPCInit.init(dss, inst, cfg); + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) external { + SPBEAMInit.init(dss, inst, cfg); } } -contract DSPCInitTest is DssTest { +contract SPBEAMInitTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; address deployer = address(0xDE9); address owner = address(0x123); @@ -69,7 +69,7 @@ contract DSPCInitTest is DssTest { DssInstance dss; ConvMock conv; - DSPCInstance inst; + SPBEAMInstance inst; function setUp() public { vm.createSelectFork("mainnet"); @@ -81,8 +81,8 @@ contract DSPCInitTest is DssTest { caller = new InitCaller(); vm.startPrank(deployer); - inst = DSPCDeploy.deploy( - DSPCDeployParams({ + inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: deployer, owner: address(pauseProxy), jug: address(dss.jug), @@ -96,10 +96,10 @@ contract DSPCInitTest is DssTest { function test_init() public { // Create test configuration - DSPCRateConfig[] memory ilks = new DSPCRateConfig[](2); + SPBEAMRateConfig[] memory ilks = new SPBEAMRateConfig[](2); // Configure ETH-A - ilks[0] = DSPCRateConfig({ + ilks[0] = SPBEAMRateConfig({ id: "ETH-A", min: uint16(0), // 0% max: uint16(1000), // 10% @@ -107,41 +107,41 @@ contract DSPCInitTest is DssTest { }); // Configure WBTC-A - ilks[1] = DSPCRateConfig({ + ilks[1] = SPBEAMRateConfig({ id: "WBTC-A", min: uint16(0), // 0% max: uint16(1500), // 15% step: uint16(100) // 1% }); - DSPCConfig memory cfg = DSPCConfig({tau: 1 days, ilks: ilks, bud: address(0x0ddaf)}); + SPBEAMConfig memory cfg = SPBEAMConfig({tau: 1 days, ilks: ilks, bud: address(0x0ddaf)}); vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); - // Verify DSPCMom authority - assertEq(DSPCMom(inst.mom).authority(), dss.chainlog.getAddress("MCD_ADM"), "Wrong authority"); + // Verify SPBEAMMom authority + assertEq(SPBEAMMom(inst.mom).authority(), dss.chainlog.getAddress("MCD_ADM"), "Wrong authority"); - // Verify DSPC permissions - assertEq(DSPC(inst.dspc).wards(inst.mom), 1, "Mom not authorized in DSPC"); + // Verify SPBEAM permissions + assertEq(SPBEAM(inst.spbeam).wards(inst.mom), 1, "Mom not authorized in SPBEAM"); // Verify core contract permissions - assertEq(JugLike(address(dss.jug)).wards(inst.dspc), 1, "DSPC not authorized in Jug"); - assertEq(PotLike(address(dss.pot)).wards(inst.dspc), 1, "DSPC not authorized in Pot"); - assertEq(SUSDSLike(susds).wards(inst.dspc), 1, "DSPC not authorized in SUSDS"); + assertEq(JugLike(address(dss.jug)).wards(inst.spbeam), 1, "SPBEAM not authorized in Jug"); + assertEq(PotLike(address(dss.pot)).wards(inst.spbeam), 1, "SPBEAM not authorized in Pot"); + assertEq(SUSDSLike(susds).wards(inst.spbeam), 1, "SPBEAM not authorized in SUSDS"); // Verify configuration - assertEq(DSPC(inst.dspc).tau(), cfg.tau, "Wrong tau"); - assertEq(DSPC(inst.dspc).buds(cfg.bud), 1, "Wrong bud"); + assertEq(SPBEAM(inst.spbeam).tau(), cfg.tau, "Wrong tau"); + assertEq(SPBEAM(inst.spbeam).buds(cfg.bud), 1, "Wrong bud"); // Verify ETH-A config - (uint16 min, uint16 max, uint16 step) = DSPC(inst.dspc).cfgs("ETH-A"); + (uint16 min, uint16 max, uint16 step) = SPBEAM(inst.spbeam).cfgs("ETH-A"); assertEq(min, ilks[0].min, "Wrong ETH-A min"); assertEq(max, ilks[0].max, "Wrong ETH-A max"); assertEq(step, ilks[0].step, "Wrong ETH-A step"); // Verify WBTC-A config - (min, max, step) = DSPC(inst.dspc).cfgs("WBTC-A"); + (min, max, step) = SPBEAM(inst.spbeam).cfgs("WBTC-A"); assertEq(min, ilks[1].min, "Wrong WBTC-A min"); assertEq(max, ilks[1].max, "Wrong WBTC-A max"); assertEq(step, ilks[1].step, "Wrong WBTC-A step"); diff --git a/src/deployment/DSPCInstance.sol b/src/deployment/SPBEAMInstance.sol similarity index 94% rename from src/deployment/DSPCInstance.sol rename to src/deployment/SPBEAMInstance.sol index ba575d5..e513755 100644 --- a/src/deployment/DSPCInstance.sol +++ b/src/deployment/SPBEAMInstance.sol @@ -16,7 +16,7 @@ pragma solidity ^0.8.24; -struct DSPCInstance { - address dspc; +struct SPBEAMInstance { + address spbeam; address mom; } From 2d04d2e6165beb02cd45379f87c9fd24cf3bb3a3 Mon Sep 17 00:00:00 2001 From: oddaf <106770775+oddaf@users.noreply.github.com> Date: Fri, 28 Mar 2025 09:50:31 -0300 Subject: [PATCH 88/96] Rename module (DSPC -> SPBEAM) (#9) * refactor: rename module (DSPC -> SPBEAM) * chore: formatting --- README.md | 32 +-- .../{DSPCDeploy.s.sol => SPBEAMDeploy.s.sol} | 16 +- script/input/1/README.md | 14 +- ...eploy.json => template-spbeam-deploy.json} | 0 src/{DSPC.sol => SPBEAM.sol} | 70 +++-- src/{DSPC.t.sol => SPBEAM.t.sol} | 260 +++++++++--------- src/{DSPCMom.sol => SPBEAMMom.sol} | 30 +- src/{DSPCMom.t.sol => SPBEAMMom.t.sol} | 48 ++-- .../{DSPCDeploy.sol => SPBEAMDeploy.sol} | 38 +-- .../{DSPCDeploy.t.sol => SPBEAMDeploy.t.sol} | 38 +-- .../{DSPCInit.sol => SPBEAMInit.sol} | 60 ++-- .../{DSPCInit.t.sol => SPBEAMInit.t.sol} | 52 ++-- .../{DSPCInstance.sol => SPBEAMInstance.sol} | 4 +- 13 files changed, 328 insertions(+), 334 deletions(-) rename script/{DSPCDeploy.s.sol => SPBEAMDeploy.s.sol} (82%) rename script/input/1/{template-dspc-deploy.json => template-spbeam-deploy.json} (100%) rename src/{DSPC.sol => SPBEAM.sol} (83%) rename src/{DSPC.t.sol => SPBEAM.t.sol} (55%) rename src/{DSPCMom.sol => SPBEAMMom.sol} (81%) rename src/{DSPCMom.t.sol => SPBEAMMom.t.sol} (75%) rename src/deployment/{DSPCDeploy.sol => SPBEAMDeploy.sol} (58%) rename src/deployment/{DSPCDeploy.t.sol => SPBEAMDeploy.t.sol} (52%) rename src/deployment/{DSPCInit.sol => SPBEAMInit.sol} (55%) rename src/deployment/{DSPCInit.t.sol => SPBEAMInit.t.sol} (69%) rename src/deployment/{DSPCInstance.sol => SPBEAMInstance.sol} (94%) diff --git a/README.md b/README.md index f410442..a0a3365 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,10 @@ -# Direct Stability Parameters Change Module (DSPC) +# Stability Parameter Bounded External Access Module (SP-BEAM) A module for the Sky Protocol that enables direct changes to stability parameters (duty, dsr, ssr) through a simple, secure interface with proper constraints and timelocks. ## Overview -The DSPC module provides a streamlined way to modify stability parameters in the Maker Protocol, including: +The SP-BEAM module provides a streamlined way to modify stability parameters in the Maker Protocol, including: - Stability fees (duty) for different collateral types via the Jug contract - Dai Savings Rate (DSR) via the Pot contract - Sky Savings Rate (SSR) via the sUSDS contract @@ -37,7 +37,7 @@ forge test 1. Deploy the contract with the required addresses: ```solidity -DSPC dspc = new DSPC( +SPBEAM beam = new SPBEAM( jugAddress, // For stability fees potAddress, // For DSR susdsAddress, // For SSR @@ -48,30 +48,30 @@ DSPC dspc = new DSPC( 2. Configure the module parameters: ```solidity // Set timelock duration -dspc.file("tau", 1 days); +beam.file("tau", 1 days); // Configure constraints for a collateral type -dspc.file("ETH-A", "max", 1000); // Max rate: 10% -dspc.file("ETH-A", "min", 1); // Min rate: 0.01% -dspc.file("ETH-A", "step", 100); // Max change: 1% +beam.file("ETH-A", "max", 1000); // Max rate: 10% +beam.file("ETH-A", "min", 1); // Min rate: 0.01% +beam.file("ETH-A", "step", 100); // Max change: 1% // Configure constraints for DSR -dspc.file("DSR", "max", 800); // Max rate: 8% -dspc.file("DSR", "min", 1); // Min rate: 0.01% -dspc.file("DSR", "step", 100); // Max change: 1% +beam.file("DSR", "max", 800); // Max rate: 8% +beam.file("DSR", "min", 1); // Min rate: 0.01% +beam.file("DSR", "step", 100); // Max change: 1% ``` 3. Add facilitators who can propose and execute rate changes: ```solidity -dspc.kiss(facilitatorAddress); +beam.kiss(facilitatorAddress); ``` 4. Execute a batch of rate changes: ```solidity -DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); -updates[0] = DSPC.ParamChange("DSR", 75); // Set DSR to 0.75% -updates[1] = DSPC.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% -dspc.set(updates); +SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](2); +updates[0] = SPBEAM.ParamChange("DSR", 75); // Set DSR to 0.75% +updates[1] = SPBEAM.ParamChange("ETH-A", 150); // Set ETH-A rate to 1.5% +beam.set(updates); ``` ## Security @@ -79,7 +79,7 @@ dspc.set(updates); The module implements a robust security model: - Two-level access control (admins and facilitators) - Rate constraints to prevent extreme changes -- Disabling without GSM delay via DSPCMom contract +- Disabling without GSM delay via SPBEAMMom contract - Circuit breaker (halt) functionality - All actions emit events for transparency diff --git a/script/DSPCDeploy.s.sol b/script/SPBEAMDeploy.s.sol similarity index 82% rename from script/DSPCDeploy.s.sol rename to script/SPBEAMDeploy.s.sol index 41ca71f..54974e5 100644 --- a/script/DSPCDeploy.s.sol +++ b/script/SPBEAMDeploy.s.sol @@ -19,21 +19,21 @@ import {Script} from "forge-std/Script.sol"; import {stdJson} from "forge-std/StdJson.sol"; import {MCD, DssInstance} from "dss-test/MCD.sol"; import {ScriptTools} from "dss-test/ScriptTools.sol"; -import {DSPCDeploy, DSPCDeployParams} from "src/deployment/DSPCDeploy.sol"; -import {DSPCInstance} from "src/deployment/DSPCInstance.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "src/deployment/SPBEAMDeploy.sol"; +import {SPBEAMInstance} from "src/deployment/SPBEAMInstance.sol"; -contract DSPCDeployScript is Script { +contract SPBEAMDeployScript is Script { using stdJson for string; using ScriptTools for string; - string constant NAME = "dspc-deploy"; + string constant NAME = "spbeam-deploy"; string config; address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; DssInstance dss = MCD.loadFromChainlog(CHAINLOG); address pauseProxy = dss.chainlog.getAddress("MCD_PAUSE_PROXY"); address conv; - DSPCInstance inst; + SPBEAMInstance inst; function run() external { config = ScriptTools.loadConfig(); @@ -41,8 +41,8 @@ contract DSPCDeployScript is Script { vm.startBroadcast(); - inst = DSPCDeploy.deploy( - DSPCDeployParams({ + inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: msg.sender, owner: pauseProxy, jug: address(dss.jug), @@ -54,7 +54,7 @@ contract DSPCDeployScript is Script { vm.stopBroadcast(); - ScriptTools.exportContract(NAME, "dspc", address(inst.dspc)); + ScriptTools.exportContract(NAME, "spbeam", address(inst.spbeam)); ScriptTools.exportContract(NAME, "mom", address(inst.mom)); ScriptTools.exportContract(NAME, "conv", conv); } diff --git a/script/input/1/README.md b/script/input/1/README.md index cb44384..57ba3ea 100644 --- a/script/input/1/README.md +++ b/script/input/1/README.md @@ -1,24 +1,24 @@ # Network 1 (Ethereum Mainnet) Deployment Configuration -This directory contains the configuration files for deploying DSPC on Ethereum Mainnet. +This directory contains the configuration files for deploying SPBEAM on Ethereum Mainnet. ## Files -### dspc-deploy.json -Configuration for deploying DSPC and DSPCMom contracts: +### spbeam-deploy.json +Configuration for deploying SPBEAM and SPBEAMMom contracts: - `conv`: Address of the converter contract that handles rate conversions between basis points and ray format ## Usage -1. Copy `template-dspc-deploy.json` into a new file (i.e.: `dspc-deploy.json`) +1. Copy `template-spbeam-deploy.json` into a new file (i.e.: `spbeam-deploy.json`) 2. Edit the new file with the correct `conv` address 3. Run the deployment script: ```bash -FOUNDRY_SCRIPT_CONFIG=dspc-deploy forge script script/DSPCDeploy.s.sol:DSPCDeployScript \ +FOUNDRY_SCRIPT_CONFIG=spbeam-deploy forge script script/SPBEAMDeploy.s.sol:SPBEAMDeployScript \ --rpc-url $ETH_RPC_URL \ --broadcast The deployment script will: 1. Load system addresses from chainlog (jug, pot, susds) -2. Deploy DSPC and DSPCMom contracts -4. Export addresses to `/script/output/1/dspc-deploy.json` +2. Deploy SPBEAM and SPBEAMMom contracts +4. Export addresses to `/script/output/1/spbeam-deploy.json` diff --git a/script/input/1/template-dspc-deploy.json b/script/input/1/template-spbeam-deploy.json similarity index 100% rename from script/input/1/template-dspc-deploy.json rename to script/input/1/template-spbeam-deploy.json diff --git a/src/DSPC.sol b/src/SPBEAM.sol similarity index 83% rename from src/DSPC.sol rename to src/SPBEAM.sol index ce61d12..37c2a79 100644 --- a/src/DSPC.sol +++ b/src/SPBEAM.sol @@ -39,18 +39,14 @@ interface ConvLike { function rtob(uint256 ray) external pure returns (uint256 bps); } -/// @title Direct Stability Parameters Change Module (DSPC) +/// @title Stability Parameter Bounded External Access Module (SP-BEAM) /// @notice A module for managing protocol stability parameters with configurable constraints and safety checks /// @dev Provides controlled access to modify stability parameters (ilk stability fees, DSR, SSR) with: /// - Configurable min/max bounds and step sizes for each parameter /// - Cooldown periods between updates /// - Ordered batch updates /// - Emergency circuit breaker -/// @custom:authors [Oddaf] -/// @custom:reviewers [] -/// @custom:auditors [] -/// @custom:bounties [] -contract DSPC { +contract SPBEAM { // --- Structs --- /// @notice Configuration for a rate parameter's constraints /// @dev All values are in basis points (1 bp = 0.01%) @@ -137,21 +133,21 @@ contract DSPC { // --- Modifiers --- modifier auth() { - require(wards[msg.sender] == 1, "DSPC/not-authorized"); + require(wards[msg.sender] == 1, "SPBEAM/not-authorized"); _; } modifier toll() { - require(buds[msg.sender] == 1, "DSPC/not-facilitator"); + require(buds[msg.sender] == 1, "SPBEAM/not-facilitator"); _; } modifier good() { - require(bad == 0, "DSPC/module-halted"); + require(bad == 0, "SPBEAM/module-halted"); _; } - /// @notice Initialize the DSPC module with core system contracts + /// @notice Initialize the SPBEAM module with core system contracts /// @param _jug Jug contract for stability fee management /// @param _pot Pot contract for Dai Savings Rate (DSR) /// @param _susds SUSDS contract for Sky Savings Rate (SSR) @@ -208,16 +204,16 @@ contract DSPC { /// - toc: Last update timestamp (set automatically) function file(bytes32 what, uint256 data) external auth { if (what == "bad") { - require(data == 0 || data == 1, "DSPC/invalid-bad-value"); + require(data == 0 || data == 1, "SPBEAM/invalid-bad-value"); bad = uint8(data); } else if (what == "tau") { - require(data <= type(uint64).max, "DSPC/invalid-tau-value"); + require(data <= type(uint64).max, "SPBEAM/invalid-tau-value"); tau = uint64(data); } else if (what == "toc") { - require(data <= type(uint128).max, "DSPC/invalid-toc-value"); + require(data <= type(uint128).max, "SPBEAM/invalid-toc-value"); toc = uint128(data); } else { - revert("DSPC/file-unrecognized-param"); + revert("SPBEAM/file-unrecognized-param"); } emit File(what, data); @@ -237,19 +233,19 @@ contract DSPC { function file(bytes32 id, bytes32 what, uint256 data) external auth { if (id != "DSR" && id != "SSR") { (uint256 duty,) = jug.ilks(id); - require(duty > 0, "DSPC/ilk-not-initialized"); + require(duty > 0, "SPBEAM/ilk-not-initialized"); } - require(data <= type(uint16).max, "DSPC/invalid-value"); + require(data <= type(uint16).max, "SPBEAM/invalid-value"); if (what == "min") { - require(data <= cfgs[id].max, "DSPC/min-too-high"); + require(data <= cfgs[id].max, "SPBEAM/min-too-high"); cfgs[id].min = uint16(data); } else if (what == "max") { - require(data >= cfgs[id].min, "DSPC/max-too-low"); + require(data >= cfgs[id].min, "SPBEAM/max-too-low"); cfgs[id].max = uint16(data); } else if (what == "step") { cfgs[id].step = uint16(data); } else { - revert("DSPC/file-unrecognized-param"); + revert("SPBEAM/file-unrecognized-param"); } emit File(id, what, data); @@ -264,34 +260,34 @@ contract DSPC { /// 4. Ensures updates are properly ordered to prevent duplicates /// 5. Calls drip() before each update to accrue fees /// @dev Reverts if: - /// - Caller not authorized (DSPC/not-facilitator) - /// - Module halted, bad = 1 (DSPC/module-halted) - /// - Empty updates array (DSPC/empty-batch) - /// - Cooldown period not elapsed (DSPC/too-early) - /// - Updates not ordered alphabetically by id (DSPC/updates-out-of-order) - /// - Rate not configured, step = 0 (DSPC/rate-not-configured) - /// - New rate < min (DSPC/below-min) - /// - New rate > max (DSPC/above-max) - /// - Rate change > step (DSPC/delta-above-step) - /// - Rate conversion failed (DSPC/invalid-rate-conv) + /// - Caller not authorized (SPBEAM/not-facilitator) + /// - Module halted, bad = 1 (SPBEAM/module-halted) + /// - Empty updates array (SPBEAM/empty-batch) + /// - Cooldown period not elapsed (SPBEAM/too-early) + /// - Updates not ordered alphabetically by id (SPBEAM/updates-out-of-order) + /// - Rate not configured, step = 0 (SPBEAM/rate-not-configured) + /// - New rate < min (SPBEAM/below-min) + /// - New rate > max (SPBEAM/above-max) + /// - Rate change > step (SPBEAM/delta-above-step) + /// - Rate conversion failed (SPBEAM/invalid-rate-conv) function set(ParamChange[] calldata updates) external toll good { - require(updates.length > 0, "DSPC/empty-batch"); - require(block.timestamp >= tau + toc, "DSPC/too-early"); + require(updates.length > 0, "SPBEAM/empty-batch"); + require(block.timestamp >= tau + toc, "SPBEAM/too-early"); toc = uint128(block.timestamp); bytes32 last; for (uint256 i = 0; i < updates.length; i++) { bytes32 id = updates[i].id; - require(id > last, "DSPC/updates-out-of-order"); + require(id > last, "SPBEAM/updates-out-of-order"); last = id; uint256 bps = updates[i].bps; Cfg memory cfg = cfgs[id]; - require(cfg.step > 0, "DSPC/rate-not-configured"); - require(bps >= cfg.min, "DSPC/below-min"); - require(bps <= cfg.max, "DSPC/above-max"); + require(cfg.step > 0, "SPBEAM/rate-not-configured"); + require(bps >= cfg.min, "SPBEAM/below-min"); + require(bps <= cfg.max, "SPBEAM/above-max"); // Check rate change is within allowed gap uint256 oldBps; @@ -312,11 +308,11 @@ contract DSPC { // Calculates absolute difference between the old and the new rate uint256 delta = bps > oldBps ? bps - oldBps : oldBps - bps; - require(delta <= cfg.step, "DSPC/delta-above-step"); + require(delta <= cfg.step, "SPBEAM/delta-above-step"); // Execute the update uint256 ray = conv.btor(bps); - require(ray >= RAY, "DSPC/invalid-rate-conv"); + require(ray >= RAY, "SPBEAM/invalid-rate-conv"); if (id == "DSR") { pot.drip(); pot.file("dsr", ray); diff --git a/src/DSPC.t.sol b/src/SPBEAM.t.sol similarity index 55% rename from src/DSPC.t.sol rename to src/SPBEAM.t.sol index 8933425..318b1af 100644 --- a/src/DSPC.t.sol +++ b/src/SPBEAM.t.sol @@ -16,12 +16,12 @@ pragma solidity ^0.8.24; import "dss-test/DssTest.sol"; -import {DSPC} from "./DSPC.sol"; -import {DSPCMom} from "./DSPCMom.sol"; +import {SPBEAM} from "./SPBEAM.sol"; +import {SPBEAMMom} from "./SPBEAMMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./deployment/DSPCInit.sol"; -import {DSPCInstance} from "./deployment/DSPCInstance.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./deployment/SPBEAMDeploy.sol"; +import {SPBEAMInit, SPBEAMConfig, SPBEAMRateConfig} from "./deployment/SPBEAMInit.sol"; +import {SPBEAMInstance} from "./deployment/SPBEAMInstance.sol"; interface ConvLike { function btor(uint256 bps) external pure returns (uint256 ray); @@ -38,8 +38,8 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { - DSPCInit.init(dss, inst, cfg); + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) external { + SPBEAMInit.init(dss, inst, cfg); } } @@ -49,12 +49,12 @@ contract MockBrokenConv is ConvMock { } } -contract DSPCTest is DssTest { +contract SPBEAMTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; DssInstance dss; - DSPC dspc; - DSPCMom mom; + SPBEAM beam; + SPBEAMMom mom; ConvLike conv; SUSDSLike susds; address pause; @@ -83,8 +83,8 @@ contract DSPCTest is DssTest { conv = ConvLike(address(new ConvMock())); - DSPCInstance memory inst = DSPCDeploy.deploy( - DSPCDeployParams({ + SPBEAMInstance memory inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: address(this), owner: address(pauseProxy), jug: address(dss.jug), @@ -93,14 +93,14 @@ contract DSPCTest is DssTest { conv: address(conv) }) ); - dspc = DSPC(inst.dspc); - mom = DSPCMom(inst.mom); + beam = SPBEAM(inst.spbeam); + mom = SPBEAMMom(inst.mom); // Initialize deployment - DSPCRateConfig[] memory ilks = new DSPCRateConfig[](3); // ETH-A, DSR, SSR + SPBEAMRateConfig[] memory ilks = new SPBEAMRateConfig[](3); // ETH-A, DSR, SSR // Configure ETH-A - ilks[0] = DSPCRateConfig({ + ilks[0] = SPBEAMRateConfig({ id: ILK, // Use the constant bytes32 ILK min: uint16(1), max: uint16(3000), @@ -108,7 +108,7 @@ contract DSPCTest is DssTest { }); // Configure DSR - ilks[1] = DSPCRateConfig({ + ilks[1] = SPBEAMRateConfig({ id: DSR, // Use the constant bytes32 DSR min: uint16(1), max: uint16(3000), @@ -116,14 +116,14 @@ contract DSPCTest is DssTest { }); // Configure SSR - ilks[2] = DSPCRateConfig({ + ilks[2] = SPBEAMRateConfig({ id: SSR, // Use the constant bytes32 SSR min: uint16(1), max: uint16(3000), step: uint16(100) }); - DSPCConfig memory cfg = DSPCConfig({ + SPBEAMConfig memory cfg = SPBEAMConfig({ tau: 0, // Start with tau = 0 for tests ilks: ilks, bud: bud @@ -133,88 +133,88 @@ contract DSPCTest is DssTest { } function test_constructor() public view { - assertEq(address(dspc.jug()), address(dss.jug)); - assertEq(address(dspc.pot()), address(dss.pot)); - assertEq(address(dspc.susds()), address(susds)); - assertEq(address(dspc.conv()), address(conv)); + assertEq(address(beam.jug()), address(dss.jug)); + assertEq(address(beam.pot()), address(dss.pot)); + assertEq(address(beam.susds()), address(susds)); + assertEq(address(beam.conv()), address(conv)); // init - assertEq(dspc.wards(address(this)), 0); - assertEq(dspc.wards(address(pauseProxy)), 1); - assertEq(dspc.wards(address(mom)), 1); + assertEq(beam.wards(address(this)), 0); + assertEq(beam.wards(address(pauseProxy)), 1); + assertEq(beam.wards(address(mom)), 1); assertEq(mom.authority(), dss.chainlog.getAddress("MCD_ADM")); - assertEq(dss.jug.wards(address(dspc)), 1); - assertEq(dss.pot.wards(address(dspc)), 1); - assertEq(SUSDSLike(dss.chainlog.getAddress("SUSDS")).wards(address(dspc)), 1); + assertEq(dss.jug.wards(address(beam)), 1); + assertEq(dss.pot.wards(address(beam)), 1); + assertEq(SUSDSLike(dss.chainlog.getAddress("SUSDS")).wards(address(beam)), 1); } function test_auth() public { - checkAuth(address(dspc), "DSPC"); + checkAuth(address(beam), "SPBEAM"); } function test_auth_methods() public { - checkModifier(address(dspc), "DSPC/not-authorized", [DSPC.kiss.selector, DSPC.diss.selector]); + checkModifier(address(beam), "SPBEAM/not-authorized", [SPBEAM.kiss.selector, SPBEAM.diss.selector]); } function test_toll_methods() public { - checkModifier(address(dspc), "DSPC/not-facilitator", [DSPC.set.selector]); + checkModifier(address(beam), "SPBEAM/not-facilitator", [SPBEAM.set.selector]); } function test_good_methods() public { vm.startPrank(address(pauseProxy)); - dspc.file("bad", 1); - dspc.kiss(address(this)); + beam.file("bad", 1); + beam.kiss(address(this)); vm.stopPrank(); - checkModifier(address(dspc), "DSPC/module-halted", [DSPC.set.selector]); + checkModifier(address(beam), "SPBEAM/module-halted", [SPBEAM.set.selector]); } function test_kiss() public { address who = address(0x0ddaf); - assertEq(dspc.buds(who), 0); + assertEq(beam.buds(who), 0); vm.prank(address(pauseProxy)); vm.expectEmit(true, true, true, true); emit Kiss(who); - dspc.kiss(who); - assertEq(dspc.buds(who), 1); + beam.kiss(who); + assertEq(beam.buds(who), 1); } function test_diss() public { address who = address(0x0ddaf); vm.prank(address(pauseProxy)); - dspc.kiss(who); - assertEq(dspc.buds(who), 1); + beam.kiss(who); + assertEq(beam.buds(who), 1); vm.prank(address(pauseProxy)); vm.expectEmit(true, true, true, true); emit Diss(who); - dspc.diss(who); - assertEq(dspc.buds(who), 0); + beam.diss(who); + assertEq(beam.buds(who), 0); } function test_file() public { - checkFileUint(address(dspc), "DSPC", ["bad", "tau", "toc"]); + checkFileUint(address(beam), "SPBEAM", ["bad", "tau", "toc"]); vm.startPrank(address(pauseProxy)); - vm.expectRevert("DSPC/invalid-bad-value"); - dspc.file("bad", 2); + vm.expectRevert("SPBEAM/invalid-bad-value"); + beam.file("bad", 2); - vm.expectRevert("DSPC/invalid-tau-value"); - dspc.file("tau", uint256(type(uint64).max) + 1); + vm.expectRevert("SPBEAM/invalid-tau-value"); + beam.file("tau", uint256(type(uint64).max) + 1); - vm.expectRevert("DSPC/invalid-toc-value"); - dspc.file("toc", uint256(type(uint128).max) + 1); + vm.expectRevert("SPBEAM/invalid-toc-value"); + beam.file("toc", uint256(type(uint128).max) + 1); vm.stopPrank(); - vm.expectRevert("DSPC/not-authorized"); - dspc.file("bad", 1); + vm.expectRevert("SPBEAM/not-authorized"); + beam.file("bad", 1); } function test_file_ilk() public { - (uint16 min, uint16 max, uint16 step) = dspc.cfgs(ILK); + (uint16 min, uint16 max, uint16 step) = beam.cfgs(ILK); assertEq(min, 1); assertEq(max, 3000); assertEq(step, 100); @@ -223,12 +223,12 @@ contract DSPCTest is DssTest { vm.expectEmit(true, true, true, true); emit File(ILK, "min", 100); - dspc.file(ILK, "min", 100); - dspc.file(ILK, "max", 3000); - dspc.file(ILK, "step", 420); + beam.file(ILK, "min", 100); + beam.file(ILK, "max", 3000); + beam.file(ILK, "step", 420); vm.stopPrank(); - (min, max, step) = dspc.cfgs(ILK); + (min, max, step) = beam.cfgs(ILK); assertEq(min, 100); assertEq(max, 3000); assertEq(step, 420); @@ -236,39 +236,39 @@ contract DSPCTest is DssTest { function test_revert_file_ilk_invalid() public { vm.startPrank(address(pauseProxy)); - (uint16 min, uint16 max,) = dspc.cfgs(ILK); + (uint16 min, uint16 max,) = beam.cfgs(ILK); - vm.expectRevert("DSPC/min-too-high"); - dspc.file(ILK, "min", max + 1); + vm.expectRevert("SPBEAM/min-too-high"); + beam.file(ILK, "min", max + 1); - vm.expectRevert("DSPC/max-too-low"); - dspc.file(ILK, "max", min - 1); + vm.expectRevert("SPBEAM/max-too-low"); + beam.file(ILK, "max", min - 1); - vm.expectRevert("DSPC/file-unrecognized-param"); - dspc.file(ILK, "unknown", 100); + vm.expectRevert("SPBEAM/file-unrecognized-param"); + beam.file(ILK, "unknown", 100); - vm.expectRevert("DSPC/invalid-value"); - dspc.file(ILK, "max", uint256(type(uint16).max) + 1); + vm.expectRevert("SPBEAM/invalid-value"); + beam.file(ILK, "max", uint256(type(uint16).max) + 1); dss.jug.drip("MOG-A"); - vm.expectRevert("DSPC/ilk-not-initialized"); - dspc.file("MOG-A", "min", 100); + vm.expectRevert("SPBEAM/ilk-not-initialized"); + beam.file("MOG-A", "min", 100); vm.stopPrank(); - vm.expectRevert("DSPC/not-authorized"); - dspc.file(ILK, "min", 100); + vm.expectRevert("SPBEAM/not-authorized"); + beam.file(ILK, "min", 100); } function test_set_ilk() public { (uint256 duty,) = dss.jug.ilks(ILK); uint256 target = conv.rtob(duty) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, target); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(target)); @@ -277,11 +277,11 @@ contract DSPCTest is DssTest { function test_set_dsr() public { uint256 target = conv.rtob(dss.pot.dsr()) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(DSR, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(DSR, target); vm.prank(bud); - dspc.set(updates); + beam.set(updates); assertEq(dss.pot.dsr(), conv.btor(target)); } @@ -290,14 +290,14 @@ contract DSPCTest is DssTest { vm.prank(bud); uint256 target = conv.rtob(susds.ssr()) - 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(SSR, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(SSR, target); vm.prank(bud); vm.expectEmit(true, true, true, true); emit Set(SSR, target); - dspc.set(updates); + beam.set(updates); assertEq(susds.ssr(), conv.btor(target)); } @@ -308,13 +308,13 @@ contract DSPCTest is DssTest { uint256 dsrTarget = conv.rtob(dss.pot.dsr()) - 50; uint256 ssrTarget = conv.rtob(susds.ssr()) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](3); - updates[0] = DSPC.ParamChange(DSR, dsrTarget); - updates[1] = DSPC.ParamChange(ILK, ilkTarget); - updates[2] = DSPC.ParamChange(SSR, ssrTarget); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](3); + updates[0] = SPBEAM.ParamChange(DSR, dsrTarget); + updates[1] = SPBEAM.ParamChange(ILK, ilkTarget); + updates[2] = SPBEAM.ParamChange(SSR, ssrTarget); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(ilkTarget)); @@ -328,11 +328,11 @@ contract DSPCTest is DssTest { vm.prank(address(pauseProxy)); dss.jug.file(ILK, "duty", conv.btor(3050)); // outside range - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 2999); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 2999); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (uint256 duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(2999)); @@ -342,10 +342,10 @@ contract DSPCTest is DssTest { vm.prank(address(pauseProxy)); dss.jug.file(ILK, "duty", conv.btor(0)); // outside range - updates[0] = DSPC.ParamChange(ILK, 50); + updates[0] = SPBEAM.ParamChange(ILK, 50); vm.prank(bud); - dspc.set(updates); + beam.set(updates); (duty,) = dss.jug.ilks(ILK); assertEq(duty, conv.btor(50)); @@ -354,92 +354,92 @@ contract DSPCTest is DssTest { function test_revert_set_duplicate() public { (uint256 duty,) = dss.jug.ilks(ILK); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](2); - updates[0] = DSPC.ParamChange(ILK, conv.rtob(duty) - 100); - updates[1] = DSPC.ParamChange(ILK, conv.rtob(duty) - 200); // duplicate, pushing rate beyond step + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](2); + updates[0] = SPBEAM.ParamChange(ILK, conv.rtob(duty) - 100); + updates[1] = SPBEAM.ParamChange(ILK, conv.rtob(duty) - 200); // duplicate, pushing rate beyond step vm.prank(bud); - vm.expectRevert("DSPC/updates-out-of-order"); - dspc.set(updates); + vm.expectRevert("SPBEAM/updates-out-of-order"); + beam.set(updates); } function test_revert_set_not_configured_rate() public { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange("PEPE-A", 10000); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange("PEPE-A", 10000); vm.prank(bud); - vm.expectRevert("DSPC/rate-not-configured"); - dspc.set(updates); + vm.expectRevert("SPBEAM/rate-not-configured"); + beam.set(updates); } function test_revert_set_empty() public { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](0); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](0); - vm.expectRevert("DSPC/empty-batch"); + vm.expectRevert("SPBEAM/empty-batch"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_unauthorized() public { - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 100); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 100); - vm.expectRevert("DSPC/not-facilitator"); - dspc.set(updates); + vm.expectRevert("SPBEAM/not-facilitator"); + beam.set(updates); } function test_revert_set_below_min() public { vm.prank(address(pauseProxy)); - dspc.file(ILK, "min", 100); + beam.file(ILK, "min", 100); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 50); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 50); - vm.expectRevert("DSPC/below-min"); + vm.expectRevert("SPBEAM/below-min"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_above_max() public { vm.prank(address(pauseProxy)); - dspc.file(ILK, "max", 100); + beam.file(ILK, "max", 100); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 150); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 150); - vm.expectRevert("DSPC/above-max"); + vm.expectRevert("SPBEAM/above-max"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_delta_above_step() public { vm.prank(address(pauseProxy)); - dspc.file(ILK, "step", 100); + beam.file(ILK, "step", 100); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, 100); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, 100); - vm.expectRevert("DSPC/delta-above-step"); + vm.expectRevert("SPBEAM/delta-above-step"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } function test_revert_set_before_cooldown() public { vm.prank(address(pauseProxy)); - dspc.file("tau", 100); + beam.file("tau", 100); uint256 currentDSR = conv.rtob(dss.pot.dsr()); - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(DSR, currentDSR + 1); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(DSR, currentDSR + 1); vm.prank(bud); - dspc.set(updates); + beam.set(updates); vm.warp(block.timestamp + 99); - updates[0] = DSPC.ParamChange(DSR, currentDSR + 2); + updates[0] = SPBEAM.ParamChange(DSR, currentDSR + 2); vm.prank(bud); - vm.expectRevert("DSPC/too-early"); - dspc.set(updates); + vm.expectRevert("SPBEAM/too-early"); + beam.set(updates); } function test_revert_set_malfunctioning_conv() public { @@ -449,11 +449,11 @@ contract DSPCTest is DssTest { (uint256 duty,) = dss.jug.ilks(ILK); uint256 target = conv.rtob(duty) + 50; - DSPC.ParamChange[] memory updates = new DSPC.ParamChange[](1); - updates[0] = DSPC.ParamChange(ILK, target); + SPBEAM.ParamChange[] memory updates = new SPBEAM.ParamChange[](1); + updates[0] = SPBEAM.ParamChange(ILK, target); - vm.expectRevert("DSPC/invalid-rate-conv"); + vm.expectRevert("SPBEAM/invalid-rate-conv"); vm.prank(bud); - dspc.set(updates); + beam.set(updates); } } diff --git a/src/DSPCMom.sol b/src/SPBEAMMom.sol similarity index 81% rename from src/DSPCMom.sol rename to src/SPBEAMMom.sol index 09e940f..53ca233 100644 --- a/src/DSPCMom.sol +++ b/src/SPBEAMMom.sol @@ -20,20 +20,16 @@ interface AuthorityLike { function canCall(address src, address dst, bytes4 sig) external view returns (bool); } -interface DSPCLike { +interface SPBEAMLike { function file(bytes32 what, uint256 data) external; } -/// @title DSPC Mom - Shutdown DSPC bypassing GSM delay. -/// @notice Governance contract for halting DSPC module operations +/// @title SPBEAM Mom - Shutdown SPBEAM bypassing GSM delay. +/// @notice Governance contract for halting SPBEAM module operations /// @dev Provides: /// - Owner/authority-based access control /// - Emergency halt without delay -/// @custom:authors [Oddaf] -/// @custom:reviewers [] -/// @custom:auditors [] -/// @custom:bounties [] -contract DSPCMom { +contract SPBEAMMom { // --- Auth --- /// @notice Owner with full admin rights address public owner; @@ -45,17 +41,17 @@ contract DSPCMom { event SetOwner(address indexed owner); /// @notice Authority contract changed event SetAuthority(address indexed authority); - /// @notice DSPC module halted - event Halt(address indexed dspc); + /// @notice SPBEAM module halted + event Halt(address indexed spbeam); // --- Modifiers --- modifier onlyOwner() { - require(msg.sender == owner, "DSPCMom/not-owner"); + require(msg.sender == owner, "SPBEAMMom/not-owner"); _; } modifier auth() { - require(isAuthorized(msg.sender, msg.sig), "DSPCMom/not-authorized"); + require(isAuthorized(msg.sender, msg.sig), "SPBEAMMom/not-authorized"); _; } @@ -96,11 +92,11 @@ contract DSPCMom { } // --- Emergency Actions --- - /// @notice Emergency halt of DSPC module - /// @param dspc Target DSPC contract + /// @notice Emergency halt of SPBEAM module + /// @param spbeam Target SPBEAM contract /// @dev Sets bad=1 to immediately halt operations - function halt(address dspc) external auth { - DSPCLike(dspc).file("bad", 1); - emit Halt(dspc); + function halt(address spbeam) external auth { + SPBEAMLike(spbeam).file("bad", 1); + emit Halt(spbeam); } } diff --git a/src/DSPCMom.t.sol b/src/SPBEAMMom.t.sol similarity index 75% rename from src/DSPCMom.t.sol rename to src/SPBEAMMom.t.sol index f84add2..c21f0e7 100644 --- a/src/DSPCMom.t.sol +++ b/src/SPBEAMMom.t.sol @@ -17,12 +17,12 @@ pragma solidity ^0.8.24; import "dss-test/DssTest.sol"; -import {DSPC} from "./DSPC.sol"; -import {DSPCMom} from "./DSPCMom.sol"; +import {SPBEAM} from "./SPBEAM.sol"; +import {SPBEAMMom} from "./SPBEAMMom.sol"; import {ConvMock} from "./mocks/ConvMock.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./deployment/DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./deployment/DSPCInit.sol"; -import {DSPCInstance} from "./deployment/DSPCInstance.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./deployment/SPBEAMDeploy.sol"; +import {SPBEAMInit, SPBEAMConfig, SPBEAMRateConfig} from "./deployment/SPBEAMInit.sol"; +import {SPBEAMInstance} from "./deployment/SPBEAMInstance.sol"; interface ChiefLike { function hat() external view returns (address); @@ -43,23 +43,23 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { - DSPCInit.init(dss, inst, cfg); + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) external { + SPBEAMInit.init(dss, inst, cfg); } } -contract DSPCMomIntegrationTest is DssTest { +contract SPBEAMMomIntegrationTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; // --- Events --- event SetOwner(address indexed owner); event SetAuthority(address indexed authority); - event Halt(address indexed dspc); + event Halt(address indexed spbeam); DssInstance dss; ChiefLike chief; - DSPC dspc; - DSPCMom mom; + SPBEAM spbeam; + SPBEAMMom mom; ConvLike conv; SUSDSLike susds; address pause; @@ -83,8 +83,8 @@ contract DSPCMomIntegrationTest is DssTest { conv = ConvLike(address(new ConvMock())); - DSPCInstance memory inst = DSPCDeploy.deploy( - DSPCDeployParams({ + SPBEAMInstance memory inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: address(this), owner: address(pauseProxy), jug: address(dss.jug), @@ -93,13 +93,13 @@ contract DSPCMomIntegrationTest is DssTest { conv: address(conv) }) ); - dspc = DSPC(inst.dspc); - mom = DSPCMom(inst.mom); + spbeam = SPBEAM(inst.spbeam); + mom = SPBEAMMom(inst.mom); // Initialize deployment - DSPCConfig memory cfg = DSPCConfig({ + SPBEAMConfig memory cfg = SPBEAMConfig({ tau: 0, // Start with tau = 0 for tests - ilks: new DSPCRateConfig[](0), // No ilks for this test + ilks: new SPBEAMRateConfig[](0), // No ilks for this test bud: address(0) // No bud for this test }); vm.prank(pause); @@ -111,15 +111,17 @@ contract DSPCMomIntegrationTest is DssTest { } function test_only_owner_methods() public { - checkModifier(address(mom), "DSPCMom/not-owner", [DSPCMom.setOwner.selector, DSPCMom.setAuthority.selector]); + checkModifier( + address(mom), "SPBEAMMom/not-owner", [SPBEAMMom.setOwner.selector, SPBEAMMom.setAuthority.selector] + ); } function test_auth_methods() public { - checkModifier(address(mom), "DSPCMom/not-authorized", [DSPCMom.halt.selector]); + checkModifier(address(mom), "SPBEAMMom/not-authorized", [SPBEAMMom.halt.selector]); vm.prank(address(pauseProxy)); mom.setAuthority(address(0)); - checkModifier(address(mom), "DSPCMom/not-authorized", [DSPCMom.halt.selector]); + checkModifier(address(mom), "SPBEAMMom/not-authorized", [SPBEAMMom.halt.selector]); } function test_setOwner() public { @@ -141,9 +143,9 @@ contract DSPCMomIntegrationTest is DssTest { function check_halt(address who) internal { vm.prank(who); vm.expectEmit(true, true, true, true); - emit Halt(address(dspc)); - mom.halt(address(dspc)); - assertEq(dspc.bad(), 1); + emit Halt(address(spbeam)); + mom.halt(address(spbeam)); + assertEq(spbeam.bad(), 1); } function test_halt_owner() public { diff --git a/src/deployment/DSPCDeploy.sol b/src/deployment/SPBEAMDeploy.sol similarity index 58% rename from src/deployment/DSPCDeploy.sol rename to src/deployment/SPBEAMDeploy.sol index 42b229f..926e345 100644 --- a/src/deployment/DSPCDeploy.sol +++ b/src/deployment/SPBEAMDeploy.sol @@ -17,18 +17,18 @@ pragma solidity ^0.8.24; import {ScriptTools} from "dss-test/ScriptTools.sol"; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAM} from "../SPBEAM.sol"; +import {SPBEAMMom} from "../SPBEAMMom.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; interface MomLike { function setOwner(address owner) external; } -/// @title DSPC Deployment Parameters -/// @notice Parameters required for deploying the DSPC system -/// @dev Used to configure the initial setup of DSPC and DSPCMom contracts -struct DSPCDeployParams { +/// @title SPBEAM Deployment Parameters +/// @notice Parameters required for deploying the SPBEAM system +/// @dev Used to configure the initial setup of SPBEAM and SPBEAMMom contracts +struct SPBEAMDeployParams { /// @dev Address deploying the contracts address deployer; /// @dev Final owner address after deployment @@ -43,23 +43,23 @@ struct DSPCDeployParams { address conv; } -/// @title DSPC Deployment Library -/// @notice Handles deployment of DSPC system contracts -/// @dev Deploys and configures DSPC and DSPCMom contracts with proper permissions -library DSPCDeploy { - /// @notice Deploy DSPC system contracts - /// @dev Deploys DSPC and DSPCMom, sets up initial permissions +/// @title SPBEAM Deployment Library +/// @notice Handles deployment of SPBEAM system contracts +/// @dev Deploys and configures SPBEAM and SPBEAMMom contracts with proper permissions +library SPBEAMDeploy { + /// @notice Deploy SPBEAM system contracts + /// @dev Deploys SPBEAM and SPBEAMMom, sets up initial permissions /// @param params Configuration parameters for deployment /// @return inst Instance containing addresses of deployed contracts - function deploy(DSPCDeployParams memory params) internal returns (DSPCInstance memory inst) { - // Deploy DSPC with core contract references - inst.dspc = address(new DSPC(params.jug, params.pot, params.susds, params.conv)); + function deploy(SPBEAMDeployParams memory params) internal returns (SPBEAMInstance memory inst) { + // Deploy SPBEAM with core contract references + inst.spbeam = address(new SPBEAM(params.jug, params.pot, params.susds, params.conv)); - // Deploy DSPCMom for governance - inst.mom = address(new DSPCMom()); + // Deploy SPBEAMMom for governance + inst.mom = address(new SPBEAMMom()); // Switch owners - ScriptTools.switchOwner(inst.dspc, params.deployer, params.owner); + ScriptTools.switchOwner(inst.spbeam, params.deployer, params.owner); MomLike(inst.mom).setOwner(params.owner); } } diff --git a/src/deployment/DSPCDeploy.t.sol b/src/deployment/SPBEAMDeploy.t.sol similarity index 52% rename from src/deployment/DSPCDeploy.t.sol rename to src/deployment/SPBEAMDeploy.t.sol index 78fbd23..cf2549e 100644 --- a/src/deployment/DSPCDeploy.t.sol +++ b/src/deployment/SPBEAMDeploy.t.sol @@ -4,10 +4,10 @@ pragma solidity ^0.8.24; import "dss-test/DssTest.sol"; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAM} from "../SPBEAM.sol"; +import {SPBEAMMom} from "../SPBEAMMom.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./SPBEAMDeploy.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; import {ConvMock} from "../mocks/ConvMock.sol"; interface JugLike { @@ -22,7 +22,7 @@ interface SUSDSLike { function wards(address) external view returns (uint256); } -contract DSPCDeployTest is DssTest { +contract SPBEAMDeployTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; address susds; address deployer = address(0xDE9); @@ -30,7 +30,7 @@ contract DSPCDeployTest is DssTest { DssInstance dss; ConvMock conv; - DSPCInstance inst; + SPBEAMInstance inst; function setUp() public { vm.createSelectFork("mainnet"); @@ -41,8 +41,8 @@ contract DSPCDeployTest is DssTest { function test_deploy() public { vm.startPrank(deployer); - inst = DSPCDeploy.deploy( - DSPCDeployParams({ + inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: deployer, owner: owner, jug: address(dss.jug), @@ -53,19 +53,19 @@ contract DSPCDeployTest is DssTest { ); vm.stopPrank(); - // Verify DSPC deployment - assertTrue(inst.dspc != address(0), "DSPC not deployed"); - assertEq(address(DSPC(inst.dspc).jug()), address(dss.jug), "Wrong jug"); - assertEq(address(DSPC(inst.dspc).pot()), address(dss.pot), "Wrong pot"); - assertEq(address(DSPC(inst.dspc).susds()), susds, "Wrong susds"); - assertEq(address(DSPC(inst.dspc).conv()), address(conv), "Wrong conv"); + // Verify SPBEAM deployment + assertTrue(inst.spbeam != address(0), "SPBEAM not deployed"); + assertEq(address(SPBEAM(inst.spbeam).jug()), address(dss.jug), "Wrong jug"); + assertEq(address(SPBEAM(inst.spbeam).pot()), address(dss.pot), "Wrong pot"); + assertEq(address(SPBEAM(inst.spbeam).susds()), susds, "Wrong susds"); + assertEq(address(SPBEAM(inst.spbeam).conv()), address(conv), "Wrong conv"); - // Verify DSPCMom deployment - assertTrue(inst.mom != address(0), "DSPCMom not deployed"); - assertEq(DSPCMom(inst.mom).owner(), owner, "Wrong mom owner"); + // Verify SPBEAMMom deployment + assertTrue(inst.mom != address(0), "SPBEAMMom not deployed"); + assertEq(SPBEAMMom(inst.mom).owner(), owner, "Wrong mom owner"); // Verify ownership transfer - assertEq(DSPC(inst.dspc).wards(owner), 1, "Owner not authorized in DSPC"); - assertEq(DSPC(inst.dspc).wards(deployer), 0, "Deployer still authorized in DSPC"); + assertEq(SPBEAM(inst.spbeam).wards(owner), 1, "Owner not authorized in SPBEAM"); + assertEq(SPBEAM(inst.spbeam).wards(deployer), 0, "Deployer still authorized in SPBEAM"); } } diff --git a/src/deployment/DSPCInit.sol b/src/deployment/SPBEAMInit.sol similarity index 55% rename from src/deployment/DSPCInit.sol rename to src/deployment/SPBEAMInit.sol index 1086d7c..046f6c9 100644 --- a/src/deployment/DSPCInit.sol +++ b/src/deployment/SPBEAMInit.sol @@ -17,25 +17,25 @@ pragma solidity ^0.8.24; import {DssInstance} from "dss-test/MCD.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; interface RelyLike { function rely(address usr) external; } -interface DSPCLike is RelyLike { +interface SPBEAMLike is RelyLike { function file(bytes32 what, uint256 data) external; function file(bytes32 ilk, bytes32 what, uint256 data) external; function kiss(address usr) external; } -interface DSPCMomLike { +interface SPBEAMMomLike { function setAuthority(address usr) external; } -/// @title Configuration parameters for a rate in DSPC +/// @title Configuration parameters for a rate in SPBEAM /// @dev Used to configure rate parameters for a specific rate -struct DSPCRateConfig { +struct SPBEAMRateConfig { /// @dev Rate identifier bytes32 id; /// @dev Minimum rate in basis points @@ -47,53 +47,53 @@ struct DSPCRateConfig { } /// @dev Step size in basis points [0-65535] -/// @title Global configuration parameters for DSPC +/// @title Global configuration parameters for SPBEAM /// @dev Used to configure global parameters and collateral-specific settings -struct DSPCConfig { +struct SPBEAMConfig { /// @dev Time delay between rate updates uint256 tau; /// @dev Collateral-specific settings - DSPCRateConfig[] ilks; + SPBEAMRateConfig[] ilks; /// @dev Bud to be authed within setup address bud; } /// @dev Array of collateral configurations /// @title Dynamic Stability Parameter Controller Initialization -/// @notice Handles initialization and configuration of the DSPC contract -/// @dev Sets up permissions and configures parameters for the DSPC system -library DSPCInit { - /// @notice Initializes a DSPC instance with the specified configuration - /// @dev Sets up permissions between DSPC and core contracts, and configures parameters +/// @notice Handles initialization and configuration of the SPBEAM contract +/// @dev Sets up permissions and configures parameters for the SPBEAM system +library SPBEAMInit { + /// @notice Initializes a SPBEAM instance with the specified configuration + /// @dev Sets up permissions between SPBEAM and core contracts, and configures parameters /// @param dss The DSS (MakerDAO) instance containing core contract references - /// @param inst The DSPC instance containing contract addresses - /// @param cfg The configuration parameters for DSPC - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) internal { + /// @param inst The SPBEAM instance containing contract addresses + /// @param cfg The configuration parameters for SPBEAM + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) internal { // Set up permissions - // Authorize DSPCMom in DSPC - RelyLike(inst.dspc).rely(inst.mom); + // Authorize SPBEAMMom in SPBEAM + RelyLike(inst.spbeam).rely(inst.mom); - // Set DSPCMom authority to MCD_ADM - DSPCMomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); + // Set SPBEAMMom authority to MCD_ADM + SPBEAMMomLike(inst.mom).setAuthority(dss.chainlog.getAddress("MCD_ADM")); - // Authorize DSPC in core contracts - dss.jug.rely(inst.dspc); - dss.pot.rely(inst.dspc); - RelyLike(dss.chainlog.getAddress("SUSDS")).rely(inst.dspc); + // Authorize SPBEAM in core contracts + dss.jug.rely(inst.spbeam); + dss.pot.rely(inst.spbeam); + RelyLike(dss.chainlog.getAddress("SUSDS")).rely(inst.spbeam); // Configure global parameters - DSPCLike(inst.dspc).file("tau", cfg.tau); + SPBEAMLike(inst.spbeam).file("tau", cfg.tau); // Configure ilks for (uint256 i = 0; i < cfg.ilks.length; i++) { - DSPCRateConfig memory ilk = cfg.ilks[i]; - DSPCLike(inst.dspc).file(ilk.id, "max", uint256(ilk.max)); - DSPCLike(inst.dspc).file(ilk.id, "min", uint256(ilk.min)); - DSPCLike(inst.dspc).file(ilk.id, "step", uint256(ilk.step)); + SPBEAMRateConfig memory ilk = cfg.ilks[i]; + SPBEAMLike(inst.spbeam).file(ilk.id, "max", uint256(ilk.max)); + SPBEAMLike(inst.spbeam).file(ilk.id, "min", uint256(ilk.min)); + SPBEAMLike(inst.spbeam).file(ilk.id, "step", uint256(ilk.step)); } // Authorize bud - DSPCLike(inst.dspc).kiss(cfg.bud); + SPBEAMLike(inst.spbeam).kiss(cfg.bud); } } diff --git a/src/deployment/DSPCInit.t.sol b/src/deployment/SPBEAMInit.t.sol similarity index 69% rename from src/deployment/DSPCInit.t.sol rename to src/deployment/SPBEAMInit.t.sol index abc82f7..0725a9c 100644 --- a/src/deployment/DSPCInit.t.sol +++ b/src/deployment/SPBEAMInit.t.sol @@ -18,11 +18,11 @@ pragma solidity ^0.8.24; import {DssTest, MCD} from "dss-test/DssTest.sol"; import {DssInstance} from "dss-test/MCD.sol"; -import {DSPC} from "../DSPC.sol"; -import {DSPCMom} from "../DSPCMom.sol"; -import {DSPCDeploy, DSPCDeployParams} from "./DSPCDeploy.sol"; -import {DSPCInit, DSPCConfig, DSPCRateConfig} from "./DSPCInit.sol"; -import {DSPCInstance} from "./DSPCInstance.sol"; +import {SPBEAM} from "../SPBEAM.sol"; +import {SPBEAMMom} from "../SPBEAMMom.sol"; +import {SPBEAMDeploy, SPBEAMDeployParams} from "./SPBEAMDeploy.sol"; +import {SPBEAMInit, SPBEAMConfig, SPBEAMRateConfig} from "./SPBEAMInit.sol"; +import {SPBEAMInstance} from "./SPBEAMInstance.sol"; import {ConvMock} from "../mocks/ConvMock.sol"; interface RelyLike { @@ -53,12 +53,12 @@ interface ProxyLike { } contract InitCaller { - function init(DssInstance memory dss, DSPCInstance memory inst, DSPCConfig memory cfg) external { - DSPCInit.init(dss, inst, cfg); + function init(DssInstance memory dss, SPBEAMInstance memory inst, SPBEAMConfig memory cfg) external { + SPBEAMInit.init(dss, inst, cfg); } } -contract DSPCInitTest is DssTest { +contract SPBEAMInitTest is DssTest { address constant CHAINLOG = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F; address deployer = address(0xDE9); address owner = address(0x123); @@ -69,7 +69,7 @@ contract DSPCInitTest is DssTest { DssInstance dss; ConvMock conv; - DSPCInstance inst; + SPBEAMInstance inst; function setUp() public { vm.createSelectFork("mainnet"); @@ -81,8 +81,8 @@ contract DSPCInitTest is DssTest { caller = new InitCaller(); vm.startPrank(deployer); - inst = DSPCDeploy.deploy( - DSPCDeployParams({ + inst = SPBEAMDeploy.deploy( + SPBEAMDeployParams({ deployer: deployer, owner: address(pauseProxy), jug: address(dss.jug), @@ -96,10 +96,10 @@ contract DSPCInitTest is DssTest { function test_init() public { // Create test configuration - DSPCRateConfig[] memory ilks = new DSPCRateConfig[](2); + SPBEAMRateConfig[] memory ilks = new SPBEAMRateConfig[](2); // Configure ETH-A - ilks[0] = DSPCRateConfig({ + ilks[0] = SPBEAMRateConfig({ id: "ETH-A", min: uint16(0), // 0% max: uint16(1000), // 10% @@ -107,41 +107,41 @@ contract DSPCInitTest is DssTest { }); // Configure WBTC-A - ilks[1] = DSPCRateConfig({ + ilks[1] = SPBEAMRateConfig({ id: "WBTC-A", min: uint16(0), // 0% max: uint16(1500), // 15% step: uint16(100) // 1% }); - DSPCConfig memory cfg = DSPCConfig({tau: 1 days, ilks: ilks, bud: address(0x0ddaf)}); + SPBEAMConfig memory cfg = SPBEAMConfig({tau: 1 days, ilks: ilks, bud: address(0x0ddaf)}); vm.prank(pause); pauseProxy.exec(address(caller), abi.encodeCall(caller.init, (dss, inst, cfg))); - // Verify DSPCMom authority - assertEq(DSPCMom(inst.mom).authority(), dss.chainlog.getAddress("MCD_ADM"), "Wrong authority"); + // Verify SPBEAMMom authority + assertEq(SPBEAMMom(inst.mom).authority(), dss.chainlog.getAddress("MCD_ADM"), "Wrong authority"); - // Verify DSPC permissions - assertEq(DSPC(inst.dspc).wards(inst.mom), 1, "Mom not authorized in DSPC"); + // Verify SPBEAM permissions + assertEq(SPBEAM(inst.spbeam).wards(inst.mom), 1, "Mom not authorized in SPBEAM"); // Verify core contract permissions - assertEq(JugLike(address(dss.jug)).wards(inst.dspc), 1, "DSPC not authorized in Jug"); - assertEq(PotLike(address(dss.pot)).wards(inst.dspc), 1, "DSPC not authorized in Pot"); - assertEq(SUSDSLike(susds).wards(inst.dspc), 1, "DSPC not authorized in SUSDS"); + assertEq(JugLike(address(dss.jug)).wards(inst.spbeam), 1, "SPBEAM not authorized in Jug"); + assertEq(PotLike(address(dss.pot)).wards(inst.spbeam), 1, "SPBEAM not authorized in Pot"); + assertEq(SUSDSLike(susds).wards(inst.spbeam), 1, "SPBEAM not authorized in SUSDS"); // Verify configuration - assertEq(DSPC(inst.dspc).tau(), cfg.tau, "Wrong tau"); - assertEq(DSPC(inst.dspc).buds(cfg.bud), 1, "Wrong bud"); + assertEq(SPBEAM(inst.spbeam).tau(), cfg.tau, "Wrong tau"); + assertEq(SPBEAM(inst.spbeam).buds(cfg.bud), 1, "Wrong bud"); // Verify ETH-A config - (uint16 min, uint16 max, uint16 step) = DSPC(inst.dspc).cfgs("ETH-A"); + (uint16 min, uint16 max, uint16 step) = SPBEAM(inst.spbeam).cfgs("ETH-A"); assertEq(min, ilks[0].min, "Wrong ETH-A min"); assertEq(max, ilks[0].max, "Wrong ETH-A max"); assertEq(step, ilks[0].step, "Wrong ETH-A step"); // Verify WBTC-A config - (min, max, step) = DSPC(inst.dspc).cfgs("WBTC-A"); + (min, max, step) = SPBEAM(inst.spbeam).cfgs("WBTC-A"); assertEq(min, ilks[1].min, "Wrong WBTC-A min"); assertEq(max, ilks[1].max, "Wrong WBTC-A max"); assertEq(step, ilks[1].step, "Wrong WBTC-A step"); diff --git a/src/deployment/DSPCInstance.sol b/src/deployment/SPBEAMInstance.sol similarity index 94% rename from src/deployment/DSPCInstance.sol rename to src/deployment/SPBEAMInstance.sol index ba575d5..e513755 100644 --- a/src/deployment/DSPCInstance.sol +++ b/src/deployment/SPBEAMInstance.sol @@ -16,7 +16,7 @@ pragma solidity ^0.8.24; -struct DSPCInstance { - address dspc; +struct SPBEAMInstance { + address spbeam; address mom; } From fcb2478c07063df2cdcf8e672ee6a05b6f0a3780 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Fri, 28 Mar 2025 10:05:03 -0300 Subject: [PATCH 89/96] refactor: rename DSPC to SPBEAM --- .github/workflows/certora.yml | 4 ++-- Makefile | 2 +- certora/{DSPC.conf => SPBEAM.conf} | 18 +++++++++--------- certora/{DSPC.spec => SPBEAM.spec} | 14 +++++++------- 4 files changed, 19 insertions(+), 19 deletions(-) rename certora/{DSPC.conf => SPBEAM.conf} (81%) rename certora/{DSPC.spec => SPBEAM.spec} (98%) diff --git a/.github/workflows/certora.yml b/.github/workflows/certora.yml index 65504d9..a0055e8 100644 --- a/.github/workflows/certora.yml +++ b/.github/workflows/certora.yml @@ -39,8 +39,8 @@ jobs: - name: Install Certora run: pip3 install certora-cli-beta - - name: Certora verify DSPC - run: make certora-dspc + - name: Certora verify SPBEAM + run: make certora-spbeam env: CERTORAKEY: ${{ secrets.CERTORAKEY }} diff --git a/Makefile b/Makefile index 6a44cd8..c6603f6 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,3 @@ PATH := ~/.solc-select/artifacts/solc-0.8.24:~/.solc-select/artifacts/solc-0.8.21:~/.solc-select/artifacts/solc-0.5.12:~/.solc-select/artifacts:$(PATH) -certora-dspc:; PATH=${PATH} certoraRun certora/DSPC.conf$(if $(rule), --rule $(rule),) +certora-spbeam:; PATH=${PATH} certoraRun certora/SPBEAM.conf$(if $(rule), --rule $(rule),) diff --git a/certora/DSPC.conf b/certora/SPBEAM.conf similarity index 81% rename from certora/DSPC.conf rename to certora/SPBEAM.conf index 210a83f..2286322 100644 --- a/certora/DSPC.conf +++ b/certora/SPBEAM.conf @@ -1,6 +1,6 @@ { "files": [ - "src/DSPC.sol", + "src/SPBEAM.sol", "certora/mocks/Conv.sol", "certora/mocks/Jug.sol", "certora/mocks/Pot.sol", @@ -15,14 +15,14 @@ "SUsds:vat=Vat", "UsdsJoin:usds=Usds", "UsdsJoin:vat=Vat", - "DSPC:jug=Jug", - "DSPC:pot=Pot", - "DSPC:susds=SUsds", - "DSPC:conv=Conv" + "SPBEAM:jug=Jug", + "SPBEAM:pot=Pot", + "SPBEAM:susds=SUsds", + "SPBEAM:conv=Conv" ], "solc_map": { "Conv": "solc-0.8.24", - "DSPC": "solc-0.8.24", + "SPBEAM": "solc-0.8.24", "Jug": "solc-0.5.12", "Pot": "solc-0.5.12", "SUsds": "solc-0.8.21", @@ -32,7 +32,7 @@ }, "solc_optimize_map": { "Conv": "200", - "DSPC": "200", + "SPBEAM": "200", "Jug": "0", "Pot": "0", "SUsds": "200", @@ -40,9 +40,9 @@ "UsdsJoin": "200", "Vat": "0" }, - "verify": "DSPC:certora/DSPC.spec", + "verify": "SPBEAM:certora/SPBEAM.spec", "parametric_contracts": [ - "DSPC" + "SPBEAM" ], "build_cache": true, "loop_iter": "3", diff --git a/certora/DSPC.spec b/certora/SPBEAM.spec similarity index 98% rename from certora/DSPC.spec rename to certora/SPBEAM.spec index 4ae46f7..d857fe2 100644 --- a/certora/DSPC.spec +++ b/certora/SPBEAM.spec @@ -1,6 +1,6 @@ -// DSPC.spec +// SPBEAM.spec -using DSPC as dspc; +using SPBEAM as spbeam; using Conv as conv; using Jug as jug; using Pot as pot; @@ -83,7 +83,7 @@ rule storage_affected(method f) { assert stepAfter != stepBefore => f.selector == sig:file(bytes32, bytes32, uint256).selector, "step[x] changed in an unexpected function"; assert badAfter != badBefore => f.selector == sig:file(bytes32, uint256).selector, "bad changed in an unexpected function"; assert tauAfter != tauBefore => f.selector == sig:file(bytes32, uint256).selector, "tau changed in an unexpected function"; - assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(DSPC.ParamChange[] calldata).selector, "toc changed in an unexpected function"; + assert tocAfter != tocBefore => f.selector == sig:file(bytes32, uint256).selector || f.selector == sig:set(SPBEAM.ParamChange[] calldata).selector, "toc changed in an unexpected function"; } // Verify that the correct storage changes for non-reverting rely @@ -309,7 +309,7 @@ ghost mapping(uint256 => uint256) bps_to_ray { } // Verify correct storage changes for non-reverting set -rule set(DSPC.ParamChange[] updates) { +rule set(SPBEAM.ParamChange[] updates) { env e; bytes32 ilk; require ilk != DSR() && ilk != SSR(); @@ -392,7 +392,7 @@ ghost mapping(bytes32 => bool) set_item_reverted { init_state axiom forall bytes32 i. set_item_reverted[i] == false; } -rule set_revert(DSPC.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss) { +rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss) { env e; bytes32 ilk; @@ -507,7 +507,7 @@ function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { } -rule set_current_higher_than_max(DSPC.ParamChange[] updates) { +rule set_current_higher_than_max(SPBEAM.ParamChange[] updates) { env e; require updates.length == 1; @@ -544,7 +544,7 @@ rule set_current_higher_than_max(DSPC.ParamChange[] updates) { assert id == ilk => dutyAfter == bps_to_ray[bps] && bps >= max - step && bps <= max, "ilk duty not within bounds"; } -rule set_current_lower_than_min(DSPC.ParamChange[] updates) { +rule set_current_lower_than_min(SPBEAM.ParamChange[] updates) { env e; require updates.length == 1; From 4507d0f18652008c70749a1bfe3b09b9ff53706a Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Fri, 28 Mar 2025 10:04:52 -0300 Subject: [PATCH 90/96] fix: remove `MockerBrokenConv` override The override was failing due to `ConvMock.btor` not being virtual. When I added the `virtual` modifier, for some reason `forge build --sizes` fail because the MockConv contract becomes too big. --- src/SPBEAM.t.sol | 8 ++++++-- src/mocks/ConvMock.sol | 12 ++++++------ 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/SPBEAM.t.sol b/src/SPBEAM.t.sol index 318b1af..49794e5 100644 --- a/src/SPBEAM.t.sol +++ b/src/SPBEAM.t.sol @@ -43,8 +43,12 @@ contract InitCaller { } } -contract MockBrokenConv is ConvMock { - function btor(uint256 /* bps */ ) public pure override returns (uint256) { +contract MockBrokenConv { + function rtob(uint256 /* ray */ ) public pure returns (uint256) { + return 0; + } + + function btor(uint256 /* bps */ ) public pure returns (uint256) { return 0; } } diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index ca19a39..74f1542 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -20014,16 +20014,16 @@ contract ConvMock { rayToBps[1000000021979553151239153027] = 10000; } - function btor(uint256 bps) public view virtual returns (uint256 ray) { - require(bps <= MAX_BPS_IN, "DSPC/bps-too-high"); + function btor(uint256 bps) public view returns (uint256 ray) { + require(bps <= MAX_BPS_IN, "Conv/bps-too-high"); ray = bpsToRay[bps]; - require(ray != 0, "DSPC/out-of-bounds"); + require(ray != 0, "Conv/out-of-bounds"); } - function rtob(uint256 ray) public view virtual returns (uint256 bps) { - require(ray >= RAY, "DSPC/ray-too-low"); + function rtob(uint256 ray) public view returns (uint256 bps) { + require(ray >= RAY, "Conv/ray-too-low"); bps = rayToBps[ray]; // Check if it's in range - require(bpsToRay[bps] == ray, "DSPC/out-of-bounds"); + require(bpsToRay[bps] == ray, "Conv/out-of-bounds"); } } From e6ff425fc5db60098dd7c37603190e40f55e6de0 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Fri, 28 Mar 2025 10:27:12 -0300 Subject: [PATCH 91/96] refactor: revert mock implementation change --- src/mocks/ConvMock.sol | 20069 +-------------------------------------- 1 file changed, 55 insertions(+), 20014 deletions(-) diff --git a/src/mocks/ConvMock.sol b/src/mocks/ConvMock.sol index 74f1542..1605b22 100644 --- a/src/mocks/ConvMock.sol +++ b/src/mocks/ConvMock.sol @@ -1,20029 +1,70 @@ +// SPDX-FileCopyrightText: © 2025 Dai Foundation +// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity ^0.8.24; contract ConvMock { uint256 public constant MAX_BPS_IN = 50_00; - uint256 internal constant BPS = 100_00; uint256 internal constant RAY = 10 ** 27; + uint256 internal constant BPS = 100_00; - mapping(uint256 => uint256) internal bpsToRay; - mapping(uint256 => uint256) internal rayToBps; + bytes internal RATES; constructor() { - bpsToRay[0] = 1000000000000000000000000000; - bpsToRay[1] = 1000000000003170820659990704; - bpsToRay[2] = 1000000000006341324285480111; - bpsToRay[3] = 1000000000009511510939859271; - bpsToRay[4] = 1000000000012681380686500226; - bpsToRay[5] = 1000000000015850933588756013; - bpsToRay[6] = 1000000000019020169709960675; - bpsToRay[7] = 1000000000022189089113429267; - bpsToRay[8] = 1000000000025357691862457863; - bpsToRay[9] = 1000000000028525978020323563; - bpsToRay[10] = 1000000000031693947650284507; - bpsToRay[11] = 1000000000034861600815579870; - bpsToRay[12] = 1000000000038028937579429884; - bpsToRay[13] = 1000000000041195958005035834; - bpsToRay[14] = 1000000000044362662155580072; - bpsToRay[15] = 1000000000047529050094226024; - bpsToRay[16] = 1000000000050695121884118193; - bpsToRay[17] = 1000000000053860877588382173; - bpsToRay[18] = 1000000000057026317270124651; - bpsToRay[19] = 1000000000060191440992433418; - bpsToRay[20] = 1000000000063356248818377377; - bpsToRay[21] = 1000000000066520740811006546; - bpsToRay[22] = 1000000000069684917033352071; - bpsToRay[23] = 1000000000072848777548426231; - bpsToRay[24] = 1000000000076012322419222442; - bpsToRay[25] = 1000000000079175551708715274; - bpsToRay[26] = 1000000000082338465479860449; - bpsToRay[27] = 1000000000085501063795594852; - bpsToRay[28] = 1000000000088663346718836541; - bpsToRay[29] = 1000000000091825314312484750; - bpsToRay[30] = 1000000000094986966639419899; - bpsToRay[31] = 1000000000098148303762503603; - bpsToRay[32] = 1000000000101309325744578677; - bpsToRay[33] = 1000000000104470032648469142; - bpsToRay[34] = 1000000000107630424536980239; - bpsToRay[35] = 1000000000110790501472898427; - bpsToRay[36] = 1000000000113950263518991400; - bpsToRay[37] = 1000000000117109710738008089; - bpsToRay[38] = 1000000000120268843192678669; - bpsToRay[39] = 1000000000123427660945714570; - bpsToRay[40] = 1000000000126586164059808482; - bpsToRay[41] = 1000000000129744352597634363; - bpsToRay[42] = 1000000000132902226621847447; - bpsToRay[43] = 1000000000136059786195084249; - bpsToRay[44] = 1000000000139217031379962578; - bpsToRay[45] = 1000000000142373962239081538; - bpsToRay[46] = 1000000000145530578835021538; - bpsToRay[47] = 1000000000148686881230344303; - bpsToRay[48] = 1000000000151842869487592874; - bpsToRay[49] = 1000000000154998543669291624; - bpsToRay[50] = 1000000000158153903837946257; - bpsToRay[51] = 1000000000161308950056043822; - bpsToRay[52] = 1000000000164463682386052718; - bpsToRay[53] = 1000000000167618100890422700; - bpsToRay[54] = 1000000000170772205631584889; - bpsToRay[55] = 1000000000173925996671951777; - bpsToRay[56] = 1000000000177079474073917237; - bpsToRay[57] = 1000000000180232637899856526; - bpsToRay[58] = 1000000000183385488212126301; - bpsToRay[59] = 1000000000186538025073064615; - bpsToRay[60] = 1000000000189690248544990934; - bpsToRay[61] = 1000000000192842158690206138; - bpsToRay[62] = 1000000000195993755570992533; - bpsToRay[63] = 1000000000199145039249613856; - bpsToRay[64] = 1000000000202296009788315281; - bpsToRay[65] = 1000000000205446667249323430; - bpsToRay[66] = 1000000000208597011694846379; - bpsToRay[67] = 1000000000211747043187073663; - bpsToRay[68] = 1000000000214896761788176285; - bpsToRay[69] = 1000000000218046167560306726; - bpsToRay[70] = 1000000000221195260565598948; - bpsToRay[71] = 1000000000224344040866168404; - bpsToRay[72] = 1000000000227492508524112044; - bpsToRay[73] = 1000000000230640663601508324; - bpsToRay[74] = 1000000000233788506160417212; - bpsToRay[75] = 1000000000236936036262880196; - bpsToRay[76] = 1000000000240083253970920290; - bpsToRay[77] = 1000000000243230159346542043; - bpsToRay[78] = 1000000000246376752451731545; - bpsToRay[79] = 1000000000249523033348456436; - bpsToRay[80] = 1000000000252669002098665913; - bpsToRay[81] = 1000000000255814658764290734; - bpsToRay[82] = 1000000000258960003407243230; - bpsToRay[83] = 1000000000262105036089417311; - bpsToRay[84] = 1000000000265249756872688471; - bpsToRay[85] = 1000000000268394165818913798; - bpsToRay[86] = 1000000000271538262989931978; - bpsToRay[87] = 1000000000274682048447563305; - bpsToRay[88] = 1000000000277825522253609693; - bpsToRay[89] = 1000000000280968684469854670; - bpsToRay[90] = 1000000000284111535158063399; - bpsToRay[91] = 1000000000287254074379982678; - bpsToRay[92] = 1000000000290396302197340948; - bpsToRay[93] = 1000000000293538218671848302; - bpsToRay[94] = 1000000000296679823865196492; - bpsToRay[95] = 1000000000299821117839058936; - bpsToRay[96] = 1000000000302962100655090723; - bpsToRay[97] = 1000000000306102772374928623; - bpsToRay[98] = 1000000000309243133060191095; - bpsToRay[99] = 1000000000312383182772478292; - bpsToRay[100] = 1000000000315522921573372069; - bpsToRay[101] = 1000000000318662349524435988; - bpsToRay[102] = 1000000000321801466687215330; - bpsToRay[103] = 1000000000324940273123237102; - bpsToRay[104] = 1000000000328078768894010037; - bpsToRay[105] = 1000000000331216954061024608; - bpsToRay[106] = 1000000000334354828685753035; - bpsToRay[107] = 1000000000337492392829649290; - bpsToRay[108] = 1000000000340629646554149104; - bpsToRay[109] = 1000000000343766589920669975; - bpsToRay[110] = 1000000000346903222990611176; - bpsToRay[111] = 1000000000350039545825353762; - bpsToRay[112] = 1000000000353175558486260576; - bpsToRay[113] = 1000000000356311261034676258; - bpsToRay[114] = 1000000000359446653531927249; - bpsToRay[115] = 1000000000362581736039321802; - bpsToRay[116] = 1000000000365716508618149987; - bpsToRay[117] = 1000000000368850971329683699; - bpsToRay[118] = 1000000000371985124235176666; - bpsToRay[119] = 1000000000375118967395864451; - bpsToRay[120] = 1000000000378252500872964469; - bpsToRay[121] = 1000000000381385724727675984; - bpsToRay[122] = 1000000000384518639021180123; - bpsToRay[123] = 1000000000387651243814639879; - bpsToRay[124] = 1000000000390783539169200122; - bpsToRay[125] = 1000000000393915525145987602; - bpsToRay[126] = 1000000000397047201806110961; - bpsToRay[127] = 1000000000400178569210660733; - bpsToRay[128] = 1000000000403309627420709360; - bpsToRay[129] = 1000000000406440376497311193; - bpsToRay[130] = 1000000000409570816501502501; - bpsToRay[131] = 1000000000412700947494301478; - bpsToRay[132] = 1000000000415830769536708248; - bpsToRay[133] = 1000000000418960282689704878; - bpsToRay[134] = 1000000000422089487014255380; - bpsToRay[135] = 1000000000425218382571305718; - bpsToRay[136] = 1000000000428346969421783819; - bpsToRay[137] = 1000000000431475247626599574; - bpsToRay[138] = 1000000000434603217246644855; - bpsToRay[139] = 1000000000437730878342793510; - bpsToRay[140] = 1000000000440858230975901380; - bpsToRay[141] = 1000000000443985275206806300; - bpsToRay[142] = 1000000000447112011096328109; - bpsToRay[143] = 1000000000450238438705268656; - bpsToRay[144] = 1000000000453364558094411809; - bpsToRay[145] = 1000000000456490369324523458; - bpsToRay[146] = 1000000000459615872456351529; - bpsToRay[147] = 1000000000462741067550625980; - bpsToRay[148] = 1000000000465865954668058822; - bpsToRay[149] = 1000000000468990533869344115; - bpsToRay[150] = 1000000000472114805215157978; - bpsToRay[151] = 1000000000475238768766158601; - bpsToRay[152] = 1000000000478362424582986244; - bpsToRay[153] = 1000000000481485772726263252; - bpsToRay[154] = 1000000000484608813256594054; - bpsToRay[155] = 1000000000487731546234565179; - bpsToRay[156] = 1000000000490853971720745253; - bpsToRay[157] = 1000000000493976089775685018; - bpsToRay[158] = 1000000000497097900459917326; - bpsToRay[159] = 1000000000500219403833957155; - bpsToRay[160] = 1000000000503340599958301616; - bpsToRay[161] = 1000000000506461488893429953; - bpsToRay[162] = 1000000000509582070699803560; - bpsToRay[163] = 1000000000512702345437865976; - bpsToRay[164] = 1000000000515822313168042905; - bpsToRay[165] = 1000000000518941973950742212; - bpsToRay[166] = 1000000000522061327846353937; - bpsToRay[167] = 1000000000525180374915250300; - bpsToRay[168] = 1000000000528299115217785706; - bpsToRay[169] = 1000000000531417548814296756; - bpsToRay[170] = 1000000000534535675765102249; - bpsToRay[171] = 1000000000537653496130503193; - bpsToRay[172] = 1000000000540771009970782812; - bpsToRay[173] = 1000000000543888217346206550; - bpsToRay[174] = 1000000000547005118317022080; - bpsToRay[175] = 1000000000550121712943459312; - bpsToRay[176] = 1000000000553238001285730395; - bpsToRay[177] = 1000000000556353983404029733; - bpsToRay[178] = 1000000000559469659358533982; - bpsToRay[179] = 1000000000562585029209402065; - bpsToRay[180] = 1000000000565700093016775172; - bpsToRay[181] = 1000000000568814850840776775; - bpsToRay[182] = 1000000000571929302741512626; - bpsToRay[183] = 1000000000575043448779070771; - bpsToRay[184] = 1000000000578157289013521555; - bpsToRay[185] = 1000000000581270823504917627; - bpsToRay[186] = 1000000000584384052313293946; - bpsToRay[187] = 1000000000587496975498667797; - bpsToRay[188] = 1000000000590609593121038783; - bpsToRay[189] = 1000000000593721905240388847; - bpsToRay[190] = 1000000000596833911916682269; - bpsToRay[191] = 1000000000599945613209865674; - bpsToRay[192] = 1000000000603057009179868046; - bpsToRay[193] = 1000000000606168099886600725; - bpsToRay[194] = 1000000000609278885389957423; - bpsToRay[195] = 1000000000612389365749814222; - bpsToRay[196] = 1000000000615499541026029589; - bpsToRay[197] = 1000000000618609411278444380; - bpsToRay[198] = 1000000000621718976566881844; - bpsToRay[199] = 1000000000624828236951147633; - bpsToRay[200] = 1000000000627937192491029810; - bpsToRay[201] = 1000000000631045843246298852; - bpsToRay[202] = 1000000000634154189276707659; - bpsToRay[203] = 1000000000637262230641991564; - bpsToRay[204] = 1000000000640369967401868332; - bpsToRay[205] = 1000000000643477399616038176; - bpsToRay[206] = 1000000000646584527344183758; - bpsToRay[207] = 1000000000649691350645970197; - bpsToRay[208] = 1000000000652797869581045076; - bpsToRay[209] = 1000000000655904084209038450; - bpsToRay[210] = 1000000000659009994589562852; - bpsToRay[211] = 1000000000662115600782213301; - bpsToRay[212] = 1000000000665220902846567304; - bpsToRay[213] = 1000000000668325900842184872; - bpsToRay[214] = 1000000000671430594828608518; - bpsToRay[215] = 1000000000674534984865363268; - bpsToRay[216] = 1000000000677639071011956667; - bpsToRay[217] = 1000000000680742853327878787; - bpsToRay[218] = 1000000000683846331872602231; - bpsToRay[219] = 1000000000686949506705582145; - bpsToRay[220] = 1000000000690052377886256219; - bpsToRay[221] = 1000000000693154945474044696; - bpsToRay[222] = 1000000000696257209528350379; - bpsToRay[223] = 1000000000699359170108558644; - bpsToRay[224] = 1000000000702460827274037431; - bpsToRay[225] = 1000000000705562181084137268; - bpsToRay[226] = 1000000000708663231598191269; - bpsToRay[227] = 1000000000711763978875515140; - bpsToRay[228] = 1000000000714864422975407191; - bpsToRay[229] = 1000000000717964563957148338; - bpsToRay[230] = 1000000000721064401880002111; - bpsToRay[231] = 1000000000724163936803214665; - bpsToRay[232] = 1000000000727263168786014781; - bpsToRay[233] = 1000000000730362097887613873; - bpsToRay[234] = 1000000000733460724167206002; - bpsToRay[235] = 1000000000736559047683967873; - bpsToRay[236] = 1000000000739657068497058849; - bpsToRay[237] = 1000000000742754786665620954; - bpsToRay[238] = 1000000000745852202248778881; - bpsToRay[239] = 1000000000748949315305640001; - bpsToRay[240] = 1000000000752046125895294364; - bpsToRay[241] = 1000000000755142634076814712; - bpsToRay[242] = 1000000000758238839909256483; - bpsToRay[243] = 1000000000761334743451657815; - bpsToRay[244] = 1000000000764430344763039558; - bpsToRay[245] = 1000000000767525643902405280; - bpsToRay[246] = 1000000000770620640928741268; - bpsToRay[247] = 1000000000773715335901016542; - bpsToRay[248] = 1000000000776809728878182856; - bpsToRay[249] = 1000000000779903819919174710; - bpsToRay[250] = 1000000000782997609082909351; - bpsToRay[251] = 1000000000786091096428286786; - bpsToRay[252] = 1000000000789184282014189785; - bpsToRay[253] = 1000000000792277165899483884; - bpsToRay[254] = 1000000000795369748143017402; - bpsToRay[255] = 1000000000798462028803621438; - bpsToRay[256] = 1000000000801554007940109881; - bpsToRay[257] = 1000000000804645685611279421; - bpsToRay[258] = 1000000000807737061875909546; - bpsToRay[259] = 1000000000810828136792762559; - bpsToRay[260] = 1000000000813918910420583580; - bpsToRay[261] = 1000000000817009382818100549; - bpsToRay[262] = 1000000000820099554044024241; - bpsToRay[263] = 1000000000823189424157048266; - bpsToRay[264] = 1000000000826278993215849080; - bpsToRay[265] = 1000000000829368261279085986; - bpsToRay[266] = 1000000000832457228405401147; - bpsToRay[267] = 1000000000835545894653419590; - bpsToRay[268] = 1000000000838634260081749213; - bpsToRay[269] = 1000000000841722324748980791; - bpsToRay[270] = 1000000000844810088713687981; - bpsToRay[271] = 1000000000847897552034427333; - bpsToRay[272] = 1000000000850984714769738294; - bpsToRay[273] = 1000000000854071576978143215; - bpsToRay[274] = 1000000000857158138718147357; - bpsToRay[275] = 1000000000860244400048238898; - bpsToRay[276] = 1000000000863330361026888943; - bpsToRay[277] = 1000000000866416021712551525; - bpsToRay[278] = 1000000000869501382163663613; - bpsToRay[279] = 1000000000872586442438645123; - bpsToRay[280] = 1000000000875671202595898921; - bpsToRay[281] = 1000000000878755662693810828; - bpsToRay[282] = 1000000000881839822790749630; - bpsToRay[283] = 1000000000884923682945067084; - bpsToRay[284] = 1000000000888007243215097924; - bpsToRay[285] = 1000000000891090503659159869; - bpsToRay[286] = 1000000000894173464335553624; - bpsToRay[287] = 1000000000897256125302562895; - bpsToRay[288] = 1000000000900338486618454391; - bpsToRay[289] = 1000000000903420548341477830; - bpsToRay[290] = 1000000000906502310529865946; - bpsToRay[291] = 1000000000909583773241834499; - bpsToRay[292] = 1000000000912664936535582274; - bpsToRay[293] = 1000000000915745800469291101; - bpsToRay[294] = 1000000000918826365101125845; - bpsToRay[295] = 1000000000921906630489234425; - bpsToRay[296] = 1000000000924986596691747814; - bpsToRay[297] = 1000000000928066263766780050; - bpsToRay[298] = 1000000000931145631772428239; - bpsToRay[299] = 1000000000934224700766772564; - bpsToRay[300] = 1000000000937303470807876289; - bpsToRay[301] = 1000000000940381941953785771; - bpsToRay[302] = 1000000000943460114262530457; - bpsToRay[303] = 1000000000946537987792122901; - bpsToRay[304] = 1000000000949615562600558765; - bpsToRay[305] = 1000000000952692838745816824; - bpsToRay[306] = 1000000000955769816285858978; - bpsToRay[307] = 1000000000958846495278630254; - bpsToRay[308] = 1000000000961922875782058814; - bpsToRay[309] = 1000000000964998957854055963; - bpsToRay[310] = 1000000000968074741552516152; - bpsToRay[311] = 1000000000971150226935316988; - bpsToRay[312] = 1000000000974225414060319240; - bpsToRay[313] = 1000000000977300302985366843; - bpsToRay[314] = 1000000000980374893768286908; - bpsToRay[315] = 1000000000983449186466889726; - bpsToRay[316] = 1000000000986523181138968776; - bpsToRay[317] = 1000000000989596877842300728; - bpsToRay[318] = 1000000000992670276634645456; - bpsToRay[319] = 1000000000995743377573746041; - bpsToRay[320] = 1000000000998816180717328774; - bpsToRay[321] = 1000000001001888686123103168; - bpsToRay[322] = 1000000001004960893848761962; - bpsToRay[323] = 1000000001008032803951981130; - bpsToRay[324] = 1000000001011104416490419883; - bpsToRay[325] = 1000000001014175731521720677; - bpsToRay[326] = 1000000001017246749103509223; - bpsToRay[327] = 1000000001020317469293394491; - bpsToRay[328] = 1000000001023387892148968714; - bpsToRay[329] = 1000000001026458017727807397; - bpsToRay[330] = 1000000001029527846087469327; - bpsToRay[331] = 1000000001032597377285496570; - bpsToRay[332] = 1000000001035666611379414489; - bpsToRay[333] = 1000000001038735548426731741; - bpsToRay[334] = 1000000001041804188484940289; - bpsToRay[335] = 1000000001044872531611515405; - bpsToRay[336] = 1000000001047940577863915679; - bpsToRay[337] = 1000000001051008327299583027; - bpsToRay[338] = 1000000001054075779975942691; - bpsToRay[339] = 1000000001057142935950403252; - bpsToRay[340] = 1000000001060209795280356633; - bpsToRay[341] = 1000000001063276358023178106; - bpsToRay[342] = 1000000001066342624236226300; - bpsToRay[343] = 1000000001069408593976843206; - bpsToRay[344] = 1000000001072474267302354182; - bpsToRay[345] = 1000000001075539644270067964; - bpsToRay[346] = 1000000001078604724937276668; - bpsToRay[347] = 1000000001081669509361255798; - bpsToRay[348] = 1000000001084733997599264251; - bpsToRay[349] = 1000000001087798189708544327; - bpsToRay[350] = 1000000001090862085746321732; - bpsToRay[351] = 1000000001093925685769805588; - bpsToRay[352] = 1000000001096988989836188433; - bpsToRay[353] = 1000000001100051998002646234; - bpsToRay[354] = 1000000001103114710326338391; - bpsToRay[355] = 1000000001106177126864407743; - bpsToRay[356] = 1000000001109239247673980573; - bpsToRay[357] = 1000000001112301072812166619; - bpsToRay[358] = 1000000001115362602336059074; - bpsToRay[359] = 1000000001118423836302734600; - bpsToRay[360] = 1000000001121484774769253326; - bpsToRay[361] = 1000000001124545417792658861; - bpsToRay[362] = 1000000001127605765429978297; - bpsToRay[363] = 1000000001130665817738222219; - bpsToRay[364] = 1000000001133725574774384703; - bpsToRay[365] = 1000000001136785036595443334; - bpsToRay[366] = 1000000001139844203258359204; - bpsToRay[367] = 1000000001142903074820076919; - bpsToRay[368] = 1000000001145961651337524612; - bpsToRay[369] = 1000000001149019932867613939; - bpsToRay[370] = 1000000001152077919467240095; - bpsToRay[371] = 1000000001155135611193281814; - bpsToRay[372] = 1000000001158193008102601379; - bpsToRay[373] = 1000000001161250110252044625; - bpsToRay[374] = 1000000001164306917698440949; - bpsToRay[375] = 1000000001167363430498603315; - bpsToRay[376] = 1000000001170419648709328258; - bpsToRay[377] = 1000000001173475572387395894; - bpsToRay[378] = 1000000001176531201589569924; - bpsToRay[379] = 1000000001179586536372597640; - bpsToRay[380] = 1000000001182641576793209935; - bpsToRay[381] = 1000000001185696322908121302; - bpsToRay[382] = 1000000001188750774774029849; - bpsToRay[383] = 1000000001191804932447617301; - bpsToRay[384] = 1000000001194858795985549004; - bpsToRay[385] = 1000000001197912365444473936; - bpsToRay[386] = 1000000001200965640881024708; - bpsToRay[387] = 1000000001204018622351817579; - bpsToRay[388] = 1000000001207071309913452452; - bpsToRay[389] = 1000000001210123703622512886; - bpsToRay[390] = 1000000001213175803535566102; - bpsToRay[391] = 1000000001216227609709162989; - bpsToRay[392] = 1000000001219279122199838110; - bpsToRay[393] = 1000000001222330341064109706; - bpsToRay[394] = 1000000001225381266358479708; - bpsToRay[395] = 1000000001228431898139433735; - bpsToRay[396] = 1000000001231482236463441109; - bpsToRay[397] = 1000000001234532281386954858; - bpsToRay[398] = 1000000001237582032966411716; - bpsToRay[399] = 1000000001240631491258232141; - bpsToRay[400] = 1000000001243680656318820312; - bpsToRay[401] = 1000000001246729528204564139; - bpsToRay[402] = 1000000001249778106971835268; - bpsToRay[403] = 1000000001252826392676989088; - bpsToRay[404] = 1000000001255874385376364739; - bpsToRay[405] = 1000000001258922085126285113; - bpsToRay[406] = 1000000001261969491983056866; - bpsToRay[407] = 1000000001265016606002970422; - bpsToRay[408] = 1000000001268063427242299977; - bpsToRay[409] = 1000000001271109955757303509; - bpsToRay[410] = 1000000001274156191604222783; - bpsToRay[411] = 1000000001277202134839283355; - bpsToRay[412] = 1000000001280247785518694582; - bpsToRay[413] = 1000000001283293143698649624; - bpsToRay[414] = 1000000001286338209435325454; - bpsToRay[415] = 1000000001289382982784882863; - bpsToRay[416] = 1000000001292427463803466464; - bpsToRay[417] = 1000000001295471652547204702; - bpsToRay[418] = 1000000001298515549072209857; - bpsToRay[419] = 1000000001301559153434578054; - bpsToRay[420] = 1000000001304602465690389263; - bpsToRay[421] = 1000000001307645485895707309; - bpsToRay[422] = 1000000001310688214106579884; - bpsToRay[423] = 1000000001313730650379038540; - bpsToRay[424] = 1000000001316772794769098706; - bpsToRay[425] = 1000000001319814647332759691; - bpsToRay[426] = 1000000001322856208126004689; - bpsToRay[427] = 1000000001325897477204800787; - bpsToRay[428] = 1000000001328938454625098968; - bpsToRay[429] = 1000000001331979140442834120; - bpsToRay[430] = 1000000001335019534713925045; - bpsToRay[431] = 1000000001338059637494274457; - bpsToRay[432] = 1000000001341099448839768997; - bpsToRay[433] = 1000000001344138968806279230; - bpsToRay[434] = 1000000001347178197449659663; - bpsToRay[435] = 1000000001350217134825748738; - bpsToRay[436] = 1000000001353255780990368849; - bpsToRay[437] = 1000000001356294135999326341; - bpsToRay[438] = 1000000001359332199908411521; - bpsToRay[439] = 1000000001362369972773398659; - bpsToRay[440] = 1000000001365407454650046000; - bpsToRay[441] = 1000000001368444645594095767; - bpsToRay[442] = 1000000001371481545661274166; - bpsToRay[443] = 1000000001374518154907291394; - bpsToRay[444] = 1000000001377554473387841645; - bpsToRay[445] = 1000000001380590501158603116; - bpsToRay[446] = 1000000001383626238275238013; - bpsToRay[447] = 1000000001386661684793392556; - bpsToRay[448] = 1000000001389696840768696987; - bpsToRay[449] = 1000000001392731706256765577; - bpsToRay[450] = 1000000001395766281313196627; - bpsToRay[451] = 1000000001398800565993572478; - bpsToRay[452] = 1000000001401834560353459521; - bpsToRay[453] = 1000000001404868264448408194; - bpsToRay[454] = 1000000001407901678333952993; - bpsToRay[455] = 1000000001410934802065612482; - bpsToRay[456] = 1000000001413967635698889291; - bpsToRay[457] = 1000000001417000179289270128; - bpsToRay[458] = 1000000001420032432892225782; - bpsToRay[459] = 1000000001423064396563211131; - bpsToRay[460] = 1000000001426096070357665149; - bpsToRay[461] = 1000000001429127454331010908; - bpsToRay[462] = 1000000001432158548538655588; - bpsToRay[463] = 1000000001435189353035990479; - bpsToRay[464] = 1000000001438219867878390995; - bpsToRay[465] = 1000000001441250093121216670; - bpsToRay[466] = 1000000001444280028819811170; - bpsToRay[467] = 1000000001447309675029502300; - bpsToRay[468] = 1000000001450339031805602006; - bpsToRay[469] = 1000000001453368099203406382; - bpsToRay[470] = 1000000001456396877278195681; - bpsToRay[471] = 1000000001459425366085234312; - bpsToRay[472] = 1000000001462453565679770855; - bpsToRay[473] = 1000000001465481476117038063; - bpsToRay[474] = 1000000001468509097452252866; - bpsToRay[475] = 1000000001471536429740616381; - bpsToRay[476] = 1000000001474563473037313917; - bpsToRay[477] = 1000000001477590227397514978; - bpsToRay[478] = 1000000001480616692876373275; - bpsToRay[479] = 1000000001483642869529026724; - bpsToRay[480] = 1000000001486668757410597461; - bpsToRay[481] = 1000000001489694356576191838; - bpsToRay[482] = 1000000001492719667080900443; - bpsToRay[483] = 1000000001495744688979798088; - bpsToRay[484] = 1000000001498769422327943831; - bpsToRay[485] = 1000000001501793867180380974; - bpsToRay[486] = 1000000001504818023592137069; - bpsToRay[487] = 1000000001507841891618223927; - bpsToRay[488] = 1000000001510865471313637625; - bpsToRay[489] = 1000000001513888762733358503; - bpsToRay[490] = 1000000001516911765932351183; - bpsToRay[491] = 1000000001519934480965564567; - bpsToRay[492] = 1000000001522956907887931841; - bpsToRay[493] = 1000000001525979046754370490; - bpsToRay[494] = 1000000001529000897619782295; - bpsToRay[495] = 1000000001532022460539053343; - bpsToRay[496] = 1000000001535043735567054034; - bpsToRay[497] = 1000000001538064722758639085; - bpsToRay[498] = 1000000001541085422168647535; - bpsToRay[499] = 1000000001544105833851902754; - bpsToRay[500] = 1000000001547125957863212448; - bpsToRay[501] = 1000000001550145794257368662; - bpsToRay[502] = 1000000001553165343089147790; - bpsToRay[503] = 1000000001556184604413310579; - bpsToRay[504] = 1000000001559203578284602136; - bpsToRay[505] = 1000000001562222264757751932; - bpsToRay[506] = 1000000001565240663887473810; - bpsToRay[507] = 1000000001568258775728465991; - bpsToRay[508] = 1000000001571276600335411077; - bpsToRay[509] = 1000000001574294137762976059; - bpsToRay[510] = 1000000001577311388065812327; - bpsToRay[511] = 1000000001580328351298555666; - bpsToRay[512] = 1000000001583345027515826272; - bpsToRay[513] = 1000000001586361416772228753; - bpsToRay[514] = 1000000001589377519122352136; - bpsToRay[515] = 1000000001592393334620769870; - bpsToRay[516] = 1000000001595408863322039839; - bpsToRay[517] = 1000000001598424105280704358; - bpsToRay[518] = 1000000001601439060551290189; - bpsToRay[519] = 1000000001604453729188308543; - bpsToRay[520] = 1000000001607468111246255079; - bpsToRay[521] = 1000000001610482206779609923; - bpsToRay[522] = 1000000001613496015842837664; - bpsToRay[523] = 1000000001616509538490387361; - bpsToRay[524] = 1000000001619522774776692555; - bpsToRay[525] = 1000000001622535724756171269; - bpsToRay[526] = 1000000001625548388483226015; - bpsToRay[527] = 1000000001628560766012243800; - bpsToRay[528] = 1000000001631572857397596136; - bpsToRay[529] = 1000000001634584662693639037; - bpsToRay[530] = 1000000001637596181954713035; - bpsToRay[531] = 1000000001640607415235143177; - bpsToRay[532] = 1000000001643618362589239040; - bpsToRay[533] = 1000000001646629024071294727; - bpsToRay[534] = 1000000001649639399735588881; - bpsToRay[535] = 1000000001652649489636384685; - bpsToRay[536] = 1000000001655659293827929873; - bpsToRay[537] = 1000000001658668812364456731; - bpsToRay[538] = 1000000001661678045300182106; - bpsToRay[539] = 1000000001664686992689307414; - bpsToRay[540] = 1000000001667695654586018638; - bpsToRay[541] = 1000000001670704031044486342; - bpsToRay[542] = 1000000001673712122118865672; - bpsToRay[543] = 1000000001676719927863296364; - bpsToRay[544] = 1000000001679727448331902751; - bpsToRay[545] = 1000000001682734683578793766; - bpsToRay[546] = 1000000001685741633658062946; - bpsToRay[547] = 1000000001688748298623788446; - bpsToRay[548] = 1000000001691754678530033036; - bpsToRay[549] = 1000000001694760773430844112; - bpsToRay[550] = 1000000001697766583380253701; - bpsToRay[551] = 1000000001700772108432278464; - bpsToRay[552] = 1000000001703777348640919706; - bpsToRay[553] = 1000000001706782304060163379; - bpsToRay[554] = 1000000001709786974743980088; - bpsToRay[555] = 1000000001712791360746325100; - bpsToRay[556] = 1000000001715795462121138343; - bpsToRay[557] = 1000000001718799278922344419; - bpsToRay[558] = 1000000001721802811203852608; - bpsToRay[559] = 1000000001724806059019556870; - bpsToRay[560] = 1000000001727809022423335855; - bpsToRay[561] = 1000000001730811701469052906; - bpsToRay[562] = 1000000001733814096210556068; - bpsToRay[563] = 1000000001736816206701678090; - bpsToRay[564] = 1000000001739818032996236434; - bpsToRay[565] = 1000000001742819575148033278; - bpsToRay[566] = 1000000001745820833210855527; - bpsToRay[567] = 1000000001748821807238474808; - bpsToRay[568] = 1000000001751822497284647491; - bpsToRay[569] = 1000000001754822903403114680; - bpsToRay[570] = 1000000001757823025647602229; - bpsToRay[571] = 1000000001760822864071820743; - bpsToRay[572] = 1000000001763822418729465585; - bpsToRay[573] = 1000000001766821689674216882; - bpsToRay[574] = 1000000001769820676959739530; - bpsToRay[575] = 1000000001772819380639683201; - bpsToRay[576] = 1000000001775817800767682345; - bpsToRay[577] = 1000000001778815937397356203; - bpsToRay[578] = 1000000001781813790582308807; - bpsToRay[579] = 1000000001784811360376128985; - bpsToRay[580] = 1000000001787808646832390371; - bpsToRay[581] = 1000000001790805650004651410; - bpsToRay[582] = 1000000001793802369946455358; - bpsToRay[583] = 1000000001796798806711330296; - bpsToRay[584] = 1000000001799794960352789133; - bpsToRay[585] = 1000000001802790830924329607; - bpsToRay[586] = 1000000001805786418479434295; - bpsToRay[587] = 1000000001808781723071570620; - bpsToRay[588] = 1000000001811776744754190855; - bpsToRay[589] = 1000000001814771483580732126; - bpsToRay[590] = 1000000001817765939604616422; - bpsToRay[591] = 1000000001820760112879250599; - bpsToRay[592] = 1000000001823754003458026386; - bpsToRay[593] = 1000000001826747611394320388; - bpsToRay[594] = 1000000001829740936741494099; - bpsToRay[595] = 1000000001832733979552893898; - bpsToRay[596] = 1000000001835726739881851062; - bpsToRay[597] = 1000000001838719217781681769; - bpsToRay[598] = 1000000001841711413305687103; - bpsToRay[599] = 1000000001844703326507153063; - bpsToRay[600] = 1000000001847694957439350562; - bpsToRay[601] = 1000000001850686306155535442; - bpsToRay[602] = 1000000001853677372708948472; - bpsToRay[603] = 1000000001856668157152815356; - bpsToRay[604] = 1000000001859658659540346741; - bpsToRay[605] = 1000000001862648879924738219; - bpsToRay[606] = 1000000001865638818359170337; - bpsToRay[607] = 1000000001868628474896808595; - bpsToRay[608] = 1000000001871617849590803463; - bpsToRay[609] = 1000000001874606942494290377; - bpsToRay[610] = 1000000001877595753660389747; - bpsToRay[611] = 1000000001880584283142206967; - bpsToRay[612] = 1000000001883572530992832417; - bpsToRay[613] = 1000000001886560497265341466; - bpsToRay[614] = 1000000001889548182012794484; - bpsToRay[615] = 1000000001892535585288236844; - bpsToRay[616] = 1000000001895522707144698926; - bpsToRay[617] = 1000000001898509547635196126; - bpsToRay[618] = 1000000001901496106812728862; - bpsToRay[619] = 1000000001904482384730282575; - bpsToRay[620] = 1000000001907468381440827740; - bpsToRay[621] = 1000000001910454096997319869; - bpsToRay[622] = 1000000001913439531452699514; - bpsToRay[623] = 1000000001916424684859892282; - bpsToRay[624] = 1000000001919409557271808825; - bpsToRay[625] = 1000000001922394148741344865; - bpsToRay[626] = 1000000001925378459321381181; - bpsToRay[627] = 1000000001928362489064783628; - bpsToRay[628] = 1000000001931346238024403135; - bpsToRay[629] = 1000000001934329706253075715; - bpsToRay[630] = 1000000001937312893803622469; - bpsToRay[631] = 1000000001940295800728849590; - bpsToRay[632] = 1000000001943278427081548373; - bpsToRay[633] = 1000000001946260772914495212; - bpsToRay[634] = 1000000001949242838280451618; - bpsToRay[635] = 1000000001952224623232164215; - bpsToRay[636] = 1000000001955206127822364746; - bpsToRay[637] = 1000000001958187352103770087; - bpsToRay[638] = 1000000001961168296129082241; - bpsToRay[639] = 1000000001964148959950988353; - bpsToRay[640] = 1000000001967129343622160710; - bpsToRay[641] = 1000000001970109447195256751; - bpsToRay[642] = 1000000001973089270722919065; - bpsToRay[643] = 1000000001976068814257775407; - bpsToRay[644] = 1000000001979048077852438695; - bpsToRay[645] = 1000000001982027061559507021; - bpsToRay[646] = 1000000001985005765431563653; - bpsToRay[647] = 1000000001987984189521177042; - bpsToRay[648] = 1000000001990962333880900827; - bpsToRay[649] = 1000000001993940198563273844; - bpsToRay[650] = 1000000001996917783620820123; - bpsToRay[651] = 1000000001999895089106048906; - bpsToRay[652] = 1000000002002872115071454639; - bpsToRay[653] = 1000000002005848861569516991; - bpsToRay[654] = 1000000002008825328652700847; - bpsToRay[655] = 1000000002011801516373456324; - bpsToRay[656] = 1000000002014777424784218768; - bpsToRay[657] = 1000000002017753053937408767; - bpsToRay[658] = 1000000002020728403885432150; - bpsToRay[659] = 1000000002023703474680679997; - bpsToRay[660] = 1000000002026678266375528644; - bpsToRay[661] = 1000000002029652779022339687; - bpsToRay[662] = 1000000002032627012673459986; - bpsToRay[663] = 1000000002035600967381221676; - bpsToRay[664] = 1000000002038574643197942168; - bpsToRay[665] = 1000000002041548040175924154; - bpsToRay[666] = 1000000002044521158367455616; - bpsToRay[667] = 1000000002047493997824809831; - bpsToRay[668] = 1000000002050466558600245373; - bpsToRay[669] = 1000000002053438840746006121; - bpsToRay[670] = 1000000002056410844314321266; - bpsToRay[671] = 1000000002059382569357405313; - bpsToRay[672] = 1000000002062354015927458089; - bpsToRay[673] = 1000000002065325184076664749; - bpsToRay[674] = 1000000002068296073857195778; - bpsToRay[675] = 1000000002071266685321207000; - bpsToRay[676] = 1000000002074237018520839584; - bpsToRay[677] = 1000000002077207073508220045; - bpsToRay[678] = 1000000002080176850335460252; - bpsToRay[679] = 1000000002083146349054657437; - bpsToRay[680] = 1000000002086115569717894196; - bpsToRay[681] = 1000000002089084512377238493; - bpsToRay[682] = 1000000002092053177084743673; - bpsToRay[683] = 1000000002095021563892448458; - bpsToRay[684] = 1000000002097989672852376961; - bpsToRay[685] = 1000000002100957504016538685; - bpsToRay[686] = 1000000002103925057436928532; - bpsToRay[687] = 1000000002106892333165526808; - bpsToRay[688] = 1000000002109859331254299227; - bpsToRay[689] = 1000000002112826051755196920; - bpsToRay[690] = 1000000002115792494720156434; - bpsToRay[691] = 1000000002118758660201099744; - bpsToRay[692] = 1000000002121724548249934257; - bpsToRay[693] = 1000000002124690158918552812; - bpsToRay[694] = 1000000002127655492258833695; - bpsToRay[695] = 1000000002130620548322640635; - bpsToRay[696] = 1000000002133585327161822816; - bpsToRay[697] = 1000000002136549828828214880; - bpsToRay[698] = 1000000002139514053373636932; - bpsToRay[699] = 1000000002142478000849894543; - bpsToRay[700] = 1000000002145441671308778766; - bpsToRay[701] = 1000000002148405064802066124; - bpsToRay[702] = 1000000002151368181381518635; - bpsToRay[703] = 1000000002154331021098883800; - bpsToRay[704] = 1000000002157293584005894622; - bpsToRay[705] = 1000000002160255870154269599; - bpsToRay[706] = 1000000002163217879595712742; - bpsToRay[707] = 1000000002166179612381913573; - bpsToRay[708] = 1000000002169141068564547128; - bpsToRay[709] = 1000000002172102248195273969; - bpsToRay[710] = 1000000002175063151325740189; - bpsToRay[711] = 1000000002178023778007577411; - bpsToRay[712] = 1000000002180984128292402799; - bpsToRay[713] = 1000000002183944202231819060; - bpsToRay[714] = 1000000002186903999877414455; - bpsToRay[715] = 1000000002189863521280762799; - bpsToRay[716] = 1000000002192822766493423465; - bpsToRay[717] = 1000000002195781735566941395; - bpsToRay[718] = 1000000002198740428552847104; - bpsToRay[719] = 1000000002201698845502656681; - bpsToRay[720] = 1000000002204656986467871801; - bpsToRay[721] = 1000000002207614851499979723; - bpsToRay[722] = 1000000002210572440650453302; - bpsToRay[723] = 1000000002213529753970750991; - bpsToRay[724] = 1000000002216486791512316847; - bpsToRay[725] = 1000000002219443553326580536; - bpsToRay[726] = 1000000002222400039464957340; - bpsToRay[727] = 1000000002225356249978848158; - bpsToRay[728] = 1000000002228312184919639519; - bpsToRay[729] = 1000000002231267844338703579; - bpsToRay[730] = 1000000002234223228287398132; - bpsToRay[731] = 1000000002237178336817066613; - bpsToRay[732] = 1000000002240133169979038105; - bpsToRay[733] = 1000000002243087727824627342; - bpsToRay[734] = 1000000002246042010405134715; - bpsToRay[735] = 1000000002248996017771846281; - bpsToRay[736] = 1000000002251949749976033760; - bpsToRay[737] = 1000000002254903207068954551; - bpsToRay[738] = 1000000002257856389101851730; - bpsToRay[739] = 1000000002260809296125954056; - bpsToRay[740] = 1000000002263761928192475979; - bpsToRay[741] = 1000000002266714285352617643; - bpsToRay[742] = 1000000002269666367657564895; - bpsToRay[743] = 1000000002272618175158489283; - bpsToRay[744] = 1000000002275569707906548069; - bpsToRay[745] = 1000000002278520965952884232; - bpsToRay[746] = 1000000002281471949348626470; - bpsToRay[747] = 1000000002284422658144889210; - bpsToRay[748] = 1000000002287373092392772609; - bpsToRay[749] = 1000000002290323252143362564; - bpsToRay[750] = 1000000002293273137447730714; - bpsToRay[751] = 1000000002296222748356934445; - bpsToRay[752] = 1000000002299172084922016896; - bpsToRay[753] = 1000000002302121147194006968; - bpsToRay[754] = 1000000002305069935223919323; - bpsToRay[755] = 1000000002308018449062754392; - bpsToRay[756] = 1000000002310966688761498383; - bpsToRay[757] = 1000000002313914654371123283; - bpsToRay[758] = 1000000002316862345942586863; - bpsToRay[759] = 1000000002319809763526832687; - bpsToRay[760] = 1000000002322756907174790110; - bpsToRay[761] = 1000000002325703776937374294; - bpsToRay[762] = 1000000002328650372865486203; - bpsToRay[763] = 1000000002331596695010012613; - bpsToRay[764] = 1000000002334542743421826121; - bpsToRay[765] = 1000000002337488518151785139; - bpsToRay[766] = 1000000002340434019250733913; - bpsToRay[767] = 1000000002343379246769502519; - bpsToRay[768] = 1000000002346324200758906870; - bpsToRay[769] = 1000000002349268881269748722; - bpsToRay[770] = 1000000002352213288352815683; - bpsToRay[771] = 1000000002355157422058881210; - bpsToRay[772] = 1000000002358101282438704622; - bpsToRay[773] = 1000000002361044869543031102; - bpsToRay[774] = 1000000002363988183422591701; - bpsToRay[775] = 1000000002366931224128103346; - bpsToRay[776] = 1000000002369873991710268842; - bpsToRay[777] = 1000000002372816486219776883; - bpsToRay[778] = 1000000002375758707707302048; - bpsToRay[779] = 1000000002378700656223504817; - bpsToRay[780] = 1000000002381642331819031568; - bpsToRay[781] = 1000000002384583734544514586; - bpsToRay[782] = 1000000002387524864450572064; - bpsToRay[783] = 1000000002390465721587808119; - bpsToRay[784] = 1000000002393406306006812783; - bpsToRay[785] = 1000000002396346617758162017; - bpsToRay[786] = 1000000002399286656892417716; - bpsToRay[787] = 1000000002402226423460127711; - bpsToRay[788] = 1000000002405165917511825773; - bpsToRay[789] = 1000000002408105139098031627; - bpsToRay[790] = 1000000002411044088269250946; - bpsToRay[791] = 1000000002413982765075975363; - bpsToRay[792] = 1000000002416921169568682475; - bpsToRay[793] = 1000000002419859301797835847; - bpsToRay[794] = 1000000002422797161813885017; - bpsToRay[795] = 1000000002425734749667265506; - bpsToRay[796] = 1000000002428672065408398813; - bpsToRay[797] = 1000000002431609109087692432; - bpsToRay[798] = 1000000002434545880755539850; - bpsToRay[799] = 1000000002437482380462320552; - bpsToRay[800] = 1000000002440418608258400030; - bpsToRay[801] = 1000000002443354564194129787; - bpsToRay[802] = 1000000002446290248319847339; - bpsToRay[803] = 1000000002449225660685876223; - bpsToRay[804] = 1000000002452160801342526004; - bpsToRay[805] = 1000000002455095670340092277; - bpsToRay[806] = 1000000002458030267728856671; - bpsToRay[807] = 1000000002460964593559086859; - bpsToRay[808] = 1000000002463898647881036558; - bpsToRay[809] = 1000000002466832430744945540; - bpsToRay[810] = 1000000002469765942201039630; - bpsToRay[811] = 1000000002472699182299530718; - bpsToRay[812] = 1000000002475632151090616757; - bpsToRay[813] = 1000000002478564848624481779; - bpsToRay[814] = 1000000002481497274951295886; - bpsToRay[815] = 1000000002484429430121215269; - bpsToRay[816] = 1000000002487361314184382201; - bpsToRay[817] = 1000000002490292927190925051; - bpsToRay[818] = 1000000002493224269190958287; - bpsToRay[819] = 1000000002496155340234582476; - bpsToRay[820] = 1000000002499086140371884298; - bpsToRay[821] = 1000000002502016669652936543; - bpsToRay[822] = 1000000002504946928127798122; - bpsToRay[823] = 1000000002507876915846514067; - bpsToRay[824] = 1000000002510806632859115540; - bpsToRay[825] = 1000000002513736079215619839; - bpsToRay[826] = 1000000002516665254966030398; - bpsToRay[827] = 1000000002519594160160336795; - bpsToRay[828] = 1000000002522522794848514761; - bpsToRay[829] = 1000000002525451159080526178; - bpsToRay[830] = 1000000002528379252906319086; - bpsToRay[831] = 1000000002531307076375827697; - bpsToRay[832] = 1000000002534234629538972383; - bpsToRay[833] = 1000000002537161912445659699; - bpsToRay[834] = 1000000002540088925145782374; - bpsToRay[835] = 1000000002543015667689219327; - bpsToRay[836] = 1000000002545942140125835662; - bpsToRay[837] = 1000000002548868342505482685; - bpsToRay[838] = 1000000002551794274877997894; - bpsToRay[839] = 1000000002554719937293204998; - bpsToRay[840] = 1000000002557645329800913916; - bpsToRay[841] = 1000000002560570452450920783; - bpsToRay[842] = 1000000002563495305293007952; - bpsToRay[843] = 1000000002566419888376944003; - bpsToRay[844] = 1000000002569344201752483747; - bpsToRay[845] = 1000000002572268245469368232; - bpsToRay[846] = 1000000002575192019577324747; - bpsToRay[847] = 1000000002578115524126066824; - bpsToRay[848] = 1000000002581038759165294249; - bpsToRay[849] = 1000000002583961724744693064; - bpsToRay[850] = 1000000002586884420913935572; - bpsToRay[851] = 1000000002589806847722680342; - bpsToRay[852] = 1000000002592729005220572215; - bpsToRay[853] = 1000000002595650893457242308; - bpsToRay[854] = 1000000002598572512482308019; - bpsToRay[855] = 1000000002601493862345373033; - bpsToRay[856] = 1000000002604414943096027328; - bpsToRay[857] = 1000000002607335754783847177; - bpsToRay[858] = 1000000002610256297458395155; - bpsToRay[859] = 1000000002613176571169220145; - bpsToRay[860] = 1000000002616096575965857340; - bpsToRay[861] = 1000000002619016311897828252; - bpsToRay[862] = 1000000002621935779014640712; - bpsToRay[863] = 1000000002624854977365788881; - bpsToRay[864] = 1000000002627773907000753250; - bpsToRay[865] = 1000000002630692567969000648; - bpsToRay[866] = 1000000002633610960319984247; - bpsToRay[867] = 1000000002636529084103143562; - bpsToRay[868] = 1000000002639446939367904465; - bpsToRay[869] = 1000000002642364526163679182; - bpsToRay[870] = 1000000002645281844539866303; - bpsToRay[871] = 1000000002648198894545850784; - bpsToRay[872] = 1000000002651115676231003954; - bpsToRay[873] = 1000000002654032189644683517; - bpsToRay[874] = 1000000002656948434836233563; - bpsToRay[875] = 1000000002659864411854984565; - bpsToRay[876] = 1000000002662780120750253393; - bpsToRay[877] = 1000000002665695561571343309; - bpsToRay[878] = 1000000002668610734367543981; - bpsToRay[879] = 1000000002671525639188131484; - bpsToRay[880] = 1000000002674440276082368302; - bpsToRay[881] = 1000000002677354645099503340; - bpsToRay[882] = 1000000002680268746288771923; - bpsToRay[883] = 1000000002683182579699395804; - bpsToRay[884] = 1000000002686096145380583168; - bpsToRay[885] = 1000000002689009443381528638; - bpsToRay[886] = 1000000002691922473751413277; - bpsToRay[887] = 1000000002694835236539404598; - bpsToRay[888] = 1000000002697747731794656564; - bpsToRay[889] = 1000000002700659959566309596; - bpsToRay[890] = 1000000002703571919903490575; - bpsToRay[891] = 1000000002706483612855312853; - bpsToRay[892] = 1000000002709395038470876252; - bpsToRay[893] = 1000000002712306196799267069; - bpsToRay[894] = 1000000002715217087889558088; - bpsToRay[895] = 1000000002718127711790808573; - bpsToRay[896] = 1000000002721038068552064286; - bpsToRay[897] = 1000000002723948158222357482; - bpsToRay[898] = 1000000002726857980850706921; - bpsToRay[899] = 1000000002729767536486117866; - bpsToRay[900] = 1000000002732676825177582095; - bpsToRay[901] = 1000000002735585846974077901; - bpsToRay[902] = 1000000002738494601924570098; - bpsToRay[903] = 1000000002741403090078010029; - bpsToRay[904] = 1000000002744311311483335565; - bpsToRay[905] = 1000000002747219266189471117; - bpsToRay[906] = 1000000002750126954245327636; - bpsToRay[907] = 1000000002753034375699802616; - bpsToRay[908] = 1000000002755941530601780109; - bpsToRay[909] = 1000000002758848419000130717; - bpsToRay[910] = 1000000002761755040943711607; - bpsToRay[911] = 1000000002764661396481366508; - bpsToRay[912] = 1000000002767567485661925724; - bpsToRay[913] = 1000000002770473308534206134; - bpsToRay[914] = 1000000002773378865147011196; - bpsToRay[915] = 1000000002776284155549130955; - bpsToRay[916] = 1000000002779189179789342046; - bpsToRay[917] = 1000000002782093937916407701; - bpsToRay[918] = 1000000002784998429979077750; - bpsToRay[919] = 1000000002787902656026088630; - bpsToRay[920] = 1000000002790806616106163389; - bpsToRay[921] = 1000000002793710310268011687; - bpsToRay[922] = 1000000002796613738560329808; - bpsToRay[923] = 1000000002799516901031800659; - bpsToRay[924] = 1000000002802419797731093776; - bpsToRay[925] = 1000000002805322428706865331; - bpsToRay[926] = 1000000002808224794007758136; - bpsToRay[927] = 1000000002811126893682401646; - bpsToRay[928] = 1000000002814028727779411968; - bpsToRay[929] = 1000000002816930296347391860; - bpsToRay[930] = 1000000002819831599434930742; - bpsToRay[931] = 1000000002822732637090604696; - bpsToRay[932] = 1000000002825633409362976474; - bpsToRay[933] = 1000000002828533916300595503; - bpsToRay[934] = 1000000002831434157951997885; - bpsToRay[935] = 1000000002834334134365706412; - bpsToRay[936] = 1000000002837233845590230556; - bpsToRay[937] = 1000000002840133291674066490; - bpsToRay[938] = 1000000002843032472665697081; - bpsToRay[939] = 1000000002845931388613591900; - bpsToRay[940] = 1000000002848830039566207226; - bpsToRay[941] = 1000000002851728425571986050; - bpsToRay[942] = 1000000002854626546679358084; - bpsToRay[943] = 1000000002857524402936739757; - bpsToRay[944] = 1000000002860421994392534231; - bpsToRay[945] = 1000000002863319321095131394; - bpsToRay[946] = 1000000002866216383092907878; - bpsToRay[947] = 1000000002869113180434227051; - bpsToRay[948] = 1000000002872009713167439031; - bpsToRay[949] = 1000000002874905981340880687; - bpsToRay[950] = 1000000002877801985002875644; - bpsToRay[951] = 1000000002880697724201734289; - bpsToRay[952] = 1000000002883593198985753772; - bpsToRay[953] = 1000000002886488409403218019; - bpsToRay[954] = 1000000002889383355502397729; - bpsToRay[955] = 1000000002892278037331550380; - bpsToRay[956] = 1000000002895172454938920238; - bpsToRay[957] = 1000000002898066608372738360; - bpsToRay[958] = 1000000002900960497681222594; - bpsToRay[959] = 1000000002903854122912577591; - bpsToRay[960] = 1000000002906747484114994807; - bpsToRay[961] = 1000000002909640581336652506; - bpsToRay[962] = 1000000002912533414625715766; - bpsToRay[963] = 1000000002915425984030336485; - bpsToRay[964] = 1000000002918318289598653387; - bpsToRay[965] = 1000000002921210331378792020; - bpsToRay[966] = 1000000002924102109418864770; - bpsToRay[967] = 1000000002926993623766970860; - bpsToRay[968] = 1000000002929884874471196354; - bpsToRay[969] = 1000000002932775861579614167; - bpsToRay[970] = 1000000002935666585140284065; - bpsToRay[971] = 1000000002938557045201252671; - bpsToRay[972] = 1000000002941447241810553473; - bpsToRay[973] = 1000000002944337175016206824; - bpsToRay[974] = 1000000002947226844866219949; - bpsToRay[975] = 1000000002950116251408586949; - bpsToRay[976] = 1000000002953005394691288810; - bpsToRay[977] = 1000000002955894274762293401; - bpsToRay[978] = 1000000002958782891669555482; - bpsToRay[979] = 1000000002961671245461016710; - bpsToRay[980] = 1000000002964559336184605642; - bpsToRay[981] = 1000000002967447163888237741; - bpsToRay[982] = 1000000002970334728619815381; - bpsToRay[983] = 1000000002973222030427227847; - bpsToRay[984] = 1000000002976109069358351348; - bpsToRay[985] = 1000000002978995845461049016; - bpsToRay[986] = 1000000002981882358783170911; - bpsToRay[987] = 1000000002984768609372554028; - bpsToRay[988] = 1000000002987654597277022302; - bpsToRay[989] = 1000000002990540322544386608; - bpsToRay[990] = 1000000002993425785222444772; - bpsToRay[991] = 1000000002996310985358981573; - bpsToRay[992] = 1000000002999195923001768747; - bpsToRay[993] = 1000000003002080598198564991; - bpsToRay[994] = 1000000003004965010997115971; - bpsToRay[995] = 1000000003007849161445154325; - bpsToRay[996] = 1000000003010733049590399667; - bpsToRay[997] = 1000000003013616675480558594; - bpsToRay[998] = 1000000003016500039163324684; - bpsToRay[999] = 1000000003019383140686378514; - bpsToRay[1000] = 1000000003022265980097387650; - bpsToRay[1001] = 1000000003025148557444006661; - bpsToRay[1002] = 1000000003028030872773877120; - bpsToRay[1003] = 1000000003030912926134627612; - bpsToRay[1004] = 1000000003033794717573873734; - bpsToRay[1005] = 1000000003036676247139218104; - bpsToRay[1006] = 1000000003039557514878250362; - bpsToRay[1007] = 1000000003042438520838547180; - bpsToRay[1008] = 1000000003045319265067672258; - bpsToRay[1009] = 1000000003048199747613176340; - bpsToRay[1010] = 1000000003051079968522597209; - bpsToRay[1011] = 1000000003053959927843459697; - bpsToRay[1012] = 1000000003056839625623275688; - bpsToRay[1013] = 1000000003059719061909544123; - bpsToRay[1014] = 1000000003062598236749751004; - bpsToRay[1015] = 1000000003065477150191369400; - bpsToRay[1016] = 1000000003068355802281859451; - bpsToRay[1017] = 1000000003071234193068668372; - bpsToRay[1018] = 1000000003074112322599230459; - bpsToRay[1019] = 1000000003076990190920967093; - bpsToRay[1020] = 1000000003079867798081286746; - bpsToRay[1021] = 1000000003082745144127584981; - bpsToRay[1022] = 1000000003085622229107244463; - bpsToRay[1023] = 1000000003088499053067634962; - bpsToRay[1024] = 1000000003091375616056113353; - bpsToRay[1025] = 1000000003094251918120023627; - bpsToRay[1026] = 1000000003097127959306696891; - bpsToRay[1027] = 1000000003100003739663451375; - bpsToRay[1028] = 1000000003102879259237592437; - bpsToRay[1029] = 1000000003105754518076412567; - bpsToRay[1030] = 1000000003108629516227191390; - bpsToRay[1031] = 1000000003111504253737195675; - bpsToRay[1032] = 1000000003114378730653679332; - bpsToRay[1033] = 1000000003117252947023883428; - bpsToRay[1034] = 1000000003120126902895036179; - bpsToRay[1035] = 1000000003123000598314352966; - bpsToRay[1036] = 1000000003125874033329036329; - bpsToRay[1037] = 1000000003128747207986275984; - bpsToRay[1038] = 1000000003131620122333248815; - bpsToRay[1039] = 1000000003134492776417118886; - bpsToRay[1040] = 1000000003137365170285037445; - bpsToRay[1041] = 1000000003140237303984142929; - bpsToRay[1042] = 1000000003143109177561560964; - bpsToRay[1043] = 1000000003145980791064404376; - bpsToRay[1044] = 1000000003148852144539773190; - bpsToRay[1045] = 1000000003151723238034754641; - bpsToRay[1046] = 1000000003154594071596423170; - bpsToRay[1047] = 1000000003157464645271840438; - bpsToRay[1048] = 1000000003160334959108055323; - bpsToRay[1049] = 1000000003163205013152103932; - bpsToRay[1050] = 1000000003166074807451009595; - bpsToRay[1051] = 1000000003168944342051782881; - bpsToRay[1052] = 1000000003171813617001421599; - bpsToRay[1053] = 1000000003174682632346910796; - bpsToRay[1054] = 1000000003177551388135222770; - bpsToRay[1055] = 1000000003180419884413317071; - bpsToRay[1056] = 1000000003183288121228140507; - bpsToRay[1057] = 1000000003186156098626627147; - bpsToRay[1058] = 1000000003189023816655698326; - bpsToRay[1059] = 1000000003191891275362262652; - bpsToRay[1060] = 1000000003194758474793216004; - bpsToRay[1061] = 1000000003197625414995441546; - bpsToRay[1062] = 1000000003200492096015809725; - bpsToRay[1063] = 1000000003203358517901178277; - bpsToRay[1064] = 1000000003206224680698392232; - bpsToRay[1065] = 1000000003209090584454283919; - bpsToRay[1066] = 1000000003211956229215672970; - bpsToRay[1067] = 1000000003214821615029366324; - bpsToRay[1068] = 1000000003217686741942158234; - bpsToRay[1069] = 1000000003220551610000830269; - bpsToRay[1070] = 1000000003223416219252151318; - bpsToRay[1071] = 1000000003226280569742877599; - bpsToRay[1072] = 1000000003229144661519752659; - bpsToRay[1073] = 1000000003232008494629507379; - bpsToRay[1074] = 1000000003234872069118859983; - bpsToRay[1075] = 1000000003237735385034516037; - bpsToRay[1076] = 1000000003240598442423168457; - bpsToRay[1077] = 1000000003243461241331497510; - bpsToRay[1078] = 1000000003246323781806170825; - bpsToRay[1079] = 1000000003249186063893843391; - bpsToRay[1080] = 1000000003252048087641157566; - bpsToRay[1081] = 1000000003254909853094743078; - bpsToRay[1082] = 1000000003257771360301217032; - bpsToRay[1083] = 1000000003260632609307183913; - bpsToRay[1084] = 1000000003263493600159235596; - bpsToRay[1085] = 1000000003266354332903951338; - bpsToRay[1086] = 1000000003269214807587897798; - bpsToRay[1087] = 1000000003272075024257629030; - bpsToRay[1088] = 1000000003274934982959686493; - bpsToRay[1089] = 1000000003277794683740599053; - bpsToRay[1090] = 1000000003280654126646882991; - bpsToRay[1091] = 1000000003283513311725042002; - bpsToRay[1092] = 1000000003286372239021567206; - bpsToRay[1093] = 1000000003289230908582937149; - bpsToRay[1094] = 1000000003292089320455617805; - bpsToRay[1095] = 1000000003294947474686062586; - bpsToRay[1096] = 1000000003297805371320712343; - bpsToRay[1097] = 1000000003300663010405995372; - bpsToRay[1098] = 1000000003303520391988327418; - bpsToRay[1099] = 1000000003306377516114111677; - bpsToRay[1100] = 1000000003309234382829738808; - bpsToRay[1101] = 1000000003312090992181586929; - bpsToRay[1102] = 1000000003314947344216021625; - bpsToRay[1103] = 1000000003317803438979395953; - bpsToRay[1104] = 1000000003320659276518050449; - bpsToRay[1105] = 1000000003323514856878313124; - bpsToRay[1106] = 1000000003326370180106499479; - bpsToRay[1107] = 1000000003329225246248912502; - bpsToRay[1108] = 1000000003332080055351842678; - bpsToRay[1109] = 1000000003334934607461567985; - bpsToRay[1110] = 1000000003337788902624353911; - bpsToRay[1111] = 1000000003340642940886453447; - bpsToRay[1112] = 1000000003343496722294107097; - bpsToRay[1113] = 1000000003346350246893542883; - bpsToRay[1114] = 1000000003349203514730976348; - bpsToRay[1115] = 1000000003352056525852610558; - bpsToRay[1116] = 1000000003354909280304636111; - bpsToRay[1117] = 1000000003357761778133231141; - bpsToRay[1118] = 1000000003360614019384561319; - bpsToRay[1119] = 1000000003363466004104779860; - bpsToRay[1120] = 1000000003366317732340027527; - bpsToRay[1121] = 1000000003369169204136432636; - bpsToRay[1122] = 1000000003372020419540111060; - bpsToRay[1123] = 1000000003374871378597166232; - bpsToRay[1124] = 1000000003377722081353689153; - bpsToRay[1125] = 1000000003380572527855758393; - bpsToRay[1126] = 1000000003383422718149440098; - bpsToRay[1127] = 1000000003386272652280787992; - bpsToRay[1128] = 1000000003389122330295843384; - bpsToRay[1129] = 1000000003391971752240635171; - bpsToRay[1130] = 1000000003394820918161179843; - bpsToRay[1131] = 1000000003397669828103481484; - bpsToRay[1132] = 1000000003400518482113531785; - bpsToRay[1133] = 1000000003403366880237310040; - bpsToRay[1134] = 1000000003406215022520783154; - bpsToRay[1135] = 1000000003409062909009905646; - bpsToRay[1136] = 1000000003411910539750619657; - bpsToRay[1137] = 1000000003414757914788854950; - bpsToRay[1138] = 1000000003417605034170528915; - bpsToRay[1139] = 1000000003420451897941546578; - bpsToRay[1140] = 1000000003423298506147800601; - bpsToRay[1141] = 1000000003426144858835171287; - bpsToRay[1142] = 1000000003428990956049526585; - bpsToRay[1143] = 1000000003431836797836722098; - bpsToRay[1144] = 1000000003434682384242601076; - bpsToRay[1145] = 1000000003437527715312994437; - bpsToRay[1146] = 1000000003440372791093720759; - bpsToRay[1147] = 1000000003443217611630586286; - bpsToRay[1148] = 1000000003446062176969384941; - bpsToRay[1149] = 1000000003448906487155898317; - bpsToRay[1150] = 1000000003451750542235895695; - bpsToRay[1151] = 1000000003454594342255134037; - bpsToRay[1152] = 1000000003457437887259357996; - bpsToRay[1153] = 1000000003460281177294299923; - bpsToRay[1154] = 1000000003463124212405679865; - bpsToRay[1155] = 1000000003465966992639205574; - bpsToRay[1156] = 1000000003468809518040572510; - bpsToRay[1157] = 1000000003471651788655463845; - bpsToRay[1158] = 1000000003474493804529550469; - bpsToRay[1159] = 1000000003477335565708490991; - bpsToRay[1160] = 1000000003480177072237931747; - bpsToRay[1161] = 1000000003483018324163506803; - bpsToRay[1162] = 1000000003485859321530837959; - bpsToRay[1163] = 1000000003488700064385534755; - bpsToRay[1164] = 1000000003491540552773194473; - bpsToRay[1165] = 1000000003494380786739402144; - bpsToRay[1166] = 1000000003497220766329730547; - bpsToRay[1167] = 1000000003500060491589740224; - bpsToRay[1168] = 1000000003502899962564979471; - bpsToRay[1169] = 1000000003505739179300984355; - bpsToRay[1170] = 1000000003508578141843278707; - bpsToRay[1171] = 1000000003511416850237374137; - bpsToRay[1172] = 1000000003514255304528770030; - bpsToRay[1173] = 1000000003517093504762953555; - bpsToRay[1174] = 1000000003519931450985399667; - bpsToRay[1175] = 1000000003522769143241571114; - bpsToRay[1176] = 1000000003525606581576918439; - bpsToRay[1177] = 1000000003528443766036879984; - bpsToRay[1178] = 1000000003531280696666881897; - bpsToRay[1179] = 1000000003534117373512338136; - bpsToRay[1180] = 1000000003536953796618650468; - bpsToRay[1181] = 1000000003539789966031208483; - bpsToRay[1182] = 1000000003542625881795389588; - bpsToRay[1183] = 1000000003545461543956559019; - bpsToRay[1184] = 1000000003548296952560069844; - bpsToRay[1185] = 1000000003551132107651262963; - bpsToRay[1186] = 1000000003553967009275467116; - bpsToRay[1187] = 1000000003556801657477998888; - bpsToRay[1188] = 1000000003559636052304162712; - bpsToRay[1189] = 1000000003562470193799250871; - bpsToRay[1190] = 1000000003565304082008543509; - bpsToRay[1191] = 1000000003568137716977308627; - bpsToRay[1192] = 1000000003570971098750802094; - bpsToRay[1193] = 1000000003573804227374267648; - bpsToRay[1194] = 1000000003576637102892936900; - bpsToRay[1195] = 1000000003579469725352029341; - bpsToRay[1196] = 1000000003582302094796752344; - bpsToRay[1197] = 1000000003585134211272301170; - bpsToRay[1198] = 1000000003587966074823858969; - bpsToRay[1199] = 1000000003590797685496596791; - bpsToRay[1200] = 1000000003593629043335673582; - bpsToRay[1201] = 1000000003596460148386236193; - bpsToRay[1202] = 1000000003599291000693419387; - bpsToRay[1203] = 1000000003602121600302345836; - bpsToRay[1204] = 1000000003604951947258126131; - bpsToRay[1205] = 1000000003607782041605858785; - bpsToRay[1206] = 1000000003610611883390630237; - bpsToRay[1207] = 1000000003613441472657514856; - bpsToRay[1208] = 1000000003616270809451574945; - bpsToRay[1209] = 1000000003619099893817860747; - bpsToRay[1210] = 1000000003621928725801410447; - bpsToRay[1211] = 1000000003624757305447250178; - bpsToRay[1212] = 1000000003627585632800394025; - bpsToRay[1213] = 1000000003630413707905844031; - bpsToRay[1214] = 1000000003633241530808590194; - bpsToRay[1215] = 1000000003636069101553610482; - bpsToRay[1216] = 1000000003638896420185870830; - bpsToRay[1217] = 1000000003641723486750325145; - bpsToRay[1218] = 1000000003644550301291915316; - bpsToRay[1219] = 1000000003647376863855571208; - bpsToRay[1220] = 1000000003650203174486210676; - bpsToRay[1221] = 1000000003653029233228739563; - bpsToRay[1222] = 1000000003655855040128051709; - bpsToRay[1223] = 1000000003658680595229028953; - bpsToRay[1224] = 1000000003661505898576541135; - bpsToRay[1225] = 1000000003664330950215446102; - bpsToRay[1226] = 1000000003667155750190589718; - bpsToRay[1227] = 1000000003669980298546805858; - bpsToRay[1228] = 1000000003672804595328916419; - bpsToRay[1229] = 1000000003675628640581731322; - bpsToRay[1230] = 1000000003678452434350048518; - bpsToRay[1231] = 1000000003681275976678653990; - bpsToRay[1232] = 1000000003684099267612321761; - bpsToRay[1233] = 1000000003686922307195813890; - bpsToRay[1234] = 1000000003689745095473880490; - bpsToRay[1235] = 1000000003692567632491259715; - bpsToRay[1236] = 1000000003695389918292677782; - bpsToRay[1237] = 1000000003698211952922848960; - bpsToRay[1238] = 1000000003701033736426475586; - bpsToRay[1239] = 1000000003703855268848248061; - bpsToRay[1240] = 1000000003706676550232844859; - bpsToRay[1241] = 1000000003709497580624932527; - bpsToRay[1242] = 1000000003712318360069165696; - bpsToRay[1243] = 1000000003715138888610187078; - bpsToRay[1244] = 1000000003717959166292627475; - bpsToRay[1245] = 1000000003720779193161105781; - bpsToRay[1246] = 1000000003723598969260228987; - bpsToRay[1247] = 1000000003726418494634592186; - bpsToRay[1248] = 1000000003729237769328778574; - bpsToRay[1249] = 1000000003732056793387359459; - bpsToRay[1250] = 1000000003734875566854894261; - bpsToRay[1251] = 1000000003737694089775930518; - bpsToRay[1252] = 1000000003740512362195003894; - bpsToRay[1253] = 1000000003743330384156638173; - bpsToRay[1254] = 1000000003746148155705345276; - bpsToRay[1255] = 1000000003748965676885625255; - bpsToRay[1256] = 1000000003751782947741966301; - bpsToRay[1257] = 1000000003754599968318844752; - bpsToRay[1258] = 1000000003757416738660725089; - bpsToRay[1259] = 1000000003760233258812059948; - bpsToRay[1260] = 1000000003763049528817290119; - bpsToRay[1261] = 1000000003765865548720844553; - bpsToRay[1262] = 1000000003768681318567140366; - bpsToRay[1263] = 1000000003771496838400582842; - bpsToRay[1264] = 1000000003774312108265565437; - bpsToRay[1265] = 1000000003777127128206469785; - bpsToRay[1266] = 1000000003779941898267665701; - bpsToRay[1267] = 1000000003782756418493511185; - bpsToRay[1268] = 1000000003785570688928352427; - bpsToRay[1269] = 1000000003788384709616523810; - bpsToRay[1270] = 1000000003791198480602347918; - bpsToRay[1271] = 1000000003794012001930135532; - bpsToRay[1272] = 1000000003796825273644185643; - bpsToRay[1273] = 1000000003799638295788785451; - bpsToRay[1274] = 1000000003802451068408210371; - bpsToRay[1275] = 1000000003805263591546724039; - bpsToRay[1276] = 1000000003808075865248578310; - bpsToRay[1277] = 1000000003810887889558013269; - bpsToRay[1278] = 1000000003813699664519257234; - bpsToRay[1279] = 1000000003816511190176526753; - bpsToRay[1280] = 1000000003819322466574026619; - bpsToRay[1281] = 1000000003822133493755949867; - bpsToRay[1282] = 1000000003824944271766477781; - bpsToRay[1283] = 1000000003827754800649779894; - bpsToRay[1284] = 1000000003830565080450014001; - bpsToRay[1285] = 1000000003833375111211326151; - bpsToRay[1286] = 1000000003836184892977850664; - bpsToRay[1287] = 1000000003838994425793710125; - bpsToRay[1288] = 1000000003841803709703015394; - bpsToRay[1289] = 1000000003844612744749865606; - bpsToRay[1290] = 1000000003847421530978348180; - bpsToRay[1291] = 1000000003850230068432538818; - bpsToRay[1292] = 1000000003853038357156501515; - bpsToRay[1293] = 1000000003855846397194288557; - bpsToRay[1294] = 1000000003858654188589940528; - bpsToRay[1295] = 1000000003861461731387486315; - bpsToRay[1296] = 1000000003864269025630943112; - bpsToRay[1297] = 1000000003867076071364316422; - bpsToRay[1298] = 1000000003869882868631600065; - bpsToRay[1299] = 1000000003872689417476776174; - bpsToRay[1300] = 1000000003875495717943815211; - bpsToRay[1301] = 1000000003878301770076675963; - bpsToRay[1302] = 1000000003881107573919305546; - bpsToRay[1303] = 1000000003883913129515639415; - bpsToRay[1304] = 1000000003886718436909601359; - bpsToRay[1305] = 1000000003889523496145103516; - bpsToRay[1306] = 1000000003892328307266046370; - bpsToRay[1307] = 1000000003895132870316318753; - bpsToRay[1308] = 1000000003897937185339797857; - bpsToRay[1309] = 1000000003900741252380349234; - bpsToRay[1310] = 1000000003903545071481826796; - bpsToRay[1311] = 1000000003906348642688072829; - bpsToRay[1312] = 1000000003909151966042917985; - bpsToRay[1313] = 1000000003911955041590181299; - bpsToRay[1314] = 1000000003914757869373670180; - bpsToRay[1315] = 1000000003917560449437180427; - bpsToRay[1316] = 1000000003920362781824496225; - bpsToRay[1317] = 1000000003923164866579390151; - bpsToRay[1318] = 1000000003925966703745623181; - bpsToRay[1319] = 1000000003928768293366944691; - bpsToRay[1320] = 1000000003931569635487092463; - bpsToRay[1321] = 1000000003934370730149792686; - bpsToRay[1322] = 1000000003937171577398759967; - bpsToRay[1323] = 1000000003939972177277697324; - bpsToRay[1324] = 1000000003942772529830296202; - bpsToRay[1325] = 1000000003945572635100236468; - bpsToRay[1326] = 1000000003948372493131186422; - bpsToRay[1327] = 1000000003951172103966802794; - bpsToRay[1328] = 1000000003953971467650730754; - bpsToRay[1329] = 1000000003956770584226603915; - bpsToRay[1330] = 1000000003959569453738044333; - bpsToRay[1331] = 1000000003962368076228662518; - bpsToRay[1332] = 1000000003965166451742057429; - bpsToRay[1333] = 1000000003967964580321816489; - bpsToRay[1334] = 1000000003970762462011515578; - bpsToRay[1335] = 1000000003973560096854719047; - bpsToRay[1336] = 1000000003976357484894979715; - bpsToRay[1337] = 1000000003979154626175838876; - bpsToRay[1338] = 1000000003981951520740826302; - bpsToRay[1339] = 1000000003984748168633460248; - bpsToRay[1340] = 1000000003987544569897247457; - bpsToRay[1341] = 1000000003990340724575683160; - bpsToRay[1342] = 1000000003993136632712251086; - bpsToRay[1343] = 1000000003995932294350423462; - bpsToRay[1344] = 1000000003998727709533661015; - bpsToRay[1345] = 1000000004001522878305412984; - bpsToRay[1346] = 1000000004004317800709117115; - bpsToRay[1347] = 1000000004007112476788199671; - bpsToRay[1348] = 1000000004009906906586075434; - bpsToRay[1349] = 1000000004012701090146147709; - bpsToRay[1350] = 1000000004015495027511808328; - bpsToRay[1351] = 1000000004018288718726437654; - bpsToRay[1352] = 1000000004021082163833404588; - bpsToRay[1353] = 1000000004023875362876066566; - bpsToRay[1354] = 1000000004026668315897769570; - bpsToRay[1355] = 1000000004029461022941848130; - bpsToRay[1356] = 1000000004032253484051625326; - bpsToRay[1357] = 1000000004035045699270412795; - bpsToRay[1358] = 1000000004037837668641510732; - bpsToRay[1359] = 1000000004040629392208207896; - bpsToRay[1360] = 1000000004043420870013781614; - bpsToRay[1361] = 1000000004046212102101497785; - bpsToRay[1362] = 1000000004049003088514610884; - bpsToRay[1363] = 1000000004051793829296363962; - bpsToRay[1364] = 1000000004054584324489988659; - bpsToRay[1365] = 1000000004057374574138705201; - bpsToRay[1366] = 1000000004060164578285722402; - bpsToRay[1367] = 1000000004062954336974237676; - bpsToRay[1368] = 1000000004065743850247437036; - bpsToRay[1369] = 1000000004068533118148495099; - bpsToRay[1370] = 1000000004071322140720575088; - bpsToRay[1371] = 1000000004074110918006828838; - bpsToRay[1372] = 1000000004076899450050396802; - bpsToRay[1373] = 1000000004079687736894408050; - bpsToRay[1374] = 1000000004082475778581980279; - bpsToRay[1375] = 1000000004085263575156219812; - bpsToRay[1376] = 1000000004088051126660221602; - bpsToRay[1377] = 1000000004090838433137069242; - bpsToRay[1378] = 1000000004093625494629834960; - bpsToRay[1379] = 1000000004096412311181579631; - bpsToRay[1380] = 1000000004099198882835352777; - bpsToRay[1381] = 1000000004101985209634192573; - bpsToRay[1382] = 1000000004104771291621125847; - bpsToRay[1383] = 1000000004107557128839168089; - bpsToRay[1384] = 1000000004110342721331323451; - bpsToRay[1385] = 1000000004113128069140584754; - bpsToRay[1386] = 1000000004115913172309933491; - bpsToRay[1387] = 1000000004118698030882339831; - bpsToRay[1388] = 1000000004121482644900762619; - bpsToRay[1389] = 1000000004124267014408149388; - bpsToRay[1390] = 1000000004127051139447436357; - bpsToRay[1391] = 1000000004129835020061548436; - bpsToRay[1392] = 1000000004132618656293399231; - bpsToRay[1393] = 1000000004135402048185891048; - bpsToRay[1394] = 1000000004138185195781914895; - bpsToRay[1395] = 1000000004140968099124350490; - bpsToRay[1396] = 1000000004143750758256066259; - bpsToRay[1397] = 1000000004146533173219919347; - bpsToRay[1398] = 1000000004149315344058755615; - bpsToRay[1399] = 1000000004152097270815409650; - bpsToRay[1400] = 1000000004154878953532704765; - bpsToRay[1401] = 1000000004157660392253453003; - bpsToRay[1402] = 1000000004160441587020455146; - bpsToRay[1403] = 1000000004163222537876500710; - bpsToRay[1404] = 1000000004166003244864367958; - bpsToRay[1405] = 1000000004168783708026823899; - bpsToRay[1406] = 1000000004171563927406624291; - bpsToRay[1407] = 1000000004174343903046513649; - bpsToRay[1408] = 1000000004177123634989225246; - bpsToRay[1409] = 1000000004179903123277481120; - bpsToRay[1410] = 1000000004182682367953992073; - bpsToRay[1411] = 1000000004185461369061457677; - bpsToRay[1412] = 1000000004188240126642566281; - bpsToRay[1413] = 1000000004191018640739995012; - bpsToRay[1414] = 1000000004193796911396409779; - bpsToRay[1415] = 1000000004196574938654465277; - bpsToRay[1416] = 1000000004199352722556804991; - bpsToRay[1417] = 1000000004202130263146061203; - bpsToRay[1418] = 1000000004204907560464854990; - bpsToRay[1419] = 1000000004207684614555796231; - bpsToRay[1420] = 1000000004210461425461483615; - bpsToRay[1421] = 1000000004213237993224504637; - bpsToRay[1422] = 1000000004216014317887435608; - bpsToRay[1423] = 1000000004218790399492841653; - bpsToRay[1424] = 1000000004221566238083276725; - bpsToRay[1425] = 1000000004224341833701283597; - bpsToRay[1426] = 1000000004227117186389393875; - bpsToRay[1427] = 1000000004229892296190127996; - bpsToRay[1428] = 1000000004232667163145995236; - bpsToRay[1429] = 1000000004235441787299493712; - bpsToRay[1430] = 1000000004238216168693110386; - bpsToRay[1431] = 1000000004240990307369321069; - bpsToRay[1432] = 1000000004243764203370590423; - bpsToRay[1433] = 1000000004246537856739371971; - bpsToRay[1434] = 1000000004249311267518108094; - bpsToRay[1435] = 1000000004252084435749230038; - bpsToRay[1436] = 1000000004254857361475157917; - bpsToRay[1437] = 1000000004257630044738300719; - bpsToRay[1438] = 1000000004260402485581056307; - bpsToRay[1439] = 1000000004263174684045811425; - bpsToRay[1440] = 1000000004265946640174941701; - bpsToRay[1441] = 1000000004268718354010811651; - bpsToRay[1442] = 1000000004271489825595774681; - bpsToRay[1443] = 1000000004274261054972173095; - bpsToRay[1444] = 1000000004277032042182338097; - bpsToRay[1445] = 1000000004279802787268589794; - bpsToRay[1446] = 1000000004282573290273237200; - bpsToRay[1447] = 1000000004285343551238578238; - bpsToRay[1448] = 1000000004288113570206899751; - bpsToRay[1449] = 1000000004290883347220477497; - bpsToRay[1450] = 1000000004293652882321576158; - bpsToRay[1451] = 1000000004296422175552449345; - bpsToRay[1452] = 1000000004299191226955339597; - bpsToRay[1453] = 1000000004301960036572478387; - bpsToRay[1454] = 1000000004304728604446086130; - bpsToRay[1455] = 1000000004307496930618372179; - bpsToRay[1456] = 1000000004310265015131534834; - bpsToRay[1457] = 1000000004313032858027761349; - bpsToRay[1458] = 1000000004315800459349227927; - bpsToRay[1459] = 1000000004318567819138099730; - bpsToRay[1460] = 1000000004321334937436530883; - bpsToRay[1461] = 1000000004324101814286664475; - bpsToRay[1462] = 1000000004326868449730632563; - bpsToRay[1463] = 1000000004329634843810556180; - bpsToRay[1464] = 1000000004332400996568545334; - bpsToRay[1465] = 1000000004335166908046699016; - bpsToRay[1466] = 1000000004337932578287105196; - bpsToRay[1467] = 1000000004340698007331840840; - bpsToRay[1468] = 1000000004343463195222971901; - bpsToRay[1469] = 1000000004346228142002553329; - bpsToRay[1470] = 1000000004348992847712629077; - bpsToRay[1471] = 1000000004351757312395232098; - bpsToRay[1472] = 1000000004354521536092384354; - bpsToRay[1473] = 1000000004357285518846096818; - bpsToRay[1474] = 1000000004360049260698369481; - bpsToRay[1475] = 1000000004362812761691191350; - bpsToRay[1476] = 1000000004365576021866540454; - bpsToRay[1477] = 1000000004368339041266383854; - bpsToRay[1478] = 1000000004371101819932677638; - bpsToRay[1479] = 1000000004373864357907366926; - bpsToRay[1480] = 1000000004376626655232385882; - bpsToRay[1481] = 1000000004379388711949657709; - bpsToRay[1482] = 1000000004382150528101094654; - bpsToRay[1483] = 1000000004384912103728598017; - bpsToRay[1484] = 1000000004387673438874058150; - bpsToRay[1485] = 1000000004390434533579354464; - bpsToRay[1486] = 1000000004393195387886355428; - bpsToRay[1487] = 1000000004395956001836918578; - bpsToRay[1488] = 1000000004398716375472890520; - bpsToRay[1489] = 1000000004401476508836106929; - bpsToRay[1490] = 1000000004404236401968392559; - bpsToRay[1491] = 1000000004406996054911561245; - bpsToRay[1492] = 1000000004409755467707415902; - bpsToRay[1493] = 1000000004412514640397748538; - bpsToRay[1494] = 1000000004415273573024340248; - bpsToRay[1495] = 1000000004418032265628961226; - bpsToRay[1496] = 1000000004420790718253370761; - bpsToRay[1497] = 1000000004423548930939317250; - bpsToRay[1498] = 1000000004426306903728538193; - bpsToRay[1499] = 1000000004429064636662760200; - bpsToRay[1500] = 1000000004431822129783699001; - bpsToRay[1501] = 1000000004434579383133059436; - bpsToRay[1502] = 1000000004437336396752535473; - bpsToRay[1503] = 1000000004440093170683810203; - bpsToRay[1504] = 1000000004442849704968555849; - bpsToRay[1505] = 1000000004445605999648433763; - bpsToRay[1506] = 1000000004448362054765094438; - bpsToRay[1507] = 1000000004451117870360177505; - bpsToRay[1508] = 1000000004453873446475311742; - bpsToRay[1509] = 1000000004456628783152115072; - bpsToRay[1510] = 1000000004459383880432194574; - bpsToRay[1511] = 1000000004462138738357146482; - bpsToRay[1512] = 1000000004464893356968556186; - bpsToRay[1513] = 1000000004467647736307998245; - bpsToRay[1514] = 1000000004470401876417036380; - bpsToRay[1515] = 1000000004473155777337223487; - bpsToRay[1516] = 1000000004475909439110101633; - bpsToRay[1517] = 1000000004478662861777202067; - bpsToRay[1518] = 1000000004481416045380045219; - bpsToRay[1519] = 1000000004484168989960140704; - bpsToRay[1520] = 1000000004486921695558987326; - bpsToRay[1521] = 1000000004489674162218073087; - bpsToRay[1522] = 1000000004492426389978875180; - bpsToRay[1523] = 1000000004495178378882860004; - bpsToRay[1524] = 1000000004497930128971483160; - bpsToRay[1525] = 1000000004500681640286189459; - bpsToRay[1526] = 1000000004503432912868412922; - bpsToRay[1527] = 1000000004506183946759576791; - bpsToRay[1528] = 1000000004508934742001093521; - bpsToRay[1529] = 1000000004511685298634364794; - bpsToRay[1530] = 1000000004514435616700781520; - bpsToRay[1531] = 1000000004517185696241723838; - bpsToRay[1532] = 1000000004519935537298561123; - bpsToRay[1533] = 1000000004522685139912651989; - bpsToRay[1534] = 1000000004525434504125344289; - bpsToRay[1535] = 1000000004528183629977975125; - bpsToRay[1536] = 1000000004530932517511870847; - bpsToRay[1537] = 1000000004533681166768347059; - bpsToRay[1538] = 1000000004536429577788708623; - bpsToRay[1539] = 1000000004539177750614249659; - bpsToRay[1540] = 1000000004541925685286253554; - bpsToRay[1541] = 1000000004544673381845992962; - bpsToRay[1542] = 1000000004547420840334729810; - bpsToRay[1543] = 1000000004550168060793715299; - bpsToRay[1544] = 1000000004552915043264189911; - bpsToRay[1545] = 1000000004555661787787383409; - bpsToRay[1546] = 1000000004558408294404514847; - bpsToRay[1547] = 1000000004561154563156792564; - bpsToRay[1548] = 1000000004563900594085414197; - bpsToRay[1549] = 1000000004566646387231566680; - bpsToRay[1550] = 1000000004569391942636426248; - bpsToRay[1551] = 1000000004572137260341158442; - bpsToRay[1552] = 1000000004574882340386918113; - bpsToRay[1553] = 1000000004577627182814849422; - bpsToRay[1554] = 1000000004580371787666085848; - bpsToRay[1555] = 1000000004583116154981750191; - bpsToRay[1556] = 1000000004585860284802954574; - bpsToRay[1557] = 1000000004588604177170800448; - bpsToRay[1558] = 1000000004591347832126378593; - bpsToRay[1559] = 1000000004594091249710769128; - bpsToRay[1560] = 1000000004596834429965041505; - bpsToRay[1561] = 1000000004599577372930254526; - bpsToRay[1562] = 1000000004602320078647456331; - bpsToRay[1563] = 1000000004605062547157684415; - bpsToRay[1564] = 1000000004607804778501965623; - bpsToRay[1565] = 1000000004610546772721316162; - bpsToRay[1566] = 1000000004613288529856741593; - bpsToRay[1567] = 1000000004616030049949236846; - bpsToRay[1568] = 1000000004618771333039786217; - bpsToRay[1569] = 1000000004621512379169363376; - bpsToRay[1570] = 1000000004624253188378931367; - bpsToRay[1571] = 1000000004626993760709442611; - bpsToRay[1572] = 1000000004629734096201838917; - bpsToRay[1573] = 1000000004632474194897051476; - bpsToRay[1574] = 1000000004635214056836000869; - bpsToRay[1575] = 1000000004637953682059597074; - bpsToRay[1576] = 1000000004640693070608739463; - bpsToRay[1577] = 1000000004643432222524316813; - bpsToRay[1578] = 1000000004646171137847207302; - bpsToRay[1579] = 1000000004648909816618278519; - bpsToRay[1580] = 1000000004651648258878387462; - bpsToRay[1581] = 1000000004654386464668380549; - bpsToRay[1582] = 1000000004657124434029093614; - bpsToRay[1583] = 1000000004659862167001351915; - bpsToRay[1584] = 1000000004662599663625970138; - bpsToRay[1585] = 1000000004665336923943752398; - bpsToRay[1586] = 1000000004668073947995492244; - bpsToRay[1587] = 1000000004670810735821972662; - bpsToRay[1588] = 1000000004673547287463966083; - bpsToRay[1589] = 1000000004676283602962234377; - bpsToRay[1590] = 1000000004679019682357528867; - bpsToRay[1591] = 1000000004681755525690590328; - bpsToRay[1592] = 1000000004684491133002148989; - bpsToRay[1593] = 1000000004687226504332924539; - bpsToRay[1594] = 1000000004689961639723626131; - bpsToRay[1595] = 1000000004692696539214952384; - bpsToRay[1596] = 1000000004695431202847591388; - bpsToRay[1597] = 1000000004698165630662220707; - bpsToRay[1598] = 1000000004700899822699507381; - bpsToRay[1599] = 1000000004703633779000107935; - bpsToRay[1600] = 1000000004706367499604668374; - bpsToRay[1601] = 1000000004709100984553824197; - bpsToRay[1602] = 1000000004711834233888200390; - bpsToRay[1603] = 1000000004714567247648411439; - bpsToRay[1604] = 1000000004717300025875061327; - bpsToRay[1605] = 1000000004720032568608743539; - bpsToRay[1606] = 1000000004722764875890041071; - bpsToRay[1607] = 1000000004725496947759526424; - bpsToRay[1608] = 1000000004728228784257761617; - bpsToRay[1609] = 1000000004730960385425298185; - bpsToRay[1610] = 1000000004733691751302677184; - bpsToRay[1611] = 1000000004736422881930429194; - bpsToRay[1612] = 1000000004739153777349074326; - bpsToRay[1613] = 1000000004741884437599122219; - bpsToRay[1614] = 1000000004744614862721072050; - bpsToRay[1615] = 1000000004747345052755412536; - bpsToRay[1616] = 1000000004750075007742621934; - bpsToRay[1617] = 1000000004752804727723168051; - bpsToRay[1618] = 1000000004755534212737508240; - bpsToRay[1619] = 1000000004758263462826089409; - bpsToRay[1620] = 1000000004760992478029348025; - bpsToRay[1621] = 1000000004763721258387710114; - bpsToRay[1622] = 1000000004766449803941591267; - bpsToRay[1623] = 1000000004769178114731396642; - bpsToRay[1624] = 1000000004771906190797520968; - bpsToRay[1625] = 1000000004774634032180348552; - bpsToRay[1626] = 1000000004777361638920253278; - bpsToRay[1627] = 1000000004780089011057598610; - bpsToRay[1628] = 1000000004782816148632737601; - bpsToRay[1629] = 1000000004785543051686012893; - bpsToRay[1630] = 1000000004788269720257756721; - bpsToRay[1631] = 1000000004790996154388290915; - bpsToRay[1632] = 1000000004793722354117926905; - bpsToRay[1633] = 1000000004796448319486965728; - bpsToRay[1634] = 1000000004799174050535698027; - bpsToRay[1635] = 1000000004801899547304404054; - bpsToRay[1636] = 1000000004804624809833353677; - bpsToRay[1637] = 1000000004807349838162806381; - bpsToRay[1638] = 1000000004810074632333011275; - bpsToRay[1639] = 1000000004812799192384207089; - bpsToRay[1640] = 1000000004815523518356622187; - bpsToRay[1641] = 1000000004818247610290474561; - bpsToRay[1642] = 1000000004820971468225971842; - bpsToRay[1643] = 1000000004823695092203311297; - bpsToRay[1644] = 1000000004826418482262679840; - bpsToRay[1645] = 1000000004829141638444254028; - bpsToRay[1646] = 1000000004831864560788200070; - bpsToRay[1647] = 1000000004834587249334673829; - bpsToRay[1648] = 1000000004837309704123820822; - bpsToRay[1649] = 1000000004840031925195776232; - bpsToRay[1650] = 1000000004842753912590664903; - bpsToRay[1651] = 1000000004845475666348601346; - bpsToRay[1652] = 1000000004848197186509689746; - bpsToRay[1653] = 1000000004850918473114023962; - bpsToRay[1654] = 1000000004853639526201687531; - bpsToRay[1655] = 1000000004856360345812753672; - bpsToRay[1656] = 1000000004859080931987285289; - bpsToRay[1657] = 1000000004861801284765334978; - bpsToRay[1658] = 1000000004864521404186945026; - bpsToRay[1659] = 1000000004867241290292147414; - bpsToRay[1660] = 1000000004869960943120963825; - bpsToRay[1661] = 1000000004872680362713405646; - bpsToRay[1662] = 1000000004875399549109473969; - bpsToRay[1663] = 1000000004878118502349159596; - bpsToRay[1664] = 1000000004880837222472443046; - bpsToRay[1665] = 1000000004883555709519294552; - bpsToRay[1666] = 1000000004886273963529674069; - bpsToRay[1667] = 1000000004888991984543531278; - bpsToRay[1668] = 1000000004891709772600805585; - bpsToRay[1669] = 1000000004894427327741426131; - bpsToRay[1670] = 1000000004897144650005311787; - bpsToRay[1671] = 1000000004899861739432371169; - bpsToRay[1672] = 1000000004902578596062502630; - bpsToRay[1673] = 1000000004905295219935594269; - bpsToRay[1674] = 1000000004908011611091523937; - bpsToRay[1675] = 1000000004910727769570159235; - bpsToRay[1676] = 1000000004913443695411357522; - bpsToRay[1677] = 1000000004916159388654965915; - bpsToRay[1678] = 1000000004918874849340821294; - bpsToRay[1679] = 1000000004921590077508750306; - bpsToRay[1680] = 1000000004924305073198569369; - bpsToRay[1681] = 1000000004927019836450084674; - bpsToRay[1682] = 1000000004929734367303092189; - bpsToRay[1683] = 1000000004932448665797377662; - bpsToRay[1684] = 1000000004935162731972716627; - bpsToRay[1685] = 1000000004937876565868874403; - bpsToRay[1686] = 1000000004940590167525606103; - bpsToRay[1687] = 1000000004943303536982656633; - bpsToRay[1688] = 1000000004946016674279760695; - bpsToRay[1689] = 1000000004948729579456642798; - bpsToRay[1690] = 1000000004951442252553017251; - bpsToRay[1691] = 1000000004954154693608588174; - bpsToRay[1692] = 1000000004956866902663049499; - bpsToRay[1693] = 1000000004959578879756084972; - bpsToRay[1694] = 1000000004962290624927368160; - bpsToRay[1695] = 1000000004965002138216562451; - bpsToRay[1696] = 1000000004967713419663321060; - bpsToRay[1697] = 1000000004970424469307287030; - bpsToRay[1698] = 1000000004973135287188093241; - bpsToRay[1699] = 1000000004975845873345362402; - bpsToRay[1700] = 1000000004978556227818707070; - bpsToRay[1701] = 1000000004981266350647729640; - bpsToRay[1702] = 1000000004983976241872022356; - bpsToRay[1703] = 1000000004986685901531167312; - bpsToRay[1704] = 1000000004989395329664736455; - bpsToRay[1705] = 1000000004992104526312291591; - bpsToRay[1706] = 1000000004994813491513384383; - bpsToRay[1707] = 1000000004997522225307556365; - bpsToRay[1708] = 1000000005000230727734338930; - bpsToRay[1709] = 1000000005002938998833253350; - bpsToRay[1710] = 1000000005005647038643810765; - bpsToRay[1711] = 1000000005008354847205512199; - bpsToRay[1712] = 1000000005011062424557848553; - bpsToRay[1713] = 1000000005013769770740300614; - bpsToRay[1714] = 1000000005016476885792339060; - bpsToRay[1715] = 1000000005019183769753424457; - bpsToRay[1716] = 1000000005021890422663007268; - bpsToRay[1717] = 1000000005024596844560527854; - bpsToRay[1718] = 1000000005027303035485416482; - bpsToRay[1719] = 1000000005030008995477093319; - bpsToRay[1720] = 1000000005032714724574968444; - bpsToRay[1721] = 1000000005035420222818441850; - bpsToRay[1722] = 1000000005038125490246903442; - bpsToRay[1723] = 1000000005040830526899733047; - bpsToRay[1724] = 1000000005043535332816300415; - bpsToRay[1725] = 1000000005046239908035965222; - bpsToRay[1726] = 1000000005048944252598077073; - bpsToRay[1727] = 1000000005051648366541975506; - bpsToRay[1728] = 1000000005054352249906989998; - bpsToRay[1729] = 1000000005057055902732439961; - bpsToRay[1730] = 1000000005059759325057634757; - bpsToRay[1731] = 1000000005062462516921873690; - bpsToRay[1732] = 1000000005065165478364446016; - bpsToRay[1733] = 1000000005067868209424630945; - bpsToRay[1734] = 1000000005070570710141697643; - bpsToRay[1735] = 1000000005073272980554905239; - bpsToRay[1736] = 1000000005075975020703502822; - bpsToRay[1737] = 1000000005078676830626729453; - bpsToRay[1738] = 1000000005081378410363814160; - bpsToRay[1739] = 1000000005084079759953975947; - bpsToRay[1740] = 1000000005086780879436423797; - bpsToRay[1741] = 1000000005089481768850356672; - bpsToRay[1742] = 1000000005092182428234963519; - bpsToRay[1743] = 1000000005094882857629423273; - bpsToRay[1744] = 1000000005097583057072904861; - bpsToRay[1745] = 1000000005100283026604567203; - bpsToRay[1746] = 1000000005102982766263559220; - bpsToRay[1747] = 1000000005105682276089019831; - bpsToRay[1748] = 1000000005108381556120077964; - bpsToRay[1749] = 1000000005111080606395852551; - bpsToRay[1750] = 1000000005113779426955452540; - bpsToRay[1751] = 1000000005116478017837976890; - bpsToRay[1752] = 1000000005119176379082514583; - bpsToRay[1753] = 1000000005121874510728144619; - bpsToRay[1754] = 1000000005124572412813936025; - bpsToRay[1755] = 1000000005127270085378947858; - bpsToRay[1756] = 1000000005129967528462229205; - bpsToRay[1757] = 1000000005132664742102819189; - bpsToRay[1758] = 1000000005135361726339746974; - bpsToRay[1759] = 1000000005138058481212031762; - bpsToRay[1760] = 1000000005140755006758682806; - bpsToRay[1761] = 1000000005143451303018699404; - bpsToRay[1762] = 1000000005146147370031070909; - bpsToRay[1763] = 1000000005148843207834776727; - bpsToRay[1764] = 1000000005151538816468786327; - bpsToRay[1765] = 1000000005154234195972059237; - bpsToRay[1766] = 1000000005156929346383545054; - bpsToRay[1767] = 1000000005159624267742183441; - bpsToRay[1768] = 1000000005162318960086904137; - bpsToRay[1769] = 1000000005165013423456626957; - bpsToRay[1770] = 1000000005167707657890261792; - bpsToRay[1771] = 1000000005170401663426708619; - bpsToRay[1772] = 1000000005173095440104857501; - bpsToRay[1773] = 1000000005175788987963588589; - bpsToRay[1774] = 1000000005178482307041772129; - bpsToRay[1775] = 1000000005181175397378268462; - bpsToRay[1776] = 1000000005183868259011928028; - bpsToRay[1777] = 1000000005186560891981591373; - bpsToRay[1778] = 1000000005189253296326089147; - bpsToRay[1779] = 1000000005191945472084242108; - bpsToRay[1780] = 1000000005194637419294861132; - bpsToRay[1781] = 1000000005197329137996747207; - bpsToRay[1782] = 1000000005200020628228691445; - bpsToRay[1783] = 1000000005202711890029475077; - bpsToRay[1784] = 1000000005205402923437869462; - bpsToRay[1785] = 1000000005208093728492636093; - bpsToRay[1786] = 1000000005210784305232526588; - bpsToRay[1787] = 1000000005213474653696282710; - bpsToRay[1788] = 1000000005216164773922636357; - bpsToRay[1789] = 1000000005218854665950309569; - bpsToRay[1790] = 1000000005221544329818014540; - bpsToRay[1791] = 1000000005224233765564453606; - bpsToRay[1792] = 1000000005226922973228319260; - bpsToRay[1793] = 1000000005229611952848294151; - bpsToRay[1794] = 1000000005232300704463051089; - bpsToRay[1795] = 1000000005234989228111253046; - bpsToRay[1796] = 1000000005237677523831553161; - bpsToRay[1797] = 1000000005240365591662594745; - bpsToRay[1798] = 1000000005243053431643011277; - bpsToRay[1799] = 1000000005245741043811426420; - bpsToRay[1800] = 1000000005248428428206454010; - bpsToRay[1801] = 1000000005251115584866698073; - bpsToRay[1802] = 1000000005253802513830752815; - bpsToRay[1803] = 1000000005256489215137202638; - bpsToRay[1804] = 1000000005259175688824622133; - bpsToRay[1805] = 1000000005261861934931576089; - bpsToRay[1806] = 1000000005264547953496619496; - bpsToRay[1807] = 1000000005267233744558297546; - bpsToRay[1808] = 1000000005269919308155145638; - bpsToRay[1809] = 1000000005272604644325689381; - bpsToRay[1810] = 1000000005275289753108444598; - bpsToRay[1811] = 1000000005277974634541917328; - bpsToRay[1812] = 1000000005280659288664603827; - bpsToRay[1813] = 1000000005283343715514990579; - bpsToRay[1814] = 1000000005286027915131554292; - bpsToRay[1815] = 1000000005288711887552761904; - bpsToRay[1816] = 1000000005291395632817070587; - bpsToRay[1817] = 1000000005294079150962927745; - bpsToRay[1818] = 1000000005296762442028771030; - bpsToRay[1819] = 1000000005299445506053028330; - bpsToRay[1820] = 1000000005302128343074117781; - bpsToRay[1821] = 1000000005304810953130447770; - bpsToRay[1822] = 1000000005307493336260416936; - bpsToRay[1823] = 1000000005310175492502414174; - bpsToRay[1824] = 1000000005312857421894818640; - bpsToRay[1825] = 1000000005315539124475999751; - bpsToRay[1826] = 1000000005318220600284317191; - bpsToRay[1827] = 1000000005320901849358120913; - bpsToRay[1828] = 1000000005323582871735751141; - bpsToRay[1829] = 1000000005326263667455538381; - bpsToRay[1830] = 1000000005328944236555803409; - bpsToRay[1831] = 1000000005331624579074857293; - bpsToRay[1832] = 1000000005334304695051001381; - bpsToRay[1833] = 1000000005336984584522527310; - bpsToRay[1834] = 1000000005339664247527717012; - bpsToRay[1835] = 1000000005342343684104842714; - bpsToRay[1836] = 1000000005345022894292166942; - bpsToRay[1837] = 1000000005347701878127942522; - bpsToRay[1838] = 1000000005350380635650412590; - bpsToRay[1839] = 1000000005353059166897810586; - bpsToRay[1840] = 1000000005355737471908360264; - bpsToRay[1841] = 1000000005358415550720275695; - bpsToRay[1842] = 1000000005361093403371761268; - bpsToRay[1843] = 1000000005363771029901011690; - bpsToRay[1844] = 1000000005366448430346211998; - bpsToRay[1845] = 1000000005369125604745537555; - bpsToRay[1846] = 1000000005371802553137154057; - bpsToRay[1847] = 1000000005374479275559217533; - bpsToRay[1848] = 1000000005377155772049874353; - bpsToRay[1849] = 1000000005379832042647261225; - bpsToRay[1850] = 1000000005382508087389505206; - bpsToRay[1851] = 1000000005385183906314723696; - bpsToRay[1852] = 1000000005387859499461024450; - bpsToRay[1853] = 1000000005390534866866505578; - bpsToRay[1854] = 1000000005393210008569255543; - bpsToRay[1855] = 1000000005395884924607353174; - bpsToRay[1856] = 1000000005398559615018867662; - bpsToRay[1857] = 1000000005401234079841858566; - bpsToRay[1858] = 1000000005403908319114375815; - bpsToRay[1859] = 1000000005406582332874459714; - bpsToRay[1860] = 1000000005409256121160140942; - bpsToRay[1861] = 1000000005411929684009440562; - bpsToRay[1862] = 1000000005414603021460370019; - bpsToRay[1863] = 1000000005417276133550931144; - bpsToRay[1864] = 1000000005419949020319116161; - bpsToRay[1865] = 1000000005422621681802907685; - bpsToRay[1866] = 1000000005425294118040278729; - bpsToRay[1867] = 1000000005427966329069192704; - bpsToRay[1868] = 1000000005430638314927603428; - bpsToRay[1869] = 1000000005433310075653455121; - bpsToRay[1870] = 1000000005435981611284682417; - bpsToRay[1871] = 1000000005438652921859210358; - bpsToRay[1872] = 1000000005441324007414954408; - bpsToRay[1873] = 1000000005443994867989820443; - bpsToRay[1874] = 1000000005446665503621704769; - bpsToRay[1875] = 1000000005449335914348494113; - bpsToRay[1876] = 1000000005452006100208065634; - bpsToRay[1877] = 1000000005454676061238286919; - bpsToRay[1878] = 1000000005457345797477015996; - bpsToRay[1879] = 1000000005460015308962101327; - bpsToRay[1880] = 1000000005462684595731381818; - bpsToRay[1881] = 1000000005465353657822686822; - bpsToRay[1882] = 1000000005468022495273836134; - bpsToRay[1883] = 1000000005470691108122640009; - bpsToRay[1884] = 1000000005473359496406899150; - bpsToRay[1885] = 1000000005476027660164404723; - bpsToRay[1886] = 1000000005478695599432938350; - bpsToRay[1887] = 1000000005481363314250272121; - bpsToRay[1888] = 1000000005484030804654168594; - bpsToRay[1889] = 1000000005486698070682380795; - bpsToRay[1890] = 1000000005489365112372652227; - bpsToRay[1891] = 1000000005492031929762716867; - bpsToRay[1892] = 1000000005494698522890299176; - bpsToRay[1893] = 1000000005497364891793114096; - bpsToRay[1894] = 1000000005500031036508867056; - bpsToRay[1895] = 1000000005502696957075253978; - bpsToRay[1896] = 1000000005505362653529961273; - bpsToRay[1897] = 1000000005508028125910665852; - bpsToRay[1898] = 1000000005510693374255035122; - bpsToRay[1899] = 1000000005513358398600726996; - bpsToRay[1900] = 1000000005516023198985389892; - bpsToRay[1901] = 1000000005518687775446662738; - bpsToRay[1902] = 1000000005521352128022174972; - bpsToRay[1903] = 1000000005524016256749546550; - bpsToRay[1904] = 1000000005526680161666387944; - bpsToRay[1905] = 1000000005529343842810300151; - bpsToRay[1906] = 1000000005532007300218874693; - bpsToRay[1907] = 1000000005534670533929693618; - bpsToRay[1908] = 1000000005537333543980329507; - bpsToRay[1909] = 1000000005539996330408345474; - bpsToRay[1910] = 1000000005542658893251295174; - bpsToRay[1911] = 1000000005545321232546722802; - bpsToRay[1912] = 1000000005547983348332163094; - bpsToRay[1913] = 1000000005550645240645141338; - bpsToRay[1914] = 1000000005553306909523173370; - bpsToRay[1915] = 1000000005555968355003765580; - bpsToRay[1916] = 1000000005558629577124414915; - bpsToRay[1917] = 1000000005561290575922608882; - bpsToRay[1918] = 1000000005563951351435825552; - bpsToRay[1919] = 1000000005566611903701533560; - bpsToRay[1920] = 1000000005569272232757192116; - bpsToRay[1921] = 1000000005571932338640250996; - bpsToRay[1922] = 1000000005574592221388150557; - bpsToRay[1923] = 1000000005577251881038321732; - bpsToRay[1924] = 1000000005579911317628186037; - bpsToRay[1925] = 1000000005582570531195155575; - bpsToRay[1926] = 1000000005585229521776633037; - bpsToRay[1927] = 1000000005587888289410011703; - bpsToRay[1928] = 1000000005590546834132675450; - bpsToRay[1929] = 1000000005593205155981998754; - bpsToRay[1930] = 1000000005595863254995346690; - bpsToRay[1931] = 1000000005598521131210074940; - bpsToRay[1932] = 1000000005601178784663529791; - bpsToRay[1933] = 1000000005603836215393048140; - bpsToRay[1934] = 1000000005606493423435957501; - bpsToRay[1935] = 1000000005609150408829576003; - bpsToRay[1936] = 1000000005611807171611212394; - bpsToRay[1937] = 1000000005614463711818166047; - bpsToRay[1938] = 1000000005617120029487726961; - bpsToRay[1939] = 1000000005619776124657175764; - bpsToRay[1940] = 1000000005622431997363783716; - bpsToRay[1941] = 1000000005625087647644812714; - bpsToRay[1942] = 1000000005627743075537515294; - bpsToRay[1943] = 1000000005630398281079134633; - bpsToRay[1944] = 1000000005633053264306904553; - bpsToRay[1945] = 1000000005635708025258049526; - bpsToRay[1946] = 1000000005638362563969784673; - bpsToRay[1947] = 1000000005641016880479315773; - bpsToRay[1948] = 1000000005643670974823839258; - bpsToRay[1949] = 1000000005646324847040542225; - bpsToRay[1950] = 1000000005648978497166602432; - bpsToRay[1951] = 1000000005651631925239188307; - bpsToRay[1952] = 1000000005654285131295458945; - bpsToRay[1953] = 1000000005656938115372564118; - bpsToRay[1954] = 1000000005659590877507644269; - bpsToRay[1955] = 1000000005662243417737830528; - bpsToRay[1956] = 1000000005664895736100244700; - bpsToRay[1957] = 1000000005667547832631999280; - bpsToRay[1958] = 1000000005670199707370197452; - bpsToRay[1959] = 1000000005672851360351933092; - bpsToRay[1960] = 1000000005675502791614290768; - bpsToRay[1961] = 1000000005678154001194345751; - bpsToRay[1962] = 1000000005680804989129164009; - bpsToRay[1963] = 1000000005683455755455802217; - bpsToRay[1964] = 1000000005686106300211307757; - bpsToRay[1965] = 1000000005688756623432718721; - bpsToRay[1966] = 1000000005691406725157063918; - bpsToRay[1967] = 1000000005694056605421362868; - bpsToRay[1968] = 1000000005696706264262625816; - bpsToRay[1969] = 1000000005699355701717853726; - bpsToRay[1970] = 1000000005702004917824038294; - bpsToRay[1971] = 1000000005704653912618161941; - bpsToRay[1972] = 1000000005707302686137197819; - bpsToRay[1973] = 1000000005709951238418109820; - bpsToRay[1974] = 1000000005712599569497852572; - bpsToRay[1975] = 1000000005715247679413371444; - bpsToRay[1976] = 1000000005717895568201602551; - bpsToRay[1977] = 1000000005720543235899472755; - bpsToRay[1978] = 1000000005723190682543899670; - bpsToRay[1979] = 1000000005725837908171791664; - bpsToRay[1980] = 1000000005728484912820047862; - bpsToRay[1981] = 1000000005731131696525558147; - bpsToRay[1982] = 1000000005733778259325203169; - bpsToRay[1983] = 1000000005736424601255854342; - bpsToRay[1984] = 1000000005739070722354373849; - bpsToRay[1985] = 1000000005741716622657614647; - bpsToRay[1986] = 1000000005744362302202420469; - bpsToRay[1987] = 1000000005747007761025625824; - bpsToRay[1988] = 1000000005749652999164056007; - bpsToRay[1989] = 1000000005752298016654527093; - bpsToRay[1990] = 1000000005754942813533845949; - bpsToRay[1991] = 1000000005757587389838810231; - bpsToRay[1992] = 1000000005760231745606208388; - bpsToRay[1993] = 1000000005762875880872819670; - bpsToRay[1994] = 1000000005765519795675414123; - bpsToRay[1995] = 1000000005768163490050752599; - bpsToRay[1996] = 1000000005770806964035586754; - bpsToRay[1997] = 1000000005773450217666659055; - bpsToRay[1998] = 1000000005776093250980702782; - bpsToRay[1999] = 1000000005778736064014442030; - bpsToRay[2000] = 1000000005781378656804591712; - bpsToRay[2001] = 1000000005784021029387857563; - bpsToRay[2002] = 1000000005786663181800936142; - bpsToRay[2003] = 1000000005789305114080514838; - bpsToRay[2004] = 1000000005791946826263271867; - bpsToRay[2005] = 1000000005794588318385876283; - bpsToRay[2006] = 1000000005797229590484987975; - bpsToRay[2007] = 1000000005799870642597257672; - bpsToRay[2008] = 1000000005802511474759326946; - bpsToRay[2009] = 1000000005805152087007828215; - bpsToRay[2010] = 1000000005807792479379384747; - bpsToRay[2011] = 1000000005810432651910610661; - bpsToRay[2012] = 1000000005813072604638110932; - bpsToRay[2013] = 1000000005815712337598481393; - bpsToRay[2014] = 1000000005818351850828308739; - bpsToRay[2015] = 1000000005820991144364170528; - bpsToRay[2016] = 1000000005823630218242635187; - bpsToRay[2017] = 1000000005826269072500262012; - bpsToRay[2018] = 1000000005828907707173601173; - bpsToRay[2019] = 1000000005831546122299193718; - bpsToRay[2020] = 1000000005834184317913571571; - bpsToRay[2021] = 1000000005836822294053257542; - bpsToRay[2022] = 1000000005839460050754765326; - bpsToRay[2023] = 1000000005842097588054599505; - bpsToRay[2024] = 1000000005844734905989255555; - bpsToRay[2025] = 1000000005847372004595219844; - bpsToRay[2026] = 1000000005850008883908969641; - bpsToRay[2027] = 1000000005852645543966973112; - bpsToRay[2028] = 1000000005855281984805689330; - bpsToRay[2029] = 1000000005857918206461568274; - bpsToRay[2030] = 1000000005860554208971050832; - bpsToRay[2031] = 1000000005863189992370568806; - bpsToRay[2032] = 1000000005865825556696544911; - bpsToRay[2033] = 1000000005868460901985392786; - bpsToRay[2034] = 1000000005871096028273516989; - bpsToRay[2035] = 1000000005873730935597313001; - bpsToRay[2036] = 1000000005876365623993167233; - bpsToRay[2037] = 1000000005879000093497457030; - bpsToRay[2038] = 1000000005881634344146550666; - bpsToRay[2039] = 1000000005884268375976807354; - bpsToRay[2040] = 1000000005886902189024577248; - bpsToRay[2041] = 1000000005889535783326201442; - bpsToRay[2042] = 1000000005892169158918011981; - bpsToRay[2043] = 1000000005894802315836331854; - bpsToRay[2044] = 1000000005897435254117475004; - bpsToRay[2045] = 1000000005900067973797746332; - bpsToRay[2046] = 1000000005902700474913441692; - bpsToRay[2047] = 1000000005905332757500847901; - bpsToRay[2048] = 1000000005907964821596242742; - bpsToRay[2049] = 1000000005910596667235894964; - bpsToRay[2050] = 1000000005913228294456064283; - bpsToRay[2051] = 1000000005915859703293001393; - bpsToRay[2052] = 1000000005918490893782947960; - bpsToRay[2053] = 1000000005921121865962136632; - bpsToRay[2054] = 1000000005923752619866791038; - bpsToRay[2055] = 1000000005926383155533125790; - bpsToRay[2056] = 1000000005929013472997346492; - bpsToRay[2057] = 1000000005931643572295649735; - bpsToRay[2058] = 1000000005934273453464223108; - bpsToRay[2059] = 1000000005936903116539245192; - bpsToRay[2060] = 1000000005939532561556885575; - bpsToRay[2061] = 1000000005942161788553304839; - bpsToRay[2062] = 1000000005944790797564654580; - bpsToRay[2063] = 1000000005947419588627077399; - bpsToRay[2064] = 1000000005950048161776706909; - bpsToRay[2065] = 1000000005952676517049667739; - bpsToRay[2066] = 1000000005955304654482075535; - bpsToRay[2067] = 1000000005957932574110036965; - bpsToRay[2068] = 1000000005960560275969649719; - bpsToRay[2069] = 1000000005963187760097002515; - bpsToRay[2070] = 1000000005965815026528175101; - bpsToRay[2071] = 1000000005968442075299238258; - bpsToRay[2072] = 1000000005971068906446253801; - bpsToRay[2073] = 1000000005973695520005274585; - bpsToRay[2074] = 1000000005976321916012344506; - bpsToRay[2075] = 1000000005978948094503498507; - bpsToRay[2076] = 1000000005981574055514762574; - bpsToRay[2077] = 1000000005984199799082153748; - bpsToRay[2078] = 1000000005986825325241680120; - bpsToRay[2079] = 1000000005989450634029340842; - bpsToRay[2080] = 1000000005992075725481126120; - bpsToRay[2081] = 1000000005994700599633017225; - bpsToRay[2082] = 1000000005997325256520986496; - bpsToRay[2083] = 1000000005999949696180997335; - bpsToRay[2084] = 1000000006002573918649004220; - bpsToRay[2085] = 1000000006005197923960952699; - bpsToRay[2086] = 1000000006007821712152779401; - bpsToRay[2087] = 1000000006010445283260412034; - bpsToRay[2088] = 1000000006013068637319769388; - bpsToRay[2089] = 1000000006015691774366761338; - bpsToRay[2090] = 1000000006018314694437288852; - bpsToRay[2091] = 1000000006020937397567243987; - bpsToRay[2092] = 1000000006023559883792509896; - bpsToRay[2093] = 1000000006026182153148960829; - bpsToRay[2094] = 1000000006028804205672462137; - bpsToRay[2095] = 1000000006031426041398870273; - bpsToRay[2096] = 1000000006034047660364032802; - bpsToRay[2097] = 1000000006036669062603788392; - bpsToRay[2098] = 1000000006039290248153966829; - bpsToRay[2099] = 1000000006041911217050389011; - bpsToRay[2100] = 1000000006044531969328866955; - bpsToRay[2101] = 1000000006047152505025203801; - bpsToRay[2102] = 1000000006049772824175193813; - bpsToRay[2103] = 1000000006052392926814622379; - bpsToRay[2104] = 1000000006055012812979266021; - bpsToRay[2105] = 1000000006057632482704892392; - bpsToRay[2106] = 1000000006060251936027260282; - bpsToRay[2107] = 1000000006062871172982119621; - bpsToRay[2108] = 1000000006065490193605211477; - bpsToRay[2109] = 1000000006068108997932268067; - bpsToRay[2110] = 1000000006070727585999012755; - bpsToRay[2111] = 1000000006073345957841160052; - bpsToRay[2112] = 1000000006075964113494415626; - bpsToRay[2113] = 1000000006078582052994476301; - bpsToRay[2114] = 1000000006081199776377030061; - bpsToRay[2115] = 1000000006083817283677756050; - bpsToRay[2116] = 1000000006086434574932324580; - bpsToRay[2117] = 1000000006089051650176397130; - bpsToRay[2118] = 1000000006091668509445626349; - bpsToRay[2119] = 1000000006094285152775656060; - bpsToRay[2120] = 1000000006096901580202121266; - bpsToRay[2121] = 1000000006099517791760648147; - bpsToRay[2122] = 1000000006102133787486854066; - bpsToRay[2123] = 1000000006104749567416347572; - bpsToRay[2124] = 1000000006107365131584728403; - bpsToRay[2125] = 1000000006109980480027587488; - bpsToRay[2126] = 1000000006112595612780506950; - bpsToRay[2127] = 1000000006115210529879060111; - bpsToRay[2128] = 1000000006117825231358811489; - bpsToRay[2129] = 1000000006120439717255316811; - bpsToRay[2130] = 1000000006123053987604123006; - bpsToRay[2131] = 1000000006125668042440768211; - bpsToRay[2132] = 1000000006128281881800781778; - bpsToRay[2133] = 1000000006130895505719684273; - bpsToRay[2134] = 1000000006133508914232987477; - bpsToRay[2135] = 1000000006136122107376194395; - bpsToRay[2136] = 1000000006138735085184799252; - bpsToRay[2137] = 1000000006141347847694287501; - bpsToRay[2138] = 1000000006143960394940135825; - bpsToRay[2139] = 1000000006146572726957812137; - bpsToRay[2140] = 1000000006149184843782775586; - bpsToRay[2141] = 1000000006151796745450476560; - bpsToRay[2142] = 1000000006154408431996356685; - bpsToRay[2143] = 1000000006157019903455848831; - bpsToRay[2144] = 1000000006159631159864377117; - bpsToRay[2145] = 1000000006162242201257356911; - bpsToRay[2146] = 1000000006164853027670194829; - bpsToRay[2147] = 1000000006167463639138288746; - bpsToRay[2148] = 1000000006170074035697027796; - bpsToRay[2149] = 1000000006172684217381792370; - bpsToRay[2150] = 1000000006175294184227954125; - bpsToRay[2151] = 1000000006177903936270875985; - bpsToRay[2152] = 1000000006180513473545912141; - bpsToRay[2153] = 1000000006183122796088408060; - bpsToRay[2154] = 1000000006185731903933700483; - bpsToRay[2155] = 1000000006188340797117117427; - bpsToRay[2156] = 1000000006190949475673978192; - bpsToRay[2157] = 1000000006193557939639593360; - bpsToRay[2158] = 1000000006196166189049264802; - bpsToRay[2159] = 1000000006198774223938285679; - bpsToRay[2160] = 1000000006201382044341940442; - bpsToRay[2161] = 1000000006203989650295504837; - bpsToRay[2162] = 1000000006206597041834245913; - bpsToRay[2163] = 1000000006209204218993422012; - bpsToRay[2164] = 1000000006211811181808282789; - bpsToRay[2165] = 1000000006214417930314069199; - bpsToRay[2166] = 1000000006217024464546013508; - bpsToRay[2167] = 1000000006219630784539339297; - bpsToRay[2168] = 1000000006222236890329261461; - bpsToRay[2169] = 1000000006224842781950986211; - bpsToRay[2170] = 1000000006227448459439711081; - bpsToRay[2171] = 1000000006230053922830624932; - bpsToRay[2172] = 1000000006232659172158907945; - bpsToRay[2173] = 1000000006235264207459731635; - bpsToRay[2174] = 1000000006237869028768258850; - bpsToRay[2175] = 1000000006240473636119643770; - bpsToRay[2176] = 1000000006243078029549031916; - bpsToRay[2177] = 1000000006245682209091560148; - bpsToRay[2178] = 1000000006248286174782356672; - bpsToRay[2179] = 1000000006250889926656541039; - bpsToRay[2180] = 1000000006253493464749224150; - bpsToRay[2181] = 1000000006256096789095508257; - bpsToRay[2182] = 1000000006258699899730486971; - bpsToRay[2183] = 1000000006261302796689245258; - bpsToRay[2184] = 1000000006263905480006859443; - bpsToRay[2185] = 1000000006266507949718397218; - bpsToRay[2186] = 1000000006269110205858917643; - bpsToRay[2187] = 1000000006271712248463471143; - bpsToRay[2188] = 1000000006274314077567099518; - bpsToRay[2189] = 1000000006276915693204835941; - bpsToRay[2190] = 1000000006279517095411704965; - bpsToRay[2191] = 1000000006282118284222722523; - bpsToRay[2192] = 1000000006284719259672895930; - bpsToRay[2193] = 1000000006287320021797223891; - bpsToRay[2194] = 1000000006289920570630696496; - bpsToRay[2195] = 1000000006292520906208295229; - bpsToRay[2196] = 1000000006295121028564992969; - bpsToRay[2197] = 1000000006297720937735753993; - bpsToRay[2198] = 1000000006300320633755533977; - bpsToRay[2199] = 1000000006302920116659280001; - bpsToRay[2200] = 1000000006305519386481930552; - bpsToRay[2201] = 1000000006308118443258415523; - bpsToRay[2202] = 1000000006310717287023656222; - bpsToRay[2203] = 1000000006313315917812565372; - bpsToRay[2204] = 1000000006315914335660047109; - bpsToRay[2205] = 1000000006318512540600996994; - bpsToRay[2206] = 1000000006321110532670302007; - bpsToRay[2207] = 1000000006323708311902840558; - bpsToRay[2208] = 1000000006326305878333482482; - bpsToRay[2209] = 1000000006328903231997089047; - bpsToRay[2210] = 1000000006331500372928512954; - bpsToRay[2211] = 1000000006334097301162598344; - bpsToRay[2212] = 1000000006336694016734180794; - bpsToRay[2213] = 1000000006339290519678087326; - bpsToRay[2214] = 1000000006341886810029136408; - bpsToRay[2215] = 1000000006344482887822137953; - bpsToRay[2216] = 1000000006347078753091893329; - bpsToRay[2217] = 1000000006349674405873195356; - bpsToRay[2218] = 1000000006352269846200828311; - bpsToRay[2219] = 1000000006354865074109567928; - bpsToRay[2220] = 1000000006357460089634181406; - bpsToRay[2221] = 1000000006360054892809427412; - bpsToRay[2222] = 1000000006362649483670056072; - bpsToRay[2223] = 1000000006365243862250808991; - bpsToRay[2224] = 1000000006367838028586419244; - bpsToRay[2225] = 1000000006370431982711611382; - bpsToRay[2226] = 1000000006373025724661101435; - bpsToRay[2227] = 1000000006375619254469596916; - bpsToRay[2228] = 1000000006378212572171796821; - bpsToRay[2229] = 1000000006380805677802391636; - bpsToRay[2230] = 1000000006383398571396063332; - bpsToRay[2231] = 1000000006385991252987485379; - bpsToRay[2232] = 1000000006388583722611322739; - bpsToRay[2233] = 1000000006391175980302231873; - bpsToRay[2234] = 1000000006393768026094860743; - bpsToRay[2235] = 1000000006396359860023848818; - bpsToRay[2236] = 1000000006398951482123827069; - bpsToRay[2237] = 1000000006401542892429417980; - bpsToRay[2238] = 1000000006404134090975235547; - bpsToRay[2239] = 1000000006406725077795885279; - bpsToRay[2240] = 1000000006409315852925964206; - bpsToRay[2241] = 1000000006411906416400060876; - bpsToRay[2242] = 1000000006414496768252755361; - bpsToRay[2243] = 1000000006417086908518619263; - bpsToRay[2244] = 1000000006419676837232215707; - bpsToRay[2245] = 1000000006422266554428099352; - bpsToRay[2246] = 1000000006424856060140816394; - bpsToRay[2247] = 1000000006427445354404904564; - bpsToRay[2248] = 1000000006430034437254893132; - bpsToRay[2249] = 1000000006432623308725302915; - bpsToRay[2250] = 1000000006435211968850646270; - bpsToRay[2251] = 1000000006437800417665427105; - bpsToRay[2252] = 1000000006440388655204140882; - bpsToRay[2253] = 1000000006442976681501274614; - bpsToRay[2254] = 1000000006445564496591306867; - bpsToRay[2255] = 1000000006448152100508707774; - bpsToRay[2256] = 1000000006450739493287939023; - bpsToRay[2257] = 1000000006453326674963453873; - bpsToRay[2258] = 1000000006455913645569697146; - bpsToRay[2259] = 1000000006458500405141105236; - bpsToRay[2260] = 1000000006461086953712106112; - bpsToRay[2261] = 1000000006463673291317119316; - bpsToRay[2262] = 1000000006466259417990555969; - bpsToRay[2263] = 1000000006468845333766818775; - bpsToRay[2264] = 1000000006471431038680302021; - bpsToRay[2265] = 1000000006474016532765391581; - bpsToRay[2266] = 1000000006476601816056464920; - bpsToRay[2267] = 1000000006479186888587891091; - bpsToRay[2268] = 1000000006481771750394030749; - bpsToRay[2269] = 1000000006484356401509236141; - bpsToRay[2270] = 1000000006486940841967851116; - bpsToRay[2271] = 1000000006489525071804211128; - bpsToRay[2272] = 1000000006492109091052643236; - bpsToRay[2273] = 1000000006494692899747466107; - bpsToRay[2274] = 1000000006497276497922990021; - bpsToRay[2275] = 1000000006499859885613516871; - bpsToRay[2276] = 1000000006502443062853340168; - bpsToRay[2277] = 1000000006505026029676745041; - bpsToRay[2278] = 1000000006507608786118008244; - bpsToRay[2279] = 1000000006510191332211398155; - bpsToRay[2280] = 1000000006512773667991174779; - bpsToRay[2281] = 1000000006515355793491589751; - bpsToRay[2282] = 1000000006517937708746886344; - bpsToRay[2283] = 1000000006520519413791299462; - bpsToRay[2284] = 1000000006523100908659055649; - bpsToRay[2285] = 1000000006525682193384373092; - bpsToRay[2286] = 1000000006528263268001461622; - bpsToRay[2287] = 1000000006530844132544522714; - bpsToRay[2288] = 1000000006533424787047749499; - bpsToRay[2289] = 1000000006536005231545326753; - bpsToRay[2290] = 1000000006538585466071430912; - bpsToRay[2291] = 1000000006541165490660230067; - bpsToRay[2292] = 1000000006543745305345883975; - bpsToRay[2293] = 1000000006546324910162544048; - bpsToRay[2294] = 1000000006548904305144353370; - bpsToRay[2295] = 1000000006551483490325446691; - bpsToRay[2296] = 1000000006554062465739950435; - bpsToRay[2297] = 1000000006556641231421982697; - bpsToRay[2298] = 1000000006559219787405653252; - bpsToRay[2299] = 1000000006561798133725063551; - bpsToRay[2300] = 1000000006564376270414306730; - bpsToRay[2301] = 1000000006566954197507467608; - bpsToRay[2302] = 1000000006569531915038622694; - bpsToRay[2303] = 1000000006572109423041840185; - bpsToRay[2304] = 1000000006574686721551179973; - bpsToRay[2305] = 1000000006577263810600693644; - bpsToRay[2306] = 1000000006579840690224424483; - bpsToRay[2307] = 1000000006582417360456407476; - bpsToRay[2308] = 1000000006584993821330669316; - bpsToRay[2309] = 1000000006587570072881228396; - bpsToRay[2310] = 1000000006590146115142094824; - bpsToRay[2311] = 1000000006592721948147270418; - bpsToRay[2312] = 1000000006595297571930748710; - bpsToRay[2313] = 1000000006597872986526514949; - bpsToRay[2314] = 1000000006600448191968546107; - bpsToRay[2315] = 1000000006603023188290810875; - bpsToRay[2316] = 1000000006605597975527269671; - bpsToRay[2317] = 1000000006608172553711874641; - bpsToRay[2318] = 1000000006610746922878569662; - bpsToRay[2319] = 1000000006613321083061290345; - bpsToRay[2320] = 1000000006615895034293964035; - bpsToRay[2321] = 1000000006618468776610509817; - bpsToRay[2322] = 1000000006621042310044838519; - bpsToRay[2323] = 1000000006623615634630852711; - bpsToRay[2324] = 1000000006626188750402446710; - bpsToRay[2325] = 1000000006628761657393506584; - bpsToRay[2326] = 1000000006631334355637910151; - bpsToRay[2327] = 1000000006633906845169526987; - bpsToRay[2328] = 1000000006636479126022218423; - bpsToRay[2329] = 1000000006639051198229837551; - bpsToRay[2330] = 1000000006641623061826229226; - bpsToRay[2331] = 1000000006644194716845230068; - bpsToRay[2332] = 1000000006646766163320668467; - bpsToRay[2333] = 1000000006649337401286364581; - bpsToRay[2334] = 1000000006651908430776130344; - bpsToRay[2335] = 1000000006654479251823769466; - bpsToRay[2336] = 1000000006657049864463077435; - bpsToRay[2337] = 1000000006659620268727841521; - bpsToRay[2338] = 1000000006662190464651840778; - bpsToRay[2339] = 1000000006664760452268846047; - bpsToRay[2340] = 1000000006667330231612619959; - bpsToRay[2341] = 1000000006669899802716916939; - bpsToRay[2342] = 1000000006672469165615483202; - bpsToRay[2343] = 1000000006675038320342056763; - bpsToRay[2344] = 1000000006677607266930367441; - bpsToRay[2345] = 1000000006680176005414136851; - bpsToRay[2346] = 1000000006682744535827078420; - bpsToRay[2347] = 1000000006685312858202897378; - bpsToRay[2348] = 1000000006687880972575290769; - bpsToRay[2349] = 1000000006690448878977947450; - bpsToRay[2350] = 1000000006693016577444548094; - bpsToRay[2351] = 1000000006695584068008765190; - bpsToRay[2352] = 1000000006698151350704263054; - bpsToRay[2353] = 1000000006700718425564697821; - bpsToRay[2354] = 1000000006703285292623717455; - bpsToRay[2355] = 1000000006705851951914961750; - bpsToRay[2356] = 1000000006708418403472062331; - bpsToRay[2357] = 1000000006710984647328642657; - bpsToRay[2358] = 1000000006713550683518318027; - bpsToRay[2359] = 1000000006716116512074695575; - bpsToRay[2360] = 1000000006718682133031374284; - bpsToRay[2361] = 1000000006721247546421944976; - bpsToRay[2362] = 1000000006723812752279990327; - bpsToRay[2363] = 1000000006726377750639084858; - bpsToRay[2364] = 1000000006728942541532794947; - bpsToRay[2365] = 1000000006731507124994678824; - bpsToRay[2366] = 1000000006734071501058286581; - bpsToRay[2367] = 1000000006736635669757160171; - bpsToRay[2368] = 1000000006739199631124833408; - bpsToRay[2369] = 1000000006741763385194831973; - bpsToRay[2370] = 1000000006744326932000673419; - bpsToRay[2371] = 1000000006746890271575867167; - bpsToRay[2372] = 1000000006749453403953914514; - bpsToRay[2373] = 1000000006752016329168308632; - bpsToRay[2374] = 1000000006754579047252534575; - bpsToRay[2375] = 1000000006757141558240069277; - bpsToRay[2376] = 1000000006759703862164381559; - bpsToRay[2377] = 1000000006762265959058932126; - bpsToRay[2378] = 1000000006764827848957173576; - bpsToRay[2379] = 1000000006767389531892550399; - bpsToRay[2380] = 1000000006769951007898498979; - bpsToRay[2381] = 1000000006772512277008447597; - bpsToRay[2382] = 1000000006775073339255816438; - bpsToRay[2383] = 1000000006777634194674017587; - bpsToRay[2384] = 1000000006780194843296455036; - bpsToRay[2385] = 1000000006782755285156524684; - bpsToRay[2386] = 1000000006785315520287614342; - bpsToRay[2387] = 1000000006787875548723103735; - bpsToRay[2388] = 1000000006790435370496364503; - bpsToRay[2389] = 1000000006792994985640760203; - bpsToRay[2390] = 1000000006795554394189646319; - bpsToRay[2391] = 1000000006798113596176370253; - bpsToRay[2392] = 1000000006800672591634271336; - bpsToRay[2393] = 1000000006803231380596680829; - bpsToRay[2394] = 1000000006805789963096921922; - bpsToRay[2395] = 1000000006808348339168309744; - bpsToRay[2396] = 1000000006810906508844151355; - bpsToRay[2397] = 1000000006813464472157745761; - bpsToRay[2398] = 1000000006816022229142383903; - bpsToRay[2399] = 1000000006818579779831348674; - bpsToRay[2400] = 1000000006821137124257914908; - bpsToRay[2401] = 1000000006823694262455349394; - bpsToRay[2402] = 1000000006826251194456910871; - bpsToRay[2403] = 1000000006828807920295850033; - bpsToRay[2404] = 1000000006831364440005409534; - bpsToRay[2405] = 1000000006833920753618823984; - bpsToRay[2406] = 1000000006836476861169319962; - bpsToRay[2407] = 1000000006839032762690116006; - bpsToRay[2408] = 1000000006841588458214422628; - bpsToRay[2409] = 1000000006844143947775442306; - bpsToRay[2410] = 1000000006846699231406369494; - bpsToRay[2411] = 1000000006849254309140390621; - bpsToRay[2412] = 1000000006851809181010684095; - bpsToRay[2413] = 1000000006854363847050420305; - bpsToRay[2414] = 1000000006856918307292761621; - bpsToRay[2415] = 1000000006859472561770862405; - bpsToRay[2416] = 1000000006862026610517869003; - bpsToRay[2417] = 1000000006864580453566919751; - bpsToRay[2418] = 1000000006867134090951144986; - bpsToRay[2419] = 1000000006869687522703667035; - bpsToRay[2420] = 1000000006872240748857600225; - bpsToRay[2421] = 1000000006874793769446050889; - bpsToRay[2422] = 1000000006877346584502117360; - bpsToRay[2423] = 1000000006879899194058889978; - bpsToRay[2424] = 1000000006882451598149451095; - bpsToRay[2425] = 1000000006885003796806875073; - bpsToRay[2426] = 1000000006887555790064228288; - bpsToRay[2427] = 1000000006890107577954569136; - bpsToRay[2428] = 1000000006892659160510948030; - bpsToRay[2429] = 1000000006895210537766407406; - bpsToRay[2430] = 1000000006897761709753981726; - bpsToRay[2431] = 1000000006900312676506697478; - bpsToRay[2432] = 1000000006902863438057573180; - bpsToRay[2433] = 1000000006905413994439619383; - bpsToRay[2434] = 1000000006907964345685838672; - bpsToRay[2435] = 1000000006910514491829225673; - bpsToRay[2436] = 1000000006913064432902767049; - bpsToRay[2437] = 1000000006915614168939441505; - bpsToRay[2438] = 1000000006918163699972219795; - bpsToRay[2439] = 1000000006920713026034064718; - bpsToRay[2440] = 1000000006923262147157931125; - bpsToRay[2441] = 1000000006925811063376765919; - bpsToRay[2442] = 1000000006928359774723508058; - bpsToRay[2443] = 1000000006930908281231088560; - bpsToRay[2444] = 1000000006933456582932430503; - bpsToRay[2445] = 1000000006936004679860449027; - bpsToRay[2446] = 1000000006938552572048051340; - bpsToRay[2447] = 1000000006941100259528136715; - bpsToRay[2448] = 1000000006943647742333596500; - bpsToRay[2449] = 1000000006946195020497314113; - bpsToRay[2450] = 1000000006948742094052165050; - bpsToRay[2451] = 1000000006951288963031016884; - bpsToRay[2452] = 1000000006953835627466729271; - bpsToRay[2453] = 1000000006956382087392153949; - bpsToRay[2454] = 1000000006958928342840134742; - bpsToRay[2455] = 1000000006961474393843507563; - bpsToRay[2456] = 1000000006964020240435100419; - bpsToRay[2457] = 1000000006966565882647733404; - bpsToRay[2458] = 1000000006969111320514218717; - bpsToRay[2459] = 1000000006971656554067360648; - bpsToRay[2460] = 1000000006974201583339955595; - bpsToRay[2461] = 1000000006976746408364792054; - bpsToRay[2462] = 1000000006979291029174650631; - bpsToRay[2463] = 1000000006981835445802304040; - bpsToRay[2464] = 1000000006984379658280517107; - bpsToRay[2465] = 1000000006986923666642046773; - bpsToRay[2466] = 1000000006989467470919642091; - bpsToRay[2467] = 1000000006992011071146044239; - bpsToRay[2468] = 1000000006994554467353986513; - bpsToRay[2469] = 1000000006997097659576194335; - bpsToRay[2470] = 1000000006999640647845385252; - bpsToRay[2471] = 1000000007002183432194268941; - bpsToRay[2472] = 1000000007004726012655547211; - bpsToRay[2473] = 1000000007007268389261914006; - bpsToRay[2474] = 1000000007009810562046055406; - bpsToRay[2475] = 1000000007012352531040649627; - bpsToRay[2476] = 1000000007014894296278367034; - bpsToRay[2477] = 1000000007017435857791870130; - bpsToRay[2478] = 1000000007019977215613813568; - bpsToRay[2479] = 1000000007022518369776844150; - bpsToRay[2480] = 1000000007025059320313600828; - bpsToRay[2481] = 1000000007027600067256714710; - bpsToRay[2482] = 1000000007030140610638809063; - bpsToRay[2483] = 1000000007032680950492499310; - bpsToRay[2484] = 1000000007035221086850393037; - bpsToRay[2485] = 1000000007037761019745089994; - bpsToRay[2486] = 1000000007040300749209182100; - bpsToRay[2487] = 1000000007042840275275253441; - bpsToRay[2488] = 1000000007045379597975880277; - bpsToRay[2489] = 1000000007047918717343631040; - bpsToRay[2490] = 1000000007050457633411066343; - bpsToRay[2491] = 1000000007052996346210738974; - bpsToRay[2492] = 1000000007055534855775193908; - bpsToRay[2493] = 1000000007058073162136968298; - bpsToRay[2494] = 1000000007060611265328591490; - bpsToRay[2495] = 1000000007063149165382585017; - bpsToRay[2496] = 1000000007065686862331462604; - bpsToRay[2497] = 1000000007068224356207730171; - bpsToRay[2498] = 1000000007070761647043885833; - bpsToRay[2499] = 1000000007073298734872419909; - bpsToRay[2500] = 1000000007075835619725814915; - bpsToRay[2501] = 1000000007078372301636545575; - bpsToRay[2502] = 1000000007080908780637078819; - bpsToRay[2503] = 1000000007083445056759873785; - bpsToRay[2504] = 1000000007085981130037381827; - bpsToRay[2505] = 1000000007088517000502046507; - bpsToRay[2506] = 1000000007091052668186303610; - bpsToRay[2507] = 1000000007093588133122581138; - bpsToRay[2508] = 1000000007096123395343299315; - bpsToRay[2509] = 1000000007098658454880870590; - bpsToRay[2510] = 1000000007101193311767699638; - bpsToRay[2511] = 1000000007103727966036183363; - bpsToRay[2512] = 1000000007106262417718710904; - bpsToRay[2513] = 1000000007108796666847663630; - bpsToRay[2514] = 1000000007111330713455415150; - bpsToRay[2515] = 1000000007113864557574331311; - bpsToRay[2516] = 1000000007116398199236770202; - bpsToRay[2517] = 1000000007118931638475082158; - bpsToRay[2518] = 1000000007121464875321609757; - bpsToRay[2519] = 1000000007123997909808687830; - bpsToRay[2520] = 1000000007126530741968643458; - bpsToRay[2521] = 1000000007129063371833795977; - bpsToRay[2522] = 1000000007131595799436456977; - bpsToRay[2523] = 1000000007134128024808930311; - bpsToRay[2524] = 1000000007136660047983512092; - bpsToRay[2525] = 1000000007139191868992490695; - bpsToRay[2526] = 1000000007141723487868146766; - bpsToRay[2527] = 1000000007144254904642753216; - bpsToRay[2528] = 1000000007146786119348575230; - bpsToRay[2529] = 1000000007149317132017870265; - bpsToRay[2530] = 1000000007151847942682888056; - bpsToRay[2531] = 1000000007154378551375870618; - bpsToRay[2532] = 1000000007156908958129052243; - bpsToRay[2533] = 1000000007159439162974659510; - bpsToRay[2534] = 1000000007161969165944911286; - bpsToRay[2535] = 1000000007164498967072018724; - bpsToRay[2536] = 1000000007167028566388185266; - bpsToRay[2537] = 1000000007169557963925606655; - bpsToRay[2538] = 1000000007172087159716470922; - bpsToRay[2539] = 1000000007174616153792958402; - bpsToRay[2540] = 1000000007177144946187241729; - bpsToRay[2541] = 1000000007179673536931485840; - bpsToRay[2542] = 1000000007182201926057847980; - bpsToRay[2543] = 1000000007184730113598477700; - bpsToRay[2544] = 1000000007187258099585516865; - bpsToRay[2545] = 1000000007189785884051099650; - bpsToRay[2546] = 1000000007192313467027352546; - bpsToRay[2547] = 1000000007194840848546394365; - bpsToRay[2548] = 1000000007197368028640336238; - bpsToRay[2549] = 1000000007199895007341281618; - bpsToRay[2550] = 1000000007202421784681326287; - bpsToRay[2551] = 1000000007204948360692558350; - bpsToRay[2552] = 1000000007207474735407058245; - bpsToRay[2553] = 1000000007210000908856898746; - bpsToRay[2554] = 1000000007212526881074144958; - bpsToRay[2555] = 1000000007215052652090854324; - bpsToRay[2556] = 1000000007217578221939076629; - bpsToRay[2557] = 1000000007220103590650854001; - bpsToRay[2558] = 1000000007222628758258220911; - bpsToRay[2559] = 1000000007225153724793204178; - bpsToRay[2560] = 1000000007227678490287822975; - bpsToRay[2561] = 1000000007230203054774088820; - bpsToRay[2562] = 1000000007232727418284005593; - bpsToRay[2563] = 1000000007235251580849569527; - bpsToRay[2564] = 1000000007237775542502769216; - bpsToRay[2565] = 1000000007240299303275585616; - bpsToRay[2566] = 1000000007242822863199992048; - bpsToRay[2567] = 1000000007245346222307954199; - bpsToRay[2568] = 1000000007247869380631430127; - bpsToRay[2569] = 1000000007250392338202370260; - bpsToRay[2570] = 1000000007252915095052717402; - bpsToRay[2571] = 1000000007255437651214406734; - bpsToRay[2572] = 1000000007257960006719365813; - bpsToRay[2573] = 1000000007260482161599514580; - bpsToRay[2574] = 1000000007263004115886765361; - bpsToRay[2575] = 1000000007265525869613022867; - bpsToRay[2576] = 1000000007268047422810184197; - bpsToRay[2577] = 1000000007270568775510138843; - bpsToRay[2578] = 1000000007273089927744768690; - bpsToRay[2579] = 1000000007275610879545948018; - bpsToRay[2580] = 1000000007278131630945543509; - bpsToRay[2581] = 1000000007280652181975414240; - bpsToRay[2582] = 1000000007283172532667411698; - bpsToRay[2583] = 1000000007285692683053379771; - bpsToRay[2584] = 1000000007288212633165154756; - bpsToRay[2585] = 1000000007290732383034565363; - bpsToRay[2586] = 1000000007293251932693432712; - bpsToRay[2587] = 1000000007295771282173570341; - bpsToRay[2588] = 1000000007298290431506784204; - bpsToRay[2589] = 1000000007300809380724872677; - bpsToRay[2590] = 1000000007303328129859626555; - bpsToRay[2591] = 1000000007305846678942829063; - bpsToRay[2592] = 1000000007308365028006255850; - bpsToRay[2593] = 1000000007310883177081674995; - bpsToRay[2594] = 1000000007313401126200847011; - bpsToRay[2595] = 1000000007315918875395524846; - bpsToRay[2596] = 1000000007318436424697453882; - bpsToRay[2597] = 1000000007320953774138371943; - bpsToRay[2598] = 1000000007323470923750009295; - bpsToRay[2599] = 1000000007325987873564088646; - bpsToRay[2600] = 1000000007328504623612325153; - bpsToRay[2601] = 1000000007331021173926426421; - bpsToRay[2602] = 1000000007333537524538092508; - bpsToRay[2603] = 1000000007336053675479015924; - bpsToRay[2604] = 1000000007338569626780881634; - bpsToRay[2605] = 1000000007341085378475367066; - bpsToRay[2606] = 1000000007343600930594142104; - bpsToRay[2607] = 1000000007346116283168869100; - bpsToRay[2608] = 1000000007348631436231202869; - bpsToRay[2609] = 1000000007351146389812790696; - bpsToRay[2610] = 1000000007353661143945272335; - bpsToRay[2611] = 1000000007356175698660280013; - bpsToRay[2612] = 1000000007358690053989438434; - bpsToRay[2613] = 1000000007361204209964364778; - bpsToRay[2614] = 1000000007363718166616668706; - bpsToRay[2615] = 1000000007366231923977952362; - bpsToRay[2616] = 1000000007368745482079810375; - bpsToRay[2617] = 1000000007371258840953829859; - bpsToRay[2618] = 1000000007373772000631590422; - bpsToRay[2619] = 1000000007376284961144664159; - bpsToRay[2620] = 1000000007378797722524615662; - bpsToRay[2621] = 1000000007381310284803002021; - bpsToRay[2622] = 1000000007383822648011372824; - bpsToRay[2623] = 1000000007386334812181270160; - bpsToRay[2624] = 1000000007388846777344228623; - bpsToRay[2625] = 1000000007391358543531775311; - bpsToRay[2626] = 1000000007393870110775429835; - bpsToRay[2627] = 1000000007396381479106704315; - bpsToRay[2628] = 1000000007398892648557103381; - bpsToRay[2629] = 1000000007401403619158124184; - bpsToRay[2630] = 1000000007403914390941256391; - bpsToRay[2631] = 1000000007406424963937982190; - bpsToRay[2632] = 1000000007408935338179776291; - bpsToRay[2633] = 1000000007411445513698105929; - bpsToRay[2634] = 1000000007413955490524430869; - bpsToRay[2635] = 1000000007416465268690203405; - bpsToRay[2636] = 1000000007418974848226868363; - bpsToRay[2637] = 1000000007421484229165863101; - bpsToRay[2638] = 1000000007423993411538617520; - bpsToRay[2639] = 1000000007426502395376554056; - bpsToRay[2640] = 1000000007429011180711087689; - bpsToRay[2641] = 1000000007431519767573625942; - bpsToRay[2642] = 1000000007434028155995568885; - bpsToRay[2643] = 1000000007436536346008309136; - bpsToRay[2644] = 1000000007439044337643231867; - bpsToRay[2645] = 1000000007441552130931714802; - bpsToRay[2646] = 1000000007444059725905128218; - bpsToRay[2647] = 1000000007446567122594834957; - bpsToRay[2648] = 1000000007449074321032190415; - bpsToRay[2649] = 1000000007451581321248542554; - bpsToRay[2650] = 1000000007454088123275231904; - bpsToRay[2651] = 1000000007456594727143591558; - bpsToRay[2652] = 1000000007459101132884947181; - bpsToRay[2653] = 1000000007461607340530617012; - bpsToRay[2654] = 1000000007464113350111911864; - bpsToRay[2655] = 1000000007466619161660135123; - bpsToRay[2656] = 1000000007469124775206582763; - bpsToRay[2657] = 1000000007471630190782543332; - bpsToRay[2658] = 1000000007474135408419297966; - bpsToRay[2659] = 1000000007476640428148120386; - bpsToRay[2660] = 1000000007479145250000276903; - bpsToRay[2661] = 1000000007481649874007026420; - bpsToRay[2662] = 1000000007484154300199620430; - bpsToRay[2663] = 1000000007486658528609303027; - bpsToRay[2664] = 1000000007489162559267310898; - bpsToRay[2665] = 1000000007491666392204873334; - bpsToRay[2666] = 1000000007494170027453212228; - bpsToRay[2667] = 1000000007496673465043542080; - bpsToRay[2668] = 1000000007499176705007069991; - bpsToRay[2669] = 1000000007501679747374995682; - bpsToRay[2670] = 1000000007504182592178511478; - bpsToRay[2671] = 1000000007506685239448802322; - bpsToRay[2672] = 1000000007509187689217045773; - bpsToRay[2673] = 1000000007511689941514412011; - bpsToRay[2674] = 1000000007514191996372063835; - bpsToRay[2675] = 1000000007516693853821156670; - bpsToRay[2676] = 1000000007519195513892838566; - bpsToRay[2677] = 1000000007521696976618250202; - bpsToRay[2678] = 1000000007524198242028524886; - bpsToRay[2679] = 1000000007526699310154788564; - bpsToRay[2680] = 1000000007529200181028159813; - bpsToRay[2681] = 1000000007531700854679749850; - bpsToRay[2682] = 1000000007534201331140662531; - bpsToRay[2683] = 1000000007536701610441994354; - bpsToRay[2684] = 1000000007539201692614834466; - bpsToRay[2685] = 1000000007541701577690264654; - bpsToRay[2686] = 1000000007544201265699359361; - bpsToRay[2687] = 1000000007546700756673185679; - bpsToRay[2688] = 1000000007549200050642803353; - bpsToRay[2689] = 1000000007551699147639264788; - bpsToRay[2690] = 1000000007554198047693615043; - bpsToRay[2691] = 1000000007556696750836891842; - bpsToRay[2692] = 1000000007559195257100125570; - bpsToRay[2693] = 1000000007561693566514339279; - bpsToRay[2694] = 1000000007564191679110548687; - bpsToRay[2695] = 1000000007566689594919762187; - bpsToRay[2696] = 1000000007569187313972980838; - bpsToRay[2697] = 1000000007571684836301198378; - bpsToRay[2698] = 1000000007574182161935401222; - bpsToRay[2699] = 1000000007576679290906568463; - bpsToRay[2700] = 1000000007579176223245671878; - bpsToRay[2701] = 1000000007581672958983675926; - bpsToRay[2702] = 1000000007584169498151537752; - bpsToRay[2703] = 1000000007586665840780207194; - bpsToRay[2704] = 1000000007589161986900626776; - bpsToRay[2705] = 1000000007591657936543731717; - bpsToRay[2706] = 1000000007594153689740449933; - bpsToRay[2707] = 1000000007596649246521702037; - bpsToRay[2708] = 1000000007599144606918401342; - bpsToRay[2709] = 1000000007601639770961453862; - bpsToRay[2710] = 1000000007604134738681758320; - bpsToRay[2711] = 1000000007606629510110206142; - bpsToRay[2712] = 1000000007609124085277681464; - bpsToRay[2713] = 1000000007611618464215061138; - bpsToRay[2714] = 1000000007614112646953214725; - bpsToRay[2715] = 1000000007616606633523004503; - bpsToRay[2716] = 1000000007619100423955285470; - bpsToRay[2717] = 1000000007621594018280905346; - bpsToRay[2718] = 1000000007624087416530704571; - bpsToRay[2719] = 1000000007626580618735516314; - bpsToRay[2720] = 1000000007629073624926166467; - bpsToRay[2721] = 1000000007631566435133473656; - bpsToRay[2722] = 1000000007634059049388249240; - bpsToRay[2723] = 1000000007636551467721297309; - bpsToRay[2724] = 1000000007639043690163414692; - bpsToRay[2725] = 1000000007641535716745390957; - bpsToRay[2726] = 1000000007644027547498008412; - bpsToRay[2727] = 1000000007646519182452042112; - bpsToRay[2728] = 1000000007649010621638259855; - bpsToRay[2729] = 1000000007651501865087422189; - bpsToRay[2730] = 1000000007653992912830282410; - bpsToRay[2731] = 1000000007656483764897586571; - bpsToRay[2732] = 1000000007658974421320073477; - bpsToRay[2733] = 1000000007661464882128474691; - bpsToRay[2734] = 1000000007663955147353514535; - bpsToRay[2735] = 1000000007666445217025910095; - bpsToRay[2736] = 1000000007668935091176371220; - bpsToRay[2737] = 1000000007671424769835600527; - bpsToRay[2738] = 1000000007673914253034293397; - bpsToRay[2739] = 1000000007676403540803137988; - bpsToRay[2740] = 1000000007678892633172815227; - bpsToRay[2741] = 1000000007681381530173998820; - bpsToRay[2742] = 1000000007683870231837355249; - bpsToRay[2743] = 1000000007686358738193543774; - bpsToRay[2744] = 1000000007688847049273216443; - bpsToRay[2745] = 1000000007691335165107018082; - bpsToRay[2746] = 1000000007693823085725586308; - bpsToRay[2747] = 1000000007696310811159551528; - bpsToRay[2748] = 1000000007698798341439536935; - bpsToRay[2749] = 1000000007701285676596158525; - bpsToRay[2750] = 1000000007703772816660025079; - bpsToRay[2751] = 1000000007706259761661738185; - bpsToRay[2752] = 1000000007708746511631892227; - bpsToRay[2753] = 1000000007711233066601074392; - bpsToRay[2754] = 1000000007713719426599864675; - bpsToRay[2755] = 1000000007716205591658835874; - bpsToRay[2756] = 1000000007718691561808553598; - bpsToRay[2757] = 1000000007721177337079576270; - bpsToRay[2758] = 1000000007723662917502455126; - bpsToRay[2759] = 1000000007726148303107734216; - bpsToRay[2760] = 1000000007728633493925950409; - bpsToRay[2761] = 1000000007731118489987633399; - bpsToRay[2762] = 1000000007733603291323305697; - bpsToRay[2763] = 1000000007736087897963482645; - bpsToRay[2764] = 1000000007738572309938672406; - bpsToRay[2765] = 1000000007741056527279375980; - bpsToRay[2766] = 1000000007743540550016087193; - bpsToRay[2767] = 1000000007746024378179292708; - bpsToRay[2768] = 1000000007748508011799472026; - bpsToRay[2769] = 1000000007750991450907097483; - bpsToRay[2770] = 1000000007753474695532634259; - bpsToRay[2771] = 1000000007755957745706540376; - bpsToRay[2772] = 1000000007758440601459266700; - bpsToRay[2773] = 1000000007760923262821256948; - bpsToRay[2774] = 1000000007763405729822947685; - bpsToRay[2775] = 1000000007765888002494768329; - bpsToRay[2776] = 1000000007768370080867141151; - bpsToRay[2777] = 1000000007770851964970481280; - bpsToRay[2778] = 1000000007773333654835196703; - bpsToRay[2779] = 1000000007775815150491688269; - bpsToRay[2780] = 1000000007778296451970349690; - bpsToRay[2781] = 1000000007780777559301567543; - bpsToRay[2782] = 1000000007783258472515721274; - bpsToRay[2783] = 1000000007785739191643183199; - bpsToRay[2784] = 1000000007788219716714318505; - bpsToRay[2785] = 1000000007790700047759485254; - bpsToRay[2786] = 1000000007793180184809034386; - bpsToRay[2787] = 1000000007795660127893309718; - bpsToRay[2788] = 1000000007798139877042647950; - bpsToRay[2789] = 1000000007800619432287378665; - bpsToRay[2790] = 1000000007803098793657824331; - bpsToRay[2791] = 1000000007805577961184300304; - bpsToRay[2792] = 1000000007808056934897114831; - bpsToRay[2793] = 1000000007810535714826569051; - bpsToRay[2794] = 1000000007813014301002956995; - bpsToRay[2795] = 1000000007815492693456565596; - bpsToRay[2796] = 1000000007817970892217674682; - bpsToRay[2797] = 1000000007820448897316556983; - bpsToRay[2798] = 1000000007822926708783478132; - bpsToRay[2799] = 1000000007825404326648696672; - bpsToRay[2800] = 1000000007827881750942464045; - bpsToRay[2801] = 1000000007830358981695024613; - bpsToRay[2802] = 1000000007832836018936615642; - bpsToRay[2803] = 1000000007835312862697467319; - bpsToRay[2804] = 1000000007837789513007802744; - bpsToRay[2805] = 1000000007840265969897837937; - bpsToRay[2806] = 1000000007842742233397781838; - bpsToRay[2807] = 1000000007845218303537836314; - bpsToRay[2808] = 1000000007847694180348196153; - bpsToRay[2809] = 1000000007850169863859049072; - bpsToRay[2810] = 1000000007852645354100575721; - bpsToRay[2811] = 1000000007855120651102949679; - bpsToRay[2812] = 1000000007857595754896337460; - bpsToRay[2813] = 1000000007860070665510898517; - bpsToRay[2814] = 1000000007862545382976785237; - bpsToRay[2815] = 1000000007865019907324142954; - bpsToRay[2816] = 1000000007867494238583109939; - bpsToRay[2817] = 1000000007869968376783817414; - bpsToRay[2818] = 1000000007872442321956389545; - bpsToRay[2819] = 1000000007874916074130943450; - bpsToRay[2820] = 1000000007877389633337589198; - bpsToRay[2821] = 1000000007879862999606429812; - bpsToRay[2822] = 1000000007882336172967561271; - bpsToRay[2823] = 1000000007884809153451072514; - bpsToRay[2824] = 1000000007887281941087045441; - bpsToRay[2825] = 1000000007889754535905554913; - bpsToRay[2826] = 1000000007892226937936668759; - bpsToRay[2827] = 1000000007894699147210447772; - bpsToRay[2828] = 1000000007897171163756945718; - bpsToRay[2829] = 1000000007899642987606209333; - bpsToRay[2830] = 1000000007902114618788278327; - bpsToRay[2831] = 1000000007904586057333185387; - bpsToRay[2832] = 1000000007907057303270956176; - bpsToRay[2833] = 1000000007909528356631609343; - bpsToRay[2834] = 1000000007911999217445156512; - bpsToRay[2835] = 1000000007914469885741602299; - bpsToRay[2836] = 1000000007916940361550944303; - bpsToRay[2837] = 1000000007919410644903173113; - bpsToRay[2838] = 1000000007921880735828272312; - bpsToRay[2839] = 1000000007924350634356218473; - bpsToRay[2840] = 1000000007926820340516981166; - bpsToRay[2841] = 1000000007929289854340522961; - bpsToRay[2842] = 1000000007931759175856799426; - bpsToRay[2843] = 1000000007934228305095759133; - bpsToRay[2844] = 1000000007936697242087343656; - bpsToRay[2845] = 1000000007939165986861487579; - bpsToRay[2846] = 1000000007941634539448118494; - bpsToRay[2847] = 1000000007944102899877157001; - bpsToRay[2848] = 1000000007946571068178516718; - bpsToRay[2849] = 1000000007949039044382104276; - bpsToRay[2850] = 1000000007951506828517819323; - bpsToRay[2851] = 1000000007953974420615554529; - bpsToRay[2852] = 1000000007956441820705195583; - bpsToRay[2853] = 1000000007958909028816621201; - bpsToRay[2854] = 1000000007961376044979703124; - bpsToRay[2855] = 1000000007963842869224306123; - bpsToRay[2856] = 1000000007966309501580287995; - bpsToRay[2857] = 1000000007968775942077499577; - bpsToRay[2858] = 1000000007971242190745784735; - bpsToRay[2859] = 1000000007973708247614980375; - bpsToRay[2860] = 1000000007976174112714916441; - bpsToRay[2861] = 1000000007978639786075415919; - bpsToRay[2862] = 1000000007981105267726294840; - bpsToRay[2863] = 1000000007983570557697362280; - bpsToRay[2864] = 1000000007986035656018420361; - bpsToRay[2865] = 1000000007988500562719264258; - bpsToRay[2866] = 1000000007990965277829682196; - bpsToRay[2867] = 1000000007993429801379455456; - bpsToRay[2868] = 1000000007995894133398358376; - bpsToRay[2869] = 1000000007998358273916158351; - bpsToRay[2870] = 1000000008000822222962615839; - bpsToRay[2871] = 1000000008003285980567484358; - bpsToRay[2872] = 1000000008005749546760510496; - bpsToRay[2873] = 1000000008008212921571433904; - bpsToRay[2874] = 1000000008010676105029987304; - bpsToRay[2875] = 1000000008013139097165896490; - bpsToRay[2876] = 1000000008015601898008880332; - bpsToRay[2877] = 1000000008018064507588650772; - bpsToRay[2878] = 1000000008020526925934912831; - bpsToRay[2879] = 1000000008022989153077364614; - bpsToRay[2880] = 1000000008025451189045697303; - bpsToRay[2881] = 1000000008027913033869595170; - bpsToRay[2882] = 1000000008030374687578735570; - bpsToRay[2883] = 1000000008032836150202788948; - bpsToRay[2884] = 1000000008035297421771418841; - bpsToRay[2885] = 1000000008037758502314281877; - bpsToRay[2886] = 1000000008040219391861027783; - bpsToRay[2887] = 1000000008042680090441299379; - bpsToRay[2888] = 1000000008045140598084732587; - bpsToRay[2889] = 1000000008047600914820956433; - bpsToRay[2890] = 1000000008050061040679593042; - bpsToRay[2891] = 1000000008052520975690257649; - bpsToRay[2892] = 1000000008054980719882558595; - bpsToRay[2893] = 1000000008057440273286097333; - bpsToRay[2894] = 1000000008059899635930468427; - bpsToRay[2895] = 1000000008062358807845259556; - bpsToRay[2896] = 1000000008064817789060051517; - bpsToRay[2897] = 1000000008067276579604418223; - bpsToRay[2898] = 1000000008069735179507926713; - bpsToRay[2899] = 1000000008072193588800137143; - bpsToRay[2900] = 1000000008074651807510602798; - bpsToRay[2901] = 1000000008077109835668870091; - bpsToRay[2902] = 1000000008079567673304478561; - bpsToRay[2903] = 1000000008082025320446960884; - bpsToRay[2904] = 1000000008084482777125842863; - bpsToRay[2905] = 1000000008086940043370643444; - bpsToRay[2906] = 1000000008089397119210874706; - bpsToRay[2907] = 1000000008091854004676041869; - bpsToRay[2908] = 1000000008094310699795643299; - bpsToRay[2909] = 1000000008096767204599170500; - bpsToRay[2910] = 1000000008099223519116108130; - bpsToRay[2911] = 1000000008101679643375933989; - bpsToRay[2912] = 1000000008104135577408119032; - bpsToRay[2913] = 1000000008106591321242127364; - bpsToRay[2914] = 1000000008109046874907416248; - bpsToRay[2915] = 1000000008111502238433436104; - bpsToRay[2916] = 1000000008113957411849630507; - bpsToRay[2917] = 1000000008116412395185436200; - bpsToRay[2918] = 1000000008118867188470283082; - bpsToRay[2919] = 1000000008121321791733594224; - bpsToRay[2920] = 1000000008123776205004785863; - bpsToRay[2921] = 1000000008126230428313267405; - bpsToRay[2922] = 1000000008128684461688441426; - bpsToRay[2923] = 1000000008131138305159703681; - bpsToRay[2924] = 1000000008133591958756443098; - bpsToRay[2925] = 1000000008136045422508041783; - bpsToRay[2926] = 1000000008138498696443875023; - bpsToRay[2927] = 1000000008140951780593311289; - bpsToRay[2928] = 1000000008143404674985712235; - bpsToRay[2929] = 1000000008145857379650432701; - bpsToRay[2930] = 1000000008148309894616820721; - bpsToRay[2931] = 1000000008150762219914217511; - bpsToRay[2932] = 1000000008153214355571957489; - bpsToRay[2933] = 1000000008155666301619368262; - bpsToRay[2934] = 1000000008158118058085770639; - bpsToRay[2935] = 1000000008160569625000478625; - bpsToRay[2936] = 1000000008163021002392799426; - bpsToRay[2937] = 1000000008165472190292033455; - bpsToRay[2938] = 1000000008167923188727474329; - bpsToRay[2939] = 1000000008170373997728408871; - bpsToRay[2940] = 1000000008172824617324117117; - bpsToRay[2941] = 1000000008175275047543872314; - bpsToRay[2942] = 1000000008177725288416940921; - bpsToRay[2943] = 1000000008180175339972582615; - bpsToRay[2944] = 1000000008182625202240050293; - bpsToRay[2945] = 1000000008185074875248590068; - bpsToRay[2946] = 1000000008187524359027441281; - bpsToRay[2947] = 1000000008189973653605836492; - bpsToRay[2948] = 1000000008192422759013001491; - bpsToRay[2949] = 1000000008194871675278155297; - bpsToRay[2950] = 1000000008197320402430510158; - bpsToRay[2951] = 1000000008199768940499271556; - bpsToRay[2952] = 1000000008202217289513638208; - bpsToRay[2953] = 1000000008204665449502802068; - bpsToRay[2954] = 1000000008207113420495948328; - bpsToRay[2955] = 1000000008209561202522255424; - bpsToRay[2956] = 1000000008212008795610895033; - bpsToRay[2957] = 1000000008214456199791032080; - bpsToRay[2958] = 1000000008216903415091824734; - bpsToRay[2959] = 1000000008219350441542424416; - bpsToRay[2960] = 1000000008221797279171975799; - bpsToRay[2961] = 1000000008224243928009616809; - bpsToRay[2962] = 1000000008226690388084478627; - bpsToRay[2963] = 1000000008229136659425685693; - bpsToRay[2964] = 1000000008231582742062355709; - bpsToRay[2965] = 1000000008234028636023599636; - bpsToRay[2966] = 1000000008236474341338521699; - bpsToRay[2967] = 1000000008238919858036219393; - bpsToRay[2968] = 1000000008241365186145783477; - bpsToRay[2969] = 1000000008243810325696297983; - bpsToRay[2970] = 1000000008246255276716840215; - bpsToRay[2971] = 1000000008248700039236480752; - bpsToRay[2972] = 1000000008251144613284283449; - bpsToRay[2973] = 1000000008253588998889305439; - bpsToRay[2974] = 1000000008256033196080597139; - bpsToRay[2975] = 1000000008258477204887202245; - bpsToRay[2976] = 1000000008260921025338157740; - bpsToRay[2977] = 1000000008263364657462493893; - bpsToRay[2978] = 1000000008265808101289234264; - bpsToRay[2979] = 1000000008268251356847395701; - bpsToRay[2980] = 1000000008270694424165988349; - bpsToRay[2981] = 1000000008273137303274015646; - bpsToRay[2982] = 1000000008275579994200474327; - bpsToRay[2983] = 1000000008278022496974354428; - bpsToRay[2984] = 1000000008280464811624639285; - bpsToRay[2985] = 1000000008282906938180305537; - bpsToRay[2986] = 1000000008285348876670323134; - bpsToRay[2987] = 1000000008287790627123655325; - bpsToRay[2988] = 1000000008290232189569258676; - bpsToRay[2989] = 1000000008292673564036083061; - bpsToRay[2990] = 1000000008295114750553071670; - bpsToRay[2991] = 1000000008297555749149161005; - bpsToRay[2992] = 1000000008299996559853280893; - bpsToRay[2993] = 1000000008302437182694354473; - bpsToRay[2994] = 1000000008304877617701298212; - bpsToRay[2995] = 1000000008307317864903021899; - bpsToRay[2996] = 1000000008309757924328428649; - bpsToRay[2997] = 1000000008312197796006414905; - bpsToRay[2998] = 1000000008314637479965870443; - bpsToRay[2999] = 1000000008317076976235678365; - bpsToRay[3000] = 1000000008319516284844715115; - bpsToRay[3001] = 1000000008321955405821850471; - bpsToRay[3002] = 1000000008324394339195947545; - bpsToRay[3003] = 1000000008326833084995862796; - bpsToRay[3004] = 1000000008329271643250446021; - bpsToRay[3005] = 1000000008331710013988540364; - bpsToRay[3006] = 1000000008334148197238982316; - bpsToRay[3007] = 1000000008336586193030601715; - bpsToRay[3008] = 1000000008339024001392221751; - bpsToRay[3009] = 1000000008341461622352658967; - bpsToRay[3010] = 1000000008343899055940723259; - bpsToRay[3011] = 1000000008346336302185217882; - bpsToRay[3012] = 1000000008348773361114939450; - bpsToRay[3013] = 1000000008351210232758677936; - bpsToRay[3014] = 1000000008353646917145216679; - bpsToRay[3015] = 1000000008356083414303332380; - bpsToRay[3016] = 1000000008358519724261795110; - bpsToRay[3017] = 1000000008360955847049368306; - bpsToRay[3018] = 1000000008363391782694808779; - bpsToRay[3019] = 1000000008365827531226866712; - bpsToRay[3020] = 1000000008368263092674285664; - bpsToRay[3021] = 1000000008370698467065802570; - bpsToRay[3022] = 1000000008373133654430147746; - bpsToRay[3023] = 1000000008375568654796044887; - bpsToRay[3024] = 1000000008378003468192211075; - bpsToRay[3025] = 1000000008380438094647356774; - bpsToRay[3026] = 1000000008382872534190185837; - bpsToRay[3027] = 1000000008385306786849395508; - bpsToRay[3028] = 1000000008387740852653676418; - bpsToRay[3029] = 1000000008390174731631712596; - bpsToRay[3030] = 1000000008392608423812181466; - bpsToRay[3031] = 1000000008395041929223753848; - bpsToRay[3032] = 1000000008397475247895093962; - bpsToRay[3033] = 1000000008399908379854859430; - bpsToRay[3034] = 1000000008402341325131701278; - bpsToRay[3035] = 1000000008404774083754263937; - bpsToRay[3036] = 1000000008407206655751185247; - bpsToRay[3037] = 1000000008409639041151096456; - bpsToRay[3038] = 1000000008412071239982622226; - bpsToRay[3039] = 1000000008414503252274380631; - bpsToRay[3040] = 1000000008416935078054983162; - bpsToRay[3041] = 1000000008419366717353034726; - bpsToRay[3042] = 1000000008421798170197133652; - bpsToRay[3043] = 1000000008424229436615871690; - bpsToRay[3044] = 1000000008426660516637834013; - bpsToRay[3045] = 1000000008429091410291599222; - bpsToRay[3046] = 1000000008431522117605739346; - bpsToRay[3047] = 1000000008433952638608819840; - bpsToRay[3048] = 1000000008436382973329399595; - bpsToRay[3049] = 1000000008438813121796030934; - bpsToRay[3050] = 1000000008441243084037259619; - bpsToRay[3051] = 1000000008443672860081624846; - bpsToRay[3052] = 1000000008446102449957659252; - bpsToRay[3053] = 1000000008448531853693888919; - bpsToRay[3054] = 1000000008450961071318833369; - bpsToRay[3055] = 1000000008453390102861005572; - bpsToRay[3056] = 1000000008455818948348911946; - bpsToRay[3057] = 1000000008458247607811052360; - bpsToRay[3058] = 1000000008460676081275920133; - bpsToRay[3059] = 1000000008463104368772002040; - bpsToRay[3060] = 1000000008465532470327778310; - bpsToRay[3061] = 1000000008467960385971722632; - bpsToRay[3062] = 1000000008470388115732302154; - bpsToRay[3063] = 1000000008472815659637977489; - bpsToRay[3064] = 1000000008475243017717202707; - bpsToRay[3065] = 1000000008477670189998425353; - bpsToRay[3066] = 1000000008480097176510086432; - bpsToRay[3067] = 1000000008482523977280620426; - bpsToRay[3068] = 1000000008484950592338455283; - bpsToRay[3069] = 1000000008487377021712012431; - bpsToRay[3070] = 1000000008489803265429706768; - bpsToRay[3071] = 1000000008492229323519946677; - bpsToRay[3072] = 1000000008494655196011134014; - bpsToRay[3073] = 1000000008497080882931664122; - bpsToRay[3074] = 1000000008499506384309925825; - bpsToRay[3075] = 1000000008501931700174301437; - bpsToRay[3076] = 1000000008504356830553166755; - bpsToRay[3077] = 1000000008506781775474891069; - bpsToRay[3078] = 1000000008509206534967837162; - bpsToRay[3079] = 1000000008511631109060361308; - bpsToRay[3080] = 1000000008514055497780813280; - bpsToRay[3081] = 1000000008516479701157536348; - bpsToRay[3082] = 1000000008518903719218867280; - bpsToRay[3083] = 1000000008521327551993136348; - bpsToRay[3084] = 1000000008523751199508667330; - bpsToRay[3085] = 1000000008526174661793777504; - bpsToRay[3086] = 1000000008528597938876777661; - bpsToRay[3087] = 1000000008531021030785972101; - bpsToRay[3088] = 1000000008533443937549658636; - bpsToRay[3089] = 1000000008535866659196128590; - bpsToRay[3090] = 1000000008538289195753666803; - bpsToRay[3091] = 1000000008540711547250551637; - bpsToRay[3092] = 1000000008543133713715054969; - bpsToRay[3093] = 1000000008545555695175442199; - bpsToRay[3094] = 1000000008547977491659972252; - bpsToRay[3095] = 1000000008550399103196897579; - bpsToRay[3096] = 1000000008552820529814464158; - bpsToRay[3097] = 1000000008555241771540911495; - bpsToRay[3098] = 1000000008557662828404472630; - bpsToRay[3099] = 1000000008560083700433374138; - bpsToRay[3100] = 1000000008562504387655836125; - bpsToRay[3101] = 1000000008564924890100072238; - bpsToRay[3102] = 1000000008567345207794289664; - bpsToRay[3103] = 1000000008569765340766689130; - bpsToRay[3104] = 1000000008572185289045464906; - bpsToRay[3105] = 1000000008574605052658804811; - bpsToRay[3106] = 1000000008577024631634890207; - bpsToRay[3107] = 1000000008579444026001896008; - bpsToRay[3108] = 1000000008581863235787990679; - bpsToRay[3109] = 1000000008584282261021336238; - bpsToRay[3110] = 1000000008586701101730088259; - bpsToRay[3111] = 1000000008589119757942395872; - bpsToRay[3112] = 1000000008591538229686401769; - bpsToRay[3113] = 1000000008593956516990242201; - bpsToRay[3114] = 1000000008596374619882046982; - bpsToRay[3115] = 1000000008598792538389939493; - bpsToRay[3116] = 1000000008601210272542036680; - bpsToRay[3117] = 1000000008603627822366449059; - bpsToRay[3118] = 1000000008606045187891280718; - bpsToRay[3119] = 1000000008608462369144629317; - bpsToRay[3120] = 1000000008610879366154586092; - bpsToRay[3121] = 1000000008613296178949235855; - bpsToRay[3122] = 1000000008615712807556656995; - bpsToRay[3123] = 1000000008618129252004921486; - bpsToRay[3124] = 1000000008620545512322094883; - bpsToRay[3125] = 1000000008622961588536236324; - bpsToRay[3126] = 1000000008625377480675398538; - bpsToRay[3127] = 1000000008627793188767627836; - bpsToRay[3128] = 1000000008630208712840964127; - bpsToRay[3129] = 1000000008632624052923440907; - bpsToRay[3130] = 1000000008635039209043085270; - bpsToRay[3131] = 1000000008637454181227917904; - bpsToRay[3132] = 1000000008639868969505953098; - bpsToRay[3133] = 1000000008642283573905198739; - bpsToRay[3134] = 1000000008644697994453656318; - bpsToRay[3135] = 1000000008647112231179320929; - bpsToRay[3136] = 1000000008649526284110181275; - bpsToRay[3137] = 1000000008651940153274219662; - bpsToRay[3138] = 1000000008654353838699412010; - bpsToRay[3139] = 1000000008656767340413727852; - bpsToRay[3140] = 1000000008659180658445130332; - bpsToRay[3141] = 1000000008661593792821576212; - bpsToRay[3142] = 1000000008664006743571015870; - bpsToRay[3143] = 1000000008666419510721393305; - bpsToRay[3144] = 1000000008668832094300646140; - bpsToRay[3145] = 1000000008671244494336705617; - bpsToRay[3146] = 1000000008673656710857496608; - bpsToRay[3147] = 1000000008676068743890937609; - bpsToRay[3148] = 1000000008678480593464940750; - bpsToRay[3149] = 1000000008680892259607411787; - bpsToRay[3150] = 1000000008683303742346250114; - bpsToRay[3151] = 1000000008685715041709348759; - bpsToRay[3152] = 1000000008688126157724594385; - bpsToRay[3153] = 1000000008690537090419867299; - bpsToRay[3154] = 1000000008692947839823041443; - bpsToRay[3155] = 1000000008695358405961984408; - bpsToRay[3156] = 1000000008697768788864557426; - bpsToRay[3157] = 1000000008700178988558615379; - bpsToRay[3158] = 1000000008702589005072006795; - bpsToRay[3159] = 1000000008704998838432573855; - bpsToRay[3160] = 1000000008707408488668152392; - bpsToRay[3161] = 1000000008709817955806571893; - bpsToRay[3162] = 1000000008712227239875655502; - bpsToRay[3163] = 1000000008714636340903220022; - bpsToRay[3164] = 1000000008717045258917075917; - bpsToRay[3165] = 1000000008719453993945027311; - bpsToRay[3166] = 1000000008721862546014871996; - bpsToRay[3167] = 1000000008724270915154401427; - bpsToRay[3168] = 1000000008726679101391400728; - bpsToRay[3169] = 1000000008729087104753648695; - bpsToRay[3170] = 1000000008731494925268917794; - bpsToRay[3171] = 1000000008733902562964974164; - bpsToRay[3172] = 1000000008736310017869577622; - bpsToRay[3173] = 1000000008738717290010481663; - bpsToRay[3174] = 1000000008741124379415433461; - bpsToRay[3175] = 1000000008743531286112173869; - bpsToRay[3176] = 1000000008745938010128437428; - bpsToRay[3177] = 1000000008748344551491952362; - bpsToRay[3178] = 1000000008750750910230440583; - bpsToRay[3179] = 1000000008753157086371617690; - bpsToRay[3180] = 1000000008755563079943192978; - bpsToRay[3181] = 1000000008757968890972869430; - bpsToRay[3182] = 1000000008760374519488343729; - bpsToRay[3183] = 1000000008762779965517306250; - bpsToRay[3184] = 1000000008765185229087441070; - bpsToRay[3185] = 1000000008767590310226425966; - bpsToRay[3186] = 1000000008769995208961932417; - bpsToRay[3187] = 1000000008772399925321625609; - bpsToRay[3188] = 1000000008774804459333164431; - bpsToRay[3189] = 1000000008777208811024201482; - bpsToRay[3190] = 1000000008779612980422383073; - bpsToRay[3191] = 1000000008782016967555349225; - bpsToRay[3192] = 1000000008784420772450733672; - bpsToRay[3193] = 1000000008786824395136163869; - bpsToRay[3194] = 1000000008789227835639260984; - bpsToRay[3195] = 1000000008791631093987639905; - bpsToRay[3196] = 1000000008794034170208909246; - bpsToRay[3197] = 1000000008796437064330671341; - bpsToRay[3198] = 1000000008798839776380522251; - bpsToRay[3199] = 1000000008801242306386051763; - bpsToRay[3200] = 1000000008803644654374843395; - bpsToRay[3201] = 1000000008806046820374474396; - bpsToRay[3202] = 1000000008808448804412515748; - bpsToRay[3203] = 1000000008810850606516532167; - bpsToRay[3204] = 1000000008813252226714082106; - bpsToRay[3205] = 1000000008815653665032717760; - bpsToRay[3206] = 1000000008818054921499985060; - bpsToRay[3207] = 1000000008820455996143423684; - bpsToRay[3208] = 1000000008822856888990567050; - bpsToRay[3209] = 1000000008825257600068942328; - bpsToRay[3210] = 1000000008827658129406070432; - bpsToRay[3211] = 1000000008830058477029466028; - bpsToRay[3212] = 1000000008832458642966637533; - bpsToRay[3213] = 1000000008834858627245087117; - bpsToRay[3214] = 1000000008837258429892310711; - bpsToRay[3215] = 1000000008839658050935797999; - bpsToRay[3216] = 1000000008842057490403032425; - bpsToRay[3217] = 1000000008844456748321491195; - bpsToRay[3218] = 1000000008846855824718645282; - bpsToRay[3219] = 1000000008849254719621959420; - bpsToRay[3220] = 1000000008851653433058892110; - bpsToRay[3221] = 1000000008854051965056895625; - bpsToRay[3222] = 1000000008856450315643416008; - bpsToRay[3223] = 1000000008858848484845893073; - bpsToRay[3224] = 1000000008861246472691760412; - bpsToRay[3225] = 1000000008863644279208445392; - bpsToRay[3226] = 1000000008866041904423369157; - bpsToRay[3227] = 1000000008868439348363946634; - bpsToRay[3228] = 1000000008870836611057586530; - bpsToRay[3229] = 1000000008873233692531691339; - bpsToRay[3230] = 1000000008875630592813657337; - bpsToRay[3231] = 1000000008878027311930874594; - bpsToRay[3232] = 1000000008880423849910726963; - bpsToRay[3233] = 1000000008882820206780592093; - bpsToRay[3234] = 1000000008885216382567841425; - bpsToRay[3235] = 1000000008887612377299840196; - bpsToRay[3236] = 1000000008890008191003947440; - bpsToRay[3237] = 1000000008892403823707515991; - bpsToRay[3238] = 1000000008894799275437892482; - bpsToRay[3239] = 1000000008897194546222417351; - bpsToRay[3240] = 1000000008899589636088424841; - bpsToRay[3241] = 1000000008901984545063242999; - bpsToRay[3242] = 1000000008904379273174193682; - bpsToRay[3243] = 1000000008906773820448592561; - bpsToRay[3244] = 1000000008909168186913749112; - bpsToRay[3245] = 1000000008911562372596966632; - bpsToRay[3246] = 1000000008913956377525542231; - bpsToRay[3247] = 1000000008916350201726766834; - bpsToRay[3248] = 1000000008918743845227925192; - bpsToRay[3249] = 1000000008921137308056295874; - bpsToRay[3250] = 1000000008923530590239151272; - bpsToRay[3251] = 1000000008925923691803757605; - bpsToRay[3252] = 1000000008928316612777374918; - bpsToRay[3253] = 1000000008930709353187257086; - bpsToRay[3254] = 1000000008933101913060651814; - bpsToRay[3255] = 1000000008935494292424800641; - bpsToRay[3256] = 1000000008937886491306938939; - bpsToRay[3257] = 1000000008940278509734295919; - bpsToRay[3258] = 1000000008942670347734094627; - bpsToRay[3259] = 1000000008945062005333551953; - bpsToRay[3260] = 1000000008947453482559878626; - bpsToRay[3261] = 1000000008949844779440279220; - bpsToRay[3262] = 1000000008952235896001952156; - bpsToRay[3263] = 1000000008954626832272089702; - bpsToRay[3264] = 1000000008957017588277877973; - bpsToRay[3265] = 1000000008959408164046496940; - bpsToRay[3266] = 1000000008961798559605120424; - bpsToRay[3267] = 1000000008964188774980916101; - bpsToRay[3268] = 1000000008966578810201045506; - bpsToRay[3269] = 1000000008968968665292664032; - bpsToRay[3270] = 1000000008971358340282920931; - bpsToRay[3271] = 1000000008973747835198959319; - bpsToRay[3272] = 1000000008976137150067916177; - bpsToRay[3273] = 1000000008978526284916922351; - bpsToRay[3274] = 1000000008980915239773102555; - bpsToRay[3275] = 1000000008983304014663575373; - bpsToRay[3276] = 1000000008985692609615453262; - bpsToRay[3277] = 1000000008988081024655842550; - bpsToRay[3278] = 1000000008990469259811843445; - bpsToRay[3279] = 1000000008992857315110550026; - bpsToRay[3280] = 1000000008995245190579050256; - bpsToRay[3281] = 1000000008997632886244425977; - bpsToRay[3282] = 1000000009000020402133752914; - bpsToRay[3283] = 1000000009002407738274100677; - bpsToRay[3284] = 1000000009004794894692532763; - bpsToRay[3285] = 1000000009007181871416106556; - bpsToRay[3286] = 1000000009009568668471873331; - bpsToRay[3287] = 1000000009011955285886878254; - bpsToRay[3288] = 1000000009014341723688160386; - bpsToRay[3289] = 1000000009016727981902752684; - bpsToRay[3290] = 1000000009019114060557682002; - bpsToRay[3291] = 1000000009021499959679969092; - bpsToRay[3292] = 1000000009023885679296628609; - bpsToRay[3293] = 1000000009026271219434669112; - bpsToRay[3294] = 1000000009028656580121093060; - bpsToRay[3295] = 1000000009031041761382896825; - bpsToRay[3296] = 1000000009033426763247070684; - bpsToRay[3297] = 1000000009035811585740598824; - bpsToRay[3298] = 1000000009038196228890459345; - bpsToRay[3299] = 1000000009040580692723624262; - bpsToRay[3300] = 1000000009042964977267059505; - bpsToRay[3301] = 1000000009045349082547724920; - bpsToRay[3302] = 1000000009047733008592574277; - bpsToRay[3303] = 1000000009050116755428555263; - bpsToRay[3304] = 1000000009052500323082609490; - bpsToRay[3305] = 1000000009054883711581672494; - bpsToRay[3306] = 1000000009057266920952673739; - bpsToRay[3307] = 1000000009059649951222536617; - bpsToRay[3308] = 1000000009062032802418178451; - bpsToRay[3309] = 1000000009064415474566510497; - bpsToRay[3310] = 1000000009066797967694437943; - bpsToRay[3311] = 1000000009069180281828859914; - bpsToRay[3312] = 1000000009071562416996669472; - bpsToRay[3313] = 1000000009073944373224753622; - bpsToRay[3314] = 1000000009076326150539993305; - bpsToRay[3315] = 1000000009078707748969263409; - bpsToRay[3316] = 1000000009081089168539432766; - bpsToRay[3317] = 1000000009083470409277364157; - bpsToRay[3318] = 1000000009085851471209914307; - bpsToRay[3319] = 1000000009088232354363933896; - bpsToRay[3320] = 1000000009090613058766267552; - bpsToRay[3321] = 1000000009092993584443753863; - bpsToRay[3322] = 1000000009095373931423225367; - bpsToRay[3323] = 1000000009097754099731508564; - bpsToRay[3324] = 1000000009100134089395423911; - bpsToRay[3325] = 1000000009102513900441785827; - bpsToRay[3326] = 1000000009104893532897402697; - bpsToRay[3327] = 1000000009107272986789076865; - bpsToRay[3328] = 1000000009109652262143604647; - bpsToRay[3329] = 1000000009112031358987776327; - bpsToRay[3330] = 1000000009114410277348376157; - bpsToRay[3331] = 1000000009116789017252182363; - bpsToRay[3332] = 1000000009119167578725967147; - bpsToRay[3333] = 1000000009121545961796496682; - bpsToRay[3334] = 1000000009123924166490531122; - bpsToRay[3335] = 1000000009126302192834824601; - bpsToRay[3336] = 1000000009128680040856125232; - bpsToRay[3337] = 1000000009131057710581175113; - bpsToRay[3338] = 1000000009133435202036710325; - bpsToRay[3339] = 1000000009135812515249460939; - bpsToRay[3340] = 1000000009138189650246151012; - bpsToRay[3341] = 1000000009140566607053498590; - bpsToRay[3342] = 1000000009142943385698215714; - bpsToRay[3343] = 1000000009145319986207008418; - bpsToRay[3344] = 1000000009147696408606576730; - bpsToRay[3345] = 1000000009150072652923614679; - bpsToRay[3346] = 1000000009152448719184810291; - bpsToRay[3347] = 1000000009154824607416845592; - bpsToRay[3348] = 1000000009157200317646396614; - bpsToRay[3349] = 1000000009159575849900133392; - bpsToRay[3350] = 1000000009161951204204719966; - bpsToRay[3351] = 1000000009164326380586814388; - bpsToRay[3352] = 1000000009166701379073068717; - bpsToRay[3353] = 1000000009169076199690129024; - bpsToRay[3354] = 1000000009171450842464635396; - bpsToRay[3355] = 1000000009173825307423221934; - bpsToRay[3356] = 1000000009176199594592516756; - bpsToRay[3357] = 1000000009178573703999141999; - bpsToRay[3358] = 1000000009180947635669713821; - bpsToRay[3359] = 1000000009183321389630842403; - bpsToRay[3360] = 1000000009185694965909131953; - bpsToRay[3361] = 1000000009188068364531180699; - bpsToRay[3362] = 1000000009190441585523580901; - bpsToRay[3363] = 1000000009192814628912918850; - bpsToRay[3364] = 1000000009195187494725774868; - bpsToRay[3365] = 1000000009197560182988723306; - bpsToRay[3366] = 1000000009199932693728332556; - bpsToRay[3367] = 1000000009202305026971165043; - bpsToRay[3368] = 1000000009204677182743777234; - bpsToRay[3369] = 1000000009207049161072719633; - bpsToRay[3370] = 1000000009209420961984536788; - bpsToRay[3371] = 1000000009211792585505767292; - bpsToRay[3372] = 1000000009214164031662943783; - bpsToRay[3373] = 1000000009216535300482592946; - bpsToRay[3374] = 1000000009218906391991235515; - bpsToRay[3375] = 1000000009221277306215386279; - bpsToRay[3376] = 1000000009223648043181554075; - bpsToRay[3377] = 1000000009226018602916241797; - bpsToRay[3378] = 1000000009228388985445946397; - bpsToRay[3379] = 1000000009230759190797158882; - bpsToRay[3380] = 1000000009233129218996364321; - bpsToRay[3381] = 1000000009235499070070041847; - bpsToRay[3382] = 1000000009237868744044664652; - bpsToRay[3383] = 1000000009240238240946699996; - bpsToRay[3384] = 1000000009242607560802609207; - bpsToRay[3385] = 1000000009244976703638847681; - bpsToRay[3386] = 1000000009247345669481864883; - bpsToRay[3387] = 1000000009249714458358104354; - bpsToRay[3388] = 1000000009252083070294003707; - bpsToRay[3389] = 1000000009254451505315994632; - bpsToRay[3390] = 1000000009256819763450502896; - bpsToRay[3391] = 1000000009259187844723948345; - bpsToRay[3392] = 1000000009261555749162744907; - bpsToRay[3393] = 1000000009263923476793300595; - bpsToRay[3394] = 1000000009266291027642017505; - bpsToRay[3395] = 1000000009268658401735291819; - bpsToRay[3396] = 1000000009271025599099513809; - bpsToRay[3397] = 1000000009273392619761067837; - bpsToRay[3398] = 1000000009275759463746332356; - bpsToRay[3399] = 1000000009278126131081679912; - bpsToRay[3400] = 1000000009280492621793477151; - bpsToRay[3401] = 1000000009282858935908084809; - bpsToRay[3402] = 1000000009285225073451857728; - bpsToRay[3403] = 1000000009287591034451144845; - bpsToRay[3404] = 1000000009289956818932289205; - bpsToRay[3405] = 1000000009292322426921627953; - bpsToRay[3406] = 1000000009294687858445492342; - bpsToRay[3407] = 1000000009297053113530207732; - bpsToRay[3408] = 1000000009299418192202093592; - bpsToRay[3409] = 1000000009301783094487463505; - bpsToRay[3410] = 1000000009304147820412625165; - bpsToRay[3411] = 1000000009306512370003880380; - bpsToRay[3412] = 1000000009308876743287525076; - bpsToRay[3413] = 1000000009311240940289849298; - bpsToRay[3414] = 1000000009313604961037137210; - bpsToRay[3415] = 1000000009315968805555667098; - bpsToRay[3416] = 1000000009318332473871711372; - bpsToRay[3417] = 1000000009320695966011536564; - bpsToRay[3418] = 1000000009323059282001403339; - bpsToRay[3419] = 1000000009325422421867566487; - bpsToRay[3420] = 1000000009327785385636274930; - bpsToRay[3421] = 1000000009330148173333771722; - bpsToRay[3422] = 1000000009332510784986294051; - bpsToRay[3423] = 1000000009334873220620073239; - bpsToRay[3424] = 1000000009337235480261334748; - bpsToRay[3425] = 1000000009339597563936298181; - bpsToRay[3426] = 1000000009341959471671177278; - bpsToRay[3427] = 1000000009344321203492179924; - bpsToRay[3428] = 1000000009346682759425508147; - bpsToRay[3429] = 1000000009349044139497358124; - bpsToRay[3430] = 1000000009351405343733920179; - bpsToRay[3431] = 1000000009353766372161378785; - bpsToRay[3432] = 1000000009356127224805912567; - bpsToRay[3433] = 1000000009358487901693694303; - bpsToRay[3434] = 1000000009360848402850890927; - bpsToRay[3435] = 1000000009363208728303663528; - bpsToRay[3436] = 1000000009365568878078167356; - bpsToRay[3437] = 1000000009367928852200551818; - bpsToRay[3438] = 1000000009370288650696960487; - bpsToRay[3439] = 1000000009372648273593531096; - bpsToRay[3440] = 1000000009375007720916395546; - bpsToRay[3441] = 1000000009377366992691679904; - bpsToRay[3442] = 1000000009379726088945504406; - bpsToRay[3443] = 1000000009382085009703983460; - bpsToRay[3444] = 1000000009384443754993225643; - bpsToRay[3445] = 1000000009386802324839333712; - bpsToRay[3446] = 1000000009389160719268404592; - bpsToRay[3447] = 1000000009391518938306529393; - bpsToRay[3448] = 1000000009393876981979793400; - bpsToRay[3449] = 1000000009396234850314276081; - bpsToRay[3450] = 1000000009398592543336051086; - bpsToRay[3451] = 1000000009400950061071186249; - bpsToRay[3452] = 1000000009403307403545743592; - bpsToRay[3453] = 1000000009405664570785779323; - bpsToRay[3454] = 1000000009408021562817343841; - bpsToRay[3455] = 1000000009410378379666481736; - bpsToRay[3456] = 1000000009412735021359231792; - bpsToRay[3457] = 1000000009415091487921626986; - bpsToRay[3458] = 1000000009417447779379694494; - bpsToRay[3459] = 1000000009419803895759455687; - bpsToRay[3460] = 1000000009422159837086926140; - bpsToRay[3461] = 1000000009424515603388115629; - bpsToRay[3462] = 1000000009426871194689028130; - bpsToRay[3463] = 1000000009429226611015661829; - bpsToRay[3464] = 1000000009431581852394009115; - bpsToRay[3465] = 1000000009433936918850056588; - bpsToRay[3466] = 1000000009436291810409785058; - bpsToRay[3467] = 1000000009438646527099169546; - bpsToRay[3468] = 1000000009441001068944179290; - bpsToRay[3469] = 1000000009443355435970777739; - bpsToRay[3470] = 1000000009445709628204922563; - bpsToRay[3471] = 1000000009448063645672565649; - bpsToRay[3472] = 1000000009450417488399653106; - bpsToRay[3473] = 1000000009452771156412125264; - bpsToRay[3474] = 1000000009455124649735916678; - bpsToRay[3475] = 1000000009457477968396956129; - bpsToRay[3476] = 1000000009459831112421166625; - bpsToRay[3477] = 1000000009462184081834465404; - bpsToRay[3478] = 1000000009464536876662763935; - bpsToRay[3479] = 1000000009466889496931967919; - bpsToRay[3480] = 1000000009469241942667977291; - bpsToRay[3481] = 1000000009471594213896686225; - bpsToRay[3482] = 1000000009473946310643983128; - bpsToRay[3483] = 1000000009476298232935750651; - bpsToRay[3484] = 1000000009478649980797865683; - bpsToRay[3485] = 1000000009481001554256199359; - bpsToRay[3486] = 1000000009483352953336617058; - bpsToRay[3487] = 1000000009485704178064978403; - bpsToRay[3488] = 1000000009488055228467137266; - bpsToRay[3489] = 1000000009490406104568941771; - bpsToRay[3490] = 1000000009492756806396234293; - bpsToRay[3491] = 1000000009495107333974851456; - bpsToRay[3492] = 1000000009497457687330624144; - bpsToRay[3493] = 1000000009499807866489377496; - bpsToRay[3494] = 1000000009502157871476930909; - bpsToRay[3495] = 1000000009504507702319098038; - bpsToRay[3496] = 1000000009506857359041686805; - bpsToRay[3497] = 1000000009509206841670499389; - bpsToRay[3498] = 1000000009511556150231332239; - bpsToRay[3499] = 1000000009513905284749976069; - bpsToRay[3500] = 1000000009516254245252215861; - bpsToRay[3501] = 1000000009518603031763830869; - bpsToRay[3502] = 1000000009520951644310594617; - bpsToRay[3503] = 1000000009523300082918274904; - bpsToRay[3504] = 1000000009525648347612633803; - bpsToRay[3505] = 1000000009527996438419427664; - bpsToRay[3506] = 1000000009530344355364407118; - bpsToRay[3507] = 1000000009532692098473317073; - bpsToRay[3508] = 1000000009535039667771896723; - bpsToRay[3509] = 1000000009537387063285879541; - bpsToRay[3510] = 1000000009539734285040993291; - bpsToRay[3511] = 1000000009542081333062960018; - bpsToRay[3512] = 1000000009544428207377496063; - bpsToRay[3513] = 1000000009546774908010312050; - bpsToRay[3514] = 1000000009549121434987112901; - bpsToRay[3515] = 1000000009551467788333597830; - bpsToRay[3516] = 1000000009553813968075460344; - bpsToRay[3517] = 1000000009556159974238388253; - bpsToRay[3518] = 1000000009558505806848063661; - bpsToRay[3519] = 1000000009560851465930162975; - bpsToRay[3520] = 1000000009563196951510356903; - bpsToRay[3521] = 1000000009565542263614310457; - bpsToRay[3522] = 1000000009567887402267682959; - bpsToRay[3523] = 1000000009570232367496128031; - bpsToRay[3524] = 1000000009572577159325293611; - bpsToRay[3525] = 1000000009574921777780821942; - bpsToRay[3526] = 1000000009577266222888349586; - bpsToRay[3527] = 1000000009579610494673507411; - bpsToRay[3528] = 1000000009581954593161920610; - bpsToRay[3529] = 1000000009584298518379208685; - bpsToRay[3530] = 1000000009586642270350985464; - bpsToRay[3531] = 1000000009588985849102859090; - bpsToRay[3532] = 1000000009591329254660432033; - bpsToRay[3533] = 1000000009593672487049301086; - bpsToRay[3534] = 1000000009596015546295057365; - bpsToRay[3535] = 1000000009598358432423286320; - bpsToRay[3536] = 1000000009600701145459567724; - bpsToRay[3537] = 1000000009603043685429475683; - bpsToRay[3538] = 1000000009605386052358578639; - bpsToRay[3539] = 1000000009607728246272439360; - bpsToRay[3540] = 1000000009610070267196614960; - bpsToRay[3541] = 1000000009612412115156656882; - bpsToRay[3542] = 1000000009614753790178110915; - bpsToRay[3543] = 1000000009617095292286517185; - bpsToRay[3544] = 1000000009619436621507410162; - bpsToRay[3545] = 1000000009621777777866318660; - bpsToRay[3546] = 1000000009624118761388765837; - bpsToRay[3547] = 1000000009626459572100269204; - bpsToRay[3548] = 1000000009628800210026340615; - bpsToRay[3549] = 1000000009631140675192486280; - bpsToRay[3550] = 1000000009633480967624206760; - bpsToRay[3551] = 1000000009635821087346996968; - bpsToRay[3552] = 1000000009638161034386346176; - bpsToRay[3553] = 1000000009640500808767738013; - bpsToRay[3554] = 1000000009642840410516650466; - bpsToRay[3555] = 1000000009645179839658555885; - bpsToRay[3556] = 1000000009647519096218920981; - bpsToRay[3557] = 1000000009649858180223206829; - bpsToRay[3558] = 1000000009652197091696868873; - bpsToRay[3559] = 1000000009654535830665356921; - bpsToRay[3560] = 1000000009656874397154115153; - bpsToRay[3561] = 1000000009659212791188582117; - bpsToRay[3562] = 1000000009661551012794190737; - bpsToRay[3563] = 1000000009663889061996368309; - bpsToRay[3564] = 1000000009666226938820536506; - bpsToRay[3565] = 1000000009668564643292111378; - bpsToRay[3566] = 1000000009670902175436503355; - bpsToRay[3567] = 1000000009673239535279117247; - bpsToRay[3568] = 1000000009675576722845352247; - bpsToRay[3569] = 1000000009677913738160601933; - bpsToRay[3570] = 1000000009680250581250254266; - bpsToRay[3571] = 1000000009682587252139691600; - bpsToRay[3572] = 1000000009684923750854290672; - bpsToRay[3573] = 1000000009687260077419422613; - bpsToRay[3574] = 1000000009689596231860452947; - bpsToRay[3575] = 1000000009691932214202741592; - bpsToRay[3576] = 1000000009694268024471642861; - bpsToRay[3577] = 1000000009696603662692505463; - bpsToRay[3578] = 1000000009698939128890672509; - bpsToRay[3579] = 1000000009701274423091481510; - bpsToRay[3580] = 1000000009703609545320264378; - bpsToRay[3581] = 1000000009705944495602347430; - bpsToRay[3582] = 1000000009708279273963051388; - bpsToRay[3583] = 1000000009710613880427691383; - bpsToRay[3584] = 1000000009712948315021576954; - bpsToRay[3585] = 1000000009715282577770012051; - bpsToRay[3586] = 1000000009717616668698295034; - bpsToRay[3587] = 1000000009719950587831718681; - bpsToRay[3588] = 1000000009722284335195570182; - bpsToRay[3589] = 1000000009724617910815131148; - bpsToRay[3590] = 1000000009726951314715677603; - bpsToRay[3591] = 1000000009729284546922479998; - bpsToRay[3592] = 1000000009731617607460803201; - bpsToRay[3593] = 1000000009733950496355906508; - bpsToRay[3594] = 1000000009736283213633043637; - bpsToRay[3595] = 1000000009738615759317462734; - bpsToRay[3596] = 1000000009740948133434406377; - bpsToRay[3597] = 1000000009743280336009111568; - bpsToRay[3598] = 1000000009745612367066809747; - bpsToRay[3599] = 1000000009747944226632726785; - bpsToRay[3600] = 1000000009750275914732082986; - bpsToRay[3601] = 1000000009752607431390093096; - bpsToRay[3602] = 1000000009754938776631966296; - bpsToRay[3603] = 1000000009757269950482906208; - bpsToRay[3604] = 1000000009759600952968110896; - bpsToRay[3605] = 1000000009761931784112772867; - bpsToRay[3606] = 1000000009764262443942079074; - bpsToRay[3607] = 1000000009766592932481210915; - bpsToRay[3608] = 1000000009768923249755344240; - bpsToRay[3609] = 1000000009771253395789649342; - bpsToRay[3610] = 1000000009773583370609290973; - bpsToRay[3611] = 1000000009775913174239428335; - bpsToRay[3612] = 1000000009778242806705215085; - bpsToRay[3613] = 1000000009780572268031799336; - bpsToRay[3614] = 1000000009782901558244323661; - bpsToRay[3615] = 1000000009785230677367925089; - bpsToRay[3616] = 1000000009787559625427735116; - bpsToRay[3617] = 1000000009789888402448879695; - bpsToRay[3618] = 1000000009792217008456479248; - bpsToRay[3619] = 1000000009794545443475648661; - bpsToRay[3620] = 1000000009796873707531497290; - bpsToRay[3621] = 1000000009799201800649128958; - bpsToRay[3622] = 1000000009801529722853641960; - bpsToRay[3623] = 1000000009803857474170129064; - bpsToRay[3624] = 1000000009806185054623677514; - bpsToRay[3625] = 1000000009808512464239369028; - bpsToRay[3626] = 1000000009810839703042279800; - bpsToRay[3627] = 1000000009813166771057480507; - bpsToRay[3628] = 1000000009815493668310036305; - bpsToRay[3629] = 1000000009817820394825006832; - bpsToRay[3630] = 1000000009820146950627446211; - bpsToRay[3631] = 1000000009822473335742403050; - bpsToRay[3632] = 1000000009824799550194920446; - bpsToRay[3633] = 1000000009827125594010035982; - bpsToRay[3634] = 1000000009829451467212781736; - bpsToRay[3635] = 1000000009831777169828184273; - bpsToRay[3636] = 1000000009834102701881264655; - bpsToRay[3637] = 1000000009836428063397038439; - bpsToRay[3638] = 1000000009838753254400515679; - bpsToRay[3639] = 1000000009841078274916700926; - bpsToRay[3640] = 1000000009843403124970593235; - bpsToRay[3641] = 1000000009845727804587186159; - bpsToRay[3642] = 1000000009848052313791467756; - bpsToRay[3643] = 1000000009850376652608420590; - bpsToRay[3644] = 1000000009852700821063021729; - bpsToRay[3645] = 1000000009855024819180242754; - bpsToRay[3646] = 1000000009857348646985049751; - bpsToRay[3647] = 1000000009859672304502403321; - bpsToRay[3648] = 1000000009861995791757258575; - bpsToRay[3649] = 1000000009864319108774565142; - bpsToRay[3650] = 1000000009866642255579267166; - bpsToRay[3651] = 1000000009868965232196303308; - bpsToRay[3652] = 1000000009871288038650606750; - bpsToRay[3653] = 1000000009873610674967105195; - bpsToRay[3654] = 1000000009875933141170720867; - bpsToRay[3655] = 1000000009878255437286370517; - bpsToRay[3656] = 1000000009880577563338965422; - bpsToRay[3657] = 1000000009882899519353411383; - bpsToRay[3658] = 1000000009885221305354608733; - bpsToRay[3659] = 1000000009887542921367452338; - bpsToRay[3660] = 1000000009889864367416831591; - bpsToRay[3661] = 1000000009892185643527630423; - bpsToRay[3662] = 1000000009894506749724727299; - bpsToRay[3663] = 1000000009896827686032995223; - bpsToRay[3664] = 1000000009899148452477301734; - bpsToRay[3665] = 1000000009901469049082508916; - bpsToRay[3666] = 1000000009903789475873473393; - bpsToRay[3667] = 1000000009906109732875046331; - bpsToRay[3668] = 1000000009908429820112073443; - bpsToRay[3669] = 1000000009910749737609394990; - bpsToRay[3670] = 1000000009913069485391845778; - bpsToRay[3671] = 1000000009915389063484255166; - bpsToRay[3672] = 1000000009917708471911447063; - bpsToRay[3673] = 1000000009920027710698239932; - bpsToRay[3674] = 1000000009922346779869446790; - bpsToRay[3675] = 1000000009924665679449875210; - bpsToRay[3676] = 1000000009926984409464327325; - bpsToRay[3677] = 1000000009929302969937599826; - bpsToRay[3678] = 1000000009931621360894483965; - bpsToRay[3679] = 1000000009933939582359765557; - bpsToRay[3680] = 1000000009936257634358224982; - bpsToRay[3681] = 1000000009938575516914637184; - bpsToRay[3682] = 1000000009940893230053771678; - bpsToRay[3683] = 1000000009943210773800392543; - bpsToRay[3684] = 1000000009945528148179258435; - bpsToRay[3685] = 1000000009947845353215122576; - bpsToRay[3686] = 1000000009950162388932732765; - bpsToRay[3687] = 1000000009952479255356831378; - bpsToRay[3688] = 1000000009954795952512155365; - bpsToRay[3689] = 1000000009957112480423436255; - bpsToRay[3690] = 1000000009959428839115400159; - bpsToRay[3691] = 1000000009961745028612767768; - bpsToRay[3692] = 1000000009964061048940254356; - bpsToRay[3693] = 1000000009966376900122569785; - bpsToRay[3694] = 1000000009968692582184418500; - bpsToRay[3695] = 1000000009971008095150499537; - bpsToRay[3696] = 1000000009973323439045506518; - bpsToRay[3697] = 1000000009975638613894127660; - bpsToRay[3698] = 1000000009977953619721045772; - bpsToRay[3699] = 1000000009980268456550938255; - bpsToRay[3700] = 1000000009982583124408477109; - bpsToRay[3701] = 1000000009984897623318328929; - bpsToRay[3702] = 1000000009987211953305154911; - bpsToRay[3703] = 1000000009989526114393610852; - bpsToRay[3704] = 1000000009991840106608347149; - bpsToRay[3705] = 1000000009994153929974008806; - bpsToRay[3706] = 1000000009996467584515235430; - bpsToRay[3707] = 1000000009998781070256661235; - bpsToRay[3708] = 1000000010001094387222915045; - bpsToRay[3709] = 1000000010003407535438620294; - bpsToRay[3710] = 1000000010005720514928395027; - bpsToRay[3711] = 1000000010008033325716851902; - bpsToRay[3712] = 1000000010010345967828598194; - bpsToRay[3713] = 1000000010012658441288235791; - bpsToRay[3714] = 1000000010014970746120361202; - bpsToRay[3715] = 1000000010017282882349565556; - bpsToRay[3716] = 1000000010019594850000434599; - bpsToRay[3717] = 1000000010021906649097548706; - bpsToRay[3718] = 1000000010024218279665482869; - bpsToRay[3719] = 1000000010026529741728806711; - bpsToRay[3720] = 1000000010028841035312084483; - bpsToRay[3721] = 1000000010031152160439875061; - bpsToRay[3722] = 1000000010033463117136731955; - bpsToRay[3723] = 1000000010035773905427203304; - bpsToRay[3724] = 1000000010038084525335831885; - bpsToRay[3725] = 1000000010040394976887155106; - bpsToRay[3726] = 1000000010042705260105705014; - bpsToRay[3727] = 1000000010045015375016008294; - bpsToRay[3728] = 1000000010047325321642586271; - bpsToRay[3729] = 1000000010049635100009954912; - bpsToRay[3730] = 1000000010051944710142624825; - bpsToRay[3731] = 1000000010054254152065101266; - bpsToRay[3732] = 1000000010056563425801884135; - bpsToRay[3733] = 1000000010058872531377467979; - bpsToRay[3734] = 1000000010061181468816341997; - bpsToRay[3735] = 1000000010063490238142990036; - bpsToRay[3736] = 1000000010065798839381890598; - bpsToRay[3737] = 1000000010068107272557516837; - bpsToRay[3738] = 1000000010070415537694336563; - bpsToRay[3739] = 1000000010072723634816812244; - bpsToRay[3740] = 1000000010075031563949401005; - bpsToRay[3741] = 1000000010077339325116554633; - bpsToRay[3742] = 1000000010079646918342719577; - bpsToRay[3743] = 1000000010081954343652336947; - bpsToRay[3744] = 1000000010084261601069842519; - bpsToRay[3745] = 1000000010086568690619666737; - bpsToRay[3746] = 1000000010088875612326234711; - bpsToRay[3747] = 1000000010091182366213966220; - bpsToRay[3748] = 1000000010093488952307275716; - bpsToRay[3749] = 1000000010095795370630572323; - bpsToRay[3750] = 1000000010098101621208259840; - bpsToRay[3751] = 1000000010100407704064736739; - bpsToRay[3752] = 1000000010102713619224396172; - bpsToRay[3753] = 1000000010105019366711625969; - bpsToRay[3754] = 1000000010107324946550808639; - bpsToRay[3755] = 1000000010109630358766321376; - bpsToRay[3756] = 1000000010111935603382536054; - bpsToRay[3757] = 1000000010114240680423819234; - bpsToRay[3758] = 1000000010116545589914532164; - bpsToRay[3759] = 1000000010118850331879030779; - bpsToRay[3760] = 1000000010121154906341665703; - bpsToRay[3761] = 1000000010123459313326782253; - bpsToRay[3762] = 1000000010125763552858720438; - bpsToRay[3763] = 1000000010128067624961814960; - bpsToRay[3764] = 1000000010130371529660395218; - bpsToRay[3765] = 1000000010132675266978785311; - bpsToRay[3766] = 1000000010134978836941304031; - bpsToRay[3767] = 1000000010137282239572264876; - bpsToRay[3768] = 1000000010139585474895976041; - bpsToRay[3769] = 1000000010141888542936740429; - bpsToRay[3770] = 1000000010144191443718855647; - bpsToRay[3771] = 1000000010146494177266614006; - bpsToRay[3772] = 1000000010148796743604302527; - bpsToRay[3773] = 1000000010151099142756202942; - bpsToRay[3774] = 1000000010153401374746591692; - bpsToRay[3775] = 1000000010155703439599739931; - bpsToRay[3776] = 1000000010158005337339913529; - bpsToRay[3777] = 1000000010160307067991373070; - bpsToRay[3778] = 1000000010162608631578373856; - bpsToRay[3779] = 1000000010164910028125165907; - bpsToRay[3780] = 1000000010167211257655993967; - bpsToRay[3781] = 1000000010169512320195097496; - bpsToRay[3782] = 1000000010171813215766710684; - bpsToRay[3783] = 1000000010174113944395062439; - bpsToRay[3784] = 1000000010176414506104376402; - bpsToRay[3785] = 1000000010178714900918870939; - bpsToRay[3786] = 1000000010181015128862759145; - bpsToRay[3787] = 1000000010183315189960248848; - bpsToRay[3788] = 1000000010185615084235542606; - bpsToRay[3789] = 1000000010187914811712837715; - bpsToRay[3790] = 1000000010190214372416326204; - bpsToRay[3791] = 1000000010192513766370194839; - bpsToRay[3792] = 1000000010194812993598625127; - bpsToRay[3793] = 1000000010197112054125793313; - bpsToRay[3794] = 1000000010199410947975870385; - bpsToRay[3795] = 1000000010201709675173022073; - bpsToRay[3796] = 1000000010204008235741408855; - bpsToRay[3797] = 1000000010206306629705185952; - bpsToRay[3798] = 1000000010208604857088503334; - bpsToRay[3799] = 1000000010210902917915505722; - bpsToRay[3800] = 1000000010213200812210332586; - bpsToRay[3801] = 1000000010215498539997118147; - bpsToRay[3802] = 1000000010217796101299991387; - bpsToRay[3803] = 1000000010220093496143076034; - bpsToRay[3804] = 1000000010222390724550490579; - bpsToRay[3805] = 1000000010224687786546348272; - bpsToRay[3806] = 1000000010226984682154757119; - bpsToRay[3807] = 1000000010229281411399819892; - bpsToRay[3808] = 1000000010231577974305634122; - bpsToRay[3809] = 1000000010233874370896292108; - bpsToRay[3810] = 1000000010236170601195880913; - bpsToRay[3811] = 1000000010238466665228482369; - bpsToRay[3812] = 1000000010240762563018173077; - bpsToRay[3813] = 1000000010243058294589024407; - bpsToRay[3814] = 1000000010245353859965102504; - bpsToRay[3815] = 1000000010247649259170468285; - bpsToRay[3816] = 1000000010249944492229177442; - bpsToRay[3817] = 1000000010252239559165280445; - bpsToRay[3818] = 1000000010254534460002822540; - bpsToRay[3819] = 1000000010256829194765843755; - bpsToRay[3820] = 1000000010259123763478378900; - bpsToRay[3821] = 1000000010261418166164457564; - bpsToRay[3822] = 1000000010263712402848104124; - bpsToRay[3823] = 1000000010266006473553337741; - bpsToRay[3824] = 1000000010268300378304172365; - bpsToRay[3825] = 1000000010270594117124616733; - bpsToRay[3826] = 1000000010272887690038674371; - bpsToRay[3827] = 1000000010275181097070343602; - bpsToRay[3828] = 1000000010277474338243617536; - bpsToRay[3829] = 1000000010279767413582484084; - bpsToRay[3830] = 1000000010282060323110925948; - bpsToRay[3831] = 1000000010284353066852920632; - bpsToRay[3832] = 1000000010286645644832440436; - bpsToRay[3833] = 1000000010288938057073452464; - bpsToRay[3834] = 1000000010291230303599918619; - bpsToRay[3835] = 1000000010293522384435795611; - bpsToRay[3836] = 1000000010295814299605034955; - bpsToRay[3837] = 1000000010298106049131582970; - bpsToRay[3838] = 1000000010300397633039380787; - bpsToRay[3839] = 1000000010302689051352364343; - bpsToRay[3840] = 1000000010304980304094464392; - bpsToRay[3841] = 1000000010307271391289606494; - bpsToRay[3842] = 1000000010309562312961711031; - bpsToRay[3843] = 1000000010311853069134693193; - bpsToRay[3844] = 1000000010314143659832462993; - bpsToRay[3845] = 1000000010316434085078925260; - bpsToRay[3846] = 1000000010318724344897979646; - bpsToRay[3847] = 1000000010321014439313520622; - bpsToRay[3848] = 1000000010323304368349437485; - bpsToRay[3849] = 1000000010325594132029614354; - bpsToRay[3850] = 1000000010327883730377930177; - bpsToRay[3851] = 1000000010330173163418258729; - bpsToRay[3852] = 1000000010332462431174468613; - bpsToRay[3853] = 1000000010334751533670423264; - bpsToRay[3854] = 1000000010337040470929980950; - bpsToRay[3855] = 1000000010339329242976994772; - bpsToRay[3856] = 1000000010341617849835312667; - bpsToRay[3857] = 1000000010343906291528777406; - bpsToRay[3858] = 1000000010346194568081226603; - bpsToRay[3859] = 1000000010348482679516492707; - bpsToRay[3860] = 1000000010350770625858403013; - bpsToRay[3861] = 1000000010353058407130779655; - bpsToRay[3862] = 1000000010355346023357439613; - bpsToRay[3863] = 1000000010357633474562194712; - bpsToRay[3864] = 1000000010359920760768851624; - bpsToRay[3865] = 1000000010362207882001211872; - bpsToRay[3866] = 1000000010364494838283071825; - bpsToRay[3867] = 1000000010366781629638222707; - bpsToRay[3868] = 1000000010369068256090450597; - bpsToRay[3869] = 1000000010371354717663536422; - bpsToRay[3870] = 1000000010373641014381255972; - bpsToRay[3871] = 1000000010375927146267379890; - bpsToRay[3872] = 1000000010378213113345673681; - bpsToRay[3873] = 1000000010380498915639897708; - bpsToRay[3874] = 1000000010382784553173807199; - bpsToRay[3875] = 1000000010385070025971152244; - bpsToRay[3876] = 1000000010387355334055677797; - bpsToRay[3877] = 1000000010389640477451123680; - bpsToRay[3878] = 1000000010391925456181224583; - bpsToRay[3879] = 1000000010394210270269710063; - bpsToRay[3880] = 1000000010396494919740304554; - bpsToRay[3881] = 1000000010398779404616727355; - bpsToRay[3882] = 1000000010401063724922692643; - bpsToRay[3883] = 1000000010403347880681909471; - bpsToRay[3884] = 1000000010405631871918081767; - bpsToRay[3885] = 1000000010407915698654908337; - bpsToRay[3886] = 1000000010410199360916082867; - bpsToRay[3887] = 1000000010412482858725293929; - bpsToRay[3888] = 1000000010414766192106224969; - bpsToRay[3889] = 1000000010417049361082554324; - bpsToRay[3890] = 1000000010419332365677955216; - bpsToRay[3891] = 1000000010421615205916095750; - bpsToRay[3892] = 1000000010423897881820638924; - bpsToRay[3893] = 1000000010426180393415242626; - bpsToRay[3894] = 1000000010428462740723559632; - bpsToRay[3895] = 1000000010430744923769237614; - bpsToRay[3896] = 1000000010433026942575919138; - bpsToRay[3897] = 1000000010435308797167241666; - bpsToRay[3898] = 1000000010437590487566837557; - bpsToRay[3899] = 1000000010439872013798334068; - bpsToRay[3900] = 1000000010442153375885353361; - bpsToRay[3901] = 1000000010444434573851512493; - bpsToRay[3902] = 1000000010446715607720423430; - bpsToRay[3903] = 1000000010448996477515693040; - bpsToRay[3904] = 1000000010451277183260923098; - bpsToRay[3905] = 1000000010453557724979710285; - bpsToRay[3906] = 1000000010455838102695646196; - bpsToRay[3907] = 1000000010458118316432317331; - bpsToRay[3908] = 1000000010460398366213305107; - bpsToRay[3909] = 1000000010462678252062185850; - bpsToRay[3910] = 1000000010464957974002530804; - bpsToRay[3911] = 1000000010467237532057906130; - bpsToRay[3912] = 1000000010469516926251872906; - bpsToRay[3913] = 1000000010471796156607987127; - bpsToRay[3914] = 1000000010474075223149799712; - bpsToRay[3915] = 1000000010476354125900856503; - bpsToRay[3916] = 1000000010478632864884698262; - bpsToRay[3917] = 1000000010480911440124860682; - bpsToRay[3918] = 1000000010483189851644874376; - bpsToRay[3919] = 1000000010485468099468264892; - bpsToRay[3920] = 1000000010487746183618552701; - bpsToRay[3921] = 1000000010490024104119253210; - bpsToRay[3922] = 1000000010492301860993876758; - bpsToRay[3923] = 1000000010494579454265928614; - bpsToRay[3924] = 1000000010496856883958908988; - bpsToRay[3925] = 1000000010499134150096313024; - bpsToRay[3926] = 1000000010501411252701630804; - bpsToRay[3927] = 1000000010503688191798347350; - bpsToRay[3928] = 1000000010505964967409942629; - bpsToRay[3929] = 1000000010508241579559891545; - bpsToRay[3930] = 1000000010510518028271663949; - bpsToRay[3931] = 1000000010512794313568724638; - bpsToRay[3932] = 1000000010515070435474533356; - bpsToRay[3933] = 1000000010517346394012544796; - bpsToRay[3934] = 1000000010519622189206208597; - bpsToRay[3935] = 1000000010521897821078969357; - bpsToRay[3936] = 1000000010524173289654266619; - bpsToRay[3937] = 1000000010526448594955534886; - bpsToRay[3938] = 1000000010528723737006203614; - bpsToRay[3939] = 1000000010530998715829697217; - bpsToRay[3940] = 1000000010533273531449435067; - bpsToRay[3941] = 1000000010535548183888831498; - bpsToRay[3942] = 1000000010537822673171295805; - bpsToRay[3943] = 1000000010540096999320232244; - bpsToRay[3944] = 1000000010542371162359040036; - bpsToRay[3945] = 1000000010544645162311113372; - bpsToRay[3946] = 1000000010546918999199841404; - bpsToRay[3947] = 1000000010549192673048608259; - bpsToRay[3948] = 1000000010551466183880793029; - bpsToRay[3949] = 1000000010553739531719769780; - bpsToRay[3950] = 1000000010556012716588907553; - bpsToRay[3951] = 1000000010558285738511570360; - bpsToRay[3952] = 1000000010560558597511117192; - bpsToRay[3953] = 1000000010562831293610902015; - bpsToRay[3954] = 1000000010565103826834273775; - bpsToRay[3955] = 1000000010567376197204576401; - bpsToRay[3956] = 1000000010569648404745148797; - bpsToRay[3957] = 1000000010571920449479324858; - bpsToRay[3958] = 1000000010574192331430433458; - bpsToRay[3959] = 1000000010576464050621798460; - bpsToRay[3960] = 1000000010578735607076738714; - bpsToRay[3961] = 1000000010581007000818568058; - bpsToRay[3962] = 1000000010583278231870595322; - bpsToRay[3963] = 1000000010585549300256124326; - bpsToRay[3964] = 1000000010587820205998453884; - bpsToRay[3965] = 1000000010590090949120877806; - bpsToRay[3966] = 1000000010592361529646684896; - bpsToRay[3967] = 1000000010594631947599158957; - bpsToRay[3968] = 1000000010596902203001578791; - bpsToRay[3969] = 1000000010599172295877218198; - bpsToRay[3970] = 1000000010601442226249345986; - bpsToRay[3971] = 1000000010603711994141225957; - bpsToRay[3972] = 1000000010605981599576116928; - bpsToRay[3973] = 1000000010608251042577272714; - bpsToRay[3974] = 1000000010610520323167942140; - bpsToRay[3975] = 1000000010612789441371369043; - bpsToRay[3976] = 1000000010615058397210792268; - bpsToRay[3977] = 1000000010617327190709445671; - bpsToRay[3978] = 1000000010619595821890558121; - bpsToRay[3979] = 1000000010621864290777353506; - bpsToRay[3980] = 1000000010624132597393050726; - bpsToRay[3981] = 1000000010626400741760863700; - bpsToRay[3982] = 1000000010628668723904001364; - bpsToRay[3983] = 1000000010630936543845667679; - bpsToRay[3984] = 1000000010633204201609061622; - bpsToRay[3985] = 1000000010635471697217377200; - bpsToRay[3986] = 1000000010637739030693803438; - bpsToRay[3987] = 1000000010640006202061524391; - bpsToRay[3988] = 1000000010642273211343719142; - bpsToRay[3989] = 1000000010644540058563561801; - bpsToRay[3990] = 1000000010646806743744221508; - bpsToRay[3991] = 1000000010649073266908862437; - bpsToRay[3992] = 1000000010651339628080643794; - bpsToRay[3993] = 1000000010653605827282719820; - bpsToRay[3994] = 1000000010655871864538239791; - bpsToRay[3995] = 1000000010658137739870348023; - bpsToRay[3996] = 1000000010660403453302183867; - bpsToRay[3997] = 1000000010662669004856881719; - bpsToRay[3998] = 1000000010664934394557571013; - bpsToRay[3999] = 1000000010667199622427376228; - bpsToRay[4000] = 1000000010669464688489416886; - bpsToRay[4001] = 1000000010671729592766807558; - bpsToRay[4002] = 1000000010673994335282657858; - bpsToRay[4003] = 1000000010676258916060072453; - bpsToRay[4004] = 1000000010678523335122151059; - bpsToRay[4005] = 1000000010680787592491988442; - bpsToRay[4006] = 1000000010683051688192674423; - bpsToRay[4007] = 1000000010685315622247293876; - bpsToRay[4008] = 1000000010687579394678926732; - bpsToRay[4009] = 1000000010689843005510647981; - bpsToRay[4010] = 1000000010692106454765527665; - bpsToRay[4011] = 1000000010694369742466630895; - bpsToRay[4012] = 1000000010696632868637017837; - bpsToRay[4013] = 1000000010698895833299743723; - bpsToRay[4014] = 1000000010701158636477858849; - bpsToRay[4015] = 1000000010703421278194408576; - bpsToRay[4016] = 1000000010705683758472433332; - bpsToRay[4017] = 1000000010707946077334968615; - bpsToRay[4018] = 1000000010710208234805044991; - bpsToRay[4019] = 1000000010712470230905688100; - bpsToRay[4020] = 1000000010714732065659918652; - bpsToRay[4021] = 1000000010716993739090752433; - bpsToRay[4022] = 1000000010719255251221200304; - bpsToRay[4023] = 1000000010721516602074268204; - bpsToRay[4024] = 1000000010723777791672957148; - bpsToRay[4025] = 1000000010726038820040263233; - bpsToRay[4026] = 1000000010728299687199177636; - bpsToRay[4027] = 1000000010730560393172686618; - bpsToRay[4028] = 1000000010732820937983771524; - bpsToRay[4029] = 1000000010735081321655408782; - bpsToRay[4030] = 1000000010737341544210569909; - bpsToRay[4031] = 1000000010739601605672221510; - bpsToRay[4032] = 1000000010741861506063325280; - bpsToRay[4033] = 1000000010744121245406838002; - bpsToRay[4034] = 1000000010746380823725711557; - bpsToRay[4035] = 1000000010748640241042892914; - bpsToRay[4036] = 1000000010750899497381324142; - bpsToRay[4037] = 1000000010753158592763942403; - bpsToRay[4038] = 1000000010755417527213679959; - bpsToRay[4039] = 1000000010757676300753464170; - bpsToRay[4040] = 1000000010759934913406217501; - bpsToRay[4041] = 1000000010762193365194857512; - bpsToRay[4042] = 1000000010764451656142296872; - bpsToRay[4043] = 1000000010766709786271443355; - bpsToRay[4044] = 1000000010768967755605199839; - bpsToRay[4045] = 1000000010771225564166464310; - bpsToRay[4046] = 1000000010773483211978129865; - bpsToRay[4047] = 1000000010775740699063084710; - bpsToRay[4048] = 1000000010777998025444212163; - bpsToRay[4049] = 1000000010780255191144390658; - bpsToRay[4050] = 1000000010782512196186493739; - bpsToRay[4051] = 1000000010784769040593390070; - bpsToRay[4052] = 1000000010787025724387943431; - bpsToRay[4053] = 1000000010789282247593012723; - bpsToRay[4054] = 1000000010791538610231451963; - bpsToRay[4055] = 1000000010793794812326110293; - bpsToRay[4056] = 1000000010796050853899831977; - bpsToRay[4057] = 1000000010798306734975456405; - bpsToRay[4058] = 1000000010800562455575818091; - bpsToRay[4059] = 1000000010802818015723746677; - bpsToRay[4060] = 1000000010805073415442066933; - bpsToRay[4061] = 1000000010807328654753598760; - bpsToRay[4062] = 1000000010809583733681157190; - bpsToRay[4063] = 1000000010811838652247552387; - bpsToRay[4064] = 1000000010814093410475589652; - bpsToRay[4065] = 1000000010816348008388069418; - bpsToRay[4066] = 1000000010818602446007787257; - bpsToRay[4067] = 1000000010820856723357533878; - bpsToRay[4068] = 1000000010823110840460095130; - bpsToRay[4069] = 1000000010825364797338252005; - bpsToRay[4070] = 1000000010827618594014780637; - bpsToRay[4071] = 1000000010829872230512452300; - bpsToRay[4072] = 1000000010832125706854033418; - bpsToRay[4073] = 1000000010834379023062285559; - bpsToRay[4074] = 1000000010836632179159965442; - bpsToRay[4075] = 1000000010838885175169824929; - bpsToRay[4076] = 1000000010841138011114611041; - bpsToRay[4077] = 1000000010843390687017065944; - bpsToRay[4078] = 1000000010845643202899926963; - bpsToRay[4079] = 1000000010847895558785926572; - bpsToRay[4080] = 1000000010850147754697792408; - bpsToRay[4081] = 1000000010852399790658247262; - bpsToRay[4082] = 1000000010854651666690009082; - bpsToRay[4083] = 1000000010856903382815790981; - bpsToRay[4084] = 1000000010859154939058301230; - bpsToRay[4085] = 1000000010861406335440243265; - bpsToRay[4086] = 1000000010863657571984315686; - bpsToRay[4087] = 1000000010865908648713212260; - bpsToRay[4088] = 1000000010868159565649621919; - bpsToRay[4089] = 1000000010870410322816228766; - bpsToRay[4090] = 1000000010872660920235712071; - bpsToRay[4091] = 1000000010874911357930746279; - bpsToRay[4092] = 1000000010877161635924001006; - bpsToRay[4093] = 1000000010879411754238141040; - bpsToRay[4094] = 1000000010881661712895826350; - bpsToRay[4095] = 1000000010883911511919712075; - bpsToRay[4096] = 1000000010886161151332448538; - bpsToRay[4097] = 1000000010888410631156681239; - bpsToRay[4098] = 1000000010890659951415050857; - bpsToRay[4099] = 1000000010892909112130193257; - bpsToRay[4100] = 1000000010895158113324739488; - bpsToRay[4101] = 1000000010897406955021315779; - bpsToRay[4102] = 1000000010899655637242543550; - bpsToRay[4103] = 1000000010901904160011039408; - bpsToRay[4104] = 1000000010904152523349415148; - bpsToRay[4105] = 1000000010906400727280277756; - bpsToRay[4106] = 1000000010908648771826229410; - bpsToRay[4107] = 1000000010910896657009867483; - bpsToRay[4108] = 1000000010913144382853784538; - bpsToRay[4109] = 1000000010915391949380568338; - bpsToRay[4110] = 1000000010917639356612801842; - bpsToRay[4111] = 1000000010919886604573063209; - bpsToRay[4112] = 1000000010922133693283925795; - bpsToRay[4113] = 1000000010924380622767958161; - bpsToRay[4114] = 1000000010926627393047724068; - bpsToRay[4115] = 1000000010928874004145782483; - bpsToRay[4116] = 1000000010931120456084687576; - bpsToRay[4117] = 1000000010933366748886988728; - bpsToRay[4118] = 1000000010935612882575230523; - bpsToRay[4119] = 1000000010937858857171952760; - bpsToRay[4120] = 1000000010940104672699690444; - bpsToRay[4121] = 1000000010942350329180973795; - bpsToRay[4122] = 1000000010944595826638328248; - bpsToRay[4123] = 1000000010946841165094274449; - bpsToRay[4124] = 1000000010949086344571328262; - bpsToRay[4125] = 1000000010951331365092000772; - bpsToRay[4126] = 1000000010953576226678798278; - bpsToRay[4127] = 1000000010955820929354222302; - bpsToRay[4128] = 1000000010958065473140769588; - bpsToRay[4129] = 1000000010960309858060932102; - bpsToRay[4130] = 1000000010962554084137197035; - bpsToRay[4131] = 1000000010964798151392046803; - bpsToRay[4132] = 1000000010967042059847959052; - bpsToRay[4133] = 1000000010969285809527406653; - bpsToRay[4134] = 1000000010971529400452857709; - bpsToRay[4135] = 1000000010973772832646775552; - bpsToRay[4136] = 1000000010976016106131618751; - bpsToRay[4137] = 1000000010978259220929841103; - bpsToRay[4138] = 1000000010980502177063891645; - bpsToRay[4139] = 1000000010982744974556214650; - bpsToRay[4140] = 1000000010984987613429249625; - bpsToRay[4141] = 1000000010987230093705431322; - bpsToRay[4142] = 1000000010989472415407189730; - bpsToRay[4143] = 1000000010991714578556950080; - bpsToRay[4144] = 1000000010993956583177132848; - bpsToRay[4145] = 1000000010996198429290153754; - bpsToRay[4146] = 1000000010998440116918423764; - bpsToRay[4147] = 1000000011000681646084349091; - bpsToRay[4148] = 1000000011002923016810331196; - bpsToRay[4149] = 1000000011005164229118766794; - bpsToRay[4150] = 1000000011007405283032047846; - bpsToRay[4151] = 1000000011009646178572561570; - bpsToRay[4152] = 1000000011011886915762690435; - bpsToRay[4153] = 1000000011014127494624812168; - bpsToRay[4154] = 1000000011016367915181299751; - bpsToRay[4155] = 1000000011018608177454521425; - bpsToRay[4156] = 1000000011020848281466840690; - bpsToRay[4157] = 1000000011023088227240616307; - bpsToRay[4158] = 1000000011025328014798202299; - bpsToRay[4159] = 1000000011027567644161947953; - bpsToRay[4160] = 1000000011029807115354197820; - bpsToRay[4161] = 1000000011032046428397291718; - bpsToRay[4162] = 1000000011034285583313564733; - bpsToRay[4163] = 1000000011036524580125347217; - bpsToRay[4164] = 1000000011038763418854964795; - bpsToRay[4165] = 1000000011041002099524738363; - bpsToRay[4166] = 1000000011043240622156984088; - bpsToRay[4167] = 1000000011045478986774013414; - bpsToRay[4168] = 1000000011047717193398133058; - bpsToRay[4169] = 1000000011049955242051645015; - bpsToRay[4170] = 1000000011052193132756846559; - bpsToRay[4171] = 1000000011054430865536030243; - bpsToRay[4172] = 1000000011056668440411483899; - bpsToRay[4173] = 1000000011058905857405490642; - bpsToRay[4174] = 1000000011061143116540328874; - bpsToRay[4175] = 1000000011063380217838272275; - bpsToRay[4176] = 1000000011065617161321589818; - bpsToRay[4177] = 1000000011067853947012545760; - bpsToRay[4178] = 1000000011070090574933399646; - bpsToRay[4179] = 1000000011072327045106406314; - bpsToRay[4180] = 1000000011074563357553815892; - bpsToRay[4181] = 1000000011076799512297873799; - bpsToRay[4182] = 1000000011079035509360820752; - bpsToRay[4183] = 1000000011081271348764892760; - bpsToRay[4184] = 1000000011083507030532321133; - bpsToRay[4185] = 1000000011085742554685332472; - bpsToRay[4186] = 1000000011087977921246148683; - bpsToRay[4187] = 1000000011090213130236986974; - bpsToRay[4188] = 1000000011092448181680059850; - bpsToRay[4189] = 1000000011094683075597575122; - bpsToRay[4190] = 1000000011096917812011735908; - bpsToRay[4191] = 1000000011099152390944740628; - bpsToRay[4192] = 1000000011101386812418783011; - bpsToRay[4193] = 1000000011103621076456052096; - bpsToRay[4194] = 1000000011105855183078732230; - bpsToRay[4195] = 1000000011108089132309003072; - bpsToRay[4196] = 1000000011110322924169039595; - bpsToRay[4197] = 1000000011112556558681012085; - bpsToRay[4198] = 1000000011114790035867086142; - bpsToRay[4199] = 1000000011117023355749422684; - bpsToRay[4200] = 1000000011119256518350177948; - bpsToRay[4201] = 1000000011121489523691503488; - bpsToRay[4202] = 1000000011123722371795546180; - bpsToRay[4203] = 1000000011125955062684448222; - bpsToRay[4204] = 1000000011128187596380347134; - bpsToRay[4205] = 1000000011130419972905375761; - bpsToRay[4206] = 1000000011132652192281662277; - bpsToRay[4207] = 1000000011134884254531330177; - bpsToRay[4208] = 1000000011137116159676498289; - bpsToRay[4209] = 1000000011139347907739280771; - bpsToRay[4210] = 1000000011141579498741787109; - bpsToRay[4211] = 1000000011143810932706122123; - bpsToRay[4212] = 1000000011146042209654385969; - bpsToRay[4213] = 1000000011148273329608674134; - bpsToRay[4214] = 1000000011150504292591077445; - bpsToRay[4215] = 1000000011152735098623682064; - bpsToRay[4216] = 1000000011154965747728569493; - bpsToRay[4217] = 1000000011157196239927816576; - bpsToRay[4218] = 1000000011159426575243495495; - bpsToRay[4219] = 1000000011161656753697673778; - bpsToRay[4220] = 1000000011163886775312414296; - bpsToRay[4221] = 1000000011166116640109775265; - bpsToRay[4222] = 1000000011168346348111810249; - bpsToRay[4223] = 1000000011170575899340568161; - bpsToRay[4224] = 1000000011172805293818093260; - bpsToRay[4225] = 1000000011175034531566425160; - bpsToRay[4226] = 1000000011177263612607598825; - bpsToRay[4227] = 1000000011179492536963644571; - bpsToRay[4228] = 1000000011181721304656588071; - bpsToRay[4229] = 1000000011183949915708450354; - bpsToRay[4230] = 1000000011186178370141247803; - bpsToRay[4231] = 1000000011188406667976992166; - bpsToRay[4232] = 1000000011190634809237690543; - bpsToRay[4233] = 1000000011192862793945345402; - bpsToRay[4234] = 1000000011195090622121954571; - bpsToRay[4235] = 1000000011197318293789511240; - bpsToRay[4236] = 1000000011199545808970003967; - bpsToRay[4237] = 1000000011201773167685416674; - bpsToRay[4238] = 1000000011204000369957728654; - bpsToRay[4239] = 1000000011206227415808914565; - bpsToRay[4240] = 1000000011208454305260944438; - bpsToRay[4241] = 1000000011210681038335783676; - bpsToRay[4242] = 1000000011212907615055393052; - bpsToRay[4243] = 1000000011215134035441728718; - bpsToRay[4244] = 1000000011217360299516742197; - bpsToRay[4245] = 1000000011219586407302380389; - bpsToRay[4246] = 1000000011221812358820585577; - bpsToRay[4247] = 1000000011224038154093295418; - bpsToRay[4248] = 1000000011226263793142442953; - bpsToRay[4249] = 1000000011228489275989956604; - bpsToRay[4250] = 1000000011230714602657760176; - bpsToRay[4251] = 1000000011232939773167772858; - bpsToRay[4252] = 1000000011235164787541909226; - bpsToRay[4253] = 1000000011237389645802079244; - bpsToRay[4254] = 1000000011239614347970188264; - bpsToRay[4255] = 1000000011241838894068137026; - bpsToRay[4256] = 1000000011244063284117821662; - bpsToRay[4257] = 1000000011246287518141133699; - bpsToRay[4258] = 1000000011248511596159960053; - bpsToRay[4259] = 1000000011250735518196183039; - bpsToRay[4260] = 1000000011252959284271680367; - bpsToRay[4261] = 1000000011255182894408325144; - bpsToRay[4262] = 1000000011257406348627985874; - bpsToRay[4263] = 1000000011259629646952526467; - bpsToRay[4264] = 1000000011261852789403806228; - bpsToRay[4265] = 1000000011264075776003679869; - bpsToRay[4266] = 1000000011266298606773997503; - bpsToRay[4267] = 1000000011268521281736604652; - bpsToRay[4268] = 1000000011270743800913342239; - bpsToRay[4269] = 1000000011272966164326046602; - bpsToRay[4270] = 1000000011275188371996549481; - bpsToRay[4271] = 1000000011277410423946678031; - bpsToRay[4272] = 1000000011279632320198254820; - bpsToRay[4273] = 1000000011281854060773097822; - bpsToRay[4274] = 1000000011284075645693020433; - bpsToRay[4275] = 1000000011286297074979831462; - bpsToRay[4276] = 1000000011288518348655335131; - bpsToRay[4277] = 1000000011290739466741331087; - bpsToRay[4278] = 1000000011292960429259614390; - bpsToRay[4279] = 1000000011295181236231975526; - bpsToRay[4280] = 1000000011297401887680200399; - bpsToRay[4281] = 1000000011299622383626070339; - bpsToRay[4282] = 1000000011301842724091362099; - bpsToRay[4283] = 1000000011304062909097847859; - bpsToRay[4284] = 1000000011306282938667295224; - bpsToRay[4285] = 1000000011308502812821467231; - bpsToRay[4286] = 1000000011310722531582122343; - bpsToRay[4287] = 1000000011312942094971014457; - bpsToRay[4288] = 1000000011315161503009892899; - bpsToRay[4289] = 1000000011317380755720502432; - bpsToRay[4290] = 1000000011319599853124583251; - bpsToRay[4291] = 1000000011321818795243870989; - bpsToRay[4292] = 1000000011324037582100096715; - bpsToRay[4293] = 1000000011326256213714986939; - bpsToRay[4294] = 1000000011328474690110263606; - bpsToRay[4295] = 1000000011330693011307644108; - bpsToRay[4296] = 1000000011332911177328841276; - bpsToRay[4297] = 1000000011335129188195563387; - bpsToRay[4298] = 1000000011337347043929514159; - bpsToRay[4299] = 1000000011339564744552392760; - bpsToRay[4300] = 1000000011341782290085893805; - bpsToRay[4301] = 1000000011343999680551707357; - bpsToRay[4302] = 1000000011346216915971518931; - bpsToRay[4303] = 1000000011348433996367009488; - bpsToRay[4304] = 1000000011350650921759855449; - bpsToRay[4305] = 1000000011352867692171728685; - bpsToRay[4306] = 1000000011355084307624296520; - bpsToRay[4307] = 1000000011357300768139221740; - bpsToRay[4308] = 1000000011359517073738162585; - bpsToRay[4309] = 1000000011361733224442772754; - bpsToRay[4310] = 1000000011363949220274701408; - bpsToRay[4311] = 1000000011366165061255593168; - bpsToRay[4312] = 1000000011368380747407088120; - bpsToRay[4313] = 1000000011370596278750821810; - bpsToRay[4314] = 1000000011372811655308425254; - bpsToRay[4315] = 1000000011375026877101524932; - bpsToRay[4316] = 1000000011377241944151742792; - bpsToRay[4317] = 1000000011379456856480696254; - bpsToRay[4318] = 1000000011381671614109998202; - bpsToRay[4319] = 1000000011383886217061256998; - bpsToRay[4320] = 1000000011386100665356076475; - bpsToRay[4321] = 1000000011388314959016055939; - bpsToRay[4322] = 1000000011390529098062790173; - bpsToRay[4323] = 1000000011392743082517869435; - bpsToRay[4324] = 1000000011394956912402879463; - bpsToRay[4325] = 1000000011397170587739401474; - bpsToRay[4326] = 1000000011399384108549012164; - bpsToRay[4327] = 1000000011401597474853283711; - bpsToRay[4328] = 1000000011403810686673783778; - bpsToRay[4329] = 1000000011406023744032075511; - bpsToRay[4330] = 1000000011408236646949717541; - bpsToRay[4331] = 1000000011410449395448263986; - bpsToRay[4332] = 1000000011412661989549264455; - bpsToRay[4333] = 1000000011414874429274264041; - bpsToRay[4334] = 1000000011417086714644803332; - bpsToRay[4335] = 1000000011419298845682418407; - bpsToRay[4336] = 1000000011421510822408640836; - bpsToRay[4337] = 1000000011423722644844997686; - bpsToRay[4338] = 1000000011425934313013011518; - bpsToRay[4339] = 1000000011428145826934200391; - bpsToRay[4340] = 1000000011430357186630077862; - bpsToRay[4341] = 1000000011432568392122152986; - bpsToRay[4342] = 1000000011434779443431930319; - bpsToRay[4343] = 1000000011436990340580909922; - bpsToRay[4344] = 1000000011439201083590587356; - bpsToRay[4345] = 1000000011441411672482453687; - bpsToRay[4346] = 1000000011443622107277995486; - bpsToRay[4347] = 1000000011445832387998694833; - bpsToRay[4348] = 1000000011448042514666029315; - bpsToRay[4349] = 1000000011450252487301472028; - bpsToRay[4350] = 1000000011452462305926491579; - bpsToRay[4351] = 1000000011454671970562552089; - bpsToRay[4352] = 1000000011456881481231113188; - bpsToRay[4353] = 1000000011459090837953630024; - bpsToRay[4354] = 1000000011461300040751553259; - bpsToRay[4355] = 1000000011463509089646329073; - bpsToRay[4356] = 1000000011465717984659399163; - bpsToRay[4357] = 1000000011467926725812200747; - bpsToRay[4358] = 1000000011470135313126166561; - bpsToRay[4359] = 1000000011472343746622724867; - bpsToRay[4360] = 1000000011474552026323299446; - bpsToRay[4361] = 1000000011476760152249309607; - bpsToRay[4362] = 1000000011478968124422170181; - bpsToRay[4363] = 1000000011481175942863291530; - bpsToRay[4364] = 1000000011483383607594079540; - bpsToRay[4365] = 1000000011485591118635935631; - bpsToRay[4366] = 1000000011487798476010256750; - bpsToRay[4367] = 1000000011490005679738435376; - bpsToRay[4368] = 1000000011492212729841859524; - bpsToRay[4369] = 1000000011494419626341912740; - bpsToRay[4370] = 1000000011496626369259974109; - bpsToRay[4371] = 1000000011498832958617418250; - bpsToRay[4372] = 1000000011501039394435615322; - bpsToRay[4373] = 1000000011503245676735931022; - bpsToRay[4374] = 1000000011505451805539726589; - bpsToRay[4375] = 1000000011507657780868358802; - bpsToRay[4376] = 1000000011509863602743179986; - bpsToRay[4377] = 1000000011512069271185538006; - bpsToRay[4378] = 1000000011514274786216776278; - bpsToRay[4379] = 1000000011516480147858233760; - bpsToRay[4380] = 1000000011518685356131244960; - bpsToRay[4381] = 1000000011520890411057139937; - bpsToRay[4382] = 1000000011523095312657244296; - bpsToRay[4383] = 1000000011525300060952879198; - bpsToRay[4384] = 1000000011527504655965361356; - bpsToRay[4385] = 1000000011529709097716003036; - bpsToRay[4386] = 1000000011531913386226112060; - bpsToRay[4387] = 1000000011534117521516991808; - bpsToRay[4388] = 1000000011536321503609941215; - bpsToRay[4389] = 1000000011538525332526254779; - bpsToRay[4390] = 1000000011540729008287222556; - bpsToRay[4391] = 1000000011542932530914130163; - bpsToRay[4392] = 1000000011545135900428258782; - bpsToRay[4393] = 1000000011547339116850885159; - bpsToRay[4394] = 1000000011549542180203281602; - bpsToRay[4395] = 1000000011551745090506715989; - bpsToRay[4396] = 1000000011553947847782451765; - bpsToRay[4397] = 1000000011556150452051747944; - bpsToRay[4398] = 1000000011558352903335859111; - bpsToRay[4399] = 1000000011560555201656035419; - bpsToRay[4400] = 1000000011562757347033522598; - bpsToRay[4401] = 1000000011564959339489561951; - bpsToRay[4402] = 1000000011567161179045390355; - bpsToRay[4403] = 1000000011569362865722240263; - bpsToRay[4404] = 1000000011571564399541339706; - bpsToRay[4405] = 1000000011573765780523912298; - bpsToRay[4406] = 1000000011575967008691177226; - bpsToRay[4407] = 1000000011578168084064349263; - bpsToRay[4408] = 1000000011580369006664638762; - bpsToRay[4409] = 1000000011582569776513251664; - bpsToRay[4410] = 1000000011584770393631389491; - bpsToRay[4411] = 1000000011586970858040249351; - bpsToRay[4412] = 1000000011589171169761023944; - bpsToRay[4413] = 1000000011591371328814901553; - bpsToRay[4414] = 1000000011593571335223066054; - bpsToRay[4415] = 1000000011595771189006696913; - bpsToRay[4416] = 1000000011597970890186969190; - bpsToRay[4417] = 1000000011600170438785053539; - bpsToRay[4418] = 1000000011602369834822116205; - bpsToRay[4419] = 1000000011604569078319319032; - bpsToRay[4420] = 1000000011606768169297819461; - bpsToRay[4421] = 1000000011608967107778770531; - bpsToRay[4422] = 1000000011611165893783320880; - bpsToRay[4423] = 1000000011613364527332614750; - bpsToRay[4424] = 1000000011615563008447791980; - bpsToRay[4425] = 1000000011617761337149988016; - bpsToRay[4426] = 1000000011619959513460333909; - bpsToRay[4427] = 1000000011622157537399956313; - bpsToRay[4428] = 1000000011624355408989977491; - bpsToRay[4429] = 1000000011626553128251515315; - bpsToRay[4430] = 1000000011628750695205683263; - bpsToRay[4431] = 1000000011630948109873590427; - bpsToRay[4432] = 1000000011633145372276341510; - bpsToRay[4433] = 1000000011635342482435036828; - bpsToRay[4434] = 1000000011637539440370772309; - bpsToRay[4435] = 1000000011639736246104639501; - bpsToRay[4436] = 1000000011641932899657725566; - bpsToRay[4437] = 1000000011644129401051113283; - bpsToRay[4438] = 1000000011646325750305881052; - bpsToRay[4439] = 1000000011648521947443102894; - bpsToRay[4440] = 1000000011650717992483848450; - bpsToRay[4441] = 1000000011652913885449182982; - bpsToRay[4442] = 1000000011655109626360167380; - bpsToRay[4443] = 1000000011657305215237858159; - bpsToRay[4444] = 1000000011659500652103307456; - bpsToRay[4445] = 1000000011661695936977563040; - bpsToRay[4446] = 1000000011663891069881668309; - bpsToRay[4447] = 1000000011666086050836662286; - bpsToRay[4448] = 1000000011668280879863579631; - bpsToRay[4449] = 1000000011670475556983450634; - bpsToRay[4450] = 1000000011672670082217301219; - bpsToRay[4451] = 1000000011674864455586152944; - bpsToRay[4452] = 1000000011677058677111023005; - bpsToRay[4453] = 1000000011679252746812924234; - bpsToRay[4454] = 1000000011681446664712865102; - bpsToRay[4455] = 1000000011683640430831849720; - bpsToRay[4456] = 1000000011685834045190877838; - bpsToRay[4457] = 1000000011688027507810944851; - bpsToRay[4458] = 1000000011690220818713041795; - bpsToRay[4459] = 1000000011692413977918155352; - bpsToRay[4460] = 1000000011694606985447267850; - bpsToRay[4461] = 1000000011696799841321357263; - bpsToRay[4462] = 1000000011698992545561397213; - bpsToRay[4463] = 1000000011701185098188356972; - bpsToRay[4464] = 1000000011703377499223201464; - bpsToRay[4465] = 1000000011705569748686891261; - bpsToRay[4466] = 1000000011707761846600382591; - bpsToRay[4467] = 1000000011709953792984627335; - bpsToRay[4468] = 1000000011712145587860573032; - bpsToRay[4469] = 1000000011714337231249162871; - bpsToRay[4470] = 1000000011716528723171335709; - bpsToRay[4471] = 1000000011718720063648026051; - bpsToRay[4472] = 1000000011720911252700164071; - bpsToRay[4473] = 1000000011723102290348675597; - bpsToRay[4474] = 1000000011725293176614482128; - bpsToRay[4475] = 1000000011727483911518500818; - bpsToRay[4476] = 1000000011729674495081644493; - bpsToRay[4477] = 1000000011731864927324821641; - bpsToRay[4478] = 1000000011734055208268936418; - bpsToRay[4479] = 1000000011736245337934888652; - bpsToRay[4480] = 1000000011738435316343573834; - bpsToRay[4481] = 1000000011740625143515883134; - bpsToRay[4482] = 1000000011742814819472703388; - bpsToRay[4483] = 1000000011745004344234917107; - bpsToRay[4484] = 1000000011747193717823402479; - bpsToRay[4485] = 1000000011749382940259033365; - bpsToRay[4486] = 1000000011751572011562679304; - bpsToRay[4487] = 1000000011753760931755205513; - bpsToRay[4488] = 1000000011755949700857472887; - bpsToRay[4489] = 1000000011758138318890338005; - bpsToRay[4490] = 1000000011760326785874653124; - bpsToRay[4491] = 1000000011762515101831266185; - bpsToRay[4492] = 1000000011764703266781020815; - bpsToRay[4493] = 1000000011766891280744756325; - bpsToRay[4494] = 1000000011769079143743307711; - bpsToRay[4495] = 1000000011771266855797505659; - bpsToRay[4496] = 1000000011773454416928176542; - bpsToRay[4497] = 1000000011775641827156142425; - bpsToRay[4498] = 1000000011777829086502221061; - bpsToRay[4499] = 1000000011780016194987225901; - bpsToRay[4500] = 1000000011782203152631966084; - bpsToRay[4501] = 1000000011784389959457246446; - bpsToRay[4502] = 1000000011786576615483867520; - bpsToRay[4503] = 1000000011788763120732625534; - bpsToRay[4504] = 1000000011790949475224312417; - bpsToRay[4505] = 1000000011793135678979715794; - bpsToRay[4506] = 1000000011795321732019618995; - bpsToRay[4507] = 1000000011797507634364801050; - bpsToRay[4508] = 1000000011799693386036036690; - bpsToRay[4509] = 1000000011801878987054096353; - bpsToRay[4510] = 1000000011804064437439746183; - bpsToRay[4511] = 1000000011806249737213748028; - bpsToRay[4512] = 1000000011808434886396859445; - bpsToRay[4513] = 1000000011810619885009833701; - bpsToRay[4514] = 1000000011812804733073419772; - bpsToRay[4515] = 1000000011814989430608362346; - bpsToRay[4516] = 1000000011817173977635401824; - bpsToRay[4517] = 1000000011819358374175274320; - bpsToRay[4518] = 1000000011821542620248711663; - bpsToRay[4519] = 1000000011823726715876441397; - bpsToRay[4520] = 1000000011825910661079186786; - bpsToRay[4521] = 1000000011828094455877666811; - bpsToRay[4522] = 1000000011830278100292596173; - bpsToRay[4523] = 1000000011832461594344685292; - bpsToRay[4524] = 1000000011834644938054640314; - bpsToRay[4525] = 1000000011836828131443163102; - bpsToRay[4526] = 1000000011839011174530951252; - bpsToRay[4527] = 1000000011841194067338698076; - bpsToRay[4528] = 1000000011843376809887092621; - bpsToRay[4529] = 1000000011845559402196819657; - bpsToRay[4530] = 1000000011847741844288559684; - bpsToRay[4531] = 1000000011849924136182988931; - bpsToRay[4532] = 1000000011852106277900779365; - bpsToRay[4533] = 1000000011854288269462598676; - bpsToRay[4534] = 1000000011856470110889110294; - bpsToRay[4535] = 1000000011858651802200973384; - bpsToRay[4536] = 1000000011860833343418842843; - bpsToRay[4537] = 1000000011863014734563369310; - bpsToRay[4538] = 1000000011865195975655199159; - bpsToRay[4539] = 1000000011867377066714974505; - bpsToRay[4540] = 1000000011869558007763333206; - bpsToRay[4541] = 1000000011871738798820908856; - bpsToRay[4542] = 1000000011873919439908330799; - bpsToRay[4543] = 1000000011876099931046224119; - bpsToRay[4544] = 1000000011878280272255209648; - bpsToRay[4545] = 1000000011880460463555903962; - bpsToRay[4546] = 1000000011882640504968919386; - bpsToRay[4547] = 1000000011884820396514863997; - bpsToRay[4548] = 1000000011887000138214341617; - bpsToRay[4549] = 1000000011889179730087951822; - bpsToRay[4550] = 1000000011891359172156289942; - bpsToRay[4551] = 1000000011893538464439947057; - bpsToRay[4552] = 1000000011895717606959510007; - bpsToRay[4553] = 1000000011897896599735561381; - bpsToRay[4554] = 1000000011900075442788679533; - bpsToRay[4555] = 1000000011902254136139438568; - bpsToRay[4556] = 1000000011904432679808408357; - bpsToRay[4557] = 1000000011906611073816154526; - bpsToRay[4558] = 1000000011908789318183238468; - bpsToRay[4559] = 1000000011910967412930217335; - bpsToRay[4560] = 1000000011913145358077644046; - bpsToRay[4561] = 1000000011915323153646067283; - bpsToRay[4562] = 1000000011917500799656031495; - bpsToRay[4563] = 1000000011919678296128076901; - bpsToRay[4564] = 1000000011921855643082739486; - bpsToRay[4565] = 1000000011924032840540551006; - bpsToRay[4566] = 1000000011926209888522038989; - bpsToRay[4567] = 1000000011928386787047726732; - bpsToRay[4568] = 1000000011930563536138133312; - bpsToRay[4569] = 1000000011932740135813773575; - bpsToRay[4570] = 1000000011934916586095158143; - bpsToRay[4571] = 1000000011937092887002793418; - bpsToRay[4572] = 1000000011939269038557181578; - bpsToRay[4573] = 1000000011941445040778820581; - bpsToRay[4574] = 1000000011943620893688204164; - bpsToRay[4575] = 1000000011945796597305821848; - bpsToRay[4576] = 1000000011947972151652158936; - bpsToRay[4577] = 1000000011950147556747696515; - bpsToRay[4578] = 1000000011952322812612911454; - bpsToRay[4579] = 1000000011954497919268276412; - bpsToRay[4580] = 1000000011956672876734259834; - bpsToRay[4581] = 1000000011958847685031325954; - bpsToRay[4582] = 1000000011961022344179934796; - bpsToRay[4583] = 1000000011963196854200542173; - bpsToRay[4584] = 1000000011965371215113599692; - bpsToRay[4585] = 1000000011967545426939554751; - bpsToRay[4586] = 1000000011969719489698850545; - bpsToRay[4587] = 1000000011971893403411926063; - bpsToRay[4588] = 1000000011974067168099216089; - bpsToRay[4589] = 1000000011976240783781151209; - bpsToRay[4590] = 1000000011978414250478157804; - bpsToRay[4591] = 1000000011980587568210658056; - bpsToRay[4592] = 1000000011982760736999069949; - bpsToRay[4593] = 1000000011984933756863807269; - bpsToRay[4594] = 1000000011987106627825279606; - bpsToRay[4595] = 1000000011989279349903892354; - bpsToRay[4596] = 1000000011991451923120046712; - bpsToRay[4597] = 1000000011993624347494139689; - bpsToRay[4598] = 1000000011995796623046564099; - bpsToRay[4599] = 1000000011997968749797708565; - bpsToRay[4600] = 1000000012000140727767957524; - bpsToRay[4601] = 1000000012002312556977691222; - bpsToRay[4602] = 1000000012004484237447285716; - bpsToRay[4603] = 1000000012006655769197112882; - bpsToRay[4604] = 1000000012008827152247540405; - bpsToRay[4605] = 1000000012010998386618931791; - bpsToRay[4606] = 1000000012013169472331646360; - bpsToRay[4607] = 1000000012015340409406039253; - bpsToRay[4608] = 1000000012017511197862461428; - bpsToRay[4609] = 1000000012019681837721259668; - bpsToRay[4610] = 1000000012021852329002776572; - bpsToRay[4611] = 1000000012024022671727350564; - bpsToRay[4612] = 1000000012026192865915315897; - bpsToRay[4613] = 1000000012028362911587002643; - bpsToRay[4614] = 1000000012030532808762736703; - bpsToRay[4615] = 1000000012032702557462839807; - bpsToRay[4616] = 1000000012034872157707629511; - bpsToRay[4617] = 1000000012037041609517419201; - bpsToRay[4618] = 1000000012039210912912518097; - bpsToRay[4619] = 1000000012041380067913231248; - bpsToRay[4620] = 1000000012043549074539859539; - bpsToRay[4621] = 1000000012045717932812699686; - bpsToRay[4622] = 1000000012047886642752044245; - bpsToRay[4623] = 1000000012050055204378181605; - bpsToRay[4624] = 1000000012052223617711395993; - bpsToRay[4625] = 1000000012054391882771967477; - bpsToRay[4626] = 1000000012056559999580171966; - bpsToRay[4627] = 1000000012058727968156281206; - bpsToRay[4628] = 1000000012060895788520562788; - bpsToRay[4629] = 1000000012063063460693280149; - bpsToRay[4630] = 1000000012065230984694692566; - bpsToRay[4631] = 1000000012067398360545055164; - bpsToRay[4632] = 1000000012069565588264618915; - bpsToRay[4633] = 1000000012071732667873630640; - bpsToRay[4634] = 1000000012073899599392333007; - bpsToRay[4635] = 1000000012076066382840964537; - bpsToRay[4636] = 1000000012078233018239759599; - bpsToRay[4637] = 1000000012080399505608948418; - bpsToRay[4638] = 1000000012082565844968757072; - bpsToRay[4639] = 1000000012084732036339407491; - bpsToRay[4640] = 1000000012086898079741117465; - bpsToRay[4641] = 1000000012089063975194100640; - bpsToRay[4642] = 1000000012091229722718566519; - bpsToRay[4643] = 1000000012093395322334720465; - bpsToRay[4644] = 1000000012095560774062763701; - bpsToRay[4645] = 1000000012097726077922893315; - bpsToRay[4646] = 1000000012099891233935302252; - bpsToRay[4647] = 1000000012102056242120179326; - bpsToRay[4648] = 1000000012104221102497709214; - bpsToRay[4649] = 1000000012106385815088072459; - bpsToRay[4650] = 1000000012108550379911445472; - bpsToRay[4651] = 1000000012110714796988000533; - bpsToRay[4652] = 1000000012112879066337905789; - bpsToRay[4653] = 1000000012115043187981325261; - bpsToRay[4654] = 1000000012117207161938418839; - bpsToRay[4655] = 1000000012119370988229342288; - bpsToRay[4656] = 1000000012121534666874247247; - bpsToRay[4657] = 1000000012123698197893281228; - bpsToRay[4658] = 1000000012125861581306587623; - bpsToRay[4659] = 1000000012128024817134305697; - bpsToRay[4660] = 1000000012130187905396570598; - bpsToRay[4661] = 1000000012132350846113513350; - bpsToRay[4662] = 1000000012134513639305260860; - bpsToRay[4663] = 1000000012136676284991935918; - bpsToRay[4664] = 1000000012138838783193657193; - bpsToRay[4665] = 1000000012141001133930539244; - bpsToRay[4666] = 1000000012143163337222692509; - bpsToRay[4667] = 1000000012145325393090223317; - bpsToRay[4668] = 1000000012147487301553233883; - bpsToRay[4669] = 1000000012149649062631822311; - bpsToRay[4670] = 1000000012151810676346082594; - bpsToRay[4671] = 1000000012153972142716104618; - bpsToRay[4672] = 1000000012156133461761974158; - bpsToRay[4673] = 1000000012158294633503772885; - bpsToRay[4674] = 1000000012160455657961578363; - bpsToRay[4675] = 1000000012162616535155464050; - bpsToRay[4676] = 1000000012164777265105499304; - bpsToRay[4677] = 1000000012166937847831749378; - bpsToRay[4678] = 1000000012169098283354275425; - bpsToRay[4679] = 1000000012171258571693134496; - bpsToRay[4680] = 1000000012173418712868379547; - bpsToRay[4681] = 1000000012175578706900059431; - bpsToRay[4682] = 1000000012177738553808218907; - bpsToRay[4683] = 1000000012179898253612898639; - bpsToRay[4684] = 1000000012182057806334135196; - bpsToRay[4685] = 1000000012184217211991961053; - bpsToRay[4686] = 1000000012186376470606404593; - bpsToRay[4687] = 1000000012188535582197490106; - bpsToRay[4688] = 1000000012190694546785237795; - bpsToRay[4689] = 1000000012192853364389663774; - bpsToRay[4690] = 1000000012195012035030780065; - bpsToRay[4691] = 1000000012197170558728594608; - bpsToRay[4692] = 1000000012199328935503111256; - bpsToRay[4693] = 1000000012201487165374329775; - bpsToRay[4694] = 1000000012203645248362245852; - bpsToRay[4695] = 1000000012205803184486851087; - bpsToRay[4696] = 1000000012207960973768133003; - bpsToRay[4697] = 1000000012210118616226075039; - bpsToRay[4698] = 1000000012212276111880656560; - bpsToRay[4699] = 1000000012214433460751852848; - bpsToRay[4700] = 1000000012216590662859635112; - bpsToRay[4701] = 1000000012218747718223970482; - bpsToRay[4702] = 1000000012220904626864822019; - bpsToRay[4703] = 1000000012223061388802148704; - bpsToRay[4704] = 1000000012225218004055905450; - bpsToRay[4705] = 1000000012227374472646043097; - bpsToRay[4706] = 1000000012229530794592508416; - bpsToRay[4707] = 1000000012231686969915244108; - bpsToRay[4708] = 1000000012233842998634188809; - bpsToRay[4709] = 1000000012235998880769277082; - bpsToRay[4710] = 1000000012238154616340439431; - bpsToRay[4711] = 1000000012240310205367602293; - bpsToRay[4712] = 1000000012242465647870688040; - bpsToRay[4713] = 1000000012244620943869614982; - bpsToRay[4714] = 1000000012246776093384297371; - bpsToRay[4715] = 1000000012248931096434645396; - bpsToRay[4716] = 1000000012251085953040565187; - bpsToRay[4717] = 1000000012253240663221958817; - bpsToRay[4718] = 1000000012255395226998724301; - bpsToRay[4719] = 1000000012257549644390755600; - bpsToRay[4720] = 1000000012259703915417942619; - bpsToRay[4721] = 1000000012261858040100171212; - bpsToRay[4722] = 1000000012264012018457323175; - bpsToRay[4723] = 1000000012266165850509276259; - bpsToRay[4724] = 1000000012268319536275904161; - bpsToRay[4725] = 1000000012270473075777076530; - bpsToRay[4726] = 1000000012272626469032658968; - bpsToRay[4727] = 1000000012274779716062513028; - bpsToRay[4728] = 1000000012276932816886496218; - bpsToRay[4729] = 1000000012279085771524462002; - bpsToRay[4730] = 1000000012281238579996259799; - bpsToRay[4731] = 1000000012283391242321734988; - bpsToRay[4732] = 1000000012285543758520728905; - bpsToRay[4733] = 1000000012287696128613078844; - bpsToRay[4734] = 1000000012289848352618618062; - bpsToRay[4735] = 1000000012292000430557175778; - bpsToRay[4736] = 1000000012294152362448577173; - bpsToRay[4737] = 1000000012296304148312643392; - bpsToRay[4738] = 1000000012298455788169191545; - bpsToRay[4739] = 1000000012300607282038034711; - bpsToRay[4740] = 1000000012302758629938981931; - bpsToRay[4741] = 1000000012304909831891838220; - bpsToRay[4742] = 1000000012307060887916404559; - bpsToRay[4743] = 1000000012309211798032477901; - bpsToRay[4744] = 1000000012311362562259851171; - bpsToRay[4745] = 1000000012313513180618313265; - bpsToRay[4746] = 1000000012315663653127649055; - bpsToRay[4747] = 1000000012317813979807639387; - bpsToRay[4748] = 1000000012319964160678061084; - bpsToRay[4749] = 1000000012322114195758686945; - bpsToRay[4750] = 1000000012324264085069285747; - bpsToRay[4751] = 1000000012326413828629622247; - bpsToRay[4752] = 1000000012328563426459457184; - bpsToRay[4753] = 1000000012330712878578547277; - bpsToRay[4754] = 1000000012332862185006645225; - bpsToRay[4755] = 1000000012335011345763499718; - bpsToRay[4756] = 1000000012337160360868855422; - bpsToRay[4757] = 1000000012339309230342452997; - bpsToRay[4758] = 1000000012341457954204029084; - bpsToRay[4759] = 1000000012343606532473316314; - bpsToRay[4760] = 1000000012345754965170043307; - bpsToRay[4761] = 1000000012347903252313934676; - bpsToRay[4762] = 1000000012350051393924711022; - bpsToRay[4763] = 1000000012352199390022088940; - bpsToRay[4764] = 1000000012354347240625781016; - bpsToRay[4765] = 1000000012356494945755495834; - bpsToRay[4766] = 1000000012358642505430937972; - bpsToRay[4767] = 1000000012360789919671808004; - bpsToRay[4768] = 1000000012362937188497802506; - bpsToRay[4769] = 1000000012365084311928614047; - bpsToRay[4770] = 1000000012367231289983931199; - bpsToRay[4771] = 1000000012369378122683438536; - bpsToRay[4772] = 1000000012371524810046816632; - bpsToRay[4773] = 1000000012373671352093742067; - bpsToRay[4774] = 1000000012375817748843887422; - bpsToRay[4775] = 1000000012377964000316921287; - bpsToRay[4776] = 1000000012380110106532508255; - bpsToRay[4777] = 1000000012382256067510308928; - bpsToRay[4778] = 1000000012384401883269979920; - bpsToRay[4779] = 1000000012386547553831173848; - bpsToRay[4780] = 1000000012388693079213539345; - bpsToRay[4781] = 1000000012390838459436721054; - bpsToRay[4782] = 1000000012392983694520359633; - bpsToRay[4783] = 1000000012395128784484091752; - bpsToRay[4784] = 1000000012397273729347550096; - bpsToRay[4785] = 1000000012399418529130363366; - bpsToRay[4786] = 1000000012401563183852156283; - bpsToRay[4787] = 1000000012403707693532549584; - bpsToRay[4788] = 1000000012405852058191160026; - bpsToRay[4789] = 1000000012407996277847600385; - bpsToRay[4790] = 1000000012410140352521479464; - bpsToRay[4791] = 1000000012412284282232402082; - bpsToRay[4792] = 1000000012414428066999969084; - bpsToRay[4793] = 1000000012416571706843777343; - bpsToRay[4794] = 1000000012418715201783419755; - bpsToRay[4795] = 1000000012420858551838485241; - bpsToRay[4796] = 1000000012423001757028558755; - bpsToRay[4797] = 1000000012425144817373221276; - bpsToRay[4798] = 1000000012427287732892049817; - bpsToRay[4799] = 1000000012429430503604617418; - bpsToRay[4800] = 1000000012431573129530493155; - bpsToRay[4801] = 1000000012433715610689242134; - bpsToRay[4802] = 1000000012435857947100425498; - bpsToRay[4803] = 1000000012438000138783600426; - bpsToRay[4804] = 1000000012440142185758320132; - bpsToRay[4805] = 1000000012442284088044133868; - bpsToRay[4806] = 1000000012444425845660586926; - bpsToRay[4807] = 1000000012446567458627220637; - bpsToRay[4808] = 1000000012448708926963572372; - bpsToRay[4809] = 1000000012450850250689175545; - bpsToRay[4810] = 1000000012452991429823559613; - bpsToRay[4811] = 1000000012455132464386250078; - bpsToRay[4812] = 1000000012457273354396768485; - bpsToRay[4813] = 1000000012459414099874632428; - bpsToRay[4814] = 1000000012461554700839355545; - bpsToRay[4815] = 1000000012463695157310447527; - bpsToRay[4816] = 1000000012465835469307414110; - bpsToRay[4817] = 1000000012467975636849757081; - bpsToRay[4818] = 1000000012470115659956974282; - bpsToRay[4819] = 1000000012472255538648559605; - bpsToRay[4820] = 1000000012474395272944002997; - bpsToRay[4821] = 1000000012476534862862790458; - bpsToRay[4822] = 1000000012478674308424404046; - bpsToRay[4823] = 1000000012480813609648321873; - bpsToRay[4824] = 1000000012482952766554018113; - bpsToRay[4825] = 1000000012485091779160962996; - bpsToRay[4826] = 1000000012487230647488622814; - bpsToRay[4827] = 1000000012489369371556459918; - bpsToRay[4828] = 1000000012491507951383932723; - bpsToRay[4829] = 1000000012493646386990495707; - bpsToRay[4830] = 1000000012495784678395599413; - bpsToRay[4831] = 1000000012497922825618690446; - bpsToRay[4832] = 1000000012500060828679211483; - bpsToRay[4833] = 1000000012502198687596601264; - bpsToRay[4834] = 1000000012504336402390294600; - bpsToRay[4835] = 1000000012506473973079722370; - bpsToRay[4836] = 1000000012508611399684311526; - bpsToRay[4837] = 1000000012510748682223485091; - bpsToRay[4838] = 1000000012512885820716662158; - bpsToRay[4839] = 1000000012515022815183257897; - bpsToRay[4840] = 1000000012517159665642683553; - bpsToRay[4841] = 1000000012519296372114346446; - bpsToRay[4842] = 1000000012521432934617649973; - bpsToRay[4843] = 1000000012523569353171993611; - bpsToRay[4844] = 1000000012525705627796772912; - bpsToRay[4845] = 1000000012527841758511379512; - bpsToRay[4846] = 1000000012529977745335201128; - bpsToRay[4847] = 1000000012532113588287621558; - bpsToRay[4848] = 1000000012534249287388020684; - bpsToRay[4849] = 1000000012536384842655774473; - bpsToRay[4850] = 1000000012538520254110254976; - bpsToRay[4851] = 1000000012540655521770830332; - bpsToRay[4852] = 1000000012542790645656864768; - bpsToRay[4853] = 1000000012544925625787718599; - bpsToRay[4854] = 1000000012547060462182748227; - bpsToRay[4855] = 1000000012549195154861306151; - bpsToRay[4856] = 1000000012551329703842740957; - bpsToRay[4857] = 1000000012553464109146397324; - bpsToRay[4858] = 1000000012555598370791616028; - bpsToRay[4859] = 1000000012557732488797733936; - bpsToRay[4860] = 1000000012559866463184084017; - bpsToRay[4861] = 1000000012562000293969995331; - bpsToRay[4862] = 1000000012564133981174793037; - bpsToRay[4863] = 1000000012566267524817798398; - bpsToRay[4864] = 1000000012568400924918328770; - bpsToRay[4865] = 1000000012570534181495697619; - bpsToRay[4866] = 1000000012572667294569214506; - bpsToRay[4867] = 1000000012574800264158185098; - bpsToRay[4868] = 1000000012576933090281911168; - bpsToRay[4869] = 1000000012579065772959690591; - bpsToRay[4870] = 1000000012581198312210817352; - bpsToRay[4871] = 1000000012583330708054581542; - bpsToRay[4872] = 1000000012585462960510269361; - bpsToRay[4873] = 1000000012587595069597163118; - bpsToRay[4874] = 1000000012589727035334541233; - bpsToRay[4875] = 1000000012591858857741678240; - bpsToRay[4876] = 1000000012593990536837844781; - bpsToRay[4877] = 1000000012596122072642307617; - bpsToRay[4878] = 1000000012598253465174329620; - bpsToRay[4879] = 1000000012600384714453169781; - bpsToRay[4880] = 1000000012602515820498083206; - bpsToRay[4881] = 1000000012604646783328321121; - bpsToRay[4882] = 1000000012606777602963130868; - bpsToRay[4883] = 1000000012608908279421755911; - bpsToRay[4884] = 1000000012611038812723435837; - bpsToRay[4885] = 1000000012613169202887406351; - bpsToRay[4886] = 1000000012615299449932899285; - bpsToRay[4887] = 1000000012617429553879142594; - bpsToRay[4888] = 1000000012619559514745360358; - bpsToRay[4889] = 1000000012621689332550772783; - bpsToRay[4890] = 1000000012623819007314596205; - bpsToRay[4891] = 1000000012625948539056043084; - bpsToRay[4892] = 1000000012628077927794322013; - bpsToRay[4893] = 1000000012630207173548637715; - bpsToRay[4894] = 1000000012632336276338191046; - bpsToRay[4895] = 1000000012634465236182178989; - bpsToRay[4896] = 1000000012636594053099794667; - bpsToRay[4897] = 1000000012638722727110227335; - bpsToRay[4898] = 1000000012640851258232662384; - bpsToRay[4899] = 1000000012642979646486281341; - bpsToRay[4900] = 1000000012645107891890261872; - bpsToRay[4901] = 1000000012647235994463777781; - bpsToRay[4902] = 1000000012649363954225999014; - bpsToRay[4903] = 1000000012651491771196091654; - bpsToRay[4904] = 1000000012653619445393217929; - bpsToRay[4905] = 1000000012655746976836536210; - bpsToRay[4906] = 1000000012657874365545201009; - bpsToRay[4907] = 1000000012660001611538362988; - bpsToRay[4908] = 1000000012662128714835168951; - bpsToRay[4909] = 1000000012664255675454761851; - bpsToRay[4910] = 1000000012666382493416280789; - bpsToRay[4911] = 1000000012668509168738861013; - bpsToRay[4912] = 1000000012670635701441633926; - bpsToRay[4913] = 1000000012672762091543727077; - bpsToRay[4914] = 1000000012674888339064264171; - bpsToRay[4915] = 1000000012677014444022365063; - bpsToRay[4916] = 1000000012679140406437145768; - bpsToRay[4917] = 1000000012681266226327718450; - bpsToRay[4918] = 1000000012683391903713191434; - bpsToRay[4919] = 1000000012685517438612669200; - bpsToRay[4920] = 1000000012687642831045252386; - bpsToRay[4921] = 1000000012689768081030037793; - bpsToRay[4922] = 1000000012691893188586118377; - bpsToRay[4923] = 1000000012694018153732583262; - bpsToRay[4924] = 1000000012696142976488517730; - bpsToRay[4925] = 1000000012698267656873003228; - bpsToRay[4926] = 1000000012700392194905117369; - bpsToRay[4927] = 1000000012702516590603933928; - bpsToRay[4928] = 1000000012704640843988522851; - bpsToRay[4929] = 1000000012706764955077950249; - bpsToRay[4930] = 1000000012708888923891278404; - bpsToRay[4931] = 1000000012711012750447565765; - bpsToRay[4932] = 1000000012713136434765866954; - bpsToRay[4933] = 1000000012715259976865232764; - bpsToRay[4934] = 1000000012717383376764710160; - bpsToRay[4935] = 1000000012719506634483342283; - bpsToRay[4936] = 1000000012721629750040168448; - bpsToRay[4937] = 1000000012723752723454224145; - bpsToRay[4938] = 1000000012725875554744541042; - bpsToRay[4939] = 1000000012727998243930146984; - bpsToRay[4940] = 1000000012730120791030065998; - bpsToRay[4941] = 1000000012732243196063318286; - bpsToRay[4942] = 1000000012734365459048920235; - bpsToRay[4943] = 1000000012736487580005884415; - bpsToRay[4944] = 1000000012738609558953219573; - bpsToRay[4945] = 1000000012740731395909930647; - bpsToRay[4946] = 1000000012742853090895018757; - bpsToRay[4947] = 1000000012744974643927481210; - bpsToRay[4948] = 1000000012747096055026311497; - bpsToRay[4949] = 1000000012749217324210499303; - bpsToRay[4950] = 1000000012751338451499030498; - bpsToRay[4951] = 1000000012753459436910887143; - bpsToRay[4952] = 1000000012755580280465047490; - bpsToRay[4953] = 1000000012757700982180485986; - bpsToRay[4954] = 1000000012759821542076173268; - bpsToRay[4955] = 1000000012761941960171076169; - bpsToRay[4956] = 1000000012764062236484157718; - bpsToRay[4957] = 1000000012766182371034377136; - bpsToRay[4958] = 1000000012768302363840689849; - bpsToRay[4959] = 1000000012770422214922047473; - bpsToRay[4960] = 1000000012772541924297397831; - bpsToRay[4961] = 1000000012774661491985684940; - bpsToRay[4962] = 1000000012776780918005849024; - bpsToRay[4963] = 1000000012778900202376826505; - bpsToRay[4964] = 1000000012781019345117550012; - bpsToRay[4965] = 1000000012783138346246948375; - bpsToRay[4966] = 1000000012785257205783946632; - bpsToRay[4967] = 1000000012787375923747466027; - bpsToRay[4968] = 1000000012789494500156424011; - bpsToRay[4969] = 1000000012791612935029734245; - bpsToRay[4970] = 1000000012793731228386306598; - bpsToRay[4971] = 1000000012795849380245047149; - bpsToRay[4972] = 1000000012797967390624858191; - bpsToRay[4973] = 1000000012800085259544638227; - bpsToRay[4974] = 1000000012802202987023281977; - bpsToRay[4975] = 1000000012804320573079680371; - bpsToRay[4976] = 1000000012806438017732720558; - bpsToRay[4977] = 1000000012808555321001285904; - bpsToRay[4978] = 1000000012810672482904255989; - bpsToRay[4979] = 1000000012812789503460506616; - bpsToRay[4980] = 1000000012814906382688909806; - bpsToRay[4981] = 1000000012817023120608333799; - bpsToRay[4982] = 1000000012819139717237643058; - bpsToRay[4983] = 1000000012821256172595698271; - bpsToRay[4984] = 1000000012823372486701356345; - bpsToRay[4985] = 1000000012825488659573470415; - bpsToRay[4986] = 1000000012827604691230889842; - bpsToRay[4987] = 1000000012829720581692460212; - bpsToRay[4988] = 1000000012831836330977023339; - bpsToRay[4989] = 1000000012833951939103417266; - bpsToRay[4990] = 1000000012836067406090476267; - bpsToRay[4991] = 1000000012838182731957030847; - bpsToRay[4992] = 1000000012840297916721907738; - bpsToRay[4993] = 1000000012842412960403929910; - bpsToRay[4994] = 1000000012844527863021916565; - bpsToRay[4995] = 1000000012846642624594683140; - bpsToRay[4996] = 1000000012848757245141041307; - bpsToRay[4997] = 1000000012850871724679798976; - bpsToRay[4998] = 1000000012852986063229760294; - bpsToRay[4999] = 1000000012855100260809725646; - bpsToRay[5000] = 1000000012857214317438491659; - bpsToRay[5001] = 1000000012859328233134851198; - bpsToRay[5002] = 1000000012861442007917593374; - bpsToRay[5003] = 1000000012863555641805503536; - bpsToRay[5004] = 1000000012865669134817363279; - bpsToRay[5005] = 1000000012867782486971950443; - bpsToRay[5006] = 1000000012869895698288039115; - bpsToRay[5007] = 1000000012872008768784399625; - bpsToRay[5008] = 1000000012874121698479798555; - bpsToRay[5009] = 1000000012876234487392998733; - bpsToRay[5010] = 1000000012878347135542759238; - bpsToRay[5011] = 1000000012880459642947835401; - bpsToRay[5012] = 1000000012882572009626978801; - bpsToRay[5013] = 1000000012884684235598937274; - bpsToRay[5014] = 1000000012886796320882454907; - bpsToRay[5015] = 1000000012888908265496272044; - bpsToRay[5016] = 1000000012891020069459125282; - bpsToRay[5017] = 1000000012893131732789747478; - bpsToRay[5018] = 1000000012895243255506867744; - bpsToRay[5019] = 1000000012897354637629211454; - bpsToRay[5020] = 1000000012899465879175500237; - bpsToRay[5021] = 1000000012901576980164451988; - bpsToRay[5022] = 1000000012903687940614780860; - bpsToRay[5023] = 1000000012905798760545197270; - bpsToRay[5024] = 1000000012907909439974407900; - bpsToRay[5025] = 1000000012910019978921115695; - bpsToRay[5026] = 1000000012912130377404019867; - bpsToRay[5027] = 1000000012914240635441815894; - bpsToRay[5028] = 1000000012916350753053195521; - bpsToRay[5029] = 1000000012918460730256846763; - bpsToRay[5030] = 1000000012920570567071453907; - bpsToRay[5031] = 1000000012922680263515697504; - bpsToRay[5032] = 1000000012924789819608254383; - bpsToRay[5033] = 1000000012926899235367797644; - bpsToRay[5034] = 1000000012929008510812996659; - bpsToRay[5035] = 1000000012931117645962517078; - bpsToRay[5036] = 1000000012933226640835020822; - bpsToRay[5037] = 1000000012935335495449166093; - bpsToRay[5038] = 1000000012937444209823607369; - bpsToRay[5039] = 1000000012939552783976995406; - bpsToRay[5040] = 1000000012941661217927977241; - bpsToRay[5041] = 1000000012943769511695196190; - bpsToRay[5042] = 1000000012945877665297291852; - bpsToRay[5043] = 1000000012947985678752900108; - bpsToRay[5044] = 1000000012950093552080653122; - bpsToRay[5045] = 1000000012952201285299179347; - bpsToRay[5046] = 1000000012954308878427103514; - bpsToRay[5047] = 1000000012956416331483046645; - bpsToRay[5048] = 1000000012958523644485626051; - bpsToRay[5049] = 1000000012960630817453455327; - bpsToRay[5050] = 1000000012962737850405144363; - bpsToRay[5051] = 1000000012964844743359299334; - bpsToRay[5052] = 1000000012966951496334522711; - bpsToRay[5053] = 1000000012969058109349413254; - bpsToRay[5054] = 1000000012971164582422566020; - bpsToRay[5055] = 1000000012973270915572572357; - bpsToRay[5056] = 1000000012975377108818019910; - bpsToRay[5057] = 1000000012977483162177492621; - bpsToRay[5058] = 1000000012979589075669570729; - bpsToRay[5059] = 1000000012981694849312830772; - bpsToRay[5060] = 1000000012983800483125845583; - bpsToRay[5061] = 1000000012985905977127184302; - bpsToRay[5062] = 1000000012988011331335412367; - bpsToRay[5063] = 1000000012990116545769091518; - bpsToRay[5064] = 1000000012992221620446779799; - bpsToRay[5065] = 1000000012994326555387031557; - bpsToRay[5066] = 1000000012996431350608397447; - bpsToRay[5067] = 1000000012998536006129424429; - bpsToRay[5068] = 1000000013000640521968655768; - bpsToRay[5069] = 1000000013002744898144631040; - bpsToRay[5070] = 1000000013004849134675886130; - bpsToRay[5071] = 1000000013006953231580953231; - bpsToRay[5072] = 1000000013009057188878360849; - bpsToRay[5073] = 1000000013011161006586633804; - bpsToRay[5074] = 1000000013013264684724293223; - bpsToRay[5075] = 1000000013015368223309856554; - bpsToRay[5076] = 1000000013017471622361837555; - bpsToRay[5077] = 1000000013019574881898746303; - bpsToRay[5078] = 1000000013021678001939089190; - bpsToRay[5079] = 1000000013023780982501368928; - bpsToRay[5080] = 1000000013025883823604084547; - bpsToRay[5081] = 1000000013027986525265731396; - bpsToRay[5082] = 1000000013030089087504801146; - bpsToRay[5083] = 1000000013032191510339781792; - bpsToRay[5084] = 1000000013034293793789157646; - bpsToRay[5085] = 1000000013036395937871409348; - bpsToRay[5086] = 1000000013038497942605013865; - bpsToRay[5087] = 1000000013040599808008444486; - bpsToRay[5088] = 1000000013042701534100170826; - bpsToRay[5089] = 1000000013044803120898658830; - bpsToRay[5090] = 1000000013046904568422370773; - bpsToRay[5091] = 1000000013049005876689765257; - bpsToRay[5092] = 1000000013051107045719297215; - bpsToRay[5093] = 1000000013053208075529417914; - bpsToRay[5094] = 1000000013055308966138574949; - bpsToRay[5095] = 1000000013057409717565212254; - bpsToRay[5096] = 1000000013059510329827770095; - bpsToRay[5097] = 1000000013061610802944685072; - bpsToRay[5098] = 1000000013063711136934390123; - bpsToRay[5099] = 1000000013065811331815314524; - bpsToRay[5100] = 1000000013067911387605883890; - bpsToRay[5101] = 1000000013070011304324520173; - bpsToRay[5102] = 1000000013072111081989641667; - bpsToRay[5103] = 1000000013074210720619663007; - bpsToRay[5104] = 1000000013076310220232995171; - bpsToRay[5105] = 1000000013078409580848045479; - bpsToRay[5106] = 1000000013080508802483217595; - bpsToRay[5107] = 1000000013082607885156911531; - bpsToRay[5108] = 1000000013084706828887523642; - bpsToRay[5109] = 1000000013086805633693446631; - bpsToRay[5110] = 1000000013088904299593069551; - bpsToRay[5111] = 1000000013091002826604777801; - bpsToRay[5112] = 1000000013093101214746953133; - bpsToRay[5113] = 1000000013095199464037973648; - bpsToRay[5114] = 1000000013097297574496213800; - bpsToRay[5115] = 1000000013099395546140044395; - bpsToRay[5116] = 1000000013101493378987832595; - bpsToRay[5117] = 1000000013103591073057941913; - bpsToRay[5118] = 1000000013105688628368732223; - bpsToRay[5119] = 1000000013107786044938559751; - bpsToRay[5120] = 1000000013109883322785777084; - bpsToRay[5121] = 1000000013111980461928733165; - bpsToRay[5122] = 1000000013114077462385773300; - bpsToRay[5123] = 1000000013116174324175239154; - bpsToRay[5124] = 1000000013118271047315468752; - bpsToRay[5125] = 1000000013120367631824796485; - bpsToRay[5126] = 1000000013122464077721553103; - bpsToRay[5127] = 1000000013124560385024065726; - bpsToRay[5128] = 1000000013126656553750657835; - bpsToRay[5129] = 1000000013128752583919649280; - bpsToRay[5130] = 1000000013130848475549356277; - bpsToRay[5131] = 1000000013132944228658091410; - bpsToRay[5132] = 1000000013135039843264163635; - bpsToRay[5133] = 1000000013137135319385878275; - bpsToRay[5134] = 1000000013139230657041537026; - bpsToRay[5135] = 1000000013141325856249437956; - bpsToRay[5136] = 1000000013143420917027875507; - bpsToRay[5137] = 1000000013145515839395140491; - bpsToRay[5138] = 1000000013147610623369520102; - bpsToRay[5139] = 1000000013149705268969297904; - bpsToRay[5140] = 1000000013151799776212753840; - bpsToRay[5141] = 1000000013153894145118164231; - bpsToRay[5142] = 1000000013155988375703801779; - bpsToRay[5143] = 1000000013158082467987935562; - bpsToRay[5144] = 1000000013160176421988831041; - bpsToRay[5145] = 1000000013162270237724750059; - bpsToRay[5146] = 1000000013164363915213950840; - bpsToRay[5147] = 1000000013166457454474687994; - bpsToRay[5148] = 1000000013168550855525212514; - bpsToRay[5149] = 1000000013170644118383771778; - bpsToRay[5150] = 1000000013172737243068609553; - bpsToRay[5151] = 1000000013174830229597965992; - bpsToRay[5152] = 1000000013176923077990077635; - bpsToRay[5153] = 1000000013179015788263177415; - bpsToRay[5154] = 1000000013181108360435494653; - bpsToRay[5155] = 1000000013183200794525255059; - bpsToRay[5156] = 1000000013185293090550680741; - bpsToRay[5157] = 1000000013187385248529990196; - bpsToRay[5158] = 1000000013189477268481398315; - bpsToRay[5159] = 1000000013191569150423116386; - bpsToRay[5160] = 1000000013193660894373352093; - bpsToRay[5161] = 1000000013195752500350309515; - bpsToRay[5162] = 1000000013197843968372189132; - bpsToRay[5163] = 1000000013199935298457187821; - bpsToRay[5164] = 1000000013202026490623498857; - bpsToRay[5165] = 1000000013204117544889311921; - bpsToRay[5166] = 1000000013206208461272813091; - bpsToRay[5167] = 1000000013208299239792184850; - bpsToRay[5168] = 1000000013210389880465606084; - bpsToRay[5169] = 1000000013212480383311252082; - bpsToRay[5170] = 1000000013214570748347294544; - bpsToRay[5171] = 1000000013216660975591901569; - bpsToRay[5172] = 1000000013218751065063237670; - bpsToRay[5173] = 1000000013220841016779463763; - bpsToRay[5174] = 1000000013222930830758737177; - bpsToRay[5175] = 1000000013225020507019211652; - bpsToRay[5176] = 1000000013227110045579037336; - bpsToRay[5177] = 1000000013229199446456360791; - bpsToRay[5178] = 1000000013231288709669324991; - bpsToRay[5179] = 1000000013233377835236069326; - bpsToRay[5180] = 1000000013235466823174729599; - bpsToRay[5181] = 1000000013237555673503438031; - bpsToRay[5182] = 1000000013239644386240323257; - bpsToRay[5183] = 1000000013241732961403510334; - bpsToRay[5184] = 1000000013243821399011120734; - bpsToRay[5185] = 1000000013245909699081272350; - bpsToRay[5186] = 1000000013247997861632079496; - bpsToRay[5187] = 1000000013250085886681652909; - bpsToRay[5188] = 1000000013252173774248099746; - bpsToRay[5189] = 1000000013254261524349523588; - bpsToRay[5190] = 1000000013256349137004024442; - bpsToRay[5191] = 1000000013258436612229698739; - bpsToRay[5192] = 1000000013260523950044639336; - bpsToRay[5193] = 1000000013262611150466935520; - bpsToRay[5194] = 1000000013264698213514673002; - bpsToRay[5195] = 1000000013266785139205933927; - bpsToRay[5196] = 1000000013268871927558796866; - bpsToRay[5197] = 1000000013270958578591336822; - bpsToRay[5198] = 1000000013273045092321625231; - bpsToRay[5199] = 1000000013275131468767729963; - bpsToRay[5200] = 1000000013277217707947715318; - bpsToRay[5201] = 1000000013279303809879642035; - bpsToRay[5202] = 1000000013281389774581567286; - bpsToRay[5203] = 1000000013283475602071544681; - bpsToRay[5204] = 1000000013285561292367624266; - bpsToRay[5205] = 1000000013287646845487852528; - bpsToRay[5206] = 1000000013289732261450272392; - bpsToRay[5207] = 1000000013291817540272923222; - bpsToRay[5208] = 1000000013293902681973840827; - bpsToRay[5209] = 1000000013295987686571057456; - bpsToRay[5210] = 1000000013298072554082601799; - bpsToRay[5211] = 1000000013300157284526498996; - bpsToRay[5212] = 1000000013302241877920770626; - bpsToRay[5213] = 1000000013304326334283434719; - bpsToRay[5214] = 1000000013306410653632505749; - bpsToRay[5215] = 1000000013308494835985994637; - bpsToRay[5216] = 1000000013310578881361908756; - bpsToRay[5217] = 1000000013312662789778251927; - bpsToRay[5218] = 1000000013314746561253024422; - bpsToRay[5219] = 1000000013316830195804222964; - bpsToRay[5220] = 1000000013318913693449840730; - bpsToRay[5221] = 1000000013320997054207867349; - bpsToRay[5222] = 1000000013323080278096288904; - bpsToRay[5223] = 1000000013325163365133087937; - bpsToRay[5224] = 1000000013327246315336243441; - bpsToRay[5225] = 1000000013329329128723730871; - bpsToRay[5226] = 1000000013331411805313522137; - bpsToRay[5227] = 1000000013333494345123585609; - bpsToRay[5228] = 1000000013335576748171886118; - bpsToRay[5229] = 1000000013337659014476384955; - bpsToRay[5230] = 1000000013339741144055039872; - bpsToRay[5231] = 1000000013341823136925805086; - bpsToRay[5232] = 1000000013343904993106631276; - bpsToRay[5233] = 1000000013345986712615465587; - bpsToRay[5234] = 1000000013348068295470251626; - bpsToRay[5235] = 1000000013350149741688929473; - bpsToRay[5236] = 1000000013352231051289435670; - bpsToRay[5237] = 1000000013354312224289703229; - bpsToRay[5238] = 1000000013356393260707661631; - bpsToRay[5239] = 1000000013358474160561236828; - bpsToRay[5240] = 1000000013360554923868351244; - bpsToRay[5241] = 1000000013362635550646923773; - bpsToRay[5242] = 1000000013364716040914869783; - bpsToRay[5243] = 1000000013366796394690101115; - bpsToRay[5244] = 1000000013368876611990526086; - bpsToRay[5245] = 1000000013370956692834049490; - bpsToRay[5246] = 1000000013373036637238572595; - bpsToRay[5247] = 1000000013375116445221993147; - bpsToRay[5248] = 1000000013377196116802205372; - bpsToRay[5249] = 1000000013379275651997099976; - bpsToRay[5250] = 1000000013381355050824564143; - bpsToRay[5251] = 1000000013383434313302481540; - bpsToRay[5252] = 1000000013385513439448732314; - bpsToRay[5253] = 1000000013387592429281193100; - bpsToRay[5254] = 1000000013389671282817737012; - bpsToRay[5255] = 1000000013391750000076233652; - bpsToRay[5256] = 1000000013393828581074549107; - bpsToRay[5257] = 1000000013395907025830545951; - bpsToRay[5258] = 1000000013397985334362083244; - bpsToRay[5259] = 1000000013400063506687016538; - bpsToRay[5260] = 1000000013402141542823197873; - bpsToRay[5261] = 1000000013404219442788475779; - bpsToRay[5262] = 1000000013406297206600695278; - bpsToRay[5263] = 1000000013408374834277697885; - bpsToRay[5264] = 1000000013410452325837321606; - bpsToRay[5265] = 1000000013412529681297400945; - bpsToRay[5266] = 1000000013414606900675766898; - bpsToRay[5267] = 1000000013416683983990246957; - bpsToRay[5268] = 1000000013418760931258665113; - bpsToRay[5269] = 1000000013420837742498841855; - bpsToRay[5270] = 1000000013422914417728594168; - bpsToRay[5271] = 1000000013424990956965735539; - bpsToRay[5272] = 1000000013427067360228075956; - bpsToRay[5273] = 1000000013429143627533421906; - bpsToRay[5274] = 1000000013431219758899576381; - bpsToRay[5275] = 1000000013433295754344338876; - bpsToRay[5276] = 1000000013435371613885505389; - bpsToRay[5277] = 1000000013437447337540868424; - bpsToRay[5278] = 1000000013439522925328216993; - bpsToRay[5279] = 1000000013441598377265336611; - bpsToRay[5280] = 1000000013443673693370009304; - bpsToRay[5281] = 1000000013445748873660013605; - bpsToRay[5282] = 1000000013447823918153124560; - bpsToRay[5283] = 1000000013449898826867113722; - bpsToRay[5284] = 1000000013451973599819749157; - bpsToRay[5285] = 1000000013454048237028795446; - bpsToRay[5286] = 1000000013456122738512013678; - bpsToRay[5287] = 1000000013458197104287161462; - bpsToRay[5288] = 1000000013460271334371992918; - bpsToRay[5289] = 1000000013462345428784258685; - bpsToRay[5290] = 1000000013464419387541705919; - bpsToRay[5291] = 1000000013466493210662078291; - bpsToRay[5292] = 1000000013468566898163115994; - bpsToRay[5293] = 1000000013470640450062555739; - bpsToRay[5294] = 1000000013472713866378130761; - bpsToRay[5295] = 1000000013474787147127570811; - bpsToRay[5296] = 1000000013476860292328602168; - bpsToRay[5297] = 1000000013478933301998947631; - bpsToRay[5298] = 1000000013481006176156326525; - bpsToRay[5299] = 1000000013483078914818454700; - bpsToRay[5300] = 1000000013485151518003044532; - bpsToRay[5301] = 1000000013487223985727804923; - bpsToRay[5302] = 1000000013489296318010441307; - bpsToRay[5303] = 1000000013491368514868655641; - bpsToRay[5304] = 1000000013493440576320146417; - bpsToRay[5305] = 1000000013495512502382608654; - bpsToRay[5306] = 1000000013497584293073733906; - bpsToRay[5307] = 1000000013499655948411210256; - bpsToRay[5308] = 1000000013501727468412722324; - bpsToRay[5309] = 1000000013503798853095951261; - bpsToRay[5310] = 1000000013505870102478574756; - bpsToRay[5311] = 1000000013507941216578267032; - bpsToRay[5312] = 1000000013510012195412698851; - bpsToRay[5313] = 1000000013512083038999537512; - bpsToRay[5314] = 1000000013514153747356446852; - bpsToRay[5315] = 1000000013516224320501087249; - bpsToRay[5316] = 1000000013518294758451115623; - bpsToRay[5317] = 1000000013520365061224185433; - bpsToRay[5318] = 1000000013522435228837946681; - bpsToRay[5319] = 1000000013524505261310045913; - bpsToRay[5320] = 1000000013526575158658126219; - bpsToRay[5321] = 1000000013528644920899827235; - bpsToRay[5322] = 1000000013530714548052785142; - bpsToRay[5323] = 1000000013532784040134632670; - bpsToRay[5324] = 1000000013534853397162999093; - bpsToRay[5325] = 1000000013536922619155510237; - bpsToRay[5326] = 1000000013538991706129788478; - bpsToRay[5327] = 1000000013541060658103452740; - bpsToRay[5328] = 1000000013543129475094118502; - bpsToRay[5329] = 1000000013545198157119397791; - bpsToRay[5330] = 1000000013547266704196899191; - bpsToRay[5331] = 1000000013549335116344227839; - bpsToRay[5332] = 1000000013551403393578985427; - bpsToRay[5333] = 1000000013553471535918770203; - bpsToRay[5334] = 1000000013555539543381176971; - bpsToRay[5335] = 1000000013557607415983797096; - bpsToRay[5336] = 1000000013559675153744218497; - bpsToRay[5337] = 1000000013561742756680025656; - bpsToRay[5338] = 1000000013563810224808799615; - bpsToRay[5339] = 1000000013565877558148117977; - bpsToRay[5340] = 1000000013567944756715554906; - bpsToRay[5341] = 1000000013570011820528681131; - bpsToRay[5342] = 1000000013572078749605063945; - bpsToRay[5343] = 1000000013574145543962267205; - bpsToRay[5344] = 1000000013576212203617851334; - bpsToRay[5345] = 1000000013578278728589373323; - bpsToRay[5346] = 1000000013580345118894386729; - bpsToRay[5347] = 1000000013582411374550441678; - bpsToRay[5348] = 1000000013584477495575084867; - bpsToRay[5349] = 1000000013586543481985859560; - bpsToRay[5350] = 1000000013588609333800305597; - bpsToRay[5351] = 1000000013590675051035959386; - bpsToRay[5352] = 1000000013592740633710353909; - bpsToRay[5353] = 1000000013594806081841018723; - bpsToRay[5354] = 1000000013596871395445479960; - bpsToRay[5355] = 1000000013598936574541260325; - bpsToRay[5356] = 1000000013601001619145879103; - bpsToRay[5357] = 1000000013603066529276852154; - bpsToRay[5358] = 1000000013605131304951691920; - bpsToRay[5359] = 1000000013607195946187907415; - bpsToRay[5360] = 1000000013609260453003004241; - bpsToRay[5361] = 1000000013611324825414484577; - bpsToRay[5362] = 1000000013613389063439847186; - bpsToRay[5363] = 1000000013615453167096587411; - bpsToRay[5364] = 1000000013617517136402197181; - bpsToRay[5365] = 1000000013619580971374165008; - bpsToRay[5366] = 1000000013621644672029975992; - bpsToRay[5367] = 1000000013623708238387111817; - bpsToRay[5368] = 1000000013625771670463050755; - bpsToRay[5369] = 1000000013627834968275267666; - bpsToRay[5370] = 1000000013629898131841234000; - bpsToRay[5371] = 1000000013631961161178417796; - bpsToRay[5372] = 1000000013634024056304283684; - bpsToRay[5373] = 1000000013636086817236292885; - bpsToRay[5374] = 1000000013638149443991903215; - bpsToRay[5375] = 1000000013640211936588569081; - bpsToRay[5376] = 1000000013642274295043741485; - bpsToRay[5377] = 1000000013644336519374868025; - bpsToRay[5378] = 1000000013646398609599392894; - bpsToRay[5379] = 1000000013648460565734756883; - bpsToRay[5380] = 1000000013650522387798397382; - bpsToRay[5381] = 1000000013652584075807748376; - bpsToRay[5382] = 1000000013654645629780240453; - bpsToRay[5383] = 1000000013656707049733300801; - bpsToRay[5384] = 1000000013658768335684353209; - bpsToRay[5385] = 1000000013660829487650818068; - bpsToRay[5386] = 1000000013662890505650112373; - bpsToRay[5387] = 1000000013664951389699649722; - bpsToRay[5388] = 1000000013667012139816840321; - bpsToRay[5389] = 1000000013669072756019090977; - bpsToRay[5390] = 1000000013671133238323805108; - bpsToRay[5391] = 1000000013673193586748382737; - bpsToRay[5392] = 1000000013675253801310220496; - bpsToRay[5393] = 1000000013677313882026711628; - bpsToRay[5394] = 1000000013679373828915245986; - bpsToRay[5395] = 1000000013681433641993210032; - bpsToRay[5396] = 1000000013683493321277986841; - bpsToRay[5397] = 1000000013685552866786956102; - bpsToRay[5398] = 1000000013687612278537494116; - bpsToRay[5399] = 1000000013689671556546973802; - bpsToRay[5400] = 1000000013691730700832764691; - bpsToRay[5401] = 1000000013693789711412232932; - bpsToRay[5402] = 1000000013695848588302741289; - bpsToRay[5403] = 1000000013697907331521649149; - bpsToRay[5404] = 1000000013699965941086312515; - bpsToRay[5405] = 1000000013702024417014084009; - bpsToRay[5406] = 1000000013704082759322312876; - bpsToRay[5407] = 1000000013706140968028344981; - bpsToRay[5408] = 1000000013708199043149522812; - bpsToRay[5409] = 1000000013710256984703185483; - bpsToRay[5410] = 1000000013712314792706668728; - bpsToRay[5411] = 1000000013714372467177304910; - bpsToRay[5412] = 1000000013716430008132423015; - bpsToRay[5413] = 1000000013718487415589348659; - bpsToRay[5414] = 1000000013720544689565404082; - bpsToRay[5415] = 1000000013722601830077908157; - bpsToRay[5416] = 1000000013724658837144176384; - bpsToRay[5417] = 1000000013726715710781520893; - bpsToRay[5418] = 1000000013728772451007250448; - bpsToRay[5419] = 1000000013730829057838670442; - bpsToRay[5420] = 1000000013732885531293082904; - bpsToRay[5421] = 1000000013734941871387786495; - bpsToRay[5422] = 1000000013736998078140076511; - bpsToRay[5423] = 1000000013739054151567244885; - bpsToRay[5424] = 1000000013741110091686580185; - bpsToRay[5425] = 1000000013743165898515367617; - bpsToRay[5426] = 1000000013745221572070889027; - bpsToRay[5427] = 1000000013747277112370422896; - bpsToRay[5428] = 1000000013749332519431244349; - bpsToRay[5429] = 1000000013751387793270625152; - bpsToRay[5430] = 1000000013753442933905833710; - bpsToRay[5431] = 1000000013755497941354135072; - bpsToRay[5432] = 1000000013757552815632790932; - bpsToRay[5433] = 1000000013759607556759059626; - bpsToRay[5434] = 1000000013761662164750196136; - bpsToRay[5435] = 1000000013763716639623452091; - bpsToRay[5436] = 1000000013765770981396075767; - bpsToRay[5437] = 1000000013767825190085312088; - bpsToRay[5438] = 1000000013769879265708402624; - bpsToRay[5439] = 1000000013771933208282585599; - bpsToRay[5440] = 1000000013773987017825095883; - bpsToRay[5441] = 1000000013776040694353165002; - bpsToRay[5442] = 1000000013778094237884021131; - bpsToRay[5443] = 1000000013780147648434889099; - bpsToRay[5444] = 1000000013782200926022990388; - bpsToRay[5445] = 1000000013784254070665543138; - bpsToRay[5446] = 1000000013786307082379762141; - bpsToRay[5447] = 1000000013788359961182858847; - bpsToRay[5448] = 1000000013790412707092041364; - bpsToRay[5449] = 1000000013792465320124514458; - bpsToRay[5450] = 1000000013794517800297479554; - bpsToRay[5451] = 1000000013796570147628134736; - bpsToRay[5452] = 1000000013798622362133674751; - bpsToRay[5453] = 1000000013800674443831291006; - bpsToRay[5454] = 1000000013802726392738171571; - bpsToRay[5455] = 1000000013804778208871501181; - bpsToRay[5456] = 1000000013806829892248461232; - bpsToRay[5457] = 1000000013808881442886229789; - bpsToRay[5458] = 1000000013810932860801981581; - bpsToRay[5459] = 1000000013812984146012888004; - bpsToRay[5460] = 1000000013815035298536117122; - bpsToRay[5461] = 1000000013817086318388833668; - bpsToRay[5462] = 1000000013819137205588199044; - bpsToRay[5463] = 1000000013821187960151371324; - bpsToRay[5464] = 1000000013823238582095505250; - bpsToRay[5465] = 1000000013825289071437752239; - bpsToRay[5466] = 1000000013827339428195260380; - bpsToRay[5467] = 1000000013829389652385174435; - bpsToRay[5468] = 1000000013831439744024635842; - bpsToRay[5469] = 1000000013833489703130782714; - bpsToRay[5470] = 1000000013835539529720749841; - bpsToRay[5471] = 1000000013837589223811668689; - bpsToRay[5472] = 1000000013839638785420667403; - bpsToRay[5473] = 1000000013841688214564870807; - bpsToRay[5474] = 1000000013843737511261400404; - bpsToRay[5475] = 1000000013845786675527374380; - bpsToRay[5476] = 1000000013847835707379907599; - bpsToRay[5477] = 1000000013849884606836111609; - bpsToRay[5478] = 1000000013851933373913094644; - bpsToRay[5479] = 1000000013853982008627961619; - bpsToRay[5480] = 1000000013856030510997814133; - bpsToRay[5481] = 1000000013858078881039750473; - bpsToRay[5482] = 1000000013860127118770865614; - bpsToRay[5483] = 1000000013862175224208251215; - bpsToRay[5484] = 1000000013864223197368995626; - bpsToRay[5485] = 1000000013866271038270183886; - bpsToRay[5486] = 1000000013868318746928897723; - bpsToRay[5487] = 1000000013870366323362215556; - bpsToRay[5488] = 1000000013872413767587212497; - bpsToRay[5489] = 1000000013874461079620960351; - bpsToRay[5490] = 1000000013876508259480527614; - bpsToRay[5491] = 1000000013878555307182979479; - bpsToRay[5492] = 1000000013880602222745377833; - bpsToRay[5493] = 1000000013882649006184781260; - bpsToRay[5494] = 1000000013884695657518245039; - bpsToRay[5495] = 1000000013886742176762821150; - bpsToRay[5496] = 1000000013888788563935558267; - bpsToRay[5497] = 1000000013890834819053501770; - bpsToRay[5498] = 1000000013892880942133693733; - bpsToRay[5499] = 1000000013894926933193172935; - bpsToRay[5500] = 1000000013896972792248974855; - bpsToRay[5501] = 1000000013899018519318131677; - bpsToRay[5502] = 1000000013901064114417672287; - bpsToRay[5503] = 1000000013903109577564622276; - bpsToRay[5504] = 1000000013905154908776003941; - bpsToRay[5505] = 1000000013907200108068836286; - bpsToRay[5506] = 1000000013909245175460135020; - bpsToRay[5507] = 1000000013911290110966912561; - bpsToRay[5508] = 1000000013913334914606178038; - bpsToRay[5509] = 1000000013915379586394937285; - bpsToRay[5510] = 1000000013917424126350192852; - bpsToRay[5511] = 1000000013919468534488943996; - bpsToRay[5512] = 1000000013921512810828186689; - bpsToRay[5513] = 1000000013923556955384913616; - bpsToRay[5514] = 1000000013925600968176114173; - bpsToRay[5515] = 1000000013927644849218774474; - bpsToRay[5516] = 1000000013929688598529877347; - bpsToRay[5517] = 1000000013931732216126402338; - bpsToRay[5518] = 1000000013933775702025325709; - bpsToRay[5519] = 1000000013935819056243620441; - bpsToRay[5520] = 1000000013937862278798256232; - bpsToRay[5521] = 1000000013939905369706199504; - bpsToRay[5522] = 1000000013941948328984413395; - bpsToRay[5523] = 1000000013943991156649857768; - bpsToRay[5524] = 1000000013946033852719489207; - bpsToRay[5525] = 1000000013948076417210261020; - bpsToRay[5526] = 1000000013950118850139123237; - bpsToRay[5527] = 1000000013952161151523022616; - bpsToRay[5528] = 1000000013954203321378902639; - bpsToRay[5529] = 1000000013956245359723703515; - bpsToRay[5530] = 1000000013958287266574362180; - bpsToRay[5531] = 1000000013960329041947812299; - bpsToRay[5532] = 1000000013962370685860984266; - bpsToRay[5533] = 1000000013964412198330805204; - bpsToRay[5534] = 1000000013966453579374198970; - bpsToRay[5535] = 1000000013968494829008086149; - bpsToRay[5536] = 1000000013970535947249384059; - bpsToRay[5537] = 1000000013972576934115006754; - bpsToRay[5538] = 1000000013974617789621865021; - bpsToRay[5539] = 1000000013976658513786866380; - bpsToRay[5540] = 1000000013978699106626915089; - bpsToRay[5541] = 1000000013980739568158912143; - bpsToRay[5542] = 1000000013982779898399755273; - bpsToRay[5543] = 1000000013984820097366338950; - bpsToRay[5544] = 1000000013986860165075554382; - bpsToRay[5545] = 1000000013988900101544289521; - bpsToRay[5546] = 1000000013990939906789429055; - bpsToRay[5547] = 1000000013992979580827854418; - bpsToRay[5548] = 1000000013995019123676443785; - bpsToRay[5549] = 1000000013997058535352072073; - bpsToRay[5550] = 1000000013999097815871610946; - bpsToRay[5551] = 1000000014001136965251928811; - bpsToRay[5552] = 1000000014003175983509890823; - bpsToRay[5553] = 1000000014005214870662358881; - bpsToRay[5554] = 1000000014007253626726191632; - bpsToRay[5555] = 1000000014009292251718244476; - bpsToRay[5556] = 1000000014011330745655369557; - bpsToRay[5557] = 1000000014013369108554415771; - bpsToRay[5558] = 1000000014015407340432228765; - bpsToRay[5559] = 1000000014017445441305650938; - bpsToRay[5560] = 1000000014019483411191521442; - bpsToRay[5561] = 1000000014021521250106676181; - bpsToRay[5562] = 1000000014023558958067947815; - bpsToRay[5563] = 1000000014025596535092165759; - bpsToRay[5564] = 1000000014027633981196156184; - bpsToRay[5565] = 1000000014029671296396742013; - bpsToRay[5566] = 1000000014031708480710742936; - bpsToRay[5567] = 1000000014033745534154975394; - bpsToRay[5568] = 1000000014035782456746252590; - bpsToRay[5569] = 1000000014037819248501384486; - bpsToRay[5570] = 1000000014039855909437177808; - bpsToRay[5571] = 1000000014041892439570436040; - bpsToRay[5572] = 1000000014043928838917959430; - bpsToRay[5573] = 1000000014045965107496544991; - bpsToRay[5574] = 1000000014048001245322986499; - bpsToRay[5575] = 1000000014050037252414074493; - bpsToRay[5576] = 1000000014052073128786596283; - bpsToRay[5577] = 1000000014054108874457335942; - bpsToRay[5578] = 1000000014056144489443074311; - bpsToRay[5579] = 1000000014058179973760589001; - bpsToRay[5580] = 1000000014060215327426654391; - bpsToRay[5581] = 1000000014062250550458041631; - bpsToRay[5582] = 1000000014064285642871518639; - bpsToRay[5583] = 1000000014066320604683850111; - bpsToRay[5584] = 1000000014068355435911797509; - bpsToRay[5585] = 1000000014070390136572119073; - bpsToRay[5586] = 1000000014072424706681569814; - bpsToRay[5587] = 1000000014074459146256901521; - bpsToRay[5588] = 1000000014076493455314862758; - bpsToRay[5589] = 1000000014078527633872198862; - bpsToRay[5590] = 1000000014080561681945651954; - bpsToRay[5591] = 1000000014082595599551960930; - bpsToRay[5592] = 1000000014084629386707861464; - bpsToRay[5593] = 1000000014086663043430086012; - bpsToRay[5594] = 1000000014088696569735363811; - bpsToRay[5595] = 1000000014090729965640420880; - bpsToRay[5596] = 1000000014092763231161980018; - bpsToRay[5597] = 1000000014094796366316760809; - bpsToRay[5598] = 1000000014096829371121479623; - bpsToRay[5599] = 1000000014098862245592849610; - bpsToRay[5600] = 1000000014100894989747580713; - bpsToRay[5601] = 1000000014102927603602379655; - bpsToRay[5602] = 1000000014104960087173949949; - bpsToRay[5603] = 1000000014106992440478991899; - bpsToRay[5604] = 1000000014109024663534202592; - bpsToRay[5605] = 1000000014111056756356275911; - bpsToRay[5606] = 1000000014113088718961902527; - bpsToRay[5607] = 1000000014115120551367769903; - bpsToRay[5608] = 1000000014117152253590562293; - bpsToRay[5609] = 1000000014119183825646960746; - bpsToRay[5610] = 1000000014121215267553643106; - bpsToRay[5611] = 1000000014123246579327284009; - bpsToRay[5612] = 1000000014125277760984554889; - bpsToRay[5613] = 1000000014127308812542123975; - bpsToRay[5614] = 1000000014129339734016656294; - bpsToRay[5615] = 1000000014131370525424813672; - bpsToRay[5616] = 1000000014133401186783254733; - bpsToRay[5617] = 1000000014135431718108634901; - bpsToRay[5618] = 1000000014137462119417606400; - bpsToRay[5619] = 1000000014139492390726818256; - bpsToRay[5620] = 1000000014141522532052916298; - bpsToRay[5621] = 1000000014143552543412543158; - bpsToRay[5622] = 1000000014145582424822338270; - bpsToRay[5623] = 1000000014147612176298937873; - bpsToRay[5624] = 1000000014149641797858975016; - bpsToRay[5625] = 1000000014151671289519079548; - bpsToRay[5626] = 1000000014153700651295878130; - bpsToRay[5627] = 1000000014155729883205994226; - bpsToRay[5628] = 1000000014157758985266048116; - bpsToRay[5629] = 1000000014159787957492656883; - bpsToRay[5630] = 1000000014161816799902434423; - bpsToRay[5631] = 1000000014163845512511991443; - bpsToRay[5632] = 1000000014165874095337935463; - bpsToRay[5633] = 1000000014167902548396870816; - bpsToRay[5634] = 1000000014169930871705398646; - bpsToRay[5635] = 1000000014171959065280116914; - bpsToRay[5636] = 1000000014173987129137620396; - bpsToRay[5637] = 1000000014176015063294500683; - bpsToRay[5638] = 1000000014178042867767346186; - bpsToRay[5639] = 1000000014180070542572742128; - bpsToRay[5640] = 1000000014182098087727270558; - bpsToRay[5641] = 1000000014184125503247510337; - bpsToRay[5642] = 1000000014186152789150037153; - bpsToRay[5643] = 1000000014188179945451423510; - bpsToRay[5644] = 1000000014190206972168238736; - bpsToRay[5645] = 1000000014192233869317048980; - bpsToRay[5646] = 1000000014194260636914417219; - bpsToRay[5647] = 1000000014196287274976903248; - bpsToRay[5648] = 1000000014198313783521063691; - bpsToRay[5649] = 1000000014200340162563451997; - bpsToRay[5650] = 1000000014202366412120618444; - bpsToRay[5651] = 1000000014204392532209110132; - bpsToRay[5652] = 1000000014206418522845470993; - bpsToRay[5653] = 1000000014208444384046241790; - bpsToRay[5654] = 1000000014210470115827960111; - bpsToRay[5655] = 1000000014212495718207160381; - bpsToRay[5656] = 1000000014214521191200373850; - bpsToRay[5657] = 1000000014216546534824128603; - bpsToRay[5658] = 1000000014218571749094949561; - bpsToRay[5659] = 1000000014220596834029358476; - bpsToRay[5660] = 1000000014222621789643873935; - bpsToRay[5661] = 1000000014224646615955011361; - bpsToRay[5662] = 1000000014226671312979283014; - bpsToRay[5663] = 1000000014228695880733197990; - bpsToRay[5664] = 1000000014230720319233262225; - bpsToRay[5665] = 1000000014232744628495978491; - bpsToRay[5666] = 1000000014234768808537846403; - bpsToRay[5667] = 1000000014236792859375362413; - bpsToRay[5668] = 1000000014238816781025019818; - bpsToRay[5669] = 1000000014240840573503308754; - bpsToRay[5670] = 1000000014242864236826716200; - bpsToRay[5671] = 1000000014244887771011725981; - bpsToRay[5672] = 1000000014246911176074818766; - bpsToRay[5673] = 1000000014248934452032472066; - bpsToRay[5674] = 1000000014250957598901160243; - bpsToRay[5675] = 1000000014252980616697354502; - bpsToRay[5676] = 1000000014255003505437522899; - bpsToRay[5677] = 1000000014257026265138130334; - bpsToRay[5678] = 1000000014259048895815638562; - bpsToRay[5679] = 1000000014261071397486506182; - bpsToRay[5680] = 1000000014263093770167188651; - bpsToRay[5681] = 1000000014265116013874138270; - bpsToRay[5682] = 1000000014267138128623804199; - bpsToRay[5683] = 1000000014269160114432632448; - bpsToRay[5684] = 1000000014271181971317065881; - bpsToRay[5685] = 1000000014273203699293544220; - bpsToRay[5686] = 1000000014275225298378504039; - bpsToRay[5687] = 1000000014277246768588378769; - bpsToRay[5688] = 1000000014279268109939598702; - bpsToRay[5689] = 1000000014281289322448590984; - bpsToRay[5690] = 1000000014283310406131779623; - bpsToRay[5691] = 1000000014285331361005585484; - bpsToRay[5692] = 1000000014287352187086426294; - bpsToRay[5693] = 1000000014289372884390716643; - bpsToRay[5694] = 1000000014291393452934867978; - bpsToRay[5695] = 1000000014293413892735288616; - bpsToRay[5696] = 1000000014295434203808383731; - bpsToRay[5697] = 1000000014297454386170555368; - bpsToRay[5698] = 1000000014299474439838202432; - bpsToRay[5699] = 1000000014301494364827720695; - bpsToRay[5700] = 1000000014303514161155502800; - bpsToRay[5701] = 1000000014305533828837938253; - bpsToRay[5702] = 1000000014307553367891413431; - bpsToRay[5703] = 1000000014309572778332311579; - bpsToRay[5704] = 1000000014311592060177012815; - bpsToRay[5705] = 1000000014313611213441894123; - bpsToRay[5706] = 1000000014315630238143329364; - bpsToRay[5707] = 1000000014317649134297689268; - bpsToRay[5708] = 1000000014319667901921341438; - bpsToRay[5709] = 1000000014321686541030650356; - bpsToRay[5710] = 1000000014323705051641977373; - bpsToRay[5711] = 1000000014325723433771680719; - bpsToRay[5712] = 1000000014327741687436115500; - bpsToRay[5713] = 1000000014329759812651633698; - bpsToRay[5714] = 1000000014331777809434584175; - bpsToRay[5715] = 1000000014333795677801312670; - bpsToRay[5716] = 1000000014335813417768161804; - bpsToRay[5717] = 1000000014337831029351471077; - bpsToRay[5718] = 1000000014339848512567576870; - bpsToRay[5719] = 1000000014341865867432812447; - bpsToRay[5720] = 1000000014343883093963507953; - bpsToRay[5721] = 1000000014345900192175990420; - bpsToRay[5722] = 1000000014347917162086583762; - bpsToRay[5723] = 1000000014349934003711608778; - bpsToRay[5724] = 1000000014351950717067383155; - bpsToRay[5725] = 1000000014353967302170221464; - bpsToRay[5726] = 1000000014355983759036435166; - bpsToRay[5727] = 1000000014358000087682332611; - bpsToRay[5728] = 1000000014360016288124219035; - bpsToRay[5729] = 1000000014362032360378396567; - bpsToRay[5730] = 1000000014364048304461164225; - bpsToRay[5731] = 1000000014366064120388817920; - bpsToRay[5732] = 1000000014368079808177650454; - bpsToRay[5733] = 1000000014370095367843951523; - bpsToRay[5734] = 1000000014372110799404007716; - bpsToRay[5735] = 1000000014374126102874102518; - bpsToRay[5736] = 1000000014376141278270516310; - bpsToRay[5737] = 1000000014378156325609526367; - bpsToRay[5738] = 1000000014380171244907406862; - bpsToRay[5739] = 1000000014382186036180428868; - bpsToRay[5740] = 1000000014384200699444860352; - bpsToRay[5741] = 1000000014386215234716966187; - bpsToRay[5742] = 1000000014388229642013008140; - bpsToRay[5743] = 1000000014390243921349244884; - bpsToRay[5744] = 1000000014392258072741931989; - bpsToRay[5745] = 1000000014394272096207321932; - bpsToRay[5746] = 1000000014396285991761664091; - bpsToRay[5747] = 1000000014398299759421204750; - bpsToRay[5748] = 1000000014400313399202187095; - bpsToRay[5749] = 1000000014402326911120851219; - bpsToRay[5750] = 1000000014404340295193434124; - bpsToRay[5751] = 1000000014406353551436169717; - bpsToRay[5752] = 1000000014408366679865288813; - bpsToRay[5753] = 1000000014410379680497019136; - bpsToRay[5754] = 1000000014412392553347585321; - bpsToRay[5755] = 1000000014414405298433208913; - bpsToRay[5756] = 1000000014416417915770108367; - bpsToRay[5757] = 1000000014418430405374499050; - bpsToRay[5758] = 1000000014420442767262593245; - bpsToRay[5759] = 1000000014422455001450600144; - bpsToRay[5760] = 1000000014424467107954725858; - bpsToRay[5761] = 1000000014426479086791173409; - bpsToRay[5762] = 1000000014428490937976142739; - bpsToRay[5763] = 1000000014430502661525830703; - bpsToRay[5764] = 1000000014432514257456431075; - bpsToRay[5765] = 1000000014434525725784134548; - bpsToRay[5766] = 1000000014436537066525128734; - bpsToRay[5767] = 1000000014438548279695598164; - bpsToRay[5768] = 1000000014440559365311724289; - bpsToRay[5769] = 1000000014442570323389685485; - bpsToRay[5770] = 1000000014444581153945657045; - bpsToRay[5771] = 1000000014446591856995811191; - bpsToRay[5772] = 1000000014448602432556317062; - bpsToRay[5773] = 1000000014450612880643340727; - bpsToRay[5774] = 1000000014452623201273045178; - bpsToRay[5775] = 1000000014454633394461590334; - bpsToRay[5776] = 1000000014456643460225133039; - bpsToRay[5777] = 1000000014458653398579827068; - bpsToRay[5778] = 1000000014460663209541823120; - bpsToRay[5779] = 1000000014462672893127268829; - bpsToRay[5780] = 1000000014464682449352308754; - bpsToRay[5781] = 1000000014466691878233084386; - bpsToRay[5782] = 1000000014468701179785734150; - bpsToRay[5783] = 1000000014470710354026393400; - bpsToRay[5784] = 1000000014472719400971194424; - bpsToRay[5785] = 1000000014474728320636266446; - bpsToRay[5786] = 1000000014476737113037735623; - bpsToRay[5787] = 1000000014478745778191725047; - bpsToRay[5788] = 1000000014480754316114354747; - bpsToRay[5789] = 1000000014482762726821741689; - bpsToRay[5790] = 1000000014484771010329999776; - bpsToRay[5791] = 1000000014486779166655239853; - bpsToRay[5792] = 1000000014488787195813569697; - bpsToRay[5793] = 1000000014490795097821094034; - bpsToRay[5794] = 1000000014492802872693914523; - bpsToRay[5795] = 1000000014494810520448129771; - bpsToRay[5796] = 1000000014496818041099835323; - bpsToRay[5797] = 1000000014498825434665123670; - bpsToRay[5798] = 1000000014500832701160084244; - bpsToRay[5799] = 1000000014502839840600803425; - bpsToRay[5800] = 1000000014504846853003364537; - bpsToRay[5801] = 1000000014506853738383847849; - bpsToRay[5802] = 1000000014508860496758330582; - bpsToRay[5803] = 1000000014510867128142886896; - bpsToRay[5804] = 1000000014512873632553587910; - bpsToRay[5805] = 1000000014514880010006501685; - bpsToRay[5806] = 1000000014516886260517693233; - bpsToRay[5807] = 1000000014518892384103224522; - bpsToRay[5808] = 1000000014520898380779154465; - bpsToRay[5809] = 1000000014522904250561538932; - bpsToRay[5810] = 1000000014524909993466430745; - bpsToRay[5811] = 1000000014526915609509879680; - bpsToRay[5812] = 1000000014528921098707932466; - bpsToRay[5813] = 1000000014530926461076632791; - bpsToRay[5814] = 1000000014532931696632021298; - bpsToRay[5815] = 1000000014534936805390135584; - bpsToRay[5816] = 1000000014536941787367010209; - bpsToRay[5817] = 1000000014538946642578676689; - bpsToRay[5818] = 1000000014540951371041163498; - bpsToRay[5819] = 1000000014542955972770496074; - bpsToRay[5820] = 1000000014544960447782696812; - bpsToRay[5821] = 1000000014546964796093785070; - bpsToRay[5822] = 1000000014548969017719777170; - bpsToRay[5823] = 1000000014550973112676686396; - bpsToRay[5824] = 1000000014552977080980522997; - bpsToRay[5825] = 1000000014554980922647294184; - bpsToRay[5826] = 1000000014556984637693004137; - bpsToRay[5827] = 1000000014558988226133654001; - bpsToRay[5828] = 1000000014560991687985241886; - bpsToRay[5829] = 1000000014562995023263762875; - bpsToRay[5830] = 1000000014564998231985209012; - bpsToRay[5831] = 1000000014567001314165569320; - bpsToRay[5832] = 1000000014569004269820829782; - bpsToRay[5833] = 1000000014571007098966973360; - bpsToRay[5834] = 1000000014573009801619979984; - bpsToRay[5835] = 1000000014575012377795826556; - bpsToRay[5836] = 1000000014577014827510486953; - bpsToRay[5837] = 1000000014579017150779932024; - bpsToRay[5838] = 1000000014581019347620129595; - bpsToRay[5839] = 1000000014583021418047044467; - bpsToRay[5840] = 1000000014585023362076638415; - bpsToRay[5841] = 1000000014587025179724870195; - bpsToRay[5842] = 1000000014589026871007695536; - bpsToRay[5843] = 1000000014591028435941067149; - bpsToRay[5844] = 1000000014593029874540934724; - bpsToRay[5845] = 1000000014595031186823244930; - bpsToRay[5846] = 1000000014597032372803941418; - bpsToRay[5847] = 1000000014599033432498964818; - bpsToRay[5848] = 1000000014601034365924252746; - bpsToRay[5849] = 1000000014603035173095739799; - bpsToRay[5850] = 1000000014605035854029357558; - bpsToRay[5851] = 1000000014607036408741034590; - bpsToRay[5852] = 1000000014609036837246696444; - bpsToRay[5853] = 1000000014611037139562265661; - bpsToRay[5854] = 1000000014613037315703661762; - bpsToRay[5855] = 1000000014615037365686801262; - bpsToRay[5856] = 1000000014617037289527597660; - bpsToRay[5857] = 1000000014619037087241961446; - bpsToRay[5858] = 1000000014621036758845800100; - bpsToRay[5859] = 1000000014623036304355018094; - bpsToRay[5860] = 1000000014625035723785516888; - bpsToRay[5861] = 1000000014627035017153194937; - bpsToRay[5862] = 1000000014629034184473947689; - bpsToRay[5863] = 1000000014631033225763667584; - bpsToRay[5864] = 1000000014633032141038244058; - bpsToRay[5865] = 1000000014635030930313563542; - bpsToRay[5866] = 1000000014637029593605509464; - bpsToRay[5867] = 1000000014639028130929962246; - bpsToRay[5868] = 1000000014641026542302799310; - bpsToRay[5869] = 1000000014643024827739895076; - bpsToRay[5870] = 1000000014645022987257120962; - bpsToRay[5871] = 1000000014647021020870345387; - bpsToRay[5872] = 1000000014649018928595433770; - bpsToRay[5873] = 1000000014651016710448248531; - bpsToRay[5874] = 1000000014653014366444649093; - bpsToRay[5875] = 1000000014655011896600491882; - bpsToRay[5876] = 1000000014657009300931630326; - bpsToRay[5877] = 1000000014659006579453914859; - bpsToRay[5878] = 1000000014661003732183192919; - bpsToRay[5879] = 1000000014663000759135308949; - bpsToRay[5880] = 1000000014664997660326104403; - bpsToRay[5881] = 1000000014666994435771417736; - bpsToRay[5882] = 1000000014668991085487084417; - bpsToRay[5883] = 1000000014670987609488936922; - bpsToRay[5884] = 1000000014672984007792804732; - bpsToRay[5885] = 1000000014674980280414514346; - bpsToRay[5886] = 1000000014676976427369889269; - bpsToRay[5887] = 1000000014678972448674750021; - bpsToRay[5888] = 1000000014680968344344914131; - bpsToRay[5889] = 1000000014682964114396196144; - bpsToRay[5890] = 1000000014684959758844407618; - bpsToRay[5891] = 1000000014686955277705357128; - bpsToRay[5892] = 1000000014688950670994850263; - bpsToRay[5893] = 1000000014690945938728689628; - bpsToRay[5894] = 1000000014692941080922674845; - bpsToRay[5895] = 1000000014694936097592602556; - bpsToRay[5896] = 1000000014696930988754266420; - bpsToRay[5897] = 1000000014698925754423457115; - bpsToRay[5898] = 1000000014700920394615962341; - bpsToRay[5899] = 1000000014702914909347566817; - bpsToRay[5900] = 1000000014704909298634052283; - bpsToRay[5901] = 1000000014706903562491197505; - bpsToRay[5902] = 1000000014708897700934778270; - bpsToRay[5903] = 1000000014710891713980567389; - bpsToRay[5904] = 1000000014712885601644334694; - bpsToRay[5905] = 1000000014714879363941847051; - bpsToRay[5906] = 1000000014716873000888868344; - bpsToRay[5907] = 1000000014718866512501159488; - bpsToRay[5908] = 1000000014720859898794478424; - bpsToRay[5909] = 1000000014722853159784580123; - bpsToRay[5910] = 1000000014724846295487216583; - bpsToRay[5911] = 1000000014726839305918136834; - bpsToRay[5912] = 1000000014728832191093086935; - bpsToRay[5913] = 1000000014730824951027809978; - bpsToRay[5914] = 1000000014732817585738046086; - bpsToRay[5915] = 1000000014734810095239532414; - bpsToRay[5916] = 1000000014736802479548003151; - bpsToRay[5917] = 1000000014738794738679189525; - bpsToRay[5918] = 1000000014740786872648819790; - bpsToRay[5919] = 1000000014742778881472619245; - bpsToRay[5920] = 1000000014744770765166310220; - bpsToRay[5921] = 1000000014746762523745612083; - bpsToRay[5922] = 1000000014748754157226241244; - bpsToRay[5923] = 1000000014750745665623911146; - bpsToRay[5924] = 1000000014752737048954332275; - bpsToRay[5925] = 1000000014754728307233212158; - bpsToRay[5926] = 1000000014756719440476255360; - bpsToRay[5927] = 1000000014758710448699163491; - bpsToRay[5928] = 1000000014760701331917635202; - bpsToRay[5929] = 1000000014762692090147366186; - bpsToRay[5930] = 1000000014764682723404049184; - bpsToRay[5931] = 1000000014766673231703373978; - bpsToRay[5932] = 1000000014768663615061027396; - bpsToRay[5933] = 1000000014770653873492693314; - bpsToRay[5934] = 1000000014772644007014052654; - bpsToRay[5935] = 1000000014774634015640783386; - bpsToRay[5936] = 1000000014776623899388560526; - bpsToRay[5937] = 1000000014778613658273056145; - bpsToRay[5938] = 1000000014780603292309939358; - bpsToRay[5939] = 1000000014782592801514876334; - bpsToRay[5940] = 1000000014784582185903530293; - bpsToRay[5941] = 1000000014786571445491561506; - bpsToRay[5942] = 1000000014788560580294627298; - bpsToRay[5943] = 1000000014790549590328382048; - bpsToRay[5944] = 1000000014792538475608477188; - bpsToRay[5945] = 1000000014794527236150561205; - bpsToRay[5946] = 1000000014796515871970279644; - bpsToRay[5947] = 1000000014798504383083275106; - bpsToRay[5948] = 1000000014800492769505187248; - bpsToRay[5949] = 1000000014802481031251652786; - bpsToRay[5950] = 1000000014804469168338305494; - bpsToRay[5951] = 1000000014806457180780776207; - bpsToRay[5952] = 1000000014808445068594692819; - bpsToRay[5953] = 1000000014810432831795680286; - bpsToRay[5954] = 1000000014812420470399360626; - bpsToRay[5955] = 1000000014814407984421352919; - bpsToRay[5956] = 1000000014816395373877273307; - bpsToRay[5957] = 1000000014818382638782734998; - bpsToRay[5958] = 1000000014820369779153348262; - bpsToRay[5959] = 1000000014822356795004720439; - bpsToRay[5960] = 1000000014824343686352455932; - bpsToRay[5961] = 1000000014826330453212156210; - bpsToRay[5962] = 1000000014828317095599419813; - bpsToRay[5963] = 1000000014830303613529842346; - bpsToRay[5964] = 1000000014832290007019016486; - bpsToRay[5965] = 1000000014834276276082531977; - bpsToRay[5966] = 1000000014836262420735975636; - bpsToRay[5967] = 1000000014838248440994931352; - bpsToRay[5968] = 1000000014840234336874980083; - bpsToRay[5969] = 1000000014842220108391699861; - bpsToRay[5970] = 1000000014844205755560665792; - bpsToRay[5971] = 1000000014846191278397450058; - bpsToRay[5972] = 1000000014848176676917621912; - bpsToRay[5973] = 1000000014850161951136747686; - bpsToRay[5974] = 1000000014852147101070390787; - bpsToRay[5975] = 1000000014854132126734111701; - bpsToRay[5976] = 1000000014856117028143467990; - bpsToRay[5977] = 1000000014858101805314014293; - bpsToRay[5978] = 1000000014860086458261302333; - bpsToRay[5979] = 1000000014862070987000880911; - bpsToRay[5980] = 1000000014864055391548295906; - bpsToRay[5981] = 1000000014866039671919090284; - bpsToRay[5982] = 1000000014868023828128804090; - bpsToRay[5983] = 1000000014870007860192974452; - bpsToRay[5984] = 1000000014871991768127135581; - bpsToRay[5985] = 1000000014873975551946818776; - bpsToRay[5986] = 1000000014875959211667552419; - bpsToRay[5987] = 1000000014877942747304861976; - bpsToRay[5988] = 1000000014879926158874270004; - bpsToRay[5989] = 1000000014881909446391296144; - bpsToRay[5990] = 1000000014883892609871457128; - bpsToRay[5991] = 1000000014885875649330266773; - bpsToRay[5992] = 1000000014887858564783235989; - bpsToRay[5993] = 1000000014889841356245872775; - bpsToRay[5994] = 1000000014891824023733682222; - bpsToRay[5995] = 1000000014893806567262166511; - bpsToRay[5996] = 1000000014895788986846824917; - bpsToRay[5997] = 1000000014897771282503153808; - bpsToRay[5998] = 1000000014899753454246646646; - bpsToRay[5999] = 1000000014901735502092793986; - bpsToRay[6000] = 1000000014903717426057083481; - bpsToRay[6001] = 1000000014905699226154999880; - bpsToRay[6002] = 1000000014907680902402025027; - bpsToRay[6003] = 1000000014909662454813637865; - bpsToRay[6004] = 1000000014911643883405314435; - bpsToRay[6005] = 1000000014913625188192527876; - bpsToRay[6006] = 1000000014915606369190748429; - bpsToRay[6007] = 1000000014917587426415443433; - bpsToRay[6008] = 1000000014919568359882077330; - bpsToRay[6009] = 1000000014921549169606111665; - bpsToRay[6010] = 1000000014923529855603005082; - bpsToRay[6011] = 1000000014925510417888213331; - bpsToRay[6012] = 1000000014927490856477189267; - bpsToRay[6013] = 1000000014929471171385382847; - bpsToRay[6014] = 1000000014931451362628241136; - bpsToRay[6015] = 1000000014933431430221208304; - bpsToRay[6016] = 1000000014935411374179725629; - bpsToRay[6017] = 1000000014937391194519231495; - bpsToRay[6018] = 1000000014939370891255161396; - bpsToRay[6019] = 1000000014941350464402947936; - bpsToRay[6020] = 1000000014943329913978020826; - bpsToRay[6021] = 1000000014945309239995806891; - bpsToRay[6022] = 1000000014947288442471730065; - bpsToRay[6023] = 1000000014949267521421211394; - bpsToRay[6024] = 1000000014951246476859669038; - bpsToRay[6025] = 1000000014953225308802518272; - bpsToRay[6026] = 1000000014955204017265171481; - bpsToRay[6027] = 1000000014957182602263038168; - bpsToRay[6028] = 1000000014959161063811524950; - bpsToRay[6029] = 1000000014961139401926035563; - bpsToRay[6030] = 1000000014963117616621970858; - bpsToRay[6031] = 1000000014965095707914728804; - bpsToRay[6032] = 1000000014967073675819704489; - bpsToRay[6033] = 1000000014969051520352290120; - bpsToRay[6034] = 1000000014971029241527875024; - bpsToRay[6035] = 1000000014973006839361845649; - bpsToRay[6036] = 1000000014974984313869585565; - bpsToRay[6037] = 1000000014976961665066475462; - bpsToRay[6038] = 1000000014978938892967893156; - bpsToRay[6039] = 1000000014980915997589213583; - bpsToRay[6040] = 1000000014982892978945808807; - bpsToRay[6041] = 1000000014984869837053048013; - bpsToRay[6042] = 1000000014986846571926297515; - bpsToRay[6043] = 1000000014988823183580920752; - bpsToRay[6044] = 1000000014990799672032278292; - bpsToRay[6045] = 1000000014992776037295727828; - bpsToRay[6046] = 1000000014994752279386624184; - bpsToRay[6047] = 1000000014996728398320319311; - bpsToRay[6048] = 1000000014998704394112162292; - bpsToRay[6049] = 1000000015000680266777499339; - bpsToRay[6050] = 1000000015002656016331673799; - bpsToRay[6051] = 1000000015004631642790026146; - bpsToRay[6052] = 1000000015006607146167893992; - bpsToRay[6053] = 1000000015008582526480612079; - bpsToRay[6054] = 1000000015010557783743512285; - bpsToRay[6055] = 1000000015012532917971923621; - bpsToRay[6056] = 1000000015014507929181172237; - bpsToRay[6057] = 1000000015016482817386581417; - bpsToRay[6058] = 1000000015018457582603471584; - bpsToRay[6059] = 1000000015020432224847160297; - bpsToRay[6060] = 1000000015022406744132962253; - bpsToRay[6061] = 1000000015024381140476189292; - bpsToRay[6062] = 1000000015026355413892150391; - bpsToRay[6063] = 1000000015028329564396151668; - bpsToRay[6064] = 1000000015030303592003496384; - bpsToRay[6065] = 1000000015032277496729484940; - bpsToRay[6066] = 1000000015034251278589414882; - bpsToRay[6067] = 1000000015036224937598580896; - bpsToRay[6068] = 1000000015038198473772274819; - bpsToRay[6069] = 1000000015040171887125785626; - bpsToRay[6070] = 1000000015042145177674399441; - bpsToRay[6071] = 1000000015044118345433399534; - bpsToRay[6072] = 1000000015046091390418066323; - bpsToRay[6073] = 1000000015048064312643677371; - bpsToRay[6074] = 1000000015050037112125507393; - bpsToRay[6075] = 1000000015052009788878828253; - bpsToRay[6076] = 1000000015053982342918908961; - bpsToRay[6077] = 1000000015055954774261015682; - bpsToRay[6078] = 1000000015057927082920411731; - bpsToRay[6079] = 1000000015059899268912357574; - bpsToRay[6080] = 1000000015061871332252110832; - bpsToRay[6081] = 1000000015063843272954926277; - bpsToRay[6082] = 1000000015065815091036055837; - bpsToRay[6083] = 1000000015067786786510748595; - bpsToRay[6084] = 1000000015069758359394250789; - bpsToRay[6085] = 1000000015071729809701805813; - bpsToRay[6086] = 1000000015073701137448654217; - bpsToRay[6087] = 1000000015075672342650033713; - bpsToRay[6088] = 1000000015077643425321179167; - bpsToRay[6089] = 1000000015079614385477322606; - bpsToRay[6090] = 1000000015081585223133693217; - bpsToRay[6091] = 1000000015083555938305517348; - bpsToRay[6092] = 1000000015085526531008018506; - bpsToRay[6093] = 1000000015087497001256417364; - bpsToRay[6094] = 1000000015089467349065931754; - bpsToRay[6095] = 1000000015091437574451776672; - bpsToRay[6096] = 1000000015093407677429164279; - bpsToRay[6097] = 1000000015095377658013303902; - bpsToRay[6098] = 1000000015097347516219402031; - bpsToRay[6099] = 1000000015099317252062662325; - bpsToRay[6100] = 1000000015101286865558285606; - bpsToRay[6101] = 1000000015103256356721469870; - bpsToRay[6102] = 1000000015105225725567410272; - bpsToRay[6103] = 1000000015107194972111299145; - bpsToRay[6104] = 1000000015109164096368325987; - bpsToRay[6105] = 1000000015111133098353677468; - bpsToRay[6106] = 1000000015113101978082537430; - bpsToRay[6107] = 1000000015115070735570086883; - bpsToRay[6108] = 1000000015117039370831504013; - bpsToRay[6109] = 1000000015119007883881964179; - bpsToRay[6110] = 1000000015120976274736639914; - bpsToRay[6111] = 1000000015122944543410700923; - bpsToRay[6112] = 1000000015124912689919314090; - bpsToRay[6113] = 1000000015126880714277643473; - bpsToRay[6114] = 1000000015128848616500850307; - bpsToRay[6115] = 1000000015130816396604093005; - bpsToRay[6116] = 1000000015132784054602527158; - bpsToRay[6117] = 1000000015134751590511305536; - bpsToRay[6118] = 1000000015136719004345578088; - bpsToRay[6119] = 1000000015138686296120491942; - bpsToRay[6120] = 1000000015140653465851191411; - bpsToRay[6121] = 1000000015142620513552817987; - bpsToRay[6122] = 1000000015144587439240510342; - bpsToRay[6123] = 1000000015146554242929404336; - bpsToRay[6124] = 1000000015148520924634633011; - bpsToRay[6125] = 1000000015150487484371326590; - bpsToRay[6126] = 1000000015152453922154612487; - bpsToRay[6127] = 1000000015154420237999615297; - bpsToRay[6128] = 1000000015156386431921456805; - bpsToRay[6129] = 1000000015158352503935255979; - bpsToRay[6130] = 1000000015160318454056128981; - bpsToRay[6131] = 1000000015162284282299189156; - bpsToRay[6132] = 1000000015164249988679547042; - bpsToRay[6133] = 1000000015166215573212310364; - bpsToRay[6134] = 1000000015168181035912584041; - bpsToRay[6135] = 1000000015170146376795470181; - bpsToRay[6136] = 1000000015172111595876068086; - bpsToRay[6137] = 1000000015174076693169474249; - bpsToRay[6138] = 1000000015176041668690782357; - bpsToRay[6139] = 1000000015178006522455083294; - bpsToRay[6140] = 1000000015179971254477465133; - bpsToRay[6141] = 1000000015181935864773013148; - bpsToRay[6142] = 1000000015183900353356809808; - bpsToRay[6143] = 1000000015185864720243934777; - bpsToRay[6144] = 1000000015187828965449464919; - bpsToRay[6145] = 1000000015189793088988474295; - bpsToRay[6146] = 1000000015191757090876034166; - bpsToRay[6147] = 1000000015193720971127212993; - bpsToRay[6148] = 1000000015195684729757076435; - bpsToRay[6149] = 1000000015197648366780687356; - bpsToRay[6150] = 1000000015199611882213105818; - bpsToRay[6151] = 1000000015201575276069389089; - bpsToRay[6152] = 1000000015203538548364591637; - bpsToRay[6153] = 1000000015205501699113765138; - bpsToRay[6154] = 1000000015207464728331958468; - bpsToRay[6155] = 1000000015209427636034217712; - bpsToRay[6156] = 1000000015211390422235586158; - bpsToRay[6157] = 1000000015213353086951104304; - bpsToRay[6158] = 1000000015215315630195809853; - bpsToRay[6159] = 1000000015217278051984737717; - bpsToRay[6160] = 1000000015219240352332920015; - bpsToRay[6161] = 1000000015221202531255386080; - bpsToRay[6162] = 1000000015223164588767162449; - bpsToRay[6163] = 1000000015225126524883272874; - bpsToRay[6164] = 1000000015227088339618738319; - bpsToRay[6165] = 1000000015229050032988576957; - bpsToRay[6166] = 1000000015231011605007804177; - bpsToRay[6167] = 1000000015232973055691432580; - bpsToRay[6168] = 1000000015234934385054471980; - bpsToRay[6169] = 1000000015236895593111929410; - bpsToRay[6170] = 1000000015238856679878809116; - bpsToRay[6171] = 1000000015240817645370112558; - bpsToRay[6172] = 1000000015242778489600838420; - bpsToRay[6173] = 1000000015244739212585982595; - bpsToRay[6174] = 1000000015246699814340538201; - bpsToRay[6175] = 1000000015248660294879495575; - bpsToRay[6176] = 1000000015250620654217842268; - bpsToRay[6177] = 1000000015252580892370563058; - bpsToRay[6178] = 1000000015254541009352639939; - bpsToRay[6179] = 1000000015256501005179052132; - bpsToRay[6180] = 1000000015258460879864776078; - bpsToRay[6181] = 1000000015260420633424785438; - bpsToRay[6182] = 1000000015262380265874051103; - bpsToRay[6183] = 1000000015264339777227541185; - bpsToRay[6184] = 1000000015266299167500221022; - bpsToRay[6185] = 1000000015268258436707053177; - bpsToRay[6186] = 1000000015270217584862997442; - bpsToRay[6187] = 1000000015272176611983010835; - bpsToRay[6188] = 1000000015274135518082047600; - bpsToRay[6189] = 1000000015276094303175059215; - bpsToRay[6190] = 1000000015278052967276994381; - bpsToRay[6191] = 1000000015280011510402799035; - bpsToRay[6192] = 1000000015281969932567416340; - bpsToRay[6193] = 1000000015283928233785786694; - bpsToRay[6194] = 1000000015285886414072847725; - bpsToRay[6195] = 1000000015287844473443534295; - bpsToRay[6196] = 1000000015289802411912778498; - bpsToRay[6197] = 1000000015291760229495509665; - bpsToRay[6198] = 1000000015293717926206654358; - bpsToRay[6199] = 1000000015295675502061136378; - bpsToRay[6200] = 1000000015297632957073876761; - bpsToRay[6201] = 1000000015299590291259793780; - bpsToRay[6202] = 1000000015301547504633802945; - bpsToRay[6203] = 1000000015303504597210817004; - bpsToRay[6204] = 1000000015305461569005745947; - bpsToRay[6205] = 1000000015307418420033496998; - bpsToRay[6206] = 1000000015309375150308974628; - bpsToRay[6207] = 1000000015311331759847080545; - bpsToRay[6208] = 1000000015313288248662713699; - bpsToRay[6209] = 1000000015315244616770770282; - bpsToRay[6210] = 1000000015317200864186143732; - bpsToRay[6211] = 1000000015319156990923724726; - bpsToRay[6212] = 1000000015321112996998401190; - bpsToRay[6213] = 1000000015323068882425058294; - bpsToRay[6214] = 1000000015325024647218578451; - bpsToRay[6215] = 1000000015326980291393841323; - bpsToRay[6216] = 1000000015328935814965723819; - bpsToRay[6217] = 1000000015330891217949100095; - bpsToRay[6218] = 1000000015332846500358841555; - bpsToRay[6219] = 1000000015334801662209816855; - bpsToRay[6220] = 1000000015336756703516891898; - bpsToRay[6221] = 1000000015338711624294929839; - bpsToRay[6222] = 1000000015340666424558791082; - bpsToRay[6223] = 1000000015342621104323333287; - bpsToRay[6224] = 1000000015344575663603411362; - bpsToRay[6225] = 1000000015346530102413877471; - bpsToRay[6226] = 1000000015348484420769581033; - bpsToRay[6227] = 1000000015350438618685368717; - bpsToRay[6228] = 1000000015352392696176084451; - bpsToRay[6229] = 1000000015354346653256569420; - bpsToRay[6230] = 1000000015356300489941662062; - bpsToRay[6231] = 1000000015358254206246198075; - bpsToRay[6232] = 1000000015360207802185010413; - bpsToRay[6233] = 1000000015362161277772929290; - bpsToRay[6234] = 1000000015364114633024782180; - bpsToRay[6235] = 1000000015366067867955393814; - bpsToRay[6236] = 1000000015368020982579586188; - bpsToRay[6237] = 1000000015369973976912178557; - bpsToRay[6238] = 1000000015371926850967987435; - bpsToRay[6239] = 1000000015373879604761826606; - bpsToRay[6240] = 1000000015375832238308507110; - bpsToRay[6241] = 1000000015377784751622837256; - bpsToRay[6242] = 1000000015379737144719622615; - bpsToRay[6243] = 1000000015381689417613666024; - bpsToRay[6244] = 1000000015383641570319767589; - bpsToRay[6245] = 1000000015385593602852724678; - bpsToRay[6246] = 1000000015387545515227331928; - bpsToRay[6247] = 1000000015389497307458381246; - bpsToRay[6248] = 1000000015391448979560661806; - bpsToRay[6249] = 1000000015393400531548960052; - bpsToRay[6250] = 1000000015395351963438059699; - bpsToRay[6251] = 1000000015397303275242741731; - bpsToRay[6252] = 1000000015399254466977784403; - bpsToRay[6253] = 1000000015401205538657963245; - bpsToRay[6254] = 1000000015403156490298051058; - bpsToRay[6255] = 1000000015405107321912817917; - bpsToRay[6256] = 1000000015407058033517031169; - bpsToRay[6257] = 1000000015409008625125455440; - bpsToRay[6258] = 1000000015410959096752852627; - bpsToRay[6259] = 1000000015412909448413981907; - bpsToRay[6260] = 1000000015414859680123599731; - bpsToRay[6261] = 1000000015416809791896459828; - bpsToRay[6262] = 1000000015418759783747313206; - bpsToRay[6263] = 1000000015420709655690908154; - bpsToRay[6264] = 1000000015422659407741990234; - bpsToRay[6265] = 1000000015424609039915302295; - bpsToRay[6266] = 1000000015426558552225584464; - bpsToRay[6267] = 1000000015428507944687574148; - bpsToRay[6268] = 1000000015430457217316006040; - bpsToRay[6269] = 1000000015432406370125612111; - bpsToRay[6270] = 1000000015434355403131121619; - bpsToRay[6271] = 1000000015436304316347261106; - bpsToRay[6272] = 1000000015438253109788754397; - bpsToRay[6273] = 1000000015440201783470322605; - bpsToRay[6274] = 1000000015442150337406684127; - bpsToRay[6275] = 1000000015444098771612554646; - bpsToRay[6276] = 1000000015446047086102647137; - bpsToRay[6277] = 1000000015447995280891671860; - bpsToRay[6278] = 1000000015449943355994336362; - bpsToRay[6279] = 1000000015451891311425345484; - bpsToRay[6280] = 1000000015453839147199401353; - bpsToRay[6281] = 1000000015455786863331203391; - bpsToRay[6282] = 1000000015457734459835448307; - bpsToRay[6283] = 1000000015459681936726830105; - bpsToRay[6284] = 1000000015461629294020040082; - bpsToRay[6285] = 1000000015463576531729766828; - bpsToRay[6286] = 1000000015465523649870696226; - bpsToRay[6287] = 1000000015467470648457511454; - bpsToRay[6288] = 1000000015469417527504892989; - bpsToRay[6289] = 1000000015471364287027518599; - bpsToRay[6290] = 1000000015473310927040063352; - bpsToRay[6291] = 1000000015475257447557199613; - bpsToRay[6292] = 1000000015477203848593597045; - bpsToRay[6293] = 1000000015479150130163922609; - bpsToRay[6294] = 1000000015481096292282840567; - bpsToRay[6295] = 1000000015483042334965012479; - bpsToRay[6296] = 1000000015484988258225097210; - bpsToRay[6297] = 1000000015486934062077750921; - bpsToRay[6298] = 1000000015488879746537627079; - bpsToRay[6299] = 1000000015490825311619376452; - bpsToRay[6300] = 1000000015492770757337647112; - bpsToRay[6301] = 1000000015494716083707084436; - bpsToRay[6302] = 1000000015496661290742331104; - bpsToRay[6303] = 1000000015498606378458027103; - bpsToRay[6304] = 1000000015500551346868809725; - bpsToRay[6305] = 1000000015502496195989313568; - bpsToRay[6306] = 1000000015504440925834170541; - bpsToRay[6307] = 1000000015506385536418009859; - bpsToRay[6308] = 1000000015508330027755458043; - bpsToRay[6309] = 1000000015510274399861138927; - bpsToRay[6310] = 1000000015512218652749673656; - bpsToRay[6311] = 1000000015514162786435680680; - bpsToRay[6312] = 1000000015516106800933775766; - bpsToRay[6313] = 1000000015518050696258571992; - bpsToRay[6314] = 1000000015519994472424679745; - bpsToRay[6315] = 1000000015521938129446706731; - bpsToRay[6316] = 1000000015523881667339257966; - bpsToRay[6317] = 1000000015525825086116935783; - bpsToRay[6318] = 1000000015527768385794339827; - bpsToRay[6319] = 1000000015529711566386067064; - bpsToRay[6320] = 1000000015531654627906711771; - bpsToRay[6321] = 1000000015533597570370865546; - bpsToRay[6322] = 1000000015535540393793117305; - bpsToRay[6323] = 1000000015537483098188053282; - bpsToRay[6324] = 1000000015539425683570257029; - bpsToRay[6325] = 1000000015541368149954309419; - bpsToRay[6326] = 1000000015543310497354788646; - bpsToRay[6327] = 1000000015545252725786270226; - bpsToRay[6328] = 1000000015547194835263326993; - bpsToRay[6329] = 1000000015549136825800529108; - bpsToRay[6330] = 1000000015551078697412444053; - bpsToRay[6331] = 1000000015553020450113636636; - bpsToRay[6332] = 1000000015554962083918668986; - bpsToRay[6333] = 1000000015556903598842100559; - bpsToRay[6334] = 1000000015558844994898488139; - bpsToRay[6335] = 1000000015560786272102385832; - bpsToRay[6336] = 1000000015562727430468345075; - bpsToRay[6337] = 1000000015564668470010914631; - bpsToRay[6338] = 1000000015566609390744640592; - bpsToRay[6339] = 1000000015568550192684066380; - bpsToRay[6340] = 1000000015570490875843732744; - bpsToRay[6341] = 1000000015572431440238177765; - bpsToRay[6342] = 1000000015574371885881936857; - bpsToRay[6343] = 1000000015576312212789542763; - bpsToRay[6344] = 1000000015578252420975525559; - bpsToRay[6345] = 1000000015580192510454412655; - bpsToRay[6346] = 1000000015582132481240728794; - bpsToRay[6347] = 1000000015584072333348996053; - bpsToRay[6348] = 1000000015586012066793733846; - bpsToRay[6349] = 1000000015587951681589458919; - bpsToRay[6350] = 1000000015589891177750685357; - bpsToRay[6351] = 1000000015591830555291924580; - bpsToRay[6352] = 1000000015593769814227685350; - bpsToRay[6353] = 1000000015595708954572473762; - bpsToRay[6354] = 1000000015597647976340793253; - bpsToRay[6355] = 1000000015599586879547144596; - bpsToRay[6356] = 1000000015601525664206025911; - bpsToRay[6357] = 1000000015603464330331932651; - bpsToRay[6358] = 1000000015605402877939357616; - bpsToRay[6359] = 1000000015607341307042790947; - bpsToRay[6360] = 1000000015609279617656720124; - bpsToRay[6361] = 1000000015611217809795629977; - bpsToRay[6362] = 1000000015613155883474002675; - bpsToRay[6363] = 1000000015615093838706317732; - bpsToRay[6364] = 1000000015617031675507052012; - bpsToRay[6365] = 1000000015618969393890679720; - bpsToRay[6366] = 1000000015620906993871672410; - bpsToRay[6367] = 1000000015622844475464498982; - bpsToRay[6368] = 1000000015624781838683625685; - bpsToRay[6369] = 1000000015626719083543516119; - bpsToRay[6370] = 1000000015628656210058631227; - bpsToRay[6371] = 1000000015630593218243429309; - bpsToRay[6372] = 1000000015632530108112366010; - bpsToRay[6373] = 1000000015634466879679894331; - bpsToRay[6374] = 1000000015636403532960464619; - bpsToRay[6375] = 1000000015638340067968524580; - bpsToRay[6376] = 1000000015640276484718519269; - bpsToRay[6377] = 1000000015642212783224891098; - bpsToRay[6378] = 1000000015644148963502079827; - bpsToRay[6379] = 1000000015646085025564522580; - bpsToRay[6380] = 1000000015648020969426653830; - bpsToRay[6381] = 1000000015649956795102905409; - bpsToRay[6382] = 1000000015651892502607706506; - bpsToRay[6383] = 1000000015653828091955483667; - bpsToRay[6384] = 1000000015655763563160660798; - bpsToRay[6385] = 1000000015657698916237659162; - bpsToRay[6386] = 1000000015659634151200897382; - bpsToRay[6387] = 1000000015661569268064791442; - bpsToRay[6388] = 1000000015663504266843754688; - bpsToRay[6389] = 1000000015665439147552197824; - bpsToRay[6390] = 1000000015667373910204528920; - bpsToRay[6391] = 1000000015669308554815153405; - bpsToRay[6392] = 1000000015671243081398474077; - bpsToRay[6393] = 1000000015673177489968891092; - bpsToRay[6394] = 1000000015675111780540801975; - bpsToRay[6395] = 1000000015677045953128601614; - bpsToRay[6396] = 1000000015678980007746682266; - bpsToRay[6397] = 1000000015680913944409433552; - bpsToRay[6398] = 1000000015682847763131242461; - bpsToRay[6399] = 1000000015684781463926493350; - bpsToRay[6400] = 1000000015686715046809567945; - bpsToRay[6401] = 1000000015688648511794845341; - bpsToRay[6402] = 1000000015690581858896702002; - bpsToRay[6403] = 1000000015692515088129511766; - bpsToRay[6404] = 1000000015694448199507645837; - bpsToRay[6405] = 1000000015696381193045472797; - bpsToRay[6406] = 1000000015698314068757358594; - bpsToRay[6407] = 1000000015700246826657666553; - bpsToRay[6408] = 1000000015702179466760757373; - bpsToRay[6409] = 1000000015704111989080989125; - bpsToRay[6410] = 1000000015706044393632717258; - bpsToRay[6411] = 1000000015707976680430294594; - bpsToRay[6412] = 1000000015709908849488071333; - bpsToRay[6413] = 1000000015711840900820395051; - bpsToRay[6414] = 1000000015713772834441610701; - bpsToRay[6415] = 1000000015715704650366060617; - bpsToRay[6416] = 1000000015717636348608084511; - bpsToRay[6417] = 1000000015719567929182019470; - bpsToRay[6418] = 1000000015721499392102199968; - bpsToRay[6419] = 1000000015723430737382957855; - bpsToRay[6420] = 1000000015725361965038622365; - bpsToRay[6421] = 1000000015727293075083520113; - bpsToRay[6422] = 1000000015729224067531975096; - bpsToRay[6423] = 1000000015731154942398308695; - bpsToRay[6424] = 1000000015733085699696839676; - bpsToRay[6425] = 1000000015735016339441884188; - bpsToRay[6426] = 1000000015736946861647755768; - bpsToRay[6427] = 1000000015738877266328765334; - bpsToRay[6428] = 1000000015740807553499221196; - bpsToRay[6429] = 1000000015742737723173429047; - bpsToRay[6430] = 1000000015744667775365691970; - bpsToRay[6431] = 1000000015746597710090310436; - bpsToRay[6432] = 1000000015748527527361582305; - bpsToRay[6433] = 1000000015750457227193802825; - bpsToRay[6434] = 1000000015752386809601264637; - bpsToRay[6435] = 1000000015754316274598257774; - bpsToRay[6436] = 1000000015756245622199069656; - bpsToRay[6437] = 1000000015758174852417985099; - bpsToRay[6438] = 1000000015760103965269286310; - bpsToRay[6439] = 1000000015762032960767252891; - bpsToRay[6440] = 1000000015763961838926161836; - bpsToRay[6441] = 1000000015765890599760287538; - bpsToRay[6442] = 1000000015767819243283901779; - bpsToRay[6443] = 1000000015769747769511273744; - bpsToRay[6444] = 1000000015771676178456670009; - bpsToRay[6445] = 1000000015773604470134354550; - bpsToRay[6446] = 1000000015775532644558588743; - bpsToRay[6447] = 1000000015777460701743631357; - bpsToRay[6448] = 1000000015779388641703738565; - bpsToRay[6449] = 1000000015781316464453163938; - bpsToRay[6450] = 1000000015783244170006158447; - bpsToRay[6451] = 1000000015785171758376970467; - bpsToRay[6452] = 1000000015787099229579845770; - bpsToRay[6453] = 1000000015789026583629027536; - bpsToRay[6454] = 1000000015790953820538756342; - bpsToRay[6455] = 1000000015792880940323270174; - bpsToRay[6456] = 1000000015794807942996804419; - bpsToRay[6457] = 1000000015796734828573591870; - bpsToRay[6458] = 1000000015798661597067862724; - bpsToRay[6459] = 1000000015800588248493844588; - bpsToRay[6460] = 1000000015802514782865762472; - bpsToRay[6461] = 1000000015804441200197838795; - bpsToRay[6462] = 1000000015806367500504293384; - bpsToRay[6463] = 1000000015808293683799343474; - bpsToRay[6464] = 1000000015810219750097203710; - bpsToRay[6465] = 1000000015812145699412086147; - bpsToRay[6466] = 1000000015814071531758200252; - bpsToRay[6467] = 1000000015815997247149752899; - bpsToRay[6468] = 1000000015817922845600948377; - bpsToRay[6469] = 1000000015819848327125988387; - bpsToRay[6470] = 1000000015821773691739072044; - bpsToRay[6471] = 1000000015823698939454395875; - bpsToRay[6472] = 1000000015825624070286153821; - bpsToRay[6473] = 1000000015827549084248537241; - bpsToRay[6474] = 1000000015829473981355734906; - bpsToRay[6475] = 1000000015831398761621933006; - bpsToRay[6476] = 1000000015833323425061315145; - bpsToRay[6477] = 1000000015835247971688062347; - bpsToRay[6478] = 1000000015837172401516353055; - bpsToRay[6479] = 1000000015839096714560363128; - bpsToRay[6480] = 1000000015841020910834265843; - bpsToRay[6481] = 1000000015842944990352231903; - bpsToRay[6482] = 1000000015844868953128429425; - bpsToRay[6483] = 1000000015846792799177023953; - bpsToRay[6484] = 1000000015848716528512178448; - bpsToRay[6485] = 1000000015850640141148053296; - bpsToRay[6486] = 1000000015852563637098806307; - bpsToRay[6487] = 1000000015854487016378592712; - bpsToRay[6488] = 1000000015856410279001565169; - bpsToRay[6489] = 1000000015858333424981873758; - bpsToRay[6490] = 1000000015860256454333665989; - bpsToRay[6491] = 1000000015862179367071086794; - bpsToRay[6492] = 1000000015864102163208278534; - bpsToRay[6493] = 1000000015866024842759380997; - bpsToRay[6494] = 1000000015867947405738531398; - bpsToRay[6495] = 1000000015869869852159864384; - bpsToRay[6496] = 1000000015871792182037512030; - bpsToRay[6497] = 1000000015873714395385603836; - bpsToRay[6498] = 1000000015875636492218266741; - bpsToRay[6499] = 1000000015877558472549625110; - bpsToRay[6500] = 1000000015879480336393800741; - bpsToRay[6501] = 1000000015881402083764912862; - bpsToRay[6502] = 1000000015883323714677078140; - bpsToRay[6503] = 1000000015885245229144410671; - bpsToRay[6504] = 1000000015887166627181021987; - bpsToRay[6505] = 1000000015889087908801021053; - bpsToRay[6506] = 1000000015891009074018514273; - bpsToRay[6507] = 1000000015892930122847605485; - bpsToRay[6508] = 1000000015894851055302395963; - bpsToRay[6509] = 1000000015896771871396984421; - bpsToRay[6510] = 1000000015898692571145467010; - bpsToRay[6511] = 1000000015900613154561937317; - bpsToRay[6512] = 1000000015902533621660486374; - bpsToRay[6513] = 1000000015904453972455202647; - bpsToRay[6514] = 1000000015906374206960172047; - bpsToRay[6515] = 1000000015908294325189477924; - bpsToRay[6516] = 1000000015910214327157201069; - bpsToRay[6517] = 1000000015912134212877419719; - bpsToRay[6518] = 1000000015914053982364209549; - bpsToRay[6519] = 1000000015915973635631643682; - bpsToRay[6520] = 1000000015917893172693792683; - bpsToRay[6521] = 1000000015919812593564724562; - bpsToRay[6522] = 1000000015921731898258504776; - bpsToRay[6523] = 1000000015923651086789196227; - bpsToRay[6524] = 1000000015925570159170859262; - bpsToRay[6525] = 1000000015927489115417551681; - bpsToRay[6526] = 1000000015929407955543328724; - bpsToRay[6527] = 1000000015931326679562243086; - bpsToRay[6528] = 1000000015933245287488344910; - bpsToRay[6529] = 1000000015935163779335681785; - bpsToRay[6530] = 1000000015937082155118298755; - bpsToRay[6531] = 1000000015939000414850238313; - bpsToRay[6532] = 1000000015940918558545540404; - bpsToRay[6533] = 1000000015942836586218242426; - bpsToRay[6534] = 1000000015944754497882379228; - bpsToRay[6535] = 1000000015946672293551983115; - bpsToRay[6536] = 1000000015948589973241083845; - bpsToRay[6537] = 1000000015950507536963708629; - bpsToRay[6538] = 1000000015952424984733882136; - bpsToRay[6539] = 1000000015954342316565626492; - bpsToRay[6540] = 1000000015956259532472961274; - bpsToRay[6541] = 1000000015958176632469903523; - bpsToRay[6542] = 1000000015960093616570467734; - bpsToRay[6543] = 1000000015962010484788665860; - bpsToRay[6544] = 1000000015963927237138507317; - bpsToRay[6545] = 1000000015965843873633998974; - bpsToRay[6546] = 1000000015967760394289145167; - bpsToRay[6547] = 1000000015969676799117947690; - bpsToRay[6548] = 1000000015971593088134405798; - bpsToRay[6549] = 1000000015973509261352516209; - bpsToRay[6550] = 1000000015975425318786273105; - bpsToRay[6551] = 1000000015977341260449668127; - bpsToRay[6552] = 1000000015979257086356690385; - bpsToRay[6553] = 1000000015981172796521326452; - bpsToRay[6554] = 1000000015983088390957560365; - bpsToRay[6555] = 1000000015985003869679373628; - bpsToRay[6556] = 1000000015986919232700745209; - bpsToRay[6557] = 1000000015988834480035651548; - bpsToRay[6558] = 1000000015990749611698066548; - bpsToRay[6559] = 1000000015992664627701961582; - bpsToRay[6560] = 1000000015994579528061305491; - bpsToRay[6561] = 1000000015996494312790064590; - bpsToRay[6562] = 1000000015998408981902202656; - bpsToRay[6563] = 1000000016000323535411680943; - bpsToRay[6564] = 1000000016002237973332458175; - bpsToRay[6565] = 1000000016004152295678490547; - bpsToRay[6566] = 1000000016006066502463731726; - bpsToRay[6567] = 1000000016007980593702132855; - bpsToRay[6568] = 1000000016009894569407642547; - bpsToRay[6569] = 1000000016011808429594206893; - bpsToRay[6570] = 1000000016013722174275769455; - bpsToRay[6571] = 1000000016015635803466271275; - bpsToRay[6572] = 1000000016017549317179650868; - bpsToRay[6573] = 1000000016019462715429844226; - bpsToRay[6574] = 1000000016021375998230784820; - bpsToRay[6575] = 1000000016023289165596403599; - bpsToRay[6576] = 1000000016025202217540628989; - bpsToRay[6577] = 1000000016027115154077386896; - bpsToRay[6578] = 1000000016029027975220600708; - bpsToRay[6579] = 1000000016030940680984191289; - bpsToRay[6580] = 1000000016032853271382076987; - bpsToRay[6581] = 1000000016034765746428173632; - bpsToRay[6582] = 1000000016036678106136394535; - bpsToRay[6583] = 1000000016038590350520650490; - bpsToRay[6584] = 1000000016040502479594849776; - bpsToRay[6585] = 1000000016042414493372898155; - bpsToRay[6586] = 1000000016044326391868698872; - bpsToRay[6587] = 1000000016046238175096152661; - bpsToRay[6588] = 1000000016048149843069157739; - bpsToRay[6589] = 1000000016050061395801609810; - bpsToRay[6590] = 1000000016051972833307402066; - bpsToRay[6591] = 1000000016053884155600425188; - bpsToRay[6592] = 1000000016055795362694567342; - bpsToRay[6593] = 1000000016057706454603714184; - bpsToRay[6594] = 1000000016059617431341748863; - bpsToRay[6595] = 1000000016061528292922552013; - bpsToRay[6596] = 1000000016063439039360001761; - bpsToRay[6597] = 1000000016065349670667973728; - bpsToRay[6598] = 1000000016067260186860341022; - bpsToRay[6599] = 1000000016069170587950974247; - bpsToRay[6600] = 1000000016071080873953741499; - bpsToRay[6601] = 1000000016072991044882508369; - bpsToRay[6602] = 1000000016074901100751137941; - bpsToRay[6603] = 1000000016076811041573490795; - bpsToRay[6604] = 1000000016078720867363425005; - bpsToRay[6605] = 1000000016080630578134796143; - bpsToRay[6606] = 1000000016082540173901457278; - bpsToRay[6607] = 1000000016084449654677258973; - bpsToRay[6608] = 1000000016086359020476049294; - bpsToRay[6609] = 1000000016088268271311673802; - bpsToRay[6610] = 1000000016090177407197975559; - bpsToRay[6611] = 1000000016092086428148795125; - bpsToRay[6612] = 1000000016093995334177970563; - bpsToRay[6613] = 1000000016095904125299337436; - bpsToRay[6614] = 1000000016097812801526728807; - bpsToRay[6615] = 1000000016099721362873975244; - bpsToRay[6616] = 1000000016101629809354904814; - bpsToRay[6617] = 1000000016103538140983343092; - bpsToRay[6618] = 1000000016105446357773113153; - bpsToRay[6619] = 1000000016107354459738035580; - bpsToRay[6620] = 1000000016109262446891928459; - bpsToRay[6621] = 1000000016111170319248607383; - bpsToRay[6622] = 1000000016113078076821885451; - bpsToRay[6623] = 1000000016114985719625573268; - bpsToRay[6624] = 1000000016116893247673478948; - bpsToRay[6625] = 1000000016118800660979408115; - bpsToRay[6626] = 1000000016120707959557163897; - bpsToRay[6627] = 1000000016122615143420546934; - bpsToRay[6628] = 1000000016124522212583355378; - bpsToRay[6629] = 1000000016126429167059384889; - bpsToRay[6630] = 1000000016128336006862428639; - bpsToRay[6631] = 1000000016130242732006277312; - bpsToRay[6632] = 1000000016132149342504719104; - bpsToRay[6633] = 1000000016134055838371539725; - bpsToRay[6634] = 1000000016135962219620522398; - bpsToRay[6635] = 1000000016137868486265447859; - bpsToRay[6636] = 1000000016139774638320094360; - bpsToRay[6637] = 1000000016141680675798237669; - bpsToRay[6638] = 1000000016143586598713651070; - bpsToRay[6639] = 1000000016145492407080105363; - bpsToRay[6640] = 1000000016147398100911368865; - bpsToRay[6641] = 1000000016149303680221207410; - bpsToRay[6642] = 1000000016151209145023384352; - bpsToRay[6643] = 1000000016153114495331660565; - bpsToRay[6644] = 1000000016155019731159794439; - bpsToRay[6645] = 1000000016156924852521541888; - bpsToRay[6646] = 1000000016158829859430656342; - bpsToRay[6647] = 1000000016160734751900888759; - bpsToRay[6648] = 1000000016162639529945987614; - bpsToRay[6649] = 1000000016164544193579698905; - bpsToRay[6650] = 1000000016166448742815766155; - bpsToRay[6651] = 1000000016168353177667930410; - bpsToRay[6652] = 1000000016170257498149930239; - bpsToRay[6653] = 1000000016172161704275501740; - bpsToRay[6654] = 1000000016174065796058378532; - bpsToRay[6655] = 1000000016175969773512291760; - bpsToRay[6656] = 1000000016177873636650970102; - bpsToRay[6657] = 1000000016179777385488139756; - bpsToRay[6658] = 1000000016181681020037524450; - bpsToRay[6659] = 1000000016183584540312845443; - bpsToRay[6660] = 1000000016185487946327821522; - bpsToRay[6661] = 1000000016187391238096169003; - bpsToRay[6662] = 1000000016189294415631601732; - bpsToRay[6663] = 1000000016191197478947831086; - bpsToRay[6664] = 1000000016193100428058565975; - bpsToRay[6665] = 1000000016195003262977512839; - bpsToRay[6666] = 1000000016196905983718375652; - bpsToRay[6667] = 1000000016198808590294855920; - bpsToRay[6668] = 1000000016200711082720652686; - bpsToRay[6669] = 1000000016202613461009462523; - bpsToRay[6670] = 1000000016204515725174979542; - bpsToRay[6671] = 1000000016206417875230895389; - bpsToRay[6672] = 1000000016208319911190899247; - bpsToRay[6673] = 1000000016210221833068677832; - bpsToRay[6674] = 1000000016212123640877915404; - bpsToRay[6675] = 1000000016214025334632293755; - bpsToRay[6676] = 1000000016215926914345492218; - bpsToRay[6677] = 1000000016217828380031187665; - bpsToRay[6678] = 1000000016219729731703054508; - bpsToRay[6679] = 1000000016221630969374764700; - bpsToRay[6680] = 1000000016223532093059987732; - bpsToRay[6681] = 1000000016225433102772390641; - bpsToRay[6682] = 1000000016227333998525638003; - bpsToRay[6683] = 1000000016229234780333391936; - bpsToRay[6684] = 1000000016231135448209312105; - bpsToRay[6685] = 1000000016233036002167055714; - bpsToRay[6686] = 1000000016234936442220277518; - bpsToRay[6687] = 1000000016236836768382629809; - bpsToRay[6688] = 1000000016238736980667762431; - bpsToRay[6689] = 1000000016240637079089322772; - bpsToRay[6690] = 1000000016242537063660955766; - bpsToRay[6691] = 1000000016244436934396303896; - bpsToRay[6692] = 1000000016246336691309007193; - bpsToRay[6693] = 1000000016248236334412703235; - bpsToRay[6694] = 1000000016250135863721027150; - bpsToRay[6695] = 1000000016252035279247611617; - bpsToRay[6696] = 1000000016253934581006086862; - bpsToRay[6697] = 1000000016255833769010080666; - bpsToRay[6698] = 1000000016257732843273218361; - bpsToRay[6699] = 1000000016259631803809122826; - bpsToRay[6700] = 1000000016261530650631414500; - bpsToRay[6701] = 1000000016263429383753711370; - bpsToRay[6702] = 1000000016265328003189628979; - bpsToRay[6703] = 1000000016267226508952780424; - bpsToRay[6704] = 1000000016269124901056776358; - bpsToRay[6705] = 1000000016271023179515224989; - bpsToRay[6706] = 1000000016272921344341732080; - bpsToRay[6707] = 1000000016274819395549900951; - bpsToRay[6708] = 1000000016276717333153332483; - bpsToRay[6709] = 1000000016278615157165625110; - bpsToRay[6710] = 1000000016280512867600374827; - bpsToRay[6711] = 1000000016282410464471175189; - bpsToRay[6712] = 1000000016284307947791617308; - bpsToRay[6713] = 1000000016286205317575289861; - bpsToRay[6714] = 1000000016288102573835779079; - bpsToRay[6715] = 1000000016289999716586668760; - bpsToRay[6716] = 1000000016291896745841540263; - bpsToRay[6717] = 1000000016293793661613972507; - bpsToRay[6718] = 1000000016295690463917541979; - bpsToRay[6719] = 1000000016297587152765822726; - bpsToRay[6720] = 1000000016299483728172386359; - bpsToRay[6721] = 1000000016301380190150802056; - bpsToRay[6722] = 1000000016303276538714636561; - bpsToRay[6723] = 1000000016305172773877454184; - bpsToRay[6724] = 1000000016307068895652816797; - bpsToRay[6725] = 1000000016308964904054283846; - bpsToRay[6726] = 1000000016310860799095412343; - bpsToRay[6727] = 1000000016312756580789756865; - bpsToRay[6728] = 1000000016314652249150869561; - bpsToRay[6729] = 1000000016316547804192300151; - bpsToRay[6730] = 1000000016318443245927595921; - bpsToRay[6731] = 1000000016320338574370301732; - bpsToRay[6732] = 1000000016322233789533960012; - bpsToRay[6733] = 1000000016324128891432110768; - bpsToRay[6734] = 1000000016326023880078291569; - bpsToRay[6735] = 1000000016327918755486037569; - bpsToRay[6736] = 1000000016329813517668881487; - bpsToRay[6737] = 1000000016331708166640353619; - bpsToRay[6738] = 1000000016333602702413981835; - bpsToRay[6739] = 1000000016335497125003291584; - bpsToRay[6740] = 1000000016337391434421805887; - bpsToRay[6741] = 1000000016339285630683045343; - bpsToRay[6742] = 1000000016341179713800528128; - bpsToRay[6743] = 1000000016343073683787769996; - bpsToRay[6744] = 1000000016344967540658284281; - bpsToRay[6745] = 1000000016346861284425581891; - bpsToRay[6746] = 1000000016348754915103171319; - bpsToRay[6747] = 1000000016350648432704558634; - bpsToRay[6748] = 1000000016352541837243247489; - bpsToRay[6749] = 1000000016354435128732739115; - bpsToRay[6750] = 1000000016356328307186532328; - bpsToRay[6751] = 1000000016358221372618123524; - bpsToRay[6752] = 1000000016360114325041006682; - bpsToRay[6753] = 1000000016362007164468673366; - bpsToRay[6754] = 1000000016363899890914612724; - bpsToRay[6755] = 1000000016365792504392311486; - bpsToRay[6756] = 1000000016367685004915253971; - bpsToRay[6757] = 1000000016369577392496922081; - bpsToRay[6758] = 1000000016371469667150795306; - bpsToRay[6759] = 1000000016373361828890350723; - bpsToRay[6760] = 1000000016375253877729062995; - bpsToRay[6761] = 1000000016377145813680404375; - bpsToRay[6762] = 1000000016379037636757844703; - bpsToRay[6763] = 1000000016380929346974851411; - bpsToRay[6764] = 1000000016382820944344889517; - bpsToRay[6765] = 1000000016384712428881421632; - bpsToRay[6766] = 1000000016386603800597907959; - bpsToRay[6767] = 1000000016388495059507806289; - bpsToRay[6768] = 1000000016390386205624572010; - bpsToRay[6769] = 1000000016392277238961658097; - bpsToRay[6770] = 1000000016394168159532515122; - bpsToRay[6771] = 1000000016396058967350591252; - bpsToRay[6772] = 1000000016397949662429332245; - bpsToRay[6773] = 1000000016399840244782181456; - bpsToRay[6774] = 1000000016401730714422579836; - bpsToRay[6775] = 1000000016403621071363965932; - bpsToRay[6776] = 1000000016405511315619775885; - bpsToRay[6777] = 1000000016407401447203443437; - bpsToRay[6778] = 1000000016409291466128399927; - bpsToRay[6779] = 1000000016411181372408074291; - bpsToRay[6780] = 1000000016413071166055893066; - bpsToRay[6781] = 1000000016414960847085280386; - bpsToRay[6782] = 1000000016416850415509657988; - bpsToRay[6783] = 1000000016418739871342445209; - bpsToRay[6784] = 1000000016420629214597058985; - bpsToRay[6785] = 1000000016422518445286913858; - bpsToRay[6786] = 1000000016424407563425421969; - bpsToRay[6787] = 1000000016426296569025993065; - bpsToRay[6788] = 1000000016428185462102034492; - bpsToRay[6789] = 1000000016430074242666951206; - bpsToRay[6790] = 1000000016431962910734145763; - bpsToRay[6791] = 1000000016433851466317018328; - bpsToRay[6792] = 1000000016435739909428966668; - bpsToRay[6793] = 1000000016437628240083386160; - bpsToRay[6794] = 1000000016439516458293669787; - bpsToRay[6795] = 1000000016441404564073208138; - bpsToRay[6796] = 1000000016443292557435389412; - bpsToRay[6797] = 1000000016445180438393599417; - bpsToRay[6798] = 1000000016447068206961221569; - bpsToRay[6799] = 1000000016448955863151636894; - bpsToRay[6800] = 1000000016450843406978224029; - bpsToRay[6801] = 1000000016452730838454359222; - bpsToRay[6802] = 1000000016454618157593416334; - bpsToRay[6803] = 1000000016456505364408766833; - bpsToRay[6804] = 1000000016458392458913779807; - bpsToRay[6805] = 1000000016460279441121821953; - bpsToRay[6806] = 1000000016462166311046257581; - bpsToRay[6807] = 1000000016464053068700448618; - bpsToRay[6808] = 1000000016465939714097754606; - bpsToRay[6809] = 1000000016467826247251532699; - bpsToRay[6810] = 1000000016469712668175137672; - bpsToRay[6811] = 1000000016471598976881921914; - bpsToRay[6812] = 1000000016473485173385235432; - bpsToRay[6813] = 1000000016475371257698425850; - bpsToRay[6814] = 1000000016477257229834838411; - bpsToRay[6815] = 1000000016479143089807815977; - bpsToRay[6816] = 1000000016481028837630699030; - bpsToRay[6817] = 1000000016482914473316825670; - bpsToRay[6818] = 1000000016484799996879531621; - bpsToRay[6819] = 1000000016486685408332150226; - bpsToRay[6820] = 1000000016488570707688012450; - bpsToRay[6821] = 1000000016490455894960446883; - bpsToRay[6822] = 1000000016492340970162779731; - bpsToRay[6823] = 1000000016494225933308334832; - bpsToRay[6824] = 1000000016496110784410433643; - bpsToRay[6825] = 1000000016497995523482395247; - bpsToRay[6826] = 1000000016499880150537536351; - bpsToRay[6827] = 1000000016501764665589171290; - bpsToRay[6828] = 1000000016503649068650612025; - bpsToRay[6829] = 1000000016505533359735168140; - bpsToRay[6830] = 1000000016507417538856146852; - bpsToRay[6831] = 1000000016509301606026853003; - bpsToRay[6832] = 1000000016511185561260589063; - bpsToRay[6833] = 1000000016513069404570655134; - bpsToRay[6834] = 1000000016514953135970348945; - bpsToRay[6835] = 1000000016516836755472965855; - bpsToRay[6836] = 1000000016518720263091798857; - bpsToRay[6837] = 1000000016520603658840138572; - bpsToRay[6838] = 1000000016522486942731273255; - bpsToRay[6839] = 1000000016524370114778488794; - bpsToRay[6840] = 1000000016526253174995068707; - bpsToRay[6841] = 1000000016528136123394294149; - bpsToRay[6842] = 1000000016530018959989443907; - bpsToRay[6843] = 1000000016531901684793794404; - bpsToRay[6844] = 1000000016533784297820619698; - bpsToRay[6845] = 1000000016535666799083191483; - bpsToRay[6846] = 1000000016537549188594779088; - bpsToRay[6847] = 1000000016539431466368649483; - bpsToRay[6848] = 1000000016541313632418067271; - bpsToRay[6849] = 1000000016543195686756294694; - bpsToRay[6850] = 1000000016545077629396591637; - bpsToRay[6851] = 1000000016546959460352215619; - bpsToRay[6852] = 1000000016548841179636421799; - bpsToRay[6853] = 1000000016550722787262462982; - bpsToRay[6854] = 1000000016552604283243589608; - bpsToRay[6855] = 1000000016554485667593049761; - bpsToRay[6856] = 1000000016556366940324089165; - bpsToRay[6857] = 1000000016558248101449951192; - bpsToRay[6858] = 1000000016560129150983876850; - bpsToRay[6859] = 1000000016562010088939104796; - bpsToRay[6860] = 1000000016563890915328871330; - bpsToRay[6861] = 1000000016565771630166410395; - bpsToRay[6862] = 1000000016567652233464953581; - bpsToRay[6863] = 1000000016569532725237730125; - bpsToRay[6864] = 1000000016571413105497966909; - bpsToRay[6865] = 1000000016573293374258888461; - bpsToRay[6866] = 1000000016575173531533716960; - bpsToRay[6867] = 1000000016577053577335672229; - bpsToRay[6868] = 1000000016578933511677971744; - bpsToRay[6869] = 1000000016580813334573830628; - bpsToRay[6870] = 1000000016582693046036461653; - bpsToRay[6871] = 1000000016584572646079075244; - bpsToRay[6872] = 1000000016586452134714879475; - bpsToRay[6873] = 1000000016588331511957080072; - bpsToRay[6874] = 1000000016590210777818880415; - bpsToRay[6875] = 1000000016592089932313481533; - bpsToRay[6876] = 1000000016593968975454082111; - bpsToRay[6877] = 1000000016595847907253878486; - bpsToRay[6878] = 1000000016597726727726064651; - bpsToRay[6879] = 1000000016599605436883832255; - bpsToRay[6880] = 1000000016601484034740370597; - bpsToRay[6881] = 1000000016603362521308866639; - bpsToRay[6882] = 1000000016605240896602504994; - bpsToRay[6883] = 1000000016607119160634467936; - bpsToRay[6884] = 1000000016608997313417935393; - bpsToRay[6885] = 1000000016610875354966084955; - bpsToRay[6886] = 1000000016612753285292091867; - bpsToRay[6887] = 1000000016614631104409129037; - bpsToRay[6888] = 1000000016616508812330367032; - bpsToRay[6889] = 1000000016618386409068974076; - bpsToRay[6890] = 1000000016620263894638116058; - bpsToRay[6891] = 1000000016622141269050956527; - bpsToRay[6892] = 1000000016624018532320656694; - bpsToRay[6893] = 1000000016625895684460375433; - bpsToRay[6894] = 1000000016627772725483269281; - bpsToRay[6895] = 1000000016629649655402492440; - bpsToRay[6896] = 1000000016631526474231196774; - bpsToRay[6897] = 1000000016633403181982531813; - bpsToRay[6898] = 1000000016635279778669644752; - bpsToRay[6899] = 1000000016637156264305680454; - bpsToRay[6900] = 1000000016639032638903781446; - bpsToRay[6901] = 1000000016640908902477087924; - bpsToRay[6902] = 1000000016642785055038737748; - bpsToRay[6903] = 1000000016644661096601866452; - bpsToRay[6904] = 1000000016646537027179607234; - bpsToRay[6905] = 1000000016648412846785090963; - bpsToRay[6906] = 1000000016650288555431446177; - bpsToRay[6907] = 1000000016652164153131799087; - bpsToRay[6908] = 1000000016654039639899273571; - bpsToRay[6909] = 1000000016655915015746991182; - bpsToRay[6910] = 1000000016657790280688071142; - bpsToRay[6911] = 1000000016659665434735630349; - bpsToRay[6912] = 1000000016661540477902783371; - bpsToRay[6913] = 1000000016663415410202642451; - bpsToRay[6914] = 1000000016665290231648317506; - bpsToRay[6915] = 1000000016667164942252916129; - bpsToRay[6916] = 1000000016669039542029543587; - bpsToRay[6917] = 1000000016670914030991302822; - bpsToRay[6918] = 1000000016672788409151294456; - bpsToRay[6919] = 1000000016674662676522616783; - bpsToRay[6920] = 1000000016676536833118365780; - bpsToRay[6921] = 1000000016678410878951635096; - bpsToRay[6922] = 1000000016680284814035516064; - bpsToRay[6923] = 1000000016682158638383097695; - bpsToRay[6924] = 1000000016684032352007466677; - bpsToRay[6925] = 1000000016685905954921707380; - bpsToRay[6926] = 1000000016687779447138901857; - bpsToRay[6927] = 1000000016689652828672129838; - bpsToRay[6928] = 1000000016691526099534468738; - bpsToRay[6929] = 1000000016693399259738993654; - bpsToRay[6930] = 1000000016695272309298777366; - bpsToRay[6931] = 1000000016697145248226890337; - bpsToRay[6932] = 1000000016699018076536400715; - bpsToRay[6933] = 1000000016700890794240374330; - bpsToRay[6934] = 1000000016702763401351874702; - bpsToRay[6935] = 1000000016704635897883963033; - bpsToRay[6936] = 1000000016706508283849698211; - bpsToRay[6937] = 1000000016708380559262136815; - bpsToRay[6938] = 1000000016710252724134333106; - bpsToRay[6939] = 1000000016712124778479339037; - bpsToRay[6940] = 1000000016713996722310204248; - bpsToRay[6941] = 1000000016715868555639976067; - bpsToRay[6942] = 1000000016717740278481699513; - bpsToRay[6943] = 1000000016719611890848417297; - bpsToRay[6944] = 1000000016721483392753169815; - bpsToRay[6945] = 1000000016723354784208995160; - bpsToRay[6946] = 1000000016725226065228929112; - bpsToRay[6947] = 1000000016727097235826005150; - bpsToRay[6948] = 1000000016728968296013254437; - bpsToRay[6949] = 1000000016730839245803705837; - bpsToRay[6950] = 1000000016732710085210385903; - bpsToRay[6951] = 1000000016734580814246318886; - bpsToRay[6952] = 1000000016736451432924526729; - bpsToRay[6953] = 1000000016738321941258029073; - bpsToRay[6954] = 1000000016740192339259843253; - bpsToRay[6955] = 1000000016742062626942984304; - bpsToRay[6956] = 1000000016743932804320464954; - bpsToRay[6957] = 1000000016745802871405295631; - bpsToRay[6958] = 1000000016747672828210484461; - bpsToRay[6959] = 1000000016749542674749037270; - bpsToRay[6960] = 1000000016751412411033957580; - bpsToRay[6961] = 1000000016753282037078246617; - bpsToRay[6962] = 1000000016755151552894903305; - bpsToRay[6963] = 1000000016757020958496924269; - bpsToRay[6964] = 1000000016758890253897303837; - bpsToRay[6965] = 1000000016760759439109034038; - bpsToRay[6966] = 1000000016762628514145104603; - bpsToRay[6967] = 1000000016764497479018502969; - bpsToRay[6968] = 1000000016766366333742214272; - bpsToRay[6969] = 1000000016768235078329221357; - bpsToRay[6970] = 1000000016770103712792504771; - bpsToRay[6971] = 1000000016771972237145042768; - bpsToRay[6972] = 1000000016773840651399811306; - bpsToRay[6973] = 1000000016775708955569784050; - bpsToRay[6974] = 1000000016777577149667932373; - bpsToRay[6975] = 1000000016779445233707225354; - bpsToRay[6976] = 1000000016781313207700629783; - bpsToRay[6977] = 1000000016783181071661110154; - bpsToRay[6978] = 1000000016785048825601628673; - bpsToRay[6979] = 1000000016786916469535145257; - bpsToRay[6980] = 1000000016788784003474617530; - bpsToRay[6981] = 1000000016790651427433000828; - bpsToRay[6982] = 1000000016792518741423248199; - bpsToRay[6983] = 1000000016794385945458310402; - bpsToRay[6984] = 1000000016796253039551135908; - bpsToRay[6985] = 1000000016798120023714670903; - bpsToRay[6986] = 1000000016799986897961859283; - bpsToRay[6987] = 1000000016801853662305642661; - bpsToRay[6988] = 1000000016803720316758960363; - bpsToRay[6989] = 1000000016805586861334749431; - bpsToRay[6990] = 1000000016807453296045944621; - bpsToRay[6991] = 1000000016809319620905478407; - bpsToRay[6992] = 1000000016811185835926280979; - bpsToRay[6993] = 1000000016813051941121280243; - bpsToRay[6994] = 1000000016814917936503401823; - bpsToRay[6995] = 1000000016816783822085569065; - bpsToRay[6996] = 1000000016818649597880703028; - bpsToRay[6997] = 1000000016820515263901722494; - bpsToRay[6998] = 1000000016822380820161543963; - bpsToRay[6999] = 1000000016824246266673081659; - bpsToRay[7000] = 1000000016826111603449247521; - bpsToRay[7001] = 1000000016827976830502951216; - bpsToRay[7002] = 1000000016829841947847100128; - bpsToRay[7003] = 1000000016831706955494599366; - bpsToRay[7004] = 1000000016833571853458351761; - bpsToRay[7005] = 1000000016835436641751257869; - bpsToRay[7006] = 1000000016837301320386215969; - bpsToRay[7007] = 1000000016839165889376122066; - bpsToRay[7008] = 1000000016841030348733869887; - bpsToRay[7009] = 1000000016842894698472350889; - bpsToRay[7010] = 1000000016844758938604454252; - bpsToRay[7011] = 1000000016846623069143066886; - bpsToRay[7012] = 1000000016848487090101073424; - bpsToRay[7013] = 1000000016850351001491356231; - bpsToRay[7014] = 1000000016852214803326795400; - bpsToRay[7015] = 1000000016854078495620268751; - bpsToRay[7016] = 1000000016855942078384651834; - bpsToRay[7017] = 1000000016857805551632817929; - bpsToRay[7018] = 1000000016859668915377638048; - bpsToRay[7019] = 1000000016861532169631980933; - bpsToRay[7020] = 1000000016863395314408713059; - bpsToRay[7021] = 1000000016865258349720698630; - bpsToRay[7022] = 1000000016867121275580799585; - bpsToRay[7023] = 1000000016868984092001875597; - bpsToRay[7024] = 1000000016870846798996784070; - bpsToRay[7025] = 1000000016872709396578380147; - bpsToRay[7026] = 1000000016874571884759516701; - bpsToRay[7027] = 1000000016876434263553044341; - bpsToRay[7028] = 1000000016878296532971811416; - bpsToRay[7029] = 1000000016880158693028664007; - bpsToRay[7030] = 1000000016882020743736445934; - bpsToRay[7031] = 1000000016883882685107998752; - bpsToRay[7032] = 1000000016885744517156161760; - bpsToRay[7033] = 1000000016887606239893771989; - bpsToRay[7034] = 1000000016889467853333664213; - bpsToRay[7035] = 1000000016891329357488670944; - bpsToRay[7036] = 1000000016893190752371622434; - bpsToRay[7037] = 1000000016895052037995346676; - bpsToRay[7038] = 1000000016896913214372669406; - bpsToRay[7039] = 1000000016898774281516414100; - bpsToRay[7040] = 1000000016900635239439401976; - bpsToRay[7041] = 1000000016902496088154451995; - bpsToRay[7042] = 1000000016904356827674380861; - bpsToRay[7043] = 1000000016906217458012003025; - bpsToRay[7044] = 1000000016908077979180130677; - bpsToRay[7045] = 1000000016909938391191573757; - bpsToRay[7046] = 1000000016911798694059139947; - bpsToRay[7047] = 1000000016913658887795634678; - bpsToRay[7048] = 1000000016915518972413861124; - bpsToRay[7049] = 1000000016917378947926620208; - bpsToRay[7050] = 1000000016919238814346710603; - bpsToRay[7051] = 1000000016921098571686928723; - bpsToRay[7052] = 1000000016922958219960068739; - bpsToRay[7053] = 1000000016924817759178922565; - bpsToRay[7054] = 1000000016926677189356279869; - bpsToRay[7055] = 1000000016928536510504928066; - bpsToRay[7056] = 1000000016930395722637652322; - bpsToRay[7057] = 1000000016932254825767235558; - bpsToRay[7058] = 1000000016934113819906458442; - bpsToRay[7059] = 1000000016935972705068099396; - bpsToRay[7060] = 1000000016937831481264934596; - bpsToRay[7061] = 1000000016939690148509737971; - bpsToRay[7062] = 1000000016941548706815281202; - bpsToRay[7063] = 1000000016943407156194333727; - bpsToRay[7064] = 1000000016945265496659662739; - bpsToRay[7065] = 1000000016947123728224033182; - bpsToRay[7066] = 1000000016948981850900207763; - bpsToRay[7067] = 1000000016950839864700946939; - bpsToRay[7068] = 1000000016952697769639008929; - bpsToRay[7069] = 1000000016954555565727149706; - bpsToRay[7070] = 1000000016956413252978123003; - bpsToRay[7071] = 1000000016958270831404680312; - bpsToRay[7072] = 1000000016960128301019570884; - bpsToRay[7073] = 1000000016961985661835541727; - bpsToRay[7074] = 1000000016963842913865337612; - bpsToRay[7075] = 1000000016965700057121701072; - bpsToRay[7076] = 1000000016967557091617372397; - bpsToRay[7077] = 1000000016969414017365089642; - bpsToRay[7078] = 1000000016971270834377588623; - bpsToRay[7079] = 1000000016973127542667602920; - bpsToRay[7080] = 1000000016974984142247863875; - bpsToRay[7081] = 1000000016976840633131100595; - bpsToRay[7082] = 1000000016978697015330039950; - bpsToRay[7083] = 1000000016980553288857406577; - bpsToRay[7084] = 1000000016982409453725922877; - bpsToRay[7085] = 1000000016984265509948309016; - bpsToRay[7086] = 1000000016986121457537282929; - bpsToRay[7087] = 1000000016987977296505560317; - bpsToRay[7088] = 1000000016989833026865854647; - bpsToRay[7089] = 1000000016991688648630877157; - bpsToRay[7090] = 1000000016993544161813336850; - bpsToRay[7091] = 1000000016995399566425940502; - bpsToRay[7092] = 1000000016997254862481392657; - bpsToRay[7093] = 1000000016999110049992395626; - bpsToRay[7094] = 1000000017000965128971649496; - bpsToRay[7095] = 1000000017002820099431852122; - bpsToRay[7096] = 1000000017004674961385699132; - bpsToRay[7097] = 1000000017006529714845883924; - bpsToRay[7098] = 1000000017008384359825097672; - bpsToRay[7099] = 1000000017010238896336029322; - bpsToRay[7100] = 1000000017012093324391365593; - bpsToRay[7101] = 1000000017013947644003790979; - bpsToRay[7102] = 1000000017015801855185987748; - bpsToRay[7103] = 1000000017017655957950635945; - bpsToRay[7104] = 1000000017019509952310413390; - bpsToRay[7105] = 1000000017021363838277995678; - bpsToRay[7106] = 1000000017023217615866056185; - bpsToRay[7107] = 1000000017025071285087266058; - bpsToRay[7108] = 1000000017026924845954294229; - bpsToRay[7109] = 1000000017028778298479807404; - bpsToRay[7110] = 1000000017030631642676470068; - bpsToRay[7111] = 1000000017032484878556944490; - bpsToRay[7112] = 1000000017034338006133890711; - bpsToRay[7113] = 1000000017036191025419966563; - bpsToRay[7114] = 1000000017038043936427827649; - bpsToRay[7115] = 1000000017039896739170127359; - bpsToRay[7116] = 1000000017041749433659516866; - bpsToRay[7117] = 1000000017043602019908645121; - bpsToRay[7118] = 1000000017045454497930158862; - bpsToRay[7119] = 1000000017047306867736702611; - bpsToRay[7120] = 1000000017049159129340918671; - bpsToRay[7121] = 1000000017051011282755447132; - bpsToRay[7122] = 1000000017052863327992925869; - bpsToRay[7123] = 1000000017054715265065990543; - bpsToRay[7124] = 1000000017056567093987274599; - bpsToRay[7125] = 1000000017058418814769409273; - bpsToRay[7126] = 1000000017060270427425023583; - bpsToRay[7127] = 1000000017062121931966744339; - bpsToRay[7128] = 1000000017063973328407196139; - bpsToRay[7129] = 1000000017065824616759001367; - bpsToRay[7130] = 1000000017067675797034780199; - bpsToRay[7131] = 1000000017069526869247150599; - bpsToRay[7132] = 1000000017071377833408728323; - bpsToRay[7133] = 1000000017073228689532126918; - bpsToRay[7134] = 1000000017075079437629957721; - bpsToRay[7135] = 1000000017076930077714829862; - bpsToRay[7136] = 1000000017078780609799350263; - bpsToRay[7137] = 1000000017080631033896123639; - bpsToRay[7138] = 1000000017082481350017752499; - bpsToRay[7139] = 1000000017084331558176837145; - bpsToRay[7140] = 1000000017086181658385975674; - bpsToRay[7141] = 1000000017088031650657763979; - bpsToRay[7142] = 1000000017089881535004795747; - bpsToRay[7143] = 1000000017091731311439662461; - bpsToRay[7144] = 1000000017093580979974953404; - bpsToRay[7145] = 1000000017095430540623255651; - bpsToRay[7146] = 1000000017097279993397154077; - bpsToRay[7147] = 1000000017099129338309231355; - bpsToRay[7148] = 1000000017100978575372067958; - bpsToRay[7149] = 1000000017102827704598242158; - bpsToRay[7150] = 1000000017104676726000330021; - bpsToRay[7151] = 1000000017106525639590905422; - bpsToRay[7152] = 1000000017108374445382540031; - bpsToRay[7153] = 1000000017110223143387803320; - bpsToRay[7154] = 1000000017112071733619262563; - bpsToRay[7155] = 1000000017113920216089482839; - bpsToRay[7156] = 1000000017115768590811027024; - bpsToRay[7157] = 1000000017117616857796455803; - bpsToRay[7158] = 1000000017119465017058327660; - bpsToRay[7159] = 1000000017121313068609198888; - bpsToRay[7160] = 1000000017123161012461623580; - bpsToRay[7161] = 1000000017125008848628153638; - bpsToRay[7162] = 1000000017126856577121338769; - bpsToRay[7163] = 1000000017128704197953726483; - bpsToRay[7164] = 1000000017130551711137862102; - bpsToRay[7165] = 1000000017132399116686288751; - bpsToRay[7166] = 1000000017134246414611547366; - bpsToRay[7167] = 1000000017136093604926176691; - bpsToRay[7168] = 1000000017137940687642713275; - bpsToRay[7169] = 1000000017139787662773691483; - bpsToRay[7170] = 1000000017141634530331643482; - bpsToRay[7171] = 1000000017143481290329099258; - bpsToRay[7172] = 1000000017145327942778586600; - bpsToRay[7173] = 1000000017147174487692631114; - bpsToRay[7174] = 1000000017149020925083756215; - bpsToRay[7175] = 1000000017150867254964483131; - bpsToRay[7176] = 1000000017152713477347330904; - bpsToRay[7177] = 1000000017154559592244816389; - bpsToRay[7178] = 1000000017156405599669454253; - bpsToRay[7179] = 1000000017158251499633756981; - bpsToRay[7180] = 1000000017160097292150234871; - bpsToRay[7181] = 1000000017161942977231396035; - bpsToRay[7182] = 1000000017163788554889746405; - bpsToRay[7183] = 1000000017165634025137789725; - bpsToRay[7184] = 1000000017167479387988027559; - bpsToRay[7185] = 1000000017169324643452959289; - bpsToRay[7186] = 1000000017171169791545082111; - bpsToRay[7187] = 1000000017173014832276891044; - bpsToRay[7188] = 1000000017174859765660878925; - bpsToRay[7189] = 1000000017176704591709536409; - bpsToRay[7190] = 1000000017178549310435351971; - bpsToRay[7191] = 1000000017180393921850811909; - bpsToRay[7192] = 1000000017182238425968400340; - bpsToRay[7193] = 1000000017184082822800599204; - bpsToRay[7194] = 1000000017185927112359888261; - bpsToRay[7195] = 1000000017187771294658745097; - bpsToRay[7196] = 1000000017189615369709645117; - bpsToRay[7197] = 1000000017191459337525061551; - bpsToRay[7198] = 1000000017193303198117465456; - bpsToRay[7199] = 1000000017195146951499325710; - bpsToRay[7200] = 1000000017196990597683109018; - bpsToRay[7201] = 1000000017198834136681279909; - bpsToRay[7202] = 1000000017200677568506300742; - bpsToRay[7203] = 1000000017202520893170631697; - bpsToRay[7204] = 1000000017204364110686730786; - bpsToRay[7205] = 1000000017206207221067053846; - bpsToRay[7206] = 1000000017208050224324054541; - bpsToRay[7207] = 1000000017209893120470184369; - bpsToRay[7208] = 1000000017211735909517892653; - bpsToRay[7209] = 1000000017213578591479626545; - bpsToRay[7210] = 1000000017215421166367831029; - bpsToRay[7211] = 1000000017217263634194948920; - bpsToRay[7212] = 1000000017219105994973420864; - bpsToRay[7213] = 1000000017220948248715685336; - bpsToRay[7214] = 1000000017222790395434178647; - bpsToRay[7215] = 1000000017224632435141334939; - bpsToRay[7216] = 1000000017226474367849586187; - bpsToRay[7217] = 1000000017228316193571362200; - bpsToRay[7218] = 1000000017230157912319090621; - bpsToRay[7219] = 1000000017231999524105196929; - bpsToRay[7220] = 1000000017233841028942104436; - bpsToRay[7221] = 1000000017235682426842234291; - bpsToRay[7222] = 1000000017237523717818005480; - bpsToRay[7223] = 1000000017239364901881834825; - bpsToRay[7224] = 1000000017241205979046136983; - bpsToRay[7225] = 1000000017243046949323324453; - bpsToRay[7226] = 1000000017244887812725807569; - bpsToRay[7227] = 1000000017246728569265994504; - bpsToRay[7228] = 1000000017248569218956291274; - bpsToRay[7229] = 1000000017250409761809101729; - bpsToRay[7230] = 1000000017252250197836827562; - bpsToRay[7231] = 1000000017254090527051868307; - bpsToRay[7232] = 1000000017255930749466621341; - bpsToRay[7233] = 1000000017257770865093481878; - bpsToRay[7234] = 1000000017259610873944842979; - bpsToRay[7235] = 1000000017261450776033095544; - bpsToRay[7236] = 1000000017263290571370628319; - bpsToRay[7237] = 1000000017265130259969827893; - bpsToRay[7238] = 1000000017266969841843078698; - bpsToRay[7239] = 1000000017268809317002763012; - bpsToRay[7240] = 1000000017270648685461260960; - bpsToRay[7241] = 1000000017272487947230950506; - bpsToRay[7242] = 1000000017274327102324207470; - bpsToRay[7243] = 1000000017276166150753405511; - bpsToRay[7244] = 1000000017278005092530916139; - bpsToRay[7245] = 1000000017279843927669108709; - bpsToRay[7246] = 1000000017281682656180350428; - bpsToRay[7247] = 1000000017283521278077006348; - bpsToRay[7248] = 1000000017285359793371439374; - bpsToRay[7249] = 1000000017287198202076010256; - bpsToRay[7250] = 1000000017289036504203077600; - bpsToRay[7251] = 1000000017290874699764997857; - bpsToRay[7252] = 1000000017292712788774125333; - bpsToRay[7253] = 1000000017294550771242812185; - bpsToRay[7254] = 1000000017296388647183408421; - bpsToRay[7255] = 1000000017298226416608261903; - bpsToRay[7256] = 1000000017300064079529718345; - bpsToRay[7257] = 1000000017301901635960121318; - bpsToRay[7258] = 1000000017303739085911812243; - bpsToRay[7259] = 1000000017305576429397130398; - bpsToRay[7260] = 1000000017307413666428412915; - bpsToRay[7261] = 1000000017309250797017994782; - bpsToRay[7262] = 1000000017311087821178208846; - bpsToRay[7263] = 1000000017312924738921385806; - bpsToRay[7264] = 1000000017314761550259854221; - bpsToRay[7265] = 1000000017316598255205940510; - bpsToRay[7266] = 1000000017318434853771968943; - bpsToRay[7267] = 1000000017320271345970261657; - bpsToRay[7268] = 1000000017322107731813138642; - bpsToRay[7269] = 1000000017323944011312917751; - bpsToRay[7270] = 1000000017325780184481914696; - bpsToRay[7271] = 1000000017327616251332443050; - bpsToRay[7272] = 1000000017329452211876814248; - bpsToRay[7273] = 1000000017331288066127337584; - bpsToRay[7274] = 1000000017333123814096320217; - bpsToRay[7275] = 1000000017334959455796067168; - bpsToRay[7276] = 1000000017336794991238881320; - bpsToRay[7277] = 1000000017338630420437063420; - bpsToRay[7278] = 1000000017340465743402912081; - bpsToRay[7279] = 1000000017342300960148723777; - bpsToRay[7280] = 1000000017344136070686792852; - bpsToRay[7281] = 1000000017345971075029411511; - bpsToRay[7282] = 1000000017347805973188869827; - bpsToRay[7283] = 1000000017349640765177455741; - bpsToRay[7284] = 1000000017351475451007455060; - bpsToRay[7285] = 1000000017353310030691151455; - bpsToRay[7286] = 1000000017355144504240826473; - bpsToRay[7287] = 1000000017356978871668759522; - bpsToRay[7288] = 1000000017358813132987227884; - bpsToRay[7289] = 1000000017360647288208506708; - bpsToRay[7290] = 1000000017362481337344869013; - bpsToRay[7291] = 1000000017364315280408585691; - bpsToRay[7292] = 1000000017366149117411925502; - bpsToRay[7293] = 1000000017367982848367155079; - bpsToRay[7294] = 1000000017369816473286538927; - bpsToRay[7295] = 1000000017371649992182339426; - bpsToRay[7296] = 1000000017373483405066816824; - bpsToRay[7297] = 1000000017375316711952229244; - bpsToRay[7298] = 1000000017377149912850832687; - bpsToRay[7299] = 1000000017378983007774881025; - bpsToRay[7300] = 1000000017380815996736626004; - bpsToRay[7301] = 1000000017382648879748317248; - bpsToRay[7302] = 1000000017384481656822202255; - bpsToRay[7303] = 1000000017386314327970526403; - bpsToRay[7304] = 1000000017388146893205532943; - bpsToRay[7305] = 1000000017389979352539463003; - bpsToRay[7306] = 1000000017391811705984555594; - bpsToRay[7307] = 1000000017393643953553047601; - bpsToRay[7308] = 1000000017395476095257173788; - bpsToRay[7309] = 1000000017397308131109166801; - bpsToRay[7310] = 1000000017399140061121257164; - bpsToRay[7311] = 1000000017400971885305673282; - bpsToRay[7312] = 1000000017402803603674641440; - bpsToRay[7313] = 1000000017404635216240385805; - bpsToRay[7314] = 1000000017406466723015128428; - bpsToRay[7315] = 1000000017408298124011089238; - bpsToRay[7316] = 1000000017410129419240486051; - bpsToRay[7317] = 1000000017411960608715534563; - bpsToRay[7318] = 1000000017413791692448448355; - bpsToRay[7319] = 1000000017415622670451438895; - bpsToRay[7320] = 1000000017417453542736715530; - bpsToRay[7321] = 1000000017419284309316485497; - bpsToRay[7322] = 1000000017421114970202953919; - bpsToRay[7323] = 1000000017422945525408323801; - bpsToRay[7324] = 1000000017424775974944796039; - bpsToRay[7325] = 1000000017426606318824569415; - bpsToRay[7326] = 1000000017428436557059840598; - bpsToRay[7327] = 1000000017430266689662804144; - bpsToRay[7328] = 1000000017432096716645652500; - bpsToRay[7329] = 1000000017433926638020576003; - bpsToRay[7330] = 1000000017435756453799762877; - bpsToRay[7331] = 1000000017437586163995399235; - bpsToRay[7332] = 1000000017439415768619669087; - bpsToRay[7333] = 1000000017441245267684754328; - bpsToRay[7334] = 1000000017443074661202834746; - bpsToRay[7335] = 1000000017444903949186088022; - bpsToRay[7336] = 1000000017446733131646689731; - bpsToRay[7337] = 1000000017448562208596813336; - bpsToRay[7338] = 1000000017450391180048630201; - bpsToRay[7339] = 1000000017452220046014309577; - bpsToRay[7340] = 1000000017454048806506018613; - bpsToRay[7341] = 1000000017455877461535922354; - bpsToRay[7342] = 1000000017457706011116183737; - bpsToRay[7343] = 1000000017459534455258963600; - bpsToRay[7344] = 1000000017461362793976420670; - bpsToRay[7345] = 1000000017463191027280711580; - bpsToRay[7346] = 1000000017465019155183990853; - bpsToRay[7347] = 1000000017466847177698410915; - bpsToRay[7348] = 1000000017468675094836122086; - bpsToRay[7349] = 1000000017470502906609272589; - bpsToRay[7350] = 1000000017472330613030008543; - bpsToRay[7351] = 1000000017474158214110473970; - bpsToRay[7352] = 1000000017475985709862810789; - bpsToRay[7353] = 1000000017477813100299158823; - bpsToRay[7354] = 1000000017479640385431655794; - bpsToRay[7355] = 1000000017481467565272437328; - bpsToRay[7356] = 1000000017483294639833636950; - bpsToRay[7357] = 1000000017485121609127386092; - bpsToRay[7358] = 1000000017486948473165814085; - bpsToRay[7359] = 1000000017488775231961048167; - bpsToRay[7360] = 1000000017490601885525213478; - bpsToRay[7361] = 1000000017492428433870433064; - bpsToRay[7362] = 1000000017494254877008827878; - bpsToRay[7363] = 1000000017496081214952516772; - bpsToRay[7364] = 1000000017497907447713616513; - bpsToRay[7365] = 1000000017499733575304241768; - bpsToRay[7366] = 1000000017501559597736505115; - bpsToRay[7367] = 1000000017503385515022517037; - bpsToRay[7368] = 1000000017505211327174385925; - bpsToRay[7369] = 1000000017507037034204218081; - bpsToRay[7370] = 1000000017508862636124117716; - bpsToRay[7371] = 1000000017510688132946186946; - bpsToRay[7372] = 1000000017512513524682525802; - bpsToRay[7373] = 1000000017514338811345232225; - bpsToRay[7374] = 1000000017516163992946402063; - bpsToRay[7375] = 1000000017517989069498129080; - bpsToRay[7376] = 1000000017519814041012504950; - bpsToRay[7377] = 1000000017521638907501619258; - bpsToRay[7378] = 1000000017523463668977559505; - bpsToRay[7379] = 1000000017525288325452411102; - bpsToRay[7380] = 1000000017527112876938257378; - bpsToRay[7381] = 1000000017528937323447179572; - bpsToRay[7382] = 1000000017530761664991256840; - bpsToRay[7383] = 1000000017532585901582566253; - bpsToRay[7384] = 1000000017534410033233182798; - bpsToRay[7385] = 1000000017536234059955179379; - bpsToRay[7386] = 1000000017538057981760626814; - bpsToRay[7387] = 1000000017539881798661593840; - bpsToRay[7388] = 1000000017541705510670147114; - bpsToRay[7389] = 1000000017543529117798351206; - bpsToRay[7390] = 1000000017545352620058268609; - bpsToRay[7391] = 1000000017547176017461959733; - bpsToRay[7392] = 1000000017548999310021482909; - bpsToRay[7393] = 1000000017550822497748894386; - bpsToRay[7394] = 1000000017552645580656248336; - bpsToRay[7395] = 1000000017554468558755596849; - bpsToRay[7396] = 1000000017556291432058989941; - bpsToRay[7397] = 1000000017558114200578475546; - bpsToRay[7398] = 1000000017559936864326099522; - bpsToRay[7399] = 1000000017561759423313905650; - bpsToRay[7400] = 1000000017563581877553935633; - bpsToRay[7401] = 1000000017565404227058229101; - bpsToRay[7402] = 1000000017567226471838823606; - bpsToRay[7403] = 1000000017569048611907754624; - bpsToRay[7404] = 1000000017570870647277055559; - bpsToRay[7405] = 1000000017572692577958757738; - bpsToRay[7406] = 1000000017574514403964890419; - bpsToRay[7407] = 1000000017576336125307480780; - bpsToRay[7408] = 1000000017578157741998553932; - bpsToRay[7409] = 1000000017579979254050132911; - bpsToRay[7410] = 1000000017581800661474238681; - bpsToRay[7411] = 1000000017583621964282890136; - bpsToRay[7412] = 1000000017585443162488104098; - bpsToRay[7413] = 1000000017587264256101895320; - bpsToRay[7414] = 1000000017589085245136276485; - bpsToRay[7415] = 1000000017590906129603258203; - bpsToRay[7416] = 1000000017592726909514849021; - bpsToRay[7417] = 1000000017594547584883055411; - bpsToRay[7418] = 1000000017596368155719881784; - bpsToRay[7419] = 1000000017598188622037330478; - bpsToRay[7420] = 1000000017600008983847401766; - bpsToRay[7421] = 1000000017601829241162093854; - bpsToRay[7422] = 1000000017603649393993402882; - bpsToRay[7423] = 1000000017605469442353322925; - bpsToRay[7424] = 1000000017607289386253845993; - bpsToRay[7425] = 1000000017609109225706962029; - bpsToRay[7426] = 1000000017610928960724658915; - bpsToRay[7427] = 1000000017612748591318922467; - bpsToRay[7428] = 1000000017614568117501736438; - bpsToRay[7429] = 1000000017616387539285082519; - bpsToRay[7430] = 1000000017618206856680940339; - bpsToRay[7431] = 1000000017620026069701287465; - bpsToRay[7432] = 1000000017621845178358099399; - bpsToRay[7433] = 1000000017623664182663349590; - bpsToRay[7434] = 1000000017625483082629009418; - bpsToRay[7435] = 1000000017627301878267048209; - bpsToRay[7436] = 1000000017629120569589433226; - bpsToRay[7437] = 1000000017630939156608129676; - bpsToRay[7438] = 1000000017632757639335100704; - bpsToRay[7439] = 1000000017634576017782307401; - bpsToRay[7440] = 1000000017636394291961708797; - bpsToRay[7441] = 1000000017638212461885261865; - bpsToRay[7442] = 1000000017640030527564921525; - bpsToRay[7443] = 1000000017641848489012640637; - bpsToRay[7444] = 1000000017643666346240370005; - bpsToRay[7445] = 1000000017645484099260058384; - bpsToRay[7446] = 1000000017647301748083652465; - bpsToRay[7447] = 1000000017649119292723096891; - bpsToRay[7448] = 1000000017650936733190334250; - bpsToRay[7449] = 1000000017652754069497305076; - bpsToRay[7450] = 1000000017654571301655947851; - bpsToRay[7451] = 1000000017656388429678199002; - bpsToRay[7452] = 1000000017658205453575992908; - bpsToRay[7453] = 1000000017660022373361261892; - bpsToRay[7454] = 1000000017661839189045936232; - bpsToRay[7455] = 1000000017663655900641944150; - bpsToRay[7456] = 1000000017665472508161211819; - bpsToRay[7457] = 1000000017667289011615663365; - bpsToRay[7458] = 1000000017669105411017220864; - bpsToRay[7459] = 1000000017670921706377804340; - bpsToRay[7460] = 1000000017672737897709331773; - bpsToRay[7461] = 1000000017674553985023719095; - bpsToRay[7462] = 1000000017676369968332880187; - bpsToRay[7463] = 1000000017678185847648726887; - bpsToRay[7464] = 1000000017680001622983168986; - bpsToRay[7465] = 1000000017681817294348114228; - bpsToRay[7466] = 1000000017683632861755468312; - bpsToRay[7467] = 1000000017685448325217134893; - bpsToRay[7468] = 1000000017687263684745015581; - bpsToRay[7469] = 1000000017689078940351009940; - bpsToRay[7470] = 1000000017690894092047015496; - bpsToRay[7471] = 1000000017692709139844927726; - bpsToRay[7472] = 1000000017694524083756640068; - bpsToRay[7473] = 1000000017696338923794043916; - bpsToRay[7474] = 1000000017698153659969028624; - bpsToRay[7475] = 1000000017699968292293481503; - bpsToRay[7476] = 1000000017701782820779287826; - bpsToRay[7477] = 1000000017703597245438330823; - bpsToRay[7478] = 1000000017705411566282491686; - bpsToRay[7479] = 1000000017707225783323649568; - bpsToRay[7480] = 1000000017709039896573681579; - bpsToRay[7481] = 1000000017710853906044462798; - bpsToRay[7482] = 1000000017712667811747866261; - bpsToRay[7483] = 1000000017714481613695762967; - bpsToRay[7484] = 1000000017716295311900021878; - bpsToRay[7485] = 1000000017718108906372509921; - bpsToRay[7486] = 1000000017719922397125091988; - bpsToRay[7487] = 1000000017721735784169630931; - bpsToRay[7488] = 1000000017723549067517987571; - bpsToRay[7489] = 1000000017725362247182020693; - bpsToRay[7490] = 1000000017727175323173587048; - bpsToRay[7491] = 1000000017728988295504541353; - bpsToRay[7492] = 1000000017730801164186736290; - bpsToRay[7493] = 1000000017732613929232022514; - bpsToRay[7494] = 1000000017734426590652248641; - bpsToRay[7495] = 1000000017736239148459261259; - bpsToRay[7496] = 1000000017738051602664904924; - bpsToRay[7497] = 1000000017739863953281022159; - bpsToRay[7498] = 1000000017741676200319453460; - bpsToRay[7499] = 1000000017743488343792037292; - bpsToRay[7500] = 1000000017745300383710610088; - bpsToRay[7501] = 1000000017747112320087006255; - bpsToRay[7502] = 1000000017748924152933058170; - bpsToRay[7503] = 1000000017750735882260596182; - bpsToRay[7504] = 1000000017752547508081448613; - bpsToRay[7505] = 1000000017754359030407441756; - bpsToRay[7506] = 1000000017756170449250399880; - bpsToRay[7507] = 1000000017757981764622145224; - bpsToRay[7508] = 1000000017759792976534498007; - bpsToRay[7509] = 1000000017761604084999276416; - bpsToRay[7510] = 1000000017763415090028296618; - bpsToRay[7511] = 1000000017765225991633372753; - bpsToRay[7512] = 1000000017767036789826316939; - bpsToRay[7513] = 1000000017768847484618939268; - bpsToRay[7514] = 1000000017770658076023047811; - bpsToRay[7515] = 1000000017772468564050448615; - bpsToRay[7516] = 1000000017774278948712945708; - bpsToRay[7517] = 1000000017776089230022341092; - bpsToRay[7518] = 1000000017777899407990434751; - bpsToRay[7519] = 1000000017779709482629024645; - bpsToRay[7520] = 1000000017781519453949906719; - bpsToRay[7521] = 1000000017783329321964874894; - bpsToRay[7522] = 1000000017785139086685721072; - bpsToRay[7523] = 1000000017786948748124235137; - bpsToRay[7524] = 1000000017788758306292204955; - bpsToRay[7525] = 1000000017790567761201416374; - bpsToRay[7526] = 1000000017792377112863653223; - bpsToRay[7527] = 1000000017794186361290697316; - bpsToRay[7528] = 1000000017795995506494328448; - bpsToRay[7529] = 1000000017797804548486324401; - bpsToRay[7530] = 1000000017799613487278460940; - bpsToRay[7531] = 1000000017801422322882511813; - bpsToRay[7532] = 1000000017803231055310248755; - bpsToRay[7533] = 1000000017805039684573441487; - bpsToRay[7534] = 1000000017806848210683857715; - bpsToRay[7535] = 1000000017808656633653263133; - bpsToRay[7536] = 1000000017810464953493421421; - bpsToRay[7537] = 1000000017812273170216094248; - bpsToRay[7538] = 1000000017814081283833041270; - bpsToRay[7539] = 1000000017815889294356020130; - bpsToRay[7540] = 1000000017817697201796786462; - bpsToRay[7541] = 1000000017819505006167093890; - bpsToRay[7542] = 1000000017821312707478694026; - bpsToRay[7543] = 1000000017823120305743336473; - bpsToRay[7544] = 1000000017824927800972768824; - bpsToRay[7545] = 1000000017826735193178736665; - bpsToRay[7546] = 1000000017828542482372983573; - bpsToRay[7547] = 1000000017830349668567251118; - bpsToRay[7548] = 1000000017832156751773278858; - bpsToRay[7549] = 1000000017833963732002804350; - bpsToRay[7550] = 1000000017835770609267563142; - bpsToRay[7551] = 1000000017837577383579288776; - bpsToRay[7552] = 1000000017839384054949712789; - bpsToRay[7553] = 1000000017841190623390564711; - bpsToRay[7554] = 1000000017842997088913572069; - bpsToRay[7555] = 1000000017844803451530460387; - bpsToRay[7556] = 1000000017846609711252953183; - bpsToRay[7557] = 1000000017848415868092771972; - bpsToRay[7558] = 1000000017850221922061636268; - bpsToRay[7559] = 1000000017852027873171263580; - bpsToRay[7560] = 1000000017853833721433369417; - bpsToRay[7561] = 1000000017855639466859667286; - bpsToRay[7562] = 1000000017857445109461868694; - bpsToRay[7563] = 1000000017859250649251683144; - bpsToRay[7564] = 1000000017861056086240818144; - bpsToRay[7565] = 1000000017862861420440979199; - bpsToRay[7566] = 1000000017864666651863869815; - bpsToRay[7567] = 1000000017866471780521191500; - bpsToRay[7568] = 1000000017868276806424643763; - bpsToRay[7569] = 1000000017870081729585924118; - bpsToRay[7570] = 1000000017871886550016728077; - bpsToRay[7571] = 1000000017873691267728749159; - bpsToRay[7572] = 1000000017875495882733678884; - bpsToRay[7573] = 1000000017877300395043206778; - bpsToRay[7574] = 1000000017879104804669020371; - bpsToRay[7575] = 1000000017880909111622805195; - bpsToRay[7576] = 1000000017882713315916244793; - bpsToRay[7577] = 1000000017884517417561020708; - bpsToRay[7578] = 1000000017886321416568812494; - bpsToRay[7579] = 1000000017888125312951297708; - bpsToRay[7580] = 1000000017889929106720151917; - bpsToRay[7581] = 1000000017891732797887048694; - bpsToRay[7582] = 1000000017893536386463659622; - bpsToRay[7583] = 1000000017895339872461654288; - bpsToRay[7584] = 1000000017897143255892700294; - bpsToRay[7585] = 1000000017898946536768463247; - bpsToRay[7586] = 1000000017900749715100606767; - bpsToRay[7587] = 1000000017902552790900792481; - bpsToRay[7588] = 1000000017904355764180680030; - bpsToRay[7589] = 1000000017906158634951927065; - bpsToRay[7590] = 1000000017907961403226189248; - bpsToRay[7591] = 1000000017909764069015120253; - bpsToRay[7592] = 1000000017911566632330371770; - bpsToRay[7593] = 1000000017913369093183593497; - bpsToRay[7594] = 1000000017915171451586433149; - bpsToRay[7595] = 1000000017916973707550536454; - bpsToRay[7596] = 1000000017918775861087547154; - bpsToRay[7597] = 1000000017920577912209107007; - bpsToRay[7598] = 1000000017922379860926855785; - bpsToRay[7599] = 1000000017924181707252431276; - bpsToRay[7600] = 1000000017925983451197469286; - bpsToRay[7601] = 1000000017927785092773603635; - bpsToRay[7602] = 1000000017929586631992466162; - bpsToRay[7603] = 1000000017931388068865686724; - bpsToRay[7604] = 1000000017933189403404893193; - bpsToRay[7605] = 1000000017934990635621711463; - bpsToRay[7606] = 1000000017936791765527765445; - bpsToRay[7607] = 1000000017938592793134677070; - bpsToRay[7608] = 1000000017940393718454066288; - bpsToRay[7609] = 1000000017942194541497551072; - bpsToRay[7610] = 1000000017943995262276747410; - bpsToRay[7611] = 1000000017945795880803269319; - bpsToRay[7612] = 1000000017947596397088728831; - bpsToRay[7613] = 1000000017949396811144736003; - bpsToRay[7614] = 1000000017951197122982898913; - bpsToRay[7615] = 1000000017952997332614823666; - bpsToRay[7616] = 1000000017954797440052114387; - bpsToRay[7617] = 1000000017956597445306373223; - bpsToRay[7618] = 1000000017958397348389200349; - bpsToRay[7619] = 1000000017960197149312193963; - bpsToRay[7620] = 1000000017961996848086950291; - bpsToRay[7621] = 1000000017963796444725063580; - bpsToRay[7622] = 1000000017965595939238126106; - bpsToRay[7623] = 1000000017967395331637728171; - bpsToRay[7624] = 1000000017969194621935458105; - bpsToRay[7625] = 1000000017970993810142902264; - bpsToRay[7626] = 1000000017972792896271645032; - bpsToRay[7627] = 1000000017974591880333268823; - bpsToRay[7628] = 1000000017976390762339354077; - bpsToRay[7629] = 1000000017978189542301479266; - bpsToRay[7630] = 1000000017979988220231220891; - bpsToRay[7631] = 1000000017981786796140153482; - bpsToRay[7632] = 1000000017983585270039849600; - bpsToRay[7633] = 1000000017985383641941879838; - bpsToRay[7634] = 1000000017987181911857812820; - bpsToRay[7635] = 1000000017988980079799215201; - bpsToRay[7636] = 1000000017990778145777651670; - bpsToRay[7637] = 1000000017992576109804684946; - bpsToRay[7638] = 1000000017994373971891875786; - bpsToRay[7639] = 1000000017996171732050782977; - bpsToRay[7640] = 1000000017997969390292963342; - bpsToRay[7641] = 1000000017999766946629971735; - bpsToRay[7642] = 1000000018001564401073361051; - bpsToRay[7643] = 1000000018003361753634682215; - bpsToRay[7644] = 1000000018005159004325484191; - bpsToRay[7645] = 1000000018006956153157313979; - bpsToRay[7646] = 1000000018008753200141716615; - bpsToRay[7647] = 1000000018010550145290235173; - bpsToRay[7648] = 1000000018012346988614410765; - bpsToRay[7649] = 1000000018014143730125782540; - bpsToRay[7650] = 1000000018015940369835887686; - bpsToRay[7651] = 1000000018017736907756261431; - bpsToRay[7652] = 1000000018019533343898437042; - bpsToRay[7653] = 1000000018021329678273945825; - bpsToRay[7654] = 1000000018023125910894317128; - bpsToRay[7655] = 1000000018024922041771078339; - bpsToRay[7656] = 1000000018026718070915754887; - bpsToRay[7657] = 1000000018028513998339870242; - bpsToRay[7658] = 1000000018030309824054945918; - bpsToRay[7659] = 1000000018032105548072501472; - bpsToRay[7660] = 1000000018033901170404054502; - bpsToRay[7661] = 1000000018035696691061120650; - bpsToRay[7662] = 1000000018037492110055213602; - bpsToRay[7663] = 1000000018039287427397845090; - bpsToRay[7664] = 1000000018041082643100524888; - bpsToRay[7665] = 1000000018042877757174760818; - bpsToRay[7666] = 1000000018044672769632058746; - bpsToRay[7667] = 1000000018046467680483922585; - bpsToRay[7668] = 1000000018048262489741854293; - bpsToRay[7669] = 1000000018050057197417353878; - bpsToRay[7670] = 1000000018051851803521919393; - bpsToRay[7671] = 1000000018053646308067046939; - bpsToRay[7672] = 1000000018055440711064230668; - bpsToRay[7673] = 1000000018057235012524962777; - bpsToRay[7674] = 1000000018059029212460733515; - bpsToRay[7675] = 1000000018060823310883031179; - bpsToRay[7676] = 1000000018062617307803342118; - bpsToRay[7677] = 1000000018064411203233150730; - bpsToRay[7678] = 1000000018066204997183939464; - bpsToRay[7679] = 1000000018067998689667188822; - bpsToRay[7680] = 1000000018069792280694377358; - bpsToRay[7681] = 1000000018071585770276981673; - bpsToRay[7682] = 1000000018073379158426476430; - bpsToRay[7683] = 1000000018075172445154334336; - bpsToRay[7684] = 1000000018076965630472026159; - bpsToRay[7685] = 1000000018078758714391020716; - bpsToRay[7686] = 1000000018080551696922784882; - bpsToRay[7687] = 1000000018082344578078783584; - bpsToRay[7688] = 1000000018084137357870479807; - bpsToRay[7689] = 1000000018085930036309334591; - bpsToRay[7690] = 1000000018087722613406807031; - bpsToRay[7691] = 1000000018089515089174354279; - bpsToRay[7692] = 1000000018091307463623431547; - bpsToRay[7693] = 1000000018093099736765492103; - bpsToRay[7694] = 1000000018094891908611987271; - bpsToRay[7695] = 1000000018096683979174366435; - bpsToRay[7696] = 1000000018098475948464077039; - bpsToRay[7697] = 1000000018100267816492564585; - bpsToRay[7698] = 1000000018102059583271272636; - bpsToRay[7699] = 1000000018103851248811642814; - bpsToRay[7700] = 1000000018105642813125114801; - bpsToRay[7701] = 1000000018107434276223126344; - bpsToRay[7702] = 1000000018109225638117113246; - bpsToRay[7703] = 1000000018111016898818509377; - bpsToRay[7704] = 1000000018112808058338746667; - bpsToRay[7705] = 1000000018114599116689255107; - bpsToRay[7706] = 1000000018116390073881462757; - bpsToRay[7707] = 1000000018118180929926795735; - bpsToRay[7708] = 1000000018119971684836678225; - bpsToRay[7709] = 1000000018121762338622532479; - bpsToRay[7710] = 1000000018123552891295778807; - bpsToRay[7711] = 1000000018125343342867835592; - bpsToRay[7712] = 1000000018127133693350119278; - bpsToRay[7713] = 1000000018128923942754044379; - bpsToRay[7714] = 1000000018130714091091023470; - bpsToRay[7715] = 1000000018132504138372467200; - bpsToRay[7716] = 1000000018134294084609784283; - bpsToRay[7717] = 1000000018136083929814381499; - bpsToRay[7718] = 1000000018137873673997663698; - bpsToRay[7719] = 1000000018139663317171033802; - bpsToRay[7720] = 1000000018141452859345892798; - bpsToRay[7721] = 1000000018143242300533639746; - bpsToRay[7722] = 1000000018145031640745671772; - bpsToRay[7723] = 1000000018146820879993384079; - bpsToRay[7724] = 1000000018148610018288169936; - bpsToRay[7725] = 1000000018150399055641420686; - bpsToRay[7726] = 1000000018152187992064525743; - bpsToRay[7727] = 1000000018153976827568872596; - bpsToRay[7728] = 1000000018155765562165846803; - bpsToRay[7729] = 1000000018157554195866831997; - bpsToRay[7730] = 1000000018159342728683209886; - bpsToRay[7731] = 1000000018161131160626360252; - bpsToRay[7732] = 1000000018162919491707660948; - bpsToRay[7733] = 1000000018164707721938487908; - bpsToRay[7734] = 1000000018166495851330215138; - bpsToRay[7735] = 1000000018168283879894214720; - bpsToRay[7736] = 1000000018170071807641856811; - bpsToRay[7737] = 1000000018171859634584509651; - bpsToRay[7738] = 1000000018173647360733539548; - bpsToRay[7739] = 1000000018175434986100310896; - bpsToRay[7740] = 1000000018177222510696186163; - bpsToRay[7741] = 1000000018179009934532525896; - bpsToRay[7742] = 1000000018180797257620688721; - bpsToRay[7743] = 1000000018182584479972031343; - bpsToRay[7744] = 1000000018184371601597908550; - bpsToRay[7745] = 1000000018186158622509673205; - bpsToRay[7746] = 1000000018187945542718676256; - bpsToRay[7747] = 1000000018189732362236266731; - bpsToRay[7748] = 1000000018191519081073791739; - bpsToRay[7749] = 1000000018193305699242596471; - bpsToRay[7750] = 1000000018195092216754024201; - bpsToRay[7751] = 1000000018196878633619416285; - bpsToRay[7752] = 1000000018198664949850112165; - bpsToRay[7753] = 1000000018200451165457449362; - bpsToRay[7754] = 1000000018202237280452763485; - bpsToRay[7755] = 1000000018204023294847388227; - bpsToRay[7756] = 1000000018205809208652655365; - bpsToRay[7757] = 1000000018207595021879894762; - bpsToRay[7758] = 1000000018209380734540434368; - bpsToRay[7759] = 1000000018211166346645600216; - bpsToRay[7760] = 1000000018212951858206716428; - bpsToRay[7761] = 1000000018214737269235105217; - bpsToRay[7762] = 1000000018216522579742086876; - bpsToRay[7763] = 1000000018218307789738979791; - bpsToRay[7764] = 1000000018220092899237100435; - bpsToRay[7765] = 1000000018221877908247763371; - bpsToRay[7766] = 1000000018223662816782281250; - bpsToRay[7767] = 1000000018225447624851964814; - bpsToRay[7768] = 1000000018227232332468122895; - bpsToRay[7769] = 1000000018229016939642062413; - bpsToRay[7770] = 1000000018230801446385088385; - bpsToRay[7771] = 1000000018232585852708503911; - bpsToRay[7772] = 1000000018234370158623610192; - bpsToRay[7773] = 1000000018236154364141706515; - bpsToRay[7774] = 1000000018237938469274090263; - bpsToRay[7775] = 1000000018239722474032056911; - bpsToRay[7776] = 1000000018241506378426900026; - bpsToRay[7777] = 1000000018243290182469911273; - bpsToRay[7778] = 1000000018245073886172380408; - bpsToRay[7779] = 1000000018246857489545595283; - bpsToRay[7780] = 1000000018248640992600841846; - bpsToRay[7781] = 1000000018250424395349404142; - bpsToRay[7782] = 1000000018252207697802564308; - bpsToRay[7783] = 1000000018253990899971602583; - bpsToRay[7784] = 1000000018255774001867797298; - bpsToRay[7785] = 1000000018257557003502424884; - bpsToRay[7786] = 1000000018259339904886759871; - bpsToRay[7787] = 1000000018261122706032074886; - bpsToRay[7788] = 1000000018262905406949640654; - bpsToRay[7789] = 1000000018264688007650726000; - bpsToRay[7790] = 1000000018266470508146597849; - bpsToRay[7791] = 1000000018268252908448521228; - bpsToRay[7792] = 1000000018270035208567759259; - bpsToRay[7793] = 1000000018271817408515573169; - bpsToRay[7794] = 1000000018273599508303222287; - bpsToRay[7795] = 1000000018275381507941964042; - bpsToRay[7796] = 1000000018277163407443053964; - bpsToRay[7797] = 1000000018278945206817745690; - bpsToRay[7798] = 1000000018280726906077290954; - bpsToRay[7799] = 1000000018282508505232939599; - bpsToRay[7800] = 1000000018284290004295939569; - bpsToRay[7801] = 1000000018286071403277536912; - bpsToRay[7802] = 1000000018287852702188975783; - bpsToRay[7803] = 1000000018289633901041498440; - bpsToRay[7804] = 1000000018291414999846345249; - bpsToRay[7805] = 1000000018293195998614754679; - bpsToRay[7806] = 1000000018294976897357963307; - bpsToRay[7807] = 1000000018296757696087205817; - bpsToRay[7808] = 1000000018298538394813715001; - bpsToRay[7809] = 1000000018300318993548721757; - bpsToRay[7810] = 1000000018302099492303455093; - bpsToRay[7811] = 1000000018303879891089142124; - bpsToRay[7812] = 1000000018305660189917008076; - bpsToRay[7813] = 1000000018307440388798276281; - bpsToRay[7814] = 1000000018309220487744168184; - bpsToRay[7815] = 1000000018311000486765903339; - bpsToRay[7816] = 1000000018312780385874699412; - bpsToRay[7817] = 1000000018314560185081772178; - bpsToRay[7818] = 1000000018316339884398335526; - bpsToRay[7819] = 1000000018318119483835601454; - bpsToRay[7820] = 1000000018319898983404780074; - bpsToRay[7821] = 1000000018321678383117079613; - bpsToRay[7822] = 1000000018323457682983706407; - bpsToRay[7823] = 1000000018325236883015864909; - bpsToRay[7824] = 1000000018327015983224757684; - bpsToRay[7825] = 1000000018328794983621585414; - bpsToRay[7826] = 1000000018330573884217546893; - bpsToRay[7827] = 1000000018332352685023839031; - bpsToRay[7828] = 1000000018334131386051656857; - bpsToRay[7829] = 1000000018335909987312193512; - bpsToRay[7830] = 1000000018337688488816640255; - bpsToRay[7831] = 1000000018339466890576186465; - bpsToRay[7832] = 1000000018341245192602019632; - bpsToRay[7833] = 1000000018343023394905325372; - bpsToRay[7834] = 1000000018344801497497287412; - bpsToRay[7835] = 1000000018346579500389087603; - bpsToRay[7836] = 1000000018348357403591905911; - bpsToRay[7837] = 1000000018350135207116920426; - bpsToRay[7838] = 1000000018351912910975307354; - bpsToRay[7839] = 1000000018353690515178241024; - bpsToRay[7840] = 1000000018355468019736893884; - bpsToRay[7841] = 1000000018357245424662436505; - bpsToRay[7842] = 1000000018359022729966037580; - bpsToRay[7843] = 1000000018360799935658863920; - bpsToRay[7844] = 1000000018362577041752080465; - bpsToRay[7845] = 1000000018364354048256850272; - bpsToRay[7846] = 1000000018366130955184334526; - bpsToRay[7847] = 1000000018367907762545692533; - bpsToRay[7848] = 1000000018369684470352081722; - bpsToRay[7849] = 1000000018371461078614657652; - bpsToRay[7850] = 1000000018373237587344574003; - bpsToRay[7851] = 1000000018375013996552982578; - bpsToRay[7852] = 1000000018376790306251033313; - bpsToRay[7853] = 1000000018378566516449874264; - bpsToRay[7854] = 1000000018380342627160651618; - bpsToRay[7855] = 1000000018382118638394509685; - bpsToRay[7856] = 1000000018383894550162590906; - bpsToRay[7857] = 1000000018385670362476035850; - bpsToRay[7858] = 1000000018387446075345983212; - bpsToRay[7859] = 1000000018389221688783569817; - bpsToRay[7860] = 1000000018390997202799930621; - bpsToRay[7861] = 1000000018392772617406198706; - bpsToRay[7862] = 1000000018394547932613505288; - bpsToRay[7863] = 1000000018396323148432979711; - bpsToRay[7864] = 1000000018398098264875749451; - bpsToRay[7865] = 1000000018399873281952940114; - bpsToRay[7866] = 1000000018401648199675675439; - bpsToRay[7867] = 1000000018403423018055077298; - bpsToRay[7868] = 1000000018405197737102265694; - bpsToRay[7869] = 1000000018406972356828358763; - bpsToRay[7870] = 1000000018408746877244472776; - bpsToRay[7871] = 1000000018410521298361722136; - bpsToRay[7872] = 1000000018412295620191219382; - bpsToRay[7873] = 1000000018414069842744075188; - bpsToRay[7874] = 1000000018415843966031398359; - bpsToRay[7875] = 1000000018417617990064295840; - bpsToRay[7876] = 1000000018419391914853872712; - bpsToRay[7877] = 1000000018421165740411232189; - bpsToRay[7878] = 1000000018422939466747475623; - bpsToRay[7879] = 1000000018424713093873702506; - bpsToRay[7880] = 1000000018426486621801010465; - bpsToRay[7881] = 1000000018428260050540495264; - bpsToRay[7882] = 1000000018430033380103250808; - bpsToRay[7883] = 1000000018431806610500369140; - bpsToRay[7884] = 1000000018433579741742940441; - bpsToRay[7885] = 1000000018435352773842053034; - bpsToRay[7886] = 1000000018437125706808793381; - bpsToRay[7887] = 1000000018438898540654246083; - bpsToRay[7888] = 1000000018440671275389493885; - bpsToRay[7889] = 1000000018442443911025617670; - bpsToRay[7890] = 1000000018444216447573696466; - bpsToRay[7891] = 1000000018445988885044807442; - bpsToRay[7892] = 1000000018447761223450025908; - bpsToRay[7893] = 1000000018449533462800425319; - bpsToRay[7894] = 1000000018451305603107077273; - bpsToRay[7895] = 1000000018453077644381051511; - bpsToRay[7896] = 1000000018454849586633415920; - bpsToRay[7897] = 1000000018456621429875236530; - bpsToRay[7898] = 1000000018458393174117577515; - bpsToRay[7899] = 1000000018460164819371501200; - bpsToRay[7900] = 1000000018461936365648068049; - bpsToRay[7901] = 1000000018463707812958336676; - bpsToRay[7902] = 1000000018465479161313363842; - bpsToRay[7903] = 1000000018467250410724204454; - bpsToRay[7904] = 1000000018469021561201911568; - bpsToRay[7905] = 1000000018470792612757536386; - bpsToRay[7906] = 1000000018472563565402128258; - bpsToRay[7907] = 1000000018474334419146734687; - bpsToRay[7908] = 1000000018476105174002401321; - bpsToRay[7909] = 1000000018477875829980171960; - bpsToRay[7910] = 1000000018479646387091088551; - bpsToRay[7911] = 1000000018481416845346191196; - bpsToRay[7912] = 1000000018483187204756518145; - bpsToRay[7913] = 1000000018484957465333105800; - bpsToRay[7914] = 1000000018486727627086988714; - bpsToRay[7915] = 1000000018488497690029199592; - bpsToRay[7916] = 1000000018490267654170769294; - bpsToRay[7917] = 1000000018492037519522726829; - bpsToRay[7918] = 1000000018493807286096099365; - bpsToRay[7919] = 1000000018495576953901912217; - bpsToRay[7920] = 1000000018497346522951188860; - bpsToRay[7921] = 1000000018499115993254950919; - bpsToRay[7922] = 1000000018500885364824218178; - bpsToRay[7923] = 1000000018502654637670008573; - bpsToRay[7924] = 1000000018504423811803338199; - bpsToRay[7925] = 1000000018506192887235221305; - bpsToRay[7926] = 1000000018507961863976670296; - bpsToRay[7927] = 1000000018509730742038695738; - bpsToRay[7928] = 1000000018511499521432306350; - bpsToRay[7929] = 1000000018513268202168509012; - bpsToRay[7930] = 1000000018515036784258308760; - bpsToRay[7931] = 1000000018516805267712708791; - bpsToRay[7932] = 1000000018518573652542710459; - bpsToRay[7933] = 1000000018520341938759313279; - bpsToRay[7934] = 1000000018522110126373514925; - bpsToRay[7935] = 1000000018523878215396311232; - bpsToRay[7936] = 1000000018525646205838696196; - bpsToRay[7937] = 1000000018527414097711661974; - bpsToRay[7938] = 1000000018529181891026198882; - bpsToRay[7939] = 1000000018530949585793295404; - bpsToRay[7940] = 1000000018532717182023938179; - bpsToRay[7941] = 1000000018534484679729112016; - bpsToRay[7942] = 1000000018536252078919799882; - bpsToRay[7943] = 1000000018538019379606982909; - bpsToRay[7944] = 1000000018539786581801640396; - bpsToRay[7945] = 1000000018541553685514749800; - bpsToRay[7946] = 1000000018543320690757286750; - bpsToRay[7947] = 1000000018545087597540225037; - bpsToRay[7948] = 1000000018546854405874536615; - bpsToRay[7949] = 1000000018548621115771191610; - bpsToRay[7950] = 1000000018550387727241158310; - bpsToRay[7951] = 1000000018552154240295403172; - bpsToRay[7952] = 1000000018553920654944890818; - bpsToRay[7953] = 1000000018555686971200584040; - bpsToRay[7954] = 1000000018557453189073443800; - bpsToRay[7955] = 1000000018559219308574429223; - bpsToRay[7956] = 1000000018560985329714497605; - bpsToRay[7957] = 1000000018562751252504604416; - bpsToRay[7958] = 1000000018564517076955703290; - bpsToRay[7959] = 1000000018566282803078746033; - bpsToRay[7960] = 1000000018568048430884682622; - bpsToRay[7961] = 1000000018569813960384461207; - bpsToRay[7962] = 1000000018571579391589028103; - bpsToRay[7963] = 1000000018573344724509327805; - bpsToRay[7964] = 1000000018575109959156302976; - bpsToRay[7965] = 1000000018576875095540894448; - bpsToRay[7966] = 1000000018578640133674041234; - bpsToRay[7967] = 1000000018580405073566680515; - bpsToRay[7968] = 1000000018582169915229747647; - bpsToRay[7969] = 1000000018583934658674176160; - bpsToRay[7970] = 1000000018585699303910897760; - bpsToRay[7971] = 1000000018587463850950842326; - bpsToRay[7972] = 1000000018589228299804937915; - bpsToRay[7973] = 1000000018590992650484110758; - bpsToRay[7974] = 1000000018592756902999285262; - bpsToRay[7975] = 1000000018594521057361384012; - bpsToRay[7976] = 1000000018596285113581327769; - bpsToRay[7977] = 1000000018598049071670035472; - bpsToRay[7978] = 1000000018599812931638424240; - bpsToRay[7979] = 1000000018601576693497409365; - bpsToRay[7980] = 1000000018603340357257904322; - bpsToRay[7981] = 1000000018605103922930820766; - bpsToRay[7982] = 1000000018606867390527068528; - bpsToRay[7983] = 1000000018608630760057555620; - bpsToRay[7984] = 1000000018610394031533188235; - bpsToRay[7985] = 1000000018612157204964870748; - bpsToRay[7986] = 1000000018613920280363505711; - bpsToRay[7987] = 1000000018615683257739993862; - bpsToRay[7988] = 1000000018617446137105234120; - bpsToRay[7989] = 1000000018619208918470123584; - bpsToRay[7990] = 1000000018620971601845557538; - bpsToRay[7991] = 1000000018622734187242429447; - bpsToRay[7992] = 1000000018624496674671630963; - bpsToRay[7993] = 1000000018626259064144051920; - bpsToRay[7994] = 1000000018628021355670580334; - bpsToRay[7995] = 1000000018629783549262102411; - bpsToRay[7996] = 1000000018631545644929502537; - bpsToRay[7997] = 1000000018633307642683663287; - bpsToRay[7998] = 1000000018635069542535465422; - bpsToRay[7999] = 1000000018636831344495787885; - bpsToRay[8000] = 1000000018638593048575507813; - bpsToRay[8001] = 1000000018640354654785500524; - bpsToRay[8002] = 1000000018642116163136639525; - bpsToRay[8003] = 1000000018643877573639796513; - bpsToRay[8004] = 1000000018645638886305841373; - bpsToRay[8005] = 1000000018647400101145642177; - bpsToRay[8006] = 1000000018649161218170065187; - bpsToRay[8007] = 1000000018650922237389974856; - bpsToRay[8008] = 1000000018652683158816233826; - bpsToRay[8009] = 1000000018654443982459702927; - bpsToRay[8010] = 1000000018656204708331241185; - bpsToRay[8011] = 1000000018657965336441705812; - bpsToRay[8012] = 1000000018659725866801952216; - bpsToRay[8013] = 1000000018661486299422833994; - bpsToRay[8014] = 1000000018663246634315202936; - bpsToRay[8015] = 1000000018665006871489909025; - bpsToRay[8016] = 1000000018666767010957800439; - bpsToRay[8017] = 1000000018668527052729723547; - bpsToRay[8018] = 1000000018670286996816522913; - bpsToRay[8019] = 1000000018672046843229041295; - bpsToRay[8020] = 1000000018673806591978119648; - bpsToRay[8021] = 1000000018675566243074597119; - bpsToRay[8022] = 1000000018677325796529311054; - bpsToRay[8023] = 1000000018679085252353096991; - bpsToRay[8024] = 1000000018680844610556788668; - bpsToRay[8025] = 1000000018682603871151218019; - bpsToRay[8026] = 1000000018684363034147215174; - bpsToRay[8027] = 1000000018686122099555608460; - bpsToRay[8028] = 1000000018687881067387224406; - bpsToRay[8029] = 1000000018689639937652887737; - bpsToRay[8030] = 1000000018691398710363421374; - bpsToRay[8031] = 1000000018693157385529646441; - bpsToRay[8032] = 1000000018694915963162382261; - bpsToRay[8033] = 1000000018696674443272446357; - bpsToRay[8034] = 1000000018698432825870654450; - bpsToRay[8035] = 1000000018700191110967820466; - bpsToRay[8036] = 1000000018701949298574756529; - bpsToRay[8037] = 1000000018703707388702272967; - bpsToRay[8038] = 1000000018705465381361178307; - bpsToRay[8039] = 1000000018707223276562279280; - bpsToRay[8040] = 1000000018708981074316380821; - bpsToRay[8041] = 1000000018710738774634286066; - bpsToRay[8042] = 1000000018712496377526796358; - bpsToRay[8043] = 1000000018714253883004711240; - bpsToRay[8044] = 1000000018716011291078828461; - bpsToRay[8045] = 1000000018717768601759943976; - bpsToRay[8046] = 1000000018719525815058851943; - bpsToRay[8047] = 1000000018721282930986344728; - bpsToRay[8048] = 1000000018723039949553212902; - bpsToRay[8049] = 1000000018724796870770245242; - bpsToRay[8050] = 1000000018726553694648228732; - bpsToRay[8051] = 1000000018728310421197948562; - bpsToRay[8052] = 1000000018730067050430188132; - bpsToRay[8053] = 1000000018731823582355729050; - bpsToRay[8054] = 1000000018733580016985351129; - bpsToRay[8055] = 1000000018735336354329832394; - bpsToRay[8056] = 1000000018737092594399949079; - bpsToRay[8057] = 1000000018738848737206475625; - bpsToRay[8058] = 1000000018740604782760184687; - bpsToRay[8059] = 1000000018742360731071847127; - bpsToRay[8060] = 1000000018744116582152232018; - bpsToRay[8061] = 1000000018745872336012106646; - bpsToRay[8062] = 1000000018747627992662236508; - bpsToRay[8063] = 1000000018749383552113385312; - bpsToRay[8064] = 1000000018751139014376314979; - bpsToRay[8065] = 1000000018752894379461785643; - bpsToRay[8066] = 1000000018754649647380555651; - bpsToRay[8067] = 1000000018756404818143381562; - bpsToRay[8068] = 1000000018758159891761018152; - bpsToRay[8069] = 1000000018759914868244218410; - bpsToRay[8070] = 1000000018761669747603733537; - bpsToRay[8071] = 1000000018763424529850312954; - bpsToRay[8072] = 1000000018765179214994704293; - bpsToRay[8073] = 1000000018766933803047653406; - bpsToRay[8074] = 1000000018768688294019904359; - bpsToRay[8075] = 1000000018770442687922199432; - bpsToRay[8076] = 1000000018772196984765279129; - bpsToRay[8077] = 1000000018773951184559882166; - bpsToRay[8078] = 1000000018775705287316745477; - bpsToRay[8079] = 1000000018777459293046604218; - bpsToRay[8080] = 1000000018779213201760191760; - bpsToRay[8081] = 1000000018780967013468239695; - bpsToRay[8082] = 1000000018782720728181477833; - bpsToRay[8083] = 1000000018784474345910634206; - bpsToRay[8084] = 1000000018786227866666435065; - bpsToRay[8085] = 1000000018787981290459604881; - bpsToRay[8086] = 1000000018789734617300866347; - bpsToRay[8087] = 1000000018791487847200940377; - bpsToRay[8088] = 1000000018793240980170546107; - bpsToRay[8089] = 1000000018794994016220400896; - bpsToRay[8090] = 1000000018796746955361220324; - bpsToRay[8091] = 1000000018798499797603718194; - bpsToRay[8092] = 1000000018800252542958606535; - bpsToRay[8093] = 1000000018802005191436595596; - bpsToRay[8094] = 1000000018803757743048393855; - bpsToRay[8095] = 1000000018805510197804708009; - bpsToRay[8096] = 1000000018807262555716242984; - bpsToRay[8097] = 1000000018809014816793701930; - bpsToRay[8098] = 1000000018810766981047786222; - bpsToRay[8099] = 1000000018812519048489195463; - bpsToRay[8100] = 1000000018814271019128627481; - bpsToRay[8101] = 1000000018816022892976778332; - bpsToRay[8102] = 1000000018817774670044342299; - bpsToRay[8103] = 1000000018819526350342011891; - bpsToRay[8104] = 1000000018821277933880477847; - bpsToRay[8105] = 1000000018823029420670429136; - bpsToRay[8106] = 1000000018824780810722552952; - bpsToRay[8107] = 1000000018826532104047534720; - bpsToRay[8108] = 1000000018828283300656058095; - bpsToRay[8109] = 1000000018830034400558804964; - bpsToRay[8110] = 1000000018831785403766455440; - bpsToRay[8111] = 1000000018833536310289687871; - bpsToRay[8112] = 1000000018835287120139178833; - bpsToRay[8113] = 1000000018837037833325603137; - bpsToRay[8114] = 1000000018838788449859633821; - bpsToRay[8115] = 1000000018840538969751942163; - bpsToRay[8116] = 1000000018842289393013197665; - bpsToRay[8117] = 1000000018844039719654068068; - bpsToRay[8118] = 1000000018845789949685219346; - bpsToRay[8119] = 1000000018847540083117315706; - bpsToRay[8120] = 1000000018849290119961019588; - bpsToRay[8121] = 1000000018851040060226991670; - bpsToRay[8122] = 1000000018852789903925890862; - bpsToRay[8123] = 1000000018854539651068374310; - bpsToRay[8124] = 1000000018856289301665097399; - bpsToRay[8125] = 1000000018858038855726713746; - bpsToRay[8126] = 1000000018859788313263875208; - bpsToRay[8127] = 1000000018861537674287231877; - bpsToRay[8128] = 1000000018863286938807432083; - bpsToRay[8129] = 1000000018865036106835122396; - bpsToRay[8130] = 1000000018866785178380947620; - bpsToRay[8131] = 1000000018868534153455550800; - bpsToRay[8132] = 1000000018870283032069573223; - bpsToRay[8133] = 1000000018872031814233654409; - bpsToRay[8134] = 1000000018873780499958432124; - bpsToRay[8135] = 1000000018875529089254542368; - bpsToRay[8136] = 1000000018877277582132619389; - bpsToRay[8137] = 1000000018879025978603295669; - bpsToRay[8138] = 1000000018880774278677201936; - bpsToRay[8139] = 1000000018882522482364967158; - bpsToRay[8140] = 1000000018884270589677218543; - bpsToRay[8141] = 1000000018886018600624581547; - bpsToRay[8142] = 1000000018887766515217679862; - bpsToRay[8143] = 1000000018889514333467135430; - bpsToRay[8144] = 1000000018891262055383568433; - bpsToRay[8145] = 1000000018893009680977597295; - bpsToRay[8146] = 1000000018894757210259838691; - bpsToRay[8147] = 1000000018896504643240907534; - bpsToRay[8148] = 1000000018898251979931416987; - bpsToRay[8149] = 1000000018899999220341978457; - bpsToRay[8150] = 1000000018901746364483201594; - bpsToRay[8151] = 1000000018903493412365694300; - bpsToRay[8152] = 1000000018905240364000062719; - bpsToRay[8153] = 1000000018906987219396911245; - bpsToRay[8154] = 1000000018908733978566842519; - bpsToRay[8155] = 1000000018910480641520457429; - bpsToRay[8156] = 1000000018912227208268355112; - bpsToRay[8157] = 1000000018913973678821132954; - bpsToRay[8158] = 1000000018915720053189386589; - bpsToRay[8159] = 1000000018917466331383709901; - bpsToRay[8160] = 1000000018919212513414695026; - bpsToRay[8161] = 1000000018920958599292932347; - bpsToRay[8162] = 1000000018922704589029010497; - bpsToRay[8163] = 1000000018924450482633516364; - bpsToRay[8164] = 1000000018926196280117035085; - bpsToRay[8165] = 1000000018927941981490150050; - bpsToRay[8166] = 1000000018929687586763442899; - bpsToRay[8167] = 1000000018931433095947493526; - bpsToRay[8168] = 1000000018933178509052880078; - bpsToRay[8169] = 1000000018934923826090178954; - bpsToRay[8170] = 1000000018936669047069964810; - bpsToRay[8171] = 1000000018938414172002810552; - bpsToRay[8172] = 1000000018940159200899287344; - bpsToRay[8173] = 1000000018941904133769964603; - bpsToRay[8174] = 1000000018943648970625410000; - bpsToRay[8175] = 1000000018945393711476189463; - bpsToRay[8176] = 1000000018947138356332867178; - bpsToRay[8177] = 1000000018948882905206005585; - bpsToRay[8178] = 1000000018950627358106165381; - bpsToRay[8179] = 1000000018952371715043905520; - bpsToRay[8180] = 1000000018954115976029783215; - bpsToRay[8181] = 1000000018955860141074353935; - bpsToRay[8182] = 1000000018957604210188171410; - bpsToRay[8183] = 1000000018959348183381787625; - bpsToRay[8184] = 1000000018961092060665752828; - bpsToRay[8185] = 1000000018962835842050615522; - bpsToRay[8186] = 1000000018964579527546922474; - bpsToRay[8187] = 1000000018966323117165218711; - bpsToRay[8188] = 1000000018968066610916047517; - bpsToRay[8189] = 1000000018969810008809950439; - bpsToRay[8190] = 1000000018971553310857467288; - bpsToRay[8191] = 1000000018973296517069136132; - bpsToRay[8192] = 1000000018975039627455493305; - bpsToRay[8193] = 1000000018976782642027073402; - bpsToRay[8194] = 1000000018978525560794409280; - bpsToRay[8195] = 1000000018980268383768032061; - bpsToRay[8196] = 1000000018982011110958471130; - bpsToRay[8197] = 1000000018983753742376254135; - bpsToRay[8198] = 1000000018985496278031906990; - bpsToRay[8199] = 1000000018987238717935953874; - bpsToRay[8200] = 1000000018988981062098917230; - bpsToRay[8201] = 1000000018990723310531317765; - bpsToRay[8202] = 1000000018992465463243674457; - bpsToRay[8203] = 1000000018994207520246504546; - bpsToRay[8204] = 1000000018995949481550323540; - bpsToRay[8205] = 1000000018997691347165645214; - bpsToRay[8206] = 1000000018999433117102981611; - bpsToRay[8207] = 1000000019001174791372843041; - bpsToRay[8208] = 1000000019002916369985738082; - bpsToRay[8209] = 1000000019004657852952173583; - bpsToRay[8210] = 1000000019006399240282654660; - bpsToRay[8211] = 1000000019008140531987684699; - bpsToRay[8212] = 1000000019009881728077765354; - bpsToRay[8213] = 1000000019011622828563396552; - bpsToRay[8214] = 1000000019013363833455076488; - bpsToRay[8215] = 1000000019015104742763301630; - bpsToRay[8216] = 1000000019016845556498566716; - bpsToRay[8217] = 1000000019018586274671364757; - bpsToRay[8218] = 1000000019020326897292187034; - bpsToRay[8219] = 1000000019022067424371523101; - bpsToRay[8220] = 1000000019023807855919860787; - bpsToRay[8221] = 1000000019025548191947686191; - bpsToRay[8222] = 1000000019027288432465483687; - bpsToRay[8223] = 1000000019029028577483735925; - bpsToRay[8224] = 1000000019030768627012923824; - bpsToRay[8225] = 1000000019032508581063526585; - bpsToRay[8226] = 1000000019034248439646021677; - bpsToRay[8227] = 1000000019035988202770884848; - bpsToRay[8228] = 1000000019037727870448590123; - bpsToRay[8229] = 1000000019039467442689609800; - bpsToRay[8230] = 1000000019041206919504414455; - bpsToRay[8231] = 1000000019042946300903472942; - bpsToRay[8232] = 1000000019044685586897252392; - bpsToRay[8233] = 1000000019046424777496218212; - bpsToRay[8234] = 1000000019048163872710834089; - bpsToRay[8235] = 1000000019049902872551561987; - bpsToRay[8236] = 1000000019051641777028862150; - bpsToRay[8237] = 1000000019053380586153193101; - bpsToRay[8238] = 1000000019055119299935011644; - bpsToRay[8239] = 1000000019056857918384772859; - bpsToRay[8240] = 1000000019058596441512930110; - bpsToRay[8241] = 1000000019060334869329935041; - bpsToRay[8242] = 1000000019062073201846237576; - bpsToRay[8243] = 1000000019063811439072285921; - bpsToRay[8244] = 1000000019065549581018526566; - bpsToRay[8245] = 1000000019067287627695404278; - bpsToRay[8246] = 1000000019069025579113362113; - bpsToRay[8247] = 1000000019070763435282841406; - bpsToRay[8248] = 1000000019072501196214281776; - bpsToRay[8249] = 1000000019074238861918121125; - bpsToRay[8250] = 1000000019075976432404795643; - bpsToRay[8251] = 1000000019077713907684739801; - bpsToRay[8252] = 1000000019079451287768386354; - bpsToRay[8253] = 1000000019081188572666166345; - bpsToRay[8254] = 1000000019082925762388509101; - bpsToRay[8255] = 1000000019084662856945842236; - bpsToRay[8256] = 1000000019086399856348591650; - bpsToRay[8257] = 1000000019088136760607181530; - bpsToRay[8258] = 1000000019089873569732034349; - bpsToRay[8259] = 1000000019091610283733570869; - bpsToRay[8260] = 1000000019093346902622210139; - bpsToRay[8261] = 1000000019095083426408369496; - bpsToRay[8262] = 1000000019096819855102464568; - bpsToRay[8263] = 1000000019098556188714909268; - bpsToRay[8264] = 1000000019100292427256115802; - bpsToRay[8265] = 1000000019102028570736494664; - bpsToRay[8266] = 1000000019103764619166454637; - bpsToRay[8267] = 1000000019105500572556402798; - bpsToRay[8268] = 1000000019107236430916744512; - bpsToRay[8269] = 1000000019108972194257883436; - bpsToRay[8270] = 1000000019110707862590221519; - bpsToRay[8271] = 1000000019112443435924159001; - bpsToRay[8272] = 1000000019114178914270094416; - bpsToRay[8273] = 1000000019115914297638424590; - bpsToRay[8274] = 1000000019117649586039544643; - bpsToRay[8275] = 1000000019119384779483847985; - bpsToRay[8276] = 1000000019121119877981726323; - bpsToRay[8277] = 1000000019122854881543569660; - bpsToRay[8278] = 1000000019124589790179766288; - bpsToRay[8279] = 1000000019126324603900702800; - bpsToRay[8280] = 1000000019128059322716764080; - bpsToRay[8281] = 1000000019129793946638333310; - bpsToRay[8282] = 1000000019131528475675791968; - bpsToRay[8283] = 1000000019133262909839519827; - bpsToRay[8284] = 1000000019134997249139894958; - bpsToRay[8285] = 1000000019136731493587293730; - bpsToRay[8286] = 1000000019138465643192090809; - bpsToRay[8287] = 1000000019140199697964659157; - bpsToRay[8288] = 1000000019141933657915370038; - bpsToRay[8289] = 1000000019143667523054593010; - bpsToRay[8290] = 1000000019145401293392695935; - bpsToRay[8291] = 1000000019147134968940044972; - bpsToRay[8292] = 1000000019148868549707004581; - bpsToRay[8293] = 1000000019150602035703937519; - bpsToRay[8294] = 1000000019152335426941204848; - bpsToRay[8295] = 1000000019154068723429165929; - bpsToRay[8296] = 1000000019155801925178178423; - bpsToRay[8297] = 1000000019157535032198598294; - bpsToRay[8298] = 1000000019159268044500779809; - bpsToRay[8299] = 1000000019161000962095075535; - bpsToRay[8300] = 1000000019162733784991836346; - bpsToRay[8301] = 1000000019164466513201411414; - bpsToRay[8302] = 1000000019166199146734148217; - bpsToRay[8303] = 1000000019167931685600392538; - bpsToRay[8304] = 1000000019169664129810488463; - bpsToRay[8305] = 1000000019171396479374778382; - bpsToRay[8306] = 1000000019173128734303602993; - bpsToRay[8307] = 1000000019174860894607301295; - bpsToRay[8308] = 1000000019176592960296210597; - bpsToRay[8309] = 1000000019178324931380666510; - bpsToRay[8310] = 1000000019180056807871002956; - bpsToRay[8311] = 1000000019181788589777552160; - bpsToRay[8312] = 1000000019183520277110644657; - bpsToRay[8313] = 1000000019185251869880609289; - bpsToRay[8314] = 1000000019186983368097773204; - bpsToRay[8315] = 1000000019188714771772461861; - bpsToRay[8316] = 1000000019190446080914999025; - bpsToRay[8317] = 1000000019192177295535706774; - bpsToRay[8318] = 1000000019193908415644905492; - bpsToRay[8319] = 1000000019195639441252913873; - bpsToRay[8320] = 1000000019197370372370048924; - bpsToRay[8321] = 1000000019199101209006625961; - bpsToRay[8322] = 1000000019200831951172958609; - bpsToRay[8323] = 1000000019202562598879358809; - bpsToRay[8324] = 1000000019204293152136136807; - bpsToRay[8325] = 1000000019206023610953601168; - bpsToRay[8326] = 1000000019207753975342058765; - bpsToRay[8327] = 1000000019209484245311814785; - bpsToRay[8328] = 1000000019211214420873172728; - bpsToRay[8329] = 1000000019212944502036434409; - bpsToRay[8330] = 1000000019214674488811899953; - bpsToRay[8331] = 1000000019216404381209867805; - bpsToRay[8332] = 1000000019218134179240634720; - bpsToRay[8333] = 1000000019219863882914495771; - bpsToRay[8334] = 1000000019221593492241744342; - bpsToRay[8335] = 1000000019223323007232672138; - bpsToRay[8336] = 1000000019225052427897569177; - bpsToRay[8337] = 1000000019226781754246723793; - bpsToRay[8338] = 1000000019228510986290422641; - bpsToRay[8339] = 1000000019230240124038950687; - bpsToRay[8340] = 1000000019231969167502591220; - bpsToRay[8341] = 1000000019233698116691625845; - bpsToRay[8342] = 1000000019235426971616334484; - bpsToRay[8343] = 1000000019237155732286995379; - bpsToRay[8344] = 1000000019238884398713885090; - bpsToRay[8345] = 1000000019240612970907278498; - bpsToRay[8346] = 1000000019242341448877448803; - bpsToRay[8347] = 1000000019244069832634667526; - bpsToRay[8348] = 1000000019245798122189204505; - bpsToRay[8349] = 1000000019247526317551327904; - bpsToRay[8350] = 1000000019249254418731304205; - bpsToRay[8351] = 1000000019250982425739398211; - bpsToRay[8352] = 1000000019252710338585873049; - bpsToRay[8353] = 1000000019254438157280990169; - bpsToRay[8354] = 1000000019256165881835009342; - bpsToRay[8355] = 1000000019257893512258188661; - bpsToRay[8356] = 1000000019259621048560784543; - bpsToRay[8357] = 1000000019261348490753051732; - bpsToRay[8358] = 1000000019263075838845243292; - bpsToRay[8359] = 1000000019264803092847610615; - bpsToRay[8360] = 1000000019266530252770403415; - bpsToRay[8361] = 1000000019268257318623869732; - bpsToRay[8362] = 1000000019269984290418255933; - bpsToRay[8363] = 1000000019271711168163806709; - bpsToRay[8364] = 1000000019273437951870765080; - bpsToRay[8365] = 1000000019275164641549372390; - bpsToRay[8366] = 1000000019276891237209868311; - bpsToRay[8367] = 1000000019278617738862490844; - bpsToRay[8368] = 1000000019280344146517476314; - bpsToRay[8369] = 1000000019282070460185059378; - bpsToRay[8370] = 1000000019283796679875473021; - bpsToRay[8371] = 1000000019285522805598948554; - bpsToRay[8372] = 1000000019287248837365715621; - bpsToRay[8373] = 1000000019288974775186002193; - bpsToRay[8374] = 1000000019290700619070034572; - bpsToRay[8375] = 1000000019292426369028037391; - bpsToRay[8376] = 1000000019294152025070233613; - bpsToRay[8377] = 1000000019295877587206844530; - bpsToRay[8378] = 1000000019297603055448089770; - bpsToRay[8379] = 1000000019299328429804187289; - bpsToRay[8380] = 1000000019301053710285353377; - bpsToRay[8381] = 1000000019302778896901802656; - bpsToRay[8382] = 1000000019304503989663748081; - bpsToRay[8383] = 1000000019306228988581400940; - bpsToRay[8384] = 1000000019307953893664970854; - bpsToRay[8385] = 1000000019309678704924665780; - bpsToRay[8386] = 1000000019311403422370692008; - bpsToRay[8387] = 1000000019313128046013254162; - bpsToRay[8388] = 1000000019314852575862555202; - bpsToRay[8389] = 1000000019316577011928796425; - bpsToRay[8390] = 1000000019318301354222177460; - bpsToRay[8391] = 1000000019320025602752896275; - bpsToRay[8392] = 1000000019321749757531149174; - bpsToRay[8393] = 1000000019323473818567130798; - bpsToRay[8394] = 1000000019325197785871034125; - bpsToRay[8395] = 1000000019326921659453050469; - bpsToRay[8396] = 1000000019328645439323369486; - bpsToRay[8397] = 1000000019330369125492179166; - bpsToRay[8398] = 1000000019332092717969665839; - bpsToRay[8399] = 1000000019333816216766014177; - bpsToRay[8400] = 1000000019335539621891407188; - bpsToRay[8401] = 1000000019337262933356026219; - bpsToRay[8402] = 1000000019338986151170050961; - bpsToRay[8403] = 1000000019340709275343659442; - bpsToRay[8404] = 1000000019342432305887028033; - bpsToRay[8405] = 1000000019344155242810331446; - bpsToRay[8406] = 1000000019345878086123742733; - bpsToRay[8407] = 1000000019347600835837433289; - bpsToRay[8408] = 1000000019349323491961572852; - bpsToRay[8409] = 1000000019351046054506329501; - bpsToRay[8410] = 1000000019352768523481869660; - bpsToRay[8411] = 1000000019354490898898358095; - bpsToRay[8412] = 1000000019356213180765957915; - bpsToRay[8413] = 1000000019357935369094830575; - bpsToRay[8414] = 1000000019359657463895135874; - bpsToRay[8415] = 1000000019361379465177031955; - bpsToRay[8416] = 1000000019363101372950675305; - bpsToRay[8417] = 1000000019364823187226220761; - bpsToRay[8418] = 1000000019366544908013821502; - bpsToRay[8419] = 1000000019368266535323629053; - bpsToRay[8420] = 1000000019369988069165793289; - bpsToRay[8421] = 1000000019371709509550462428; - bpsToRay[8422] = 1000000019373430856487783037; - bpsToRay[8423] = 1000000019375152109987900033; - bpsToRay[8424] = 1000000019376873270060956677; - bpsToRay[8425] = 1000000019378594336717094581; - bpsToRay[8426] = 1000000019380315309966453706; - bpsToRay[8427] = 1000000019382036189819172359; - bpsToRay[8428] = 1000000019383756976285387201; - bpsToRay[8429] = 1000000019385477669375233239; - bpsToRay[8430] = 1000000019387198269098843832; - bpsToRay[8431] = 1000000019388918775466350690; - bpsToRay[8432] = 1000000019390639188487883872; - bpsToRay[8433] = 1000000019392359508173571791; - bpsToRay[8434] = 1000000019394079734533541209; - bpsToRay[8435] = 1000000019395799867577917242; - bpsToRay[8436] = 1000000019397519907316823356; - bpsToRay[8437] = 1000000019399239853760381372; - bpsToRay[8438] = 1000000019400959706918711464; - bpsToRay[8439] = 1000000019402679466801932157; - bpsToRay[8440] = 1000000019404399133420160333; - bpsToRay[8441] = 1000000019406118706783511225; - bpsToRay[8442] = 1000000019407838186902098423; - bpsToRay[8443] = 1000000019409557573786033870; - bpsToRay[8444] = 1000000019411276867445427867; - bpsToRay[8445] = 1000000019412996067890389067; - bpsToRay[8446] = 1000000019414715175131024480; - bpsToRay[8447] = 1000000019416434189177439474; - bpsToRay[8448] = 1000000019418153110039737771; - bpsToRay[8449] = 1000000019419871937728021454; - bpsToRay[8450] = 1000000019421590672252390959; - bpsToRay[8451] = 1000000019423309313622945081; - bpsToRay[8452] = 1000000019425027861849780974; - bpsToRay[8453] = 1000000019426746316942994151; - bpsToRay[8454] = 1000000019428464678912678481; - bpsToRay[8455] = 1000000019430182947768926195; - bpsToRay[8456] = 1000000019431901123521827882; - bpsToRay[8457] = 1000000019433619206181472490; - bpsToRay[8458] = 1000000019435337195757947331; - bpsToRay[8459] = 1000000019437055092261338072; - bpsToRay[8460] = 1000000019438772895701728744; - bpsToRay[8461] = 1000000019440490606089201741; - bpsToRay[8462] = 1000000019442208223433837815; - bpsToRay[8463] = 1000000019443925747745716082; - bpsToRay[8464] = 1000000019445643179034914020; - bpsToRay[8465] = 1000000019447360517311507470; - bpsToRay[8466] = 1000000019449077762585570634; - bpsToRay[8467] = 1000000019450794914867176081; - bpsToRay[8468] = 1000000019452511974166394739; - bpsToRay[8469] = 1000000019454228940493295906; - bpsToRay[8470] = 1000000019455945813857947238; - bpsToRay[8471] = 1000000019457662594270414762; - bpsToRay[8472] = 1000000019459379281740762866; - bpsToRay[8473] = 1000000019461095876279054304; - bpsToRay[8474] = 1000000019462812377895350198; - bpsToRay[8475] = 1000000019464528786599710033; - bpsToRay[8476] = 1000000019466245102402191663; - bpsToRay[8477] = 1000000019467961325312851309; - bpsToRay[8478] = 1000000019469677455341743557; - bpsToRay[8479] = 1000000019471393492498921365; - bpsToRay[8480] = 1000000019473109436794436053; - bpsToRay[8481] = 1000000019474825288238337314; - bpsToRay[8482] = 1000000019476541046840673208; - bpsToRay[8483] = 1000000019478256712611490164; - bpsToRay[8484] = 1000000019479972285560832982; - bpsToRay[8485] = 1000000019481687765698744828; - bpsToRay[8486] = 1000000019483403153035267242; - bpsToRay[8487] = 1000000019485118447580440132; - bpsToRay[8488] = 1000000019486833649344301778; - bpsToRay[8489] = 1000000019488548758336888832; - bpsToRay[8490] = 1000000019490263774568236316; - bpsToRay[8491] = 1000000019491978698048377623; - bpsToRay[8492] = 1000000019493693528787344519; - bpsToRay[8493] = 1000000019495408266795167146; - bpsToRay[8494] = 1000000019497122912081874013; - bpsToRay[8495] = 1000000019498837464657492007; - bpsToRay[8496] = 1000000019500551924532046386; - bpsToRay[8497] = 1000000019502266291715560784; - bpsToRay[8498] = 1000000019503980566218057206; - bpsToRay[8499] = 1000000019505694748049556036; - bpsToRay[8500] = 1000000019507408837220076029; - bpsToRay[8501] = 1000000019509122833739634318; - bpsToRay[8502] = 1000000019510836737618246412; - bpsToRay[8503] = 1000000019512550548865926194; - bpsToRay[8504] = 1000000019514264267492685924; - bpsToRay[8505] = 1000000019515977893508536240; - bpsToRay[8506] = 1000000019517691426923486156; - bpsToRay[8507] = 1000000019519404867747543065; - bpsToRay[8508] = 1000000019521118215990712736; - bpsToRay[8509] = 1000000019522831471662999316; - bpsToRay[8510] = 1000000019524544634774405332; - bpsToRay[8511] = 1000000019526257705334931690; - bpsToRay[8512] = 1000000019527970683354577675; - bpsToRay[8513] = 1000000019529683568843340950; - bpsToRay[8514] = 1000000019531396361811217559; - bpsToRay[8515] = 1000000019533109062268201927; - bpsToRay[8516] = 1000000019534821670224286859; - bpsToRay[8517] = 1000000019536534185689463541; - bpsToRay[8518] = 1000000019538246608673721540; - bpsToRay[8519] = 1000000019539958939187048805; - bpsToRay[8520] = 1000000019541671177239431669; - bpsToRay[8521] = 1000000019543383322840854842; - bpsToRay[8522] = 1000000019545095376001301423; - bpsToRay[8523] = 1000000019546807336730752891; - bpsToRay[8524] = 1000000019548519205039189107; - bpsToRay[8525] = 1000000019550230980936588320; - bpsToRay[8526] = 1000000019551942664432927159; - bpsToRay[8527] = 1000000019553654255538180638; - bpsToRay[8528] = 1000000019555365754262322160; - bpsToRay[8529] = 1000000019557077160615323508; - bpsToRay[8530] = 1000000019558788474607154854; - bpsToRay[8531] = 1000000019560499696247784753; - bpsToRay[8532] = 1000000019562210825547180149; - bpsToRay[8533] = 1000000019563921862515306371; - bpsToRay[8534] = 1000000019565632807162127135; - bpsToRay[8535] = 1000000019567343659497604546; - bpsToRay[8536] = 1000000019569054419531699092; - bpsToRay[8537] = 1000000019570765087274369656; - bpsToRay[8538] = 1000000019572475662735573501; - bpsToRay[8539] = 1000000019574186145925266288; - bpsToRay[8540] = 1000000019575896536853402059; - bpsToRay[8541] = 1000000019577606835529933249; - bpsToRay[8542] = 1000000019579317041964810682; - bpsToRay[8543] = 1000000019581027156167983573; - bpsToRay[8544] = 1000000019582737178149399527; - bpsToRay[8545] = 1000000019584447107919004537; - bpsToRay[8546] = 1000000019586156945486742993; - bpsToRay[8547] = 1000000019587866690862557669; - bpsToRay[8548] = 1000000019589576344056389737; - bpsToRay[8549] = 1000000019591285905078178759; - bpsToRay[8550] = 1000000019592995373937862689; - bpsToRay[8551] = 1000000019594704750645377873; - bpsToRay[8552] = 1000000019596414035210659053; - bpsToRay[8553] = 1000000019598123227643639361; - bpsToRay[8554] = 1000000019599832327954250327; - bpsToRay[8555] = 1000000019601541336152421872; - bpsToRay[8556] = 1000000019603250252248082310; - bpsToRay[8557] = 1000000019604959076251158355; - bpsToRay[8558] = 1000000019606667808171575114; - bpsToRay[8559] = 1000000019608376448019256087; - bpsToRay[8560] = 1000000019610084995804123174; - bpsToRay[8561] = 1000000019611793451536096669; - bpsToRay[8562] = 1000000019613501815225095263; - bpsToRay[8563] = 1000000019615210086881036044; - bpsToRay[8564] = 1000000019616918266513834497; - bpsToRay[8565] = 1000000019618626354133404505; - bpsToRay[8566] = 1000000019620334349749658350; - bpsToRay[8567] = 1000000019622042253372506711; - bpsToRay[8568] = 1000000019623750065011858666; - bpsToRay[8569] = 1000000019625457784677621692; - bpsToRay[8570] = 1000000019627165412379701666; - bpsToRay[8571] = 1000000019628872948128002863; - bpsToRay[8572] = 1000000019630580391932427962; - bpsToRay[8573] = 1000000019632287743802878037; - bpsToRay[8574] = 1000000019633995003749252568; - bpsToRay[8575] = 1000000019635702171781449432; - bpsToRay[8576] = 1000000019637409247909364910; - bpsToRay[8577] = 1000000019639116232142893683; - bpsToRay[8578] = 1000000019640823124491928838; - bpsToRay[8579] = 1000000019642529924966361858; - bpsToRay[8580] = 1000000019644236633576082635; - bpsToRay[8581] = 1000000019645943250330979460; - bpsToRay[8582] = 1000000019647649775240939030; - bpsToRay[8583] = 1000000019649356208315846444; - bpsToRay[8584] = 1000000019651062549565585208; - bpsToRay[8585] = 1000000019652768799000037231; - bpsToRay[8586] = 1000000019654474956629082825; - bpsToRay[8587] = 1000000019656181022462600710; - bpsToRay[8588] = 1000000019657886996510468009; - bpsToRay[8589] = 1000000019659592878782560255; - bpsToRay[8590] = 1000000019661298669288751384; - bpsToRay[8591] = 1000000019663004368038913738; - bpsToRay[8592] = 1000000019664709975042918068; - bpsToRay[8593] = 1000000019666415490310633533; - bpsToRay[8594] = 1000000019668120913851927696; - bpsToRay[8595] = 1000000019669826245676666531; - bpsToRay[8596] = 1000000019671531485794714421; - bpsToRay[8597] = 1000000019673236634215934155; - bpsToRay[8598] = 1000000019674941690950186933; - bpsToRay[8599] = 1000000019676646656007332363; - bpsToRay[8600] = 1000000019678351529397228463; - bpsToRay[8601] = 1000000019680056311129731662; - bpsToRay[8602] = 1000000019681761001214696799; - bpsToRay[8603] = 1000000019683465599661977123; - bpsToRay[8604] = 1000000019685170106481424294; - bpsToRay[8605] = 1000000019686874521682888385; - bpsToRay[8606] = 1000000019688578845276217880; - bpsToRay[8607] = 1000000019690283077271259672; - bpsToRay[8608] = 1000000019691987217677859074; - bpsToRay[8609] = 1000000019693691266505859802; - bpsToRay[8610] = 1000000019695395223765103993; - bpsToRay[8611] = 1000000019697099089465432194; - bpsToRay[8612] = 1000000019698802863616683367; - bpsToRay[8613] = 1000000019700506546228694886; - bpsToRay[8614] = 1000000019702210137311302542; - bpsToRay[8615] = 1000000019703913636874340539; - bpsToRay[8616] = 1000000019705617044927641498; - bpsToRay[8617] = 1000000019707320361481036453; - bpsToRay[8618] = 1000000019709023586544354858; - bpsToRay[8619] = 1000000019710726720127424577; - bpsToRay[8620] = 1000000019712429762240071896; - bpsToRay[8621] = 1000000019714132712892121515; - bpsToRay[8622] = 1000000019715835572093396554; - bpsToRay[8623] = 1000000019717538339853718546; - bpsToRay[8624] = 1000000019719241016182907446; - bpsToRay[8625] = 1000000019720943601090781625; - bpsToRay[8626] = 1000000019722646094587157873; - bpsToRay[8627] = 1000000019724348496681851400; - bpsToRay[8628] = 1000000019726050807384675834; - bpsToRay[8629] = 1000000019727753026705443223; - bpsToRay[8630] = 1000000019729455154653964034; - bpsToRay[8631] = 1000000019731157191240047158; - bpsToRay[8632] = 1000000019732859136473499900; - bpsToRay[8633] = 1000000019734560990364127992; - bpsToRay[8634] = 1000000019736262752921735584; - bpsToRay[8635] = 1000000019737964424156125249; - bpsToRay[8636] = 1000000019739666004077097982; - bpsToRay[8637] = 1000000019741367492694453198; - bpsToRay[8638] = 1000000019743068890017988738; - bpsToRay[8639] = 1000000019744770196057500864; - bpsToRay[8640] = 1000000019746471410822784262; - bpsToRay[8641] = 1000000019748172534323632041; - bpsToRay[8642] = 1000000019749873566569835734; - bpsToRay[8643] = 1000000019751574507571185299; - bpsToRay[8644] = 1000000019753275357337469119; - bpsToRay[8645] = 1000000019754976115878473999; - bpsToRay[8646] = 1000000019756676783203985175; - bpsToRay[8647] = 1000000019758377359323786302; - bpsToRay[8648] = 1000000019760077844247659467; - bpsToRay[8649] = 1000000019761778237985385179; - bpsToRay[8650] = 1000000019763478540546742376; - bpsToRay[8651] = 1000000019765178751941508423; - bpsToRay[8652] = 1000000019766878872179459110; - bpsToRay[8653] = 1000000019768578901270368657; - bpsToRay[8654] = 1000000019770278839224009713; - bpsToRay[8655] = 1000000019771978686050153352; - bpsToRay[8656] = 1000000019773678441758569079; - bpsToRay[8657] = 1000000019775378106359024828; - bpsToRay[8658] = 1000000019777077679861286963; - bpsToRay[8659] = 1000000019778777162275120275; - bpsToRay[8660] = 1000000019780476553610287987; - bpsToRay[8661] = 1000000019782175853876551752; - bpsToRay[8662] = 1000000019783875063083671655; - bpsToRay[8663] = 1000000019785574181241406209; - bpsToRay[8664] = 1000000019787273208359512363; - bpsToRay[8665] = 1000000019788972144447745493; - bpsToRay[8666] = 1000000019790670989515859410; - bpsToRay[8667] = 1000000019792369743573606356; - bpsToRay[8668] = 1000000019794068406630737008; - bpsToRay[8669] = 1000000019795766978697000471; - bpsToRay[8670] = 1000000019797465459782144290; - bpsToRay[8671] = 1000000019799163849895914439; - bpsToRay[8672] = 1000000019800862149048055328; - bpsToRay[8673] = 1000000019802560357248309801; - bpsToRay[8674] = 1000000019804258474506419137; - bpsToRay[8675] = 1000000019805956500832123050; - bpsToRay[8676] = 1000000019807654436235159689; - bpsToRay[8677] = 1000000019809352280725265639; - bpsToRay[8678] = 1000000019811050034312175922; - bpsToRay[8679] = 1000000019812747697005623995; - bpsToRay[8680] = 1000000019814445268815341752; - bpsToRay[8681] = 1000000019816142749751059525; - bpsToRay[8682] = 1000000019817840139822506084; - bpsToRay[8683] = 1000000019819537439039408634; - bpsToRay[8684] = 1000000019821234647411492821; - bpsToRay[8685] = 1000000019822931764948482727; - bpsToRay[8686] = 1000000019824628791660100876; - bpsToRay[8687] = 1000000019826325727556068227; - bpsToRay[8688] = 1000000019828022572646104182; - bpsToRay[8689] = 1000000019829719326939926581; - bpsToRay[8690] = 1000000019831415990447251705; - bpsToRay[8691] = 1000000019833112563177794274; - bpsToRay[8692] = 1000000019834809045141267450; - bpsToRay[8693] = 1000000019836505436347382837; - bpsToRay[8694] = 1000000019838201736805850477; - bpsToRay[8695] = 1000000019839897946526378859; - bpsToRay[8696] = 1000000019841594065518674908; - bpsToRay[8697] = 1000000019843290093792443997; - bpsToRay[8698] = 1000000019844986031357389939; - bpsToRay[8699] = 1000000019846681878223214989; - bpsToRay[8700] = 1000000019848377634399619849; - bpsToRay[8701] = 1000000019850073299896303661; - bpsToRay[8702] = 1000000019851768874722964014; - bpsToRay[8703] = 1000000019853464358889296941; - bpsToRay[8704] = 1000000019855159752404996917; - bpsToRay[8705] = 1000000019856855055279756866; - bpsToRay[8706] = 1000000019858550267523268155; - bpsToRay[8707] = 1000000019860245389145220596; - bpsToRay[8708] = 1000000019861940420155302451; - bpsToRay[8709] = 1000000019863635360563200425; - bpsToRay[8710] = 1000000019865330210378599670; - bpsToRay[8711] = 1000000019867024969611183786; - bpsToRay[8712] = 1000000019868719638270634821; - bpsToRay[8713] = 1000000019870414216366633269; - bpsToRay[8714] = 1000000019872108703908858076; - bpsToRay[8715] = 1000000019873803100906986629; - bpsToRay[8716] = 1000000019875497407370694772; - bpsToRay[8717] = 1000000019877191623309656793; - bpsToRay[8718] = 1000000019878885748733545431; - bpsToRay[8719] = 1000000019880579783652031874; - bpsToRay[8720] = 1000000019882273728074785762; - bpsToRay[8721] = 1000000019883967582011475183; - bpsToRay[8722] = 1000000019885661345471766678; - bpsToRay[8723] = 1000000019887355018465325236; - bpsToRay[8724] = 1000000019889048601001814301; - bpsToRay[8725] = 1000000019890742093090895767; - bpsToRay[8726] = 1000000019892435494742229981; - bpsToRay[8727] = 1000000019894128805965475739; - bpsToRay[8728] = 1000000019895822026770290295; - bpsToRay[8729] = 1000000019897515157166329351; - bpsToRay[8730] = 1000000019899208197163247067; - bpsToRay[8731] = 1000000019900901146770696053; - bpsToRay[8732] = 1000000019902594005998327375; - bpsToRay[8733] = 1000000019904286774855790554; - bpsToRay[8734] = 1000000019905979453352733562; - bpsToRay[8735] = 1000000019907672041498802832; - bpsToRay[8736] = 1000000019909364539303643246; - bpsToRay[8737] = 1000000019911056946776898148; - bpsToRay[8738] = 1000000019912749263928209333; - bpsToRay[8739] = 1000000019914441490767217054; - bpsToRay[8740] = 1000000019916133627303560021; - bpsToRay[8741] = 1000000019917825673546875400; - bpsToRay[8742] = 1000000019919517629506798819; - bpsToRay[8743] = 1000000019921209495192964356; - bpsToRay[8744] = 1000000019922901270615004553; - bpsToRay[8745] = 1000000019924592955782550408; - bpsToRay[8746] = 1000000019926284550705231377; - bpsToRay[8747] = 1000000019927976055392675377; - bpsToRay[8748] = 1000000019929667469854508782; - bpsToRay[8749] = 1000000019931358794100356430; - bpsToRay[8750] = 1000000019933050028139841613; - bpsToRay[8751] = 1000000019934741171982586087; - bpsToRay[8752] = 1000000019936432225638210068; - bpsToRay[8753] = 1000000019938123189116332234; - bpsToRay[8754] = 1000000019939814062426569721; - bpsToRay[8755] = 1000000019941504845578538131; - bpsToRay[8756] = 1000000019943195538581851525; - bpsToRay[8757] = 1000000019944886141446122425; - bpsToRay[8758] = 1000000019946576654180961822; - bpsToRay[8759] = 1000000019948267076795979161; - bpsToRay[8760] = 1000000019949957409300782358; - bpsToRay[8761] = 1000000019951647651704977788; - bpsToRay[8762] = 1000000019953337804018170292; - bpsToRay[8763] = 1000000019955027866249963174; - bpsToRay[8764] = 1000000019956717838409958205; - bpsToRay[8765] = 1000000019958407720507755616; - bpsToRay[8766] = 1000000019960097512552954109; - bpsToRay[8767] = 1000000019961787214555150849; - bpsToRay[8768] = 1000000019963476826523941464; - bpsToRay[8769] = 1000000019965166348468920054; - bpsToRay[8770] = 1000000019966855780399679180; - bpsToRay[8771] = 1000000019968545122325809875; - bpsToRay[8772] = 1000000019970234374256901634; - bpsToRay[8773] = 1000000019971923536202542425; - bpsToRay[8774] = 1000000019973612608172318678; - bpsToRay[8775] = 1000000019975301590175815296; - bpsToRay[8776] = 1000000019976990482222615648; - bpsToRay[8777] = 1000000019978679284322301573; - bpsToRay[8778] = 1000000019980367996484453378; - bpsToRay[8779] = 1000000019982056618718649841; - bpsToRay[8780] = 1000000019983745151034468208; - bpsToRay[8781] = 1000000019985433593441484196; - bpsToRay[8782] = 1000000019987121945949271992; - bpsToRay[8783] = 1000000019988810208567404255; - bpsToRay[8784] = 1000000019990498381305452115; - bpsToRay[8785] = 1000000019992186464172985172; - bpsToRay[8786] = 1000000019993874457179571499; - bpsToRay[8787] = 1000000019995562360334777640; - bpsToRay[8788] = 1000000019997250173648168612; - bpsToRay[8789] = 1000000019998937897129307905; - bpsToRay[8790] = 1000000020000625530787757482; - bpsToRay[8791] = 1000000020002313074633077780; - bpsToRay[8792] = 1000000020004000528674827707; - bpsToRay[8793] = 1000000020005687892922564648; - bpsToRay[8794] = 1000000020007375167385844462; - bpsToRay[8795] = 1000000020009062352074221481; - bpsToRay[8796] = 1000000020010749446997248514; - bpsToRay[8797] = 1000000020012436452164476843; - bpsToRay[8798] = 1000000020014123367585456228; - bpsToRay[8799] = 1000000020015810193269734903; - bpsToRay[8800] = 1000000020017496929226859581; - bpsToRay[8801] = 1000000020019183575466375447; - bpsToRay[8802] = 1000000020020870131997826170; - bpsToRay[8803] = 1000000020022556598830753888; - bpsToRay[8804] = 1000000020024242975974699224; - bpsToRay[8805] = 1000000020025929263439201274; - bpsToRay[8806] = 1000000020027615461233797613; - bpsToRay[8807] = 1000000020029301569368024297; - bpsToRay[8808] = 1000000020030987587851415860; - bpsToRay[8809] = 1000000020032673516693505313; - bpsToRay[8810] = 1000000020034359355903824149; - bpsToRay[8811] = 1000000020036045105491902339; - bpsToRay[8812] = 1000000020037730765467268337; - bpsToRay[8813] = 1000000020039416335839449075; - bpsToRay[8814] = 1000000020041101816617969965; - bpsToRay[8815] = 1000000020042787207812354904; - bpsToRay[8816] = 1000000020044472509432126266; - bpsToRay[8817] = 1000000020046157721486804911; - bpsToRay[8818] = 1000000020047842843985910178; - bpsToRay[8819] = 1000000020049527876938959890; - bpsToRay[8820] = 1000000020051212820355470352; - bpsToRay[8821] = 1000000020052897674244956352; - bpsToRay[8822] = 1000000020054582438616931164; - bpsToRay[8823] = 1000000020056267113480906541; - bpsToRay[8824] = 1000000020057951698846392724; - bpsToRay[8825] = 1000000020059636194722898437; - bpsToRay[8826] = 1000000020061320601119930888; - bpsToRay[8827] = 1000000020063004918046995771; - bpsToRay[8828] = 1000000020064689145513597267; - bpsToRay[8829] = 1000000020066373283529238037; - bpsToRay[8830] = 1000000020068057332103419236; - bpsToRay[8831] = 1000000020069741291245640498; - bpsToRay[8832] = 1000000020071425160965399947; - bpsToRay[8833] = 1000000020073108941272194197; - bpsToRay[8834] = 1000000020074792632175518341; - bpsToRay[8835] = 1000000020076476233684865968; - bpsToRay[8836] = 1000000020078159745809729151; - bpsToRay[8837] = 1000000020079843168559598451; - bpsToRay[8838] = 1000000020081526501943962918; - bpsToRay[8839] = 1000000020083209745972310093; - bpsToRay[8840] = 1000000020084892900654126002; - bpsToRay[8841] = 1000000020086575965998895164; - bpsToRay[8842] = 1000000020088258942016100588; - bpsToRay[8843] = 1000000020089941828715223770; - bpsToRay[8844] = 1000000020091624626105744699; - bpsToRay[8845] = 1000000020093307334197141855; - bpsToRay[8846] = 1000000020094989952998892207; - bpsToRay[8847] = 1000000020096672482520471219; - bpsToRay[8848] = 1000000020098354922771352842; - bpsToRay[8849] = 1000000020100037273761009523; - bpsToRay[8850] = 1000000020101719535498912200; - bpsToRay[8851] = 1000000020103401707994530304; - bpsToRay[8852] = 1000000020105083791257331758; - bpsToRay[8853] = 1000000020106765785296782980; - bpsToRay[8854] = 1000000020108447690122348881; - bpsToRay[8855] = 1000000020110129505743492865; - bpsToRay[8856] = 1000000020111811232169676833; - bpsToRay[8857] = 1000000020113492869410361176; - bpsToRay[8858] = 1000000020115174417475004786; - bpsToRay[8859] = 1000000020116855876373065045; - bpsToRay[8860] = 1000000020118537246113997834; - bpsToRay[8861] = 1000000020120218526707257528; - bpsToRay[8862] = 1000000020121899718162296998; - bpsToRay[8863] = 1000000020123580820488567614; - bpsToRay[8864] = 1000000020125261833695519242; - bpsToRay[8865] = 1000000020126942757792600241; - bpsToRay[8866] = 1000000020128623592789257476; - bpsToRay[8867] = 1000000020130304338694936301; - bpsToRay[8868] = 1000000020131984995519080574; - bpsToRay[8869] = 1000000020133665563271132648; - bpsToRay[8870] = 1000000020135346041960533378; - bpsToRay[8871] = 1000000020137026431596722116; - bpsToRay[8872] = 1000000020138706732189136713; - bpsToRay[8873] = 1000000020140386943747213521; - bpsToRay[8874] = 1000000020142067066280387392; - bpsToRay[8875] = 1000000020143747099798091677; - bpsToRay[8876] = 1000000020145427044309758231; - bpsToRay[8877] = 1000000020147106899824817406; - bpsToRay[8878] = 1000000020148786666352698057; - bpsToRay[8879] = 1000000020150466343902827542; - bpsToRay[8880] = 1000000020152145932484631718; - bpsToRay[8881] = 1000000020153825432107534947; - bpsToRay[8882] = 1000000020155504842780960093; - bpsToRay[8883] = 1000000020157184164514328522; - bpsToRay[8884] = 1000000020158863397317060104; - bpsToRay[8885] = 1000000020160542541198573211; - bpsToRay[8886] = 1000000020162221596168284722; - bpsToRay[8887] = 1000000020163900562235610018; - bpsToRay[8888] = 1000000020165579439409962985; - bpsToRay[8889] = 1000000020167258227700756012; - bpsToRay[8890] = 1000000020168936927117399997; - bpsToRay[8891] = 1000000020170615537669304340; - bpsToRay[8892] = 1000000020172294059365876949; - bpsToRay[8893] = 1000000020173972492216524237; - bpsToRay[8894] = 1000000020175650836230651123; - bpsToRay[8895] = 1000000020177329091417661033; - bpsToRay[8896] = 1000000020179007257786955901; - bpsToRay[8897] = 1000000020180685335347936169; - bpsToRay[8898] = 1000000020182363324110000782; - bpsToRay[8899] = 1000000020184041224082547200; - bpsToRay[8900] = 1000000020185719035274971385; - bpsToRay[8901] = 1000000020187396757696667812; - bpsToRay[8902] = 1000000020189074391357029461; - bpsToRay[8903] = 1000000020190751936265447827; - bpsToRay[8904] = 1000000020192429392431312906; - bpsToRay[8905] = 1000000020194106759864013214; - bpsToRay[8906] = 1000000020195784038572935769; - bpsToRay[8907] = 1000000020197461228567466103; - bpsToRay[8908] = 1000000020199138329856988259; - bpsToRay[8909] = 1000000020200815342450884791; - bpsToRay[8910] = 1000000020202492266358536762; - bpsToRay[8911] = 1000000020204169101589323750; - bpsToRay[8912] = 1000000020205845848152623845; - bpsToRay[8913] = 1000000020207522506057813646; - bpsToRay[8914] = 1000000020209199075314268269; - bpsToRay[8915] = 1000000020210875555931361340; - bpsToRay[8916] = 1000000020212551947918465000; - bpsToRay[8917] = 1000000020214228251284949901; - bpsToRay[8918] = 1000000020215904466040185214; - bpsToRay[8919] = 1000000020217580592193538618; - bpsToRay[8920] = 1000000020219256629754376312; - bpsToRay[8921] = 1000000020220932578732063007; - bpsToRay[8922] = 1000000020222608439135961931; - bpsToRay[8923] = 1000000020224284210975434825; - bpsToRay[8924] = 1000000020225959894259841949; - bpsToRay[8925] = 1000000020227635488998542076; - bpsToRay[8926] = 1000000020229310995200892497; - bpsToRay[8927] = 1000000020230986412876249021; - bpsToRay[8928] = 1000000020232661742033965972; - bpsToRay[8929] = 1000000020234336982683396194; - bpsToRay[8930] = 1000000020236012134833891045; - bpsToRay[8931] = 1000000020237687198494800405; - bpsToRay[8932] = 1000000020239362173675472669; - bpsToRay[8933] = 1000000020241037060385254751; - bpsToRay[8934] = 1000000020242711858633492088; - bpsToRay[8935] = 1000000020244386568429528633; - bpsToRay[8936] = 1000000020246061189782706857; - bpsToRay[8937] = 1000000020247735722702367756; - bpsToRay[8938] = 1000000020249410167197850841; - bpsToRay[8939] = 1000000020251084523278494145; - bpsToRay[8940] = 1000000020252758790953634225; - bpsToRay[8941] = 1000000020254432970232606156; - bpsToRay[8942] = 1000000020256107061124743535; - bpsToRay[8943] = 1000000020257781063639378482; - bpsToRay[8944] = 1000000020259454977785841636; - bpsToRay[8945] = 1000000020261128803573462164; - bpsToRay[8946] = 1000000020262802541011567749; - bpsToRay[8947] = 1000000020264476190109484603; - bpsToRay[8948] = 1000000020266149750876537457; - bpsToRay[8949] = 1000000020267823223322049569; - bpsToRay[8950] = 1000000020269496607455342719; - bpsToRay[8951] = 1000000020271169903285737212; - bpsToRay[8952] = 1000000020272843110822551875; - bpsToRay[8953] = 1000000020274516230075104065; - bpsToRay[8954] = 1000000020276189261052709662; - bpsToRay[8955] = 1000000020277862203764683069; - bpsToRay[8956] = 1000000020279535058220337216; - bpsToRay[8957] = 1000000020281207824428983564; - bpsToRay[8958] = 1000000020282880502399932092; - bpsToRay[8959] = 1000000020284553092142491314; - bpsToRay[8960] = 1000000020286225593665968266; - bpsToRay[8961] = 1000000020287898006979668513; - bpsToRay[8962] = 1000000020289570332092896147; - bpsToRay[8963] = 1000000020291242569014953788; - bpsToRay[8964] = 1000000020292914717755142587; - bpsToRay[8965] = 1000000020294586778322762220; - bpsToRay[8966] = 1000000020296258750727110894; - bpsToRay[8967] = 1000000020297930634977485344; - bpsToRay[8968] = 1000000020299602431083180836; - bpsToRay[8969] = 1000000020301274139053491166; - bpsToRay[8970] = 1000000020302945758897708658; - bpsToRay[8971] = 1000000020304617290625124169; - bpsToRay[8972] = 1000000020306288734245027087; - bpsToRay[8973] = 1000000020307960089766705327; - bpsToRay[8974] = 1000000020309631357199445340; - bpsToRay[8975] = 1000000020311302536552532106; - bpsToRay[8976] = 1000000020312973627835249139; - bpsToRay[8977] = 1000000020314644631056878485; - bpsToRay[8978] = 1000000020316315546226700722; - bpsToRay[8979] = 1000000020317986373353994961; - bpsToRay[8980] = 1000000020319657112448038846; - bpsToRay[8981] = 1000000020321327763518108555; - bpsToRay[8982] = 1000000020322998326573478801; - bpsToRay[8983] = 1000000020324668801623422830; - bpsToRay[8984] = 1000000020326339188677212422; - bpsToRay[8985] = 1000000020328009487744117892; - bpsToRay[8986] = 1000000020329679698833408092; - bpsToRay[8987] = 1000000020331349821954350409; - bpsToRay[8988] = 1000000020333019857116210763; - bpsToRay[8989] = 1000000020334689804328253614; - bpsToRay[8990] = 1000000020336359663599741954; - bpsToRay[8991] = 1000000020338029434939937316; - bpsToRay[8992] = 1000000020339699118358099767; - bpsToRay[8993] = 1000000020341368713863487913; - bpsToRay[8994] = 1000000020343038221465358897; - bpsToRay[8995] = 1000000020344707641172968400; - bpsToRay[8996] = 1000000020346376972995570640; - bpsToRay[8997] = 1000000020348046216942418378; - bpsToRay[8998] = 1000000020349715373022762906; - bpsToRay[8999] = 1000000020351384441245854063; - bpsToRay[9000] = 1000000020353053421620940223; - bpsToRay[9001] = 1000000020354722314157268302; - bpsToRay[9002] = 1000000020356391118864083753; - bpsToRay[9003] = 1000000020358059835750630572; - bpsToRay[9004] = 1000000020359728464826151296; - bpsToRay[9005] = 1000000020361397006099887003; - bpsToRay[9006] = 1000000020363065459581077309; - bpsToRay[9007] = 1000000020364733825278960375; - bpsToRay[9008] = 1000000020366402103202772903; - bpsToRay[9009] = 1000000020368070293361750138; - bpsToRay[9010] = 1000000020369738395765125865; - bpsToRay[9011] = 1000000020371406410422132415; - bpsToRay[9012] = 1000000020373074337342000659; - bpsToRay[9013] = 1000000020374742176533960015; - bpsToRay[9014] = 1000000020376409928007238443; - bpsToRay[9015] = 1000000020378077591771062444; - bpsToRay[9016] = 1000000020379745167834657070; - bpsToRay[9017] = 1000000020381412656207245911; - bpsToRay[9018] = 1000000020383080056898051107; - bpsToRay[9019] = 1000000020384747369916293340; - bpsToRay[9020] = 1000000020386414595271191839; - bpsToRay[9021] = 1000000020388081732971964381; - bpsToRay[9022] = 1000000020389748783027827283; - bpsToRay[9023] = 1000000020391415745447995416; - bpsToRay[9024] = 1000000020393082620241682192; - bpsToRay[9025] = 1000000020394749407418099573; - bpsToRay[9026] = 1000000020396416106986458070; - bpsToRay[9027] = 1000000020398082718955966736; - bpsToRay[9028] = 1000000020399749243335833178; - bpsToRay[9029] = 1000000020401415680135263548; - bpsToRay[9030] = 1000000020403082029363462548; - bpsToRay[9031] = 1000000020404748291029633429; - bpsToRay[9032] = 1000000020406414465142977990; - bpsToRay[9033] = 1000000020408080551712696581; - bpsToRay[9034] = 1000000020409746550747988100; - bpsToRay[9035] = 1000000020411412462258049999; - bpsToRay[9036] = 1000000020413078286252078275; - bpsToRay[9037] = 1000000020414744022739267481; - bpsToRay[9038] = 1000000020416409671728810718; - bpsToRay[9039] = 1000000020418075233229899639; - bpsToRay[9040] = 1000000020419740707251724448; - bpsToRay[9041] = 1000000020421406093803473905; - bpsToRay[9042] = 1000000020423071392894335315; - bpsToRay[9043] = 1000000020424736604533494543; - bpsToRay[9044] = 1000000020426401728730136002; - bpsToRay[9045] = 1000000020428066765493442661; - bpsToRay[9046] = 1000000020429731714832596040; - bpsToRay[9047] = 1000000020431396576756776217; - bpsToRay[9048] = 1000000020433061351275161818; - bpsToRay[9049] = 1000000020434726038396930030; - bpsToRay[9050] = 1000000020436390638131256590; - bpsToRay[9051] = 1000000020438055150487315791; - bpsToRay[9052] = 1000000020439719575474280483; - bpsToRay[9053] = 1000000020441383913101322070; - bpsToRay[9054] = 1000000020443048163377610514; - bpsToRay[9055] = 1000000020444712326312314329; - bpsToRay[9056] = 1000000020446376401914600591; - bpsToRay[9057] = 1000000020448040390193634929; - bpsToRay[9058] = 1000000020449704291158581532; - bpsToRay[9059] = 1000000020451368104818603142; - bpsToRay[9060] = 1000000020453031831182861063; - bpsToRay[9061] = 1000000020454695470260515157; - bpsToRay[9062] = 1000000020456359022060723842; - bpsToRay[9063] = 1000000020458022486592644094; - bpsToRay[9064] = 1000000020459685863865431454; - bpsToRay[9065] = 1000000020461349153888240014; - bpsToRay[9066] = 1000000020463012356670222430; - bpsToRay[9067] = 1000000020464675472220529919; - bpsToRay[9068] = 1000000020466338500548312257; - bpsToRay[9069] = 1000000020468001441662717778; - bpsToRay[9070] = 1000000020469664295572893381; - bpsToRay[9071] = 1000000020471327062287984523; - bpsToRay[9072] = 1000000020472989741817135223; - bpsToRay[9073] = 1000000020474652334169488064; - bpsToRay[9074] = 1000000020476314839354184187; - bpsToRay[9075] = 1000000020477977257380363298; - bpsToRay[9076] = 1000000020479639588257163666; - bpsToRay[9077] = 1000000020481301831993722120; - bpsToRay[9078] = 1000000020482963988599174056; - bpsToRay[9079] = 1000000020484626058082653431; - bpsToRay[9080] = 1000000020486288040453292766; - bpsToRay[9081] = 1000000020487949935720223147; - bpsToRay[9082] = 1000000020489611743892574223; - bpsToRay[9083] = 1000000020491273464979474210; - bpsToRay[9084] = 1000000020492935098990049887; - bpsToRay[9085] = 1000000020494596645933426599; - bpsToRay[9086] = 1000000020496258105818728257; - bpsToRay[9087] = 1000000020497919478655077336; - bpsToRay[9088] = 1000000020499580764451594880; - bpsToRay[9089] = 1000000020501241963217400498; - bpsToRay[9090] = 1000000020502903074961612367; - bpsToRay[9091] = 1000000020504564099693347229; - bpsToRay[9092] = 1000000020506225037421720394; - bpsToRay[9093] = 1000000020507885888155845741; - bpsToRay[9094] = 1000000020509546651904835716; - bpsToRay[9095] = 1000000020511207328677801335; - bpsToRay[9096] = 1000000020512867918483852179; - bpsToRay[9097] = 1000000020514528421332096402; - bpsToRay[9098] = 1000000020516188837231640723; - bpsToRay[9099] = 1000000020517849166191590436; - bpsToRay[9100] = 1000000020519509408221049399; - bpsToRay[9101] = 1000000020521169563329120043; - bpsToRay[9102] = 1000000020522829631524903371; - bpsToRay[9103] = 1000000020524489612817498954; - bpsToRay[9104] = 1000000020526149507216004934; - bpsToRay[9105] = 1000000020527809314729518026; - bpsToRay[9106] = 1000000020529469035367133516; - bpsToRay[9107] = 1000000020531128669137945262; - bpsToRay[9108] = 1000000020532788216051045693; - bpsToRay[9109] = 1000000020534447676115525812; - bpsToRay[9110] = 1000000020536107049340475193; - bpsToRay[9111] = 1000000020537766335734981987; - bpsToRay[9112] = 1000000020539425535308132912; - bpsToRay[9113] = 1000000020541084648069013267; - bpsToRay[9114] = 1000000020542743674026706920; - bpsToRay[9115] = 1000000020544402613190296315; - bpsToRay[9116] = 1000000020546061465568862469; - bpsToRay[9117] = 1000000020547720231171484977; - bpsToRay[9118] = 1000000020549378910007242007; - bpsToRay[9119] = 1000000020551037502085210301; - bpsToRay[9120] = 1000000020552696007414465182; - bpsToRay[9121] = 1000000020554354426004080544; - bpsToRay[9122] = 1000000020556012757863128859; - bpsToRay[9123] = 1000000020557671003000681175; - bpsToRay[9124] = 1000000020559329161425807120; - bpsToRay[9125] = 1000000020560987233147574896; - bpsToRay[9126] = 1000000020562645218175051284; - bpsToRay[9127] = 1000000020564303116517301641; - bpsToRay[9128] = 1000000020565960928183389906; - bpsToRay[9129] = 1000000020567618653182378593; - bpsToRay[9130] = 1000000020569276291523328795; - bpsToRay[9131] = 1000000020570933843215300187; - bpsToRay[9132] = 1000000020572591308267351020; - bpsToRay[9133] = 1000000020574248686688538126; - bpsToRay[9134] = 1000000020575905978487916919; - bpsToRay[9135] = 1000000020577563183674541388; - bpsToRay[9136] = 1000000020579220302257464108; - bpsToRay[9137] = 1000000020580877334245736232; - bpsToRay[9138] = 1000000020582534279648407494; - bpsToRay[9139] = 1000000020584191138474526212; - bpsToRay[9140] = 1000000020585847910733139281; - bpsToRay[9141] = 1000000020587504596433292185; - bpsToRay[9142] = 1000000020589161195584028982; - bpsToRay[9143] = 1000000020590817708194392321; - bpsToRay[9144] = 1000000020592474134273423425; - bpsToRay[9145] = 1000000020594130473830162110; - bpsToRay[9146] = 1000000020595786726873646766; - bpsToRay[9147] = 1000000020597442893412914374; - bpsToRay[9148] = 1000000020599098973457000497; - bpsToRay[9149] = 1000000020600754967014939281; - bpsToRay[9150] = 1000000020602410874095763456; - bpsToRay[9151] = 1000000020604066694708504340; - bpsToRay[9152] = 1000000020605722428862191834; - bpsToRay[9153] = 1000000020607378076565854427; - bpsToRay[9154] = 1000000020609033637828519190; - bpsToRay[9155] = 1000000020610689112659211784; - bpsToRay[9156] = 1000000020612344501066956455; - bpsToRay[9157] = 1000000020613999803060776034; - bpsToRay[9158] = 1000000020615655018649691942; - bpsToRay[9159] = 1000000020617310147842724185; - bpsToRay[9160] = 1000000020618965190648891360; - bpsToRay[9161] = 1000000020620620147077210647; - bpsToRay[9162] = 1000000020622275017136697818; - bpsToRay[9163] = 1000000020623929800836367232; - bpsToRay[9164] = 1000000020625584498185231838; - bpsToRay[9165] = 1000000020627239109192303172; - bpsToRay[9166] = 1000000020628893633866591362; - bpsToRay[9167] = 1000000020630548072217105124; - bpsToRay[9168] = 1000000020632202424252851765; - bpsToRay[9169] = 1000000020633856689982837180; - bpsToRay[9170] = 1000000020635510869416065857; - bpsToRay[9171] = 1000000020637164962561540876; - bpsToRay[9172] = 1000000020638818969428263904; - bpsToRay[9173] = 1000000020640472890025235203; - bpsToRay[9174] = 1000000020642126724361453626; - bpsToRay[9175] = 1000000020643780472445916617; - bpsToRay[9176] = 1000000020645434134287620214; - bpsToRay[9177] = 1000000020647087709895559046; - bpsToRay[9178] = 1000000020648741199278726334; - bpsToRay[9179] = 1000000020650394602446113896; - bpsToRay[9180] = 1000000020652047919406712141; - bpsToRay[9181] = 1000000020653701150169510072; - bpsToRay[9182] = 1000000020655354294743495287; - bpsToRay[9183] = 1000000020657007353137653976; - bpsToRay[9184] = 1000000020658660325360970928; - bpsToRay[9185] = 1000000020660313211422429521; - bpsToRay[9186] = 1000000020661966011331011735; - bpsToRay[9187] = 1000000020663618725095698141; - bpsToRay[9188] = 1000000020665271352725467906; - bpsToRay[9189] = 1000000020666923894229298796; - bpsToRay[9190] = 1000000020668576349616167171; - bpsToRay[9191] = 1000000020670228718895047988; - bpsToRay[9192] = 1000000020671881002074914804; - bpsToRay[9193] = 1000000020673533199164739768; - bpsToRay[9194] = 1000000020675185310173493631; - bpsToRay[9195] = 1000000020676837335110145740; - bpsToRay[9196] = 1000000020678489273983664040; - bpsToRay[9197] = 1000000020680141126803015078; - bpsToRay[9198] = 1000000020681792893577163993; - bpsToRay[9199] = 1000000020683444574315074529; - bpsToRay[9200] = 1000000020685096169025709028; - bpsToRay[9201] = 1000000020686747677718028431; - bpsToRay[9202] = 1000000020688399100400992278; - bpsToRay[9203] = 1000000020690050437083558711; - bpsToRay[9204] = 1000000020691701687774684471; - bpsToRay[9205] = 1000000020693352852483324902; - bpsToRay[9206] = 1000000020695003931218433948; - bpsToRay[9207] = 1000000020696654923988964153; - bpsToRay[9208] = 1000000020698305830803866663; - bpsToRay[9209] = 1000000020699956651672091229; - bpsToRay[9210] = 1000000020701607386602586203; - bpsToRay[9211] = 1000000020703258035604298536; - bpsToRay[9212] = 1000000020704908598686173787; - bpsToRay[9213] = 1000000020706559075857156114; - bpsToRay[9214] = 1000000020708209467126188282; - bpsToRay[9215] = 1000000020709859772502211657; - bpsToRay[9216] = 1000000020711509991994166211; - bpsToRay[9217] = 1000000020713160125610990519; - bpsToRay[9218] = 1000000020714810173361621761; - bpsToRay[9219] = 1000000020716460135254995722; - bpsToRay[9220] = 1000000020718110011300046791; - bpsToRay[9221] = 1000000020719759801505707966; - bpsToRay[9222] = 1000000020721409505880910848; - bpsToRay[9223] = 1000000020723059124434585643; - bpsToRay[9224] = 1000000020724708657175661166; - bpsToRay[9225] = 1000000020726358104113064837; - bpsToRay[9226] = 1000000020728007465255722684; - bpsToRay[9227] = 1000000020729656740612559341; - bpsToRay[9228] = 1000000020731305930192498050; - bpsToRay[9229] = 1000000020732955034004460663; - bpsToRay[9230] = 1000000020734604052057367636; - bpsToRay[9231] = 1000000020736252984360138036; - bpsToRay[9232] = 1000000020737901830921689539; - bpsToRay[9233] = 1000000020739550591750938429; - bpsToRay[9234] = 1000000020741199266856799598; - bpsToRay[9235] = 1000000020742847856248186551; - bpsToRay[9236] = 1000000020744496359934011399; - bpsToRay[9237] = 1000000020746144777923184866; - bpsToRay[9238] = 1000000020747793110224616286; - bpsToRay[9239] = 1000000020749441356847213601; - bpsToRay[9240] = 1000000020751089517799883368; - bpsToRay[9241] = 1000000020752737593091530752; - bpsToRay[9242] = 1000000020754385582731059532; - bpsToRay[9243] = 1000000020756033486727372097; - bpsToRay[9244] = 1000000020757681305089369449; - bpsToRay[9245] = 1000000020759329037825951202; - bpsToRay[9246] = 1000000020760976684946015583; - bpsToRay[9247] = 1000000020762624246458459433; - bpsToRay[9248] = 1000000020764271722372178205; - bpsToRay[9249] = 1000000020765919112696065965; - bpsToRay[9250] = 1000000020767566417439015395; - bpsToRay[9251] = 1000000020769213636609917790; - bpsToRay[9252] = 1000000020770860770217663058; - bpsToRay[9253] = 1000000020772507818271139726; - bpsToRay[9254] = 1000000020774154780779234930; - bpsToRay[9255] = 1000000020775801657750834425; - bpsToRay[9256] = 1000000020777448449194822584; - bpsToRay[9257] = 1000000020779095155120082390; - bpsToRay[9258] = 1000000020780741775535495446; - bpsToRay[9259] = 1000000020782388310449941971; - bpsToRay[9260] = 1000000020784034759872300801; - bpsToRay[9261] = 1000000020785681123811449386; - bpsToRay[9262] = 1000000020787327402276263798; - bpsToRay[9263] = 1000000020788973595275618725; - bpsToRay[9264] = 1000000020790619702818387471; - bpsToRay[9265] = 1000000020792265724913441958; - bpsToRay[9266] = 1000000020793911661569652730; - bpsToRay[9267] = 1000000020795557512795888949; - bpsToRay[9268] = 1000000020797203278601018391; - bpsToRay[9269] = 1000000020798848958993907458; - bpsToRay[9270] = 1000000020800494553983421168; - bpsToRay[9271] = 1000000020802140063578423159; - bpsToRay[9272] = 1000000020803785487787775690; - bpsToRay[9273] = 1000000020805430826620339641; - bpsToRay[9274] = 1000000020807076080084974512; - bpsToRay[9275] = 1000000020808721248190538424; - bpsToRay[9276] = 1000000020810366330945888118; - bpsToRay[9277] = 1000000020812011328359878961; - bpsToRay[9278] = 1000000020813656240441364936; - bpsToRay[9279] = 1000000020815301067199198652; - bpsToRay[9280] = 1000000020816945808642231341; - bpsToRay[9281] = 1000000020818590464779312857; - bpsToRay[9282] = 1000000020820235035619291673; - bpsToRay[9283] = 1000000020821879521171014892; - bpsToRay[9284] = 1000000020823523921443328236; - bpsToRay[9285] = 1000000020825168236445076054; - bpsToRay[9286] = 1000000020826812466185101315; - bpsToRay[9287] = 1000000020828456610672245618; - bpsToRay[9288] = 1000000020830100669915349181; - bpsToRay[9289] = 1000000020831744643923250852; - bpsToRay[9290] = 1000000020833388532704788101; - bpsToRay[9291] = 1000000020835032336268797025; - bpsToRay[9292] = 1000000020836676054624112349; - bpsToRay[9293] = 1000000020838319687779567417; - bpsToRay[9294] = 1000000020839963235743994210; - bpsToRay[9295] = 1000000020841606698526223327; - bpsToRay[9296] = 1000000020843250076135083997; - bpsToRay[9297] = 1000000020844893368579404078; - bpsToRay[9298] = 1000000020846536575868010053; - bpsToRay[9299] = 1000000020848179698009727036; - bpsToRay[9300] = 1000000020849822735013378765; - bpsToRay[9301] = 1000000020851465686887787610; - bpsToRay[9302] = 1000000020853108553641774569; - bpsToRay[9303] = 1000000020854751335284159266; - bpsToRay[9304] = 1000000020856394031823759960; - bpsToRay[9305] = 1000000020858036643269393535; - bpsToRay[9306] = 1000000020859679169629875506; - bpsToRay[9307] = 1000000020861321610914020019; - bpsToRay[9308] = 1000000020862963967130639850; - bpsToRay[9309] = 1000000020864606238288546406; - bpsToRay[9310] = 1000000020866248424396549724; - bpsToRay[9311] = 1000000020867890525463458474; - bpsToRay[9312] = 1000000020869532541498079955; - bpsToRay[9313] = 1000000020871174472509220102; - bpsToRay[9314] = 1000000020872816318505683477; - bpsToRay[9315] = 1000000020874458079496273280; - bpsToRay[9316] = 1000000020876099755489791338; - bpsToRay[9317] = 1000000020877741346495038117; - bpsToRay[9318] = 1000000020879382852520812709; - bpsToRay[9319] = 1000000020881024273575912848; - bpsToRay[9320] = 1000000020882665609669134895; - bpsToRay[9321] = 1000000020884306860809273848; - bpsToRay[9322] = 1000000020885948027005123340; - bpsToRay[9323] = 1000000020887589108265475638; - bpsToRay[9324] = 1000000020889230104599121642; - bpsToRay[9325] = 1000000020890871016014850891; - bpsToRay[9326] = 1000000020892511842521451557; - bpsToRay[9327] = 1000000020894152584127710448; - bpsToRay[9328] = 1000000020895793240842413010; - bpsToRay[9329] = 1000000020897433812674343323; - bpsToRay[9330] = 1000000020899074299632284105; - bpsToRay[9331] = 1000000020900714701725016711; - bpsToRay[9332] = 1000000020902355018961321132; - bpsToRay[9333] = 1000000020903995251349975997; - bpsToRay[9334] = 1000000020905635398899758575; - bpsToRay[9335] = 1000000020907275461619444770; - bpsToRay[9336] = 1000000020908915439517809128; - bpsToRay[9337] = 1000000020910555332603624828; - bpsToRay[9338] = 1000000020912195140885663693; - bpsToRay[9339] = 1000000020913834864372696184; - bpsToRay[9340] = 1000000020915474503073491401; - bpsToRay[9341] = 1000000020917114056996817083; - bpsToRay[9342] = 1000000020918753526151439610; - bpsToRay[9343] = 1000000020920392910546124003; - bpsToRay[9344] = 1000000020922032210189633922; - bpsToRay[9345] = 1000000020923671425090731669; - bpsToRay[9346] = 1000000020925310555258178187; - bpsToRay[9347] = 1000000020926949600700733061; - bpsToRay[9348] = 1000000020928588561427154516; - bpsToRay[9349] = 1000000020930227437446199421; - bpsToRay[9350] = 1000000020931866228766623286; - bpsToRay[9351] = 1000000020933504935397180265; - bpsToRay[9352] = 1000000020935143557346623152; - bpsToRay[9353] = 1000000020936782094623703389; - bpsToRay[9354] = 1000000020938420547237171057; - bpsToRay[9355] = 1000000020940058915195774882; - bpsToRay[9356] = 1000000020941697198508262234; - bpsToRay[9357] = 1000000020943335397183379129; - bpsToRay[9358] = 1000000020944973511229870225; - bpsToRay[9359] = 1000000020946611540656478827; - bpsToRay[9360] = 1000000020948249485471946881; - bpsToRay[9361] = 1000000020949887345685014985; - bpsToRay[9362] = 1000000020951525121304422378; - bpsToRay[9363] = 1000000020953162812338906945; - bpsToRay[9364] = 1000000020954800418797205219; - bpsToRay[9365] = 1000000020956437940688052380; - bpsToRay[9366] = 1000000020958075378020182251; - bpsToRay[9367] = 1000000020959712730802327307; - bpsToRay[9368] = 1000000020961349999043218668; - bpsToRay[9369] = 1000000020962987182751586100; - bpsToRay[9370] = 1000000020964624281936158019; - bpsToRay[9371] = 1000000020966261296605661489; - bpsToRay[9372] = 1000000020967898226768822224; - bpsToRay[9373] = 1000000020969535072434364582; - bpsToRay[9374] = 1000000020971171833611011575; - bpsToRay[9375] = 1000000020972808510307484860; - bpsToRay[9376] = 1000000020974445102532504749; - bpsToRay[9377] = 1000000020976081610294790199; - bpsToRay[9378] = 1000000020977718033603058819; - bpsToRay[9379] = 1000000020979354372466026869; - bpsToRay[9380] = 1000000020980990626892409258; - bpsToRay[9381] = 1000000020982626796890919548; - bpsToRay[9382] = 1000000020984262882470269951; - bpsToRay[9383] = 1000000020985898883639171329; - bpsToRay[9384] = 1000000020987534800406333200; - bpsToRay[9385] = 1000000020989170632780463731; - bpsToRay[9386] = 1000000020990806380770269742; - bpsToRay[9387] = 1000000020992442044384456705; - bpsToRay[9388] = 1000000020994077623631728747; - bpsToRay[9389] = 1000000020995713118520788645; - bpsToRay[9390] = 1000000020997348529060337833; - bpsToRay[9391] = 1000000020998983855259076396; - bpsToRay[9392] = 1000000021000619097125703075; - bpsToRay[9393] = 1000000021002254254668915262; - bpsToRay[9394] = 1000000021003889327897409010; - bpsToRay[9395] = 1000000021005524316819879020; - bpsToRay[9396] = 1000000021007159221445018652; - bpsToRay[9397] = 1000000021008794041781519920; - bpsToRay[9398] = 1000000021010428777838073494; - bpsToRay[9399] = 1000000021012063429623368701; - bpsToRay[9400] = 1000000021013697997146093523; - bpsToRay[9401] = 1000000021015332480414934599; - bpsToRay[9402] = 1000000021016966879438577225; - bpsToRay[9403] = 1000000021018601194225705352; - bpsToRay[9404] = 1000000021020235424785001592; - bpsToRay[9405] = 1000000021021869571125147213; - bpsToRay[9406] = 1000000021023503633254822139; - bpsToRay[9407] = 1000000021025137611182704955; - bpsToRay[9408] = 1000000021026771504917472904; - bpsToRay[9409] = 1000000021028405314467801886; - bpsToRay[9410] = 1000000021030039039842366461; - bpsToRay[9411] = 1000000021031672681049839850; - bpsToRay[9412] = 1000000021033306238098893931; - bpsToRay[9413] = 1000000021034939710998199243; - bpsToRay[9414] = 1000000021036573099756424985; - bpsToRay[9415] = 1000000021038206404382239016; - bpsToRay[9416] = 1000000021039839624884307857; - bpsToRay[9417] = 1000000021041472761271296689; - bpsToRay[9418] = 1000000021043105813551869354; - bpsToRay[9419] = 1000000021044738781734688354; - bpsToRay[9420] = 1000000021046371665828414857; - bpsToRay[9421] = 1000000021048004465841708690; - bpsToRay[9422] = 1000000021049637181783228343; - bpsToRay[9423] = 1000000021051269813661630969; - bpsToRay[9424] = 1000000021052902361485572381; - bpsToRay[9425] = 1000000021054534825263707061; - bpsToRay[9426] = 1000000021056167205004688149; - bpsToRay[9427] = 1000000021057799500717167451; - bpsToRay[9428] = 1000000021059431712409795437; - bpsToRay[9429] = 1000000021061063840091221242; - bpsToRay[9430] = 1000000021062695883770092662; - bpsToRay[9431] = 1000000021064327843455056162; - bpsToRay[9432] = 1000000021065959719154756872; - bpsToRay[9433] = 1000000021067591510877838582; - bpsToRay[9434] = 1000000021069223218632943755; - bpsToRay[9435] = 1000000021070854842428713514; - bpsToRay[9436] = 1000000021072486382273787653; - bpsToRay[9437] = 1000000021074117838176804627; - bpsToRay[9438] = 1000000021075749210146401562; - bpsToRay[9439] = 1000000021077380498191214251; - bpsToRay[9440] = 1000000021079011702319877152; - bpsToRay[9441] = 1000000021080642822541023391; - bpsToRay[9442] = 1000000021082273858863284763; - bpsToRay[9443] = 1000000021083904811295291730; - bpsToRay[9444] = 1000000021085535679845673424; - bpsToRay[9445] = 1000000021087166464523057642; - bpsToRay[9446] = 1000000021088797165336070856; - bpsToRay[9447] = 1000000021090427782293338202; - bpsToRay[9448] = 1000000021092058315403483486; - bpsToRay[9449] = 1000000021093688764675129185; - bpsToRay[9450] = 1000000021095319130116896449; - bpsToRay[9451] = 1000000021096949411737405092; - bpsToRay[9452] = 1000000021098579609545273603; - bpsToRay[9453] = 1000000021100209723549119140; - bpsToRay[9454] = 1000000021101839753757557533; - bpsToRay[9455] = 1000000021103469700179203284; - bpsToRay[9456] = 1000000021105099562822669564; - bpsToRay[9457] = 1000000021106729341696568219; - bpsToRay[9458] = 1000000021108359036809509766; - bpsToRay[9459] = 1000000021109988648170103394; - bpsToRay[9460] = 1000000021111618175786956964; - bpsToRay[9461] = 1000000021113247619668677013; - bpsToRay[9462] = 1000000021114876979823868748; - bpsToRay[9463] = 1000000021116506256261136053; - bpsToRay[9464] = 1000000021118135448989081482; - bpsToRay[9465] = 1000000021119764558016306265; - bpsToRay[9466] = 1000000021121393583351410308; - bpsToRay[9467] = 1000000021123022525002992189; - bpsToRay[9468] = 1000000021124651382979649161; - bpsToRay[9469] = 1000000021126280157289977155; - bpsToRay[9470] = 1000000021127908847942570774; - bpsToRay[9471] = 1000000021129537454946023301; - bpsToRay[9472] = 1000000021131165978308926689; - bpsToRay[9473] = 1000000021132794418039871573; - bpsToRay[9474] = 1000000021134422774147447262; - bpsToRay[9475] = 1000000021136051046640241741; - bpsToRay[9476] = 1000000021137679235526841675; - bpsToRay[9477] = 1000000021139307340815832403; - bpsToRay[9478] = 1000000021140935362515797945; - bpsToRay[9479] = 1000000021142563300635320996; - bpsToRay[9480] = 1000000021144191155182982930; - bpsToRay[9481] = 1000000021145818926167363800; - bpsToRay[9482] = 1000000021147446613597042338; - bpsToRay[9483] = 1000000021149074217480595956; - bpsToRay[9484] = 1000000021150701737826600742; - bpsToRay[9485] = 1000000021152329174643631465; - bpsToRay[9486] = 1000000021153956527940261575; - bpsToRay[9487] = 1000000021155583797725063203; - bpsToRay[9488] = 1000000021157210984006607157; - bpsToRay[9489] = 1000000021158838086793462926; - bpsToRay[9490] = 1000000021160465106094198684; - bpsToRay[9491] = 1000000021162092041917381283; - bpsToRay[9492] = 1000000021163718894271576256; - bpsToRay[9493] = 1000000021165345663165347819; - bpsToRay[9494] = 1000000021166972348607258868; - bpsToRay[9495] = 1000000021168598950605870985; - bpsToRay[9496] = 1000000021170225469169744432; - bpsToRay[9497] = 1000000021171851904307438154; - bpsToRay[9498] = 1000000021173478256027509779; - bpsToRay[9499] = 1000000021175104524338515618; - bpsToRay[9500] = 1000000021176730709249010667; - bpsToRay[9501] = 1000000021178356810767548605; - bpsToRay[9502] = 1000000021179982828902681797; - bpsToRay[9503] = 1000000021181608763662961287; - bpsToRay[9504] = 1000000021183234615056936809; - bpsToRay[9505] = 1000000021184860383093156782; - bpsToRay[9506] = 1000000021186486067780168307; - bpsToRay[9507] = 1000000021188111669126517170; - bpsToRay[9508] = 1000000021189737187140747849; - bpsToRay[9509] = 1000000021191362621831403501; - bpsToRay[9510] = 1000000021192987973207025974; - bpsToRay[9511] = 1000000021194613241276155799; - bpsToRay[9512] = 1000000021196238426047332195; - bpsToRay[9513] = 1000000021197863527529093071; - bpsToRay[9514] = 1000000021199488545729975021; - bpsToRay[9515] = 1000000021201113480658513324; - bpsToRay[9516] = 1000000021202738332323241953; - bpsToRay[9517] = 1000000021204363100732693562; - bpsToRay[9518] = 1000000021205987785895399502; - bpsToRay[9519] = 1000000021207612387819889804; - bpsToRay[9520] = 1000000021209236906514693195; - bpsToRay[9521] = 1000000021210861341988337085; - bpsToRay[9522] = 1000000021212485694249347580; - bpsToRay[9523] = 1000000021214109963306249471; - bpsToRay[9524] = 1000000021215734149167566241; - bpsToRay[9525] = 1000000021217358251841820063; - bpsToRay[9526] = 1000000021218982271337531802; - bpsToRay[9527] = 1000000021220606207663221010; - bpsToRay[9528] = 1000000021222230060827405935; - bpsToRay[9529] = 1000000021223853830838603512; - bpsToRay[9530] = 1000000021225477517705329371; - bpsToRay[9531] = 1000000021227101121436097833; - bpsToRay[9532] = 1000000021228724642039421911; - bpsToRay[9533] = 1000000021230348079523813310; - bpsToRay[9534] = 1000000021231971433897782427; - bpsToRay[9535] = 1000000021233594705169838355; - bpsToRay[9536] = 1000000021235217893348488878; - bpsToRay[9537] = 1000000021236840998442240473; - bpsToRay[9538] = 1000000021238464020459598314; - bpsToRay[9539] = 1000000021240086959409066265; - bpsToRay[9540] = 1000000021241709815299146887; - bpsToRay[9541] = 1000000021243332588138341436; - bpsToRay[9542] = 1000000021244955277935149860; - bpsToRay[9543] = 1000000021246577884698070805; - bpsToRay[9544] = 1000000021248200408435601610; - bpsToRay[9545] = 1000000021249822849156238313; - bpsToRay[9546] = 1000000021251445206868475647; - bpsToRay[9547] = 1000000021253067481580807036; - bpsToRay[9548] = 1000000021254689673301724609; - bpsToRay[9549] = 1000000021256311782039719186; - bpsToRay[9550] = 1000000021257933807803280285; - bpsToRay[9551] = 1000000021259555750600896123; - bpsToRay[9552] = 1000000021261177610441053612; - bpsToRay[9553] = 1000000021262799387332238365; - bpsToRay[9554] = 1000000021264421081282934690; - bpsToRay[9555] = 1000000021266042692301625596; - bpsToRay[9556] = 1000000021267664220396792789; - bpsToRay[9557] = 1000000021269285665576916672; - bpsToRay[9558] = 1000000021270907027850476352; - bpsToRay[9559] = 1000000021272528307225949633; - bpsToRay[9560] = 1000000021274149503711813016; - bpsToRay[9561] = 1000000021275770617316541707; - bpsToRay[9562] = 1000000021277391648048609609; - bpsToRay[9563] = 1000000021279012595916489324; - bpsToRay[9564] = 1000000021280633460928652160; - bpsToRay[9565] = 1000000021282254243093568122; - bpsToRay[9566] = 1000000021283874942419705916; - bpsToRay[9567] = 1000000021285495558915532952; - bpsToRay[9568] = 1000000021287116092589515341; - bpsToRay[9569] = 1000000021288736543450117894; - bpsToRay[9570] = 1000000021290356911505804127; - bpsToRay[9571] = 1000000021291977196765036258; - bpsToRay[9572] = 1000000021293597399236275207; - bpsToRay[9573] = 1000000021295217518927980598; - bpsToRay[9574] = 1000000021296837555848610757; - bpsToRay[9575] = 1000000021298457510006622716; - bpsToRay[9576] = 1000000021300077381410472209; - bpsToRay[9577] = 1000000021301697170068613676; - bpsToRay[9578] = 1000000021303316875989500258; - bpsToRay[9579] = 1000000021304936499181583805; - bpsToRay[9580] = 1000000021306556039653314870; - bpsToRay[9581] = 1000000021308175497413142711; - bpsToRay[9582] = 1000000021309794872469515290; - bpsToRay[9583] = 1000000021311414164830879280; - bpsToRay[9584] = 1000000021313033374505680055; - bpsToRay[9585] = 1000000021314652501502361696; - bpsToRay[9586] = 1000000021316271545829366993; - bpsToRay[9587] = 1000000021317890507495137440; - bpsToRay[9588] = 1000000021319509386508113242; - bpsToRay[9589] = 1000000021321128182876733306; - bpsToRay[9590] = 1000000021322746896609435252; - bpsToRay[9591] = 1000000021324365527714655404; - bpsToRay[9592] = 1000000021325984076200828797; - bpsToRay[9593] = 1000000021327602542076389171; - bpsToRay[9594] = 1000000021329220925349768978; - bpsToRay[9595] = 1000000021330839226029399378; - bpsToRay[9596] = 1000000021332457444123710238; - bpsToRay[9597] = 1000000021334075579641130140; - bpsToRay[9598] = 1000000021335693632590086368; - bpsToRay[9599] = 1000000021337311602979004923; - bpsToRay[9600] = 1000000021338929490816310513; - bpsToRay[9601] = 1000000021340547296110426556; - bpsToRay[9602] = 1000000021342165018869775181; - bpsToRay[9603] = 1000000021343782659102777232; - bpsToRay[9604] = 1000000021345400216817852259; - bpsToRay[9605] = 1000000021347017692023418526; - bpsToRay[9606] = 1000000021348635084727893008; - bpsToRay[9607] = 1000000021350252394939691393; - bpsToRay[9608] = 1000000021351869622667228081; - bpsToRay[9609] = 1000000021353486767918916187; - bpsToRay[9610] = 1000000021355103830703167533; - bpsToRay[9611] = 1000000021356720811028392661; - bpsToRay[9612] = 1000000021358337708903000822; - bpsToRay[9613] = 1000000021359954524335399980; - bpsToRay[9614] = 1000000021361571257333996817; - bpsToRay[9615] = 1000000021363187907907196727; - bpsToRay[9616] = 1000000021364804476063403818; - bpsToRay[9617] = 1000000021366420961811020914; - bpsToRay[9618] = 1000000021368037365158449552; - bpsToRay[9619] = 1000000021369653686114089987; - bpsToRay[9620] = 1000000021371269924686341187; - bpsToRay[9621] = 1000000021372886080883600836; - bpsToRay[9622] = 1000000021374502154714265338; - bpsToRay[9623] = 1000000021376118146186729808; - bpsToRay[9624] = 1000000021377734055309388080; - bpsToRay[9625] = 1000000021379349882090632705; - bpsToRay[9626] = 1000000021380965626538854950; - bpsToRay[9627] = 1000000021382581288662444801; - bpsToRay[9628] = 1000000021384196868469790961; - bpsToRay[9629] = 1000000021385812365969280848; - bpsToRay[9630] = 1000000021387427781169300605; - bpsToRay[9631] = 1000000021389043114078235086; - bpsToRay[9632] = 1000000021390658364704467867; - bpsToRay[9633] = 1000000021392273533056381244; - bpsToRay[9634] = 1000000021393888619142356230; - bpsToRay[9635] = 1000000021395503622970772558; - bpsToRay[9636] = 1000000021397118544550008682; - bpsToRay[9637] = 1000000021398733383888441774; - bpsToRay[9638] = 1000000021400348140994447728; - bpsToRay[9639] = 1000000021401962815876401158; - bpsToRay[9640] = 1000000021403577408542675398; - bpsToRay[9641] = 1000000021405191919001642503; - bpsToRay[9642] = 1000000021406806347261673250; - bpsToRay[9643] = 1000000021408420693331137139; - bpsToRay[9644] = 1000000021410034957218402388; - bpsToRay[9645] = 1000000021411649138931835939; - bpsToRay[9646] = 1000000021413263238479803458; - bpsToRay[9647] = 1000000021414877255870669331; - bpsToRay[9648] = 1000000021416491191112796669; - bpsToRay[9649] = 1000000021418105044214547303; - bpsToRay[9650] = 1000000021419718815184281790; - bpsToRay[9651] = 1000000021421332504030359411; - bpsToRay[9652] = 1000000021422946110761138169; - bpsToRay[9653] = 1000000021424559635384974793; - bpsToRay[9654] = 1000000021426173077910224732; - bpsToRay[9655] = 1000000021427786438345242167; - bpsToRay[9656] = 1000000021429399716698379997; - bpsToRay[9657] = 1000000021431012912977989851; - bpsToRay[9658] = 1000000021432626027192422079; - bpsToRay[9659] = 1000000021434239059350025762; - bpsToRay[9660] = 1000000021435852009459148702; - bpsToRay[9661] = 1000000021437464877528137431; - bpsToRay[9662] = 1000000021439077663565337204; - bpsToRay[9663] = 1000000021440690367579092006; - bpsToRay[9664] = 1000000021442302989577744547; - bpsToRay[9665] = 1000000021443915529569636263; - bpsToRay[9666] = 1000000021445527987563107323; - bpsToRay[9667] = 1000000021447140363566496615; - bpsToRay[9668] = 1000000021448752657588141766; - bpsToRay[9669] = 1000000021450364869636379120; - bpsToRay[9670] = 1000000021451976999719543756; - bpsToRay[9671] = 1000000021453589047845969483; - bpsToRay[9672] = 1000000021455201014023988834; - bpsToRay[9673] = 1000000021456812898261933077; - bpsToRay[9674] = 1000000021458424700568132203; - bpsToRay[9675] = 1000000021460036420950914938; - bpsToRay[9676] = 1000000021461648059418608738; - bpsToRay[9677] = 1000000021463259615979539784; - bpsToRay[9678] = 1000000021464871090642032996; - bpsToRay[9679] = 1000000021466482483414412017; - bpsToRay[9680] = 1000000021468093794304999225; - bpsToRay[9681] = 1000000021469705023322115729; - bpsToRay[9682] = 1000000021471316170474081370; - bpsToRay[9683] = 1000000021472927235769214720; - bpsToRay[9684] = 1000000021474538219215833083; - bpsToRay[9685] = 1000000021476149120822252496; - bpsToRay[9686] = 1000000021477759940596787728; - bpsToRay[9687] = 1000000021479370678547752283; - bpsToRay[9688] = 1000000021480981334683458396; - bpsToRay[9689] = 1000000021482591909012217035; - bpsToRay[9690] = 1000000021484202401542337904; - bpsToRay[9691] = 1000000021485812812282129439; - bpsToRay[9692] = 1000000021487423141239898812; - bpsToRay[9693] = 1000000021489033388423951926; - bpsToRay[9694] = 1000000021490643553842593424; - bpsToRay[9695] = 1000000021492253637504126680; - bpsToRay[9696] = 1000000021493863639416853802; - bpsToRay[9697] = 1000000021495473559589075640; - bpsToRay[9698] = 1000000021497083398029091773; - bpsToRay[9699] = 1000000021498693154745200519; - bpsToRay[9700] = 1000000021500302829745698932; - bpsToRay[9701] = 1000000021501912423038882802; - bpsToRay[9702] = 1000000021503521934633046657; - bpsToRay[9703] = 1000000021505131364536483760; - bpsToRay[9704] = 1000000021506740712757486113; - bpsToRay[9705] = 1000000021508349979304344456; - bpsToRay[9706] = 1000000021509959164185348265; - bpsToRay[9707] = 1000000021511568267408785753; - bpsToRay[9708] = 1000000021513177288982943876; - bpsToRay[9709] = 1000000021514786228916108326; - bpsToRay[9710] = 1000000021516395087216563531; - bpsToRay[9711] = 1000000021518003863892592663; - bpsToRay[9712] = 1000000021519612558952477629; - bpsToRay[9713] = 1000000021521221172404499080; - bpsToRay[9714] = 1000000021522829704256936402; - bpsToRay[9715] = 1000000021524438154518067725; - bpsToRay[9716] = 1000000021526046523196169918; - bpsToRay[9717] = 1000000021527654810299518591; - bpsToRay[9718] = 1000000021529263015836388092; - bpsToRay[9719] = 1000000021530871139815051515; - bpsToRay[9720] = 1000000021532479182243780693; - bpsToRay[9721] = 1000000021534087143130846199; - bpsToRay[9722] = 1000000021535695022484517350; - bpsToRay[9723] = 1000000021537302820313062204; - bpsToRay[9724] = 1000000021538910536624747565; - bpsToRay[9725] = 1000000021540518171427838973; - bpsToRay[9726] = 1000000021542125724730600717; - bpsToRay[9727] = 1000000021543733196541295825; - bpsToRay[9728] = 1000000021545340586868186072; - bpsToRay[9729] = 1000000021546947895719531973; - bpsToRay[9730] = 1000000021548555123103592792; - bpsToRay[9731] = 1000000021550162269028626530; - bpsToRay[9732] = 1000000021551769333502889939; - bpsToRay[9733] = 1000000021553376316534638512; - bpsToRay[9734] = 1000000021554983218132126488; - bpsToRay[9735] = 1000000021556590038303606853; - bpsToRay[9736] = 1000000021558196777057331335; - bpsToRay[9737] = 1000000021559803434401550410; - bpsToRay[9738] = 1000000021561410010344513300; - bpsToRay[9739] = 1000000021563016504894467972; - bpsToRay[9740] = 1000000021564622918059661140; - bpsToRay[9741] = 1000000021566229249848338266; - bpsToRay[9742] = 1000000021567835500268743557; - bpsToRay[9743] = 1000000021569441669329119967; - bpsToRay[9744] = 1000000021571047757037709200; - bpsToRay[9745] = 1000000021572653763402751707; - bpsToRay[9746] = 1000000021574259688432486685; - bpsToRay[9747] = 1000000021575865532135152081; - bpsToRay[9748] = 1000000021577471294518984591; - bpsToRay[9749] = 1000000021579076975592219657; - bpsToRay[9750] = 1000000021580682575363091474; - bpsToRay[9751] = 1000000021582288093839832982; - bpsToRay[9752] = 1000000021583893531030675874; - bpsToRay[9753] = 1000000021585498886943850592; - bpsToRay[9754] = 1000000021587104161587586327; - bpsToRay[9755] = 1000000021588709354970111019; - bpsToRay[9756] = 1000000021590314467099651363; - bpsToRay[9757] = 1000000021591919497984432801; - bpsToRay[9758] = 1000000021593524447632679526; - bpsToRay[9759] = 1000000021595129316052614485; - bpsToRay[9760] = 1000000021596734103252459374; - bpsToRay[9761] = 1000000021598338809240434642; - bpsToRay[9762] = 1000000021599943434024759490; - bpsToRay[9763] = 1000000021601547977613651871; - bpsToRay[9764] = 1000000021603152440015328491; - bpsToRay[9765] = 1000000021604756821238004808; - bpsToRay[9766] = 1000000021606361121289895034; - bpsToRay[9767] = 1000000021607965340179212134; - bpsToRay[9768] = 1000000021609569477914167825; - bpsToRay[9769] = 1000000021611173534502972580; - bpsToRay[9770] = 1000000021612777509953835627; - bpsToRay[9771] = 1000000021614381404274964943; - bpsToRay[9772] = 1000000021615985217474567267; - bpsToRay[9773] = 1000000021617588949560848087; - bpsToRay[9774] = 1000000021619192600542011648; - bpsToRay[9775] = 1000000021620796170426260951; - bpsToRay[9776] = 1000000021622399659221797752; - bpsToRay[9777] = 1000000021624003066936822564; - bpsToRay[9778] = 1000000021625606393579534651; - bpsToRay[9779] = 1000000021627209639158132043; - bpsToRay[9780] = 1000000021628812803680811515; - bpsToRay[9781] = 1000000021630415887155768610; - bpsToRay[9782] = 1000000021632018889591197618; - bpsToRay[9783] = 1000000021633621810995291595; - bpsToRay[9784] = 1000000021635224651376242349; - bpsToRay[9785] = 1000000021636827410742240447; - bpsToRay[9786] = 1000000021638430089101475216; - bpsToRay[9787] = 1000000021640032686462134738; - bpsToRay[9788] = 1000000021641635202832405858; - bpsToRay[9789] = 1000000021643237638220474177; - bpsToRay[9790] = 1000000021644839992634524055; - bpsToRay[9791] = 1000000021646442266082738611; - bpsToRay[9792] = 1000000021648044458573299725; - bpsToRay[9793] = 1000000021649646570114388037; - bpsToRay[9794] = 1000000021651248600714182947; - bpsToRay[9795] = 1000000021652850550380862614; - bpsToRay[9796] = 1000000021654452419122603958; - bpsToRay[9797] = 1000000021656054206947582660; - bpsToRay[9798] = 1000000021657655913863973164; - bpsToRay[9799] = 1000000021659257539879948673; - bpsToRay[9800] = 1000000021660859085003681151; - bpsToRay[9801] = 1000000021662460549243341328; - bpsToRay[9802] = 1000000021664061932607098690; - bpsToRay[9803] = 1000000021665663235103121490; - bpsToRay[9804] = 1000000021667264456739576744; - bpsToRay[9805] = 1000000021668865597524630226; - bpsToRay[9806] = 1000000021670466657466446478; - bpsToRay[9807] = 1000000021672067636573188805; - bpsToRay[9808] = 1000000021673668534853019271; - bpsToRay[9809] = 1000000021675269352314098709; - bpsToRay[9810] = 1000000021676870088964586713; - bpsToRay[9811] = 1000000021678470744812641643; - bpsToRay[9812] = 1000000021680071319866420625; - bpsToRay[9813] = 1000000021681671814134079545; - bpsToRay[9814] = 1000000021683272227623773058; - bpsToRay[9815] = 1000000021684872560343654583; - bpsToRay[9816] = 1000000021686472812301876306; - bpsToRay[9817] = 1000000021688072983506589178; - bpsToRay[9818] = 1000000021689673073965942915; - bpsToRay[9819] = 1000000021691273083688086000; - bpsToRay[9820] = 1000000021692873012681165684; - bpsToRay[9821] = 1000000021694472860953327982; - bpsToRay[9822] = 1000000021696072628512717681; - bpsToRay[9823] = 1000000021697672315367478329; - bpsToRay[9824] = 1000000021699271921525752246; - bpsToRay[9825] = 1000000021700871446995680519; - bpsToRay[9826] = 1000000021702470891785403001; - bpsToRay[9827] = 1000000021704070255903058316; - bpsToRay[9828] = 1000000021705669539356783857; - bpsToRay[9829] = 1000000021707268742154715782; - bpsToRay[9830] = 1000000021708867864304989022; - bpsToRay[9831] = 1000000021710466905815737276; - bpsToRay[9832] = 1000000021712065866695093012; - bpsToRay[9833] = 1000000021713664746951187467; - bpsToRay[9834] = 1000000021715263546592150652; - bpsToRay[9835] = 1000000021716862265626111344; - bpsToRay[9836] = 1000000021718460904061197091; - bpsToRay[9837] = 1000000021720059461905534215; - bpsToRay[9838] = 1000000021721657939167247807; - bpsToRay[9839] = 1000000021723256335854461729; - bpsToRay[9840] = 1000000021724854651975298614; - bpsToRay[9841] = 1000000021726452887537879870; - bpsToRay[9842] = 1000000021728051042550325673; - bpsToRay[9843] = 1000000021729649117020754974; - bpsToRay[9844] = 1000000021731247110957285495; - bpsToRay[9845] = 1000000021732845024368033733; - bpsToRay[9846] = 1000000021734442857261114954; - bpsToRay[9847] = 1000000021736040609644643201; - bpsToRay[9848] = 1000000021737638281526731291; - bpsToRay[9849] = 1000000021739235872915490812; - bpsToRay[9850] = 1000000021740833383819032127; - bpsToRay[9851] = 1000000021742430814245464373; - bpsToRay[9852] = 1000000021744028164202895462; - bpsToRay[9853] = 1000000021745625433699432083; - bpsToRay[9854] = 1000000021747222622743179696; - bpsToRay[9855] = 1000000021748819731342242539; - bpsToRay[9856] = 1000000021750416759504723623; - bpsToRay[9857] = 1000000021752013707238724737; - bpsToRay[9858] = 1000000021753610574552346447; - bpsToRay[9859] = 1000000021755207361453688091; - bpsToRay[9860] = 1000000021756804067950847789; - bpsToRay[9861] = 1000000021758400694051922433; - bpsToRay[9862] = 1000000021759997239765007694; - bpsToRay[9863] = 1000000021761593705098198022; - bpsToRay[9864] = 1000000021763190090059586640; - bpsToRay[9865] = 1000000021764786394657265553; - bpsToRay[9866] = 1000000021766382618899325542; - bpsToRay[9867] = 1000000021767978762793856166; - bpsToRay[9868] = 1000000021769574826348945765; - bpsToRay[9869] = 1000000021771170809572681453; - bpsToRay[9870] = 1000000021772766712473149127; - bpsToRay[9871] = 1000000021774362535058433462; - bpsToRay[9872] = 1000000021775958277336617913; - bpsToRay[9873] = 1000000021777553939315784714; - bpsToRay[9874] = 1000000021779149521004014877; - bpsToRay[9875] = 1000000021780745022409388199; - bpsToRay[9876] = 1000000021782340443539983254; - bpsToRay[9877] = 1000000021783935784403877396; - bpsToRay[9878] = 1000000021785531045009146762; - bpsToRay[9879] = 1000000021787126225363866271; - bpsToRay[9880] = 1000000021788721325476109620; - bpsToRay[9881] = 1000000021790316345353949290; - bpsToRay[9882] = 1000000021791911285005456544; - bpsToRay[9883] = 1000000021793506144438701426; - bpsToRay[9884] = 1000000021795100923661752763; - bpsToRay[9885] = 1000000021796695622682678165; - bpsToRay[9886] = 1000000021798290241509544024; - bpsToRay[9887] = 1000000021799884780150415518; - bpsToRay[9888] = 1000000021801479238613356603; - bpsToRay[9889] = 1000000021803073616906430024; - bpsToRay[9890] = 1000000021804667915037697306; - bpsToRay[9891] = 1000000021806262133015218760; - bpsToRay[9892] = 1000000021807856270847053482; - bpsToRay[9893] = 1000000021809450328541259351; - bpsToRay[9894] = 1000000021811044306105893031; - bpsToRay[9895] = 1000000021812638203549009974; - bpsToRay[9896] = 1000000021814232020878664411; - bpsToRay[9897] = 1000000021815825758102909365; - bpsToRay[9898] = 1000000021817419415229796642; - bpsToRay[9899] = 1000000021819012992267376834; - bpsToRay[9900] = 1000000021820606489223699321; - bpsToRay[9901] = 1000000021822199906106812267; - bpsToRay[9902] = 1000000021823793242924762624; - bpsToRay[9903] = 1000000021825386499685596130; - bpsToRay[9904] = 1000000021826979676397357315; - bpsToRay[9905] = 1000000021828572773068089490; - bpsToRay[9906] = 1000000021830165789705834758; - bpsToRay[9907] = 1000000021831758726318634008; - bpsToRay[9908] = 1000000021833351582914526918; - bpsToRay[9909] = 1000000021834944359501551955; - bpsToRay[9910] = 1000000021836537056087746374; - bpsToRay[9911] = 1000000021838129672681146219; - bpsToRay[9912] = 1000000021839722209289786324; - bpsToRay[9913] = 1000000021841314665921700311; - bpsToRay[9914] = 1000000021842907042584920594; - bpsToRay[9915] = 1000000021844499339287478375; - bpsToRay[9916] = 1000000021846091556037403647; - bpsToRay[9917] = 1000000021847683692842725193; - bpsToRay[9918] = 1000000021849275749711470586; - bpsToRay[9919] = 1000000021850867726651666193; - bpsToRay[9920] = 1000000021852459623671337169; - bpsToRay[9921] = 1000000021854051440778507461; - bpsToRay[9922] = 1000000021855643177981199810; - bpsToRay[9923] = 1000000021857234835287435745; - bpsToRay[9924] = 1000000021858826412705235591; - bpsToRay[9925] = 1000000021860417910242618463; - bpsToRay[9926] = 1000000021862009327907602268; - bpsToRay[9927] = 1000000021863600665708203710; - bpsToRay[9928] = 1000000021865191923652438280; - bpsToRay[9929] = 1000000021866783101748320269; - bpsToRay[9930] = 1000000021868374200003862755; - bpsToRay[9931] = 1000000021869965218427077615; - bpsToRay[9932] = 1000000021871556157025975518; - bpsToRay[9933] = 1000000021873147015808565927; - bpsToRay[9934] = 1000000021874737794782857101; - bpsToRay[9935] = 1000000021876328493956856091; - bpsToRay[9936] = 1000000021877919113338568748; - bpsToRay[9937] = 1000000021879509652935999713; - bpsToRay[9938] = 1000000021881100112757152424; - bpsToRay[9939] = 1000000021882690492810029118; - bpsToRay[9940] = 1000000021884280793102630824; - bpsToRay[9941] = 1000000021885871013642957370; - bpsToRay[9942] = 1000000021887461154439007378; - bpsToRay[9943] = 1000000021889051215498778269; - bpsToRay[9944] = 1000000021890641196830266260; - bpsToRay[9945] = 1000000021892231098441466365; - bpsToRay[9946] = 1000000021893820920340372396; - bpsToRay[9947] = 1000000021895410662534976963; - bpsToRay[9948] = 1000000021897000325033271473; - bpsToRay[9949] = 1000000021898589907843246131; - bpsToRay[9950] = 1000000021900179410972889943; - bpsToRay[9951] = 1000000021901768834430190709; - bpsToRay[9952] = 1000000021903358178223135034; - bpsToRay[9953] = 1000000021904947442359708315; - bpsToRay[9954] = 1000000021906536626847894756; - bpsToRay[9955] = 1000000021908125731695677355; - bpsToRay[9956] = 1000000021909714756911037912; - bpsToRay[9957] = 1000000021911303702501957027; - bpsToRay[9958] = 1000000021912892568476414100; - bpsToRay[9959] = 1000000021914481354842387331; - bpsToRay[9960] = 1000000021916070061607853724; - bpsToRay[9961] = 1000000021917658688780789081; - bpsToRay[9962] = 1000000021919247236369168005; - bpsToRay[9963] = 1000000021920835704380963901; - bpsToRay[9964] = 1000000021922424092824148978; - bpsToRay[9965] = 1000000021924012401706694246; - bpsToRay[9966] = 1000000021925600631036569516; - bpsToRay[9967] = 1000000021927188780821743402; - bpsToRay[9968] = 1000000021928776851070183322; - bpsToRay[9969] = 1000000021930364841789855494; - bpsToRay[9970] = 1000000021931952752988724944; - bpsToRay[9971] = 1000000021933540584674755497; - bpsToRay[9972] = 1000000021935128336855909784; - bpsToRay[9973] = 1000000021936716009540149239; - bpsToRay[9974] = 1000000021938303602735434102; - bpsToRay[9975] = 1000000021939891116449723415; - bpsToRay[9976] = 1000000021941478550690975027; - bpsToRay[9977] = 1000000021943065905467145588; - bpsToRay[9978] = 1000000021944653180786190559; - bpsToRay[9979] = 1000000021946240376656064202; - bpsToRay[9980] = 1000000021947827493084719585; - bpsToRay[9981] = 1000000021949414530080108585; - bpsToRay[9982] = 1000000021951001487650181881; - bpsToRay[9983] = 1000000021952588365802888961; - bpsToRay[9984] = 1000000021954175164546178118; - bpsToRay[9985] = 1000000021955761883887996454; - bpsToRay[9986] = 1000000021957348523836289875; - bpsToRay[9987] = 1000000021958935084399003098; - bpsToRay[9988] = 1000000021960521565584079645; - bpsToRay[9989] = 1000000021962107967399461846; - bpsToRay[9990] = 1000000021963694289853090839; - bpsToRay[9991] = 1000000021965280532952906572; - bpsToRay[9992] = 1000000021966866696706847799; - bpsToRay[9993] = 1000000021968452781122852084; - bpsToRay[9994] = 1000000021970038786208855800; - bpsToRay[9995] = 1000000021971624711972794130; - bpsToRay[9996] = 1000000021973210558422601065; - bpsToRay[9997] = 1000000021974796325566209405; - bpsToRay[9998] = 1000000021976382013411550763; - bpsToRay[9999] = 1000000021977967621966555560; - bpsToRay[10000] = 1000000021979553151239153027; + RATES = + hex"0000000000000000000b43d83715d0b0001687669d710caf0021caab36d8f947002d0da6071491820038505711ea862d004392be5b213de3004ed4dbe67ed513005a16afb7c91e0700655839d2c5a0eb0070997a3b399bdb007bda70f4ea02de00871b1e039b7ffc00925b816b12733a009d9b9b2f12f2a800a8db6b5360ca6800b41af1dbbf7cb100bf5a2ecbf241dd00ca992227bc086b00d5d7cbf2df750a00e1162c311ee2a100ec5442e63c625200f7921015f9bb870102cf93c4186bf7010e0ccdf459a7aa011949beaa7e590a01248665ea4720e1012fc2c3b7745664013afed815c6073d01463aa308fbf78e0151762494d5a1fb015cb15cbd1237b30167ec4b8570a075017326f0f1af7a96017e614d058d1b0f01899b5fc4c78d7b0194d529331c942801a00ea95449a81901ab47e02c0bf90d01b680cdbe206d8a01c1b9720e43a2e201ccf1cd2031ed3b01d829def7a7579701e361a7985fa3d901ee992706164ad201f9d05d44867c420205074a576b1ee202103dee427ed06f021b7449097be5aa0226aa5ab01c6a680231e0233a1a2191023d15a2ab2e852e02484ad90712c66e02537fc6517fcdac025eb46a8e2e3a790269e8c5c0d663a102751cd7ed305735028050a116f3da8e028b842141d86a5d0296b75871953aa702a1ea46a9e136d602ad1cebee7301ba02b84f484300f59502c3815bab41242002ceb3262ae9569102d9e4a7c5af0da602e515e07f4781ab02f046d05b67a27f02fb77775dc4179d0306a7d58a1140260311d7eae40332e4031d07b76f4dbe540328373b2fa468ac0333667628ba6fe4033e95685e42c9bc0349c411d3f023c40354f2728d74e3620360208a8e8325db036b4e59daccc05903767be076033ff40381a91e63d7e9b9038cd613a7fbbaae039802c0461f67de03a32f2441f35e5f03ae5b3f9f27c35703b98712616c740603c4b29c8c7105ca03cfddde23e4c62903db08d72b76badd03e63387a6d5a1ce03f15def99aff12703fc880f07b3d7560407b1e5f48f3b140412db7463efbb6e041e04ba5982afcc04292db7d8f527f80434566ce5f3ec23043f7ed9842b7cef044aa6fdb74813770455ced982f5a1540460f66ceadfd0a5046c1db7f2b20414047744ba9e1756e204826b74f0ba9cee048d91e6ee4662b50498b8109a64ed6004a3ddf1f8c03acb04af038b0d02018a04ba28dbdad3b0f004c54de465de711704d072a4b1cb22e804db971cc242602204e6bb4c9aec7b6004f1df343f71802204fd02d3b37932d10508262afaab10ca0513493a18ae5063051e6c011129e0f305298e7fe7c46ada0534b0b6a0244f83053fd2a53defa975054af44bc4cc4c50055615aa385fc4db056136c09c4f5907056c578ef44007fa0577781543d68a12058298538eb750f1058db849d886877d0598d7f824e811f005a3f75e777f8dd905af167cd3f0522505ba35533ddd6f2605c553e1b8e9ae9805d0722848b793ae05db9026f0e95b1405e6adddb520faf605f1cb4c9900230b05fce873a0283c9606080552ce3a6a77061321ea26d78926061e3e39ada02ec406295a416634ab1c06347601543507ad063f91797b4107b0064aaca9def828210655c79282f99fc20660e2336ae45f29066bfc8c9a5710bc0677169e14f018c606823067de4d9573068d49e9fa0d5eda069863246bcd070906a37c173729da0406ae94c25fc0ddd406b9ad25e92ed28606c4c541d710323b06cfdd162d01312506daf4a2ee9dbd9a06e60be81f81800e06f122e5c347db2306fc399bdd8bebb00707500a71e888c10712663183f843a8071d7c11175567f8072891a92f99fb990733a6f9d05fbec4073ebc02fd402c110749d0c4b9d4787c0754e53f09b5936a075ff971f07c26b4076b0d5d71c096a907762101911b02190781345e5223425c078c4773b870eb5607975a41c79b4b8007a26cc883396bf007ad7f07eee2105b07b891000e2bb72507c3a2b0e4ac995e07ceb41a75faaad107d9c53cc5ab9a0407e4d617d754d04707efe6abae8b71b207faf6f84ee45d33080606fdbbf42c93081116bbf94f347b081c26330a89847a08273562f336e7150832444bb6eae1bf083d52ed5938b4ef08486147ddb35c1d08536f5b47ed8dca085e7d279b79bb8e08698aacdbea1215087497eb0cd0792f087fa4e231be93ce088ab1924e45c0150895bdfb65f7175c08a0ca1d7c636e3408abd5f8951b547108b6e18cb3af153208c1ecd9dbaeb6e408ccf7e010a9fb4b08d8029f56305f8c08e30d17afd11c2c08ee1749211b252008f92133ad9d29ce09042ad758e59515090f343426828d54091a3d4a1a01f4720925461936f167e409304ea180de40b5093b56e2fb55938809465edda9e430a8095166919016a406095c6dfeb1793544096775251197e7bb09727c04b3fe7a83097d829d9c386877098888efcdd0e84109938efb4c52ec5b099e94c01b49231809a99a3e3e3df6ab09b49f75b8bb8d3409bfa4668e4bc8b709caa910c278473409d5ad7458ca62a509e0b19154cb310409ebb567ba03845709f6b8f78bfbeab20a01bc40ce3cae3f0a0cbf43844dd5490a17c1ffb1b7223d0a22c4755a0013b10a2dc6a480afe4720a38c88d294d8b810a43ca2f575fbc210a4ecb8b0e6ce5da0a59cca051fb34810a64cd6f259090410a6fcdf78cb29d9c0a7ace398ae6bd780a85ce3523b20d230a90cdea5a9966570a9bcd5933215f460aa6cc81b0ce4aa00ab1cb63d72437940abcc9ffa9a6f1de0ac7c8552bda01c80ad2c6646140ac360addc42d4d5df2a70ae8c1aff3b493420af3beec57c708d90afebbe27d178aec0b09b89267280dba0b14b4fc197a423e0b1fb11f978f96390b2aacfce4e9343d0b35a894050803aa0b40a3e4fb6ca8bf0b4b9eefcb97849c0b5699b47908b5450b619433074015b10b6c8e6b79bd3dca0b77885dd3ff82780b82820a1985f5a20b8d7b704dcf663b0b987490745a60460ba36d6a90a52cdd0bae65fea62dd2370bb95e4cb87213ad0bc45654caef71c50bcf4e16e1232a360bda4592fe8a37ef0be53cc926a1531d0bf033b95ce4f1320bfb2a63a4d144ef0c0620c801e23e650c1116e677938afd0c1c0cbf096095830c270251bac486290c31f79e8f3a428c0c3ceca58a3c6dbe0c47e166af45684c0c52d5e201cf50440c5dca178554013d0c68be073d4d14580c73b1b12d33e04f0c7ea515588179770c899833c2aeb1c60c948b0c6f3418da0c9f7d9f6189fc030caa6fec9d2866420cb561f42587205d0cc053b5fe1db0d50ccb45322a635bf90cd63668adcf23e60ce127598bd7c8920cec1804c7f3c7cf0cf7086a65995d540d01f88a683e82c10d0ce864d358efab0d17d7f9aa5e19990d22c748f0c334150d2db652a9fd30ad0d38a516d980bef80d43939582c24ca20d4e81cea936056e0d596fc2504fd33e0d645d707b835e1b0d6f4ad92e440c380d7a37fc6c0501fc0d8524da383922080d90117296530d3b0d9afdc589c522bc0da5e9d316017ffe0db0d59b3e7a00c80dbbc11e06a03f380dc6ac5b71e593d00dd1975383bb15790ddc82063f9199860de76c73a8d9b3c00df2569bc303b66a0dfd407e917fb24a0e082a1c17bd76ab0e131374592c91650e1dfc87593c4ee70e28e5551b5bba3b0e33cddda2f99d0a0e3eb620f3847fa50e499e1f106aa90f0e5485d7fd1a1efa0e5f6d4bbd00a5d90e6a547a538bc0dd0e753b63c428b2010e80220812447a0d0e8b0867414bd89f0e95ee8154ab4c330ea0d4564fcf12230eabb9e6362326b40eb69f310b1345190ec18436d20ae77a0ecc68f78e7546fc0ed74d7343bd5bc60ee231a9f54ddd060eed159ba69140fc0ef7f9485af1bcfc0f02dcb015d945760f0dbfd2dab18dfb0f18a2b0ace409470f2385498fd9e9440f2e679d86fc1f140f3949ac95b35b110f442b76bf680cda0f4f0cfc078263570f59ee3c716a4cbf0f64cf380087769d0f6fafeeb8414ddb0f7a90609bfefec20f85708daf2775080f905075f5215bce0f9b301971531dad0fa60f782722e4b90fb0ee9219f69a8b0fbbcd674d33e83f0fc6abf7c44036860fd18a438280ada40fdc684a8b5a35770fe7460ce23175840ff2238a8a6ad4f30ffd00c3876a7a9f1007ddb7dc944d161012ba678d4bf2a3101d96d29cf4d151102872f90ef20ef510334edae6a69133103e2a782774fd82104905d0d4bfb9361053e0e4f1e8e984105ebbb4825273881069963f895dfc4f107470860a6ce8d6107f4a8808e05e19108a2445881941151094fdbe8b7836cc109fd6f3165da45010aaafe32c29aec410b5888ed03c3b6b10c060f605f4efa410cb3918d0b330f610d610f733d6251610e0e89132bcb1ed10ebbfe6d0c57d9e10f696f8114eee8a11016dc4f7b72b5c110c444d875c1b0711171a91c39b64d51121f091afd2706a112cc64d4f5e65c411379bc4a59c2d4d114270f7b5e86fd8114d45e6839f96ab11581a91121dcb841162eef764bef8a0116dc3197edec8c3117896f763d8a73911836a911707bfe2118e3de69bc6ff36119910f7f571124911a3e3c5276066d511aeb64e34ef2b3f11b9889321774e9b11c45a93f05280b611cf2c50a4da321811d9fdc94267940e11e4cefdcc5398af11ef9fee45f6f2e011fa709ab2aa165e1205410315c537c11210112772a04c86121ae107cc930b0f1225b0a426f4eaad12307ffc851d23ac123b4f10ea62af4c12461de15a1c47d21250ec6dd7a0688b125bbab666454dd1126688bb0960f5131271567bc4491cd8127c23f89a5344c81286f1318ed4adb51291be26a5225999129c8ad7e0910ba512a757454475483e12b2236ed423550f12bcef5492ef390212c7baf6842cbc5112d28654ab2f688512dd516f0b4a888112e81c45a7d1288312f2e6d88416163012fdb127a36be09713087b330924d836131344fab8930f02131e0e7eb508586d1328d7bf01d6496c1333a0bba24e387d133e697499c13dac134931e9eb80329b1353fa1b9adbb289135ec209ab241a53136989b41fa9887e1374511afbbbdd41137f183e42aaba821389df1df7c583e11394a5ba1e5b5ec2139f6c12b9bb324b13aa3227cd33a77013b4f7f95c1328f613bfbd8769a7e37b13ca82d1f93fc57d13d547d90e287f5c13e00c9cabaf836413ead11cd52205cf13f595598dccfcd314005952d8fd209e140b1d08b9feeb621415e07b341e995c1420a3aa4aa828d6142b669600e75a2e1436293e5a27afe11440eba359b46e88144badc502d89ce714566fa358df03ef1461313e5f122ec2146bf29618bc6abd1476b3aa8927c77d1481747bb39e16e2148c35099b68ed1b1496f55443d1a0a414a1b55bb0214a5514ac751fe3a0c55e14b734a0e198af5b14c1f3dead51684814ccb2d94a13129714d77190bb25932e14e2300503d0916d14ecee36275b773714f7ac24290d70f9150269cf0c2d6da7150d2736d4021ecf1517e45b83d1f8971522a13d1ee331c1152d5ddba87bc3ba15381a3723e16a971542d64f9459a51f154d9224fd29b4d215584db761969ded15630906c4e5276f156dc4132a59db2215787edc953905a01583396308c6b656158df3a68846bf8e1598ada716fcb67315a36764b82bf31815ae20df6f17907c15b8da173f026c9215c3930c2b2f284715ce4bbe36e0278515d9042d6557913b15e3bc59b9d74f6715ee744337a10f1215f92be9e1f640601603e34dbc181691160e9a6ec94788081619514d0cc54e4e162407e889d1e61f162ebe4143ad8f66163974573d984d4d16442a2a7ad1e63f164edfbafe99e3e716599508cc2f934316644a13e6d204a0166efedc51c00ba11679b36210383f4b168467a52578fa05168f1ba594c0599f1699cf63614c3f5816a482de8e5a4fe816af36171f27f37d16b9e90d16f255cb16c49bc078f6660916cf4e314870d70016da005f889e1f0716e4b24b3cba781116ef63f46801dfad16fa155b0db017111704c67f3100a31b170f7760d52ecc5a171a27fffd759f161724d85cad0feb4e172f8876e73844c6173a384eaf2903081744e7e4081c416c174f9736f54bdf1f175a464779f17f261764f51599468862176fa3a15684259e177a51eab4e3458c1784fff1b79c9ad0178fadb661e89c05179a5b38b6ff83c017a50878ba19509a17afb5766e6dc53317ba6231d734683817c50eaaf7a4846c17cfbae1d2f528a717da66d66c5d27e317e51288c713194017efbdf8e64d580617fa6926cd4203af180514127f26ffea180fbebbff31f4a4181a692350984e0a18251348768f3c92182fbd2b744bb4fe183a66cc4d0270671845102b03e7ec38184fb9479c306a43185a6222190ff0b818650aba7dba4a35186fb310cd6305c7187a5b250b3d76f1188502f73a7cb5b2188faa875e539e8a189a51d579f4d28118a4f8e19092b72918af9faba55f76ab18ba4633bb8cffc718c4ec79d64d05d918cf927df8d100e318da3840264a2d9218e4ddc061e98d3e18ef82feaedfe5f818fa27fb105dc28d1904ccb589937287190f712e1db10a37191a1564cfe662bc1924b959a3631a07192f5d0c9b5692de193a007dbaeff4e61944a3ad055e2ca7194f469a7dcfeb921959e9462773a80419648bb005779d53196f2dd81b09cbca1979cfbe6b57f8b619847162f98fae69198f12c5c8de3c3f1999b3e6dc70b6a719a454c63773f72219aef563dd149c5219b995bfd07f09f819c435da14df68fc19ced5b2ad61a77519d975499d3178ab19e4149ee77a552119eeb3b28f677a9319f952849823ec071a03f11504da71c91a0e8f63d8b599731a192d7116dfb5f71a23cb3cc282dfa11a2e68c6dec8f41a1a39060f6edb96741a43a31675e42f2c1a4e3fdbf70bec2e1a58dc5ff57bc0de1a6378a2745c661e1a6e14a376d65a4f1a78b0630011e15c1a834be1133704bd1a8de71db36d937a1a988218e3dd223a1aa31cd2a7ad0b391aadb74b02046e611ab85181f60a313d1ac2eb7786e4ff0c1acd852bb7bb48bf1ad81e9e8bb345031ae2b7d005f2f0451aed50c029a00cb61af7e96ef9e022551b0281dc79d87eec1b0d1a08acae36221b17b1f3958621771b22499d3784e04a1b2ce10595ced7e71b37782cb38833811b420f1293d4e4411b4ca5b739d8a1461b573c1aa8b6e7af1b61d23ce392fa991b6c681ded8fe32f1b76fdbdc9d070a71b81931c7b77384d1b8c283a05a695851b96bd166b80a9d21ba151b1b0275cdb1babe60bd6bc5c741bb67a24e2611c9b1bc10dfcd636d78a1bcba193b55e8daf1bd634e982f905bf1be0c7fe4226ccaf1beb5ad1f60835c41bf5ed64a1bd5a901c007fb648661aff1c0b11c6ed221d561c15a3969310ce3d1c2035253d5160c41c2ac672ef02ce671c35577fab43d7121c3fe84b7533012c1c4a78d64fee99981c5509203e94b3ba1c5f9929444329801c6a28f164179b671c74b878a12f707d1c7f47befea7d6691c89d6c47f9dc1721c946589272dec811c9ef40cf874d9291ca9824ff68ecfad1cb410522497df021cbe9e1385abdcd81cc92b941ce665a01cd3b8d3ed62dc8d1cde45d2fa3c6b9c1ce8d291468e039d1cf35f0ed5725c341cfdeb4baa03f3dd1d087747c75d0ff91d1303033097bcca1d1d8e7de8cdcd811d2819b7f318dc3d1d32a4b152924a141d3d2f6a0a533f181d47b9e21d74aa5b1d5244198f0f41f81d5cce10623b83121d6757c69a11b1e01d71e13c39a9d9b11d7c6a71441bccec1d86f365bc7f251f1d917c19a5eb42fb1d9c048d03774e601da68cbfd83a36601db114b2274ab1441dbb9c63f3bf3c8f1dc623d540ae1d0e1dd0ab06112d5ecc1ddb31f66852d52b1de5b8a649341ad81df03f15b6e691de1dfac544b47f639f1e054b33451380e61e0fd0e16bb7a1e51e1a564f2b8046381e24db7c8781b4f11e2f606982cffc9d1e39e516207ef3431e44698263a2366f1e4eedae4f4d2b341e597199e692fe371e63f5452c86a3af1e6e78b0243ad7691e78fbdad0c21cd31e837ec5352ebf001e8e016f5492d0a91e9883d932002c391ea30602d08873cb1ead87ec333d11361eb809955d2f360f1ec28afe516fdbaf1ecd0c27130fc3381ed78d0fa51f759c1ee20db80aaf439e1eec8e2046cf45df1ef70e485c8f5cdb1f018e304eff30f41f0c0dd8212e32751f168d3fd62b99991f210c677106668e1f2b8b4ef4cd617b1f3609f6648f1a891f40885dc359e9e01f4b0685143befb71f55846c5a4314521f600213987d08081f6a7f7ad1f7434b1f74fca209bf06ab1f7f798942e15adf1f89f630806b10c31f947297c568c1651f9eeebf14e6ce081fa96aa671f160261fb3e64ddf94697a1fbe61b560dba4011fc8dcdcf8d292041fd357c4aa847e1a1fddd26c78fc7b2d1fe84cd4674564801ff2c6fc7869ddb81ffd40e4af7452db2007ba8d0f6ef858201233f59b63cb0f201cad1e565c9053202726074362d5ef20319eb0657ff22f203c1719bfbd03de20468f435522f2562051072d28ba6d7b205b7ed73d8bedc52065f641969fb44920706d6c36fdcab3207ae45721ae035920855b0259b7f937208fd16de2230ff6209a4799bdf673f220a4bd85f0391a4320af33327bf1c0ba20b9a89f6426edee20c41dccabdef13e20ce92ba561fe2d520d9076865efa3b220e37bd6de53ddaa20edf005c252037320f863f514ef50a02102d7a4d930c9b1210d4b15121b3c102117be45c2b33e1a21223136edfd2f20212ca3e896fd37772137165ac0b7486f2141888d6e2f1c61214bfa80a26836b421566c346065e3df2160dda8ab2b396d216b4edd85bb160b2175bfd2f318218221803088f644ccc3218aa0ff924351eb21951136ca15b447219f812ea0bdc05921a9f0e7193d0be221b460603694f5dd21becf99fbc6a69021c93e946bd30f8a21d3ad4f89baeba821de1bcb587ebf1e21e88a07db1ed77b21f2f805149b4bab21fd65c307f3fbff2207d341b82892342212408128388175221cad815b23065f22271a4253e7270b223186c41583b30e223bf306a2f7438422465f09ff403b0e2250cace2d5cc5de225b3653304ad9b52265a1990b0835f322700c9fc092638e227a776753e6b5252284e1efc80246f9228f4c391fe1fefb2299b6435e828ccf22a4200e86e069cc22ae899a9bf7d90a22b8f2e7a0c4e75f22c35bf598436b6a22cdc4c4856f059322d82d546b43201422e295a54cbaeeff22ecfdb72cd1703e22f7658a0e816b9b2301cd1df4c572c9230c3472e297e16223169b88daf2dcee2321025fe0d054f1232b68f7f72a02df2335cf5120f96a332340356b6137d866234a9b46bade64ff235500e330e5f18e235f6640c64729bd2369cb5f7dfa83462374303f5af83e06237e94e0603863fc2388f94290b2c94f23935d65ef5f0c50239dc14a7f34958323a824f0432a97a323b288573e380fa823bceb7f7353c4cb23c74e68e574488823d1b113978ff6a923dc137f8c9cf54823e675acc79134d423f0d79b4b62701623fb394b1b062c3724059abc3971b8c4240ffbeea99a2fb3241a5ce26e7475692424bd978af538c0242f1e0e0210f30924397e45d6bbe8132443de3f0bea2631244e3df9a48f863c24589d75a39fab9c2462fcb30c0e0448246d5bb1e0cdc8d12477ba7224d1fc62248218f3db0d6cc8248c77370672b2772496d53ba9f4308a24a13301c88414d124ab9089651457ce24b5edd28296bcbf24c04add23fcd1a024caa7a94c37ef3224d50436fe3938fd24df60863cf19d5b24e9bc970b51d57524f418696c4a655124fe73fd62cb9bcd2508cf52f1c592ad25132a6a1c282e9c251d8542e4e31f2e2527dfdd4ee5deec25323a395d1fb353253c9457127facdc2546ee3671f4a700255147d77e6d483e255ba13a3ad8021d2565fa5eaa23113625705344cf3c7d34257aabecad1218dc258504564691820f258f5c819ea821d52599b46eb8432c5c25a40c1d964fa0fd25ae638e3bba4a4825b8bac0ab6fbdfd25c311b4e85c5d1e25cd686af56c53ea25d7bee2d58b99e925e2151c8ba5f1ea25ec6b181aa6ea0f25f6c0d58579dbcd26011654cf09ebf2260b6b95fa420aad2615c0990a0cf38d2620155e01552d8d262a69e4e3050b142634be2db206a9f8263f12387143f38d2649660523a69c9d2653b993cc182577265e0ce46d81d9ec26685ff70accd15c2672b2cba6e1eeb6267d056244a9e07c268757bae70d20cb2691a9d590f3f55e269bfbb245466f9526a64d5106ec6c7626b09eb1d8cd94b626baefd4bdd15cbd26c540b9b8df04a726cf9160ccdd985026d9e1c9fcb3ef5326e431f54b48ad1026ee81e2bb8240b326f8d1925046e538270321040c7ca16e270d7037f30948002717bf2e06d2777427220de64abd9a36272c5c60c1afe6982736aa9d6e8e5eda2740f89c543dd12f274b465d75a2d7bd275593e0d5a1d8ac275fe126771f061c276a2e2e5cfe5e3a27747af88a23ab39277ec7850172835c278913d3c5ce48fa27935fe4da1a2a82279dabb84139228427a7f74dfe0df7ad27b242a6137b3cd727bc8dc08463510227c6d89d53a85f6627d1233c842c5f6b27db6d9e18d114b727e5b7c214780f2f27f001a87a02aafc27fa4b514c521091280494bc8e4734ac280eddea42c2d863281926da6ca5892128236f8d0ecfa0ac282db8022c21452e28380039c77a693828424833e3bacbc2284c8ff083c1f8372856d76faa6f467728611eb15aa1dada286b65b59738a6362875ac7c631265e5287ff305c10da3cb288a3951b408b65428947f603ee1c082289ec5316476b1ec28a90ac527a546c228b3501b8b4b07d728bd953492454aa128c7da103f71313f28d21eae95abaa8128dc630f97d171e828e6a73348bf0fad28f0eb19ab50d8c528fb2ec2c262eeea2905722e90d14099290fb55d1977891a2919f84e5f31508629243b0264d9ebca292e7d792d4c7cad2938bfb2bb63f1d5294301af11fb06c7294d436e33ec43f4295784f02411feb82961c634e546595f296c073c7a63432c29764806e642785e298088942bbd8230298ac8e44dadb6e4299508f74eec39c5299f48cd3251fb2b29a98865fab7b87f29b3c7c1aaf5fc4329be06e045e51e1529c845c1ce5d42b329d2846647365c0229dcc2cdb348290c29e700f8156a361229f13ee57073dc8229fb7c95c73c43052a05ba091c9a5d802a0ff73f7364ed1c2a1a3438ce7280462a2470f5309972b82a2ead749cafed7a2a38e9b7158be6ec2a4325bc9e0322c22a4d618538eb32142a579d10e91973592a61d85fb16312712a6c1371949d08a82a764e46959c1cbb2a8088deb734e2dc2a8ac339fc3bbcb82a94fd586784d97b2a9f3739fbe435d42aa970debc2d9bfb2ab3aa46ab34a3b52abde371cbccb25a2ac81c6020c8fad52ad25511acfc7daf2adc8d86733a09122ae6c5be765438c92af0fdb9b91d764b2afb35783e67f8bb2b056cfa0905c4ef2b0fa43f1bc8ad752b19db47798252972b2412132504225e2b2e48a2211f589b2b387ef470a4fee42b42b50a1665eca42b4ceae31532c7132b57207f6fdc01462b6155df2931dc292b6b8b02440466902b75bfe8c3237d2f2b7ff492a95ecaa62b8a28fff985c7852b945d30b667ba512b9e9124e2d3b7842ba8c4dc8198a1982bb2f857958529062bbd2b962167cc512bc75e98280ed8022bd1915dac4866b62bdbc3e6b0e2611b2be5f63338aa7dfc2bf02843466e423b2bfa5a16dcfb00e12c048badff1ddb1f2c0ebd08afa3c04c2c18ee26f1596df22c231f08c70b6fcf2c2d4fae33861fdb2c3780173995a64b2c41b043dc05f9962c4be0341da2de7c2c560fe80137e8042c603f5f8990778a2c6a6e9ab977bcbd2c749d9993b8b5a52c7ecc5c1b1e2ea82c88fae25272c28f2c93292c3c80da8a2c9d5739dc12ae342ca7850b33f2439a2cb1b2a046e96f3d2cbbdff917c1d4162cc60d15a944e39f2cd039f5fe3bddd32cda669a196fd1332ce49301fda99acf2ceebf2dadb1e6452cf8eb1d2c512dc92d0316d07c4fba262d0d4247a075a2c92d176d829b8acdbf2d2198817056efbe2d2bc34421a18c262d35edcab231f5082d40181524cf4b292d4a42237c407e0c2d546bf5bb4c4bea2d5e958be4b941c62d68bee5fb4dbb662d72e80401cfe35d2d7d10e5fb05b30d2d87398be9b4f2af2d9161f5d0a339522d9b8a23b295ece62da5b2159252423d2dafd9cb729d3d0d2dba0145563baffa2dc428833ff23c972dce4f853285536c2dd8764b30b933fa2de29cd53d51ecbd2decc3235b135b382df6e9358cc12bf12e010f0bd51eda792e0b34a636efb1712e155a04b4f6ca912e1f7f2751f70ea42e29a40e10b335972e33c8b8f3edc6762e3ded27fe6917762e48115b32e74df12e523552942a5e772e5c590e24f40cc72e667c8de805ebd92e709fd1e0215de32e7ac2da1007945c2e84e5a67a798ffe2e8f0837223820cf2e992a8c0a03e6252ea34ca5349d4ea72ead6e82a4c498542eb790245d39d0872ec1b18a60bcd3fc2ecbd2b4b20d4ed42ed5f3a353eabc982ee01456491468412eea34cd94496c392ef455093848b2622efe750937d0f4182f0894cd95a0ba382f12b45654765d232f1cd3a3771004c32f26f2b5002ba88c2f31118af2870f892f3b302550dfd0582f454e841df351322f4f6ca75c7ec7ee2f598a8f0f3f3a092f63a83b38f17ca62f6dc5abdc5234932f77e2e0fc1dd6522f81ffda9b10a6192f8c1c98bbe6b7d72f96391b615bef392fa055628e2bffb22faa716e45126c742fb48d3e88ca88852fbea8d35c0f76b72fc8c42cc19c29ae2fd2df4abc2b63ed2fdcfa2d4e77b7cd2fe714d47b3b878f2ff12f40453105552ffb4970af12332c30056365bb98e313300f7d1f6d7eb6f93019969dc77d20c63023afe0cc4d625e302dc8e87ea88da53037e1b4e14784853041fa45f6e2f8ef304c129bc2336ce330562ab645f132733060429584d46bc7306a5a3981950b23307471a23eead2e9307e88cfbf8d55a030889fc20633f5f33092b6791595e6c0309cccf4f06a2b0f30a6e3359967962330b0f93b1344cb7330bb0f0560b83eb930c52494847833ee30cf39e8813abf5330d94f0159b5c57330e363df109efb2a30ed7881a8abe5a730f78ce92491da703101a1158705ff69310bb506d2bd4ad83115c8bd0a6c8364311fdc3830c840233129ef784884e8943134027d5456b4ab313e154756f1acd4314827d65309a9f331523a2a4b52556c315c4c43427f292831665e213b436f9831706fc4385243b7317a812c3c5e9115318492594a1b13d3318ea34b643a58ae3198b4028d6ebd0031a2c47ec86a6ec431acd4c017df6c9d31b6e4c67e7f85d831c0f491fefc5a7231cb04229c075b1931d513785851c93731df2293368cb6ee31e931733969072131f3401863976d7b31fd4e82b7c86e6c32075cb238ac5f3332116aa6e8f365e1321b7860cb4d795d322585dfe26a6168322f932430f9b6a13239a02db9aae28b3243acfc7f2d1f8f324db990842f79023257c5e9cb60cb293261d208576fc33f326bddec2b0adf723275e99548e06ef2327ff503b39e91ee328a00376df3399932940b307a8c2834329e15eedc16f10832a820729540f87432b22abba8b773eb32bc34ca192769fd32c63e9de93db25932d048371ba6f5cf32da5195b30fae5632e45ab9b224271632ee63a31b907c6232f86c51f2009bc3330274c6382043fa330c7cfff09b0506331684ff1e1c402633208cc3c34f27e1332a944de2dec00233349b9d7f75ddaa333ea2b29bbf27433348a98d3a6514963352b02d5e11eec0335cb693096fd0423366bcbe3f28a4fd3370c2af01e62a3b337ac8655451eeaf3384cde139155280338ed322b2d987463398d829c447901333a2dcf67008417533ace188b8c4417b33b6e5e0a12407ba33c0e9fe2bcfdd4e33caede15b6fdce333d4f18a32abf2b533def4f8b42bdc9633e8f82ce29729f633f2fb26c0953bdd33fcfde650cd44fc3407006b95e649a7341102b692871fdd341b04c749566f503425069dbcfab161342f0839f01a312c3439099be55b0b8734430ac39f632f09344d0bb120d85c0e34570c646c6024ba34610cdd849fecfd346b0d1c6c3cea9934750d2125dc2525347f0cebb422761134890c7c19b488ab34930bd25936da22349d0aee754db98e34a709d0709d47ec34b108784dc9782b34bb06e60f760f2b34c50519b846a3c334cf03134ade9ec734d900d2c9e13b0634e2fe5837f1855534ecfba397b25c9234f6f8b4ebc671a13500f58c36d0477b350af2297b72332b3514ee8cbc4e5bd5351eeab5fc06bab63528e6a53d3d1b313532e25a82931ac7353cddd5ceaa29283546d9172423882d3550d41e85a04be2355aceebf5c15a863564c97f77276c94356ec3d90c730cc23578bdf8b844980b3582b7de7d3c3dad358cb18a5df9ff303596aafc5d1db06b35a0a4347d46f78835aa9d32c1154d0635b495f72b27fbc135be8e81be1e20ee35c886d27c96ac2b35d27ee969305f7b35dc76c68689cf4a35e66e69d741627735f065d35df5524f35fa5d031d43aa9c360453f917ca49a2360e4ab55026e02136184137c8f6f1613622378084d7d332362c2d8f8666adec36362364d0407c7d3640190065020c61364a0e624747fdb33654038a79aec324365df878fed2a20b3667ed2dd94fb2613671e1a90bc1dec7367bd5ea98c4e48d3685c9f282f453b3368fbdc0cceb8eef3699b1557945cbae36a3a4b08a9e121f36ad97d2038f3d2c36b78ab9e6b3fa8a36c17d6836a6cab436cb6fdcf60200f636d56218275fc36a36df5419cd5a0b0236e945e1ea8aa38b36f33770818b2bad36fd28c594f514f6370719e12761a3d537110ac33b69efa9371afb6bd3a6e2ba3724ebdaf2b13a47372edc109b2186833738cc0ccf902a9c3742bbcf92955cbe374cab58e6c9261837569aa8cec362e1376089bf4d1bc258376a789c6469c6ce377467401744c5a6377e55aa6843e757378843db59fe2778379231d2ef0a54bb379c1f9129ff10f737a60d160d72d12a37affa619bfbdd7d37b9e773d830514837c3d44cc4a61b1637cdc0ec63f2fcac37d7ad52b8ac8b0637e1997fc5682e6237eb85738cbb224237f5712e113a756e37ff5caf557b09fb380947f75c11954c381333062792a018381d1ddbba92866e3827087817a577b93830f2db415f76c4383add053a5459ba3844c6f60517ca33384eb0ada43d453138589a2c1a581b223862837169fb6fec386c6c7d95ba3aec38765550a02746fb38803dea8bd53270388a264b5b566f2638940e73113d4282389df661b01bc57238a7de173a83e47738b1c593b3075fa438bbacd71c37caa238c593e178a68cba38cf7ab2cae4e0d038d9614b1583d56f38e347aa5b144cc938ed2dd09e26fcbd38f713bde14c6ed73900f97227150059390adeed7210e23b3914c42fc4d01932391ea93921e27db339288e098bd7bbf7393272a1053f53fb393c56ff90a8998c39463b2530a2b44539501f11e7bc9f94395a02c5b8852abf3963e640a58af8e8396dc982b15c810f3977ac8bde880e1a39818f5c2f9bbed3398b71f3a72585f33995545247b32a1f399f367813d245f239a918650e1047fd39b2fa1938fa72cb39bcdb94971ddcea39c6bcd72b0770e639d09de0f743ed5639da7eb1fe5fe4db39e45f4a42e7be2339ee3fa9c767b3f139f81fd08e6bd51e3a01ffbe9a8004a03a0bdf73ee2ff9893a15bef08c073f0d3a1f9e34769134893a297d3fb0590d843a335c123be9d1b33a3d3aac1bce5cfd3a47190d52915f7f3a50f735e2bd5d933a5ad525cedcafce3a64b2dd197983073a6e905bc51dd85f3a786da1d453853d3a824aaf49a433583a8c2784279960b53a96042070bc5fb53a9fe0842796570d3aa9bcaf4eb041d33ab398a1e892ef7c3abd745bf7c703e43ac74fdd7ed4f7503ad12b26804516723adb0636fe9f826d3ae4e10efc6c30d73aeebbae7c32ebc33af89615807b51be3b0270440bccd5d63b0c4a3a20aebf9d3b1623f7c1a82b2f3b1ffd7cf14009333b29d6c9b1fd1ee13b33afde066606053b3d88b9f1012d033b47615d7454d6d93b5139c892e71b273b5b11fb4f3de6313b64e9f5abdef8e23b6ec1b7ab4fe8d03b7899415016203e3b8270929cb6de273b8c47ab93b736393b961e8c379c10de3b9ff5348aea2b413ba9cba49026174d3bb3a1dc49d43bb33bbd77dbba78d3f23bc74da2e497f0533bd12331cab575f23bdaf8886f551ec53be4cda6d4fa79973beea28cfe28ea123bf8773aed63a8c33c024bb0a52dc31b3c0c1fee280a1b733c15f3f3787b69143c1fc7c0990438363c299b558c26ea083c336eb25465b4ac3c3d41d6f442a3483c4714c36e3f95fd3c50e777c4de41f13c5ab9f3faa031553c648c381206c3623c6e5e440d932c623c783017efc675b23c8201b3bb217dc93c8bd3177224f8363c95a44317516da63c9f7536ad273bee3ca945f2362696063cb31675b4cf840e3cbce6c12ba1e35a3cc6b6d49d1d666d3cd086b00bc194fe3cda56537a0dcc013ce425beea813da63cedf4f25f9af1603cf7c3eddbd9c3e43d0192b161bc67323d0b613cf3c162983d152f90946712b13d1efdac462ba96f3d28cb900b8d2e1d3d32993be7097d5e3d3c66afdb1e493a3d4633ebea4919183d5000f0170749ca3d59cdbc63d60d893d639a50d3326c023d6d66ad679942513d7732d2238743083d80febf0978f6393d8aca741beab96c3d9495f15d58bfb13d9e6136d03f119b3da82c4477198d493db1f71a5463e6633dbbc1b86a99a6263dc58c1ebc362b613dcf564d4bb4aa7e3dd920441b902d803de2ea032e43940e3decb38a864993723df67cda261cb69a3e0045f210375e253e0a0ed24713c05c3e13d77acd2be93f3e1d9feba4f9ba813e276824d0f6eb933e313026539d09a33e3af7f02f6577a03e44bf8266c96e3e3e4e86dcfc41fbff3e584dfff248052c3e6214eb4b5443e43e6bdb9f09df48183e75a21b306177933e7f685fc1530dfa3e892e6cbf2c1cd73e92f4422c648b913e9cb9e00b74177a3ea67f465ed253d03eb0447528f6a9be3eba096c6c5858633ec3ce2c2b6e74d53ecd92b468afea213ed75705269379553ee11b1e678fb97f3eeadf002e1b17b33ef4a2aa7cabd70f3efe661d55b810bb3f082958bbb5b3f23f11ec5cb11a86023f1baf29385c22523f2571be53effa633f2f341c064b55d73f38f64251e352713f42b831392ce41f3f4c79e8be9cd4f43f563b68e4a7c5353f5ffcb1adc22b583f69bdc31c6054083f737e9d32f6622a3f7d3f3ff3f84ee13f86ffab61d9e98e3f90bfdf7f0ed7d83f9a7fdc4e0a95af3fa43fa1d140754e3fadff300b239f403fb7be86fe2712613fc17da6acbda3e83fcb3c8f1959ff613fd4fb40466ea6be3fdeb9ba366df24b3fe877fcebca10bf3ff2360868f507373ffbf3dcb060b1424005b179c47ec0d9400f6edfa7c0be6e40192c0e5c9808e94022e905e575d5b0402ca5c644cb30a74036624f7d08fc3340401ea1909ff1454049dabc82009f54405396a0539b6c65405d524d07e0951240670dc2a1402c874070c901222a1c8d407a84088d0e258640843ed8e45bde77408df9722a82b5064097b3d461f1ed8540a16dff8d18a2ee40ab27f3ae65c6eb40b4e1b0c84821da40be9b36dd2e52ce40c85485ef86cf9440d20d9e01bfe4b640dbc67f1647b58340e57f292f8c3c0940ef379c4ffb492340f8efd87a0284784102a7ddb00f6c7d410c5fabf48f567b4116174349ef6e93411fcea3b29cb7c0412985cd31040bdc41333cbfc7921ba3413cf37b78b36eb54146aa0046d4639f4150604e34612fd6415a166543c5dfc54163cc45776e56c6416d81eed1c64f2f4177376155395a4f4180ec9d0432e073418aa1a1e11e20ef4194566fee663218419e0b072e76015141a7bf67a3b8530941b173915097c2c041bb2784377ec30a41c4db405ad79d9641ce8ec5bd0c732b41d8421460873bb241e1f52c47b1c63841eba80d74f5b8ee41f55ab7eabc913341ff0d2bab6fa3904208bf68b9781bc14212716f173efcb9421c233ec72d20a24225d4d7cbab38e3422f863a2721ce2242393765dbf940484242e85aec99c688424c99195b6b6f5e425649a12ad62092425ff9f25d4197414269aa0cf51567dd427359f0f4b8fe31427d099e5e939d634286b915350c5ff9429068557a8a37e0429a175f3173ee6b42a3c6325c30245642ad74cefd2551cd42b7233516b9c66d42c0d164ab53a94b42ca7f5dbd58f8f142d42d204f2f8b6b42dddaac633d0e4142e78801fbe7068242f135211b92d0c142fae209c4a5a12043048ebbf984834c430e3b37bc945a864317e77d1039e1a54321938bf6d9ab16432b3f6472d820e84334eb06869984c7433e96723481f002434841a77ef553924351eca66857781a435b976ef30bfdeb4365420121765d08436eec5cf5f9e5294378968272f9bdc2438240719ad8e602438bea2a6ffa34d6439593acf4c058f1439f3cf92b8dd8ce43a8e60f16c512b143b28eeeb8c83cac43bc379813f964a643c5e00b2aba705843cf8847ff6d1d5543d9304e9473010e43e2d81eec2d88d143ec7fb908fdf9d343f6271ced45712b43ffce4a9b64e3e14409754215bd1ee644131c035eaec71d441cc28e789a5961442668e365e02a8344300f0228e067524439b4eac3fb149b44435a9d39900f2e444d00198bff0be24456a55fbda7979944604a6fd0e917424469ef49c822c7dd447393eda5b3be7e447d385b6bfae8534486dc931d570aa344908094bc26c2d7449a24604ac8867944a3c7f5cb9aa33744ad6b5540fb3eee44b70e7ead4857a344c0b17212dfc38e44ca542f741f311b44d3f6b6d36426ec44dd9908330c03e044e73b239573ff1344f0dd08fcf927e444fa7eb86bf865f645042031e4ce7939450dc17569d7f9e245176282fd71587e4521035aa1f6dde8452aa3fc59c4ab54453444682736ba50453de49e0ca8dcc74547849e0c76bd074551246828fbddbf455ac3fc64939a0d4564635ac1992572456e028342678be64577a175e959b1cd45814032b8ca5407458adeb9b31407e945947d0ada913b46459e1b26319c347445a7b90bba8f124945b156bb77c3cc2445baf4356b9431ee45c491799859ec2245ce2e88006e7bc745d7cb60a62b3a7c45e168038be95a7a45eb0470b401e69245f4a0a820cdc23745fe3ca9d4a5a97f4607d875d1e231264611740c1adbc691461b0f6cb1eaafd24624aa9799670bae462e458cd3a8d1994637e04c6307d1c546417ad649dbb51a464b152a8a7bfd404654af49274004a1465e4932227efe6b4667e2e57e8ff69746717c633dc9d1e6467b15ab62834ded4684aebdef130110468e479ae5cf5a8b4697e042490ea27546a178b41b26f9c046ab10f05e6e5a3f46b4a8f7153a96a946be40c841e15a9d46c7d863e6b82aa346d16fca0614643446db06faa24b3db746e49df5bdb1c68c46ee34bb5a9ce70746f7cb4b7b61607c470161a62253cd3a470af7cb51c8a09747148dbb0c1426eb471e2375538a85994727b8fa2a7fbb1247314e4993479ed5473ae3639035e17547447848239e0c9e474e0cf74fd383124757a171172980b6476135b57bf31a8c476ac9c480833ebd47745d9e272cb497477df14272421c97478784b16415f065479117eafefa82de479aaaef4542001147a43dbe393e6d4947add057dd41a90d47b762bc339d6b2047c0f4eb3ea3448b47ca86e500a49f9d47d418a97bf2bfed47ddaa38b2dec26147e73b92a7b99d2e47f0ccb75cd41fdc47fa5da6d47ef34d4803ee61110a99bb480d7ee614c76ebc48170f35e205a74c48209f507b1551c7482a2f35e24655f54833bee619e87505483d4e61244b49964846dda703be47bd48506cb7ba90bcfc4859fb934b11d05648638a39b7908245486d18ab025bacc14876a6e72dc2034c488034ee3c1212e64889c2c02f9a421c4893505d0aa8d107489cddc4cf8bd95148a66af780914e3648aff7f52006fc8948b984bdb03a8ab948c31151337978cd48cc9dafac11207448d629d91c4eb4fa48dfb5cd867f435948e9418cecefb22f48f2cd1751ecc1ce48fc586cb7c30c354905e38d20bf0519490f6e788f2cf9e84918f92f055911ca492283b0858f4da6492c0dfd121b882549359814ad4975b6493f21f75964a4904948aba518b87cb34952351ded903ff3495bbe61da3709f449654770e0f7d030496ed04b041d61fb497858f045f268814981e160a8c166d6498b699c2ed4b9ea4994f1a2da769895499e7974adf1139a49a80111ab8e15a849b18879d597635e49bb0fad2e569b5049c496abb815360749ce1d75751c860749d7a40a67b5b7d149e12a6a9229d1e549eab095f6c1b4cd49f4368c97c61b1149fdbc4e777f994d4a0741db98369e254a10c733fc33724e4a1a4c57a5be38944a23d146971eedda4a2d5600d29d691e4a36da865a815b7a4a405ed73112502e4a49e2f35897ac9a4a5366dad358b0484a5cea8da39c74ef4a666e0bcba9ee744a6ff1554dc7eaea4a79746a2c3d129e4a82f74a694fe8134a8c79f60746c8094a95fc6d0867e97d4a9f7eaf6ef95db14aa900bd3d4110294ab282967584c6b64abc043b1a0a21704ac585ab2d169ac24acf06e6b0ef876a4ad887eda7da16774ae208c0141b51564aeb895df7f81bce4af509c755b534064afe89fc2f9732874b0809fc87e28a424b1189c860db888e4b1b095fbcc655324b2488c29de6f2634b2e07f106813cc84b3786eaf8d8eb814b4105b0773190254b4a844183ce96c94b54029e20f346004b5d80c650e2bee44b66feba15dffd114b707c79722dd6b14b79fa04680efc764b83775af9c5f9a84b8cf47d2995341b4b96716af9beec414b9fee246c853d214ba96aa9842a1c624bb2e6fa42ef5a474bbc6316ab16a1bc4bc5defebee1784f4bcf5ab280913e3a4bd8d631f2672e664be2517d16a45e664bebcc93ef89be894bf547767f5819ce4bfec224c85015f34c083c9eccb2336e4c11b6e48ebecd794c1b30f610b61a124c24aad354d829fb4c2e247c5d64e8c34c379df12c9c1cc34c411731c4bd67284c4a903e280843f04c54091658bc09f04c5d81ba5917eada4c66fa2a2b5af3394c707265d1c40a7c4c79ea6d4e91f2f24c836240a40349d44c8cd9dfd45687444c96514ae1c9fe524c9fc881ce9bdcfc4ca93f849d0a2c364cb2b6534f52cfe84cbc2cede7b386f74cc5a3546869eb454ccf1986d3b371b24cd88f852bcd6a234ce2054f72f4ff824ceb7ae5ab6737c64cf4f047d760f3f24cfe6575f91ef0164d07da7012ddc35a4d114f3626d9dffa4d1ac3c8374f934c4d243826467b05c34d2dac5056983af24d37204669e311904d409408829743784d4a0796a2f065b44d537af0cd29e8744d5cee17037f171d4d666109482b18444d6fd3c79d68edb54d794652057374774d82b8a8828564cd4d8c2acb16d952374d959cb9c4a9ab7a4d9f0e748e30baa24da87ffb75a8a5024db1f14e7d4b6b3c4dbb626da752e93f4dc4d358f5f8d64c4dce44106b76c4fd4dd7b4940a0623434de124e3d3e03a6a4dea94ffcb3e2f1f4df404e7f25901714dfd749c4b698cd44e06e41cd8a888244e1053699c4e85aa4e19c2829893f31e4e233167cfb119a94e2ca01943de1de94e360e96f752fff64e3f7ce0ec479b614e48eaf724f3a73d4e5258d9a38eb61a4e5bc6886a5036114e6534037b6f70c04e6ea14ad9238b534e780e5e85a386814e817b3e83263e964e8ae7ead3e26b6d4e9454637a0ea0804e9dc0a877e14cdc4ea72cb9cf90bb304eb09897835311cc4eba0441955e52a44ec36fb807e85b504eccdafadd26e5174ed6460a174f84e94edfb0e5b897ab694ee91b8dc334a4ed4ef28602395b99814efbf0431d418cee4f055a50711b5eb44f0ec42a371dca184f182dd0717d661e4f219743226ea5964f2b00824c25d7154f34698df0d724fb4f3dd26612b6957c4f473b0ab3f80a9c4f50a37bd6cf42344f5a0bb97d6fd5f74f6373c3aa0d3b734f6cdb9a5edac4164f76433d9e0b9d304f7faaad69d2cff64f8911e9c46341834f9278f2afefb2e14f9bdfc82eaac1064fa5466a42c6e4d94faeacd8ee7673374fb8131433eb9cf54fc1791c15586ee04fcadef094eed1c74fd44491b4e08a754fdda9ff775f39bd4fe70f39de9c5c774ff07440ecc94b844ff9d914a4173bd650033db506b73e6b500ca22216da40575016065bd6b10ac2501f6a62486c42ef5028ce356e3c6a3e503231d54a51de2e503b9541dedcd8605044f87b2e0d6e9b504e5b813a1392ce5057be54051f1316506120f3915f99bb506a835fe104ad3b5073e598f63db047507d479ed339e1c85086a9717a285ce250900b10ed3818f750996c7d2e97e9ab50a2cdb640767ee550ac2ebc250264d450b58f8ede6a03f150bef02e6edba10350c8509ad8855d2050d1b0d41d9535b350db10da4039047c50e470ad429e7f9550edd04d26f3397650f72fb9ef64a0f351008ef39e2001465109edfa3552820e51134ccdb7292751511cab6e25d0d183512609db83763d84512f6815d24604a95138c61d146c9cb8514223f14c1657f2514b81927b6f65125154df00a4a3cf50515e3c3bc9df7e6651679943ed4e368f5170f619111b9892517a52bb377321bd5183af2a62802be9518d0b66946ded815196676fcf677986519fc3461597bf8a51a91ee969298bba51b27a59cc4786e051bbd597411c366251c530a1c9d1fc4d51ce8b796893174e51d7e61e1f89a2bc51e1408ff0df969c51ea9acedebec79c51f3f4daeb50e71d51fd4eb418bf83365206a85a693406b4521001cdded7b91b52195b0e7bd3beb15222b41c42511878522c0cf73478a4385235659f54731c7e523ebe14a469189e5248165726830cbc52516e66dce949c7525ac643c9c3fd8452641dedef3b3288526d75654f76d0475276cca9ec9e9b07528023bbc8da33f452897a9ae65119175292d147472aa55d529c27c0ed8e109b52a57e07dba26f8f52aed41c138eb3e552b829fd9779ac3752c17fac698a041352cad5288be643fd52d42a7200b4d17252dd7f88ca1beee952e6d46cea41bbd952f0291e634c34ba52f97d9d3761330b5302d1e968a66d4e530c2602f9417714531579e9eb57c0f8531ecd9e410e98aa5328211ffc8b28e85331746f1ff27989533ac78bad696f8053441a75a714ccd7534d6d2d0f1930bc5356bfb1e79b177b5360120432beda8953696423f2a8b0825372b611297cad2c537c07cbd95ec17a538559540472bb94538eaaa9acdc46d35397fbccd4beebc853a14cbd7e3e103d53aa9d7bab7cf73953b3ee075e9ec10153bd3e6099c66b2253c68e875f16d06853cfde7bb0b2a8ed53d92e3d90bc8a1353e27dcd0156e68b53ebcd2a04a40e5953f51c549cc62ed553fe6b4ccbdf52ab5407ba12941161e5541108a5f77e21e8541a5706f847357a5423a535988e1cc5542cf331da743555543640fbc01aba23543f8e934ba2c3935448dbf87f2d47745452292b5cdb190a545b762be6cce90d5464c2fa1f2345ad546e0f9607fe9a9254775bffa37f30e45480a836f3c52f4a5489f43bfaf099ed5493400ebb21527c549c8baf3677183254a5d71d6f1187d354af225967101bb254b86d6320922bb454c1b83a9db6ed5354cb02dfe09d73a054d44d52eb64af4654dd9793c02b6e8f54e6e1a261105d6154f02b7ed032054b54f975290faecd7e5502bea121a4fad3550c07e70832afd2551550fac575ecb1551e99dc5b8c8f555527e28bcc94535b55312b091aaad214553a735447ed828d5543bb6d5679b991554d0354486ca9a955564b091fe36322555f928bdefad4105568d9dc87cfc84d557220fb1c7ee97f557b67e79f24bf1d5584aea211ddae6f558df52a76c5fa8d55973b80cff9c46a55a081a51f950ad455a9c79767b3aa7255b30d57aa715dcd55bc52e5e9e9bd5155c5984228383f4d55cedd6c677837fc55d82264a9c4d98355e1672af13933f355eaabbf3ff0355055f3f0219804a99055fd3451fb913aa2560678506cb0706f560fbc1ced7cb0da5618ffb780103fc55622432026853f19562b8656e2f5aebc5634c95bb77b6ca5563e0c2ea63034cf56474ecfb12da1445650913eda8d2a215659d37c246825955663158790d7c7e3566c576121f5236956759908d9d928a4567eda7eba9ca62956881bc2c65848b356915cd4ff249b22569a9db5671a067a56a3de640050d1ec56ad1ee0cce122d456b65f2bcee2fcc056bf9f45086e416f56c8df2c7b9ab0d656d21ee22a7fe92156db5e66173566bb56e49db843d2844a56eddcd8b26e7ab356f71bc76520612257005a845dff2d0b5709990f9f21b2275712d7692a9ea27e571c1591028c8e65572553872901e485572e914ba014f1db5737cede69dbe1ba57410c3f886cbdd3574a496efddd6e305753866ccc43b93d575cc338f5b543c95765ffd37c479109576f3c3c6210029957787873a923d8815781b47953983138578af04d638209a357942befdaf63d1e579d6760bc09857c57a6a2a008d07b0557afddadc35f948257b91889edcb273757c253348a2766ee57cb8dad9a8865f257d4c7f52102151757de020b1fa843ba57e73bef988e9fc857f075a28dc8b5ba57f9af240169f09e5802e873f5859a18580c21926c2eda6158155a7f6778b851581e933ae976195c5827cbc4f439c1975831041d89d653b8583a3c44ac5e511e5843743a5de419d4584cabfea079ec885855e3917631e69f585f1af2e11e042c58685222e3501ff6587189217ed9f37b587abfeeb5cd16f45883f68a8a3b0155588d2cf4fe3508545896632e13cc6064589f9935cd121cc358a8cf0c2c172f7358b204b132ec694158bb3a24e3a279c758c46f674049ef7258cda4784af3377d58d6d95805ae9dfc58e00e06728c4ddb58e94283939c50df58f276cf6aee8fae58fbaae9fa92d1cc5904ded34498bda1590e128b4b0fd87f591746121007869b59207967958f0b185929ac8bddb5880a5932df7eea89fe74593c1240be1b4e4c594544d15a783683594e7730c1af54fe5957a95ef5cf26a15960db5bf8e60752596a0d27cd0231f659733ec27431c073597c702bf082abbe5985a1644402cbcf598ed26b70bfd7b15998034178c7657a59a133e65e26ea5459aa645a22ebba8059b3949cc923095459bcc4ae52d9e94159c5f48ec21d4bd759cf243e18fa01c559d853bc597cbadd59e1830985b2061859eab2259fa6519359f3e110a965ea9d59fd0fcaa4fcfdad5a063e539477966c5a0f6cab79e19fb85a189ad25746e3a45a21c8c82eb30b7b5a2af68d02319fc55a342420d3ce08475a3d5183a5938c085a467eb5798d51515a4fabb651c65db45a58d8863049960b5a6205251721be7b5a6b319308597a775a745dd005fb4cc85a7d89dc121197865a86b5b72ea69c215a8fe1615dc47b645a990cdaa17535765aa23822fbc2a9da5aab633a6eb6977b5ab48e20fc5a9ca15abdb8d6a6b837005ac6e35b6fd8c3b35ad00daf59c57f475ad937d2668785b05ae261c49827d25a5aeb8b85f0af40235af4b516722689635afdde761e9647e95b0707a4f806f5045b1030a30080e97f5b1959703a0c5daa5b22820ca6b169585b2baa78487803e65b34d2b3216804395b3dfabd338920c55b47229680e2ef8c5b504a3f0b7ce6235b5971b6d55e59b45b6298fde08e7f045b6bc0142f146a6c5b74e6f9c2f70fe85b7e0dae9e3d43125b873432c2edb7265b905a86330eff055b9980a8f0a78d3b5ba2a69afdbdb3fb5babcc5c5c57a5275bb4f1ed0e7b72515bbe174d162f0cbe5bc73c7c757845695bd0617b2e5ccd035bd9864942e233f95be2aae6b50dea775bebcf5386e540675bf4f38fba6d65765bfe179b51ab69185c073b764ea43a875c105f20b35ca8cb5c19829a81d962b75c22a5e3bc1ef6ef5c2bc8fc6431d3ea5c34ebe47c1647f45c3e0e9c05d081335c47312303648da55c50537976d65b285c59759f6229b77a5c629794c762503b5c6bb959a883b2f15c74daee07914d0a5c7dfc51e68e6bdf5c871d85477e3cb75c903e882c63cccb5c995f5a974209425ca27ffc8a1bbf3b5caba06e06f39bd15cb4c0af0fcc2c135cbde0bfa6a7dd145cc7009fcd88fbe25cd0204f8671b5915cd93fced364173a5ce25f1db6620dfe5ceb7e3c316d67065cf49d2a4687cf8e5cfdbbe7f7b2d4dd5d06da7546efe44f5d0ff8d236404b565d1916fec7a5377b5d2234fafd1fb6615d2b52c6d8b0b5cb5d3470625c5903975d3d8dcd8a194dcc5d46ab0863f222905d4fc812ebe3f0375d58e4ed23ef053a5d6201970e1390435d6b1e10ac51a0285d743a5a00a923f55d7d56730d19eaeb5d86725bd3a3a4805d8f8e145645e0655d98a99c97000e8b5da1c4f497d17f1f5daae01c5ab962925db3fb13e1b6c9985dbd15db2ec8a52f5dc6307243edc69d5dcf4ad92324df775dd8650fce6c819e5de17f1647c31f485dea98ec91270aff5df3b292ac9677a35dfccc089c0f786d5e05e54e619000f65e0efe63ff15e5335e181749769ed97c5e212ffeca28728c5e2a4883fbb025865e3360d90d3347f75e3c78fe00af0fd75e4590f2d820938b5e4ea8b79584c9ef5e57c04c3ad88a4d5e60d7b0ca188c685e69eee54541687d5e7305e9ae4f97425e7c1cbe073f71f05e853362520d323b5e8e49d690b4f2615e97601ac532ad1f5ea0762ef1823dc25ea98c13179f601c5eb2a1c73985b0925ebbb74b5930ac175ec4cc9f789bb0315ecde1c399c1fafe5ed6f6b7be9eab305ee00b7be92cc01a5ee920101b6719a65ef23474574878645efb48a89ecb7d825f045cacf3eaaad65f0d708158a062dd5f168425cee6e8bf5f1f979a58b860515f28aadef80ece155f31bdf3aee417455f3ad0d87f3201cb5f43e38d6af234475f4cf612741e361a5f5608679caf6f5b5f5f1a8ce69f28e15f682c8253e68c495f713e47e67ea3f05f7a4fdda0605afa5f83614383847d575f8c727991e3b7c15f95837fcd7697c05f9e945638358bb05fa7a4fcd418e2be5fb0b573a318ccee5fb9c5baa72d5b1e5fc2d5d1e24e7f065fcbe5b956740b3c5fd4f5710595b3375fde04f8f1ab0b505fe714511cab88c95ff02379888e81c95ff93272374b2d616002413b2ad8a393600b4fd4652ddd4e60145e3de841b475601d6c77b60ae3df60267a81d080075a602f885c39979bb060389606f347fea76041a381ff876f03604ab0cd604c0c8c6053bde9178bd80b605ccad5273cb3546065d79191546141606ee41e57c885ba6077f07b7c8ea5b46080fca9019c2737608a08a6e8e6515d6093147534624c56609c2013e605216b60a52b82ffc3bb0360ae36c28392e49c60b741d273674add60c04cb2d1357b8860c957639ef1e58b60d261e4de90d8f660db6c369206870760e47658bb47022860ed804b5c463df360f68a0e76f80f3560ff93a20d502beb61089d0621422b4f6111a63ab4c185d1611aaf3fc9c1951f6123b81562359424612cc0bb80109f0d6135c9322545b34b613ed17953c7af966147d9910d8953ee6150e179547d419b6159e9322a95fb3a6162f0bb91c5e4b2616bf8158bff43406174ff401b343d76617e063b4156db3c61870d07005905d6619013a35a2c87e761991a1050c30d6e61a2204de60e23cd61ab265c1bff39ca61b42c3af4879f9461bd31ea719886c161c6376a9523025561cf3cbb611806c061d841dcd76869e761e146cefa04e31e61ea4b91cade0b3461f350254be45c6a61fc54897f083282620558be6639cab9620e5cc4036943cc6217609a58869dfb622064416781bb09622967b9324a5e4562326b01bad02c83623b6e1b0302ac27624471050cd14523624d73bfda2b40f96256764b6cffcac3625f78a7c73def2b62687ad4ead49c7a62717cd2d9b2a292627a7ea195c6b2f36283804120ff60be628c81b17d4b20b6629582f2ac984943629e8404b0d5127862a784e78bef960e62b0859b3fd5cf6e62b9861fce759baf62c2867539bcb99a62cb869b8398c9ae62d48692adf74e1d62dd865abac5aad662e685f3abf1258262ef855d8366e58962f884984313f411630183a3ece53c07630a828082c78a1c6313812e06a78cc7631c7fac7a71d44e63257dfbe012d2c0632e7c1c3976dbfe63377a0d888a25b9634077cfcf38c778634975630f6eba9a635272c74b17da53635b6ffc841fe3b663646d02bc7275b6636d69d9f5fb11246376668232a518b2637f62fb745bd0ff63885f45bd0a608a63915b610e9bcfc2639a574d6afb090163a3530ad412d89063ac4e994bcdecac63b549f8d416d58463be45296ed8054163c7402b1dfbd00263d03afde36c6be263d935a1c113f0fd63e23016b8dc596e63eb2a5cccaf815263f42473fe7726cf63fd1e5c501cea0e64061815c38a4d45640f11a05aa8b4ba64180afc176166be64210428fb9d8bb46429fd2709462e156432f5f642443a71643bee96a8807f6f6444e7083de3add2644ddf4b0456587f6456d75efdc0f474645fcf442c0bd8d96468c6fa911f3ef76471be822ee34240647ab5db073fe0506483ad051c1cf8f0648ca4006f624e1764959acd02f783ef649e916ad8c420d464a787d9f2af8d5a64b07e1a52a1144e64b9742bfa7fe2b564c26a0eec3307d464cb5fc329a1753164d45548b4b1fe9364dd4a9f8f4b5a0564e63fc7bb541fdb64ef34c13ab2cab264f8298c0f4db77265011e283b0b2555650a1295bfd135e0651306d49f85ecf2651bfae4dc0f30bb6524eec67752c9c4652de279733662f36536d5fdd19f8988653fc9539473ad256548bc7abd981fcc6551af734ef215e5655aa23d4a66a63b656394d8b1daca07656c874587335cea65757983cc551cf3657e6b938324aaa365875d74ad8688ee65904f274d5f1d3a659940ab6492af6765a23200f50569cf65ab2328009b594665b4142089386d2165bd04ea90c0773565c5f58619172bdc65cee5f3242021f465d7d631b3bed2e265e0c641c9d69a9a65e9b623684ab79865f2a5d690fe4aec65fb955b45d45835660484b188afc5a8660d73d95b735c0f661662d2c001c6cd661f519db83d93e26628403a460933ea66312ea86b46fa22663a1ce829d91c6a66430af983a1b347664bf8dc7a82b9e36654e691105e0e16665dd4174715705f6666c16f208a83ee666fae989e9ecea566789b93c333b91866818860902a8e90668a74ff07647d0f6693616f2ac2954f669c4db0fc25cacb66a539c47d6ef3bb66ae25a9b07ec91566b711609735e69866bffce93374cac766c8e843871bd6ee66d1d36f940b4f2366dabe6d5c235a4966e3a93ce144021566ec93de254d330d66f57e512a1ebc8b66fe6895f19850bd670752ac7d9984b067103c94d001d0486719264eeab08e4967220fdacf84fc56672af938805e3af56733e267ff1b4d90673ccb694d9b1a7b6745b43c6dbc6af2674e9ce1615deb1a675785582a5e2a0d67606da0ca9b99cf676955bb43f48f5a67723da7984742a0677b2565c971ce8667840cf5d95230ed678cf457c9c64ab46795db8b9cabdfb8679ec29153e096d367a7a968f141f9eb67b0901276ad75e467b9768de6005aae67c25cdb4117db4267cb42fa89d10da767d428ebc208eaf467dd0eaeeb9c4f4e67e5f4440867f9f367eed9ab1a488d3267f7bee4231a8e766800a3ef24ba6644680988cc2104604068126d7b19d4ab27681b51fc110758e26824364f08785e76682d1a74020394126835fe6aff84b50d683ee23402d75feb6847c5cf0dd7165b6850a93c225f3d3e68598c7b424b1ca668626f8c6f75dfda686b526fabba955668743524f8f42ed4687d17ac58fd81456885fa05cdb144da688edc3158ea15036897be2efc82707268a09ffeba54b92268a981a0943b344e68b263148c100a8168bb445aa3ad478f68c42572dcecda9968cd065d39a8961468d5e719bbba2fc368dec7a864fb40c268e7a8093745458268f0883c34719dcf68f968415e598ccf69024818b6d6390b690b27c23fc0ac666914073dfaf1d42a691ce68bea4281066925c5ac0f8b670f692ea49e6ca51dc66937836303682016694061f9d5accc5869494062e54b645a69521e9e341c0d58695afcabc3f6d0056963da8b96b3988d696cb83dae2a3695697595c20c325d3e697e7318b2a3a32669875041a355827069902d3ce01f58be69990a0a6ad8673869a1e6aa4557d29269aac31c7174a30569b39f60f105c45769bc7b77c5e205de69c55760f1e01a8269ce331c76d698bb69d70eaa569bfa9a69dfea0a93069dc369e8c53d2decc37869f1a0422924909869fa7b1986840d9d6a0355c347e126a46a0c303f6f11ab6d6a150a8dfdeb4f5c6a1de4aef643a9806a26bea259f0348f6a2f98682ac64eed6a3872006a9b3aaa6a414b6b1b441d8b6a4a24a83e9601056a52fdb7d665d2436a5bd699e48862276a64af4e6ad2654f6a6d87d56b1874146a76602ee72f0a8f6a7f385ae0ea88956a8810595a1f31c46a90e82a54a12d7b6a99bfcdd24486e46aa29743d4dd2cf16aab6e8c5e3ef25e6ab445a7703d8dbb6abd1c950cac99626ac5f355355f93846acec9e7ec29de286ad7a04d32debf276ae076850b51603d6ae94c8f7754cef76af2226c78bbfcc96afaf81c1159bf036b03cd9e4300ced86b0ca2f30f83c9636b15781a78b52fa26b1e4d148067667e6b2721e1286cb6ce6b2ff68072974d566b38caf260b93ac86b419f36f4a473c96b4a734e302ad0f76b534738151e0ee16b5c1af4a54fce156b64ee83e29193166b6dc1e5ceb4c66c6b76951a6b8ab4996b7f6821bae48e246b883afbbe93679a6b910da87868398b6b99e027ea33e0936ba2b27a15c71d586bab849efcf2948c6bb45696a186cef46bbd2861055439656bc5f9fe2a2b24c96bcecb6e11dbc61f6bd79cb0be3636806be06dc6310a731f6be93eae6c285d4d6bf20f69715fba7a6bfadff7428034376c03b057e159583a6c0c808b4fba985f6c1550918f734aa96c1e206aa252a9466c26f0168a27d2926c2fbf9548c1c9166c388ee6dfef738e6c415e0b517f9ce96c4a2d029f40f44b6c52fbcccb020d106c5bca69d6915ecf6c6498d9c3bd455b6c6d671c945400c36c7635324a23b55c6c7f031ae6fa6bba6c87d0d66ca610b76c909e64dcf475746c996bc639b34f606ca238fa84b0382d6cab0601bfb8ade56cb3d2dbec9a12da6cbc9f890d21adb76cc56c09231ca9786cce385c305815716cd7048236a0e54e6cdfd07b37c3f11a6ce89c47358df5396cf167e631cb92706cfa33582e494de96d02fe9d2cd3912f6d0bc9b52f36aa346d1494a0373ecb556d1d5f5e46b80b556d2629ef5f6e656a6d2ef453832db9336d37be8ab3c1cac66d408894f2f642a96d4952724296adda6d521c22a46e7dce6d5ae5a61a4908746d63aefca5f188376d6c782649331c026d75412305d8c7416d7e09f2ddad71e16d86d295d27be8576d8f9b0be60edb9c6d9863551a30e1366da12b7170ac73356da9f360eb4bf0376db2bb238bd99b6b6dbb82b9541f9c906dc44a2245e7ffff6dcd115e62fcb6a06dd5d86dad2795fb6dde9f502632582f6de76605cfe69bf96df02c8eac0de4b86df8f2eabc719a696e01b91a02db09ae6e0a7f1c811363d16e1344f238e3bec26e1c0a9b2c15151d6e24d0175c7046286e2d9566cbbe15db6e365a897bc72cde6e3f1f7f6e5418896e47e448a52d4aee6e50a8e5221b1ad46e596d54e6e5c3bb6e623197f55565e16e6af5ae4f32063f6e73b997f6438e916e7c7d54ec51cd546e8540e5332475cb6e8e0448cc831ffb6e96c77fba3548b96e9f8a89fe02519f6ea84d6799b181176eb110188f0a02596eb9d29cdfd2e56f6ec294f48dd31f386ecb571f9ad189686ed4191e0894e2896edcdaefd8e3ce026ee59c950d84d4146eee5e0da83e61e06ef71f59aad6c9686effe0791714418f6f08a16beebce61f6f1162323396b7c66f1a22cbe7679c206f22e3390bf55db06f2ba379a305abe86f34638dae5e1b2a6f3d23752fc424cc6f45e33028fd27146f4ea2be9bce653f6f57622089fd07866f602155f54e1b176f68e05edf8692226f719f3b4a6b43d26f7a5deb37c0ec546f831c6ea94c2cd96f8bdac5a0d18b956f9498f0201573c76f9d56ee28dc35b36fa614bfbcea06ab6faed264de0301116fb78fdd8deb24526fc04d29ce6654f16fc90a49a1385c836fd1c73d0824e9b56fda840404ef904b6fe3409e995bc9246febfd0cc72cf23d6ff4b94e90264eaf6ffd7563f60b06b97006314cfa9e27b7700eed099fa2a42e7017a899e6db53cb702063fdd20af36170291f3562f424f47031da409b596faf703a951f7cfd3ff470434fd209a1e752704c0a5843099c8d7054c4b22af67ba3705d7edfc32a85c4706638e10d67a162706ef2b60b6f9a257077ac5ebf0420f8708065db29e6cc0470891f2b4dd916b87091d84f2c9c61c8709a9146c7f1f32b70a34a12219af62870ac02b13b587b4a70b4bb2416eb787070bd736ab614c8c770c62b851a952ccd70cee373462d4a5270d79b353a9dac8170e052caf9a6c3da70e90a348508e63770f1c171de844ecf70fa788307d91e3971032f6802c75a6b710be620d10eeebd71149cad746fabf1711d530deea9482771260942417b5ef1712ebf4a6ea571467137752677e6e58f71402ad65eff07a17148e05a25ad08c2715195b1cdafffaf715a4add58c6e8997162ffdcc8b0a527716bb4b01f2bfc7d717469575df79b3a717d1dd286d213797185d2219b79dcd7718e86449dad547571973a3b8f2abcf4719fee0671b03e8171a8a1a546fbe6cc71b1551810cba91371ba085ed0dd5e2171c2bb7988eec44e71cb6e683abd7f8471d4212ae807194071dcd3c19289009471e5862c3c008a2871ee386ae62af04071f6ea7d92c552b971ff9c64438cb71072084e1efa3e085e7210ffadb89617607219b11080519a7772226247532d2da9722b135232e552a37233c431213670bd723c74e41fdcd4fd7245256b3094b214724dd5c6551a2063725685f58f291e01725f35f8e07d8eb57267e5d04ad33bff7270957bcfe5d517727944fb7170eef07281f44f31300439728aa37710de755f7293527312378893729c014336f669c572a4afe780d62aac72ad5e5ff191c2c572b60cac8ae40f5872bebacd4e87d37572c768c23e37b7fd72d0168b5bae4b9e72d8c428a8a602d772e1719a26d937fc72ea1edfd8022b3572f2cbf9bddb028172fb78e7da1dc9be730425aa2e84729d730cd240bcc8d4b473157eab86a4ad75731e2aea8dd1a0367326d6fdd409362d732f82e55b04de7d73382ea1247dee297340da31322da0247349859585cd154b735230ce21155469735adbdb05bf4a39736386bc3583c96b736c3171b21b8a9d7374dbfb7d3f2c6b737d865998a733677386308c060c0a19738eda92c726010c7397846dddad4ec573a02e1d4b5a0fcc73a8d7a111e446ac73b180f93303dbf373ba2a25b0709e3773c2d3268be2421773cb7bfbc710623b73d424a563b27f5a73dccd236380003a73e57575c83031b073ee1d9c937a46a773f6c597c715581c73ff6d6764b865267408150b6e1a52f27410bc83e4f1eccb741963d0caf5e41874220af221dcd060742ab1e7eb5d2f4a743358b2292d64a2743bff50dd03ba577444a5c408966083744d4c0bad9b6d667455f227cdc8dd6d745e98186ad4933474673ddd86745782746fe377225dd954747888e54046adda74812e27e1e450787489d33f08ec22ca7492782ab7136ca6749b1ceaee0f5c1e74a3c17faf95058174ac65e8fd59635f74b50a26d911568874bdae394471a61274c65220412eff5774cef5dbd0fdf5fa74d7996bf59303e674e03cd0b0a2895474e8e00a03e0ccca74f18317f101fb1d74fa25fa79ba27767502c8b19fbd4b52750b6b3d64bf468075140d9dca73df2b751cafd2d28ec1d6752551dc7ec38163752df3bad0c5970e7536956dca486274753f36f56cff29977547d851ba9d18d975507982b4d5430475591a885d5aa14a7561bb62b5e01348756a5c11c0185f057572fc957db630f8757b9cedf06c1c0675843d1b19ec9988758cdd1cfbea094a75957cf39816b191759e1c9ef024bf1375a6bc1f05c6450975af5b73daad3d2075b7fa9d708b878a75c0999bc912eaf375c9386ee5f5148f75d1d716c8e3981075da7593738fefb575e313e4e7ab7c3e75ebb20b26e784fa75f4500632f537c175fcedd60d85a8fd76058b7ab849d3a3760e28f434f2993d7616c6428530c1ea761f6365aab4fc5c7628005da72fdde076309d2a7c51e25c763939cc2bcb6c507641d642b74cc4dc764a728e20861bc276530eae69278760765baaa392e104bd7664466d9f627785766ce20c905baa0c76757d80677c4d4e767e18c92673f8f37686b3e6cef22b55768f4ed962a649797697e9a0e33f9f1776a0843d526d5e9c76a91eaeb1dea12b76b1b8f50342669e76ba53104847958776c2ed00829cfb3676cb86c5b3f14bba76d4205fddf321dd76dcb9cf0250ff2e76e5531322b94c0076edec2c40da576a76f6851a5e62574a76ff1ddd7cff684b7707b6759e5f8ddf77104ee2c430b2487718e724f020a69777217f3c23dd22ae772a17286113c5437732aee9a97213e0773b467ffea57ae97743ddeb625b4d99774c752bd640c60677550c415c030525775da32bf54f12c8776639eba3d1dda3776ed08069383b4e777766ea472ee845777ffd293f6287ec7788933d537fa48f779129268532af637799bee4d628008e77a25478480bd72377aae9e0dc8a592477b37f1e954f938a77bc143174077a3c77c4a9197a5de81f77cd3dd6a9fe9f0b77d5d269049547d677de66d08bcd725077e6fb0d4152954a77ef8f1f26d00e9377f823063df122fe7800b6c28860fe6178094a5407cab39b7811ddbabdd93c8e781a70f6ac377a2a78230407d490346c782b96ee388e1a5c783429a9d9dbc214783cbc3aba23a8be78454ea0db103299784de0dc3e4baafc785672ece5804451785f04d2d25818207867968e067d27097870281e839958ce7878b9844b567c4b78814abf5f5e47827889dbcfc15a579778926cb572f430d1789afd7075d53ea378a38e00cba6d3a378ac1e667612299878b4aea176c0617278bd3eb1cf5a835378c5ce9781897e8b78ce5e528ef6299f78d6ede2f949424878df7d48c22b6d7578e80c83eb45374e78f09b94763f133678f92a7a64c15bcd7901b935b87452ef790a47c6730021bc7912d62c960cd893791b646823426f187923f2791c48c437792c805f82c79e2279350e1b5866aa54793d9bac9ecd7d967946291357a393ff794eb64f849050f579574361273aff2d795fd048414ad0b479685d04d466deea7970e996e2362a87797975fe6c5f9b9a7982023b748a0192798a8e4dfc5c133679931a36057c6eb1799ba5f39191998a79a43186a24200ae79acbcef3933f86e79b5482d580dbc8179bdd3410075700979c65e2a34111d8f79cee8e8f486b70a79d7737d437c15e179dffde72296fae979e88826937d0e6879f1123b97d3e01d79f99c263140e7387a0225e6616982617a0aaf7c29f2f7be7a1338e78c8274ed7a1bc2288abd0f0b7a244b3f2647c2b37a2cd42b60c774037a355ced3be0ee9c7a3de584b938e5a47a466df1da73f3c77a4ef634a1369b3a7a577e4d0f2545c07a60063b25e444a47a688dfee717d0c47a71159854640a8a7a799d076f6cf9f87a82244c39d68ea07a8aab66b5449fac7a933256e35aebdd7a9bb91cc5bd198d7aa43fb85e0eb6b77aacc629adf338ef7ab54c70b70dfd697abdd28d7b0248fb7ac6587ffb7348227acede483a040efc7ad763e63857994e7adfe959f810ca897ae86ea37ad26dc87af0f3c2c23f35d17af978b7cff9bd1c7b01fd82a5a485d07b0a822344e1f9c57b130699af546a8a7b1b8ae5e69e11627b240f07ec610f4b7b2c92ffc23f6cf97b3516cd69db1ae27b3d9a70e4d5f1337b461dea34d1afdd7b4ea1395b6ffe917b57245e5a526cc47b5fa759331a71b07b682a29e7696c577b70acd078e0a3827b792f4ce92145c77b81b19f39cc69897b8a33c76c830cf77b92b5c582e616127b9b37997e9652b17ba3b943613478787bac3ac32c6124e87bb4bc18e1bcdd577bbd3d4482e80ef27bc5be4611830ec87bce3f1d8f2e19c27bd6bfcafd8954a87bdf404e5e34cc257be7c0a7b2d074c67bf040d6fcfc2afe7bf8c0dc3e57b3267c0140b77882b9817c09c068ad1cd23b7c123fefddc5796f7c1abf4d0c1c13237c233e8039bfeb517c2bbd89685035e27c343c68996c0eb47c3cbb1dceb2799c7c4539a909c262667c4db80a4c3a9cd57c56364197b9e4ac7c5eb44eeddedda87c673232504813857c6fafebc093fa027c782d7b4060ece07c80aae0d14d2fe37c89281c74f6eed77c91a52e2cfc3d917c9a2215fafb17ef7ca29ed3e09161db7cab1b67df5ce74d7cb397d1f8fb5c4e7cbc14122f0a5cf67cc4902883276d757ccd0c14f6effa0a7cd587d78c0157107cde037043f8c0f97ce67edf20735c527ceefa24230e35c57cf7753f4d66421b7cfff030a1185e3c7d086af81fc14f337d10e595cafdc22e7d196009a46a4c827d21da53ada36bac7d2a5473e84585527d32ce6a55ece7447d3b4836f835c7817d43c1d9d0bc44387d4c3b52e11c63c47d54b4a22af214b97d5d2dc7afd92ddc7d65a6c3716d6e287d6e1f95714a7cd17d76983db10be9467d7f10bc324d2b317d878910f6a9a2787d90013bffbc97457d98793d4f2139ff7da0f114e672a3527da968c2c74bd42e7db1e046f347b5cb7dba57a16c0119a97dc2ced23312b9937dcb45d94a1737a17dd3bcb6b2a91e377ddc336a6e62e00a7de4a9f47eded8207ded2054e5b749d67df5968ba48660d97dfe0c98bce631317e06827c3070b73e7e0ef83600bfd7bd7e176dc62f6d5fc37e1fe32cbe1304c87e285869ae4a64a07e30cd7d01ad05877e394266b9d456177e41b726d859ad547e4a2bbd5ed64aa77e52a02a4ee355e37e5b146daa19df497e6388877212df817e6bfc77a86737a77e74703e4eafb1477e7ce3db6684fe5d7e85574ef17fb95b7e8dca98f138652b7e963db967476d2a7e9eb0b0554525327ea7237dbcc9c9997eaf96219f6d7f307eb8089bfec853497ec07aecdc723bb57ec8ed143a0316cb7ed15f121912ab647ed9d0e67b38a8de7ee24291620ca7227eeab412cf2626a27ef3256ac41c905a7efb9699428735d77f04079e4bfd51337f0c7879e21605187f14e92c06685cc67f1d59b4ba8b4c107f25ca140015af5e7f2e3a49d89e4bb47f36aa5645bbcead7f3f1a394904ce807f4789f2e40fca047f4ff983187328ae7f5868e9e7c53a947f60d827539c386f7f69473b5d8e439d7f71b626073166237f7a24e7521b92b17f82937f3fe2a49b7f8b01edd21c5fe57f9370330a5e71427f9bde4eea3e6e147fa44c417351d46a7facba0aa72e0b0c7fb527aa876861737fbd952115960fd27fc6026e534c37117fce6f92421fe0d47fd6dc8ce3a5ff7c7fdf495e39736e277fe7b606451cf0b27ff02285083733bb7ff88eda8456cca78000fb06bb10399b80096709adf7e1858011d2e35ea2141d801a3e93cea309e28022aa1aff8ee421802b1578f2f9acf7803380adaa77574c803bebb9279bbedc8044569b6bfaa837804cc1547927c0c180552be450b69eb3805d964af43ac1228066008865478ffb806e6a9ca5705c088076d487b6485ef0807f3e499962bb398087a7e250527c4b80901151dcaa967380987a983ffde6e180a0e3b57bdf33ab80a94ca991e12bd180b1b5748396673d80ba1e16529166c480c2868f0064942880caeede8ea2421f80d35704fedcac4980dbbf0252a5f74080e426d68b90308d80ec8e81ab2d4eb580f4f603b30f313180fd5d5ca4c7a0768105c48c81e84df4810e2b934c02d4188116927104a8b651811ef925ad6b610d81275fb147dc29bc812fc613d58c4ed481382c4d580cf7d28140925dd0ef353a8148f84541c4009a81515e03ac1c3c8c8159c3991188b4b481622905739a1dcb816a8e48d3e115978172f36333ee22f2817b58549551b5ca8183bd1cf99c2723818c21bc625db91781948632d12696dc819cea804786d4c581a54ea4c70e703e81adb2a0514d4fd481b61672e7d3433381be7a1c8c30032c81c6dd9d3ff331b381cf40f504ac59e181d7a423dbeaeff781e00729c73e515f81e86a06c835c4af81f0ccbae06079a881f92f46114d893c820191a85c8bf58a8209f3e1c3aaa9e7821255f248387ad8821ab7d9ebc4261a82231998afdc52a0822b7b2e960f90968233dc9b9fec5964823c3ddfcf010fab82449efb24dbff50824cffeda30b5d70825560b74b1d4871825dc1581e9fc7f8826621d01f20ccf1826e821f4e2e318e8276e245ad55b949827f42433e2510e88287a2180229ce7b829001c3faf17161829861472a09624882a0c0a190fef33082a91fd3315f5f6a82b17edc0cb7cb9e82b9ddbc249545c782c23c737a84c53c82ca9b0210132aad82d2f967e6cd402282db57a5003fb90582e3b5b95df7321b82ec13a50180318c82f47167ec6726e282fccf0220386b0a83052c739e80405a830d89bc68cad28b8315e6dc80a436c3831e43d3e7986b918326a0a29f3358f2832efd48a900d050833759c6068c8c86833fb61ab96231e183481246c30d4e2183506e4a2519587c8358ca24e111b19f836125d6f881a3af836981606cf4624b8371dcc13ff50a91837a37f9730ea3188382930907cc1bfb838aedefffb84ed3839348ae5c5dfebf839ba3441f47d86283a3fdb14a0071e383ac57f5de124af283b4b211dd07cccb83bd0c05486b4a3583c565d021c6ff8083cdbf726aa5129083d618ec248f92d883de723d5110795d83e6cb65f1b1a8b683ef246607fced1583f77d3d957bfc3d83ffd5ec9bb8758f84082e731c3be205841086d1188fb4358418df06923d4855842137138acde43984298ef803cab7588431e6b3febcdacb843a3e477d2d5150844295b280a5074e844aecf50aacd2d18453440f1ccd7393845b9b00b88f92f58463f1c9df7bc40b846c486a931a839284749ee2d4f437ff847cf532a691317284854b5a0979a9c5848da158ff35c4868495f72f894d8ef8849e4cdda949001d84a6a26360aff8ad84aef7c0b10a431f84b74cf59bdf93a784bfa20222b7883984c7f6e64719a88f84d04ba20a8d661f84d8a0356e9a1c2b84e0f4a074c70fb684e948e31e9b6f9284f19cfd6d9e545384f9f0ef6356c062850244b9014b9fed850a985a4903c8f88512ebd33c05fb52851b3f23dbd8e0a18523924c2a030c5e852be54c280afbd585343823d7771630853c8ad339cdac6c8544dd5a5094f963854d2fb91d5321cf855581efa18e3440855dd3fddecc2930856625e3d692e2f2856e77a18a682dc38576c936fbd1bfc1857f1aa42c5538f285876be91d782344858fbd05d0bff28d85980dfa47b2049485a05ec683d3a10785a8af6a86a9f98885b0ffe651ba29a885b95039e68936e885c1a065469c10c085c9f0687377909d85d240436ea079e285da8ff6399b79ed85e2df80d5ed281585eb2ee3451a05ad85f37e1d88a67e0985fbcd2fa216e67986041c1992ef7e51860c6adb5cb46ee58614b97500e9cb91861d07e6811391b58625562fdeb5a8ba862da4511b53e2128635f24a3871f93b863e401b379393bf86468dc41a3c4137864edb44e1ef7b4d8657289d9030a5ba865f75ce26830e508667c2d6a669ecf086700fb71168639586785c6f69017e538680a8ffaeb833588688f567e40f62ed869141a80a89d77786998dc023aa457d86a1d9b030f34ba686aa257833e772ba86b271182e092da686babc9020dad97c86c307e00ddebd7786cb5307f6970afa86d39e07dc85dd9386dbe8dfc12d3afa86e4338fa60f131986ec7e178cad400686f4c8777689860c86fd12af652593a387055cbf5a03017e870da6a756a352818715f0675c87f3cc871e39ff6d323cb58726836f8a236ece872eccb7b4dcb5e9873715d7eedf2810873f5ed039abc5938747a7a096c37901874ff04907a7172a875838c98dd75f28876081222ad4fa588768c952e0207c608771115baf3a63308779593c99a317038781a0f5a0daea628789e886c6621a2387922ff00bb8cd70879a7731725f15be87a2be4afbd4eedd87ab053ca99a3eef87b34c067d2ed66d87bb92a87812702887c3d9229bc4b14d87cc1f74e9c5296187d4659f6393524c87dcaba20aae904f87e4f17ce096321087ed372fe6c9709587f57cbb1ec76f4a87fdc21e8a0f3bfe8806075a2a1fcee8880e4c6e00780aa88816915a0e96bc4a881ed61e55fa9b4488271abad8224978882f5f2f968c533b8837a37c92b72f51883fe7a1ce213ef088482b9f4a48cdc388506f7508ac11ea8858b3230ac92bfe8860f6a9521e270e88693a07e028f8a888717d3eb66780d18879c04dd6578a0f888203354176c967888a45f4f942de5f8892888cff3952fe889acafd54d79bd388a30d45fb9b17ef88ab4f66f50110ec88b391604286baee88bbd331e5a934a188c414dbdfe5874288cc565e32b8a69788d497b8df9f70f988dcd8ebe816af4f88e519f74d9b151688ed5adb11a9405e88f59b9735bdb9cc88fddc2bbb54f49e89061c98a3eb4eab890e5cddf0fd106389169cfba4066cd5891edcf1be8381ae89271cc041f05737892f5c672fc8e05d89379be68988fab2893fdb3e50ac6e6789481a6e86aeee57895059772d0c180389589858453f73978960d711d0c473e6896915a3d11676748971540e47b0c37189799251360e8dbb8981d06c9daaf2e3898a0e608000fb2e89924c2cde8b9992899a89d1bac5abbe89a2c74f1629fa1789ab04a4f23337bc89b341d3505c028689bb7eda321ee30a89c3bbb998f64c9d89cbf871865c9d5289d43501fbcc1dfd89dc716afabf023589e4adac84af685689ece9c69b17598089f525b93f70c99e89fd61847335975f8a059d2837df8c438a0dd8a48ee85c908a1613f979c9a75d8a1e4f26f9fcf6928a268a2d10fbbee58a2ec50bc03f5fdf8a36ffc3094123df8a3f3a52ed7a40188a4774bb6e63d4948a4faefc8d76ec398a57e9164c2c7cc48a602308abfd66d18a685cd3ae6275d68a70967754d4602c8a78cff3a0cbc70c8a81094893c1368f8a8942762f2d25b58a917b7c7487f6618a99b45b6549f55f8aa1ed1302eb5a648aaa25a34ee4480d8ab25e0c4aaccbe68aba964df7bcde668ac2ce68578c62f38acb065b6b9327e58ad33e273548e6868adb75cbb62543138ae3ad48ef9fccbe8aebe49ee32ffdb28af41bcd924d3b0f8afc52d4fe6ed4f28b0489b5290c06748b0cc06e139bf5a78b14f6ffbf95b3a28b1d2d6a2e703c758b2563ad61a277378b2d99c95aa336038b35cfbe1ae935f58b3e058ba3eb1f338b463b31f71f84e88b4e70b115fce54d8b56a60901f9a9a28b5edb39bc8c26368b671043472a9a668b6f4525a34b309f8b7779e0d263fe608b7fae74d5eb04398b87e2e1af562dd28b901727601b51e78b984b45e9b0324b8ba07f3d4d8a7bed8ba8b30d8d1fc6d48bb0e6b6a9e596268bb91a38a55158258bc14d9380d866338bc980c73df004d48bd1b3d3de0d63ad8bd9e6b962a59d898be21977cd2db8598bea4c0f1f1aa5338bf27e7f59e140578bfab0c87ef651318c02e2ea8fce8a578c0b14e58dde898c8c1346b97a9ad7c48c1b78665777e9238c23a9ec25ea1d008c2bdb4ae765bde38c340c829d5f018c8c3c3d93494a08f18c446e7cec9ae03f8c4c9f3f88c57ee08c54cfdb1f3dc7768c5d004fb17787e28c65309d40e679448c6d60c3cefe3ffb8c7590c35d326ba78c7dc09becf6772d8c85f04d7fbdc8b68c8e1fd816fbb1b08c964f3bb4236ed28c9e7e7858a8281f8ca6ad8e05fcf0df8caedc7cbd94c7ac8cb70b4480e296698cbf39e55159324d8cc7685f306b5bdf8ccf96b21f8bbef68cd7c4de202cf2bf8cdff2e333c179be8ce820c15bbbc1cc8cf04e78998e241b8cf87c08eeaae5398d00a9725c84350e8d08d6b4e48c2ee08d1103d08834d9538d1930c548f0266f8d215d93282ff3988d298a3a2766099c8d31b6ba48041ca78d39e3138b7bcc528d420f45f33ea39b8d4a3b5180be18e98d526736356b8e108d5a92f412b8504e8d62be8b1a1598538d6ae9fb4cf48a3c8d731544acc635978d7b40673afb95678d836b62f90590218d8b9637e854f7b18d93c0e60a5a89798d9beb6d6086ee578da415cdec4abaa08dac4007af166e268db46a1aaa5a743a8dbc9406df8723aa8dc4bdcc500cbec38dcce76afd5b735b8dd510e2e8e35ac28ddd3a34141479d38de5635e805ec0f08ded8c622f320bff8df5b53f21fe22748dfdddf55a32b74a8e060684d93f690c8e0e2eeda093c1d18e16572fb19f37418e1e7f4b0dd12a958e26a73fb698e8978e2ecf0dad65a9a88e36f6b4f3a691bd8e3f1e358acab0628e47458f744100bd8e4f6cc2b178698c8e5793cf43dfbd2b8e5fbab52ce5b9948e67e1746df9085c8e70080d08883ebc8e782e7efe01dd8d8e8054ca4fd4514d8e887aeeff6df21d8e90a0ed0e3d03c38e98c6c47dafb5b28ea0ec754f3423008ea911ff843852748eb137631e2a367c8eb95ca01e77ad388ec181b6868e80748ec9a6a657dc65b08ed1cb6f93cefe1b8ed9f0123bd3d69b8ee2148e515867cb8eea38e3d5ca15fa8ef25d12ca9631338efa811b3129f5378f02a4fd0af289888f0ac8b8595d015e8f12ec4d1dd65bb78f1b0fbb59cb83498f2333030ea94e918f2b56243ddc7fcc8f33791ee8d1c4fe8f3b9bf310f5b7ee8f43bea0b7b4de2d8f4be127de7ba9128f54038886b675c18f5c25c2b1d18d298f6447d6613924058f6c69c396595ae08f748b8a529e3e168f7cad2a9773c5d48f84cea46645d61b8f8ceff7c0803ebe8f951124a78ebb6b8f9d322b1cdcf3a38fa5530b21d67ac58fad73c4b7e6d0078fb59457e0795e7d8fbdb4c49cf97d188fc5d50aeed26ea88fcdf52ad76f61e08fd61524583b71518fde34f772a1a3738fe654a4280ceaa58fee742a79e825268ff6938a699e1d248ffeb2c3f89988b29006d1d7284509d1900ef0c3fa0b2e6c90170f8a6f56705f901f2e2a8991357490274ca44a25cf65902f6af7b27e7be090378924c4056487903fa72b80249eef9047c50be8462caa904fe2c5fdd3fb3b90580059c237e42390601dc736dbacdf90683b0e5d2906e79070582f36898fb190787529c466d0b3908091fe082a3f699088aeac033d3d499090cb33b70917d49098e79524f7089090a103d04e70350690a91fe534ddaecc90b13bd3d9a8738290b9579c3e396cd090c1733e63f9706e90c98eba4c51402290d1aa0ff8a989c290d9c53f6a6ae73590e1e048a2fdde7490e9fb2ba3cae19190f215e86e3a4ead90fa307f03b4700691024aef65a17bf0910a6539956994da91127f5d9474c94d911a995b642b13f49122b33305f45b93912acce47b3873139132e66fc55f197a913affd4e5cff9f491431913ddf2abd2914b322caf2eb28a91534b1f5aeb7db7915b63ebe290692091637c924784bcb7916b95128b2fac969173ad6caef8590a917bc5a0b445ce889183ddae9c7f05bc918bf596690ae37d91940d581b5038da919c24f3b4b5c31691a43c6936a22ba691ac53b8a27c083c91b46ae1f9a9dac091bc81e53d92115491c498c26f9b065691ccaf79912b006591d4c60aa3a8325991dcdc75a878bb4d91e4f2baa102a69e91ed08d98eabebec91f51ed272da6f1c91fd34a54ef4005592054a52245e5c0d920d5fd8f47f2afb92157539c0bc0226921d8a748a7a62de92259f89531fbac1922db4781c1163bb9235c940e6b4a40a923ddde3b46eae3d9245f26086a4a134924e06b75ebb882492561ae83e185a9c925e2ef3261ffc7c926642d818373e03926e569715c2dbc592766a3020277eb4927e7da338c9bc21928690f0610e15b8928ea4179a58f9889296b718e60ec1ff929ec9f44593b5ef92a6dca9ba4c089192aeef39459bd97d92b701a2e8e734ba92bf13e6a59212b292c726047d00583c92cf37fc7095d69a92d749ce81b64b7a92df5b7ab1c560fa92e76d010226ada692ef7e61743db47c92f78f9c096de4ee92ffa0b0c31a9ae09307b19fa2a71ead930fc268a976a5279317d30bd8ec4f96931fe389326b2bc29327f3e0b75633e59330041269104ec09338141e48fc4f8a93402404587cf5fc934833c498f4ee539350435f0bc6d14c935852d3b2552427936062228e0258a99368714ba030cd229370804eea42cc6693788f2c6d9a8dd493809de42b9a35549388ac7625a3d35f9390bae25d1964f69398c928d35cd3b093a0d74989cff5ae93a8e54481d48da793b0f319bccc4ae693b900c93c18c94993c10e53011b914493c91bb70d3617e593d128f561c9bed293d9360e0037d44c93e14300e9e1932f93e94fce202822f793f15c75a46c97bb93f968f7780ff237940175539c731fc59409818a12f6fa6494118d9adcfc48b694199985fbe3be069421a54b710dfa429429b0eb3ddb8a059431bc6563ace6939439c7b9e3e275da9441d2e8bfdc8a779449ddf1f8fb63b49451e8d5909f2d8c9459f393882800ad9461fe2be0f5e271946a089e9c68c4ef947212ebbbe086ed947a1d1340bcf3eb948227152c5dc421948a30f180229c8094923aa83d6b0eb4949a44396596992794a24da4fa04a6ff94aa56eafc14902494b2600b6d25993c94ba69064e96f3b194c271dba1c7bdb094ca7a8b6817022c94d28315a2e3b8dc94da8b7a538cc64194e293b97b70fba494ea9bd31bef171a94f2a3c73665c38494faab95cc33988e9502b33edeb71ab5950abac26f4ebb469512c2207f58d860951ac9591033bcf29522d06c233da0c5952ad759b9d4a8729532de21d556e56e953ae4c4772256039542eb41a094e557954af199530c6b6a9552f7cb8fe6ad1d955afdd858815c28956303bfae3a1728956b0981926e699b95730f1e067bcbdf957b14950bbfa336958319e6a39741c9958b1f12cf5fe6a6959324199076bdc3959b28fae838e00295a32db6d803532b95ab324d613309f695b336be8524e40795bb3b0a4535adf395c33f30a2c2213b95cb43319f26e45595d3470d3bc08aa995db4ac379eb949595e34e545b046f6b95eb51bfe067757595f355060b70edf595fb5826dd7d0d2896035b2257e7f446960b5df87c0db183961360a94b4a4014961b6334c6f9882a9623659af0775ef9962b67dbc91f86b6963369f7524dae9a963b6bed8d5d72e596436dbe7baa5cdd964b6f6a1e8fe2cc965370f07769680a965b725187923cf79663738d50659f02966b74a3d33eb8a1967375951178a161967b76610c6e5dd896837707c57adfb3968b77893df905ac969377e577439b98969b781c72b55a5e96a3782e31a8e7fa96ab781ab578d78596b377e1ff7fa92e96bb77841117ca4196c37700eb9b952696cb76589065516496d3758b00cf339f96db74983e335d9e96e3738049ebde4796eb72432552b1a796f370e0d1c1c0ee96fb6f595092e27097036daca31fd9ae970b6bdacac2574b971369e3c8d3f91a971b67c79eae4a17972365864daac269972b631fd722c769973360943c6faba0973b5de37eeaaec397435b0d9fecfdbe974b5812a0cfb2b0975354f282ebd4ec975b51ad479a58fc97634e42f03420a2976b4ab37e11fadb977346fef28ca3da977b43254efcc51297833f2694baf532978b3b02c51fb829979336b9e1837f23979b324beb3ea89197a32db8e3a9802497ab2900cc1c3ed397b32423a5ef0ad897bb1f217279f7b897c319fa3315063b97cb14ade918247897d30f3c95db2dcc97db09a63ab5eae397e303ead90011b897eafe0a7211459197f2f8050741170697faf1da99e704049802eb8b2b5a77c6980ae516bcf2cade9812de7d50074334981ad7bee5ef14069822d0db80015deb982ac9d31f952ed39832c2a5c601820c983abb53749d403d9842b3dc2cbf3f6d984aac3fefbe43009852a47ebef0fbbf985a9c989bae07cf9862948d874bf2bd986a8c5d8321357a9872840890843659987a7b8eb0cb491a988272efe54caee2988a6a2c2f5e96409892614390571b30989a5836098c471a98a24f039c5410d498aa45ac4a045ca398b23c3013f2fc3c98ba328efb75aeca98c228c901e220e698ca1ede288deca298d214ce70ce998398da0a99dbf99c8898e200406b64582798e9f5c220641c5198f1eb1efc4e267298f9e0570077a1739901d56a2e35a5bb9909ca5886dd39319911bf220bc34f3c9919b3c6be3cc8c69921a8469f9e743d99299ca1b13d0d91993190d7f46d3e3b993984e96a839d3b994178d614d4af1899496c9df4b4e5e6995160410b78a142995953bf5a742e5799614718e2fbc7df99693a4da663962399712d5da5ffaefb99792048e32415d29981130f5f24bbaa998905b11b557f139990f82e190a2c3a9998ea8659967ce099a0dcb9de4e185e99a8cec8a88493aa99b0c0b2b98d715499b8b27812bc218799c0a418b564021099c89594a2d85e5899d086ebdc6c6f6d99d8781e63735bf899e0692c3940384b99e85a155f26065e99f04ad9d677b5ca99f83b79a08823d29a002bf4beaa1b649a081c4b323055149a100c7cfc6d77239a17fc8a1eb415809a1fec729a56b1c69a27dc3670a7bb409a2fcbd5a2f98eeb9a37bb50329e77759a3faaa620e8ad3e9a4799d76f2a565c9a4f88e41eb5869c9a5777cc30dc3f809a5f668fa6f070449a67552e8243f5de9a6f43a8c4289afe9a7731fe6df018119a7f202f80ec13459a870e3bfe6e20819a8efc23e7c7c1719a96e9e73e4a65839a9ed786034769e59aa6c5003810198b9aaeb255ddf5ad319ab69f86f6494b569abe8c93825c08459ac6797b837ee6109ace663efb02d4959ad652ddea38b1809ade3f58527148479ae62bae34fd52329aee17df932d76589af603ec6e5249a19afdefd4c7bc4ec99b05db98a0bbf6619b0dc737faa19ecc9b15b2b2d6bd94489b1d9e09366010e99b25893b1ad93c9b9b2d744885792d279b355f31778fe6329b3d49f5f26d593b9b453495f76165a69b4d1f1187bbd8af9b550968a4cc6d7a9b5cf39b4fe2cd0b9b64dda98a4e8e489b6cc793555f35ff9b74b158b26436e29b7c9af9a2acf18e9b8484762788b4859b8c6dce4246bc369b945701f43632fc9b9c40113ea6311c9ba428fc22e5bcce9bac11c2a243ca359bb3fa64be0f3b659bbbe2e27796e0699bc3cb3bd029773a9bcbb370c915abc99bd39b8163aa17fc9bdb836da13543b09be36b358305a4ba9beb52d90a699eea9bf33a5838af840c9bfb21b30f2593e89c0308e98f19fc429c0aeffbb9dad8de9c12d6e990b633839c1abdb314fa03f59c22a45847f42fff9c2a8ad92af28b6f9c327135bf42d8189c3a576e0632c5d29c423d82010ff2839c4a2371b127ea149c52093d17c8267d9c59eee4363e0fbf9c61d4670dd6fbec9c69b9c59fe02f1f9c719effeda6db8a9c798415f87821699c816907c1a10f0f9c894dd54a6ea0e49c91327e942dc15e9c991703a02b49119ca0fb646fb3fea69ca8dfa1041496db9cb0c3b95e99b48f9cb8a7ad808fe8b69cc08b7d6b43b2669cc86f2920017ecf9cd052b0a015a9439cd83613eccc7b339ce0195307722c339ce7fc6df152e1f89cefdf64abbab05f9cf7c23737f599679cffa4e5974f8d399d07876fcb146a239d0f69d5d48ffca09d174c17b50dff539d1f2e356dda1b0d9d27102f003fe6cb9d2ef2046d8ae7bb9d36d3b5b70691369d3eb542ddfe44cc9d4696abe3bd523c9d4e77f0c98ef77b9d56591190be60af9d5e3a0e3a96a8389d661ae6c862d6ad9d6dfb9b3b6de2dd9d75dc2b9502b1d39d7dbc97d66c16d09d859ce000f4d3599d8d7d0415e7972d9d955d04168f00489d9d3ce004359aec9da51c97e025e1999dacfc2babaa3d129db4db9b680d04609dbcbae716987cd09dc49a0eb896d9f89dcc79124f523db29dd457f1dc14b8269ddc36ad602847c49de41544dcd6d9489debf3b8536a47be9df3d207c52c5c7a9dfbb0333366cf269e038e3a9f6345bb9e0b6c1e0a6b54839e1349dd75c87e1d9e1b2778e2c4337b9e2304f052a7d3e79e2ae243c6bcad029e32bf73404bfac49e3a9c7ec09ee77f9e42796648fe8be29e4a5629dab3eef79e5232c9770806259e5a0f451f43b5329e61eb9cd4afce479e69c7d0989511e99e71a3e06c3c2f049e797fcc50edc2e79e815b9447f259449e89373852926c369e9112b87216643e9e98ee14a7c698479ea0c94cf4eb4da69ea8a4615accb81a9eb07f51dab2f9cf9eb85a1e75e623629ec034c72dae33dc9ec80f4c035318b79ecfe9acf81cadde9ed7c3ea0d52bdb19edf9e03443d01039ee777f89e231f1c9eef51ca1c4cadbb9ef72b77c00131199eff05018a881be49f06de677d28cf489f0eb7a9992a9aeb9f1690c7dfd4bcf19f1e69c2526e61fb9f264298f23ea52b9f2e1b4bc08c90219f35f3dabe9f1b039f3dcc45edbd2c769f45a48d4f2d99a79f4d7cb0e43726459f5554b0ae20848a9f5d2c8cae3055349f650444e5ad278f9f6cdbd955dd796e9f74b34a0007b7309f7c8a96e5723bc49f8461c0076350a49f8c38c567212ddd9f940fa705f1fa0a9f9be664e51bca5a9fa3bcff05e4a28e9fab9375699274fd9fb369c8116b22929fbb3ff6feb47ad29fc3160232b43bd69fcaebe9aeb012569fd2c1ad73ed99a09fda974d83b25ba09fe26cc9df43d0e19fea422287e760889ff217577ee2605e9ff9ec68c57a14cca001c1565cf3b0dca00996204694563ca0116ac683a11540a0193f49155eecdfa02113a7fd12cabba028e7e33c018b1ca030bbfad36ff8f3a0388feec4a2cddea04063bf10deb227a048376bb9683cc2a0500af4bf83f355a057de5a24764a35a05fb19be983a468a06784ba0ff053a7a06f57b49900985ba0772a8b85f8a1a6a07efd3ed81c8d5fa086cfce90b06813a08ea23ab0f82d07a09674833a37c63aa09e46a82db30c6aa0a618a98cadc70aa0adea87586bac4fa0b5bc419230612aa0bd8dd83b3f7950a0c55f4b54dc7733a0cd309ae04acc07a0d501c6decdd7c8a0dcd2cf51a8e931a0e4a3b43a1f3dc6a0ec7475997401d1a0f4451370ea5066a0fc158dc1c53363a103e5e48d47a36da10bb617d4b487f8a1138627994eb745a11b5613dc58f663a12325dc9f15f930a12af581e2c8625ea132c503a8b2c36ca13a9461f2179cb0a142639cc0395d55a14a32b4145a6359a15201a7efbcfb93a159d07853a361b3a1619f25414fc03fa1696daeba04309ba1713c14bf02bb06a1790a57518d569ca180d87672e5e955a188a672244e480da190744a6708367ea19841ff3c556743a1a00f90a5777bdca1a7dcfea3b004aea1afaa4938408102a1b77770646a5f06a1bf4474296efbd4a1c71154888fa36fa1cede11830d90c0a1d6aaab1a29eda0a1de77214f25d2d5a1e643742342480ea1ee0fa397c043efa1f5dbafade0ac0aa1fda79866e454e3a205735dc40c01f0a20d3effc698659da2150a7e6fca214aa21cd5d9c0e1c54ea224a111bb1fd0f8a22c6c265fc4b28ea2343717b010c753a23c01e5ad445b83a243cc90589faa58a24b9717b362de0aa253617bbece0fcfa25b2bbc7c2147dda262f5d9ec9c7d6ca26abfd4117f96b8a27289aaec0a68fda27a535e7d7cb87fa2821ceec7163887a289e65bca168b68a291afa587bd4277a29978cc0149de1da2a141cf37fbcdc3a2a90aaf2d126fe7a2b0d36be1cd120da2b89c05576af0d0a2c0647b8f2b37d2a2c82cce8a4d01cda2cff4fe4a0f5889a2d7bd0acfb134e2a2df84f41c717ecca2e74cba318f0d4aa2ef145d1048a67ea2f6dbdcb9dcff9ca2fea3392f8abcf3a3066a72729071efa30e3188842ca115a315f87b659dbc08a31dbf4b18222389a32585f79cf82777a32d4c80f55e06d5a33512e72291efc4a33cd92a25d1ff89a3449f4a005c428fa34c6546b36eb465a3542b2040473fbfa35bf0d6a823be7ba363b669ec41f99ea36b7bda0ddfa959a37341270e3a7505a37b0650ee8ff32da382cb57b01da984a38a903b54210ceea39254fbdbd78180a39a1999487e5a7ea3a1de139b52da61a3a9a26ad59232d2a3b1669ef87984b3a3b92ab00545e01aa3c0ee9dfd344452a3c8b268e1819fe1a3d07610b36ad087a3d83995742ca33ca3dffcf72503d435a3e7c035c72d0ee5a3ef83515be4edfca3f74649e467fb6aa3ff091f61f2b060a406cbd1d5c17550a40e8e614110a1efa41650cda51c7d35a41e131703213d62a425d53d5c5b07fba42d9740b205f1cda4355921055dfeeca43d1ade579f22baa444dc78aa053fdea44c9deffdcc2854a4545f44542f9d5ca45c2075ae6b4f8da463e1840dbadec9a46ba26f7359da44a4736337e083c083a47b23dd5673ff65a482e45fd665f414a48aa4bf6194eb16a49264fbf93c2048a49a25159e96bedba4a1e50c52dfe15ea4a9a4e0175291b7a4b16490ed29c929a4b9241ed5a07056a4c0e389d1f15f38a4c8a2d1e3575d2fa4d061f70b0d20f7a4d820f94a4d50b0a4dfdfd8a25281daa4e79e951457395aa4ef5d2ea195eb7da4f71ba54b48fbf1a4fed9f912aabdcea5069829f8f57396a50e5637ff634f31a5161423272e71f7a51dd1eb7190eca5a5258f90dfc4bf6da52d4d137303d9e8a5350a732c881b25a53cc7b00d8b519ea54484ca17473b44a54c41c14af58577a553fe95a9cfcd0ea55bbb47350f9e53a56377d5edee7507a56b3441d5a5bc65a572f08aed6ecf1ea57aacb13682f75ea58268b4b21b6ecda58a249561715e8ca591e05345bddf40a5999bee6039f907a5a15766b21ea37fa5a912bc3ca4c5caa5b0cdef0105368aa5b888ff0078bbe5a5c043ec3c380b84a5c7feb6b57bca98a5cfb95e6d7c8dd8a5d773e36572d983a5df2e459e97215ea5e6e8851a21c8bca5eea2a1d94b227aa5f65c9bdd4b7102a5fe1673275ae64ca605d027b8b1a3dda60d89b99287bacca6154328b6152bbfa61cfc752491e6f1a624b59edf35cc2fa62c6ea5e738aad9a634278a3dd241e9a63be04be43a3feca64398eadba84308a64b51672553d8fda65309c0c2747f25a65ac1f7b441a276a6627a0bfbf29f82a66a31fd9abec278a671e9cc91dd4729a679a178e2855903a68159028dee1315a6891069954e8014a690c7adf9dd9a56a6987ecfbcd24bd4a6a035cedf636e32a6a7ecab62c7cab5a6afa36548361a4fa6b759fc90e50598a6bf10713e0b24d5a6c6c6c350defff4a6ce7cf2ca970e94a6d632ffac69b7fca6dde8e9f78d5324a6e59eb1ad3826b9a6ed5456cea06913a6f509d95cfc403fa6fcbf395981c1ffa7047476c566f3c7a70c2991a1e1cac1a713de89f0282bd1a71b935fb16feb90a7234812e6eece53a72afca391da8826a732b111b368bcd5a73a655d4cceffe5a74219865f42d499a749cd8cebf9adf5a7518170f428eebea75935327905e976a760e8d17bc5e064a7689c4dfd9e0595a7704fa7ffc37ad6a77802df836b51bca77fb5f489ca8ba3a78768e7141619b0a78f1bb72382dccfa796ce64b945a5b9a79e80efd69334efa7a633587ca03ac2a7ade59eaca15750a7b597c267cb1a83a7bd49c3af520419a7c4fba2846a83a0a7ccad5ee848f877a7d45ef8dc21b1d1a7dc10706128eeb5a7e3c1c57892de03a7eb72f823939e6ca7f32408635f3e7ea7fad4f63929bc9ea80285c1a627070ba80a366aab8afbe0a811e6f14a896915a819975584560c7da82147975a2493cda828f7b6cd289c97a830a7b3de95b450a838578e8f9f584fa8400746e178f5cca847b6dcd555e9e7a84f66506c6981a1a85715a1a7e6f9e6a85ec4d089017f86a86673dd10ec2f3ca86e22c740da15aea875d18f19fe2f69a87d80349d8b68eca8852eb7ccb49e9da88cdd18a8ac9cd5a8948b5732a61fdba89c39736bd3d3e7a8a3e76d55685522a8ab9544f0962faaa8b342fa3e8fdf8ea8baf08d4087d0d5a8c29dfdf7b05f7ba8ca4b4c653bd772a8d1f8788a5c74a8a8d9a58268446302a8e1526a0025be61a8e8ff2f533292a0a8f0abd2629cdb9ba8f858532f968527a90004b1bb516b1ba907b0ee06ff594fa90f5d0813d20b9ca91708ffe2fb2ddda91eb4d575ac5bf1a9266088cd1721baa92e0c19ea6cfb23a935b788cedf541ea93d62d57b9f88a1a9450dfff1dee4b0a94cb90832cea458a95463ee3f9ff3afa95c0eb21983eedca963b953c1aba20fa96b63d33948098ba9730e30818a119fa97ab86b9ba296b0a982628488c26530a98a0c7b4a1a39a8a991b64fe0dac0b2a99960024e349703a9a1099293584960a9a8b300b17654aaa9b05c4ca9bf25d9a9b805767d631a00a9bfae7e2d927e4ca9c75763bb7d9009a9cf002728547c9aa9d6a8c875476187a9de5147a3864c75a9e5f9a4b4413b28a9eda1dfa8a81b86a9f549f881eacb9ba9fcf1ef41391994aa0499c3e7c2c3c3aa0c417676b778a1aa13e906ef46d6cdaa1b907552a06d10aa2337c1a1f3ba5baa2adeebde702dccaa3285f4094526a7aa3a2cda23a1f463aa41d39e2eb5d6a1aa497a402baffd32aa5120c01bbf8818aa58c71e00138784aa606d59d9dafbdaaa681373aa44d5b2aa6fb96b727ff5d7aa775f4133bb2d4caa7f04f4ef253d49aa86aa86a5ecd73caa8e4ff659409cceaa95f5440a4f1fe2aa9d9a6fba46e295aaa53f796a565740aaace4611babe079aab48926cf75d117aabc2dca86e26c2baac3d24c431fe50caacb76ac055c5f4faad31ae9cec5eecdaadabf05a08a97a3aae262ff7bd84e31aaea06d761dcf71faaf1aa8d53c6675baaf94e2152c2641cab00f1935ffea2e1ab0894e37ca8c973ab103811a9ee6de7ab17db1de8fd16a0ab1f7e083b023a4dab2720d0a12b3fe9ab2ec3771ca57ec6ab3665fbae9e3e7eab3e085e5842b705ab45aa9f1ac0109cab4d4cbdf74363daab54eebaeef9b9abab5c909603100b54ab64324f34b3426eab6bd3e6851038ecab73755bf553b918ab7b16af86aa7d9aab82b7e13a413174ab8a58f111447004ab91f9df0ce0c50aab999aab2e42ac9faba13b557696933faba8dbdde708d5c8abb07c4480c5c178abb81c8944f993f3abbfbcac34d07b3eabc75cad517695c7abcefc8c9c17f25fabd69c4a15e09040abde3be5bffc5f10abe5db5f9b973ed8abed7ab7a9dd0011abf519edebf9639eabfcb90263181ad1ac0457f51064c768ac0bf6c5f50afb90ac139575123639e6ac1b34026911f57bac22d26dfac991d0ac2a70b7c88862daac320edfd379ad01ac39ace61cc8a528ac414acaa5a070a2ac48e88d6f2c253cac50862e7a96c93fac5823adc90b536bac5fc10b5bb4aaf9ac675e4733bda7a3ac6efb615251119cac769859b899a199ac7e353067c200caac85d1e560f4c8e3ac8d6e78a55c8416ac950aea3623ad1aac9ca73a1474af2aaca443684179e604acabdf74be5d9decacb37b5f8c4a13aeacbb1728ac69749dacc2b2d01fe5de94acca4e55e7e95ff9acd1e9ba059df7bdacd984fc7a2d955eace1201d46c218e5ace8bb1c6c8552ecacf055f9eca10499acf7f0b5c83edfa7acff8b500088865ead0725c896a78b99ad0ec01f8bc572caad165a54e10baff5ad1df46897a3a7b5ad258e5ab0b6af3aad2d282b2d6e0c4ead34c1da0ef2f551ad3c5b67566e9141ad43f4d30509f7b4ad4b8e1d1bee30dead5327459c44358ead5ac04c8734ef33ad625931dde937dbad69f1f5a189da35ad718a97d33f918ead792318743309dbad80bb77858cdfb0ad8853b50875a048ad8febd0fe15c982ad9783cb6795c9e6ad9f1ba4461e00a3ada6b35b9ad6bd8eadae4af166e84129adb5e265ab7abca1adbd79b869b651ceadc510e9a2c31335adcca7f957c9040badd43ee789f01830addbd5b43a603438ade36c5f6a412d68adeb02e91abac9b6adf299514cf4bfccadfa2f980216b709ae01c5bd3b484780ae095bc0f9b0f9fcae10f1a33e784800ae1887640ac59bc7ae201d035fc05043ae27b2813e8fb127ae2f47dda85afaddae36dd189e495a8cae3e72322181ee1cae46072a332bc430ae4d9c00d46ddc31ae5530b6066f2643ae5cc549ca56834dae6459bc214ac4feae6bee0d0c72adc2ae73823c8cf4f0d3ae7b164aa3f8322aae82aa3752a3068aae8a3e029a1bf380ae91d1ac7b896f5fae996534f811e148aea0f89c10dba126aea88be1c70cf7b1aeb01f061bcc1e6eaeb7b209103f3fb1aebf44eaa58c76a0aec6d7aadcd9cf2daece6a49b74d4621aed5fcc7360cc914aedd8f235a3e3675aee5215e25075d86aeecb377978dfe61aef4456fb2f7c9f4aefbd746786a6207af0368fbe90b593daf0afa900600330faf128c02d06e63d5af1a1d54497b50c2af21ae84724c4fe6af293f934c06a82faf30d080d7cf916daf38614d16cc344caf3ff1f80a21aa5daf478281b2f4fe13af4f12ea126b2ac6af56a33129a91cadaf5e3356f9d3b0ebaf65c35b840fb587af6d533ec981e970af74e300cb4efc7daf7c72a18a9b8f70af840221088c33f5af8b917f46456ca6af9320bc44ebad06af9aafd805a35989afa23ed28990c792afa9cdabd1d83d71afb15c63df9df26cafb8eafab4060eb7afc079705034ab7bafc807c4b54dd2d5afcf95f7e4757fd5afd72409decf9e86afdeb1faa5800be5afe63fca39aa95ebafedcd789c72fb87aff55b05cefceca8affce871d26c0a32b00475bca7e3e60ab00c02e650880310b0138feecd7bd522b01b1cd61fe2c121b022a99c48e01ce9b02a364149972f5eb031c2c5232b3062b0394f27d6bf48dcb040db69657692b9b0486789d07418e8b04ff38918dad763b0577f673fcdbb29b05f0b24466fa244b06696c02de35bc5b06e223af74ba7cab075ad94a3cb377cb07d38cd3484ad10b084c3e4aa9a9bcbb08c4edb072f8800b093d9b04b65e711b09b646478601f72b0a2eef78f4088a8b0aa796991296b4eb0b203ba7f3d010eb0b98dea5a9d74abb0c117f9246ce1ffb0c8a1e6ddcd55f5b0d02bb387e0ce97b0d7b55f23c93b05b0df3ee9b2a87b7ab0e6c85335a06149b0ee519badd2aee7b0f5dac31c6117e2b0fd63c9826d40e7b104ecaee118bfc2b10c757339851b62b113fe168cd3cbd4b11b8698dc263a49b1230efa289dc116b12a973a735babb0b1321f59bd8136b9b139a758082f8ff1b1412f355487d647b148b6f1a3ab19ccb1503e8cf6ba5bc0b157c6074ed68e89b15f4d60ad2095bcb166d49912b94617b16e5bb080c16588b175e2a6f859ab2bb17d697c7aa2bf4bb184f03108bd3b65b18c76c4a3c9aa26b193fd374ce8876db19b8389053a404fb1a309b9cddf3313b1aa8fc9a7f7af39b1b215b894a3f573b1b99b86950437aeb1c12133aa389910b1c8a6bfd5612df5b1d02c2b179dfbf8b1d7b175720ef9eeb1df369ee5d40fe7b1e6bba7740d1732b1ee408f1dd9da5fb1f5c555e45a1539b1fd49fbc8ad74cfb204ce80cbf39772b20c52e4ef4c0cb4b213d72833d6556bb21b5b4a9ab1e3b2b222df4c24fe1aebb22a632cd3da4fbfb231e6eca865c81ab2396a8ba3bfbb36b240ee09c7075195b2487167135ba504b24ff4a389dbc09bb25777bf2ba6a0c0b25efab9f9db3326b2667d93f59856ceb26e004d1ffcdc0b000000000000000000000000000000000000000000000000"; + } + + function btor(uint256 bps) public view virtual returns (uint256 ray) { + require(bps <= MAX_BPS_IN); + + assembly { + let offset := mul(bps, 8) // Each rate is 8 bytes + let wordPos := div(offset, 32) // Which 32-byte word to read + let bytePos := mod(offset, 32) // Position within the word + + let dataSlot := keccak256(RATES.slot, 0x20) + + let value := sload(add(dataSlot, wordPos)) + + let shifted := shr(mul(sub(24, bytePos), 8), value) - rayToBps[1000000000000000000000000000] = 0; - rayToBps[1000000000003170820659990704] = 1; - rayToBps[1000000000006341324285480111] = 2; - rayToBps[1000000000009511510939859271] = 3; - rayToBps[1000000000012681380686500226] = 4; - rayToBps[1000000000015850933588756013] = 5; - rayToBps[1000000000019020169709960675] = 6; - rayToBps[1000000000022189089113429267] = 7; - rayToBps[1000000000025357691862457863] = 8; - rayToBps[1000000000028525978020323563] = 9; - rayToBps[1000000000031693947650284507] = 10; - rayToBps[1000000000034861600815579870] = 11; - rayToBps[1000000000038028937579429884] = 12; - rayToBps[1000000000041195958005035834] = 13; - rayToBps[1000000000044362662155580072] = 14; - rayToBps[1000000000047529050094226024] = 15; - rayToBps[1000000000050695121884118193] = 16; - rayToBps[1000000000053860877588382173] = 17; - rayToBps[1000000000057026317270124651] = 18; - rayToBps[1000000000060191440992433418] = 19; - rayToBps[1000000000063356248818377377] = 20; - rayToBps[1000000000066520740811006546] = 21; - rayToBps[1000000000069684917033352071] = 22; - rayToBps[1000000000072848777548426231] = 23; - rayToBps[1000000000076012322419222442] = 24; - rayToBps[1000000000079175551708715274] = 25; - rayToBps[1000000000082338465479860449] = 26; - rayToBps[1000000000085501063795594852] = 27; - rayToBps[1000000000088663346718836541] = 28; - rayToBps[1000000000091825314312484750] = 29; - rayToBps[1000000000094986966639419899] = 30; - rayToBps[1000000000098148303762503603] = 31; - rayToBps[1000000000101309325744578677] = 32; - rayToBps[1000000000104470032648469142] = 33; - rayToBps[1000000000107630424536980239] = 34; - rayToBps[1000000000110790501472898427] = 35; - rayToBps[1000000000113950263518991400] = 36; - rayToBps[1000000000117109710738008089] = 37; - rayToBps[1000000000120268843192678669] = 38; - rayToBps[1000000000123427660945714570] = 39; - rayToBps[1000000000126586164059808482] = 40; - rayToBps[1000000000129744352597634363] = 41; - rayToBps[1000000000132902226621847447] = 42; - rayToBps[1000000000136059786195084249] = 43; - rayToBps[1000000000139217031379962578] = 44; - rayToBps[1000000000142373962239081538] = 45; - rayToBps[1000000000145530578835021538] = 46; - rayToBps[1000000000148686881230344303] = 47; - rayToBps[1000000000151842869487592874] = 48; - rayToBps[1000000000154998543669291624] = 49; - rayToBps[1000000000158153903837946257] = 50; - rayToBps[1000000000161308950056043822] = 51; - rayToBps[1000000000164463682386052718] = 52; - rayToBps[1000000000167618100890422700] = 53; - rayToBps[1000000000170772205631584889] = 54; - rayToBps[1000000000173925996671951777] = 55; - rayToBps[1000000000177079474073917237] = 56; - rayToBps[1000000000180232637899856526] = 57; - rayToBps[1000000000183385488212126301] = 58; - rayToBps[1000000000186538025073064615] = 59; - rayToBps[1000000000189690248544990934] = 60; - rayToBps[1000000000192842158690206138] = 61; - rayToBps[1000000000195993755570992533] = 62; - rayToBps[1000000000199145039249613856] = 63; - rayToBps[1000000000202296009788315281] = 64; - rayToBps[1000000000205446667249323430] = 65; - rayToBps[1000000000208597011694846379] = 66; - rayToBps[1000000000211747043187073663] = 67; - rayToBps[1000000000214896761788176285] = 68; - rayToBps[1000000000218046167560306726] = 69; - rayToBps[1000000000221195260565598948] = 70; - rayToBps[1000000000224344040866168404] = 71; - rayToBps[1000000000227492508524112044] = 72; - rayToBps[1000000000230640663601508324] = 73; - rayToBps[1000000000233788506160417212] = 74; - rayToBps[1000000000236936036262880196] = 75; - rayToBps[1000000000240083253970920290] = 76; - rayToBps[1000000000243230159346542043] = 77; - rayToBps[1000000000246376752451731545] = 78; - rayToBps[1000000000249523033348456436] = 79; - rayToBps[1000000000252669002098665913] = 80; - rayToBps[1000000000255814658764290734] = 81; - rayToBps[1000000000258960003407243230] = 82; - rayToBps[1000000000262105036089417311] = 83; - rayToBps[1000000000265249756872688471] = 84; - rayToBps[1000000000268394165818913798] = 85; - rayToBps[1000000000271538262989931978] = 86; - rayToBps[1000000000274682048447563305] = 87; - rayToBps[1000000000277825522253609693] = 88; - rayToBps[1000000000280968684469854670] = 89; - rayToBps[1000000000284111535158063399] = 90; - rayToBps[1000000000287254074379982678] = 91; - rayToBps[1000000000290396302197340948] = 92; - rayToBps[1000000000293538218671848302] = 93; - rayToBps[1000000000296679823865196492] = 94; - rayToBps[1000000000299821117839058936] = 95; - rayToBps[1000000000302962100655090723] = 96; - rayToBps[1000000000306102772374928623] = 97; - rayToBps[1000000000309243133060191095] = 98; - rayToBps[1000000000312383182772478292] = 99; - rayToBps[1000000000315522921573372069] = 100; - rayToBps[1000000000318662349524435988] = 101; - rayToBps[1000000000321801466687215330] = 102; - rayToBps[1000000000324940273123237102] = 103; - rayToBps[1000000000328078768894010037] = 104; - rayToBps[1000000000331216954061024608] = 105; - rayToBps[1000000000334354828685753035] = 106; - rayToBps[1000000000337492392829649290] = 107; - rayToBps[1000000000340629646554149104] = 108; - rayToBps[1000000000343766589920669975] = 109; - rayToBps[1000000000346903222990611176] = 110; - rayToBps[1000000000350039545825353762] = 111; - rayToBps[1000000000353175558486260576] = 112; - rayToBps[1000000000356311261034676258] = 113; - rayToBps[1000000000359446653531927249] = 114; - rayToBps[1000000000362581736039321802] = 115; - rayToBps[1000000000365716508618149987] = 116; - rayToBps[1000000000368850971329683699] = 117; - rayToBps[1000000000371985124235176666] = 118; - rayToBps[1000000000375118967395864451] = 119; - rayToBps[1000000000378252500872964469] = 120; - rayToBps[1000000000381385724727675984] = 121; - rayToBps[1000000000384518639021180123] = 122; - rayToBps[1000000000387651243814639879] = 123; - rayToBps[1000000000390783539169200122] = 124; - rayToBps[1000000000393915525145987602] = 125; - rayToBps[1000000000397047201806110961] = 126; - rayToBps[1000000000400178569210660733] = 127; - rayToBps[1000000000403309627420709360] = 128; - rayToBps[1000000000406440376497311193] = 129; - rayToBps[1000000000409570816501502501] = 130; - rayToBps[1000000000412700947494301478] = 131; - rayToBps[1000000000415830769536708248] = 132; - rayToBps[1000000000418960282689704878] = 133; - rayToBps[1000000000422089487014255380] = 134; - rayToBps[1000000000425218382571305718] = 135; - rayToBps[1000000000428346969421783819] = 136; - rayToBps[1000000000431475247626599574] = 137; - rayToBps[1000000000434603217246644855] = 138; - rayToBps[1000000000437730878342793510] = 139; - rayToBps[1000000000440858230975901380] = 140; - rayToBps[1000000000443985275206806300] = 141; - rayToBps[1000000000447112011096328109] = 142; - rayToBps[1000000000450238438705268656] = 143; - rayToBps[1000000000453364558094411809] = 144; - rayToBps[1000000000456490369324523458] = 145; - rayToBps[1000000000459615872456351529] = 146; - rayToBps[1000000000462741067550625980] = 147; - rayToBps[1000000000465865954668058822] = 148; - rayToBps[1000000000468990533869344115] = 149; - rayToBps[1000000000472114805215157978] = 150; - rayToBps[1000000000475238768766158601] = 151; - rayToBps[1000000000478362424582986244] = 152; - rayToBps[1000000000481485772726263252] = 153; - rayToBps[1000000000484608813256594054] = 154; - rayToBps[1000000000487731546234565179] = 155; - rayToBps[1000000000490853971720745253] = 156; - rayToBps[1000000000493976089775685018] = 157; - rayToBps[1000000000497097900459917326] = 158; - rayToBps[1000000000500219403833957155] = 159; - rayToBps[1000000000503340599958301616] = 160; - rayToBps[1000000000506461488893429953] = 161; - rayToBps[1000000000509582070699803560] = 162; - rayToBps[1000000000512702345437865976] = 163; - rayToBps[1000000000515822313168042905] = 164; - rayToBps[1000000000518941973950742212] = 165; - rayToBps[1000000000522061327846353937] = 166; - rayToBps[1000000000525180374915250300] = 167; - rayToBps[1000000000528299115217785706] = 168; - rayToBps[1000000000531417548814296756] = 169; - rayToBps[1000000000534535675765102249] = 170; - rayToBps[1000000000537653496130503193] = 171; - rayToBps[1000000000540771009970782812] = 172; - rayToBps[1000000000543888217346206550] = 173; - rayToBps[1000000000547005118317022080] = 174; - rayToBps[1000000000550121712943459312] = 175; - rayToBps[1000000000553238001285730395] = 176; - rayToBps[1000000000556353983404029733] = 177; - rayToBps[1000000000559469659358533982] = 178; - rayToBps[1000000000562585029209402065] = 179; - rayToBps[1000000000565700093016775172] = 180; - rayToBps[1000000000568814850840776775] = 181; - rayToBps[1000000000571929302741512626] = 182; - rayToBps[1000000000575043448779070771] = 183; - rayToBps[1000000000578157289013521555] = 184; - rayToBps[1000000000581270823504917627] = 185; - rayToBps[1000000000584384052313293946] = 186; - rayToBps[1000000000587496975498667797] = 187; - rayToBps[1000000000590609593121038783] = 188; - rayToBps[1000000000593721905240388847] = 189; - rayToBps[1000000000596833911916682269] = 190; - rayToBps[1000000000599945613209865674] = 191; - rayToBps[1000000000603057009179868046] = 192; - rayToBps[1000000000606168099886600725] = 193; - rayToBps[1000000000609278885389957423] = 194; - rayToBps[1000000000612389365749814222] = 195; - rayToBps[1000000000615499541026029589] = 196; - rayToBps[1000000000618609411278444380] = 197; - rayToBps[1000000000621718976566881844] = 198; - rayToBps[1000000000624828236951147633] = 199; - rayToBps[1000000000627937192491029810] = 200; - rayToBps[1000000000631045843246298852] = 201; - rayToBps[1000000000634154189276707659] = 202; - rayToBps[1000000000637262230641991564] = 203; - rayToBps[1000000000640369967401868332] = 204; - rayToBps[1000000000643477399616038176] = 205; - rayToBps[1000000000646584527344183758] = 206; - rayToBps[1000000000649691350645970197] = 207; - rayToBps[1000000000652797869581045076] = 208; - rayToBps[1000000000655904084209038450] = 209; - rayToBps[1000000000659009994589562852] = 210; - rayToBps[1000000000662115600782213301] = 211; - rayToBps[1000000000665220902846567304] = 212; - rayToBps[1000000000668325900842184872] = 213; - rayToBps[1000000000671430594828608518] = 214; - rayToBps[1000000000674534984865363268] = 215; - rayToBps[1000000000677639071011956667] = 216; - rayToBps[1000000000680742853327878787] = 217; - rayToBps[1000000000683846331872602231] = 218; - rayToBps[1000000000686949506705582145] = 219; - rayToBps[1000000000690052377886256219] = 220; - rayToBps[1000000000693154945474044696] = 221; - rayToBps[1000000000696257209528350379] = 222; - rayToBps[1000000000699359170108558644] = 223; - rayToBps[1000000000702460827274037431] = 224; - rayToBps[1000000000705562181084137268] = 225; - rayToBps[1000000000708663231598191269] = 226; - rayToBps[1000000000711763978875515140] = 227; - rayToBps[1000000000714864422975407191] = 228; - rayToBps[1000000000717964563957148338] = 229; - rayToBps[1000000000721064401880002111] = 230; - rayToBps[1000000000724163936803214665] = 231; - rayToBps[1000000000727263168786014781] = 232; - rayToBps[1000000000730362097887613873] = 233; - rayToBps[1000000000733460724167206002] = 234; - rayToBps[1000000000736559047683967873] = 235; - rayToBps[1000000000739657068497058849] = 236; - rayToBps[1000000000742754786665620954] = 237; - rayToBps[1000000000745852202248778881] = 238; - rayToBps[1000000000748949315305640001] = 239; - rayToBps[1000000000752046125895294364] = 240; - rayToBps[1000000000755142634076814712] = 241; - rayToBps[1000000000758238839909256483] = 242; - rayToBps[1000000000761334743451657815] = 243; - rayToBps[1000000000764430344763039558] = 244; - rayToBps[1000000000767525643902405280] = 245; - rayToBps[1000000000770620640928741268] = 246; - rayToBps[1000000000773715335901016542] = 247; - rayToBps[1000000000776809728878182856] = 248; - rayToBps[1000000000779903819919174710] = 249; - rayToBps[1000000000782997609082909351] = 250; - rayToBps[1000000000786091096428286786] = 251; - rayToBps[1000000000789184282014189785] = 252; - rayToBps[1000000000792277165899483884] = 253; - rayToBps[1000000000795369748143017402] = 254; - rayToBps[1000000000798462028803621438] = 255; - rayToBps[1000000000801554007940109881] = 256; - rayToBps[1000000000804645685611279421] = 257; - rayToBps[1000000000807737061875909546] = 258; - rayToBps[1000000000810828136792762559] = 259; - rayToBps[1000000000813918910420583580] = 260; - rayToBps[1000000000817009382818100549] = 261; - rayToBps[1000000000820099554044024241] = 262; - rayToBps[1000000000823189424157048266] = 263; - rayToBps[1000000000826278993215849080] = 264; - rayToBps[1000000000829368261279085986] = 265; - rayToBps[1000000000832457228405401147] = 266; - rayToBps[1000000000835545894653419590] = 267; - rayToBps[1000000000838634260081749213] = 268; - rayToBps[1000000000841722324748980791] = 269; - rayToBps[1000000000844810088713687981] = 270; - rayToBps[1000000000847897552034427333] = 271; - rayToBps[1000000000850984714769738294] = 272; - rayToBps[1000000000854071576978143215] = 273; - rayToBps[1000000000857158138718147357] = 274; - rayToBps[1000000000860244400048238898] = 275; - rayToBps[1000000000863330361026888943] = 276; - rayToBps[1000000000866416021712551525] = 277; - rayToBps[1000000000869501382163663613] = 278; - rayToBps[1000000000872586442438645123] = 279; - rayToBps[1000000000875671202595898921] = 280; - rayToBps[1000000000878755662693810828] = 281; - rayToBps[1000000000881839822790749630] = 282; - rayToBps[1000000000884923682945067084] = 283; - rayToBps[1000000000888007243215097924] = 284; - rayToBps[1000000000891090503659159869] = 285; - rayToBps[1000000000894173464335553624] = 286; - rayToBps[1000000000897256125302562895] = 287; - rayToBps[1000000000900338486618454391] = 288; - rayToBps[1000000000903420548341477830] = 289; - rayToBps[1000000000906502310529865946] = 290; - rayToBps[1000000000909583773241834499] = 291; - rayToBps[1000000000912664936535582274] = 292; - rayToBps[1000000000915745800469291101] = 293; - rayToBps[1000000000918826365101125845] = 294; - rayToBps[1000000000921906630489234425] = 295; - rayToBps[1000000000924986596691747814] = 296; - rayToBps[1000000000928066263766780050] = 297; - rayToBps[1000000000931145631772428239] = 298; - rayToBps[1000000000934224700766772564] = 299; - rayToBps[1000000000937303470807876289] = 300; - rayToBps[1000000000940381941953785771] = 301; - rayToBps[1000000000943460114262530457] = 302; - rayToBps[1000000000946537987792122901] = 303; - rayToBps[1000000000949615562600558765] = 304; - rayToBps[1000000000952692838745816824] = 305; - rayToBps[1000000000955769816285858978] = 306; - rayToBps[1000000000958846495278630254] = 307; - rayToBps[1000000000961922875782058814] = 308; - rayToBps[1000000000964998957854055963] = 309; - rayToBps[1000000000968074741552516152] = 310; - rayToBps[1000000000971150226935316988] = 311; - rayToBps[1000000000974225414060319240] = 312; - rayToBps[1000000000977300302985366843] = 313; - rayToBps[1000000000980374893768286908] = 314; - rayToBps[1000000000983449186466889726] = 315; - rayToBps[1000000000986523181138968776] = 316; - rayToBps[1000000000989596877842300728] = 317; - rayToBps[1000000000992670276634645456] = 318; - rayToBps[1000000000995743377573746041] = 319; - rayToBps[1000000000998816180717328774] = 320; - rayToBps[1000000001001888686123103168] = 321; - rayToBps[1000000001004960893848761962] = 322; - rayToBps[1000000001008032803951981130] = 323; - rayToBps[1000000001011104416490419883] = 324; - rayToBps[1000000001014175731521720677] = 325; - rayToBps[1000000001017246749103509223] = 326; - rayToBps[1000000001020317469293394491] = 327; - rayToBps[1000000001023387892148968714] = 328; - rayToBps[1000000001026458017727807397] = 329; - rayToBps[1000000001029527846087469327] = 330; - rayToBps[1000000001032597377285496570] = 331; - rayToBps[1000000001035666611379414489] = 332; - rayToBps[1000000001038735548426731741] = 333; - rayToBps[1000000001041804188484940289] = 334; - rayToBps[1000000001044872531611515405] = 335; - rayToBps[1000000001047940577863915679] = 336; - rayToBps[1000000001051008327299583027] = 337; - rayToBps[1000000001054075779975942691] = 338; - rayToBps[1000000001057142935950403252] = 339; - rayToBps[1000000001060209795280356633] = 340; - rayToBps[1000000001063276358023178106] = 341; - rayToBps[1000000001066342624236226300] = 342; - rayToBps[1000000001069408593976843206] = 343; - rayToBps[1000000001072474267302354182] = 344; - rayToBps[1000000001075539644270067964] = 345; - rayToBps[1000000001078604724937276668] = 346; - rayToBps[1000000001081669509361255798] = 347; - rayToBps[1000000001084733997599264251] = 348; - rayToBps[1000000001087798189708544327] = 349; - rayToBps[1000000001090862085746321732] = 350; - rayToBps[1000000001093925685769805588] = 351; - rayToBps[1000000001096988989836188433] = 352; - rayToBps[1000000001100051998002646234] = 353; - rayToBps[1000000001103114710326338391] = 354; - rayToBps[1000000001106177126864407743] = 355; - rayToBps[1000000001109239247673980573] = 356; - rayToBps[1000000001112301072812166619] = 357; - rayToBps[1000000001115362602336059074] = 358; - rayToBps[1000000001118423836302734600] = 359; - rayToBps[1000000001121484774769253326] = 360; - rayToBps[1000000001124545417792658861] = 361; - rayToBps[1000000001127605765429978297] = 362; - rayToBps[1000000001130665817738222219] = 363; - rayToBps[1000000001133725574774384703] = 364; - rayToBps[1000000001136785036595443334] = 365; - rayToBps[1000000001139844203258359204] = 366; - rayToBps[1000000001142903074820076919] = 367; - rayToBps[1000000001145961651337524612] = 368; - rayToBps[1000000001149019932867613939] = 369; - rayToBps[1000000001152077919467240095] = 370; - rayToBps[1000000001155135611193281814] = 371; - rayToBps[1000000001158193008102601379] = 372; - rayToBps[1000000001161250110252044625] = 373; - rayToBps[1000000001164306917698440949] = 374; - rayToBps[1000000001167363430498603315] = 375; - rayToBps[1000000001170419648709328258] = 376; - rayToBps[1000000001173475572387395894] = 377; - rayToBps[1000000001176531201589569924] = 378; - rayToBps[1000000001179586536372597640] = 379; - rayToBps[1000000001182641576793209935] = 380; - rayToBps[1000000001185696322908121302] = 381; - rayToBps[1000000001188750774774029849] = 382; - rayToBps[1000000001191804932447617301] = 383; - rayToBps[1000000001194858795985549004] = 384; - rayToBps[1000000001197912365444473936] = 385; - rayToBps[1000000001200965640881024708] = 386; - rayToBps[1000000001204018622351817579] = 387; - rayToBps[1000000001207071309913452452] = 388; - rayToBps[1000000001210123703622512886] = 389; - rayToBps[1000000001213175803535566102] = 390; - rayToBps[1000000001216227609709162989] = 391; - rayToBps[1000000001219279122199838110] = 392; - rayToBps[1000000001222330341064109706] = 393; - rayToBps[1000000001225381266358479708] = 394; - rayToBps[1000000001228431898139433735] = 395; - rayToBps[1000000001231482236463441109] = 396; - rayToBps[1000000001234532281386954858] = 397; - rayToBps[1000000001237582032966411716] = 398; - rayToBps[1000000001240631491258232141] = 399; - rayToBps[1000000001243680656318820312] = 400; - rayToBps[1000000001246729528204564139] = 401; - rayToBps[1000000001249778106971835268] = 402; - rayToBps[1000000001252826392676989088] = 403; - rayToBps[1000000001255874385376364739] = 404; - rayToBps[1000000001258922085126285113] = 405; - rayToBps[1000000001261969491983056866] = 406; - rayToBps[1000000001265016606002970422] = 407; - rayToBps[1000000001268063427242299977] = 408; - rayToBps[1000000001271109955757303509] = 409; - rayToBps[1000000001274156191604222783] = 410; - rayToBps[1000000001277202134839283355] = 411; - rayToBps[1000000001280247785518694582] = 412; - rayToBps[1000000001283293143698649624] = 413; - rayToBps[1000000001286338209435325454] = 414; - rayToBps[1000000001289382982784882863] = 415; - rayToBps[1000000001292427463803466464] = 416; - rayToBps[1000000001295471652547204702] = 417; - rayToBps[1000000001298515549072209857] = 418; - rayToBps[1000000001301559153434578054] = 419; - rayToBps[1000000001304602465690389263] = 420; - rayToBps[1000000001307645485895707309] = 421; - rayToBps[1000000001310688214106579884] = 422; - rayToBps[1000000001313730650379038540] = 423; - rayToBps[1000000001316772794769098706] = 424; - rayToBps[1000000001319814647332759691] = 425; - rayToBps[1000000001322856208126004689] = 426; - rayToBps[1000000001325897477204800787] = 427; - rayToBps[1000000001328938454625098968] = 428; - rayToBps[1000000001331979140442834120] = 429; - rayToBps[1000000001335019534713925045] = 430; - rayToBps[1000000001338059637494274457] = 431; - rayToBps[1000000001341099448839768997] = 432; - rayToBps[1000000001344138968806279230] = 433; - rayToBps[1000000001347178197449659663] = 434; - rayToBps[1000000001350217134825748738] = 435; - rayToBps[1000000001353255780990368849] = 436; - rayToBps[1000000001356294135999326341] = 437; - rayToBps[1000000001359332199908411521] = 438; - rayToBps[1000000001362369972773398659] = 439; - rayToBps[1000000001365407454650046000] = 440; - rayToBps[1000000001368444645594095767] = 441; - rayToBps[1000000001371481545661274166] = 442; - rayToBps[1000000001374518154907291394] = 443; - rayToBps[1000000001377554473387841645] = 444; - rayToBps[1000000001380590501158603116] = 445; - rayToBps[1000000001383626238275238013] = 446; - rayToBps[1000000001386661684793392556] = 447; - rayToBps[1000000001389696840768696987] = 448; - rayToBps[1000000001392731706256765577] = 449; - rayToBps[1000000001395766281313196627] = 450; - rayToBps[1000000001398800565993572478] = 451; - rayToBps[1000000001401834560353459521] = 452; - rayToBps[1000000001404868264448408194] = 453; - rayToBps[1000000001407901678333952993] = 454; - rayToBps[1000000001410934802065612482] = 455; - rayToBps[1000000001413967635698889291] = 456; - rayToBps[1000000001417000179289270128] = 457; - rayToBps[1000000001420032432892225782] = 458; - rayToBps[1000000001423064396563211131] = 459; - rayToBps[1000000001426096070357665149] = 460; - rayToBps[1000000001429127454331010908] = 461; - rayToBps[1000000001432158548538655588] = 462; - rayToBps[1000000001435189353035990479] = 463; - rayToBps[1000000001438219867878390995] = 464; - rayToBps[1000000001441250093121216670] = 465; - rayToBps[1000000001444280028819811170] = 466; - rayToBps[1000000001447309675029502300] = 467; - rayToBps[1000000001450339031805602006] = 468; - rayToBps[1000000001453368099203406382] = 469; - rayToBps[1000000001456396877278195681] = 470; - rayToBps[1000000001459425366085234312] = 471; - rayToBps[1000000001462453565679770855] = 472; - rayToBps[1000000001465481476117038063] = 473; - rayToBps[1000000001468509097452252866] = 474; - rayToBps[1000000001471536429740616381] = 475; - rayToBps[1000000001474563473037313917] = 476; - rayToBps[1000000001477590227397514978] = 477; - rayToBps[1000000001480616692876373275] = 478; - rayToBps[1000000001483642869529026724] = 479; - rayToBps[1000000001486668757410597461] = 480; - rayToBps[1000000001489694356576191838] = 481; - rayToBps[1000000001492719667080900443] = 482; - rayToBps[1000000001495744688979798088] = 483; - rayToBps[1000000001498769422327943831] = 484; - rayToBps[1000000001501793867180380974] = 485; - rayToBps[1000000001504818023592137069] = 486; - rayToBps[1000000001507841891618223927] = 487; - rayToBps[1000000001510865471313637625] = 488; - rayToBps[1000000001513888762733358503] = 489; - rayToBps[1000000001516911765932351183] = 490; - rayToBps[1000000001519934480965564567] = 491; - rayToBps[1000000001522956907887931841] = 492; - rayToBps[1000000001525979046754370490] = 493; - rayToBps[1000000001529000897619782295] = 494; - rayToBps[1000000001532022460539053343] = 495; - rayToBps[1000000001535043735567054034] = 496; - rayToBps[1000000001538064722758639085] = 497; - rayToBps[1000000001541085422168647535] = 498; - rayToBps[1000000001544105833851902754] = 499; - rayToBps[1000000001547125957863212448] = 500; - rayToBps[1000000001550145794257368662] = 501; - rayToBps[1000000001553165343089147790] = 502; - rayToBps[1000000001556184604413310579] = 503; - rayToBps[1000000001559203578284602136] = 504; - rayToBps[1000000001562222264757751932] = 505; - rayToBps[1000000001565240663887473810] = 506; - rayToBps[1000000001568258775728465991] = 507; - rayToBps[1000000001571276600335411077] = 508; - rayToBps[1000000001574294137762976059] = 509; - rayToBps[1000000001577311388065812327] = 510; - rayToBps[1000000001580328351298555666] = 511; - rayToBps[1000000001583345027515826272] = 512; - rayToBps[1000000001586361416772228753] = 513; - rayToBps[1000000001589377519122352136] = 514; - rayToBps[1000000001592393334620769870] = 515; - rayToBps[1000000001595408863322039839] = 516; - rayToBps[1000000001598424105280704358] = 517; - rayToBps[1000000001601439060551290189] = 518; - rayToBps[1000000001604453729188308543] = 519; - rayToBps[1000000001607468111246255079] = 520; - rayToBps[1000000001610482206779609923] = 521; - rayToBps[1000000001613496015842837664] = 522; - rayToBps[1000000001616509538490387361] = 523; - rayToBps[1000000001619522774776692555] = 524; - rayToBps[1000000001622535724756171269] = 525; - rayToBps[1000000001625548388483226015] = 526; - rayToBps[1000000001628560766012243800] = 527; - rayToBps[1000000001631572857397596136] = 528; - rayToBps[1000000001634584662693639037] = 529; - rayToBps[1000000001637596181954713035] = 530; - rayToBps[1000000001640607415235143177] = 531; - rayToBps[1000000001643618362589239040] = 532; - rayToBps[1000000001646629024071294727] = 533; - rayToBps[1000000001649639399735588881] = 534; - rayToBps[1000000001652649489636384685] = 535; - rayToBps[1000000001655659293827929873] = 536; - rayToBps[1000000001658668812364456731] = 537; - rayToBps[1000000001661678045300182106] = 538; - rayToBps[1000000001664686992689307414] = 539; - rayToBps[1000000001667695654586018638] = 540; - rayToBps[1000000001670704031044486342] = 541; - rayToBps[1000000001673712122118865672] = 542; - rayToBps[1000000001676719927863296364] = 543; - rayToBps[1000000001679727448331902751] = 544; - rayToBps[1000000001682734683578793766] = 545; - rayToBps[1000000001685741633658062946] = 546; - rayToBps[1000000001688748298623788446] = 547; - rayToBps[1000000001691754678530033036] = 548; - rayToBps[1000000001694760773430844112] = 549; - rayToBps[1000000001697766583380253701] = 550; - rayToBps[1000000001700772108432278464] = 551; - rayToBps[1000000001703777348640919706] = 552; - rayToBps[1000000001706782304060163379] = 553; - rayToBps[1000000001709786974743980088] = 554; - rayToBps[1000000001712791360746325100] = 555; - rayToBps[1000000001715795462121138343] = 556; - rayToBps[1000000001718799278922344419] = 557; - rayToBps[1000000001721802811203852608] = 558; - rayToBps[1000000001724806059019556870] = 559; - rayToBps[1000000001727809022423335855] = 560; - rayToBps[1000000001730811701469052906] = 561; - rayToBps[1000000001733814096210556068] = 562; - rayToBps[1000000001736816206701678090] = 563; - rayToBps[1000000001739818032996236434] = 564; - rayToBps[1000000001742819575148033278] = 565; - rayToBps[1000000001745820833210855527] = 566; - rayToBps[1000000001748821807238474808] = 567; - rayToBps[1000000001751822497284647491] = 568; - rayToBps[1000000001754822903403114680] = 569; - rayToBps[1000000001757823025647602229] = 570; - rayToBps[1000000001760822864071820743] = 571; - rayToBps[1000000001763822418729465585] = 572; - rayToBps[1000000001766821689674216882] = 573; - rayToBps[1000000001769820676959739530] = 574; - rayToBps[1000000001772819380639683201] = 575; - rayToBps[1000000001775817800767682345] = 576; - rayToBps[1000000001778815937397356203] = 577; - rayToBps[1000000001781813790582308807] = 578; - rayToBps[1000000001784811360376128985] = 579; - rayToBps[1000000001787808646832390371] = 580; - rayToBps[1000000001790805650004651410] = 581; - rayToBps[1000000001793802369946455358] = 582; - rayToBps[1000000001796798806711330296] = 583; - rayToBps[1000000001799794960352789133] = 584; - rayToBps[1000000001802790830924329607] = 585; - rayToBps[1000000001805786418479434295] = 586; - rayToBps[1000000001808781723071570620] = 587; - rayToBps[1000000001811776744754190855] = 588; - rayToBps[1000000001814771483580732126] = 589; - rayToBps[1000000001817765939604616422] = 590; - rayToBps[1000000001820760112879250599] = 591; - rayToBps[1000000001823754003458026386] = 592; - rayToBps[1000000001826747611394320388] = 593; - rayToBps[1000000001829740936741494099] = 594; - rayToBps[1000000001832733979552893898] = 595; - rayToBps[1000000001835726739881851062] = 596; - rayToBps[1000000001838719217781681769] = 597; - rayToBps[1000000001841711413305687103] = 598; - rayToBps[1000000001844703326507153063] = 599; - rayToBps[1000000001847694957439350562] = 600; - rayToBps[1000000001850686306155535442] = 601; - rayToBps[1000000001853677372708948472] = 602; - rayToBps[1000000001856668157152815356] = 603; - rayToBps[1000000001859658659540346741] = 604; - rayToBps[1000000001862648879924738219] = 605; - rayToBps[1000000001865638818359170337] = 606; - rayToBps[1000000001868628474896808595] = 607; - rayToBps[1000000001871617849590803463] = 608; - rayToBps[1000000001874606942494290377] = 609; - rayToBps[1000000001877595753660389747] = 610; - rayToBps[1000000001880584283142206967] = 611; - rayToBps[1000000001883572530992832417] = 612; - rayToBps[1000000001886560497265341466] = 613; - rayToBps[1000000001889548182012794484] = 614; - rayToBps[1000000001892535585288236844] = 615; - rayToBps[1000000001895522707144698926] = 616; - rayToBps[1000000001898509547635196126] = 617; - rayToBps[1000000001901496106812728862] = 618; - rayToBps[1000000001904482384730282575] = 619; - rayToBps[1000000001907468381440827740] = 620; - rayToBps[1000000001910454096997319869] = 621; - rayToBps[1000000001913439531452699514] = 622; - rayToBps[1000000001916424684859892282] = 623; - rayToBps[1000000001919409557271808825] = 624; - rayToBps[1000000001922394148741344865] = 625; - rayToBps[1000000001925378459321381181] = 626; - rayToBps[1000000001928362489064783628] = 627; - rayToBps[1000000001931346238024403135] = 628; - rayToBps[1000000001934329706253075715] = 629; - rayToBps[1000000001937312893803622469] = 630; - rayToBps[1000000001940295800728849590] = 631; - rayToBps[1000000001943278427081548373] = 632; - rayToBps[1000000001946260772914495212] = 633; - rayToBps[1000000001949242838280451618] = 634; - rayToBps[1000000001952224623232164215] = 635; - rayToBps[1000000001955206127822364746] = 636; - rayToBps[1000000001958187352103770087] = 637; - rayToBps[1000000001961168296129082241] = 638; - rayToBps[1000000001964148959950988353] = 639; - rayToBps[1000000001967129343622160710] = 640; - rayToBps[1000000001970109447195256751] = 641; - rayToBps[1000000001973089270722919065] = 642; - rayToBps[1000000001976068814257775407] = 643; - rayToBps[1000000001979048077852438695] = 644; - rayToBps[1000000001982027061559507021] = 645; - rayToBps[1000000001985005765431563653] = 646; - rayToBps[1000000001987984189521177042] = 647; - rayToBps[1000000001990962333880900827] = 648; - rayToBps[1000000001993940198563273844] = 649; - rayToBps[1000000001996917783620820123] = 650; - rayToBps[1000000001999895089106048906] = 651; - rayToBps[1000000002002872115071454639] = 652; - rayToBps[1000000002005848861569516991] = 653; - rayToBps[1000000002008825328652700847] = 654; - rayToBps[1000000002011801516373456324] = 655; - rayToBps[1000000002014777424784218768] = 656; - rayToBps[1000000002017753053937408767] = 657; - rayToBps[1000000002020728403885432150] = 658; - rayToBps[1000000002023703474680679997] = 659; - rayToBps[1000000002026678266375528644] = 660; - rayToBps[1000000002029652779022339687] = 661; - rayToBps[1000000002032627012673459986] = 662; - rayToBps[1000000002035600967381221676] = 663; - rayToBps[1000000002038574643197942168] = 664; - rayToBps[1000000002041548040175924154] = 665; - rayToBps[1000000002044521158367455616] = 666; - rayToBps[1000000002047493997824809831] = 667; - rayToBps[1000000002050466558600245373] = 668; - rayToBps[1000000002053438840746006121] = 669; - rayToBps[1000000002056410844314321266] = 670; - rayToBps[1000000002059382569357405313] = 671; - rayToBps[1000000002062354015927458089] = 672; - rayToBps[1000000002065325184076664749] = 673; - rayToBps[1000000002068296073857195778] = 674; - rayToBps[1000000002071266685321207000] = 675; - rayToBps[1000000002074237018520839584] = 676; - rayToBps[1000000002077207073508220045] = 677; - rayToBps[1000000002080176850335460252] = 678; - rayToBps[1000000002083146349054657437] = 679; - rayToBps[1000000002086115569717894196] = 680; - rayToBps[1000000002089084512377238493] = 681; - rayToBps[1000000002092053177084743673] = 682; - rayToBps[1000000002095021563892448458] = 683; - rayToBps[1000000002097989672852376961] = 684; - rayToBps[1000000002100957504016538685] = 685; - rayToBps[1000000002103925057436928532] = 686; - rayToBps[1000000002106892333165526808] = 687; - rayToBps[1000000002109859331254299227] = 688; - rayToBps[1000000002112826051755196920] = 689; - rayToBps[1000000002115792494720156434] = 690; - rayToBps[1000000002118758660201099744] = 691; - rayToBps[1000000002121724548249934257] = 692; - rayToBps[1000000002124690158918552812] = 693; - rayToBps[1000000002127655492258833695] = 694; - rayToBps[1000000002130620548322640635] = 695; - rayToBps[1000000002133585327161822816] = 696; - rayToBps[1000000002136549828828214880] = 697; - rayToBps[1000000002139514053373636932] = 698; - rayToBps[1000000002142478000849894543] = 699; - rayToBps[1000000002145441671308778766] = 700; - rayToBps[1000000002148405064802066124] = 701; - rayToBps[1000000002151368181381518635] = 702; - rayToBps[1000000002154331021098883800] = 703; - rayToBps[1000000002157293584005894622] = 704; - rayToBps[1000000002160255870154269599] = 705; - rayToBps[1000000002163217879595712742] = 706; - rayToBps[1000000002166179612381913573] = 707; - rayToBps[1000000002169141068564547128] = 708; - rayToBps[1000000002172102248195273969] = 709; - rayToBps[1000000002175063151325740189] = 710; - rayToBps[1000000002178023778007577411] = 711; - rayToBps[1000000002180984128292402799] = 712; - rayToBps[1000000002183944202231819060] = 713; - rayToBps[1000000002186903999877414455] = 714; - rayToBps[1000000002189863521280762799] = 715; - rayToBps[1000000002192822766493423465] = 716; - rayToBps[1000000002195781735566941395] = 717; - rayToBps[1000000002198740428552847104] = 718; - rayToBps[1000000002201698845502656681] = 719; - rayToBps[1000000002204656986467871801] = 720; - rayToBps[1000000002207614851499979723] = 721; - rayToBps[1000000002210572440650453302] = 722; - rayToBps[1000000002213529753970750991] = 723; - rayToBps[1000000002216486791512316847] = 724; - rayToBps[1000000002219443553326580536] = 725; - rayToBps[1000000002222400039464957340] = 726; - rayToBps[1000000002225356249978848158] = 727; - rayToBps[1000000002228312184919639519] = 728; - rayToBps[1000000002231267844338703579] = 729; - rayToBps[1000000002234223228287398132] = 730; - rayToBps[1000000002237178336817066613] = 731; - rayToBps[1000000002240133169979038105] = 732; - rayToBps[1000000002243087727824627342] = 733; - rayToBps[1000000002246042010405134715] = 734; - rayToBps[1000000002248996017771846281] = 735; - rayToBps[1000000002251949749976033760] = 736; - rayToBps[1000000002254903207068954551] = 737; - rayToBps[1000000002257856389101851730] = 738; - rayToBps[1000000002260809296125954056] = 739; - rayToBps[1000000002263761928192475979] = 740; - rayToBps[1000000002266714285352617643] = 741; - rayToBps[1000000002269666367657564895] = 742; - rayToBps[1000000002272618175158489283] = 743; - rayToBps[1000000002275569707906548069] = 744; - rayToBps[1000000002278520965952884232] = 745; - rayToBps[1000000002281471949348626470] = 746; - rayToBps[1000000002284422658144889210] = 747; - rayToBps[1000000002287373092392772609] = 748; - rayToBps[1000000002290323252143362564] = 749; - rayToBps[1000000002293273137447730714] = 750; - rayToBps[1000000002296222748356934445] = 751; - rayToBps[1000000002299172084922016896] = 752; - rayToBps[1000000002302121147194006968] = 753; - rayToBps[1000000002305069935223919323] = 754; - rayToBps[1000000002308018449062754392] = 755; - rayToBps[1000000002310966688761498383] = 756; - rayToBps[1000000002313914654371123283] = 757; - rayToBps[1000000002316862345942586863] = 758; - rayToBps[1000000002319809763526832687] = 759; - rayToBps[1000000002322756907174790110] = 760; - rayToBps[1000000002325703776937374294] = 761; - rayToBps[1000000002328650372865486203] = 762; - rayToBps[1000000002331596695010012613] = 763; - rayToBps[1000000002334542743421826121] = 764; - rayToBps[1000000002337488518151785139] = 765; - rayToBps[1000000002340434019250733913] = 766; - rayToBps[1000000002343379246769502519] = 767; - rayToBps[1000000002346324200758906870] = 768; - rayToBps[1000000002349268881269748722] = 769; - rayToBps[1000000002352213288352815683] = 770; - rayToBps[1000000002355157422058881210] = 771; - rayToBps[1000000002358101282438704622] = 772; - rayToBps[1000000002361044869543031102] = 773; - rayToBps[1000000002363988183422591701] = 774; - rayToBps[1000000002366931224128103346] = 775; - rayToBps[1000000002369873991710268842] = 776; - rayToBps[1000000002372816486219776883] = 777; - rayToBps[1000000002375758707707302048] = 778; - rayToBps[1000000002378700656223504817] = 779; - rayToBps[1000000002381642331819031568] = 780; - rayToBps[1000000002384583734544514586] = 781; - rayToBps[1000000002387524864450572064] = 782; - rayToBps[1000000002390465721587808119] = 783; - rayToBps[1000000002393406306006812783] = 784; - rayToBps[1000000002396346617758162017] = 785; - rayToBps[1000000002399286656892417716] = 786; - rayToBps[1000000002402226423460127711] = 787; - rayToBps[1000000002405165917511825773] = 788; - rayToBps[1000000002408105139098031627] = 789; - rayToBps[1000000002411044088269250946] = 790; - rayToBps[1000000002413982765075975363] = 791; - rayToBps[1000000002416921169568682475] = 792; - rayToBps[1000000002419859301797835847] = 793; - rayToBps[1000000002422797161813885017] = 794; - rayToBps[1000000002425734749667265506] = 795; - rayToBps[1000000002428672065408398813] = 796; - rayToBps[1000000002431609109087692432] = 797; - rayToBps[1000000002434545880755539850] = 798; - rayToBps[1000000002437482380462320552] = 799; - rayToBps[1000000002440418608258400030] = 800; - rayToBps[1000000002443354564194129787] = 801; - rayToBps[1000000002446290248319847339] = 802; - rayToBps[1000000002449225660685876223] = 803; - rayToBps[1000000002452160801342526004] = 804; - rayToBps[1000000002455095670340092277] = 805; - rayToBps[1000000002458030267728856671] = 806; - rayToBps[1000000002460964593559086859] = 807; - rayToBps[1000000002463898647881036558] = 808; - rayToBps[1000000002466832430744945540] = 809; - rayToBps[1000000002469765942201039630] = 810; - rayToBps[1000000002472699182299530718] = 811; - rayToBps[1000000002475632151090616757] = 812; - rayToBps[1000000002478564848624481779] = 813; - rayToBps[1000000002481497274951295886] = 814; - rayToBps[1000000002484429430121215269] = 815; - rayToBps[1000000002487361314184382201] = 816; - rayToBps[1000000002490292927190925051] = 817; - rayToBps[1000000002493224269190958287] = 818; - rayToBps[1000000002496155340234582476] = 819; - rayToBps[1000000002499086140371884298] = 820; - rayToBps[1000000002502016669652936543] = 821; - rayToBps[1000000002504946928127798122] = 822; - rayToBps[1000000002507876915846514067] = 823; - rayToBps[1000000002510806632859115540] = 824; - rayToBps[1000000002513736079215619839] = 825; - rayToBps[1000000002516665254966030398] = 826; - rayToBps[1000000002519594160160336795] = 827; - rayToBps[1000000002522522794848514761] = 828; - rayToBps[1000000002525451159080526178] = 829; - rayToBps[1000000002528379252906319086] = 830; - rayToBps[1000000002531307076375827697] = 831; - rayToBps[1000000002534234629538972383] = 832; - rayToBps[1000000002537161912445659699] = 833; - rayToBps[1000000002540088925145782374] = 834; - rayToBps[1000000002543015667689219327] = 835; - rayToBps[1000000002545942140125835662] = 836; - rayToBps[1000000002548868342505482685] = 837; - rayToBps[1000000002551794274877997894] = 838; - rayToBps[1000000002554719937293204998] = 839; - rayToBps[1000000002557645329800913916] = 840; - rayToBps[1000000002560570452450920783] = 841; - rayToBps[1000000002563495305293007952] = 842; - rayToBps[1000000002566419888376944003] = 843; - rayToBps[1000000002569344201752483747] = 844; - rayToBps[1000000002572268245469368232] = 845; - rayToBps[1000000002575192019577324747] = 846; - rayToBps[1000000002578115524126066824] = 847; - rayToBps[1000000002581038759165294249] = 848; - rayToBps[1000000002583961724744693064] = 849; - rayToBps[1000000002586884420913935572] = 850; - rayToBps[1000000002589806847722680342] = 851; - rayToBps[1000000002592729005220572215] = 852; - rayToBps[1000000002595650893457242308] = 853; - rayToBps[1000000002598572512482308019] = 854; - rayToBps[1000000002601493862345373033] = 855; - rayToBps[1000000002604414943096027328] = 856; - rayToBps[1000000002607335754783847177] = 857; - rayToBps[1000000002610256297458395155] = 858; - rayToBps[1000000002613176571169220145] = 859; - rayToBps[1000000002616096575965857340] = 860; - rayToBps[1000000002619016311897828252] = 861; - rayToBps[1000000002621935779014640712] = 862; - rayToBps[1000000002624854977365788881] = 863; - rayToBps[1000000002627773907000753250] = 864; - rayToBps[1000000002630692567969000648] = 865; - rayToBps[1000000002633610960319984247] = 866; - rayToBps[1000000002636529084103143562] = 867; - rayToBps[1000000002639446939367904465] = 868; - rayToBps[1000000002642364526163679182] = 869; - rayToBps[1000000002645281844539866303] = 870; - rayToBps[1000000002648198894545850784] = 871; - rayToBps[1000000002651115676231003954] = 872; - rayToBps[1000000002654032189644683517] = 873; - rayToBps[1000000002656948434836233563] = 874; - rayToBps[1000000002659864411854984565] = 875; - rayToBps[1000000002662780120750253393] = 876; - rayToBps[1000000002665695561571343309] = 877; - rayToBps[1000000002668610734367543981] = 878; - rayToBps[1000000002671525639188131484] = 879; - rayToBps[1000000002674440276082368302] = 880; - rayToBps[1000000002677354645099503340] = 881; - rayToBps[1000000002680268746288771923] = 882; - rayToBps[1000000002683182579699395804] = 883; - rayToBps[1000000002686096145380583168] = 884; - rayToBps[1000000002689009443381528638] = 885; - rayToBps[1000000002691922473751413277] = 886; - rayToBps[1000000002694835236539404598] = 887; - rayToBps[1000000002697747731794656564] = 888; - rayToBps[1000000002700659959566309596] = 889; - rayToBps[1000000002703571919903490575] = 890; - rayToBps[1000000002706483612855312853] = 891; - rayToBps[1000000002709395038470876252] = 892; - rayToBps[1000000002712306196799267069] = 893; - rayToBps[1000000002715217087889558088] = 894; - rayToBps[1000000002718127711790808573] = 895; - rayToBps[1000000002721038068552064286] = 896; - rayToBps[1000000002723948158222357482] = 897; - rayToBps[1000000002726857980850706921] = 898; - rayToBps[1000000002729767536486117866] = 899; - rayToBps[1000000002732676825177582095] = 900; - rayToBps[1000000002735585846974077901] = 901; - rayToBps[1000000002738494601924570098] = 902; - rayToBps[1000000002741403090078010029] = 903; - rayToBps[1000000002744311311483335565] = 904; - rayToBps[1000000002747219266189471117] = 905; - rayToBps[1000000002750126954245327636] = 906; - rayToBps[1000000002753034375699802616] = 907; - rayToBps[1000000002755941530601780109] = 908; - rayToBps[1000000002758848419000130717] = 909; - rayToBps[1000000002761755040943711607] = 910; - rayToBps[1000000002764661396481366508] = 911; - rayToBps[1000000002767567485661925724] = 912; - rayToBps[1000000002770473308534206134] = 913; - rayToBps[1000000002773378865147011196] = 914; - rayToBps[1000000002776284155549130955] = 915; - rayToBps[1000000002779189179789342046] = 916; - rayToBps[1000000002782093937916407701] = 917; - rayToBps[1000000002784998429979077750] = 918; - rayToBps[1000000002787902656026088630] = 919; - rayToBps[1000000002790806616106163389] = 920; - rayToBps[1000000002793710310268011687] = 921; - rayToBps[1000000002796613738560329808] = 922; - rayToBps[1000000002799516901031800659] = 923; - rayToBps[1000000002802419797731093776] = 924; - rayToBps[1000000002805322428706865331] = 925; - rayToBps[1000000002808224794007758136] = 926; - rayToBps[1000000002811126893682401646] = 927; - rayToBps[1000000002814028727779411968] = 928; - rayToBps[1000000002816930296347391860] = 929; - rayToBps[1000000002819831599434930742] = 930; - rayToBps[1000000002822732637090604696] = 931; - rayToBps[1000000002825633409362976474] = 932; - rayToBps[1000000002828533916300595503] = 933; - rayToBps[1000000002831434157951997885] = 934; - rayToBps[1000000002834334134365706412] = 935; - rayToBps[1000000002837233845590230556] = 936; - rayToBps[1000000002840133291674066490] = 937; - rayToBps[1000000002843032472665697081] = 938; - rayToBps[1000000002845931388613591900] = 939; - rayToBps[1000000002848830039566207226] = 940; - rayToBps[1000000002851728425571986050] = 941; - rayToBps[1000000002854626546679358084] = 942; - rayToBps[1000000002857524402936739757] = 943; - rayToBps[1000000002860421994392534231] = 944; - rayToBps[1000000002863319321095131394] = 945; - rayToBps[1000000002866216383092907878] = 946; - rayToBps[1000000002869113180434227051] = 947; - rayToBps[1000000002872009713167439031] = 948; - rayToBps[1000000002874905981340880687] = 949; - rayToBps[1000000002877801985002875644] = 950; - rayToBps[1000000002880697724201734289] = 951; - rayToBps[1000000002883593198985753772] = 952; - rayToBps[1000000002886488409403218019] = 953; - rayToBps[1000000002889383355502397729] = 954; - rayToBps[1000000002892278037331550380] = 955; - rayToBps[1000000002895172454938920238] = 956; - rayToBps[1000000002898066608372738360] = 957; - rayToBps[1000000002900960497681222594] = 958; - rayToBps[1000000002903854122912577591] = 959; - rayToBps[1000000002906747484114994807] = 960; - rayToBps[1000000002909640581336652506] = 961; - rayToBps[1000000002912533414625715766] = 962; - rayToBps[1000000002915425984030336485] = 963; - rayToBps[1000000002918318289598653387] = 964; - rayToBps[1000000002921210331378792020] = 965; - rayToBps[1000000002924102109418864770] = 966; - rayToBps[1000000002926993623766970860] = 967; - rayToBps[1000000002929884874471196354] = 968; - rayToBps[1000000002932775861579614167] = 969; - rayToBps[1000000002935666585140284065] = 970; - rayToBps[1000000002938557045201252671] = 971; - rayToBps[1000000002941447241810553473] = 972; - rayToBps[1000000002944337175016206824] = 973; - rayToBps[1000000002947226844866219949] = 974; - rayToBps[1000000002950116251408586949] = 975; - rayToBps[1000000002953005394691288810] = 976; - rayToBps[1000000002955894274762293401] = 977; - rayToBps[1000000002958782891669555482] = 978; - rayToBps[1000000002961671245461016710] = 979; - rayToBps[1000000002964559336184605642] = 980; - rayToBps[1000000002967447163888237741] = 981; - rayToBps[1000000002970334728619815381] = 982; - rayToBps[1000000002973222030427227847] = 983; - rayToBps[1000000002976109069358351348] = 984; - rayToBps[1000000002978995845461049016] = 985; - rayToBps[1000000002981882358783170911] = 986; - rayToBps[1000000002984768609372554028] = 987; - rayToBps[1000000002987654597277022302] = 988; - rayToBps[1000000002990540322544386608] = 989; - rayToBps[1000000002993425785222444772] = 990; - rayToBps[1000000002996310985358981573] = 991; - rayToBps[1000000002999195923001768747] = 992; - rayToBps[1000000003002080598198564991] = 993; - rayToBps[1000000003004965010997115971] = 994; - rayToBps[1000000003007849161445154325] = 995; - rayToBps[1000000003010733049590399667] = 996; - rayToBps[1000000003013616675480558594] = 997; - rayToBps[1000000003016500039163324684] = 998; - rayToBps[1000000003019383140686378514] = 999; - rayToBps[1000000003022265980097387650] = 1000; - rayToBps[1000000003025148557444006661] = 1001; - rayToBps[1000000003028030872773877120] = 1002; - rayToBps[1000000003030912926134627612] = 1003; - rayToBps[1000000003033794717573873734] = 1004; - rayToBps[1000000003036676247139218104] = 1005; - rayToBps[1000000003039557514878250362] = 1006; - rayToBps[1000000003042438520838547180] = 1007; - rayToBps[1000000003045319265067672258] = 1008; - rayToBps[1000000003048199747613176340] = 1009; - rayToBps[1000000003051079968522597209] = 1010; - rayToBps[1000000003053959927843459697] = 1011; - rayToBps[1000000003056839625623275688] = 1012; - rayToBps[1000000003059719061909544123] = 1013; - rayToBps[1000000003062598236749751004] = 1014; - rayToBps[1000000003065477150191369400] = 1015; - rayToBps[1000000003068355802281859451] = 1016; - rayToBps[1000000003071234193068668372] = 1017; - rayToBps[1000000003074112322599230459] = 1018; - rayToBps[1000000003076990190920967093] = 1019; - rayToBps[1000000003079867798081286746] = 1020; - rayToBps[1000000003082745144127584981] = 1021; - rayToBps[1000000003085622229107244463] = 1022; - rayToBps[1000000003088499053067634962] = 1023; - rayToBps[1000000003091375616056113353] = 1024; - rayToBps[1000000003094251918120023627] = 1025; - rayToBps[1000000003097127959306696891] = 1026; - rayToBps[1000000003100003739663451375] = 1027; - rayToBps[1000000003102879259237592437] = 1028; - rayToBps[1000000003105754518076412567] = 1029; - rayToBps[1000000003108629516227191390] = 1030; - rayToBps[1000000003111504253737195675] = 1031; - rayToBps[1000000003114378730653679332] = 1032; - rayToBps[1000000003117252947023883428] = 1033; - rayToBps[1000000003120126902895036179] = 1034; - rayToBps[1000000003123000598314352966] = 1035; - rayToBps[1000000003125874033329036329] = 1036; - rayToBps[1000000003128747207986275984] = 1037; - rayToBps[1000000003131620122333248815] = 1038; - rayToBps[1000000003134492776417118886] = 1039; - rayToBps[1000000003137365170285037445] = 1040; - rayToBps[1000000003140237303984142929] = 1041; - rayToBps[1000000003143109177561560964] = 1042; - rayToBps[1000000003145980791064404376] = 1043; - rayToBps[1000000003148852144539773190] = 1044; - rayToBps[1000000003151723238034754641] = 1045; - rayToBps[1000000003154594071596423170] = 1046; - rayToBps[1000000003157464645271840438] = 1047; - rayToBps[1000000003160334959108055323] = 1048; - rayToBps[1000000003163205013152103932] = 1049; - rayToBps[1000000003166074807451009595] = 1050; - rayToBps[1000000003168944342051782881] = 1051; - rayToBps[1000000003171813617001421599] = 1052; - rayToBps[1000000003174682632346910796] = 1053; - rayToBps[1000000003177551388135222770] = 1054; - rayToBps[1000000003180419884413317071] = 1055; - rayToBps[1000000003183288121228140507] = 1056; - rayToBps[1000000003186156098626627147] = 1057; - rayToBps[1000000003189023816655698326] = 1058; - rayToBps[1000000003191891275362262652] = 1059; - rayToBps[1000000003194758474793216004] = 1060; - rayToBps[1000000003197625414995441546] = 1061; - rayToBps[1000000003200492096015809725] = 1062; - rayToBps[1000000003203358517901178277] = 1063; - rayToBps[1000000003206224680698392232] = 1064; - rayToBps[1000000003209090584454283919] = 1065; - rayToBps[1000000003211956229215672970] = 1066; - rayToBps[1000000003214821615029366324] = 1067; - rayToBps[1000000003217686741942158234] = 1068; - rayToBps[1000000003220551610000830269] = 1069; - rayToBps[1000000003223416219252151318] = 1070; - rayToBps[1000000003226280569742877599] = 1071; - rayToBps[1000000003229144661519752659] = 1072; - rayToBps[1000000003232008494629507379] = 1073; - rayToBps[1000000003234872069118859983] = 1074; - rayToBps[1000000003237735385034516037] = 1075; - rayToBps[1000000003240598442423168457] = 1076; - rayToBps[1000000003243461241331497510] = 1077; - rayToBps[1000000003246323781806170825] = 1078; - rayToBps[1000000003249186063893843391] = 1079; - rayToBps[1000000003252048087641157566] = 1080; - rayToBps[1000000003254909853094743078] = 1081; - rayToBps[1000000003257771360301217032] = 1082; - rayToBps[1000000003260632609307183913] = 1083; - rayToBps[1000000003263493600159235596] = 1084; - rayToBps[1000000003266354332903951338] = 1085; - rayToBps[1000000003269214807587897798] = 1086; - rayToBps[1000000003272075024257629030] = 1087; - rayToBps[1000000003274934982959686493] = 1088; - rayToBps[1000000003277794683740599053] = 1089; - rayToBps[1000000003280654126646882991] = 1090; - rayToBps[1000000003283513311725042002] = 1091; - rayToBps[1000000003286372239021567206] = 1092; - rayToBps[1000000003289230908582937149] = 1093; - rayToBps[1000000003292089320455617805] = 1094; - rayToBps[1000000003294947474686062586] = 1095; - rayToBps[1000000003297805371320712343] = 1096; - rayToBps[1000000003300663010405995372] = 1097; - rayToBps[1000000003303520391988327418] = 1098; - rayToBps[1000000003306377516114111677] = 1099; - rayToBps[1000000003309234382829738808] = 1100; - rayToBps[1000000003312090992181586929] = 1101; - rayToBps[1000000003314947344216021625] = 1102; - rayToBps[1000000003317803438979395953] = 1103; - rayToBps[1000000003320659276518050449] = 1104; - rayToBps[1000000003323514856878313124] = 1105; - rayToBps[1000000003326370180106499479] = 1106; - rayToBps[1000000003329225246248912502] = 1107; - rayToBps[1000000003332080055351842678] = 1108; - rayToBps[1000000003334934607461567985] = 1109; - rayToBps[1000000003337788902624353911] = 1110; - rayToBps[1000000003340642940886453447] = 1111; - rayToBps[1000000003343496722294107097] = 1112; - rayToBps[1000000003346350246893542883] = 1113; - rayToBps[1000000003349203514730976348] = 1114; - rayToBps[1000000003352056525852610558] = 1115; - rayToBps[1000000003354909280304636111] = 1116; - rayToBps[1000000003357761778133231141] = 1117; - rayToBps[1000000003360614019384561319] = 1118; - rayToBps[1000000003363466004104779860] = 1119; - rayToBps[1000000003366317732340027527] = 1120; - rayToBps[1000000003369169204136432636] = 1121; - rayToBps[1000000003372020419540111060] = 1122; - rayToBps[1000000003374871378597166232] = 1123; - rayToBps[1000000003377722081353689153] = 1124; - rayToBps[1000000003380572527855758393] = 1125; - rayToBps[1000000003383422718149440098] = 1126; - rayToBps[1000000003386272652280787992] = 1127; - rayToBps[1000000003389122330295843384] = 1128; - rayToBps[1000000003391971752240635171] = 1129; - rayToBps[1000000003394820918161179843] = 1130; - rayToBps[1000000003397669828103481484] = 1131; - rayToBps[1000000003400518482113531785] = 1132; - rayToBps[1000000003403366880237310040] = 1133; - rayToBps[1000000003406215022520783154] = 1134; - rayToBps[1000000003409062909009905646] = 1135; - rayToBps[1000000003411910539750619657] = 1136; - rayToBps[1000000003414757914788854950] = 1137; - rayToBps[1000000003417605034170528915] = 1138; - rayToBps[1000000003420451897941546578] = 1139; - rayToBps[1000000003423298506147800601] = 1140; - rayToBps[1000000003426144858835171287] = 1141; - rayToBps[1000000003428990956049526585] = 1142; - rayToBps[1000000003431836797836722098] = 1143; - rayToBps[1000000003434682384242601076] = 1144; - rayToBps[1000000003437527715312994437] = 1145; - rayToBps[1000000003440372791093720759] = 1146; - rayToBps[1000000003443217611630586286] = 1147; - rayToBps[1000000003446062176969384941] = 1148; - rayToBps[1000000003448906487155898317] = 1149; - rayToBps[1000000003451750542235895695] = 1150; - rayToBps[1000000003454594342255134037] = 1151; - rayToBps[1000000003457437887259357996] = 1152; - rayToBps[1000000003460281177294299923] = 1153; - rayToBps[1000000003463124212405679865] = 1154; - rayToBps[1000000003465966992639205574] = 1155; - rayToBps[1000000003468809518040572510] = 1156; - rayToBps[1000000003471651788655463845] = 1157; - rayToBps[1000000003474493804529550469] = 1158; - rayToBps[1000000003477335565708490991] = 1159; - rayToBps[1000000003480177072237931747] = 1160; - rayToBps[1000000003483018324163506803] = 1161; - rayToBps[1000000003485859321530837959] = 1162; - rayToBps[1000000003488700064385534755] = 1163; - rayToBps[1000000003491540552773194473] = 1164; - rayToBps[1000000003494380786739402144] = 1165; - rayToBps[1000000003497220766329730547] = 1166; - rayToBps[1000000003500060491589740224] = 1167; - rayToBps[1000000003502899962564979471] = 1168; - rayToBps[1000000003505739179300984355] = 1169; - rayToBps[1000000003508578141843278707] = 1170; - rayToBps[1000000003511416850237374137] = 1171; - rayToBps[1000000003514255304528770030] = 1172; - rayToBps[1000000003517093504762953555] = 1173; - rayToBps[1000000003519931450985399667] = 1174; - rayToBps[1000000003522769143241571114] = 1175; - rayToBps[1000000003525606581576918439] = 1176; - rayToBps[1000000003528443766036879984] = 1177; - rayToBps[1000000003531280696666881897] = 1178; - rayToBps[1000000003534117373512338136] = 1179; - rayToBps[1000000003536953796618650468] = 1180; - rayToBps[1000000003539789966031208483] = 1181; - rayToBps[1000000003542625881795389588] = 1182; - rayToBps[1000000003545461543956559019] = 1183; - rayToBps[1000000003548296952560069844] = 1184; - rayToBps[1000000003551132107651262963] = 1185; - rayToBps[1000000003553967009275467116] = 1186; - rayToBps[1000000003556801657477998888] = 1187; - rayToBps[1000000003559636052304162712] = 1188; - rayToBps[1000000003562470193799250871] = 1189; - rayToBps[1000000003565304082008543509] = 1190; - rayToBps[1000000003568137716977308627] = 1191; - rayToBps[1000000003570971098750802094] = 1192; - rayToBps[1000000003573804227374267648] = 1193; - rayToBps[1000000003576637102892936900] = 1194; - rayToBps[1000000003579469725352029341] = 1195; - rayToBps[1000000003582302094796752344] = 1196; - rayToBps[1000000003585134211272301170] = 1197; - rayToBps[1000000003587966074823858969] = 1198; - rayToBps[1000000003590797685496596791] = 1199; - rayToBps[1000000003593629043335673582] = 1200; - rayToBps[1000000003596460148386236193] = 1201; - rayToBps[1000000003599291000693419387] = 1202; - rayToBps[1000000003602121600302345836] = 1203; - rayToBps[1000000003604951947258126131] = 1204; - rayToBps[1000000003607782041605858785] = 1205; - rayToBps[1000000003610611883390630237] = 1206; - rayToBps[1000000003613441472657514856] = 1207; - rayToBps[1000000003616270809451574945] = 1208; - rayToBps[1000000003619099893817860747] = 1209; - rayToBps[1000000003621928725801410447] = 1210; - rayToBps[1000000003624757305447250178] = 1211; - rayToBps[1000000003627585632800394025] = 1212; - rayToBps[1000000003630413707905844031] = 1213; - rayToBps[1000000003633241530808590194] = 1214; - rayToBps[1000000003636069101553610482] = 1215; - rayToBps[1000000003638896420185870830] = 1216; - rayToBps[1000000003641723486750325145] = 1217; - rayToBps[1000000003644550301291915316] = 1218; - rayToBps[1000000003647376863855571208] = 1219; - rayToBps[1000000003650203174486210676] = 1220; - rayToBps[1000000003653029233228739563] = 1221; - rayToBps[1000000003655855040128051709] = 1222; - rayToBps[1000000003658680595229028953] = 1223; - rayToBps[1000000003661505898576541135] = 1224; - rayToBps[1000000003664330950215446102] = 1225; - rayToBps[1000000003667155750190589718] = 1226; - rayToBps[1000000003669980298546805858] = 1227; - rayToBps[1000000003672804595328916419] = 1228; - rayToBps[1000000003675628640581731322] = 1229; - rayToBps[1000000003678452434350048518] = 1230; - rayToBps[1000000003681275976678653990] = 1231; - rayToBps[1000000003684099267612321761] = 1232; - rayToBps[1000000003686922307195813890] = 1233; - rayToBps[1000000003689745095473880490] = 1234; - rayToBps[1000000003692567632491259715] = 1235; - rayToBps[1000000003695389918292677782] = 1236; - rayToBps[1000000003698211952922848960] = 1237; - rayToBps[1000000003701033736426475586] = 1238; - rayToBps[1000000003703855268848248061] = 1239; - rayToBps[1000000003706676550232844859] = 1240; - rayToBps[1000000003709497580624932527] = 1241; - rayToBps[1000000003712318360069165696] = 1242; - rayToBps[1000000003715138888610187078] = 1243; - rayToBps[1000000003717959166292627475] = 1244; - rayToBps[1000000003720779193161105781] = 1245; - rayToBps[1000000003723598969260228987] = 1246; - rayToBps[1000000003726418494634592186] = 1247; - rayToBps[1000000003729237769328778574] = 1248; - rayToBps[1000000003732056793387359459] = 1249; - rayToBps[1000000003734875566854894261] = 1250; - rayToBps[1000000003737694089775930518] = 1251; - rayToBps[1000000003740512362195003894] = 1252; - rayToBps[1000000003743330384156638173] = 1253; - rayToBps[1000000003746148155705345276] = 1254; - rayToBps[1000000003748965676885625255] = 1255; - rayToBps[1000000003751782947741966301] = 1256; - rayToBps[1000000003754599968318844752] = 1257; - rayToBps[1000000003757416738660725089] = 1258; - rayToBps[1000000003760233258812059948] = 1259; - rayToBps[1000000003763049528817290119] = 1260; - rayToBps[1000000003765865548720844553] = 1261; - rayToBps[1000000003768681318567140366] = 1262; - rayToBps[1000000003771496838400582842] = 1263; - rayToBps[1000000003774312108265565437] = 1264; - rayToBps[1000000003777127128206469785] = 1265; - rayToBps[1000000003779941898267665701] = 1266; - rayToBps[1000000003782756418493511185] = 1267; - rayToBps[1000000003785570688928352427] = 1268; - rayToBps[1000000003788384709616523810] = 1269; - rayToBps[1000000003791198480602347918] = 1270; - rayToBps[1000000003794012001930135532] = 1271; - rayToBps[1000000003796825273644185643] = 1272; - rayToBps[1000000003799638295788785451] = 1273; - rayToBps[1000000003802451068408210371] = 1274; - rayToBps[1000000003805263591546724039] = 1275; - rayToBps[1000000003808075865248578310] = 1276; - rayToBps[1000000003810887889558013269] = 1277; - rayToBps[1000000003813699664519257234] = 1278; - rayToBps[1000000003816511190176526753] = 1279; - rayToBps[1000000003819322466574026619] = 1280; - rayToBps[1000000003822133493755949867] = 1281; - rayToBps[1000000003824944271766477781] = 1282; - rayToBps[1000000003827754800649779894] = 1283; - rayToBps[1000000003830565080450014001] = 1284; - rayToBps[1000000003833375111211326151] = 1285; - rayToBps[1000000003836184892977850664] = 1286; - rayToBps[1000000003838994425793710125] = 1287; - rayToBps[1000000003841803709703015394] = 1288; - rayToBps[1000000003844612744749865606] = 1289; - rayToBps[1000000003847421530978348180] = 1290; - rayToBps[1000000003850230068432538818] = 1291; - rayToBps[1000000003853038357156501515] = 1292; - rayToBps[1000000003855846397194288557] = 1293; - rayToBps[1000000003858654188589940528] = 1294; - rayToBps[1000000003861461731387486315] = 1295; - rayToBps[1000000003864269025630943112] = 1296; - rayToBps[1000000003867076071364316422] = 1297; - rayToBps[1000000003869882868631600065] = 1298; - rayToBps[1000000003872689417476776174] = 1299; - rayToBps[1000000003875495717943815211] = 1300; - rayToBps[1000000003878301770076675963] = 1301; - rayToBps[1000000003881107573919305546] = 1302; - rayToBps[1000000003883913129515639415] = 1303; - rayToBps[1000000003886718436909601359] = 1304; - rayToBps[1000000003889523496145103516] = 1305; - rayToBps[1000000003892328307266046370] = 1306; - rayToBps[1000000003895132870316318753] = 1307; - rayToBps[1000000003897937185339797857] = 1308; - rayToBps[1000000003900741252380349234] = 1309; - rayToBps[1000000003903545071481826796] = 1310; - rayToBps[1000000003906348642688072829] = 1311; - rayToBps[1000000003909151966042917985] = 1312; - rayToBps[1000000003911955041590181299] = 1313; - rayToBps[1000000003914757869373670180] = 1314; - rayToBps[1000000003917560449437180427] = 1315; - rayToBps[1000000003920362781824496225] = 1316; - rayToBps[1000000003923164866579390151] = 1317; - rayToBps[1000000003925966703745623181] = 1318; - rayToBps[1000000003928768293366944691] = 1319; - rayToBps[1000000003931569635487092463] = 1320; - rayToBps[1000000003934370730149792686] = 1321; - rayToBps[1000000003937171577398759967] = 1322; - rayToBps[1000000003939972177277697324] = 1323; - rayToBps[1000000003942772529830296202] = 1324; - rayToBps[1000000003945572635100236468] = 1325; - rayToBps[1000000003948372493131186422] = 1326; - rayToBps[1000000003951172103966802794] = 1327; - rayToBps[1000000003953971467650730754] = 1328; - rayToBps[1000000003956770584226603915] = 1329; - rayToBps[1000000003959569453738044333] = 1330; - rayToBps[1000000003962368076228662518] = 1331; - rayToBps[1000000003965166451742057429] = 1332; - rayToBps[1000000003967964580321816489] = 1333; - rayToBps[1000000003970762462011515578] = 1334; - rayToBps[1000000003973560096854719047] = 1335; - rayToBps[1000000003976357484894979715] = 1336; - rayToBps[1000000003979154626175838876] = 1337; - rayToBps[1000000003981951520740826302] = 1338; - rayToBps[1000000003984748168633460248] = 1339; - rayToBps[1000000003987544569897247457] = 1340; - rayToBps[1000000003990340724575683160] = 1341; - rayToBps[1000000003993136632712251086] = 1342; - rayToBps[1000000003995932294350423462] = 1343; - rayToBps[1000000003998727709533661015] = 1344; - rayToBps[1000000004001522878305412984] = 1345; - rayToBps[1000000004004317800709117115] = 1346; - rayToBps[1000000004007112476788199671] = 1347; - rayToBps[1000000004009906906586075434] = 1348; - rayToBps[1000000004012701090146147709] = 1349; - rayToBps[1000000004015495027511808328] = 1350; - rayToBps[1000000004018288718726437654] = 1351; - rayToBps[1000000004021082163833404588] = 1352; - rayToBps[1000000004023875362876066566] = 1353; - rayToBps[1000000004026668315897769570] = 1354; - rayToBps[1000000004029461022941848130] = 1355; - rayToBps[1000000004032253484051625326] = 1356; - rayToBps[1000000004035045699270412795] = 1357; - rayToBps[1000000004037837668641510732] = 1358; - rayToBps[1000000004040629392208207896] = 1359; - rayToBps[1000000004043420870013781614] = 1360; - rayToBps[1000000004046212102101497785] = 1361; - rayToBps[1000000004049003088514610884] = 1362; - rayToBps[1000000004051793829296363962] = 1363; - rayToBps[1000000004054584324489988659] = 1364; - rayToBps[1000000004057374574138705201] = 1365; - rayToBps[1000000004060164578285722402] = 1366; - rayToBps[1000000004062954336974237676] = 1367; - rayToBps[1000000004065743850247437036] = 1368; - rayToBps[1000000004068533118148495099] = 1369; - rayToBps[1000000004071322140720575088] = 1370; - rayToBps[1000000004074110918006828838] = 1371; - rayToBps[1000000004076899450050396802] = 1372; - rayToBps[1000000004079687736894408050] = 1373; - rayToBps[1000000004082475778581980279] = 1374; - rayToBps[1000000004085263575156219812] = 1375; - rayToBps[1000000004088051126660221602] = 1376; - rayToBps[1000000004090838433137069242] = 1377; - rayToBps[1000000004093625494629834960] = 1378; - rayToBps[1000000004096412311181579631] = 1379; - rayToBps[1000000004099198882835352777] = 1380; - rayToBps[1000000004101985209634192573] = 1381; - rayToBps[1000000004104771291621125847] = 1382; - rayToBps[1000000004107557128839168089] = 1383; - rayToBps[1000000004110342721331323451] = 1384; - rayToBps[1000000004113128069140584754] = 1385; - rayToBps[1000000004115913172309933491] = 1386; - rayToBps[1000000004118698030882339831] = 1387; - rayToBps[1000000004121482644900762619] = 1388; - rayToBps[1000000004124267014408149388] = 1389; - rayToBps[1000000004127051139447436357] = 1390; - rayToBps[1000000004129835020061548436] = 1391; - rayToBps[1000000004132618656293399231] = 1392; - rayToBps[1000000004135402048185891048] = 1393; - rayToBps[1000000004138185195781914895] = 1394; - rayToBps[1000000004140968099124350490] = 1395; - rayToBps[1000000004143750758256066259] = 1396; - rayToBps[1000000004146533173219919347] = 1397; - rayToBps[1000000004149315344058755615] = 1398; - rayToBps[1000000004152097270815409650] = 1399; - rayToBps[1000000004154878953532704765] = 1400; - rayToBps[1000000004157660392253453003] = 1401; - rayToBps[1000000004160441587020455146] = 1402; - rayToBps[1000000004163222537876500710] = 1403; - rayToBps[1000000004166003244864367958] = 1404; - rayToBps[1000000004168783708026823899] = 1405; - rayToBps[1000000004171563927406624291] = 1406; - rayToBps[1000000004174343903046513649] = 1407; - rayToBps[1000000004177123634989225246] = 1408; - rayToBps[1000000004179903123277481120] = 1409; - rayToBps[1000000004182682367953992073] = 1410; - rayToBps[1000000004185461369061457677] = 1411; - rayToBps[1000000004188240126642566281] = 1412; - rayToBps[1000000004191018640739995012] = 1413; - rayToBps[1000000004193796911396409779] = 1414; - rayToBps[1000000004196574938654465277] = 1415; - rayToBps[1000000004199352722556804991] = 1416; - rayToBps[1000000004202130263146061203] = 1417; - rayToBps[1000000004204907560464854990] = 1418; - rayToBps[1000000004207684614555796231] = 1419; - rayToBps[1000000004210461425461483615] = 1420; - rayToBps[1000000004213237993224504637] = 1421; - rayToBps[1000000004216014317887435608] = 1422; - rayToBps[1000000004218790399492841653] = 1423; - rayToBps[1000000004221566238083276725] = 1424; - rayToBps[1000000004224341833701283597] = 1425; - rayToBps[1000000004227117186389393875] = 1426; - rayToBps[1000000004229892296190127996] = 1427; - rayToBps[1000000004232667163145995236] = 1428; - rayToBps[1000000004235441787299493712] = 1429; - rayToBps[1000000004238216168693110386] = 1430; - rayToBps[1000000004240990307369321069] = 1431; - rayToBps[1000000004243764203370590423] = 1432; - rayToBps[1000000004246537856739371971] = 1433; - rayToBps[1000000004249311267518108094] = 1434; - rayToBps[1000000004252084435749230038] = 1435; - rayToBps[1000000004254857361475157917] = 1436; - rayToBps[1000000004257630044738300719] = 1437; - rayToBps[1000000004260402485581056307] = 1438; - rayToBps[1000000004263174684045811425] = 1439; - rayToBps[1000000004265946640174941701] = 1440; - rayToBps[1000000004268718354010811651] = 1441; - rayToBps[1000000004271489825595774681] = 1442; - rayToBps[1000000004274261054972173095] = 1443; - rayToBps[1000000004277032042182338097] = 1444; - rayToBps[1000000004279802787268589794] = 1445; - rayToBps[1000000004282573290273237200] = 1446; - rayToBps[1000000004285343551238578238] = 1447; - rayToBps[1000000004288113570206899751] = 1448; - rayToBps[1000000004290883347220477497] = 1449; - rayToBps[1000000004293652882321576158] = 1450; - rayToBps[1000000004296422175552449345] = 1451; - rayToBps[1000000004299191226955339597] = 1452; - rayToBps[1000000004301960036572478387] = 1453; - rayToBps[1000000004304728604446086130] = 1454; - rayToBps[1000000004307496930618372179] = 1455; - rayToBps[1000000004310265015131534834] = 1456; - rayToBps[1000000004313032858027761349] = 1457; - rayToBps[1000000004315800459349227927] = 1458; - rayToBps[1000000004318567819138099730] = 1459; - rayToBps[1000000004321334937436530883] = 1460; - rayToBps[1000000004324101814286664475] = 1461; - rayToBps[1000000004326868449730632563] = 1462; - rayToBps[1000000004329634843810556180] = 1463; - rayToBps[1000000004332400996568545334] = 1464; - rayToBps[1000000004335166908046699016] = 1465; - rayToBps[1000000004337932578287105196] = 1466; - rayToBps[1000000004340698007331840840] = 1467; - rayToBps[1000000004343463195222971901] = 1468; - rayToBps[1000000004346228142002553329] = 1469; - rayToBps[1000000004348992847712629077] = 1470; - rayToBps[1000000004351757312395232098] = 1471; - rayToBps[1000000004354521536092384354] = 1472; - rayToBps[1000000004357285518846096818] = 1473; - rayToBps[1000000004360049260698369481] = 1474; - rayToBps[1000000004362812761691191350] = 1475; - rayToBps[1000000004365576021866540454] = 1476; - rayToBps[1000000004368339041266383854] = 1477; - rayToBps[1000000004371101819932677638] = 1478; - rayToBps[1000000004373864357907366926] = 1479; - rayToBps[1000000004376626655232385882] = 1480; - rayToBps[1000000004379388711949657709] = 1481; - rayToBps[1000000004382150528101094654] = 1482; - rayToBps[1000000004384912103728598017] = 1483; - rayToBps[1000000004387673438874058150] = 1484; - rayToBps[1000000004390434533579354464] = 1485; - rayToBps[1000000004393195387886355428] = 1486; - rayToBps[1000000004395956001836918578] = 1487; - rayToBps[1000000004398716375472890520] = 1488; - rayToBps[1000000004401476508836106929] = 1489; - rayToBps[1000000004404236401968392559] = 1490; - rayToBps[1000000004406996054911561245] = 1491; - rayToBps[1000000004409755467707415902] = 1492; - rayToBps[1000000004412514640397748538] = 1493; - rayToBps[1000000004415273573024340248] = 1494; - rayToBps[1000000004418032265628961226] = 1495; - rayToBps[1000000004420790718253370761] = 1496; - rayToBps[1000000004423548930939317250] = 1497; - rayToBps[1000000004426306903728538193] = 1498; - rayToBps[1000000004429064636662760200] = 1499; - rayToBps[1000000004431822129783699001] = 1500; - rayToBps[1000000004434579383133059436] = 1501; - rayToBps[1000000004437336396752535473] = 1502; - rayToBps[1000000004440093170683810203] = 1503; - rayToBps[1000000004442849704968555849] = 1504; - rayToBps[1000000004445605999648433763] = 1505; - rayToBps[1000000004448362054765094438] = 1506; - rayToBps[1000000004451117870360177505] = 1507; - rayToBps[1000000004453873446475311742] = 1508; - rayToBps[1000000004456628783152115072] = 1509; - rayToBps[1000000004459383880432194574] = 1510; - rayToBps[1000000004462138738357146482] = 1511; - rayToBps[1000000004464893356968556186] = 1512; - rayToBps[1000000004467647736307998245] = 1513; - rayToBps[1000000004470401876417036380] = 1514; - rayToBps[1000000004473155777337223487] = 1515; - rayToBps[1000000004475909439110101633] = 1516; - rayToBps[1000000004478662861777202067] = 1517; - rayToBps[1000000004481416045380045219] = 1518; - rayToBps[1000000004484168989960140704] = 1519; - rayToBps[1000000004486921695558987326] = 1520; - rayToBps[1000000004489674162218073087] = 1521; - rayToBps[1000000004492426389978875180] = 1522; - rayToBps[1000000004495178378882860004] = 1523; - rayToBps[1000000004497930128971483160] = 1524; - rayToBps[1000000004500681640286189459] = 1525; - rayToBps[1000000004503432912868412922] = 1526; - rayToBps[1000000004506183946759576791] = 1527; - rayToBps[1000000004508934742001093521] = 1528; - rayToBps[1000000004511685298634364794] = 1529; - rayToBps[1000000004514435616700781520] = 1530; - rayToBps[1000000004517185696241723838] = 1531; - rayToBps[1000000004519935537298561123] = 1532; - rayToBps[1000000004522685139912651989] = 1533; - rayToBps[1000000004525434504125344289] = 1534; - rayToBps[1000000004528183629977975125] = 1535; - rayToBps[1000000004530932517511870847] = 1536; - rayToBps[1000000004533681166768347059] = 1537; - rayToBps[1000000004536429577788708623] = 1538; - rayToBps[1000000004539177750614249659] = 1539; - rayToBps[1000000004541925685286253554] = 1540; - rayToBps[1000000004544673381845992962] = 1541; - rayToBps[1000000004547420840334729810] = 1542; - rayToBps[1000000004550168060793715299] = 1543; - rayToBps[1000000004552915043264189911] = 1544; - rayToBps[1000000004555661787787383409] = 1545; - rayToBps[1000000004558408294404514847] = 1546; - rayToBps[1000000004561154563156792564] = 1547; - rayToBps[1000000004563900594085414197] = 1548; - rayToBps[1000000004566646387231566680] = 1549; - rayToBps[1000000004569391942636426248] = 1550; - rayToBps[1000000004572137260341158442] = 1551; - rayToBps[1000000004574882340386918113] = 1552; - rayToBps[1000000004577627182814849422] = 1553; - rayToBps[1000000004580371787666085848] = 1554; - rayToBps[1000000004583116154981750191] = 1555; - rayToBps[1000000004585860284802954574] = 1556; - rayToBps[1000000004588604177170800448] = 1557; - rayToBps[1000000004591347832126378593] = 1558; - rayToBps[1000000004594091249710769128] = 1559; - rayToBps[1000000004596834429965041505] = 1560; - rayToBps[1000000004599577372930254526] = 1561; - rayToBps[1000000004602320078647456331] = 1562; - rayToBps[1000000004605062547157684415] = 1563; - rayToBps[1000000004607804778501965623] = 1564; - rayToBps[1000000004610546772721316162] = 1565; - rayToBps[1000000004613288529856741593] = 1566; - rayToBps[1000000004616030049949236846] = 1567; - rayToBps[1000000004618771333039786217] = 1568; - rayToBps[1000000004621512379169363376] = 1569; - rayToBps[1000000004624253188378931367] = 1570; - rayToBps[1000000004626993760709442611] = 1571; - rayToBps[1000000004629734096201838917] = 1572; - rayToBps[1000000004632474194897051476] = 1573; - rayToBps[1000000004635214056836000869] = 1574; - rayToBps[1000000004637953682059597074] = 1575; - rayToBps[1000000004640693070608739463] = 1576; - rayToBps[1000000004643432222524316813] = 1577; - rayToBps[1000000004646171137847207302] = 1578; - rayToBps[1000000004648909816618278519] = 1579; - rayToBps[1000000004651648258878387462] = 1580; - rayToBps[1000000004654386464668380549] = 1581; - rayToBps[1000000004657124434029093614] = 1582; - rayToBps[1000000004659862167001351915] = 1583; - rayToBps[1000000004662599663625970138] = 1584; - rayToBps[1000000004665336923943752398] = 1585; - rayToBps[1000000004668073947995492244] = 1586; - rayToBps[1000000004670810735821972662] = 1587; - rayToBps[1000000004673547287463966083] = 1588; - rayToBps[1000000004676283602962234377] = 1589; - rayToBps[1000000004679019682357528867] = 1590; - rayToBps[1000000004681755525690590328] = 1591; - rayToBps[1000000004684491133002148989] = 1592; - rayToBps[1000000004687226504332924539] = 1593; - rayToBps[1000000004689961639723626131] = 1594; - rayToBps[1000000004692696539214952384] = 1595; - rayToBps[1000000004695431202847591388] = 1596; - rayToBps[1000000004698165630662220707] = 1597; - rayToBps[1000000004700899822699507381] = 1598; - rayToBps[1000000004703633779000107935] = 1599; - rayToBps[1000000004706367499604668374] = 1600; - rayToBps[1000000004709100984553824197] = 1601; - rayToBps[1000000004711834233888200390] = 1602; - rayToBps[1000000004714567247648411439] = 1603; - rayToBps[1000000004717300025875061327] = 1604; - rayToBps[1000000004720032568608743539] = 1605; - rayToBps[1000000004722764875890041071] = 1606; - rayToBps[1000000004725496947759526424] = 1607; - rayToBps[1000000004728228784257761617] = 1608; - rayToBps[1000000004730960385425298185] = 1609; - rayToBps[1000000004733691751302677184] = 1610; - rayToBps[1000000004736422881930429194] = 1611; - rayToBps[1000000004739153777349074326] = 1612; - rayToBps[1000000004741884437599122219] = 1613; - rayToBps[1000000004744614862721072050] = 1614; - rayToBps[1000000004747345052755412536] = 1615; - rayToBps[1000000004750075007742621934] = 1616; - rayToBps[1000000004752804727723168051] = 1617; - rayToBps[1000000004755534212737508240] = 1618; - rayToBps[1000000004758263462826089409] = 1619; - rayToBps[1000000004760992478029348025] = 1620; - rayToBps[1000000004763721258387710114] = 1621; - rayToBps[1000000004766449803941591267] = 1622; - rayToBps[1000000004769178114731396642] = 1623; - rayToBps[1000000004771906190797520968] = 1624; - rayToBps[1000000004774634032180348552] = 1625; - rayToBps[1000000004777361638920253278] = 1626; - rayToBps[1000000004780089011057598610] = 1627; - rayToBps[1000000004782816148632737601] = 1628; - rayToBps[1000000004785543051686012893] = 1629; - rayToBps[1000000004788269720257756721] = 1630; - rayToBps[1000000004790996154388290915] = 1631; - rayToBps[1000000004793722354117926905] = 1632; - rayToBps[1000000004796448319486965728] = 1633; - rayToBps[1000000004799174050535698027] = 1634; - rayToBps[1000000004801899547304404054] = 1635; - rayToBps[1000000004804624809833353677] = 1636; - rayToBps[1000000004807349838162806381] = 1637; - rayToBps[1000000004810074632333011275] = 1638; - rayToBps[1000000004812799192384207089] = 1639; - rayToBps[1000000004815523518356622187] = 1640; - rayToBps[1000000004818247610290474561] = 1641; - rayToBps[1000000004820971468225971842] = 1642; - rayToBps[1000000004823695092203311297] = 1643; - rayToBps[1000000004826418482262679840] = 1644; - rayToBps[1000000004829141638444254028] = 1645; - rayToBps[1000000004831864560788200070] = 1646; - rayToBps[1000000004834587249334673829] = 1647; - rayToBps[1000000004837309704123820822] = 1648; - rayToBps[1000000004840031925195776232] = 1649; - rayToBps[1000000004842753912590664903] = 1650; - rayToBps[1000000004845475666348601346] = 1651; - rayToBps[1000000004848197186509689746] = 1652; - rayToBps[1000000004850918473114023962] = 1653; - rayToBps[1000000004853639526201687531] = 1654; - rayToBps[1000000004856360345812753672] = 1655; - rayToBps[1000000004859080931987285289] = 1656; - rayToBps[1000000004861801284765334978] = 1657; - rayToBps[1000000004864521404186945026] = 1658; - rayToBps[1000000004867241290292147414] = 1659; - rayToBps[1000000004869960943120963825] = 1660; - rayToBps[1000000004872680362713405646] = 1661; - rayToBps[1000000004875399549109473969] = 1662; - rayToBps[1000000004878118502349159596] = 1663; - rayToBps[1000000004880837222472443046] = 1664; - rayToBps[1000000004883555709519294552] = 1665; - rayToBps[1000000004886273963529674069] = 1666; - rayToBps[1000000004888991984543531278] = 1667; - rayToBps[1000000004891709772600805585] = 1668; - rayToBps[1000000004894427327741426131] = 1669; - rayToBps[1000000004897144650005311787] = 1670; - rayToBps[1000000004899861739432371169] = 1671; - rayToBps[1000000004902578596062502630] = 1672; - rayToBps[1000000004905295219935594269] = 1673; - rayToBps[1000000004908011611091523937] = 1674; - rayToBps[1000000004910727769570159235] = 1675; - rayToBps[1000000004913443695411357522] = 1676; - rayToBps[1000000004916159388654965915] = 1677; - rayToBps[1000000004918874849340821294] = 1678; - rayToBps[1000000004921590077508750306] = 1679; - rayToBps[1000000004924305073198569369] = 1680; - rayToBps[1000000004927019836450084674] = 1681; - rayToBps[1000000004929734367303092189] = 1682; - rayToBps[1000000004932448665797377662] = 1683; - rayToBps[1000000004935162731972716627] = 1684; - rayToBps[1000000004937876565868874403] = 1685; - rayToBps[1000000004940590167525606103] = 1686; - rayToBps[1000000004943303536982656633] = 1687; - rayToBps[1000000004946016674279760695] = 1688; - rayToBps[1000000004948729579456642798] = 1689; - rayToBps[1000000004951442252553017251] = 1690; - rayToBps[1000000004954154693608588174] = 1691; - rayToBps[1000000004956866902663049499] = 1692; - rayToBps[1000000004959578879756084972] = 1693; - rayToBps[1000000004962290624927368160] = 1694; - rayToBps[1000000004965002138216562451] = 1695; - rayToBps[1000000004967713419663321060] = 1696; - rayToBps[1000000004970424469307287030] = 1697; - rayToBps[1000000004973135287188093241] = 1698; - rayToBps[1000000004975845873345362402] = 1699; - rayToBps[1000000004978556227818707070] = 1700; - rayToBps[1000000004981266350647729640] = 1701; - rayToBps[1000000004983976241872022356] = 1702; - rayToBps[1000000004986685901531167312] = 1703; - rayToBps[1000000004989395329664736455] = 1704; - rayToBps[1000000004992104526312291591] = 1705; - rayToBps[1000000004994813491513384383] = 1706; - rayToBps[1000000004997522225307556365] = 1707; - rayToBps[1000000005000230727734338930] = 1708; - rayToBps[1000000005002938998833253350] = 1709; - rayToBps[1000000005005647038643810765] = 1710; - rayToBps[1000000005008354847205512199] = 1711; - rayToBps[1000000005011062424557848553] = 1712; - rayToBps[1000000005013769770740300614] = 1713; - rayToBps[1000000005016476885792339060] = 1714; - rayToBps[1000000005019183769753424457] = 1715; - rayToBps[1000000005021890422663007268] = 1716; - rayToBps[1000000005024596844560527854] = 1717; - rayToBps[1000000005027303035485416482] = 1718; - rayToBps[1000000005030008995477093319] = 1719; - rayToBps[1000000005032714724574968444] = 1720; - rayToBps[1000000005035420222818441850] = 1721; - rayToBps[1000000005038125490246903442] = 1722; - rayToBps[1000000005040830526899733047] = 1723; - rayToBps[1000000005043535332816300415] = 1724; - rayToBps[1000000005046239908035965222] = 1725; - rayToBps[1000000005048944252598077073] = 1726; - rayToBps[1000000005051648366541975506] = 1727; - rayToBps[1000000005054352249906989998] = 1728; - rayToBps[1000000005057055902732439961] = 1729; - rayToBps[1000000005059759325057634757] = 1730; - rayToBps[1000000005062462516921873690] = 1731; - rayToBps[1000000005065165478364446016] = 1732; - rayToBps[1000000005067868209424630945] = 1733; - rayToBps[1000000005070570710141697643] = 1734; - rayToBps[1000000005073272980554905239] = 1735; - rayToBps[1000000005075975020703502822] = 1736; - rayToBps[1000000005078676830626729453] = 1737; - rayToBps[1000000005081378410363814160] = 1738; - rayToBps[1000000005084079759953975947] = 1739; - rayToBps[1000000005086780879436423797] = 1740; - rayToBps[1000000005089481768850356672] = 1741; - rayToBps[1000000005092182428234963519] = 1742; - rayToBps[1000000005094882857629423273] = 1743; - rayToBps[1000000005097583057072904861] = 1744; - rayToBps[1000000005100283026604567203] = 1745; - rayToBps[1000000005102982766263559220] = 1746; - rayToBps[1000000005105682276089019831] = 1747; - rayToBps[1000000005108381556120077964] = 1748; - rayToBps[1000000005111080606395852551] = 1749; - rayToBps[1000000005113779426955452540] = 1750; - rayToBps[1000000005116478017837976890] = 1751; - rayToBps[1000000005119176379082514583] = 1752; - rayToBps[1000000005121874510728144619] = 1753; - rayToBps[1000000005124572412813936025] = 1754; - rayToBps[1000000005127270085378947858] = 1755; - rayToBps[1000000005129967528462229205] = 1756; - rayToBps[1000000005132664742102819189] = 1757; - rayToBps[1000000005135361726339746974] = 1758; - rayToBps[1000000005138058481212031762] = 1759; - rayToBps[1000000005140755006758682806] = 1760; - rayToBps[1000000005143451303018699404] = 1761; - rayToBps[1000000005146147370031070909] = 1762; - rayToBps[1000000005148843207834776727] = 1763; - rayToBps[1000000005151538816468786327] = 1764; - rayToBps[1000000005154234195972059237] = 1765; - rayToBps[1000000005156929346383545054] = 1766; - rayToBps[1000000005159624267742183441] = 1767; - rayToBps[1000000005162318960086904137] = 1768; - rayToBps[1000000005165013423456626957] = 1769; - rayToBps[1000000005167707657890261792] = 1770; - rayToBps[1000000005170401663426708619] = 1771; - rayToBps[1000000005173095440104857501] = 1772; - rayToBps[1000000005175788987963588589] = 1773; - rayToBps[1000000005178482307041772129] = 1774; - rayToBps[1000000005181175397378268462] = 1775; - rayToBps[1000000005183868259011928028] = 1776; - rayToBps[1000000005186560891981591373] = 1777; - rayToBps[1000000005189253296326089147] = 1778; - rayToBps[1000000005191945472084242108] = 1779; - rayToBps[1000000005194637419294861132] = 1780; - rayToBps[1000000005197329137996747207] = 1781; - rayToBps[1000000005200020628228691445] = 1782; - rayToBps[1000000005202711890029475077] = 1783; - rayToBps[1000000005205402923437869462] = 1784; - rayToBps[1000000005208093728492636093] = 1785; - rayToBps[1000000005210784305232526588] = 1786; - rayToBps[1000000005213474653696282710] = 1787; - rayToBps[1000000005216164773922636357] = 1788; - rayToBps[1000000005218854665950309569] = 1789; - rayToBps[1000000005221544329818014540] = 1790; - rayToBps[1000000005224233765564453606] = 1791; - rayToBps[1000000005226922973228319260] = 1792; - rayToBps[1000000005229611952848294151] = 1793; - rayToBps[1000000005232300704463051089] = 1794; - rayToBps[1000000005234989228111253046] = 1795; - rayToBps[1000000005237677523831553161] = 1796; - rayToBps[1000000005240365591662594745] = 1797; - rayToBps[1000000005243053431643011277] = 1798; - rayToBps[1000000005245741043811426420] = 1799; - rayToBps[1000000005248428428206454010] = 1800; - rayToBps[1000000005251115584866698073] = 1801; - rayToBps[1000000005253802513830752815] = 1802; - rayToBps[1000000005256489215137202638] = 1803; - rayToBps[1000000005259175688824622133] = 1804; - rayToBps[1000000005261861934931576089] = 1805; - rayToBps[1000000005264547953496619496] = 1806; - rayToBps[1000000005267233744558297546] = 1807; - rayToBps[1000000005269919308155145638] = 1808; - rayToBps[1000000005272604644325689381] = 1809; - rayToBps[1000000005275289753108444598] = 1810; - rayToBps[1000000005277974634541917328] = 1811; - rayToBps[1000000005280659288664603827] = 1812; - rayToBps[1000000005283343715514990579] = 1813; - rayToBps[1000000005286027915131554292] = 1814; - rayToBps[1000000005288711887552761904] = 1815; - rayToBps[1000000005291395632817070587] = 1816; - rayToBps[1000000005294079150962927745] = 1817; - rayToBps[1000000005296762442028771030] = 1818; - rayToBps[1000000005299445506053028330] = 1819; - rayToBps[1000000005302128343074117781] = 1820; - rayToBps[1000000005304810953130447770] = 1821; - rayToBps[1000000005307493336260416936] = 1822; - rayToBps[1000000005310175492502414174] = 1823; - rayToBps[1000000005312857421894818640] = 1824; - rayToBps[1000000005315539124475999751] = 1825; - rayToBps[1000000005318220600284317191] = 1826; - rayToBps[1000000005320901849358120913] = 1827; - rayToBps[1000000005323582871735751141] = 1828; - rayToBps[1000000005326263667455538381] = 1829; - rayToBps[1000000005328944236555803409] = 1830; - rayToBps[1000000005331624579074857293] = 1831; - rayToBps[1000000005334304695051001381] = 1832; - rayToBps[1000000005336984584522527310] = 1833; - rayToBps[1000000005339664247527717012] = 1834; - rayToBps[1000000005342343684104842714] = 1835; - rayToBps[1000000005345022894292166942] = 1836; - rayToBps[1000000005347701878127942522] = 1837; - rayToBps[1000000005350380635650412590] = 1838; - rayToBps[1000000005353059166897810586] = 1839; - rayToBps[1000000005355737471908360264] = 1840; - rayToBps[1000000005358415550720275695] = 1841; - rayToBps[1000000005361093403371761268] = 1842; - rayToBps[1000000005363771029901011690] = 1843; - rayToBps[1000000005366448430346211998] = 1844; - rayToBps[1000000005369125604745537555] = 1845; - rayToBps[1000000005371802553137154057] = 1846; - rayToBps[1000000005374479275559217533] = 1847; - rayToBps[1000000005377155772049874353] = 1848; - rayToBps[1000000005379832042647261225] = 1849; - rayToBps[1000000005382508087389505206] = 1850; - rayToBps[1000000005385183906314723696] = 1851; - rayToBps[1000000005387859499461024450] = 1852; - rayToBps[1000000005390534866866505578] = 1853; - rayToBps[1000000005393210008569255543] = 1854; - rayToBps[1000000005395884924607353174] = 1855; - rayToBps[1000000005398559615018867662] = 1856; - rayToBps[1000000005401234079841858566] = 1857; - rayToBps[1000000005403908319114375815] = 1858; - rayToBps[1000000005406582332874459714] = 1859; - rayToBps[1000000005409256121160140942] = 1860; - rayToBps[1000000005411929684009440562] = 1861; - rayToBps[1000000005414603021460370019] = 1862; - rayToBps[1000000005417276133550931144] = 1863; - rayToBps[1000000005419949020319116161] = 1864; - rayToBps[1000000005422621681802907685] = 1865; - rayToBps[1000000005425294118040278729] = 1866; - rayToBps[1000000005427966329069192704] = 1867; - rayToBps[1000000005430638314927603428] = 1868; - rayToBps[1000000005433310075653455121] = 1869; - rayToBps[1000000005435981611284682417] = 1870; - rayToBps[1000000005438652921859210358] = 1871; - rayToBps[1000000005441324007414954408] = 1872; - rayToBps[1000000005443994867989820443] = 1873; - rayToBps[1000000005446665503621704769] = 1874; - rayToBps[1000000005449335914348494113] = 1875; - rayToBps[1000000005452006100208065634] = 1876; - rayToBps[1000000005454676061238286919] = 1877; - rayToBps[1000000005457345797477015996] = 1878; - rayToBps[1000000005460015308962101327] = 1879; - rayToBps[1000000005462684595731381818] = 1880; - rayToBps[1000000005465353657822686822] = 1881; - rayToBps[1000000005468022495273836134] = 1882; - rayToBps[1000000005470691108122640009] = 1883; - rayToBps[1000000005473359496406899150] = 1884; - rayToBps[1000000005476027660164404723] = 1885; - rayToBps[1000000005478695599432938350] = 1886; - rayToBps[1000000005481363314250272121] = 1887; - rayToBps[1000000005484030804654168594] = 1888; - rayToBps[1000000005486698070682380795] = 1889; - rayToBps[1000000005489365112372652227] = 1890; - rayToBps[1000000005492031929762716867] = 1891; - rayToBps[1000000005494698522890299176] = 1892; - rayToBps[1000000005497364891793114096] = 1893; - rayToBps[1000000005500031036508867056] = 1894; - rayToBps[1000000005502696957075253978] = 1895; - rayToBps[1000000005505362653529961273] = 1896; - rayToBps[1000000005508028125910665852] = 1897; - rayToBps[1000000005510693374255035122] = 1898; - rayToBps[1000000005513358398600726996] = 1899; - rayToBps[1000000005516023198985389892] = 1900; - rayToBps[1000000005518687775446662738] = 1901; - rayToBps[1000000005521352128022174972] = 1902; - rayToBps[1000000005524016256749546550] = 1903; - rayToBps[1000000005526680161666387944] = 1904; - rayToBps[1000000005529343842810300151] = 1905; - rayToBps[1000000005532007300218874693] = 1906; - rayToBps[1000000005534670533929693618] = 1907; - rayToBps[1000000005537333543980329507] = 1908; - rayToBps[1000000005539996330408345474] = 1909; - rayToBps[1000000005542658893251295174] = 1910; - rayToBps[1000000005545321232546722802] = 1911; - rayToBps[1000000005547983348332163094] = 1912; - rayToBps[1000000005550645240645141338] = 1913; - rayToBps[1000000005553306909523173370] = 1914; - rayToBps[1000000005555968355003765580] = 1915; - rayToBps[1000000005558629577124414915] = 1916; - rayToBps[1000000005561290575922608882] = 1917; - rayToBps[1000000005563951351435825552] = 1918; - rayToBps[1000000005566611903701533560] = 1919; - rayToBps[1000000005569272232757192116] = 1920; - rayToBps[1000000005571932338640250996] = 1921; - rayToBps[1000000005574592221388150557] = 1922; - rayToBps[1000000005577251881038321732] = 1923; - rayToBps[1000000005579911317628186037] = 1924; - rayToBps[1000000005582570531195155575] = 1925; - rayToBps[1000000005585229521776633037] = 1926; - rayToBps[1000000005587888289410011703] = 1927; - rayToBps[1000000005590546834132675450] = 1928; - rayToBps[1000000005593205155981998754] = 1929; - rayToBps[1000000005595863254995346690] = 1930; - rayToBps[1000000005598521131210074940] = 1931; - rayToBps[1000000005601178784663529791] = 1932; - rayToBps[1000000005603836215393048140] = 1933; - rayToBps[1000000005606493423435957501] = 1934; - rayToBps[1000000005609150408829576003] = 1935; - rayToBps[1000000005611807171611212394] = 1936; - rayToBps[1000000005614463711818166047] = 1937; - rayToBps[1000000005617120029487726961] = 1938; - rayToBps[1000000005619776124657175764] = 1939; - rayToBps[1000000005622431997363783716] = 1940; - rayToBps[1000000005625087647644812714] = 1941; - rayToBps[1000000005627743075537515294] = 1942; - rayToBps[1000000005630398281079134633] = 1943; - rayToBps[1000000005633053264306904553] = 1944; - rayToBps[1000000005635708025258049526] = 1945; - rayToBps[1000000005638362563969784673] = 1946; - rayToBps[1000000005641016880479315773] = 1947; - rayToBps[1000000005643670974823839258] = 1948; - rayToBps[1000000005646324847040542225] = 1949; - rayToBps[1000000005648978497166602432] = 1950; - rayToBps[1000000005651631925239188307] = 1951; - rayToBps[1000000005654285131295458945] = 1952; - rayToBps[1000000005656938115372564118] = 1953; - rayToBps[1000000005659590877507644269] = 1954; - rayToBps[1000000005662243417737830528] = 1955; - rayToBps[1000000005664895736100244700] = 1956; - rayToBps[1000000005667547832631999280] = 1957; - rayToBps[1000000005670199707370197452] = 1958; - rayToBps[1000000005672851360351933092] = 1959; - rayToBps[1000000005675502791614290768] = 1960; - rayToBps[1000000005678154001194345751] = 1961; - rayToBps[1000000005680804989129164009] = 1962; - rayToBps[1000000005683455755455802217] = 1963; - rayToBps[1000000005686106300211307757] = 1964; - rayToBps[1000000005688756623432718721] = 1965; - rayToBps[1000000005691406725157063918] = 1966; - rayToBps[1000000005694056605421362868] = 1967; - rayToBps[1000000005696706264262625816] = 1968; - rayToBps[1000000005699355701717853726] = 1969; - rayToBps[1000000005702004917824038294] = 1970; - rayToBps[1000000005704653912618161941] = 1971; - rayToBps[1000000005707302686137197819] = 1972; - rayToBps[1000000005709951238418109820] = 1973; - rayToBps[1000000005712599569497852572] = 1974; - rayToBps[1000000005715247679413371444] = 1975; - rayToBps[1000000005717895568201602551] = 1976; - rayToBps[1000000005720543235899472755] = 1977; - rayToBps[1000000005723190682543899670] = 1978; - rayToBps[1000000005725837908171791664] = 1979; - rayToBps[1000000005728484912820047862] = 1980; - rayToBps[1000000005731131696525558147] = 1981; - rayToBps[1000000005733778259325203169] = 1982; - rayToBps[1000000005736424601255854342] = 1983; - rayToBps[1000000005739070722354373849] = 1984; - rayToBps[1000000005741716622657614647] = 1985; - rayToBps[1000000005744362302202420469] = 1986; - rayToBps[1000000005747007761025625824] = 1987; - rayToBps[1000000005749652999164056007] = 1988; - rayToBps[1000000005752298016654527093] = 1989; - rayToBps[1000000005754942813533845949] = 1990; - rayToBps[1000000005757587389838810231] = 1991; - rayToBps[1000000005760231745606208388] = 1992; - rayToBps[1000000005762875880872819670] = 1993; - rayToBps[1000000005765519795675414123] = 1994; - rayToBps[1000000005768163490050752599] = 1995; - rayToBps[1000000005770806964035586754] = 1996; - rayToBps[1000000005773450217666659055] = 1997; - rayToBps[1000000005776093250980702782] = 1998; - rayToBps[1000000005778736064014442030] = 1999; - rayToBps[1000000005781378656804591712] = 2000; - rayToBps[1000000005784021029387857563] = 2001; - rayToBps[1000000005786663181800936142] = 2002; - rayToBps[1000000005789305114080514838] = 2003; - rayToBps[1000000005791946826263271867] = 2004; - rayToBps[1000000005794588318385876283] = 2005; - rayToBps[1000000005797229590484987975] = 2006; - rayToBps[1000000005799870642597257672] = 2007; - rayToBps[1000000005802511474759326946] = 2008; - rayToBps[1000000005805152087007828215] = 2009; - rayToBps[1000000005807792479379384747] = 2010; - rayToBps[1000000005810432651910610661] = 2011; - rayToBps[1000000005813072604638110932] = 2012; - rayToBps[1000000005815712337598481393] = 2013; - rayToBps[1000000005818351850828308739] = 2014; - rayToBps[1000000005820991144364170528] = 2015; - rayToBps[1000000005823630218242635187] = 2016; - rayToBps[1000000005826269072500262012] = 2017; - rayToBps[1000000005828907707173601173] = 2018; - rayToBps[1000000005831546122299193718] = 2019; - rayToBps[1000000005834184317913571571] = 2020; - rayToBps[1000000005836822294053257542] = 2021; - rayToBps[1000000005839460050754765326] = 2022; - rayToBps[1000000005842097588054599505] = 2023; - rayToBps[1000000005844734905989255555] = 2024; - rayToBps[1000000005847372004595219844] = 2025; - rayToBps[1000000005850008883908969641] = 2026; - rayToBps[1000000005852645543966973112] = 2027; - rayToBps[1000000005855281984805689330] = 2028; - rayToBps[1000000005857918206461568274] = 2029; - rayToBps[1000000005860554208971050832] = 2030; - rayToBps[1000000005863189992370568806] = 2031; - rayToBps[1000000005865825556696544911] = 2032; - rayToBps[1000000005868460901985392786] = 2033; - rayToBps[1000000005871096028273516989] = 2034; - rayToBps[1000000005873730935597313001] = 2035; - rayToBps[1000000005876365623993167233] = 2036; - rayToBps[1000000005879000093497457030] = 2037; - rayToBps[1000000005881634344146550666] = 2038; - rayToBps[1000000005884268375976807354] = 2039; - rayToBps[1000000005886902189024577248] = 2040; - rayToBps[1000000005889535783326201442] = 2041; - rayToBps[1000000005892169158918011981] = 2042; - rayToBps[1000000005894802315836331854] = 2043; - rayToBps[1000000005897435254117475004] = 2044; - rayToBps[1000000005900067973797746332] = 2045; - rayToBps[1000000005902700474913441692] = 2046; - rayToBps[1000000005905332757500847901] = 2047; - rayToBps[1000000005907964821596242742] = 2048; - rayToBps[1000000005910596667235894964] = 2049; - rayToBps[1000000005913228294456064283] = 2050; - rayToBps[1000000005915859703293001393] = 2051; - rayToBps[1000000005918490893782947960] = 2052; - rayToBps[1000000005921121865962136632] = 2053; - rayToBps[1000000005923752619866791038] = 2054; - rayToBps[1000000005926383155533125790] = 2055; - rayToBps[1000000005929013472997346492] = 2056; - rayToBps[1000000005931643572295649735] = 2057; - rayToBps[1000000005934273453464223108] = 2058; - rayToBps[1000000005936903116539245192] = 2059; - rayToBps[1000000005939532561556885575] = 2060; - rayToBps[1000000005942161788553304839] = 2061; - rayToBps[1000000005944790797564654580] = 2062; - rayToBps[1000000005947419588627077399] = 2063; - rayToBps[1000000005950048161776706909] = 2064; - rayToBps[1000000005952676517049667739] = 2065; - rayToBps[1000000005955304654482075535] = 2066; - rayToBps[1000000005957932574110036965] = 2067; - rayToBps[1000000005960560275969649719] = 2068; - rayToBps[1000000005963187760097002515] = 2069; - rayToBps[1000000005965815026528175101] = 2070; - rayToBps[1000000005968442075299238258] = 2071; - rayToBps[1000000005971068906446253801] = 2072; - rayToBps[1000000005973695520005274585] = 2073; - rayToBps[1000000005976321916012344506] = 2074; - rayToBps[1000000005978948094503498507] = 2075; - rayToBps[1000000005981574055514762574] = 2076; - rayToBps[1000000005984199799082153748] = 2077; - rayToBps[1000000005986825325241680120] = 2078; - rayToBps[1000000005989450634029340842] = 2079; - rayToBps[1000000005992075725481126120] = 2080; - rayToBps[1000000005994700599633017225] = 2081; - rayToBps[1000000005997325256520986496] = 2082; - rayToBps[1000000005999949696180997335] = 2083; - rayToBps[1000000006002573918649004220] = 2084; - rayToBps[1000000006005197923960952699] = 2085; - rayToBps[1000000006007821712152779401] = 2086; - rayToBps[1000000006010445283260412034] = 2087; - rayToBps[1000000006013068637319769388] = 2088; - rayToBps[1000000006015691774366761338] = 2089; - rayToBps[1000000006018314694437288852] = 2090; - rayToBps[1000000006020937397567243987] = 2091; - rayToBps[1000000006023559883792509896] = 2092; - rayToBps[1000000006026182153148960829] = 2093; - rayToBps[1000000006028804205672462137] = 2094; - rayToBps[1000000006031426041398870273] = 2095; - rayToBps[1000000006034047660364032802] = 2096; - rayToBps[1000000006036669062603788392] = 2097; - rayToBps[1000000006039290248153966829] = 2098; - rayToBps[1000000006041911217050389011] = 2099; - rayToBps[1000000006044531969328866955] = 2100; - rayToBps[1000000006047152505025203801] = 2101; - rayToBps[1000000006049772824175193813] = 2102; - rayToBps[1000000006052392926814622379] = 2103; - rayToBps[1000000006055012812979266021] = 2104; - rayToBps[1000000006057632482704892392] = 2105; - rayToBps[1000000006060251936027260282] = 2106; - rayToBps[1000000006062871172982119621] = 2107; - rayToBps[1000000006065490193605211477] = 2108; - rayToBps[1000000006068108997932268067] = 2109; - rayToBps[1000000006070727585999012755] = 2110; - rayToBps[1000000006073345957841160052] = 2111; - rayToBps[1000000006075964113494415626] = 2112; - rayToBps[1000000006078582052994476301] = 2113; - rayToBps[1000000006081199776377030061] = 2114; - rayToBps[1000000006083817283677756050] = 2115; - rayToBps[1000000006086434574932324580] = 2116; - rayToBps[1000000006089051650176397130] = 2117; - rayToBps[1000000006091668509445626349] = 2118; - rayToBps[1000000006094285152775656060] = 2119; - rayToBps[1000000006096901580202121266] = 2120; - rayToBps[1000000006099517791760648147] = 2121; - rayToBps[1000000006102133787486854066] = 2122; - rayToBps[1000000006104749567416347572] = 2123; - rayToBps[1000000006107365131584728403] = 2124; - rayToBps[1000000006109980480027587488] = 2125; - rayToBps[1000000006112595612780506950] = 2126; - rayToBps[1000000006115210529879060111] = 2127; - rayToBps[1000000006117825231358811489] = 2128; - rayToBps[1000000006120439717255316811] = 2129; - rayToBps[1000000006123053987604123006] = 2130; - rayToBps[1000000006125668042440768211] = 2131; - rayToBps[1000000006128281881800781778] = 2132; - rayToBps[1000000006130895505719684273] = 2133; - rayToBps[1000000006133508914232987477] = 2134; - rayToBps[1000000006136122107376194395] = 2135; - rayToBps[1000000006138735085184799252] = 2136; - rayToBps[1000000006141347847694287501] = 2137; - rayToBps[1000000006143960394940135825] = 2138; - rayToBps[1000000006146572726957812137] = 2139; - rayToBps[1000000006149184843782775586] = 2140; - rayToBps[1000000006151796745450476560] = 2141; - rayToBps[1000000006154408431996356685] = 2142; - rayToBps[1000000006157019903455848831] = 2143; - rayToBps[1000000006159631159864377117] = 2144; - rayToBps[1000000006162242201257356911] = 2145; - rayToBps[1000000006164853027670194829] = 2146; - rayToBps[1000000006167463639138288746] = 2147; - rayToBps[1000000006170074035697027796] = 2148; - rayToBps[1000000006172684217381792370] = 2149; - rayToBps[1000000006175294184227954125] = 2150; - rayToBps[1000000006177903936270875985] = 2151; - rayToBps[1000000006180513473545912141] = 2152; - rayToBps[1000000006183122796088408060] = 2153; - rayToBps[1000000006185731903933700483] = 2154; - rayToBps[1000000006188340797117117427] = 2155; - rayToBps[1000000006190949475673978192] = 2156; - rayToBps[1000000006193557939639593360] = 2157; - rayToBps[1000000006196166189049264802] = 2158; - rayToBps[1000000006198774223938285679] = 2159; - rayToBps[1000000006201382044341940442] = 2160; - rayToBps[1000000006203989650295504837] = 2161; - rayToBps[1000000006206597041834245913] = 2162; - rayToBps[1000000006209204218993422012] = 2163; - rayToBps[1000000006211811181808282789] = 2164; - rayToBps[1000000006214417930314069199] = 2165; - rayToBps[1000000006217024464546013508] = 2166; - rayToBps[1000000006219630784539339297] = 2167; - rayToBps[1000000006222236890329261461] = 2168; - rayToBps[1000000006224842781950986211] = 2169; - rayToBps[1000000006227448459439711081] = 2170; - rayToBps[1000000006230053922830624932] = 2171; - rayToBps[1000000006232659172158907945] = 2172; - rayToBps[1000000006235264207459731635] = 2173; - rayToBps[1000000006237869028768258850] = 2174; - rayToBps[1000000006240473636119643770] = 2175; - rayToBps[1000000006243078029549031916] = 2176; - rayToBps[1000000006245682209091560148] = 2177; - rayToBps[1000000006248286174782356672] = 2178; - rayToBps[1000000006250889926656541039] = 2179; - rayToBps[1000000006253493464749224150] = 2180; - rayToBps[1000000006256096789095508257] = 2181; - rayToBps[1000000006258699899730486971] = 2182; - rayToBps[1000000006261302796689245258] = 2183; - rayToBps[1000000006263905480006859443] = 2184; - rayToBps[1000000006266507949718397218] = 2185; - rayToBps[1000000006269110205858917643] = 2186; - rayToBps[1000000006271712248463471143] = 2187; - rayToBps[1000000006274314077567099518] = 2188; - rayToBps[1000000006276915693204835941] = 2189; - rayToBps[1000000006279517095411704965] = 2190; - rayToBps[1000000006282118284222722523] = 2191; - rayToBps[1000000006284719259672895930] = 2192; - rayToBps[1000000006287320021797223891] = 2193; - rayToBps[1000000006289920570630696496] = 2194; - rayToBps[1000000006292520906208295229] = 2195; - rayToBps[1000000006295121028564992969] = 2196; - rayToBps[1000000006297720937735753993] = 2197; - rayToBps[1000000006300320633755533977] = 2198; - rayToBps[1000000006302920116659280001] = 2199; - rayToBps[1000000006305519386481930552] = 2200; - rayToBps[1000000006308118443258415523] = 2201; - rayToBps[1000000006310717287023656222] = 2202; - rayToBps[1000000006313315917812565372] = 2203; - rayToBps[1000000006315914335660047109] = 2204; - rayToBps[1000000006318512540600996994] = 2205; - rayToBps[1000000006321110532670302007] = 2206; - rayToBps[1000000006323708311902840558] = 2207; - rayToBps[1000000006326305878333482482] = 2208; - rayToBps[1000000006328903231997089047] = 2209; - rayToBps[1000000006331500372928512954] = 2210; - rayToBps[1000000006334097301162598344] = 2211; - rayToBps[1000000006336694016734180794] = 2212; - rayToBps[1000000006339290519678087326] = 2213; - rayToBps[1000000006341886810029136408] = 2214; - rayToBps[1000000006344482887822137953] = 2215; - rayToBps[1000000006347078753091893329] = 2216; - rayToBps[1000000006349674405873195356] = 2217; - rayToBps[1000000006352269846200828311] = 2218; - rayToBps[1000000006354865074109567928] = 2219; - rayToBps[1000000006357460089634181406] = 2220; - rayToBps[1000000006360054892809427412] = 2221; - rayToBps[1000000006362649483670056072] = 2222; - rayToBps[1000000006365243862250808991] = 2223; - rayToBps[1000000006367838028586419244] = 2224; - rayToBps[1000000006370431982711611382] = 2225; - rayToBps[1000000006373025724661101435] = 2226; - rayToBps[1000000006375619254469596916] = 2227; - rayToBps[1000000006378212572171796821] = 2228; - rayToBps[1000000006380805677802391636] = 2229; - rayToBps[1000000006383398571396063332] = 2230; - rayToBps[1000000006385991252987485379] = 2231; - rayToBps[1000000006388583722611322739] = 2232; - rayToBps[1000000006391175980302231873] = 2233; - rayToBps[1000000006393768026094860743] = 2234; - rayToBps[1000000006396359860023848818] = 2235; - rayToBps[1000000006398951482123827069] = 2236; - rayToBps[1000000006401542892429417980] = 2237; - rayToBps[1000000006404134090975235547] = 2238; - rayToBps[1000000006406725077795885279] = 2239; - rayToBps[1000000006409315852925964206] = 2240; - rayToBps[1000000006411906416400060876] = 2241; - rayToBps[1000000006414496768252755361] = 2242; - rayToBps[1000000006417086908518619263] = 2243; - rayToBps[1000000006419676837232215707] = 2244; - rayToBps[1000000006422266554428099352] = 2245; - rayToBps[1000000006424856060140816394] = 2246; - rayToBps[1000000006427445354404904564] = 2247; - rayToBps[1000000006430034437254893132] = 2248; - rayToBps[1000000006432623308725302915] = 2249; - rayToBps[1000000006435211968850646270] = 2250; - rayToBps[1000000006437800417665427105] = 2251; - rayToBps[1000000006440388655204140882] = 2252; - rayToBps[1000000006442976681501274614] = 2253; - rayToBps[1000000006445564496591306867] = 2254; - rayToBps[1000000006448152100508707774] = 2255; - rayToBps[1000000006450739493287939023] = 2256; - rayToBps[1000000006453326674963453873] = 2257; - rayToBps[1000000006455913645569697146] = 2258; - rayToBps[1000000006458500405141105236] = 2259; - rayToBps[1000000006461086953712106112] = 2260; - rayToBps[1000000006463673291317119316] = 2261; - rayToBps[1000000006466259417990555969] = 2262; - rayToBps[1000000006468845333766818775] = 2263; - rayToBps[1000000006471431038680302021] = 2264; - rayToBps[1000000006474016532765391581] = 2265; - rayToBps[1000000006476601816056464920] = 2266; - rayToBps[1000000006479186888587891091] = 2267; - rayToBps[1000000006481771750394030749] = 2268; - rayToBps[1000000006484356401509236141] = 2269; - rayToBps[1000000006486940841967851116] = 2270; - rayToBps[1000000006489525071804211128] = 2271; - rayToBps[1000000006492109091052643236] = 2272; - rayToBps[1000000006494692899747466107] = 2273; - rayToBps[1000000006497276497922990021] = 2274; - rayToBps[1000000006499859885613516871] = 2275; - rayToBps[1000000006502443062853340168] = 2276; - rayToBps[1000000006505026029676745041] = 2277; - rayToBps[1000000006507608786118008244] = 2278; - rayToBps[1000000006510191332211398155] = 2279; - rayToBps[1000000006512773667991174779] = 2280; - rayToBps[1000000006515355793491589751] = 2281; - rayToBps[1000000006517937708746886344] = 2282; - rayToBps[1000000006520519413791299462] = 2283; - rayToBps[1000000006523100908659055649] = 2284; - rayToBps[1000000006525682193384373092] = 2285; - rayToBps[1000000006528263268001461622] = 2286; - rayToBps[1000000006530844132544522714] = 2287; - rayToBps[1000000006533424787047749499] = 2288; - rayToBps[1000000006536005231545326753] = 2289; - rayToBps[1000000006538585466071430912] = 2290; - rayToBps[1000000006541165490660230067] = 2291; - rayToBps[1000000006543745305345883975] = 2292; - rayToBps[1000000006546324910162544048] = 2293; - rayToBps[1000000006548904305144353370] = 2294; - rayToBps[1000000006551483490325446691] = 2295; - rayToBps[1000000006554062465739950435] = 2296; - rayToBps[1000000006556641231421982697] = 2297; - rayToBps[1000000006559219787405653252] = 2298; - rayToBps[1000000006561798133725063551] = 2299; - rayToBps[1000000006564376270414306730] = 2300; - rayToBps[1000000006566954197507467608] = 2301; - rayToBps[1000000006569531915038622694] = 2302; - rayToBps[1000000006572109423041840185] = 2303; - rayToBps[1000000006574686721551179973] = 2304; - rayToBps[1000000006577263810600693644] = 2305; - rayToBps[1000000006579840690224424483] = 2306; - rayToBps[1000000006582417360456407476] = 2307; - rayToBps[1000000006584993821330669316] = 2308; - rayToBps[1000000006587570072881228396] = 2309; - rayToBps[1000000006590146115142094824] = 2310; - rayToBps[1000000006592721948147270418] = 2311; - rayToBps[1000000006595297571930748710] = 2312; - rayToBps[1000000006597872986526514949] = 2313; - rayToBps[1000000006600448191968546107] = 2314; - rayToBps[1000000006603023188290810875] = 2315; - rayToBps[1000000006605597975527269671] = 2316; - rayToBps[1000000006608172553711874641] = 2317; - rayToBps[1000000006610746922878569662] = 2318; - rayToBps[1000000006613321083061290345] = 2319; - rayToBps[1000000006615895034293964035] = 2320; - rayToBps[1000000006618468776610509817] = 2321; - rayToBps[1000000006621042310044838519] = 2322; - rayToBps[1000000006623615634630852711] = 2323; - rayToBps[1000000006626188750402446710] = 2324; - rayToBps[1000000006628761657393506584] = 2325; - rayToBps[1000000006631334355637910151] = 2326; - rayToBps[1000000006633906845169526987] = 2327; - rayToBps[1000000006636479126022218423] = 2328; - rayToBps[1000000006639051198229837551] = 2329; - rayToBps[1000000006641623061826229226] = 2330; - rayToBps[1000000006644194716845230068] = 2331; - rayToBps[1000000006646766163320668467] = 2332; - rayToBps[1000000006649337401286364581] = 2333; - rayToBps[1000000006651908430776130344] = 2334; - rayToBps[1000000006654479251823769466] = 2335; - rayToBps[1000000006657049864463077435] = 2336; - rayToBps[1000000006659620268727841521] = 2337; - rayToBps[1000000006662190464651840778] = 2338; - rayToBps[1000000006664760452268846047] = 2339; - rayToBps[1000000006667330231612619959] = 2340; - rayToBps[1000000006669899802716916939] = 2341; - rayToBps[1000000006672469165615483202] = 2342; - rayToBps[1000000006675038320342056763] = 2343; - rayToBps[1000000006677607266930367441] = 2344; - rayToBps[1000000006680176005414136851] = 2345; - rayToBps[1000000006682744535827078420] = 2346; - rayToBps[1000000006685312858202897378] = 2347; - rayToBps[1000000006687880972575290769] = 2348; - rayToBps[1000000006690448878977947450] = 2349; - rayToBps[1000000006693016577444548094] = 2350; - rayToBps[1000000006695584068008765190] = 2351; - rayToBps[1000000006698151350704263054] = 2352; - rayToBps[1000000006700718425564697821] = 2353; - rayToBps[1000000006703285292623717455] = 2354; - rayToBps[1000000006705851951914961750] = 2355; - rayToBps[1000000006708418403472062331] = 2356; - rayToBps[1000000006710984647328642657] = 2357; - rayToBps[1000000006713550683518318027] = 2358; - rayToBps[1000000006716116512074695575] = 2359; - rayToBps[1000000006718682133031374284] = 2360; - rayToBps[1000000006721247546421944976] = 2361; - rayToBps[1000000006723812752279990327] = 2362; - rayToBps[1000000006726377750639084858] = 2363; - rayToBps[1000000006728942541532794947] = 2364; - rayToBps[1000000006731507124994678824] = 2365; - rayToBps[1000000006734071501058286581] = 2366; - rayToBps[1000000006736635669757160171] = 2367; - rayToBps[1000000006739199631124833408] = 2368; - rayToBps[1000000006741763385194831973] = 2369; - rayToBps[1000000006744326932000673419] = 2370; - rayToBps[1000000006746890271575867167] = 2371; - rayToBps[1000000006749453403953914514] = 2372; - rayToBps[1000000006752016329168308632] = 2373; - rayToBps[1000000006754579047252534575] = 2374; - rayToBps[1000000006757141558240069277] = 2375; - rayToBps[1000000006759703862164381559] = 2376; - rayToBps[1000000006762265959058932126] = 2377; - rayToBps[1000000006764827848957173576] = 2378; - rayToBps[1000000006767389531892550399] = 2379; - rayToBps[1000000006769951007898498979] = 2380; - rayToBps[1000000006772512277008447597] = 2381; - rayToBps[1000000006775073339255816438] = 2382; - rayToBps[1000000006777634194674017587] = 2383; - rayToBps[1000000006780194843296455036] = 2384; - rayToBps[1000000006782755285156524684] = 2385; - rayToBps[1000000006785315520287614342] = 2386; - rayToBps[1000000006787875548723103735] = 2387; - rayToBps[1000000006790435370496364503] = 2388; - rayToBps[1000000006792994985640760203] = 2389; - rayToBps[1000000006795554394189646319] = 2390; - rayToBps[1000000006798113596176370253] = 2391; - rayToBps[1000000006800672591634271336] = 2392; - rayToBps[1000000006803231380596680829] = 2393; - rayToBps[1000000006805789963096921922] = 2394; - rayToBps[1000000006808348339168309744] = 2395; - rayToBps[1000000006810906508844151355] = 2396; - rayToBps[1000000006813464472157745761] = 2397; - rayToBps[1000000006816022229142383903] = 2398; - rayToBps[1000000006818579779831348674] = 2399; - rayToBps[1000000006821137124257914908] = 2400; - rayToBps[1000000006823694262455349394] = 2401; - rayToBps[1000000006826251194456910871] = 2402; - rayToBps[1000000006828807920295850033] = 2403; - rayToBps[1000000006831364440005409534] = 2404; - rayToBps[1000000006833920753618823984] = 2405; - rayToBps[1000000006836476861169319962] = 2406; - rayToBps[1000000006839032762690116006] = 2407; - rayToBps[1000000006841588458214422628] = 2408; - rayToBps[1000000006844143947775442306] = 2409; - rayToBps[1000000006846699231406369494] = 2410; - rayToBps[1000000006849254309140390621] = 2411; - rayToBps[1000000006851809181010684095] = 2412; - rayToBps[1000000006854363847050420305] = 2413; - rayToBps[1000000006856918307292761621] = 2414; - rayToBps[1000000006859472561770862405] = 2415; - rayToBps[1000000006862026610517869003] = 2416; - rayToBps[1000000006864580453566919751] = 2417; - rayToBps[1000000006867134090951144986] = 2418; - rayToBps[1000000006869687522703667035] = 2419; - rayToBps[1000000006872240748857600225] = 2420; - rayToBps[1000000006874793769446050889] = 2421; - rayToBps[1000000006877346584502117360] = 2422; - rayToBps[1000000006879899194058889978] = 2423; - rayToBps[1000000006882451598149451095] = 2424; - rayToBps[1000000006885003796806875073] = 2425; - rayToBps[1000000006887555790064228288] = 2426; - rayToBps[1000000006890107577954569136] = 2427; - rayToBps[1000000006892659160510948030] = 2428; - rayToBps[1000000006895210537766407406] = 2429; - rayToBps[1000000006897761709753981726] = 2430; - rayToBps[1000000006900312676506697478] = 2431; - rayToBps[1000000006902863438057573180] = 2432; - rayToBps[1000000006905413994439619383] = 2433; - rayToBps[1000000006907964345685838672] = 2434; - rayToBps[1000000006910514491829225673] = 2435; - rayToBps[1000000006913064432902767049] = 2436; - rayToBps[1000000006915614168939441505] = 2437; - rayToBps[1000000006918163699972219795] = 2438; - rayToBps[1000000006920713026034064718] = 2439; - rayToBps[1000000006923262147157931125] = 2440; - rayToBps[1000000006925811063376765919] = 2441; - rayToBps[1000000006928359774723508058] = 2442; - rayToBps[1000000006930908281231088560] = 2443; - rayToBps[1000000006933456582932430503] = 2444; - rayToBps[1000000006936004679860449027] = 2445; - rayToBps[1000000006938552572048051340] = 2446; - rayToBps[1000000006941100259528136715] = 2447; - rayToBps[1000000006943647742333596500] = 2448; - rayToBps[1000000006946195020497314113] = 2449; - rayToBps[1000000006948742094052165050] = 2450; - rayToBps[1000000006951288963031016884] = 2451; - rayToBps[1000000006953835627466729271] = 2452; - rayToBps[1000000006956382087392153949] = 2453; - rayToBps[1000000006958928342840134742] = 2454; - rayToBps[1000000006961474393843507563] = 2455; - rayToBps[1000000006964020240435100419] = 2456; - rayToBps[1000000006966565882647733404] = 2457; - rayToBps[1000000006969111320514218717] = 2458; - rayToBps[1000000006971656554067360648] = 2459; - rayToBps[1000000006974201583339955595] = 2460; - rayToBps[1000000006976746408364792054] = 2461; - rayToBps[1000000006979291029174650631] = 2462; - rayToBps[1000000006981835445802304040] = 2463; - rayToBps[1000000006984379658280517107] = 2464; - rayToBps[1000000006986923666642046773] = 2465; - rayToBps[1000000006989467470919642091] = 2466; - rayToBps[1000000006992011071146044239] = 2467; - rayToBps[1000000006994554467353986513] = 2468; - rayToBps[1000000006997097659576194335] = 2469; - rayToBps[1000000006999640647845385252] = 2470; - rayToBps[1000000007002183432194268941] = 2471; - rayToBps[1000000007004726012655547211] = 2472; - rayToBps[1000000007007268389261914006] = 2473; - rayToBps[1000000007009810562046055406] = 2474; - rayToBps[1000000007012352531040649627] = 2475; - rayToBps[1000000007014894296278367034] = 2476; - rayToBps[1000000007017435857791870130] = 2477; - rayToBps[1000000007019977215613813568] = 2478; - rayToBps[1000000007022518369776844150] = 2479; - rayToBps[1000000007025059320313600828] = 2480; - rayToBps[1000000007027600067256714710] = 2481; - rayToBps[1000000007030140610638809063] = 2482; - rayToBps[1000000007032680950492499310] = 2483; - rayToBps[1000000007035221086850393037] = 2484; - rayToBps[1000000007037761019745089994] = 2485; - rayToBps[1000000007040300749209182100] = 2486; - rayToBps[1000000007042840275275253441] = 2487; - rayToBps[1000000007045379597975880277] = 2488; - rayToBps[1000000007047918717343631040] = 2489; - rayToBps[1000000007050457633411066343] = 2490; - rayToBps[1000000007052996346210738974] = 2491; - rayToBps[1000000007055534855775193908] = 2492; - rayToBps[1000000007058073162136968298] = 2493; - rayToBps[1000000007060611265328591490] = 2494; - rayToBps[1000000007063149165382585017] = 2495; - rayToBps[1000000007065686862331462604] = 2496; - rayToBps[1000000007068224356207730171] = 2497; - rayToBps[1000000007070761647043885833] = 2498; - rayToBps[1000000007073298734872419909] = 2499; - rayToBps[1000000007075835619725814915] = 2500; - rayToBps[1000000007078372301636545575] = 2501; - rayToBps[1000000007080908780637078819] = 2502; - rayToBps[1000000007083445056759873785] = 2503; - rayToBps[1000000007085981130037381827] = 2504; - rayToBps[1000000007088517000502046507] = 2505; - rayToBps[1000000007091052668186303610] = 2506; - rayToBps[1000000007093588133122581138] = 2507; - rayToBps[1000000007096123395343299315] = 2508; - rayToBps[1000000007098658454880870590] = 2509; - rayToBps[1000000007101193311767699638] = 2510; - rayToBps[1000000007103727966036183363] = 2511; - rayToBps[1000000007106262417718710904] = 2512; - rayToBps[1000000007108796666847663630] = 2513; - rayToBps[1000000007111330713455415150] = 2514; - rayToBps[1000000007113864557574331311] = 2515; - rayToBps[1000000007116398199236770202] = 2516; - rayToBps[1000000007118931638475082158] = 2517; - rayToBps[1000000007121464875321609757] = 2518; - rayToBps[1000000007123997909808687830] = 2519; - rayToBps[1000000007126530741968643458] = 2520; - rayToBps[1000000007129063371833795977] = 2521; - rayToBps[1000000007131595799436456977] = 2522; - rayToBps[1000000007134128024808930311] = 2523; - rayToBps[1000000007136660047983512092] = 2524; - rayToBps[1000000007139191868992490695] = 2525; - rayToBps[1000000007141723487868146766] = 2526; - rayToBps[1000000007144254904642753216] = 2527; - rayToBps[1000000007146786119348575230] = 2528; - rayToBps[1000000007149317132017870265] = 2529; - rayToBps[1000000007151847942682888056] = 2530; - rayToBps[1000000007154378551375870618] = 2531; - rayToBps[1000000007156908958129052243] = 2532; - rayToBps[1000000007159439162974659510] = 2533; - rayToBps[1000000007161969165944911286] = 2534; - rayToBps[1000000007164498967072018724] = 2535; - rayToBps[1000000007167028566388185266] = 2536; - rayToBps[1000000007169557963925606655] = 2537; - rayToBps[1000000007172087159716470922] = 2538; - rayToBps[1000000007174616153792958402] = 2539; - rayToBps[1000000007177144946187241729] = 2540; - rayToBps[1000000007179673536931485840] = 2541; - rayToBps[1000000007182201926057847980] = 2542; - rayToBps[1000000007184730113598477700] = 2543; - rayToBps[1000000007187258099585516865] = 2544; - rayToBps[1000000007189785884051099650] = 2545; - rayToBps[1000000007192313467027352546] = 2546; - rayToBps[1000000007194840848546394365] = 2547; - rayToBps[1000000007197368028640336238] = 2548; - rayToBps[1000000007199895007341281618] = 2549; - rayToBps[1000000007202421784681326287] = 2550; - rayToBps[1000000007204948360692558350] = 2551; - rayToBps[1000000007207474735407058245] = 2552; - rayToBps[1000000007210000908856898746] = 2553; - rayToBps[1000000007212526881074144958] = 2554; - rayToBps[1000000007215052652090854324] = 2555; - rayToBps[1000000007217578221939076629] = 2556; - rayToBps[1000000007220103590650854001] = 2557; - rayToBps[1000000007222628758258220911] = 2558; - rayToBps[1000000007225153724793204178] = 2559; - rayToBps[1000000007227678490287822975] = 2560; - rayToBps[1000000007230203054774088820] = 2561; - rayToBps[1000000007232727418284005593] = 2562; - rayToBps[1000000007235251580849569527] = 2563; - rayToBps[1000000007237775542502769216] = 2564; - rayToBps[1000000007240299303275585616] = 2565; - rayToBps[1000000007242822863199992048] = 2566; - rayToBps[1000000007245346222307954199] = 2567; - rayToBps[1000000007247869380631430127] = 2568; - rayToBps[1000000007250392338202370260] = 2569; - rayToBps[1000000007252915095052717402] = 2570; - rayToBps[1000000007255437651214406734] = 2571; - rayToBps[1000000007257960006719365813] = 2572; - rayToBps[1000000007260482161599514580] = 2573; - rayToBps[1000000007263004115886765361] = 2574; - rayToBps[1000000007265525869613022867] = 2575; - rayToBps[1000000007268047422810184197] = 2576; - rayToBps[1000000007270568775510138843] = 2577; - rayToBps[1000000007273089927744768690] = 2578; - rayToBps[1000000007275610879545948018] = 2579; - rayToBps[1000000007278131630945543509] = 2580; - rayToBps[1000000007280652181975414240] = 2581; - rayToBps[1000000007283172532667411698] = 2582; - rayToBps[1000000007285692683053379771] = 2583; - rayToBps[1000000007288212633165154756] = 2584; - rayToBps[1000000007290732383034565363] = 2585; - rayToBps[1000000007293251932693432712] = 2586; - rayToBps[1000000007295771282173570341] = 2587; - rayToBps[1000000007298290431506784204] = 2588; - rayToBps[1000000007300809380724872677] = 2589; - rayToBps[1000000007303328129859626555] = 2590; - rayToBps[1000000007305846678942829063] = 2591; - rayToBps[1000000007308365028006255850] = 2592; - rayToBps[1000000007310883177081674995] = 2593; - rayToBps[1000000007313401126200847011] = 2594; - rayToBps[1000000007315918875395524846] = 2595; - rayToBps[1000000007318436424697453882] = 2596; - rayToBps[1000000007320953774138371943] = 2597; - rayToBps[1000000007323470923750009295] = 2598; - rayToBps[1000000007325987873564088646] = 2599; - rayToBps[1000000007328504623612325153] = 2600; - rayToBps[1000000007331021173926426421] = 2601; - rayToBps[1000000007333537524538092508] = 2602; - rayToBps[1000000007336053675479015924] = 2603; - rayToBps[1000000007338569626780881634] = 2604; - rayToBps[1000000007341085378475367066] = 2605; - rayToBps[1000000007343600930594142104] = 2606; - rayToBps[1000000007346116283168869100] = 2607; - rayToBps[1000000007348631436231202869] = 2608; - rayToBps[1000000007351146389812790696] = 2609; - rayToBps[1000000007353661143945272335] = 2610; - rayToBps[1000000007356175698660280013] = 2611; - rayToBps[1000000007358690053989438434] = 2612; - rayToBps[1000000007361204209964364778] = 2613; - rayToBps[1000000007363718166616668706] = 2614; - rayToBps[1000000007366231923977952362] = 2615; - rayToBps[1000000007368745482079810375] = 2616; - rayToBps[1000000007371258840953829859] = 2617; - rayToBps[1000000007373772000631590422] = 2618; - rayToBps[1000000007376284961144664159] = 2619; - rayToBps[1000000007378797722524615662] = 2620; - rayToBps[1000000007381310284803002021] = 2621; - rayToBps[1000000007383822648011372824] = 2622; - rayToBps[1000000007386334812181270160] = 2623; - rayToBps[1000000007388846777344228623] = 2624; - rayToBps[1000000007391358543531775311] = 2625; - rayToBps[1000000007393870110775429835] = 2626; - rayToBps[1000000007396381479106704315] = 2627; - rayToBps[1000000007398892648557103381] = 2628; - rayToBps[1000000007401403619158124184] = 2629; - rayToBps[1000000007403914390941256391] = 2630; - rayToBps[1000000007406424963937982190] = 2631; - rayToBps[1000000007408935338179776291] = 2632; - rayToBps[1000000007411445513698105929] = 2633; - rayToBps[1000000007413955490524430869] = 2634; - rayToBps[1000000007416465268690203405] = 2635; - rayToBps[1000000007418974848226868363] = 2636; - rayToBps[1000000007421484229165863101] = 2637; - rayToBps[1000000007423993411538617520] = 2638; - rayToBps[1000000007426502395376554056] = 2639; - rayToBps[1000000007429011180711087689] = 2640; - rayToBps[1000000007431519767573625942] = 2641; - rayToBps[1000000007434028155995568885] = 2642; - rayToBps[1000000007436536346008309136] = 2643; - rayToBps[1000000007439044337643231867] = 2644; - rayToBps[1000000007441552130931714802] = 2645; - rayToBps[1000000007444059725905128218] = 2646; - rayToBps[1000000007446567122594834957] = 2647; - rayToBps[1000000007449074321032190415] = 2648; - rayToBps[1000000007451581321248542554] = 2649; - rayToBps[1000000007454088123275231904] = 2650; - rayToBps[1000000007456594727143591558] = 2651; - rayToBps[1000000007459101132884947181] = 2652; - rayToBps[1000000007461607340530617012] = 2653; - rayToBps[1000000007464113350111911864] = 2654; - rayToBps[1000000007466619161660135123] = 2655; - rayToBps[1000000007469124775206582763] = 2656; - rayToBps[1000000007471630190782543332] = 2657; - rayToBps[1000000007474135408419297966] = 2658; - rayToBps[1000000007476640428148120386] = 2659; - rayToBps[1000000007479145250000276903] = 2660; - rayToBps[1000000007481649874007026420] = 2661; - rayToBps[1000000007484154300199620430] = 2662; - rayToBps[1000000007486658528609303027] = 2663; - rayToBps[1000000007489162559267310898] = 2664; - rayToBps[1000000007491666392204873334] = 2665; - rayToBps[1000000007494170027453212228] = 2666; - rayToBps[1000000007496673465043542080] = 2667; - rayToBps[1000000007499176705007069991] = 2668; - rayToBps[1000000007501679747374995682] = 2669; - rayToBps[1000000007504182592178511478] = 2670; - rayToBps[1000000007506685239448802322] = 2671; - rayToBps[1000000007509187689217045773] = 2672; - rayToBps[1000000007511689941514412011] = 2673; - rayToBps[1000000007514191996372063835] = 2674; - rayToBps[1000000007516693853821156670] = 2675; - rayToBps[1000000007519195513892838566] = 2676; - rayToBps[1000000007521696976618250202] = 2677; - rayToBps[1000000007524198242028524886] = 2678; - rayToBps[1000000007526699310154788564] = 2679; - rayToBps[1000000007529200181028159813] = 2680; - rayToBps[1000000007531700854679749850] = 2681; - rayToBps[1000000007534201331140662531] = 2682; - rayToBps[1000000007536701610441994354] = 2683; - rayToBps[1000000007539201692614834466] = 2684; - rayToBps[1000000007541701577690264654] = 2685; - rayToBps[1000000007544201265699359361] = 2686; - rayToBps[1000000007546700756673185679] = 2687; - rayToBps[1000000007549200050642803353] = 2688; - rayToBps[1000000007551699147639264788] = 2689; - rayToBps[1000000007554198047693615043] = 2690; - rayToBps[1000000007556696750836891842] = 2691; - rayToBps[1000000007559195257100125570] = 2692; - rayToBps[1000000007561693566514339279] = 2693; - rayToBps[1000000007564191679110548687] = 2694; - rayToBps[1000000007566689594919762187] = 2695; - rayToBps[1000000007569187313972980838] = 2696; - rayToBps[1000000007571684836301198378] = 2697; - rayToBps[1000000007574182161935401222] = 2698; - rayToBps[1000000007576679290906568463] = 2699; - rayToBps[1000000007579176223245671878] = 2700; - rayToBps[1000000007581672958983675926] = 2701; - rayToBps[1000000007584169498151537752] = 2702; - rayToBps[1000000007586665840780207194] = 2703; - rayToBps[1000000007589161986900626776] = 2704; - rayToBps[1000000007591657936543731717] = 2705; - rayToBps[1000000007594153689740449933] = 2706; - rayToBps[1000000007596649246521702037] = 2707; - rayToBps[1000000007599144606918401342] = 2708; - rayToBps[1000000007601639770961453862] = 2709; - rayToBps[1000000007604134738681758320] = 2710; - rayToBps[1000000007606629510110206142] = 2711; - rayToBps[1000000007609124085277681464] = 2712; - rayToBps[1000000007611618464215061138] = 2713; - rayToBps[1000000007614112646953214725] = 2714; - rayToBps[1000000007616606633523004503] = 2715; - rayToBps[1000000007619100423955285470] = 2716; - rayToBps[1000000007621594018280905346] = 2717; - rayToBps[1000000007624087416530704571] = 2718; - rayToBps[1000000007626580618735516314] = 2719; - rayToBps[1000000007629073624926166467] = 2720; - rayToBps[1000000007631566435133473656] = 2721; - rayToBps[1000000007634059049388249240] = 2722; - rayToBps[1000000007636551467721297309] = 2723; - rayToBps[1000000007639043690163414692] = 2724; - rayToBps[1000000007641535716745390957] = 2725; - rayToBps[1000000007644027547498008412] = 2726; - rayToBps[1000000007646519182452042112] = 2727; - rayToBps[1000000007649010621638259855] = 2728; - rayToBps[1000000007651501865087422189] = 2729; - rayToBps[1000000007653992912830282410] = 2730; - rayToBps[1000000007656483764897586571] = 2731; - rayToBps[1000000007658974421320073477] = 2732; - rayToBps[1000000007661464882128474691] = 2733; - rayToBps[1000000007663955147353514535] = 2734; - rayToBps[1000000007666445217025910095] = 2735; - rayToBps[1000000007668935091176371220] = 2736; - rayToBps[1000000007671424769835600527] = 2737; - rayToBps[1000000007673914253034293397] = 2738; - rayToBps[1000000007676403540803137988] = 2739; - rayToBps[1000000007678892633172815227] = 2740; - rayToBps[1000000007681381530173998820] = 2741; - rayToBps[1000000007683870231837355249] = 2742; - rayToBps[1000000007686358738193543774] = 2743; - rayToBps[1000000007688847049273216443] = 2744; - rayToBps[1000000007691335165107018082] = 2745; - rayToBps[1000000007693823085725586308] = 2746; - rayToBps[1000000007696310811159551528] = 2747; - rayToBps[1000000007698798341439536935] = 2748; - rayToBps[1000000007701285676596158525] = 2749; - rayToBps[1000000007703772816660025079] = 2750; - rayToBps[1000000007706259761661738185] = 2751; - rayToBps[1000000007708746511631892227] = 2752; - rayToBps[1000000007711233066601074392] = 2753; - rayToBps[1000000007713719426599864675] = 2754; - rayToBps[1000000007716205591658835874] = 2755; - rayToBps[1000000007718691561808553598] = 2756; - rayToBps[1000000007721177337079576270] = 2757; - rayToBps[1000000007723662917502455126] = 2758; - rayToBps[1000000007726148303107734216] = 2759; - rayToBps[1000000007728633493925950409] = 2760; - rayToBps[1000000007731118489987633399] = 2761; - rayToBps[1000000007733603291323305697] = 2762; - rayToBps[1000000007736087897963482645] = 2763; - rayToBps[1000000007738572309938672406] = 2764; - rayToBps[1000000007741056527279375980] = 2765; - rayToBps[1000000007743540550016087193] = 2766; - rayToBps[1000000007746024378179292708] = 2767; - rayToBps[1000000007748508011799472026] = 2768; - rayToBps[1000000007750991450907097483] = 2769; - rayToBps[1000000007753474695532634259] = 2770; - rayToBps[1000000007755957745706540376] = 2771; - rayToBps[1000000007758440601459266700] = 2772; - rayToBps[1000000007760923262821256948] = 2773; - rayToBps[1000000007763405729822947685] = 2774; - rayToBps[1000000007765888002494768329] = 2775; - rayToBps[1000000007768370080867141151] = 2776; - rayToBps[1000000007770851964970481280] = 2777; - rayToBps[1000000007773333654835196703] = 2778; - rayToBps[1000000007775815150491688269] = 2779; - rayToBps[1000000007778296451970349690] = 2780; - rayToBps[1000000007780777559301567543] = 2781; - rayToBps[1000000007783258472515721274] = 2782; - rayToBps[1000000007785739191643183199] = 2783; - rayToBps[1000000007788219716714318505] = 2784; - rayToBps[1000000007790700047759485254] = 2785; - rayToBps[1000000007793180184809034386] = 2786; - rayToBps[1000000007795660127893309718] = 2787; - rayToBps[1000000007798139877042647950] = 2788; - rayToBps[1000000007800619432287378665] = 2789; - rayToBps[1000000007803098793657824331] = 2790; - rayToBps[1000000007805577961184300304] = 2791; - rayToBps[1000000007808056934897114831] = 2792; - rayToBps[1000000007810535714826569051] = 2793; - rayToBps[1000000007813014301002956995] = 2794; - rayToBps[1000000007815492693456565596] = 2795; - rayToBps[1000000007817970892217674682] = 2796; - rayToBps[1000000007820448897316556983] = 2797; - rayToBps[1000000007822926708783478132] = 2798; - rayToBps[1000000007825404326648696672] = 2799; - rayToBps[1000000007827881750942464045] = 2800; - rayToBps[1000000007830358981695024613] = 2801; - rayToBps[1000000007832836018936615642] = 2802; - rayToBps[1000000007835312862697467319] = 2803; - rayToBps[1000000007837789513007802744] = 2804; - rayToBps[1000000007840265969897837937] = 2805; - rayToBps[1000000007842742233397781838] = 2806; - rayToBps[1000000007845218303537836314] = 2807; - rayToBps[1000000007847694180348196153] = 2808; - rayToBps[1000000007850169863859049072] = 2809; - rayToBps[1000000007852645354100575721] = 2810; - rayToBps[1000000007855120651102949679] = 2811; - rayToBps[1000000007857595754896337460] = 2812; - rayToBps[1000000007860070665510898517] = 2813; - rayToBps[1000000007862545382976785237] = 2814; - rayToBps[1000000007865019907324142954] = 2815; - rayToBps[1000000007867494238583109939] = 2816; - rayToBps[1000000007869968376783817414] = 2817; - rayToBps[1000000007872442321956389545] = 2818; - rayToBps[1000000007874916074130943450] = 2819; - rayToBps[1000000007877389633337589198] = 2820; - rayToBps[1000000007879862999606429812] = 2821; - rayToBps[1000000007882336172967561271] = 2822; - rayToBps[1000000007884809153451072514] = 2823; - rayToBps[1000000007887281941087045441] = 2824; - rayToBps[1000000007889754535905554913] = 2825; - rayToBps[1000000007892226937936668759] = 2826; - rayToBps[1000000007894699147210447772] = 2827; - rayToBps[1000000007897171163756945718] = 2828; - rayToBps[1000000007899642987606209333] = 2829; - rayToBps[1000000007902114618788278327] = 2830; - rayToBps[1000000007904586057333185387] = 2831; - rayToBps[1000000007907057303270956176] = 2832; - rayToBps[1000000007909528356631609343] = 2833; - rayToBps[1000000007911999217445156512] = 2834; - rayToBps[1000000007914469885741602299] = 2835; - rayToBps[1000000007916940361550944303] = 2836; - rayToBps[1000000007919410644903173113] = 2837; - rayToBps[1000000007921880735828272312] = 2838; - rayToBps[1000000007924350634356218473] = 2839; - rayToBps[1000000007926820340516981166] = 2840; - rayToBps[1000000007929289854340522961] = 2841; - rayToBps[1000000007931759175856799426] = 2842; - rayToBps[1000000007934228305095759133] = 2843; - rayToBps[1000000007936697242087343656] = 2844; - rayToBps[1000000007939165986861487579] = 2845; - rayToBps[1000000007941634539448118494] = 2846; - rayToBps[1000000007944102899877157001] = 2847; - rayToBps[1000000007946571068178516718] = 2848; - rayToBps[1000000007949039044382104276] = 2849; - rayToBps[1000000007951506828517819323] = 2850; - rayToBps[1000000007953974420615554529] = 2851; - rayToBps[1000000007956441820705195583] = 2852; - rayToBps[1000000007958909028816621201] = 2853; - rayToBps[1000000007961376044979703124] = 2854; - rayToBps[1000000007963842869224306123] = 2855; - rayToBps[1000000007966309501580287995] = 2856; - rayToBps[1000000007968775942077499577] = 2857; - rayToBps[1000000007971242190745784735] = 2858; - rayToBps[1000000007973708247614980375] = 2859; - rayToBps[1000000007976174112714916441] = 2860; - rayToBps[1000000007978639786075415919] = 2861; - rayToBps[1000000007981105267726294840] = 2862; - rayToBps[1000000007983570557697362280] = 2863; - rayToBps[1000000007986035656018420361] = 2864; - rayToBps[1000000007988500562719264258] = 2865; - rayToBps[1000000007990965277829682196] = 2866; - rayToBps[1000000007993429801379455456] = 2867; - rayToBps[1000000007995894133398358376] = 2868; - rayToBps[1000000007998358273916158351] = 2869; - rayToBps[1000000008000822222962615839] = 2870; - rayToBps[1000000008003285980567484358] = 2871; - rayToBps[1000000008005749546760510496] = 2872; - rayToBps[1000000008008212921571433904] = 2873; - rayToBps[1000000008010676105029987304] = 2874; - rayToBps[1000000008013139097165896490] = 2875; - rayToBps[1000000008015601898008880332] = 2876; - rayToBps[1000000008018064507588650772] = 2877; - rayToBps[1000000008020526925934912831] = 2878; - rayToBps[1000000008022989153077364614] = 2879; - rayToBps[1000000008025451189045697303] = 2880; - rayToBps[1000000008027913033869595170] = 2881; - rayToBps[1000000008030374687578735570] = 2882; - rayToBps[1000000008032836150202788948] = 2883; - rayToBps[1000000008035297421771418841] = 2884; - rayToBps[1000000008037758502314281877] = 2885; - rayToBps[1000000008040219391861027783] = 2886; - rayToBps[1000000008042680090441299379] = 2887; - rayToBps[1000000008045140598084732587] = 2888; - rayToBps[1000000008047600914820956433] = 2889; - rayToBps[1000000008050061040679593042] = 2890; - rayToBps[1000000008052520975690257649] = 2891; - rayToBps[1000000008054980719882558595] = 2892; - rayToBps[1000000008057440273286097333] = 2893; - rayToBps[1000000008059899635930468427] = 2894; - rayToBps[1000000008062358807845259556] = 2895; - rayToBps[1000000008064817789060051517] = 2896; - rayToBps[1000000008067276579604418223] = 2897; - rayToBps[1000000008069735179507926713] = 2898; - rayToBps[1000000008072193588800137143] = 2899; - rayToBps[1000000008074651807510602798] = 2900; - rayToBps[1000000008077109835668870091] = 2901; - rayToBps[1000000008079567673304478561] = 2902; - rayToBps[1000000008082025320446960884] = 2903; - rayToBps[1000000008084482777125842863] = 2904; - rayToBps[1000000008086940043370643444] = 2905; - rayToBps[1000000008089397119210874706] = 2906; - rayToBps[1000000008091854004676041869] = 2907; - rayToBps[1000000008094310699795643299] = 2908; - rayToBps[1000000008096767204599170500] = 2909; - rayToBps[1000000008099223519116108130] = 2910; - rayToBps[1000000008101679643375933989] = 2911; - rayToBps[1000000008104135577408119032] = 2912; - rayToBps[1000000008106591321242127364] = 2913; - rayToBps[1000000008109046874907416248] = 2914; - rayToBps[1000000008111502238433436104] = 2915; - rayToBps[1000000008113957411849630507] = 2916; - rayToBps[1000000008116412395185436200] = 2917; - rayToBps[1000000008118867188470283082] = 2918; - rayToBps[1000000008121321791733594224] = 2919; - rayToBps[1000000008123776205004785863] = 2920; - rayToBps[1000000008126230428313267405] = 2921; - rayToBps[1000000008128684461688441426] = 2922; - rayToBps[1000000008131138305159703681] = 2923; - rayToBps[1000000008133591958756443098] = 2924; - rayToBps[1000000008136045422508041783] = 2925; - rayToBps[1000000008138498696443875023] = 2926; - rayToBps[1000000008140951780593311289] = 2927; - rayToBps[1000000008143404674985712235] = 2928; - rayToBps[1000000008145857379650432701] = 2929; - rayToBps[1000000008148309894616820721] = 2930; - rayToBps[1000000008150762219914217511] = 2931; - rayToBps[1000000008153214355571957489] = 2932; - rayToBps[1000000008155666301619368262] = 2933; - rayToBps[1000000008158118058085770639] = 2934; - rayToBps[1000000008160569625000478625] = 2935; - rayToBps[1000000008163021002392799426] = 2936; - rayToBps[1000000008165472190292033455] = 2937; - rayToBps[1000000008167923188727474329] = 2938; - rayToBps[1000000008170373997728408871] = 2939; - rayToBps[1000000008172824617324117117] = 2940; - rayToBps[1000000008175275047543872314] = 2941; - rayToBps[1000000008177725288416940921] = 2942; - rayToBps[1000000008180175339972582615] = 2943; - rayToBps[1000000008182625202240050293] = 2944; - rayToBps[1000000008185074875248590068] = 2945; - rayToBps[1000000008187524359027441281] = 2946; - rayToBps[1000000008189973653605836492] = 2947; - rayToBps[1000000008192422759013001491] = 2948; - rayToBps[1000000008194871675278155297] = 2949; - rayToBps[1000000008197320402430510158] = 2950; - rayToBps[1000000008199768940499271556] = 2951; - rayToBps[1000000008202217289513638208] = 2952; - rayToBps[1000000008204665449502802068] = 2953; - rayToBps[1000000008207113420495948328] = 2954; - rayToBps[1000000008209561202522255424] = 2955; - rayToBps[1000000008212008795610895033] = 2956; - rayToBps[1000000008214456199791032080] = 2957; - rayToBps[1000000008216903415091824734] = 2958; - rayToBps[1000000008219350441542424416] = 2959; - rayToBps[1000000008221797279171975799] = 2960; - rayToBps[1000000008224243928009616809] = 2961; - rayToBps[1000000008226690388084478627] = 2962; - rayToBps[1000000008229136659425685693] = 2963; - rayToBps[1000000008231582742062355709] = 2964; - rayToBps[1000000008234028636023599636] = 2965; - rayToBps[1000000008236474341338521699] = 2966; - rayToBps[1000000008238919858036219393] = 2967; - rayToBps[1000000008241365186145783477] = 2968; - rayToBps[1000000008243810325696297983] = 2969; - rayToBps[1000000008246255276716840215] = 2970; - rayToBps[1000000008248700039236480752] = 2971; - rayToBps[1000000008251144613284283449] = 2972; - rayToBps[1000000008253588998889305439] = 2973; - rayToBps[1000000008256033196080597139] = 2974; - rayToBps[1000000008258477204887202245] = 2975; - rayToBps[1000000008260921025338157740] = 2976; - rayToBps[1000000008263364657462493893] = 2977; - rayToBps[1000000008265808101289234264] = 2978; - rayToBps[1000000008268251356847395701] = 2979; - rayToBps[1000000008270694424165988349] = 2980; - rayToBps[1000000008273137303274015646] = 2981; - rayToBps[1000000008275579994200474327] = 2982; - rayToBps[1000000008278022496974354428] = 2983; - rayToBps[1000000008280464811624639285] = 2984; - rayToBps[1000000008282906938180305537] = 2985; - rayToBps[1000000008285348876670323134] = 2986; - rayToBps[1000000008287790627123655325] = 2987; - rayToBps[1000000008290232189569258676] = 2988; - rayToBps[1000000008292673564036083061] = 2989; - rayToBps[1000000008295114750553071670] = 2990; - rayToBps[1000000008297555749149161005] = 2991; - rayToBps[1000000008299996559853280893] = 2992; - rayToBps[1000000008302437182694354473] = 2993; - rayToBps[1000000008304877617701298212] = 2994; - rayToBps[1000000008307317864903021899] = 2995; - rayToBps[1000000008309757924328428649] = 2996; - rayToBps[1000000008312197796006414905] = 2997; - rayToBps[1000000008314637479965870443] = 2998; - rayToBps[1000000008317076976235678365] = 2999; - rayToBps[1000000008319516284844715115] = 3000; - rayToBps[1000000008321955405821850471] = 3001; - rayToBps[1000000008324394339195947545] = 3002; - rayToBps[1000000008326833084995862796] = 3003; - rayToBps[1000000008329271643250446021] = 3004; - rayToBps[1000000008331710013988540364] = 3005; - rayToBps[1000000008334148197238982316] = 3006; - rayToBps[1000000008336586193030601715] = 3007; - rayToBps[1000000008339024001392221751] = 3008; - rayToBps[1000000008341461622352658967] = 3009; - rayToBps[1000000008343899055940723259] = 3010; - rayToBps[1000000008346336302185217882] = 3011; - rayToBps[1000000008348773361114939450] = 3012; - rayToBps[1000000008351210232758677936] = 3013; - rayToBps[1000000008353646917145216679] = 3014; - rayToBps[1000000008356083414303332380] = 3015; - rayToBps[1000000008358519724261795110] = 3016; - rayToBps[1000000008360955847049368306] = 3017; - rayToBps[1000000008363391782694808779] = 3018; - rayToBps[1000000008365827531226866712] = 3019; - rayToBps[1000000008368263092674285664] = 3020; - rayToBps[1000000008370698467065802570] = 3021; - rayToBps[1000000008373133654430147746] = 3022; - rayToBps[1000000008375568654796044887] = 3023; - rayToBps[1000000008378003468192211075] = 3024; - rayToBps[1000000008380438094647356774] = 3025; - rayToBps[1000000008382872534190185837] = 3026; - rayToBps[1000000008385306786849395508] = 3027; - rayToBps[1000000008387740852653676418] = 3028; - rayToBps[1000000008390174731631712596] = 3029; - rayToBps[1000000008392608423812181466] = 3030; - rayToBps[1000000008395041929223753848] = 3031; - rayToBps[1000000008397475247895093962] = 3032; - rayToBps[1000000008399908379854859430] = 3033; - rayToBps[1000000008402341325131701278] = 3034; - rayToBps[1000000008404774083754263937] = 3035; - rayToBps[1000000008407206655751185247] = 3036; - rayToBps[1000000008409639041151096456] = 3037; - rayToBps[1000000008412071239982622226] = 3038; - rayToBps[1000000008414503252274380631] = 3039; - rayToBps[1000000008416935078054983162] = 3040; - rayToBps[1000000008419366717353034726] = 3041; - rayToBps[1000000008421798170197133652] = 3042; - rayToBps[1000000008424229436615871690] = 3043; - rayToBps[1000000008426660516637834013] = 3044; - rayToBps[1000000008429091410291599222] = 3045; - rayToBps[1000000008431522117605739346] = 3046; - rayToBps[1000000008433952638608819840] = 3047; - rayToBps[1000000008436382973329399595] = 3048; - rayToBps[1000000008438813121796030934] = 3049; - rayToBps[1000000008441243084037259619] = 3050; - rayToBps[1000000008443672860081624846] = 3051; - rayToBps[1000000008446102449957659252] = 3052; - rayToBps[1000000008448531853693888919] = 3053; - rayToBps[1000000008450961071318833369] = 3054; - rayToBps[1000000008453390102861005572] = 3055; - rayToBps[1000000008455818948348911946] = 3056; - rayToBps[1000000008458247607811052360] = 3057; - rayToBps[1000000008460676081275920133] = 3058; - rayToBps[1000000008463104368772002040] = 3059; - rayToBps[1000000008465532470327778310] = 3060; - rayToBps[1000000008467960385971722632] = 3061; - rayToBps[1000000008470388115732302154] = 3062; - rayToBps[1000000008472815659637977489] = 3063; - rayToBps[1000000008475243017717202707] = 3064; - rayToBps[1000000008477670189998425353] = 3065; - rayToBps[1000000008480097176510086432] = 3066; - rayToBps[1000000008482523977280620426] = 3067; - rayToBps[1000000008484950592338455283] = 3068; - rayToBps[1000000008487377021712012431] = 3069; - rayToBps[1000000008489803265429706768] = 3070; - rayToBps[1000000008492229323519946677] = 3071; - rayToBps[1000000008494655196011134014] = 3072; - rayToBps[1000000008497080882931664122] = 3073; - rayToBps[1000000008499506384309925825] = 3074; - rayToBps[1000000008501931700174301437] = 3075; - rayToBps[1000000008504356830553166755] = 3076; - rayToBps[1000000008506781775474891069] = 3077; - rayToBps[1000000008509206534967837162] = 3078; - rayToBps[1000000008511631109060361308] = 3079; - rayToBps[1000000008514055497780813280] = 3080; - rayToBps[1000000008516479701157536348] = 3081; - rayToBps[1000000008518903719218867280] = 3082; - rayToBps[1000000008521327551993136348] = 3083; - rayToBps[1000000008523751199508667330] = 3084; - rayToBps[1000000008526174661793777504] = 3085; - rayToBps[1000000008528597938876777661] = 3086; - rayToBps[1000000008531021030785972101] = 3087; - rayToBps[1000000008533443937549658636] = 3088; - rayToBps[1000000008535866659196128590] = 3089; - rayToBps[1000000008538289195753666803] = 3090; - rayToBps[1000000008540711547250551637] = 3091; - rayToBps[1000000008543133713715054969] = 3092; - rayToBps[1000000008545555695175442199] = 3093; - rayToBps[1000000008547977491659972252] = 3094; - rayToBps[1000000008550399103196897579] = 3095; - rayToBps[1000000008552820529814464158] = 3096; - rayToBps[1000000008555241771540911495] = 3097; - rayToBps[1000000008557662828404472630] = 3098; - rayToBps[1000000008560083700433374138] = 3099; - rayToBps[1000000008562504387655836125] = 3100; - rayToBps[1000000008564924890100072238] = 3101; - rayToBps[1000000008567345207794289664] = 3102; - rayToBps[1000000008569765340766689130] = 3103; - rayToBps[1000000008572185289045464906] = 3104; - rayToBps[1000000008574605052658804811] = 3105; - rayToBps[1000000008577024631634890207] = 3106; - rayToBps[1000000008579444026001896008] = 3107; - rayToBps[1000000008581863235787990679] = 3108; - rayToBps[1000000008584282261021336238] = 3109; - rayToBps[1000000008586701101730088259] = 3110; - rayToBps[1000000008589119757942395872] = 3111; - rayToBps[1000000008591538229686401769] = 3112; - rayToBps[1000000008593956516990242201] = 3113; - rayToBps[1000000008596374619882046982] = 3114; - rayToBps[1000000008598792538389939493] = 3115; - rayToBps[1000000008601210272542036680] = 3116; - rayToBps[1000000008603627822366449059] = 3117; - rayToBps[1000000008606045187891280718] = 3118; - rayToBps[1000000008608462369144629317] = 3119; - rayToBps[1000000008610879366154586092] = 3120; - rayToBps[1000000008613296178949235855] = 3121; - rayToBps[1000000008615712807556656995] = 3122; - rayToBps[1000000008618129252004921486] = 3123; - rayToBps[1000000008620545512322094883] = 3124; - rayToBps[1000000008622961588536236324] = 3125; - rayToBps[1000000008625377480675398538] = 3126; - rayToBps[1000000008627793188767627836] = 3127; - rayToBps[1000000008630208712840964127] = 3128; - rayToBps[1000000008632624052923440907] = 3129; - rayToBps[1000000008635039209043085270] = 3130; - rayToBps[1000000008637454181227917904] = 3131; - rayToBps[1000000008639868969505953098] = 3132; - rayToBps[1000000008642283573905198739] = 3133; - rayToBps[1000000008644697994453656318] = 3134; - rayToBps[1000000008647112231179320929] = 3135; - rayToBps[1000000008649526284110181275] = 3136; - rayToBps[1000000008651940153274219662] = 3137; - rayToBps[1000000008654353838699412010] = 3138; - rayToBps[1000000008656767340413727852] = 3139; - rayToBps[1000000008659180658445130332] = 3140; - rayToBps[1000000008661593792821576212] = 3141; - rayToBps[1000000008664006743571015870] = 3142; - rayToBps[1000000008666419510721393305] = 3143; - rayToBps[1000000008668832094300646140] = 3144; - rayToBps[1000000008671244494336705617] = 3145; - rayToBps[1000000008673656710857496608] = 3146; - rayToBps[1000000008676068743890937609] = 3147; - rayToBps[1000000008678480593464940750] = 3148; - rayToBps[1000000008680892259607411787] = 3149; - rayToBps[1000000008683303742346250114] = 3150; - rayToBps[1000000008685715041709348759] = 3151; - rayToBps[1000000008688126157724594385] = 3152; - rayToBps[1000000008690537090419867299] = 3153; - rayToBps[1000000008692947839823041443] = 3154; - rayToBps[1000000008695358405961984408] = 3155; - rayToBps[1000000008697768788864557426] = 3156; - rayToBps[1000000008700178988558615379] = 3157; - rayToBps[1000000008702589005072006795] = 3158; - rayToBps[1000000008704998838432573855] = 3159; - rayToBps[1000000008707408488668152392] = 3160; - rayToBps[1000000008709817955806571893] = 3161; - rayToBps[1000000008712227239875655502] = 3162; - rayToBps[1000000008714636340903220022] = 3163; - rayToBps[1000000008717045258917075917] = 3164; - rayToBps[1000000008719453993945027311] = 3165; - rayToBps[1000000008721862546014871996] = 3166; - rayToBps[1000000008724270915154401427] = 3167; - rayToBps[1000000008726679101391400728] = 3168; - rayToBps[1000000008729087104753648695] = 3169; - rayToBps[1000000008731494925268917794] = 3170; - rayToBps[1000000008733902562964974164] = 3171; - rayToBps[1000000008736310017869577622] = 3172; - rayToBps[1000000008738717290010481663] = 3173; - rayToBps[1000000008741124379415433461] = 3174; - rayToBps[1000000008743531286112173869] = 3175; - rayToBps[1000000008745938010128437428] = 3176; - rayToBps[1000000008748344551491952362] = 3177; - rayToBps[1000000008750750910230440583] = 3178; - rayToBps[1000000008753157086371617690] = 3179; - rayToBps[1000000008755563079943192978] = 3180; - rayToBps[1000000008757968890972869430] = 3181; - rayToBps[1000000008760374519488343729] = 3182; - rayToBps[1000000008762779965517306250] = 3183; - rayToBps[1000000008765185229087441070] = 3184; - rayToBps[1000000008767590310226425966] = 3185; - rayToBps[1000000008769995208961932417] = 3186; - rayToBps[1000000008772399925321625609] = 3187; - rayToBps[1000000008774804459333164431] = 3188; - rayToBps[1000000008777208811024201482] = 3189; - rayToBps[1000000008779612980422383073] = 3190; - rayToBps[1000000008782016967555349225] = 3191; - rayToBps[1000000008784420772450733672] = 3192; - rayToBps[1000000008786824395136163869] = 3193; - rayToBps[1000000008789227835639260984] = 3194; - rayToBps[1000000008791631093987639905] = 3195; - rayToBps[1000000008794034170208909246] = 3196; - rayToBps[1000000008796437064330671341] = 3197; - rayToBps[1000000008798839776380522251] = 3198; - rayToBps[1000000008801242306386051763] = 3199; - rayToBps[1000000008803644654374843395] = 3200; - rayToBps[1000000008806046820374474396] = 3201; - rayToBps[1000000008808448804412515748] = 3202; - rayToBps[1000000008810850606516532167] = 3203; - rayToBps[1000000008813252226714082106] = 3204; - rayToBps[1000000008815653665032717760] = 3205; - rayToBps[1000000008818054921499985060] = 3206; - rayToBps[1000000008820455996143423684] = 3207; - rayToBps[1000000008822856888990567050] = 3208; - rayToBps[1000000008825257600068942328] = 3209; - rayToBps[1000000008827658129406070432] = 3210; - rayToBps[1000000008830058477029466028] = 3211; - rayToBps[1000000008832458642966637533] = 3212; - rayToBps[1000000008834858627245087117] = 3213; - rayToBps[1000000008837258429892310711] = 3214; - rayToBps[1000000008839658050935797999] = 3215; - rayToBps[1000000008842057490403032425] = 3216; - rayToBps[1000000008844456748321491195] = 3217; - rayToBps[1000000008846855824718645282] = 3218; - rayToBps[1000000008849254719621959420] = 3219; - rayToBps[1000000008851653433058892110] = 3220; - rayToBps[1000000008854051965056895625] = 3221; - rayToBps[1000000008856450315643416008] = 3222; - rayToBps[1000000008858848484845893073] = 3223; - rayToBps[1000000008861246472691760412] = 3224; - rayToBps[1000000008863644279208445392] = 3225; - rayToBps[1000000008866041904423369157] = 3226; - rayToBps[1000000008868439348363946634] = 3227; - rayToBps[1000000008870836611057586530] = 3228; - rayToBps[1000000008873233692531691339] = 3229; - rayToBps[1000000008875630592813657337] = 3230; - rayToBps[1000000008878027311930874594] = 3231; - rayToBps[1000000008880423849910726963] = 3232; - rayToBps[1000000008882820206780592093] = 3233; - rayToBps[1000000008885216382567841425] = 3234; - rayToBps[1000000008887612377299840196] = 3235; - rayToBps[1000000008890008191003947440] = 3236; - rayToBps[1000000008892403823707515991] = 3237; - rayToBps[1000000008894799275437892482] = 3238; - rayToBps[1000000008897194546222417351] = 3239; - rayToBps[1000000008899589636088424841] = 3240; - rayToBps[1000000008901984545063242999] = 3241; - rayToBps[1000000008904379273174193682] = 3242; - rayToBps[1000000008906773820448592561] = 3243; - rayToBps[1000000008909168186913749112] = 3244; - rayToBps[1000000008911562372596966632] = 3245; - rayToBps[1000000008913956377525542231] = 3246; - rayToBps[1000000008916350201726766834] = 3247; - rayToBps[1000000008918743845227925192] = 3248; - rayToBps[1000000008921137308056295874] = 3249; - rayToBps[1000000008923530590239151272] = 3250; - rayToBps[1000000008925923691803757605] = 3251; - rayToBps[1000000008928316612777374918] = 3252; - rayToBps[1000000008930709353187257086] = 3253; - rayToBps[1000000008933101913060651814] = 3254; - rayToBps[1000000008935494292424800641] = 3255; - rayToBps[1000000008937886491306938939] = 3256; - rayToBps[1000000008940278509734295919] = 3257; - rayToBps[1000000008942670347734094627] = 3258; - rayToBps[1000000008945062005333551953] = 3259; - rayToBps[1000000008947453482559878626] = 3260; - rayToBps[1000000008949844779440279220] = 3261; - rayToBps[1000000008952235896001952156] = 3262; - rayToBps[1000000008954626832272089702] = 3263; - rayToBps[1000000008957017588277877973] = 3264; - rayToBps[1000000008959408164046496940] = 3265; - rayToBps[1000000008961798559605120424] = 3266; - rayToBps[1000000008964188774980916101] = 3267; - rayToBps[1000000008966578810201045506] = 3268; - rayToBps[1000000008968968665292664032] = 3269; - rayToBps[1000000008971358340282920931] = 3270; - rayToBps[1000000008973747835198959319] = 3271; - rayToBps[1000000008976137150067916177] = 3272; - rayToBps[1000000008978526284916922351] = 3273; - rayToBps[1000000008980915239773102555] = 3274; - rayToBps[1000000008983304014663575373] = 3275; - rayToBps[1000000008985692609615453262] = 3276; - rayToBps[1000000008988081024655842550] = 3277; - rayToBps[1000000008990469259811843445] = 3278; - rayToBps[1000000008992857315110550026] = 3279; - rayToBps[1000000008995245190579050256] = 3280; - rayToBps[1000000008997632886244425977] = 3281; - rayToBps[1000000009000020402133752914] = 3282; - rayToBps[1000000009002407738274100677] = 3283; - rayToBps[1000000009004794894692532763] = 3284; - rayToBps[1000000009007181871416106556] = 3285; - rayToBps[1000000009009568668471873331] = 3286; - rayToBps[1000000009011955285886878254] = 3287; - rayToBps[1000000009014341723688160386] = 3288; - rayToBps[1000000009016727981902752684] = 3289; - rayToBps[1000000009019114060557682002] = 3290; - rayToBps[1000000009021499959679969092] = 3291; - rayToBps[1000000009023885679296628609] = 3292; - rayToBps[1000000009026271219434669112] = 3293; - rayToBps[1000000009028656580121093060] = 3294; - rayToBps[1000000009031041761382896825] = 3295; - rayToBps[1000000009033426763247070684] = 3296; - rayToBps[1000000009035811585740598824] = 3297; - rayToBps[1000000009038196228890459345] = 3298; - rayToBps[1000000009040580692723624262] = 3299; - rayToBps[1000000009042964977267059505] = 3300; - rayToBps[1000000009045349082547724920] = 3301; - rayToBps[1000000009047733008592574277] = 3302; - rayToBps[1000000009050116755428555263] = 3303; - rayToBps[1000000009052500323082609490] = 3304; - rayToBps[1000000009054883711581672494] = 3305; - rayToBps[1000000009057266920952673739] = 3306; - rayToBps[1000000009059649951222536617] = 3307; - rayToBps[1000000009062032802418178451] = 3308; - rayToBps[1000000009064415474566510497] = 3309; - rayToBps[1000000009066797967694437943] = 3310; - rayToBps[1000000009069180281828859914] = 3311; - rayToBps[1000000009071562416996669472] = 3312; - rayToBps[1000000009073944373224753622] = 3313; - rayToBps[1000000009076326150539993305] = 3314; - rayToBps[1000000009078707748969263409] = 3315; - rayToBps[1000000009081089168539432766] = 3316; - rayToBps[1000000009083470409277364157] = 3317; - rayToBps[1000000009085851471209914307] = 3318; - rayToBps[1000000009088232354363933896] = 3319; - rayToBps[1000000009090613058766267552] = 3320; - rayToBps[1000000009092993584443753863] = 3321; - rayToBps[1000000009095373931423225367] = 3322; - rayToBps[1000000009097754099731508564] = 3323; - rayToBps[1000000009100134089395423911] = 3324; - rayToBps[1000000009102513900441785827] = 3325; - rayToBps[1000000009104893532897402697] = 3326; - rayToBps[1000000009107272986789076865] = 3327; - rayToBps[1000000009109652262143604647] = 3328; - rayToBps[1000000009112031358987776327] = 3329; - rayToBps[1000000009114410277348376157] = 3330; - rayToBps[1000000009116789017252182363] = 3331; - rayToBps[1000000009119167578725967147] = 3332; - rayToBps[1000000009121545961796496682] = 3333; - rayToBps[1000000009123924166490531122] = 3334; - rayToBps[1000000009126302192834824601] = 3335; - rayToBps[1000000009128680040856125232] = 3336; - rayToBps[1000000009131057710581175113] = 3337; - rayToBps[1000000009133435202036710325] = 3338; - rayToBps[1000000009135812515249460939] = 3339; - rayToBps[1000000009138189650246151012] = 3340; - rayToBps[1000000009140566607053498590] = 3341; - rayToBps[1000000009142943385698215714] = 3342; - rayToBps[1000000009145319986207008418] = 3343; - rayToBps[1000000009147696408606576730] = 3344; - rayToBps[1000000009150072652923614679] = 3345; - rayToBps[1000000009152448719184810291] = 3346; - rayToBps[1000000009154824607416845592] = 3347; - rayToBps[1000000009157200317646396614] = 3348; - rayToBps[1000000009159575849900133392] = 3349; - rayToBps[1000000009161951204204719966] = 3350; - rayToBps[1000000009164326380586814388] = 3351; - rayToBps[1000000009166701379073068717] = 3352; - rayToBps[1000000009169076199690129024] = 3353; - rayToBps[1000000009171450842464635396] = 3354; - rayToBps[1000000009173825307423221934] = 3355; - rayToBps[1000000009176199594592516756] = 3356; - rayToBps[1000000009178573703999141999] = 3357; - rayToBps[1000000009180947635669713821] = 3358; - rayToBps[1000000009183321389630842403] = 3359; - rayToBps[1000000009185694965909131953] = 3360; - rayToBps[1000000009188068364531180699] = 3361; - rayToBps[1000000009190441585523580901] = 3362; - rayToBps[1000000009192814628912918850] = 3363; - rayToBps[1000000009195187494725774868] = 3364; - rayToBps[1000000009197560182988723306] = 3365; - rayToBps[1000000009199932693728332556] = 3366; - rayToBps[1000000009202305026971165043] = 3367; - rayToBps[1000000009204677182743777234] = 3368; - rayToBps[1000000009207049161072719633] = 3369; - rayToBps[1000000009209420961984536788] = 3370; - rayToBps[1000000009211792585505767292] = 3371; - rayToBps[1000000009214164031662943783] = 3372; - rayToBps[1000000009216535300482592946] = 3373; - rayToBps[1000000009218906391991235515] = 3374; - rayToBps[1000000009221277306215386279] = 3375; - rayToBps[1000000009223648043181554075] = 3376; - rayToBps[1000000009226018602916241797] = 3377; - rayToBps[1000000009228388985445946397] = 3378; - rayToBps[1000000009230759190797158882] = 3379; - rayToBps[1000000009233129218996364321] = 3380; - rayToBps[1000000009235499070070041847] = 3381; - rayToBps[1000000009237868744044664652] = 3382; - rayToBps[1000000009240238240946699996] = 3383; - rayToBps[1000000009242607560802609207] = 3384; - rayToBps[1000000009244976703638847681] = 3385; - rayToBps[1000000009247345669481864883] = 3386; - rayToBps[1000000009249714458358104354] = 3387; - rayToBps[1000000009252083070294003707] = 3388; - rayToBps[1000000009254451505315994632] = 3389; - rayToBps[1000000009256819763450502896] = 3390; - rayToBps[1000000009259187844723948345] = 3391; - rayToBps[1000000009261555749162744907] = 3392; - rayToBps[1000000009263923476793300595] = 3393; - rayToBps[1000000009266291027642017505] = 3394; - rayToBps[1000000009268658401735291819] = 3395; - rayToBps[1000000009271025599099513809] = 3396; - rayToBps[1000000009273392619761067837] = 3397; - rayToBps[1000000009275759463746332356] = 3398; - rayToBps[1000000009278126131081679912] = 3399; - rayToBps[1000000009280492621793477151] = 3400; - rayToBps[1000000009282858935908084809] = 3401; - rayToBps[1000000009285225073451857728] = 3402; - rayToBps[1000000009287591034451144845] = 3403; - rayToBps[1000000009289956818932289205] = 3404; - rayToBps[1000000009292322426921627953] = 3405; - rayToBps[1000000009294687858445492342] = 3406; - rayToBps[1000000009297053113530207732] = 3407; - rayToBps[1000000009299418192202093592] = 3408; - rayToBps[1000000009301783094487463505] = 3409; - rayToBps[1000000009304147820412625165] = 3410; - rayToBps[1000000009306512370003880380] = 3411; - rayToBps[1000000009308876743287525076] = 3412; - rayToBps[1000000009311240940289849298] = 3413; - rayToBps[1000000009313604961037137210] = 3414; - rayToBps[1000000009315968805555667098] = 3415; - rayToBps[1000000009318332473871711372] = 3416; - rayToBps[1000000009320695966011536564] = 3417; - rayToBps[1000000009323059282001403339] = 3418; - rayToBps[1000000009325422421867566487] = 3419; - rayToBps[1000000009327785385636274930] = 3420; - rayToBps[1000000009330148173333771722] = 3421; - rayToBps[1000000009332510784986294051] = 3422; - rayToBps[1000000009334873220620073239] = 3423; - rayToBps[1000000009337235480261334748] = 3424; - rayToBps[1000000009339597563936298181] = 3425; - rayToBps[1000000009341959471671177278] = 3426; - rayToBps[1000000009344321203492179924] = 3427; - rayToBps[1000000009346682759425508147] = 3428; - rayToBps[1000000009349044139497358124] = 3429; - rayToBps[1000000009351405343733920179] = 3430; - rayToBps[1000000009353766372161378785] = 3431; - rayToBps[1000000009356127224805912567] = 3432; - rayToBps[1000000009358487901693694303] = 3433; - rayToBps[1000000009360848402850890927] = 3434; - rayToBps[1000000009363208728303663528] = 3435; - rayToBps[1000000009365568878078167356] = 3436; - rayToBps[1000000009367928852200551818] = 3437; - rayToBps[1000000009370288650696960487] = 3438; - rayToBps[1000000009372648273593531096] = 3439; - rayToBps[1000000009375007720916395546] = 3440; - rayToBps[1000000009377366992691679904] = 3441; - rayToBps[1000000009379726088945504406] = 3442; - rayToBps[1000000009382085009703983460] = 3443; - rayToBps[1000000009384443754993225643] = 3444; - rayToBps[1000000009386802324839333712] = 3445; - rayToBps[1000000009389160719268404592] = 3446; - rayToBps[1000000009391518938306529393] = 3447; - rayToBps[1000000009393876981979793400] = 3448; - rayToBps[1000000009396234850314276081] = 3449; - rayToBps[1000000009398592543336051086] = 3450; - rayToBps[1000000009400950061071186249] = 3451; - rayToBps[1000000009403307403545743592] = 3452; - rayToBps[1000000009405664570785779323] = 3453; - rayToBps[1000000009408021562817343841] = 3454; - rayToBps[1000000009410378379666481736] = 3455; - rayToBps[1000000009412735021359231792] = 3456; - rayToBps[1000000009415091487921626986] = 3457; - rayToBps[1000000009417447779379694494] = 3458; - rayToBps[1000000009419803895759455687] = 3459; - rayToBps[1000000009422159837086926140] = 3460; - rayToBps[1000000009424515603388115629] = 3461; - rayToBps[1000000009426871194689028130] = 3462; - rayToBps[1000000009429226611015661829] = 3463; - rayToBps[1000000009431581852394009115] = 3464; - rayToBps[1000000009433936918850056588] = 3465; - rayToBps[1000000009436291810409785058] = 3466; - rayToBps[1000000009438646527099169546] = 3467; - rayToBps[1000000009441001068944179290] = 3468; - rayToBps[1000000009443355435970777739] = 3469; - rayToBps[1000000009445709628204922563] = 3470; - rayToBps[1000000009448063645672565649] = 3471; - rayToBps[1000000009450417488399653106] = 3472; - rayToBps[1000000009452771156412125264] = 3473; - rayToBps[1000000009455124649735916678] = 3474; - rayToBps[1000000009457477968396956129] = 3475; - rayToBps[1000000009459831112421166625] = 3476; - rayToBps[1000000009462184081834465404] = 3477; - rayToBps[1000000009464536876662763935] = 3478; - rayToBps[1000000009466889496931967919] = 3479; - rayToBps[1000000009469241942667977291] = 3480; - rayToBps[1000000009471594213896686225] = 3481; - rayToBps[1000000009473946310643983128] = 3482; - rayToBps[1000000009476298232935750651] = 3483; - rayToBps[1000000009478649980797865683] = 3484; - rayToBps[1000000009481001554256199359] = 3485; - rayToBps[1000000009483352953336617058] = 3486; - rayToBps[1000000009485704178064978403] = 3487; - rayToBps[1000000009488055228467137266] = 3488; - rayToBps[1000000009490406104568941771] = 3489; - rayToBps[1000000009492756806396234293] = 3490; - rayToBps[1000000009495107333974851456] = 3491; - rayToBps[1000000009497457687330624144] = 3492; - rayToBps[1000000009499807866489377496] = 3493; - rayToBps[1000000009502157871476930909] = 3494; - rayToBps[1000000009504507702319098038] = 3495; - rayToBps[1000000009506857359041686805] = 3496; - rayToBps[1000000009509206841670499389] = 3497; - rayToBps[1000000009511556150231332239] = 3498; - rayToBps[1000000009513905284749976069] = 3499; - rayToBps[1000000009516254245252215861] = 3500; - rayToBps[1000000009518603031763830869] = 3501; - rayToBps[1000000009520951644310594617] = 3502; - rayToBps[1000000009523300082918274904] = 3503; - rayToBps[1000000009525648347612633803] = 3504; - rayToBps[1000000009527996438419427664] = 3505; - rayToBps[1000000009530344355364407118] = 3506; - rayToBps[1000000009532692098473317073] = 3507; - rayToBps[1000000009535039667771896723] = 3508; - rayToBps[1000000009537387063285879541] = 3509; - rayToBps[1000000009539734285040993291] = 3510; - rayToBps[1000000009542081333062960018] = 3511; - rayToBps[1000000009544428207377496063] = 3512; - rayToBps[1000000009546774908010312050] = 3513; - rayToBps[1000000009549121434987112901] = 3514; - rayToBps[1000000009551467788333597830] = 3515; - rayToBps[1000000009553813968075460344] = 3516; - rayToBps[1000000009556159974238388253] = 3517; - rayToBps[1000000009558505806848063661] = 3518; - rayToBps[1000000009560851465930162975] = 3519; - rayToBps[1000000009563196951510356903] = 3520; - rayToBps[1000000009565542263614310457] = 3521; - rayToBps[1000000009567887402267682959] = 3522; - rayToBps[1000000009570232367496128031] = 3523; - rayToBps[1000000009572577159325293611] = 3524; - rayToBps[1000000009574921777780821942] = 3525; - rayToBps[1000000009577266222888349586] = 3526; - rayToBps[1000000009579610494673507411] = 3527; - rayToBps[1000000009581954593161920610] = 3528; - rayToBps[1000000009584298518379208685] = 3529; - rayToBps[1000000009586642270350985464] = 3530; - rayToBps[1000000009588985849102859090] = 3531; - rayToBps[1000000009591329254660432033] = 3532; - rayToBps[1000000009593672487049301086] = 3533; - rayToBps[1000000009596015546295057365] = 3534; - rayToBps[1000000009598358432423286320] = 3535; - rayToBps[1000000009600701145459567724] = 3536; - rayToBps[1000000009603043685429475683] = 3537; - rayToBps[1000000009605386052358578639] = 3538; - rayToBps[1000000009607728246272439360] = 3539; - rayToBps[1000000009610070267196614960] = 3540; - rayToBps[1000000009612412115156656882] = 3541; - rayToBps[1000000009614753790178110915] = 3542; - rayToBps[1000000009617095292286517185] = 3543; - rayToBps[1000000009619436621507410162] = 3544; - rayToBps[1000000009621777777866318660] = 3545; - rayToBps[1000000009624118761388765837] = 3546; - rayToBps[1000000009626459572100269204] = 3547; - rayToBps[1000000009628800210026340615] = 3548; - rayToBps[1000000009631140675192486280] = 3549; - rayToBps[1000000009633480967624206760] = 3550; - rayToBps[1000000009635821087346996968] = 3551; - rayToBps[1000000009638161034386346176] = 3552; - rayToBps[1000000009640500808767738013] = 3553; - rayToBps[1000000009642840410516650466] = 3554; - rayToBps[1000000009645179839658555885] = 3555; - rayToBps[1000000009647519096218920981] = 3556; - rayToBps[1000000009649858180223206829] = 3557; - rayToBps[1000000009652197091696868873] = 3558; - rayToBps[1000000009654535830665356921] = 3559; - rayToBps[1000000009656874397154115153] = 3560; - rayToBps[1000000009659212791188582117] = 3561; - rayToBps[1000000009661551012794190737] = 3562; - rayToBps[1000000009663889061996368309] = 3563; - rayToBps[1000000009666226938820536506] = 3564; - rayToBps[1000000009668564643292111378] = 3565; - rayToBps[1000000009670902175436503355] = 3566; - rayToBps[1000000009673239535279117247] = 3567; - rayToBps[1000000009675576722845352247] = 3568; - rayToBps[1000000009677913738160601933] = 3569; - rayToBps[1000000009680250581250254266] = 3570; - rayToBps[1000000009682587252139691600] = 3571; - rayToBps[1000000009684923750854290672] = 3572; - rayToBps[1000000009687260077419422613] = 3573; - rayToBps[1000000009689596231860452947] = 3574; - rayToBps[1000000009691932214202741592] = 3575; - rayToBps[1000000009694268024471642861] = 3576; - rayToBps[1000000009696603662692505463] = 3577; - rayToBps[1000000009698939128890672509] = 3578; - rayToBps[1000000009701274423091481510] = 3579; - rayToBps[1000000009703609545320264378] = 3580; - rayToBps[1000000009705944495602347430] = 3581; - rayToBps[1000000009708279273963051388] = 3582; - rayToBps[1000000009710613880427691383] = 3583; - rayToBps[1000000009712948315021576954] = 3584; - rayToBps[1000000009715282577770012051] = 3585; - rayToBps[1000000009717616668698295034] = 3586; - rayToBps[1000000009719950587831718681] = 3587; - rayToBps[1000000009722284335195570182] = 3588; - rayToBps[1000000009724617910815131148] = 3589; - rayToBps[1000000009726951314715677603] = 3590; - rayToBps[1000000009729284546922479998] = 3591; - rayToBps[1000000009731617607460803201] = 3592; - rayToBps[1000000009733950496355906508] = 3593; - rayToBps[1000000009736283213633043637] = 3594; - rayToBps[1000000009738615759317462734] = 3595; - rayToBps[1000000009740948133434406377] = 3596; - rayToBps[1000000009743280336009111568] = 3597; - rayToBps[1000000009745612367066809747] = 3598; - rayToBps[1000000009747944226632726785] = 3599; - rayToBps[1000000009750275914732082986] = 3600; - rayToBps[1000000009752607431390093096] = 3601; - rayToBps[1000000009754938776631966296] = 3602; - rayToBps[1000000009757269950482906208] = 3603; - rayToBps[1000000009759600952968110896] = 3604; - rayToBps[1000000009761931784112772867] = 3605; - rayToBps[1000000009764262443942079074] = 3606; - rayToBps[1000000009766592932481210915] = 3607; - rayToBps[1000000009768923249755344240] = 3608; - rayToBps[1000000009771253395789649342] = 3609; - rayToBps[1000000009773583370609290973] = 3610; - rayToBps[1000000009775913174239428335] = 3611; - rayToBps[1000000009778242806705215085] = 3612; - rayToBps[1000000009780572268031799336] = 3613; - rayToBps[1000000009782901558244323661] = 3614; - rayToBps[1000000009785230677367925089] = 3615; - rayToBps[1000000009787559625427735116] = 3616; - rayToBps[1000000009789888402448879695] = 3617; - rayToBps[1000000009792217008456479248] = 3618; - rayToBps[1000000009794545443475648661] = 3619; - rayToBps[1000000009796873707531497290] = 3620; - rayToBps[1000000009799201800649128958] = 3621; - rayToBps[1000000009801529722853641960] = 3622; - rayToBps[1000000009803857474170129064] = 3623; - rayToBps[1000000009806185054623677514] = 3624; - rayToBps[1000000009808512464239369028] = 3625; - rayToBps[1000000009810839703042279800] = 3626; - rayToBps[1000000009813166771057480507] = 3627; - rayToBps[1000000009815493668310036305] = 3628; - rayToBps[1000000009817820394825006832] = 3629; - rayToBps[1000000009820146950627446211] = 3630; - rayToBps[1000000009822473335742403050] = 3631; - rayToBps[1000000009824799550194920446] = 3632; - rayToBps[1000000009827125594010035982] = 3633; - rayToBps[1000000009829451467212781736] = 3634; - rayToBps[1000000009831777169828184273] = 3635; - rayToBps[1000000009834102701881264655] = 3636; - rayToBps[1000000009836428063397038439] = 3637; - rayToBps[1000000009838753254400515679] = 3638; - rayToBps[1000000009841078274916700926] = 3639; - rayToBps[1000000009843403124970593235] = 3640; - rayToBps[1000000009845727804587186159] = 3641; - rayToBps[1000000009848052313791467756] = 3642; - rayToBps[1000000009850376652608420590] = 3643; - rayToBps[1000000009852700821063021729] = 3644; - rayToBps[1000000009855024819180242754] = 3645; - rayToBps[1000000009857348646985049751] = 3646; - rayToBps[1000000009859672304502403321] = 3647; - rayToBps[1000000009861995791757258575] = 3648; - rayToBps[1000000009864319108774565142] = 3649; - rayToBps[1000000009866642255579267166] = 3650; - rayToBps[1000000009868965232196303308] = 3651; - rayToBps[1000000009871288038650606750] = 3652; - rayToBps[1000000009873610674967105195] = 3653; - rayToBps[1000000009875933141170720867] = 3654; - rayToBps[1000000009878255437286370517] = 3655; - rayToBps[1000000009880577563338965422] = 3656; - rayToBps[1000000009882899519353411383] = 3657; - rayToBps[1000000009885221305354608733] = 3658; - rayToBps[1000000009887542921367452338] = 3659; - rayToBps[1000000009889864367416831591] = 3660; - rayToBps[1000000009892185643527630423] = 3661; - rayToBps[1000000009894506749724727299] = 3662; - rayToBps[1000000009896827686032995223] = 3663; - rayToBps[1000000009899148452477301734] = 3664; - rayToBps[1000000009901469049082508916] = 3665; - rayToBps[1000000009903789475873473393] = 3666; - rayToBps[1000000009906109732875046331] = 3667; - rayToBps[1000000009908429820112073443] = 3668; - rayToBps[1000000009910749737609394990] = 3669; - rayToBps[1000000009913069485391845778] = 3670; - rayToBps[1000000009915389063484255166] = 3671; - rayToBps[1000000009917708471911447063] = 3672; - rayToBps[1000000009920027710698239932] = 3673; - rayToBps[1000000009922346779869446790] = 3674; - rayToBps[1000000009924665679449875210] = 3675; - rayToBps[1000000009926984409464327325] = 3676; - rayToBps[1000000009929302969937599826] = 3677; - rayToBps[1000000009931621360894483965] = 3678; - rayToBps[1000000009933939582359765557] = 3679; - rayToBps[1000000009936257634358224982] = 3680; - rayToBps[1000000009938575516914637184] = 3681; - rayToBps[1000000009940893230053771678] = 3682; - rayToBps[1000000009943210773800392543] = 3683; - rayToBps[1000000009945528148179258435] = 3684; - rayToBps[1000000009947845353215122576] = 3685; - rayToBps[1000000009950162388932732765] = 3686; - rayToBps[1000000009952479255356831378] = 3687; - rayToBps[1000000009954795952512155365] = 3688; - rayToBps[1000000009957112480423436255] = 3689; - rayToBps[1000000009959428839115400159] = 3690; - rayToBps[1000000009961745028612767768] = 3691; - rayToBps[1000000009964061048940254356] = 3692; - rayToBps[1000000009966376900122569785] = 3693; - rayToBps[1000000009968692582184418500] = 3694; - rayToBps[1000000009971008095150499537] = 3695; - rayToBps[1000000009973323439045506518] = 3696; - rayToBps[1000000009975638613894127660] = 3697; - rayToBps[1000000009977953619721045772] = 3698; - rayToBps[1000000009980268456550938255] = 3699; - rayToBps[1000000009982583124408477109] = 3700; - rayToBps[1000000009984897623318328929] = 3701; - rayToBps[1000000009987211953305154911] = 3702; - rayToBps[1000000009989526114393610852] = 3703; - rayToBps[1000000009991840106608347149] = 3704; - rayToBps[1000000009994153929974008806] = 3705; - rayToBps[1000000009996467584515235430] = 3706; - rayToBps[1000000009998781070256661235] = 3707; - rayToBps[1000000010001094387222915045] = 3708; - rayToBps[1000000010003407535438620294] = 3709; - rayToBps[1000000010005720514928395027] = 3710; - rayToBps[1000000010008033325716851902] = 3711; - rayToBps[1000000010010345967828598194] = 3712; - rayToBps[1000000010012658441288235791] = 3713; - rayToBps[1000000010014970746120361202] = 3714; - rayToBps[1000000010017282882349565556] = 3715; - rayToBps[1000000010019594850000434599] = 3716; - rayToBps[1000000010021906649097548706] = 3717; - rayToBps[1000000010024218279665482869] = 3718; - rayToBps[1000000010026529741728806711] = 3719; - rayToBps[1000000010028841035312084483] = 3720; - rayToBps[1000000010031152160439875061] = 3721; - rayToBps[1000000010033463117136731955] = 3722; - rayToBps[1000000010035773905427203304] = 3723; - rayToBps[1000000010038084525335831885] = 3724; - rayToBps[1000000010040394976887155106] = 3725; - rayToBps[1000000010042705260105705014] = 3726; - rayToBps[1000000010045015375016008294] = 3727; - rayToBps[1000000010047325321642586271] = 3728; - rayToBps[1000000010049635100009954912] = 3729; - rayToBps[1000000010051944710142624825] = 3730; - rayToBps[1000000010054254152065101266] = 3731; - rayToBps[1000000010056563425801884135] = 3732; - rayToBps[1000000010058872531377467979] = 3733; - rayToBps[1000000010061181468816341997] = 3734; - rayToBps[1000000010063490238142990036] = 3735; - rayToBps[1000000010065798839381890598] = 3736; - rayToBps[1000000010068107272557516837] = 3737; - rayToBps[1000000010070415537694336563] = 3738; - rayToBps[1000000010072723634816812244] = 3739; - rayToBps[1000000010075031563949401005] = 3740; - rayToBps[1000000010077339325116554633] = 3741; - rayToBps[1000000010079646918342719577] = 3742; - rayToBps[1000000010081954343652336947] = 3743; - rayToBps[1000000010084261601069842519] = 3744; - rayToBps[1000000010086568690619666737] = 3745; - rayToBps[1000000010088875612326234711] = 3746; - rayToBps[1000000010091182366213966220] = 3747; - rayToBps[1000000010093488952307275716] = 3748; - rayToBps[1000000010095795370630572323] = 3749; - rayToBps[1000000010098101621208259840] = 3750; - rayToBps[1000000010100407704064736739] = 3751; - rayToBps[1000000010102713619224396172] = 3752; - rayToBps[1000000010105019366711625969] = 3753; - rayToBps[1000000010107324946550808639] = 3754; - rayToBps[1000000010109630358766321376] = 3755; - rayToBps[1000000010111935603382536054] = 3756; - rayToBps[1000000010114240680423819234] = 3757; - rayToBps[1000000010116545589914532164] = 3758; - rayToBps[1000000010118850331879030779] = 3759; - rayToBps[1000000010121154906341665703] = 3760; - rayToBps[1000000010123459313326782253] = 3761; - rayToBps[1000000010125763552858720438] = 3762; - rayToBps[1000000010128067624961814960] = 3763; - rayToBps[1000000010130371529660395218] = 3764; - rayToBps[1000000010132675266978785311] = 3765; - rayToBps[1000000010134978836941304031] = 3766; - rayToBps[1000000010137282239572264876] = 3767; - rayToBps[1000000010139585474895976041] = 3768; - rayToBps[1000000010141888542936740429] = 3769; - rayToBps[1000000010144191443718855647] = 3770; - rayToBps[1000000010146494177266614006] = 3771; - rayToBps[1000000010148796743604302527] = 3772; - rayToBps[1000000010151099142756202942] = 3773; - rayToBps[1000000010153401374746591692] = 3774; - rayToBps[1000000010155703439599739931] = 3775; - rayToBps[1000000010158005337339913529] = 3776; - rayToBps[1000000010160307067991373070] = 3777; - rayToBps[1000000010162608631578373856] = 3778; - rayToBps[1000000010164910028125165907] = 3779; - rayToBps[1000000010167211257655993967] = 3780; - rayToBps[1000000010169512320195097496] = 3781; - rayToBps[1000000010171813215766710684] = 3782; - rayToBps[1000000010174113944395062439] = 3783; - rayToBps[1000000010176414506104376402] = 3784; - rayToBps[1000000010178714900918870939] = 3785; - rayToBps[1000000010181015128862759145] = 3786; - rayToBps[1000000010183315189960248848] = 3787; - rayToBps[1000000010185615084235542606] = 3788; - rayToBps[1000000010187914811712837715] = 3789; - rayToBps[1000000010190214372416326204] = 3790; - rayToBps[1000000010192513766370194839] = 3791; - rayToBps[1000000010194812993598625127] = 3792; - rayToBps[1000000010197112054125793313] = 3793; - rayToBps[1000000010199410947975870385] = 3794; - rayToBps[1000000010201709675173022073] = 3795; - rayToBps[1000000010204008235741408855] = 3796; - rayToBps[1000000010206306629705185952] = 3797; - rayToBps[1000000010208604857088503334] = 3798; - rayToBps[1000000010210902917915505722] = 3799; - rayToBps[1000000010213200812210332586] = 3800; - rayToBps[1000000010215498539997118147] = 3801; - rayToBps[1000000010217796101299991387] = 3802; - rayToBps[1000000010220093496143076034] = 3803; - rayToBps[1000000010222390724550490579] = 3804; - rayToBps[1000000010224687786546348272] = 3805; - rayToBps[1000000010226984682154757119] = 3806; - rayToBps[1000000010229281411399819892] = 3807; - rayToBps[1000000010231577974305634122] = 3808; - rayToBps[1000000010233874370896292108] = 3809; - rayToBps[1000000010236170601195880913] = 3810; - rayToBps[1000000010238466665228482369] = 3811; - rayToBps[1000000010240762563018173077] = 3812; - rayToBps[1000000010243058294589024407] = 3813; - rayToBps[1000000010245353859965102504] = 3814; - rayToBps[1000000010247649259170468285] = 3815; - rayToBps[1000000010249944492229177442] = 3816; - rayToBps[1000000010252239559165280445] = 3817; - rayToBps[1000000010254534460002822540] = 3818; - rayToBps[1000000010256829194765843755] = 3819; - rayToBps[1000000010259123763478378900] = 3820; - rayToBps[1000000010261418166164457564] = 3821; - rayToBps[1000000010263712402848104124] = 3822; - rayToBps[1000000010266006473553337741] = 3823; - rayToBps[1000000010268300378304172365] = 3824; - rayToBps[1000000010270594117124616733] = 3825; - rayToBps[1000000010272887690038674371] = 3826; - rayToBps[1000000010275181097070343602] = 3827; - rayToBps[1000000010277474338243617536] = 3828; - rayToBps[1000000010279767413582484084] = 3829; - rayToBps[1000000010282060323110925948] = 3830; - rayToBps[1000000010284353066852920632] = 3831; - rayToBps[1000000010286645644832440436] = 3832; - rayToBps[1000000010288938057073452464] = 3833; - rayToBps[1000000010291230303599918619] = 3834; - rayToBps[1000000010293522384435795611] = 3835; - rayToBps[1000000010295814299605034955] = 3836; - rayToBps[1000000010298106049131582970] = 3837; - rayToBps[1000000010300397633039380787] = 3838; - rayToBps[1000000010302689051352364343] = 3839; - rayToBps[1000000010304980304094464392] = 3840; - rayToBps[1000000010307271391289606494] = 3841; - rayToBps[1000000010309562312961711031] = 3842; - rayToBps[1000000010311853069134693193] = 3843; - rayToBps[1000000010314143659832462993] = 3844; - rayToBps[1000000010316434085078925260] = 3845; - rayToBps[1000000010318724344897979646] = 3846; - rayToBps[1000000010321014439313520622] = 3847; - rayToBps[1000000010323304368349437485] = 3848; - rayToBps[1000000010325594132029614354] = 3849; - rayToBps[1000000010327883730377930177] = 3850; - rayToBps[1000000010330173163418258729] = 3851; - rayToBps[1000000010332462431174468613] = 3852; - rayToBps[1000000010334751533670423264] = 3853; - rayToBps[1000000010337040470929980950] = 3854; - rayToBps[1000000010339329242976994772] = 3855; - rayToBps[1000000010341617849835312667] = 3856; - rayToBps[1000000010343906291528777406] = 3857; - rayToBps[1000000010346194568081226603] = 3858; - rayToBps[1000000010348482679516492707] = 3859; - rayToBps[1000000010350770625858403013] = 3860; - rayToBps[1000000010353058407130779655] = 3861; - rayToBps[1000000010355346023357439613] = 3862; - rayToBps[1000000010357633474562194712] = 3863; - rayToBps[1000000010359920760768851624] = 3864; - rayToBps[1000000010362207882001211872] = 3865; - rayToBps[1000000010364494838283071825] = 3866; - rayToBps[1000000010366781629638222707] = 3867; - rayToBps[1000000010369068256090450597] = 3868; - rayToBps[1000000010371354717663536422] = 3869; - rayToBps[1000000010373641014381255972] = 3870; - rayToBps[1000000010375927146267379890] = 3871; - rayToBps[1000000010378213113345673681] = 3872; - rayToBps[1000000010380498915639897708] = 3873; - rayToBps[1000000010382784553173807199] = 3874; - rayToBps[1000000010385070025971152244] = 3875; - rayToBps[1000000010387355334055677797] = 3876; - rayToBps[1000000010389640477451123680] = 3877; - rayToBps[1000000010391925456181224583] = 3878; - rayToBps[1000000010394210270269710063] = 3879; - rayToBps[1000000010396494919740304554] = 3880; - rayToBps[1000000010398779404616727355] = 3881; - rayToBps[1000000010401063724922692643] = 3882; - rayToBps[1000000010403347880681909471] = 3883; - rayToBps[1000000010405631871918081767] = 3884; - rayToBps[1000000010407915698654908337] = 3885; - rayToBps[1000000010410199360916082867] = 3886; - rayToBps[1000000010412482858725293929] = 3887; - rayToBps[1000000010414766192106224969] = 3888; - rayToBps[1000000010417049361082554324] = 3889; - rayToBps[1000000010419332365677955216] = 3890; - rayToBps[1000000010421615205916095750] = 3891; - rayToBps[1000000010423897881820638924] = 3892; - rayToBps[1000000010426180393415242626] = 3893; - rayToBps[1000000010428462740723559632] = 3894; - rayToBps[1000000010430744923769237614] = 3895; - rayToBps[1000000010433026942575919138] = 3896; - rayToBps[1000000010435308797167241666] = 3897; - rayToBps[1000000010437590487566837557] = 3898; - rayToBps[1000000010439872013798334068] = 3899; - rayToBps[1000000010442153375885353361] = 3900; - rayToBps[1000000010444434573851512493] = 3901; - rayToBps[1000000010446715607720423430] = 3902; - rayToBps[1000000010448996477515693040] = 3903; - rayToBps[1000000010451277183260923098] = 3904; - rayToBps[1000000010453557724979710285] = 3905; - rayToBps[1000000010455838102695646196] = 3906; - rayToBps[1000000010458118316432317331] = 3907; - rayToBps[1000000010460398366213305107] = 3908; - rayToBps[1000000010462678252062185850] = 3909; - rayToBps[1000000010464957974002530804] = 3910; - rayToBps[1000000010467237532057906130] = 3911; - rayToBps[1000000010469516926251872906] = 3912; - rayToBps[1000000010471796156607987127] = 3913; - rayToBps[1000000010474075223149799712] = 3914; - rayToBps[1000000010476354125900856503] = 3915; - rayToBps[1000000010478632864884698262] = 3916; - rayToBps[1000000010480911440124860682] = 3917; - rayToBps[1000000010483189851644874376] = 3918; - rayToBps[1000000010485468099468264892] = 3919; - rayToBps[1000000010487746183618552701] = 3920; - rayToBps[1000000010490024104119253210] = 3921; - rayToBps[1000000010492301860993876758] = 3922; - rayToBps[1000000010494579454265928614] = 3923; - rayToBps[1000000010496856883958908988] = 3924; - rayToBps[1000000010499134150096313024] = 3925; - rayToBps[1000000010501411252701630804] = 3926; - rayToBps[1000000010503688191798347350] = 3927; - rayToBps[1000000010505964967409942629] = 3928; - rayToBps[1000000010508241579559891545] = 3929; - rayToBps[1000000010510518028271663949] = 3930; - rayToBps[1000000010512794313568724638] = 3931; - rayToBps[1000000010515070435474533356] = 3932; - rayToBps[1000000010517346394012544796] = 3933; - rayToBps[1000000010519622189206208597] = 3934; - rayToBps[1000000010521897821078969357] = 3935; - rayToBps[1000000010524173289654266619] = 3936; - rayToBps[1000000010526448594955534886] = 3937; - rayToBps[1000000010528723737006203614] = 3938; - rayToBps[1000000010530998715829697217] = 3939; - rayToBps[1000000010533273531449435067] = 3940; - rayToBps[1000000010535548183888831498] = 3941; - rayToBps[1000000010537822673171295805] = 3942; - rayToBps[1000000010540096999320232244] = 3943; - rayToBps[1000000010542371162359040036] = 3944; - rayToBps[1000000010544645162311113372] = 3945; - rayToBps[1000000010546918999199841404] = 3946; - rayToBps[1000000010549192673048608259] = 3947; - rayToBps[1000000010551466183880793029] = 3948; - rayToBps[1000000010553739531719769780] = 3949; - rayToBps[1000000010556012716588907553] = 3950; - rayToBps[1000000010558285738511570360] = 3951; - rayToBps[1000000010560558597511117192] = 3952; - rayToBps[1000000010562831293610902015] = 3953; - rayToBps[1000000010565103826834273775] = 3954; - rayToBps[1000000010567376197204576401] = 3955; - rayToBps[1000000010569648404745148797] = 3956; - rayToBps[1000000010571920449479324858] = 3957; - rayToBps[1000000010574192331430433458] = 3958; - rayToBps[1000000010576464050621798460] = 3959; - rayToBps[1000000010578735607076738714] = 3960; - rayToBps[1000000010581007000818568058] = 3961; - rayToBps[1000000010583278231870595322] = 3962; - rayToBps[1000000010585549300256124326] = 3963; - rayToBps[1000000010587820205998453884] = 3964; - rayToBps[1000000010590090949120877806] = 3965; - rayToBps[1000000010592361529646684896] = 3966; - rayToBps[1000000010594631947599158957] = 3967; - rayToBps[1000000010596902203001578791] = 3968; - rayToBps[1000000010599172295877218198] = 3969; - rayToBps[1000000010601442226249345986] = 3970; - rayToBps[1000000010603711994141225957] = 3971; - rayToBps[1000000010605981599576116928] = 3972; - rayToBps[1000000010608251042577272714] = 3973; - rayToBps[1000000010610520323167942140] = 3974; - rayToBps[1000000010612789441371369043] = 3975; - rayToBps[1000000010615058397210792268] = 3976; - rayToBps[1000000010617327190709445671] = 3977; - rayToBps[1000000010619595821890558121] = 3978; - rayToBps[1000000010621864290777353506] = 3979; - rayToBps[1000000010624132597393050726] = 3980; - rayToBps[1000000010626400741760863700] = 3981; - rayToBps[1000000010628668723904001364] = 3982; - rayToBps[1000000010630936543845667679] = 3983; - rayToBps[1000000010633204201609061622] = 3984; - rayToBps[1000000010635471697217377200] = 3985; - rayToBps[1000000010637739030693803438] = 3986; - rayToBps[1000000010640006202061524391] = 3987; - rayToBps[1000000010642273211343719142] = 3988; - rayToBps[1000000010644540058563561801] = 3989; - rayToBps[1000000010646806743744221508] = 3990; - rayToBps[1000000010649073266908862437] = 3991; - rayToBps[1000000010651339628080643794] = 3992; - rayToBps[1000000010653605827282719820] = 3993; - rayToBps[1000000010655871864538239791] = 3994; - rayToBps[1000000010658137739870348023] = 3995; - rayToBps[1000000010660403453302183867] = 3996; - rayToBps[1000000010662669004856881719] = 3997; - rayToBps[1000000010664934394557571013] = 3998; - rayToBps[1000000010667199622427376228] = 3999; - rayToBps[1000000010669464688489416886] = 4000; - rayToBps[1000000010671729592766807558] = 4001; - rayToBps[1000000010673994335282657858] = 4002; - rayToBps[1000000010676258916060072453] = 4003; - rayToBps[1000000010678523335122151059] = 4004; - rayToBps[1000000010680787592491988442] = 4005; - rayToBps[1000000010683051688192674423] = 4006; - rayToBps[1000000010685315622247293876] = 4007; - rayToBps[1000000010687579394678926732] = 4008; - rayToBps[1000000010689843005510647981] = 4009; - rayToBps[1000000010692106454765527665] = 4010; - rayToBps[1000000010694369742466630895] = 4011; - rayToBps[1000000010696632868637017837] = 4012; - rayToBps[1000000010698895833299743723] = 4013; - rayToBps[1000000010701158636477858849] = 4014; - rayToBps[1000000010703421278194408576] = 4015; - rayToBps[1000000010705683758472433332] = 4016; - rayToBps[1000000010707946077334968615] = 4017; - rayToBps[1000000010710208234805044991] = 4018; - rayToBps[1000000010712470230905688100] = 4019; - rayToBps[1000000010714732065659918652] = 4020; - rayToBps[1000000010716993739090752433] = 4021; - rayToBps[1000000010719255251221200304] = 4022; - rayToBps[1000000010721516602074268204] = 4023; - rayToBps[1000000010723777791672957148] = 4024; - rayToBps[1000000010726038820040263233] = 4025; - rayToBps[1000000010728299687199177636] = 4026; - rayToBps[1000000010730560393172686618] = 4027; - rayToBps[1000000010732820937983771524] = 4028; - rayToBps[1000000010735081321655408782] = 4029; - rayToBps[1000000010737341544210569909] = 4030; - rayToBps[1000000010739601605672221510] = 4031; - rayToBps[1000000010741861506063325280] = 4032; - rayToBps[1000000010744121245406838002] = 4033; - rayToBps[1000000010746380823725711557] = 4034; - rayToBps[1000000010748640241042892914] = 4035; - rayToBps[1000000010750899497381324142] = 4036; - rayToBps[1000000010753158592763942403] = 4037; - rayToBps[1000000010755417527213679959] = 4038; - rayToBps[1000000010757676300753464170] = 4039; - rayToBps[1000000010759934913406217501] = 4040; - rayToBps[1000000010762193365194857512] = 4041; - rayToBps[1000000010764451656142296872] = 4042; - rayToBps[1000000010766709786271443355] = 4043; - rayToBps[1000000010768967755605199839] = 4044; - rayToBps[1000000010771225564166464310] = 4045; - rayToBps[1000000010773483211978129865] = 4046; - rayToBps[1000000010775740699063084710] = 4047; - rayToBps[1000000010777998025444212163] = 4048; - rayToBps[1000000010780255191144390658] = 4049; - rayToBps[1000000010782512196186493739] = 4050; - rayToBps[1000000010784769040593390070] = 4051; - rayToBps[1000000010787025724387943431] = 4052; - rayToBps[1000000010789282247593012723] = 4053; - rayToBps[1000000010791538610231451963] = 4054; - rayToBps[1000000010793794812326110293] = 4055; - rayToBps[1000000010796050853899831977] = 4056; - rayToBps[1000000010798306734975456405] = 4057; - rayToBps[1000000010800562455575818091] = 4058; - rayToBps[1000000010802818015723746677] = 4059; - rayToBps[1000000010805073415442066933] = 4060; - rayToBps[1000000010807328654753598760] = 4061; - rayToBps[1000000010809583733681157190] = 4062; - rayToBps[1000000010811838652247552387] = 4063; - rayToBps[1000000010814093410475589652] = 4064; - rayToBps[1000000010816348008388069418] = 4065; - rayToBps[1000000010818602446007787257] = 4066; - rayToBps[1000000010820856723357533878] = 4067; - rayToBps[1000000010823110840460095130] = 4068; - rayToBps[1000000010825364797338252005] = 4069; - rayToBps[1000000010827618594014780637] = 4070; - rayToBps[1000000010829872230512452300] = 4071; - rayToBps[1000000010832125706854033418] = 4072; - rayToBps[1000000010834379023062285559] = 4073; - rayToBps[1000000010836632179159965442] = 4074; - rayToBps[1000000010838885175169824929] = 4075; - rayToBps[1000000010841138011114611041] = 4076; - rayToBps[1000000010843390687017065944] = 4077; - rayToBps[1000000010845643202899926963] = 4078; - rayToBps[1000000010847895558785926572] = 4079; - rayToBps[1000000010850147754697792408] = 4080; - rayToBps[1000000010852399790658247262] = 4081; - rayToBps[1000000010854651666690009082] = 4082; - rayToBps[1000000010856903382815790981] = 4083; - rayToBps[1000000010859154939058301230] = 4084; - rayToBps[1000000010861406335440243265] = 4085; - rayToBps[1000000010863657571984315686] = 4086; - rayToBps[1000000010865908648713212260] = 4087; - rayToBps[1000000010868159565649621919] = 4088; - rayToBps[1000000010870410322816228766] = 4089; - rayToBps[1000000010872660920235712071] = 4090; - rayToBps[1000000010874911357930746279] = 4091; - rayToBps[1000000010877161635924001006] = 4092; - rayToBps[1000000010879411754238141040] = 4093; - rayToBps[1000000010881661712895826350] = 4094; - rayToBps[1000000010883911511919712075] = 4095; - rayToBps[1000000010886161151332448538] = 4096; - rayToBps[1000000010888410631156681239] = 4097; - rayToBps[1000000010890659951415050857] = 4098; - rayToBps[1000000010892909112130193257] = 4099; - rayToBps[1000000010895158113324739488] = 4100; - rayToBps[1000000010897406955021315779] = 4101; - rayToBps[1000000010899655637242543550] = 4102; - rayToBps[1000000010901904160011039408] = 4103; - rayToBps[1000000010904152523349415148] = 4104; - rayToBps[1000000010906400727280277756] = 4105; - rayToBps[1000000010908648771826229410] = 4106; - rayToBps[1000000010910896657009867483] = 4107; - rayToBps[1000000010913144382853784538] = 4108; - rayToBps[1000000010915391949380568338] = 4109; - rayToBps[1000000010917639356612801842] = 4110; - rayToBps[1000000010919886604573063209] = 4111; - rayToBps[1000000010922133693283925795] = 4112; - rayToBps[1000000010924380622767958161] = 4113; - rayToBps[1000000010926627393047724068] = 4114; - rayToBps[1000000010928874004145782483] = 4115; - rayToBps[1000000010931120456084687576] = 4116; - rayToBps[1000000010933366748886988728] = 4117; - rayToBps[1000000010935612882575230523] = 4118; - rayToBps[1000000010937858857171952760] = 4119; - rayToBps[1000000010940104672699690444] = 4120; - rayToBps[1000000010942350329180973795] = 4121; - rayToBps[1000000010944595826638328248] = 4122; - rayToBps[1000000010946841165094274449] = 4123; - rayToBps[1000000010949086344571328262] = 4124; - rayToBps[1000000010951331365092000772] = 4125; - rayToBps[1000000010953576226678798278] = 4126; - rayToBps[1000000010955820929354222302] = 4127; - rayToBps[1000000010958065473140769588] = 4128; - rayToBps[1000000010960309858060932102] = 4129; - rayToBps[1000000010962554084137197035] = 4130; - rayToBps[1000000010964798151392046803] = 4131; - rayToBps[1000000010967042059847959052] = 4132; - rayToBps[1000000010969285809527406653] = 4133; - rayToBps[1000000010971529400452857709] = 4134; - rayToBps[1000000010973772832646775552] = 4135; - rayToBps[1000000010976016106131618751] = 4136; - rayToBps[1000000010978259220929841103] = 4137; - rayToBps[1000000010980502177063891645] = 4138; - rayToBps[1000000010982744974556214650] = 4139; - rayToBps[1000000010984987613429249625] = 4140; - rayToBps[1000000010987230093705431322] = 4141; - rayToBps[1000000010989472415407189730] = 4142; - rayToBps[1000000010991714578556950080] = 4143; - rayToBps[1000000010993956583177132848] = 4144; - rayToBps[1000000010996198429290153754] = 4145; - rayToBps[1000000010998440116918423764] = 4146; - rayToBps[1000000011000681646084349091] = 4147; - rayToBps[1000000011002923016810331196] = 4148; - rayToBps[1000000011005164229118766794] = 4149; - rayToBps[1000000011007405283032047846] = 4150; - rayToBps[1000000011009646178572561570] = 4151; - rayToBps[1000000011011886915762690435] = 4152; - rayToBps[1000000011014127494624812168] = 4153; - rayToBps[1000000011016367915181299751] = 4154; - rayToBps[1000000011018608177454521425] = 4155; - rayToBps[1000000011020848281466840690] = 4156; - rayToBps[1000000011023088227240616307] = 4157; - rayToBps[1000000011025328014798202299] = 4158; - rayToBps[1000000011027567644161947953] = 4159; - rayToBps[1000000011029807115354197820] = 4160; - rayToBps[1000000011032046428397291718] = 4161; - rayToBps[1000000011034285583313564733] = 4162; - rayToBps[1000000011036524580125347217] = 4163; - rayToBps[1000000011038763418854964795] = 4164; - rayToBps[1000000011041002099524738363] = 4165; - rayToBps[1000000011043240622156984088] = 4166; - rayToBps[1000000011045478986774013414] = 4167; - rayToBps[1000000011047717193398133058] = 4168; - rayToBps[1000000011049955242051645015] = 4169; - rayToBps[1000000011052193132756846559] = 4170; - rayToBps[1000000011054430865536030243] = 4171; - rayToBps[1000000011056668440411483899] = 4172; - rayToBps[1000000011058905857405490642] = 4173; - rayToBps[1000000011061143116540328874] = 4174; - rayToBps[1000000011063380217838272275] = 4175; - rayToBps[1000000011065617161321589818] = 4176; - rayToBps[1000000011067853947012545760] = 4177; - rayToBps[1000000011070090574933399646] = 4178; - rayToBps[1000000011072327045106406314] = 4179; - rayToBps[1000000011074563357553815892] = 4180; - rayToBps[1000000011076799512297873799] = 4181; - rayToBps[1000000011079035509360820752] = 4182; - rayToBps[1000000011081271348764892760] = 4183; - rayToBps[1000000011083507030532321133] = 4184; - rayToBps[1000000011085742554685332472] = 4185; - rayToBps[1000000011087977921246148683] = 4186; - rayToBps[1000000011090213130236986974] = 4187; - rayToBps[1000000011092448181680059850] = 4188; - rayToBps[1000000011094683075597575122] = 4189; - rayToBps[1000000011096917812011735908] = 4190; - rayToBps[1000000011099152390944740628] = 4191; - rayToBps[1000000011101386812418783011] = 4192; - rayToBps[1000000011103621076456052096] = 4193; - rayToBps[1000000011105855183078732230] = 4194; - rayToBps[1000000011108089132309003072] = 4195; - rayToBps[1000000011110322924169039595] = 4196; - rayToBps[1000000011112556558681012085] = 4197; - rayToBps[1000000011114790035867086142] = 4198; - rayToBps[1000000011117023355749422684] = 4199; - rayToBps[1000000011119256518350177948] = 4200; - rayToBps[1000000011121489523691503488] = 4201; - rayToBps[1000000011123722371795546180] = 4202; - rayToBps[1000000011125955062684448222] = 4203; - rayToBps[1000000011128187596380347134] = 4204; - rayToBps[1000000011130419972905375761] = 4205; - rayToBps[1000000011132652192281662277] = 4206; - rayToBps[1000000011134884254531330177] = 4207; - rayToBps[1000000011137116159676498289] = 4208; - rayToBps[1000000011139347907739280771] = 4209; - rayToBps[1000000011141579498741787109] = 4210; - rayToBps[1000000011143810932706122123] = 4211; - rayToBps[1000000011146042209654385969] = 4212; - rayToBps[1000000011148273329608674134] = 4213; - rayToBps[1000000011150504292591077445] = 4214; - rayToBps[1000000011152735098623682064] = 4215; - rayToBps[1000000011154965747728569493] = 4216; - rayToBps[1000000011157196239927816576] = 4217; - rayToBps[1000000011159426575243495495] = 4218; - rayToBps[1000000011161656753697673778] = 4219; - rayToBps[1000000011163886775312414296] = 4220; - rayToBps[1000000011166116640109775265] = 4221; - rayToBps[1000000011168346348111810249] = 4222; - rayToBps[1000000011170575899340568161] = 4223; - rayToBps[1000000011172805293818093260] = 4224; - rayToBps[1000000011175034531566425160] = 4225; - rayToBps[1000000011177263612607598825] = 4226; - rayToBps[1000000011179492536963644571] = 4227; - rayToBps[1000000011181721304656588071] = 4228; - rayToBps[1000000011183949915708450354] = 4229; - rayToBps[1000000011186178370141247803] = 4230; - rayToBps[1000000011188406667976992166] = 4231; - rayToBps[1000000011190634809237690543] = 4232; - rayToBps[1000000011192862793945345402] = 4233; - rayToBps[1000000011195090622121954571] = 4234; - rayToBps[1000000011197318293789511240] = 4235; - rayToBps[1000000011199545808970003967] = 4236; - rayToBps[1000000011201773167685416674] = 4237; - rayToBps[1000000011204000369957728654] = 4238; - rayToBps[1000000011206227415808914565] = 4239; - rayToBps[1000000011208454305260944438] = 4240; - rayToBps[1000000011210681038335783676] = 4241; - rayToBps[1000000011212907615055393052] = 4242; - rayToBps[1000000011215134035441728718] = 4243; - rayToBps[1000000011217360299516742197] = 4244; - rayToBps[1000000011219586407302380389] = 4245; - rayToBps[1000000011221812358820585577] = 4246; - rayToBps[1000000011224038154093295418] = 4247; - rayToBps[1000000011226263793142442953] = 4248; - rayToBps[1000000011228489275989956604] = 4249; - rayToBps[1000000011230714602657760176] = 4250; - rayToBps[1000000011232939773167772858] = 4251; - rayToBps[1000000011235164787541909226] = 4252; - rayToBps[1000000011237389645802079244] = 4253; - rayToBps[1000000011239614347970188264] = 4254; - rayToBps[1000000011241838894068137026] = 4255; - rayToBps[1000000011244063284117821662] = 4256; - rayToBps[1000000011246287518141133699] = 4257; - rayToBps[1000000011248511596159960053] = 4258; - rayToBps[1000000011250735518196183039] = 4259; - rayToBps[1000000011252959284271680367] = 4260; - rayToBps[1000000011255182894408325144] = 4261; - rayToBps[1000000011257406348627985874] = 4262; - rayToBps[1000000011259629646952526467] = 4263; - rayToBps[1000000011261852789403806228] = 4264; - rayToBps[1000000011264075776003679869] = 4265; - rayToBps[1000000011266298606773997503] = 4266; - rayToBps[1000000011268521281736604652] = 4267; - rayToBps[1000000011270743800913342239] = 4268; - rayToBps[1000000011272966164326046602] = 4269; - rayToBps[1000000011275188371996549481] = 4270; - rayToBps[1000000011277410423946678031] = 4271; - rayToBps[1000000011279632320198254820] = 4272; - rayToBps[1000000011281854060773097822] = 4273; - rayToBps[1000000011284075645693020433] = 4274; - rayToBps[1000000011286297074979831462] = 4275; - rayToBps[1000000011288518348655335131] = 4276; - rayToBps[1000000011290739466741331087] = 4277; - rayToBps[1000000011292960429259614390] = 4278; - rayToBps[1000000011295181236231975526] = 4279; - rayToBps[1000000011297401887680200399] = 4280; - rayToBps[1000000011299622383626070339] = 4281; - rayToBps[1000000011301842724091362099] = 4282; - rayToBps[1000000011304062909097847859] = 4283; - rayToBps[1000000011306282938667295224] = 4284; - rayToBps[1000000011308502812821467231] = 4285; - rayToBps[1000000011310722531582122343] = 4286; - rayToBps[1000000011312942094971014457] = 4287; - rayToBps[1000000011315161503009892899] = 4288; - rayToBps[1000000011317380755720502432] = 4289; - rayToBps[1000000011319599853124583251] = 4290; - rayToBps[1000000011321818795243870989] = 4291; - rayToBps[1000000011324037582100096715] = 4292; - rayToBps[1000000011326256213714986939] = 4293; - rayToBps[1000000011328474690110263606] = 4294; - rayToBps[1000000011330693011307644108] = 4295; - rayToBps[1000000011332911177328841276] = 4296; - rayToBps[1000000011335129188195563387] = 4297; - rayToBps[1000000011337347043929514159] = 4298; - rayToBps[1000000011339564744552392760] = 4299; - rayToBps[1000000011341782290085893805] = 4300; - rayToBps[1000000011343999680551707357] = 4301; - rayToBps[1000000011346216915971518931] = 4302; - rayToBps[1000000011348433996367009488] = 4303; - rayToBps[1000000011350650921759855449] = 4304; - rayToBps[1000000011352867692171728685] = 4305; - rayToBps[1000000011355084307624296520] = 4306; - rayToBps[1000000011357300768139221740] = 4307; - rayToBps[1000000011359517073738162585] = 4308; - rayToBps[1000000011361733224442772754] = 4309; - rayToBps[1000000011363949220274701408] = 4310; - rayToBps[1000000011366165061255593168] = 4311; - rayToBps[1000000011368380747407088120] = 4312; - rayToBps[1000000011370596278750821810] = 4313; - rayToBps[1000000011372811655308425254] = 4314; - rayToBps[1000000011375026877101524932] = 4315; - rayToBps[1000000011377241944151742792] = 4316; - rayToBps[1000000011379456856480696254] = 4317; - rayToBps[1000000011381671614109998202] = 4318; - rayToBps[1000000011383886217061256998] = 4319; - rayToBps[1000000011386100665356076475] = 4320; - rayToBps[1000000011388314959016055939] = 4321; - rayToBps[1000000011390529098062790173] = 4322; - rayToBps[1000000011392743082517869435] = 4323; - rayToBps[1000000011394956912402879463] = 4324; - rayToBps[1000000011397170587739401474] = 4325; - rayToBps[1000000011399384108549012164] = 4326; - rayToBps[1000000011401597474853283711] = 4327; - rayToBps[1000000011403810686673783778] = 4328; - rayToBps[1000000011406023744032075511] = 4329; - rayToBps[1000000011408236646949717541] = 4330; - rayToBps[1000000011410449395448263986] = 4331; - rayToBps[1000000011412661989549264455] = 4332; - rayToBps[1000000011414874429274264041] = 4333; - rayToBps[1000000011417086714644803332] = 4334; - rayToBps[1000000011419298845682418407] = 4335; - rayToBps[1000000011421510822408640836] = 4336; - rayToBps[1000000011423722644844997686] = 4337; - rayToBps[1000000011425934313013011518] = 4338; - rayToBps[1000000011428145826934200391] = 4339; - rayToBps[1000000011430357186630077862] = 4340; - rayToBps[1000000011432568392122152986] = 4341; - rayToBps[1000000011434779443431930319] = 4342; - rayToBps[1000000011436990340580909922] = 4343; - rayToBps[1000000011439201083590587356] = 4344; - rayToBps[1000000011441411672482453687] = 4345; - rayToBps[1000000011443622107277995486] = 4346; - rayToBps[1000000011445832387998694833] = 4347; - rayToBps[1000000011448042514666029315] = 4348; - rayToBps[1000000011450252487301472028] = 4349; - rayToBps[1000000011452462305926491579] = 4350; - rayToBps[1000000011454671970562552089] = 4351; - rayToBps[1000000011456881481231113188] = 4352; - rayToBps[1000000011459090837953630024] = 4353; - rayToBps[1000000011461300040751553259] = 4354; - rayToBps[1000000011463509089646329073] = 4355; - rayToBps[1000000011465717984659399163] = 4356; - rayToBps[1000000011467926725812200747] = 4357; - rayToBps[1000000011470135313126166561] = 4358; - rayToBps[1000000011472343746622724867] = 4359; - rayToBps[1000000011474552026323299446] = 4360; - rayToBps[1000000011476760152249309607] = 4361; - rayToBps[1000000011478968124422170181] = 4362; - rayToBps[1000000011481175942863291530] = 4363; - rayToBps[1000000011483383607594079540] = 4364; - rayToBps[1000000011485591118635935631] = 4365; - rayToBps[1000000011487798476010256750] = 4366; - rayToBps[1000000011490005679738435376] = 4367; - rayToBps[1000000011492212729841859524] = 4368; - rayToBps[1000000011494419626341912740] = 4369; - rayToBps[1000000011496626369259974109] = 4370; - rayToBps[1000000011498832958617418250] = 4371; - rayToBps[1000000011501039394435615322] = 4372; - rayToBps[1000000011503245676735931022] = 4373; - rayToBps[1000000011505451805539726589] = 4374; - rayToBps[1000000011507657780868358802] = 4375; - rayToBps[1000000011509863602743179986] = 4376; - rayToBps[1000000011512069271185538006] = 4377; - rayToBps[1000000011514274786216776278] = 4378; - rayToBps[1000000011516480147858233760] = 4379; - rayToBps[1000000011518685356131244960] = 4380; - rayToBps[1000000011520890411057139937] = 4381; - rayToBps[1000000011523095312657244296] = 4382; - rayToBps[1000000011525300060952879198] = 4383; - rayToBps[1000000011527504655965361356] = 4384; - rayToBps[1000000011529709097716003036] = 4385; - rayToBps[1000000011531913386226112060] = 4386; - rayToBps[1000000011534117521516991808] = 4387; - rayToBps[1000000011536321503609941215] = 4388; - rayToBps[1000000011538525332526254779] = 4389; - rayToBps[1000000011540729008287222556] = 4390; - rayToBps[1000000011542932530914130163] = 4391; - rayToBps[1000000011545135900428258782] = 4392; - rayToBps[1000000011547339116850885159] = 4393; - rayToBps[1000000011549542180203281602] = 4394; - rayToBps[1000000011551745090506715989] = 4395; - rayToBps[1000000011553947847782451765] = 4396; - rayToBps[1000000011556150452051747944] = 4397; - rayToBps[1000000011558352903335859111] = 4398; - rayToBps[1000000011560555201656035419] = 4399; - rayToBps[1000000011562757347033522598] = 4400; - rayToBps[1000000011564959339489561951] = 4401; - rayToBps[1000000011567161179045390355] = 4402; - rayToBps[1000000011569362865722240263] = 4403; - rayToBps[1000000011571564399541339706] = 4404; - rayToBps[1000000011573765780523912298] = 4405; - rayToBps[1000000011575967008691177226] = 4406; - rayToBps[1000000011578168084064349263] = 4407; - rayToBps[1000000011580369006664638762] = 4408; - rayToBps[1000000011582569776513251664] = 4409; - rayToBps[1000000011584770393631389491] = 4410; - rayToBps[1000000011586970858040249351] = 4411; - rayToBps[1000000011589171169761023944] = 4412; - rayToBps[1000000011591371328814901553] = 4413; - rayToBps[1000000011593571335223066054] = 4414; - rayToBps[1000000011595771189006696913] = 4415; - rayToBps[1000000011597970890186969190] = 4416; - rayToBps[1000000011600170438785053539] = 4417; - rayToBps[1000000011602369834822116205] = 4418; - rayToBps[1000000011604569078319319032] = 4419; - rayToBps[1000000011606768169297819461] = 4420; - rayToBps[1000000011608967107778770531] = 4421; - rayToBps[1000000011611165893783320880] = 4422; - rayToBps[1000000011613364527332614750] = 4423; - rayToBps[1000000011615563008447791980] = 4424; - rayToBps[1000000011617761337149988016] = 4425; - rayToBps[1000000011619959513460333909] = 4426; - rayToBps[1000000011622157537399956313] = 4427; - rayToBps[1000000011624355408989977491] = 4428; - rayToBps[1000000011626553128251515315] = 4429; - rayToBps[1000000011628750695205683263] = 4430; - rayToBps[1000000011630948109873590427] = 4431; - rayToBps[1000000011633145372276341510] = 4432; - rayToBps[1000000011635342482435036828] = 4433; - rayToBps[1000000011637539440370772309] = 4434; - rayToBps[1000000011639736246104639501] = 4435; - rayToBps[1000000011641932899657725566] = 4436; - rayToBps[1000000011644129401051113283] = 4437; - rayToBps[1000000011646325750305881052] = 4438; - rayToBps[1000000011648521947443102894] = 4439; - rayToBps[1000000011650717992483848450] = 4440; - rayToBps[1000000011652913885449182982] = 4441; - rayToBps[1000000011655109626360167380] = 4442; - rayToBps[1000000011657305215237858159] = 4443; - rayToBps[1000000011659500652103307456] = 4444; - rayToBps[1000000011661695936977563040] = 4445; - rayToBps[1000000011663891069881668309] = 4446; - rayToBps[1000000011666086050836662286] = 4447; - rayToBps[1000000011668280879863579631] = 4448; - rayToBps[1000000011670475556983450634] = 4449; - rayToBps[1000000011672670082217301219] = 4450; - rayToBps[1000000011674864455586152944] = 4451; - rayToBps[1000000011677058677111023005] = 4452; - rayToBps[1000000011679252746812924234] = 4453; - rayToBps[1000000011681446664712865102] = 4454; - rayToBps[1000000011683640430831849720] = 4455; - rayToBps[1000000011685834045190877838] = 4456; - rayToBps[1000000011688027507810944851] = 4457; - rayToBps[1000000011690220818713041795] = 4458; - rayToBps[1000000011692413977918155352] = 4459; - rayToBps[1000000011694606985447267850] = 4460; - rayToBps[1000000011696799841321357263] = 4461; - rayToBps[1000000011698992545561397213] = 4462; - rayToBps[1000000011701185098188356972] = 4463; - rayToBps[1000000011703377499223201464] = 4464; - rayToBps[1000000011705569748686891261] = 4465; - rayToBps[1000000011707761846600382591] = 4466; - rayToBps[1000000011709953792984627335] = 4467; - rayToBps[1000000011712145587860573032] = 4468; - rayToBps[1000000011714337231249162871] = 4469; - rayToBps[1000000011716528723171335709] = 4470; - rayToBps[1000000011718720063648026051] = 4471; - rayToBps[1000000011720911252700164071] = 4472; - rayToBps[1000000011723102290348675597] = 4473; - rayToBps[1000000011725293176614482128] = 4474; - rayToBps[1000000011727483911518500818] = 4475; - rayToBps[1000000011729674495081644493] = 4476; - rayToBps[1000000011731864927324821641] = 4477; - rayToBps[1000000011734055208268936418] = 4478; - rayToBps[1000000011736245337934888652] = 4479; - rayToBps[1000000011738435316343573834] = 4480; - rayToBps[1000000011740625143515883134] = 4481; - rayToBps[1000000011742814819472703388] = 4482; - rayToBps[1000000011745004344234917107] = 4483; - rayToBps[1000000011747193717823402479] = 4484; - rayToBps[1000000011749382940259033365] = 4485; - rayToBps[1000000011751572011562679304] = 4486; - rayToBps[1000000011753760931755205513] = 4487; - rayToBps[1000000011755949700857472887] = 4488; - rayToBps[1000000011758138318890338005] = 4489; - rayToBps[1000000011760326785874653124] = 4490; - rayToBps[1000000011762515101831266185] = 4491; - rayToBps[1000000011764703266781020815] = 4492; - rayToBps[1000000011766891280744756325] = 4493; - rayToBps[1000000011769079143743307711] = 4494; - rayToBps[1000000011771266855797505659] = 4495; - rayToBps[1000000011773454416928176542] = 4496; - rayToBps[1000000011775641827156142425] = 4497; - rayToBps[1000000011777829086502221061] = 4498; - rayToBps[1000000011780016194987225901] = 4499; - rayToBps[1000000011782203152631966084] = 4500; - rayToBps[1000000011784389959457246446] = 4501; - rayToBps[1000000011786576615483867520] = 4502; - rayToBps[1000000011788763120732625534] = 4503; - rayToBps[1000000011790949475224312417] = 4504; - rayToBps[1000000011793135678979715794] = 4505; - rayToBps[1000000011795321732019618995] = 4506; - rayToBps[1000000011797507634364801050] = 4507; - rayToBps[1000000011799693386036036690] = 4508; - rayToBps[1000000011801878987054096353] = 4509; - rayToBps[1000000011804064437439746183] = 4510; - rayToBps[1000000011806249737213748028] = 4511; - rayToBps[1000000011808434886396859445] = 4512; - rayToBps[1000000011810619885009833701] = 4513; - rayToBps[1000000011812804733073419772] = 4514; - rayToBps[1000000011814989430608362346] = 4515; - rayToBps[1000000011817173977635401824] = 4516; - rayToBps[1000000011819358374175274320] = 4517; - rayToBps[1000000011821542620248711663] = 4518; - rayToBps[1000000011823726715876441397] = 4519; - rayToBps[1000000011825910661079186786] = 4520; - rayToBps[1000000011828094455877666811] = 4521; - rayToBps[1000000011830278100292596173] = 4522; - rayToBps[1000000011832461594344685292] = 4523; - rayToBps[1000000011834644938054640314] = 4524; - rayToBps[1000000011836828131443163102] = 4525; - rayToBps[1000000011839011174530951252] = 4526; - rayToBps[1000000011841194067338698076] = 4527; - rayToBps[1000000011843376809887092621] = 4528; - rayToBps[1000000011845559402196819657] = 4529; - rayToBps[1000000011847741844288559684] = 4530; - rayToBps[1000000011849924136182988931] = 4531; - rayToBps[1000000011852106277900779365] = 4532; - rayToBps[1000000011854288269462598676] = 4533; - rayToBps[1000000011856470110889110294] = 4534; - rayToBps[1000000011858651802200973384] = 4535; - rayToBps[1000000011860833343418842843] = 4536; - rayToBps[1000000011863014734563369310] = 4537; - rayToBps[1000000011865195975655199159] = 4538; - rayToBps[1000000011867377066714974505] = 4539; - rayToBps[1000000011869558007763333206] = 4540; - rayToBps[1000000011871738798820908856] = 4541; - rayToBps[1000000011873919439908330799] = 4542; - rayToBps[1000000011876099931046224119] = 4543; - rayToBps[1000000011878280272255209648] = 4544; - rayToBps[1000000011880460463555903962] = 4545; - rayToBps[1000000011882640504968919386] = 4546; - rayToBps[1000000011884820396514863997] = 4547; - rayToBps[1000000011887000138214341617] = 4548; - rayToBps[1000000011889179730087951822] = 4549; - rayToBps[1000000011891359172156289942] = 4550; - rayToBps[1000000011893538464439947057] = 4551; - rayToBps[1000000011895717606959510007] = 4552; - rayToBps[1000000011897896599735561381] = 4553; - rayToBps[1000000011900075442788679533] = 4554; - rayToBps[1000000011902254136139438568] = 4555; - rayToBps[1000000011904432679808408357] = 4556; - rayToBps[1000000011906611073816154526] = 4557; - rayToBps[1000000011908789318183238468] = 4558; - rayToBps[1000000011910967412930217335] = 4559; - rayToBps[1000000011913145358077644046] = 4560; - rayToBps[1000000011915323153646067283] = 4561; - rayToBps[1000000011917500799656031495] = 4562; - rayToBps[1000000011919678296128076901] = 4563; - rayToBps[1000000011921855643082739486] = 4564; - rayToBps[1000000011924032840540551006] = 4565; - rayToBps[1000000011926209888522038989] = 4566; - rayToBps[1000000011928386787047726732] = 4567; - rayToBps[1000000011930563536138133312] = 4568; - rayToBps[1000000011932740135813773575] = 4569; - rayToBps[1000000011934916586095158143] = 4570; - rayToBps[1000000011937092887002793418] = 4571; - rayToBps[1000000011939269038557181578] = 4572; - rayToBps[1000000011941445040778820581] = 4573; - rayToBps[1000000011943620893688204164] = 4574; - rayToBps[1000000011945796597305821848] = 4575; - rayToBps[1000000011947972151652158936] = 4576; - rayToBps[1000000011950147556747696515] = 4577; - rayToBps[1000000011952322812612911454] = 4578; - rayToBps[1000000011954497919268276412] = 4579; - rayToBps[1000000011956672876734259834] = 4580; - rayToBps[1000000011958847685031325954] = 4581; - rayToBps[1000000011961022344179934796] = 4582; - rayToBps[1000000011963196854200542173] = 4583; - rayToBps[1000000011965371215113599692] = 4584; - rayToBps[1000000011967545426939554751] = 4585; - rayToBps[1000000011969719489698850545] = 4586; - rayToBps[1000000011971893403411926063] = 4587; - rayToBps[1000000011974067168099216089] = 4588; - rayToBps[1000000011976240783781151209] = 4589; - rayToBps[1000000011978414250478157804] = 4590; - rayToBps[1000000011980587568210658056] = 4591; - rayToBps[1000000011982760736999069949] = 4592; - rayToBps[1000000011984933756863807269] = 4593; - rayToBps[1000000011987106627825279606] = 4594; - rayToBps[1000000011989279349903892354] = 4595; - rayToBps[1000000011991451923120046712] = 4596; - rayToBps[1000000011993624347494139689] = 4597; - rayToBps[1000000011995796623046564099] = 4598; - rayToBps[1000000011997968749797708565] = 4599; - rayToBps[1000000012000140727767957524] = 4600; - rayToBps[1000000012002312556977691222] = 4601; - rayToBps[1000000012004484237447285716] = 4602; - rayToBps[1000000012006655769197112882] = 4603; - rayToBps[1000000012008827152247540405] = 4604; - rayToBps[1000000012010998386618931791] = 4605; - rayToBps[1000000012013169472331646360] = 4606; - rayToBps[1000000012015340409406039253] = 4607; - rayToBps[1000000012017511197862461428] = 4608; - rayToBps[1000000012019681837721259668] = 4609; - rayToBps[1000000012021852329002776572] = 4610; - rayToBps[1000000012024022671727350564] = 4611; - rayToBps[1000000012026192865915315897] = 4612; - rayToBps[1000000012028362911587002643] = 4613; - rayToBps[1000000012030532808762736703] = 4614; - rayToBps[1000000012032702557462839807] = 4615; - rayToBps[1000000012034872157707629511] = 4616; - rayToBps[1000000012037041609517419201] = 4617; - rayToBps[1000000012039210912912518097] = 4618; - rayToBps[1000000012041380067913231248] = 4619; - rayToBps[1000000012043549074539859539] = 4620; - rayToBps[1000000012045717932812699686] = 4621; - rayToBps[1000000012047886642752044245] = 4622; - rayToBps[1000000012050055204378181605] = 4623; - rayToBps[1000000012052223617711395993] = 4624; - rayToBps[1000000012054391882771967477] = 4625; - rayToBps[1000000012056559999580171966] = 4626; - rayToBps[1000000012058727968156281206] = 4627; - rayToBps[1000000012060895788520562788] = 4628; - rayToBps[1000000012063063460693280149] = 4629; - rayToBps[1000000012065230984694692566] = 4630; - rayToBps[1000000012067398360545055164] = 4631; - rayToBps[1000000012069565588264618915] = 4632; - rayToBps[1000000012071732667873630640] = 4633; - rayToBps[1000000012073899599392333007] = 4634; - rayToBps[1000000012076066382840964537] = 4635; - rayToBps[1000000012078233018239759599] = 4636; - rayToBps[1000000012080399505608948418] = 4637; - rayToBps[1000000012082565844968757072] = 4638; - rayToBps[1000000012084732036339407491] = 4639; - rayToBps[1000000012086898079741117465] = 4640; - rayToBps[1000000012089063975194100640] = 4641; - rayToBps[1000000012091229722718566519] = 4642; - rayToBps[1000000012093395322334720465] = 4643; - rayToBps[1000000012095560774062763701] = 4644; - rayToBps[1000000012097726077922893315] = 4645; - rayToBps[1000000012099891233935302252] = 4646; - rayToBps[1000000012102056242120179326] = 4647; - rayToBps[1000000012104221102497709214] = 4648; - rayToBps[1000000012106385815088072459] = 4649; - rayToBps[1000000012108550379911445472] = 4650; - rayToBps[1000000012110714796988000533] = 4651; - rayToBps[1000000012112879066337905789] = 4652; - rayToBps[1000000012115043187981325261] = 4653; - rayToBps[1000000012117207161938418839] = 4654; - rayToBps[1000000012119370988229342288] = 4655; - rayToBps[1000000012121534666874247247] = 4656; - rayToBps[1000000012123698197893281228] = 4657; - rayToBps[1000000012125861581306587623] = 4658; - rayToBps[1000000012128024817134305697] = 4659; - rayToBps[1000000012130187905396570598] = 4660; - rayToBps[1000000012132350846113513350] = 4661; - rayToBps[1000000012134513639305260860] = 4662; - rayToBps[1000000012136676284991935918] = 4663; - rayToBps[1000000012138838783193657193] = 4664; - rayToBps[1000000012141001133930539244] = 4665; - rayToBps[1000000012143163337222692509] = 4666; - rayToBps[1000000012145325393090223317] = 4667; - rayToBps[1000000012147487301553233883] = 4668; - rayToBps[1000000012149649062631822311] = 4669; - rayToBps[1000000012151810676346082594] = 4670; - rayToBps[1000000012153972142716104618] = 4671; - rayToBps[1000000012156133461761974158] = 4672; - rayToBps[1000000012158294633503772885] = 4673; - rayToBps[1000000012160455657961578363] = 4674; - rayToBps[1000000012162616535155464050] = 4675; - rayToBps[1000000012164777265105499304] = 4676; - rayToBps[1000000012166937847831749378] = 4677; - rayToBps[1000000012169098283354275425] = 4678; - rayToBps[1000000012171258571693134496] = 4679; - rayToBps[1000000012173418712868379547] = 4680; - rayToBps[1000000012175578706900059431] = 4681; - rayToBps[1000000012177738553808218907] = 4682; - rayToBps[1000000012179898253612898639] = 4683; - rayToBps[1000000012182057806334135196] = 4684; - rayToBps[1000000012184217211991961053] = 4685; - rayToBps[1000000012186376470606404593] = 4686; - rayToBps[1000000012188535582197490106] = 4687; - rayToBps[1000000012190694546785237795] = 4688; - rayToBps[1000000012192853364389663774] = 4689; - rayToBps[1000000012195012035030780065] = 4690; - rayToBps[1000000012197170558728594608] = 4691; - rayToBps[1000000012199328935503111256] = 4692; - rayToBps[1000000012201487165374329775] = 4693; - rayToBps[1000000012203645248362245852] = 4694; - rayToBps[1000000012205803184486851087] = 4695; - rayToBps[1000000012207960973768133003] = 4696; - rayToBps[1000000012210118616226075039] = 4697; - rayToBps[1000000012212276111880656560] = 4698; - rayToBps[1000000012214433460751852848] = 4699; - rayToBps[1000000012216590662859635112] = 4700; - rayToBps[1000000012218747718223970482] = 4701; - rayToBps[1000000012220904626864822019] = 4702; - rayToBps[1000000012223061388802148704] = 4703; - rayToBps[1000000012225218004055905450] = 4704; - rayToBps[1000000012227374472646043097] = 4705; - rayToBps[1000000012229530794592508416] = 4706; - rayToBps[1000000012231686969915244108] = 4707; - rayToBps[1000000012233842998634188809] = 4708; - rayToBps[1000000012235998880769277082] = 4709; - rayToBps[1000000012238154616340439431] = 4710; - rayToBps[1000000012240310205367602293] = 4711; - rayToBps[1000000012242465647870688040] = 4712; - rayToBps[1000000012244620943869614982] = 4713; - rayToBps[1000000012246776093384297371] = 4714; - rayToBps[1000000012248931096434645396] = 4715; - rayToBps[1000000012251085953040565187] = 4716; - rayToBps[1000000012253240663221958817] = 4717; - rayToBps[1000000012255395226998724301] = 4718; - rayToBps[1000000012257549644390755600] = 4719; - rayToBps[1000000012259703915417942619] = 4720; - rayToBps[1000000012261858040100171212] = 4721; - rayToBps[1000000012264012018457323175] = 4722; - rayToBps[1000000012266165850509276259] = 4723; - rayToBps[1000000012268319536275904161] = 4724; - rayToBps[1000000012270473075777076530] = 4725; - rayToBps[1000000012272626469032658968] = 4726; - rayToBps[1000000012274779716062513028] = 4727; - rayToBps[1000000012276932816886496218] = 4728; - rayToBps[1000000012279085771524462002] = 4729; - rayToBps[1000000012281238579996259799] = 4730; - rayToBps[1000000012283391242321734988] = 4731; - rayToBps[1000000012285543758520728905] = 4732; - rayToBps[1000000012287696128613078844] = 4733; - rayToBps[1000000012289848352618618062] = 4734; - rayToBps[1000000012292000430557175778] = 4735; - rayToBps[1000000012294152362448577173] = 4736; - rayToBps[1000000012296304148312643392] = 4737; - rayToBps[1000000012298455788169191545] = 4738; - rayToBps[1000000012300607282038034711] = 4739; - rayToBps[1000000012302758629938981931] = 4740; - rayToBps[1000000012304909831891838220] = 4741; - rayToBps[1000000012307060887916404559] = 4742; - rayToBps[1000000012309211798032477901] = 4743; - rayToBps[1000000012311362562259851171] = 4744; - rayToBps[1000000012313513180618313265] = 4745; - rayToBps[1000000012315663653127649055] = 4746; - rayToBps[1000000012317813979807639387] = 4747; - rayToBps[1000000012319964160678061084] = 4748; - rayToBps[1000000012322114195758686945] = 4749; - rayToBps[1000000012324264085069285747] = 4750; - rayToBps[1000000012326413828629622247] = 4751; - rayToBps[1000000012328563426459457184] = 4752; - rayToBps[1000000012330712878578547277] = 4753; - rayToBps[1000000012332862185006645225] = 4754; - rayToBps[1000000012335011345763499718] = 4755; - rayToBps[1000000012337160360868855422] = 4756; - rayToBps[1000000012339309230342452997] = 4757; - rayToBps[1000000012341457954204029084] = 4758; - rayToBps[1000000012343606532473316314] = 4759; - rayToBps[1000000012345754965170043307] = 4760; - rayToBps[1000000012347903252313934676] = 4761; - rayToBps[1000000012350051393924711022] = 4762; - rayToBps[1000000012352199390022088940] = 4763; - rayToBps[1000000012354347240625781016] = 4764; - rayToBps[1000000012356494945755495834] = 4765; - rayToBps[1000000012358642505430937972] = 4766; - rayToBps[1000000012360789919671808004] = 4767; - rayToBps[1000000012362937188497802506] = 4768; - rayToBps[1000000012365084311928614047] = 4769; - rayToBps[1000000012367231289983931199] = 4770; - rayToBps[1000000012369378122683438536] = 4771; - rayToBps[1000000012371524810046816632] = 4772; - rayToBps[1000000012373671352093742067] = 4773; - rayToBps[1000000012375817748843887422] = 4774; - rayToBps[1000000012377964000316921287] = 4775; - rayToBps[1000000012380110106532508255] = 4776; - rayToBps[1000000012382256067510308928] = 4777; - rayToBps[1000000012384401883269979920] = 4778; - rayToBps[1000000012386547553831173848] = 4779; - rayToBps[1000000012388693079213539345] = 4780; - rayToBps[1000000012390838459436721054] = 4781; - rayToBps[1000000012392983694520359633] = 4782; - rayToBps[1000000012395128784484091752] = 4783; - rayToBps[1000000012397273729347550096] = 4784; - rayToBps[1000000012399418529130363366] = 4785; - rayToBps[1000000012401563183852156283] = 4786; - rayToBps[1000000012403707693532549584] = 4787; - rayToBps[1000000012405852058191160026] = 4788; - rayToBps[1000000012407996277847600385] = 4789; - rayToBps[1000000012410140352521479464] = 4790; - rayToBps[1000000012412284282232402082] = 4791; - rayToBps[1000000012414428066999969084] = 4792; - rayToBps[1000000012416571706843777343] = 4793; - rayToBps[1000000012418715201783419755] = 4794; - rayToBps[1000000012420858551838485241] = 4795; - rayToBps[1000000012423001757028558755] = 4796; - rayToBps[1000000012425144817373221276] = 4797; - rayToBps[1000000012427287732892049817] = 4798; - rayToBps[1000000012429430503604617418] = 4799; - rayToBps[1000000012431573129530493155] = 4800; - rayToBps[1000000012433715610689242134] = 4801; - rayToBps[1000000012435857947100425498] = 4802; - rayToBps[1000000012438000138783600426] = 4803; - rayToBps[1000000012440142185758320132] = 4804; - rayToBps[1000000012442284088044133868] = 4805; - rayToBps[1000000012444425845660586926] = 4806; - rayToBps[1000000012446567458627220637] = 4807; - rayToBps[1000000012448708926963572372] = 4808; - rayToBps[1000000012450850250689175545] = 4809; - rayToBps[1000000012452991429823559613] = 4810; - rayToBps[1000000012455132464386250078] = 4811; - rayToBps[1000000012457273354396768485] = 4812; - rayToBps[1000000012459414099874632428] = 4813; - rayToBps[1000000012461554700839355545] = 4814; - rayToBps[1000000012463695157310447527] = 4815; - rayToBps[1000000012465835469307414110] = 4816; - rayToBps[1000000012467975636849757081] = 4817; - rayToBps[1000000012470115659956974282] = 4818; - rayToBps[1000000012472255538648559605] = 4819; - rayToBps[1000000012474395272944002997] = 4820; - rayToBps[1000000012476534862862790458] = 4821; - rayToBps[1000000012478674308424404046] = 4822; - rayToBps[1000000012480813609648321873] = 4823; - rayToBps[1000000012482952766554018113] = 4824; - rayToBps[1000000012485091779160962996] = 4825; - rayToBps[1000000012487230647488622814] = 4826; - rayToBps[1000000012489369371556459918] = 4827; - rayToBps[1000000012491507951383932723] = 4828; - rayToBps[1000000012493646386990495707] = 4829; - rayToBps[1000000012495784678395599413] = 4830; - rayToBps[1000000012497922825618690446] = 4831; - rayToBps[1000000012500060828679211483] = 4832; - rayToBps[1000000012502198687596601264] = 4833; - rayToBps[1000000012504336402390294600] = 4834; - rayToBps[1000000012506473973079722370] = 4835; - rayToBps[1000000012508611399684311526] = 4836; - rayToBps[1000000012510748682223485091] = 4837; - rayToBps[1000000012512885820716662158] = 4838; - rayToBps[1000000012515022815183257897] = 4839; - rayToBps[1000000012517159665642683553] = 4840; - rayToBps[1000000012519296372114346446] = 4841; - rayToBps[1000000012521432934617649973] = 4842; - rayToBps[1000000012523569353171993611] = 4843; - rayToBps[1000000012525705627796772912] = 4844; - rayToBps[1000000012527841758511379512] = 4845; - rayToBps[1000000012529977745335201128] = 4846; - rayToBps[1000000012532113588287621558] = 4847; - rayToBps[1000000012534249287388020684] = 4848; - rayToBps[1000000012536384842655774473] = 4849; - rayToBps[1000000012538520254110254976] = 4850; - rayToBps[1000000012540655521770830332] = 4851; - rayToBps[1000000012542790645656864768] = 4852; - rayToBps[1000000012544925625787718599] = 4853; - rayToBps[1000000012547060462182748227] = 4854; - rayToBps[1000000012549195154861306151] = 4855; - rayToBps[1000000012551329703842740957] = 4856; - rayToBps[1000000012553464109146397324] = 4857; - rayToBps[1000000012555598370791616028] = 4858; - rayToBps[1000000012557732488797733936] = 4859; - rayToBps[1000000012559866463184084017] = 4860; - rayToBps[1000000012562000293969995331] = 4861; - rayToBps[1000000012564133981174793037] = 4862; - rayToBps[1000000012566267524817798398] = 4863; - rayToBps[1000000012568400924918328770] = 4864; - rayToBps[1000000012570534181495697619] = 4865; - rayToBps[1000000012572667294569214506] = 4866; - rayToBps[1000000012574800264158185098] = 4867; - rayToBps[1000000012576933090281911168] = 4868; - rayToBps[1000000012579065772959690591] = 4869; - rayToBps[1000000012581198312210817352] = 4870; - rayToBps[1000000012583330708054581542] = 4871; - rayToBps[1000000012585462960510269361] = 4872; - rayToBps[1000000012587595069597163118] = 4873; - rayToBps[1000000012589727035334541233] = 4874; - rayToBps[1000000012591858857741678240] = 4875; - rayToBps[1000000012593990536837844781] = 4876; - rayToBps[1000000012596122072642307617] = 4877; - rayToBps[1000000012598253465174329620] = 4878; - rayToBps[1000000012600384714453169781] = 4879; - rayToBps[1000000012602515820498083206] = 4880; - rayToBps[1000000012604646783328321121] = 4881; - rayToBps[1000000012606777602963130868] = 4882; - rayToBps[1000000012608908279421755911] = 4883; - rayToBps[1000000012611038812723435837] = 4884; - rayToBps[1000000012613169202887406351] = 4885; - rayToBps[1000000012615299449932899285] = 4886; - rayToBps[1000000012617429553879142594] = 4887; - rayToBps[1000000012619559514745360358] = 4888; - rayToBps[1000000012621689332550772783] = 4889; - rayToBps[1000000012623819007314596205] = 4890; - rayToBps[1000000012625948539056043084] = 4891; - rayToBps[1000000012628077927794322013] = 4892; - rayToBps[1000000012630207173548637715] = 4893; - rayToBps[1000000012632336276338191046] = 4894; - rayToBps[1000000012634465236182178989] = 4895; - rayToBps[1000000012636594053099794667] = 4896; - rayToBps[1000000012638722727110227335] = 4897; - rayToBps[1000000012640851258232662384] = 4898; - rayToBps[1000000012642979646486281341] = 4899; - rayToBps[1000000012645107891890261872] = 4900; - rayToBps[1000000012647235994463777781] = 4901; - rayToBps[1000000012649363954225999014] = 4902; - rayToBps[1000000012651491771196091654] = 4903; - rayToBps[1000000012653619445393217929] = 4904; - rayToBps[1000000012655746976836536210] = 4905; - rayToBps[1000000012657874365545201009] = 4906; - rayToBps[1000000012660001611538362988] = 4907; - rayToBps[1000000012662128714835168951] = 4908; - rayToBps[1000000012664255675454761851] = 4909; - rayToBps[1000000012666382493416280789] = 4910; - rayToBps[1000000012668509168738861013] = 4911; - rayToBps[1000000012670635701441633926] = 4912; - rayToBps[1000000012672762091543727077] = 4913; - rayToBps[1000000012674888339064264171] = 4914; - rayToBps[1000000012677014444022365063] = 4915; - rayToBps[1000000012679140406437145768] = 4916; - rayToBps[1000000012681266226327718450] = 4917; - rayToBps[1000000012683391903713191434] = 4918; - rayToBps[1000000012685517438612669200] = 4919; - rayToBps[1000000012687642831045252386] = 4920; - rayToBps[1000000012689768081030037793] = 4921; - rayToBps[1000000012691893188586118377] = 4922; - rayToBps[1000000012694018153732583262] = 4923; - rayToBps[1000000012696142976488517730] = 4924; - rayToBps[1000000012698267656873003228] = 4925; - rayToBps[1000000012700392194905117369] = 4926; - rayToBps[1000000012702516590603933928] = 4927; - rayToBps[1000000012704640843988522851] = 4928; - rayToBps[1000000012706764955077950249] = 4929; - rayToBps[1000000012708888923891278404] = 4930; - rayToBps[1000000012711012750447565765] = 4931; - rayToBps[1000000012713136434765866954] = 4932; - rayToBps[1000000012715259976865232764] = 4933; - rayToBps[1000000012717383376764710160] = 4934; - rayToBps[1000000012719506634483342283] = 4935; - rayToBps[1000000012721629750040168448] = 4936; - rayToBps[1000000012723752723454224145] = 4937; - rayToBps[1000000012725875554744541042] = 4938; - rayToBps[1000000012727998243930146984] = 4939; - rayToBps[1000000012730120791030065998] = 4940; - rayToBps[1000000012732243196063318286] = 4941; - rayToBps[1000000012734365459048920235] = 4942; - rayToBps[1000000012736487580005884415] = 4943; - rayToBps[1000000012738609558953219573] = 4944; - rayToBps[1000000012740731395909930647] = 4945; - rayToBps[1000000012742853090895018757] = 4946; - rayToBps[1000000012744974643927481210] = 4947; - rayToBps[1000000012747096055026311497] = 4948; - rayToBps[1000000012749217324210499303] = 4949; - rayToBps[1000000012751338451499030498] = 4950; - rayToBps[1000000012753459436910887143] = 4951; - rayToBps[1000000012755580280465047490] = 4952; - rayToBps[1000000012757700982180485986] = 4953; - rayToBps[1000000012759821542076173268] = 4954; - rayToBps[1000000012761941960171076169] = 4955; - rayToBps[1000000012764062236484157718] = 4956; - rayToBps[1000000012766182371034377136] = 4957; - rayToBps[1000000012768302363840689849] = 4958; - rayToBps[1000000012770422214922047473] = 4959; - rayToBps[1000000012772541924297397831] = 4960; - rayToBps[1000000012774661491985684940] = 4961; - rayToBps[1000000012776780918005849024] = 4962; - rayToBps[1000000012778900202376826505] = 4963; - rayToBps[1000000012781019345117550012] = 4964; - rayToBps[1000000012783138346246948375] = 4965; - rayToBps[1000000012785257205783946632] = 4966; - rayToBps[1000000012787375923747466027] = 4967; - rayToBps[1000000012789494500156424011] = 4968; - rayToBps[1000000012791612935029734245] = 4969; - rayToBps[1000000012793731228386306598] = 4970; - rayToBps[1000000012795849380245047149] = 4971; - rayToBps[1000000012797967390624858191] = 4972; - rayToBps[1000000012800085259544638227] = 4973; - rayToBps[1000000012802202987023281977] = 4974; - rayToBps[1000000012804320573079680371] = 4975; - rayToBps[1000000012806438017732720558] = 4976; - rayToBps[1000000012808555321001285904] = 4977; - rayToBps[1000000012810672482904255989] = 4978; - rayToBps[1000000012812789503460506616] = 4979; - rayToBps[1000000012814906382688909806] = 4980; - rayToBps[1000000012817023120608333799] = 4981; - rayToBps[1000000012819139717237643058] = 4982; - rayToBps[1000000012821256172595698271] = 4983; - rayToBps[1000000012823372486701356345] = 4984; - rayToBps[1000000012825488659573470415] = 4985; - rayToBps[1000000012827604691230889842] = 4986; - rayToBps[1000000012829720581692460212] = 4987; - rayToBps[1000000012831836330977023339] = 4988; - rayToBps[1000000012833951939103417266] = 4989; - rayToBps[1000000012836067406090476267] = 4990; - rayToBps[1000000012838182731957030847] = 4991; - rayToBps[1000000012840297916721907738] = 4992; - rayToBps[1000000012842412960403929910] = 4993; - rayToBps[1000000012844527863021916565] = 4994; - rayToBps[1000000012846642624594683140] = 4995; - rayToBps[1000000012848757245141041307] = 4996; - rayToBps[1000000012850871724679798976] = 4997; - rayToBps[1000000012852986063229760294] = 4998; - rayToBps[1000000012855100260809725646] = 4999; - rayToBps[1000000012857214317438491659] = 5000; - rayToBps[1000000012859328233134851198] = 5001; - rayToBps[1000000012861442007917593374] = 5002; - rayToBps[1000000012863555641805503536] = 5003; - rayToBps[1000000012865669134817363279] = 5004; - rayToBps[1000000012867782486971950443] = 5005; - rayToBps[1000000012869895698288039115] = 5006; - rayToBps[1000000012872008768784399625] = 5007; - rayToBps[1000000012874121698479798555] = 5008; - rayToBps[1000000012876234487392998733] = 5009; - rayToBps[1000000012878347135542759238] = 5010; - rayToBps[1000000012880459642947835401] = 5011; - rayToBps[1000000012882572009626978801] = 5012; - rayToBps[1000000012884684235598937274] = 5013; - rayToBps[1000000012886796320882454907] = 5014; - rayToBps[1000000012888908265496272044] = 5015; - rayToBps[1000000012891020069459125282] = 5016; - rayToBps[1000000012893131732789747478] = 5017; - rayToBps[1000000012895243255506867744] = 5018; - rayToBps[1000000012897354637629211454] = 5019; - rayToBps[1000000012899465879175500237] = 5020; - rayToBps[1000000012901576980164451988] = 5021; - rayToBps[1000000012903687940614780860] = 5022; - rayToBps[1000000012905798760545197270] = 5023; - rayToBps[1000000012907909439974407900] = 5024; - rayToBps[1000000012910019978921115695] = 5025; - rayToBps[1000000012912130377404019867] = 5026; - rayToBps[1000000012914240635441815894] = 5027; - rayToBps[1000000012916350753053195521] = 5028; - rayToBps[1000000012918460730256846763] = 5029; - rayToBps[1000000012920570567071453907] = 5030; - rayToBps[1000000012922680263515697504] = 5031; - rayToBps[1000000012924789819608254383] = 5032; - rayToBps[1000000012926899235367797644] = 5033; - rayToBps[1000000012929008510812996659] = 5034; - rayToBps[1000000012931117645962517078] = 5035; - rayToBps[1000000012933226640835020822] = 5036; - rayToBps[1000000012935335495449166093] = 5037; - rayToBps[1000000012937444209823607369] = 5038; - rayToBps[1000000012939552783976995406] = 5039; - rayToBps[1000000012941661217927977241] = 5040; - rayToBps[1000000012943769511695196190] = 5041; - rayToBps[1000000012945877665297291852] = 5042; - rayToBps[1000000012947985678752900108] = 5043; - rayToBps[1000000012950093552080653122] = 5044; - rayToBps[1000000012952201285299179347] = 5045; - rayToBps[1000000012954308878427103514] = 5046; - rayToBps[1000000012956416331483046645] = 5047; - rayToBps[1000000012958523644485626051] = 5048; - rayToBps[1000000012960630817453455327] = 5049; - rayToBps[1000000012962737850405144363] = 5050; - rayToBps[1000000012964844743359299334] = 5051; - rayToBps[1000000012966951496334522711] = 5052; - rayToBps[1000000012969058109349413254] = 5053; - rayToBps[1000000012971164582422566020] = 5054; - rayToBps[1000000012973270915572572357] = 5055; - rayToBps[1000000012975377108818019910] = 5056; - rayToBps[1000000012977483162177492621] = 5057; - rayToBps[1000000012979589075669570729] = 5058; - rayToBps[1000000012981694849312830772] = 5059; - rayToBps[1000000012983800483125845583] = 5060; - rayToBps[1000000012985905977127184302] = 5061; - rayToBps[1000000012988011331335412367] = 5062; - rayToBps[1000000012990116545769091518] = 5063; - rayToBps[1000000012992221620446779799] = 5064; - rayToBps[1000000012994326555387031557] = 5065; - rayToBps[1000000012996431350608397447] = 5066; - rayToBps[1000000012998536006129424429] = 5067; - rayToBps[1000000013000640521968655768] = 5068; - rayToBps[1000000013002744898144631040] = 5069; - rayToBps[1000000013004849134675886130] = 5070; - rayToBps[1000000013006953231580953231] = 5071; - rayToBps[1000000013009057188878360849] = 5072; - rayToBps[1000000013011161006586633804] = 5073; - rayToBps[1000000013013264684724293223] = 5074; - rayToBps[1000000013015368223309856554] = 5075; - rayToBps[1000000013017471622361837555] = 5076; - rayToBps[1000000013019574881898746303] = 5077; - rayToBps[1000000013021678001939089190] = 5078; - rayToBps[1000000013023780982501368928] = 5079; - rayToBps[1000000013025883823604084547] = 5080; - rayToBps[1000000013027986525265731396] = 5081; - rayToBps[1000000013030089087504801146] = 5082; - rayToBps[1000000013032191510339781792] = 5083; - rayToBps[1000000013034293793789157646] = 5084; - rayToBps[1000000013036395937871409348] = 5085; - rayToBps[1000000013038497942605013865] = 5086; - rayToBps[1000000013040599808008444486] = 5087; - rayToBps[1000000013042701534100170826] = 5088; - rayToBps[1000000013044803120898658830] = 5089; - rayToBps[1000000013046904568422370773] = 5090; - rayToBps[1000000013049005876689765257] = 5091; - rayToBps[1000000013051107045719297215] = 5092; - rayToBps[1000000013053208075529417914] = 5093; - rayToBps[1000000013055308966138574949] = 5094; - rayToBps[1000000013057409717565212254] = 5095; - rayToBps[1000000013059510329827770095] = 5096; - rayToBps[1000000013061610802944685072] = 5097; - rayToBps[1000000013063711136934390123] = 5098; - rayToBps[1000000013065811331815314524] = 5099; - rayToBps[1000000013067911387605883890] = 5100; - rayToBps[1000000013070011304324520173] = 5101; - rayToBps[1000000013072111081989641667] = 5102; - rayToBps[1000000013074210720619663007] = 5103; - rayToBps[1000000013076310220232995171] = 5104; - rayToBps[1000000013078409580848045479] = 5105; - rayToBps[1000000013080508802483217595] = 5106; - rayToBps[1000000013082607885156911531] = 5107; - rayToBps[1000000013084706828887523642] = 5108; - rayToBps[1000000013086805633693446631] = 5109; - rayToBps[1000000013088904299593069551] = 5110; - rayToBps[1000000013091002826604777801] = 5111; - rayToBps[1000000013093101214746953133] = 5112; - rayToBps[1000000013095199464037973648] = 5113; - rayToBps[1000000013097297574496213800] = 5114; - rayToBps[1000000013099395546140044395] = 5115; - rayToBps[1000000013101493378987832595] = 5116; - rayToBps[1000000013103591073057941913] = 5117; - rayToBps[1000000013105688628368732223] = 5118; - rayToBps[1000000013107786044938559751] = 5119; - rayToBps[1000000013109883322785777084] = 5120; - rayToBps[1000000013111980461928733165] = 5121; - rayToBps[1000000013114077462385773300] = 5122; - rayToBps[1000000013116174324175239154] = 5123; - rayToBps[1000000013118271047315468752] = 5124; - rayToBps[1000000013120367631824796485] = 5125; - rayToBps[1000000013122464077721553103] = 5126; - rayToBps[1000000013124560385024065726] = 5127; - rayToBps[1000000013126656553750657835] = 5128; - rayToBps[1000000013128752583919649280] = 5129; - rayToBps[1000000013130848475549356277] = 5130; - rayToBps[1000000013132944228658091410] = 5131; - rayToBps[1000000013135039843264163635] = 5132; - rayToBps[1000000013137135319385878275] = 5133; - rayToBps[1000000013139230657041537026] = 5134; - rayToBps[1000000013141325856249437956] = 5135; - rayToBps[1000000013143420917027875507] = 5136; - rayToBps[1000000013145515839395140491] = 5137; - rayToBps[1000000013147610623369520102] = 5138; - rayToBps[1000000013149705268969297904] = 5139; - rayToBps[1000000013151799776212753840] = 5140; - rayToBps[1000000013153894145118164231] = 5141; - rayToBps[1000000013155988375703801779] = 5142; - rayToBps[1000000013158082467987935562] = 5143; - rayToBps[1000000013160176421988831041] = 5144; - rayToBps[1000000013162270237724750059] = 5145; - rayToBps[1000000013164363915213950840] = 5146; - rayToBps[1000000013166457454474687994] = 5147; - rayToBps[1000000013168550855525212514] = 5148; - rayToBps[1000000013170644118383771778] = 5149; - rayToBps[1000000013172737243068609553] = 5150; - rayToBps[1000000013174830229597965992] = 5151; - rayToBps[1000000013176923077990077635] = 5152; - rayToBps[1000000013179015788263177415] = 5153; - rayToBps[1000000013181108360435494653] = 5154; - rayToBps[1000000013183200794525255059] = 5155; - rayToBps[1000000013185293090550680741] = 5156; - rayToBps[1000000013187385248529990196] = 5157; - rayToBps[1000000013189477268481398315] = 5158; - rayToBps[1000000013191569150423116386] = 5159; - rayToBps[1000000013193660894373352093] = 5160; - rayToBps[1000000013195752500350309515] = 5161; - rayToBps[1000000013197843968372189132] = 5162; - rayToBps[1000000013199935298457187821] = 5163; - rayToBps[1000000013202026490623498857] = 5164; - rayToBps[1000000013204117544889311921] = 5165; - rayToBps[1000000013206208461272813091] = 5166; - rayToBps[1000000013208299239792184850] = 5167; - rayToBps[1000000013210389880465606084] = 5168; - rayToBps[1000000013212480383311252082] = 5169; - rayToBps[1000000013214570748347294544] = 5170; - rayToBps[1000000013216660975591901569] = 5171; - rayToBps[1000000013218751065063237670] = 5172; - rayToBps[1000000013220841016779463763] = 5173; - rayToBps[1000000013222930830758737177] = 5174; - rayToBps[1000000013225020507019211652] = 5175; - rayToBps[1000000013227110045579037336] = 5176; - rayToBps[1000000013229199446456360791] = 5177; - rayToBps[1000000013231288709669324991] = 5178; - rayToBps[1000000013233377835236069326] = 5179; - rayToBps[1000000013235466823174729599] = 5180; - rayToBps[1000000013237555673503438031] = 5181; - rayToBps[1000000013239644386240323257] = 5182; - rayToBps[1000000013241732961403510334] = 5183; - rayToBps[1000000013243821399011120734] = 5184; - rayToBps[1000000013245909699081272350] = 5185; - rayToBps[1000000013247997861632079496] = 5186; - rayToBps[1000000013250085886681652909] = 5187; - rayToBps[1000000013252173774248099746] = 5188; - rayToBps[1000000013254261524349523588] = 5189; - rayToBps[1000000013256349137004024442] = 5190; - rayToBps[1000000013258436612229698739] = 5191; - rayToBps[1000000013260523950044639336] = 5192; - rayToBps[1000000013262611150466935520] = 5193; - rayToBps[1000000013264698213514673002] = 5194; - rayToBps[1000000013266785139205933927] = 5195; - rayToBps[1000000013268871927558796866] = 5196; - rayToBps[1000000013270958578591336822] = 5197; - rayToBps[1000000013273045092321625231] = 5198; - rayToBps[1000000013275131468767729963] = 5199; - rayToBps[1000000013277217707947715318] = 5200; - rayToBps[1000000013279303809879642035] = 5201; - rayToBps[1000000013281389774581567286] = 5202; - rayToBps[1000000013283475602071544681] = 5203; - rayToBps[1000000013285561292367624266] = 5204; - rayToBps[1000000013287646845487852528] = 5205; - rayToBps[1000000013289732261450272392] = 5206; - rayToBps[1000000013291817540272923222] = 5207; - rayToBps[1000000013293902681973840827] = 5208; - rayToBps[1000000013295987686571057456] = 5209; - rayToBps[1000000013298072554082601799] = 5210; - rayToBps[1000000013300157284526498996] = 5211; - rayToBps[1000000013302241877920770626] = 5212; - rayToBps[1000000013304326334283434719] = 5213; - rayToBps[1000000013306410653632505749] = 5214; - rayToBps[1000000013308494835985994637] = 5215; - rayToBps[1000000013310578881361908756] = 5216; - rayToBps[1000000013312662789778251927] = 5217; - rayToBps[1000000013314746561253024422] = 5218; - rayToBps[1000000013316830195804222964] = 5219; - rayToBps[1000000013318913693449840730] = 5220; - rayToBps[1000000013320997054207867349] = 5221; - rayToBps[1000000013323080278096288904] = 5222; - rayToBps[1000000013325163365133087937] = 5223; - rayToBps[1000000013327246315336243441] = 5224; - rayToBps[1000000013329329128723730871] = 5225; - rayToBps[1000000013331411805313522137] = 5226; - rayToBps[1000000013333494345123585609] = 5227; - rayToBps[1000000013335576748171886118] = 5228; - rayToBps[1000000013337659014476384955] = 5229; - rayToBps[1000000013339741144055039872] = 5230; - rayToBps[1000000013341823136925805086] = 5231; - rayToBps[1000000013343904993106631276] = 5232; - rayToBps[1000000013345986712615465587] = 5233; - rayToBps[1000000013348068295470251626] = 5234; - rayToBps[1000000013350149741688929473] = 5235; - rayToBps[1000000013352231051289435670] = 5236; - rayToBps[1000000013354312224289703229] = 5237; - rayToBps[1000000013356393260707661631] = 5238; - rayToBps[1000000013358474160561236828] = 5239; - rayToBps[1000000013360554923868351244] = 5240; - rayToBps[1000000013362635550646923773] = 5241; - rayToBps[1000000013364716040914869783] = 5242; - rayToBps[1000000013366796394690101115] = 5243; - rayToBps[1000000013368876611990526086] = 5244; - rayToBps[1000000013370956692834049490] = 5245; - rayToBps[1000000013373036637238572595] = 5246; - rayToBps[1000000013375116445221993147] = 5247; - rayToBps[1000000013377196116802205372] = 5248; - rayToBps[1000000013379275651997099976] = 5249; - rayToBps[1000000013381355050824564143] = 5250; - rayToBps[1000000013383434313302481540] = 5251; - rayToBps[1000000013385513439448732314] = 5252; - rayToBps[1000000013387592429281193100] = 5253; - rayToBps[1000000013389671282817737012] = 5254; - rayToBps[1000000013391750000076233652] = 5255; - rayToBps[1000000013393828581074549107] = 5256; - rayToBps[1000000013395907025830545951] = 5257; - rayToBps[1000000013397985334362083244] = 5258; - rayToBps[1000000013400063506687016538] = 5259; - rayToBps[1000000013402141542823197873] = 5260; - rayToBps[1000000013404219442788475779] = 5261; - rayToBps[1000000013406297206600695278] = 5262; - rayToBps[1000000013408374834277697885] = 5263; - rayToBps[1000000013410452325837321606] = 5264; - rayToBps[1000000013412529681297400945] = 5265; - rayToBps[1000000013414606900675766898] = 5266; - rayToBps[1000000013416683983990246957] = 5267; - rayToBps[1000000013418760931258665113] = 5268; - rayToBps[1000000013420837742498841855] = 5269; - rayToBps[1000000013422914417728594168] = 5270; - rayToBps[1000000013424990956965735539] = 5271; - rayToBps[1000000013427067360228075956] = 5272; - rayToBps[1000000013429143627533421906] = 5273; - rayToBps[1000000013431219758899576381] = 5274; - rayToBps[1000000013433295754344338876] = 5275; - rayToBps[1000000013435371613885505389] = 5276; - rayToBps[1000000013437447337540868424] = 5277; - rayToBps[1000000013439522925328216993] = 5278; - rayToBps[1000000013441598377265336611] = 5279; - rayToBps[1000000013443673693370009304] = 5280; - rayToBps[1000000013445748873660013605] = 5281; - rayToBps[1000000013447823918153124560] = 5282; - rayToBps[1000000013449898826867113722] = 5283; - rayToBps[1000000013451973599819749157] = 5284; - rayToBps[1000000013454048237028795446] = 5285; - rayToBps[1000000013456122738512013678] = 5286; - rayToBps[1000000013458197104287161462] = 5287; - rayToBps[1000000013460271334371992918] = 5288; - rayToBps[1000000013462345428784258685] = 5289; - rayToBps[1000000013464419387541705919] = 5290; - rayToBps[1000000013466493210662078291] = 5291; - rayToBps[1000000013468566898163115994] = 5292; - rayToBps[1000000013470640450062555739] = 5293; - rayToBps[1000000013472713866378130761] = 5294; - rayToBps[1000000013474787147127570811] = 5295; - rayToBps[1000000013476860292328602168] = 5296; - rayToBps[1000000013478933301998947631] = 5297; - rayToBps[1000000013481006176156326525] = 5298; - rayToBps[1000000013483078914818454700] = 5299; - rayToBps[1000000013485151518003044532] = 5300; - rayToBps[1000000013487223985727804923] = 5301; - rayToBps[1000000013489296318010441307] = 5302; - rayToBps[1000000013491368514868655641] = 5303; - rayToBps[1000000013493440576320146417] = 5304; - rayToBps[1000000013495512502382608654] = 5305; - rayToBps[1000000013497584293073733906] = 5306; - rayToBps[1000000013499655948411210256] = 5307; - rayToBps[1000000013501727468412722324] = 5308; - rayToBps[1000000013503798853095951261] = 5309; - rayToBps[1000000013505870102478574756] = 5310; - rayToBps[1000000013507941216578267032] = 5311; - rayToBps[1000000013510012195412698851] = 5312; - rayToBps[1000000013512083038999537512] = 5313; - rayToBps[1000000013514153747356446852] = 5314; - rayToBps[1000000013516224320501087249] = 5315; - rayToBps[1000000013518294758451115623] = 5316; - rayToBps[1000000013520365061224185433] = 5317; - rayToBps[1000000013522435228837946681] = 5318; - rayToBps[1000000013524505261310045913] = 5319; - rayToBps[1000000013526575158658126219] = 5320; - rayToBps[1000000013528644920899827235] = 5321; - rayToBps[1000000013530714548052785142] = 5322; - rayToBps[1000000013532784040134632670] = 5323; - rayToBps[1000000013534853397162999093] = 5324; - rayToBps[1000000013536922619155510237] = 5325; - rayToBps[1000000013538991706129788478] = 5326; - rayToBps[1000000013541060658103452740] = 5327; - rayToBps[1000000013543129475094118502] = 5328; - rayToBps[1000000013545198157119397791] = 5329; - rayToBps[1000000013547266704196899191] = 5330; - rayToBps[1000000013549335116344227839] = 5331; - rayToBps[1000000013551403393578985427] = 5332; - rayToBps[1000000013553471535918770203] = 5333; - rayToBps[1000000013555539543381176971] = 5334; - rayToBps[1000000013557607415983797096] = 5335; - rayToBps[1000000013559675153744218497] = 5336; - rayToBps[1000000013561742756680025656] = 5337; - rayToBps[1000000013563810224808799615] = 5338; - rayToBps[1000000013565877558148117977] = 5339; - rayToBps[1000000013567944756715554906] = 5340; - rayToBps[1000000013570011820528681131] = 5341; - rayToBps[1000000013572078749605063945] = 5342; - rayToBps[1000000013574145543962267205] = 5343; - rayToBps[1000000013576212203617851334] = 5344; - rayToBps[1000000013578278728589373323] = 5345; - rayToBps[1000000013580345118894386729] = 5346; - rayToBps[1000000013582411374550441678] = 5347; - rayToBps[1000000013584477495575084867] = 5348; - rayToBps[1000000013586543481985859560] = 5349; - rayToBps[1000000013588609333800305597] = 5350; - rayToBps[1000000013590675051035959386] = 5351; - rayToBps[1000000013592740633710353909] = 5352; - rayToBps[1000000013594806081841018723] = 5353; - rayToBps[1000000013596871395445479960] = 5354; - rayToBps[1000000013598936574541260325] = 5355; - rayToBps[1000000013601001619145879103] = 5356; - rayToBps[1000000013603066529276852154] = 5357; - rayToBps[1000000013605131304951691920] = 5358; - rayToBps[1000000013607195946187907415] = 5359; - rayToBps[1000000013609260453003004241] = 5360; - rayToBps[1000000013611324825414484577] = 5361; - rayToBps[1000000013613389063439847186] = 5362; - rayToBps[1000000013615453167096587411] = 5363; - rayToBps[1000000013617517136402197181] = 5364; - rayToBps[1000000013619580971374165008] = 5365; - rayToBps[1000000013621644672029975992] = 5366; - rayToBps[1000000013623708238387111817] = 5367; - rayToBps[1000000013625771670463050755] = 5368; - rayToBps[1000000013627834968275267666] = 5369; - rayToBps[1000000013629898131841234000] = 5370; - rayToBps[1000000013631961161178417796] = 5371; - rayToBps[1000000013634024056304283684] = 5372; - rayToBps[1000000013636086817236292885] = 5373; - rayToBps[1000000013638149443991903215] = 5374; - rayToBps[1000000013640211936588569081] = 5375; - rayToBps[1000000013642274295043741485] = 5376; - rayToBps[1000000013644336519374868025] = 5377; - rayToBps[1000000013646398609599392894] = 5378; - rayToBps[1000000013648460565734756883] = 5379; - rayToBps[1000000013650522387798397382] = 5380; - rayToBps[1000000013652584075807748376] = 5381; - rayToBps[1000000013654645629780240453] = 5382; - rayToBps[1000000013656707049733300801] = 5383; - rayToBps[1000000013658768335684353209] = 5384; - rayToBps[1000000013660829487650818068] = 5385; - rayToBps[1000000013662890505650112373] = 5386; - rayToBps[1000000013664951389699649722] = 5387; - rayToBps[1000000013667012139816840321] = 5388; - rayToBps[1000000013669072756019090977] = 5389; - rayToBps[1000000013671133238323805108] = 5390; - rayToBps[1000000013673193586748382737] = 5391; - rayToBps[1000000013675253801310220496] = 5392; - rayToBps[1000000013677313882026711628] = 5393; - rayToBps[1000000013679373828915245986] = 5394; - rayToBps[1000000013681433641993210032] = 5395; - rayToBps[1000000013683493321277986841] = 5396; - rayToBps[1000000013685552866786956102] = 5397; - rayToBps[1000000013687612278537494116] = 5398; - rayToBps[1000000013689671556546973802] = 5399; - rayToBps[1000000013691730700832764691] = 5400; - rayToBps[1000000013693789711412232932] = 5401; - rayToBps[1000000013695848588302741289] = 5402; - rayToBps[1000000013697907331521649149] = 5403; - rayToBps[1000000013699965941086312515] = 5404; - rayToBps[1000000013702024417014084009] = 5405; - rayToBps[1000000013704082759322312876] = 5406; - rayToBps[1000000013706140968028344981] = 5407; - rayToBps[1000000013708199043149522812] = 5408; - rayToBps[1000000013710256984703185483] = 5409; - rayToBps[1000000013712314792706668728] = 5410; - rayToBps[1000000013714372467177304910] = 5411; - rayToBps[1000000013716430008132423015] = 5412; - rayToBps[1000000013718487415589348659] = 5413; - rayToBps[1000000013720544689565404082] = 5414; - rayToBps[1000000013722601830077908157] = 5415; - rayToBps[1000000013724658837144176384] = 5416; - rayToBps[1000000013726715710781520893] = 5417; - rayToBps[1000000013728772451007250448] = 5418; - rayToBps[1000000013730829057838670442] = 5419; - rayToBps[1000000013732885531293082904] = 5420; - rayToBps[1000000013734941871387786495] = 5421; - rayToBps[1000000013736998078140076511] = 5422; - rayToBps[1000000013739054151567244885] = 5423; - rayToBps[1000000013741110091686580185] = 5424; - rayToBps[1000000013743165898515367617] = 5425; - rayToBps[1000000013745221572070889027] = 5426; - rayToBps[1000000013747277112370422896] = 5427; - rayToBps[1000000013749332519431244349] = 5428; - rayToBps[1000000013751387793270625152] = 5429; - rayToBps[1000000013753442933905833710] = 5430; - rayToBps[1000000013755497941354135072] = 5431; - rayToBps[1000000013757552815632790932] = 5432; - rayToBps[1000000013759607556759059626] = 5433; - rayToBps[1000000013761662164750196136] = 5434; - rayToBps[1000000013763716639623452091] = 5435; - rayToBps[1000000013765770981396075767] = 5436; - rayToBps[1000000013767825190085312088] = 5437; - rayToBps[1000000013769879265708402624] = 5438; - rayToBps[1000000013771933208282585599] = 5439; - rayToBps[1000000013773987017825095883] = 5440; - rayToBps[1000000013776040694353165002] = 5441; - rayToBps[1000000013778094237884021131] = 5442; - rayToBps[1000000013780147648434889099] = 5443; - rayToBps[1000000013782200926022990388] = 5444; - rayToBps[1000000013784254070665543138] = 5445; - rayToBps[1000000013786307082379762141] = 5446; - rayToBps[1000000013788359961182858847] = 5447; - rayToBps[1000000013790412707092041364] = 5448; - rayToBps[1000000013792465320124514458] = 5449; - rayToBps[1000000013794517800297479554] = 5450; - rayToBps[1000000013796570147628134736] = 5451; - rayToBps[1000000013798622362133674751] = 5452; - rayToBps[1000000013800674443831291006] = 5453; - rayToBps[1000000013802726392738171571] = 5454; - rayToBps[1000000013804778208871501181] = 5455; - rayToBps[1000000013806829892248461232] = 5456; - rayToBps[1000000013808881442886229789] = 5457; - rayToBps[1000000013810932860801981581] = 5458; - rayToBps[1000000013812984146012888004] = 5459; - rayToBps[1000000013815035298536117122] = 5460; - rayToBps[1000000013817086318388833668] = 5461; - rayToBps[1000000013819137205588199044] = 5462; - rayToBps[1000000013821187960151371324] = 5463; - rayToBps[1000000013823238582095505250] = 5464; - rayToBps[1000000013825289071437752239] = 5465; - rayToBps[1000000013827339428195260380] = 5466; - rayToBps[1000000013829389652385174435] = 5467; - rayToBps[1000000013831439744024635842] = 5468; - rayToBps[1000000013833489703130782714] = 5469; - rayToBps[1000000013835539529720749841] = 5470; - rayToBps[1000000013837589223811668689] = 5471; - rayToBps[1000000013839638785420667403] = 5472; - rayToBps[1000000013841688214564870807] = 5473; - rayToBps[1000000013843737511261400404] = 5474; - rayToBps[1000000013845786675527374380] = 5475; - rayToBps[1000000013847835707379907599] = 5476; - rayToBps[1000000013849884606836111609] = 5477; - rayToBps[1000000013851933373913094644] = 5478; - rayToBps[1000000013853982008627961619] = 5479; - rayToBps[1000000013856030510997814133] = 5480; - rayToBps[1000000013858078881039750473] = 5481; - rayToBps[1000000013860127118770865614] = 5482; - rayToBps[1000000013862175224208251215] = 5483; - rayToBps[1000000013864223197368995626] = 5484; - rayToBps[1000000013866271038270183886] = 5485; - rayToBps[1000000013868318746928897723] = 5486; - rayToBps[1000000013870366323362215556] = 5487; - rayToBps[1000000013872413767587212497] = 5488; - rayToBps[1000000013874461079620960351] = 5489; - rayToBps[1000000013876508259480527614] = 5490; - rayToBps[1000000013878555307182979479] = 5491; - rayToBps[1000000013880602222745377833] = 5492; - rayToBps[1000000013882649006184781260] = 5493; - rayToBps[1000000013884695657518245039] = 5494; - rayToBps[1000000013886742176762821150] = 5495; - rayToBps[1000000013888788563935558267] = 5496; - rayToBps[1000000013890834819053501770] = 5497; - rayToBps[1000000013892880942133693733] = 5498; - rayToBps[1000000013894926933193172935] = 5499; - rayToBps[1000000013896972792248974855] = 5500; - rayToBps[1000000013899018519318131677] = 5501; - rayToBps[1000000013901064114417672287] = 5502; - rayToBps[1000000013903109577564622276] = 5503; - rayToBps[1000000013905154908776003941] = 5504; - rayToBps[1000000013907200108068836286] = 5505; - rayToBps[1000000013909245175460135020] = 5506; - rayToBps[1000000013911290110966912561] = 5507; - rayToBps[1000000013913334914606178038] = 5508; - rayToBps[1000000013915379586394937285] = 5509; - rayToBps[1000000013917424126350192852] = 5510; - rayToBps[1000000013919468534488943996] = 5511; - rayToBps[1000000013921512810828186689] = 5512; - rayToBps[1000000013923556955384913616] = 5513; - rayToBps[1000000013925600968176114173] = 5514; - rayToBps[1000000013927644849218774474] = 5515; - rayToBps[1000000013929688598529877347] = 5516; - rayToBps[1000000013931732216126402338] = 5517; - rayToBps[1000000013933775702025325709] = 5518; - rayToBps[1000000013935819056243620441] = 5519; - rayToBps[1000000013937862278798256232] = 5520; - rayToBps[1000000013939905369706199504] = 5521; - rayToBps[1000000013941948328984413395] = 5522; - rayToBps[1000000013943991156649857768] = 5523; - rayToBps[1000000013946033852719489207] = 5524; - rayToBps[1000000013948076417210261020] = 5525; - rayToBps[1000000013950118850139123237] = 5526; - rayToBps[1000000013952161151523022616] = 5527; - rayToBps[1000000013954203321378902639] = 5528; - rayToBps[1000000013956245359723703515] = 5529; - rayToBps[1000000013958287266574362180] = 5530; - rayToBps[1000000013960329041947812299] = 5531; - rayToBps[1000000013962370685860984266] = 5532; - rayToBps[1000000013964412198330805204] = 5533; - rayToBps[1000000013966453579374198970] = 5534; - rayToBps[1000000013968494829008086149] = 5535; - rayToBps[1000000013970535947249384059] = 5536; - rayToBps[1000000013972576934115006754] = 5537; - rayToBps[1000000013974617789621865021] = 5538; - rayToBps[1000000013976658513786866380] = 5539; - rayToBps[1000000013978699106626915089] = 5540; - rayToBps[1000000013980739568158912143] = 5541; - rayToBps[1000000013982779898399755273] = 5542; - rayToBps[1000000013984820097366338950] = 5543; - rayToBps[1000000013986860165075554382] = 5544; - rayToBps[1000000013988900101544289521] = 5545; - rayToBps[1000000013990939906789429055] = 5546; - rayToBps[1000000013992979580827854418] = 5547; - rayToBps[1000000013995019123676443785] = 5548; - rayToBps[1000000013997058535352072073] = 5549; - rayToBps[1000000013999097815871610946] = 5550; - rayToBps[1000000014001136965251928811] = 5551; - rayToBps[1000000014003175983509890823] = 5552; - rayToBps[1000000014005214870662358881] = 5553; - rayToBps[1000000014007253626726191632] = 5554; - rayToBps[1000000014009292251718244476] = 5555; - rayToBps[1000000014011330745655369557] = 5556; - rayToBps[1000000014013369108554415771] = 5557; - rayToBps[1000000014015407340432228765] = 5558; - rayToBps[1000000014017445441305650938] = 5559; - rayToBps[1000000014019483411191521442] = 5560; - rayToBps[1000000014021521250106676181] = 5561; - rayToBps[1000000014023558958067947815] = 5562; - rayToBps[1000000014025596535092165759] = 5563; - rayToBps[1000000014027633981196156184] = 5564; - rayToBps[1000000014029671296396742013] = 5565; - rayToBps[1000000014031708480710742936] = 5566; - rayToBps[1000000014033745534154975394] = 5567; - rayToBps[1000000014035782456746252590] = 5568; - rayToBps[1000000014037819248501384486] = 5569; - rayToBps[1000000014039855909437177808] = 5570; - rayToBps[1000000014041892439570436040] = 5571; - rayToBps[1000000014043928838917959430] = 5572; - rayToBps[1000000014045965107496544991] = 5573; - rayToBps[1000000014048001245322986499] = 5574; - rayToBps[1000000014050037252414074493] = 5575; - rayToBps[1000000014052073128786596283] = 5576; - rayToBps[1000000014054108874457335942] = 5577; - rayToBps[1000000014056144489443074311] = 5578; - rayToBps[1000000014058179973760589001] = 5579; - rayToBps[1000000014060215327426654391] = 5580; - rayToBps[1000000014062250550458041631] = 5581; - rayToBps[1000000014064285642871518639] = 5582; - rayToBps[1000000014066320604683850111] = 5583; - rayToBps[1000000014068355435911797509] = 5584; - rayToBps[1000000014070390136572119073] = 5585; - rayToBps[1000000014072424706681569814] = 5586; - rayToBps[1000000014074459146256901521] = 5587; - rayToBps[1000000014076493455314862758] = 5588; - rayToBps[1000000014078527633872198862] = 5589; - rayToBps[1000000014080561681945651954] = 5590; - rayToBps[1000000014082595599551960930] = 5591; - rayToBps[1000000014084629386707861464] = 5592; - rayToBps[1000000014086663043430086012] = 5593; - rayToBps[1000000014088696569735363811] = 5594; - rayToBps[1000000014090729965640420880] = 5595; - rayToBps[1000000014092763231161980018] = 5596; - rayToBps[1000000014094796366316760809] = 5597; - rayToBps[1000000014096829371121479623] = 5598; - rayToBps[1000000014098862245592849610] = 5599; - rayToBps[1000000014100894989747580713] = 5600; - rayToBps[1000000014102927603602379655] = 5601; - rayToBps[1000000014104960087173949949] = 5602; - rayToBps[1000000014106992440478991899] = 5603; - rayToBps[1000000014109024663534202592] = 5604; - rayToBps[1000000014111056756356275911] = 5605; - rayToBps[1000000014113088718961902527] = 5606; - rayToBps[1000000014115120551367769903] = 5607; - rayToBps[1000000014117152253590562293] = 5608; - rayToBps[1000000014119183825646960746] = 5609; - rayToBps[1000000014121215267553643106] = 5610; - rayToBps[1000000014123246579327284009] = 5611; - rayToBps[1000000014125277760984554889] = 5612; - rayToBps[1000000014127308812542123975] = 5613; - rayToBps[1000000014129339734016656294] = 5614; - rayToBps[1000000014131370525424813672] = 5615; - rayToBps[1000000014133401186783254733] = 5616; - rayToBps[1000000014135431718108634901] = 5617; - rayToBps[1000000014137462119417606400] = 5618; - rayToBps[1000000014139492390726818256] = 5619; - rayToBps[1000000014141522532052916298] = 5620; - rayToBps[1000000014143552543412543158] = 5621; - rayToBps[1000000014145582424822338270] = 5622; - rayToBps[1000000014147612176298937873] = 5623; - rayToBps[1000000014149641797858975016] = 5624; - rayToBps[1000000014151671289519079548] = 5625; - rayToBps[1000000014153700651295878130] = 5626; - rayToBps[1000000014155729883205994226] = 5627; - rayToBps[1000000014157758985266048116] = 5628; - rayToBps[1000000014159787957492656883] = 5629; - rayToBps[1000000014161816799902434423] = 5630; - rayToBps[1000000014163845512511991443] = 5631; - rayToBps[1000000014165874095337935463] = 5632; - rayToBps[1000000014167902548396870816] = 5633; - rayToBps[1000000014169930871705398646] = 5634; - rayToBps[1000000014171959065280116914] = 5635; - rayToBps[1000000014173987129137620396] = 5636; - rayToBps[1000000014176015063294500683] = 5637; - rayToBps[1000000014178042867767346186] = 5638; - rayToBps[1000000014180070542572742128] = 5639; - rayToBps[1000000014182098087727270558] = 5640; - rayToBps[1000000014184125503247510337] = 5641; - rayToBps[1000000014186152789150037153] = 5642; - rayToBps[1000000014188179945451423510] = 5643; - rayToBps[1000000014190206972168238736] = 5644; - rayToBps[1000000014192233869317048980] = 5645; - rayToBps[1000000014194260636914417219] = 5646; - rayToBps[1000000014196287274976903248] = 5647; - rayToBps[1000000014198313783521063691] = 5648; - rayToBps[1000000014200340162563451997] = 5649; - rayToBps[1000000014202366412120618444] = 5650; - rayToBps[1000000014204392532209110132] = 5651; - rayToBps[1000000014206418522845470993] = 5652; - rayToBps[1000000014208444384046241790] = 5653; - rayToBps[1000000014210470115827960111] = 5654; - rayToBps[1000000014212495718207160381] = 5655; - rayToBps[1000000014214521191200373850] = 5656; - rayToBps[1000000014216546534824128603] = 5657; - rayToBps[1000000014218571749094949561] = 5658; - rayToBps[1000000014220596834029358476] = 5659; - rayToBps[1000000014222621789643873935] = 5660; - rayToBps[1000000014224646615955011361] = 5661; - rayToBps[1000000014226671312979283014] = 5662; - rayToBps[1000000014228695880733197990] = 5663; - rayToBps[1000000014230720319233262225] = 5664; - rayToBps[1000000014232744628495978491] = 5665; - rayToBps[1000000014234768808537846403] = 5666; - rayToBps[1000000014236792859375362413] = 5667; - rayToBps[1000000014238816781025019818] = 5668; - rayToBps[1000000014240840573503308754] = 5669; - rayToBps[1000000014242864236826716200] = 5670; - rayToBps[1000000014244887771011725981] = 5671; - rayToBps[1000000014246911176074818766] = 5672; - rayToBps[1000000014248934452032472066] = 5673; - rayToBps[1000000014250957598901160243] = 5674; - rayToBps[1000000014252980616697354502] = 5675; - rayToBps[1000000014255003505437522899] = 5676; - rayToBps[1000000014257026265138130334] = 5677; - rayToBps[1000000014259048895815638562] = 5678; - rayToBps[1000000014261071397486506182] = 5679; - rayToBps[1000000014263093770167188651] = 5680; - rayToBps[1000000014265116013874138270] = 5681; - rayToBps[1000000014267138128623804199] = 5682; - rayToBps[1000000014269160114432632448] = 5683; - rayToBps[1000000014271181971317065881] = 5684; - rayToBps[1000000014273203699293544220] = 5685; - rayToBps[1000000014275225298378504039] = 5686; - rayToBps[1000000014277246768588378769] = 5687; - rayToBps[1000000014279268109939598702] = 5688; - rayToBps[1000000014281289322448590984] = 5689; - rayToBps[1000000014283310406131779623] = 5690; - rayToBps[1000000014285331361005585484] = 5691; - rayToBps[1000000014287352187086426294] = 5692; - rayToBps[1000000014289372884390716643] = 5693; - rayToBps[1000000014291393452934867978] = 5694; - rayToBps[1000000014293413892735288616] = 5695; - rayToBps[1000000014295434203808383731] = 5696; - rayToBps[1000000014297454386170555368] = 5697; - rayToBps[1000000014299474439838202432] = 5698; - rayToBps[1000000014301494364827720695] = 5699; - rayToBps[1000000014303514161155502800] = 5700; - rayToBps[1000000014305533828837938253] = 5701; - rayToBps[1000000014307553367891413431] = 5702; - rayToBps[1000000014309572778332311579] = 5703; - rayToBps[1000000014311592060177012815] = 5704; - rayToBps[1000000014313611213441894123] = 5705; - rayToBps[1000000014315630238143329364] = 5706; - rayToBps[1000000014317649134297689268] = 5707; - rayToBps[1000000014319667901921341438] = 5708; - rayToBps[1000000014321686541030650356] = 5709; - rayToBps[1000000014323705051641977373] = 5710; - rayToBps[1000000014325723433771680719] = 5711; - rayToBps[1000000014327741687436115500] = 5712; - rayToBps[1000000014329759812651633698] = 5713; - rayToBps[1000000014331777809434584175] = 5714; - rayToBps[1000000014333795677801312670] = 5715; - rayToBps[1000000014335813417768161804] = 5716; - rayToBps[1000000014337831029351471077] = 5717; - rayToBps[1000000014339848512567576870] = 5718; - rayToBps[1000000014341865867432812447] = 5719; - rayToBps[1000000014343883093963507953] = 5720; - rayToBps[1000000014345900192175990420] = 5721; - rayToBps[1000000014347917162086583762] = 5722; - rayToBps[1000000014349934003711608778] = 5723; - rayToBps[1000000014351950717067383155] = 5724; - rayToBps[1000000014353967302170221464] = 5725; - rayToBps[1000000014355983759036435166] = 5726; - rayToBps[1000000014358000087682332611] = 5727; - rayToBps[1000000014360016288124219035] = 5728; - rayToBps[1000000014362032360378396567] = 5729; - rayToBps[1000000014364048304461164225] = 5730; - rayToBps[1000000014366064120388817920] = 5731; - rayToBps[1000000014368079808177650454] = 5732; - rayToBps[1000000014370095367843951523] = 5733; - rayToBps[1000000014372110799404007716] = 5734; - rayToBps[1000000014374126102874102518] = 5735; - rayToBps[1000000014376141278270516310] = 5736; - rayToBps[1000000014378156325609526367] = 5737; - rayToBps[1000000014380171244907406862] = 5738; - rayToBps[1000000014382186036180428868] = 5739; - rayToBps[1000000014384200699444860352] = 5740; - rayToBps[1000000014386215234716966187] = 5741; - rayToBps[1000000014388229642013008140] = 5742; - rayToBps[1000000014390243921349244884] = 5743; - rayToBps[1000000014392258072741931989] = 5744; - rayToBps[1000000014394272096207321932] = 5745; - rayToBps[1000000014396285991761664091] = 5746; - rayToBps[1000000014398299759421204750] = 5747; - rayToBps[1000000014400313399202187095] = 5748; - rayToBps[1000000014402326911120851219] = 5749; - rayToBps[1000000014404340295193434124] = 5750; - rayToBps[1000000014406353551436169717] = 5751; - rayToBps[1000000014408366679865288813] = 5752; - rayToBps[1000000014410379680497019136] = 5753; - rayToBps[1000000014412392553347585321] = 5754; - rayToBps[1000000014414405298433208913] = 5755; - rayToBps[1000000014416417915770108367] = 5756; - rayToBps[1000000014418430405374499050] = 5757; - rayToBps[1000000014420442767262593245] = 5758; - rayToBps[1000000014422455001450600144] = 5759; - rayToBps[1000000014424467107954725858] = 5760; - rayToBps[1000000014426479086791173409] = 5761; - rayToBps[1000000014428490937976142739] = 5762; - rayToBps[1000000014430502661525830703] = 5763; - rayToBps[1000000014432514257456431075] = 5764; - rayToBps[1000000014434525725784134548] = 5765; - rayToBps[1000000014436537066525128734] = 5766; - rayToBps[1000000014438548279695598164] = 5767; - rayToBps[1000000014440559365311724289] = 5768; - rayToBps[1000000014442570323389685485] = 5769; - rayToBps[1000000014444581153945657045] = 5770; - rayToBps[1000000014446591856995811191] = 5771; - rayToBps[1000000014448602432556317062] = 5772; - rayToBps[1000000014450612880643340727] = 5773; - rayToBps[1000000014452623201273045178] = 5774; - rayToBps[1000000014454633394461590334] = 5775; - rayToBps[1000000014456643460225133039] = 5776; - rayToBps[1000000014458653398579827068] = 5777; - rayToBps[1000000014460663209541823120] = 5778; - rayToBps[1000000014462672893127268829] = 5779; - rayToBps[1000000014464682449352308754] = 5780; - rayToBps[1000000014466691878233084386] = 5781; - rayToBps[1000000014468701179785734150] = 5782; - rayToBps[1000000014470710354026393400] = 5783; - rayToBps[1000000014472719400971194424] = 5784; - rayToBps[1000000014474728320636266446] = 5785; - rayToBps[1000000014476737113037735623] = 5786; - rayToBps[1000000014478745778191725047] = 5787; - rayToBps[1000000014480754316114354747] = 5788; - rayToBps[1000000014482762726821741689] = 5789; - rayToBps[1000000014484771010329999776] = 5790; - rayToBps[1000000014486779166655239853] = 5791; - rayToBps[1000000014488787195813569697] = 5792; - rayToBps[1000000014490795097821094034] = 5793; - rayToBps[1000000014492802872693914523] = 5794; - rayToBps[1000000014494810520448129771] = 5795; - rayToBps[1000000014496818041099835323] = 5796; - rayToBps[1000000014498825434665123670] = 5797; - rayToBps[1000000014500832701160084244] = 5798; - rayToBps[1000000014502839840600803425] = 5799; - rayToBps[1000000014504846853003364537] = 5800; - rayToBps[1000000014506853738383847849] = 5801; - rayToBps[1000000014508860496758330582] = 5802; - rayToBps[1000000014510867128142886896] = 5803; - rayToBps[1000000014512873632553587910] = 5804; - rayToBps[1000000014514880010006501685] = 5805; - rayToBps[1000000014516886260517693233] = 5806; - rayToBps[1000000014518892384103224522] = 5807; - rayToBps[1000000014520898380779154465] = 5808; - rayToBps[1000000014522904250561538932] = 5809; - rayToBps[1000000014524909993466430745] = 5810; - rayToBps[1000000014526915609509879680] = 5811; - rayToBps[1000000014528921098707932466] = 5812; - rayToBps[1000000014530926461076632791] = 5813; - rayToBps[1000000014532931696632021298] = 5814; - rayToBps[1000000014534936805390135584] = 5815; - rayToBps[1000000014536941787367010209] = 5816; - rayToBps[1000000014538946642578676689] = 5817; - rayToBps[1000000014540951371041163498] = 5818; - rayToBps[1000000014542955972770496074] = 5819; - rayToBps[1000000014544960447782696812] = 5820; - rayToBps[1000000014546964796093785070] = 5821; - rayToBps[1000000014548969017719777170] = 5822; - rayToBps[1000000014550973112676686396] = 5823; - rayToBps[1000000014552977080980522997] = 5824; - rayToBps[1000000014554980922647294184] = 5825; - rayToBps[1000000014556984637693004137] = 5826; - rayToBps[1000000014558988226133654001] = 5827; - rayToBps[1000000014560991687985241886] = 5828; - rayToBps[1000000014562995023263762875] = 5829; - rayToBps[1000000014564998231985209012] = 5830; - rayToBps[1000000014567001314165569320] = 5831; - rayToBps[1000000014569004269820829782] = 5832; - rayToBps[1000000014571007098966973360] = 5833; - rayToBps[1000000014573009801619979984] = 5834; - rayToBps[1000000014575012377795826556] = 5835; - rayToBps[1000000014577014827510486953] = 5836; - rayToBps[1000000014579017150779932024] = 5837; - rayToBps[1000000014581019347620129595] = 5838; - rayToBps[1000000014583021418047044467] = 5839; - rayToBps[1000000014585023362076638415] = 5840; - rayToBps[1000000014587025179724870195] = 5841; - rayToBps[1000000014589026871007695536] = 5842; - rayToBps[1000000014591028435941067149] = 5843; - rayToBps[1000000014593029874540934724] = 5844; - rayToBps[1000000014595031186823244930] = 5845; - rayToBps[1000000014597032372803941418] = 5846; - rayToBps[1000000014599033432498964818] = 5847; - rayToBps[1000000014601034365924252746] = 5848; - rayToBps[1000000014603035173095739799] = 5849; - rayToBps[1000000014605035854029357558] = 5850; - rayToBps[1000000014607036408741034590] = 5851; - rayToBps[1000000014609036837246696444] = 5852; - rayToBps[1000000014611037139562265661] = 5853; - rayToBps[1000000014613037315703661762] = 5854; - rayToBps[1000000014615037365686801262] = 5855; - rayToBps[1000000014617037289527597660] = 5856; - rayToBps[1000000014619037087241961446] = 5857; - rayToBps[1000000014621036758845800100] = 5858; - rayToBps[1000000014623036304355018094] = 5859; - rayToBps[1000000014625035723785516888] = 5860; - rayToBps[1000000014627035017153194937] = 5861; - rayToBps[1000000014629034184473947689] = 5862; - rayToBps[1000000014631033225763667584] = 5863; - rayToBps[1000000014633032141038244058] = 5864; - rayToBps[1000000014635030930313563542] = 5865; - rayToBps[1000000014637029593605509464] = 5866; - rayToBps[1000000014639028130929962246] = 5867; - rayToBps[1000000014641026542302799310] = 5868; - rayToBps[1000000014643024827739895076] = 5869; - rayToBps[1000000014645022987257120962] = 5870; - rayToBps[1000000014647021020870345387] = 5871; - rayToBps[1000000014649018928595433770] = 5872; - rayToBps[1000000014651016710448248531] = 5873; - rayToBps[1000000014653014366444649093] = 5874; - rayToBps[1000000014655011896600491882] = 5875; - rayToBps[1000000014657009300931630326] = 5876; - rayToBps[1000000014659006579453914859] = 5877; - rayToBps[1000000014661003732183192919] = 5878; - rayToBps[1000000014663000759135308949] = 5879; - rayToBps[1000000014664997660326104403] = 5880; - rayToBps[1000000014666994435771417736] = 5881; - rayToBps[1000000014668991085487084417] = 5882; - rayToBps[1000000014670987609488936922] = 5883; - rayToBps[1000000014672984007792804732] = 5884; - rayToBps[1000000014674980280414514346] = 5885; - rayToBps[1000000014676976427369889269] = 5886; - rayToBps[1000000014678972448674750021] = 5887; - rayToBps[1000000014680968344344914131] = 5888; - rayToBps[1000000014682964114396196144] = 5889; - rayToBps[1000000014684959758844407618] = 5890; - rayToBps[1000000014686955277705357128] = 5891; - rayToBps[1000000014688950670994850263] = 5892; - rayToBps[1000000014690945938728689628] = 5893; - rayToBps[1000000014692941080922674845] = 5894; - rayToBps[1000000014694936097592602556] = 5895; - rayToBps[1000000014696930988754266420] = 5896; - rayToBps[1000000014698925754423457115] = 5897; - rayToBps[1000000014700920394615962341] = 5898; - rayToBps[1000000014702914909347566817] = 5899; - rayToBps[1000000014704909298634052283] = 5900; - rayToBps[1000000014706903562491197505] = 5901; - rayToBps[1000000014708897700934778270] = 5902; - rayToBps[1000000014710891713980567389] = 5903; - rayToBps[1000000014712885601644334694] = 5904; - rayToBps[1000000014714879363941847051] = 5905; - rayToBps[1000000014716873000888868344] = 5906; - rayToBps[1000000014718866512501159488] = 5907; - rayToBps[1000000014720859898794478424] = 5908; - rayToBps[1000000014722853159784580123] = 5909; - rayToBps[1000000014724846295487216583] = 5910; - rayToBps[1000000014726839305918136834] = 5911; - rayToBps[1000000014728832191093086935] = 5912; - rayToBps[1000000014730824951027809978] = 5913; - rayToBps[1000000014732817585738046086] = 5914; - rayToBps[1000000014734810095239532414] = 5915; - rayToBps[1000000014736802479548003151] = 5916; - rayToBps[1000000014738794738679189525] = 5917; - rayToBps[1000000014740786872648819790] = 5918; - rayToBps[1000000014742778881472619245] = 5919; - rayToBps[1000000014744770765166310220] = 5920; - rayToBps[1000000014746762523745612083] = 5921; - rayToBps[1000000014748754157226241244] = 5922; - rayToBps[1000000014750745665623911146] = 5923; - rayToBps[1000000014752737048954332275] = 5924; - rayToBps[1000000014754728307233212158] = 5925; - rayToBps[1000000014756719440476255360] = 5926; - rayToBps[1000000014758710448699163491] = 5927; - rayToBps[1000000014760701331917635202] = 5928; - rayToBps[1000000014762692090147366186] = 5929; - rayToBps[1000000014764682723404049184] = 5930; - rayToBps[1000000014766673231703373978] = 5931; - rayToBps[1000000014768663615061027396] = 5932; - rayToBps[1000000014770653873492693314] = 5933; - rayToBps[1000000014772644007014052654] = 5934; - rayToBps[1000000014774634015640783386] = 5935; - rayToBps[1000000014776623899388560526] = 5936; - rayToBps[1000000014778613658273056145] = 5937; - rayToBps[1000000014780603292309939358] = 5938; - rayToBps[1000000014782592801514876334] = 5939; - rayToBps[1000000014784582185903530293] = 5940; - rayToBps[1000000014786571445491561506] = 5941; - rayToBps[1000000014788560580294627298] = 5942; - rayToBps[1000000014790549590328382048] = 5943; - rayToBps[1000000014792538475608477188] = 5944; - rayToBps[1000000014794527236150561205] = 5945; - rayToBps[1000000014796515871970279644] = 5946; - rayToBps[1000000014798504383083275106] = 5947; - rayToBps[1000000014800492769505187248] = 5948; - rayToBps[1000000014802481031251652786] = 5949; - rayToBps[1000000014804469168338305494] = 5950; - rayToBps[1000000014806457180780776207] = 5951; - rayToBps[1000000014808445068594692819] = 5952; - rayToBps[1000000014810432831795680286] = 5953; - rayToBps[1000000014812420470399360626] = 5954; - rayToBps[1000000014814407984421352919] = 5955; - rayToBps[1000000014816395373877273307] = 5956; - rayToBps[1000000014818382638782734998] = 5957; - rayToBps[1000000014820369779153348262] = 5958; - rayToBps[1000000014822356795004720439] = 5959; - rayToBps[1000000014824343686352455932] = 5960; - rayToBps[1000000014826330453212156210] = 5961; - rayToBps[1000000014828317095599419813] = 5962; - rayToBps[1000000014830303613529842346] = 5963; - rayToBps[1000000014832290007019016486] = 5964; - rayToBps[1000000014834276276082531977] = 5965; - rayToBps[1000000014836262420735975636] = 5966; - rayToBps[1000000014838248440994931352] = 5967; - rayToBps[1000000014840234336874980083] = 5968; - rayToBps[1000000014842220108391699861] = 5969; - rayToBps[1000000014844205755560665792] = 5970; - rayToBps[1000000014846191278397450058] = 5971; - rayToBps[1000000014848176676917621912] = 5972; - rayToBps[1000000014850161951136747686] = 5973; - rayToBps[1000000014852147101070390787] = 5974; - rayToBps[1000000014854132126734111701] = 5975; - rayToBps[1000000014856117028143467990] = 5976; - rayToBps[1000000014858101805314014293] = 5977; - rayToBps[1000000014860086458261302333] = 5978; - rayToBps[1000000014862070987000880911] = 5979; - rayToBps[1000000014864055391548295906] = 5980; - rayToBps[1000000014866039671919090284] = 5981; - rayToBps[1000000014868023828128804090] = 5982; - rayToBps[1000000014870007860192974452] = 5983; - rayToBps[1000000014871991768127135581] = 5984; - rayToBps[1000000014873975551946818776] = 5985; - rayToBps[1000000014875959211667552419] = 5986; - rayToBps[1000000014877942747304861976] = 5987; - rayToBps[1000000014879926158874270004] = 5988; - rayToBps[1000000014881909446391296144] = 5989; - rayToBps[1000000014883892609871457128] = 5990; - rayToBps[1000000014885875649330266773] = 5991; - rayToBps[1000000014887858564783235989] = 5992; - rayToBps[1000000014889841356245872775] = 5993; - rayToBps[1000000014891824023733682222] = 5994; - rayToBps[1000000014893806567262166511] = 5995; - rayToBps[1000000014895788986846824917] = 5996; - rayToBps[1000000014897771282503153808] = 5997; - rayToBps[1000000014899753454246646646] = 5998; - rayToBps[1000000014901735502092793986] = 5999; - rayToBps[1000000014903717426057083481] = 6000; - rayToBps[1000000014905699226154999880] = 6001; - rayToBps[1000000014907680902402025027] = 6002; - rayToBps[1000000014909662454813637865] = 6003; - rayToBps[1000000014911643883405314435] = 6004; - rayToBps[1000000014913625188192527876] = 6005; - rayToBps[1000000014915606369190748429] = 6006; - rayToBps[1000000014917587426415443433] = 6007; - rayToBps[1000000014919568359882077330] = 6008; - rayToBps[1000000014921549169606111665] = 6009; - rayToBps[1000000014923529855603005082] = 6010; - rayToBps[1000000014925510417888213331] = 6011; - rayToBps[1000000014927490856477189267] = 6012; - rayToBps[1000000014929471171385382847] = 6013; - rayToBps[1000000014931451362628241136] = 6014; - rayToBps[1000000014933431430221208304] = 6015; - rayToBps[1000000014935411374179725629] = 6016; - rayToBps[1000000014937391194519231495] = 6017; - rayToBps[1000000014939370891255161396] = 6018; - rayToBps[1000000014941350464402947936] = 6019; - rayToBps[1000000014943329913978020826] = 6020; - rayToBps[1000000014945309239995806891] = 6021; - rayToBps[1000000014947288442471730065] = 6022; - rayToBps[1000000014949267521421211394] = 6023; - rayToBps[1000000014951246476859669038] = 6024; - rayToBps[1000000014953225308802518272] = 6025; - rayToBps[1000000014955204017265171481] = 6026; - rayToBps[1000000014957182602263038168] = 6027; - rayToBps[1000000014959161063811524950] = 6028; - rayToBps[1000000014961139401926035563] = 6029; - rayToBps[1000000014963117616621970858] = 6030; - rayToBps[1000000014965095707914728804] = 6031; - rayToBps[1000000014967073675819704489] = 6032; - rayToBps[1000000014969051520352290120] = 6033; - rayToBps[1000000014971029241527875024] = 6034; - rayToBps[1000000014973006839361845649] = 6035; - rayToBps[1000000014974984313869585565] = 6036; - rayToBps[1000000014976961665066475462] = 6037; - rayToBps[1000000014978938892967893156] = 6038; - rayToBps[1000000014980915997589213583] = 6039; - rayToBps[1000000014982892978945808807] = 6040; - rayToBps[1000000014984869837053048013] = 6041; - rayToBps[1000000014986846571926297515] = 6042; - rayToBps[1000000014988823183580920752] = 6043; - rayToBps[1000000014990799672032278292] = 6044; - rayToBps[1000000014992776037295727828] = 6045; - rayToBps[1000000014994752279386624184] = 6046; - rayToBps[1000000014996728398320319311] = 6047; - rayToBps[1000000014998704394112162292] = 6048; - rayToBps[1000000015000680266777499339] = 6049; - rayToBps[1000000015002656016331673799] = 6050; - rayToBps[1000000015004631642790026146] = 6051; - rayToBps[1000000015006607146167893992] = 6052; - rayToBps[1000000015008582526480612079] = 6053; - rayToBps[1000000015010557783743512285] = 6054; - rayToBps[1000000015012532917971923621] = 6055; - rayToBps[1000000015014507929181172237] = 6056; - rayToBps[1000000015016482817386581417] = 6057; - rayToBps[1000000015018457582603471584] = 6058; - rayToBps[1000000015020432224847160297] = 6059; - rayToBps[1000000015022406744132962253] = 6060; - rayToBps[1000000015024381140476189292] = 6061; - rayToBps[1000000015026355413892150391] = 6062; - rayToBps[1000000015028329564396151668] = 6063; - rayToBps[1000000015030303592003496384] = 6064; - rayToBps[1000000015032277496729484940] = 6065; - rayToBps[1000000015034251278589414882] = 6066; - rayToBps[1000000015036224937598580896] = 6067; - rayToBps[1000000015038198473772274819] = 6068; - rayToBps[1000000015040171887125785626] = 6069; - rayToBps[1000000015042145177674399441] = 6070; - rayToBps[1000000015044118345433399534] = 6071; - rayToBps[1000000015046091390418066323] = 6072; - rayToBps[1000000015048064312643677371] = 6073; - rayToBps[1000000015050037112125507393] = 6074; - rayToBps[1000000015052009788878828253] = 6075; - rayToBps[1000000015053982342918908961] = 6076; - rayToBps[1000000015055954774261015682] = 6077; - rayToBps[1000000015057927082920411731] = 6078; - rayToBps[1000000015059899268912357574] = 6079; - rayToBps[1000000015061871332252110832] = 6080; - rayToBps[1000000015063843272954926277] = 6081; - rayToBps[1000000015065815091036055837] = 6082; - rayToBps[1000000015067786786510748595] = 6083; - rayToBps[1000000015069758359394250789] = 6084; - rayToBps[1000000015071729809701805813] = 6085; - rayToBps[1000000015073701137448654217] = 6086; - rayToBps[1000000015075672342650033713] = 6087; - rayToBps[1000000015077643425321179167] = 6088; - rayToBps[1000000015079614385477322606] = 6089; - rayToBps[1000000015081585223133693217] = 6090; - rayToBps[1000000015083555938305517348] = 6091; - rayToBps[1000000015085526531008018506] = 6092; - rayToBps[1000000015087497001256417364] = 6093; - rayToBps[1000000015089467349065931754] = 6094; - rayToBps[1000000015091437574451776672] = 6095; - rayToBps[1000000015093407677429164279] = 6096; - rayToBps[1000000015095377658013303902] = 6097; - rayToBps[1000000015097347516219402031] = 6098; - rayToBps[1000000015099317252062662325] = 6099; - rayToBps[1000000015101286865558285606] = 6100; - rayToBps[1000000015103256356721469870] = 6101; - rayToBps[1000000015105225725567410272] = 6102; - rayToBps[1000000015107194972111299145] = 6103; - rayToBps[1000000015109164096368325987] = 6104; - rayToBps[1000000015111133098353677468] = 6105; - rayToBps[1000000015113101978082537430] = 6106; - rayToBps[1000000015115070735570086883] = 6107; - rayToBps[1000000015117039370831504013] = 6108; - rayToBps[1000000015119007883881964179] = 6109; - rayToBps[1000000015120976274736639914] = 6110; - rayToBps[1000000015122944543410700923] = 6111; - rayToBps[1000000015124912689919314090] = 6112; - rayToBps[1000000015126880714277643473] = 6113; - rayToBps[1000000015128848616500850307] = 6114; - rayToBps[1000000015130816396604093005] = 6115; - rayToBps[1000000015132784054602527158] = 6116; - rayToBps[1000000015134751590511305536] = 6117; - rayToBps[1000000015136719004345578088] = 6118; - rayToBps[1000000015138686296120491942] = 6119; - rayToBps[1000000015140653465851191411] = 6120; - rayToBps[1000000015142620513552817987] = 6121; - rayToBps[1000000015144587439240510342] = 6122; - rayToBps[1000000015146554242929404336] = 6123; - rayToBps[1000000015148520924634633011] = 6124; - rayToBps[1000000015150487484371326590] = 6125; - rayToBps[1000000015152453922154612487] = 6126; - rayToBps[1000000015154420237999615297] = 6127; - rayToBps[1000000015156386431921456805] = 6128; - rayToBps[1000000015158352503935255979] = 6129; - rayToBps[1000000015160318454056128981] = 6130; - rayToBps[1000000015162284282299189156] = 6131; - rayToBps[1000000015164249988679547042] = 6132; - rayToBps[1000000015166215573212310364] = 6133; - rayToBps[1000000015168181035912584041] = 6134; - rayToBps[1000000015170146376795470181] = 6135; - rayToBps[1000000015172111595876068086] = 6136; - rayToBps[1000000015174076693169474249] = 6137; - rayToBps[1000000015176041668690782357] = 6138; - rayToBps[1000000015178006522455083294] = 6139; - rayToBps[1000000015179971254477465133] = 6140; - rayToBps[1000000015181935864773013148] = 6141; - rayToBps[1000000015183900353356809808] = 6142; - rayToBps[1000000015185864720243934777] = 6143; - rayToBps[1000000015187828965449464919] = 6144; - rayToBps[1000000015189793088988474295] = 6145; - rayToBps[1000000015191757090876034166] = 6146; - rayToBps[1000000015193720971127212993] = 6147; - rayToBps[1000000015195684729757076435] = 6148; - rayToBps[1000000015197648366780687356] = 6149; - rayToBps[1000000015199611882213105818] = 6150; - rayToBps[1000000015201575276069389089] = 6151; - rayToBps[1000000015203538548364591637] = 6152; - rayToBps[1000000015205501699113765138] = 6153; - rayToBps[1000000015207464728331958468] = 6154; - rayToBps[1000000015209427636034217712] = 6155; - rayToBps[1000000015211390422235586158] = 6156; - rayToBps[1000000015213353086951104304] = 6157; - rayToBps[1000000015215315630195809853] = 6158; - rayToBps[1000000015217278051984737717] = 6159; - rayToBps[1000000015219240352332920015] = 6160; - rayToBps[1000000015221202531255386080] = 6161; - rayToBps[1000000015223164588767162449] = 6162; - rayToBps[1000000015225126524883272874] = 6163; - rayToBps[1000000015227088339618738319] = 6164; - rayToBps[1000000015229050032988576957] = 6165; - rayToBps[1000000015231011605007804177] = 6166; - rayToBps[1000000015232973055691432580] = 6167; - rayToBps[1000000015234934385054471980] = 6168; - rayToBps[1000000015236895593111929410] = 6169; - rayToBps[1000000015238856679878809116] = 6170; - rayToBps[1000000015240817645370112558] = 6171; - rayToBps[1000000015242778489600838420] = 6172; - rayToBps[1000000015244739212585982595] = 6173; - rayToBps[1000000015246699814340538201] = 6174; - rayToBps[1000000015248660294879495575] = 6175; - rayToBps[1000000015250620654217842268] = 6176; - rayToBps[1000000015252580892370563058] = 6177; - rayToBps[1000000015254541009352639939] = 6178; - rayToBps[1000000015256501005179052132] = 6179; - rayToBps[1000000015258460879864776078] = 6180; - rayToBps[1000000015260420633424785438] = 6181; - rayToBps[1000000015262380265874051103] = 6182; - rayToBps[1000000015264339777227541185] = 6183; - rayToBps[1000000015266299167500221022] = 6184; - rayToBps[1000000015268258436707053177] = 6185; - rayToBps[1000000015270217584862997442] = 6186; - rayToBps[1000000015272176611983010835] = 6187; - rayToBps[1000000015274135518082047600] = 6188; - rayToBps[1000000015276094303175059215] = 6189; - rayToBps[1000000015278052967276994381] = 6190; - rayToBps[1000000015280011510402799035] = 6191; - rayToBps[1000000015281969932567416340] = 6192; - rayToBps[1000000015283928233785786694] = 6193; - rayToBps[1000000015285886414072847725] = 6194; - rayToBps[1000000015287844473443534295] = 6195; - rayToBps[1000000015289802411912778498] = 6196; - rayToBps[1000000015291760229495509665] = 6197; - rayToBps[1000000015293717926206654358] = 6198; - rayToBps[1000000015295675502061136378] = 6199; - rayToBps[1000000015297632957073876761] = 6200; - rayToBps[1000000015299590291259793780] = 6201; - rayToBps[1000000015301547504633802945] = 6202; - rayToBps[1000000015303504597210817004] = 6203; - rayToBps[1000000015305461569005745947] = 6204; - rayToBps[1000000015307418420033496998] = 6205; - rayToBps[1000000015309375150308974628] = 6206; - rayToBps[1000000015311331759847080545] = 6207; - rayToBps[1000000015313288248662713699] = 6208; - rayToBps[1000000015315244616770770282] = 6209; - rayToBps[1000000015317200864186143732] = 6210; - rayToBps[1000000015319156990923724726] = 6211; - rayToBps[1000000015321112996998401190] = 6212; - rayToBps[1000000015323068882425058294] = 6213; - rayToBps[1000000015325024647218578451] = 6214; - rayToBps[1000000015326980291393841323] = 6215; - rayToBps[1000000015328935814965723819] = 6216; - rayToBps[1000000015330891217949100095] = 6217; - rayToBps[1000000015332846500358841555] = 6218; - rayToBps[1000000015334801662209816855] = 6219; - rayToBps[1000000015336756703516891898] = 6220; - rayToBps[1000000015338711624294929839] = 6221; - rayToBps[1000000015340666424558791082] = 6222; - rayToBps[1000000015342621104323333287] = 6223; - rayToBps[1000000015344575663603411362] = 6224; - rayToBps[1000000015346530102413877471] = 6225; - rayToBps[1000000015348484420769581033] = 6226; - rayToBps[1000000015350438618685368717] = 6227; - rayToBps[1000000015352392696176084451] = 6228; - rayToBps[1000000015354346653256569420] = 6229; - rayToBps[1000000015356300489941662062] = 6230; - rayToBps[1000000015358254206246198075] = 6231; - rayToBps[1000000015360207802185010413] = 6232; - rayToBps[1000000015362161277772929290] = 6233; - rayToBps[1000000015364114633024782180] = 6234; - rayToBps[1000000015366067867955393814] = 6235; - rayToBps[1000000015368020982579586188] = 6236; - rayToBps[1000000015369973976912178557] = 6237; - rayToBps[1000000015371926850967987435] = 6238; - rayToBps[1000000015373879604761826606] = 6239; - rayToBps[1000000015375832238308507110] = 6240; - rayToBps[1000000015377784751622837256] = 6241; - rayToBps[1000000015379737144719622615] = 6242; - rayToBps[1000000015381689417613666024] = 6243; - rayToBps[1000000015383641570319767589] = 6244; - rayToBps[1000000015385593602852724678] = 6245; - rayToBps[1000000015387545515227331928] = 6246; - rayToBps[1000000015389497307458381246] = 6247; - rayToBps[1000000015391448979560661806] = 6248; - rayToBps[1000000015393400531548960052] = 6249; - rayToBps[1000000015395351963438059699] = 6250; - rayToBps[1000000015397303275242741731] = 6251; - rayToBps[1000000015399254466977784403] = 6252; - rayToBps[1000000015401205538657963245] = 6253; - rayToBps[1000000015403156490298051058] = 6254; - rayToBps[1000000015405107321912817917] = 6255; - rayToBps[1000000015407058033517031169] = 6256; - rayToBps[1000000015409008625125455440] = 6257; - rayToBps[1000000015410959096752852627] = 6258; - rayToBps[1000000015412909448413981907] = 6259; - rayToBps[1000000015414859680123599731] = 6260; - rayToBps[1000000015416809791896459828] = 6261; - rayToBps[1000000015418759783747313206] = 6262; - rayToBps[1000000015420709655690908154] = 6263; - rayToBps[1000000015422659407741990234] = 6264; - rayToBps[1000000015424609039915302295] = 6265; - rayToBps[1000000015426558552225584464] = 6266; - rayToBps[1000000015428507944687574148] = 6267; - rayToBps[1000000015430457217316006040] = 6268; - rayToBps[1000000015432406370125612111] = 6269; - rayToBps[1000000015434355403131121619] = 6270; - rayToBps[1000000015436304316347261106] = 6271; - rayToBps[1000000015438253109788754397] = 6272; - rayToBps[1000000015440201783470322605] = 6273; - rayToBps[1000000015442150337406684127] = 6274; - rayToBps[1000000015444098771612554646] = 6275; - rayToBps[1000000015446047086102647137] = 6276; - rayToBps[1000000015447995280891671860] = 6277; - rayToBps[1000000015449943355994336362] = 6278; - rayToBps[1000000015451891311425345484] = 6279; - rayToBps[1000000015453839147199401353] = 6280; - rayToBps[1000000015455786863331203391] = 6281; - rayToBps[1000000015457734459835448307] = 6282; - rayToBps[1000000015459681936726830105] = 6283; - rayToBps[1000000015461629294020040082] = 6284; - rayToBps[1000000015463576531729766828] = 6285; - rayToBps[1000000015465523649870696226] = 6286; - rayToBps[1000000015467470648457511454] = 6287; - rayToBps[1000000015469417527504892989] = 6288; - rayToBps[1000000015471364287027518599] = 6289; - rayToBps[1000000015473310927040063352] = 6290; - rayToBps[1000000015475257447557199613] = 6291; - rayToBps[1000000015477203848593597045] = 6292; - rayToBps[1000000015479150130163922609] = 6293; - rayToBps[1000000015481096292282840567] = 6294; - rayToBps[1000000015483042334965012479] = 6295; - rayToBps[1000000015484988258225097210] = 6296; - rayToBps[1000000015486934062077750921] = 6297; - rayToBps[1000000015488879746537627079] = 6298; - rayToBps[1000000015490825311619376452] = 6299; - rayToBps[1000000015492770757337647112] = 6300; - rayToBps[1000000015494716083707084436] = 6301; - rayToBps[1000000015496661290742331104] = 6302; - rayToBps[1000000015498606378458027103] = 6303; - rayToBps[1000000015500551346868809725] = 6304; - rayToBps[1000000015502496195989313568] = 6305; - rayToBps[1000000015504440925834170541] = 6306; - rayToBps[1000000015506385536418009859] = 6307; - rayToBps[1000000015508330027755458043] = 6308; - rayToBps[1000000015510274399861138927] = 6309; - rayToBps[1000000015512218652749673656] = 6310; - rayToBps[1000000015514162786435680680] = 6311; - rayToBps[1000000015516106800933775766] = 6312; - rayToBps[1000000015518050696258571992] = 6313; - rayToBps[1000000015519994472424679745] = 6314; - rayToBps[1000000015521938129446706731] = 6315; - rayToBps[1000000015523881667339257966] = 6316; - rayToBps[1000000015525825086116935783] = 6317; - rayToBps[1000000015527768385794339827] = 6318; - rayToBps[1000000015529711566386067064] = 6319; - rayToBps[1000000015531654627906711771] = 6320; - rayToBps[1000000015533597570370865546] = 6321; - rayToBps[1000000015535540393793117305] = 6322; - rayToBps[1000000015537483098188053282] = 6323; - rayToBps[1000000015539425683570257029] = 6324; - rayToBps[1000000015541368149954309419] = 6325; - rayToBps[1000000015543310497354788646] = 6326; - rayToBps[1000000015545252725786270226] = 6327; - rayToBps[1000000015547194835263326993] = 6328; - rayToBps[1000000015549136825800529108] = 6329; - rayToBps[1000000015551078697412444053] = 6330; - rayToBps[1000000015553020450113636636] = 6331; - rayToBps[1000000015554962083918668986] = 6332; - rayToBps[1000000015556903598842100559] = 6333; - rayToBps[1000000015558844994898488139] = 6334; - rayToBps[1000000015560786272102385832] = 6335; - rayToBps[1000000015562727430468345075] = 6336; - rayToBps[1000000015564668470010914631] = 6337; - rayToBps[1000000015566609390744640592] = 6338; - rayToBps[1000000015568550192684066380] = 6339; - rayToBps[1000000015570490875843732744] = 6340; - rayToBps[1000000015572431440238177765] = 6341; - rayToBps[1000000015574371885881936857] = 6342; - rayToBps[1000000015576312212789542763] = 6343; - rayToBps[1000000015578252420975525559] = 6344; - rayToBps[1000000015580192510454412655] = 6345; - rayToBps[1000000015582132481240728794] = 6346; - rayToBps[1000000015584072333348996053] = 6347; - rayToBps[1000000015586012066793733846] = 6348; - rayToBps[1000000015587951681589458919] = 6349; - rayToBps[1000000015589891177750685357] = 6350; - rayToBps[1000000015591830555291924580] = 6351; - rayToBps[1000000015593769814227685350] = 6352; - rayToBps[1000000015595708954572473762] = 6353; - rayToBps[1000000015597647976340793253] = 6354; - rayToBps[1000000015599586879547144596] = 6355; - rayToBps[1000000015601525664206025911] = 6356; - rayToBps[1000000015603464330331932651] = 6357; - rayToBps[1000000015605402877939357616] = 6358; - rayToBps[1000000015607341307042790947] = 6359; - rayToBps[1000000015609279617656720124] = 6360; - rayToBps[1000000015611217809795629977] = 6361; - rayToBps[1000000015613155883474002675] = 6362; - rayToBps[1000000015615093838706317732] = 6363; - rayToBps[1000000015617031675507052012] = 6364; - rayToBps[1000000015618969393890679720] = 6365; - rayToBps[1000000015620906993871672410] = 6366; - rayToBps[1000000015622844475464498982] = 6367; - rayToBps[1000000015624781838683625685] = 6368; - rayToBps[1000000015626719083543516119] = 6369; - rayToBps[1000000015628656210058631227] = 6370; - rayToBps[1000000015630593218243429309] = 6371; - rayToBps[1000000015632530108112366010] = 6372; - rayToBps[1000000015634466879679894331] = 6373; - rayToBps[1000000015636403532960464619] = 6374; - rayToBps[1000000015638340067968524580] = 6375; - rayToBps[1000000015640276484718519269] = 6376; - rayToBps[1000000015642212783224891098] = 6377; - rayToBps[1000000015644148963502079827] = 6378; - rayToBps[1000000015646085025564522580] = 6379; - rayToBps[1000000015648020969426653830] = 6380; - rayToBps[1000000015649956795102905409] = 6381; - rayToBps[1000000015651892502607706506] = 6382; - rayToBps[1000000015653828091955483667] = 6383; - rayToBps[1000000015655763563160660798] = 6384; - rayToBps[1000000015657698916237659162] = 6385; - rayToBps[1000000015659634151200897382] = 6386; - rayToBps[1000000015661569268064791442] = 6387; - rayToBps[1000000015663504266843754688] = 6388; - rayToBps[1000000015665439147552197824] = 6389; - rayToBps[1000000015667373910204528920] = 6390; - rayToBps[1000000015669308554815153405] = 6391; - rayToBps[1000000015671243081398474077] = 6392; - rayToBps[1000000015673177489968891092] = 6393; - rayToBps[1000000015675111780540801975] = 6394; - rayToBps[1000000015677045953128601614] = 6395; - rayToBps[1000000015678980007746682266] = 6396; - rayToBps[1000000015680913944409433552] = 6397; - rayToBps[1000000015682847763131242461] = 6398; - rayToBps[1000000015684781463926493350] = 6399; - rayToBps[1000000015686715046809567945] = 6400; - rayToBps[1000000015688648511794845341] = 6401; - rayToBps[1000000015690581858896702002] = 6402; - rayToBps[1000000015692515088129511766] = 6403; - rayToBps[1000000015694448199507645837] = 6404; - rayToBps[1000000015696381193045472797] = 6405; - rayToBps[1000000015698314068757358594] = 6406; - rayToBps[1000000015700246826657666553] = 6407; - rayToBps[1000000015702179466760757373] = 6408; - rayToBps[1000000015704111989080989125] = 6409; - rayToBps[1000000015706044393632717258] = 6410; - rayToBps[1000000015707976680430294594] = 6411; - rayToBps[1000000015709908849488071333] = 6412; - rayToBps[1000000015711840900820395051] = 6413; - rayToBps[1000000015713772834441610701] = 6414; - rayToBps[1000000015715704650366060617] = 6415; - rayToBps[1000000015717636348608084511] = 6416; - rayToBps[1000000015719567929182019470] = 6417; - rayToBps[1000000015721499392102199968] = 6418; - rayToBps[1000000015723430737382957855] = 6419; - rayToBps[1000000015725361965038622365] = 6420; - rayToBps[1000000015727293075083520113] = 6421; - rayToBps[1000000015729224067531975096] = 6422; - rayToBps[1000000015731154942398308695] = 6423; - rayToBps[1000000015733085699696839676] = 6424; - rayToBps[1000000015735016339441884188] = 6425; - rayToBps[1000000015736946861647755768] = 6426; - rayToBps[1000000015738877266328765334] = 6427; - rayToBps[1000000015740807553499221196] = 6428; - rayToBps[1000000015742737723173429047] = 6429; - rayToBps[1000000015744667775365691970] = 6430; - rayToBps[1000000015746597710090310436] = 6431; - rayToBps[1000000015748527527361582305] = 6432; - rayToBps[1000000015750457227193802825] = 6433; - rayToBps[1000000015752386809601264637] = 6434; - rayToBps[1000000015754316274598257774] = 6435; - rayToBps[1000000015756245622199069656] = 6436; - rayToBps[1000000015758174852417985099] = 6437; - rayToBps[1000000015760103965269286310] = 6438; - rayToBps[1000000015762032960767252891] = 6439; - rayToBps[1000000015763961838926161836] = 6440; - rayToBps[1000000015765890599760287538] = 6441; - rayToBps[1000000015767819243283901779] = 6442; - rayToBps[1000000015769747769511273744] = 6443; - rayToBps[1000000015771676178456670009] = 6444; - rayToBps[1000000015773604470134354550] = 6445; - rayToBps[1000000015775532644558588743] = 6446; - rayToBps[1000000015777460701743631357] = 6447; - rayToBps[1000000015779388641703738565] = 6448; - rayToBps[1000000015781316464453163938] = 6449; - rayToBps[1000000015783244170006158447] = 6450; - rayToBps[1000000015785171758376970467] = 6451; - rayToBps[1000000015787099229579845770] = 6452; - rayToBps[1000000015789026583629027536] = 6453; - rayToBps[1000000015790953820538756342] = 6454; - rayToBps[1000000015792880940323270174] = 6455; - rayToBps[1000000015794807942996804419] = 6456; - rayToBps[1000000015796734828573591870] = 6457; - rayToBps[1000000015798661597067862724] = 6458; - rayToBps[1000000015800588248493844588] = 6459; - rayToBps[1000000015802514782865762472] = 6460; - rayToBps[1000000015804441200197838795] = 6461; - rayToBps[1000000015806367500504293384] = 6462; - rayToBps[1000000015808293683799343474] = 6463; - rayToBps[1000000015810219750097203710] = 6464; - rayToBps[1000000015812145699412086147] = 6465; - rayToBps[1000000015814071531758200252] = 6466; - rayToBps[1000000015815997247149752899] = 6467; - rayToBps[1000000015817922845600948377] = 6468; - rayToBps[1000000015819848327125988387] = 6469; - rayToBps[1000000015821773691739072044] = 6470; - rayToBps[1000000015823698939454395875] = 6471; - rayToBps[1000000015825624070286153821] = 6472; - rayToBps[1000000015827549084248537241] = 6473; - rayToBps[1000000015829473981355734906] = 6474; - rayToBps[1000000015831398761621933006] = 6475; - rayToBps[1000000015833323425061315145] = 6476; - rayToBps[1000000015835247971688062347] = 6477; - rayToBps[1000000015837172401516353055] = 6478; - rayToBps[1000000015839096714560363128] = 6479; - rayToBps[1000000015841020910834265843] = 6480; - rayToBps[1000000015842944990352231903] = 6481; - rayToBps[1000000015844868953128429425] = 6482; - rayToBps[1000000015846792799177023953] = 6483; - rayToBps[1000000015848716528512178448] = 6484; - rayToBps[1000000015850640141148053296] = 6485; - rayToBps[1000000015852563637098806307] = 6486; - rayToBps[1000000015854487016378592712] = 6487; - rayToBps[1000000015856410279001565169] = 6488; - rayToBps[1000000015858333424981873758] = 6489; - rayToBps[1000000015860256454333665989] = 6490; - rayToBps[1000000015862179367071086794] = 6491; - rayToBps[1000000015864102163208278534] = 6492; - rayToBps[1000000015866024842759380997] = 6493; - rayToBps[1000000015867947405738531398] = 6494; - rayToBps[1000000015869869852159864384] = 6495; - rayToBps[1000000015871792182037512030] = 6496; - rayToBps[1000000015873714395385603836] = 6497; - rayToBps[1000000015875636492218266741] = 6498; - rayToBps[1000000015877558472549625110] = 6499; - rayToBps[1000000015879480336393800741] = 6500; - rayToBps[1000000015881402083764912862] = 6501; - rayToBps[1000000015883323714677078140] = 6502; - rayToBps[1000000015885245229144410671] = 6503; - rayToBps[1000000015887166627181021987] = 6504; - rayToBps[1000000015889087908801021053] = 6505; - rayToBps[1000000015891009074018514273] = 6506; - rayToBps[1000000015892930122847605485] = 6507; - rayToBps[1000000015894851055302395963] = 6508; - rayToBps[1000000015896771871396984421] = 6509; - rayToBps[1000000015898692571145467010] = 6510; - rayToBps[1000000015900613154561937317] = 6511; - rayToBps[1000000015902533621660486374] = 6512; - rayToBps[1000000015904453972455202647] = 6513; - rayToBps[1000000015906374206960172047] = 6514; - rayToBps[1000000015908294325189477924] = 6515; - rayToBps[1000000015910214327157201069] = 6516; - rayToBps[1000000015912134212877419719] = 6517; - rayToBps[1000000015914053982364209549] = 6518; - rayToBps[1000000015915973635631643682] = 6519; - rayToBps[1000000015917893172693792683] = 6520; - rayToBps[1000000015919812593564724562] = 6521; - rayToBps[1000000015921731898258504776] = 6522; - rayToBps[1000000015923651086789196227] = 6523; - rayToBps[1000000015925570159170859262] = 6524; - rayToBps[1000000015927489115417551681] = 6525; - rayToBps[1000000015929407955543328724] = 6526; - rayToBps[1000000015931326679562243086] = 6527; - rayToBps[1000000015933245287488344910] = 6528; - rayToBps[1000000015935163779335681785] = 6529; - rayToBps[1000000015937082155118298755] = 6530; - rayToBps[1000000015939000414850238313] = 6531; - rayToBps[1000000015940918558545540404] = 6532; - rayToBps[1000000015942836586218242426] = 6533; - rayToBps[1000000015944754497882379228] = 6534; - rayToBps[1000000015946672293551983115] = 6535; - rayToBps[1000000015948589973241083845] = 6536; - rayToBps[1000000015950507536963708629] = 6537; - rayToBps[1000000015952424984733882136] = 6538; - rayToBps[1000000015954342316565626492] = 6539; - rayToBps[1000000015956259532472961274] = 6540; - rayToBps[1000000015958176632469903523] = 6541; - rayToBps[1000000015960093616570467734] = 6542; - rayToBps[1000000015962010484788665860] = 6543; - rayToBps[1000000015963927237138507317] = 6544; - rayToBps[1000000015965843873633998974] = 6545; - rayToBps[1000000015967760394289145167] = 6546; - rayToBps[1000000015969676799117947690] = 6547; - rayToBps[1000000015971593088134405798] = 6548; - rayToBps[1000000015973509261352516209] = 6549; - rayToBps[1000000015975425318786273105] = 6550; - rayToBps[1000000015977341260449668127] = 6551; - rayToBps[1000000015979257086356690385] = 6552; - rayToBps[1000000015981172796521326452] = 6553; - rayToBps[1000000015983088390957560365] = 6554; - rayToBps[1000000015985003869679373628] = 6555; - rayToBps[1000000015986919232700745209] = 6556; - rayToBps[1000000015988834480035651548] = 6557; - rayToBps[1000000015990749611698066548] = 6558; - rayToBps[1000000015992664627701961582] = 6559; - rayToBps[1000000015994579528061305491] = 6560; - rayToBps[1000000015996494312790064590] = 6561; - rayToBps[1000000015998408981902202656] = 6562; - rayToBps[1000000016000323535411680943] = 6563; - rayToBps[1000000016002237973332458175] = 6564; - rayToBps[1000000016004152295678490547] = 6565; - rayToBps[1000000016006066502463731726] = 6566; - rayToBps[1000000016007980593702132855] = 6567; - rayToBps[1000000016009894569407642547] = 6568; - rayToBps[1000000016011808429594206893] = 6569; - rayToBps[1000000016013722174275769455] = 6570; - rayToBps[1000000016015635803466271275] = 6571; - rayToBps[1000000016017549317179650868] = 6572; - rayToBps[1000000016019462715429844226] = 6573; - rayToBps[1000000016021375998230784820] = 6574; - rayToBps[1000000016023289165596403599] = 6575; - rayToBps[1000000016025202217540628989] = 6576; - rayToBps[1000000016027115154077386896] = 6577; - rayToBps[1000000016029027975220600708] = 6578; - rayToBps[1000000016030940680984191289] = 6579; - rayToBps[1000000016032853271382076987] = 6580; - rayToBps[1000000016034765746428173632] = 6581; - rayToBps[1000000016036678106136394535] = 6582; - rayToBps[1000000016038590350520650490] = 6583; - rayToBps[1000000016040502479594849776] = 6584; - rayToBps[1000000016042414493372898155] = 6585; - rayToBps[1000000016044326391868698872] = 6586; - rayToBps[1000000016046238175096152661] = 6587; - rayToBps[1000000016048149843069157739] = 6588; - rayToBps[1000000016050061395801609810] = 6589; - rayToBps[1000000016051972833307402066] = 6590; - rayToBps[1000000016053884155600425188] = 6591; - rayToBps[1000000016055795362694567342] = 6592; - rayToBps[1000000016057706454603714184] = 6593; - rayToBps[1000000016059617431341748863] = 6594; - rayToBps[1000000016061528292922552013] = 6595; - rayToBps[1000000016063439039360001761] = 6596; - rayToBps[1000000016065349670667973728] = 6597; - rayToBps[1000000016067260186860341022] = 6598; - rayToBps[1000000016069170587950974247] = 6599; - rayToBps[1000000016071080873953741499] = 6600; - rayToBps[1000000016072991044882508369] = 6601; - rayToBps[1000000016074901100751137941] = 6602; - rayToBps[1000000016076811041573490795] = 6603; - rayToBps[1000000016078720867363425005] = 6604; - rayToBps[1000000016080630578134796143] = 6605; - rayToBps[1000000016082540173901457278] = 6606; - rayToBps[1000000016084449654677258973] = 6607; - rayToBps[1000000016086359020476049294] = 6608; - rayToBps[1000000016088268271311673802] = 6609; - rayToBps[1000000016090177407197975559] = 6610; - rayToBps[1000000016092086428148795125] = 6611; - rayToBps[1000000016093995334177970563] = 6612; - rayToBps[1000000016095904125299337436] = 6613; - rayToBps[1000000016097812801526728807] = 6614; - rayToBps[1000000016099721362873975244] = 6615; - rayToBps[1000000016101629809354904814] = 6616; - rayToBps[1000000016103538140983343092] = 6617; - rayToBps[1000000016105446357773113153] = 6618; - rayToBps[1000000016107354459738035580] = 6619; - rayToBps[1000000016109262446891928459] = 6620; - rayToBps[1000000016111170319248607383] = 6621; - rayToBps[1000000016113078076821885451] = 6622; - rayToBps[1000000016114985719625573268] = 6623; - rayToBps[1000000016116893247673478948] = 6624; - rayToBps[1000000016118800660979408115] = 6625; - rayToBps[1000000016120707959557163897] = 6626; - rayToBps[1000000016122615143420546934] = 6627; - rayToBps[1000000016124522212583355378] = 6628; - rayToBps[1000000016126429167059384889] = 6629; - rayToBps[1000000016128336006862428639] = 6630; - rayToBps[1000000016130242732006277312] = 6631; - rayToBps[1000000016132149342504719104] = 6632; - rayToBps[1000000016134055838371539725] = 6633; - rayToBps[1000000016135962219620522398] = 6634; - rayToBps[1000000016137868486265447859] = 6635; - rayToBps[1000000016139774638320094360] = 6636; - rayToBps[1000000016141680675798237669] = 6637; - rayToBps[1000000016143586598713651070] = 6638; - rayToBps[1000000016145492407080105363] = 6639; - rayToBps[1000000016147398100911368865] = 6640; - rayToBps[1000000016149303680221207410] = 6641; - rayToBps[1000000016151209145023384352] = 6642; - rayToBps[1000000016153114495331660565] = 6643; - rayToBps[1000000016155019731159794439] = 6644; - rayToBps[1000000016156924852521541888] = 6645; - rayToBps[1000000016158829859430656342] = 6646; - rayToBps[1000000016160734751900888759] = 6647; - rayToBps[1000000016162639529945987614] = 6648; - rayToBps[1000000016164544193579698905] = 6649; - rayToBps[1000000016166448742815766155] = 6650; - rayToBps[1000000016168353177667930410] = 6651; - rayToBps[1000000016170257498149930239] = 6652; - rayToBps[1000000016172161704275501740] = 6653; - rayToBps[1000000016174065796058378532] = 6654; - rayToBps[1000000016175969773512291760] = 6655; - rayToBps[1000000016177873636650970102] = 6656; - rayToBps[1000000016179777385488139756] = 6657; - rayToBps[1000000016181681020037524450] = 6658; - rayToBps[1000000016183584540312845443] = 6659; - rayToBps[1000000016185487946327821522] = 6660; - rayToBps[1000000016187391238096169003] = 6661; - rayToBps[1000000016189294415631601732] = 6662; - rayToBps[1000000016191197478947831086] = 6663; - rayToBps[1000000016193100428058565975] = 6664; - rayToBps[1000000016195003262977512839] = 6665; - rayToBps[1000000016196905983718375652] = 6666; - rayToBps[1000000016198808590294855920] = 6667; - rayToBps[1000000016200711082720652686] = 6668; - rayToBps[1000000016202613461009462523] = 6669; - rayToBps[1000000016204515725174979542] = 6670; - rayToBps[1000000016206417875230895389] = 6671; - rayToBps[1000000016208319911190899247] = 6672; - rayToBps[1000000016210221833068677832] = 6673; - rayToBps[1000000016212123640877915404] = 6674; - rayToBps[1000000016214025334632293755] = 6675; - rayToBps[1000000016215926914345492218] = 6676; - rayToBps[1000000016217828380031187665] = 6677; - rayToBps[1000000016219729731703054508] = 6678; - rayToBps[1000000016221630969374764700] = 6679; - rayToBps[1000000016223532093059987732] = 6680; - rayToBps[1000000016225433102772390641] = 6681; - rayToBps[1000000016227333998525638003] = 6682; - rayToBps[1000000016229234780333391936] = 6683; - rayToBps[1000000016231135448209312105] = 6684; - rayToBps[1000000016233036002167055714] = 6685; - rayToBps[1000000016234936442220277518] = 6686; - rayToBps[1000000016236836768382629809] = 6687; - rayToBps[1000000016238736980667762431] = 6688; - rayToBps[1000000016240637079089322772] = 6689; - rayToBps[1000000016242537063660955766] = 6690; - rayToBps[1000000016244436934396303896] = 6691; - rayToBps[1000000016246336691309007193] = 6692; - rayToBps[1000000016248236334412703235] = 6693; - rayToBps[1000000016250135863721027150] = 6694; - rayToBps[1000000016252035279247611617] = 6695; - rayToBps[1000000016253934581006086862] = 6696; - rayToBps[1000000016255833769010080666] = 6697; - rayToBps[1000000016257732843273218361] = 6698; - rayToBps[1000000016259631803809122826] = 6699; - rayToBps[1000000016261530650631414500] = 6700; - rayToBps[1000000016263429383753711370] = 6701; - rayToBps[1000000016265328003189628979] = 6702; - rayToBps[1000000016267226508952780424] = 6703; - rayToBps[1000000016269124901056776358] = 6704; - rayToBps[1000000016271023179515224989] = 6705; - rayToBps[1000000016272921344341732080] = 6706; - rayToBps[1000000016274819395549900951] = 6707; - rayToBps[1000000016276717333153332483] = 6708; - rayToBps[1000000016278615157165625110] = 6709; - rayToBps[1000000016280512867600374827] = 6710; - rayToBps[1000000016282410464471175189] = 6711; - rayToBps[1000000016284307947791617308] = 6712; - rayToBps[1000000016286205317575289861] = 6713; - rayToBps[1000000016288102573835779079] = 6714; - rayToBps[1000000016289999716586668760] = 6715; - rayToBps[1000000016291896745841540263] = 6716; - rayToBps[1000000016293793661613972507] = 6717; - rayToBps[1000000016295690463917541979] = 6718; - rayToBps[1000000016297587152765822726] = 6719; - rayToBps[1000000016299483728172386359] = 6720; - rayToBps[1000000016301380190150802056] = 6721; - rayToBps[1000000016303276538714636561] = 6722; - rayToBps[1000000016305172773877454184] = 6723; - rayToBps[1000000016307068895652816797] = 6724; - rayToBps[1000000016308964904054283846] = 6725; - rayToBps[1000000016310860799095412343] = 6726; - rayToBps[1000000016312756580789756865] = 6727; - rayToBps[1000000016314652249150869561] = 6728; - rayToBps[1000000016316547804192300151] = 6729; - rayToBps[1000000016318443245927595921] = 6730; - rayToBps[1000000016320338574370301732] = 6731; - rayToBps[1000000016322233789533960012] = 6732; - rayToBps[1000000016324128891432110768] = 6733; - rayToBps[1000000016326023880078291569] = 6734; - rayToBps[1000000016327918755486037569] = 6735; - rayToBps[1000000016329813517668881487] = 6736; - rayToBps[1000000016331708166640353619] = 6737; - rayToBps[1000000016333602702413981835] = 6738; - rayToBps[1000000016335497125003291584] = 6739; - rayToBps[1000000016337391434421805887] = 6740; - rayToBps[1000000016339285630683045343] = 6741; - rayToBps[1000000016341179713800528128] = 6742; - rayToBps[1000000016343073683787769996] = 6743; - rayToBps[1000000016344967540658284281] = 6744; - rayToBps[1000000016346861284425581891] = 6745; - rayToBps[1000000016348754915103171319] = 6746; - rayToBps[1000000016350648432704558634] = 6747; - rayToBps[1000000016352541837243247489] = 6748; - rayToBps[1000000016354435128732739115] = 6749; - rayToBps[1000000016356328307186532328] = 6750; - rayToBps[1000000016358221372618123524] = 6751; - rayToBps[1000000016360114325041006682] = 6752; - rayToBps[1000000016362007164468673366] = 6753; - rayToBps[1000000016363899890914612724] = 6754; - rayToBps[1000000016365792504392311486] = 6755; - rayToBps[1000000016367685004915253971] = 6756; - rayToBps[1000000016369577392496922081] = 6757; - rayToBps[1000000016371469667150795306] = 6758; - rayToBps[1000000016373361828890350723] = 6759; - rayToBps[1000000016375253877729062995] = 6760; - rayToBps[1000000016377145813680404375] = 6761; - rayToBps[1000000016379037636757844703] = 6762; - rayToBps[1000000016380929346974851411] = 6763; - rayToBps[1000000016382820944344889517] = 6764; - rayToBps[1000000016384712428881421632] = 6765; - rayToBps[1000000016386603800597907959] = 6766; - rayToBps[1000000016388495059507806289] = 6767; - rayToBps[1000000016390386205624572010] = 6768; - rayToBps[1000000016392277238961658097] = 6769; - rayToBps[1000000016394168159532515122] = 6770; - rayToBps[1000000016396058967350591252] = 6771; - rayToBps[1000000016397949662429332245] = 6772; - rayToBps[1000000016399840244782181456] = 6773; - rayToBps[1000000016401730714422579836] = 6774; - rayToBps[1000000016403621071363965932] = 6775; - rayToBps[1000000016405511315619775885] = 6776; - rayToBps[1000000016407401447203443437] = 6777; - rayToBps[1000000016409291466128399927] = 6778; - rayToBps[1000000016411181372408074291] = 6779; - rayToBps[1000000016413071166055893066] = 6780; - rayToBps[1000000016414960847085280386] = 6781; - rayToBps[1000000016416850415509657988] = 6782; - rayToBps[1000000016418739871342445209] = 6783; - rayToBps[1000000016420629214597058985] = 6784; - rayToBps[1000000016422518445286913858] = 6785; - rayToBps[1000000016424407563425421969] = 6786; - rayToBps[1000000016426296569025993065] = 6787; - rayToBps[1000000016428185462102034492] = 6788; - rayToBps[1000000016430074242666951206] = 6789; - rayToBps[1000000016431962910734145763] = 6790; - rayToBps[1000000016433851466317018328] = 6791; - rayToBps[1000000016435739909428966668] = 6792; - rayToBps[1000000016437628240083386160] = 6793; - rayToBps[1000000016439516458293669787] = 6794; - rayToBps[1000000016441404564073208138] = 6795; - rayToBps[1000000016443292557435389412] = 6796; - rayToBps[1000000016445180438393599417] = 6797; - rayToBps[1000000016447068206961221569] = 6798; - rayToBps[1000000016448955863151636894] = 6799; - rayToBps[1000000016450843406978224029] = 6800; - rayToBps[1000000016452730838454359222] = 6801; - rayToBps[1000000016454618157593416334] = 6802; - rayToBps[1000000016456505364408766833] = 6803; - rayToBps[1000000016458392458913779807] = 6804; - rayToBps[1000000016460279441121821953] = 6805; - rayToBps[1000000016462166311046257581] = 6806; - rayToBps[1000000016464053068700448618] = 6807; - rayToBps[1000000016465939714097754606] = 6808; - rayToBps[1000000016467826247251532699] = 6809; - rayToBps[1000000016469712668175137672] = 6810; - rayToBps[1000000016471598976881921914] = 6811; - rayToBps[1000000016473485173385235432] = 6812; - rayToBps[1000000016475371257698425850] = 6813; - rayToBps[1000000016477257229834838411] = 6814; - rayToBps[1000000016479143089807815977] = 6815; - rayToBps[1000000016481028837630699030] = 6816; - rayToBps[1000000016482914473316825670] = 6817; - rayToBps[1000000016484799996879531621] = 6818; - rayToBps[1000000016486685408332150226] = 6819; - rayToBps[1000000016488570707688012450] = 6820; - rayToBps[1000000016490455894960446883] = 6821; - rayToBps[1000000016492340970162779731] = 6822; - rayToBps[1000000016494225933308334832] = 6823; - rayToBps[1000000016496110784410433643] = 6824; - rayToBps[1000000016497995523482395247] = 6825; - rayToBps[1000000016499880150537536351] = 6826; - rayToBps[1000000016501764665589171290] = 6827; - rayToBps[1000000016503649068650612025] = 6828; - rayToBps[1000000016505533359735168140] = 6829; - rayToBps[1000000016507417538856146852] = 6830; - rayToBps[1000000016509301606026853003] = 6831; - rayToBps[1000000016511185561260589063] = 6832; - rayToBps[1000000016513069404570655134] = 6833; - rayToBps[1000000016514953135970348945] = 6834; - rayToBps[1000000016516836755472965855] = 6835; - rayToBps[1000000016518720263091798857] = 6836; - rayToBps[1000000016520603658840138572] = 6837; - rayToBps[1000000016522486942731273255] = 6838; - rayToBps[1000000016524370114778488794] = 6839; - rayToBps[1000000016526253174995068707] = 6840; - rayToBps[1000000016528136123394294149] = 6841; - rayToBps[1000000016530018959989443907] = 6842; - rayToBps[1000000016531901684793794404] = 6843; - rayToBps[1000000016533784297820619698] = 6844; - rayToBps[1000000016535666799083191483] = 6845; - rayToBps[1000000016537549188594779088] = 6846; - rayToBps[1000000016539431466368649483] = 6847; - rayToBps[1000000016541313632418067271] = 6848; - rayToBps[1000000016543195686756294694] = 6849; - rayToBps[1000000016545077629396591637] = 6850; - rayToBps[1000000016546959460352215619] = 6851; - rayToBps[1000000016548841179636421799] = 6852; - rayToBps[1000000016550722787262462982] = 6853; - rayToBps[1000000016552604283243589608] = 6854; - rayToBps[1000000016554485667593049761] = 6855; - rayToBps[1000000016556366940324089165] = 6856; - rayToBps[1000000016558248101449951192] = 6857; - rayToBps[1000000016560129150983876850] = 6858; - rayToBps[1000000016562010088939104796] = 6859; - rayToBps[1000000016563890915328871330] = 6860; - rayToBps[1000000016565771630166410395] = 6861; - rayToBps[1000000016567652233464953581] = 6862; - rayToBps[1000000016569532725237730125] = 6863; - rayToBps[1000000016571413105497966909] = 6864; - rayToBps[1000000016573293374258888461] = 6865; - rayToBps[1000000016575173531533716960] = 6866; - rayToBps[1000000016577053577335672229] = 6867; - rayToBps[1000000016578933511677971744] = 6868; - rayToBps[1000000016580813334573830628] = 6869; - rayToBps[1000000016582693046036461653] = 6870; - rayToBps[1000000016584572646079075244] = 6871; - rayToBps[1000000016586452134714879475] = 6872; - rayToBps[1000000016588331511957080072] = 6873; - rayToBps[1000000016590210777818880415] = 6874; - rayToBps[1000000016592089932313481533] = 6875; - rayToBps[1000000016593968975454082111] = 6876; - rayToBps[1000000016595847907253878486] = 6877; - rayToBps[1000000016597726727726064651] = 6878; - rayToBps[1000000016599605436883832255] = 6879; - rayToBps[1000000016601484034740370597] = 6880; - rayToBps[1000000016603362521308866639] = 6881; - rayToBps[1000000016605240896602504994] = 6882; - rayToBps[1000000016607119160634467936] = 6883; - rayToBps[1000000016608997313417935393] = 6884; - rayToBps[1000000016610875354966084955] = 6885; - rayToBps[1000000016612753285292091867] = 6886; - rayToBps[1000000016614631104409129037] = 6887; - rayToBps[1000000016616508812330367032] = 6888; - rayToBps[1000000016618386409068974076] = 6889; - rayToBps[1000000016620263894638116058] = 6890; - rayToBps[1000000016622141269050956527] = 6891; - rayToBps[1000000016624018532320656694] = 6892; - rayToBps[1000000016625895684460375433] = 6893; - rayToBps[1000000016627772725483269281] = 6894; - rayToBps[1000000016629649655402492440] = 6895; - rayToBps[1000000016631526474231196774] = 6896; - rayToBps[1000000016633403181982531813] = 6897; - rayToBps[1000000016635279778669644752] = 6898; - rayToBps[1000000016637156264305680454] = 6899; - rayToBps[1000000016639032638903781446] = 6900; - rayToBps[1000000016640908902477087924] = 6901; - rayToBps[1000000016642785055038737748] = 6902; - rayToBps[1000000016644661096601866452] = 6903; - rayToBps[1000000016646537027179607234] = 6904; - rayToBps[1000000016648412846785090963] = 6905; - rayToBps[1000000016650288555431446177] = 6906; - rayToBps[1000000016652164153131799087] = 6907; - rayToBps[1000000016654039639899273571] = 6908; - rayToBps[1000000016655915015746991182] = 6909; - rayToBps[1000000016657790280688071142] = 6910; - rayToBps[1000000016659665434735630349] = 6911; - rayToBps[1000000016661540477902783371] = 6912; - rayToBps[1000000016663415410202642451] = 6913; - rayToBps[1000000016665290231648317506] = 6914; - rayToBps[1000000016667164942252916129] = 6915; - rayToBps[1000000016669039542029543587] = 6916; - rayToBps[1000000016670914030991302822] = 6917; - rayToBps[1000000016672788409151294456] = 6918; - rayToBps[1000000016674662676522616783] = 6919; - rayToBps[1000000016676536833118365780] = 6920; - rayToBps[1000000016678410878951635096] = 6921; - rayToBps[1000000016680284814035516064] = 6922; - rayToBps[1000000016682158638383097695] = 6923; - rayToBps[1000000016684032352007466677] = 6924; - rayToBps[1000000016685905954921707380] = 6925; - rayToBps[1000000016687779447138901857] = 6926; - rayToBps[1000000016689652828672129838] = 6927; - rayToBps[1000000016691526099534468738] = 6928; - rayToBps[1000000016693399259738993654] = 6929; - rayToBps[1000000016695272309298777366] = 6930; - rayToBps[1000000016697145248226890337] = 6931; - rayToBps[1000000016699018076536400715] = 6932; - rayToBps[1000000016700890794240374330] = 6933; - rayToBps[1000000016702763401351874702] = 6934; - rayToBps[1000000016704635897883963033] = 6935; - rayToBps[1000000016706508283849698211] = 6936; - rayToBps[1000000016708380559262136815] = 6937; - rayToBps[1000000016710252724134333106] = 6938; - rayToBps[1000000016712124778479339037] = 6939; - rayToBps[1000000016713996722310204248] = 6940; - rayToBps[1000000016715868555639976067] = 6941; - rayToBps[1000000016717740278481699513] = 6942; - rayToBps[1000000016719611890848417297] = 6943; - rayToBps[1000000016721483392753169815] = 6944; - rayToBps[1000000016723354784208995160] = 6945; - rayToBps[1000000016725226065228929112] = 6946; - rayToBps[1000000016727097235826005150] = 6947; - rayToBps[1000000016728968296013254437] = 6948; - rayToBps[1000000016730839245803705837] = 6949; - rayToBps[1000000016732710085210385903] = 6950; - rayToBps[1000000016734580814246318886] = 6951; - rayToBps[1000000016736451432924526729] = 6952; - rayToBps[1000000016738321941258029073] = 6953; - rayToBps[1000000016740192339259843253] = 6954; - rayToBps[1000000016742062626942984304] = 6955; - rayToBps[1000000016743932804320464954] = 6956; - rayToBps[1000000016745802871405295631] = 6957; - rayToBps[1000000016747672828210484461] = 6958; - rayToBps[1000000016749542674749037270] = 6959; - rayToBps[1000000016751412411033957580] = 6960; - rayToBps[1000000016753282037078246617] = 6961; - rayToBps[1000000016755151552894903305] = 6962; - rayToBps[1000000016757020958496924269] = 6963; - rayToBps[1000000016758890253897303837] = 6964; - rayToBps[1000000016760759439109034038] = 6965; - rayToBps[1000000016762628514145104603] = 6966; - rayToBps[1000000016764497479018502969] = 6967; - rayToBps[1000000016766366333742214272] = 6968; - rayToBps[1000000016768235078329221357] = 6969; - rayToBps[1000000016770103712792504771] = 6970; - rayToBps[1000000016771972237145042768] = 6971; - rayToBps[1000000016773840651399811306] = 6972; - rayToBps[1000000016775708955569784050] = 6973; - rayToBps[1000000016777577149667932373] = 6974; - rayToBps[1000000016779445233707225354] = 6975; - rayToBps[1000000016781313207700629783] = 6976; - rayToBps[1000000016783181071661110154] = 6977; - rayToBps[1000000016785048825601628673] = 6978; - rayToBps[1000000016786916469535145257] = 6979; - rayToBps[1000000016788784003474617530] = 6980; - rayToBps[1000000016790651427433000828] = 6981; - rayToBps[1000000016792518741423248199] = 6982; - rayToBps[1000000016794385945458310402] = 6983; - rayToBps[1000000016796253039551135908] = 6984; - rayToBps[1000000016798120023714670903] = 6985; - rayToBps[1000000016799986897961859283] = 6986; - rayToBps[1000000016801853662305642661] = 6987; - rayToBps[1000000016803720316758960363] = 6988; - rayToBps[1000000016805586861334749431] = 6989; - rayToBps[1000000016807453296045944621] = 6990; - rayToBps[1000000016809319620905478407] = 6991; - rayToBps[1000000016811185835926280979] = 6992; - rayToBps[1000000016813051941121280243] = 6993; - rayToBps[1000000016814917936503401823] = 6994; - rayToBps[1000000016816783822085569065] = 6995; - rayToBps[1000000016818649597880703028] = 6996; - rayToBps[1000000016820515263901722494] = 6997; - rayToBps[1000000016822380820161543963] = 6998; - rayToBps[1000000016824246266673081659] = 6999; - rayToBps[1000000016826111603449247521] = 7000; - rayToBps[1000000016827976830502951216] = 7001; - rayToBps[1000000016829841947847100128] = 7002; - rayToBps[1000000016831706955494599366] = 7003; - rayToBps[1000000016833571853458351761] = 7004; - rayToBps[1000000016835436641751257869] = 7005; - rayToBps[1000000016837301320386215969] = 7006; - rayToBps[1000000016839165889376122066] = 7007; - rayToBps[1000000016841030348733869887] = 7008; - rayToBps[1000000016842894698472350889] = 7009; - rayToBps[1000000016844758938604454252] = 7010; - rayToBps[1000000016846623069143066886] = 7011; - rayToBps[1000000016848487090101073424] = 7012; - rayToBps[1000000016850351001491356231] = 7013; - rayToBps[1000000016852214803326795400] = 7014; - rayToBps[1000000016854078495620268751] = 7015; - rayToBps[1000000016855942078384651834] = 7016; - rayToBps[1000000016857805551632817929] = 7017; - rayToBps[1000000016859668915377638048] = 7018; - rayToBps[1000000016861532169631980933] = 7019; - rayToBps[1000000016863395314408713059] = 7020; - rayToBps[1000000016865258349720698630] = 7021; - rayToBps[1000000016867121275580799585] = 7022; - rayToBps[1000000016868984092001875597] = 7023; - rayToBps[1000000016870846798996784070] = 7024; - rayToBps[1000000016872709396578380147] = 7025; - rayToBps[1000000016874571884759516701] = 7026; - rayToBps[1000000016876434263553044341] = 7027; - rayToBps[1000000016878296532971811416] = 7028; - rayToBps[1000000016880158693028664007] = 7029; - rayToBps[1000000016882020743736445934] = 7030; - rayToBps[1000000016883882685107998752] = 7031; - rayToBps[1000000016885744517156161760] = 7032; - rayToBps[1000000016887606239893771989] = 7033; - rayToBps[1000000016889467853333664213] = 7034; - rayToBps[1000000016891329357488670944] = 7035; - rayToBps[1000000016893190752371622434] = 7036; - rayToBps[1000000016895052037995346676] = 7037; - rayToBps[1000000016896913214372669406] = 7038; - rayToBps[1000000016898774281516414100] = 7039; - rayToBps[1000000016900635239439401976] = 7040; - rayToBps[1000000016902496088154451995] = 7041; - rayToBps[1000000016904356827674380861] = 7042; - rayToBps[1000000016906217458012003025] = 7043; - rayToBps[1000000016908077979180130677] = 7044; - rayToBps[1000000016909938391191573757] = 7045; - rayToBps[1000000016911798694059139947] = 7046; - rayToBps[1000000016913658887795634678] = 7047; - rayToBps[1000000016915518972413861124] = 7048; - rayToBps[1000000016917378947926620208] = 7049; - rayToBps[1000000016919238814346710603] = 7050; - rayToBps[1000000016921098571686928723] = 7051; - rayToBps[1000000016922958219960068739] = 7052; - rayToBps[1000000016924817759178922565] = 7053; - rayToBps[1000000016926677189356279869] = 7054; - rayToBps[1000000016928536510504928066] = 7055; - rayToBps[1000000016930395722637652322] = 7056; - rayToBps[1000000016932254825767235558] = 7057; - rayToBps[1000000016934113819906458442] = 7058; - rayToBps[1000000016935972705068099396] = 7059; - rayToBps[1000000016937831481264934596] = 7060; - rayToBps[1000000016939690148509737971] = 7061; - rayToBps[1000000016941548706815281202] = 7062; - rayToBps[1000000016943407156194333727] = 7063; - rayToBps[1000000016945265496659662739] = 7064; - rayToBps[1000000016947123728224033182] = 7065; - rayToBps[1000000016948981850900207763] = 7066; - rayToBps[1000000016950839864700946939] = 7067; - rayToBps[1000000016952697769639008929] = 7068; - rayToBps[1000000016954555565727149706] = 7069; - rayToBps[1000000016956413252978123003] = 7070; - rayToBps[1000000016958270831404680312] = 7071; - rayToBps[1000000016960128301019570884] = 7072; - rayToBps[1000000016961985661835541727] = 7073; - rayToBps[1000000016963842913865337612] = 7074; - rayToBps[1000000016965700057121701072] = 7075; - rayToBps[1000000016967557091617372397] = 7076; - rayToBps[1000000016969414017365089642] = 7077; - rayToBps[1000000016971270834377588623] = 7078; - rayToBps[1000000016973127542667602920] = 7079; - rayToBps[1000000016974984142247863875] = 7080; - rayToBps[1000000016976840633131100595] = 7081; - rayToBps[1000000016978697015330039950] = 7082; - rayToBps[1000000016980553288857406577] = 7083; - rayToBps[1000000016982409453725922877] = 7084; - rayToBps[1000000016984265509948309016] = 7085; - rayToBps[1000000016986121457537282929] = 7086; - rayToBps[1000000016987977296505560317] = 7087; - rayToBps[1000000016989833026865854647] = 7088; - rayToBps[1000000016991688648630877157] = 7089; - rayToBps[1000000016993544161813336850] = 7090; - rayToBps[1000000016995399566425940502] = 7091; - rayToBps[1000000016997254862481392657] = 7092; - rayToBps[1000000016999110049992395626] = 7093; - rayToBps[1000000017000965128971649496] = 7094; - rayToBps[1000000017002820099431852122] = 7095; - rayToBps[1000000017004674961385699132] = 7096; - rayToBps[1000000017006529714845883924] = 7097; - rayToBps[1000000017008384359825097672] = 7098; - rayToBps[1000000017010238896336029322] = 7099; - rayToBps[1000000017012093324391365593] = 7100; - rayToBps[1000000017013947644003790979] = 7101; - rayToBps[1000000017015801855185987748] = 7102; - rayToBps[1000000017017655957950635945] = 7103; - rayToBps[1000000017019509952310413390] = 7104; - rayToBps[1000000017021363838277995678] = 7105; - rayToBps[1000000017023217615866056185] = 7106; - rayToBps[1000000017025071285087266058] = 7107; - rayToBps[1000000017026924845954294229] = 7108; - rayToBps[1000000017028778298479807404] = 7109; - rayToBps[1000000017030631642676470068] = 7110; - rayToBps[1000000017032484878556944490] = 7111; - rayToBps[1000000017034338006133890711] = 7112; - rayToBps[1000000017036191025419966563] = 7113; - rayToBps[1000000017038043936427827649] = 7114; - rayToBps[1000000017039896739170127359] = 7115; - rayToBps[1000000017041749433659516866] = 7116; - rayToBps[1000000017043602019908645121] = 7117; - rayToBps[1000000017045454497930158862] = 7118; - rayToBps[1000000017047306867736702611] = 7119; - rayToBps[1000000017049159129340918671] = 7120; - rayToBps[1000000017051011282755447132] = 7121; - rayToBps[1000000017052863327992925869] = 7122; - rayToBps[1000000017054715265065990543] = 7123; - rayToBps[1000000017056567093987274599] = 7124; - rayToBps[1000000017058418814769409273] = 7125; - rayToBps[1000000017060270427425023583] = 7126; - rayToBps[1000000017062121931966744339] = 7127; - rayToBps[1000000017063973328407196139] = 7128; - rayToBps[1000000017065824616759001367] = 7129; - rayToBps[1000000017067675797034780199] = 7130; - rayToBps[1000000017069526869247150599] = 7131; - rayToBps[1000000017071377833408728323] = 7132; - rayToBps[1000000017073228689532126918] = 7133; - rayToBps[1000000017075079437629957721] = 7134; - rayToBps[1000000017076930077714829862] = 7135; - rayToBps[1000000017078780609799350263] = 7136; - rayToBps[1000000017080631033896123639] = 7137; - rayToBps[1000000017082481350017752499] = 7138; - rayToBps[1000000017084331558176837145] = 7139; - rayToBps[1000000017086181658385975674] = 7140; - rayToBps[1000000017088031650657763979] = 7141; - rayToBps[1000000017089881535004795747] = 7142; - rayToBps[1000000017091731311439662461] = 7143; - rayToBps[1000000017093580979974953404] = 7144; - rayToBps[1000000017095430540623255651] = 7145; - rayToBps[1000000017097279993397154077] = 7146; - rayToBps[1000000017099129338309231355] = 7147; - rayToBps[1000000017100978575372067958] = 7148; - rayToBps[1000000017102827704598242158] = 7149; - rayToBps[1000000017104676726000330021] = 7150; - rayToBps[1000000017106525639590905422] = 7151; - rayToBps[1000000017108374445382540031] = 7152; - rayToBps[1000000017110223143387803320] = 7153; - rayToBps[1000000017112071733619262563] = 7154; - rayToBps[1000000017113920216089482839] = 7155; - rayToBps[1000000017115768590811027024] = 7156; - rayToBps[1000000017117616857796455803] = 7157; - rayToBps[1000000017119465017058327660] = 7158; - rayToBps[1000000017121313068609198888] = 7159; - rayToBps[1000000017123161012461623580] = 7160; - rayToBps[1000000017125008848628153638] = 7161; - rayToBps[1000000017126856577121338769] = 7162; - rayToBps[1000000017128704197953726483] = 7163; - rayToBps[1000000017130551711137862102] = 7164; - rayToBps[1000000017132399116686288751] = 7165; - rayToBps[1000000017134246414611547366] = 7166; - rayToBps[1000000017136093604926176691] = 7167; - rayToBps[1000000017137940687642713275] = 7168; - rayToBps[1000000017139787662773691483] = 7169; - rayToBps[1000000017141634530331643482] = 7170; - rayToBps[1000000017143481290329099258] = 7171; - rayToBps[1000000017145327942778586600] = 7172; - rayToBps[1000000017147174487692631114] = 7173; - rayToBps[1000000017149020925083756215] = 7174; - rayToBps[1000000017150867254964483131] = 7175; - rayToBps[1000000017152713477347330904] = 7176; - rayToBps[1000000017154559592244816389] = 7177; - rayToBps[1000000017156405599669454253] = 7178; - rayToBps[1000000017158251499633756981] = 7179; - rayToBps[1000000017160097292150234871] = 7180; - rayToBps[1000000017161942977231396035] = 7181; - rayToBps[1000000017163788554889746405] = 7182; - rayToBps[1000000017165634025137789725] = 7183; - rayToBps[1000000017167479387988027559] = 7184; - rayToBps[1000000017169324643452959289] = 7185; - rayToBps[1000000017171169791545082111] = 7186; - rayToBps[1000000017173014832276891044] = 7187; - rayToBps[1000000017174859765660878925] = 7188; - rayToBps[1000000017176704591709536409] = 7189; - rayToBps[1000000017178549310435351971] = 7190; - rayToBps[1000000017180393921850811909] = 7191; - rayToBps[1000000017182238425968400340] = 7192; - rayToBps[1000000017184082822800599204] = 7193; - rayToBps[1000000017185927112359888261] = 7194; - rayToBps[1000000017187771294658745097] = 7195; - rayToBps[1000000017189615369709645117] = 7196; - rayToBps[1000000017191459337525061551] = 7197; - rayToBps[1000000017193303198117465456] = 7198; - rayToBps[1000000017195146951499325710] = 7199; - rayToBps[1000000017196990597683109018] = 7200; - rayToBps[1000000017198834136681279909] = 7201; - rayToBps[1000000017200677568506300742] = 7202; - rayToBps[1000000017202520893170631697] = 7203; - rayToBps[1000000017204364110686730786] = 7204; - rayToBps[1000000017206207221067053846] = 7205; - rayToBps[1000000017208050224324054541] = 7206; - rayToBps[1000000017209893120470184369] = 7207; - rayToBps[1000000017211735909517892653] = 7208; - rayToBps[1000000017213578591479626545] = 7209; - rayToBps[1000000017215421166367831029] = 7210; - rayToBps[1000000017217263634194948920] = 7211; - rayToBps[1000000017219105994973420864] = 7212; - rayToBps[1000000017220948248715685336] = 7213; - rayToBps[1000000017222790395434178647] = 7214; - rayToBps[1000000017224632435141334939] = 7215; - rayToBps[1000000017226474367849586187] = 7216; - rayToBps[1000000017228316193571362200] = 7217; - rayToBps[1000000017230157912319090621] = 7218; - rayToBps[1000000017231999524105196929] = 7219; - rayToBps[1000000017233841028942104436] = 7220; - rayToBps[1000000017235682426842234291] = 7221; - rayToBps[1000000017237523717818005480] = 7222; - rayToBps[1000000017239364901881834825] = 7223; - rayToBps[1000000017241205979046136983] = 7224; - rayToBps[1000000017243046949323324453] = 7225; - rayToBps[1000000017244887812725807569] = 7226; - rayToBps[1000000017246728569265994504] = 7227; - rayToBps[1000000017248569218956291274] = 7228; - rayToBps[1000000017250409761809101729] = 7229; - rayToBps[1000000017252250197836827562] = 7230; - rayToBps[1000000017254090527051868307] = 7231; - rayToBps[1000000017255930749466621341] = 7232; - rayToBps[1000000017257770865093481878] = 7233; - rayToBps[1000000017259610873944842979] = 7234; - rayToBps[1000000017261450776033095544] = 7235; - rayToBps[1000000017263290571370628319] = 7236; - rayToBps[1000000017265130259969827893] = 7237; - rayToBps[1000000017266969841843078698] = 7238; - rayToBps[1000000017268809317002763012] = 7239; - rayToBps[1000000017270648685461260960] = 7240; - rayToBps[1000000017272487947230950506] = 7241; - rayToBps[1000000017274327102324207470] = 7242; - rayToBps[1000000017276166150753405511] = 7243; - rayToBps[1000000017278005092530916139] = 7244; - rayToBps[1000000017279843927669108709] = 7245; - rayToBps[1000000017281682656180350428] = 7246; - rayToBps[1000000017283521278077006348] = 7247; - rayToBps[1000000017285359793371439374] = 7248; - rayToBps[1000000017287198202076010256] = 7249; - rayToBps[1000000017289036504203077600] = 7250; - rayToBps[1000000017290874699764997857] = 7251; - rayToBps[1000000017292712788774125333] = 7252; - rayToBps[1000000017294550771242812185] = 7253; - rayToBps[1000000017296388647183408421] = 7254; - rayToBps[1000000017298226416608261903] = 7255; - rayToBps[1000000017300064079529718345] = 7256; - rayToBps[1000000017301901635960121318] = 7257; - rayToBps[1000000017303739085911812243] = 7258; - rayToBps[1000000017305576429397130398] = 7259; - rayToBps[1000000017307413666428412915] = 7260; - rayToBps[1000000017309250797017994782] = 7261; - rayToBps[1000000017311087821178208846] = 7262; - rayToBps[1000000017312924738921385806] = 7263; - rayToBps[1000000017314761550259854221] = 7264; - rayToBps[1000000017316598255205940510] = 7265; - rayToBps[1000000017318434853771968943] = 7266; - rayToBps[1000000017320271345970261657] = 7267; - rayToBps[1000000017322107731813138642] = 7268; - rayToBps[1000000017323944011312917751] = 7269; - rayToBps[1000000017325780184481914696] = 7270; - rayToBps[1000000017327616251332443050] = 7271; - rayToBps[1000000017329452211876814248] = 7272; - rayToBps[1000000017331288066127337584] = 7273; - rayToBps[1000000017333123814096320217] = 7274; - rayToBps[1000000017334959455796067168] = 7275; - rayToBps[1000000017336794991238881320] = 7276; - rayToBps[1000000017338630420437063420] = 7277; - rayToBps[1000000017340465743402912081] = 7278; - rayToBps[1000000017342300960148723777] = 7279; - rayToBps[1000000017344136070686792852] = 7280; - rayToBps[1000000017345971075029411511] = 7281; - rayToBps[1000000017347805973188869827] = 7282; - rayToBps[1000000017349640765177455741] = 7283; - rayToBps[1000000017351475451007455060] = 7284; - rayToBps[1000000017353310030691151455] = 7285; - rayToBps[1000000017355144504240826473] = 7286; - rayToBps[1000000017356978871668759522] = 7287; - rayToBps[1000000017358813132987227884] = 7288; - rayToBps[1000000017360647288208506708] = 7289; - rayToBps[1000000017362481337344869013] = 7290; - rayToBps[1000000017364315280408585691] = 7291; - rayToBps[1000000017366149117411925502] = 7292; - rayToBps[1000000017367982848367155079] = 7293; - rayToBps[1000000017369816473286538927] = 7294; - rayToBps[1000000017371649992182339426] = 7295; - rayToBps[1000000017373483405066816824] = 7296; - rayToBps[1000000017375316711952229244] = 7297; - rayToBps[1000000017377149912850832687] = 7298; - rayToBps[1000000017378983007774881025] = 7299; - rayToBps[1000000017380815996736626004] = 7300; - rayToBps[1000000017382648879748317248] = 7301; - rayToBps[1000000017384481656822202255] = 7302; - rayToBps[1000000017386314327970526403] = 7303; - rayToBps[1000000017388146893205532943] = 7304; - rayToBps[1000000017389979352539463003] = 7305; - rayToBps[1000000017391811705984555594] = 7306; - rayToBps[1000000017393643953553047601] = 7307; - rayToBps[1000000017395476095257173788] = 7308; - rayToBps[1000000017397308131109166801] = 7309; - rayToBps[1000000017399140061121257164] = 7310; - rayToBps[1000000017400971885305673282] = 7311; - rayToBps[1000000017402803603674641440] = 7312; - rayToBps[1000000017404635216240385805] = 7313; - rayToBps[1000000017406466723015128428] = 7314; - rayToBps[1000000017408298124011089238] = 7315; - rayToBps[1000000017410129419240486051] = 7316; - rayToBps[1000000017411960608715534563] = 7317; - rayToBps[1000000017413791692448448355] = 7318; - rayToBps[1000000017415622670451438895] = 7319; - rayToBps[1000000017417453542736715530] = 7320; - rayToBps[1000000017419284309316485497] = 7321; - rayToBps[1000000017421114970202953919] = 7322; - rayToBps[1000000017422945525408323801] = 7323; - rayToBps[1000000017424775974944796039] = 7324; - rayToBps[1000000017426606318824569415] = 7325; - rayToBps[1000000017428436557059840598] = 7326; - rayToBps[1000000017430266689662804144] = 7327; - rayToBps[1000000017432096716645652500] = 7328; - rayToBps[1000000017433926638020576003] = 7329; - rayToBps[1000000017435756453799762877] = 7330; - rayToBps[1000000017437586163995399235] = 7331; - rayToBps[1000000017439415768619669087] = 7332; - rayToBps[1000000017441245267684754328] = 7333; - rayToBps[1000000017443074661202834746] = 7334; - rayToBps[1000000017444903949186088022] = 7335; - rayToBps[1000000017446733131646689731] = 7336; - rayToBps[1000000017448562208596813336] = 7337; - rayToBps[1000000017450391180048630201] = 7338; - rayToBps[1000000017452220046014309577] = 7339; - rayToBps[1000000017454048806506018613] = 7340; - rayToBps[1000000017455877461535922354] = 7341; - rayToBps[1000000017457706011116183737] = 7342; - rayToBps[1000000017459534455258963600] = 7343; - rayToBps[1000000017461362793976420670] = 7344; - rayToBps[1000000017463191027280711580] = 7345; - rayToBps[1000000017465019155183990853] = 7346; - rayToBps[1000000017466847177698410915] = 7347; - rayToBps[1000000017468675094836122086] = 7348; - rayToBps[1000000017470502906609272589] = 7349; - rayToBps[1000000017472330613030008543] = 7350; - rayToBps[1000000017474158214110473970] = 7351; - rayToBps[1000000017475985709862810789] = 7352; - rayToBps[1000000017477813100299158823] = 7353; - rayToBps[1000000017479640385431655794] = 7354; - rayToBps[1000000017481467565272437328] = 7355; - rayToBps[1000000017483294639833636950] = 7356; - rayToBps[1000000017485121609127386092] = 7357; - rayToBps[1000000017486948473165814085] = 7358; - rayToBps[1000000017488775231961048167] = 7359; - rayToBps[1000000017490601885525213478] = 7360; - rayToBps[1000000017492428433870433064] = 7361; - rayToBps[1000000017494254877008827878] = 7362; - rayToBps[1000000017496081214952516772] = 7363; - rayToBps[1000000017497907447713616513] = 7364; - rayToBps[1000000017499733575304241768] = 7365; - rayToBps[1000000017501559597736505115] = 7366; - rayToBps[1000000017503385515022517037] = 7367; - rayToBps[1000000017505211327174385925] = 7368; - rayToBps[1000000017507037034204218081] = 7369; - rayToBps[1000000017508862636124117716] = 7370; - rayToBps[1000000017510688132946186946] = 7371; - rayToBps[1000000017512513524682525802] = 7372; - rayToBps[1000000017514338811345232225] = 7373; - rayToBps[1000000017516163992946402063] = 7374; - rayToBps[1000000017517989069498129080] = 7375; - rayToBps[1000000017519814041012504950] = 7376; - rayToBps[1000000017521638907501619258] = 7377; - rayToBps[1000000017523463668977559505] = 7378; - rayToBps[1000000017525288325452411102] = 7379; - rayToBps[1000000017527112876938257378] = 7380; - rayToBps[1000000017528937323447179572] = 7381; - rayToBps[1000000017530761664991256840] = 7382; - rayToBps[1000000017532585901582566253] = 7383; - rayToBps[1000000017534410033233182798] = 7384; - rayToBps[1000000017536234059955179379] = 7385; - rayToBps[1000000017538057981760626814] = 7386; - rayToBps[1000000017539881798661593840] = 7387; - rayToBps[1000000017541705510670147114] = 7388; - rayToBps[1000000017543529117798351206] = 7389; - rayToBps[1000000017545352620058268609] = 7390; - rayToBps[1000000017547176017461959733] = 7391; - rayToBps[1000000017548999310021482909] = 7392; - rayToBps[1000000017550822497748894386] = 7393; - rayToBps[1000000017552645580656248336] = 7394; - rayToBps[1000000017554468558755596849] = 7395; - rayToBps[1000000017556291432058989941] = 7396; - rayToBps[1000000017558114200578475546] = 7397; - rayToBps[1000000017559936864326099522] = 7398; - rayToBps[1000000017561759423313905650] = 7399; - rayToBps[1000000017563581877553935633] = 7400; - rayToBps[1000000017565404227058229101] = 7401; - rayToBps[1000000017567226471838823606] = 7402; - rayToBps[1000000017569048611907754624] = 7403; - rayToBps[1000000017570870647277055559] = 7404; - rayToBps[1000000017572692577958757738] = 7405; - rayToBps[1000000017574514403964890419] = 7406; - rayToBps[1000000017576336125307480780] = 7407; - rayToBps[1000000017578157741998553932] = 7408; - rayToBps[1000000017579979254050132911] = 7409; - rayToBps[1000000017581800661474238681] = 7410; - rayToBps[1000000017583621964282890136] = 7411; - rayToBps[1000000017585443162488104098] = 7412; - rayToBps[1000000017587264256101895320] = 7413; - rayToBps[1000000017589085245136276485] = 7414; - rayToBps[1000000017590906129603258203] = 7415; - rayToBps[1000000017592726909514849021] = 7416; - rayToBps[1000000017594547584883055411] = 7417; - rayToBps[1000000017596368155719881784] = 7418; - rayToBps[1000000017598188622037330478] = 7419; - rayToBps[1000000017600008983847401766] = 7420; - rayToBps[1000000017601829241162093854] = 7421; - rayToBps[1000000017603649393993402882] = 7422; - rayToBps[1000000017605469442353322925] = 7423; - rayToBps[1000000017607289386253845993] = 7424; - rayToBps[1000000017609109225706962029] = 7425; - rayToBps[1000000017610928960724658915] = 7426; - rayToBps[1000000017612748591318922467] = 7427; - rayToBps[1000000017614568117501736438] = 7428; - rayToBps[1000000017616387539285082519] = 7429; - rayToBps[1000000017618206856680940339] = 7430; - rayToBps[1000000017620026069701287465] = 7431; - rayToBps[1000000017621845178358099399] = 7432; - rayToBps[1000000017623664182663349590] = 7433; - rayToBps[1000000017625483082629009418] = 7434; - rayToBps[1000000017627301878267048209] = 7435; - rayToBps[1000000017629120569589433226] = 7436; - rayToBps[1000000017630939156608129676] = 7437; - rayToBps[1000000017632757639335100704] = 7438; - rayToBps[1000000017634576017782307401] = 7439; - rayToBps[1000000017636394291961708797] = 7440; - rayToBps[1000000017638212461885261865] = 7441; - rayToBps[1000000017640030527564921525] = 7442; - rayToBps[1000000017641848489012640637] = 7443; - rayToBps[1000000017643666346240370005] = 7444; - rayToBps[1000000017645484099260058384] = 7445; - rayToBps[1000000017647301748083652465] = 7446; - rayToBps[1000000017649119292723096891] = 7447; - rayToBps[1000000017650936733190334250] = 7448; - rayToBps[1000000017652754069497305076] = 7449; - rayToBps[1000000017654571301655947851] = 7450; - rayToBps[1000000017656388429678199002] = 7451; - rayToBps[1000000017658205453575992908] = 7452; - rayToBps[1000000017660022373361261892] = 7453; - rayToBps[1000000017661839189045936232] = 7454; - rayToBps[1000000017663655900641944150] = 7455; - rayToBps[1000000017665472508161211819] = 7456; - rayToBps[1000000017667289011615663365] = 7457; - rayToBps[1000000017669105411017220864] = 7458; - rayToBps[1000000017670921706377804340] = 7459; - rayToBps[1000000017672737897709331773] = 7460; - rayToBps[1000000017674553985023719095] = 7461; - rayToBps[1000000017676369968332880187] = 7462; - rayToBps[1000000017678185847648726887] = 7463; - rayToBps[1000000017680001622983168986] = 7464; - rayToBps[1000000017681817294348114228] = 7465; - rayToBps[1000000017683632861755468312] = 7466; - rayToBps[1000000017685448325217134893] = 7467; - rayToBps[1000000017687263684745015581] = 7468; - rayToBps[1000000017689078940351009940] = 7469; - rayToBps[1000000017690894092047015496] = 7470; - rayToBps[1000000017692709139844927726] = 7471; - rayToBps[1000000017694524083756640068] = 7472; - rayToBps[1000000017696338923794043916] = 7473; - rayToBps[1000000017698153659969028624] = 7474; - rayToBps[1000000017699968292293481503] = 7475; - rayToBps[1000000017701782820779287826] = 7476; - rayToBps[1000000017703597245438330823] = 7477; - rayToBps[1000000017705411566282491686] = 7478; - rayToBps[1000000017707225783323649568] = 7479; - rayToBps[1000000017709039896573681579] = 7480; - rayToBps[1000000017710853906044462798] = 7481; - rayToBps[1000000017712667811747866261] = 7482; - rayToBps[1000000017714481613695762967] = 7483; - rayToBps[1000000017716295311900021878] = 7484; - rayToBps[1000000017718108906372509921] = 7485; - rayToBps[1000000017719922397125091988] = 7486; - rayToBps[1000000017721735784169630931] = 7487; - rayToBps[1000000017723549067517987571] = 7488; - rayToBps[1000000017725362247182020693] = 7489; - rayToBps[1000000017727175323173587048] = 7490; - rayToBps[1000000017728988295504541353] = 7491; - rayToBps[1000000017730801164186736290] = 7492; - rayToBps[1000000017732613929232022514] = 7493; - rayToBps[1000000017734426590652248641] = 7494; - rayToBps[1000000017736239148459261259] = 7495; - rayToBps[1000000017738051602664904924] = 7496; - rayToBps[1000000017739863953281022159] = 7497; - rayToBps[1000000017741676200319453460] = 7498; - rayToBps[1000000017743488343792037292] = 7499; - rayToBps[1000000017745300383710610088] = 7500; - rayToBps[1000000017747112320087006255] = 7501; - rayToBps[1000000017748924152933058170] = 7502; - rayToBps[1000000017750735882260596182] = 7503; - rayToBps[1000000017752547508081448613] = 7504; - rayToBps[1000000017754359030407441756] = 7505; - rayToBps[1000000017756170449250399880] = 7506; - rayToBps[1000000017757981764622145224] = 7507; - rayToBps[1000000017759792976534498007] = 7508; - rayToBps[1000000017761604084999276416] = 7509; - rayToBps[1000000017763415090028296618] = 7510; - rayToBps[1000000017765225991633372753] = 7511; - rayToBps[1000000017767036789826316939] = 7512; - rayToBps[1000000017768847484618939268] = 7513; - rayToBps[1000000017770658076023047811] = 7514; - rayToBps[1000000017772468564050448615] = 7515; - rayToBps[1000000017774278948712945708] = 7516; - rayToBps[1000000017776089230022341092] = 7517; - rayToBps[1000000017777899407990434751] = 7518; - rayToBps[1000000017779709482629024645] = 7519; - rayToBps[1000000017781519453949906719] = 7520; - rayToBps[1000000017783329321964874894] = 7521; - rayToBps[1000000017785139086685721072] = 7522; - rayToBps[1000000017786948748124235137] = 7523; - rayToBps[1000000017788758306292204955] = 7524; - rayToBps[1000000017790567761201416374] = 7525; - rayToBps[1000000017792377112863653223] = 7526; - rayToBps[1000000017794186361290697316] = 7527; - rayToBps[1000000017795995506494328448] = 7528; - rayToBps[1000000017797804548486324401] = 7529; - rayToBps[1000000017799613487278460940] = 7530; - rayToBps[1000000017801422322882511813] = 7531; - rayToBps[1000000017803231055310248755] = 7532; - rayToBps[1000000017805039684573441487] = 7533; - rayToBps[1000000017806848210683857715] = 7534; - rayToBps[1000000017808656633653263133] = 7535; - rayToBps[1000000017810464953493421421] = 7536; - rayToBps[1000000017812273170216094248] = 7537; - rayToBps[1000000017814081283833041270] = 7538; - rayToBps[1000000017815889294356020130] = 7539; - rayToBps[1000000017817697201796786462] = 7540; - rayToBps[1000000017819505006167093890] = 7541; - rayToBps[1000000017821312707478694026] = 7542; - rayToBps[1000000017823120305743336473] = 7543; - rayToBps[1000000017824927800972768824] = 7544; - rayToBps[1000000017826735193178736665] = 7545; - rayToBps[1000000017828542482372983573] = 7546; - rayToBps[1000000017830349668567251118] = 7547; - rayToBps[1000000017832156751773278858] = 7548; - rayToBps[1000000017833963732002804350] = 7549; - rayToBps[1000000017835770609267563142] = 7550; - rayToBps[1000000017837577383579288776] = 7551; - rayToBps[1000000017839384054949712789] = 7552; - rayToBps[1000000017841190623390564711] = 7553; - rayToBps[1000000017842997088913572069] = 7554; - rayToBps[1000000017844803451530460387] = 7555; - rayToBps[1000000017846609711252953183] = 7556; - rayToBps[1000000017848415868092771972] = 7557; - rayToBps[1000000017850221922061636268] = 7558; - rayToBps[1000000017852027873171263580] = 7559; - rayToBps[1000000017853833721433369417] = 7560; - rayToBps[1000000017855639466859667286] = 7561; - rayToBps[1000000017857445109461868694] = 7562; - rayToBps[1000000017859250649251683144] = 7563; - rayToBps[1000000017861056086240818144] = 7564; - rayToBps[1000000017862861420440979199] = 7565; - rayToBps[1000000017864666651863869815] = 7566; - rayToBps[1000000017866471780521191500] = 7567; - rayToBps[1000000017868276806424643763] = 7568; - rayToBps[1000000017870081729585924118] = 7569; - rayToBps[1000000017871886550016728077] = 7570; - rayToBps[1000000017873691267728749159] = 7571; - rayToBps[1000000017875495882733678884] = 7572; - rayToBps[1000000017877300395043206778] = 7573; - rayToBps[1000000017879104804669020371] = 7574; - rayToBps[1000000017880909111622805195] = 7575; - rayToBps[1000000017882713315916244793] = 7576; - rayToBps[1000000017884517417561020708] = 7577; - rayToBps[1000000017886321416568812494] = 7578; - rayToBps[1000000017888125312951297708] = 7579; - rayToBps[1000000017889929106720151917] = 7580; - rayToBps[1000000017891732797887048694] = 7581; - rayToBps[1000000017893536386463659622] = 7582; - rayToBps[1000000017895339872461654288] = 7583; - rayToBps[1000000017897143255892700294] = 7584; - rayToBps[1000000017898946536768463247] = 7585; - rayToBps[1000000017900749715100606767] = 7586; - rayToBps[1000000017902552790900792481] = 7587; - rayToBps[1000000017904355764180680030] = 7588; - rayToBps[1000000017906158634951927065] = 7589; - rayToBps[1000000017907961403226189248] = 7590; - rayToBps[1000000017909764069015120253] = 7591; - rayToBps[1000000017911566632330371770] = 7592; - rayToBps[1000000017913369093183593497] = 7593; - rayToBps[1000000017915171451586433149] = 7594; - rayToBps[1000000017916973707550536454] = 7595; - rayToBps[1000000017918775861087547154] = 7596; - rayToBps[1000000017920577912209107007] = 7597; - rayToBps[1000000017922379860926855785] = 7598; - rayToBps[1000000017924181707252431276] = 7599; - rayToBps[1000000017925983451197469286] = 7600; - rayToBps[1000000017927785092773603635] = 7601; - rayToBps[1000000017929586631992466162] = 7602; - rayToBps[1000000017931388068865686724] = 7603; - rayToBps[1000000017933189403404893193] = 7604; - rayToBps[1000000017934990635621711463] = 7605; - rayToBps[1000000017936791765527765445] = 7606; - rayToBps[1000000017938592793134677070] = 7607; - rayToBps[1000000017940393718454066288] = 7608; - rayToBps[1000000017942194541497551072] = 7609; - rayToBps[1000000017943995262276747410] = 7610; - rayToBps[1000000017945795880803269319] = 7611; - rayToBps[1000000017947596397088728831] = 7612; - rayToBps[1000000017949396811144736003] = 7613; - rayToBps[1000000017951197122982898913] = 7614; - rayToBps[1000000017952997332614823666] = 7615; - rayToBps[1000000017954797440052114387] = 7616; - rayToBps[1000000017956597445306373223] = 7617; - rayToBps[1000000017958397348389200349] = 7618; - rayToBps[1000000017960197149312193963] = 7619; - rayToBps[1000000017961996848086950291] = 7620; - rayToBps[1000000017963796444725063580] = 7621; - rayToBps[1000000017965595939238126106] = 7622; - rayToBps[1000000017967395331637728171] = 7623; - rayToBps[1000000017969194621935458105] = 7624; - rayToBps[1000000017970993810142902264] = 7625; - rayToBps[1000000017972792896271645032] = 7626; - rayToBps[1000000017974591880333268823] = 7627; - rayToBps[1000000017976390762339354077] = 7628; - rayToBps[1000000017978189542301479266] = 7629; - rayToBps[1000000017979988220231220891] = 7630; - rayToBps[1000000017981786796140153482] = 7631; - rayToBps[1000000017983585270039849600] = 7632; - rayToBps[1000000017985383641941879838] = 7633; - rayToBps[1000000017987181911857812820] = 7634; - rayToBps[1000000017988980079799215201] = 7635; - rayToBps[1000000017990778145777651670] = 7636; - rayToBps[1000000017992576109804684946] = 7637; - rayToBps[1000000017994373971891875786] = 7638; - rayToBps[1000000017996171732050782977] = 7639; - rayToBps[1000000017997969390292963342] = 7640; - rayToBps[1000000017999766946629971735] = 7641; - rayToBps[1000000018001564401073361051] = 7642; - rayToBps[1000000018003361753634682215] = 7643; - rayToBps[1000000018005159004325484191] = 7644; - rayToBps[1000000018006956153157313979] = 7645; - rayToBps[1000000018008753200141716615] = 7646; - rayToBps[1000000018010550145290235173] = 7647; - rayToBps[1000000018012346988614410765] = 7648; - rayToBps[1000000018014143730125782540] = 7649; - rayToBps[1000000018015940369835887686] = 7650; - rayToBps[1000000018017736907756261431] = 7651; - rayToBps[1000000018019533343898437042] = 7652; - rayToBps[1000000018021329678273945825] = 7653; - rayToBps[1000000018023125910894317128] = 7654; - rayToBps[1000000018024922041771078339] = 7655; - rayToBps[1000000018026718070915754887] = 7656; - rayToBps[1000000018028513998339870242] = 7657; - rayToBps[1000000018030309824054945918] = 7658; - rayToBps[1000000018032105548072501472] = 7659; - rayToBps[1000000018033901170404054502] = 7660; - rayToBps[1000000018035696691061120650] = 7661; - rayToBps[1000000018037492110055213602] = 7662; - rayToBps[1000000018039287427397845090] = 7663; - rayToBps[1000000018041082643100524888] = 7664; - rayToBps[1000000018042877757174760818] = 7665; - rayToBps[1000000018044672769632058746] = 7666; - rayToBps[1000000018046467680483922585] = 7667; - rayToBps[1000000018048262489741854293] = 7668; - rayToBps[1000000018050057197417353878] = 7669; - rayToBps[1000000018051851803521919393] = 7670; - rayToBps[1000000018053646308067046939] = 7671; - rayToBps[1000000018055440711064230668] = 7672; - rayToBps[1000000018057235012524962777] = 7673; - rayToBps[1000000018059029212460733515] = 7674; - rayToBps[1000000018060823310883031179] = 7675; - rayToBps[1000000018062617307803342118] = 7676; - rayToBps[1000000018064411203233150730] = 7677; - rayToBps[1000000018066204997183939464] = 7678; - rayToBps[1000000018067998689667188822] = 7679; - rayToBps[1000000018069792280694377358] = 7680; - rayToBps[1000000018071585770276981673] = 7681; - rayToBps[1000000018073379158426476430] = 7682; - rayToBps[1000000018075172445154334336] = 7683; - rayToBps[1000000018076965630472026159] = 7684; - rayToBps[1000000018078758714391020716] = 7685; - rayToBps[1000000018080551696922784882] = 7686; - rayToBps[1000000018082344578078783584] = 7687; - rayToBps[1000000018084137357870479807] = 7688; - rayToBps[1000000018085930036309334591] = 7689; - rayToBps[1000000018087722613406807031] = 7690; - rayToBps[1000000018089515089174354279] = 7691; - rayToBps[1000000018091307463623431547] = 7692; - rayToBps[1000000018093099736765492103] = 7693; - rayToBps[1000000018094891908611987271] = 7694; - rayToBps[1000000018096683979174366435] = 7695; - rayToBps[1000000018098475948464077039] = 7696; - rayToBps[1000000018100267816492564585] = 7697; - rayToBps[1000000018102059583271272636] = 7698; - rayToBps[1000000018103851248811642814] = 7699; - rayToBps[1000000018105642813125114801] = 7700; - rayToBps[1000000018107434276223126344] = 7701; - rayToBps[1000000018109225638117113246] = 7702; - rayToBps[1000000018111016898818509377] = 7703; - rayToBps[1000000018112808058338746667] = 7704; - rayToBps[1000000018114599116689255107] = 7705; - rayToBps[1000000018116390073881462757] = 7706; - rayToBps[1000000018118180929926795735] = 7707; - rayToBps[1000000018119971684836678225] = 7708; - rayToBps[1000000018121762338622532479] = 7709; - rayToBps[1000000018123552891295778807] = 7710; - rayToBps[1000000018125343342867835592] = 7711; - rayToBps[1000000018127133693350119278] = 7712; - rayToBps[1000000018128923942754044379] = 7713; - rayToBps[1000000018130714091091023470] = 7714; - rayToBps[1000000018132504138372467200] = 7715; - rayToBps[1000000018134294084609784283] = 7716; - rayToBps[1000000018136083929814381499] = 7717; - rayToBps[1000000018137873673997663698] = 7718; - rayToBps[1000000018139663317171033802] = 7719; - rayToBps[1000000018141452859345892798] = 7720; - rayToBps[1000000018143242300533639746] = 7721; - rayToBps[1000000018145031640745671772] = 7722; - rayToBps[1000000018146820879993384079] = 7723; - rayToBps[1000000018148610018288169936] = 7724; - rayToBps[1000000018150399055641420686] = 7725; - rayToBps[1000000018152187992064525743] = 7726; - rayToBps[1000000018153976827568872596] = 7727; - rayToBps[1000000018155765562165846803] = 7728; - rayToBps[1000000018157554195866831997] = 7729; - rayToBps[1000000018159342728683209886] = 7730; - rayToBps[1000000018161131160626360252] = 7731; - rayToBps[1000000018162919491707660948] = 7732; - rayToBps[1000000018164707721938487908] = 7733; - rayToBps[1000000018166495851330215138] = 7734; - rayToBps[1000000018168283879894214720] = 7735; - rayToBps[1000000018170071807641856811] = 7736; - rayToBps[1000000018171859634584509651] = 7737; - rayToBps[1000000018173647360733539548] = 7738; - rayToBps[1000000018175434986100310896] = 7739; - rayToBps[1000000018177222510696186163] = 7740; - rayToBps[1000000018179009934532525896] = 7741; - rayToBps[1000000018180797257620688721] = 7742; - rayToBps[1000000018182584479972031343] = 7743; - rayToBps[1000000018184371601597908550] = 7744; - rayToBps[1000000018186158622509673205] = 7745; - rayToBps[1000000018187945542718676256] = 7746; - rayToBps[1000000018189732362236266731] = 7747; - rayToBps[1000000018191519081073791739] = 7748; - rayToBps[1000000018193305699242596471] = 7749; - rayToBps[1000000018195092216754024201] = 7750; - rayToBps[1000000018196878633619416285] = 7751; - rayToBps[1000000018198664949850112165] = 7752; - rayToBps[1000000018200451165457449362] = 7753; - rayToBps[1000000018202237280452763485] = 7754; - rayToBps[1000000018204023294847388227] = 7755; - rayToBps[1000000018205809208652655365] = 7756; - rayToBps[1000000018207595021879894762] = 7757; - rayToBps[1000000018209380734540434368] = 7758; - rayToBps[1000000018211166346645600216] = 7759; - rayToBps[1000000018212951858206716428] = 7760; - rayToBps[1000000018214737269235105217] = 7761; - rayToBps[1000000018216522579742086876] = 7762; - rayToBps[1000000018218307789738979791] = 7763; - rayToBps[1000000018220092899237100435] = 7764; - rayToBps[1000000018221877908247763371] = 7765; - rayToBps[1000000018223662816782281250] = 7766; - rayToBps[1000000018225447624851964814] = 7767; - rayToBps[1000000018227232332468122895] = 7768; - rayToBps[1000000018229016939642062413] = 7769; - rayToBps[1000000018230801446385088385] = 7770; - rayToBps[1000000018232585852708503911] = 7771; - rayToBps[1000000018234370158623610192] = 7772; - rayToBps[1000000018236154364141706515] = 7773; - rayToBps[1000000018237938469274090263] = 7774; - rayToBps[1000000018239722474032056911] = 7775; - rayToBps[1000000018241506378426900026] = 7776; - rayToBps[1000000018243290182469911273] = 7777; - rayToBps[1000000018245073886172380408] = 7778; - rayToBps[1000000018246857489545595283] = 7779; - rayToBps[1000000018248640992600841846] = 7780; - rayToBps[1000000018250424395349404142] = 7781; - rayToBps[1000000018252207697802564308] = 7782; - rayToBps[1000000018253990899971602583] = 7783; - rayToBps[1000000018255774001867797298] = 7784; - rayToBps[1000000018257557003502424884] = 7785; - rayToBps[1000000018259339904886759871] = 7786; - rayToBps[1000000018261122706032074886] = 7787; - rayToBps[1000000018262905406949640654] = 7788; - rayToBps[1000000018264688007650726000] = 7789; - rayToBps[1000000018266470508146597849] = 7790; - rayToBps[1000000018268252908448521228] = 7791; - rayToBps[1000000018270035208567759259] = 7792; - rayToBps[1000000018271817408515573169] = 7793; - rayToBps[1000000018273599508303222287] = 7794; - rayToBps[1000000018275381507941964042] = 7795; - rayToBps[1000000018277163407443053964] = 7796; - rayToBps[1000000018278945206817745690] = 7797; - rayToBps[1000000018280726906077290954] = 7798; - rayToBps[1000000018282508505232939599] = 7799; - rayToBps[1000000018284290004295939569] = 7800; - rayToBps[1000000018286071403277536912] = 7801; - rayToBps[1000000018287852702188975783] = 7802; - rayToBps[1000000018289633901041498440] = 7803; - rayToBps[1000000018291414999846345249] = 7804; - rayToBps[1000000018293195998614754679] = 7805; - rayToBps[1000000018294976897357963307] = 7806; - rayToBps[1000000018296757696087205817] = 7807; - rayToBps[1000000018298538394813715001] = 7808; - rayToBps[1000000018300318993548721757] = 7809; - rayToBps[1000000018302099492303455093] = 7810; - rayToBps[1000000018303879891089142124] = 7811; - rayToBps[1000000018305660189917008076] = 7812; - rayToBps[1000000018307440388798276281] = 7813; - rayToBps[1000000018309220487744168184] = 7814; - rayToBps[1000000018311000486765903339] = 7815; - rayToBps[1000000018312780385874699412] = 7816; - rayToBps[1000000018314560185081772178] = 7817; - rayToBps[1000000018316339884398335526] = 7818; - rayToBps[1000000018318119483835601454] = 7819; - rayToBps[1000000018319898983404780074] = 7820; - rayToBps[1000000018321678383117079613] = 7821; - rayToBps[1000000018323457682983706407] = 7822; - rayToBps[1000000018325236883015864909] = 7823; - rayToBps[1000000018327015983224757684] = 7824; - rayToBps[1000000018328794983621585414] = 7825; - rayToBps[1000000018330573884217546893] = 7826; - rayToBps[1000000018332352685023839031] = 7827; - rayToBps[1000000018334131386051656857] = 7828; - rayToBps[1000000018335909987312193512] = 7829; - rayToBps[1000000018337688488816640255] = 7830; - rayToBps[1000000018339466890576186465] = 7831; - rayToBps[1000000018341245192602019632] = 7832; - rayToBps[1000000018343023394905325372] = 7833; - rayToBps[1000000018344801497497287412] = 7834; - rayToBps[1000000018346579500389087603] = 7835; - rayToBps[1000000018348357403591905911] = 7836; - rayToBps[1000000018350135207116920426] = 7837; - rayToBps[1000000018351912910975307354] = 7838; - rayToBps[1000000018353690515178241024] = 7839; - rayToBps[1000000018355468019736893884] = 7840; - rayToBps[1000000018357245424662436505] = 7841; - rayToBps[1000000018359022729966037580] = 7842; - rayToBps[1000000018360799935658863920] = 7843; - rayToBps[1000000018362577041752080465] = 7844; - rayToBps[1000000018364354048256850272] = 7845; - rayToBps[1000000018366130955184334526] = 7846; - rayToBps[1000000018367907762545692533] = 7847; - rayToBps[1000000018369684470352081722] = 7848; - rayToBps[1000000018371461078614657652] = 7849; - rayToBps[1000000018373237587344574003] = 7850; - rayToBps[1000000018375013996552982578] = 7851; - rayToBps[1000000018376790306251033313] = 7852; - rayToBps[1000000018378566516449874264] = 7853; - rayToBps[1000000018380342627160651618] = 7854; - rayToBps[1000000018382118638394509685] = 7855; - rayToBps[1000000018383894550162590906] = 7856; - rayToBps[1000000018385670362476035850] = 7857; - rayToBps[1000000018387446075345983212] = 7858; - rayToBps[1000000018389221688783569817] = 7859; - rayToBps[1000000018390997202799930621] = 7860; - rayToBps[1000000018392772617406198706] = 7861; - rayToBps[1000000018394547932613505288] = 7862; - rayToBps[1000000018396323148432979711] = 7863; - rayToBps[1000000018398098264875749451] = 7864; - rayToBps[1000000018399873281952940114] = 7865; - rayToBps[1000000018401648199675675439] = 7866; - rayToBps[1000000018403423018055077298] = 7867; - rayToBps[1000000018405197737102265694] = 7868; - rayToBps[1000000018406972356828358763] = 7869; - rayToBps[1000000018408746877244472776] = 7870; - rayToBps[1000000018410521298361722136] = 7871; - rayToBps[1000000018412295620191219382] = 7872; - rayToBps[1000000018414069842744075188] = 7873; - rayToBps[1000000018415843966031398359] = 7874; - rayToBps[1000000018417617990064295840] = 7875; - rayToBps[1000000018419391914853872712] = 7876; - rayToBps[1000000018421165740411232189] = 7877; - rayToBps[1000000018422939466747475623] = 7878; - rayToBps[1000000018424713093873702506] = 7879; - rayToBps[1000000018426486621801010465] = 7880; - rayToBps[1000000018428260050540495264] = 7881; - rayToBps[1000000018430033380103250808] = 7882; - rayToBps[1000000018431806610500369140] = 7883; - rayToBps[1000000018433579741742940441] = 7884; - rayToBps[1000000018435352773842053034] = 7885; - rayToBps[1000000018437125706808793381] = 7886; - rayToBps[1000000018438898540654246083] = 7887; - rayToBps[1000000018440671275389493885] = 7888; - rayToBps[1000000018442443911025617670] = 7889; - rayToBps[1000000018444216447573696466] = 7890; - rayToBps[1000000018445988885044807442] = 7891; - rayToBps[1000000018447761223450025908] = 7892; - rayToBps[1000000018449533462800425319] = 7893; - rayToBps[1000000018451305603107077273] = 7894; - rayToBps[1000000018453077644381051511] = 7895; - rayToBps[1000000018454849586633415920] = 7896; - rayToBps[1000000018456621429875236530] = 7897; - rayToBps[1000000018458393174117577515] = 7898; - rayToBps[1000000018460164819371501200] = 7899; - rayToBps[1000000018461936365648068049] = 7900; - rayToBps[1000000018463707812958336676] = 7901; - rayToBps[1000000018465479161313363842] = 7902; - rayToBps[1000000018467250410724204454] = 7903; - rayToBps[1000000018469021561201911568] = 7904; - rayToBps[1000000018470792612757536386] = 7905; - rayToBps[1000000018472563565402128258] = 7906; - rayToBps[1000000018474334419146734687] = 7907; - rayToBps[1000000018476105174002401321] = 7908; - rayToBps[1000000018477875829980171960] = 7909; - rayToBps[1000000018479646387091088551] = 7910; - rayToBps[1000000018481416845346191196] = 7911; - rayToBps[1000000018483187204756518145] = 7912; - rayToBps[1000000018484957465333105800] = 7913; - rayToBps[1000000018486727627086988714] = 7914; - rayToBps[1000000018488497690029199592] = 7915; - rayToBps[1000000018490267654170769294] = 7916; - rayToBps[1000000018492037519522726829] = 7917; - rayToBps[1000000018493807286096099365] = 7918; - rayToBps[1000000018495576953901912217] = 7919; - rayToBps[1000000018497346522951188860] = 7920; - rayToBps[1000000018499115993254950919] = 7921; - rayToBps[1000000018500885364824218178] = 7922; - rayToBps[1000000018502654637670008573] = 7923; - rayToBps[1000000018504423811803338199] = 7924; - rayToBps[1000000018506192887235221305] = 7925; - rayToBps[1000000018507961863976670296] = 7926; - rayToBps[1000000018509730742038695738] = 7927; - rayToBps[1000000018511499521432306350] = 7928; - rayToBps[1000000018513268202168509012] = 7929; - rayToBps[1000000018515036784258308760] = 7930; - rayToBps[1000000018516805267712708791] = 7931; - rayToBps[1000000018518573652542710459] = 7932; - rayToBps[1000000018520341938759313279] = 7933; - rayToBps[1000000018522110126373514925] = 7934; - rayToBps[1000000018523878215396311232] = 7935; - rayToBps[1000000018525646205838696196] = 7936; - rayToBps[1000000018527414097711661974] = 7937; - rayToBps[1000000018529181891026198882] = 7938; - rayToBps[1000000018530949585793295404] = 7939; - rayToBps[1000000018532717182023938179] = 7940; - rayToBps[1000000018534484679729112016] = 7941; - rayToBps[1000000018536252078919799882] = 7942; - rayToBps[1000000018538019379606982909] = 7943; - rayToBps[1000000018539786581801640396] = 7944; - rayToBps[1000000018541553685514749800] = 7945; - rayToBps[1000000018543320690757286750] = 7946; - rayToBps[1000000018545087597540225037] = 7947; - rayToBps[1000000018546854405874536615] = 7948; - rayToBps[1000000018548621115771191610] = 7949; - rayToBps[1000000018550387727241158310] = 7950; - rayToBps[1000000018552154240295403172] = 7951; - rayToBps[1000000018553920654944890818] = 7952; - rayToBps[1000000018555686971200584040] = 7953; - rayToBps[1000000018557453189073443800] = 7954; - rayToBps[1000000018559219308574429223] = 7955; - rayToBps[1000000018560985329714497605] = 7956; - rayToBps[1000000018562751252504604416] = 7957; - rayToBps[1000000018564517076955703290] = 7958; - rayToBps[1000000018566282803078746033] = 7959; - rayToBps[1000000018568048430884682622] = 7960; - rayToBps[1000000018569813960384461207] = 7961; - rayToBps[1000000018571579391589028103] = 7962; - rayToBps[1000000018573344724509327805] = 7963; - rayToBps[1000000018575109959156302976] = 7964; - rayToBps[1000000018576875095540894448] = 7965; - rayToBps[1000000018578640133674041234] = 7966; - rayToBps[1000000018580405073566680515] = 7967; - rayToBps[1000000018582169915229747647] = 7968; - rayToBps[1000000018583934658674176160] = 7969; - rayToBps[1000000018585699303910897760] = 7970; - rayToBps[1000000018587463850950842326] = 7971; - rayToBps[1000000018589228299804937915] = 7972; - rayToBps[1000000018590992650484110758] = 7973; - rayToBps[1000000018592756902999285262] = 7974; - rayToBps[1000000018594521057361384012] = 7975; - rayToBps[1000000018596285113581327769] = 7976; - rayToBps[1000000018598049071670035472] = 7977; - rayToBps[1000000018599812931638424240] = 7978; - rayToBps[1000000018601576693497409365] = 7979; - rayToBps[1000000018603340357257904322] = 7980; - rayToBps[1000000018605103922930820766] = 7981; - rayToBps[1000000018606867390527068528] = 7982; - rayToBps[1000000018608630760057555620] = 7983; - rayToBps[1000000018610394031533188235] = 7984; - rayToBps[1000000018612157204964870748] = 7985; - rayToBps[1000000018613920280363505711] = 7986; - rayToBps[1000000018615683257739993862] = 7987; - rayToBps[1000000018617446137105234120] = 7988; - rayToBps[1000000018619208918470123584] = 7989; - rayToBps[1000000018620971601845557538] = 7990; - rayToBps[1000000018622734187242429447] = 7991; - rayToBps[1000000018624496674671630963] = 7992; - rayToBps[1000000018626259064144051920] = 7993; - rayToBps[1000000018628021355670580334] = 7994; - rayToBps[1000000018629783549262102411] = 7995; - rayToBps[1000000018631545644929502537] = 7996; - rayToBps[1000000018633307642683663287] = 7997; - rayToBps[1000000018635069542535465422] = 7998; - rayToBps[1000000018636831344495787885] = 7999; - rayToBps[1000000018638593048575507813] = 8000; - rayToBps[1000000018640354654785500524] = 8001; - rayToBps[1000000018642116163136639525] = 8002; - rayToBps[1000000018643877573639796513] = 8003; - rayToBps[1000000018645638886305841373] = 8004; - rayToBps[1000000018647400101145642177] = 8005; - rayToBps[1000000018649161218170065187] = 8006; - rayToBps[1000000018650922237389974856] = 8007; - rayToBps[1000000018652683158816233826] = 8008; - rayToBps[1000000018654443982459702927] = 8009; - rayToBps[1000000018656204708331241185] = 8010; - rayToBps[1000000018657965336441705812] = 8011; - rayToBps[1000000018659725866801952216] = 8012; - rayToBps[1000000018661486299422833994] = 8013; - rayToBps[1000000018663246634315202936] = 8014; - rayToBps[1000000018665006871489909025] = 8015; - rayToBps[1000000018666767010957800439] = 8016; - rayToBps[1000000018668527052729723547] = 8017; - rayToBps[1000000018670286996816522913] = 8018; - rayToBps[1000000018672046843229041295] = 8019; - rayToBps[1000000018673806591978119648] = 8020; - rayToBps[1000000018675566243074597119] = 8021; - rayToBps[1000000018677325796529311054] = 8022; - rayToBps[1000000018679085252353096991] = 8023; - rayToBps[1000000018680844610556788668] = 8024; - rayToBps[1000000018682603871151218019] = 8025; - rayToBps[1000000018684363034147215174] = 8026; - rayToBps[1000000018686122099555608460] = 8027; - rayToBps[1000000018687881067387224406] = 8028; - rayToBps[1000000018689639937652887737] = 8029; - rayToBps[1000000018691398710363421374] = 8030; - rayToBps[1000000018693157385529646441] = 8031; - rayToBps[1000000018694915963162382261] = 8032; - rayToBps[1000000018696674443272446357] = 8033; - rayToBps[1000000018698432825870654450] = 8034; - rayToBps[1000000018700191110967820466] = 8035; - rayToBps[1000000018701949298574756529] = 8036; - rayToBps[1000000018703707388702272967] = 8037; - rayToBps[1000000018705465381361178307] = 8038; - rayToBps[1000000018707223276562279280] = 8039; - rayToBps[1000000018708981074316380821] = 8040; - rayToBps[1000000018710738774634286066] = 8041; - rayToBps[1000000018712496377526796358] = 8042; - rayToBps[1000000018714253883004711240] = 8043; - rayToBps[1000000018716011291078828461] = 8044; - rayToBps[1000000018717768601759943976] = 8045; - rayToBps[1000000018719525815058851943] = 8046; - rayToBps[1000000018721282930986344728] = 8047; - rayToBps[1000000018723039949553212902] = 8048; - rayToBps[1000000018724796870770245242] = 8049; - rayToBps[1000000018726553694648228732] = 8050; - rayToBps[1000000018728310421197948562] = 8051; - rayToBps[1000000018730067050430188132] = 8052; - rayToBps[1000000018731823582355729050] = 8053; - rayToBps[1000000018733580016985351129] = 8054; - rayToBps[1000000018735336354329832394] = 8055; - rayToBps[1000000018737092594399949079] = 8056; - rayToBps[1000000018738848737206475625] = 8057; - rayToBps[1000000018740604782760184687] = 8058; - rayToBps[1000000018742360731071847127] = 8059; - rayToBps[1000000018744116582152232018] = 8060; - rayToBps[1000000018745872336012106646] = 8061; - rayToBps[1000000018747627992662236508] = 8062; - rayToBps[1000000018749383552113385312] = 8063; - rayToBps[1000000018751139014376314979] = 8064; - rayToBps[1000000018752894379461785643] = 8065; - rayToBps[1000000018754649647380555651] = 8066; - rayToBps[1000000018756404818143381562] = 8067; - rayToBps[1000000018758159891761018152] = 8068; - rayToBps[1000000018759914868244218410] = 8069; - rayToBps[1000000018761669747603733537] = 8070; - rayToBps[1000000018763424529850312954] = 8071; - rayToBps[1000000018765179214994704293] = 8072; - rayToBps[1000000018766933803047653406] = 8073; - rayToBps[1000000018768688294019904359] = 8074; - rayToBps[1000000018770442687922199432] = 8075; - rayToBps[1000000018772196984765279129] = 8076; - rayToBps[1000000018773951184559882166] = 8077; - rayToBps[1000000018775705287316745477] = 8078; - rayToBps[1000000018777459293046604218] = 8079; - rayToBps[1000000018779213201760191760] = 8080; - rayToBps[1000000018780967013468239695] = 8081; - rayToBps[1000000018782720728181477833] = 8082; - rayToBps[1000000018784474345910634206] = 8083; - rayToBps[1000000018786227866666435065] = 8084; - rayToBps[1000000018787981290459604881] = 8085; - rayToBps[1000000018789734617300866347] = 8086; - rayToBps[1000000018791487847200940377] = 8087; - rayToBps[1000000018793240980170546107] = 8088; - rayToBps[1000000018794994016220400896] = 8089; - rayToBps[1000000018796746955361220324] = 8090; - rayToBps[1000000018798499797603718194] = 8091; - rayToBps[1000000018800252542958606535] = 8092; - rayToBps[1000000018802005191436595596] = 8093; - rayToBps[1000000018803757743048393855] = 8094; - rayToBps[1000000018805510197804708009] = 8095; - rayToBps[1000000018807262555716242984] = 8096; - rayToBps[1000000018809014816793701930] = 8097; - rayToBps[1000000018810766981047786222] = 8098; - rayToBps[1000000018812519048489195463] = 8099; - rayToBps[1000000018814271019128627481] = 8100; - rayToBps[1000000018816022892976778332] = 8101; - rayToBps[1000000018817774670044342299] = 8102; - rayToBps[1000000018819526350342011891] = 8103; - rayToBps[1000000018821277933880477847] = 8104; - rayToBps[1000000018823029420670429136] = 8105; - rayToBps[1000000018824780810722552952] = 8106; - rayToBps[1000000018826532104047534720] = 8107; - rayToBps[1000000018828283300656058095] = 8108; - rayToBps[1000000018830034400558804964] = 8109; - rayToBps[1000000018831785403766455440] = 8110; - rayToBps[1000000018833536310289687871] = 8111; - rayToBps[1000000018835287120139178833] = 8112; - rayToBps[1000000018837037833325603137] = 8113; - rayToBps[1000000018838788449859633821] = 8114; - rayToBps[1000000018840538969751942163] = 8115; - rayToBps[1000000018842289393013197665] = 8116; - rayToBps[1000000018844039719654068068] = 8117; - rayToBps[1000000018845789949685219346] = 8118; - rayToBps[1000000018847540083117315706] = 8119; - rayToBps[1000000018849290119961019588] = 8120; - rayToBps[1000000018851040060226991670] = 8121; - rayToBps[1000000018852789903925890862] = 8122; - rayToBps[1000000018854539651068374310] = 8123; - rayToBps[1000000018856289301665097399] = 8124; - rayToBps[1000000018858038855726713746] = 8125; - rayToBps[1000000018859788313263875208] = 8126; - rayToBps[1000000018861537674287231877] = 8127; - rayToBps[1000000018863286938807432083] = 8128; - rayToBps[1000000018865036106835122396] = 8129; - rayToBps[1000000018866785178380947620] = 8130; - rayToBps[1000000018868534153455550800] = 8131; - rayToBps[1000000018870283032069573223] = 8132; - rayToBps[1000000018872031814233654409] = 8133; - rayToBps[1000000018873780499958432124] = 8134; - rayToBps[1000000018875529089254542368] = 8135; - rayToBps[1000000018877277582132619389] = 8136; - rayToBps[1000000018879025978603295669] = 8137; - rayToBps[1000000018880774278677201936] = 8138; - rayToBps[1000000018882522482364967158] = 8139; - rayToBps[1000000018884270589677218543] = 8140; - rayToBps[1000000018886018600624581547] = 8141; - rayToBps[1000000018887766515217679862] = 8142; - rayToBps[1000000018889514333467135430] = 8143; - rayToBps[1000000018891262055383568433] = 8144; - rayToBps[1000000018893009680977597295] = 8145; - rayToBps[1000000018894757210259838691] = 8146; - rayToBps[1000000018896504643240907534] = 8147; - rayToBps[1000000018898251979931416987] = 8148; - rayToBps[1000000018899999220341978457] = 8149; - rayToBps[1000000018901746364483201594] = 8150; - rayToBps[1000000018903493412365694300] = 8151; - rayToBps[1000000018905240364000062719] = 8152; - rayToBps[1000000018906987219396911245] = 8153; - rayToBps[1000000018908733978566842519] = 8154; - rayToBps[1000000018910480641520457429] = 8155; - rayToBps[1000000018912227208268355112] = 8156; - rayToBps[1000000018913973678821132954] = 8157; - rayToBps[1000000018915720053189386589] = 8158; - rayToBps[1000000018917466331383709901] = 8159; - rayToBps[1000000018919212513414695026] = 8160; - rayToBps[1000000018920958599292932347] = 8161; - rayToBps[1000000018922704589029010497] = 8162; - rayToBps[1000000018924450482633516364] = 8163; - rayToBps[1000000018926196280117035085] = 8164; - rayToBps[1000000018927941981490150050] = 8165; - rayToBps[1000000018929687586763442899] = 8166; - rayToBps[1000000018931433095947493526] = 8167; - rayToBps[1000000018933178509052880078] = 8168; - rayToBps[1000000018934923826090178954] = 8169; - rayToBps[1000000018936669047069964810] = 8170; - rayToBps[1000000018938414172002810552] = 8171; - rayToBps[1000000018940159200899287344] = 8172; - rayToBps[1000000018941904133769964603] = 8173; - rayToBps[1000000018943648970625410000] = 8174; - rayToBps[1000000018945393711476189463] = 8175; - rayToBps[1000000018947138356332867178] = 8176; - rayToBps[1000000018948882905206005585] = 8177; - rayToBps[1000000018950627358106165381] = 8178; - rayToBps[1000000018952371715043905520] = 8179; - rayToBps[1000000018954115976029783215] = 8180; - rayToBps[1000000018955860141074353935] = 8181; - rayToBps[1000000018957604210188171410] = 8182; - rayToBps[1000000018959348183381787625] = 8183; - rayToBps[1000000018961092060665752828] = 8184; - rayToBps[1000000018962835842050615522] = 8185; - rayToBps[1000000018964579527546922474] = 8186; - rayToBps[1000000018966323117165218711] = 8187; - rayToBps[1000000018968066610916047517] = 8188; - rayToBps[1000000018969810008809950439] = 8189; - rayToBps[1000000018971553310857467288] = 8190; - rayToBps[1000000018973296517069136132] = 8191; - rayToBps[1000000018975039627455493305] = 8192; - rayToBps[1000000018976782642027073402] = 8193; - rayToBps[1000000018978525560794409280] = 8194; - rayToBps[1000000018980268383768032061] = 8195; - rayToBps[1000000018982011110958471130] = 8196; - rayToBps[1000000018983753742376254135] = 8197; - rayToBps[1000000018985496278031906990] = 8198; - rayToBps[1000000018987238717935953874] = 8199; - rayToBps[1000000018988981062098917230] = 8200; - rayToBps[1000000018990723310531317765] = 8201; - rayToBps[1000000018992465463243674457] = 8202; - rayToBps[1000000018994207520246504546] = 8203; - rayToBps[1000000018995949481550323540] = 8204; - rayToBps[1000000018997691347165645214] = 8205; - rayToBps[1000000018999433117102981611] = 8206; - rayToBps[1000000019001174791372843041] = 8207; - rayToBps[1000000019002916369985738082] = 8208; - rayToBps[1000000019004657852952173583] = 8209; - rayToBps[1000000019006399240282654660] = 8210; - rayToBps[1000000019008140531987684699] = 8211; - rayToBps[1000000019009881728077765354] = 8212; - rayToBps[1000000019011622828563396552] = 8213; - rayToBps[1000000019013363833455076488] = 8214; - rayToBps[1000000019015104742763301630] = 8215; - rayToBps[1000000019016845556498566716] = 8216; - rayToBps[1000000019018586274671364757] = 8217; - rayToBps[1000000019020326897292187034] = 8218; - rayToBps[1000000019022067424371523101] = 8219; - rayToBps[1000000019023807855919860787] = 8220; - rayToBps[1000000019025548191947686191] = 8221; - rayToBps[1000000019027288432465483687] = 8222; - rayToBps[1000000019029028577483735925] = 8223; - rayToBps[1000000019030768627012923824] = 8224; - rayToBps[1000000019032508581063526585] = 8225; - rayToBps[1000000019034248439646021677] = 8226; - rayToBps[1000000019035988202770884848] = 8227; - rayToBps[1000000019037727870448590123] = 8228; - rayToBps[1000000019039467442689609800] = 8229; - rayToBps[1000000019041206919504414455] = 8230; - rayToBps[1000000019042946300903472942] = 8231; - rayToBps[1000000019044685586897252392] = 8232; - rayToBps[1000000019046424777496218212] = 8233; - rayToBps[1000000019048163872710834089] = 8234; - rayToBps[1000000019049902872551561987] = 8235; - rayToBps[1000000019051641777028862150] = 8236; - rayToBps[1000000019053380586153193101] = 8237; - rayToBps[1000000019055119299935011644] = 8238; - rayToBps[1000000019056857918384772859] = 8239; - rayToBps[1000000019058596441512930110] = 8240; - rayToBps[1000000019060334869329935041] = 8241; - rayToBps[1000000019062073201846237576] = 8242; - rayToBps[1000000019063811439072285921] = 8243; - rayToBps[1000000019065549581018526566] = 8244; - rayToBps[1000000019067287627695404278] = 8245; - rayToBps[1000000019069025579113362113] = 8246; - rayToBps[1000000019070763435282841406] = 8247; - rayToBps[1000000019072501196214281776] = 8248; - rayToBps[1000000019074238861918121125] = 8249; - rayToBps[1000000019075976432404795643] = 8250; - rayToBps[1000000019077713907684739801] = 8251; - rayToBps[1000000019079451287768386354] = 8252; - rayToBps[1000000019081188572666166345] = 8253; - rayToBps[1000000019082925762388509101] = 8254; - rayToBps[1000000019084662856945842236] = 8255; - rayToBps[1000000019086399856348591650] = 8256; - rayToBps[1000000019088136760607181530] = 8257; - rayToBps[1000000019089873569732034349] = 8258; - rayToBps[1000000019091610283733570869] = 8259; - rayToBps[1000000019093346902622210139] = 8260; - rayToBps[1000000019095083426408369496] = 8261; - rayToBps[1000000019096819855102464568] = 8262; - rayToBps[1000000019098556188714909268] = 8263; - rayToBps[1000000019100292427256115802] = 8264; - rayToBps[1000000019102028570736494664] = 8265; - rayToBps[1000000019103764619166454637] = 8266; - rayToBps[1000000019105500572556402798] = 8267; - rayToBps[1000000019107236430916744512] = 8268; - rayToBps[1000000019108972194257883436] = 8269; - rayToBps[1000000019110707862590221519] = 8270; - rayToBps[1000000019112443435924159001] = 8271; - rayToBps[1000000019114178914270094416] = 8272; - rayToBps[1000000019115914297638424590] = 8273; - rayToBps[1000000019117649586039544643] = 8274; - rayToBps[1000000019119384779483847985] = 8275; - rayToBps[1000000019121119877981726323] = 8276; - rayToBps[1000000019122854881543569660] = 8277; - rayToBps[1000000019124589790179766288] = 8278; - rayToBps[1000000019126324603900702800] = 8279; - rayToBps[1000000019128059322716764080] = 8280; - rayToBps[1000000019129793946638333310] = 8281; - rayToBps[1000000019131528475675791968] = 8282; - rayToBps[1000000019133262909839519827] = 8283; - rayToBps[1000000019134997249139894958] = 8284; - rayToBps[1000000019136731493587293730] = 8285; - rayToBps[1000000019138465643192090809] = 8286; - rayToBps[1000000019140199697964659157] = 8287; - rayToBps[1000000019141933657915370038] = 8288; - rayToBps[1000000019143667523054593010] = 8289; - rayToBps[1000000019145401293392695935] = 8290; - rayToBps[1000000019147134968940044972] = 8291; - rayToBps[1000000019148868549707004581] = 8292; - rayToBps[1000000019150602035703937519] = 8293; - rayToBps[1000000019152335426941204848] = 8294; - rayToBps[1000000019154068723429165929] = 8295; - rayToBps[1000000019155801925178178423] = 8296; - rayToBps[1000000019157535032198598294] = 8297; - rayToBps[1000000019159268044500779809] = 8298; - rayToBps[1000000019161000962095075535] = 8299; - rayToBps[1000000019162733784991836346] = 8300; - rayToBps[1000000019164466513201411414] = 8301; - rayToBps[1000000019166199146734148217] = 8302; - rayToBps[1000000019167931685600392538] = 8303; - rayToBps[1000000019169664129810488463] = 8304; - rayToBps[1000000019171396479374778382] = 8305; - rayToBps[1000000019173128734303602993] = 8306; - rayToBps[1000000019174860894607301295] = 8307; - rayToBps[1000000019176592960296210597] = 8308; - rayToBps[1000000019178324931380666510] = 8309; - rayToBps[1000000019180056807871002956] = 8310; - rayToBps[1000000019181788589777552160] = 8311; - rayToBps[1000000019183520277110644657] = 8312; - rayToBps[1000000019185251869880609289] = 8313; - rayToBps[1000000019186983368097773204] = 8314; - rayToBps[1000000019188714771772461861] = 8315; - rayToBps[1000000019190446080914999025] = 8316; - rayToBps[1000000019192177295535706774] = 8317; - rayToBps[1000000019193908415644905492] = 8318; - rayToBps[1000000019195639441252913873] = 8319; - rayToBps[1000000019197370372370048924] = 8320; - rayToBps[1000000019199101209006625961] = 8321; - rayToBps[1000000019200831951172958609] = 8322; - rayToBps[1000000019202562598879358809] = 8323; - rayToBps[1000000019204293152136136807] = 8324; - rayToBps[1000000019206023610953601168] = 8325; - rayToBps[1000000019207753975342058765] = 8326; - rayToBps[1000000019209484245311814785] = 8327; - rayToBps[1000000019211214420873172728] = 8328; - rayToBps[1000000019212944502036434409] = 8329; - rayToBps[1000000019214674488811899953] = 8330; - rayToBps[1000000019216404381209867805] = 8331; - rayToBps[1000000019218134179240634720] = 8332; - rayToBps[1000000019219863882914495771] = 8333; - rayToBps[1000000019221593492241744342] = 8334; - rayToBps[1000000019223323007232672138] = 8335; - rayToBps[1000000019225052427897569177] = 8336; - rayToBps[1000000019226781754246723793] = 8337; - rayToBps[1000000019228510986290422641] = 8338; - rayToBps[1000000019230240124038950687] = 8339; - rayToBps[1000000019231969167502591220] = 8340; - rayToBps[1000000019233698116691625845] = 8341; - rayToBps[1000000019235426971616334484] = 8342; - rayToBps[1000000019237155732286995379] = 8343; - rayToBps[1000000019238884398713885090] = 8344; - rayToBps[1000000019240612970907278498] = 8345; - rayToBps[1000000019242341448877448803] = 8346; - rayToBps[1000000019244069832634667526] = 8347; - rayToBps[1000000019245798122189204505] = 8348; - rayToBps[1000000019247526317551327904] = 8349; - rayToBps[1000000019249254418731304205] = 8350; - rayToBps[1000000019250982425739398211] = 8351; - rayToBps[1000000019252710338585873049] = 8352; - rayToBps[1000000019254438157280990169] = 8353; - rayToBps[1000000019256165881835009342] = 8354; - rayToBps[1000000019257893512258188661] = 8355; - rayToBps[1000000019259621048560784543] = 8356; - rayToBps[1000000019261348490753051732] = 8357; - rayToBps[1000000019263075838845243292] = 8358; - rayToBps[1000000019264803092847610615] = 8359; - rayToBps[1000000019266530252770403415] = 8360; - rayToBps[1000000019268257318623869732] = 8361; - rayToBps[1000000019269984290418255933] = 8362; - rayToBps[1000000019271711168163806709] = 8363; - rayToBps[1000000019273437951870765080] = 8364; - rayToBps[1000000019275164641549372390] = 8365; - rayToBps[1000000019276891237209868311] = 8366; - rayToBps[1000000019278617738862490844] = 8367; - rayToBps[1000000019280344146517476314] = 8368; - rayToBps[1000000019282070460185059378] = 8369; - rayToBps[1000000019283796679875473021] = 8370; - rayToBps[1000000019285522805598948554] = 8371; - rayToBps[1000000019287248837365715621] = 8372; - rayToBps[1000000019288974775186002193] = 8373; - rayToBps[1000000019290700619070034572] = 8374; - rayToBps[1000000019292426369028037391] = 8375; - rayToBps[1000000019294152025070233613] = 8376; - rayToBps[1000000019295877587206844530] = 8377; - rayToBps[1000000019297603055448089770] = 8378; - rayToBps[1000000019299328429804187289] = 8379; - rayToBps[1000000019301053710285353377] = 8380; - rayToBps[1000000019302778896901802656] = 8381; - rayToBps[1000000019304503989663748081] = 8382; - rayToBps[1000000019306228988581400940] = 8383; - rayToBps[1000000019307953893664970854] = 8384; - rayToBps[1000000019309678704924665780] = 8385; - rayToBps[1000000019311403422370692008] = 8386; - rayToBps[1000000019313128046013254162] = 8387; - rayToBps[1000000019314852575862555202] = 8388; - rayToBps[1000000019316577011928796425] = 8389; - rayToBps[1000000019318301354222177460] = 8390; - rayToBps[1000000019320025602752896275] = 8391; - rayToBps[1000000019321749757531149174] = 8392; - rayToBps[1000000019323473818567130798] = 8393; - rayToBps[1000000019325197785871034125] = 8394; - rayToBps[1000000019326921659453050469] = 8395; - rayToBps[1000000019328645439323369486] = 8396; - rayToBps[1000000019330369125492179166] = 8397; - rayToBps[1000000019332092717969665839] = 8398; - rayToBps[1000000019333816216766014177] = 8399; - rayToBps[1000000019335539621891407188] = 8400; - rayToBps[1000000019337262933356026219] = 8401; - rayToBps[1000000019338986151170050961] = 8402; - rayToBps[1000000019340709275343659442] = 8403; - rayToBps[1000000019342432305887028033] = 8404; - rayToBps[1000000019344155242810331446] = 8405; - rayToBps[1000000019345878086123742733] = 8406; - rayToBps[1000000019347600835837433289] = 8407; - rayToBps[1000000019349323491961572852] = 8408; - rayToBps[1000000019351046054506329501] = 8409; - rayToBps[1000000019352768523481869660] = 8410; - rayToBps[1000000019354490898898358095] = 8411; - rayToBps[1000000019356213180765957915] = 8412; - rayToBps[1000000019357935369094830575] = 8413; - rayToBps[1000000019359657463895135874] = 8414; - rayToBps[1000000019361379465177031955] = 8415; - rayToBps[1000000019363101372950675305] = 8416; - rayToBps[1000000019364823187226220761] = 8417; - rayToBps[1000000019366544908013821502] = 8418; - rayToBps[1000000019368266535323629053] = 8419; - rayToBps[1000000019369988069165793289] = 8420; - rayToBps[1000000019371709509550462428] = 8421; - rayToBps[1000000019373430856487783037] = 8422; - rayToBps[1000000019375152109987900033] = 8423; - rayToBps[1000000019376873270060956677] = 8424; - rayToBps[1000000019378594336717094581] = 8425; - rayToBps[1000000019380315309966453706] = 8426; - rayToBps[1000000019382036189819172359] = 8427; - rayToBps[1000000019383756976285387201] = 8428; - rayToBps[1000000019385477669375233239] = 8429; - rayToBps[1000000019387198269098843832] = 8430; - rayToBps[1000000019388918775466350690] = 8431; - rayToBps[1000000019390639188487883872] = 8432; - rayToBps[1000000019392359508173571791] = 8433; - rayToBps[1000000019394079734533541209] = 8434; - rayToBps[1000000019395799867577917242] = 8435; - rayToBps[1000000019397519907316823356] = 8436; - rayToBps[1000000019399239853760381372] = 8437; - rayToBps[1000000019400959706918711464] = 8438; - rayToBps[1000000019402679466801932157] = 8439; - rayToBps[1000000019404399133420160333] = 8440; - rayToBps[1000000019406118706783511225] = 8441; - rayToBps[1000000019407838186902098423] = 8442; - rayToBps[1000000019409557573786033870] = 8443; - rayToBps[1000000019411276867445427867] = 8444; - rayToBps[1000000019412996067890389067] = 8445; - rayToBps[1000000019414715175131024480] = 8446; - rayToBps[1000000019416434189177439474] = 8447; - rayToBps[1000000019418153110039737771] = 8448; - rayToBps[1000000019419871937728021454] = 8449; - rayToBps[1000000019421590672252390959] = 8450; - rayToBps[1000000019423309313622945081] = 8451; - rayToBps[1000000019425027861849780974] = 8452; - rayToBps[1000000019426746316942994151] = 8453; - rayToBps[1000000019428464678912678481] = 8454; - rayToBps[1000000019430182947768926195] = 8455; - rayToBps[1000000019431901123521827882] = 8456; - rayToBps[1000000019433619206181472490] = 8457; - rayToBps[1000000019435337195757947331] = 8458; - rayToBps[1000000019437055092261338072] = 8459; - rayToBps[1000000019438772895701728744] = 8460; - rayToBps[1000000019440490606089201741] = 8461; - rayToBps[1000000019442208223433837815] = 8462; - rayToBps[1000000019443925747745716082] = 8463; - rayToBps[1000000019445643179034914020] = 8464; - rayToBps[1000000019447360517311507470] = 8465; - rayToBps[1000000019449077762585570634] = 8466; - rayToBps[1000000019450794914867176081] = 8467; - rayToBps[1000000019452511974166394739] = 8468; - rayToBps[1000000019454228940493295906] = 8469; - rayToBps[1000000019455945813857947238] = 8470; - rayToBps[1000000019457662594270414762] = 8471; - rayToBps[1000000019459379281740762866] = 8472; - rayToBps[1000000019461095876279054304] = 8473; - rayToBps[1000000019462812377895350198] = 8474; - rayToBps[1000000019464528786599710033] = 8475; - rayToBps[1000000019466245102402191663] = 8476; - rayToBps[1000000019467961325312851309] = 8477; - rayToBps[1000000019469677455341743557] = 8478; - rayToBps[1000000019471393492498921365] = 8479; - rayToBps[1000000019473109436794436053] = 8480; - rayToBps[1000000019474825288238337314] = 8481; - rayToBps[1000000019476541046840673208] = 8482; - rayToBps[1000000019478256712611490164] = 8483; - rayToBps[1000000019479972285560832982] = 8484; - rayToBps[1000000019481687765698744828] = 8485; - rayToBps[1000000019483403153035267242] = 8486; - rayToBps[1000000019485118447580440132] = 8487; - rayToBps[1000000019486833649344301778] = 8488; - rayToBps[1000000019488548758336888832] = 8489; - rayToBps[1000000019490263774568236316] = 8490; - rayToBps[1000000019491978698048377623] = 8491; - rayToBps[1000000019493693528787344519] = 8492; - rayToBps[1000000019495408266795167146] = 8493; - rayToBps[1000000019497122912081874013] = 8494; - rayToBps[1000000019498837464657492007] = 8495; - rayToBps[1000000019500551924532046386] = 8496; - rayToBps[1000000019502266291715560784] = 8497; - rayToBps[1000000019503980566218057206] = 8498; - rayToBps[1000000019505694748049556036] = 8499; - rayToBps[1000000019507408837220076029] = 8500; - rayToBps[1000000019509122833739634318] = 8501; - rayToBps[1000000019510836737618246412] = 8502; - rayToBps[1000000019512550548865926194] = 8503; - rayToBps[1000000019514264267492685924] = 8504; - rayToBps[1000000019515977893508536240] = 8505; - rayToBps[1000000019517691426923486156] = 8506; - rayToBps[1000000019519404867747543065] = 8507; - rayToBps[1000000019521118215990712736] = 8508; - rayToBps[1000000019522831471662999316] = 8509; - rayToBps[1000000019524544634774405332] = 8510; - rayToBps[1000000019526257705334931690] = 8511; - rayToBps[1000000019527970683354577675] = 8512; - rayToBps[1000000019529683568843340950] = 8513; - rayToBps[1000000019531396361811217559] = 8514; - rayToBps[1000000019533109062268201927] = 8515; - rayToBps[1000000019534821670224286859] = 8516; - rayToBps[1000000019536534185689463541] = 8517; - rayToBps[1000000019538246608673721540] = 8518; - rayToBps[1000000019539958939187048805] = 8519; - rayToBps[1000000019541671177239431669] = 8520; - rayToBps[1000000019543383322840854842] = 8521; - rayToBps[1000000019545095376001301423] = 8522; - rayToBps[1000000019546807336730752891] = 8523; - rayToBps[1000000019548519205039189107] = 8524; - rayToBps[1000000019550230980936588320] = 8525; - rayToBps[1000000019551942664432927159] = 8526; - rayToBps[1000000019553654255538180638] = 8527; - rayToBps[1000000019555365754262322160] = 8528; - rayToBps[1000000019557077160615323508] = 8529; - rayToBps[1000000019558788474607154854] = 8530; - rayToBps[1000000019560499696247784753] = 8531; - rayToBps[1000000019562210825547180149] = 8532; - rayToBps[1000000019563921862515306371] = 8533; - rayToBps[1000000019565632807162127135] = 8534; - rayToBps[1000000019567343659497604546] = 8535; - rayToBps[1000000019569054419531699092] = 8536; - rayToBps[1000000019570765087274369656] = 8537; - rayToBps[1000000019572475662735573501] = 8538; - rayToBps[1000000019574186145925266288] = 8539; - rayToBps[1000000019575896536853402059] = 8540; - rayToBps[1000000019577606835529933249] = 8541; - rayToBps[1000000019579317041964810682] = 8542; - rayToBps[1000000019581027156167983573] = 8543; - rayToBps[1000000019582737178149399527] = 8544; - rayToBps[1000000019584447107919004537] = 8545; - rayToBps[1000000019586156945486742993] = 8546; - rayToBps[1000000019587866690862557669] = 8547; - rayToBps[1000000019589576344056389737] = 8548; - rayToBps[1000000019591285905078178759] = 8549; - rayToBps[1000000019592995373937862689] = 8550; - rayToBps[1000000019594704750645377873] = 8551; - rayToBps[1000000019596414035210659053] = 8552; - rayToBps[1000000019598123227643639361] = 8553; - rayToBps[1000000019599832327954250327] = 8554; - rayToBps[1000000019601541336152421872] = 8555; - rayToBps[1000000019603250252248082310] = 8556; - rayToBps[1000000019604959076251158355] = 8557; - rayToBps[1000000019606667808171575114] = 8558; - rayToBps[1000000019608376448019256087] = 8559; - rayToBps[1000000019610084995804123174] = 8560; - rayToBps[1000000019611793451536096669] = 8561; - rayToBps[1000000019613501815225095263] = 8562; - rayToBps[1000000019615210086881036044] = 8563; - rayToBps[1000000019616918266513834497] = 8564; - rayToBps[1000000019618626354133404505] = 8565; - rayToBps[1000000019620334349749658350] = 8566; - rayToBps[1000000019622042253372506711] = 8567; - rayToBps[1000000019623750065011858666] = 8568; - rayToBps[1000000019625457784677621692] = 8569; - rayToBps[1000000019627165412379701666] = 8570; - rayToBps[1000000019628872948128002863] = 8571; - rayToBps[1000000019630580391932427962] = 8572; - rayToBps[1000000019632287743802878037] = 8573; - rayToBps[1000000019633995003749252568] = 8574; - rayToBps[1000000019635702171781449432] = 8575; - rayToBps[1000000019637409247909364910] = 8576; - rayToBps[1000000019639116232142893683] = 8577; - rayToBps[1000000019640823124491928838] = 8578; - rayToBps[1000000019642529924966361858] = 8579; - rayToBps[1000000019644236633576082635] = 8580; - rayToBps[1000000019645943250330979460] = 8581; - rayToBps[1000000019647649775240939030] = 8582; - rayToBps[1000000019649356208315846444] = 8583; - rayToBps[1000000019651062549565585208] = 8584; - rayToBps[1000000019652768799000037231] = 8585; - rayToBps[1000000019654474956629082825] = 8586; - rayToBps[1000000019656181022462600710] = 8587; - rayToBps[1000000019657886996510468009] = 8588; - rayToBps[1000000019659592878782560255] = 8589; - rayToBps[1000000019661298669288751384] = 8590; - rayToBps[1000000019663004368038913738] = 8591; - rayToBps[1000000019664709975042918068] = 8592; - rayToBps[1000000019666415490310633533] = 8593; - rayToBps[1000000019668120913851927696] = 8594; - rayToBps[1000000019669826245676666531] = 8595; - rayToBps[1000000019671531485794714421] = 8596; - rayToBps[1000000019673236634215934155] = 8597; - rayToBps[1000000019674941690950186933] = 8598; - rayToBps[1000000019676646656007332363] = 8599; - rayToBps[1000000019678351529397228463] = 8600; - rayToBps[1000000019680056311129731662] = 8601; - rayToBps[1000000019681761001214696799] = 8602; - rayToBps[1000000019683465599661977123] = 8603; - rayToBps[1000000019685170106481424294] = 8604; - rayToBps[1000000019686874521682888385] = 8605; - rayToBps[1000000019688578845276217880] = 8606; - rayToBps[1000000019690283077271259672] = 8607; - rayToBps[1000000019691987217677859074] = 8608; - rayToBps[1000000019693691266505859802] = 8609; - rayToBps[1000000019695395223765103993] = 8610; - rayToBps[1000000019697099089465432194] = 8611; - rayToBps[1000000019698802863616683367] = 8612; - rayToBps[1000000019700506546228694886] = 8613; - rayToBps[1000000019702210137311302542] = 8614; - rayToBps[1000000019703913636874340539] = 8615; - rayToBps[1000000019705617044927641498] = 8616; - rayToBps[1000000019707320361481036453] = 8617; - rayToBps[1000000019709023586544354858] = 8618; - rayToBps[1000000019710726720127424577] = 8619; - rayToBps[1000000019712429762240071896] = 8620; - rayToBps[1000000019714132712892121515] = 8621; - rayToBps[1000000019715835572093396554] = 8622; - rayToBps[1000000019717538339853718546] = 8623; - rayToBps[1000000019719241016182907446] = 8624; - rayToBps[1000000019720943601090781625] = 8625; - rayToBps[1000000019722646094587157873] = 8626; - rayToBps[1000000019724348496681851400] = 8627; - rayToBps[1000000019726050807384675834] = 8628; - rayToBps[1000000019727753026705443223] = 8629; - rayToBps[1000000019729455154653964034] = 8630; - rayToBps[1000000019731157191240047158] = 8631; - rayToBps[1000000019732859136473499900] = 8632; - rayToBps[1000000019734560990364127992] = 8633; - rayToBps[1000000019736262752921735584] = 8634; - rayToBps[1000000019737964424156125249] = 8635; - rayToBps[1000000019739666004077097982] = 8636; - rayToBps[1000000019741367492694453198] = 8637; - rayToBps[1000000019743068890017988738] = 8638; - rayToBps[1000000019744770196057500864] = 8639; - rayToBps[1000000019746471410822784262] = 8640; - rayToBps[1000000019748172534323632041] = 8641; - rayToBps[1000000019749873566569835734] = 8642; - rayToBps[1000000019751574507571185299] = 8643; - rayToBps[1000000019753275357337469119] = 8644; - rayToBps[1000000019754976115878473999] = 8645; - rayToBps[1000000019756676783203985175] = 8646; - rayToBps[1000000019758377359323786302] = 8647; - rayToBps[1000000019760077844247659467] = 8648; - rayToBps[1000000019761778237985385179] = 8649; - rayToBps[1000000019763478540546742376] = 8650; - rayToBps[1000000019765178751941508423] = 8651; - rayToBps[1000000019766878872179459110] = 8652; - rayToBps[1000000019768578901270368657] = 8653; - rayToBps[1000000019770278839224009713] = 8654; - rayToBps[1000000019771978686050153352] = 8655; - rayToBps[1000000019773678441758569079] = 8656; - rayToBps[1000000019775378106359024828] = 8657; - rayToBps[1000000019777077679861286963] = 8658; - rayToBps[1000000019778777162275120275] = 8659; - rayToBps[1000000019780476553610287987] = 8660; - rayToBps[1000000019782175853876551752] = 8661; - rayToBps[1000000019783875063083671655] = 8662; - rayToBps[1000000019785574181241406209] = 8663; - rayToBps[1000000019787273208359512363] = 8664; - rayToBps[1000000019788972144447745493] = 8665; - rayToBps[1000000019790670989515859410] = 8666; - rayToBps[1000000019792369743573606356] = 8667; - rayToBps[1000000019794068406630737008] = 8668; - rayToBps[1000000019795766978697000471] = 8669; - rayToBps[1000000019797465459782144290] = 8670; - rayToBps[1000000019799163849895914439] = 8671; - rayToBps[1000000019800862149048055328] = 8672; - rayToBps[1000000019802560357248309801] = 8673; - rayToBps[1000000019804258474506419137] = 8674; - rayToBps[1000000019805956500832123050] = 8675; - rayToBps[1000000019807654436235159689] = 8676; - rayToBps[1000000019809352280725265639] = 8677; - rayToBps[1000000019811050034312175922] = 8678; - rayToBps[1000000019812747697005623995] = 8679; - rayToBps[1000000019814445268815341752] = 8680; - rayToBps[1000000019816142749751059525] = 8681; - rayToBps[1000000019817840139822506084] = 8682; - rayToBps[1000000019819537439039408634] = 8683; - rayToBps[1000000019821234647411492821] = 8684; - rayToBps[1000000019822931764948482727] = 8685; - rayToBps[1000000019824628791660100876] = 8686; - rayToBps[1000000019826325727556068227] = 8687; - rayToBps[1000000019828022572646104182] = 8688; - rayToBps[1000000019829719326939926581] = 8689; - rayToBps[1000000019831415990447251705] = 8690; - rayToBps[1000000019833112563177794274] = 8691; - rayToBps[1000000019834809045141267450] = 8692; - rayToBps[1000000019836505436347382837] = 8693; - rayToBps[1000000019838201736805850477] = 8694; - rayToBps[1000000019839897946526378859] = 8695; - rayToBps[1000000019841594065518674908] = 8696; - rayToBps[1000000019843290093792443997] = 8697; - rayToBps[1000000019844986031357389939] = 8698; - rayToBps[1000000019846681878223214989] = 8699; - rayToBps[1000000019848377634399619849] = 8700; - rayToBps[1000000019850073299896303661] = 8701; - rayToBps[1000000019851768874722964014] = 8702; - rayToBps[1000000019853464358889296941] = 8703; - rayToBps[1000000019855159752404996917] = 8704; - rayToBps[1000000019856855055279756866] = 8705; - rayToBps[1000000019858550267523268155] = 8706; - rayToBps[1000000019860245389145220596] = 8707; - rayToBps[1000000019861940420155302451] = 8708; - rayToBps[1000000019863635360563200425] = 8709; - rayToBps[1000000019865330210378599670] = 8710; - rayToBps[1000000019867024969611183786] = 8711; - rayToBps[1000000019868719638270634821] = 8712; - rayToBps[1000000019870414216366633269] = 8713; - rayToBps[1000000019872108703908858076] = 8714; - rayToBps[1000000019873803100906986629] = 8715; - rayToBps[1000000019875497407370694772] = 8716; - rayToBps[1000000019877191623309656793] = 8717; - rayToBps[1000000019878885748733545431] = 8718; - rayToBps[1000000019880579783652031874] = 8719; - rayToBps[1000000019882273728074785762] = 8720; - rayToBps[1000000019883967582011475183] = 8721; - rayToBps[1000000019885661345471766678] = 8722; - rayToBps[1000000019887355018465325236] = 8723; - rayToBps[1000000019889048601001814301] = 8724; - rayToBps[1000000019890742093090895767] = 8725; - rayToBps[1000000019892435494742229981] = 8726; - rayToBps[1000000019894128805965475739] = 8727; - rayToBps[1000000019895822026770290295] = 8728; - rayToBps[1000000019897515157166329351] = 8729; - rayToBps[1000000019899208197163247067] = 8730; - rayToBps[1000000019900901146770696053] = 8731; - rayToBps[1000000019902594005998327375] = 8732; - rayToBps[1000000019904286774855790554] = 8733; - rayToBps[1000000019905979453352733562] = 8734; - rayToBps[1000000019907672041498802832] = 8735; - rayToBps[1000000019909364539303643246] = 8736; - rayToBps[1000000019911056946776898148] = 8737; - rayToBps[1000000019912749263928209333] = 8738; - rayToBps[1000000019914441490767217054] = 8739; - rayToBps[1000000019916133627303560021] = 8740; - rayToBps[1000000019917825673546875400] = 8741; - rayToBps[1000000019919517629506798819] = 8742; - rayToBps[1000000019921209495192964356] = 8743; - rayToBps[1000000019922901270615004553] = 8744; - rayToBps[1000000019924592955782550408] = 8745; - rayToBps[1000000019926284550705231377] = 8746; - rayToBps[1000000019927976055392675377] = 8747; - rayToBps[1000000019929667469854508782] = 8748; - rayToBps[1000000019931358794100356430] = 8749; - rayToBps[1000000019933050028139841613] = 8750; - rayToBps[1000000019934741171982586087] = 8751; - rayToBps[1000000019936432225638210068] = 8752; - rayToBps[1000000019938123189116332234] = 8753; - rayToBps[1000000019939814062426569721] = 8754; - rayToBps[1000000019941504845578538131] = 8755; - rayToBps[1000000019943195538581851525] = 8756; - rayToBps[1000000019944886141446122425] = 8757; - rayToBps[1000000019946576654180961822] = 8758; - rayToBps[1000000019948267076795979161] = 8759; - rayToBps[1000000019949957409300782358] = 8760; - rayToBps[1000000019951647651704977788] = 8761; - rayToBps[1000000019953337804018170292] = 8762; - rayToBps[1000000019955027866249963174] = 8763; - rayToBps[1000000019956717838409958205] = 8764; - rayToBps[1000000019958407720507755616] = 8765; - rayToBps[1000000019960097512552954109] = 8766; - rayToBps[1000000019961787214555150849] = 8767; - rayToBps[1000000019963476826523941464] = 8768; - rayToBps[1000000019965166348468920054] = 8769; - rayToBps[1000000019966855780399679180] = 8770; - rayToBps[1000000019968545122325809875] = 8771; - rayToBps[1000000019970234374256901634] = 8772; - rayToBps[1000000019971923536202542425] = 8773; - rayToBps[1000000019973612608172318678] = 8774; - rayToBps[1000000019975301590175815296] = 8775; - rayToBps[1000000019976990482222615648] = 8776; - rayToBps[1000000019978679284322301573] = 8777; - rayToBps[1000000019980367996484453378] = 8778; - rayToBps[1000000019982056618718649841] = 8779; - rayToBps[1000000019983745151034468208] = 8780; - rayToBps[1000000019985433593441484196] = 8781; - rayToBps[1000000019987121945949271992] = 8782; - rayToBps[1000000019988810208567404255] = 8783; - rayToBps[1000000019990498381305452115] = 8784; - rayToBps[1000000019992186464172985172] = 8785; - rayToBps[1000000019993874457179571499] = 8786; - rayToBps[1000000019995562360334777640] = 8787; - rayToBps[1000000019997250173648168612] = 8788; - rayToBps[1000000019998937897129307905] = 8789; - rayToBps[1000000020000625530787757482] = 8790; - rayToBps[1000000020002313074633077780] = 8791; - rayToBps[1000000020004000528674827707] = 8792; - rayToBps[1000000020005687892922564648] = 8793; - rayToBps[1000000020007375167385844462] = 8794; - rayToBps[1000000020009062352074221481] = 8795; - rayToBps[1000000020010749446997248514] = 8796; - rayToBps[1000000020012436452164476843] = 8797; - rayToBps[1000000020014123367585456228] = 8798; - rayToBps[1000000020015810193269734903] = 8799; - rayToBps[1000000020017496929226859581] = 8800; - rayToBps[1000000020019183575466375447] = 8801; - rayToBps[1000000020020870131997826170] = 8802; - rayToBps[1000000020022556598830753888] = 8803; - rayToBps[1000000020024242975974699224] = 8804; - rayToBps[1000000020025929263439201274] = 8805; - rayToBps[1000000020027615461233797613] = 8806; - rayToBps[1000000020029301569368024297] = 8807; - rayToBps[1000000020030987587851415860] = 8808; - rayToBps[1000000020032673516693505313] = 8809; - rayToBps[1000000020034359355903824149] = 8810; - rayToBps[1000000020036045105491902339] = 8811; - rayToBps[1000000020037730765467268337] = 8812; - rayToBps[1000000020039416335839449075] = 8813; - rayToBps[1000000020041101816617969965] = 8814; - rayToBps[1000000020042787207812354904] = 8815; - rayToBps[1000000020044472509432126266] = 8816; - rayToBps[1000000020046157721486804911] = 8817; - rayToBps[1000000020047842843985910178] = 8818; - rayToBps[1000000020049527876938959890] = 8819; - rayToBps[1000000020051212820355470352] = 8820; - rayToBps[1000000020052897674244956352] = 8821; - rayToBps[1000000020054582438616931164] = 8822; - rayToBps[1000000020056267113480906541] = 8823; - rayToBps[1000000020057951698846392724] = 8824; - rayToBps[1000000020059636194722898437] = 8825; - rayToBps[1000000020061320601119930888] = 8826; - rayToBps[1000000020063004918046995771] = 8827; - rayToBps[1000000020064689145513597267] = 8828; - rayToBps[1000000020066373283529238037] = 8829; - rayToBps[1000000020068057332103419236] = 8830; - rayToBps[1000000020069741291245640498] = 8831; - rayToBps[1000000020071425160965399947] = 8832; - rayToBps[1000000020073108941272194197] = 8833; - rayToBps[1000000020074792632175518341] = 8834; - rayToBps[1000000020076476233684865968] = 8835; - rayToBps[1000000020078159745809729151] = 8836; - rayToBps[1000000020079843168559598451] = 8837; - rayToBps[1000000020081526501943962918] = 8838; - rayToBps[1000000020083209745972310093] = 8839; - rayToBps[1000000020084892900654126002] = 8840; - rayToBps[1000000020086575965998895164] = 8841; - rayToBps[1000000020088258942016100588] = 8842; - rayToBps[1000000020089941828715223770] = 8843; - rayToBps[1000000020091624626105744699] = 8844; - rayToBps[1000000020093307334197141855] = 8845; - rayToBps[1000000020094989952998892207] = 8846; - rayToBps[1000000020096672482520471219] = 8847; - rayToBps[1000000020098354922771352842] = 8848; - rayToBps[1000000020100037273761009523] = 8849; - rayToBps[1000000020101719535498912200] = 8850; - rayToBps[1000000020103401707994530304] = 8851; - rayToBps[1000000020105083791257331758] = 8852; - rayToBps[1000000020106765785296782980] = 8853; - rayToBps[1000000020108447690122348881] = 8854; - rayToBps[1000000020110129505743492865] = 8855; - rayToBps[1000000020111811232169676833] = 8856; - rayToBps[1000000020113492869410361176] = 8857; - rayToBps[1000000020115174417475004786] = 8858; - rayToBps[1000000020116855876373065045] = 8859; - rayToBps[1000000020118537246113997834] = 8860; - rayToBps[1000000020120218526707257528] = 8861; - rayToBps[1000000020121899718162296998] = 8862; - rayToBps[1000000020123580820488567614] = 8863; - rayToBps[1000000020125261833695519242] = 8864; - rayToBps[1000000020126942757792600241] = 8865; - rayToBps[1000000020128623592789257476] = 8866; - rayToBps[1000000020130304338694936301] = 8867; - rayToBps[1000000020131984995519080574] = 8868; - rayToBps[1000000020133665563271132648] = 8869; - rayToBps[1000000020135346041960533378] = 8870; - rayToBps[1000000020137026431596722116] = 8871; - rayToBps[1000000020138706732189136713] = 8872; - rayToBps[1000000020140386943747213521] = 8873; - rayToBps[1000000020142067066280387392] = 8874; - rayToBps[1000000020143747099798091677] = 8875; - rayToBps[1000000020145427044309758231] = 8876; - rayToBps[1000000020147106899824817406] = 8877; - rayToBps[1000000020148786666352698057] = 8878; - rayToBps[1000000020150466343902827542] = 8879; - rayToBps[1000000020152145932484631718] = 8880; - rayToBps[1000000020153825432107534947] = 8881; - rayToBps[1000000020155504842780960093] = 8882; - rayToBps[1000000020157184164514328522] = 8883; - rayToBps[1000000020158863397317060104] = 8884; - rayToBps[1000000020160542541198573211] = 8885; - rayToBps[1000000020162221596168284722] = 8886; - rayToBps[1000000020163900562235610018] = 8887; - rayToBps[1000000020165579439409962985] = 8888; - rayToBps[1000000020167258227700756012] = 8889; - rayToBps[1000000020168936927117399997] = 8890; - rayToBps[1000000020170615537669304340] = 8891; - rayToBps[1000000020172294059365876949] = 8892; - rayToBps[1000000020173972492216524237] = 8893; - rayToBps[1000000020175650836230651123] = 8894; - rayToBps[1000000020177329091417661033] = 8895; - rayToBps[1000000020179007257786955901] = 8896; - rayToBps[1000000020180685335347936169] = 8897; - rayToBps[1000000020182363324110000782] = 8898; - rayToBps[1000000020184041224082547200] = 8899; - rayToBps[1000000020185719035274971385] = 8900; - rayToBps[1000000020187396757696667812] = 8901; - rayToBps[1000000020189074391357029461] = 8902; - rayToBps[1000000020190751936265447827] = 8903; - rayToBps[1000000020192429392431312906] = 8904; - rayToBps[1000000020194106759864013214] = 8905; - rayToBps[1000000020195784038572935769] = 8906; - rayToBps[1000000020197461228567466103] = 8907; - rayToBps[1000000020199138329856988259] = 8908; - rayToBps[1000000020200815342450884791] = 8909; - rayToBps[1000000020202492266358536762] = 8910; - rayToBps[1000000020204169101589323750] = 8911; - rayToBps[1000000020205845848152623845] = 8912; - rayToBps[1000000020207522506057813646] = 8913; - rayToBps[1000000020209199075314268269] = 8914; - rayToBps[1000000020210875555931361340] = 8915; - rayToBps[1000000020212551947918465000] = 8916; - rayToBps[1000000020214228251284949901] = 8917; - rayToBps[1000000020215904466040185214] = 8918; - rayToBps[1000000020217580592193538618] = 8919; - rayToBps[1000000020219256629754376312] = 8920; - rayToBps[1000000020220932578732063007] = 8921; - rayToBps[1000000020222608439135961931] = 8922; - rayToBps[1000000020224284210975434825] = 8923; - rayToBps[1000000020225959894259841949] = 8924; - rayToBps[1000000020227635488998542076] = 8925; - rayToBps[1000000020229310995200892497] = 8926; - rayToBps[1000000020230986412876249021] = 8927; - rayToBps[1000000020232661742033965972] = 8928; - rayToBps[1000000020234336982683396194] = 8929; - rayToBps[1000000020236012134833891045] = 8930; - rayToBps[1000000020237687198494800405] = 8931; - rayToBps[1000000020239362173675472669] = 8932; - rayToBps[1000000020241037060385254751] = 8933; - rayToBps[1000000020242711858633492088] = 8934; - rayToBps[1000000020244386568429528633] = 8935; - rayToBps[1000000020246061189782706857] = 8936; - rayToBps[1000000020247735722702367756] = 8937; - rayToBps[1000000020249410167197850841] = 8938; - rayToBps[1000000020251084523278494145] = 8939; - rayToBps[1000000020252758790953634225] = 8940; - rayToBps[1000000020254432970232606156] = 8941; - rayToBps[1000000020256107061124743535] = 8942; - rayToBps[1000000020257781063639378482] = 8943; - rayToBps[1000000020259454977785841636] = 8944; - rayToBps[1000000020261128803573462164] = 8945; - rayToBps[1000000020262802541011567749] = 8946; - rayToBps[1000000020264476190109484603] = 8947; - rayToBps[1000000020266149750876537457] = 8948; - rayToBps[1000000020267823223322049569] = 8949; - rayToBps[1000000020269496607455342719] = 8950; - rayToBps[1000000020271169903285737212] = 8951; - rayToBps[1000000020272843110822551875] = 8952; - rayToBps[1000000020274516230075104065] = 8953; - rayToBps[1000000020276189261052709662] = 8954; - rayToBps[1000000020277862203764683069] = 8955; - rayToBps[1000000020279535058220337216] = 8956; - rayToBps[1000000020281207824428983564] = 8957; - rayToBps[1000000020282880502399932092] = 8958; - rayToBps[1000000020284553092142491314] = 8959; - rayToBps[1000000020286225593665968266] = 8960; - rayToBps[1000000020287898006979668513] = 8961; - rayToBps[1000000020289570332092896147] = 8962; - rayToBps[1000000020291242569014953788] = 8963; - rayToBps[1000000020292914717755142587] = 8964; - rayToBps[1000000020294586778322762220] = 8965; - rayToBps[1000000020296258750727110894] = 8966; - rayToBps[1000000020297930634977485344] = 8967; - rayToBps[1000000020299602431083180836] = 8968; - rayToBps[1000000020301274139053491166] = 8969; - rayToBps[1000000020302945758897708658] = 8970; - rayToBps[1000000020304617290625124169] = 8971; - rayToBps[1000000020306288734245027087] = 8972; - rayToBps[1000000020307960089766705327] = 8973; - rayToBps[1000000020309631357199445340] = 8974; - rayToBps[1000000020311302536552532106] = 8975; - rayToBps[1000000020312973627835249139] = 8976; - rayToBps[1000000020314644631056878485] = 8977; - rayToBps[1000000020316315546226700722] = 8978; - rayToBps[1000000020317986373353994961] = 8979; - rayToBps[1000000020319657112448038846] = 8980; - rayToBps[1000000020321327763518108555] = 8981; - rayToBps[1000000020322998326573478801] = 8982; - rayToBps[1000000020324668801623422830] = 8983; - rayToBps[1000000020326339188677212422] = 8984; - rayToBps[1000000020328009487744117892] = 8985; - rayToBps[1000000020329679698833408092] = 8986; - rayToBps[1000000020331349821954350409] = 8987; - rayToBps[1000000020333019857116210763] = 8988; - rayToBps[1000000020334689804328253614] = 8989; - rayToBps[1000000020336359663599741954] = 8990; - rayToBps[1000000020338029434939937316] = 8991; - rayToBps[1000000020339699118358099767] = 8992; - rayToBps[1000000020341368713863487913] = 8993; - rayToBps[1000000020343038221465358897] = 8994; - rayToBps[1000000020344707641172968400] = 8995; - rayToBps[1000000020346376972995570640] = 8996; - rayToBps[1000000020348046216942418378] = 8997; - rayToBps[1000000020349715373022762906] = 8998; - rayToBps[1000000020351384441245854063] = 8999; - rayToBps[1000000020353053421620940223] = 9000; - rayToBps[1000000020354722314157268302] = 9001; - rayToBps[1000000020356391118864083753] = 9002; - rayToBps[1000000020358059835750630572] = 9003; - rayToBps[1000000020359728464826151296] = 9004; - rayToBps[1000000020361397006099887003] = 9005; - rayToBps[1000000020363065459581077309] = 9006; - rayToBps[1000000020364733825278960375] = 9007; - rayToBps[1000000020366402103202772903] = 9008; - rayToBps[1000000020368070293361750138] = 9009; - rayToBps[1000000020369738395765125865] = 9010; - rayToBps[1000000020371406410422132415] = 9011; - rayToBps[1000000020373074337342000659] = 9012; - rayToBps[1000000020374742176533960015] = 9013; - rayToBps[1000000020376409928007238443] = 9014; - rayToBps[1000000020378077591771062444] = 9015; - rayToBps[1000000020379745167834657070] = 9016; - rayToBps[1000000020381412656207245911] = 9017; - rayToBps[1000000020383080056898051107] = 9018; - rayToBps[1000000020384747369916293340] = 9019; - rayToBps[1000000020386414595271191839] = 9020; - rayToBps[1000000020388081732971964381] = 9021; - rayToBps[1000000020389748783027827283] = 9022; - rayToBps[1000000020391415745447995416] = 9023; - rayToBps[1000000020393082620241682192] = 9024; - rayToBps[1000000020394749407418099573] = 9025; - rayToBps[1000000020396416106986458070] = 9026; - rayToBps[1000000020398082718955966736] = 9027; - rayToBps[1000000020399749243335833178] = 9028; - rayToBps[1000000020401415680135263548] = 9029; - rayToBps[1000000020403082029363462548] = 9030; - rayToBps[1000000020404748291029633429] = 9031; - rayToBps[1000000020406414465142977990] = 9032; - rayToBps[1000000020408080551712696581] = 9033; - rayToBps[1000000020409746550747988100] = 9034; - rayToBps[1000000020411412462258049999] = 9035; - rayToBps[1000000020413078286252078275] = 9036; - rayToBps[1000000020414744022739267481] = 9037; - rayToBps[1000000020416409671728810718] = 9038; - rayToBps[1000000020418075233229899639] = 9039; - rayToBps[1000000020419740707251724448] = 9040; - rayToBps[1000000020421406093803473905] = 9041; - rayToBps[1000000020423071392894335315] = 9042; - rayToBps[1000000020424736604533494543] = 9043; - rayToBps[1000000020426401728730136002] = 9044; - rayToBps[1000000020428066765493442661] = 9045; - rayToBps[1000000020429731714832596040] = 9046; - rayToBps[1000000020431396576756776217] = 9047; - rayToBps[1000000020433061351275161818] = 9048; - rayToBps[1000000020434726038396930030] = 9049; - rayToBps[1000000020436390638131256590] = 9050; - rayToBps[1000000020438055150487315791] = 9051; - rayToBps[1000000020439719575474280483] = 9052; - rayToBps[1000000020441383913101322070] = 9053; - rayToBps[1000000020443048163377610514] = 9054; - rayToBps[1000000020444712326312314329] = 9055; - rayToBps[1000000020446376401914600591] = 9056; - rayToBps[1000000020448040390193634929] = 9057; - rayToBps[1000000020449704291158581532] = 9058; - rayToBps[1000000020451368104818603142] = 9059; - rayToBps[1000000020453031831182861063] = 9060; - rayToBps[1000000020454695470260515157] = 9061; - rayToBps[1000000020456359022060723842] = 9062; - rayToBps[1000000020458022486592644094] = 9063; - rayToBps[1000000020459685863865431454] = 9064; - rayToBps[1000000020461349153888240014] = 9065; - rayToBps[1000000020463012356670222430] = 9066; - rayToBps[1000000020464675472220529919] = 9067; - rayToBps[1000000020466338500548312257] = 9068; - rayToBps[1000000020468001441662717778] = 9069; - rayToBps[1000000020469664295572893381] = 9070; - rayToBps[1000000020471327062287984523] = 9071; - rayToBps[1000000020472989741817135223] = 9072; - rayToBps[1000000020474652334169488064] = 9073; - rayToBps[1000000020476314839354184187] = 9074; - rayToBps[1000000020477977257380363298] = 9075; - rayToBps[1000000020479639588257163666] = 9076; - rayToBps[1000000020481301831993722120] = 9077; - rayToBps[1000000020482963988599174056] = 9078; - rayToBps[1000000020484626058082653431] = 9079; - rayToBps[1000000020486288040453292766] = 9080; - rayToBps[1000000020487949935720223147] = 9081; - rayToBps[1000000020489611743892574223] = 9082; - rayToBps[1000000020491273464979474210] = 9083; - rayToBps[1000000020492935098990049887] = 9084; - rayToBps[1000000020494596645933426599] = 9085; - rayToBps[1000000020496258105818728257] = 9086; - rayToBps[1000000020497919478655077336] = 9087; - rayToBps[1000000020499580764451594880] = 9088; - rayToBps[1000000020501241963217400498] = 9089; - rayToBps[1000000020502903074961612367] = 9090; - rayToBps[1000000020504564099693347229] = 9091; - rayToBps[1000000020506225037421720394] = 9092; - rayToBps[1000000020507885888155845741] = 9093; - rayToBps[1000000020509546651904835716] = 9094; - rayToBps[1000000020511207328677801335] = 9095; - rayToBps[1000000020512867918483852179] = 9096; - rayToBps[1000000020514528421332096402] = 9097; - rayToBps[1000000020516188837231640723] = 9098; - rayToBps[1000000020517849166191590436] = 9099; - rayToBps[1000000020519509408221049399] = 9100; - rayToBps[1000000020521169563329120043] = 9101; - rayToBps[1000000020522829631524903371] = 9102; - rayToBps[1000000020524489612817498954] = 9103; - rayToBps[1000000020526149507216004934] = 9104; - rayToBps[1000000020527809314729518026] = 9105; - rayToBps[1000000020529469035367133516] = 9106; - rayToBps[1000000020531128669137945262] = 9107; - rayToBps[1000000020532788216051045693] = 9108; - rayToBps[1000000020534447676115525812] = 9109; - rayToBps[1000000020536107049340475193] = 9110; - rayToBps[1000000020537766335734981987] = 9111; - rayToBps[1000000020539425535308132912] = 9112; - rayToBps[1000000020541084648069013267] = 9113; - rayToBps[1000000020542743674026706920] = 9114; - rayToBps[1000000020544402613190296315] = 9115; - rayToBps[1000000020546061465568862469] = 9116; - rayToBps[1000000020547720231171484977] = 9117; - rayToBps[1000000020549378910007242007] = 9118; - rayToBps[1000000020551037502085210301] = 9119; - rayToBps[1000000020552696007414465182] = 9120; - rayToBps[1000000020554354426004080544] = 9121; - rayToBps[1000000020556012757863128859] = 9122; - rayToBps[1000000020557671003000681175] = 9123; - rayToBps[1000000020559329161425807120] = 9124; - rayToBps[1000000020560987233147574896] = 9125; - rayToBps[1000000020562645218175051284] = 9126; - rayToBps[1000000020564303116517301641] = 9127; - rayToBps[1000000020565960928183389906] = 9128; - rayToBps[1000000020567618653182378593] = 9129; - rayToBps[1000000020569276291523328795] = 9130; - rayToBps[1000000020570933843215300187] = 9131; - rayToBps[1000000020572591308267351020] = 9132; - rayToBps[1000000020574248686688538126] = 9133; - rayToBps[1000000020575905978487916919] = 9134; - rayToBps[1000000020577563183674541388] = 9135; - rayToBps[1000000020579220302257464108] = 9136; - rayToBps[1000000020580877334245736232] = 9137; - rayToBps[1000000020582534279648407494] = 9138; - rayToBps[1000000020584191138474526212] = 9139; - rayToBps[1000000020585847910733139281] = 9140; - rayToBps[1000000020587504596433292185] = 9141; - rayToBps[1000000020589161195584028982] = 9142; - rayToBps[1000000020590817708194392321] = 9143; - rayToBps[1000000020592474134273423425] = 9144; - rayToBps[1000000020594130473830162110] = 9145; - rayToBps[1000000020595786726873646766] = 9146; - rayToBps[1000000020597442893412914374] = 9147; - rayToBps[1000000020599098973457000497] = 9148; - rayToBps[1000000020600754967014939281] = 9149; - rayToBps[1000000020602410874095763456] = 9150; - rayToBps[1000000020604066694708504340] = 9151; - rayToBps[1000000020605722428862191834] = 9152; - rayToBps[1000000020607378076565854427] = 9153; - rayToBps[1000000020609033637828519190] = 9154; - rayToBps[1000000020610689112659211784] = 9155; - rayToBps[1000000020612344501066956455] = 9156; - rayToBps[1000000020613999803060776034] = 9157; - rayToBps[1000000020615655018649691942] = 9158; - rayToBps[1000000020617310147842724185] = 9159; - rayToBps[1000000020618965190648891360] = 9160; - rayToBps[1000000020620620147077210647] = 9161; - rayToBps[1000000020622275017136697818] = 9162; - rayToBps[1000000020623929800836367232] = 9163; - rayToBps[1000000020625584498185231838] = 9164; - rayToBps[1000000020627239109192303172] = 9165; - rayToBps[1000000020628893633866591362] = 9166; - rayToBps[1000000020630548072217105124] = 9167; - rayToBps[1000000020632202424252851765] = 9168; - rayToBps[1000000020633856689982837180] = 9169; - rayToBps[1000000020635510869416065857] = 9170; - rayToBps[1000000020637164962561540876] = 9171; - rayToBps[1000000020638818969428263904] = 9172; - rayToBps[1000000020640472890025235203] = 9173; - rayToBps[1000000020642126724361453626] = 9174; - rayToBps[1000000020643780472445916617] = 9175; - rayToBps[1000000020645434134287620214] = 9176; - rayToBps[1000000020647087709895559046] = 9177; - rayToBps[1000000020648741199278726334] = 9178; - rayToBps[1000000020650394602446113896] = 9179; - rayToBps[1000000020652047919406712141] = 9180; - rayToBps[1000000020653701150169510072] = 9181; - rayToBps[1000000020655354294743495287] = 9182; - rayToBps[1000000020657007353137653976] = 9183; - rayToBps[1000000020658660325360970928] = 9184; - rayToBps[1000000020660313211422429521] = 9185; - rayToBps[1000000020661966011331011735] = 9186; - rayToBps[1000000020663618725095698141] = 9187; - rayToBps[1000000020665271352725467906] = 9188; - rayToBps[1000000020666923894229298796] = 9189; - rayToBps[1000000020668576349616167171] = 9190; - rayToBps[1000000020670228718895047988] = 9191; - rayToBps[1000000020671881002074914804] = 9192; - rayToBps[1000000020673533199164739768] = 9193; - rayToBps[1000000020675185310173493631] = 9194; - rayToBps[1000000020676837335110145740] = 9195; - rayToBps[1000000020678489273983664040] = 9196; - rayToBps[1000000020680141126803015078] = 9197; - rayToBps[1000000020681792893577163993] = 9198; - rayToBps[1000000020683444574315074529] = 9199; - rayToBps[1000000020685096169025709028] = 9200; - rayToBps[1000000020686747677718028431] = 9201; - rayToBps[1000000020688399100400992278] = 9202; - rayToBps[1000000020690050437083558711] = 9203; - rayToBps[1000000020691701687774684471] = 9204; - rayToBps[1000000020693352852483324902] = 9205; - rayToBps[1000000020695003931218433948] = 9206; - rayToBps[1000000020696654923988964153] = 9207; - rayToBps[1000000020698305830803866663] = 9208; - rayToBps[1000000020699956651672091229] = 9209; - rayToBps[1000000020701607386602586203] = 9210; - rayToBps[1000000020703258035604298536] = 9211; - rayToBps[1000000020704908598686173787] = 9212; - rayToBps[1000000020706559075857156114] = 9213; - rayToBps[1000000020708209467126188282] = 9214; - rayToBps[1000000020709859772502211657] = 9215; - rayToBps[1000000020711509991994166211] = 9216; - rayToBps[1000000020713160125610990519] = 9217; - rayToBps[1000000020714810173361621761] = 9218; - rayToBps[1000000020716460135254995722] = 9219; - rayToBps[1000000020718110011300046791] = 9220; - rayToBps[1000000020719759801505707966] = 9221; - rayToBps[1000000020721409505880910848] = 9222; - rayToBps[1000000020723059124434585643] = 9223; - rayToBps[1000000020724708657175661166] = 9224; - rayToBps[1000000020726358104113064837] = 9225; - rayToBps[1000000020728007465255722684] = 9226; - rayToBps[1000000020729656740612559341] = 9227; - rayToBps[1000000020731305930192498050] = 9228; - rayToBps[1000000020732955034004460663] = 9229; - rayToBps[1000000020734604052057367636] = 9230; - rayToBps[1000000020736252984360138036] = 9231; - rayToBps[1000000020737901830921689539] = 9232; - rayToBps[1000000020739550591750938429] = 9233; - rayToBps[1000000020741199266856799598] = 9234; - rayToBps[1000000020742847856248186551] = 9235; - rayToBps[1000000020744496359934011399] = 9236; - rayToBps[1000000020746144777923184866] = 9237; - rayToBps[1000000020747793110224616286] = 9238; - rayToBps[1000000020749441356847213601] = 9239; - rayToBps[1000000020751089517799883368] = 9240; - rayToBps[1000000020752737593091530752] = 9241; - rayToBps[1000000020754385582731059532] = 9242; - rayToBps[1000000020756033486727372097] = 9243; - rayToBps[1000000020757681305089369449] = 9244; - rayToBps[1000000020759329037825951202] = 9245; - rayToBps[1000000020760976684946015583] = 9246; - rayToBps[1000000020762624246458459433] = 9247; - rayToBps[1000000020764271722372178205] = 9248; - rayToBps[1000000020765919112696065965] = 9249; - rayToBps[1000000020767566417439015395] = 9250; - rayToBps[1000000020769213636609917790] = 9251; - rayToBps[1000000020770860770217663058] = 9252; - rayToBps[1000000020772507818271139726] = 9253; - rayToBps[1000000020774154780779234930] = 9254; - rayToBps[1000000020775801657750834425] = 9255; - rayToBps[1000000020777448449194822584] = 9256; - rayToBps[1000000020779095155120082390] = 9257; - rayToBps[1000000020780741775535495446] = 9258; - rayToBps[1000000020782388310449941971] = 9259; - rayToBps[1000000020784034759872300801] = 9260; - rayToBps[1000000020785681123811449386] = 9261; - rayToBps[1000000020787327402276263798] = 9262; - rayToBps[1000000020788973595275618725] = 9263; - rayToBps[1000000020790619702818387471] = 9264; - rayToBps[1000000020792265724913441958] = 9265; - rayToBps[1000000020793911661569652730] = 9266; - rayToBps[1000000020795557512795888949] = 9267; - rayToBps[1000000020797203278601018391] = 9268; - rayToBps[1000000020798848958993907458] = 9269; - rayToBps[1000000020800494553983421168] = 9270; - rayToBps[1000000020802140063578423159] = 9271; - rayToBps[1000000020803785487787775690] = 9272; - rayToBps[1000000020805430826620339641] = 9273; - rayToBps[1000000020807076080084974512] = 9274; - rayToBps[1000000020808721248190538424] = 9275; - rayToBps[1000000020810366330945888118] = 9276; - rayToBps[1000000020812011328359878961] = 9277; - rayToBps[1000000020813656240441364936] = 9278; - rayToBps[1000000020815301067199198652] = 9279; - rayToBps[1000000020816945808642231341] = 9280; - rayToBps[1000000020818590464779312857] = 9281; - rayToBps[1000000020820235035619291673] = 9282; - rayToBps[1000000020821879521171014892] = 9283; - rayToBps[1000000020823523921443328236] = 9284; - rayToBps[1000000020825168236445076054] = 9285; - rayToBps[1000000020826812466185101315] = 9286; - rayToBps[1000000020828456610672245618] = 9287; - rayToBps[1000000020830100669915349181] = 9288; - rayToBps[1000000020831744643923250852] = 9289; - rayToBps[1000000020833388532704788101] = 9290; - rayToBps[1000000020835032336268797025] = 9291; - rayToBps[1000000020836676054624112349] = 9292; - rayToBps[1000000020838319687779567417] = 9293; - rayToBps[1000000020839963235743994210] = 9294; - rayToBps[1000000020841606698526223327] = 9295; - rayToBps[1000000020843250076135083997] = 9296; - rayToBps[1000000020844893368579404078] = 9297; - rayToBps[1000000020846536575868010053] = 9298; - rayToBps[1000000020848179698009727036] = 9299; - rayToBps[1000000020849822735013378765] = 9300; - rayToBps[1000000020851465686887787610] = 9301; - rayToBps[1000000020853108553641774569] = 9302; - rayToBps[1000000020854751335284159266] = 9303; - rayToBps[1000000020856394031823759960] = 9304; - rayToBps[1000000020858036643269393535] = 9305; - rayToBps[1000000020859679169629875506] = 9306; - rayToBps[1000000020861321610914020019] = 9307; - rayToBps[1000000020862963967130639850] = 9308; - rayToBps[1000000020864606238288546406] = 9309; - rayToBps[1000000020866248424396549724] = 9310; - rayToBps[1000000020867890525463458474] = 9311; - rayToBps[1000000020869532541498079955] = 9312; - rayToBps[1000000020871174472509220102] = 9313; - rayToBps[1000000020872816318505683477] = 9314; - rayToBps[1000000020874458079496273280] = 9315; - rayToBps[1000000020876099755489791338] = 9316; - rayToBps[1000000020877741346495038117] = 9317; - rayToBps[1000000020879382852520812709] = 9318; - rayToBps[1000000020881024273575912848] = 9319; - rayToBps[1000000020882665609669134895] = 9320; - rayToBps[1000000020884306860809273848] = 9321; - rayToBps[1000000020885948027005123340] = 9322; - rayToBps[1000000020887589108265475638] = 9323; - rayToBps[1000000020889230104599121642] = 9324; - rayToBps[1000000020890871016014850891] = 9325; - rayToBps[1000000020892511842521451557] = 9326; - rayToBps[1000000020894152584127710448] = 9327; - rayToBps[1000000020895793240842413010] = 9328; - rayToBps[1000000020897433812674343323] = 9329; - rayToBps[1000000020899074299632284105] = 9330; - rayToBps[1000000020900714701725016711] = 9331; - rayToBps[1000000020902355018961321132] = 9332; - rayToBps[1000000020903995251349975997] = 9333; - rayToBps[1000000020905635398899758575] = 9334; - rayToBps[1000000020907275461619444770] = 9335; - rayToBps[1000000020908915439517809128] = 9336; - rayToBps[1000000020910555332603624828] = 9337; - rayToBps[1000000020912195140885663693] = 9338; - rayToBps[1000000020913834864372696184] = 9339; - rayToBps[1000000020915474503073491401] = 9340; - rayToBps[1000000020917114056996817083] = 9341; - rayToBps[1000000020918753526151439610] = 9342; - rayToBps[1000000020920392910546124003] = 9343; - rayToBps[1000000020922032210189633922] = 9344; - rayToBps[1000000020923671425090731669] = 9345; - rayToBps[1000000020925310555258178187] = 9346; - rayToBps[1000000020926949600700733061] = 9347; - rayToBps[1000000020928588561427154516] = 9348; - rayToBps[1000000020930227437446199421] = 9349; - rayToBps[1000000020931866228766623286] = 9350; - rayToBps[1000000020933504935397180265] = 9351; - rayToBps[1000000020935143557346623152] = 9352; - rayToBps[1000000020936782094623703389] = 9353; - rayToBps[1000000020938420547237171057] = 9354; - rayToBps[1000000020940058915195774882] = 9355; - rayToBps[1000000020941697198508262234] = 9356; - rayToBps[1000000020943335397183379129] = 9357; - rayToBps[1000000020944973511229870225] = 9358; - rayToBps[1000000020946611540656478827] = 9359; - rayToBps[1000000020948249485471946881] = 9360; - rayToBps[1000000020949887345685014985] = 9361; - rayToBps[1000000020951525121304422378] = 9362; - rayToBps[1000000020953162812338906945] = 9363; - rayToBps[1000000020954800418797205219] = 9364; - rayToBps[1000000020956437940688052380] = 9365; - rayToBps[1000000020958075378020182251] = 9366; - rayToBps[1000000020959712730802327307] = 9367; - rayToBps[1000000020961349999043218668] = 9368; - rayToBps[1000000020962987182751586100] = 9369; - rayToBps[1000000020964624281936158019] = 9370; - rayToBps[1000000020966261296605661489] = 9371; - rayToBps[1000000020967898226768822224] = 9372; - rayToBps[1000000020969535072434364582] = 9373; - rayToBps[1000000020971171833611011575] = 9374; - rayToBps[1000000020972808510307484860] = 9375; - rayToBps[1000000020974445102532504749] = 9376; - rayToBps[1000000020976081610294790199] = 9377; - rayToBps[1000000020977718033603058819] = 9378; - rayToBps[1000000020979354372466026869] = 9379; - rayToBps[1000000020980990626892409258] = 9380; - rayToBps[1000000020982626796890919548] = 9381; - rayToBps[1000000020984262882470269951] = 9382; - rayToBps[1000000020985898883639171329] = 9383; - rayToBps[1000000020987534800406333200] = 9384; - rayToBps[1000000020989170632780463731] = 9385; - rayToBps[1000000020990806380770269742] = 9386; - rayToBps[1000000020992442044384456705] = 9387; - rayToBps[1000000020994077623631728747] = 9388; - rayToBps[1000000020995713118520788645] = 9389; - rayToBps[1000000020997348529060337833] = 9390; - rayToBps[1000000020998983855259076396] = 9391; - rayToBps[1000000021000619097125703075] = 9392; - rayToBps[1000000021002254254668915262] = 9393; - rayToBps[1000000021003889327897409010] = 9394; - rayToBps[1000000021005524316819879020] = 9395; - rayToBps[1000000021007159221445018652] = 9396; - rayToBps[1000000021008794041781519920] = 9397; - rayToBps[1000000021010428777838073494] = 9398; - rayToBps[1000000021012063429623368701] = 9399; - rayToBps[1000000021013697997146093523] = 9400; - rayToBps[1000000021015332480414934599] = 9401; - rayToBps[1000000021016966879438577225] = 9402; - rayToBps[1000000021018601194225705352] = 9403; - rayToBps[1000000021020235424785001592] = 9404; - rayToBps[1000000021021869571125147213] = 9405; - rayToBps[1000000021023503633254822139] = 9406; - rayToBps[1000000021025137611182704955] = 9407; - rayToBps[1000000021026771504917472904] = 9408; - rayToBps[1000000021028405314467801886] = 9409; - rayToBps[1000000021030039039842366461] = 9410; - rayToBps[1000000021031672681049839850] = 9411; - rayToBps[1000000021033306238098893931] = 9412; - rayToBps[1000000021034939710998199243] = 9413; - rayToBps[1000000021036573099756424985] = 9414; - rayToBps[1000000021038206404382239016] = 9415; - rayToBps[1000000021039839624884307857] = 9416; - rayToBps[1000000021041472761271296689] = 9417; - rayToBps[1000000021043105813551869354] = 9418; - rayToBps[1000000021044738781734688354] = 9419; - rayToBps[1000000021046371665828414857] = 9420; - rayToBps[1000000021048004465841708690] = 9421; - rayToBps[1000000021049637181783228343] = 9422; - rayToBps[1000000021051269813661630969] = 9423; - rayToBps[1000000021052902361485572381] = 9424; - rayToBps[1000000021054534825263707061] = 9425; - rayToBps[1000000021056167205004688149] = 9426; - rayToBps[1000000021057799500717167451] = 9427; - rayToBps[1000000021059431712409795437] = 9428; - rayToBps[1000000021061063840091221242] = 9429; - rayToBps[1000000021062695883770092662] = 9430; - rayToBps[1000000021064327843455056162] = 9431; - rayToBps[1000000021065959719154756872] = 9432; - rayToBps[1000000021067591510877838582] = 9433; - rayToBps[1000000021069223218632943755] = 9434; - rayToBps[1000000021070854842428713514] = 9435; - rayToBps[1000000021072486382273787653] = 9436; - rayToBps[1000000021074117838176804627] = 9437; - rayToBps[1000000021075749210146401562] = 9438; - rayToBps[1000000021077380498191214251] = 9439; - rayToBps[1000000021079011702319877152] = 9440; - rayToBps[1000000021080642822541023391] = 9441; - rayToBps[1000000021082273858863284763] = 9442; - rayToBps[1000000021083904811295291730] = 9443; - rayToBps[1000000021085535679845673424] = 9444; - rayToBps[1000000021087166464523057642] = 9445; - rayToBps[1000000021088797165336070856] = 9446; - rayToBps[1000000021090427782293338202] = 9447; - rayToBps[1000000021092058315403483486] = 9448; - rayToBps[1000000021093688764675129185] = 9449; - rayToBps[1000000021095319130116896449] = 9450; - rayToBps[1000000021096949411737405092] = 9451; - rayToBps[1000000021098579609545273603] = 9452; - rayToBps[1000000021100209723549119140] = 9453; - rayToBps[1000000021101839753757557533] = 9454; - rayToBps[1000000021103469700179203284] = 9455; - rayToBps[1000000021105099562822669564] = 9456; - rayToBps[1000000021106729341696568219] = 9457; - rayToBps[1000000021108359036809509766] = 9458; - rayToBps[1000000021109988648170103394] = 9459; - rayToBps[1000000021111618175786956964] = 9460; - rayToBps[1000000021113247619668677013] = 9461; - rayToBps[1000000021114876979823868748] = 9462; - rayToBps[1000000021116506256261136053] = 9463; - rayToBps[1000000021118135448989081482] = 9464; - rayToBps[1000000021119764558016306265] = 9465; - rayToBps[1000000021121393583351410308] = 9466; - rayToBps[1000000021123022525002992189] = 9467; - rayToBps[1000000021124651382979649161] = 9468; - rayToBps[1000000021126280157289977155] = 9469; - rayToBps[1000000021127908847942570774] = 9470; - rayToBps[1000000021129537454946023301] = 9471; - rayToBps[1000000021131165978308926689] = 9472; - rayToBps[1000000021132794418039871573] = 9473; - rayToBps[1000000021134422774147447262] = 9474; - rayToBps[1000000021136051046640241741] = 9475; - rayToBps[1000000021137679235526841675] = 9476; - rayToBps[1000000021139307340815832403] = 9477; - rayToBps[1000000021140935362515797945] = 9478; - rayToBps[1000000021142563300635320996] = 9479; - rayToBps[1000000021144191155182982930] = 9480; - rayToBps[1000000021145818926167363800] = 9481; - rayToBps[1000000021147446613597042338] = 9482; - rayToBps[1000000021149074217480595956] = 9483; - rayToBps[1000000021150701737826600742] = 9484; - rayToBps[1000000021152329174643631465] = 9485; - rayToBps[1000000021153956527940261575] = 9486; - rayToBps[1000000021155583797725063203] = 9487; - rayToBps[1000000021157210984006607157] = 9488; - rayToBps[1000000021158838086793462926] = 9489; - rayToBps[1000000021160465106094198684] = 9490; - rayToBps[1000000021162092041917381283] = 9491; - rayToBps[1000000021163718894271576256] = 9492; - rayToBps[1000000021165345663165347819] = 9493; - rayToBps[1000000021166972348607258868] = 9494; - rayToBps[1000000021168598950605870985] = 9495; - rayToBps[1000000021170225469169744432] = 9496; - rayToBps[1000000021171851904307438154] = 9497; - rayToBps[1000000021173478256027509779] = 9498; - rayToBps[1000000021175104524338515618] = 9499; - rayToBps[1000000021176730709249010667] = 9500; - rayToBps[1000000021178356810767548605] = 9501; - rayToBps[1000000021179982828902681797] = 9502; - rayToBps[1000000021181608763662961287] = 9503; - rayToBps[1000000021183234615056936809] = 9504; - rayToBps[1000000021184860383093156782] = 9505; - rayToBps[1000000021186486067780168307] = 9506; - rayToBps[1000000021188111669126517170] = 9507; - rayToBps[1000000021189737187140747849] = 9508; - rayToBps[1000000021191362621831403501] = 9509; - rayToBps[1000000021192987973207025974] = 9510; - rayToBps[1000000021194613241276155799] = 9511; - rayToBps[1000000021196238426047332195] = 9512; - rayToBps[1000000021197863527529093071] = 9513; - rayToBps[1000000021199488545729975021] = 9514; - rayToBps[1000000021201113480658513324] = 9515; - rayToBps[1000000021202738332323241953] = 9516; - rayToBps[1000000021204363100732693562] = 9517; - rayToBps[1000000021205987785895399502] = 9518; - rayToBps[1000000021207612387819889804] = 9519; - rayToBps[1000000021209236906514693195] = 9520; - rayToBps[1000000021210861341988337085] = 9521; - rayToBps[1000000021212485694249347580] = 9522; - rayToBps[1000000021214109963306249471] = 9523; - rayToBps[1000000021215734149167566241] = 9524; - rayToBps[1000000021217358251841820063] = 9525; - rayToBps[1000000021218982271337531802] = 9526; - rayToBps[1000000021220606207663221010] = 9527; - rayToBps[1000000021222230060827405935] = 9528; - rayToBps[1000000021223853830838603512] = 9529; - rayToBps[1000000021225477517705329371] = 9530; - rayToBps[1000000021227101121436097833] = 9531; - rayToBps[1000000021228724642039421911] = 9532; - rayToBps[1000000021230348079523813310] = 9533; - rayToBps[1000000021231971433897782427] = 9534; - rayToBps[1000000021233594705169838355] = 9535; - rayToBps[1000000021235217893348488878] = 9536; - rayToBps[1000000021236840998442240473] = 9537; - rayToBps[1000000021238464020459598314] = 9538; - rayToBps[1000000021240086959409066265] = 9539; - rayToBps[1000000021241709815299146887] = 9540; - rayToBps[1000000021243332588138341436] = 9541; - rayToBps[1000000021244955277935149860] = 9542; - rayToBps[1000000021246577884698070805] = 9543; - rayToBps[1000000021248200408435601610] = 9544; - rayToBps[1000000021249822849156238313] = 9545; - rayToBps[1000000021251445206868475647] = 9546; - rayToBps[1000000021253067481580807036] = 9547; - rayToBps[1000000021254689673301724609] = 9548; - rayToBps[1000000021256311782039719186] = 9549; - rayToBps[1000000021257933807803280285] = 9550; - rayToBps[1000000021259555750600896123] = 9551; - rayToBps[1000000021261177610441053612] = 9552; - rayToBps[1000000021262799387332238365] = 9553; - rayToBps[1000000021264421081282934690] = 9554; - rayToBps[1000000021266042692301625596] = 9555; - rayToBps[1000000021267664220396792789] = 9556; - rayToBps[1000000021269285665576916672] = 9557; - rayToBps[1000000021270907027850476352] = 9558; - rayToBps[1000000021272528307225949633] = 9559; - rayToBps[1000000021274149503711813016] = 9560; - rayToBps[1000000021275770617316541707] = 9561; - rayToBps[1000000021277391648048609609] = 9562; - rayToBps[1000000021279012595916489324] = 9563; - rayToBps[1000000021280633460928652160] = 9564; - rayToBps[1000000021282254243093568122] = 9565; - rayToBps[1000000021283874942419705916] = 9566; - rayToBps[1000000021285495558915532952] = 9567; - rayToBps[1000000021287116092589515341] = 9568; - rayToBps[1000000021288736543450117894] = 9569; - rayToBps[1000000021290356911505804127] = 9570; - rayToBps[1000000021291977196765036258] = 9571; - rayToBps[1000000021293597399236275207] = 9572; - rayToBps[1000000021295217518927980598] = 9573; - rayToBps[1000000021296837555848610757] = 9574; - rayToBps[1000000021298457510006622716] = 9575; - rayToBps[1000000021300077381410472209] = 9576; - rayToBps[1000000021301697170068613676] = 9577; - rayToBps[1000000021303316875989500258] = 9578; - rayToBps[1000000021304936499181583805] = 9579; - rayToBps[1000000021306556039653314870] = 9580; - rayToBps[1000000021308175497413142711] = 9581; - rayToBps[1000000021309794872469515290] = 9582; - rayToBps[1000000021311414164830879280] = 9583; - rayToBps[1000000021313033374505680055] = 9584; - rayToBps[1000000021314652501502361696] = 9585; - rayToBps[1000000021316271545829366993] = 9586; - rayToBps[1000000021317890507495137440] = 9587; - rayToBps[1000000021319509386508113242] = 9588; - rayToBps[1000000021321128182876733306] = 9589; - rayToBps[1000000021322746896609435252] = 9590; - rayToBps[1000000021324365527714655404] = 9591; - rayToBps[1000000021325984076200828797] = 9592; - rayToBps[1000000021327602542076389171] = 9593; - rayToBps[1000000021329220925349768978] = 9594; - rayToBps[1000000021330839226029399378] = 9595; - rayToBps[1000000021332457444123710238] = 9596; - rayToBps[1000000021334075579641130140] = 9597; - rayToBps[1000000021335693632590086368] = 9598; - rayToBps[1000000021337311602979004923] = 9599; - rayToBps[1000000021338929490816310513] = 9600; - rayToBps[1000000021340547296110426556] = 9601; - rayToBps[1000000021342165018869775181] = 9602; - rayToBps[1000000021343782659102777232] = 9603; - rayToBps[1000000021345400216817852259] = 9604; - rayToBps[1000000021347017692023418526] = 9605; - rayToBps[1000000021348635084727893008] = 9606; - rayToBps[1000000021350252394939691393] = 9607; - rayToBps[1000000021351869622667228081] = 9608; - rayToBps[1000000021353486767918916187] = 9609; - rayToBps[1000000021355103830703167533] = 9610; - rayToBps[1000000021356720811028392661] = 9611; - rayToBps[1000000021358337708903000822] = 9612; - rayToBps[1000000021359954524335399980] = 9613; - rayToBps[1000000021361571257333996817] = 9614; - rayToBps[1000000021363187907907196727] = 9615; - rayToBps[1000000021364804476063403818] = 9616; - rayToBps[1000000021366420961811020914] = 9617; - rayToBps[1000000021368037365158449552] = 9618; - rayToBps[1000000021369653686114089987] = 9619; - rayToBps[1000000021371269924686341187] = 9620; - rayToBps[1000000021372886080883600836] = 9621; - rayToBps[1000000021374502154714265338] = 9622; - rayToBps[1000000021376118146186729808] = 9623; - rayToBps[1000000021377734055309388080] = 9624; - rayToBps[1000000021379349882090632705] = 9625; - rayToBps[1000000021380965626538854950] = 9626; - rayToBps[1000000021382581288662444801] = 9627; - rayToBps[1000000021384196868469790961] = 9628; - rayToBps[1000000021385812365969280848] = 9629; - rayToBps[1000000021387427781169300605] = 9630; - rayToBps[1000000021389043114078235086] = 9631; - rayToBps[1000000021390658364704467867] = 9632; - rayToBps[1000000021392273533056381244] = 9633; - rayToBps[1000000021393888619142356230] = 9634; - rayToBps[1000000021395503622970772558] = 9635; - rayToBps[1000000021397118544550008682] = 9636; - rayToBps[1000000021398733383888441774] = 9637; - rayToBps[1000000021400348140994447728] = 9638; - rayToBps[1000000021401962815876401158] = 9639; - rayToBps[1000000021403577408542675398] = 9640; - rayToBps[1000000021405191919001642503] = 9641; - rayToBps[1000000021406806347261673250] = 9642; - rayToBps[1000000021408420693331137139] = 9643; - rayToBps[1000000021410034957218402388] = 9644; - rayToBps[1000000021411649138931835939] = 9645; - rayToBps[1000000021413263238479803458] = 9646; - rayToBps[1000000021414877255870669331] = 9647; - rayToBps[1000000021416491191112796669] = 9648; - rayToBps[1000000021418105044214547303] = 9649; - rayToBps[1000000021419718815184281790] = 9650; - rayToBps[1000000021421332504030359411] = 9651; - rayToBps[1000000021422946110761138169] = 9652; - rayToBps[1000000021424559635384974793] = 9653; - rayToBps[1000000021426173077910224732] = 9654; - rayToBps[1000000021427786438345242167] = 9655; - rayToBps[1000000021429399716698379997] = 9656; - rayToBps[1000000021431012912977989851] = 9657; - rayToBps[1000000021432626027192422079] = 9658; - rayToBps[1000000021434239059350025762] = 9659; - rayToBps[1000000021435852009459148702] = 9660; - rayToBps[1000000021437464877528137431] = 9661; - rayToBps[1000000021439077663565337204] = 9662; - rayToBps[1000000021440690367579092006] = 9663; - rayToBps[1000000021442302989577744547] = 9664; - rayToBps[1000000021443915529569636263] = 9665; - rayToBps[1000000021445527987563107323] = 9666; - rayToBps[1000000021447140363566496615] = 9667; - rayToBps[1000000021448752657588141766] = 9668; - rayToBps[1000000021450364869636379120] = 9669; - rayToBps[1000000021451976999719543756] = 9670; - rayToBps[1000000021453589047845969483] = 9671; - rayToBps[1000000021455201014023988834] = 9672; - rayToBps[1000000021456812898261933077] = 9673; - rayToBps[1000000021458424700568132203] = 9674; - rayToBps[1000000021460036420950914938] = 9675; - rayToBps[1000000021461648059418608738] = 9676; - rayToBps[1000000021463259615979539784] = 9677; - rayToBps[1000000021464871090642032996] = 9678; - rayToBps[1000000021466482483414412017] = 9679; - rayToBps[1000000021468093794304999225] = 9680; - rayToBps[1000000021469705023322115729] = 9681; - rayToBps[1000000021471316170474081370] = 9682; - rayToBps[1000000021472927235769214720] = 9683; - rayToBps[1000000021474538219215833083] = 9684; - rayToBps[1000000021476149120822252496] = 9685; - rayToBps[1000000021477759940596787728] = 9686; - rayToBps[1000000021479370678547752283] = 9687; - rayToBps[1000000021480981334683458396] = 9688; - rayToBps[1000000021482591909012217035] = 9689; - rayToBps[1000000021484202401542337904] = 9690; - rayToBps[1000000021485812812282129439] = 9691; - rayToBps[1000000021487423141239898812] = 9692; - rayToBps[1000000021489033388423951926] = 9693; - rayToBps[1000000021490643553842593424] = 9694; - rayToBps[1000000021492253637504126680] = 9695; - rayToBps[1000000021493863639416853802] = 9696; - rayToBps[1000000021495473559589075640] = 9697; - rayToBps[1000000021497083398029091773] = 9698; - rayToBps[1000000021498693154745200519] = 9699; - rayToBps[1000000021500302829745698932] = 9700; - rayToBps[1000000021501912423038882802] = 9701; - rayToBps[1000000021503521934633046657] = 9702; - rayToBps[1000000021505131364536483760] = 9703; - rayToBps[1000000021506740712757486113] = 9704; - rayToBps[1000000021508349979304344456] = 9705; - rayToBps[1000000021509959164185348265] = 9706; - rayToBps[1000000021511568267408785753] = 9707; - rayToBps[1000000021513177288982943876] = 9708; - rayToBps[1000000021514786228916108326] = 9709; - rayToBps[1000000021516395087216563531] = 9710; - rayToBps[1000000021518003863892592663] = 9711; - rayToBps[1000000021519612558952477629] = 9712; - rayToBps[1000000021521221172404499080] = 9713; - rayToBps[1000000021522829704256936402] = 9714; - rayToBps[1000000021524438154518067725] = 9715; - rayToBps[1000000021526046523196169918] = 9716; - rayToBps[1000000021527654810299518591] = 9717; - rayToBps[1000000021529263015836388092] = 9718; - rayToBps[1000000021530871139815051515] = 9719; - rayToBps[1000000021532479182243780693] = 9720; - rayToBps[1000000021534087143130846199] = 9721; - rayToBps[1000000021535695022484517350] = 9722; - rayToBps[1000000021537302820313062204] = 9723; - rayToBps[1000000021538910536624747565] = 9724; - rayToBps[1000000021540518171427838973] = 9725; - rayToBps[1000000021542125724730600717] = 9726; - rayToBps[1000000021543733196541295825] = 9727; - rayToBps[1000000021545340586868186072] = 9728; - rayToBps[1000000021546947895719531973] = 9729; - rayToBps[1000000021548555123103592792] = 9730; - rayToBps[1000000021550162269028626530] = 9731; - rayToBps[1000000021551769333502889939] = 9732; - rayToBps[1000000021553376316534638512] = 9733; - rayToBps[1000000021554983218132126488] = 9734; - rayToBps[1000000021556590038303606853] = 9735; - rayToBps[1000000021558196777057331335] = 9736; - rayToBps[1000000021559803434401550410] = 9737; - rayToBps[1000000021561410010344513300] = 9738; - rayToBps[1000000021563016504894467972] = 9739; - rayToBps[1000000021564622918059661140] = 9740; - rayToBps[1000000021566229249848338266] = 9741; - rayToBps[1000000021567835500268743557] = 9742; - rayToBps[1000000021569441669329119967] = 9743; - rayToBps[1000000021571047757037709200] = 9744; - rayToBps[1000000021572653763402751707] = 9745; - rayToBps[1000000021574259688432486685] = 9746; - rayToBps[1000000021575865532135152081] = 9747; - rayToBps[1000000021577471294518984591] = 9748; - rayToBps[1000000021579076975592219657] = 9749; - rayToBps[1000000021580682575363091474] = 9750; - rayToBps[1000000021582288093839832982] = 9751; - rayToBps[1000000021583893531030675874] = 9752; - rayToBps[1000000021585498886943850592] = 9753; - rayToBps[1000000021587104161587586327] = 9754; - rayToBps[1000000021588709354970111019] = 9755; - rayToBps[1000000021590314467099651363] = 9756; - rayToBps[1000000021591919497984432801] = 9757; - rayToBps[1000000021593524447632679526] = 9758; - rayToBps[1000000021595129316052614485] = 9759; - rayToBps[1000000021596734103252459374] = 9760; - rayToBps[1000000021598338809240434642] = 9761; - rayToBps[1000000021599943434024759490] = 9762; - rayToBps[1000000021601547977613651871] = 9763; - rayToBps[1000000021603152440015328491] = 9764; - rayToBps[1000000021604756821238004808] = 9765; - rayToBps[1000000021606361121289895034] = 9766; - rayToBps[1000000021607965340179212134] = 9767; - rayToBps[1000000021609569477914167825] = 9768; - rayToBps[1000000021611173534502972580] = 9769; - rayToBps[1000000021612777509953835627] = 9770; - rayToBps[1000000021614381404274964943] = 9771; - rayToBps[1000000021615985217474567267] = 9772; - rayToBps[1000000021617588949560848087] = 9773; - rayToBps[1000000021619192600542011648] = 9774; - rayToBps[1000000021620796170426260951] = 9775; - rayToBps[1000000021622399659221797752] = 9776; - rayToBps[1000000021624003066936822564] = 9777; - rayToBps[1000000021625606393579534651] = 9778; - rayToBps[1000000021627209639158132043] = 9779; - rayToBps[1000000021628812803680811515] = 9780; - rayToBps[1000000021630415887155768610] = 9781; - rayToBps[1000000021632018889591197618] = 9782; - rayToBps[1000000021633621810995291595] = 9783; - rayToBps[1000000021635224651376242349] = 9784; - rayToBps[1000000021636827410742240447] = 9785; - rayToBps[1000000021638430089101475216] = 9786; - rayToBps[1000000021640032686462134738] = 9787; - rayToBps[1000000021641635202832405858] = 9788; - rayToBps[1000000021643237638220474177] = 9789; - rayToBps[1000000021644839992634524055] = 9790; - rayToBps[1000000021646442266082738611] = 9791; - rayToBps[1000000021648044458573299725] = 9792; - rayToBps[1000000021649646570114388037] = 9793; - rayToBps[1000000021651248600714182947] = 9794; - rayToBps[1000000021652850550380862614] = 9795; - rayToBps[1000000021654452419122603958] = 9796; - rayToBps[1000000021656054206947582660] = 9797; - rayToBps[1000000021657655913863973164] = 9798; - rayToBps[1000000021659257539879948673] = 9799; - rayToBps[1000000021660859085003681151] = 9800; - rayToBps[1000000021662460549243341328] = 9801; - rayToBps[1000000021664061932607098690] = 9802; - rayToBps[1000000021665663235103121490] = 9803; - rayToBps[1000000021667264456739576744] = 9804; - rayToBps[1000000021668865597524630226] = 9805; - rayToBps[1000000021670466657466446478] = 9806; - rayToBps[1000000021672067636573188805] = 9807; - rayToBps[1000000021673668534853019271] = 9808; - rayToBps[1000000021675269352314098709] = 9809; - rayToBps[1000000021676870088964586713] = 9810; - rayToBps[1000000021678470744812641643] = 9811; - rayToBps[1000000021680071319866420625] = 9812; - rayToBps[1000000021681671814134079545] = 9813; - rayToBps[1000000021683272227623773058] = 9814; - rayToBps[1000000021684872560343654583] = 9815; - rayToBps[1000000021686472812301876306] = 9816; - rayToBps[1000000021688072983506589178] = 9817; - rayToBps[1000000021689673073965942915] = 9818; - rayToBps[1000000021691273083688086000] = 9819; - rayToBps[1000000021692873012681165684] = 9820; - rayToBps[1000000021694472860953327982] = 9821; - rayToBps[1000000021696072628512717681] = 9822; - rayToBps[1000000021697672315367478329] = 9823; - rayToBps[1000000021699271921525752246] = 9824; - rayToBps[1000000021700871446995680519] = 9825; - rayToBps[1000000021702470891785403001] = 9826; - rayToBps[1000000021704070255903058316] = 9827; - rayToBps[1000000021705669539356783857] = 9828; - rayToBps[1000000021707268742154715782] = 9829; - rayToBps[1000000021708867864304989022] = 9830; - rayToBps[1000000021710466905815737276] = 9831; - rayToBps[1000000021712065866695093012] = 9832; - rayToBps[1000000021713664746951187467] = 9833; - rayToBps[1000000021715263546592150652] = 9834; - rayToBps[1000000021716862265626111344] = 9835; - rayToBps[1000000021718460904061197091] = 9836; - rayToBps[1000000021720059461905534215] = 9837; - rayToBps[1000000021721657939167247807] = 9838; - rayToBps[1000000021723256335854461729] = 9839; - rayToBps[1000000021724854651975298614] = 9840; - rayToBps[1000000021726452887537879870] = 9841; - rayToBps[1000000021728051042550325673] = 9842; - rayToBps[1000000021729649117020754974] = 9843; - rayToBps[1000000021731247110957285495] = 9844; - rayToBps[1000000021732845024368033733] = 9845; - rayToBps[1000000021734442857261114954] = 9846; - rayToBps[1000000021736040609644643201] = 9847; - rayToBps[1000000021737638281526731291] = 9848; - rayToBps[1000000021739235872915490812] = 9849; - rayToBps[1000000021740833383819032127] = 9850; - rayToBps[1000000021742430814245464373] = 9851; - rayToBps[1000000021744028164202895462] = 9852; - rayToBps[1000000021745625433699432083] = 9853; - rayToBps[1000000021747222622743179696] = 9854; - rayToBps[1000000021748819731342242539] = 9855; - rayToBps[1000000021750416759504723623] = 9856; - rayToBps[1000000021752013707238724737] = 9857; - rayToBps[1000000021753610574552346447] = 9858; - rayToBps[1000000021755207361453688091] = 9859; - rayToBps[1000000021756804067950847789] = 9860; - rayToBps[1000000021758400694051922433] = 9861; - rayToBps[1000000021759997239765007694] = 9862; - rayToBps[1000000021761593705098198022] = 9863; - rayToBps[1000000021763190090059586640] = 9864; - rayToBps[1000000021764786394657265553] = 9865; - rayToBps[1000000021766382618899325542] = 9866; - rayToBps[1000000021767978762793856166] = 9867; - rayToBps[1000000021769574826348945765] = 9868; - rayToBps[1000000021771170809572681453] = 9869; - rayToBps[1000000021772766712473149127] = 9870; - rayToBps[1000000021774362535058433462] = 9871; - rayToBps[1000000021775958277336617913] = 9872; - rayToBps[1000000021777553939315784714] = 9873; - rayToBps[1000000021779149521004014877] = 9874; - rayToBps[1000000021780745022409388199] = 9875; - rayToBps[1000000021782340443539983254] = 9876; - rayToBps[1000000021783935784403877396] = 9877; - rayToBps[1000000021785531045009146762] = 9878; - rayToBps[1000000021787126225363866271] = 9879; - rayToBps[1000000021788721325476109620] = 9880; - rayToBps[1000000021790316345353949290] = 9881; - rayToBps[1000000021791911285005456544] = 9882; - rayToBps[1000000021793506144438701426] = 9883; - rayToBps[1000000021795100923661752763] = 9884; - rayToBps[1000000021796695622682678165] = 9885; - rayToBps[1000000021798290241509544024] = 9886; - rayToBps[1000000021799884780150415518] = 9887; - rayToBps[1000000021801479238613356603] = 9888; - rayToBps[1000000021803073616906430024] = 9889; - rayToBps[1000000021804667915037697306] = 9890; - rayToBps[1000000021806262133015218760] = 9891; - rayToBps[1000000021807856270847053482] = 9892; - rayToBps[1000000021809450328541259351] = 9893; - rayToBps[1000000021811044306105893031] = 9894; - rayToBps[1000000021812638203549009974] = 9895; - rayToBps[1000000021814232020878664411] = 9896; - rayToBps[1000000021815825758102909365] = 9897; - rayToBps[1000000021817419415229796642] = 9898; - rayToBps[1000000021819012992267376834] = 9899; - rayToBps[1000000021820606489223699321] = 9900; - rayToBps[1000000021822199906106812267] = 9901; - rayToBps[1000000021823793242924762624] = 9902; - rayToBps[1000000021825386499685596130] = 9903; - rayToBps[1000000021826979676397357315] = 9904; - rayToBps[1000000021828572773068089490] = 9905; - rayToBps[1000000021830165789705834758] = 9906; - rayToBps[1000000021831758726318634008] = 9907; - rayToBps[1000000021833351582914526918] = 9908; - rayToBps[1000000021834944359501551955] = 9909; - rayToBps[1000000021836537056087746374] = 9910; - rayToBps[1000000021838129672681146219] = 9911; - rayToBps[1000000021839722209289786324] = 9912; - rayToBps[1000000021841314665921700311] = 9913; - rayToBps[1000000021842907042584920594] = 9914; - rayToBps[1000000021844499339287478375] = 9915; - rayToBps[1000000021846091556037403647] = 9916; - rayToBps[1000000021847683692842725193] = 9917; - rayToBps[1000000021849275749711470586] = 9918; - rayToBps[1000000021850867726651666193] = 9919; - rayToBps[1000000021852459623671337169] = 9920; - rayToBps[1000000021854051440778507461] = 9921; - rayToBps[1000000021855643177981199810] = 9922; - rayToBps[1000000021857234835287435745] = 9923; - rayToBps[1000000021858826412705235591] = 9924; - rayToBps[1000000021860417910242618463] = 9925; - rayToBps[1000000021862009327907602268] = 9926; - rayToBps[1000000021863600665708203710] = 9927; - rayToBps[1000000021865191923652438280] = 9928; - rayToBps[1000000021866783101748320269] = 9929; - rayToBps[1000000021868374200003862755] = 9930; - rayToBps[1000000021869965218427077615] = 9931; - rayToBps[1000000021871556157025975518] = 9932; - rayToBps[1000000021873147015808565927] = 9933; - rayToBps[1000000021874737794782857101] = 9934; - rayToBps[1000000021876328493956856091] = 9935; - rayToBps[1000000021877919113338568748] = 9936; - rayToBps[1000000021879509652935999713] = 9937; - rayToBps[1000000021881100112757152424] = 9938; - rayToBps[1000000021882690492810029118] = 9939; - rayToBps[1000000021884280793102630824] = 9940; - rayToBps[1000000021885871013642957370] = 9941; - rayToBps[1000000021887461154439007378] = 9942; - rayToBps[1000000021889051215498778269] = 9943; - rayToBps[1000000021890641196830266260] = 9944; - rayToBps[1000000021892231098441466365] = 9945; - rayToBps[1000000021893820920340372396] = 9946; - rayToBps[1000000021895410662534976963] = 9947; - rayToBps[1000000021897000325033271473] = 9948; - rayToBps[1000000021898589907843246131] = 9949; - rayToBps[1000000021900179410972889943] = 9950; - rayToBps[1000000021901768834430190709] = 9951; - rayToBps[1000000021903358178223135034] = 9952; - rayToBps[1000000021904947442359708315] = 9953; - rayToBps[1000000021906536626847894756] = 9954; - rayToBps[1000000021908125731695677355] = 9955; - rayToBps[1000000021909714756911037912] = 9956; - rayToBps[1000000021911303702501957027] = 9957; - rayToBps[1000000021912892568476414100] = 9958; - rayToBps[1000000021914481354842387331] = 9959; - rayToBps[1000000021916070061607853724] = 9960; - rayToBps[1000000021917658688780789081] = 9961; - rayToBps[1000000021919247236369168005] = 9962; - rayToBps[1000000021920835704380963901] = 9963; - rayToBps[1000000021922424092824148978] = 9964; - rayToBps[1000000021924012401706694246] = 9965; - rayToBps[1000000021925600631036569516] = 9966; - rayToBps[1000000021927188780821743402] = 9967; - rayToBps[1000000021928776851070183322] = 9968; - rayToBps[1000000021930364841789855494] = 9969; - rayToBps[1000000021931952752988724944] = 9970; - rayToBps[1000000021933540584674755497] = 9971; - rayToBps[1000000021935128336855909784] = 9972; - rayToBps[1000000021936716009540149239] = 9973; - rayToBps[1000000021938303602735434102] = 9974; - rayToBps[1000000021939891116449723415] = 9975; - rayToBps[1000000021941478550690975027] = 9976; - rayToBps[1000000021943065905467145588] = 9977; - rayToBps[1000000021944653180786190559] = 9978; - rayToBps[1000000021946240376656064202] = 9979; - rayToBps[1000000021947827493084719585] = 9980; - rayToBps[1000000021949414530080108585] = 9981; - rayToBps[1000000021951001487650181881] = 9982; - rayToBps[1000000021952588365802888961] = 9983; - rayToBps[1000000021954175164546178118] = 9984; - rayToBps[1000000021955761883887996454] = 9985; - rayToBps[1000000021957348523836289875] = 9986; - rayToBps[1000000021958935084399003098] = 9987; - rayToBps[1000000021960521565584079645] = 9988; - rayToBps[1000000021962107967399461846] = 9989; - rayToBps[1000000021963694289853090839] = 9990; - rayToBps[1000000021965280532952906572] = 9991; - rayToBps[1000000021966866696706847799] = 9992; - rayToBps[1000000021968452781122852084] = 9993; - rayToBps[1000000021970038786208855800] = 9994; - rayToBps[1000000021971624711972794130] = 9995; - rayToBps[1000000021973210558422601065] = 9996; - rayToBps[1000000021974796325566209405] = 9997; - rayToBps[1000000021976382013411550763] = 9998; - rayToBps[1000000021977967621966555560] = 9999; - rayToBps[1000000021979553151239153027] = 10000; + ray := add(and(shifted, 0xFFFFFFFFFFFFFFFF), RAY) + } } - function btor(uint256 bps) public view returns (uint256 ray) { - require(bps <= MAX_BPS_IN, "Conv/bps-too-high"); - ray = bpsToRay[bps]; - require(ray != 0, "Conv/out-of-bounds"); + function rtob(uint256 ray) public pure returns (uint256 bps) { + uint256 yearlyRate = _rpow(ray, 365 days); + return ((yearlyRate - RAY) * BPS + RAY / 2) / RAY; } - function rtob(uint256 ray) public view returns (uint256 bps) { - require(ray >= RAY, "Conv/ray-too-low"); - bps = rayToBps[ray]; - // Check if it's in range - require(bpsToRay[bps] == ray, "Conv/out-of-bounds"); + function _rpow(uint256 x, uint256 n) internal pure returns (uint256 z) { + assembly { + switch x + case 0 { + switch n + case 0 { z := RAY } + default { z := 0 } + } + default { + switch mod(n, 2) + case 0 { z := RAY } + default { z := x } + let half := div(RAY, 2) // for rounding. + for { n := div(n, 2) } n { n := div(n, 2) } { + let xx := mul(x, x) + if iszero(eq(div(xx, x), x)) { revert(0, 0) } + let xxRound := add(xx, half) + if lt(xxRound, xx) { revert(0, 0) } + x := div(xxRound, RAY) + if mod(n, 2) { + let zx := mul(z, x) + if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) } + let zxRound := add(zx, half) + if lt(zxRound, zx) { revert(0, 0) } + z := div(zxRound, RAY) + } + } + } + } } } From 59a1f48c0f1311c4673268222dfbe05b6a853b24 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Tue, 1 Apr 2025 13:26:22 -0300 Subject: [PATCH 92/96] refactor: improve and cleanup rules --- certora/SPBEAM.spec | 55 +++++++++++++++++++++------------------------ 1 file changed, 26 insertions(+), 29 deletions(-) diff --git a/certora/SPBEAM.spec b/certora/SPBEAM.spec index d857fe2..af7c338 100644 --- a/certora/SPBEAM.spec +++ b/certora/SPBEAM.spec @@ -304,8 +304,8 @@ rule file_per_id_revert(bytes32 id, bytes32 what, uint256 data) { "file revert rules failed"; } -ghost mapping(uint256 => uint256) bps_to_ray { - init_state axiom forall uint256 i. bps_to_ray[i] == 0; +ghost mapping(mathint => mathint) bps_to_ray { + init_state axiom forall mathint i. bps_to_ray[i] == 0; } // Verify correct storage changes for non-reverting set @@ -328,7 +328,7 @@ rule set(SPBEAM.ParamChange[] updates) { dutyAfter, _rho = jug.ilks(ilk); // Manually convert all BPS values to RAY after the function call - // Store in the ghost mapping for use in the assertions + // Store in the ghost mapping to use it in the assertions if (updates.length > 0) { bps_to_ray[updates[0].bps] = conv.btor(updates[0].bps); } @@ -340,51 +340,49 @@ rule set(SPBEAM.ParamChange[] updates) { } // If DSR is in updates, then its value should match the converted input value - assert exists uint256 i. i < updates.length => updates[i].id == DSR() => - dsrAfter == to_mathint(bps_to_ray[updates[i].bps]), "DSR in updates; dsr not set correctly"; + assert exists uint256 i. i < updates.length && updates[i].id == DSR() => + dsrAfter == bps_to_ray[updates[i].bps], "DSR in updates; dsr not set correctly"; // If DSR is not in updates, then the value should not change assert (forall uint256 i. i < updates.length => updates[i].id != DSR()) => dsrAfter == dsrBefore, "DSR not in updates; dsr changed unexpectedly"; // If the value of DSR changed, then it should be in updates assert dsrAfter != dsrBefore => - (exists uint256 i. i < updates.length => updates[i].id == DSR()), "dsr changed; DSR not in updates"; + (exists uint256 i. i < updates.length && updates[i].id == DSR()), "dsr changed; DSR not in updates"; // If the value of DSR did not change, then it should either NOT be in updates or be in updates with the same value assert dsrAfter == dsrBefore => ( (forall uint256 i. i < updates.length => updates[i].id != DSR()) || - (exists uint256 i. i < updates.length => (updates[i].id == DSR() && to_mathint(bps_to_ray[updates[i].bps]) == dsrBefore)) + (exists uint256 i. i < updates.length && updates[i].id == DSR() && bps_to_ray[updates[i].bps] == dsrBefore) ), "dsr not changed; DSR in updates with different value"; - // If SSR is in updates, then its value should match the converted input value - assert exists uint256 i. i < updates.length => updates[i].id == SSR() => - ssrAfter == to_mathint(bps_to_ray[updates[i].bps]), "SSR in updates; ssr not set correctly"; + assert exists uint256 i. i < updates.length && updates[i].id == SSR() => + ssrAfter == bps_to_ray[updates[i].bps], "SSR in updates; ssr not set correctly"; // If SSR is not in updates, then the value should not change assert (forall uint256 i. i < updates.length => updates[i].id != SSR()) => ssrAfter == ssrBefore, "SSR not in updates; ssr changed unexpectedly"; // If the value of SSR changed, then it should be in updates assert ssrAfter != ssrBefore => ( - exists uint256 i. i < updates.length => updates[i].id == SSR() + exists uint256 i. i < updates.length && updates[i].id == SSR() ), "ssr changed; SSR not in updates"; // If the value of SSR did not change, then it should either NOT be in updates or be in updates with the same value assert ssrAfter == ssrBefore => ( (forall uint256 i. i < updates.length => updates[i].id != SSR()) || - (exists uint256 i. i < updates.length => (updates[i].id == SSR() && to_mathint(bps_to_ray[updates[i].bps]) == ssrBefore)) + (exists uint256 i. i < updates.length && updates[i].id == SSR() && bps_to_ray[updates[i].bps] == ssrBefore) ), "ssr not changed; SSR in updates with different value"; - // If ilk is in updates, then its duty value should match the converted input value - assert exists uint256 i. i < updates.length => updates[i].id == ilk => - dutyAfter == to_mathint(bps_to_ray[updates[i].bps]), "ilk in updates; duty not set correctly"; + assert exists uint256 i. i < updates.length && updates[i].id == ilk => + dutyAfter == bps_to_ray[updates[i].bps], "ilk in updates; duty not set correctly"; // If ilk is not in updates, then the value should not change assert (forall uint256 i. i < updates.length => updates[i].id != ilk) => dutyAfter == dutyBefore, "ilk not in updates; duty changed unexpectedly"; // If the value of ilk duty changed, then it should be in updates assert dutyAfter != dutyBefore => - (exists uint256 i. i < updates.length => updates[i].id == ilk), "duty changed; ilk not in updates"; + (exists uint256 i. i < updates.length && updates[i].id == ilk), "duty changed; ilk not in updates"; // If the value of ilk duty did not change, then it should either NOT be in updates or be in updates with the same value assert dutyAfter == dutyBefore => ( (forall uint256 i. i < updates.length => updates[i].id != ilk) || - (exists uint256 i. i < updates.length => (updates[i].id == ilk && to_mathint(bps_to_ray[updates[i].bps]) == dutyBefore)) + (exists uint256 i. i < updates.length && updates[i].id == ilk && bps_to_ray[updates[i].bps] == dutyBefore) ), "duty not changed; ilk in updates with different value"; } @@ -417,7 +415,7 @@ rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints, uint256[] bp bool revert4 = e.block.timestamp < tau() + toc(); // No updates bool revert5 = updates.length == 0; - // Sorted elements + // Strictly ordered elements bool revert6 = idsAsUints.length == 2 ? idsAsUints[0] >= idsAsUints[1] : false; bool revert7 = idsAsUints.length == 3 ? ( idsAsUints[0] >= idsAsUints[1] || @@ -435,22 +433,21 @@ rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints, uint256[] bp set_item_reverted[updates[2].id] = check_item_revert(e, updates[2].id, updates[2].bps); } - bool revert8 = updates.length > 0 ? set_item_reverted[updates[0].id] : false; - bool revert9 = updates.length > 1 - ? set_item_reverted[updates[0].id] || set_item_reverted[updates[1].id] - : false; - bool revert10 = updates.length > 2 - ? set_item_reverted[updates[0].id] || set_item_reverted[updates[1].id] || set_item_reverted[updates[2].id] - : false; + bool revert8 = exists uint256 i. i < updates.length && set_item_reverted[updates[i].id]; set@withrevert(e, updates); - assert lastReverted <=> + assert lastReverted => revert1 || revert2 || revert3 || revert4 || revert5 || revert6 || - revert7 || revert8 || revert9 || - revert10, - "set revert rules failed"; + revert7 || revert8, + "set reverted for an unknown reason"; + + assert revert1 || revert2 || revert3 || + revert4 || revert5 || revert6 || + revert7 || revert8 => + lastReverted, + "set should have reverted"; } function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { From a4b7919e6f5ec5de590cbf423dd379db99d89280 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 10 Apr 2025 16:14:55 -0300 Subject: [PATCH 93/96] feat(file_per_id): add assertions for keeping other params unchanged --- certora/SPBEAM.spec | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/certora/SPBEAM.spec b/certora/SPBEAM.spec index af7c338..fee2b05 100644 --- a/certora/SPBEAM.spec +++ b/certora/SPBEAM.spec @@ -260,10 +260,15 @@ rule file_global_revert(bytes32 what, uint256 data) { // Verify correct storage changes for non-reverting file for individual rate parameters rule file_per_id(bytes32 id, bytes32 what, uint256 data) { env e; + bytes32 other; + require other != id; mathint minBefore; mathint maxBefore; mathint stepBefore; minBefore, maxBefore, stepBefore = cfgs(id); + mathint minOtherBefore; mathint maxOtherBefore; mathint stepOtherBefore; + minOtherBefore, maxOtherBefore, stepOtherBefore = cfgs(other); + file(e, id, what, data); mathint minAfter; mathint maxAfter; mathint stepAfter; @@ -275,6 +280,13 @@ rule file_per_id(bytes32 id, bytes32 what, uint256 data) { assert what != MAX() => maxAfter == maxBefore, "file did keep unchanged max"; assert what == STEP() => stepAfter == to_mathint(data), "file did not set step"; assert what != STEP() => stepAfter == stepBefore, "file did keep unchanged step"; + + mathint minOtherAfter; mathint maxOtherAfter; mathint stepOtherAfter; + minOtherAfter, maxOtherAfter, stepOtherAfter = cfgs(other); + + assert minOtherAfter == minOtherBefore, "file unexpectedly changed other min"; + assert maxOtherAfter == maxOtherBefore, "file unexpectedly changed other max"; + assert stepOtherAfter == stepOtherBefore, "file unexpectedly changed other step"; } // Verify revert rules on file for individual rate parameters From b3b22474e53e0e527b56ca8f1361b3a0994d007a Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 10 Apr 2025 16:16:34 -0300 Subject: [PATCH 94/96] refactor(set): remove require on updates.length --- certora/SPBEAM.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/certora/SPBEAM.spec b/certora/SPBEAM.spec index fee2b05..94d68f4 100644 --- a/certora/SPBEAM.spec +++ b/certora/SPBEAM.spec @@ -325,7 +325,7 @@ rule set(SPBEAM.ParamChange[] updates) { env e; bytes32 ilk; require ilk != DSR() && ilk != SSR(); - require updates.length > 0 && updates.length < 4; + require updates.length < 4; mathint dsrBefore = pot.dsr(); mathint ssrBefore = susds.ssr(); From f0f2ea9b0b85e53c7e38cfa512c2f4c68e5cc9a9 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 10 Apr 2025 16:18:30 -0300 Subject: [PATCH 95/96] refactor(set_revert): apply suggestions from code review --- certora/SPBEAM.spec | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/certora/SPBEAM.spec b/certora/SPBEAM.spec index 94d68f4..f11a805 100644 --- a/certora/SPBEAM.spec +++ b/certora/SPBEAM.spec @@ -402,19 +402,17 @@ ghost mapping(bytes32 => bool) set_item_reverted { init_state axiom forall bytes32 i. set_item_reverted[i] == false; } -rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints, uint256[] bpss) { +rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints) { env e; bytes32 ilk; require ilk != DSR() && ilk != SSR(); require updates.length < 4; - require updates.length == bpss.length; - require idsAsUints.length == bpss.length; - // ID cannot be bytes32(0) + require updates.length == idsAsUints.length; require forall uint256 i. i < updates.length => ( + // ID cannot be bytes32(0) updates[i].id != EMPTY_BYTES32() && - updates[i].id == to_bytes32(idsAsUints[i]) && - updates[i].bps == to_mathint(bpss[i]) + updates[i].id == to_bytes32(idsAsUints[i]) ); // It is impossible for `toc` to be greater than block.timestamp require toc() <= e.block.timestamp; @@ -428,13 +426,13 @@ rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints, uint256[] bp // No updates bool revert5 = updates.length == 0; // Strictly ordered elements - bool revert6 = idsAsUints.length == 2 ? idsAsUints[0] >= idsAsUints[1] : false; - bool revert7 = idsAsUints.length == 3 ? ( + bool revert6 = updates.length == 2 ? idsAsUints[0] >= idsAsUints[1] : false; + bool revert7 = updates.length == 3 ? ( idsAsUints[0] >= idsAsUints[1] || - idsAsUints[0] >= idsAsUints[2] || idsAsUints[1] >= idsAsUints[2] ) : false; + // Check if any update would revert if (updates.length > 0) { set_item_reverted[updates[0].id] = check_item_revert(e, updates[0].id, updates[0].bps); } @@ -444,7 +442,6 @@ rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints, uint256[] bp if (updates.length > 2) { set_item_reverted[updates[2].id] = check_item_revert(e, updates[2].id, updates[2].bps); } - bool revert8 = exists uint256 i. i < updates.length && set_item_reverted[updates[i].id]; set@withrevert(e, updates); From 67d5fbc62080eee2b7a6fffdec466a8e9e8f9b98 Mon Sep 17 00:00:00 2001 From: amusingaxl <112016538+amusingaxl@users.noreply.github.com> Date: Thu, 10 Apr 2025 16:20:13 -0300 Subject: [PATCH 96/96] feat(invariants): add rules check on invariants for the rates being set --- certora/SPBEAM.spec | 69 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 66 insertions(+), 3 deletions(-) diff --git a/certora/SPBEAM.spec b/certora/SPBEAM.spec index f11a805..c851d6d 100644 --- a/certora/SPBEAM.spec +++ b/certora/SPBEAM.spec @@ -459,6 +459,10 @@ rule set_revert(SPBEAM.ParamChange[] updates, uint256[] idsAsUints) { "set should have reverted"; } +function abs_diff(mathint a, mathint b) returns mathint { + return a > b ? a - b : b - a; +} + function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { mathint min; mathint max; mathint step; min, max, step = cfgs(id); @@ -493,7 +497,7 @@ function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { actualOldBps = oldBps; } - mathint delta = bps > actualOldBps ? bps - actualOldBps : actualOldBps - bps; + mathint delta = abs_diff(bps, actualOldBps); mathint ray = conv.btor(bps); bool revertA = step == 0; @@ -510,10 +514,69 @@ function check_item_revert(env e, bytes32 id, uint256 bps) returns bool { revertA || revertB || revertC || revertD || revertE || revertF || revertG || revertH || revertI; +} + +rule set_invariants_current_within_bounds(SPBEAM.ParamChange[] updates) { + env e; + + require updates.length == 1; + bytes32 id = updates[0].id; + uint256 bps = updates[0].bps; + + bytes32 ilk; + require ilk != DSR() && ilk != SSR(); + + mathint min; mathint max; mathint step; + min, max, step = cfgs(id); + + uint256 dsrBefore = pot.dsr(); + uint256 ssrBefore = susds.ssr(); + uint256 dutyBefore; uint256 _rho; + dutyBefore, _rho = jug.ilks(ilk); + + mathint dsrBeforeBps = conv.rtob(dsrBefore); + mathint ssrBeforeBps = conv.rtob(ssrBefore); + mathint dutyBeforeBps = conv.rtob(dutyBefore); + + // Ensure the previous values are within bounds + require id == DSR() => dsrBeforeBps >= min && dsrBeforeBps <= max; + require id == SSR() => ssrBeforeBps >= min && ssrBeforeBps <= max; + require id == ilk => dutyBeforeBps >= min && dutyBeforeBps <= max; + + set(e, updates); + + uint256 dsrAfter = pot.dsr(); + uint256 ssrAfter = susds.ssr(); + uint256 dutyAfter; + dutyAfter, _rho = jug.ilks(ilk); + mathint dsrAfterBps = conv.rtob(dsrAfter); + mathint ssrAfterBps = conv.rtob(ssrAfter); + mathint dutyAfterBps = conv.rtob(dutyAfter); + + // Set cannot set the value of the rate greater than max + assert id == DSR() => dsrAfterBps <= max, "dsrAfterBps > max"; + // Set cannot set the value of the rate lower than min + assert id == DSR() => dsrAfterBps >= min, "dsrAfterBps < min"; + // Set cannot set the value of the rate to change by more than step + assert id == DSR() => abs_diff(dsrAfterBps, dsrBeforeBps) <= step, "abs(dsrAfterBps - dsrBeforeBps) > step"; + + // Set cannot set the value of the rate greater than max + assert id == SSR() => ssrAfterBps <= max, "ssrAfterBps > max"; + // Set cannot set the value of the rate lower than min + assert id == SSR() => ssrAfterBps >= min, "ssrAfterBps < min"; + // Set cannot set the value of the rate to change by more than step + assert id == SSR() => abs_diff(ssrAfterBps, ssrBeforeBps) <= step, "abs(ssrAfterBps - ssrBeforeBps) > step"; + + // Set cannot set the value of the rate greater than max + assert id == ilk => dutyAfterBps <= max, "dutyAfterBps > max"; + // Set cannot set the value of the rate lower than min + assert id == ilk => dutyAfterBps >= min, "dutyAfterBps < min"; + // Set cannot set the value of the rate to change by more than step + assert id == ilk => abs_diff(dutyAfterBps, dutyBeforeBps) <= step, "abs(dutyAfterBps - dutyBeforeBps) > step"; } -rule set_current_higher_than_max(SPBEAM.ParamChange[] updates) { +rule set_invariants_current_higher_than_max(SPBEAM.ParamChange[] updates) { env e; require updates.length == 1; @@ -550,7 +613,7 @@ rule set_current_higher_than_max(SPBEAM.ParamChange[] updates) { assert id == ilk => dutyAfter == bps_to_ray[bps] && bps >= max - step && bps <= max, "ilk duty not within bounds"; } -rule set_current_lower_than_min(SPBEAM.ParamChange[] updates) { +rule set_invariants_current_lower_than_min(SPBEAM.ParamChange[] updates) { env e; require updates.length == 1;