減法減法減法減法本文介绍本人精心设计的高精度汇编语言算法，包括以下各项算术运算及及常用初等函数值的计算方法，计算准确度可以去到小数点后 6570 位。为了缩短等候时间，本程式的精确度只有 1200位。
前言
在资源受限的嵌入式系统或微控制器（如高效能的STC32G12K128 单片机）中实现高精度数学运算，往往需要精细的记忆体管理与高效的数学模型。本文将带您深入探讨二进位高精度算法的核心架构，特别是如何透过 TERMA、TERMB、TERMC 和 TERMD 等暂存区来保存繁复的中间计算结果，并剖析平方根与圆周率等经典算法背后的数学原理。
高精度算法程式库内提供的子程序
|------------|---------------------------------------------|
| 子程序名称 | 说明 |
| ADD8 | a = a + b |
| SUB8 | a = a -- b |
| MULTIPLY | c = a * b (c < 256) |
| DIVIDE | c = a / b (b <> 0) |
| DIV16B | b = b / div (16位元除法) (div <> 0, 存入R6, R7) |
| DIV16C | c = c / div (16位元除法) (div <> 0, 存入R6, R7) |
| SQUARE | c = a * a (c < 256) |
| x_CONST | c = a * CONST (DPTR 指向ROM 内常数地址) |
| ATAN | a = Acc*atan(1/DIV_L) (DIV_L < 256) |
| ATAN2 | a = atan(a) |
| SIN | a = sin(a 度) |
| SIN_r | a = sin(a rad) |
| LN | a = ln(a) (1 <= a < 256) |
| LOG | a = log(a) (1 <= a < 256) |
| Ex | a = e^x (x > 0) |
| TENX | a = 10^x (x > 0) |
| SQRT | a = sqrt(a) |
| ROOT | a = a^(1/div) (div <> 0) |
| MOV_E | a = e |
| MOV_PI | a = pi |
| MOV_LN2 | a = ln(2) |
| MOV_LN10 | a = ln(10) |
| MOV_LOGe | a = log(e) |
| MOV_SQRT2 | a = sqrt(2) |
| COPYA2B | b = a |
| COPYA2D | d = a |
| COPYB2A | a = b |
| COPYC2A | a = c |
| COPYC2B | b = c |
| COPYD2A | a = d |
| COPYD2B | b = d |
| SWAPA_D | a <-> d |
| SHIFT_A_R | a = a / 2 |
| SHIFT_A_L | a = a * 2 |
| COMP8 | 若 a >= b 则设定 LARGEFLAG；若 a = b 则 C=1 |
| CHECK_ERR | 截断误差检查，若 a = b 则 C=1（忽略最后一个位元组） |
| CHECK_ZERO | 若 b = 0 则设定 ZEROFLAG |
核心架构：利用 TERMA 到 TERMD 储存中间结果
在处理数千位甚至上万位的高精度小数时，单一硬体暂存器已无法容纳，因此必须在记忆体（如扩展 RAM）中划分出专门的缓冲区。在许多高精度运算架构中，这四个核心暂存区扮演了分工合作的角色：
- TERMA、 TERMB、TERMC ： 存放在 xdata 区域, 最大容量有 8K。当执高精度乘法时，积的位数是乘数和被乘数的2倍，虽然此程序已预留 xdata 2*SIZE 位元组给 TERMC，其实最少只需要 SIZE + 1 位元组便已足够，因为 SIZE+1之后的数据全部舍弃不用。
- TERMD： 存放在 edata 区域, 最大容量有 4K。 除了 TERMD ，程式内的堆栈和变量也使用 edata 存贮，故此 TERMD 不可以无限量扩大。
TERMA, TERMB, TERMC 数据的存取
bash
; 存入数据
MOV DPTR, #TERMA ; TERMA 地址, 此是整数位
MOV A, #1 ; 存入的数据先放入 ACC
MOVX @DPTR, A
; 提取数据
MOV DPTR, #TERMA
MOVX A, @DPTR ; 提取的数据在ACCTERMD 数据的存取
bash
; 存入数据
MOV WR0, #TERMD+SIZE-1 ; TERMD 地址, 此是最后一个位元组
MOV A, #0FFH ; 要存入的数据
MOV @R0, R11 ; R11 即是 ACC, 只可以用 R11, 不能写 A
; 提取数据
MOV WR0, #TERMD+SIZE-1
MOV R11, @R0
MOV R7, A ; 提取的数据存入R7TERMA, TERMB, TERMC, TERMD 数据格式
- 无符号定点数
- 小数点在第一位元组之后
- 最高位是整数, 然后是分数, 最高位在前面, 最低位在后面。
|----|----|----|---|---|-----|---|--------|--------|
| 索引 | 0 | 1 | 2 | 3 | ... | | SIZE-2 | SIZE-1 |
| | 整数 | 分数 | | | | | | 分数 |
例如:
bash
; 设a = 1
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A
; 设 b = 1.5
CALL CLR_TERMB
MOV DPTR, #TERMB
MOV A, #1
MOVX @DPTR, B
INC DPTR
MOV A, #80H
MOVX @DPTR, BTERMA，TERMB，TERMC 之间的数据转移
STC32G 单片机支援双 DPTR 地址指针，进行 xdata 阵列数据的交换变得十分容易，以下是使用双DPTR 指针，把 TERMC 阵列数据抄录去 TERMA:
bash
COPYC2A:
MOV DPS,#00111000B ; 自动交换、自动递增、选择 DPTR0
MOV DPTR, #TERMC ; 来源 (DPTR0)
MOV DPTR, #TERMA ; 目标 (DPTR1)
MOV_X:
MOV WR4, #SIZE ; 16 位元 SIZE，要复制的位元组数
MOV A, R5 ; 低位元组
JZ MOV_X1
INC R4 ; 若低位元组 <> 0，高位元组 += 1
MOV_X1: MOVX A, @DPTR ; 从来源取得一个位元组
MOVX @DPTR, A ; 复制一个位元组至目标
DJNZ R5, MOV_X1
DJNZ R4, MOV_X1
MOV DPS, #00000000B ; 将 DPS 重设为预设值
RETTERMA，TERMD 之间的数据转移
TERMA 与 TERMD 位于不同的记忆段, TERMA 位于xdata 记忆段，地位在 01:0000H 至 01:0000H 之间，需要使用 MOVX @DPTR 存取数据。TERMD 位于 edata 记忆段，地位在 00:0000H 至 00:0000H 之间，使用R0-R7 间接存取数据。以下是使用DPTR 指针及R0，R1，把 TERMA 阵列数据抄录去 TERMD:
bash
COPYA2D:
MOV WR0, #TERMD ; 目标位于 edata 区域
MOV DPTR, #TERMA ; 来源位于 xdata 区域
MOV WR4, #SIZE ; 16 位元 SIZE，要复制的位元组数
MOV A, R5 ; 低位元组
JZ MOV_X2
INC R4 ; 若低位元组 <> 0，高位元组 += 1
MOV_X2: MOVX A, @DPTR ; 从来源取得一个位元组
MOV @WR0, R11 ; 放入 edata，R11 = ACC
INC DPTR ; INC DPTR
ADD WR0, #1 ; INC WR0
DJNZ R5, MOV_X2
DJNZ R4, MOV_X2
RET算法原理拆解：
加法
cpp
#include <stdint.h>
uint8_t add8(uint8_t *dest, const uint8_t *src1, const uint8_t *src2, int size) {
uint16_t carry = 0; // 使用 16-bit 来暂存当前相加的和以及产生的进位
for (int i = 0; i < size; i++) {
// 将对应位置的两个 8-bit 数值加上上一轮的进位
uint16_t sum = (uint16_t)src1[i] + (uint16_t)src2[i] + carry;
// 存入目标位元组
dest[i] = (uint8_t)(sum & 0xFF);
// 计算新进位（若和超过 255，则 carry 为 1，否则为 0）
carry = sum >> 8;
}
return (uint8_t)carry; // 回传最终溢位/进位
}減法
cpp
#include <stdint.h>
uint8_t sub8(uint8_t *dest, const uint8_t *src1, const uint8_t *src2, int size) {
int16_t borrow = 0; // 使用 16-bit 有号数来暂存减法结果与借位
for (int i = 0; i < size; i++) {
// 被减数减去减数，再减去上一轮的借位
int16_t sub = (int16_t)src1[i] - (int16_t)src2[i] - borrow;
if (sub < 0) {
dest[i] = (uint8_t)(sub + 256); // 若小于 0 代表不够减，借位并加上 256
borrow = 1; // 设定下一轮的借位为 1
} else {
dest[i] = (uint8_t)sub; //足够减，直接写入结果
borrow = 0; // 清除借位
}
}
return (uint8_t)borrow; // 回传最终的借位状态
}乘法
乘法比较繁杂，TERMA 是被乘数，TERMB 是乘数，他们的长度都是SIZE，当进行长乘法之后，积放在TERMC内，但长度变成 2*SIZE，整数有两个位元组，而分数只有 SIZE -- 2 个位元组，TERMC最后的地址是 #TERMC + 2*SIZE -- 2，因为本程式的限制，TERMC 只用一个整数位元组，即最大的数值是 255.9999999......，最小可以表示的非0数是2^-((SiZE-1)*8)，所以#TERM+SIZE 之后的位元组会被舍弃，不会参与之后的计算。如果你想改变 SIZE 的数值，除了修改相应的DP 数值外，#TERMC+SIZE+1 至 #TERMC+2*SIZE-2 之间的RAM不可用 。注意 #TERMC -- 1 位元组需要保留作乘法溢出之用，因为 256*256 = 65536 (16位元)，#TERMC -- 1 会储存16位元乘积的高8位，#TERMC 会储存16位元乘积的低8位，而分数部分由 #TERMC+1 至 #TERMC+SIZE -- 1，#TERM+SIZE 预留作截断差误之用，如大过 80H (0.5), 需要向前进一位 (四捨五入)。
長乘算法：
multiply(a0..size-1, b0...size-1) --> product 0..2\*size-1
for b_j = size-1 to 0 step -1
carry = 0
for a_i = size-1 to 0 step -1
sum = producta_i + b_j + 1 + carry + aa_i * bb_j
carry = sum / 256
producta_i + b_j + 1 = sum mod 256
productb_j = carry
return product
运用Excel 模拟高精度乘法算法
乘法
cpp
#include <stdint.h>
#include <string.h>
void multiply(uint8_t *dest, const uint8_t *src1, int n, const uint8_t *src2, int m) {
// 1. 初始化目标缓冲区，将所有位元组归零 (乘法结果需清空后再进行累积)
memset(dest, 0, n + m);
// 2. 双回圈实作直式乘法
for (int i = 0; i < n; i++) {
uint16_t carry = 0;
for (int j = 0; j < m; j++) {
// 两数相乘，加上原本目标位置的值，再加上低位传上来的进位
// 使用 uint32_t 避免 16-bit 乘法溢位 (255 * 255 = 65025，加上累积数值可能超过 16-bit)
uint32_t prod = (uint32_t)src1[i] * (uint32_t)src2[j] + dest[i + j] + carry;
// 存入当前位元组
dest[i + j] = (uint8_t)(prod & 0xFF);
// 提取高位作为下一轮的进位
carry = (uint16_t)(prod >> 8);
}
// 3. 将剩余的进位向更高位传递扩散
int k = i + m;
while (carry > 0 && k < (n + m)) {
uint32_t sum = dest[k] + carry;
dest[k] = (uint8_t)(sum & 0xFF);
carry = (uint16_t)(sum >> 8);
k++;
}
}
}除法 (高精度除低精度)
cpp
#include <stdint.h>
uint16_t div16b(uint8_t *buf, int size, uint16_t divisor) {
if (divisor == 0) {
return 0; // 错误防范：除数不能为零
}
uint32_t remainder = 0; // 使用 32-bit 暂存器来容纳跨位元组的余数与扩展计算
// 因为是 Little-endian，最高位元组在阵列尾端 (size - 1)，
// 我们必须从高位向低位进行长除法运算。
for (int i = size - 1; i >= 0; i--) {
// 将上一轮的余数乘以 256 (左移 8 位)，再加上当前位元组的数值
remainder = (remainder << 8) + buf[i];
// 计算当前位置的商
uint32_t quotient = remainder / divisor;
// 将商写回缓冲区覆盖原数
buf[i] = (uint8_t)quotient;
// 计算并更新剩余的余数，准备带入下一轮
remainder = remainder % divisor;
}
return (uint16_t)remainder; // 回传最后的 16-bit 余数
}除法 (高精度除高精度)
cpp
#include <stdint.h>
#include <string.h>
/**
* @brief 辅助函数：比较两个大数的大小
* @return 1 代表 a > b, 0 代表 a == b, -1 代表 a < b
*/
int compare(const uint8_t *a, const uint8_t *b, int size) {
for (int i = size - 1; i >= 0; i--) {
if (a[i] > b[i]) return 1;
if (a[i] < b[i]) return -1;
}
return 0;
}
/**
* @brief 辅助函数：大数整体左移 1 位 (Little-endian)
*/
void shl1(uint8_t *buf, int size) {
uint8_t carry = 0;
for (int i = 0; i < size; i++) {
uint8_t next_carry = (buf[i] >> 7) & 1;
buf[i] = (buf[i] << 1) | carry;
carry = next_carry;
}
}
/**
* @brief 辅助函数：大数就地减法 (buf = buf - subtrahend)
*/
uint8_t sub_in_place(uint8_t *buf, const uint8_t *subtrahend, int size) {
int16_t borrow = 0;
for (int i = 0; i < size; i++) {
int16_t sub = (int16_t)buf[i] - (int16_t)subtrahend[i] - borrow;
if (sub < 0) {
buf[i] = (uint8_t)(sub + 256);
borrow = 1;
} else {
buf[i] = (uint8_t)sub;
borrow = 0;
}
}
return (uint8_t)borrow;
}
void divide(uint8_t *quotient, uint8_t *remainder,
const uint8_t *dividend, const uint8_t *divisor, int size) {
// 1. 初始化商与余数为 0
memset(quotient, 0, size);
memset(remainder, 0, size);
int total_bits = size * 8;
// 2. 从被除数的最高位元开始，向低位元进行回圈
for (int i = total_bits - 1; i >= 0; i--) {
// 步骤 A：余数缓冲区整体左移 1 位，准备容纳新的一位元
shl1(remainder, size);
// 步骤 B：从被除数中取出当前回圈对应的 bit，填入余数的最低位 (Bit 0)
int byte_idx = i / 8;
int bit_idx = i % 8;
uint8_t bit = (dividend[byte_idx] >> bit_idx) & 1;
remainder[0] |= bit; // 假设采用 Little-endian（低位位元组在索引 0）
// 步骤 C：试商 ------ 检查目前的余数是否大于等于除数
if (compare(remainder, divisor, size) >= 0) {
// 若够减，余数减去除数
sub_in_place(remainder, divisor, size);
// 同时将商的对应 bit 设为 1
int q_byte_idx = i / 8;
int q_bit_idx = i % 8;
quotient[q_byte_idx] |= (1 << q_bit_idx);
}
// 若不够减，商的该 bit 维持 0，继续下一轮
}
}初等函数数值算法
高精度算法的效率不只取决于记忆体管理，更仰赖巧妙的数学公式设计以实现快速收敛：
- 平方根 (SQRT) ：牛顿截线法（牛顿迭代法）
- 原理：透过切线逼近零点的思路，迭代公式为 x(n+1) = (x / x(n) + x(n)/2。
- 特点：具有平方收敛的特性（每次迭代有效位数几乎翻倍），配合 TERMA 与 TERMB 储存分子与分母的中间除法结果，能迅速收敛到极高精度。
- 圆周率 (pi) ：马青公式（ Machin Formula ）
- 公式：pi = 16*atan(1/5) - 4*atan(1/239)。
- 特点：利用 atan 的泰勒展开式，由于数值小且收敛极快，结合工作暂存区可以精确计算出数千甚至数万位的 pi 值。
- 自然常数 (e) ：阶乘级数展开
- 公式：e = 1 + 1/1! + 1/2! + 1/3! + ...
- 迭代逻辑：利用递推关系 TERMA(n) = TERMA(n-1) + TERMB(n) 且 TERMB(n) = TERMB(n-1) / n，只需进行数千次迭代即可获得精确到小数点后数千位的好成绩。
sin, atan, ln, e^x, 10^x, a^x 使用马克劳林级数展开式计算结果：
1<x<= 2
-
-
迭代公式：
= 1
测试
本程式已经内置 25 项测试，检测程式的准确度及运算速度。
ISP烧录时, 请选用 22.1184 MHz：
测试结果：
bash
Test 1: 1 second
MULTIPLY Test: sqrt(2)*sqrt(2) = 2
2.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 2: 1 second
x_CONST test: 2*pi = 6.283185307179586476925286766559
6.283185307179586476925286766559005768394338798750211641949889184615632812572417997256069650684234135964296173026564613294187689219101164463450718816256962234900568205403877042211119289245897909860763928857621951331866892256951296467573566330542403818291297133846920697220908653296426787214520498282547449174013212631176349763041841925658508183430728735785180720022661061097640933042768293903883023218866114540731519183906184372234763865223586210237096148924759925499134703771505449782455876366023898259667346724881313286172042789892790449474381404359721887405541078434352586353504769349636935338810264001136254290527121655571542685515579218347274357442936881802449906860293099170742101584559378517847084039912224258043921728068836319627259549542619921037414422699999996745956099902119463465632192637190048918910693816605285044616506689370070523862376342020006275677505773175066416762841234355338294607196506980857510937462319125727764707575187503915563715561064342453613226003855753222391818432840397876190514402130971726557731872306763655936460603904070603705937991547245198827782499443550566958263031149714484908301391901659066233723455711778150196763509274929878638510120801855403342278019697648025
Test 3: 10 seconds
pi test: pi - const pi = 0
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 4: 3 seconds
e test: e - const e = 0
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 5: 1 second
Square Test: sqrt(2)^2 = 2
2.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 6: 3 seconds
Divison Test: 2/sqrt(2) - sqrt(2) = 0
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 7: 1 second
Divided by 0 error test
Divided by 0, denominator must > 0
Test 8: 32 seconds
Square root test: sqrt(2) - const sqrt(2) = 0
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 9: 2 minutes 16 seconds
SIN test: sin(20 deg) = 0.342020143325668733044099614682259
0.342020143325668733044099614682259580763083367514160628465048497684714763702077599564190182338525547540473533531177825503637598153952464215745455346891177149979388398818816073695563822157490166819659551390627959274195423688377658627062015009418795415104238052302584171479952757650809257850619853521120432271042907086484711854362711100112298602666522147837549004920742401703476618311248036533392613902730466411080167829215961715406686187566132904789904167725157680153267628031843230663109325525727546757297191266804256393548484487330916162044567136416079129996375428794614969413464337544677331610580242513101022026120691023629929279214615727521692899598039344139730834757581843858686907429680488441484255004449165076276932747104756629342913190448483441107043680931451927553977754483099146653053529933655581825276350310090747356689295092327247715352370721359949192517021462831065216428836744657419553999848791567436157859786707439602567296022257078336529143778700061758170127571220568051923242005353998139899487195824314420222081377399533662247274183110381603408175206661672072351379755021990678763373203179686430509123584466194175992933959514230374263663438952534766868792736482993226311901073902190823
Test 10: 8 seconds
ATAN(1/x) test: atan(1/4)= 0.2449786631268641541720824812112758
0.244978663126864154172082481211275810914144098381184067127375914667355119587642096574534157668701991363834804490037118374295485420995059976958986960614203735201277087387581655721586715982638550632052208787306750143415623363482639563697808521591073245835238135076299955568901125830266262330259915753281027606233560275361075202178574138468515160692640281335140849794410060237988463942611526552602061396037795444238072604741943917886119777288186990730107505901507422498584394142059686034142517953473222901085505491711086992836288804990169501187901302413223900986215604596838555245031846160294115555805517393415146087605909077608695391272836419928418547224248609165394407114752423629898088385199095655722081885509305931407269830477250580573532634040252936680881526648595216631239377666381701907041862228685371841224649496309332444582291854387641098359195532956476987579894850393201056049972285113673451862666076167578470901596911472621106871866784641519749360796987255462092881294676491323802367507696235607418642094568608295746622775080852621695563370364462815801617344501346062099459043084285960080331715396471234771578983205342452024990706161554477072864697745766204446023456885577421590346116021914756
Test 11: 9 minutes 55 seconds, please wait...
ATAN2(x) test: atan(0.25) = 0.2449786631268641541720824812112758
0.244978663126864154172082481211275810914144098381184067127375914667355119587642096574534157668701991363834804490037118374295485420995059976958986960614203735201277087387581655721586715982638550632052208787306750143415623363482639563697808521591073245835238135076299955568901125830266262330259915753281027606233560275361075202178574138468515160692640281335140849794410060237988463942611526552602061396037795444238072604741943917886119777288186990730107505901507422498584394142059686034142517953473222901085505491711086992836288804990169501187901302413223900986215604596838555245031846160294115555805517393415146087605909077608695391272836419928418547224248609165394407114752423629898088385199095655722081885509305931407269830477250580573532634040252936680881526648595216631239377666381701907041862228685371841224649496309332444582291854387641098359195532956476987579894850393201056049972285113673451862666076167578470901596911472621106871866784641519749360796987255462092881294676491323802367507696235607418642094568608295746622775080852621695563370364462815801617344501346062099459043084285960080331715396471234771578983205342452024990706161554477072864697745766204446023456885577421590346116021914756
Test 12: 1 second
eX_1 test: e^0 = 1
1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 13: 5 minutes 13 seconds, please wait...
eX_1 test: e^1 - const e = 0
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 14: 4 minutes 42 seconds, please wait...
eX test: e^0.5 = 1.648721270700128146848650787814163
1.648721270700128146848650787814163571653776100710148011575079311640661021194215608632776520056366643002866637756307797004671166975219609159840971452490059796929422659098403914719948464659489244896868905336418465720841066656859800088924981211712287375214972195511971609034091115619799869839960642655091754574626304483075194758258782625439931955712690076545322881476100957739788486181443265208203424170104718338591510630125661475533808252026061400972891959084050148915029440695633113776763800958480893295122472263556542654171757524108358697276592606615399767667602791615334471108288209526962579040493568545937895700765873284254090379105075427204373252220367024848354530232284647224626948615601399628457155493511823787995953393839630518930143663470973970745394992559999139325600238851775934264897003299660655233417317072150264163231538915542099197223531186607636417739109317180597584237434761501550460133383790072499112540204938297708362567407415066912334848459025310542186346129245516832438123233127623485031564566955289681541861332857851769003621451203805530287241840764741913476785908851595757628982177325764453491221265551091546786198209630592641865576143785960780695675154171944491929466741075306837
Test 15: 5 minutes 13 seconds, please wait...
eX test: e^4 = 54.5981500331442390781102612028608
54.598150033144239078110261202860878402790737038614068725826593958553662099935869481676980561944734142784115445771087427811757103941236835853906107979894150302205115283108333866620586298411962540126750188489755334308250840477874515456886427992418727851477656527785933007097606068409344747799929360428039509743222460286460125218118689333936714668821094753317230526323957636144681660862574233028959695451026671336817507109793810743369410442290704626768720963794957056227500714843872673598081888768584167109987934672455186442621035753630022701899662983779325968137362529609839556632774186444899724391662272116388047381945227627224541422950083584839367182183218742324051401224732591985727767388314976254545223875428253410499190569941582450004266542880815136541237549954667993300593549926091098107136649816873481445906989840752581023758471859698052603710393316176446965225236592565786649284055468960659189017502713247353373379352775078184197485922076667558443345855576854462340441119779411598742137946590246945533530254785386193671490223222793691782305199524480191166538594961386667784841351390301834823667745393724993265876312473228743306773047625371905954872589490342836598578562163738290052440076288889582
Test 16: 5 minutes 28 seconds, please wait...
eX test: e^250 = 3.7464546145026732603499548122029e+108
3.746454614502673260349954812202920145808830754281315919228921310748648754622741231829765091624032687183730723972999843568005881733262347252198623061102396885515462063886689862390054253730970515552812350323413757074633542293435555525636683850202111513022960766962377532151403658720825693120449575067874002250445749013085473125886281423421640603870803991479933476743648291996303181576345284990690781006234240524209456291901241087856549010204624289722902850655662506985484394693531113196472490807767611888313381848940467264220403895218813632496681733766156832496445867256340126247749891945539000591930235547352075163989852903158989769923524166101798944103273694436687470420692018673105077332324204665809231676618466323994043749890011251614742143507312294978019051152397469754157701806762379561745081372126288565037476997135449955899343531076097168240536791084851256883132120612490751598117478339000762756889617001171434245413151289097289334656515673888994864758668477379598474741182836425747872221249010850535616820375123812496633061911520542395504016964385484333551939741230692375132027116735924131868944495918572754152464304652732480861623118257582162118546470474918126652475894943906128947754620216386e+108
Test 17: 1 second
10^0 test: 10^0 = 1
1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 18: 5 minutes 28 seconds, please wait...
10^x test: 10^200.5 = 3.1622776601683793319988935444327e+200
3.162277660168379331998893544432718533719555139325216826857504852792594438639238221344248108379300295187347284152840055148548856030453880014690519596700153903344921657179259940659150153474113339484124085316929577090471576461044369257879062037808609941828371711548406328552999118596824564203326961604691314336128949791890266529543612676178781350061388186278580463683134952478031143769334671973819513185678403231241795402218308045872844614600253577579702828644029024407977896034543989163349222652612067792651676031048436697793756926155720500369894909469421850007358348844643882731109289109042348054235653403907274019786543725939641726001306990000955784463109626790694418336130181302894541703315807731626386395193793704654765220632063686587197822049312426053454111609356979828132452297000798883523759585328579251362964686511497675217123459559238039375625125369855194955325099947038843990336466165470647234999796132343403021857052187836676345789510732982875157945215771652139626324438399018484560935762602031676804240795894693424781414580651430453325889714467693111375924047050770185460439272128358941921437984326343229410069841773833560726911107125549274561841707758654442076025678341820374148294554615347e+200
Test 19: 18 minutes 12 seconds, please wait...
Cube root test: 255^(1/3) = 6.34132570538499732938067087536118
6.341325705384997329380670875361188033074693230799037894499616641465811036513699321249563821906410112557069126335833922949792477315670563597746429129965675316663866461265386762226311724790674469155245284133109802444901901638925482678587118071918271891230949182992706150548125935003625661081366933838263212402900113609319676606983392891291950399627801363051824699179755383145292409743985916459958519828447344197689309683276355831856464517841403296602649149704155595186645435668250757306009801583513746191914243098540227349416973113931645137927564612811702195979037705297020487826055992782105392690277375113210718103834401580325055518663985085563179367188276005907484607846190503967761700828341205567766643324024386225269409482839804300125001073616063533378415005259180453771990131160108804554562120433173404993496485145553806481648835199564007957370557645167904860548468060571551585050503618519897587137989635620582696253518911737807829631207768939713716716762431097595530619621156715454597538539096403494289013167038334836358966818435740325267856103569891076273748899328256072973978998499175696648774727251386301022103619451919898204634217177953754497957966411066243824744457950035398352061798890875258
Test 20: 1 second
LN(0.5) error test: LN(x) x must >= 1
ln(x) error, x must >= 1
Test 21: 12 minutes 28 seconds, please wait...
LNx test: ln(2) - const ln(2) = 0
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Test 22: 4 minutes 53 seconds, please wait...
log test: log(2)=0.30102999566398119521373889472449
0.301029995663981195213738894724493026768189881462108541310427461127108189274424509486927252118186172040684477191430995379094767881133523505999692333704695575064502964254193402661819734311602943501183902898178582617154439531861929046353884699520239310849612462540400263312594621478845847318282672683982326196542793507631317548350927138964946917785768918050790007599548087815459714585031964877626122492290829118190951498997171619860477676500067820517912557328628668342000402920509837084572224895494297562149707244659708613689609221909482761214391496528235167826492314804027746243244163311538738259303883039380633216130239051880582131915685461692905301505131926985378488418718320065753569468392971742132010905896890850585624640987218396876648539856235161277302638927878260849836681030308431415560813943617674548856663424538123733932422469594349060212044504296827460688478546115684768410643797950046596991774565754086401846407945652954434107740829399974540073721701680194889055485691069400375411689963415759297218064430381028152033923880856331986854539873935485606578428968489826139442608466327829526028766212762304341922026289121120836126005583686254899999092794878431974744338886862911771315741314322282
Test 23: 4 minutes 53 seconds, please wait...
LNx test: ln(1.125) = 0.11778303565638345453879410947052
0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070203674283679447744586647971007591486629326935414142825881648428787826281817046899394115090287498329176573822409983297969313684866976958025828691654534773835401113115048973018802627778615375864408231577477072338621742105921687742744890856434417581558788556454210170708662020697523014519411106233014302353673820947289745530581535248035663288396924475364489787617406396401217552911453314718860744608977772935780276683351285309722550251814823491538249176245676465776580973848680449714714761740116217846417023480817524679195034265269095535932192565610528613809026941899349013569270736191617087478368136325928772826594005459843604113044324679338094572471376194937145576461093859123686254664237203262003137064724198790994215392014274402483948460904730203102015304385541740326069701359150749904746613796465182401094719837261993200188418153151256269548605117865143434292533027324033734749883434060385800266079523312666171529822819090507644776480486145044131778901741104351369407914970716644325540759518027055359371367545854269453201086080716789177260924921723049504354998074996012654263150717316418
Test 24: 4 minutes 53 seconds, please wait...
LN test pwd = 0: ln(1.125) = 0.11778303565638345453879410947052
0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070203674283679447744586647971007591486629326935414142825881648428787826281817046899394115090287498329176573822409983297969313684866976958025828691654534773835401113115048973018802627778615375864408231577477072338621742105921687742744890856434417581558788556454210170708662020697523014519411106233014302353673820947289745530581535248035663288396924475364489787617406396401217552911453314718860744608977772935780276683351285309722550251814823491538249176245676465776580973848680449714714761740116217846417023480817524679195034265269095535932192565610528613809026941899349013569270736191617087478368136325928772826594005459843604113044324679338094572471376194937145576461093859123686254664237203262003137064724198790994215392014274402483948460904730203102015304385541740326069701359150749904746613796465182401094719837261993200188418153151256269548605117865143434292533027324033734749883434060385800266079523312666171529822819090507644776480486145044131778901741104351369407914970716644325540759518027055359371367545854269453201086080716789177260924921723049504354998074996012654263150717316418
Test 25: 4 minutes 53 seconds, please wait...
LN test pwd = 2: ln(4.5)=1.50407739677627407337325835238687
1.504077396776274073373258352386874841219480981285243649348708657781594964467523218141368182631045490033938577111345045751050488216102909085072932989899478859275597967538391299168440359064830246336361790518227325087052063360328661119177815178026426304880457555440788026053846400357181497118257682702856725179233181365413621964779395347367679088459950348470124820917648754724585513625296244302291620801627569696576901421266805202732624633060552233382674800854592474019194230993705266312818401355815530999620903187152828792717018792134358781775627707915877868598539031021473984186066367994188003100504956703824191845759046127279812165205613424392438861072446533373820195220412704497905709886928361712060755414412689282275703928958755625366987328295667801134519568983698254371083519426059265793371163996032721021723292518510787405524177757674546845663681409467987366914732171949309113131476855670153335928755561201907919063237674332598072872705494375041005332452564158589868703213357175408284306352341129915423254452371048201659651214072238099662118005630128738812231930997862449030648576193609245799930539572899934659422986276243130277024098242614375312991242663524259911291857547383695233568263796688462总结
高精度运算完美展现了「硬体记忆体规划」与「数学收敛美学」的结合。在单片机上进行高精度算法只是想证明一点，就是无论多么繁复的算法，STC32G12K128单片机一定可以胜任有余。各位可以选择程式库内合适的子程序, 汇入在自己的专案内，省去了不少编写代码的时间。
STC32G12K128单片机高精度算法完整代码：
bash
; STC657032G12K128 - 4K edata，8K xdata
; 内部振荡器 22.1184 MHz，波特率（Baud）115200
; Memory Model：XSmall，变数储存在 edata 远端指标 -4
; xdata 01:0000H - 01:1FFFH (8K)
$NOMOD51 ; 停用标准 8051 SFR 的内建预先定义
#include "STC32G.INC" ; 载入 STC32G 的自订标头或定义档案
;****************************************
; 二进位高精度算法（高达 6570 位数）
; 使用具备 8K xdata 的 STC32G 单晶片
;****************************************
;
; 可用的子程序：
; ----------------------
; ADD8 a = a + b
; SUB8 a = a - b
; MULTIPLY c = a * b (c < 256)
; DIVIDE c = a / b (b <> 0)
; DIV16B b = b / div (16-bit) (div <> 0，储存于 R6, R7)
; DIV16C c = c / div (16-bit) (div <> 0，储存于 R6, R7)
; SQUARE c = a * a (c < 256)
; x_CONST c = a * CONST (常数位于 DPTR 所指向的程式码区域)
; ATAN a = Acc*atan(1/DIV_L) (DIV_L < 256)
; ATAN2 a = atan(a)
; SIN a = sin(a deg)
; SIN_r a = sin(a rad)
; LN a = ln(a) (1 <= a < 256)
; LOG a = log(a) (1 <= a < 256)
; eX a = e^x (x > 0)
; TENX a = 10^x (x > 0)
; SQRT a = sqrt(a)
; ROOT a = a^(1/div) (div <> 0)
; MOV_E a = e
; MOV_PI a = pi
; MOV_LN2 a = ln(2)
; MOV_LN10 a = ln(10)
; MOV_LOGe a = log(e)
; MOV_SQRT2 a = sqrt(2)
; COPYA2B b = a
; COPYA2D d = a
; COPYB2A a = b
; COPYC2A a = c
; COPYC2B b = c
; COPYD2A a = d
; COPYD2B b = d
; SWAPA_D a <-> d
; SHIFT_A_R a = a / 2
; SHIFT_A_L a = a * 2
; COMP8 若 a >= b 则设定 LARGEFLAG；若 a = b 则 C=1
; CHECK_ERR 截断误差检查，若 a = b 则 C=1（忽略最后一个位元组）
; CHECK_ZERO 若 b = 0 则设定 ZEROFLAG
;*************************************************************************
; 位数 = SIZE * 2.408 = 1208 位数
SIZE EQU 502 ; TERM 的大小，必须为偶数，最大 2730(0AAAH)，约 6570 位数
DP EQU 600 ; DP=(SIZE-1)*1.204，要列印的位数 = DP*2
; 最大 DP 3284，列印 6568 小数位
; 最大 SIZE
;SIZE EQU 2730
;DP EQU 3284
data_seg1 segment edata
rseg data_seg1
LARGEFLAG BIT F0 ; 当 TERMA >= TERMB 时设定
ZEROFLAG BIT F0 ; 当 TERMB = 0 时设定
bit_x EQU 25H ; 用于 DIVIDE 的位元
RAM EQU 26H ; 来自 RAM 则为 1 (MULTIPLY/SQUARE)，来自 ROM 则为 0 (x_CONST)
pwd EQU 27H ; 用于 ln, e^x 的 pwd
ten_pwd EQU 28H ; 10^x 指数部分
DIV_H EQU 30H ; 除数 (高位)
DIV_L EQU 31H ; 除数 (低位)
TERMP_H EQU 32H ; 项次幂 (高位)
TERMP_L EQU 33H ; 项次幂 (低位)
Dval EQU 34H ; 用于二进位转 ASCII（高位元组）
Dval_L EQU 35H ; Dval+1（低位元组）
S1BRT BIT AUXR.0 ; 1=选择 Timer2 作为波特率产生器
T2x12 BIT AUXR.2 ; 1=1T 模式，即 CPU 时钟不分频（FOSC/1）
T2_CT BIT AUXR.3 ; 0=Timer2 是一个计时器（系统时钟计数器）
T2R BIT AUXR.4 ; 1=启用 Timer2 计数
STACK_POINTER:
DS 200 ; 在 edata 中保留 200 个位元组供堆栈指标使用
TERMD: DS SIZE ; TERMD 的起始地址（位于 edata 区域）
;=====================================================
; STC32G12K128 具备双 24 位元 DPTR 指标
; DPTR 24 位元指标地址 (DR56) = DPL(82H), DPH(83H), DPXL(84H)
; DPS (E3H) DPTR 指标选择器
; bit 0 - SEL 0=DPTR0, 1=DPTR1
; bit 3,4 - AU0, AU1 1=启用 DPTR0/DPTR1 自动递增/递减
; bit 5 - TSL 1=自动交换 SEL
; bit 6 - ID0 1=DPTR0 自动递减, 0=自动递增
; bit 7 - ID1 1=DPTR1 自动递减, 0=自动递增
;=====================================================
; 新增巨集以取代 DEC DPTR
DEC_DPTR MACRO ; DEC DPTR0 指令
DEC DPL ; DPL - 1
MOV A, DPL
XRL A, #0xFF ; 是 0xFF 吗？不能使用会影响 C 的 CJNE
JNZ $+4 ; 不是，跳过，$+4 (2 位元组程式码)
DEC DPH ; 是，DPH - 1 (2 位元组程式码)
ENDM
data_seg2 segment xdata
rseg data_seg2
TERMA: DS SIZE ; TERMA 的起始地址（位于 xdata 区域）
TERMB: DS SIZE ; TERMB 的起始地址
TERMC_OV: DS 1 ; TERMC 溢位位元组（当 a*b > 255 时设定）
TERMC: DS 2*SIZE ; TERMC 的起始地址（MULTIPLY 至少需要 1 个额外位元组）
; 完整相乘最大 2*SIZE 位元组
CSEG AT 0000H
LJMP MAIN ; FF:0000H
; int LJMP 表格置于此处
prog_seg segment code
rseg prog_seg
;=======================================================
ORG 0200H ; FF:0200H
MAIN: MOV SP, #STACK_POINTER ; 新的堆栈指标
CALL INIT_UART ; 初始化 115200 波特率
JMP TEST
;---------------------------------------------------
; 显示讯息
;---------------------------------------------------
T1_MSG: DB 13,10,13,10,"Test 1: 1 second",13,10,"MULTIPLY Test: sqrt(2)*sqrt(2) = 2",13,10,0
T2_MSG: DB 13,10,13,10,"Test 2: 1 second",13,10,"x_CONST test: 2*pi = 6.283185307179586476925286766559",13,10,0
T3_MSG: DB 13,10,13,10,"Test 3: 10 seconds",13,10,"pi test: pi - const pi = 0",13,10,0
T4_MSG: DB 13,10,13,10,"Test 4: 3 seconds",13,10,"e test: e - const e = 0",13,10,0
T5_MSG: DB 13,10,13,10,"Test 5: 1 second",13,10,"Square Test: sqrt(2)^2 = 2",13,10,0
T6_MSG: DB 13,10,13,10,"Test 6: 3 seconds",13,10,"Divison Test: 2/sqrt(2) - sqrt(2) = 0",13,10,0
T7_MSG: DB 13,10,13,10,"Test 7: 1 second",13,10,"Divided by 0 error test",13,10,0
T8_MSG: DB 13,10,13,10,"Test 8: 32 seconds",13,10,"Square root test: sqrt(2) - const sqrt(2) = 0",13,10,0
T9_MSG: DB 13,10,13,10,"Test 9: 2 minutes 16 seconds",13,10,"SIN test: sin(20 deg) = 0.342020143325668733044099614682259",13,10,0
T10_MSG: DB 13,10,13,10,"Test 10: 8 seconds",13,10,"ATAN(1/x) test: atan(1/4)= 0.2449786631268641541720824812112758",13,10,0
T11_MSG: DB 13,10,13,10,"Test 11: 9 minutes 55 seconds, please wait...", 13,10,"ATAN2(x) test: atan(0.25) = 0.2449786631268641541720824812112758",13,10,0
T12_MSG: DB 13,10,13,10,"Test 12: 1 second",13,10,"eX_1 test: e^0 = 1",13,10,0
T13_MSG: DB 13,10,13,10,"Test 13: 5 minutes 13 seconds, please wait...",13,10,"eX_1 test: e^1 - const e = 0",13,10,0
T14_MSG: DB 13,10,13,10,"Test 14: 4 minutes 42 seconds, please wait...",13,10,"eX test: e^0.5 = 1.648721270700128146848650787814163",13,10,0
T15_MSG: DB 13,10,13,10,"Test 15: 5 minutes 13 seconds, please wait...",13,10,"eX test: e^4 = 54.5981500331442390781102612028608",13,10,0
T16_MSG: DB 13,10,13,10,"Test 16: 5 minutes 28 seconds, please wait...",13,10,"eX test: e^250 = 3.7464546145026732603499548122029e+108",13,10,0
T17_MSG: DB 13,10,13,10,"Test 17: 1 second",13,10, "10^0 test: 10^0 = 1",13,10,0
T18_MSG: DB 13,10,13,10,"Test 18: 5 minutes 28 seconds, please wait...",13,10,"10^x test: 10^200.5 = 3.1622776601683793319988935444327e+200",13,10,0
T19_MSG: DB 13,10,13,10,"Test 19: 18 minutes 12 seconds, please wait...",13,10,"Cube root test: 255^(1/3) = 6.34132570538499732938067087536118",13,10,0
T20_MSG: DB 13,10,13,10,"Test 20: 1 second",13,10, "LN(0.5) error test: LN(x) x must >= 1",13,10,0
T21_MSG: DB 13,10,13,10,"Test 21: 12 minutes 28 seconds, please wait...",13,10,"LNx test: ln(2) - const ln(2) = 0",13,10,0
T22_MSG: DB 13,10,13,10,"Test 22: 4 minutes 53 seconds, please wait...",13,10,"log test: log(2)=0.30102999566398119521373889472449",13,10,0
T23_MSG: DB 13,10,13,10,"Test 23: 4 minutes 53 seconds, please wait...",13,10,"LNx test: ln(1.125) = 0.11778303565638345453879410947052",13,10,0
T24_MSG: DB 13,10,13,10,"Test 24: 4 minutes 53 seconds, please wait...",13,10,"LN test pwd = 0: ln(1.125) = 0.11778303565638345453879410947052",13,10,0
T25_MSG: DB 13,10,13,10,"Test 25: 4 minutes 53 seconds, please wait...",13,10,"LN test pwd = 2: ln(4.5)=1.50407739677627407337325835238687",13,10,0
;---------------------------------------------------
; 25 个测试（总耗时：90 分钟）
;---------------------------------------------------
TEST:
; 测试 1：MULTIPLY
; sqrt(2)*sqrt(2) = 2
MOV DPTR, #T1_MSG
CALL PRTSTR
CALL MOV_SQRT2 ; a = sqrt(2)
CALL COPYA2B ; b = sqrt(2)
CALL MULTIPLY ; 1 秒
CALL COPYC2A ; a = 2
CALL OUT_A
; 测试 2：x_CONST
; 2*pi
MOV DPTR, #T2_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #2
MOVX @DPTR, A
MOV DPTR, #pi
CALL x_CONST ; 1 秒
CALL COPYC2A
CALL OUT_A ; 2*pi = 6.283185307179586476925286766559
; 测试 3：FIND_PI
MOV DPTR, #T3_MSG
CALL PRTSTR
CALL FIND_PI ; 10 秒
CALL COPYA2B
CALL MOV_PI
CALL SUB8
CALL OUT_A ; a = 0
; 测试 4：FIND_E
MOV DPTR, #T4_MSG
CALL PRTSTR
CALL FIND_E ; 3 秒
CALL COPYA2B ; b = e
CALL MOV_E ; a = e
CALL SUB8 ; a = 0
CALL OUT_A
; 测试 5：SQUARE
; sqrt(2)^2 = 2
MOV DPTR, #T5_MSG
CALL PRTSTR
CALL MOV_SQRT2
CALL SQUARE ; 1 秒
CALL COPYC2A
CALL OUT_A ; a = 2
; 测试 6：DIVIDE
; 2/sqrt(2) = sqrt(2)
MOV DPTR, #T6_MSG
CALL PRTSTR
CALL MOV_SQRT2
MOV COPYA2B ; b = sqrt(2)
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #2
MOVX @DPTR, A ; a = 2
CALL DIVIDE ; 3 秒
CALL COPYC2A ; c = a/b = sqrt(2)
CALL SUB8 ; a = 0
CALL OUT_A
; 测试 7：测试除以 0 错误
MOV DPTR, #T7_MSG
CALL PRTSTR
CALL CLR_TERMB
CALL DIVIDE
; 测试 8：平方根
; sqrt(2)
MOV DPTR, #T8_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #2
MOVX @DPTR, A ; a = 2
CALL SQRT ; 32 秒
CALL COPYA2B ; b = sqrt(2)
CALL MOV_SQRT2 ; a = sqrt(2)
CALL SUB8 ; a = 0
CALL OUT_A
; 测试 9：SIN
; sin(20 deg)
MOV DPTR, #T9_MSG
CALL PRTSTR
MOV A, #20
CALL SIN_A ; 2 分 16 秒
CALL OUT_A ; sin(20 deg) = 0.342020143325668733044099614682259
; 测试 10：ATAN(1/x)
; 测试 1*atan(1/4)
MOV DPTR, #T10_MSG
CALL PRTSTR
MOV DIV_L, #4
MOV A, #1
CALL ATAN ; 8 秒（ATAN 较快）
CALL OUT_A ; atan(1/4)= 0.2449786631268641541720824812112758
; 测试 11：ATAN2
; 测试 atan(0.25)
MOV DPTR, #T11_MSG
CALL PRTSTR
CALL CLR_TERMB
MOV DPTR, #TERMB
MOV A, #1
MOVX @DPTR, A ; b = 1
MOV R6, #0
MOV R7, #4
CALL DIV16B ; b=1/4
CALL COPYB2A ; a=1/4
CALL ATAN2 ; 9 分 55 秒（比 ATAN 慢得多）
CALL OUT_A ; ATAN(0.25) = 0.2449786631268641541720824812112758
; 测试 12：eX_1 测试
; e^0
MOV DPTR, #T12_MSG
CALL PRTSTR
CALL CLR_TERMA
CALL eX_1
CALL OUT_A ; e^0 = 1
; 测试 13：eX_1 测试
; e^1
MOV DPTR, #T13_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A ; a = 1
CALL eX_1 ; 5 分 13 秒？？
CALL COPYA2D
CALL MOV_E
CALL COPYA2B ; b = e^1
CALL COPYD2A ; a = e^1
CALL SUB8 ; a 应为 0
CALL OUT_A
; 测试 14：eX 测试
; e^0.5
MOV DPTR, #T14_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA+1
MOV A, #80H
MOVX @DPTR, A
CALL eX ; 4 分 42 秒
CALL OUT_A ; e^0.5 = 1.648721270700128146848650787814163
; 测试 15：eX 测试
; e^4
MOV DPTR, #T15_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #4
MOVX @DPTR, A ; a = 4
CALL eX ; 5 分 13 秒
CALL OUT_A ; e^4 = 54.5981500331442390781102612028608
; 测试 16：eX 测试
; e^250
MOV DPTR, #T16_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #250
MOVX @DPTR, A
CALL eX ; 5 分 28 秒
CALL OUT_A ; e^250 = 3.7464546145026732603499548122029e+108
MOV A, #'e'
CALL SEND
MOV A, #'+'
CALL SEND
MOV A, ten_pwd ; 输出 10^ten_pwd 指数部分
CALL BIN2ASC
; 测试 17：10^x 测试
; 10^0
MOV DPTR, #T17_MSG
CALL PRTSTR
CALL CLR_TERMA
CALL TENX
CALL OUT_A ; 10^0 = 1
; 测试 18：10^x 测试
; 10^200.5
MOV DPTR, #T18_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #200
MOVX @DPTR, A
MOV A, #80H
INC DPTR
MOVX @DPTR, A
CALL TENX ; 5 分 28 秒
CALL OUT_A ; 10^200.5 = 3.1622776601683793319988935444327e+200
MOV A, #'e'
CALL SEND
MOV A, #'+'
CALL SEND
MOV A, ten_pwd ; 输出 10^ten_pwd 指数部分
CALL BIN2ASC
; 测试 19：立方根测试
; 255^(1/3)
MOV DPTR, #T19_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #255
MOVX @DPTR, A ; a = 255
MOV DIV_L, #3 ; DIV_L = 3，立方根
CALL ROOT ; 18 分 12 秒
CALL OUT_A ; 255^(1/3) = 6.34132570538499732938067087536118
; 测试 20：ln(0) 测试
; 测试 ln(0)
MOV DPTR, #T20_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #0
MOVX @DPTR, A ; a = 0
INC DPTR
MOV A, #80H ; 0.5
MOVX @DPTR, A
CALL LN ; ln(0.5) 错误
; 测试 21：LNx 测试
; ln(2)
MOV DPTR, #T21_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #2
MOVX @DPTR, A ; a = 2
CALL LNx ; 12 分 28 秒
CALL COPYA2B ; b = ln(2)
MOV MOV_LN2 ; a = ln(2)
CALL SUB8 ; a 应为 0
CALL OUT_A
; 测试 22：LOG 测试
; log(2)
MOV DPTR, #T22_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #2
MOVX @DPTR, A
CALL LOG ; 4 秒
CALL OUT_A ; log(2)=0.30102999566398119521373889472449
; 测试 23：LNx 测试
; ln(1.125)
MOV DPTR, #T23_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A
INC DPTR
MOV A, #00100000B
MOVX @DPTR, A
CALL LNx ; 4 分 53 秒
CALL OUT_A ; ln(1.125) = 0.11778303565638345453879410947052
; 测试 24：LN 测试，pwd = 0
; ln(1.125)
MOV DPTR, #T24_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A
INC DPTR
MOV A, #00100000B
MOVX @DPTR, A
CALL LN ; 4 分 53 秒
CALL OUT_A ; ln(1.125) = 0.11778303565638345453879410947052
; 测试 25：LN 测试，pwd = 2
; ln(4.5)
MOV DPTR, #T25_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #4
MOVX @DPTR, A ; a = 4
INC DPTR
MOV A, #80H ; 0.5
MOVX @DPTR, A
CALL LN ; 4 分 53 秒
CALL OUT_A ; ln(4.5)=1.50407739677627407337325835238687
DONE: SJMP $
;------------------------------------------------------------------
; 透过串口 #1 传送字元至 PC
; 波特率：115200 (22.1184 MHz) 适用于 STC32G
;------------------------------------------------------------------
INIT_UART:
MOV WTST,#0 ; 设定程式指令延时参数，赋值为 0 时速度设为最快，程式码不等待
MOV CKCON, #0 ; 提高存取 XRAM 速度，xdata 存取不增加等待
ORL P_SW2,#080H ; 扩充暂存器 (XFR) 存取致能
MOV P3M0,#0 ; 串口 1 输出/输入连接埠设为准双向口
MOV P3M1,#0
CLR T2R ; 先停止计时器，再修改设定
CLR T2_CT ; Timer2 设定为计时器模式
MOV SCON, #50H ; 串口 1 模式 1，允许串口接收资料
MOV T2L, #0D0H ; (65536 - (22118400UL / 115200+2) / 4)
MOV T2H, #0FFH ; (65536 - (22118400UL / 115200+2) / 4) >> 8
SETB S1BRT ; 选择 Timer2 作为波特率发射器
SETB T2x12 ; Timer2 设定为 1T 模式（不分频）
CLR IE2.2 ; 禁止 Timer2 中断
SETB T2R ; 启动 Timer2
CLR ES ; 不允许串口 1 中断
RET
; 将 Acc 中的字元传送至串口 #1
SEND:
MOV SBUF, A ; 将 Acc 中的字元移至串口输出缓冲区
JNB TI, $ ; 等待直到传输完成（TI 变高准位）
CLR TI ; 手动清除 TI 以供下一个位元组使用
RET ; 返回
; 从串口 #1 接收一个字元到 Acc
RECV: ; 从串口接收一个位元组
JNB RI, $ ; 等待直到接收到资料
CLR RI ; 先清除 RI
MOV A, SBUF ; 从串口输入缓冲区取得资料
RET
;-------------------------------------------------------
; PRTSTR（以 \0 结尾）
;
; 输入：DPTR = 字串地址
; 使用的暂存器：A, DPTR
;-------------------------------------------------------
PRTSTR:
CLR A ; 偏移量 = 0
MOVC A, @A+DPTR ; DPTR+A(偏移量)
JZ PRTSTR_DONE ; \0 字串结束符号
CALL SEND
INC DPTR
SJMP PRTSTR
PRTSTR_DONE:
RET
;-----------------------------------------------------------
; CLR_TERMC (xDATA)
; c = 0
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
CLR_TERMC:
MOV DPTR, #TERMC
CLR_TERM:
MOV WR4, #SIZE ; 要清除的项次数
MOV A, R5
JZ LOOP2
INC R4
MOV A, #0 ; 先清除 ACC
LOOP2: MOVX @DPTR, A ; 清除 TERMC 位元组
INC DPTR
DJNZ R5, LOOP2 ; 递减低位元组计数器
DJNZ R4, LOOP2 ; 递减高位元组计数器
RET
;-----------------------------------------------------------
; CLR_TERMA (xDATA)
; a = 0
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
CLR_TERMA:
MOV DPTR, #TERMA
SJMP CLR_TERM
;-----------------------------------------------------------
; CLR_TERMB (xDATA)
; b = 0
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
CLR_TERMB:
MOV DPTR, #TERMB
SJMP CLR_TERM
;-----------------------------------------------------------
; COPYC2A（使用双 DPTR）
;
; TERMA <-- TERMC
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
COPYC2A:
MOV DPS,#00111000B ; 自动交换、自动递增、选择 DPTR0
MOV DPTR, #TERMC ; 来源 (DPTR0)
MOV DPTR, #TERMA ; 目标 (DPTR1)
MOV_X:
MOV WR4, #SIZE ; 16 位元 SIZE，要复制的位元组数
MOV A, R5 ; 低位元组
JZ MOV_X1
INC R4 ; 若低位元组 <> 0，高位元组 += 1
MOV_X1: MOVX A, @DPTR ; 从来源取得一个位元组
MOVX @DPTR, A ; 复制一个位元组至目标
DJNZ R5, MOV_X1
DJNZ R4, MOV_X1
MOV DPS, #00000000B ; 将 DPS 重设为预设值
RET
;-----------------------------------------------------------
; COPYC2B（使用双 DPTR）
;
; TERMB <-- TERMC
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
COPYC2B:
MOV DPS,#00111000B ; 自动交换、自动递增、选择 DPTR0
MOV DPTR, #TERMC ; 来源
MOV DPTR, #TERMB ; 目标
SJMP MOV_X
;-----------------------------------------------------------
; COPYB2A（使用双 DPTR）
;
; TERMA <-- TERMB
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
COPYB2A:
MOV DPS,#00111000B ; 自动交换、自动递增、选择 DPTR0
MOV DPTR, #TERMB ; 来源
MOV DPTR, #TERMA ; 目标
SJMP MOV_X
;-----------------------------------------------------------
; COPYA2B
;
; TERMB <-- TERMA
;
; 使用的暂存器：A, R4, R5, DPTR
;-----------------------------------------------------------
COPYA2B:
MOV DPS,#00111000B ; 自动交换、自动递增、选择 DPTR0
MOV DPTR, #TERMA ; 来源
MOV DPTR, #TERMB ; 目标
SJMP MOV_X
;-----------------------------------------------------------
; COPYA2D
;
; TERMD <-- TERMA
;
; 使用的暂存器：A(R11), [R0, R1](TERMD), R4, R5, DPTR
;-----------------------------------------------------------
COPYA2D:
MOV WR0, #TERMD ; 目标位于 edata 区域
MOV DPTR, #TERMA ; 来源位于 xdata 区域
MOV WR4, #SIZE ; 16 位元 SIZE，要复制的位元组数
MOV A, R5 ; 低位元组
JZ MOV_X2
INC R4 ; 若低位元组 <> 0，高位元组 += 1
MOV_X2: MOVX A, @DPTR ; 从来源取得一个位元组
MOV @WR0, R11 ; 放入 edata，R11 = ACC
INC DPTR ; INC DPTR
ADD WR0, #1 ; INC WR0
DJNZ R5, MOV_X2
DJNZ R4, MOV_X2
RET
;-----------------------------------------------------------
; COPYD2A
;
; TERMA <-- TERMD
;
; 使用的暂存器：A(R11), [R0, R1](TERMD), R4, R5, DPTR
;-----------------------------------------------------------
COPYD2A:
MOV WR0, #TERMD ; 来源位于 edata 区域
MOV DPTR, #TERMA ; 目标位于 xdata 区域
MOV_X3:
MOV WR4, #SIZE ; 16 位元 SIZE，要复制的位元组数
MOV A, R5 ; 低位元组
JZ MOV_X4
INC R4 ; 若低位元组 <> 0，高位元组 += 1
MOV_X4: MOV R11, @WR0 ; 从 edata 取得一个位元组
MOVX @DPTR, A ; 放入 xdata TERMA
INC DPTR ; INC DPTR
ADD WR0, #1 ; INC WR0
DJNZ R5, MOV_X4
DJNZ R4, MOV_X4
RET
;-----------------------------------------------------------
; COPYD2B
;
; TERMB <-- TERMD
;
; 使用的暂存器：A(R11), [R0, R1](TERMD), R4, R5, DPTR
;-----------------------------------------------------------
COPYD2B:
MOV WR0, #TERMD ; 来源位于 edata 区域
MOV DPTR, #TERMB ; 目标位于 xdata 区域
SJMP MOV_X3
;-----------------------------------------------------------
; SWAPA_D
;
; TERMA <--> TERMD
;
; 使用的暂存器：A(R11), R0, R1, R4, R5, R6, DPTR
;-----------------------------------------------------------
SWAPA_D:
MOV WR0, #TERMD ; TERMD 地址位于 edata 区域
MOV DPTR, #TERMA ; TERMA 地址位于 xdata 区域
MOV WR4, #SIZE ; 要交换的位元组数
MOV A, R5
JZ SWAP_X2
INC R4
SWAP_X2: MOVX A, @DPTR ; 从 TERMA 取得一个位元组到 A
MOV R6, A ; R6 = TERMA 资料
MOV R11, @WR0 ; 从 TERMD 取得一个位元组到 A (Acc = TERMD 资料)
MOVX @DPTR, A ; 将 TERMD 资料写入 TERMA
MOV A, R6
MOV @WR0, R11 ; 将原本的 TERMA 资料写入 TERMD
INC DPTR ; TERMA 中的下一个位元组
ADD WR0, #1 ; TERMD 中的下一个位元组
DJNZ R5, SWAP_X2 ; 重复直到完成
DJNZ R4, SWAP_X2
RET
;-----------------------------------------------------------
; MOV_PI
;
; TERMA = PI
;
; 使用的暂存器：Acc, R4, R5, DPTR
;-----------------------------------------------------------
MOV_PI:
MOV DPS, #00111000B ; 自动交换、自动递增
MOV DPTR, #pi ; 将来源 pi 常数地址载入 DPTR0
MOV_IT:
MOV DPTR, #TERMA ; 将目标地址 TERMA 载入 DPTR1
MOV WR4, #SIZE
MOV A, R5 ; 低位元组
JZ MOV_T
INC R4 ; 若低位元组 <> 0，高位元组 + 1
MOV_T:
CLR A ; 清除 Acc
MOVC A, @A+DPTR ; 从程式码记忆体移动
MOVX @DPTR, A ; 放入 xdata
DJNZ R5, MOV_T
DJNZ R4, MOV_T
MOV DPS,#00000000B ; 还原 DPS 的预设值
RET
;-----------------------------------------------------------
; 将其他常数移动到 TERMA
; 使用的暂存器：Acc, R4, R5, DPTR
;-----------------------------------------------------------
MOV_E:
MOV DPS, #00111000B ; 自动交换、自动递增
MOV DPTR, #e ; 将来源 e 常数地址载入 DPTR0
SJMP MOV_IT
MOV_LN2:
MOV DPS, #00111000B ; 自动交换、自动递增
MOV DPTR, #ln_2 ; 将来源 ln(2) 常数地址载入 DPTR0
SJMP MOV_IT
MOV_LN10:
MOV DPS, #00111000B ; 自动交换、自动递增
MOV DPTR, #ln_10 ; 将来源 ln(10) 常数地址载入 DPTR0
SJMP MOV_IT
MOV_LOGe:
MOV DPS, #00111000B ; 自动交换、自动递增
MOV DPTR, #log_e ; 将来源 log(e) 常数地址载入 DPTR0
SJMP MOV_IT
MOV_SQRT2:
MOV DPS, #00111000B ; 自动交换、自动递增
MOV DPTR, #sqrt_2 ; 将来源 sqrt(2) 常数地址载入 DPTR0
SJMP MOV_IT
;-----------------------------------------------------------
; ADD8
; TERMA = TERMA + TERMB（使用双 DPTR）
;
; 使用的暂存器：A, B, R4, R5, DPTR
; TERMB 保持不变
;-----------------------------------------------------------
ADD8:
MOV DPTR, #TERMA+SIZE-1 ; 从最低有效位元 (lsb) 开始
XRL DPS, #01H ; DPTR1
MOV DPTR, #TERMB+SIZE-1
MOV WR4, #SIZE ; 要相加的位元组数
MOV A, R5
JZ CLR_C1
INC R4
CLR_C1: CLR C ; 相加前清除进位
NXT_DIGIT:
MOVX A, @DPTR ; 从 TERMB 取得被加数
MOV B, A
XRL DPS, #01H ; DPTR0
MOVX A, @DPTR ; 从 TERMA 取得加数
ADDC A, B ; 将两个加数与进位相加
MOVX @DPTR, A ; 将和放回 TERMA
DEC_DPTR ; DPTR0--
XRL DPS, #01H
DEC_DPTR ; DPTR1--
DJNZ R5, NXT_DIGIT ; 处理下一个位数
DJNZ R4, NXT_DIGIT
MOV DPS, #0 ; 以 DPTR0 离开
RET
;----------------------------------------------------------
; SUB8
; TERMA = TERMA - TERMB（使用双 DPTR）
;
; 使用的暂存器：A, B, R4, R5, DPTR
; TERMB 保持不变
;-----------------------------------------------------------
SUB8:
MOV DPTR, #TERMA+SIZE-1 ; 从 LSB 开始
XRL DPS, #01H ; DPTR1
MOV DPTR, #TERMB+SIZE-1
MOV WR4, #SIZE ; 要相减的位元组数
MOV A, R5
JZ CLR_C2
INC R4
CLR_C2: CLR C ; 相减前清除进位
NXT_DIG2: MOVX A, @DPTR ; 从 TERMB 取得减数
MOV B, A
XRL DPS, #01H ; DPTR0
MOVX A, @DPTR ; 从 TERMA 取得被减数
SUBB A, B ; 减去减数与借位
MOVX @DPTR, A ; 将差放回 TERMA
DEC_DPTR ; DPTR0--
XRL DPS, #01H
DEC_DPTR ; DPTR1--
DJNZ R5, NXT_DIG2 ; 处理下一个位数
DJNZ R4, NXT_DIG2
MOV DPS, #0 ; 以 DPTR0 离开
RET
;---------------------------------------------------------
; COMP8
; 比较 TERMA 与 TERMB（使用双 DPTR）
; 若 TERMA >= TERMB，设定 LARGEFLAG (F0)
; 若相等则 C=1
;
; 使用的暂存器：A, B, R4, R5, DPTR
; TERMA, TERMB 保持不变
;---------------------------------------------------------
;
COMP8:
CLR LARGEFLAG ; 清除 LARGEFLAG
MOV DPS,#00111001B ; 启用 TSL 自动交换、自动递增、选择 DPTR1
MOV DPTR, #TERMB ; TERMA 地址至 DPTR1
MOV DPTR, #TERMA ; TERMB 地址至 DPTR0
MOV WR4, #SIZE ; 要比较的位元组数
COMP8_0:
MOV A, R5
JZ CLR_C3
INC R4
CLR_C3: CLR C ; 先清除 C
COMP8_1:
MOVX A, @DPTR ; 从 TERMB 取得一个位元组
MOV B, A ; 移至 B
MOVX A, @DPTR ; 从 TERMA 取得一个位元组
SUBB A, B ; 比较
JZ CHECK_NEXT ; 相等，C=0，检查下一个位元组
JNC GREATER ; 大于，设定旗标并离开
CLR C ; 若较小则 C=0
MOV DPS,#00000000B ; 还原预设 DPS 值
RET ; 若较小则返回
CHECK_NEXT:
DJNZ R5, COMP8_1
DJNZ R4, COMP8_1
SETB C ; 若相等则 C=1
GREATER: SETB LARGEFLAG ; 若大于或等于则设定 LARGEFLAG
MOV DPS,#00000000B ; 还原预设 DPS 值
RET
;---------------------------------------------------------
; CHECK_ERR
; 检查截断误差：比较 TERMA 与 TERMB
; 若 TERMA = TERMB，设定 C=1（忽略最后一个位元组）
;
; 使用的暂存器：A, B, R4, R5, DPTR
; TERMA, TERMB 保持不变
;---------------------------------------------------------
CHECK_ERR:
CLR LARGEFLAG ; 清除 LARGEFLAG
MOV DPS,#00111001B ; 启用 TSL 自动交换、自动递增、选择 DPTR1
MOV DPTR, #TERMB ; TERMA 地址至 DPTR1
MOV DPTR, #TERMA ; TERMB 地址至 DPTR0
MOV WR4, #SIZE-1 ; 要比较的位元组数（-1 以忽略最后一个位元组）
SJMP COMP8_0
;----------------------------------------------------------
; CHECK_ZERO
; 若 TERMB = 0 则设定 ZEROFLAG
;
; 使用的暂存器：A, R4, R5, DPTR
; TERMB 保持不变
;-----------------------------------------------------------
CHECK_ZERO:
CLR ZEROFLAG ; 先清除 ZEROFLAG
MOV DPTR, #TERMB
MOV WR4, #SIZE
MOV A, R5
JZ NXT_DIG3
INC R4
NXT_DIG3: MOVX A, @DPTR ; 从 TERMB 取得位数
JNZ NXT_DIG4 ; 若非零则离开
INC DPTR
DJNZ R5,NXT_DIG3
DJNZ R4,NXT_DIG3 ; 处理下一个位数
SETB ZEROFLAG ; 若全部为零则离开并设定 ZEROFLAG
NXT_DIG4: RET
;----------------------------------------------------------
; MULTIPLY
; TERMC = TERMA * TERMB
;
; 使用的暂存器：A, B, R1(b[b_j]), [R2, R3](b_j), [R4, R5](a_i),
; R6(进位), R7, DPTR
;
; RAM=1 表示 TERMB 来自 RAM，RAM=0 表示 TERMB 来自 ROM
;
; multiply(a[0..size-1], b[0...size-1]) --> product [0..2*size-1]
;
; for b_j = size-1 to 0 step -1
; carry = 0
; for a_i = size-1 to 0 step -1
; sum = product[a_i + b_j + 1] + carry + a[a_i] * b[b_j]
; carry = sum / 256
; product[a_i + b_j + 1] = sum mod 256
; product[b_j] = carry
; return product
;
; TERMA, TERMB 保持不变。
;
; 耗时：1 秒
;-----------------------------------------------------------
MULTIPLY:
MOV DPTR, #TERMB+SIZE-1 ; DPTR0 用于 TERMB 地址
SQUARE1: ; TERMC = TERMA * TERMA (进入点)
MOV RAM, #1 ; RAM=1 表示 RAM 来源
MULTIPLY1:
MOV WR2, #SIZE ; b[b_i] 大小
;----------------------------------------
; 取得 b[b_j]，RAM=1 则从 RAM，否则从 ROM
; ----------------------------------------------------
FOR_B: MOV A, RAM ; 来自 RAM 还是 ROM？
JNZ FROM_RAM
; 从 ROM 提取
MOV A, #0
MOVC A, @A+DPTR
SJMP STORE_b_j
FROM_RAM:
MOVX A, @DPTR ; 取得 b[b_i] 到 A (TERMB 的 DPTR0)
;-----------------------------------------------------
STORE_b_j:
MOV R1, A ; 储存至 R1
PUSH DPL
PUSH DPH ; 将 DPTR0 (TERMB 地址) 压入堆栈
XRL DPS, #01H ; 切换至 DPTR1
MOV DPTR, #TERMA+SIZE-1 ; TERMA 的 DPTR1
MOV R6, #0 ; carry = 0
MOV WR4, #SIZE ; a[a_i] 大小
; 计算积 product 的地址
XRL DPS, #01H ; TERMC 的 DPTR0
MOV DPTR, #TERMC ; TERMC 基础地址
; 积的地址 proudct = TERMC+[R2,R3]+[R4,R5]-2
MOV A, R3
ADD A, R5
JNC DEC_0
INC DPH
DEC_0: ADD A, DPL ; + TERMC 基础地址
MOV DPL, A
JNC DEC_1
INC DPH
DEC_1: MOV DPL, A
MOV A, DPH
ADD A, R2
ADD A, R4 ;假设 DPH 中无进位 (xdata 地址 01:0000 - 01:1FFF)
MOV DPH, A
DEC_DPTR ; -2，调整计数器与指标之间的差值
DEC_DPTR ; 例如：第 1 次执行，SIZE+SIZE=2*SIZE，
; 但 TERMC 中的最后一个位元组是 2*SIZE-2
; --- 内回圈 ----
XRL DPS, #01H ; 切换回 DPTR1 (TERMA 地址)
FOR_A: MOV B, R1 ; B = 来自 R1 的 b[b_j]
MOVX A, @DPTR ; A = a[a_i]
MUL AB ; BA = A * B
ADD A, R6 ; carry + a[a_i] * b[b_j]
JNC MULT1
INC B ; 进位 carry + 1
MULT1: MOV R7, A ; R7 = C + a[a_i] * b[b_j]
XRL DPS, #01H ; TERMC 地址 DPTR0
MOVX A, @DPTR ; 取得product
ADD A, R7 ; A = (product + carry + a[a_i] * b[b_j]) mod 256
MOVX @DPTR, A ; 将积 product 放回
JNC MULT2
INC B ; 进位 carry + 1
MULT2: MOV R6, B ; 进位 carry = (product + carry + a[a_i] * b[b_i])/ 256
MULT3: DEC_DPTR ; TERMC 地址 - 1
XRL DPS, #01H ; TERMA 地址 DPTR1
DEC_DPTR ; TERMA 地址 - 1
; --- 内回圈 ----
MOV A, R5
ADD A, #0FFH ; 等同于 DEC R5，但会更新进位旗标 (C)
MOV R5, A
MOV A, R4
ADDC A, #0FFH ; 若低位元组发生借位则减 1
MOV R4, A
; 检查 R4 与 R5 是否皆为零
ORL A, R5
JNZ FOR_A ; 仍在 DPTR1 资料流中
; FOR_A 结束
XRL DPS, #01H ; DPTR0 (TERMC 地址)
; 将最终进位储存至 product[b_j]
MOV A, R6 ; 取得最后的进位 carry
MOVX @DPTR, A ; product[b_j] = carry
; --- 外回圈 ---
POP DPH
POP DPL ; 还原 TERMB 地址
DEC_DPTR ; TERMB 地址 - 1 (DPTR0)
; TERMB
MOV A, R3
ADD A, #0FFH ; 等同于 DEC R3，但会更新进位旗标 (C)
MOV R3, A
MOV A, R2
ADDC A, #0FFH ; 若低位元组发生借位则减 1
MOV R2, A
; 检查 R2 与 R3 是否皆为零
ORL A, R3
JNZ JMP_FOR_B ; 保持在 DPTR0 资料流中
; --- 调整 product 最后一个位数 ---
; RET ; 若不需要调整则 RET
adj0:
MOV DPTR, #TERMC + SIZE
MOVX A, @DPTR
ANL A, #80H ; 截断误差检查 (bit 7 >= 0.5)
JNZ adj1 ; 若非零则四舍五入进位
adj_done:
RET
adj1:
DEC_DPTR ; TERMC 地址 - 1
SETB C ; C=1 (来自 TERMC+SIZE 位元组的进位)
adj2: MOVX A, @DPTR
ADDC A, #0
MOVX @DPTR, A
JNC adj_done
DEC_DPTR ; 上至 #TERMC-1 (溢位错误)
SJMP adj2
JMP_FOR_B:
JMP FOR_B
;----------------------------------------------------------
; SQUARE
; TERMC = TERMA * TERMA
;
; 使用的暂存器：A, B, R1(a[a_j]), [R2, R3](a_j), [R4, R5](a_i),
; R6(进位), R7, DPTR
;
; TERMA 保持不变
; 耗时：1 秒
;-----------------------------------------------------------
SQUARE:
MOV DPTR, #TERMA+SIZE-1 ; TERMA 地址的 DPTR0
JMP SQUARE1
;----------------------------------------------------------
; x_CONST
; TERMC = TERMA * CONSTANT
;
; 使用的暂存器：A, B, R1(b[b_j]), [R2, R3](b_j), [R4, R5](a_i),
; R6(进位), R7, DPTR
;
; TERMA 保持不变
; 耗时：1 秒
;-----------------------------------------------------------
x_CONST:
; DPTR 指向 CONSTANT 地址
; DPTR = #CONSTANT + SIZE - 1
MOV A, DPL
ADD A, #LOW (SIZE - 1)
MOV DPL, A
MOV A, DPH
ADDC A, #HIGH (SIZE - 1)
MOV DPH, A
MOV RAM, #0 ; RAM = 0 表示 ROM 来源
JMP MULTIPLY1
;------------------------------------------------------------
; DIV16C
;
; TERMC = TERMC / DIV (16-BIT)
;
; 使用的暂存器：A, R0(商), [R1, R2](余数), R3(位元计数器), [R4, R5](位元组计数器),
; DPTR, [R6, R7](DIV)
;------------------------------------------------------------
DIV16C: MOV DPTR, #TERMC
SJMP DIV16
;------------------------------------------------------------
; DIV16B
;
; TERMB = TERMB / DIV (16-BIT)
;
; 使用的暂存器：A, R0(商), [R1, R2](余数), R3(位元计数器), [R4, R5](位元组计数器),
; DPTR, [R6, R7](DIV)
; 耗时：秒
;------------------------------------------------------------
DIV16B:
MOV DPTR, #TERMB ; TERMB 从此处开始
DIV16:
MOV WR4, #SIZE ; 项次数
MOV A, R5
JZ SKIP_00
INC R4
SKIP_00: MOVX A, @DPTR ; 跳过前导 0
JNZ DIV16_1
INC DPTR
DJNZ R5, SKIP_00
DJNZ R4, SKIP_00
SETB ZEROFLAG ; 若全为零则设定 ZEROFLAG
RET ; 被除数全为零，返回
DIV16_1: MOV R2, #0 ; 余数低位初始化为 0
MOV R1, #0 ; 余数高位初始化为 0
NXT_BYTE:
MOV R3, #8 ; 每个 Byte 有 8 个 Bits
MOVX A, @DPTR ; 从外部 SRAM 读取目前 Byte
MOV R0, A ; 存入 R0，同时也是商=0
NXT_BIT:
; 余数 [R1, R2] 与目前位元进行联合左移
MOV A, R0
ADD A, R0 ; R0 左移一位，最高位进入 C
MOV R0, A
MOV A, R2
RLC A ; 余数低位左移，带入 C
MOV R2, A
MOV A, R1
RLC A ; 余数高位左移，带入 C
MOV R1, A
JC DO_SUB ; C=1 代表溢位，一定够减，直接去减！
; C=0 时，进行试探性相减 [R1, R2] - [R6, R7]
CLR C
MOV A, R2
SUBB A, R7
MOV A, R1
SUBB A, R6
JC NO_SUB ; 若 C=1，代表余数 < 除数，不能减
DO_SUB: ; 够减：更新真实余数，并将商的该位设为 1
CLR C
MOV A, R2
SUBB A, R7
MOV R2, A ; 更新低位余数
MOV A, R1
SUBB A, R6
MOV R1, A ; 更新高位余数
MOV A, R0 ; 商 --> A
ORL A, #01H ; 更新商，将刚刚左移空出的最低位补 1
MOV R0, A ; 商暂存在 R0
NO_SUB: ; 不够减：保持原余数，商的该位维持 0
DJNZ R3, NXT_BIT ; 8 个位元尚未跑完则继续
MOV A, R0 ; 计算好的商
MOVX @DPTR, A ; 写回外部 SRAM
INC DPTR ; 指标移至下一个位元组
DJNZ R5, NXT_BYTE ; 下一个位元组
DJNZ R4, NXT_BYTE
RET
;-----------------------------------------------------------------------
; DIVIDE:
;
; c = TERMA / TERMB
;
; 长除法演算法：
; if D = 0 then set overflow error, end
; Q := 0 -- 初始化商与余数为零
; R := 0
; for i := n - 1 .. 0 do -- 这里 n 是分子 (N) 中的位元数
; R := R << 1 -- R 左移 1 位元
; R(0) := N(i) -- 设定 R 的 LSB 等于分子的第 i 位元
; if R >= D then -- 如果余数 (R) >= 分母 (D)
; R := R - D
; Q(i) := 1
; end
; end
;
; 要求：分子 <= 255
; 分母 <> 0
; 使用的暂存器：
; A, B, R0(商), [R4, R5](计数器), DPTR
; TERMB 保持不变
;
; TERMA 被覆盖，TERMB 保持不变
; 耗时：3 秒
;-----------------------------------------------------------------------
DIVIDE:
CALL CHECK_ZERO ; b = 0?
JNB ZEROFLAG, CONTD ; 不是，继续
; b=0，溢位错误
DIVIDE_ERR:
MOV DPTR, #DIV0 ; 列印 "Divided by 0" 错误
CALL PRTSTR
RET
CONTD: CALL CLR_TERMC ; 清除 TERMC
CALL COMP8 ; 分子 = 分母？
JNC CONTD1 ; 先检查 C
MOV DPTR, #TERMC ; 若分子 = 分母则 C = 1
MOV A, #1
MOVX @DPTR, A ; 返回且商 = 1
RET
CONTD1: JNB LARGEFLAG, CONTD2; 分子 > 分母？不是，跳过
; 是，若分子 > 分母则重复相减
;- - - 分子 > 分母
MOV R0, #0 ; 商 = 0
QPLUS1: INC R0 ; 商+1
CALL SUB8 ; n = n - d
CALL COMP8
JB LARGEFLAG, QPLUS1
MOV DPTR, #TERMC ; 商的整数部分
MOV A, R0
MOVX @DPTR, A ; 更新商
;- - - 分子 < 分母
CONTD2:
MOV DPTR, #TERMC+1 ; 商的小数部分
;---------- 除法主回圈 ---------------------------------------
LOOP3:
MOV bit_x, #80H ; 从第 7 位元开始
MOV R0, #0 ; 初始商 = 0
; 将 TERMC DPTR 压入堆栈
PUSH DPH
PUSH DPL
LOOP4: CALL SHIFT_A_L ; R << 1，C=余数的 MSB
JC LARGER ; C=1，余数 > 分母
CALL COMP8 ; C=0，检查余数 >= 分母？
JNB LARGEFLAG, NEXT_Q ; 余数 < 分母，商=0
LARGER: CALL SUB8 ; 余数 = 余数 - 分母
MOV A, R0
ADD A, bit_x ; 商 = 1
MOV R0, A ; 更新商
NEXT_Q: MOV A, bit_x ; 移至商的下一个位元
CLR C
RRC A ; 下一个位元
MOV bit_x, A
JNC LOOP4 ; 在同一个位元组内
; 位元组结束，还原 DPTR 并更新 TERMC 中的商
POP DPL
POP DPH
MOV A, R0
MOVX @DPTR, A ; 更新 TERMC 中的商
INC DPTR ; TERMC DPTR + 1
MOV A, DPL
CJNE A, #LOW (TERMC+SIZE), LOOP3 ; TERMC 结束？
MOV A, DPH
CJNE A, #HIGH (TERMC+SIZE), LOOP3
RET ; 是，返回
;-------------------------------------------------- -----------------
; SHIFT_A_R
;
; TERMA >>= 1
;
; 使用的暂存器：A, R4, R5, DPTR
;-------------------------------------------------------------------
SHIFT_A_R:
MOV DPTR, #TERMA
MOV WR4, #SIZE
MOV A, R5
JZ SHIFT_R
INC R4
SHIFT_R:
CLR C ; 第一次位移前 C=0
SHIFT_R1: MOVX A, @DPTR
RRC A ; An = An+1, A7=C, C=A0
MOVX @DPTR, A
INC DPTR
DJNZ R5, SHIFT_R1
DJNZ R4, SHIFT_R1
RET
;--------------------------------------------------------------------
; SHIFT_A_L
;
; TERMA <<= 1
;
; 使用的暂存器：A, R4, R5, DPTR
;--------------------------------------------------------------------
SHIFT_A_L:
MOV DPTR, #TERMA+SIZE-1
MOV WR4, #SIZE
MOV A, R5
JZ SHIFT_L
INC R4
SHIFT_L:
CLR C ; 第一次位移前 C=0
SHIFT_L1:
MOVX A, @DPTR
RLC A ; An+1 = An, A0 = C, C = A7
MOVX @DPTR, A
DEC_DPTR
DJNZ R5, SHIFT_L1
DJNZ R4, SHIFT_L1
RET
;--------------------------------------------------------------------
; ATAN（使用欧拉于 1748 年提出的泰勒级数）
;
; TERMA = Acc*ATAN(1/div) 2 <= div < 256 储存于 DIV_L
; atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...
; arcsin (x) = atan(x/sqrt(1-x^2))
;
; TERMC = TERMC / div^2
; TERMB = TERMC / n (n = 1, 3, 5, 7,...)
; TERMA = TERMA +/- TERMB (3, 7, 11 - ; 5, 9, 13 +)
;
; TERMB, TERMC 被覆盖
; 耗时：9 秒 (div = 4)
;--------------------------------------------------------------------
ATAN:
MOV R0, A ; 保留 Acc
CALL CLR_TERMC
MOV DPTR, #TERMC
MOV A, R0 ; c = Acc
MOVX @DPTR, A
; 第一个除数是 div
MOV R6, #0
MOV R7, DIV_L
CALL DIV16C ; c = Acc/div
CALL COPYC2A ; a = Acc/div
; 下一个除数是 div^2
MOV A, DIV_L
MOV B, A
MUL AB
MOV DIV_L, A ; div^2 的低位元组
MOV DIV_H, B ; div^2 的高位元组
; 下一个 n 是 3
MOV TERMP_H, #0 ; 下一个除数 div = 3
MOV TERMP_L, #3
ATAN_LOOP:
MOV R6, DIV_H
MOV R7, DIV_L
CALL DIV16C ; TERMC / div^2
CALL COPYC2B
MOV R6, TERMP_H
MOV R7, TERMP_L
CALL DIV16B ; TERMB = TERMC / div^2 / n
CALL CHECK_ZERO
JB ZEROFLAG, ATAN_DONE
MOV A, TERMP_L
RRC A
RRC A
JC ATAN_SUB ; 3, 7, 11 -
; 偶数 +
CALL ADD8 ; 5, 9, 13 +
SJMP ATAN_LOOP2
; 奇数 -
ATAN_SUB: CALL SUB8
ATAN_LOOP2:
MOV A, TERMP_L
ADD A, #2 ; div += 2
MOV TERMP_L, A
JNC ATAN_LOOP
INC TERMP_H
SJMP ATAN_LOOP
ATAN_DONE:RET
;--------------------------------------------------------------------
; ATAN2 (x 储存在 TERMA)
;
; atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ... (0<= x <= 0.5)
; atan(x) = 2*atan(x/(1+sqrt(1+x*x)) (x > 0.5)
; arcsin(x) = atan(x/sqrt(1-x^2))
;
; TERMC = TERMC / x^2
; TERMB = TERMC / n (n = 1, 3, 5, 7,...)
; TERMA = TERMA +/- TERMB (3, 7, 11 - ; 5, 9, 13 +)
;
; TERMB, TERMC, TERMD 被覆盖，TERMD = x^2
; 耗时：9 分 55 秒 (x = 1/4)
;--------------------------------------------------------------------
ATAN2:
CALL COPYA2D ; d = x = sum
CALL COPYA2B ; b = x (目前项)
CALL SQUARE ; TERMC = x^2 (乘数)
CALL COPYC2A ; TERMA = x^2 (TERMA 交替保存 x^2/sum)
MOV TERMP_H, #0
MOV TERMP_L, #3 ; 下一个除数 n = 3
ATAN2_LOOP:
CALL MULTIPLY ; TERMC = x^n (下一个幂次)
CALL COPYC2B
MOV R6, TERMP_H
MOV R7, TERMP_L
CALL DIV16B ; TERMB = x^n / n
CALL SWAPA_D ; a = sum, d=x^2
CALL CHECK_ZERO
JB ZEROFLAG, ATAN2_DONE
MOV A, TERMP_L
RRC A
RRC A
JC ATAN2_SUB ; 3, 7, 11 -
; 偶数 +
CALL ADD8 ; 5, 9, 13 +
SJMP ATAN2_SWAP
; 奇数 -
ATAN2_SUB:
CALL SUB8
ATAN2_SWAP:
CALL SWAPA_D ; a = x^2, d=新 sum
CALL COPYC2B ; TERMB = 新 term
MOV A, TERMP_L
ADD A, #2 ; n += 2
MOV TERMP_L, A
JNC ATAN2_LOOP
INC TERMP_H
SJMP ATAN2_LOOP
ATAN2_DONE:
RET
;---------------------------------------------------------------
; 使用牛顿-拉夫森方法 (1690) 寻找 sqrt(x)
; a(0) = 1 或 x/2
; a(n) = [a(n-1) + x/a(n-1)]/2 n=1, 2, 3,....
;
; TERMB, TERMC 被覆盖，TERMD = x
; 耗时：32 秒
;---------------------------------------------------------------
SQRT: CALL COPYA2D ; d = x
; 设定 sqrt 的初始值
MOV DPTR, #TERMA
MOVX A, @DPTR
CLR C
SUBB A, #2
JC SQRT_X ; x < 2
CALL SHIFT_A_R ; x/2 作为 sqrt 的初始值
SQRT_X: CALL SWAPA_D ; x
CALL COPYD2B ; b = 之前的 sqrt 值
CALL COPYA2D ; 将 x 储存在 d
CALL DIVIDE ; c = x/b
CALL COPYC2A ; a = 新的 sqrt 值
CALL ADD8 ; a = a + b
CALL SHIFT_A_R ; a = a / 2，平均值
CALL CHECK_ERR ; 截断误差检查，a=b?
JNC SQRT_X ; 不是，C=0，继续
RET ; 是，C=1，完成
;---------------------------------------------------------------
; 使用马青公式 (1706) 寻找 pi
; TERMA = pi = 16*atan(1/5) - 4*atan(1/239)
;
; TERMB, TERMC, TERMD 被覆盖
; 耗时：10 秒
;---------------------------------------------------------------
FIND_PI:
MOV DIV_L, #239
MOV A, #4
CALL ATAN ; 4*atan(1/239)
CALL COPYA2D ; 储存至 TERMD
MOV DIV_L, #5
MOV A, #16
CALL ATAN ; 16*atan(1/5)
CALL COPYD2B
CALL SUB8 ; 16*atan(1/5) - 4*atan(1/239)
RET
;---------------------------------------------------------------
; 使用泰勒级数 (1748) 寻找 e
; TERMA = e = 1 + 1/1! + 1/2! + 1/3! + ... + 1/2252!
;
; TERMB 被覆盖
; 耗时：3 秒
;---------------------------------------------------------------
FIND_E:
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A ; a = 1
CALL COPYA2B ; b = 1
MOV DPTR, #TERMA
MOV A, #2
MOVX @DPTR, A ; a = 2
MOV R7, #2
MOV R6, #0 ; n = 2
FIND_E1: CALL DIV16B ; b = 1 / n!
CALL CHECK_ZERO ; b = 0?
JB ZEROFLAG, E_DONE
CALL ADD8 ; a = a + 1 / n!
INC R7 ; n = n + 1
MOV A, R7
JNZ FIND_E1
INC R6
SJMP FIND_E1
E_DONE:
RET
;---------------------------------------------------
; 使用泰勒级数 (1748) 寻找 sin(a deg)：
; 首先将 a deg 转换为 x rad
; x rad = a * pi / 180 弧度
; sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...
; cos(x) = sin(pi/2 - x)
;
; 假设标准任意精度记忆体区块：
; TERMA / TERMD = x^2 或 sum
; TERMB = TERMA * TERMB / n!
; TERMA = TERMA +/- TERMB
;
; TERMB, TERMC, TERMD 被覆盖
; 耗时：2 分 16 秒
;---------------------------------------------------
SIN_A: MOV R0, A ; 将 Acc 度数储存到 R0
CALL CLR_TERMA ; 清除 a
MOV DPTR, #TERMA
MOV A, R0 ; Acc 度数
MOVX @DPTR, A ; a = Acc 度数
SIN: ; sin(TERMA deg)
; 将度数转换为弧度：x = Acc * pi / 180
CALL SWAPA_D ; d = x 度数
MOV MOV_PI ; a = pi
CALL COPYA2B ; b = pi
CALL SWAPA_D
CALL MULTIPLY ; c = x * pi
CALL COPYC2B ; b = x * pi
MOV R6, #0
MOV R7, #180 ; 除数 180
CALL DIV16B ; b = x (rad)
; 初始化级数变数
CALL COPYB2A ; a = sum = x (第一项)
; 为后续更高幂次的项准备 x^2 (x * x)
SIN_r: ; sin (TERMA rad)
CALL COPYA2B ; b = x 补偿 SIN_r 进入点
CALL SQUARE ; c = x^2
CALL SWAPA_D ; 将 sum 储存在 d
CALL COPYC2A ; a = x^2
; 初始化阶乘除数
MOV DIV_L, #1 ; 初始化 div (第一次执行时会变成 2)
MOV DIV_H, #0
LOOP_S: ; 将目前项乘以 x^2 以取得下一个幂次 (例如：x -> x^3 -> x^5)
CALL MULTIPLY ; c = a * b = x^3 --> x^5
INC DIV_L
MOV A, DIV_L
JNZ DIV_1
INC DIV_H
DIV_1: MOV R6, DIV_H
MOV R7, DIV_L
CALL DIV16C ; /2, /4, /6, ...
INC DIV_L
MOV A, DIV_L
JNZ DIV_2
INC DIV_H
DIV_2: MOV R6, DIV_H
MOV R7, DIV_L
CALL DIV16C ; /3, /5, /7 ... --> c = x^(2k+1) /(2k+1)!
CALL SWAPA_D ; a = sum
CALL CHECK_ZERO ; c = 0?
JB ZEROFLAG, SIN_DONE
CALL COPYC2B ; b = 新 term
MOV A, DIV_L
RRC A
RRC A
JC SIN_SUB ; a = a +/- b
; 偶数 +
CALL ADD8 ; 5, 9, 13 +
SJMP SIN_SWAP
SIN_SUB: CALL SUB8 ; 3, 7, 11 -
SIN_SWAP: CALL SWAPA_D ; 将 sum 储存在 d
SJMP LOOP_S
SIN_DONE: RET
;---------------------------------------------------------------
; 寻找 log(x) log(x) = ln(x) * log(e) (1 <= x)
;
; TERMB, TERMC, TERMD 被覆盖
; 耗时：12 分 28 秒
;---------------------------------------------------------------
LOG:
CALL LN
MOV DPTR, #log_e ; log(e) 常数地址至 DPTR
CALL x_CONST ; ln(x)*log(e)
CALL COPYC2A ; a=log(x)
RET
;---------------------------------------------------------------
; 使用麦克劳林展开式寻找 ln(x) (1 <= x < 2)
; 透过使用转换 t = (x-1)/(x+1)，
; ln(x) = 2 ( t + t^3/3 + t^5/5 + t^7/7 + ...)
;
; 对于 x >= 2，使用 ln(a*2^n) = ln(a)+n*ln(2)
; log(x) = ln(x) * log(e)
;
; TERMB, TERMC, TERMD 被覆盖
; 耗时：12 分 28 秒 (ln(2))
;---------------------------------------------------------------
LN: ; 对于 x >= 2
; 寻找 n 使得 x = a*2^n
; ln(x) = ln(a)+n*ln(2)
; 重复将 x 除以 2 直到 1 <= x < 2
MOV pwd, #0 ; 开始 n = 0
SHIFT_X: MOV DPTR, #TERMA ; 从 TERMA 取得整数位元组
MOVX A, @DPTR
JZ LN_ERR
CJNE A, #1, SHIFT_IT
; A = 1，位移结束
CALL LNx ; ln(a) 其中 1 <= a < 2
MOV A, pwd ; 检查 pwd
JNZ PWD_MUL ; n>0，执行相乘
RET ; pwd=0, ln(x) = ln(a)
LN_ERR:
MOV DPTR, #LN0 ; 列印 "ln(x) error, x must >= 1" 错误
CALL PRTSTR
RET
SHIFT_IT: CALL SHIFT_A_R ; x/2
INC pwd ; n+1
SJMP SHIFT_X ; 重复
PWD_MUL: ; n>0, ln(x) = ln(a)+n*ln(2)
CALL COPYA2B ; b = ln(a)
; n*ln(2)
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, pwd
MOVX @DPTR, A ; a = n
MOV DPTR, #ln_2 ; ln_2 常数地址至 DPTR
CALL x_CONST ; n*ln(2)
CALL COPYC2A ; a=n*ln(2)
; ln(a)+n*ln(2)
CALL ADD8 ; ln(a)+n*ln(2)
RET
LNx: ; 对于 1<= x < 2
CALL COPYA2B ; b = x
; x - 1
MOV DPTR, #TERMA
MOVX A, @DPTR
DEC A
MOVX @DPTR, A ; x - 1
MOV DPTR, #TERMB
MOVX A, @DPTR
INC A
MOVX @DPTR, A ; x + 1
CALL DIVIDE ; TERMC = t = (x-1)/(x+1)
; t = (x - 1) / (x + 1)
CALL COPYC2A ; a = t
CALL COPYA2D ; d = t (总和累加器从 t 开始)
CALL COPYA2B ; b = t (目前项)
CALL SQUARE ; TERMC = t^2 (乘数)
CALL COPYC2A ; TERMA = t^2 (TERMA 交替保存 t^2/sum)
MOV TERMP_H, #0
MOV TERMP_L, #3 ; 下一个除数 n = 3
LNx_LOOP:
CALL MULTIPLY ; TERMC = t^n (下一个幂次)
CALL COPYC2B
MOV R6, TERMP_H
MOV R7, TERMP_L
CALL DIV16B ; TERMB = t^n / n
CALL SWAPA_D ; a = sum, d=t^2
CALL CHECK_ZERO
JB ZEROFLAG, LNx_DONE
CALL ADD8 ; sum = sum + term
CALL SWAPA_D ; a = t^2, d=新 sum
CALL COPYC2B ; TERMB = 新 term
MOV A, TERMP_L
ADD A, #2 ; n += 2
MOV TERMP_L, A
JNC LNx_LOOP
INC TERMP_H
SJMP LNx_LOOP
LNx_DONE:
CALL SHIFT_A_L ; ln(x) = 2*sum
RET
;---------------------------------------------------------------
; 寻找 a^(1/x)
; a^(1/x) = e^(ln(a)/x)
;
; 输入： TERMA = a (底数)，DIV_L = x
;
; 被覆盖的暂存器：TERMB, TERMC, TERMD
; 耗时：18 分 12 秒
;---------------------------------------------------------------
ROOT:
; 在 TERMA 中计算 ln(a)
CALL LN ; TERMA = ln(a)
CALL COPYA2B
MOV R6, #0
MOV R7, DIV_L ; x
CALL DIV16B ; TERMB = ln(a)/x
CALL COPYB2A ; TERMA = ln(a)/x
CALL eX ; TERMA = e^(ln(a)/x)
RET
;---------------------------------------------------------------
; 寻找 10^x
; 10^x = 10^(I+F) = 10^I * 10^F = 10^I * e^(F*ln(10))
;
; TERMB, TERMC, TERMD 被覆盖
; 耗时：5 分 28 秒
;
; TERMB, TERMC, TERMD 被覆盖
;---------------------------------------------------------------
TENX: ; 如果 x = 0，返回 1
CALL COPYA2B
CALL CHECK_ZERO
JNB ZEROFLAG, GET_I
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A
RET
; 将整数部分撷取到 ten_pwd
GET_I: MOV DPTR, #TERMA
MOVX A, @DPTR
MOV ten_pwd, A
MOV A, #0
MOVX @DPTR, A ; 清除整数部分，只留下小数部分 F (0 <= F < 1)
; --- 小数部分 * ln(10) ---
MOV DPTR, #ln_10
CALL x_CONST
CALL COPYC2A ; a = x
CALL eX ; e^(F*ln(10)) 最大 e^2.302585
; 尾数部分储存在 a
; 指数部分储存在 ten_pwd，输出 10^ten_pwd
; 结果 = a*10^pwd
RET
;---------------------------------------------------------------
; 使用泰勒级数寻找 e^x (1 <= x < 2)
; TERMA = e^x = 1 + x + x^2/2! + x^3/3! + x^4/4! + ...
; 对于 x > 2
; e^x = e^(2^k*r) = (e^r)^(2^k) (其中 r = x/(2^k) 且 1 <= r < 2)
; a^x = e^(x*ln(a))
;
; TERMB, TERMC, TERMD 被覆盖，TERMD = x
; 耗时：5 分 13 秒 (e^1)
;---------------------------------------------------------------
eX: MOV DPTR, #TERMA ; 检查 x
MOVX A, @DPTR
CLR C
SUBB A, #5 ; x < 5?
JC eX_s ; 是，呼叫小 x 的 e^x
; e^x > 148, x >= 5，结果为 m*10^ten_pwd 格式
; e^x = 10^(x*log(e))
MOV DPTR, #log_e ; log(e) 常数地址
CALL x_CONST
CALL COPYC2A
CALL TENX ; 尾数部分在 a，指数部分在 ten_pwd
RET
eX_s: ; x < 5.545177
MOV pwd, #0 ; 清除缩放计数器
ex_Scale_Loop:
MOV DPTR,#TERMA
MOVX A, @DPTR ; 取得 x 的整数部分
; 如果 x < 2，跳过
CLR C
SUBB A, #2
JC eX_0 ; 如果 x < 2，C=1
; 否则，将 x 除以 2
CALL SHIFT_A_R ; 向右位移 1 位元
INC pwd
SJMP ex_Scale_Loop
eX_0: ; 现在 0 <= x < 2
CALL eX_1 ; e^x
eX_Square_Loop:
; 如果 pwd = 0，离开
MOV A, pwd
JZ eX_DONE
; 将目前结果平方
CALL SQUARE ; (e^x)^2
CALL COPYC2A
DEC pwd
SJMP eX_Square_Loop
eX_1: ; 0 <= x < 2
CALL COPYA2B
CALL CHECK_ZERO
JNB ZEROFLAG, eX_2
; 如果 x = 0，返回 1
MOV DPTR, #TERMA
MOV A, #1
MOVX @DPTR, A
RET
eX_2: CALL COPYA2D ; d = x (乘数)
CALL COPYA2B ; b = x (term)
; 初始化 sum = 1 + x
MOV DPTR, #TERMA
MOVX A, @DPTR
INC A
MOVX @DPTR, A ; a = 1 + x = sum
CALL SWAPA_D ; a = x, d = sum
MOV TERMP_H, #0
MOV TERMP_L, #2 ; n 从 2 开始
eX_LOOP:
CALL MULTIPLY ; c = x * term (下一个幂次项)
CALL COPYC2B
MOV R6, TERMP_H
MOV R7, TERMP_L
CALL DIV16B ; b = x * term / n --> 新 term
CALL SWAPA_D ; a = sum, d = x
CALL CHECK_ZERO
JB ZEROFLAG, eX_DONE
CALL ADD8 ; sum = sum + term
CALL SWAPA_D ; a = x, d = sum
MOV A, TERMP_L
ADD A, #1 ; n++
MOV TERMP_L, A
JNC eX_LOOP
INC TERMP_H
SJMP eX_LOOP
eX_DONE:
RET
;==========================================================
; 将二进位 TERMA 转换为十进位
; 并透过串口传送到 PC
;
; 使用的暂存器：A, B, R2(DP counter_H), R3(DP counter_L), R4 (Counter_H), R5 (Counter_L),
; R6 (MSB 进位), DPTR
; TERMA 被覆盖
;==========================================================
OUT_A:
MOV DPTR, #TERMA ; TERMA 中的整数部分 (即 3)
MOVX A, @DPTR
CALL BIN2ASC ; 二进位转 ASCII (8-bit)
MOV A, #'.' ; 列印小数点
CALL SEND
MOV WR2, #DP ; 要列印的位数 = DP*2
MOV A, R3
JZ CONV2
INC R2
CONV2: CALL MULT100 ; 小数 x 100，列印 2 个 BCD 位数
DJNZ R3, CONV2
DJNZ R2, CONV2
RET
;----------------------------------------------------------
; 将 TERMA 中的二进位小数乘以 100 以取得接下来的 2 个十进位位数
; 2F,30,31 ...73 = 被乘数
; x 100 = 乘数
; -------------------------
; R4 2F,30,31 ...73 = 乘积
;
; 使用的暂存器：A, B, R4 (Counter_H), R5 (Counter_L), R6 (MSB 进位), DPTR
; TERMA 被覆盖
;-----------------------------------------------------------
MULT100:
MOV DPTR, #TERMA+SIZE-1
MOV WR4, #SIZE-1 ; 要相乘的位元组数
MOV A, R5
JZ MULT100_0
INC R4
MULT100_0:
MOV R6, #0 ; 先清除进位
MULT100_1:
MOV B, #100
MOVX A, @DPTR
MUL AB ; BA = A * 100
ADD A, R6 ; 加上先前的进位
JNC MULT100_2
INC B
MULT100_2:
MOV R6, B ; 进位至 R4
MOVX @DPTR, A ; 放回
DEC_DPTR
DJNZ R5, MULT100_1
DJNZ R4, MULT100_1
MOV A, R6 ; MSB 至 A 以供输出
CALL BCD_PRINT ; 2 个 BCD 位数传送到串口
RET
;---------------------------------------------------------------
; 输入： ACC 8-bit 二进位
; 输出： 3 位数 BCD 至串口
;---------------------------------------------------------------
BIN2ASC:
MOV Dval,#0 ; 高位元组 = 0
MOV Dval+1,A ; 低位元组
CLR A ; A=0，无前导零
JMP BINASC8
;---------------------------------------------------------------
; 输入： Dval (高位元组), Dval+1 (低位元组)
; 输出： 5 位数 BCD 至串口
;
; 使用的暂存器：A, R1, R6, DPTR
;---------------------------------------------------------------
BINASC:
;Dval 包含要以十进位列印的值
;Acc, R1, R6, 与 DPTR 被覆盖
;
;MOV Dval,@R1 ; 高位元组，放入 Dval
;INC R1
;MOV Dval+1,@R1 ; 低位元组，放入 Dval+1
CLR A ; A=0，无前导零
MOV DPTR,#10000 ; 减去 10000
ACALL RSUB ; 执行减法
MOV DPTR,#1000 ; 现在 1000
ACALL RSUB
BINASC8:
MOV DPTR,#100 ; 现在 100
ACALL RSUB
MOV DPTR,#10 ; 现在 10
ACALL RSUB
MOV DPTR,#1 ; 现在 1
ACALL RSUB
JZ RSUB2 ; 跳过 RET
RSUB_R: RET
RSUB: MOV R6,#-1 ; 设定计数器
RSUB1: INC R6 ; 递增计数器
XCH A,Dval ; 执行快速比较
CJNE A,DPH,$+3 ; 仅比较高位元组
XCH A,Dval
JC FAST_DONE ; C=1, Dval < DPTR，完成
XCH A,Dval+1 ; 取得低位元组
SUBB A,DPL ; 相减，清除借位
XCH A,Dval+1 ; 放回
XCH A,Dval ; 取得高位元组
SUBB A,DPH ; 从高位元组减去
XCH A,Dval ; 放回
JNC RSUB1 ; 重复直到借位
XCH A,Dval+1
ADD A,DPL ; 还原 Dval
XCH A,Dval+1
XCH A,Dval
ADDC A,DPH
XCH A,Dval
FAST_DONE:
ORL A,R6 ; 对计数值进行 OR 运算
JZ RSUB_R ; 如果为零则返回
RSUB2: MOV A,#'0' ; 取得 ASCII 偏移值
ADD A,R6 ; 加上计数
JMP SEND ; 列印并离开
;===================================================
; 列印储存在 A 中的 BCD 位数
; 输入： A = 十六进位 (最大 99=0x63)
; 输出： 2 个 BCD 位数至串口
; ==================================================
BCD_PRINT:
MOV B,#10
DIV AB ; A = A / 10; B = A % 10
ANL A,#0FH ; 列印十位数
ADD A,#30H
CALL SEND
MOV A, B ; 个位数
ANL A,#0FH ; 列印个位数
ADD A,#30H
CALL SEND
RET
;---------------------------------------------------------------
; 输入： A = 十六进位（4-bit，仅低半位元组）
; 输出： B = ASC
;
; 使用的暂存器：A, B
;---------------------------------------------------------------
HEX2ASC:
ANL A,#0FH ; 仅保留低半位元组
CLR C
SUBB A,#10 ; -10
JC DIGIT ; 有借位，是个数字
ADD A,#'A' ; 0xA - 10 + 'A'
JMP HEX2ASC2
DIGIT: ADD A,#10+'0' ; 0x0-10+10+'0'
HEX2ASC2:
MOV B, A
RET
;===================================================
; 列印储存在 A 中的 HEX 位数
; 输入： A = HEX (2 位数)
; ==================================================
HEX_PRINT:
PUSH ACC ; 保留低半位元组
SWAP A ; 列印高半位元组
CALL HEX2ASC ; 将 A 中的 hex 转换为 B 中的 ASC
MOV A, B
CALL SEND
POP ACC ; 还原低半位元组
CALL HEX2ASC
MOV A, B
JMP SEND
;------------------------------------------------------
; 以 HEX 格式列印 TERMA（每行 10 个 HEX）
;------------------------------------------------------
OUT_HEXA:
MOV DPTR, #TERMA ; 指向 TERMA
MOV WR4, #SIZE ; 要列印的总位元组数
MOV A, R5
JZ OUT_HEXA1
INC R4
OUT_HEXA1:
CALL NEW_LINE
MOV R7, #1 ; 第一行是整数部分
PRT_LOOP2:
MOV A, #'0' ; hex 前缀
CALL SEND
MOV A, #'x'
CALL SEND
MOVX A, @DPTR ; 从表格取得目前位元组
CALL HEX_PRINT ; 列印 hex 位数 (例如：B7)
; 列印前，检查 R7 是否为零
DEC R7
MOV A, R7
JNZ PRT_LOOP3
CALL NEW_LINE
SJMP PRT_LOOP4
PRT_LOOP3:
MOV A, #',' ; 分隔符号 ,
CALL SEND
MOV A, #' ' ; 空格
CALL SEND
PRT_LOOP4:
INC DPTR ; 移动至下一个位元组
DJNZ R5, PRT_LOOP2
DJNZ R4, PRT_LOOP2
CALL CRLF
RET
NEW_LINE:
; 新行与前缀产生
CALL CRLF ; 跳行
MOV R7, #10 ; 重设下一行 10 个项目的行计数器
MOV A, #' ' ; 4 个空格
CALL SEND
CALL SEND
CALL SEND
CALL SEND
MOV A, #'D' ; 列印 "DB" 关键字
CALL SEND
MOV A, #'B'
CALL SEND
MOV A, #' ' ; 空格
CALL SEND
RET
CRLF:
; 列印 CRLF (新行)
MOV A, #13 ; CR
CALL SEND
MOV A, #10 ; LF
CALL SEND
RET
;------------------------------------------------
; 字串讯息
;------------------------------------------------
DIV0: DB "Divided by 0, denominator must > 0", 13, 10, 0
LN0: DB "ln(x) error, x must >= 1", 13, 10, 0
;-----------------------------------------------------
; 常数 (6572 dp)
;
; 可用的常数：
; e, pi, ln_2, ln_10, log_e, sqrt_2
;-----------------------------------------------------
e: DB 2
DB 0xB7, 0xE1, 0x51, 0x62, 0x8A, 0xED, 0x2A, 0x6A, 0xBF, 0x71
DB 0x58, 0x80, 0x9C, 0xF4, 0xF3, 0xC7, 0x62, 0xE7, 0x16, 0x0F
DB 0x38, 0xB4, 0xDA, 0x56, 0xA7, 0x84, 0xD9, 0x04, 0x51, 0x90
DB 0xCF, 0xEF, 0x32, 0x4E, 0x77, 0x38, 0x92, 0x6C, 0xFB, 0xE5
DB 0xF4, 0xBF, 0x8D, 0x8D, 0x8C, 0x31, 0xD7, 0x63, 0xDA, 0x06
DB 0xC8, 0x0A, 0xBB, 0x11, 0x85, 0xEB, 0x4F, 0x7C, 0x7B, 0x57
DB 0x57, 0xF5, 0x95, 0x84, 0x90, 0xCF, 0xD4, 0x7D, 0x7C, 0x19
DB 0xBB, 0x42, 0x15, 0x8D, 0x95, 0x54, 0xF7, 0xB4, 0x6B, 0xCE
DB 0xD5, 0x5C, 0x4D, 0x79, 0xFD, 0x5F, 0x24, 0xD6, 0x61, 0x3C
DB 0x31, 0xC3, 0x83, 0x9A, 0x2D, 0xDF, 0x8A, 0x9A, 0x27, 0x6B
DB 0xCF, 0xBF, 0xA1, 0xC8, 0x77, 0xC5, 0x62, 0x84, 0xDA, 0xB7
DB 0x9C, 0xD4, 0xC2, 0xB3, 0x29, 0x3D, 0x20, 0xE9, 0xE5, 0xEA
DB 0xF0, 0x2A, 0xC6, 0x0A, 0xCC, 0x93, 0xED, 0x87, 0x44, 0x22
DB 0xA5, 0x2E, 0xCB, 0x23, 0x8F, 0xEE, 0xE5, 0xAB, 0x6A, 0xDD
DB 0x83, 0x5F, 0xD1, 0xA0, 0x75, 0x3D, 0x0A, 0x8F, 0x78, 0xE5
DB 0x37, 0xD2, 0xB9, 0x5B, 0xB7, 0x9D, 0x8D, 0xCA, 0xEC, 0x64
DB 0x2C, 0x1E, 0x9F, 0x23, 0xB8, 0x29, 0xB5, 0xC2, 0x78, 0x0B
DB 0xF3, 0x87, 0x37, 0xDF, 0x8B, 0xB3, 0x00, 0xD0, 0x13, 0x34
DB 0xA0, 0xD0, 0xBD, 0x86, 0x45, 0xCB, 0xFA, 0x73, 0xA6, 0x16
DB 0x0F, 0xFE, 0x39, 0x3C, 0x48, 0xCB, 0xBB, 0xCA, 0x06, 0x0F
DB 0x0F, 0xF8, 0xEC, 0x6D, 0x31, 0xBE, 0xB5, 0xCC, 0xEE, 0xD7
DB 0xF2, 0xF0, 0xBB, 0x08, 0x80, 0x17, 0x16, 0x3B, 0xC6, 0x0D
DB 0xF4, 0x5A, 0x0E, 0xCB, 0x1B, 0xCD, 0x28, 0x9B, 0x06, 0xCB
DB 0xBF, 0xEA, 0x21, 0xAD, 0x08, 0xE1, 0x84, 0x7F, 0x3F, 0x73
DB 0x78, 0xD5, 0x6C, 0xED, 0x94, 0x64, 0x0D, 0x6E, 0xF0, 0xD3
DB 0xD3, 0x7B, 0xE6, 0x70, 0x08, 0xE1, 0x86, 0xD1, 0xBF, 0x27
DB 0x5B, 0x9B, 0x24, 0x1D, 0xEB, 0x64, 0x74, 0x9A, 0x47, 0xDF
DB 0xDF, 0xB9, 0x66, 0x32, 0xC3, 0xEB, 0x06, 0x1B, 0x64, 0x72
DB 0xBB, 0xF8, 0x4C, 0x26, 0x14, 0x4E, 0x49, 0xC2, 0xD0, 0x4C
DB 0x32, 0x4E, 0xF1, 0x0D, 0xE5, 0x13, 0xD3, 0xF5, 0x11, 0x4B
DB 0x8B, 0x5D, 0x37, 0x4D, 0x93, 0xCB, 0x88, 0x79, 0xC7, 0xD5
DB 0x2F, 0xFD, 0x72, 0xBA, 0x0A, 0xAE, 0x72, 0x77, 0xDA, 0x7B
DB 0xA1, 0xB4, 0xAF, 0x14, 0x88, 0xD8, 0xE8, 0x36, 0xAF, 0x14
DB 0x86, 0x5E, 0x6C, 0x37, 0xAB, 0x68, 0x76, 0xFE, 0x69, 0x0B
DB 0x57, 0x11, 0x21, 0x38, 0x2A, 0xF3, 0x41, 0xAF, 0xE9, 0x4F
DB 0x77, 0xBC, 0xF0, 0x6C, 0x83, 0xB8, 0xFF, 0x56, 0x75, 0xF0
DB 0x97, 0x90, 0x74, 0xAD, 0x9A, 0x78, 0x7B, 0xC5, 0xB9, 0xBD
DB 0x4B, 0x0C, 0x59, 0x37, 0xD3, 0xED, 0xE4, 0xC3, 0xA7, 0x93
DB 0x96, 0x21, 0x5E, 0xDA, 0xB1, 0xF5, 0x7D, 0x0B, 0x5A, 0x7D
DB 0xB4, 0x61, 0xDD, 0x8F, 0x3C, 0x75, 0x54, 0x0D, 0x00, 0x12
DB 0x1F, 0xD5, 0x6E, 0x95, 0xF8, 0xC7, 0x31, 0xE9, 0xC4, 0xD7
DB 0x22, 0x1B, 0xBE, 0xD0, 0xC6, 0x2B, 0xB5, 0xA8, 0x78, 0x04
DB 0xB6, 0x79, 0xA0, 0xCA, 0xA4, 0x1D, 0x80, 0x2A, 0x46, 0x04
DB 0xC3, 0x11, 0xB7, 0x1D, 0xE3, 0xE5, 0xC6, 0xB4, 0x00, 0xE0
DB 0x24, 0xA6, 0x66, 0x8C, 0xCF, 0x2E, 0x2D, 0xE8, 0x68, 0x76
DB 0xE4, 0xF5, 0xC5, 0x00, 0x00, 0xF0, 0xA9, 0x3B, 0x3A, 0xA7
DB 0xE6, 0x34, 0x2B, 0x30, 0x2A, 0x0A, 0x47, 0x37, 0x3B, 0x25
DB 0xF7, 0x3E, 0x3B, 0x26, 0xD5, 0x69, 0xFE, 0x22, 0x91, 0xAD
DB 0x36, 0xD6, 0xA1, 0x47, 0xD1, 0x06, 0x0B, 0x87, 0x1A, 0x28
DB 0x01, 0xF9, 0x78, 0x37, 0x64, 0x08, 0x2F, 0xF5, 0x92, 0xD9
DB 0x14, 0x0D, 0xB1, 0xE9, 0x39, 0x9D, 0xF4, 0xB0, 0xE1, 0x4C
DB 0xA8, 0xE8, 0x8E, 0xE9, 0x11, 0x0B, 0x2B, 0xD4, 0xFA, 0x98
DB 0xEE, 0xD1, 0x50, 0xCA, 0x6D, 0xD8, 0x93, 0x22, 0x45, 0xEF
DB 0x75, 0x92, 0xC7, 0x03, 0xF5, 0x32, 0xCE, 0x3A, 0x30, 0xCD
DB 0x31, 0xC0, 0x70, 0xEB, 0x36, 0xB4, 0x19, 0x5F, 0xF3, 0x3F
DB 0xB1, 0xC6, 0x6C, 0x7D, 0x70, 0xF9, 0x39, 0x18, 0x10, 0x7C
DB 0xE2, 0x05, 0x1F, 0xED, 0x33, 0xF6, 0xD1, 0xDE, 0x94, 0x91
DB 0xC7, 0xDE, 0xA6, 0xA5, 0xA4, 0x42, 0xE1, 0x54, 0xC8, 0xBB
DB 0x6D, 0x8D, 0x03, 0x62, 0x80, 0x3B, 0xC2, 0x48, 0xD4, 0x14
DB 0x47, 0x8C, 0x2A, 0xFB, 0x07, 0xFF, 0xE7, 0x8E, 0x89, 0xB9
DB 0xFE, 0xCA, 0x7E, 0x30, 0x60, 0xC0, 0x8F, 0x0D, 0x61, 0xF8
DB 0xE3, 0x68, 0x01, 0xDF, 0x66, 0xD1, 0xD8, 0xF9, 0x39, 0x2E
DB 0x52, 0xCA, 0xEF, 0x06, 0x53, 0x19, 0x94, 0x79, 0xDF, 0x2B
DB 0xE6, 0x4B, 0xBA, 0xAB, 0x00, 0x8C, 0xA8, 0xA0, 0x6F, 0xDA
DB 0xCE, 0x9C, 0xE7, 0x04, 0x89, 0x84, 0x5A, 0x08, 0x2B, 0xA3
DB 0x6D, 0x61, 0x1E, 0x99, 0xF2, 0xFB, 0xE7, 0x24, 0x24, 0x6D
DB 0x18, 0xB5, 0x4E, 0x33, 0x5C, 0xAC, 0x0D, 0xD1, 0xAB, 0x9D
DB 0xFD, 0x79, 0x88, 0xA4, 0xB0, 0xC4, 0x55, 0x8A, 0xA1, 0x19
DB 0x41, 0x77, 0x20, 0xB6, 0xE1, 0x50, 0xCE, 0x2B, 0x92, 0x7D
DB 0x48, 0xD7, 0x25, 0x6E, 0x44, 0x5E, 0x33, 0x3C, 0xB7, 0x57
DB 0x2B, 0x3B, 0xD0, 0x0F, 0xB2, 0x74, 0x60, 0x43, 0x18, 0x9C
DB 0xAC, 0x11, 0x6C, 0xED, 0xC7, 0xE7, 0x71, 0xAE, 0x03, 0x58
DB 0xFF, 0x75, 0x2A, 0x3A, 0x6B, 0x6C, 0x79, 0xA5, 0x8A, 0x9A
DB 0x54, 0x9B, 0x50, 0xC5, 0x87, 0x06, 0x90, 0x75, 0x5C, 0x35
DB 0xE4, 0xE3, 0x6B, 0x52, 0x90, 0x38, 0xCA, 0x73, 0x3F, 0xD1
DB 0xAA, 0xA8, 0xDA, 0xB4, 0x01, 0x33, 0xD8, 0x03, 0x20, 0xE0
DB 0x79, 0x09, 0x68, 0xC7, 0x65, 0x46, 0xB9, 0x93, 0xF6, 0xC8
DB 0xFF, 0x3B, 0x25, 0x42, 0x75, 0x0D, 0xA1, 0xFF, 0xAD, 0xA7
DB 0xB7, 0x47, 0x31, 0x78, 0x2E, 0x33, 0x0E, 0xF7, 0xD9, 0x2C
DB 0x43, 0xBE, 0x1A, 0xD8, 0xC5, 0x0A, 0x8E, 0xAE, 0x20, 0xA5
DB 0x55, 0x6C, 0xBD, 0xD1, 0xF2, 0x4C, 0x99, 0x97, 0x2C, 0xB0
DB 0x3C, 0x73, 0x00, 0x6F, 0x5C, 0x08, 0xA4, 0xE2, 0x20, 0xE7
DB 0x4A, 0xBC, 0x17, 0x91, 0x51, 0x41, 0x2B, 0x1E, 0x2D, 0xD6
DB 0x0A, 0x08, 0xA1, 0x1B, 0x02, 0xE8, 0xD7, 0x0D, 0x7D, 0x71
DB 0x64, 0x58, 0x33, 0x01, 0x1B, 0xF6, 0x09, 0x45, 0x50, 0x7F
DB 0x1A, 0x32, 0x72, 0x1A, 0xC0, 0x8A, 0xED, 0xC2, 0x66, 0x1D
DB 0xA9, 0x18, 0x39, 0xD1, 0x46, 0xA2, 0xA4, 0xC4, 0x25, 0xC0
DB 0xFF, 0xB8, 0x70, 0x85, 0xF9, 0xB0, 0xE0, 0x9B, 0x94, 0xB1
DB 0x46, 0xA9, 0xA4, 0x78, 0x39, 0x08, 0xF3, 0xF2, 0x67, 0xA7
DB 0x8C, 0x59, 0x43, 0x04, 0x85, 0xED, 0x89, 0x20, 0x5B, 0x36
DB 0xB6, 0x6A, 0x57, 0xE7, 0x56, 0xE0, 0x06, 0x52, 0x23, 0x67
DB 0x02, 0x82, 0x87, 0xF8, 0xC1, 0xD6, 0x95, 0xDF, 0x88, 0xC6
DB 0x0F, 0xE0, 0x75, 0x28, 0xFC, 0xBE, 0x91, 0x5C, 0x7B, 0xF2
DB 0x33, 0x82, 0xEA, 0x29, 0x3F, 0xA2, 0xDA, 0x15, 0x77, 0xF9
DB 0xCA, 0xC2, 0x99, 0xBB, 0x7B, 0x4B, 0xEE, 0xAF, 0xEF, 0x96
DB 0x28, 0xC3, 0xEB, 0xEA, 0xF8, 0x71, 0x75, 0xC6, 0xA1, 0xF8
DB 0xBD, 0xD0, 0x7B, 0xE3, 0x07, 0xFA, 0x1B, 0xFA, 0x9A, 0xEF
DB 0xF7, 0x94, 0xC1, 0x9D, 0xFC, 0x36, 0x5F, 0x44, 0x75, 0x27
DB 0xDE, 0xA1, 0x10, 0xF4, 0x20, 0x8B, 0x94, 0x1A, 0xA7, 0xD1
DB 0x85, 0x38, 0x04, 0x78, 0xAA, 0x52, 0x0E, 0x3F, 0xE2, 0x33
DB 0x5A, 0x32, 0x2E, 0xDF, 0x14, 0x7B, 0xBD, 0xB5, 0x27, 0xAA
DB 0x2A, 0xD3, 0xCB, 0x0F, 0x7D, 0x6E, 0xD3, 0x81, 0xCD, 0x6A
DB 0xC3, 0x5A, 0x1D, 0x24, 0xBF, 0x89, 0xB7, 0x50, 0x19, 0x60
DB 0x5A, 0xEE, 0x9D, 0xFA, 0xBA, 0x5C, 0xFC, 0xED, 0x03, 0x3B
DB 0xA2, 0x10, 0x2A, 0x0B, 0xDB, 0xE3, 0xB4, 0x9D, 0x72, 0x72
DB 0xF8, 0x9E, 0x09, 0xD0, 0x08, 0xE5, 0xD5, 0xBD, 0x99, 0x23
DB 0x93, 0x62, 0x86, 0x1E, 0xB4, 0x26, 0x29, 0x7C, 0x58, 0x41
DB 0x39, 0x75, 0x15, 0x47, 0x3C, 0xF2, 0xA3, 0xD6, 0xDE, 0x58
DB 0xC4, 0xBB, 0x1B, 0x91, 0xAD, 0x97, 0xAB, 0xF0, 0x28, 0xE9
DB 0x66, 0x5D, 0xA4, 0xEC, 0xE8, 0x0D, 0xDC, 0x13, 0xE0, 0xDF
DB 0x43, 0x22, 0xED, 0xA0, 0xFD, 0x38, 0x9B, 0x17, 0x5E, 0x8D
DB 0x10, 0xD0, 0x8C, 0x52, 0x30, 0xA6, 0xB5, 0x76, 0xC9, 0x4F
DB 0xC5, 0x2B, 0x4E, 0x74, 0xB2, 0xE3, 0x42, 0x0E, 0x90, 0x2C
DB 0x82, 0xEE, 0x7A, 0xEB, 0x80, 0x5C, 0x2E, 0xB7, 0x65, 0x17
DB 0xEA, 0xBF, 0xFB, 0x87, 0x77, 0x37, 0x8C, 0x38, 0x06, 0xC9
DB 0x1D, 0x07, 0xF1, 0x09, 0xD6, 0x75, 0x27, 0xC1, 0x85, 0x68
DB 0x34, 0x48, 0x15, 0x4D, 0x69, 0x21, 0x61, 0x07, 0x55, 0xBE
DB 0xF3, 0x0B, 0x80, 0x27, 0xE5, 0xE8, 0xB0, 0x4E, 0x59, 0x2E
DB 0x8B, 0x2E, 0xA3, 0x54, 0xA2, 0x61, 0xEA, 0xBB, 0x48, 0x51
DB 0x64, 0x72, 0xD4, 0x69, 0xA6, 0x68, 0x24, 0xF2, 0x4D, 0x44
DB 0xB1, 0x5C, 0xE1, 0x42, 0xFC, 0xB6, 0x53, 0x07, 0xF2, 0x1C
DB 0xDA, 0xBB, 0xD6, 0x85, 0x8C, 0xC7, 0xAE, 0x3C, 0xEE, 0x06
DB 0xAE, 0x64, 0xBE, 0xD9, 0x1A, 0x04, 0x12, 0xE6, 0xF3, 0x3B
DB 0xA0, 0x4F, 0xAB, 0x57, 0xB8, 0xE5, 0x21, 0x65, 0xCA, 0x81
DB 0xD0, 0xC7, 0xD1, 0x18, 0x38, 0x5D, 0x6D, 0x23, 0x0A, 0x47
DB 0xE1, 0xE8, 0xB5, 0x3A, 0xF0, 0xD9, 0xA7, 0xAA, 0xC2, 0x52
DB 0x7B, 0x46, 0xC4, 0x02, 0x78, 0x41, 0xAA, 0x38, 0x5A, 0x40
DB 0xC6, 0xC5, 0x17, 0xAF, 0x8E, 0xD2, 0x68, 0xF4, 0x69, 0x99
DB 0x0D, 0x6D, 0xAE, 0x2B, 0x68, 0xF6, 0x2F, 0xDD, 0xB6, 0xF3
DB 0x03, 0xA7, 0x59, 0x8B, 0xE8, 0xD5, 0xB7, 0x1A, 0x3A, 0x80
DB 0x37, 0x12, 0xC7, 0xE6, 0xBB, 0x1B, 0xCB, 0xC0, 0xC8, 0x7B
DB 0xEA, 0x5A, 0x8E, 0xE3, 0xE8, 0xE1, 0xE8, 0xE6, 0xEB, 0xA9
DB 0x9C, 0x04, 0x7D, 0xB5, 0xF6, 0xE1, 0x37, 0x27, 0x96, 0xDC
DB 0x26, 0x34, 0xE5, 0x65, 0x52, 0xD8, 0x0C, 0x5F, 0xBA, 0xF8
DB 0x26, 0xA9, 0xC3, 0xDC, 0x2C, 0x19, 0xE9, 0x96, 0x9E, 0x27
DB 0x65, 0xBF, 0x88, 0x1E, 0xEA, 0x8B, 0xF6, 0x70, 0x50, 0x1F
DB 0x6A, 0x39, 0xCC, 0x95, 0xE5, 0x35, 0x91, 0x17, 0xF9, 0xFE
DB 0xC0, 0xAD, 0xFB, 0x7B, 0x95, 0x95, 0x29, 0xBD, 0x2C, 0x7B
DB 0xE5, 0xDB, 0x65, 0x70, 0x7C, 0x4C, 0xA4, 0xDE, 0x86, 0x90
DB 0x92, 0xF0, 0x02, 0x9D, 0x9E, 0x35, 0x24, 0x6F, 0x49, 0x53
DB 0xA7, 0xE0, 0x75, 0xE5, 0x18, 0x08, 0x68, 0xFA, 0x5B, 0xD6
DB 0x0A, 0x32, 0x8B, 0x3F, 0xEA, 0x53, 0x08, 0x4D, 0x17, 0x4C
DB 0x9D, 0xE8, 0xC8, 0xF6, 0xA1, 0x97, 0xD6, 0x63, 0x59, 0xB6
DB 0x9A, 0x22, 0x92, 0xD2, 0x5F, 0x12, 0xF1, 0xB3, 0x22, 0x39
DB 0x2B, 0x10, 0x35, 0xA8, 0x15, 0x8A, 0x10, 0xF9, 0x56, 0x0F
DB 0xF1, 0x92, 0x7E, 0x26, 0x9B, 0xF2, 0xA6, 0xE1, 0x64, 0x4A
DB 0x56, 0x43, 0xCA, 0x70, 0xB2, 0xF6, 0x61, 0xE2, 0xA3, 0xCA
DB 0x13, 0x4E, 0x51, 0x5E, 0x81, 0xC6, 0x2D, 0x12, 0x9B, 0xA3
DB 0xB6, 0xD6, 0x6C, 0xE3, 0xBA, 0xD9, 0x54, 0x36, 0xC1, 0x5F
DB 0xCE, 0x6E, 0xCC, 0xD5, 0x2A, 0xAD, 0x27, 0x10, 0x47, 0xDE
DB 0xF5, 0x5B, 0x08, 0x43, 0x35, 0x49, 0x1F, 0x86, 0x59, 0x90
DB 0xC4, 0x71, 0x66, 0x61, 0x1A, 0xED, 0xDC, 0xDC, 0x4B, 0x80
DB 0x7A, 0x11, 0xBE, 0x08, 0x4D, 0x85, 0xB0, 0xEF, 0xA8, 0x0B
DB 0xD3, 0x1F, 0x0A, 0x02, 0x1E, 0x45, 0x80, 0x25, 0x82, 0xD1
DB 0xF6, 0x05, 0xB1, 0xAE, 0x3E, 0x32, 0x74, 0xAE, 0x42, 0x53
DB 0x5D, 0xA2, 0x74, 0xF7, 0xFE, 0xD7, 0xC5, 0xA3, 0x86, 0x9C
DB 0xCD, 0xBC, 0xA5, 0x8C, 0x54, 0xDD, 0x24, 0x98, 0x6A, 0x59
DB 0x3F, 0x18, 0xBB, 0x8C, 0x42, 0x29, 0x1E, 0x79, 0x64, 0xC9
DB 0x93, 0xD1, 0x4C, 0xBA, 0xC3, 0x63, 0xA8, 0x01, 0xA2, 0x04
DB 0x8D, 0x4E, 0x3C, 0x6F, 0x8E, 0xCF, 0xA7, 0x5F, 0xCC, 0xD0
DB 0x09, 0xA6, 0x49, 0xAF, 0x5E, 0xC2, 0x0C, 0x4D, 0x7E, 0xD7
DB 0x84, 0x37, 0xB4, 0x6B, 0x6A, 0xAF, 0x5B, 0x9D, 0xB4, 0xAD
DB 0xF4, 0x02, 0xCF, 0x64, 0x05, 0x30, 0x11, 0x8E, 0x98, 0x52
DB 0xBE, 0x42, 0x03, 0xF2, 0x2C, 0xBB, 0x68, 0xDF, 0xF2, 0xBF
DB 0x38, 0xA6, 0xEA, 0xE0, 0xB6, 0xD0, 0xE7, 0xBB, 0xFE, 0x4D
DB 0xD3, 0x97, 0xD4, 0x24, 0x01, 0xF6, 0x14, 0x19, 0xB1, 0xF3
DB 0x8C, 0x03, 0x8B, 0xD2, 0x4B, 0xAD, 0x2F, 0x30, 0x71, 0xC2
DB 0xE1, 0x44, 0x72, 0x1F, 0xF7, 0x28, 0x66, 0x53, 0x0E, 0x1B
DB 0xC7, 0xF6, 0xDC, 0x9F, 0x62, 0x17, 0xE2, 0x58, 0x5A, 0xC3
DB 0xFF, 0x7C, 0x8F, 0xB1, 0xE8, 0x68, 0x23, 0x3D, 0x62, 0xDE
DB 0x85, 0xE6, 0xDF, 0x73, 0xBF, 0xD1, 0xC8, 0x1E, 0x45, 0x66
DB 0xCE, 0x96, 0x35, 0x95, 0x02, 0x2C, 0x3B, 0x91, 0x05, 0x64
DB 0x2F, 0x07, 0x29, 0x43, 0x94, 0x41, 0xBC, 0xD9, 0x83, 0xEA
DB 0x5F, 0x18, 0xE1, 0xBC, 0xCD, 0x4E, 0xCC, 0x56, 0xCA, 0xB4
DB 0x39, 0x0D, 0xF6, 0x15, 0x5B, 0x21, 0xBD, 0x8A, 0xB7, 0xC7
DB 0x2F, 0x00, 0x36, 0x21, 0xB4, 0xD1, 0x80, 0x37, 0xAC, 0xE4
DB 0x46, 0xEC, 0x12, 0x0E, 0x52, 0x14, 0xD1, 0x86, 0x2E, 0xB0
DB 0x5C, 0x6B, 0xB5, 0x7D, 0xED, 0x78, 0x9B, 0x1D, 0x98, 0x1A
DB 0x31, 0xB9, 0x6A, 0x33, 0xB3, 0x52, 0x0E, 0x76, 0x64, 0x5D
DB 0xCE, 0x6C, 0x54, 0x1E, 0x09, 0x95, 0xB7, 0xB1, 0x5A, 0xD8
DB 0x00, 0x8C, 0x7D, 0x6B, 0x9C, 0x90, 0x95, 0xF0, 0x56, 0x3E
DB 0xEF, 0xFB, 0x01, 0xDE, 0x6C, 0x4F, 0xFD, 0xA8, 0xDB, 0xD6
DB 0x43, 0xFD, 0x03, 0xFF, 0x5C, 0x5C, 0x5D, 0x0A, 0xFB, 0x47
DB 0xE3, 0x3B, 0x41, 0xCC, 0x9B, 0x01, 0x4D, 0xB5, 0x26, 0xCA
DB 0xE4, 0xFD, 0x54, 0x15, 0xF5, 0x72, 0xC4, 0xE9, 0x18, 0x13
DB 0x27, 0x4A, 0x4A, 0x85, 0x0E, 0x1F, 0x63, 0x34, 0x38, 0xC1
DB 0x50, 0x65, 0xA3, 0x11, 0x4F, 0xED, 0xCD, 0xCF, 0x2B, 0x36
DB 0x4E, 0x81, 0xC1, 0x58, 0xAD, 0x60, 0x18, 0xC2, 0x26, 0x16
DB 0x52, 0x07, 0x7E, 0x20, 0xC4, 0xB1, 0x6A, 0x5E, 0x07, 0xAC
DB 0x79, 0x12, 0x97, 0xDA, 0x1D, 0x7F, 0x22, 0xB9, 0x3B, 0x7B
DB 0xBD, 0x5F, 0x04, 0xBC, 0x92, 0xA7, 0x58, 0x5D, 0xAD, 0x27
DB 0x3C, 0x4C, 0xDE, 0x7B, 0xC7, 0xB6, 0x7B, 0x32, 0xA3, 0x82
DB 0x0A, 0x79, 0xC7, 0x87, 0x5D, 0x14, 0x54, 0x5C, 0x6D, 0x11
DB 0xF4, 0xB0, 0xB3, 0x46, 0xFA, 0xDE, 0x8E, 0xE9, 0xEC, 0xD0
DB 0x9E, 0x8E, 0x0D, 0xE1, 0xBF, 0x70, 0x9E, 0x18, 0x4C, 0xA9
DB 0x09, 0x37, 0x01, 0x88, 0x4F, 0x76, 0x7C, 0x72, 0x16, 0x7F
DB 0xE9, 0x0F, 0xC7, 0x07, 0x84, 0x39, 0xC1, 0xBE, 0x57, 0x94
DB 0xBB, 0xCC, 0x42, 0x4D, 0xBA, 0xAC, 0x1F, 0x4D, 0x03, 0xEC
DB 0x1B, 0x37, 0xC7, 0xD1, 0x36, 0xC4, 0x9A, 0x76, 0xC0, 0x5A
DB 0xEE, 0xED, 0x73, 0xBE, 0x47, 0xB0, 0x87, 0x0E, 0x5A, 0x51
DB 0x11, 0x5D, 0x34, 0xC5, 0xDC, 0xB7, 0x4A, 0x81, 0x01, 0xDF
DB 0x2B, 0x5A, 0xAF, 0xF9, 0x9E, 0x0F, 0x07, 0x3E, 0xBF, 0x63
DB 0x1D, 0xA2, 0x9E, 0x5B, 0x1F, 0x74, 0x88, 0x57, 0xC1, 0xA7
DB 0xC1, 0xFE, 0xAE, 0x62, 0x14, 0xF9, 0xEB, 0x79, 0x95, 0x20
DB 0xE8, 0xF1, 0x40, 0xB6, 0xC4, 0x9C, 0x23, 0x10, 0x67, 0x41
DB 0x27, 0xB6, 0x89, 0x1D, 0xE5, 0x4F, 0xD0, 0xE4, 0x5E, 0x69
DB 0x41, 0x62, 0x58, 0x03, 0xD1, 0x26, 0xC3, 0x95, 0x0C, 0x0D
DB 0xBF, 0x72, 0xB6, 0x29, 0xA9, 0xD2, 0xA6, 0xEE, 0xCF, 0x4C
DB 0x04, 0xF4, 0xDE, 0xBA, 0xC8, 0x4F, 0xFB, 0x85, 0x3B, 0x81
DB 0x80, 0x1B, 0x3D, 0x9D, 0xBD, 0x19, 0x1C, 0x00, 0x48, 0xF3
DB 0xC1, 0x0C, 0x1B, 0x7C, 0x03, 0x5F, 0x79, 0xE4, 0xD6, 0x27
DB 0x12, 0xA9, 0x99, 0xC5, 0xC6, 0xA6, 0xCF, 0x47, 0xD5, 0xC3
DB 0x80, 0xBB, 0x1D, 0xF5, 0x24, 0xD9, 0xE7, 0x7F, 0xC7, 0xBB
DB 0xDF, 0xEE, 0x3E, 0x3E, 0x77, 0xAB, 0x5E, 0x45, 0xF6, 0x32
DB 0xC5, 0xFB, 0xA1, 0x3B, 0xD5, 0x7B, 0x3C, 0xC6, 0x70, 0xFD
DB 0xFA, 0x0B, 0x0B, 0xF6, 0x4A, 0x96, 0x04, 0x92, 0xAE, 0xAA
DB 0x14, 0xBB, 0x15, 0x7F, 0xD4, 0x89, 0x92, 0x36, 0x8C, 0x9F
DB 0xD0, 0xA2, 0xEB, 0xF9, 0x44, 0xE0, 0xB3, 0x96, 0x14, 0xDC
DB 0xBF, 0x45, 0x3A, 0xF9, 0x75, 0xCE, 0xB3, 0xDA, 0x50, 0x7C
DB 0xBB, 0x40, 0x83, 0x08, 0x20, 0x75, 0xC9, 0x00, 0x67, 0x2E
DB 0xF2, 0x14, 0xB0, 0x5C, 0x67, 0x47, 0x0E, 0x38, 0xFB, 0x31
DB 0x76, 0xAE, 0x19, 0xA5, 0xC1, 0x5F, 0xBA, 0x6F, 0x38, 0x56
DB 0x93, 0xAA, 0x04, 0x84, 0xD9, 0x73, 0x1E, 0x4D, 0x24, 0xB7
DB 0x46, 0x06, 0x92, 0xC0, 0xE8, 0x41, 0x83, 0xA3, 0x47, 0x21
DB 0xB1, 0x7C, 0x58, 0xF3, 0x81, 0x9C, 0xDF, 0xB1, 0xE0, 0x08
DB 0xEA, 0xFC, 0xED, 0x5F, 0x9D, 0x53, 0xB7, 0x78, 0xDA, 0x71
DB 0x61, 0x43, 0x8A, 0x5D, 0xD8, 0x4B, 0x36, 0x0F, 0x06, 0xF0
DB 0xC1, 0x42, 0xA9, 0xD0, 0xAE, 0x7F, 0x15, 0x1A, 0x89, 0xDD
DB 0x77, 0x06, 0x25, 0x18, 0x5F, 0x59, 0xC9, 0x37, 0x58, 0xD8
DB 0x72, 0xA0, 0x3A, 0xD6, 0x96, 0xE0, 0x8D, 0x2F, 0xE3, 0x0D
DB 0x01, 0x88, 0x61, 0xD1, 0xAC, 0x9C, 0xC8, 0xA6, 0x70, 0x99
DB 0x73, 0x24, 0x90, 0x4B, 0xC8, 0x87, 0x32, 0x3B, 0xA9, 0x5C
DB 0x8D, 0xD0, 0x4B, 0x9B, 0xE3, 0x12, 0x76, 0x9A, 0x31, 0xE7
DB 0x1E, 0x98, 0x8A, 0x33, 0xBD, 0x1C, 0x8E, 0xF0, 0x24, 0xA3
DB 0x98, 0x3E, 0x84, 0x5D, 0xEF, 0xCA, 0xF0, 0x03, 0xA6, 0x88
DB 0x8D, 0xDE, 0x26, 0x23, 0x84, 0x5F, 0x58, 0x6B, 0xF4, 0xDC
DB 0x88, 0xF4, 0x11, 0x75, 0x7E, 0x87, 0x28, 0x0C, 0x54, 0x1D
DB 0x80, 0xD1, 0x00, 0xEB, 0x44, 0x6C, 0x36, 0xFB, 0xD4, 0xCA
DB 0xA0, 0xDD, 0xEF, 0x68, 0xCA, 0xEE, 0xAB, 0xB3, 0x22, 0x86
DB 0x58, 0x57, 0xD9, 0xDA, 0x5C, 0xD8, 0x80, 0xCC, 0xA4, 0x48
DB 0x78, 0xA4, 0x2C, 0xB9, 0xE5, 0x1F, 0x19, 0xFD, 0x55, 0x0B
DB 0xAA, 0x29, 0x66, 0x31, 0x01, 0xF2, 0x9D, 0x12, 0x44, 0xCB
DB 0xFB, 0x6C, 0xC8, 0x01, 0xF3, 0xEF, 0x56, 0x6E, 0x43, 0xF8
DB 0xC6, 0xB6, 0xFF, 0x5F, 0x64, 0xC3, 0xE9, 0x4C, 0x3B, 0x75
DB 0x9F, 0x02, 0x51, 0x62, 0x5E, 0xF0, 0x6F, 0x8A, 0xFF, 0x00
DB 0x48, 0x37, 0x7B, 0xCC, 0x63, 0x83, 0x2C, 0xF8, 0xCC, 0xEA
DB 0x74, 0x15, 0x80, 0x90, 0x57, 0x3B, 0x88, 0x95, 0x49, 0x9C
DB 0xB0, 0xA6, 0xD4, 0xCC, 0x68, 0x47, 0x5B, 0x71, 0x10, 0x74
DB 0xA5, 0x5F, 0xD3, 0x62, 0x4A, 0x06, 0xB4, 0x3A, 0xAA, 0xDC
DB 0xC4, 0xF3, 0x6A, 0xB4, 0x24, 0x2C, 0xCD, 0xEF, 0x36, 0xFE
DB 0x47, 0xCC, 0x56, 0x82, 0x4E, 0x9C, 0xB2, 0x83, 0x1E, 0xE1
DB 0xE3, 0xC9, 0x63, 0x8B, 0x8D, 0xFF, 0xB3, 0x7A, 0x0F, 0xD2
DB 0x98, 0x4D, 0x2E, 0x2C, 0x33, 0xD3, 0x78, 0xA9, 0x9C, 0x0F
DB 0xD0, 0xFB, 0xF3, 0xB6, 0x44, 0x31, 0xAD, 0xD5, 0x55, 0xBE
DB 0x6E, 0x29, 0x1F, 0x9B, 0xF7, 0x53, 0xA1, 0x03, 0x55, 0x60
DB 0x76, 0xF6, 0x6C, 0xBA, 0x1C, 0x3B, 0xCD, 0xC5, 0x66, 0x2F
DB 0x63, 0x9C, 0x22, 0x7D, 0x4A, 0xD3, 0xE5, 0xD1, 0x1C, 0x55
DB 0x61, 0xB0, 0xAB, 0x02, 0x64, 0x48, 0x19, 0x99, 0x08, 0xFC
DB 0x66, 0x02, 0x82, 0x9D, 0x98, 0xB8, 0x25, 0x86, 0xB0, 0x47
DB 0x90, 0x3F, 0x64, 0x95, 0x9B, 0x7E, 0xAD, 0x34, 0x99, 0x54
DB 0x0B, 0x4B, 0x67, 0x1C, 0xC6, 0xDD, 0x4E, 0xFA, 0xEE, 0x48
DB 0xEA, 0x5D, 0x62, 0xB6, 0xB0, 0xA1, 0xB5, 0x95, 0x51, 0x41
DB 0xC7, 0x55, 0xF1, 0xA0, 0x46, 0x04, 0xD4, 0x32, 0xB2, 0x79
DB 0x9B, 0x4E, 0xF4, 0x6E, 0x84, 0x52, 0xD8, 0x88, 0x46, 0x92
DB 0x24, 0x44, 0x16, 0xFB, 0x6D, 0x31, 0xA8, 0x43, 0xAC, 0xDF
DB 0x4C, 0xF7, 0xA1, 0xED, 0xC0, 0xF5, 0x2D, 0xCB, 0x8E, 0x19
DB 0xFF, 0x2C, 0x8F, 0x92, 0xE4, 0x03, 0x97, 0x65, 0xE9, 0x29
DB 0xF8, 0x55, 0x8F, 0xD5, 0x4E, 0xE8, 0xD1, 0x51, 0x3D, 0x5E
DB 0xA7, 0xEC, 0x1F, 0x7E, 0x81, 0x2B, 0x7F, 0x73, 0x38, 0x7A
DB 0x07, 0x74, 0xC5, 0x0B, 0xD3, 0xCE, 0xDD, 0xC5, 0x11, 0x37
DB 0x0A, 0x18, 0x38, 0x1A, 0xE8, 0x67, 0xF8, 0x4B, 0x6F, 0x39
DB 0x6E, 0xEA, 0x51, 0x64, 0x54, 0xAE, 0xBE, 0xE4, 0xBB, 0x00
DB 0xD2, 0xFC, 0x11, 0x0C, 0x44, 0x9B, 0x89, 0x91, 0xD6, 0x3B
pi: DB 3
DB 0x24, 0x3F, 0x6A, 0x88, 0x85, 0xA3, 0x08, 0xD3, 0x13, 0x19
DB 0x8A, 0x2E, 0x03, 0x70, 0x73, 0x44, 0xA4, 0x09, 0x38, 0x22
DB 0x29, 0x9F, 0x31, 0xD0, 0x08, 0x2E, 0xFA, 0x98, 0xEC, 0x4E
DB 0x6C, 0x89, 0x45, 0x28, 0x21, 0xE6, 0x38, 0xD0, 0x13, 0x77
DB 0xBE, 0x54, 0x66, 0xCF, 0x34, 0xE9, 0x0C, 0x6C, 0xC0, 0xAC
DB 0x29, 0xB7, 0xC9, 0x7C, 0x50, 0xDD, 0x3F, 0x84, 0xD5, 0xB5
DB 0xB5, 0x47, 0x09, 0x17, 0x92, 0x16, 0xD5, 0xD9, 0x89, 0x79
DB 0xFB, 0x1B, 0xD1, 0x31, 0x0B, 0xA6, 0x98, 0xDF, 0xB5, 0xAC
DB 0x2F, 0xFD, 0x72, 0xDB, 0xD0, 0x1A, 0xDF, 0xB7, 0xB8, 0xE1
DB 0xAF, 0xED, 0x6A, 0x26, 0x7E, 0x96, 0xBA, 0x7C, 0x90, 0x45
DB 0xF1, 0x2C, 0x7F, 0x99, 0x24, 0xA1, 0x99, 0x47, 0xB3, 0x91
DB 0x6C, 0xF7, 0x08, 0x01, 0xF2, 0xE2, 0x85, 0x8E, 0xFC, 0x16
DB 0x63, 0x69, 0x20, 0xD8, 0x71, 0x57, 0x4E, 0x69, 0xA4, 0x58
DB 0xFE, 0xA3, 0xF4, 0x93, 0x3D, 0x7E, 0x0D, 0x95, 0x74, 0x8F
DB 0x72, 0x8E, 0xB6, 0x58, 0x71, 0x8B, 0xCD, 0x58, 0x82, 0x15
DB 0x4A, 0xEE, 0x7B, 0x54, 0xA4, 0x1D, 0xC2, 0x5A, 0x59, 0xB5
DB 0x9C, 0x30, 0xD5, 0x39, 0x2A, 0xF2, 0x60, 0x13, 0xC5, 0xD1
DB 0xB0, 0x23, 0x28, 0x60, 0x85, 0xF0, 0xCA, 0x41, 0x79, 0x18
DB 0xB8, 0xDB, 0x38, 0xEF, 0x8E, 0x79, 0xDC, 0xB0, 0x60, 0x3A
DB 0x18, 0x0E, 0x6C, 0x9E, 0x0E, 0x8B, 0xB0, 0x1E, 0x8A, 0x3E
DB 0xD7, 0x15, 0x77, 0xC1, 0xBD, 0x31, 0x4B, 0x27, 0x78, 0xAF
DB 0x2F, 0xDA, 0x55, 0x60, 0x5C, 0x60, 0xE6, 0x55, 0x25, 0xF3
DB 0xAA, 0x55, 0xAB, 0x94, 0x57, 0x48, 0x98, 0x62, 0x63, 0xE8
DB 0x14, 0x40, 0x55, 0xCA, 0x39, 0x6A, 0x2A, 0xAB, 0x10, 0xB6
DB 0xB4, 0xCC, 0x5C, 0x34, 0x11, 0x41, 0xE8, 0xCE, 0xA1, 0x54
DB 0x86, 0xAF, 0x7C, 0x72, 0xE9, 0x93, 0xB3, 0xEE, 0x14, 0x11
DB 0x63, 0x6F, 0xBC, 0x2A, 0x2B, 0xA9, 0xC5, 0x5D, 0x74, 0x18
DB 0x31, 0xF6, 0xCE, 0x5C, 0x3E, 0x16, 0x9B, 0x87, 0x93, 0x1E
DB 0xAF, 0xD6, 0xBA, 0x33, 0x6C, 0x24, 0xCF, 0x5C, 0x7A, 0x32
DB 0x53, 0x81, 0x28, 0x95, 0x86, 0x77, 0x3B, 0x8F, 0x48, 0x98
DB 0x6B, 0x4B, 0xB9, 0xAF, 0xC4, 0xBF, 0xE8, 0x1B, 0x66, 0x28
DB 0x21, 0x93, 0x61, 0xD8, 0x09, 0xCC, 0xFB, 0x21, 0xA9, 0x91
DB 0x48, 0x7C, 0xAC, 0x60, 0x5D, 0xEC, 0x80, 0x32, 0xEF, 0x84
DB 0x5D, 0x5D, 0xE9, 0x85, 0x75, 0xB1, 0xDC, 0x26, 0x23, 0x02
DB 0xEB, 0x65, 0x1B, 0x88, 0x23, 0x89, 0x3E, 0x81, 0xD3, 0x96
DB 0xAC, 0xC5, 0x0F, 0x6D, 0x6F, 0xF3, 0x83, 0xF4, 0x42, 0x39
DB 0x2E, 0x0B, 0x44, 0x82, 0xA4, 0x84, 0x20, 0x04, 0x69, 0xC8
DB 0xF0, 0x4A, 0x9E, 0x1F, 0x9B, 0x5E, 0x21, 0xC6, 0x68, 0x42
DB 0xF6, 0xE9, 0x6C, 0x9A, 0x67, 0x0C, 0x9C, 0x61, 0xAB, 0xD3
DB 0x88, 0xF0, 0x6A, 0x51, 0xA0, 0xD2, 0xD8, 0x54, 0x2F, 0x68
DB 0x96, 0x0F, 0xA7, 0x28, 0xAB, 0x51, 0x33, 0xA3, 0x6E, 0xEF
DB 0x0B, 0x6C, 0x13, 0x7A, 0x3B, 0xE4, 0xBA, 0x3B, 0xF0, 0x50
DB 0x7E, 0xFB, 0x2A, 0x98, 0xA1, 0xF1, 0x65, 0x1D, 0x39, 0xAF
DB 0x01, 0x76, 0x66, 0xCA, 0x59, 0x3E, 0x82, 0x43, 0x0E, 0x88
DB 0x8C, 0xEE, 0x86, 0x19, 0x45, 0x6F, 0x9F, 0xB4, 0x7D, 0x84
DB 0xA5, 0xC3, 0x3B, 0x8B, 0x5E, 0xBE, 0xE0, 0x6F, 0x75, 0xD8
DB 0x85, 0xC1, 0x20, 0x73, 0x40, 0x1A, 0x44, 0x9F, 0x56, 0xC1
DB 0x6A, 0xA6, 0x4E, 0xD3, 0xAA, 0x62, 0x36, 0x3F, 0x77, 0x06
DB 0x1B, 0xFE, 0xDF, 0x72, 0x42, 0x9B, 0x02, 0x3D, 0x37, 0xD0
DB 0xD7, 0x24, 0xD0, 0x0A, 0x12, 0x48, 0xDB, 0x0F, 0xEA, 0xD3
DB 0x49, 0xF1, 0xC0, 0x9B, 0x07, 0x53, 0x72, 0xC9, 0x80, 0x99
DB 0x1B, 0x7B, 0x25, 0xD4, 0x79, 0xD8, 0xF6, 0xE8, 0xDE, 0xF7
DB 0xE3, 0xFE, 0x50, 0x1A, 0xB6, 0x79, 0x4C, 0x3B, 0x97, 0x6C
DB 0xE0, 0xBD, 0x04, 0xC0, 0x06, 0xBA, 0xC1, 0xA9, 0x4F, 0xB6
DB 0x40, 0x9F, 0x60, 0xC4, 0x5E, 0x5C, 0x9E, 0xC2, 0x19, 0x6A
DB 0x24, 0x63, 0x68, 0xFB, 0x6F, 0xAF, 0x3E, 0x6C, 0x53, 0xB5
DB 0x13, 0x39, 0xB2, 0xEB, 0x3B, 0x52, 0xEC, 0x6F, 0x6D, 0xFC
DB 0x51, 0x1F, 0x9B, 0x30, 0x95, 0x2C, 0xCC, 0x81, 0x45, 0x44
DB 0xAF, 0x5E, 0xBD, 0x09, 0xBE, 0xE3, 0xD0, 0x04, 0xDE, 0x33
DB 0x4A, 0xFD, 0x66, 0x0F, 0x28, 0x07, 0x19, 0x2E, 0x4B, 0xB3
DB 0xC0, 0xCB, 0xA8, 0x57, 0x45, 0xC8, 0x74, 0x0F, 0xD2, 0x0B
DB 0x5F, 0x39, 0xB9, 0xD3, 0xFB, 0xDB, 0x55, 0x79, 0xC0, 0xBD
DB 0x1A, 0x60, 0x32, 0x0A, 0xD6, 0xA1, 0x00, 0xC6, 0x40, 0x2C
DB 0x72, 0x79, 0x67, 0x9F, 0x25, 0xFE, 0xFB, 0x1F, 0xA3, 0xCC
DB 0x8E, 0xA5, 0xE9, 0xF8, 0xDB, 0x32, 0x22, 0xF8, 0x3C, 0x75
DB 0x16, 0xDF, 0xFD, 0x61, 0x6B, 0x15, 0x2F, 0x50, 0x1E, 0xC8
DB 0xAD, 0x05, 0x52, 0xAB, 0x32, 0x3D, 0xB5, 0xFA, 0xFD, 0x23
DB 0x87, 0x60, 0x53, 0x31, 0x7B, 0x48, 0x3E, 0x00, 0xDF, 0x82
DB 0x9E, 0x5C, 0x57, 0xBB, 0xCA, 0x6F, 0x8C, 0xA0, 0x1A, 0x87
DB 0x56, 0x2E, 0xDF, 0x17, 0x69, 0xDB, 0xD5, 0x42, 0xA8, 0xF6
DB 0x28, 0x7E, 0xFF, 0xC3, 0xAC, 0x67, 0x32, 0xC6, 0x8C, 0x4F
DB 0x55, 0x73, 0x69, 0x5B, 0x27, 0xB0, 0xBB, 0xCA, 0x58, 0xC8
DB 0xE1, 0xFF, 0xA3, 0x5D, 0xB8, 0xF0, 0x11, 0xA0, 0x10, 0xFA
DB 0x3D, 0x98, 0xFD, 0x21, 0x83, 0xB8, 0x4A, 0xFC, 0xB5, 0x6C
DB 0x2D, 0xD1, 0xD3, 0x5B, 0x9A, 0x53, 0xE4, 0x79, 0xB6, 0xF8
DB 0x45, 0x65, 0xD2, 0x8E, 0x49, 0xBC, 0x4B, 0xFB, 0x97, 0x90
DB 0xE1, 0xDD, 0xF2, 0xDA, 0xA4, 0xCB, 0x7E, 0x33, 0x62, 0xFB
DB 0x13, 0x41, 0xCE, 0xE4, 0xC6, 0xE8, 0xEF, 0x20, 0xCA, 0xDA
DB 0x36, 0x77, 0x4C, 0x01, 0xD0, 0x7E, 0x9E, 0xFE, 0x2B, 0xF1
DB 0x1F, 0xB4, 0x95, 0xDB, 0xDA, 0x4D, 0xAE, 0x90, 0x91, 0x98
DB 0xEA, 0xAD, 0x8E, 0x71, 0x6B, 0x93, 0xD5, 0xA0, 0xD0, 0x8E
DB 0xD1, 0xD0, 0xAF, 0xC7, 0x25, 0xE0, 0x8E, 0x3C, 0x5B, 0x2F
DB 0x8E, 0x75, 0x94, 0xB7, 0x8F, 0xF6, 0xE2, 0xFB, 0xF2, 0x12
DB 0x2B, 0x64, 0x88, 0x88, 0xB8, 0x12, 0x90, 0x0D, 0xF0, 0x1C
DB 0x4F, 0xAD, 0x5E, 0xA0, 0x68, 0x8F, 0xC3, 0x1C, 0xD1, 0xCF
DB 0xF1, 0x91, 0xB3, 0xA8, 0xC1, 0xAD, 0x2F, 0x2F, 0x22, 0x18
DB 0xBE, 0x0E, 0x17, 0x77, 0xEA, 0x75, 0x2D, 0xFE, 0x8B, 0x02
DB 0x1F, 0xA1, 0xE5, 0xA0, 0xCC, 0x0F, 0xB5, 0x6F, 0x74, 0xE8
DB 0x18, 0xAC, 0xF3, 0xD6, 0xCE, 0x89, 0xE2, 0x99, 0xB4, 0xA8
DB 0x4F, 0xE0, 0xFD, 0x13, 0xE0, 0xB7, 0x7C, 0xC4, 0x3B, 0x81
DB 0xD2, 0xAD, 0xA8, 0xD9, 0x16, 0x5F, 0xA2, 0x66, 0x80, 0x95
DB 0x77, 0x05, 0x93, 0xCC, 0x73, 0x14, 0x21, 0x1A, 0x14, 0x77
DB 0xE6, 0xAD, 0x20, 0x65, 0x77, 0xB5, 0xFA, 0x86, 0xC7, 0x54
DB 0x42, 0xF5, 0xFB, 0x9D, 0x35, 0xCF, 0xEB, 0xCD, 0xAF, 0x0C
DB 0x7B, 0x3E, 0x89, 0xA0, 0xD6, 0x41, 0x1B, 0xD3, 0xAE, 0x1E
DB 0x7E, 0x49, 0x00, 0x25, 0x0E, 0x2D, 0x20, 0x71, 0xB3, 0x5E
DB 0x22, 0x68, 0x00, 0xBB, 0x57, 0xB8, 0xE0, 0xAF, 0x24, 0x64
DB 0x36, 0x9B, 0xF0, 0x09, 0xB9, 0x1E, 0x55, 0x63, 0x91, 0x1D
DB 0x59, 0xDF, 0xA6, 0xAA, 0x78, 0xC1, 0x43, 0x89, 0xD9, 0x5A
DB 0x53, 0x7F, 0x20, 0x7D, 0x5B, 0xA2, 0x02, 0xE5, 0xB9, 0xC5
DB 0x83, 0x26, 0x03, 0x76, 0x62, 0x95, 0xCF, 0xA9, 0x11, 0xC8
DB 0x19, 0x68, 0x4E, 0x73, 0x4A, 0x41, 0xB3, 0x47, 0x2D, 0xCA
DB 0x7B, 0x14, 0xA9, 0x4A, 0x1B, 0x51, 0x00, 0x52, 0x9A, 0x53
DB 0x29, 0x15, 0xD6, 0x0F, 0x57, 0x3F, 0xBC, 0x9B, 0xC6, 0xE4
DB 0x2B, 0x60, 0xA4, 0x76, 0x81, 0xE6, 0x74, 0x00, 0x08, 0xBA
DB 0x6F, 0xB5, 0x57, 0x1B, 0xE9, 0x1F, 0xF2, 0x96, 0xEC, 0x6B
DB 0x2A, 0x0D, 0xD9, 0x15, 0xB6, 0x63, 0x65, 0x21, 0xE7, 0xB9
DB 0xF9, 0xB6, 0xFF, 0x34, 0x05, 0x2E, 0xC5, 0x85, 0x56, 0x64
DB 0x53, 0xB0, 0x2D, 0x5D, 0xA9, 0x9F, 0x8F, 0xA1, 0x08, 0xBA
DB 0x47, 0x99, 0x6E, 0x85, 0x07, 0x6A, 0x4B, 0x7A, 0x70, 0xE9
DB 0xB5, 0xB3, 0x29, 0x44, 0xDB, 0x75, 0x09, 0x2E, 0xC4, 0x19
DB 0x26, 0x23, 0xAD, 0x6E, 0xA6, 0xB0, 0x49, 0xA7, 0xDF, 0x7D
DB 0x9C, 0xEE, 0x60, 0xB8, 0x8F, 0xED, 0xB2, 0x66, 0xEC, 0xAA
DB 0x8C, 0x71, 0x69, 0x9A, 0x17, 0xFF, 0x56, 0x64, 0x52, 0x6C
DB 0xC2, 0xB1, 0x9E, 0xE1, 0x19, 0x36, 0x02, 0xA5, 0x75, 0x09
DB 0x4C, 0x29, 0xA0, 0x59, 0x13, 0x40, 0xE4, 0x18, 0x3A, 0x3E
DB 0x3F, 0x54, 0x98, 0x9A, 0x5B, 0x42, 0x9D, 0x65, 0x6B, 0x8F
DB 0xE4, 0xD6, 0x99, 0xF7, 0x3F, 0xD6, 0xA1, 0xD2, 0x9C, 0x07
DB 0xEF, 0xE8, 0x30, 0xF5, 0x4D, 0x2D, 0x38, 0xE6, 0xF0, 0x25
DB 0x5D, 0xC1, 0x4C, 0xDD, 0x20, 0x86, 0x84, 0x70, 0xEB, 0x26
DB 0x63, 0x82, 0xE9, 0xC6, 0x02, 0x1E, 0xCC, 0x5E, 0x09, 0x68
DB 0x6B, 0x3F, 0x3E, 0xBA, 0xEF, 0xC9, 0x3C, 0x97, 0x18, 0x14
DB 0x6B, 0x6A, 0x70, 0xA1, 0x68, 0x7F, 0x35, 0x84, 0x52, 0xA0
DB 0xE2, 0x86, 0xB7, 0x9C, 0x53, 0x05, 0xAA, 0x50, 0x07, 0x37
DB 0x3E, 0x07, 0x84, 0x1C, 0x7F, 0xDE, 0xAE, 0x5C, 0x8E, 0x7D
DB 0x44, 0xEC, 0x57, 0x16, 0xF2, 0xB8, 0xB0, 0x3A, 0xDA, 0x37
DB 0xF0, 0x50, 0x0C, 0x0D, 0xF0, 0x1C, 0x1F, 0x04, 0x02, 0x00
DB 0xB3, 0xFF, 0xAE, 0x0C, 0xF5, 0x1A, 0x3C, 0xB5, 0x74, 0xB2
DB 0x25, 0x83, 0x7A, 0x58, 0xDC, 0x09, 0x21, 0xBD, 0xD1, 0x91
DB 0x13, 0xF9, 0x7C, 0xA9, 0x2F, 0xF6, 0x94, 0x32, 0x47, 0x73
DB 0x22, 0xF5, 0x47, 0x01, 0x3A, 0xE5, 0xE5, 0x81, 0x37, 0xC2
DB 0xDA, 0xDC, 0xC8, 0xB5, 0x76, 0x34, 0x9A, 0xF3, 0xDD, 0xA7
DB 0xA9, 0x44, 0x61, 0x46, 0x0F, 0xD0, 0x03, 0x0E, 0xEC, 0xC8
DB 0xC7, 0x3E, 0xA4, 0x75, 0x1E, 0x41, 0xE2, 0x38, 0xCD, 0x99
DB 0x3B, 0xEA, 0x0E, 0x2F, 0x32, 0x80, 0xBB, 0xA1, 0x18, 0x3E
DB 0xB3, 0x31, 0x4E, 0x54, 0x8B, 0x38, 0x4F, 0x6D, 0xB9, 0x08
DB 0x6F, 0x42, 0x0D, 0x03, 0xF6, 0x0A, 0x04, 0xBF, 0x2C, 0xB8
DB 0x12, 0x90, 0x24, 0x97, 0x7C, 0x79, 0x56, 0x79, 0xB0, 0x72
DB 0xBC, 0xAF, 0x89, 0xAF, 0xDE, 0x9A, 0x77, 0x1F, 0xD9, 0x93
DB 0x08, 0x10, 0xB3, 0x8B, 0xAE, 0x12, 0xDC, 0xCF, 0x3F, 0x2E
DB 0x55, 0x12, 0x72, 0x1F, 0x2E, 0x6B, 0x71, 0x24, 0x50, 0x1A
DB 0xDD, 0xE6, 0x9F, 0x84, 0xCD, 0x87, 0x7A, 0x58, 0x47, 0x18
DB 0x74, 0x08, 0xDA, 0x17, 0xBC, 0x9F, 0x9A, 0xBC, 0xE9, 0x4B
DB 0x7D, 0x8C, 0xEC, 0x7A, 0xEC, 0x3A, 0xDB, 0x85, 0x1D, 0xFA
DB 0x63, 0x09, 0x43, 0x66, 0xC4, 0x64, 0xC3, 0xD2, 0xEF, 0x1C
DB 0x18, 0x47, 0x32, 0x15, 0xD9, 0x08, 0xDD, 0x43, 0x3B, 0x37
DB 0x24, 0xC2, 0xBA, 0x16, 0x12, 0xA1, 0x4D, 0x43, 0x2A, 0x65
DB 0xC4, 0x51, 0x50, 0x94, 0x00, 0x02, 0x13, 0x3A, 0xE4, 0xDD
DB 0x71, 0xDF, 0xF8, 0x9E, 0x10, 0x31, 0x4E, 0x55, 0x81, 0xAC
DB 0x77, 0xD6, 0x5F, 0x11, 0x19, 0x9B, 0x04, 0x35, 0x56, 0xF1
DB 0xD7, 0xA3, 0xC7, 0x6B, 0x3C, 0x11, 0x18, 0x3B, 0x59, 0x24
DB 0xA5, 0x09, 0xF2, 0x8F, 0xE6, 0xED, 0x97, 0xF1, 0xFB, 0xFA
DB 0x9E, 0xBA, 0xBF, 0x2C, 0x1E, 0x15, 0x3C, 0x6E, 0x86, 0xE3
DB 0x45, 0x70, 0xEA, 0xE9, 0x6F, 0xB1, 0x86, 0x0E, 0x5E, 0x0A
DB 0x5A, 0x3E, 0x2A, 0xB3, 0x77, 0x1F, 0xE7, 0x1C, 0x4E, 0x3D
DB 0x06, 0xFA, 0x29, 0x65, 0xDC, 0xB9, 0x99, 0xE7, 0x1D, 0x0F
DB 0x80, 0x3E, 0x89, 0xD6, 0x52, 0x66, 0xC8, 0x25, 0x2E, 0x4C
DB 0xC9, 0x78, 0x9C, 0x10, 0xB3, 0x6A, 0xC6, 0x15, 0x0E, 0xBA
DB 0x94, 0xE2, 0xEA, 0x78, 0xA5, 0xFC, 0x3C, 0x53, 0x1E, 0x0A
DB 0x2D, 0xF4, 0xF2, 0xF7, 0x4E, 0xA7, 0x36, 0x1D, 0x2B, 0x3D
DB 0x19, 0x39, 0x26, 0x0F, 0x19, 0xC2, 0x79, 0x60, 0x52, 0x23
DB 0xA7, 0x08, 0xF7, 0x13, 0x12, 0xB6, 0xEB, 0xAD, 0xFE, 0x6E
DB 0xEA, 0xC3, 0x1F, 0x66, 0xE3, 0xBC, 0x45, 0x95, 0xA6, 0x7B
DB 0xC8, 0x83, 0xB1, 0x7F, 0x37, 0xD1, 0x01, 0x8C, 0xFF, 0x28
DB 0xC3, 0x32, 0xDD, 0xEF, 0xBE, 0x6C, 0x5A, 0xA5, 0x65, 0x58
DB 0x21, 0x85, 0x68, 0xAB, 0x98, 0x02, 0xEE, 0xCE, 0xA5, 0x0F
DB 0xDB, 0x2F, 0x95, 0x3B, 0x2A, 0xEF, 0x7D, 0xAD, 0x5B, 0x6E
DB 0x2F, 0x84, 0x15, 0x21, 0xB6, 0x28, 0x29, 0x07, 0x61, 0x70
DB 0xEC, 0xDD, 0x47, 0x75, 0x61, 0x9F, 0x15, 0x10, 0x13, 0xCC
DB 0xA8, 0x30, 0xEB, 0x61, 0xBD, 0x96, 0x03, 0x34, 0xFE, 0x1E
DB 0xAA, 0x03, 0x63, 0xCF, 0xB5, 0x73, 0x5C, 0x90, 0x4C, 0x70
DB 0xA2, 0x39, 0xD5, 0x9E, 0x9E, 0x0B, 0xCB, 0xAA, 0xDE, 0x14
DB 0xEE, 0xCC, 0x86, 0xBC, 0x60, 0x62, 0x2C, 0xA7, 0x9C, 0xAB
DB 0x5C, 0xAB, 0xB2, 0xF3, 0x84, 0x6E, 0x64, 0x8B, 0x1E, 0xAF
DB 0x19, 0xBD, 0xF0, 0xCA, 0xA0, 0x23, 0x69, 0xB9, 0x65, 0x5A
DB 0xBB, 0x50, 0x40, 0x68, 0x5A, 0x32, 0x3C, 0x2A, 0xB4, 0xB3
DB 0x31, 0x9E, 0xE9, 0xD5, 0xC0, 0x21, 0xB8, 0xF7, 0x9B, 0x54
DB 0x0B, 0x19, 0x87, 0x5F, 0xA0, 0x99, 0x95, 0xF7, 0x99, 0x7E
DB 0x62, 0x3D, 0x7D, 0xA8, 0xF8, 0x37, 0x88, 0x9A, 0x97, 0xE3
DB 0x2D, 0x77, 0x11, 0xED, 0x93, 0x5F, 0x16, 0x68, 0x12, 0x81
DB 0x0E, 0x35, 0x88, 0x29, 0xC7, 0xE6, 0x1F, 0xD6, 0x96, 0xDE
DB 0xDF, 0xA1, 0x78, 0x58, 0xBA, 0x99, 0x57, 0xF5, 0x84, 0xA5
DB 0x1B, 0x22, 0x72, 0x63, 0x9B, 0x83, 0xC3, 0xFF, 0x1A, 0xC2
DB 0x46, 0x96, 0xCD, 0xB3, 0x0A, 0xEB, 0x53, 0x2E, 0x30, 0x54
DB 0x8F, 0xD9, 0x48, 0xE4, 0x6D, 0xBC, 0x31, 0x28, 0x58, 0xEB
DB 0xF2, 0xEF, 0x34, 0xC6, 0xFF, 0xEA, 0xFE, 0x28, 0xED, 0x61
DB 0xEE, 0x7C, 0x3C, 0x73, 0x5D, 0x4A, 0x14, 0xD9, 0xE8, 0x64
DB 0xB7, 0xE3, 0x42, 0x10, 0x5D, 0x14, 0x20, 0x3E, 0x13, 0xE0
DB 0x45, 0xEE, 0xE2, 0xB6, 0xA3, 0xAA, 0xAB, 0xEA, 0xDB, 0x6C
DB 0x4F, 0x15, 0xFA, 0xCB, 0x4F, 0xD0, 0xC7, 0x42, 0xF4, 0x42
DB 0xEF, 0x6A, 0xBB, 0xB5, 0x65, 0x4F, 0x3B, 0x1D, 0x41, 0xCD
DB 0x21, 0x05, 0xD8, 0x1E, 0x79, 0x9E, 0x86, 0x85, 0x4D, 0xC7
DB 0xE4, 0x4B, 0x47, 0x6A, 0x3D, 0x81, 0x62, 0x50, 0xCF, 0x62
DB 0xA1, 0xF2, 0x5B, 0x8D, 0x26, 0x46, 0xFC, 0x88, 0x83, 0xA0
DB 0xC1, 0xC7, 0xB6, 0xA3, 0x7F, 0x15, 0x24, 0xC3, 0x69, 0xCB
DB 0x74, 0x92, 0x47, 0x84, 0x8A, 0x0B, 0x56, 0x92, 0xB2, 0x85
DB 0x09, 0x5B, 0xBF, 0x00, 0xAD, 0x19, 0x48, 0x9D, 0x14, 0x62
DB 0xB1, 0x74, 0x23, 0x82, 0x0E, 0x00, 0x58, 0x42, 0x8D, 0x2A
DB 0x0C, 0x55, 0xF5, 0xEA, 0x1D, 0xAD, 0xF4, 0x3E, 0x23, 0x3F
DB 0x70, 0x61, 0x33, 0x72, 0xF0, 0x92, 0x8D, 0x93, 0x7E, 0x41
DB 0xD6, 0x5F, 0xEC, 0xF1, 0x6C, 0x22, 0x3B, 0xDB, 0x7C, 0xDE
DB 0x37, 0x59, 0xCB, 0xEE, 0x74, 0x60, 0x40, 0x85, 0xF2, 0xA7
DB 0xCE, 0x77, 0x32, 0x6E, 0xA6, 0x07, 0x80, 0x84, 0x19, 0xF8
DB 0x50, 0x9E, 0xE8, 0xEF, 0xD8, 0x55, 0x61, 0xD9, 0x97, 0x35
DB 0xA9, 0x69, 0xA7, 0xAA, 0xC5, 0x0C, 0x06, 0xC2, 0x5A, 0x04
DB 0xAB, 0xFC, 0x80, 0x0B, 0xCA, 0xDC, 0x9E, 0x44, 0x7A, 0x2E
DB 0xC3, 0x45, 0x34, 0x84, 0xFD, 0xD5, 0x67, 0x05, 0x0E, 0x1E
DB 0x9E, 0xC9, 0xDB, 0x73, 0xDB, 0xD3, 0x10, 0x55, 0x88, 0xCD
DB 0x67, 0x5F, 0xDA, 0x79, 0xE3, 0x67, 0x43, 0x40, 0xC5, 0xC4
DB 0x34, 0x65, 0x71, 0x3E, 0x38, 0xD8, 0x3D, 0x28, 0xF8, 0x9E
DB 0xF1, 0x6D, 0xFF, 0x20, 0x15, 0x3E, 0x21, 0xE7, 0x8F, 0xB0
DB 0x3D, 0x4A, 0xE6, 0xE3, 0x9F, 0x2B, 0xDB, 0x83, 0xAD, 0xF7
DB 0xE9, 0x3D, 0x5A, 0x68, 0x94, 0x81, 0x40, 0xF7, 0xF6, 0x4C
DB 0x26, 0x1C, 0x94, 0x69, 0x29, 0x34, 0x41, 0x15, 0x20, 0xF7
DB 0x76, 0x02, 0xD4, 0xF7, 0xBC, 0xF4, 0x6B, 0x2E, 0xD4, 0xA2
DB 0x00, 0x68, 0xD4, 0x08, 0x24, 0x71, 0x33, 0x20, 0xF4, 0x6A
DB 0x43, 0xB7, 0xD4, 0xB7, 0x50, 0x00, 0x61, 0xAF, 0x1E, 0x39
DB 0xF6, 0x2E, 0x97, 0x24, 0x45, 0x46, 0x14, 0x21, 0x4F, 0x74
DB 0xBF, 0x8B, 0x88, 0x40, 0x4D, 0x95, 0xFC, 0x1D, 0x96, 0xB5
DB 0x91, 0xAF, 0x70, 0xF4, 0xDD, 0xD3, 0x66, 0xA0, 0x2F, 0x45
DB 0xBF, 0xBC, 0x09, 0xEC, 0x03, 0xBD, 0x97, 0x85, 0x7F, 0xAC
DB 0x6D, 0xD0, 0x31, 0xCB, 0x85, 0x04, 0x96, 0xEB, 0x27, 0xB3
DB 0x55, 0xFD, 0x39, 0x41, 0xDA, 0x25, 0x47, 0xE6, 0xAB, 0xCA
DB 0x0A, 0x9A, 0x28, 0x50, 0x78, 0x25, 0x53, 0x04, 0x29, 0xF4
DB 0x0A, 0x2C, 0x86, 0xDA, 0xE9, 0xB6, 0x6D, 0xFB, 0x68, 0xDC
DB 0x14, 0x62, 0xD7, 0x48, 0x69, 0x00, 0x68, 0x0E, 0xC0, 0xA4
DB 0x27, 0xA1, 0x8D, 0xEE, 0x4F, 0x3F, 0xFE, 0xA2, 0xE8, 0x87
DB 0xAD, 0x8C, 0xB5, 0x8C, 0xE0, 0x06, 0x7A, 0xF4, 0xD6, 0xB6
DB 0xAA, 0xCE, 0x1E, 0x7C, 0xD3, 0x37, 0x5F, 0xEC, 0xCE, 0x78
DB 0xA3, 0x99, 0x40, 0x6B, 0x2A, 0x42, 0x20, 0xFE, 0x9E, 0x35
DB 0xD9, 0xF3, 0x85, 0xB9, 0xEE, 0x39, 0xD7, 0xAB, 0x3B, 0x12
DB 0x4E, 0x8B, 0x1D, 0xC9, 0xFA, 0xF7, 0x4B, 0x6D, 0x18, 0x56
DB 0x26, 0xA3, 0x66, 0x31, 0xEA, 0xE3, 0x97, 0xB2, 0x3A, 0x6E
DB 0xFA, 0x74, 0xDD, 0x5B, 0x43, 0x32, 0x68, 0x41, 0xE7, 0xF7
DB 0xCA, 0x78, 0x20, 0xFB, 0xFB, 0x0A, 0xF5, 0x4E, 0xD8, 0xFE
DB 0xB3, 0x97, 0x45, 0x40, 0x56, 0xAC, 0xBA, 0x48, 0x95, 0x27
DB 0x55, 0x53, 0x3A, 0x3A, 0x20, 0x83, 0x8D, 0x87, 0xFE, 0x6B
DB 0xA9, 0xB7, 0xD0, 0x96, 0x95, 0x4B, 0x55, 0xA8, 0x67, 0xBC
DB 0xA1, 0x15, 0x9A, 0x58, 0xCC, 0xA9, 0x29, 0x63, 0x99, 0xE1
DB 0xDB, 0x33, 0xA6, 0x2A, 0x4A, 0x56, 0x3F, 0x31, 0x25, 0xF9
DB 0x5E, 0xF4, 0x7E, 0x1C, 0x90, 0x29, 0x31, 0x7C, 0xFD, 0xF8
DB 0xE8, 0x02, 0x04, 0x27, 0x2F, 0x70, 0x80, 0xBB, 0x15, 0x5C
DB 0x05, 0x28, 0x2C, 0xE3, 0x95, 0xC1, 0x15, 0x48, 0xE4, 0xC6
DB 0x6D, 0x22, 0x48, 0xC1, 0x13, 0x3F, 0xC7, 0x0F, 0x86, 0xDC
DB 0x07, 0xF9, 0xC9, 0xEE, 0x41, 0x04, 0x1F, 0x0F, 0x40, 0x47
DB 0x79, 0xA4, 0x5D, 0x88, 0x6E, 0x17, 0x32, 0x5F, 0x51, 0xEB
DB 0xD5, 0x9B, 0xC0, 0xD1, 0xF2, 0xBC, 0xC1, 0x8F, 0x41, 0x11
DB 0x35, 0x64, 0x25, 0x7B, 0x78, 0x34, 0x60, 0x2A, 0x9C, 0x60
DB 0xDF, 0xF8, 0xE8, 0xA3, 0x1F, 0x63, 0x6C, 0x1B, 0x0E, 0x12
DB 0xB4, 0xC2, 0x02, 0xE1, 0x32, 0x9E, 0xAF, 0x66, 0x4F, 0xD1
DB 0xCA, 0xD1, 0x81, 0x15, 0x6B, 0x23, 0x95, 0xE0, 0x33, 0x3E
DB 0x92, 0xE1, 0x3B, 0x24, 0x0B, 0x62, 0xEE, 0xBE, 0xB9, 0x22
DB 0x85, 0xB2, 0xA2, 0x0E, 0xE6, 0xBA, 0x0D, 0x99, 0xDE, 0x72
DB 0x0C, 0x8C, 0x2D, 0xA2, 0xF7, 0x28, 0xD0, 0x12, 0x78, 0x45
DB 0x95, 0xB7, 0x94, 0xFD, 0x64, 0x7D, 0x08, 0x62, 0xE7, 0xCC
DB 0xF5, 0xF0, 0x54, 0x49, 0xA3, 0x6F, 0x87, 0x7D, 0x48, 0xFA
DB 0xC3, 0x9D, 0xFD, 0x27, 0xF3, 0x3E, 0x8D, 0x1E, 0x0A, 0x47
DB 0x63, 0x41, 0x99, 0x2E, 0xFF, 0x74, 0x3A, 0x6F, 0x6E, 0xAB
DB 0xF4, 0xF8, 0xFD, 0x37, 0xA8, 0x12, 0xDC, 0x60, 0xA1, 0xEB
DB 0xDD, 0xF8, 0x99, 0x1B, 0xE1, 0x4C, 0xDB, 0x6E, 0x6B, 0x0D
DB 0xC6, 0x7B, 0x55, 0x10, 0x6D, 0x67, 0x2C, 0x37, 0x27, 0x65
DB 0xD4, 0x3B, 0xDC, 0xD0, 0xE8, 0x04, 0xF1, 0x29, 0x0D, 0xC7
DB 0xCC, 0x00, 0xFF, 0xA3, 0xB5, 0x39, 0x0F, 0x92, 0x69, 0x0F
DB 0xED, 0x0B, 0x66, 0x7B, 0x9F, 0xFB, 0xCE, 0xDB, 0x7D, 0x9C
DB 0xA0, 0x91, 0xCF, 0x0B, 0xD9, 0x15, 0x5E, 0xA3, 0xBB, 0x13
DB 0x2F, 0x88, 0x51, 0x5B, 0xAD, 0x24, 0x7B, 0x94, 0x79, 0xBF
DB 0x76, 0x3B, 0xD6, 0xEB, 0x37, 0x39, 0x2E, 0xB3, 0xCC, 0x11
DB 0x59, 0x79, 0x80, 0x26, 0xE2, 0x97, 0xF4, 0x2E, 0x31, 0x2D
DB 0x68, 0x42, 0xAD, 0xA7, 0xC6, 0x6A, 0x2B, 0x3B, 0x12, 0x75
DB 0x4C, 0xCC, 0x78, 0x2E, 0xF1, 0x1C, 0x6A, 0x12, 0x42, 0x37
DB 0xB7, 0x92, 0x51, 0xE7, 0x06, 0xA1, 0xBB, 0xE6, 0x4B, 0xFB
DB 0x63, 0x50, 0x1A, 0x6B, 0x10, 0x18, 0x11, 0xCA, 0xED, 0xFA
DB 0x3D, 0x25, 0xBD, 0xD8, 0xE2, 0xE1, 0xC3, 0xC9, 0x44, 0x42
ln_2: DB 0
DB 0xB1, 0x72, 0x17, 0xF7, 0xD1, 0xCF, 0x79, 0xAB, 0xC9, 0xE3
DB 0xB3, 0x98, 0x03, 0xF2, 0xF6, 0xAF, 0x40, 0xF3, 0x43, 0x26
DB 0x72, 0x98, 0xB6, 0x2D, 0x8A, 0x0D, 0x17, 0x5B, 0x8B, 0xAA
DB 0xFA, 0x2B, 0xE7, 0xB8, 0x76, 0x20, 0x6D, 0xEB, 0xAC, 0x98
DB 0x55, 0x95, 0x52, 0xFB, 0x4A, 0xFA, 0x1B, 0x10, 0xED, 0x2E
DB 0xAE, 0x35, 0xC1, 0x38, 0x21, 0x44, 0x27, 0x57, 0x3B, 0x29
DB 0x11, 0x69, 0xB8, 0x25, 0x3E, 0x96, 0xCA, 0x16, 0x22, 0x4A
DB 0xE8, 0xC5, 0x1A, 0xCB, 0xDA, 0x11, 0x31, 0x7C, 0x38, 0x7E
DB 0xB9, 0xEA, 0x9B, 0xC3, 0xB1, 0x36, 0x60, 0x3B, 0x25, 0x6F
DB 0xA0, 0xEC, 0x76, 0x57, 0xF7, 0x4B, 0x72, 0xCE, 0x87, 0xB1
DB 0x9D, 0x65, 0x48, 0xCA, 0xF5, 0xDF, 0xA6, 0xBD, 0x38, 0x30
DB 0x32, 0x48, 0x65, 0x5F, 0xA1, 0x87, 0x2F, 0x20, 0xE3, 0xA2
DB 0xDA, 0x2D, 0x97, 0xC5, 0x0F, 0x3F, 0xD5, 0xC6, 0x07, 0xF4
DB 0xCA, 0x11, 0xFB, 0x5B, 0xFB, 0x90, 0x61, 0x0D, 0x30, 0xF8
DB 0x8F, 0xE5, 0x51, 0xA2, 0xEE, 0x56, 0x9D, 0x6D, 0xFC, 0x1E
DB 0xFA, 0x15, 0x7D, 0x2E, 0x23, 0xDE, 0x14, 0x00, 0xB3, 0x96
DB 0x17, 0x46, 0x07, 0x75, 0xDB, 0x89, 0x90, 0xE5, 0xC9, 0x43
DB 0xE7, 0x32, 0xB4, 0x79, 0xCD, 0x33, 0xCC, 0xCC, 0x4E, 0x65
DB 0x93, 0x93, 0x51, 0x4C, 0x4C, 0x1A, 0x1E, 0x0B, 0xD1, 0xD6
DB 0x09, 0x5D, 0x25, 0x66, 0x9B, 0x33, 0x35, 0x64, 0xA3, 0x37
DB 0x6A, 0x9C, 0x7F, 0x8A, 0x5E, 0x14, 0x8E, 0x82, 0x07, 0x4D
DB 0xB6, 0x01, 0x5C, 0xFE, 0x7A, 0xA3, 0x0C, 0x48, 0x0A, 0x54
DB 0x17, 0x35, 0x0D, 0x2C, 0x95, 0x5D, 0x51, 0x79, 0xB1, 0xE1
DB 0x7B, 0x9D, 0xAE, 0x31, 0x3C, 0xDB, 0x6C, 0x60, 0x6C, 0xB1
DB 0x07, 0x8F, 0x73, 0x5D, 0x1B, 0x2D, 0xB3, 0x1B, 0x5F, 0x50
DB 0xB5, 0x18, 0x50, 0x64, 0xC1, 0x8B, 0x4D, 0x16, 0x2D, 0xB3
DB 0xB3, 0x65, 0x85, 0x3D, 0x75, 0x98, 0xA1, 0x95, 0x1A, 0xE2
DB 0x73, 0xEE, 0x55, 0x70, 0xB6, 0xC6, 0x8F, 0x96, 0x98, 0x34
DB 0x96, 0xD4, 0xE6, 0xD3, 0x30, 0xAF, 0x88, 0x9B, 0x44, 0xA0
DB 0x25, 0x54, 0x73, 0x1C, 0xDC, 0x8E, 0xA1, 0x72, 0x93, 0xD1
DB 0x22, 0x8A, 0x4E, 0xF9, 0x8D, 0x6F, 0x51, 0x77, 0xFB, 0xCF
DB 0x07, 0x55, 0x26, 0x8A, 0x5C, 0x1F, 0x95, 0x38, 0xB9, 0x82
DB 0x61, 0xAF, 0xFD, 0x44, 0x6B, 0x1C, 0xA3, 0xCF, 0x5E, 0x92
DB 0x22, 0xB8, 0x8C, 0x66, 0xD3, 0xC5, 0x42, 0x21, 0x83, 0xED
DB 0xC9, 0x94, 0x21, 0x09, 0x0B, 0xBB, 0x16, 0xFA, 0xF3, 0xD9
DB 0x49, 0xF2, 0x36, 0xE0, 0x2B, 0x20, 0xCE, 0xE8, 0x86, 0xB9
DB 0x05, 0xC1, 0x28, 0xD5, 0x3D, 0x0B, 0xD2, 0xF9, 0x62, 0x13
DB 0x63, 0x19, 0x6A, 0xF5, 0x03, 0x02, 0x00, 0x60, 0xE4, 0x99
DB 0x08, 0x39, 0x1A, 0x0C, 0x57, 0x33, 0x9B, 0xA2, 0xBE, 0xBA
DB 0x7D, 0x05, 0x2A, 0xC5, 0xB6, 0x1C, 0xC4, 0xE9, 0x20, 0x7C
DB 0xEF, 0x2F, 0x0C, 0xE2, 0xD7, 0x37, 0x39, 0x58, 0xD7, 0x62
DB 0x26, 0x58, 0x90, 0x1E, 0x64, 0x6A, 0x95, 0x18, 0x44, 0x60
DB 0xDC, 0x4E, 0x74, 0x87, 0x15, 0x6E, 0x0C, 0x29, 0x24, 0x13
DB 0xD5, 0xE3, 0x61, 0xC1, 0x69, 0x6D, 0xD2, 0x4A, 0xAE, 0xBD
DB 0x47, 0x38, 0x26, 0xFD, 0xA0, 0xC2, 0x38, 0xB9, 0x0A, 0xB1
DB 0x11, 0xBB, 0xBD, 0x67, 0xC7, 0x24, 0x97, 0x2C, 0xD1, 0x8B
DB 0xFB, 0xBD, 0x9D, 0x42, 0x6C, 0x47, 0x20, 0x96, 0xE7, 0x61
DB 0x15, 0xC0, 0x5F, 0x6F, 0x7C, 0xEB, 0xAC, 0x9F, 0x45, 0xAE
DB 0xCE, 0xCB, 0x72, 0xF1, 0x9C, 0x38, 0x33, 0x9D, 0x8F, 0x68
DB 0x26, 0x25, 0x0D, 0xEA, 0x89, 0x1E, 0xF0, 0x7A, 0xFF, 0xF3
DB 0xA8, 0x92, 0x37, 0x4E, 0x17, 0x5E, 0xB4, 0xAF, 0xC8, 0xDA
DB 0xAD, 0xD8, 0x85, 0xDB, 0x6A, 0xB0, 0x3A, 0x49, 0xBD, 0x0D
DB 0xC0, 0xB1, 0xB3, 0x1D, 0x8A, 0x0E, 0x23, 0xFA, 0xC5, 0xE5
DB 0x76, 0x7D, 0xF9, 0x58, 0x84, 0xE0, 0x64, 0x25, 0xA4, 0x15
DB 0x26, 0xFA, 0xC5, 0x1C, 0x3E, 0xA8, 0x44, 0x9F, 0xE8, 0xF7
DB 0x0E, 0xDD, 0x06, 0x2B, 0x1A, 0x63, 0xA6, 0xC4, 0xC6, 0x0C
DB 0x52, 0xAB, 0x33, 0x16, 0x1E, 0x23, 0x84, 0x38, 0x89, 0x7A
DB 0x39, 0xCE, 0x78, 0xB6, 0x3C, 0x9F, 0x36, 0x4F, 0x5B, 0x8A
DB 0xEF, 0x22, 0xEC, 0x2F, 0xEE, 0x6E, 0x08, 0x50, 0xEC, 0xA4
DB 0x2D, 0x06, 0xFB, 0x0C, 0x75, 0xDF, 0x54, 0x97, 0xE0, 0x0C
DB 0x55, 0x4B, 0x03, 0xD7, 0xD2, 0x87, 0x4A, 0x00, 0x0C, 0xA8
DB 0xF5, 0x8D, 0x94, 0xF0, 0x34, 0x1C, 0xBE, 0x2E, 0xC9, 0x21
DB 0x56, 0xC9, 0xF9, 0x49, 0xDB, 0x4A, 0x93, 0x16, 0xF2, 0x81
DB 0x50, 0x1E, 0x53, 0xDA, 0xEC, 0x3F, 0x64, 0xF1, 0xB7, 0x83
DB 0x15, 0x4C, 0x60, 0x32, 0x0E, 0x2F, 0xF7, 0x93, 0x33, 0xCE
DB 0x35, 0x73, 0xFA, 0xCC, 0x5F, 0xDC, 0xF1, 0x17, 0x85, 0x90
DB 0x31, 0x55, 0xBB, 0xD9, 0x0F, 0x02, 0x3B, 0x22, 0x02, 0x24
DB 0xFC, 0xD8, 0x47, 0x1B, 0xF4, 0xF4, 0x45, 0xF0, 0xA8, 0x8A
DB 0x14, 0xF0, 0xCD, 0x97, 0x6E, 0xA3, 0x54, 0xBB, 0x20, 0xCD
DB 0xB5, 0xCC, 0xB3, 0xDB, 0x23, 0x92, 0x88, 0xD5, 0x86, 0x55
DB 0x4E, 0x2A, 0x0E, 0x8A, 0x6F, 0xE5, 0x1A, 0x8C, 0xFA, 0xA7
DB 0x2E, 0xF2, 0xAD, 0x8A, 0x43, 0xDC, 0x42, 0x12, 0xB2, 0x10
DB 0xB7, 0x79, 0xDF, 0xE4, 0x9D, 0x73, 0x07, 0xCC, 0x84, 0x65
DB 0x32, 0xE4, 0xB9, 0x69, 0x4E, 0xDA, 0xD1, 0x62, 0xAF, 0x05
DB 0x3B, 0x17, 0x51, 0xF3, 0xA3, 0xD0, 0x91, 0xF6, 0x56, 0x65
DB 0x81, 0x54, 0x12, 0xB5, 0xE8, 0xC2, 0x02, 0x46, 0x10, 0x69
DB 0xAC, 0x14, 0xB9, 0x58, 0x78, 0x49, 0x34, 0xB8, 0xD6, 0xCC
DB 0xE1, 0xDA, 0xA5, 0x05, 0x37, 0x01, 0x1A, 0xA4, 0xFB, 0x42
DB 0xB9, 0xA3, 0xDE, 0xF4, 0x1B, 0xDA, 0x1F, 0x85, 0xEF, 0x6F
DB 0xDB, 0xF2, 0xF2, 0xD8, 0x9D, 0x2A, 0x4B, 0x18, 0x35, 0x27
DB 0x8F, 0xD9, 0x40, 0x57, 0x89, 0xF4, 0x56, 0x81, 0x2B, 0x55
DB 0x28, 0x79, 0xA6, 0x16, 0x86, 0x95, 0xC1, 0x29, 0x63, 0xB0
DB 0xFF, 0x01, 0xEA, 0xAB, 0x73, 0xE5, 0xB5, 0xC1, 0x58, 0x53
DB 0x18, 0xE7, 0x62, 0x4F, 0x14, 0xA5, 0x1A, 0x4A, 0x02, 0x6B
DB 0x68, 0x08, 0x29, 0x20, 0x57, 0xFD, 0x99, 0xB6, 0x6D, 0xC0
DB 0x85, 0xA9, 0x8A, 0xC8, 0xD8, 0xCA, 0xF9, 0xEE, 0xEE, 0xA9
DB 0x8A, 0x24, 0x00, 0xCA, 0xC9, 0x5F, 0x26, 0x0F, 0xD1, 0x00
DB 0x36, 0xF9, 0xF9, 0x10, 0x96, 0xAC, 0x31, 0x95, 0x22, 0x0A
DB 0x1A, 0x35, 0x6B, 0x2A, 0x73, 0xB7, 0xEA, 0xAD, 0xAF, 0x6D
DB 0x60, 0x58, 0x71, 0xEF, 0x7A, 0xFB, 0x80, 0xBC, 0x42, 0x34
DB 0x33, 0x56, 0x2E, 0x94, 0xB1, 0x2D, 0xFA, 0xB4, 0x14, 0x45
DB 0x15, 0x79, 0xDF, 0x59, 0xEA, 0xE0, 0x51, 0x70, 0x70, 0x62
DB 0x40, 0x12, 0xA8, 0x29, 0x62, 0xC5, 0x9C, 0xAB, 0x34, 0x7F
DB 0x83, 0x04, 0xD8, 0x89, 0x65, 0x9E, 0x5A, 0x91, 0x39, 0xDB
DB 0x14, 0xEF, 0xCC, 0x30, 0x85, 0x2B, 0xE3, 0xE8, 0xFC, 0x99
DB 0xF1, 0x4D, 0x1D, 0x82, 0x2D, 0xD6, 0xE2, 0xF7, 0x67, 0x97
DB 0xE3, 0x02, 0x19, 0xC8, 0xAA, 0x9C, 0xE8, 0x84, 0x8A, 0x88
DB 0x6E, 0xB3, 0xC8, 0x7B, 0x72, 0x95, 0x98, 0x80, 0x12, 0xE8
DB 0x31, 0x41, 0x86, 0xED, 0xBA, 0xF8, 0x68, 0x56, 0xCC, 0xD3
DB 0xC3, 0xB6, 0xEE, 0x94, 0xE6, 0x2F, 0x11, 0x0A, 0x67, 0x83
DB 0xD2, 0xAA, 0xE8, 0x9C, 0xCC, 0x3B, 0x76, 0xFC, 0x43, 0x5A
DB 0x0C, 0xE1, 0x34, 0xC2, 0x83, 0x8F, 0xD5, 0x71, 0xEC, 0x6C
DB 0x13, 0x66, 0xA9, 0x92, 0xCB, 0xB9, 0xAC, 0x40, 0x7D, 0xDB
DB 0x6C, 0x13, 0xA4, 0xB8, 0xD1, 0xEC, 0xF7, 0x56, 0x7E, 0xB0
DB 0x97, 0x1C, 0xC9, 0x0B, 0x55, 0x18, 0x56, 0x9F, 0x14, 0x4E
DB 0x67, 0xEB, 0xE9, 0xB4, 0x26, 0x98, 0xFE, 0xA7, 0x9D, 0x89
DB 0xD5, 0xC5, 0xED, 0x40, 0xAC, 0x5E, 0x37, 0x01, 0xD7, 0xD7
DB 0x72, 0x53, 0x77, 0xCF, 0x06, 0x56, 0x90, 0x7F, 0xB9, 0xB1
DB 0xB1, 0x6E, 0xA8, 0x91, 0x1A, 0xFB, 0xF1, 0xAE, 0x5A, 0x66
DB 0x20, 0x3D, 0x62, 0xFD, 0x1E, 0x70, 0x93, 0x43, 0x5B, 0x9C
DB 0x27, 0x77, 0x36, 0xA7, 0x0F, 0xA8, 0x60, 0x1C, 0xF6, 0x86
DB 0x8A, 0x05, 0x5B, 0x22, 0x38, 0x67, 0x7A, 0x2B, 0xFB, 0xBD
DB 0x84, 0x3B, 0xFA, 0x18, 0x73, 0xF0, 0xC4, 0x46, 0xB0, 0x1B
DB 0x2A, 0xE0, 0xE9, 0x8E, 0x0E, 0x15, 0x27, 0xA9, 0x00, 0xB1
DB 0xAF, 0x5E, 0x75, 0xF8, 0x7C, 0x7C, 0xD1, 0x7A, 0xF8, 0x04
DB 0xD9, 0x33, 0xD6, 0xF7, 0xE1, 0xB9, 0xE1, 0x90, 0x3D, 0x71
DB 0xC7, 0xBB, 0xA0, 0x28, 0x11, 0x37, 0x60, 0x90, 0xDD, 0x61
DB 0x73, 0x35, 0xDF, 0xDD, 0x42, 0x4F, 0x2B, 0x66, 0x1C, 0xD8
DB 0x50, 0x63, 0x03, 0x4E, 0x34, 0x1B, 0x06, 0xE2, 0x11, 0x97
DB 0x7B, 0x07, 0x5A, 0x8B, 0x78, 0x08, 0xDF, 0x43, 0xBD, 0x8E
DB 0xEF, 0x1F, 0xD9, 0x67, 0x8C, 0xC0, 0xB5, 0xE9, 0xF6, 0x0A
DB 0x3E, 0xB8, 0x17, 0x47, 0xF8, 0x7E, 0x57, 0x09, 0x46, 0x8D
DB 0x78, 0xEB, 0xD2, 0xDA, 0x01, 0x16, 0xE6, 0xB6, 0x5A, 0xEB
DB 0x3B, 0xE7, 0x7E, 0xE2, 0x36, 0xFD, 0xC3, 0x3B, 0xC8, 0xE7
DB 0xDF, 0x1F, 0xFC, 0x2E, 0x22, 0x88, 0xF8, 0xCA, 0x9A, 0xEE
DB 0x5B, 0x60, 0x89, 0x9D, 0x52, 0x24, 0x7F, 0x4C, 0xE0, 0xB6
DB 0xFF, 0xD8, 0xB9, 0x47, 0x81, 0x76, 0x42, 0xC6, 0xF2, 0x24
DB 0xF7, 0x0F, 0x88, 0x25, 0x5E, 0x1C, 0x08, 0x39, 0xCB, 0xCB
DB 0xDD, 0x82, 0x6C, 0x5D, 0x37, 0x70, 0x06, 0x7E, 0x3E, 0x08
DB 0xEB, 0x67, 0x9C, 0x1D, 0xB7, 0xFF, 0xC1, 0x68, 0x42, 0x23
DB 0xD7, 0xC6, 0xE6, 0x81, 0x15, 0xA2, 0x83, 0x22, 0x91, 0xFF
DB 0x14, 0xFC, 0x9D, 0xB2, 0x5D, 0xA9, 0xBE, 0xCC, 0xB4, 0xC2
DB 0x75, 0x33, 0xE7, 0x47, 0xD9, 0x04, 0x7F, 0x55, 0xC9, 0x01
DB 0xAF, 0xF6, 0x4A, 0x09, 0xC4, 0x5B, 0xE2, 0xC7, 0x3E, 0x6F
DB 0xDC, 0x29, 0x69, 0x6E, 0x22, 0x68, 0xA5, 0xE0, 0xC9, 0x2F
DB 0x51, 0x81, 0x95, 0xDB, 0xBD, 0x18, 0xC4, 0xEF, 0x70, 0x2D
DB 0x6C, 0x55, 0x01, 0x31, 0x6D, 0xED, 0x1F, 0x3E, 0x55, 0x85
DB 0xF6, 0xDD, 0xD1, 0x3A, 0x05, 0x95, 0x46, 0x94, 0x87, 0x0E
DB 0x71, 0xC1, 0x94, 0xCB, 0xC4, 0x39, 0x62, 0xE1, 0x12, 0xEE
DB 0x67, 0x99, 0x0C, 0x36, 0x31, 0x21, 0x77, 0xD1, 0xB7, 0xB1
DB 0xA7, 0x69, 0xF8, 0x87, 0x32, 0x4B, 0x53, 0xDE, 0x1A, 0x4C
DB 0x99, 0xC9, 0xA0, 0x92, 0xC1, 0x06, 0xC3, 0xCE, 0x35, 0xB9
DB 0x48, 0xCB, 0x52, 0x53, 0xD6, 0x6A, 0xE9, 0x9D, 0x7E, 0xFB
DB 0xEA, 0x3D, 0x9E, 0x7F, 0x58, 0x62, 0x17, 0xAE, 0xB4, 0x06
DB 0x8A, 0xEE, 0xDE, 0x38, 0x4F, 0xA8, 0x8B, 0x87, 0xFD, 0x03
DB 0x63, 0x81, 0xA7, 0x43, 0x42, 0xDA, 0x7A, 0x6E, 0xD2, 0x65
DB 0x8A, 0xDE, 0xA5, 0xEE, 0x41, 0x4C, 0xBC, 0x1B, 0xB5, 0xF5
DB 0x05, 0xD2, 0x20, 0xA7, 0x04, 0x3A, 0x07, 0x42, 0x28, 0x1B
DB 0x03, 0xF8, 0x1F, 0xC6, 0x47, 0x39, 0x30, 0xFF, 0x7C, 0x84
DB 0x7E, 0x90, 0xA3, 0x73, 0xF5, 0xA9, 0xA5, 0x27, 0xBD, 0x44
DB 0x47, 0xAD, 0xB7, 0xD1, 0x9C, 0x45, 0xE2, 0x71, 0x5D, 0x3D
DB 0x15, 0xC2, 0x98, 0x57, 0x0B, 0x15, 0x2C, 0xEC, 0x2F, 0xBD
DB 0x58, 0x2D, 0xC4, 0x6A, 0xE7, 0x26, 0xE4, 0x9E, 0x3C, 0x7C
DB 0x33, 0x4B, 0x5E, 0xFD, 0xB4, 0xC6, 0xFA, 0x45, 0x07, 0xBA
DB 0x00, 0x26, 0x76, 0x1A, 0x68, 0x0B, 0x77, 0xF6, 0xCA, 0xB5
DB 0xED, 0x37, 0x6D, 0x10, 0x58, 0x39, 0xF0, 0x31, 0x92, 0x22
DB 0xBE, 0x8F, 0xDB, 0x67, 0x92, 0x68, 0x9F, 0xF1, 0x58, 0xA5
DB 0x99, 0x08, 0xF1, 0x67, 0x07, 0x76, 0x73, 0x8A, 0xF2, 0x0F
DB 0x3C, 0xCF, 0x6D, 0x58, 0x2B, 0xA8, 0xC6, 0x12, 0x0D, 0xA6
DB 0xA6, 0x49, 0xA5, 0x57, 0x83, 0xCE, 0x13, 0x4A, 0x42, 0xBB
DB 0xAF, 0xAE, 0x7D, 0xAC, 0x1D, 0x53, 0x87, 0xBF, 0x01, 0x8D
DB 0x2B, 0x31, 0x01, 0x22, 0x34, 0x78, 0x59, 0x28, 0xDC, 0xDB
DB 0x04, 0x1E, 0x93, 0x25, 0xB4, 0xAF, 0x62, 0x1A, 0x8A, 0x55
DB 0x5E, 0x27, 0x6A, 0x31, 0x41, 0xF6, 0x01, 0xE3, 0xBD, 0x2B
DB 0xCB, 0x98, 0x56, 0xB2, 0x9F, 0xAD, 0xC8, 0xEC, 0x1B, 0x2F
DB 0x45, 0xA1, 0x62, 0x99, 0xE5, 0xAC, 0xFA, 0x4D, 0x76, 0x8E
DB 0xE2, 0xFE, 0x52, 0x71, 0x57, 0xFF, 0xCD, 0x4A, 0x70, 0xAA
DB 0x1E, 0xDF, 0x64, 0x10, 0x11, 0x0B, 0xD6, 0x15, 0xE2, 0x57
DB 0xA2, 0x03, 0xF7, 0x6E, 0xD0, 0xE7, 0x90, 0x70, 0xD2, 0x0A
DB 0x75, 0x1F, 0xCC, 0x43, 0xA7, 0xC4, 0x11, 0x79, 0x05, 0x7F
DB 0xC4, 0x50, 0xDC, 0xA7, 0xA9, 0x02, 0x47, 0x84, 0xBE, 0x09
DB 0xF6, 0x09, 0xEE, 0xC9, 0x04, 0x43, 0x85, 0x0A, 0xCA, 0x3B
DB 0xED, 0x5F, 0x3D, 0x14, 0xAF, 0x70, 0x7B, 0xB0, 0x95, 0xAF
DB 0x93, 0x1C, 0xF8, 0x31, 0x7D, 0x02, 0xA3, 0x73, 0x4A, 0xD2
DB 0xCC, 0x11, 0x4B, 0xFF, 0x03, 0xD0, 0x60, 0x4A, 0x99, 0x8E
DB 0x01, 0x95, 0x0B, 0x82, 0xE6, 0x86, 0xCE, 0x94, 0xA8, 0x38
DB 0xEE, 0x11, 0x68, 0x96, 0x88, 0xD0, 0xFD, 0x96, 0x7D, 0x06
DB 0xBD, 0xA5, 0xB7, 0x2A, 0xA6, 0x13, 0xFA, 0x22, 0x0B, 0xBD
DB 0xEC, 0x99, 0x5C, 0x53, 0xEF, 0xAD, 0xE3, 0x56, 0xED, 0x90
DB 0xB7, 0xA9, 0x43, 0xFD, 0x28, 0x0F, 0xCE, 0x7D, 0xF5, 0x1D
DB 0x60, 0x7B, 0x1B, 0x85, 0x53, 0x5B, 0x4C, 0xE9, 0x34, 0x3F
DB 0x67, 0x1D, 0x48, 0x77, 0xFC, 0x71, 0x94, 0xCC, 0xC4, 0xCD
DB 0xFE, 0xFC, 0x08, 0xEA, 0x6D, 0xA2, 0x46, 0x40, 0xBB, 0xE2
DB 0xBA, 0x0F, 0x2B, 0x9F, 0x73, 0xAD, 0x3D, 0xDA, 0x75, 0x60
DB 0x93, 0x22, 0x47, 0xFF, 0x56, 0x56, 0x34, 0x67, 0xF3, 0x20
DB 0x18, 0xE1, 0x4F, 0xE4, 0x6C, 0x75, 0xA4, 0x4A, 0x4D, 0x5D
DB 0x7E, 0x8D, 0xAB, 0x6B, 0xB6, 0xDB, 0xF8, 0xBC, 0x4E, 0x6D
DB 0x07, 0xF9, 0xE7, 0xD9, 0x93, 0xD8, 0x99, 0x57, 0x23, 0x81
DB 0x57, 0xFB, 0xEF, 0xFA, 0x03, 0x45, 0xB5, 0xAA, 0xB3, 0xD1
DB 0xFE, 0xED, 0xCB, 0x09, 0xF1, 0x4C, 0x40, 0x25, 0x7B, 0x2B
DB 0x7F, 0x30, 0x8E, 0xB7, 0x99, 0xAB, 0x4C, 0x95, 0xD1, 0xA1
DB 0xED, 0x94, 0xBD, 0xDA, 0x0B, 0x62, 0x5F, 0x39, 0xC4, 0xC8
DB 0x6F, 0xC5, 0xEE, 0x57, 0x48, 0x04, 0x1D, 0x64, 0x7A, 0xEF
DB 0xCB, 0x7A, 0xF2, 0x26, 0xFE, 0x13, 0x82, 0x99, 0x7D, 0x87
DB 0xB2, 0x21, 0x99, 0xE9, 0x12, 0xC3, 0xE3, 0xF5, 0x3D, 0xB5
DB 0xA7, 0x20, 0x8E, 0x03, 0x52, 0xBB, 0x66, 0xB3, 0x79, 0x77
DB 0x8C, 0xEE, 0x2E, 0xC9, 0xAF, 0x2D, 0x87, 0x31, 0x11, 0x9F
DB 0x38, 0xBD, 0x9D, 0x90, 0xD4, 0x3E, 0x05, 0x4D, 0x8B, 0x71
DB 0xFC, 0x0C, 0x0D, 0x10, 0x99, 0x0E, 0x84, 0xC3, 0x32, 0x02
DB 0xEC, 0xC9, 0xFE, 0xD5, 0x1F, 0x62, 0x63, 0x93, 0xCC, 0xC5
DB 0x66, 0x84, 0x03, 0x67, 0xAE, 0x0B, 0x74, 0xCB, 0x4D, 0xBF
DB 0xE4, 0xCE, 0xBD, 0x7F, 0xE7, 0x4B, 0x8D, 0xE2, 0xAA, 0x91
DB 0x76, 0xBD, 0xB5, 0x00, 0x61, 0x3E, 0xE2, 0xAC, 0x34, 0xE4
DB 0xE9, 0xE7, 0x87, 0xB4, 0xC2, 0x9E, 0x7F, 0xB2, 0x08, 0xA9
DB 0xDD, 0x9C, 0x92, 0xF0, 0x02, 0xCA, 0x30, 0xF8, 0x33, 0xF5
DB 0x60, 0x93, 0xC1, 0x84, 0x8B, 0xDE, 0x22, 0xA0, 0xBD, 0xAD
DB 0x10, 0x22, 0x21, 0x80, 0x95, 0xF2, 0xB8, 0x63, 0xB0, 0x6C
DB 0xCA, 0x87, 0x9F, 0x0B, 0xC8, 0xD7, 0x73, 0xA5, 0x28, 0x1E
DB 0xEF, 0xA8, 0x11, 0x77, 0x4A, 0x66, 0x64, 0xB9, 0xF1, 0xB1
DB 0x2A, 0x25, 0xC5, 0x4E, 0xB9, 0xD9, 0x07, 0x73, 0x5D, 0x44
DB 0x1C, 0x77, 0xE8, 0x42, 0x7C, 0xDA, 0x02, 0xB7, 0x50, 0x8D
DB 0x45, 0x49, 0x5B, 0x4E, 0xC1, 0xB2, 0xE6, 0xB8, 0x5E, 0x8D
DB 0x75, 0x1A, 0x8F, 0x7D, 0xD2, 0x71, 0xEE, 0x0E, 0xC8, 0xDC
DB 0xE8, 0xB6, 0x35, 0x96, 0x53, 0x3F, 0xC2, 0x41, 0xFE, 0x15
DB 0xA9, 0xCF, 0xA5, 0xAB, 0xD5, 0x73, 0x5A, 0xED, 0x99, 0x93
DB 0x7F, 0x74, 0x09, 0x36, 0x9A, 0x1B, 0x26, 0x32, 0x1B, 0xD1
DB 0x35, 0x0E, 0xCB, 0xF2, 0x1C, 0x45, 0x4C, 0x1D, 0xA1, 0x19
DB 0xC7, 0x12, 0x16, 0xD7, 0x3E, 0x8E, 0xC5, 0xDD, 0x5C, 0x59
DB 0x27, 0x9D, 0x16, 0xF2, 0xD3, 0xFF, 0x84, 0x47, 0xCD, 0x6A
DB 0xCD, 0x1F, 0x8D, 0x6B, 0x54, 0x71, 0x95, 0x49, 0xA7, 0xC2
DB 0xBB, 0x38, 0xAE, 0xF7, 0xE6, 0x7C, 0x20, 0x08, 0xBC, 0xD7
DB 0x89, 0x24, 0xBA, 0x55, 0x75, 0xDB, 0xAE, 0x31, 0xF6, 0x54
DB 0x9F, 0x33, 0x7C, 0x9C, 0x24, 0x49, 0x07, 0x04, 0xA3, 0x44
DB 0x0C, 0x51, 0x3E, 0xF2, 0xB9, 0xC7, 0x30, 0xC6, 0xF6, 0x4C
DB 0x03, 0x1C, 0x91, 0x3B, 0x81, 0x86, 0xC5, 0xEE, 0x43, 0xA2
DB 0x62, 0x7E, 0xF4, 0x52, 0xA9, 0x43, 0x58, 0xB2, 0x69, 0x65
DB 0xA8, 0x48, 0xD4, 0x12, 0x9A, 0xF7, 0x2E, 0xD3, 0xB4, 0xEC
DB 0x0D, 0x1A, 0x20, 0x60, 0x62, 0x00, 0x67, 0x86, 0x2B, 0x47
DB 0xDE, 0xF3, 0x6E, 0xA6, 0x6B, 0xC4, 0x81, 0xA4, 0x32, 0x68
DB 0x77, 0x8C, 0x0E, 0x17, 0x6D, 0x3A, 0x2F, 0x7C, 0x12, 0xA6
DB 0x9D, 0xD6, 0x54, 0x31, 0x4A, 0xFC, 0xA2, 0x07, 0xA0, 0xC1
DB 0xF9, 0x00, 0xA2, 0xC7, 0xAC, 0xB9, 0xAA, 0x69, 0x58, 0x70
DB 0x19, 0x31, 0x03, 0xD8, 0x87, 0xB8, 0xD0, 0xD1, 0x6B, 0xFF
DB 0x66, 0x22, 0x9B, 0x1D, 0x5C, 0x71, 0xE4, 0x0B, 0xB1, 0x96
DB 0xE5, 0xA5, 0xA8, 0x7A, 0xEA, 0x56, 0x00, 0x1F, 0x36, 0xAA
DB 0x98, 0xB3, 0x4A, 0x93, 0x53, 0xF8, 0x87, 0x5C, 0xA6, 0x6F
DB 0xCF, 0x6E, 0x80, 0xEB, 0xEB, 0x0C, 0x22, 0xFC, 0x51, 0x10
DB 0x40, 0xD7, 0x66, 0xF3, 0x8A, 0x91, 0xD1, 0x8E, 0xB2, 0xC5
DB 0xF0, 0x2E, 0x9A, 0xAA, 0xAE, 0xD8, 0xDA, 0xF4, 0x9B, 0xDC
DB 0x90, 0xA7, 0xC8, 0x11, 0x7A, 0xA4, 0xAC, 0xC8, 0xA6, 0x02
DB 0x89, 0xCA, 0x3C, 0xB5, 0xB5, 0x44, 0x57, 0xE1, 0x39, 0x1C
DB 0x8F, 0x7D, 0x31, 0x05, 0x4E, 0x5B, 0x58, 0xF5, 0x0A, 0xC7
DB 0x6E, 0xC5, 0x66, 0x20, 0xCC, 0xA6, 0x48, 0x97, 0x2F, 0x6D
DB 0xC0, 0x8E, 0x00, 0xCE, 0x59, 0xD5, 0xDB, 0x3A, 0x89, 0x08
DB 0x50, 0x24, 0xA9, 0xB4, 0xBF, 0x7F, 0xB0, 0x13, 0xEC, 0xA9
DB 0x2E, 0x5C, 0x1C, 0x83, 0x68, 0xF1, 0xD8, 0xC1, 0x3D, 0x87
DB 0xB3, 0x77, 0xE6, 0xF3, 0xCA, 0x18, 0x06, 0x0A, 0xFE, 0x25
DB 0x42, 0xBE, 0x41, 0xC4, 0x83, 0xBE, 0x5D, 0xCA, 0x1A, 0x3F
DB 0xC1, 0x0C, 0xC4, 0x65, 0xDA, 0x62, 0x74, 0x04, 0x38, 0x27
DB 0x96, 0x76, 0x04, 0xF4, 0x09, 0xA1, 0xFB, 0xAE, 0xB8, 0xA5
DB 0xE4, 0xF1, 0xFE, 0x54, 0x41, 0xD2, 0x86, 0x43, 0xFD, 0x2D
DB 0x6D, 0x64, 0xDA, 0x55, 0xB7, 0x46, 0xA4, 0xF3, 0xD2, 0x18
DB 0x7E, 0xFA, 0xDE, 0x66, 0xC0, 0xBF, 0x8E, 0xDB, 0x27, 0x1E
DB 0x34, 0xD7, 0x1A, 0xD4, 0x3D, 0x43, 0xE5, 0xBA, 0xCA, 0x7F
DB 0x76, 0x9E, 0x2B, 0xA1, 0xC2, 0x72, 0xA4, 0x9D, 0xE8, 0x19
DB 0x10, 0xE8, 0xB6, 0x02, 0xE9, 0x67, 0x1B, 0xE8, 0x20, 0x31
DB 0x49, 0x1D, 0x74, 0xFB, 0x17, 0x05, 0x1B, 0xDB, 0x41, 0x1A
DB 0x86, 0xC5, 0x89, 0x7C, 0x13, 0x3A, 0x47, 0x48, 0x55, 0x97
DB 0xEE, 0xA6, 0x9D, 0x95, 0xA1, 0x26, 0x8B, 0xFE, 0x49, 0x14
DB 0x09, 0xE6, 0xE3, 0xF9, 0xD2, 0xAA, 0x2D, 0xFB, 0x55, 0x70
DB 0x09, 0x7E, 0xE1, 0xD4, 0x2C, 0x07, 0xEE, 0x5A, 0x2D, 0x67
DB 0x3D, 0xD9, 0xAC, 0xAD, 0x6B, 0x02, 0x69, 0x39, 0x40, 0x56
DB 0xC8, 0x0D, 0xC2, 0xB5, 0xB6, 0xC2, 0x39, 0xB3, 0x55, 0xA0
DB 0xBF, 0xAA, 0xA4, 0xD8, 0xB1, 0x2B, 0x86, 0xF4, 0x27, 0xB5
DB 0xBF, 0xC1, 0x59, 0xF1, 0x2D, 0x27, 0x32, 0xFB, 0x9D, 0x53
DB 0x6B, 0x06, 0x2E, 0x90, 0x4D, 0x70, 0xA7, 0x8A, 0xE8, 0x8F
DB 0x14, 0x2D, 0x27, 0x57, 0xAD, 0xEF, 0x78, 0x3B, 0x74, 0xA7
DB 0x6C, 0x7E, 0x2A, 0xD8, 0x45, 0x62, 0xA4, 0x78, 0xE0, 0x8A
DB 0x97, 0x8D, 0xCC, 0x2C, 0x0E, 0xE3, 0xB6, 0x0D, 0x5A, 0xB4
DB 0x3F, 0xED, 0x28, 0x6D, 0x8A, 0xC9, 0x92, 0xC9, 0x91, 0x8E
DB 0x5F, 0x23, 0x22, 0xE2, 0x2E, 0xA4, 0x8D, 0x7D, 0xE9, 0x50
DB 0x45, 0x46, 0xFE, 0x52, 0x3C, 0xF5, 0x9F, 0x15, 0xD5, 0x7E
DB 0x0C, 0x6A, 0x27, 0xC0, 0x09, 0xCB, 0xA9, 0x2F, 0xDD, 0x34
ln_10: DB 2
DB 0x4D, 0x76, 0x37, 0x76, 0xAA, 0xA2, 0xB0, 0x5B, 0xA9, 0x5B
DB 0x58, 0xAE, 0x0B, 0x4C, 0x28, 0xA3, 0x8A, 0x3F, 0xB3, 0xE7
DB 0x69, 0x77, 0xE4, 0x3A, 0x0F, 0x18, 0x7A, 0x08, 0x07, 0xC0
DB 0xB5, 0xCA, 0x58, 0xBC, 0x0B, 0x5E, 0xC6, 0xA0, 0x41, 0x73
DB 0x31, 0xC3, 0x2F, 0x00, 0xB1, 0x7C, 0x35, 0xA0, 0xB1, 0x88
DB 0x90, 0x61, 0x04, 0x2F, 0x8B, 0x6B, 0xEE, 0x3D, 0xE2, 0x10
DB 0x0B, 0x94, 0x5B, 0x59, 0xE0, 0xB3, 0xE2, 0x8A, 0x2A, 0x32
DB 0x44, 0x79, 0xD9, 0x6A, 0x9B, 0x0E, 0xC3, 0x60, 0xC7, 0xEF
DB 0xBD, 0x9B, 0x3A, 0xC1, 0x2A, 0xCF, 0x1B, 0xE9, 0x45, 0x86
DB 0xED, 0x27, 0x48, 0x67, 0x1E, 0xEF, 0x29, 0x9E, 0xCD, 0x6C
DB 0x8D, 0x81, 0x42, 0x16, 0x3A, 0x4C, 0xDA, 0x35, 0x11, 0xE2
DB 0x71, 0x3D, 0x6C, 0x22, 0xC1, 0x5F, 0x57, 0xB7, 0x88, 0x3D
DB 0x1A, 0x7A, 0x96, 0x3A, 0x4C, 0x17, 0xA6, 0x07, 0x89, 0x1E
DB 0x3F, 0x2A, 0xB4, 0xEB, 0xBA, 0x62, 0x73, 0x56, 0xD0, 0xB9
DB 0xA8, 0x9C, 0x58, 0x66, 0x91, 0xFB, 0x2C, 0x9A, 0x5E, 0x31
DB 0x75, 0x3F, 0x6C, 0x74, 0xA3, 0xA9, 0x5F, 0x53, 0xF7, 0x03
DB 0x90, 0x2F, 0xCF, 0x30, 0x78, 0x50, 0x49, 0xA9, 0x15, 0xD9
DB 0x73, 0x78, 0x9A, 0x0C, 0xE7, 0x6F, 0xD1, 0xFE, 0xA5, 0xB7
DB 0xAC, 0x9C, 0x41, 0x82, 0xBE, 0x21, 0x21, 0xBA, 0xA6, 0xDD
DB 0x00, 0x78, 0xF7, 0xF4, 0xF1, 0x45, 0xD2, 0x39, 0xB5, 0xB8
DB 0xE1, 0x23, 0x23, 0x49, 0x7E, 0xBC, 0x6F, 0x2B, 0xA2, 0x01
DB 0x1F, 0xC5, 0xEC, 0x36, 0x6D, 0x42, 0xA5, 0x27, 0xAA, 0xAB
DB 0x7D, 0xA7, 0xA2, 0x97, 0xDD, 0xF8, 0xDD, 0x81, 0x3A, 0x50
DB 0xE5, 0x83, 0x8E, 0x29, 0x5C, 0x03, 0xFF, 0x78, 0xB6, 0xC6
DB 0xB5, 0xAF, 0xEF, 0xFF, 0x60, 0x86, 0xE8, 0x29, 0x32, 0xC1
DB 0x19, 0xB5, 0x86, 0xE9, 0x92, 0x3B, 0xBE, 0x67, 0x23, 0x97
DB 0xDA, 0x5D, 0x3C, 0xD8, 0xE6, 0x0A, 0x9E, 0x32, 0x91, 0x77
DB 0x7F, 0x20, 0x25, 0x09, 0x85, 0xE0, 0x64, 0x49, 0xE9, 0xB8
DB 0xED, 0xC3, 0xF3, 0x68, 0xB5, 0xCC, 0xB5, 0x1E, 0xD7, 0x92
DB 0xC7, 0x23, 0x03, 0x96, 0x84, 0x2A, 0xA9, 0x98, 0x12, 0x94
DB 0xC9, 0x3B, 0x0F, 0x72, 0xF1, 0x93, 0xAA, 0x01, 0xB8, 0x66
DB 0x15, 0x98, 0x7C, 0x74, 0xD9, 0xB0, 0x81, 0x98, 0xE0, 0xD1
DB 0x35, 0x7A, 0x10, 0xFC, 0x81, 0x90, 0xAE, 0x5C, 0x29, 0x8B
DB 0x46, 0x39, 0x1E, 0x3D, 0xEF, 0x56, 0x3F, 0x34, 0x20, 0xC9
DB 0x29, 0xEC, 0xCA, 0x9B, 0x7B, 0xE1, 0x68, 0x17, 0xAD, 0x58
DB 0xC8, 0xE9, 0x08, 0x7B, 0xD7, 0x82, 0xC0, 0x10, 0x42, 0x82
DB 0x83, 0x67, 0x09, 0x81, 0xE5, 0x2A, 0x5D, 0xBF, 0xDB, 0xFC
DB 0xD8, 0xF6, 0xC0, 0x2D, 0xAC, 0xCF, 0xD0, 0xB1, 0x63, 0x7B
DB 0xE2, 0x8F, 0x14, 0xB7, 0xB5, 0xA6, 0xC4, 0xF7, 0x06, 0x80
DB 0xDC, 0xC2, 0xD9, 0x49, 0x37, 0x06, 0x30, 0x59, 0xFA, 0x1A
DB 0x67, 0x5B, 0x48, 0x3A, 0x8B, 0x7B, 0xF4, 0xAF, 0x40, 0x1B
DB 0xE2, 0xD2, 0xF8, 0x51, 0x68, 0xAB, 0x7C, 0xF3, 0x2E, 0xCC
DB 0x62, 0x76, 0x92, 0x76, 0xF0, 0x49, 0x87, 0x22, 0xCF, 0x93
DB 0x6A, 0xB5, 0xA8, 0xDB, 0x3B, 0x32, 0xCB, 0x56, 0xB9, 0x6E
DB 0x26, 0xFD, 0xD4, 0xBE, 0xD7, 0x7E, 0xCD, 0x4F, 0xFC, 0xC1
DB 0x97, 0x10, 0x33, 0xF3, 0xBB, 0x20, 0x6F, 0x96, 0xA6, 0xA5
DB 0x9F, 0xF7, 0x71, 0x5F, 0x12, 0xE0, 0xCC, 0x04, 0x01, 0xAF
DB 0xC1, 0x89, 0x2D, 0x03, 0xB5, 0xE9, 0x5B, 0x1B, 0x37, 0x36
DB 0x8B, 0x5B, 0xFA, 0x44, 0xE2, 0x3A, 0x78, 0xF9, 0x22, 0xA4
DB 0xFD, 0x7D, 0x78, 0xED, 0xBA, 0xD2, 0xE0, 0x71, 0x29, 0x6D
DB 0x4F, 0x52, 0x7A, 0x9A, 0x39, 0x9A, 0x2B, 0xAA, 0xEA, 0x0F
DB 0x1F, 0xE3, 0xED, 0x7C, 0x1B, 0x0D, 0x62, 0xB2, 0x3D, 0xC3
DB 0xEA, 0x76, 0x31, 0x66, 0x31, 0x5D, 0x14, 0x0A, 0xEB, 0xD5
DB 0x32, 0x5B, 0x21, 0x24, 0x47, 0xC0, 0x12, 0x0B, 0x42, 0x54
DB 0x68, 0x2B, 0xC0, 0x8A, 0xAE, 0xEA, 0xC2, 0x03, 0xB2, 0x5F
DB 0xBF, 0x4D, 0x9C, 0x79, 0x38, 0x39, 0x4B, 0xC5, 0x9A, 0xDB
DB 0x35, 0x73, 0x48, 0x98, 0x37, 0x19, 0xDE, 0x54, 0xB8, 0x78
DB 0xD2, 0x8F, 0xDE, 0x65, 0x9D, 0xFC, 0xB0, 0x75, 0x23, 0xC4
DB 0xA5, 0x12, 0xDB, 0x14, 0xAE, 0x84, 0xC1, 0xF9, 0xC1, 0x35
DB 0x9F, 0xE4, 0x70, 0x40, 0xD7, 0x91, 0x3A, 0x49, 0xF1, 0x8C
DB 0x0F, 0x3C, 0x4A, 0xFF, 0x8B, 0x34, 0xB8, 0xC7, 0xE3, 0xB9
DB 0x21, 0x0C, 0xD1, 0x35, 0x46, 0xC3, 0xCD, 0xF6, 0x90, 0xAE
DB 0x7C, 0x2C, 0x3F, 0x64, 0x4D, 0x3E, 0xCB, 0x67, 0xE0, 0x57
DB 0x92, 0x43, 0x65, 0x98, 0xA0, 0xFC, 0x8E, 0x58, 0x9D, 0x9B
DB 0xB3, 0xAA, 0xC7, 0x93, 0xCE, 0xD7, 0xF2, 0x19, 0x1A, 0x04
DB 0x9F, 0x8A, 0xD8, 0x1B, 0x44, 0x34, 0xE9, 0x17, 0xD2, 0xDA
DB 0xDD, 0xD8, 0x40, 0xB4, 0xBF, 0x6E, 0xD0, 0x82, 0x03, 0x23
DB 0xEA, 0x13, 0x43, 0xFE, 0x7D, 0x17, 0x16, 0x2B, 0xBC, 0xE3
DB 0x6C, 0x90, 0x43, 0xF4, 0x7C, 0x73, 0xAE, 0xB5, 0xCC, 0xEC
DB 0x8A, 0x05, 0x4B, 0x29, 0x7C, 0xDB, 0x77, 0xCA, 0x76, 0xA9
DB 0x51, 0x0C, 0xD2, 0xE3, 0x7B, 0xAB, 0xD9, 0x65, 0x39, 0x18
DB 0x9C, 0x4C, 0x7B, 0x52, 0x16, 0xD1, 0xA8, 0x20, 0x8B, 0x84
DB 0xA3, 0x6D, 0x1C, 0x72, 0x94, 0xE4, 0xE2, 0xA1, 0x13, 0x0E
DB 0xFB, 0xDF, 0xCD, 0x48, 0x57, 0x22, 0xCE, 0x0A, 0xF1, 0x38
DB 0xF9, 0x31, 0xBC, 0x55, 0x8A, 0x17, 0xD5, 0x30, 0x5E, 0xAD
DB 0x02, 0x3B, 0x32, 0xFD, 0xFD, 0x7B, 0x45, 0xAA, 0xCF, 0xDB
DB 0x3B, 0x4A, 0x11, 0xB7, 0xD1, 0x5F, 0x85, 0x3E, 0xED, 0x17
DB 0x67, 0x15, 0x91, 0xAB, 0x52, 0x5E, 0xB1, 0xA5, 0xD2, 0x50
DB 0x51, 0x77, 0x8C, 0xBA, 0x4E, 0x41, 0xC4, 0xA3, 0x49, 0x8F
DB 0x54, 0x85, 0xE7, 0xBE, 0xD0, 0x93, 0x59, 0x19, 0x47, 0x5B
DB 0xAF, 0x03, 0x27, 0xC2, 0xED, 0x60, 0xE9, 0x13, 0x19, 0x04
DB 0xB2, 0x12, 0x16, 0xEC, 0xA6, 0x99, 0x34, 0xC6, 0x8B, 0x36
DB 0x4A, 0x55, 0x11, 0xA6, 0x8C, 0xAC, 0x6A, 0xF7, 0xDF, 0xD4
DB 0x80, 0xB2, 0x92, 0xA9, 0xB2, 0x4C, 0xBA, 0x6D, 0x4F, 0x3C
DB 0xE1, 0x6A, 0xC4, 0xD8, 0x9D, 0x07, 0xCD, 0x59, 0x77, 0xA7
DB 0x01, 0x95, 0x80, 0x26, 0x40, 0x72, 0x22, 0xAE, 0xF7, 0x61
DB 0xD3, 0xBF, 0x3D, 0xCC, 0xFD, 0xD8, 0x6B, 0x50, 0xD7, 0xCF
DB 0x02, 0x0F, 0xF5, 0xAE, 0x3B, 0x80, 0x2F, 0xBC, 0x47, 0x1F
DB 0x15, 0x4A, 0xA2, 0x75, 0x63, 0x39, 0x28, 0x87, 0x5C, 0x79
DB 0x53, 0xC9, 0x05, 0x5F, 0xDB, 0x1F, 0x51, 0x88, 0x8C, 0x5B
DB 0xA6, 0x25, 0x5B, 0x5D, 0x14, 0x00, 0x9F, 0x7B, 0x2F, 0x4E
DB 0x63, 0x61, 0x2E, 0x62, 0xCD, 0xA8, 0x1C, 0x93, 0x09, 0x73
DB 0x6C, 0x8D, 0xDD, 0x83, 0xA4, 0xC9, 0x2D, 0xA1, 0xD4, 0x8F
DB 0x94, 0x1A, 0x3B, 0x6B, 0x64, 0xCE, 0x48, 0x65, 0xFC, 0x02
DB 0xE1, 0x4E, 0x8C, 0x9A, 0xCC, 0xC3, 0x11, 0x11, 0x94, 0x4A
DB 0x4A, 0x58, 0xD2, 0xF0, 0x19, 0xC3, 0x85, 0xDE, 0x01, 0xB7
DB 0x8C, 0xE3, 0x6B, 0x11, 0x54, 0xDD, 0x24, 0xAB, 0x86, 0x6B
DB 0x76, 0x0F, 0x3D, 0x14, 0x00, 0x3D, 0x6D, 0x08, 0xEF, 0x39
DB 0x92, 0x5F, 0x48, 0x27, 0x8C, 0x38, 0x62, 0x84, 0xF2, 0xFC
DB 0x1A, 0x1D, 0x9E, 0x5C, 0xC4, 0x0F, 0x65, 0x21, 0x4D, 0x9A
DB 0x05, 0x41, 0xAE, 0xE8, 0xBA, 0x4E, 0xA6, 0x91, 0xF7, 0x56
DB 0x74, 0xFF, 0xC5, 0xF3, 0x5D, 0x1A, 0x30, 0x81, 0xD6, 0xF9
DB 0x54, 0xA9, 0x0D, 0x1E, 0xD2, 0x98, 0xE3, 0xBF, 0x52, 0x68
DB 0xB9, 0x98, 0xFB, 0xC9, 0xF6, 0x66, 0x22, 0x48, 0xC1, 0x6F
DB 0x06, 0x72, 0x6C, 0xAD, 0x06, 0x79, 0x22, 0xD8, 0xED, 0xD8
DB 0xDD, 0x44, 0xDE, 0x9D, 0x5D, 0x97, 0x4D, 0x01, 0x77, 0x6C
DB 0xF3, 0xF6, 0x91, 0xB6, 0x0B, 0x6B, 0xD1, 0xFD, 0xE7, 0x30
DB 0x78, 0xD8, 0x42, 0xBD, 0xDE, 0xA9, 0x0B, 0x51, 0x1E, 0x37
DB 0x7B, 0x98, 0x1D, 0x1C, 0xDC, 0x18, 0x94, 0xF6, 0xC3, 0x80
DB 0xFE, 0xF3, 0xB5, 0xDB, 0x0F, 0x01, 0xA0, 0x1B, 0xED, 0xDA
DB 0xFD, 0xDF, 0xA7, 0x16, 0x38, 0xF6, 0x94, 0x33, 0x73, 0x54
DB 0x01, 0xB6, 0xA7, 0x52, 0x8F, 0x4F, 0x0D, 0xBE, 0xC0, 0xDE
DB 0xAE, 0xAF, 0xD3, 0x4B, 0x39, 0x36, 0x87, 0xE2, 0x2A, 0x36
DB 0x7D, 0x21, 0xF6, 0x23, 0x5F, 0x3A, 0x65, 0xBB, 0xAD, 0xF9
DB 0x2A, 0xE5, 0x01, 0xA8, 0xBD, 0xCC, 0xAD, 0x6B, 0x74, 0x92
DB 0x06, 0x35, 0x82, 0x4D, 0x87, 0xDE, 0xC9, 0xF7, 0xD5, 0xEE
DB 0xB9, 0x74, 0x1E, 0xF2, 0x92, 0x7E, 0x78, 0x4F, 0x2D, 0x04
DB 0x6A, 0x25, 0x90, 0x53, 0x4C, 0xE8, 0x9D, 0x40, 0xF0, 0x02
DB 0xD2, 0x03, 0x26, 0xDB, 0x3F, 0xBE, 0xE3, 0xFD, 0x1A, 0x38
DB 0xE7, 0x5F, 0x4E, 0x30, 0xB4, 0x6D, 0x9B, 0x5A, 0xD2, 0x6D
DB 0x57, 0xEF, 0x69, 0xBB, 0x1A, 0x89, 0xB1, 0x96, 0x8A, 0x66
DB 0x15, 0x82, 0x2C, 0x0D, 0xE1, 0x08, 0x60, 0xA1, 0x68, 0x43
DB 0xC1, 0xD6, 0x21, 0xF3, 0x54, 0x37, 0xDF, 0x13, 0x3E, 0xE2
DB 0xF2, 0x31, 0xEF, 0xB8, 0x32, 0xA4, 0x96, 0xEA, 0x0F, 0xF1
DB 0xA1, 0x31, 0x4B, 0xAF, 0xCF, 0x66, 0xF8, 0x0D, 0xE0, 0x57
DB 0xF0, 0x52, 0x6D, 0xDB, 0x7B, 0xBC, 0x28, 0xCA, 0x5D, 0x0A
DB 0x7E, 0xF8, 0xFC, 0xA0, 0x53, 0x14, 0xEA, 0x9F, 0x3E, 0x23
DB 0x6D, 0x23, 0x2C, 0x50, 0xFA, 0x08, 0x1F, 0x6A, 0xD9, 0x12
DB 0xE0, 0xD8, 0x94, 0x15, 0x64, 0xFF, 0x9C, 0xFD, 0xE4, 0xEC
DB 0xD7, 0x9D, 0x2C, 0x72, 0xDA, 0x52, 0xCA, 0x37, 0xDB, 0x4B
DB 0xB5, 0xFA, 0x56, 0x40, 0x2C, 0x12, 0x9F, 0x8A, 0xBF, 0xDF
DB 0xA6, 0xA1, 0x16, 0xCC, 0xAC, 0x6E, 0x89, 0xF2, 0x24, 0x18
DB 0x7F, 0x4A, 0xF8, 0x9A, 0x5A, 0xD3, 0x28, 0x8C, 0x72, 0x51
DB 0xFE, 0x36, 0xEC, 0x0A, 0x46, 0xC1, 0xE3, 0x28, 0xCF, 0x41
DB 0xA4, 0x62, 0x0D, 0x98, 0xF7, 0x91, 0x87, 0x8A, 0x5E, 0x45
DB 0xBB, 0x58, 0x35, 0x92, 0xE2, 0x20, 0x2C, 0xF8, 0x95, 0xEB
DB 0xCD, 0xBB, 0x5E, 0xD3, 0xFE, 0xC2, 0xC7, 0x6E, 0xDF, 0xBE
DB 0xF8, 0x55, 0x09, 0x0C, 0xD5, 0x6F, 0x08, 0x50, 0x32, 0x24
DB 0xC2, 0x47, 0x19, 0x37, 0x37, 0x15, 0x3D, 0x18, 0x17, 0x66
DB 0xF7, 0x81, 0x00, 0xCC, 0xA7, 0xB1, 0x36, 0x88, 0x3F, 0x71
DB 0xD6, 0xE0, 0xBE, 0xAC, 0x25, 0xAD, 0xAA, 0xE2, 0x3C, 0x80
DB 0xB3, 0x99, 0xA3, 0x63, 0x9F, 0xE2, 0x1E, 0xC7, 0xA8, 0xF9
DB 0xCE, 0x3C, 0xC1, 0x20, 0x0F, 0xB8, 0x94, 0x3E, 0xD6, 0x20
DB 0xD7, 0x1E, 0xB3, 0x1E, 0x8C, 0xF6, 0x24, 0x76, 0x93, 0x8F
DB 0xD5, 0x9B, 0x0A, 0x88, 0x42, 0x57, 0x67, 0x32, 0xA5, 0x11
DB 0x9E, 0x94, 0x93, 0x21, 0x7A, 0x55, 0x8E, 0x1D, 0x51, 0xF6
DB 0x11, 0x4E, 0xB4, 0x4B, 0x09, 0xC6, 0x87, 0xCD, 0x67, 0xF9
DB 0x05, 0xE3, 0x6B, 0x40, 0xE8, 0x83, 0xCA, 0x8B, 0x9F, 0x70
DB 0xFC, 0x7F, 0x1B, 0x38, 0x9F, 0xFA, 0xD8, 0x66, 0x73, 0x55
DB 0x98, 0xE4, 0x59, 0x3D, 0x37, 0x22, 0xCF, 0xB5, 0x6E, 0xE3
DB 0x94, 0x40, 0xF9, 0x87, 0xBD, 0xD6, 0x5A, 0xE1, 0x0E, 0x52
DB 0x54, 0x68, 0xB9, 0x1D, 0x87, 0x1E, 0xCB, 0x05, 0x78, 0xCF
DB 0xC3, 0x88, 0xF8, 0x13, 0xB1, 0xF6, 0xE7, 0x6E, 0x6A, 0x3E
DB 0x75, 0x17, 0xB1, 0xD0, 0xD9, 0x7F, 0x99, 0x58, 0x83, 0xDF
DB 0x0D, 0xCA, 0xC5, 0x5F, 0xEC, 0x6A, 0xF5, 0xCA, 0x36, 0x0E
DB 0x07, 0x6F, 0x4A, 0x77, 0x72, 0x62, 0xB9, 0x57, 0x3C, 0xF2
DB 0x06, 0x7E, 0xD3, 0x24, 0x09, 0x73, 0xBB, 0x56, 0xAA, 0x6A
DB 0x8D, 0x50, 0xD6, 0x99, 0x12, 0x09, 0x0C, 0x75, 0xAC, 0x49
DB 0x36, 0x30, 0x38, 0xB5, 0x5B, 0x09, 0x53, 0x45, 0xBE, 0x89
DB 0x9F, 0x1C, 0x8A, 0xD0, 0xC8, 0x9C, 0x6B, 0xFF, 0xC2, 0x75
DB 0xB3, 0xC9, 0x54, 0x13, 0x05, 0xD5, 0xEB, 0x21, 0x42, 0xA0
DB 0xD5, 0xF7, 0xB3, 0x65, 0x85, 0x57, 0xC0, 0xF3, 0x5D, 0x61
DB 0xDB, 0x48, 0x5E, 0x48, 0x60, 0x9B, 0x6C, 0xED, 0x37, 0xEB
DB 0x2F, 0xEF, 0x25, 0xD6, 0x17, 0x3A, 0x13, 0xC8, 0x1A, 0x7F
DB 0x2F, 0x66, 0xAD, 0x3F, 0x36, 0xBB, 0xCE, 0x72, 0xE9, 0x1D
DB 0x0F, 0xE2, 0xE3, 0x7B, 0x74, 0xEA, 0x2C, 0xE5, 0xD3, 0xB1
DB 0x47, 0xE5, 0x0F, 0xF1, 0x4B, 0xBC, 0x88, 0x0A, 0x04, 0xBF
DB 0xBC, 0xE6, 0x9B, 0xFA, 0x16, 0x73, 0x2D, 0x4D, 0xE5, 0xD8
DB 0x72, 0xF7, 0x77, 0x8B, 0xC3, 0xE3, 0x6B, 0xE4, 0xC3, 0x96
DB 0x81, 0x0A, 0x1A, 0x0B, 0x58, 0x6D, 0xDD, 0xF2, 0x07, 0x74
DB 0x39, 0x86, 0x87, 0xCC, 0x63, 0x7A, 0x3B, 0xE1, 0x59, 0x6F
DB 0xF8, 0x6D, 0xC6, 0x43, 0x69, 0xE7, 0xAE, 0x57, 0x74, 0x53
DB 0x49, 0x38, 0x3E, 0x8A, 0x52, 0x29, 0x6B, 0xD0, 0x31, 0xD4
DB 0xBA, 0xA3, 0xC3, 0x7E, 0x13, 0x64, 0x06, 0xAF, 0xD2, 0x40
DB 0x59, 0xC1, 0x9F, 0x7F, 0x05, 0x9C, 0x65, 0xC0, 0xB7, 0xA6
DB 0x8E, 0x53, 0xB9, 0xEC, 0xDE, 0xDB, 0x17, 0xA7, 0x2F, 0x51
DB 0x09, 0x1A, 0x00, 0xC0, 0x47, 0x45, 0xF9, 0x73, 0xE9, 0x6A
DB 0xAF, 0x2F, 0xB0, 0x79, 0xBD, 0x12, 0xE1, 0x6B, 0x2F, 0xC3
DB 0x0F, 0xB2, 0x28, 0x29, 0xBA, 0x81, 0xC2, 0x40, 0xD3, 0x83
DB 0xE9, 0x31, 0x3C, 0x9C, 0x3F, 0x29, 0x6B, 0xFF, 0xFF, 0x45
DB 0x51, 0x68, 0x8B, 0xF5, 0x90, 0xBA, 0xA1, 0xD3, 0x75, 0x76
DB 0xA5, 0x2B, 0x44, 0xBC, 0x2B, 0x25, 0xC9, 0xE0, 0x3A, 0x14
DB 0xAF, 0x01, 0xF4, 0x85, 0xC8, 0x3D, 0xA9, 0x1B, 0x65, 0x2F
DB 0xA0, 0x32, 0x9C, 0xA1, 0x5C, 0x2F, 0x22, 0x61, 0xCB, 0x7A
DB 0x3D, 0x9F, 0xC5, 0xC2, 0x23, 0xA1, 0xDE, 0x2F, 0xE6, 0xCD
DB 0xB5, 0xCA, 0x62, 0xB4, 0xF1, 0x8A, 0x20, 0xC4, 0xE2, 0xE3
DB 0x1B, 0xE3, 0x95, 0x17, 0xEF, 0x2D, 0xE0, 0xC2, 0x6E, 0x6A
DB 0xCC, 0x23, 0x4D, 0xC4, 0x65, 0xA8, 0x74, 0x9F, 0x4C, 0x0E
DB 0xCE, 0xBC, 0x4B, 0x01, 0x9B, 0x6E, 0xF9, 0xA6, 0x49, 0x7F
DB 0x91, 0xA0, 0x4F, 0x20, 0xB5, 0xBF, 0x1A, 0x6C, 0x7B, 0x8C
DB 0x30, 0xBB, 0x43, 0xC0, 0x51, 0x5A, 0x6F, 0x35, 0xD3, 0x97
DB 0xDC, 0x31, 0xB1, 0xC8, 0x1B, 0xC0, 0x26, 0xF9, 0x8F, 0x55
DB 0x53, 0x96, 0x20, 0x1D, 0xF6, 0xB2, 0x72, 0xF7, 0xBD, 0x3B
DB 0x5F, 0xE1, 0x5F, 0xB0, 0xAB, 0x4C, 0x1F, 0x79, 0xC5, 0x83
DB 0xF5, 0x88, 0xD8, 0x5E, 0x03, 0xA2, 0x65, 0x4E, 0x6A, 0x1A
DB 0xAF, 0x8C, 0x7B, 0x1D, 0xDD, 0x7F, 0x59, 0x41, 0x1A, 0x00
DB 0xA1, 0xF8, 0x79, 0x01, 0x03, 0xBC, 0x82, 0x24, 0x8B, 0xCE
DB 0x94, 0xD4, 0x97, 0xDA, 0xB1, 0x56, 0x7E, 0x0E, 0xBE, 0x94
DB 0xA2, 0xBE, 0xE3, 0x16, 0xAA, 0x40, 0x17, 0xE9, 0xA3, 0x3E
DB 0x77, 0xF3, 0x73, 0x78, 0x02, 0x09, 0xE7, 0xFD, 0xF2, 0x5E
DB 0x4A, 0x4D, 0xEE, 0x3C, 0x3A, 0xAF, 0x4B, 0x9A, 0xAD, 0x14
DB 0xD7, 0x56, 0x3E, 0xE8, 0xD4, 0xC6, 0xF2, 0x1D, 0xB6, 0xC2
DB 0xFD, 0x15, 0x51, 0xA7, 0x99, 0x6C, 0x3D, 0x3C, 0x54, 0x1E
DB 0xFD, 0x21, 0xBA, 0xC8, 0x59, 0xEA, 0x0B, 0x24, 0xB3, 0xF8
DB 0x94, 0x73, 0x35, 0xEA, 0xE4, 0x99, 0xE9, 0xF2, 0x6E, 0x12
DB 0x56, 0x6D, 0x5F, 0xAC, 0x91, 0x6E, 0xBE, 0x2D, 0x3E, 0x9D
DB 0xD7, 0x9F, 0x26, 0x22, 0xEE, 0xBF, 0x8D, 0x88, 0x55, 0xA8
DB 0xFB, 0xBE, 0xA8, 0x13, 0xAB, 0x54, 0x32, 0xDD, 0xD5, 0xCE
DB 0xF7, 0xCA, 0xD8, 0xC9, 0x2A, 0x20, 0x55, 0xEA, 0x6E, 0xB5
DB 0xB6, 0xFB, 0x9C, 0x90, 0x4B, 0xAF, 0x69, 0x3A, 0xB1, 0x4D
DB 0xAB, 0xB7, 0x67, 0x22, 0x49, 0xB9, 0xBE, 0xB8, 0x62, 0x42
DB 0xCE, 0x02, 0x33, 0x55, 0x79, 0x12, 0x7E, 0xA8, 0x1D, 0x53
DB 0x77, 0x7C, 0x7D, 0xBB, 0x48, 0x7A, 0x81, 0x9F, 0x5B, 0x40
DB 0x4F, 0xBA, 0xE6, 0x44, 0xC7, 0xC2, 0xF3, 0xD8, 0xBC, 0x58
DB 0xC7, 0x7E, 0x09, 0xF0, 0x0C, 0x89, 0x34, 0x88, 0xD5, 0xE4
DB 0x1D, 0xA3, 0x4A, 0xE2, 0x35, 0x6A, 0xE5, 0xED, 0x1A, 0xCE
DB 0xC3, 0x53, 0xEC, 0xED, 0x35, 0x5D, 0x16, 0xF2, 0xF9, 0xAE
DB 0x14, 0x82, 0x45, 0x5B, 0x2F, 0x69, 0x92, 0xEF, 0x7C, 0x0B
DB 0xF0, 0x33, 0xE5, 0x93, 0xE0, 0xF8, 0x4C, 0x89, 0x9B, 0xD6
DB 0xF7, 0x7E, 0x01, 0x96, 0x6B, 0x8F, 0x4E, 0x96, 0x04, 0x7E
DB 0xE7, 0xD1, 0x91, 0x34, 0x45, 0xE6, 0x11, 0x47, 0x4A, 0x52
DB 0xF5, 0x2D, 0x14, 0x6E, 0x50, 0xA0, 0xE0, 0xEB, 0xF9, 0xAA
DB 0x5D, 0xD4, 0xBC, 0xF3, 0x5F, 0x00, 0x03, 0x47, 0x19, 0xA1
DB 0x23, 0x34, 0x89, 0x0D, 0x2C, 0x83, 0xDA, 0xA4, 0xF5, 0x68
DB 0x1C, 0xE0, 0xDC, 0x9D, 0x8B, 0xA6, 0xDE, 0xBB, 0x0F, 0x8D
DB 0x03, 0xAA, 0xE0, 0xAE, 0x1F, 0x0B, 0x45, 0xED, 0x18, 0x76
DB 0x18, 0xEB, 0x18, 0xF8, 0xC0, 0x1C, 0x33, 0x2F, 0xD6, 0x60
DB 0x16, 0x92, 0x41, 0xF1, 0xDC, 0x9B, 0x95, 0x68, 0xE9, 0xA1
DB 0x24, 0xF4, 0x28, 0xFC, 0x25, 0xDF, 0xB5, 0xDE, 0x42, 0xC7
DB 0xF9, 0x6E, 0x60, 0xC0, 0x83, 0x0C, 0x83, 0xB7, 0x67, 0x87
DB 0xF7, 0x5D, 0x75, 0x80, 0x50, 0x5D, 0x9F, 0x15, 0xC7, 0xB5
DB 0xA1, 0x88, 0x83, 0x6F, 0x06, 0x04, 0x01, 0x4C, 0xE6, 0x8C
DB 0x99, 0x89, 0x18, 0x19, 0x0A, 0xC1, 0x7A, 0x1E, 0xF1, 0x61
DB 0x43, 0xB9, 0xD0, 0x89, 0x67, 0x0A, 0x7F, 0xEE, 0x0B, 0xD4
DB 0xC4, 0x48, 0x10, 0xF2, 0x6D, 0x16, 0x27, 0x06, 0xD5, 0xEC
DB 0xC4, 0xD0, 0xA4, 0xB7, 0x29, 0xEA, 0x80, 0x33, 0x14, 0x05
DB 0x68, 0x95, 0x0C, 0x79, 0x54, 0x44, 0xC7, 0xA9, 0x54, 0xA5
DB 0x60, 0x31, 0xA5, 0x37, 0xBE, 0xE5, 0x5C, 0x8C, 0xF5, 0xDB
DB 0x10, 0x93, 0x68, 0x36, 0x5F, 0x2A, 0xCF, 0x13, 0x31, 0x2D
DB 0x6D, 0x1F, 0xBB, 0x03, 0x71, 0x35, 0xCA, 0x3F, 0xCC, 0x42
DB 0x31, 0x27, 0x88, 0x3E, 0xA8, 0x20, 0x0D, 0x7B, 0x4F, 0x3D
DB 0x04, 0x8A, 0x8B, 0x07, 0x66, 0x54, 0xB5, 0x14, 0x2C, 0x99
DB 0xF9, 0x92, 0x56, 0x71, 0x05, 0x29, 0xD1, 0x05, 0x3B, 0x10
DB 0x06, 0x52, 0xAC, 0x71, 0xB8, 0xA9, 0xA0, 0x2D, 0x34, 0x68
DB 0xDD, 0x4A, 0x44, 0x75, 0x66, 0xBE, 0x6A, 0x34, 0xEB, 0x55
DB 0x01, 0x36, 0x8C, 0x36, 0x23, 0xFD, 0x37, 0x59, 0xE0, 0x83
DB 0xD8, 0xE5, 0xF9, 0x7E, 0x80, 0xDB, 0x26, 0xA5, 0x04, 0x1E
DB 0xEF, 0xF0, 0x07, 0x55, 0xDE, 0x95, 0x86, 0x6F, 0x55, 0x55
DB 0x34, 0xA3, 0xDE, 0x95, 0xD1, 0x76, 0x62, 0x19, 0x51, 0x2C
DB 0x1B, 0xB1, 0x70, 0x09, 0xD8, 0x3B, 0x72, 0x9C, 0xD4, 0x51
DB 0xC4, 0x95, 0x9D, 0xED, 0xCF, 0x1A, 0xCA, 0x84, 0xFF, 0x5E
DB 0x8D, 0x1A, 0xA1, 0x50, 0x52, 0x37, 0x62, 0xFC, 0xE0, 0x87
DB 0xFE, 0x63, 0x70, 0x61, 0x49, 0xF6, 0xBE, 0x41, 0x8F, 0xA7
DB 0x1E, 0x40, 0xA2, 0x35, 0x12, 0x10, 0xE8, 0x96, 0x23, 0x6F
DB 0xBF, 0x25, 0x08, 0x30, 0x81, 0xD9, 0x8A, 0x41, 0x88, 0x9D
DB 0x04, 0xC0, 0xF7, 0x20, 0x59, 0x99, 0xD2, 0xC1, 0x5F, 0x53
DB 0xDC, 0x73, 0x3C, 0x08, 0x7E, 0x16, 0xD5, 0xF5, 0x38, 0x5B
DB 0x2C, 0xE3, 0x53, 0x14, 0x92, 0x83, 0xC6, 0x69, 0x3B, 0xD2
DB 0x17, 0xB3, 0x78, 0xE6, 0xC9, 0x65, 0x30, 0xB4, 0xEB, 0x1C
DB 0xA2, 0xDA, 0xDB, 0x65, 0x4E, 0x51, 0x88, 0xD9, 0xA9, 0xC6
DB 0xA0, 0x63, 0x14, 0xE9, 0xCB, 0xC7, 0xF6, 0x52, 0xF1, 0x96
DB 0x40, 0xCF, 0xA8, 0x44, 0xC7, 0xE0, 0xDC, 0x75, 0xF7, 0xDA
DB 0x6D, 0xE7, 0xE5, 0xCA, 0x6E, 0xEE, 0x52, 0x3A, 0x5F, 0xA4
DB 0x03, 0x27, 0x9B, 0xCC, 0xCA, 0xD9, 0x86, 0x6C, 0xA9, 0xCF
DB 0x42, 0xF4, 0x49, 0x82, 0x26, 0xC2, 0xB6, 0x4F, 0xC6, 0x5A
DB 0x93, 0xD8, 0xEA, 0xE4, 0xFE, 0xAD, 0x31, 0x91, 0x84, 0x21
DB 0x16, 0xC5, 0xB7, 0x2A, 0x20, 0x4D, 0x97, 0xD7, 0x04, 0xCB
DB 0x61, 0xD5, 0xEE, 0xB5, 0x94, 0xE7, 0xB0, 0xA0, 0xC2, 0x9F
DB 0xCC, 0x27, 0xA6, 0x44, 0x5D, 0x5C, 0xE7, 0x85, 0x3B, 0xEF
DB 0x66, 0x35, 0xFA, 0x26, 0xF9, 0x40, 0xD6, 0x43, 0xC4, 0xCC
DB 0x30, 0x39, 0x61, 0x71, 0x52, 0x61, 0xDA, 0x1D, 0x28, 0xE3
DB 0xFD, 0x68, 0x0C, 0x3D, 0x6A, 0x25, 0x09, 0x5B, 0x63, 0x04
DB 0x45, 0x42, 0x24, 0xF3, 0x7C, 0xF5, 0xF6, 0x86, 0x2A, 0x45
log_e: DB 0
DB 0x6F, 0x2D, 0xEC, 0x54, 0x9B, 0x94, 0x38, 0xCA, 0x9A, 0xAD
DB 0xD5, 0x57, 0xD6, 0x99, 0xEE, 0x19, 0x1F, 0x71, 0xA3, 0x01
DB 0x22, 0xE4, 0xD1, 0x01, 0x1D, 0x1F, 0x96, 0xA2, 0x7B, 0xC7
DB 0x52, 0x9E, 0x3A, 0xA1, 0x27, 0x7D, 0x0A, 0x01, 0x79, 0xF9
DB 0x49, 0x11, 0xAA, 0xC9, 0x63, 0x23, 0x25, 0x0A, 0x8C, 0x67
DB 0x1D, 0xEC, 0xFE, 0x9C, 0x6E, 0x5E, 0x37, 0xD1, 0x5C, 0x69
DB 0x64, 0x66, 0xD3, 0xD9, 0xA1, 0xAB, 0x5E, 0x8C, 0xA4, 0x68
DB 0x37, 0xFC, 0xA0, 0x03, 0x90, 0x02, 0xC6, 0x0E, 0xE2, 0x6D
DB 0x32, 0xC5, 0xB0, 0xF5, 0x21, 0x64, 0x26, 0xB5, 0x28, 0x59
DB 0xB6, 0xF6, 0x97, 0x9B, 0x9C, 0xEA, 0xAA, 0x18, 0x10, 0x95
DB 0x73, 0x46, 0x02, 0x6A, 0x32, 0x47, 0x66, 0x44, 0xE6, 0x28
DB 0xFC, 0x9A, 0x6B, 0xCA, 0x6B, 0x27, 0x93, 0xE4, 0xB4, 0x75
DB 0xD9, 0xFF, 0x20, 0x61, 0x76, 0x6D, 0x8F, 0xB6, 0x68, 0x90
DB 0xD6, 0xE3, 0x28, 0x63, 0x2F, 0x4A, 0x3E, 0xEB, 0x60, 0x43
DB 0x8F, 0x3F, 0xB1, 0x64, 0x15, 0x89, 0xC2, 0xA3, 0x37, 0xE6
DB 0xE2, 0xCC, 0x6B, 0x89, 0x2E, 0xF8, 0x90, 0xA7, 0x2B, 0x2F
DB 0x15, 0xD2, 0x85, 0xEC, 0x76, 0xDE, 0x05, 0x44, 0xDD, 0xC9
DB 0x25, 0x4D, 0xD9, 0xBD, 0x46, 0x01, 0x63, 0x93, 0xAA, 0x8B
DB 0x7E, 0x1D, 0x3E, 0x8E, 0x0B, 0xE6, 0x26, 0x71, 0x02, 0x64
DB 0xFB, 0x04, 0x33, 0xB4, 0xA1, 0x46, 0xBC, 0x6A, 0xB4, 0x9B
DB 0x13, 0x0A, 0x58, 0x86, 0xE5, 0xE2, 0x98, 0x69, 0x93, 0x33
DB 0xBD, 0xFA, 0x95, 0xF0, 0xB3, 0x9B, 0x0F, 0xD7, 0x76, 0x8F
DB 0x99, 0xB6, 0xB0, 0xA0, 0xC4, 0x24, 0xA9, 0xDD, 0x4F, 0x8B
DB 0xEF, 0x2B, 0x1F, 0xE8, 0xD8, 0xE3, 0x67, 0x31, 0x7B, 0x4A
DB 0xEE, 0x29, 0xFD, 0xAC, 0xDD, 0x14, 0x3B, 0x20, 0xD7, 0x69
DB 0xE0, 0xA5, 0x7A, 0x3F, 0xDD, 0xA0, 0xAE, 0xF3, 0x04, 0x32
DB 0x08, 0x70, 0x9C, 0x5F, 0x22, 0x84, 0x67, 0x9B, 0xF8, 0x73
DB 0x2C, 0x84, 0x6A, 0x6C, 0x33, 0x0E, 0x02, 0x3E, 0x59, 0x6E
DB 0x95, 0x58, 0x75, 0xC9, 0xCE, 0x40, 0xB5, 0xB5, 0xF7, 0x5F
DB 0x37, 0x2C, 0xA5, 0xD3, 0x5B, 0xC8, 0xFC, 0x04, 0x9D, 0x3A
DB 0x4E, 0xBA, 0x62, 0xAE, 0x30, 0x21, 0xC0, 0xD0, 0xFE, 0x93
DB 0xDB, 0xBA, 0x31, 0x86, 0xB9, 0x22, 0x1C, 0x79, 0x3D, 0xBE
DB 0x90, 0xAE, 0x7A, 0x91, 0x47, 0x3A, 0x51, 0x9E, 0xDA, 0x05
DB 0x65, 0x76, 0x64, 0x9E, 0x29, 0x81, 0x0D, 0xCE, 0xF9, 0x26
DB 0xCC, 0x72, 0xF3, 0xDD, 0xD2, 0x19, 0x03, 0xA7, 0x5B, 0x3E
DB 0xF4, 0x1B, 0xA2, 0x80, 0xD5, 0x48, 0x16, 0x5F, 0x7A, 0x80
DB 0xE8, 0x36, 0xC7, 0xC0, 0x2F, 0x05, 0xC2, 0x34, 0xA1, 0x2E
DB 0x16, 0x1A, 0x00, 0x0E, 0x99, 0x9A, 0x42, 0x66, 0x89, 0xB4
DB 0xA5, 0x66, 0xCF, 0x65, 0x27, 0x28, 0xDD, 0xE8, 0x3B, 0x14
DB 0x19, 0x06, 0x91, 0x80, 0x25, 0x11, 0x2D, 0x76, 0x35, 0x48
DB 0x44, 0x10, 0x55, 0xD1, 0x70, 0x23, 0xB6, 0x24, 0xD0, 0x03
DB 0x2B, 0x98, 0x06, 0x11, 0x12, 0x5C, 0x42, 0x4A, 0xD5, 0x6A
DB 0x1B, 0x0D, 0x67, 0x7E, 0x85, 0x49, 0x6B, 0xEB, 0xCA, 0xDC
DB 0xDF, 0xE4, 0xB1, 0x66, 0x8C, 0x67, 0x9E, 0xD4, 0x0C, 0x74
DB 0x97, 0x6B, 0xB2, 0xF8, 0xD1, 0x15, 0xA1, 0xDF, 0x98, 0x08
DB 0x06, 0x68, 0x76, 0x03, 0x10, 0xB3, 0x8F, 0x8B, 0x54, 0x5B
DB 0x84, 0x76, 0x44, 0xC5, 0xE7, 0xC2, 0xC0, 0x8E, 0x61, 0xCA
DB 0x09, 0x83, 0xE2, 0x42, 0x92, 0x4D, 0x37, 0xE8, 0xAC, 0xEA
DB 0x10, 0x93, 0x01, 0x24, 0x56, 0x98, 0x8A, 0x1A, 0x1B, 0xCD
DB 0x63, 0x9F, 0x5D, 0xB6, 0x0F, 0xDC, 0xF6, 0x81, 0xBE, 0x0E
DB 0x70, 0x29, 0x2D, 0x19, 0x32, 0x9A, 0x47, 0xB9, 0xEC, 0xCD
DB 0x41, 0x1F, 0xD8, 0x47, 0x5C, 0xBC, 0x68, 0xCA, 0xE2, 0xD2
DB 0xAC, 0xAD, 0xB2, 0xF1, 0x7C, 0x9E, 0x51, 0x7D, 0xF1, 0xD7
DB 0xBF, 0x9D, 0x43, 0xDD, 0x2C, 0xFD, 0x93, 0x81, 0xB7, 0x46
DB 0x93, 0xE7, 0xED, 0x8A, 0xC7, 0xC3, 0x0A, 0xF3, 0xDF, 0x28
DB 0x3A, 0x5B, 0x58, 0xF5, 0x2B, 0x26, 0xD3, 0xDD, 0x50, 0x0F
DB 0xF2, 0x06, 0xD7, 0xC6, 0x40, 0x54, 0x56, 0x8B, 0x18, 0xED
DB 0xFD, 0x70, 0x52, 0xB9, 0xA7, 0x6A, 0x15, 0xCC, 0x70, 0x8F
DB 0x90, 0x76, 0x66, 0x8F, 0xBB, 0x60, 0xE8, 0x19, 0x9C, 0xD8
DB 0xFF, 0x32, 0x0F, 0x23, 0x00, 0xE8, 0xA6, 0x60, 0x8A, 0x5F
DB 0x5B, 0x2E, 0xEE, 0x18, 0x20, 0xA5, 0x46, 0x5A, 0x51, 0xEF
DB 0x86, 0x5B, 0x64, 0xA2, 0x9E, 0x42, 0x0A, 0x3A, 0xD1, 0x3F
DB 0x9A, 0x29, 0x2F, 0xC7, 0x25, 0x18, 0x61, 0xFA, 0x95, 0x4E
DB 0x37, 0xE0, 0x83, 0xF6, 0x8E, 0xD1, 0x15, 0xC3, 0xEC, 0x75
DB 0xD8, 0x0C, 0xA2, 0x32, 0x8C, 0xA9, 0x14, 0x8E, 0x1B, 0x21
DB 0xF2, 0xDF, 0x67, 0x7E, 0x91, 0x72, 0x79, 0x46, 0xA8, 0x68
DB 0x88, 0x2E, 0x1E, 0xCF, 0x45, 0x2D, 0xC7, 0xF9, 0x03, 0x9D
DB 0x30, 0x25, 0xD8, 0xF4, 0xBF, 0x17, 0x66, 0x5B, 0x3F, 0xFB
DB 0x12, 0xCC, 0xFA, 0x79, 0xA4, 0xBB, 0x88, 0x23, 0x21, 0x4A
DB 0x65, 0x02, 0x1F, 0xA5, 0x40, 0x5D, 0x51, 0xB4, 0xD4, 0x16
DB 0xFE, 0x42, 0xC2, 0xCD, 0x36, 0x84, 0x3A, 0x3E, 0xE4, 0xF6
DB 0x37, 0xD4, 0xF7, 0xF9, 0xD1, 0x09, 0x93, 0x36, 0x3E, 0xCD
DB 0x39, 0xE3, 0xA8, 0x37, 0xC8, 0xA9, 0x5C, 0xD3, 0xA8, 0xA9
DB 0x63, 0x2A, 0x62, 0x47, 0xD7, 0x75, 0x34, 0xF3, 0x07, 0xE1
DB 0xF8, 0x3C, 0xBB, 0xA7, 0xC9, 0x23, 0x8D, 0x5B, 0xDD, 0xA3
DB 0x76, 0x66, 0x88, 0x0B, 0x22, 0x1B, 0x2F, 0x8C, 0x74, 0xB3
DB 0x74, 0x7C, 0xDD, 0x0D, 0x7D, 0x53, 0x9A, 0x0B, 0x4D, 0x36
DB 0xF0, 0xB0, 0xCB, 0x3D, 0x64, 0x58, 0x8E, 0xCE, 0x95, 0x84
DB 0xF0, 0x3E, 0x8D, 0x22, 0xE2, 0xA3, 0x5A, 0xAA, 0xAA, 0x1C
DB 0x57, 0xBE, 0x3C, 0x02, 0xD3, 0x72, 0x15, 0x0E, 0xE5, 0x7F
DB 0x5B, 0x83, 0x66, 0xF1, 0xAD, 0x83, 0xCA, 0x01, 0x39, 0x4A
DB 0x23, 0xBB, 0xED, 0x5C, 0x03, 0xB3, 0x3F, 0x00, 0x6E, 0x74
DB 0xD9, 0x1D, 0x8D, 0xA0, 0x79, 0xA9, 0xFA, 0xFB, 0x39, 0x90
DB 0x8B, 0xF2, 0xDA, 0x8D, 0x02, 0x0E, 0x86, 0x21, 0x22, 0x4B
DB 0x9A, 0x36, 0x8C, 0xDB, 0x60, 0x23, 0x96, 0x2C, 0x25, 0x4A
DB 0x69, 0x0D, 0x76, 0xE4, 0x85, 0x31, 0x51, 0x0A, 0x45, 0x41
DB 0x89, 0x62, 0x1B, 0x61, 0x94, 0x7C, 0x15, 0xED, 0xA1, 0x8F
DB 0xF9, 0x48, 0xF0, 0xF0, 0x26, 0x5A, 0x61, 0x8E, 0x06, 0x31
DB 0xB3, 0x44, 0x57, 0xE8, 0x01, 0x59, 0xCB, 0x44, 0x09, 0x81
DB 0xAF, 0x4E, 0x75, 0x14, 0x4E, 0xBB, 0x42, 0x75, 0xBB, 0x4F
DB 0xB1, 0x30, 0xE6, 0x12, 0xF8, 0xAA, 0x50, 0xBE, 0x62, 0xB7
DB 0x8D, 0xEE, 0x6A, 0x56, 0xBA, 0x95, 0x73, 0xBE, 0xD3, 0xB2
DB 0xF7, 0xBD, 0x6B, 0x85, 0xF2, 0xC6, 0x87, 0xD7, 0x2C, 0xDA
DB 0x4D, 0x96, 0x12, 0x70, 0x38, 0x30, 0xBF, 0x92, 0xBB, 0x84
DB 0x7C, 0x8A, 0xC6, 0xA8, 0x15, 0x7C, 0x1E, 0x5C, 0x28, 0x9C
DB 0xB5, 0xCE, 0xB0, 0x01, 0xFE, 0x67, 0xF2, 0x5C, 0x8D, 0xDE
DB 0xC9, 0xDF, 0x12, 0xB3, 0x77, 0xBC, 0x75, 0x3E, 0x25, 0x19
DB 0xD6, 0xD2, 0x1E, 0xEB, 0x6F, 0x61, 0x53, 0xA9, 0x4B, 0x6C
DB 0xD8, 0x36, 0xE4, 0xBE, 0x1E, 0x97, 0x05, 0xD0, 0x97, 0xDB
DB 0xED, 0x94, 0x5C, 0xE0, 0x75, 0x83, 0x62, 0xAA, 0xB8, 0x4C
DB 0x5D, 0xC5, 0xF4, 0xDF, 0xEB, 0x3B, 0x72, 0x15, 0xB7, 0x9E
DB 0x46, 0x92, 0x87, 0x32, 0xC4, 0x13, 0xCF, 0x89, 0xE9, 0xF2
DB 0xDE, 0xF7, 0xAB, 0x95, 0x27, 0xE0, 0x26, 0x6D, 0x80, 0x7D
DB 0x20, 0x70, 0x15, 0xBA, 0x16, 0x35, 0x00, 0xB8, 0x4F, 0x9B
DB 0xEC, 0x33, 0x26, 0x5E, 0x9F, 0x98, 0x03, 0xCA, 0x87, 0xA4
DB 0x4F, 0xC2, 0xD8, 0x14, 0x43, 0x31, 0x09, 0xB8, 0x8B, 0x82
DB 0xBF, 0x5A, 0x74, 0x83, 0x47, 0xD5, 0xEB, 0x59, 0xB3, 0x90
DB 0x86, 0x63, 0x98, 0xDD, 0x87, 0x62, 0x4D, 0x36, 0x62, 0x34
DB 0x30, 0x38, 0x48, 0xD9, 0xD8, 0x5B, 0x03, 0x9F, 0x39, 0xA1
DB 0xB1, 0xB4, 0x1A, 0x40, 0xC1, 0x80, 0xCB, 0x26, 0xE8, 0xDF
DB 0xB7, 0xB2, 0x2F, 0x91, 0xD7, 0xD7, 0x5D, 0xEE, 0xFD, 0x1C
DB 0x37, 0xFB, 0x9B, 0x28, 0x81, 0xAA, 0x4C, 0xC0, 0x8D, 0xDD
DB 0xB3, 0xA3, 0xB3, 0x79, 0x13, 0xD3, 0x5F, 0xCC, 0xFE, 0x35
DB 0x41, 0xA5, 0x32, 0x2F, 0x0A, 0x18, 0x80, 0xFF, 0x62, 0x92
DB 0x1F, 0xC4, 0x82, 0x22, 0x91, 0x2F, 0x12, 0xB4, 0x22, 0x4D
DB 0xE6, 0x2C, 0x10, 0x4C, 0xBE, 0x2E, 0xF3, 0x79, 0xFC, 0x19
DB 0x5F, 0xE8, 0x9A, 0x63, 0x2B, 0xE4, 0x63, 0x16, 0x74, 0x21
DB 0xB7, 0xE5, 0x3A, 0xB0, 0x0A, 0x9F, 0xEC, 0xCC, 0xA0, 0xF8
DB 0x08, 0x53, 0xA7, 0x0C, 0x31, 0x71, 0xA3, 0xAF, 0xE3, 0x52
DB 0x79, 0xB9, 0x19, 0x29, 0x41, 0xEB, 0x24, 0x3C, 0xA1, 0xA9
DB 0x07, 0x26, 0xF2, 0xA9, 0x79, 0x36, 0x4E, 0x84, 0x91, 0x42
DB 0x6C, 0x23, 0x55, 0x31, 0x30, 0x00, 0xEF, 0xF3, 0x47, 0x94
DB 0xE5, 0xC5, 0x44, 0x7B, 0x58, 0x7E, 0xAF, 0x3D, 0x32, 0xD6
DB 0x4E, 0xAF, 0xD8, 0x74, 0x8D, 0xC3, 0xFF, 0x9E, 0x23, 0xE0
DB 0x08, 0x5C, 0x98, 0xD7, 0xD2, 0x8B, 0x80, 0x9F, 0x94, 0x0C
DB 0xD8, 0xAC, 0xD7, 0xE3, 0x54, 0xE6, 0xF4, 0x09, 0xD0, 0x06
DB 0x61, 0xA9, 0x82, 0xAE, 0x93, 0x32, 0xC1, 0xE1, 0x5B, 0x90
DB 0xDD, 0xB8, 0xA9, 0x8E, 0xFE, 0x6E, 0x84, 0xEB, 0x72, 0x21
DB 0x31, 0xCA, 0xAD, 0xB0, 0x10, 0xF3, 0x78, 0xE9, 0x93, 0x22
DB 0x9B, 0x02, 0xF5, 0x53, 0x61, 0xAC, 0xBD, 0xE0, 0xAD, 0xCC
DB 0x69, 0x07, 0xB4, 0x7E, 0xA0, 0x7E, 0x98, 0xC3, 0x21, 0x59
DB 0x31, 0x56, 0x7C, 0xAC, 0x7D, 0x42, 0x34, 0xCE, 0x46, 0xBF
DB 0xE1, 0xF6, 0xEC, 0xA0, 0xF1, 0xE0, 0xD9, 0x20, 0x11, 0x68
DB 0x9F, 0x98, 0xD2, 0xED, 0x46, 0xCF, 0xC9, 0xEF, 0x99, 0x18
DB 0xA7, 0xA6, 0x53, 0xCC, 0x49, 0x73, 0x78, 0xC8, 0x87, 0xA7
DB 0xD0, 0xA4, 0xD7, 0xD9, 0xDD, 0x13, 0xB4, 0xA6, 0xEC, 0x9F
DB 0x2B, 0x6E, 0x24, 0x56, 0x65, 0x76, 0x4A, 0xC3, 0xF5, 0x4D
DB 0x9D, 0x34, 0x4F, 0x8C, 0xBF, 0xFF, 0x6C, 0x0B, 0xD0, 0xE5
DB 0x2C, 0xB4, 0x40, 0x76, 0x27, 0x3E, 0x6F, 0x15, 0x78, 0xE7
DB 0x2C, 0x17, 0xB2, 0x16, 0x26, 0x56, 0xA8, 0x23, 0xE1, 0x94
DB 0xF2, 0x83, 0xAA, 0x79, 0x62, 0xC2, 0xAF, 0xD3, 0x24, 0xDE
DB 0xA0, 0x75, 0xAC, 0x42, 0x2B, 0x7B, 0xAC, 0xC5, 0x69, 0x91
DB 0xB3, 0x8A, 0xAB, 0x8B, 0xFE, 0x2C, 0x80, 0x4E, 0xE7, 0x46
DB 0x75, 0x33, 0x7E, 0x69, 0xEF, 0xE6, 0x9A, 0x1D, 0x84, 0xFD
DB 0xD9, 0x41, 0xEF, 0xB8, 0xBB, 0x13, 0xEA, 0x1B, 0x1E, 0x21
DB 0x1F, 0x74, 0xCD, 0xB1, 0x91, 0x63, 0x13, 0xBB, 0xB5, 0x23
DB 0x39, 0x8E, 0xB7, 0xC5, 0x13, 0x5B, 0x11, 0xF0, 0x90, 0x79
DB 0x07, 0x29, 0xDA, 0x4D, 0x46, 0x4B, 0x9D, 0xF6, 0x8A, 0xC4
DB 0x72, 0x88, 0xA2, 0x5B, 0xA3, 0xFB, 0x95, 0x39, 0x6F, 0xFC
DB 0x6C, 0x76, 0x98, 0x43, 0x9C, 0x3E, 0xC8, 0xAA, 0x99, 0xC7
DB 0x1B, 0x8B, 0x8B, 0x33, 0x9A, 0x0A, 0x21, 0x96, 0x69, 0x5F
DB 0xC4, 0x8E, 0x6E, 0x4B, 0x66, 0x8B, 0x01, 0x77, 0x3F, 0x8C
DB 0x8F, 0x09, 0xF2, 0x9E, 0xCE, 0x9C, 0xC2, 0x94, 0x46, 0x4D
DB 0xF0, 0x36, 0xCE, 0x3B, 0xC0, 0x4A, 0xDC, 0x8A, 0xF6, 0xBE
DB 0xB5, 0x0E, 0xEE, 0x68, 0x8C, 0xDC, 0xF8, 0x04, 0xA1, 0x13
DB 0x97, 0xBC, 0x3B, 0x06, 0x4A, 0x8F, 0x4C, 0x64, 0xBA, 0x0D
DB 0xCC, 0x44, 0xEB, 0x3F, 0xF1, 0x86, 0x6D, 0x64, 0x63, 0xA9
DB 0x35, 0x78, 0xE0, 0x8F, 0xB9, 0x7D, 0xC1, 0xB7, 0x1D, 0x23
DB 0x90, 0xBC, 0x37, 0x36, 0x05, 0x99, 0x21, 0x37, 0x8D, 0xE6
DB 0x29, 0x89, 0x50, 0x30, 0x57, 0xF8, 0xBE, 0xB3, 0x24, 0x98
DB 0x0C, 0x21, 0xE1, 0x32, 0xD1, 0x7F, 0xE8, 0x58, 0xE7, 0x42
DB 0x88, 0x70, 0x05, 0x66, 0x7C, 0xD2, 0x6B, 0x34, 0x46, 0xA9
DB 0xF2, 0x68, 0x00, 0x25, 0x69, 0xF9, 0x68, 0xA6, 0xAE, 0xE4
DB 0x07, 0x73, 0xC6, 0xCE, 0x45, 0xB3, 0x66, 0xA5, 0x50, 0x5E
DB 0x13, 0x54, 0xAF, 0x29, 0xB4, 0x25, 0xC2, 0x25, 0x04, 0x3C
DB 0x16, 0xBC, 0xA2, 0x22, 0x6A, 0xD9, 0x40, 0xA6, 0xE9, 0xE1
DB 0x4C, 0x75, 0xF1, 0xC5, 0x8A, 0x3F, 0xDB, 0x99, 0x28, 0xA9
DB 0x17, 0x85, 0xF1, 0xAC, 0xB1, 0x71, 0x69, 0x1A, 0x92, 0xFB
DB 0x5B, 0xC6, 0x7C, 0x2E, 0x0C, 0x76, 0x7E, 0x1F, 0x27, 0x61
DB 0xF7, 0xA1, 0xF4, 0x00, 0xEB, 0x0C, 0xF2, 0x87, 0x44, 0x19
DB 0x34, 0x43, 0x23, 0xFF, 0x00, 0x2F, 0x0A, 0x25, 0xA9, 0xF4
DB 0x10, 0x47, 0x9E, 0x51, 0x5C, 0xFC, 0x9A, 0x2D, 0x53, 0xA8
DB 0xAD, 0x18, 0x5A, 0xFE, 0x05, 0x86, 0x7D, 0x2C, 0x9A, 0xEE
DB 0x59, 0xCF, 0x23, 0x2F, 0xB5, 0xB2, 0x8D, 0x09, 0xFC, 0x64
DB 0x6B, 0x91, 0xE8, 0x9F, 0xDC, 0x45, 0x80, 0xFF, 0xA7, 0xD7
DB 0xB1, 0x18, 0xF4, 0x1D, 0x18, 0x26, 0xBE, 0x94, 0x1F, 0xE9
DB 0xCF, 0x5B, 0xEC, 0xCD, 0x9C, 0x19, 0x50, 0x52, 0x9D, 0xED
DB 0x5F, 0x88, 0x80, 0x10, 0xBE, 0xB8, 0x19, 0x3F, 0x0E, 0xE4
DB 0x8D, 0x68, 0x6B, 0xC0, 0x36, 0x0F, 0x28, 0x3B, 0xFB, 0xCA
DB 0xDB, 0x6F, 0x55, 0xBA, 0x06, 0xF1, 0x76, 0x4C, 0xE1, 0x29
DB 0x2E, 0x81, 0x88, 0xF3, 0xDE, 0xCE, 0x91, 0xE1, 0x6E, 0xB4
DB 0x59, 0xFE, 0x8D, 0x25, 0x55, 0x02, 0x7D, 0x3A, 0x7C, 0x23
DB 0x6F, 0x1C, 0x16, 0xA6, 0x7B, 0x0E, 0x28, 0x96, 0xEA, 0xE8
DB 0xB9, 0xE4, 0xCD, 0x13, 0x36, 0xF3, 0xF5, 0xA5, 0x67, 0xEF
DB 0x2F, 0xFF, 0xFF, 0xE1, 0x5A, 0x48, 0xEC, 0xF0, 0xB0, 0xFC
DB 0xCB, 0x82, 0x86, 0xFF, 0x49, 0x74, 0xE8, 0x5B, 0xB5, 0x9E
DB 0x28, 0x8B, 0x32, 0x5E, 0xC9, 0x76, 0x32, 0x16, 0xB3, 0xCD
DB 0x96, 0xA0, 0x19, 0xBC, 0xFF, 0xC1, 0xD0, 0x2C, 0x7E, 0x37
DB 0x01, 0x60, 0x51, 0x0E, 0xF0, 0xC0, 0x91, 0x93, 0x5E, 0x22
DB 0x03, 0xCD, 0x13, 0xEF, 0x18, 0x58, 0xA3, 0x8F, 0x07, 0xE6
DB 0xAC, 0xFA, 0xAE, 0x53, 0x29, 0x54, 0x9F, 0x58, 0xB0, 0xDF
DB 0x57, 0x44, 0xD3, 0xB5, 0x83, 0xBA, 0xBA, 0x3A, 0x7D, 0x47
DB 0x00, 0x34, 0x58, 0x41, 0x93, 0x4D, 0xA9, 0x80, 0x77, 0x3E
DB 0xF2, 0xDE, 0x40, 0xE5, 0x93, 0x21, 0x61, 0xF2, 0xD8, 0xCD
DB 0xC6, 0x72, 0x56, 0x68, 0x37, 0x3C, 0xC2, 0x1E, 0xAD, 0x30
DB 0x7E, 0x70, 0xA9, 0xBD, 0x50, 0x2F, 0xB4, 0xB2, 0xD4, 0xD8
DB 0x29, 0x1D, 0x3F, 0x25, 0x0B, 0xD7, 0x7F, 0xE9, 0x5F, 0x2E
DB 0x90, 0x2F, 0x97, 0xF3, 0x79, 0xB8, 0xD0, 0x9E, 0x6D, 0x72
DB 0x10, 0xCA, 0xBE, 0x1E, 0x53, 0xB7, 0xE4, 0x49, 0x35, 0x21
DB 0xC8, 0x10, 0x63, 0x18, 0x7C, 0x8B, 0x26, 0x12, 0x6F, 0xB1
DB 0xB3, 0x2A, 0x6D, 0xFC, 0xA5, 0xF1, 0x66, 0x2F, 0x4C, 0xDB
DB 0x32, 0x1C, 0xBB, 0x80, 0x6A, 0x69, 0x21, 0xF4, 0xB7, 0xAE
DB 0x46, 0x81, 0x23, 0x06, 0xC2, 0x6F, 0xC6, 0xB9, 0x8C, 0x5C
DB 0x87, 0xD6, 0xB8, 0x80, 0x69, 0x36, 0xF2, 0xEF, 0xF0, 0x71
DB 0x2C, 0x44, 0x76, 0x0F, 0xF7, 0x81, 0xD7, 0x02, 0xC5, 0x40
DB 0x84, 0x54, 0xFE, 0x72, 0xFC, 0xD7, 0x10, 0x5E, 0x42, 0xCD
DB 0xE5, 0xD5, 0x03, 0x08, 0x7F, 0x75, 0x62, 0xC0, 0x76, 0xE7
DB 0xD4, 0x59, 0x02, 0x5E, 0x7A, 0xF8, 0x49, 0xF1, 0xD6, 0xA9
DB 0x0A, 0xBF, 0xB2, 0xD9, 0xCF, 0x96, 0x7E, 0x2B, 0xC1, 0xA6
DB 0xD1, 0x11, 0xAE, 0xAF, 0xC2, 0x8C, 0x34, 0x47, 0x15, 0x46
DB 0xCF, 0x4C, 0xB3, 0x31, 0x21, 0xA0, 0xE7, 0x74, 0x42, 0xB3
DB 0x86, 0x9A, 0xED, 0x1E, 0xD4, 0xE1, 0x6B, 0xDE, 0xA6, 0x4F
DB 0xEF, 0x57, 0x6F, 0x00, 0x49, 0x48, 0x1F, 0x09, 0x6D, 0x74
DB 0x53, 0x07, 0x66, 0xC1, 0x83, 0x87, 0xC7, 0xE5, 0x85, 0x74
DB 0x21, 0xF2, 0x79, 0x4E, 0x93, 0x65, 0xE0, 0xC6, 0xBD, 0x79
DB 0x7D, 0xE3, 0xAC, 0xBC, 0x2A, 0xD7, 0x2D, 0xD7, 0xBD, 0x69
DB 0x58, 0x65, 0x33, 0xAF, 0xA6, 0xFD, 0xD0, 0xD9, 0x89, 0xFE
DB 0x07, 0xEE, 0xF8, 0x79, 0xCB, 0x7F, 0xD2, 0x57, 0xFA, 0x7D
DB 0x6E, 0x57, 0x9C, 0x97, 0xD0, 0x21, 0xC5, 0x6C, 0xB6, 0x45
DB 0x7D, 0xF5, 0x90, 0x6E, 0x76, 0x8F, 0x44, 0xC3, 0x91, 0xF5
DB 0xCC, 0xC7, 0x64, 0x5E, 0x64, 0x2A, 0x40, 0xB1, 0x23, 0x2B
DB 0x07, 0x66, 0x5E, 0x68, 0x6D, 0x56, 0x22, 0x6D, 0xB6, 0xAC
DB 0x21, 0xA3, 0xED, 0xEA, 0x32, 0xE9, 0xDA, 0xCC, 0x8B, 0xC3
DB 0xA8, 0x95, 0x75, 0x8A, 0x30, 0xBD, 0x39, 0xBD, 0x42, 0x58
DB 0x46, 0xA1, 0x05, 0x0C, 0x79, 0x89, 0x11, 0x0E, 0x80, 0x4C
DB 0x20, 0x1D, 0x0D, 0x8C, 0x87, 0x9E, 0x4E, 0xC6, 0x2C, 0xD9
DB 0x73, 0xD8, 0x4C, 0xEC, 0x03, 0x10, 0xE5, 0x61, 0xF7, 0xE2
DB 0xAB, 0x1A, 0x43, 0xCF, 0xC0, 0xDD, 0x60, 0xE6, 0xF2, 0xC2
DB 0x70, 0x24, 0x8E, 0xDD, 0x77, 0xEF, 0x94, 0x75, 0x08, 0xB9
DB 0x6F, 0x9C, 0x4A, 0x98, 0x4A, 0x1D, 0xC8, 0xF8, 0x40, 0x9A
DB 0xC7, 0xFD, 0x5E, 0x97, 0x7E, 0x88, 0xBC, 0xF6, 0xDF, 0xCA
DB 0xD4, 0x6B, 0xC0, 0xDB, 0x82, 0x35, 0x9E, 0x49, 0x50, 0x75
DB 0xB1, 0xED, 0x80, 0xF0, 0x02, 0x52, 0x4E, 0xE0, 0x97, 0xB0
DB 0xB4, 0x64, 0x82, 0x40, 0xB2, 0x0F, 0xD4, 0x66, 0x12, 0xB7
DB 0x99, 0x98, 0x0B, 0xD6, 0x4B, 0xEE, 0xC5, 0x72, 0x19, 0xF4
DB 0xCD, 0x79, 0xAE, 0xF4, 0xCD, 0xBA, 0xE9, 0x46, 0xF1, 0x84
DB 0x43, 0xF3, 0xDA, 0xF6, 0xA9, 0x1E, 0xBB, 0xCD, 0xA0, 0xC1
DB 0xAA, 0xFE, 0x11, 0xA4, 0x04, 0x0D, 0xB2, 0x2F, 0xA2, 0x29
DB 0x7A, 0x8A, 0x8B, 0x63, 0xE6, 0x91, 0x19, 0x7D, 0x79, 0x63
DB 0x44, 0xC9, 0x4B, 0xC9, 0x71, 0x69, 0x17, 0x08, 0x64, 0x1C
DB 0x73, 0xFA, 0xD6, 0xC4, 0x0F, 0x0C, 0x5C, 0x4E, 0x29, 0x0F
DB 0x27, 0x2D, 0x3C, 0xBF, 0xFE, 0xFC, 0x74, 0x7D, 0xE0, 0xB2
DB 0x29, 0x79, 0x7D, 0xFB, 0x13, 0xFD, 0x2C, 0xD5, 0x76, 0x77
DB 0xCC, 0x7B, 0x90, 0x39, 0x92, 0x0B, 0x9C, 0xC8, 0x1A, 0x0C
DB 0x21, 0xE5, 0x5B, 0x8B, 0xCE, 0x94, 0x83, 0xB5, 0xCE, 0xC7
DB 0x6C, 0x21, 0xFE, 0x3D, 0xC2, 0x75, 0x03, 0xEC, 0x25, 0xCD
DB 0x1E, 0x02, 0xBA, 0x5D, 0xC7, 0x9F, 0xEB, 0x6C, 0xC0, 0x62
DB 0x00, 0x38, 0x56, 0xAC, 0xD8, 0x8A, 0x44, 0xDB, 0xFE, 0xD7
DB 0xD2, 0xED, 0x48, 0x79, 0xD5, 0x6D, 0x33, 0xCD, 0x70, 0x67
DB 0x0B, 0x75, 0x11, 0x0C, 0x26, 0xAD, 0x75, 0x25, 0x31, 0x5F
DB 0x4D, 0x2D, 0x4A, 0x48, 0xA8, 0x8F, 0x89, 0x99, 0x2E, 0xB4
DB 0xA1, 0xC2, 0x78, 0x72, 0xBC, 0xC8, 0x95, 0x8F, 0x23, 0x7C
DB 0xEF, 0x2C, 0xF7, 0xA9, 0xB0, 0xD3, 0x24, 0x4F, 0x83, 0x6E
DB 0xD4, 0xEB, 0xCE, 0xC5, 0xBE, 0x4B, 0x9C, 0xCD, 0x21, 0x66
DB 0x51, 0x8D, 0xFD, 0xCB, 0xBB, 0xDA, 0xEF, 0xF4, 0x7A, 0xFB
DB 0x2E, 0xAB, 0x09, 0x8A, 0xE1, 0x5D, 0x98, 0x99, 0x8E, 0x8B
DB 0xE1, 0x52, 0x82, 0xDF, 0x49, 0x78, 0xFA, 0xB1, 0xD3, 0x52
DB 0x83, 0xEC, 0x58, 0x4D, 0x2E, 0x21, 0xF8, 0xDF, 0x90, 0xB6
DB 0xED, 0x45, 0xDB, 0x8D, 0x7D, 0xBD, 0xBA, 0x31, 0x04, 0x6B
DB 0xD2, 0x3C, 0xBF, 0x96, 0xCC, 0x65, 0xEB, 0x82, 0x58, 0x29
DB 0x9E, 0x66, 0x51, 0x08, 0xDA, 0xED, 0x9E, 0xA0, 0xA5, 0xAF
DB 0x72, 0xD7, 0x58, 0x11, 0xE2, 0xAE, 0x3A, 0xC2, 0x14, 0x42
DB 0x70, 0x93, 0x86, 0x24, 0x06, 0x83, 0xF0, 0xE3, 0x1A, 0x4D
DB 0x77, 0xB0, 0xDC, 0xC9, 0xD6, 0x62, 0xAA, 0xDD, 0x0F, 0x0D
DB 0xC4, 0x34, 0x67, 0xBC, 0xEE, 0x10, 0xD8, 0x8A, 0x9E, 0xF4
DB 0xD6, 0x74, 0x9F, 0x9F, 0x0F, 0xE9, 0xC6, 0x53, 0x2F, 0xCD
DB 0xAF, 0x1B, 0xF1, 0x9C, 0x5F, 0x29, 0xAB, 0x62, 0x7E, 0xA9
DB 0xF0, 0x76, 0xF4, 0x08, 0x03, 0xEB, 0x2F, 0xDB, 0xD5, 0x8C
DB 0x3D, 0xD5, 0x48, 0x9D, 0x11, 0x6C, 0x98, 0xC4, 0x8A, 0x56
DB 0x1D, 0x96, 0x78, 0x9C, 0xE7, 0xB9, 0xB7, 0x23, 0xD9, 0xE5
DB 0xED, 0x7E, 0x68, 0x93, 0x6B, 0x31, 0x12, 0x51, 0xEF, 0x36
DB 0x5E, 0xA5, 0x23, 0x1B, 0x1F, 0x12, 0x0A, 0xF5, 0x6F, 0x3F
DB 0x54, 0x38, 0x70, 0x9B, 0xC2, 0xCF, 0x15, 0x66, 0x2C, 0xB3
sqrt_2: DB 1
DB 0x6A, 0x09, 0xE6, 0x67, 0xF3, 0xBC, 0xC9, 0x08, 0xB2, 0xFB
DB 0x13, 0x66, 0xEA, 0x95, 0x7D, 0x3E, 0x3A, 0xDE, 0xC1, 0x75
DB 0x12, 0x77, 0x50, 0x99, 0xDA, 0x2F, 0x59, 0x0B, 0x06, 0x67
DB 0x32, 0x2A, 0x95, 0xF9, 0x06, 0x08, 0x75, 0x71, 0x45, 0x87
DB 0x51, 0x63, 0xFC, 0xDF, 0xB9, 0x07, 0xB6, 0x72, 0x1E, 0xE9
DB 0x50, 0xBC, 0x87, 0x38, 0xF6, 0x94, 0xF0, 0x09, 0x0E, 0x6C
DB 0x7B, 0xF4, 0x4E, 0xD1, 0xA4, 0x40, 0x5D, 0x0E, 0x85, 0x5E
DB 0x3E, 0x9C, 0xA6, 0x0B, 0x38, 0xC0, 0x23, 0x78, 0x66, 0xF7
DB 0x95, 0x63, 0x79, 0x22, 0x2D, 0x10, 0x8B, 0x14, 0x8C, 0x15
DB 0x78, 0xE4, 0x5E, 0xF8, 0x9C, 0x67, 0x8D, 0xAB, 0x51, 0x47
DB 0x17, 0x6F, 0xD3, 0xB9, 0x96, 0x54, 0xC6, 0x86, 0x63, 0xE7
DB 0x90, 0x9B, 0xEA, 0x5E, 0x24, 0x1F, 0x06, 0xDC, 0xB0, 0x5D
DB 0xD5, 0x49, 0x41, 0x13, 0x20, 0x81, 0x94, 0x95, 0x02, 0x72
DB 0x95, 0x6D, 0xB1, 0xFA, 0x1D, 0xFB, 0xE9, 0xA7, 0x40, 0x59
DB 0xD7, 0x92, 0x7C, 0x18, 0x84, 0xC9, 0xB5, 0x79, 0xAA, 0x51
DB 0x6C, 0xA3, 0x71, 0x9E, 0x68, 0x36, 0xDF, 0x04, 0x6D, 0x8E
DB 0x02, 0x09, 0xB8, 0x03, 0xFC, 0x64, 0x6A, 0x5E, 0x66, 0x54
DB 0xBD, 0x3E, 0xF7, 0xB4, 0x3D, 0x7F, 0xED, 0x43, 0x7C, 0x7F
DB 0x94, 0x44, 0x26, 0x0F, 0xBD, 0x40, 0xC4, 0x83, 0xEF, 0x55
DB 0x03, 0x85, 0x83, 0xF9, 0x7B, 0xBD, 0x45, 0xEF, 0xB8, 0x66
DB 0x31, 0x07, 0x14, 0x5D, 0x5F, 0xEB, 0xE7, 0x65, 0xA4, 0x9E
DB 0x94, 0xEC, 0x7F, 0x59, 0x71, 0x05, 0xFB, 0xFC, 0x2E, 0x1F
DB 0xA7, 0x63, 0xEF, 0x01, 0xF3, 0x59, 0x9C, 0x82, 0xF2, 0xFE
DB 0x50, 0x0B, 0x84, 0x8C, 0xF0, 0xBD, 0x25, 0x2A, 0xE0, 0x46
DB 0xBF, 0x9F, 0x1E, 0xF7, 0x94, 0x7D, 0x46, 0x76, 0x9A, 0xF8
DB 0xC1, 0x4B, 0xCC, 0x67, 0xC7, 0xC2, 0x90, 0xBE, 0x76, 0x92
DB 0x9B, 0x05, 0x78, 0xC1, 0x0B, 0x58, 0x4F, 0xB4, 0x87, 0xC9
DB 0x24, 0xF5, 0xB7, 0x1F, 0x82, 0xDC, 0xD2, 0x90, 0x36, 0x09
DB 0xDE, 0xE8, 0x91, 0x29, 0x83, 0xD4, 0xEA, 0xAD, 0x0E, 0xEA
DB 0x32, 0x1F, 0x74, 0x89, 0xF4, 0x6A, 0x7E, 0x90, 0x30, 0xBE
DB 0x20, 0xFB, 0x76, 0x94, 0xEF, 0xB5, 0x8C, 0x99, 0x84, 0xCD
DB 0xD7, 0x0A, 0x1D, 0xA9, 0x04, 0x5C, 0x3D, 0x13, 0x3A, 0x06
DB 0x84, 0x23, 0xD6, 0xE3, 0x83, 0x03, 0xD9, 0x01, 0xBA, 0x9D
DB 0xA3, 0x47, 0x66, 0x84, 0x79, 0x6C, 0x5C, 0xD5, 0x97, 0x2D
DB 0xC0, 0xFF, 0x35, 0x40, 0xC3, 0x41, 0x29, 0x42, 0xD6, 0x40
DB 0x61, 0x01, 0xEF, 0x6F, 0xC6, 0xDE, 0x91, 0x14, 0xA2, 0xB4
DB 0xF2, 0x48, 0xC6, 0x89, 0xC6, 0x00, 0xBB, 0x40, 0xA8, 0xB5
DB 0x6B, 0x04, 0x1F, 0xD5, 0xDE, 0x6E, 0x0D, 0xD0, 0xC6, 0x6D
DB 0x48, 0x31, 0xFE, 0x7F, 0xFF, 0x57, 0x57, 0xE4, 0x71, 0x09
DB 0x80, 0xCD, 0xBD, 0x5C, 0x26, 0x84, 0x85, 0xDA, 0x5E, 0x91
DB 0xB3, 0xE2, 0xF2, 0x05, 0xB7, 0x27, 0x25, 0xB9, 0x71, 0xD6
DB 0x0A, 0x1F, 0x88, 0x8F, 0x08, 0xA0, 0xA6, 0xE1, 0x00, 0xCC
DB 0xED, 0xC2, 0xCE, 0x5B, 0xD9, 0x8A, 0xEE, 0x71, 0xE4, 0x2E
DB 0x26, 0x8D, 0x37, 0xA6, 0x07, 0x2F, 0x22, 0x02, 0x34, 0x61
DB 0x3F, 0xFC, 0x22, 0x45, 0x34, 0x39, 0xEA, 0x97, 0xA9, 0x99
DB 0xB6, 0xC9, 0xE3, 0xCE, 0x71, 0xF9, 0x4D, 0x60, 0x92, 0xAC
DB 0xE1, 0x20, 0xAB, 0x8E, 0x55, 0x0E, 0x0D, 0x55, 0x11, 0x68
DB 0x86, 0x31, 0x77, 0x8C, 0xF6, 0x03, 0x50, 0xD0, 0x2F, 0xE8
DB 0x5F, 0x29, 0xEC, 0x8B, 0xE5, 0xC7, 0x2B, 0x80, 0x7A, 0xF5
DB 0x77, 0x1B, 0x82, 0x5B, 0x30, 0xA0, 0xE7, 0x83, 0x76, 0xA9
DB 0x1C, 0x08, 0xC6, 0xA7, 0xF0, 0xF8, 0xF3, 0x23, 0xB3, 0x62
DB 0x81, 0xD2, 0x25, 0x68, 0x9C, 0x0B, 0x5A, 0x82, 0x04, 0x7D
DB 0xB9, 0x89, 0xF6, 0x3A, 0x8A, 0x64, 0xE8, 0x51, 0x9B, 0xC0
DB 0xD0, 0xC1, 0xE2, 0x22, 0x80, 0x48, 0x4D, 0x94, 0xF4, 0xF9
DB 0xBB, 0x3D, 0x4B, 0x31, 0xD4, 0x89, 0xD7, 0x52, 0x31, 0xB5
DB 0xC6, 0x33, 0xC4, 0x80, 0xC9, 0x6B, 0xE5, 0x49, 0xBF, 0x5D
DB 0x96, 0x67, 0x8B, 0x4D, 0x2C, 0x4D, 0xDA, 0x86, 0x7B, 0xD8
DB 0xE4, 0x80, 0x29, 0xFE, 0xA8, 0xC8, 0x17, 0x35, 0x67, 0xC2
DB 0xBA, 0x3D, 0x3C, 0xE9, 0xDF, 0xE0, 0xBD, 0x1B, 0x4D, 0xD7
DB 0x71, 0x17, 0x80, 0x57, 0xB6, 0x95, 0xB7, 0xEA, 0xF1, 0xB0
DB 0x5C, 0x22, 0xC8, 0xD5, 0xFE, 0xEB, 0xD0, 0x77, 0xFE, 0xC9
DB 0x6D, 0xB8, 0xF7, 0x78, 0xFC, 0x1C, 0x2B, 0xBB, 0xCE, 0x1B
DB 0x49, 0xEB, 0xF5, 0xAF, 0x44, 0x60, 0x88, 0x29, 0x58, 0xAD
DB 0xD0, 0x1C, 0xA7, 0xF1, 0xB6, 0xBC, 0x0B, 0x7E, 0xC1, 0xBC
DB 0x6E, 0x0A, 0x6E, 0xDB, 0xC6, 0x7F, 0x85, 0xB2, 0x74, 0xE0
DB 0x86, 0x1B, 0x3A, 0x13, 0x75, 0x71, 0xB1, 0x65, 0x49, 0x87
DB 0x3D, 0x21, 0x1C, 0x6A, 0xAE, 0x69, 0xD8, 0x01, 0xE5, 0x79
DB 0x44, 0x5B, 0xC6, 0x0A, 0x3E, 0x0A, 0x4F, 0xD8, 0x96, 0x8E
DB 0xB7, 0x94, 0xBD, 0xC7, 0x02, 0xD6, 0x94, 0x5D, 0xA9, 0x4B
DB 0x04, 0xA4, 0x40, 0xCA, 0xBC, 0x94, 0x38, 0x7C, 0x3D, 0x26
DB 0xFD, 0x0F, 0x3B, 0xE8, 0xAF, 0x63, 0x05, 0xA5, 0x3A, 0x17
DB 0x72, 0x88, 0xAC, 0xA1, 0x3F, 0xB4, 0x06, 0xC9, 0x82, 0x91
DB 0x5D, 0x83, 0xBA, 0x0D, 0x35, 0x58, 0xD8, 0x1D, 0xD1, 0x15
DB 0x9E, 0x96, 0x43, 0xEA, 0xA2, 0x7E, 0xB7, 0x75, 0x7A, 0x20
DB 0x52, 0x97, 0x5B, 0x6F, 0x4A, 0x88, 0x9E, 0x3D, 0x09, 0x2B
DB 0xB1, 0xC6, 0x85, 0x48, 0x0D, 0xC2, 0xE9, 0x99, 0x47, 0xB3
DB 0x72, 0xDE, 0xDA, 0x05, 0xE2, 0x19, 0x2F, 0x95, 0xB1, 0xB9
DB 0x26, 0x51, 0x2B, 0x40, 0x4C, 0x33, 0x18, 0x1D, 0x64, 0xA3
DB 0x59, 0xA8, 0x9B, 0x6F, 0x88, 0x64, 0xF3, 0xD5, 0x75, 0x31
DB 0x93, 0x59, 0xAA, 0x38, 0x62, 0x57, 0xA9, 0x3A, 0x57, 0xA5
DB 0x97, 0x75, 0x47, 0xFA, 0x0F, 0x60, 0x6C, 0xC3, 0x2E, 0xEA
DB 0x84, 0xEF, 0x71, 0x03, 0xD2, 0xD2, 0xD5, 0x7B, 0x6C, 0x15
DB 0x3A, 0x5F, 0x37, 0xC2, 0xC7, 0x7F, 0xE2, 0x92, 0x8D, 0x32
DB 0x1B, 0x29, 0x47, 0x0E, 0xAE, 0x41, 0x58, 0xB3, 0xCE, 0xDC
DB 0x64, 0xAD, 0xE1, 0xE4, 0x31, 0xA1, 0x38, 0xBB, 0x7B, 0xE7
DB 0x30, 0x5B, 0x46, 0xF7, 0xFE, 0x0B, 0xC7, 0x54, 0xFF, 0x3E
DB 0xC0, 0x42, 0xBD, 0xC8, 0x5B, 0x32, 0x59, 0x96, 0x52, 0x2A
DB 0x87, 0xB8, 0x64, 0x3E, 0x3D, 0x17, 0x87, 0x0F, 0x8C, 0x25
DB 0xB5, 0x97, 0x80, 0x60, 0xD5, 0x5B, 0x82, 0xFD, 0x4E, 0xD3
DB 0xF3, 0xE1, 0x58, 0x92, 0xB5, 0xB5, 0x23, 0x61, 0x82, 0xCB
DB 0x28, 0x31, 0xF4, 0x4C, 0xA2, 0x7A, 0xD1, 0xA6, 0x6F, 0xD5
DB 0x6F, 0xDC, 0x29, 0xA7, 0xC7, 0xA9, 0x3E, 0x42, 0x79, 0xAA
DB 0x12, 0xD4, 0x60, 0xA0, 0xD4, 0x94, 0x95, 0xB6, 0xBE, 0x4D
DB 0xC7, 0x3D, 0xDF, 0x96, 0xEE, 0x80, 0xA9, 0xDF, 0xC2, 0x2D
DB 0x8D, 0x38, 0x5E, 0xA2, 0xEC, 0xC8, 0x01, 0xD7, 0x40, 0xC1
DB 0x99, 0x0C, 0x7B, 0xF2, 0x84, 0x58, 0x48, 0x05, 0x27, 0xBB
DB 0x8B, 0xA8, 0x10, 0x9D, 0x27, 0x70, 0xC3, 0xFF, 0xDE, 0x12
DB 0x1A, 0x7B, 0xE4, 0x34, 0xF8, 0x3D, 0x0A, 0xAB, 0xFB, 0xDE
DB 0x53, 0x1F, 0x74, 0xBA, 0xFD, 0xBC, 0x2D, 0xAF, 0xBE, 0xCE
DB 0x02, 0xE6, 0x5B, 0xB7, 0x7B, 0x8F, 0xBB, 0x8C, 0xDB, 0x4A
DB 0xD8, 0xE4, 0xB9, 0xEF, 0x01, 0xE2, 0xC9, 0x0F, 0x80, 0x69
DB 0xD2, 0x3E, 0xCF, 0xB0, 0xC8, 0xE2, 0xE2, 0x7D, 0x64, 0x7D
DB 0xAA, 0x43, 0x76, 0x2A, 0x64, 0xB9, 0xC7, 0xD7, 0x45, 0x34
DB 0x4F, 0xDB, 0x51, 0x6F, 0xC5, 0x6F, 0xA1, 0xEA, 0xE6, 0xA9
DB 0x58, 0x74, 0xFB, 0x50, 0x1F, 0x69, 0xB1, 0x7B, 0x66, 0xB8
DB 0x1D, 0xFB, 0xA1, 0x1E, 0xD5, 0x24, 0x15, 0xD7, 0xEE, 0x3E
DB 0x53, 0xF9, 0x58, 0x59, 0x46, 0xBB, 0x20, 0x81, 0x61, 0x78
DB 0x05, 0x99, 0x68, 0x05, 0xBB, 0x4F, 0x9D, 0xA7, 0x96, 0xF6
DB 0x33, 0xC9, 0xD1, 0x3F, 0x6C, 0x17, 0x2C, 0x3A, 0xFE, 0x34
DB 0x01, 0xA3, 0x2E, 0x99, 0xDD, 0x6A, 0x24, 0x7E, 0x27, 0x96
DB 0x00, 0xA3, 0xF5, 0xC0, 0x99, 0x91, 0xA6, 0x55, 0x4A, 0x35
DB 0x00, 0x0F, 0xFE, 0x09, 0x0A, 0xBF, 0xBC, 0x2D, 0x8A, 0x4A
DB 0x88, 0x14, 0x59, 0xED, 0x12, 0x7A, 0x54, 0xCC, 0xEC, 0xB6
DB 0x3C, 0xF6, 0x37, 0x3A, 0x71, 0x1C, 0x9C, 0xF9, 0x15, 0x66
DB 0xC3, 0x97, 0xB2, 0x82, 0x78, 0xA7, 0xF0, 0xBB, 0x8B, 0xBC
DB 0x45, 0x16, 0xDD, 0xCA, 0xB0, 0xF6, 0xE9, 0x55, 0x74, 0x48
DB 0xF9, 0x3E, 0xEB, 0x80, 0xF6, 0x9F, 0x34, 0xB5, 0x25, 0xC7
DB 0x60, 0xF3, 0x38, 0x0E, 0xF9, 0xED, 0xB8, 0xAC, 0xEE, 0xFA
DB 0x8D, 0xB3, 0xC7, 0xCE, 0x26, 0xE4, 0x2A, 0xA5, 0x98, 0x4D
DB 0x4D, 0xB9, 0x56, 0x12, 0xEC, 0x52, 0x8A, 0x24, 0x5F, 0xCF
DB 0x43, 0xDB, 0x37, 0x57, 0xF0, 0xA0, 0xA1, 0xFC, 0x24, 0xFE
DB 0x21, 0x8F, 0x4B, 0x63, 0x07, 0x20, 0x90, 0x40, 0x44, 0xB2
DB 0x32, 0xF3, 0x8C, 0x40, 0x32, 0xF1, 0xC3, 0xAB, 0x89, 0x71
DB 0xDD, 0x4F, 0x79, 0x66, 0xDD, 0x97, 0x61, 0x4B, 0xAE, 0x8D
DB 0x79, 0x7A, 0x08, 0x48, 0xB1, 0xD5, 0xCF, 0xDB, 0x13, 0x7D
DB 0x0A, 0x18, 0x1B, 0x20, 0xCE, 0x77, 0x5D, 0x4D, 0xBA, 0xE5
DB 0x13, 0x93, 0xBD, 0x57, 0x2A, 0x26, 0xCC, 0x5C, 0x5E, 0x0B
DB 0xDE, 0x6E, 0x42, 0x33, 0xEF, 0xEA, 0xDA, 0xD3, 0xA0, 0x8D
DB 0x0A, 0xE2, 0x11, 0x9A, 0xC0, 0xCA, 0x4E, 0x07, 0xD3, 0x41
DB 0x50, 0x82, 0xE4, 0x4A, 0xCC, 0x3F, 0x0F, 0xB3, 0x4A, 0xCB
DB 0x07, 0xC9, 0x6F, 0xCB, 0x5D, 0x0F, 0x4B, 0x7D, 0x89, 0x79
DB 0xEA, 0x9C, 0x8E, 0x7F, 0x63, 0x7D, 0x66, 0x16, 0x18, 0xB9
DB 0x78, 0xA7, 0x54, 0x4B, 0xB0, 0x2F, 0xE0, 0x85, 0x51, 0xA2
DB 0x8D, 0x25, 0xDB, 0xCD, 0x92, 0xE4, 0xA3, 0x28, 0x50, 0x29
DB 0xFD, 0xB6, 0x2C, 0xC7, 0xE5, 0xEE, 0x2C, 0x9B, 0x1A, 0x30
DB 0x42, 0x8A, 0x57, 0x49, 0x17, 0x6E, 0x08, 0x5A, 0x29, 0xB5
DB 0xDE, 0x32, 0xBD, 0x6A, 0xD8, 0x45, 0xBB, 0xE2, 0xFA, 0x16
DB 0x52, 0x0C, 0xEA, 0xA8, 0x8B, 0x5B, 0x0B, 0x39, 0xC9, 0x61
DB 0xCC, 0x2D, 0xA3, 0x68, 0x37, 0x43, 0x76, 0x7F, 0x97, 0x33
DB 0x5C, 0x3F, 0xC5, 0x95, 0x71, 0x28, 0x2D, 0x33, 0x8C, 0x39
DB 0xF3, 0x7E, 0x12, 0x96, 0x11, 0xE1, 0x17, 0x46, 0xFE, 0xB7
DB 0x54, 0xCE, 0xB3, 0x76, 0x16, 0x3C, 0x52, 0xA1, 0x0A, 0x2D
DB 0x23, 0xE6, 0x8A, 0x2B, 0xC7, 0xD3, 0x28, 0x7D, 0x1A, 0x72
DB 0x71, 0xC5, 0xEF, 0x90, 0x55, 0x0B, 0x07, 0x05, 0x4A, 0x63
DB 0x35, 0x4C, 0x86, 0xB6, 0xC9, 0x38, 0xF4, 0x5A, 0xE8, 0xD2
DB 0xFD, 0x8C, 0x23, 0x56, 0xD7, 0xC5, 0xAA, 0x21, 0xB2, 0x45
DB 0x76, 0x37, 0x2F, 0xE3, 0x1B, 0xD4, 0x1F, 0x98, 0x36, 0xAF
DB 0x67, 0x44, 0x1F, 0xD0, 0x72, 0x46, 0xD8, 0x41, 0xDE, 0x5C
DB 0xAE, 0x84, 0x61, 0x0C, 0x55, 0xA1, 0x2C, 0xED, 0x62, 0xF4
DB 0xCB, 0x51, 0xFF, 0x3A, 0x3E, 0x1B, 0xD5, 0x18, 0x7E, 0x20
DB 0x8E, 0x40, 0xE0, 0x1E, 0xCC, 0x30, 0xA2, 0x63, 0xC5, 0x4D
DB 0x3B, 0x9B, 0x3C, 0x9A, 0x1D, 0x7B, 0x2A, 0xD9, 0xC3, 0x33
DB 0x06, 0x2B, 0x1D, 0xCC, 0x09, 0x9D, 0x91, 0x8E, 0x32, 0xBB
DB 0xFE, 0xA9, 0x0F, 0x20, 0x83, 0x44, 0x22, 0x20, 0x6E, 0x9F
DB 0x02, 0xDF, 0xD7, 0x51, 0xA4, 0x73, 0xCA, 0x66, 0xD4, 0x74
DB 0xB1, 0x0C, 0xB7, 0xC1, 0x76, 0x32, 0x40, 0xB5, 0x55, 0x15
DB 0x97, 0x04, 0x00, 0xBF, 0x86, 0x0A, 0x98, 0x95, 0x14, 0xB1
DB 0x44, 0x6E, 0x8C, 0xE4, 0x2C, 0xBB, 0x1A, 0x6F, 0x70, 0xDD
DB 0x2F, 0xDF, 0x48, 0xD3, 0x02, 0xF6, 0x35, 0x5B, 0xB1, 0xD1
DB 0xA5, 0x0A, 0x05, 0x14, 0x26, 0x9A, 0x7F, 0xA4, 0x08, 0xEA
DB 0xED, 0xE6, 0xC2, 0x07, 0x15, 0x0A, 0x68, 0x40, 0xA8, 0xC6
DB 0xD2, 0x77, 0x83, 0xEF, 0xA8, 0xF3, 0x13, 0xC9, 0xBC, 0x7C
DB 0xAC, 0xFB, 0x1E, 0xBB, 0xC9, 0xD8, 0xF3, 0x86, 0x69, 0x35
DB 0xE8, 0xFB, 0xE4, 0x91, 0x20, 0xA5, 0xFD, 0x11, 0xD4, 0x64
DB 0x8D, 0xFA, 0xD3, 0xE8, 0x13, 0x92, 0xD7, 0x36, 0xDE, 0x1A
DB 0x29, 0xA4, 0x2D, 0x8E, 0x65, 0xA7, 0x34, 0xAF, 0x48, 0x5D
DB 0x29, 0x5F, 0xB0, 0xC1, 0x1C, 0x91, 0x3A, 0x06, 0xAF, 0x40
DB 0x9B, 0x12, 0x78, 0x6E, 0xC8, 0xF4, 0xD8, 0xE7, 0x81, 0xF3
DB 0xEB, 0xB8, 0x55, 0xE6, 0x87, 0x31, 0x8D, 0x3D, 0x71, 0x3D
DB 0xAD, 0x46, 0xD3, 0xAB, 0xDA, 0x87, 0x79, 0xCB, 0xBE, 0x7A
DB 0x01, 0x2A, 0x21, 0xBA, 0x9A, 0x49, 0xF9, 0x39, 0xD7, 0x8F
DB 0xA6, 0xCE, 0xCD, 0xCC, 0x87, 0x09, 0xEB, 0x79, 0x59, 0xF5
DB 0x24, 0xE2, 0xAC, 0x80, 0x89, 0x7A, 0xF7, 0xD9, 0xC0, 0x20
DB 0x55, 0xBE, 0x67, 0x23, 0xE0, 0x24, 0x2F, 0x77, 0x94, 0x0A
DB 0xAC, 0x6B, 0xE9, 0x1F, 0x0D, 0xC1, 0xB6, 0xDC, 0x01, 0x4D
DB 0xE0, 0x67, 0x97, 0x58, 0x07, 0xA4, 0x46, 0x56, 0x16, 0x78
DB 0xD7, 0x99, 0x27, 0xBF, 0x63, 0xB0, 0x69, 0x63, 0x48, 0x82
DB 0x67, 0x5A, 0x3D, 0x49, 0x53, 0x05, 0x3F, 0x6D, 0x67, 0x50
DB 0xA1, 0xCE, 0x0C, 0x19, 0x66, 0x70, 0x52, 0xD1, 0xEC, 0xEF
DB 0xE2, 0x73, 0x91, 0x4B, 0xD4, 0x25, 0x78, 0xF2, 0x57, 0xBA
DB 0xD3, 0xEB, 0xC1, 0x67, 0x36, 0x0E, 0x91, 0xF1, 0x14, 0x82
DB 0x8E, 0xE1, 0x92, 0xAC, 0xBD, 0x48, 0xDA, 0x1B, 0xC5, 0x37
DB 0x3B, 0x60, 0xB7, 0xF8, 0x10, 0x55, 0x19, 0x70, 0x1B, 0x01
DB 0x4B, 0x68, 0xBE, 0x45, 0x11, 0x39, 0x83, 0x83, 0x8B, 0x6E
DB 0xC6, 0x52, 0x24, 0xED, 0xAF, 0xFC, 0x7E, 0xC0, 0xA8, 0x7C
DB 0xCC, 0xC8, 0xDB, 0xB1, 0x4A, 0xBE, 0xCC, 0x2F, 0x91, 0xA4
DB 0x9A, 0x96, 0x79, 0x45, 0x07, 0x4D, 0xEE, 0x27, 0x56, 0x86
DB 0x2F, 0x08, 0x55, 0xFF, 0xEF, 0x47, 0x7E, 0xD8, 0x46, 0xD2
DB 0xF3, 0x43, 0xC6, 0x9A, 0xA2, 0xB3, 0xCE, 0xE3, 0xFB, 0xA9
DB 0x20, 0xAB, 0xD1, 0x76, 0x0F, 0x54, 0x49, 0x36, 0xC7, 0xAB
DB 0x39, 0x2B, 0x5E, 0xAD, 0x61, 0x98, 0xDF, 0x92, 0x82, 0x3A
DB 0x89, 0x0E, 0xE7, 0x87, 0xBA, 0xDA, 0xBE, 0x2A, 0x72, 0xE9
DB 0x95, 0x6F, 0x56, 0xBF, 0x4D, 0xED, 0xE9, 0x70, 0xA0, 0xC5
DB 0x5A, 0x3F, 0x4E, 0x25, 0x0B, 0x8E, 0xD9, 0xE1, 0x69, 0xB1
DB 0xD3, 0x5F, 0x98, 0x99, 0x8F, 0x4E, 0xD7, 0x8D, 0xD9, 0x9A
DB 0xA7, 0xA2, 0x26, 0x47, 0x21, 0x3B, 0x9B, 0x1E, 0x92, 0xD4
DB 0xF7, 0xAB, 0x0F, 0x16, 0x8D, 0x31, 0x7E, 0x05, 0x8D, 0xD4
DB 0xD8, 0x61, 0x0E, 0x03, 0xAF, 0x7C, 0x63, 0xC2, 0x80, 0xD9
DB 0x56, 0x14, 0x3D, 0x30, 0xA6, 0xA7, 0x0B, 0xE9, 0xAE, 0x91
DB 0x7C, 0x17, 0xA1, 0x88, 0x1B, 0xD5, 0xA4, 0xA5, 0x1C, 0xBB
DB 0xD4, 0x7D, 0xA2, 0xEE, 0xC9, 0x68, 0xD7, 0x9B, 0xE8, 0xDC
DB 0xBA, 0x5E, 0xD0, 0x91, 0xA2, 0xB8, 0x44, 0xF9, 0xCC, 0xB1
DB 0x60, 0x4E, 0x94, 0x1D, 0xB4, 0x5D, 0x47, 0xB8, 0xEC, 0xA6
DB 0x30, 0x26, 0xFB, 0xB6, 0x43, 0xE1, 0x9B, 0x2F, 0x7D, 0x1D
DB 0xF8, 0x87, 0x24, 0x31, 0xF7, 0x3B, 0x75, 0x17, 0xC7, 0x77
DB 0x0F, 0x0C, 0x97, 0x34, 0x74, 0x40, 0xD4, 0xF9, 0x38, 0xA5
DB 0x6F, 0xB5, 0xB1, 0x3E, 0x5A, 0x1C, 0x35, 0x57, 0x64, 0xBD
DB 0xB3, 0x51, 0xBD, 0x69, 0xD0, 0xFB, 0x7E, 0xA3, 0x7F, 0x42
DB 0xD6, 0x28, 0xA1, 0x23, 0x8E, 0x53, 0xCE, 0x7B, 0x89, 0xFB
DB 0xAA, 0xBF, 0x02, 0xB6, 0x3D, 0xBD, 0x9D, 0x8B, 0x7E, 0x41
DB 0x29, 0x18, 0x80, 0x54, 0x42, 0xBB, 0x96, 0x8C, 0x69, 0x55
DB 0x68, 0x9D, 0xF1, 0xF9, 0xE4, 0x25, 0x2A, 0xC0, 0x42, 0x60
DB 0x9E, 0x9A, 0xFD, 0x7A, 0xBB, 0xB2, 0xF4, 0xD7, 0x53, 0x90
DB 0xEA, 0xD2, 0x35, 0xA6, 0xB1, 0x07, 0x55, 0x3A, 0xB8, 0xD7
DB 0x1A, 0x5B, 0x45, 0x62, 0xDC, 0x92, 0x8F, 0xC3, 0xB6, 0xF7
DB 0xC4, 0x3C, 0xA2, 0xB2, 0xF9, 0x3A, 0xE8, 0xB9, 0x1B, 0x7F
DB 0x06, 0x63, 0x9F, 0xD5, 0x5E, 0xE2, 0x63, 0x72, 0x7A, 0x25
DB 0x16, 0xE0, 0xE3, 0x82, 0x7A, 0x42, 0x61, 0xCA, 0x8C, 0xF0
DB 0xED, 0x0A, 0xC8, 0x4B, 0x57, 0xBB, 0x03, 0x20, 0xAF, 0x8D
DB 0x4A, 0x6F, 0x60, 0x91, 0x1E, 0xB3, 0x8A, 0xA4, 0xCE, 0x78
DB 0x2B, 0xA4, 0xFE, 0x9F, 0xC4, 0x98, 0x92, 0xB9, 0x07, 0xE8
DB 0x02, 0xA3, 0xAA, 0x0D, 0x68, 0xFB, 0x98, 0x25, 0x4F, 0x65
DB 0x4A, 0xE8, 0x4A, 0x40, 0xEF, 0x07, 0x8A, 0xA2, 0x34, 0xC4
DB 0xC5, 0x1C, 0xF5, 0xC5, 0xD2, 0x52, 0x5D, 0x1E, 0x39, 0x85
DB 0xF7, 0x0E, 0x87, 0x0A, 0x4C, 0xE3, 0x69, 0x5B, 0xF0, 0xB0
DB 0xAD, 0x80, 0x96, 0x06, 0xD0, 0x72, 0xF0, 0xD3, 0xD2, 0xBC
DB 0x30, 0x12, 0xE8, 0x43, 0x7D, 0xA1, 0x2F, 0x15, 0x10, 0x87
DB 0x6A, 0x48, 0xA1, 0x2D, 0x84, 0xDC, 0x10, 0xCC, 0xEA, 0x92
DB 0x2A, 0x26, 0x7E, 0x93, 0x2B, 0x23, 0xEE, 0x26, 0xA1, 0x2B
DB 0x05, 0x3E, 0xDB, 0x5A, 0xEA, 0xA8, 0x56, 0x24, 0xCF, 0xD3
DB 0x54, 0x01, 0xF0, 0x1E, 0xCA, 0x15, 0xB0, 0xF1, 0x20, 0xF9
DB 0x1A, 0xF1, 0xD3, 0xB4, 0x2A, 0x94, 0x0D, 0xB5, 0xDA, 0xEB
DB 0x7F, 0x4C, 0xE1, 0x53, 0xBF, 0xE8, 0xDA, 0x57, 0x84, 0xDA
DB 0x83, 0x86, 0xB5, 0x6E, 0xE3, 0x3E, 0x93, 0x25, 0xB7, 0x15
DB 0xB9, 0xDC, 0xBF, 0x39, 0x2D, 0xF9, 0xCB, 0x2F, 0x84, 0xB5
DB 0xD7, 0xBE, 0x6B, 0xA2, 0x41, 0xAB, 0x57, 0x98, 0x09, 0x9F
DB 0xEA, 0x94, 0x37, 0x7A, 0x46, 0x22, 0xF5, 0x5F, 0x48, 0xDE
DB 0x74, 0xED, 0x08, 0x2E, 0x15, 0x94, 0x8C, 0x2C, 0xC8, 0xED
DB 0xDA, 0xF2, 0xE7, 0xDC, 0x99, 0xAA, 0xA9, 0xD2, 0x45, 0xD1
DB 0xD7, 0x0D, 0x91, 0xEA, 0xED, 0x59, 0x14, 0xF7, 0x0E, 0x68
DB 0xE3, 0xC7, 0x4E, 0x0C, 0xB1, 0x0C, 0x1A, 0xD0, 0x7C, 0xF2
DB 0x85, 0x4B, 0x9B, 0x5E, 0x5A, 0x50, 0x69, 0x84, 0xAD, 0x61
DB 0x78, 0x18, 0x90, 0x6C, 0x7C, 0x4D, 0xF3, 0xAF, 0x36, 0xAC
DB 0x76, 0x3A, 0x94, 0x18, 0x9F, 0x3C, 0x67, 0xB4, 0x7E, 0xBF
DB 0xDE, 0x2D, 0x68, 0x1F, 0x95, 0x1C, 0x3B, 0x56, 0x4C, 0xDD
DB 0xA4, 0xD6, 0xEB, 0xE8, 0xB7, 0x3E, 0x2C, 0x8A, 0xB1, 0x35
DB 0xB8, 0x29, 0x93, 0xC1, 0xA4, 0x0D, 0xAB, 0xAB, 0xCE, 0x83
DB 0x36, 0xD4, 0x33, 0x06, 0xF3, 0x0F, 0x05, 0x6F, 0xF2, 0x7D
DB 0x96, 0x08, 0xFA, 0x19, 0x49, 0x0A, 0xC2, 0xAC, 0xF9, 0xDF
DB 0x3C, 0x24, 0x32, 0x8B, 0x8C, 0x0D, 0x2F, 0xC0, 0x87, 0xB0
DB 0xC2, 0x11, 0xAE, 0xB4, 0x2C, 0xCD, 0x7C, 0x1F, 0xEF, 0xB3
DB 0x4B, 0x81, 0x80, 0x2B, 0xFD, 0xD3, 0x48, 0x99, 0x1E, 0xC7
DB 0x45, 0x72, 0xC2, 0xAE, 0x2E, 0x10, 0xCE, 0x78, 0xC9, 0x53
DB 0xEB, 0x89, 0x41, 0xAB, 0xF7, 0x4B, 0x88, 0xC7, 0x38, 0xAF
DB 0x78, 0x8A, 0x57, 0x1A, 0xE3, 0xDB, 0xE8, 0xAC, 0x35, 0x87
DB 0xD5, 0xA3, 0xA5, 0x57, 0xAB, 0xDA, 0xEB, 0x9D, 0x87, 0x16
DB 0x71, 0xD6, 0xD8, 0x69, 0x1D, 0xC1, 0x7F, 0xA5, 0x8F, 0x07
DB 0x5A, 0xD4, 0x6C, 0x39, 0x86, 0x6D, 0x52, 0x0D, 0x96, 0x4B
DB 0x4B, 0x6D, 0xB3, 0x62, 0xA2, 0x83, 0x1E, 0xEB, 0x93, 0x6D
DB 0x08, 0xE1, 0x0A, 0x05, 0x11, 0xCE, 0x04, 0x70, 0xBE, 0x20
DB 0x7D, 0xC6, 0x64, 0xB3, 0xD6, 0x88, 0x88, 0x51, 0x8F, 0xE1
DB 0xC1, 0x8C, 0x90, 0x37, 0x98, 0x90, 0x15, 0xD3, 0xD5, 0x76
DB 0x71, 0x4F, 0xCE, 0x03, 0x90, 0xEA, 0xBF, 0xB1, 0x17, 0xDC
DB 0x13, 0x38, 0xAA, 0xB6, 0x9E, 0x8B, 0x87, 0xDA, 0x13, 0x51
DB 0xBC, 0xA7, 0x75, 0xA4, 0x12, 0xBA, 0x71, 0x91, 0x17, 0x68
DB 0x88, 0x39, 0x13, 0x0B, 0x8F, 0xAD, 0xF2, 0xA4, 0x09, 0x92
DB 0xF5, 0x40, 0xDF, 0xC0, 0x26, 0xEE, 0x24, 0xBE, 0xF3, 0xF4
DB 0xD0, 0x16, 0x99, 0xDD, 0x2E, 0xB8, 0x16, 0x86, 0x87, 0x30
DB 0x61, 0x87, 0x49, 0x1B, 0x27, 0xDB, 0xA7, 0x26, 0xFA, 0xDE
DB 0x50, 0x99, 0xEA, 0xAF, 0x33, 0x39, 0x8F, 0x81, 0x8A, 0xF8
DB 0x69, 0x71, 0xC1, 0xE5, 0xFB, 0x19, 0x4A, 0x92, 0x7D, 0x46
DB 0xEB, 0xE9, 0xF2, 0xC4, 0x56, 0x77, 0x1B, 0xD0, 0x7D, 0x89
DB 0x22, 0xE4, 0x38, 0x28, 0xB5, 0xFF, 0x03, 0x3B, 0x74, 0x61
END各项常数预留了 6572 位，足够任何SIZE 之用。
如想增加 CONST常数的数量，先把TERMA的计算结果，汇出成专有的DB 格式，然后插入在程式的未端, 再在前面加一个独一无异的常数名称便可。汇出 TERMA的代码如下：
bash
; 汇出 255 的立方根:
MOV DPTR, #T19_MSG
CALL PRTSTR
CALL CLR_TERMA
MOV DPTR, #TERMA
MOV A, #255
MOVX @DPTR, A ; a = 255
MOV DIV_L, #3 ; DIV_L = 3, cube root
CALL ROOT
CALL OUT_HEXA
JMP $