From 8a4fc1aab9a0d4bb78a8f9b9bce10d93548e31d0 Mon Sep 17 00:00:00 2001 From: xfong Date: Tue, 2 Nov 2021 11:11:50 +0800 Subject: [PATCH] Update 1.1 to threefry PRNG (#6) * first code clean up * partition mtgp32 parameters into separate file * push mtgp32 parameters into separate files * Merge branch 'stashing initial edits * attempt build of threefry prng * file path fixes * clean up files * rename rng files * added kernels for threefry prng * integrated threefry prng * fixed compile * running threefry * clean threefry prng * added tester for threefry * cleaned threefry tester * complete threefry rng implementation and integration * update version --- engine/engine.go | 2 +- engine/temperature.go | 4 +- opencl/Makefile | 4 + opencl/kernels_src/cl/RNGmtgp_init.cl | 8 +- opencl/kernels_src/cl/RNGthreefry_init.cl | 87 + opencl/kernels_src/cl/RNGthreefry_normal.cl | 221 + opencl/kernels_src/cl/RNGthreefry_uint.cl | 166 + opencl/kernels_src/cl/RNGthreefry_uniform.cl | 184 + opencl/kernels_src/cl/RNGxorwow_normal.cl | 60 +- opencl/kernels_src/cl/RNGxorwow_uniform.cl | 36 +- opencl/kernels_src/clh/RNGthreefry.clh | 252 + opencl/kernels_src/sequencecl.go | 7 +- opencl/oclRAND/RNGmtgp.go | 41 +- opencl/oclRAND/RNGthreefry.go | 102 + opencl/oclRAND/mtgp32-11213.go | 273 + opencl/oclRAND/mtgp32.go | 11532 ----------------- opencl/oclRAND/mtgp32_typedef.txt | 24 +- opencl/oclRAND/mtgp32dc-params-11213.go | 11269 ++++++++++++++++ opencl/oclRAND/threefry.go | 89 + opencl/oclRAND/xorwow.go | 6 +- opencl/rng.go | 22 +- test/rk4temperature.mx3 | 2 +- 22 files changed, 12743 insertions(+), 11648 deletions(-) create mode 100644 opencl/kernels_src/cl/RNGthreefry_init.cl create mode 100644 opencl/kernels_src/cl/RNGthreefry_normal.cl create mode 100644 opencl/kernels_src/cl/RNGthreefry_uint.cl create mode 100644 opencl/kernels_src/cl/RNGthreefry_uniform.cl create mode 100644 opencl/kernels_src/clh/RNGthreefry.clh create mode 100644 opencl/oclRAND/RNGthreefry.go create mode 100644 opencl/oclRAND/mtgp32-11213.go delete mode 100644 opencl/oclRAND/mtgp32.go create mode 100644 opencl/oclRAND/mtgp32dc-params-11213.go create mode 100644 opencl/oclRAND/threefry.go diff --git a/engine/engine.go b/engine/engine.go index f7ce971..2e269bb 100644 --- a/engine/engine.go +++ b/engine/engine.go @@ -20,7 +20,7 @@ import ( "time" ) -const VERSION = "uMagNUS 1.1" +const VERSION = "uMagNUS 1.2" var UNAME = VERSION + " " + runtime.GOOS + "_" + runtime.GOARCH + " " + runtime.Version() + " (" + runtime.Compiler + ")" diff --git a/engine/temperature.go b/engine/temperature.go index caee99b..c12fbb9 100644 --- a/engine/temperature.go +++ b/engine/temperature.go @@ -44,7 +44,7 @@ func initRNG() uint64 { func (b *thermField) UpdateSeed(seedVal *uint64) { if b.generator == nil { - b.generator = opencl.NewGenerator("mtgp") + b.generator = opencl.NewGenerator("threefry") } if seedVal == nil { b.seed = initRNG() @@ -69,7 +69,7 @@ func (b *thermField) update() { } if b.generator == nil { - b.generator = opencl.NewGenerator("mtgp") + b.generator = opencl.NewGenerator("threefry") b.seed = initRNG() b.UpdateSeed(&b.seed) } diff --git a/opencl/Makefile b/opencl/Makefile index e367642..6dbe867 100644 --- a/opencl/Makefile +++ b/opencl/Makefile @@ -11,9 +11,13 @@ WRAPPERS := $(WRAPPERFILES:.cl=_wrapper.go) all: ocl2go wrappers opencl2go + mv RNGmrg32k3a*_wrapper.go oclRAND/. mv RNGmtgp*_wrapper.go oclRAND/. + mv RNGthreefry*_wrapper.go oclRAND/. mv RNGxorwow*_wrapper.go oclRAND/. + sed -i "s/package opencl/package oclRAND/g" oclRAND/RNGmrg32k3a*wrapper.go sed -i "s/package opencl/package oclRAND/g" oclRAND/RNGmtgp*wrapper.go + sed -i "s/package opencl/package oclRAND/g" oclRAND/RNGthreefry*wrapper.go sed -i "s/package opencl/package oclRAND/g" oclRAND/RNGxorwow*wrapper.go go install -v diff --git a/opencl/kernels_src/cl/RNGmtgp_init.cl b/opencl/kernels_src/cl/RNGmtgp_init.cl index 43bdda5..e370171 100644 --- a/opencl/kernels_src/cl/RNGmtgp_init.cl +++ b/opencl/kernels_src/cl/RNGmtgp_init.cl @@ -22,18 +22,22 @@ __kernel void mtgp32_init_seed_kernel( __constant uint* sh1_tbl, __constant uint* sh2_tbl, __global uint* d_status, - uint seed) + __global uint* seed) { const int gid = get_group_id(0); const int lid = get_local_id(0); const int local_size = get_local_size(0); __local uint status[MTGP32_N]; + __local uint seedVal; mtgp32_t mtgp; mtgp.status = status; mtgp.param_tbl = ¶m_tbl[MTGP32_TS * gid]; // initialize - mtgp32_init_state(&mtgp, seed + gid); + if (lid == 0) { + seedVal = seed[gid]; + } + mtgp32_init_state(&mtgp, seedVal); barrier(CLK_LOCAL_MEM_FENCE); d_status[gid * MTGP32_N + lid] = status[lid]; diff --git a/opencl/kernels_src/cl/RNGthreefry_init.cl b/opencl/kernels_src/cl/RNGthreefry_init.cl new file mode 100644 index 0000000..2d5d728 --- /dev/null +++ b/opencl/kernels_src/cl/RNGthreefry_init.cl @@ -0,0 +1,87 @@ +/** +@file +Implements threefry RNG. +******************************************************* + * Modified version of Random123 library: + * https://www.deshawresearch.com/downloads/download_random123.cgi/ + * The original copyright can be seen here: + * + * RANDOM123 LICENSE AGREEMENT + * + * Copyright 2010-2011, D. E. Shaw Research. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions, and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions, and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of D. E. Shaw Research nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *********************************************************/ + +/** +State of threefry RNG. We will store in global buffer as a set of uint +** +counter: uint[4] +key: uint[4] +state: uint[4] +index: uint +typedef struct{ + uint counter[4]; + uint result[4]; + uint key[4]; + uint tracker; +} threefry_state; +**/ + +/** +Seeds threefry RNG. +@param state Variable, that holds state of the generator to be seeded. +@param seed Value used for seeding. Should be randomly generated for each instance of generator (thread). +**/ +__kernel void +threefry_seed(__global uint __restrict *state_key, + __global uint __restrict *state_counter, + __global uint __restrict *state_result, + __global uint __restrict *state_tracker, + __global uint __restrict *seed) { + uint gid = get_global_id(0); + uint rng_count = get_global_size(0); + uint idx = gid; + uint localJ = seed[gid]; + state_key[idx] = localJ; + state_counter[idx] = 0x00000000; + state_result[idx] = 0x00000000; + state_tracker[idx] = 4; + idx += rng_count; + state_key[idx] = 0x00000000; + state_counter[idx] = 0x00000000; + state_result[idx] = 0x00000000; + idx += rng_count; + state_key[idx] = gid; + state_counter[idx] = 0x00000000; + state_result[idx] = 0x00000000; + idx += rng_count; + state_key[idx] = 0x00000000; + state_counter[idx] = 0x00000000; + state_result[idx] = 0x00000000; +} diff --git a/opencl/kernels_src/cl/RNGthreefry_normal.cl b/opencl/kernels_src/cl/RNGthreefry_normal.cl new file mode 100644 index 0000000..99f8d3a --- /dev/null +++ b/opencl/kernels_src/cl/RNGthreefry_normal.cl @@ -0,0 +1,221 @@ +/** +@file +Implements threefry RNG. +******************************************************* + * Modified version of Random123 library: + * https://www.deshawresearch.com/downloads/download_random123.cgi/ + * The original copyright can be seen here: + * + * RANDOM123 LICENSE AGREEMENT + * + * Copyright 2010-2011, D. E. Shaw Research. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions, and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions, and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of D. E. Shaw Research nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *********************************************************/ + +/** +State of threefry RNG. We will store in global buffer as a set of uint +** +typedef struct{ + uint counter[4]; + uint result[4]; + uint key[4]; + uint tracker; +} threefry_state; +**/ + +/** +Generates a random 32-bit unsigned integer using threefry RNG. +@param state State of the RNG to use. +**/ +__kernel void +threefry_normal(__global uint __restrict *state_key, + __global uint __restrict *state_counter, + __global uint __restrict *state_result, + __global uint __restrict *state_tracker, + __global float __restrict *output, + int data_size) { + uint gid = get_global_id(0); + uint rng_count = get_global_size(0); + uint tmpIdx = gid; + threefry_state state_; + threefry_state *state = &state_; + + // For first out of four sets... + // Read in counter + state->counter[0] = state_counter[tmpIdx]; + // Read in result + state->result[0] = state_result[tmpIdx]; + // Read in key + state->key[0] = state_key[tmpIdx]; + // Read in tracker + state->tracker = state_tracker[tmpIdx]; + + // For second out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[1] = state_counter[tmpIdx]; + // Read in result + state->result[1] = state_result[tmpIdx]; + // Read in key + state->key[1] = state_key[tmpIdx]; + + // For third out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[2] = state_counter[tmpIdx]; + // Read in result + state->result[2] = state_result[tmpIdx]; + // Read in key + state->key[2] = state_key[tmpIdx]; + + // For last out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[3] = state_counter[tmpIdx]; + // Read in result + state->result[3] = state_result[tmpIdx]; + // Read in key + state->key[3] = state_key[tmpIdx]; + + for (uint outIndex = gid; outIndex < data_size / 2; outIndex += rng_count) { + uint num1[2]; + float res1[4]; + uint lidx = 0; + if (state->tracker > 3) { + threefry_round(state); + state->tracker = 1; + num1[lidx++] = state->result[0]; + } else if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + num1[lidx++] = tmp; + } else { + num1[lidx++] = state->result[state->tracker++]; + } + if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + num1[lidx] = tmp; + } else { + num1[lidx] = state->result[state->tracker++]; + } + res1[0] = uint2float(num1[0], num1[1]); + lidx = 0; + if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + num1[lidx++] = tmp; + } else { + num1[lidx++] = state->result[state->tracker++]; + } + if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + num1[lidx] = tmp; + } else { + num1[lidx] = state->result[state->tracker++]; + } + res1[1] = uint2float(num1[0], num1[1]); + res1[2] = sqrt( -2.0f * log(res1[0])) * cospi(2.0f * res1[1]); + res1[3] = sqrt( -2.0f * log(res1[0])) * sinpi(2.0f * res1[1]); + output[outIndex] = res1[2]; + output[outIndex + (data_size/2)] = res1[3]; + } + + // For first out of four sets... + // Write out counter + tmpIdx = gid; + state_counter[tmpIdx] = state->counter[0]; + // Write out result + state_result[tmpIdx] = state->result[0]; + // Write out key + state_key[tmpIdx] = state->key[0]; + // Write out tracker + state_tracker[tmpIdx] = state->tracker; + + // For second out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[1]; + // Write out result + state_result[tmpIdx] = state->result[1]; + // Write out key + state_key[tmpIdx] = state->key[1]; + + // For third out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[2]; + // Write out result + state_result[tmpIdx] = state->result[2]; + // Write out key + state_key[tmpIdx] = state->key[2]; + + // For last out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[3]; + // Write out result + state_result[tmpIdx] = state->result[3]; + // Write out key + state_key[tmpIdx] = state->key[3]; + +} diff --git a/opencl/kernels_src/cl/RNGthreefry_uint.cl b/opencl/kernels_src/cl/RNGthreefry_uint.cl new file mode 100644 index 0000000..1429266 --- /dev/null +++ b/opencl/kernels_src/cl/RNGthreefry_uint.cl @@ -0,0 +1,166 @@ +/** +@file +Implements threefry RNG. +******************************************************* + * Modified version of Random123 library: + * https://www.deshawresearch.com/downloads/download_random123.cgi/ + * The original copyright can be seen here: + * + * RANDOM123 LICENSE AGREEMENT + * + * Copyright 2010-2011, D. E. Shaw Research. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions, and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions, and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of D. E. Shaw Research nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *********************************************************/ + +/** +State of threefry RNG. We will store in global buffer as a set of uint +** +typedef struct{ + uint counter[4]; + uint result[4]; + uint key[4]; + uint tracker; +} threefry_state; +**/ + +/** +Generates a random 32-bit unsigned integer using threefry RNG. +@param state State of the RNG to use. +**/ +__kernel void +threefry_uint(__global uint __restrict *state_key, + __global uint __restrict *state_counter, + __global uint __restrict *state_result, + __global uint __restrict *state_tracker, + __global uint __restrict *output, + int data_size) { + uint gid = get_global_id(0); + uint rng_count = get_global_size(0); + uint tmpIdx = gid; + threefry_state state_; + threefry_state *state = &state_; + + // For first out of four sets... + // Read in counter + state->counter[0] = state_counter[tmpIdx]; + // Read in result + state->result[0] = state_result[tmpIdx]; + // Read in key + state->key[0] = state_key[tmpIdx]; + // Read in tracker + state->tracker = state_tracker[tmpIdx]; + + // For second out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[1] = state_counter[tmpIdx]; + // Read in result + state->result[1] = state_result[tmpIdx]; + // Read in key + state->key[1] = state_key[tmpIdx]; + + // For third out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[2] = state_counter[tmpIdx]; + // Read in result + state->result[2] = state_result[tmpIdx]; + // Read in key + state->key[2] = state_key[tmpIdx]; + + // For last out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[3] = state_counter[tmpIdx]; + // Read in result + state->result[3] = state_result[tmpIdx]; + // Read in key + state->key[3] = state_key[tmpIdx]; + + for (uint outIndex = gid; outIndex < data_size; outIndex += rng_count) { + if (state->tracker > 3) { + threefry_round(state); + state->tracker = 1; + output[outIndex] = state->result[0]; + } else if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + output[outIndex] = tmp; + } else { + output[outIndex] = state->result[state->tracker++]; + } + } + + // For first out of four sets... + // Write out counter + tmpIdx = gid; + state_counter[tmpIdx] = state->counter[0]; + // Write out result + state_result[tmpIdx] = state->result[0]; + // Write out key + state_key[tmpIdx] = state->key[0]; + // Write out tracker + state_tracker[tmpIdx] = state->tracker; + + // For second out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[1]; + // Write out result + state_result[tmpIdx] = state->result[1]; + // Write out key + state_key[tmpIdx] = state->key[1]; + + // For third out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[2]; + // Write out result + state_result[tmpIdx] = state->result[2]; + // Write out key + state_key[tmpIdx] = state->key[2]; + + // For last out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[3]; + // Write out result + state_result[tmpIdx] = state->result[3]; + // Write out key + state_key[tmpIdx] = state->key[3]; + +} diff --git a/opencl/kernels_src/cl/RNGthreefry_uniform.cl b/opencl/kernels_src/cl/RNGthreefry_uniform.cl new file mode 100644 index 0000000..0772a02 --- /dev/null +++ b/opencl/kernels_src/cl/RNGthreefry_uniform.cl @@ -0,0 +1,184 @@ +/** +@file +Implements threefry RNG. +******************************************************* + * Modified version of Random123 library: + * https://www.deshawresearch.com/downloads/download_random123.cgi/ + * The original copyright can be seen here: + * + * RANDOM123 LICENSE AGREEMENT + * + * Copyright 2010-2011, D. E. Shaw Research. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions, and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions, and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of D. E. Shaw Research nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *********************************************************/ + +/** +State of threefry RNG. We will store in global buffer as a set of uint +** +typedef struct{ + uint counter[4]; + uint result[4]; + uint key[4]; + uint tracker; +} threefry_state; +**/ + +/** +Generates a random 32-bit unsigned integer using threefry RNG. +@param state State of the RNG to use. +**/ +__kernel void +threefry_uniform(__global uint __restrict *state_key, + __global uint __restrict *state_counter, + __global uint __restrict *state_result, + __global uint __restrict *state_tracker, + __global float __restrict *output, + int data_size) { + uint gid = get_global_id(0); + uint rng_count = get_global_size(0); + uint tmpIdx = gid; + threefry_state state_; + threefry_state *state = &state_; + + // For first out of four sets... + // Read in counter + state->counter[0] = state_counter[tmpIdx]; + // Read in result + state->result[0] = state_result[tmpIdx]; + // Read in key + state->key[0] = state_key[tmpIdx]; + // Read in tracker + state->tracker = state_tracker[tmpIdx]; + + // For second out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[1] = state_counter[tmpIdx]; + // Read in result + state->result[1] = state_result[tmpIdx]; + // Read in key + state->key[1] = state_key[tmpIdx]; + + // For third out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[2] = state_counter[tmpIdx]; + // Read in result + state->result[2] = state_result[tmpIdx]; + // Read in key + state->key[2] = state_key[tmpIdx]; + + // For last out of four sets... + tmpIdx += rng_count; + // Read in counter + state->counter[3] = state_counter[tmpIdx]; + // Read in result + state->result[3] = state_result[tmpIdx]; + // Read in key + state->key[3] = state_key[tmpIdx]; + + for (uint outIndex = gid; outIndex < data_size; outIndex += rng_count) { + uint num1[2]; + uint lidx = 0; + if (state->tracker > 3) { + threefry_round(state); + state->tracker = 1; + num1[lidx++] = state->result[0]; + } else if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + num1[lidx++] = tmp; + } else { + num1[lidx++] = state->result[state->tracker++]; + } + if (state->tracker == 3) { + uint tmp = state->result[3]; + if (++state->counter[0] == 0) { + if (++state->counter[1] == 0) { + if (++state->counter[2] == 0) { + ++state->counter[3]; + } + } + } + threefry_round(state); + state->tracker = 0; + num1[lidx] = tmp; + } else { + num1[lidx] = state->result[state->tracker++]; + } + output[outIndex] = uint2float(num1[0], num1[1]); + } + + // For first out of four sets... + // Write out counter + tmpIdx = gid; + state_counter[tmpIdx] = state->counter[0]; + // Write out result + state_result[tmpIdx] = state->result[0]; + // Write out key + state_key[tmpIdx] = state->key[0]; + // Write out tracker + state_tracker[tmpIdx] = state->tracker; + + // For second out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[1]; + // Write out result + state_result[tmpIdx] = state->result[1]; + // Write out key + state_key[tmpIdx] = state->key[1]; + + // For third out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[2]; + // Write out result + state_result[tmpIdx] = state->result[2]; + // Write out key + state_key[tmpIdx] = state->key[2]; + + // For last out of four sets... + // Write out counter + tmpIdx += rng_count; + state_counter[tmpIdx] = state->counter[3]; + // Write out result + state_result[tmpIdx] = state->result[3]; + // Write out key + state_key[tmpIdx] = state->key[3]; + +} diff --git a/opencl/kernels_src/cl/RNGxorwow_normal.cl b/opencl/kernels_src/cl/RNGxorwow_normal.cl index 2d1dbfb..7374a13 100644 --- a/opencl/kernels_src/cl/RNGxorwow_normal.cl +++ b/opencl/kernels_src/cl/RNGxorwow_normal.cl @@ -75,41 +75,7 @@ __kernel void xorwow_normal( uint num2 = d+x[4]; - // Find single-precision floating point representation - // for the integer formed by the pair of uint32... - // the approach is to treat the uint64 as a 32-bit uint - // with 32 fractional bits. We divide the number by - // 2^32 to get the floating point number. The steps are - // to first find the 23-bit mantissa based on the uint64. - // We then use the position of the leading 1 to find the - // relative exponent. For example, if the MSB in the - // first uint32 is 1, then the integer portion is at - // least 2^31, which means dividing by 2^32 gives a - // result between 0.5f (0x3f000000) and 1.0f (0x3f800000). - // Hence, the exponent bits are 01111110 = 126. Note that - // the PRNG never returns uint32(0) so we are guaranteed. - // that a leading 1 exists in the first uint32. - uint finalNum = 0; - uint expo = 32; - for (;expo > 0; expo--) { - uint flag0 = num1 & 0x80000000; - num1 <<= 1; - if (flag0 != 0) { - break; - } - } - if (expo < 23) { - uint maskbits = 0xffffffff; - uint shPos = 23 - expo; - maskbits >>= shPos; - maskbits <<= shPos; - maskbits = ~maskbits; - finalNum ^= (num2 & maskbits); - } - finalNum ^= (num1 >> 9); - uint newExpo = 94 + expo; - finalNum ^= newExpo << 23; - float tmpRes1 = as_float(finalNum); // output value + float tmpRes1 = uint2float(num1, num2); // output value // Repeat for second float... // generate a pair of uint32 (one uint64) @@ -137,29 +103,7 @@ __kernel void xorwow_normal( num2 = d+x[4]; - // Find single-precision floating point representation - // for the integer formed by the pair of uint32... - finalNum = 0; - expo = 32; - for (;expo > 0; expo--) { - uint flag0 = num1 & 0x80000000; - num1 <<= 1; - if (flag0 != 0) { - break; - } - } - if (expo < 23) { - uint maskbits = 0xffffffff; - uint shPos = 23 - expo; - maskbits >>= shPos; - maskbits <<= shPos; - maskbits = ~maskbits; - finalNum ^= (num2 & maskbits); - } - finalNum ^= (num1 >> 9); - newExpo = 94 + expo; - finalNum ^= newExpo << 23; - float tmpRes2 = as_float(finalNum); // output value + float tmpRes2 = uint2float(num1, num2); // output value z0 = sqrt( -2.0f * log(tmpRes1)) * cospi(2.0f * tmpRes2); z1 = sqrt( -2.0f * log(tmpRes1)) * sinpi(2.0f * tmpRes2); diff --git a/opencl/kernels_src/cl/RNGxorwow_uniform.cl b/opencl/kernels_src/cl/RNGxorwow_uniform.cl index 58b1442..fed7dac 100644 --- a/opencl/kernels_src/cl/RNGxorwow_uniform.cl +++ b/opencl/kernels_src/cl/RNGxorwow_uniform.cl @@ -71,41 +71,7 @@ __kernel void xorwow_uniform( uint num2 = d+x[4]; - // Find single-precision floating point representation - // for the integer formed by the pair of uint32... - // the approach is to treat the uint64 as a 32-bit uint - // with 32 fractional bits. We divide the number by - // 2^32 to get the floating point number. The steps are - // to first find the 23-bit mantissa based on the uint64. - // We then use the position of the leading 1 to find the - // relative exponent. For example, if the MSB in the - // first uint32 is 1, then the integer portion is at - // least 2^31, which means dividing by 2^32 gives a - // result between 0.5f (0x3f000000) and 1.0f (0x3f800000). - // Hence, the exponent bits are 01111110 = 126. Note that - // the PRNG never returns uint32(0) so we are guaranteed. - // that a leading 1 exists in the first uint32. - uint finalNum = 0; - uint expo = 32; - for (;expo > 0; expo--) { - uint flag0 = num1 & 0x80000000; - num1 <<= 1; - if (flag0 != 0) { - break; - } - } - if (expo < 23) { - uint maskbits = 0xffffffff; - uint shPos = 23 - expo; - maskbits >>= shPos; - maskbits <<= shPos; - maskbits = ~maskbits; - finalNum ^= (num2 & maskbits); - } - finalNum ^= (num1 >> 9); - uint newExpo = 94 + expo; - finalNum ^= newExpo << 23; - d_data[pos] = as_float(finalNum); // output value + d_data[pos] = uint2float(num1, num2); // output value } // update the state buffer with the latest state diff --git a/opencl/kernels_src/clh/RNGthreefry.clh b/opencl/kernels_src/clh/RNGthreefry.clh new file mode 100644 index 0000000..65cac1c --- /dev/null +++ b/opencl/kernels_src/clh/RNGthreefry.clh @@ -0,0 +1,252 @@ +#define THREEFRY_ELEMENTS_PER_BLOCK 256 +#define SKEIN_KS_PARITY64 0x1BD11BDAA9FC1A22 +#define SKEIN_KS_PARITY32 0x1BD11BDA +constant int THREEFRY2X64_ROTATION[] = {16, 42, 12, 31, 16, 32, 24, 21}; + +constant int THREEFRY4X32_ROTATION_0[] = {10, 26}; +constant int THREEFRY4X32_ROTATION_1[] = {11, 21}; +constant int THREEFRY4X32_ROTATION_2[] = {13, 27}; +constant int THREEFRY4X32_ROTATION_3[] = {23, 5}; +constant int THREEFRY4X32_ROTATION_4[] = { 6, 20}; +constant int THREEFRY4X32_ROTATION_5[] = {17, 11}; +constant int THREEFRY4X32_ROTATION_6[] = {25, 10}; +constant int THREEFRY4X32_ROTATION_7[] = {18, 20}; + +/** +State of threefry RNG. +*/ +typedef struct{ + uint counter[4]; + uint result[4]; + uint key[4]; + uint tracker; +} threefry_state; + +static inline ulong RotL64(ulong x, uint N){ + return (x << (N & 63)) | (x >> ((64 - N) & 63)); +} + +static inline ulong RotL32(uint x, uint N){ + return (x << (N & 31)) | (x >> ((32 - N) & 31)); +} + +static inline void threefry_round(threefry_state* state){ + uint ks[5]; // + ks[4] = SKEIN_KS_PARITY32; + + // Unrolled for loop + ks[0] = state->key[0]; + state->result[0] = state->counter[0]; + ks[4] ^= state->key[0]; + ks[1] = state->key[1]; + state->result[1] = state->counter[1]; + ks[4] ^= state->key[1]; + ks[2] = state->key[2]; + state->result[2] = state->counter[2]; + ks[4] ^= state->key[2]; + ks[3] = state->key[3]; + state->result[3] = state->counter[3]; + ks[4] ^= state->key[3]; + + /* Insert initial key before round 0 */ + state->result[0] += ks[0]; + state->result[1] += ks[1]; + state->result[2] += ks[2]; + state->result[3] += ks[3]; + + /* First round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_0[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_0[1]); + state->result[3] ^= state->result[2]; + + /* Second round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_1[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_1[1]); + state->result[1] ^= state->result[2]; + + /* Third round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_2[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_2[1]); + state->result[3] ^= state->result[2]; + + /* Fourth round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_3[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_3[1]); + state->result[1] ^= state->result[2]; + + /* InjectKey(r=1) */ + state->result[0] += ks[1]; + state->result[1] += ks[2]; + state->result[2] += ks[3]; + state->result[3] += ks[4]; + state->result[3] += 1; /* X[4-1] += r */ + + /* Fifth round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_4[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_4[1]); + state->result[3] ^= state->result[2]; + + /* Sixth round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_5[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_5[1]); + state->result[1] ^= state->result[2]; + + /* Seventh round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_6[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_6[1]); + state->result[3] ^= state->result[2]; + + /* Eighth round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_7[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_7[1]); + state->result[1] ^= state->result[2]; + + /* InjectKey(r=2) */ + state->result[0] += ks[2]; + state->result[1] += ks[3]; + state->result[2] += ks[4]; + state->result[3] += ks[0]; + state->result[3] += 2; /* X[4-1] += r */ + + /* 9-th round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_0[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_0[1]); + state->result[3] ^= state->result[2]; + + /* 10-th round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_1[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_1[1]); + state->result[1] ^= state->result[2]; + + /* 11-th round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_2[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_2[1]); + state->result[3] ^= state->result[2]; + + /* 12-th round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_3[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_3[1]); + state->result[1] ^= state->result[2]; + + /* InjectKey(r=3) */ + state->result[0] += ks[3]; + state->result[1] += ks[4]; + state->result[2] += ks[0]; + state->result[3] += ks[1]; + state->result[3] += 3; /* X[4-1] += r */ + + /* 13-th round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_4[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_4[1]); + state->result[3] ^= state->result[2]; + + /* 14-th round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_5[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_5[1]); + state->result[1] ^= state->result[2]; + + /* 15-th round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_6[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_6[1]); + state->result[3] ^= state->result[2]; + + /* 16-th round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_7[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_7[1]); + state->result[1] ^= state->result[2]; + + /* InjectKey(r=4) */ + state->result[0] += ks[4]; + state->result[1] += ks[0]; + state->result[2] += ks[1]; + state->result[3] += ks[2]; + state->result[3] += 4; /* X[4-1] += r */ + + /* 17-th round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_0[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_0[1]); + state->result[3] ^= state->result[2]; + + /* 18-th round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_1[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_1[1]); + state->result[1] ^= state->result[2]; + + /* 19-th round */ + state->result[0] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_2[0]); + state->result[1] ^= state->result[0]; + state->result[2] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_2[1]); + state->result[3] ^= state->result[2]; + + /* 20-th round */ + state->result[0] += state->result[3]; + state->result[3] = RotL32(state->result[3], THREEFRY4X32_ROTATION_3[0]); + state->result[3] ^= state->result[0]; + state->result[2] += state->result[1]; + state->result[1] = RotL32(state->result[1], THREEFRY4X32_ROTATION_3[1]); + state->result[1] ^= state->result[2]; + + /* InjectKey(r=5) */ + state->result[0] += ks[0]; + state->result[1] += ks[1]; + state->result[2] += ks[2]; + state->result[3] += ks[3]; + state->result[3] += 5; /* X[4-1] += r */ + +} diff --git a/opencl/kernels_src/sequencecl.go b/opencl/kernels_src/sequencecl.go index 6e05f43..09b9336 100644 --- a/opencl/kernels_src/sequencecl.go +++ b/opencl/kernels_src/sequencecl.go @@ -11,9 +11,10 @@ var OCLHeadersList = []string{ "atomicf", "reduce", "amul", + "RNG_common", "RNGmrg32k3a", "RNGmtgp", - "RNG_common", + "RNGthreefry", "RNGxorwow", "sum"} @@ -85,4 +86,8 @@ var OCLKernelsList = []string{ "xorwow_uint", "xorwow_uniform", "xorwow_normal", + "threefry_seed", + "threefry_uint", + "threefry_uniform", + "threefry_normal", "square"} diff --git a/opencl/oclRAND/RNGmtgp.go b/opencl/oclRAND/RNGmtgp.go index d9e06c4..1f8605e 100644 --- a/opencl/oclRAND/RNGmtgp.go +++ b/opencl/oclRAND/RNGmtgp.go @@ -7,21 +7,48 @@ import ( "github.com/seeder-research/uMagNUS/opencl/cl" "github.com/seeder-research/uMagNUS/timer" + "math/rand" ) func (p *MTGP32dc_params_array_ptr) Init(seed uint64, events []*cl.Event) { - SeedVal := seed << 32 - SeedVal = SeedVal >> 32 - if SeedVal == 0 { - SeedVal = seed >> 32 + // Generate random seed array to seed the PRNG + rand.Seed((int64)(seed)) + totalCount := p.GetGroupCount() + seed_arr := make([]uint32, totalCount) + for idx := 0; idx < totalCount; idx++ { + tmpNum := rand.Uint32() + for tmpNum == 0 { + tmpNum = rand.Uint32() + } + seed_arr[idx] = tmpNum } + + // Copy random seed array to GPU + context := p.GetContext() + seed_buf, err := context.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(seed_arr[0]))*totalCount, nil) + defer seed_buf.Release() + if err != nil { + log.Fatalln("Unable to create buffer for mtgp32 seed array!") + } + var seed_event *cl.Event + seed_event, err = ClCmdQueue.EnqueueWriteBuffer(seed_buf, false, 0, int(unsafe.Sizeof(seed_arr[0]))*totalCount, unsafe.Pointer(&seed_arr[0]), nil) + if err != nil { + log.Fatalln("Unable to write seed buffer to device: ", err) + } + if events != nil { + err = cl.WaitForEvents(events) + if err != nil { + fmt.Printf("First WaitForEvents failed in InitRNG: %+v \n", err) + } + } + event := k_mtgp32_init_seed_kernel_async(unsafe.Pointer(p.Rec_buf), unsafe.Pointer(p.Temper_buf), unsafe.Pointer(p.Flt_temper_buf), unsafe.Pointer(p.Pos_buf), - unsafe.Pointer(p.Sh1_buf), unsafe.Pointer(p.Sh2_buf), unsafe.Pointer(p.Status_buf), uint32(SeedVal), - &config{[]int{p.GetGroupCount() * p.GetGroupSize()}, []int{p.GetGroupSize()}}, events) + unsafe.Pointer(p.Sh1_buf), unsafe.Pointer(p.Sh2_buf), unsafe.Pointer(p.Status_buf), unsafe.Pointer(seed_buf), + &config{[]int{p.GetGroupCount() * p.GetGroupSize()}, []int{p.GetGroupSize()}}, []*cl.Event{seed_event}) p.Ini = true - err := cl.WaitForEvents([]*cl.Event{event}) + err = cl.WaitForEvents([]*cl.Event{event}) if err != nil { fmt.Printf("WaitForEvents failed in InitRNG: %+v \n", err) } diff --git a/opencl/oclRAND/RNGthreefry.go b/opencl/oclRAND/RNGthreefry.go new file mode 100644 index 0000000..a0a2cbd --- /dev/null +++ b/opencl/oclRAND/RNGthreefry.go @@ -0,0 +1,102 @@ +package oclRAND + +import ( + "fmt" + "log" + "unsafe" + + "github.com/seeder-research/uMagNUS/opencl/cl" + "github.com/seeder-research/uMagNUS/timer" + "math/rand" +) + +func (p *THREEFRY_status_array_ptr) Init(seed uint64, events []*cl.Event) { + // Generate random seed array to seed the PRNG + rand.Seed((int64)(seed)) + totalCount := p.GetStatusSize() + seed_arr := make([]uint32, totalCount) + for idx := 0; idx < totalCount; idx++ { + tmpNum := rand.Uint32() + for tmpNum == 0 { + tmpNum = rand.Uint32() + } + seed_arr[idx] = tmpNum + } + + // Copy random seed array to GPU + context := p.GetContext() + seed_buf, err := context.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(seed_arr[0]))*totalCount, nil) + defer seed_buf.Release() + if err != nil { + log.Fatalln("Unable to create buffer for THREEFRY seed array!") + } + var seed_event *cl.Event + seed_event, err = ClCmdQueue.EnqueueWriteBuffer(seed_buf, false, 0, int(unsafe.Sizeof(seed_arr[0]))*totalCount, unsafe.Pointer(&seed_arr[0]), nil) + if err != nil { + log.Fatalln("Unable to write seed buffer to device: ", err) + } + if events != nil { + err = cl.WaitForEvents(events) + if err != nil { + fmt.Printf("First WaitForEvents failed in InitRNG: %+v \n", err) + } + } + + // Seed the RNG + event := k_threefry_seed_async(unsafe.Pointer(p.Status_key), unsafe.Pointer(p.Status_counter), + unsafe.Pointer(p.Status_result), unsafe.Pointer(p.Status_tracker), unsafe.Pointer(seed_buf), + &config{[]int{totalCount}, []int{p.GetGroupSize()}}, []*cl.Event{seed_event}) + + p.Ini = true + err = cl.WaitForEvents([]*cl.Event{event}) + if err != nil { + fmt.Printf("Second WaitForEvents failed in InitRNG: %+v \n", err) + } + +} + +func (p *THREEFRY_status_array_ptr) GenerateUniform(d_data unsafe.Pointer, data_size int, events []*cl.Event) *cl.Event { + + if p.Ini == false { + log.Fatalln("Generator has not been initialized!") + } + + if Synchronous { // debug + ClCmdQueue.Finish() + timer.Start("threefry_uniform") + } + + event := k_threefry_uniform_async(unsafe.Pointer(p.Status_key), unsafe.Pointer(p.Status_counter), + unsafe.Pointer(p.Status_result), unsafe.Pointer(p.Status_tracker), d_data, data_size, + &config{[]int{p.GetStatusSize()}, []int{p.GetGroupSize()}}, events) + + if Synchronous { // debug + ClCmdQueue.Finish() + timer.Stop("threefry_uniform") + } + + return event +} + +func (p *THREEFRY_status_array_ptr) GenerateNormal(d_data unsafe.Pointer, data_size int, events []*cl.Event) *cl.Event { + + if p.Ini == false { + log.Fatalln("Generator has not been initialized!") + } + + if Synchronous { // debug + ClCmdQueue.Finish() + timer.Start("threefry_normal") + } + + event := k_threefry_normal_async(unsafe.Pointer(p.Status_key), unsafe.Pointer(p.Status_counter), + unsafe.Pointer(p.Status_result), unsafe.Pointer(p.Status_tracker), d_data, data_size, + &config{[]int{p.GetStatusSize()}, []int{p.GetGroupSize()}}, events) + + if Synchronous { // debug + ClCmdQueue.Finish() + timer.Stop("threefry_normal") + } + + return event +} diff --git a/opencl/oclRAND/mtgp32-11213.go b/opencl/oclRAND/mtgp32-11213.go new file mode 100644 index 0000000..11d961e --- /dev/null +++ b/opencl/oclRAND/mtgp32-11213.go @@ -0,0 +1,273 @@ +package oclRAND + +import ( + "github.com/seeder-research/uMagNUS/opencl/cl" + "log" + "unsafe" +) + +const MTGPDC_MEXP = 11213 +const MTGPDC_N = 351 +const MTGPDC_FLOOR_2P = 256 +const MTGPDC_CEIL_2P = 512 +const MTGPDC_TN = MTGPDC_FLOOR_2P +const MTGPDC_LS = (MTGPDC_TN * 3) +const MTGPDC_TS = 16 + +const MTGPDC_PARAMS_NUM = mtgpdc_params_11213_num + +var mtgpdc_params_num = mtgpdc_params_11213_num +var MTGP32_params_fast_ = MTGP32_params_fast_11213 + +type MTGP32dc_params_fast_t struct { + mexp int /**< Mersenne exponent. This is redundant. */ + pos int /**< pick up position. */ + sh1 int /**< shift value 1. 0 < sh1 < 32. */ + sh2 int /**< shift value 2. 0 < sh2 < 32. */ + tbl [16]uint32 /**< a small matrix. */ + tmp_tbl [16]uint32 /**< a small matrix for tempering. */ + flt_tmp_tbl [16]uint32 /**< a small matrix for tempering and converting to float. */ + mask uint32 /**< This is a mask for state space */ + poly_sha1 [21]string /**< SHA1 digest */ +} + +type MTGP32dc_params_array_ptr struct { + Ini bool + Pos []int + Sh1 []int + Sh2 []int + Rec []uint32 + Temper []uint32 + Flt_temper []uint32 + Status []uint32 + Pos_buf *cl.MemObject + Sh1_buf *cl.MemObject + Sh2_buf *cl.MemObject + Rec_buf *cl.MemObject + Temper_buf *cl.MemObject + Flt_temper_buf *cl.MemObject + Status_buf *cl.MemObject + Pos_size int + Sh1_size int + Sh2_size int + Rec_size int + Temper_size int + Flt_temper_size int + Status_size int + GroupSize int + GroupCount int + ClCtx *cl.Context +} + +func NewMTGPParams() *MTGP32dc_params_array_ptr { + q := new(MTGP32dc_params_array_ptr) + q.Ini = false + q.GroupSize = MTGPDC_N + q.GroupCount = 1 + return q +} + +func (p *MTGP32dc_params_array_ptr) GetMTGPArrays() { + if (p.GroupSize > mtgpdc_params_num) || (p.GroupSize < 0) { + log.Fatalln("Input range: 0 < GroupSize < ", mtgpdc_params_num) + } + rec_array := make([]uint32, (MTGPDC_TS * p.GroupCount)) + temper_array := make([]uint32, (MTGPDC_TS * p.GroupCount)) + flt_temper_array := make([]uint32, (MTGPDC_TS * p.GroupCount)) + pos_array := make([]int, p.GroupCount) + sh1_array := make([]int, p.GroupCount) + sh2_array := make([]int, p.GroupCount) + status_array := make([]uint32, MTGPDC_N*p.GroupCount) + for i := 0; i < p.GroupCount; i++ { + for j := 0; j < MTGPDC_TS; j++ { + rec_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].tbl[j] + temper_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].tmp_tbl[j] + flt_temper_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].flt_tmp_tbl[j] + } + pos_array[i] = MTGP32_params_fast_[i].pos + sh1_array[i] = MTGP32_params_fast_[i].sh1 + sh2_array[i] = MTGP32_params_fast_[i].sh2 + } + + p.Pos = pos_array + p.Pos_size = int(unsafe.Sizeof(pos_array[0])) * len(pos_array) + p.Sh1 = sh1_array + p.Sh1_size = int(unsafe.Sizeof(sh1_array[0])) * len(sh1_array) + p.Sh2 = sh2_array + p.Sh2_size = int(unsafe.Sizeof(sh2_array[0])) * len(sh2_array) + p.Rec = rec_array + p.Rec_size = int(unsafe.Sizeof(rec_array[0])) * len(rec_array) + p.Temper = temper_array + p.Temper_size = int(unsafe.Sizeof(temper_array[0])) * len(temper_array) + p.Flt_temper = flt_temper_array + p.Flt_temper_size = int(unsafe.Sizeof(flt_temper_array[0])) * len(flt_temper_array) + p.Status = status_array + p.Status_size = int(unsafe.Sizeof(status_array[0])) * len(status_array) + + p.Pos_buf = nil + p.Sh1_buf = nil + p.Sh2_buf = nil + p.Rec_buf = nil + p.Temper_buf = nil + p.Flt_temper_buf = nil + p.Status_buf = nil +} + +func (p *MTGP32dc_params_array_ptr) CreateParamBuffers(context *cl.Context) { + var err error + p.Pos_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Pos[0]))*len(p.Pos), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 pos array!") + } + p.Sh1_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Sh1[0]))*len(p.Sh1), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 sh1 array!") + } + p.Sh2_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Sh2[0]))*len(p.Sh2), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 sh2 array!") + } + p.Rec_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Rec[0]))*len(p.Rec), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 rec array!") + } + p.Temper_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Temper[0]))*len(p.Temper), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 temper array!") + } + p.Flt_temper_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Flt_temper[0]))*len(p.Flt_temper), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 flt_temper array!") + } + p.Status_buf, err = context.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(p.Status[0]))*len(p.Status), nil) + if err != nil { + log.Fatalln("Unable to create buffer for MTGP32 status array!") + } + p.SetContext(context) +} + +func (p *MTGP32dc_params_array_ptr) LoadAllParamBuffersToDevice(eventWaitList []*cl.Event) ([]*cl.Event, error) { + var err error + + var pos_event *cl.Event + pos_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Pos_buf, false, 0, p.Pos_size, unsafe.Pointer(&p.Pos[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write pos buffer to device: ", err) + } + + var sh1_event *cl.Event + sh1_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Sh1_buf, false, 0, p.Sh1_size, unsafe.Pointer(&p.Sh1[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write sh1 buffer to device: ", err) + } + + var sh2_event *cl.Event + sh2_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Sh2_buf, false, 0, p.Sh2_size, unsafe.Pointer(&p.Sh2[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write sh2 buffer to device: ", err) + } + + var rec_event *cl.Event + rec_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Rec_buf, false, 0, p.Rec_size, unsafe.Pointer(&p.Rec[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write rec buffer to device: ", err) + } + + var temper_event *cl.Event + temper_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Temper_buf, false, 0, p.Temper_size, unsafe.Pointer(&p.Temper[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write temper buffer to device: ", err) + } + + var flt_temper_event *cl.Event + flt_temper_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Flt_temper_buf, false, 0, p.Flt_temper_size, unsafe.Pointer(&p.Flt_temper[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write flt_temper buffer to device: ", err) + } + + return []*cl.Event{pos_event, sh1_event, sh2_event, rec_event, temper_event, flt_temper_event}, nil +} + +func (p *MTGP32dc_params_array_ptr) LoadStatusBuffersToDevice(eventWaitList []*cl.Event) (*cl.Event, error) { + status_event, err := ClCmdQueue.EnqueueWriteBuffer(p.Status_buf, false, 0, p.Status_size, unsafe.Pointer(&p.Status[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to write status buffer to device: ", err) + } + return status_event, nil +} + +func (p *MTGP32dc_params_array_ptr) LoadStatusBuffersFromDevice(eventWaitList []*cl.Event) (*cl.Event, error) { + status_event, err := ClCmdQueue.EnqueueReadBuffer(p.Status_buf, false, 0, p.Status_size, unsafe.Pointer(&p.Status[0]), eventWaitList) + if err != nil { + log.Fatalln("Unable to read status buffer from device: ", err) + } + return status_event, nil +} + +func (p *MTGP32dc_params_array_ptr) SetRecursionArray(arr []uint32) { + p.Rec = arr +} + +func (p *MTGP32dc_params_array_ptr) GetRecursionArray() []uint32 { + return p.Rec +} + +func (p *MTGP32dc_params_array_ptr) SetPositionArray(arr []int) { + p.Pos = arr +} + +func (p *MTGP32dc_params_array_ptr) GetPositionArray() []int { + return p.Pos +} + +func (p *MTGP32dc_params_array_ptr) SetSH1Array(arr []int) { + p.Sh1 = arr +} + +func (p *MTGP32dc_params_array_ptr) GetSH1Array() []int { + return p.Sh1 +} + +func (p *MTGP32dc_params_array_ptr) SetSH2Array(arr []int) { + p.Sh2 = arr +} + +func (p *MTGP32dc_params_array_ptr) GetSH2Array() []int { + return p.Sh2 +} + +func (p *MTGP32dc_params_array_ptr) SetStatusArray(arr []uint32) { + p.Status = arr +} + +func (p *MTGP32dc_params_array_ptr) GetStatusArray() []uint32 { + return p.Status +} + +func (p *MTGP32dc_params_array_ptr) SetGroupSize(in int) { + p.GroupSize = in +} + +func (p *MTGP32dc_params_array_ptr) GetGroupSize() int { + return p.GroupSize +} + +func (p *MTGP32dc_params_array_ptr) SetGroupCount(in int) { + p.GroupCount = in +} + +func (p *MTGP32dc_params_array_ptr) GetGroupCount() int { + return p.GroupCount +} + +func (p *MTGP32dc_params_array_ptr) RecommendSize() int { + return 12 * p.GroupCount * MTGPDC_TN +} + +func (p *MTGP32dc_params_array_ptr) SetContext(context *cl.Context) { + p.ClCtx = context +} + +func (p *MTGP32dc_params_array_ptr) GetContext() *cl.Context { + return p.ClCtx +} diff --git a/opencl/oclRAND/mtgp32.go b/opencl/oclRAND/mtgp32.go deleted file mode 100644 index 4b90c1d..0000000 --- a/opencl/oclRAND/mtgp32.go +++ /dev/null @@ -1,11532 +0,0 @@ -package oclRAND - -import ( - "github.com/seeder-research/uMagNUS/opencl/cl" - "log" - "unsafe" -) - -const MTGPDC_MEXP = 11213 -const MTGPDC_N = 351 -const MTGPDC_FLOOR_2P = 256 -const MTGPDC_CEIL_2P = 512 -const MTGPDC_TN = MTGPDC_FLOOR_2P -const MTGPDC_LS = (MTGPDC_TN * 3) -const MTGPDC_TS = 16 - -const MTGPDC_PARAMS_NUM = mtgpdc_params_11213_num - -var mtgpdc_params_num = mtgpdc_params_11213_num -var MTGP32_params_fast_ = MTGP32_params_fast_11213 - -type MTGP32dc_params_fast_t struct { - mexp int /**< Mersenne exponent. This is redundant. */ - pos int /**< pick up position. */ - sh1 int /**< shift value 1. 0 < sh1 < 32. */ - sh2 int /**< shift value 2. 0 < sh2 < 32. */ - tbl [16]uint32 /**< a small matrix. */ - tmp_tbl [16]uint32 /**< a small matrix for tempering. */ - flt_tmp_tbl [16]uint32 /**< a small matrix for tempering and converting to float. */ - mask uint32 /**< This is a mask for state space */ - poly_sha1 [21]string /**< SHA1 digest */ -} - -type MTGP32dc_params_array_ptr struct { - Ini bool - Pos []int - Sh1 []int - Sh2 []int - Rec []uint32 - Temper []uint32 - Flt_temper []uint32 - Status []uint32 - Pos_buf *cl.MemObject - Sh1_buf *cl.MemObject - Sh2_buf *cl.MemObject - Rec_buf *cl.MemObject - Temper_buf *cl.MemObject - Flt_temper_buf *cl.MemObject - Status_buf *cl.MemObject - Pos_size int - Sh1_size int - Sh2_size int - Rec_size int - Temper_size int - Flt_temper_size int - Status_size int - GroupSize int - GroupCount int -} - -func NewMTGPParams() *MTGP32dc_params_array_ptr { - q := new(MTGP32dc_params_array_ptr) - q.Ini = false - q.GroupSize = MTGPDC_N - q.GroupCount = 1 - return q -} - -func (p *MTGP32dc_params_array_ptr) GetMTGPArrays() { - if (p.GroupSize > mtgpdc_params_num) || (p.GroupSize < 0) { - log.Fatalln("Input range: 0 < GroupSize < ", mtgpdc_params_num) - } - rec_array := make([]uint32, (MTGPDC_TS * p.GroupCount)) - temper_array := make([]uint32, (MTGPDC_TS * p.GroupCount)) - flt_temper_array := make([]uint32, (MTGPDC_TS * p.GroupCount)) - pos_array := make([]int, p.GroupCount) - sh1_array := make([]int, p.GroupCount) - sh2_array := make([]int, p.GroupCount) - status_array := make([]uint32, MTGPDC_N*p.GroupCount) - for i := 0; i < p.GroupCount; i++ { - for j := 0; j < MTGPDC_TS; j++ { - rec_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].tbl[j] - temper_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].tmp_tbl[j] - flt_temper_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].flt_tmp_tbl[j] - } - pos_array[i] = MTGP32_params_fast_[i].pos - sh1_array[i] = MTGP32_params_fast_[i].sh1 - sh2_array[i] = MTGP32_params_fast_[i].sh2 - } - - p.Pos = pos_array - p.Pos_size = int(unsafe.Sizeof(pos_array[0])) * len(pos_array) - p.Sh1 = sh1_array - p.Sh1_size = int(unsafe.Sizeof(sh1_array[0])) * len(sh1_array) - p.Sh2 = sh2_array - p.Sh2_size = int(unsafe.Sizeof(sh2_array[0])) * len(sh2_array) - p.Rec = rec_array - p.Rec_size = int(unsafe.Sizeof(rec_array[0])) * len(rec_array) - p.Temper = temper_array - p.Temper_size = int(unsafe.Sizeof(temper_array[0])) * len(temper_array) - p.Flt_temper = flt_temper_array - p.Flt_temper_size = int(unsafe.Sizeof(flt_temper_array[0])) * len(flt_temper_array) - p.Status = status_array - p.Status_size = int(unsafe.Sizeof(status_array[0])) * len(status_array) - - p.Pos_buf = nil - p.Sh1_buf = nil - p.Sh2_buf = nil - p.Rec_buf = nil - p.Temper_buf = nil - p.Flt_temper_buf = nil - p.Status_buf = nil -} - -func (p *MTGP32dc_params_array_ptr) CreateParamBuffers(context *cl.Context) { - var err error - p.Pos_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Pos[0]))*len(p.Pos), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 pos array!") - } - p.Sh1_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Sh1[0]))*len(p.Sh1), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 sh1 array!") - } - p.Sh2_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Sh2[0]))*len(p.Sh2), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 sh2 array!") - } - p.Rec_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Rec[0]))*len(p.Rec), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 rec array!") - } - p.Temper_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Temper[0]))*len(p.Temper), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 temper array!") - } - p.Flt_temper_buf, err = context.CreateBufferUnsafe(cl.MemReadOnly, int(unsafe.Sizeof(p.Flt_temper[0]))*len(p.Flt_temper), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 flt_temper array!") - } - p.Status_buf, err = context.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(p.Status[0]))*len(p.Status), nil) - if err != nil { - log.Fatalln("Unable to create buffer for MTGP32 status array!") - } -} - -func (p *MTGP32dc_params_array_ptr) LoadAllParamBuffersToDevice(eventWaitList []*cl.Event) ([]*cl.Event, error) { - var err error - - var pos_event *cl.Event - pos_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Pos_buf, false, 0, p.Pos_size, unsafe.Pointer(&p.Pos[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write pos buffer to device: ", err) - } - - var sh1_event *cl.Event - sh1_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Sh1_buf, false, 0, p.Sh1_size, unsafe.Pointer(&p.Sh1[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write sh1 buffer to device: ", err) - } - - var sh2_event *cl.Event - sh2_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Sh2_buf, false, 0, p.Sh2_size, unsafe.Pointer(&p.Sh2[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write sh2 buffer to device: ", err) - } - - var rec_event *cl.Event - rec_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Rec_buf, false, 0, p.Rec_size, unsafe.Pointer(&p.Rec[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write rec buffer to device: ", err) - } - - var temper_event *cl.Event - temper_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Temper_buf, false, 0, p.Temper_size, unsafe.Pointer(&p.Temper[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write temper buffer to device: ", err) - } - - var flt_temper_event *cl.Event - flt_temper_event, err = ClCmdQueue.EnqueueWriteBuffer(p.Flt_temper_buf, false, 0, p.Flt_temper_size, unsafe.Pointer(&p.Flt_temper[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write flt_temper buffer to device: ", err) - } - - return []*cl.Event{pos_event, sh1_event, sh2_event, rec_event, temper_event, flt_temper_event}, nil -} - -func (p *MTGP32dc_params_array_ptr) LoadStatusBuffersToDevice(eventWaitList []*cl.Event) (*cl.Event, error) { - status_event, err := ClCmdQueue.EnqueueWriteBuffer(p.Status_buf, false, 0, p.Status_size, unsafe.Pointer(&p.Status[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to write status buffer to device: ", err) - } - return status_event, nil -} - -func (p *MTGP32dc_params_array_ptr) LoadStatusBuffersFromDevice(eventWaitList []*cl.Event) (*cl.Event, error) { - status_event, err := ClCmdQueue.EnqueueReadBuffer(p.Status_buf, false, 0, p.Status_size, unsafe.Pointer(&p.Status[0]), eventWaitList) - if err != nil { - log.Fatalln("Unable to read status buffer from device: ", err) - } - return status_event, nil -} - -func (p *MTGP32dc_params_array_ptr) SetRecursionArray(arr []uint32) { - p.Rec = arr -} - -func (p *MTGP32dc_params_array_ptr) GetRecursionArray() []uint32 { - return p.Rec -} - -func (p *MTGP32dc_params_array_ptr) SetPositionArray(arr []int) { - p.Pos = arr -} - -func (p *MTGP32dc_params_array_ptr) GetPositionArray() []int { - return p.Pos -} - -func (p *MTGP32dc_params_array_ptr) SetSH1Array(arr []int) { - p.Sh1 = arr -} - -func (p *MTGP32dc_params_array_ptr) GetSH1Array() []int { - return p.Sh1 -} - -func (p *MTGP32dc_params_array_ptr) SetSH2Array(arr []int) { - p.Sh2 = arr -} - -func (p *MTGP32dc_params_array_ptr) GetSH2Array() []int { - return p.Sh2 -} - -func (p *MTGP32dc_params_array_ptr) SetStatusArray(arr []uint32) { - p.Status = arr -} - -func (p *MTGP32dc_params_array_ptr) GetStatusArray() []uint32 { - return p.Status -} - -func (p *MTGP32dc_params_array_ptr) SetGroupSize(in int) { - p.GroupSize = in -} - -func (p *MTGP32dc_params_array_ptr) GetGroupSize() int { - return p.GroupSize -} - -func (p *MTGP32dc_params_array_ptr) SetGroupCount(in int) { - p.GroupCount = in -} - -func (p *MTGP32dc_params_array_ptr) GetGroupCount() int { - return p.GroupCount -} - -func (p *MTGP32dc_params_array_ptr) RecommendSize() int { - return 12 * p.GroupCount * MTGPDC_TN -} - -var MTGP32_params_fast_11213 = []MTGP32dc_params_fast_t{ - { - /* No.0 delta:1924 weight:1595 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x4f909277, 0xd506358c, 0x9a96a7fb, 0xecc00000, 0xa3509277, 0x39c6358c, 0x7656a7fb, 0x00009fd9, 0x4f900dae, 0xd506aa55, 0x9a963822, 0xecc09fd9, 0xa3500dae, 0x39c6aa55, 0x76563822}, - [16]uint32{0x00000000, 0x007c4132, 0x2b4020ed, 0x2b3c61df, 0x000240a5, 0x007e0197, 0x2b426048, 0x2b3e217a, 0x00414015, 0x003d0127, 0x2b0160f8, 0x2b7d21ca, 0x004300b0, 0x003f4182, 0x2b03205d, 0x2b7f616f}, - [16]uint32{0x3f800000, 0x3f803e20, 0x3f95a010, 0x3f959e30, 0x3f800120, 0x3f803f00, 0x3f95a130, 0x3f959f10, 0x3f8020a0, 0x3f801e80, 0x3f9580b0, 0x3f95be90, 0x3f802180, 0x3f801fa0, 0x3f958190, 0x3f95bfb0}, - uint32(0xfff80000), - [21]string{"0x43", "0x93", "0x2a", "0x2d", "0x4c", "0xab", "0x4c", "0xd3", "0x8f", "0xfb", "0x1e", "0xdd", "0x5e", "0x1a", "0xbb", "0x08", "0x92", "0x84", "0x17", "0x63", "0x00"}}, - { - /* No.1 delta:2138 weight:1245 */ - 11213, - 36, - 13, - 4, - [16]uint32{0x00000000, 0x04e7bdd9, 0xbd4135d8, 0xb9a68801, 0xf0c00015, 0xf427bdcc, 0x4d8135cd, 0x49668814, 0x0000e79e, 0x04e75a47, 0xbd41d246, 0xb9a66f9f, 0xf0c0e78b, 0xf4275a52, 0x4d81d253, 0x49666f8a}, - [16]uint32{0x00000000, 0x007802fe, 0x0084013b, 0x00fc03c5, 0x00060156, 0x007e03a8, 0x0082006d, 0x00fa0293, 0x0004001a, 0x007c02e4, 0x00800121, 0x00f803df, 0x0002014c, 0x007a03b2, 0x00860077, 0x00fe0289}, - [16]uint32{0x3f800000, 0x3f803c01, 0x3f804200, 0x3f807e01, 0x3f800300, 0x3f803f01, 0x3f804100, 0x3f807d01, 0x3f800200, 0x3f803e01, 0x3f804000, 0x3f807c01, 0x3f800100, 0x3f803d01, 0x3f804300, 0x3f807f01}, - uint32(0xfff80000), - [21]string{"0xda", "0xdf", "0x57", "0xe8", "0xbe", "0xba", "0x9b", "0x01", "0x23", "0xe2", "0x5d", "0x4b", "0x41", "0xf7", "0xb2", "0x6b", "0x77", "0x6f", "0x03", "0xd0", "0x00"}}, - { - /* No.2 delta:3099 weight:651 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x7f1f322e, 0xd937af30, 0xa6289d1e, 0x0940002c, 0x765f3202, 0xd077af1c, 0xaf689d32, 0x00001134, 0x7f1f231a, 0xd937be04, 0xa6288c2a, 0x09401118, 0x765f2336, 0xd077be28, 0xaf688c06}, - [16]uint32{0x00000000, 0x824a98bb, 0x24000749, 0xa64a9ff2, 0x49208c71, 0xcb6a14ca, 0x6d208b38, 0xef6a1383, 0x0cd00f55, 0x8e9a97ee, 0x28d0081c, 0xaa9a90a7, 0x45f08324, 0xc7ba1b9f, 0x61f0846d, 0xe3ba1cd6}, - [16]uint32{0x3f800000, 0x3fc1254c, 0x3f920003, 0x3fd3254f, 0x3fa49046, 0x3fe5b50a, 0x3fb69045, 0x3ff7b509, 0x3f866807, 0x3fc74d4b, 0x3f946804, 0x3fd54d48, 0x3fa2f841, 0x3fe3dd0d, 0x3fb0f842, 0x3ff1dd0e}, - uint32(0xfff80000), - [21]string{"0x6f", "0xaa", "0x42", "0x5f", "0x0c", "0xc0", "0x2d", "0x43", "0xf7", "0xd3", "0x08", "0xe8", "0xa4", "0xf5", "0x90", "0xf9", "0x21", "0x33", "0x77", "0x99", "0x00"}}, - { - /* No.3 delta:1149 weight:1465 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x62e3424e, 0xefb75beb, 0x8d5419a5, 0x40100039, 0x22f34277, 0xafa75bd2, 0xcd44199c, 0x000028cd, 0x62e36a83, 0xefb77326, 0x8d543168, 0x401028f4, 0x22f36aba, 0xafa7731f, 0xcd443151}, - [16]uint32{0x00000000, 0x2047d296, 0x600c0c1f, 0x404bde89, 0x3022e17a, 0x106533ec, 0x502eed65, 0x70693ff3, 0x0003c01d, 0x2044128b, 0x600fcc02, 0x40481e94, 0x30212167, 0x1066f3f1, 0x502d2d78, 0x706affee}, - [16]uint32{0x3f800000, 0x3f9023e9, 0x3fb00606, 0x3fa025ef, 0x3f981170, 0x3f883299, 0x3fa81776, 0x3fb8349f, 0x3f8001e0, 0x3f902209, 0x3fb007e6, 0x3fa0240f, 0x3f981090, 0x3f883379, 0x3fa81696, 0x3fb8357f}, - uint32(0xfff80000), - [21]string{"0xfb", "0x19", "0xb8", "0xaa", "0x2c", "0x32", "0xc9", "0x9e", "0x0d", "0xae", "0xf2", "0x6e", "0x0e", "0xe4", "0x9b", "0x81", "0x41", "0xe7", "0xa0", "0xb4", "0x00"}}, - { - /* No.4 delta:1024 weight:1407 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x477707e5, 0x4312f2cf, 0x0465f52a, 0x7c10004e, 0x3b6707ab, 0x3f02f281, 0x7875f564, 0x0000fcc0, 0x4777fb25, 0x43120e0f, 0x046509ea, 0x7c10fc8e, 0x3b67fb6b, 0x3f020e41, 0x787509a4}, - [16]uint32{0x00000000, 0x600c0cde, 0x000c9193, 0x60009d4d, 0x4000d35f, 0x200cdf81, 0x400c42cc, 0x20004e12, 0x10408219, 0x704c8ec7, 0x104c138a, 0x70401f54, 0x50405146, 0x304c5d98, 0x504cc0d5, 0x3040cc0b}, - [16]uint32{0x3f800000, 0x3fb00606, 0x3f800648, 0x3fb0004e, 0x3fa00069, 0x3f90066f, 0x3fa00621, 0x3f900027, 0x3f882041, 0x3fb82647, 0x3f882609, 0x3fb8200f, 0x3fa82028, 0x3f98262e, 0x3fa82660, 0x3f982066}, - uint32(0xfff80000), - [21]string{"0xaa", "0x61", "0xae", "0x97", "0xb0", "0xc9", "0x61", "0x3b", "0x8c", "0x50", "0xd3", "0xba", "0xe7", "0x18", "0xe0", "0xe4", "0xd0", "0xfb", "0x02", "0xc8", "0x00"}}, - { - /* No.5 delta:935 weight:1239 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x16f2897a, 0x078f68af, 0x117de1d5, 0xe1100050, 0xf7e2892a, 0xe69f68ff, 0xf06de185, 0x00005520, 0x16f2dc5a, 0x078f3d8f, 0x117db4f5, 0xe1105570, 0xf7e2dc0a, 0xe69f3ddf, 0xf06db4a5}, - [16]uint32{0x00000000, 0x6006f596, 0x00a6008a, 0x60a0f51c, 0x2002a409, 0x4004519f, 0x20a4a483, 0x40a25115, 0x2001e8ee, 0x40071d78, 0x20a7e864, 0x40a11df2, 0x00034ce7, 0x6005b971, 0x00a54c6d, 0x60a3b9fb}, - [16]uint32{0x3f800000, 0x3fb0037a, 0x3f805300, 0x3fb0507a, 0x3f900152, 0x3fa00228, 0x3f905252, 0x3fa05128, 0x3f9000f4, 0x3fa0038e, 0x3f9053f4, 0x3fa0508e, 0x3f8001a6, 0x3fb002dc, 0x3f8052a6, 0x3fb051dc}, - uint32(0xfff80000), - [21]string{"0x75", "0xae", "0x88", "0x03", "0x75", "0xde", "0x93", "0x7e", "0xa0", "0x4e", "0xfd", "0xb2", "0x06", "0x47", "0x4c", "0x5a", "0x7f", "0xa6", "0x68", "0xf0", "0x00"}}, - { - /* No.6 delta:2636 weight:1479 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xa236b2f7, 0x673cd97c, 0xc50a6b8b, 0x0740006f, 0xa576b298, 0x607cd913, 0xc24a6be4, 0x0000a23f, 0xa23610c8, 0x673c7b43, 0xc50ac9b4, 0x0740a250, 0xa57610a7, 0x607c7b2c, 0xc24ac9db}, - [16]uint32{0x00000000, 0x0003441a, 0x1002681f, 0x10012c05, 0x2000b20d, 0x2003f617, 0x3002da12, 0x30019e08, 0x2000001b, 0x20034401, 0x30026804, 0x30012c1e, 0x0000b216, 0x0003f60c, 0x1002da09, 0x10019e13}, - [16]uint32{0x3f800000, 0x3f8001a2, 0x3f880134, 0x3f880096, 0x3f900059, 0x3f9001fb, 0x3f98016d, 0x3f9800cf, 0x3f900000, 0x3f9001a2, 0x3f980134, 0x3f980096, 0x3f800059, 0x3f8001fb, 0x3f88016d, 0x3f8800cf}, - uint32(0xfff80000), - [21]string{"0xff", "0xdb", "0x7b", "0xc1", "0xcb", "0xf5", "0x52", "0x32", "0x4d", "0x74", "0xd0", "0xbb", "0x88", "0x29", "0x89", "0x26", "0xba", "0x41", "0x92", "0xe3", "0x00"}}, - { - /* No.7 delta:1036 weight:1615 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x13dc0d56, 0xfcc23381, 0xef1e3ed7, 0x65e00072, 0x763c0d24, 0x992233f3, 0x8afe3ea5, 0x00003944, 0x13dc3412, 0xfcc20ac5, 0xef1e0793, 0x65e03936, 0x763c3460, 0x99220ab7, 0x8afe07e1}, - [16]uint32{0x00000000, 0x304c1192, 0x0002c01d, 0x304ed18f, 0x60482c07, 0x50043d95, 0x604aec1a, 0x5006fd88, 0x600001c4, 0x504c1056, 0x6002c1d9, 0x504ed04b, 0x00482dc3, 0x30043c51, 0x004aedde, 0x3006fc4c}, - [16]uint32{0x3f800000, 0x3f982608, 0x3f800160, 0x3f982768, 0x3fb02416, 0x3fa8021e, 0x3fb02576, 0x3fa8037e, 0x3fb00000, 0x3fa82608, 0x3fb00160, 0x3fa82768, 0x3f802416, 0x3f98021e, 0x3f802576, 0x3f98037e}, - uint32(0xfff80000), - [21]string{"0xf5", "0x20", "0xa8", "0x18", "0xff", "0xcc", "0xac", "0xc9", "0x44", "0xd4", "0x78", "0x19", "0x0a", "0x78", "0x20", "0x63", "0xe8", "0x72", "0x36", "0x71", "0x00"}}, - { - /* No.8 delta:1185 weight:1437 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x8ffabd15, 0x251190b0, 0xaaeb2da5, 0x6180008a, 0xee7abd9f, 0x4491903a, 0xcb6b2d2f, 0x00003391, 0x8ffa8e84, 0x2511a321, 0xaaeb1e34, 0x6180331b, 0xee7a8e0e, 0x4491a3ab, 0xcb6b1ebe}, - [16]uint32{0x00000000, 0x087422da, 0x0002d1fd, 0x0876f327, 0x9010009e, 0x98642244, 0x9012d163, 0x9866f3b9, 0x506880d6, 0x581ca20c, 0x506a512b, 0x581e73f1, 0xc0788048, 0xc80ca292, 0xc07a51b5, 0xc80e736f}, - [16]uint32{0x3f800000, 0x3f843a11, 0x3f800168, 0x3f843b79, 0x3fc80800, 0x3fcc3211, 0x3fc80968, 0x3fcc3379, 0x3fa83440, 0x3fac0e51, 0x3fa83528, 0x3fac0f39, 0x3fe03c40, 0x3fe40651, 0x3fe03d28, 0x3fe40739}, - uint32(0xfff80000), - [21]string{"0xe8", "0x7d", "0x49", "0xd8", "0x59", "0xcb", "0xa2", "0xaa", "0xce", "0xb9", "0xd8", "0xd9", "0x4e", "0x89", "0xff", "0x1e", "0xc6", "0x5c", "0x9c", "0x62", "0x00"}}, - { - /* No.9 delta:940 weight:1557 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x75b471ab, 0xa13c72ac, 0xd4880307, 0x64d00099, 0x11647132, 0xc5ec7235, 0xb058039e, 0x00007a74, 0x75b40bdf, 0xa13c08d8, 0xd4887973, 0x64d07aed, 0x11640b46, 0xc5ec0841, 0xb05879ea}, - [16]uint32{0x00000000, 0x0001f4d5, 0x104e140e, 0x104fe0db, 0x20022818, 0x2003dccd, 0x304c3c16, 0x304dc8c3, 0x2000278c, 0x2001d359, 0x304e3382, 0x304fc757, 0x00020f94, 0x0003fb41, 0x104c1b9a, 0x104def4f}, - [16]uint32{0x3f800000, 0x3f8000fa, 0x3f88270a, 0x3f8827f0, 0x3f900114, 0x3f9001ee, 0x3f98261e, 0x3f9826e4, 0x3f900013, 0x3f9000e9, 0x3f982719, 0x3f9827e3, 0x3f800107, 0x3f8001fd, 0x3f88260d, 0x3f8826f7}, - uint32(0xfff80000), - [21]string{"0xf3", "0x2e", "0xad", "0xf6", "0x6f", "0x50", "0x04", "0xb1", "0x67", "0x86", "0x75", "0x45", "0x70", "0x60", "0x5d", "0x63", "0xaf", "0x93", "0x7f", "0xa0", "0x00"}}, - { - /* No.10 delta:2070 weight:1315 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0xaff041eb, 0x194d1f47, 0xb6bd5eac, 0x58a000a5, 0xf750414e, 0x41ed1fe2, 0xee1d5e09, 0x0000bcbf, 0xaff0fd54, 0x194da3f8, 0xb6bde213, 0x58a0bc1a, 0xf750fdf1, 0x41eda35d, 0xee1de2b6}, - [16]uint32{0x00000000, 0x1082801b, 0x0800e183, 0x18826198, 0x009c291f, 0x101ea904, 0x089cc89c, 0x181e4887, 0x60002519, 0x7082a502, 0x6800c49a, 0x78824481, 0x609c0c06, 0x701e8c1d, 0x689ced85, 0x781e6d9e}, - [16]uint32{0x3f800000, 0x3f884140, 0x3f840070, 0x3f8c4130, 0x3f804e14, 0x3f880f54, 0x3f844e64, 0x3f8c0f24, 0x3fb00012, 0x3fb84152, 0x3fb40062, 0x3fbc4122, 0x3fb04e06, 0x3fb80f46, 0x3fb44e76, 0x3fbc0f36}, - uint32(0xfff80000), - [21]string{"0x5d", "0x09", "0x8c", "0x60", "0x3e", "0xd8", "0x24", "0xaf", "0x49", "0xc9", "0xa3", "0x2e", "0xab", "0x4f", "0xb4", "0xe6", "0x15", "0x68", "0xd1", "0x47", "0x00"}}, - { - /* No.11 delta:1515 weight:1659 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x98993010, 0xd2526ec9, 0x4acb5ed9, 0x148000b8, 0x8c1930a8, 0xc6d26e71, 0x5e4b5e61, 0x00004381, 0x98997391, 0xd2522d48, 0x4acb1d58, 0x14804339, 0x8c197329, 0xc6d22df0, 0x5e4b1de0}, - [16]uint32{0x00000000, 0x1f8f2033, 0x2051c174, 0x3fdee147, 0x2121601a, 0x3eae4029, 0x0170a16e, 0x1eff815d, 0x00412412, 0x1fce0421, 0x2010e566, 0x3f9fc555, 0x21604408, 0x3eef643b, 0x0131857c, 0x1ebea54f}, - [16]uint32{0x3f800000, 0x3f8fc790, 0x3f9028e0, 0x3f9fef70, 0x3f9090b0, 0x3f9f5720, 0x3f80b850, 0x3f8f7fc0, 0x3f802092, 0x3f8fe702, 0x3f900872, 0x3f9fcfe2, 0x3f90b022, 0x3f9f77b2, 0x3f8098c2, 0x3f8f5f52}, - uint32(0xfff80000), - [21]string{"0xbe", "0x72", "0x05", "0x26", "0xcb", "0xaa", "0x6d", "0x25", "0xac", "0xaf", "0x9c", "0x2f", "0xe1", "0xe7", "0x35", "0x3c", "0x6e", "0x4e", "0x4b", "0x24", "0x00"}}, - { - /* No.12 delta:820 weight:1581 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xddfffc66, 0x11479e19, 0xccb8627f, 0x8d1000c6, 0x50effca0, 0x9c579edf, 0x41a862b9, 0x00004882, 0xddffb4e4, 0x1147d69b, 0xccb82afd, 0x8d104844, 0x50efb422, 0x9c57d65d, 0x41a82a3b}, - [16]uint32{0x00000000, 0x000d341f, 0x7001d194, 0x700ce58b, 0x0122201d, 0x012f1402, 0x7123f189, 0x712ec596, 0x040d80b7, 0x0400b4a8, 0x740c5123, 0x7401653c, 0x052fa0aa, 0x052294b5, 0x752e713e, 0x75234521}, - [16]uint32{0x3f800000, 0x3f80069a, 0x3fb800e8, 0x3fb80672, 0x3f809110, 0x3f80978a, 0x3fb891f8, 0x3fb89762, 0x3f8206c0, 0x3f82005a, 0x3fba0628, 0x3fba00b2, 0x3f8297d0, 0x3f82914a, 0x3fba9738, 0x3fba91a2}, - uint32(0xfff80000), - [21]string{"0x6e", "0xf5", "0x55", "0xa0", "0x30", "0x84", "0x66", "0xdc", "0xa6", "0x4a", "0x52", "0xe1", "0xd8", "0x99", "0x66", "0x12", "0xd7", "0x4b", "0x83", "0x2c", "0x00"}}, - { - /* No.13 delta:707 weight:1529 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0x9b47b275, 0x3b5e5ca5, 0xa019eed0, 0x72c000d6, 0xe987b2a3, 0x499e5c73, 0xd2d9ee06, 0x000090c6, 0x9b4722b3, 0x3b5ecc63, 0xa0197e16, 0x72c09010, 0xe9872265, 0x499eccb5, 0xd2d97ec0}, - [16]uint32{0x00000000, 0x2068289d, 0x10121266, 0x307a3afb, 0x201641bf, 0x007e6922, 0x300453d9, 0x106c7b44, 0x00120017, 0x207a288a, 0x10001271, 0x30683aec, 0x200441a8, 0x006c6935, 0x301653ce, 0x107e7b53}, - [16]uint32{0x3f800000, 0x3f903414, 0x3f880909, 0x3f983d1d, 0x3f900b20, 0x3f803f34, 0x3f980229, 0x3f88363d, 0x3f800900, 0x3f903d14, 0x3f880009, 0x3f98341d, 0x3f900220, 0x3f803634, 0x3f980b29, 0x3f883f3d}, - uint32(0xfff80000), - [21]string{"0x24", "0xca", "0x5b", "0xd7", "0x52", "0x91", "0x29", "0xca", "0xa8", "0x9b", "0x1b", "0x5e", "0xb6", "0x1d", "0x1e", "0x72", "0x3d", "0x9d", "0xdb", "0x31", "0x00"}}, - { - /* No.14 delta:740 weight:1357 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0xa4ded64e, 0xeb88426b, 0x4f569425, 0x56d000e9, 0xf20ed6a7, 0xbd584282, 0x198694cc, 0x0000e140, 0xa4de370e, 0xeb88a32b, 0x4f567565, 0x56d0e1a9, 0xf20e37e7, 0xbd58a3c2, 0x1986758c}, - [16]uint32{0x00000000, 0x00031972, 0x20046011, 0x20077963, 0x40081018, 0x400b096a, 0x600c7009, 0x600f697b, 0x4140013c, 0x4143184e, 0x6144612d, 0x6147785f, 0x01481124, 0x014b0856, 0x214c7135, 0x214f6847}, - [16]uint32{0x3f800000, 0x3f80018c, 0x3f900230, 0x3f9003bc, 0x3fa00408, 0x3fa00584, 0x3fb00638, 0x3fb007b4, 0x3fa0a000, 0x3fa0a18c, 0x3fb0a230, 0x3fb0a3bc, 0x3f80a408, 0x3f80a584, 0x3f90a638, 0x3f90a7b4}, - uint32(0xfff80000), - [21]string{"0xc3", "0x74", "0x1c", "0x60", "0x3b", "0xf4", "0xad", "0x34", "0x2e", "0x3d", "0xf9", "0xde", "0x63", "0x53", "0xf9", "0xe5", "0xcf", "0x78", "0x9a", "0x9d", "0x00"}}, - { - /* No.15 delta:1412 weight:1175 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xd5f40b06, 0x9e909b5e, 0x4b649058, 0xd5b000f1, 0x00440bf7, 0x4b209baf, 0x9ed490a9, 0x00006d10, 0xd5f46616, 0x9e90f64e, 0x4b64fd48, 0xd5b06de1, 0x004466e7, 0x4b20f6bf, 0x9ed4fdb9}, - [16]uint32{0x00000000, 0x0035813a, 0x104ac0ec, 0x107f41d6, 0x00024054, 0x0037c16e, 0x104880b8, 0x107d0182, 0x100040a4, 0x1035c19e, 0x004a8048, 0x007f0172, 0x100200f0, 0x103781ca, 0x0048c01c, 0x007d4126}, - [16]uint32{0x3f800000, 0x3f801ac0, 0x3f882560, 0x3f883fa0, 0x3f800120, 0x3f801be0, 0x3f882440, 0x3f883e80, 0x3f880020, 0x3f881ae0, 0x3f802540, 0x3f803f80, 0x3f880100, 0x3f881bc0, 0x3f802460, 0x3f803ea0}, - uint32(0xfff80000), - [21]string{"0x1c", "0xc5", "0xf3", "0xcc", "0xc0", "0xa1", "0xf5", "0x12", "0xe1", "0x21", "0x45", "0x6c", "0x8c", "0xe8", "0x81", "0x31", "0xc4", "0x16", "0xc8", "0x01", "0x00"}}, - { - /* No.16 delta:829 weight:1511 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0x6a4ed196, 0x75986580, 0x1fd6b416, 0xb6f00102, 0xdcbed094, 0xc3686482, 0xa926b514, 0x0000ff65, 0x6a4e2ef3, 0x75989ae5, 0x1fd64b73, 0xb6f0fe67, 0xdcbe2ff1, 0xc3689be7, 0xa9264a71}, - [16]uint32{0x00000000, 0x4024d5d3, 0x4060c1ff, 0x0044142c, 0x003141b5, 0x40159466, 0x4051804a, 0x00755599, 0x000241de, 0x4026940d, 0x40628021, 0x004655f2, 0x0033006b, 0x4017d5b8, 0x4053c194, 0x00771447}, - [16]uint32{0x3f800000, 0x3fa0126a, 0x3fa03060, 0x3f80220a, 0x3f8018a0, 0x3fa00aca, 0x3fa028c0, 0x3f803aaa, 0x3f800120, 0x3fa0134a, 0x3fa03140, 0x3f80232a, 0x3f801980, 0x3fa00bea, 0x3fa029e0, 0x3f803b8a}, - uint32(0xfff80000), - [21]string{"0x90", "0xef", "0xab", "0xea", "0x9a", "0x3e", "0x54", "0x08", "0xd7", "0x59", "0x31", "0x77", "0x70", "0x41", "0x3a", "0x49", "0x1d", "0x02", "0xc8", "0x4d", "0x00"}}, - { - /* No.17 delta:939 weight:1249 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x9b6dd2da, 0x7a47766d, 0xe12aa4b7, 0x28b00115, 0xb3ddd3cf, 0x52f77778, 0xc99aa5a2, 0x0000ac7e, 0x9b6d7ea4, 0x7a47da13, 0xe12a08c9, 0x28b0ad6b, 0xb3dd7fb1, 0x52f7db06, 0xc99a09dc}, - [16]uint32{0x00000000, 0x0074455a, 0x10038197, 0x1077c4cd, 0x00027014, 0x0076354e, 0x1001f183, 0x1075b4d9, 0x100a0011, 0x107e454b, 0x00098186, 0x007dc4dc, 0x10087005, 0x107c355f, 0x000bf192, 0x007fb4c8}, - [16]uint32{0x3f800000, 0x3f803a22, 0x3f8801c0, 0x3f883be2, 0x3f800138, 0x3f803b1a, 0x3f8800f8, 0x3f883ada, 0x3f880500, 0x3f883f22, 0x3f8004c0, 0x3f803ee2, 0x3f880438, 0x3f883e1a, 0x3f8005f8, 0x3f803fda}, - uint32(0xfff80000), - [21]string{"0x1d", "0x4d", "0xd6", "0x26", "0x63", "0x10", "0x49", "0x3c", "0xd2", "0x16", "0xf9", "0xb1", "0xc2", "0x24", "0x34", "0xcf", "0x7d", "0x43", "0x28", "0xcb", "0x00"}}, - { - /* No.18 delta:1038 weight:1423 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xb32bc1dd, 0x940d95ad, 0x27265470, 0x4bb0012e, 0xf89bc0f3, 0xdfbd9483, 0x6c96555e, 0x0000d383, 0xb32b125e, 0x940d462e, 0x272687f3, 0x4bb0d2ad, 0xf89b1370, 0xdfbd4700, 0x6c9686dd}, - [16]uint32{0x00000000, 0x100c2016, 0x0003a04f, 0x100f8059, 0x2040861d, 0x304ca60b, 0x20432652, 0x304f0644, 0x0050ea1f, 0x105cca09, 0x00534a50, 0x105f6a46, 0x20106c02, 0x301c4c14, 0x2013cc4d, 0x301fec5b}, - [16]uint32{0x3f800000, 0x3f880610, 0x3f8001d0, 0x3f8807c0, 0x3f902043, 0x3f982653, 0x3f902193, 0x3f982783, 0x3f802875, 0x3f882e65, 0x3f8029a5, 0x3f882fb5, 0x3f900836, 0x3f980e26, 0x3f9009e6, 0x3f980ff6}, - uint32(0xfff80000), - [21]string{"0x64", "0x79", "0xc7", "0x6f", "0xcc", "0x48", "0x7c", "0x0a", "0x43", "0xe9", "0x95", "0xcd", "0x1c", "0x2d", "0xa0", "0xc0", "0x7e", "0x12", "0xc2", "0xf7", "0x00"}}, - { - /* No.19 delta:2427 weight:765 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0xbd514c94, 0xd2534abd, 0x6f020629, 0xbf20013d, 0x02714da9, 0x6d734b80, 0xd0220714, 0x00002d73, 0xbd5161e7, 0xd25367ce, 0x6f022b5a, 0xbf202c4e, 0x027160da, 0x6d7366f3, 0xd0222a67}, - [16]uint32{0x00000000, 0x19a54197, 0x106021ca, 0x09c5605d, 0x101000ff, 0x09b54168, 0x00702135, 0x19d560a2, 0x004800b0, 0x19ed4127, 0x1028217a, 0x098d60ed, 0x1058004f, 0x09fd41d8, 0x00382185, 0x199d6012}, - [16]uint32{0x3f800000, 0x3f8cd2a0, 0x3f883010, 0x3f84e2b0, 0x3f880800, 0x3f84daa0, 0x3f803810, 0x3f8ceab0, 0x3f802400, 0x3f8cf6a0, 0x3f881410, 0x3f84c6b0, 0x3f882c00, 0x3f84fea0, 0x3f801c10, 0x3f8cceb0}, - uint32(0xfff80000), - [21]string{"0x7d", "0x7c", "0x61", "0x34", "0xcc", "0xaf", "0xb1", "0x1c", "0xa1", "0xe8", "0x1d", "0xb4", "0xa9", "0x8f", "0x15", "0x98", "0xd1", "0xba", "0x42", "0x9b", "0x00"}}, - { - /* No.20 delta:1784 weight:1485 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0xfeb307f4, 0x3c1e7eea, 0xc2ad791e, 0x33d00140, 0xcd6306b4, 0x0fce7faa, 0xf17d785e, 0x00007ab3, 0xfeb37d47, 0x3c1e0459, 0xc2ad03ad, 0x33d07bf3, 0xcd637c07, 0x0fce0519, 0xf17d02ed}, - [16]uint32{0x00000000, 0x0ae69956, 0x54269098, 0x5ec009ce, 0x304007d5, 0x3aa69e83, 0x6466974d, 0x6e800e1b, 0x0059801d, 0x0abf194b, 0x547f1085, 0x5e9989d3, 0x301987c8, 0x3aff1e9e, 0x643f1750, 0x6ed98e06}, - [16]uint32{0x3f800000, 0x3f85734c, 0x3faa1348, 0x3faf6004, 0x3f982003, 0x3f9d534f, 0x3fb2334b, 0x3fb74007, 0x3f802cc0, 0x3f855f8c, 0x3faa3f88, 0x3faf4cc4, 0x3f980cc3, 0x3f9d7f8f, 0x3fb21f8b, 0x3fb76cc7}, - uint32(0xfff80000), - [21]string{"0x3f", "0xcf", "0x58", "0xca", "0x42", "0x13", "0xe5", "0xd0", "0x0f", "0x09", "0x0b", "0x67", "0x5b", "0xb8", "0x8c", "0x3d", "0x2c", "0xd8", "0xef", "0x68", "0x00"}}, - { - /* No.21 delta:974 weight:1601 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0x2554da2a, 0xc20d8e4e, 0xe7595464, 0xd500015a, 0xf054db70, 0x170d8f14, 0x3259553e, 0x0000b8c9, 0x255462e3, 0xc20d3687, 0xe759ecad, 0xd500b993, 0xf05463b9, 0x170d37dd, 0x3259edf7}, - [16]uint32{0x00000000, 0x000264d6, 0x00010c23, 0x000368f5, 0x102ca1fb, 0x102ec52d, 0x102dadd8, 0x102fc90e, 0xf01c200a, 0xf01e44dc, 0xf01d2c29, 0xf01f48ff, 0xe03081f1, 0xe032e527, 0xe0318dd2, 0xe033e904}, - [16]uint32{0x3f800000, 0x3f800132, 0x3f800086, 0x3f8001b4, 0x3f881650, 0x3f881762, 0x3f8816d6, 0x3f8817e4, 0x3ff80e10, 0x3ff80f22, 0x3ff80e96, 0x3ff80fa4, 0x3ff01840, 0x3ff01972, 0x3ff018c6, 0x3ff019f4}, - uint32(0xfff80000), - [21]string{"0x49", "0xb2", "0x44", "0x10", "0x53", "0x58", "0xa0", "0x92", "0xcc", "0x3a", "0xbc", "0x4f", "0x77", "0x55", "0xeb", "0x20", "0xc6", "0xbf", "0x94", "0x54", "0x00"}}, - { - /* No.22 delta:3113 weight:577 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x1c0fe41b, 0x17e3e180, 0x0bec059b, 0x3210016f, 0x2e1fe574, 0x25f3e0ef, 0x39fc04f4, 0x0000f40c, 0x1c0f1017, 0x17e3158c, 0x0becf197, 0x3210f563, 0x2e1f1178, 0x25f314e3, 0x39fcf0f8}, - [16]uint32{0x00000000, 0x8800a03e, 0x4c6061c3, 0xc460c1fd, 0x0e210048, 0x8621a076, 0x4241618b, 0xca41c1b5, 0x84304150, 0x0c30e16e, 0xc8502093, 0x405080ad, 0x8a114118, 0x0211e126, 0xc67120db, 0x4e7180e5}, - [16]uint32{0x3f800000, 0x3fc40050, 0x3fa63030, 0x3fe23060, 0x3f871080, 0x3fc310d0, 0x3fa120b0, 0x3fe520e0, 0x3fc21820, 0x3f861870, 0x3fe42810, 0x3fa02840, 0x3fc508a0, 0x3f8108f0, 0x3fe33890, 0x3fa738c0}, - uint32(0xfff80000), - [21]string{"0xd3", "0x3b", "0x23", "0x49", "0xd1", "0x4b", "0xe8", "0xf0", "0x12", "0xf9", "0x95", "0xf9", "0x30", "0x1c", "0xa0", "0xc1", "0xa7", "0xc7", "0xb2", "0xb2", "0x00"}}, - { - /* No.23 delta:2078 weight:1299 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x81f19cc8, 0x40d67766, 0xc127ebae, 0xbbb0017f, 0x3a419db7, 0xfb667619, 0x7a97ead1, 0x00003964, 0x81f1a5ac, 0x40d64e02, 0xc127d2ca, 0xbbb0381b, 0x3a41a4d3, 0xfb664f7d, 0x7a97d3b5}, - [16]uint32{0x00000000, 0x0106027a, 0x0024013f, 0x01220345, 0x0070002b, 0x01760251, 0x00540114, 0x0152036e, 0x004c00bd, 0x014a02c7, 0x00680182, 0x016e03f8, 0x003c0096, 0x013a02ec, 0x001801a9, 0x011e03d3}, - [16]uint32{0x3f800000, 0x3f808301, 0x3f801200, 0x3f809101, 0x3f803800, 0x3f80bb01, 0x3f802a00, 0x3f80a901, 0x3f802600, 0x3f80a501, 0x3f803400, 0x3f80b701, 0x3f801e00, 0x3f809d01, 0x3f800c00, 0x3f808f01}, - uint32(0xfff80000), - [21]string{"0x75", "0x55", "0x0b", "0x56", "0x9a", "0x7d", "0xe4", "0xa5", "0x47", "0x15", "0x33", "0xb5", "0x32", "0x55", "0x1d", "0xbd", "0x42", "0x5c", "0x06", "0xb4", "0x00"}}, - { - /* No.24 delta:765 weight:721 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0xa44b9eb8, 0xb66d2770, 0x1226b9c8, 0xa7400180, 0x030b9f38, 0x112d26f0, 0xb566b848, 0x000093e2, 0xa44b0d5a, 0xb66db492, 0x12262a2a, 0xa7409262, 0x030b0cda, 0x112db512, 0xb5662baa}, - [16]uint32{0x00000000, 0x206c4d57, 0x40044405, 0x60680952, 0x7042401b, 0x502e0d4c, 0x3046041e, 0x102a4949, 0x70200204, 0x504c4f53, 0x30244601, 0x10480b56, 0x0062421f, 0x200e0f48, 0x4066061a, 0x600a4b4d}, - [16]uint32{0x3f800000, 0x3f903626, 0x3fa00222, 0x3fb03404, 0x3fb82120, 0x3fa81706, 0x3f982302, 0x3f881524, 0x3fb81001, 0x3fa82627, 0x3f981223, 0x3f882405, 0x3f803121, 0x3f900707, 0x3fa03303, 0x3fb00525}, - uint32(0xfff80000), - [21]string{"0x7f", "0xad", "0x7b", "0xd7", "0x2d", "0x36", "0xd7", "0x2e", "0xea", "0xde", "0x5a", "0x26", "0xe0", "0x66", "0x33", "0x76", "0x48", "0x3d", "0x70", "0x76", "0x00"}}, - { - /* No.25 delta:1491 weight:1691 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xa197c538, 0x2189e50a, 0x801e2032, 0xbe900193, 0x1f07c4ab, 0x9f19e499, 0x3e8e21a1, 0x000019a2, 0xa197dc9a, 0x2189fca8, 0x801e3990, 0xbe901831, 0x1f07dd09, 0x9f19fd3b, 0x3e8e3803}, - [16]uint32{0x00000000, 0x0cb682dc, 0x21840a6e, 0x2d3288b2, 0x0050d01d, 0x0ce652c1, 0x21d4da73, 0x2d6258af, 0x00201614, 0x0c9694c8, 0x21a41c7a, 0x2d129ea6, 0x0070c609, 0x0cc644d5, 0x21f4cc67, 0x2d424ebb}, - [16]uint32{0x3f800000, 0x3f865b41, 0x3f90c205, 0x3f969944, 0x3f802868, 0x3f867329, 0x3f90ea6d, 0x3f96b12c, 0x3f80100b, 0x3f864b4a, 0x3f90d20e, 0x3f96894f, 0x3f803863, 0x3f866322, 0x3f90fa66, 0x3f96a127}, - uint32(0xfff80000), - [21]string{"0x23", "0x39", "0x98", "0xe2", "0x20", "0xce", "0x7e", "0x4a", "0xf3", "0x5f", "0x8a", "0xa2", "0x7c", "0xaf", "0x4c", "0x20", "0x4b", "0x3c", "0x2a", "0x3e", "0x00"}}, - { - /* No.26 delta:1271 weight:1733 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0xd060775e, 0xa2b1b9c5, 0x72d1ce9b, 0x97f001a8, 0x479076f6, 0x3541b86d, 0xe521cf33, 0x0000a701, 0xd060d05f, 0xa2b11ec4, 0x72d1699a, 0x97f0a6a9, 0x4790d1f7, 0x35411f6c, 0xe5216832}, - [16]uint32{0x00000000, 0x1c6bc8f4, 0x006c38db, 0x1c07f02f, 0x00501012, 0x1c3bd8e6, 0x003c28c9, 0x1c57e03d, 0x000f2417, 0x1c64ece3, 0x00631ccc, 0x1c08d438, 0x005f3405, 0x1c34fcf1, 0x00330cde, 0x1c58c42a}, - [16]uint32{0x3f800000, 0x3f8e35e4, 0x3f80361c, 0x3f8e03f8, 0x3f802808, 0x3f8e1dec, 0x3f801e14, 0x3f8e2bf0, 0x3f800792, 0x3f8e3276, 0x3f80318e, 0x3f8e046a, 0x3f802f9a, 0x3f8e1a7e, 0x3f801986, 0x3f8e2c62}, - uint32(0xfff80000), - [21]string{"0x2b", "0x91", "0x85", "0xa8", "0xca", "0xa6", "0x3a", "0xf1", "0x2d", "0xea", "0x12", "0x7d", "0x47", "0xb4", "0x80", "0x80", "0x0e", "0x7b", "0x4f", "0x67", "0x00"}}, - { - /* No.27 delta:1231 weight:1525 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x7afaa5cb, 0xf61d93c3, 0x8ce73608, 0xca1001bc, 0xb0eaa477, 0x3c0d927f, 0x46f737b4, 0x0000830c, 0x7afa26c7, 0xf61d10cf, 0x8ce7b504, 0xca1082b0, 0xb0ea277b, 0x3c0d1173, 0x46f7b4b8}, - [16]uint32{0x00000000, 0x09255812, 0x004cc81c, 0x0969900e, 0x10a0480d, 0x1985101f, 0x10ec8011, 0x19c9d803, 0x00209a18, 0x0905c20a, 0x006c5204, 0x09490a16, 0x1080d215, 0x19a58a07, 0x10cc1a09, 0x19e9421b}, - [16]uint32{0x3f800000, 0x3f8492ac, 0x3f802664, 0x3f84b4c8, 0x3f885024, 0x3f8cc288, 0x3f887640, 0x3f8ce4ec, 0x3f80104d, 0x3f8482e1, 0x3f803629, 0x3f84a485, 0x3f884069, 0x3f8cd2c5, 0x3f88660d, 0x3f8cf4a1}, - uint32(0xfff80000), - [21]string{"0x3a", "0x40", "0x03", "0x20", "0xef", "0x18", "0x5a", "0xe5", "0x2a", "0x38", "0xb1", "0xf0", "0x41", "0xf4", "0x32", "0x78", "0xa2", "0x41", "0xdc", "0x93", "0x00"}}, - { - /* No.28 delta:1090 weight:1601 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x37b07ae5, 0x1e34ad30, 0x2984d7d5, 0xa54001cc, 0x92f07b29, 0xbb74acfc, 0x8cc4d619, 0x00009771, 0x37b0ed94, 0x1e343a41, 0x298440a4, 0xa54096bd, 0x92f0ec58, 0xbb743b8d, 0x8cc44168}, - [16]uint32{0x00000000, 0x80503416, 0x007c0c1a, 0x802c380c, 0x0003646b, 0x8053507d, 0x007f6871, 0x802f5c67, 0x00002c05, 0x80501813, 0x007c201f, 0x802c1409, 0x0003486e, 0x80537c78, 0x007f4474, 0x802f7062}, - [16]uint32{0x3f800000, 0x3fc0281a, 0x3f803e06, 0x3fc0161c, 0x3f8001b2, 0x3fc029a8, 0x3f803fb4, 0x3fc017ae, 0x3f800016, 0x3fc0280c, 0x3f803e10, 0x3fc0160a, 0x3f8001a4, 0x3fc029be, 0x3f803fa2, 0x3fc017b8}, - uint32(0xfff80000), - [21]string{"0x2e", "0x51", "0xa2", "0xb0", "0x84", "0xe2", "0x9b", "0x71", "0x83", "0xc5", "0x6d", "0xe2", "0x0e", "0xb2", "0x3e", "0xe3", "0x35", "0x5e", "0x59", "0x0b", "0x00"}}, - { - /* No.29 delta:1026 weight:985 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x098de739, 0x1e064906, 0x178bae3f, 0x0fb001de, 0x063de6e7, 0x11b648d8, 0x183bafe1, 0x000062cb, 0x098d85f2, 0x1e062bcd, 0x178bccf4, 0x0fb06315, 0x063d842c, 0x11b62a13, 0x183bcd2a}, - [16]uint32{0x00000000, 0x206d117f, 0x201209fe, 0x007f1881, 0x000180fc, 0x206c9183, 0x20138902, 0x007e987d, 0x2010c016, 0x007dd169, 0x0002c9e8, 0x206fd897, 0x201140ea, 0x007c5195, 0x00034914, 0x206e586b}, - [16]uint32{0x3f800000, 0x3f903688, 0x3f900904, 0x3f803f8c, 0x3f8000c0, 0x3f903648, 0x3f9009c4, 0x3f803f4c, 0x3f900860, 0x3f803ee8, 0x3f800164, 0x3f9037ec, 0x3f9008a0, 0x3f803e28, 0x3f8001a4, 0x3f90372c}, - uint32(0xfff80000), - [21]string{"0x06", "0x77", "0xd1", "0x7e", "0xdc", "0xf3", "0x70", "0x1c", "0x50", "0xd7", "0x02", "0x4b", "0x90", "0x4c", "0x30", "0xef", "0x1a", "0xfc", "0x80", "0xf2", "0x00"}}, - { - /* No.30 delta:1006 weight:1433 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0xe98943f8, 0x1d8008b8, 0xf4094b40, 0x897001e6, 0x60f9421e, 0x94f0095e, 0x7d794aa6, 0x00000d37, 0xe9894ecf, 0x1d80058f, 0xf4094677, 0x89700cd1, 0x60f94f29, 0x94f00469, 0x7d794791}, - [16]uint32{0x00000000, 0x60006e16, 0x802610db, 0xe0267ecd, 0x00035407, 0x60033a11, 0x802544dc, 0xe0252aca, 0x4068e812, 0x20688604, 0xc04ef8c9, 0xa04e96df, 0x406bbc15, 0x206bd203, 0xc04dacce, 0xa04dc2d8}, - [16]uint32{0x3f800000, 0x3fb00037, 0x3fc01308, 0x3ff0133f, 0x3f8001aa, 0x3fb0019d, 0x3fc012a2, 0x3ff01295, 0x3fa03474, 0x3f903443, 0x3fe0277c, 0x3fd0274b, 0x3fa035de, 0x3f9035e9, 0x3fe026d6, 0x3fd026e1}, - uint32(0xfff80000), - [21]string{"0x6c", "0x35", "0x43", "0x19", "0x5c", "0x54", "0xcc", "0x5d", "0x7f", "0x18", "0xa9", "0xf1", "0xa9", "0x02", "0x57", "0x08", "0x33", "0x68", "0x15", "0x6f", "0x00"}}, - { - /* No.31 delta:2643 weight:851 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x9a117ca4, 0x10aad759, 0x8abbabfd, 0x344001fe, 0xae517d5a, 0x24ead6a7, 0xbefbaa03, 0x00005300, 0x9a112fa4, 0x10aa8459, 0x8abbf8fd, 0x344052fe, 0xae512e5a, 0x24ea85a7, 0xbefbf903}, - [16]uint32{0x00000000, 0x13fd6396, 0xc008012f, 0xd3f562b9, 0x2c0a0612, 0x3ff76584, 0xec02073d, 0xffff64ab, 0x0e50429c, 0x1dad210a, 0xce5843b3, 0xdda52025, 0x225a448e, 0x31a72718, 0xe25245a1, 0xf1af2637}, - [16]uint32{0x3f800000, 0x3f89feb1, 0x3fe00400, 0x3fe9fab1, 0x3f960503, 0x3f9ffbb2, 0x3ff60103, 0x3fffffb2, 0x3f872821, 0x3f8ed690, 0x3fe72c21, 0x3feed290, 0x3f912d22, 0x3f98d393, 0x3ff12922, 0x3ff8d793}, - uint32(0xfff80000), - [21]string{"0xbe", "0xdb", "0xc1", "0x19", "0xc3", "0x76", "0x96", "0x70", "0x64", "0x79", "0xf9", "0x78", "0x33", "0x36", "0x98", "0xc5", "0x84", "0x29", "0x62", "0x9b", "0x00"}}, - { - /* No.32 delta:931 weight:1201 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x5c03fe6b, 0xf980c4cd, 0xa5833aa6, 0xd1800200, 0x8d83fc6b, 0x2800c6cd, 0x740338a6, 0x00005e80, 0x5c03a0eb, 0xf9809a4d, 0xa5836426, 0xd1805c80, 0x8d83a2eb, 0x2800984d, 0x74036626}, - [16]uint32{0x00000000, 0x440311b6, 0x50014125, 0x14025093, 0x30806002, 0x748371b4, 0x60812127, 0x24823091, 0x2001518f, 0x64024039, 0x700010aa, 0x3403011c, 0x1081318d, 0x5482203b, 0x408070a8, 0x0483611e}, - [16]uint32{0x3f800000, 0x3fa20188, 0x3fa800a0, 0x3f8a0128, 0x3f984030, 0x3fba41b8, 0x3fb04090, 0x3f924118, 0x3f9000a8, 0x3fb20120, 0x3fb80008, 0x3f9a0180, 0x3f884098, 0x3faa4110, 0x3fa04038, 0x3f8241b0}, - uint32(0xfff80000), - [21]string{"0x88", "0x0a", "0xba", "0xc7", "0x94", "0x4a", "0x94", "0xdb", "0x00", "0x44", "0xcd", "0xb3", "0xf7", "0x4b", "0x3f", "0x58", "0xf1", "0xe2", "0x5d", "0xa8", "0x00"}}, - { - /* No.33 delta:2638 weight:897 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x4799d6f6, 0xa319c120, 0xe48017d6, 0x5ac00217, 0x1d59d4e1, 0xf9d9c337, 0xbe4015c1, 0x00004ab0, 0x47999c46, 0xa3198b90, 0xe4805d66, 0x5ac048a7, 0x1d599e51, 0xf9d98987, 0xbe405f71}, - [16]uint32{0x00000000, 0x9080001d, 0xb90703ee, 0x298703f3, 0x4820e8c7, 0xd8a0e8da, 0xf127eb29, 0x61a7eb34, 0x82f810ab, 0x127810b6, 0x3bff1345, 0xab7f1358, 0xcad8f86c, 0x5a58f871, 0x73dffb82, 0xe35ffb9f}, - [16]uint32{0x3f800000, 0x3fc84000, 0x3fdc8381, 0x3f94c381, 0x3fa41074, 0x3fec5074, 0x3ff893f5, 0x3fb0d3f5, 0x3fc17c08, 0x3f893c08, 0x3f9dff89, 0x3fd5bf89, 0x3fe56c7c, 0x3fad2c7c, 0x3fb9effd, 0x3ff1affd}, - uint32(0xfff80000), - [21]string{"0xa1", "0xd1", "0x5b", "0x36", "0xed", "0x69", "0x7c", "0xd5", "0x59", "0x6f", "0x3d", "0xb6", "0xeb", "0xc7", "0x5a", "0xa6", "0x25", "0xb1", "0xde", "0x82", "0x00"}}, - { - /* No.34 delta:2636 weight:929 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x3c08004a, 0x7d62e150, 0x416ae11a, 0xa1c00225, 0x9dc8026f, 0xdca2e375, 0xe0aae33f, 0x000090a6, 0x3c0890ec, 0x7d6271f6, 0x416a71bc, 0xa1c09283, 0x9dc892c9, 0xdca273d3, 0xe0aa7399}, - [16]uint32{0x00000000, 0xa470699a, 0x1202409c, 0xb6722906, 0xe1d34561, 0x45a32cfb, 0xf3d105fd, 0x57a16c67, 0x5f304155, 0xfb4028cf, 0x4d3201c9, 0xe9426853, 0xbee30434, 0x1a936dae, 0xace144a8, 0x08912d32}, - [16]uint32{0x3f800000, 0x3fd23834, 0x3f890120, 0x3fdb3914, 0x3ff0e9a2, 0x3fa2d196, 0x3ff9e882, 0x3fabd0b6, 0x3faf9820, 0x3ffda014, 0x3fa69900, 0x3ff4a134, 0x3fdf7182, 0x3f8d49b6, 0x3fd670a2, 0x3f844896}, - uint32(0xfff80000), - [21]string{"0x19", "0x24", "0xa9", "0x32", "0x47", "0xfb", "0xc5", "0x02", "0xd0", "0x5a", "0xd6", "0x29", "0xb7", "0x28", "0xc1", "0x1d", "0x3f", "0x73", "0x88", "0xe1", "0x00"}}, - { - /* No.35 delta:1232 weight:1687 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x3edd78fb, 0x2bc6abe4, 0x151bd31f, 0x3f400231, 0x019d7aca, 0x1486a9d5, 0x2a5bd12e, 0x00002ae9, 0x3edd5212, 0x2bc6810d, 0x151bf9f6, 0x3f4028d8, 0x019d5023, 0x1486833c, 0x2a5bfbc7}, - [16]uint32{0x00000000, 0x0824a87e, 0x4048c809, 0x486c6077, 0x5039801d, 0x581d2863, 0x10714814, 0x1855e06a, 0x000e7145, 0x082ad93b, 0x4046b94c, 0x48621132, 0x5037f158, 0x58135926, 0x107f3951, 0x185b912f}, - [16]uint32{0x3f800000, 0x3f841254, 0x3fa02464, 0x3fa43630, 0x3fa81cc0, 0x3fac0e94, 0x3f8838a4, 0x3f8c2af0, 0x3f800738, 0x3f84156c, 0x3fa0235c, 0x3fa43108, 0x3fa81bf8, 0x3fac09ac, 0x3f883f9c, 0x3f8c2dc8}, - uint32(0xfff80000), - [21]string{"0xa9", "0x98", "0x5d", "0xcc", "0x59", "0xa5", "0x1a", "0x00", "0xc7", "0x87", "0x68", "0x82", "0xf4", "0x04", "0x8b", "0xc3", "0xa3", "0x0c", "0x1e", "0x53", "0x00"}}, - { - /* No.36 delta:786 weight:1663 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0x94ee5ba3, 0x071342e5, 0x93fd1946, 0x7cd00242, 0xe83e59e1, 0x7bc340a7, 0xef2d1b04, 0x0000e533, 0x94eebe90, 0x0713a7d6, 0x93fdfc75, 0x7cd0e771, 0xe83ebcd2, 0x7bc3a594, 0xef2dfe37}, - [16]uint32{0x00000000, 0x1001c81e, 0x8005654f, 0x9004ad51, 0x00023019, 0x1003f807, 0x80075556, 0x90069d48, 0x40008195, 0x5001498b, 0xc005e4da, 0xd0042cc4, 0x4002b18c, 0x50037992, 0xc007d4c3, 0xd0061cdd}, - [16]uint32{0x3f800000, 0x3f8800e4, 0x3fc002b2, 0x3fc80256, 0x3f800118, 0x3f8801fc, 0x3fc003aa, 0x3fc8034e, 0x3fa00040, 0x3fa800a4, 0x3fe002f2, 0x3fe80216, 0x3fa00158, 0x3fa801bc, 0x3fe003ea, 0x3fe8030e}, - uint32(0xfff80000), - [21]string{"0xbc", "0xac", "0x40", "0xe1", "0xa4", "0xcf", "0x68", "0x57", "0x92", "0x5d", "0xc9", "0xb3", "0x6f", "0xd5", "0x5b", "0x1b", "0xac", "0x54", "0xa1", "0x77", "0x00"}}, - { - /* No.37 delta:2265 weight:1225 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0xcd0f688b, 0xf8f41039, 0x35fb78b2, 0x5f400250, 0x924f6adb, 0xa7b41269, 0x6abb7ae2, 0x0000f07f, 0xcd0f98f4, 0xf8f4e046, 0x35fb88cd, 0x5f40f22f, 0x924f9aa4, 0xa7b4e216, 0x6abb8a9d}, - [16]uint32{0x00000000, 0x09832156, 0x0c00c8d3, 0x0583e985, 0x0e88499a, 0x070b68cc, 0x02888149, 0x0b0ba01f, 0x1680886e, 0x1f03a938, 0x1a8040bd, 0x130361eb, 0x1808c1f4, 0x118be0a2, 0x14080927, 0x1d8b2871}, - [16]uint32{0x3f800000, 0x3f84c190, 0x3f860064, 0x3f82c1f4, 0x3f874424, 0x3f8385b4, 0x3f814440, 0x3f8585d0, 0x3f8b4044, 0x3f8f81d4, 0x3f8d4020, 0x3f8981b0, 0x3f8c0460, 0x3f88c5f0, 0x3f8a0404, 0x3f8ec594}, - uint32(0xfff80000), - [21]string{"0x61", "0xcc", "0x16", "0xa5", "0xdd", "0xbe", "0xe2", "0x88", "0x85", "0x5d", "0x84", "0x1d", "0xae", "0x86", "0x9e", "0x5a", "0x80", "0xf1", "0x6b", "0x64", "0x00"}}, - { - /* No.38 delta:2677 weight:905 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x42e3bb47, 0x9e764ebc, 0xdc95f5fb, 0x4de0026f, 0x0f03b928, 0xd3964cd3, 0x9175f794, 0x00006bb7, 0x42e3d0f0, 0x9e76250b, 0xdc959e4c, 0x4de069d8, 0x0f03d29f, 0xd3962764, 0x91759c23}, - [16]uint32{0x00000000, 0x224f1092, 0xa0508803, 0x821f9891, 0xa028403a, 0x826750a8, 0x0078c839, 0x2237d8ab, 0x4220e01e, 0x606ff08c, 0xe270681d, 0xc03f788f, 0xe208a024, 0xc047b0b6, 0x42582827, 0x601738b5}, - [16]uint32{0x3f800000, 0x3f912788, 0x3fd02844, 0x3fc10fcc, 0x3fd01420, 0x3fc133a8, 0x3f803c64, 0x3f911bec, 0x3fa11070, 0x3fb037f8, 0x3ff13834, 0x3fe01fbc, 0x3ff10450, 0x3fe023d8, 0x3fa12c14, 0x3fb00b9c}, - uint32(0xfff80000), - [21]string{"0x84", "0x26", "0x0e", "0x3e", "0x1b", "0xc1", "0xf1", "0x19", "0xe5", "0x93", "0xf4", "0x85", "0x7e", "0x2f", "0x17", "0x2e", "0x58", "0xd9", "0x6f", "0x9a", "0x00"}}, - { - /* No.39 delta:786 weight:667 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x676d51d0, 0xf68c5350, 0x91e10280, 0x0650027f, 0x613d53af, 0xf0dc512f, 0x97b100ff, 0x000019cd, 0x676d481d, 0xf68c4a9d, 0x91e11b4d, 0x06501bb2, 0x613d4a62, 0xf0dc48e2, 0x97b11932}, - [16]uint32{0x00000000, 0x5167c43f, 0x000671a9, 0x5161b596, 0x004105ed, 0x5126c1d2, 0x00477444, 0x5120b07b, 0x43820068, 0x12e5c457, 0x438471c1, 0x12e3b5fe, 0x43c30585, 0x12a4c1ba, 0x43c5742c, 0x12a2b013}, - [16]uint32{0x3f800000, 0x3fa8b3e2, 0x3f800338, 0x3fa8b0da, 0x3f802082, 0x3fa89360, 0x3f8023ba, 0x3fa89058, 0x3fa1c100, 0x3f8972e2, 0x3fa1c238, 0x3f8971da, 0x3fa1e182, 0x3f895260, 0x3fa1e2ba, 0x3f895158}, - uint32(0xfff80000), - [21]string{"0xe3", "0xa3", "0x8f", "0xb6", "0xe8", "0xba", "0x04", "0x11", "0xbf", "0x43", "0xc9", "0x1f", "0x8d", "0x61", "0xe8", "0x61", "0xb3", "0x99", "0xfe", "0xaf", "0x00"}}, - { - /* No.40 delta:745 weight:1705 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0x6f7fb8fe, 0x4386db54, 0x2cf963aa, 0xef600289, 0x801fba77, 0xace6d9dd, 0xc3996123, 0x0000b944, 0x6f7f01ba, 0x43866210, 0x2cf9daee, 0xef60bbcd, 0x801f0333, 0xace66099, 0xc399d867}, - [16]uint32{0x00000000, 0x1000e41e, 0x3021c209, 0x20212617, 0x50001606, 0x4000f218, 0x6021d40f, 0x70213011, 0x30000113, 0x2000e50d, 0x0021c31a, 0x10212704, 0x60001715, 0x7000f30b, 0x5021d51c, 0x40213102}, - [16]uint32{0x3f800000, 0x3f880072, 0x3f9810e1, 0x3f901093, 0x3fa8000b, 0x3fa00079, 0x3fb010ea, 0x3fb81098, 0x3f980000, 0x3f900072, 0x3f8010e1, 0x3f881093, 0x3fb0000b, 0x3fb80079, 0x3fa810ea, 0x3fa01098}, - uint32(0xfff80000), - [21]string{"0xc0", "0x16", "0xdd", "0x23", "0x9e", "0xdf", "0x73", "0x5b", "0x4c", "0xc1", "0x3b", "0xb8", "0x4e", "0xf9", "0x1a", "0x07", "0xc5", "0x25", "0x31", "0x02", "0x00"}}, - { - /* No.41 delta:1262 weight:1689 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0x9f1bdb6d, 0x8180e703, 0x1e9b3c6e, 0x1ac00292, 0x85dbd9ff, 0x9b40e591, 0x045b3efc, 0x00007a0d, 0x9f1ba160, 0x81809d0e, 0x1e9b4663, 0x1ac0789f, 0x85dba3f2, 0x9b409f9c, 0x045b44f1}, - [16]uint32{0x00000000, 0x007e003a, 0x00628151, 0x001c816b, 0x38a801e5, 0x38d601df, 0x38ca80b4, 0x38b4808e, 0x0002a118, 0x007ca122, 0x00602049, 0x001e2073, 0x38aaa0fd, 0x38d4a0c7, 0x38c821ac, 0x38b62196}, - [16]uint32{0x3f800000, 0x3f803f00, 0x3f803140, 0x3f800e40, 0x3f9c5400, 0x3f9c6b00, 0x3f9c6540, 0x3f9c5a40, 0x3f800150, 0x3f803e50, 0x3f803010, 0x3f800f10, 0x3f9c5550, 0x3f9c6a50, 0x3f9c6410, 0x3f9c5b10}, - uint32(0xfff80000), - [21]string{"0xe6", "0x9b", "0xca", "0x13", "0x53", "0x35", "0xe1", "0xcd", "0x81", "0x66", "0x78", "0xbe", "0xc1", "0x5c", "0x46", "0x67", "0xa5", "0xbe", "0xf3", "0x4c", "0x00"}}, - { - /* No.42 delta:2137 weight:1311 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x610b70db, 0x55576aea, 0x345c1a31, 0xf8a002aa, 0x99ab7271, 0xadf76840, 0xccfc189b, 0x0000dbb3, 0x610bab68, 0x5557b159, 0x345cc182, 0xf8a0d919, 0x99aba9c2, 0xadf7b3f3, 0xccfcc328}, - [16]uint32{0x00000000, 0x2c80f07a, 0x0d71214d, 0x21f1d137, 0x67010013, 0x4b81f069, 0x6a70215e, 0x46f0d124, 0x03c0e921, 0x2f40195b, 0x0eb1c86c, 0x22313816, 0x64c1e932, 0x48411948, 0x69b0c87f, 0x45303805}, - [16]uint32{0x3f800000, 0x3f964078, 0x3f86b890, 0x3f90f8e8, 0x3fb38080, 0x3fa5c0f8, 0x3fb53810, 0x3fa37868, 0x3f81e074, 0x3f97a00c, 0x3f8758e4, 0x3f91189c, 0x3fb260f4, 0x3fa4208c, 0x3fb4d864, 0x3fa2981c}, - uint32(0xfff80000), - [21]string{"0xce", "0x58", "0x3a", "0xdd", "0xda", "0x30", "0x1a", "0x13", "0xf0", "0x74", "0xa1", "0xfc", "0x0d", "0x09", "0x89", "0xba", "0x95", "0x5b", "0xbc", "0x05", "0x00"}}, - { - /* No.43 delta:3542 weight:1399 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0x903af7e2, 0xbc53f76e, 0x2c69008c, 0x47d002b6, 0xd7eaf554, 0xfb83f5d8, 0x6bb9023a, 0x00002113, 0x903ad6f1, 0xbc53d67d, 0x2c69219f, 0x47d023a5, 0xd7ead447, 0xfb83d4cb, 0x6bb92329}, - [16]uint32{0x00000000, 0x0102809a, 0x000001b3, 0x01028129, 0x0000016d, 0x010281f7, 0x000000de, 0x01028044, 0x0000801d, 0x01020087, 0x000081ae, 0x01020134, 0x00008170, 0x010201ea, 0x000080c3, 0x01020059}, - [16]uint32{0x3f800000, 0x3f808140, 0x3f800000, 0x3f808140, 0x3f800000, 0x3f808140, 0x3f800000, 0x3f808140, 0x3f800040, 0x3f808100, 0x3f800040, 0x3f808100, 0x3f800040, 0x3f808100, 0x3f800040, 0x3f808100}, - uint32(0xfff80000), - [21]string{"0x7e", "0x35", "0x4c", "0x0a", "0x5d", "0x28", "0x1a", "0xea", "0x31", "0xd8", "0x9a", "0xab", "0xbe", "0xfd", "0xb4", "0x88", "0x86", "0xdd", "0xf1", "0x63", "0x00"}}, - { - /* No.44 delta:1029 weight:1639 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x067fc6ad, 0x97c590e7, 0x91ba564a, 0x9d0002c0, 0x9b7fc46d, 0x0ac59227, 0x0cba548a, 0x00002c42, 0x067feaef, 0x97c5bca5, 0x91ba7a08, 0x9d002e82, 0x9b7fe82f, 0x0ac5be65, 0x0cba78c8}, - [16]uint32{0x00000000, 0x1073e352, 0x000301a9, 0x1070e2fb, 0x403d181e, 0x504efb4c, 0x403e19b7, 0x504dfae5, 0x01042383, 0x1177c0d1, 0x0107222a, 0x1174c178, 0x41393b9d, 0x514ad8cf, 0x413a3a34, 0x5149d966}, - [16]uint32{0x3f800000, 0x3f8839f1, 0x3f800180, 0x3f883871, 0x3fa01e8c, 0x3fa8277d, 0x3fa01f0c, 0x3fa826fd, 0x3f808211, 0x3f88bbe0, 0x3f808391, 0x3f88ba60, 0x3fa09c9d, 0x3fa8a56c, 0x3fa09d1d, 0x3fa8a4ec}, - uint32(0xfff80000), - [21]string{"0xf0", "0x72", "0x85", "0x59", "0x14", "0x29", "0xb0", "0x54", "0x97", "0xb5", "0x08", "0x91", "0x41", "0x02", "0x93", "0xa3", "0xd1", "0x61", "0xf7", "0x56", "0x00"}}, - { - /* No.45 delta:758 weight:1579 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x293a9a50, 0x911e56b5, 0xb824cce5, 0xed8002df, 0xc4ba988f, 0x7c9e546a, 0x55a4ce3a, 0x0000fe7c, 0x293a642c, 0x911ea8c9, 0xb8243299, 0xed80fca3, 0xc4ba66f3, 0x7c9eaa16, 0x55a43046}, - [16]uint32{0x00000000, 0x2006607a, 0x00001259, 0x20067223, 0x10224205, 0x3024227f, 0x1022505c, 0x30243026, 0x1102f9ab, 0x310499d1, 0x1102ebf2, 0x31048b88, 0x0120bbae, 0x2126dbd4, 0x0120a9f7, 0x2126c98d}, - [16]uint32{0x3f800000, 0x3f900330, 0x3f800009, 0x3f900339, 0x3f881121, 0x3f981211, 0x3f881128, 0x3f981218, 0x3f88817c, 0x3f98824c, 0x3f888175, 0x3f988245, 0x3f80905d, 0x3f90936d, 0x3f809054, 0x3f909364}, - uint32(0xfff80000), - [21]string{"0x45", "0xa1", "0x36", "0xfd", "0x29", "0xae", "0x9d", "0x89", "0x66", "0xc1", "0x52", "0x23", "0xab", "0x49", "0x91", "0x54", "0x97", "0x2d", "0xe8", "0xab", "0x00"}}, - { - /* No.46 delta:740 weight:1653 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0xc2bfb3ee, 0x1e17102e, 0xdca8a3c0, 0x56a002e6, 0x941fb108, 0x48b712c8, 0x8a08a126, 0x000030c2, 0xc2bf832c, 0x1e1720ec, 0xdca89302, 0x56a03224, 0x941f81ca, 0x48b7220a, 0x8a0891e4}, - [16]uint32{0x00000000, 0x10238477, 0x0000c015, 0x10234462, 0x026089fd, 0x12430d8a, 0x026049e8, 0x1243cd9f, 0xc044320b, 0xd067b67c, 0xc044f21e, 0xd0677669, 0xc224bbf6, 0xd2073f81, 0xc2247be3, 0xd207ff94}, - [16]uint32{0x3f800000, 0x3f8811c2, 0x3f800060, 0x3f8811a2, 0x3f813044, 0x3f892186, 0x3f813024, 0x3f8921e6, 0x3fe02219, 0x3fe833db, 0x3fe02279, 0x3fe833bb, 0x3fe1125d, 0x3fe9039f, 0x3fe1123d, 0x3fe903ff}, - uint32(0xfff80000), - [21]string{"0xbc", "0x35", "0xb5", "0xf4", "0x1c", "0x83", "0xb1", "0x43", "0x2f", "0xbc", "0x98", "0xc0", "0x2d", "0x75", "0x1c", "0xf7", "0xa7", "0x58", "0x91", "0xef", "0x00"}}, - { - /* No.47 delta:1023 weight:1339 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x103bbf40, 0x47cf4a25, 0x57f4f565, 0xa17002f9, 0xb14bbdb9, 0xe6bf48dc, 0xf684f79c, 0x000043a1, 0x103bfce1, 0x47cf0984, 0x57f4b6c4, 0xa1704158, 0xb14bfe18, 0xe6bf0b7d, 0xf684b43d}, - [16]uint32{0x00000000, 0x400061b6, 0x601e2a1a, 0x201e4bac, 0x40090073, 0x000961c5, 0x20172a69, 0x60174bdf, 0x10002118, 0x500040ae, 0x701e0b02, 0x301e6ab4, 0x5009216b, 0x100940dd, 0x30170b71, 0x70176ac7}, - [16]uint32{0x3f800000, 0x3fa00030, 0x3fb00f15, 0x3f900f25, 0x3fa00480, 0x3f8004b0, 0x3f900b95, 0x3fb00ba5, 0x3f880010, 0x3fa80020, 0x3fb80f05, 0x3f980f35, 0x3fa80490, 0x3f8804a0, 0x3f980b85, 0x3fb80bb5}, - uint32(0xfff80000), - [21]string{"0x35", "0xfc", "0x27", "0xb0", "0x9a", "0x8d", "0x46", "0x03", "0xc5", "0x29", "0xf2", "0x0e", "0x1d", "0x9f", "0xa6", "0xc1", "0xfb", "0x8b", "0x60", "0x83", "0x00"}}, - { - /* No.48 delta:914 weight:1427 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x881827c4, 0xf677e94d, 0x7e6fce89, 0x27900300, 0xaf8824c4, 0xd1e7ea4d, 0x59ffcd89, 0x0000042e, 0x881823ea, 0xf677ed63, 0x7e6fcaa7, 0x2790072e, 0xaf8820ea, 0xd1e7ee63, 0x59ffc9a7}, - [16]uint32{0x00000000, 0x2807115b, 0x208271f5, 0x088560ae, 0x00819c78, 0x28868d23, 0x2003ed8d, 0x0804fcd6, 0x0040c0cc, 0x2847d197, 0x20c2b139, 0x08c5a062, 0x00c15cb4, 0x28c64def, 0x20432d41, 0x08443c1a}, - [16]uint32{0x3f800000, 0x3f940388, 0x3f904138, 0x3f8442b0, 0x3f8040ce, 0x3f944346, 0x3f9001f6, 0x3f84027e, 0x3f802060, 0x3f9423e8, 0x3f906158, 0x3f8462d0, 0x3f8060ae, 0x3f946326, 0x3f902196, 0x3f84221e}, - uint32(0xfff80000), - [21]string{"0xb1", "0xcb", "0x4d", "0x0a", "0x50", "0x26", "0x0e", "0x75", "0xee", "0xf1", "0x61", "0xbe", "0x7a", "0x0c", "0xff", "0xfa", "0x59", "0x3f", "0xbb", "0xbb", "0x00"}}, - { - /* No.49 delta:1496 weight:1687 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x97d0a142, 0x5c5a83fc, 0xcb8a22be, 0x83f0031d, 0x1420a25f, 0xdfaa80e1, 0x487a21a3, 0x00005114, 0x97d0f056, 0x5c5ad2e8, 0xcb8a73aa, 0x83f05209, 0x1420f34b, 0xdfaad1f5, 0x487a70b7}, - [16]uint32{0x00000000, 0xc94004fa, 0x202c881d, 0xe96c8ce7, 0x00712561, 0xc931219b, 0x205dad7c, 0xe91da986, 0x109e1016, 0xd9de14ec, 0x30b2980b, 0xf9f29cf1, 0x10ef3577, 0xd9af318d, 0x30c3bd6a, 0xf983b990}, - [16]uint32{0x3f800000, 0x3fe4a002, 0x3f901644, 0x3ff4b646, 0x3f803892, 0x3fe49890, 0x3f902ed6, 0x3ff48ed4, 0x3f884f08, 0x3fecef0a, 0x3f98594c, 0x3ffcf94e, 0x3f88779a, 0x3fecd798, 0x3f9861de, 0x3ffcc1dc}, - uint32(0xfff80000), - [21]string{"0xc7", "0x1f", "0xb6", "0x33", "0x7b", "0xc0", "0xe2", "0x07", "0x61", "0x31", "0xf3", "0x6b", "0xc4", "0x02", "0xee", "0xb8", "0xf5", "0xde", "0x86", "0xfb", "0x00"}}, - { - /* No.50 delta:1017 weight:1379 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x8a72e209, 0x80064108, 0x0a74a301, 0x2a700329, 0xa002e120, 0xaa764221, 0x2004a028, 0x0000276e, 0x8a72c567, 0x80066666, 0x0a74846f, 0x2a702447, 0xa002c64e, 0xaa76654f, 0x20048746}, - [16]uint32{0x00000000, 0x60030972, 0x281ea939, 0x481da04b, 0x5000de16, 0x3003d764, 0x781e772f, 0x181d7e5d, 0x1000841e, 0x70038d6c, 0x381e2d27, 0x581d2455, 0x40005a08, 0x2003537a, 0x681ef331, 0x081dfa43}, - [16]uint32{0x3f800000, 0x3fb00184, 0x3f940f54, 0x3fa40ed0, 0x3fa8006f, 0x3f9801eb, 0x3fbc0f3b, 0x3f8c0ebf, 0x3f880042, 0x3fb801c6, 0x3f9c0f16, 0x3fac0e92, 0x3fa0002d, 0x3f9001a9, 0x3fb40f79, 0x3f840efd}, - uint32(0xfff80000), - [21]string{"0xcf", "0xe0", "0xdd", "0xe5", "0xc6", "0xd8", "0x52", "0x00", "0x6d", "0xb3", "0x72", "0xaa", "0xa6", "0x9d", "0xce", "0x2e", "0xa2", "0x63", "0x0b", "0x0d", "0x00"}}, - { - /* No.51 delta:2045 weight:1309 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x7ba353c2, 0x72444e05, 0x09e71dc7, 0xe8e0033b, 0x934350f9, 0x9aa44d3e, 0xe1071efc, 0x0000fa95, 0x7ba3a957, 0x7244b490, 0x09e7e752, 0xe8e0f9ae, 0x9343aa6c, 0x9aa4b7ab, 0xe107e469}, - [16]uint32{0x00000000, 0x24188114, 0x2314009a, 0x070c818e, 0x9618202c, 0xb200a138, 0xb50c20b6, 0x9114a1a2, 0x0c2438e1, 0x283cb9f5, 0x2f30387b, 0x0b28b96f, 0x9a3c18cd, 0xbe2499d9, 0xb9281857, 0x9d309943}, - [16]uint32{0x3f800000, 0x3f920c40, 0x3f918a00, 0x3f838640, 0x3fcb0c10, 0x3fd90050, 0x3fda8610, 0x3fc88a50, 0x3f86121c, 0x3f941e5c, 0x3f97981c, 0x3f85945c, 0x3fcd1e0c, 0x3fdf124c, 0x3fdc940c, 0x3fce984c}, - uint32(0xfff80000), - [21]string{"0x70", "0xc6", "0x77", "0xbf", "0xe4", "0x1a", "0x82", "0x0a", "0x8a", "0x5b", "0x2a", "0x93", "0x4f", "0x09", "0xb7", "0x9f", "0x7f", "0x0f", "0x33", "0xc9", "0x00"}}, - { - /* No.52 delta:839 weight:1583 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x674726ea, 0x27a13070, 0x40e6169a, 0x1bc0034a, 0x7c8725a0, 0x3c61333a, 0x5b2615d0, 0x00006a2b, 0x67474cc1, 0x27a15a5b, 0x40e67cb1, 0x1bc06961, 0x7c874f8b, 0x3c615911, 0x5b267ffb}, - [16]uint32{0x00000000, 0x41028416, 0x4000140f, 0x01029019, 0x1000121b, 0x5102960d, 0x50000614, 0x11028202, 0x90401c03, 0xd1429815, 0xd040080c, 0x91428c1a, 0x80400e18, 0xc1428a0e, 0xc0401a17, 0x81429e01}, - [16]uint32{0x3f800000, 0x3fa08142, 0x3fa0000a, 0x3f808148, 0x3f880009, 0x3fa8814b, 0x3fa80003, 0x3f888141, 0x3fc8200e, 0x3fe8a14c, 0x3fe82004, 0x3fc8a146, 0x3fc02007, 0x3fe0a145, 0x3fe0200d, 0x3fc0a14f}, - uint32(0xfff80000), - [21]string{"0x14", "0x30", "0xd7", "0x1b", "0xa4", "0xa0", "0x00", "0x4f", "0x40", "0x49", "0xc4", "0x4f", "0x7f", "0x8b", "0x76", "0x18", "0xd7", "0x6a", "0xfd", "0x81", "0x00"}}, - { - /* No.53 delta:769 weight:1553 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xd85e8608, 0xa7b19d3c, 0x7fef1b34, 0x81a00358, 0x59fe8550, 0x26119e64, 0xfe4f186c, 0x000048bb, 0xd85eceb3, 0xa7b1d587, 0x7fef538f, 0x81a04be3, 0x59fecdeb, 0x2611d6df, 0xfe4f50d7}, - [16]uint32{0x00000000, 0x402c0417, 0x40019731, 0x002d9326, 0x0068848c, 0x4044809b, 0x406913bd, 0x004517aa, 0x3008e615, 0x7024e202, 0x70097124, 0x30257533, 0x30606299, 0x704c668e, 0x7061f5a8, 0x304df1bf}, - [16]uint32{0x3f800000, 0x3fa01602, 0x3fa000cb, 0x3f8016c9, 0x3f803442, 0x3fa02240, 0x3fa03489, 0x3f80228b, 0x3f980473, 0x3fb81271, 0x3fb804b8, 0x3f9812ba, 0x3f983031, 0x3fb82633, 0x3fb830fa, 0x3f9826f8}, - uint32(0xfff80000), - [21]string{"0xd6", "0x8f", "0x13", "0x03", "0x40", "0x7a", "0xe8", "0x41", "0xe3", "0x27", "0x5b", "0x23", "0x49", "0x63", "0x1b", "0x16", "0x6a", "0xa2", "0x14", "0x04", "0x00"}}, - { - /* No.54 delta:951 weight:1563 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0xf09fc6c7, 0xf0b7937f, 0x002855b8, 0x29700360, 0xd9efc5a7, 0xd9c7901f, 0x295856d8, 0x00002334, 0xf09fe5f3, 0xf0b7b04b, 0x0028768c, 0x29702054, 0xd9efe693, 0xd9c7b32b, 0x295875ec}, - [16]uint32{0x00000000, 0x900c71be, 0x204dbc0a, 0xb041cdb4, 0x0020a5f7, 0x902cd449, 0x206d19fd, 0xb0616843, 0x2000300f, 0xb00c41b1, 0x004d8c05, 0x9041fdbb, 0x202095f8, 0xb02ce446, 0x006d29f2, 0x9061584c}, - [16]uint32{0x3f800000, 0x3fc80638, 0x3f9026de, 0x3fd820e6, 0x3f801052, 0x3fc8166a, 0x3f90368c, 0x3fd830b4, 0x3f900018, 0x3fd80620, 0x3f8026c6, 0x3fc820fe, 0x3f90104a, 0x3fd81672, 0x3f803694, 0x3fc830ac}, - uint32(0xfff80000), - [21]string{"0xf8", "0xc0", "0x25", "0xb4", "0xda", "0x06", "0xca", "0xc7", "0x17", "0x31", "0xd6", "0x67", "0x69", "0x44", "0xeb", "0x40", "0x1f", "0x0d", "0xb7", "0xc8", "0x00"}}, - { - /* No.55 delta:820 weight:651 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x57316eba, 0x26094031, 0x71382e8b, 0xe8700378, 0xbf416dc2, 0xce794349, 0x99482df3, 0x000012ad, 0x57317c17, 0x2609529c, 0x71383c26, 0xe87011d5, 0xbf417f6f, 0xce7951e4, 0x99483f5e}, - [16]uint32{0x00000000, 0x48301d92, 0x2c04420b, 0x64345f99, 0x0228401d, 0x4a185d8f, 0x2e2c0216, 0x661c1f84, 0x21510062, 0x69611df0, 0x0d554269, 0x45655ffb, 0x2379407f, 0x6b495ded, 0x0f7d0274, 0x474d1fe6}, - [16]uint32{0x3f800000, 0x3fa4180e, 0x3f960221, 0x3fb21a2f, 0x3f811420, 0x3fa50c2e, 0x3f971601, 0x3fb30e0f, 0x3f90a880, 0x3fb4b08e, 0x3f86aaa1, 0x3fa2b2af, 0x3f91bca0, 0x3fb5a4ae, 0x3f87be81, 0x3fa3a68f}, - uint32(0xfff80000), - [21]string{"0x7e", "0x9c", "0x5e", "0x32", "0xc0", "0x16", "0x45", "0xbd", "0x76", "0x10", "0xe1", "0xbf", "0x45", "0x88", "0x55", "0xbd", "0x7d", "0x2a", "0x9a", "0x13", "0x00"}}, - { - /* No.56 delta:985 weight:1247 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0xd8c9f7ef, 0x678c6234, 0xbf4595db, 0xedc00381, 0x3509f46e, 0x8a4c61b5, 0x5285965a, 0x000064df, 0xd8c99330, 0x678c06eb, 0xbf45f104, 0xedc0675e, 0x350990b1, 0x8a4c056a, 0x5285f285}, - [16]uint32{0x00000000, 0x404d099a, 0x10636cac, 0x502e6536, 0x01078014, 0x414a898e, 0x1164ecb8, 0x5129e522, 0x000220ad, 0x404f2937, 0x10614c01, 0x502c459b, 0x0105a0b9, 0x4148a923, 0x1166cc15, 0x512bc58f}, - [16]uint32{0x3f800000, 0x3fa02684, 0x3f8831b6, 0x3fa81732, 0x3f8083c0, 0x3fa0a544, 0x3f88b276, 0x3fa894f2, 0x3f800110, 0x3fa02794, 0x3f8830a6, 0x3fa81622, 0x3f8082d0, 0x3fa0a454, 0x3f88b366, 0x3fa895e2}, - uint32(0xfff80000), - [21]string{"0x47", "0x79", "0x4f", "0x24", "0x4f", "0x28", "0x51", "0x55", "0xe6", "0x00", "0xb2", "0x92", "0x43", "0x2e", "0xef", "0x24", "0x53", "0x4b", "0x89", "0xae", "0x00"}}, - { - /* No.57 delta:2159 weight:1381 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x7a54ffc0, 0x46d69d10, 0x3c8262d0, 0xae80039c, 0xd4d4fc5c, 0xe8569e8c, 0x9202614c, 0x00006126, 0x7a549ee6, 0x46d6fc36, 0x3c8203f6, 0xae8062ba, 0xd4d49d7a, 0xe856ffaa, 0x9202006a}, - [16]uint32{0x00000000, 0x648d905b, 0x1720008f, 0x73ad90d4, 0x08090109, 0x6c849152, 0x1f290186, 0x7ba491dd, 0x4884300c, 0x2c09a057, 0x5fa43083, 0x3b29a0d8, 0x408d3105, 0x2400a15e, 0x57ad318a, 0x3320a1d1}, - [16]uint32{0x3f800000, 0x3fb246c8, 0x3f8b9000, 0x3fb9d6c8, 0x3f840480, 0x3fb64248, 0x3f8f9480, 0x3fbdd248, 0x3fa44218, 0x3f9604d0, 0x3fafd218, 0x3f9d94d0, 0x3fa04698, 0x3f920050, 0x3fabd698, 0x3f999050}, - uint32(0xfff80000), - [21]string{"0x65", "0x7d", "0x27", "0xa8", "0x7d", "0x8d", "0x8f", "0x40", "0xf6", "0x00", "0x92", "0x6e", "0xb9", "0x2c", "0x8f", "0x1f", "0xf7", "0xcd", "0xf8", "0xf8", "0x00"}}, - { - /* No.58 delta:960 weight:1657 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0x39030bf4, 0xdc4c74cc, 0xe54f7f38, 0x384003a5, 0x01430851, 0xe40c7769, 0xdd0f7c9d, 0x0000d6eb, 0x3903dd1f, 0xdc4ca227, 0xe54fa9d3, 0x3840d54e, 0x0143deba, 0xe40ca182, 0xdd0faa76}, - [16]uint32{0x00000000, 0x4036ac1a, 0x506559cc, 0x1053f5d6, 0x0002501b, 0x4034fc01, 0x506709d7, 0x1051a5cd, 0x30280592, 0x701ea988, 0x604d5c5e, 0x207bf044, 0x302a5589, 0x701cf993, 0x604f0c45, 0x2079a05f}, - [16]uint32{0x3f800000, 0x3fa01b56, 0x3fa832ac, 0x3f8829fa, 0x3f800128, 0x3fa01a7e, 0x3fa83384, 0x3f8828d2, 0x3f981402, 0x3fb80f54, 0x3fb026ae, 0x3f903df8, 0x3f98152a, 0x3fb80e7c, 0x3fb02786, 0x3f903cd0}, - uint32(0xfff80000), - [21]string{"0x22", "0xa6", "0x3d", "0x5c", "0x9c", "0x64", "0xc4", "0x1a", "0x87", "0xbc", "0x5a", "0x8b", "0x20", "0xf8", "0x21", "0x9e", "0x1f", "0xf6", "0xcd", "0xcc", "0x00"}}, - { - /* No.59 delta:756 weight:1633 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0xe9579f78, 0xecb6987d, 0x05e10705, 0xdd5003bf, 0x34079cc7, 0x31e69bc2, 0xd8b104ba, 0x00008eff, 0xe9571187, 0xecb61682, 0x05e189fa, 0xdd508d40, 0x34071238, 0x31e6153d, 0xd8b18a45}, - [16]uint32{0x00000000, 0x8004081d, 0x300b8a16, 0xb00f820b, 0x20025234, 0xa0065a29, 0x1009d822, 0x900dd03f, 0x3000f0b8, 0xb004f8a5, 0x000b7aae, 0x800f72b3, 0x1002a28c, 0x9006aa91, 0x2009289a, 0xa00d2087}, - [16]uint32{0x3f800000, 0x3fc00204, 0x3f9805c5, 0x3fd807c1, 0x3f900129, 0x3fd0032d, 0x3f8804ec, 0x3fc806e8, 0x3f980078, 0x3fd8027c, 0x3f8005bd, 0x3fc007b9, 0x3f880151, 0x3fc80355, 0x3f900494, 0x3fd00690}, - uint32(0xfff80000), - [21]string{"0x85", "0x15", "0x62", "0xa4", "0x84", "0x38", "0x47", "0xdf", "0x75", "0x59", "0xe1", "0x04", "0xe4", "0xca", "0xb9", "0x9c", "0x18", "0x22", "0x13", "0xe3", "0x00"}}, - { - /* No.60 delta:884 weight:1491 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0x2b4ddbaa, 0x62581d43, 0x4915c6e9, 0xb02003cc, 0x9b6dd866, 0xd2781e8f, 0xf935c525, 0x0000065e, 0x2b4dddf4, 0x62581b1d, 0x4915c0b7, 0xb0200592, 0x9b6dde38, 0xd27818d1, 0xf935c37b}, - [16]uint32{0x00000000, 0x4857d1f3, 0x006c189c, 0x483bc96f, 0x00109016, 0x484741e5, 0x007c888a, 0x482b5979, 0x0042e11e, 0x481530ed, 0x002ef982, 0x48792871, 0x00527108, 0x4805a0fb, 0x003e6994, 0x4869b867}, - [16]uint32{0x3f800000, 0x3fa42be8, 0x3f80360c, 0x3fa41de4, 0x3f800848, 0x3fa423a0, 0x3f803e44, 0x3fa415ac, 0x3f802170, 0x3fa40a98, 0x3f80177c, 0x3fa43c94, 0x3f802938, 0x3fa402d0, 0x3f801f34, 0x3fa434dc}, - uint32(0xfff80000), - [21]string{"0x39", "0x31", "0x69", "0x5e", "0x7e", "0x10", "0xb8", "0xaa", "0x3a", "0x98", "0x1c", "0x5b", "0xff", "0x82", "0x62", "0x56", "0xa4", "0x6d", "0x74", "0xcb", "0x00"}}, - { - /* No.61 delta:906 weight:1689 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0x91a3a21f, 0x5fe47590, 0xce47d78f, 0x4ae003d2, 0xdb43a1cd, 0x15047642, 0x84a7d45d, 0x0000207b, 0x91a38264, 0x5fe455eb, 0xce47f7f4, 0x4ae023a9, 0xdb4381b6, 0x15045639, 0x84a7f426}, - [16]uint32{0x00000000, 0x0003183a, 0x685560d6, 0x685678ec, 0x00080811, 0x000b102b, 0x685d68c7, 0x685e70fd, 0x10414608, 0x10425e32, 0x781426de, 0x78173ee4, 0x10494e19, 0x104a5623, 0x781c2ecf, 0x781f36f5}, - [16]uint32{0x3f800000, 0x3f80018c, 0x3fb42ab0, 0x3fb42b3c, 0x3f800404, 0x3f800588, 0x3fb42eb4, 0x3fb42f38, 0x3f8820a3, 0x3f88212f, 0x3fbc0a13, 0x3fbc0b9f, 0x3f8824a7, 0x3f88252b, 0x3fbc0e17, 0x3fbc0f9b}, - uint32(0xfff80000), - [21]string{"0x57", "0x3c", "0x84", "0xe5", "0x98", "0xdb", "0x39", "0x4a", "0xeb", "0xa4", "0x81", "0x6b", "0x09", "0x0d", "0xc0", "0xe8", "0xe9", "0x35", "0x36", "0xb6", "0x00"}}, - { - /* No.62 delta:1119 weight:1595 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0x7c95ddbe, 0xbc1eaeaf, 0xc08b7311, 0xc13003e8, 0xbda5de56, 0x7d2ead47, 0x01bb70f9, 0x00001cd3, 0x7c95c16d, 0xbc1eb27c, 0xc08b6fc2, 0xc1301f3b, 0xbda5c285, 0x7d2eb194, 0x01bb6c2a}, - [16]uint32{0x00000000, 0x20449212, 0x2026c1f4, 0x006253e6, 0x1008101b, 0x304c8209, 0x302ed1ef, 0x106a43fd, 0x00035008, 0x2047c21a, 0x202591fc, 0x006103ee, 0x100b4013, 0x304fd201, 0x302d81e7, 0x106913f5}, - [16]uint32{0x3f800000, 0x3f902249, 0x3f901360, 0x3f803129, 0x3f880408, 0x3f982641, 0x3f981768, 0x3f883521, 0x3f8001a8, 0x3f9023e1, 0x3f9012c8, 0x3f803081, 0x3f8805a0, 0x3f9827e9, 0x3f9816c0, 0x3f883489}, - uint32(0xfff80000), - [21]string{"0x15", "0x36", "0x2b", "0xe9", "0xbe", "0xfc", "0x35", "0x7f", "0x43", "0x78", "0xb2", "0xe9", "0x1b", "0x6f", "0xe1", "0x9a", "0x31", "0x7e", "0xa7", "0xa5", "0x00"}}, - { - /* No.63 delta:1018 weight:1315 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0xf4c75a08, 0x33451618, 0xc7824c10, 0x1a2003fc, 0xeee759f4, 0x296515e4, 0xdda24fec, 0x0000bc07, 0xf4c7e60f, 0x3345aa1f, 0xc782f017, 0x1a20bffb, 0xeee7e5f3, 0x2965a9e3, 0xdda2f3eb}, - [16]uint32{0x00000000, 0x0154993e, 0x102e04dc, 0x117a9de2, 0x00562016, 0x0102b928, 0x107824ca, 0x112cbdf4, 0x00028084, 0x015619ba, 0x102c8458, 0x11781d66, 0x0054a092, 0x010039ac, 0x107aa44e, 0x112e3d70}, - [16]uint32{0x3f800000, 0x3f80aa4c, 0x3f881702, 0x3f88bd4e, 0x3f802b10, 0x3f80815c, 0x3f883c12, 0x3f88965e, 0x3f800140, 0x3f80ab0c, 0x3f881642, 0x3f88bc0e, 0x3f802a50, 0x3f80801c, 0x3f883d52, 0x3f88971e}, - uint32(0xfff80000), - [21]string{"0x0b", "0x34", "0x5c", "0x8b", "0x80", "0x6e", "0x98", "0xde", "0x54", "0x2d", "0xbc", "0xd0", "0x18", "0x38", "0x01", "0x6b", "0x27", "0x70", "0x53", "0x67", "0x00"}}, - { - /* No.64 delta:1089 weight:1641 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x320f354d, 0x4b52ac78, 0x795d9935, 0x1be00405, 0x29ef3148, 0x50b2a87d, 0x62bd9d30, 0x0000f8ea, 0x320fcda7, 0x4b525492, 0x795d61df, 0x1be0fcef, 0x29efc9a2, 0x50b25097, 0x62bd65da}, - [16]uint32{0x00000000, 0x00441014, 0x0168282f, 0x012c383b, 0x205018c9, 0x201408dd, 0x213830e6, 0x217c20f2, 0x0060788e, 0x0024689a, 0x010850a1, 0x014c40b5, 0x20306047, 0x20747053, 0x21584868, 0x211c587c}, - [16]uint32{0x3f800000, 0x3f802208, 0x3f80b414, 0x3f80961c, 0x3f90280c, 0x3f900a04, 0x3f909c18, 0x3f90be10, 0x3f80303c, 0x3f801234, 0x3f808428, 0x3f80a620, 0x3f901830, 0x3f903a38, 0x3f90ac24, 0x3f908e2c}, - uint32(0xfff80000), - [21]string{"0x0b", "0x75", "0x3a", "0x0f", "0x25", "0x1b", "0x1e", "0x62", "0x79", "0xde", "0x49", "0xe4", "0x67", "0xde", "0x19", "0x1c", "0x07", "0x87", "0xb7", "0x03", "0x00"}}, - { - /* No.65 delta:714 weight:1595 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xc4cfa437, 0xb22d512f, 0x76e2f518, 0x1fb00411, 0xdb7fa026, 0xad9d553e, 0x6952f109, 0x0000b641, 0xc4cf1276, 0xb22de76e, 0x76e24359, 0x1fb0b250, 0xdb7f1667, 0xad9de37f, 0x69524748}, - [16]uint32{0x00000000, 0x0003499a, 0x904c1025, 0x904f59bf, 0x60086118, 0x600b2882, 0xf044713d, 0xf04738a7, 0x00009815, 0x0003d18f, 0x904c8830, 0x904fc1aa, 0x6008f90d, 0x600bb097, 0xf044e928, 0xf047a0b2}, - [16]uint32{0x3f800000, 0x3f8001a4, 0x3fc82608, 0x3fc827ac, 0x3fb00430, 0x3fb00594, 0x3ff82238, 0x3ff8239c, 0x3f80004c, 0x3f8001e8, 0x3fc82644, 0x3fc827e0, 0x3fb0047c, 0x3fb005d8, 0x3ff82274, 0x3ff823d0}, - uint32(0xfff80000), - [21]string{"0xc2", "0xcd", "0xc7", "0x28", "0xfa", "0x9f", "0xe4", "0x82", "0x5d", "0x7c", "0x58", "0x33", "0x83", "0xa7", "0x2d", "0xd5", "0x6e", "0x00", "0xce", "0x8b", "0x00"}}, - { - /* No.66 delta:1489 weight:1775 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x27ac5b8e, 0x7da1bc19, 0x5a0de797, 0xc1d00429, 0xe67c5fa7, 0xbc71b830, 0x9bdde3be, 0x0000f5b6, 0x27acae38, 0x7da149af, 0x5a0d1221, 0xc1d0f19f, 0xe67caa11, 0xbc714d86, 0x9bdd1608}, - [16]uint32{0x00000000, 0x486c4874, 0x0249557f, 0x4a251d0b, 0x107c8402, 0x5810cc76, 0x1235d17d, 0x5a599909, 0x1003f025, 0x586fb851, 0x124aa55a, 0x5a26ed2e, 0x007f7427, 0x48133c53, 0x02362158, 0x4a5a692c}, - [16]uint32{0x3f800000, 0x3fa43624, 0x3f8124aa, 0x3fa5128e, 0x3f883e42, 0x3fac0866, 0x3f891ae8, 0x3fad2ccc, 0x3f8801f8, 0x3fac37dc, 0x3f892552, 0x3fad1376, 0x3f803fba, 0x3fa4099e, 0x3f811b10, 0x3fa52d34}, - uint32(0xfff80000), - [21]string{"0x96", "0xb5", "0xb1", "0x05", "0x1a", "0xe3", "0x5f", "0x00", "0x61", "0x64", "0xea", "0x66", "0xa3", "0x2b", "0xe1", "0x35", "0xb4", "0x7d", "0x59", "0xd2", "0x00"}}, - { - /* No.67 delta:723 weight:1463 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0xfc1f1f2f, 0xc4d2cb0e, 0x38cdd421, 0xc2b00437, 0x3eaf1b18, 0x0662cf39, 0xfa7dd016, 0x0000a8c0, 0xfc1fb7ef, 0xc4d263ce, 0x38cd7ce1, 0xc2b0acf7, 0x3eafb3d8, 0x066267f9, 0xfa7d78d6}, - [16]uint32{0x00000000, 0x00641c81, 0x340b711d, 0x346f6d9c, 0x1015e41f, 0x1071f89e, 0x241e9502, 0x247a8983, 0x00028e08, 0x00669289, 0x3409ff15, 0x346de394, 0x10176a17, 0x10737696, 0x241c1b0a, 0x2478078b}, - [16]uint32{0x3f800000, 0x3f80320e, 0x3f9a05b8, 0x3f9a37b6, 0x3f880af2, 0x3f8838fc, 0x3f920f4a, 0x3f923d44, 0x3f800147, 0x3f803349, 0x3f9a04ff, 0x3f9a36f1, 0x3f880bb5, 0x3f8839bb, 0x3f920e0d, 0x3f923c03}, - uint32(0xfff80000), - [21]string{"0xf4", "0x2a", "0x3e", "0xd7", "0x86", "0x3d", "0xa0", "0x67", "0x25", "0xa6", "0xa8", "0x85", "0x72", "0xca", "0x5c", "0x60", "0xcc", "0xc8", "0x6f", "0x35", "0x00"}}, - { - /* No.68 delta:1693 weight:1443 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x13299b1c, 0x63241401, 0x700d8f1d, 0x42600440, 0x51499f5c, 0x21441041, 0x326d8b5d, 0x00001370, 0x1329886c, 0x63240771, 0x700d9c6d, 0x42601730, 0x51498c2c, 0x21440331, 0x326d982d}, - [16]uint32{0x00000000, 0x21a4819e, 0x153ae095, 0x349e610b, 0x40056146, 0x61a1e0d8, 0x553f81d3, 0x749b004d, 0x180164bc, 0x39a5e522, 0x0d3b8429, 0x2c9f05b7, 0x580405fa, 0x79a08464, 0x4d3ee56f, 0x6c9a64f1}, - [16]uint32{0x3f800000, 0x3f90d240, 0x3f8a9d70, 0x3f9a4f30, 0x3fa002b0, 0x3fb0d0f0, 0x3faa9fc0, 0x3fba4d80, 0x3f8c00b2, 0x3f9cd2f2, 0x3f869dc2, 0x3f964f82, 0x3fac0202, 0x3fbcd042, 0x3fa69f72, 0x3fb64d32}, - uint32(0xfff80000), - [21]string{"0xd1", "0x71", "0x93", "0x13", "0xcd", "0x52", "0x65", "0x76", "0x85", "0x6a", "0x2e", "0xb7", "0xf3", "0x0b", "0x49", "0x99", "0x86", "0x3d", "0x92", "0x0d", "0x00"}}, - { - /* No.69 delta:1307 weight:1479 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x07c30918, 0x94343ae4, 0x93f733fc, 0x6db00450, 0x6a730d48, 0xf9843eb4, 0xfe4737ac, 0x00007d59, 0x07c37441, 0x943447bd, 0x93f74ea5, 0x6db07909, 0x6a737011, 0xf98443ed, 0xfe474af5}, - [16]uint32{0x00000000, 0x4075907e, 0x004c410c, 0x4039d172, 0x002f09cd, 0x405a99b3, 0x006348c1, 0x4016d8bf, 0x4008b006, 0x007d2078, 0x4044f10a, 0x00316174, 0x4027b9cb, 0x005229b5, 0x406bf8c7, 0x001e68b9}, - [16]uint32{0x3f800000, 0x3fa03ac8, 0x3f802620, 0x3fa01ce8, 0x3f801784, 0x3fa02d4c, 0x3f8031a4, 0x3fa00b6c, 0x3fa00458, 0x3f803e90, 0x3fa02278, 0x3f8018b0, 0x3fa013dc, 0x3f802914, 0x3fa035fc, 0x3f800f34}, - uint32(0xfff80000), - [21]string{"0xf5", "0x02", "0x42", "0xbf", "0xf1", "0xcd", "0x2a", "0xe7", "0xcc", "0x16", "0x29", "0xd9", "0xdf", "0x4c", "0x1b", "0x8a", "0xd2", "0xe3", "0x42", "0x87", "0x00"}}, - { - /* No.70 delta:2277 weight:1275 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x7556a31c, 0xe17eb988, 0x94281a94, 0x85000461, 0xf056a77d, 0x647ebde9, 0x11281ef5, 0x0000a401, 0x7556071d, 0xe17e1d89, 0x9428be95, 0x8500a060, 0xf056037c, 0x647e19e8, 0x1128baf4}, - [16]uint32{0x00000000, 0x4a8384f2, 0x14b0012d, 0x5e3385df, 0x18488015, 0x52cb04e7, 0x0cf88138, 0x467b05ca, 0x4800403a, 0x0283c4c8, 0x5cb04117, 0x1633c5e5, 0x5048c02f, 0x1acb44dd, 0x44f8c102, 0x0e7b45f0}, - [16]uint32{0x3f800000, 0x3fa541c2, 0x3f8a5800, 0x3faf19c2, 0x3f8c2440, 0x3fa96582, 0x3f867c40, 0x3fa33d82, 0x3fa40020, 0x3f8141e2, 0x3fae5820, 0x3f8b19e2, 0x3fa82460, 0x3f8d65a2, 0x3fa27c60, 0x3f873da2}, - uint32(0xfff80000), - [21]string{"0x1e", "0x51", "0xac", "0x8a", "0x9d", "0x34", "0x89", "0x83", "0x73", "0xe5", "0x49", "0x94", "0x37", "0x11", "0x32", "0x2d", "0x8a", "0xb6", "0xcd", "0x96", "0x00"}}, - { - /* No.71 delta:1215 weight:1591 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0xc94d3c2c, 0x2e401a94, 0xe70d26b8, 0x50100470, 0x995d385c, 0x7e501ee4, 0xb71d22c8, 0x00006b09, 0xc94d5725, 0x2e40719d, 0xe70d4db1, 0x50106f79, 0x995d5355, 0x7e5075ed, 0xb71d49c1}, - [16]uint32{0x00000000, 0x0826883a, 0x005840e9, 0x087ec8d3, 0x205c05d1, 0x287a8deb, 0x20044538, 0x2822cd02, 0x11089817, 0x192e102d, 0x1150d8fe, 0x197650c4, 0x31549dc6, 0x397215fc, 0x310cdd2f, 0x392a5515}, - [16]uint32{0x3f800000, 0x3f841344, 0x3f802c20, 0x3f843f64, 0x3f902e02, 0x3f943d46, 0x3f900222, 0x3f941166, 0x3f88844c, 0x3f8c9708, 0x3f88a86c, 0x3f8cbb28, 0x3f98aa4e, 0x3f9cb90a, 0x3f98866e, 0x3f9c952a}, - uint32(0xfff80000), - [21]string{"0x4f", "0x05", "0x82", "0x20", "0xf4", "0x8d", "0x2d", "0xe9", "0x1c", "0xd5", "0x73", "0x15", "0xb0", "0xaa", "0xf2", "0x4f", "0x30", "0x04", "0x96", "0xb4", "0x00"}}, - { - /* No.72 delta:652 weight:1403 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x291f4139, 0xe6434801, 0xcf5c0938, 0xe4b0048a, 0xcdaf45b3, 0x02f34c8b, 0x2bec0db2, 0x00008ad9, 0x291fcbe0, 0xe643c2d8, 0xcf5c83e1, 0xe4b08e53, 0xcdafcf6a, 0x02f3c652, 0x2bec876b}, - [16]uint32{0x00000000, 0x0063c957, 0x802cb41b, 0x804f7d4c, 0x0431412d, 0x0452887a, 0x841df536, 0x847e3c61, 0x000231d1, 0x0061f886, 0x802e85ca, 0x804d4c9d, 0x043370fc, 0x0450b9ab, 0x841fc4e7, 0x847c0db0}, - [16]uint32{0x3f800000, 0x3f8031e4, 0x3fc0165a, 0x3fc027be, 0x3f8218a0, 0x3f822944, 0x3fc20efa, 0x3fc23f1e, 0x3f800118, 0x3f8030fc, 0x3fc01742, 0x3fc026a6, 0x3f8219b8, 0x3f82285c, 0x3fc20fe2, 0x3fc23e06}, - uint32(0xfff80000), - [21]string{"0x6f", "0x2d", "0x27", "0x79", "0xae", "0xd3", "0x36", "0x85", "0x65", "0x0d", "0x5d", "0xb5", "0xac", "0x24", "0x89", "0xe2", "0x2e", "0xbe", "0x97", "0xb4", "0x00"}}, - { - /* No.73 delta:1101 weight:1763 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x560d2adb, 0xb2127f1a, 0xe41f55c1, 0x51300499, 0x073d2e42, 0xe3227b83, 0xb52f5158, 0x0000abdc, 0x560d8107, 0xb212d4c6, 0xe41ffe1d, 0x5130af45, 0x073d859e, 0xe322d05f, 0xb52ffa84}, - [16]uint32{0x00000000, 0x0050e576, 0x600041bb, 0x6050a4cd, 0xb00138e7, 0xb051dd91, 0xd001795c, 0xd0519c2a, 0x30181083, 0x3048f5f5, 0x50185138, 0x5048b44e, 0x80192864, 0x8049cd12, 0xe01969df, 0xe0498ca9}, - [16]uint32{0x3f800000, 0x3f802872, 0x3fb00020, 0x3fb02852, 0x3fd8009c, 0x3fd828ee, 0x3fe800bc, 0x3fe828ce, 0x3f980c08, 0x3f98247a, 0x3fa80c28, 0x3fa8245a, 0x3fc00c94, 0x3fc024e6, 0x3ff00cb4, 0x3ff024c6}, - uint32(0xfff80000), - [21]string{"0x24", "0xa9", "0xfe", "0xbb", "0x8f", "0x2a", "0x81", "0xe7", "0x73", "0x37", "0xb9", "0x39", "0x98", "0x66", "0x5c", "0x81", "0x55", "0xb9", "0x0e", "0x19", "0x00"}}, - { - /* No.74 delta:876 weight:905 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0x5af2542e, 0x5bb7bc50, 0x0145e87e, 0x331004a3, 0x69e2508d, 0x68a7b8f3, 0x3255ecdd, 0x0000f93b, 0x5af2ad15, 0x5bb7456b, 0x01451145, 0x3310fd98, 0x69e2a9b6, 0x68a741c8, 0x325515e6}, - [16]uint32{0x00000000, 0x404c409a, 0x0040115f, 0x400c51c5, 0x00676079, 0x402b20e3, 0x00277126, 0x406b31bc, 0x000eb018, 0x4042f082, 0x004ea147, 0x4002e1dd, 0x0069d061, 0x402590fb, 0x0029c13e, 0x406581a4}, - [16]uint32{0x3f800000, 0x3fa02620, 0x3f802008, 0x3fa00628, 0x3f8033b0, 0x3fa01590, 0x3f8013b8, 0x3fa03598, 0x3f800758, 0x3fa02178, 0x3f802750, 0x3fa00170, 0x3f8034e8, 0x3fa012c8, 0x3f8014e0, 0x3fa032c0}, - uint32(0xfff80000), - [21]string{"0x6c", "0xbd", "0x29", "0xe3", "0x65", "0xd4", "0x88", "0x90", "0x6f", "0x21", "0x6e", "0xed", "0x6d", "0x9a", "0xf6", "0xfe", "0x97", "0xbe", "0x58", "0x4b", "0x00"}}, - { - /* No.75 delta:885 weight:1253 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x5e39eadc, 0xa9b23c93, 0xf78bd64f, 0xe1e004b7, 0xbfd9ee6b, 0x48523824, 0x166bd2f8, 0x00008ac0, 0x5e39601c, 0xa9b2b653, 0xf78b5c8f, 0xe1e08e77, 0xbfd964ab, 0x4852b2e4, 0x166b5838}, - [16]uint32{0x00000000, 0x400301de, 0xd000c86d, 0x9003c9b3, 0x40106097, 0x00136149, 0x9010a8fa, 0xd013a924, 0xc0008019, 0x800381c7, 0x10004874, 0x500349aa, 0x8010e08e, 0xc013e150, 0x501028e3, 0x1013293d}, - [16]uint32{0x3f800000, 0x3fa00180, 0x3fe80064, 0x3fc801e4, 0x3fa00830, 0x3f8009b0, 0x3fc80854, 0x3fe809d4, 0x3fe00040, 0x3fc001c0, 0x3f880024, 0x3fa801a4, 0x3fc00870, 0x3fe009f0, 0x3fa80814, 0x3f880994}, - uint32(0xfff80000), - [21]string{"0x60", "0xba", "0x71", "0x72", "0x3a", "0x97", "0x88", "0x75", "0x5e", "0x45", "0xcf", "0xe5", "0x59", "0xa2", "0x0c", "0xd8", "0xdf", "0x65", "0x87", "0x19", "0x00"}}, - { - /* No.76 delta:2153 weight:1269 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x3206c523, 0x1c0d4583, 0x2e0b80a0, 0xec9004cd, 0xde96c1ee, 0xf09d414e, 0xc29b846d, 0x0000d57e, 0x3206105d, 0x1c0d90fd, 0x2e0b55de, 0xec90d1b3, 0xde961490, 0xf09d9430, 0xc29b5113}, - [16]uint32{0x00000000, 0x034309f2, 0x10040b87, 0x13470275, 0x0800401e, 0x0b4349ec, 0x18044b99, 0x1b47426b, 0x272120ed, 0x2462291f, 0x37252b6a, 0x34662298, 0x2f2160f3, 0x2c626901, 0x3f256b74, 0x3c666286}, - [16]uint32{0x3f800000, 0x3f81a184, 0x3f880205, 0x3f89a381, 0x3f840020, 0x3f85a1a4, 0x3f8c0225, 0x3f8da3a1, 0x3f939090, 0x3f923114, 0x3f9b9295, 0x3f9a3311, 0x3f9790b0, 0x3f963134, 0x3f9f92b5, 0x3f9e3331}, - uint32(0xfff80000), - [21]string{"0x77", "0xa5", "0x9d", "0xbd", "0xae", "0xa2", "0xaa", "0x67", "0xc1", "0x01", "0xdd", "0x6f", "0x89", "0x9b", "0xb6", "0x7a", "0xfd", "0x3d", "0x4a", "0xb0", "0x00"}}, - { - /* No.77 delta:1132 weight:1669 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x35724a27, 0x53a7ed07, 0x66d5a720, 0xff8004de, 0xcaf24ef9, 0xac27e9d9, 0x9955a3fe, 0x0000e9f3, 0x3572a3d4, 0x53a704f4, 0x66d54ed3, 0xff80ed2d, 0xcaf2a70a, 0xac27002a, 0x99554a0d}, - [16]uint32{0x00000000, 0x18371172, 0x4000108e, 0x583701fc, 0x0048f0fa, 0x187fe188, 0x4048e074, 0x587ff106, 0x007a08dd, 0x184d19af, 0x407a1853, 0x584d0921, 0x0032f827, 0x1805e955, 0x4032e8a9, 0x5805f9db}, - [16]uint32{0x3f800000, 0x3f8c1b88, 0x3fa00008, 0x3fac1b80, 0x3f802478, 0x3f8c3ff0, 0x3fa02470, 0x3fac3ff8, 0x3f803d04, 0x3f8c268c, 0x3fa03d0c, 0x3fac2684, 0x3f80197c, 0x3f8c02f4, 0x3fa01974, 0x3fac02fc}, - uint32(0xfff80000), - [21]string{"0x85", "0xdd", "0xb3", "0x21", "0x23", "0x3b", "0x83", "0xad", "0x64", "0x33", "0x12", "0x30", "0x80", "0xf8", "0x38", "0xfc", "0x83", "0x12", "0x88", "0x20", "0x00"}}, - { - /* No.78 delta:1199 weight:1651 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0xd89eace9, 0x2735054e, 0xffaba9a7, 0xbdd004ea, 0x654ea803, 0x9ae501a4, 0x427bad4d, 0x0000497f, 0xd89ee596, 0x27354c31, 0xffabe0d8, 0xbdd04d95, 0x654ee17c, 0x9ae548db, 0x427be432}, - [16]uint32{0x00000000, 0x00390194, 0x0078e00b, 0x0041e19f, 0xd010193a, 0xd02918ae, 0xd068f931, 0xd051f8a5, 0x10090419, 0x1030058d, 0x1071e412, 0x1048e586, 0xc0191d23, 0xc0201cb7, 0xc061fd28, 0xc058fcbc}, - [16]uint32{0x3f800000, 0x3f801c80, 0x3f803c70, 0x3f8020f0, 0x3fe8080c, 0x3fe8148c, 0x3fe8347c, 0x3fe828fc, 0x3f880482, 0x3f881802, 0x3f8838f2, 0x3f882472, 0x3fe00c8e, 0x3fe0100e, 0x3fe030fe, 0x3fe02c7e}, - uint32(0xfff80000), - [21]string{"0x08", "0xa7", "0x35", "0x7c", "0xcf", "0x56", "0x3b", "0xc3", "0x85", "0x5b", "0xc7", "0xc0", "0x5d", "0x90", "0x74", "0xe6", "0xcc", "0xb0", "0xb1", "0xfd", "0x00"}}, - { - /* No.79 delta:892 weight:1675 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0x0434b892, 0x79823e0d, 0x7db6869f, 0xa4e004f5, 0xa0d4bc67, 0xdd623af8, 0xd956826a, 0x000060f0, 0x0434d862, 0x79825efd, 0x7db6e66f, 0xa4e06405, 0xa0d4dc97, 0xdd625a08, 0xd956e29a}, - [16]uint32{0x00000000, 0x000b801a, 0x18405819, 0x184bd803, 0x00022c07, 0x0009ac1d, 0x1842741e, 0x1849f404, 0x400315d5, 0x400895cf, 0x58434dcc, 0x5848cdd6, 0x400139d2, 0x400ab9c8, 0x584161cb, 0x584ae1d1}, - [16]uint32{0x3f800000, 0x3f8005c0, 0x3f8c202c, 0x3f8c25ec, 0x3f800116, 0x3f8004d6, 0x3f8c213a, 0x3f8c24fa, 0x3fa0018a, 0x3fa0044a, 0x3fac21a6, 0x3fac2466, 0x3fa0009c, 0x3fa0055c, 0x3fac20b0, 0x3fac2570}, - uint32(0xfff80000), - [21]string{"0xf2", "0x33", "0x90", "0x14", "0xd2", "0xa7", "0x36", "0xf6", "0x35", "0x60", "0x0e", "0xf6", "0x5a", "0xdf", "0x90", "0x11", "0xaf", "0x95", "0x8a", "0x3b", "0x00"}}, - { - /* No.80 delta:1111 weight:1547 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x7cf58980, 0x9082a4b0, 0xec772d30, 0x52d0050d, 0x2e258c8d, 0xc252a1bd, 0xbea7283d, 0x000017b4, 0x7cf59e34, 0x9082b304, 0xec773a84, 0x52d012b9, 0x2e259b39, 0xc252b609, 0xbea73f89}, - [16]uint32{0x00000000, 0x006810fa, 0x00049929, 0x006c89d3, 0x4002109c, 0x406a0066, 0x400689b5, 0x406e994f, 0x40018936, 0x406999cc, 0x4005101f, 0x406d00e5, 0x000399aa, 0x006b8950, 0x00070083, 0x006f1079}, - [16]uint32{0x3f800000, 0x3f803408, 0x3f80024c, 0x3f803644, 0x3fa00108, 0x3fa03500, 0x3fa00344, 0x3fa0374c, 0x3fa000c4, 0x3fa034cc, 0x3fa00288, 0x3fa03680, 0x3f8001cc, 0x3f8035c4, 0x3f800380, 0x3f803788}, - uint32(0xfff80000), - [21]string{"0x04", "0xb7", "0x35", "0x5a", "0x80", "0x90", "0x46", "0x94", "0x03", "0x85", "0xfe", "0x64", "0x9d", "0xcc", "0x88", "0x0d", "0xfa", "0xef", "0xbb", "0x76", "0x00"}}, - { - /* No.81 delta:1067 weight:1455 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x6079553d, 0xde15d819, 0xbe6c8d24, 0xe7b0051a, 0x87c95027, 0x39a5dd03, 0x59dc883e, 0x0000cde0, 0x607998dd, 0xde1515f9, 0xbe6c40c4, 0xe7b0c8fa, 0x87c99dc7, 0x39a510e3, 0x59dc45de}, - [16]uint32{0x00000000, 0x0014109a, 0x60246415, 0x6030748f, 0x1052207c, 0x104630e6, 0x70764469, 0x706254f3, 0x00412001, 0x0055309b, 0x60654414, 0x6071548e, 0x1013007d, 0x100710e7, 0x70376468, 0x702374f2}, - [16]uint32{0x3f800000, 0x3f800a08, 0x3fb01232, 0x3fb0183a, 0x3f882910, 0x3f882318, 0x3fb83b22, 0x3fb8312a, 0x3f802090, 0x3f802a98, 0x3fb032a2, 0x3fb038aa, 0x3f880980, 0x3f880388, 0x3fb81bb2, 0x3fb811ba}, - uint32(0xfff80000), - [21]string{"0xd4", "0x7c", "0x86", "0xf0", "0x36", "0x3f", "0x03", "0x44", "0x41", "0x4f", "0xa2", "0x9f", "0x4b", "0x03", "0x50", "0xcc", "0xba", "0x69", "0x39", "0x97", "0x00"}}, - { - /* No.82 delta:811 weight:1339 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xcce813fe, 0x2dbec8f0, 0xe156db0e, 0xc7000522, 0x0be816dc, 0xeabecdd2, 0x2656de2c, 0x0000eb42, 0xcce8f8bc, 0x2dbe23b2, 0xe156304c, 0xc700ee60, 0x0be8fd9e, 0xeabe2690, 0x2656356e}, - [16]uint32{0x00000000, 0x07621833, 0x0a02c005, 0x0d60d836, 0x00f080d4, 0x079298e7, 0x0af240d1, 0x0d9058e2, 0x0003007b, 0x07611848, 0x0a01c07e, 0x0d63d84d, 0x00f380af, 0x0791989c, 0x0af140aa, 0x0d935899}, - [16]uint32{0x3f800000, 0x3f83b10c, 0x3f850160, 0x3f86b06c, 0x3f807840, 0x3f83c94c, 0x3f857920, 0x3f86c82c, 0x3f800180, 0x3f83b08c, 0x3f8500e0, 0x3f86b1ec, 0x3f8079c0, 0x3f83c8cc, 0x3f8578a0, 0x3f86c9ac}, - uint32(0xfff80000), - [21]string{"0x6f", "0x0a", "0xa8", "0x49", "0xe5", "0x73", "0xb3", "0x24", "0x00", "0xaa", "0xd2", "0xbe", "0x44", "0x6a", "0x7b", "0x67", "0x2f", "0xbe", "0x5f", "0x02", "0x00"}}, - { - /* No.83 delta:882 weight:1645 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x0433906c, 0xa3bc9f1a, 0xa78f0f76, 0x2420053a, 0x20139556, 0x879c9a20, 0x83af0a4c, 0x00008edc, 0x04331eb0, 0xa3bc11c6, 0xa78f81aa, 0x24208be6, 0x20131b8a, 0x879c14fc, 0x83af8490}, - [16]uint32{0x00000000, 0x0440301b, 0x10000895, 0x1440388e, 0x84024037, 0x8042702c, 0x940248a2, 0x904278b9, 0x4020201a, 0x44601001, 0x5020288f, 0x54601894, 0xc422602d, 0xc0625036, 0xd42268b8, 0xd06258a3}, - [16]uint32{0x3f800000, 0x3f822018, 0x3f880004, 0x3f8a201c, 0x3fc20120, 0x3fc02138, 0x3fca0124, 0x3fc8213c, 0x3fa01010, 0x3fa23008, 0x3fa81014, 0x3faa300c, 0x3fe21130, 0x3fe03128, 0x3fea1134, 0x3fe8312c}, - uint32(0xfff80000), - [21]string{"0x8b", "0x04", "0x62", "0xcc", "0x60", "0xe5", "0x43", "0xbf", "0x8b", "0x19", "0x87", "0x92", "0x22", "0x34", "0x6c", "0xb0", "0x7b", "0x42", "0x5f", "0x43", "0x00"}}, - { - /* No.84 delta:830 weight:1133 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xbe99f4e9, 0xfd60a36e, 0x43f95787, 0x43e00547, 0xfd79f1ae, 0xbe80a629, 0x001952c0, 0x000095ae, 0xbe996147, 0xfd6036c0, 0x43f9c229, 0x43e090e9, 0xfd796400, 0xbe803387, 0x0019c76e}, - [16]uint32{0x00000000, 0x107c111b, 0x0041587f, 0x103d4964, 0x6042c325, 0x703ed23e, 0x60039b5a, 0x707f8a41, 0x006029e8, 0x101c38f3, 0x00217197, 0x105d608c, 0x6022eacd, 0x705efbd6, 0x6063b2b2, 0x701fa3a9}, - [16]uint32{0x3f800000, 0x3f883e08, 0x3f8020ac, 0x3f881ea4, 0x3fb02161, 0x3fb81f69, 0x3fb001cd, 0x3fb83fc5, 0x3f803014, 0x3f880e1c, 0x3f8010b8, 0x3f882eb0, 0x3fb01175, 0x3fb82f7d, 0x3fb031d9, 0x3fb80fd1}, - uint32(0xfff80000), - [21]string{"0x2d", "0xfa", "0x77", "0x28", "0x17", "0x09", "0x3a", "0x65", "0x8d", "0xf8", "0x6b", "0x36", "0xcd", "0xc2", "0xd0", "0xbc", "0x4b", "0xb4", "0xd7", "0x62", "0x00"}}, - { - /* No.85 delta:1093 weight:1403 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xc523f0a7, 0xa559b351, 0x607a43f6, 0x80c00550, 0x45e3f5f7, 0x2599b601, 0xe0ba46a6, 0x0000cfc3, 0xc5233f64, 0xa5597c92, 0x607a8c35, 0x80c0ca93, 0x45e33a34, 0x259979c2, 0xe0ba8965}, - [16]uint32{0x00000000, 0xa040113e, 0x006639a3, 0xa026289d, 0x10440018, 0xb0041126, 0x102239bb, 0xb0622885, 0x004014b4, 0xa000058a, 0x00262d17, 0xa0663c29, 0x100414ac, 0xb0440592, 0x10622d0f, 0xb0223c31}, - [16]uint32{0x3f800000, 0x3fd02008, 0x3f80331c, 0x3fd01314, 0x3f882200, 0x3fd80208, 0x3f88111c, 0x3fd83114, 0x3f80200a, 0x3fd00002, 0x3f801316, 0x3fd0331e, 0x3f88020a, 0x3fd82202, 0x3f883116, 0x3fd8111e}, - uint32(0xfff80000), - [21]string{"0xf8", "0x53", "0xb6", "0xd8", "0xc2", "0x2e", "0xe8", "0x92", "0x09", "0xc8", "0xe5", "0xc2", "0x2f", "0xaa", "0x91", "0x62", "0x04", "0x6f", "0xb5", "0xb3", "0x00"}}, - { - /* No.86 delta:828 weight:1503 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0xf1a04143, 0xe2f3966d, 0x1353d72e, 0xcea0056c, 0x3f00442f, 0x2c539301, 0xddf3d242, 0x0000a274, 0xf1a0e337, 0xe2f33419, 0x1353755a, 0xcea0a718, 0x3f00e65b, 0x2c533175, 0xddf37036}, - [16]uint32{0x00000000, 0x30214876, 0x00001c0b, 0x3021547d, 0x200c31d8, 0x102d79ae, 0x200c2dd3, 0x102d65a5, 0x100201ff, 0x20234989, 0x10021df4, 0x20235582, 0x300e3027, 0x002f7851, 0x300e2c2c, 0x002f645a}, - [16]uint32{0x3f800000, 0x3f9810a4, 0x3f80000e, 0x3f9810aa, 0x3f900618, 0x3f8816bc, 0x3f900616, 0x3f8816b2, 0x3f880100, 0x3f9011a4, 0x3f88010e, 0x3f9011aa, 0x3f980718, 0x3f8017bc, 0x3f980716, 0x3f8017b2}, - uint32(0xfff80000), - [21]string{"0xc6", "0xaf", "0x7a", "0x2f", "0x8a", "0x20", "0x8f", "0x4a", "0x23", "0x5e", "0x76", "0xae", "0x77", "0xae", "0x14", "0xe3", "0xda", "0x07", "0x11", "0xc7", "0x00"}}, - { - /* No.87 delta:607 weight:1543 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0xa4b76d7c, 0x45c400c4, 0xe1736db8, 0x0d300578, 0xa9876804, 0x48f405bc, 0xec4368c0, 0x0000422b, 0xa4b72f57, 0x45c442ef, 0xe1732f93, 0x0d304753, 0xa9872a2f, 0x48f44797, 0xec432aeb}, - [16]uint32{0x00000000, 0xb8015572, 0x5000389b, 0xe8016de9, 0x00401611, 0xb8414363, 0x50402e8a, 0xe8417bf8, 0x30002424, 0x88017156, 0x60001cbf, 0xd80149cd, 0x30403235, 0x88416747, 0x60400aae, 0xd8415fdc}, - [16]uint32{0x3f800000, 0x3fdc00aa, 0x3fa8001c, 0x3ff400b6, 0x3f80200b, 0x3fdc20a1, 0x3fa82017, 0x3ff420bd, 0x3f980012, 0x3fc400b8, 0x3fb0000e, 0x3fec00a4, 0x3f982019, 0x3fc420b3, 0x3fb02005, 0x3fec20af}, - uint32(0xfff80000), - [21]string{"0x64", "0xe3", "0xa5", "0xfc", "0xf9", "0x14", "0x87", "0xba", "0xca", "0xba", "0xcd", "0xfe", "0xb0", "0xc6", "0x7c", "0xfa", "0xc2", "0xf1", "0xfc", "0xff", "0x00"}}, - { - /* No.88 delta:1382 weight:1193 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0xd20be97d, 0xb3aca4a3, 0x61a74dde, 0xa690058e, 0x749becf3, 0x153ca12d, 0xc7374850, 0x0000b111, 0xd20b586c, 0xb3ac15b2, 0x61a7fccf, 0xa690b49f, 0x749b5de2, 0x153c103c, 0xc737f941}, - [16]uint32{0x00000000, 0x10024a1d, 0x30000417, 0x20024e0a, 0x0040001b, 0x10424a06, 0x3040040c, 0x20424e11, 0x2000080f, 0x30024212, 0x10000c18, 0x00024605, 0x20400814, 0x30424209, 0x10400c03, 0x0042461e}, - [16]uint32{0x3f800000, 0x3f880125, 0x3f980002, 0x3f900127, 0x3f802000, 0x3f882125, 0x3f982002, 0x3f902127, 0x3f900004, 0x3f980121, 0x3f880006, 0x3f800123, 0x3f902004, 0x3f982121, 0x3f882006, 0x3f802123}, - uint32(0xfff80000), - [21]string{"0xed", "0xf6", "0x52", "0x4a", "0x5a", "0x45", "0xb6", "0xb6", "0xfa", "0xcf", "0x99", "0x71", "0xde", "0x31", "0xe2", "0x46", "0xc7", "0x6b", "0x19", "0x13", "0x00"}}, - { - /* No.89 delta:1180 weight:1491 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x2de6b803, 0x8b7e4ab5, 0xa698f2b6, 0x2ff00595, 0x0216bd96, 0xa48e4f20, 0x8968f723, 0x00004dc6, 0x2de6f5c5, 0x8b7e0773, 0xa698bf70, 0x2ff04853, 0x0216f050, 0xa48e02e6, 0x8968bae5}, - [16]uint32{0x00000000, 0x0016287a, 0x005e21b9, 0x004809c3, 0x10390011, 0x102f286b, 0x106721a8, 0x107109d2, 0x4020fa8f, 0x4036d2f5, 0x407edb36, 0x4068f34c, 0x5019fa9e, 0x500fd2e4, 0x5047db27, 0x5051f35d}, - [16]uint32{0x3f800000, 0x3f800b14, 0x3f802f10, 0x3f802404, 0x3f881c80, 0x3f881794, 0x3f883390, 0x3f883884, 0x3fa0107d, 0x3fa01b69, 0x3fa03f6d, 0x3fa03479, 0x3fa80cfd, 0x3fa807e9, 0x3fa823ed, 0x3fa828f9}, - uint32(0xfff80000), - [21]string{"0x26", "0xf5", "0x2a", "0xf0", "0x1f", "0x39", "0x50", "0x05", "0xe0", "0x65", "0xe0", "0xb7", "0xc1", "0x91", "0xba", "0xbe", "0x20", "0x11", "0x69", "0x66", "0x00"}}, - { - /* No.90 delta:895 weight:1613 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0xbbe1a4c8, 0x719d09e5, 0xca7cad2d, 0x189005a8, 0xa371a160, 0x690d0c4d, 0xd2eca885, 0x00007129, 0xbbe1d5e1, 0x719d78cc, 0xca7cdc04, 0x18907481, 0xa371d049, 0x690d7d64, 0xd2ecd9ac}, - [16]uint32{0x00000000, 0x403ac91e, 0x501d2402, 0x1027ed1c, 0x0003f418, 0x40393d06, 0x501ed01a, 0x10241904, 0x0021118e, 0x401bd890, 0x503c358c, 0x1006fc92, 0x0022e596, 0x40182c88, 0x503fc194, 0x1005088a}, - [16]uint32{0x3f800000, 0x3fa01d64, 0x3fa80e92, 0x3f8813f6, 0x3f8001fa, 0x3fa01c9e, 0x3fa80f68, 0x3f88120c, 0x3f801088, 0x3fa00dec, 0x3fa81e1a, 0x3f88037e, 0x3f801172, 0x3fa00c16, 0x3fa81fe0, 0x3f880284}, - uint32(0xfff80000), - [21]string{"0x52", "0x4a", "0x20", "0x7e", "0x06", "0x76", "0xc3", "0x1a", "0x7c", "0x32", "0x80", "0x84", "0x2a", "0xe2", "0x61", "0xa1", "0x40", "0x18", "0xf9", "0xdf", "0x00"}}, - { - /* No.91 delta:780 weight:1635 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0x03cba17f, 0x54ce7bbd, 0x5705dac2, 0xb42005b7, 0xb7eba4c8, 0xe0ee7e0a, 0xe325df75, 0x0000327f, 0x03cb9300, 0x54ce49c2, 0x5705e8bd, 0xb42037c8, 0xb7eb96b7, 0xe0ee4c75, 0xe325ed0a}, - [16]uint32{0x00000000, 0x3403405a, 0x1000c111, 0x2403814b, 0x0000d014, 0x3403904e, 0x10001105, 0x2403515f, 0x04000408, 0x30034452, 0x1400c519, 0x20038543, 0x0400d41c, 0x30039446, 0x1400150d, 0x20035557}, - [16]uint32{0x3f800000, 0x3f9a01a0, 0x3f880060, 0x3f9201c0, 0x3f800068, 0x3f9a01c8, 0x3f880008, 0x3f9201a8, 0x3f820002, 0x3f9801a2, 0x3f8a0062, 0x3f9001c2, 0x3f82006a, 0x3f9801ca, 0x3f8a000a, 0x3f9001aa}, - uint32(0xfff80000), - [21]string{"0xed", "0x70", "0xe5", "0x8e", "0x42", "0xde", "0x26", "0x57", "0xe7", "0x69", "0xad", "0xce", "0x2b", "0xdb", "0x32", "0x6d", "0xe3", "0x81", "0xa5", "0xcb", "0x00"}}, - { - /* No.92 delta:723 weight:1653 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0x8e16d78b, 0x6475cd40, 0xea631acb, 0xef6005c1, 0x6176d24a, 0x8b15c881, 0x05031f0a, 0x0000c64c, 0x8e1611c7, 0x64750b0c, 0xea63dc87, 0xef60c38d, 0x61761406, 0x8b150ecd, 0x0503d946}, - [16]uint32{0x00000000, 0x0006157d, 0x3008494f, 0x300e5c32, 0x000281c6, 0x000494bb, 0x300ac889, 0x300cddf4, 0x40008459, 0x40069124, 0x7008cd16, 0x700ed86b, 0x4002059f, 0x400410e2, 0x700a4cd0, 0x700c59ad}, - [16]uint32{0x3f800000, 0x3f80030a, 0x3f980424, 0x3f98072e, 0x3f800140, 0x3f80024a, 0x3f980564, 0x3f98066e, 0x3fa00042, 0x3fa00348, 0x3fb80466, 0x3fb8076c, 0x3fa00102, 0x3fa00208, 0x3fb80526, 0x3fb8062c}, - uint32(0xfff80000), - [21]string{"0xc2", "0x1f", "0xf1", "0xdf", "0x5c", "0xfe", "0x71", "0xcc", "0x49", "0x9f", "0x31", "0x60", "0x70", "0x60", "0xf6", "0x07", "0xfe", "0xac", "0xe8", "0x47", "0x00"}}, - { - /* No.93 delta:575 weight:1639 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x3d168a5a, 0xef7b6b30, 0xd26de16a, 0xeda005d7, 0xd0b68f8d, 0x02db6ee7, 0x3fcde4bd, 0x00005226, 0x3d16d87c, 0xef7b3916, 0xd26db34c, 0xeda057f1, 0xd0b6ddab, 0x02db3cc1, 0x3fcdb69b}, - [16]uint32{0x00000000, 0x4003c13a, 0x10004815, 0x5003892f, 0x4020101c, 0x0023d126, 0x50205809, 0x10239933, 0x60002c17, 0x2003ed2d, 0x70006402, 0x3003a538, 0x20203c0b, 0x6023fd31, 0x3020741e, 0x7023b524}, - [16]uint32{0x3f800000, 0x3fa001e0, 0x3f880024, 0x3fa801c4, 0x3fa01008, 0x3f8011e8, 0x3fa8102c, 0x3f8811cc, 0x3fb00016, 0x3f9001f6, 0x3fb80032, 0x3f9801d2, 0x3f90101e, 0x3fb011fe, 0x3f98103a, 0x3fb811da}, - uint32(0xfff80000), - [21]string{"0x0f", "0xe1", "0x48", "0x51", "0x21", "0xf0", "0x2d", "0xc4", "0x7c", "0xec", "0x9f", "0x73", "0x68", "0x9d", "0x0b", "0xdf", "0x77", "0x24", "0xcb", "0x77", "0x00"}}, - { - /* No.94 delta:1168 weight:1445 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x100553e0, 0x60a5e657, 0x70a0b5b7, 0x188005ee, 0x0885560e, 0x7825e3b9, 0x6820b059, 0x000077ef, 0x1005240f, 0x60a591b8, 0x70a0c258, 0x18807201, 0x088521e1, 0x78259456, 0x6820c7b6}, - [16]uint32{0x00000000, 0x20040036, 0x00428925, 0x20468913, 0x2043401f, 0x00474029, 0x2001c93a, 0x0005c90c, 0x604848e4, 0x404c48d2, 0x600ac1c1, 0x400ec1f7, 0x400b08fb, 0x600f08cd, 0x404981de, 0x604d81e8}, - [16]uint32{0x3f800000, 0x3f900200, 0x3f802144, 0x3f902344, 0x3f9021a0, 0x3f8023a0, 0x3f9000e4, 0x3f8002e4, 0x3fb02424, 0x3fa02624, 0x3fb00560, 0x3fa00760, 0x3fa00584, 0x3fb00784, 0x3fa024c0, 0x3fb026c0}, - uint32(0xfff80000), - [21]string{"0xaa", "0x81", "0xeb", "0x85", "0xab", "0x03", "0xbb", "0x80", "0x2e", "0x38", "0x36", "0x94", "0xb2", "0x7b", "0xd5", "0x39", "0x3f", "0x8f", "0x44", "0x22", "0x00"}}, - { - /* No.95 delta:874 weight:1655 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xa9f511af, 0xe424f2f4, 0x4dd1e35b, 0x17c005f3, 0xbe35145c, 0xf3e4f707, 0x5a11e6a8, 0x00000d8b, 0xa9f51c24, 0xe424ff7f, 0x4dd1eed0, 0x17c00878, 0xbe3519d7, 0xf3e4fa8c, 0x5a11eb23}, - [16]uint32{0x00000000, 0x908240ba, 0x00030d87, 0x90814d3d, 0x1080101f, 0x800250a5, 0x10831d98, 0x80015d22, 0x3012920e, 0xa090d2b4, 0x30119f89, 0xa093df33, 0x20928211, 0xb010c2ab, 0x20918f96, 0xb013cf2c}, - [16]uint32{0x3f800000, 0x3fc84120, 0x3f800186, 0x3fc840a6, 0x3f884008, 0x3fc00128, 0x3f88418e, 0x3fc000ae, 0x3f980949, 0x3fd04869, 0x3f9808cf, 0x3fd049ef, 0x3f904941, 0x3fd80861, 0x3f9048c7, 0x3fd809e7}, - uint32(0xfff80000), - [21]string{"0xa0", "0xed", "0x8a", "0xea", "0x95", "0xb5", "0x41", "0xea", "0xbb", "0xc9", "0x2a", "0x0a", "0x89", "0x15", "0x5b", "0x68", "0x5b", "0xb0", "0x11", "0x6d", "0x00"}}, - { - /* No.96 delta:861 weight:1191 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0x77c881e2, 0xe42dd114, 0x93e550f6, 0x8be00606, 0xfc2887e4, 0x6fcdd712, 0x180556f0, 0x00008be7, 0x77c80a05, 0xe42d5af3, 0x93e5db11, 0x8be08de1, 0xfc280c03, 0x6fcd5cf5, 0x1805dd17}, - [16]uint32{0x00000000, 0x0077459e, 0x4008115b, 0x407f54c5, 0x500201cd, 0x50754453, 0x100a1096, 0x107d5508, 0x000a00c7, 0x007d4559, 0x4002119c, 0x40755402, 0x5008010a, 0x507f4494, 0x10001051, 0x107755cf}, - [16]uint32{0x3f800000, 0x3f803ba2, 0x3fa00408, 0x3fa03faa, 0x3fa80100, 0x3fa83aa2, 0x3f880508, 0x3f883eaa, 0x3f800500, 0x3f803ea2, 0x3fa00108, 0x3fa03aaa, 0x3fa80400, 0x3fa83fa2, 0x3f880008, 0x3f883baa}, - uint32(0xfff80000), - [21]string{"0x33", "0x7e", "0x21", "0x5c", "0x53", "0x94", "0xc7", "0x17", "0x10", "0x34", "0x52", "0x6f", "0x67", "0x0e", "0x45", "0x13", "0xbf", "0xca", "0x19", "0xe8", "0x00"}}, - { - /* No.97 delta:2676 weight:853 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0xbd6a2668, 0xcc9d55b7, 0x71f773df, 0x3110061c, 0x8c7a2074, 0xfd8d53ab, 0x40e775c3, 0x00008fa3, 0xbd6aa9cb, 0xcc9dda14, 0x71f7fc7c, 0x311089bf, 0x8c7aafd7, 0xfd8ddc08, 0x40e7fa60}, - [16]uint32{0x00000000, 0x8e8000fa, 0x4181077f, 0xcf010785, 0x0c81e018, 0x8201e0e2, 0x4d00e767, 0xc380e79d, 0x02806af4, 0x8c006a0e, 0x43016d8b, 0xcd816d71, 0x0e018aec, 0x80818a16, 0x4f808d93, 0xc1008d69}, - [16]uint32{0x3f800000, 0x3fc74000, 0x3fa0c083, 0x3fe78083, 0x3f8640f0, 0x3fc100f0, 0x3fa68073, 0x3fe1c073, 0x3f814035, 0x3fc60035, 0x3fa180b6, 0x3fe6c0b6, 0x3f8700c5, 0x3fc040c5, 0x3fa7c046, 0x3fe08046}, - uint32(0xfff80000), - [21]string{"0x38", "0x47", "0x11", "0xb2", "0x01", "0x45", "0xb4", "0xc5", "0x3c", "0xee", "0x80", "0x03", "0x22", "0xf6", "0xc5", "0x68", "0x67", "0x28", "0xe1", "0xf0", "0x00"}}, - { - /* No.98 delta:827 weight:1491 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x0915d02d, 0x72064141, 0x7b13916c, 0x2840062e, 0x2155d603, 0x5a46476f, 0x53539742, 0x0000b9fc, 0x091569d1, 0x7206f8bd, 0x7b132890, 0x2840bfd2, 0x21556fff, 0x5a46fe93, 0x53532ebe}, - [16]uint32{0x00000000, 0x083d1115, 0x0002041c, 0x083f1509, 0x0001ae5b, 0x083cbf4e, 0x0003aa47, 0x083ebb52, 0x2004c174, 0x2839d061, 0x2006c568, 0x283bd47d, 0x20056f2f, 0x28387e3a, 0x20076b33, 0x283a7a26}, - [16]uint32{0x3f800000, 0x3f841e88, 0x3f800102, 0x3f841f8a, 0x3f8000d7, 0x3f841e5f, 0x3f8001d5, 0x3f841f5d, 0x3f900260, 0x3f941ce8, 0x3f900362, 0x3f941dea, 0x3f9002b7, 0x3f941c3f, 0x3f9003b5, 0x3f941d3d}, - uint32(0xfff80000), - [21]string{"0xca", "0x80", "0x3a", "0x23", "0x9d", "0x6c", "0x94", "0x61", "0x87", "0xfb", "0xb8", "0xf2", "0xda", "0xec", "0x64", "0x91", "0x28", "0x87", "0x26", "0xd6", "0x00"}}, - { - /* No.99 delta:708 weight:1311 */ - 11213, - 64, - 13, - 4, - [16]uint32{0x00000000, 0xce20c03e, 0x994236e0, 0x5762f6de, 0xc9300632, 0x0710c60c, 0x507230d2, 0x9e52f0ec, 0x0000a7af, 0xce206791, 0x9942914f, 0x57625171, 0xc930a19d, 0x071061a3, 0x5072977d, 0x9e525743}, - [16]uint32{0x00000000, 0x4101741e, 0x8020818b, 0xc121f595, 0x40033011, 0x0102440f, 0xc023b19a, 0x8122c584, 0x000101fc, 0x410075e2, 0x80218077, 0xc120f469, 0x400231ed, 0x010345f3, 0xc022b066, 0x8123c478}, - [16]uint32{0x3f800000, 0x3fa080ba, 0x3fc01040, 0x3fe090fa, 0x3fa00198, 0x3f808122, 0x3fe011d8, 0x3fc09162, 0x3f800080, 0x3fa0803a, 0x3fc010c0, 0x3fe0907a, 0x3fa00118, 0x3f8081a2, 0x3fe01158, 0x3fc091e2}, - uint32(0xfff80000), - [21]string{"0xdf", "0xbf", "0x75", "0x14", "0x07", "0x6a", "0xc5", "0x64", "0x4f", "0xc6", "0xe3", "0x60", "0x4e", "0x50", "0xe0", "0xa1", "0x15", "0x2e", "0x91", "0x98", "0x00"}}, - { - /* No.100 delta:1786 weight:1467 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x981c6d4d, 0xc6e26a11, 0x5efe075c, 0xddc00649, 0x45dc6b04, 0x1b226c58, 0x833e0115, 0x0000ca50, 0x981ca71d, 0xc6e2a041, 0x5efecd0c, 0xddc0cc19, 0x45dca154, 0x1b22a608, 0x833ecb45}, - [16]uint32{0x00000000, 0x20c503f2, 0x005801d7, 0x209d0225, 0x006c0011, 0x20a903e3, 0x003401c6, 0x20f10234, 0x000500a9, 0x20c0035b, 0x005d017e, 0x2098028c, 0x006900b8, 0x20ac034a, 0x0031016f, 0x20f4029d}, - [16]uint32{0x3f800000, 0x3f906281, 0x3f802c00, 0x3f904e81, 0x3f803600, 0x3f905481, 0x3f801a00, 0x3f907881, 0x3f800280, 0x3f906001, 0x3f802e80, 0x3f904c01, 0x3f803480, 0x3f905601, 0x3f801880, 0x3f907a01}, - uint32(0xfff80000), - [21]string{"0x6c", "0x2a", "0xd8", "0xe1", "0xb3", "0x20", "0xd0", "0xd8", "0xb2", "0x06", "0x11", "0x6f", "0xd5", "0x68", "0xed", "0xd8", "0xf6", "0xd8", "0x6a", "0x7f", "0x00"}}, - { - /* No.101 delta:615 weight:1671 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0x2fc3606f, 0x866cdf27, 0xa9afbf48, 0x5a500657, 0x75936638, 0xdc3cd970, 0xf3ffb91f, 0x000086e4, 0x2fc3e68b, 0x866c59c3, 0xa9af39ac, 0x5a5080b3, 0x7593e0dc, 0xdc3c5f94, 0xf3ff3ffb}, - [16]uint32{0x00000000, 0x0003c9f5, 0x503ca9b1, 0x503f6044, 0x0040501e, 0x004399eb, 0x507cf9af, 0x507f305a, 0x10101326, 0x1013dad3, 0x402cba97, 0x402f7362, 0x10504338, 0x10538acd, 0x406cea89, 0x406f237c}, - [16]uint32{0x3f800000, 0x3f8001e4, 0x3fa81e54, 0x3fa81fb0, 0x3f802028, 0x3f8021cc, 0x3fa83e7c, 0x3fa83f98, 0x3f880809, 0x3f8809ed, 0x3fa0165d, 0x3fa017b9, 0x3f882821, 0x3f8829c5, 0x3fa03675, 0x3fa03791}, - uint32(0xfff80000), - [21]string{"0x09", "0xb2", "0xd9", "0x88", "0x39", "0x98", "0x64", "0xbb", "0x2b", "0x23", "0x3f", "0x58", "0xc9", "0x59", "0xb2", "0x4f", "0xbf", "0xa5", "0x49", "0x32", "0x00"}}, - { - /* No.102 delta:1133 weight:1553 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x3b16c68a, 0x56b5b9f3, 0x6da37f79, 0xdde00663, 0xe6f6c0e9, 0x8b55bf90, 0xb043791a, 0x0000b22c, 0x3b1674a6, 0x56b50bdf, 0x6da3cd55, 0xdde0b44f, 0xe6f672c5, 0x8b550dbc, 0xb043cb36}, - [16]uint32{0x00000000, 0x0050209e, 0x20042152, 0x205401cc, 0x512001e5, 0x5170217b, 0x712420b7, 0x71740029, 0x8008080f, 0x80582891, 0xa00c295d, 0xa05c09c3, 0xd12809ea, 0xd1782974, 0xf12c28b8, 0xf17c0826}, - [16]uint32{0x3f800000, 0x3f802810, 0x3f900210, 0x3f902a00, 0x3fa89000, 0x3fa8b810, 0x3fb89210, 0x3fb8ba00, 0x3fc00404, 0x3fc02c14, 0x3fd00614, 0x3fd02e04, 0x3fe89404, 0x3fe8bc14, 0x3ff89614, 0x3ff8be04}, - uint32(0xfff80000), - [21]string{"0x3b", "0x5d", "0x87", "0x3e", "0x94", "0x58", "0x84", "0xcc", "0x7e", "0x4e", "0xde", "0xc6", "0x0c", "0x67", "0x79", "0xfc", "0x9f", "0x6d", "0x46", "0xbd", "0x00"}}, - { - /* No.103 delta:811 weight:1325 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xd5a39580, 0x4e8f650d, 0x9b2cf08d, 0x0970067f, 0xdcd393ff, 0x47ff6372, 0x925cf6f2, 0x0000763a, 0xd5a3e3ba, 0x4e8f1337, 0x9b2c86b7, 0x09707045, 0xdcd3e5c5, 0x47ff1548, 0x925c80c8}, - [16]uint32{0x00000000, 0x45650a5f, 0x007910dc, 0x451c1a83, 0x00051015, 0x45601a4a, 0x007c00c9, 0x45190a96, 0x5a046011, 0x1f616a4e, 0x5a7d70cd, 0x1f187a92, 0x5a017004, 0x1f647a5b, 0x5a7860d8, 0x1f1d6a87}, - [16]uint32{0x3f800000, 0x3fa2b285, 0x3f803c88, 0x3fa28e0d, 0x3f800288, 0x3fa2b00d, 0x3f803e00, 0x3fa28c85, 0x3fad0230, 0x3f8fb0b5, 0x3fad3eb8, 0x3f8f8c3d, 0x3fad00b8, 0x3f8fb23d, 0x3fad3c30, 0x3f8f8eb5}, - uint32(0xfff80000), - [21]string{"0x6f", "0x58", "0x8b", "0x82", "0xd5", "0x56", "0xd7", "0xf2", "0x15", "0xea", "0x59", "0xc4", "0x57", "0xcc", "0xfd", "0x6c", "0x15", "0xb2", "0xb8", "0xe6", "0x00"}}, - { - /* No.104 delta:909 weight:1351 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x9e28fdaf, 0xa1b52cd6, 0x3f9dd179, 0xb720068d, 0x2908fb22, 0x16952a5b, 0x88bdd7f4, 0x0000f73d, 0x9e280a92, 0xa1b5dbeb, 0x3f9d2644, 0xb720f1b0, 0x29080c1f, 0x1695dd66, 0x88bd20c9}, - [16]uint32{0x00000000, 0x00a718d2, 0x40620151, 0x40c51983, 0x04400086, 0x04e71854, 0x442201d7, 0x44851905, 0x21098019, 0x21ae98cb, 0x616b8148, 0x61cc999a, 0x2549809f, 0x25ee984d, 0x652b81ce, 0x658c991c}, - [16]uint32{0x3f800000, 0x3f80538c, 0x3fa03100, 0x3fa0628c, 0x3f822000, 0x3f82738c, 0x3fa21100, 0x3fa2428c, 0x3f9084c0, 0x3f90d74c, 0x3fb0b5c0, 0x3fb0e64c, 0x3f92a4c0, 0x3f92f74c, 0x3fb295c0, 0x3fb2c64c}, - uint32(0xfff80000), - [21]string{"0x15", "0x66", "0xae", "0x57", "0x60", "0x6c", "0xc6", "0x24", "0xbc", "0x0d", "0xc3", "0xd2", "0xf9", "0x60", "0xc8", "0x33", "0x56", "0x5b", "0x5c", "0x9e", "0x00"}}, - { - /* No.105 delta:1214 weight:1739 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x1881a49b, 0x3034feaa, 0x28b55a31, 0x9ba00692, 0x8321a209, 0xab94f838, 0xb3155ca3, 0x00008b7d, 0x18812fe6, 0x303475d7, 0x28b5d14c, 0x9ba08def, 0x83212974, 0xab947345, 0xb315d7de}, - [16]uint32{0x00000000, 0xa00c0172, 0x504021ff, 0xf04c208d, 0x6018048e, 0xc01405fc, 0x30582571, 0x90542403, 0x007840db, 0xa07441a9, 0x50386124, 0xf0346056, 0x60604455, 0xc06c4527, 0x302065aa, 0x902c64d8}, - [16]uint32{0x3f800000, 0x3fd00600, 0x3fa82010, 0x3ff82610, 0x3fb00c02, 0x3fe00a02, 0x3f982c12, 0x3fc82a12, 0x3f803c20, 0x3fd03a20, 0x3fa81c30, 0x3ff81a30, 0x3fb03022, 0x3fe03622, 0x3f981032, 0x3fc81632}, - uint32(0xfff80000), - [21]string{"0x3d", "0xee", "0x4f", "0xc8", "0x97", "0xc3", "0x5d", "0x81", "0xe2", "0xee", "0xd8", "0xfe", "0x39", "0x57", "0x22", "0xe1", "0x6b", "0x53", "0xef", "0x01", "0x00"}}, - { - /* No.106 delta:1179 weight:1561 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x24c5846f, 0x36a1a146, 0x12642529, 0xf43006ab, 0xd0f582c4, 0xc291a7ed, 0xe6542382, 0x0000698b, 0x24c5ede4, 0x36a1c8cd, 0x12644ca2, 0xf4306f20, 0xd0f5eb4f, 0xc291ce66, 0xe6544a09}, - [16]uint32{0x00000000, 0x0064ce12, 0x80389018, 0x805c5e0a, 0x10030803, 0x1067c611, 0x903b981b, 0x905f5609, 0x1000fc01, 0x10643213, 0x90386c19, 0x905ca20b, 0x0003f402, 0x00673a10, 0x803b641a, 0x805faa08}, - [16]uint32{0x3f800000, 0x3f803267, 0x3fc01c48, 0x3fc02e2f, 0x3f880184, 0x3f8833e3, 0x3fc81dcc, 0x3fc82fab, 0x3f88007e, 0x3f883219, 0x3fc81c36, 0x3fc82e51, 0x3f8001fa, 0x3f80339d, 0x3fc01db2, 0x3fc02fd5}, - uint32(0xfff80000), - [21]string{"0xb7", "0xa8", "0x13", "0x1a", "0x7b", "0xa0", "0xe7", "0x3f", "0x3d", "0xd3", "0x79", "0x84", "0x0c", "0x9e", "0xc3", "0xc7", "0xaf", "0xe4", "0xc5", "0x89", "0x00"}}, - { - /* No.107 delta:1739 weight:1481 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0xee4529e6, 0x874b1cc0, 0x690e3526, 0x976006bc, 0x79252f5a, 0x102b1a7c, 0xfe6e339a, 0x0000ad84, 0xee458462, 0x874bb144, 0x690e98a2, 0x9760ab38, 0x792582de, 0x102bb7f8, 0xfe6e9e1e}, - [16]uint32{0x00000000, 0x4064011d, 0x007e01ab, 0x401a00b6, 0x000201f3, 0x406600ee, 0x007c0058, 0x40180145, 0x0000013c, 0x40640021, 0x007e0097, 0x401a018a, 0x000200cf, 0x406601d2, 0x007c0164, 0x40180079}, - [16]uint32{0x3f800000, 0x3fa03200, 0x3f803f00, 0x3fa00d00, 0x3f800100, 0x3fa03300, 0x3f803e00, 0x3fa00c00, 0x3f800000, 0x3fa03200, 0x3f803f00, 0x3fa00d00, 0x3f800100, 0x3fa03300, 0x3f803e00, 0x3fa00c00}, - uint32(0xfff80000), - [21]string{"0x1d", "0x5d", "0x6c", "0x4c", "0xff", "0xe9", "0xda", "0x62", "0xb7", "0x42", "0xb0", "0x5c", "0x89", "0x06", "0x2f", "0x9e", "0xdd", "0xbd", "0x57", "0xb4", "0x00"}}, - { - /* No.108 delta:702 weight:1537 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xa61eb29f, 0xe4028f27, 0x421c3db8, 0xe31006c9, 0x450eb456, 0x071289ee, 0xa10c3b71, 0x000034cf, 0xa61e8650, 0xe402bbe8, 0x421c0977, 0xe3103206, 0x450e8099, 0x0712bd21, 0xa10c0fbe}, - [16]uint32{0x00000000, 0x306c40f5, 0x0052410e, 0x303e01fb, 0x10920342, 0x20fe43b7, 0x10c0424c, 0x20ac02b9, 0x200800c3, 0x10644036, 0x205a41cd, 0x10360138, 0x309a0381, 0x00f64374, 0x30c8428f, 0x00a4027a}, - [16]uint32{0x3f800000, 0x3f983620, 0x3f802920, 0x3f981f00, 0x3f884901, 0x3f907f21, 0x3f886021, 0x3f905601, 0x3f900400, 0x3f883220, 0x3f902d20, 0x3f881b00, 0x3f984d01, 0x3f807b21, 0x3f986421, 0x3f805201}, - uint32(0xfff80000), - [21]string{"0x4c", "0xe2", "0x2a", "0x1c", "0x8e", "0xad", "0xc1", "0x99", "0x25", "0xec", "0x54", "0xf7", "0x2f", "0x18", "0x4f", "0x98", "0xaa", "0xe2", "0x63", "0xaa", "0x00"}}, - { - /* No.109 delta:1143 weight:1537 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x4f009f44, 0xec9355d5, 0xa393ca91, 0xfc0006d8, 0xb300999c, 0x1093530d, 0x5f93cc49, 0x0000fd15, 0x4f006251, 0xec93a8c0, 0xa3933784, 0xfc00fbcd, 0xb3006489, 0x1093ae18, 0x5f93315c}, - [16]uint32{0x00000000, 0x400e1032, 0x00092919, 0x4007392b, 0x006c38a7, 0x40622895, 0x006511be, 0x406b018c, 0x4052e15f, 0x005cf16d, 0x405bc846, 0x0055d874, 0x403ed9f8, 0x0030c9ca, 0x4037f0e1, 0x0039e0d3}, - [16]uint32{0x3f800000, 0x3fa00708, 0x3f800494, 0x3fa0039c, 0x3f80361c, 0x3fa03114, 0x3f803288, 0x3fa03580, 0x3fa02970, 0x3f802e78, 0x3fa02de4, 0x3f802aec, 0x3fa01f6c, 0x3f801864, 0x3fa01bf8, 0x3f801cf0}, - uint32(0xfff80000), - [21]string{"0x15", "0xc6", "0x81", "0xbd", "0xc5", "0x3a", "0xd0", "0xc7", "0x24", "0xad", "0x87", "0x5f", "0x74", "0xa5", "0xb7", "0xc1", "0x6d", "0xc6", "0x85", "0xdc", "0x00"}}, - { - /* No.110 delta:910 weight:1209 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0xf914b93f, 0x23aeca7f, 0xdaba7340, 0x44e006e2, 0xbdf4bfdd, 0x674ecc9d, 0x9e5a75a2, 0x0000456f, 0xf914fc50, 0x23ae8f10, 0xdaba362f, 0x44e0438d, 0xbdf4fab2, 0x674e89f2, 0x9e5a30cd}, - [16]uint32{0x00000000, 0x406d91d2, 0x10023de6, 0x506fac34, 0x1000511a, 0x506dc0c8, 0x00026cfc, 0x406ffd2e, 0x40184c07, 0x0075ddd5, 0x501a71e1, 0x1077e033, 0x50181d1d, 0x10758ccf, 0x401a20fb, 0x0077b129}, - [16]uint32{0x3f800000, 0x3fa036c8, 0x3f88011e, 0x3fa837d6, 0x3f880028, 0x3fa836e0, 0x3f800136, 0x3fa037fe, 0x3fa00c26, 0x3f803aee, 0x3fa80d38, 0x3f883bf0, 0x3fa80c0e, 0x3f883ac6, 0x3fa00d10, 0x3f803bd8}, - uint32(0xfff80000), - [21]string{"0x83", "0x91", "0x1a", "0xa2", "0x3a", "0x01", "0xc4", "0x60", "0xfe", "0xfc", "0xd0", "0x70", "0x7b", "0xef", "0x38", "0x48", "0x8f", "0x98", "0xfa", "0x44", "0x00"}}, - { - /* No.111 delta:587 weight:1251 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0xec78402c, 0xf8d2123a, 0x14aa5216, 0xb61006ff, 0x5a6846d3, 0x4ec214c5, 0xa2ba54e9, 0x0000e95f, 0xec78a973, 0xf8d2fb65, 0x14aabb49, 0xb610efa0, 0x5a68af8c, 0x4ec2fd9a, 0xa2babdb6}, - [16]uint32{0x00000000, 0x40028d76, 0x50044a0b, 0x1006c77d, 0x6001c20f, 0x20034f79, 0x30058804, 0x70070572, 0x200065e7, 0x6002e891, 0x70042fec, 0x3006a29a, 0x4001a7e8, 0x00032a9e, 0x1005ede3, 0x50076095}, - [16]uint32{0x3f800000, 0x3fa00146, 0x3fa80225, 0x3f880363, 0x3fb000e1, 0x3f9001a7, 0x3f9802c4, 0x3fb80382, 0x3f900032, 0x3fb00174, 0x3fb80217, 0x3f980351, 0x3fa000d3, 0x3f800195, 0x3f8802f6, 0x3fa803b0}, - uint32(0xfff80000), - [21]string{"0x90", "0xec", "0x33", "0x35", "0xf4", "0x57", "0xba", "0x69", "0x2a", "0xd4", "0xb9", "0x92", "0x2f", "0xb6", "0x45", "0x3c", "0x1d", "0x82", "0xbc", "0xcc", "0x00"}}, - { - /* No.112 delta:733 weight:1123 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xf03b5e04, 0xfbe77025, 0x0bdc2e21, 0xec900702, 0x1cab5906, 0x17777727, 0xe74c2923, 0x00008094, 0xf03bde90, 0xfbe7f0b1, 0x0bdcaeb5, 0xec908796, 0x1cabd992, 0x1777f7b3, 0xe74ca9b7}, - [16]uint32{0x00000000, 0x406c0cf7, 0x50414e9a, 0x102d426d, 0x00401411, 0x402c18e6, 0x50015a8b, 0x106d567c, 0x60098402, 0x206588f5, 0x3048ca98, 0x7024c66f, 0x60499013, 0x20259ce4, 0x3008de89, 0x7064d27e}, - [16]uint32{0x3f800000, 0x3fa03606, 0x3fa820a7, 0x3f8816a1, 0x3f80200a, 0x3fa0160c, 0x3fa800ad, 0x3f8836ab, 0x3fb004c2, 0x3f9032c4, 0x3f982465, 0x3fb81263, 0x3fb024c8, 0x3f9012ce, 0x3f98046f, 0x3fb83269}, - uint32(0xfff80000), - [21]string{"0x21", "0xcc", "0x88", "0xfe", "0xbf", "0x09", "0xdb", "0xf4", "0xcc", "0xac", "0xb9", "0x48", "0xc6", "0x11", "0x42", "0x45", "0x08", "0xcf", "0x55", "0xf8", "0x00"}}, - { - /* No.113 delta:961 weight:1485 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0xf8e15148, 0xcf71a664, 0x3790f72c, 0x55a0071e, 0xad415656, 0x9ad1a17a, 0x6230f032, 0x00004daa, 0xf8e11ce2, 0xcf71ebce, 0x3790ba86, 0x55a04ab4, 0xad411bfc, 0x9ad1ecd0, 0x6230bd98}, - [16]uint32{0x00000000, 0x20142173, 0x50001eed, 0x70143f9e, 0x007e01db, 0x206a20a8, 0x507e1f36, 0x706a3e45, 0x00029019, 0x2016b16a, 0x50028ef4, 0x7016af87, 0x007c91c2, 0x2068b0b1, 0x507c8f2f, 0x7068ae5c}, - [16]uint32{0x3f800000, 0x3f900a10, 0x3fa8000f, 0x3fb80a1f, 0x3f803f00, 0x3f903510, 0x3fa83f0f, 0x3fb8351f, 0x3f800148, 0x3f900b58, 0x3fa80147, 0x3fb80b57, 0x3f803e48, 0x3f903458, 0x3fa83e47, 0x3fb83457}, - uint32(0xfff80000), - [21]string{"0x9f", "0xa0", "0xe0", "0xda", "0x23", "0xbf", "0xa1", "0xb7", "0xb0", "0xeb", "0x5d", "0xf4", "0x6e", "0xcb", "0xa1", "0x43", "0xf7", "0x9b", "0x0e", "0x6c", "0x00"}}, - { - /* No.114 delta:1259 weight:1687 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0x3f45045b, 0x4e9e0af7, 0x71db0eac, 0x6140072d, 0x5e050376, 0x2fde0dda, 0x109b0981, 0x0000e7b0, 0x3f45e3eb, 0x4e9eed47, 0x71dbe91c, 0x6140e09d, 0x5e05e4c6, 0x2fdeea6a, 0x109bee31}, - [16]uint32{0x00000000, 0x300c059a, 0x405e408f, 0x70524515, 0x20285cdc, 0x10245946, 0x60761c53, 0x507a19c9, 0x24482218, 0x14442782, 0x64166297, 0x541a670d, 0x04607ec4, 0x346c7b5e, 0x443e3e4b, 0x74323bd1}, - [16]uint32{0x3f800000, 0x3f980602, 0x3fa02f20, 0x3fb82922, 0x3f90142e, 0x3f88122c, 0x3fb03b0e, 0x3fa83d0c, 0x3f922411, 0x3f8a2213, 0x3fb20b31, 0x3faa0d33, 0x3f82303f, 0x3f9a363d, 0x3fa21f1f, 0x3fba191d}, - uint32(0xfff80000), - [21]string{"0xf4", "0x32", "0x1b", "0x7a", "0xe6", "0x66", "0x05", "0xfc", "0x41", "0xb9", "0x19", "0x2a", "0x8f", "0xba", "0x14", "0xbe", "0x8d", "0x4f", "0xd4", "0x55", "0x00"}}, - { - /* No.115 delta:1749 weight:1509 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0xc9a19456, 0xd71166f0, 0x1eb0f2a6, 0xdd60073e, 0x14c19368, 0x0a7161ce, 0xc3d0f598, 0x00002adc, 0xc9a1be8a, 0xd7114c2c, 0x1eb0d87a, 0xdd602de2, 0x14c1b9b4, 0x0a714b12, 0xc3d0df44}, - [16]uint32{0x00000000, 0x42ac41fb, 0x1080a407, 0x522ce5fc, 0x08448816, 0x4ae8c9ed, 0x18c42c11, 0x5a686dea, 0x20600822, 0x62cc49d9, 0x30e0ac25, 0x724cedde, 0x28248034, 0x6a88c1cf, 0x38a42433, 0x7a0865c8}, - [16]uint32{0x3f800000, 0x3fa15620, 0x3f884052, 0x3fa91672, 0x3f842244, 0x3fa57464, 0x3f8c6216, 0x3fad3436, 0x3f903004, 0x3fb16624, 0x3f987056, 0x3fb92676, 0x3f941240, 0x3fb54460, 0x3f9c5212, 0x3fbd0432}, - uint32(0xfff80000), - [21]string{"0x45", "0xb5", "0x72", "0x39", "0xb8", "0xc6", "0x3e", "0xc7", "0x26", "0xde", "0x33", "0xeb", "0xc0", "0xc2", "0x54", "0xfa", "0x37", "0x18", "0x9c", "0xc9", "0x00"}}, - { - /* No.116 delta:881 weight:973 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x43507563, 0x0a62d22e, 0x4932a74d, 0xc2b00743, 0x81e07220, 0xc8d2d56d, 0x8b82a00e, 0x0000b615, 0x4350c376, 0x0a62643b, 0x49321158, 0xc2b0b156, 0x81e0c435, 0xc8d26378, 0x8b82161b}, - [16]uint32{0x00000000, 0x4000989f, 0x0803e4ee, 0x48037c71, 0x0021cc48, 0x402154d7, 0x082228a6, 0x4822b039, 0x20023124, 0x6002a9bb, 0x2801d5ca, 0x68014d55, 0x2023fd6c, 0x602365f3, 0x28201982, 0x6820811d}, - [16]uint32{0x3f800000, 0x3fa0004c, 0x3f8401f2, 0x3fa401be, 0x3f8010e6, 0x3fa010aa, 0x3f841114, 0x3fa41158, 0x3f900118, 0x3fb00154, 0x3f9400ea, 0x3fb400a6, 0x3f9011fe, 0x3fb011b2, 0x3f94100c, 0x3fb41040}, - uint32(0xfff80000), - [21]string{"0x36", "0x5e", "0x9b", "0x40", "0x8b", "0x86", "0xee", "0x44", "0xd5", "0x89", "0xa1", "0x27", "0x1e", "0xb0", "0x35", "0x38", "0x90", "0x44", "0xf0", "0x85", "0x00"}}, - { - /* No.117 delta:1063 weight:1401 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0xf3e49888, 0x5ca452bc, 0xaf40ca34, 0xb9300752, 0x4ad49fda, 0xe59455ee, 0x1670cd66, 0x00008d1b, 0xf3e41593, 0x5ca4dfa7, 0xaf40472f, 0xb9308a49, 0x4ad412c1, 0xe594d8f5, 0x1670407d}, - [16]uint32{0x00000000, 0x800249d4, 0x10814a9e, 0x9083034a, 0x10201192, 0x90225846, 0x00a15b0c, 0x80a312d8, 0x6001201d, 0xe00369c9, 0x70806a83, 0xf0822357, 0x7021318f, 0xf023785b, 0x60a07b11, 0xe0a232c5}, - [16]uint32{0x3f800000, 0x3fc00124, 0x3f8840a5, 0x3fc84181, 0x3f881008, 0x3fc8112c, 0x3f8050ad, 0x3fc05189, 0x3fb00090, 0x3ff001b4, 0x3fb84035, 0x3ff84111, 0x3fb81098, 0x3ff811bc, 0x3fb0503d, 0x3ff05119}, - uint32(0xfff80000), - [21]string{"0x60", "0xed", "0xc6", "0xf3", "0xc6", "0x80", "0xb1", "0x3b", "0xc1", "0x64", "0x78", "0x4b", "0x3f", "0x63", "0xbd", "0x7b", "0xc4", "0x0c", "0xd9", "0x39", "0x00"}}, - { - /* No.118 delta:1137 weight:1497 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x71930aea, 0x570aa1e5, 0x2699ab0f, 0xcc600761, 0xbdf30d8b, 0x9b6aa684, 0xeaf9ac6e, 0x00005787, 0x71935d6d, 0x570af662, 0x2699fc88, 0xcc6050e6, 0xbdf35a0c, 0x9b6af103, 0xeaf9fbe9}, - [16]uint32{0x00000000, 0x0045283e, 0x00010852, 0x0044206c, 0x102c0195, 0x106929ab, 0x102d09c7, 0x106821f9, 0x0000441f, 0x00456c21, 0x00014c4d, 0x00446473, 0x102c458a, 0x10696db4, 0x102d4dd8, 0x106865e6}, - [16]uint32{0x3f800000, 0x3f802294, 0x3f800084, 0x3f802210, 0x3f881600, 0x3f883494, 0x3f881684, 0x3f883410, 0x3f800022, 0x3f8022b6, 0x3f8000a6, 0x3f802232, 0x3f881622, 0x3f8834b6, 0x3f8816a6, 0x3f883432}, - uint32(0xfff80000), - [21]string{"0x3f", "0x85", "0x79", "0x0e", "0x9f", "0xcf", "0x7a", "0xf1", "0x61", "0x7a", "0x2f", "0x3e", "0x53", "0x2c", "0xba", "0x5f", "0x95", "0x72", "0xb1", "0xaf", "0x00"}}, - { - /* No.119 delta:2081 weight:1319 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x5de13e8c, 0xaf27000d, 0xf2c63e81, 0xe4c00772, 0xb92139fe, 0x4be7077f, 0x160639f3, 0x0000339b, 0x5de10d17, 0xaf273396, 0xf2c60d1a, 0xe4c034e9, 0xb9210a65, 0x4be734e4, 0x16060a68}, - [16]uint32{0x00000000, 0x0cfc0054, 0x0a801c7b, 0x067c1c2f, 0x06b26091, 0x0a4e60c5, 0x0c327cea, 0x00ce7cbe, 0x06038017, 0x0aff8043, 0x0c839c6c, 0x007f9c38, 0x00b1e086, 0x0c4de0d2, 0x0a31fcfd, 0x06cdfca9}, - [16]uint32{0x3f800000, 0x3f867e00, 0x3f85400e, 0x3f833e0e, 0x3f835930, 0x3f852730, 0x3f86193e, 0x3f80673e, 0x3f8301c0, 0x3f857fc0, 0x3f8641ce, 0x3f803fce, 0x3f8058f0, 0x3f8626f0, 0x3f8518fe, 0x3f8366fe}, - uint32(0xfff80000), - [21]string{"0x0d", "0x39", "0xf3", "0x78", "0x89", "0x68", "0xeb", "0xd5", "0x15", "0x9f", "0x5c", "0x20", "0xc1", "0x91", "0x35", "0xe8", "0x14", "0x9a", "0x0a", "0x34", "0x00"}}, - { - /* No.120 delta:938 weight:1729 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x5ad5c7fc, 0x50877aee, 0x0a52bd12, 0x0f400787, 0x5595c07b, 0x5fc77d69, 0x0512ba95, 0x0000b61e, 0x5ad571e2, 0x5087ccf0, 0x0a520b0c, 0x0f40b199, 0x55957665, 0x5fc7cb77, 0x05120c8b}, - [16]uint32{0x00000000, 0x00234632, 0x000208b7, 0x00214e85, 0x206c297e, 0x204f6f4c, 0x206e21c9, 0x204d67fb, 0x90145093, 0x903716a1, 0x90165824, 0x90351e16, 0xb07879ed, 0xb05b3fdf, 0xb07a715a, 0xb0593768}, - [16]uint32{0x3f800000, 0x3f8011a3, 0x3f800104, 0x3f8010a7, 0x3f903614, 0x3f9027b7, 0x3f903710, 0x3f9026b3, 0x3fc80a28, 0x3fc81b8b, 0x3fc80b2c, 0x3fc81a8f, 0x3fd83c3c, 0x3fd82d9f, 0x3fd83d38, 0x3fd82c9b}, - uint32(0xfff80000), - [21]string{"0x53", "0x85", "0x3f", "0x41", "0x21", "0x4b", "0x43", "0x04", "0x88", "0x1d", "0x85", "0xcd", "0x7c", "0xf6", "0x24", "0x1b", "0x9b", "0x62", "0xb7", "0xbc", "0x00"}}, - { - /* No.121 delta:1254 weight:1595 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xf4721b6f, 0x38780238, 0xcc0a1957, 0x0a800791, 0xfef21cfe, 0x32f805a9, 0xc68a1ec6, 0x00008e00, 0xf472956f, 0x38788c38, 0xcc0a9757, 0x0a808991, 0xfef292fe, 0x32f88ba9, 0xc68a90c6}, - [16]uint32{0x00000000, 0x105500de, 0x504089f2, 0x4015892c, 0x2010110b, 0x304511d5, 0x705098f9, 0x60059827, 0x00644410, 0x103144ce, 0x5024cde2, 0x4071cd3c, 0x2074551b, 0x302155c5, 0x7034dce9, 0x6061dc37}, - [16]uint32{0x3f800000, 0x3f882a80, 0x3fa82044, 0x3fa00ac4, 0x3f900808, 0x3f982288, 0x3fb8284c, 0x3fb002cc, 0x3f803222, 0x3f8818a2, 0x3fa81266, 0x3fa038e6, 0x3f903a2a, 0x3f9810aa, 0x3fb81a6e, 0x3fb030ee}, - uint32(0xfff80000), - [21]string{"0x25", "0xb4", "0x83", "0xd2", "0x14", "0x30", "0xa0", "0x57", "0x76", "0x91", "0x93", "0x5e", "0x6b", "0x3a", "0x16", "0x61", "0x4b", "0x33", "0xd7", "0x9d", "0x00"}}, - { - /* No.122 delta:2273 weight:1235 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x687364d2, 0xba9856f7, 0xd2eb3225, 0x654007a9, 0x0d33637b, 0xdfd8515e, 0xb7ab358c, 0x00009222, 0x6873f6f0, 0xba98c4d5, 0xd2eba007, 0x6540958b, 0x0d33f159, 0xdfd8c37c, 0xb7aba7ae}, - [16]uint32{0x00000000, 0x247a41dc, 0x3b8c83a3, 0x1ff6c27f, 0x804ca051, 0xa436e18d, 0xbbc023f2, 0x9fba622e, 0x29340c18, 0x0d4e4dc4, 0x12b88fbb, 0x36c2ce67, 0xa978ac49, 0x8d02ed95, 0x92f42fea, 0xb68e6e36}, - [16]uint32{0x3f800000, 0x3f923d20, 0x3f9dc641, 0x3f8ffb61, 0x3fc02650, 0x3fd21b70, 0x3fdde011, 0x3fcfdd31, 0x3f949a06, 0x3f86a726, 0x3f895c47, 0x3f9b6167, 0x3fd4bc56, 0x3fc68176, 0x3fc97a17, 0x3fdb4737}, - uint32(0xfff80000), - [21]string{"0x16", "0xe5", "0x70", "0x73", "0xbe", "0x32", "0xee", "0x39", "0x6b", "0x15", "0xd3", "0x8f", "0xfb", "0xb6", "0xa5", "0x64", "0xa6", "0x28", "0x10", "0x42", "0x00"}}, - { - /* No.123 delta:887 weight:1675 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x9ffafe84, 0x081afe71, 0x97e000f5, 0xb02007bf, 0x2fdaf93b, 0xb83af9ce, 0x27c0074a, 0x000053a9, 0x9ffaad2d, 0x081aadd8, 0x97e0535c, 0xb0205416, 0x2fdaaa92, 0xb83aaa67, 0x27c054e3}, - [16]uint32{0x00000000, 0x5024f876, 0x4002e819, 0x1026106f, 0x00020174, 0x5026f902, 0x4000e96d, 0x1024111b, 0x008101f0, 0x50a5f986, 0x4083e9e9, 0x10a7119f, 0x00830084, 0x50a7f8f2, 0x4081e89d, 0x10a510eb}, - [16]uint32{0x3f800000, 0x3fa8127c, 0x3fa00174, 0x3f881308, 0x3f800100, 0x3fa8137c, 0x3fa00074, 0x3f881208, 0x3f804080, 0x3fa852fc, 0x3fa041f4, 0x3f885388, 0x3f804180, 0x3fa853fc, 0x3fa040f4, 0x3f885288}, - uint32(0xfff80000), - [21]string{"0xf7", "0xea", "0x73", "0x84", "0x56", "0x0b", "0xb3", "0x0b", "0x8a", "0x6d", "0x5f", "0xd0", "0xca", "0xd9", "0x28", "0x47", "0x7c", "0x3a", "0x53", "0xfa", "0x00"}}, - { - /* No.124 delta:667 weight:1687 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xbed9237e, 0xe52a7947, 0x5bf35a39, 0x730007cd, 0xcdd924b3, 0x962a7e8a, 0x28f35df4, 0x0000f310, 0xbed9d06e, 0xe52a8a57, 0x5bf3a929, 0x7300f4dd, 0xcdd9d7a3, 0x962a8d9a, 0x28f3aee4}, - [16]uint32{0x00000000, 0x00020dde, 0x2000c18a, 0x2002cc54, 0x5040601b, 0x50426dc5, 0x7040a191, 0x7042ac4f, 0x600c200d, 0x600e2dd3, 0x400ce187, 0x400eec59, 0x304c4016, 0x304e4dc8, 0x104c819c, 0x104e8c42}, - [16]uint32{0x3f800000, 0x3f800106, 0x3f900060, 0x3f900166, 0x3fa82030, 0x3fa82136, 0x3fb82050, 0x3fb82156, 0x3fb00610, 0x3fb00716, 0x3fa00670, 0x3fa00776, 0x3f982620, 0x3f982726, 0x3f882640, 0x3f882746}, - uint32(0xfff80000), - [21]string{"0x03", "0x26", "0x66", "0x84", "0x6a", "0xdf", "0x3c", "0x27", "0x3e", "0xa5", "0x4e", "0x5a", "0x89", "0x62", "0x3c", "0x64", "0xa4", "0x63", "0x62", "0x6c", "0x00"}}, - { - /* No.125 delta:3095 weight:631 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xaf97f659, 0xe63edaa4, 0x49a92cfd, 0x1cd007d8, 0xb347f181, 0xfaeedd7c, 0x55792b25, 0x0000f83b, 0xaf970e62, 0xe63e229f, 0x49a9d4c6, 0x1cd0ffe3, 0xb34709ba, 0xfaee2547, 0x5579d31e}, - [16]uint32{0x00000000, 0x80348027, 0x8830479e, 0x0804c7b9, 0xeb8801ec, 0x6bbc81cb, 0x63b84672, 0xe38cc655, 0x0fd8801a, 0x8fec003d, 0x87e8c784, 0x07dc47a3, 0xe45081f6, 0x646401d1, 0x6c60c668, 0xec54464f}, - [16]uint32{0x3f800000, 0x3fc01a40, 0x3fc41823, 0x3f840263, 0x3ff5c400, 0x3fb5de40, 0x3fb1dc23, 0x3ff1c663, 0x3f87ec40, 0x3fc7f600, 0x3fc3f463, 0x3f83ee23, 0x3ff22840, 0x3fb23200, 0x3fb63063, 0x3ff62a23}, - uint32(0xfff80000), - [21]string{"0xb5", "0xd4", "0xc7", "0xbc", "0x65", "0xb7", "0x30", "0x68", "0x6a", "0x83", "0x03", "0x7c", "0x40", "0x97", "0x66", "0x5c", "0x4c", "0x77", "0xf7", "0x13", "0x00"}}, - { - /* No.126 delta:1826 weight:1491 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0xbb3fabf7, 0xc77376e1, 0x7c4cdd16, 0x220007e0, 0x993fac17, 0xe5737101, 0x5e4cdaf6, 0x0000b280, 0xbb3f1977, 0xc773c461, 0x7c4c6f96, 0x2200b560, 0x993f1e97, 0xe573c381, 0x5e4c6876}, - [16]uint32{0x00000000, 0x48e1e99a, 0x046541af, 0x4c84a835, 0x008f02c4, 0x486eeb5e, 0x04ea436b, 0x4c0baaf1, 0x40a23019, 0x0843d983, 0x44c771b6, 0x0c26982c, 0x402d32dd, 0x08ccdb47, 0x44487372, 0x0ca99ae8}, - [16]uint32{0x3f800000, 0x3fa470f4, 0x3f8232a0, 0x3fa64254, 0x3f804781, 0x3fa43775, 0x3f827521, 0x3fa605d5, 0x3fa05118, 0x3f8421ec, 0x3fa263b8, 0x3f86134c, 0x3fa01699, 0x3f84666d, 0x3fa22439, 0x3f8654cd}, - uint32(0xfff80000), - [21]string{"0x84", "0x07", "0xf5", "0x68", "0xec", "0x9b", "0xa3", "0xb0", "0x2b", "0x79", "0x21", "0x0e", "0xc5", "0x1e", "0xa0", "0xdf", "0x36", "0x4e", "0x70", "0xcf", "0x00"}}, - { - /* No.127 delta:977 weight:1317 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x63f0c30e, 0x083a1093, 0x6bcad39d, 0x104007f8, 0x73b0c4f6, 0x187a176b, 0x7b8ad465, 0x0000dfbf, 0x63f01cb1, 0x083acf2c, 0x6bca0c22, 0x1040d847, 0x73b01b49, 0x187ac8d4, 0x7b8a0bda}, - [16]uint32{0x00000000, 0x00463d7e, 0x4001620d, 0x40475f73, 0x34006019, 0x34465d67, 0x74010214, 0x74473f6a, 0x61002826, 0x61461558, 0x21014a2b, 0x21477755, 0x5500483f, 0x55467541, 0x15012a32, 0x1547174c}, - [16]uint32{0x3f800000, 0x3f80231e, 0x3fa000b1, 0x3fa023af, 0x3f9a0030, 0x3f9a232e, 0x3fba0081, 0x3fba239f, 0x3fb08014, 0x3fb0a30a, 0x3f9080a5, 0x3f90a3bb, 0x3faa8024, 0x3faaa33a, 0x3f8a8095, 0x3f8aa38b}, - uint32(0xfff80000), - [21]string{"0x7b", "0x49", "0x48", "0xac", "0x0e", "0x29", "0x12", "0xd6", "0xb9", "0x98", "0xe4", "0x38", "0x8b", "0x47", "0x4f", "0x4b", "0x6d", "0xa3", "0x6b", "0x2d", "0x00"}}, - { - /* No.128 delta:691 weight:1641 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x5473c0b0, 0x0f5cfd3e, 0x5b2f3d8e, 0x2c20080c, 0x7853c8bc, 0x237cf532, 0x770f3582, 0x0000cc52, 0x54730ce2, 0x0f5c316c, 0x5b2ff1dc, 0x2c20c45e, 0x785304ee, 0x237c3960, 0x770ff9d0}, - [16]uint32{0x00000000, 0x404c8097, 0x00037003, 0x404ff094, 0x100805ca, 0x5044855d, 0x100b75c9, 0x5047f55e, 0x4000113c, 0x004c91ab, 0x4003613f, 0x004fe1a8, 0x500814f6, 0x10449461, 0x500b64f5, 0x1047e462}, - [16]uint32{0x3f800000, 0x3fa02640, 0x3f8001b8, 0x3fa027f8, 0x3f880402, 0x3fa82242, 0x3f8805ba, 0x3fa823fa, 0x3fa00008, 0x3f802648, 0x3fa001b0, 0x3f8027f0, 0x3fa8040a, 0x3f88224a, 0x3fa805b2, 0x3f8823f2}, - uint32(0xfff80000), - [21]string{"0x0c", "0x35", "0x0e", "0x67", "0x61", "0x0d", "0xf3", "0xdc", "0xd8", "0x29", "0x50", "0xe8", "0xaf", "0xff", "0x6f", "0x88", "0xcf", "0xa3", "0x3e", "0xfa", "0x00"}}, - { - /* No.129 delta:1085 weight:1313 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0xda085890, 0x01457dcf, 0xdb4d255f, 0x46f0081a, 0x9cf8508a, 0x47b575d5, 0x9dbd2d45, 0x00000630, 0xda085ea0, 0x01457bff, 0xdb4d236f, 0x46f00e2a, 0x9cf856ba, 0x47b573e5, 0x9dbd2b75}, - [16]uint32{0x00000000, 0x102499ba, 0x007c0406, 0x10589dbc, 0x00021107, 0x102688bd, 0x007e1501, 0x105a8cbb, 0xe08e4133, 0xf0aad889, 0xe0f24535, 0xf0d6dc8f, 0xe08c5034, 0xf0a8c98e, 0xe0f05432, 0xf0d4cd88}, - [16]uint32{0x3f800000, 0x3f88124c, 0x3f803e02, 0x3f882c4e, 0x3f800108, 0x3f881344, 0x3f803f0a, 0x3f882d46, 0x3ff04720, 0x3ff8556c, 0x3ff07922, 0x3ff86b6e, 0x3ff04628, 0x3ff85464, 0x3ff0782a, 0x3ff86a66}, - uint32(0xfff80000), - [21]string{"0xc2", "0xbe", "0xfc", "0xa1", "0xa9", "0xa7", "0xe1", "0x8c", "0x54", "0x80", "0x2f", "0x61", "0x16", "0xca", "0x97", "0x26", "0xb0", "0x77", "0xd4", "0xcf", "0x00"}}, - { - /* No.130 delta:1766 weight:1661 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0x7a7a5fa4, 0xa616acc6, 0xdc6cf362, 0xff400828, 0x853a578c, 0x5956a4ee, 0x232cfb4a, 0x000071f3, 0x7a7a2e57, 0xa616dd35, 0xdc6c8291, 0xff4079db, 0x853a267f, 0x5956d51d, 0x232c8ab9}, - [16]uint32{0x00000000, 0x866528b2, 0x0c7020fd, 0x8a15084f, 0x004361a9, 0x8626491b, 0x0c334154, 0x8a5669e6, 0x02018121, 0x8464a993, 0x0e71a1dc, 0x8814896e, 0x0242e088, 0x8427c83a, 0x0e32c075, 0x8857e8c7}, - [16]uint32{0x3f800000, 0x3fc33294, 0x3f863810, 0x3fc50a84, 0x3f8021b0, 0x3fc31324, 0x3f8619a0, 0x3fc52b34, 0x3f8100c0, 0x3fc23254, 0x3f8738d0, 0x3fc40a44, 0x3f812170, 0x3fc213e4, 0x3f871960, 0x3fc42bf4}, - uint32(0xfff80000), - [21]string{"0x24", "0x7e", "0x0d", "0x64", "0xeb", "0x06", "0x35", "0x8c", "0x85", "0xd0", "0xa6", "0x24", "0x9f", "0xeb", "0x93", "0x0b", "0xb5", "0x7a", "0x20", "0xa7", "0x00"}}, - { - /* No.131 delta:704 weight:1621 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0x3e922477, 0x359f388b, 0x0b0d1cfc, 0x17a00835, 0x29322c42, 0x223f30be, 0x1cad14c9, 0x00001efd, 0x3e923a8a, 0x359f2676, 0x0b0d0201, 0x17a016c8, 0x293232bf, 0x223f2e43, 0x1cad0a34}, - [16]uint32{0x00000000, 0x4c650012, 0x022da0e3, 0x4e48a0f1, 0x0044102f, 0x4c21103d, 0x0269b0cc, 0x4e0cb0de, 0x0020fdb5, 0x4c45fda7, 0x020d5d56, 0x4e685d44, 0x0064ed9a, 0x4c01ed88, 0x02494d79, 0x4e2c4d6b}, - [16]uint32{0x3f800000, 0x3fa63280, 0x3f8116d0, 0x3fa72450, 0x3f802208, 0x3fa61088, 0x3f8134d8, 0x3fa70658, 0x3f80107e, 0x3fa622fe, 0x3f8106ae, 0x3fa7342e, 0x3f803276, 0x3fa600f6, 0x3f8124a6, 0x3fa71626}, - uint32(0xfff80000), - [21]string{"0xc3", "0x01", "0xf9", "0xeb", "0xa0", "0x0a", "0xd9", "0x04", "0x35", "0x26", "0x4e", "0xeb", "0xe1", "0xa6", "0xf4", "0x6b", "0x3e", "0xe2", "0x63", "0x5c", "0x00"}}, - { - /* No.132 delta:945 weight:1681 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0x1b464ade, 0x87a5d98b, 0x9ce39355, 0xda700843, 0xc136429d, 0x5dd5d1c8, 0x46939b16, 0x00004dfa, 0x1b460724, 0x87a59471, 0x9ce3deaf, 0xda7045b9, 0xc1360f67, 0x5dd59c32, 0x4693d6ec}, - [16]uint32{0x00000000, 0x204d093a, 0x50022059, 0x704f2963, 0x303049ad, 0x107d4097, 0x603269f4, 0x407f60ce, 0x5001088b, 0x704c01b1, 0x000328d2, 0x204e21e8, 0x60314126, 0x407c481c, 0x3033617f, 0x107e6845}, - [16]uint32{0x3f800000, 0x3f902684, 0x3fa80110, 0x3fb82794, 0x3f981824, 0x3f883ea0, 0x3fb01934, 0x3fa03fb0, 0x3fa80084, 0x3fb82600, 0x3f800194, 0x3f902710, 0x3fb018a0, 0x3fa03e24, 0x3f9819b0, 0x3f883f34}, - uint32(0xfff80000), - [21]string{"0xb4", "0x6d", "0xa1", "0xb3", "0x8f", "0xe5", "0x1b", "0xa2", "0x02", "0xc6", "0xab", "0xb1", "0x90", "0x5e", "0x18", "0x29", "0x79", "0x33", "0xeb", "0x3b", "0x00"}}, - { - /* No.133 delta:1586 weight:1619 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0xe767c596, 0x5528e484, 0xb24f2112, 0x9a800850, 0x7de7cdc6, 0xcfa8ecd4, 0x28cf2942, 0x00007135, 0xe767b4a3, 0x552895b1, 0xb24f5027, 0x9a807965, 0x7de7bcf3, 0xcfa89de1, 0x28cf5877}, - [16]uint32{0x00000000, 0x099010de, 0x2784a18b, 0x2e14b155, 0x140a4876, 0x1d9a58a8, 0x338ee9fd, 0x3a1ef923, 0x006a207a, 0x09fa30a4, 0x27ee81f1, 0x2e7e912f, 0x1460680c, 0x1df078d2, 0x33e4c987, 0x3a74d959}, - [16]uint32{0x3f800000, 0x3f84c808, 0x3f93c250, 0x3f970a58, 0x3f8a0524, 0x3f8ecd2c, 0x3f99c774, 0x3f9d0f7c, 0x3f803510, 0x3f84fd18, 0x3f93f740, 0x3f973f48, 0x3f8a3034, 0x3f8ef83c, 0x3f99f264, 0x3f9d3a6c}, - uint32(0xfff80000), - [21]string{"0x88", "0x24", "0x80", "0xd9", "0xf7", "0x5d", "0x33", "0x6e", "0x29", "0x40", "0x2a", "0xbe", "0x1c", "0x91", "0x53", "0x7d", "0xcf", "0x99", "0xa8", "0x74", "0x00"}}, - { - /* No.134 delta:607 weight:1541 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0xb1f1c8f6, 0x117327cd, 0xa082ef3b, 0xd5c00860, 0x6431c096, 0xc4b32fad, 0x7542e75b, 0x00008802, 0xb1f140f4, 0x1173afcf, 0xa0826739, 0xd5c08062, 0x64314894, 0xc4b3a7af, 0x75426f59}, - [16]uint32{0x00000000, 0x0020701f, 0x205cd976, 0x207ca969, 0x4000c018, 0x4020b007, 0x605c196e, 0x607c6971, 0x00401c1c, 0x00606c03, 0x201cc56a, 0x203cb575, 0x4040dc04, 0x4060ac1b, 0x601c0572, 0x603c756d}, - [16]uint32{0x3f800000, 0x3f801038, 0x3f902e6c, 0x3f903e54, 0x3fa00060, 0x3fa01058, 0x3fb02e0c, 0x3fb03e34, 0x3f80200e, 0x3f803036, 0x3f900e62, 0x3f901e5a, 0x3fa0206e, 0x3fa03056, 0x3fb00e02, 0x3fb01e3a}, - uint32(0xfff80000), - [21]string{"0xff", "0x78", "0x00", "0xdd", "0xe1", "0xe1", "0xcb", "0x7d", "0xfb", "0x5a", "0xbf", "0x61", "0xcc", "0x53", "0xae", "0xf9", "0xbb", "0x22", "0x95", "0x3d", "0x00"}}, - { - /* No.135 delta:1216 weight:1481 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x2efc7b65, 0xd5ed2bc8, 0xfb1150ad, 0xff90087c, 0xd16c7319, 0x2a7d23b4, 0x048158d1, 0x000011a9, 0x2efc6acc, 0xd5ed3a61, 0xfb114104, 0xff9019d5, 0xd16c62b0, 0x2a7d321d, 0x04814978}, - [16]uint32{0x00000000, 0x30022096, 0x10040ddf, 0x20062d49, 0x10008108, 0x2002a19e, 0x00048cd7, 0x3006ac41, 0x60184015, 0x501a6083, 0x701c4dca, 0x401e6d5c, 0x7018c11d, 0x401ae18b, 0x601cccc2, 0x501eec54}, - [16]uint32{0x3f800000, 0x3f980110, 0x3f880206, 0x3f900316, 0x3f880040, 0x3f900150, 0x3f800246, 0x3f980356, 0x3fb00c20, 0x3fa80d30, 0x3fb80e26, 0x3fa00f36, 0x3fb80c60, 0x3fa00d70, 0x3fb00e66, 0x3fa80f76}, - uint32(0xfff80000), - [21]string{"0x5b", "0x58", "0xff", "0x3f", "0x25", "0x71", "0x1b", "0x41", "0xf4", "0xac", "0xf6", "0xd0", "0x44", "0xdd", "0x3d", "0x65", "0xb9", "0x91", "0xb3", "0x64", "0x00"}}, - { - /* No.136 delta:915 weight:1245 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xf6ee1897, 0x8bd48878, 0x7d3a90ef, 0x4e20088a, 0xb8ce101d, 0xc5f480f2, 0x331a9865, 0x0000ef87, 0xf6eef710, 0x8bd467ff, 0x7d3a7f68, 0x4e20e70d, 0xb8ceff9a, 0xc5f46f75, 0x331a77e2}, - [16]uint32{0x00000000, 0x00123032, 0x4004005e, 0x4016306c, 0x10012419, 0x1013142b, 0x50052447, 0x50171475, 0x2020f01c, 0x2032c02e, 0x6024f042, 0x6036c070, 0x3021d405, 0x3033e437, 0x7025d45b, 0x7037e469}, - [16]uint32{0x3f800000, 0x3f800918, 0x3fa00200, 0x3fa00b18, 0x3f880092, 0x3f88098a, 0x3fa80292, 0x3fa80b8a, 0x3f901078, 0x3f901960, 0x3fb01278, 0x3fb01b60, 0x3f9810ea, 0x3f9819f2, 0x3fb812ea, 0x3fb81bf2}, - uint32(0xfff80000), - [21]string{"0xd0", "0x2f", "0xaa", "0xb2", "0x0e", "0xf8", "0x08", "0x6a", "0x9a", "0xa7", "0xc7", "0xdb", "0xc7", "0x2a", "0x01", "0x6d", "0xba", "0x24", "0x6f", "0xc6", "0x00"}}, - { - /* No.137 delta:1408 weight:1561 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0x58bdda30, 0x08dab14b, 0x50676b7b, 0xff20089e, 0xa79dd2ae, 0xf7fab9d5, 0xaf4763e5, 0x0000596d, 0x58bd835d, 0x08dae826, 0x50673216, 0xff2051f3, 0xa79d8bc3, 0xf7fae0b8, 0xaf473a88}, - [16]uint32{0x00000000, 0x0054247e, 0x10139d12, 0x1047b96c, 0x60482015, 0x601c046b, 0x705bbd07, 0x700f9979, 0x201f890a, 0x204bad74, 0x300c1418, 0x30583066, 0x4057a91f, 0x40038d61, 0x5044340d, 0x50101073}, - [16]uint32{0x3f800000, 0x3f802a12, 0x3f8809ce, 0x3f8823dc, 0x3fb02410, 0x3fb00e02, 0x3fb82dde, 0x3fb807cc, 0x3f900fc4, 0x3f9025d6, 0x3f98060a, 0x3f982c18, 0x3fa02bd4, 0x3fa001c6, 0x3fa8221a, 0x3fa80808}, - uint32(0xfff80000), - [21]string{"0xc2", "0x03", "0x9f", "0xf3", "0xff", "0x15", "0xdc", "0x23", "0x3b", "0x01", "0xbe", "0x8f", "0x1d", "0x7a", "0x00", "0xfd", "0xcd", "0x06", "0xea", "0xd1", "0x00"}}, - { - /* No.138 delta:1148 weight:1595 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0xd2c7bfa4, 0xbdd43421, 0x6f138b85, 0x169008a8, 0xc457b70c, 0xab443c89, 0x7983832d, 0x0000d08f, 0xd2c76f2b, 0xbdd4e4ae, 0x6f135b0a, 0x1690d827, 0xc4576783, 0xab44ec06, 0x798353a2}, - [16]uint32{0x00000000, 0x101f7156, 0x00274394, 0x103832c2, 0x004ec0fc, 0x1051b1aa, 0x00698368, 0x1076f23e, 0x600c823d, 0x7013f36b, 0x602bc1a9, 0x7034b0ff, 0x604242c1, 0x705d3397, 0x60650155, 0x707a7003}, - [16]uint32{0x3f800000, 0x3f880fb8, 0x3f8013a1, 0x3f881c19, 0x3f802760, 0x3f8828d8, 0x3f8034c1, 0x3f883b79, 0x3fb00641, 0x3fb809f9, 0x3fb015e0, 0x3fb81a58, 0x3fb02121, 0x3fb82e99, 0x3fb03280, 0x3fb83d38}, - uint32(0xfff80000), - [21]string{"0x82", "0xce", "0x83", "0x96", "0x5a", "0xc8", "0xee", "0x6a", "0xea", "0x48", "0xc3", "0x82", "0x83", "0xbb", "0xa6", "0x50", "0x47", "0x9a", "0xb8", "0x57", "0x00"}}, - { - /* No.139 delta:806 weight:1289 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x167bdfc7, 0xd623904f, 0xc0584f88, 0xb8f008be, 0xae8bd779, 0x6ed398f1, 0x78a84736, 0x000012ed, 0x167bcd2a, 0xd62382a2, 0xc0585d65, 0xb8f01a53, 0xae8bc594, 0x6ed38a1c, 0x78a855db}, - [16]uint32{0x00000000, 0x1070993d, 0x0002147e, 0x10728d43, 0x404085b8, 0x50301c85, 0x404291c6, 0x503208fb, 0x00010807, 0x1071913a, 0x00031c79, 0x10738544, 0x40418dbf, 0x50311482, 0x404399c1, 0x503300fc}, - [16]uint32{0x3f800000, 0x3f88384c, 0x3f80010a, 0x3f883946, 0x3fa02042, 0x3fa8180e, 0x3fa02148, 0x3fa81904, 0x3f800084, 0x3f8838c8, 0x3f80018e, 0x3f8839c2, 0x3fa020c6, 0x3fa8188a, 0x3fa021cc, 0x3fa81980}, - uint32(0xfff80000), - [21]string{"0x0b", "0x53", "0x7d", "0x77", "0x88", "0xbe", "0xf7", "0xe0", "0xab", "0x5e", "0x31", "0x24", "0xee", "0x24", "0xd6", "0x65", "0x85", "0x33", "0xf4", "0xc6", "0x00"}}, - { - /* No.140 delta:708 weight:1653 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0xa843165f, 0xfd791587, 0x553a03d8, 0xb6d008c3, 0x1e931e9c, 0x4ba91d44, 0xe3ea0b1b, 0x00007382, 0xa84365dd, 0xfd796605, 0x553a705a, 0xb6d07b41, 0x1e936d1e, 0x4ba96ec6, 0xe3ea7899}, - [16]uint32{0x00000000, 0x00032c13, 0x4000a36f, 0x40038f7c, 0xf00000f7, 0xf0032ce4, 0xb000a398, 0xb0038f8b, 0x10006816, 0x10034405, 0x5000cb79, 0x5003e76a, 0xe00068e1, 0xe00344f2, 0xa000cb8e, 0xa003e79d}, - [16]uint32{0x3f800000, 0x3f800196, 0x3fa00051, 0x3fa001c7, 0x3ff80000, 0x3ff80196, 0x3fd80051, 0x3fd801c7, 0x3f880034, 0x3f8801a2, 0x3fa80065, 0x3fa801f3, 0x3ff00034, 0x3ff001a2, 0x3fd00065, 0x3fd001f3}, - uint32(0xfff80000), - [21]string{"0x8a", "0x61", "0xc1", "0x12", "0xfb", "0x34", "0x22", "0xe4", "0xea", "0xfd", "0x6a", "0x85", "0x6e", "0x31", "0x31", "0xe0", "0x83", "0x16", "0x29", "0x46", "0x00"}}, - { - /* No.141 delta:999 weight:979 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0x704436df, 0x3cf475e1, 0x4cb0433e, 0x82c008dc, 0xf2843e03, 0xbe347d3d, 0xce704be2, 0x0000a242, 0x7044949d, 0x3cf4d7a3, 0x4cb0e17c, 0x82c0aa9e, 0xf2849c41, 0xbe34df7f, 0xce70e9a0}, - [16]uint32{0x00000000, 0x0023d9b6, 0x0054015b, 0x0077d8ed, 0x27d021f1, 0x27f3f847, 0x278420aa, 0x27a7f91c, 0x0a0a2118, 0x0a29f8ae, 0x0a5e2043, 0x0a7df9f5, 0x2dda00e9, 0x2df9d95f, 0x2d8e01b2, 0x2dadd804}, - [16]uint32{0x3f800000, 0x3f8011ec, 0x3f802a00, 0x3f803bec, 0x3f93e810, 0x3f93f9fc, 0x3f93c210, 0x3f93d3fc, 0x3f850510, 0x3f8514fc, 0x3f852f10, 0x3f853efc, 0x3f96ed00, 0x3f96fcec, 0x3f96c700, 0x3f96d6ec}, - uint32(0xfff80000), - [21]string{"0x15", "0x85", "0xd9", "0x08", "0x97", "0x45", "0xfd", "0x4a", "0x34", "0x36", "0x05", "0xdf", "0xdc", "0xe2", "0x28", "0x04", "0x9b", "0x16", "0xc3", "0x00", "0x00"}}, - { - /* No.142 delta:602 weight:1747 */ - 11213, - 75, - 13, - 4, - [16]uint32{0x00000000, 0xb6dda24b, 0x671fd84c, 0xd1c27a07, 0x66a008e9, 0xd07daaa2, 0x01bfd0a5, 0xb76272ee, 0x00006563, 0xb6ddc728, 0x671fbd2f, 0xd1c21f64, 0x66a06d8a, 0xd07dcfc1, 0x01bfb5c6, 0xb762178d}, - [16]uint32{0x00000000, 0x0801011f, 0x40040106, 0x48050019, 0x0020cfdd, 0x0821cec2, 0x4024cedb, 0x4825cfc4, 0x10001c18, 0x18011d07, 0x50041d1e, 0x58051c01, 0x1020d3c5, 0x1821d2da, 0x5024d2c3, 0x5825d3dc}, - [16]uint32{0x3f800000, 0x3f840080, 0x3fa00200, 0x3fa40280, 0x3f801067, 0x3f8410e7, 0x3fa01267, 0x3fa412e7, 0x3f88000e, 0x3f8c008e, 0x3fa8020e, 0x3fac028e, 0x3f881069, 0x3f8c10e9, 0x3fa81269, 0x3fac12e9}, - uint32(0xfff80000), - [21]string{"0xd2", "0xa3", "0xa9", "0x60", "0x33", "0x46", "0x34", "0x7a", "0xa5", "0x3c", "0x04", "0x27", "0x4d", "0x40", "0xa4", "0xb7", "0xc0", "0x45", "0xc2", "0xf2", "0x00"}}, - { - /* No.143 delta:1765 weight:1617 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0x989cafc6, 0x80343f5b, 0x18a8909d, 0x3d4008f0, 0xa5dca736, 0xbd7437ab, 0x25e8986d, 0x0000873e, 0x989c28f8, 0x8034b865, 0x18a817a3, 0x3d408fce, 0xa5dc2008, 0xbd74b095, 0x25e81f53}, - [16]uint32{0x00000000, 0x6b6020fa, 0x2218c043, 0x4978e0b9, 0x6003218c, 0x0b630176, 0x421be1cf, 0x297bc135, 0x4088a010, 0x2be880ea, 0x62906053, 0x09f040a9, 0x208b819c, 0x4beba166, 0x029341df, 0x69f36125}, - [16]uint32{0x3f800000, 0x3fb5b010, 0x3f910c60, 0x3fa4bc70, 0x3fb00190, 0x3f85b180, 0x3fa10df0, 0x3f94bde0, 0x3fa04450, 0x3f95f440, 0x3fb14830, 0x3f84f820, 0x3f9045c0, 0x3fa5f5d0, 0x3f8149a0, 0x3fb4f9b0}, - uint32(0xfff80000), - [21]string{"0x5d", "0x7b", "0x8e", "0x78", "0xae", "0x8f", "0x26", "0xae", "0x7a", "0xb2", "0x3d", "0x45", "0x25", "0xfa", "0x23", "0x36", "0x5c", "0xd4", "0x99", "0x12", "0x00"}}, - { - /* No.144 delta:884 weight:1707 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0xd9cdefd4, 0xf3e209ac, 0x2a2fe678, 0xa8900905, 0x715de6d1, 0x5b7200a9, 0x82bfef7d, 0x00004eeb, 0xd9cda13f, 0xf3e24747, 0x2a2fa893, 0xa89047ee, 0x715da83a, 0x5b724e42, 0x82bfa196}, - [16]uint32{0x00000000, 0x200fa85a, 0x0074809f, 0x207b28c5, 0x4043441c, 0x604cec46, 0x4037c483, 0x60386cd9, 0x00024017, 0x200de84d, 0x0076c088, 0x207968d2, 0x4041040b, 0x604eac51, 0x40358494, 0x603a2cce}, - [16]uint32{0x3f800000, 0x3f9007d4, 0x3f803a40, 0x3f903d94, 0x3fa021a2, 0x3fb02676, 0x3fa01be2, 0x3fb01c36, 0x3f800120, 0x3f9006f4, 0x3f803b60, 0x3f903cb4, 0x3fa02082, 0x3fb02756, 0x3fa01ac2, 0x3fb01d16}, - uint32(0xfff80000), - [21]string{"0x09", "0xbe", "0x73", "0x0d", "0x54", "0x0c", "0xac", "0xda", "0x00", "0x3d", "0xa5", "0xe1", "0x05", "0xcd", "0xd4", "0x30", "0xec", "0x1e", "0x1c", "0x13", "0x00"}}, - { - /* No.145 delta:894 weight:1007 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0x4a30df1a, 0x68613901, 0x2251e61b, 0x4f200919, 0x0510d603, 0x27413018, 0x6d71ef02, 0x0000747c, 0x4a30ab66, 0x68614d7d, 0x22519267, 0x4f207d65, 0x0510a27f, 0x27414464, 0x6d719b7e}, - [16]uint32{0x00000000, 0x006c19f2, 0x0e40882b, 0x0e2c91d9, 0x04c0040e, 0x04ac1dfc, 0x0a808c25, 0x0aec95d7, 0x0bc0405f, 0x0bac59ad, 0x0580c874, 0x05ecd186, 0x0f004451, 0x0f6c5da3, 0x0140cc7a, 0x012cd588}, - [16]uint32{0x3f800000, 0x3f80360c, 0x3f872044, 0x3f871648, 0x3f826002, 0x3f82560e, 0x3f854046, 0x3f85764a, 0x3f85e020, 0x3f85d62c, 0x3f82c064, 0x3f82f668, 0x3f878022, 0x3f87b62e, 0x3f80a066, 0x3f80966a}, - uint32(0xfff80000), - [21]string{"0xb4", "0x19", "0x71", "0x8c", "0x48", "0x30", "0x79", "0xde", "0x01", "0x63", "0xe1", "0x7e", "0x4c", "0xce", "0x2f", "0x84", "0xe5", "0x58", "0x95", "0xd4", "0x00"}}, - { - /* No.146 delta:604 weight:1733 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x0039c62e, 0xcd8ee945, 0xcdb72f6b, 0xba000927, 0xba39cf09, 0x778ee062, 0x77b7264c, 0x0000b53e, 0x00397310, 0xcd8e5c7b, 0xcdb79a55, 0xba00bc19, 0xba397a37, 0x778e555c, 0x77b79372}, - [16]uint32{0x00000000, 0x11048bfa, 0x3013f01d, 0x21177be7, 0x50006411, 0x4104efeb, 0x6013940c, 0x71171ff6, 0x6001209f, 0x7105ab65, 0x5012d082, 0x41165b78, 0x3001448e, 0x2105cf74, 0x0012b493, 0x11163f69}, - [16]uint32{0x3f800000, 0x3f888245, 0x3f9809f8, 0x3f908bbd, 0x3fa80032, 0x3fa08277, 0x3fb009ca, 0x3fb88b8f, 0x3fb00090, 0x3fb882d5, 0x3fa80968, 0x3fa08b2d, 0x3f9800a2, 0x3f9082e7, 0x3f80095a, 0x3f888b1f}, - uint32(0xfff80000), - [21]string{"0x6c", "0x4c", "0x5a", "0xeb", "0x13", "0x2e", "0xdb", "0xc6", "0x8d", "0x7c", "0x6b", "0xa3", "0x75", "0x22", "0xa4", "0x2d", "0x14", "0xbc", "0xde", "0x56", "0x00"}}, - { - /* No.147 delta:960 weight:1163 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0x43b4ae5b, 0x76e80719, 0x355ca942, 0xdf100930, 0x9ca4a76b, 0xa9f80e29, 0xea4ca072, 0x0000673e, 0x43b4c965, 0x76e86027, 0x355cce7c, 0xdf106e0e, 0x9ca4c055, 0xa9f86917, 0xea4cc74c}, - [16]uint32{0x00000000, 0x0005f1de, 0x00021107, 0x0007e0d9, 0x547e5191, 0x547ba04f, 0x547c4096, 0x5479b148, 0x8022012c, 0x8027f0f2, 0x8020102b, 0x8025e1f5, 0xd45c50bd, 0xd459a163, 0xd45e41ba, 0xd45bb064}, - [16]uint32{0x3f800000, 0x3f8002f8, 0x3f800108, 0x3f8003f0, 0x3faa3f28, 0x3faa3dd0, 0x3faa3e20, 0x3faa3cd8, 0x3fc01100, 0x3fc013f8, 0x3fc01008, 0x3fc012f0, 0x3fea2e28, 0x3fea2cd0, 0x3fea2f20, 0x3fea2dd8}, - uint32(0xfff80000), - [21]string{"0x8a", "0x3e", "0x0b", "0xb1", "0x58", "0x61", "0xa0", "0x53", "0xdf", "0xf6", "0x62", "0x32", "0xbe", "0x8c", "0x82", "0x52", "0x0d", "0x83", "0x86", "0x83", "0x00"}}, - { - /* No.148 delta:901 weight:1609 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0xfb134e5d, 0x92dacb87, 0x69c985da, 0x1a50094b, 0xe1434716, 0x888ac2cc, 0x73998c91, 0x00000bda, 0xfb134587, 0x92dac05d, 0x69c98e00, 0x1a500291, 0xe1434ccc, 0x888ac916, 0x7399874b}, - [16]uint32{0x00000000, 0x4003bff3, 0x500059bf, 0x1003e64c, 0x30020205, 0x7001bdf6, 0x60025bba, 0x2001e449, 0x00026032, 0x4001dfc1, 0x5002398d, 0x1001867e, 0x30006237, 0x7003ddc4, 0x60003b88, 0x2003847b}, - [16]uint32{0x3f800000, 0x3fa001df, 0x3fa8002c, 0x3f8801f3, 0x3f980101, 0x3fb800de, 0x3fb0012d, 0x3f9000f2, 0x3f800130, 0x3fa000ef, 0x3fa8011c, 0x3f8800c3, 0x3f980031, 0x3fb801ee, 0x3fb0001d, 0x3f9001c2}, - uint32(0xfff80000), - [21]string{"0xed", "0x19", "0x5c", "0x48", "0x36", "0x04", "0xa5", "0x0d", "0x32", "0x2c", "0x92", "0xd7", "0xf6", "0x35", "0x06", "0x7d", "0xb8", "0x72", "0x6a", "0x9e", "0x00"}}, - { - /* No.149 delta:1073 weight:1557 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0xdd6ff907, 0x1b8687a5, 0xc6e97ea2, 0xa6200958, 0x7b4ff05f, 0xbda68efd, 0x60c977fa, 0x000050b0, 0xdd6fa9b7, 0x1b86d715, 0xc6e92e12, 0xa62059e8, 0x7b4fa0ef, 0xbda6de4d, 0x60c9274a}, - [16]uint32{0x00000000, 0x4014141a, 0x107ca00b, 0x5068b411, 0x00028813, 0x40169c09, 0x107e2818, 0x506a3c02, 0x1000116d, 0x50140577, 0x007cb166, 0x4068a57c, 0x1002997e, 0x50168d64, 0x007e3975, 0x406a2d6f}, - [16]uint32{0x3f800000, 0x3fa00a0a, 0x3f883e50, 0x3fa8345a, 0x3f800144, 0x3fa00b4e, 0x3f883f14, 0x3fa8351e, 0x3f880008, 0x3fa80a02, 0x3f803e58, 0x3fa03452, 0x3f88014c, 0x3fa80b46, 0x3f803f1c, 0x3fa03516}, - uint32(0xfff80000), - [21]string{"0xb2", "0xbf", "0x1a", "0x47", "0x01", "0x3a", "0x6d", "0xd8", "0xca", "0x8c", "0x43", "0x5e", "0x9e", "0x18", "0x90", "0xa5", "0x15", "0x8d", "0x50", "0x00", "0x00"}}, - { - /* No.150 delta:626 weight:1459 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xd8f56f8e, 0xa51a2f65, 0x7def40eb, 0x0e800961, 0xd67566ef, 0xab9a2604, 0x736f498a, 0x00005f13, 0xd8f5309d, 0xa51a7076, 0x7def1ff8, 0x0e805672, 0xd67539fc, 0xab9a7917, 0x736f1699}, - [16]uint32{0x00000000, 0x406dc45a, 0x5011893c, 0x107c4d66, 0x004384ad, 0x402e40f7, 0x50520d91, 0x103fc9cb, 0x006340c9, 0x400e8493, 0x5072c9f5, 0x101f0daf, 0x0020c464, 0x404d003e, 0x50314d58, 0x105c8902}, - [16]uint32{0x3f800000, 0x3fa036e2, 0x3fa808c4, 0x3f883e26, 0x3f8021c2, 0x3fa01720, 0x3fa82906, 0x3f881fe4, 0x3f8031a0, 0x3fa00742, 0x3fa83964, 0x3f880f86, 0x3f801062, 0x3fa02680, 0x3fa818a6, 0x3f882e44}, - uint32(0xfff80000), - [21]string{"0x81", "0x66", "0xc0", "0x11", "0xf2", "0x1e", "0x67", "0x18", "0x8d", "0x9f", "0x75", "0x54", "0x6b", "0x1a", "0x5f", "0x67", "0xf0", "0xe9", "0x1a", "0xdc", "0x00"}}, - { - /* No.151 delta:787 weight:1455 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0xc047ffe2, 0xbb464990, 0x7b01b672, 0xb5900979, 0x75d7f69b, 0x0ed640e9, 0xce91bf0b, 0x0000a703, 0xc04758e1, 0xbb46ee93, 0x7b011171, 0xb590ae7a, 0x75d75198, 0x0ed6e7ea, 0xce911808}, - [16]uint32{0x00000000, 0x0002a1fe, 0x700cbbd2, 0x700e1a2c, 0x40440016, 0x4046a1e8, 0x3048bbc4, 0x304a1a3a, 0x2001701b, 0x2003d1e5, 0x500dcbc9, 0x500f6a37, 0x6045700d, 0x6047d1f3, 0x1049cbdf, 0x104b6a21}, - [16]uint32{0x3f800000, 0x3f800150, 0x3fb8065d, 0x3fb8070d, 0x3fa02200, 0x3fa02350, 0x3f98245d, 0x3f98250d, 0x3f9000b8, 0x3f9001e8, 0x3fa806e5, 0x3fa807b5, 0x3fb022b8, 0x3fb023e8, 0x3f8824e5, 0x3f8825b5}, - uint32(0xfff80000), - [21]string{"0x02", "0x9f", "0x13", "0x9e", "0x40", "0x74", "0xd9", "0x43", "0xb3", "0x32", "0xf0", "0x44", "0x3a", "0x4a", "0xee", "0xd4", "0x2e", "0x2a", "0x08", "0x78", "0x00"}}, - { - /* No.152 delta:2273 weight:1239 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0xd3754bf9, 0x602e9050, 0xb35bdba9, 0x78100988, 0xab654271, 0x183e99d8, 0xcb4bd221, 0x0000d221, 0xd37599d8, 0x602e4271, 0xb35b0988, 0x7810dba9, 0xab659050, 0x183e4bf9, 0xcb4b0000}, - [16]uint32{0x00000000, 0x2c855e1a, 0x38182087, 0x149d7e9d, 0xb0000011, 0x9c855e0b, 0x88182096, 0xa49d7e8c, 0x0a898a1e, 0x260cd404, 0x3291aa99, 0x1e14f483, 0xba898a0f, 0x960cd415, 0x8291aa88, 0xae14f492}, - [16]uint32{0x3f800000, 0x3f9642af, 0x3f9c0c10, 0x3f8a4ebf, 0x3fd80000, 0x3fce42af, 0x3fc40c10, 0x3fd24ebf, 0x3f8544c5, 0x3f93066a, 0x3f9948d5, 0x3f8f0a7a, 0x3fdd44c5, 0x3fcb066a, 0x3fc148d5, 0x3fd70a7a}, - uint32(0xfff80000), - [21]string{"0x74", "0xe0", "0xac", "0xfc", "0x8c", "0x6a", "0xf9", "0x80", "0x8c", "0x13", "0xa4", "0xb5", "0x63", "0x77", "0xdc", "0xb5", "0x3d", "0xab", "0x49", "0xd7", "0x00"}}, - { - /* No.153 delta:871 weight:1143 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xfedc74b0, 0xaee6d14b, 0x503aa5fb, 0xce20099e, 0x30fc7d2e, 0x60c6d8d5, 0x9e1aac65, 0x0000ae3e, 0xfedcda8e, 0xaee67f75, 0x503a0bc5, 0xce20a7a0, 0x30fcd310, 0x60c676eb, 0x9e1a025b}, - [16]uint32{0x00000000, 0x00545892, 0x0002459d, 0x00561d0f, 0x4200321a, 0x42546a88, 0x42027787, 0x42562f15, 0xa010630e, 0xa0443b9c, 0xa0122693, 0xa0467e01, 0xe2105114, 0xe2440986, 0xe2121489, 0xe2464c1b}, - [16]uint32{0x3f800000, 0x3f802a2c, 0x3f800122, 0x3f802b0e, 0x3fa10019, 0x3fa12a35, 0x3fa1013b, 0x3fa12b17, 0x3fd00831, 0x3fd0221d, 0x3fd00913, 0x3fd0233f, 0x3ff10828, 0x3ff12204, 0x3ff1090a, 0x3ff12326}, - uint32(0xfff80000), - [21]string{"0x78", "0xb7", "0xc4", "0x5a", "0x2d", "0x30", "0xeb", "0xa8", "0x00", "0xa7", "0xd4", "0x75", "0x85", "0x8f", "0x9c", "0x97", "0x0c", "0x23", "0x95", "0xb0", "0x00"}}, - { - /* No.154 delta:680 weight:1645 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xf2f6c7de, 0xab19ce85, 0x59ef095b, 0xbc3009a5, 0x4ec6ce7b, 0x1729c720, 0xe5df00fe, 0x00004ae2, 0xf2f68d3c, 0xab198467, 0x59ef43b9, 0xbc304347, 0x4ec68499, 0x17298dc2, 0xe5df4a1c}, - [16]uint32{0x00000000, 0x6074301d, 0x0050108c, 0x60242091, 0x0024ac05, 0x60509c18, 0x0074bc89, 0x60008c94, 0x20092003, 0x407d101e, 0x2059308f, 0x402d0092, 0x202d8c06, 0x4059bc1b, 0x207d9c8a, 0x4009ac97}, - [16]uint32{0x3f800000, 0x3fb03a18, 0x3f802808, 0x3fb01210, 0x3f801256, 0x3fb0284e, 0x3f803a5e, 0x3fb00046, 0x3f900490, 0x3fa03e88, 0x3f902c98, 0x3fa01680, 0x3f9016c6, 0x3fa02cde, 0x3f903ece, 0x3fa004d6}, - uint32(0xfff80000), - [21]string{"0xec", "0x69", "0xee", "0x1e", "0xad", "0x69", "0x24", "0x8c", "0xc7", "0x98", "0x5a", "0xd4", "0x98", "0xfd", "0xb3", "0xc1", "0xe0", "0xfa", "0x9e", "0xf3", "0x00"}}, - { - /* No.155 delta:1483 weight:1731 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x6773f0aa, 0xe4e35e87, 0x8390ae2d, 0xeb2009b3, 0x8c53f919, 0x0fc35734, 0x68b0a79e, 0x0000f41b, 0x677304b1, 0xe4e3aa9c, 0x83905a36, 0xeb20fda8, 0x8c530d02, 0x0fc3a32f, 0x68b05385}, - [16]uint32{0x00000000, 0x082689de, 0x40412a3b, 0x4867a3e5, 0x003b7a17, 0x081df3c9, 0x407a502c, 0x485cd9f2, 0x4006001d, 0x482089c3, 0x00472a26, 0x0861a3f8, 0x403d7a0a, 0x481bf3d4, 0x007c5031, 0x085ad9ef}, - [16]uint32{0x3f800000, 0x3f841344, 0x3fa02095, 0x3fa433d1, 0x3f801dbd, 0x3f840ef9, 0x3fa03d28, 0x3fa42e6c, 0x3fa00300, 0x3fa41044, 0x3f802395, 0x3f8430d1, 0x3fa01ebd, 0x3fa40df9, 0x3f803e28, 0x3f842d6c}, - uint32(0xfff80000), - [21]string{"0x91", "0x6b", "0x3e", "0xd5", "0xba", "0xef", "0xf4", "0xa8", "0xf8", "0x4f", "0x70", "0xfd", "0x6c", "0x0f", "0x76", "0x88", "0xd4", "0x1d", "0xcf", "0x43", "0x00"}}, - { - /* No.156 delta:733 weight:1193 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0xc46496aa, 0x6333d0ee, 0xa7574644, 0xd33009c1, 0x17549f6b, 0xb003d92f, 0x74674f85, 0x00005202, 0xc464c4a8, 0x633382ec, 0xa7571446, 0xd3305bc3, 0x1754cd69, 0xb0038b2d, 0x74671d87}, - [16]uint32{0x00000000, 0x106c1592, 0xc034481b, 0xd0585d89, 0x1110946a, 0x017c81f8, 0xd124dc71, 0xc148c9e3, 0x2062041e, 0x300e118c, 0xe0564c05, 0xf03a5997, 0x31729074, 0x211e85e6, 0xf146d86f, 0xe12acdfd}, - [16]uint32{0x3f800000, 0x3f88360a, 0x3fe01a24, 0x3fe82c2e, 0x3f88884a, 0x3f80be40, 0x3fe8926e, 0x3fe0a464, 0x3f903102, 0x3f980708, 0x3ff02b26, 0x3ff81d2c, 0x3f98b948, 0x3f908f42, 0x3ff8a36c, 0x3ff09566}, - uint32(0xfff80000), - [21]string{"0xfb", "0x19", "0xfa", "0xea", "0x83", "0x92", "0x82", "0x21", "0xbb", "0x01", "0xbd", "0xb5", "0xbd", "0xca", "0xb0", "0xf6", "0x77", "0x93", "0x35", "0xe5", "0x00"}}, - { - /* No.157 delta:880 weight:975 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0xb3f72ee5, 0x0d4a781f, 0xbebd56fa, 0x32e009d2, 0x81172737, 0x3faa71cd, 0x8c5d5f28, 0x00008f44, 0xb3f7a1a1, 0x0d4af75b, 0xbebdd9be, 0x32e08696, 0x8117a873, 0x3faafe89, 0x8c5dd06c}, - [16]uint32{0x00000000, 0x1160d07b, 0x3980408e, 0x28e090f5, 0x0e5100d7, 0x1f31d0ac, 0x37d14059, 0x26b19022, 0x43c8e012, 0x52a83069, 0x7a48a09c, 0x6b2870e7, 0x4d99e0c5, 0x5cf930be, 0x7419a04b, 0x65797030}, - [16]uint32{0x3f800000, 0x3f88b068, 0x3f9cc020, 0x3f947048, 0x3f872880, 0x3f8f98e8, 0x3f9be8a0, 0x3f9358c8, 0x3fa1e470, 0x3fa95418, 0x3fbd2450, 0x3fb59438, 0x3fa6ccf0, 0x3fae7c98, 0x3fba0cd0, 0x3fb2bcb8}, - uint32(0xfff80000), - [21]string{"0xe8", "0x4a", "0xb3", "0x87", "0xe1", "0x48", "0xc9", "0x8e", "0xef", "0x24", "0x1e", "0xda", "0x9b", "0x0f", "0x74", "0x19", "0x5e", "0x98", "0x31", "0xf0", "0x00"}}, - { - /* No.158 delta:663 weight:1719 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x403d0e8e, 0x336bfa3e, 0x7356f4b0, 0xd48009e9, 0x94bd0767, 0xe7ebf3d7, 0xa7d6fd59, 0x00000ddd, 0x403d0353, 0x336bf7e3, 0x7356f96d, 0xd4800434, 0x94bd0aba, 0xe7ebfe0a, 0xa7d6f084}, - [16]uint32{0x00000000, 0x501a59b6, 0x7004582a, 0x201e019c, 0x000325ad, 0x50197c1b, 0x70077d87, 0x201d2431, 0x30544063, 0x604e19d5, 0x40501849, 0x104a41ff, 0x305765ce, 0x604d3c78, 0x40533de4, 0x10496452}, - [16]uint32{0x3f800000, 0x3fa80d2c, 0x3fb8022c, 0x3f900f00, 0x3f800192, 0x3fa80cbe, 0x3fb803be, 0x3f900e92, 0x3f982a20, 0x3fb0270c, 0x3fa0280c, 0x3f882520, 0x3f982bb2, 0x3fb0269e, 0x3fa0299e, 0x3f8824b2}, - uint32(0xfff80000), - [21]string{"0xed", "0xea", "0xb8", "0x18", "0xc8", "0x76", "0x78", "0xc5", "0x42", "0x78", "0x5e", "0xb8", "0xe7", "0x06", "0xb4", "0xbf", "0x24", "0x82", "0xa2", "0x30", "0x00"}}, - { - /* No.159 delta:1845 weight:1483 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x4d99df0f, 0x05f964c0, 0x4860bbcf, 0xbee009fc, 0xf379d6f3, 0xbb196d3c, 0xf680b233, 0x00007b31, 0x4d99a43e, 0x05f91ff1, 0x4860c0fe, 0xbee072cd, 0xf379adc2, 0xbb19160d, 0xf680c902}, - [16]uint32{0x00000000, 0x58cc8356, 0x26780415, 0x7eb48743, 0x4200501f, 0x1accd349, 0x6478540a, 0x3cb4d75c, 0x081541f4, 0x50d9c2a2, 0x2e6d45e1, 0x76a1c6b7, 0x4a1511eb, 0x12d992bd, 0x6c6d15fe, 0x34a196a8}, - [16]uint32{0x3f800000, 0x3fac6641, 0x3f933c02, 0x3fbf5a43, 0x3fa10028, 0x3f8d6669, 0x3fb23c2a, 0x3f9e5a6b, 0x3f840aa0, 0x3fa86ce1, 0x3f9736a2, 0x3fbb50e3, 0x3fa50a88, 0x3f896cc9, 0x3fb6368a, 0x3f9a50cb}, - uint32(0xfff80000), - [21]string{"0xe0", "0x6e", "0xee", "0x13", "0x9c", "0xda", "0xb8", "0x10", "0x90", "0x8b", "0x5f", "0x38", "0x70", "0xda", "0x77", "0xae", "0x88", "0x80", "0xfa", "0x25", "0x00"}}, - { - /* No.160 delta:701 weight:1237 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x533b8e4b, 0x04e41c3b, 0x57df9270, 0x93200a0c, 0xc01b8447, 0x97c41637, 0xc4ff987c, 0x00001b54, 0x533b951f, 0x04e4076f, 0x57df8924, 0x93201158, 0xc01b9f13, 0x97c40d63, 0xc4ff8328}, - [16]uint32{0x00000000, 0x106fb1bd, 0x9040018f, 0x802fb032, 0x5032405b, 0x405df1e6, 0xc07241d4, 0xd01df069, 0x004a780e, 0x1025c9b3, 0x900a7981, 0x8065c83c, 0x50783855, 0x401789e8, 0xc03839da, 0xd0578867}, - [16]uint32{0x3f800000, 0x3f8837d8, 0x3fc82000, 0x3fc017d8, 0x3fa81920, 0x3fa02ef8, 0x3fe03920, 0x3fe80ef8, 0x3f80253c, 0x3f8812e4, 0x3fc8053c, 0x3fc032e4, 0x3fa83c1c, 0x3fa00bc4, 0x3fe01c1c, 0x3fe82bc4}, - uint32(0xfff80000), - [21]string{"0x7e", "0x9c", "0x0e", "0x2e", "0x61", "0x72", "0xa8", "0x37", "0x50", "0x74", "0xe3", "0xa9", "0x39", "0xd8", "0x5e", "0x44", "0xd8", "0xaa", "0x0a", "0x3a", "0x00"}}, - { - /* No.161 delta:1210 weight:1361 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0xda18d8f3, 0x864b1d8a, 0x5c53c579, 0x8ff00a12, 0x55e8d2e1, 0x09bb1798, 0xd3a3cf6b, 0x00000ad1, 0xda18d222, 0x864b175b, 0x5c53cfa8, 0x8ff000c3, 0x55e8d830, 0x09bb1d49, 0xd3a3c5ba}, - [16]uint32{0x00000000, 0x006d79f2, 0x0052d5c7, 0x003fac35, 0x0009b6eb, 0x0064cf19, 0x005b632c, 0x00361ade, 0x4201ac05, 0x426cd5f7, 0x425379c2, 0x423e0030, 0x42081aee, 0x4265631c, 0x425acf29, 0x4237b6db}, - [16]uint32{0x3f800000, 0x3f8036bc, 0x3f80296a, 0x3f801fd6, 0x3f8004db, 0x3f803267, 0x3f802db1, 0x3f801b0d, 0x3fa100d6, 0x3fa1366a, 0x3fa129bc, 0x3fa11f00, 0x3fa1040d, 0x3fa132b1, 0x3fa12d67, 0x3fa11bdb}, - uint32(0xfff80000), - [21]string{"0xca", "0x08", "0xd3", "0xcf", "0xb4", "0x8a", "0x29", "0x9a", "0x0c", "0xbf", "0xff", "0x3b", "0x35", "0x66", "0x50", "0x68", "0xc1", "0x0b", "0x60", "0xef", "0x00"}}, - { - /* No.162 delta:795 weight:1449 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0xbcdfb5d0, 0xc8fddc0c, 0x742269dc, 0xbca00a22, 0x007fbff2, 0x745dd62e, 0xc88263fe, 0x0000e6c3, 0xbcdf5313, 0xc8fd3acf, 0x74228f1f, 0xbca0ece1, 0x007f5931, 0x745d30ed, 0xc882853d}, - [16]uint32{0x00000000, 0x00124092, 0x200000f4, 0x20124066, 0x1001919b, 0x1013d109, 0x3001916f, 0x3013d1fd, 0x90006878, 0x901228ea, 0xb000688c, 0xb012281e, 0x8001f9e3, 0x8013b971, 0xa001f917, 0xa013b985}, - [16]uint32{0x3f800000, 0x3f800920, 0x3f900000, 0x3f900920, 0x3f8800c8, 0x3f8809e8, 0x3f9800c8, 0x3f9809e8, 0x3fc80034, 0x3fc80914, 0x3fd80034, 0x3fd80914, 0x3fc000fc, 0x3fc009dc, 0x3fd000fc, 0x3fd009dc}, - uint32(0xfff80000), - [21]string{"0x72", "0xc8", "0xed", "0xae", "0x2a", "0x9b", "0xef", "0x90", "0x98", "0x10", "0x0e", "0xa2", "0x98", "0x6e", "0xc4", "0x9f", "0x4e", "0x30", "0x0c", "0x95", "0x00"}}, - { - /* No.163 delta:2431 weight:1043 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0x22ab4cf9, 0x4d93d360, 0x6f389f99, 0xe3e00a3f, 0xc14b46c6, 0xae73d95f, 0x8cd895a6, 0x0000213d, 0x22ab6dc4, 0x4d93f25d, 0x6f38bea4, 0xe3e02b02, 0xc14b67fb, 0xae73f862, 0x8cd8b49b}, - [16]uint32{0x00000000, 0x9eb058d6, 0xe1c02c0f, 0x7f7074d9, 0x70888d5e, 0xee38d588, 0x9148a151, 0x0ff8f987, 0x16084c1b, 0x88b814cd, 0xf7c86014, 0x697838c2, 0x6680c145, 0xf8309993, 0x8740ed4a, 0x19f0b59c}, - [16]uint32{0x3f800000, 0x3fcf582c, 0x3ff0e016, 0x3fbfb83a, 0x3fb84446, 0x3ff71c6a, 0x3fc8a450, 0x3f87fc7c, 0x3f8b0426, 0x3fc45c0a, 0x3ffbe430, 0x3fb4bc1c, 0x3fb34060, 0x3ffc184c, 0x3fc3a076, 0x3f8cf85a}, - uint32(0xfff80000), - [21]string{"0xd2", "0x4a", "0xaf", "0xe3", "0x55", "0xc3", "0xfa", "0x9a", "0x5e", "0xb9", "0xbc", "0x94", "0x33", "0xf2", "0x6c", "0xa1", "0xee", "0xc7", "0xa1", "0x72", "0x00"}}, - { - /* No.164 delta:2864 weight:779 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0x930e07df, 0xe7b13610, 0x74bf31cf, 0x3b500a4f, 0xa85e0d90, 0xdce13c5f, 0x4fef3b80, 0x0000c7c0, 0x930ec01f, 0xe7b1f1d0, 0x74bff60f, 0x3b50cd8f, 0xa85eca50, 0xdce1fb9f, 0x4feffc40}, - [16]uint32{0x00000000, 0x9e6701be, 0x3079c5f2, 0xae1ec44c, 0x1220219b, 0x8c472025, 0x2259e469, 0xbc3ee5d7, 0x08808d8e, 0x96e78c30, 0x38f9487c, 0xa69e49c2, 0x1aa0ac15, 0x84c7adab, 0x2ad969e7, 0xb4be6859}, - [16]uint32{0x3f800000, 0x3fcf3380, 0x3f983ce2, 0x3fd70f62, 0x3f891010, 0x3fc62390, 0x3f912cf2, 0x3fde1f72, 0x3f844046, 0x3fcb73c6, 0x3f9c7ca4, 0x3fd34f24, 0x3f8d5056, 0x3fc263d6, 0x3f956cb4, 0x3fda5f34}, - uint32(0xfff80000), - [21]string{"0x6e", "0x02", "0x89", "0x09", "0x39", "0xd5", "0xf9", "0x3d", "0x6d", "0x6b", "0x67", "0x1e", "0x31", "0x28", "0x71", "0xbd", "0x6d", "0xf7", "0xbd", "0x39", "0x00"}}, - { - /* No.165 delta:1244 weight:1685 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0x255f9767, 0xd34967dc, 0xf616f0bb, 0x64000a53, 0x415f9d34, 0xb7496d8f, 0x9216fae8, 0x0000db64, 0x255f4c03, 0xd349bcb8, 0xf6162bdf, 0x6400d137, 0x415f4650, 0xb749b6eb, 0x9216218c}, - [16]uint32{0x00000000, 0x40245894, 0xc0466d97, 0x80623503, 0x00450011, 0x40615885, 0xc0036d86, 0x80273512, 0x0002440b, 0x40261c9f, 0xc044299c, 0x80607108, 0x0047441a, 0x40631c8e, 0xc001298d, 0x80257119}, - [16]uint32{0x3f800000, 0x3fa0122c, 0x3fe02336, 0x3fc0311a, 0x3f802280, 0x3fa030ac, 0x3fe001b6, 0x3fc0139a, 0x3f800122, 0x3fa0130e, 0x3fe02214, 0x3fc03038, 0x3f8023a2, 0x3fa0318e, 0x3fe00094, 0x3fc012b8}, - uint32(0xfff80000), - [21]string{"0x24", "0x46", "0xd1", "0x9b", "0xe1", "0xfc", "0x9e", "0xe4", "0xef", "0xb2", "0x97", "0x74", "0xdc", "0x89", "0x9d", "0x7b", "0xbc", "0x51", "0x66", "0xeb", "0x00"}}, - { - /* No.166 delta:975 weight:1321 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x9eebf48a, 0xc2268cb3, 0x5ccd7839, 0xf3d00a66, 0x6d3bfeec, 0x31f686d5, 0xaf1d725f, 0x000006fd, 0x9eebf277, 0xc2268a4e, 0x5ccd7ec4, 0xf3d00c9b, 0x6d3bf811, 0x31f68028, 0xaf1d74a2}, - [16]uint32{0x00000000, 0x6041241e, 0x40030919, 0x20422d07, 0x203c71f4, 0x407d55ea, 0x603f78ed, 0x007e5cf3, 0x4020680b, 0x20614c15, 0x00236112, 0x6062450c, 0x601c19ff, 0x005d3de1, 0x201f10e6, 0x405e34f8}, - [16]uint32{0x3f800000, 0x3fb02092, 0x3fa00184, 0x3f902116, 0x3f901e38, 0x3fa03eaa, 0x3fb01fbc, 0x3f803f2e, 0x3fa01034, 0x3f9030a6, 0x3f8011b0, 0x3fb03122, 0x3fb00e0c, 0x3f802e9e, 0x3f900f88, 0x3fa02f1a}, - uint32(0xfff80000), - [21]string{"0x66", "0x41", "0xa4", "0xda", "0xc7", "0xc0", "0x9a", "0x46", "0x41", "0x04", "0x63", "0x70", "0x97", "0xc0", "0x79", "0xcd", "0xc4", "0xe3", "0x25", "0x6c", "0x00"}}, - { - /* No.167 delta:822 weight:1569 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x82155f47, 0x6ecf1b68, 0xecda442f, 0x26b00a77, 0xa4a55530, 0x487f111f, 0xca6a4e58, 0x0000b1cf, 0x8215ee88, 0x6ecfaaa7, 0xecdaf5e0, 0x26b0bbb8, 0xa4a5e4ff, 0x487fa0d0, 0xca6aff97}, - [16]uint32{0x00000000, 0x00741c12, 0x002010e6, 0x00540cf4, 0x10038215, 0x10779e07, 0x102392f3, 0x10578ee1, 0x2001820e, 0x20759e1c, 0x202192e8, 0x20558efa, 0x3002001b, 0x30761c09, 0x302210fd, 0x30560cef}, - [16]uint32{0x3f800000, 0x3f803a0e, 0x3f801008, 0x3f802a06, 0x3f8801c1, 0x3f883bcf, 0x3f8811c9, 0x3f882bc7, 0x3f9000c1, 0x3f903acf, 0x3f9010c9, 0x3f902ac7, 0x3f980100, 0x3f983b0e, 0x3f981108, 0x3f982b06}, - uint32(0xfff80000), - [21]string{"0x0b", "0x4f", "0x62", "0x95", "0x75", "0x0b", "0x08", "0x87", "0xec", "0x7c", "0xff", "0x1c", "0xaa", "0xf5", "0x0c", "0x88", "0xa4", "0xcf", "0x35", "0x71", "0x00"}}, - { - /* No.168 delta:2479 weight:1075 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0xb2b1de9a, 0x3cd6fd93, 0x8e672309, 0x66a00a8a, 0xd411d410, 0x5a76f719, 0xe8c72983, 0x0000316f, 0xb2b1eff5, 0x3cd6ccfc, 0x8e671266, 0x66a03be5, 0xd411e57f, 0x5a76c676, 0xe8c718ec}, - [16]uint32{0x00000000, 0xf87321b4, 0x0215c11e, 0xfa66e0aa, 0x30c06818, 0xc8b349ac, 0x32d5a906, 0xcaa688b2, 0x30b60413, 0xc8c525a7, 0x32a3c50d, 0xcad0e4b9, 0x00766c0b, 0xf8054dbf, 0x0263ad15, 0xfa108ca1}, - [16]uint32{0x3f800000, 0x3ffc3990, 0x3f810ae0, 0x3ffd3370, 0x3f986034, 0x3fe459a4, 0x3f996ad4, 0x3fe55344, 0x3f985b02, 0x3fe46292, 0x3f9951e2, 0x3fe56872, 0x3f803b36, 0x3ffc02a6, 0x3f8131d6, 0x3ffd0846}, - uint32(0xfff80000), - [21]string{"0xe2", "0xcf", "0x0e", "0x1e", "0xa2", "0xe7", "0xf0", "0xe2", "0x9d", "0x80", "0x77", "0xba", "0xb6", "0x20", "0xa9", "0x8a", "0x3c", "0xfe", "0xda", "0x1d", "0x00"}}, - { - /* No.169 delta:1568 weight:1675 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0xccc1bd43, 0x3fe6a0cd, 0xf3271d8e, 0x46b00a9e, 0x8a71b7dd, 0x7956aa53, 0xb5971710, 0x00006731, 0xccc1da72, 0x3fe6c7fc, 0xf3277abf, 0x46b06daf, 0x8a71d0ec, 0x7956cd62, 0xb5977021}, - [16]uint32{0x00000000, 0x08811f14, 0x011d01d1, 0x099c1ec5, 0x8006ce1f, 0x8887d10b, 0x811bcfce, 0x899ad0da, 0x048001fc, 0x0c011ee8, 0x059d002d, 0x0d1c1f39, 0x8486cfe3, 0x8c07d0f7, 0x859bce32, 0x8d1ad126}, - [16]uint32{0x3f800000, 0x3f84408f, 0x3f808e80, 0x3f84ce0f, 0x3fc00367, 0x3fc443e8, 0x3fc08de7, 0x3fc4cd68, 0x3f824000, 0x3f86008f, 0x3f82ce80, 0x3f868e0f, 0x3fc24367, 0x3fc603e8, 0x3fc2cde7, 0x3fc68d68}, - uint32(0xfff80000), - [21]string{"0x36", "0x03", "0x1e", "0xd8", "0xe1", "0x52", "0x01", "0x67", "0x0e", "0x46", "0xc9", "0x8c", "0x5b", "0x72", "0xf4", "0x1b", "0xd0", "0xcc", "0x90", "0x66", "0x00"}}, - { - /* No.170 delta:887 weight:1169 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0x204cedf9, 0x665b37f8, 0x4617da01, 0x6cd00aa0, 0x4c9ce759, 0x0a8b3d58, 0x2ac7d0a1, 0x00003dab, 0x204cd052, 0x665b0a53, 0x4617e7aa, 0x6cd0370b, 0x4c9cdaf2, 0x0a8b00f3, 0x2ac7ed0a}, - [16]uint32{0x00000000, 0x002e2b75, 0x700212a9, 0x702c39dc, 0x0002f80a, 0x002cd37f, 0x7000eaa3, 0x702ec1d6, 0x600c0412, 0x60222f67, 0x100e16bb, 0x10203dce, 0x600efc18, 0x6020d76d, 0x100ceeb1, 0x1022c5c4}, - [16]uint32{0x3f800000, 0x3f801715, 0x3fb80109, 0x3fb8161c, 0x3f80017c, 0x3f801669, 0x3fb80075, 0x3fb81760, 0x3fb00602, 0x3fb01117, 0x3f88070b, 0x3f88101e, 0x3fb0077e, 0x3fb0106b, 0x3f880677, 0x3f881162}, - uint32(0xfff80000), - [21]string{"0x09", "0x30", "0x36", "0x45", "0x63", "0x72", "0x06", "0x8f", "0x3a", "0xd2", "0xc5", "0x1a", "0x3f", "0x29", "0x2a", "0xf1", "0x62", "0x72", "0xb4", "0x65", "0x00"}}, - { - /* No.171 delta:736 weight:1515 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0x179d8c42, 0xa333f12e, 0xb4ae7d6c, 0x9cc00abf, 0x8b5d86fd, 0x3ff3fb91, 0x286e77d3, 0x0000f0c5, 0x179d7c87, 0xa33301eb, 0xb4ae8da9, 0x9cc0fa7a, 0x8b5d7638, 0x3ff30b54, 0x286e8716}, - [16]uint32{0x00000000, 0x8002113f, 0x0082696e, 0x80807851, 0x4000394d, 0xc0022872, 0x40825023, 0xc080411c, 0x00481046, 0x804a0179, 0x00ca7928, 0x80c86817, 0x4048290b, 0xc04a3834, 0x40ca4065, 0xc0c8515a}, - [16]uint32{0x3f800000, 0x3fc00108, 0x3f804134, 0x3fc0403c, 0x3fa0001c, 0x3fe00114, 0x3fa04128, 0x3fe04020, 0x3f802408, 0x3fc02500, 0x3f80653c, 0x3fc06434, 0x3fa02414, 0x3fe0251c, 0x3fa06520, 0x3fe06428}, - uint32(0xfff80000), - [21]string{"0xb1", "0xdc", "0x86", "0xb7", "0x63", "0x4f", "0xd7", "0xb9", "0xfd", "0x4e", "0x0f", "0x84", "0x3f", "0x56", "0xd4", "0xde", "0xa1", "0x15", "0x74", "0x63", "0x00"}}, - { - /* No.172 delta:864 weight:1317 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0xf8a54642, 0x32b17565, 0xca143327, 0x31d00ac8, 0xc9754c8a, 0x03617fad, 0xfbc439ef, 0x00003df6, 0xf8a57bb4, 0x32b14893, 0xca140ed1, 0x31d0373e, 0xc975717c, 0x0361425b, 0xfbc40419}, - [16]uint32{0x00000000, 0x0802d814, 0x4001806f, 0x4803587b, 0x1001f7b5, 0x18032fa1, 0x500077da, 0x5802afce, 0x20019189, 0x2803499d, 0x600011e6, 0x6802c9f2, 0x3000663c, 0x3802be28, 0x7001e653, 0x78033e47}, - [16]uint32{0x3f800000, 0x3f84016c, 0x3fa000c0, 0x3fa401ac, 0x3f8800fb, 0x3f8c0197, 0x3fa8003b, 0x3fac0157, 0x3f9000c8, 0x3f9401a4, 0x3fb00008, 0x3fb40164, 0x3f980033, 0x3f9c015f, 0x3fb800f3, 0x3fbc019f}, - uint32(0xfff80000), - [21]string{"0x4a", "0x6e", "0x2f", "0x88", "0x4c", "0x33", "0x7b", "0xbb", "0xe2", "0x96", "0xe6", "0xf1", "0xaf", "0xba", "0x1b", "0xee", "0x2a", "0x1a", "0xe1", "0xa6", "0x00"}}, - { - /* No.173 delta:722 weight:1525 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x07c60bc2, 0x5e3370e7, 0x59f57b25, 0xa9000adb, 0xaec60119, 0xf7337a3c, 0xf0f571fe, 0x00007779, 0x07c67cbb, 0x5e33079e, 0x59f50c5c, 0xa9007da2, 0xaec67660, 0xf7330d45, 0xf0f50687}, - [16]uint32{0x00000000, 0x00641895, 0x1012440a, 0x10765c9f, 0x0003c213, 0x0067da86, 0x10118619, 0x10759e8c, 0x50000011, 0x50641884, 0x4012441b, 0x40765c8e, 0x5003c202, 0x5067da97, 0x40118608, 0x40759e9d}, - [16]uint32{0x3f800000, 0x3f80320c, 0x3f880922, 0x3f883b2e, 0x3f8001e1, 0x3f8033ed, 0x3f8808c3, 0x3f883acf, 0x3fa80000, 0x3fa8320c, 0x3fa00922, 0x3fa03b2e, 0x3fa801e1, 0x3fa833ed, 0x3fa008c3, 0x3fa03acf}, - uint32(0xfff80000), - [21]string{"0x88", "0x54", "0x4e", "0x54", "0xfc", "0x97", "0x1d", "0xee", "0x8c", "0x35", "0x96", "0x45", "0x39", "0x47", "0x01", "0x41", "0x49", "0xf9", "0xcc", "0x13", "0x00"}}, - { - /* No.174 delta:2446 weight:1169 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0x7013cfde, 0xefc0532c, 0x9fd39cf2, 0x44000aed, 0x3413c533, 0xabc059c1, 0xdbd3961f, 0x0000c8ca, 0x70130714, 0xefc09be6, 0x9fd35438, 0x4400c227, 0x34130df9, 0xabc0910b, 0xdbd35ed5}, - [16]uint32{0x00000000, 0xf209a07a, 0x0ce0201c, 0xfee98066, 0x424e80c8, 0xb04720b2, 0x4eaea0d4, 0xbca700ae, 0x034ca48f, 0xf14504f5, 0x0fac8493, 0xfda524e9, 0x41022447, 0xb30b843d, 0x4de2045b, 0xbfeba421}, - [16]uint32{0x3f800000, 0x3ff904d0, 0x3f867010, 0x3fff74c0, 0x3fa12740, 0x3fd82390, 0x3fa75750, 0x3fde5380, 0x3f81a652, 0x3ff8a282, 0x3f87d642, 0x3ffed292, 0x3fa08112, 0x3fd985c2, 0x3fa6f102, 0x3fdff5d2}, - uint32(0xfff80000), - [21]string{"0x13", "0x0d", "0x73", "0x24", "0x2d", "0xe1", "0x34", "0x35", "0x61", "0x80", "0x9d", "0x5b", "0x96", "0xec", "0xac", "0x0a", "0x74", "0x51", "0x84", "0xe0", "0x00"}}, - { - /* No.175 delta:2035 weight:1341 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xf5158300, 0xcf4b2e46, 0x3a5ead46, 0xcfe00afa, 0x3af589fa, 0x00ab24bc, 0xf5bea7bc, 0x00006481, 0xf515e781, 0xcf4b4ac7, 0x3a5ec9c7, 0xcfe06e7b, 0x3af5ed7b, 0x00ab403d, 0xf5bec33d}, - [16]uint32{0x00000000, 0x066611dd, 0x4038015e, 0x465e1083, 0x40780137, 0x461e10ea, 0x00400069, 0x062611b4, 0x003000c5, 0x06561118, 0x4008019b, 0x466e1046, 0x404801f2, 0x462e102f, 0x007000ac, 0x06161171}, - [16]uint32{0x3f800000, 0x3f833308, 0x3fa01c00, 0x3fa32f08, 0x3fa03c00, 0x3fa30f08, 0x3f802000, 0x3f831308, 0x3f801800, 0x3f832b08, 0x3fa00400, 0x3fa33708, 0x3fa02400, 0x3fa31708, 0x3f803800, 0x3f830b08}, - uint32(0xfff80000), - [21]string{"0x97", "0xdb", "0x01", "0xc1", "0xf7", "0x06", "0x48", "0x6f", "0x2d", "0x16", "0x52", "0x4d", "0x8d", "0x90", "0xea", "0xbf", "0x42", "0x39", "0xde", "0xc6", "0x00"}}, - { - /* No.176 delta:677 weight:1749 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0x2c5dfd73, 0x32ebbb4c, 0x1eb6463f, 0xaa100b0b, 0x864df678, 0x98fbb047, 0xb4a64d34, 0x0000c001, 0x2c5d3d72, 0x32eb7b4d, 0x1eb6863e, 0xaa10cb0a, 0x864d3679, 0x98fb7046, 0xb4a68d35}, - [16]uint32{0x00000000, 0x04033977, 0x010221e2, 0x05011895, 0x20020c11, 0x24013566, 0x21002df3, 0x25031484, 0xa101801e, 0xa502b969, 0xa003a1fc, 0xa400988b, 0x81038c0f, 0x8500b578, 0x8001aded, 0x8402949a}, - [16]uint32{0x3f800000, 0x3f82019c, 0x3f808110, 0x3f82808c, 0x3f900106, 0x3f92009a, 0x3f908016, 0x3f92818a, 0x3fd080c0, 0x3fd2815c, 0x3fd001d0, 0x3fd2004c, 0x3fc081c6, 0x3fc2805a, 0x3fc000d6, 0x3fc2014a}, - uint32(0xfff80000), - [21]string{"0x60", "0x52", "0xb4", "0x25", "0xa0", "0xd9", "0xbc", "0x6c", "0x91", "0x27", "0x2f", "0x09", "0x47", "0x69", "0xd1", "0x4f", "0x6d", "0x77", "0x92", "0xa4", "0x00"}}, - { - /* No.177 delta:916 weight:1259 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x0edb5b50, 0x2243d5fb, 0x2c988eab, 0xe1a00b10, 0xef7b5040, 0xc3e3deeb, 0xcd3885bb, 0x0000692e, 0x0edb327e, 0x2243bcd5, 0x2c98e785, 0xe1a0623e, 0xef7b396e, 0xc3e3b7c5, 0xcd38ec95}, - [16]uint32{0x00000000, 0x0063f81e, 0x50200803, 0x5043f01d, 0x40000014, 0x4063f80a, 0x10200817, 0x1043f009, 0x2040021c, 0x2023fa02, 0x70600a1f, 0x7003f201, 0x60400208, 0x6023fa16, 0x30600a0b, 0x3003f215}, - [16]uint32{0x3f800000, 0x3f8031fc, 0x3fa81004, 0x3fa821f8, 0x3fa00000, 0x3fa031fc, 0x3f881004, 0x3f8821f8, 0x3f902001, 0x3f9011fd, 0x3fb83005, 0x3fb801f9, 0x3fb02001, 0x3fb011fd, 0x3f983005, 0x3f9801f9}, - uint32(0xfff80000), - [21]string{"0x60", "0x25", "0x79", "0xde", "0xf6", "0xe8", "0x56", "0x6f", "0xaf", "0xf7", "0xdc", "0x78", "0x78", "0xa5", "0x6d", "0xed", "0x68", "0x2f", "0x7b", "0x92", "0x00"}}, - { - /* No.178 delta:650 weight:1481 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0xbb2934b3, 0x5d9e85db, 0xe6b7b168, 0x43600b20, 0xf8493f93, 0x1efe8efb, 0xa5d7ba48, 0x0000631f, 0xbb2957ac, 0x5d9ee6c4, 0xe6b7d277, 0x4360683f, 0xf8495c8c, 0x1efeede4, 0xa5d7d957}, - [16]uint32{0x00000000, 0x00531dbe, 0x401011fc, 0x40430c42, 0x00508097, 0x00039d29, 0x4040916b, 0x40138cd5, 0x201c69ad, 0x204f7413, 0x600c7851, 0x605f65ef, 0x204ce93a, 0x201ff484, 0x605cf8c6, 0x600fe578}, - [16]uint32{0x3f800000, 0x3f80298e, 0x3fa00808, 0x3fa02186, 0x3f802840, 0x3f8001ce, 0x3fa02048, 0x3fa009c6, 0x3f900e34, 0x3f9027ba, 0x3fb0063c, 0x3fb02fb2, 0x3f902674, 0x3f900ffa, 0x3fb02e7c, 0x3fb007f2}, - uint32(0xfff80000), - [21]string{"0xc1", "0x4b", "0x2e", "0x05", "0xf5", "0x1d", "0x5c", "0x01", "0xb2", "0xb4", "0xf8", "0xe8", "0xe0", "0xdc", "0x65", "0xee", "0x85", "0x3a", "0x54", "0x2a", "0x00"}}, - { - /* No.179 delta:1090 weight:1633 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x3208ef45, 0x55becd4e, 0x67b6220b, 0x01b00b3e, 0x33b8e47b, 0x540ec670, 0x66062935, 0x0000dec1, 0x32083184, 0x55be138f, 0x67b6fcca, 0x01b0d5ff, 0x33b83aba, 0x540e18b1, 0x6606f7f4}, - [16]uint32{0x00000000, 0x161c41de, 0x001700a3, 0x160b417d, 0x000011af, 0x161c5071, 0x0017110c, 0x160b50d2, 0x004881fa, 0x1654c024, 0x005f8159, 0x1643c087, 0x00489055, 0x1654d18b, 0x005f90f6, 0x1643d128}, - [16]uint32{0x3f800000, 0x3f8b0e20, 0x3f800b80, 0x3f8b05a0, 0x3f800008, 0x3f8b0e28, 0x3f800b88, 0x3f8b05a8, 0x3f802440, 0x3f8b2a60, 0x3f802fc0, 0x3f8b21e0, 0x3f802448, 0x3f8b2a68, 0x3f802fc8, 0x3f8b21e8}, - uint32(0xfff80000), - [21]string{"0x74", "0xa1", "0xe2", "0x05", "0xf7", "0x40", "0x90", "0xcb", "0x54", "0x07", "0x93", "0x7a", "0xc0", "0xc1", "0x78", "0x0e", "0x6d", "0x04", "0xcc", "0x35", "0x00"}}, - { - /* No.180 delta:1121 weight:1579 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x505c5b53, 0xcdee4615, 0x9db21d46, 0xa8400b4c, 0xf81c501f, 0x65ae4d59, 0x35f2160a, 0x00007394, 0x505c28c7, 0xcdee3581, 0x9db26ed2, 0xa84078d8, 0xf81c238b, 0x65ae3ecd, 0x35f2659e}, - [16]uint32{0x00000000, 0x007e01b6, 0x0003c171, 0x007dc0c7, 0x2011c062, 0x206fc1d4, 0x20120113, 0x206c00a5, 0x00003018, 0x007e31ae, 0x0003f169, 0x007df0df, 0x2011f07a, 0x206ff1cc, 0x2012310b, 0x206c30bd}, - [16]uint32{0x3f800000, 0x3f803f00, 0x3f8001e0, 0x3f803ee0, 0x3f9008e0, 0x3f9037e0, 0x3f900900, 0x3f903600, 0x3f800018, 0x3f803f18, 0x3f8001f8, 0x3f803ef8, 0x3f9008f8, 0x3f9037f8, 0x3f900918, 0x3f903618}, - uint32(0xfff80000), - [21]string{"0x20", "0x14", "0xed", "0x53", "0xf0", "0xa3", "0x58", "0x5e", "0x39", "0x5c", "0x10", "0x47", "0x72", "0x36", "0x5d", "0x27", "0xd4", "0x0a", "0x93", "0x09", "0x00"}}, - { - /* No.181 delta:1270 weight:1603 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0x77d67f0d, 0x76f2a9b5, 0x0124d6b8, 0x83500b50, 0xf486745d, 0xf5a2a2e5, 0x8274dde8, 0x00005afa, 0x77d625f7, 0x76f2f34f, 0x01248c42, 0x835051aa, 0xf4862ea7, 0xf5a2f81f, 0x82748712}, - [16]uint32{0x00000000, 0x08261d9a, 0x2049a073, 0x286fbde9, 0x006e03e7, 0x08481e7d, 0x2027a394, 0x2801be0e, 0x3008601b, 0x382e7d81, 0x1041c068, 0x1867ddf2, 0x306663fc, 0x38407e66, 0x102fc38f, 0x1809de15}, - [16]uint32{0x3f800000, 0x3f84130e, 0x3f9024d0, 0x3f9437de, 0x3f803701, 0x3f84240f, 0x3f9013d1, 0x3f9400df, 0x3f980430, 0x3f9c173e, 0x3f8820e0, 0x3f8c33ee, 0x3f983331, 0x3f9c203f, 0x3f8817e1, 0x3f8c04ef}, - uint32(0xfff80000), - [21]string{"0xdc", "0x4d", "0x79", "0x4b", "0xba", "0xd4", "0x51", "0x7b", "0x82", "0x70", "0x29", "0xec", "0xaa", "0x5c", "0xe7", "0x0b", "0x6f", "0xb9", "0x88", "0x84", "0x00"}}, - { - /* No.182 delta:1434 weight:1199 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x7c783189, 0xe762da2e, 0x9b1aeba7, 0x73c00b6d, 0x0fb83ae4, 0x94a2d143, 0xe8dae0ca, 0x0000f2df, 0x7c78c356, 0xe76228f1, 0x9b1a1978, 0x73c0f9b2, 0x0fb8c83b, 0x94a2239c, 0xe8da1215}, - [16]uint32{0x00000000, 0x20020696, 0x016200f4, 0x21600662, 0x540020c7, 0x74022651, 0x55622033, 0x756026a5, 0x0400806b, 0x240286fd, 0x0562809f, 0x25608609, 0x5000a0ac, 0x7002a63a, 0x5162a058, 0x7160a6ce}, - [16]uint32{0x3f800000, 0x3f900103, 0x3f80b100, 0x3f90b003, 0x3faa0010, 0x3fba0113, 0x3faab110, 0x3fbab013, 0x3f820040, 0x3f920143, 0x3f82b140, 0x3f92b043, 0x3fa80050, 0x3fb80153, 0x3fa8b150, 0x3fb8b053}, - uint32(0xfff80000), - [21]string{"0xf6", "0x60", "0xc0", "0x9d", "0x81", "0x56", "0xe5", "0x79", "0x7c", "0xcb", "0xee", "0x7a", "0xd9", "0x6a", "0x60", "0x34", "0x7d", "0x2f", "0x65", "0xe0", "0x00"}}, - { - /* No.183 delta:1029 weight:1561 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0xfd44e4d2, 0xf1f56eb4, 0x0cb18a66, 0x2ba00b7e, 0xd6e4efac, 0xda5565ca, 0x27118118, 0x0000dc8f, 0xfd44385d, 0xf1f5b23b, 0x0cb156e9, 0x2ba0d7f1, 0xd6e43323, 0xda55b945, 0x27115d97}, - [16]uint32{0x00000000, 0x007c21fe, 0x100400cc, 0x10782132, 0x000310e7, 0x007f3119, 0x1007102b, 0x107b31d5, 0x0000181a, 0x007c39e4, 0x100418d6, 0x10783928, 0x000308fd, 0x007f2903, 0x10070831, 0x107b29cf}, - [16]uint32{0x3f800000, 0x3f803e10, 0x3f880200, 0x3f883c10, 0x3f800188, 0x3f803f98, 0x3f880388, 0x3f883d98, 0x3f80000c, 0x3f803e1c, 0x3f88020c, 0x3f883c1c, 0x3f800184, 0x3f803f94, 0x3f880384, 0x3f883d94}, - uint32(0xfff80000), - [21]string{"0xe5", "0x4f", "0x1f", "0x15", "0xf6", "0x89", "0xa6", "0xd9", "0x04", "0xe3", "0xd0", "0x6e", "0x01", "0x48", "0x08", "0x36", "0x7f", "0x71", "0x9a", "0x8d", "0x00"}}, - { - /* No.184 delta:624 weight:1571 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xcfea1ce0, 0x16085e8e, 0xd9e2426e, 0x11500b80, 0xdeba1760, 0x0758550e, 0xc8b249ee, 0x000041d7, 0xcfea5d37, 0x16081f59, 0xd9e203b9, 0x11504a57, 0xdeba56b7, 0x075814d9, 0xc8b20839}, - [16]uint32{0x00000000, 0x1079913a, 0x000328c7, 0x107ab9fd, 0x4062f00b, 0x501b6131, 0x4061d8cc, 0x501849f6, 0x90240809, 0x805d9933, 0x902720ce, 0x805eb1f4, 0xd046f802, 0xc03f6938, 0xd045d0c5, 0xc03c41ff}, - [16]uint32{0x3f800000, 0x3f883cc8, 0x3f800194, 0x3f883d5c, 0x3fa03178, 0x3fa80db0, 0x3fa030ec, 0x3fa80c24, 0x3fc81204, 0x3fc02ecc, 0x3fc81390, 0x3fc02f58, 0x3fe8237c, 0x3fe01fb4, 0x3fe822e8, 0x3fe01e20}, - uint32(0xfff80000), - [21]string{"0x51", "0x66", "0xe5", "0x17", "0xfb", "0x72", "0x1d", "0x3c", "0xa5", "0xf3", "0x76", "0x62", "0x85", "0x05", "0xb1", "0xaa", "0x24", "0xe7", "0x36", "0xc5", "0x00"}}, - { - /* No.185 delta:1091 weight:1671 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0x280b74b6, 0x7d7b3c94, 0x55704822, 0xece00b99, 0xc4eb7f2f, 0x919b370d, 0xb99043bb, 0x0000dbc1, 0x280baf77, 0x7d7be755, 0x557093e3, 0xece0d058, 0xc4eba4ee, 0x919beccc, 0xb990987a}, - [16]uint32{0x00000000, 0x300c001a, 0x0042b911, 0x304eb90b, 0x00418416, 0x304d840c, 0x00033d07, 0x300f3d1d, 0x6000c7a3, 0x500cc7b9, 0x60427eb2, 0x504e7ea8, 0x604143b5, 0x504d43af, 0x6003faa4, 0x500ffabe}, - [16]uint32{0x3f800000, 0x3f980600, 0x3f80215c, 0x3f98275c, 0x3f8020c2, 0x3f9826c2, 0x3f80019e, 0x3f98079e, 0x3fb00063, 0x3fa80663, 0x3fb0213f, 0x3fa8273f, 0x3fb020a1, 0x3fa826a1, 0x3fb001fd, 0x3fa807fd}, - uint32(0xfff80000), - [21]string{"0xf2", "0xd6", "0x37", "0x24", "0x51", "0x91", "0xc6", "0x90", "0xa9", "0xbc", "0x8d", "0x34", "0x24", "0xf7", "0xee", "0x28", "0xd5", "0xf8", "0xe1", "0xfe", "0x00"}}, - { - /* No.186 delta:1106 weight:1387 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0xd113dd47, 0xed0d5ed0, 0x3c1e8397, 0xbd300bac, 0x6c23d6eb, 0x503d557c, 0x812e883b, 0x00000b0f, 0xd113d648, 0xed0d55df, 0x3c1e8898, 0xbd3000a3, 0x6c23dde4, 0x503d5e73, 0x812e8334}, - [16]uint32{0x00000000, 0x005ef41e, 0x70252012, 0x707bd40c, 0x00051809, 0x005bec17, 0x7020381b, 0x707ecc05, 0x1046212d, 0x1018d533, 0x6063013f, 0x603df521, 0x10433924, 0x101dcd3a, 0x60661936, 0x6038ed28}, - [16]uint32{0x3f800000, 0x3f802f7a, 0x3fb81290, 0x3fb83dea, 0x3f80028c, 0x3f802df6, 0x3fb8101c, 0x3fb83f66, 0x3f882310, 0x3f880c6a, 0x3fb03180, 0x3fb01efa, 0x3f88219c, 0x3f880ee6, 0x3fb0330c, 0x3fb01c76}, - uint32(0xfff80000), - [21]string{"0x89", "0xd2", "0x06", "0x89", "0xe4", "0xb6", "0x3e", "0xc0", "0x18", "0xec", "0x1d", "0x2c", "0x18", "0xf9", "0xa8", "0x97", "0x03", "0x1e", "0xe8", "0x52", "0x00"}}, - { - /* No.187 delta:1132 weight:1531 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x8fdbb324, 0x981dfafd, 0x17c649d9, 0x40600bb8, 0xcfbbb89c, 0xd87df145, 0x57a64261, 0x00002fea, 0x8fdb9cce, 0x981dd517, 0x17c66633, 0x40602452, 0xcfbb9776, 0xd87ddeaf, 0x57a66d8b}, - [16]uint32{0x00000000, 0x0839de56, 0x107c681f, 0x1845b649, 0x0041500e, 0x08788e58, 0x103d3811, 0x1804e647, 0x00641053, 0x085dce05, 0x1018784c, 0x1821a61a, 0x0025405d, 0x081c9e0b, 0x10592842, 0x1860f614}, - [16]uint32{0x3f800000, 0x3f841cef, 0x3f883e34, 0x3f8c22db, 0x3f8020a8, 0x3f843c47, 0x3f881e9c, 0x3f8c0273, 0x3f803208, 0x3f842ee7, 0x3f880c3c, 0x3f8c10d3, 0x3f8012a0, 0x3f840e4f, 0x3f882c94, 0x3f8c307b}, - uint32(0xfff80000), - [21]string{"0x2a", "0x5f", "0x68", "0xfa", "0xbd", "0xf8", "0x19", "0xd5", "0x40", "0xb1", "0x39", "0x22", "0x43", "0xa7", "0xcc", "0xd9", "0x05", "0x43", "0x7c", "0x15", "0x00"}}, - { - /* No.188 delta:1040 weight:1601 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0xad234f29, 0xa8c21258, 0x05e15d71, 0xe5c00bc2, 0x48e344eb, 0x4d02199a, 0xe02156b3, 0x000075a9, 0xad233a80, 0xa8c267f1, 0x05e128d8, 0xe5c07e6b, 0x48e33142, 0x4d026c33, 0xe021231a}, - [16]uint32{0x00000000, 0x003d9c1e, 0x0002b01c, 0x003f2c02, 0x21008014, 0x213d1c0a, 0x21023008, 0x213fac16, 0x403c040f, 0x40019811, 0x403eb413, 0x4003280d, 0x613c841b, 0x61011805, 0x613e3407, 0x6103a819}, - [16]uint32{0x3f800000, 0x3f801ece, 0x3f800158, 0x3f801f96, 0x3f908040, 0x3f909e8e, 0x3f908118, 0x3f909fd6, 0x3fa01e02, 0x3fa000cc, 0x3fa01f5a, 0x3fa00194, 0x3fb09e42, 0x3fb0808c, 0x3fb09f1a, 0x3fb081d4}, - uint32(0xfff80000), - [21]string{"0x3e", "0xa4", "0x26", "0xb3", "0x94", "0x22", "0x87", "0xf4", "0x15", "0x2e", "0x07", "0x74", "0xc9", "0xee", "0xfe", "0x50", "0xc9", "0x7a", "0x8c", "0x37", "0x00"}}, - { - /* No.189 delta:733 weight:1605 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x11d23732, 0xb9ce7b60, 0xa81c4c52, 0x9ed00bde, 0x8f023cec, 0x271e70be, 0x36cc478c, 0x00007cb5, 0x11d24b87, 0xb9ce07d5, 0xa81c30e7, 0x9ed0776b, 0x8f024059, 0x271e0c0b, 0x36cc3b39}, - [16]uint32{0x00000000, 0x2802001b, 0x500081d1, 0x780281ca, 0x00023165, 0x2800317e, 0x5002b0b4, 0x7800b0af, 0x20001618, 0x08021603, 0x700097c9, 0x580297d2, 0x2002277d, 0x08002766, 0x7002a6ac, 0x5800a6b7}, - [16]uint32{0x3f800000, 0x3f940100, 0x3fa80040, 0x3fbc0140, 0x3f800118, 0x3f940018, 0x3fa80158, 0x3fbc0058, 0x3f90000b, 0x3f84010b, 0x3fb8004b, 0x3fac014b, 0x3f900113, 0x3f840013, 0x3fb80153, 0x3fac0053}, - uint32(0xfff80000), - [21]string{"0x99", "0x50", "0x99", "0xc6", "0x2d", "0x5d", "0x37", "0x23", "0x1e", "0xc8", "0x4e", "0x80", "0xad", "0xdc", "0xfc", "0x85", "0x61", "0x88", "0x59", "0x55", "0x00"}}, - { - /* No.190 delta:841 weight:1165 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0x7f42d515, 0x73d3e490, 0x0c913185, 0x38e00be1, 0x47a2def4, 0x4b33ef71, 0x34713a64, 0x00001fa0, 0x7f42cab5, 0x73d3fb30, 0x0c912e25, 0x38e01441, 0x47a2c154, 0x4b33f0d1, 0x347125c4}, - [16]uint32{0x00000000, 0x382491de, 0x704f89b9, 0x486b1867, 0x000206bf, 0x38269761, 0x704d8f06, 0x48691ed8, 0x1003c19d, 0x28275043, 0x604c4824, 0x5868d9fa, 0x1001c722, 0x282556fc, 0x604e4e9b, 0x586adf45}, - [16]uint32{0x3f800000, 0x3f9c1248, 0x3fb827c4, 0x3fa4358c, 0x3f800103, 0x3f9c134b, 0x3fb826c7, 0x3fa4348f, 0x3f8801e0, 0x3f9413a8, 0x3fb02624, 0x3fac346c, 0x3f8800e3, 0x3f9412ab, 0x3fb02727, 0x3fac356f}, - uint32(0xfff80000), - [21]string{"0x9c", "0xba", "0x5c", "0x8d", "0x1f", "0x35", "0x67", "0xd1", "0x3e", "0xfd", "0xeb", "0xad", "0x1a", "0x7d", "0xa1", "0xdb", "0x36", "0x7a", "0x53", "0xdb", "0x00"}}, - { - /* No.191 delta:684 weight:1773 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0x1a68bb25, 0x99cfab64, 0x83a71041, 0xf5400bf8, 0xef28b0dd, 0x6c8fa09c, 0x76e71bb9, 0x00000bdb, 0x1a68b0fe, 0x99cfa0bf, 0x83a71b9a, 0xf5400023, 0xef28bb06, 0x6c8fab47, 0x76e71062}, - [16]uint32{0x00000000, 0x680ca41d, 0x400338c9, 0x280f9cd4, 0x1003415e, 0x780fe543, 0x50007997, 0x380cdd8a, 0x000300b2, 0x680fa4af, 0x4000387b, 0x280c9c66, 0x100041ec, 0x780ce5f1, 0x50037925, 0x380fdd38}, - [16]uint32{0x3f800000, 0x3fb40652, 0x3fa0019c, 0x3f9407ce, 0x3f8801a0, 0x3fbc07f2, 0x3fa8003c, 0x3f9c066e, 0x3f800180, 0x3fb407d2, 0x3fa0001c, 0x3f94064e, 0x3f880020, 0x3fbc0672, 0x3fa801bc, 0x3f9c07ee}, - uint32(0xfff80000), - [21]string{"0x57", "0xb1", "0x39", "0xad", "0x77", "0xf6", "0x11", "0xab", "0x8e", "0x87", "0xbd", "0x92", "0xe6", "0x1c", "0x36", "0x3f", "0x11", "0x36", "0x4b", "0x13", "0x00"}}, - { - /* No.192 delta:760 weight:1213 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xa615d0a5, 0x36265494, 0x90338431, 0x4cc00c07, 0xead5dca2, 0x7ae65893, 0xdcf38836, 0x0000b3d1, 0xa6156374, 0x3626e745, 0x903337e0, 0x4cc0bfd6, 0xead56f73, 0x7ae6eb42, 0xdcf33be7}, - [16]uint32{0x00000000, 0x103e2c7e, 0x400109b1, 0x503f25cf, 0x00023c18, 0x103c1066, 0x400335a9, 0x503d19d7, 0x5040180c, 0x407e3472, 0x104111bd, 0x007f3dc3, 0x50422414, 0x407c086a, 0x10432da5, 0x007d01db}, - [16]uint32{0x3f800000, 0x3f881f16, 0x3fa00084, 0x3fa81f92, 0x3f80011e, 0x3f881e08, 0x3fa0019a, 0x3fa81e8c, 0x3fa8200c, 0x3fa03f1a, 0x3f882088, 0x3f803f9e, 0x3fa82112, 0x3fa03e04, 0x3f882196, 0x3f803e80}, - uint32(0xfff80000), - [21]string{"0xd8", "0xc1", "0x31", "0x89", "0x51", "0xc4", "0x64", "0x36", "0x0a", "0x93", "0x66", "0x13", "0xb2", "0x95", "0xaa", "0xc1", "0xc3", "0xc0", "0xb8", "0x8b", "0x00"}}, - { - /* No.193 delta:1152 weight:1405 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x2a562cc2, 0x5301e69e, 0x7957ca5c, 0x56500c10, 0x7c0620d2, 0x0551ea8e, 0x2f07c64c, 0x00005e85, 0x2a567247, 0x5301b81b, 0x795794d9, 0x56505295, 0x7c067e57, 0x0551b40b, 0x2f0798c9}, - [16]uint32{0x00000000, 0x0074a472, 0x002b317b, 0x005f9509, 0x000845d7, 0x007ce1a5, 0x002374ac, 0x0057d0de, 0x188c149f, 0x18f8b0ed, 0x18a725e4, 0x18d38196, 0x18845148, 0x18f0f53a, 0x18af6033, 0x18dbc441}, - [16]uint32{0x3f800000, 0x3f803a52, 0x3f801598, 0x3f802fca, 0x3f800422, 0x3f803e70, 0x3f8011ba, 0x3f802be8, 0x3f8c460a, 0x3f8c7c58, 0x3f8c5392, 0x3f8c69c0, 0x3f8c4228, 0x3f8c787a, 0x3f8c57b0, 0x3f8c6de2}, - uint32(0xfff80000), - [21]string{"0xd9", "0x61", "0xf1", "0xb6", "0x98", "0x11", "0x7c", "0xe3", "0x44", "0x58", "0xdf", "0x98", "0xd0", "0xad", "0x22", "0x7d", "0x82", "0x7f", "0x7d", "0x68", "0x00"}}, - { - /* No.194 delta:830 weight:741 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x8cd9e453, 0xa9431e7a, 0x259afa29, 0xb3700c2d, 0x3fa9e87e, 0x1a331257, 0x96eaf604, 0x0000f7a7, 0x8cd913f4, 0xa943e9dd, 0x259a0d8e, 0xb370fb8a, 0x3fa91fd9, 0x1a33e5f0, 0x96ea01a3}, - [16]uint32{0x00000000, 0x90a5295b, 0x204211b1, 0xb0e738ea, 0x40400013, 0xd0e52948, 0x600211a2, 0xf0a738f9, 0x20205854, 0xb085710f, 0x006249e5, 0x90c760be, 0x60605847, 0xf0c5711c, 0x402249f6, 0xd08760ad}, - [16]uint32{0x3f800000, 0x3fc85294, 0x3f902108, 0x3fd8739c, 0x3fa02000, 0x3fe87294, 0x3fb00108, 0x3ff8539c, 0x3f90102c, 0x3fd842b8, 0x3f803124, 0x3fc863b0, 0x3fb0302c, 0x3ff862b8, 0x3fa01124, 0x3fe843b0}, - uint32(0xfff80000), - [21]string{"0x48", "0x4b", "0x3d", "0x12", "0xa2", "0x94", "0xb1", "0x8c", "0xf5", "0xfb", "0xa5", "0xaf", "0x07", "0xa0", "0xdb", "0xe9", "0xfa", "0x44", "0xed", "0xb7", "0x00"}}, - { - /* No.195 delta:2879 weight:775 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0xff682600, 0xf74c4baa, 0x08246daa, 0x24100c3b, 0xdb782a3b, 0xd35c4791, 0x2c346191, 0x0000ffe5, 0xff68d9e5, 0xf74cb44f, 0x0824924f, 0x2410f3de, 0xdb78d5de, 0xd35cb874, 0x2c349e74}, - [16]uint32{0x00000000, 0xc030959e, 0x9050a099, 0x50603507, 0x802601ba, 0x40169424, 0x1076a123, 0xd04634bd, 0xf014ce13, 0x30245b8d, 0x60446e8a, 0xa074fb14, 0x7032cfa9, 0xb0025a37, 0xe0626f30, 0x2052faae}, - [16]uint32{0x3f800000, 0x3fe0184a, 0x3fc82850, 0x3fa8301a, 0x3fc01300, 0x3fa00b4a, 0x3f883b50, 0x3fe8231a, 0x3ff80a67, 0x3f98122d, 0x3fb02237, 0x3fd03a7d, 0x3fb81967, 0x3fd8012d, 0x3ff03137, 0x3f90297d}, - uint32(0xfff80000), - [21]string{"0x3d", "0xf6", "0x9a", "0x6e", "0x6b", "0x65", "0x93", "0x08", "0x5e", "0x4b", "0x6a", "0x30", "0xfd", "0x5d", "0x93", "0x81", "0x59", "0xda", "0xe1", "0x46", "0x00"}}, - { - /* No.196 delta:949 weight:1287 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x7d54e010, 0x9f44b63a, 0xe210562a, 0xd9500c42, 0xa404ec52, 0x4614ba78, 0x3b405a68, 0x0000e124, 0x7d540134, 0x9f44571e, 0xe210b70e, 0xd950ed66, 0xa4040d76, 0x46145b5c, 0x3b40bb4c}, - [16]uint32{0x00000000, 0x207e16bb, 0x1030a309, 0x304eb5b2, 0x0063c14f, 0x201dd7f4, 0x10536246, 0x302d74fd, 0x0002a401, 0x207cb2ba, 0x10320708, 0x304c11b3, 0x0061654e, 0x201f73f5, 0x1051c647, 0x302fd0fc}, - [16]uint32{0x3f800000, 0x3f903f0b, 0x3f881851, 0x3f98275a, 0x3f8031e0, 0x3f900eeb, 0x3f8829b1, 0x3f9816ba, 0x3f800152, 0x3f903e59, 0x3f881903, 0x3f982608, 0x3f8030b2, 0x3f900fb9, 0x3f8828e3, 0x3f9817e8}, - uint32(0xfff80000), - [21]string{"0xef", "0x4e", "0xef", "0x76", "0x36", "0xad", "0x27", "0xbf", "0xbe", "0xf2", "0xb6", "0x37", "0x72", "0xee", "0x0d", "0xf6", "0xc0", "0x73", "0x4e", "0xcb", "0x00"}}, - { - /* No.197 delta:1232 weight:1565 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x03ab6700, 0x3a6567b0, 0x39ce00b0, 0x81b00c5d, 0x821b6b5d, 0xbbd56bed, 0xb87e0ced, 0x0000770e, 0x03ab100e, 0x3a6510be, 0x39ce77be, 0x81b07b53, 0x821b1c53, 0xbbd51ce3, 0xb87e7be3}, - [16]uint32{0x00000000, 0x202e803a, 0x0002114e, 0x202c9174, 0x80382018, 0xa016a022, 0x803a3156, 0xa014b16c, 0x406830c8, 0x6046b0f2, 0x406a2186, 0x6044a1bc, 0xc05010d0, 0xe07e90ea, 0xc052019e, 0xe07c81a4}, - [16]uint32{0x3f800000, 0x3f901740, 0x3f800108, 0x3f901648, 0x3fc01c10, 0x3fd00b50, 0x3fc01d18, 0x3fd00a58, 0x3fa03418, 0x3fb02358, 0x3fa03510, 0x3fb02250, 0x3fe02808, 0x3ff03f48, 0x3fe02900, 0x3ff03e40}, - uint32(0xfff80000), - [21]string{"0x0f", "0xde", "0x34", "0x7f", "0xb2", "0x37", "0x9a", "0xef", "0x08", "0x8e", "0x0d", "0x5d", "0x68", "0xdf", "0xfd", "0x51", "0x8e", "0xe6", "0x31", "0x13", "0x00"}}, - { - /* No.198 delta:2483 weight:1073 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0x61924bce, 0x6cc60700, 0x0d544cce, 0x93700c63, 0xf2e247ad, 0xffb60b63, 0x9e2440ad, 0x00001b81, 0x6192504f, 0x6cc61c81, 0x0d54574f, 0x937017e2, 0xf2e25c2c, 0xffb610e2, 0x9e245b2c}, - [16]uint32{0x00000000, 0x83d01574, 0x1b0a01de, 0x98da14aa, 0x0e262003, 0x8df63577, 0x152c21dd, 0x96fc34a9, 0x1e181411, 0x9dc80165, 0x051215cf, 0x86c200bb, 0x103e3412, 0x93ee2166, 0x0b3435cc, 0x88e420b8}, - [16]uint32{0x3f800000, 0x3fc1e80a, 0x3f8d8500, 0x3fcc6d0a, 0x3f871310, 0x3fc6fb1a, 0x3f8a9610, 0x3fcb7e1a, 0x3f8f0c0a, 0x3fcee400, 0x3f82890a, 0x3fc36100, 0x3f881f1a, 0x3fc9f710, 0x3f859a1a, 0x3fc47210}, - uint32(0xfff80000), - [21]string{"0xa6", "0x78", "0x00", "0x0c", "0x62", "0x97", "0x94", "0x6c", "0xb7", "0xf6", "0xbc", "0x41", "0xb1", "0x29", "0xe5", "0x9c", "0x5f", "0x37", "0xaa", "0x79", "0x00"}}, - { - /* No.199 delta:3090 weight:657 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x4b70564e, 0x58ad48a7, 0x13dd1ee9, 0xbaa00c75, 0xf1d05a3b, 0xe20d44d2, 0xa97d129c, 0x0000d9bf, 0x4b708ff1, 0x58ad9118, 0x13ddc756, 0xbaa0d5ca, 0xf1d08384, 0xe20d9d6d, 0xa97dcb23}, - [16]uint32{0x00000000, 0xb0f01e5e, 0x08c04155, 0xb8305f0b, 0xc0085078, 0x70f84e26, 0xc8c8112d, 0x78380f73, 0x3618200f, 0x86e83e51, 0x3ed8615a, 0x8e287f04, 0xf6107077, 0x46e06e29, 0xfed03122, 0x4e202f7c}, - [16]uint32{0x3f800000, 0x3fd8780f, 0x3f846020, 0x3fdc182f, 0x3fe00428, 0x3fb87c27, 0x3fe46408, 0x3fbc1c07, 0x3f9b0c10, 0x3fc3741f, 0x3f9f6c30, 0x3fc7143f, 0x3ffb0838, 0x3fa37037, 0x3fff6818, 0x3fa71017}, - uint32(0xfff80000), - [21]string{"0x77", "0x27", "0xbd", "0xef", "0xef", "0x2a", "0x66", "0xc1", "0xb7", "0x5e", "0x51", "0x52", "0x94", "0xd0", "0xf8", "0x35", "0xfa", "0x0d", "0x43", "0x0a", "0x00"}}, - { - /* No.200 delta:740 weight:741 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x8f869099, 0x3346f936, 0xbcc069af, 0x55700c8a, 0xdaf69c13, 0x6636f5bc, 0xe9b06525, 0x000036a5, 0x8f86a63c, 0x3346cf93, 0xbcc05f0a, 0x55703a2f, 0xdaf6aab6, 0x6636c319, 0xe9b05380}, - [16]uint32{0x00000000, 0x704c0036, 0x20620511, 0x502e0527, 0x103101cb, 0x607d01fd, 0x305304da, 0x401f04ec, 0x6003a014, 0x104fa022, 0x4061a505, 0x302da533, 0x7032a1df, 0x007ea1e9, 0x5050a4ce, 0x201ca4f8}, - [16]uint32{0x3f800000, 0x3fb82600, 0x3f903102, 0x3fa81702, 0x3f881880, 0x3fb03e80, 0x3f982982, 0x3fa00f82, 0x3fb001d0, 0x3f8827d0, 0x3fa030d2, 0x3f9816d2, 0x3fb81950, 0x3f803f50, 0x3fa82852, 0x3f900e52}, - uint32(0xfff80000), - [21]string{"0xf2", "0xbb", "0xb7", "0x23", "0x62", "0xc4", "0x51", "0x55", "0x4e", "0xfd", "0x6a", "0xa0", "0x00", "0x9a", "0x5f", "0x5c", "0xc9", "0x8b", "0xe1", "0xad", "0x00"}}, - { - /* No.201 delta:1425 weight:1547 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0x135e711b, 0x4f1a6841, 0x5c44195a, 0x29b00c9f, 0x3aee7d84, 0x66aa64de, 0x75f415c5, 0x0000262f, 0x135e5734, 0x4f1a4e6e, 0x5c443f75, 0x29b02ab0, 0x3aee5bab, 0x66aa42f1, 0x75f433ea}, - [16]uint32{0x00000000, 0x2ced025e, 0x33d864e2, 0x1f3566bc, 0x0052e20a, 0x2cbfe054, 0x338a86e8, 0x1f6784b6, 0x004c5c0d, 0x2ca15e53, 0x339438ef, 0x1f793ab1, 0x001ebe07, 0x2cf3bc59, 0x33c6dae5, 0x1f2bd8bb}, - [16]uint32{0x3f800000, 0x3f967681, 0x3f99ec32, 0x3f8f9ab3, 0x3f802971, 0x3f965ff0, 0x3f99c543, 0x3f8fb3c2, 0x3f80262e, 0x3f9650af, 0x3f99ca1c, 0x3f8fbc9d, 0x3f800f5f, 0x3f9679de, 0x3f99e36d, 0x3f8f95ec}, - uint32(0xfff80000), - [21]string{"0x2e", "0x3f", "0x27", "0x5d", "0xc5", "0x8f", "0xb5", "0x58", "0xd9", "0x3d", "0x14", "0x9e", "0x59", "0x07", "0x1b", "0x89", "0xab", "0xd6", "0x1b", "0x36", "0x00"}}, - { - /* No.202 delta:1120 weight:1567 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0xac59e4f5, 0x4a749b39, 0xe62d7fcc, 0x14200cad, 0xb879e858, 0x5e549794, 0xf20d7361, 0x000000e9, 0xac59e41c, 0x4a749bd0, 0xe62d7f25, 0x14200c44, 0xb879e8b1, 0x5e54977d, 0xf20d7388}, - [16]uint32{0x00000000, 0x007c19d6, 0x000240f9, 0x007e592f, 0x0023e00b, 0x005ff9dd, 0x0021a0f2, 0x005db924, 0x1041101f, 0x103d09c9, 0x104350e6, 0x103f4930, 0x1062f014, 0x101ee9c2, 0x1060b0ed, 0x101ca93b}, - [16]uint32{0x3f800000, 0x3f803e0c, 0x3f800120, 0x3f803f2c, 0x3f8011f0, 0x3f802ffc, 0x3f8010d0, 0x3f802edc, 0x3f882088, 0x3f881e84, 0x3f8821a8, 0x3f881fa4, 0x3f883178, 0x3f880f74, 0x3f883058, 0x3f880e54}, - uint32(0xfff80000), - [21]string{"0xea", "0x36", "0xa9", "0xe3", "0x3a", "0x26", "0xb0", "0x23", "0x4f", "0xf2", "0x04", "0xc7", "0x80", "0x6f", "0x26", "0x1b", "0xc0", "0xd5", "0x12", "0x07", "0x00"}}, - { - /* No.203 delta:753 weight:719 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x1ff43116, 0x3ca75344, 0x23536252, 0xac600cb8, 0xb3943dae, 0x90c75ffc, 0x8f336eea, 0x0000ec4c, 0x1ff4dd5a, 0x3ca7bf08, 0x23538e1e, 0xac60e0f4, 0xb394d1e2, 0x90c7b3b0, 0x8f3382a6}, - [16]uint32{0x00000000, 0x4044a13d, 0x202280c3, 0x606621fe, 0x5013e1ba, 0x10574087, 0x70316179, 0x3075c044, 0x300809f5, 0x704ca8c8, 0x102a8936, 0x506e280b, 0x601be84f, 0x205f4972, 0x4039688c, 0x007dc9b1}, - [16]uint32{0x3f800000, 0x3fa02250, 0x3f901140, 0x3fb03310, 0x3fa809f0, 0x3f882ba0, 0x3fb818b0, 0x3f983ae0, 0x3f980404, 0x3fb82654, 0x3f881544, 0x3fa83714, 0x3fb00df4, 0x3f902fa4, 0x3fa01cb4, 0x3f803ee4}, - uint32(0xfff80000), - [21]string{"0x67", "0xa5", "0xb8", "0x3b", "0xd2", "0xe3", "0x32", "0x76", "0x7e", "0x2c", "0xc8", "0x24", "0x35", "0x26", "0x61", "0x3e", "0x98", "0x93", "0xaa", "0x04", "0x00"}}, - { - /* No.204 delta:2490 weight:1505 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0x5eafb656, 0xb33f8c5e, 0xed903a08, 0x1c600ccc, 0x42cfba9a, 0xaf5f8092, 0xf1f036c4, 0x000062ca, 0x5eafd49c, 0xb33fee94, 0xed9058c2, 0x1c606e06, 0x42cfd850, 0xaf5fe258, 0xf1f0540e}, - [16]uint32{0x00000000, 0x3002c1b3, 0x000251dd, 0x3000906e, 0x40008016, 0x700241a5, 0x4002d1cb, 0x70001078, 0x0001935a, 0x300352e9, 0x0003c287, 0x30010334, 0x4001134c, 0x7003d2ff, 0x40034291, 0x70018322}, - [16]uint32{0x3f800000, 0x3f980160, 0x3f800128, 0x3f980048, 0x3fa00040, 0x3fb80120, 0x3fa00168, 0x3fb80008, 0x3f8000c9, 0x3f9801a9, 0x3f8001e1, 0x3f980081, 0x3fa00089, 0x3fb801e9, 0x3fa001a1, 0x3fb800c1}, - uint32(0xfff80000), - [21]string{"0x1e", "0x97", "0x10", "0x94", "0x21", "0xb5", "0xf6", "0x23", "0xac", "0xeb", "0x87", "0x1b", "0xfe", "0x7d", "0x9a", "0xb2", "0xe0", "0x55", "0x2e", "0x99", "0x00"}}, - { - /* No.205 delta:1418 weight:1259 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0xb013d5ad, 0x92b7f4e1, 0x22a4214c, 0xee400cdd, 0x5e53d970, 0x7cf7f83c, 0xcce42d91, 0x00002e80, 0xb013fb2d, 0x92b7da61, 0x22a40fcc, 0xee40225d, 0x5e53f7f0, 0x7cf7d6bc, 0xcce40311}, - [16]uint32{0x00000000, 0x004280f7, 0x200501c2, 0x20478135, 0x1000018b, 0x1042817c, 0x30050049, 0x304780be, 0x100301d1, 0x10418126, 0x30060013, 0x304480e4, 0x0003005a, 0x004180ad, 0x20060198, 0x2044816f}, - [16]uint32{0x3f800000, 0x3f802140, 0x3f900280, 0x3f9023c0, 0x3f880000, 0x3f882140, 0x3f980280, 0x3f9823c0, 0x3f880180, 0x3f8820c0, 0x3f980300, 0x3f982240, 0x3f800180, 0x3f8020c0, 0x3f900300, 0x3f902240}, - uint32(0xfff80000), - [21]string{"0x9c", "0x84", "0x7d", "0x4e", "0xc8", "0xee", "0xe3", "0x0a", "0x73", "0x0a", "0x36", "0x27", "0x06", "0xf5", "0x9b", "0x70", "0xdb", "0x20", "0xd2", "0x7c", "0x00"}}, - { - /* No.206 delta:835 weight:1117 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0xabe51a17, 0x92f9658b, 0x391c7f9c, 0xf5300cec, 0x5ed516fb, 0x67c96967, 0xcc2c7370, 0x0000c823, 0xabe5d234, 0x92f9ada8, 0x391cb7bf, 0xf530c4cf, 0x5ed5ded8, 0x67c9a144, 0xcc2cbb53}, - [16]uint32{0x00000000, 0xc000201f, 0x00020415, 0xc002240a, 0x1000820c, 0xd000a213, 0x10028619, 0xd002a606, 0x60004812, 0xa000680d, 0x60024c07, 0xa0026c18, 0x7000ca1e, 0xb000ea01, 0x7002ce0b, 0xb002ee14}, - [16]uint32{0x3f800000, 0x3fe00010, 0x3f800102, 0x3fe00112, 0x3f880041, 0x3fe80051, 0x3f880143, 0x3fe80153, 0x3fb00024, 0x3fd00034, 0x3fb00126, 0x3fd00136, 0x3fb80065, 0x3fd80075, 0x3fb80167, 0x3fd80177}, - uint32(0xfff80000), - [21]string{"0x69", "0xf5", "0xd3", "0xed", "0xb9", "0x43", "0x3a", "0x4a", "0x87", "0xe0", "0xc1", "0x10", "0x6c", "0xb0", "0x55", "0x6c", "0xd4", "0x9e", "0xe5", "0x90", "0x00"}}, - { - /* No.207 delta:670 weight:1477 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0x00a0fbb0, 0xe2484b5d, 0xe2e8b0ed, 0x40d00cfc, 0x4070f74c, 0xa29847a1, 0xa238bc11, 0x0000f40d, 0x00a00fbd, 0xe248bf50, 0xe2e844e0, 0x40d0f8f1, 0x40700341, 0xa298b3ac, 0xa238481c}, - [16]uint32{0x00000000, 0x000253fe, 0x0048217a, 0x004a7284, 0x120408ad, 0x12065b53, 0x124c29d7, 0x124e7a29, 0x1040c1bc, 0x10429242, 0x1008e0c6, 0x100ab338, 0x0244c911, 0x02469aef, 0x020ce86b, 0x020ebb95}, - [16]uint32{0x3f800000, 0x3f800129, 0x3f802410, 0x3f802539, 0x3f890204, 0x3f89032d, 0x3f892614, 0x3f89273d, 0x3f882060, 0x3f882149, 0x3f880470, 0x3f880559, 0x3f812264, 0x3f81234d, 0x3f810674, 0x3f81075d}, - uint32(0xfff80000), - [21]string{"0x99", "0x83", "0x87", "0x20", "0xf2", "0x97", "0x99", "0xd5", "0xd2", "0x77", "0x6e", "0xb7", "0x02", "0x7a", "0xa4", "0xd0", "0xc9", "0x3e", "0xe7", "0x8b", "0x00"}}, - { - /* No.208 delta:827 weight:747 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x6ab7503d, 0x78c35ee8, 0x12740ed5, 0x0a200d05, 0x60975d38, 0x72e353ed, 0x185403d0, 0x0000d2c7, 0x6ab782fa, 0x78c38c2f, 0x1274dc12, 0x0a20dfc2, 0x60978fff, 0x72e3812a, 0x1854d117}, - [16]uint32{0x00000000, 0x0c9e017b, 0x01503585, 0x0dce34fe, 0x02020073, 0x0e9c0108, 0x035235f6, 0x0fcc348d, 0x0040893c, 0x0cde8847, 0x0110bcb9, 0x0d8ebdc2, 0x0242894f, 0x0edc8834, 0x0312bcca, 0x0f8cbdb1}, - [16]uint32{0x3f800000, 0x3f864f00, 0x3f80a81a, 0x3f86e71a, 0x3f810100, 0x3f874e00, 0x3f81a91a, 0x3f87e61a, 0x3f802044, 0x3f866f44, 0x3f80885e, 0x3f86c75e, 0x3f812144, 0x3f876e44, 0x3f81895e, 0x3f87c65e}, - uint32(0xfff80000), - [21]string{"0x8f", "0x72", "0x12", "0x18", "0x88", "0x56", "0x56", "0x47", "0xc7", "0x52", "0x17", "0xcf", "0x89", "0x98", "0x5f", "0xc8", "0x8b", "0x6c", "0x5f", "0xe5", "0x00"}}, - { - /* No.209 delta:755 weight:1449 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x71586746, 0xfa76fda6, 0x8b2e9ae0, 0xe0d00d16, 0x91886a50, 0x1aa6f0b0, 0x6bfe97f6, 0x00000411, 0x71586357, 0xfa76f9b7, 0x8b2e9ef1, 0xe0d00907, 0x91886e41, 0x1aa6f4a1, 0x6bfe93e7}, - [16]uint32{0x00000000, 0x10834dd3, 0x7001a5de, 0x6082e80d, 0x4021601b, 0x50a22dc8, 0x3020c5c5, 0x20a38816, 0x6001f121, 0x7082bcf2, 0x100054ff, 0x0083192c, 0x2020913a, 0x30a3dce9, 0x502134e4, 0x40a27937}, - [16]uint32{0x3f800000, 0x3f8841a6, 0x3fb800d2, 0x3fb04174, 0x3fa010b0, 0x3fa85116, 0x3f981062, 0x3f9051c4, 0x3fb000f8, 0x3fb8415e, 0x3f88002a, 0x3f80418c, 0x3f901048, 0x3f9851ee, 0x3fa8109a, 0x3fa0513c}, - uint32(0xfff80000), - [21]string{"0xd7", "0xad", "0x88", "0x14", "0x6e", "0x50", "0xe8", "0xc2", "0x45", "0x39", "0x5f", "0x00", "0xb8", "0x4b", "0xf8", "0x7f", "0xa4", "0x5b", "0xad", "0xac", "0x00"}}, - { - /* No.210 delta:586 weight:1381 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0xb126e2d0, 0xeb81c72e, 0x5aa725fe, 0x05000d23, 0xb426eff3, 0xee81ca0d, 0x5fa728dd, 0x0000b8f6, 0xb1265a26, 0xeb817fd8, 0x5aa79d08, 0x0500b5d5, 0xb4265705, 0xee8172fb, 0x5fa7902b}, - [16]uint32{0x00000000, 0x21001656, 0x0002b01a, 0x2102a64c, 0x40000143, 0x61001715, 0x4002b159, 0x6102a70f, 0x900c082e, 0xb10c1e78, 0x900eb834, 0xb10eae62, 0xd00c096d, 0xf10c1f3b, 0xd00eb977, 0xf10eaf21}, - [16]uint32{0x3f800000, 0x3f90800b, 0x3f800158, 0x3f908153, 0x3fa00000, 0x3fb0800b, 0x3fa00158, 0x3fb08153, 0x3fc80604, 0x3fd8860f, 0x3fc8075c, 0x3fd88757, 0x3fe80604, 0x3ff8860f, 0x3fe8075c, 0x3ff88757}, - uint32(0xfff80000), - [21]string{"0x9f", "0x18", "0x29", "0xdb", "0xe3", "0xe7", "0x0c", "0xf9", "0xe8", "0x52", "0x7f", "0xe7", "0x53", "0x58", "0x10", "0xfa", "0x39", "0x2b", "0x01", "0x90", "0x00"}}, - { - /* No.211 delta:583 weight:1397 */ - 11213, - 81, - 13, - 4, - [16]uint32{0x00000000, 0x882e2760, 0x600360c7, 0xe82d47a7, 0x87b00d33, 0x0f9e2a53, 0xe7b36df4, 0x6f9d4a94, 0x00005355, 0x882e7435, 0x60033392, 0xe82d14f2, 0x87b05e66, 0x0f9e7906, 0xe7b33ea1, 0x6f9d19c1}, - [16]uint32{0x00000000, 0x31648495, 0x0001981a, 0x31651c8f, 0x202c0199, 0x1148850c, 0x202d9983, 0x11491d16, 0x002220a7, 0x3146a432, 0x0023b8bd, 0x31473c28, 0x200e213e, 0x116aa5ab, 0x200fb924, 0x116b3db1}, - [16]uint32{0x3f800000, 0x3f98b242, 0x3f8000cc, 0x3f98b28e, 0x3f901600, 0x3f88a442, 0x3f9016cc, 0x3f88a48e, 0x3f801110, 0x3f98a352, 0x3f8011dc, 0x3f98a39e, 0x3f900710, 0x3f88b552, 0x3f9007dc, 0x3f88b59e}, - uint32(0xfff80000), - [21]string{"0x6b", "0x2c", "0xdf", "0x43", "0x83", "0xbf", "0xec", "0x70", "0x70", "0x52", "0x2c", "0x4d", "0x48", "0x48", "0xe3", "0xfa", "0x5a", "0x93", "0x0a", "0x33", "0x00"}}, - { - /* No.212 delta:1186 weight:1545 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x8d36105b, 0xc4199cb9, 0x492f8ce2, 0xd2900d49, 0x5fa61d12, 0x168991f0, 0x9bbf81ab, 0x00002cf7, 0x8d363cac, 0xc419b04e, 0x492fa015, 0xd29021be, 0x5fa631e5, 0x1689bd07, 0x9bbfad5c}, - [16]uint32{0x00000000, 0x80002a1a, 0x02032619, 0x82030c03, 0x3002c187, 0xb002eb9d, 0x3201e79e, 0xb201cd84, 0x0003a6a5, 0x80038cbf, 0x020080bc, 0x8200aaa6, 0x30016722, 0xb0014d38, 0x3202413b, 0xb2026b21}, - [16]uint32{0x3f800000, 0x3fc00015, 0x3f810193, 0x3fc10186, 0x3f980160, 0x3fd80175, 0x3f9900f3, 0x3fd900e6, 0x3f8001d3, 0x3fc001c6, 0x3f810040, 0x3fc10055, 0x3f9800b3, 0x3fd800a6, 0x3f990120, 0x3fd90135}, - uint32(0xfff80000), - [21]string{"0x6d", "0x67", "0xa8", "0xbe", "0xe2", "0x5e", "0xa1", "0x6a", "0xa9", "0x0e", "0x34", "0x31", "0x87", "0xf7", "0xac", "0x44", "0xfa", "0x7e", "0x41", "0xa2", "0x00"}}, - { - /* No.213 delta:825 weight:1579 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x01838606, 0x71d01ded, 0x70539beb, 0x96f00d57, 0x97738b51, 0xe72010ba, 0xe6a396bc, 0x0000ea71, 0x01836c77, 0x71d0f79c, 0x7053719a, 0x96f0e726, 0x97736120, 0xe720facb, 0xe6a37ccd}, - [16]uint32{0x00000000, 0x10026332, 0x70001817, 0x60027b25, 0x100100bb, 0x00036389, 0x600118ac, 0x70037b9e, 0x40806053, 0x50820361, 0x30807844, 0x20821b76, 0x508160e8, 0x408303da, 0x208178ff, 0x30831bcd}, - [16]uint32{0x3f800000, 0x3f880131, 0x3fb8000c, 0x3fb0013d, 0x3f880080, 0x3f8001b1, 0x3fb0008c, 0x3fb801bd, 0x3fa04030, 0x3fa84101, 0x3f98403c, 0x3f90410d, 0x3fa840b0, 0x3fa04181, 0x3f9040bc, 0x3f98418d}, - uint32(0xfff80000), - [21]string{"0x09", "0x23", "0x73", "0x01", "0xff", "0x14", "0x1c", "0xa3", "0xf0", "0x4d", "0xdc", "0x38", "0x05", "0x50", "0xb2", "0x09", "0x8b", "0xad", "0xa8", "0x46", "0x00"}}, - { - /* No.214 delta:948 weight:969 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x0bf25cfd, 0x74c8e46d, 0x7f3ab890, 0x1f800d6e, 0x14725193, 0x6b48e903, 0x60bab5fe, 0x0000b8f9, 0x0bf2e404, 0x74c85c94, 0x7f3a0069, 0x1f80b597, 0x1472e96a, 0x6b4851fa, 0x60ba0d07}, - [16]uint32{0x00000000, 0xa05040b6, 0x0003900c, 0xa053d0ba, 0x20501012, 0x800050a4, 0x2053801e, 0x8003c0a8, 0x20206419, 0x807024af, 0x2023f415, 0x8073b4a3, 0x0070740b, 0xa02034bd, 0x0073e407, 0xa023a4b1}, - [16]uint32{0x3f800000, 0x3fd02820, 0x3f8001c8, 0x3fd029e8, 0x3f902808, 0x3fc00028, 0x3f9029c0, 0x3fc001e0, 0x3f901032, 0x3fc03812, 0x3f9011fa, 0x3fc039da, 0x3f80383a, 0x3fd0101a, 0x3f8039f2, 0x3fd011d2}, - uint32(0xfff80000), - [21]string{"0xe4", "0xd6", "0x8f", "0x32", "0xa8", "0x42", "0xef", "0xb6", "0x9d", "0x5a", "0xcf", "0x60", "0xfd", "0x88", "0x3d", "0xce", "0xef", "0xfe", "0x15", "0x79", "0x00"}}, - { - /* No.215 delta:1475 weight:1683 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xd53ab74c, 0xc7105e0d, 0x122ae941, 0x45400d7a, 0x907aba36, 0x82505377, 0x576ae43b, 0x00000c2c, 0xd53abb60, 0xc7105221, 0x122ae56d, 0x45400156, 0x907ab61a, 0x82505f5b, 0x576ae817}, - [16]uint32{0x00000000, 0x08441ad6, 0x00446303, 0x080079d5, 0x205671b2, 0x28126b64, 0x201212b1, 0x28560867, 0x0031190f, 0x087503d9, 0x00757a0c, 0x083160da, 0x206768bd, 0x2823726b, 0x20230bbe, 0x28671168}, - [16]uint32{0x3f800000, 0x3f84220d, 0x3f802231, 0x3f84003c, 0x3f902b38, 0x3f940935, 0x3f900909, 0x3f942b04, 0x3f80188c, 0x3f843a81, 0x3f803abd, 0x3f8418b0, 0x3f9033b4, 0x3f9411b9, 0x3f901185, 0x3f943388}, - uint32(0xfff80000), - [21]string{"0xe7", "0x59", "0xda", "0xc8", "0x4b", "0xb3", "0x0f", "0x1e", "0xfa", "0x17", "0xe2", "0x51", "0x72", "0xbe", "0xed", "0xc6", "0x33", "0x46", "0x33", "0xb0", "0x00"}}, - { - /* No.216 delta:837 weight:1593 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0xb808e5ef, 0x7155b0d3, 0xc95d553c, 0x93700d87, 0x2b78e868, 0xe225bd54, 0x5a2d58bb, 0x0000e70d, 0xb80802e2, 0x715557de, 0xc95db231, 0x9370ea8a, 0x2b780f65, 0xe2255a59, 0x5a2dbfb6}, - [16]uint32{0x00000000, 0x0002041f, 0x0001e013, 0x0003e40c, 0x20040348, 0x20060757, 0x2005e35b, 0x2007e744, 0x706c09ea, 0x706e0df5, 0x706de9f9, 0x706fede6, 0x50680aa2, 0x506a0ebd, 0x5069eab1, 0x506beeae}, - [16]uint32{0x3f800000, 0x3f800102, 0x3f8000f0, 0x3f8001f2, 0x3f900201, 0x3f900303, 0x3f9002f1, 0x3f9003f3, 0x3fb83604, 0x3fb83706, 0x3fb836f4, 0x3fb837f6, 0x3fa83405, 0x3fa83507, 0x3fa834f5, 0x3fa835f7}, - uint32(0xfff80000), - [21]string{"0x3a", "0x6e", "0xf3", "0x8e", "0xf1", "0x1f", "0x2e", "0xf7", "0xc1", "0x1b", "0x4c", "0x25", "0xdd", "0x03", "0x57", "0x41", "0x04", "0x3d", "0x01", "0xdd", "0x00"}}, - { - /* No.217 delta:1108 weight:1531 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0x38b9e580, 0x253c3d68, 0x1d85d8e8, 0xcbd00d91, 0xf369e811, 0xeeec30f9, 0xd655d579, 0x0000fd0b, 0x38b9188b, 0x253cc063, 0x1d8525e3, 0xcbd0f09a, 0xf369151a, 0xeeeccdf2, 0xd6552872}, - [16]uint32{0x00000000, 0x046d09b2, 0x407401d7, 0x44190865, 0x000911c9, 0x0464187b, 0x407d101e, 0x441019ac, 0x4000201c, 0x446d29ae, 0x007421cb, 0x04192879, 0x400931d5, 0x44643867, 0x007d3002, 0x041039b0}, - [16]uint32{0x3f800000, 0x3f823684, 0x3fa03a00, 0x3fa20c84, 0x3f800488, 0x3f82320c, 0x3fa03e88, 0x3fa2080c, 0x3fa00010, 0x3fa23694, 0x3f803a10, 0x3f820c94, 0x3fa00498, 0x3fa2321c, 0x3f803e98, 0x3f82081c}, - uint32(0xfff80000), - [21]string{"0xc8", "0x6c", "0x27", "0x5f", "0xec", "0xc7", "0xf5", "0x3a", "0xbf", "0xb3", "0x55", "0xa1", "0xa1", "0x9f", "0x60", "0x19", "0xac", "0x5f", "0x18", "0x71", "0x00"}}, - { - /* No.218 delta:894 weight:1525 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0x0b862a98, 0x1606e550, 0x1d80cfc8, 0x9d500da0, 0x96d62738, 0x8b56e8f0, 0x80d0c268, 0x00001599, 0x0b863f01, 0x1606f0c9, 0x1d80da51, 0x9d501839, 0x96d632a1, 0x8b56fd69, 0x80d0d7f1}, - [16]uint32{0x00000000, 0x001941be, 0x5065607d, 0x507c21c3, 0x10030172, 0x101a40cc, 0x4066610f, 0x407f20b1, 0x000251b6, 0x001b1008, 0x506731cb, 0x507e7075, 0x100150c4, 0x1018117a, 0x406430b9, 0x407d7107}, - [16]uint32{0x3f800000, 0x3f800ca0, 0x3fa832b0, 0x3fa83e10, 0x3f880180, 0x3f880d20, 0x3fa03330, 0x3fa03f90, 0x3f800128, 0x3f800d88, 0x3fa83398, 0x3fa83f38, 0x3f8800a8, 0x3f880c08, 0x3fa03218, 0x3fa03eb8}, - uint32(0xfff80000), - [21]string{"0x1b", "0x9b", "0xe2", "0x40", "0x50", "0x35", "0x38", "0x4a", "0xd9", "0x2f", "0xe4", "0x23", "0x03", "0xd4", "0xb9", "0xf8", "0xa8", "0xab", "0x0f", "0x6a", "0x00"}}, - { - /* No.219 delta:891 weight:1533 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x9f9392da, 0xcdd2dfef, 0x52414d35, 0x22900dbd, 0xbd039f67, 0xef42d252, 0x70d14088, 0x0000c2d2, 0x9f935008, 0xcdd21d3d, 0x52418fe7, 0x2290cf6f, 0xbd035db5, 0xef421080, 0x70d1825a}, - [16]uint32{0x00000000, 0x600600b6, 0x0002491d, 0x600449ab, 0x00016079, 0x600760cf, 0x00032964, 0x600529d2, 0x1000501f, 0x700650a9, 0x10021902, 0x700419b4, 0x10013066, 0x700730d0, 0x1003797b, 0x700579cd}, - [16]uint32{0x3f800000, 0x3fb00300, 0x3f800124, 0x3fb00224, 0x3f8000b0, 0x3fb003b0, 0x3f800194, 0x3fb00294, 0x3f880028, 0x3fb80328, 0x3f88010c, 0x3fb8020c, 0x3f880098, 0x3fb80398, 0x3f8801bc, 0x3fb802bc}, - uint32(0xfff80000), - [21]string{"0x82", "0xfc", "0xf1", "0xdf", "0xe8", "0x96", "0x44", "0x45", "0x91", "0xae", "0x27", "0xda", "0x06", "0x1d", "0x00", "0xaf", "0x72", "0x2d", "0xa6", "0xa3", "0x00"}}, - { - /* No.220 delta:978 weight:1467 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x236a1f70, 0x764e5295, 0x55244de5, 0xdbf00dc8, 0xf89a12b8, 0xadbe5f5d, 0x8ed4402d, 0x0000c9bc, 0x236ad6cc, 0x764e9b29, 0x55248459, 0xdbf0c474, 0xf89adb04, 0xadbe96e1, 0x8ed48991}, - [16]uint32{0x00000000, 0x022d91fa, 0x1002207c, 0x122fb186, 0x5031860e, 0x521c17f4, 0x4033a672, 0x421e3788, 0x00114401, 0x023cd5fb, 0x1013647d, 0x123ef587, 0x5020c20f, 0x520d53f5, 0x4022e273, 0x420f7389}, - [16]uint32{0x3f800000, 0x3f8116c8, 0x3f880110, 0x3f8917d8, 0x3fa818c3, 0x3fa90e0b, 0x3fa019d3, 0x3fa10f1b, 0x3f8008a2, 0x3f811e6a, 0x3f8809b2, 0x3f891f7a, 0x3fa81061, 0x3fa906a9, 0x3fa01171, 0x3fa107b9}, - uint32(0xfff80000), - [21]string{"0x33", "0x7b", "0x46", "0xd2", "0xbc", "0xf8", "0x2c", "0x88", "0xcc", "0xf9", "0x40", "0x12", "0x7d", "0x61", "0x89", "0xb2", "0xe7", "0x15", "0x55", "0xb6", "0x00"}}, - { - /* No.221 delta:602 weight:1579 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x395966ee, 0x6cbf26f7, 0x55e64019, 0xff500dd8, 0xc6096b36, 0x93ef2b2f, 0xaab64dc1, 0x00004fb5, 0x3959295b, 0x6cbf6942, 0x55e60fac, 0xff50426d, 0xc6092483, 0x93ef649a, 0xaab60274}, - [16]uint32{0x00000000, 0x3002919e, 0x00025a59, 0x3000cbc7, 0x0401201c, 0x3403b182, 0x04037a45, 0x3401ebdb, 0x20000b12, 0x10029a8c, 0x2002514b, 0x1000c0d5, 0x24012b0e, 0x1403ba90, 0x24037157, 0x1401e0c9}, - [16]uint32{0x3f800000, 0x3f980148, 0x3f80012d, 0x3f980065, 0x3f820090, 0x3f9a01d8, 0x3f8201bd, 0x3f9a00f5, 0x3f900005, 0x3f88014d, 0x3f900128, 0x3f880060, 0x3f920095, 0x3f8a01dd, 0x3f9201b8, 0x3f8a00f0}, - uint32(0xfff80000), - [21]string{"0xbf", "0x26", "0xe4", "0x1e", "0xa2", "0x93", "0x19", "0x22", "0x0d", "0xa0", "0x15", "0x2f", "0xc9", "0x3c", "0x83", "0x07", "0x28", "0xf5", "0x52", "0x45", "0x00"}}, - { - /* No.222 delta:1212 weight:1493 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x77f6a878, 0xb8df422f, 0xcf29ea57, 0xa9000deb, 0xdef6a593, 0x11df4fc4, 0x6629e7bc, 0x0000e4d2, 0x77f64caa, 0xb8dfa6fd, 0xcf290e85, 0xa900e939, 0xdef64141, 0x11dfab16, 0x6629036e}, - [16]uint32{0x00000000, 0x00255176, 0x001245c7, 0x003714b1, 0x4824480b, 0x4801197d, 0x48360dcc, 0x48135cba, 0x0042a01f, 0x0067f169, 0x0050e5d8, 0x0075b4ae, 0x4866e814, 0x4843b962, 0x4874add3, 0x4851fca5}, - [16]uint32{0x3f800000, 0x3f8012a8, 0x3f800922, 0x3f801b8a, 0x3fa41224, 0x3fa4008c, 0x3fa41b06, 0x3fa409ae, 0x3f802150, 0x3f8033f8, 0x3f802872, 0x3f803ada, 0x3fa43374, 0x3fa421dc, 0x3fa43a56, 0x3fa428fe}, - uint32(0xfff80000), - [21]string{"0x73", "0x81", "0xfa", "0xca", "0x9b", "0x8c", "0x56", "0x79", "0xac", "0xde", "0xd7", "0x97", "0x4a", "0x95", "0x2d", "0xac", "0xaf", "0x7a", "0xd7", "0xfd", "0x00"}}, - { - /* No.223 delta:702 weight:1671 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x4a8a3f8e, 0x8cb6604e, 0xc63c5fc0, 0x13c00df0, 0x594a327e, 0x9f766dbe, 0xd5fc5230, 0x00001edd, 0x4a8a2153, 0x8cb67e93, 0xc63c411d, 0x13c0132d, 0x594a2ca3, 0x9f767363, 0xd5fc4ced}, - [16]uint32{0x00000000, 0x1006109e, 0x00401077, 0x104600e9, 0x0002280b, 0x10043895, 0x0042387c, 0x104428e2, 0x3000821f, 0x20069281, 0x30409268, 0x204682f6, 0x3002aa14, 0x2004ba8a, 0x3042ba63, 0x2044aafd}, - [16]uint32{0x3f800000, 0x3f880308, 0x3f802008, 0x3f882300, 0x3f800114, 0x3f88021c, 0x3f80211c, 0x3f882214, 0x3f980041, 0x3f900349, 0x3f982049, 0x3f902341, 0x3f980155, 0x3f90025d, 0x3f98215d, 0x3f902255}, - uint32(0xfff80000), - [21]string{"0x66", "0x5a", "0xdb", "0xfa", "0x2e", "0xdd", "0x15", "0x6f", "0x21", "0xb3", "0x08", "0x1a", "0x9f", "0xf4", "0xca", "0x85", "0x6e", "0x6c", "0xf1", "0x8b", "0x00"}}, - { - /* No.224 delta:1058 weight:1543 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x804482da, 0x202f737b, 0xa06bf1a1, 0x84a00e0c, 0x04e48cd6, 0xa48f7d77, 0x24cbffad, 0x00007fee, 0x8044fd34, 0x202f0c95, 0xa06b8e4f, 0x84a071e2, 0x04e4f338, 0xa48f0299, 0x24cb8043}, - [16]uint32{0x00000000, 0x005e00fa, 0x0c4c9193, 0x0c129169, 0x000a180d, 0x005418f7, 0x0c46899e, 0x0c188964, 0x00027011, 0x005c70eb, 0x0c4ee182, 0x0c10e178, 0x0008681c, 0x005668e6, 0x0c44f98f, 0x0c1af975}, - [16]uint32{0x3f800000, 0x3f802f00, 0x3f862648, 0x3f860948, 0x3f80050c, 0x3f802a0c, 0x3f862344, 0x3f860c44, 0x3f800138, 0x3f802e38, 0x3f862770, 0x3f860870, 0x3f800434, 0x3f802b34, 0x3f86227c, 0x3f860d7c}, - uint32(0xfff80000), - [21]string{"0xbe", "0xa2", "0x6b", "0x7e", "0xe7", "0x1c", "0x3a", "0xcf", "0xce", "0xb8", "0xc6", "0x54", "0x6e", "0x94", "0xb2", "0x2e", "0xe3", "0x9c", "0x91", "0x68", "0x00"}}, - { - /* No.225 delta:2138 weight:1359 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x3e90494e, 0xbc17bf5f, 0x8287f611, 0x14400e13, 0x2ad0475d, 0xa857b14c, 0x96c7f802, 0x00007c06, 0x3e903548, 0xbc17c359, 0x82878a17, 0x14407215, 0x2ad03b5b, 0xa857cd4a, 0x96c78404}, - [16]uint32{0x00000000, 0x58041376, 0x14286614, 0x4c2c7562, 0x42004ea8, 0x1a045dde, 0x562828bc, 0x0e2c3bca, 0x6c00413f, 0x34045249, 0x7828272b, 0x202c345d, 0x2e000f97, 0x76041ce1, 0x3a286983, 0x622c7af5}, - [16]uint32{0x3f800000, 0x3fac0209, 0x3f8a1433, 0x3fa6163a, 0x3fa10027, 0x3f8d022e, 0x3fab1414, 0x3f87161d, 0x3fb60020, 0x3f9a0229, 0x3fbc1413, 0x3f90161a, 0x3f970007, 0x3fbb020e, 0x3f9d1434, 0x3fb1163d}, - uint32(0xfff80000), - [21]string{"0xd7", "0x40", "0x51", "0x63", "0x1e", "0xeb", "0x82", "0x1f", "0xe6", "0xec", "0xc3", "0xcc", "0x79", "0x9d", "0x0a", "0x57", "0xff", "0x3c", "0xb9", "0xa8", "0x00"}}, - { - /* No.226 delta:616 weight:1675 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xfd1bd24f, 0xf3f9ff78, 0x0ee22d37, 0xedb00e2b, 0x10abdc64, 0x1e49f153, 0xe352231c, 0x00003a6a, 0xfd1be825, 0xf3f9c512, 0x0ee2175d, 0xedb03441, 0x10abe60e, 0x1e49cb39, 0xe3521976}, - [16]uint32{0x00000000, 0x400110b6, 0x1010f815, 0x5011e8a3, 0x2024c20a, 0x6025d2bc, 0x30343a1f, 0x70352aa9, 0x4001c15e, 0x0000d1e8, 0x5011394b, 0x101029fd, 0x60250354, 0x202413e2, 0x7035fb41, 0x3034ebf7}, - [16]uint32{0x3f800000, 0x3fa00088, 0x3f88087c, 0x3fa808f4, 0x3f901261, 0x3fb012e9, 0x3f981a1d, 0x3fb81a95, 0x3fa000e0, 0x3f800068, 0x3fa8089c, 0x3f880814, 0x3fb01281, 0x3f901209, 0x3fb81afd, 0x3f981a75}, - uint32(0xfff80000), - [21]string{"0xe3", "0x47", "0xc7", "0xb8", "0xe5", "0x9f", "0x82", "0x92", "0xc8", "0x0d", "0x68", "0x3b", "0x78", "0xd6", "0x97", "0x3d", "0xe8", "0x4e", "0x01", "0xa6", "0x00"}}, - { - /* No.227 delta:692 weight:1731 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x6da145eb, 0x9b35488c, 0xf6940d67, 0x39000e3d, 0x54a14bd6, 0xa23546b1, 0xcf94035a, 0x00001f6e, 0x6da15a85, 0x9b3557e2, 0xf6941209, 0x39001153, 0x54a154b8, 0xa23559df, 0xcf941c34}, - [16]uint32{0x00000000, 0x100311fb, 0x40023a07, 0x50012bfc, 0x40002412, 0x500335e9, 0x00021e15, 0x10010fee, 0x3000801d, 0x200391e6, 0x7002ba1a, 0x6001abe1, 0x7000a40f, 0x6003b5f4, 0x30029e08, 0x20018ff3}, - [16]uint32{0x3f800000, 0x3f880188, 0x3fa0011d, 0x3fa80095, 0x3fa00012, 0x3fa8019a, 0x3f80010f, 0x3f880087, 0x3f980040, 0x3f9001c8, 0x3fb8015d, 0x3fb000d5, 0x3fb80052, 0x3fb001da, 0x3f98014f, 0x3f9000c7}, - uint32(0xfff80000), - [21]string{"0x44", "0xcc", "0x15", "0x5b", "0xe6", "0x5e", "0x83", "0x55", "0x84", "0xf9", "0xce", "0xc8", "0xa2", "0x6f", "0x0c", "0xff", "0x71", "0xc1", "0x9f", "0x0b", "0x00"}}, - { - /* No.228 delta:2153 weight:1377 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x51f9dadd, 0xa2f375d5, 0xf30aaf08, 0x0c100e49, 0x5de9d494, 0xaee37b9c, 0xff1aa141, 0x000074c6, 0x51f9ae1b, 0xa2f30113, 0xf30adbce, 0x0c107a8f, 0x5de9a052, 0xaee30f5a, 0xff1ad587}, - [16]uint32{0x00000000, 0x267510b2, 0x712609d7, 0x57531965, 0x1402001f, 0x327710ad, 0x652409c8, 0x4351197a, 0xad185203, 0x8b6d42b1, 0xdc3e5bd4, 0xfa4b4b66, 0xb91a521c, 0x9f6f42ae, 0xc83c5bcb, 0xee494b79}, - [16]uint32{0x3f800000, 0x3f933a88, 0x3fb89304, 0x3faba98c, 0x3f8a0100, 0x3f993b88, 0x3fb29204, 0x3fa1a88c, 0x3fd68c29, 0x3fc5b6a1, 0x3fee1f2d, 0x3ffd25a5, 0x3fdc8d29, 0x3fcfb7a1, 0x3fe41e2d, 0x3ff724a5}, - uint32(0xfff80000), - [21]string{"0x12", "0xbb", "0xe9", "0xb1", "0xe2", "0xeb", "0x7f", "0xee", "0xab", "0x7a", "0xff", "0x95", "0x21", "0x30", "0xf0", "0xe2", "0x19", "0x07", "0x21", "0x7c", "0x00"}}, - { - /* No.229 delta:1599 weight:1619 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0xde4e5727, 0x27620ea0, 0xf92c5987, 0xed300e53, 0x337e5974, 0xca5200f3, 0x141c57d4, 0x00001e91, 0xde4e49b6, 0x27621031, 0xf92c4716, 0xed3010c2, 0x337e47e5, 0xca521e62, 0x141c4945}, - [16]uint32{0x00000000, 0x08962914, 0x900110df, 0x989739cb, 0x0041601c, 0x08d74908, 0x904070c3, 0x98d659d7, 0x50014112, 0x58976806, 0xc00051cd, 0xc89678d9, 0x5040210e, 0x58d6081a, 0xc04131d1, 0xc8d718c5}, - [16]uint32{0x3f800000, 0x3f844b14, 0x3fc80088, 0x3fcc4b9c, 0x3f8020b0, 0x3f846ba4, 0x3fc82038, 0x3fcc6b2c, 0x3fa800a0, 0x3fac4bb4, 0x3fe00028, 0x3fe44b3c, 0x3fa82010, 0x3fac6b04, 0x3fe02098, 0x3fe46b8c}, - uint32(0xfff80000), - [21]string{"0x2a", "0xa2", "0x16", "0xca", "0x49", "0x08", "0xa1", "0x51", "0xd3", "0xd5", "0x61", "0xe9", "0x08", "0xcb", "0x4d", "0x45", "0x5e", "0x1b", "0xad", "0x1c", "0x00"}}, - { - /* No.230 delta:1191 weight:1545 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x194b78e6, 0x6f1d3bb7, 0x76564351, 0xabb00e6d, 0xb2fb768b, 0xc4ad35da, 0xdde64d3c, 0x00009530, 0x194bedd6, 0x6f1dae87, 0x7656d661, 0xabb09b5d, 0xb2fbe3bb, 0xc4ada0ea, 0xdde6d80c}, - [16]uint32{0x00000000, 0x602667de, 0x0055807d, 0x6073e7a3, 0x100a1805, 0x702c7fdb, 0x105f9878, 0x7079ffa6, 0x0002458c, 0x60242252, 0x0057c5f1, 0x6071a22f, 0x10085d89, 0x702e3a57, 0x105dddf4, 0x707bba2a}, - [16]uint32{0x3f800000, 0x3fb01333, 0x3f802ac0, 0x3fb039f3, 0x3f88050c, 0x3fb8163f, 0x3f882fcc, 0x3fb83cff, 0x3f800122, 0x3fb01211, 0x3f802be2, 0x3fb038d1, 0x3f88042e, 0x3fb8171d, 0x3f882eee, 0x3fb83ddd}, - uint32(0xfff80000), - [21]string{"0x62", "0x34", "0x3d", "0x24", "0x5d", "0x6b", "0xfd", "0x1f", "0xea", "0x46", "0xba", "0x4e", "0xb4", "0x16", "0xfd", "0x63", "0xf8", "0x2d", "0x94", "0xfa", "0x00"}}, - { - /* No.231 delta:1759 weight:1557 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0xa9aa6236, 0xb8d54cd0, 0x117f2ee6, 0x92100e78, 0x3bba6c4e, 0x2ac542a8, 0x836f209e, 0x00003edb, 0xa9aa5ced, 0xb8d5720b, 0x117f103d, 0x921030a3, 0x3bba5295, 0x2ac57c73, 0x836f1e45}, - [16]uint32{0x00000000, 0x6c129416, 0x5880901b, 0x3492040d, 0xc11100f2, 0xad0394e4, 0x999190e9, 0xf58304ff, 0x08b04183, 0x64a2d595, 0x5030d198, 0x3c22458e, 0xc9a14171, 0xa5b3d567, 0x9121d16a, 0xfd33457c}, - [16]uint32{0x3f800000, 0x3fb6094a, 0x3fac4048, 0x3f9a4902, 0x3fe08880, 0x3fd681ca, 0x3fccc8c8, 0x3ffac182, 0x3f845820, 0x3fb2516a, 0x3fa81868, 0x3f9e1122, 0x3fe4d0a0, 0x3fd2d9ea, 0x3fc890e8, 0x3ffe99a2}, - uint32(0xfff80000), - [21]string{"0xc5", "0x66", "0xfd", "0xf5", "0x39", "0x9a", "0x81", "0xf8", "0x17", "0x8b", "0x0c", "0xd1", "0x39", "0xa7", "0xb8", "0x7f", "0x48", "0xb7", "0x37", "0x1d", "0x00"}}, - { - /* No.232 delta:1474 weight:1163 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xe68d94c3, 0xca52dfa6, 0x2cdf4b65, 0x94d00e81, 0x725d9a42, 0x5e82d127, 0xb80f45e4, 0x000055a0, 0xe68dc163, 0xca528a06, 0x2cdf1ec5, 0x94d05b21, 0x725dcfe2, 0x5e828487, 0xb80f1044}, - [16]uint32{0x00000000, 0x107d2196, 0x000301af, 0x107e2039, 0x20200014, 0x305d2182, 0x202301bb, 0x305e202d, 0x00408086, 0x103da110, 0x00438129, 0x103ea0bf, 0x20608092, 0x301da104, 0x2063813d, 0x301ea0ab}, - [16]uint32{0x3f800000, 0x3f883e90, 0x3f800180, 0x3f883f10, 0x3f901000, 0x3f982e90, 0x3f901180, 0x3f982f10, 0x3f802040, 0x3f881ed0, 0x3f8021c0, 0x3f881f50, 0x3f903040, 0x3f980ed0, 0x3f9031c0, 0x3f980f50}, - uint32(0xfff80000), - [21]string{"0x0d", "0x8f", "0xf6", "0xb5", "0x00", "0x2c", "0x82", "0x15", "0x41", "0xd9", "0x7e", "0x26", "0x8a", "0xbf", "0xde", "0x9d", "0xce", "0x09", "0xa6", "0x52", "0x00"}}, - { - /* No.233 delta:1710 weight:1477 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xfaa4c149, 0x0a815e24, 0xf0259f6d, 0x48a00e96, 0xb204cfdf, 0x422150b2, 0xb88591fb, 0x000046a7, 0xfaa487ee, 0x0a811883, 0xf025d9ca, 0x48a04831, 0xb2048978, 0x42211615, 0xb885d75c}, - [16]uint32{0x00000000, 0x4687105e, 0x0d572a02, 0x4bd03a5c, 0x09024807, 0x4f855859, 0x04556205, 0x42d2725b, 0x0104001f, 0x47831041, 0x0c532a1d, 0x4ad43a43, 0x08064818, 0x4e815846, 0x0551621a, 0x43d67244}, - [16]uint32{0x3f800000, 0x3fa34388, 0x3f86ab95, 0x3fa5e81d, 0x3f848124, 0x3fa7c2ac, 0x3f822ab1, 0x3fa16939, 0x3f808200, 0x3fa3c188, 0x3f862995, 0x3fa56a1d, 0x3f840324, 0x3fa740ac, 0x3f82a8b1, 0x3fa1eb39}, - uint32(0xfff80000), - [21]string{"0xc1", "0x62", "0xd4", "0xf4", "0x4d", "0x8c", "0xb8", "0x20", "0x0e", "0xb1", "0x1e", "0x69", "0x92", "0xcb", "0xfa", "0xaf", "0x15", "0x8d", "0x27", "0x1d", "0x00"}}, - { - /* No.234 delta:1697 weight:1443 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x87b7826a, 0xc475bc43, 0x43c23e29, 0x24800eab, 0xa3378cc1, 0xe0f5b2e8, 0x67423082, 0x0000d36a, 0x87b75100, 0xc4756f29, 0x43c2ed43, 0x2480ddc1, 0xa3375fab, 0xe0f56182, 0x6742e3e8}, - [16]uint32{0x00000000, 0x0f09897a, 0x4155e01f, 0x4e5c6965, 0x0080392e, 0x0f89b054, 0x41d5d931, 0x4edc504b, 0x0048a403, 0x0f412d79, 0x411d441c, 0x4e14cd66, 0x00c89d2d, 0x0fc11457, 0x419d7d32, 0x4e94f448}, - [16]uint32{0x3f800000, 0x3f8784c4, 0x3fa0aaf0, 0x3fa72e34, 0x3f80401c, 0x3f87c4d8, 0x3fa0eaec, 0x3fa76e28, 0x3f802452, 0x3f87a096, 0x3fa08ea2, 0x3fa70a66, 0x3f80644e, 0x3f87e08a, 0x3fa0cebe, 0x3fa74a7a}, - uint32(0xfff80000), - [21]string{"0x84", "0x56", "0xa8", "0xb2", "0x6f", "0x3d", "0x04", "0x3a", "0x11", "0x3c", "0x50", "0x4b", "0xe0", "0x99", "0xa4", "0x12", "0xda", "0x3f", "0xfb", "0x81", "0x00"}}, - { - /* No.235 delta:796 weight:1591 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0x99ea585a, 0x057b62ab, 0x9c913af1, 0x03900eb2, 0x9a7a56e8, 0x06eb6c19, 0x9f013443, 0x0000556f, 0x99ea0d35, 0x057b37c4, 0x9c916f9e, 0x03905bdd, 0x9a7a0387, 0x06eb3976, 0x9f01612c}, - [16]uint32{0x00000000, 0x2142a81a, 0x800225b6, 0xa1408dac, 0x00030965, 0x2141a17f, 0x80012cd3, 0xa14384c9, 0x0800300b, 0x29429811, 0x880215bd, 0xa940bda7, 0x0803396e, 0x29419174, 0x88011cd8, 0xa943b4c2}, - [16]uint32{0x3f800000, 0x3f90a154, 0x3fc00112, 0x3fd0a046, 0x3f800184, 0x3f90a0d0, 0x3fc00096, 0x3fd0a1c2, 0x3f840018, 0x3f94a14c, 0x3fc4010a, 0x3fd4a05e, 0x3f84019c, 0x3f94a0c8, 0x3fc4008e, 0x3fd4a1da}, - uint32(0xfff80000), - [21]string{"0xd5", "0x6f", "0x5c", "0x04", "0x37", "0x62", "0xa3", "0x86", "0xe3", "0x2e", "0xd5", "0x2a", "0xf9", "0x33", "0xc6", "0x05", "0x8e", "0x64", "0x05", "0xb7", "0x00"}}, - { - /* No.236 delta:991 weight:1467 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0xaf21b504, 0xa5813444, 0x0aa08140, 0xe0600ecd, 0x4f41bbc9, 0x45e13a89, 0xeac08f8d, 0x0000f230, 0xaf214734, 0xa581c674, 0x0aa07370, 0xe060fcfd, 0x4f4149f9, 0x45e1c8b9, 0xeac07dbd}, - [16]uint32{0x00000000, 0x00430d1a, 0xb00140ef, 0xb0424df5, 0x400165f8, 0x404268e2, 0xf0002517, 0xf043280d, 0x20024432, 0x20414928, 0x900304dd, 0x904009c7, 0x600321ca, 0x60402cd0, 0xd0026125, 0xd0416c3f}, - [16]uint32{0x3f800000, 0x3f802186, 0x3fd800a0, 0x3fd82126, 0x3fa000b2, 0x3fa02134, 0x3ff80012, 0x3ff82194, 0x3f900122, 0x3f9020a4, 0x3fc80182, 0x3fc82004, 0x3fb00190, 0x3fb02016, 0x3fe80130, 0x3fe820b6}, - uint32(0xfff80000), - [21]string{"0x08", "0x23", "0x32", "0x65", "0xad", "0x77", "0xc1", "0xe9", "0xfa", "0x97", "0xa8", "0xe8", "0xfa", "0x5e", "0xa7", "0xfa", "0x8c", "0x95", "0x7e", "0x83", "0x00"}}, - { - /* No.237 delta:735 weight:677 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x4f2644c0, 0x34a648ac, 0x7b800c6c, 0x8dd00ed7, 0xc2f64a17, 0xb976467b, 0xf65002bb, 0x00004ef0, 0x4f260a30, 0x34a6065c, 0x7b80429c, 0x8dd04027, 0xc2f604e7, 0xb976088b, 0xf6504c4b}, - [16]uint32{0x00000000, 0x4cf610d5, 0x439d0047, 0x0f6b1092, 0x02d00d6d, 0x4e261db8, 0x414d0d2a, 0x0dbb1dff, 0x00798016, 0x4c8f90c3, 0x43e48051, 0x0f129084, 0x02a98d7b, 0x4e5f9dae, 0x41348d3c, 0x0dc29de9}, - [16]uint32{0x3f800000, 0x3fa67b08, 0x3fa1ce80, 0x3f87b588, 0x3f816806, 0x3fa7130e, 0x3fa0a686, 0x3f86dd8e, 0x3f803cc0, 0x3fa647c8, 0x3fa1f240, 0x3f878948, 0x3f8154c6, 0x3fa72fce, 0x3fa09a46, 0x3f86e14e}, - uint32(0xfff80000), - [21]string{"0x85", "0xf6", "0x81", "0x30", "0x53", "0x61", "0x3f", "0x78", "0xaf", "0xfb", "0xcb", "0x42", "0x18", "0xea", "0x66", "0xf7", "0x00", "0xb6", "0x51", "0x2a", "0x00"}}, - { - /* No.238 delta:1646 weight:1631 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x28a1b51b, 0xbc17178b, 0x94b6a290, 0x0f500ee9, 0x27f1bbf2, 0xb3471962, 0x9be6ac79, 0x00005fbe, 0x28a1eaa5, 0xbc174835, 0x94b6fd2e, 0x0f505157, 0x27f1e44c, 0xb34746dc, 0x9be6f3c7}, - [16]uint32{0x00000000, 0x080edc5a, 0x210608d4, 0x2908d48e, 0x000ad00c, 0x08040c56, 0x210cd8d8, 0x29020482, 0x60496c11, 0x6847b04b, 0x414f64c5, 0x4941b89f, 0x6043bc1d, 0x684d6047, 0x4145b4c9, 0x494b6893}, - [16]uint32{0x3f800000, 0x3f84076e, 0x3f908304, 0x3f94846a, 0x3f800568, 0x3f840206, 0x3f90866c, 0x3f948102, 0x3fb024b6, 0x3fb423d8, 0x3fa0a7b2, 0x3fa4a0dc, 0x3fb021de, 0x3fb426b0, 0x3fa0a2da, 0x3fa4a5b4}, - uint32(0xfff80000), - [21]string{"0x85", "0x16", "0x1a", "0x04", "0xc7", "0x8c", "0xaa", "0xe7", "0x0f", "0x71", "0x74", "0x2d", "0xcd", "0xbf", "0xec", "0xeb", "0x55", "0x2d", "0x65", "0xad", "0x00"}}, - { - /* No.239 delta:921 weight:1259 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0xc2571fd3, 0x43f1fa5c, 0x81a6e58f, 0x00d00ef5, 0xc2871126, 0x4321f4a9, 0x8176eb7a, 0x000065ce, 0xc2577a1d, 0x43f19f92, 0x81a68041, 0x00d06b3b, 0xc28774e8, 0x43219167, 0x81768eb4}, - [16]uint32{0x00000000, 0x004e991c, 0x00034177, 0x004dd86b, 0x40500103, 0x401e981f, 0x40534074, 0x401dd968, 0x2040e418, 0x200e7d04, 0x2043a56f, 0x200d3c73, 0x6010e51b, 0x605e7c07, 0x6013a46c, 0x605d3d70}, - [16]uint32{0x3f800000, 0x3f80274c, 0x3f8001a0, 0x3f8026ec, 0x3fa02800, 0x3fa00f4c, 0x3fa029a0, 0x3fa00eec, 0x3f902072, 0x3f90073e, 0x3f9021d2, 0x3f90069e, 0x3fb00872, 0x3fb02f3e, 0x3fb009d2, 0x3fb02e9e}, - uint32(0xfff80000), - [21]string{"0x08", "0x7b", "0xe5", "0x96", "0x58", "0x63", "0x7b", "0xa7", "0x0b", "0xcf", "0x64", "0x7f", "0xe5", "0xf7", "0xbc", "0x0c", "0x66", "0x46", "0x6a", "0x7e", "0x00"}}, - { - /* No.240 delta:777 weight:1607 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0x7afb4c42, 0xb4b78f4b, 0xce4cc309, 0x91a00f01, 0xeb5b4343, 0x2517804a, 0x5feccc08, 0x0000e97f, 0x7afba53d, 0xb4b76634, 0xce4c2a76, 0x91a0e67e, 0xeb5baa3c, 0x25176935, 0x5fec2577}, - [16]uint32{0x00000000, 0x504a0016, 0x80005ce4, 0xd04a5cf2, 0x0002040e, 0x50480418, 0x800258ea, 0xd04858fc, 0x40003a0b, 0x104a3a1d, 0xc00066ef, 0x904a66f9, 0x40023e05, 0x10483e13, 0xc00262e1, 0x904862f7}, - [16]uint32{0x3f800000, 0x3fa82500, 0x3fc0002e, 0x3fe8252e, 0x3f800102, 0x3fa82402, 0x3fc0012c, 0x3fe8242c, 0x3fa0001d, 0x3f88251d, 0x3fe00033, 0x3fc82533, 0x3fa0011f, 0x3f88241f, 0x3fe00131, 0x3fc82431}, - uint32(0xfff80000), - [21]string{"0x7d", "0xc6", "0x75", "0x54", "0xc8", "0xc1", "0xba", "0xe6", "0x6d", "0xc2", "0x62", "0xa9", "0xad", "0x80", "0x06", "0x6f", "0x52", "0x9f", "0x84", "0x48", "0x00"}}, - { - /* No.241 delta:2880 weight:821 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0xbbc180f5, 0x82b154f4, 0x3970d401, 0xc7d00f1a, 0x7c118fef, 0x45615bee, 0xfea0db1b, 0x000098e9, 0xbbc1181c, 0x82b1cc1d, 0x39704ce8, 0xc7d097f3, 0x7c111706, 0x4561c307, 0xfea043f2}, - [16]uint32{0x00000000, 0x886b015a, 0x0803c5ad, 0x8068c4f7, 0x4c0d802f, 0xc4668175, 0x440e4582, 0xcc6544d8, 0x422a0813, 0xca410949, 0x4a29cdbe, 0xc242cce4, 0x0e27883c, 0x864c8966, 0x06244d91, 0x8e4f4ccb}, - [16]uint32{0x3f800000, 0x3fc43580, 0x3f8401e2, 0x3fc03462, 0x3fa606c0, 0x3fe23340, 0x3fa20722, 0x3fe632a2, 0x3fa11504, 0x3fe52084, 0x3fa514e6, 0x3fe12166, 0x3f8713c4, 0x3fc32644, 0x3f831226, 0x3fc727a6}, - uint32(0xfff80000), - [21]string{"0xd3", "0x96", "0x70", "0x46", "0x95", "0xf4", "0x96", "0xb6", "0xa1", "0x5b", "0xec", "0x17", "0xc7", "0x4c", "0xe6", "0x33", "0x1b", "0x16", "0x1d", "0x79", "0x00"}}, - { - /* No.242 delta:1388 weight:1649 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xf70ad49c, 0x3721e624, 0xc02b32b8, 0xecb00f20, 0x1bbadbbc, 0xdb91e904, 0x2c9b3d98, 0x0000cf92, 0xf70a1b0e, 0x372129b6, 0xc02bfd2a, 0xecb0c0b2, 0x1bba142e, 0xdb912696, 0x2c9bf20a}, - [16]uint32{0x00000000, 0x4054e153, 0x207a0102, 0x602ee051, 0x4035641a, 0x00618549, 0x604f6518, 0x201b844b, 0x00501812, 0x4004f941, 0x202a1910, 0x607ef843, 0x40657c08, 0x00319d5b, 0x601f7d0a, 0x204b9c59}, - [16]uint32{0x3f800000, 0x3fa02a70, 0x3f903d00, 0x3fb01770, 0x3fa01ab2, 0x3f8030c2, 0x3fb027b2, 0x3f900dc2, 0x3f80280c, 0x3fa0027c, 0x3f90150c, 0x3fb03f7c, 0x3fa032be, 0x3f8018ce, 0x3fb00fbe, 0x3f9025ce}, - uint32(0xfff80000), - [21]string{"0x21", "0xa5", "0x6f", "0x7b", "0xe2", "0xe3", "0x9a", "0x38", "0x8d", "0x3b", "0xad", "0x35", "0x7d", "0x5b", "0x6c", "0xd5", "0x14", "0x7f", "0x83", "0x43", "0x00"}}, - { - /* No.243 delta:822 weight:715 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x5c622cc8, 0xd18006f0, 0x8de22a38, 0xb6c00f33, 0xeaa223fb, 0x674009c3, 0x3b22250b, 0x00006b6b, 0x5c6247a3, 0xd1806d9b, 0x8de24153, 0xb6c06458, 0xeaa24890, 0x674062a8, 0x3b224e60}, - [16]uint32{0x00000000, 0x0043b215, 0x104205bf, 0x1001b7aa, 0x0de0001b, 0x0da3b20e, 0x1da205a4, 0x1de1b7b1, 0x20c10146, 0x2082b353, 0x308304f9, 0x30c0b6ec, 0x2d21015d, 0x2d62b348, 0x3d6304e2, 0x3d20b6f7}, - [16]uint32{0x3f800000, 0x3f8021d9, 0x3f882102, 0x3f8800db, 0x3f86f000, 0x3f86d1d9, 0x3f8ed102, 0x3f8ef0db, 0x3f906080, 0x3f904159, 0x3f984182, 0x3f98605b, 0x3f969080, 0x3f96b159, 0x3f9eb182, 0x3f9e905b}, - uint32(0xfff80000), - [21]string{"0x53", "0x4d", "0x4a", "0xc1", "0x80", "0xb0", "0x11", "0x78", "0x0b", "0xb8", "0x0d", "0xac", "0xd2", "0x38", "0x5b", "0x1c", "0xc4", "0x45", "0xb9", "0xd9", "0x00"}}, - { - /* No.244 delta:1331 weight:1553 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xb107a6a0, 0x6b935e95, 0xda94f835, 0xa6b00f4e, 0x17b7a9ee, 0xcd2351db, 0x7c24f77b, 0x000004d0, 0xb107a270, 0x6b935a45, 0xda94fce5, 0xa6b00b9e, 0x17b7ad3e, 0xcd23550b, 0x7c24f3ab}, - [16]uint32{0x00000000, 0x34509156, 0x104b48a5, 0x241bd9f3, 0x0023b194, 0x347320c2, 0x1068f931, 0x24386867, 0x0046240d, 0x3416b55b, 0x100d6ca8, 0x245dfdfe, 0x00659599, 0x343504cf, 0x102edd3c, 0x247e4c6a}, - [16]uint32{0x3f800000, 0x3f9a2848, 0x3f8825a4, 0x3f920dec, 0x3f8011d8, 0x3f9a3990, 0x3f88347c, 0x3f921c34, 0x3f802312, 0x3f9a0b5a, 0x3f8806b6, 0x3f922efe, 0x3f8032ca, 0x3f9a1a82, 0x3f88176e, 0x3f923f26}, - uint32(0xfff80000), - [21]string{"0xc1", "0x2c", "0x81", "0xd7", "0x86", "0x64", "0xb1", "0x2b", "0x64", "0x0d", "0x03", "0xf6", "0x5c", "0x83", "0x00", "0x2a", "0xbc", "0xea", "0xdc", "0x0f", "0x00"}}, - { - /* No.245 delta:1052 weight:1575 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x897f1ecc, 0x20523dfa, 0xa92d2336, 0xcc300f52, 0x454f119e, 0xec6232a8, 0x651d2c64, 0x0000802c, 0x897f9ee0, 0x2052bdd6, 0xa92da31a, 0xcc308f7e, 0x454f91b2, 0xec62b284, 0x651dac48}, - [16]uint32{0x00000000, 0x4049c135, 0x600005fa, 0x2049c4cf, 0x800080f6, 0xc04941c3, 0xe000850c, 0xa0494439, 0x00001090, 0x4049d1a5, 0x6000156a, 0x2049d45f, 0x80009066, 0xc0495153, 0xe000959c, 0xa04954a9}, - [16]uint32{0x3f800000, 0x3fa024e0, 0x3fb00002, 0x3f9024e2, 0x3fc00040, 0x3fe024a0, 0x3ff00042, 0x3fd024a2, 0x3f800008, 0x3fa024e8, 0x3fb0000a, 0x3f9024ea, 0x3fc00048, 0x3fe024a8, 0x3ff0004a, 0x3fd024aa}, - uint32(0xfff80000), - [21]string{"0x34", "0xf6", "0x87", "0x19", "0x71", "0x96", "0xeb", "0x10", "0x2c", "0x0c", "0x30", "0xf6", "0x48", "0x8c", "0x49", "0x9b", "0x14", "0x7f", "0xfa", "0x83", "0x00"}}, - { - /* No.246 delta:866 weight:1437 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0x8bfba319, 0x05d4ddb9, 0x8e2f7ea0, 0x48900f6a, 0xc36bac73, 0x4d44d2d3, 0xc6bf71ca, 0x0000411a, 0x8bfbe203, 0x05d49ca3, 0x8e2f3fba, 0x48904e70, 0xc36bed69, 0x4d4493c9, 0xc6bf30d0}, - [16]uint32{0x00000000, 0x0318b3f6, 0x68390a3f, 0x6b21b9c9, 0x606462a2, 0x637cd154, 0x085d689d, 0x0b45db6b, 0x001181d2, 0x03093224, 0x68288bed, 0x6b30381b, 0x6075e370, 0x636d5086, 0x084ce94f, 0x0b545ab9}, - [16]uint32{0x3f800000, 0x3f818c59, 0x3fb41c85, 0x3fb590dc, 0x3fb03231, 0x3fb1be68, 0x3f842eb4, 0x3f85a2ed, 0x3f8008c0, 0x3f818499, 0x3fb41445, 0x3fb5981c, 0x3fb03af1, 0x3fb1b6a8, 0x3f842674, 0x3f85aa2d}, - uint32(0xfff80000), - [21]string{"0xd8", "0xaa", "0x8c", "0x91", "0xd1", "0x94", "0x8a", "0x56", "0x8b", "0xf4", "0xbf", "0xff", "0x90", "0xb6", "0x8c", "0x6e", "0x55", "0xfc", "0xf6", "0x1e", "0x00"}}, - { - /* No.247 delta:1081 weight:1351 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x4038e490, 0x927decbe, 0xd245082e, 0xaf700f77, 0xef48ebe7, 0x3d0de3c9, 0x7d350759, 0x0000e3af, 0x4038073f, 0x927d0f11, 0xd245eb81, 0xaf70ecd8, 0xef480848, 0x3d0d0066, 0x7d35e4f6}, - [16]uint32{0x00000000, 0x00745192, 0x004a196d, 0x003e48ff, 0x00098019, 0x007dd18b, 0x00439974, 0x0037c8e6, 0x2080298c, 0x20f4781e, 0x20ca30e1, 0x20be6173, 0x2089a995, 0x20fdf807, 0x20c3b0f8, 0x20b7e16a}, - [16]uint32{0x3f800000, 0x3f803a28, 0x3f80250c, 0x3f801f24, 0x3f8004c0, 0x3f803ee8, 0x3f8021cc, 0x3f801be4, 0x3f904014, 0x3f907a3c, 0x3f906518, 0x3f905f30, 0x3f9044d4, 0x3f907efc, 0x3f9061d8, 0x3f905bf0}, - uint32(0xfff80000), - [21]string{"0x81", "0x97", "0x5b", "0xe9", "0x62", "0x18", "0xbd", "0x08", "0xff", "0xc4", "0x8f", "0xf2", "0xcc", "0xba", "0xb8", "0x1c", "0xe3", "0xa5", "0x8b", "0x68", "0x00"}}, - { - /* No.248 delta:917 weight:1245 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0xf6306c98, 0x83db0b6e, 0x75eb67f6, 0x1c800f86, 0xeab0631e, 0x9f5b04e8, 0x696b6870, 0x000099c0, 0xf630f558, 0x83db92ae, 0x75ebfe36, 0x1c809646, 0xeab0fade, 0x9f5b9d28, 0x696bf1b0}, - [16]uint32{0x00000000, 0x204c216b, 0x400000bc, 0x604c21d7, 0x5030c811, 0x707ce97a, 0x1030c8ad, 0x307ce9c6, 0x40010804, 0x604d296f, 0x000108b8, 0x204d29d3, 0x1031c015, 0x307de17e, 0x5031c0a9, 0x707de1c2}, - [16]uint32{0x3f800000, 0x3f902610, 0x3fa00000, 0x3fb02610, 0x3fa81864, 0x3fb83e74, 0x3f881864, 0x3f983e74, 0x3fa00084, 0x3fb02694, 0x3f800084, 0x3f902694, 0x3f8818e0, 0x3f983ef0, 0x3fa818e0, 0x3fb83ef0}, - uint32(0xfff80000), - [21]string{"0x49", "0x62", "0x20", "0xf2", "0xe9", "0xcd", "0x93", "0x52", "0xa3", "0xfd", "0x81", "0x9b", "0xf7", "0xcb", "0x48", "0x7c", "0x53", "0xf4", "0xd1", "0x96", "0x00"}}, - { - /* No.249 delta:3104 weight:611 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xfe07e67a, 0x0d725357, 0xf375b52d, 0x7ea00f98, 0x80a7e9e2, 0x73d25ccf, 0x8dd5bab5, 0x0000a8bb, 0xfe074ec1, 0x0d72fbec, 0xf3751d96, 0x7ea0a723, 0x80a74159, 0x73d2f474, 0x8dd5120e}, - [16]uint32{0x00000000, 0x0200b4eb, 0x08d2409e, 0x0ad2f475, 0xb041120c, 0xb241a6e7, 0xb8935292, 0xba93e679, 0x28008013, 0x2a0034f8, 0x20d2c08d, 0x22d27466, 0x9841921f, 0x9a4126f4, 0x9093d281, 0x9293666a}, - [16]uint32{0x3f800000, 0x3f81005a, 0x3f846920, 0x3f85697a, 0x3fd82089, 0x3fd920d3, 0x3fdc49a9, 0x3fdd49f3, 0x3f940040, 0x3f95001a, 0x3f906960, 0x3f91693a, 0x3fcc20c9, 0x3fcd2093, 0x3fc849e9, 0x3fc949b3}, - uint32(0xfff80000), - [21]string{"0xc5", "0xe0", "0xf8", "0xcc", "0xa0", "0x0e", "0x7d", "0x9b", "0x3c", "0xa5", "0x41", "0x95", "0x21", "0xf6", "0x26", "0x8e", "0x33", "0xf4", "0x75", "0x77", "0x00"}}, - { - /* No.250 delta:869 weight:1669 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0xc43f1bd2, 0x06294d87, 0xc2165655, 0xffd00fa3, 0x3bef1471, 0xf9f94224, 0x3dc659f6, 0x00001d94, 0xc43f0646, 0x06295013, 0xc2164bc1, 0xffd01237, 0x3bef09e5, 0xf9f95fb0, 0x3dc64462}, - [16]uint32{0x00000000, 0x306c79d6, 0x0003428f, 0x306f3b59, 0x703813be, 0x40546a68, 0x703b5131, 0x405728e7, 0x1028401c, 0x204439ca, 0x102b0293, 0x20477b45, 0x601053a2, 0x507c2a74, 0x6013112d, 0x507f68fb}, - [16]uint32{0x3f800000, 0x3f98363c, 0x3f8001a1, 0x3f98379d, 0x3fb81c09, 0x3fa02a35, 0x3fb81da8, 0x3fa02b94, 0x3f881420, 0x3f90221c, 0x3f881581, 0x3f9023bd, 0x3fb00829, 0x3fa83e15, 0x3fb00988, 0x3fa83fb4}, - uint32(0xfff80000), - [21]string{"0x9d", "0x68", "0xef", "0xad", "0x03", "0x83", "0x62", "0x0c", "0x79", "0x30", "0xd2", "0x34", "0x90", "0x4e", "0xb3", "0x38", "0xdc", "0x59", "0x79", "0xd2", "0x00"}}, - { - /* No.251 delta:1162 weight:1717 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0xe894c623, 0x4d24d22d, 0xa5b0140e, 0x8ee00fbc, 0x6674c99f, 0xc3c4dd91, 0x2b501bb2, 0x00005afc, 0xe8949cdf, 0x4d2488d1, 0xa5b04ef2, 0x8ee05540, 0x66749363, 0xc3c4876d, 0x2b50414e}, - [16]uint32{0x00000000, 0x110c053a, 0x404a21cf, 0x514624f5, 0x3040a0dc, 0x214ca5e6, 0x700a8113, 0x61068429, 0x00062071, 0x110a254b, 0x404c01be, 0x51400484, 0x304680ad, 0x214a8597, 0x700ca162, 0x6100a458}, - [16]uint32{0x3f800000, 0x3f888602, 0x3fa02510, 0x3fa8a312, 0x3f982050, 0x3f90a652, 0x3fb80540, 0x3fb08342, 0x3f800310, 0x3f888512, 0x3fa02600, 0x3fa8a002, 0x3f982340, 0x3f90a542, 0x3fb80650, 0x3fb08052}, - uint32(0xfff80000), - [21]string{"0x79", "0x69", "0xf5", "0xba", "0x26", "0x51", "0xcd", "0x20", "0x6e", "0x16", "0x6f", "0x8b", "0xac", "0x8d", "0xf4", "0xbe", "0xaa", "0xa1", "0x19", "0xb4", "0x00"}}, - { - /* No.252 delta:1583 weight:1609 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x8a792ec4, 0xfe8e1123, 0x74f73fe7, 0xab800fc3, 0x21f92107, 0x550e1ee0, 0xdf773024, 0x0000e184, 0x8a79cf40, 0xfe8ef0a7, 0x74f7de63, 0xab80ee47, 0x21f9c083, 0x550eff64, 0xdf77d1a0}, - [16]uint32{0x00000000, 0x84a648b2, 0x005a030a, 0x84fc4bb8, 0x593d009c, 0xdd9b482e, 0x59670396, 0xddc14b24, 0x10008353, 0x94a6cbe1, 0x105a8059, 0x94fcc8eb, 0x493d83cf, 0xcd9bcb7d, 0x496780c5, 0xcdc1c877}, - [16]uint32{0x3f800000, 0x3fc25324, 0x3f802d01, 0x3fc27e25, 0x3fac9e80, 0x3feecda4, 0x3facb381, 0x3feee0a5, 0x3f880041, 0x3fca5365, 0x3f882d40, 0x3fca7e64, 0x3fa49ec1, 0x3fe6cde5, 0x3fa4b3c0, 0x3fe6e0e4}, - uint32(0xfff80000), - [21]string{"0xbb", "0xd6", "0x98", "0x2a", "0x1f", "0x07", "0x0d", "0x35", "0xa2", "0x37", "0x88", "0xe4", "0x31", "0xe7", "0xea", "0x27", "0xc8", "0x07", "0x91", "0x6a", "0x00"}}, - { - /* No.253 delta:721 weight:1577 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0x3e850aef, 0xd60ef703, 0xe88bfdec, 0x14400fd1, 0x2ac5053e, 0xc24ef8d2, 0xfccbf23d, 0x0000412b, 0x3e854bc4, 0xd60eb628, 0xe88bbcc7, 0x14404efa, 0x2ac54415, 0xc24eb9f9, 0xfccbb316}, - [16]uint32{0x00000000, 0x000231ba, 0x2064c13f, 0x2066f085, 0x30080017, 0x300a31ad, 0x106cc128, 0x106ef092, 0x2000a80b, 0x200299b1, 0x00646934, 0x0066588e, 0x1008a81c, 0x100a99a6, 0x306c6923, 0x306e5899}, - [16]uint32{0x3f800000, 0x3f800118, 0x3f903260, 0x3f903378, 0x3f980400, 0x3f980518, 0x3f883660, 0x3f883778, 0x3f900054, 0x3f90014c, 0x3f803234, 0x3f80332c, 0x3f880454, 0x3f88054c, 0x3f983634, 0x3f98372c}, - uint32(0xfff80000), - [21]string{"0x0f", "0x5c", "0x5d", "0x61", "0x52", "0x2d", "0xf2", "0x5f", "0xa2", "0x7e", "0x9b", "0xd4", "0xa5", "0x3a", "0xc0", "0xf5", "0x0c", "0x06", "0x70", "0xbd", "0x00"}}, - { - /* No.254 delta:711 weight:1425 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0xb21db8e2, 0xd4e65389, 0x66fbeb6b, 0x61700fed, 0xd36db70f, 0xb5965c64, 0x078be486, 0x00007046, 0xb21dc8a4, 0xd4e623cf, 0x66fb9b2d, 0x61707fab, 0xd36dc749, 0xb5962c22, 0x078b94c0}, - [16]uint32{0x00000000, 0x80021f16, 0x1800041c, 0x98021b0a, 0x20100011, 0xa0121f07, 0x3810040d, 0xb8121b1b, 0xc000101a, 0x40020f0c, 0xd8001406, 0x58020b10, 0xe010100b, 0x60120f1d, 0xf8101417, 0x78120b01}, - [16]uint32{0x3f800000, 0x3fc0010f, 0x3f8c0002, 0x3fcc010d, 0x3f900800, 0x3fd0090f, 0x3f9c0802, 0x3fdc090d, 0x3fe00008, 0x3fa00107, 0x3fec000a, 0x3fac0105, 0x3ff00808, 0x3fb00907, 0x3ffc080a, 0x3fbc0905}, - uint32(0xfff80000), - [21]string{"0x86", "0xc9", "0x7c", "0x93", "0x6b", "0x18", "0xc2", "0x59", "0xcd", "0x8e", "0x32", "0x73", "0x35", "0x8d", "0x77", "0x06", "0xdf", "0xbd", "0xea", "0x12", "0x00"}}, - { - /* No.255 delta:933 weight:1313 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x349456a5, 0x5a59f264, 0x6ecda4c1, 0x6b000ffb, 0x5f94595e, 0x3159fd9f, 0x05cdab3a, 0x0000e642, 0x3494b0e7, 0x5a591426, 0x6ecd4283, 0x6b00e9b9, 0x5f94bf1c, 0x31591bdd, 0x05cd4d78}, - [16]uint32{0x00000000, 0xa064199d, 0x00028c09, 0xa0669594, 0x0070160c, 0xa0140f91, 0x00729a05, 0xa0168398, 0x202d0013, 0x8049198e, 0x202f8c1a, 0x804b9587, 0x205d161f, 0x80390f82, 0x205f9a16, 0x803b838b}, - [16]uint32{0x3f800000, 0x3fd0320c, 0x3f800146, 0x3fd0334a, 0x3f80380b, 0x3fd00a07, 0x3f80394d, 0x3fd00b41, 0x3f901680, 0x3fc0248c, 0x3f9017c6, 0x3fc025ca, 0x3f902e8b, 0x3fc01c87, 0x3f902fcd, 0x3fc01dc1}, - uint32(0xfff80000), - [21]string{"0x45", "0x8b", "0x9e", "0x01", "0x37", "0x33", "0x2f", "0x18", "0xc2", "0x03", "0x68", "0x8a", "0x70", "0xc5", "0x62", "0xdb", "0xcc", "0xa0", "0x2d", "0x43", "0x00"}}, - { - /* No.256 delta:605 weight:1801 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x342137e7, 0x86f5904e, 0xb2d4a7a9, 0x1f30100c, 0x2b1127eb, 0x99c58042, 0xade4b7a5, 0x0000f1e9, 0x3421c60e, 0x86f561a7, 0xb2d45640, 0x1f30e1e5, 0x2b11d602, 0x99c571ab, 0xade4464c}, - [16]uint32{0x00000000, 0x6054283e, 0x402c6d03, 0x2078453d, 0x00032984, 0x605701ba, 0x402f4487, 0x207b6cb9, 0x00441390, 0x60103bae, 0x40687e93, 0x203c56ad, 0x00473a14, 0x6013122a, 0x406b5717, 0x203f7f29}, - [16]uint32{0x3f800000, 0x3fb02a14, 0x3fa01636, 0x3f903c22, 0x3f800194, 0x3fb02b80, 0x3fa017a2, 0x3f903db6, 0x3f802209, 0x3fb0081d, 0x3fa0343f, 0x3f901e2b, 0x3f80239d, 0x3fb00989, 0x3fa035ab, 0x3f901fbf}, - uint32(0xfff80000), - [21]string{"0x6a", "0x8c", "0x53", "0xa9", "0x17", "0xee", "0xbd", "0x72", "0x95", "0x5a", "0xce", "0xd3", "0x11", "0x5d", "0xa2", "0x36", "0xea", "0x74", "0x99", "0x2a", "0x00"}}, - { - /* No.257 delta:863 weight:1373 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xb7066e36, 0x2c98dbac, 0x9b9eb59a, 0x9b101010, 0x2c167e26, 0xb788cbbc, 0x008ea58a, 0x00006100, 0xb7060f36, 0x2c98baac, 0x9b9ed49a, 0x9b107110, 0x2c161f26, 0xb788aabc, 0x008ec48a}, - [16]uint32{0x00000000, 0x20401155, 0x101c1407, 0x305c0552, 0x1072a07c, 0x3032b129, 0x006eb47b, 0x202ea52e, 0x50204163, 0x70605036, 0x403c5564, 0x607c4431, 0x4052e11f, 0x6012f04a, 0x504ef518, 0x700ee44d}, - [16]uint32{0x3f800000, 0x3f902008, 0x3f880e0a, 0x3f982e02, 0x3f883950, 0x3f981958, 0x3f80375a, 0x3f901752, 0x3fa81020, 0x3fb83028, 0x3fa01e2a, 0x3fb03e22, 0x3fa02970, 0x3fb00978, 0x3fa8277a, 0x3fb80772}, - uint32(0xfff80000), - [21]string{"0xc8", "0xf8", "0xe1", "0x6d", "0x99", "0xea", "0x62", "0x89", "0x5e", "0xf6", "0x2a", "0x05", "0x18", "0x72", "0x7f", "0x94", "0xd4", "0xbc", "0x43", "0x2f", "0x00"}}, - { - /* No.258 delta:844 weight:1611 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x360179e6, 0x7d8f574e, 0x4b8e2ea8, 0xe3e01029, 0xd5e169cf, 0x9e6f4767, 0xa86e3e81, 0x0000388d, 0x3601416b, 0x7d8f6fc3, 0x4b8e1625, 0xe3e028a4, 0xd5e15142, 0x9e6f7fea, 0xa86e060c}, - [16]uint32{0x00000000, 0x0002359a, 0x38042137, 0x380614ad, 0x2001a0a4, 0x2003953e, 0x18058193, 0x1807b409, 0x10408054, 0x1042b5ce, 0x2844a163, 0x284694f9, 0x304120f0, 0x3043156a, 0x084501c7, 0x0847345d}, - [16]uint32{0x3f800000, 0x3f80011a, 0x3f9c0210, 0x3f9c030a, 0x3f9000d0, 0x3f9001ca, 0x3f8c02c0, 0x3f8c03da, 0x3f882040, 0x3f88215a, 0x3f942250, 0x3f94234a, 0x3f982090, 0x3f98218a, 0x3f842280, 0x3f84239a}, - uint32(0xfff80000), - [21]string{"0xfb", "0xdc", "0xb0", "0x3d", "0x31", "0x8e", "0x11", "0xf1", "0x4a", "0x02", "0xb2", "0x55", "0xda", "0xae", "0x59", "0x8f", "0x1a", "0x96", "0x73", "0x1d", "0x00"}}, - { - /* No.259 delta:992 weight:1607 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0xd8eeb2ae, 0xbb27aba5, 0x63c9190b, 0x0a701030, 0xd29ea29e, 0xb157bb95, 0x69b9093b, 0x0000f6ce, 0xd8ee4460, 0xbb275d6b, 0x63c9efc5, 0x0a70e6fe, 0xd29e5450, 0xb1574d5b, 0x69b9fff5}, - [16]uint32{0x00000000, 0x406b805a, 0x105c4107, 0x5037c15d, 0x00020011, 0x4069804b, 0x105e4116, 0x5035c14c, 0x000360ee, 0x4068e0b4, 0x105f21e9, 0x5034a1b3, 0x000160ff, 0x406ae0a5, 0x105d21f8, 0x5036a1a2}, - [16]uint32{0x3f800000, 0x3fa035c0, 0x3f882e20, 0x3fa81be0, 0x3f800100, 0x3fa034c0, 0x3f882f20, 0x3fa81ae0, 0x3f8001b0, 0x3fa03470, 0x3f882f90, 0x3fa81a50, 0x3f8000b0, 0x3fa03570, 0x3f882e90, 0x3fa81b50}, - uint32(0xfff80000), - [21]string{"0xf3", "0xf4", "0xf3", "0x13", "0xb4", "0xd8", "0xeb", "0xf3", "0xc0", "0xd5", "0xea", "0x82", "0xf4", "0x00", "0xb5", "0x10", "0xcf", "0xe7", "0x19", "0x71", "0x00"}}, - { - /* No.260 delta:1024 weight:1663 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0xd7afe2a0, 0xd521d695, 0x028e3435, 0xdfb0104f, 0x081ff2ef, 0x0a91c6da, 0xdd3e247a, 0x00007d7d, 0xd7af9fdd, 0xd521abe8, 0x028e4948, 0xdfb06d32, 0x081f8f92, 0x0a91bba7, 0xdd3e5907}, - [16]uint32{0x00000000, 0x346a0796, 0x005c830f, 0x34368499, 0x00720015, 0x34180783, 0x002e831a, 0x3444848c, 0x00030169, 0x346906ff, 0x005f8266, 0x343585f0, 0x0071017c, 0x341b06ea, 0x002d8273, 0x344785e5}, - [16]uint32{0x3f800000, 0x3f9a3503, 0x3f802e41, 0x3f9a1b42, 0x3f803900, 0x3f9a0c03, 0x3f801741, 0x3f9a2242, 0x3f800180, 0x3f9a3483, 0x3f802fc1, 0x3f9a1ac2, 0x3f803880, 0x3f9a0d83, 0x3f8016c1, 0x3f9a23c2}, - uint32(0xfff80000), - [21]string{"0xa1", "0x73", "0x91", "0x1d", "0x3a", "0x48", "0xba", "0xbe", "0x46", "0x5c", "0xa1", "0x3d", "0x32", "0x83", "0x48", "0xcb", "0xb5", "0x5e", "0x31", "0xec", "0x00"}}, - { - /* No.261 delta:1296 weight:1559 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xb4eadce0, 0xf6b33791, 0x4259eb71, 0x5370105f, 0xe79accbf, 0xa5c327ce, 0x1129fb2e, 0x00005bbe, 0xb4ea875e, 0xf6b36c2f, 0x4259b0cf, 0x53704be1, 0xe79a9701, 0xa5c37c70, 0x1129a090}, - [16]uint32{0x00000000, 0x003c00f2, 0x00526c15, 0x006e6ce7, 0x444121d8, 0x447d212a, 0x44134dcd, 0x442f4d3f, 0x5040517b, 0x507c5189, 0x50123d6e, 0x502e3d9c, 0x140170a3, 0x143d7051, 0x14531cb6, 0x146f1c44}, - [16]uint32{0x3f800000, 0x3f801e00, 0x3f802936, 0x3f803736, 0x3fa22090, 0x3fa23e90, 0x3fa209a6, 0x3fa217a6, 0x3fa82028, 0x3fa83e28, 0x3fa8091e, 0x3fa8171e, 0x3f8a00b8, 0x3f8a1eb8, 0x3f8a298e, 0x3f8a378e}, - uint32(0xfff80000), - [21]string{"0x39", "0xec", "0xa1", "0x9c", "0xfe", "0x15", "0x24", "0x8f", "0x79", "0x2a", "0xe2", "0x1b", "0x4b", "0x1f", "0x3b", "0x93", "0xc2", "0xf8", "0xfe", "0x28", "0x00"}}, - { - /* No.262 delta:1036 weight:1361 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x2b06a8a3, 0x088b8a7e, 0x238d22dd, 0x84a0106f, 0xafa6b8cc, 0x8c2b9a11, 0xa72d32b2, 0x00007f70, 0x2b06d7d3, 0x088bf50e, 0x238d5dad, 0x84a06f1f, 0xafa6c7bc, 0x8c2be561, 0xa72d4dc2}, - [16]uint32{0x00000000, 0x104ea5f6, 0x0002781c, 0x104cddea, 0x2014148f, 0x305ab179, 0x20166c93, 0x3058c965, 0x4004020e, 0x504aa7f8, 0x40067a12, 0x5048dfe4, 0x60101681, 0x705eb377, 0x60126e9d, 0x705ccb6b}, - [16]uint32{0x3f800000, 0x3f882752, 0x3f80013c, 0x3f88266e, 0x3f900a0a, 0x3f982d58, 0x3f900b36, 0x3f982c64, 0x3fa00201, 0x3fa82553, 0x3fa0033d, 0x3fa8246f, 0x3fb0080b, 0x3fb82f59, 0x3fb00937, 0x3fb82e65}, - uint32(0xfff80000), - [21]string{"0x8c", "0xc5", "0x0c", "0x35", "0x11", "0x9b", "0x8d", "0x08", "0xef", "0x18", "0xf5", "0x67", "0x99", "0x5d", "0x0b", "0x26", "0x1e", "0xca", "0x92", "0x53", "0x00"}}, - { - /* No.263 delta:2453 weight:1089 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0x458429b4, 0x7cef26c1, 0x396b0f75, 0x4320107b, 0x06a439cf, 0x3fcf36ba, 0x7a4b1f0e, 0x0000f056, 0x4584d9e2, 0x7cefd697, 0x396bff23, 0x4320e02d, 0x06a4c999, 0x3fcfc6ec, 0x7a4bef58}, - [16]uint32{0x00000000, 0xf34c009a, 0x2c8290eb, 0xdfce9071, 0x0c60dc1d, 0xff2cdc87, 0x20e24cf6, 0xd3ae4c6c, 0x8100a015, 0x724ca08f, 0xad8230fe, 0x5ece3064, 0x8d607c08, 0x7e2c7c92, 0xa1e2ece3, 0x52aeec79}, - [16]uint32{0x3f800000, 0x3ff9a600, 0x3f964148, 0x3fefe748, 0x3f86306e, 0x3fff966e, 0x3f907126, 0x3fe9d726, 0x3fc08050, 0x3fb92650, 0x3fd6c118, 0x3faf6718, 0x3fc6b03e, 0x3fbf163e, 0x3fd0f176, 0x3fa95776}, - uint32(0xfff80000), - [21]string{"0x94", "0x05", "0x08", "0x43", "0xc1", "0xf2", "0xec", "0xc6", "0x72", "0xf9", "0x7b", "0x5f", "0x0b", "0xb7", "0x20", "0x90", "0xa1", "0x0c", "0x05", "0xc3", "0x00"}}, - { - /* No.264 delta:2296 weight:1275 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x6d36c21f, 0x2d55d337, 0x40631128, 0x40101082, 0x2d26d29d, 0x6d45c3b5, 0x007301aa, 0x0000fec9, 0x6d363cd6, 0x2d552dfe, 0x4063efe1, 0x4010ee4b, 0x2d262c54, 0x6d453d7c, 0x0073ff63}, - [16]uint32{0x00000000, 0x91d0823c, 0x01433183, 0x9093b3bf, 0x08238018, 0x99f30224, 0x0960b19b, 0x98b033a7, 0x284041e9, 0xb990c3d5, 0x2903706a, 0xb8d3f256, 0x2063c1f1, 0xb1b343cd, 0x2120f072, 0xb0f0724e}, - [16]uint32{0x3f800000, 0x3fc8e841, 0x3f80a198, 0x3fc849d9, 0x3f8411c0, 0x3fccf981, 0x3f84b058, 0x3fcc5819, 0x3f942020, 0x3fdcc861, 0x3f9481b8, 0x3fdc69f9, 0x3f9031e0, 0x3fd8d9a1, 0x3f909078, 0x3fd87839}, - uint32(0xfff80000), - [21]string{"0xb5", "0xe7", "0x9a", "0xf6", "0x8c", "0xb1", "0x53", "0x83", "0xaa", "0xdc", "0x4f", "0xd1", "0x27", "0xbd", "0x92", "0xce", "0x9a", "0x97", "0xf6", "0x5d", "0x00"}}, - { - /* No.265 delta:1158 weight:1607 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0xc81c6b49, 0x43c14ad1, 0x8bdd2198, 0x4bf01098, 0x83ec7bd1, 0x08315a49, 0xc02d3100, 0x0000415a, 0xc81c2a13, 0x43c10b8b, 0x8bdd60c2, 0x4bf051c2, 0x83ec3a8b, 0x08311b13, 0xc02d705a}, - [16]uint32{0x00000000, 0x407d1df6, 0x002288e3, 0x405f9515, 0x004109da, 0x403c142c, 0x00638139, 0x401e9ccf, 0x400090de, 0x007d8d28, 0x4022183d, 0x005f05cb, 0x40419904, 0x003c84f2, 0x406311e7, 0x001e0c11}, - [16]uint32{0x3f800000, 0x3fa03e8e, 0x3f801144, 0x3fa02fca, 0x3f802084, 0x3fa01e0a, 0x3f8031c0, 0x3fa00f4e, 0x3fa00048, 0x3f803ec6, 0x3fa0110c, 0x3f802f82, 0x3fa020cc, 0x3f801e42, 0x3fa03188, 0x3f800f06}, - uint32(0xfff80000), - [21]string{"0x8d", "0x79", "0x23", "0x39", "0x76", "0x1c", "0x07", "0xdc", "0x6e", "0x0b", "0x77", "0xe9", "0xca", "0xc2", "0x1e", "0xd5", "0x38", "0x40", "0xdc", "0x78", "0x00"}}, - { - /* No.266 delta:846 weight:1549 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0xfafaddf3, 0x7291565f, 0x886b8bac, 0xcf0010ac, 0x35facd5f, 0xbd9146f3, 0x476b9b00, 0x0000950e, 0xfafa48fd, 0x7291c351, 0x886b1ea2, 0xcf0085a2, 0x35fa5851, 0xbd91d3fd, 0x476b0e0e}, - [16]uint32{0x00000000, 0x00412d7a, 0x20048415, 0x2045a96f, 0x402211bc, 0x40633cc6, 0x602695a9, 0x6067b8d3, 0x00020117, 0x00432c6d, 0x20068502, 0x2047a878, 0x402010ab, 0x40613dd1, 0x602494be, 0x6065b9c4}, - [16]uint32{0x3f800000, 0x3f802096, 0x3f900242, 0x3f9022d4, 0x3fa01108, 0x3fa0319e, 0x3fb0134a, 0x3fb033dc, 0x3f800100, 0x3f802196, 0x3f900342, 0x3f9023d4, 0x3fa01008, 0x3fa0309e, 0x3fb0124a, 0x3fb032dc}, - uint32(0xfff80000), - [21]string{"0x62", "0xdc", "0x6e", "0x67", "0x1c", "0xbc", "0xab", "0x5f", "0xd4", "0x36", "0x3c", "0x45", "0x2a", "0xee", "0x29", "0xad", "0xcd", "0xf4", "0x0e", "0x8b", "0x00"}}, - { - /* No.267 delta:913 weight:1567 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0x4f356cb4, 0x0cbf6d0c, 0x438a01b8, 0x18b010b3, 0x57857c07, 0x140f7dbf, 0x5b3a110b, 0x000019a5, 0x4f357511, 0x0cbf74a9, 0x438a181d, 0x18b00916, 0x578565a2, 0x140f641a, 0x5b3a08ae}, - [16]uint32{0x00000000, 0x00048272, 0x02005f69, 0x0204dd1b, 0x0403b813, 0x04073a61, 0x0603e77a, 0x06076508, 0x20001016, 0x20049264, 0x22004f7f, 0x2204cd0d, 0x2403a805, 0x24072a77, 0x2603f76c, 0x2607751e}, - [16]uint32{0x3f800000, 0x3f800241, 0x3f81002f, 0x3f81026e, 0x3f8201dc, 0x3f82039d, 0x3f8301f3, 0x3f8303b2, 0x3f900008, 0x3f900249, 0x3f910027, 0x3f910266, 0x3f9201d4, 0x3f920395, 0x3f9301fb, 0x3f9303ba}, - uint32(0xfff80000), - [21]string{"0x30", "0x6f", "0xbb", "0x9a", "0x32", "0xf0", "0x90", "0xbb", "0x63", "0x06", "0xf6", "0x11", "0x8c", "0xd3", "0xfc", "0x59", "0xbd", "0x92", "0xbe", "0x9a", "0x00"}}, - { - /* No.268 delta:1119 weight:1599 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x9541706b, 0xd1114ada, 0x44503ab1, 0x1cc010c0, 0x898160ab, 0xcdd15a1a, 0x58902a71, 0x00006fc3, 0x95411fa8, 0xd1112519, 0x44505572, 0x1cc07f03, 0x89810f68, 0xcdd135d9, 0x589045b2}, - [16]uint32{0x00000000, 0x122f889e, 0x0047c15c, 0x126849c2, 0x00016049, 0x122ee8d7, 0x0046a115, 0x1269298b, 0x00001003, 0x122f989d, 0x0047d15f, 0x126859c1, 0x0001704a, 0x122ef8d4, 0x0046b116, 0x12693988}, - [16]uint32{0x3f800000, 0x3f8917c4, 0x3f8023e0, 0x3f893424, 0x3f8000b0, 0x3f891774, 0x3f802350, 0x3f893494, 0x3f800008, 0x3f8917cc, 0x3f8023e8, 0x3f89342c, 0x3f8000b8, 0x3f89177c, 0x3f802358, 0x3f89349c}, - uint32(0xfff80000), - [21]string{"0xda", "0x1c", "0xfa", "0x88", "0x67", "0x70", "0x8b", "0xf7", "0x03", "0x1b", "0x66", "0x13", "0x62", "0xdd", "0x6d", "0xeb", "0xad", "0xfa", "0xf2", "0x5b", "0x00"}}, - { - /* No.269 delta:1697 weight:1573 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x4d9d43f2, 0xaef042ac, 0xe36d015e, 0xed2010d6, 0xa0bd5324, 0x43d0527a, 0x0e4d1188, 0x0000ade0, 0x4d9dee12, 0xaef0ef4c, 0xe36dacbe, 0xed20bd36, 0xa0bdfec4, 0x43d0ff9a, 0x0e4dbc68}, - [16]uint32{0x00000000, 0x4b91e1dd, 0x0d05a42b, 0x469445f6, 0x0100484c, 0x4a91a991, 0x0c05ec67, 0x47940dba, 0x0463801f, 0x4ff261c2, 0x09662434, 0x42f7c5e9, 0x0563c853, 0x4ef2298e, 0x08666c78, 0x43f78da5}, - [16]uint32{0x3f800000, 0x3fa5c8f0, 0x3f8682d2, 0x3fa34a22, 0x3f808024, 0x3fa548d4, 0x3f8602f6, 0x3fa3ca06, 0x3f8231c0, 0x3fa7f930, 0x3f84b312, 0x3fa17be2, 0x3f82b1e4, 0x3fa77914, 0x3f843336, 0x3fa1fbc6}, - uint32(0xfff80000), - [21]string{"0x5c", "0xd8", "0x63", "0xbe", "0xba", "0x24", "0x1c", "0x39", "0x86", "0xd4", "0x6a", "0xa6", "0x66", "0x0d", "0x5c", "0x89", "0x96", "0x7c", "0x26", "0x0d", "0x00"}}, - { - /* No.270 delta:756 weight:1637 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0xabb61e82, 0xc736718e, 0x6c806f0c, 0x094010e1, 0xa2f60e63, 0xce76616f, 0x65c07fed, 0x000015ec, 0xabb60b6e, 0xc7366462, 0x6c807ae0, 0x0940050d, 0xa2f61b8f, 0xce767483, 0x65c06a01}, - [16]uint32{0x00000000, 0x112e80f6, 0x0045b007, 0x116b30f1, 0x00020c18, 0x112c8cee, 0x0047bc1f, 0x11693ce9, 0x1000580c, 0x012ed8fa, 0x1045e80b, 0x016b68fd, 0x10025414, 0x012cd4e2, 0x1047e413, 0x016964e5}, - [16]uint32{0x3f800000, 0x3f889740, 0x3f8022d8, 0x3f88b598, 0x3f800106, 0x3f889646, 0x3f8023de, 0x3f88b49e, 0x3f88002c, 0x3f80976c, 0x3f8822f4, 0x3f80b5b4, 0x3f88012a, 0x3f80966a, 0x3f8823f2, 0x3f80b4b2}, - uint32(0xfff80000), - [21]string{"0xd0", "0xe9", "0x18", "0x44", "0xaf", "0x9f", "0x2f", "0x8a", "0xd3", "0xb5", "0x95", "0x44", "0xbb", "0x80", "0x3d", "0x72", "0xbd", "0x1e", "0x62", "0xad", "0x00"}}, - { - /* No.271 delta:1600 weight:1575 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x70c8924a, 0x9c076e90, 0xeccffcda, 0x5f0010fa, 0x2fc882b0, 0xc3077e6a, 0xb3cfec20, 0x00008d22, 0x70c81f68, 0x9c07e3b2, 0xeccf71f8, 0x5f009dd8, 0x2fc80f92, 0xc307f348, 0xb3cf6102}, - [16]uint32{0x00000000, 0x007c00bd, 0x2004008e, 0x20780033, 0x00020017, 0x007e00aa, 0x20060099, 0x207a0024, 0x004001cc, 0x003c0171, 0x20440142, 0x203801ff, 0x004201db, 0x003e0166, 0x20460155, 0x203a01e8}, - [16]uint32{0x3f800000, 0x3f803e00, 0x3f900200, 0x3f903c00, 0x3f800100, 0x3f803f00, 0x3f900300, 0x3f903d00, 0x3f802000, 0x3f801e00, 0x3f902200, 0x3f901c00, 0x3f802100, 0x3f801f00, 0x3f902300, 0x3f901d00}, - uint32(0xfff80000), - [21]string{"0xe4", "0x54", "0xe8", "0xd1", "0xa5", "0xea", "0x2d", "0x86", "0x55", "0xac", "0x70", "0xd0", "0x6d", "0x7c", "0x84", "0xc1", "0xdb", "0xbe", "0x53", "0x9a", "0x00"}}, - { - /* No.272 delta:728 weight:1065 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xc21c2ebb, 0xf24cb725, 0x3050999e, 0xd1a0110a, 0x13bc3fb1, 0x23eca62f, 0xe1f08894, 0x00005f5d, 0xc21c71e6, 0xf24ce878, 0x3050c6c3, 0xd1a04e57, 0x13bc60ec, 0x23ecf972, 0xe1f0d7c9}, - [16]uint32{0x00000000, 0x784401f7, 0x18008c1d, 0x60448dea, 0x10444818, 0x680049ef, 0x0844c405, 0x7000c5f2, 0x200ba06b, 0x584fa19c, 0x380b2c76, 0x404f2d81, 0x304fe873, 0x480be984, 0x284f646e, 0x500b6599}, - [16]uint32{0x3f800000, 0x3fbc2200, 0x3f8c0046, 0x3fb02246, 0x3f882224, 0x3fb40024, 0x3f842262, 0x3fb80062, 0x3f9005d0, 0x3fac27d0, 0x3f9c0596, 0x3fa02796, 0x3f9827f4, 0x3fa405f4, 0x3f9427b2, 0x3fa805b2}, - uint32(0xfff80000), - [21]string{"0xdd", "0x63", "0xa5", "0x3a", "0x9a", "0x9b", "0x18", "0xeb", "0xf0", "0x0c", "0x73", "0x50", "0xb9", "0x71", "0x9e", "0x6e", "0x27", "0x9e", "0x31", "0x4a", "0x00"}}, - { - /* No.273 delta:1358 weight:1725 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0xda0ac527, 0x6467f2c3, 0xbe6d37e4, 0xce701116, 0x147ad431, 0xaa17e3d5, 0x701d26f2, 0x0000b1f7, 0xda0a74d0, 0x64674334, 0xbe6d8613, 0xce70a0e1, 0x147a65c6, 0xaa175222, 0x701d9705}, - [16]uint32{0x00000000, 0x01746c56, 0x005ac03c, 0x012eac6a, 0x50580017, 0x512c6c41, 0x5002c02b, 0x5176ac7d, 0x002c8c18, 0x0158e04e, 0x00764c24, 0x01022072, 0x50748c0f, 0x5100e059, 0x502e4c33, 0x515a2065}, - [16]uint32{0x3f800000, 0x3f80ba36, 0x3f802d60, 0x3f809756, 0x3fa82c00, 0x3fa89636, 0x3fa80160, 0x3fa8bb56, 0x3f801646, 0x3f80ac70, 0x3f803b26, 0x3f808110, 0x3fa83a46, 0x3fa88070, 0x3fa81726, 0x3fa8ad10}, - uint32(0xfff80000), - [21]string{"0x44", "0x41", "0xba", "0xab", "0xdc", "0xf8", "0xf7", "0xcd", "0x33", "0x44", "0x35", "0xe2", "0x3b", "0xc0", "0x47", "0x81", "0x9e", "0x05", "0x22", "0xd7", "0x00"}}, - { - /* No.274 delta:1122 weight:787 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0xce9bde90, 0x699bdce0, 0xa7000270, 0xa0801120, 0x6e1bcfb0, 0xc91bcdc0, 0x07801350, 0x00009101, 0xce9b4f91, 0x699b4de1, 0xa7009371, 0xa0808021, 0x6e1b5eb1, 0xc91b5cc1, 0x07808251}, - [16]uint32{0x00000000, 0x002ca953, 0x44104016, 0x443ce945, 0x0823099b, 0x080fa0c8, 0x4c33498d, 0x4c1fe0de, 0x0078806a, 0x00542939, 0x4468c07c, 0x4444692f, 0x085b89f1, 0x087720a2, 0x4c4bc9e7, 0x4c6760b4}, - [16]uint32{0x3f800000, 0x3f801654, 0x3fa20820, 0x3fa21e74, 0x3f841184, 0x3f8407d0, 0x3fa619a4, 0x3fa60ff0, 0x3f803c40, 0x3f802a14, 0x3fa23460, 0x3fa22234, 0x3f842dc4, 0x3f843b90, 0x3fa625e4, 0x3fa633b0}, - uint32(0xfff80000), - [21]string{"0xf9", "0x2c", "0x8f", "0xd2", "0xf9", "0x88", "0x4d", "0x07", "0xb0", "0xea", "0x2d", "0x5c", "0xad", "0xcb", "0xb3", "0x0d", "0xd1", "0x1e", "0x5a", "0x63", "0x00"}}, - { - /* No.275 delta:950 weight:1249 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x7e6d7d4f, 0x69588448, 0x1735f907, 0x2fd0113b, 0x51bd6c74, 0x46889573, 0x38e5e83c, 0x0000563b, 0x7e6d2b74, 0x6958d273, 0x1735af3c, 0x2fd04700, 0x51bd3a4f, 0x4688c348, 0x38e5be07}, - [16]uint32{0x00000000, 0x000678d2, 0x000a29b5, 0x000c5167, 0x04011c18, 0x040764ca, 0x040b35ad, 0x040d4d7f, 0x6039981b, 0x603fe0c9, 0x6033b1ae, 0x6035c97c, 0x64388403, 0x643efcd1, 0x6432adb6, 0x6434d564}, - [16]uint32{0x3f800000, 0x3f80033c, 0x3f800514, 0x3f800628, 0x3f82008e, 0x3f8203b2, 0x3f82059a, 0x3f8206a6, 0x3fb01ccc, 0x3fb01ff0, 0x3fb019d8, 0x3fb01ae4, 0x3fb21c42, 0x3fb21f7e, 0x3fb21956, 0x3fb21a6a}, - uint32(0xfff80000), - [21]string{"0xb4", "0x0a", "0x68", "0xbf", "0x57", "0xdf", "0x2f", "0x96", "0xc5", "0xfb", "0xb2", "0x72", "0xaf", "0x76", "0x35", "0xd9", "0x37", "0x35", "0xff", "0x40", "0x00"}}, - { - /* No.276 delta:1838 weight:1567 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x8b4d8ae9, 0x70653340, 0xfb28b9a9, 0x3e801148, 0xb5cd9ba1, 0x4ee52208, 0xc5a8a8e1, 0x00002645, 0x8b4dacac, 0x70651505, 0xfb289fec, 0x3e80370d, 0xb5cdbde4, 0x4ee5044d, 0xc5a88ea4}, - [16]uint32{0x00000000, 0x0a04137a, 0x20020411, 0x2a06176b, 0x05041cbe, 0x0f000fc4, 0x250618af, 0x2f020bd5, 0x40c60c06, 0x4ac21f7c, 0x60c40817, 0x6ac01b6d, 0x45c210b8, 0x4fc603c2, 0x65c014a9, 0x6fc407d3}, - [16]uint32{0x3f800000, 0x3f850209, 0x3f900102, 0x3f95030b, 0x3f82820e, 0x3f878007, 0x3f92830c, 0x3f978105, 0x3fa06306, 0x3fa5610f, 0x3fb06204, 0x3fb5600d, 0x3fa2e108, 0x3fa7e301, 0x3fb2e00a, 0x3fb7e203}, - uint32(0xfff80000), - [21]string{"0x94", "0xe1", "0x7d", "0x1d", "0x8d", "0x35", "0x00", "0xf2", "0x61", "0x59", "0x41", "0x7c", "0x87", "0x05", "0xa8", "0xe8", "0xb7", "0x2b", "0xfd", "0x93", "0x00"}}, - { - /* No.277 delta:1254 weight:1607 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0xd0891025, 0x727f3781, 0xa2f627a4, 0x46a0115d, 0x96290178, 0x34df26dc, 0xe45636f9, 0x00006a97, 0xd0897ab2, 0x727f5d16, 0xa2f64d33, 0x46a07bca, 0x96296bef, 0x34df4c4b, 0xe4565c6e}, - [16]uint32{0x00000000, 0x00456212, 0x103acf0c, 0x107fad1e, 0x000328af, 0x00464abd, 0x1039e7a3, 0x107c85b1, 0x6024c4c4, 0x6061a6d6, 0x701e0bc8, 0x705b69da, 0x6027ec6b, 0x60628e79, 0x701d2367, 0x70584175}, - [16]uint32{0x3f800000, 0x3f8022b1, 0x3f881d67, 0x3f883fd6, 0x3f800194, 0x3f802325, 0x3f881cf3, 0x3f883e42, 0x3fb01262, 0x3fb030d3, 0x3fb80f05, 0x3fb82db4, 0x3fb013f6, 0x3fb03147, 0x3fb80e91, 0x3fb82c20}, - uint32(0xfff80000), - [21]string{"0x5b", "0x30", "0x99", "0x8d", "0xb2", "0x61", "0xf4", "0x48", "0x1b", "0x40", "0x8e", "0xa6", "0x36", "0x25", "0xf0", "0x06", "0xce", "0xc1", "0x2f", "0xfb", "0x00"}}, - { - /* No.278 delta:782 weight:1549 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0x2309b04c, 0x25f485a4, 0x06fd35e8, 0xcc50116d, 0xef59a121, 0xe9a494c9, 0xcaad2485, 0x00003120, 0x2309816c, 0x25f4b484, 0x06fd04c8, 0xcc50204d, 0xef599001, 0xe9a4a5e9, 0xcaad15a5}, - [16]uint32{0x00000000, 0x4003f13a, 0x4006199d, 0x0005e8a7, 0x80104014, 0xc013b12e, 0xc0165989, 0x8015a8b3, 0x000280c2, 0x400171f8, 0x4004995f, 0x00076865, 0x8012c0d6, 0xc01131ec, 0xc014d94b, 0x80172871}, - [16]uint32{0x3f800000, 0x3fa001f8, 0x3fa0030c, 0x3f8002f4, 0x3fc00820, 0x3fe009d8, 0x3fe00b2c, 0x3fc00ad4, 0x3f800140, 0x3fa000b8, 0x3fa0024c, 0x3f8003b4, 0x3fc00960, 0x3fe00898, 0x3fe00a6c, 0x3fc00b94}, - uint32(0xfff80000), - [21]string{"0x98", "0x6c", "0x92", "0x22", "0xba", "0x4a", "0x8c", "0x3f", "0x27", "0xbc", "0x64", "0x8e", "0x0c", "0x12", "0xfc", "0x5d", "0x2e", "0xb9", "0x5d", "0x2d", "0x00"}}, - { - /* No.279 delta:964 weight:1583 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0x64b5ae78, 0xddc790e6, 0xb9723e9e, 0xb280117a, 0xd635bf02, 0x6f47819c, 0x0bf22fe4, 0x0000343e, 0x64b59a46, 0xddc7a4d8, 0xb9720aa0, 0xb2802544, 0xd6358b3c, 0x6f47b5a2, 0x0bf21bda}, - [16]uint32{0x00000000, 0x202c40d5, 0x000214bf, 0x202e546a, 0x70182913, 0x503469c6, 0x701a3dac, 0x50367d79, 0x00002838, 0x202c68ed, 0x00023c87, 0x202e7c52, 0x7018012b, 0x503441fe, 0x701a1594, 0x50365541}, - [16]uint32{0x3f800000, 0x3f901620, 0x3f80010a, 0x3f90172a, 0x3fb80c14, 0x3fa81a34, 0x3fb80d1e, 0x3fa81b3e, 0x3f800014, 0x3f901634, 0x3f80011e, 0x3f90173e, 0x3fb80c00, 0x3fa81a20, 0x3fb80d0a, 0x3fa81b2a}, - uint32(0xfff80000), - [21]string{"0x00", "0x2b", "0x78", "0xb7", "0x08", "0x0d", "0x4a", "0xdd", "0xda", "0xb1", "0x47", "0xe7", "0x4e", "0xf9", "0xfd", "0x3f", "0xcb", "0xd1", "0x68", "0x60", "0x00"}}, - { - /* No.280 delta:891 weight:1215 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0x80f61612, 0xe0421e2f, 0x60b4083d, 0xff601181, 0x7f960793, 0x1f220fae, 0x9fd419bc, 0x0000cd04, 0x80f6db16, 0xe042d32b, 0x60b4c539, 0xff60dc85, 0x7f96ca97, 0x1f22c2aa, 0x9fd4d4b8}, - [16]uint32{0x00000000, 0x200a8bfa, 0x00021119, 0x20089ae3, 0x88010051, 0xa80b8bab, 0x88031148, 0xa8099ab2, 0x0803801f, 0x28090be5, 0x08019106, 0x280b1afc, 0x8002804e, 0xa0080bb4, 0x80009157, 0xa00a1aad}, - [16]uint32{0x3f800000, 0x3f900545, 0x3f800108, 0x3f90044d, 0x3fc40080, 0x3fd405c5, 0x3fc40188, 0x3fd404cd, 0x3f8401c0, 0x3f940485, 0x3f8400c8, 0x3f94058d, 0x3fc00140, 0x3fd00405, 0x3fc00048, 0x3fd0050d}, - uint32(0xfff80000), - [21]string{"0xe0", "0x92", "0x4f", "0xbe", "0x53", "0xa9", "0x47", "0x7a", "0x31", "0x29", "0xb2", "0x7d", "0xb5", "0xd6", "0x3c", "0x0e", "0x44", "0x1c", "0x2a", "0x9f", "0x00"}}, - { - /* No.281 delta:718 weight:1617 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xd0eacbf9, 0x6f9819c7, 0xbf72d23e, 0x24301190, 0xf4dada69, 0x4ba80857, 0x9b42c3ae, 0x00003866, 0xd0eaf39f, 0x6f9821a1, 0xbf72ea58, 0x243029f6, 0xf4dae20f, 0x4ba83031, 0x9b42fbc8}, - [16]uint32{0x00000000, 0x30441012, 0x2020d0e6, 0x1064c0f4, 0x0015400a, 0x30515018, 0x203590ec, 0x107180fe, 0x10063009, 0x2042201b, 0x3026e0ef, 0x0062f0fd, 0x10137003, 0x20576011, 0x3033a0e5, 0x0077b0f7}, - [16]uint32{0x3f800000, 0x3f982208, 0x3f901068, 0x3f883260, 0x3f800aa0, 0x3f9828a8, 0x3f901ac8, 0x3f8838c0, 0x3f880318, 0x3f902110, 0x3f981370, 0x3f803178, 0x3f8809b8, 0x3f902bb0, 0x3f9819d0, 0x3f803bd8}, - uint32(0xfff80000), - [21]string{"0x05", "0x57", "0xfa", "0xe9", "0xae", "0x63", "0x42", "0x79", "0x73", "0x85", "0x07", "0xdd", "0x6f", "0xfc", "0x41", "0x80", "0xac", "0x70", "0x23", "0xbb", "0x00"}}, - { - /* No.282 delta:753 weight:1359 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x224604fe, 0x681e2258, 0x4a5826a6, 0x148011a3, 0x36c6155d, 0x7c9e33fb, 0x5ed83705, 0x000032ce, 0x22463630, 0x681e1096, 0x4a581468, 0x1480236d, 0x36c62793, 0x7c9e0135, 0x5ed805cb}, - [16]uint32{0x00000000, 0x0005003e, 0x200081a5, 0x2005819b, 0x000200f4, 0x000700ca, 0x20028151, 0x2007816f, 0x3020281d, 0x30252823, 0x1020a9b8, 0x1025a986, 0x302228e9, 0x302728d7, 0x1022a94c, 0x1027a972}, - [16]uint32{0x3f800000, 0x3f800280, 0x3f900040, 0x3f9002c0, 0x3f800100, 0x3f800380, 0x3f900140, 0x3f9003c0, 0x3f981014, 0x3f981294, 0x3f881054, 0x3f8812d4, 0x3f981114, 0x3f981394, 0x3f881154, 0x3f8813d4}, - uint32(0xfff80000), - [21]string{"0x3f", "0xd5", "0xce", "0x0a", "0x76", "0x47", "0x21", "0x51", "0xd3", "0x4e", "0xaa", "0xe4", "0x2a", "0xed", "0x46", "0xa5", "0x91", "0xd8", "0x9f", "0x2f", "0x00"}}, - { - /* No.283 delta:947 weight:1779 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0xaec76b1f, 0x658b179b, 0xcb4c7c84, 0xe21011b0, 0x4cd77aaf, 0x879b062b, 0x295c6d34, 0x00006807, 0xaec70318, 0x658b7f9c, 0xcb4c1483, 0xe21079b7, 0x4cd712a8, 0x879b6e2c, 0x295c0533}, - [16]uint32{0x00000000, 0x003d799a, 0x4056040c, 0x406b7d96, 0x00021015, 0x003f698f, 0x40541419, 0x40696d83, 0x10503202, 0x106d4b98, 0x5006360e, 0x503b4f94, 0x10522217, 0x106f5b8d, 0x5004261b, 0x50395f81}, - [16]uint32{0x3f800000, 0x3f801ebc, 0x3fa02b02, 0x3fa035be, 0x3f800108, 0x3f801fb4, 0x3fa02a0a, 0x3fa034b6, 0x3f882819, 0x3f8836a5, 0x3fa8031b, 0x3fa81da7, 0x3f882911, 0x3f8837ad, 0x3fa80213, 0x3fa81caf}, - uint32(0xfff80000), - [21]string{"0x2b", "0x0f", "0xe1", "0xde", "0xb8", "0x2e", "0x98", "0xe4", "0x72", "0xda", "0x9f", "0xbe", "0xd4", "0x7e", "0x12", "0x72", "0x2a", "0xbf", "0xc0", "0xbd", "0x00"}}, - { - /* No.284 delta:1490 weight:1675 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x619dbdb3, 0xf6a0f779, 0x973d4aca, 0x9f3011c2, 0xfeadac71, 0x6990e6bb, 0x080d5b08, 0x0000aa9b, 0x619d1728, 0xf6a05de2, 0x973de051, 0x9f30bb59, 0xfead06ea, 0x69904c20, 0x080df193}, - [16]uint32{0x00000000, 0x0ec1421c, 0x1194a576, 0x1f55e76a, 0x005c0501, 0x0e9d471d, 0x11c8a077, 0x1f09e26b, 0x0106c1be, 0x0fc783a2, 0x109264c8, 0x1e5326d4, 0x015ac4bf, 0x0f9b86a3, 0x10ce61c9, 0x1e0f23d5}, - [16]uint32{0x3f800000, 0x3f8760a1, 0x3f88ca52, 0x3f8faaf3, 0x3f802e02, 0x3f874ea3, 0x3f88e450, 0x3f8f84f1, 0x3f808360, 0x3f87e3c1, 0x3f884932, 0x3f8f2993, 0x3f80ad62, 0x3f87cdc3, 0x3f886730, 0x3f8f0791}, - uint32(0xfff80000), - [21]string{"0x6a", "0x53", "0xfa", "0x26", "0x33", "0xa8", "0x93", "0x37", "0xfc", "0x50", "0xa0", "0xf2", "0xff", "0xaf", "0x75", "0x8f", "0xcd", "0x66", "0xd2", "0xb9", "0x00"}}, - { - /* No.285 delta:3095 weight:661 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xe7c9b0cb, 0xc5282bcc, 0x22e19b07, 0x3c1011dc, 0xdbd9a117, 0xf9383a10, 0x1ef18adb, 0x0000e809, 0xe7c958c2, 0xc528c3c5, 0x22e1730e, 0x3c10f9d5, 0xdbd9491e, 0xf938d219, 0x1ef162d2}, - [16]uint32{0x00000000, 0x8e5e0433, 0x24138167, 0xaa4d8554, 0xfa41240b, 0x741f2038, 0xde52a56c, 0x500ca15f, 0x4a20808e, 0xc47e84bd, 0x6e3301e9, 0xe06d05da, 0xb061a485, 0x3e3fa0b6, 0x947225e2, 0x1a2c21d1}, - [16]uint32{0x3f800000, 0x3fc72f02, 0x3f9209c0, 0x3fd526c2, 0x3ffd2092, 0x3fba0f90, 0x3fef2952, 0x3fa80650, 0x3fa51040, 0x3fe23f42, 0x3fb71980, 0x3ff03682, 0x3fd830d2, 0x3f9f1fd0, 0x3fca3912, 0x3f8d1610}, - uint32(0xfff80000), - [21]string{"0x85", "0x07", "0x92", "0x11", "0xb5", "0x99", "0xaf", "0xf3", "0xd4", "0x48", "0xd2", "0x4f", "0xc5", "0x5e", "0x14", "0xe7", "0xbf", "0x6a", "0xdc", "0x72", "0x00"}}, - { - /* No.286 delta:583 weight:1681 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xd114fb9b, 0x52af99ff, 0x83bb6264, 0x63d011ed, 0xb2c4ea76, 0x317f8812, 0xe06b7389, 0x0000aee3, 0xd1145578, 0x52af371c, 0x83bbcc87, 0x63d0bf0e, 0xb2c44495, 0x317f26f1, 0xe06bdd6a}, - [16]uint32{0x00000000, 0x400308d3, 0xa0016539, 0xe0026dea, 0x1000a99e, 0x5003a14d, 0xb001cca7, 0xf002c474, 0xc000201b, 0x800328c8, 0x60014522, 0x20024df1, 0xd0008985, 0x90038156, 0x7001ecbc, 0x3002e46f}, - [16]uint32{0x3f800000, 0x3fa00184, 0x3fd000b2, 0x3ff00136, 0x3f880054, 0x3fa801d0, 0x3fd800e6, 0x3ff80162, 0x3fe00010, 0x3fc00194, 0x3fb000a2, 0x3f900126, 0x3fe80044, 0x3fc801c0, 0x3fb800f6, 0x3f980172}, - uint32(0xfff80000), - [21]string{"0x59", "0xc7", "0x8f", "0x55", "0x07", "0x75", "0xd0", "0xc9", "0x26", "0x6c", "0x4f", "0x0b", "0xb9", "0x98", "0x3f", "0xf3", "0xa7", "0x43", "0x2b", "0x28", "0x00"}}, - { - /* No.287 delta:2333 weight:1651 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0xa6e6a28f, 0xcea8da4b, 0x684e78c4, 0x7e2011f5, 0xd8c6b37a, 0xb088cbbe, 0x166e6931, 0x0000594d, 0xa6e6fbc2, 0xcea88306, 0x684e2189, 0x7e2048b8, 0xd8c6ea37, 0xb08892f3, 0x166e307c}, - [16]uint32{0x00000000, 0x000d841a, 0x00000073, 0x000d8469, 0x01200016, 0x012d840c, 0x01200065, 0x012d847f, 0x100001a4, 0x100d85be, 0x100001d7, 0x100d85cd, 0x112001b2, 0x112d85a8, 0x112001c1, 0x112d85db}, - [16]uint32{0x3f800000, 0x3f8006c2, 0x3f800000, 0x3f8006c2, 0x3f809000, 0x3f8096c2, 0x3f809000, 0x3f8096c2, 0x3f880000, 0x3f8806c2, 0x3f880000, 0x3f8806c2, 0x3f889000, 0x3f8896c2, 0x3f889000, 0x3f8896c2}, - uint32(0xfff80000), - [21]string{"0x95", "0x93", "0x90", "0x58", "0x58", "0xc5", "0xf4", "0x07", "0x73", "0xc9", "0x6e", "0x56", "0x93", "0x99", "0x69", "0x69", "0x63", "0x32", "0xfc", "0xcd", "0x00"}}, - { - /* No.288 delta:904 weight:1651 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x9b7f9dd5, 0xb4d1a31b, 0x2fae3ece, 0x30001203, 0xab7f8fd6, 0x84d1b118, 0x1fae2ccd, 0x00005429, 0x9b7fc9fc, 0xb4d1f732, 0x2fae6ae7, 0x3000462a, 0xab7fdbff, 0x84d1e531, 0x1fae78e4}, - [16]uint32{0x00000000, 0x00543bfa, 0x200aa815, 0x205e93ef, 0xc0202419, 0xc0741fe3, 0xe02a8c0c, 0xe07eb7f6, 0x00036807, 0x005753fd, 0x2009c012, 0x205dfbe8, 0xc0234c1e, 0xc07777e4, 0xe029e40b, 0xe07ddff1}, - [16]uint32{0x3f800000, 0x3f802a1d, 0x3f900554, 0x3f902f49, 0x3fe01012, 0x3fe03a0f, 0x3ff01546, 0x3ff03f5b, 0x3f8001b4, 0x3f802ba9, 0x3f9004e0, 0x3f902efd, 0x3fe011a6, 0x3fe03bbb, 0x3ff014f2, 0x3ff03eef}, - uint32(0xfff80000), - [21]string{"0x4b", "0x8d", "0x51", "0xbb", "0x0f", "0x66", "0x85", "0xe2", "0xee", "0x64", "0xad", "0xbc", "0xe9", "0xed", "0x1c", "0xf6", "0xd4", "0x8b", "0xfc", "0x06", "0x00"}}, - { - /* No.289 delta:902 weight:1623 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0xf3d2ad48, 0x862006c8, 0x75f2ab80, 0x04e0121c, 0xf732bf54, 0x82c014d4, 0x7112b99c, 0x0000c395, 0xf3d26edd, 0x8620c55d, 0x75f26815, 0x04e0d189, 0xf7327cc1, 0x82c0d741, 0x71127a09}, - [16]uint32{0x00000000, 0xe80819be, 0x0046189b, 0xe84e0125, 0x0035f014, 0xe83de9aa, 0x0073e88f, 0xe87bf131, 0x00031910, 0xe80b00ae, 0x0045018b, 0xe84d1835, 0x0036e904, 0xe83ef0ba, 0x0070f19f, 0xe878e821}, - [16]uint32{0x3f800000, 0x3ff4040c, 0x3f80230c, 0x3ff42700, 0x3f801af8, 0x3ff41ef4, 0x3f8039f4, 0x3ff43df8, 0x3f80018c, 0x3ff40580, 0x3f802280, 0x3ff4268c, 0x3f801b74, 0x3ff41f78, 0x3f803878, 0x3ff43c74}, - uint32(0xfff80000), - [21]string{"0xae", "0xf8", "0x4a", "0x6c", "0xc4", "0xdb", "0x75", "0x9f", "0x35", "0x59", "0x15", "0x31", "0x28", "0x48", "0x4d", "0x2a", "0x4d", "0x55", "0xff", "0x19", "0x00"}}, - { - /* No.290 delta:944 weight:1727 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xfbcc3f05, 0x04249a13, 0xffe8a516, 0xfec0122c, 0x050c2d29, 0xfae4883f, 0x0128b73a, 0x00009b2a, 0xfbcca42f, 0x04240139, 0xffe83e3c, 0xfec08906, 0x050cb603, 0xfae41315, 0x01282c10}, - [16]uint32{0x00000000, 0x0042281e, 0x20021065, 0x2040387b, 0x10001707, 0x10423f19, 0x30020762, 0x30402f7c, 0x80000156, 0x80422948, 0xa0021133, 0xa040392d, 0x90001651, 0x90423e4f, 0xb0020634, 0xb0402e2a}, - [16]uint32{0x3f800000, 0x3f802114, 0x3f900108, 0x3f90201c, 0x3f88000b, 0x3f88211f, 0x3f980103, 0x3f982017, 0x3fc00000, 0x3fc02114, 0x3fd00108, 0x3fd0201c, 0x3fc8000b, 0x3fc8211f, 0x3fd80103, 0x3fd82017}, - uint32(0xfff80000), - [21]string{"0xd4", "0xd6", "0xb1", "0x99", "0x08", "0xa8", "0x90", "0x00", "0x71", "0xcc", "0xa0", "0x44", "0x61", "0xd7", "0x04", "0x86", "0xa4", "0x9b", "0xa2", "0x7c", "0x00"}}, - { - /* No.291 delta:1190 weight:1597 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0xf3b4ed24, 0xdef22bdc, 0x2d46c6f8, 0x28f01237, 0xdb44ff13, 0xf60239eb, 0x05b6d4cf, 0x00008792, 0xf3b46ab6, 0xdef2ac4e, 0x2d46416a, 0x28f095a5, 0xdb447881, 0xf602be79, 0x05b6535d}, - [16]uint32{0x00000000, 0x344c0816, 0x00402d67, 0x340c2571, 0x106819d5, 0x242411c3, 0x102834b2, 0x24643ca4, 0x105d0014, 0x24110802, 0x101d2d73, 0x24512565, 0x003519c1, 0x347911d7, 0x007534a6, 0x34393cb0}, - [16]uint32{0x3f800000, 0x3f9a2604, 0x3f802016, 0x3f9a0612, 0x3f88340c, 0x3f921208, 0x3f88141a, 0x3f92321e, 0x3f882e80, 0x3f920884, 0x3f880e96, 0x3f922892, 0x3f801a8c, 0x3f9a3c88, 0x3f803a9a, 0x3f9a1c9e}, - uint32(0xfff80000), - [21]string{"0x80", "0x71", "0x1d", "0x30", "0x3e", "0x00", "0x11", "0x0a", "0x22", "0xba", "0x95", "0xe8", "0xd9", "0xde", "0x23", "0x06", "0xd8", "0x66", "0x7b", "0xf1", "0x00"}}, - { - /* No.292 delta:2057 weight:1297 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x76d6388e, 0x0d4dedf7, 0x7b9bd579, 0x09d0124f, 0x7f062ac1, 0x049dffb8, 0x724bc736, 0x00004430, 0x76d67cbe, 0x0d4da9c7, 0x7b9b9149, 0x09d0567f, 0x7f066ef1, 0x049dbb88, 0x724b8306}, - [16]uint32{0x00000000, 0x30a50892, 0x0e304027, 0x3e9548b5, 0xf1907209, 0xc1357a9b, 0xffa0322e, 0xcf053abc, 0x402243cd, 0x70874b5f, 0x4e1203ea, 0x7eb70b78, 0xb1b231c4, 0x81173956, 0xbf8271e3, 0x8f277971}, - [16]uint32{0x3f800000, 0x3f985284, 0x3f871820, 0x3f9f4aa4, 0x3ff8c839, 0x3fe09abd, 0x3fffd019, 0x3fe7829d, 0x3fa01121, 0x3fb843a5, 0x3fa70901, 0x3fbf5b85, 0x3fd8d918, 0x3fc08b9c, 0x3fdfc138, 0x3fc793bc}, - uint32(0xfff80000), - [21]string{"0xb8", "0x0c", "0x99", "0x53", "0x57", "0x6e", "0x5e", "0xa5", "0x36", "0x91", "0xa1", "0xa1", "0x4b", "0xd9", "0x7f", "0xfc", "0xb6", "0x6e", "0x0b", "0xcd", "0x00"}}, - { - /* No.293 delta:832 weight:693 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x14933608, 0x74422a10, 0x60d11c18, 0x5b701258, 0x4fe32450, 0x2f323848, 0x3ba10e40, 0x00008f9e, 0x1493b996, 0x7442a58e, 0x60d19386, 0x5b709dc6, 0x4fe3abce, 0x2f32b7d6, 0x3ba181de}, - [16]uint32{0x00000000, 0x024d06f3, 0x0042201c, 0x020f26ef, 0x6078100e, 0x623516fd, 0x603a3012, 0x627736e1, 0x201041f7, 0x225d4704, 0x205261eb, 0x221f6718, 0x406851f9, 0x4225570a, 0x402a71e5, 0x42677716}, - [16]uint32{0x3f800000, 0x3f812683, 0x3f802110, 0x3f810793, 0x3fb03c08, 0x3fb11a8b, 0x3fb01d18, 0x3fb13b9b, 0x3f900820, 0x3f912ea3, 0x3f902930, 0x3f910fb3, 0x3fa03428, 0x3fa112ab, 0x3fa01538, 0x3fa133bb}, - uint32(0xfff80000), - [21]string{"0x59", "0x1e", "0x1b", "0x5c", "0xdd", "0x6e", "0x9b", "0x3c", "0x61", "0xef", "0x52", "0x51", "0x06", "0x7d", "0x37", "0x69", "0xbc", "0x02", "0x4e", "0xae", "0x00"}}, - { - /* No.294 delta:1075 weight:1641 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0xd240a087, 0x0d7c4b77, 0xdf3cebf0, 0x9200126c, 0x4040b2eb, 0x9f7c591b, 0x4d3cf99c, 0x0000e34c, 0xd24043cb, 0x0d7ca83b, 0xdf3c08bc, 0x9200f120, 0x404051a7, 0x9f7cba57, 0x4d3c1ad0}, - [16]uint32{0x00000000, 0x004054da, 0x4003013f, 0x404355e5, 0x0167684d, 0x01273c97, 0x41646972, 0x41243da8, 0x203cb990, 0x207ced4a, 0x603fb8af, 0x607fec75, 0x215bd1dd, 0x211b8507, 0x6158d0e2, 0x61188438}, - [16]uint32{0x3f800000, 0x3f80202a, 0x3fa00180, 0x3fa021aa, 0x3f80b3b4, 0x3f80939e, 0x3fa0b234, 0x3fa0921e, 0x3f901e5c, 0x3f903e76, 0x3fb01fdc, 0x3fb03ff6, 0x3f90ade8, 0x3f908dc2, 0x3fb0ac68, 0x3fb08c42}, - uint32(0xfff80000), - [21]string{"0xc0", "0xfa", "0x1f", "0x55", "0x3f", "0xba", "0x1f", "0x2b", "0xbe", "0x72", "0x99", "0x33", "0x7d", "0x40", "0xd0", "0x51", "0x33", "0x34", "0x9c", "0xf4", "0x00"}}, - { - /* No.295 delta:1186 weight:1657 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0xc7df60ac, 0x6a1ad971, 0xadc5b9dd, 0x76c01270, 0xb11f72dc, 0x1cdacb01, 0xdb05abad, 0x000085a7, 0xc7dfe50b, 0x6a1a5cd6, 0xadc53c7a, 0x76c097d7, 0xb11ff77b, 0x1cda4ea6, 0xdb052e0a}, - [16]uint32{0x00000000, 0x00055956, 0x00027175, 0x00072823, 0x3078c818, 0x307d914e, 0x307ab96d, 0x307fe03b, 0x0040001d, 0x0045594b, 0x00427168, 0x0047283e, 0x3038c805, 0x303d9153, 0x303ab970, 0x303fe026}, - [16]uint32{0x3f800000, 0x3f8002ac, 0x3f800138, 0x3f800394, 0x3f983c64, 0x3f983ec8, 0x3f983d5c, 0x3f983ff0, 0x3f802000, 0x3f8022ac, 0x3f802138, 0x3f802394, 0x3f981c64, 0x3f981ec8, 0x3f981d5c, 0x3f981ff0}, - uint32(0xfff80000), - [21]string{"0xd3", "0xe7", "0x86", "0x9b", "0xe3", "0x0a", "0x21", "0x7d", "0x7d", "0x27", "0x36", "0x03", "0x1d", "0x93", "0xef", "0xe6", "0x00", "0x1e", "0xd7", "0xd0", "0x00"}}, - { - /* No.296 delta:1412 weight:1597 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0x23b04c56, 0x4d815b5f, 0x6e311709, 0x40f0128b, 0x63405edd, 0x0d7149d4, 0x2ec10582, 0x00002283, 0x23b06ed5, 0x4d8179dc, 0x6e31358a, 0x40f03008, 0x63407c5e, 0x0d716b57, 0x2ec12701}, - [16]uint32{0x00000000, 0x5084d83e, 0x007c401c, 0x50f89822, 0x40030dba, 0x1087d584, 0x407f4da6, 0x10fb9598, 0x40004919, 0x10849127, 0x407c0905, 0x10f8d13b, 0x000344a3, 0x50879c9d, 0x007f04bf, 0x50fbdc81}, - [16]uint32{0x3f800000, 0x3fa8426c, 0x3f803e20, 0x3fa87c4c, 0x3fa00186, 0x3f8843ea, 0x3fa03fa6, 0x3f887dca, 0x3fa00024, 0x3f884248, 0x3fa03e04, 0x3f887c68, 0x3f8001a2, 0x3fa843ce, 0x3f803f82, 0x3fa87dee}, - uint32(0xfff80000), - [21]string{"0x92", "0x7d", "0x94", "0x21", "0x4b", "0x3a", "0x32", "0x48", "0xf6", "0x7a", "0x9a", "0xec", "0xd7", "0xb6", "0x56", "0xfc", "0xc9", "0x34", "0x67", "0xb1", "0x00"}}, - { - /* No.297 delta:763 weight:1457 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xb7a54f1e, 0xa71f8dd6, 0x10bac2c8, 0x1ba01298, 0xac055d86, 0xbcbf9f4e, 0x0b1ad050, 0x0000142d, 0xb7a55b33, 0xa71f99fb, 0x10bad6e5, 0x1ba006b5, 0xac0549ab, 0xbcbf8b63, 0x0b1ac47d}, - [16]uint32{0x00000000, 0x58680016, 0x20711899, 0x7819188f, 0x105cce7c, 0x4834ce6a, 0x302dd6e5, 0x6845d6f3, 0x006a187a, 0x5802186c, 0x201b00e3, 0x787300f5, 0x1036d606, 0x485ed610, 0x3047ce9f, 0x682fce89}, - [16]uint32{0x3f800000, 0x3fac3400, 0x3f90388c, 0x3fbc0c8c, 0x3f882e67, 0x3fa41a67, 0x3f9816eb, 0x3fb422eb, 0x3f80350c, 0x3fac010c, 0x3f900d80, 0x3fbc3980, 0x3f881b6b, 0x3fa42f6b, 0x3f9823e7, 0x3fb417e7}, - uint32(0xfff80000), - [21]string{"0x93", "0xe2", "0xc7", "0x95", "0xfa", "0x46", "0xe7", "0xb4", "0x33", "0x62", "0xbc", "0x1b", "0xa4", "0x2a", "0x04", "0x02", "0x8b", "0xdd", "0x23", "0x94", "0x00"}}, - { - /* No.298 delta:967 weight:1527 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0xb982e373, 0xc724b811, 0x7ea65b62, 0x87c012ac, 0x3e42f1df, 0x40e4aabd, 0xf96649ce, 0x00003985, 0xb982daf6, 0xc7248194, 0x7ea662e7, 0x87c02b29, 0x3e42c85a, 0x40e49338, 0xf966704b}, - [16]uint32{0x00000000, 0x0842bb3a, 0x1002e6c3, 0x18405df9, 0x0000409e, 0x0842fba4, 0x1002a65d, 0x18401d67, 0x2001801b, 0x28433b21, 0x300366d8, 0x3841dde2, 0x2001c085, 0x28437bbf, 0x30032646, 0x38419d7c}, - [16]uint32{0x3f800000, 0x3f84215d, 0x3f880173, 0x3f8c202e, 0x3f800020, 0x3f84217d, 0x3f880153, 0x3f8c200e, 0x3f9000c0, 0x3f94219d, 0x3f9801b3, 0x3f9c20ee, 0x3f9000e0, 0x3f9421bd, 0x3f980193, 0x3f9c20ce}, - uint32(0xfff80000), - [21]string{"0x83", "0x91", "0x32", "0xcf", "0x3d", "0x1d", "0x50", "0x21", "0x0f", "0x8f", "0x38", "0x19", "0x7c", "0x4a", "0x0d", "0xb5", "0xfd", "0x7d", "0x82", "0xf3", "0x00"}}, - { - /* No.299 delta:962 weight:1567 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0xc27cca59, 0x4c189d3f, 0x8e645766, 0x150012be, 0xd77cd8e7, 0x59188f81, 0x9b6445d8, 0x0000c223, 0xc27c087a, 0x4c185f1c, 0x8e649545, 0x1500d09d, 0xd77c1ac4, 0x59184da2, 0x9b6487fb}, - [16]uint32{0x00000000, 0x302f041e, 0x30402c73, 0x006f286d, 0x00020df6, 0x302d09e8, 0x30422185, 0x006d259b, 0x103d240c, 0x20122012, 0x207d087f, 0x10520c61, 0x103f29fa, 0x20102de4, 0x207f0589, 0x10500197}, - [16]uint32{0x3f800000, 0x3f981782, 0x3f982016, 0x3f803794, 0x3f800106, 0x3f981684, 0x3f982110, 0x3f803692, 0x3f881e92, 0x3f900910, 0x3f903e84, 0x3f882906, 0x3f881f94, 0x3f900816, 0x3f903f82, 0x3f882800}, - uint32(0xfff80000), - [21]string{"0x47", "0xce", "0x43", "0x26", "0xfa", "0xae", "0x02", "0x83", "0x8f", "0x1b", "0x8f", "0x36", "0xea", "0x52", "0x53", "0x47", "0x2a", "0x67", "0xd8", "0x6a", "0x00"}}, - { - /* No.300 delta:1760 weight:1591 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x3f026d07, 0x19579ecc, 0x2655f3cb, 0xacd012c9, 0x93d27fce, 0xb5878c05, 0x8a85e102, 0x0000ef47, 0x3f028240, 0x1957718b, 0x26551c8c, 0xacd0fd8e, 0x93d29089, 0xb5876342, 0x8a850e45}, - [16]uint32{0x00000000, 0x2069c1ba, 0x401c61ee, 0x6075a054, 0x000a0195, 0x2063c02f, 0x4016607b, 0x607fa1c1, 0x60010186, 0x4068c03c, 0x201d6068, 0x0074a1d2, 0x600b0013, 0x4062c1a9, 0x201761fd, 0x007ea047}, - [16]uint32{0x3f800000, 0x3f9034e0, 0x3fa00e30, 0x3fb03ad0, 0x3f800500, 0x3f9031e0, 0x3fa00b30, 0x3fb03fd0, 0x3fb00080, 0x3fa03460, 0x3f900eb0, 0x3f803a50, 0x3fb00580, 0x3fa03160, 0x3f900bb0, 0x3f803f50}, - uint32(0xfff80000), - [21]string{"0x1d", "0x00", "0x02", "0x17", "0x1b", "0x97", "0xf7", "0x0a", "0xa3", "0xe8", "0x85", "0x28", "0x9a", "0x23", "0xda", "0xb4", "0x36", "0x75", "0x8e", "0x11", "0x00"}}, - { - /* No.301 delta:1047 weight:1545 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0xd43bf17f, 0xe7f5581a, 0x33cea965, 0x2c1012d5, 0xf82be3aa, 0xcbe54acf, 0x1fdebbb0, 0x00006475, 0xd43b950a, 0xe7f53c6f, 0x33cecd10, 0x2c1076a0, 0xf82b87df, 0xcbe52eba, 0x1fdedfc5}, - [16]uint32{0x00000000, 0x457f8936, 0x04112862, 0x416ea154, 0x000241db, 0x457dc8ed, 0x041369b9, 0x416ce08f, 0x0003e112, 0x457c6824, 0x0412c970, 0x416d4046, 0x0001a0c9, 0x457e29ff, 0x041088ab, 0x416f019d}, - [16]uint32{0x3f800000, 0x3fa2bfc4, 0x3f820894, 0x3fa0b750, 0x3f800120, 0x3fa2bee4, 0x3f8209b4, 0x3fa0b670, 0x3f8001f0, 0x3fa2be34, 0x3f820964, 0x3fa0b6a0, 0x3f8000d0, 0x3fa2bf14, 0x3f820844, 0x3fa0b780}, - uint32(0xfff80000), - [21]string{"0x75", "0x8c", "0xb1", "0x8e", "0x7c", "0x9b", "0xdd", "0xca", "0xc7", "0x29", "0xc4", "0xe2", "0x01", "0x90", "0x5c", "0x6b", "0xbf", "0x62", "0xa1", "0xc0", "0x00"}}, - { - /* No.302 delta:890 weight:1167 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0x018e6586, 0x580ecd60, 0x5980a8e6, 0xc71012e8, 0xc69e776e, 0x9f1edf88, 0x9e90ba0e, 0x0000d017, 0x018eb591, 0x580e1d77, 0x598078f1, 0xc710c2ff, 0xc69ea779, 0x9f1e0f9f, 0x9e906a19}, - [16]uint32{0x00000000, 0x004729d5, 0x00011011, 0x004639c4, 0x8202309a, 0x8245194f, 0x8203208b, 0x8244095e, 0x50020409, 0x50452ddc, 0x50031418, 0x50443dcd, 0xd2003493, 0xd2471d46, 0xd2012482, 0xd2460d57}, - [16]uint32{0x3f800000, 0x3f802394, 0x3f800088, 0x3f80231c, 0x3fc10118, 0x3fc1228c, 0x3fc10190, 0x3fc12204, 0x3fa80102, 0x3fa82296, 0x3fa8018a, 0x3fa8221e, 0x3fe9001a, 0x3fe9238e, 0x3fe90092, 0x3fe92306}, - uint32(0xfff80000), - [21]string{"0x0c", "0x95", "0xf2", "0x1f", "0x1c", "0x57", "0x62", "0x5a", "0xbe", "0xa0", "0x3b", "0xf3", "0xa3", "0xd9", "0xb9", "0x39", "0x25", "0x5a", "0x07", "0x95", "0x00"}}, - { - /* No.303 delta:1427 weight:1213 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x1456d307, 0x08679ffe, 0x1c314cf9, 0xfe0012fd, 0xea56c1fa, 0xf6678d03, 0xe2315e04, 0x0000b8b5, 0x14566bb2, 0x0867274b, 0x1c31f44c, 0xfe00aa48, 0xea56794f, 0xf66735b6, 0xe231e6b1}, - [16]uint32{0x00000000, 0x204c0072, 0x203001b1, 0x007c01c3, 0x0003008d, 0x204f00ff, 0x2033013c, 0x007f014e, 0x00120018, 0x205e006a, 0x202201a9, 0x006e01db, 0x00110095, 0x205d00e7, 0x20210124, 0x006d0156}, - [16]uint32{0x3f800000, 0x3f902600, 0x3f901800, 0x3f803e00, 0x3f800180, 0x3f902780, 0x3f901980, 0x3f803f80, 0x3f800900, 0x3f902f00, 0x3f901100, 0x3f803700, 0x3f800880, 0x3f902e80, 0x3f901080, 0x3f803680}, - uint32(0xfff80000), - [21]string{"0x9c", "0xbd", "0x22", "0x1a", "0xd8", "0x36", "0xbc", "0xc1", "0x67", "0x4b", "0xed", "0xae", "0x29", "0x91", "0x71", "0xed", "0x8c", "0xc3", "0xf2", "0x02", "0x00"}}, - { - /* No.304 delta:1858 weight:1583 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x2e925e9d, 0x11274489, 0x3fb51a14, 0x7250130c, 0x5cc24d91, 0x63775785, 0x4de50918, 0x00000a61, 0x2e9254fc, 0x11274ee8, 0x3fb51075, 0x7250196d, 0x5cc247f0, 0x63775de4, 0x4de50379}, - [16]uint32{0x00000000, 0x088d213e, 0x1642c1bd, 0x1ecfe083, 0x0441f115, 0x0cccd02b, 0x120330a8, 0x1a8e1196, 0x084aa014, 0x00c7812a, 0x1e0861a9, 0x16854097, 0x0c0b5101, 0x0486703f, 0x1a4990bc, 0x12c4b182}, - [16]uint32{0x3f800000, 0x3f844690, 0x3f8b2160, 0x3f8f67f0, 0x3f8220f8, 0x3f866668, 0x3f890198, 0x3f8d4708, 0x3f842550, 0x3f8063c0, 0x3f8f0430, 0x3f8b42a0, 0x3f8605a8, 0x3f824338, 0x3f8d24c8, 0x3f896258}, - uint32(0xfff80000), - [21]string{"0xc8", "0xb0", "0x37", "0xab", "0x1e", "0x72", "0x05", "0x42", "0xc1", "0xa1", "0xea", "0xa1", "0x70", "0x0c", "0x00", "0x43", "0x64", "0x93", "0x35", "0xbb", "0x00"}}, - { - /* No.305 delta:802 weight:1487 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0xcbc49a4f, 0xeb3fc8c9, 0x20fb5286, 0x89b0131b, 0x42748954, 0x628fdbd2, 0xa94b419d, 0x0000db70, 0xcbc4413f, 0xeb3f13b9, 0x20fb89f6, 0x89b0c86b, 0x42745224, 0x628f00a2, 0xa94b9aed}, - [16]uint32{0x00000000, 0x4c3e591a, 0x4401a331, 0x083ffa2b, 0x10024e57, 0x5c3c174d, 0x5403ed66, 0x183db47c, 0x10011203, 0x5c3f4b19, 0x5400b132, 0x183ee828, 0x00035c54, 0x4c3d054e, 0x4402ff65, 0x083ca67f}, - [16]uint32{0x3f800000, 0x3fa61f2c, 0x3fa200d1, 0x3f841ffd, 0x3f880127, 0x3fae1e0b, 0x3faa01f6, 0x3f8c1eda, 0x3f880089, 0x3fae1fa5, 0x3faa0058, 0x3f8c1f74, 0x3f8001ae, 0x3fa61e82, 0x3fa2017f, 0x3f841e53}, - uint32(0xfff80000), - [21]string{"0x8a", "0xf2", "0x95", "0xa2", "0x6a", "0xf2", "0xd1", "0x1e", "0x6e", "0xce", "0x7a", "0x6c", "0x06", "0xd0", "0x5a", "0x97", "0x8f", "0xfc", "0x55", "0x9b", "0x00"}}, - { - /* No.306 delta:2270 weight:1221 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x0ffdf430, 0x9805d495, 0x97f820a5, 0x34d01329, 0x3b2de719, 0xacd5c7bc, 0xa328338c, 0x0000cf90, 0x0ffd3ba0, 0x98051b05, 0x97f8ef35, 0x34d0dcb9, 0x3b2d2889, 0xacd5082c, 0xa328fc1c}, - [16]uint32{0x00000000, 0x38481ade, 0x0a0007ed, 0x32481d33, 0x10216f15, 0x286975cb, 0x1a2168f8, 0x22697226, 0x7048ac12, 0x4800b6cc, 0x7a48abff, 0x4200b121, 0x6069c307, 0x5821d9d9, 0x6a69c4ea, 0x5221de34}, - [16]uint32{0x3f800000, 0x3f9c240d, 0x3f850003, 0x3f99240e, 0x3f8810b7, 0x3f9434ba, 0x3f8d10b4, 0x3f9134b9, 0x3fb82456, 0x3fa4005b, 0x3fbd2455, 0x3fa10058, 0x3fb034e1, 0x3fac10ec, 0x3fb534e2, 0x3fa910ef}, - uint32(0xfff80000), - [21]string{"0xa3", "0x6a", "0xa6", "0x01", "0x38", "0x7b", "0xcc", "0x4b", "0xb3", "0x80", "0x46", "0xcb", "0x97", "0x62", "0xc4", "0x0b", "0x6d", "0x5b", "0x89", "0x37", "0x00"}}, - { - /* No.307 delta:795 weight:1601 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0x9c198fc0, 0x58693458, 0xc470bb98, 0x23d01337, 0xbfc99cf7, 0x7bb9276f, 0xe7a0a8af, 0x0000bc9d, 0x9c19335d, 0x586988c5, 0xc4700705, 0x23d0afaa, 0xbfc9206a, 0x7bb99bf2, 0xe7a01432}, - [16]uint32{0x00000000, 0x0435a092, 0x80702809, 0x8445889b, 0x0020a816, 0x04150884, 0x8050801f, 0x8465208d, 0x0042900e, 0x0477309c, 0x8032b807, 0x84071895, 0x00623818, 0x0457988a, 0x80121011, 0x8427b083}, - [16]uint32{0x3f800000, 0x3f821ad0, 0x3fc03814, 0x3fc222c4, 0x3f801054, 0x3f820a84, 0x3fc02840, 0x3fc23290, 0x3f802148, 0x3f823b98, 0x3fc0195c, 0x3fc2038c, 0x3f80311c, 0x3f822bcc, 0x3fc00908, 0x3fc213d8}, - uint32(0xfff80000), - [21]string{"0x19", "0xa6", "0x69", "0x4d", "0x2e", "0x6e", "0xce", "0x8b", "0xca", "0x9f", "0xd0", "0x79", "0xfd", "0xc0", "0xfd", "0x13", "0xdc", "0xec", "0xe8", "0x20", "0x00"}}, - { - /* No.308 delta:590 weight:1743 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x8227645c, 0x754c4fdb, 0xf76b2b87, 0xf780134e, 0x75a77712, 0x82cc5c95, 0x00eb38c9, 0x00005db0, 0x822739ec, 0x754c126b, 0xf76b7637, 0xf7804efe, 0x75a72aa2, 0x82cc0125, 0x00eb6579}, - [16]uint32{0x00000000, 0x7002a21b, 0xa0000416, 0xd002a60d, 0x40018172, 0x30032369, 0xe0018564, 0x9003277f, 0x0002101a, 0x7000b201, 0xa002140c, 0xd000b617, 0x40039168, 0x30013373, 0xe003957e, 0x90013765}, - [16]uint32{0x3f800000, 0x3fb80151, 0x3fd00002, 0x3fe80153, 0x3fa000c0, 0x3f980191, 0x3ff000c2, 0x3fc80193, 0x3f800108, 0x3fb80059, 0x3fd0010a, 0x3fe8005b, 0x3fa001c8, 0x3f980099, 0x3ff001ca, 0x3fc8009b}, - uint32(0xfff80000), - [21]string{"0x24", "0xbe", "0xf6", "0x8b", "0xa2", "0x9e", "0xd6", "0x87", "0x4b", "0xbe", "0x7d", "0xa5", "0x0d", "0xe7", "0x79", "0x1e", "0x9a", "0x6b", "0xbf", "0x73", "0x00"}}, - { - /* No.309 delta:873 weight:1579 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x8b01278d, 0x28979c3d, 0xa396bbb0, 0x4b50135d, 0xc05134d0, 0x63c78f60, 0xe8c6a8ed, 0x0000d66c, 0x8b01f1e1, 0x28974a51, 0xa3966ddc, 0x4b50c531, 0xc051e2bc, 0x63c7590c, 0xe8c67e81}, - [16]uint32{0x00000000, 0x0143e0fa, 0xd0000415, 0xd143e4ef, 0xc000380b, 0xc143d8f1, 0x10003c1e, 0x1143dce4, 0x40000318, 0x4143e3e2, 0x9000070d, 0x9143e7f7, 0x80003b13, 0x8143dbe9, 0x50003f06, 0x5143dffc}, - [16]uint32{0x3f800000, 0x3f80a1f0, 0x3fe80002, 0x3fe8a1f2, 0x3fe0001c, 0x3fe0a1ec, 0x3f88001e, 0x3f88a1ee, 0x3fa00001, 0x3fa0a1f1, 0x3fc80003, 0x3fc8a1f3, 0x3fc0001d, 0x3fc0a1ed, 0x3fa8001f, 0x3fa8a1ef}, - uint32(0xfff80000), - [21]string{"0x22", "0x31", "0x98", "0x10", "0x8a", "0x36", "0x12", "0xd8", "0x2b", "0xf9", "0xfb", "0x86", "0x15", "0x7b", "0x39", "0xa3", "0x4b", "0x3a", "0xd6", "0x6e", "0x00"}}, - { - /* No.310 delta:869 weight:999 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0xe34e1c12, 0x209c21dc, 0xc3d23dce, 0x2d101365, 0xce5e0f77, 0x0d8c32b9, 0xeec22eab, 0x00000660, 0xe34e1a72, 0x209c27bc, 0xc3d23bae, 0x2d101505, 0xce5e0917, 0x0d8c34d9, 0xeec228cb}, - [16]uint32{0x00000000, 0x3043083d, 0x2002a91a, 0x1041a127, 0x1002fc16, 0x2041f42b, 0x3000550c, 0x00435d31, 0x50002014, 0x60432829, 0x7002890e, 0x40418133, 0x4002dc02, 0x7041d43f, 0x60007518, 0x50437d25}, - [16]uint32{0x3f800000, 0x3f982184, 0x3f900154, 0x3f8820d0, 0x3f88017e, 0x3f9020fa, 0x3f98002a, 0x3f8021ae, 0x3fa80010, 0x3fb02194, 0x3fb80144, 0x3fa020c0, 0x3fa0016e, 0x3fb820ea, 0x3fb0003a, 0x3fa821be}, - uint32(0xfff80000), - [21]string{"0x62", "0x66", "0x00", "0x51", "0x21", "0xb0", "0x79", "0x50", "0xd5", "0x85", "0x99", "0x1a", "0x20", "0x58", "0xb6", "0xa2", "0x13", "0x7a", "0x09", "0x2a", "0x00"}}, - { - /* No.311 delta:725 weight:1501 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x478a7f0d, 0x8ad13ad0, 0xcd5b45dd, 0xb810137b, 0xff9a6c76, 0x32c129ab, 0x754b56a6, 0x0000d27e, 0x478aad73, 0x8ad1e8ae, 0xcd5b97a3, 0xb810c105, 0xff9abe08, 0x32c1fbd5, 0x754b84d8}, - [16]uint32{0x00000000, 0x380203d3, 0x100021fc, 0x2802222f, 0x82010d5b, 0xba030e88, 0x92012ca7, 0xaa032f74, 0x80002142, 0xb8022291, 0x900000be, 0xa802036d, 0x02012c19, 0x3a032fca, 0x12010de5, 0x2a030e36}, - [16]uint32{0x3f800000, 0x3f9c0101, 0x3f880010, 0x3f940111, 0x3fc10086, 0x3fdd0187, 0x3fc90096, 0x3fd50197, 0x3fc00010, 0x3fdc0111, 0x3fc80000, 0x3fd40101, 0x3f810096, 0x3f9d0197, 0x3f890086, 0x3f950187}, - uint32(0xfff80000), - [21]string{"0x98", "0x56", "0x66", "0xc5", "0x07", "0xed", "0x45", "0x13", "0x3f", "0x85", "0xa8", "0x5e", "0xd3", "0x70", "0xc4", "0x18", "0x48", "0x6d", "0x62", "0x63", "0x00"}}, - { - /* No.312 delta:1534 weight:1411 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x00b4ab14, 0xb562a900, 0xb5d60214, 0xa1301388, 0xa184b89c, 0x1452ba88, 0x14e6119c, 0x00008fd9, 0x00b424cd, 0xb56226d9, 0xb5d68dcd, 0xa1309c51, 0xa1843745, 0x14523551, 0x14e69e45}, - [16]uint32{0x00000000, 0x042b017a, 0x800a25e6, 0x8421249c, 0x106411fd, 0x144f1087, 0x906e341b, 0x94453561, 0x20026016, 0x2429616c, 0xa00845f0, 0xa423448a, 0x306671eb, 0x344d7091, 0xb06c540d, 0xb4475577}, - [16]uint32{0x3f800000, 0x3f821580, 0x3fc00512, 0x3fc21092, 0x3f883208, 0x3f8a2788, 0x3fc8371a, 0x3fca229a, 0x3f900130, 0x3f9214b0, 0x3fd00422, 0x3fd211a2, 0x3f983338, 0x3f9a26b8, 0x3fd8362a, 0x3fda23aa}, - uint32(0xfff80000), - [21]string{"0x0e", "0x08", "0x24", "0x45", "0x72", "0x8c", "0xef", "0x0b", "0x3a", "0xbe", "0xef", "0xf3", "0x47", "0x01", "0x4b", "0x04", "0xd2", "0x27", "0x27", "0x7e", "0x00"}}, - { - /* No.313 delta:837 weight:1555 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x6d665276, 0x652e079c, 0x084855ea, 0x16101395, 0x7b7641e3, 0x733e1409, 0x1e58467f, 0x0000074a, 0x6d66553c, 0x652e00d6, 0x084852a0, 0x161014df, 0x7b7646a9, 0x733e1343, 0x1e584135}, - [16]uint32{0x00000000, 0x100468b6, 0x20025c95, 0x30063423, 0x00019019, 0x1005f8af, 0x2003cc8c, 0x3007a43a, 0x6000240e, 0x70044cb8, 0x4002789b, 0x5006102d, 0x6001b417, 0x7005dca1, 0x4003e882, 0x50078034}, - [16]uint32{0x3f800000, 0x3f880234, 0x3f90012e, 0x3f98031a, 0x3f8000c8, 0x3f8802fc, 0x3f9001e6, 0x3f9803d2, 0x3fb00012, 0x3fb80226, 0x3fa0013c, 0x3fa80308, 0x3fb000da, 0x3fb802ee, 0x3fa001f4, 0x3fa803c0}, - uint32(0xfff80000), - [21]string{"0x05", "0xb8", "0xd1", "0xe6", "0xec", "0x01", "0xf4", "0x0b", "0x19", "0x45", "0xe7", "0x27", "0x9f", "0xa7", "0x63", "0x05", "0x6b", "0xe9", "0xe5", "0x36", "0x00"}}, - { - /* No.314 delta:897 weight:983 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x16dc0e50, 0xe4c764a4, 0xf21b6af4, 0x8a9013a9, 0x9c4c1df9, 0x6e57770d, 0x788b795d, 0x00006fcc, 0x16dc619c, 0xe4c70b68, 0xf21b0538, 0x8a907c65, 0x9c4c7235, 0x6e5718c1, 0x788b1691}, - [16]uint32{0x00000000, 0x50000057, 0x69110819, 0x3911084e, 0x4003b013, 0x1003b044, 0x2912b80a, 0x7912b85d, 0x400040f8, 0x100040af, 0x291148e1, 0x791148b6, 0x0003f0eb, 0x5003f0bc, 0x6912f8f2, 0x3912f8a5}, - [16]uint32{0x3f800000, 0x3fa80000, 0x3fb48884, 0x3f9c8884, 0x3fa001d8, 0x3f8801d8, 0x3f94895c, 0x3fbc895c, 0x3fa00020, 0x3f880020, 0x3f9488a4, 0x3fbc88a4, 0x3f8001f8, 0x3fa801f8, 0x3fb4897c, 0x3f9c897c}, - uint32(0xfff80000), - [21]string{"0xd9", "0x1b", "0x73", "0x16", "0x98", "0x53", "0x60", "0xca", "0xdb", "0x7d", "0xfd", "0x3e", "0x0f", "0x70", "0x73", "0x9f", "0xa5", "0x47", "0x51", "0x7b", "0x00"}}, - { - /* No.315 delta:769 weight:1561 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0x4728414d, 0x255cb3ed, 0x6274f2a0, 0x23b013b0, 0x649852fd, 0x06eca05d, 0x41c4e110, 0x00008881, 0x4728c9cc, 0x255c3b6c, 0x62747a21, 0x23b09b31, 0x6498da7c, 0x06ec28dc, 0x41c46991}, - [16]uint32{0x00000000, 0x00168d1f, 0x000aef0b, 0x001c6214, 0x400360f3, 0x4015edec, 0x40098ff8, 0x401f02e7, 0x20142006, 0x2002ad19, 0x201ecf0d, 0x20084212, 0x601740f5, 0x6001cdea, 0x601daffe, 0x600b22e1}, - [16]uint32{0x3f800000, 0x3f800b46, 0x3f800577, 0x3f800e31, 0x3fa001b0, 0x3fa00af6, 0x3fa004c7, 0x3fa00f81, 0x3f900a10, 0x3f900156, 0x3f900f67, 0x3f900421, 0x3fb00ba0, 0x3fb000e6, 0x3fb00ed7, 0x3fb00591}, - uint32(0xfff80000), - [21]string{"0x71", "0xed", "0xd0", "0xe5", "0x86", "0xff", "0x04", "0x4f", "0x0d", "0xc7", "0x47", "0x80", "0xe7", "0xed", "0xfb", "0x64", "0x23", "0xc3", "0x09", "0x9f", "0x00"}}, - { - /* No.316 delta:1571 weight:1533 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x478766bf, 0x9d080954, 0xda8f6feb, 0xa0d013c8, 0xe7577577, 0x3dd81a9c, 0x7a5f7c23, 0x0000938f, 0x4787f530, 0x9d089adb, 0xda8ffc64, 0xa0d08047, 0xe757e6f8, 0x3dd88913, 0x7a5fefac}, - [16]uint32{0x00000000, 0x103992f2, 0x00530191, 0x106a9363, 0x41f84817, 0x51c1dae5, 0x41ab4986, 0x5192db74, 0xa0108208, 0xb02910fa, 0xa0438399, 0xb07a116b, 0xe1e8ca1f, 0xf1d158ed, 0xe1bbcb8e, 0xf182597c}, - [16]uint32{0x3f800000, 0x3f881cc9, 0x3f802980, 0x3f883549, 0x3fa0fc24, 0x3fa8e0ed, 0x3fa0d5a4, 0x3fa8c96d, 0x3fd00841, 0x3fd81488, 0x3fd021c1, 0x3fd83d08, 0x3ff0f465, 0x3ff8e8ac, 0x3ff0dde5, 0x3ff8c12c}, - uint32(0xfff80000), - [21]string{"0x8e", "0x5b", "0x93", "0xaa", "0xef", "0xef", "0x2b", "0x60", "0x7f", "0x6f", "0xbb", "0x32", "0x2a", "0xf3", "0x5c", "0x7a", "0x85", "0x28", "0x14", "0xb3", "0x00"}}, - { - /* No.317 delta:797 weight:987 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0xf7e1c4a2, 0x1e587863, 0xe9b9bcc1, 0x563013df, 0xa1d1d77d, 0x48686bbc, 0xbf89af1e, 0x00001394, 0xf7e1d736, 0x1e586bf7, 0xe9b9af55, 0x5630004b, 0xa1d1c4e9, 0x48687828, 0xbf89bc8a}, - [16]uint32{0x00000000, 0x07f01055, 0x4d0a1891, 0x4afa08c4, 0x0860c96c, 0x0f90d939, 0x456ad1fd, 0x429ac1a8, 0x90c0081f, 0x9730184a, 0xddca108e, 0xda3a00db, 0x98a0c173, 0x9f50d126, 0xd5aad9e2, 0xd25ac9b7}, - [16]uint32{0x3f800000, 0x3f83f808, 0x3fa6850c, 0x3fa57d04, 0x3f843064, 0x3f87c86c, 0x3fa2b568, 0x3fa14d60, 0x3fc86004, 0x3fcb980c, 0x3feee508, 0x3fed1d00, 0x3fcc5060, 0x3fcfa868, 0x3fead56c, 0x3fe92d64}, - uint32(0xfff80000), - [21]string{"0x1b", "0x30", "0x07", "0x24", "0x04", "0xf5", "0x67", "0x3f", "0x7e", "0xd5", "0x57", "0x9b", "0x73", "0x1b", "0xd8", "0xc0", "0x7a", "0x2e", "0xf6", "0x14", "0x00"}}, - { - /* No.318 delta:704 weight:1405 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0x9529c577, 0xc83c7399, 0x5d15b6ee, 0xefb013e0, 0x7a99d697, 0x278c6079, 0xb2a5a50e, 0x0000e239, 0x9529274e, 0xc83c91a0, 0x5d1554d7, 0xefb0f1d9, 0x7a9934ae, 0x278c8240, 0xb2a54737}, - [16]uint32{0x00000000, 0xa40209b3, 0x51006095, 0xf5026926, 0x80740887, 0x24760134, 0xd1746812, 0x757661a1, 0x0042219f, 0xa440282c, 0x5142410a, 0xf54048b9, 0x80362918, 0x243420ab, 0xd136498d, 0x7534403e}, - [16]uint32{0x3f800000, 0x3fd20104, 0x3fa88030, 0x3ffa8134, 0x3fc03a04, 0x3f923b00, 0x3fe8ba34, 0x3fbabb30, 0x3f802110, 0x3fd22014, 0x3fa8a120, 0x3ffaa024, 0x3fc01b14, 0x3f921a10, 0x3fe89b24, 0x3fba9a20}, - uint32(0xfff80000), - [21]string{"0xf1", "0x57", "0x29", "0xfc", "0x60", "0x9e", "0xd0", "0x93", "0x68", "0x21", "0x36", "0x83", "0xbf", "0x33", "0x33", "0x45", "0x83", "0x30", "0x85", "0x00", "0x00"}}, - { - /* No.319 delta:1947 weight:1519 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0xbad4c9df, 0xc6af05e7, 0x7c7bcc38, 0x680013f3, 0xd2d4da2c, 0xaeaf1614, 0x147bdfcb, 0x00004bee, 0xbad48231, 0xc6af4e09, 0x7c7b87d6, 0x6800581d, 0xd2d491c2, 0xaeaf5dfa, 0x147b9425}, - [16]uint32{0x00000000, 0x0e4422ba, 0x40802d79, 0x4ec40fc3, 0x0184080e, 0x0fc02ab4, 0x41042577, 0x4f4007cd, 0x0941ea0b, 0x0705c8b1, 0x49c1c772, 0x4785e5c8, 0x08c5e205, 0x0681c0bf, 0x4845cf7c, 0x4601edc6}, - [16]uint32{0x3f800000, 0x3f872211, 0x3fa04016, 0x3fa76207, 0x3f80c204, 0x3f87e015, 0x3fa08212, 0x3fa7a003, 0x3f84a0f5, 0x3f8382e4, 0x3fa4e0e3, 0x3fa3c2f2, 0x3f8462f1, 0x3f8340e0, 0x3fa422e7, 0x3fa300f6}, - uint32(0xfff80000), - [21]string{"0x58", "0xb2", "0xf4", "0xf5", "0xd7", "0x57", "0x9e", "0x1c", "0x57", "0x25", "0xfa", "0xee", "0x3f", "0x39", "0x72", "0x4c", "0x05", "0x26", "0x40", "0x8e", "0x00"}}, - { - /* No.320 delta:1343 weight:1707 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x95687d9e, 0xe12eee39, 0x744693a7, 0x00f01403, 0x9598699d, 0xe1defa3a, 0x74b687a4, 0x00004df2, 0x9568306c, 0xe12ea3cb, 0x7446de55, 0x00f059f1, 0x9598246f, 0xe1deb7c8, 0x74b6ca56}, - [16]uint32{0x00000000, 0x00304112, 0x000c8057, 0x003cc145, 0x0002018b, 0x00324099, 0x000e81dc, 0x003ec0ce, 0x0071015f, 0x0041404d, 0x007d8108, 0x004dc01a, 0x007300d4, 0x004341c6, 0x007f8083, 0x004fc191}, - [16]uint32{0x3f800000, 0x3f801820, 0x3f800640, 0x3f801e60, 0x3f800100, 0x3f801920, 0x3f800740, 0x3f801f60, 0x3f803880, 0x3f8020a0, 0x3f803ec0, 0x3f8026e0, 0x3f803980, 0x3f8021a0, 0x3f803fc0, 0x3f8027e0}, - uint32(0xfff80000), - [21]string{"0x3d", "0x98", "0x7f", "0xba", "0x4c", "0x07", "0x45", "0x40", "0x8d", "0x87", "0x77", "0xdc", "0x7b", "0xd4", "0xba", "0x42", "0x41", "0xfd", "0x7a", "0xf3", "0x00"}}, - { - /* No.321 delta:763 weight:1119 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0x9aa13a36, 0x3e3a4f1f, 0xa49b7529, 0x0b401415, 0x91e12e23, 0x357a5b0a, 0xafdb613c, 0x000016d1, 0x9aa12ce7, 0x3e3a59ce, 0xa49b63f8, 0x0b4002c4, 0x91e138f2, 0x357a4ddb, 0xafdb77ed}, - [16]uint32{0x00000000, 0x103a1d72, 0x10460014, 0x007c1d66, 0x0041080f, 0x107b157d, 0x1007081b, 0x003d1569, 0x0062700a, 0x10586d78, 0x1024701e, 0x001e6d6c, 0x00237805, 0x10196577, 0x10657811, 0x005f6563}, - [16]uint32{0x3f800000, 0x3f881d0e, 0x3f882300, 0x3f803e0e, 0x3f802084, 0x3f883d8a, 0x3f880384, 0x3f801e8a, 0x3f803138, 0x3f882c36, 0x3f881238, 0x3f800f36, 0x3f8011bc, 0x3f880cb2, 0x3f8832bc, 0x3f802fb2}, - uint32(0xfff80000), - [21]string{"0x3f", "0x7f", "0x60", "0xab", "0x7f", "0x82", "0x81", "0x09", "0xd4", "0xa6", "0x94", "0x58", "0x17", "0xb3", "0xc7", "0x2a", "0x79", "0xaa", "0x29", "0x1e", "0x00"}}, - { - /* No.322 delta:2883 weight:821 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0xe0fb1a8f, 0xa6843748, 0x467f2dc7, 0x4b20142c, 0xabdb0ea3, 0xeda42364, 0x0d5f39eb, 0x00002dcb, 0xe0fb3744, 0xa6841a83, 0x467f000c, 0x4b2039e7, 0xabdb2368, 0xeda40eaf, 0x0d5f1420}, - [16]uint32{0x00000000, 0x1a03e997, 0x0e120811, 0x1411e186, 0x096200d5, 0x1361e942, 0x077008c4, 0x1d73e153, 0x80020c8f, 0x9a01e518, 0x8e10049e, 0x9413ed09, 0x89600c5a, 0x9363e5cd, 0x8772044b, 0x9d71eddc}, - [16]uint32{0x3f800000, 0x3f8d01f4, 0x3f870904, 0x3f8a08f0, 0x3f84b100, 0x3f89b0f4, 0x3f83b804, 0x3f8eb9f0, 0x3fc00106, 0x3fcd00f2, 0x3fc70802, 0x3fca09f6, 0x3fc4b006, 0x3fc9b1f2, 0x3fc3b902, 0x3fceb8f6}, - uint32(0xfff80000), - [21]string{"0x07", "0x40", "0x26", "0xee", "0x41", "0x3e", "0x36", "0x8f", "0x2b", "0x61", "0xbe", "0xa5", "0xb4", "0xc1", "0xdb", "0x90", "0x7f", "0x30", "0x55", "0x08", "0x00"}}, - { - /* No.323 delta:787 weight:1255 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0xc201724a, 0xbd7f5d87, 0x7f7e2fcd, 0xc0b01432, 0x02b16678, 0x7dcf49b5, 0xbfce3bff, 0x0000d10c, 0xc201a346, 0xbd7f8c8b, 0x7f7efec1, 0xc0b0c53e, 0x02b1b774, 0x7dcf98b9, 0xbfceeaf3}, - [16]uint32{0x00000000, 0x2003097e, 0x2000e049, 0x0003e937, 0x100409ab, 0x300700d5, 0x3004e9e2, 0x1007e09c, 0x6004001a, 0x40070964, 0x4004e053, 0x6007e92d, 0x700009b1, 0x500300cf, 0x5000e9f8, 0x7003e086}, - [16]uint32{0x3f800000, 0x3f900184, 0x3f900070, 0x3f8001f4, 0x3f880204, 0x3f980380, 0x3f980274, 0x3f8803f0, 0x3fb00200, 0x3fa00384, 0x3fa00270, 0x3fb003f4, 0x3fb80004, 0x3fa80180, 0x3fa80074, 0x3fb801f0}, - uint32(0xfff80000), - [21]string{"0x3c", "0x1d", "0xc8", "0x48", "0xca", "0x0e", "0x2b", "0x39", "0x42", "0x3d", "0x4c", "0xff", "0x69", "0xac", "0xff", "0xe8", "0xf7", "0xa9", "0xe2", "0x6c", "0x00"}}, - { - /* No.324 delta:795 weight:1553 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0x3c65716d, 0x511a1b1b, 0x6d7f6a76, 0x6420144e, 0x58456523, 0x353a0f55, 0x095f7e38, 0x0000c620, 0x3c65b74d, 0x511add3b, 0x6d7fac56, 0x6420d26e, 0x5845a303, 0x353ac975, 0x095fb818}, - [16]uint32{0x00000000, 0x0005193e, 0x0002b037, 0x0007a909, 0x0043901c, 0x00468922, 0x0041202b, 0x00443915, 0x282110a3, 0x2824099d, 0x2823a094, 0x2826b9aa, 0x286280bf, 0x28679981, 0x28603088, 0x286529b6}, - [16]uint32{0x3f800000, 0x3f80028c, 0x3f800158, 0x3f8003d4, 0x3f8021c8, 0x3f802344, 0x3f802090, 0x3f80221c, 0x3f941088, 0x3f941204, 0x3f9411d0, 0x3f94135c, 0x3f943140, 0x3f9433cc, 0x3f943018, 0x3f943294}, - uint32(0xfff80000), - [21]string{"0x6b", "0x7e", "0x85", "0x2e", "0xce", "0x11", "0x4b", "0xad", "0xcd", "0x12", "0x16", "0xd1", "0xb1", "0xeb", "0x8a", "0x25", "0xa8", "0xfa", "0xe8", "0x1e", "0x00"}}, - { - /* No.325 delta:1620 weight:1585 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x1c3439f2, 0x2cb4051e, 0x30803cec, 0x12901459, 0x0ea42dab, 0x3e241147, 0x221028b5, 0x00005f03, 0x1c3466f1, 0x2cb45a1d, 0x308063ef, 0x12904b5a, 0x0ea472a8, 0x3e244e44, 0x221077b6}, - [16]uint32{0x00000000, 0x00f80992, 0xc20402dc, 0xc2fc0b4e, 0x200c8011, 0x20f48983, 0xe20882cd, 0xe2f08b5f, 0x1000440b, 0x10f84d99, 0xd20446d7, 0xd2fc4f45, 0x300cc41a, 0x30f4cd88, 0xf208c6c6, 0xf2f0cf54}, - [16]uint32{0x3f800000, 0x3f807c04, 0x3fe10201, 0x3fe17e05, 0x3f900640, 0x3f907a44, 0x3ff10441, 0x3ff17845, 0x3f880022, 0x3f887c26, 0x3fe90223, 0x3fe97e27, 0x3f980662, 0x3f987a66, 0x3ff90463, 0x3ff97867}, - uint32(0xfff80000), - [21]string{"0x14", "0x85", "0x7c", "0xf8", "0xd2", "0x0e", "0x6b", "0x76", "0x39", "0x54", "0x41", "0x6f", "0x01", "0xf9", "0x76", "0x71", "0x51", "0xc6", "0x4a", "0x7a", "0x00"}}, - { - /* No.326 delta:1192 weight:1299 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x96676930, 0x1ebf2087, 0x88d849b7, 0xe8001466, 0x7e677d56, 0xf6bf34e1, 0x60d85dd1, 0x00003950, 0x96675060, 0x1ebf19d7, 0x88d870e7, 0xe8002d36, 0x7e674406, 0xf6bf0db1, 0x60d86481}, - [16]uint32{0x00000000, 0x0026ca1c, 0x004350b3, 0x00659aaf, 0x2108e059, 0x212e2a45, 0x214bb0ea, 0x216d7af6, 0x00024012, 0x00248a0e, 0x004110a1, 0x0067dabd, 0x210aa04b, 0x212c6a57, 0x2149f0f8, 0x216f3ae4}, - [16]uint32{0x3f800000, 0x3f801365, 0x3f8021a8, 0x3f8032cd, 0x3f908470, 0x3f909715, 0x3f90a5d8, 0x3f90b6bd, 0x3f800120, 0x3f801245, 0x3f802088, 0x3f8033ed, 0x3f908550, 0x3f909635, 0x3f90a4f8, 0x3f90b79d}, - uint32(0xfff80000), - [21]string{"0x4f", "0x3b", "0x08", "0x33", "0xa8", "0xee", "0x2e", "0x08", "0xcf", "0x9c", "0x3b", "0x52", "0x0b", "0xa7", "0x35", "0xfc", "0xdb", "0x1d", "0xe8", "0x24", "0x00"}}, - { - /* No.327 delta:1536 weight:1647 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x8bc3dfcb, 0x91944dcf, 0x1a579204, 0x4c101471, 0xc7d3cbba, 0xdd8459be, 0x56478675, 0x000012f3, 0x8bc3cd38, 0x91945f3c, 0x1a5780f7, 0x4c100682, 0xc7d3d949, 0xdd844b4d, 0x56479486}, - [16]uint32{0x00000000, 0x0057a0dc, 0x0078411f, 0x002fe1c3, 0x100441ab, 0x1053e177, 0x107c00b4, 0x102ba068, 0x1000007e, 0x1057a0a2, 0x10784161, 0x102fe1bd, 0x000441d5, 0x0053e109, 0x007c00ca, 0x002ba016}, - [16]uint32{0x3f800000, 0x3f802bd0, 0x3f803c20, 0x3f8017f0, 0x3f880220, 0x3f8829f0, 0x3f883e00, 0x3f8815d0, 0x3f880000, 0x3f882bd0, 0x3f883c20, 0x3f8817f0, 0x3f800220, 0x3f8029f0, 0x3f803e00, 0x3f8015d0}, - uint32(0xfff80000), - [21]string{"0xf8", "0x64", "0x08", "0xa2", "0x57", "0xd1", "0x81", "0xf2", "0x8a", "0x27", "0xab", "0x84", "0x7d", "0xb0", "0x0b", "0xe5", "0x22", "0x66", "0x24", "0x1d", "0x00"}}, - { - /* No.328 delta:1074 weight:779 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x48a4e13a, 0x0f8b032c, 0x472fe216, 0xa9701488, 0xe1d4f5b2, 0xa6fb17a4, 0xee5ff69e, 0x000021ce, 0x48a4c0f4, 0x0f8b22e2, 0x472fc3d8, 0xa9703546, 0xe1d4d47c, 0xa6fb366a, 0xee5fd750}, - [16]uint32{0x00000000, 0x08658037, 0x00184019, 0x087dc02e, 0x0003016d, 0x0866815a, 0x001b4174, 0x087ec143, 0x40241ba8, 0x48419b9f, 0x403c5bb1, 0x4859db86, 0x40271ac5, 0x48429af2, 0x403f5adc, 0x485adaeb}, - [16]uint32{0x3f800000, 0x3f8432c0, 0x3f800c20, 0x3f843ee0, 0x3f800180, 0x3f843340, 0x3f800da0, 0x3f843f60, 0x3fa0120d, 0x3fa420cd, 0x3fa01e2d, 0x3fa42ced, 0x3fa0138d, 0x3fa4214d, 0x3fa01fad, 0x3fa42d6d}, - uint32(0xfff80000), - [21]string{"0x5d", "0xa9", "0xf2", "0x8d", "0x87", "0x47", "0x78", "0x7c", "0x72", "0xda", "0x47", "0x7c", "0xfd", "0xdc", "0x62", "0x66", "0xcb", "0x82", "0x28", "0x6b", "0x00"}}, - { - /* No.329 delta:1431 weight:1593 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0x52b71d7c, 0x4f1c5a83, 0x1dab47ff, 0x9630149b, 0xc48709e7, 0xd92c4e18, 0x8b9b5364, 0x00004833, 0x52b7554f, 0x4f1c12b0, 0x1dab0fcc, 0x96305ca8, 0xc48741d4, 0xd92c062b, 0x8b9b1b57}, - [16]uint32{0x00000000, 0x007ae0b2, 0x10440c15, 0x103eeca7, 0xa084100e, 0xa0fef0bc, 0xb0c01c1b, 0xb0bafca9, 0x10310011, 0x104be0a3, 0x00750c04, 0x000fecb6, 0xb0b5101f, 0xb0cff0ad, 0xa0f11c0a, 0xa08bfcb8}, - [16]uint32{0x3f800000, 0x3f803d70, 0x3f882206, 0x3f881f76, 0x3fd04208, 0x3fd07f78, 0x3fd8600e, 0x3fd85d7e, 0x3f881880, 0x3f8825f0, 0x3f803a86, 0x3f8007f6, 0x3fd85a88, 0x3fd867f8, 0x3fd0788e, 0x3fd045fe}, - uint32(0xfff80000), - [21]string{"0x4b", "0x4c", "0x4a", "0x92", "0x08", "0x7a", "0x0d", "0x81", "0xbe", "0x69", "0xe8", "0x71", "0xcb", "0xdf", "0x9c", "0xad", "0x46", "0x94", "0x0a", "0x2f", "0x00"}}, - { - /* No.330 delta:1014 weight:1347 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xb9ac6e8d, 0x4ade8d84, 0xf372e309, 0xa47014a3, 0x1ddc7a2e, 0xeeae9927, 0x5702f7aa, 0x000051d7, 0xb9ac3f5a, 0x4adedc53, 0xf372b2de, 0xa4704574, 0x1ddc2bf9, 0xeeaec8f0, 0x5702a67d}, - [16]uint32{0x00000000, 0x104c047a, 0x900a898b, 0x80468df1, 0x30022057, 0x204e242d, 0xa008a9dc, 0xb044ada6, 0x30018033, 0x204d8449, 0xa00b09b8, 0xb0470dc2, 0x0003a064, 0x104fa41e, 0x900929ef, 0x80452d95}, - [16]uint32{0x3f800000, 0x3f882602, 0x3fc80544, 0x3fc02346, 0x3f980110, 0x3f902712, 0x3fd00454, 0x3fd82256, 0x3f9800c0, 0x3f9026c2, 0x3fd00584, 0x3fd82386, 0x3f8001d0, 0x3f8827d2, 0x3fc80494, 0x3fc02296}, - uint32(0xfff80000), - [21]string{"0xfb", "0x45", "0x9c", "0x16", "0xf7", "0x4b", "0x41", "0x51", "0x56", "0x25", "0x8d", "0xac", "0x08", "0x7e", "0xf6", "0x74", "0x59", "0x43", "0x10", "0x3a", "0x00"}}, - { - /* No.331 delta:942 weight:1487 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0x4f381880, 0x42fe1804, 0x0dc60084, 0x44a014b6, 0x0b980c36, 0x065e0cb2, 0x49661432, 0x0000f4e4, 0x4f38ec64, 0x42feece0, 0x0dc6f460, 0x44a0e052, 0x0b98f8d2, 0x065ef856, 0x4966e0d6}, - [16]uint32{0x00000000, 0x102441bf, 0x2052801d, 0x3076c1a2, 0x00024c05, 0x10260dba, 0x2050cc18, 0x30748da7, 0x201c65cc, 0x30382473, 0x004ee5d1, 0x106aa46e, 0x201e29c9, 0x303a6876, 0x004ca9d4, 0x1068e86b}, - [16]uint32{0x3f800000, 0x3f881220, 0x3f902940, 0x3f983b60, 0x3f800126, 0x3f881306, 0x3f902866, 0x3f983a46, 0x3f900e32, 0x3f981c12, 0x3f802772, 0x3f883552, 0x3f900f14, 0x3f981d34, 0x3f802654, 0x3f883474}, - uint32(0xfff80000), - [21]string{"0x9f", "0x3c", "0x4e", "0x68", "0xc4", "0xf3", "0xb7", "0x86", "0xdd", "0xe6", "0x06", "0x02", "0x74", "0x0b", "0x88", "0xbb", "0xa0", "0x54", "0x7d", "0xc6", "0x00"}}, - { - /* No.332 delta:1315 weight:1465 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0xd9ebe020, 0xbcf2d8aa, 0x6519388a, 0xa8e014c6, 0x710bf4e6, 0x1412cc6c, 0xcdf92c4c, 0x00001a2d, 0xd9ebfa0d, 0xbcf2c287, 0x651922a7, 0xa8e00eeb, 0x710beecb, 0x1412d641, 0xcdf93661}, - [16]uint32{0x00000000, 0x0041d1f6, 0x003c282f, 0x007df9d9, 0x82728135, 0x823350c3, 0x824ea91a, 0x820f78ec, 0x0002219b, 0x0043f06d, 0x003e09b4, 0x007fd842, 0x8270a0ae, 0x82317158, 0x824c8881, 0x820d5977}, - [16]uint32{0x3f800000, 0x3f8020e8, 0x3f801e14, 0x3f803efc, 0x3fc13940, 0x3fc119a8, 0x3fc12754, 0x3fc107bc, 0x3f800110, 0x3f8021f8, 0x3f801f04, 0x3f803fec, 0x3fc13850, 0x3fc118b8, 0x3fc12644, 0x3fc106ac}, - uint32(0xfff80000), - [21]string{"0x07", "0x6d", "0xbc", "0xfd", "0x70", "0x7b", "0x0f", "0x98", "0xc9", "0x68", "0xda", "0x90", "0x90", "0x27", "0x32", "0x15", "0xf5", "0x14", "0x0c", "0x29", "0x00"}}, - { - /* No.333 delta:820 weight:1577 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0xe096b9be, 0xdcdb6ce8, 0x3c4dd556, 0xa7a014d6, 0x4736ad68, 0x7b7b783e, 0x9bedc180, 0x00000186, 0xe096b838, 0xdcdb6d6e, 0x3c4dd4d0, 0xa7a01550, 0x4736acee, 0x7b7b79b8, 0x9bedc006}, - [16]uint32{0x00000000, 0x5000a013, 0x0002357a, 0x50029569, 0xa044041e, 0xf044a40d, 0xa0463164, 0xf0469177, 0x10012a15, 0x40018a06, 0x10031f6f, 0x4003bf7c, 0xb0452e0b, 0xe0458e18, 0xb0471b71, 0xe047bb62}, - [16]uint32{0x3f800000, 0x3fa80050, 0x3f80011a, 0x3fa8014a, 0x3fd02202, 0x3ff82252, 0x3fd02318, 0x3ff82348, 0x3f880095, 0x3fa000c5, 0x3f88018f, 0x3fa001df, 0x3fd82297, 0x3ff022c7, 0x3fd8238d, 0x3ff023dd}, - uint32(0xfff80000), - [21]string{"0xde", "0x1b", "0xa2", "0x18", "0xa3", "0x83", "0xee", "0xf9", "0x62", "0xfc", "0xdf", "0x4e", "0x92", "0x5e", "0x6a", "0xed", "0x9d", "0xc5", "0x62", "0xb1", "0x00"}}, - { - /* No.334 delta:1674 weight:1425 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0x0243c96b, 0x115a5aa7, 0x131993cc, 0xfe0014ea, 0xfc43dd81, 0xef5a4e4d, 0xed198726, 0x0000ad8a, 0x024364e1, 0x115af72d, 0x13193e46, 0xfe00b960, 0xfc43700b, 0xef5ae3c7, 0xed192aac}, - [16]uint32{0x00000000, 0x002c01ba, 0x004100df, 0x006d0165, 0x30080068, 0x302401d2, 0x304900b7, 0x3065010d, 0x20000018, 0x202c01a2, 0x204100c7, 0x206d017d, 0x10080070, 0x102401ca, 0x104900af, 0x10650115}, - [16]uint32{0x3f800000, 0x3f801600, 0x3f802080, 0x3f803680, 0x3f980400, 0x3f981200, 0x3f982480, 0x3f983280, 0x3f900000, 0x3f901600, 0x3f902080, 0x3f903680, 0x3f880400, 0x3f881200, 0x3f882480, 0x3f883280}, - uint32(0xfff80000), - [21]string{"0xb4", "0xae", "0xea", "0x67", "0xc4", "0xae", "0x5b", "0x04", "0x54", "0xea", "0x0d", "0x15", "0xe5", "0x54", "0x57", "0x6f", "0xe7", "0xf7", "0x7e", "0x99", "0x00"}}, - { - /* No.335 delta:1075 weight:1679 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x51638d87, 0xe085c9f6, 0xb1e64471, 0xb68014f8, 0xe7e3997f, 0x5605dd0e, 0x07665089, 0x00007b51, 0x5163f6d6, 0xe085b2a7, 0xb1e63f20, 0xb6806fa9, 0xe7e3e22e, 0x5605a65f, 0x07662bd8}, - [16]uint32{0x00000000, 0x40386133, 0x00640036, 0x405c6105, 0x0801600f, 0x4839013c, 0x08656039, 0x485d010a, 0x0003015b, 0x403b6068, 0x0067016d, 0x405f605e, 0x08026154, 0x483a0067, 0x08666162, 0x485e0051}, - [16]uint32{0x3f800000, 0x3fa01c30, 0x3f803200, 0x3fa02e30, 0x3f8400b0, 0x3fa41c80, 0x3f8432b0, 0x3fa42e80, 0x3f800180, 0x3fa01db0, 0x3f803380, 0x3fa02fb0, 0x3f840130, 0x3fa41d00, 0x3f843330, 0x3fa42f00}, - uint32(0xfff80000), - [21]string{"0x0b", "0x36", "0x2f", "0x64", "0x4c", "0x2c", "0xf2", "0x85", "0xc3", "0x18", "0x3a", "0x0b", "0x27", "0x8e", "0x6b", "0xff", "0x2a", "0xaf", "0xb1", "0xa1", "0x00"}}, - { - /* No.336 delta:1464 weight:1505 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xd4f52a80, 0xca4a05ad, 0x1ebf2f2d, 0x12b0150f, 0xc6453f8f, 0xd8fa10a2, 0x0c0f3a22, 0x00003ef1, 0xd4f51471, 0xca4a3b5c, 0x1ebf11dc, 0x12b02bfe, 0xc645017e, 0xd8fa2e53, 0x0c0f04d3}, - [16]uint32{0x00000000, 0x0067293e, 0x503b404a, 0x505c6974, 0x001e11b7, 0x00793889, 0x502551fd, 0x504278c3, 0x0005001b, 0x00622925, 0x503e4051, 0x5059696f, 0x001b11ac, 0x007c3892, 0x502051e6, 0x504778d8}, - [16]uint32{0x3f800000, 0x3f803394, 0x3fa81da0, 0x3fa82e34, 0x3f800f08, 0x3f803c9c, 0x3fa812a8, 0x3fa8213c, 0x3f800280, 0x3f803114, 0x3fa81f20, 0x3fa82cb4, 0x3f800d88, 0x3f803e1c, 0x3fa81028, 0x3fa823bc}, - uint32(0xfff80000), - [21]string{"0xad", "0x6a", "0xc9", "0xf1", "0xb0", "0xb0", "0xaf", "0x19", "0x40", "0x96", "0x82", "0xbd", "0x6b", "0x7f", "0xd6", "0x80", "0x4f", "0xc9", "0xe2", "0xb4", "0x00"}}, - { - /* No.337 delta:1298 weight:1167 */ - 11213, - 36, - 13, - 4, - [16]uint32{0x00000000, 0xb6de49a0, 0x3acc1f09, 0x8c1256a9, 0xf690151b, 0x404e5cbb, 0xcc5c0a12, 0x7a8243b2, 0x00004270, 0xb6de0bd0, 0x3acc5d79, 0x8c1214d9, 0xf690576b, 0x404e1ecb, 0xcc5c4862, 0x7a8201c2}, - [16]uint32{0x00000000, 0x007e419e, 0x000200d5, 0x007c414b, 0x100101ba, 0x107f4024, 0x1003016f, 0x107d40f1, 0x0001e019, 0x007fa187, 0x0003e0cc, 0x007da152, 0x1000e1a3, 0x107ea03d, 0x1002e176, 0x107ca0e8}, - [16]uint32{0x3f800000, 0x3f803f20, 0x3f800100, 0x3f803e20, 0x3f880080, 0x3f883fa0, 0x3f880180, 0x3f883ea0, 0x3f8000f0, 0x3f803fd0, 0x3f8001f0, 0x3f803ed0, 0x3f880070, 0x3f883f50, 0x3f880170, 0x3f883e50}, - uint32(0xfff80000), - [21]string{"0x78", "0xa4", "0xac", "0x37", "0xf1", "0x2d", "0xc7", "0xe4", "0x78", "0x4d", "0x40", "0xea", "0x5f", "0xb5", "0x65", "0x8c", "0xb3", "0xfe", "0x6e", "0x11", "0x00"}}, - { - /* No.338 delta:1869 weight:1493 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x557ccf79, 0x92c336a6, 0xc7bff9df, 0xceb01526, 0x9bccda5f, 0x5c732380, 0x090fecf9, 0x000054db, 0x557c9ba2, 0x92c3627d, 0xc7bfad04, 0xceb041fd, 0x9bcc8e84, 0x5c73775b, 0x090fb822}, - [16]uint32{0x00000000, 0x9907821a, 0x2113e1ad, 0xb81463b7, 0x28806039, 0xb187e223, 0x09938194, 0x9094038e, 0x7064d35e, 0xe9635144, 0x517732f3, 0xc870b0e9, 0x58e4b367, 0xc1e3317d, 0x79f752ca, 0xe0f0d0d0}, - [16]uint32{0x3f800000, 0x3fcc83c1, 0x3f9089f0, 0x3fdc0a31, 0x3f944030, 0x3fd8c3f1, 0x3f84c9c0, 0x3fc84a01, 0x3fb83269, 0x3ff4b1a8, 0x3fa8bb99, 0x3fe43858, 0x3fac7259, 0x3fe0f198, 0x3fbcfba9, 0x3ff07868}, - uint32(0xfff80000), - [21]string{"0xce", "0x65", "0xce", "0xc4", "0x70", "0xc0", "0x87", "0xff", "0x4d", "0x30", "0x57", "0xe1", "0x4e", "0x54", "0x2a", "0x2e", "0x65", "0x2d", "0x07", "0xd9", "0x00"}}, - { - /* No.339 delta:802 weight:1691 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0xe347fae3, 0xaa93278b, 0x49d4dd68, 0xbcb01531, 0x5ff7efd2, 0x162332ba, 0xf564c859, 0x000084b0, 0xe3477e53, 0xaa93a33b, 0x49d459d8, 0xbcb09181, 0x5ff76b62, 0x1623b60a, 0xf5644ce9}, - [16]uint32{0x00000000, 0x01401c77, 0x10000206, 0x11401e71, 0x9000019b, 0x91401dec, 0x8000039d, 0x81401fea, 0x3101a0f2, 0x3041bc85, 0x2101a2f4, 0x2041be83, 0xa101a169, 0xa041bd1e, 0xb101a36f, 0xb041bf18}, - [16]uint32{0x3f800000, 0x3f80a00e, 0x3f880001, 0x3f88a00f, 0x3fc80000, 0x3fc8a00e, 0x3fc00001, 0x3fc0a00f, 0x3f9880d0, 0x3f9820de, 0x3f9080d1, 0x3f9020df, 0x3fd080d0, 0x3fd020de, 0x3fd880d1, 0x3fd820df}, - uint32(0xfff80000), - [21]string{"0xc1", "0x7e", "0xb1", "0x45", "0xa6", "0x8c", "0x0c", "0xa0", "0xc5", "0x7f", "0x0f", "0xc0", "0x8a", "0x9e", "0xb3", "0x56", "0x33", "0x68", "0x3b", "0x18", "0x00"}}, - { - /* No.340 delta:2189 weight:1223 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xc7331da0, 0x6241ad6d, 0xa572b0cd, 0x11b0154f, 0xd68308ef, 0x73f1b822, 0xb4c2a582, 0x00007d34, 0xc7336094, 0x6241d059, 0xa572cdf9, 0x11b0687b, 0xd68375db, 0x73f1c516, 0xb4c2d8b6}, - [16]uint32{0x00000000, 0x0d02153a, 0x0a004409, 0x07025133, 0x038372be, 0x0e816784, 0x098336b7, 0x0481238d, 0x01001a1c, 0x0c020f26, 0x0b005e15, 0x06024b2f, 0x028368a2, 0x0f817d98, 0x08832cab, 0x05813991}, - [16]uint32{0x3f800000, 0x3f86810a, 0x3f850022, 0x3f838128, 0x3f81c1b9, 0x3f8740b3, 0x3f84c19b, 0x3f824091, 0x3f80800d, 0x3f860107, 0x3f85802f, 0x3f830125, 0x3f8141b4, 0x3f87c0be, 0x3f844196, 0x3f82c09c}, - uint32(0xfff80000), - [21]string{"0xd7", "0x99", "0xdc", "0x3d", "0xe6", "0x75", "0xb5", "0x4d", "0xc6", "0x0a", "0x51", "0x47", "0xac", "0x0f", "0x03", "0x6f", "0xec", "0x35", "0x6b", "0x7a", "0x00"}}, - { - /* No.341 delta:1415 weight:1677 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0xe5a8fe2d, 0x99e7dc90, 0x7c4f22bd, 0x7d101555, 0x98b8eb78, 0xe4f7c9c5, 0x015f37e8, 0x00008141, 0xe5a87f6c, 0x99e75dd1, 0x7c4fa3fc, 0x7d109414, 0x98b86a39, 0xe4f74884, 0x015fb6a9}, - [16]uint32{0x00000000, 0x006c4197, 0x001001f2, 0x007c4065, 0x000200aa, 0x006e413d, 0x00120158, 0x007e40cf, 0x1043801c, 0x102fc18b, 0x105381ee, 0x103fc079, 0x104180b6, 0x102dc121, 0x10518144, 0x103dc0d3}, - [16]uint32{0x3f800000, 0x3f803620, 0x3f800800, 0x3f803e20, 0x3f800100, 0x3f803720, 0x3f800900, 0x3f803f20, 0x3f8821c0, 0x3f8817e0, 0x3f8829c0, 0x3f881fe0, 0x3f8820c0, 0x3f8816e0, 0x3f8828c0, 0x3f881ee0}, - uint32(0xfff80000), - [21]string{"0x61", "0x5c", "0xdd", "0x3f", "0xcb", "0x58", "0xda", "0xf6", "0x62", "0xe9", "0x0d", "0xb8", "0x14", "0xbd", "0x63", "0x5b", "0x3e", "0xb3", "0x37", "0xce", "0x00"}}, - { - /* No.342 delta:706 weight:1683 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0x72c9c252, 0xa7c90593, 0xd500c7c1, 0x6f701562, 0x1db9d730, 0xc8b910f1, 0xba70d2a3, 0x0000a0f4, 0x72c962a6, 0xa7c9a567, 0xd5006735, 0x6f70b596, 0x1db977c4, 0xc8b9b005, 0xba707257}, - [16]uint32{0x00000000, 0x4002049e, 0x4410ce1d, 0x0412ca83, 0x1009e50a, 0x500be194, 0x54192b17, 0x141b2f89, 0x4001ac65, 0x0003a8fb, 0x04116278, 0x441366e6, 0x5008496f, 0x100a4df1, 0x14188772, 0x541a83ec}, - [16]uint32{0x3f800000, 0x3fa00102, 0x3fa20867, 0x3f820965, 0x3f8804f2, 0x3fa805f0, 0x3faa0c95, 0x3f8a0d97, 0x3fa000d6, 0x3f8001d4, 0x3f8208b1, 0x3fa209b3, 0x3fa80424, 0x3f880526, 0x3f8a0c43, 0x3faa0d41}, - uint32(0xfff80000), - [21]string{"0xac", "0x26", "0x73", "0x72", "0xdc", "0x6b", "0xa4", "0x2c", "0xdb", "0x49", "0x64", "0xd3", "0x82", "0x95", "0x07", "0x34", "0xee", "0x5c", "0xc9", "0x8b", "0x00"}}, - { - /* No.343 delta:1208 weight:1535 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x469f7107, 0x71bce1ea, 0x372390ed, 0x05c01570, 0x435f6477, 0x747cf49a, 0x32e3859d, 0x00000429, 0x469f752e, 0x71bce5c3, 0x372394c4, 0x05c01159, 0x435f605e, 0x747cf0b3, 0x32e381b4}, - [16]uint32{0x00000000, 0x0051133a, 0xa0000017, 0xa051132d, 0x30188495, 0x304997af, 0x90188482, 0x904997b8, 0x00899c11, 0x00d88f2b, 0xa0899c06, 0xa0d88f3c, 0x30911884, 0x30c00bbe, 0x90911893, 0x90c00ba9}, - [16]uint32{0x3f800000, 0x3f802889, 0x3fd00000, 0x3fd02889, 0x3f980c42, 0x3f9824cb, 0x3fc80c42, 0x3fc824cb, 0x3f8044ce, 0x3f806c47, 0x3fd044ce, 0x3fd06c47, 0x3f98488c, 0x3f986005, 0x3fc8488c, 0x3fc86005}, - uint32(0xfff80000), - [21]string{"0x6b", "0x61", "0x0b", "0x45", "0x93", "0xc7", "0x5b", "0x8e", "0xaf", "0x89", "0x6d", "0x89", "0xff", "0xb6", "0x38", "0x9e", "0x2e", "0xee", "0x76", "0x8f", "0x00"}}, - { - /* No.344 delta:1500 weight:1641 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x8bc3dfcb, 0x91944dcf, 0x1a579204, 0x4c101581, 0xc7d3ca4a, 0xdd84584e, 0x56478785, 0x000012f3, 0x8bc3cd38, 0x91945f3c, 0x1a5780f7, 0x4c100772, 0xc7d3d8b9, 0xdd844abd, 0x56479576}, - [16]uint32{0x00000000, 0x004c809c, 0x0038c1a2, 0x0074413e, 0x00084076, 0x0044c0ea, 0x003081d4, 0x007c0148, 0x22100010, 0x225c808c, 0x2228c1b2, 0x2264412e, 0x22184066, 0x2254c0fa, 0x222081c4, 0x226c0158}, - [16]uint32{0x3f800000, 0x3f802640, 0x3f801c60, 0x3f803a20, 0x3f800420, 0x3f802260, 0x3f801840, 0x3f803e00, 0x3f910800, 0x3f912e40, 0x3f911460, 0x3f913220, 0x3f910c20, 0x3f912a60, 0x3f911040, 0x3f913600}, - uint32(0xfff80000), - [21]string{"0x8b", "0x8d", "0x88", "0xed", "0x19", "0xc2", "0x91", "0xc6", "0xd2", "0x10", "0x21", "0xea", "0xf5", "0x4b", "0x24", "0x19", "0x15", "0x85", "0x9c", "0x0d", "0x00"}}, - { - /* No.345 delta:874 weight:1661 */ - 11213, - 75, - 13, - 4, - [16]uint32{0x00000000, 0xa6151454, 0xff23562b, 0x5936427f, 0xf260159a, 0x547501ce, 0x0d4343b1, 0xab5657e5, 0x00005ee0, 0xa6154ab4, 0xff2308cb, 0x59361c9f, 0xf2604b7a, 0x54755f2e, 0x0d431d51, 0xab560905}, - [16]uint32{0x00000000, 0x9010c13b, 0x20020407, 0xb012c53c, 0x400032d6, 0xd010f3ed, 0x600236d1, 0xf012f7ea, 0x0001981e, 0x90115925, 0x20039c19, 0xb0135d22, 0x4001aac8, 0xd0116bf3, 0x6003aecf, 0xf0136ff4}, - [16]uint32{0x3f800000, 0x3fc80860, 0x3f900102, 0x3fd80962, 0x3fa00019, 0x3fe80879, 0x3fb0011b, 0x3ff8097b, 0x3f8000cc, 0x3fc808ac, 0x3f9001ce, 0x3fd809ae, 0x3fa000d5, 0x3fe808b5, 0x3fb001d7, 0x3ff809b7}, - uint32(0xfff80000), - [21]string{"0xe5", "0xb9", "0xf4", "0xf6", "0xd6", "0x20", "0x83", "0x08", "0x4b", "0xfe", "0x22", "0xa5", "0x3e", "0xe1", "0xfa", "0xc1", "0x74", "0x64", "0xc1", "0xd4", "0x00"}}, - { - /* No.346 delta:668 weight:1631 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0x6cdca230, 0x1e5aef28, 0x72864d18, 0xff5015aa, 0x938cb79a, 0xe10afa82, 0x8dd658b2, 0x0000a0f4, 0x6cdc02c4, 0x1e5a4fdc, 0x7286edec, 0xff50b55e, 0x938c176e, 0xe10a5a76, 0x8dd6f846}, - [16]uint32{0x00000000, 0x50031033, 0x4000e967, 0x1003f954, 0x0016840e, 0x5015943d, 0x40166d69, 0x10157d5a, 0x00021c02, 0x50010c31, 0x4002f565, 0x1001e556, 0x0014980c, 0x5017883f, 0x4014716b, 0x10176158}, - [16]uint32{0x3f800000, 0x3fa80188, 0x3fa00074, 0x3f8801fc, 0x3f800b42, 0x3fa80aca, 0x3fa00b36, 0x3f880abe, 0x3f80010e, 0x3fa80086, 0x3fa0017a, 0x3f8800f2, 0x3f800a4c, 0x3fa80bc4, 0x3fa00a38, 0x3f880bb0}, - uint32(0xfff80000), - [21]string{"0x16", "0xc9", "0xc2", "0xe3", "0xc9", "0x45", "0xe3", "0x66", "0x08", "0x01", "0xb7", "0x05", "0xc4", "0x33", "0xde", "0xa4", "0x72", "0x32", "0x0c", "0x60", "0x00"}}, - { - /* No.347 delta:672 weight:1377 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0x64f6ccf6, 0xa5446450, 0xc1b2a8a6, 0xc7e015bb, 0xa316d94d, 0x62a471eb, 0x0652bd1d, 0x0000ba59, 0x64f676af, 0xa544de09, 0xc1b212ff, 0xc7e0afe2, 0xa3166314, 0x62a4cbb2, 0x06520744}, - [16]uint32{0x00000000, 0x1038517d, 0x9062008e, 0x805a51f3, 0x004064af, 0x107835d2, 0x90226421, 0x801a355c, 0x20208015, 0x3018d168, 0xb042809b, 0xa07ad1e6, 0x2060e4ba, 0x3058b5c7, 0xb002e434, 0xa03ab549}, - [16]uint32{0x3f800000, 0x3f881c28, 0x3fc83100, 0x3fc02d28, 0x3f802032, 0x3f883c1a, 0x3fc81132, 0x3fc00d1a, 0x3f901040, 0x3f980c68, 0x3fd82140, 0x3fd03d68, 0x3f903072, 0x3f982c5a, 0x3fd80172, 0x3fd01d5a}, - uint32(0xfff80000), - [21]string{"0x85", "0xa9", "0x7e", "0x54", "0xab", "0x3e", "0x90", "0xf7", "0xf7", "0x23", "0x6e", "0xa4", "0xc4", "0x27", "0x65", "0xe3", "0xda", "0x9b", "0x92", "0xdf", "0x00"}}, - { - /* No.348 delta:580 weight:1491 */ - 11213, - 81, - 13, - 4, - [16]uint32{0x00000000, 0x6280169c, 0x54214e05, 0x36a15899, 0x513015c8, 0x33b00354, 0x05115bcd, 0x67914d51, 0x0000a747, 0x6280b1db, 0x5421e942, 0x36a1ffde, 0x5130b28f, 0x33b0a413, 0x0511fc8a, 0x6791ea16}, - [16]uint32{0x00000000, 0x204441be, 0x500204e2, 0x7046455c, 0x180101d8, 0x38454066, 0x4803053a, 0x68474484, 0x0002126c, 0x204653d2, 0x5000168e, 0x70445730, 0x180313b4, 0x3847520a, 0x48011756, 0x684556e8}, - [16]uint32{0x3f800000, 0x3f902220, 0x3fa80102, 0x3fb82322, 0x3f8c0080, 0x3f9c22a0, 0x3fa40182, 0x3fb423a2, 0x3f800109, 0x3f902329, 0x3fa8000b, 0x3fb8222b, 0x3f8c0189, 0x3f9c23a9, 0x3fa4008b, 0x3fb422ab}, - uint32(0xfff80000), - [21]string{"0x72", "0xe8", "0x94", "0x01", "0x7c", "0xd8", "0x51", "0xed", "0xa5", "0xfb", "0xb8", "0x7b", "0x35", "0xc5", "0xa7", "0xaa", "0x1f", "0x3b", "0xb8", "0x2b", "0x00"}}, - { - /* No.349 delta:846 weight:1637 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0xe7441d0e, 0x0fc4362c, 0xe8802b22, 0xc44015df, 0x230408d1, 0xcb8423f3, 0x2cc03efd, 0x000008b0, 0xe74415be, 0x0fc43e9c, 0xe8802392, 0xc4401d6f, 0x23040061, 0xcb842b43, 0x2cc0364d}, - [16]uint32{0x00000000, 0x100330b2, 0x8001a194, 0x90029126, 0x5000dc15, 0x4003eca7, 0xd0017d81, 0xc0024d33, 0x4000140f, 0x500324bd, 0xc001b59b, 0xd0028529, 0x1000c81a, 0x0003f8a8, 0x9001698e, 0x8002593c}, - [16]uint32{0x3f800000, 0x3f880198, 0x3fc000d0, 0x3fc80148, 0x3fa8006e, 0x3fa001f6, 0x3fe800be, 0x3fe00126, 0x3fa0000a, 0x3fa80192, 0x3fe000da, 0x3fe80142, 0x3f880064, 0x3f8001fc, 0x3fc800b4, 0x3fc0012c}, - uint32(0xfff80000), - [21]string{"0x5c", "0xa1", "0x5f", "0x80", "0x8d", "0x97", "0x0a", "0xef", "0x81", "0xeb", "0x8f", "0x27", "0x82", "0xff", "0x97", "0x46", "0xab", "0xd8", "0xa0", "0xb6", "0x00"}}, - { - /* No.350 delta:2671 weight:847 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x697b76cd, 0xbc944c5f, 0xd5ef3a92, 0xa4b015e2, 0xcdcb632f, 0x182459bd, 0x715f2f70, 0x0000113d, 0x697b67f0, 0xbc945d62, 0xd5ef2baf, 0xa4b004df, 0xcdcb7212, 0x18244880, 0x715f3e4d}, - [16]uint32{0x00000000, 0x9604f13a, 0x0c4aa42b, 0x9a4e5511, 0x0b2c0417, 0x9d28f52d, 0x0766a03c, 0x91625106, 0x07142084, 0x9110d1be, 0x0b5e84af, 0x9d5a7595, 0x0c382493, 0x9a3cd5a9, 0x007280b8, 0x96767182}, - [16]uint32{0x3f800000, 0x3fcb0278, 0x3f862552, 0x3fcd272a, 0x3f859602, 0x3fce947a, 0x3f83b350, 0x3fc8b128, 0x3f838a10, 0x3fc88868, 0x3f85af42, 0x3fcead3a, 0x3f861c12, 0x3fcd1e6a, 0x3f803940, 0x3fcb3b38}, - uint32(0xfff80000), - [21]string{"0xf9", "0xc5", "0x41", "0xba", "0xb9", "0x62", "0xc3", "0x80", "0x73", "0xc1", "0xf6", "0xc6", "0x28", "0x01", "0x75", "0x10", "0x4a", "0x59", "0xaa", "0x76", "0x00"}}, - { - /* No.351 delta:884 weight:1701 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0xd5645896, 0x731c013c, 0xa67859aa, 0x162015f1, 0xc3444d67, 0x653c14cd, 0xb0584c5b, 0x00004a2c, 0xd56412ba, 0x731c4b10, 0xa6781386, 0x16205fdd, 0xc344074b, 0x653c5ee1, 0xb0580677}, - [16]uint32{0x00000000, 0x41424556, 0x70002053, 0x31426505, 0x3002c01e, 0x71408548, 0x4002e04d, 0x0140a51b, 0x20007219, 0x6142374f, 0x5000524a, 0x1142171c, 0x1002b207, 0x5140f751, 0x60029254, 0x2140d702}, - [16]uint32{0x3f800000, 0x3fa0a122, 0x3fb80010, 0x3f98a132, 0x3f980160, 0x3fb8a042, 0x3fa00170, 0x3f80a052, 0x3f900039, 0x3fb0a11b, 0x3fa80029, 0x3f88a10b, 0x3f880159, 0x3fa8a07b, 0x3fb00149, 0x3f90a06b}, - uint32(0xfff80000), - [21]string{"0x6e", "0x2b", "0xde", "0x14", "0x2d", "0xc6", "0x7c", "0x00", "0x5d", "0x85", "0xf5", "0xbd", "0x5a", "0xb3", "0x43", "0x8c", "0x46", "0xf2", "0x80", "0xa2", "0x00"}}, - { - /* No.352 delta:1012 weight:1759 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0x8d0371f4, 0x25227130, 0xa82100c4, 0xb8e0160d, 0x35e367f9, 0x9dc2673d, 0x10c116c9, 0x00003be5, 0x8d034a11, 0x25224ad5, 0xa8213b21, 0xb8e02de8, 0x35e35c1c, 0x9dc25cd8, 0x10c12d2c}, - [16]uint32{0x00000000, 0x102761be, 0x007611f1, 0x1051704f, 0x00484bfb, 0x106f2a45, 0x003e5a0a, 0x10193bb4, 0x48001806, 0x582779b8, 0x487609f7, 0x58516849, 0x484853fd, 0x586f3243, 0x483e420c, 0x581923b2}, - [16]uint32{0x3f800000, 0x3f8813b0, 0x3f803b08, 0x3f8828b8, 0x3f802425, 0x3f883795, 0x3f801f2d, 0x3f880c9d, 0x3fa4000c, 0x3fac13bc, 0x3fa43b04, 0x3fac28b4, 0x3fa42429, 0x3fac3799, 0x3fa41f21, 0x3fac0c91}, - uint32(0xfff80000), - [21]string{"0x14", "0x60", "0xb3", "0x50", "0x2c", "0x67", "0xc9", "0xec", "0x2a", "0x2b", "0xcf", "0xc2", "0x36", "0xbf", "0xe3", "0xbc", "0xe8", "0xa7", "0x8b", "0x14", "0x00"}}, - { - /* No.353 delta:865 weight:1537 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0xf28f5762, 0x10a3e4bb, 0xe22cb3d9, 0xa1b01610, 0x533f4172, 0xb113f2ab, 0x439ca5c9, 0x0000b547, 0xf28fe225, 0x10a351fc, 0xe22c069e, 0xa1b0a357, 0x533ff435, 0xb11347ec, 0x439c108e}, - [16]uint32{0x00000000, 0x502c0937, 0x1401c011, 0x442dc926, 0x00035008, 0x502f593f, 0x14029019, 0x442e992e, 0x5000020c, 0x002c0b3b, 0x4401c21d, 0x142dcb2a, 0x50035204, 0x002f5b33, 0x44029215, 0x142e9b22}, - [16]uint32{0x3f800000, 0x3fa81604, 0x3f8a00e0, 0x3fa216e4, 0x3f8001a8, 0x3fa817ac, 0x3f8a0148, 0x3fa2174c, 0x3fa80001, 0x3f801605, 0x3fa200e1, 0x3f8a16e5, 0x3fa801a9, 0x3f8017ad, 0x3fa20149, 0x3f8a174d}, - uint32(0xfff80000), - [21]string{"0x8b", "0x2a", "0x0c", "0xdc", "0x72", "0xbd", "0x5b", "0xbd", "0xce", "0x57", "0x2b", "0x56", "0xfe", "0x29", "0x1c", "0x90", "0xe2", "0x89", "0x78", "0x37", "0x00"}}, - { - /* No.354 delta:1086 weight:1395 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x2a73898b, 0x2bc778a1, 0x01b4f12a, 0xc0101625, 0xea639fae, 0xebd76e84, 0xc1a4e70f, 0x00005fa6, 0x2a73d62d, 0x2bc72707, 0x01b4ae8c, 0xc0104983, 0xea63c008, 0xebd73122, 0xc1a4b8a9}, - [16]uint32{0x00000000, 0x00548076, 0x6158a151, 0x610c2127, 0x0023f032, 0x00777044, 0x617b5163, 0x612fd115, 0x0003141c, 0x0057946a, 0x615bb54d, 0x610f353b, 0x0020e42e, 0x00746458, 0x6178457f, 0x612cc509}, - [16]uint32{0x3f800000, 0x3f802a40, 0x3fb0ac50, 0x3fb08610, 0x3f8011f8, 0x3f803bb8, 0x3fb0bda8, 0x3fb097e8, 0x3f80018a, 0x3f802bca, 0x3fb0adda, 0x3fb0879a, 0x3f801072, 0x3f803a32, 0x3fb0bc22, 0x3fb09662}, - uint32(0xfff80000), - [21]string{"0xc1", "0x4f", "0x6a", "0x0d", "0x5d", "0xd0", "0x28", "0xff", "0x27", "0x0d", "0x1c", "0xa0", "0xd3", "0x5d", "0xe6", "0x18", "0x2c", "0x28", "0x48", "0x32", "0x00"}}, - { - /* No.355 delta:860 weight:1565 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0xb757ab7c, 0x584f0020, 0xef18ab5c, 0x27201630, 0x9077bd4c, 0x7f6f1610, 0xc838bd6c, 0x0000df99, 0xb75774e5, 0x584fdfb9, 0xef1874c5, 0x2720c9a9, 0x907762d5, 0x7f6fc989, 0xc83862f5}, - [16]uint32{0x00000000, 0x1020605a, 0x700105ec, 0x602165b6, 0xe0001003, 0xf0207059, 0x900115ef, 0x802175b5, 0x6000001e, 0x70206044, 0x100105f2, 0x002165a8, 0x8000101d, 0x90207047, 0xf00115f1, 0xe02175ab}, - [16]uint32{0x3f800000, 0x3f881030, 0x3fb80082, 0x3fb010b2, 0x3ff00008, 0x3ff81038, 0x3fc8008a, 0x3fc010ba, 0x3fb00000, 0x3fb81030, 0x3f880082, 0x3f8010b2, 0x3fc00008, 0x3fc81038, 0x3ff8008a, 0x3ff010ba}, - uint32(0xfff80000), - [21]string{"0x34", "0x86", "0x19", "0x26", "0xaa", "0xfd", "0xd4", "0xd7", "0xa8", "0xb6", "0x9e", "0xb2", "0xcc", "0xd0", "0x06", "0xe7", "0xbf", "0x58", "0x55", "0x64", "0x00"}}, - { - /* No.356 delta:1005 weight:1725 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xe2ad09a9, 0x031bb3d5, 0xe1b6ba7c, 0xed301640, 0x0f9d1fe9, 0xee2ba595, 0x0c86ac3c, 0x00007c4a, 0xe2ad75e3, 0x031bcf9f, 0xe1b6c636, 0xed306a0a, 0x0f9d63a3, 0xee2bd9df, 0x0c86d076}, - [16]uint32{0x00000000, 0x507c185e, 0x300a0519, 0x60761d47, 0x100217eb, 0x407e0fb5, 0x200812f2, 0x70740aac, 0x1001021d, 0x407d1a43, 0x200b0704, 0x70771f5a, 0x000315f6, 0x507f0da8, 0x300910ef, 0x607508b1}, - [16]uint32{0x3f800000, 0x3fa83e0c, 0x3f980502, 0x3fb03b0e, 0x3f88010b, 0x3fa03f07, 0x3f900409, 0x3fb83a05, 0x3f880081, 0x3fa03e8d, 0x3f900583, 0x3fb83b8f, 0x3f80018a, 0x3fa83f86, 0x3f980488, 0x3fb03a84}, - uint32(0xfff80000), - [21]string{"0xe0", "0x2a", "0xe4", "0x2c", "0xf9", "0xbe", "0x0e", "0xec", "0x9d", "0x4a", "0x95", "0x02", "0x1e", "0x7d", "0x34", "0x1d", "0x1f", "0xc5", "0xe7", "0x34", "0x00"}}, - { - /* No.357 delta:1742 weight:1501 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0xa0a72c62, 0x05e61d1e, 0xa541317c, 0x67d01659, 0xc7773a3b, 0x62360b47, 0xc2912725, 0x0000957f, 0xa0a7b91d, 0x05e68861, 0xa541a403, 0x67d08326, 0xc777af44, 0x62369e38, 0xc291b25a}, - [16]uint32{0x00000000, 0x281150de, 0x404c418a, 0x685d1154, 0x080d040b, 0x201c54d5, 0x48414581, 0x6050155f, 0x90e041c6, 0xb8f11118, 0xd0ac004c, 0xf8bd5092, 0x98ed45cd, 0xb0fc1513, 0xd8a10447, 0xf0b05499}, - [16]uint32{0x3f800000, 0x3f9408a8, 0x3fa02620, 0x3fb42e88, 0x3f840682, 0x3f900e2a, 0x3fa420a2, 0x3fb0280a, 0x3fc87020, 0x3fdc7888, 0x3fe85600, 0x3ffc5ea8, 0x3fcc76a2, 0x3fd87e0a, 0x3fec5082, 0x3ff8582a}, - uint32(0xfff80000), - [21]string{"0x85", "0xbb", "0xe2", "0x15", "0x0a", "0xf7", "0x0d", "0xd8", "0x7b", "0x9c", "0x37", "0x41", "0x74", "0x35", "0x37", "0xb4", "0xf8", "0x43", "0x55", "0xb0", "0x00"}}, - { - /* No.358 delta:917 weight:1591 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0xf655e780, 0xce108c27, 0x38456ba7, 0xf8a0166d, 0x0ef5f1ed, 0x36b09a4a, 0xc0e57dca, 0x00009a4a, 0xf6557dca, 0xce10166d, 0x3845f1ed, 0xf8a08c27, 0x0ef56ba7, 0x36b00000, 0xc0e5e780}, - [16]uint32{0x00000000, 0x007413fa, 0x000a0c19, 0x007e1fe3, 0x0011081f, 0x00651be5, 0x001b0406, 0x006f17fc, 0x4030a0f2, 0x4044b308, 0x403aaceb, 0x404ebf11, 0x4021a8ed, 0x4055bb17, 0x402ba4f4, 0x405fb70e}, - [16]uint32{0x3f800000, 0x3f803a09, 0x3f800506, 0x3f803f0f, 0x3f800884, 0x3f80328d, 0x3f800d82, 0x3f80378b, 0x3fa01850, 0x3fa02259, 0x3fa01d56, 0x3fa0275f, 0x3fa010d4, 0x3fa02add, 0x3fa015d2, 0x3fa02fdb}, - uint32(0xfff80000), - [21]string{"0x4a", "0x7e", "0x0d", "0x83", "0xdc", "0xd9", "0x45", "0xd7", "0xd7", "0xea", "0xfa", "0x38", "0xae", "0xc1", "0xed", "0x09", "0x5d", "0xf8", "0x6e", "0x1c", "0x00"}}, - { - /* No.359 delta:988 weight:1719 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0x39ff8e1e, 0x052720a1, 0x3cd8aebf, 0xca501672, 0xf3af986c, 0xcf7736d3, 0xf688b8cd, 0x00001f50, 0x39ff914e, 0x05273ff1, 0x3cd8b1ef, 0xca500922, 0xf3af873c, 0xcf772983, 0xf688a79d}, - [16]uint32{0x00000000, 0x602c709a, 0x101a202f, 0x703650b5, 0x0064c159, 0x6048b1c3, 0x107ee176, 0x705291ec, 0x0003c801, 0x602fb89b, 0x1019e82e, 0x703598b4, 0x00670958, 0x604b79c2, 0x107d2977, 0x705159ed}, - [16]uint32{0x3f800000, 0x3fb01638, 0x3f880d10, 0x3fb81b28, 0x3f803260, 0x3fb02458, 0x3f883f70, 0x3fb82948, 0x3f8001e4, 0x3fb017dc, 0x3f880cf4, 0x3fb81acc, 0x3f803384, 0x3fb025bc, 0x3f883e94, 0x3fb828ac}, - uint32(0xfff80000), - [21]string{"0x6f", "0x5b", "0x81", "0x0e", "0x88", "0xf9", "0x5d", "0x76", "0x87", "0x44", "0xb2", "0x5a", "0xd9", "0x1e", "0x0c", "0x85", "0x4a", "0xa6", "0xa6", "0x50", "0x00"}}, - { - /* No.360 delta:1132 weight:1663 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xde530426, 0x95ff5ef7, 0x4bac5ad1, 0xd1f01682, 0x0fa312a4, 0x440f4875, 0x9a5c4c53, 0x0000dea0, 0xde53da86, 0x95ff8057, 0x4bac8471, 0xd1f0c822, 0x0fa3cc04, 0x440f96d5, 0x9a5c92f3}, - [16]uint32{0x00000000, 0x0044015c, 0x00330035, 0x00770169, 0x21b9c1a2, 0x21fdc0fe, 0x218ac197, 0x21cec0cb, 0x0020301d, 0x00643141, 0x00133028, 0x00573174, 0x2199f1bf, 0x21ddf0e3, 0x21aaf18a, 0x21eef0d6}, - [16]uint32{0x3f800000, 0x3f802200, 0x3f801980, 0x3f803b80, 0x3f90dce0, 0x3f90fee0, 0x3f90c560, 0x3f90e760, 0x3f801018, 0x3f803218, 0x3f800998, 0x3f802b98, 0x3f90ccf8, 0x3f90eef8, 0x3f90d578, 0x3f90f778}, - uint32(0xfff80000), - [21]string{"0xe4", "0xa2", "0x91", "0x75", "0x75", "0x5f", "0x6f", "0xcc", "0x85", "0x64", "0x78", "0xdd", "0x14", "0x7e", "0xcc", "0x18", "0xf4", "0x0c", "0x08", "0xe3", "0x00"}}, - { - /* No.361 delta:769 weight:1621 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0x78161af6, 0x17c5d7ee, 0x6fd3cd18, 0x78f0169b, 0x00e60c6d, 0x6f35c175, 0x1723db83, 0x00000185, 0x78161b73, 0x17c5d66b, 0x6fd3cc9d, 0x78f0171e, 0x00e60de8, 0x6f35c0f0, 0x1723da06}, - [16]uint32{0x00000000, 0x300d07b6, 0x0021ca1a, 0x302ccdac, 0x70001f45, 0x400d18f3, 0x7021d55f, 0x402cd2e9, 0x20001194, 0x100d1622, 0x2021db8e, 0x102cdc38, 0x50000ed1, 0x600d0967, 0x5021c4cb, 0x602cc37d}, - [16]uint32{0x3f800000, 0x3f980683, 0x3f8010e5, 0x3f981666, 0x3fb8000f, 0x3fa0068c, 0x3fb810ea, 0x3fa01669, 0x3f900008, 0x3f88068b, 0x3f9010ed, 0x3f88166e, 0x3fa80007, 0x3fb00684, 0x3fa810e2, 0x3fb01661}, - uint32(0xfff80000), - [21]string{"0x10", "0x6d", "0x31", "0xe8", "0x2c", "0xfe", "0x25", "0xff", "0xd4", "0xc5", "0x51", "0x0b", "0x5a", "0xb8", "0x88", "0xb6", "0x5f", "0x91", "0xe3", "0xa1", "0x00"}}, - { - /* No.362 delta:721 weight:1605 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0x4a126c87, 0x2c51b2ae, 0x6643de29, 0xe29016af, 0xa8827a28, 0xcec1a401, 0x84d3c886, 0x0000d2fd, 0x4a12be7a, 0x2c516053, 0x66430cd4, 0xe290c452, 0xa882a8d5, 0xcec176fc, 0x84d31a7b}, - [16]uint32{0x00000000, 0x0874707f, 0x0063cc03, 0x0817bc7c, 0x101820da, 0x186c50a5, 0x107becd9, 0x180f9ca6, 0x00110011, 0x0865706e, 0x0072cc12, 0x0806bc6d, 0x100920cb, 0x187d50b4, 0x106aecc8, 0x181e9cb7}, - [16]uint32{0x3f800000, 0x3f843a38, 0x3f8031e6, 0x3f840bde, 0x3f880c10, 0x3f8c3628, 0x3f883df6, 0x3f8c07ce, 0x3f800880, 0x3f8432b8, 0x3f803966, 0x3f84035e, 0x3f880490, 0x3f8c3ea8, 0x3f883576, 0x3f8c0f4e}, - uint32(0xfff80000), - [21]string{"0xc6", "0x3f", "0x57", "0xc9", "0x84", "0x7a", "0xfe", "0x04", "0xa0", "0x91", "0xba", "0xea", "0xb4", "0xec", "0x03", "0x62", "0x0a", "0x8b", "0xb5", "0x90", "0x00"}}, - { - /* No.363 delta:909 weight:957 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x03661a42, 0x87294fa0, 0x844f55e2, 0x87b016b1, 0x84d60cf3, 0x00995911, 0x03ff4353, 0x00006897, 0x036672d5, 0x87292737, 0x844f3d75, 0x87b07e26, 0x84d66464, 0x00993186, 0x03ff2bc4}, - [16]uint32{0x00000000, 0x101602db, 0x0201841c, 0x121786c7, 0x00405013, 0x105652c8, 0x0241d40f, 0x1257d6d4, 0x10020016, 0x001402cd, 0x1203840a, 0x021586d1, 0x10425005, 0x005452de, 0x1243d419, 0x0255d6c2}, - [16]uint32{0x3f800000, 0x3f880b01, 0x3f8100c2, 0x3f890bc3, 0x3f802028, 0x3f882b29, 0x3f8120ea, 0x3f892beb, 0x3f880100, 0x3f800a01, 0x3f8901c2, 0x3f810ac3, 0x3f882128, 0x3f802a29, 0x3f8921ea, 0x3f812aeb}, - uint32(0xfff80000), - [21]string{"0x7a", "0x5d", "0xdd", "0x4b", "0xea", "0x67", "0x23", "0x48", "0xe6", "0xf0", "0x1d", "0x7d", "0x70", "0xc2", "0xb6", "0x1a", "0x1f", "0x0b", "0x6e", "0x1c", "0x00"}}, - { - /* No.364 delta:1121 weight:1379 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xf75fa322, 0x25af2d0a, 0xd2f08e28, 0x9b1016c8, 0x6c4fb5ea, 0xbebf3bc2, 0x49e098e0, 0x00002571, 0xf75f8653, 0x25af087b, 0xd2f0ab59, 0x9b1033b9, 0x6c4f909b, 0xbebf1eb3, 0x49e0bd91}, - [16]uint32{0x00000000, 0x4846b97e, 0x600400f4, 0x2842b98a, 0x0040a16b, 0x48061815, 0x6044a19f, 0x280218e1, 0x00036218, 0x4845db66, 0x600762ec, 0x2841db92, 0x0043c373, 0x48057a0d, 0x6047c387, 0x28017af9}, - [16]uint32{0x3f800000, 0x3fa4235c, 0x3fb00200, 0x3f94215c, 0x3f802050, 0x3fa4030c, 0x3fb02250, 0x3f94010c, 0x3f8001b1, 0x3fa422ed, 0x3fb003b1, 0x3f9420ed, 0x3f8021e1, 0x3fa402bd, 0x3fb023e1, 0x3f9400bd}, - uint32(0xfff80000), - [21]string{"0x1d", "0x8e", "0x0a", "0xda", "0xaf", "0x74", "0xe0", "0xed", "0x73", "0xff", "0xd0", "0x1e", "0x9c", "0x74", "0x10", "0xfa", "0x70", "0x03", "0x50", "0x44", "0x00"}}, - { - /* No.365 delta:746 weight:1697 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0xe80f1cc0, 0xd0da24f8, 0x38d53838, 0xffc016dd, 0x17cf0a1d, 0x2f1a3225, 0xc7152ee5, 0x00002907, 0xe80f35c7, 0xd0da0dff, 0x38d5113f, 0xffc03fda, 0x17cf231a, 0x2f1a1b22, 0xc71507e2}, - [16]uint32{0x00000000, 0x006e5c92, 0x00021394, 0x006c4f06, 0x20b0b138, 0x20deedaa, 0x20b2a2ac, 0x20dcfe3e, 0x00102091, 0x007e7c03, 0x00123305, 0x007c6f97, 0x20a091a9, 0x20cecd3b, 0x20a2823d, 0x20ccdeaf}, - [16]uint32{0x3f800000, 0x3f80372e, 0x3f800109, 0x3f803627, 0x3f905858, 0x3f906f76, 0x3f905951, 0x3f906e7f, 0x3f800810, 0x3f803f3e, 0x3f800919, 0x3f803e37, 0x3f905048, 0x3f906766, 0x3f905141, 0x3f90666f}, - uint32(0xfff80000), - [21]string{"0xb9", "0xf4", "0x84", "0x25", "0xe9", "0xaf", "0xca", "0xa9", "0x05", "0x9e", "0x09", "0xdf", "0xc1", "0xc2", "0xff", "0x5d", "0x9c", "0xec", "0x16", "0xec", "0x00"}}, - { - /* No.366 delta:1013 weight:1599 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0x240769b0, 0xadd4325d, 0x89d35bed, 0xe4b016e0, 0xc0b77f50, 0x496424bd, 0x6d634d0d, 0x000021ea, 0x2407485a, 0xadd413b7, 0x89d37a07, 0xe4b0370a, 0xc0b75eba, 0x49640557, 0x6d636ce7}, - [16]uint32{0x00000000, 0x004ca13c, 0x2918de15, 0x29547f29, 0x00353076, 0x0079914a, 0x292dee63, 0x29614f5f, 0x0004f0de, 0x004851e2, 0x291c2ecb, 0x29508ff7, 0x0031c0a8, 0x007d6194, 0x29291ebd, 0x2965bf81}, - [16]uint32{0x3f800000, 0x3f802650, 0x3f948c6f, 0x3f94aa3f, 0x3f801a98, 0x3f803cc8, 0x3f9496f7, 0x3f94b0a7, 0x3f800278, 0x3f802428, 0x3f948e17, 0x3f94a847, 0x3f8018e0, 0x3f803eb0, 0x3f94948f, 0x3f94b2df}, - uint32(0xfff80000), - [21]string{"0xb8", "0x5b", "0x3b", "0x53", "0xa9", "0x4b", "0x2d", "0x9b", "0x80", "0x3f", "0x17", "0x1b", "0x48", "0xc0", "0xcd", "0x5a", "0xb6", "0x7d", "0x93", "0x54", "0x00"}}, - { - /* No.367 delta:1230 weight:1517 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x570b7517, 0x07ae9069, 0x50a5e57e, 0x143016fc, 0x433b63eb, 0x139e8695, 0x4495f382, 0x0000f479, 0x570b816e, 0x07ae6410, 0x50a51107, 0x1430e285, 0x433b9792, 0x139e72ec, 0x449507fb}, - [16]uint32{0x00000000, 0x005409be, 0x201a613c, 0x204e6882, 0x200b22a4, 0x205f2b1a, 0x00114398, 0x00454a26, 0x40000011, 0x405409af, 0x601a612d, 0x604e6893, 0x600b22b5, 0x605f2b0b, 0x40114389, 0x40454a37}, - [16]uint32{0x3f800000, 0x3f802a04, 0x3f900d30, 0x3f902734, 0x3f900591, 0x3f902f95, 0x3f8008a1, 0x3f8022a5, 0x3fa00000, 0x3fa02a04, 0x3fb00d30, 0x3fb02734, 0x3fb00591, 0x3fb02f95, 0x3fa008a1, 0x3fa022a5}, - uint32(0xfff80000), - [21]string{"0x51", "0x56", "0x7a", "0x39", "0xc7", "0xe7", "0x00", "0xdd", "0x43", "0x09", "0xc8", "0xa3", "0x0a", "0x02", "0x38", "0xfb", "0x23", "0x3a", "0xe0", "0xea", "0x00"}}, - { - /* No.368 delta:1742 weight:1575 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0xbbb1bd4d, 0x22f590fd, 0x99442db0, 0xe220170e, 0x5991aa43, 0xc0d587f3, 0x7b643abe, 0x00005856, 0xbbb1e51b, 0x22f5c8ab, 0x994475e6, 0xe2204f58, 0x5991f215, 0xc0d5dfa5, 0x7b6462e8}, - [16]uint32{0x00000000, 0x16287a36, 0x10744419, 0x065c3e2f, 0x0a02201d, 0x1c2a5a2b, 0x1a766404, 0x0c5e1e32, 0x020c0307, 0x14247931, 0x1278471e, 0x04503d28, 0x080e231a, 0x1e26592c, 0x187a6703, 0x0e521d35}, - [16]uint32{0x3f800000, 0x3f8b143d, 0x3f883a22, 0x3f832e1f, 0x3f850110, 0x3f8e152d, 0x3f8d3b32, 0x3f862f0f, 0x3f810601, 0x3f8a123c, 0x3f893c23, 0x3f82281e, 0x3f840711, 0x3f8f132c, 0x3f8c3d33, 0x3f87290e}, - uint32(0xfff80000), - [21]string{"0xa1", "0x4d", "0xf4", "0x27", "0x3c", "0x05", "0x11", "0x88", "0x1e", "0x46", "0xa9", "0x99", "0x67", "0xbc", "0x85", "0xbf", "0x28", "0x84", "0x2e", "0x5c", "0x00"}}, - { - /* No.369 delta:726 weight:1493 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xc95e3084, 0xc197c8f4, 0x08c9f870, 0x1ba01716, 0xd2fe2792, 0xda37dfe2, 0x1369ef66, 0x000044e4, 0xc95e7460, 0xc1978c10, 0x08c9bc94, 0x1ba053f2, 0xd2fe6376, 0xda379b06, 0x1369ab82}, - [16]uint32{0x00000000, 0x10220dfd, 0x2041f206, 0x3063fffb, 0x00028011, 0x10208dec, 0x20437217, 0x30617fea, 0x20080e74, 0x302a0389, 0x0049fc72, 0x106bf18f, 0x200a8e65, 0x30288398, 0x004b7c63, 0x1069719e}, - [16]uint32{0x3f800000, 0x3f881106, 0x3f9020f9, 0x3f9831ff, 0x3f800140, 0x3f881046, 0x3f9021b9, 0x3f9830bf, 0x3f900407, 0x3f981501, 0x3f8024fe, 0x3f8835f8, 0x3f900547, 0x3f981441, 0x3f8025be, 0x3f8834b8}, - uint32(0xfff80000), - [21]string{"0xab", "0xeb", "0x3a", "0x5e", "0x71", "0xac", "0x42", "0xdc", "0x1f", "0x31", "0x75", "0xad", "0xa3", "0x48", "0x3e", "0x93", "0xe1", "0xac", "0xf7", "0x8e", "0x00"}}, - { - /* No.370 delta:1803 weight:1429 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0xce97c038, 0xe6b97d49, 0x282ebd71, 0x82901720, 0x4c07d718, 0x64296a69, 0xaabeaa51, 0x0000a04b, 0xce976073, 0xe6b9dd02, 0x282e1d3a, 0x8290b76b, 0x4c077753, 0x6429ca22, 0xaabe0a1a}, - [16]uint32{0x00000000, 0x0d698b3e, 0x02424bf5, 0x0f2bc0cb, 0x00c013b9, 0x0da99887, 0x0282584c, 0x0febd372, 0x00520378, 0x0d3b8846, 0x0210488d, 0x0f79c3b3, 0x009210c1, 0x0dfb9bff, 0x02d05b34, 0x0fb9d00a}, - [16]uint32{0x3f800000, 0x3f86b4c5, 0x3f812125, 0x3f8795e0, 0x3f806009, 0x3f86d4cc, 0x3f81412c, 0x3f87f5e9, 0x3f802901, 0x3f869dc4, 0x3f810824, 0x3f87bce1, 0x3f804908, 0x3f86fdcd, 0x3f81682d, 0x3f87dce8}, - uint32(0xfff80000), - [21]string{"0x62", "0x9e", "0x2a", "0xf0", "0xed", "0xa4", "0x3b", "0x1b", "0x80", "0xbf", "0xea", "0x22", "0x10", "0x9b", "0xb1", "0xae", "0x96", "0xc1", "0xb4", "0x25", "0x00"}}, - { - /* No.371 delta:909 weight:1601 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x92531619, 0x1b699f68, 0x893a8971, 0xef301737, 0x7d63012e, 0xf459885f, 0x660a9e46, 0x000088cc, 0x92539ed5, 0x1b6917a4, 0x893a01bd, 0xef309ffb, 0x7d6389e2, 0xf4590093, 0x660a168a}, - [16]uint32{0x00000000, 0x40556436, 0x604e63cf, 0x201b07f9, 0x1002001d, 0x5057642b, 0x704c63d2, 0x301907e4, 0x0003841a, 0x4056e02c, 0x604de7d5, 0x201883e3, 0x10018407, 0x5054e031, 0x704fe7c8, 0x301a83fe}, - [16]uint32{0x3f800000, 0x3fa02ab2, 0x3fb02731, 0x3f900d83, 0x3f880100, 0x3fa82bb2, 0x3fb82631, 0x3f980c83, 0x3f8001c2, 0x3fa02b70, 0x3fb026f3, 0x3f900c41, 0x3f8800c2, 0x3fa82a70, 0x3fb827f3, 0x3f980d41}, - uint32(0xfff80000), - [21]string{"0xab", "0xcb", "0x82", "0x30", "0xa8", "0xd3", "0x6a", "0xa1", "0x5b", "0xdf", "0x89", "0xb8", "0x21", "0xa0", "0xba", "0x8f", "0xe8", "0xd6", "0xd2", "0x8d", "0x00"}}, - { - /* No.372 delta:1110 weight:1457 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x9ea2eb89, 0x9a5249dc, 0x04f0a255, 0x84c0174f, 0x1a62fcc6, 0x1e925e93, 0x8030b51a, 0x00000697, 0x9ea2ed1e, 0x9a524f4b, 0x04f0a4c2, 0x84c011d8, 0x1a62fa51, 0x1e925804, 0x8030b38d}, - [16]uint32{0x00000000, 0x107d1296, 0x010344fa, 0x117e566c, 0x0002b9f3, 0x107fab65, 0x0101fd09, 0x117cef9f, 0x50032807, 0x407e3a91, 0x51006cfd, 0x417d7e6b, 0x500191f4, 0x407c8362, 0x5102d50e, 0x417fc798}, - [16]uint32{0x3f800000, 0x3f883e89, 0x3f8081a2, 0x3f88bf2b, 0x3f80015c, 0x3f883fd5, 0x3f8080fe, 0x3f88be77, 0x3fa80194, 0x3fa03f1d, 0x3fa88036, 0x3fa0bebf, 0x3fa800c8, 0x3fa03e41, 0x3fa8816a, 0x3fa0bfe3}, - uint32(0xfff80000), - [21]string{"0x15", "0x2e", "0x1b", "0x3e", "0x9b", "0xda", "0x1c", "0xff", "0x98", "0x29", "0xb1", "0x7e", "0xf5", "0x47", "0x1c", "0xbc", "0x67", "0x3b", "0xd0", "0x4a", "0x00"}}, - { - /* No.373 delta:890 weight:725 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0xf453124c, 0x9133123d, 0x65600071, 0x6d601757, 0x9933051b, 0xfc53056a, 0x08001726, 0x00000732, 0xf453157e, 0x9133150f, 0x65600743, 0x6d601065, 0x99330229, 0xfc530258, 0x08001014}, - [16]uint32{0x00000000, 0x002f04d5, 0x440d9817, 0x44229cc2, 0x0049b01f, 0x0066b4ca, 0x44442808, 0x446b2cdd, 0x200c8013, 0x202384c6, 0x64011804, 0x642e1cd1, 0x2045300c, 0x206a34d9, 0x6448a81b, 0x6467acce}, - [16]uint32{0x3f800000, 0x3f801782, 0x3fa206cc, 0x3fa2114e, 0x3f8024d8, 0x3f80335a, 0x3fa22214, 0x3fa23596, 0x3f900640, 0x3f9011c2, 0x3fb2008c, 0x3fb2170e, 0x3f902298, 0x3f90351a, 0x3fb22454, 0x3fb233d6}, - uint32(0xfff80000), - [21]string{"0x23", "0x25", "0x32", "0x61", "0x6d", "0x7c", "0xe0", "0x06", "0x40", "0x4b", "0x1c", "0x66", "0x52", "0x30", "0x1f", "0xee", "0xa1", "0x54", "0xc1", "0xab", "0x00"}}, - { - /* No.374 delta:919 weight:915 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0x9e5812ea, 0xe62fe6ba, 0x7877f450, 0x30c0176d, 0xae980587, 0xd6eff1d7, 0x48b7e33d, 0x00002e3e, 0x9e583cd4, 0xe62fc884, 0x7877da6e, 0x30c03953, 0xae982bb9, 0xd6efdfe9, 0x48b7cd03}, - [16]uint32{0x00000000, 0x0077909a, 0x400a8817, 0x407d188d, 0x4000e41f, 0x40777485, 0x000a6c08, 0x007dfc92, 0x404311c6, 0x4034815c, 0x004999d1, 0x003e094b, 0x0043f5d9, 0x00346543, 0x40497dce, 0x403eed54}, - [16]uint32{0x3f800000, 0x3f803bc8, 0x3fa00544, 0x3fa03e8c, 0x3fa00072, 0x3fa03bba, 0x3f800536, 0x3f803efe, 0x3fa02188, 0x3fa01a40, 0x3f8024cc, 0x3f801f04, 0x3f8021fa, 0x3f801a32, 0x3fa024be, 0x3fa01f76}, - uint32(0xfff80000), - [21]string{"0x6f", "0x7d", "0xf0", "0x37", "0xf9", "0x32", "0xc2", "0x38", "0x87", "0x2f", "0xac", "0xd8", "0xea", "0x5e", "0xcc", "0x2a", "0x14", "0xb2", "0x55", "0xcc", "0x00"}}, - { - /* No.375 delta:1049 weight:1571 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0x04209f4c, 0x6f150bce, 0x6b359482, 0xdb501770, 0xdf70883c, 0xb4451cbe, 0xb06583f2, 0x000010de, 0x04208f92, 0x6f151b10, 0x6b35845c, 0xdb5007ae, 0xdf7098e2, 0xb4450c60, 0xb065932c}, - [16]uint32{0x00000000, 0x6065e433, 0x0002881a, 0x60676c29, 0x70e108e2, 0x1084ecd1, 0x70e380f8, 0x108664cb, 0x0109621b, 0x616c8628, 0x010bea01, 0x616e0e32, 0x71e86af9, 0x118d8eca, 0x71eae2e3, 0x118f06d0}, - [16]uint32{0x3f800000, 0x3fb032f2, 0x3f800144, 0x3fb033b6, 0x3fb87084, 0x3f884276, 0x3fb871c0, 0x3f884332, 0x3f8084b1, 0x3fb0b643, 0x3f8085f5, 0x3fb0b707, 0x3fb8f435, 0x3f88c6c7, 0x3fb8f571, 0x3f88c783}, - uint32(0xfff80000), - [21]string{"0x35", "0x60", "0x49", "0xb8", "0x2a", "0x1d", "0x72", "0x07", "0x1f", "0xe0", "0x0d", "0x14", "0xc1", "0xb7", "0x9d", "0x98", "0x9e", "0x0d", "0x5b", "0xd0", "0x00"}}, - { - /* No.376 delta:944 weight:1451 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0xbc72f163, 0x2dfbf47d, 0x9189051e, 0xb1b0178e, 0x0dc2e6ed, 0x9c4be3f3, 0x20391290, 0x0000b3b4, 0xbc7242d7, 0x2dfb47c9, 0x9189b6aa, 0xb1b0a43a, 0x0dc25559, 0x9c4b5047, 0x2039a124}, - [16]uint32{0x00000000, 0x10560972, 0x04086049, 0x145e693b, 0x30042016, 0x20522964, 0x340c405f, 0x245a492d, 0x0002140c, 0x10541d7e, 0x040a7445, 0x145c7d37, 0x3006341a, 0x20503d68, 0x340e5453, 0x24585d21}, - [16]uint32{0x3f800000, 0x3f882b04, 0x3f820430, 0x3f8a2f34, 0x3f980210, 0x3f902914, 0x3f9a0620, 0x3f922d24, 0x3f80010a, 0x3f882a0e, 0x3f82053a, 0x3f8a2e3e, 0x3f98031a, 0x3f90281e, 0x3f9a072a, 0x3f922c2e}, - uint32(0xfff80000), - [21]string{"0xd0", "0xf5", "0x67", "0x95", "0x9d", "0x13", "0xd7", "0x1d", "0xe7", "0xaa", "0xf3", "0xf9", "0xa9", "0x7f", "0x6d", "0x0a", "0x13", "0xc4", "0xc6", "0x41", "0x00"}}, - { - /* No.377 delta:1088 weight:1285 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x5cc92a03, 0x05adcc7e, 0x5964e67d, 0x84f0179f, 0xd8393d9c, 0x815ddbe1, 0xdd94f1e2, 0x000074d7, 0x5cc95ed4, 0x05adb8a9, 0x596492aa, 0x84f06348, 0xd839494b, 0x815daf36, 0xdd948535}, - [16]uint32{0x00000000, 0x007d1db6, 0x80603213, 0x801d2fa5, 0x00021409, 0x007f09bf, 0x8062261a, 0x801f3bac, 0x00034808, 0x007e55be, 0x80637a1b, 0x801e67ad, 0x00015c01, 0x007c41b7, 0x80616e12, 0x801c73a4}, - [16]uint32{0x3f800000, 0x3f803e8e, 0x3fc03019, 0x3fc00e97, 0x3f80010a, 0x3f803f84, 0x3fc03113, 0x3fc00f9d, 0x3f8001a4, 0x3f803f2a, 0x3fc031bd, 0x3fc00f33, 0x3f8000ae, 0x3f803e20, 0x3fc030b7, 0x3fc00e39}, - uint32(0xfff80000), - [21]string{"0x31", "0xac", "0x55", "0xef", "0xb3", "0x54", "0x1b", "0x51", "0xe0", "0x64", "0xc0", "0xcc", "0x09", "0x1f", "0x95", "0xb6", "0x75", "0x9e", "0x9f", "0x3a", "0x00"}}, - { - /* No.378 delta:824 weight:729 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0xf4f93c6a, 0x8692c625, 0x726bfa4f, 0x29e017a1, 0xdd192bcb, 0xaf72d184, 0x5b8bedee, 0x0000a26b, 0xf4f99e01, 0x8692644e, 0x726b5824, 0x29e0b5ca, 0xdd1989a0, 0xaf7273ef, 0x5b8b4f85}, - [16]uint32{0x00000000, 0x503005de, 0x087d481c, 0x584d4dc2, 0x0068340b, 0x505831d5, 0x08157c17, 0x582579c9, 0x48000013, 0x183005cd, 0x407d480f, 0x104d4dd1, 0x48683418, 0x185831c6, 0x40157c04, 0x102579da}, - [16]uint32{0x3f800000, 0x3fa81802, 0x3f843ea4, 0x3fac26a6, 0x3f80341a, 0x3fa82c18, 0x3f840abe, 0x3fac12bc, 0x3fa40000, 0x3f8c1802, 0x3fa03ea4, 0x3f8826a6, 0x3fa4341a, 0x3f8c2c18, 0x3fa00abe, 0x3f8812bc}, - uint32(0xfff80000), - [21]string{"0x31", "0x0d", "0x9b", "0x5d", "0xb9", "0xe2", "0xc6", "0x14", "0xa1", "0x82", "0x69", "0x5e", "0xb0", "0xd0", "0x2a", "0xf8", "0x03", "0x22", "0x85", "0xff", "0x00"}}, - { - /* No.379 delta:2050 weight:1585 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x9952c50d, 0xedce1744, 0x749cd249, 0x08c017b5, 0x9192d2b8, 0xe50e00f1, 0x7c5cc5fc, 0x00003690, 0x9952f39d, 0xedce21d4, 0x749ce4d9, 0x08c02125, 0x9192e428, 0xe50e3661, 0x7c5cf36c}, - [16]uint32{0x00000000, 0x405ce3d3, 0x00520074, 0x400ee3a7, 0x00280196, 0x4074e245, 0x007a01e2, 0x4026e231, 0x741001bd, 0x344ce26e, 0x744201c9, 0x341ee21a, 0x7438002b, 0x3464e3f8, 0x746a005f, 0x3436e38c}, - [16]uint32{0x3f800000, 0x3fa02e71, 0x3f802900, 0x3fa00771, 0x3f801400, 0x3fa03a71, 0x3f803d00, 0x3fa01371, 0x3fba0800, 0x3f9a2671, 0x3fba2100, 0x3f9a0f71, 0x3fba1c00, 0x3f9a3271, 0x3fba3500, 0x3f9a1b71}, - uint32(0xfff80000), - [21]string{"0xcb", "0x23", "0x2d", "0xee", "0x59", "0x7d", "0xc7", "0x51", "0x3a", "0x51", "0x5c", "0xa9", "0xa0", "0x85", "0xac", "0xc6", "0x53", "0xf4", "0xd9", "0x8f", "0x00"}}, - { - /* No.380 delta:734 weight:755 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x3a4dd5b2, 0x9f753afe, 0xa538ef4c, 0x6d4017c6, 0x570dc274, 0xf2352d38, 0xc878f88a, 0x00003f8f, 0x3a4dea3d, 0x9f750571, 0xa538d0c3, 0x6d402849, 0x570dfdfb, 0xf23512b7, 0xc878c705}, - [16]uint32{0x00000000, 0x41e8019a, 0x51420043, 0x10aa01d9, 0x0c11a13c, 0x4df9a0a6, 0x5d53a17f, 0x1cbba0e5, 0x0144a217, 0x40aca38d, 0x5006a254, 0x11eea3ce, 0x0d55032b, 0x4cbd02b1, 0x5c170368, 0x1dff02f2}, - [16]uint32{0x3f800000, 0x3fa0f400, 0x3fa8a100, 0x3f885500, 0x3f8608d0, 0x3fa6fcd0, 0x3faea9d0, 0x3f8e5dd0, 0x3f80a251, 0x3fa05651, 0x3fa80351, 0x3f88f751, 0x3f86aa81, 0x3fa65e81, 0x3fae0b81, 0x3f8eff81}, - uint32(0xfff80000), - [21]string{"0x02", "0x93", "0x13", "0xd2", "0x2d", "0xc3", "0xcf", "0xcb", "0x72", "0x8d", "0xed", "0x7d", "0x79", "0x71", "0x4c", "0x5d", "0xf2", "0x35", "0x52", "0xc4", "0x00"}}, - { - /* No.381 delta:695 weight:1327 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0x4a2d336a, 0xcbcd0b4d, 0x81e03827, 0x3c4017d2, 0x766d24b8, 0xf78d1c9f, 0xbda02ff5, 0x00003940, 0x4a2d0a2a, 0xcbcd320d, 0x81e00167, 0x3c402e92, 0x766d1df8, 0xf78d25df, 0xbda016b5}, - [16]uint32{0x00000000, 0x406c491f, 0x0018165c, 0x40745f43, 0x5a8c40bd, 0x1ae009a2, 0x5a9456e1, 0x1af81ffe, 0x40080196, 0x00644889, 0x401017ca, 0x007c5ed5, 0x1a84412b, 0x5ae80834, 0x1a9c5777, 0x5af01e68}, - [16]uint32{0x3f800000, 0x3fa03624, 0x3f800c0b, 0x3fa03a2f, 0x3fad4620, 0x3f8d7004, 0x3fad4a2b, 0x3f8d7c0f, 0x3fa00400, 0x3f803224, 0x3fa0080b, 0x3f803e2f, 0x3f8d4220, 0x3fad7404, 0x3f8d4e2b, 0x3fad780f}, - uint32(0xfff80000), - [21]string{"0x68", "0xc4", "0x49", "0x1c", "0x51", "0x0b", "0xd4", "0xe5", "0xf4", "0xe0", "0x12", "0xf8", "0xfa", "0xd2", "0x93", "0x37", "0x42", "0x7a", "0x25", "0x28", "0x00"}}, - { - /* No.382 delta:1075 weight:1435 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0xb1b67f06, 0x407a2626, 0xf1cc5920, 0xf21017e8, 0x43a668ee, 0xb26a31ce, 0x03dc4ec8, 0x00004cda, 0xb1b633dc, 0x407a6afc, 0xf1cc15fa, 0xf2105b32, 0x43a62434, 0xb26a7d14, 0x03dc0212}, - [16]uint32{0x00000000, 0x004611bb, 0x2002c02d, 0x2044d196, 0x20032074, 0x204531cf, 0x0001e059, 0x0047f1e2, 0x0002109e, 0x00440125, 0x2000d0b3, 0x2046c108, 0x200130ea, 0x20472151, 0x0003f0c7, 0x0045e17c}, - [16]uint32{0x3f800000, 0x3f802308, 0x3f900160, 0x3f902268, 0x3f900190, 0x3f902298, 0x3f8000f0, 0x3f8023f8, 0x3f800108, 0x3f802200, 0x3f900068, 0x3f902360, 0x3f900098, 0x3f902390, 0x3f8001f8, 0x3f8022f0}, - uint32(0xfff80000), - [21]string{"0x19", "0xfc", "0x70", "0xab", "0x75", "0x6b", "0x2f", "0xe6", "0x9d", "0xe6", "0xda", "0xd0", "0xf4", "0x08", "0xd7", "0xb2", "0xc5", "0xfa", "0xbc", "0xe7", "0x00"}}, - { - /* No.383 delta:1078 weight:1421 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x9ea2eb89, 0x9a5249dc, 0x04f0a255, 0x84c017ff, 0x1a62fc76, 0x1e925e23, 0x8030b5aa, 0x00000697, 0x9ea2ed1e, 0x9a524f4b, 0x04f0a4c2, 0x84c01168, 0x1a62fae1, 0x1e9258b4, 0x8030b33d}, - [16]uint32{0x00000000, 0x800d0816, 0x40274a07, 0xc02a4211, 0x4002e9e2, 0xc00fe1f4, 0x0025a3e5, 0x8028abf3, 0x4001d089, 0xc00cd89f, 0x00269a8e, 0x802b9298, 0x0003396b, 0x800e317d, 0x4024736c, 0xc0297b7a}, - [16]uint32{0x3f800000, 0x3fc00684, 0x3fa013a5, 0x3fe01521, 0x3fa00174, 0x3fe007f0, 0x3f8012d1, 0x3fc01455, 0x3fa000e8, 0x3fe0066c, 0x3f80134d, 0x3fc015c9, 0x3f80019c, 0x3fc00718, 0x3fa01239, 0x3fe014bd}, - uint32(0xfff80000), - [21]string{"0x47", "0xdd", "0x7a", "0x23", "0xe4", "0x00", "0xb0", "0x59", "0xae", "0xb2", "0xdf", "0xfd", "0x21", "0x35", "0xb9", "0xdd", "0xe9", "0x91", "0x8e", "0xd1", "0x00"}}, - { - /* No.384 delta:614 weight:1663 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x789bd9b9, 0xe1471eb4, 0x99dcc70d, 0x92401808, 0xeadbc1b1, 0x730706bc, 0x0b9cdf05, 0x0000cbdb, 0x789b1262, 0xe147d56f, 0x99dc0cd6, 0x9240d3d3, 0xeadb0a6a, 0x7307cd67, 0x0b9c14de}, - [16]uint32{0x00000000, 0x00421735, 0x5130081e, 0x51721f2b, 0x00037267, 0x00416552, 0x51337a79, 0x51716d4c, 0x201c080f, 0x205e1f3a, 0x712c0011, 0x716e1724, 0x201f7a68, 0x205d6d5d, 0x712f7276, 0x716d6543}, - [16]uint32{0x3f800000, 0x3f80210b, 0x3fa89804, 0x3fa8b90f, 0x3f8001b9, 0x3f8020b2, 0x3fa899bd, 0x3fa8b8b6, 0x3f900e04, 0x3f902f0f, 0x3fb89600, 0x3fb8b70b, 0x3f900fbd, 0x3f902eb6, 0x3fb897b9, 0x3fb8b6b2}, - uint32(0xfff80000), - [21]string{"0xf5", "0x82", "0x42", "0x91", "0xec", "0xcf", "0x55", "0x4c", "0x99", "0x8d", "0x85", "0xa5", "0xbe", "0x5b", "0xd2", "0xc7", "0xe7", "0x67", "0x93", "0x4d", "0x00"}}, - { - /* No.385 delta:1194 weight:1183 */ - 11213, - 36, - 13, - 4, - [16]uint32{0x00000000, 0x42c7329a, 0x61c85650, 0x230f64ca, 0xc3e01810, 0x81272a8a, 0xa2284e40, 0xe0ef7cda, 0x00005450, 0x42c766ca, 0x61c80200, 0x230f309a, 0xc3e04c40, 0x81277eda, 0xa2281a10, 0xe0ef288a}, - [16]uint32{0x00000000, 0x006e85ff, 0x2013c012, 0x207d45ed, 0x0003af3c, 0x006d2ac3, 0x20106f2e, 0x207eead1, 0x00004017, 0x006ec5e8, 0x20138005, 0x207d05fa, 0x0003ef2b, 0x006d6ad4, 0x20102f39, 0x207eaac6}, - [16]uint32{0x3f800000, 0x3f803742, 0x3f9009e0, 0x3f903ea2, 0x3f8001d7, 0x3f803695, 0x3f900837, 0x3f903f75, 0x3f800020, 0x3f803762, 0x3f9009c0, 0x3f903e82, 0x3f8001f7, 0x3f8036b5, 0x3f900817, 0x3f903f55}, - uint32(0xfff80000), - [21]string{"0x73", "0x10", "0xc3", "0x30", "0xe6", "0xff", "0xe1", "0x72", "0x2d", "0x2f", "0xd3", "0xcc", "0xf0", "0x3f", "0xc6", "0xa4", "0x5d", "0x80", "0x4a", "0x2e", "0x00"}}, - { - /* No.386 delta:1854 weight:1525 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x07bb317a, 0x40213aa8, 0x479a0bd2, 0xa250182b, 0xa5eb2951, 0xe2712283, 0xe5ca13f9, 0x000070c0, 0x07bb41ba, 0x40214a68, 0x479a7b12, 0xa25068eb, 0xa5eb5991, 0xe2715243, 0xe5ca6339}, - [16]uint32{0x00000000, 0x0d0e8dfe, 0x0883c857, 0x058d45a9, 0x0e904963, 0x039ec49d, 0x06138134, 0x0b1d0cca, 0x21ad841a, 0x2ca309e4, 0x292e4c4d, 0x2420c1b3, 0x2f3dcd79, 0x22334087, 0x27be052e, 0x2ab088d0}, - [16]uint32{0x3f800000, 0x3f868746, 0x3f8441e4, 0x3f82c6a2, 0x3f874824, 0x3f81cf62, 0x3f8309c0, 0x3f858e86, 0x3f90d6c2, 0x3f965184, 0x3f949726, 0x3f921060, 0x3f979ee6, 0x3f9119a0, 0x3f93df02, 0x3f955844}, - uint32(0xfff80000), - [21]string{"0x98", "0x61", "0xd2", "0x1b", "0xb5", "0x8e", "0x0a", "0x6e", "0xcd", "0xb3", "0x70", "0xf9", "0x2e", "0x52", "0x5d", "0x61", "0xfb", "0xd9", "0x99", "0xc0", "0x00"}}, - { - /* No.387 delta:761 weight:1663 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x51346d03, 0x2b2d40e1, 0x7a192de2, 0x50001831, 0x01347532, 0x7b2d58d0, 0x2a1935d3, 0x00009492, 0x5134f991, 0x2b2dd473, 0x7a19b970, 0x50008ca3, 0x0134e1a0, 0x7b2dcc42, 0x2a19a141}, - [16]uint32{0x00000000, 0x00663497, 0x60000dbb, 0x6066392c, 0x20002572, 0x206611e5, 0x400028c9, 0x40661c5e, 0x50023c0d, 0x5064089a, 0x300231b6, 0x30640521, 0x7002197f, 0x70642de8, 0x100214c4, 0x10642053}, - [16]uint32{0x3f800000, 0x3f80331a, 0x3fb00006, 0x3fb0331c, 0x3f900012, 0x3f903308, 0x3fa00014, 0x3fa0330e, 0x3fa8011e, 0x3fa83204, 0x3f980118, 0x3f983202, 0x3fb8010c, 0x3fb83216, 0x3f88010a, 0x3f883210}, - uint32(0xfff80000), - [21]string{"0xec", "0xef", "0xbe", "0x73", "0xaa", "0x5e", "0x52", "0xe9", "0xe7", "0x75", "0x1d", "0x4b", "0x52", "0xcc", "0x2b", "0xa9", "0x97", "0x9b", "0x11", "0x9c", "0x00"}}, - { - /* No.388 delta:1533 weight:1351 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0xe8a1238a, 0x12bbf47c, 0xfa1ad7f6, 0x73b0184c, 0x9b113bc6, 0x610bec30, 0x89aacfba, 0x00005821, 0xe8a17bab, 0x12bbac5d, 0xfa1a8fd7, 0x73b0406d, 0x9b1163e7, 0x610bb411, 0x89aa979b}, - [16]uint32{0x00000000, 0x0839217d, 0x006c81d2, 0x0855a0af, 0x00122003, 0x082b017e, 0x007ea1d1, 0x084780ac, 0x00022018, 0x083b0165, 0x006ea1ca, 0x085780b7, 0x0010001b, 0x08292166, 0x007c81c9, 0x0845a0b4}, - [16]uint32{0x3f800000, 0x3f841c90, 0x3f803640, 0x3f842ad0, 0x3f800910, 0x3f841580, 0x3f803f50, 0x3f8423c0, 0x3f800110, 0x3f841d80, 0x3f803750, 0x3f842bc0, 0x3f800800, 0x3f841490, 0x3f803e40, 0x3f8422d0}, - uint32(0xfff80000), - [21]string{"0x92", "0x60", "0x0d", "0x80", "0xe9", "0x33", "0x2d", "0x46", "0x2b", "0xf2", "0xb4", "0x32", "0x74", "0x9b", "0xf8", "0x99", "0xf8", "0xc3", "0x2e", "0x86", "0x00"}}, - { - /* No.389 delta:873 weight:1257 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0x9fbb556e, 0xb88be20a, 0x2730b764, 0x35c01850, 0xaa7b4d3e, 0x8d4bfa5a, 0x12f0af34, 0x0000bc4d, 0x9fbbe923, 0xb88b5e47, 0x27300b29, 0x35c0a41d, 0xaa7bf173, 0x8d4b4617, 0x12f01379}, - [16]uint32{0x00000000, 0x71341c1e, 0x104378c2, 0x617764dc, 0x0001e91b, 0x7135f505, 0x104291d9, 0x61768dc7, 0x102424ce, 0x611038d0, 0x00675c0c, 0x71534012, 0x1025cdd5, 0x6111d1cb, 0x0066b517, 0x7152a909}, - [16]uint32{0x3f800000, 0x3fb89a0e, 0x3f8821bc, 0x3fb0bbb2, 0x3f8000f4, 0x3fb89afa, 0x3f882148, 0x3fb0bb46, 0x3f881212, 0x3fb0881c, 0x3f8033ae, 0x3fb8a9a0, 0x3f8812e6, 0x3fb088e8, 0x3f80335a, 0x3fb8a954}, - uint32(0xfff80000), - [21]string{"0x0d", "0x4f", "0x87", "0x46", "0x77", "0xdc", "0xa2", "0xd6", "0x85", "0x1a", "0x61", "0xa3", "0x3e", "0x03", "0x0f", "0xe7", "0xc8", "0xb9", "0x0a", "0x8d", "0x00"}}, - { - /* No.390 delta:2038 weight:1291 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x5164b2ef, 0x2c1644e0, 0x7d72f60f, 0xd410186b, 0x8574aa84, 0xf8065c8b, 0xa962ee64, 0x0000382d, 0x51648ac2, 0x2c167ccd, 0x7d72ce22, 0xd4102046, 0x857492a9, 0xf80664a6, 0xa962d649}, - [16]uint32{0x00000000, 0x1228803c, 0x0b08d5cb, 0x192055f7, 0x0f64c15f, 0x1d4c4163, 0x046c1494, 0x164494a8, 0x32604199, 0x2048c1a5, 0x39689452, 0x2b40146e, 0x3d0480c6, 0x2f2c00fa, 0x360c550d, 0x2424d531}, - [16]uint32{0x3f800000, 0x3f891440, 0x3f85846a, 0x3f8c902a, 0x3f87b260, 0x3f8ea620, 0x3f82360a, 0x3f8b224a, 0x3f993020, 0x3f902460, 0x3f9cb44a, 0x3f95a00a, 0x3f9e8240, 0x3f979600, 0x3f9b062a, 0x3f92126a}, - uint32(0xfff80000), - [21]string{"0x32", "0x79", "0x3b", "0xa6", "0x82", "0x51", "0x24", "0x1e", "0xe8", "0x3c", "0xb9", "0x62", "0x18", "0x8d", "0x76", "0x6e", "0x20", "0xc4", "0x51", "0xf8", "0x00"}}, - { - /* No.391 delta:1140 weight:1415 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xc9aa39b4, 0xc7d85494, 0x0e726d20, 0x2cc0187a, 0xe56a21ce, 0xeb184cee, 0x22b2755a, 0x00005a62, 0xc9aa63d6, 0xc7d80ef6, 0x0e723742, 0x2cc04218, 0xe56a7bac, 0xeb18168c, 0x22b22f38}, - [16]uint32{0x00000000, 0x60029c1d, 0xb00da012, 0xd00f3c0f, 0x0002010e, 0x60009d13, 0xb00fa11c, 0xd00d3d01, 0x00501135, 0x60528d28, 0xb05db127, 0xd05f2d3a, 0x0052103b, 0x60508c26, 0xb05fb029, 0xd05d2c34}, - [16]uint32{0x3f800000, 0x3fb0014e, 0x3fd806d0, 0x3fe8079e, 0x3f800100, 0x3fb0004e, 0x3fd807d0, 0x3fe8069e, 0x3f802808, 0x3fb02946, 0x3fd82ed8, 0x3fe82f96, 0x3f802908, 0x3fb02846, 0x3fd82fd8, 0x3fe82e96}, - uint32(0xfff80000), - [21]string{"0x69", "0x24", "0xff", "0x79", "0xe9", "0x53", "0xd5", "0x66", "0xbd", "0x7a", "0x4d", "0x67", "0xd3", "0x60", "0x34", "0x64", "0x08", "0x18", "0x9f", "0x93", "0x00"}}, - { - /* No.392 delta:2336 weight:1173 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x14bfc97b, 0x293ec8a0, 0x3d8101db, 0x39d0188f, 0x2d6fd1f4, 0x10eed02f, 0x04511954, 0x00008d1e, 0x14bf4465, 0x293e45be, 0x3d818cc5, 0x39d09591, 0x2d6f5cea, 0x10ee5d31, 0x0451944a}, - [16]uint32{0x00000000, 0xe0c6035e, 0x1c3a4547, 0xfcfc4619, 0x021307e3, 0xe2d504bd, 0x1e2942a4, 0xfeef41fa, 0x0041c16b, 0xe087c235, 0x1c7b842c, 0xfcbd8772, 0x0252c688, 0xe294c5d6, 0x1e6883cf, 0xfeae8091}, - [16]uint32{0x3f800000, 0x3ff06301, 0x3f8e1d22, 0x3ffe7e23, 0x3f810983, 0x3ff16a82, 0x3f8f14a1, 0x3fff77a0, 0x3f8020e0, 0x3ff043e1, 0x3f8e3dc2, 0x3ffe5ec3, 0x3f812963, 0x3ff14a62, 0x3f8f3441, 0x3fff5740}, - uint32(0xfff80000), - [21]string{"0xa1", "0xc3", "0xef", "0xa2", "0xbd", "0xe7", "0xcf", "0xfc", "0xfd", "0x80", "0x13", "0x97", "0xa4", "0x66", "0x96", "0x1e", "0xdd", "0x51", "0xed", "0xf0", "0x00"}}, - { - /* No.393 delta:871 weight:1573 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0xda1efd75, 0x44ba0c25, 0x9ea4f150, 0x9970189f, 0x436ee5ea, 0xddca14ba, 0x07d4e9cf, 0x00008611, 0xda1e7b64, 0x44ba8a34, 0x9ea47741, 0x99709e8e, 0x436e63fb, 0xddca92ab, 0x07d46fde}, - [16]uint32{0x00000000, 0x000301ff, 0xa000c1bd, 0xa003c042, 0x00006817, 0x000369e8, 0xa000a9aa, 0xa003a855, 0x2054861a, 0x205787e5, 0x805447a7, 0x80574658, 0x2054ee0d, 0x2057eff2, 0x80542fb0, 0x80572e4f}, - [16]uint32{0x3f800000, 0x3f800180, 0x3fd00060, 0x3fd001e0, 0x3f800034, 0x3f8001b4, 0x3fd00054, 0x3fd001d4, 0x3f902a43, 0x3f902bc3, 0x3fc02a23, 0x3fc02ba3, 0x3f902a77, 0x3f902bf7, 0x3fc02a17, 0x3fc02b97}, - uint32(0xfff80000), - [21]string{"0xc1", "0xf0", "0x4a", "0x60", "0x21", "0xed", "0xe8", "0x38", "0xd1", "0xac", "0x26", "0xbf", "0xde", "0xc7", "0xed", "0xa3", "0xc7", "0xe6", "0x06", "0x38", "0x00"}}, - { - /* No.394 delta:1517 weight:1705 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x786dc002, 0x7926fdb6, 0x014b3db4, 0xaf2018aa, 0xd74dd8a8, 0xd606e51c, 0xae6b251e, 0x0000c70a, 0x786d0708, 0x79263abc, 0x014bfabe, 0xaf20dfa0, 0xd74d1fa2, 0xd6062216, 0xae6be214}, - [16]uint32{0x00000000, 0x484b915b, 0x0047f8d8, 0x480c6983, 0x440a809d, 0x0c4111c6, 0x444d7845, 0x0c06e91e, 0x02282116, 0x4a63b04d, 0x026fd9ce, 0x4a244895, 0x4622a18b, 0x0e6930d0, 0x46655953, 0x0e2ec808}, - [16]uint32{0x3f800000, 0x3fa425c8, 0x3f8023fc, 0x3fa40634, 0x3fa20540, 0x3f862088, 0x3fa226bc, 0x3f860374, 0x3f811410, 0x3fa531d8, 0x3f8137ec, 0x3fa51224, 0x3fa31150, 0x3f873498, 0x3fa332ac, 0x3f871764}, - uint32(0xfff80000), - [21]string{"0xbc", "0xf2", "0xae", "0x6c", "0x1a", "0x34", "0x9b", "0x5d", "0x7c", "0x65", "0x7b", "0x77", "0x57", "0x31", "0xaa", "0x37", "0x42", "0xe0", "0x3f", "0x31", "0x00"}}, - { - /* No.395 delta:1035 weight:1367 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x143d8e44, 0x3d637843, 0x295ef607, 0x8a3018bd, 0x9e0d96f9, 0xb75360fe, 0xa36eeeba, 0x00009dc3, 0x143d1387, 0x3d63e580, 0x295e6bc4, 0x8a30857e, 0x9e0d0b3a, 0xb753fd3d, 0xa36e7379}, - [16]uint32{0x00000000, 0x00037416, 0x20440409, 0x2047701f, 0x1010121b, 0x1013660d, 0x30541612, 0x30576204, 0x4066b1ce, 0x4065c5d8, 0x6022b5c7, 0x6021c1d1, 0x5076a3d5, 0x5075d7c3, 0x7032a7dc, 0x7031d3ca}, - [16]uint32{0x3f800000, 0x3f8001ba, 0x3f902202, 0x3f9023b8, 0x3f880809, 0x3f8809b3, 0x3f982a0b, 0x3f982bb1, 0x3fa03358, 0x3fa032e2, 0x3fb0115a, 0x3fb010e0, 0x3fa83b51, 0x3fa83aeb, 0x3fb81953, 0x3fb818e9}, - uint32(0xfff80000), - [21]string{"0x15", "0x55", "0xb5", "0x38", "0xbd", "0x13", "0xe4", "0xa7", "0xd1", "0x20", "0x66", "0x03", "0x26", "0x71", "0x19", "0xfa", "0x2c", "0x03", "0xeb", "0xcb", "0x00"}}, - { - /* No.396 delta:722 weight:1445 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x6552a43b, 0x4a6b1404, 0x2f39b03f, 0x9a7018c3, 0xff22bcf8, 0xd01b0cc7, 0xb549a8fc, 0x0000fe80, 0x65525abb, 0x4a6bea84, 0x2f394ebf, 0x9a70e643, 0xff224278, 0xd01bf247, 0xb549567c}, - [16]uint32{0x00000000, 0x103e11be, 0x0003044b, 0x103d15f5, 0x503b3654, 0x400527ea, 0x5038321f, 0x400623a1, 0x0002bc06, 0x103cadb8, 0x0001b84d, 0x103fa9f3, 0x50398a52, 0x40079bec, 0x503a8e19, 0x40049fa7}, - [16]uint32{0x3f800000, 0x3f881f08, 0x3f800182, 0x3f881e8a, 0x3fa81d9b, 0x3fa00293, 0x3fa81c19, 0x3fa00311, 0x3f80015e, 0x3f881e56, 0x3f8000dc, 0x3f881fd4, 0x3fa81cc5, 0x3fa003cd, 0x3fa81d47, 0x3fa0024f}, - uint32(0xfff80000), - [21]string{"0xad", "0x8a", "0xfd", "0x27", "0xb8", "0x3e", "0x15", "0x8a", "0x49", "0x48", "0xd9", "0xd7", "0x59", "0x94", "0xb0", "0x87", "0xfc", "0x57", "0x26", "0xf4", "0x00"}}, - { - /* No.397 delta:840 weight:1603 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x669d918e, 0xdcb4eaab, 0xba297b25, 0x581018d3, 0x3e8d895d, 0x84a4f278, 0xe23963f6, 0x00000e05, 0x669d9f8b, 0xdcb4e4ae, 0xba297520, 0x581016d6, 0x3e8d8758, 0x84a4fc7d, 0xe2396df3}, - [16]uint32{0x00000000, 0xa0215816, 0x2001aab4, 0x8020f2a2, 0x002258ee, 0xa00300f8, 0x2023f25a, 0x8002aa4c, 0x4000621e, 0xe0213a08, 0x6001c8aa, 0xc02090bc, 0x40223af0, 0xe00362e6, 0x60239044, 0xc002c852}, - [16]uint32{0x3f800000, 0x3fd010ac, 0x3f9000d5, 0x3fc01079, 0x3f80112c, 0x3fd00180, 0x3f9011f9, 0x3fc00155, 0x3fa00031, 0x3ff0109d, 0x3fb000e4, 0x3fe01048, 0x3fa0111d, 0x3ff001b1, 0x3fb011c8, 0x3fe00164}, - uint32(0xfff80000), - [21]string{"0x75", "0x9a", "0x24", "0xfc", "0x18", "0x38", "0x61", "0xb9", "0xb3", "0x13", "0xb4", "0xcb", "0xd5", "0xae", "0xfa", "0x52", "0x8f", "0x60", "0x2a", "0x4f", "0x00"}}, - { - /* No.398 delta:1725 weight:1293 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x46ab68d5, 0x5c04de2b, 0x1aafb6fe, 0xe52018ec, 0xa38b7039, 0xb924c6c7, 0xff8fae12, 0x00009d52, 0x46abf587, 0x5c044379, 0x1aaf2bac, 0xe52085be, 0xa38bed6b, 0xb9245b95, 0xff8f3340}, - [16]uint32{0x00000000, 0x007c01d6, 0x004400f5, 0x00380123, 0x0000015f, 0x007c0089, 0x004401aa, 0x0038007c, 0x0041001e, 0x003d01c8, 0x000500eb, 0x0079013d, 0x00410141, 0x003d0097, 0x000501b4, 0x00790062}, - [16]uint32{0x3f800000, 0x3f803e00, 0x3f802200, 0x3f801c00, 0x3f800000, 0x3f803e00, 0x3f802200, 0x3f801c00, 0x3f802080, 0x3f801e80, 0x3f800280, 0x3f803c80, 0x3f802080, 0x3f801e80, 0x3f800280, 0x3f803c80}, - uint32(0xfff80000), - [21]string{"0xdb", "0x63", "0x57", "0xb1", "0xff", "0x25", "0x5b", "0x3f", "0xb8", "0x43", "0xa0", "0x6d", "0x1c", "0x80", "0x82", "0x9d", "0x33", "0x74", "0x52", "0xf1", "0x00"}}, - { - /* No.399 delta:780 weight:1553 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0x1807b5d7, 0x79b56b4c, 0x61b2de9b, 0x334018f9, 0x2b47ad2e, 0x4af573b5, 0x52f2c662, 0x0000df01, 0x18076ad6, 0x79b5b44d, 0x61b2019a, 0x3340c7f8, 0x2b47722f, 0x4af5acb4, 0x52f21963}, - [16]uint32{0x00000000, 0x00040952, 0x60212011, 0x60252943, 0x10001526, 0x10041c74, 0x70213537, 0x70253c65, 0x40000a1a, 0x40040348, 0x20212a0b, 0x20252359, 0x50001f3c, 0x5004166e, 0x30213f2d, 0x3025367f}, - [16]uint32{0x3f800000, 0x3f800204, 0x3fb01090, 0x3fb01294, 0x3f88000a, 0x3f88020e, 0x3fb8109a, 0x3fb8129e, 0x3fa00005, 0x3fa00201, 0x3f901095, 0x3f901291, 0x3fa8000f, 0x3fa8020b, 0x3f98109f, 0x3f98129b}, - uint32(0xfff80000), - [21]string{"0x3d", "0xe1", "0x0e", "0xa7", "0x85", "0xab", "0xc6", "0xe8", "0x6f", "0x4b", "0xcd", "0xbb", "0xd5", "0xa4", "0x09", "0xa9", "0x26", "0x43", "0xbc", "0xfe", "0x00"}}, - { - /* No.400 delta:2266 weight:1249 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0xe2dbfe7d, 0xd0e935c8, 0x3232cbb5, 0xff001901, 0x1ddbe77c, 0x2fe92cc9, 0xcd32d2b4, 0x0000f8d9, 0xe2db06a4, 0xd0e9cd11, 0x3232336c, 0xff00e1d8, 0x1ddb1fa5, 0x2fe9d410, 0xcd322a6d}, - [16]uint32{0x00000000, 0x0a4380b6, 0x120148e9, 0x1842c85f, 0x2140981d, 0x2b0318ab, 0x3341d0f4, 0x39025042, 0x700000a7, 0x7a438011, 0x6201484e, 0x6842c8f8, 0x514098ba, 0x5b03180c, 0x4341d053, 0x490250e5}, - [16]uint32{0x3f800000, 0x3f8521c0, 0x3f8900a4, 0x3f8c2164, 0x3f90a04c, 0x3f95818c, 0x3f99a0e8, 0x3f9c8128, 0x3fb80000, 0x3fbd21c0, 0x3fb100a4, 0x3fb42164, 0x3fa8a04c, 0x3fad818c, 0x3fa1a0e8, 0x3fa48128}, - uint32(0xfff80000), - [21]string{"0x36", "0x58", "0x6f", "0x1a", "0x58", "0x7f", "0x55", "0xac", "0x11", "0x3e", "0x26", "0x32", "0x97", "0xb7", "0x1a", "0x18", "0x6a", "0x72", "0x2a", "0xbe", "0x00"}}, - { - /* No.401 delta:2650 weight:873 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0xe1aed356, 0x5e9f273a, 0xbf31f46c, 0xa2e01919, 0x434eca4f, 0xfc7f3e23, 0x1dd1ed75, 0x000081de, 0xe1ae5288, 0x5e9fa6e4, 0xbf3175b2, 0xa2e098c7, 0x434e4b91, 0xfc7fbffd, 0x1dd16cab}, - [16]uint32{0x00000000, 0xc0706532, 0x280209b8, 0xe8726c8a, 0xd6906019, 0x16e0052b, 0xfe9269a1, 0x3ee20c93, 0x22991407, 0xe2e97135, 0x0a9b1dbf, 0xcaeb788d, 0xf409741e, 0x3479112c, 0xdc0b7da6, 0x1c7b1894}, - [16]uint32{0x3f800000, 0x3fe03832, 0x3f940104, 0x3ff43936, 0x3feb4830, 0x3f8b7002, 0x3fff4934, 0x3f9f7106, 0x3f914c8a, 0x3ff174b8, 0x3f854d8e, 0x3fe575bc, 0x3ffa04ba, 0x3f9a3c88, 0x3fee05be, 0x3f8e3d8c}, - uint32(0xfff80000), - [21]string{"0x33", "0x8e", "0xa6", "0x98", "0x68", "0xf0", "0x3f", "0x0f", "0xc5", "0xf7", "0x8e", "0x62", "0x24", "0xf2", "0x8f", "0x37", "0x53", "0xf4", "0x2d", "0x6b", "0x00"}}, - { - /* No.402 delta:983 weight:1731 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x94aa7ca2, 0x2140e274, 0xb5ea9ed6, 0x6c201925, 0xf88a6587, 0x4d60fb51, 0xd9ca87f3, 0x0000da27, 0x94aaa685, 0x21403853, 0xb5ea44f1, 0x6c20c302, 0xf88abfa0, 0x4d602176, 0xd9ca5dd4}, - [16]uint32{0x00000000, 0x602ba1b2, 0x00026179, 0x6029c0cb, 0x810800a4, 0xe123a116, 0x810a61dd, 0xe121c06f, 0x8080401e, 0xe0abe1ac, 0x80822167, 0xe0a980d5, 0x018840ba, 0x61a3e108, 0x018a21c3, 0x61a18071}, - [16]uint32{0x3f800000, 0x3fb015d0, 0x3f800130, 0x3fb014e0, 0x3fc08400, 0x3ff091d0, 0x3fc08530, 0x3ff090e0, 0x3fc04020, 0x3ff055f0, 0x3fc04110, 0x3ff054c0, 0x3f80c420, 0x3fb0d1f0, 0x3f80c510, 0x3fb0d0c0}, - uint32(0xfff80000), - [21]string{"0xbc", "0x77", "0xad", "0x3a", "0x86", "0x5e", "0x7c", "0xff", "0xfe", "0x2c", "0x07", "0x2b", "0xa9", "0xfb", "0xb0", "0xae", "0x84", "0x09", "0xe6", "0xa8", "0x00"}}, - { - /* No.403 delta:688 weight:1461 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xb1e47e54, 0x0bb002f8, 0xba547cac, 0x3fa0193d, 0x8e446769, 0x34101bc5, 0x85f46591, 0x0000b2a5, 0xb1e4ccf1, 0x0bb0b05d, 0xba54ce09, 0x3fa0ab98, 0x8e44d5cc, 0x3410a960, 0x85f4d734}, - [16]uint32{0x00000000, 0xdc142153, 0x2262019a, 0xfe7620c9, 0x0068e026, 0xdc7cc175, 0x220ae1bc, 0xfe1ec0ef, 0x0012381d, 0xdc06194e, 0x22703987, 0xfe6418d4, 0x007ad83b, 0xdc6ef968, 0x2218d9a1, 0xfe0cf8f2}, - [16]uint32{0x3f800000, 0x3fee0a10, 0x3f913100, 0x3fff3b10, 0x3f803470, 0x3fee3e60, 0x3f910570, 0x3fff0f60, 0x3f80091c, 0x3fee030c, 0x3f91381c, 0x3fff320c, 0x3f803d6c, 0x3fee377c, 0x3f910c6c, 0x3fff067c}, - uint32(0xfff80000), - [21]string{"0xf3", "0x99", "0xfd", "0x47", "0xca", "0x52", "0x7b", "0x4e", "0xc2", "0x1a", "0x72", "0x95", "0xdb", "0x1a", "0xe5", "0x0f", "0x58", "0x17", "0xb9", "0x96", "0x00"}}, - { - /* No.404 delta:2158 weight:1325 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xf3fd55b8, 0xf999547e, 0x0a6401c6, 0x27401949, 0xd4bd4cf1, 0xded94d37, 0x2d24188f, 0x0000b353, 0xf3fde6eb, 0xf999e72d, 0x0a64b295, 0x2740aa1a, 0xd4bdffa2, 0xded9fe64, 0x2d24abdc}, - [16]uint32{0x00000000, 0x0c526f12, 0x1500841c, 0x1952eb0e, 0x0b180c01, 0x074a6313, 0x1e18881d, 0x124ae70f, 0x24487005, 0x281a1f17, 0x3148f419, 0x3d1a9b0b, 0x2f507c04, 0x23021316, 0x3a50f818, 0x3602970a}, - [16]uint32{0x3f800000, 0x3f862937, 0x3f8a8042, 0x3f8ca975, 0x3f858c06, 0x3f83a531, 0x3f8f0c44, 0x3f892573, 0x3f922438, 0x3f940d0f, 0x3f98a47a, 0x3f9e8d4d, 0x3f97a83e, 0x3f918109, 0x3f9d287c, 0x3f9b014b}, - uint32(0xfff80000), - [21]string{"0xc3", "0x74", "0x74", "0x92", "0x5b", "0x70", "0x8c", "0x5d", "0xe8", "0x35", "0xf4", "0xb0", "0xa9", "0x24", "0xe6", "0x54", "0xba", "0x40", "0xcf", "0x0f", "0x00"}}, - { - /* No.405 delta:938 weight:1185 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x52862043, 0xd780840d, 0x8506a44e, 0xe4d01955, 0xb6563916, 0x33509d58, 0x61d6bd1b, 0x0000efed, 0x5286cfae, 0xd7806be0, 0x85064ba3, 0xe4d0f6b8, 0xb656d6fb, 0x335072b5, 0x61d652f6}, - [16]uint32{0x00000000, 0x404f4096, 0x00024c9d, 0x404d0c0b, 0x206cb002, 0x6023f094, 0x206efc9f, 0x6021bc09, 0x400bc211, 0x00448287, 0x40098e8c, 0x0046ce1a, 0x60677213, 0x20283285, 0x60653e8e, 0x202a7e18}, - [16]uint32{0x3f800000, 0x3fa027a0, 0x3f800126, 0x3fa02686, 0x3f903658, 0x3fb011f8, 0x3f90377e, 0x3fb010de, 0x3fa005e1, 0x3f802241, 0x3fa004c7, 0x3f802367, 0x3fb033b9, 0x3f901419, 0x3fb0329f, 0x3f90153f}, - uint32(0xfff80000), - [21]string{"0x7f", "0xf9", "0x6d", "0x9a", "0xea", "0xa3", "0xf9", "0xf2", "0xbb", "0x37", "0x32", "0x5e", "0x26", "0x79", "0xd2", "0x7a", "0x4b", "0xd5", "0x7f", "0xe8", "0x00"}}, - { - /* No.406 delta:1252 weight:1757 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0xe880a2a5, 0x895e81f7, 0x61de2352, 0x13e01963, 0xfb60bbc6, 0x9abe9894, 0x723e3a31, 0x00009436, 0xe8803693, 0x895e15c1, 0x61deb764, 0x13e08d55, 0xfb602ff0, 0x9abe0ca2, 0x723eae07}, - [16]uint32{0x00000000, 0x206478da, 0x004f0046, 0x202b789c, 0x400c4404, 0x60683cde, 0x40434442, 0x60273c98, 0x00301137, 0x205469ed, 0x007f1171, 0x201b69ab, 0x403c5533, 0x60582de9, 0x40735575, 0x60172daf}, - [16]uint32{0x3f800000, 0x3f90323c, 0x3f802780, 0x3f9015bc, 0x3fa00622, 0x3fb0341e, 0x3fa021a2, 0x3fb0139e, 0x3f801808, 0x3f902a34, 0x3f803f88, 0x3f900db4, 0x3fa01e2a, 0x3fb02c16, 0x3fa039aa, 0x3fb00b96}, - uint32(0xfff80000), - [21]string{"0x97", "0xea", "0xc7", "0x0e", "0x13", "0x4a", "0x4a", "0xde", "0xa5", "0x17", "0x77", "0x45", "0xc4", "0xc5", "0x87", "0x34", "0x14", "0x87", "0x57", "0x42", "0x00"}}, - { - /* No.407 delta:783 weight:1331 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0xd707084f, 0x9ed93c29, 0x49de3466, 0x96f01970, 0x41f7113f, 0x08292559, 0xdf2e2d16, 0x000051e5, 0xd70759aa, 0x9ed96dcc, 0x49de6583, 0x96f04895, 0x41f740da, 0x082974bc, 0xdf2e7cf3}, - [16]uint32{0x00000000, 0x0054c37a, 0xa07a1991, 0xa02edaeb, 0x00030014, 0x0057c36e, 0xa0791985, 0xa02ddaff, 0x00009017, 0x0054536d, 0xa07a8986, 0xa02e4afc, 0x00039003, 0x00575379, 0xa0798992, 0xa02d4ae8}, - [16]uint32{0x3f800000, 0x3f802a61, 0x3fd03d0c, 0x3fd0176d, 0x3f800180, 0x3f802be1, 0x3fd03c8c, 0x3fd016ed, 0x3f800048, 0x3f802a29, 0x3fd03d44, 0x3fd01725, 0x3f8001c8, 0x3f802ba9, 0x3fd03cc4, 0x3fd016a5}, - uint32(0xfff80000), - [21]string{"0x35", "0xaa", "0x33", "0x13", "0x1e", "0x49", "0x0f", "0x90", "0x67", "0x81", "0x1c", "0x7d", "0x0f", "0xbb", "0xe4", "0x70", "0x38", "0x4a", "0x04", "0x5f", "0x00"}}, - { - /* No.408 delta:1682 weight:1569 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0xa312a06e, 0x7f135ca4, 0xdc01fcca, 0x01a0198e, 0xa2b2b9e0, 0x7eb3452a, 0xdda1e544, 0x000036a9, 0xa31296c7, 0x7f136a0d, 0xdc01ca63, 0x01a02f27, 0xa2b28f49, 0x7eb37383, 0xdda1d3ed}, - [16]uint32{0x00000000, 0x004c01d3, 0x4020013f, 0x406c00ec, 0x2021002d, 0x206d01fe, 0x60010112, 0x604d00c1, 0x00000077, 0x004c01a4, 0x40200148, 0x406c009b, 0x2021005a, 0x206d0189, 0x60010165, 0x604d00b6}, - [16]uint32{0x3f800000, 0x3f802600, 0x3fa01000, 0x3fa03600, 0x3f901080, 0x3f903680, 0x3fb00080, 0x3fb02680, 0x3f800000, 0x3f802600, 0x3fa01000, 0x3fa03600, 0x3f901080, 0x3f903680, 0x3fb00080, 0x3fb02680}, - uint32(0xfff80000), - [21]string{"0xa8", "0xbf", "0x78", "0xce", "0x3e", "0xe9", "0x50", "0xd4", "0x3a", "0x88", "0x2f", "0xbe", "0x47", "0x8e", "0x68", "0xc1", "0x47", "0x4f", "0x76", "0x96", "0x00"}}, - { - /* No.409 delta:1013 weight:1173 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x247e8d9b, 0xac3b09dc, 0x88458447, 0xd0701993, 0xf40e9408, 0x7c4b104f, 0x58359dd4, 0x000001f0, 0x247e8c6b, 0xac3b082c, 0x884585b7, 0xd0701863, 0xf40e95f8, 0x7c4b11bf, 0x58359c24}, - [16]uint32{0x00000000, 0x3041455a, 0x8002664e, 0xb0432314, 0x5001b076, 0x6040f52c, 0xd003d638, 0xe0429362, 0x04005419, 0x34411143, 0x84023257, 0xb443770d, 0x5401e46f, 0x6440a135, 0xd4038221, 0xe442c77b}, - [16]uint32{0x3f800000, 0x3f9820a2, 0x3fc00133, 0x3fd82191, 0x3fa800d8, 0x3fb0207a, 0x3fe801eb, 0x3ff02149, 0x3f82002a, 0x3f9a2088, 0x3fc20119, 0x3fda21bb, 0x3faa00f2, 0x3fb22050, 0x3fea01c1, 0x3ff22163}, - uint32(0xfff80000), - [21]string{"0xf0", "0xc1", "0x7d", "0x8b", "0xe2", "0x9e", "0x59", "0x35", "0x96", "0x48", "0xd0", "0x14", "0x5e", "0x8f", "0x0b", "0x36", "0x00", "0xce", "0xf1", "0x71", "0x00"}}, - { - /* No.410 delta:1115 weight:1363 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x8192a8cc, 0xa56576fc, 0x24f7de30, 0xbca019ad, 0x3d32b161, 0x19c56f51, 0x9857c79d, 0x00009b4e, 0x81923382, 0xa565edb2, 0x24f7457e, 0xbca082e3, 0x3d322a2f, 0x19c5f41f, 0x98575cd3}, - [16]uint32{0x00000000, 0x10349155, 0x406750ae, 0x5053c1fb, 0x4002640c, 0x5036f559, 0x006534a2, 0x1051a5f7, 0x40012418, 0x5035b54d, 0x006674b6, 0x1052e5e3, 0x00034014, 0x1037d141, 0x406410ba, 0x505081ef}, - [16]uint32{0x3f800000, 0x3f881a48, 0x3fa033a8, 0x3fa829e0, 0x3fa00132, 0x3fa81b7a, 0x3f80329a, 0x3f8828d2, 0x3fa00092, 0x3fa81ada, 0x3f80333a, 0x3f882972, 0x3f8001a0, 0x3f881be8, 0x3fa03208, 0x3fa82840}, - uint32(0xfff80000), - [21]string{"0x15", "0x0b", "0x2c", "0xe6", "0xe0", "0x4c", "0x62", "0xc1", "0x40", "0x7a", "0x71", "0x13", "0xea", "0xbd", "0x9d", "0x38", "0xd7", "0x7f", "0xa8", "0xac", "0x00"}}, - { - /* No.411 delta:1393 weight:1675 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0xa0095e24, 0xfab39763, 0x5abac947, 0xb28019b8, 0x1289479c, 0x48338edb, 0xe83ad0ff, 0x00009b6b, 0xa009c54f, 0xfab30c08, 0x5aba522c, 0xb28082d3, 0x1289dcf7, 0x483315b0, 0xe83a4b94}, - [16]uint32{0x00000000, 0x4a5decba, 0x00562411, 0x4a0bc8ab, 0x4406e13e, 0x0e5b0d84, 0x4450c52f, 0x0e0d2995, 0x007880b8, 0x4a256c02, 0x002ea4a9, 0x4a734813, 0x447e6186, 0x0e238d3c, 0x44284597, 0x0e75a92d}, - [16]uint32{0x3f800000, 0x3fa52ef6, 0x3f802b12, 0x3fa505e4, 0x3fa20370, 0x3f872d86, 0x3fa22862, 0x3f870694, 0x3f803c40, 0x3fa512b6, 0x3f801752, 0x3fa539a4, 0x3fa23f30, 0x3f8711c6, 0x3fa21422, 0x3f873ad4}, - uint32(0xfff80000), - [21]string{"0xdb", "0x9e", "0xc8", "0xb1", "0xe3", "0x0b", "0x69", "0x0d", "0xf1", "0x8a", "0x58", "0x17", "0xc1", "0xe2", "0xaa", "0xad", "0x52", "0x36", "0x28", "0x41", "0x00"}}, - { - /* No.412 delta:911 weight:1285 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0xa1135c19, 0xa2371c1f, 0x03244006, 0x8bc019c2, 0x2ad345db, 0x29f705dd, 0x88e459c4, 0x0000e704, 0xa113bb1d, 0xa237fb1b, 0x0324a702, 0x8bc0fec6, 0x2ad3a2df, 0x29f7e2d9, 0x88e4bec0}, - [16]uint32{0x00000000, 0x1003ab1e, 0x1000e015, 0x00034b0b, 0x4068580c, 0x506bf312, 0x5068b819, 0x406b1307, 0x7074100e, 0x6077bb10, 0x6074f01b, 0x70775b05, 0x301c4802, 0x201fe31c, 0x201ca817, 0x301f0309}, - [16]uint32{0x3f800000, 0x3f8801d5, 0x3f880070, 0x3f8001a5, 0x3fa0342c, 0x3fa835f9, 0x3fa8345c, 0x3fa03589, 0x3fb83a08, 0x3fb03bdd, 0x3fb03a78, 0x3fb83bad, 0x3f980e24, 0x3f900ff1, 0x3f900e54, 0x3f980f81}, - uint32(0xfff80000), - [21]string{"0xe2", "0xff", "0x51", "0x6a", "0x3c", "0x06", "0xde", "0x51", "0x5b", "0x4f", "0x25", "0xc4", "0x5a", "0x0a", "0x5d", "0x3f", "0xa9", "0x40", "0x0f", "0xf0", "0x00"}}, - { - /* No.413 delta:1113 weight:1727 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x3c2bcd99, 0x2b6fe7c4, 0x17442a5d, 0x496019d0, 0x754bd449, 0x620ffe14, 0x5e24338d, 0x00007a55, 0x3c2bb7cc, 0x2b6f9d91, 0x17445008, 0x49606385, 0x754bae1c, 0x620f8441, 0x5e2449d8}, - [16]uint32{0x00000000, 0x105c81be, 0x00228dab, 0x107e0c15, 0x10023017, 0x005eb1a9, 0x1020bdbc, 0x007c3c02, 0x20020014, 0x305e81aa, 0x20208dbf, 0x307c0c01, 0x30003003, 0x205cb1bd, 0x3022bda8, 0x207e3c16}, - [16]uint32{0x3f800000, 0x3f882e40, 0x3f801146, 0x3f883f06, 0x3f880118, 0x3f802f58, 0x3f88105e, 0x3f803e1e, 0x3f900100, 0x3f982f40, 0x3f901046, 0x3f983e06, 0x3f980018, 0x3f902e58, 0x3f98115e, 0x3f903f1e}, - uint32(0xfff80000), - [21]string{"0xa2", "0xe7", "0x43", "0xe5", "0x82", "0x36", "0xdc", "0xe3", "0x6e", "0xe2", "0x55", "0xd8", "0xfe", "0x7c", "0x4c", "0x56", "0xc4", "0x20", "0x1b", "0xe2", "0x00"}}, - { - /* No.414 delta:1720 weight:1681 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0x61318219, 0x38a5e2e3, 0x599460fa, 0x2a0019e9, 0x4b319bf0, 0x12a5fb0a, 0x73947913, 0x00003497, 0x6131b68e, 0x38a5d674, 0x5994546d, 0x2a002d7e, 0x4b31af67, 0x12a5cf9d, 0x73944d84}, - [16]uint32{0x00000000, 0x003c01ba, 0x6022c1eb, 0x601ec051, 0x106141d6, 0x105d406c, 0x7043803d, 0x707f8187, 0x000260b7, 0x003e610d, 0x6020a15c, 0x601ca0e6, 0x10632161, 0x105f20db, 0x7041e08a, 0x707de130}, - [16]uint32{0x3f800000, 0x3f801e00, 0x3fb01160, 0x3fb00f60, 0x3f8830a0, 0x3f882ea0, 0x3fb821c0, 0x3fb83fc0, 0x3f800130, 0x3f801f30, 0x3fb01050, 0x3fb00e50, 0x3f883190, 0x3f882f90, 0x3fb820f0, 0x3fb83ef0}, - uint32(0xfff80000), - [21]string{"0x0e", "0x4f", "0x4e", "0x4b", "0x3f", "0xba", "0x64", "0x69", "0x9d", "0xf0", "0x3a", "0x12", "0x3d", "0xd1", "0xe8", "0x04", "0x82", "0x7a", "0x67", "0xe8", "0x00"}}, - { - /* No.415 delta:776 weight:1311 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xf9a60b27, 0xa0ea6250, 0x594c6977, 0xdee019f9, 0x274612de, 0x7e0a7ba9, 0x87ac708e, 0x00003ca0, 0xf9a63787, 0xa0ea5ef0, 0x594c55d7, 0xdee02559, 0x27462e7e, 0x7e0a4709, 0x87ac4c2e}, - [16]uint32{0x00000000, 0x606091b3, 0x40302129, 0x2050b09a, 0x10440165, 0x702490d6, 0x5074204c, 0x3014b1ff, 0x5008405c, 0x3068d1ef, 0x10386175, 0x7058f0c6, 0x404c4139, 0x202cd08a, 0x007c6010, 0x601cf1a3}, - [16]uint32{0x3f800000, 0x3fb03048, 0x3fa01810, 0x3f902858, 0x3f882200, 0x3fb81248, 0x3fa83a10, 0x3f980a58, 0x3fa80420, 0x3f983468, 0x3f881c30, 0x3fb82c78, 0x3fa02620, 0x3f901668, 0x3f803e30, 0x3fb00e78}, - uint32(0xfff80000), - [21]string{"0xa1", "0x33", "0x08", "0x47", "0xcc", "0x62", "0xe4", "0x95", "0xe2", "0x64", "0xa2", "0x48", "0xf9", "0x1a", "0x10", "0xd3", "0xd1", "0xe8", "0xd9", "0xc2", "0x00"}}, - { - /* No.416 delta:1715 weight:1591 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x004285ba, 0xc559b40b, 0xc51b31b1, 0xbb901a0c, 0xbbd29fb6, 0x7ec9ae07, 0x7e8b2bbd, 0x00004bd6, 0x0042ce6c, 0xc559ffdd, 0xc51b7a67, 0xbb9051da, 0xbbd2d460, 0x7ec9e5d1, 0x7e8b606b}, - [16]uint32{0x00000000, 0x0174813a, 0x680800d3, 0x697c81e9, 0x005a01dc, 0x012e80e6, 0x6852010f, 0x69268035, 0x0024001f, 0x01508125, 0x682c00cc, 0x695881f6, 0x007e01c3, 0x010a80f9, 0x68760110, 0x6902802a}, - [16]uint32{0x3f800000, 0x3f80ba40, 0x3fb40400, 0x3fb4be40, 0x3f802d00, 0x3f809740, 0x3fb42900, 0x3fb49340, 0x3f801200, 0x3f80a840, 0x3fb41600, 0x3fb4ac40, 0x3f803f00, 0x3f808540, 0x3fb43b00, 0x3fb48140}, - uint32(0xfff80000), - [21]string{"0x78", "0xc2", "0x13", "0xe8", "0x63", "0xa1", "0x0a", "0x39", "0x4f", "0x07", "0x47", "0x49", "0x07", "0xd9", "0xa7", "0x1e", "0x0d", "0x3f", "0x92", "0x15", "0x00"}}, - { - /* No.417 delta:1194 weight:1671 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x198b5884, 0x2bad330c, 0x32266b88, 0x1db01a18, 0x043b429c, 0x361d2914, 0x2f967190, 0x0000fa5b, 0x198ba2df, 0x2badc957, 0x322691d3, 0x1db0e043, 0x043bb8c7, 0x361dd34f, 0x2f968bcb}, - [16]uint32{0x00000000, 0x287ca0b6, 0x24d2010d, 0x0caea1bb, 0x005a4014, 0x2826e0a2, 0x24884119, 0x0cf4e1af, 0x3048d47e, 0x183474c8, 0x149ad573, 0x3ce675c5, 0x3012946a, 0x186e34dc, 0x14c09567, 0x3cbc35d1}, - [16]uint32{0x3f800000, 0x3f943e50, 0x3f926900, 0x3f865750, 0x3f802d20, 0x3f941370, 0x3f924420, 0x3f867a70, 0x3f98246a, 0x3f8c1a3a, 0x3f8a4d6a, 0x3f9e733a, 0x3f98094a, 0x3f8c371a, 0x3f8a604a, 0x3f9e5e1a}, - uint32(0xfff80000), - [21]string{"0x98", "0xd1", "0xda", "0x5a", "0x80", "0x18", "0xbd", "0xae", "0x24", "0x02", "0x8c", "0x67", "0x6d", "0xbc", "0x97", "0xd5", "0x50", "0x94", "0x3f", "0xc1", "0x00"}}, - { - /* No.418 delta:867 weight:1673 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0xd090b11f, 0x8d9806df, 0x5d08b7c0, 0x6f201a25, 0xbfb0ab3a, 0xe2b81cfa, 0x3228ade5, 0x0000721c, 0xd090c303, 0x8d9874c3, 0x5d08c5dc, 0x6f206839, 0xbfb0d926, 0xe2b86ee6, 0x3228dff9}, - [16]uint32{0x00000000, 0x30610032, 0x8044460e, 0xb025463c, 0x0002e295, 0x3063e2a7, 0x8046a49b, 0xb027a4a9, 0x00018de8, 0x30608dda, 0x8045cbe6, 0xb024cbd4, 0x00036f7d, 0x30626f4f, 0x80472973, 0xb0262941}, - [16]uint32{0x3f800000, 0x3f983080, 0x3fc02223, 0x3fd812a3, 0x3f800171, 0x3f9831f1, 0x3fc02352, 0x3fd813d2, 0x3f8000c6, 0x3f983046, 0x3fc022e5, 0x3fd81265, 0x3f8001b7, 0x3f983137, 0x3fc02394, 0x3fd81314}, - uint32(0xfff80000), - [21]string{"0xb5", "0x6e", "0x06", "0xe7", "0xf1", "0xb2", "0xef", "0x9e", "0x92", "0xaf", "0xbc", "0xad", "0x80", "0xc6", "0x58", "0x7e", "0xd2", "0x18", "0xa5", "0x7b", "0x00"}}, - { - /* No.419 delta:1693 weight:1439 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0xea68a7ff, 0x03799b91, 0xe9113c6e, 0x92f01a33, 0x7898bdcc, 0x918981a2, 0x7be1265d, 0x0000e0b0, 0xea68474f, 0x03797b21, 0xe911dcde, 0x92f0fa83, 0x78985d7c, 0x91896112, 0x7be1c6ed}, - [16]uint32{0x00000000, 0x283e821a, 0x00520054, 0x286c824e, 0x00020036, 0x283c822c, 0x00500062, 0x286e8278, 0x401000a7, 0x682e82bd, 0x404200f3, 0x687c82e9, 0x40120091, 0x682c828b, 0x404000c5, 0x687e82df}, - [16]uint32{0x3f800000, 0x3f941f41, 0x3f802900, 0x3f943641, 0x3f800100, 0x3f941e41, 0x3f802800, 0x3f943741, 0x3fa00800, 0x3fb41741, 0x3fa02100, 0x3fb43e41, 0x3fa00900, 0x3fb41641, 0x3fa02000, 0x3fb43f41}, - uint32(0xfff80000), - [21]string{"0x3d", "0x08", "0x4c", "0x67", "0xfc", "0x9c", "0x48", "0xe9", "0x46", "0x4b", "0x9a", "0xc0", "0x56", "0xd4", "0x48", "0xbf", "0x57", "0x04", "0x85", "0x7b", "0x00"}}, - { - /* No.420 delta:795 weight:1591 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0x255d4f5c, 0x5cd2db7e, 0x798f9422, 0xa9201a4f, 0x8c7d5513, 0xf5f2c131, 0xd0af8e6d, 0x0000cb40, 0x255d841c, 0x5cd2103e, 0x798f5f62, 0xa920d10f, 0x8c7d9e53, 0xf5f20a71, 0xd0af452d}, - [16]uint32{0x00000000, 0x5021117e, 0x084011f9, 0x58610087, 0x9000001a, 0xc0211164, 0x984011e3, 0xc861009d, 0x40020cb7, 0x10231dc9, 0x48421d4e, 0x18630c30, 0xd0020cad, 0x80231dd3, 0xd8421d54, 0x88630c2a}, - [16]uint32{0x3f800000, 0x3fa81088, 0x3f842008, 0x3fac3080, 0x3fc80000, 0x3fe01088, 0x3fcc2008, 0x3fe43080, 0x3fa00106, 0x3f88118e, 0x3fa4210e, 0x3f8c3186, 0x3fe80106, 0x3fc0118e, 0x3fec210e, 0x3fc43186}, - uint32(0xfff80000), - [21]string{"0x74", "0x32", "0x9a", "0x95", "0xe8", "0xe5", "0x81", "0x16", "0x6f", "0x6f", "0x8c", "0x54", "0xef", "0xc7", "0x6d", "0x3c", "0xe4", "0x6d", "0xb0", "0x78", "0x00"}}, - { - /* No.421 delta:1100 weight:1723 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x37fb03b4, 0xdf064fab, 0xe8fd4c1f, 0xdf801a56, 0xe87b19e2, 0x008655fd, 0x377d5649, 0x000089fe, 0x37fb8a4a, 0xdf06c655, 0xe8fdc5e1, 0xdf8093a8, 0xe87b901c, 0x0086dc03, 0x377ddfb7}, - [16]uint32{0x00000000, 0x00448097, 0x1002018c, 0x1046811b, 0x000260ef, 0x0046e078, 0x10006163, 0x1044e1f4, 0x0003e1bc, 0x0047612b, 0x1001e030, 0x104560a7, 0x00018153, 0x004501c4, 0x100380df, 0x10470048}, - [16]uint32{0x3f800000, 0x3f802240, 0x3f880100, 0x3f882340, 0x3f800130, 0x3f802370, 0x3f880030, 0x3f882270, 0x3f8001f0, 0x3f8023b0, 0x3f8800f0, 0x3f8822b0, 0x3f8000c0, 0x3f802280, 0x3f8801c0, 0x3f882380}, - uint32(0xfff80000), - [21]string{"0xce", "0xc9", "0x70", "0x4d", "0x28", "0x45", "0xcd", "0x59", "0x03", "0x6b", "0x34", "0x1c", "0xc7", "0x4b", "0xe8", "0x03", "0x11", "0x1a", "0x99", "0xd3", "0x00"}}, - { - /* No.422 delta:814 weight:1609 */ - 11213, - 81, - 13, - 4, - [16]uint32{0x00000000, 0x3863afab, 0x2366d254, 0x1b057dff, 0xc9301a6b, 0xf153b5c0, 0xea56c83f, 0xd2356794, 0x0000630c, 0x3863cca7, 0x2366b158, 0x1b051ef3, 0xc9307967, 0xf153d6cc, 0xea56ab33, 0xd2350498}, - [16]uint32{0x00000000, 0x80005053, 0x402000ba, 0xc02050e9, 0x4003e077, 0xc003b024, 0x0023e0cd, 0x8023b09e, 0x50000118, 0xd000514b, 0x102001a2, 0x902051f1, 0x1003e16f, 0x9003b13c, 0x5023e1d5, 0xd023b186}, - [16]uint32{0x3f800000, 0x3fc00028, 0x3fa01000, 0x3fe01028, 0x3fa001f0, 0x3fe001d8, 0x3f8011f0, 0x3fc011d8, 0x3fa80000, 0x3fe80028, 0x3f881000, 0x3fc81028, 0x3f8801f0, 0x3fc801d8, 0x3fa811f0, 0x3fe811d8}, - uint32(0xfff80000), - [21]string{"0xe1", "0x6e", "0xa6", "0x29", "0xce", "0xac", "0x56", "0x2c", "0x51", "0xf5", "0xed", "0x2b", "0x0c", "0xa5", "0x65", "0xf4", "0xb5", "0xae", "0x43", "0x81", "0x00"}}, - { - /* No.423 delta:804 weight:1751 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x37fb03b4, 0xdf064fab, 0xe8fd4c1f, 0xdf801a76, 0xe87b19c2, 0x008655dd, 0x377d5669, 0x000089fe, 0x37fb8a4a, 0xdf06c655, 0xe8fdc5e1, 0xdf809388, 0xe87b903c, 0x0086dc23, 0x377ddf97}, - [16]uint32{0x00000000, 0x20016137, 0x1002543b, 0x3003350c, 0x50008425, 0x7001e512, 0x4002d01e, 0x6003b129, 0x4400a80f, 0x6401c938, 0x5402fc34, 0x74039d03, 0x14002c2a, 0x34014d1d, 0x04027811, 0x24031926}, - [16]uint32{0x3f800000, 0x3f9000b0, 0x3f88012a, 0x3f98019a, 0x3fa80042, 0x3fb800f2, 0x3fa00168, 0x3fb001d8, 0x3fa20054, 0x3fb200e4, 0x3faa017e, 0x3fba01ce, 0x3f8a0016, 0x3f9a00a6, 0x3f82013c, 0x3f92018c}, - uint32(0xfff80000), - [21]string{"0x3c", "0x2c", "0x9b", "0xc9", "0xdb", "0x8e", "0x3d", "0x36", "0x5d", "0xdf", "0xa0", "0xeb", "0x2c", "0x11", "0x71", "0xa9", "0xc5", "0xb3", "0x48", "0x7e", "0x00"}}, - { - /* No.424 delta:3104 weight:631 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xd90825a7, 0x47df8dbf, 0x9ed7a818, 0x45701a8e, 0x9c783f29, 0x02af9731, 0xdba7b296, 0x00002d8c, 0xd908082b, 0x47dfa033, 0x9ed78594, 0x45703702, 0x9c7812a5, 0x02afbabd, 0xdba79f1a}, - [16]uint32{0x00000000, 0xfd6002c1, 0x10b500c3, 0xedd50202, 0x4049100d, 0xbd2912cc, 0x50fc10ce, 0xad9c120f, 0xd000e011, 0x2d60e2d0, 0xc0b5e0d2, 0x3dd5e213, 0x9049f01c, 0x6d29f2dd, 0x80fcf0df, 0x7d9cf21e}, - [16]uint32{0x3f800000, 0x3ffeb001, 0x3f885a80, 0x3ff6ea81, 0x3fa02488, 0x3fde9489, 0x3fa87e08, 0x3fd6ce09, 0x3fe80070, 0x3f96b071, 0x3fe05af0, 0x3f9eeaf1, 0x3fc824f8, 0x3fb694f9, 0x3fc07e78, 0x3fbece79}, - uint32(0xfff80000), - [21]string{"0x15", "0x8e", "0x88", "0xbb", "0xf9", "0x37", "0x89", "0xe6", "0xd7", "0x5b", "0xc9", "0xfd", "0x54", "0x36", "0x12", "0x84", "0x7d", "0x9a", "0x74", "0x37", "0x00"}}, - { - /* No.425 delta:1053 weight:1527 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0x6b29794b, 0x0da3033f, 0x668a7a74, 0xc3101a90, 0xa83963db, 0xceb319af, 0xa59a60e4, 0x00002517, 0x6b295c5c, 0x0da32628, 0x668a5f63, 0xc3103f87, 0xa83946cc, 0xceb33cb8, 0xa59a45f3}, - [16]uint32{0x00000000, 0x804180de, 0x40440539, 0xc00585e7, 0x20404108, 0xa001c1d6, 0x60044431, 0xe045c4ef, 0x20702015, 0xa031a0cb, 0x6034252c, 0xe075a5f2, 0x0030611d, 0x8071e1c3, 0x40746424, 0xc035e4fa}, - [16]uint32{0x3f800000, 0x3fc020c0, 0x3fa02202, 0x3fe002c2, 0x3f902020, 0x3fd000e0, 0x3fb00222, 0x3ff022e2, 0x3f903810, 0x3fd018d0, 0x3fb01a12, 0x3ff03ad2, 0x3f801830, 0x3fc038f0, 0x3fa03a32, 0x3fe01af2}, - uint32(0xfff80000), - [21]string{"0xe9", "0x03", "0xeb", "0x9e", "0x61", "0xab", "0xc2", "0x9b", "0x13", "0x95", "0xb0", "0x67", "0x7d", "0x21", "0x0a", "0xc5", "0x77", "0xe9", "0xe1", "0x5b", "0x00"}}, - { - /* No.426 delta:894 weight:1671 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x7516d380, 0x0bb65d81, 0x7ea08e01, 0x3b101aa3, 0x4e06c923, 0x30a64722, 0x45b094a2, 0x000040e3, 0x75169363, 0x0bb61d62, 0x7ea0cee2, 0x3b105a40, 0x4e0689c0, 0x30a607c1, 0x45b0d441}, - [16]uint32{0x00000000, 0x4016c0d6, 0x0041403c, 0x405780ea, 0x0002460f, 0x401486d9, 0x00430633, 0x4055c6e5, 0x1005041b, 0x5013c4cd, 0x10444427, 0x505284f1, 0x10074214, 0x501182c2, 0x10460228, 0x5050c2fe}, - [16]uint32{0x3f800000, 0x3fa00b60, 0x3f8020a0, 0x3fa02bc0, 0x3f800123, 0x3fa00a43, 0x3f802183, 0x3fa02ae3, 0x3f880282, 0x3fa809e2, 0x3f882222, 0x3fa82942, 0x3f8803a1, 0x3fa808c1, 0x3f882301, 0x3fa82861}, - uint32(0xfff80000), - [21]string{"0xdc", "0x93", "0x3f", "0x7f", "0x9a", "0x0e", "0xc2", "0xb9", "0x81", "0x8d", "0x3e", "0x41", "0x06", "0x30", "0xdf", "0x25", "0xa2", "0xec", "0x32", "0x10", "0x00"}}, - { - /* No.427 delta:1635 weight:1469 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x0e897e65, 0x138eb418, 0x1d07ca7d, 0x8f201abf, 0x81a964da, 0x9caeaea7, 0x9227d0c2, 0x00008a40, 0x0e89f425, 0x138e3e58, 0x1d07403d, 0x8f2090ff, 0x81a9ee9a, 0x9cae24e7, 0x92275a82}, - [16]uint32{0x00000000, 0x6e5c1116, 0x00052033, 0x6e593125, 0x1901809d, 0x775d918b, 0x1904a0ae, 0x7758b1b8, 0x1163c81a, 0x7f3fd90c, 0x1166e829, 0x7f3af93f, 0x08624887, 0x663e5991, 0x086768b4, 0x663b79a2}, - [16]uint32{0x3f800000, 0x3fb72e08, 0x3f800290, 0x3fb72c98, 0x3f8c80c0, 0x3fbbaec8, 0x3f8c8250, 0x3fbbac58, 0x3f88b1e4, 0x3fbf9fec, 0x3f88b374, 0x3fbf9d7c, 0x3f843124, 0x3fb31f2c, 0x3f8433b4, 0x3fb31dbc}, - uint32(0xfff80000), - [21]string{"0xe4", "0xfa", "0x76", "0x5f", "0xbf", "0x62", "0x4a", "0x27", "0x8a", "0xbe", "0xbd", "0x36", "0xae", "0xef", "0x0a", "0x51", "0x71", "0xbd", "0xbb", "0x53", "0x00"}}, - { - /* No.428 delta:2647 weight:869 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x43527f08, 0x9d9bc601, 0xdec9b909, 0x62d01ac0, 0x218265c8, 0xff4bdcc1, 0xbc19a3c9, 0x000031e0, 0x43524ee8, 0x9d9bf7e1, 0xdec988e9, 0x62d02b20, 0x21825428, 0xff4bed21, 0xbc199229}, - [16]uint32{0x00000000, 0xc0650c7a, 0x3860005f, 0xf8050c25, 0x0c18851c, 0xcc7d8966, 0x34788543, 0xf41d8939, 0x18204149, 0xd8454d33, 0x20404116, 0xe0254d6c, 0x1438c455, 0xd45dc82f, 0x2c58c40a, 0xec3dc870}, - [16]uint32{0x3f800000, 0x3fe03286, 0x3f9c3000, 0x3ffc0286, 0x3f860c42, 0x3fe63ec4, 0x3f9a3c42, 0x3ffa0ec4, 0x3f8c1020, 0x3fec22a6, 0x3f902020, 0x3ff012a6, 0x3f8a1c62, 0x3fea2ee4, 0x3f962c62, 0x3ff61ee4}, - uint32(0xfff80000), - [21]string{"0x93", "0x26", "0x3d", "0x15", "0xb2", "0xad", "0xa9", "0x17", "0x31", "0xc4", "0x4b", "0x19", "0xf2", "0xcd", "0x2a", "0x53", "0xf7", "0x46", "0x04", "0x86", "0x00"}}, - { - /* No.429 delta:574 weight:1741 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0x78bfa3bb, 0xb26daf1b, 0xcad20ca0, 0x8c901ad9, 0xf42fb962, 0x3efdb5c2, 0x46421679, 0x000057cd, 0x78bff476, 0xb26df8d6, 0xcad25b6d, 0x8c904d14, 0xf42feeaf, 0x3efde20f, 0x464241b4}, - [16]uint32{0x00000000, 0x407ec892, 0x0003b8cb, 0x407d7059, 0x00205005, 0x405e9897, 0x0023e8ce, 0x405d205c, 0x60100204, 0x206eca96, 0x6013bacf, 0x206d725d, 0x60305201, 0x204e9a93, 0x6033eaca, 0x204d2258}, - [16]uint32{0x3f800000, 0x3fa03f64, 0x3f8001dc, 0x3fa03eb8, 0x3f801028, 0x3fa02f4c, 0x3f8011f4, 0x3fa02e90, 0x3fb00801, 0x3f903765, 0x3fb009dd, 0x3f9036b9, 0x3fb01829, 0x3f90274d, 0x3fb019f5, 0x3f902691}, - uint32(0xfff80000), - [21]string{"0xf6", "0xa3", "0x4d", "0x6c", "0xcc", "0x76", "0xeb", "0x15", "0x04", "0xa7", "0xd2", "0x15", "0xe5", "0x85", "0xa1", "0x29", "0xed", "0x3a", "0xd8", "0x51", "0x00"}}, - { - /* No.430 delta:1044 weight:1679 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x7f3e4b3c, 0x3db50e58, 0x428b4564, 0xe4101aea, 0x9b2e51d6, 0xd9a514b2, 0xa69b5f8e, 0x0000d877, 0x7f3e934b, 0x3db5d62f, 0x428b9d13, 0xe410c29d, 0x9b2e89a1, 0xd9a5ccc5, 0xa69b87f9}, - [16]uint32{0x00000000, 0x101e1117, 0x41021eed, 0x511c0ffa, 0x0000106e, 0x101e0179, 0x41020e83, 0x511c1f94, 0x30230012, 0x203d1105, 0x71211eff, 0x613f0fe8, 0x3023107c, 0x203d016b, 0x71210e91, 0x613f1f86}, - [16]uint32{0x3f800000, 0x3f880f08, 0x3fa0810f, 0x3fa88e07, 0x3f800008, 0x3f880f00, 0x3fa08107, 0x3fa88e0f, 0x3f981180, 0x3f901e88, 0x3fb8908f, 0x3fb09f87, 0x3f981188, 0x3f901e80, 0x3fb89087, 0x3fb09f8f}, - uint32(0xfff80000), - [21]string{"0x31", "0x88", "0xd4", "0xfd", "0x08", "0xd5", "0x86", "0x97", "0xb7", "0xc8", "0xf4", "0xee", "0x84", "0x1e", "0x7a", "0x4d", "0x9c", "0x4b", "0xb3", "0xb0", "0x00"}}, - { - /* No.431 delta:987 weight:967 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0x2c1a5d06, 0x76bc8d6b, 0x5aa6d06d, 0x34c01af1, 0x18da47f7, 0x427c979a, 0x6e66ca9c, 0x0000659c, 0x2c1a389a, 0x76bce8f7, 0x5aa6b5f1, 0x34c07f6d, 0x18da226b, 0x427cf206, 0x6e66af00}, - [16]uint32{0x00000000, 0x006c313e, 0x00038909, 0x006fb837, 0x0401012c, 0x046d3012, 0x04028825, 0x046eb91b, 0x2032214d, 0x205e1073, 0x2031a844, 0x205d997a, 0x24332061, 0x245f115f, 0x2430a968, 0x245c9856}, - [16]uint32{0x3f800000, 0x3f803618, 0x3f8001c4, 0x3f8037dc, 0x3f820080, 0x3f823698, 0x3f820144, 0x3f82375c, 0x3f901910, 0x3f902f08, 0x3f9018d4, 0x3f902ecc, 0x3f921990, 0x3f922f88, 0x3f921854, 0x3f922e4c}, - uint32(0xfff80000), - [21]string{"0xa8", "0x3a", "0x69", "0x50", "0x5c", "0x5c", "0xa1", "0xaf", "0x0b", "0x54", "0xee", "0xb0", "0x76", "0x02", "0xae", "0x8b", "0x6e", "0x77", "0xe7", "0x55", "0x00"}}, - { - /* No.432 delta:1531 weight:1641 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x1adf62b5, 0x18570b8b, 0x0288693e, 0x89001b01, 0x93df79b4, 0x9157108a, 0x8b88723f, 0x000025aa, 0x1adf471f, 0x18572e21, 0x02884c94, 0x89003eab, 0x93df5c1e, 0x91573520, 0x8b885795}, - [16]uint32{0x00000000, 0x0e9e017a, 0x00610113, 0x0eff0069, 0x00580148, 0x0ec60032, 0x0039005b, 0x0ea70121, 0x0004e182, 0x0e9ae0f8, 0x0065e091, 0x0efbe1eb, 0x005ce0ca, 0x0ec2e1b0, 0x003de1d9, 0x0ea3e0a3}, - [16]uint32{0x3f800000, 0x3f874f00, 0x3f803080, 0x3f877f80, 0x3f802c00, 0x3f876300, 0x3f801c80, 0x3f875380, 0x3f800270, 0x3f874d70, 0x3f8032f0, 0x3f877df0, 0x3f802e70, 0x3f876170, 0x3f801ef0, 0x3f8751f0}, - uint32(0xfff80000), - [21]string{"0x8d", "0xe9", "0x17", "0xb7", "0x70", "0xfc", "0xcc", "0x88", "0xdc", "0x5e", "0x6c", "0x4d", "0x30", "0xdc", "0x8e", "0xf8", "0x2b", "0x2f", "0xf6", "0xb6", "0x00"}}, - { - /* No.433 delta:839 weight:1293 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x3bd71db2, 0x48ca34cb, 0x731d2979, 0x27101b15, 0x1cc706a7, 0x6fda2fde, 0x540d326c, 0x0000081e, 0x3bd715ac, 0x48ca3cd5, 0x731d2167, 0x2710130b, 0x1cc70eb9, 0x6fda27c0, 0x540d3a72}, - [16]uint32{0x00000000, 0x90630612, 0x004c00fb, 0x902f06e9, 0x0027c1aa, 0x9044c7b8, 0x006bc151, 0x9008c743, 0x1820532e, 0x8843553c, 0x186c53d5, 0x880f55c7, 0x18079284, 0x88649496, 0x184b927f, 0x8828946d}, - [16]uint32{0x3f800000, 0x3fc83183, 0x3f802600, 0x3fc81783, 0x3f8013e0, 0x3fc82263, 0x3f8035e0, 0x3fc80463, 0x3f8c1029, 0x3fc421aa, 0x3f8c3629, 0x3fc407aa, 0x3f8c03c9, 0x3fc4324a, 0x3f8c25c9, 0x3fc4144a}, - uint32(0xfff80000), - [21]string{"0xab", "0x47", "0x41", "0x3a", "0x1f", "0x1f", "0x5c", "0x24", "0x61", "0x69", "0x71", "0xa7", "0x97", "0xdd", "0xb6", "0xe9", "0x5e", "0x9f", "0xf3", "0x45", "0x00"}}, - { - /* No.434 delta:1393 weight:1441 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xd67e23e4, 0x16517cf4, 0xc02f5f10, 0x02f01b25, 0xd48e38c1, 0x14a167d1, 0xc2df4435, 0x00000830, 0xd67e2bd4, 0x165174c4, 0xc02f5720, 0x02f01315, 0xd48e30f1, 0x14a16fe1, 0xc2df4c05}, - [16]uint32{0x00000000, 0x205e48da, 0x402a61b7, 0x6074296d, 0x60288538, 0x4076cde2, 0x2002e48f, 0x005cac55, 0x404ab18b, 0x6014f951, 0x0060d03c, 0x203e98e6, 0x206234b3, 0x003c7c69, 0x60485504, 0x40161dde}, - [16]uint32{0x3f800000, 0x3f902f24, 0x3fa01530, 0x3fb03a14, 0x3fb01442, 0x3fa03b66, 0x3f900172, 0x3f802e56, 0x3fa02558, 0x3fb00a7c, 0x3f803068, 0x3f901f4c, 0x3f90311a, 0x3f801e3e, 0x3fb0242a, 0x3fa00b0e}, - uint32(0xfff80000), - [21]string{"0x31", "0xc3", "0x14", "0x4a", "0xc5", "0xa4", "0x7d", "0x37", "0x3e", "0x1b", "0xe0", "0x5a", "0x1c", "0x8e", "0x39", "0xf2", "0x4a", "0x5f", "0xe5", "0x18", "0x00"}}, - { - /* No.435 delta:1506 weight:1529 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0xe8f6d4d6, 0x1f9921a7, 0xf76ff571, 0xafa01b37, 0x4756cfe1, 0xb0393a90, 0x58cfee46, 0x0000e946, 0xe8f63d90, 0x1f99c8e1, 0xf76f1c37, 0xafa0f271, 0x475626a7, 0xb039d3d6, 0x58cf0700}, - [16]uint32{0x00000000, 0x2865415a, 0x4002c982, 0x686788d8, 0x3070e1d3, 0x1815a089, 0x70722851, 0x5817690b, 0x00687156, 0x280d300c, 0x406ab8d4, 0x680ff98e, 0x30189085, 0x187dd1df, 0x701a5907, 0x587f185d}, - [16]uint32{0x3f800000, 0x3f9432a0, 0x3fa00164, 0x3fb433c4, 0x3f983870, 0x3f8c0ad0, 0x3fb83914, 0x3fac0bb4, 0x3f803438, 0x3f940698, 0x3fa0355c, 0x3fb407fc, 0x3f980c48, 0x3f8c3ee8, 0x3fb80d2c, 0x3fac3f8c}, - uint32(0xfff80000), - [21]string{"0x30", "0xa9", "0xe2", "0x5b", "0xe5", "0xa1", "0x47", "0xfd", "0x4b", "0x6c", "0x8a", "0x14", "0x23", "0xe0", "0x8f", "0xef", "0xcb", "0xe8", "0x90", "0x2f", "0x00"}}, - { - /* No.436 delta:1226 weight:1523 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x557fb620, 0x6c5a80b0, 0x39253690, 0x42801b40, 0x17ffad60, 0x2eda9bf0, 0x7ba52dd0, 0x00005ec4, 0x557fe8e4, 0x6c5ade74, 0x39256854, 0x42804584, 0x17fff3a4, 0x2edac534, 0x7ba57314}, - [16]uint32{0x00000000, 0x006da17b, 0x400a6152, 0x4067c029, 0x0402009c, 0x046fa1e7, 0x440861ce, 0x4465c0b5, 0xd0106016, 0xd07dc16d, 0x901a0144, 0x9077a03f, 0xd412608a, 0xd47fc1f1, 0x941801d8, 0x9475a0a3}, - [16]uint32{0x3f800000, 0x3f8036d0, 0x3fa00530, 0x3fa033e0, 0x3f820100, 0x3f8237d0, 0x3fa20430, 0x3fa232e0, 0x3fe80830, 0x3fe83ee0, 0x3fc80d00, 0x3fc83bd0, 0x3fea0930, 0x3fea3fe0, 0x3fca0c00, 0x3fca3ad0}, - uint32(0xfff80000), - [21]string{"0x08", "0x12", "0xb6", "0xd0", "0x24", "0x49", "0xa5", "0x85", "0x4b", "0xb2", "0xf1", "0x9b", "0x2c", "0x64", "0xbf", "0xb1", "0x6f", "0xd1", "0xeb", "0xda", "0x00"}}, - { - /* No.437 delta:650 weight:1717 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0x36d515bc, 0x557945ab, 0x63ac5017, 0xb4701b5b, 0x82a50ee7, 0xe1095ef0, 0xd7dc4b4c, 0x0000845f, 0x36d591e3, 0x5579c1f4, 0x63acd448, 0xb4709f04, 0x82a58ab8, 0xe109daaf, 0xd7dccf13}, - [16]uint32{0x00000000, 0x2002b91b, 0x80006411, 0xa002dd0a, 0x400011d6, 0x6002a8cd, 0xc00075c7, 0xe002ccdc, 0x20011812, 0x0003a109, 0xa0017c03, 0x8003c518, 0x600109c4, 0x4003b0df, 0xe0016dd5, 0xc003d4ce}, - [16]uint32{0x3f800000, 0x3f90015c, 0x3fc00032, 0x3fd0016e, 0x3fa00008, 0x3fb00154, 0x3fe0003a, 0x3ff00166, 0x3f90008c, 0x3f8001d0, 0x3fd000be, 0x3fc001e2, 0x3fb00084, 0x3fa001d8, 0x3ff000b6, 0x3fe001ea}, - uint32(0xfff80000), - [21]string{"0x1e", "0x01", "0x6d", "0x92", "0x46", "0x9d", "0x77", "0x5f", "0x99", "0x39", "0x34", "0x1e", "0x83", "0xd4", "0x50", "0x06", "0xba", "0xf4", "0x06", "0xc5", "0x00"}}, - { - /* No.438 delta:768 weight:1315 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0xc4e1fbbb, 0x1f16f6c1, 0xdbf70d7a, 0xce201b6c, 0x0ac1e0d7, 0xd136edad, 0x15d71616, 0x00007f3f, 0xc4e18484, 0x1f1689fe, 0xdbf77245, 0xce206453, 0x0ac19fe8, 0xd1369292, 0x15d76929}, - [16]uint32{0x00000000, 0x40041072, 0x2029710b, 0x602d6179, 0x280400ed, 0x6800109f, 0x082d71e6, 0x48296194, 0x000081f0, 0x40049182, 0x2029f0fb, 0x602de089, 0x2804811d, 0x6800916f, 0x082df016, 0x4829e064}, - [16]uint32{0x3f800000, 0x3fa00208, 0x3f9014b8, 0x3fb016b0, 0x3f940200, 0x3fb40008, 0x3f8416b8, 0x3fa414b0, 0x3f800040, 0x3fa00248, 0x3f9014f8, 0x3fb016f0, 0x3f940240, 0x3fb40048, 0x3f8416f8, 0x3fa414f0}, - uint32(0xfff80000), - [21]string{"0xb5", "0x2e", "0xf9", "0xc4", "0x1f", "0x96", "0x80", "0x45", "0xea", "0x23", "0x83", "0x02", "0x10", "0x9c", "0x4e", "0x87", "0xf1", "0x13", "0xd8", "0xc5", "0x00"}}, - { - /* No.439 delta:1209 weight:1595 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0xd0453d45, 0xa2f377d4, 0x72b64a91, 0x4ed01b75, 0x9e952630, 0xec236ca1, 0x3c6651e4, 0x00006db6, 0xd04550f3, 0xa2f31a62, 0x72b62727, 0x4ed076c3, 0x9e954b86, 0xec230117, 0x3c663c52}, - [16]uint32{0x00000000, 0xc00de97a, 0x020145e3, 0xc20cac99, 0x405ce122, 0x80510858, 0x425da4c1, 0x82504dbb, 0x00609dfe, 0xc06d7484, 0x0261d81d, 0xc26c3167, 0x403c7cdc, 0x803195a6, 0x423d393f, 0x8230d045}, - [16]uint32{0x3f800000, 0x3fe006f4, 0x3f8100a2, 0x3fe10656, 0x3fa02e70, 0x3fc02884, 0x3fa12ed2, 0x3fc12826, 0x3f80304e, 0x3fe036ba, 0x3f8130ec, 0x3fe13618, 0x3fa01e3e, 0x3fc018ca, 0x3fa11e9c, 0x3fc11868}, - uint32(0xfff80000), - [21]string{"0x16", "0xcc", "0xdf", "0x96", "0x0d", "0x0c", "0x8d", "0x9d", "0x4c", "0xe0", "0xb7", "0x30", "0xd3", "0xe2", "0xba", "0xde", "0x4f", "0xd2", "0x13", "0xb1", "0x00"}}, - { - /* No.440 delta:661 weight:1719 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0xecde6bb9, 0x18155470, 0xf4cb3fc9, 0x03e01b89, 0xef3e7030, 0x1bf54ff9, 0xf72b2440, 0x0000d089, 0xecdebb30, 0x181584f9, 0xf4cbef40, 0x03e0cb00, 0xef3ea0b9, 0x1bf59f70, 0xf72bf4c9}, - [16]uint32{0x00000000, 0xb0078c1a, 0x2022e34f, 0x90256f55, 0x00020012, 0xb0058c08, 0x2020e35d, 0x90276f47, 0x10601010, 0xa0679c0a, 0x3042f35f, 0x80457f45, 0x10621002, 0xa0659c18, 0x3040f34d, 0x80477f57}, - [16]uint32{0x3f800000, 0x3fd803c6, 0x3f901171, 0x3fc812b7, 0x3f800100, 0x3fd802c6, 0x3f901071, 0x3fc813b7, 0x3f883008, 0x3fd033ce, 0x3f982179, 0x3fc022bf, 0x3f883108, 0x3fd032ce, 0x3f982079, 0x3fc023bf}, - uint32(0xfff80000), - [21]string{"0x02", "0x84", "0xb3", "0x29", "0xd9", "0x66", "0x77", "0xde", "0xd3", "0xde", "0x2c", "0x98", "0xba", "0x8d", "0xd0", "0x9f", "0xa3", "0xa5", "0xa6", "0x62", "0x00"}}, - { - /* No.441 delta:896 weight:1197 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0x74b73a0a, 0x02330f4f, 0x76843545, 0x6ff01b95, 0x1b47219f, 0x6dc314da, 0x19742ed0, 0x000064da, 0x74b75ed0, 0x02336b95, 0x7684519f, 0x6ff07f4f, 0x1b474545, 0x6dc37000, 0x19744a0a}, - [16]uint32{0x00000000, 0x100f7056, 0x40229c0d, 0x502dec5b, 0x106a00f9, 0x006570af, 0x50489cf4, 0x4047eca2, 0x000283c1, 0x100df397, 0x40201fcc, 0x502f6f9a, 0x10688338, 0x0067f36e, 0x504a1f35, 0x40456f63}, - [16]uint32{0x3f800000, 0x3f8807b8, 0x3fa0114e, 0x3fa816f6, 0x3f883500, 0x3f8032b8, 0x3fa8244e, 0x3fa023f6, 0x3f800141, 0x3f8806f9, 0x3fa0100f, 0x3fa817b7, 0x3f883441, 0x3f8033f9, 0x3fa8250f, 0x3fa022b7}, - uint32(0xfff80000), - [21]string{"0x8f", "0x1e", "0x77", "0x99", "0xde", "0x44", "0x8e", "0x66", "0xcc", "0x6e", "0x8e", "0xfa", "0xe2", "0xdf", "0x89", "0x94", "0x86", "0xbd", "0x7f", "0xfb", "0x00"}}, - { - /* No.442 delta:1044 weight:1603 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0xf2acd20d, 0x2e78f6ac, 0xdcd424a1, 0x11c01ba2, 0xe36cc9af, 0x3fb8ed0e, 0xcd143f03, 0x00003333, 0xf2ace13e, 0x2e78c59f, 0xdcd41792, 0x11c02891, 0xe36cfa9c, 0x3fb8de3d, 0xcd140c30}, - [16]uint32{0x00000000, 0x600423fa, 0x300230fc, 0x50061306, 0x3001c0a3, 0x5005e359, 0x0003f05f, 0x6007d3a5, 0x1403b116, 0x740792ec, 0x240181ea, 0x4405a210, 0x240271b5, 0x4406524f, 0x14004149, 0x740462b3}, - [16]uint32{0x3f800000, 0x3fb00211, 0x3f980118, 0x3fa80309, 0x3f9800e0, 0x3fa802f1, 0x3f8001f8, 0x3fb003e9, 0x3f8a01d8, 0x3fba03c9, 0x3f9200c0, 0x3fa202d1, 0x3f920138, 0x3fa20329, 0x3f8a0020, 0x3fba0231}, - uint32(0xfff80000), - [21]string{"0x61", "0x3f", "0x9c", "0x01", "0xef", "0xb0", "0xd2", "0x20", "0x2e", "0x27", "0xf6", "0xbd", "0x73", "0xbc", "0x66", "0x3a", "0x0b", "0xac", "0x78", "0xe5", "0x00"}}, - { - /* No.443 delta:1046 weight:1629 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x142cd4e2, 0x5c38fde5, 0x48142907, 0x7a401bb1, 0x6e6ccf53, 0x2678e654, 0x325432b6, 0x0000fb50, 0x142c2fb2, 0x5c3806b5, 0x4814d257, 0x7a40e0e1, 0x6e6c3403, 0x26781d04, 0x3254c9e6}, - [16]uint32{0x00000000, 0x004de1de, 0x800ec185, 0x8043205b, 0x000200b4, 0x004fe16a, 0x800cc131, 0x804120ef, 0x240c001d, 0x2441e1c3, 0xa402c198, 0xa44f2046, 0x240e00a9, 0x2443e177, 0xa400c12c, 0xa44d20f2}, - [16]uint32{0x3f800000, 0x3f8026f0, 0x3fc00760, 0x3fc02190, 0x3f800100, 0x3f8027f0, 0x3fc00660, 0x3fc02090, 0x3f920600, 0x3f9220f0, 0x3fd20160, 0x3fd22790, 0x3f920700, 0x3f9221f0, 0x3fd20060, 0x3fd22690}, - uint32(0xfff80000), - [21]string{"0x65", "0x13", "0x59", "0x24", "0xc4", "0xfb", "0xe5", "0xe6", "0xe1", "0x9a", "0x95", "0x21", "0xdb", "0x47", "0x93", "0x4d", "0xd3", "0xb3", "0x91", "0xcc", "0x00"}}, - { - /* No.444 delta:669 weight:1447 */ - 11213, - 81, - 13, - 4, - [16]uint32{0x00000000, 0x053e5913, 0xae3d13ce, 0xab034add, 0x5ae01bc7, 0x5fde42d4, 0xf4dd0809, 0xf1e3511a, 0x0000b142, 0x053ee851, 0xae3da28c, 0xab03fb9f, 0x5ae0aa85, 0x5fdef396, 0xf4ddb94b, 0xf1e3e058}, - [16]uint32{0x00000000, 0x3001c83d, 0x20032cc9, 0x1002e4f4, 0x0002349a, 0x3003fca7, 0x20011853, 0x1000d06e, 0x6000001c, 0x5001c821, 0x40032cd5, 0x7002e4e8, 0x60023486, 0x5003fcbb, 0x4001184f, 0x7000d072}, - [16]uint32{0x3f800000, 0x3f9800e4, 0x3f900196, 0x3f880172, 0x3f80011a, 0x3f9801fe, 0x3f90008c, 0x3f880068, 0x3fb00000, 0x3fa800e4, 0x3fa00196, 0x3fb80172, 0x3fb0011a, 0x3fa801fe, 0x3fa0008c, 0x3fb80068}, - uint32(0xfff80000), - [21]string{"0x2b", "0x33", "0x3a", "0xe8", "0xf0", "0x8a", "0xb9", "0xc8", "0x97", "0xec", "0xc2", "0xca", "0x81", "0x45", "0x89", "0x05", "0xd4", "0x8b", "0x2e", "0xa9", "0x00"}}, - { - /* No.445 delta:1946 weight:1335 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0x1c4b156c, 0x39a6b0f0, 0x25eda59c, 0x91b01bd0, 0x8dfb0ebc, 0xa816ab20, 0xb45dbe4c, 0x00004b50, 0x1c4b5e3c, 0x39a6fba0, 0x25edeecc, 0x91b05080, 0x8dfb45ec, 0xa816e070, 0xb45df51c}, - [16]uint32{0x00000000, 0x0a958997, 0x0f02a212, 0x05972b85, 0x00801026, 0x0a1599b1, 0x0f82b234, 0x05173ba3, 0x44180c15, 0x4e8d8582, 0x4b1aae07, 0x418f2790, 0x44981c33, 0x4e0d95a4, 0x4b9abe21, 0x410f37b6}, - [16]uint32{0x3f800000, 0x3f854ac4, 0x3f878151, 0x3f82cb95, 0x3f804008, 0x3f850acc, 0x3f87c159, 0x3f828b9d, 0x3fa20c06, 0x3fa746c2, 0x3fa58d57, 0x3fa0c793, 0x3fa24c0e, 0x3fa706ca, 0x3fa5cd5f, 0x3fa0879b}, - uint32(0xfff80000), - [21]string{"0x16", "0x8a", "0x65", "0x8e", "0x09", "0x67", "0xbe", "0x3b", "0xba", "0x27", "0xec", "0xf7", "0xa1", "0x87", "0x82", "0x1b", "0x4e", "0xea", "0x8d", "0x1f", "0x00"}}, - { - /* No.446 delta:2283 weight:1213 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x196d7152, 0x70b7638d, 0x69da12df, 0x0f501be1, 0x163d6ab3, 0x7fe7786c, 0x668a093e, 0x00005fc3, 0x196d2e91, 0x70b73c4e, 0x69da4d1c, 0x0f504422, 0x163d3570, 0x7fe727af, 0x668a56fd}, - [16]uint32{0x00000000, 0x241580d6, 0x22100542, 0x06058594, 0x19c021dc, 0x3dd5a10a, 0x3bd0249e, 0x1fc5a448, 0x0c160027, 0x280380f1, 0x2e060565, 0x0a1385b3, 0x15d621fb, 0x31c3a12d, 0x37c624b9, 0x13d3a46f}, - [16]uint32{0x3f800000, 0x3f920ac0, 0x3f910802, 0x3f8302c2, 0x3f8ce010, 0x3f9eead0, 0x3f9de812, 0x3f8fe2d2, 0x3f860b00, 0x3f9401c0, 0x3f970302, 0x3f8509c2, 0x3f8aeb10, 0x3f98e1d0, 0x3f9be312, 0x3f89e9d2}, - uint32(0xfff80000), - [21]string{"0xe0", "0x34", "0x97", "0x6e", "0x7b", "0xab", "0x93", "0x95", "0xb6", "0x3c", "0x37", "0x45", "0x72", "0xbf", "0xbd", "0x20", "0xa9", "0x0e", "0x06", "0x5b", "0x00"}}, - { - /* No.447 delta:940 weight:1651 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x378ab458, 0x999d98e1, 0xae172cb9, 0x17b01bfc, 0x203aafa4, 0x8e2d831d, 0xb9a73745, 0x000086af, 0x378a32f7, 0x999d1e4e, 0xae17aa16, 0x17b09d53, 0x203a290b, 0x8e2d05b2, 0xb9a7b1ea}, - [16]uint32{0x00000000, 0x80009816, 0x400c0eac, 0xc00c96ba, 0x00139604, 0x80130e12, 0x401f98a8, 0xc01f00be, 0x00031418, 0x80038c0e, 0x400f1ab4, 0xc00f82a2, 0x0010821c, 0x80101a0a, 0x401c8cb0, 0xc01c14a6}, - [16]uint32{0x3f800000, 0x3fc0004c, 0x3fa00607, 0x3fe0064b, 0x3f8009cb, 0x3fc00987, 0x3fa00fcc, 0x3fe00f80, 0x3f80018a, 0x3fc001c6, 0x3fa0078d, 0x3fe007c1, 0x3f800841, 0x3fc0080d, 0x3fa00e46, 0x3fe00e0a}, - uint32(0xfff80000), - [21]string{"0xe7", "0x7e", "0x5f", "0x3f", "0x63", "0x46", "0xb4", "0x5e", "0x55", "0xe4", "0xbe", "0x63", "0x84", "0x07", "0x66", "0x97", "0x54", "0x8d", "0x57", "0xc8", "0x00"}}, - { - /* No.448 delta:773 weight:1505 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x887f6254, 0x5c60053c, 0xd41f6768, 0x5c701c0b, 0xd40f7e5f, 0x00101937, 0x886f7b63, 0x000077da, 0x887f158e, 0x5c6072e6, 0xd41f10b2, 0x5c706bd1, 0xd40f0985, 0x00106eed, 0x886f0cb9}, - [16]uint32{0x00000000, 0xc102113a, 0x2081016d, 0xe1831057, 0xa00031de, 0x610220e4, 0x808130b3, 0x41832189, 0x4000601d, 0x81027127, 0x60816170, 0xa183704a, 0xe00051c3, 0x210240f9, 0xc08150ae, 0x01834194}, - [16]uint32{0x3f800000, 0x3fe08108, 0x3f904080, 0x3ff0c188, 0x3fd00018, 0x3fb08110, 0x3fc04098, 0x3fa0c190, 0x3fa00030, 0x3fc08138, 0x3fb040b0, 0x3fd0c1b8, 0x3ff00028, 0x3f908120, 0x3fe040a8, 0x3f80c1a0}, - uint32(0xfff80000), - [21]string{"0x52", "0x3b", "0xa8", "0xb8", "0xa4", "0x44", "0xdb", "0x43", "0xd2", "0xa1", "0xd3", "0xd4", "0x80", "0x7e", "0x9e", "0xeb", "0x10", "0x02", "0xa7", "0x3d", "0x00"}}, - { - /* No.449 delta:1695 weight:1347 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x5e96a7dd, 0xd58d224d, 0x8b1b8590, 0xd4801c15, 0x8a16bbc8, 0x010d3e58, 0x5f9b9985, 0x000052a0, 0x5e96f57d, 0xd58d70ed, 0x8b1bd730, 0xd4804eb5, 0x8a16e968, 0x010d6cf8, 0x5f9bcb25}, - [16]uint32{0x00000000, 0x8045a132, 0x004e104c, 0x800bb17e, 0x530821a9, 0xd34d809b, 0x534631e5, 0xd30390d7, 0x0d207078, 0x8d65d14a, 0x0d6e6034, 0x8d2bc106, 0x5e2851d1, 0xde6df0e3, 0x5e66419d, 0xde23e0af}, - [16]uint32{0x3f800000, 0x3fc022d0, 0x3f802708, 0x3fc005d8, 0x3fa98410, 0x3fe9a6c0, 0x3fa9a318, 0x3fe981c8, 0x3f869038, 0x3fc6b2e8, 0x3f86b730, 0x3fc695e0, 0x3faf1428, 0x3fef36f8, 0x3faf3320, 0x3fef11f0}, - uint32(0xfff80000), - [21]string{"0xc3", "0xbf", "0x9f", "0xb6", "0xc5", "0x31", "0x9b", "0x86", "0x9a", "0x6d", "0x96", "0x67", "0x5b", "0xec", "0x24", "0xb7", "0x3e", "0xd3", "0xe0", "0x07", "0x00"}}, - { - /* No.450 delta:1302 weight:1591 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x91534dd5, 0x8670ccfb, 0x1723812e, 0xdab01c26, 0x4be351f3, 0x5cc0d0dd, 0xcd939d08, 0x0000308b, 0x91537d5e, 0x8670fc70, 0x1723b1a5, 0xdab02cad, 0x4be36178, 0x5cc0e056, 0xcd93ad83}, - [16]uint32{0x00000000, 0x0065417c, 0x240e846e, 0x246bc512, 0x00222089, 0x004761f5, 0x242ca4e7, 0x2449e59b, 0x2010003d, 0x20754141, 0x041e8453, 0x047bc52f, 0x203220b4, 0x205761c8, 0x043ca4da, 0x0459e5a6}, - [16]uint32{0x3f800000, 0x3f8032a0, 0x3f920742, 0x3f9235e2, 0x3f801110, 0x3f8023b0, 0x3f921652, 0x3f9224f2, 0x3f900800, 0x3f903aa0, 0x3f820f42, 0x3f823de2, 0x3f901910, 0x3f902bb0, 0x3f821e52, 0x3f822cf2}, - uint32(0xfff80000), - [21]string{"0x67", "0x48", "0x0f", "0xce", "0x04", "0x1c", "0x7a", "0x4a", "0xb8", "0xdb", "0xa3", "0x1f", "0x34", "0x33", "0xac", "0x96", "0x18", "0x13", "0xb5", "0x20", "0x00"}}, - { - /* No.451 delta:774 weight:1351 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0x8dfdec88, 0x42759c86, 0xcf88700e, 0xd7801c3e, 0x5a7df0b6, 0x95f580b8, 0x18086c30, 0x0000426d, 0x8dfdaee5, 0x4275deeb, 0xcf883263, 0xd7805e53, 0x5a7db2db, 0x95f5c2d5, 0x18082e5d}, - [16]uint32{0x00000000, 0x0f951152, 0x004a4883, 0x0fdf59d1, 0x00321c17, 0x0fa70d45, 0x00785494, 0x0fed45c6, 0x5618001a, 0x598d1148, 0x56524899, 0x59c759cb, 0x562a1c0d, 0x59bf0d5f, 0x5660548e, 0x59f545dc}, - [16]uint32{0x3f800000, 0x3f87ca88, 0x3f802524, 0x3f87efac, 0x3f80190e, 0x3f87d386, 0x3f803c2a, 0x3f87f6a2, 0x3fab0c00, 0x3facc688, 0x3fab2924, 0x3face3ac, 0x3fab150e, 0x3facdf86, 0x3fab302a, 0x3facfaa2}, - uint32(0xfff80000), - [21]string{"0xad", "0x39", "0x35", "0x49", "0x70", "0xc4", "0xa9", "0x33", "0x85", "0xa8", "0x0b", "0x37", "0x54", "0x33", "0xbb", "0x71", "0x02", "0xa4", "0x96", "0xea", "0x00"}}, - { - /* No.452 delta:726 weight:1365 */ - 11213, - 64, - 13, - 4, - [16]uint32{0x00000000, 0x9be3fbc9, 0x04688a47, 0x9f8b718e, 0x47d01c47, 0xdc33e78e, 0x43b89600, 0xd85b6dc9, 0x00008529, 0x9be37ee0, 0x04680f6e, 0x9f8bf4a7, 0x47d0996e, 0xdc3362a7, 0x43b81329, 0xd85be8e0}, - [16]uint32{0x00000000, 0x6101697a, 0x24001fbe, 0x450176c4, 0x0002101d, 0x61037967, 0x24020fa3, 0x450366d9, 0x3005cccf, 0x5104a5b5, 0x1405d371, 0x7504ba0b, 0x3007dcd2, 0x5106b5a8, 0x1407c36c, 0x7506aa16}, - [16]uint32{0x3f800000, 0x3fb080b4, 0x3f92000f, 0x3fa280bb, 0x3f800108, 0x3fb081bc, 0x3f920107, 0x3fa281b3, 0x3f9802e6, 0x3fa88252, 0x3f8a02e9, 0x3fba825d, 0x3f9803ee, 0x3fa8835a, 0x3f8a03e1, 0x3fba8355}, - uint32(0xfff80000), - [21]string{"0xd1", "0xa0", "0x4f", "0x52", "0xcc", "0x74", "0xcd", "0x0d", "0xf0", "0x50", "0xda", "0x06", "0xe6", "0x16", "0xb3", "0x08", "0x75", "0x4e", "0xa7", "0xe1", "0x00"}}, - { - /* No.453 delta:977 weight:1675 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x3202f4e6, 0xbba89e7a, 0x89aa6a9c, 0x26a01c5e, 0x14a2e8b8, 0x9d088224, 0xaf0a76c2, 0x0000ce49, 0x32023aaf, 0xbba85033, 0x89aaa4d5, 0x26a0d217, 0x14a226f1, 0x9d084c6d, 0xaf0ab88b}, - [16]uint32{0x00000000, 0x6872097f, 0x000320e5, 0x6871299a, 0x00710056, 0x68030929, 0x007220b3, 0x680029cc, 0xa001881b, 0xc8738164, 0xa002a8fe, 0xc870a181, 0xa070884d, 0xc8028132, 0xa073a8a8, 0xc801a1d7}, - [16]uint32{0x3f800000, 0x3fb43904, 0x3f800190, 0x3fb43894, 0x3f803880, 0x3fb40184, 0x3f803910, 0x3fb40014, 0x3fd000c4, 0x3fe439c0, 0x3fd00154, 0x3fe43850, 0x3fd03844, 0x3fe40140, 0x3fd039d4, 0x3fe400d0}, - uint32(0xfff80000), - [21]string{"0x9a", "0x39", "0x76", "0xe0", "0x00", "0xe4", "0xad", "0x40", "0x6d", "0xbc", "0x26", "0x84", "0xc1", "0x11", "0x26", "0x3e", "0x39", "0x81", "0x75", "0x5e", "0x00"}}, - { - /* No.454 delta:2877 weight:859 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0xb26c64aa, 0x948e3b5e, 0x26e25ff4, 0x66a01c69, 0xd4cc78c3, 0xf22e2737, 0x4042439d, 0x0000d341, 0xb26cb7eb, 0x948ee81f, 0x26e28cb5, 0x66a0cf28, 0xd4ccab82, 0xf22ef476, 0x404290dc}, - [16]uint32{0x00000000, 0xe5365b96, 0x0d2c001c, 0xe81a5b8a, 0x0fd203f1, 0xeae45867, 0x02fe03ed, 0xe7c8587b, 0x8004461e, 0x65321d88, 0x8d284602, 0x681e1d94, 0x8fd645ef, 0x6ae01e79, 0x82fa45f3, 0x67cc1e65}, - [16]uint32{0x3f800000, 0x3ff29b2d, 0x3f869600, 0x3ff40d2d, 0x3f87e901, 0x3ff5722c, 0x3f817f01, 0x3ff3e42c, 0x3fc00223, 0x3fb2990e, 0x3fc69423, 0x3fb40f0e, 0x3fc7eb22, 0x3fb5700f, 0x3fc17d22, 0x3fb3e60f}, - uint32(0xfff80000), - [21]string{"0xc1", "0x8a", "0x93", "0xc3", "0x26", "0x42", "0x3a", "0xdc", "0x79", "0xb1", "0x2a", "0x11", "0xd4", "0xac", "0xc3", "0xf9", "0xfa", "0x71", "0x61", "0x9a", "0x00"}}, - { - /* No.455 delta:681 weight:1617 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0xe9a7fd5d, 0x7e4e5765, 0x97e9aa38, 0x28701c79, 0xc1d7e124, 0x563e4b1c, 0xbf99b641, 0x000080d7, 0xe9a77d8a, 0x7e4ed7b2, 0x97e92aef, 0x28709cae, 0xc1d761f3, 0x563ecbcb, 0xbf993696}, - [16]uint32{0x00000000, 0x300363d7, 0x1000cc03, 0x2003afd4, 0x40000a0e, 0x700369d9, 0x5000c60d, 0x6003a5da, 0xa000080b, 0x90036bdc, 0xb000c408, 0x8003a7df, 0xe0000205, 0xd00361d2, 0xf000ce06, 0xc003add1}, - [16]uint32{0x3f800000, 0x3f9801b1, 0x3f880066, 0x3f9001d7, 0x3fa00005, 0x3fb801b4, 0x3fa80063, 0x3fb001d2, 0x3fd00004, 0x3fc801b5, 0x3fd80062, 0x3fc001d3, 0x3ff00001, 0x3fe801b0, 0x3ff80067, 0x3fe001d6}, - uint32(0xfff80000), - [21]string{"0xd5", "0x14", "0x04", "0xa9", "0x05", "0x77", "0x56", "0x00", "0x9b", "0x45", "0x3c", "0xb7", "0x4c", "0x3f", "0x61", "0x70", "0x89", "0x78", "0x8d", "0x54", "0x00"}}, - { - /* No.456 delta:1708 weight:1567 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xb252a23e, 0x1bc3b15c, 0xa9911362, 0x1bb01c87, 0xa9e2beb9, 0x0073addb, 0xb2210fe5, 0x0000202e, 0xb2528210, 0x1bc39172, 0xa991334c, 0x1bb03ca9, 0xa9e29e97, 0x00738df5, 0xb2212fcb}, - [16]uint32{0x00000000, 0x2c1b011a, 0x80058011, 0xac1e810b, 0x0d102512, 0x210b2408, 0x8d15a503, 0xa10ea419, 0x020085bc, 0x2e1b84a6, 0x820505ad, 0xae1e04b7, 0x0f10a0ae, 0x230ba1b4, 0x8f1520bf, 0xa30e21a5}, - [16]uint32{0x3f800000, 0x3f960d80, 0x3fc002c0, 0x3fd60f40, 0x3f868812, 0x3f908592, 0x3fc68ad2, 0x3fd08752, 0x3f810042, 0x3f970dc2, 0x3fc10282, 0x3fd70f02, 0x3f878850, 0x3f9185d0, 0x3fc78a90, 0x3fd18710}, - uint32(0xfff80000), - [21]string{"0xfe", "0xf5", "0x65", "0x22", "0x34", "0x59", "0xa4", "0x03", "0x8f", "0x5c", "0x1f", "0xda", "0xfe", "0xda", "0xb8", "0x69", "0xf8", "0x0a", "0xde", "0xe6", "0x00"}}, - { - /* No.457 delta:860 weight:1561 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0xad2d4d15, 0x64c8b75e, 0xc9e5fa4b, 0xcad01c96, 0x67fd5183, 0xae18abc8, 0x0335e6dd, 0x00001b43, 0xad2d5656, 0x64c8ac1d, 0xc9e5e108, 0xcad007d5, 0x67fd4ac0, 0xae18b08b, 0x0335fd9e}, - [16]uint32{0x00000000, 0x0002afba, 0xc048c115, 0xc04a6eaf, 0x400431e3, 0x40069e59, 0x804cf0f6, 0x804e5f4c, 0x00016145, 0x0003ceff, 0xc049a050, 0xc04b0fea, 0x400550a6, 0x4007ff1c, 0x804d91b3, 0x804f3e09}, - [16]uint32{0x3f800000, 0x3f800157, 0x3fe02460, 0x3fe02537, 0x3fa00218, 0x3fa0034f, 0x3fc02678, 0x3fc0272f, 0x3f8000b0, 0x3f8001e7, 0x3fe024d0, 0x3fe02587, 0x3fa002a8, 0x3fa003ff, 0x3fc026c8, 0x3fc0279f}, - uint32(0xfff80000), - [21]string{"0x8c", "0x2e", "0x2b", "0x31", "0x16", "0x38", "0xd4", "0x83", "0x1c", "0x8a", "0xfc", "0x4f", "0xa3", "0xe7", "0x93", "0xbc", "0xc8", "0x5f", "0xa8", "0x52", "0x00"}}, - { - /* No.458 delta:1676 weight:1533 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x79fa442f, 0xf4897b00, 0x8d733f2f, 0x2e401cac, 0x57ba5883, 0xdac967ac, 0xa3332383, 0x00005efb, 0x79fa1ad4, 0xf48925fb, 0x8d7361d4, 0x2e404257, 0x57ba0678, 0xdac93957, 0xa3337d78}, - [16]uint32{0x00000000, 0x0c6178b6, 0x7034c021, 0x7c55b897, 0x010aa18b, 0x0d6bd93d, 0x713e61aa, 0x7d5f191c, 0x0c1c0404, 0x007d7cb2, 0x7c28c425, 0x7049bc93, 0x0d16a58f, 0x0177dd39, 0x7d2265ae, 0x71431d18}, - [16]uint32{0x3f800000, 0x3f8630bc, 0x3fb81a60, 0x3fbe2adc, 0x3f808550, 0x3f86b5ec, 0x3fb89f30, 0x3fbeaf8c, 0x3f860e02, 0x3f803ebe, 0x3fbe1462, 0x3fb824de, 0x3f868b52, 0x3f80bbee, 0x3fbe9132, 0x3fb8a18e}, - uint32(0xfff80000), - [21]string{"0xaf", "0xfd", "0x1f", "0x6b", "0xc7", "0x3c", "0xbf", "0xbe", "0x3f", "0xb9", "0xf5", "0x1b", "0x89", "0xa6", "0xc1", "0xc5", "0xc0", "0x6f", "0x8d", "0x88", "0x00"}}, - { - /* No.459 delta:2859 weight:827 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0x966cdd4d, 0x2dcf6a78, 0xbba3b735, 0x50c01cba, 0xc6acc1f7, 0x7d0f76c2, 0xeb63ab8f, 0x00007e6d, 0x966ca320, 0x2dcf1415, 0xbba3c958, 0x50c062d7, 0xc6acbf9a, 0x7d0f08af, 0xeb63d5e2}, - [16]uint32{0x00000000, 0x90c2e156, 0x398a8087, 0xa94861d1, 0x34102fed, 0xa4d2cebb, 0x0d9aaf6a, 0x9d584e3c, 0x8c00e21e, 0x1cc20348, 0xb58a6299, 0x254883cf, 0xb810cdf3, 0x28d22ca5, 0x819a4d74, 0x1158ac22}, - [16]uint32{0x3f800000, 0x3fc86170, 0x3f9cc540, 0x3fd4a430, 0x3f9a0817, 0x3fd26967, 0x3f86cd57, 0x3fceac27, 0x3fc60071, 0x3f8e6101, 0x3fdac531, 0x3f92a441, 0x3fdc0866, 0x3f946916, 0x3fc0cd26, 0x3f88ac56}, - uint32(0xfff80000), - [21]string{"0xa1", "0x48", "0x6f", "0xb4", "0x98", "0x4a", "0xc0", "0x55", "0x79", "0xdf", "0x91", "0x6f", "0x8d", "0xfb", "0xf8", "0x83", "0x2a", "0x8c", "0x08", "0xe3", "0x00"}}, - { - /* No.460 delta:3091 weight:655 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xf7f86c95, 0x6bcc71ce, 0x9c341d5b, 0x5d901cc1, 0xaa687054, 0x365c6d0f, 0xc1a4019a, 0x00004c13, 0xf7f82086, 0x6bcc3ddd, 0x9c345148, 0x5d9050d2, 0xaa683c47, 0x365c211c, 0xc1a44d89}, - [16]uint32{0x00000000, 0xef0005af, 0x1362b07d, 0xfc62b5d2, 0x50614171, 0xbf6144de, 0x4303f10c, 0xac03f4a3, 0x09822615, 0xe68223ba, 0x1ae09668, 0xf5e093c7, 0x59e36764, 0xb6e362cb, 0x4a81d719, 0xa581d2b6}, - [16]uint32{0x3f800000, 0x3ff78002, 0x3f89b158, 0x3ffe315a, 0x3fa830a0, 0x3fdfb0a2, 0x3fa181f8, 0x3fd601fa, 0x3f84c113, 0x3ff34111, 0x3f8d704b, 0x3ffaf049, 0x3facf1b3, 0x3fdb71b1, 0x3fa540eb, 0x3fd2c0e9}, - uint32(0xfff80000), - [21]string{"0xd8", "0x49", "0xac", "0x16", "0x01", "0x46", "0x55", "0xa8", "0x4b", "0xb8", "0x6e", "0x39", "0x40", "0x02", "0x2d", "0x70", "0x6d", "0x36", "0x2d", "0x52", "0x00"}}, - { - /* No.461 delta:1147 weight:1403 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xdbd3783d, 0xbe49cbc8, 0x659ab3f5, 0xed501cdd, 0x368364e0, 0x5319d715, 0x88caaf28, 0x00005530, 0xdbd32d0d, 0xbe499ef8, 0x659ae6c5, 0xed5049ed, 0x368331d0, 0x53198225, 0x88cafa18}, - [16]uint32{0x00000000, 0xa3396c7e, 0x005264ec, 0xa36b0892, 0x00028606, 0xa33bea78, 0x0050e2ea, 0xa3698e94, 0x0034801d, 0xa30dec63, 0x0066e4f1, 0xa35f888f, 0x0036061b, 0xa30f6a65, 0x006462f7, 0xa35d0e89}, - [16]uint32{0x3f800000, 0x3fd19cb6, 0x3f802932, 0x3fd1b584, 0x3f800143, 0x3fd19df5, 0x3f802871, 0x3fd1b4c7, 0x3f801a40, 0x3fd186f6, 0x3f803372, 0x3fd1afc4, 0x3f801b03, 0x3fd187b5, 0x3f803231, 0x3fd1ae87}, - uint32(0xfff80000), - [21]string{"0xa0", "0x0c", "0xaf", "0xc1", "0x62", "0x6d", "0x77", "0x93", "0x39", "0x49", "0x43", "0xa1", "0x6f", "0xcd", "0xd2", "0xe0", "0x82", "0x21", "0x82", "0x00", "0x00"}}, - { - /* No.462 delta:1650 weight:1547 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xde2dcf6b, 0x3af4f8e1, 0xe4d9378a, 0xbe901ce6, 0x60bdd38d, 0x8464e407, 0x5a492b6c, 0x0000829f, 0xde2d4df4, 0x3af47a7e, 0xe4d9b515, 0xbe909e79, 0x60bd5112, 0x84646698, 0x5a49a9f3}, - [16]uint32{0x00000000, 0x0901583c, 0x05ad222d, 0x0cac7a11, 0x018240de, 0x088318e2, 0x042f62f3, 0x0d2e3acf, 0x40124219, 0x49131a25, 0x45bf6034, 0x4cbe3808, 0x419002c7, 0x48915afb, 0x443d20ea, 0x4d3c78d6}, - [16]uint32{0x3f800000, 0x3f8480ac, 0x3f82d691, 0x3f86563d, 0x3f80c120, 0x3f84418c, 0x3f8217b1, 0x3f86971d, 0x3fa00921, 0x3fa4898d, 0x3fa2dfb0, 0x3fa65f1c, 0x3fa0c801, 0x3fa448ad, 0x3fa21e90, 0x3fa69e3c}, - uint32(0xfff80000), - [21]string{"0x8e", "0x3a", "0x8d", "0x78", "0x09", "0x9d", "0xe5", "0x21", "0x70", "0xc8", "0x56", "0xf3", "0x4a", "0xd3", "0xf0", "0x79", "0x72", "0xea", "0x34", "0x2b", "0x00"}}, - { - /* No.463 delta:1698 weight:1635 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0x3ea32c98, 0xa2768504, 0x9cd5a99c, 0xb3701cf6, 0x8dd3306e, 0x110699f2, 0x2fa5b56a, 0x00001c59, 0x3ea330c1, 0xa276995d, 0x9cd5b5c5, 0xb37000af, 0x8dd32c37, 0x110685ab, 0x2fa5a933}, - [16]uint32{0x00000000, 0x005e605a, 0x403001ef, 0x406e61b5, 0x00620071, 0x003c602b, 0x4052019e, 0x400c61c4, 0x00020048, 0x005c6012, 0x403201a7, 0x406c61fd, 0x00600039, 0x003e6063, 0x405001d6, 0x400e618c}, - [16]uint32{0x3f800000, 0x3f802f30, 0x3fa01800, 0x3fa03730, 0x3f803100, 0x3f801e30, 0x3fa02900, 0x3fa00630, 0x3f800100, 0x3f802e30, 0x3fa01900, 0x3fa03630, 0x3f803000, 0x3f801f30, 0x3fa02800, 0x3fa00730}, - uint32(0xfff80000), - [21]string{"0xa4", "0xe1", "0x31", "0xab", "0xca", "0x6a", "0x42", "0x05", "0x4d", "0x09", "0xc5", "0x2d", "0x81", "0xcc", "0x0d", "0x32", "0x77", "0x2e", "0x23", "0x6d", "0x00"}}, - { - /* No.464 delta:994 weight:1683 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x6ab86193, 0x33d2fced, 0x596a9d7e, 0x3bd01d03, 0x51687c90, 0x0802e1ee, 0x62ba807d, 0x0000cbf6, 0x6ab8aa65, 0x33d2371b, 0x596a5688, 0x3bd0d6f5, 0x5168b766, 0x08022a18, 0x62ba4b8b}, - [16]uint32{0x00000000, 0x101fc3ba, 0x000200d7, 0x101dc36d, 0xc040c084, 0xd05f033e, 0xc042c053, 0xd05d03e9, 0x3818003b, 0x2807c381, 0x381a00ec, 0x2805c356, 0xf858c0bf, 0xe8470305, 0xf85ac068, 0xe84503d2}, - [16]uint32{0x3f800000, 0x3f880fe1, 0x3f800100, 0x3f880ee1, 0x3fe02060, 0x3fe82f81, 0x3fe02160, 0x3fe82e81, 0x3f9c0c00, 0x3f9403e1, 0x3f9c0d00, 0x3f9402e1, 0x3ffc2c60, 0x3ff42381, 0x3ffc2d60, 0x3ff42281}, - uint32(0xfff80000), - [21]string{"0x65", "0x41", "0x75", "0x17", "0xf0", "0x67", "0x8d", "0x81", "0x45", "0x3f", "0xae", "0xf9", "0xc4", "0x4a", "0xda", "0x19", "0x1a", "0x50", "0x12", "0xff", "0x00"}}, - { - /* No.465 delta:1002 weight:1417 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0x7e8c4d8d, 0x0204aa47, 0x7c88e7ca, 0x8f401d1f, 0xf1cc5092, 0x8d44b758, 0xf3c8fad5, 0x0000df1b, 0x7e8c9296, 0x0204755c, 0x7c8838d1, 0x8f40c204, 0xf1cc8f89, 0x8d446843, 0xf3c825ce}, - [16]uint32{0x00000000, 0x10002832, 0x4800201d, 0x5800082f, 0xa1001229, 0xb1003a1b, 0xe9003234, 0xf9001a06, 0xe0000401, 0xf0002c33, 0xa800241c, 0xb8000c2e, 0x41001628, 0x51003e1a, 0x09003635, 0x19001e07}, - [16]uint32{0x3f800000, 0x3f880014, 0x3fa40010, 0x3fac0004, 0x3fd08009, 0x3fd8801d, 0x3ff48019, 0x3ffc800d, 0x3ff00002, 0x3ff80016, 0x3fd40012, 0x3fdc0006, 0x3fa0800b, 0x3fa8801f, 0x3f84801b, 0x3f8c800f}, - uint32(0xfff80000), - [21]string{"0xcb", "0xd2", "0x42", "0x56", "0xac", "0xd3", "0xc2", "0x53", "0x5c", "0xf0", "0x3f", "0xae", "0x10", "0x6e", "0x1a", "0x1a", "0x95", "0x0d", "0xc4", "0xfe", "0x00"}}, - { - /* No.466 delta:1116 weight:1429 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xe8a2def6, 0x6697b821, 0x8e3566d7, 0x98701d28, 0x70d2c3de, 0xfee7a509, 0x16457bff, 0x0000b64a, 0xe8a268bc, 0x66970e6b, 0x8e35d09d, 0x9870ab62, 0x70d27594, 0xfee71343, 0x1645cdb5}, - [16]uint32{0x00000000, 0x581c021a, 0x200281ff, 0x781e83e5, 0x0003550e, 0x581f5714, 0x2001d4f1, 0x781dd6eb, 0x02240015, 0x5a38020f, 0x222681ea, 0x7a3a83f0, 0x0227551b, 0x5a3b5701, 0x2225d4e4, 0x7a39d6fe}, - [16]uint32{0x3f800000, 0x3fac0e01, 0x3f900140, 0x3fbc0f41, 0x3f8001aa, 0x3fac0fab, 0x3f9000ea, 0x3fbc0eeb, 0x3f811200, 0x3fad1c01, 0x3f911340, 0x3fbd1d41, 0x3f8113aa, 0x3fad1dab, 0x3f9112ea, 0x3fbd1ceb}, - uint32(0xfff80000), - [21]string{"0x8d", "0x16", "0x92", "0xc4", "0xde", "0xb4", "0x29", "0xc1", "0x8e", "0xea", "0x8e", "0xe6", "0x47", "0xa0", "0x78", "0x42", "0x18", "0x3d", "0x05", "0x7d", "0x00"}}, - { - /* No.467 delta:762 weight:1591 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0x30431de8, 0xf4246d55, 0xc46770bd, 0xcca01d38, 0xfce300d0, 0x3884706d, 0x08c76d85, 0x00000155, 0x30431cbd, 0xf4246c00, 0xc46771e8, 0xcca01c6d, 0xfce30185, 0x38847138, 0x08c76cd0}, - [16]uint32{0x00000000, 0x005c993b, 0x0003588e, 0x005fc1b5, 0x0002a01c, 0x005e3927, 0x0001f892, 0x005d61a9, 0x20103008, 0x204ca933, 0x20136886, 0x204ff1bd, 0x20129014, 0x204e092f, 0x2011c89a, 0x204d51a1}, - [16]uint32{0x3f800000, 0x3f802e4c, 0x3f8001ac, 0x3f802fe0, 0x3f800150, 0x3f802f1c, 0x3f8000fc, 0x3f802eb0, 0x3f900818, 0x3f902654, 0x3f9009b4, 0x3f9027f8, 0x3f900948, 0x3f902704, 0x3f9008e4, 0x3f9026a8}, - uint32(0xfff80000), - [21]string{"0xc3", "0x53", "0xa2", "0x6c", "0x7b", "0x6b", "0x11", "0xcb", "0x82", "0x73", "0x97", "0x3a", "0x25", "0x79", "0x35", "0x90", "0x85", "0x92", "0x32", "0xa3", "0x00"}}, - { - /* No.468 delta:1074 weight:1391 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x1836f48e, 0x1958a0d1, 0x016e545f, 0x8e001d40, 0x9636e9ce, 0x9758bd91, 0x8f6e491f, 0x00006285, 0x1836960b, 0x1958c254, 0x016e36da, 0x8e007fc5, 0x96368b4b, 0x9758df14, 0x8f6e2b9a}, - [16]uint32{0x00000000, 0x400da476, 0x304444d5, 0x7049e0a3, 0x10132148, 0x501e853e, 0x2057659d, 0x605ac1eb, 0x0023a17f, 0x402e0509, 0x3067e5aa, 0x706a41dc, 0x10308037, 0x503d2441, 0x2074c4e2, 0x60796094}, - [16]uint32{0x3f800000, 0x3fa006d2, 0x3f982222, 0x3fb824f0, 0x3f880990, 0x3fa80f42, 0x3f902bb2, 0x3fb02d60, 0x3f8011d0, 0x3fa01702, 0x3f9833f2, 0x3fb83520, 0x3f881840, 0x3fa81e92, 0x3f903a62, 0x3fb03cb0}, - uint32(0xfff80000), - [21]string{"0xa6", "0xe2", "0x37", "0x6d", "0xb3", "0xb4", "0xf8", "0x37", "0x2e", "0x27", "0xa3", "0xd0", "0x12", "0xa1", "0x16", "0x1d", "0x94", "0x5b", "0x07", "0xb1", "0x00"}}, - { - /* No.469 delta:982 weight:1581 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x965ae253, 0xe70f4509, 0x7155a75a, 0x64a01d5b, 0xf2faff08, 0x83af5852, 0x15f5ba01, 0x0000bf56, 0x965a5d05, 0xe70ffa5f, 0x7155180c, 0x64a0a20d, 0xf2fa405e, 0x83afe704, 0x15f50557}, - [16]uint32{0x00000000, 0x200240f2, 0x240051d7, 0x04021125, 0x1406d09c, 0x3404906e, 0x3006814b, 0x1004c1b9, 0x1013e01a, 0x3011a0e8, 0x3413b1cd, 0x1411f13f, 0x04153086, 0x24177074, 0x20156151, 0x001721a3}, - [16]uint32{0x3f800000, 0x3f900120, 0x3f920028, 0x3f820108, 0x3f8a0368, 0x3f9a0248, 0x3f980340, 0x3f880260, 0x3f8809f0, 0x3f9808d0, 0x3f9a09d8, 0x3f8a08f8, 0x3f820a98, 0x3f920bb8, 0x3f900ab0, 0x3f800b90}, - uint32(0xfff80000), - [21]string{"0x08", "0xc2", "0xc2", "0xbf", "0xba", "0x73", "0xe8", "0x04", "0x76", "0xa9", "0x5b", "0x1a", "0xad", "0xea", "0x5d", "0x5a", "0x98", "0xb9", "0xba", "0x85", "0x00"}}, - { - /* No.470 delta:997 weight:1427 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x57991792, 0xd2b792b3, 0x852e8521, 0x02e01d68, 0x55790afa, 0xd0578fdb, 0x87ce9849, 0x000085ae, 0x5799923c, 0xd2b7171d, 0x852e008f, 0x02e098c6, 0x55798f54, 0xd0570a75, 0x87ce1de7}, - [16]uint32{0x00000000, 0x402d0552, 0x0002c915, 0x402fcc47, 0x40467019, 0x006b754b, 0x4044b90c, 0x0069bc5e, 0x10b30c1a, 0x509e0948, 0x10b1c50f, 0x509cc05d, 0x50f57c03, 0x10d87951, 0x50f7b516, 0x10dab044}, - [16]uint32{0x3f800000, 0x3fa01682, 0x3f800164, 0x3fa017e6, 0x3fa02338, 0x3f8035ba, 0x3fa0225c, 0x3f8034de, 0x3f885986, 0x3fa84f04, 0x3f8858e2, 0x3fa84e60, 0x3fa87abe, 0x3f886c3c, 0x3fa87bda, 0x3f886d58}, - uint32(0xfff80000), - [21]string{"0xb6", "0xab", "0xb8", "0x8e", "0x22", "0xc6", "0xc1", "0xf1", "0xd8", "0x58", "0x6d", "0x23", "0x10", "0x08", "0x4b", "0x05", "0x84", "0x5d", "0xba", "0xc4", "0x00"}}, - { - /* No.471 delta:1497 weight:1575 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x4ab0bf22, 0x834b4b03, 0xc9fbf421, 0xfd201d7c, 0xb790a25e, 0x7e6b567f, 0x34dbe95d, 0x00005885, 0x4ab0e7a7, 0x834b1386, 0xc9fbaca4, 0xfd2045f9, 0xb790fadb, 0x7e6b0efa, 0x34dbb1d8}, - [16]uint32{0x00000000, 0x0c14987e, 0x52f8e4ea, 0x5eec7c94, 0x004008d6, 0x0c5490a8, 0x52b8ec3c, 0x5eac7442, 0x0063e01f, 0x0c777861, 0x529b04f5, 0x5e8f9c8b, 0x0023e8c9, 0x0c3770b7, 0x52db0c23, 0x5ecf945d}, - [16]uint32{0x3f800000, 0x3f860a4c, 0x3fa97c72, 0x3faf763e, 0x3f802004, 0x3f862a48, 0x3fa95c76, 0x3faf563a, 0x3f8031f0, 0x3f863bbc, 0x3fa94d82, 0x3faf47ce, 0x3f8011f4, 0x3f861bb8, 0x3fa96d86, 0x3faf67ca}, - uint32(0xfff80000), - [21]string{"0x3f", "0x76", "0x21", "0x59", "0xf5", "0x5e", "0x78", "0x7a", "0xc1", "0x86", "0x48", "0x8d", "0x51", "0x11", "0x8a", "0x29", "0xa0", "0x2f", "0x4f", "0x52", "0x00"}}, - { - /* No.472 delta:1546 weight:1671 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x3c6f0fba, 0x5b32d4c5, 0x675ddb7f, 0x20801d89, 0x1cef1233, 0x7bb2c94c, 0x47ddc6f6, 0x00006cad, 0x3c6f6317, 0x5b32b868, 0x675db7d2, 0x20807124, 0x1cef7e9e, 0x7bb2a5e1, 0x47ddaa5b}, - [16]uint32{0x00000000, 0xa0d64076, 0x2054202f, 0x80826059, 0x003c098a, 0xa0ea49fc, 0x206829a5, 0x80be69d3, 0x20340012, 0x80e24064, 0x0060203d, 0xa0b6604b, 0x20080998, 0x80de49ee, 0x005c29b7, 0xa08a69c1}, - [16]uint32{0x3f800000, 0x3fd06b20, 0x3f902a10, 0x3fc04130, 0x3f801e04, 0x3fd07524, 0x3f903414, 0x3fc05f34, 0x3f901a00, 0x3fc07120, 0x3f803010, 0x3fd05b30, 0x3f900404, 0x3fc06f24, 0x3f802e14, 0x3fd04534}, - uint32(0xfff80000), - [21]string{"0x4b", "0x84", "0x52", "0xf4", "0xd4", "0x3a", "0xf0", "0x78", "0xc5", "0xe1", "0xa3", "0xd3", "0xdd", "0x9c", "0x43", "0x2f", "0xbf", "0xe2", "0x0b", "0xbb", "0x00"}}, - { - /* No.473 delta:592 weight:1593 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0x06b61206, 0x99dff500, 0x9f69e706, 0x29701d90, 0x2fc60f96, 0xb0afe890, 0xb619fa96, 0x000061d0, 0x06b673d6, 0x99df94d0, 0x9f6986d6, 0x29707c40, 0x2fc66e46, 0xb0af8940, 0xb6199b46}, - [16]uint32{0x00000000, 0x20426f15, 0x40101c0f, 0x6052731a, 0x0002860b, 0x2040e91e, 0x40129a04, 0x6050f511, 0xc0015601, 0xe0433914, 0x80114a0e, 0xa053251b, 0xc003d00a, 0xe041bf1f, 0x8013cc05, 0xa051a310}, - [16]uint32{0x3f800000, 0x3f902137, 0x3fa0080e, 0x3fb02939, 0x3f800143, 0x3f902074, 0x3fa0094d, 0x3fb0287a, 0x3fe000ab, 0x3ff0219c, 0x3fc008a5, 0x3fd02992, 0x3fe001e8, 0x3ff020df, 0x3fc009e6, 0x3fd028d1}, - uint32(0xfff80000), - [21]string{"0xec", "0x8a", "0x48", "0x6b", "0x4d", "0xf5", "0xc2", "0x21", "0x1b", "0x26", "0xab", "0x20", "0xda", "0x44", "0xaf", "0x66", "0x0f", "0xc7", "0x91", "0x68", "0x00"}}, - { - /* No.474 delta:1484 weight:1665 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x4a404019, 0x6200ed9f, 0x2840ad86, 0x5f701da0, 0x15305db9, 0x3d70f03f, 0x7730b026, 0x000080de, 0x4a40c0c7, 0x62006d41, 0x28402d58, 0x5f709d7e, 0x1530dd67, 0x3d7070e1, 0x773030f8}, - [16]uint32{0x00000000, 0x0604021a, 0x000151d3, 0x060553c9, 0x00605025, 0x0664523f, 0x006101f6, 0x066503ec, 0x00401801, 0x06441a1b, 0x004149d2, 0x06454bc8, 0x00204824, 0x06244a3e, 0x002119f7, 0x06251bed}, - [16]uint32{0x3f800000, 0x3f830201, 0x3f8000a8, 0x3f8302a9, 0x3f803028, 0x3f833229, 0x3f803080, 0x3f833281, 0x3f80200c, 0x3f83220d, 0x3f8020a4, 0x3f8322a5, 0x3f801024, 0x3f831225, 0x3f80108c, 0x3f83128d}, - uint32(0xfff80000), - [21]string{"0xd5", "0x07", "0x86", "0x6a", "0xf3", "0xf9", "0xb4", "0xfd", "0x66", "0x09", "0x32", "0xf8", "0x34", "0x16", "0x71", "0x7b", "0x8c", "0x00", "0x39", "0xec", "0x00"}}, - { - /* No.475 delta:830 weight:1563 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x4d5a359d, 0x74795c1b, 0x39236986, 0xdd501dbb, 0x900a2826, 0xa92941a0, 0xe473743d, 0x0000d2bf, 0x4d5ae722, 0x74798ea4, 0x3923bb39, 0xdd50cf04, 0x900afa99, 0xa929931f, 0xe473a682}, - [16]uint32{0x00000000, 0x4001e5f5, 0x200281fe, 0x6003640b, 0x3003c5b1, 0x70022044, 0x1001444f, 0x5000a1ba, 0x0003045c, 0x4002e1a9, 0x200185a2, 0x60006057, 0x3000c1ed, 0x70012418, 0x10024013, 0x5003a5e6}, - [16]uint32{0x3f800000, 0x3fa000f2, 0x3f900140, 0x3fb001b2, 0x3f9801e2, 0x3fb80110, 0x3f8800a2, 0x3fa80050, 0x3f800182, 0x3fa00170, 0x3f9000c2, 0x3fb00030, 0x3f980060, 0x3fb80092, 0x3f880120, 0x3fa801d2}, - uint32(0xfff80000), - [21]string{"0xe9", "0x4d", "0x06", "0xe7", "0xbe", "0x86", "0x9c", "0xcb", "0x53", "0xa2", "0x6c", "0x00", "0xb5", "0x04", "0xa1", "0x88", "0xe1", "0x00", "0x63", "0x02", "0x00"}}, - { - /* No.476 delta:1031 weight:1603 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xc2e33ade, 0xed885798, 0x2f6b6d46, 0x44c01dc8, 0x86232716, 0xa9484a50, 0x6bab708e, 0x0000f315, 0xc2e3c9cb, 0xed88a48d, 0x2f6b9e53, 0x44c0eedd, 0x8623d403, 0xa948b945, 0x6bab839b}, - [16]uint32{0x00000000, 0x800d0e3e, 0x00252155, 0x80282f6b, 0x10472307, 0x904a2d39, 0x10620252, 0x906f0c6c, 0x00031017, 0x800e1e29, 0x00263142, 0x802b3f7c, 0x10443310, 0x90493d2e, 0x10611245, 0x906c1c7b}, - [16]uint32{0x3f800000, 0x3fc00687, 0x3f801290, 0x3fc01417, 0x3f882391, 0x3fc82516, 0x3f883101, 0x3fc83786, 0x3f800188, 0x3fc0070f, 0x3f801318, 0x3fc0159f, 0x3f882219, 0x3fc8249e, 0x3f883089, 0x3fc8360e}, - uint32(0xfff80000), - [21]string{"0x4a", "0x30", "0x35", "0x89", "0xd9", "0x2e", "0xb6", "0xe1", "0xe4", "0xbc", "0x08", "0x82", "0x8f", "0x3c", "0x33", "0x86", "0x05", "0x31", "0xf8", "0x50", "0x00"}}, - { - /* No.477 delta:1735 weight:1445 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0x55099ce0, 0x7b86d53c, 0x2e8f49dc, 0xcca01dde, 0x99a9813e, 0xb726c8e2, 0xe22f5402, 0x00008290, 0x55091e70, 0x7b8657ac, 0x2e8fcb4c, 0xcca09f4e, 0x99a903ae, 0xb7264a72, 0xe22fd692}, - [16]uint32{0x00000000, 0x06052037, 0x10423c74, 0x16471c43, 0x016c608c, 0x076940bb, 0x112e5cf8, 0x172b7ccf, 0x0a20801d, 0x0c25a02a, 0x1a62bc69, 0x1c679c5e, 0x0b4ce091, 0x0d49c0a6, 0x1b0edce5, 0x1d0bfcd2}, - [16]uint32{0x3f800000, 0x3f830290, 0x3f88211e, 0x3f8b238e, 0x3f80b630, 0x3f83b4a0, 0x3f88972e, 0x3f8b95be, 0x3f851040, 0x3f8612d0, 0x3f8d315e, 0x3f8e33ce, 0x3f85a670, 0x3f86a4e0, 0x3f8d876e, 0x3f8e85fe}, - uint32(0xfff80000), - [21]string{"0x56", "0x92", "0xc7", "0x71", "0xc4", "0xe9", "0x4d", "0x92", "0xdc", "0xbb", "0x7f", "0xca", "0x0d", "0xc7", "0xe1", "0x44", "0xde", "0x50", "0xe1", "0xd1", "0x00"}}, - { - /* No.478 delta:2293 weight:1169 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x03773cb0, 0x5ab6d4e0, 0x59c1e850, 0x1b401de9, 0x18372159, 0x41f6c909, 0x4281f5b9, 0x000004f2, 0x03773842, 0x5ab6d012, 0x59c1eca2, 0x1b40191b, 0x183725ab, 0x41f6cdfb, 0x4281f14b}, - [16]uint32{0x00000000, 0xa75012d6, 0x2c5c1073, 0x8b0c02a5, 0x02da413c, 0xa58a53ea, 0x2e86514f, 0x89d64399, 0x22bc6018, 0x85ec72ce, 0x0ee0706b, 0xa9b062bd, 0x20662124, 0x873633f2, 0x0c3a3157, 0xab6a2381}, - [16]uint32{0x3f800000, 0x3fd3a809, 0x3f962e08, 0x3fc58601, 0x3f816d20, 0x3fd2c529, 0x3f974328, 0x3fc4eb21, 0x3f915e30, 0x3fc2f639, 0x3f877038, 0x3fd4d831, 0x3f903310, 0x3fc39b19, 0x3f861d18, 0x3fd5b511}, - uint32(0xfff80000), - [21]string{"0x2b", "0x0a", "0x30", "0xdf", "0x64", "0x4e", "0xf5", "0x76", "0xac", "0x6c", "0x8c", "0xbc", "0x7f", "0x19", "0x7e", "0x4f", "0x81", "0x59", "0x5d", "0xa6", "0x00"}}, - { - /* No.479 delta:791 weight:1715 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x539b6779, 0xda60077c, 0x89fb6005, 0x2ea01dfd, 0x7d3b7a84, 0xf4c01a81, 0xa75b7df8, 0x00008ebd, 0x539be9c4, 0xda6089c1, 0x89fbeeb8, 0x2ea09340, 0x7d3bf439, 0xf4c0943c, 0xa75bf345}, - [16]uint32{0x00000000, 0x0074511a, 0x14901889, 0x14e44993, 0x000a11cb, 0x007e40d1, 0x149a0942, 0x14ee5858, 0x0003001c, 0x00775106, 0x14931895, 0x14e7498f, 0x000911d7, 0x007d40cd, 0x1499095e, 0x14ed5844}, - [16]uint32{0x3f800000, 0x3f803a28, 0x3f8a480c, 0x3f8a7224, 0x3f800508, 0x3f803f20, 0x3f8a4d04, 0x3f8a772c, 0x3f800180, 0x3f803ba8, 0x3f8a498c, 0x3f8a73a4, 0x3f800488, 0x3f803ea0, 0x3f8a4c84, 0x3f8a76ac}, - uint32(0xfff80000), - [21]string{"0x0d", "0x78", "0xe7", "0xaa", "0x59", "0xa3", "0x84", "0x11", "0xef", "0x4d", "0x42", "0x34", "0xd3", "0x52", "0x22", "0x2f", "0x7c", "0xce", "0xac", "0x83", "0x00"}}, - { - /* No.480 delta:1595 weight:1647 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0xbd2c5e77, 0xb22dc09c, 0x0f019eeb, 0x3bb01e08, 0x869c407f, 0x899dde94, 0x34b180e3, 0x0000c58d, 0xbd2c9bfa, 0xb22d0511, 0x0f015b66, 0x3bb0db85, 0x869c85f2, 0x899d1b19, 0x34b1456e}, - [16]uint32{0x00000000, 0x086d0b5a, 0x0812c0b7, 0x007fcbed, 0x3073801e, 0x381e8b44, 0x386140a9, 0x300c4bf3, 0x4072c0e6, 0x481fcbbc, 0x48600051, 0x400d0b0b, 0x700140f8, 0x786c4ba2, 0x7813804f, 0x707e8b15}, - [16]uint32{0x3f800000, 0x3f843685, 0x3f840960, 0x3f803fe5, 0x3f9839c0, 0x3f9c0f45, 0x3f9c30a0, 0x3f980625, 0x3fa03960, 0x3fa40fe5, 0x3fa43000, 0x3fa00685, 0x3fb800a0, 0x3fbc3625, 0x3fbc09c0, 0x3fb83f45}, - uint32(0xfff80000), - [21]string{"0xa5", "0xd7", "0xca", "0x72", "0xf2", "0x58", "0xa0", "0x42", "0x12", "0xcf", "0x8c", "0x91", "0xdf", "0xbb", "0x30", "0x7d", "0x2e", "0xcd", "0xf7", "0x31", "0x00"}}, - { - /* No.481 delta:661 weight:1585 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0x8706d6f8, 0x9a56f601, 0x1d5020f9, 0xa3201e10, 0x2426c8e8, 0x3976e811, 0xbe703ee9, 0x0000aace, 0x87067c36, 0x9a565ccf, 0x1d508a37, 0xa320b4de, 0x24266226, 0x397642df, 0xbe709427}, - [16]uint32{0x00000000, 0x003ad475, 0x1003c1d2, 0x103915a7, 0x1000300a, 0x103ae47f, 0x0003f1d8, 0x003925ad, 0xb00486da, 0xb03e52af, 0xa0074708, 0xa03d937d, 0xa004b6d0, 0xa03e62a5, 0xb0077702, 0xb03da377}, - [16]uint32{0x3f800000, 0x3f801d6a, 0x3f8801e0, 0x3f881c8a, 0x3f880018, 0x3f881d72, 0x3f8001f8, 0x3f801c92, 0x3fd80243, 0x3fd81f29, 0x3fd003a3, 0x3fd01ec9, 0x3fd0025b, 0x3fd01f31, 0x3fd803bb, 0x3fd81ed1}, - uint32(0xfff80000), - [21]string{"0x8b", "0x7f", "0x7e", "0x4f", "0xc3", "0x10", "0x72", "0x81", "0x14", "0xfe", "0xb0", "0x5b", "0x7e", "0x02", "0x7d", "0x2c", "0x67", "0x07", "0x22", "0x64", "0x00"}}, - { - /* No.482 delta:1427 weight:1483 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0xe4a1391a, 0x8e203bc0, 0x6a8102da, 0x9ed01e29, 0x7a712733, 0x10f025e9, 0xf4511cf3, 0x0000aa49, 0xe4a19353, 0x8e209189, 0x6a81a893, 0x9ed0b460, 0x7a718d7a, 0x10f08fa0, 0xf451b6ba}, - [16]uint32{0x00000000, 0x0055a05a, 0x002d21dc, 0x00788186, 0x0024e04d, 0x00714017, 0x0009c191, 0x005c61cb, 0x26012068, 0x26548032, 0x262c01b4, 0x2679a1ee, 0x2625c025, 0x2670607f, 0x2608e1f9, 0x265d41a3}, - [16]uint32{0x3f800000, 0x3f802ad0, 0x3f801690, 0x3f803c40, 0x3f801270, 0x3f8038a0, 0x3f8004e0, 0x3f802e30, 0x3f930090, 0x3f932a40, 0x3f931600, 0x3f933cd0, 0x3f9312e0, 0x3f933830, 0x3f930470, 0x3f932ea0}, - uint32(0xfff80000), - [21]string{"0xf3", "0x09", "0x00", "0xdd", "0x80", "0x3f", "0x75", "0x9a", "0xc3", "0x5c", "0x4f", "0x26", "0x48", "0x9d", "0xf9", "0x76", "0x59", "0xa1", "0xf3", "0xbd", "0x00"}}, - { - /* No.483 delta:895 weight:1643 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x4cfacd5b, 0x27cd4160, 0x6b378c3b, 0xa8b01e31, 0xe44ad36a, 0x8f7d5f51, 0xc387920a, 0x000098a4, 0x4cfa55ff, 0x27cdd9c4, 0x6b37149f, 0xa8b08695, 0xe44a4bce, 0x8f7dc7f5, 0xc3870aae}, - [16]uint32{0x00000000, 0x014440bf, 0x2002818d, 0x2146c132, 0x00031944, 0x014759fb, 0x200198c9, 0x2145d876, 0x1000c0a8, 0x11448017, 0x30024125, 0x3146019a, 0x1003d9ec, 0x11479953, 0x30015861, 0x314518de}, - [16]uint32{0x3f800000, 0x3f80a220, 0x3f900140, 0x3f90a360, 0x3f80018c, 0x3f80a3ac, 0x3f9000cc, 0x3f90a2ec, 0x3f880060, 0x3f88a240, 0x3f980120, 0x3f98a300, 0x3f8801ec, 0x3f88a3cc, 0x3f9800ac, 0x3f98a28c}, - uint32(0xfff80000), - [21]string{"0x89", "0x3f", "0x9f", "0xbf", "0x6d", "0xff", "0x9f", "0x6c", "0xfd", "0x8e", "0xef", "0x64", "0x30", "0xad", "0xc5", "0x03", "0x35", "0xe5", "0xe9", "0xe4", "0x00"}}, - { - /* No.484 delta:1190 weight:1435 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0xf2958c1f, 0xcd7d7078, 0x3fe8fc67, 0x8e601e49, 0x7cf59256, 0x431d6e31, 0xb188e22e, 0x0000eabe, 0xf29566a1, 0xcd7d9ac6, 0x3fe816d9, 0x8e60f4f7, 0x7cf578e8, 0x431d848f, 0xb1880890}, - [16]uint32{0x00000000, 0x4815193e, 0x00495842, 0x485c417c, 0x00383075, 0x482d294b, 0x00716837, 0x48647109, 0x000d0013, 0x4818192d, 0x00445851, 0x4851416f, 0x00353066, 0x48202958, 0x007c6824, 0x4869711a}, - [16]uint32{0x3f800000, 0x3fa40a8c, 0x3f8024ac, 0x3fa42e20, 0x3f801c18, 0x3fa41694, 0x3f8038b4, 0x3fa43238, 0x3f800680, 0x3fa40c0c, 0x3f80222c, 0x3fa428a0, 0x3f801a98, 0x3fa41014, 0x3f803e34, 0x3fa434b8}, - uint32(0xfff80000), - [21]string{"0x54", "0xe9", "0x22", "0x78", "0x5d", "0xe4", "0xa7", "0xbc", "0x18", "0x76", "0xac", "0x5b", "0x66", "0x30", "0xbb", "0x80", "0xb4", "0xa7", "0xc2", "0x63", "0x00"}}, - { - /* No.485 delta:1384 weight:1657 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0x5a57ad1b, 0x036a3d74, 0x593d906f, 0x6e801e5f, 0x34d7b344, 0x6dea232b, 0x37bd8e30, 0x0000d457, 0x5a57794c, 0x036ae923, 0x593d4438, 0x6e80ca08, 0x34d76713, 0x6deaf77c, 0x37bd5a67}, - [16]uint32{0x00000000, 0x40245dbe, 0x107e60d7, 0x505a3d69, 0x1020141c, 0x500449a2, 0x005e74cb, 0x407a2975, 0x0040581f, 0x406405a1, 0x103e38c8, 0x501a6576, 0x10604c03, 0x504411bd, 0x001e2cd4, 0x403a716a}, - [16]uint32{0x3f800000, 0x3fa0122e, 0x3f883f30, 0x3fa82d1e, 0x3f88100a, 0x3fa80224, 0x3f802f3a, 0x3fa03d14, 0x3f80202c, 0x3fa03202, 0x3f881f1c, 0x3fa80d32, 0x3f883026, 0x3fa82208, 0x3f800f16, 0x3fa01d38}, - uint32(0xfff80000), - [21]string{"0x86", "0x73", "0xee", "0xd6", "0x35", "0x0a", "0x6e", "0x88", "0x98", "0x23", "0x58", "0x03", "0xcd", "0x66", "0x13", "0xda", "0x6f", "0xf4", "0xa8", "0x9c", "0x00"}}, - { - /* No.486 delta:789 weight:981 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0xb85eea7e, 0xcc10c616, 0x744e2c68, 0x21901e68, 0x99cef416, 0xed80d87e, 0x55de3200, 0x00004652, 0xb85eac2c, 0xcc108044, 0x744e6a3a, 0x2190583a, 0x99ceb244, 0xed809e2c, 0x55de7452}, - [16]uint32{0x00000000, 0x0046c133, 0x2003020f, 0x2045c33c, 0xa0141115, 0xa052d026, 0x8017131a, 0x8051d229, 0x5000881b, 0x50464928, 0x70038a14, 0x70454b27, 0xf014990e, 0xf052583d, 0xd0179b01, 0xd0515a32}, - [16]uint32{0x3f800000, 0x3f802360, 0x3f900181, 0x3f9022e1, 0x3fd00a08, 0x3fd02968, 0x3fc00b89, 0x3fc028e9, 0x3fa80044, 0x3fa82324, 0x3fb801c5, 0x3fb822a5, 0x3ff80a4c, 0x3ff8292c, 0x3fe80bcd, 0x3fe828ad}, - uint32(0xfff80000), - [21]string{"0x39", "0xa7", "0x43", "0x82", "0x10", "0xf1", "0x92", "0xf4", "0x2f", "0x72", "0x84", "0x17", "0x0b", "0xc0", "0xf2", "0x11", "0x07", "0x37", "0x0a", "0x5f", "0x00"}}, - { - /* No.487 delta:809 weight:1233 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x9d9a9223, 0x96c66987, 0x0b5cfba4, 0x5e301e79, 0xc3aa8c5a, 0xc8f677fe, 0x556ce5dd, 0x00005333, 0x9d9ac110, 0x96c63ab4, 0x0b5ca897, 0x5e304d4a, 0xc3aadf69, 0xc8f624cd, 0x556cb6ee}, - [16]uint32{0x00000000, 0x80022115, 0x100280ff, 0x9000a1ea, 0x00022151, 0x80000044, 0x1000a1ae, 0x900280bb, 0x2002d816, 0xa000f903, 0x300058e9, 0xb00279fc, 0x2000f947, 0xa002d852, 0x300279b8, 0xb00058ad}, - [16]uint32{0x3f800000, 0x3fc00110, 0x3f880140, 0x3fc80050, 0x3f800110, 0x3fc00000, 0x3f880050, 0x3fc80140, 0x3f90016c, 0x3fd0007c, 0x3f98002c, 0x3fd8013c, 0x3f90007c, 0x3fd0016c, 0x3f98013c, 0x3fd8002c}, - uint32(0xfff80000), - [21]string{"0x7e", "0xb6", "0xab", "0x08", "0x94", "0x26", "0x29", "0x6d", "0x64", "0x90", "0x30", "0x0b", "0xf2", "0x59", "0x96", "0x33", "0x0c", "0x56", "0x49", "0x6e", "0x00"}}, - { - /* No.488 delta:767 weight:1605 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x83dbce25, 0x0f7c1229, 0x8ca7dc0c, 0xf4401e86, 0x779bd0a3, 0xfb3c0caf, 0x78e7c28a, 0x00008620, 0x83db4805, 0x0f7c9409, 0x8ca75a2c, 0xf44098a6, 0x779b5683, 0xfb3c8a8f, 0x78e744aa}, - [16]uint32{0x00000000, 0x0068101e, 0x00020509, 0x006a1517, 0x8029900b, 0x80418015, 0x802b9502, 0x8043851c, 0x10014807, 0x10695819, 0x10034d0e, 0x106b5d10, 0x9028d80c, 0x9040c812, 0x902add05, 0x9042cd1b}, - [16]uint32{0x3f800000, 0x3f803408, 0x3f800102, 0x3f80350a, 0x3fc014c8, 0x3fc020c0, 0x3fc015ca, 0x3fc021c2, 0x3f8800a4, 0x3f8834ac, 0x3f8801a6, 0x3f8835ae, 0x3fc8146c, 0x3fc82064, 0x3fc8156e, 0x3fc82166}, - uint32(0xfff80000), - [21]string{"0x8d", "0xa5", "0x7f", "0x9e", "0x3f", "0x68", "0x4c", "0xbb", "0xb0", "0x3c", "0xf5", "0x1f", "0x8a", "0xe6", "0xaf", "0x78", "0xbc", "0x05", "0x6b", "0x83", "0x00"}}, - { - /* No.489 delta:659 weight:1469 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0x965af929, 0x55575ec4, 0xc30da7ed, 0x1b301e90, 0x8d6ae7b9, 0x4e674054, 0xd83db97d, 0x0000d995, 0x965a20bc, 0x55578751, 0xc30d7e78, 0x1b30c705, 0x8d6a3e2c, 0x4e6799c1, 0xd83d60e8}, - [16]uint32{0x00000000, 0x4003ec1e, 0x10031935, 0x5000f52b, 0x001029b2, 0x4013c5ac, 0x10133087, 0x5010dc99, 0x80001213, 0xc003fe0d, 0x90030b26, 0xd000e738, 0x80103ba1, 0xc013d7bf, 0x90132294, 0xd010ce8a}, - [16]uint32{0x3f800000, 0x3fa001f6, 0x3f88018c, 0x3fa8007a, 0x3f800814, 0x3fa009e2, 0x3f880998, 0x3fa8086e, 0x3fc00009, 0x3fe001ff, 0x3fc80185, 0x3fe80073, 0x3fc0081d, 0x3fe009eb, 0x3fc80991, 0x3fe80867}, - uint32(0xfff80000), - [21]string{"0x86", "0x7f", "0xad", "0xde", "0xa5", "0x0a", "0x4a", "0x94", "0x67", "0xe3", "0xcf", "0x91", "0xe1", "0xc5", "0x2e", "0x2e", "0x81", "0x54", "0xf4", "0x76", "0x00"}}, - { - /* No.490 delta:2006 weight:1357 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x2c3a57a8, 0x7d913669, 0x51ab61c1, 0x8bc01ea9, 0xa7fa4901, 0xf65128c0, 0xda6b7f68, 0x0000fb64, 0x2c3aaccc, 0x7d91cd0d, 0x51ab9aa5, 0x8bc0e5cd, 0xa7fab265, 0xf651d3a4, 0xda6b840c}, - [16]uint32{0x00000000, 0x21a4a05e, 0x0a8105db, 0x2b25a585, 0x0494814a, 0x25302114, 0x0e158491, 0x2fb124cf, 0x6090251d, 0x41348543, 0x6a1120c6, 0x4bb58098, 0x6404a457, 0x45a00409, 0x6e85a18c, 0x4f2101d2}, - [16]uint32{0x3f800000, 0x3f90d250, 0x3f854082, 0x3f9592d2, 0x3f824a40, 0x3f929810, 0x3f870ac2, 0x3f97d892, 0x3fb04812, 0x3fa09a42, 0x3fb50890, 0x3fa5dac0, 0x3fb20252, 0x3fa2d002, 0x3fb742d0, 0x3fa79080}, - uint32(0xfff80000), - [21]string{"0xf4", "0x0f", "0xf1", "0x1f", "0xed", "0xdf", "0xba", "0x86", "0xea", "0x9b", "0xa8", "0x8b", "0x2f", "0x20", "0x30", "0x95", "0xb0", "0x77", "0x5c", "0xdf", "0x00"}}, - { - /* No.491 delta:1573 weight:1665 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x4eff2c33, 0xed467d5f, 0xa3b9516c, 0x71701eba, 0x3f8f3289, 0x9c3663e5, 0xd2c94fd6, 0x00008ae3, 0x4effa6d0, 0xed46f7bc, 0xa3b9db8f, 0x71709459, 0x3f8fb86a, 0x9c36e906, 0xd2c9c535}, - [16]uint32{0x00000000, 0x0838791a, 0x80101447, 0x88286d5d, 0xaae4a1e4, 0xa2dcd8fe, 0x2af4b5a3, 0x22ccccb9, 0x00714116, 0x0849380c, 0x80615551, 0x88592c4b, 0xaa95e0f2, 0xa2ad99e8, 0x2a85f4b5, 0x22bd8daf}, - [16]uint32{0x3f800000, 0x3f841c3c, 0x3fc0080a, 0x3fc41436, 0x3fd57250, 0x3fd16e6c, 0x3f957a5a, 0x3f916666, 0x3f8038a0, 0x3f84249c, 0x3fc030aa, 0x3fc42c96, 0x3fd54af0, 0x3fd156cc, 0x3f9542fa, 0x3f915ec6}, - uint32(0xfff80000), - [21]string{"0x43", "0x78", "0xfc", "0x4c", "0xe1", "0x28", "0x2a", "0x91", "0x6f", "0x5d", "0x7e", "0x43", "0x67", "0x9f", "0x17", "0x74", "0xb9", "0xdb", "0xa8", "0x88", "0x00"}}, - { - /* No.492 delta:1070 weight:1409 */ - 11213, - 64, - 13, - 4, - [16]uint32{0x00000000, 0xe9cd57ea, 0x44cf19b4, 0xad024e5e, 0x56201ec3, 0xbfed4929, 0x12ef0777, 0xfb22509d, 0x0000116d, 0xe9cd4687, 0x44cf08d9, 0xad025f33, 0x56200fae, 0xbfed5844, 0x12ef161a, 0xfb2241f0}, - [16]uint32{0x00000000, 0x5002c79a, 0x00032c0d, 0x5001eb97, 0x304c83cc, 0x604e4456, 0x304fafc1, 0x604d685b, 0x5003880f, 0x00014f95, 0x5000a402, 0x00026398, 0x604f0bc3, 0x304dcc59, 0x604c27ce, 0x304ee054}, - [16]uint32{0x3f800000, 0x3fa80163, 0x3f800196, 0x3fa800f5, 0x3f982641, 0x3fb02722, 0x3f9827d7, 0x3fb026b4, 0x3fa801c4, 0x3f8000a7, 0x3fa80052, 0x3f800131, 0x3fb02785, 0x3f9826e6, 0x3fb02613, 0x3f982770}, - uint32(0xfff80000), - [21]string{"0x24", "0x8c", "0x8b", "0x31", "0xdd", "0x5d", "0xe3", "0xe4", "0x00", "0x26", "0x0e", "0x6c", "0x42", "0xd3", "0x46", "0xe7", "0xbd", "0xe8", "0x67", "0x1a", "0x00"}}, - { - /* No.493 delta:1753 weight:1735 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x02767588, 0xd0730661, 0xd20573e9, 0xea701edc, 0xe8066b54, 0x3a0318bd, 0x38756d35, 0x0000b317, 0x0276c69f, 0xd073b576, 0xd205c0fe, 0xea70adcb, 0xe806d843, 0x3a03abaa, 0x3875de22}, - [16]uint32{0x00000000, 0x4006005e, 0x00020072, 0x4004002c, 0x00000114, 0x4006014a, 0x00020166, 0x40040138, 0x10200041, 0x5026001f, 0x10220033, 0x5024006d, 0x10200155, 0x5026010b, 0x10220127, 0x50240179}, - [16]uint32{0x3f800000, 0x3fa00300, 0x3f800100, 0x3fa00200, 0x3f800000, 0x3fa00300, 0x3f800100, 0x3fa00200, 0x3f881000, 0x3fa81300, 0x3f881100, 0x3fa81200, 0x3f881000, 0x3fa81300, 0x3f881100, 0x3fa81200}, - uint32(0xfff80000), - [21]string{"0xfb", "0x9b", "0x0c", "0xbf", "0x75", "0x1e", "0xf4", "0x4d", "0xef", "0xcf", "0x64", "0x01", "0xe6", "0x8d", "0x4a", "0x9d", "0x74", "0x82", "0xa5", "0xda", "0x00"}}, - { - /* No.494 delta:709 weight:1577 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0xd24d494b, 0x90952c70, 0x42d8653b, 0xf1f01ee5, 0x23bd57ae, 0x61653295, 0xb3287bde, 0x00009a06, 0xd24dd34d, 0x9095b676, 0x42d8ff3d, 0xf1f084e3, 0x23bdcda8, 0x6165a893, 0xb328e1d8}, - [16]uint32{0x00000000, 0x701e4a16, 0x0044181b, 0x705a520d, 0x20020581, 0x501c4f97, 0x20461d9a, 0x5058578c, 0x0003f013, 0x701dba05, 0x0047e808, 0x7059a21e, 0x2001f592, 0x501fbf84, 0x2045ed89, 0x505ba79f}, - [16]uint32{0x3f800000, 0x3fb80f25, 0x3f80220c, 0x3fb82d29, 0x3f900102, 0x3fa80e27, 0x3f90230e, 0x3fa82c2b, 0x3f8001f8, 0x3fb80edd, 0x3f8023f4, 0x3fb82cd1, 0x3f9000fa, 0x3fa80fdf, 0x3f9022f6, 0x3fa82dd3}, - uint32(0xfff80000), - [21]string{"0xb7", "0xb7", "0x54", "0x7d", "0x9e", "0x50", "0x47", "0x13", "0xf5", "0x7c", "0x05", "0x29", "0xdd", "0x89", "0x3b", "0x34", "0xd7", "0x53", "0x65", "0x79", "0x00"}}, - { - /* No.495 delta:1028 weight:1515 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x2fb43edf, 0x2e937a41, 0x0127449e, 0x2a201efc, 0x05942023, 0x04b364bd, 0x2b075a62, 0x0000280c, 0x2fb416d3, 0x2e93524d, 0x01276c92, 0x2a2036f0, 0x0594082f, 0x04b34cb1, 0x2b07726e}, - [16]uint32{0x00000000, 0x001401b6, 0x20021c51, 0x20161de7, 0x204180b2, 0x20558104, 0x00439ce3, 0x00579d55, 0x00138018, 0x000781ae, 0x20119c49, 0x20059dff, 0x205200aa, 0x2046011c, 0x00501cfb, 0x00441d4d}, - [16]uint32{0x3f800000, 0x3f800a00, 0x3f90010e, 0x3f900b0e, 0x3f9020c0, 0x3f902ac0, 0x3f8021ce, 0x3f802bce, 0x3f8009c0, 0x3f8003c0, 0x3f9008ce, 0x3f9002ce, 0x3f902900, 0x3f902300, 0x3f80280e, 0x3f80220e}, - uint32(0xfff80000), - [21]string{"0x4a", "0x8b", "0x2b", "0xb5", "0xdb", "0x72", "0x65", "0xb0", "0x8e", "0xe3", "0x03", "0x95", "0x6a", "0xe2", "0x5b", "0x6c", "0xe7", "0xa9", "0xbe", "0xab", "0x00"}}, - { - /* No.496 delta:752 weight:939 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0xa4c1cbc4, 0x361ad6d9, 0x92db1d1d, 0xcfa01f0b, 0x6b61d4cf, 0xf9bac9d2, 0x5d7b0216, 0x00007250, 0xa4c1b994, 0x361aa489, 0x92db6f4d, 0xcfa06d5b, 0x6b61a69f, 0xf9babb82, 0x5d7b7046}, - [16]uint32{0x00000000, 0x0002515e, 0x004b220a, 0x00497354, 0x400522b9, 0x400773e7, 0x404e00b3, 0x404c51ed, 0x30059904, 0x3007c85a, 0x304ebb0e, 0x304cea50, 0x7000bbbd, 0x7002eae3, 0x704b99b7, 0x7049c8e9}, - [16]uint32{0x3f800000, 0x3f800128, 0x3f802591, 0x3f8024b9, 0x3fa00291, 0x3fa003b9, 0x3fa02700, 0x3fa02628, 0x3f9802cc, 0x3f9803e4, 0x3f98275d, 0x3f982675, 0x3fb8005d, 0x3fb80175, 0x3fb825cc, 0x3fb824e4}, - uint32(0xfff80000), - [21]string{"0xa1", "0x8c", "0x80", "0x23", "0xeb", "0xa3", "0xb8", "0x86", "0xd7", "0xc0", "0x2b", "0xe6", "0xf1", "0x09", "0x7d", "0x9c", "0xef", "0xeb", "0xee", "0xae", "0x00"}}, - { - /* No.497 delta:1099 weight:1519 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x271f9562, 0xbbf030da, 0x9cefa5b8, 0xb7701f10, 0x906f8a72, 0x0c802fca, 0x2b9fbaa8, 0x0000198d, 0x271f8cef, 0xbbf02957, 0x9cefbc35, 0xb770069d, 0x906f93ff, 0x0c803647, 0x2b9fa325}, - [16]uint32{0x00000000, 0x800ba41e, 0xf010fd4d, 0x701b5953, 0x0003c6b9, 0x800862a7, 0xf0133bf4, 0x70189fea, 0x20081606, 0xa003b218, 0xd018eb4b, 0x50134f55, 0x200bd0bf, 0xa00074a1, 0xd01b2df2, 0x501089ec}, - [16]uint32{0x3f800000, 0x3fc005d2, 0x3ff8087e, 0x3fb80dac, 0x3f8001e3, 0x3fc00431, 0x3ff8099d, 0x3fb80c4f, 0x3f90040b, 0x3fd001d9, 0x3fe80c75, 0x3fa809a7, 0x3f9005e8, 0x3fd0003a, 0x3fe80d96, 0x3fa80844}, - uint32(0xfff80000), - [21]string{"0x27", "0xc2", "0x53", "0x1a", "0x1b", "0xd5", "0xc1", "0x6f", "0xd2", "0xbb", "0xb2", "0xc3", "0x27", "0xd1", "0xb9", "0x8f", "0xcd", "0x32", "0x22", "0x81", "0x00"}}, - { - /* No.498 delta:1303 weight:1655 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x1733fa30, 0xe70844d6, 0xf03bbee6, 0x35701f23, 0x2243e513, 0xd2785bf5, 0xc54ba1c5, 0x00005582, 0x1733afb2, 0xe7081154, 0xf03beb64, 0x35704aa1, 0x2243b091, 0xd2780e77, 0xc54bf447}, - [16]uint32{0x00000000, 0x184428f6, 0x007b940e, 0x183fbcf8, 0x0006500d, 0x184278fb, 0x007dc403, 0x1839ecf5, 0x30085014, 0x284c78e2, 0x3073c41a, 0x2837ecec, 0x300e0019, 0x284a28ef, 0x30759417, 0x2831bce1}, - [16]uint32{0x3f800000, 0x3f8c2214, 0x3f803dca, 0x3f8c1fde, 0x3f800328, 0x3f8c213c, 0x3f803ee2, 0x3f8c1cf6, 0x3f980428, 0x3f94263c, 0x3f9839e2, 0x3f941bf6, 0x3f980700, 0x3f942514, 0x3f983aca, 0x3f9418de}, - uint32(0xfff80000), - [21]string{"0x03", "0x29", "0x0f", "0x56", "0xb2", "0x78", "0x76", "0x1a", "0x98", "0x00", "0x16", "0xe4", "0x87", "0x2b", "0xd0", "0xea", "0x7e", "0x3d", "0x1a", "0x34", "0x00"}}, - { - /* No.499 delta:975 weight:939 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0x31621f00, 0x006813a0, 0x310a0ca0, 0xed401f38, 0xdc220038, 0xed280c98, 0xdc4a1398, 0x00004b3d, 0x3162543d, 0x0068589d, 0x310a479d, 0xed405405, 0xdc224b05, 0xed2847a5, 0xdc4a58a5}, - [16]uint32{0x00000000, 0x2d009196, 0x00984bdf, 0x2d98da49, 0x080ea1d9, 0x250e304f, 0x0896ea06, 0x25967b90, 0x2074060a, 0x0d74979c, 0x20ec4dd5, 0x0decdc43, 0x287aa7d3, 0x057a3645, 0x28e2ec0c, 0x05e27d9a}, - [16]uint32{0x3f800000, 0x3f968048, 0x3f804c25, 0x3f96cc6d, 0x3f840750, 0x3f928718, 0x3f844b75, 0x3f92cb3d, 0x3f903a03, 0x3f86ba4b, 0x3f907626, 0x3f86f66e, 0x3f943d53, 0x3f82bd1b, 0x3f947176, 0x3f82f13e}, - uint32(0xfff80000), - [21]string{"0x62", "0x1f", "0x93", "0x6c", "0xc5", "0x17", "0x97", "0x43", "0x43", "0x22", "0x46", "0x0f", "0xe9", "0x69", "0xff", "0x1c", "0x86", "0xe4", "0xca", "0x55", "0x00"}}, - { - /* No.500 delta:842 weight:1647 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0xdefa9e3b, 0xb4c11010, 0x6a3b8e2b, 0xe5a01f43, 0x3b5a8178, 0x51610f53, 0x8f9b9168, 0x0000857c, 0xdefa1b47, 0xb4c1956c, 0x6a3b0b57, 0xe5a09a3f, 0x3b5a0404, 0x51618a2f, 0x8f9b1414}, - [16]uint32{0x00000000, 0x29800f9a, 0x80038465, 0xa9838bff, 0x4040381c, 0x69c03786, 0xc043bc79, 0xe9c3b3e3, 0x40000411, 0x69800b8b, 0xc0038074, 0xe9838fee, 0x00403c0d, 0x29c03397, 0x8043b868, 0xa9c3b7f2}, - [16]uint32{0x3f800000, 0x3f94c007, 0x3fc001c2, 0x3fd4c1c5, 0x3fa0201c, 0x3fb4e01b, 0x3fe021de, 0x3ff4e1d9, 0x3fa00002, 0x3fb4c005, 0x3fe001c0, 0x3ff4c1c7, 0x3f80201e, 0x3f94e019, 0x3fc021dc, 0x3fd4e1db}, - uint32(0xfff80000), - [21]string{"0x37", "0x79", "0xef", "0x11", "0xfa", "0xbb", "0xd1", "0x60", "0x6a", "0x27", "0x2d", "0x86", "0x86", "0xe6", "0xc0", "0x06", "0x38", "0x2a", "0x2f", "0xd9", "0x00"}}, - { - /* No.501 delta:1691 weight:1569 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x1d0833ab, 0x1a2e9cbe, 0x0726af15, 0xed401f5d, 0xf0482cf6, 0xf76e83e3, 0xea66b048, 0x00000923, 0x1d083a88, 0x1a2e959d, 0x0726a636, 0xed40167e, 0xf04825d5, 0xf76e8ac0, 0xea66b96b}, - [16]uint32{0x00000000, 0x0b4a0674, 0x172a7607, 0x1c607073, 0x120c01cb, 0x194607bf, 0x052677cc, 0x0e6c71b8, 0x01089009, 0x0a42967d, 0x1622e60e, 0x1d68e07a, 0x130491c2, 0x184e97b6, 0x042ee7c5, 0x0f64e1b1}, - [16]uint32{0x3f800000, 0x3f85a503, 0x3f8b953b, 0x3f8e3038, 0x3f890600, 0x3f8ca303, 0x3f82933b, 0x3f873638, 0x3f808448, 0x3f85214b, 0x3f8b1173, 0x3f8eb470, 0x3f898248, 0x3f8c274b, 0x3f821773, 0x3f87b270}, - uint32(0xfff80000), - [21]string{"0x84", "0xae", "0x26", "0x5d", "0x95", "0x7a", "0xf4", "0x77", "0x7d", "0x0d", "0xaa", "0x7b", "0x7d", "0x47", "0xc2", "0xf8", "0xbe", "0x0a", "0x1b", "0x73", "0x00"}}, - { - /* No.502 delta:738 weight:1295 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x94c874ca, 0x9fe20cc4, 0x0b2a780e, 0xa5b01f6e, 0x31786ba4, 0x3a5213aa, 0xae9a6760, 0x0000862d, 0x94c8f2e7, 0x9fe28ae9, 0x0b2afe23, 0xa5b09943, 0x3178ed89, 0x3a529587, 0xae9ae14d}, - [16]uint32{0x00000000, 0xb0524a12, 0x420c81f1, 0xf25ecbe3, 0x00201169, 0xb0725b7b, 0x422c9098, 0xf27eda8a, 0x0049718c, 0xb01b3b9e, 0x4245f07d, 0xf217ba6f, 0x006960e5, 0xb03b2af7, 0x4265e114, 0xf237ab06}, - [16]uint32{0x3f800000, 0x3fd82925, 0x3fa10640, 0x3ff92f65, 0x3f801008, 0x3fd8392d, 0x3fa11648, 0x3ff93f6d, 0x3f8024b8, 0x3fd80d9d, 0x3fa122f8, 0x3ff90bdd, 0x3f8034b0, 0x3fd81d95, 0x3fa132f0, 0x3ff91bd5}, - uint32(0xfff80000), - [21]string{"0xf4", "0xff", "0x04", "0x85", "0x9a", "0x6f", "0x4a", "0x9a", "0x26", "0x75", "0xb2", "0x6c", "0xd6", "0x26", "0x47", "0xc0", "0x62", "0x9b", "0xe7", "0x2e", "0x00"}}, - { - /* No.503 delta:2181 weight:1281 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x259c0784, 0xe28c721e, 0xc710759a, 0x25401f7f, 0x00dc18fb, 0xc7cc6d61, 0xe2506ae5, 0x00004b77, 0x259c4cf3, 0xe28c3969, 0xc7103eed, 0x25405408, 0x00dc538c, 0xc7cc2616, 0xe2502192}, - [16]uint32{0x00000000, 0x090deb3e, 0x87b08223, 0x8ebd691d, 0x210a9879, 0x28077347, 0xa6ba1a5a, 0xafb7f164, 0x40316418, 0x493c8f26, 0xc781e63b, 0xce8c0d05, 0x613bfc61, 0x6836175f, 0xe68b7e42, 0xef86957c}, - [16]uint32{0x3f800000, 0x3f8486f5, 0x3fc3d841, 0x3fc75eb4, 0x3f90854c, 0x3f9403b9, 0x3fd35d0d, 0x3fd7dbf8, 0x3fa018b2, 0x3fa49e47, 0x3fe3c0f3, 0x3fe74606, 0x3fb09dfe, 0x3fb41b0b, 0x3ff345bf, 0x3ff7c34a}, - uint32(0xfff80000), - [21]string{"0xc7", "0xf7", "0x07", "0xf3", "0x63", "0x0c", "0x7c", "0x71", "0xf2", "0x55", "0x74", "0x61", "0xbf", "0x57", "0xb6", "0xdf", "0x32", "0x37", "0x21", "0x96", "0x00"}}, - { - /* No.504 delta:766 weight:1267 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x9f43d775, 0x7b36ec44, 0xe4753b31, 0x74d01f8c, 0xeb93c8f9, 0x0fe6f3c8, 0x90a524bd, 0x00005f7d, 0x9f438808, 0x7b36b339, 0xe475644c, 0x74d040f1, 0xeb939784, 0x0fe6acb5, 0x90a57bc0}, - [16]uint32{0x00000000, 0x2060b0f7, 0x10022a24, 0x30629ad3, 0x014d20fb, 0x212d900c, 0x114f0adf, 0x312fba28, 0x00648019, 0x200430ee, 0x1066aa3d, 0x30061aca, 0x0129a0e2, 0x21491015, 0x112b8ac6, 0x314b3a31}, - [16]uint32{0x3f800000, 0x3f903058, 0x3f880115, 0x3f98314d, 0x3f80a690, 0x3f9096c8, 0x3f88a785, 0x3f9897dd, 0x3f803240, 0x3f900218, 0x3f883355, 0x3f98030d, 0x3f8094d0, 0x3f90a488, 0x3f8895c5, 0x3f98a59d}, - uint32(0xfff80000), - [21]string{"0x06", "0x85", "0x1b", "0xdf", "0x27", "0xea", "0x66", "0x92", "0x13", "0x05", "0x26", "0x34", "0xeb", "0x54", "0x5d", "0x3e", "0xfb", "0xbb", "0xf7", "0x9b", "0x00"}}, - { - /* No.505 delta:979 weight:1611 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x55df1c42, 0x8ec3866e, 0xdb1c9a2c, 0x1b901f95, 0x4e4f03d7, 0x955399fb, 0xc08c85b9, 0x00009220, 0x55df8e62, 0x8ec3144e, 0xdb1c080c, 0x1b908db5, 0x4e4f91f7, 0x95530bdb, 0xc08c1799}, - [16]uint32{0x00000000, 0x380c955a, 0x020248b3, 0x3a0edde9, 0x20025374, 0x180ec62e, 0x22001bc7, 0x1a0c8e9d, 0x0003d32f, 0x380f4675, 0x02019b9c, 0x3a0d0ec6, 0x2001805b, 0x180d1501, 0x2203c8e8, 0x1a0f5db2}, - [16]uint32{0x3f800000, 0x3f9c064a, 0x3f810124, 0x3f9d076e, 0x3f900129, 0x3f8c0763, 0x3f91000d, 0x3f8d0647, 0x3f8001e9, 0x3f9c07a3, 0x3f8100cd, 0x3f9d0687, 0x3f9000c0, 0x3f8c068a, 0x3f9101e4, 0x3f8d07ae}, - uint32(0xfff80000), - [21]string{"0x23", "0x3c", "0x47", "0x37", "0x48", "0xb7", "0x8d", "0x06", "0xe7", "0xe9", "0x33", "0x18", "0xc6", "0xd8", "0xf4", "0x2b", "0x78", "0x66", "0x85", "0xa7", "0x00"}}, - { - /* No.506 delta:855 weight:1625 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0x170efc48, 0x3770a1e3, 0x207e5dab, 0x24701fa9, 0x337ee3e1, 0x1300be4a, 0x040e4202, 0x00002a96, 0x170ed6de, 0x37708b75, 0x207e773d, 0x2470353f, 0x337ec977, 0x130094dc, 0x040e6894}, - [16]uint32{0x00000000, 0x00060af6, 0x0482020d, 0x048408fb, 0x0002d201, 0x0004d8f7, 0x0480d00c, 0x0486dafa, 0x10409885, 0x10469273, 0x14c29a88, 0x14c4907e, 0x10424a84, 0x10444072, 0x14c04889, 0x14c6427f}, - [16]uint32{0x3f800000, 0x3f800305, 0x3f824101, 0x3f824204, 0x3f800169, 0x3f80026c, 0x3f824068, 0x3f82436d, 0x3f88204c, 0x3f882349, 0x3f8a614d, 0x3f8a6248, 0x3f882125, 0x3f882220, 0x3f8a6024, 0x3f8a6321}, - uint32(0xfff80000), - [21]string{"0x64", "0x5b", "0x4e", "0x08", "0x23", "0x49", "0x7e", "0x85", "0x00", "0x16", "0x27", "0x0a", "0x54", "0x38", "0xfc", "0x4a", "0x36", "0xe2", "0xe3", "0xbe", "0x00"}}, - { - /* No.507 delta:1930 weight:1461 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0x3a0ab12a, 0x860dc6e0, 0xbc0777ca, 0xa5001fbe, 0x9f0aae94, 0x230dd95e, 0x19076874, 0x0000b52e, 0x3a0a0404, 0x860d73ce, 0xbc07c2e4, 0xa500aa90, 0x9f0a1bba, 0x230d6c70, 0x1907dd5a}, - [16]uint32{0x00000000, 0x34803133, 0x0840201a, 0x3cc01129, 0x400180a8, 0x7481b19b, 0x4841a0b2, 0x7cc19181, 0x228c2dac, 0x160c1c9f, 0x2acc0db6, 0x1e4c3c85, 0x628dad04, 0x560d9c37, 0x6acd8d1e, 0x5e4dbc2d}, - [16]uint32{0x3f800000, 0x3f9a4018, 0x3f842010, 0x3f9e6008, 0x3fa000c0, 0x3fba40d8, 0x3fa420d0, 0x3fbe60c8, 0x3f914616, 0x3f8b060e, 0x3f956606, 0x3f8f261e, 0x3fb146d6, 0x3fab06ce, 0x3fb566c6, 0x3faf26de}, - uint32(0xfff80000), - [21]string{"0xca", "0x23", "0xf1", "0x6b", "0x02", "0x95", "0x73", "0x85", "0xc6", "0xbc", "0xb6", "0xc0", "0xb7", "0xc8", "0xe9", "0xab", "0x24", "0xe5", "0x9c", "0xbc", "0x00"}}, - { - /* No.508 delta:1148 weight:1473 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x3e476448, 0x2d19b410, 0x135ed058, 0x77701fc7, 0x49377b8f, 0x5a69abd7, 0x642ecf9f, 0x000014ac, 0x3e4770e4, 0x2d19a0bc, 0x135ec4f4, 0x77700b6b, 0x49376f23, 0x5a69bf7b, 0x642edb33}, - [16]uint32{0x00000000, 0x054cc11e, 0x003a7ab1, 0x0576bbaf, 0x00dc8b87, 0x05904a99, 0x00e6f136, 0x05aa3028, 0x00034012, 0x054f810c, 0x00393aa3, 0x0575fbbd, 0x00dfcb95, 0x05930a8b, 0x00e5b124, 0x05a9703a}, - [16]uint32{0x3f800000, 0x3f82a660, 0x3f801d3d, 0x3f82bb5d, 0x3f806e45, 0x3f82c825, 0x3f807378, 0x3f82d518, 0x3f8001a0, 0x3f82a7c0, 0x3f801c9d, 0x3f82bafd, 0x3f806fe5, 0x3f82c985, 0x3f8072d8, 0x3f82d4b8}, - uint32(0xfff80000), - [21]string{"0x2e", "0xa7", "0xb8", "0x82", "0x69", "0xd0", "0xd3", "0x6f", "0x5a", "0x01", "0xd6", "0x28", "0xdc", "0x82", "0xed", "0x83", "0xc8", "0x07", "0x5a", "0x0b", "0x00"}}, - { - /* No.509 delta:925 weight:1687 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0x7b4a4f00, 0xbacb592f, 0xc181162f, 0x9ca01fd3, 0xe7ea50d3, 0x266b46fc, 0x5d2109fc, 0x00000c91, 0x7b4a4391, 0xbacb55be, 0xc1811abe, 0x9ca01342, 0xe7ea5c42, 0x266b4a6d, 0x5d21056d}, - [16]uint32{0x00000000, 0x4003bc12, 0x80244a47, 0xc027f655, 0x0000580a, 0x4003e418, 0x8024124d, 0xc027ae5f, 0x4000058e, 0x0003b99c, 0xc0244fc9, 0x8027f3db, 0x40005d84, 0x0003e196, 0xc02417c3, 0x8027abd1}, - [16]uint32{0x3f800000, 0x3fa001de, 0x3fc01225, 0x3fe013fb, 0x3f80002c, 0x3fa001f2, 0x3fc01209, 0x3fe013d7, 0x3fa00002, 0x3f8001dc, 0x3fe01227, 0x3fc013f9, 0x3fa0002e, 0x3f8001f0, 0x3fe0120b, 0x3fc013d5}, - uint32(0xfff80000), - [21]string{"0xce", "0x41", "0xdf", "0xa3", "0xed", "0x34", "0x9e", "0x0d", "0xcd", "0xe8", "0x7a", "0xaa", "0x8c", "0xf2", "0x32", "0xd8", "0xa7", "0x47", "0x5f", "0xdc", "0x00"}}, - { - /* No.510 delta:871 weight:1739 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xe9b1101c, 0xaa673461, 0x43d6247d, 0x2c101fe6, 0xc5a10ffa, 0x86772b87, 0x6fc63b9b, 0x0000fe72, 0xe9b1ee6e, 0xaa67ca13, 0x43d6da0f, 0x2c10e194, 0xc5a1f188, 0x8677d5f5, 0x6fc6c5e9}, - [16]uint32{0x00000000, 0x20256a3e, 0x20000c51, 0x0025666f, 0x200230f6, 0x00275ac8, 0x00023ca7, 0x20275699, 0x1000215a, 0x30254b64, 0x30002d0b, 0x10254735, 0x300211ac, 0x10277b92, 0x10021dfd, 0x302777c3}, - [16]uint32{0x3f800000, 0x3f9012b5, 0x3f900006, 0x3f8012b3, 0x3f900118, 0x3f8013ad, 0x3f80011e, 0x3f9013ab, 0x3f880010, 0x3f9812a5, 0x3f980016, 0x3f8812a3, 0x3f980108, 0x3f8813bd, 0x3f88010e, 0x3f9813bb}, - uint32(0xfff80000), - [21]string{"0xc6", "0x00", "0x8d", "0x5d", "0x6f", "0xe5", "0x56", "0x01", "0xd3", "0xc9", "0xee", "0xa0", "0x9d", "0xf4", "0xa3", "0x87", "0x70", "0xf3", "0x36", "0x88", "0x00"}}, - { - /* No.511 delta:824 weight:741 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x26a409c0, 0xbfab6fe5, 0x990f6625, 0xc0801ffd, 0xe624163d, 0x7f2b7018, 0x598f79d8, 0x000072a2, 0x26a47b62, 0xbfab1d47, 0x990f1487, 0xc0806d5f, 0xe624649f, 0x7f2b02ba, 0x598f0b7a}, - [16]uint32{0x00000000, 0x38c204d7, 0x204b8134, 0x188985e3, 0x0270160f, 0x3ab212d8, 0x223b973b, 0x1af993ec, 0x004a021d, 0x388806ca, 0x20018329, 0x18c387fe, 0x023a1412, 0x3af810c5, 0x22719526, 0x1ab391f1}, - [16]uint32{0x3f800000, 0x3f9c6102, 0x3f9025c0, 0x3f8c44c2, 0x3f81380b, 0x3f9d5909, 0x3f911dcb, 0x3f8d7cc9, 0x3f802501, 0x3f9c4403, 0x3f9000c1, 0x3f8c61c3, 0x3f811d0a, 0x3f9d7c08, 0x3f9138ca, 0x3f8d59c8}, - uint32(0xfff80000), - [21]string{"0xdb", "0xf1", "0x57", "0xcc", "0xf3", "0xd1", "0xab", "0x93", "0xd9", "0xfd", "0xd6", "0xc0", "0x7b", "0x7e", "0x6c", "0x10", "0x59", "0x56", "0x7c", "0x00", "0x00"}}, - { - /* No.512 delta:1155 weight:1527 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0x87785293, 0x27be9c94, 0xa0c6ce07, 0xbd00200e, 0x3a78729d, 0x9abebc9a, 0x1dc6ee09, 0x00002d9f, 0x87787f0c, 0x27beb10b, 0xa0c6e398, 0xbd000d91, 0x3a785f02, 0x9abe9105, 0x1dc6c396}, - [16]uint32{0x00000000, 0x62048374, 0x106b4159, 0x726fc22d, 0x004028de, 0x6244abaa, 0x102b6987, 0x722feaf3, 0x40040c1c, 0x22008f68, 0x506f4d45, 0x326bce31, 0x404424c2, 0x2240a7b6, 0x502f659b, 0x322be6ef}, - [16]uint32{0x3f800000, 0x3fb10241, 0x3f8835a0, 0x3fb937e1, 0x3f802014, 0x3fb12255, 0x3f8815b4, 0x3fb917f5, 0x3fa00206, 0x3f910047, 0x3fa837a6, 0x3f9935e7, 0x3fa02212, 0x3f912053, 0x3fa817b2, 0x3f9915f3}, - uint32(0xfff80000), - [21]string{"0x2f", "0xf5", "0x9f", "0xfd", "0x60", "0xbf", "0x71", "0x7b", "0x30", "0x49", "0xf0", "0x60", "0x3d", "0xf9", "0xdb", "0x5f", "0xfd", "0x35", "0xd9", "0xf4", "0x00"}}, - { - /* No.513 delta:2160 weight:1327 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xce66cb8e, 0xa5b50647, 0x6bd3cdc9, 0xeae0201c, 0x2486eb92, 0x4f55265b, 0x8133edd5, 0x00008c09, 0xce664787, 0xa5b58a4e, 0x6bd341c0, 0xeae0ac15, 0x2486679b, 0x4f55aa52, 0x813361dc}, - [16]uint32{0x00000000, 0x0e84f4b6, 0x01001bca, 0x0f84ef7c, 0x40a40413, 0x4e20f0a5, 0x41a41fd9, 0x4f20eb6f, 0x86a80402, 0x882cf0b4, 0x87a81fc8, 0x892ceb7e, 0xc60c0011, 0xc888f4a7, 0xc70c1bdb, 0xc988ef6d}, - [16]uint32{0x3f800000, 0x3f87427a, 0x3f80800d, 0x3f87c277, 0x3fa05202, 0x3fa71078, 0x3fa0d20f, 0x3fa79075, 0x3fc35402, 0x3fc41678, 0x3fc3d40f, 0x3fc49675, 0x3fe30600, 0x3fe4447a, 0x3fe3860d, 0x3fe4c477}, - uint32(0xfff80000), - [21]string{"0x86", "0xe7", "0x33", "0x4f", "0x95", "0x55", "0xe5", "0x2f", "0x2f", "0xf0", "0x98", "0xae", "0x89", "0x27", "0x8b", "0x3b", "0xea", "0xa5", "0xd2", "0x3c", "0x00"}}, - { - /* No.514 delta:932 weight:1229 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x2cf347b3, 0xf0355ca5, 0xdcc61b16, 0xeb70202e, 0xc783679d, 0x1b457c8b, 0x37b63b38, 0x0000e034, 0x2cf3a787, 0xf035bc91, 0xdcc6fb22, 0xeb70c01a, 0xc78387a9, 0x1b459cbf, 0x37b6db0c}, - [16]uint32{0x00000000, 0x202c15d2, 0x1020a18d, 0x300cb45f, 0x8027601c, 0xa00b75ce, 0x9007c191, 0xb02bd443, 0x00023219, 0x202e27cb, 0x10229394, 0x300e8646, 0x80255205, 0xa00947d7, 0x9005f388, 0xb029e65a}, - [16]uint32{0x3f800000, 0x3f90160a, 0x3f881050, 0x3f98065a, 0x3fc013b0, 0x3fd005ba, 0x3fc803e0, 0x3fd815ea, 0x3f800119, 0x3f901713, 0x3f881149, 0x3f980743, 0x3fc012a9, 0x3fd004a3, 0x3fc802f9, 0x3fd814f3}, - uint32(0xfff80000), - [21]string{"0x73", "0xd0", "0xc5", "0x1c", "0xc2", "0x8b", "0x63", "0x1f", "0x12", "0x4a", "0xf1", "0x31", "0x9e", "0x05", "0xc2", "0x9f", "0x40", "0xdd", "0xa6", "0x69", "0x00"}}, - { - /* No.515 delta:1421 weight:1681 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0x70c0ae96, 0xca93687c, 0xba53c6ea, 0x10302035, 0x60f08ea3, 0xdaa34849, 0xaa63e6df, 0x00005744, 0x70c0f9d2, 0xca933f38, 0xba5391ae, 0x10307771, 0x60f0d9e7, 0xdaa31f0d, 0xaa63b19b}, - [16]uint32{0x00000000, 0x20036036, 0x3000001b, 0x1003602d, 0x308d212a, 0x108e411c, 0x008d2131, 0x208e4107, 0x000000c5, 0x200360f3, 0x300000de, 0x100360e8, 0x308d21ef, 0x108e41d9, 0x008d21f4, 0x208e41c2}, - [16]uint32{0x3f800000, 0x3f9001b0, 0x3f980000, 0x3f8801b0, 0x3f984690, 0x3f884720, 0x3f804690, 0x3f904720, 0x3f800000, 0x3f9001b0, 0x3f980000, 0x3f8801b0, 0x3f984690, 0x3f884720, 0x3f804690, 0x3f904720}, - uint32(0xfff80000), - [21]string{"0x5e", "0x19", "0x83", "0x9a", "0xe2", "0x58", "0x35", "0x9a", "0x2e", "0xc6", "0x5c", "0x6f", "0x0c", "0x99", "0xfa", "0x23", "0x0b", "0xc8", "0x65", "0x5e", "0x00"}}, - { - /* No.516 delta:2642 weight:857 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x1884afd0, 0x6afbbc31, 0x727f13e1, 0xa540204a, 0xbdc48f9a, 0xcfbb9c7b, 0xd73f33ab, 0x00002020, 0x18848ff0, 0x6afb9c11, 0x727f33c1, 0xa540006a, 0xbdc4afba, 0xcfbbbc5b, 0xd73f138b}, - [16]uint32{0x00000000, 0xeb40121c, 0x5a2883e3, 0xb16891ff, 0x55180235, 0xbe581029, 0x0f3081d6, 0xe47093ca, 0x14a20127, 0xffe2133b, 0x4e8a82c4, 0xa5ca90d8, 0x41ba0312, 0xaafa110e, 0x1b9280f1, 0xf0d292ed}, - [16]uint32{0x3f800000, 0x3ff5a009, 0x3fad1441, 0x3fd8b448, 0x3faa8c01, 0x3fdf2c08, 0x3f879840, 0x3ff23849, 0x3f8a5100, 0x3ffff109, 0x3fa74541, 0x3fd2e548, 0x3fa0dd01, 0x3fd57d08, 0x3f8dc940, 0x3ff86949}, - uint32(0xfff80000), - [21]string{"0x8a", "0xd8", "0xe6", "0x8c", "0x89", "0x7d", "0xc4", "0x12", "0x88", "0x81", "0x6b", "0x92", "0xa8", "0x51", "0xf8", "0x3c", "0x43", "0x95", "0x28", "0x13", "0x00"}}, - { - /* No.517 delta:3108 weight:621 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x08e91d00, 0x2e92e32f, 0x267bfe2f, 0x8c202052, 0x84c93d52, 0xa2b2c37d, 0xaa5bde7d, 0x00001bb1, 0x08e906b1, 0x2e92f89e, 0x267be59e, 0x8c203be3, 0x84c926e3, 0xa2b2d8cc, 0xaa5bc5cc}, - [16]uint32{0x00000000, 0xd14a003a, 0x24112134, 0xf55b210e, 0x0e39449d, 0xdf7344a7, 0x2a2865a9, 0xfb626593, 0x21d8588c, 0xf09258b6, 0x05c979b8, 0xd4837982, 0x2fe11c11, 0xfeab1c2b, 0x0bf03d25, 0xdaba3d1f}, - [16]uint32{0x3f800000, 0x3fe8a500, 0x3f920890, 0x3ffaad90, 0x3f871ca2, 0x3fefb9a2, 0x3f951432, 0x3ffdb132, 0x3f90ec2c, 0x3ff8492c, 0x3f82e4bc, 0x3fea41bc, 0x3f97f08e, 0x3fff558e, 0x3f85f81e, 0x3fed5d1e}, - uint32(0xfff80000), - [21]string{"0x87", "0xc2", "0x43", "0xa0", "0xbf", "0x42", "0xc6", "0x5a", "0x3d", "0xbd", "0x8f", "0x7b", "0x96", "0x17", "0x9f", "0xe7", "0x83", "0xff", "0xfe", "0xfd", "0x00"}}, - { - /* No.518 delta:1221 weight:1699 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0xbe7c1fc3, 0x2c7bf787, 0x9207e844, 0xc6702065, 0x780c3fa6, 0xea0bd7e2, 0x5477c821, 0x0000ece0, 0xbe7cf323, 0x2c7b1b67, 0x920704a4, 0xc670cc85, 0x780cd346, 0xea0b3b02, 0x547724c1}, - [16]uint32{0x00000000, 0x4061481a, 0x0074068f, 0x40154e95, 0x04148dd6, 0x4475c5cc, 0x04608b59, 0x4401c343, 0x80083004, 0xc069781e, 0x807c368b, 0xc01d7e91, 0x841cbdd2, 0xc47df5c8, 0x8468bb5d, 0xc409f347}, - [16]uint32{0x3f800000, 0x3fa030a4, 0x3f803a03, 0x3fa00aa7, 0x3f820a46, 0x3fa23ae2, 0x3f823045, 0x3fa200e1, 0x3fc00418, 0x3fe034bc, 0x3fc03e1b, 0x3fe00ebf, 0x3fc20e5e, 0x3fe23efa, 0x3fc2345d, 0x3fe204f9}, - uint32(0xfff80000), - [21]string{"0xaa", "0x0e", "0xfd", "0x66", "0x1e", "0xcb", "0x06", "0x51", "0x18", "0x32", "0x59", "0x68", "0x00", "0x67", "0x96", "0x9a", "0x6c", "0x1d", "0xe4", "0xf5", "0x00"}}, - { - /* No.519 delta:868 weight:1283 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0xe80ff725, 0x5677fca4, 0xbe780b81, 0x72b02078, 0x9abfd75d, 0x24c7dcdc, 0xccc82bf9, 0x0000939b, 0xe80f64be, 0x56776f3f, 0xbe78981a, 0x72b0b3e3, 0x9abf44c6, 0x24c74f47, 0xccc8b862}, - [16]uint32{0x00000000, 0x007c121e, 0x00121bca, 0x006e09d4, 0x40021611, 0x407e040f, 0x40100ddb, 0x406c1fc5, 0x1001225c, 0x107d3042, 0x10133996, 0x106f2b88, 0x5003344d, 0x507f2653, 0x50112f87, 0x506d3d99}, - [16]uint32{0x3f800000, 0x3f803e09, 0x3f80090d, 0x3f803704, 0x3fa0010b, 0x3fa03f02, 0x3fa00806, 0x3fa0360f, 0x3f880091, 0x3f883e98, 0x3f88099c, 0x3f883795, 0x3fa8019a, 0x3fa83f93, 0x3fa80897, 0x3fa8369e}, - uint32(0xfff80000), - [21]string{"0x5e", "0x97", "0xad", "0x3e", "0x61", "0xfb", "0x49", "0x2d", "0x78", "0x49", "0xf1", "0x71", "0xc5", "0xc7", "0x21", "0x22", "0xde", "0x54", "0x98", "0x49", "0x00"}}, - { - /* No.520 delta:940 weight:1315 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x6b3e4fd6, 0x3212cc5c, 0x592c838a, 0x61b0208c, 0x0a8e6f5a, 0x53a2ecd0, 0x389ca306, 0x0000af84, 0x6b3ee052, 0x321263d8, 0x592c2c0e, 0x61b08f08, 0x0a8ec0de, 0x53a24354, 0x389c0c82}, - [16]uint32{0x00000000, 0x0464813f, 0x0079406e, 0x041dc151, 0x40264844, 0x4442c97b, 0x405f082a, 0x443b8915, 0x00047912, 0x0460f82d, 0x007d397c, 0x0419b843, 0x40223156, 0x4446b069, 0x405b7138, 0x443ff007}, - [16]uint32{0x3f800000, 0x3f823240, 0x3f803ca0, 0x3f820ee0, 0x3fa01324, 0x3fa22164, 0x3fa02f84, 0x3fa21dc4, 0x3f80023c, 0x3f82307c, 0x3f803e9c, 0x3f820cdc, 0x3fa01118, 0x3fa22358, 0x3fa02db8, 0x3fa21ff8}, - uint32(0xfff80000), - [21]string{"0x95", "0xf9", "0x4c", "0xf4", "0x9f", "0xcb", "0x0b", "0xf9", "0xe6", "0x3b", "0x7a", "0xd5", "0x04", "0x1c", "0x90", "0xdc", "0x09", "0xd7", "0xf4", "0x25", "0x00"}}, - { - /* No.521 delta:751 weight:1163 */ - 11213, - 58, - 13, - 4, - [16]uint32{0x00000000, 0xc76cbb46, 0x460db42c, 0x81610f6a, 0xf1e02090, 0x368c9bd6, 0xb7ed94bc, 0x70812ffa, 0x0000287a, 0xc76c933c, 0x460d9c56, 0x81612710, 0xf1e008ea, 0x368cb3ac, 0xb7edbcc6, 0x70810780}, - [16]uint32{0x00000000, 0x000751fd, 0x0003431e, 0x000412e3, 0x5008e018, 0x500fb1e5, 0x500ba306, 0x500cf2fb, 0x2018760a, 0x201f27f7, 0x201b3514, 0x201c64e9, 0x70109612, 0x7017c7ef, 0x7013d50c, 0x701484f1}, - [16]uint32{0x3f800000, 0x3f8003a8, 0x3f8001a1, 0x3f800209, 0x3fa80470, 0x3fa807d8, 0x3fa805d1, 0x3fa80679, 0x3f900c3b, 0x3f900f93, 0x3f900d9a, 0x3f900e32, 0x3fb8084b, 0x3fb80be3, 0x3fb809ea, 0x3fb80a42}, - uint32(0xfff80000), - [21]string{"0xdf", "0x20", "0xca", "0xe9", "0xfa", "0xaf", "0x33", "0xf7", "0xcf", "0xe9", "0xd9", "0x75", "0x19", "0xee", "0xfb", "0x13", "0x5f", "0xc4", "0xe8", "0x07", "0x00"}}, - { - /* No.522 delta:1021 weight:1541 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xee60dd0c, 0xe2bf0b40, 0x0cdfd64c, 0x918020ac, 0x7fe0fda0, 0x733f2bec, 0x9d5ff6e0, 0x00007f2b, 0xee60a227, 0xe2bf746b, 0x0cdfa967, 0x91805f87, 0x7fe0828b, 0x733f54c7, 0x9d5f89cb}, - [16]uint32{0x00000000, 0x300281f6, 0x5001009f, 0x60038169, 0x0002601c, 0x3000e1ea, 0x50036083, 0x6001e175, 0x60004818, 0x5002c9ee, 0x30014887, 0x0003c971, 0x60022804, 0x5000a9f2, 0x3003289b, 0x0001a96d}, - [16]uint32{0x3f800000, 0x3f980140, 0x3fa80080, 0x3fb001c0, 0x3f800130, 0x3f980070, 0x3fa801b0, 0x3fb000f0, 0x3fb00024, 0x3fa80164, 0x3f9800a4, 0x3f8001e4, 0x3fb00114, 0x3fa80054, 0x3f980194, 0x3f8000d4}, - uint32(0xfff80000), - [21]string{"0xb6", "0x42", "0xb3", "0x91", "0x61", "0x41", "0x63", "0x9a", "0x5a", "0xf2", "0x92", "0xba", "0x92", "0xfa", "0x26", "0xee", "0xeb", "0xa2", "0x67", "0xa9", "0x00"}}, - { - /* No.523 delta:866 weight:1625 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0xca08d772, 0xc1b4ae65, 0x0bbc7917, 0xcc2020b5, 0x0628f7c7, 0x0d948ed0, 0xc79c59a2, 0x000047a0, 0xca0890d2, 0xc1b4e9c5, 0x0bbc3eb7, 0xcc206715, 0x0628b067, 0x0d94c970, 0xc79c1e02}, - [16]uint32{0x00000000, 0x10041e1a, 0x20039039, 0x30078e23, 0x00012196, 0x10053f8c, 0x2002b1af, 0x3006afb5, 0x1000707e, 0x00046e64, 0x3003e047, 0x2007fe5d, 0x100151e8, 0x00054ff2, 0x3002c1d1, 0x2006dfcb}, - [16]uint32{0x3f800000, 0x3f88020f, 0x3f9001c8, 0x3f9803c7, 0x3f800090, 0x3f88029f, 0x3f900158, 0x3f980357, 0x3f880038, 0x3f800237, 0x3f9801f0, 0x3f9003ff, 0x3f8800a8, 0x3f8002a7, 0x3f980160, 0x3f90036f}, - uint32(0xfff80000), - [21]string{"0x3d", "0xcb", "0xcc", "0x7b", "0xa0", "0xbf", "0x2a", "0xf5", "0x90", "0x94", "0xdd", "0x67", "0x81", "0x76", "0x1e", "0x40", "0xda", "0x4e", "0x1d", "0xa3", "0x00"}}, - { - /* No.524 delta:1005 weight:1233 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x73945edf, 0xcf5c4fe1, 0xbcc8113e, 0x06e020ce, 0x75747e11, 0xc9bc6f2f, 0xba2831f0, 0x000043fd, 0x73941d22, 0xcf5c0c1c, 0xbcc852c3, 0x06e06333, 0x75743dec, 0xc9bc2cd2, 0xba28720d}, - [16]uint32{0x00000000, 0x006ad0b2, 0x08440986, 0x082ed934, 0x1002801a, 0x106850a8, 0x1846899c, 0x182c592e, 0x00001a9f, 0x006aca2d, 0x08441319, 0x082ec3ab, 0x10029a85, 0x10684a37, 0x18469303, 0x182c43b1}, - [16]uint32{0x3f800000, 0x3f803568, 0x3f842204, 0x3f84176c, 0x3f880140, 0x3f883428, 0x3f8c2344, 0x3f8c162c, 0x3f80000d, 0x3f803565, 0x3f842209, 0x3f841761, 0x3f88014d, 0x3f883425, 0x3f8c2349, 0x3f8c1621}, - uint32(0xfff80000), - [21]string{"0x3f", "0x15", "0xdb", "0xe5", "0xf3", "0xfd", "0x2e", "0x67", "0x96", "0xa0", "0xbc", "0xee", "0x9b", "0x8c", "0xe6", "0x82", "0x10", "0x50", "0x4f", "0xaf", "0x00"}}, - { - /* No.525 delta:696 weight:1293 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0x8619f1d5, 0x2306a2ae, 0xa51f537b, 0xac2020d7, 0x2a39d102, 0x8f268279, 0x093f73ac, 0x00000901, 0x8619f8d4, 0x2306abaf, 0xa51f5a7a, 0xac2029d6, 0x2a39d803, 0x8f268b78, 0x093f7aad}, - [16]uint32{0x00000000, 0x30760532, 0x200b0011, 0x107d0523, 0x00413418, 0x3037312a, 0x204a3409, 0x103c313b, 0x0021600e, 0x3057653c, 0x202a601f, 0x105c652d, 0x00605416, 0x30165124, 0x206b5407, 0x101d5135}, - [16]uint32{0x3f800000, 0x3f983b02, 0x3f900580, 0x3f883e82, 0x3f80209a, 0x3f981b98, 0x3f90251a, 0x3f881e18, 0x3f8010b0, 0x3f982bb2, 0x3f901530, 0x3f882e32, 0x3f80302a, 0x3f980b28, 0x3f9035aa, 0x3f880ea8}, - uint32(0xfff80000), - [21]string{"0xd0", "0x25", "0xe2", "0xae", "0x30", "0x67", "0x30", "0xa6", "0x0e", "0x2a", "0xaa", "0x14", "0x30", "0x01", "0x17", "0x1d", "0x6e", "0x2b", "0x04", "0x42", "0x00"}}, - { - /* No.526 delta:919 weight:1573 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0xecd500d4, 0x0b96a1db, 0xe743a10f, 0xcaf020e0, 0x26252034, 0xc166813b, 0x2db381ef, 0x0000b14e, 0xecd5b19a, 0x0b961095, 0xe7431041, 0xcaf091ae, 0x2625917a, 0xc1663075, 0x2db330a1}, - [16]uint32{0x00000000, 0x305de097, 0x200200a5, 0x105fe032, 0x00034c18, 0x305eac8f, 0x20014cbd, 0x105cac2a, 0x50050019, 0x6058e08e, 0x700700bc, 0x405ae02b, 0x50064c01, 0x605bac96, 0x70044ca4, 0x4059ac33}, - [16]uint32{0x3f800000, 0x3f982ef0, 0x3f900100, 0x3f882ff0, 0x3f8001a6, 0x3f982f56, 0x3f9000a6, 0x3f882e56, 0x3fa80280, 0x3fb02c70, 0x3fb80380, 0x3fa02d70, 0x3fa80326, 0x3fb02dd6, 0x3fb80226, 0x3fa02cd6}, - uint32(0xfff80000), - [21]string{"0xff", "0x22", "0xd9", "0x6c", "0xc5", "0xcd", "0xd0", "0xa0", "0xcf", "0x50", "0xd6", "0x1a", "0xa1", "0xc2", "0x11", "0x9e", "0x9c", "0xa9", "0xcc", "0xae", "0x00"}}, - { - /* No.527 delta:1935 weight:1457 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0xfc225ba0, 0x742ebe4f, 0x880ce5ef, 0x4c4020fb, 0xb0627b5b, 0x386e9eb4, 0xc44cc514, 0x00003ee1, 0xfc226541, 0x742e80ae, 0x880cdb0e, 0x4c401e1a, 0xb06245ba, 0x386ea055, 0xc44cfbf5}, - [16]uint32{0x00000000, 0x0c2409be, 0x28012182, 0x2425283c, 0x10008416, 0x1c248da8, 0x3801a594, 0x3425ac2a, 0x0a13840f, 0x06378db1, 0x2212a58d, 0x2e36ac33, 0x1a130019, 0x163709a7, 0x3212219b, 0x3e362825}, - [16]uint32{0x3f800000, 0x3f861204, 0x3f940090, 0x3f921294, 0x3f880042, 0x3f8e1246, 0x3f9c00d2, 0x3f9a12d6, 0x3f8509c2, 0x3f831bc6, 0x3f910952, 0x3f971b56, 0x3f8d0980, 0x3f8b1b84, 0x3f990910, 0x3f9f1b14}, - uint32(0xfff80000), - [21]string{"0xaf", "0x0c", "0xcc", "0xd1", "0x2b", "0x2a", "0xb8", "0xdc", "0xfe", "0x84", "0x16", "0xda", "0x8d", "0x9a", "0x6e", "0xfc", "0xed", "0xe8", "0xb4", "0xab", "0x00"}}, - { - /* No.528 delta:1000 weight:1189 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x2de15ca2, 0x0cef7303, 0x210e2fa1, 0x22702103, 0x0f917da1, 0x2e9f5200, 0x037e0ea2, 0x000086e4, 0x2de1da46, 0x0ceff5e7, 0x210ea945, 0x2270a7e7, 0x0f91fb45, 0x2e9fd4e4, 0x037e8846}, - [16]uint32{0x00000000, 0x182e01de, 0x0002b097, 0x182cb149, 0x0009e012, 0x1827e1cc, 0x000b5085, 0x1825515b, 0x400e019f, 0x58200041, 0x400cb108, 0x5822b0d6, 0x4007e18d, 0x5829e053, 0x4005511a, 0x582b50c4}, - [16]uint32{0x3f800000, 0x3f8c1700, 0x3f800158, 0x3f8c1658, 0x3f8004f0, 0x3f8c13f0, 0x3f8005a8, 0x3f8c12a8, 0x3fa00700, 0x3fac1000, 0x3fa00658, 0x3fac1158, 0x3fa003f0, 0x3fac14f0, 0x3fa002a8, 0x3fac15a8}, - uint32(0xfff80000), - [21]string{"0x99", "0xa0", "0xc4", "0xb6", "0x54", "0xa9", "0x6d", "0x83", "0x09", "0x43", "0xf9", "0x31", "0x8d", "0xcd", "0x34", "0xfb", "0x24", "0xf7", "0x6e", "0x54", "0x00"}}, - { - /* No.529 delta:829 weight:1699 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x71cae969, 0x0fef3654, 0x7e25df3d, 0x21402113, 0x508ac87a, 0x2eaf1747, 0x5f65fe2e, 0x0000dd55, 0x71ca343c, 0x0fefeb01, 0x7e250268, 0x2140fc46, 0x508a152f, 0x2eafca12, 0x5f65237b}, - [16]uint32{0x00000000, 0x80020492, 0x400201b6, 0xc0000524, 0x200001ef, 0xa002057d, 0x60020059, 0xe00004cb, 0x05218811, 0x85238c83, 0x452389a7, 0xc5218d35, 0x252189fe, 0xa5238d6c, 0x65238848, 0xe5218cda}, - [16]uint32{0x3f800000, 0x3fc00102, 0x3fa00100, 0x3fe00002, 0x3f900000, 0x3fd00102, 0x3fb00100, 0x3ff00002, 0x3f8290c4, 0x3fc291c6, 0x3fa291c4, 0x3fe290c6, 0x3f9290c4, 0x3fd291c6, 0x3fb291c4, 0x3ff290c6}, - uint32(0xfff80000), - [21]string{"0x16", "0x3a", "0xc1", "0x00", "0xdc", "0xf2", "0x82", "0x39", "0x11", "0x7d", "0xe6", "0x33", "0xc3", "0xad", "0x09", "0x5a", "0xfe", "0x5a", "0x22", "0xff", "0x00"}}, - { - /* No.530 delta:881 weight:1203 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x3e4c2af6, 0xad4ff67e, 0x9303dc88, 0xe0a02120, 0xdeec0bd6, 0x4defd75e, 0x73a3fda8, 0x0000f19a, 0x3e4cdb6c, 0xad4f07e4, 0x93032d12, 0xe0a0d0ba, 0xdeecfa4c, 0x4def26c4, 0x73a30c32}, - [16]uint32{0x00000000, 0x00655e1d, 0x611d611a, 0x61783f07, 0x000341a5, 0x00661fb8, 0x611e20bf, 0x617b7ea2, 0x0044c176, 0x00219f6b, 0x6159a06c, 0x613cfe71, 0x004780d3, 0x0022dece, 0x615ae1c9, 0x613fbfd4}, - [16]uint32{0x3f800000, 0x3f8032af, 0x3fb08eb0, 0x3fb0bc1f, 0x3f8001a0, 0x3f80330f, 0x3fb08f10, 0x3fb0bdbf, 0x3f802260, 0x3f8010cf, 0x3fb0acd0, 0x3fb09e7f, 0x3f8023c0, 0x3f80116f, 0x3fb0ad70, 0x3fb09fdf}, - uint32(0xfff80000), - [21]string{"0x2f", "0xb6", "0x72", "0x3f", "0x72", "0x6a", "0xb8", "0x55", "0x63", "0xff", "0xf8", "0xd0", "0xaa", "0x76", "0x69", "0x80", "0x03", "0x44", "0x7b", "0x3a", "0x00"}}, - { - /* No.531 delta:890 weight:1451 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x3508c08f, 0x598443ed, 0x6c8c8362, 0xb8002138, 0x8d08e1b7, 0xe18462d5, 0xd48ca25a, 0x000092b0, 0x3508523f, 0x5984d15d, 0x6c8c11d2, 0xb800b388, 0x8d087307, 0xe184f065, 0xd48c30ea}, - [16]uint32{0x00000000, 0x40029cbd, 0x10060ce3, 0x5004905e, 0x000300fb, 0x40019c46, 0x10050c18, 0x500790a5, 0x1000180c, 0x500284b1, 0x000614ef, 0x40048852, 0x100318f7, 0x5001844a, 0x00051414, 0x400788a9}, - [16]uint32{0x3f800000, 0x3fa0014e, 0x3f880306, 0x3fa80248, 0x3f800180, 0x3fa000ce, 0x3f880286, 0x3fa803c8, 0x3f88000c, 0x3fa80142, 0x3f80030a, 0x3fa00244, 0x3f88018c, 0x3fa800c2, 0x3f80028a, 0x3fa003c4}, - uint32(0xfff80000), - [21]string{"0x75", "0xfe", "0x4f", "0xb9", "0xda", "0xd1", "0x10", "0x9a", "0x79", "0xe3", "0x31", "0x2e", "0x8c", "0x51", "0xf6", "0x90", "0x4f", "0xda", "0x2e", "0xa0", "0x00"}}, - { - /* No.532 delta:943 weight:1581 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0xa90fb87a, 0x3ce8537c, 0x95e7eb06, 0xf620214e, 0x5f2f9934, 0xcac87232, 0x63c7ca48, 0x000048da, 0xa90ff0a0, 0x3ce81ba6, 0x95e7a3dc, 0xf6206994, 0x5f2fd1ee, 0xcac83ae8, 0x63c78292}, - [16]uint32{0x00000000, 0x00420055, 0x0003419e, 0x004141cb, 0x0000881a, 0x0042884f, 0x0003c984, 0x0041c9d1, 0x203c3138, 0x207e316d, 0x203f70a6, 0x207d70f3, 0x203cb922, 0x207eb977, 0x203ff8bc, 0x207df8e9}, - [16]uint32{0x3f800000, 0x3f802100, 0x3f8001a0, 0x3f8020a0, 0x3f800044, 0x3f802144, 0x3f8001e4, 0x3f8020e4, 0x3f901e18, 0x3f903f18, 0x3f901fb8, 0x3f903eb8, 0x3f901e5c, 0x3f903f5c, 0x3f901ffc, 0x3f903efc}, - uint32(0xfff80000), - [21]string{"0x4f", "0xc3", "0x64", "0xeb", "0x40", "0x4f", "0x3b", "0xf9", "0x5b", "0x6b", "0xcf", "0x99", "0xd4", "0xef", "0x0d", "0xc6", "0xb1", "0xe5", "0x04", "0xd1", "0x00"}}, - { - /* No.533 delta:2031 weight:1369 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x88568c8f, 0xf3727684, 0x7b24fa0b, 0xe940215e, 0x6116add1, 0x1a3257da, 0x9264db55, 0x00001ac7, 0x88569648, 0xf3726c43, 0x7b24e0cc, 0xe9403b99, 0x6116b716, 0x1a324d1d, 0x9264c192}, - [16]uint32{0x00000000, 0x05358432, 0x0c80040b, 0x09b58039, 0x158c3186, 0x10b9b5b4, 0x190c358d, 0x1c39b1bf, 0x204625f5, 0x2573a1c7, 0x2cc621fe, 0x29f3a5cc, 0x35ca1473, 0x30ff9041, 0x394a1078, 0x3c7f944a}, - [16]uint32{0x3f800000, 0x3f829ac2, 0x3f864002, 0x3f84dac0, 0x3f8ac618, 0x3f885cda, 0x3f8c861a, 0x3f8e1cd8, 0x3f902312, 0x3f92b9d0, 0x3f966310, 0x3f94f9d2, 0x3f9ae50a, 0x3f987fc8, 0x3f9ca508, 0x3f9e3fca}, - uint32(0xfff80000), - [21]string{"0x29", "0xa5", "0x53", "0x15", "0xb5", "0x8e", "0x70", "0x08", "0x7b", "0xc3", "0x1f", "0xfe", "0x48", "0x8b", "0xfb", "0x91", "0x3a", "0x6d", "0x5d", "0x7a", "0x00"}}, - { - /* No.534 delta:1133 weight:1449 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0x109f073d, 0x4d854320, 0x5d1a441d, 0x8c50216e, 0x9ccf2653, 0xc1d5624e, 0xd14a6573, 0x00006145, 0x109f6678, 0x4d852265, 0x5d1a2558, 0x8c50402b, 0x9ccf4716, 0xc1d5030b, 0xd14a0436}, - [16]uint32{0x00000000, 0x02071b7e, 0x004ca419, 0x024bbf67, 0x00024096, 0x02055be8, 0x004ee48f, 0x0249fff1, 0x4018300c, 0x421f2b72, 0x40549415, 0x42538f6b, 0x401a709a, 0x421d6be4, 0x4056d483, 0x4251cffd}, - [16]uint32{0x3f800000, 0x3f81038d, 0x3f802652, 0x3f8125df, 0x3f800120, 0x3f8102ad, 0x3f802772, 0x3f8124ff, 0x3fa00c18, 0x3fa10f95, 0x3fa02a4a, 0x3fa129c7, 0x3fa00d38, 0x3fa10eb5, 0x3fa02b6a, 0x3fa128e7}, - uint32(0xfff80000), - [21]string{"0x40", "0x8f", "0x2f", "0xbe", "0x50", "0x9c", "0x0b", "0xc9", "0x23", "0x60", "0xce", "0xe2", "0x8c", "0x7d", "0x0e", "0x13", "0x80", "0x29", "0xa5", "0x8e", "0x00"}}, - { - /* No.535 delta:900 weight:1519 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0xfcab2249, 0x1301a5c1, 0xefaa8788, 0x0eb02179, 0xf21b0330, 0x1db184b8, 0xe11aa6f1, 0x0000d9b7, 0xfcabfbfe, 0x13017c76, 0xefaa5e3f, 0x0eb0f8ce, 0xf21bda87, 0x1db15d0f, 0xe11a7f46}, - [16]uint32{0x00000000, 0x004390da, 0x20035e03, 0x2040ced9, 0x5008e1d7, 0x504b710d, 0x700bbfd4, 0x70482f0e, 0x0000a046, 0x0043309c, 0x2003fe45, 0x20406e9f, 0x50084191, 0x504bd14b, 0x700b1f92, 0x70488f48}, - [16]uint32{0x3f800000, 0x3f8021c8, 0x3f9001af, 0x3f902067, 0x3fa80470, 0x3fa825b8, 0x3fb805df, 0x3fb82417, 0x3f800050, 0x3f802198, 0x3f9001ff, 0x3f902037, 0x3fa80420, 0x3fa825e8, 0x3fb8058f, 0x3fb82447}, - uint32(0xfff80000), - [21]string{"0x0e", "0x7c", "0xd8", "0xbf", "0x93", "0x39", "0x20", "0x31", "0x2b", "0x29", "0x2f", "0xad", "0xe5", "0x60", "0x07", "0x06", "0xf0", "0xce", "0xbf", "0xda", "0x00"}}, - { - /* No.536 delta:1464 weight:1661 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xfb4ed716, 0x133c8328, 0xe872543e, 0x99b0218f, 0x62fef699, 0x8a8ca2a7, 0x71c275b1, 0x000072aa, 0xfb4ea5bc, 0x133cf182, 0xe8722694, 0x99b05325, 0x62fe8433, 0x8a8cd00d, 0x71c2071b}, - [16]uint32{0x00000000, 0x004029fe, 0x4e64e0d8, 0x4e24c926, 0xc21b4074, 0xc25b698a, 0x8c7fa0ac, 0x8c3f8952, 0x003a4175, 0x007a688b, 0x4e5ea1ad, 0x4e1e8853, 0xc2210101, 0xc26128ff, 0x8c45e1d9, 0x8c05c827}, - [16]uint32{0x3f800000, 0x3f802014, 0x3fa73270, 0x3fa71264, 0x3fe10da0, 0x3fe12db4, 0x3fc63fd0, 0x3fc61fc4, 0x3f801d20, 0x3f803d34, 0x3fa72f50, 0x3fa70f44, 0x3fe11080, 0x3fe13094, 0x3fc622f0, 0x3fc602e4}, - uint32(0xfff80000), - [21]string{"0x8c", "0x97", "0xe4", "0xbd", "0x3c", "0x81", "0x04", "0xdc", "0xcd", "0x97", "0x82", "0x0c", "0xad", "0x62", "0xe3", "0xb7", "0xf2", "0x3d", "0xf6", "0x61", "0x00"}}, - { - /* No.537 delta:2148 weight:1369 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x5bfd1d30, 0x60d1a7a5, 0x3b2cba95, 0xfed02196, 0xa52d3ca6, 0x9e018633, 0xc5fc9b03, 0x00002e81, 0x5bfd33b1, 0x60d18924, 0x3b2c9414, 0xfed00f17, 0xa52d1227, 0x9e01a8b2, 0xc5fcb582}, - [16]uint32{0x00000000, 0x1c0034f4, 0x0208080e, 0x1e083cfa, 0x09040018, 0x150434ec, 0x0b0c0816, 0x170c3ce2, 0x1220a206, 0x0e2096f2, 0x1028aa08, 0x0c289efc, 0x1b24a21e, 0x072496ea, 0x192caa10, 0x052c9ee4}, - [16]uint32{0x3f800000, 0x3f8e001a, 0x3f810404, 0x3f8f041e, 0x3f848200, 0x3f8a821a, 0x3f858604, 0x3f8b861e, 0x3f891051, 0x3f87104b, 0x3f881455, 0x3f86144f, 0x3f8d9251, 0x3f83924b, 0x3f8c9655, 0x3f82964f}, - uint32(0xfff80000), - [21]string{"0xc2", "0x36", "0xf2", "0x66", "0xcc", "0x1b", "0x1c", "0x2a", "0x20", "0xa7", "0x46", "0x50", "0xec", "0xd2", "0xd6", "0x0e", "0x5b", "0x83", "0x2e", "0xcd", "0x00"}}, - { - /* No.538 delta:708 weight:1613 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0x9cb14c88, 0xfa6f7a45, 0x66de36cd, 0x50a021a6, 0xcc116d2e, 0xaacf5be3, 0x367e176b, 0x0000b83e, 0x9cb1f4b6, 0xfa6fc27b, 0x66de8ef3, 0x50a09998, 0xcc11d510, 0xaacfe3dd, 0x367eaf55}, - [16]uint32{0x00000000, 0x0023433e, 0x001028b1, 0x00336b8f, 0x2100d0b2, 0x2123938c, 0x2110f803, 0x2133bb3d, 0x40004616, 0x40230528, 0x40106ea7, 0x40332d99, 0x610096a4, 0x6123d59a, 0x6110be15, 0x6133fd2b}, - [16]uint32{0x3f800000, 0x3f8011a1, 0x3f800814, 0x3f8019b5, 0x3f908068, 0x3f9091c9, 0x3f90887c, 0x3f9099dd, 0x3fa00023, 0x3fa01182, 0x3fa00837, 0x3fa01996, 0x3fb0804b, 0x3fb091ea, 0x3fb0885f, 0x3fb099fe}, - uint32(0xfff80000), - [21]string{"0x23", "0x66", "0x6a", "0xe2", "0x68", "0x07", "0x37", "0x50", "0xd0", "0xf9", "0xac", "0xbb", "0x10", "0x29", "0xcf", "0x1f", "0x11", "0x14", "0xfd", "0x53", "0x00"}}, - { - /* No.539 delta:595 weight:1545 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0xd0895f38, 0xfd6b6245, 0x2de23d7d, 0x6b4021b2, 0xbbc97e8a, 0x962b43f7, 0x46a21ccf, 0x0000d42b, 0xd0898b13, 0xfd6bb66e, 0x2de2e956, 0x6b40f599, 0xbbc9aaa1, 0x962b97dc, 0x46a2c8e4}, - [16]uint32{0x00000000, 0x4401541b, 0x1802419d, 0x5c031586, 0x40402612, 0x04417209, 0x5842678f, 0x1c433394, 0x2002b803, 0x6403ec18, 0x3800f99e, 0x7c01ad85, 0x60429e11, 0x2443ca0a, 0x7840df8c, 0x3c418b97}, - [16]uint32{0x3f800000, 0x3fa200aa, 0x3f8c0120, 0x3fae018a, 0x3fa02013, 0x3f8220b9, 0x3fac2133, 0x3f8e2199, 0x3f90015c, 0x3fb201f6, 0x3f9c007c, 0x3fbe00d6, 0x3fb0214f, 0x3f9221e5, 0x3fbc206f, 0x3f9e20c5}, - uint32(0xfff80000), - [21]string{"0x35", "0x85", "0x51", "0x8f", "0xfb", "0x07", "0x00", "0x28", "0xad", "0xf3", "0xa5", "0xc0", "0xd7", "0x38", "0x07", "0x26", "0xc5", "0xab", "0xba", "0x9a", "0x00"}}, - { - /* No.540 delta:1110 weight:1529 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x21135886, 0x8c1229fd, 0xad01717b, 0x3d8021ce, 0x1c937948, 0xb1920833, 0x908150b5, 0x00008e94, 0x2113d612, 0x8c12a769, 0xad01ffef, 0x3d80af5a, 0x1c93f7dc, 0xb19286a7, 0x9081de21}, - [16]uint32{0x00000000, 0xb04e16d2, 0x78605ae3, 0xc82e4c31, 0x400c2c05, 0xf0423ad7, 0x386c76e6, 0x88226034, 0x0002021d, 0xb04c14cf, 0x786258fe, 0xc82c4e2c, 0x400e2e18, 0xf04038ca, 0x386e74fb, 0x88206229}, - [16]uint32{0x3f800000, 0x3fd8270b, 0x3fbc302d, 0x3fe41726, 0x3fa00616, 0x3ff8211d, 0x3f9c363b, 0x3fc41130, 0x3f800101, 0x3fd8260a, 0x3fbc312c, 0x3fe41627, 0x3fa00717, 0x3ff8201c, 0x3f9c373a, 0x3fc41031}, - uint32(0xfff80000), - [21]string{"0x37", "0x49", "0x93", "0x4e", "0x5c", "0x24", "0xa2", "0x0b", "0x56", "0x99", "0x3f", "0xad", "0xe4", "0x97", "0xd9", "0xbd", "0x4d", "0xb1", "0x8b", "0x91", "0x00"}}, - { - /* No.541 delta:2067 weight:1351 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x5a2ff8fe, 0x326dc2b6, 0x68423a48, 0x037021d3, 0x595fd92d, 0x311de365, 0x6b321b9b, 0x0000b75e, 0x5a2f4fa0, 0x326d75e8, 0x68428d16, 0x0370968d, 0x595f6e73, 0x311d543b, 0x6b32acc5}, - [16]uint32{0x00000000, 0x287f21ba, 0x0e0446ee, 0x267b6754, 0x01f28422, 0x298da598, 0x0ff6c2cc, 0x2789e376, 0x09008087, 0x217fa13d, 0x0704c669, 0x2f7be7d3, 0x08f204a5, 0x208d251f, 0x06f6424b, 0x2e8963f1}, - [16]uint32{0x3f800000, 0x3f943f90, 0x3f870223, 0x3f933db3, 0x3f80f942, 0x3f94c6d2, 0x3f87fb61, 0x3f93c4f1, 0x3f848040, 0x3f90bfd0, 0x3f838263, 0x3f97bdf3, 0x3f847902, 0x3f904692, 0x3f837b21, 0x3f9744b1}, - uint32(0xfff80000), - [21]string{"0x53", "0x34", "0x92", "0xf8", "0x0f", "0x41", "0x89", "0x50", "0x59", "0x43", "0x6c", "0x71", "0x00", "0x5d", "0xa3", "0xa5", "0x2c", "0x54", "0x1b", "0xf0", "0x00"}}, - { - /* No.542 delta:1168 weight:1381 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xc3ba3870, 0xc960e4c4, 0x0adadcb4, 0x2b3021e6, 0xe88a1996, 0xe250c522, 0x21eafd52, 0x00001b17, 0xc3ba2367, 0xc960ffd3, 0x0adac7a3, 0x2b303af1, 0xe88a0281, 0xe250de35, 0x21eae645}, - [16]uint32{0x00000000, 0x00248d1e, 0x0003b08a, 0x00273d94, 0x0a208012, 0x0a040d0c, 0x0a233098, 0x0a07bd86, 0x02048187, 0x02200c99, 0x0207310d, 0x0223bc13, 0x08240195, 0x08008c8b, 0x0827b11f, 0x08033c01}, - [16]uint32{0x3f800000, 0x3f801246, 0x3f8001d8, 0x3f80139e, 0x3f851040, 0x3f850206, 0x3f851198, 0x3f8503de, 0x3f810240, 0x3f811006, 0x3f810398, 0x3f8111de, 0x3f841200, 0x3f840046, 0x3f8413d8, 0x3f84019e}, - uint32(0xfff80000), - [21]string{"0xff", "0x49", "0x62", "0x3a", "0x76", "0x10", "0xd1", "0xe2", "0xb9", "0x1b", "0x7e", "0x0a", "0x40", "0xa0", "0xd8", "0x64", "0x1c", "0x13", "0x9e", "0x1c", "0x00"}}, - { - /* No.543 delta:676 weight:1575 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0x1ddf4c5e, 0x8884e2ee, 0x955baeb0, 0x6d0021f5, 0x70df6dab, 0xe584c31b, 0xf85b8f45, 0x00001c20, 0x1ddf507e, 0x8884fece, 0x955bb290, 0x6d003dd5, 0x70df718b, 0xe584df3b, 0xf85b9365}, - [16]uint32{0x00000000, 0x5026c9de, 0x4048010d, 0x106ec8d3, 0x400292ef, 0x10245b31, 0x004a93e2, 0x506c5a3c, 0x4001ca0a, 0x102703d4, 0x0049cb07, 0x506f02d9, 0x000358e5, 0x5025913b, 0x404b59e8, 0x106d9036}, - [16]uint32{0x3f800000, 0x3fa81364, 0x3fa02400, 0x3f883764, 0x3fa00149, 0x3f88122d, 0x3f802549, 0x3fa8362d, 0x3fa000e5, 0x3f881381, 0x3f8024e5, 0x3fa83781, 0x3f8001ac, 0x3fa812c8, 0x3fa025ac, 0x3f8836c8}, - uint32(0xfff80000), - [21]string{"0x0a", "0x84", "0x89", "0xe8", "0x9d", "0xbf", "0x19", "0xc9", "0xb3", "0x63", "0x6a", "0xdf", "0x85", "0xe2", "0x29", "0x03", "0x9a", "0x2d", "0x8f", "0xf7", "0x00"}}, - { - /* No.544 delta:1742 weight:1469 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0x1db1d24c, 0x3eec97d6, 0x235d459a, 0xbff02201, 0xa241f04d, 0x811cb5d7, 0x9cad679b, 0x0000db96, 0x1db109da, 0x3eec4c40, 0x235d9e0c, 0xbff0f997, 0xa2412bdb, 0x811c6e41, 0x9cadbc0d}, - [16]uint32{0x00000000, 0x31384436, 0x40c001b9, 0x71f8458f, 0x38b8807e, 0x0980c448, 0x787881c7, 0x4940c5f1, 0x52081018, 0x6330542e, 0x12c811a1, 0x23f05597, 0x6ab09066, 0x5b88d450, 0x2a7091df, 0x1b48d5e9}, - [16]uint32{0x3f800000, 0x3f989c22, 0x3fa06000, 0x3fb8fc22, 0x3f9c5c40, 0x3f84c062, 0x3fbc3c40, 0x3fa4a062, 0x3fa90408, 0x3fb1982a, 0x3f896408, 0x3f91f82a, 0x3fb55848, 0x3fadc46a, 0x3f953848, 0x3f8da46a}, - uint32(0xfff80000), - [21]string{"0x5d", "0x57", "0x9f", "0xb9", "0x09", "0x68", "0xaa", "0x32", "0x0b", "0x19", "0x00", "0x5f", "0xc2", "0x02", "0x33", "0x83", "0xc0", "0x88", "0xca", "0x73", "0x00"}}, - { - /* No.545 delta:830 weight:723 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0xee61c1c7, 0x48d9eb95, 0xa6b82a52, 0xf9a02216, 0x17c1e3d1, 0xb179c983, 0x5f180844, 0x00006f97, 0xee61ae50, 0x48d98402, 0xa6b845c5, 0xf9a04d81, 0x17c18c46, 0xb179a614, 0x5f1867d3}, - [16]uint32{0x00000000, 0x10411315, 0x603f901b, 0x707e830e, 0x102415f1, 0x006506e4, 0x701b85ea, 0x605a96ff, 0x10ac8194, 0x00ed9281, 0x7093118f, 0x60d2029a, 0x00889465, 0x10c98770, 0x60b7047e, 0x70f6176b}, - [16]uint32{0x3f800000, 0x3f882089, 0x3fb01fc8, 0x3fb83f41, 0x3f88120a, 0x3f803283, 0x3fb80dc2, 0x3fb02d4b, 0x3f885640, 0x3f8076c9, 0x3fb84988, 0x3fb06901, 0x3f80444a, 0x3f8864c3, 0x3fb05b82, 0x3fb87b0b}, - uint32(0xfff80000), - [21]string{"0xb5", "0x09", "0x80", "0x60", "0xc1", "0x22", "0xe5", "0x13", "0xa4", "0x13", "0x8a", "0xcf", "0x38", "0xeb", "0x40", "0xb5", "0x3e", "0x96", "0x89", "0x04", "0x00"}}, - { - /* No.546 delta:2306 weight:1231 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x9557ec1a, 0x9e675f66, 0x0b30b37c, 0x2380222d, 0xb6d7ce37, 0xbde77d4b, 0x28b09151, 0x00002e09, 0x9557c213, 0x9e67716f, 0x0b309d75, 0x23800c24, 0xb6d7e03e, 0xbde75342, 0x28b0bf58}, - [16]uint32{0x00000000, 0x246a61f2, 0x17e8907f, 0x3382f18d, 0x0d101161, 0x297a7093, 0x1af8811e, 0x3e92e0ec, 0x1a850135, 0x3eef60c7, 0x0d6d914a, 0x2907f0b8, 0x17951054, 0x33ff71a6, 0x007d802b, 0x2417e1d9}, - [16]uint32{0x3f800000, 0x3f923530, 0x3f8bf448, 0x3f99c178, 0x3f868808, 0x3f94bd38, 0x3f8d7c40, 0x3f9f4970, 0x3f8d4280, 0x3f9f77b0, 0x3f86b6c8, 0x3f9483f8, 0x3f8bca88, 0x3f99ffb8, 0x3f803ec0, 0x3f920bf0}, - uint32(0xfff80000), - [21]string{"0xf5", "0x78", "0xf8", "0x7a", "0xea", "0xe8", "0x7e", "0x79", "0x68", "0x19", "0x03", "0xe7", "0x2e", "0x31", "0x48", "0x7f", "0x24", "0x1f", "0xef", "0xc1", "0x00"}}, - { - /* No.547 delta:819 weight:1241 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x124cbc0f, 0x7941082e, 0x6b0db421, 0xebc0223b, 0xf98c9e34, 0x92812a15, 0x80cd961a, 0x0000f4d0, 0x124c48df, 0x7941fcfe, 0x6b0d40f1, 0xebc0d6eb, 0xf98c6ae4, 0x9281dec5, 0x80cd62ca}, - [16]uint32{0x00000000, 0x4102013b, 0x20022839, 0x61002902, 0xc001e047, 0x8103e17c, 0xe003c87e, 0xa101c945, 0x00402008, 0x41422133, 0x20420831, 0x6140090a, 0xc041c04f, 0x8143c174, 0xe043e876, 0xa141e94d}, - [16]uint32{0x3f800000, 0x3fa08100, 0x3f900114, 0x3fb08014, 0x3fe000f0, 0x3fc081f0, 0x3ff001e4, 0x3fd080e4, 0x3f802010, 0x3fa0a110, 0x3f902104, 0x3fb0a004, 0x3fe020e0, 0x3fc0a1e0, 0x3ff021f4, 0x3fd0a0f4}, - uint32(0xfff80000), - [21]string{"0xd8", "0xd7", "0xda", "0x57", "0xb2", "0x55", "0x76", "0xb0", "0x45", "0x38", "0x12", "0x5b", "0xeb", "0x97", "0x49", "0xe6", "0x15", "0x53", "0xc2", "0x46", "0x00"}}, - { - /* No.548 delta:1676 weight:1543 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0xf4586abb, 0xe4feef64, 0x10a685df, 0xd8002240, 0x2c5848fb, 0x3cfecd24, 0xc8a6a79f, 0x0000ad37, 0xf458c78c, 0xe4fe4253, 0x10a628e8, 0xd8008f77, 0x2c58e5cc, 0x3cfe6013, 0xc8a60aa8}, - [16]uint32{0x00000000, 0x001451de, 0x00420055, 0x0056518b, 0x0010007c, 0x000451a2, 0x00520029, 0x004651f7, 0x100000bf, 0x10145161, 0x104200ea, 0x10565134, 0x101000c3, 0x1004511d, 0x10520096, 0x10465148}, - [16]uint32{0x3f800000, 0x3f800a28, 0x3f802100, 0x3f802b28, 0x3f800800, 0x3f800228, 0x3f802900, 0x3f802328, 0x3f880000, 0x3f880a28, 0x3f882100, 0x3f882b28, 0x3f880800, 0x3f880228, 0x3f882900, 0x3f882328}, - uint32(0xfff80000), - [21]string{"0x2d", "0x27", "0x80", "0xf8", "0x2f", "0xd3", "0xe0", "0x35", "0x59", "0x1e", "0xbf", "0xa6", "0xf9", "0x0b", "0xce", "0x96", "0xec", "0x01", "0xbc", "0xd2", "0x00"}}, - { - /* No.549 delta:1031 weight:1483 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x0d932aec, 0x3a81cfe8, 0x3712e504, 0x7b202257, 0x76b308bb, 0x41a1edbf, 0x4c32c753, 0x00000174, 0x0d932b98, 0x3a81ce9c, 0x3712e470, 0x7b202323, 0x76b309cf, 0x41a1eccb, 0x4c32c627}, - [16]uint32{0x00000000, 0x402c71de, 0x406e6003, 0x004211dd, 0x0002a417, 0x402ed5c9, 0x406cc414, 0x0040b5ca, 0x1062d615, 0x504ea7cb, 0x500cb616, 0x1020c7c8, 0x10607202, 0x504c03dc, 0x500e1201, 0x102263df}, - [16]uint32{0x3f800000, 0x3fa01638, 0x3fa03730, 0x3f802108, 0x3f800152, 0x3fa0176a, 0x3fa03662, 0x3f80205a, 0x3f88316b, 0x3fa82753, 0x3fa8065b, 0x3f881063, 0x3f883039, 0x3fa82601, 0x3fa80709, 0x3f881131}, - uint32(0xfff80000), - [21]string{"0x02", "0xd6", "0xe1", "0x55", "0xc4", "0x13", "0x0e", "0x73", "0x9a", "0xe4", "0x74", "0x49", "0x61", "0x30", "0x0f", "0xdc", "0x10", "0xcc", "0xdf", "0x9e", "0x00"}}, - { - /* No.550 delta:1409 weight:1553 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0x695f4080, 0x98f256d6, 0xf1ad1656, 0xaee02263, 0xc7bf62e3, 0x361274b5, 0x5f4d3435, 0x00006737, 0x695f27b7, 0x98f231e1, 0xf1ad7161, 0xaee04554, 0xc7bf05d4, 0x36121382, 0x5f4d5302}, - [16]uint32{0x00000000, 0x085780b6, 0x201d617c, 0x284ae1ca, 0x00024112, 0x0855c1a4, 0x201f206e, 0x2848a0d8, 0x0001001b, 0x085680ad, 0x201c6167, 0x284be1d1, 0x00034109, 0x0854c1bf, 0x201e2075, 0x2849a0c3}, - [16]uint32{0x3f800000, 0x3f842bc0, 0x3f900eb0, 0x3f942570, 0x3f800120, 0x3f842ae0, 0x3f900f90, 0x3f942450, 0x3f800080, 0x3f842b40, 0x3f900e30, 0x3f9425f0, 0x3f8001a0, 0x3f842a60, 0x3f900f10, 0x3f9424d0}, - uint32(0xfff80000), - [21]string{"0x30", "0xdd", "0x63", "0x3b", "0xc8", "0xfa", "0xb2", "0x63", "0x72", "0xe1", "0xfc", "0x6d", "0xe7", "0x00", "0xb4", "0x1b", "0xdf", "0x93", "0xe1", "0x92", "0x00"}}, - { - /* No.551 delta:2268 weight:1229 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x0b958c40, 0x6147f0e1, 0x6ad27ca1, 0xb370227d, 0xb8e5ae3d, 0xd237d29c, 0xd9a25edc, 0x0000ff96, 0x0b9573d6, 0x61470f77, 0x6ad28337, 0xb370ddeb, 0xb8e551ab, 0xd2372d0a, 0xd9a2a14a}, - [16]uint32{0x00000000, 0x0e1a0136, 0x228d2094, 0x2c9721a2, 0x104009ed, 0x1e5a08db, 0x32cd2979, 0x3cd7284f, 0x4103c013, 0x4f19c125, 0x638ee087, 0x6d94e1b1, 0x5143c9fe, 0x5f59c8c8, 0x73cee96a, 0x7dd4e85c}, - [16]uint32{0x3f800000, 0x3f870d00, 0x3f914690, 0x3f964b90, 0x3f882004, 0x3f8f2d04, 0x3f996694, 0x3f9e6b94, 0x3fa081e0, 0x3fa78ce0, 0x3fb1c770, 0x3fb6ca70, 0x3fa8a1e4, 0x3faface4, 0x3fb9e774, 0x3fbeea74}, - uint32(0xfff80000), - [21]string{"0x20", "0x02", "0x63", "0x23", "0x8a", "0x32", "0x10", "0xf2", "0xca", "0x39", "0x5f", "0x26", "0xa0", "0x22", "0x0e", "0x1a", "0xde", "0x1d", "0xbe", "0x76", "0x00"}}, - { - /* No.552 delta:1408 weight:1223 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xde290d7b, 0xbe0f8a5a, 0x60268721, 0x8a002282, 0x54292ff9, 0x340fa8d8, 0xea26a5a3, 0x00004e5d, 0xde294326, 0xbe0fc407, 0x6026c97c, 0x8a006cdf, 0x542961a4, 0x340fe685, 0xea26ebfe}, - [16]uint32{0x00000000, 0x005e5197, 0x2a3001d1, 0x2a6e5046, 0x00160019, 0x0048518e, 0x2a2601c8, 0x2a78505f, 0x0002400d, 0x005c119a, 0x2a3241dc, 0x2a6c104b, 0x00144014, 0x004a1183, 0x2a2441c5, 0x2a7a1052}, - [16]uint32{0x3f800000, 0x3f802f28, 0x3f951800, 0x3f953728, 0x3f800b00, 0x3f802428, 0x3f951300, 0x3f953c28, 0x3f800120, 0x3f802e08, 0x3f951920, 0x3f953608, 0x3f800a20, 0x3f802508, 0x3f951220, 0x3f953d08}, - uint32(0xfff80000), - [21]string{"0x0f", "0xed", "0x1d", "0x72", "0xc8", "0xee", "0xfe", "0x5a", "0x4e", "0x1a", "0xc3", "0x4e", "0xa8", "0x76", "0xc0", "0xfe", "0xe8", "0x35", "0xac", "0xab", "0x00"}}, - { - /* No.553 delta:1650 weight:1523 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x9ca1406d, 0xb6bfd945, 0x2a1e9928, 0x3cb02292, 0xa01162ff, 0x8a0ffbd7, 0x16aebbba, 0x0000f10a, 0x9ca1b167, 0xb6bf284f, 0x2a1e6822, 0x3cb0d398, 0xa01193f5, 0x8a0f0add, 0x16ae4ab0}, - [16]uint32{0x00000000, 0x0dd22e9a, 0x31c22073, 0x3c100ee9, 0x2083a08d, 0x2d518e17, 0x114180fe, 0x1c93ae64, 0x0301a055, 0x0ed38ecf, 0x32c38026, 0x3f11aebc, 0x238200d8, 0x2e502e42, 0x124020ab, 0x1f920e31}, - [16]uint32{0x3f800000, 0x3f86e917, 0x3f98e110, 0x3f9e0807, 0x3f9041d0, 0x3f96a8c7, 0x3f88a0c0, 0x3f8e49d7, 0x3f8180d0, 0x3f8769c7, 0x3f9961c0, 0x3f9f88d7, 0x3f91c100, 0x3f972817, 0x3f892010, 0x3f8fc907}, - uint32(0xfff80000), - [21]string{"0x9e", "0x3b", "0xd3", "0x59", "0x77", "0x60", "0x67", "0x46", "0x36", "0x62", "0xda", "0x24", "0x08", "0x5b", "0x66", "0x1c", "0x9d", "0x6a", "0xef", "0x30", "0x00"}}, - { - /* No.554 delta:1729 weight:1621 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x891fe769, 0x5d23546f, 0xd43cb306, 0x921022ad, 0x1b0fc5c4, 0xcf3376c2, 0x462c91ab, 0x0000bcff, 0x891f5b96, 0x5d23e890, 0xd43c0ff9, 0x92109e52, 0x1b0f793b, 0xcf33ca3d, 0x462c2d54}, - [16]uint32{0x00000000, 0x00422076, 0x90344094, 0x907660e2, 0x2c14001a, 0x2c56206c, 0xbc20408e, 0xbc6260f8, 0x000221eb, 0x0040019d, 0x9036617f, 0x90744109, 0x2c1621f1, 0x2c540187, 0xbc226165, 0xbc604113}, - [16]uint32{0x3f800000, 0x3f802110, 0x3fc81a20, 0x3fc83b30, 0x3f960a00, 0x3f962b10, 0x3fde1020, 0x3fde3130, 0x3f800110, 0x3f802000, 0x3fc81b30, 0x3fc83a20, 0x3f960b10, 0x3f962a00, 0x3fde1130, 0x3fde3020}, - uint32(0xfff80000), - [21]string{"0xbe", "0x6c", "0xf3", "0xfd", "0xe9", "0x01", "0x45", "0x29", "0xbd", "0xfd", "0x6f", "0x6f", "0x2f", "0x4a", "0xf2", "0xb2", "0xa9", "0x6b", "0xda", "0x3a", "0x00"}}, - { - /* No.555 delta:991 weight:1627 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0x0f9e99c8, 0x04d29090, 0x0b4c0958, 0xbd8022bb, 0xb21ebb73, 0xb952b22b, 0xb6cc2be3, 0x0000d220, 0x0f9e4be8, 0x04d242b0, 0x0b4cdb78, 0xbd80f09b, 0xb21e6953, 0xb952600b, 0xb6ccf9c3}, - [16]uint32{0x00000000, 0x30021c3e, 0x0002001b, 0x30001c25, 0x404d2201, 0x704f3e3f, 0x404f221a, 0x704d3e24, 0x507e3086, 0x607c2cb8, 0x507c309d, 0x607e2ca3, 0x10331287, 0x20310eb9, 0x1031129c, 0x20330ea2}, - [16]uint32{0x3f800000, 0x3f98010e, 0x3f800100, 0x3f98000e, 0x3fa02691, 0x3fb8279f, 0x3fa02791, 0x3fb8269f, 0x3fa83f18, 0x3fb03e16, 0x3fa83e18, 0x3fb03f16, 0x3f881989, 0x3f901887, 0x3f881889, 0x3f901987}, - uint32(0xfff80000), - [21]string{"0xf3", "0x38", "0x30", "0x54", "0x0e", "0x91", "0xf8", "0x1e", "0x23", "0xc7", "0x58", "0x59", "0x9b", "0x08", "0x33", "0x2f", "0xeb", "0xe2", "0x06", "0xe2", "0x00"}}, - { - /* No.556 delta:1172 weight:1635 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0x7ab2da65, 0xe01f151e, 0x9aadcf7b, 0x240022ce, 0x5eb2f8ab, 0xc41f37d0, 0xbeadedb5, 0x000051cb, 0x7ab28bae, 0xe01f44d5, 0x9aad9eb0, 0x24007305, 0x5eb2a960, 0xc41f661b, 0xbeadbc7e}, - [16]uint32{0x00000000, 0x70402df2, 0x0065041b, 0x702529e9, 0x001abc78, 0x705a918a, 0x007fb863, 0x703f9591, 0x00028d61, 0x7042a093, 0x0067897a, 0x7027a488, 0x00183119, 0x70581ceb, 0x007d3502, 0x703d18f0}, - [16]uint32{0x3f800000, 0x3fb82016, 0x3f803282, 0x3fb81294, 0x3f800d5e, 0x3fb82d48, 0x3f803fdc, 0x3fb81fca, 0x3f800146, 0x3fb82150, 0x3f8033c4, 0x3fb813d2, 0x3f800c18, 0x3fb82c0e, 0x3f803e9a, 0x3fb81e8c}, - uint32(0xfff80000), - [21]string{"0xa1", "0x68", "0x0b", "0xdb", "0x03", "0xc0", "0xb3", "0x79", "0x39", "0xd3", "0x9c", "0x3f", "0x3b", "0x83", "0x22", "0x78", "0xc3", "0xaf", "0x50", "0x74", "0x00"}}, - { - /* No.557 delta:1072 weight:1203 */ - 11213, - 36, - 13, - 4, - [16]uint32{0x00000000, 0x0361420c, 0x032db76a, 0x004cf566, 0xa68022d2, 0xa5e160de, 0xa5ad95b8, 0xa6ccd7b4, 0x000022af, 0x036160a3, 0x032d95c5, 0x004cd7c9, 0xa680007d, 0xa5e14271, 0xa5adb717, 0xa6ccf51b}, - [16]uint32{0x00000000, 0x203ecb3a, 0x4003a951, 0x603d626b, 0x800000c5, 0xa03ecbff, 0xc003a994, 0xe03d62ae, 0x4000690c, 0x603ea236, 0x0003c05d, 0x203d0b67, 0xc00069c9, 0xe03ea2f3, 0x8003c098, 0xa03d0ba2}, - [16]uint32{0x3f800000, 0x3f901f65, 0x3fa001d4, 0x3fb01eb1, 0x3fc00000, 0x3fd01f65, 0x3fe001d4, 0x3ff01eb1, 0x3fa00034, 0x3fb01f51, 0x3f8001e0, 0x3f901e85, 0x3fe00034, 0x3ff01f51, 0x3fc001e0, 0x3fd01e85}, - uint32(0xfff80000), - [21]string{"0xe1", "0x4b", "0x8a", "0x46", "0x7f", "0x4c", "0x9f", "0xbc", "0xb6", "0x0d", "0x39", "0x66", "0x06", "0xd0", "0x1f", "0x14", "0x60", "0xdd", "0xe6", "0x36", "0x00"}}, - { - /* No.558 delta:1131 weight:1691 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x9cdcd095, 0xe7ba2488, 0x7b66f41d, 0xda6022ec, 0x46bcf279, 0x3dda0664, 0xa106d6f1, 0x00002257, 0x9cdcf2c2, 0xe7ba06df, 0x7b66d64a, 0xda6000bb, 0x46bcd02e, 0x3dda2433, 0xa106f4a6}, - [16]uint32{0x00000000, 0x101da8de, 0x2027f16c, 0x303a59b2, 0x0041f1b5, 0x105c596b, 0x206600d9, 0x307ba807, 0x00312816, 0x102c80c8, 0x2016d97a, 0x300b71a4, 0x0070d9a3, 0x106d717d, 0x205728cf, 0x304a8011}, - [16]uint32{0x3f800000, 0x3f880ed4, 0x3f9013f8, 0x3f981d2c, 0x3f8020f8, 0x3f882e2c, 0x3f903300, 0x3f983dd4, 0x3f801894, 0x3f881640, 0x3f900b6c, 0x3f9805b8, 0x3f80386c, 0x3f8836b8, 0x3f902b94, 0x3f982540}, - uint32(0xfff80000), - [21]string{"0x1c", "0x93", "0x74", "0xb4", "0xe8", "0x21", "0x0c", "0x01", "0xf9", "0xa5", "0xf3", "0x38", "0x74", "0xcb", "0x7f", "0xec", "0x8f", "0xe6", "0x0c", "0xa7", "0x00"}}, - { - /* No.559 delta:1644 weight:1465 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x6e552ab0, 0xce5848d0, 0xa00d6260, 0x451022f2, 0x2b450842, 0x8b486a22, 0xe51d4092, 0x000081a6, 0x6e55ab16, 0xce58c976, 0xa00de3c6, 0x4510a354, 0x2b4589e4, 0x8b48eb84, 0xe51dc134}, - [16]uint32{0x00000000, 0x086f4d97, 0x2072340a, 0x281d799d, 0x11004011, 0x196f0d86, 0x3172741b, 0x391d398c, 0x208899e5, 0x28e7d472, 0x00faadef, 0x0895e078, 0x3188d9f4, 0x39e79463, 0x11faedfe, 0x1995a069}, - [16]uint32{0x3f800000, 0x3f8437a6, 0x3f90391a, 0x3f940ebc, 0x3f888020, 0x3f8cb786, 0x3f98b93a, 0x3f9c8e9c, 0x3f90444c, 0x3f9473ea, 0x3f807d56, 0x3f844af0, 0x3f98c46c, 0x3f9cf3ca, 0x3f88fd76, 0x3f8ccad0}, - uint32(0xfff80000), - [21]string{"0x3d", "0xc3", "0x9a", "0x1e", "0xc7", "0x7f", "0x5b", "0xa4", "0x5a", "0xc9", "0x17", "0x9f", "0xeb", "0x61", "0xe8", "0x87", "0x65", "0x30", "0xd8", "0xfc", "0x00"}}, - { - /* No.560 delta:735 weight:1721 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0x2143c00e, 0x0f98a6f3, 0x2edb66fd, 0x1f50230c, 0x3e13e302, 0x10c885ff, 0x318b45f1, 0x00004f2d, 0x21438f23, 0x0f98e9de, 0x2edb29d0, 0x1f506c21, 0x3e13ac2f, 0x10c8cad2, 0x318b0adc}, - [16]uint32{0x00000000, 0x006489f2, 0x20041009, 0x206099fb, 0x0003d1d7, 0x00675825, 0x2007c1de, 0x2063482c, 0x0021301c, 0x0045b9ee, 0x20252015, 0x2041a9e7, 0x0022e1cb, 0x00466839, 0x2026f1c2, 0x20427830}, - [16]uint32{0x3f800000, 0x3f803244, 0x3f900208, 0x3f90304c, 0x3f8001e8, 0x3f8033ac, 0x3f9003e0, 0x3f9031a4, 0x3f801098, 0x3f8022dc, 0x3f901290, 0x3f9020d4, 0x3f801170, 0x3f802334, 0x3f901378, 0x3f90213c}, - uint32(0xfff80000), - [21]string{"0xd2", "0x04", "0x0d", "0x01", "0x85", "0xc5", "0x27", "0xee", "0x50", "0x7c", "0x98", "0xec", "0xf2", "0x37", "0x50", "0x61", "0xbf", "0x7a", "0xd4", "0xa2", "0x00"}}, - { - /* No.561 delta:740 weight:1499 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x0784b100, 0xdced0f87, 0xdb69be87, 0x8440231f, 0x83c4921f, 0x58ad2c98, 0x5f299d98, 0x0000dd1a, 0x07846c1a, 0xdcedd29d, 0xdb69639d, 0x8440fe05, 0x83c44f05, 0x58adf182, 0x5f294082}, - [16]uint32{0x00000000, 0x017f10fa, 0x00030137, 0x017c11cd, 0x000082f4, 0x017f920e, 0x000383c3, 0x017c9339, 0x40181a3f, 0x41670ac5, 0x401b1b08, 0x41640bf2, 0x401898cb, 0x41678831, 0x401b99fc, 0x41648906}, - [16]uint32{0x3f800000, 0x3f80bf88, 0x3f800180, 0x3f80be08, 0x3f800041, 0x3f80bfc9, 0x3f8001c1, 0x3f80be49, 0x3fa00c0d, 0x3fa0b385, 0x3fa00d8d, 0x3fa0b205, 0x3fa00c4c, 0x3fa0b3c4, 0x3fa00dcc, 0x3fa0b244}, - uint32(0xfff80000), - [21]string{"0x30", "0x3c", "0x36", "0x0f", "0x05", "0xe0", "0x61", "0x46", "0x56", "0x97", "0xa3", "0x00", "0x30", "0xf5", "0xd3", "0x23", "0x94", "0x2b", "0x47", "0x3c", "0x00"}}, - { - /* No.562 delta:968 weight:951 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0x8f1b238d, 0xdd9f709b, 0x52845316, 0x29802322, 0xa69b00af, 0xf41f53b9, 0x7b047034, 0x0000cb2a, 0x8f1be8a7, 0xdd9fbbb1, 0x5284983c, 0x2980e808, 0xa69bcb85, 0xf41f9893, 0x7b04bb1e}, - [16]uint32{0x00000000, 0x1fec1dba, 0x127831f7, 0x0d942c4d, 0x0044020e, 0x1fa81fb4, 0x123c33f9, 0x0dd02e43, 0x222a100f, 0x3dc60db5, 0x305221f8, 0x2fbe3c42, 0x226e1201, 0x3d820fbb, 0x301623f6, 0x2ffa3e4c}, - [16]uint32{0x3f800000, 0x3f8ff60e, 0x3f893c18, 0x3f86ca16, 0x3f802201, 0x3f8fd40f, 0x3f891e19, 0x3f86e817, 0x3f911508, 0x3f9ee306, 0x3f982910, 0x3f97df1e, 0x3f913709, 0x3f9ec107, 0x3f980b11, 0x3f97fd1f}, - uint32(0xfff80000), - [21]string{"0x45", "0x03", "0x69", "0x38", "0xda", "0x8b", "0x25", "0x4a", "0xba", "0xa1", "0xa2", "0x9b", "0xb5", "0xa4", "0x62", "0x5c", "0x99", "0x6e", "0x9c", "0x32", "0x00"}}, - { - /* No.563 delta:666 weight:1507 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x4e44098f, 0x8d3b9783, 0xc37f9e0c, 0xb620233c, 0xf8642ab3, 0x3b1bb4bf, 0x755fbd30, 0x0000c6a3, 0x4e44cf2c, 0x8d3b5120, 0xc37f58af, 0xb620e59f, 0xf864ec10, 0x3b1b721c, 0x755f7b93}, - [16]uint32{0x00000000, 0x01220db6, 0x40007443, 0x412279f5, 0x800041dd, 0x81224c6b, 0xc000359e, 0xc1223828, 0x1000268f, 0x11222b39, 0x500052cc, 0x51225f7a, 0x90006752, 0x91226ae4, 0xd0001311, 0xd1221ea7}, - [16]uint32{0x3f800000, 0x3f809106, 0x3fa0003a, 0x3fa0913c, 0x3fc00020, 0x3fc09126, 0x3fe0001a, 0x3fe0911c, 0x3f880013, 0x3f889115, 0x3fa80029, 0x3fa8912f, 0x3fc80033, 0x3fc89135, 0x3fe80009, 0x3fe8910f}, - uint32(0xfff80000), - [21]string{"0xf8", "0x1a", "0xf3", "0x78", "0xed", "0xf4", "0x03", "0x64", "0xe4", "0x52", "0x5d", "0x91", "0xed", "0x75", "0x6b", "0xba", "0x7b", "0x43", "0xa1", "0xe8", "0x00"}}, - { - /* No.564 delta:647 weight:1181 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xd8f33a9b, 0xe3af3f77, 0x3b5c05ec, 0xf1c02349, 0x293319d2, 0x126f1c3e, 0xca9c26a5, 0x000070ee, 0xd8f34a75, 0xe3af4f99, 0x3b5c7502, 0xf1c053a7, 0x2933693c, 0x126f6cd0, 0xca9c564b}, - [16]uint32{0x00000000, 0x3013e452, 0x4040028c, 0x7053e6de, 0x0020801d, 0x3033644f, 0x40608291, 0x707366c3, 0x1041841b, 0x20526049, 0x50018697, 0x601262c5, 0x10610406, 0x2072e054, 0x5021068a, 0x6032e2d8}, - [16]uint32{0x3f800000, 0x3f9809f2, 0x3fa02001, 0x3fb829f3, 0x3f801040, 0x3f9819b2, 0x3fa03041, 0x3fb839b3, 0x3f8820c2, 0x3f902930, 0x3fa800c3, 0x3fb00931, 0x3f883082, 0x3f903970, 0x3fa81083, 0x3fb01971}, - uint32(0xfff80000), - [21]string{"0xb5", "0x13", "0x27", "0x77", "0xaf", "0x8d", "0x32", "0xf7", "0x82", "0xc0", "0xb7", "0xdb", "0x9b", "0x69", "0x02", "0xe8", "0x60", "0xd8", "0x8b", "0x4e", "0x00"}}, - { - /* No.565 delta:826 weight:1527 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x1254c38d, 0xa41cd251, 0xb64811dc, 0x16e02356, 0x04b4e0db, 0xb2fcf107, 0xa0a8328a, 0x00007e13, 0x1254bd9e, 0xa41cac42, 0xb6486fcf, 0x16e05d45, 0x04b49ec8, 0xb2fc8f14, 0xa0a84c99}, - [16]uint32{0x00000000, 0x204e193e, 0x102de103, 0x3063f83d, 0x202000e7, 0x006e19d9, 0x300de1e4, 0x1043f8da, 0x00021134, 0x204c080a, 0x102ff037, 0x3061e909, 0x202211d3, 0x006c08ed, 0x300ff0d0, 0x1041e9ee}, - [16]uint32{0x3f800000, 0x3f90270c, 0x3f8816f0, 0x3f9831fc, 0x3f901000, 0x3f80370c, 0x3f9806f0, 0x3f8821fc, 0x3f800108, 0x3f902604, 0x3f8817f8, 0x3f9830f4, 0x3f901108, 0x3f803604, 0x3f9807f8, 0x3f8820f4}, - uint32(0xfff80000), - [21]string{"0x07", "0x92", "0xf4", "0xe5", "0x4a", "0xfe", "0xbc", "0xe8", "0x6d", "0xb3", "0x5d", "0x71", "0xcf", "0x66", "0xda", "0x67", "0xef", "0xd0", "0x6e", "0x46", "0x00"}}, - { - /* No.566 delta:1403 weight:1689 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x65b804b0, 0xe888ba20, 0x8d30be90, 0x9e002361, 0xfbb827d1, 0x76889941, 0x13309df1, 0x00009326, 0x65b89796, 0xe8882906, 0x8d302db6, 0x9e00b047, 0xfbb8b4f7, 0x76880a67, 0x13300ed7}, - [16]uint32{0x00000000, 0x0034019a, 0x000000e9, 0x00340173, 0x102001b4, 0x1014002e, 0x1020015d, 0x101400c7, 0x100200bf, 0x10360125, 0x10020056, 0x103601cc, 0x0022010b, 0x00160091, 0x002201e2, 0x00160078}, - [16]uint32{0x3f800000, 0x3f801a00, 0x3f800000, 0x3f801a00, 0x3f881000, 0x3f880a00, 0x3f881000, 0x3f880a00, 0x3f880100, 0x3f881b00, 0x3f880100, 0x3f881b00, 0x3f801100, 0x3f800b00, 0x3f801100, 0x3f800b00}, - uint32(0xfff80000), - [21]string{"0x66", "0xf9", "0x0d", "0xb5", "0xaf", "0x59", "0x83", "0x07", "0x61", "0x44", "0x4d", "0xc5", "0x98", "0xb6", "0x8d", "0x8f", "0x48", "0x7f", "0x60", "0x1f", "0x00"}}, - { - /* No.567 delta:576 weight:1617 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x058d67ed, 0x97f5a577, 0x9278c29a, 0x00502373, 0x05dd449e, 0x97a58604, 0x9228e1e9, 0x000090d7, 0x058df73a, 0x97f535a0, 0x9278524d, 0x0050b3a4, 0x05ddd449, 0x97a516d3, 0x9228713e}, - [16]uint32{0x00000000, 0x8041081b, 0x40022067, 0xc043287c, 0x08027808, 0x88437013, 0x4800586f, 0xc8415074, 0x10004429, 0x90414c32, 0x5002644e, 0xd0436c55, 0x18023c21, 0x9843343a, 0x58001c46, 0xd841145d}, - [16]uint32{0x3f800000, 0x3fc02084, 0x3fa00110, 0x3fe02194, 0x3f84013c, 0x3fc421b8, 0x3fa4002c, 0x3fe420a8, 0x3f880022, 0x3fc820a6, 0x3fa80132, 0x3fe821b6, 0x3f8c011e, 0x3fcc219a, 0x3fac000e, 0x3fec208a}, - uint32(0xfff80000), - [21]string{"0x84", "0x43", "0xbf", "0xce", "0x07", "0x13", "0x49", "0x6f", "0x49", "0xe5", "0xae", "0x16", "0x42", "0x85", "0x1d", "0x87", "0x8c", "0x9e", "0xc4", "0x81", "0x00"}}, - { - /* No.568 delta:916 weight:1657 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xc51212ca, 0xd8436746, 0x1d51758c, 0xed102385, 0x2802314f, 0x355344c3, 0xf0415609, 0x00000421, 0xc51216eb, 0xd8436367, 0x1d5171ad, 0xed1027a4, 0x2802356e, 0x355340e2, 0xf0415228}, - [16]uint32{0x00000000, 0x4025fc1a, 0x00414afe, 0x4064b6e4, 0x00031143, 0x4026ed59, 0x00425bbd, 0x4067a7a7, 0x90001c01, 0xd025e01b, 0x904156ff, 0xd064aae5, 0x90030d42, 0xd026f158, 0x904247bc, 0xd067bba6}, - [16]uint32{0x3f800000, 0x3fa012fe, 0x3f8020a5, 0x3fa0325b, 0x3f800188, 0x3fa01376, 0x3f80212d, 0x3fa033d3, 0x3fc8000e, 0x3fe812f0, 0x3fc820ab, 0x3fe83255, 0x3fc80186, 0x3fe81378, 0x3fc82123, 0x3fe833dd}, - uint32(0xfff80000), - [21]string{"0x06", "0xa6", "0xbe", "0x0a", "0x82", "0x60", "0xac", "0x55", "0xa0", "0x75", "0xe5", "0x40", "0x55", "0xe8", "0x01", "0x2c", "0x1c", "0x2b", "0xba", "0x97", "0x00"}}, - { - /* No.569 delta:868 weight:1715 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xe60c22f0, 0x40821976, 0xa68e3b86, 0xc6d02397, 0x20dc0167, 0x86523ae1, 0x605e1811, 0x00000fc3, 0xe60c2d33, 0x408216b5, 0xa68e3445, 0xc6d02c54, 0x20dc0ea4, 0x86523522, 0x605e17d2}, - [16]uint32{0x00000000, 0x8040b4b2, 0x2003402c, 0xa043f49e, 0x30005a04, 0xb040eeb6, 0x10031a28, 0x9043ae9a, 0x00426405, 0x8002d0b7, 0x20412429, 0xa001909b, 0x30423e01, 0xb0028ab3, 0x10417e2d, 0x9001ca9f}, - [16]uint32{0x3f800000, 0x3fc0205a, 0x3f9001a0, 0x3fd021fa, 0x3f98002d, 0x3fd82077, 0x3f88018d, 0x3fc821d7, 0x3f802132, 0x3fc00168, 0x3f902092, 0x3fd000c8, 0x3f98211f, 0x3fd80145, 0x3f8820bf, 0x3fc800e5}, - uint32(0xfff80000), - [21]string{"0x22", "0xe9", "0x16", "0x97", "0x46", "0x82", "0x83", "0xc3", "0xa6", "0x1c", "0x42", "0xb5", "0x41", "0xa1", "0x2a", "0x37", "0x70", "0x03", "0x2d", "0xda", "0x00"}}, - { - /* No.570 delta:796 weight:973 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0x3f4a19c2, 0xfabc4f03, 0xc5f656c1, 0xa27023a3, 0x9d3a3a61, 0x58cc6ca0, 0x67867562, 0x00007570, 0x3f4a6cb2, 0xfabc3a73, 0xc5f623b1, 0xa27056d3, 0x9d3a4f11, 0x58cc19d0, 0x67860012}, - [16]uint32{0x00000000, 0x0031e45d, 0x406cac0a, 0x405d4857, 0x40300619, 0x4001e244, 0x005caa13, 0x006d4e4e, 0x800210bf, 0x8033f4e2, 0xc06ebcb5, 0xc05f58e8, 0xc03216a6, 0xc003f2fb, 0x805ebaac, 0x806f5ef1}, - [16]uint32{0x3f800000, 0x3f8018f2, 0x3fa03656, 0x3fa02ea4, 0x3fa01803, 0x3fa000f1, 0x3f802e55, 0x3f8036a7, 0x3fc00108, 0x3fc019fa, 0x3fe0375e, 0x3fe02fac, 0x3fe0190b, 0x3fe001f9, 0x3fc02f5d, 0x3fc037af}, - uint32(0xfff80000), - [21]string{"0xf9", "0x5d", "0x51", "0xa5", "0xd3", "0xf1", "0x85", "0x34", "0x9d", "0x12", "0xd1", "0xc6", "0xfc", "0x3f", "0xb8", "0xfa", "0xea", "0x1e", "0x7d", "0xb3", "0x00"}}, - { - /* No.571 delta:846 weight:1529 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0xdc4991bd, 0x37ab9327, 0xebe2029a, 0x431023b0, 0x9f59b20d, 0x74bbb097, 0xa8f2212a, 0x00006306, 0xdc49f2bb, 0x37abf021, 0xebe2619c, 0x431040b6, 0x9f59d10b, 0x74bbd391, 0xa8f2422c}, - [16]uint32{0x00000000, 0x10371416, 0x50428454, 0x40759042, 0x00029818, 0x10358c0e, 0x50401c4c, 0x4077085a, 0x4008007f, 0x503f1469, 0x104a842b, 0x007d903d, 0x400a9867, 0x503d8c71, 0x10481c33, 0x007f0825}, - [16]uint32{0x3f800000, 0x3f881b8a, 0x3fa82142, 0x3fa03ac8, 0x3f80014c, 0x3f881ac6, 0x3fa8200e, 0x3fa03b84, 0x3fa00400, 0x3fa81f8a, 0x3f882542, 0x3f803ec8, 0x3fa0054c, 0x3fa81ec6, 0x3f88240e, 0x3f803f84}, - uint32(0xfff80000), - [21]string{"0x23", "0x2f", "0xfa", "0x7c", "0x6d", "0x77", "0x53", "0x6d", "0xac", "0x09", "0xb7", "0x89", "0xb8", "0x19", "0x39", "0x54", "0x0e", "0x52", "0x21", "0x2c", "0x00"}}, - { - /* No.572 delta:1688 weight:1633 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0x87785293, 0x27be9c94, 0xa0c6ce07, 0xbd0023ce, 0x3a78715d, 0x9abebf5a, 0x1dc6edc9, 0x00002d9f, 0x87787f0c, 0x27beb10b, 0xa0c6e398, 0xbd000e51, 0x3a785cc2, 0x9abe92c5, 0x1dc6c056}, - [16]uint32{0x00000000, 0x005e01b4, 0x2009009f, 0x2057012b, 0x240c00b7, 0x24520103, 0x04050028, 0x045b019c, 0x002101f5, 0x007f0041, 0x2028016a, 0x207600de, 0x242d0142, 0x247300f6, 0x042401dd, 0x047a0069}, - [16]uint32{0x3f800000, 0x3f802f00, 0x3f900480, 0x3f902b80, 0x3f920600, 0x3f922900, 0x3f820280, 0x3f822d80, 0x3f801080, 0x3f803f80, 0x3f901400, 0x3f903b00, 0x3f921680, 0x3f923980, 0x3f821200, 0x3f823d00}, - uint32(0xfff80000), - [21]string{"0x8f", "0xdd", "0xeb", "0xcd", "0x16", "0x11", "0x15", "0x3c", "0xc3", "0xfd", "0x4b", "0x96", "0x25", "0xd8", "0x41", "0xc4", "0x48", "0x70", "0x1e", "0x7c", "0x00"}}, - { - /* No.573 delta:677 weight:1389 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xbddf0a8f, 0xe43de34b, 0x59e2e9c4, 0xcca023d8, 0x717f2957, 0x289dc093, 0x9542ca1c, 0x0000504c, 0xbddf5ac3, 0xe43db307, 0x59e2b988, 0xcca07394, 0x717f791b, 0x289d90df, 0x95429a50}, - [16]uint32{0x00000000, 0x00542972, 0x1021560d, 0x10757f7f, 0x104a1154, 0x101e3826, 0x006b4759, 0x003f6e2b, 0x45800813, 0x45d42161, 0x55a15e1e, 0x55f5776c, 0x55ca1947, 0x559e3035, 0x45eb4f4a, 0x45bf6638}, - [16]uint32{0x3f800000, 0x3f802a14, 0x3f8810ab, 0x3f883abf, 0x3f882508, 0x3f880f1c, 0x3f8035a3, 0x3f801fb7, 0x3fa2c004, 0x3fa2ea10, 0x3faad0af, 0x3faafabb, 0x3faae50c, 0x3faacf18, 0x3fa2f5a7, 0x3fa2dfb3}, - uint32(0xfff80000), - [21]string{"0x02", "0x57", "0x6d", "0xc8", "0x62", "0x76", "0x80", "0x82", "0x3f", "0xcf", "0x0d", "0x54", "0x42", "0x8d", "0x13", "0x24", "0xba", "0x5a", "0x6b", "0xc8", "0x00"}}, - { - /* No.574 delta:851 weight:1495 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x8f6a848c, 0xa22ca200, 0x2d46268c, 0x473023e1, 0xc85aa76d, 0xe51c81e1, 0x6a76056d, 0x0000b6a3, 0x8f6a322f, 0xa22c14a3, 0x2d46902f, 0x47309542, 0xc85a11ce, 0xe51c3742, 0x6a76b3ce}, - [16]uint32{0x00000000, 0x00420d9a, 0x80084d66, 0x804a40fc, 0x004161c3, 0x00036c59, 0x80492ca5, 0x800b213f, 0x300020b7, 0x30422d2d, 0xb0086dd1, 0xb04a604b, 0x30414174, 0x30034cee, 0xb0490c12, 0xb00b0188}, - [16]uint32{0x3f800000, 0x3f802106, 0x3fc00426, 0x3fc02520, 0x3f8020b0, 0x3f8001b6, 0x3fc02496, 0x3fc00590, 0x3f980010, 0x3f982116, 0x3fd80436, 0x3fd82530, 0x3f9820a0, 0x3f9801a6, 0x3fd82486, 0x3fd80580}, - uint32(0xfff80000), - [21]string{"0xc2", "0x52", "0xcb", "0xb7", "0xa5", "0x4e", "0xd3", "0xc2", "0x91", "0x42", "0x07", "0x12", "0x03", "0xc0", "0x21", "0xeb", "0xa1", "0x31", "0x0e", "0xe1", "0x00"}}, - { - /* No.575 delta:897 weight:1805 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x4fa8d5e7, 0xf50c0d09, 0xbaa4d8ee, 0x16b023fa, 0x5918f61d, 0xe3bc2ef3, 0xac14fb14, 0x0000edb9, 0x4fa8385e, 0xf50ce0b0, 0xbaa43557, 0x16b0ce43, 0x59181ba4, 0xe3bcc34a, 0xac1416ad}, - [16]uint32{0x00000000, 0x580f1812, 0x0002136e, 0x580d0b7c, 0x60002c13, 0x380f3401, 0x60023f7d, 0x380d276f, 0x40100016, 0x181f1804, 0x40121378, 0x181d0b6a, 0x20102c05, 0x781f3417, 0x20123f6b, 0x781d2779}, - [16]uint32{0x3f800000, 0x3fac078c, 0x3f800109, 0x3fac0685, 0x3fb00016, 0x3f9c079a, 0x3fb0011f, 0x3f9c0693, 0x3fa00800, 0x3f8c0f8c, 0x3fa00909, 0x3f8c0e85, 0x3f900816, 0x3fbc0f9a, 0x3f90091f, 0x3fbc0e93}, - uint32(0xfff80000), - [21]string{"0x68", "0xed", "0xf0", "0x2b", "0x1e", "0x97", "0x38", "0xd1", "0x43", "0x1d", "0x85", "0xb1", "0xeb", "0x5a", "0x00", "0xa6", "0x59", "0x98", "0x1f", "0xd1", "0x00"}}, - { - /* No.576 delta:1985 weight:1777 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xf228822a, 0x4d2e7685, 0xbf06f4af, 0xb590240b, 0x47b8a621, 0xf8be528e, 0x0a96d0a4, 0x0000318d, 0xf228b3a7, 0x4d2e4708, 0xbf06c522, 0xb5901586, 0x47b897ac, 0xf8be6303, 0x0a96e129}, - [16]uint32{0x00000000, 0x087408dd, 0x0040003b, 0x083408e6, 0x002a00be, 0x085e0863, 0x006a0085, 0x081e0858, 0x300001d7, 0x3874090a, 0x304001ec, 0x38340931, 0x302a0169, 0x385e09b4, 0x306a0152, 0x381e098f}, - [16]uint32{0x3f800000, 0x3f843a04, 0x3f802000, 0x3f841a04, 0x3f801500, 0x3f842f04, 0x3f803500, 0x3f840f04, 0x3f980000, 0x3f9c3a04, 0x3f982000, 0x3f9c1a04, 0x3f981500, 0x3f9c2f04, 0x3f983500, 0x3f9c0f04}, - uint32(0xfff80000), - [21]string{"0x09", "0x87", "0xd9", "0xe5", "0x26", "0xb3", "0x73", "0x57", "0xf0", "0xae", "0x93", "0xaf", "0x0c", "0x9d", "0x86", "0x56", "0xcd", "0xe6", "0x02", "0x5f", "0x00"}}, - { - /* No.577 delta:718 weight:1687 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x5ae91cbe, 0x3ba1ba41, 0x6148a6ff, 0x6d70241a, 0x379938a4, 0x56d19e5b, 0x0c3882e5, 0x00005993, 0x5ae9452d, 0x3ba1e3d2, 0x6148ff6c, 0x6d707d89, 0x37996137, 0x56d1c7c8, 0x0c38db76}, - [16]uint32{0x00000000, 0x9002419a, 0x100221ef, 0x80006075, 0x51010016, 0xc103418c, 0x410321f9, 0xd1016063, 0x41009004, 0xd102d19e, 0x5102b1eb, 0xc100f071, 0x10019012, 0x8003d188, 0x0003b1fd, 0x9001f067}, - [16]uint32{0x3f800000, 0x3fc80120, 0x3f880110, 0x3fc00030, 0x3fa88080, 0x3fe081a0, 0x3fa08190, 0x3fe880b0, 0x3fa08048, 0x3fe88168, 0x3fa88158, 0x3fe08078, 0x3f8800c8, 0x3fc001e8, 0x3f8001d8, 0x3fc800f8}, - uint32(0xfff80000), - [21]string{"0x05", "0x42", "0x99", "0x58", "0x2f", "0x1c", "0x8f", "0xa9", "0xa5", "0x51", "0xa8", "0x1a", "0xdc", "0x69", "0xd2", "0x5c", "0xe0", "0x84", "0x07", "0xb3", "0x00"}}, - { - /* No.578 delta:2667 weight:885 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x13fc4637, 0x01ff15f1, 0x120353c6, 0x32e02426, 0x211c6211, 0x331f31d7, 0x20e377e0, 0x00004435, 0x13fc0202, 0x01ff51c4, 0x120317f3, 0x32e06013, 0x211c2624, 0x331f75e2, 0x20e333d5}, - [16]uint32{0x00000000, 0xa604c57a, 0xfe2241bc, 0x582684c6, 0x541c0112, 0xf218c468, 0xaa3e40ae, 0x0c3a85d4, 0x2080ae17, 0x86846b6d, 0xdea2efab, 0x78a62ad1, 0x749caf05, 0xd2986a7f, 0x8abeeeb9, 0x2cba2bc3}, - [16]uint32{0x3f800000, 0x3fd30262, 0x3fff1120, 0x3fac1342, 0x3faa0e00, 0x3ff90c62, 0x3fd51f20, 0x3f861d42, 0x3f904057, 0x3fc34235, 0x3fef5177, 0x3fbc5315, 0x3fba4e57, 0x3fe94c35, 0x3fc55f77, 0x3f965d15}, - uint32(0xfff80000), - [21]string{"0x56", "0x99", "0x67", "0xcb", "0xdf", "0x58", "0xa1", "0x0b", "0xa3", "0xe9", "0x9c", "0x2b", "0x01", "0xd1", "0x12", "0xd9", "0xf7", "0x2a", "0xf1", "0x3a", "0x00"}}, - { - /* No.579 delta:692 weight:1623 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xce93380c, 0x85dab300, 0x4b498b0c, 0x7dc02437, 0xb3531c3b, 0xf81a9737, 0x3689af3b, 0x00005cd3, 0xce9364df, 0x85daefd3, 0x4b49d7df, 0x7dc078e4, 0xb35340e8, 0xf81acbe4, 0x3689f3e8}, - [16]uint32{0x00000000, 0x1003c63e, 0x0100121d, 0x1103d423, 0x40116348, 0x5012a576, 0x41117155, 0x5112b76b, 0x2000201f, 0x3003e621, 0x21003202, 0x3103f43c, 0x60114357, 0x70128569, 0x6111514a, 0x71129774}, - [16]uint32{0x3f800000, 0x3f8801e3, 0x3f808009, 0x3f8881ea, 0x3fa008b1, 0x3fa80952, 0x3fa088b8, 0x3fa8895b, 0x3f900010, 0x3f9801f3, 0x3f908019, 0x3f9881fa, 0x3fb008a1, 0x3fb80942, 0x3fb088a8, 0x3fb8894b}, - uint32(0xfff80000), - [21]string{"0xb8", "0x23", "0xe8", "0xb7", "0xf8", "0xb5", "0x9f", "0x83", "0x18", "0x3f", "0xe1", "0xe1", "0x03", "0xf5", "0x55", "0xb1", "0xdf", "0x92", "0x20", "0xb2", "0x00"}}, - { - /* No.580 delta:1067 weight:1601 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0xb1a4c3ee, 0xb18ff085, 0x002b336b, 0xe0402447, 0x51e4e7a9, 0x51cfd4c2, 0xe06b172c, 0x0000819d, 0xb1a44273, 0xb18f7118, 0x002bb2f6, 0xe040a5da, 0x51e46634, 0x51cf555f, 0xe06b96b1}, - [16]uint32{0x00000000, 0x40241a1a, 0x100161b1, 0x50257bab, 0x4000119c, 0x00240b86, 0x5001702d, 0x10256a37, 0x011110e5, 0x41350aff, 0x11107154, 0x51346b4e, 0x41110179, 0x01351b63, 0x511060c8, 0x11347ad2}, - [16]uint32{0x3f800000, 0x3fa0120d, 0x3f8800b0, 0x3fa812bd, 0x3fa00008, 0x3f801205, 0x3fa800b8, 0x3f8812b5, 0x3f808888, 0x3fa09a85, 0x3f888838, 0x3fa89a35, 0x3fa08880, 0x3f809a8d, 0x3fa88830, 0x3f889a3d}, - uint32(0xfff80000), - [21]string{"0x9b", "0x60", "0xfb", "0x33", "0xf5", "0x44", "0xfc", "0x28", "0xbf", "0x2c", "0x87", "0x95", "0x5f", "0xa9", "0x2d", "0x20", "0x1a", "0xff", "0xef", "0xae", "0x00"}}, - { - /* No.581 delta:1337 weight:1507 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0x111e2100, 0x8a566841, 0x9b484941, 0x14c02452, 0x05de0552, 0x9e964c13, 0x8f886d13, 0x00003262, 0x111e1362, 0x8a565a23, 0x9b487b23, 0x14c01630, 0x05de3730, 0x9e967e71, 0x8f885f71}, - [16]uint32{0x00000000, 0x118a039e, 0x0049f11b, 0x11c3f285, 0x82085039, 0x938253a7, 0x8241a122, 0x93cba2bc, 0x0025d014, 0x11afd38a, 0x006c210f, 0x11e62291, 0x822d802d, 0x93a783b3, 0x82647136, 0x93ee72a8}, - [16]uint32{0x3f800000, 0x3f88c501, 0x3f8024f8, 0x3f88e1f9, 0x3fc10428, 0x3fc9c129, 0x3fc120d0, 0x3fc9e5d1, 0x3f8012e8, 0x3f88d7e9, 0x3f803610, 0x3f88f311, 0x3fc116c0, 0x3fc9d3c1, 0x3fc13238, 0x3fc9f739}, - uint32(0xfff80000), - [21]string{"0xd8", "0x9f", "0x8b", "0xee", "0xda", "0x62", "0x7c", "0x98", "0xda", "0x49", "0x6b", "0x6b", "0x52", "0xcf", "0xc3", "0x19", "0x44", "0xa6", "0x49", "0x63", "0x00"}}, - { - /* No.582 delta:2046 weight:1311 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x91fd9faa, 0xedf45b1b, 0x7c09c4b1, 0x4aa02460, 0xdb5dbbca, 0xa7547f7b, 0x36a9e0d1, 0x0000288f, 0x91fdb725, 0xedf47394, 0x7c09ec3e, 0x4aa00cef, 0xdb5d9345, 0xa75457f4, 0x36a9c85e}, - [16]uint32{0x00000000, 0x0f128396, 0x10cd0079, 0x1fdf83ef, 0x1060d203, 0x1f725195, 0x00add27a, 0x0fbf51ec, 0x08b049d4, 0x07a2ca42, 0x187d49ad, 0x176fca3b, 0x18d09bd7, 0x17c21841, 0x081d9bae, 0x070f1838}, - [16]uint32{0x3f800000, 0x3f878941, 0x3f886680, 0x3f8fefc1, 0x3f883069, 0x3f8fb928, 0x3f8056e9, 0x3f87dfa8, 0x3f845824, 0x3f83d165, 0x3f8c3ea4, 0x3f8bb7e5, 0x3f8c684d, 0x3f8be10c, 0x3f840ecd, 0x3f83878c}, - uint32(0xfff80000), - [21]string{"0xf9", "0x39", "0x19", "0x57", "0x14", "0xbc", "0xca", "0xd3", "0x8c", "0xcf", "0xcf", "0xdd", "0x71", "0x49", "0x91", "0x82", "0x74", "0xac", "0x6c", "0x67", "0x00"}}, - { - /* No.583 delta:997 weight:1675 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x0037248a, 0xe0b4f02c, 0xe083d4a6, 0xe0002479, 0xe03700f3, 0x00b4d455, 0x0083f0df, 0x00009577, 0x0037b1fd, 0xe0b4655b, 0xe08341d1, 0xe000b10e, 0xe0379584, 0x00b44122, 0x008365a8}, - [16]uint32{0x00000000, 0x41240855, 0x4000814c, 0x01248919, 0x4008401a, 0x012c484f, 0x0008c156, 0x412cc903, 0x40007008, 0x0124785d, 0x0000f144, 0x4124f911, 0x00083012, 0x412c3847, 0x4008b15e, 0x012cb90b}, - [16]uint32{0x3f800000, 0x3fa09204, 0x3fa00040, 0x3f809244, 0x3fa00420, 0x3f809624, 0x3f800460, 0x3fa09664, 0x3fa00038, 0x3f80923c, 0x3f800078, 0x3fa0927c, 0x3f800418, 0x3fa0961c, 0x3fa00458, 0x3f80965c}, - uint32(0xfff80000), - [21]string{"0x5f", "0xa4", "0x83", "0x10", "0x49", "0xa7", "0x5c", "0x56", "0x7d", "0x75", "0x23", "0x1d", "0x8c", "0x2e", "0xf7", "0x22", "0x57", "0xd1", "0xed", "0xda", "0x00"}}, - { - /* No.584 delta:1031 weight:1783 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xe9b1101c, 0xaa673461, 0x43d6247d, 0x2c102486, 0xc5a1349a, 0x867710e7, 0x6fc600fb, 0x0000fe72, 0xe9b1ee6e, 0xaa67ca13, 0x43d6da0f, 0x2c10daf4, 0xc5a1cae8, 0x8677ee95, 0x6fc6fe89}, - [16]uint32{0x00000000, 0x0003f11e, 0x40243211, 0x4027c30f, 0x40004d16, 0x4003bc08, 0x00247f07, 0x00278e19, 0x30000018, 0x3003f106, 0x70243209, 0x7027c317, 0x70004d0e, 0x7003bc10, 0x30247f1f, 0x30278e01}, - [16]uint32{0x3f800000, 0x3f8001f8, 0x3fa01219, 0x3fa013e1, 0x3fa00026, 0x3fa001de, 0x3f80123f, 0x3f8013c7, 0x3f980000, 0x3f9801f8, 0x3fb81219, 0x3fb813e1, 0x3fb80026, 0x3fb801de, 0x3f98123f, 0x3f9813c7}, - uint32(0xfff80000), - [21]string{"0x34", "0xcc", "0x2b", "0x12", "0x90", "0xca", "0x98", "0x8a", "0x0e", "0x1a", "0xf3", "0x03", "0x4d", "0xbe", "0xb0", "0xec", "0x3d", "0x7b", "0x4f", "0x4d", "0x00"}}, - { - /* No.585 delta:1210 weight:1565 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0xff2d7f66, 0xcbc1108c, 0x34ec6fea, 0xd400249b, 0x2b2d5bfd, 0x1fc13417, 0xe0ec4b71, 0x00006562, 0xff2d1a04, 0xcbc175ee, 0x34ec0a88, 0xd40041f9, 0x2b2d3e9f, 0x1fc15175, 0xe0ec2e13}, - [16]uint32{0x00000000, 0x4825b032, 0x004161f4, 0x4864d1c6, 0x0020601c, 0x4805d02e, 0x006101e8, 0x4844b1da, 0x10130c01, 0x5836bc33, 0x10526df5, 0x5877ddc7, 0x10336c1d, 0x5816dc2f, 0x10720de9, 0x5857bddb}, - [16]uint32{0x3f800000, 0x3fa412d8, 0x3f8020b0, 0x3fa43268, 0x3f801030, 0x3fa402e8, 0x3f803080, 0x3fa42258, 0x3f880986, 0x3fac1b5e, 0x3f882936, 0x3fac3bee, 0x3f8819b6, 0x3fac0b6e, 0x3f883906, 0x3fac2bde}, - uint32(0xfff80000), - [21]string{"0x4e", "0xf2", "0x1f", "0x4d", "0xc3", "0x9e", "0xb9", "0x8d", "0x8a", "0x34", "0x06", "0xfe", "0x37", "0x71", "0xea", "0x47", "0xb1", "0x8a", "0xba", "0xcd", "0x00"}}, - { - /* No.586 delta:1070 weight:1463 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x3be7d0a0, 0x3506e62a, 0x0ee1368a, 0x1cc024aa, 0x2727f40a, 0x29c6c280, 0x12211220, 0x0000dfba, 0x3be70f1a, 0x35063990, 0x0ee1e930, 0x1cc0fb10, 0x27272bb0, 0x29c61d3a, 0x1221cd9a}, - [16]uint32{0x00000000, 0x004600f5, 0x00482189, 0x000e217c, 0x0102101b, 0x014410ee, 0x014a3192, 0x010c3167, 0x0002001e, 0x004400eb, 0x004a2197, 0x000c2162, 0x01001005, 0x014610f0, 0x0148318c, 0x010e3179}, - [16]uint32{0x3f800000, 0x3f802300, 0x3f802410, 0x3f800710, 0x3f808108, 0x3f80a208, 0x3f80a518, 0x3f808618, 0x3f800100, 0x3f802200, 0x3f802510, 0x3f800610, 0x3f808008, 0x3f80a308, 0x3f80a418, 0x3f808718}, - uint32(0xfff80000), - [21]string{"0x23", "0x07", "0xea", "0x91", "0x71", "0xbe", "0xb3", "0x40", "0x97", "0xea", "0x80", "0xf3", "0x60", "0xf0", "0x5c", "0xc4", "0x25", "0x5e", "0x63", "0xb3", "0x00"}}, - { - /* No.587 delta:790 weight:985 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0xe507a764, 0xbd470523, 0x5840a247, 0x071024bc, 0xe21783d8, 0xba57219f, 0x5f5086fb, 0x00006a57, 0xe507cd33, 0xbd476f74, 0x5840c810, 0x07104eeb, 0xe217e98f, 0xba574bc8, 0x5f50ecac}, - [16]uint32{0x00000000, 0x100dc492, 0x32022369, 0x220fe7fb, 0x4020001e, 0x502dc48c, 0x72222377, 0x622fe7e5, 0x20541426, 0x3059d0b4, 0x1256374f, 0x025bf3dd, 0x60741438, 0x7079d0aa, 0x52763751, 0x427bf3c3}, - [16]uint32{0x3f800000, 0x3f8806e2, 0x3f990111, 0x3f9107f3, 0x3fa01000, 0x3fa816e2, 0x3fb91111, 0x3fb117f3, 0x3f902a0a, 0x3f982ce8, 0x3f892b1b, 0x3f812df9, 0x3fb03a0a, 0x3fb83ce8, 0x3fa93b1b, 0x3fa13df9}, - uint32(0xfff80000), - [21]string{"0x4f", "0x1a", "0xf7", "0xeb", "0xac", "0x14", "0x00", "0x08", "0xf6", "0x70", "0x27", "0x49", "0x53", "0x85", "0x8a", "0x65", "0x64", "0x96", "0x6c", "0xf8", "0x00"}}, - { - /* No.588 delta:995 weight:731 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x9d944760, 0x0dc28bf0, 0x9056cc90, 0xcf1024ca, 0x528463aa, 0xc2d2af3a, 0x5f46e85a, 0x00008812, 0x9d94cf72, 0x0dc203e2, 0x90564482, 0xcf10acd8, 0x5284ebb8, 0xc2d22728, 0x5f466048}, - [16]uint32{0x00000000, 0x009370ff, 0x0084100d, 0x001760f2, 0x64221014, 0x64b160eb, 0x64a60019, 0x643570e6, 0x00188877, 0x008bf888, 0x009c987a, 0x000fe885, 0x643a9863, 0x64a9e89c, 0x64be886e, 0x642df891}, - [16]uint32{0x3f800000, 0x3f8049b8, 0x3f804208, 0x3f800bb0, 0x3fb21108, 0x3fb258b0, 0x3fb25300, 0x3fb21ab8, 0x3f800c44, 0x3f8045fc, 0x3f804e4c, 0x3f8007f4, 0x3fb21d4c, 0x3fb254f4, 0x3fb25f44, 0x3fb216fc}, - uint32(0xfff80000), - [21]string{"0x7b", "0xb1", "0xab", "0xba", "0x95", "0x4b", "0xee", "0xd4", "0x3d", "0x12", "0x9e", "0xae", "0xc2", "0x8c", "0xaf", "0x4b", "0xaa", "0xd7", "0x10", "0x18", "0x00"}}, - { - /* No.589 delta:1028 weight:1399 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x926f102b, 0xa94f801e, 0x3b209035, 0xcf4024dc, 0x5d2f34f7, 0x660fa4c2, 0xf460b4e9, 0x00002535, 0x926f351e, 0xa94fa52b, 0x3b20b500, 0xcf4001e9, 0x5d2f11c2, 0x660f81f7, 0xf46091dc}, - [16]uint32{0x00000000, 0x20650536, 0x005ee5a5, 0x203be093, 0x40174c19, 0x6072492f, 0x4049a9bc, 0x602cac8a, 0x00034e1b, 0x20664b2d, 0x005dabbe, 0x2038ae88, 0x40140202, 0x60710734, 0x404ae7a7, 0x602fe291}, - [16]uint32{0x3f800000, 0x3f903282, 0x3f802f72, 0x3f901df0, 0x3fa00ba6, 0x3fb03924, 0x3fa024d4, 0x3fb01656, 0x3f8001a7, 0x3f903325, 0x3f802ed5, 0x3f901c57, 0x3fa00a01, 0x3fb03883, 0x3fa02573, 0x3fb017f1}, - uint32(0xfff80000), - [21]string{"0x83", "0x6a", "0xfd", "0x6e", "0x8b", "0x3f", "0xbe", "0x9f", "0xbb", "0xba", "0xc5", "0xea", "0x11", "0x3a", "0xc0", "0xc3", "0xef", "0xec", "0xb7", "0x3e", "0x00"}}, - { - /* No.590 delta:1184 weight:1509 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x7ec2da9f, 0xb2a21c05, 0xcc60c69a, 0x3e8024ec, 0x4042fe73, 0x8c2238e9, 0xf2e0e276, 0x00007c8a, 0x7ec2a615, 0xb2a2608f, 0xcc60ba10, 0x3e805866, 0x404282f9, 0x8c224463, 0xf2e09efc}, - [16]uint32{0x00000000, 0x5036b156, 0x103e2e03, 0x40089f55, 0x00206407, 0x5016d551, 0x101e4a04, 0x4028fb52, 0x10408018, 0x4076314e, 0x007eae1b, 0x50481f4d, 0x1060e41f, 0x40565549, 0x005eca1c, 0x50687b4a}, - [16]uint32{0x3f800000, 0x3fa81b58, 0x3f881f17, 0x3fa0044f, 0x3f801032, 0x3fa80b6a, 0x3f880f25, 0x3fa0147d, 0x3f882040, 0x3fa03b18, 0x3f803f57, 0x3fa8240f, 0x3f883072, 0x3fa02b2a, 0x3f802f65, 0x3fa8343d}, - uint32(0xfff80000), - [21]string{"0xc6", "0x0e", "0x52", "0xeb", "0x49", "0xf4", "0x46", "0x7e", "0x6a", "0x32", "0xeb", "0x29", "0x18", "0xfd", "0x14", "0xc9", "0xf7", "0x92", "0x81", "0x67", "0x00"}}, - { - /* No.591 delta:1437 weight:1635 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0x7c0b221b, 0x06bf4edf, 0x7ab46cc4, 0xd8b024f0, 0xa4bb06eb, 0xde0f6a2f, 0xa2044834, 0x000082de, 0x7c0ba0c5, 0x06bfcc01, 0x7ab4ee1a, 0xd8b0a62e, 0xa4bb8435, 0xde0fe8f1, 0xa204caea}, - [16]uint32{0x00000000, 0x442d0c9e, 0x20538de9, 0x647e8177, 0x20373403, 0x641a389d, 0x0064b9ea, 0x4449b574, 0x00181992, 0x4435150c, 0x204b947b, 0x646698e5, 0x202f2d91, 0x6402210f, 0x007ca078, 0x4451ace6}, - [16]uint32{0x3f800000, 0x3fa21686, 0x3f9029c6, 0x3fb23f40, 0x3f901b9a, 0x3fb20d1c, 0x3f80325c, 0x3fa224da, 0x3f800c0c, 0x3fa21a8a, 0x3f9025ca, 0x3fb2334c, 0x3f901796, 0x3fb20110, 0x3f803e50, 0x3fa228d6}, - uint32(0xfff80000), - [21]string{"0xce", "0x5c", "0x8e", "0x30", "0xda", "0x87", "0xc7", "0x78", "0x6b", "0xc1", "0xef", "0xcf", "0x9f", "0xdb", "0x43", "0x64", "0x0c", "0x85", "0xf5", "0x5d", "0x00"}}, - { - /* No.592 delta:1237 weight:1641 */ - 11213, - 75, - 13, - 4, - [16]uint32{0x00000000, 0x9cd3418d, 0x00dacc27, 0x9c098daa, 0xca002509, 0x56d36484, 0xcadae92e, 0x5609a8a3, 0x000048d7, 0x9cd3095a, 0x00da84f0, 0x9c09c57d, 0xca006dde, 0x56d32c53, 0xcadaa1f9, 0x5609e074}, - [16]uint32{0x00000000, 0x002300fe, 0x000501fd, 0x00260103, 0x006b81a6, 0x00488158, 0x006e805b, 0x004d80a5, 0x0000a097, 0x0023a069, 0x0005a16a, 0x0026a194, 0x006b2131, 0x004821cf, 0x006e20cc, 0x004d2032}, - [16]uint32{0x3f800000, 0x3f801180, 0x3f800280, 0x3f801300, 0x3f8035c0, 0x3f802440, 0x3f803740, 0x3f8026c0, 0x3f800050, 0x3f8011d0, 0x3f8002d0, 0x3f801350, 0x3f803590, 0x3f802410, 0x3f803710, 0x3f802690}, - uint32(0xfff80000), - [21]string{"0x2a", "0x59", "0xaf", "0xc9", "0xf3", "0x7c", "0x73", "0xcc", "0x2c", "0x98", "0x5d", "0x1f", "0x78", "0xeb", "0x3a", "0xbb", "0x1a", "0x2c", "0x00", "0xf3", "0x00"}}, - { - /* No.593 delta:851 weight:1233 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x8d9eb4ed, 0x798b2d00, 0xf41599ed, 0xe3702511, 0x6eee91fc, 0x9afb0811, 0x1765bcfc, 0x0000d290, 0x8d9e667d, 0x798bff90, 0xf4154b7d, 0xe370f781, 0x6eee436c, 0x9afbda81, 0x17656e6c}, - [16]uint32{0x00000000, 0xd005535e, 0x206180fb, 0xf064d3a5, 0x000095dd, 0xd005c683, 0x20611526, 0xf0644678, 0x6006200a, 0xb0037354, 0x4067a0f1, 0x9062f3af, 0x6006b5d7, 0xb003e689, 0x4067352c, 0x90626672}, - [16]uint32{0x3f800000, 0x3fe802a9, 0x3f9030c0, 0x3ff83269, 0x3f80004a, 0x3fe802e3, 0x3f90308a, 0x3ff83223, 0x3fb00310, 0x3fd801b9, 0x3fa033d0, 0x3fc83179, 0x3fb0035a, 0x3fd801f3, 0x3fa0339a, 0x3fc83133}, - uint32(0xfff80000), - [21]string{"0xaf", "0x54", "0xe4", "0x6d", "0xed", "0xa3", "0x9c", "0x8c", "0xc3", "0xc7", "0x4c", "0xb2", "0x74", "0x58", "0x7a", "0x2b", "0x05", "0x1a", "0x2c", "0x1f", "0x00"}}, - { - /* No.594 delta:964 weight:1441 */ - 11213, - 64, - 13, - 4, - [16]uint32{0x00000000, 0x999400a5, 0xb9a6fae0, 0x2032fa45, 0xbf60252a, 0x26f4258f, 0x06c6dfca, 0x9f52df6f, 0x00008203, 0x999482a6, 0xb9a678e3, 0x20327846, 0xbf60a729, 0x26f4a78c, 0x06c65dc9, 0x9f525d6c}, - [16]uint32{0x00000000, 0x004a009a, 0x0003806d, 0x004980f7, 0x20169013, 0x205c9089, 0x2015107e, 0x205f10e4, 0x000271cb, 0x00487151, 0x0001f1a6, 0x004bf13c, 0x2014e1d8, 0x205ee142, 0x201761b5, 0x205d612f}, - [16]uint32{0x3f800000, 0x3f802500, 0x3f8001c0, 0x3f8024c0, 0x3f900b48, 0x3f902e48, 0x3f900a88, 0x3f902f88, 0x3f800138, 0x3f802438, 0x3f8000f8, 0x3f8025f8, 0x3f900a70, 0x3f902f70, 0x3f900bb0, 0x3f902eb0}, - uint32(0xfff80000), - [21]string{"0x5c", "0x42", "0x3e", "0xc4", "0xe2", "0x2c", "0x70", "0xd5", "0x10", "0x6b", "0x3c", "0xf4", "0x07", "0x5b", "0x40", "0x12", "0x9e", "0x84", "0xac", "0x92", "0x00"}}, - { - /* No.595 delta:1005 weight:1563 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0x1e48f78e, 0x7ad5bf5f, 0x649d48d1, 0x14602530, 0x0a28d2be, 0x6eb59a6f, 0x70fd6de1, 0x0000a249, 0x1e4855c7, 0x7ad51d16, 0x649dea98, 0x14608779, 0x0a2870f7, 0x6eb53826, 0x70fdcfa8}, - [16]uint32{0x00000000, 0x0006007a, 0x208079ae, 0x208679d4, 0x0050290b, 0x00562971, 0x20d050a5, 0x20d650df, 0x00006023, 0x00066059, 0x2080198d, 0x208619f7, 0x00504928, 0x00564952, 0x20d03086, 0x20d630fc}, - [16]uint32{0x3f800000, 0x3f800300, 0x3f90403c, 0x3f90433c, 0x3f802814, 0x3f802b14, 0x3f906828, 0x3f906b28, 0x3f800030, 0x3f800330, 0x3f90400c, 0x3f90430c, 0x3f802824, 0x3f802b24, 0x3f906818, 0x3f906b18}, - uint32(0xfff80000), - [21]string{"0x00", "0xf7", "0x75", "0x4f", "0xb4", "0xbc", "0xf9", "0x6b", "0xcc", "0x2e", "0xe9", "0x87", "0x9d", "0x13", "0xfa", "0x99", "0x0b", "0x3b", "0xd4", "0x30", "0x00"}}, - { - /* No.596 delta:1574 weight:1671 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0x2c2cbe52, 0x1b48725a, 0x3764cc08, 0xd140254e, 0xfd6c9b1c, 0xca085714, 0xe624e946, 0x0000c506, 0x2c2c7b54, 0x1b48b75c, 0x3764090e, 0xd140e048, 0xfd6c5e1a, 0xca089212, 0xe6242c40}, - [16]uint32{0x00000000, 0x003001f7, 0x000c0074, 0x003c0183, 0x00400172, 0x00700085, 0x004c0106, 0x007c00f1, 0x00020053, 0x003201a4, 0x000e0027, 0x003e01d0, 0x00420121, 0x007200d6, 0x004e0155, 0x007e00a2}, - [16]uint32{0x3f800000, 0x3f801800, 0x3f800600, 0x3f801e00, 0x3f802000, 0x3f803800, 0x3f802600, 0x3f803e00, 0x3f800100, 0x3f801900, 0x3f800700, 0x3f801f00, 0x3f802100, 0x3f803900, 0x3f802700, 0x3f803f00}, - uint32(0xfff80000), - [21]string{"0xe7", "0x43", "0x7b", "0x38", "0x3d", "0x4f", "0xb3", "0x76", "0x06", "0x90", "0xcc", "0x06", "0x32", "0x39", "0x55", "0xb7", "0xf4", "0xa4", "0x3d", "0x6f", "0x00"}}, - { - /* No.597 delta:995 weight:1485 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xcb21f7ef, 0xd7194c56, 0x1c38bbb9, 0x91602552, 0x5a41d2bd, 0x46796904, 0x8d589eeb, 0x00007dc9, 0xcb218a26, 0xd719319f, 0x1c38c670, 0x9160589b, 0x5a41af74, 0x467914cd, 0x8d58e322}, - [16]uint32{0x00000000, 0x007720b3, 0x004b361c, 0x003c16af, 0x08010176, 0x087621c5, 0x084a376a, 0x083d17d9, 0x000ab008, 0x007d90bb, 0x00418614, 0x0036a6a7, 0x080bb17e, 0x087c91cd, 0x08408762, 0x0837a7d1}, - [16]uint32{0x3f800000, 0x3f803b90, 0x3f80259b, 0x3f801e0b, 0x3f840080, 0x3f843b10, 0x3f84251b, 0x3f841e8b, 0x3f800558, 0x3f803ec8, 0x3f8020c3, 0x3f801b53, 0x3f8405d8, 0x3f843e48, 0x3f842043, 0x3f841bd3}, - uint32(0xfff80000), - [21]string{"0xc8", "0xb0", "0x59", "0x75", "0xcb", "0xc1", "0x69", "0xac", "0xe3", "0x25", "0xef", "0xa3", "0xd2", "0x9a", "0xe1", "0x92", "0xaa", "0x78", "0xfb", "0xee", "0x00"}}, - { - /* No.598 delta:973 weight:1701 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x2b424337, 0xf5abe468, 0xdee9a75f, 0xa8e0256c, 0x83a2665b, 0x5d4bc104, 0x76098233, 0x0000829b, 0x2b42c1ac, 0xf5ab66f3, 0xdee925c4, 0xa8e0a7f7, 0x83a2e4c0, 0x5d4b439f, 0x760900a8}, - [16]uint32{0x00000000, 0x0047195e, 0x0402f3ab, 0x0445eaf5, 0x0002c139, 0x0045d867, 0x04003292, 0x04472bcc, 0x20418171, 0x2006982f, 0x244372da, 0x24046b84, 0x20434048, 0x20045916, 0x2441b3e3, 0x2406aabd}, - [16]uint32{0x3f800000, 0x3f80238c, 0x3f820179, 0x3f8222f5, 0x3f800160, 0x3f8022ec, 0x3f820019, 0x3f822395, 0x3f9020c0, 0x3f90034c, 0x3f9221b9, 0x3f920235, 0x3f9021a0, 0x3f90022c, 0x3f9220d9, 0x3f920355}, - uint32(0xfff80000), - [21]string{"0xfd", "0xa6", "0x08", "0xa1", "0x34", "0x48", "0xd8", "0x48", "0x0e", "0x32", "0x30", "0x35", "0x46", "0x2b", "0x49", "0x5d", "0x98", "0xf4", "0xc3", "0xcf", "0x00"}}, - { - /* No.599 delta:651 weight:1201 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xee34b5e5, 0xede22038, 0x03d695dd, 0x48f02572, 0xa6c49097, 0xa512054a, 0x4b26b0af, 0x000031ad, 0xee348448, 0xede21195, 0x03d6a470, 0x48f014df, 0xa6c4a13a, 0xa51234e7, 0x4b268102}, - [16]uint32{0x00000000, 0x4058881e, 0x0023c28c, 0x407b4a92, 0x0130217f, 0x4168a961, 0x0113e3f3, 0x414b6bed, 0x20130019, 0x604b8807, 0x2030c295, 0x60684a8b, 0x21232166, 0x617ba978, 0x2100e3ea, 0x61586bf4}, - [16]uint32{0x3f800000, 0x3fa02c44, 0x3f8011e1, 0x3fa03da5, 0x3f809810, 0x3fa0b454, 0x3f8089f1, 0x3fa0a5b5, 0x3f900980, 0x3fb025c4, 0x3f901861, 0x3fb03425, 0x3f909190, 0x3fb0bdd4, 0x3f908071, 0x3fb0ac35}, - uint32(0xfff80000), - [21]string{"0x04", "0x3f", "0xe7", "0x7f", "0x3a", "0xdb", "0xae", "0x81", "0xfd", "0x93", "0xb4", "0x48", "0x60", "0xee", "0xd9", "0xb7", "0x98", "0x19", "0x09", "0x2e", "0x00"}}, - { - /* No.600 delta:1387 weight:1713 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xb65f7d7c, 0xa8d0a065, 0x1e8fdd19, 0x12002580, 0xa45f58fc, 0xbad085e5, 0x0c8ff899, 0x00001877, 0xb65f650b, 0xa8d0b812, 0x1e8fc56e, 0x12003df7, 0xa45f408b, 0xbad09d92, 0x0c8fe0ee}, - [16]uint32{0x00000000, 0x2c67e5b6, 0x006601e7, 0x2c01e451, 0x5004115f, 0x7c63f4e9, 0x506210b8, 0x7c05f50e, 0x040a7806, 0x286d9db0, 0x046c79e1, 0x280b9c57, 0x540e6959, 0x78698cef, 0x546868be, 0x780f8d08}, - [16]uint32{0x3f800000, 0x3f9633f2, 0x3f803300, 0x3f9600f2, 0x3fa80208, 0x3fbe31fa, 0x3fa83108, 0x3fbe02fa, 0x3f82053c, 0x3f9436ce, 0x3f82363c, 0x3f9405ce, 0x3faa0734, 0x3fbc34c6, 0x3faa3434, 0x3fbc07c6}, - uint32(0xfff80000), - [21]string{"0x79", "0xf0", "0x41", "0x84", "0x97", "0x13", "0xbb", "0xe5", "0x60", "0xcc", "0x7f", "0x22", "0x69", "0x0d", "0xe7", "0x2c", "0x76", "0x70", "0x2a", "0x62", "0x00"}}, - { - /* No.601 delta:823 weight:1563 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x54749ca5, 0x6435fceb, 0x3041604e, 0x76a02591, 0x22d4b934, 0x1295d97a, 0x46e145df, 0x00003f82, 0x5474a327, 0x6435c369, 0x30415fcc, 0x76a01a13, 0x22d486b6, 0x1295e6f8, 0x46e17a5d}, - [16]uint32{0x00000000, 0x2116cd97, 0x00251543, 0x2133d8d4, 0x0002f21f, 0x21143f88, 0x0027e75c, 0x21312acb, 0x10404012, 0x31568d85, 0x10655551, 0x317398c6, 0x1042b20d, 0x31547f9a, 0x1067a74e, 0x31716ad9}, - [16]uint32{0x3f800000, 0x3f908b66, 0x3f80128a, 0x3f9099ec, 0x3f800179, 0x3f908a1f, 0x3f8013f3, 0x3f909895, 0x3f882020, 0x3f98ab46, 0x3f8832aa, 0x3f98b9cc, 0x3f882159, 0x3f98aa3f, 0x3f8833d3, 0x3f98b8b5}, - uint32(0xfff80000), - [21]string{"0xb2", "0xa7", "0x9e", "0xdb", "0x67", "0x54", "0x9d", "0x5f", "0x3c", "0xd7", "0xcd", "0x32", "0xe0", "0xf1", "0x5e", "0x15", "0xac", "0x11", "0xc3", "0x90", "0x00"}}, - { - /* No.602 delta:1045 weight:1421 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0xced295ce, 0x9b250664, 0x55f793aa, 0xb99025a0, 0x7742b06e, 0x22b523c4, 0xec67b60a, 0x00008fff, 0xced21a31, 0x9b25899b, 0x55f71c55, 0xb990aa5f, 0x77423f91, 0x22b5ac3b, 0xec6739f5}, - [16]uint32{0x00000000, 0x3037081a, 0x0040d0d6, 0x3077d8cc, 0x000e6a15, 0x3039620f, 0x004ebac3, 0x3079b2d9, 0x20026132, 0x10356928, 0x2042b1e4, 0x1075b9fe, 0x200c0b27, 0x103b033d, 0x204cdbf1, 0x107bd3eb}, - [16]uint32{0x3f800000, 0x3f981b84, 0x3f802068, 0x3f983bec, 0x3f800735, 0x3f981cb1, 0x3f80275d, 0x3f983cd9, 0x3f900130, 0x3f881ab4, 0x3f902158, 0x3f883adc, 0x3f900605, 0x3f881d81, 0x3f90266d, 0x3f883de9}, - uint32(0xfff80000), - [21]string{"0xb7", "0x69", "0x8a", "0x1b", "0x23", "0x0e", "0x52", "0xfe", "0xb0", "0x06", "0x8e", "0x54", "0x62", "0x96", "0xff", "0x4e", "0x99", "0xda", "0xb2", "0x76", "0x00"}}, - { - /* No.603 delta:1118 weight:1471 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0x57c64060, 0xd9f2496f, 0x8e34090f, 0x6a4025b0, 0x3d8665d0, 0xb3b26cdf, 0xe4742cbf, 0x0000a7fb, 0x57c6e79b, 0xd9f2ee94, 0x8e34aef4, 0x6a40824b, 0x3d86c22b, 0xb3b2cb24, 0xe4748b44}, - [16]uint32{0x00000000, 0x002c2956, 0x005a31ef, 0x007618b9, 0x0009606d, 0x0025493b, 0x00535182, 0x007f78d4, 0x410479e7, 0x412850b1, 0x415e4808, 0x4172615e, 0x410d198a, 0x412130dc, 0x41572865, 0x417b0133}, - [16]uint32{0x3f800000, 0x3f801614, 0x3f802d18, 0x3f803b0c, 0x3f8004b0, 0x3f8012a4, 0x3f8029a8, 0x3f803fbc, 0x3fa0823c, 0x3fa09428, 0x3fa0af24, 0x3fa0b930, 0x3fa0868c, 0x3fa09098, 0x3fa0ab94, 0x3fa0bd80}, - uint32(0xfff80000), - [21]string{"0xba", "0xf7", "0xbc", "0x44", "0xdf", "0x33", "0xe7", "0xfb", "0xab", "0xb6", "0xc9", "0x4f", "0x00", "0xa8", "0xe9", "0x5b", "0x58", "0xe9", "0x70", "0x90", "0x00"}}, - { - /* No.604 delta:936 weight:1635 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x9c8048c4, 0x768a1136, 0xea0a59f2, 0x60a025c6, 0xfc206d02, 0x162a34f0, 0x8aaa7c34, 0x00005492, 0x9c801c56, 0x768a45a4, 0xea0a0d60, 0x60a07154, 0xfc203990, 0x162a6062, 0x8aaa28a6}, - [16]uint32{0x00000000, 0x20058a13, 0x002278fc, 0x2027f2ef, 0x5000661b, 0x7005ec08, 0x50221ee7, 0x702794f4, 0x5000200a, 0x7005aa19, 0x502258f6, 0x7027d2e5, 0x00004611, 0x2005cc02, 0x00223eed, 0x2027b4fe}, - [16]uint32{0x3f800000, 0x3f9002c5, 0x3f80113c, 0x3f9013f9, 0x3fa80033, 0x3fb802f6, 0x3fa8110f, 0x3fb813ca, 0x3fa80010, 0x3fb802d5, 0x3fa8112c, 0x3fb813e9, 0x3f800023, 0x3f9002e6, 0x3f80111f, 0x3f9013da}, - uint32(0xfff80000), - [21]string{"0x08", "0x3e", "0x62", "0xc3", "0x49", "0xd3", "0xf0", "0xf6", "0xc2", "0x80", "0xc3", "0x06", "0xbf", "0x53", "0x2b", "0xec", "0x95", "0xd9", "0xda", "0x0f", "0x00"}}, - { - /* No.605 delta:1103 weight:1361 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0x6f5407f2, 0xfce50ba0, 0x93b10c52, 0x2e7025db, 0x41242229, 0xd2952e7b, 0xbdc12989, 0x0000f0f0, 0x6f54f702, 0xfce5fb50, 0x93b1fca2, 0x2e70d52b, 0x4124d2d9, 0xd295de8b, 0xbdc1d979}, - [16]uint32{0x00000000, 0x304e09d6, 0x000211bf, 0x304c1869, 0x2012401a, 0x105c49cc, 0x201051a5, 0x105e5873, 0x10410104, 0x200f08d2, 0x104310bb, 0x200d196d, 0x3053411e, 0x001d48c8, 0x305150a1, 0x001f5977}, - [16]uint32{0x3f800000, 0x3f982704, 0x3f800108, 0x3f98260c, 0x3f900920, 0x3f882e24, 0x3f900828, 0x3f882f2c, 0x3f882080, 0x3f900784, 0x3f882188, 0x3f90068c, 0x3f9829a0, 0x3f800ea4, 0x3f9828a8, 0x3f800fac}, - uint32(0xfff80000), - [21]string{"0x5f", "0x6c", "0xcc", "0x8b", "0x15", "0xe0", "0xc0", "0x17", "0x74", "0x39", "0x8a", "0xda", "0x5a", "0xba", "0x72", "0xf0", "0x0b", "0xde", "0x4a", "0x8d", "0x00"}}, - { - /* No.606 delta:1146 weight:1309 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xd9ee8680, 0x9dfedd30, 0x44105bb0, 0x8bf025e1, 0x521ea361, 0x160ef8d1, 0xcfe07e51, 0x00006d60, 0xd9eeebe0, 0x9dfeb050, 0x441036d0, 0x8bf04881, 0x521ece01, 0x160e95b1, 0xcfe01331}, - [16]uint32{0x00000000, 0x606b807e, 0x00540155, 0x603f812b, 0x400261ec, 0x2069e192, 0x405660b9, 0x203de0c7, 0x0002601d, 0x6069e063, 0x00566148, 0x603de136, 0x400001f1, 0x206b818f, 0x405400a4, 0x203f80da}, - [16]uint32{0x3f800000, 0x3fb035c0, 0x3f802a00, 0x3fb01fc0, 0x3fa00130, 0x3f9034f0, 0x3fa02b30, 0x3f901ef0, 0x3f800130, 0x3fb034f0, 0x3f802b30, 0x3fb01ef0, 0x3fa00000, 0x3f9035c0, 0x3fa02a00, 0x3f901fc0}, - uint32(0xfff80000), - [21]string{"0x2e", "0x47", "0xd8", "0xc5", "0xd0", "0x3e", "0xab", "0xe6", "0x04", "0x41", "0x7d", "0x2b", "0xe3", "0xb7", "0xb6", "0x5f", "0x30", "0x4a", "0x2a", "0xe8", "0x00"}}, - { - /* No.607 delta:855 weight:1683 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x74e60bda, 0x86e864df, 0xf20e6f05, 0x7f0025fc, 0x0be62e26, 0xf9e84123, 0x8d0e4af9, 0x00004467, 0x74e64fbd, 0x86e820b8, 0xf20e2b62, 0x7f00619b, 0x0be66a41, 0xf9e80544, 0x8d0e0e9e}, - [16]uint32{0x00000000, 0x00021096, 0x201ca06b, 0x201eb0fd, 0x00590e11, 0x005b1e87, 0x2045ae7a, 0x2047beec, 0x0010cfae, 0x0012df38, 0x200c6fc5, 0x200e7f53, 0x0049c1bf, 0x004bd129, 0x205561d4, 0x20577142}, - [16]uint32{0x3f800000, 0x3f800108, 0x3f900e50, 0x3f900f58, 0x3f802c87, 0x3f802d8f, 0x3f9022d7, 0x3f9023df, 0x3f800867, 0x3f80096f, 0x3f900637, 0x3f90073f, 0x3f8024e0, 0x3f8025e8, 0x3f902ab0, 0x3f902bb8}, - uint32(0xfff80000), - [21]string{"0xcc", "0x7f", "0x57", "0x67", "0xe0", "0x2b", "0x93", "0x72", "0x25", "0x14", "0x8e", "0xfb", "0xab", "0x9d", "0x9e", "0x84", "0xe8", "0x13", "0xf3", "0xc7", "0x00"}}, - { - /* No.608 delta:1082 weight:1415 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0xfcbfc022, 0xc765e810, 0x3bda2832, 0xa6d0260e, 0x5a6fe62c, 0x61b5ce1e, 0x9d0a0e3c, 0x00002cf4, 0xfcbfecd6, 0xc765c4e4, 0x3bda04c6, 0xa6d00afa, 0x5a6fcad8, 0x61b5e2ea, 0x9d0a22c8}, - [16]uint32{0x00000000, 0x00483c71, 0x003e080f, 0x0076347e, 0x10081014, 0x10402c65, 0x1036181b, 0x107e246a, 0x10034406, 0x104b7877, 0x103d4c09, 0x10757078, 0x000b5412, 0x00436863, 0x00355c1d, 0x007d606c}, - [16]uint32{0x3f800000, 0x3f80241e, 0x3f801f04, 0x3f803b1a, 0x3f880408, 0x3f882016, 0x3f881b0c, 0x3f883f12, 0x3f8801a2, 0x3f8825bc, 0x3f881ea6, 0x3f883ab8, 0x3f8005aa, 0x3f8021b4, 0x3f801aae, 0x3f803eb0}, - uint32(0xfff80000), - [21]string{"0x99", "0x9f", "0xab", "0xfc", "0x24", "0xf3", "0x5b", "0xa0", "0xcb", "0xa1", "0x5c", "0xb0", "0xed", "0x9a", "0x76", "0x00", "0x0c", "0xca", "0x96", "0x56", "0x00"}}, - { - /* No.609 delta:2869 weight:817 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0xfb16ba9d, 0x3cb695cd, 0xc7a02f50, 0xb0702611, 0x4b669c8c, 0x8cc6b3dc, 0x77d00941, 0x00007d23, 0xfb16c7be, 0x3cb6e8ee, 0xc7a05273, 0xb0705b32, 0x4b66e1af, 0x8cc6ceff, 0x77d07462}, - [16]uint32{0x00000000, 0xc85c1356, 0x0c609102, 0xc43c8254, 0x6824287a, 0xa0783b2c, 0x6444b978, 0xac18aa2e, 0x0a00019d, 0xc25c12cb, 0x0660909f, 0xce3c83c9, 0x622429e7, 0xaa783ab1, 0x6e44b8e5, 0xa618abb3}, - [16]uint32{0x3f800000, 0x3fe42e09, 0x3f863048, 0x3fe21e41, 0x3fb41214, 0x3fd03c1d, 0x3fb2225c, 0x3fd60c55, 0x3f850000, 0x3fe12e09, 0x3f833048, 0x3fe71e41, 0x3fb11214, 0x3fd53c1d, 0x3fb7225c, 0x3fd30c55}, - uint32(0xfff80000), - [21]string{"0xc5", "0xea", "0xe7", "0x52", "0xe0", "0x2c", "0x43", "0x7d", "0x40", "0x3d", "0x1a", "0x11", "0xaa", "0xe6", "0x80", "0xa7", "0xb5", "0xde", "0x68", "0x23", "0x00"}}, - { - /* No.610 delta:887 weight:1295 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x0ebbeaf0, 0x22eaefc6, 0x2c510536, 0x5ff0262a, 0x514bccda, 0x7d1ac9ec, 0x73a1231c, 0x000081df, 0x0ebb6b2f, 0x22ea6e19, 0x2c5184e9, 0x5ff0a7f5, 0x514b4d05, 0x7d1a4833, 0x73a1a2c3}, - [16]uint32{0x00000000, 0x2026501f, 0x1003a80b, 0x3025f814, 0x41021419, 0x61244406, 0x5101bc12, 0x7127ec0d, 0x00020d96, 0x20245d89, 0x1001a59d, 0x3027f582, 0x4100198f, 0x61264990, 0x5103b184, 0x7125e19b}, - [16]uint32{0x3f800000, 0x3f901328, 0x3f8801d4, 0x3f9812fc, 0x3fa0810a, 0x3fb09222, 0x3fa880de, 0x3fb893f6, 0x3f800106, 0x3f90122e, 0x3f8800d2, 0x3f9813fa, 0x3fa0800c, 0x3fb09324, 0x3fa881d8, 0x3fb892f0}, - uint32(0xfff80000), - [21]string{"0x6e", "0x23", "0xda", "0xaf", "0xad", "0x9d", "0xd2", "0x68", "0xd9", "0xd8", "0x84", "0xb3", "0x63", "0x4c", "0xba", "0xde", "0xc0", "0x1f", "0xb4", "0x21", "0x00"}}, - { - /* No.611 delta:771 weight:1551 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xa79f7ea7, 0x932ad413, 0x34b5aab4, 0xcc50263b, 0x6bcf589c, 0x5f7af228, 0xf8e58c8f, 0x00008563, 0xa79ffbc4, 0x932a5170, 0x34b52fd7, 0xcc50a358, 0x6bcfddff, 0x5f7a774b, 0xf8e509ec}, - [16]uint32{0x00000000, 0x202215f5, 0x50240416, 0x700611e3, 0xe024201b, 0xc00635ee, 0xb000240d, 0x902231f8, 0x40400024, 0x606215d1, 0x10640432, 0x304611c7, 0xa064203f, 0x804635ca, 0xf0402429, 0xd06231dc}, - [16]uint32{0x3f800000, 0x3f90110a, 0x3fa81202, 0x3fb80308, 0x3ff01210, 0x3fe0031a, 0x3fd80012, 0x3fc81118, 0x3fa02000, 0x3fb0310a, 0x3f883202, 0x3f982308, 0x3fd03210, 0x3fc0231a, 0x3ff82012, 0x3fe83118}, - uint32(0xfff80000), - [21]string{"0xfb", "0xcc", "0x8c", "0xe9", "0x4d", "0x94", "0x92", "0x14", "0x0d", "0xf4", "0x49", "0x43", "0x37", "0x7b", "0xee", "0x2d", "0x09", "0x84", "0x27", "0x6e", "0x00"}}, - { - /* No.612 delta:1721 weight:1683 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x608bed53, 0xdaa13f6c, 0xba2ad23f, 0x06102645, 0x669bcb16, 0xdcb11929, 0xbc3af47a, 0x00006462, 0x608b8931, 0xdaa15b0e, 0xba2ab65d, 0x06104227, 0x669baf74, 0xdcb17d4b, 0xbc3a9018}, - [16]uint32{0x00000000, 0x007001d3, 0x000c019c, 0x007c004f, 0x0000804d, 0x0070819e, 0x000c81d1, 0x007c8002, 0x002a4017, 0x005a41c4, 0x0026418b, 0x00564058, 0x002ac05a, 0x005ac189, 0x0026c1c6, 0x0056c015}, - [16]uint32{0x3f800000, 0x3f803800, 0x3f800600, 0x3f803e00, 0x3f800040, 0x3f803840, 0x3f800640, 0x3f803e40, 0x3f801520, 0x3f802d20, 0x3f801320, 0x3f802b20, 0x3f801560, 0x3f802d60, 0x3f801360, 0x3f802b60}, - uint32(0xfff80000), - [21]string{"0x86", "0x13", "0x4c", "0x43", "0xa4", "0xd1", "0x89", "0x22", "0x7e", "0x2b", "0xc1", "0x6f", "0xbb", "0xa2", "0xfb", "0xad", "0x01", "0x59", "0x8b", "0x69", "0x00"}}, - { - /* No.613 delta:1309 weight:1651 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x8725599c, 0xcc344751, 0x4b111ecd, 0x3400265f, 0xb3257fc3, 0xf834610e, 0x7f113892, 0x00002a3f, 0x872573a3, 0xcc346d6e, 0x4b1134f2, 0x34000c60, 0xb32555fc, 0xf8344b31, 0x7f1112ad}, - [16]uint32{0x00000000, 0x5004847e, 0x20401c05, 0x7044987b, 0x107e0014, 0x407a846a, 0x303e1c11, 0x603a986f, 0x0056c022, 0x5052445c, 0x2016dc27, 0x70125859, 0x1028c036, 0x402c4448, 0x3068dc33, 0x606c584d}, - [16]uint32{0x3f800000, 0x3fa80242, 0x3f90200e, 0x3fb8224c, 0x3f883f00, 0x3fa03d42, 0x3f981f0e, 0x3fb01d4c, 0x3f802b60, 0x3fa82922, 0x3f900b6e, 0x3fb8092c, 0x3f881460, 0x3fa01622, 0x3f98346e, 0x3fb0362c}, - uint32(0xfff80000), - [21]string{"0xa7", "0xd5", "0x92", "0x22", "0x73", "0x00", "0x0b", "0xe0", "0x53", "0xb8", "0x04", "0x95", "0xf2", "0xbe", "0xdb", "0x95", "0x68", "0xb1", "0x94", "0x18", "0x00"}}, - { - /* No.614 delta:2905 weight:769 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0x638e4117, 0xecbfe499, 0x8f31a58e, 0x81302667, 0xe2be6770, 0x6d8fc2fe, 0x0e0183e9, 0x00000cf7, 0x638e4de0, 0xecbfe86e, 0x8f31a979, 0x81302a90, 0xe2be6b87, 0x6d8fce09, 0x0e018f1e}, - [16]uint32{0x00000000, 0x90f0923a, 0x0c290014, 0x9cd9922e, 0x127a9006, 0x828a023c, 0x1e539012, 0x8ea30228, 0x0820050d, 0x98d09737, 0x04090519, 0x94f99723, 0x1a5a950b, 0x8aaa0731, 0x1673951f, 0x86830725}, - [16]uint32{0x3f800000, 0x3fc87849, 0x3f861480, 0x3fce6cc9, 0x3f893d48, 0x3fc14501, 0x3f8f29c8, 0x3fc75181, 0x3f841002, 0x3fcc684b, 0x3f820482, 0x3fca7ccb, 0x3f8d2d4a, 0x3fc55503, 0x3f8b39ca, 0x3fc34183}, - uint32(0xfff80000), - [21]string{"0x1d", "0x1a", "0x3b", "0xef", "0x38", "0x1f", "0x12", "0x0b", "0x21", "0x12", "0x98", "0xd8", "0x8f", "0xc9", "0x9f", "0xfb", "0x4b", "0xbe", "0x6b", "0x92", "0x00"}}, - { - /* No.615 delta:1665 weight:1565 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xf4088f50, 0x4b8225bc, 0xbf8aaaec, 0xa480267f, 0x5088a92f, 0xef0203c3, 0x1b0a8c93, 0x00009f95, 0xf40810c5, 0x4b82ba29, 0xbf8a3579, 0xa480b9ea, 0x508836ba, 0xef029c56, 0x1b0a1306}, - [16]uint32{0x00000000, 0x0d4660da, 0x035a40d9, 0x0e1c2003, 0x03c0f0a4, 0x0e86907e, 0x009ab07d, 0x0ddcd0a7, 0x010441a8, 0x0c422172, 0x025e0171, 0x0f1861ab, 0x02c4b10c, 0x0f82d1d6, 0x019ef1d5, 0x0cd8910f}, - [16]uint32{0x3f800000, 0x3f86a330, 0x3f81ad20, 0x3f870e10, 0x3f81e078, 0x3f874348, 0x3f804d58, 0x3f86ee68, 0x3f808220, 0x3f862110, 0x3f812f00, 0x3f878c30, 0x3f816258, 0x3f87c168, 0x3f80cf78, 0x3f866c48}, - uint32(0xfff80000), - [21]string{"0xa4", "0xc4", "0xa6", "0xfb", "0x2f", "0x2e", "0xa7", "0xd2", "0xc7", "0x23", "0x3e", "0x43", "0xb2", "0x17", "0x37", "0x40", "0xa6", "0x54", "0xfa", "0x59", "0x00"}}, - { - /* No.616 delta:867 weight:1503 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0x92bb52eb, 0x65a9b7fe, 0xf712e515, 0xa7f02689, 0x354b7462, 0xc2599177, 0x50e2c39c, 0x0000f6d6, 0x92bba43d, 0x65a94128, 0xf71213c3, 0xa7f0d05f, 0x354b82b4, 0xc25967a1, 0x50e2354a}, - [16]uint32{0x00000000, 0xc0609df6, 0x00025b53, 0xc062c6a5, 0x0022421d, 0xc042dfeb, 0x0020194e, 0xc04084b8, 0x20020202, 0xe0629ff4, 0x20005951, 0xe060c4a7, 0x2020401f, 0xe040dde9, 0x20221b4c, 0xe04286ba}, - [16]uint32{0x3f800000, 0x3fe0304e, 0x3f80012d, 0x3fe03163, 0x3f801121, 0x3fe0216f, 0x3f80100c, 0x3fe02042, 0x3f900101, 0x3ff0314f, 0x3f90002c, 0x3ff03062, 0x3f901020, 0x3ff0206e, 0x3f90110d, 0x3ff02143}, - uint32(0xfff80000), - [21]string{"0x85", "0x04", "0xca", "0xaf", "0x94", "0xdd", "0x85", "0xe1", "0xcb", "0x14", "0x33", "0x83", "0x79", "0x98", "0x3c", "0x75", "0xc4", "0x49", "0xfd", "0x6b", "0x00"}}, - { - /* No.617 delta:1676 weight:1639 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0x27527d8e, 0xcb473f15, 0xec15429b, 0xf250269a, 0xd5025b14, 0x3917198f, 0x1e456401, 0x0000c47a, 0x2752b9f4, 0xcb47fb6f, 0xec1586e1, 0xf250e2e0, 0xd5029f6e, 0x3917ddf5, 0x1e45a07b}, - [16]uint32{0x00000000, 0x006c2155, 0x00034073, 0x006f6126, 0x0204c1f8, 0x0268e0ad, 0x0207818b, 0x026ba0de, 0x0000c137, 0x006ce062, 0x00038144, 0x006fa011, 0x020400cf, 0x0268219a, 0x020740bc, 0x026b61e9}, - [16]uint32{0x3f800000, 0x3f803610, 0x3f8001a0, 0x3f8037b0, 0x3f810260, 0x3f813470, 0x3f8103c0, 0x3f8135d0, 0x3f800060, 0x3f803670, 0x3f8001c0, 0x3f8037d0, 0x3f810200, 0x3f813410, 0x3f8103a0, 0x3f8135b0}, - uint32(0xfff80000), - [21]string{"0xbf", "0x62", "0x44", "0x02", "0x13", "0xf1", "0xcc", "0xa4", "0x9c", "0xb4", "0xde", "0x95", "0x97", "0x5c", "0x54", "0x98", "0x60", "0x15", "0x39", "0x8e", "0x00"}}, - { - /* No.618 delta:1717 weight:1347 */ - 11213, - 64, - 13, - 4, - [16]uint32{0x00000000, 0xd81946d0, 0x6175779c, 0xb96c314c, 0xbbd026a6, 0x63c96076, 0xdaa5513a, 0x02bc17ea, 0x00006fcc, 0xd819291c, 0x61751850, 0xb96c5e80, 0xbbd0496a, 0x63c90fba, 0xdaa53ef6, 0x02bc7826}, - [16]uint32{0x00000000, 0x000200bf, 0x00000082, 0x0002003d, 0x2069019a, 0x206b0125, 0x20690118, 0x206b01a7, 0x401c01b6, 0x401e0109, 0x401c0134, 0x401e018b, 0x6075002c, 0x60770093, 0x607500ae, 0x60770011}, - [16]uint32{0x3f800000, 0x3f800100, 0x3f800000, 0x3f800100, 0x3f903480, 0x3f903580, 0x3f903480, 0x3f903580, 0x3fa00e00, 0x3fa00f00, 0x3fa00e00, 0x3fa00f00, 0x3fb03a80, 0x3fb03b80, 0x3fb03a80, 0x3fb03b80}, - uint32(0xfff80000), - [21]string{"0xa4", "0x2e", "0xda", "0xaa", "0x55", "0x3d", "0x86", "0x11", "0x7e", "0x49", "0xe4", "0xda", "0x66", "0x35", "0x26", "0x31", "0x60", "0x1d", "0x6b", "0x98", "0x00"}}, - { - /* No.619 delta:947 weight:1595 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x524682db, 0xd7d886be, 0x859e0465, 0xd2d026b0, 0x8096a46b, 0x0508a00e, 0x574e22d5, 0x0000107f, 0x524692a4, 0xd7d896c1, 0x859e141a, 0xd2d036cf, 0x8096b414, 0x0508b071, 0x574e32aa}, - [16]uint32{0x00000000, 0x1025f9de, 0x20032c4d, 0x3026d593, 0x20005867, 0x3025a1b9, 0x0003742a, 0x10268df4, 0x4003930f, 0x50266ad1, 0x6000bf42, 0x7025469c, 0x6003cb68, 0x702632b6, 0x4000e725, 0x50251efb}, - [16]uint32{0x3f800000, 0x3f8812fc, 0x3f900196, 0x3f98136a, 0x3f90002c, 0x3f9812d0, 0x3f8001ba, 0x3f881346, 0x3fa001c9, 0x3fa81335, 0x3fb0005f, 0x3fb812a3, 0x3fb001e5, 0x3fb81319, 0x3fa00073, 0x3fa8128f}, - uint32(0xfff80000), - [21]string{"0x00", "0x3e", "0xce", "0x51", "0xcd", "0x78", "0x94", "0x20", "0xf3", "0x7c", "0x06", "0xeb", "0x07", "0x19", "0x06", "0xf4", "0x58", "0xb5", "0xee", "0x24", "0x00"}}, - { - /* No.620 delta:3092 weight:635 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xd60ac9f0, 0x7c1657f0, 0xaa1c9e00, 0x949026ce, 0x429aef3e, 0xe886713e, 0x3e8cb8ce, 0x00000714, 0xd60acee4, 0x7c1650e4, 0xaa1c9914, 0x949021da, 0x429ae82a, 0xe886762a, 0x3e8cbfda}, - [16]uint32{0x00000000, 0x83d099df, 0x312020b2, 0xb2f0b96d, 0x10c0058a, 0x93109c55, 0x21e02538, 0xa230bce7, 0x0a880014, 0x895899cb, 0x3ba820a6, 0xb878b979, 0x1a48059e, 0x99989c41, 0x2b68252c, 0xa8b8bcf3}, - [16]uint32{0x3f800000, 0x3fc1e84c, 0x3f989010, 0x3fd9785c, 0x3f886002, 0x3fc9884e, 0x3f90f012, 0x3fd1185e, 0x3f854400, 0x3fc4ac4c, 0x3f9dd410, 0x3fdc3c5c, 0x3f8d2402, 0x3fcccc4e, 0x3f95b412, 0x3fd45c5e}, - uint32(0xfff80000), - [21]string{"0x23", "0xec", "0xeb", "0x2e", "0xe4", "0x47", "0xc9", "0x4f", "0xe6", "0x31", "0xc7", "0x30", "0xcd", "0x95", "0xe9", "0x0f", "0x83", "0xde", "0xc0", "0x16", "0x00"}}, - { - /* No.621 delta:655 weight:1715 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0xbb48eeca, 0x663d6af7, 0xdd75843d, 0x362026d8, 0x8d68c812, 0x501d4c2f, 0xeb55a2e5, 0x0000620c, 0xbb488cc6, 0x663d08fb, 0xdd75e631, 0x362044d4, 0x8d68aa1e, 0x501d2e23, 0xeb55c0e9}, - [16]uint32{0x00000000, 0x2075849d, 0x000370aa, 0x2076f437, 0x10388368, 0x304d07f5, 0x103bf3c2, 0x304e775f, 0x0000a403, 0x2075209e, 0x0003d4a9, 0x20765034, 0x1038276b, 0x304da3f6, 0x103b57c1, 0x304ed35c}, - [16]uint32{0x3f800000, 0x3f903ac2, 0x3f8001b8, 0x3f903b7a, 0x3f881c41, 0x3f982683, 0x3f881df9, 0x3f98273b, 0x3f800052, 0x3f903a90, 0x3f8001ea, 0x3f903b28, 0x3f881c13, 0x3f9826d1, 0x3f881dab, 0x3f982769}, - uint32(0xfff80000), - [21]string{"0xfc", "0xa0", "0x47", "0x6e", "0xa0", "0x27", "0x3f", "0xf9", "0x1b", "0xcd", "0x1d", "0xe5", "0x8c", "0xb8", "0x30", "0xc3", "0x1a", "0x76", "0x3b", "0x21", "0x00"}}, - { - /* No.622 delta:1514 weight:1541 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0x5eef6293, 0x4e715698, 0x109e340b, 0x08b026e2, 0x565f4471, 0x46c1707a, 0x182e12e9, 0x00002fa5, 0x5eef4d36, 0x4e71793d, 0x109e1bae, 0x08b00947, 0x565f6bd4, 0x46c15fdf, 0x182e3d4c}, - [16]uint32{0x00000000, 0x1037c99e, 0x402820a2, 0x501fe93c, 0x10342157, 0x0003e8c9, 0x501c01f5, 0x402bc86b, 0x50559048, 0x406259d6, 0x107db0ea, 0x004a7974, 0x4061b11f, 0x50567881, 0x004991bd, 0x107e5823}, - [16]uint32{0x3f800000, 0x3f881be4, 0x3fa01410, 0x3fa80ff4, 0x3f881a10, 0x3f8001f4, 0x3fa80e00, 0x3fa015e4, 0x3fa82ac8, 0x3fa0312c, 0x3f883ed8, 0x3f80253c, 0x3fa030d8, 0x3fa82b3c, 0x3f8024c8, 0x3f883f2c}, - uint32(0xfff80000), - [21]string{"0x7b", "0xfd", "0xca", "0x16", "0x74", "0x8c", "0x4c", "0x1d", "0x00", "0x41", "0x9d", "0xa7", "0x79", "0xe3", "0xf8", "0x58", "0xb7", "0x27", "0x3f", "0xe4", "0x00"}}, - { - /* No.623 delta:755 weight:1729 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0x46cbd438, 0x280f1161, 0x6ec4c559, 0x4fa026f1, 0x096bf2c9, 0x67af3790, 0x2164e3a8, 0x0000c6ea, 0x46cb12d2, 0x280fd78b, 0x6ec403b3, 0x4fa0e01b, 0x096b3423, 0x67aff17a, 0x21642542}, - [16]uint32{0x00000000, 0xa86058be, 0x0003805b, 0xa863d8e5, 0x0030220a, 0xa8507ab4, 0x0033a251, 0xa853faef, 0x1004201d, 0xb86478a3, 0x1007a046, 0xb867f8f8, 0x10340217, 0xb8545aa9, 0x1037824c, 0xb857daf2}, - [16]uint32{0x3f800000, 0x3fd4302c, 0x3f8001c0, 0x3fd431ec, 0x3f801811, 0x3fd4283d, 0x3f8019d1, 0x3fd429fd, 0x3f880210, 0x3fdc323c, 0x3f8803d0, 0x3fdc33fc, 0x3f881a01, 0x3fdc2a2d, 0x3f881bc1, 0x3fdc2bed}, - uint32(0xfff80000), - [21]string{"0xb5", "0x92", "0x01", "0x70", "0x20", "0xd6", "0xbb", "0x69", "0x99", "0x3a", "0x90", "0x4f", "0xdc", "0xc2", "0x17", "0x8f", "0x8e", "0x43", "0x14", "0x35", "0x00"}}, - { - /* No.624 delta:2168 weight:1255 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x9eace3f4, 0xcd23c2aa, 0x538f215e, 0xd1f02700, 0x4f5cc4f4, 0x1cd3e5aa, 0x827f065e, 0x00007152, 0x9eac92a6, 0xcd23b3f8, 0x538f500c, 0xd1f05652, 0x4f5cb5a6, 0x1cd394f8, 0x827f770c}, - [16]uint32{0x00000000, 0x214389db, 0x0a026412, 0x2b41edc9, 0x00704388, 0x2133ca53, 0x0a72279a, 0x2b31ae41, 0xb8184165, 0x995bc8be, 0xb21a2577, 0x9359acac, 0xb86802ed, 0x992b8b36, 0xb26a66ff, 0x9329ef24}, - [16]uint32{0x3f800000, 0x3f90a1c4, 0x3f850132, 0x3f95a0f6, 0x3f803821, 0x3f9099e5, 0x3f853913, 0x3f9598d7, 0x3fdc0c20, 0x3fccade4, 0x3fd90d12, 0x3fc9acd6, 0x3fdc3401, 0x3fcc95c5, 0x3fd93533, 0x3fc994f7}, - uint32(0xfff80000), - [21]string{"0x7e", "0xad", "0xfe", "0x4e", "0x67", "0xee", "0x0a", "0x39", "0xeb", "0xf2", "0xd2", "0x5c", "0xec", "0x45", "0x85", "0x3a", "0x75", "0xf3", "0x25", "0xe7", "0x00"}}, - { - /* No.625 delta:811 weight:939 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0x8a37e969, 0x8613fabb, 0x0c2413d2, 0x84102713, 0x0e27ce7a, 0x0203dda8, 0x883434c1, 0x0000b09b, 0x8a3759f2, 0x86134a20, 0x0c24a349, 0x84109788, 0x0e277ee1, 0x02036d33, 0x8834845a}, - [16]uint32{0x00000000, 0x004fe57f, 0x501101dd, 0x505ee4a2, 0x1048942e, 0x10077151, 0x405995f3, 0x4016708c, 0x50034014, 0x504ca56b, 0x001241c9, 0x005da4b6, 0x404bd43a, 0x40043145, 0x105ad5e7, 0x10153098}, - [16]uint32{0x3f800000, 0x3f8027f2, 0x3fa80880, 0x3fa82f72, 0x3f88244a, 0x3f8803b8, 0x3fa02cca, 0x3fa00b38, 0x3fa801a0, 0x3fa82652, 0x3f800920, 0x3f802ed2, 0x3fa025ea, 0x3fa00218, 0x3f882d6a, 0x3f880a98}, - uint32(0xfff80000), - [21]string{"0x15", "0x91", "0x6c", "0x2d", "0x1f", "0x9b", "0x63", "0x02", "0xed", "0x7e", "0x94", "0xe9", "0x8a", "0x87", "0x9c", "0xf7", "0x9c", "0x6a", "0x57", "0xe8", "0x00"}}, - { - /* No.626 delta:905 weight:729 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x487ef5e9, 0x5ebf8ee5, 0x16c17b0c, 0xecd0272a, 0xa4aed2c3, 0xb26fa9cf, 0xfa115c26, 0x00002da5, 0x487ed84c, 0x5ebfa340, 0x16c156a9, 0xecd00a8f, 0xa4aeff66, 0xb26f846a, 0xfa117183}, - [16]uint32{0x00000000, 0x081c1ed7, 0x0561001b, 0x0d7d1ecc, 0x40884802, 0x489456d5, 0x45e94819, 0x4df556ce, 0x004201a7, 0x085e1f70, 0x052301bc, 0x0d3f1f6b, 0x40ca49a5, 0x48d65772, 0x45ab49be, 0x4db75769}, - [16]uint32{0x3f800000, 0x3f840e0f, 0x3f82b080, 0x3f86be8f, 0x3fa04424, 0x3fa44a2b, 0x3fa2f4a4, 0x3fa6faab, 0x3f802100, 0x3f842f0f, 0x3f829180, 0x3f869f8f, 0x3fa06524, 0x3fa46b2b, 0x3fa2d5a4, 0x3fa6dbab}, - uint32(0xfff80000), - [21]string{"0xbf", "0x0b", "0xe8", "0x6e", "0xd2", "0xb2", "0x2e", "0xfd", "0x0a", "0xcf", "0x83", "0x75", "0xe1", "0x95", "0x9c", "0xfc", "0x24", "0xf1", "0x86", "0xdc", "0x00"}}, - { - /* No.627 delta:708 weight:1509 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0x7c8307e4, 0x72c9b5f4, 0x0e4ab210, 0x75f02730, 0x097320d4, 0x073992c4, 0x7bba9520, 0x000049f7, 0x7c834e13, 0x72c9fc03, 0x0e4afbe7, 0x75f06ec7, 0x09736923, 0x0739db33, 0x7bbadcd7}, - [16]uint32{0x00000000, 0x4004201e, 0x20024b2a, 0x60066b34, 0x7042e276, 0x3046c268, 0x5040a95c, 0x10448942, 0x10001005, 0x5004301b, 0x30025b2f, 0x70067b31, 0x6042f273, 0x2046d26d, 0x4040b959, 0x00449947}, - [16]uint32{0x3f800000, 0x3fa00210, 0x3f900125, 0x3fb00335, 0x3fb82171, 0x3f982361, 0x3fa82054, 0x3f882244, 0x3f880008, 0x3fa80218, 0x3f98012d, 0x3fb8033d, 0x3fb02179, 0x3f902369, 0x3fa0205c, 0x3f80224c}, - uint32(0xfff80000), - [21]string{"0x1b", "0x67", "0xbd", "0xdc", "0x43", "0x72", "0x4b", "0xf1", "0x2d", "0xbf", "0x1f", "0x32", "0xad", "0x1f", "0x77", "0x96", "0x0c", "0x80", "0xbb", "0x03", "0x00"}}, - { - /* No.628 delta:1122 weight:1799 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x09bcd29a, 0x52ed8467, 0x5b5156fd, 0xf4902743, 0xfd2cf5d9, 0xa67da324, 0xafc171be, 0x00004b29, 0x09bc99b3, 0x52edcf4e, 0x5b511dd4, 0xf4906c6a, 0xfd2cbef0, 0xa67de80d, 0xafc13a97}, - [16]uint32{0x00000000, 0x4820c11e, 0x800061cc, 0xc820a0d2, 0x1008d008, 0x58281116, 0x9008b1c4, 0xd82870da, 0x40022019, 0x0822e107, 0xc00241d5, 0x882280cb, 0x500af011, 0x182a310f, 0xd00a91dd, 0x982a50c3}, - [16]uint32{0x3f800000, 0x3fa41060, 0x3fc00030, 0x3fe41050, 0x3f880468, 0x3fac1408, 0x3fc80458, 0x3fec1438, 0x3fa00110, 0x3f841170, 0x3fe00120, 0x3fc41140, 0x3fa80578, 0x3f8c1518, 0x3fe80548, 0x3fcc1528}, - uint32(0xfff80000), - [21]string{"0x0e", "0xa2", "0x1d", "0xef", "0x2f", "0x58", "0x86", "0x12", "0xe8", "0xf5", "0x25", "0x41", "0x7e", "0x5f", "0xca", "0xf2", "0xe4", "0x42", "0xdf", "0xc6", "0x00"}}, - { - /* No.629 delta:811 weight:1603 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0x3cb77a18, 0x4828f6f5, 0x749f8ced, 0x5f302750, 0x63875d48, 0x1718d1a5, 0x2bafabbd, 0x0000ef80, 0x3cb79598, 0x48281975, 0x749f636d, 0x5f30c8d0, 0x6387b2c8, 0x17183e25, 0x2baf443d}, - [16]uint32{0x00000000, 0x204c84b2, 0x40021f46, 0x604e9bf4, 0x40018205, 0x604d06b7, 0x00039d43, 0x204f19f1, 0x1000401b, 0x304cc4a9, 0x50025f5d, 0x704edbef, 0x5001c21e, 0x704d46ac, 0x1003dd58, 0x304f59ea}, - [16]uint32{0x3f800000, 0x3f902642, 0x3fa0010f, 0x3fb0274d, 0x3fa000c1, 0x3fb02683, 0x3f8001ce, 0x3f90278c, 0x3f880020, 0x3f982662, 0x3fa8012f, 0x3fb8276d, 0x3fa800e1, 0x3fb826a3, 0x3f8801ee, 0x3f9827ac}, - uint32(0xfff80000), - [21]string{"0xdd", "0x8b", "0x4d", "0xe4", "0x27", "0x29", "0x42", "0x47", "0x53", "0xda", "0x4a", "0xe9", "0xa2", "0x5c", "0x0b", "0x9e", "0xbc", "0x68", "0xe6", "0x1f", "0x00"}}, - { - /* No.630 delta:1016 weight:1229 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0x5f47ce13, 0xfffc577f, 0xa0bb996c, 0xad70276a, 0xf237e979, 0x528c7015, 0x0dcbbe06, 0x000036dd, 0x5f47f8ce, 0xfffc61a2, 0xa0bbafb1, 0xad7011b7, 0xf237dfa4, 0x528c46c8, 0x0dcb88db}, - [16]uint32{0x00000000, 0x4420185f, 0x100600f1, 0x542618ae, 0x00028194, 0x442299cb, 0x10048165, 0x5424993a, 0x00010407, 0x44211c58, 0x100704f6, 0x54271ca9, 0x00038593, 0x44239dcc, 0x10058562, 0x54259d3d}, - [16]uint32{0x3f800000, 0x3fa2100c, 0x3f880300, 0x3faa130c, 0x3f800140, 0x3fa2114c, 0x3f880240, 0x3faa124c, 0x3f800082, 0x3fa2108e, 0x3f880382, 0x3faa138e, 0x3f8001c2, 0x3fa211ce, 0x3f8802c2, 0x3faa12ce}, - uint32(0xfff80000), - [21]string{"0xfb", "0x6d", "0x75", "0xc1", "0x1e", "0xc6", "0x12", "0x58", "0xf7", "0x25", "0x03", "0xec", "0xb7", "0x75", "0xd0", "0xf4", "0xcd", "0x3f", "0xf4", "0xfb", "0x00"}}, - { - /* No.631 delta:995 weight:1673 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x6df50ec3, 0xc3232dde, 0xaed6231d, 0x9aa0277b, 0xf75529b8, 0x59830aa5, 0x34760466, 0x0000d47e, 0x6df5dabd, 0xc323f9a0, 0xaed6f763, 0x9aa0f305, 0xf755fdc6, 0x5983dedb, 0x3476d018}, - [16]uint32{0x00000000, 0x0003ac1e, 0xa06835b1, 0xa06b99af, 0x00602047, 0x00638c59, 0xa00815f6, 0xa00bb9e8, 0x1000152c, 0x1003b932, 0xb068209d, 0xb06b8c83, 0x1060356b, 0x10639975, 0xb00800da, 0xb00bacc4}, - [16]uint32{0x3f800000, 0x3f8001d6, 0x3fd0341a, 0x3fd035cc, 0x3f803010, 0x3f8031c6, 0x3fd0040a, 0x3fd005dc, 0x3f88000a, 0x3f8801dc, 0x3fd83410, 0x3fd835c6, 0x3f88301a, 0x3f8831cc, 0x3fd80400, 0x3fd805d6}, - uint32(0xfff80000), - [21]string{"0x73", "0xf9", "0x58", "0x94", "0xcb", "0x1d", "0x35", "0x64", "0x04", "0x56", "0xc7", "0x7d", "0x7f", "0x0a", "0x8a", "0xfe", "0x8b", "0xe0", "0x33", "0x84", "0x00"}}, - { - /* No.632 delta:773 weight:1473 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0x20f1fa99, 0xd6561500, 0xf6a7ef99, 0xf8b0278b, 0xd841dd12, 0x2ee6328b, 0x0e17c812, 0x000065ac, 0x20f19f35, 0xd65670ac, 0xf6a78a35, 0xf8b04227, 0xd841b8be, 0x2ee65727, 0x0e17adbe}, - [16]uint32{0x00000000, 0x1041a0fd, 0x8011218c, 0x90508171, 0x40008092, 0x5041206f, 0xc011a11e, 0xd05001e3, 0x0128e128, 0x116941d5, 0x8139c0a4, 0x91786059, 0x412861ba, 0x5169c147, 0xc1394036, 0xd178e0cb}, - [16]uint32{0x3f800000, 0x3f8820d0, 0x3fc00890, 0x3fc82840, 0x3fa00040, 0x3fa82090, 0x3fe008d0, 0x3fe82800, 0x3f809470, 0x3f88b4a0, 0x3fc09ce0, 0x3fc8bc30, 0x3fa09430, 0x3fa8b4e0, 0x3fe09ca0, 0x3fe8bc70}, - uint32(0xfff80000), - [21]string{"0x5d", "0xc5", "0x75", "0x67", "0xa0", "0x3e", "0x52", "0x15", "0x0b", "0x40", "0x3c", "0x18", "0x56", "0x6e", "0x2b", "0xe7", "0x5f", "0x39", "0x75", "0xec", "0x00"}}, - { - /* No.633 delta:860 weight:1601 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0x56a2fcc0, 0x37bccf56, 0x611e3396, 0x91f02796, 0xc752db56, 0xa64ce8c0, 0xf0ee1400, 0x0000b0e1, 0x56a24c21, 0x37bc7fb7, 0x611e8377, 0x91f09777, 0xc7526bb7, 0xa64c5821, 0xf0eea4e1}, - [16]uint32{0x00000000, 0x4008509a, 0x1000116f, 0x500841f5, 0x200341a4, 0x600b113e, 0x300350cb, 0x700b0051, 0x004200d7, 0x404a504d, 0x104211b8, 0x504a4122, 0x20414173, 0x604911e9, 0x3041501c, 0x70490086}, - [16]uint32{0x3f800000, 0x3fa00428, 0x3f880008, 0x3fa80420, 0x3f9001a0, 0x3fb00588, 0x3f9801a8, 0x3fb80580, 0x3f802100, 0x3fa02528, 0x3f882108, 0x3fa82520, 0x3f9020a0, 0x3fb02488, 0x3f9820a8, 0x3fb82480}, - uint32(0xfff80000), - [21]string{"0xf9", "0xf3", "0xe7", "0x61", "0x2a", "0xc7", "0x69", "0xa4", "0xdd", "0x59", "0xbd", "0x87", "0x5b", "0xce", "0x3c", "0x7c", "0x4b", "0x51", "0x48", "0x74", "0x00"}}, - { - /* No.634 delta:2645 weight:917 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x469ad979, 0x10db26c0, 0x5641ffb9, 0xed8027a1, 0xab1afed8, 0xfd5b0161, 0xbbc1d818, 0x00003231, 0x469aeb48, 0x10db14f1, 0x5641cd88, 0xed801590, 0xab1acce9, 0xfd5b3350, 0xbbc1ea29}, - [16]uint32{0x00000000, 0x848023d6, 0xe581008b, 0x6101235d, 0x3201034c, 0xb681209a, 0xd78003c7, 0x53002011, 0x4049402f, 0xc4c963f9, 0xa5c840a4, 0x21486372, 0x72484363, 0xf6c860b5, 0x97c943e8, 0x1349603e}, - [16]uint32{0x3f800000, 0x3fc24011, 0x3ff2c080, 0x3fb08091, 0x3f990081, 0x3fdb4090, 0x3febc001, 0x3fa98010, 0x3fa024a0, 0x3fe264b1, 0x3fd2e420, 0x3f90a431, 0x3fb92421, 0x3ffb6430, 0x3fcbe4a1, 0x3f89a4b0}, - uint32(0xfff80000), - [21]string{"0x3c", "0xf6", "0x19", "0x43", "0x69", "0xb5", "0x9f", "0xd7", "0x1b", "0x13", "0xbf", "0x21", "0xc0", "0x28", "0xc9", "0x50", "0xd4", "0x49", "0xbc", "0xa9", "0x00"}}, - { - /* No.635 delta:1122 weight:1499 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x572e332c, 0x2f6e1d16, 0x78402e3a, 0x8ea027b5, 0xd98e1499, 0xa1ce3aa3, 0xf6e0098f, 0x0000cacb, 0x572ef9e7, 0x2f6ed7dd, 0x7840e4f1, 0x8ea0ed7e, 0xd98ede52, 0xa1cef068, 0xf6e0c344}, - [16]uint32{0x00000000, 0x301ea87a, 0x606af135, 0x5074594f, 0x006b2509, 0x30758d73, 0x6001d43c, 0x501f7c46, 0x00026010, 0x301cc86a, 0x60689125, 0x5076395f, 0x00694519, 0x3077ed63, 0x6003b42c, 0x501d1c56}, - [16]uint32{0x3f800000, 0x3f980f54, 0x3fb03578, 0x3fa83a2c, 0x3f803592, 0x3f983ac6, 0x3fb000ea, 0x3fa80fbe, 0x3f800130, 0x3f980e64, 0x3fb03448, 0x3fa83b1c, 0x3f8034a2, 0x3f983bf6, 0x3fb001da, 0x3fa80e8e}, - uint32(0xfff80000), - [21]string{"0x60", "0x69", "0xd8", "0x82", "0xcc", "0x6f", "0xdd", "0x11", "0xa4", "0x9a", "0x4c", "0x20", "0x8b", "0xec", "0xf9", "0x89", "0x5a", "0x12", "0xf1", "0xa8", "0x00"}}, - { - /* No.636 delta:773 weight:725 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0xb8034d5a, 0xda3d4934, 0x623e046e, 0xe99027cc, 0x51936a96, 0x33ad6ef8, 0x8bae23a2, 0x0000dd52, 0xb8039008, 0xda3d9466, 0x623ed93c, 0xe990fa9e, 0x5193b7c4, 0x33adb3aa, 0x8baefef0}, - [16]uint32{0x00000000, 0x4a449037, 0x400110c3, 0x0a4580f4, 0x4022e19d, 0x0a6671aa, 0x0023f15e, 0x4a676169, 0x00501053, 0x4a148064, 0x40510090, 0x0a1590a7, 0x4072f1ce, 0x0a3661f9, 0x0073e10d, 0x4a37713a}, - [16]uint32{0x3f800000, 0x3fa52248, 0x3fa00088, 0x3f8522c0, 0x3fa01170, 0x3f853338, 0x3f8011f8, 0x3fa533b0, 0x3f802808, 0x3fa50a40, 0x3fa02880, 0x3f850ac8, 0x3fa03978, 0x3f851b30, 0x3f8039f0, 0x3fa51bb8}, - uint32(0xfff80000), - [21]string{"0xba", "0x25", "0x13", "0xc4", "0x8a", "0xf6", "0xa7", "0x55", "0x70", "0xda", "0xf1", "0x17", "0x77", "0x0a", "0xb6", "0x83", "0x4a", "0x69", "0x45", "0x45", "0x00"}}, - { - /* No.637 delta:1366 weight:1673 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xcab590cf, 0x36b4510d, 0xfc01c1c2, 0x092027d0, 0xc395b71f, 0x3f9476dd, 0xf521e612, 0x00008eca, 0xcab51e05, 0x36b4dfc7, 0xfc014f08, 0x0920a91a, 0xc39539d5, 0x3f94f817, 0xf52168d8}, - [16]uint32{0x00000000, 0x3030be3a, 0x20186835, 0x1028d60f, 0x002ea366, 0x301e1d5c, 0x2036cb53, 0x10067569, 0x0042e071, 0x30725e4b, 0x205a8844, 0x106a367e, 0x006c4317, 0x305cfd2d, 0x20742b22, 0x10449518}, - [16]uint32{0x3f800000, 0x3f98185f, 0x3f900c34, 0x3f88146b, 0x3f801751, 0x3f980f0e, 0x3f901b65, 0x3f88033a, 0x3f802170, 0x3f98392f, 0x3f902d44, 0x3f88351b, 0x3f803621, 0x3f982e7e, 0x3f903a15, 0x3f88224a}, - uint32(0xfff80000), - [21]string{"0x3b", "0x38", "0xc3", "0x65", "0x23", "0xa7", "0x44", "0xf8", "0x5f", "0xd8", "0xad", "0x75", "0x16", "0x73", "0xfc", "0x48", "0xf6", "0x8f", "0xfd", "0x7e", "0x00"}}, - { - /* No.638 delta:736 weight:1685 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x904eccf5, 0x728dead9, 0xe2c3262c, 0x207027ee, 0xb03eeb1b, 0x52fdcd37, 0xc2b301c2, 0x0000dbf1, 0x904e1704, 0x728d3128, 0xe2c3fddd, 0x2070fc1f, 0xb03e30ea, 0x52fd16c6, 0xc2b3da33}, - [16]uint32{0x00000000, 0x800018f6, 0x4000e1ac, 0xc000f95a, 0x00a01772, 0x80a00f84, 0x40a0f6de, 0xc0a0ee28, 0x2041810b, 0xa04199fd, 0x604160a7, 0xe0417851, 0x20e19679, 0xa0e18e8f, 0x60e177d5, 0xe0e16f23}, - [16]uint32{0x3f800000, 0x3fc0000c, 0x3fa00070, 0x3fe0007c, 0x3f80500b, 0x3fc05007, 0x3fa0507b, 0x3fe05077, 0x3f9020c0, 0x3fd020cc, 0x3fb020b0, 0x3ff020bc, 0x3f9070cb, 0x3fd070c7, 0x3fb070bb, 0x3ff070b7}, - uint32(0xfff80000), - [21]string{"0xfa", "0x5e", "0xdb", "0x80", "0xdb", "0xe1", "0x7e", "0x69", "0x3b", "0xc1", "0x34", "0x78", "0x15", "0xc4", "0x10", "0x22", "0x58", "0xad", "0xfa", "0xe2", "0x00"}}, - { - /* No.639 delta:800 weight:1301 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x664fa452, 0x02335b44, 0x647cff16, 0x224027f0, 0x440f83a2, 0x20737cb4, 0x463cd8e6, 0x000095b6, 0x664f31e4, 0x0233cef2, 0x647c6aa0, 0x2240b246, 0x440f1614, 0x2073e902, 0x463c4d50}, - [16]uint32{0x00000000, 0x212ed537, 0x1024115a, 0x310ac46d, 0x046461e8, 0x254ab4df, 0x144070b2, 0x356ea585, 0x2002459d, 0x012c90aa, 0x302654c7, 0x110881f0, 0x24662475, 0x0548f142, 0x3442352f, 0x156ce018}, - [16]uint32{0x3f800000, 0x3f90976a, 0x3f881208, 0x3f988562, 0x3f823230, 0x3f92a55a, 0x3f8a2038, 0x3f9ab752, 0x3f900122, 0x3f809648, 0x3f98132a, 0x3f888440, 0x3f923312, 0x3f82a478, 0x3f9a211a, 0x3f8ab670}, - uint32(0xfff80000), - [21]string{"0x8b", "0xfb", "0x7a", "0xfd", "0xa6", "0xf3", "0x61", "0x3e", "0x1d", "0x73", "0x73", "0x21", "0x1d", "0x43", "0x27", "0x8b", "0x5a", "0x91", "0x90", "0xf8", "0x00"}}, - { - /* No.640 delta:718 weight:1325 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x4b963850, 0xb746833f, 0xfcd0bb6f, 0xadc02802, 0xe6561052, 0x1a86ab3d, 0x5110936d, 0x000056ab, 0x4b966efb, 0xb746d594, 0xfcd0edc4, 0xadc07ea9, 0xe65646f9, 0x1a86fd96, 0x5110c5c6}, - [16]uint32{0x00000000, 0x020cc8d7, 0x804101e9, 0x824dc93e, 0x007284ab, 0x027e4c7c, 0x80338542, 0x823f4d95, 0x000849a7, 0x02048170, 0x8049484e, 0x82458099, 0x007acd0c, 0x027605db, 0x803bcce5, 0x82370432}, - [16]uint32{0x3f800000, 0x3f810664, 0x3fc02080, 0x3fc126e4, 0x3f803942, 0x3f813f26, 0x3fc019c2, 0x3fc11fa6, 0x3f800424, 0x3f810240, 0x3fc024a4, 0x3fc122c0, 0x3f803d66, 0x3f813b02, 0x3fc01de6, 0x3fc11b82}, - uint32(0xfff80000), - [21]string{"0xce", "0x30", "0x15", "0x26", "0x2c", "0x47", "0x2d", "0x2e", "0x6d", "0x8d", "0xec", "0xae", "0xbd", "0x5c", "0x67", "0x93", "0x37", "0x66", "0x61", "0xd7", "0x00"}}, - { - /* No.641 delta:1651 weight:1563 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xb4fd9d64, 0xec73539a, 0x588ecefe, 0x2d802810, 0x997db574, 0xc1f37b8a, 0x750ee6ee, 0x0000d3da, 0xb4fd4ebe, 0xec738040, 0x588e1d24, 0x2d80fbca, 0x997d66ae, 0xc1f3a850, 0x750e3534}, - [16]uint32{0x00000000, 0x0d0ab813, 0x00749c0b, 0x0d7e2418, 0x004ec206, 0x0d447a15, 0x003a5e0d, 0x0d30e61e, 0x004bb01a, 0x0d410809, 0x003f2c11, 0x0d359402, 0x0005721c, 0x0d0fca0f, 0x0071ee17, 0x0d7b5604}, - [16]uint32{0x3f800000, 0x3f86855c, 0x3f803a4e, 0x3f86bf12, 0x3f802761, 0x3f86a23d, 0x3f801d2f, 0x3f869873, 0x3f8025d8, 0x3f86a084, 0x3f801f96, 0x3f869aca, 0x3f8002b9, 0x3f8687e5, 0x3f8038f7, 0x3f86bdab}, - uint32(0xfff80000), - [21]string{"0x73", "0xb5", "0x98", "0x13", "0x31", "0x72", "0x05", "0x95", "0x46", "0xd3", "0xed", "0x36", "0xc7", "0xec", "0xc3", "0xfb", "0x0d", "0x08", "0x23", "0x80", "0x00"}}, - { - /* No.642 delta:2155 weight:1317 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x21d93e20, 0x54e726bc, 0x753e189c, 0xf7502822, 0xd6891602, 0xa3b70e9e, 0x826e30be, 0x00005fc4, 0x21d961e4, 0x54e77978, 0x753e4758, 0xf75077e6, 0xd68949c6, 0xa3b7515a, 0x826e6f7a}, - [16]uint32{0x00000000, 0x0eda5135, 0x0cc2440b, 0x0218153e, 0x2480c096, 0x2a5a91a3, 0x2842849d, 0x2698d5a8, 0x5ea4a612, 0x507ef727, 0x5266e219, 0x5cbcb32c, 0x7a246684, 0x74fe37b1, 0x76e6228f, 0x783c73ba}, - [16]uint32{0x3f800000, 0x3f876d28, 0x3f866122, 0x3f810c0a, 0x3f924060, 0x3f952d48, 0x3f942142, 0x3f934c6a, 0x3faf5253, 0x3fa83f7b, 0x3fa93371, 0x3fae5e59, 0x3fbd1233, 0x3fba7f1b, 0x3fbb7311, 0x3fbc1e39}, - uint32(0xfff80000), - [21]string{"0xee", "0x5c", "0x37", "0x5e", "0xb0", "0x4a", "0x6b", "0x44", "0xd4", "0xc7", "0x6a", "0xac", "0x2b", "0xa5", "0x44", "0x49", "0x39", "0x04", "0x9b", "0x17", "0x00"}}, - { - /* No.643 delta:975 weight:1667 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0xf1e0960f, 0x045f6783, 0xf5bff18c, 0xcd502833, 0x3cb0be3c, 0xc90f4fb0, 0x38efd9bf, 0x00009e6a, 0xf1e00865, 0x045ff9e9, 0xf5bf6fe6, 0xcd50b659, 0x3cb02056, 0xc90fd1da, 0x38ef47d5}, - [16]uint32{0x00000000, 0x100cc07a, 0x40060111, 0x500ac16b, 0x2050900c, 0x305c5076, 0x6056911d, 0x705a5167, 0x00020018, 0x100ec062, 0x40040109, 0x5008c173, 0x20529014, 0x305e506e, 0x60549105, 0x7058517f}, - [16]uint32{0x3f800000, 0x3f880660, 0x3fa00300, 0x3fa80560, 0x3f902848, 0x3f982e28, 0x3fb02b48, 0x3fb82d28, 0x3f800100, 0x3f880760, 0x3fa00200, 0x3fa80460, 0x3f902948, 0x3f982f28, 0x3fb02a48, 0x3fb82c28}, - uint32(0xfff80000), - [21]string{"0x96", "0x37", "0xd1", "0xe7", "0x6f", "0x2b", "0xd4", "0x49", "0xf8", "0xff", "0x12", "0x3e", "0xf6", "0xd0", "0xd8", "0x5b", "0x3d", "0x6a", "0xd7", "0xa9", "0x00"}}, - { - /* No.644 delta:903 weight:1567 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0x4f8925e6, 0x52376c1d, 0x1dbe49fb, 0xa8d02842, 0xe7590da4, 0xfae7445f, 0xb56e61b9, 0x0000a095, 0x4f898573, 0x5237cc88, 0x1dbee96e, 0xa8d088d7, 0xe759ad31, 0xfae7e4ca, 0xb56ec12c}, - [16]uint32{0x00000000, 0x305c2915, 0x0003497f, 0x305f606a, 0x00202013, 0x307c0906, 0x0023696c, 0x307f4079, 0x10003178, 0x205c186d, 0x10037807, 0x205f5112, 0x1020116b, 0x207c387e, 0x10235814, 0x207f7101}, - [16]uint32{0x3f800000, 0x3f982e14, 0x3f8001a4, 0x3f982fb0, 0x3f801010, 0x3f983e04, 0x3f8011b4, 0x3f983fa0, 0x3f880018, 0x3f902e0c, 0x3f8801bc, 0x3f902fa8, 0x3f881008, 0x3f903e1c, 0x3f8811ac, 0x3f903fb8}, - uint32(0xfff80000), - [21]string{"0xe3", "0xec", "0xd0", "0x30", "0x6e", "0x1e", "0x46", "0xae", "0x73", "0xa6", "0xf8", "0xfc", "0xd7", "0x99", "0xe0", "0x67", "0xe0", "0x2d", "0xc8", "0x47", "0x00"}}, - { - /* No.645 delta:660 weight:1647 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x625a8fef, 0x5bb5921d, 0x39ef1df2, 0x64b02850, 0x06eaa7bf, 0x3f05ba4d, 0x5d5f35a2, 0x0000f31f, 0x625a7cf0, 0x5bb56102, 0x39efeeed, 0x64b0db4f, 0x06ea54a0, 0x3f054952, 0x5d5fc6bd}, - [16]uint32{0x00000000, 0x00441976, 0x30039014, 0x30478962, 0x0002c20e, 0x0046db78, 0x3001521a, 0x30454b6c, 0x60221261, 0x60660b17, 0x50218275, 0x50659b03, 0x6020d06f, 0x6064c919, 0x5023407b, 0x5067590d}, - [16]uint32{0x3f800000, 0x3f80220c, 0x3f9801c8, 0x3f9823c4, 0x3f800161, 0x3f80236d, 0x3f9800a9, 0x3f9822a5, 0x3fb01109, 0x3fb03305, 0x3fa810c1, 0x3fa832cd, 0x3fb01068, 0x3fb03264, 0x3fa811a0, 0x3fa833ac}, - uint32(0xfff80000), - [21]string{"0xc1", "0xa3", "0x7d", "0xf7", "0x5d", "0x61", "0x9a", "0x92", "0xc2", "0xd3", "0x05", "0x6e", "0x90", "0xdf", "0x06", "0xd1", "0x8b", "0x17", "0xcc", "0xc8", "0x00"}}, - { - /* No.646 delta:932 weight:1495 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0xc783558b, 0x053e9e10, 0xc2bdcb9b, 0xaba0286d, 0x6c237de6, 0xae9eb67d, 0x691de3f6, 0x00009934, 0xc783ccbf, 0x053e0724, 0xc2bd52af, 0xaba0b159, 0x6c23e4d2, 0xae9e2f49, 0x691d7ac2}, - [16]uint32{0x00000000, 0x000219dd, 0x30040927, 0x300610fa, 0x401c001e, 0x401e19c3, 0x70180939, 0x701a10e4, 0x2048002b, 0x204a19f6, 0x104c090c, 0x104e10d1, 0x60540035, 0x605619e8, 0x50500912, 0x505210cf}, - [16]uint32{0x3f800000, 0x3f80010c, 0x3f980204, 0x3f980308, 0x3fa00e00, 0x3fa00f0c, 0x3fb80c04, 0x3fb80d08, 0x3f902400, 0x3f90250c, 0x3f882604, 0x3f882708, 0x3fb02a00, 0x3fb02b0c, 0x3fa82804, 0x3fa82908}, - uint32(0xfff80000), - [21]string{"0xb6", "0xe6", "0xae", "0xba", "0xb1", "0xbd", "0x85", "0x3f", "0x35", "0x93", "0xd3", "0x77", "0xc4", "0xaf", "0xc4", "0x3f", "0x63", "0x88", "0x7a", "0x06", "0x00"}}, - { - /* No.647 delta:1009 weight:1587 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0xaef5cae8, 0xda0274b0, 0x74f7be58, 0x5b802872, 0xf575e29a, 0x81825cc2, 0x2f77962a, 0x0000b3f0, 0xaef57918, 0xda02c740, 0x74f70da8, 0x5b809b82, 0xf575516a, 0x8182ef32, 0x2f7725da}, - [16]uint32{0x00000000, 0x0002f95d, 0x00034012, 0x0001b94f, 0x005c0144, 0x005ef819, 0x005f4156, 0x005db80b, 0x20081168, 0x200ae835, 0x200b517a, 0x2009a827, 0x2054102c, 0x2056e971, 0x2057503e, 0x2055a963}, - [16]uint32{0x3f800000, 0x3f80017c, 0x3f8001a0, 0x3f8000dc, 0x3f802e00, 0x3f802f7c, 0x3f802fa0, 0x3f802edc, 0x3f900408, 0x3f900574, 0x3f9005a8, 0x3f9004d4, 0x3f902a08, 0x3f902b74, 0x3f902ba8, 0x3f902ad4}, - uint32(0xfff80000), - [21]string{"0x95", "0x71", "0x09", "0xed", "0xeb", "0x65", "0x00", "0x8e", "0x3b", "0x18", "0xf8", "0x93", "0x84", "0x59", "0xc4", "0x30", "0x88", "0xae", "0x07", "0x9c", "0x00"}}, - { - /* No.648 delta:989 weight:1267 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x885ac586, 0x39862d71, 0xb1dce8f7, 0x56d0288b, 0xde8aed0d, 0x6f5605fa, 0xe70cc07c, 0x00008ef1, 0x885a4b77, 0x3986a380, 0xb1dc6606, 0x56d0a67a, 0xde8a63fc, 0x6f568b0b, 0xe70c4e8d}, - [16]uint32{0x00000000, 0x31a6e852, 0x0065313c, 0x31c3d96e, 0x000471f1, 0x31a299a3, 0x006140cd, 0x31c7a89f, 0x0003915e, 0x31a5790c, 0x0066a062, 0x31c04830, 0x0007e0af, 0x31a108fd, 0x0062d193, 0x31c439c1}, - [16]uint32{0x3f800000, 0x3f98d374, 0x3f803298, 0x3f98e1ec, 0x3f800238, 0x3f98d14c, 0x3f8030a0, 0x3f98e3d4, 0x3f8001c8, 0x3f98d2bc, 0x3f803350, 0x3f98e024, 0x3f8003f0, 0x3f98d084, 0x3f803168, 0x3f98e21c}, - uint32(0xfff80000), - [21]string{"0x4e", "0x28", "0x4c", "0x03", "0x8c", "0x28", "0x0d", "0x68", "0x02", "0x09", "0xab", "0x02", "0xe9", "0xe7", "0xe0", "0xc3", "0x21", "0x8d", "0xac", "0xff", "0x00"}}, - { - /* No.649 delta:576 weight:1629 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0xc2f9536b, 0x29a16a0c, 0xeb583967, 0xc8702895, 0x0a897bfe, 0xe1d14299, 0x232811f2, 0x0000f870, 0xc2f9ab1b, 0x29a1927c, 0xeb58c117, 0xc870d0e5, 0x0a89838e, 0xe1d1bae9, 0x2328e982}, - [16]uint32{0x00000000, 0x80000413, 0x5003cbcc, 0xd003cfdf, 0x30002018, 0xb000240b, 0x6003ebd4, 0xe003efc7, 0x2002200d, 0xa002241e, 0x7001ebc1, 0xf001efd2, 0x10020015, 0x90020406, 0x4001cbd9, 0xc001cfca}, - [16]uint32{0x3f800000, 0x3fc00002, 0x3fa801e5, 0x3fe801e7, 0x3f980010, 0x3fd80012, 0x3fb001f5, 0x3ff001f7, 0x3f900110, 0x3fd00112, 0x3fb800f5, 0x3ff800f7, 0x3f880100, 0x3fc80102, 0x3fa000e5, 0x3fe000e7}, - uint32(0xfff80000), - [21]string{"0x2d", "0xff", "0x0e", "0xbc", "0x3a", "0x59", "0x06", "0x5c", "0x5c", "0xd8", "0x67", "0xc4", "0xc0", "0xbe", "0x3f", "0x92", "0xd7", "0x2b", "0x36", "0xaf", "0x00"}}, - { - /* No.650 delta:942 weight:1667 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x6ce07665, 0x165ee1ef, 0x7abe978a, 0x70f028a1, 0x1c105ec4, 0x66aec94e, 0x0a4ebf2b, 0x000061cf, 0x6ce017aa, 0x165e8020, 0x7abef645, 0x70f0496e, 0x1c103f0b, 0x66aea881, 0x0a4edee4}, - [16]uint32{0x00000000, 0x0066a016, 0x0038fc14, 0x005e5c02, 0x501c160e, 0x507ab618, 0x5024ea1a, 0x50424a0c, 0x0010b807, 0x00761811, 0x00284413, 0x004ee405, 0x500cae09, 0x506a0e1f, 0x5034521d, 0x5052f20b}, - [16]uint32{0x3f800000, 0x3f803350, 0x3f801c7e, 0x3f802f2e, 0x3fa80e0b, 0x3fa83d5b, 0x3fa81275, 0x3fa82125, 0x3f80085c, 0x3f803b0c, 0x3f801422, 0x3f802772, 0x3fa80657, 0x3fa83507, 0x3fa81a29, 0x3fa82979}, - uint32(0xfff80000), - [21]string{"0xe2", "0x43", "0x36", "0xd5", "0x2d", "0x13", "0xee", "0xbc", "0x6f", "0x79", "0x79", "0xde", "0xe3", "0xc4", "0xb0", "0x01", "0xcc", "0xc8", "0x8c", "0xf7", "0x00"}}, - { - /* No.651 delta:2187 weight:1665 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xda5afb70, 0x042345ef, 0xde79be9f, 0x4f6028b0, 0x953ad3c0, 0x4b436d5f, 0x9119962f, 0x0000b486, 0xda5a4ff6, 0x0423f169, 0xde790a19, 0x4f609c36, 0x953a6746, 0x4b43d9d9, 0x911922a9}, - [16]uint32{0x00000000, 0x4cad00d2, 0x005e8149, 0x4cf3819b, 0x0050001a, 0x4cfd00c8, 0x000e8153, 0x4ca38181, 0x00400047, 0x4ced0095, 0x001e810e, 0x4cb381dc, 0x0010005d, 0x4cbd008f, 0x004e8114, 0x4ce381c6}, - [16]uint32{0x3f800000, 0x3fa65680, 0x3f802f40, 0x3fa679c0, 0x3f802800, 0x3fa67e80, 0x3f800740, 0x3fa651c0, 0x3f802000, 0x3fa67680, 0x3f800f40, 0x3fa659c0, 0x3f800800, 0x3fa65e80, 0x3f802740, 0x3fa671c0}, - uint32(0xfff80000), - [21]string{"0xf2", "0x3d", "0x63", "0xaf", "0x71", "0x99", "0x36", "0xb4", "0x61", "0x70", "0x83", "0xf3", "0x18", "0xe4", "0x2c", "0xe5", "0x4e", "0x03", "0x14", "0x71", "0x00"}}, - { - /* No.652 delta:964 weight:1539 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0xb7d60312, 0xff1ee9fa, 0x48c8eae8, 0x887028c1, 0x3fa62bd3, 0x776ec13b, 0xc0b8c229, 0x000029b4, 0xb7d62aa6, 0xff1ec04e, 0x48c8c35c, 0x88700175, 0x3fa60267, 0x776ee88f, 0xc0b8eb9d}, - [16]uint32{0x00000000, 0x301e0036, 0x00491011, 0x30571027, 0x0003641e, 0x301d6428, 0x004a740f, 0x30547439, 0x400ce01b, 0x7012e02d, 0x4045f00a, 0x705bf03c, 0x400f8405, 0x70118433, 0x40469414, 0x70589422}, - [16]uint32{0x3f800000, 0x3f980f00, 0x3f802488, 0x3f982b88, 0x3f8001b2, 0x3f980eb2, 0x3f80253a, 0x3f982a3a, 0x3fa00670, 0x3fb80970, 0x3fa022f8, 0x3fb82df8, 0x3fa007c2, 0x3fb808c2, 0x3fa0234a, 0x3fb82c4a}, - uint32(0xfff80000), - [21]string{"0xf5", "0x91", "0x72", "0x0b", "0xa3", "0xea", "0xc7", "0x14", "0x81", "0xed", "0x6c", "0x30", "0x33", "0xc2", "0x97", "0x83", "0x7d", "0xcf", "0x05", "0x42", "0x00"}}, - { - /* No.653 delta:3098 weight:643 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xddc0adac, 0x43b11700, 0x9e71baac, 0xa22028d0, 0x7fe0857c, 0xe1913fd0, 0x3c51927c, 0x00006e8b, 0xddc0c327, 0x43b1798b, 0x9e71d427, 0xa220465b, 0x7fe0ebf7, 0xe191515b, 0x3c51fcf7}, - [16]uint32{0x00000000, 0x9000591f, 0x88204611, 0x18201f0e, 0x05282016, 0x95287909, 0x8d086607, 0x1d083f18, 0x0cd0200c, 0x9cd07913, 0x84f0661d, 0x14f03f02, 0x09f8001a, 0x99f85905, 0x81d8460b, 0x11d81f14}, - [16]uint32{0x3f800000, 0x3fc8002c, 0x3fc41023, 0x3f8c100f, 0x3f829410, 0x3fca943c, 0x3fc68433, 0x3f8e841f, 0x3f866810, 0x3fce683c, 0x3fc27833, 0x3f8a781f, 0x3f84fc00, 0x3fccfc2c, 0x3fc0ec23, 0x3f88ec0f}, - uint32(0xfff80000), - [21]string{"0xce", "0x2e", "0xc1", "0x55", "0xbb", "0x0d", "0x5b", "0x60", "0x82", "0xb4", "0x3b", "0x1f", "0x8c", "0xa4", "0xe4", "0xe6", "0x12", "0x61", "0xa8", "0x02", "0x00"}}, - { - /* No.654 delta:660 weight:1559 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x372ceb15, 0x20eeabe4, 0x17c240f1, 0x9b6028ed, 0xac4cc3f8, 0xbb8e8309, 0x8ca2681c, 0x0000a396, 0x372c4883, 0x20ee0872, 0x17c2e367, 0x9b608b7b, 0xac4c606e, 0xbb8e209f, 0x8ca2cb8a}, - [16]uint32{0x00000000, 0x180349d3, 0x5002d0cc, 0x4801991f, 0x4000f186, 0x5803b855, 0x1002214a, 0x08016899, 0x3001c01d, 0x280289ce, 0x600310d1, 0x78005902, 0x7001319b, 0x68027848, 0x2003e157, 0x3800a884}, - [16]uint32{0x3f800000, 0x3f8c01a4, 0x3fa80168, 0x3fa400cc, 0x3fa00078, 0x3fac01dc, 0x3f880110, 0x3f8400b4, 0x3f9800e0, 0x3f940144, 0x3fb00188, 0x3fbc002c, 0x3fb80098, 0x3fb4013c, 0x3f9001f0, 0x3f9c0054}, - uint32(0xfff80000), - [21]string{"0x1a", "0xac", "0xaf", "0x2f", "0x31", "0xd0", "0x9e", "0xf0", "0xdb", "0x32", "0x7a", "0xe2", "0xa0", "0x62", "0xa9", "0x42", "0x6c", "0xc9", "0x3a", "0xf4", "0x00"}}, - { - /* No.655 delta:984 weight:735 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x9f8eb19b, 0x006f0f4f, 0x9fe1bed4, 0x60f028fa, 0xff7e9961, 0x609f27b5, 0xff11962e, 0x0000f0f7, 0x9f8e416c, 0x006fffb8, 0x9fe14e23, 0x60f0d80d, 0xff7e6996, 0x609fd742, 0xff1166d9}, - [16]uint32{0x00000000, 0x002081b7, 0x400590ca, 0x4025117d, 0x21034012, 0x2123c1a5, 0x6106d0d8, 0x6126516f, 0x00481008, 0x006891bf, 0x404d80c2, 0x406d0175, 0x214b501a, 0x216bd1ad, 0x614ec0d0, 0x616e4167}, - [16]uint32{0x3f800000, 0x3f801040, 0x3fa002c8, 0x3fa01288, 0x3f9081a0, 0x3f9091e0, 0x3fb08368, 0x3fb09328, 0x3f802408, 0x3f803448, 0x3fa026c0, 0x3fa03680, 0x3f90a5a8, 0x3f90b5e8, 0x3fb0a760, 0x3fb0b720}, - uint32(0xfff80000), - [21]string{"0x30", "0xed", "0x78", "0x6c", "0x1c", "0x63", "0x46", "0xc8", "0x3c", "0x32", "0xe8", "0xf0", "0x13", "0xc4", "0x0c", "0x4b", "0x2c", "0x4a", "0xcb", "0x65", "0x00"}}, - { - /* No.656 delta:1139 weight:1193 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0xddeeaede, 0xa05f5e68, 0x7db1f0b6, 0x08002902, 0xd5ee87dc, 0xa85f776a, 0x75b1d9b4, 0x00000b50, 0xddeea58e, 0xa05f5538, 0x7db1fbe6, 0x08002252, 0xd5ee8c8c, 0xa85f7c3a, 0x75b1d2e4}, - [16]uint32{0x00000000, 0x00307875, 0xc90110d2, 0xc93168a7, 0x0041518a, 0x007129ff, 0xc9404158, 0xc970392d, 0x000cc809, 0x003cb07c, 0xc90dd8db, 0xc93da0ae, 0x004d9983, 0x007de1f6, 0xc94c8951, 0xc97cf124}, - [16]uint32{0x3f800000, 0x3f80183c, 0x3fe48088, 0x3fe498b4, 0x3f8020a8, 0x3f803894, 0x3fe4a020, 0x3fe4b81c, 0x3f800664, 0x3f801e58, 0x3fe486ec, 0x3fe49ed0, 0x3f8026cc, 0x3f803ef0, 0x3fe4a644, 0x3fe4be78}, - uint32(0xfff80000), - [21]string{"0xde", "0xd5", "0x71", "0xd5", "0xd3", "0x9c", "0x67", "0xe4", "0x79", "0xfd", "0x5d", "0xdd", "0x42", "0xaf", "0xb9", "0xeb", "0x68", "0x2f", "0x52", "0x80", "0x00"}}, - { - /* No.657 delta:905 weight:1507 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x96993115, 0xbb4b4097, 0x2dd27182, 0x0f202916, 0x99b91803, 0xb46b6981, 0x22f25894, 0x0000b8b4, 0x969989a1, 0xbb4bf823, 0x2dd2c936, 0x0f2091a2, 0x99b9a0b7, 0xb46bd135, 0x22f2e020}, - [16]uint32{0x00000000, 0x200348dd, 0x000010c6, 0x2003581b, 0x7000b035, 0x5003f8e8, 0x7000a0f3, 0x5003e82e, 0x6000883f, 0x4003c0e2, 0x600098f9, 0x4003d024, 0x1000380a, 0x300370d7, 0x100028cc, 0x30036011}, - [16]uint32{0x3f800000, 0x3f9001a4, 0x3f800008, 0x3f9001ac, 0x3fb80058, 0x3fa801fc, 0x3fb80050, 0x3fa801f4, 0x3fb00044, 0x3fa001e0, 0x3fb0004c, 0x3fa001e8, 0x3f88001c, 0x3f9801b8, 0x3f880014, 0x3f9801b0}, - uint32(0xfff80000), - [21]string{"0x65", "0xc7", "0xa1", "0x6f", "0x11", "0x9d", "0x93", "0x0d", "0xf2", "0x32", "0xc9", "0xa0", "0x27", "0x91", "0x8a", "0x29", "0xf1", "0x8f", "0x9c", "0x5f", "0x00"}}, - { - /* No.658 delta:1013 weight:1233 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x509efe05, 0x36821f44, 0x661ce141, 0xa9f0292f, 0xf96ed72a, 0x9f72366b, 0xcfecc86e, 0x00005040, 0x509eae45, 0x36824f04, 0x661cb101, 0xa9f0796f, 0xf96e876a, 0x9f72662b, 0xcfec982e}, - [16]uint32{0x00000000, 0x501f113f, 0x00001869, 0x501f0956, 0x4000c011, 0x101fd12e, 0x4000d878, 0x101fc947, 0x10303c1a, 0x402f2d25, 0x10302473, 0x402f354c, 0x5030fc0b, 0x002fed34, 0x5030e462, 0x002ff55d}, - [16]uint32{0x3f800000, 0x3fa80f88, 0x3f80000c, 0x3fa80f84, 0x3fa00060, 0x3f880fe8, 0x3fa0006c, 0x3f880fe4, 0x3f88181e, 0x3fa01796, 0x3f881812, 0x3fa0179a, 0x3fa8187e, 0x3f8017f6, 0x3fa81872, 0x3f8017fa}, - uint32(0xfff80000), - [21]string{"0x0f", "0x8f", "0x4d", "0x73", "0x21", "0x87", "0xd2", "0xc5", "0x92", "0x87", "0x30", "0x8a", "0x4e", "0xc7", "0xe2", "0x40", "0xa3", "0xd9", "0xde", "0x44", "0x00"}}, - { - /* No.659 delta:766 weight:1541 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x1de8985e, 0x622465ba, 0x7fccfde4, 0x8bf0293a, 0x9618b164, 0xe9d44c80, 0xf43cd4de, 0x00002c85, 0x1de8b4db, 0x6224493f, 0x7fccd161, 0x8bf005bf, 0x96189de1, 0xe9d46005, 0xf43cf85b}, - [16]uint32{0x00000000, 0x3027b1d7, 0x006d24b5, 0x304a9562, 0x0001c50b, 0x302674dc, 0x006ce1be, 0x304b5069, 0x20000012, 0x1027b1c5, 0x206d24a7, 0x104a9570, 0x2001c519, 0x102674ce, 0x206ce1ac, 0x104b507b}, - [16]uint32{0x3f800000, 0x3f9813d8, 0x3f803692, 0x3f98254a, 0x3f8000e2, 0x3f98133a, 0x3f803670, 0x3f9825a8, 0x3f900000, 0x3f8813d8, 0x3f903692, 0x3f88254a, 0x3f9000e2, 0x3f88133a, 0x3f903670, 0x3f8825a8}, - uint32(0xfff80000), - [21]string{"0x19", "0x49", "0xd4", "0x55", "0x84", "0x35", "0xd9", "0xd8", "0x47", "0x87", "0xf4", "0xd3", "0x8b", "0xac", "0x7d", "0x8e", "0x59", "0xf8", "0x1c", "0x97", "0x00"}}, - { - /* No.660 delta:1168 weight:1519 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0xb4156412, 0xcdb16655, 0x79a40247, 0x7cc02946, 0xc8d54d54, 0xb1714f13, 0x05642b01, 0x00001e30, 0xb4157a22, 0xcdb17865, 0x79a41c77, 0x7cc03776, 0xc8d55364, 0xb1715123, 0x05643531}, - [16]uint32{0x00000000, 0x506e89d4, 0x2041b10b, 0x702f38df, 0x004810a2, 0x50269976, 0x2009a1a9, 0x7067287d, 0xb2085803, 0xe266d1d7, 0x9249e908, 0xc22760dc, 0xb24048a1, 0xe22ec175, 0x9201f9aa, 0xc26f707e}, - [16]uint32{0x3f800000, 0x3fa83744, 0x3f9020d8, 0x3fb8179c, 0x3f802408, 0x3fa8134c, 0x3f9004d0, 0x3fb83394, 0x3fd9042c, 0x3ff13368, 0x3fc924f4, 0x3fe113b0, 0x3fd92024, 0x3ff11760, 0x3fc900fc, 0x3fe137b8}, - uint32(0xfff80000), - [21]string{"0x39", "0xed", "0x0f", "0x14", "0x6c", "0xe6", "0xa8", "0x2e", "0x15", "0x38", "0xc1", "0x5c", "0xd2", "0xef", "0x93", "0xf3", "0xfe", "0x7e", "0x53", "0x31", "0x00"}}, - { - /* No.661 delta:917 weight:1167 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x8c4f0872, 0x9593001b, 0x19dc0869, 0xd5802959, 0x59cf212b, 0x40132942, 0xcc5c2130, 0x0000e44a, 0x8c4fec38, 0x9593e451, 0x19dcec23, 0xd580cd13, 0x59cfc561, 0x4013cd08, 0xcc5cc57a}, - [16]uint32{0x00000000, 0x007e01fe, 0x00203097, 0x005e3169, 0x3003004f, 0x307d01b1, 0x302330d8, 0x305d3126, 0x20028175, 0x207c808b, 0x2022b1e2, 0x205cb01c, 0x1001813a, 0x107f80c4, 0x1021b1ad, 0x105fb053}, - [16]uint32{0x3f800000, 0x3f803f00, 0x3f801018, 0x3f802f18, 0x3f980180, 0x3f983e80, 0x3f981198, 0x3f982e98, 0x3f900140, 0x3f903e40, 0x3f901158, 0x3f902e58, 0x3f8800c0, 0x3f883fc0, 0x3f8810d8, 0x3f882fd8}, - uint32(0xfff80000), - [21]string{"0x88", "0x25", "0x1a", "0x00", "0xae", "0xf6", "0xae", "0x7b", "0x20", "0x83", "0x3a", "0x7b", "0xd5", "0x0b", "0x23", "0x81", "0x82", "0x42", "0x0b", "0x76", "0x00"}}, - { - /* No.662 delta:955 weight:1471 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0xbc2bba97, 0x62750fb7, 0xde5eb520, 0xfc102960, 0x403b93f7, 0x9e6526d7, 0x224e9c40, 0x00000e67, 0xbc2bb4f0, 0x627501d0, 0xde5ebb47, 0xfc102707, 0x403b9d90, 0x9e6528b0, 0x224e9227}, - [16]uint32{0x00000000, 0x88820612, 0x0021d95e, 0x88a3df4c, 0x01023073, 0x89803661, 0x0123e92d, 0x89a1ef3f, 0x0003801c, 0x8881860e, 0x00225942, 0x88a05f50, 0x0101b06f, 0x8983b67d, 0x01206931, 0x89a26f23}, - [16]uint32{0x3f800000, 0x3fc44103, 0x3f8010ec, 0x3fc451ef, 0x3f808118, 0x3fc4c01b, 0x3f8091f4, 0x3fc4d0f7, 0x3f8001c0, 0x3fc440c3, 0x3f80112c, 0x3fc4502f, 0x3f8080d8, 0x3fc4c1db, 0x3f809034, 0x3fc4d137}, - uint32(0xfff80000), - [21]string{"0x63", "0x09", "0x9e", "0x71", "0xa3", "0x44", "0xd4", "0x07", "0x19", "0x81", "0x02", "0x07", "0x55", "0x45", "0x71", "0x4d", "0xfb", "0x33", "0x63", "0x5a", "0x00"}}, - { - /* No.663 delta:890 weight:1707 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x1f16f5e5, 0xa734a9c3, 0xb8225c26, 0x37102979, 0x2806dc9c, 0x902480ba, 0x8f32755f, 0x00002f8b, 0x1f16da6e, 0xa7348648, 0xb82273ad, 0x371006f2, 0x2806f317, 0x9024af31, 0x8f325ad4}, - [16]uint32{0x00000000, 0x00010dba, 0x087c2195, 0x087d2c2f, 0x60168012, 0x60178da8, 0x686aa187, 0x686bac3d, 0x4000004b, 0x40010df1, 0x487c21de, 0x487d2c64, 0x20168059, 0x20178de3, 0x286aa1cc, 0x286bac76}, - [16]uint32{0x3f800000, 0x3f800086, 0x3f843e10, 0x3f843e96, 0x3fb00b40, 0x3fb00bc6, 0x3fb43550, 0x3fb435d6, 0x3fa00000, 0x3fa00086, 0x3fa43e10, 0x3fa43e96, 0x3f900b40, 0x3f900bc6, 0x3f943550, 0x3f9435d6}, - uint32(0xfff80000), - [21]string{"0x6f", "0x1e", "0x41", "0x32", "0x63", "0xd9", "0xf9", "0x94", "0x8d", "0x6d", "0x44", "0xb6", "0x9f", "0x43", "0xb1", "0x51", "0x16", "0x2d", "0x37", "0xd9", "0x00"}}, - { - /* No.664 delta:667 weight:953 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0x654dce22, 0x52a6d3bb, 0x37eb1d99, 0x6880298a, 0x0dcde7a8, 0x3a26fa31, 0x5f6b3413, 0x0000e7f9, 0x654d29db, 0x52a63442, 0x37ebfa60, 0x6880ce73, 0x0dcd0051, 0x3a261dc8, 0x5f6bd3ea}, - [16]uint32{0x00000000, 0x006e8135, 0x480701a7, 0x48698092, 0x2018241a, 0x2076a52f, 0x681f25bd, 0x6871a488, 0x004a55d1, 0x0024d4e4, 0x484d5476, 0x4823d543, 0x205271cb, 0x203cf0fe, 0x6855706c, 0x683bf159}, - [16]uint32{0x3f800000, 0x3f803740, 0x3fa40380, 0x3fa434c0, 0x3f900c12, 0x3f903b52, 0x3fb40f92, 0x3fb438d2, 0x3f80252a, 0x3f80126a, 0x3fa426aa, 0x3fa411ea, 0x3f902938, 0x3f901e78, 0x3fb42ab8, 0x3fb41df8}, - uint32(0xfff80000), - [21]string{"0x85", "0x3c", "0x97", "0x24", "0x6e", "0x85", "0xd2", "0xd6", "0x08", "0xf0", "0x79", "0x88", "0xdb", "0x11", "0xd1", "0x92", "0xb0", "0x34", "0xaf", "0xa9", "0x00"}}, - { - /* No.665 delta:889 weight:1549 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x15a89dc0, 0xdb3e289d, 0xce96b55d, 0xe660299d, 0xf3c8b45d, 0x3d5e0100, 0x28f69cc0, 0x00000834, 0x15a895f4, 0xdb3e20a9, 0xce96bd69, 0xe66021a9, 0xf3c8bc69, 0x3d5e0934, 0x28f694f4}, - [16]uint32{0x00000000, 0x3016f1de, 0x000130cd, 0x3017c113, 0x5400a711, 0x641656cf, 0x540197dc, 0x64176602, 0x7000601b, 0x401691c5, 0x700150d6, 0x4017a108, 0x2400c70a, 0x141636d4, 0x2401f7c7, 0x14170619}, - [16]uint32{0x3f800000, 0x3f980b78, 0x3f800098, 0x3f980be0, 0x3faa0053, 0x3fb20b2b, 0x3faa00cb, 0x3fb20bb3, 0x3fb80030, 0x3fa00b48, 0x3fb800a8, 0x3fa00bd0, 0x3f920063, 0x3f8a0b1b, 0x3f9200fb, 0x3f8a0b83}, - uint32(0xfff80000), - [21]string{"0xa3", "0x7f", "0x49", "0x35", "0xd4", "0xfe", "0xce", "0x04", "0x1c", "0x43", "0x24", "0x63", "0xce", "0x91", "0xbf", "0x69", "0x54", "0xd7", "0xb1", "0xf6", "0x00"}}, - { - /* No.666 delta:2284 weight:1263 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x6a113d56, 0xb7ea0d41, 0xddfb3017, 0xda4029ad, 0xb05114fb, 0x6daa24ec, 0x07bb19ba, 0x000061d0, 0x6a115c86, 0xb7ea6c91, 0xddfb51c7, 0xda40487d, 0xb051752b, 0x6daa453c, 0x07bb786a}, - [16]uint32{0x00000000, 0xc682109e, 0x670701b9, 0xa1851127, 0x0ef8420d, 0xc87a5293, 0x69ff43b4, 0xaf7d532a, 0x1220202b, 0xd4a230b5, 0x75272192, 0xb3a5310c, 0x1cd86226, 0xda5a72b8, 0x7bdf639f, 0xbd5d7301}, - [16]uint32{0x3f800000, 0x3fe34108, 0x3fb38380, 0x3fd0c288, 0x3f877c21, 0x3fe43d29, 0x3fb4ffa1, 0x3fd7bea9, 0x3f891010, 0x3fea5118, 0x3fba9390, 0x3fd9d298, 0x3f8e6c31, 0x3fed2d39, 0x3fbdefb1, 0x3fdeaeb9}, - uint32(0xfff80000), - [21]string{"0x90", "0x08", "0xd5", "0xc8", "0xe3", "0x3e", "0x63", "0xa1", "0x3d", "0x14", "0x5b", "0x05", "0x5a", "0x8f", "0xd6", "0x2d", "0x14", "0xd5", "0x16", "0xe6", "0x00"}}, - { - /* No.667 delta:2054 weight:1275 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x47a1ad9a, 0x419246d3, 0x0633eb49, 0x45f029b7, 0x0251842d, 0x04626f64, 0x43c3c2fe, 0x000025c4, 0x47a1885e, 0x41926317, 0x0633ce8d, 0x45f00c73, 0x0251a1e9, 0x04624aa0, 0x43c3e73a}, - [16]uint32{0x00000000, 0x1c034276, 0x12e081f1, 0x0ee3c387, 0x2c509004, 0x3053d272, 0x3eb011f5, 0x22b35383, 0xc810001e, 0xd4134268, 0xdaf081ef, 0xc6f3c399, 0xe440901a, 0xf843d26c, 0xf6a011eb, 0xeaa3539d}, - [16]uint32{0x3f800000, 0x3f8e01a1, 0x3f897040, 0x3f8771e1, 0x3f962848, 0x3f9829e9, 0x3f9f5808, 0x3f9159a9, 0x3fe40800, 0x3fea09a1, 0x3fed7840, 0x3fe379e1, 0x3ff22048, 0x3ffc21e9, 0x3ffb5008, 0x3ff551a9}, - uint32(0xfff80000), - [21]string{"0x67", "0x18", "0x91", "0xb1", "0x28", "0xa9", "0x45", "0xb6", "0x69", "0x1a", "0xdb", "0xea", "0x65", "0xf2", "0x13", "0x57", "0x3c", "0xfc", "0x49", "0x49", "0x00"}}, - { - /* No.668 delta:941 weight:1633 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0x9baafc80, 0x463c2adb, 0xdd96d65b, 0x4a3029c8, 0xd19ad548, 0x0c0c0313, 0x97a6ff93, 0x0000982b, 0x9baa64ab, 0x463cb2f0, 0xdd964e70, 0x4a30b1e3, 0xd19a4d63, 0x0c0c9b38, 0x97a667b8}, - [16]uint32{0x00000000, 0x206701be, 0x4000a145, 0x6067a0fb, 0x2002301c, 0x006531a2, 0x60029159, 0x406590e7, 0x000040ef, 0x20674151, 0x4000e1aa, 0x6067e014, 0x200270f3, 0x0065714d, 0x6002d1b6, 0x4065d008}, - [16]uint32{0x3f800000, 0x3f903380, 0x3fa00050, 0x3fb033d0, 0x3f900118, 0x3f803298, 0x3fb00148, 0x3fa032c8, 0x3f800020, 0x3f9033a0, 0x3fa00070, 0x3fb033f0, 0x3f900138, 0x3f8032b8, 0x3fb00168, 0x3fa032e8}, - uint32(0xfff80000), - [21]string{"0x71", "0x9b", "0x16", "0x1e", "0x4d", "0x5f", "0x94", "0xdd", "0x57", "0x62", "0x07", "0x20", "0xda", "0x27", "0xf7", "0x26", "0xc6", "0xe1", "0x5c", "0xc3", "0x00"}}, - { - /* No.669 delta:1197 weight:1565 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0x7653274c, 0x9a0ee346, 0xec5dc40a, 0x431029de, 0x35430e92, 0xd91eca98, 0xaf4dedd4, 0x0000a6ae, 0x765381e2, 0x9a0e45e8, 0xec5d62a4, 0x43108f70, 0x3543a83c, 0xd91e6c36, 0xaf4d4b7a}, - [16]uint32{0x00000000, 0x08004135, 0x0401021c, 0x0c014329, 0x01000307, 0x09004232, 0x0501011b, 0x0d01402e, 0x600000ec, 0x680041d9, 0x640102f0, 0x6c0143c5, 0x610003eb, 0x690042de, 0x650101f7, 0x6d0140c2}, - [16]uint32{0x3f800000, 0x3f840020, 0x3f820081, 0x3f8600a1, 0x3f808001, 0x3f848021, 0x3f828080, 0x3f8680a0, 0x3fb00000, 0x3fb40020, 0x3fb20081, 0x3fb600a1, 0x3fb08001, 0x3fb48021, 0x3fb28080, 0x3fb680a0}, - uint32(0xfff80000), - [21]string{"0xa0", "0x20", "0xee", "0x1b", "0xe5", "0x22", "0xee", "0x71", "0xdc", "0xfa", "0xaa", "0xbc", "0x75", "0xe0", "0x1b", "0x8d", "0xa7", "0x69", "0x9d", "0x44", "0x00"}}, - { - /* No.670 delta:2148 weight:1399 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x539e5b65, 0x8cf33dac, 0xdf6d66c9, 0x7fd029e8, 0x2c4e728d, 0xf3231444, 0xa0bd4f21, 0x00003083, 0x539e6be6, 0x8cf30d2f, 0xdf6d564a, 0x7fd0196b, 0x2c4e420e, 0xf32324c7, 0xa0bd7fa2}, - [16]uint32{0x00000000, 0x49912d53, 0x0c0141d9, 0x45906c8a, 0x03808814, 0x4a11a547, 0x0f81c9cd, 0x4610e49e, 0x1aa44202, 0x53356f51, 0x16a503db, 0x5f342e88, 0x1924ca16, 0x50b5e745, 0x15258bcf, 0x5cb4a69c}, - [16]uint32{0x3f800000, 0x3fa4c896, 0x3f8600a0, 0x3fa2c836, 0x3f81c044, 0x3fa508d2, 0x3f87c0e4, 0x3fa30872, 0x3f8d5221, 0x3fa99ab7, 0x3f8b5281, 0x3faf9a17, 0x3f8c9265, 0x3fa85af3, 0x3f8a92c5, 0x3fae5a53}, - uint32(0xfff80000), - [21]string{"0xa6", "0x6a", "0x76", "0x3a", "0x31", "0x11", "0x47", "0x0f", "0xce", "0x1c", "0x53", "0xdc", "0xa5", "0x33", "0x08", "0x6e", "0x53", "0xd0", "0xaa", "0x59", "0x00"}}, - { - /* No.671 delta:762 weight:1521 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x0ca76d20, 0xeb183a1f, 0xe7bf573f, 0x2a9029f3, 0x263744d3, 0xc18813ec, 0xcd2f7ecc, 0x00005eb0, 0x0ca73390, 0xeb1864af, 0xe7bf098f, 0x2a907743, 0x26371a63, 0xc1884d5c, 0xcd2f207c}, - [16]uint32{0x00000000, 0x08648995, 0x30024156, 0x3866c8c3, 0x0002812e, 0x086608bb, 0x3000c078, 0x386449ed, 0x19172819, 0x1173a18c, 0x2915694f, 0x2171e0da, 0x1915a937, 0x117120a2, 0x2917e861, 0x217361f4}, - [16]uint32{0x3f800000, 0x3f843244, 0x3f980120, 0x3f9c3364, 0x3f800140, 0x3f843304, 0x3f980060, 0x3f9c3224, 0x3f8c8b94, 0x3f88b9d0, 0x3f948ab4, 0x3f90b8f0, 0x3f8c8ad4, 0x3f88b890, 0x3f948bf4, 0x3f90b9b0}, - uint32(0xfff80000), - [21]string{"0xab", "0x20", "0xd2", "0x90", "0xbc", "0xb7", "0x07", "0xb5", "0x34", "0x98", "0xad", "0xa8", "0x28", "0x00", "0xd0", "0x90", "0xd6", "0xa8", "0x5b", "0xec", "0x00"}}, - { - /* No.672 delta:944 weight:911 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0xb427dce0, 0x2313c140, 0x97341da0, 0xc1702a08, 0x7557f6e8, 0xe263eb48, 0x564437a8, 0x00000abd, 0xb427d65d, 0x2313cbfd, 0x9734171d, 0xc17020b5, 0x7557fc55, 0xe263e1f5, 0x56443d15}, - [16]uint32{0x00000000, 0x005a4df6, 0x2024d19c, 0x207e9c6a, 0x0003e00f, 0x0059adf9, 0x20273193, 0x207d7c65, 0x2041c01d, 0x201b8deb, 0x00651181, 0x003f5c77, 0x20422012, 0x20186de4, 0x0066f18e, 0x003cbc78}, - [16]uint32{0x3f800000, 0x3f802d26, 0x3f901268, 0x3f903f4e, 0x3f8001f0, 0x3f802cd6, 0x3f901398, 0x3f903ebe, 0x3f9020e0, 0x3f900dc6, 0x3f803288, 0x3f801fae, 0x3f902110, 0x3f900c36, 0x3f803378, 0x3f801e5e}, - uint32(0xfff80000), - [21]string{"0x9b", "0x2f", "0x9c", "0xc9", "0x8f", "0x56", "0x5a", "0xd9", "0x5c", "0x62", "0x58", "0x41", "0x7b", "0x21", "0xb5", "0xaa", "0x44", "0xf6", "0x64", "0xe1", "0x00"}}, - { - /* No.673 delta:754 weight:1631 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x0a463d08, 0xd0b19a69, 0xdaf7a761, 0xcd002a15, 0xc746171d, 0x1db1b07c, 0x17f78d74, 0x000059be, 0x0a4664b6, 0xd0b1c3d7, 0xdaf7fedf, 0xcd0073ab, 0xc7464ea3, 0x1db1e9c2, 0x17f7d4ca}, - [16]uint32{0x00000000, 0x0003009e, 0x400c91af, 0x400f9131, 0x11784a1a, 0x117b4a84, 0x5174dbb5, 0x5177db2b, 0x10450013, 0x1046008d, 0x504991bc, 0x504a9122, 0x013d4a09, 0x013e4a97, 0x4131dba6, 0x4132db38}, - [16]uint32{0x3f800000, 0x3f800180, 0x3fa00648, 0x3fa007c8, 0x3f88bc25, 0x3f88bda5, 0x3fa8ba6d, 0x3fa8bbed, 0x3f882280, 0x3f882300, 0x3fa824c8, 0x3fa82548, 0x3f809ea5, 0x3f809f25, 0x3fa098ed, 0x3fa0996d}, - uint32(0xfff80000), - [21]string{"0xf2", "0xff", "0x5e", "0x68", "0xc8", "0x39", "0x73", "0x0b", "0x05", "0x36", "0x4c", "0x58", "0x1c", "0x20", "0xff", "0x3c", "0xfd", "0xd7", "0xfb", "0x2c", "0x00"}}, - { - /* No.674 delta:724 weight:1401 */ - 11213, - 64, - 13, - 4, - [16]uint32{0x00000000, 0xf01895c2, 0xbd30a31c, 0x4d2836de, 0xe4402a28, 0x1458bfea, 0x59708934, 0xa9681cf6, 0x0000ec4e, 0xf018798c, 0xbd304f52, 0x4d28da90, 0xe440c666, 0x145853a4, 0x5970657a, 0xa968f0b8}, - [16]uint32{0x00000000, 0x20424d9f, 0x0003c611, 0x20418b8e, 0x40010015, 0x60434d8a, 0x4002c604, 0x60408b9b, 0x100020d9, 0x30426d46, 0x1003e6c8, 0x3041ab57, 0x500120cc, 0x70436d53, 0x5002e6dd, 0x7040ab42}, - [16]uint32{0x3f800000, 0x3f902126, 0x3f8001e3, 0x3f9020c5, 0x3fa00080, 0x3fb021a6, 0x3fa00163, 0x3fb02045, 0x3f880010, 0x3f982136, 0x3f8801f3, 0x3f9820d5, 0x3fa80090, 0x3fb821b6, 0x3fa80173, 0x3fb82055}, - uint32(0xfff80000), - [21]string{"0x0a", "0x7c", "0xe4", "0x8f", "0xf6", "0xf2", "0x7d", "0x30", "0xf5", "0xa8", "0x68", "0xad", "0x29", "0x95", "0x29", "0x7d", "0xa3", "0xc2", "0x94", "0x3d", "0x00"}}, - { - /* No.675 delta:691 weight:1655 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x81ad5ebe, 0x591d6a96, 0xd8b03428, 0xe7a02a3d, 0x660d7483, 0xbebd40ab, 0x3f101e15, 0x0000188b, 0x81ad4635, 0x591d721d, 0xd8b02ca3, 0xe7a032b6, 0x660d6c08, 0xbebd5820, 0x3f10069e}, - [16]uint32{0x00000000, 0x240285f6, 0x000257d1, 0x2400d227, 0x1041040b, 0x344381fd, 0x104353da, 0x3441d62c, 0x80000013, 0xa40285e5, 0x800257c2, 0xa400d234, 0x90410418, 0xb44381ee, 0x904353c9, 0xb441d63f}, - [16]uint32{0x3f800000, 0x3f920142, 0x3f80012b, 0x3f920069, 0x3f882082, 0x3f9a21c0, 0x3f8821a9, 0x3f9a20eb, 0x3fc00000, 0x3fd20142, 0x3fc0012b, 0x3fd20069, 0x3fc82082, 0x3fda21c0, 0x3fc821a9, 0x3fda20eb}, - uint32(0xfff80000), - [21]string{"0x1b", "0xf3", "0xdd", "0x2d", "0xa2", "0xf5", "0x15", "0x56", "0x6c", "0x03", "0xd6", "0xd5", "0xe6", "0x9f", "0x09", "0xc9", "0xeb", "0x04", "0x1d", "0x4c", "0x00"}}, - { - /* No.676 delta:2888 weight:835 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0x27e8f1e6, 0x2b07f0c0, 0x0cef0126, 0x53d02a40, 0x7438dba6, 0x78d7da80, 0x5f3f2b66, 0x00009ac7, 0x27e86b21, 0x2b076a07, 0x0cef9be1, 0x53d0b087, 0x74384161, 0x78d74047, 0x5f3fb1a1}, - [16]uint32{0x00000000, 0x804491b5, 0x2608010e, 0xa64c90bb, 0x21414059, 0xa105d1ec, 0x07494157, 0x870dd0e2, 0x0dc50201, 0x8d8193b4, 0x2bcd030f, 0xab8992ba, 0x2c844258, 0xacc0d3ed, 0x0a8c4356, 0x8ac8d2e3}, - [16]uint32{0x3f800000, 0x3fc02248, 0x3f930400, 0x3fd32648, 0x3f90a0a0, 0x3fd082e8, 0x3f83a4a0, 0x3fc386e8, 0x3f86e281, 0x3fc6c0c9, 0x3f95e681, 0x3fd5c4c9, 0x3f964221, 0x3fd66069, 0x3f854621, 0x3fc56469}, - uint32(0xfff80000), - [21]string{"0x20", "0x55", "0x9f", "0x52", "0xcb", "0xa8", "0xf1", "0xc3", "0x40", "0xf2", "0xb5", "0xb1", "0x70", "0x33", "0xbe", "0x42", "0x35", "0x35", "0xf4", "0x86", "0x00"}}, - { - /* No.677 delta:1298 weight:1637 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0xf0dfaf34, 0xc33fdbfa, 0x33e074ce, 0xd5502a52, 0x258f8566, 0x166ff1a8, 0xe6b05e9c, 0x0000a8cc, 0xf0df07f8, 0xc33f7336, 0x33e0dc02, 0xd550829e, 0x258f2daa, 0x166f5964, 0xe6b0f650}, - [16]uint32{0x00000000, 0x205265c7, 0xc96c217e, 0xe93e44b9, 0x2401f19d, 0x0453945a, 0xed6dd0e3, 0xcd3fb524, 0x2024885c, 0x0076ed9b, 0xe948a922, 0xc91acce5, 0x042579c1, 0x24771c06, 0xcd4958bf, 0xed1b3d78}, - [16]uint32{0x3f800000, 0x3f902932, 0x3fe4b610, 0x3ff49f22, 0x3f9200f8, 0x3f8229ca, 0x3ff6b6e8, 0x3fe69fda, 0x3f901244, 0x3f803b76, 0x3ff4a454, 0x3fe48d66, 0x3f8212bc, 0x3f923b8e, 0x3fe6a4ac, 0x3ff68d9e}, - uint32(0xfff80000), - [21]string{"0x64", "0x66", "0x3c", "0xa9", "0xb6", "0x90", "0xd6", "0x98", "0x4a", "0x59", "0x3e", "0xbb", "0xc2", "0x3c", "0xdb", "0x7d", "0x16", "0x26", "0xf2", "0x8e", "0x00"}}, - { - /* No.678 delta:1656 weight:1613 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xfc93fa1c, 0x9215d5e4, 0x6e862ff8, 0xefb02a61, 0x1323d07d, 0x7da5ff85, 0x81360599, 0x0000f9ef, 0xfc9303f3, 0x92152c0b, 0x6e86d617, 0xefb0d38e, 0x13232992, 0x7da5066a, 0x8136fc76}, - [16]uint32{0x00000000, 0x0daa0f5c, 0x4242f663, 0x4fe8f93f, 0x400c580a, 0x4da65756, 0x024eae69, 0x0fe4a135, 0x1070012d, 0x1dda0e71, 0x5232f74e, 0x5f98f812, 0x507c5927, 0x5dd6567b, 0x123eaf44, 0x1f94a018}, - [16]uint32{0x3f800000, 0x3f86d507, 0x3fa1217b, 0x3fa7f47c, 0x3fa0062c, 0x3fa6d32b, 0x3f812757, 0x3f87f250, 0x3f883800, 0x3f8eed07, 0x3fa9197b, 0x3fafcc7c, 0x3fa83e2c, 0x3faeeb2b, 0x3f891f57, 0x3f8fca50}, - uint32(0xfff80000), - [21]string{"0xc7", "0x96", "0x75", "0x81", "0x05", "0xf9", "0x1f", "0x2d", "0x20", "0xed", "0x42", "0xb6", "0x7e", "0xee", "0x15", "0xff", "0x02", "0xaf", "0x37", "0x62", "0x00"}}, - { - /* No.679 delta:1225 weight:1667 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x378cf027, 0x1f2d848f, 0x28a174a8, 0x65302a75, 0x52bcda52, 0x7a1daefa, 0x4d915edd, 0x0000fbb6, 0x378c0b91, 0x1f2d7f39, 0x28a18f1e, 0x6530d1c3, 0x52bc21e4, 0x7a1d554c, 0x4d91a56b}, - [16]uint32{0x00000000, 0x006e2034, 0x00204496, 0x004e64a2, 0x5c98f0f1, 0x5cf6d0c5, 0x5cb8b467, 0x5cd69453, 0x2018413c, 0x20766108, 0x203805aa, 0x2056259e, 0x7c80b1cd, 0x7cee91f9, 0x7ca0f55b, 0x7cced56f}, - [16]uint32{0x3f800000, 0x3f803710, 0x3f801022, 0x3f802732, 0x3fae4c78, 0x3fae7b68, 0x3fae5c5a, 0x3fae6b4a, 0x3f900c20, 0x3f903b30, 0x3f901c02, 0x3f902b12, 0x3fbe4058, 0x3fbe7748, 0x3fbe507a, 0x3fbe676a}, - uint32(0xfff80000), - [21]string{"0xb5", "0xb7", "0x67", "0x73", "0xb6", "0x8e", "0xab", "0x04", "0x12", "0xea", "0x83", "0x74", "0xb2", "0x65", "0x91", "0x82", "0xe2", "0x1a", "0x28", "0x13", "0x00"}}, - { - /* No.680 delta:752 weight:1673 */ - 11213, - 75, - 13, - 4, - [16]uint32{0x00000000, 0xd9bb6a3c, 0xb144aa48, 0x68ffc074, 0x76d02a80, 0xaf6b40bc, 0xc79480c8, 0x1e2feaf4, 0x0000ceaa, 0xd9bba496, 0xb14464e2, 0x68ff0ede, 0x76d0e42a, 0xaf6b8e16, 0xc7944e62, 0x1e2f245e}, - [16]uint32{0x00000000, 0x000390b7, 0x001010c6, 0x00138071, 0x5001017c, 0x500291cb, 0x501111ba, 0x5012810d, 0x900041df, 0x9003d168, 0x90105119, 0x9013c1ae, 0xc00140a3, 0xc002d014, 0xc0115065, 0xc012c0d2}, - [16]uint32{0x3f800000, 0x3f8001c8, 0x3f800808, 0x3f8009c0, 0x3fa80080, 0x3fa80148, 0x3fa80888, 0x3fa80940, 0x3fc80020, 0x3fc801e8, 0x3fc80828, 0x3fc809e0, 0x3fe000a0, 0x3fe00168, 0x3fe008a8, 0x3fe00960}, - uint32(0xfff80000), - [21]string{"0xaa", "0x37", "0x8c", "0x9d", "0x0d", "0x3d", "0x93", "0x45", "0xbd", "0xf8", "0xbe", "0x46", "0x7f", "0x58", "0xd5", "0x06", "0x44", "0x13", "0x58", "0x1e", "0x00"}}, - { - /* No.681 delta:955 weight:1563 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0xed428b4b, 0x05612acc, 0xe823a187, 0x0d602a99, 0xe022a1d2, 0x08010055, 0xe5438b1e, 0x000021b3, 0xed42aaf8, 0x05610b7f, 0xe8238034, 0x0d600b2a, 0xe0228061, 0x080121e6, 0xe543aaad}, - [16]uint32{0x00000000, 0x413fa072, 0x004610b6, 0x4179b0c4, 0x0003d01f, 0x413c706d, 0x0045c0a9, 0x417a60db, 0x000120bc, 0x413e80ce, 0x0047300a, 0x41789078, 0x0002f0a3, 0x413d50d1, 0x0044e015, 0x417b4067}, - [16]uint32{0x3f800000, 0x3fa09fd0, 0x3f802308, 0x3fa0bcd8, 0x3f8001e8, 0x3fa09e38, 0x3f8022e0, 0x3fa0bd30, 0x3f800090, 0x3fa09f40, 0x3f802398, 0x3fa0bc48, 0x3f800178, 0x3fa09ea8, 0x3f802270, 0x3fa0bda0}, - uint32(0xfff80000), - [21]string{"0x68", "0xea", "0x31", "0xa4", "0x56", "0x04", "0x96", "0xc0", "0xc5", "0xbd", "0xd1", "0x72", "0x45", "0x87", "0x79", "0xb8", "0x58", "0xf6", "0xf9", "0x6a", "0x00"}}, - { - /* No.682 delta:790 weight:1367 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0xa4d766a7, 0x9c6bcbf0, 0x38bcad57, 0xe3902aae, 0x47474c09, 0x7ffbe15e, 0xdb2c87f9, 0x000047b5, 0xa4d72112, 0x9c6b8c45, 0x38bceae2, 0xe3906d1b, 0x47470bbc, 0x7ffba6eb, 0xdb2cc04c}, - [16]uint32{0x00000000, 0x004e9975, 0x20620083, 0x202c99f6, 0x0012b012, 0x005c2967, 0x2070b091, 0x203e29e4, 0x20091808, 0x2047817d, 0x006b188b, 0x002581fe, 0x201ba81a, 0x2055316f, 0x0079a899, 0x003731ec}, - [16]uint32{0x3f800000, 0x3f80274c, 0x3f903100, 0x3f90164c, 0x3f800958, 0x3f802e14, 0x3f903858, 0x3f901f14, 0x3f90048c, 0x3f9023c0, 0x3f80358c, 0x3f8012c0, 0x3f900dd4, 0x3f902a98, 0x3f803cd4, 0x3f801b98}, - uint32(0xfff80000), - [21]string{"0x07", "0x61", "0x29", "0xd6", "0x6d", "0x04", "0xdc", "0x6a", "0xd2", "0xa7", "0x31", "0x84", "0xac", "0x3e", "0x56", "0x58", "0x0d", "0x32", "0x2d", "0x88", "0x00"}}, - { - /* No.683 delta:1454 weight:1495 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0x9afb758b, 0xea3505c7, 0x70ce704c, 0xbb002ab0, 0x21fb5f3b, 0x51352f77, 0xcbce5afc, 0x00003d6b, 0x9afb48e0, 0xea3538ac, 0x70ce4d27, 0xbb0017db, 0x21fb6250, 0x5135121c, 0xcbce6797}, - [16]uint32{0x00000000, 0x107520de, 0x004c40ef, 0x10396031, 0x000ca188, 0x10798156, 0x0040e167, 0x1035c1b9, 0x1100801d, 0x0175a0c3, 0x114cc0f2, 0x0139e02c, 0x110c2195, 0x0179014b, 0x1140617a, 0x013541a4}, - [16]uint32{0x3f800000, 0x3f883a90, 0x3f802620, 0x3f881cb0, 0x3f800650, 0x3f883cc0, 0x3f802070, 0x3f881ae0, 0x3f888040, 0x3f80bad0, 0x3f88a660, 0x3f809cf0, 0x3f888610, 0x3f80bc80, 0x3f88a030, 0x3f809aa0}, - uint32(0xfff80000), - [21]string{"0xca", "0xd2", "0x93", "0xe4", "0x1d", "0xa3", "0x1c", "0x92", "0x46", "0x20", "0x9f", "0x5f", "0xb5", "0x70", "0x28", "0xcd", "0xfb", "0xd0", "0x11", "0x9b", "0x00"}}, - { - /* No.684 delta:802 weight:891 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0xa14df0bb, 0xdcdafd66, 0x7d970ddd, 0xab902ac8, 0x0addda73, 0x774ad7ae, 0xd6072715, 0x0000bfeb, 0xa14d4f50, 0xdcda428d, 0x7d97b236, 0xab909523, 0x0add6598, 0x774a6845, 0xd60798fe}, - [16]uint32{0x00000000, 0x63b451bb, 0x80242906, 0xe39078bd, 0x20482511, 0x43fc74aa, 0xa06c0c17, 0xc3d85dac, 0x1600417f, 0x75b410c4, 0x96246879, 0xf59039c2, 0x3648646e, 0x55fc35d5, 0xb66c4d68, 0xd5d81cd3}, - [16]uint32{0x3f800000, 0x3fb1da28, 0x3fc01214, 0x3ff1c83c, 0x3f902412, 0x3fa1fe3a, 0x3fd03606, 0x3fe1ec2e, 0x3f8b0020, 0x3fbada08, 0x3fcb1234, 0x3ffac81c, 0x3f9b2432, 0x3faafe1a, 0x3fdb3626, 0x3feaec0e}, - uint32(0xfff80000), - [21]string{"0xef", "0x08", "0x48", "0x27", "0xc2", "0x43", "0xcd", "0xa5", "0x83", "0x65", "0x18", "0xb6", "0x08", "0xb1", "0x04", "0xc9", "0x9a", "0x89", "0x14", "0xd8", "0x00"}}, - { - /* No.685 delta:1202 weight:745 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x9d32cc08, 0x7d8a0867, 0xe0b8c46f, 0xd4202ade, 0x4912e6d6, 0xa9aa22b9, 0x3498eeb1, 0x00009a9a, 0x9d325692, 0x7d8a92fd, 0xe0b85ef5, 0xd420b044, 0x49127c4c, 0xa9aab823, 0x3498742b}, - [16]uint32{0x00000000, 0x07f30f3d, 0x0042091b, 0x07b10626, 0x3030801e, 0x37c38f23, 0x30728905, 0x37818638, 0x0060600f, 0x07936f32, 0x00226914, 0x07d16629, 0x3050e011, 0x37a3ef2c, 0x3012e90a, 0x37e1e637}, - [16]uint32{0x3f800000, 0x3f83f987, 0x3f802104, 0x3f83d883, 0x3f981840, 0x3f9be1c7, 0x3f983944, 0x3f9bc0c3, 0x3f803030, 0x3f83c9b7, 0x3f801134, 0x3f83e8b3, 0x3f982870, 0x3f9bd1f7, 0x3f980974, 0x3f9bf0f3}, - uint32(0xfff80000), - [21]string{"0x97", "0x40", "0xd9", "0x81", "0x9e", "0xe9", "0x63", "0xd2", "0x63", "0x05", "0xae", "0x59", "0x1a", "0xa1", "0x0c", "0xd2", "0xa8", "0x17", "0x82", "0x23", "0x00"}}, - { - /* No.686 delta:904 weight:1673 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0xab627736, 0x32142b59, 0x99765c6f, 0xd2f02aeb, 0x79925ddd, 0xe0e401b2, 0x4b867684, 0x0000c039, 0xab62b70f, 0x3214eb60, 0x99769c56, 0xd2f0ead2, 0x79929de4, 0xe0e4c18b, 0x4b86b6bd}, - [16]uint32{0x00000000, 0x02211b32, 0x0043b267, 0x0262a955, 0xa00300fc, 0xa2221bce, 0xa040b29b, 0xa261a9a9, 0x00010546, 0x02201e74, 0x0042b721, 0x0263ac13, 0xa00205ba, 0xa2231e88, 0xa041b7dd, 0xa260acef}, - [16]uint32{0x3f800000, 0x3f81108d, 0x3f8021d9, 0x3f813154, 0x3fd00180, 0x3fd1110d, 0x3fd02059, 0x3fd130d4, 0x3f800082, 0x3f81100f, 0x3f80215b, 0x3f8131d6, 0x3fd00102, 0x3fd1118f, 0x3fd020db, 0x3fd13056}, - uint32(0xfff80000), - [21]string{"0x38", "0xfa", "0x4f", "0x2d", "0x7b", "0x44", "0x2a", "0xb4", "0x9e", "0x6e", "0x01", "0x28", "0x70", "0x80", "0xf3", "0xc6", "0xce", "0x7f", "0x20", "0x38", "0x00"}}, - { - /* No.687 delta:2186 weight:1175 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xc845fc13, 0x9a2a2643, 0x526fda50, 0xc1602af9, 0x0925d6ea, 0x5b4a0cba, 0x930ff0a9, 0x00002b90, 0xc845d783, 0x9a2a0dd3, 0x526ff1c0, 0xc1600169, 0x0925fd7a, 0x5b4a272a, 0x930fdb39}, - [16]uint32{0x00000000, 0x6832ca1a, 0x88000a0f, 0xe032c015, 0x14010258, 0x7c33c842, 0x9c010857, 0xf433c24d, 0x00601c16, 0x6852d60c, 0x88601619, 0xe052dc03, 0x14611e4e, 0x7c53d454, 0x9c611441, 0xf453de5b}, - [16]uint32{0x3f800000, 0x3fb41965, 0x3fc40005, 0x3ff01960, 0x3f8a0081, 0x3fbe19e4, 0x3fce0084, 0x3ffa19e1, 0x3f80300e, 0x3fb4296b, 0x3fc4300b, 0x3ff0296e, 0x3f8a308f, 0x3fbe29ea, 0x3fce308a, 0x3ffa29ef}, - uint32(0xfff80000), - [21]string{"0xe8", "0x72", "0x5e", "0x94", "0xe6", "0xaa", "0xb6", "0x99", "0x4e", "0x9a", "0x2d", "0x7b", "0x67", "0xd3", "0xd9", "0x27", "0x9d", "0x2b", "0xea", "0x4c", "0x00"}}, - { - /* No.688 delta:775 weight:1283 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x1143d93c, 0x70065e3b, 0x61458707, 0x6c002b02, 0x7d43f23e, 0x1c067539, 0x0d45ac05, 0x00006ed2, 0x1143b7ee, 0x700630e9, 0x6145e9d5, 0x6c0045d0, 0x7d439cec, 0x1c061beb, 0x0d45c2d7}, - [16]uint32{0x00000000, 0x007c11be, 0x00027c1c, 0x007e6da2, 0x30340809, 0x304819b7, 0x30367415, 0x304a65ab, 0x40038416, 0x407f95a8, 0x4001f80a, 0x407de9b4, 0x70378c1f, 0x704b9da1, 0x7035f003, 0x7049e1bd}, - [16]uint32{0x3f800000, 0x3f803e08, 0x3f80013e, 0x3f803f36, 0x3f981a04, 0x3f98240c, 0x3f981b3a, 0x3f982532, 0x3fa001c2, 0x3fa03fca, 0x3fa000fc, 0x3fa03ef4, 0x3fb81bc6, 0x3fb825ce, 0x3fb81af8, 0x3fb824f0}, - uint32(0xfff80000), - [21]string{"0xf0", "0x08", "0xbc", "0x82", "0x1e", "0x36", "0x45", "0xe3", "0x23", "0x4e", "0x60", "0xec", "0x0a", "0x38", "0xe9", "0xa3", "0x1b", "0xe6", "0xb9", "0x5b", "0x00"}}, - { - /* No.689 delta:932 weight:1243 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x5c9f9e47, 0xe07a90a6, 0xbce50ee1, 0x26d02b1b, 0x7a4fb55c, 0xc6aabbbd, 0x9a3525fa, 0x0000aae2, 0x5c9f34a5, 0xe07a3a44, 0xbce5a403, 0x26d081f9, 0x7a4f1fbe, 0xc6aa115f, 0x9a358f18}, - [16]uint32{0x00000000, 0x00448056, 0x003908bf, 0x007d88e9, 0x201200c3, 0x20568095, 0x202b087c, 0x206f882a, 0x20001e14, 0x20449e42, 0x203916ab, 0x207d96fd, 0x00121ed7, 0x00569e81, 0x002b1668, 0x006f963e}, - [16]uint32{0x3f800000, 0x3f802240, 0x3f801c84, 0x3f803ec4, 0x3f900900, 0x3f902b40, 0x3f901584, 0x3f9037c4, 0x3f90000f, 0x3f90224f, 0x3f901c8b, 0x3f903ecb, 0x3f80090f, 0x3f802b4f, 0x3f80158b, 0x3f8037cb}, - uint32(0xfff80000), - [21]string{"0xa7", "0x08", "0x7c", "0xd0", "0x1d", "0x5a", "0x32", "0x9e", "0xbc", "0xd4", "0x96", "0x9c", "0x4e", "0x30", "0x2a", "0x02", "0xa6", "0x8b", "0x2f", "0x33", "0x00"}}, - { - /* No.690 delta:1022 weight:1573 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0x2e8b71e9, 0x629da5de, 0x4c16d437, 0x28702b21, 0x06fb5ac8, 0x4aed8eff, 0x6466ff16, 0x00006e83, 0x2e8b1f6a, 0x629dcb5d, 0x4c16bab4, 0x287045a2, 0x06fb344b, 0x4aede07c, 0x64669195}, - [16]uint32{0x00000000, 0x400f41f6, 0x400b2cb9, 0x00046d4f, 0x3003940b, 0x700cd5fd, 0x7008b8b2, 0x3007f944, 0x3000645e, 0x700f25a8, 0x700b48e7, 0x30040911, 0x0003f055, 0x400cb1a3, 0x4008dcec, 0x00079d1a}, - [16]uint32{0x3f800000, 0x3fa007a0, 0x3fa00596, 0x3f800236, 0x3f9801ca, 0x3fb8066a, 0x3fb8045c, 0x3f9803fc, 0x3f980032, 0x3fb80792, 0x3fb805a4, 0x3f980204, 0x3f8001f8, 0x3fa00658, 0x3fa0046e, 0x3f8003ce}, - uint32(0xfff80000), - [21]string{"0x55", "0x4b", "0xa5", "0x55", "0x16", "0x56", "0x00", "0x07", "0x52", "0xab", "0xe7", "0x4a", "0x79", "0xb7", "0x71", "0xae", "0xbf", "0x09", "0xe1", "0xe3", "0x00"}}, - { - /* No.691 delta:716 weight:1417 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0xa5e14faf, 0xf40aed99, 0x51eba236, 0x54202b30, 0xf1c1649f, 0xa02ac6a9, 0x05cb8906, 0x0000550b, 0xa5e11aa4, 0xf40ab892, 0x51ebf73d, 0x54207e3b, 0xf1c13194, 0xa02a93a2, 0x05cbdc0d}, - [16]uint32{0x00000000, 0xf042189a, 0x10066011, 0xe044788b, 0x20020406, 0xd0401c9c, 0x30046417, 0xc0467c8d, 0x00400af3, 0xf0021269, 0x10466ae2, 0xe0047278, 0x20420ef5, 0xd000166f, 0x30446ee4, 0xc006767e}, - [16]uint32{0x3f800000, 0x3ff8210c, 0x3f880330, 0x3ff0223c, 0x3f900102, 0x3fe8200e, 0x3f980232, 0x3fe0233e, 0x3f802005, 0x3ff80109, 0x3f882335, 0x3ff00239, 0x3f902107, 0x3fe8000b, 0x3f982237, 0x3fe0033b}, - uint32(0xfff80000), - [21]string{"0xeb", "0x1f", "0x92", "0x14", "0x93", "0x32", "0xc6", "0xc7", "0x67", "0xa8", "0x5e", "0x73", "0x83", "0xc8", "0xa1", "0x90", "0x95", "0x78", "0x82", "0x7e", "0x00"}}, - { - /* No.692 delta:1060 weight:1233 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0xb0e29cc7, 0xf65cc601, 0x46be5ac6, 0x6a502b49, 0xdab2b78e, 0x9c0ced48, 0x2cee718f, 0x0000da6a, 0xb0e246ad, 0xf65c1c6b, 0x46be80ac, 0x6a50f123, 0xdab26de4, 0x9c0c3722, 0x2ceeabe5}, - [16]uint32{0x00000000, 0x00748d5a, 0x000201dd, 0x00768c87, 0xe01c0905, 0xe068845f, 0xe01e08d8, 0xe06a8582, 0x50080014, 0x507c8d4e, 0x500a01c9, 0x507e8c93, 0xb0140911, 0xb060844b, 0xb01608cc, 0xb0628596}, - [16]uint32{0x3f800000, 0x3f803a46, 0x3f800100, 0x3f803b46, 0x3ff00e04, 0x3ff03442, 0x3ff00f04, 0x3ff03542, 0x3fa80400, 0x3fa83e46, 0x3fa80500, 0x3fa83f46, 0x3fd80a04, 0x3fd83042, 0x3fd80b04, 0x3fd83142}, - uint32(0xfff80000), - [21]string{"0xad", "0x3d", "0x85", "0xdb", "0xec", "0x85", "0xd5", "0x0d", "0x0b", "0xbb", "0xf0", "0xf6", "0x8c", "0x35", "0xb3", "0x80", "0xcb", "0x1a", "0x65", "0x3d", "0x00"}}, - { - /* No.693 delta:1458 weight:1553 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x89028909, 0x09922e0d, 0x8090a704, 0x3e402b58, 0xb742a251, 0x37d20555, 0xbed08c5c, 0x00006f06, 0x8902e60f, 0x0992410b, 0x8090c802, 0x3e40445e, 0xb742cd57, 0x37d26a53, 0xbed0e35a}, - [16]uint32{0x00000000, 0x006e00ba, 0x00130033, 0x007d0089, 0x0271012c, 0x021f0196, 0x0262011f, 0x020c01a5, 0x2003009c, 0x206d0026, 0x201000af, 0x207e0015, 0x227201b0, 0x221c010a, 0x22610183, 0x220f0139}, - [16]uint32{0x3f800000, 0x3f803700, 0x3f800980, 0x3f803e80, 0x3f813880, 0x3f810f80, 0x3f813100, 0x3f810600, 0x3f900180, 0x3f903680, 0x3f900800, 0x3f903f00, 0x3f913900, 0x3f910e00, 0x3f913080, 0x3f910780}, - uint32(0xfff80000), - [21]string{"0x6a", "0x0e", "0xf5", "0xe4", "0x8b", "0x37", "0x53", "0xf6", "0x37", "0x13", "0x48", "0x6f", "0xdc", "0x7d", "0xdb", "0xb6", "0xd0", "0x7f", "0x2b", "0xb0", "0x00"}}, - { - /* No.694 delta:963 weight:1487 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0xaa31eed0, 0x68df0cb5, 0xc2eee265, 0xee802b61, 0x44b1c5b1, 0x865f27d4, 0x2c6ec904, 0x0000b330, 0xaa315de0, 0x68dfbf85, 0xc2ee5155, 0xee809851, 0x44b17681, 0x865f94e4, 0x2c6e7a34}, - [16]uint32{0x00000000, 0x200c7296, 0x0002585b, 0x200e2acd, 0x30002015, 0x100c5283, 0x3002784e, 0x100e0ad8, 0x000162b2, 0x200d1024, 0x00033ae9, 0x200f487f, 0x300142a7, 0x100d3031, 0x30031afc, 0x100f686a}, - [16]uint32{0x3f800000, 0x3f900639, 0x3f80012c, 0x3f900715, 0x3f980010, 0x3f880629, 0x3f98013c, 0x3f880705, 0x3f8000b1, 0x3f900688, 0x3f80019d, 0x3f9007a4, 0x3f9800a1, 0x3f880698, 0x3f98018d, 0x3f8807b4}, - uint32(0xfff80000), - [21]string{"0x21", "0xa8", "0xf9", "0xbc", "0x0c", "0x6c", "0x8a", "0xee", "0xfc", "0xf2", "0x59", "0x74", "0x50", "0xd0", "0x23", "0x18", "0xdc", "0xec", "0xf1", "0x78", "0x00"}}, - { - /* No.695 delta:1033 weight:1507 */ - 11213, - 54, - 13, - 4, - [16]uint32{0x00000000, 0xbeac6872, 0x9f74d9c6, 0x21d8b1b4, 0x4f602b7d, 0xf1cc430f, 0xd014f2bb, 0x6eb89ac9, 0x00003c37, 0xbeac5445, 0x9f74e5f1, 0x21d88d83, 0x4f60174a, 0xf1cc7f38, 0xd014ce8c, 0x6eb8a6fe}, - [16]uint32{0x00000000, 0x0003d99a, 0x600d321e, 0x600eeb84, 0x1041a203, 0x10427b99, 0x704c901d, 0x704f4987, 0x00002416, 0x0003fd8c, 0x600d1608, 0x600ecf92, 0x10418615, 0x10425f8f, 0x704cb40b, 0x704f6d91}, - [16]uint32{0x3f800000, 0x3f8001ec, 0x3fb00699, 0x3fb00775, 0x3f8820d1, 0x3f88213d, 0x3fb82648, 0x3fb827a4, 0x3f800012, 0x3f8001fe, 0x3fb0068b, 0x3fb00767, 0x3f8820c3, 0x3f88212f, 0x3fb8265a, 0x3fb827b6}, - uint32(0xfff80000), - [21]string{"0x03", "0xfe", "0xd3", "0x09", "0xa3", "0x85", "0x4f", "0xea", "0x6f", "0xf7", "0x00", "0x48", "0xfd", "0x6f", "0xfe", "0xed", "0x9f", "0x5c", "0x32", "0xca", "0x00"}}, - { - /* No.696 delta:1158 weight:1433 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x2d5d463e, 0x2180bcea, 0x0cddfad4, 0x79202b87, 0x547d6db9, 0x58a0976d, 0x75fdd153, 0x00009b81, 0x2d5dddbf, 0x2180276b, 0x0cdd6155, 0x7920b006, 0x547df638, 0x58a00cec, 0x75fd4ad2}, - [16]uint32{0x00000000, 0x3084731e, 0x00026803, 0x30861b1d, 0x20140a0a, 0x10907914, 0x20166209, 0x10921117, 0x0003deb6, 0x3087ada8, 0x0001b6b5, 0x3085c5ab, 0x2017d4bc, 0x1093a7a2, 0x2015bcbf, 0x1091cfa1}, - [16]uint32{0x3f800000, 0x3f984239, 0x3f800134, 0x3f98430d, 0x3f900a05, 0x3f88483c, 0x3f900b31, 0x3f884908, 0x3f8001ef, 0x3f9843d6, 0x3f8000db, 0x3f9842e2, 0x3f900bea, 0x3f8849d3, 0x3f900ade, 0x3f8848e7}, - uint32(0xfff80000), - [21]string{"0xca", "0x95", "0x82", "0x4b", "0x34", "0xf2", "0x37", "0x66", "0x84", "0x94", "0x93", "0x26", "0xfa", "0xd0", "0xe1", "0x3e", "0xb2", "0xaf", "0x59", "0x1e", "0x00"}}, - { - /* No.697 delta:721 weight:1497 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0xa00e95c3, 0x5abe067b, 0xfab093b8, 0xf5502b95, 0x555ebe56, 0xafee2dee, 0x0fe0b82d, 0x0000be37, 0xa00e2bf4, 0x5abeb84c, 0xfab02d8f, 0xf55095a2, 0x555e0061, 0xafee93d9, 0x0fe0061a}, - [16]uint32{0x00000000, 0x204cacf5, 0x005e6413, 0x2012c8e6, 0x002ca81e, 0x206004eb, 0x0072cc0d, 0x203e60f8, 0x0003280a, 0x204f84ff, 0x005d4c19, 0x2011e0ec, 0x002f8014, 0x20632ce1, 0x0071e407, 0x203d48f2}, - [16]uint32{0x3f800000, 0x3f902656, 0x3f802f32, 0x3f900964, 0x3f801654, 0x3f903002, 0x3f803966, 0x3f901f30, 0x3f800194, 0x3f9027c2, 0x3f802ea6, 0x3f9008f0, 0x3f8017c0, 0x3f903196, 0x3f8038f2, 0x3f901ea4}, - uint32(0xfff80000), - [21]string{"0xa5", "0xe9", "0x6e", "0x20", "0xc2", "0x5c", "0x26", "0xa8", "0x92", "0x5f", "0x7d", "0x41", "0xc8", "0xa8", "0x95", "0x5f", "0x5e", "0x8e", "0xe2", "0x47", "0x00"}}, - { - /* No.698 delta:689 weight:1667 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x6322d488, 0xf80be38a, 0x9b293702, 0xeeb02ba2, 0x8d92ff2a, 0x16bbc828, 0x75991ca0, 0x00004232, 0x632296ba, 0xf80ba1b8, 0x9b297530, 0xeeb06990, 0x8d92bd18, 0x16bb8a1a, 0x75995e92}, - [16]uint32{0x00000000, 0x000419dd, 0x402115e6, 0x40250c3b, 0x1400b40e, 0x1404add3, 0x5421a1e8, 0x5425b835, 0x1020b807, 0x1024a1da, 0x5001ade1, 0x5005b43c, 0x04200c09, 0x042415d4, 0x440119ef, 0x44050032}, - [16]uint32{0x3f800000, 0x3f80020c, 0x3fa0108a, 0x3fa01286, 0x3f8a005a, 0x3f8a0256, 0x3faa10d0, 0x3faa12dc, 0x3f88105c, 0x3f881250, 0x3fa800d6, 0x3fa802da, 0x3f821006, 0x3f82120a, 0x3fa2008c, 0x3fa20280}, - uint32(0xfff80000), - [21]string{"0x00", "0xa5", "0x0f", "0xa6", "0xbd", "0x0c", "0x32", "0xa3", "0x2e", "0x2c", "0x87", "0xea", "0x4c", "0x5a", "0x03", "0x93", "0xbf", "0x99", "0xcb", "0x74", "0x00"}}, - { - /* No.699 delta:1079 weight:1465 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x5434731b, 0x39cd1ea0, 0x6df96dbb, 0x45802bb9, 0x11b458a2, 0x7c4d3519, 0x28794602, 0x00001d7b, 0x54346e60, 0x39cd03db, 0x6df970c0, 0x458036c2, 0x11b445d9, 0x7c4d2862, 0x28795b79}, - [16]uint32{0x00000000, 0x485d5455, 0x4058202a, 0x0805747f, 0x006da1d8, 0x4830f58d, 0x403581f2, 0x0868d5a7, 0x00083004, 0x48556451, 0x4050102e, 0x080d447b, 0x006591dc, 0x4838c589, 0x403db1f6, 0x0860e5a3}, - [16]uint32{0x3f800000, 0x3fa42eaa, 0x3fa02c10, 0x3f8402ba, 0x3f8036d0, 0x3fa4187a, 0x3fa01ac0, 0x3f84346a, 0x3f800418, 0x3fa42ab2, 0x3fa02808, 0x3f8406a2, 0x3f8032c8, 0x3fa41c62, 0x3fa01ed8, 0x3f843072}, - uint32(0xfff80000), - [21]string{"0x89", "0x23", "0xd7", "0x03", "0x17", "0x79", "0x57", "0xbe", "0x96", "0x69", "0x86", "0x88", "0x36", "0x9f", "0x19", "0x4d", "0x7e", "0x49", "0x4b", "0x46", "0x00"}}, - { - /* No.700 delta:805 weight:1655 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x988f7805, 0x33dbcd88, 0xab54b58d, 0x7c402bcf, 0xe4cf53ca, 0x4f9be647, 0xd7149e42, 0x00006460, 0x988f1c65, 0x33dba9e8, 0xab54d1ed, 0x7c404faf, 0xe4cf37aa, 0x4f9b8227, 0xd714fa22}, - [16]uint32{0x00000000, 0x007e5995, 0x0002c1f3, 0x007c9866, 0x0001300c, 0x007f6999, 0x0003f1ff, 0x007da86a, 0x1000040d, 0x107e5d98, 0x1002c5fe, 0x107c9c6b, 0x10013401, 0x107f6d94, 0x1003f5f2, 0x107dac67}, - [16]uint32{0x3f800000, 0x3f803f2c, 0x3f800160, 0x3f803e4c, 0x3f800098, 0x3f803fb4, 0x3f8001f8, 0x3f803ed4, 0x3f880002, 0x3f883f2e, 0x3f880162, 0x3f883e4e, 0x3f88009a, 0x3f883fb6, 0x3f8801fa, 0x3f883ed6}, - uint32(0xfff80000), - [21]string{"0xf5", "0x72", "0x97", "0xba", "0x66", "0x48", "0x85", "0xa2", "0xc4", "0x32", "0xa0", "0x9c", "0xf6", "0x3d", "0x44", "0x1c", "0x63", "0x05", "0xaf", "0xa2", "0x00"}}, - { - /* No.701 delta:668 weight:1457 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x68380722, 0xeed3df88, 0x86ebd8aa, 0xdb502bdb, 0xb3682cf9, 0x3583f453, 0x5dbbf371, 0x0000f040, 0x6838f762, 0xeed32fc8, 0x86eb28ea, 0xdb50db9b, 0xb368dcb9, 0x35830413, 0x5dbb0331}, - [16]uint32{0x00000000, 0x205610cb, 0x0042841f, 0x201494d4, 0x80000191, 0xa056115a, 0x8042858e, 0xa0149545, 0x0041e85e, 0x2017f895, 0x00036c41, 0x20557c8a, 0x8041e9cf, 0xa017f904, 0x80036dd0, 0xa0557d1b}, - [16]uint32{0x3f800000, 0x3f902b08, 0x3f802142, 0x3f900a4a, 0x3fc00000, 0x3fd02b08, 0x3fc02142, 0x3fd00a4a, 0x3f8020f4, 0x3f900bfc, 0x3f8001b6, 0x3f902abe, 0x3fc020f4, 0x3fd00bfc, 0x3fc001b6, 0x3fd02abe}, - uint32(0xfff80000), - [21]string{"0x7d", "0x3c", "0x16", "0xae", "0xc7", "0xa9", "0x28", "0xfa", "0xee", "0x23", "0x6c", "0x22", "0xbe", "0x25", "0x00", "0x7f", "0xcd", "0x78", "0x74", "0x26", "0x00"}}, - { - /* No.702 delta:887 weight:1029 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0xfdc963ba, 0xb2d94898, 0x4f102b22, 0x86b02be1, 0x7b79485b, 0x34696379, 0xc9a000c3, 0x000079af, 0xfdc91a15, 0xb2d93137, 0x4f10528d, 0x86b0524e, 0x7b7931f4, 0x34691ad6, 0xc9a0796c}, - [16]uint32{0x00000000, 0x073c61de, 0x508a2111, 0x57b640cf, 0x08718295, 0x0f4de34b, 0x58fba384, 0x5fc7c25a, 0x4829001d, 0x4f1561c3, 0x18a3210c, 0x1f9f40d2, 0x40588288, 0x4764e356, 0x10d2a399, 0x17eec247}, - [16]uint32{0x3f800000, 0x3f839e30, 0x3fa84510, 0x3fabdb20, 0x3f8438c1, 0x3f87a6f1, 0x3fac7dd1, 0x3fafe3e1, 0x3fa41480, 0x3fa78ab0, 0x3f8c5190, 0x3f8fcfa0, 0x3fa02c41, 0x3fa3b271, 0x3f886951, 0x3f8bf761}, - uint32(0xfff80000), - [21]string{"0xdf", "0xc2", "0xd6", "0x13", "0x13", "0x49", "0x1a", "0x72", "0xf3", "0xaa", "0x72", "0x78", "0x6c", "0x4a", "0x4e", "0xc2", "0xbb", "0x82", "0x4b", "0x8b", "0x00"}}, - { - /* No.703 delta:901 weight:1683 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0x02a73e27, 0x9a272486, 0x98801aa1, 0x31202bfd, 0x338715da, 0xab070f7b, 0xa9a0315c, 0x00005fcb, 0x02a761ec, 0x9a277b4d, 0x9880456a, 0x31207436, 0x33874a11, 0xab0750b0, 0xa9a06e97}, - [16]uint32{0x00000000, 0x006c659f, 0x0002840a, 0x006ee195, 0x3100489c, 0x316c2d03, 0x3102cc96, 0x316ea909, 0x60049e12, 0x6068fb8d, 0x60061a18, 0x606a7f87, 0x5104d68e, 0x5168b311, 0x51065284, 0x516a371b}, - [16]uint32{0x3f800000, 0x3f803632, 0x3f800142, 0x3f803770, 0x3f988024, 0x3f98b616, 0x3f988166, 0x3f98b754, 0x3fb0024f, 0x3fb0347d, 0x3fb0030d, 0x3fb0353f, 0x3fa8826b, 0x3fa8b459, 0x3fa88329, 0x3fa8b51b}, - uint32(0xfff80000), - [21]string{"0x53", "0xba", "0x2c", "0x08", "0x90", "0xe1", "0x2b", "0x4f", "0xf2", "0xa3", "0xeb", "0xae", "0x44", "0x57", "0x3c", "0xa3", "0x45", "0x55", "0x16", "0x80", "0x00"}}, - { - /* No.704 delta:1419 weight:1587 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x090de45e, 0x0a9e0c17, 0x0393e849, 0xf1c02c07, 0xf8cdc859, 0xfb5e2010, 0xf253c44e, 0x0000569a, 0x090db2c4, 0x0a9e5a8d, 0x0393bed3, 0xf1c07a9d, 0xf8cd9ec3, 0xfb5e768a, 0xf25392d4}, - [16]uint32{0x00000000, 0x005d00fe, 0x34328105, 0x346f81fb, 0x0030808c, 0x006d8072, 0x34020189, 0x345f0177, 0x0002c0bd, 0x005fc043, 0x343041b8, 0x346d4146, 0x00324031, 0x006f40cf, 0x3400c134, 0x345dc1ca}, - [16]uint32{0x3f800000, 0x3f802e80, 0x3f9a1940, 0x3f9a37c0, 0x3f801840, 0x3f8036c0, 0x3f9a0100, 0x3f9a2f80, 0x3f800160, 0x3f802fe0, 0x3f9a1820, 0x3f9a36a0, 0x3f801920, 0x3f8037a0, 0x3f9a0060, 0x3f9a2ee0}, - uint32(0xfff80000), - [21]string{"0x5e", "0x97", "0x5a", "0x2a", "0xdb", "0x36", "0x22", "0xa5", "0x47", "0xd3", "0x1e", "0xde", "0xbd", "0x08", "0xd2", "0x81", "0x11", "0x86", "0x39", "0x64", "0x00"}}, - { - /* No.705 delta:1204 weight:1445 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x5e1277ff, 0xa9545c45, 0xf7462bba, 0x26602c19, 0x78725be6, 0x8f34705c, 0xd12607a3, 0x000065d3, 0x5e12122c, 0xa9543996, 0xf7464e69, 0x266049ca, 0x78723e35, 0x8f34158f, 0xd1266270}, - [16]uint32{0x00000000, 0x705c7572, 0x006693b1, 0x703ae6c3, 0x0002253a, 0x705e5048, 0x0064b68b, 0x7038c3f9, 0x1020840e, 0x607cf17c, 0x104617bf, 0x601a62cd, 0x1022a134, 0x607ed446, 0x10443285, 0x601847f7}, - [16]uint32{0x3f800000, 0x3fb82e3a, 0x3f803349, 0x3fb81d73, 0x3f800112, 0x3fb82f28, 0x3f80325b, 0x3fb81c61, 0x3f881042, 0x3fb03e78, 0x3f88230b, 0x3fb00d31, 0x3f881150, 0x3fb03f6a, 0x3f882219, 0x3fb00c23}, - uint32(0xfff80000), - [21]string{"0x4f", "0x86", "0x71", "0xb2", "0xd4", "0xa3", "0x83", "0x4b", "0xc0", "0x11", "0x40", "0x6f", "0xfc", "0x2e", "0xf6", "0x9e", "0xd8", "0x97", "0xb7", "0x5d", "0x00"}}, - { - /* No.706 delta:793 weight:1735 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0x31087562, 0x34d312e9, 0x05db678b, 0x8bc02c23, 0xbac85941, 0xbf133eca, 0x8e1b4ba8, 0x0000e749, 0x3108922b, 0x34d3f5a0, 0x05db80c2, 0x8bc0cb6a, 0xbac8be08, 0xbf13d983, 0x8e1bace1}, - [16]uint32{0x00000000, 0x2023005d, 0x00023026, 0x2021307b, 0x803c202f, 0xa01f2072, 0x803e1009, 0xa01d1054, 0x00101817, 0x2033184a, 0x00122831, 0x2031286c, 0x802c3838, 0xa00f3865, 0x802e081e, 0xa00d0843}, - [16]uint32{0x3f800000, 0x3f901180, 0x3f800118, 0x3f901098, 0x3fc01e10, 0x3fd00f90, 0x3fc01f08, 0x3fd00e88, 0x3f80080c, 0x3f90198c, 0x3f800914, 0x3f901894, 0x3fc0161c, 0x3fd0079c, 0x3fc01704, 0x3fd00684}, - uint32(0xfff80000), - [21]string{"0x0f", "0xd9", "0xb0", "0xfc", "0x1e", "0x00", "0x89", "0x45", "0x27", "0x5d", "0xb5", "0xf6", "0x8c", "0xbb", "0x86", "0xc3", "0x13", "0x99", "0xe6", "0x66", "0x00"}}, - { - /* No.707 delta:936 weight:1237 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0xfa2806ab, 0x81164481, 0x7b3e422a, 0xca402c3b, 0x30682a90, 0x4b5668ba, 0xb17e6e11, 0x0000a345, 0xfa28a5ee, 0x8116e7c4, 0x7b3ee16f, 0xca408f7e, 0x306889d5, 0x4b56cbff, 0xb17ecd54}, - [16]uint32{0x00000000, 0x205c107a, 0x202a0842, 0x00761838, 0x00492c74, 0x20153c0e, 0x20632436, 0x003f344c, 0x0002281b, 0x205e3861, 0x20282059, 0x00743023, 0x004b046f, 0x20171415, 0x20610c2d, 0x003d1c57}, - [16]uint32{0x3f800000, 0x3f902e08, 0x3f901504, 0x3f803b0c, 0x3f802496, 0x3f900a9e, 0x3f903192, 0x3f801f9a, 0x3f800114, 0x3f902f1c, 0x3f901410, 0x3f803a18, 0x3f802582, 0x3f900b8a, 0x3f903086, 0x3f801e8e}, - uint32(0xfff80000), - [21]string{"0x08", "0x11", "0x90", "0xc1", "0xd9", "0x41", "0xab", "0x89", "0x39", "0xed", "0xa1", "0x0a", "0x8f", "0x5b", "0xaf", "0xc8", "0x74", "0x28", "0x0e", "0x4e", "0x00"}}, - { - /* No.708 delta:709 weight:1555 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0x0354317d, 0xf05fe7b9, 0xf30bd6c4, 0x2c102c4e, 0x2f441d33, 0xdc4fcbf7, 0xdf1bfa8a, 0x0000f02d, 0x0354c150, 0xf05f1794, 0xf30b26e9, 0x2c10dc63, 0x2f44ed1e, 0xdc4f3bda, 0xdf1b0aa7}, - [16]uint32{0x00000000, 0x20661c17, 0x00419e8c, 0x2027829b, 0x000c00bf, 0x206a1ca8, 0x004d9e33, 0x202b8224, 0x4010400a, 0x60765c1d, 0x4051de86, 0x6037c291, 0x401c40b5, 0x607a5ca2, 0x405dde39, 0x603bc22e}, - [16]uint32{0x3f800000, 0x3f90330e, 0x3f8020cf, 0x3f9013c1, 0x3f800600, 0x3f90350e, 0x3f8026cf, 0x3f9015c1, 0x3fa00820, 0x3fb03b2e, 0x3fa028ef, 0x3fb01be1, 0x3fa00e20, 0x3fb03d2e, 0x3fa02eef, 0x3fb01de1}, - uint32(0xfff80000), - [21]string{"0x88", "0xab", "0x25", "0x13", "0xb4", "0x11", "0x86", "0x57", "0xc6", "0x01", "0xb8", "0x21", "0x08", "0x7c", "0x1d", "0x67", "0x80", "0xb4", "0x2c", "0xa8", "0x00"}}, - { - /* No.709 delta:671 weight:1423 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0x1a428927, 0x5ceae995, 0x46a860b2, 0x07602c50, 0x1d22a577, 0x5b8ac5c5, 0x41c84ce2, 0x0000b850, 0x1a423177, 0x5cea51c5, 0x46a8d8e2, 0x07609400, 0x1d221d27, 0x5b8a7d95, 0x41c8f4b2}, - [16]uint32{0x00000000, 0x100640d2, 0x10038adb, 0x0005ca09, 0x300020f6, 0x20066024, 0x2003aa2d, 0x3005eaff, 0x70000211, 0x600642c3, 0x600388ca, 0x7005c818, 0x400022e7, 0x50066235, 0x5003a83c, 0x4005e8ee}, - [16]uint32{0x3f800000, 0x3f880320, 0x3f8801c5, 0x3f8002e5, 0x3f980010, 0x3f900330, 0x3f9001d5, 0x3f9802f5, 0x3fb80001, 0x3fb00321, 0x3fb001c4, 0x3fb802e4, 0x3fa00011, 0x3fa80331, 0x3fa801d4, 0x3fa002f4}, - uint32(0xfff80000), - [21]string{"0x9e", "0xff", "0x79", "0xe9", "0x97", "0xfd", "0x27", "0xef", "0xde", "0x6c", "0x39", "0x49", "0xbf", "0x17", "0x1d", "0x63", "0xe8", "0x65", "0x29", "0xee", "0x00"}}, - { - /* No.710 delta:1669 weight:1535 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x5fdfc99f, 0x813670b6, 0xdee9b929, 0xd4802c69, 0x8b5fe5f6, 0x55b65cdf, 0x0a699540, 0x0000dc79, 0x5fdf15e6, 0x8136accf, 0xdee96550, 0xd480f010, 0x8b5f398f, 0x55b680a6, 0x0a694939}, - [16]uint32{0x00000000, 0x311082da, 0x18545d54, 0x2944df8e, 0x4030a43b, 0x712026e1, 0x5864f96f, 0x69747bb5, 0x08262409, 0x3936a6d3, 0x1072795d, 0x2162fb87, 0x48168032, 0x790602e8, 0x5042dd66, 0x61525fbc}, - [16]uint32{0x3f800000, 0x3f988841, 0x3f8c2a2e, 0x3f94a26f, 0x3fa01852, 0x3fb89013, 0x3fac327c, 0x3fb4ba3d, 0x3f841312, 0x3f9c9b53, 0x3f88393c, 0x3f90b17d, 0x3fa40b40, 0x3fbc8301, 0x3fa8216e, 0x3fb0a92f}, - uint32(0xfff80000), - [21]string{"0x74", "0xac", "0xd3", "0x5b", "0x58", "0x5f", "0xfd", "0x6f", "0x7b", "0xd4", "0x41", "0x62", "0x28", "0x03", "0x54", "0xee", "0x42", "0x27", "0xf7", "0x66", "0x00"}}, - { - /* No.711 delta:898 weight:1533 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x847b10ed, 0xb36b738f, 0x37106362, 0x46c02c72, 0xc2bb3c9f, 0xf5ab5ffd, 0x71d04f10, 0x00009b57, 0x847b8bba, 0xb36be8d8, 0x3710f835, 0x46c0b725, 0xc2bba7c8, 0xf5abc4aa, 0x71d0d447}, - [16]uint32{0x00000000, 0x007c41da, 0x4000106d, 0x407c51b7, 0x1043a4a9, 0x103fe573, 0x5043b4c4, 0x503ff51e, 0x0003c411, 0x007f85cb, 0x4003d47c, 0x407f95a6, 0x104060b8, 0x103c2162, 0x504070d5, 0x503c310f}, - [16]uint32{0x3f800000, 0x3f803e20, 0x3fa00008, 0x3fa03e28, 0x3f8821d2, 0x3f881ff2, 0x3fa821da, 0x3fa81ffa, 0x3f8001e2, 0x3f803fc2, 0x3fa001ea, 0x3fa03fca, 0x3f882030, 0x3f881e10, 0x3fa82038, 0x3fa81e18}, - uint32(0xfff80000), - [21]string{"0x9b", "0x56", "0xcc", "0x7a", "0xc8", "0x35", "0x62", "0xc0", "0xa8", "0x27", "0xfa", "0xc5", "0x59", "0xb9", "0x88", "0x4e", "0x69", "0x60", "0x9e", "0x69", "0x00"}}, - { - /* No.712 delta:1056 weight:1405 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x76cd7a5b, 0x3a968880, 0x4c5bf2db, 0xe7b02c83, 0x917d56d8, 0xdd26a403, 0xabebde58, 0x0000d01b, 0x76cdaa40, 0x3a96589b, 0x4c5b22c0, 0xe7b0fc98, 0x917d86c3, 0xdd267418, 0xabeb0e43}, - [16]uint32{0x00000000, 0x046d217e, 0x401f21d4, 0x447200aa, 0x000211f2, 0x046f308c, 0x401d3026, 0x44701158, 0x10501015, 0x143d316b, 0x504f31c1, 0x542210bf, 0x105201e7, 0x143f2099, 0x504d2033, 0x5420014d}, - [16]uint32{0x3f800000, 0x3f823690, 0x3fa00f90, 0x3fa23900, 0x3f800108, 0x3f823798, 0x3fa00e98, 0x3fa23808, 0x3f882808, 0x3f8a1e98, 0x3fa82798, 0x3faa1108, 0x3f882900, 0x3f8a1f90, 0x3fa82690, 0x3faa1000}, - uint32(0xfff80000), - [21]string{"0xc2", "0xa1", "0x44", "0xd6", "0x10", "0x9a", "0x3e", "0x53", "0x8e", "0x42", "0x06", "0x0b", "0xef", "0x18", "0xf2", "0x33", "0x96", "0x04", "0x95", "0xba", "0x00"}}, - { - /* No.713 delta:1692 weight:1621 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xf6f7da68, 0x5a1ee0bf, 0xace93ad7, 0xa8702c95, 0x5e87f6fd, 0xf26ecc2a, 0x04991642, 0x0000d0ab, 0xf6f70ac3, 0x5a1e3014, 0xace9ea7c, 0xa870fc3e, 0x5e872656, 0xf26e1c81, 0x0499c6e9}, - [16]uint32{0x00000000, 0x647641b7, 0x000201e6, 0x64744051, 0x2008015a, 0x447e40ed, 0x200a00bc, 0x447c410b, 0x000100c2, 0x64774175, 0x00030124, 0x64754093, 0x20090198, 0x447f402f, 0x200b007e, 0x447d41c9}, - [16]uint32{0x3f800000, 0x3fb23b20, 0x3f800100, 0x3fb23a20, 0x3f900400, 0x3fa23f20, 0x3f900500, 0x3fa23e20, 0x3f800080, 0x3fb23ba0, 0x3f800180, 0x3fb23aa0, 0x3f900480, 0x3fa23fa0, 0x3f900580, 0x3fa23ea0}, - uint32(0xfff80000), - [21]string{"0x2f", "0x0c", "0xb2", "0xfa", "0xd2", "0x5c", "0x6f", "0xe7", "0x76", "0x83", "0xc4", "0x7b", "0xd6", "0x98", "0x7e", "0xc8", "0x9f", "0x48", "0x4f", "0x42", "0x00"}}, - { - /* No.714 delta:779 weight:1605 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xe62f42c5, 0x1428fce7, 0xf207be22, 0xe4e02ca7, 0x02cf6e62, 0xf0c8d040, 0x16e79285, 0x0000c353, 0xe62f8196, 0x14283fb4, 0xf2077d71, 0xe4e0eff4, 0x02cfad31, 0xf0c81313, 0x16e751d6}, - [16]uint32{0x00000000, 0x2005c0b2, 0x0003007e, 0x2006c0cc, 0x10101811, 0x3015d8a3, 0x1013186f, 0x3016d8dd, 0x0040d409, 0x204514bb, 0x0043d477, 0x204614c5, 0x1050cc18, 0x30550caa, 0x1053cc66, 0x30560cd4}, - [16]uint32{0x3f800000, 0x3f9002e0, 0x3f800180, 0x3f900360, 0x3f88080c, 0x3f980aec, 0x3f88098c, 0x3f980b6c, 0x3f80206a, 0x3f90228a, 0x3f8021ea, 0x3f90230a, 0x3f882866, 0x3f982a86, 0x3f8829e6, 0x3f982b06}, - uint32(0xfff80000), - [21]string{"0x14", "0xf0", "0x00", "0x03", "0x12", "0x65", "0xd6", "0xa0", "0x2a", "0x29", "0x89", "0x16", "0xaf", "0xe1", "0x98", "0x21", "0xa7", "0xba", "0x73", "0x40", "0x00"}}, - { - /* No.715 delta:2154 weight:1395 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xfe7db2af, 0x52a648d9, 0xacdbfa76, 0x7bd02cbc, 0x85ad9e13, 0x29766465, 0xd70bd6ca, 0x00006bc2, 0xfe7dd96d, 0x52a6231b, 0xacdb91b4, 0x7bd0477e, 0x85adf5d1, 0x29760fa7, 0xd70bbd08}, - [16]uint32{0x00000000, 0x1ac0ac96, 0x528874ef, 0x4848d879, 0x089c4212, 0x125cee84, 0x5a1436fd, 0x40d49a6b, 0x90680015, 0x8aa8ac83, 0xc2e074fa, 0xd820d86c, 0x98f44207, 0x8234ee91, 0xca7c36e8, 0xd0bc9a7e}, - [16]uint32{0x3f800000, 0x3f8d6056, 0x3fa9443a, 0x3fa4246c, 0x3f844e21, 0x3f892e77, 0x3fad0a1b, 0x3fa06a4d, 0x3fc83400, 0x3fc55456, 0x3fe1703a, 0x3fec106c, 0x3fcc7a21, 0x3fc11a77, 0x3fe53e1b, 0x3fe85e4d}, - uint32(0xfff80000), - [21]string{"0x3f", "0x51", "0xd0", "0x6e", "0x1f", "0xf0", "0xb7", "0x2b", "0x01", "0x11", "0xd1", "0x7e", "0x50", "0x28", "0x42", "0x84", "0xbc", "0xf7", "0x57", "0x30", "0x00"}}, - { - /* No.716 delta:1054 weight:1583 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xafbe3c4c, 0xbfeb6190, 0x10555ddc, 0xfe302cce, 0x518e1082, 0x41db4d5e, 0xee657112, 0x0000e99b, 0xafbed5d7, 0xbfeb880b, 0x1055b447, 0xfe30c555, 0x518ef919, 0x41dba4c5, 0xee659889}, - [16]uint32{0x00000000, 0x4004781c, 0x80035399, 0xc0072b85, 0x20024016, 0x6006380a, 0xa001138f, 0xe0056b93, 0x20012103, 0x6005591f, 0xa002729a, 0xe0060a86, 0x00036115, 0x40071909, 0x8000328c, 0xc0044a90}, - [16]uint32{0x3f800000, 0x3fa0023c, 0x3fc001a9, 0x3fe00395, 0x3f900120, 0x3fb0031c, 0x3fd00089, 0x3ff002b5, 0x3f900090, 0x3fb002ac, 0x3fd00139, 0x3ff00305, 0x3f8001b0, 0x3fa0038c, 0x3fc00019, 0x3fe00225}, - uint32(0xfff80000), - [21]string{"0xed", "0x74", "0x8b", "0xb0", "0x4e", "0xc2", "0x0a", "0x82", "0x8d", "0x6f", "0x44", "0x09", "0x04", "0x9d", "0x89", "0xa6", "0x97", "0x1b", "0x37", "0xec", "0x00"}}, - { - /* No.717 delta:1418 weight:1007 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x3c23cb1d, 0x69b35404, 0x55909f19, 0xade02cda, 0x91c3e7c7, 0xc45378de, 0xf870b3c3, 0x0000292f, 0x3c23e232, 0x69b37d2b, 0x5590b636, 0xade005f5, 0x91c3cee8, 0xc45351f1, 0xf8709aec}, - [16]uint32{0x00000000, 0x00ac81b2, 0x1054813e, 0x10f8008c, 0x00600017, 0x00cc81a5, 0x10348129, 0x1098009b, 0x0011014a, 0x00bd80f8, 0x10458074, 0x10e901c6, 0x0071015d, 0x00dd80ef, 0x10258063, 0x108901d1}, - [16]uint32{0x3f800000, 0x3f805640, 0x3f882a40, 0x3f887c00, 0x3f803000, 0x3f806640, 0x3f881a40, 0x3f884c00, 0x3f800880, 0x3f805ec0, 0x3f8822c0, 0x3f887480, 0x3f803880, 0x3f806ec0, 0x3f8812c0, 0x3f884480}, - uint32(0xfff80000), - [21]string{"0xb7", "0x05", "0x1d", "0x4f", "0x98", "0x88", "0x8e", "0x9c", "0xae", "0x16", "0x64", "0x7c", "0x3e", "0x6c", "0x97", "0xe3", "0x0b", "0x1b", "0xa4", "0xde", "0x00"}}, - { - /* No.718 delta:820 weight:1629 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x9112c5eb, 0x969abab1, 0x07887f5a, 0xffb02cec, 0x6ea2e907, 0x692a965d, 0xf83853b6, 0x0000032f, 0x9112c6c4, 0x969ab99e, 0x07887c75, 0xffb02fc3, 0x6ea2ea28, 0x692a9572, 0xf8385099}, - [16]uint32{0x00000000, 0x400473f2, 0x1002815f, 0x5006f2ad, 0x30004015, 0x700433e7, 0x2002c14a, 0x6006b2b8, 0x00016a4e, 0x400519bc, 0x1003eb11, 0x500798e3, 0x30012a5b, 0x700559a9, 0x2003ab04, 0x6007d8f6}, - [16]uint32{0x3f800000, 0x3fa00239, 0x3f880140, 0x3fa80379, 0x3f980020, 0x3fb80219, 0x3f900160, 0x3fb00359, 0x3f8000b5, 0x3fa0028c, 0x3f8801f5, 0x3fa803cc, 0x3f980095, 0x3fb802ac, 0x3f9001d5, 0x3fb003ec}, - uint32(0xfff80000), - [21]string{"0x11", "0x9b", "0x2d", "0x90", "0x6a", "0xf0", "0xb5", "0x99", "0xb3", "0x87", "0xea", "0x84", "0xcd", "0xba", "0x5b", "0x63", "0x16", "0xab", "0x2b", "0x28", "0x00"}}, - { - /* No.719 delta:669 weight:1297 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x9c78eb92, 0xb6d3e0ee, 0x2aab0b7c, 0x1dd02cf9, 0x81a8c76b, 0xab03cc17, 0x377b2785, 0x00009201, 0x9c787993, 0xb6d372ef, 0x2aab997d, 0x1dd0bef8, 0x81a8556a, 0xab035e16, 0x377bb584}, - [16]uint32{0x00000000, 0x00424855, 0x46012276, 0x46436a23, 0x60042872, 0x60466027, 0x26050a04, 0x26474251, 0x0002858d, 0x0040cdd8, 0x4603a7fb, 0x4641efae, 0x6006adff, 0x6044e5aa, 0x26078f89, 0x2645c7dc}, - [16]uint32{0x3f800000, 0x3f802124, 0x3fa30091, 0x3fa321b5, 0x3fb00214, 0x3fb02330, 0x3f930285, 0x3f9323a1, 0x3f800142, 0x3f802066, 0x3fa301d3, 0x3fa320f7, 0x3fb00356, 0x3fb02272, 0x3f9303c7, 0x3f9322e3}, - uint32(0xfff80000), - [21]string{"0x77", "0xf5", "0x31", "0x2a", "0xb8", "0xb1", "0x26", "0x31", "0x52", "0x1a", "0x03", "0xae", "0x16", "0xbf", "0x19", "0xf4", "0x56", "0x71", "0xd8", "0x18", "0x00"}}, - { - /* No.720 delta:2860 weight:815 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0x2a128739, 0x46c0915b, 0x6cd21662, 0xcac02d0e, 0xe0d2aa37, 0x8c00bc55, 0xa6123b6c, 0x00009c35, 0x2a121b0c, 0x46c00d6e, 0x6cd28a57, 0xcac0b13b, 0xe0d23602, 0x8c002060, 0xa612a759}, - [16]uint32{0x00000000, 0x498a89ff, 0x94e0c209, 0xdd6a4bf6, 0x242688cd, 0x6dac0132, 0xb0c64ac4, 0xf94cc33b, 0x80902208, 0xc91aabf7, 0x1470e001, 0x5dfa69fe, 0xa4b6aac5, 0xed3c233a, 0x305668cc, 0x79dce133}, - [16]uint32{0x3f800000, 0x3fa4c544, 0x3fca7061, 0x3feeb525, 0x3f921344, 0x3fb6d600, 0x3fd86325, 0x3ffca661, 0x3fc04811, 0x3fe48d55, 0x3f8a3870, 0x3faefd34, 0x3fd25b55, 0x3ff69e11, 0x3f982b34, 0x3fbcee70}, - uint32(0xfff80000), - [21]string{"0xe3", "0x70", "0x35", "0xc4", "0x4d", "0x27", "0xea", "0x55", "0xe1", "0x72", "0xd8", "0x77", "0xae", "0xf9", "0x9e", "0xc8", "0xe4", "0x05", "0x0d", "0x33", "0x00"}}, - { - /* No.721 delta:1691 weight:1497 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0xe0c7a9c5, 0xb5861ea4, 0x5541b761, 0x04d02d1d, 0xe41784d8, 0xb15633b9, 0x51919a7c, 0x0000a95f, 0xe0c7009a, 0xb586b7fb, 0x55411e3e, 0x04d08442, 0xe4172d87, 0xb1569ae6, 0x51913323}, - [16]uint32{0x00000000, 0x487581bb, 0x0003014f, 0x487680f4, 0x00000111, 0x487580aa, 0x0003005e, 0x487681e5, 0x30128016, 0x786701ad, 0x30118159, 0x786400e2, 0x30128107, 0x786700bc, 0x30118048, 0x786401f3}, - [16]uint32{0x3f800000, 0x3fa43ac0, 0x3f800180, 0x3fa43b40, 0x3f800000, 0x3fa43ac0, 0x3f800180, 0x3fa43b40, 0x3f980940, 0x3fbc3380, 0x3f9808c0, 0x3fbc3200, 0x3f980940, 0x3fbc3380, 0x3f9808c0, 0x3fbc3200}, - uint32(0xfff80000), - [21]string{"0x3d", "0x2f", "0x3d", "0x73", "0x83", "0x23", "0x81", "0xa8", "0x1b", "0x84", "0x18", "0x04", "0xd6", "0xb6", "0x8d", "0x28", "0x1d", "0x88", "0x24", "0x3f", "0x00"}}, - { - /* No.722 delta:1154 weight:1387 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0xca209038, 0x73a5c6f7, 0xb98556cf, 0xd9002d2b, 0x1320bd13, 0xaaa5ebdc, 0x60857be4, 0x00009a5f, 0xca200a67, 0x73a55ca8, 0xb985cc90, 0xd900b774, 0x1320274c, 0xaaa57183, 0x6085e1bb}, - [16]uint32{0x00000000, 0x00406b96, 0x203c20fa, 0x207c4b6c, 0x20034212, 0x20432984, 0x003f62e8, 0x007f097e, 0x000304bb, 0x00436f2d, 0x203f2441, 0x207f4fd7, 0x200046a9, 0x20402d3f, 0x003c6653, 0x007c0dc5}, - [16]uint32{0x3f800000, 0x3f802035, 0x3f901e10, 0x3f903e25, 0x3f9001a1, 0x3f902194, 0x3f801fb1, 0x3f803f84, 0x3f800182, 0x3f8021b7, 0x3f901f92, 0x3f903fa7, 0x3f900023, 0x3f902016, 0x3f801e33, 0x3f803e06}, - uint32(0xfff80000), - [21]string{"0x24", "0x7f", "0x31", "0xb7", "0xd4", "0x8a", "0xfa", "0x36", "0x05", "0x16", "0xcb", "0x7e", "0xb9", "0xed", "0xf6", "0xd2", "0xe7", "0xcc", "0x3f", "0xc9", "0x00"}}, - { - /* No.723 delta:836 weight:1099 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x8f8a6d9c, 0xf0241420, 0x7fae79bc, 0xe5302d3f, 0x6aba40a3, 0x1514391f, 0x9a9e5483, 0x00006eb0, 0x8f8a032c, 0xf0247a90, 0x7fae170c, 0xe530438f, 0x6aba2e13, 0x151457af, 0x9a9e3a33}, - [16]uint32{0x00000000, 0x0803c416, 0x7003e19b, 0x7800258d, 0x2021024e, 0x2822c658, 0x5022e3d5, 0x582127c3, 0x70001324, 0x7803d732, 0x0003f2bf, 0x080036a9, 0x5021116a, 0x5822d57c, 0x2022f0f1, 0x282134e7}, - [16]uint32{0x3f800000, 0x3f8401e2, 0x3fb801f0, 0x3fbc0012, 0x3f901081, 0x3f941163, 0x3fa81171, 0x3fac1093, 0x3fb80009, 0x3fbc01eb, 0x3f8001f9, 0x3f84001b, 0x3fa81088, 0x3fac116a, 0x3f901178, 0x3f94109a}, - uint32(0xfff80000), - [21]string{"0x2b", "0xec", "0x0b", "0x9a", "0xca", "0xbd", "0x0d", "0x5d", "0xb6", "0x58", "0x00", "0xb4", "0x2d", "0xfc", "0x55", "0x43", "0xb4", "0x4d", "0xbb", "0xee", "0x00"}}, - { - /* No.724 delta:857 weight:1705 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0xf02ccf1e, 0x34ba0cac, 0xc496c3b2, 0xded02d40, 0x2efce25e, 0xea6a21ec, 0x1a46eef2, 0x000099b4, 0xf02c56aa, 0x34ba9518, 0xc4965a06, 0xded0b4f4, 0x2efc7bea, 0xea6ab858, 0x1a467746}, - [16]uint32{0x00000000, 0x2000203b, 0x1000f069, 0x3000d052, 0x020140f5, 0x220160ce, 0x1201b09c, 0x320190a7, 0x4046815e, 0x6046a165, 0x50467137, 0x7046510c, 0x4247c1ab, 0x6247e190, 0x524731c2, 0x724711f9}, - [16]uint32{0x3f800000, 0x3f900010, 0x3f880078, 0x3f980068, 0x3f8100a0, 0x3f9100b0, 0x3f8900d8, 0x3f9900c8, 0x3fa02340, 0x3fb02350, 0x3fa82338, 0x3fb82328, 0x3fa123e0, 0x3fb123f0, 0x3fa92398, 0x3fb92388}, - uint32(0xfff80000), - [21]string{"0x28", "0x73", "0x99", "0x4b", "0xde", "0x9b", "0xb6", "0xb5", "0x7e", "0x65", "0xf8", "0x6f", "0x75", "0xc9", "0x01", "0x0d", "0x9d", "0x56", "0x10", "0xa4", "0x00"}}, - { - /* No.725 delta:1512 weight:1635 */ - 11213, - 15, - 13, - 4, - [16]uint32{0x00000000, 0x6db36d1f, 0x504286cf, 0x3df1ebd0, 0x88c02d58, 0xe5734047, 0xd882ab97, 0xb531c688, 0x00002e4d, 0x6db34352, 0x5042a882, 0x3df1c59d, 0x88c00315, 0xe5736e0a, 0xd88285da, 0xb531e8c5}, - [16]uint32{0x00000000, 0x21b4a5f2, 0x801c046d, 0xa1a8a19f, 0x00438c39, 0x21f729cb, 0x805f8854, 0xa1eb2da6, 0x4110481c, 0x60a4edee, 0xc10c4c71, 0xe0b8e983, 0x4153c425, 0x60e761d7, 0xc14fc048, 0xe0fb65ba}, - [16]uint32{0x3f800000, 0x3f90da52, 0x3fc00e02, 0x3fd0d450, 0x3f8021c6, 0x3f90fb94, 0x3fc02fc4, 0x3fd0f596, 0x3fa08824, 0x3fb05276, 0x3fe08626, 0x3ff05c74, 0x3fa0a9e2, 0x3fb073b0, 0x3fe0a7e0, 0x3ff07db2}, - uint32(0xfff80000), - [21]string{"0x96", "0xec", "0x77", "0x29", "0xfd", "0xd0", "0x3b", "0x05", "0x39", "0x49", "0x17", "0x56", "0xd8", "0xc4", "0x71", "0x3a", "0x7f", "0x44", "0x97", "0x3c", "0x00"}}, - { - /* No.726 delta:759 weight:1721 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0xc7d4366f, 0x28c69961, 0xef12af0e, 0x79d02d6e, 0xbe041b01, 0x5116b40f, 0x96c28260, 0x00004364, 0xc7d4750b, 0x28c6da05, 0xef12ec6a, 0x79d06e0a, 0xbe045865, 0x5116f76b, 0x96c2c104}, - [16]uint32{0x00000000, 0x4c02195f, 0x40001802, 0x0c02015d, 0x50021008, 0x1c000957, 0x1002080a, 0x5c001155, 0x2011001b, 0x6c131944, 0x60111819, 0x2c130146, 0x70131013, 0x3c11094c, 0x30130811, 0x7c11114e}, - [16]uint32{0x3f800000, 0x3fa6010c, 0x3fa0000c, 0x3f860100, 0x3fa80108, 0x3f8e0004, 0x3f880104, 0x3fae0008, 0x3f900880, 0x3fb6098c, 0x3fb0088c, 0x3f960980, 0x3fb80988, 0x3f9e0884, 0x3f980984, 0x3fbe0888}, - uint32(0xfff80000), - [21]string{"0x99", "0x25", "0xe3", "0x79", "0xb6", "0x96", "0xff", "0x0e", "0x9c", "0x45", "0xa9", "0xab", "0x0e", "0x11", "0x40", "0x68", "0x75", "0xc5", "0x85", "0xb1", "0x00"}}, - { - /* No.727 delta:592 weight:1695 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0x362c9c20, 0x77692b6a, 0x4145b74a, 0x36f02d7f, 0x00dcb15f, 0x41990615, 0x77b59a35, 0x000028de, 0x362cb4fe, 0x776903b4, 0x41459f94, 0x36f005a1, 0x00dc9981, 0x41992ecb, 0x77b5b2eb}, - [16]uint32{0x00000000, 0x6002d8fa, 0x0100300d, 0x6102e8f7, 0xe1008019, 0x810258e3, 0xe000b014, 0x800268ee, 0x50038412, 0x30015ce8, 0x5103b41f, 0x31016ce5, 0xb103040b, 0xd101dcf1, 0xb0033406, 0xd001ecfc}, - [16]uint32{0x3f800000, 0x3fb0016c, 0x3f808018, 0x3fb08174, 0x3ff08040, 0x3fc0812c, 0x3ff00058, 0x3fc00134, 0x3fa801c2, 0x3f9800ae, 0x3fa881da, 0x3f9880b6, 0x3fd88182, 0x3fe880ee, 0x3fd8019a, 0x3fe800f6}, - uint32(0xfff80000), - [21]string{"0x22", "0xc6", "0x11", "0x96", "0xb7", "0x8b", "0x4d", "0x63", "0x57", "0x72", "0x66", "0x8e", "0x64", "0xc0", "0xa5", "0x18", "0xb3", "0x72", "0x41", "0x0b", "0x00"}}, - { - /* No.728 delta:922 weight:1745 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xbd4db67b, 0xea6c891a, 0x57213f61, 0xa7002d80, 0x1a4d9bfb, 0x4d6ca49a, 0xf02112e1, 0x00007d13, 0xbd4dcb68, 0xea6cf409, 0x57214272, 0xa7005093, 0x1a4de6e8, 0x4d6cd989, 0xf0216ff2}, - [16]uint32{0x00000000, 0x0813393e, 0x00038d9d, 0x0810b4a3, 0x00027386, 0x08114ab8, 0x0001fe1b, 0x0812c725, 0x8050db79, 0x8843e247, 0x805356e4, 0x88406fda, 0x8052a8ff, 0x884191c1, 0x80512562, 0x88421c5c}, - [16]uint32{0x3f800000, 0x3f84099c, 0x3f8001c6, 0x3f84085a, 0x3f800139, 0x3f8408a5, 0x3f8000ff, 0x3f840963, 0x3fc0286d, 0x3fc421f1, 0x3fc029ab, 0x3fc42037, 0x3fc02954, 0x3fc420c8, 0x3fc02892, 0x3fc4210e}, - uint32(0xfff80000), - [21]string{"0x98", "0x00", "0x4c", "0x9b", "0xd6", "0x72", "0xea", "0x9a", "0xdb", "0xb0", "0x70", "0xa0", "0xb4", "0x3c", "0x76", "0x55", "0xc4", "0xe1", "0x43", "0xa2", "0x00"}}, - { - /* No.729 delta:841 weight:1487 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0x0f9aaea3, 0xfca4ace6, 0xf33e0245, 0xed202d9b, 0xe2ba8338, 0x1184817d, 0x1e1e2fde, 0x000093ab, 0x0f9a3d08, 0xfca43f4d, 0xf33e91ee, 0xed20be30, 0xe2ba1093, 0x118412d6, 0x1e1ebc75}, - [16]uint32{0x00000000, 0xb01001fe, 0x50002144, 0xe01020ba, 0x100201e2, 0xa012001c, 0x400220a6, 0xf0122158, 0x20001811, 0x901019ef, 0x70003955, 0xc01038ab, 0x300219f3, 0x8012180d, 0x600238b7, 0xd0123949}, - [16]uint32{0x3f800000, 0x3fd80800, 0x3fa80010, 0x3ff00810, 0x3f880100, 0x3fd00900, 0x3fa00110, 0x3ff80910, 0x3f90000c, 0x3fc8080c, 0x3fb8001c, 0x3fe0081c, 0x3f98010c, 0x3fc0090c, 0x3fb0011c, 0x3fe8091c}, - uint32(0xfff80000), - [21]string{"0xe6", "0xa3", "0x9a", "0x05", "0x35", "0x58", "0xf0", "0x5a", "0xe5", "0xcc", "0x22", "0xed", "0x5a", "0x3f", "0x5c", "0xbf", "0xe1", "0x9f", "0x78", "0x4d", "0x00"}}, - { - /* No.730 delta:905 weight:743 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0xc8ebe93e, 0x7ac72e91, 0xb22cc7af, 0xc4a02da2, 0x0c4bc49c, 0xbe670333, 0x768cea0d, 0x0000ffff, 0xc8eb16c1, 0x7ac7d16e, 0xb22c3850, 0xc4a0d25d, 0x0c4b3b63, 0xbe67fccc, 0x768c15f2}, - [16]uint32{0x00000000, 0x8048043a, 0x3051599c, 0xb0195da6, 0x10140012, 0x905c0428, 0x2045598e, 0xa00d5db4, 0x8024886d, 0x006c8c57, 0xb075d1f1, 0x303dd5cb, 0x9030887f, 0x10788c45, 0xa061d1e3, 0x2029d5d9}, - [16]uint32{0x3f800000, 0x3fc02402, 0x3f9828ac, 0x3fd80cae, 0x3f880a00, 0x3fc82e02, 0x3f9022ac, 0x3fd006ae, 0x3fc01244, 0x3f803646, 0x3fd83ae8, 0x3f981eea, 0x3fc81844, 0x3f883c46, 0x3fd030e8, 0x3f9014ea}, - uint32(0xfff80000), - [21]string{"0xd5", "0xad", "0x91", "0x23", "0xb9", "0x14", "0x30", "0x2e", "0x1f", "0x13", "0x85", "0x35", "0xfe", "0x97", "0x90", "0xc7", "0x02", "0xcb", "0xfd", "0x1d", "0x00"}}, - { - /* No.731 delta:1036 weight:1413 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x0bf6c4fb, 0xdf105bcf, 0xd4e69f34, 0xed302dba, 0xe6c6e941, 0x32207675, 0x39d6b28e, 0x00007cd0, 0x0bf6b82b, 0xdf10271f, 0xd4e6e3e4, 0xed30516a, 0xe6c69591, 0x32200aa5, 0x39d6ce5e}, - [16]uint32{0x00000000, 0x402c4d5a, 0x0072c149, 0x405e8c13, 0x00029217, 0x402edf4d, 0x0070535e, 0x405c1e04, 0x6028005c, 0x20044d06, 0x605ac115, 0x20768c4f, 0x602a924b, 0x2006df11, 0x60585302, 0x20741e58}, - [16]uint32{0x3f800000, 0x3fa01626, 0x3f803960, 0x3fa02f46, 0x3f800149, 0x3fa0176f, 0x3f803829, 0x3fa02e0f, 0x3fb01400, 0x3f900226, 0x3fb02d60, 0x3f903b46, 0x3fb01549, 0x3f90036f, 0x3fb02c29, 0x3f903a0f}, - uint32(0xfff80000), - [21]string{"0x83", "0x3b", "0x97", "0xcc", "0xa0", "0xd0", "0xa8", "0x3d", "0x8f", "0xf8", "0x5f", "0xfb", "0xd6", "0x88", "0xb8", "0xfa", "0x32", "0x3d", "0xf5", "0x96", "0x00"}}, - { - /* No.732 delta:822 weight:1581 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x6553c7b0, 0xca67c2c8, 0xaf340578, 0x1df02dc2, 0x78a3ea72, 0xd797ef0a, 0xb2c428ba, 0x00009c81, 0x65535b31, 0xca675e49, 0xaf3499f9, 0x1df0b143, 0x78a376f3, 0xd797738b, 0xb2c4b43b}, - [16]uint32{0x00000000, 0x0122011e, 0x100225c3, 0x112024dd, 0x10013006, 0x11233118, 0x000315c5, 0x012114db, 0x0041801a, 0x01638104, 0x1043a5d9, 0x1161a4c7, 0x1040b01c, 0x1162b102, 0x004295df, 0x016094c1}, - [16]uint32{0x3f800000, 0x3f809100, 0x3f880112, 0x3f889012, 0x3f880098, 0x3f889198, 0x3f80018a, 0x3f80908a, 0x3f8020c0, 0x3f80b1c0, 0x3f8821d2, 0x3f88b0d2, 0x3f882058, 0x3f88b158, 0x3f80214a, 0x3f80b04a}, - uint32(0xfff80000), - [21]string{"0xb7", "0x1c", "0xd7", "0x84", "0xd3", "0x48", "0x2d", "0x54", "0xf9", "0x0b", "0x4b", "0x07", "0x1b", "0x72", "0xac", "0x2c", "0x81", "0x93", "0xe5", "0x76", "0x00"}}, - { - /* No.733 delta:1410 weight:1587 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0xc44776d8, 0xb6a8315e, 0x72ef4786, 0xb0302dda, 0x74775b02, 0x06981c84, 0xc2df6a5c, 0x00003f80, 0xc4474958, 0xb6a80ede, 0x72ef7806, 0xb030125a, 0x74776482, 0x06982304, 0xc2df55dc}, - [16]uint32{0x00000000, 0x2974c045, 0x120489b6, 0x3b7049f3, 0x007a01f8, 0x290ec1bd, 0x127e884e, 0x3b0a480b, 0x00e8421e, 0x299c825b, 0x12eccba8, 0x3b980bed, 0x009243e6, 0x29e683a3, 0x1296ca50, 0x3be20a15}, - [16]uint32{0x3f800000, 0x3f94ba60, 0x3f890244, 0x3f9db824, 0x3f803d00, 0x3f948760, 0x3f893f44, 0x3f9d8524, 0x3f807421, 0x3f94ce41, 0x3f897665, 0x3f9dcc05, 0x3f804921, 0x3f94f341, 0x3f894b65, 0x3f9df105}, - uint32(0xfff80000), - [21]string{"0xa9", "0x61", "0x59", "0x1b", "0xc9", "0xa2", "0xb9", "0x98", "0xdf", "0x17", "0x2a", "0x2b", "0x89", "0xe8", "0x96", "0x34", "0xfd", "0xcd", "0xbb", "0x42", "0x00"}}, - { - /* No.734 delta:1846 weight:1417 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0xb0e7ff5a, 0xb90cb420, 0x09eb4b7a, 0x86b02deb, 0x3657d2b1, 0x3fbc99cb, 0x8f5b6691, 0x00001060, 0xb0e7ef3a, 0xb90ca440, 0x09eb5b1a, 0x86b03d8b, 0x3657c2d1, 0x3fbc89ab, 0x8f5b76f1}, - [16]uint32{0x00000000, 0x8511e4b6, 0x407a817f, 0xc56b65c9, 0x50126a0e, 0xd5038eb8, 0x1068eb71, 0x95790fc7, 0x18096214, 0x9d1886a2, 0x5873e36b, 0xdd6207dd, 0x481b081a, 0xcd0aecac, 0x08618965, 0x8d706dd3}, - [16]uint32{0x3f800000, 0x3fc288f2, 0x3fa03d40, 0x3fe2b5b2, 0x3fa80935, 0x3fea81c7, 0x3f883475, 0x3fcabc87, 0x3f8c04b1, 0x3fce8c43, 0x3fac39f1, 0x3feeb103, 0x3fa40d84, 0x3fe68576, 0x3f8430c4, 0x3fc6b836}, - uint32(0xfff80000), - [21]string{"0xe6", "0xd1", "0x6a", "0xb3", "0xd3", "0x6a", "0x3c", "0xd4", "0x60", "0xf9", "0x71", "0x92", "0xca", "0x31", "0xeb", "0x82", "0xb9", "0xfe", "0x4f", "0xc2", "0x00"}}, - { - /* No.735 delta:2475 weight:1071 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0xadfe4796, 0xa371aa39, 0x0e8fedaf, 0x50602df5, 0xfd9e6a63, 0xf31187cc, 0x5eefc05a, 0x00000a3c, 0xadfe4daa, 0xa371a005, 0x0e8fe793, 0x506027c9, 0xfd9e605f, 0xf3118df0, 0x5eefca66}, - [16]uint32{0x00000000, 0xa743b892, 0x0931020f, 0xae72ba9d, 0x21e08814, 0x86a33086, 0x28d18a1b, 0x8f923289, 0x806a001c, 0x2729b88e, 0x895b0213, 0x2e18ba81, 0xa18a8808, 0x06c9309a, 0xa8bb8a07, 0x0ff83295}, - [16]uint32{0x3f800000, 0x3fd3a1dc, 0x3f849881, 0x3fd7395d, 0x3f90f044, 0x3fc35198, 0x3f9468c5, 0x3fc7c919, 0x3fc03500, 0x3f9394dc, 0x3fc4ad81, 0x3f970c5d, 0x3fd0c544, 0x3f836498, 0x3fd45dc5, 0x3f87fc19}, - uint32(0xfff80000), - [21]string{"0x39", "0x1d", "0x79", "0xdb", "0xb2", "0xd7", "0x5c", "0xb1", "0xf2", "0xc1", "0xb7", "0xf3", "0x36", "0x29", "0xb8", "0x43", "0x70", "0xaf", "0xd2", "0xb9", "0x00"}}, - { - /* No.736 delta:716 weight:1529 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xb985165a, 0xedf3e2ed, 0x5476f4b7, 0x82b02e05, 0x3b35385f, 0x6f43cce8, 0xd6c6dab2, 0x0000cd45, 0xb985db1f, 0xedf32fa8, 0x547639f2, 0x82b0e340, 0x3b35f51a, 0x6f4301ad, 0xd6c617f7}, - [16]uint32{0x00000000, 0x0042b41a, 0x2800c155, 0x2842754f, 0xb02006dc, 0xb062b2c6, 0x9820c789, 0x98627393, 0x4000201b, 0x40429401, 0x6800e14e, 0x68425554, 0xf02026c7, 0xf06292dd, 0xd820e792, 0xd8625388}, - [16]uint32{0x3f800000, 0x3f80215a, 0x3f940060, 0x3f94213a, 0x3fd81003, 0x3fd83159, 0x3fcc1063, 0x3fcc3139, 0x3fa00010, 0x3fa0214a, 0x3fb40070, 0x3fb4212a, 0x3ff81013, 0x3ff83149, 0x3fec1073, 0x3fec3129}, - uint32(0xfff80000), - [21]string{"0x72", "0x67", "0x24", "0x01", "0xcd", "0x16", "0x85", "0x06", "0x88", "0x93", "0x31", "0x0b", "0xcd", "0xd9", "0xc1", "0x40", "0xa4", "0xaf", "0x17", "0x16", "0x00"}}, - { - /* No.737 delta:1000 weight:1433 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x4348dab8, 0xb2c6cf40, 0xf18e15f8, 0xb7802e1b, 0xf4c8f4a3, 0x0546e15b, 0x460e3be3, 0x000057cf, 0x43488d77, 0xb2c6988f, 0xf18e4237, 0xb78079d4, 0xf4c8a36c, 0x0546b694, 0x460e6c2c}, - [16]uint32{0x00000000, 0x106040f6, 0x0054754a, 0x103435bc, 0x000360c3, 0x10632035, 0x00571589, 0x1037557f, 0x042c8078, 0x144cc08e, 0x0478f532, 0x1418b5c4, 0x042fe0bb, 0x144fa04d, 0x047b95f1, 0x141bd507}, - [16]uint32{0x3f800000, 0x3f883020, 0x3f802a3a, 0x3f881a1a, 0x3f8001b0, 0x3f883190, 0x3f802b8a, 0x3f881baa, 0x3f821640, 0x3f8a2660, 0x3f823c7a, 0x3f8a0c5a, 0x3f8217f0, 0x3f8a27d0, 0x3f823dca, 0x3f8a0dea}, - uint32(0xfff80000), - [21]string{"0x1b", "0x62", "0x03", "0xc1", "0xba", "0xe1", "0x85", "0x55", "0xb2", "0x0c", "0xf7", "0xc4", "0x92", "0xe4", "0x04", "0x94", "0x45", "0xbb", "0xaf", "0x83", "0x00"}}, - { - /* No.738 delta:1086 weight:1481 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x2668eeaa, 0x2fba33c8, 0x09d2dd62, 0x8aa02e21, 0xacc8c08b, 0xa51a1de9, 0x8372f343, 0x0000982b, 0x26687681, 0x2fbaabe3, 0x09d24549, 0x8aa0b60a, 0xacc858a0, 0xa51a85c2, 0x83726b68}, - [16]uint32{0x00000000, 0x403ced1e, 0x4051520f, 0x006dbf11, 0x20218e03, 0x601d631d, 0x6070dc0c, 0x204c3112, 0x000a61e4, 0x40368cfa, 0x405b33eb, 0x0067def5, 0x202befe7, 0x601702f9, 0x607abde8, 0x204650f6}, - [16]uint32{0x3f800000, 0x3fa01e76, 0x3fa028a9, 0x3f8036df, 0x3f9010c7, 0x3fb00eb1, 0x3fb0386e, 0x3f902618, 0x3f800530, 0x3fa01b46, 0x3fa02d99, 0x3f8033ef, 0x3f9015f7, 0x3fb00b81, 0x3fb03d5e, 0x3f902328}, - uint32(0xfff80000), - [21]string{"0x2b", "0x14", "0x6e", "0xa9", "0x8e", "0xd7", "0xe6", "0xd2", "0x13", "0x5b", "0xaa", "0x5a", "0xc1", "0x62", "0x78", "0x7d", "0xa7", "0xa1", "0x50", "0xa8", "0x00"}}, - { - /* No.739 delta:664 weight:1561 */ - 11213, - 80, - 13, - 4, - [16]uint32{0x00000000, 0x9e463afc, 0x2fed8630, 0xb1abbccc, 0x40f02e3c, 0xdeb614c0, 0x6f1da80c, 0xf15b92f0, 0x00005e46, 0x9e4664ba, 0x2fedd876, 0xb1abe28a, 0x40f0707a, 0xdeb64a86, 0x6f1df64a, 0xf15bccb6}, - [16]uint32{0x00000000, 0x3003841b, 0x000240cf, 0x3001c4d4, 0x1000481d, 0x2003cc06, 0x100208d2, 0x20018cc9, 0x04003401, 0x3403b01a, 0x040274ce, 0x3401f0d5, 0x14007c1c, 0x2403f807, 0x14023cd3, 0x2401b8c8}, - [16]uint32{0x3f800000, 0x3f9801c2, 0x3f800120, 0x3f9800e2, 0x3f880024, 0x3f9001e6, 0x3f880104, 0x3f9000c6, 0x3f82001a, 0x3f9a01d8, 0x3f82013a, 0x3f9a00f8, 0x3f8a003e, 0x3f9201fc, 0x3f8a011e, 0x3f9200dc}, - uint32(0xfff80000), - [21]string{"0xeb", "0xb2", "0xa2", "0x3b", "0x29", "0xa9", "0x79", "0xd3", "0x77", "0x5a", "0xb9", "0x45", "0xf0", "0xce", "0x90", "0x4a", "0x6e", "0x43", "0xd3", "0x31", "0x00"}}, - { - /* No.740 delta:823 weight:729 */ - 11213, - 88, - 13, - 4, - [16]uint32{0x00000000, 0x2df9dab0, 0x36db7996, 0x1b22a326, 0x96202e43, 0xbbd9f4f3, 0xa0fb57d5, 0x8d028d65, 0x0000ad61, 0x2df977d1, 0x36dbd4f7, 0x1b220e47, 0x96208322, 0xbbd95992, 0xa0fbfab4, 0x8d022004}, - [16]uint32{0x00000000, 0xa048ee12, 0x0069871c, 0xa021690e, 0x4340120b, 0xe308fc19, 0x43299517, 0xe3617b05, 0xa5426c0d, 0x050a821f, 0xa52beb11, 0x05630503, 0xe6027e06, 0x464a9014, 0xe66bf91a, 0x46231708}, - [16]uint32{0x3f800000, 0x3fd02477, 0x3f8034c3, 0x3fd010b4, 0x3fa1a009, 0x3ff1847e, 0x3fa194ca, 0x3ff1b0bd, 0x3fd2a136, 0x3f828541, 0x3fd295f5, 0x3f82b182, 0x3ff3013f, 0x3fa32548, 0x3ff335fc, 0x3fa3118b}, - uint32(0xfff80000), - [21]string{"0x33", "0x6e", "0x8f", "0xe1", "0xb2", "0x21", "0x56", "0x65", "0xe5", "0xbc", "0x01", "0x3d", "0x33", "0x2e", "0x33", "0x03", "0x1f", "0xce", "0x5e", "0x84", "0x00"}}, - { - /* No.741 delta:818 weight:1265 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x790b895a, 0x7c905d86, 0x059bd4dc, 0x23b02e5e, 0x5abba704, 0x5f2073d8, 0x262bfa82, 0x00003ab4, 0x790bb3ee, 0x7c906732, 0x059bee68, 0x23b014ea, 0x5abb9db0, 0x5f20496c, 0x262bc036}, - [16]uint32{0x00000000, 0x0065e415, 0x8412002b, 0x8477e43e, 0x00021052, 0x0067f447, 0x84101079, 0x8475f46c, 0x40684809, 0x400dac1c, 0xc47a4822, 0xc41fac37, 0x406a585b, 0x400fbc4e, 0xc4785870, 0xc41dbc65}, - [16]uint32{0x3f800000, 0x3f8032f2, 0x3fc20900, 0x3fc23bf2, 0x3f800108, 0x3f8033fa, 0x3fc20808, 0x3fc23afa, 0x3fa03424, 0x3fa006d6, 0x3fe23d24, 0x3fe20fd6, 0x3fa0352c, 0x3fa007de, 0x3fe23c2c, 0x3fe20ede}, - uint32(0xfff80000), - [21]string{"0x68", "0x46", "0xd3", "0x03", "0x4a", "0x57", "0x92", "0x46", "0x61", "0x92", "0x43", "0xe0", "0x2f", "0x44", "0x8e", "0x38", "0xc7", "0x76", "0x71", "0x3c", "0x00"}}, - { - /* No.742 delta:1000 weight:1215 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0xb63840f5, 0x5d974ebf, 0xebaf0e4a, 0x93a02e62, 0x25986e97, 0xce3760dd, 0x780f2028, 0x0000405f, 0xb63800aa, 0x5d970ee0, 0xebaf4e15, 0x93a06e3d, 0x25982ec8, 0xce372082, 0x780f6077}, - [16]uint32{0x00000000, 0x08016772, 0x50200011, 0x58216763, 0x9001bc1c, 0x9800db6e, 0xc021bc0d, 0xc820db7f, 0x400015da, 0x480172a8, 0x102015cb, 0x182172b9, 0xd001a9c6, 0xd800ceb4, 0x8021a9d7, 0x8820cea5}, - [16]uint32{0x3f800000, 0x3f8400b3, 0x3fa81000, 0x3fac10b3, 0x3fc800de, 0x3fcc006d, 0x3fe010de, 0x3fe4106d, 0x3fa0000a, 0x3fa400b9, 0x3f88100a, 0x3f8c10b9, 0x3fe800d4, 0x3fec0067, 0x3fc010d4, 0x3fc41067}, - uint32(0xfff80000), - [21]string{"0xeb", "0xaf", "0x0f", "0x23", "0xc7", "0x79", "0x23", "0x49", "0xe6", "0xf5", "0x00", "0xc0", "0x07", "0xb4", "0x5f", "0xcd", "0x17", "0x90", "0x88", "0xc9", "0x00"}}, - { - /* No.743 delta:787 weight:1499 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x196bf88a, 0xe0990c1f, 0xf9f2f495, 0x9d202e77, 0x844bd6fd, 0x7db92268, 0x64d2dae2, 0x00004be7, 0x196bb36d, 0xe09947f8, 0xf9f2bf72, 0x9d206590, 0x844b9d1a, 0x7db9698f, 0x64d29105}, - [16]uint32{0x00000000, 0x4071a3d7, 0x500c1671, 0x107db5a6, 0x00411209, 0x4030b1de, 0x504d0478, 0x103ca7af, 0x0002001c, 0x4073a3cb, 0x500e166d, 0x107fb5ba, 0x00431215, 0x4032b1c2, 0x504f0464, 0x103ea7b3}, - [16]uint32{0x3f800000, 0x3fa038d1, 0x3fa8060b, 0x3f883eda, 0x3f802089, 0x3fa01858, 0x3fa82682, 0x3f881e53, 0x3f800100, 0x3fa039d1, 0x3fa8070b, 0x3f883fda, 0x3f802189, 0x3fa01958, 0x3fa82782, 0x3f881f53}, - uint32(0xfff80000), - [21]string{"0x64", "0x9e", "0x1e", "0x3b", "0x8b", "0xb8", "0xc5", "0x56", "0xf8", "0x3d", "0xf8", "0xcc", "0x45", "0x12", "0xb4", "0xf8", "0x16", "0x73", "0x1c", "0x66", "0x00"}}, - { - /* No.744 delta:1328 weight:1453 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x09404275, 0x6a9808b1, 0x63d84ac4, 0x4c002e8e, 0x45406cfb, 0x2698263f, 0x2fd8644a, 0x00007727, 0x09403552, 0x6a987f96, 0x63d83de3, 0x4c0059a9, 0x45401bdc, 0x26985118, 0x2fd8136d}, - [16]uint32{0x00000000, 0x383444de, 0x4006301c, 0x783274c2, 0x20029009, 0x1836d4d7, 0x6004a015, 0x5830e4cb, 0x0004e0ed, 0x3830a433, 0x4002d0f1, 0x7836942f, 0x200670e4, 0x1832343a, 0x600040f8, 0x58340426}, - [16]uint32{0x3f800000, 0x3f9c1a22, 0x3fa00318, 0x3fbc193a, 0x3f900148, 0x3f8c1b6a, 0x3fb00250, 0x3fac1872, 0x3f800270, 0x3f9c1852, 0x3fa00168, 0x3fbc1b4a, 0x3f900338, 0x3f8c191a, 0x3fb00020, 0x3fac1a02}, - uint32(0xfff80000), - [21]string{"0xb5", "0xdb", "0xe7", "0xab", "0x9a", "0x9d", "0xc1", "0x9e", "0x8d", "0x73", "0x1d", "0x3a", "0xcf", "0x24", "0x1a", "0x54", "0xb3", "0xcb", "0x09", "0xac", "0x00"}}, - { - /* No.745 delta:820 weight:925 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0x68c4353c, 0xe9e86ef1, 0x812c5bcd, 0x50602e9e, 0x38a41ba2, 0xb988406f, 0xd14c7553, 0x00009943, 0x68c4ac7f, 0xe9e8f7b2, 0x812cc28e, 0x5060b7dd, 0x38a482e1, 0xb988d92c, 0xd14cec10}, - [16]uint32{0x00000000, 0x687d741e, 0x4003c497, 0x287eb089, 0x5822619b, 0x305f1585, 0x1821a50c, 0x705cd112, 0x00020091, 0x687f748f, 0x4001c406, 0x287cb018, 0x5820610a, 0x305d1514, 0x1823a59d, 0x705ed183}, - [16]uint32{0x3f800000, 0x3fb43eba, 0x3fa001e2, 0x3f943f58, 0x3fac1130, 0x3f982f8a, 0x3f8c10d2, 0x3fb82e68, 0x3f800100, 0x3fb43fba, 0x3fa000e2, 0x3f943e58, 0x3fac1030, 0x3f982e8a, 0x3f8c11d2, 0x3fb82f68}, - uint32(0xfff80000), - [21]string{"0x79", "0xa3", "0xf9", "0xc8", "0xa6", "0x34", "0x0e", "0x81", "0xc5", "0xbf", "0x7e", "0x81", "0x88", "0x5a", "0x12", "0x1a", "0xa2", "0xc6", "0x3b", "0xc0", "0x00"}}, - { - /* No.746 delta:732 weight:1529 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0x93be21db, 0x95f07927, 0x064e58fc, 0xc7002eaf, 0x54be0f74, 0x52f05788, 0xc14e7653, 0x000054f1, 0x93be752a, 0x95f02dd6, 0x064e0c0d, 0xc7007a5e, 0x54be5b85, 0x52f00379, 0xc14e22a2}, - [16]uint32{0x00000000, 0x6000d855, 0x4002260a, 0x2002fe5f, 0x80008404, 0xe0005c51, 0xc002a20e, 0xa0027a5b, 0x0000199d, 0x6000c1c8, 0x40023f97, 0x2002e7c2, 0x80009d99, 0xe00045cc, 0xc002bb93, 0xa00263c6}, - [16]uint32{0x3f800000, 0x3fb0006c, 0x3fa00113, 0x3f90017f, 0x3fc00042, 0x3ff0002e, 0x3fe00151, 0x3fd0013d, 0x3f80000c, 0x3fb00060, 0x3fa0011f, 0x3f900173, 0x3fc0004e, 0x3ff00022, 0x3fe0015d, 0x3fd00131}, - uint32(0xfff80000), - [21]string{"0xce", "0xd8", "0x30", "0xb3", "0x7b", "0xd1", "0xe7", "0xc7", "0xd9", "0x3a", "0x7b", "0xbd", "0x6e", "0xa2", "0xf2", "0x45", "0xc2", "0x88", "0xa4", "0xa1", "0x00"}}, - { - /* No.747 delta:1133 weight:1553 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0xc6100b1d, 0x744ae871, 0xb25ae36c, 0x2ef02eb1, 0xe8e025ac, 0x5abac6c0, 0x9caacddd, 0x00000996, 0xc610028b, 0x744ae1e7, 0xb25aeafa, 0x2ef02727, 0xe8e02c3a, 0x5abacf56, 0x9caac44b}, - [16]uint32{0x00000000, 0x0046f09a, 0x620265d9, 0x62449543, 0x01020014, 0x0144f08e, 0x630065cd, 0x63469557, 0x100040ea, 0x1046b070, 0x72022533, 0x7244d5a9, 0x110240fe, 0x1144b064, 0x73002527, 0x7346d5bd}, - [16]uint32{0x3f800000, 0x3f802378, 0x3fb10132, 0x3fb1224a, 0x3f808100, 0x3f80a278, 0x3fb18032, 0x3fb1a34a, 0x3f880020, 0x3f882358, 0x3fb90112, 0x3fb9226a, 0x3f888120, 0x3f88a258, 0x3fb98012, 0x3fb9a36a}, - uint32(0xfff80000), - [21]string{"0xdc", "0x97", "0xd7", "0x0a", "0xf7", "0xeb", "0x23", "0xa6", "0x31", "0x0d", "0x07", "0x1b", "0x10", "0x2f", "0x6c", "0x60", "0x8b", "0xe0", "0x33", "0x73", "0x00"}}, - { - /* No.748 delta:1287 weight:1623 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xe931db10, 0x2ddbfeb6, 0xc4ea25a6, 0x62a02ec7, 0x8b91f5d7, 0x4f7bd071, 0xa64a0b61, 0x0000cc53, 0xe9311743, 0x2ddb32e5, 0xc4eae9f5, 0x62a0e294, 0x8b913984, 0x4f7b1c22, 0xa64ac732}, - [16]uint32{0x00000000, 0x004280d2, 0x6020e60c, 0x606266de, 0x20c8041a, 0x208a84c8, 0x40e8e216, 0x40aa62c4, 0x8424181b, 0x846698c9, 0xe404fe17, 0xe4467ec5, 0xa4ec1c01, 0xa4ae9cd3, 0xc4ccfa0d, 0xc48e7adf}, - [16]uint32{0x3f800000, 0x3f802140, 0x3fb01073, 0x3fb03133, 0x3f906402, 0x3f904542, 0x3fa07471, 0x3fa05531, 0x3fc2120c, 0x3fc2334c, 0x3ff2027f, 0x3ff2233f, 0x3fd2760e, 0x3fd2574e, 0x3fe2667d, 0x3fe2473d}, - uint32(0xfff80000), - [21]string{"0x0e", "0x6e", "0x4a", "0xeb", "0xd4", "0x8d", "0xdc", "0x3a", "0x42", "0x57", "0xe5", "0x66", "0x54", "0x22", "0x92", "0xd3", "0x99", "0x5d", "0xf1", "0x2d", "0x00"}}, - { - /* No.749 delta:867 weight:1183 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xd60e9140, 0x97657349, 0x416be209, 0x7ea02ed8, 0xa8aebf98, 0xe9c55d91, 0x3fcbccd1, 0x00008b87, 0xd60e1ac7, 0x9765f8ce, 0x416b698e, 0x7ea0a55f, 0xa8ae341f, 0xe9c5d616, 0x3fcb4756}, - [16]uint32{0x00000000, 0x205e71b2, 0x40231007, 0x607d61b5, 0x0004c21e, 0x205ab3ac, 0x4027d219, 0x6079a3ab, 0x0002171d, 0x205c66af, 0x4021071a, 0x607f76a8, 0x0006d503, 0x2058a4b1, 0x4025c504, 0x607bb4b6}, - [16]uint32{0x3f800000, 0x3f902f38, 0x3fa01188, 0x3fb03eb0, 0x3f800261, 0x3f902d59, 0x3fa013e9, 0x3fb03cd1, 0x3f80010b, 0x3f902e33, 0x3fa01083, 0x3fb03fbb, 0x3f80036a, 0x3f902c52, 0x3fa012e2, 0x3fb03dda}, - uint32(0xfff80000), - [21]string{"0x72", "0x85", "0x37", "0xf3", "0x30", "0x30", "0x84", "0x16", "0x6e", "0xa3", "0x9e", "0xf1", "0xff", "0xb2", "0x7d", "0x92", "0x42", "0x17", "0x26", "0x18", "0x00"}}, - { - /* No.750 delta:1453 weight:1637 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xe207e4aa, 0x421628a0, 0xa011cc0a, 0xab502ee9, 0x4957ca43, 0xe9460649, 0x0b41e2e3, 0x0000f6d9, 0xe2071273, 0x4216de79, 0xa0113ad3, 0xab50d830, 0x49573c9a, 0xe946f090, 0x0b41143a}, - [16]uint32{0x00000000, 0xa80f5454, 0x616000db, 0xc96f548f, 0x3002092a, 0x980d5d7e, 0x516209f1, 0xf96d5da5, 0x0064143c, 0xa86b4068, 0x610414e7, 0xc90b40b3, 0x30661d16, 0x98694942, 0x51061dcd, 0xf9094999}, - [16]uint32{0x3f800000, 0x3fd407aa, 0x3fb0b000, 0x3fe4b7aa, 0x3f980104, 0x3fcc06ae, 0x3fa8b104, 0x3ffcb6ae, 0x3f80320a, 0x3fd435a0, 0x3fb0820a, 0x3fe485a0, 0x3f98330e, 0x3fcc34a4, 0x3fa8830e, 0x3ffc84a4}, - uint32(0xfff80000), - [21]string{"0xf8", "0xf0", "0xc1", "0xc1", "0x00", "0x82", "0x5a", "0xb8", "0x78", "0x47", "0xf4", "0x67", "0x67", "0xd6", "0xe0", "0x66", "0xd1", "0x4f", "0xaf", "0x1f", "0x00"}}, - { - /* No.751 delta:838 weight:1123 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xf20dcbd4, 0x089654b6, 0xfa9b9f62, 0xef602ef3, 0x1d6de527, 0xe7f67a45, 0x15fbb191, 0x00004ca7, 0xf20d8773, 0x08961811, 0xfa9bd3c5, 0xef606254, 0x1d6da980, 0xe7f636e2, 0x15fbfd36}, - [16]uint32{0x00000000, 0x506e0192, 0x100287d9, 0x406c864b, 0x20003815, 0x706e3987, 0x3002bfcc, 0x606cbe5e, 0x10015006, 0x406f5194, 0x0003d7df, 0x506dd64d, 0x30016813, 0x606f6981, 0x2003efca, 0x706dee58}, - [16]uint32{0x3f800000, 0x3fa83700, 0x3f880143, 0x3fa03643, 0x3f90001c, 0x3fb8371c, 0x3f98015f, 0x3fb0365f, 0x3f8800a8, 0x3fa037a8, 0x3f8001eb, 0x3fa836eb, 0x3f9800b4, 0x3fb037b4, 0x3f9001f7, 0x3fb836f7}, - uint32(0xfff80000), - [21]string{"0xae", "0xe2", "0x24", "0xe2", "0xa6", "0xf4", "0x56", "0xf2", "0x53", "0xec", "0x19", "0x48", "0xf8", "0x0c", "0x03", "0x23", "0x26", "0xc7", "0xe9", "0x10", "0x00"}}, - { - /* No.752 delta:620 weight:1439 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0x01bea120, 0x5ee2bf84, 0x5f5c1ea4, 0x8db02f06, 0x8c0e8e26, 0xd3529082, 0xd2ec31a2, 0x00007544, 0x01bed464, 0x5ee2cac0, 0x5f5c6be0, 0x8db05a42, 0x8c0efb62, 0xd352e5c6, 0xd2ec44e6}, - [16]uint32{0x00000000, 0x40048153, 0x1040019e, 0x504480cd, 0x30029004, 0x70061157, 0x2042919a, 0x604610c9, 0x2020301f, 0x6024b14c, 0x30603181, 0x7064b0d2, 0x1022a01b, 0x50262148, 0x0062a185, 0x406620d6}, - [16]uint32{0x3f800000, 0x3fa00240, 0x3f882000, 0x3fa82240, 0x3f980148, 0x3fb80308, 0x3f902148, 0x3fb02308, 0x3f901018, 0x3fb01258, 0x3f983018, 0x3fb83258, 0x3f881150, 0x3fa81310, 0x3f803150, 0x3fa03310}, - uint32(0xfff80000), - [21]string{"0x8c", "0xe5", "0x46", "0x3a", "0x16", "0x90", "0xe3", "0x1d", "0xcc", "0xd7", "0x23", "0x84", "0xf7", "0x70", "0x9c", "0x6f", "0xf3", "0x0f", "0x4e", "0xf9", "0x00"}}, - { - /* No.753 delta:1676 weight:1579 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x81b84728, 0x36d62cb5, 0xb76e6b9d, 0xf9002f19, 0x78b86831, 0xcfd603ac, 0x4e6e4484, 0x0000590d, 0x81b81e25, 0x36d675b8, 0xb76e3290, 0xf9007614, 0x78b8313c, 0xcfd65aa1, 0x4e6e1d89}, - [16]uint32{0x00000000, 0x0c18abfe, 0x00622553, 0x0c7a8ead, 0x20805d4f, 0x2c98f6b1, 0x20e2781c, 0x2cfad3e2, 0x40900015, 0x4c88abeb, 0x40f22546, 0x4cea8eb8, 0x60105d5a, 0x6c08f6a4, 0x60727809, 0x6c6ad3f7}, - [16]uint32{0x3f800000, 0x3f860c55, 0x3f803112, 0x3f863d47, 0x3f90402e, 0x3f964c7b, 0x3f90713c, 0x3f967d69, 0x3fa04800, 0x3fa64455, 0x3fa07912, 0x3fa67547, 0x3fb0082e, 0x3fb6047b, 0x3fb0393c, 0x3fb63569}, - uint32(0xfff80000), - [21]string{"0x11", "0xf7", "0xb8", "0x6e", "0xab", "0x18", "0x86", "0xa8", "0x1d", "0x51", "0xd4", "0x88", "0x9b", "0x91", "0xb3", "0x1b", "0xcb", "0x08", "0x44", "0xbc", "0x00"}}, - { - /* No.754 delta:620 weight:1357 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0xe8d71056, 0xa2339a43, 0x4ae48a15, 0xd6502f2e, 0x3e873f78, 0x7463b56d, 0x9cb4a53b, 0x000094c6, 0xe8d78490, 0xa2330e85, 0x4ae41ed3, 0xd650bbe8, 0x3e87abbe, 0x746321ab, 0x9cb431fd}, - [16]uint32{0x00000000, 0x18020235, 0x10002492, 0x080226a7, 0x60003c0a, 0x78023e3f, 0x70001898, 0x68021aad, 0x021108dc, 0x1a130ae9, 0x12112c4e, 0x0a132e7b, 0x621134d6, 0x7a1336e3, 0x72111044, 0x6a131271}, - [16]uint32{0x3f800000, 0x3f8c0101, 0x3f880012, 0x3f840113, 0x3fb0001e, 0x3fbc011f, 0x3fb8000c, 0x3fb4010d, 0x3f810884, 0x3f8d0985, 0x3f890896, 0x3f850997, 0x3fb1089a, 0x3fbd099b, 0x3fb90888, 0x3fb50989}, - uint32(0xfff80000), - [21]string{"0xd3", "0xa0", "0xf4", "0x6c", "0x7a", "0x5f", "0x71", "0x51", "0x05", "0xd4", "0xaa", "0x31", "0xc2", "0xe0", "0xf0", "0x56", "0x09", "0x62", "0x12", "0x48", "0x00"}}, - { - /* No.755 delta:984 weight:1467 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0xd84ea056, 0x6a6a36ab, 0xb22496fd, 0x6c702f3f, 0xb43e8f69, 0x061a1994, 0xde54b9c2, 0x0000a4ec, 0xd84e04ba, 0x6a6a9247, 0xb2243211, 0x6c708bd3, 0xb43e2b85, 0x061abd78, 0xde541d2e}, - [16]uint32{0x00000000, 0x0003e11e, 0x005c4833, 0x005fa92d, 0x403c4d6f, 0x403fac71, 0x4060055c, 0x4063e442, 0x80101204, 0x8013f31a, 0x804c5a37, 0x804fbb29, 0xc02c5f6b, 0xc02fbe75, 0xc0701758, 0xc073f646}, - [16]uint32{0x3f800000, 0x3f8001f0, 0x3f802e24, 0x3f802fd4, 0x3fa01e26, 0x3fa01fd6, 0x3fa03002, 0x3fa031f2, 0x3fc00809, 0x3fc009f9, 0x3fc0262d, 0x3fc027dd, 0x3fe0162f, 0x3fe017df, 0x3fe0380b, 0x3fe039fb}, - uint32(0xfff80000), - [21]string{"0xae", "0x60", "0xaf", "0x94", "0x49", "0x39", "0x30", "0xa8", "0x46", "0x13", "0x39", "0x52", "0x64", "0x09", "0x67", "0x43", "0x5d", "0x18", "0x6d", "0xa8", "0x00"}}, - { - /* No.756 delta:643 weight:1603 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x8cfbdea7, 0x18184f08, 0x94e391af, 0x45002f46, 0xc9fbf1e1, 0x5d18604e, 0xd1e3bee9, 0x0000e16f, 0x8cfb3fc8, 0x1818ae67, 0x94e370c0, 0x4500ce29, 0xc9fb108e, 0x5d188121, 0xd1e35f86}, - [16]uint32{0x00000000, 0x80034053, 0x08003a05, 0x88037a56, 0x60030bc2, 0xe0004b91, 0x680331c7, 0xe8007194, 0x0012835c, 0x8011c30f, 0x0812b959, 0x8811f90a, 0x6011889e, 0xe012c8cd, 0x6811b29b, 0xe812f2c8}, - [16]uint32{0x3f800000, 0x3fc001a0, 0x3f84001d, 0x3fc401bd, 0x3fb00185, 0x3ff00025, 0x3fb40198, 0x3ff40038, 0x3f800941, 0x3fc008e1, 0x3f84095c, 0x3fc408fc, 0x3fb008c4, 0x3ff00964, 0x3fb408d9, 0x3ff40979}, - uint32(0xfff80000), - [21]string{"0xf8", "0x4f", "0xc4", "0xfc", "0x78", "0xae", "0xfe", "0x5f", "0xc6", "0x4a", "0x1e", "0xed", "0xe2", "0x2c", "0xb7", "0x7f", "0x92", "0x71", "0xe0", "0x73", "0x00"}}, - { - /* No.757 delta:3100 weight:641 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0xde26a3da, 0x4b9a85d3, 0x95bc2609, 0x9d902f52, 0x43b68c88, 0xd60aaa81, 0x082c095b, 0x000029ec, 0xde268a36, 0x4b9aac3f, 0x95bc0fe5, 0x9d9006be, 0x43b6a564, 0xd60a836d, 0x082c20b7}, - [16]uint32{0x00000000, 0x244931ab, 0x11142e02, 0x355d1fa9, 0xeb01081e, 0xcf4839b5, 0xfa15261c, 0xde5c17b7, 0xc0111013, 0xe45821b8, 0xd1053e11, 0xf54c0fba, 0x2b10180d, 0x0f5929a6, 0x3a04360f, 0x1e4d07a4}, - [16]uint32{0x3f800000, 0x3f922498, 0x3f888a17, 0x3f9aae8f, 0x3ff58084, 0x3fe7a41c, 0x3ffd0a93, 0x3fef2e0b, 0x3fe00888, 0x3ff22c10, 0x3fe8829f, 0x3ffaa607, 0x3f95880c, 0x3f87ac94, 0x3f9d021b, 0x3f8f2683}, - uint32(0xfff80000), - [21]string{"0xac", "0x51", "0x62", "0xb7", "0x65", "0xd2", "0x7d", "0x54", "0x73", "0x0b", "0xc4", "0x5e", "0xa5", "0xfd", "0x52", "0xea", "0x74", "0x10", "0xc0", "0x94", "0x00"}}, - { - /* No.758 delta:874 weight:703 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x2e8cbb1e, 0xf4fa7474, 0xda76cf6a, 0xeea02f66, 0xc02c9478, 0x1a5a5b12, 0x34d6e00c, 0x000004c9, 0x2e8cbfd7, 0xf4fa70bd, 0xda76cba3, 0xeea02baf, 0xc02c90b1, 0x1a5a5fdb, 0x34d6e4c5}, - [16]uint32{0x00000000, 0x0813693b, 0x6003b934, 0x6810d00f, 0x6092cdc8, 0x6881a4f3, 0x009174fc, 0x08821dc7, 0x3061d01d, 0x3872b926, 0x50626929, 0x58710012, 0x50f31dd5, 0x58e074ee, 0x30f0a4e1, 0x38e3cdda}, - [16]uint32{0x3f800000, 0x3f8409b4, 0x3fb001dc, 0x3fb40868, 0x3fb04966, 0x3fb440d2, 0x3f8048ba, 0x3f84410e, 0x3f9830e8, 0x3f9c395c, 0x3fa83134, 0x3fac3880, 0x3fa8798e, 0x3fac703a, 0x3f987852, 0x3f9c71e6}, - uint32(0xfff80000), - [21]string{"0xb7", "0x80", "0x01", "0xda", "0x6a", "0x06", "0xcb", "0x0b", "0x87", "0xd1", "0x72", "0x09", "0x85", "0xbf", "0xd7", "0x96", "0x7c", "0x62", "0xbc", "0xbf", "0x00"}}, - { - /* No.759 delta:683 weight:1685 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xdd4812d0, 0x11d230dc, 0xcc9a220c, 0x29702f79, 0xf4383da9, 0x38a21fa5, 0xe5ea0d75, 0x000040b3, 0xdd485263, 0x11d2706f, 0xcc9a62bf, 0x29706fca, 0xf4387d1a, 0x38a25f16, 0xe5ea4dc6}, - [16]uint32{0x00000000, 0x802e0955, 0x201fac1a, 0xa031a54f, 0x00021014, 0x802c1941, 0x201dbc0e, 0xa033b55b, 0x00015c12, 0x802f5547, 0x201ef008, 0xa030f95d, 0x00034c06, 0x802d4553, 0x201ce01c, 0xa032e949}, - [16]uint32{0x3f800000, 0x3fc01704, 0x3f900fd6, 0x3fd018d2, 0x3f800108, 0x3fc0160c, 0x3f900ede, 0x3fd019da, 0x3f8000ae, 0x3fc017aa, 0x3f900f78, 0x3fd0187c, 0x3f8001a6, 0x3fc016a2, 0x3f900e70, 0x3fd01974}, - uint32(0xfff80000), - [21]string{"0xa8", "0x6f", "0x18", "0x09", "0xdd", "0x29", "0xa7", "0xe7", "0xb7", "0x2d", "0x89", "0x52", "0x0d", "0x53", "0x3d", "0x78", "0xb4", "0x58", "0xe9", "0x38", "0x00"}}, - { - /* No.760 delta:1005 weight:1475 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x8017a48d, 0x8fd0fcdf, 0x0fc75852, 0xa5b02f8e, 0x25a78b03, 0x2a60d351, 0xaa7777dc, 0x0000f42a, 0x801750a7, 0x8fd008f5, 0x0fc7ac78, 0xa5b0dba4, 0x25a77f29, 0x2a60277b, 0xaa7783f6}, - [16]uint32{0x00000000, 0x00020c96, 0x102c695c, 0x102e65ca, 0x90080c65, 0x900a00f3, 0x80246539, 0x802669af, 0x30400414, 0x30420882, 0x206c6d48, 0x206e61de, 0xa0480871, 0xa04a04e7, 0xb064612d, 0xb0666dbb}, - [16]uint32{0x3f800000, 0x3f800106, 0x3f881634, 0x3f881732, 0x3fc80406, 0x3fc80500, 0x3fc01232, 0x3fc01334, 0x3f982002, 0x3f982104, 0x3f903636, 0x3f903730, 0x3fd02404, 0x3fd02502, 0x3fd83230, 0x3fd83336}, - uint32(0xfff80000), - [21]string{"0xff", "0xa2", "0xe7", "0xa5", "0xe8", "0xbe", "0x8c", "0xd5", "0x26", "0x96", "0x59", "0x31", "0x8c", "0x7d", "0x40", "0xb1", "0x0c", "0xe5", "0xfb", "0xfd", "0x00"}}, - { - /* No.761 delta:1058 weight:1427 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x2d507f27, 0xc6c15eab, 0xeb91218c, 0xb1502f96, 0x9c0050b1, 0x7791713d, 0x5ac10e1a, 0x0000ff10, 0x2d508037, 0xc6c1a1bb, 0xeb91de9c, 0xb150d086, 0x9c00afa1, 0x77918e2d, 0x5ac1f10a}, - [16]uint32{0x00000000, 0x0074a8d6, 0x100cc09f, 0x10786849, 0x000c9107, 0x007839d1, 0x10005198, 0x1074f94e, 0x5004041b, 0x5070accd, 0x4008c484, 0x407c6c52, 0x5008951c, 0x507c3dca, 0x40045583, 0x4070fd55}, - [16]uint32{0x3f800000, 0x3f803a54, 0x3f880660, 0x3f883c34, 0x3f800648, 0x3f803c1c, 0x3f880028, 0x3f883a7c, 0x3fa80202, 0x3fa83856, 0x3fa00462, 0x3fa03e36, 0x3fa8044a, 0x3fa83e1e, 0x3fa0022a, 0x3fa0387e}, - uint32(0xfff80000), - [21]string{"0xa0", "0xda", "0xbf", "0x0f", "0xe8", "0x10", "0x29", "0x4c", "0x5b", "0x40", "0xf2", "0xa9", "0x26", "0x75", "0xd9", "0x59", "0xfb", "0x28", "0xa7", "0xdb", "0x00"}}, - { - /* No.762 delta:913 weight:1687 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0xa9a41684, 0xb7826690, 0x1e267014, 0xee402fa2, 0x47e43926, 0x59c24932, 0xf0665fb6, 0x000013c4, 0xa9a40540, 0xb7827554, 0x1e2663d0, 0xee403c66, 0x47e42ae2, 0x59c25af6, 0xf0664c72}, - [16]uint32{0x00000000, 0x3004017d, 0x606401bb, 0x506000c6, 0x0002f0b5, 0x3006f1c8, 0x6066f10e, 0x5062f073, 0x600dc937, 0x5009c84a, 0x0069c88c, 0x306dc9f1, 0x600f3982, 0x500b38ff, 0x006b3839, 0x306f3944}, - [16]uint32{0x3f800000, 0x3f980200, 0x3fb03200, 0x3fa83000, 0x3f800178, 0x3f980378, 0x3fb03378, 0x3fa83178, 0x3fb006e4, 0x3fa804e4, 0x3f8034e4, 0x3f9836e4, 0x3fb0079c, 0x3fa8059c, 0x3f80359c, 0x3f98379c}, - uint32(0xfff80000), - [21]string{"0x0f", "0xc5", "0xcc", "0x6a", "0x0e", "0x60", "0x64", "0x81", "0x8e", "0xc7", "0x19", "0xcd", "0xee", "0xc7", "0xd4", "0xb9", "0x68", "0xb7", "0x4b", "0xb4", "0x00"}}, - { - /* No.763 delta:2142 weight:1293 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xb9a47aa6, 0x51fcd1b1, 0xe858ab17, 0xae502fba, 0x17f4551c, 0xffacfe0b, 0x460884ad, 0x0000ea47, 0xb9a490e1, 0x51fc3bf6, 0xe8584150, 0xae50c5fd, 0x17f4bf5b, 0xffac144c, 0x46086eea}, - [16]uint32{0x00000000, 0x5aa5d176, 0x43800143, 0x1925d035, 0x12408811, 0x48e55967, 0x51c08952, 0x0b655824, 0x8403240e, 0xdea6f578, 0xc783254d, 0x9d26f43b, 0x9643ac1f, 0xcce67d69, 0xd5c3ad5c, 0x8f667c2a}, - [16]uint32{0x3f800000, 0x3fad52e8, 0x3fa1c000, 0x3f8c92e8, 0x3f892044, 0x3fa472ac, 0x3fa8e044, 0x3f85b2ac, 0x3fc20192, 0x3fef537a, 0x3fe3c192, 0x3fce937a, 0x3fcb21d6, 0x3fe6733e, 0x3feae1d6, 0x3fc7b33e}, - uint32(0xfff80000), - [21]string{"0xd2", "0xb8", "0x4e", "0xe7", "0xa6", "0x10", "0x21", "0xab", "0x24", "0x03", "0x85", "0xbb", "0x24", "0x3a", "0x1e", "0x48", "0x95", "0xfa", "0xa8", "0xf1", "0x00"}}, - { - /* No.764 delta:755 weight:1573 */ - 11213, - 74, - 13, - 4, - [16]uint32{0x00000000, 0x0b551f3f, 0x7da19575, 0x76f48a4a, 0x37a02fc5, 0x3cf530fa, 0x4a01bab0, 0x4154a58f, 0x00000e6b, 0x0b551154, 0x7da19b1e, 0x76f48421, 0x37a021ae, 0x3cf53e91, 0x4a01b4db, 0x4154abe4}, - [16]uint32{0x00000000, 0x0016203b, 0x4020e139, 0x4036c102, 0x106b08cd, 0x107d28f6, 0x504be9f4, 0x505dc9cf, 0x00032215, 0x0015022e, 0x4023c32c, 0x4035e317, 0x10682ad8, 0x107e0ae3, 0x5048cbe1, 0x505eebda}, - [16]uint32{0x3f800000, 0x3f800b10, 0x3fa01070, 0x3fa01b60, 0x3f883584, 0x3f883e94, 0x3fa825f4, 0x3fa82ee4, 0x3f800191, 0x3f800a81, 0x3fa011e1, 0x3fa01af1, 0x3f883415, 0x3f883f05, 0x3fa82465, 0x3fa82f75}, - uint32(0xfff80000), - [21]string{"0xf8", "0x92", "0x5e", "0x29", "0x78", "0x15", "0xc1", "0xac", "0x9d", "0x42", "0x22", "0x73", "0x2b", "0x0c", "0xd8", "0x32", "0x49", "0xb8", "0xa9", "0x77", "0x00"}}, - { - /* No.765 delta:1063 weight:1539 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0xf6bc68ab, 0x1c11ba11, 0xeaadd2ba, 0x82b02fd3, 0x740c4778, 0x9ea195c2, 0x681dfd69, 0x0000cbbd, 0xf6bca316, 0x1c1171ac, 0xeaad1907, 0x82b0e46e, 0x740c8cc5, 0x9ea15e7f, 0x681d36d4}, - [16]uint32{0x00000000, 0x001f373e, 0x10141138, 0x100b2606, 0x100c2013, 0x1013172d, 0x0018312b, 0x00070615, 0x4050101c, 0x404f2722, 0x50440124, 0x505b361a, 0x505c300f, 0x50430731, 0x40482137, 0x40571609}, - [16]uint32{0x3f800000, 0x3f800f9b, 0x3f880a08, 0x3f880593, 0x3f880610, 0x3f88098b, 0x3f800c18, 0x3f800383, 0x3fa02808, 0x3fa02793, 0x3fa82200, 0x3fa82d9b, 0x3fa82e18, 0x3fa82183, 0x3fa02410, 0x3fa02b8b}, - uint32(0xfff80000), - [21]string{"0x20", "0xa5", "0xeb", "0xe7", "0x1b", "0xf8", "0x66", "0x6d", "0x4d", "0x66", "0x7d", "0x71", "0x16", "0xcd", "0x5d", "0x95", "0x30", "0xd8", "0xea", "0x29", "0x00"}}, - { - /* No.766 delta:1224 weight:1629 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0xe13eec75, 0xac2a5913, 0x4d14b566, 0x89c02fef, 0x68fec39a, 0x25ea76fc, 0xc4d49a89, 0x0000a3ae, 0xe13e4fdb, 0xac2afabd, 0x4d1416c8, 0x89c08c41, 0x68fe6034, 0x25ead552, 0xc4d43927}, - [16]uint32{0x00000000, 0x88264412, 0x41002145, 0xc9266557, 0x10030011, 0x98254403, 0x51032154, 0xd9256546, 0x0040105a, 0x88665448, 0x4140311f, 0xc966750d, 0x1043104b, 0x98655459, 0x5143310e, 0xd965751c}, - [16]uint32{0x3f800000, 0x3fc41322, 0x3fa08010, 0x3fe49332, 0x3f880180, 0x3fcc12a2, 0x3fa88190, 0x3fec92b2, 0x3f802008, 0x3fc4332a, 0x3fa0a018, 0x3fe4b33a, 0x3f882188, 0x3fcc32aa, 0x3fa8a198, 0x3fecb2ba}, - uint32(0xfff80000), - [21]string{"0x07", "0x8d", "0x3d", "0xa0", "0xb4", "0x21", "0x83", "0xb5", "0x2e", "0x53", "0x24", "0x11", "0xbb", "0x29", "0x86", "0xc0", "0x6c", "0x99", "0x7a", "0x44", "0x00"}}, - { - /* No.767 delta:753 weight:1547 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xe6a76783, 0xf3a1dafa, 0x1506bd79, 0xaf702ff8, 0x49d7487b, 0x5cd1f502, 0xba769281, 0x0000b619, 0xe6a7d19a, 0xf3a16ce3, 0x15060b60, 0xaf7099e1, 0x49d7fe62, 0x5cd1431b, 0xba762498}, - [16]uint32{0x00000000, 0x105c01df, 0x504220b5, 0x401e216a, 0x00027c06, 0x105e7dd9, 0x50405cb3, 0x401c5d6c, 0x00012157, 0x105d2088, 0x504301e2, 0x401f003d, 0x00035d51, 0x105f5c8e, 0x50417de4, 0x401d7c3b}, - [16]uint32{0x3f800000, 0x3f882e00, 0x3fa82110, 0x3fa00f10, 0x3f80013e, 0x3f882f3e, 0x3fa8202e, 0x3fa00e2e, 0x3f800090, 0x3f882e90, 0x3fa82180, 0x3fa00f80, 0x3f8001ae, 0x3f882fae, 0x3fa820be, 0x3fa00ebe}, - uint32(0xfff80000), - [21]string{"0x19", "0xb6", "0x7c", "0x66", "0x55", "0x1b", "0x1a", "0x74", "0x9c", "0xb1", "0xe3", "0x9b", "0xe8", "0x28", "0xb0", "0x8f", "0x8d", "0x42", "0x53", "0xcb", "0x00"}}, - { - /* No.768 delta:573 weight:1621 */ - 11213, - 93, - 13, - 4, - [16]uint32{0x00000000, 0x2d57cf1f, 0xe0a066b6, 0xcdf7a9a9, 0xfb40300f, 0xd617ff10, 0x1be056b9, 0x36b799a6, 0x0000f084, 0x2d573f9b, 0xe0a09632, 0xcdf7592d, 0xfb40c08b, 0xd6170f94, 0x1be0a63d, 0x36b76922}, - [16]uint32{0x00000000, 0xe0021176, 0x20422409, 0xc040357f, 0x000a2c12, 0xe0083d64, 0x2048081b, 0xc04a196d, 0x0162ba0a, 0xe160ab7c, 0x21209e03, 0xc1228f75, 0x01689618, 0xe16a876e, 0x212ab211, 0xc128a367}, - [16]uint32{0x3f800000, 0x3ff00108, 0x3f902112, 0x3fe0201a, 0x3f800516, 0x3ff0041e, 0x3f902404, 0x3fe0250c, 0x3f80b15d, 0x3ff0b055, 0x3f90904f, 0x3fe09147, 0x3f80b44b, 0x3ff0b543, 0x3f909559, 0x3fe09451}, - uint32(0xfff80000), - [21]string{"0x5f", "0x80", "0x31", "0x8a", "0xfe", "0xe6", "0x7c", "0x35", "0x1f", "0xe5", "0x12", "0x50", "0x4d", "0x5c", "0x15", "0x22", "0xfc", "0xc6", "0xa4", "0xc6", "0x00"}}, - { - /* No.769 delta:1220 weight:1657 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x48613428, 0x8f1d3dfe, 0xc77c09d6, 0xbc703017, 0xf411043f, 0x336d0de9, 0x7b0c39c1, 0x0000d78c, 0x4861e3a4, 0x8f1dea72, 0xc77cde5a, 0xbc70e79b, 0xf411d3b3, 0x336dda65, 0x7b0cee4d}, - [16]uint32{0x00000000, 0x004a24da, 0x0032b10f, 0x007895d5, 0x20226526, 0x206841fc, 0x2010d429, 0x205af0f3, 0x800809c4, 0x80422d1e, 0x803ab8cb, 0x80709c11, 0xa02a6ce2, 0xa0604838, 0xa018dded, 0xa052f937}, - [16]uint32{0x3f800000, 0x3f802512, 0x3f801958, 0x3f803c4a, 0x3f901132, 0x3f903420, 0x3f90086a, 0x3f902d78, 0x3fc00404, 0x3fc02116, 0x3fc01d5c, 0x3fc0384e, 0x3fd01536, 0x3fd03024, 0x3fd00c6e, 0x3fd0297c}, - uint32(0xfff80000), - [21]string{"0xe6", "0x25", "0xd1", "0xf9", "0xed", "0x8a", "0xc2", "0xbe", "0xdb", "0xc7", "0x9f", "0x52", "0xdc", "0xfb", "0xa2", "0xf7", "0xd1", "0xb7", "0x36", "0xcd", "0x00"}}, - { - /* No.770 delta:837 weight:1673 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x0cec7299, 0x0080ea2e, 0x0c6c98b7, 0x1b503025, 0x17bc42bc, 0x1bd0da0b, 0x173ca892, 0x0000be5b, 0x0cecccc2, 0x00805475, 0x0c6c26ec, 0x1b508e7e, 0x17bcfce7, 0x1bd06450, 0x173c16c9}, - [16]uint32{0x00000000, 0x4802899a, 0x4000811f, 0x08020885, 0x800060d6, 0xc802e94c, 0xc000e1c9, 0x88026853, 0x2003021c, 0x68018b86, 0x60038303, 0x28010a99, 0xa00362ca, 0xe801eb50, 0xe003e3d5, 0xa8016a4f}, - [16]uint32{0x3f800000, 0x3fa40144, 0x3fa00040, 0x3f840104, 0x3fc00030, 0x3fe40174, 0x3fe00070, 0x3fc40134, 0x3f900181, 0x3fb400c5, 0x3fb001c1, 0x3f940085, 0x3fd001b1, 0x3ff400f5, 0x3ff001f1, 0x3fd400b5}, - uint32(0xfff80000), - [21]string{"0x64", "0x2b", "0x99", "0x22", "0x9a", "0x9e", "0x38", "0x4a", "0xeb", "0x73", "0x6e", "0xb2", "0x5e", "0x84", "0x8c", "0x4e", "0x19", "0x60", "0x08", "0x9d", "0x00"}}, - { - /* No.771 delta:1426 weight:1635 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x6854f3c4, 0x4700c943, 0x2f543a87, 0x36203036, 0x5e74c3f2, 0x7120f975, 0x19740ab1, 0x00003220, 0x6854c1e4, 0x4700fb63, 0x2f5408a7, 0x36200216, 0x5e74f1d2, 0x7120cb55, 0x19743891}, - [16]uint32{0x00000000, 0x004e8197, 0x001241ae, 0x005cc039, 0x000000da, 0x004e814d, 0x00124174, 0x005cc0e3, 0x2018007f, 0x205681e8, 0x200a41d1, 0x2044c046, 0x201800a5, 0x20568132, 0x200a410b, 0x2044c09c}, - [16]uint32{0x3f800000, 0x3f802740, 0x3f800920, 0x3f802e60, 0x3f800000, 0x3f802740, 0x3f800920, 0x3f802e60, 0x3f900c00, 0x3f902b40, 0x3f900520, 0x3f902260, 0x3f900c00, 0x3f902b40, 0x3f900520, 0x3f902260}, - uint32(0xfff80000), - [21]string{"0x7d", "0xab", "0x83", "0xbe", "0x61", "0x27", "0x73", "0xf0", "0x5d", "0x44", "0xbe", "0xee", "0xb1", "0xb0", "0x91", "0x73", "0x49", "0xba", "0x94", "0xad", "0x00"}}, - { - /* No.772 delta:942 weight:1575 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0xda02d64a, 0x9496c558, 0x4e941312, 0x2bc03043, 0xf1c2e609, 0xbf56f51b, 0x65542351, 0x0000c766, 0xda02112c, 0x9496023e, 0x4e94d474, 0x2bc0f725, 0xf1c2216f, 0xbf56327d, 0x6554e437}, - [16]uint32{0x00000000, 0x0062ceb2, 0x60c51497, 0x60a7da25, 0x000201ba, 0x0060cf08, 0x60c7152d, 0x60a5db9f, 0x400031fc, 0x4062ff4e, 0x20c5256b, 0x20a7ebd9, 0x40023046, 0x4060fef4, 0x20c724d1, 0x20a5ea63}, - [16]uint32{0x3f800000, 0x3f803167, 0x3fb0628a, 0x3fb053ed, 0x3f800100, 0x3f803067, 0x3fb0638a, 0x3fb052ed, 0x3fa00018, 0x3fa0317f, 0x3f906292, 0x3f9053f5, 0x3fa00118, 0x3fa0307f, 0x3f906392, 0x3f9052f5}, - uint32(0xfff80000), - [21]string{"0xd6", "0x07", "0xaf", "0x11", "0xee", "0x10", "0xbc", "0x93", "0x45", "0xec", "0x49", "0x20", "0x82", "0x5c", "0x81", "0x95", "0x70", "0xea", "0x4f", "0x24", "0x00"}}, - { - /* No.773 delta:1334 weight:1777 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0x57ca9c79, 0xf0e93050, 0xa723ac29, 0x1ca0305f, 0x4b6aac26, 0xec49000f, 0xbb839c76, 0x000097d7, 0x57ca0bae, 0xf0e9a787, 0xa7233bfe, 0x1ca0a788, 0x4b6a3bf1, 0xec4997d8, 0xbb830ba1}, - [16]uint32{0x00000000, 0x283c21de, 0x205bc4cd, 0x0867e513, 0x3035781b, 0x180959c5, 0x106ebcd6, 0x38529d08, 0x0041ec0a, 0x287dcdd4, 0x201a28c7, 0x08260919, 0x30749411, 0x1848b5cf, 0x102f50dc, 0x38137102}, - [16]uint32{0x3f800000, 0x3f941e10, 0x3f902de2, 0x3f8433f2, 0x3f981abc, 0x3f8c04ac, 0x3f88375e, 0x3f9c294e, 0x3f8020f6, 0x3f943ee6, 0x3f900d14, 0x3f841304, 0x3f983a4a, 0x3f8c245a, 0x3f8817a8, 0x3f9c09b8}, - uint32(0xfff80000), - [21]string{"0x56", "0xf9", "0x68", "0xde", "0xe8", "0x46", "0x61", "0x16", "0xe3", "0x69", "0x27", "0xa8", "0x55", "0xe4", "0x4b", "0xf9", "0x24", "0x95", "0x9c", "0x3d", "0x00"}}, - { - /* No.774 delta:788 weight:1779 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xc0b4d540, 0xccca8778, 0x0c7e5238, 0x82c0306a, 0x4274e52a, 0x4e0ab712, 0x8ebe6252, 0x0000d2e4, 0xc0b407a4, 0xccca559c, 0x0c7e80dc, 0x82c0e28e, 0x427437ce, 0x4e0a65f6, 0x8ebeb0b6}, - [16]uint32{0x00000000, 0x20208817, 0x30001082, 0x10209895, 0x8510217f, 0xa530a968, 0xb51031fd, 0x9530b9ea, 0x40000cce, 0x602084d9, 0x70001c4c, 0x5020945b, 0xc5102db1, 0xe530a5a6, 0xf5103d33, 0xd530b524}, - [16]uint32{0x3f800000, 0x3f901044, 0x3f980008, 0x3f88104c, 0x3fc28810, 0x3fd29854, 0x3fda8818, 0x3fca985c, 0x3fa00006, 0x3fb01042, 0x3fb8000e, 0x3fa8104a, 0x3fe28816, 0x3ff29852, 0x3ffa881e, 0x3fea985a}, - uint32(0xfff80000), - [21]string{"0xb9", "0xa9", "0xe7", "0x1c", "0xf0", "0x5b", "0x2a", "0xc9", "0x37", "0xc9", "0x7a", "0xa6", "0xd4", "0x4a", "0x80", "0xbc", "0xfa", "0xe6", "0x84", "0xd2", "0x00"}}, - { - /* No.775 delta:908 weight:1351 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0x7217df4e, 0x3e2c12b5, 0x4c3bcdfb, 0x7c603072, 0x0e77ef3c, 0x424c22c7, 0x305bfd89, 0x00009ebd, 0x721741f3, 0x3e2c8c08, 0x4c3b5346, 0x7c60aecf, 0x0e777181, 0x424cbc7a, 0x305b6334}, - [16]uint32{0x00000000, 0x2054581d, 0x006e6117, 0x203a390a, 0x00120e0e, 0x20465613, 0x007c6f19, 0x20283704, 0x0003c5cf, 0x20579dd2, 0x006da4d8, 0x2039fcc5, 0x0011cbc1, 0x204593dc, 0x007faad6, 0x202bf2cb}, - [16]uint32{0x3f800000, 0x3f902a2c, 0x3f803730, 0x3f901d1c, 0x3f800907, 0x3f90232b, 0x3f803e37, 0x3f90141b, 0x3f8001e2, 0x3f902bce, 0x3f8036d2, 0x3f901cfe, 0x3f8008e5, 0x3f9022c9, 0x3f803fd5, 0x3f9015f9}, - uint32(0xfff80000), - [21]string{"0x29", "0xb0", "0x52", "0x73", "0x0b", "0xbe", "0x73", "0x8a", "0x64", "0xbb", "0x9c", "0xfd", "0xd8", "0x30", "0xc9", "0xf5", "0xca", "0xef", "0xb1", "0xce", "0x00"}}, - { - /* No.776 delta:2144 weight:1259 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x6e034128, 0x0dfcc020, 0x63ff8108, 0xad503080, 0xc35371a8, 0xa0acf0a0, 0xceafb188, 0x000070f9, 0x6e0331d1, 0x0dfcb0d9, 0x63fff1f1, 0xad504079, 0xc3530151, 0xa0ac8059, 0xceafc171}, - [16]uint32{0x00000000, 0x4113087a, 0x1aa94da5, 0x5bba45df, 0x2cf23ab3, 0x6de132c9, 0x365b7716, 0x77487f6c, 0x0f000117, 0x4e13096d, 0x15a94cb2, 0x54ba44c8, 0x23f23ba4, 0x62e133de, 0x395b7601, 0x78487e7b}, - [16]uint32{0x3f800000, 0x3fa08984, 0x3f8d54a6, 0x3faddd22, 0x3f96791d, 0x3fb6f099, 0x3f9b2dbb, 0x3fbba43f, 0x3f878000, 0x3fa70984, 0x3f8ad4a6, 0x3faa5d22, 0x3f91f91d, 0x3fb17099, 0x3f9cadbb, 0x3fbc243f}, - uint32(0xfff80000), - [21]string{"0x26", "0x40", "0x6a", "0xc3", "0x59", "0x25", "0xa3", "0xf2", "0x21", "0x1b", "0xa4", "0x65", "0x23", "0xb0", "0x50", "0xbc", "0x88", "0xbd", "0x27", "0xfd", "0x00"}}, - { - /* No.777 delta:762 weight:1025 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0x4434980f, 0x3a259514, 0x7e110d1b, 0x8bb03096, 0xcf84a899, 0xb195a582, 0xf5a13d8d, 0x0000c015, 0x4434581a, 0x3a255501, 0x7e11cd0e, 0x8bb0f083, 0xcf84688c, 0xb1956597, 0xf5a1fd98}, - [16]uint32{0x00000000, 0x104c897a, 0x60021c1f, 0x704e9565, 0x0002021d, 0x104e8b67, 0x60001e02, 0x704c9778, 0x4028ae1c, 0x50642766, 0x202ab203, 0x30663b79, 0x402aac01, 0x5066257b, 0x2028b01e, 0x30643964}, - [16]uint32{0x3f800000, 0x3f882644, 0x3fb0010e, 0x3fb8274a, 0x3f800101, 0x3f882745, 0x3fb0000f, 0x3fb8264b, 0x3fa01457, 0x3fa83213, 0x3f901559, 0x3f98331d, 0x3fa01556, 0x3fa83312, 0x3f901458, 0x3f98321c}, - uint32(0xfff80000), - [21]string{"0x26", "0x58", "0x69", "0x9d", "0xf9", "0x4d", "0x84", "0x59", "0x7f", "0x2f", "0x5d", "0x95", "0x15", "0x69", "0xb3", "0xe4", "0x63", "0xd1", "0x01", "0xd0", "0x00"}}, - { - /* No.778 delta:1053 weight:1429 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x403aeda5, 0xb89b3499, 0xf8a1d93c, 0x863030ac, 0xc60add09, 0x3eab0435, 0x7e91e990, 0x000058f2, 0x403ab557, 0xb89b6c6b, 0xf8a181ce, 0x8630685e, 0xc60a85fb, 0x3eab5cc7, 0x7e91b162}, - [16]uint32{0x00000000, 0x004d11f6, 0x200381f9, 0x204e900f, 0x01066132, 0x014b70c4, 0x2105e0cb, 0x2148f13d, 0x01310c1a, 0x017c1dec, 0x21328de3, 0x217f9c15, 0x00376d28, 0x007a7cde, 0x2034ecd1, 0x2079fd27}, - [16]uint32{0x3f800000, 0x3f802688, 0x3f9001c0, 0x3f902748, 0x3f808330, 0x3f80a5b8, 0x3f9082f0, 0x3f90a478, 0x3f809886, 0x3f80be0e, 0x3f909946, 0x3f90bfce, 0x3f801bb6, 0x3f803d3e, 0x3f901a76, 0x3f903cfe}, - uint32(0xfff80000), - [21]string{"0xaf", "0x6c", "0xd1", "0xfd", "0x66", "0x44", "0x06", "0x5f", "0x92", "0x38", "0x0a", "0x51", "0x68", "0x55", "0xec", "0x41", "0x89", "0xce", "0x87", "0x6d", "0x00"}}, - { - /* No.779 delta:969 weight:1305 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x95f85638, 0xcc15ae7f, 0x59edf847, 0x0ba030bb, 0x9e586683, 0xc7b59ec4, 0x524dc8fc, 0x00004da0, 0x95f81b98, 0xcc15e3df, 0x59edb5e7, 0x0ba07d1b, 0x9e582b23, 0xc7b5d364, 0x524d855c}, - [16]uint32{0x00000000, 0x207483f6, 0x006a01da, 0x201e822c, 0x10038149, 0x307702bf, 0x10698093, 0x301d0365, 0x000050a8, 0x2074d35e, 0x006a5172, 0x201ed284, 0x1003d1e1, 0x30775217, 0x1069d03b, 0x301d53cd}, - [16]uint32{0x3f800000, 0x3f903a41, 0x3f803500, 0x3f900f41, 0x3f8801c0, 0x3f983b81, 0x3f8834c0, 0x3f980e81, 0x3f800028, 0x3f903a69, 0x3f803528, 0x3f900f69, 0x3f8801e8, 0x3f983ba9, 0x3f8834e8, 0x3f980ea9}, - uint32(0xfff80000), - [21]string{"0xa4", "0xb2", "0xff", "0x0b", "0xbf", "0xf7", "0x2a", "0x57", "0xf1", "0x47", "0x2c", "0x03", "0x1b", "0xee", "0xb2", "0xe2", "0x38", "0x2b", "0x8f", "0x82", "0x00"}}, - { - /* No.780 delta:961 weight:1217 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0x064e300b, 0x9b6d41ee, 0x9d2371e5, 0xe55030ca, 0xe31e00c1, 0x7e3d7124, 0x7873412f, 0x0000b361, 0x064e836a, 0x9b6df28f, 0x9d23c284, 0xe55083ab, 0xe31eb3a0, 0x7e3dc245, 0x7873f24e}, - [16]uint32{0x00000000, 0x005c9196, 0x43980db1, 0x43c49c27, 0x00730019, 0x002f918f, 0x43eb0da8, 0x43b79c3e, 0x00084417, 0x0054d581, 0x439049a6, 0x43ccd830, 0x007b440e, 0x0027d598, 0x43e349bf, 0x43bfd829}, - [16]uint32{0x3f800000, 0x3f802e48, 0x3fa1cc06, 0x3fa1e24e, 0x3f803980, 0x3f8017c8, 0x3fa1f586, 0x3fa1dbce, 0x3f800422, 0x3f802a6a, 0x3fa1c824, 0x3fa1e66c, 0x3f803da2, 0x3f8013ea, 0x3fa1f1a4, 0x3fa1dfec}, - uint32(0xfff80000), - [21]string{"0xe4", "0x57", "0xc1", "0xdb", "0xe7", "0x47", "0xcf", "0xc3", "0x84", "0x19", "0xac", "0x63", "0x22", "0xb2", "0xa2", "0x68", "0x9f", "0xfa", "0xe8", "0x13", "0x00"}}, - { - /* No.781 delta:862 weight:1723 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x66a17256, 0x2a0ef328, 0x4caf817e, 0xf29030dd, 0x9431428b, 0xd89ec3f5, 0xbe3fb1a3, 0x000018fd, 0x66a16aab, 0x2a0eebd5, 0x4caf9983, 0xf2902820, 0x94315a76, 0xd89edb08, 0xbe3fa95e}, - [16]uint32{0x00000000, 0x0002121e, 0x00004607, 0x00025419, 0x403dc114, 0x403fd30a, 0x403d8713, 0x403f950d, 0x70512052, 0x7053324c, 0x70516655, 0x7053744b, 0x306ce146, 0x306ef358, 0x306ca741, 0x306eb55f}, - [16]uint32{0x3f800000, 0x3f800109, 0x3f800023, 0x3f80012a, 0x3fa01ee0, 0x3fa01fe9, 0x3fa01ec3, 0x3fa01fca, 0x3fb82890, 0x3fb82999, 0x3fb828b3, 0x3fb829ba, 0x3f983670, 0x3f983779, 0x3f983653, 0x3f98375a}, - uint32(0xfff80000), - [21]string{"0x71", "0x2d", "0xf6", "0xbf", "0x9e", "0x0f", "0x5a", "0x80", "0xca", "0x7f", "0x67", "0x35", "0x3c", "0xdc", "0x18", "0x8d", "0x09", "0xa0", "0xca", "0xd8", "0x00"}}, - { - /* No.782 delta:768 weight:1497 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x8ddebe9c, 0x51cb8ab6, 0xdc15342a, 0xc81030e6, 0x45ce8e7a, 0x99dbba50, 0x140504cc, 0x00008de6, 0x8dde337a, 0x51cb0750, 0xdc15b9cc, 0xc810bd00, 0x45ce039c, 0x99db37b6, 0x1405892a}, - [16]uint32{0x00000000, 0x6020455b, 0x00038839, 0x6023cd62, 0x114da816, 0x716ded4d, 0x114e202f, 0x716e6574, 0x008029a8, 0x60a06cf3, 0x0083a191, 0x60a3e4ca, 0x11cd81be, 0x71edc4e5, 0x11ce0987, 0x71ee4cdc}, - [16]uint32{0x3f800000, 0x3fb01022, 0x3f8001c4, 0x3fb011e6, 0x3f88a6d4, 0x3fb8b6f6, 0x3f88a710, 0x3fb8b732, 0x3f804014, 0x3fb05036, 0x3f8041d0, 0x3fb051f2, 0x3f88e6c0, 0x3fb8f6e2, 0x3f88e704, 0x3fb8f726}, - uint32(0xfff80000), - [21]string{"0x8c", "0xaa", "0x09", "0xbc", "0x86", "0x48", "0x02", "0x9d", "0x6f", "0x30", "0x6b", "0x6d", "0x17", "0xc5", "0xbc", "0x8d", "0x39", "0xea", "0x79", "0x49", "0x00"}}, - { - /* No.783 delta:961 weight:1663 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0x9843dafc, 0xfdd2109a, 0x6591ca66, 0xe58030fa, 0x7dc3ea06, 0x18522060, 0x8011fa9c, 0x00002fbf, 0x9843f543, 0xfdd23f25, 0x6591e5d9, 0xe5801f45, 0x7dc3c5b9, 0x18520fdf, 0x8011d523}, - [16]uint32{0x00000000, 0x006c707c, 0x4059016e, 0x40357112, 0x100e0898, 0x106278e4, 0x505709f6, 0x503b798a, 0x00030015, 0x006f7069, 0x405a017b, 0x40367107, 0x100d088d, 0x106178f1, 0x505409e3, 0x5038799f}, - [16]uint32{0x3f800000, 0x3f803638, 0x3fa02c80, 0x3fa01ab8, 0x3f880704, 0x3f88313c, 0x3fa82b84, 0x3fa81dbc, 0x3f800180, 0x3f8037b8, 0x3fa02d00, 0x3fa01b38, 0x3f880684, 0x3f8830bc, 0x3fa82a04, 0x3fa81c3c}, - uint32(0xfff80000), - [21]string{"0x14", "0x86", "0xa3", "0x96", "0x8a", "0xae", "0x77", "0xe6", "0x0c", "0xb7", "0xdc", "0xce", "0x14", "0xd7", "0xab", "0x98", "0xc0", "0x67", "0x3a", "0xcc", "0x00"}}, - { - /* No.784 delta:1173 weight:1629 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0xb920a94b, 0x1f535a2b, 0xa673f360, 0x5cf03102, 0xe5d09849, 0x43a36b29, 0xfa83c262, 0x00005e55, 0xb920f71e, 0x1f53047e, 0xa673ad35, 0x5cf06f57, 0xe5d0c61c, 0x43a3357c, 0xfa839c37}, - [16]uint32{0x00000000, 0x106860fe, 0x8508891b, 0x9560e9e5, 0x1017100d, 0x007f70f3, 0x951f9916, 0x8577f9e8, 0x406001f0, 0x5008610e, 0xc56888eb, 0xd500e815, 0x507711fd, 0x401f7103, 0xd57f98e6, 0xc517f818}, - [16]uint32{0x3f800000, 0x3f883430, 0x3fc28444, 0x3fcab074, 0x3f880b88, 0x3f803fb8, 0x3fca8fcc, 0x3fc2bbfc, 0x3fa03000, 0x3fa80430, 0x3fe2b444, 0x3fea8074, 0x3fa83b88, 0x3fa00fb8, 0x3feabfcc, 0x3fe28bfc}, - uint32(0xfff80000), - [21]string{"0x18", "0x2f", "0xea", "0xf0", "0x0b", "0x6b", "0x70", "0x7b", "0x34", "0xf1", "0x11", "0xe3", "0x37", "0x94", "0x1d", "0x9b", "0x47", "0x7c", "0xfc", "0x6f", "0x00"}}, - { - /* No.785 delta:754 weight:725 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x8e6006e8, 0x2f91906d, 0xa1f19685, 0xa430311f, 0x2a5037f7, 0x8ba1a172, 0x05c1a79a, 0x0000dc9b, 0x8e60da73, 0x2f914cf6, 0xa1f14a1e, 0xa430ed84, 0x2a50eb6c, 0x8ba17de9, 0x05c17b01}, - [16]uint32{0x00000000, 0x707e0152, 0x60028015, 0x107c8147, 0x5003880a, 0x207d8958, 0x3001081f, 0x407f094d, 0xd0404203, 0xa03e4351, 0xb042c216, 0xc03cc344, 0x8043ca09, 0xf03dcb5b, 0xe0414a1c, 0x903f4b4e}, - [16]uint32{0x3f800000, 0x3fb83f00, 0x3fb00140, 0x3f883e40, 0x3fa801c4, 0x3f903ec4, 0x3f980084, 0x3fa03f84, 0x3fe82021, 0x3fd01f21, 0x3fd82161, 0x3fe01e61, 0x3fc021e5, 0x3ff81ee5, 0x3ff020a5, 0x3fc81fa5}, - uint32(0xfff80000), - [21]string{"0xa7", "0xe0", "0xae", "0x47", "0xae", "0x80", "0xe4", "0x09", "0xe7", "0x6c", "0xba", "0x8e", "0xfc", "0xe2", "0x11", "0xcc", "0xdf", "0x14", "0x25", "0x74", "0x00"}}, - { - /* No.786 delta:743 weight:1217 */ - 11213, - 60, - 13, - 4, - [16]uint32{0x00000000, 0x790b895a, 0x7c905d86, 0x059bd4dc, 0x23b0312e, 0x5abbb874, 0x5f206ca8, 0x262be5f2, 0x00003ab4, 0x790bb3ee, 0x7c906732, 0x059bee68, 0x23b00b9a, 0x5abb82c0, 0x5f20561c, 0x262bdf46}, - [16]uint32{0x00000000, 0x004c625f, 0x2082a015, 0x20cec24a, 0x102420cc, 0x10684293, 0x30a680d9, 0x30eae286, 0x002211b2, 0x006e73ed, 0x20a0b1a7, 0x20ecd3f8, 0x1006317e, 0x104a5321, 0x3084916b, 0x30c8f334}, - [16]uint32{0x3f800000, 0x3f802631, 0x3f904150, 0x3f906761, 0x3f881210, 0x3f883421, 0x3f985340, 0x3f987571, 0x3f801108, 0x3f803739, 0x3f905058, 0x3f907669, 0x3f880318, 0x3f882529, 0x3f984248, 0x3f986479}, - uint32(0xfff80000), - [21]string{"0x7c", "0x29", "0xc6", "0xea", "0x79", "0x83", "0x6b", "0xe5", "0x3e", "0xb7", "0x4b", "0x60", "0x7e", "0xc7", "0x7e", "0x2d", "0xa2", "0x8d", "0x01", "0xa4", "0x00"}}, - { - /* No.787 delta:672 weight:1573 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0x3d1fcedf, 0x15073d04, 0x2818f3db, 0x7a70313f, 0x476fffe0, 0x6f770c3b, 0x5268c2e4, 0x0000a334, 0x3d1f6deb, 0x15079e30, 0x281850ef, 0x7a70920b, 0x476f5cd4, 0x6f77af0f, 0x526861d0}, - [16]uint32{0x00000000, 0x08ec5bd6, 0x30025c11, 0x38ee07c7, 0x00025012, 0x08ee0bc4, 0x30000c03, 0x38ec57d5, 0x600420c9, 0x68e87b1f, 0x50067cd8, 0x58ea270e, 0x600670db, 0x68ea2b0d, 0x50042cca, 0x58e8771c}, - [16]uint32{0x3f800000, 0x3f84762d, 0x3f98012e, 0x3f9c7703, 0x3f800128, 0x3f847705, 0x3f980006, 0x3f9c762b, 0x3fb00210, 0x3fb4743d, 0x3fa8033e, 0x3fac7513, 0x3fb00338, 0x3fb47515, 0x3fa80216, 0x3fac743b}, - uint32(0xfff80000), - [21]string{"0x81", "0x17", "0xed", "0xca", "0x47", "0xb2", "0x2a", "0xcc", "0x79", "0x10", "0x4e", "0x1d", "0x6e", "0x2a", "0x18", "0x53", "0x51", "0x7f", "0x87", "0x55", "0x00"}}, - { - /* No.788 delta:3119 weight:595 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x3270e2e3, 0x313b2b25, 0x034bc9c6, 0x19803145, 0x2bf0d3a6, 0x28bb1a60, 0x1acbf883, 0x00004b15, 0x3270a9f6, 0x313b6030, 0x034b82d3, 0x19807a50, 0x2bf098b3, 0x28bb5175, 0x1acbb396}, - [16]uint32{0x00000000, 0xe06201a3, 0x142a0079, 0xf44801da, 0x08c0c16b, 0xe8a2c0c8, 0x1ceac112, 0xfc88c0b1, 0x20208818, 0xc04289bb, 0x340a8861, 0xd46889c2, 0x28e04973, 0xc88248d0, 0x3cca490a, 0xdca848a9}, - [16]uint32{0x3f800000, 0x3ff03100, 0x3f8a1500, 0x3ffa2400, 0x3f846060, 0x3ff45160, 0x3f8e7560, 0x3ffe4460, 0x3f901044, 0x3fe02144, 0x3f9a0544, 0x3fea3444, 0x3f947024, 0x3fe44124, 0x3f9e6524, 0x3fee5424}, - uint32(0xfff80000), - [21]string{"0x24", "0x91", "0x3f", "0x38", "0x15", "0x1c", "0x00", "0x79", "0x3c", "0xcd", "0xeb", "0x78", "0xa5", "0xb1", "0xd0", "0xdf", "0xb4", "0x78", "0x73", "0x0b", "0x00"}}, - { - /* No.789 delta:779 weight:1341 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x66a7aefd, 0x2031efa7, 0x4696415a, 0x88503156, 0xeef79fab, 0xa861def1, 0xcec6700c, 0x00004147, 0x66a7efba, 0x2031aee0, 0x4696001d, 0x88507011, 0xeef7deec, 0xa8619fb6, 0xcec6314b}, - [16]uint32{0x00000000, 0x605800d5, 0x90220616, 0xf07a06c3, 0x30424158, 0x501a418d, 0xa060474e, 0xc038479b, 0x00099401, 0x605194d4, 0x902b9217, 0xf07392c2, 0x304bd559, 0x5013d58c, 0xa069d34f, 0xc031d39a}, - [16]uint32{0x3f800000, 0x3fb02c00, 0x3fc81103, 0x3ff83d03, 0x3f982120, 0x3fa80d20, 0x3fd03023, 0x3fe01c23, 0x3f8004ca, 0x3fb028ca, 0x3fc815c9, 0x3ff839c9, 0x3f9825ea, 0x3fa809ea, 0x3fd034e9, 0x3fe018e9}, - uint32(0xfff80000), - [21]string{"0x83", "0xd9", "0xb1", "0xf5", "0xb7", "0x1e", "0xcd", "0x02", "0x95", "0xab", "0xfa", "0x46", "0x38", "0xaa", "0xdb", "0xd5", "0x5f", "0xb7", "0x0f", "0x02", "0x00"}}, - { - /* No.790 delta:1009 weight:1375 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xd3009b2d, 0xf6de0a36, 0x25de911b, 0x00803166, 0xd380aa4b, 0xf65e3b50, 0x255ea07d, 0x0000fe53, 0xd300657e, 0xf6def465, 0x25de6f48, 0x0080cf35, 0xd3805418, 0xf65ec503, 0x255e5e2e}, - [16]uint32{0x00000000, 0x604c01be, 0xe02821fc, 0x80642042, 0x0079c0ca, 0x6035c174, 0xe051e136, 0x801de088, 0x0006119f, 0x604a1021, 0xe02e3063, 0x806231dd, 0x007fd155, 0x6033d0eb, 0xe057f0a9, 0x801bf117}, - [16]uint32{0x3f800000, 0x3fb02600, 0x3ff01410, 0x3fc03210, 0x3f803ce0, 0x3fb01ae0, 0x3ff028f0, 0x3fc00ef0, 0x3f800308, 0x3fb02508, 0x3ff01718, 0x3fc03118, 0x3f803fe8, 0x3fb019e8, 0x3ff02bf8, 0x3fc00df8}, - uint32(0xfff80000), - [21]string{"0x66", "0xf0", "0xfc", "0x95", "0x59", "0xac", "0x7f", "0xa0", "0x86", "0xe2", "0x45", "0x61", "0x7d", "0x9d", "0xa4", "0x42", "0x54", "0x1d", "0x62", "0xb6", "0x00"}}, - { - /* No.791 delta:799 weight:1631 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x984d4dce, 0xd3197c7c, 0x4b5431b2, 0x93b03171, 0x0bfd7cbf, 0x40a94d0d, 0xd8e400c3, 0x00006580, 0x984d284e, 0xd31919fc, 0x4b545432, 0x93b054f1, 0x0bfd193f, 0x40a9288d, 0xd8e46543}, - [16]uint32{0x00000000, 0x2100313a, 0x2006080b, 0x01063931, 0xb00011ac, 0x91002096, 0x900619a7, 0xb106289d, 0x00401204, 0x2140233e, 0x20461a0f, 0x01462b35, 0xb04003a8, 0x91403292, 0x90460ba3, 0xb1463a99}, - [16]uint32{0x3f800000, 0x3f908018, 0x3f900304, 0x3f80831c, 0x3fd80008, 0x3fc88010, 0x3fc8030c, 0x3fd88314, 0x3f802009, 0x3f90a011, 0x3f90230d, 0x3f80a315, 0x3fd82001, 0x3fc8a019, 0x3fc82305, 0x3fd8a31d}, - uint32(0xfff80000), - [21]string{"0x1a", "0x48", "0x24", "0x36", "0xb2", "0x6a", "0xfc", "0x6e", "0x90", "0x45", "0x87", "0x65", "0xb5", "0x3f", "0x72", "0xdb", "0x04", "0x6b", "0x27", "0x1a", "0x00"}}, - { - /* No.792 delta:2000 weight:1417 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x76cd7a5b, 0x3a968880, 0x4c5bf2db, 0xe7b03183, 0x917d4bd8, 0xdd26b903, 0xabebc358, 0x0000d01b, 0x76cdaa40, 0x3a96589b, 0x4c5b22c0, 0xe7b0e198, 0x917d9bc3, 0xdd266918, 0xabeb1343}, - [16]uint32{0x00000000, 0x0014a53e, 0x701e80ca, 0x700a25f4, 0x00020032, 0x0016a50c, 0x701c80f8, 0x700825c6, 0x404000d5, 0x4054a5eb, 0x305e801f, 0x304a2521, 0x404200e7, 0x4056a5d9, 0x305c802d, 0x30482513}, - [16]uint32{0x3f800000, 0x3f800a52, 0x3fb80f40, 0x3fb80512, 0x3f800100, 0x3f800b52, 0x3fb80e40, 0x3fb80412, 0x3fa02000, 0x3fa02a52, 0x3f982f40, 0x3f982512, 0x3fa02100, 0x3fa02b52, 0x3f982e40, 0x3f982412}, - uint32(0xfff80000), - [21]string{"0xdf", "0x52", "0xc6", "0xa6", "0xe7", "0xd1", "0xbb", "0x5e", "0x82", "0xd2", "0x56", "0x7b", "0x34", "0x62", "0x02", "0x2e", "0x8a", "0x7d", "0xa0", "0xf0", "0x00"}}, - { - /* No.793 delta:1031 weight:1599 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x0f33f8b5, 0x1f196f03, 0x102a97b6, 0xd8003196, 0xd733c923, 0xc7195e95, 0xc82aa620, 0x0000b1f1, 0x0f334944, 0x1f19def2, 0x102a2647, 0xd8008067, 0xd73378d2, 0xc719ef64, 0xc82a17d1}, - [16]uint32{0x00000000, 0x104990b6, 0x005c016c, 0x101591da, 0x0002e01f, 0x104b70a9, 0x005ee173, 0x101771c5, 0x0001f1b8, 0x1048610e, 0x005df0d4, 0x10146062, 0x000311a7, 0x104a8111, 0x005f10cb, 0x1016807d}, - [16]uint32{0x3f800000, 0x3f8824c8, 0x3f802e00, 0x3f880ac8, 0x3f800170, 0x3f8825b8, 0x3f802f70, 0x3f880bb8, 0x3f8000f8, 0x3f882430, 0x3f802ef8, 0x3f880a30, 0x3f800188, 0x3f882540, 0x3f802f88, 0x3f880b40}, - uint32(0xfff80000), - [21]string{"0x62", "0x20", "0x35", "0xdc", "0x41", "0x58", "0xba", "0xc6", "0x82", "0xa5", "0xda", "0xf3", "0xb2", "0xf1", "0xef", "0xfc", "0xc8", "0xd2", "0x30", "0x92", "0x00"}}, - { - /* No.794 delta:1221 weight:1465 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x7afadb16, 0x64cdd530, 0x1e370e26, 0x19f031a7, 0x630aeab1, 0x7d3de497, 0x07c73f81, 0x0000f2c0, 0x7afa29d6, 0x64cd27f0, 0x1e37fce6, 0x19f0c367, 0x630a1871, 0x7d3d1657, 0x07c7cd41}, - [16]uint32{0x00000000, 0x3025c356, 0x60067aad, 0x5023b9fb, 0x10406402, 0x2065a754, 0x70461eaf, 0x4063ddf9, 0x00051268, 0x3020d13e, 0x600368c5, 0x5026ab93, 0x1045766a, 0x2060b53c, 0x70430cc7, 0x4066cf91}, - [16]uint32{0x3f800000, 0x3f9812e1, 0x3fb0033d, 0x3fa811dc, 0x3f882032, 0x3f9032d3, 0x3fb8230f, 0x3fa031ee, 0x3f800289, 0x3f981068, 0x3fb001b4, 0x3fa81355, 0x3f8822bb, 0x3f90305a, 0x3fb82186, 0x3fa03367}, - uint32(0xfff80000), - [21]string{"0xb3", "0x8c", "0x0a", "0x5e", "0xb1", "0x44", "0xa4", "0x47", "0x8f", "0x6c", "0x16", "0x5a", "0x0c", "0x84", "0x45", "0x8a", "0x30", "0xb4", "0xa9", "0x8f", "0x00"}}, - { - /* No.795 delta:866 weight:1655 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x2b6e1893, 0x3aa6f805, 0x11c8e096, 0x313031ba, 0x1a5e2929, 0x0b96c9bf, 0x20f8d12c, 0x00009710, 0x2b6e8f83, 0x3aa66f15, 0x11c87786, 0x3130a6aa, 0x1a5ebe39, 0x0b965eaf, 0x20f8463c}, - [16]uint32{0x00000000, 0x2006e413, 0x000229ff, 0x2004cdec, 0x10001a02, 0x3006fe11, 0x100233fd, 0x3004d7ee, 0x60440019, 0x4042e40a, 0x604629e6, 0x4040cdf5, 0x70441a1b, 0x5042fe08, 0x704633e4, 0x5040d7f7}, - [16]uint32{0x3f800000, 0x3f900372, 0x3f800114, 0x3f900266, 0x3f88000d, 0x3f98037f, 0x3f880119, 0x3f98026b, 0x3fb02200, 0x3fa02172, 0x3fb02314, 0x3fa02066, 0x3fb8220d, 0x3fa8217f, 0x3fb82319, 0x3fa8206b}, - uint32(0xfff80000), - [21]string{"0xae", "0x10", "0xf8", "0x61", "0xf3", "0xbc", "0x6b", "0xed", "0x3f", "0xfe", "0x5b", "0x34", "0xef", "0x50", "0x04", "0x9d", "0x58", "0x38", "0x62", "0x04", "0x00"}}, - { - /* No.796 delta:1066 weight:1613 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0xa010cdae, 0x03de5640, 0xa3ce9bee, 0x416031c2, 0xe170fc6c, 0x42be6782, 0xe2aeaa2c, 0x000076eb, 0xa010bb45, 0x03de20ab, 0xa3ceed05, 0x41604729, 0xe1708a87, 0x42be1169, 0xe2aedcc7}, - [16]uint32{0x00000000, 0x1005549a, 0x304c6014, 0x2049348e, 0x106ac401, 0x006f909b, 0x2026a415, 0x3023f08f, 0x10016812, 0x00043c88, 0x204d0806, 0x30485c9c, 0x006bac13, 0x106ef889, 0x3027cc07, 0x2022989d}, - [16]uint32{0x3f800000, 0x3f8802aa, 0x3f982630, 0x3f90249a, 0x3f883562, 0x3f8037c8, 0x3f901352, 0x3f9811f8, 0x3f8800b4, 0x3f80021e, 0x3f902684, 0x3f98242e, 0x3f8035d6, 0x3f88377c, 0x3f9813e6, 0x3f90114c}, - uint32(0xfff80000), - [21]string{"0x63", "0x6a", "0xb4", "0xc4", "0x16", "0x81", "0x2f", "0xf4", "0xd6", "0x23", "0x35", "0x2c", "0xd3", "0xd0", "0x72", "0x56", "0x83", "0xe4", "0x08", "0x26", "0x00"}}, - { - /* No.797 delta:976 weight:1693 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xe6b8c054, 0xb3d41b91, 0x556cdbc5, 0x19d031dc, 0xff68f188, 0xaa042a4d, 0x4cbcea19, 0x0000d097, 0xe6b810c3, 0xb3d4cb06, 0x556c0b52, 0x19d0e14b, 0xff68211f, 0xaa04fada, 0x4cbc3a8e}, - [16]uint32{0x00000000, 0x04003e12, 0x5000140e, 0x54002a1c, 0x900002a3, 0x94003cb1, 0xc00016ad, 0xc40028bf, 0xb0100019, 0xb4103e0b, 0xe0101417, 0xe4102a05, 0x201002ba, 0x24103ca8, 0x701016b4, 0x741028a6}, - [16]uint32{0x3f800000, 0x3f82001f, 0x3fa8000a, 0x3faa0015, 0x3fc80001, 0x3fca001e, 0x3fe0000b, 0x3fe20014, 0x3fd80800, 0x3fda081f, 0x3ff0080a, 0x3ff20815, 0x3f900801, 0x3f92081e, 0x3fb8080b, 0x3fba0814}, - uint32(0xfff80000), - [21]string{"0xdc", "0x15", "0x75", "0xab", "0x23", "0xde", "0x4b", "0x39", "0x98", "0xfe", "0xaf", "0xdf", "0xba", "0xd8", "0x57", "0xf1", "0x7c", "0x2c", "0x1b", "0xde", "0x00"}}, - { - /* No.798 delta:1013 weight:1599 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0x75967d97, 0x6ee4ce50, 0x1b72b3c7, 0xfc8031ed, 0x89164c7a, 0x9264ffbd, 0xe7f2822a, 0x0000fb30, 0x759686a7, 0x6ee43560, 0x1b7248f7, 0xfc80cadd, 0x8916b74a, 0x9264048d, 0xe7f2791a}, - [16]uint32{0x00000000, 0x540b0856, 0x2060c973, 0x746bc125, 0x90480c0b, 0xc443045d, 0xb028c578, 0xe423cd2e, 0x0002840c, 0x54098c5a, 0x20624d7f, 0x74694529, 0x904a8807, 0xc4418051, 0xb02a4174, 0xe4214922}, - [16]uint32{0x3f800000, 0x3faa0584, 0x3f903064, 0x3fba35e0, 0x3fc82406, 0x3fe22182, 0x3fd81462, 0x3ff211e6, 0x3f800142, 0x3faa04c6, 0x3f903126, 0x3fba34a2, 0x3fc82544, 0x3fe220c0, 0x3fd81520, 0x3ff210a4}, - uint32(0xfff80000), - [21]string{"0x59", "0xe2", "0x25", "0x14", "0xa2", "0x7b", "0x51", "0xd4", "0xee", "0x11", "0x99", "0x37", "0xdb", "0x97", "0xe1", "0xca", "0x54", "0x44", "0x09", "0xbd", "0x00"}}, - { - /* No.799 delta:2643 weight:883 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0xc6656f9f, 0x199c52c8, 0xdff93d57, 0x466031f7, 0x80055e68, 0x5ffc633f, 0x99990ca0, 0x0000fd3a, 0xc66592a5, 0x199caff2, 0xdff9c06d, 0x4660cccd, 0x8005a352, 0x5ffc9e05, 0x9999f19a}, - [16]uint32{0x00000000, 0xa22500b6, 0x14208118, 0xb60581ae, 0x1a100035, 0xb8350083, 0x0e30812d, 0xac15819b, 0x95964019, 0x37b340af, 0x81b6c101, 0x2393c1b7, 0x8f86402c, 0x2da3409a, 0x9ba6c134, 0x3983c182}, - [16]uint32{0x3f800000, 0x3fd11280, 0x3f8a1040, 0x3fdb02c0, 0x3f8d0800, 0x3fdc1a80, 0x3f871840, 0x3fd60ac0, 0x3fcacb20, 0x3f9bd9a0, 0x3fc0db60, 0x3f91c9e0, 0x3fc7c320, 0x3f96d1a0, 0x3fcdd360, 0x3f9cc1e0}, - uint32(0xfff80000), - [21]string{"0xed", "0x6c", "0xf0", "0xbe", "0x91", "0x9b", "0x82", "0x55", "0x81", "0x47", "0x0e", "0xd8", "0x02", "0x39", "0x04", "0x9c", "0x23", "0xc5", "0xa4", "0x7a", "0x00"}}, - { - /* No.800 delta:807 weight:1521 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xeca160b8, 0x8f015ca1, 0x63a03c19, 0x7ca03200, 0x900152b8, 0xf3a16ea1, 0x1f000e19, 0x000082e3, 0xeca1e25b, 0x8f01de42, 0x63a0befa, 0x7ca0b0e3, 0x9001d05b, 0xf3a1ec42, 0x1f008cfa}, - [16]uint32{0x00000000, 0x401e0216, 0x00024b6a, 0x401c497c, 0x11051947, 0x511b1b51, 0x1107522d, 0x5119503b, 0x00010204, 0x401f0012, 0x0003496e, 0x401d4b78, 0x11041b43, 0x511a1955, 0x11065029, 0x5118523f}, - [16]uint32{0x3f800000, 0x3fa00f01, 0x3f800125, 0x3fa00e24, 0x3f88828c, 0x3fa88d8d, 0x3f8883a9, 0x3fa88ca8, 0x3f800081, 0x3fa00f80, 0x3f8001a4, 0x3fa00ea5, 0x3f88820d, 0x3fa88d0c, 0x3f888328, 0x3fa88c29}, - uint32(0xfff80000), - [21]string{"0x20", "0xa1", "0x1b", "0x58", "0xd3", "0xc0", "0x8f", "0xdd", "0xc8", "0xa8", "0xd2", "0xde", "0x38", "0xaa", "0xf1", "0xfe", "0x43", "0xff", "0xcd", "0xe3", "0x00"}}, - { - /* No.801 delta:1758 weight:1601 */ - 11213, - 12, - 13, - 4, - [16]uint32{0x00000000, 0x5a625a10, 0x232758be, 0x794502ae, 0x82d03213, 0xd8b26803, 0xa1f76aad, 0xfb9530bd, 0x00003216, 0x5a626806, 0x23276aa8, 0x794530b8, 0x82d00005, 0xd8b25a15, 0xa1f758bb, 0xfb9502ab}, - [16]uint32{0x00000000, 0x84a561f6, 0x1042809b, 0x94e7e16d, 0x01288114, 0x858de0e2, 0x116a018f, 0x95cf6079, 0x091981a4, 0x8dbce052, 0x195b013f, 0x9dfe60c9, 0x083100b0, 0x8c946146, 0x1873802b, 0x9cd6e1dd}, - [16]uint32{0x3f800000, 0x3fc252b0, 0x3f882140, 0x3fca73f0, 0x3f809440, 0x3fc2c6f0, 0x3f88b500, 0x3fcae7b0, 0x3f848cc0, 0x3fc6de70, 0x3f8cad80, 0x3fceff30, 0x3f841880, 0x3fc64a30, 0x3f8c39c0, 0x3fce6b70}, - uint32(0xfff80000), - [21]string{"0xd5", "0x27", "0xba", "0xce", "0xb3", "0x85", "0x59", "0xe5", "0xc8", "0xe3", "0x97", "0x73", "0x8e", "0xc3", "0x3e", "0xef", "0xac", "0x4c", "0xa3", "0xa1", "0x00"}}, - { - /* No.802 delta:922 weight:1533 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x0abb479f, 0x299530f4, 0x232e776b, 0x3590322e, 0x3f2b75b1, 0x1c0502da, 0x16be4545, 0x00003c8d, 0x0abb7b12, 0x29950c79, 0x232e4be6, 0x35900ea3, 0x3f2b493c, 0x1c053e57, 0x16be79c8}, - [16]uint32{0x00000000, 0x007640fd, 0x000a00b2, 0x007c404f, 0x50213805, 0x505778f8, 0x502b38b7, 0x505d784a, 0x00022019, 0x007460e4, 0x000820ab, 0x007e6056, 0x5023181c, 0x505558e1, 0x502918ae, 0x505f5853}, - [16]uint32{0x3f800000, 0x3f803b20, 0x3f800500, 0x3f803e20, 0x3fa8109c, 0x3fa82bbc, 0x3fa8159c, 0x3fa82ebc, 0x3f800110, 0x3f803a30, 0x3f800410, 0x3f803f30, 0x3fa8118c, 0x3fa82aac, 0x3fa8148c, 0x3fa82fac}, - uint32(0xfff80000), - [21]string{"0x74", "0xcf", "0xe4", "0x03", "0xe3", "0x08", "0xa1", "0xe8", "0x47", "0x37", "0x52", "0x67", "0x79", "0x0c", "0x6e", "0xd3", "0xf6", "0x43", "0x7b", "0xb9", "0x00"}}, - { - /* No.803 delta:970 weight:1003 */ - 11213, - 89, - 13, - 4, - [16]uint32{0x00000000, 0x0c088765, 0xac99bbcb, 0xa0913cae, 0xa5c0323f, 0xa9c8b55a, 0x095989f4, 0x05510e91, 0x0000024d, 0x0c088528, 0xac99b986, 0xa0913ee3, 0xa5c03072, 0xa9c8b717, 0x09598bb9, 0x05510cdc}, - [16]uint32{0x00000000, 0x47a7b8df, 0x68a45b06, 0x2f03e3d9, 0x400109b4, 0x07a6b16b, 0x28a552b2, 0x6f02ea6d, 0x7090101a, 0x3737a8c5, 0x18344b1c, 0x5f93f3c3, 0x309119ae, 0x7736a171, 0x583542a8, 0x1f92fa77}, - [16]uint32{0x3f800000, 0x3fa3d3dc, 0x3fb4522d, 0x3f9781f1, 0x3fa00084, 0x3f83d358, 0x3f9452a9, 0x3fb78175, 0x3fb84808, 0x3f9b9bd4, 0x3f8c1a25, 0x3fafc9f9, 0x3f98488c, 0x3fbb9b50, 0x3fac1aa1, 0x3f8fc97d}, - uint32(0xfff80000), - [21]string{"0x88", "0x0a", "0xc2", "0xe5", "0x7a", "0xb5", "0x91", "0x78", "0x7a", "0x44", "0x03", "0xd3", "0xae", "0x99", "0x83", "0xbd", "0x08", "0xfb", "0x31", "0x5c", "0x00"}}, - { - /* No.804 delta:754 weight:1363 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0xbbc6a6ed, 0xf745e84f, 0x4c834ea2, 0xe440324c, 0x5f8694a1, 0x1305da03, 0xa8c37cee, 0x0000003f, 0xbbc6a6d2, 0xf745e870, 0x4c834e9d, 0xe4403273, 0x5f86949e, 0x1305da3c, 0xa8c37cd1}, - [16]uint32{0x00000000, 0x800067f6, 0x01033a0d, 0x81035dfb, 0x40008609, 0xc000e1ff, 0x4103bc04, 0xc103dbf2, 0x5002c21e, 0xd002a5e8, 0x5101f813, 0xd1019fe5, 0x10024417, 0x900223e1, 0x11017e1a, 0x910119ec}, - [16]uint32{0x3f800000, 0x3fc00033, 0x3f80819d, 0x3fc081ae, 0x3fa00043, 0x3fe00070, 0x3fa081de, 0x3fe081ed, 0x3fa80161, 0x3fe80152, 0x3fa880fc, 0x3fe880cf, 0x3f880122, 0x3fc80111, 0x3f8880bf, 0x3fc8808c}, - uint32(0xfff80000), - [21]string{"0x6f", "0xd8", "0x43", "0xc4", "0x8c", "0x9b", "0x48", "0x62", "0xfa", "0x67", "0xcb", "0x19", "0x6b", "0xa8", "0xe1", "0xee", "0xac", "0xfb", "0x9c", "0xc4", "0x00"}}, - { - /* No.805 delta:878 weight:1627 */ - 11213, - 48, - 13, - 4, - [16]uint32{0x00000000, 0x9664e72f, 0x44701dfa, 0xd214fad5, 0x07103250, 0x9174d57f, 0x43602faa, 0xd504c885, 0x0000caf7, 0x96642dd8, 0x4470d70d, 0xd2143022, 0x0710f8a7, 0x91741f88, 0x4360e55d, 0xd5040272}, - [16]uint32{0x00000000, 0x20055412, 0x0008f05e, 0x200da44c, 0x00222e03, 0x20277a11, 0x002ade5d, 0x202f8a4f, 0x30000018, 0x1005540a, 0x3008f046, 0x100da454, 0x30222e1b, 0x10277a09, 0x302ade45, 0x102f8a57}, - [16]uint32{0x3f800000, 0x3f9002aa, 0x3f800478, 0x3f9006d2, 0x3f801117, 0x3f9013bd, 0x3f80156f, 0x3f9017c5, 0x3f980000, 0x3f8802aa, 0x3f980478, 0x3f8806d2, 0x3f981117, 0x3f8813bd, 0x3f98156f, 0x3f8817c5}, - uint32(0xfff80000), - [21]string{"0x7f", "0xdb", "0x48", "0x77", "0x81", "0x32", "0x34", "0x75", "0xb7", "0x8b", "0x80", "0xf6", "0x46", "0x7a", "0x2a", "0xa6", "0x28", "0x66", "0x71", "0xf2", "0x00"}}, - { - /* No.806 delta:790 weight:1135 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0xdf7087e0, 0xd4f7d780, 0x0b875060, 0x3860326e, 0xe710b58e, 0xec97e5ee, 0x33e7620e, 0x0000e8fc, 0xdf706f1c, 0xd4f73f7c, 0x0b87b89c, 0x3860da92, 0xe7105d72, 0xec970d12, 0x33e78af2}, - [16]uint32{0x00000000, 0x000210bb, 0x1001820d, 0x100392b6, 0x480900fe, 0x480b1045, 0x580882f3, 0x580a9248, 0x4000c174, 0x4002d1cf, 0x50014379, 0x500353c2, 0x0809c18a, 0x080bd131, 0x18084387, 0x180a533c}, - [16]uint32{0x3f800000, 0x3f800108, 0x3f8800c1, 0x3f8801c9, 0x3fa40480, 0x3fa40588, 0x3fac0441, 0x3fac0549, 0x3fa00060, 0x3fa00168, 0x3fa800a1, 0x3fa801a9, 0x3f8404e0, 0x3f8405e8, 0x3f8c0421, 0x3f8c0529}, - uint32(0xfff80000), - [21]string{"0xfa", "0xef", "0x9b", "0x27", "0xb1", "0x8c", "0x21", "0x7d", "0xe6", "0x46", "0x15", "0x6c", "0xb3", "0x6b", "0xba", "0xa9", "0x4a", "0x02", "0x41", "0x4c", "0x00"}}, - { - /* No.807 delta:1102 weight:761 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x554a2d17, 0xf1444969, 0xa40e647e, 0x91f03278, 0xc4ba1f6f, 0x60b47b11, 0x35fe5606, 0x00006026, 0x554a4d31, 0xf144294f, 0xa40e0458, 0x91f0525e, 0xc4ba7f49, 0x60b41b37, 0x35fe3620}, - [16]uint32{0x00000000, 0x00628c5a, 0x800401ab, 0x80668df1, 0x71010172, 0x71638d28, 0xf10500d9, 0xf1678c83, 0x4003401e, 0x4061cc44, 0xc00741b5, 0xc065cdef, 0x3102416c, 0x3160cd36, 0xb10640c7, 0xb164cc9d}, - [16]uint32{0x3f800000, 0x3f803146, 0x3fc00200, 0x3fc03346, 0x3fb88080, 0x3fb8b1c6, 0x3ff88280, 0x3ff8b3c6, 0x3fa001a0, 0x3fa030e6, 0x3fe003a0, 0x3fe032e6, 0x3f988120, 0x3f98b066, 0x3fd88320, 0x3fd8b266}, - uint32(0xfff80000), - [21]string{"0x56", "0x61", "0x8f", "0x09", "0xef", "0x5c", "0x30", "0xdc", "0x40", "0xd0", "0x9e", "0xe6", "0x92", "0x9d", "0x61", "0x5d", "0x16", "0x8c", "0x01", "0x2f", "0x00"}}, - { - /* No.808 delta:2004 weight:1653 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0x2df15ce5, 0xcf48aa2c, 0xe2b9f6c9, 0x71903288, 0x5c616e6d, 0xbed898a4, 0x9329c441, 0x00004e1b, 0x2df112fe, 0xcf48e437, 0xe2b9b8d2, 0x71907c93, 0x5c612076, 0xbed8d6bf, 0x93298a5a}, - [16]uint32{0x00000000, 0x0002a19a, 0x004c81f4, 0x004e206e, 0x085001b9, 0x0852a023, 0x081c804d, 0x081e21d7, 0x00280011, 0x002aa18b, 0x006481e5, 0x0066207f, 0x087801a8, 0x087aa032, 0x0834805c, 0x083621c6}, - [16]uint32{0x3f800000, 0x3f800150, 0x3f802640, 0x3f802710, 0x3f842800, 0x3f842950, 0x3f840e40, 0x3f840f10, 0x3f801400, 0x3f801550, 0x3f803240, 0x3f803310, 0x3f843c00, 0x3f843d50, 0x3f841a40, 0x3f841b10}, - uint32(0xfff80000), - [21]string{"0x99", "0x97", "0x4e", "0xed", "0x12", "0x8b", "0xec", "0xf2", "0xbb", "0x81", "0xe0", "0x91", "0x1c", "0xd8", "0x16", "0x3b", "0xc8", "0xa6", "0x67", "0x1a", "0x00"}}, - { - /* No.809 delta:1097 weight:1243 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0x0ead4746, 0xedc30260, 0xe36e4526, 0x0cd03297, 0x027d75d1, 0xe11330f7, 0xefbe77b1, 0x000052c0, 0x0ead1586, 0xedc350a0, 0xe36e17e6, 0x0cd06057, 0x027d2711, 0xe1136237, 0xefbe2571}, - [16]uint32{0x00000000, 0xc0018afe, 0x007c18bd, 0xc07d9243, 0x40030051, 0x80028aaf, 0x407f18ec, 0x807e9212, 0x8001414b, 0x4000cbb5, 0x807d59f6, 0x407cd308, 0xc002411a, 0x0003cbe4, 0xc07e59a7, 0x007fd359}, - [16]uint32{0x3f800000, 0x3fe000c5, 0x3f803e0c, 0x3fe03ec9, 0x3fa00180, 0x3fc00145, 0x3fa03f8c, 0x3fc03f49, 0x3fc000a0, 0x3fa00065, 0x3fc03eac, 0x3fa03e69, 0x3fe00120, 0x3f8001e5, 0x3fe03f2c, 0x3f803fe9}, - uint32(0xfff80000), - [21]string{"0x53", "0x9d", "0x15", "0xec", "0x0c", "0x8f", "0x50", "0x9b", "0x06", "0x13", "0x63", "0xd7", "0x20", "0xa0", "0x37", "0xe3", "0xb5", "0x31", "0x8d", "0x59", "0x00"}}, - { - /* No.810 delta:1986 weight:925 */ - 11213, - 51, - 13, - 4, - [16]uint32{0x00000000, 0x92b74108, 0x7385356f, 0xe1327467, 0x2ab032a5, 0xb80773ad, 0x593507ca, 0xcb8246c2, 0x000030cf, 0x92b771c7, 0x738505a0, 0xe13244a8, 0x2ab0026a, 0xb8074362, 0x59353705, 0xcb82760d}, - [16]uint32{0x00000000, 0x5000081e, 0x200001af, 0x700009b1, 0x0000004c, 0x50000852, 0x200001e3, 0x700009fd, 0xc00000ba, 0x900008a4, 0xe0000115, 0xb000090b, 0xc00000f6, 0x900008e8, 0xe0000159, 0xb0000947}, - [16]uint32{0x3f800000, 0x3fa80004, 0x3f900000, 0x3fb80004, 0x3f800000, 0x3fa80004, 0x3f900000, 0x3fb80004, 0x3fe00000, 0x3fc80004, 0x3ff00000, 0x3fd80004, 0x3fe00000, 0x3fc80004, 0x3ff00000, 0x3fd80004}, - uint32(0xfff80000), - [21]string{"0xa3", "0x6d", "0x7c", "0x6d", "0xec", "0xf1", "0x21", "0x0d", "0x4d", "0x42", "0x61", "0x56", "0xc2", "0x58", "0xa6", "0xaf", "0xaa", "0xba", "0x41", "0xfb", "0x00"}}, - { - /* No.811 delta:911 weight:963 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0xd7591026, 0xa84f7daa, 0x7f166d8c, 0xdea032bd, 0x09f9229b, 0x76ef4f17, 0xa1b65f31, 0x0000bfd4, 0xd759aff2, 0xa84fc27e, 0x7f16d258, 0xdea08d69, 0x09f99d4f, 0x76eff0c3, 0xa1b6e0e5}, - [16]uint32{0x00000000, 0x006d25fa, 0x50280171, 0x5045248b, 0x201a10ff, 0x20773505, 0x7032118e, 0x705f3474, 0x200841bc, 0x20656446, 0x702040cd, 0x704d6537, 0x00125143, 0x007f74b9, 0x503a5032, 0x505775c8}, - [16]uint32{0x3f800000, 0x3f803692, 0x3fa81400, 0x3fa82292, 0x3f900d08, 0x3f903b9a, 0x3fb81908, 0x3fb82f9a, 0x3f900420, 0x3f9032b2, 0x3fb81020, 0x3fb826b2, 0x3f800928, 0x3f803fba, 0x3fa81d28, 0x3fa82bba}, - uint32(0xfff80000), - [21]string{"0x14", "0x08", "0x9b", "0x06", "0xda", "0x10", "0x86", "0xf5", "0xb3", "0x33", "0x2e", "0xcd", "0x4c", "0xd8", "0x51", "0x8d", "0x1f", "0xc7", "0x97", "0x2c", "0x00"}}, - { - /* No.812 delta:593 weight:1829 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x5fbcf51f, 0x98b79a9a, 0xc70b6f85, 0x31f032cb, 0x6e4cc7d4, 0xa947a851, 0xf6fb5d4e, 0x00004edc, 0x5fbcbbc3, 0x98b7d446, 0xc70b2159, 0x31f07c17, 0x6e4c8908, 0xa947e68d, 0xf6fb1392}, - [16]uint32{0x00000000, 0x20022136, 0x00021189, 0x200030bf, 0xc000010d, 0xe002203b, 0xc0021084, 0xe00031b2, 0x7003255d, 0x5001046b, 0x700134d4, 0x500315e2, 0xb0032450, 0x90010566, 0xb00135d9, 0x900314ef}, - [16]uint32{0x3f800000, 0x3f900110, 0x3f800108, 0x3f900018, 0x3fe00000, 0x3ff00110, 0x3fe00108, 0x3ff00018, 0x3fb80192, 0x3fa80082, 0x3fb8009a, 0x3fa8018a, 0x3fd80192, 0x3fc80082, 0x3fd8009a, 0x3fc8018a}, - uint32(0xfff80000), - [21]string{"0x23", "0xe1", "0x3b", "0xbf", "0x88", "0x82", "0xfd", "0x93", "0x73", "0x76", "0x16", "0xa2", "0x0b", "0xd3", "0x2f", "0x00", "0x97", "0x8e", "0x26", "0x8e", "0x00"}}, - { - /* No.813 delta:930 weight:1205 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x3151665e, 0x5438759b, 0x656913c5, 0xd02032d8, 0xe1715486, 0x84184743, 0xb549211d, 0x0000a819, 0x3151ce47, 0x5438dd82, 0x6569bbdc, 0xd0209ac1, 0xe171fc9f, 0x8418ef5a, 0xb5498904}, - [16]uint32{0x00000000, 0xc066157a, 0x000205af, 0xc06410d5, 0x20042866, 0xe0623d1c, 0x20062dc9, 0xe06038b3, 0x60141017, 0xa072056d, 0x601615b8, 0xa07000c2, 0x40103871, 0x80762d0b, 0x40123dde, 0x807428a4}, - [16]uint32{0x3f800000, 0x3fe0330a, 0x3f800102, 0x3fe03208, 0x3f900214, 0x3ff0311e, 0x3f900316, 0x3ff0301c, 0x3fb00a08, 0x3fd03902, 0x3fb00b0a, 0x3fd03800, 0x3fa0081c, 0x3fc03b16, 0x3fa0091e, 0x3fc03a14}, - uint32(0xfff80000), - [21]string{"0x15", "0xd0", "0x7f", "0xe0", "0x17", "0xfb", "0xd7", "0x1a", "0x42", "0xe6", "0x86", "0x89", "0xcb", "0x17", "0xf1", "0x72", "0xa1", "0x2c", "0x4f", "0x56", "0x00"}}, - { - /* No.814 delta:832 weight:1133 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0x5a0f9104, 0x84a207db, 0xdead96df, 0xe80032e3, 0xb20fa3e7, 0x6ca23538, 0x36ada43c, 0x000002a9, 0x5a0f93ad, 0x84a20572, 0xdead9476, 0xe800304a, 0xb20fa14e, 0x6ca23791, 0x36ada695}, - [16]uint32{0x00000000, 0x30388412, 0x1064181d, 0x205c9c0f, 0x00020269, 0x303a867b, 0x10661a74, 0x205e9e66, 0x14417001, 0x2479f413, 0x0425681c, 0x341dec0e, 0x14437268, 0x247bf67a, 0x04276a75, 0x341fee67}, - [16]uint32{0x3f800000, 0x3f981c42, 0x3f88320c, 0x3f902e4e, 0x3f800101, 0x3f981d43, 0x3f88330d, 0x3f902f4f, 0x3f8a20b8, 0x3f923cfa, 0x3f8212b4, 0x3f9a0ef6, 0x3f8a21b9, 0x3f923dfb, 0x3f8213b5, 0x3f9a0ff7}, - uint32(0xfff80000), - [21]string{"0xce", "0xc8", "0xec", "0x83", "0xcc", "0x6e", "0x8a", "0x5b", "0xcd", "0x76", "0xee", "0xcb", "0x66", "0xcc", "0x59", "0x54", "0xd8", "0x02", "0xbe", "0x63", "0x00"}}, - { - /* No.815 delta:776 weight:1615 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0xdc1ed819, 0x09d68b28, 0xd5c85331, 0x020032fa, 0xde1eeae3, 0x0bd6b9d2, 0xd7c861cb, 0x0000da41, 0xdc1e0258, 0x09d65169, 0xd5c88970, 0x0200e8bb, 0xde1e30a2, 0x0bd66393, 0xd7c8bb8a}, - [16]uint32{0x00000000, 0x20021416, 0x40401e0d, 0x60420a1b, 0x8001093a, 0xa0031d2c, 0xc0411737, 0xe0430321, 0x3000001e, 0x10021408, 0x70401e13, 0x50420a05, 0xb0010924, 0x90031d32, 0xf0411729, 0xd043033f}, - [16]uint32{0x3f800000, 0x3f90010a, 0x3fa0200f, 0x3fb02105, 0x3fc00084, 0x3fd0018e, 0x3fe0208b, 0x3ff02181, 0x3f980000, 0x3f88010a, 0x3fb8200f, 0x3fa82105, 0x3fd80084, 0x3fc8018e, 0x3ff8208b, 0x3fe82181}, - uint32(0xfff80000), - [21]string{"0xd0", "0xb2", "0x11", "0x4c", "0xc4", "0xb1", "0x60", "0x79", "0x60", "0xc0", "0x10", "0x75", "0x37", "0x8e", "0x88", "0xb6", "0xe2", "0xd4", "0x7a", "0x88", "0x00"}}, - { - /* No.816 delta:812 weight:1497 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x6fbfa028, 0x651705ec, 0x0aa8a5c4, 0xb0303301, 0xdf8f9329, 0xd52736ed, 0xba9896c5, 0x0000fdf9, 0x6fbf5dd1, 0x6517f815, 0x0aa8583d, 0xb030cef8, 0xdf8f6ed0, 0xd527cb14, 0xba986b3c}, - [16]uint32{0x00000000, 0x20031b52, 0x1000281d, 0x3003334f, 0x30000211, 0x10031943, 0x20002a0c, 0x0003315e, 0x09341216, 0x29370944, 0x19343a0b, 0x39372159, 0x39341007, 0x19370b55, 0x2934381a, 0x09372348}, - [16]uint32{0x3f800000, 0x3f90018d, 0x3f880014, 0x3f980199, 0x3f980001, 0x3f88018c, 0x3f900015, 0x3f800198, 0x3f849a09, 0x3f949b84, 0x3f8c9a1d, 0x3f9c9b90, 0x3f9c9a08, 0x3f8c9b85, 0x3f949a1c, 0x3f849b91}, - uint32(0xfff80000), - [21]string{"0xa6", "0x71", "0x3f", "0xe7", "0xae", "0xc8", "0xe7", "0xa6", "0x98", "0x1a", "0xb3", "0x83", "0xe3", "0x9d", "0xa5", "0x96", "0x59", "0x48", "0x7c", "0x03", "0x00"}}, - { - /* No.817 delta:996 weight:1399 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0x5d4b95b0, 0x041181ae, 0x595a141e, 0xa1d03311, 0xfc9ba6a1, 0xa5c1b2bf, 0xf88a270f, 0x00008fb6, 0x5d4b1a06, 0x04110e18, 0x595a9ba8, 0xa1d0bca7, 0xfc9b2917, 0xa5c13d09, 0xf88aa8b9}, - [16]uint32{0x00000000, 0x805811da, 0x007600e7, 0x802e113d, 0x000b103c, 0x805301e6, 0x007d10db, 0x80250101, 0x00022018, 0x805a31c2, 0x007420ff, 0x802c3125, 0x00093024, 0x805121fe, 0x007f30c3, 0x80272119}, - [16]uint32{0x3f800000, 0x3fc02c08, 0x3f803b00, 0x3fc01708, 0x3f800588, 0x3fc02980, 0x3f803e88, 0x3fc01280, 0x3f800110, 0x3fc02d18, 0x3f803a10, 0x3fc01618, 0x3f800498, 0x3fc02890, 0x3f803f98, 0x3fc01390}, - uint32(0xfff80000), - [21]string{"0xcf", "0x0e", "0xdc", "0x27", "0x59", "0x80", "0xe0", "0x33", "0xe0", "0x1f", "0x24", "0x1d", "0x47", "0x14", "0x50", "0x74", "0x9c", "0x01", "0x4d", "0x71", "0x00"}}, - { - /* No.818 delta:829 weight:1327 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x5d97761f, 0xbcde4dd3, 0xe1493bcc, 0x71a03322, 0x2c37453d, 0xcd7e7ef1, 0x90e908ee, 0x00005ac4, 0x5d972cdb, 0xbcde1717, 0xe1496108, 0x71a069e6, 0x2c371ff9, 0xcd7e2435, 0x90e9522a}, - [16]uint32{0x00000000, 0x9005251f, 0x40098156, 0xd00ca449, 0x1042e014, 0x8047c50b, 0x504b6142, 0xc04e445d, 0x20408045, 0xb045a55a, 0x60490113, 0xf04c240c, 0x30026051, 0xa007454e, 0x700be107, 0xe00ec418}, - [16]uint32{0x3f800000, 0x3fc80292, 0x3fa004c0, 0x3fe80652, 0x3f882170, 0x3fc023e2, 0x3fa825b0, 0x3fe02722, 0x3f902040, 0x3fd822d2, 0x3fb02480, 0x3ff82612, 0x3f980130, 0x3fd003a2, 0x3fb805f0, 0x3ff00762}, - uint32(0xfff80000), - [21]string{"0x26", "0x1d", "0x1e", "0xb6", "0xa5", "0x64", "0xa7", "0x82", "0x8c", "0x79", "0x69", "0x7f", "0x78", "0xf5", "0xc1", "0xdb", "0xbd", "0x2b", "0xa8", "0x3d", "0x00"}}, - { - /* No.819 delta:1173 weight:1521 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0x9978b429, 0x6582d994, 0xfcfa6dbd, 0xe0703336, 0x7908871f, 0x85f2eaa2, 0x1c8a5e8b, 0x00006a05, 0x9978de2c, 0x6582b391, 0xfcfa07b8, 0xe0705933, 0x7908ed1a, 0x85f280a7, 0x1c8a348e}, - [16]uint32{0x00000000, 0x0024135e, 0x10622635, 0x1046356b, 0x50d0500f, 0x50f44351, 0x40b2763a, 0x40966564, 0x50146608, 0x50307556, 0x4076403d, 0x40525363, 0x00c43607, 0x00e02559, 0x10a61032, 0x1082036c}, - [16]uint32{0x3f800000, 0x3f801209, 0x3f883113, 0x3f88231a, 0x3fa86828, 0x3fa87a21, 0x3fa0593b, 0x3fa04b32, 0x3fa80a33, 0x3fa8183a, 0x3fa03b20, 0x3fa02929, 0x3f80621b, 0x3f807012, 0x3f885308, 0x3f884101}, - uint32(0xfff80000), - [21]string{"0x82", "0x3b", "0x97", "0xb1", "0x32", "0x4a", "0xf9", "0x10", "0x95", "0xf4", "0x65", "0x04", "0x76", "0x4e", "0x65", "0x45", "0xdd", "0x7b", "0x7c", "0x23", "0x00"}}, - { - /* No.820 delta:1510 weight:1615 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xeca160b8, 0x8f015ca1, 0x63a03c19, 0x7ca03340, 0x900153f8, 0xf3a16fe1, 0x1f000f59, 0x000082e3, 0xeca1e25b, 0x8f01de42, 0x63a0befa, 0x7ca0b1a3, 0x9001d11b, 0xf3a1ed02, 0x1f008dba}, - [16]uint32{0x00000000, 0x00684176, 0x9017206a, 0x907f611c, 0x0012004b, 0x007a413d, 0x90052021, 0x906d6157, 0x00024008, 0x006a017e, 0x90156062, 0x907d2114, 0x00104043, 0x00780135, 0x90076029, 0x906f215f}, - [16]uint32{0x3f800000, 0x3f803420, 0x3fc80b90, 0x3fc83fb0, 0x3f800900, 0x3f803d20, 0x3fc80290, 0x3fc836b0, 0x3f800120, 0x3f803500, 0x3fc80ab0, 0x3fc83e90, 0x3f800820, 0x3f803c00, 0x3fc803b0, 0x3fc83790}, - uint32(0xfff80000), - [21]string{"0xc9", "0x83", "0x22", "0x11", "0x92", "0xca", "0x81", "0x3e", "0xd0", "0x3c", "0x03", "0x94", "0x75", "0xb1", "0xe3", "0xa3", "0x58", "0xed", "0x80", "0xd0", "0x00"}}, - { - /* No.821 delta:1468 weight:1661 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xb5a0ba7d, 0xb63ed1c3, 0x039e6bbe, 0x90703351, 0x25d0892c, 0x264ee292, 0x93ee58ef, 0x0000f62b, 0xb5a04c56, 0xb63e27e8, 0x039e9d95, 0x9070c57a, 0x25d07f07, 0x264e14b9, 0x93eeaec4}, - [16]uint32{0x00000000, 0x407e513a, 0x50115174, 0x106f004e, 0x00422c0c, 0x403c7d36, 0x50537d78, 0x102d2c42, 0x2002d415, 0x607c852f, 0x70138561, 0x306dd45b, 0x2040f819, 0x603ea923, 0x7051a96d, 0x302ff857}, - [16]uint32{0x3f800000, 0x3fa03f28, 0x3fa808a8, 0x3f883780, 0x3f802116, 0x3fa01e3e, 0x3fa829be, 0x3f881696, 0x3f90016a, 0x3fb03e42, 0x3fb809c2, 0x3f9836ea, 0x3f90207c, 0x3fb01f54, 0x3fb828d4, 0x3f9817fc}, - uint32(0xfff80000), - [21]string{"0xbd", "0xe3", "0xe0", "0x4a", "0x82", "0x9a", "0xd3", "0x8c", "0xc9", "0x90", "0xd1", "0x09", "0xc2", "0xf7", "0xb2", "0x7c", "0x72", "0x90", "0x60", "0x55", "0x00"}}, - { - /* No.822 delta:1931 weight:1379 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0xca46bedd, 0x29517305, 0xe317cdd8, 0x9980336d, 0x53c68db0, 0xb0d14068, 0x7a97feb5, 0x00009a52, 0xca46248f, 0x2951e957, 0xe317578a, 0x9980a93f, 0x53c617e2, 0xb0d1da3a, 0x7a9764e7}, - [16]uint32{0x00000000, 0x4d517f56, 0x40401411, 0x0d116b47, 0x401808ff, 0x0d4977a9, 0x00581cee, 0x4d0963b8, 0xc7ee700c, 0x8abf0f5a, 0x87ae641d, 0xcaff1b4b, 0x87f678f3, 0xcaa707a5, 0xc7b66ce2, 0x8ae713b4}, - [16]uint32{0x3f800000, 0x3fa6a8bf, 0x3fa0200a, 0x3f8688b5, 0x3fa00c04, 0x3f86a4bb, 0x3f802c0e, 0x3fa684b1, 0x3fe3f738, 0x3fc55f87, 0x3fc3d732, 0x3fe57f8d, 0x3fc3fb3c, 0x3fe55383, 0x3fe3db36, 0x3fc57389}, - uint32(0xfff80000), - [21]string{"0x62", "0x59", "0x00", "0x08", "0x09", "0xac", "0x26", "0x12", "0x01", "0x06", "0x8f", "0xac", "0x70", "0x58", "0x0a", "0x50", "0xc5", "0xcf", "0x56", "0xad", "0x00"}}, - { - /* No.823 delta:834 weight:1539 */ - 11213, - 55, - 13, - 4, - [16]uint32{0x00000000, 0x0d9b6aba, 0x74d72ee7, 0x794c445d, 0x72c03377, 0x7f5b59cd, 0x06171d90, 0x0b8c772a, 0x000051d7, 0x0d9b3b6d, 0x74d77f30, 0x794c158a, 0x72c062a0, 0x7f5b081a, 0x06174c47, 0x0b8c26fd}, - [16]uint32{0x00000000, 0x114790be, 0x304c206d, 0x210bb0d3, 0x0002c61c, 0x114556a2, 0x304ee671, 0x210976cf, 0x00011007, 0x114680b9, 0x304d306a, 0x210aa0d4, 0x0003d61b, 0x114446a5, 0x304ff676, 0x210866c8}, - [16]uint32{0x3f800000, 0x3f88a3c8, 0x3f982610, 0x3f9085d8, 0x3f800163, 0x3f88a2ab, 0x3f982773, 0x3f9084bb, 0x3f800088, 0x3f88a340, 0x3f982698, 0x3f908550, 0x3f8001eb, 0x3f88a223, 0x3f9827fb, 0x3f908433}, - uint32(0xfff80000), - [21]string{"0xf0", "0x81", "0x43", "0x0b", "0x1e", "0x48", "0xcd", "0xa4", "0xf5", "0xc4", "0x2d", "0x3f", "0x2e", "0xc4", "0x04", "0x34", "0x7a", "0xd4", "0x51", "0xe4", "0x00"}}, - { - /* No.824 delta:1084 weight:1529 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0xa43f33f0, 0x4fb4a6aa, 0xeb8b955a, 0xaab0338a, 0x0e8f007a, 0xe5049520, 0x413ba6d0, 0x0000492d, 0xa43f7add, 0x4fb4ef87, 0xeb8bdc77, 0xaab07aa7, 0x0e8f4957, 0xe504dc0d, 0x413beffd}, - [16]uint32{0x00000000, 0x2002c87c, 0x50fd91ef, 0x70ff5993, 0x00401017, 0x2042d86b, 0x50bd81f8, 0x70bf4984, 0x60402b5d, 0x4042e321, 0x30bdbab2, 0x10bf72ce, 0x60003b4a, 0x4002f336, 0x30fdaaa5, 0x10ff62d9}, - [16]uint32{0x3f800000, 0x3f900164, 0x3fa87ec8, 0x3fb87fac, 0x3f802008, 0x3f90216c, 0x3fa85ec0, 0x3fb85fa4, 0x3fb02015, 0x3fa02171, 0x3f985edd, 0x3f885fb9, 0x3fb0001d, 0x3fa00179, 0x3f987ed5, 0x3f887fb1}, - uint32(0xfff80000), - [21]string{"0x10", "0x09", "0xac", "0x98", "0xcf", "0x44", "0x58", "0x74", "0x2b", "0x11", "0xe5", "0x53", "0xba", "0xd4", "0x07", "0x57", "0x47", "0xc5", "0x3e", "0xbf", "0x00"}}, - { - /* No.825 delta:935 weight:1259 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x77ffb15d, 0x52d34888, 0x252cf9d5, 0x39903393, 0x4e6f82ce, 0x6b437b1b, 0x1cbcca46, 0x0000925c, 0x77ff2301, 0x52d3dad4, 0x252c6b89, 0x3990a1cf, 0x4e6f1092, 0x6b43e947, 0x1cbc581a}, - [16]uint32{0x00000000, 0x100441f6, 0x700440d3, 0x60000125, 0x30021002, 0x200651f4, 0x400650d1, 0x50021127, 0x30013c1c, 0x20057dea, 0x40057ccf, 0x50013d39, 0x00032c1e, 0x10076de8, 0x70076ccd, 0x60032d3b}, - [16]uint32{0x3f800000, 0x3f880220, 0x3fb80220, 0x3fb00000, 0x3f980108, 0x3f900328, 0x3fa00328, 0x3fa80108, 0x3f98009e, 0x3f9002be, 0x3fa002be, 0x3fa8009e, 0x3f800196, 0x3f8803b6, 0x3fb803b6, 0x3fb00196}, - uint32(0xfff80000), - [21]string{"0xbf", "0xa6", "0x28", "0x24", "0xc4", "0x2e", "0x47", "0x0c", "0x86", "0x38", "0xf1", "0xa4", "0xc6", "0x0e", "0xd6", "0x37", "0x52", "0x34", "0x6c", "0xa1", "0x00"}}, - { - /* No.826 delta:625 weight:1373 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0x3e399f20, 0x350e6d29, 0x0b37f209, 0x767033ab, 0x4849ac8b, 0x437e5e82, 0x7d47c1a2, 0x000033bb, 0x3e39ac9b, 0x350e5e92, 0x0b37c1b2, 0x76700010, 0x48499f30, 0x437e6d39, 0x7d47f219}, - [16]uint32{0x00000000, 0x304d159e, 0x4029e0c2, 0x7064f55c, 0x80402019, 0xb00d3587, 0xc069c0db, 0xf024d545, 0x3020810b, 0x006d9495, 0x700961c9, 0x40447457, 0xb060a112, 0x802db48c, 0xf04941d0, 0xc004544e}, - [16]uint32{0x3f800000, 0x3f98268a, 0x3fa014f0, 0x3fb8327a, 0x3fc02010, 0x3fd8069a, 0x3fe034e0, 0x3ff8126a, 0x3f981040, 0x3f8036ca, 0x3fb804b0, 0x3fa0223a, 0x3fd83050, 0x3fc016da, 0x3ff824a0, 0x3fe0022a}, - uint32(0xfff80000), - [21]string{"0x6d", "0x95", "0x38", "0xc0", "0x12", "0xc0", "0x30", "0x09", "0x96", "0x3d", "0x80", "0xfe", "0x20", "0x2d", "0x6f", "0x09", "0x31", "0xc6", "0x93", "0xba", "0x00"}}, - { - /* No.827 delta:667 weight:913 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0x0cb6bfff, 0xba01cbc4, 0xb6b7743b, 0xe32033be, 0xef968c41, 0x5921f87a, 0x55974785, 0x00007a41, 0x0cb6c5be, 0xba01b185, 0xb6b70e7a, 0xe32049ff, 0xef96f600, 0x5921823b, 0x55973dc4}, - [16]uint32{0x00000000, 0x10481edb, 0x412001dc, 0x51681f07, 0x10052908, 0x004d37d3, 0x512528d4, 0x416d360f, 0x200211b6, 0x304a0f6d, 0x6122106a, 0x716a0eb1, 0x300738be, 0x204f2665, 0x71273962, 0x616f27b9}, - [16]uint32{0x3f800000, 0x3f88240f, 0x3fa09000, 0x3fa8b40f, 0x3f880294, 0x3f80269b, 0x3fa89294, 0x3fa0b69b, 0x3f900108, 0x3f982507, 0x3fb09108, 0x3fb8b507, 0x3f98039c, 0x3f902793, 0x3fb8939c, 0x3fb0b793}, - uint32(0xfff80000), - [21]string{"0x03", "0x7a", "0xee", "0xc2", "0x61", "0xb3", "0xa1", "0x1f", "0xca", "0xa8", "0xbb", "0x26", "0x2c", "0x01", "0xb1", "0x48", "0x51", "0xa0", "0x37", "0x13", "0x00"}}, - { - /* No.828 delta:2646 weight:895 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0x53a8de3a, 0x1a76474c, 0x49de9976, 0xbab033c0, 0xe918edfa, 0xa0c6748c, 0xf36eaab6, 0x0000301f, 0x53a8ee25, 0x1a767753, 0x49dea969, 0xbab003df, 0xe918dde5, 0xa0c64493, 0xf36e9aa9}, - [16]uint32{0x00000000, 0x8cc291bf, 0x82298142, 0x0eeb10fd, 0x6a60c1b4, 0xe6a2500b, 0xe84940f6, 0x648bd149, 0x0924e1e8, 0x85e67057, 0x8b0d60aa, 0x07cff115, 0x6344205c, 0xef86b1e3, 0xe16da11e, 0x6daf30a1}, - [16]uint32{0x3f800000, 0x3fc66148, 0x3fc114c0, 0x3f877588, 0x3fb53060, 0x3ff35128, 0x3ff424a0, 0x3fb245e8, 0x3f849270, 0x3fc2f338, 0x3fc586b0, 0x3f83e7f8, 0x3fb1a210, 0x3ff7c358, 0x3ff0b6d0, 0x3fb6d798}, - uint32(0xfff80000), - [21]string{"0xa1", "0x21", "0x6e", "0x85", "0x4a", "0x3d", "0x8a", "0xa3", "0xe3", "0x37", "0xf2", "0xd1", "0x69", "0x44", "0xb5", "0x9c", "0x3e", "0xd7", "0x33", "0xa8", "0x00"}}, - { - /* No.829 delta:2275 weight:1301 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0x23c11a1a, 0xa308047b, 0x80c91e61, 0xec2033de, 0xcfe129c4, 0x4f2837a5, 0x6ce92dbf, 0x00006c47, 0x23c1765d, 0xa308683c, 0x80c97226, 0xec205f99, 0xcfe14583, 0x4f285be2, 0x6ce941f8}, - [16]uint32{0x00000000, 0x0d1395f2, 0x66045c18, 0x6b17c9ea, 0x07a16019, 0x0ab2f5eb, 0x61a53c01, 0x6cb6a9f3, 0x21080407, 0x2c1b91f5, 0x470c581f, 0x4a1fcded, 0x26a9641e, 0x2bbaf1ec, 0x40ad3806, 0x4dbeadf4}, - [16]uint32{0x3f800000, 0x3f8689ca, 0x3fb3022e, 0x3fb58be4, 0x3f83d0b0, 0x3f85597a, 0x3fb0d29e, 0x3fb65b54, 0x3f908402, 0x3f960dc8, 0x3fa3862c, 0x3fa50fe6, 0x3f9354b2, 0x3f95dd78, 0x3fa0569c, 0x3fa6df56}, - uint32(0xfff80000), - [21]string{"0x95", "0xf7", "0x64", "0x86", "0xe1", "0x89", "0x77", "0x67", "0x1e", "0x73", "0x88", "0xb4", "0x00", "0xc5", "0x73", "0x52", "0x43", "0xf0", "0xe6", "0xf0", "0x00"}}, - { - /* No.830 delta:2155 weight:1353 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x8732db4c, 0x52eb0569, 0xd5d9de25, 0x744033ee, 0xf372e8a2, 0x26ab3687, 0xa199edcb, 0x0000454c, 0x87329e00, 0x52eb4025, 0xd5d99b69, 0x744076a2, 0xf372adee, 0x26ab73cb, 0xa199a887}, - [16]uint32{0x00000000, 0x094903fc, 0x2ac00406, 0x238907fa, 0x04bc1964, 0x0df51a98, 0x2e7c1d62, 0x27351e9e, 0x068602e1, 0x0fcf011d, 0x2c4606e7, 0x250f051b, 0x023a1b85, 0x0b731879, 0x28fa1f83, 0x21b31c7f}, - [16]uint32{0x3f800000, 0x3f84a481, 0x3f956002, 0x3f91c483, 0x3f825e0c, 0x3f86fa8d, 0x3f973e0e, 0x3f939a8f, 0x3f834301, 0x3f87e780, 0x3f962303, 0x3f928782, 0x3f811d0d, 0x3f85b98c, 0x3f947d0f, 0x3f90d98e}, - uint32(0xfff80000), - [21]string{"0x3c", "0x15", "0xa2", "0x3a", "0x13", "0xe1", "0x2b", "0xa6", "0x90", "0x7d", "0xc1", "0xbf", "0x09", "0xf7", "0x3e", "0x98", "0x65", "0x2f", "0x1f", "0x72", "0x00"}}, - { - /* No.831 delta:724 weight:1289 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x820171b2, 0x006ede0a, 0x826fafb8, 0xdb0033f5, 0x59014247, 0xdb6eedff, 0x596f9c4d, 0x000013cd, 0x8201627f, 0x006ecdc7, 0x826fbc75, 0xdb002038, 0x5901518a, 0xdb6efe32, 0x596f8f80}, - [16]uint32{0x00000000, 0x40378cfd, 0x00023011, 0x4035bcec, 0x10040025, 0x50338cd8, 0x10063034, 0x5031bcc9, 0x0001e81a, 0x403664e7, 0x0003d80b, 0x403454f6, 0x1005e83f, 0x503264c2, 0x1007d82e, 0x503054d3}, - [16]uint32{0x3f800000, 0x3fa01bc6, 0x3f800118, 0x3fa01ade, 0x3f880200, 0x3fa819c6, 0x3f880318, 0x3fa818de, 0x3f8000f4, 0x3fa01b32, 0x3f8001ec, 0x3fa01a2a, 0x3f8802f4, 0x3fa81932, 0x3f8803ec, 0x3fa8182a}, - uint32(0xfff80000), - [21]string{"0x4c", "0x34", "0x65", "0x9a", "0x7c", "0x4c", "0xcc", "0x8a", "0x4b", "0xc4", "0x7b", "0x73", "0xe2", "0xc0", "0x77", "0xb6", "0xb5", "0x22", "0x52", "0x8a", "0x00"}}, - { - /* No.832 delta:1702 weight:1773 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0xe90425c6, 0x7b147cad, 0x9210596b, 0x59f0340d, 0xb0f411cb, 0x22e448a0, 0xcbe06d66, 0x0000b1fc, 0xe904943a, 0x7b14cd51, 0x9210e897, 0x59f085f1, 0xb0f4a037, 0x22e4f95c, 0xcbe0dc9a}, - [16]uint32{0x00000000, 0x181a025e, 0x00000031, 0x181a026f, 0x400a01ac, 0x581003f2, 0x400a019d, 0x581003c3, 0x00020017, 0x18180249, 0x00020026, 0x18180278, 0x400801bb, 0x581203e5, 0x4008018a, 0x581203d4}, - [16]uint32{0x3f800000, 0x3f8c0d01, 0x3f800000, 0x3f8c0d01, 0x3fa00500, 0x3fac0801, 0x3fa00500, 0x3fac0801, 0x3f800100, 0x3f8c0c01, 0x3f800100, 0x3f8c0c01, 0x3fa00400, 0x3fac0901, 0x3fa00400, 0x3fac0901}, - uint32(0xfff80000), - [21]string{"0xbc", "0xdc", "0xef", "0x4a", "0xe3", "0x61", "0xf5", "0xa6", "0xee", "0x0b", "0x7e", "0x34", "0xff", "0xf4", "0xce", "0x85", "0xc9", "0x02", "0x83", "0x77", "0x00"}}, - { - /* No.833 delta:857 weight:1471 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x69a0516a, 0x64f467e0, 0x0d54368a, 0x7c303419, 0x15906573, 0x18c453f9, 0x71640293, 0x0000b7eb, 0x69a0e681, 0x64f4d00b, 0x0d548161, 0x7c3083f2, 0x1590d298, 0x18c4e412, 0x7164b578}, - [16]uint32{0x00000000, 0x104e0416, 0x106338fb, 0x002d3ced, 0x004dd9e5, 0x1003ddf3, 0x102ee11e, 0x0060e508, 0x00020322, 0x104c0734, 0x10613bd9, 0x002f3fcf, 0x004fdac7, 0x1001ded1, 0x102ce23c, 0x0062e62a}, - [16]uint32{0x3f800000, 0x3f882702, 0x3f88319c, 0x3f80169e, 0x3f8026ec, 0x3f8801ee, 0x3f881770, 0x3f803072, 0x3f800101, 0x3f882603, 0x3f88309d, 0x3f80179f, 0x3f8027ed, 0x3f8800ef, 0x3f881671, 0x3f803173}, - uint32(0xfff80000), - [21]string{"0xb6", "0xa4", "0xf0", "0xda", "0xe0", "0xb3", "0x34", "0xa8", "0xfb", "0x12", "0x26", "0x0d", "0x4d", "0x4e", "0xc8", "0x0a", "0x31", "0x72", "0xb0", "0xbd", "0x00"}}, - { - /* No.834 delta:1512 weight:1201 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0xebf425d3, 0x2178e6ac, 0xca8cc37f, 0x1cd0342e, 0xf72411fd, 0x3da8d282, 0xd65cf751, 0x00007185, 0xebf45456, 0x21789729, 0xca8cb2fa, 0x1cd045ab, 0xf7246078, 0x3da8a307, 0xd65c86d4}, - [16]uint32{0x00000000, 0x0004a07e, 0x000080ef, 0x00042091, 0x10420122, 0x1046a15c, 0x104281cd, 0x104621b3, 0x10010039, 0x1005a047, 0x100180d6, 0x100520a8, 0x0043011b, 0x0047a165, 0x004381f4, 0x0047218a}, - [16]uint32{0x3f800000, 0x3f800250, 0x3f800040, 0x3f800210, 0x3f882100, 0x3f882350, 0x3f882140, 0x3f882310, 0x3f880080, 0x3f8802d0, 0x3f8800c0, 0x3f880290, 0x3f802180, 0x3f8023d0, 0x3f8021c0, 0x3f802390}, - uint32(0xfff80000), - [21]string{"0xca", "0x55", "0x4b", "0x4f", "0x50", "0x63", "0xc0", "0x5c", "0xc1", "0xcd", "0x5f", "0x21", "0x2e", "0x57", "0x37", "0x5c", "0xb0", "0x4f", "0x2d", "0x50", "0x00"}}, - { - /* No.835 delta:1033 weight:1607 */ - 11213, - 37, - 13, - 4, - [16]uint32{0x00000000, 0xd8d8169a, 0xf0c12601, 0x2819309b, 0xf3703430, 0x2ba822aa, 0x03b11231, 0xdb6904ab, 0x000036a1, 0xd8d8203b, 0xf0c110a0, 0x2819063a, 0xf3700291, 0x2ba8140b, 0x03b12490, 0xdb69320a}, - [16]uint32{0x00000000, 0x005020d6, 0x404c01b4, 0x401c2162, 0x900a61e5, 0x905a4133, 0xd0466051, 0xd0164087, 0x0002a04b, 0x0052809d, 0x404ea1ff, 0x401e8129, 0x9008c1ae, 0x9058e178, 0xd044c01a, 0xd014e0cc}, - [16]uint32{0x3f800000, 0x3f802810, 0x3fa02600, 0x3fa00e10, 0x3fc80530, 0x3fc82d20, 0x3fe82330, 0x3fe80b20, 0x3f800150, 0x3f802940, 0x3fa02750, 0x3fa00f40, 0x3fc80460, 0x3fc82c70, 0x3fe82260, 0x3fe80a70}, - uint32(0xfff80000), - [21]string{"0xca", "0x00", "0x58", "0xcd", "0xc6", "0x49", "0x16", "0x0a", "0xca", "0xbc", "0x00", "0x7c", "0x8f", "0x3a", "0x88", "0x09", "0x16", "0x73", "0xd4", "0xfa", "0x00"}}, - { - /* No.836 delta:1121 weight:1723 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0x45ef1573, 0x8fc740c3, 0xca2855b0, 0x33703443, 0x769f2130, 0xbcb77480, 0xf95861f3, 0x00003e92, 0x45ef2be1, 0x8fc77e51, 0xca286b22, 0x33700ad1, 0x769f1fa2, 0xbcb74a12, 0xf9585f61}, - [16]uint32{0x00000000, 0x104e08d4, 0x20025019, 0x304c58cd, 0x20013187, 0x304f3953, 0x0003619e, 0x104d694a, 0x70257408, 0x606b7cdc, 0x50272411, 0x40692cc5, 0x5024458f, 0x406a4d5b, 0x70261596, 0x60681d42}, - [16]uint32{0x3f800000, 0x3f882704, 0x3f900128, 0x3f98262c, 0x3f900098, 0x3f98279c, 0x3f8001b0, 0x3f8826b4, 0x3fb812ba, 0x3fb035be, 0x3fa81392, 0x3fa03496, 0x3fa81222, 0x3fa03526, 0x3fb8130a, 0x3fb0340e}, - uint32(0xfff80000), - [21]string{"0x43", "0xeb", "0x93", "0x60", "0xe1", "0x81", "0xf5", "0x0d", "0x33", "0x3b", "0x8b", "0x07", "0xd4", "0x68", "0xb2", "0xd8", "0xd6", "0xb5", "0x2e", "0x82", "0x00"}}, - { - /* No.837 delta:972 weight:1231 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x5fa33807, 0x6959b830, 0x36fa8037, 0x1f50345d, 0x40f30c5a, 0x76098c6d, 0x29aab46a, 0x00008310, 0x5fa3bb17, 0x69593b20, 0x36fa0327, 0x1f50b74d, 0x40f38f4a, 0x76090f7d, 0x29aa377a}, - [16]uint32{0x00000000, 0x854cf1d5, 0x2054408b, 0xa518b15e, 0x004239da, 0x850ec80f, 0x20167951, 0xa55a8884, 0x00024367, 0x854eb2b2, 0x205603ec, 0xa51af239, 0x00407abd, 0x850c8b68, 0x20143a36, 0xa558cbe3}, - [16]uint32{0x3f800000, 0x3fc2a678, 0x3f902a20, 0x3fd28c58, 0x3f80211c, 0x3fc28764, 0x3f900b3c, 0x3fd2ad44, 0x3f800121, 0x3fc2a759, 0x3f902b01, 0x3fd28d79, 0x3f80203d, 0x3fc28645, 0x3f900a1d, 0x3fd2ac65}, - uint32(0xfff80000), - [21]string{"0xf2", "0x6d", "0x75", "0x79", "0xbf", "0x5c", "0x57", "0xac", "0x36", "0xcc", "0x10", "0xf7", "0xf1", "0x92", "0x55", "0x0c", "0xc1", "0x8a", "0x2e", "0x63", "0x00"}}, - { - /* No.838 delta:799 weight:1619 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0xd4424727, 0xe9b0500d, 0x3df2172a, 0x16b0346c, 0xc2f2734b, 0xff006461, 0x2b422346, 0x0000045a, 0xd442437d, 0xe9b05457, 0x3df21370, 0x16b03036, 0xc2f27711, 0xff00603b, 0x2b42271c}, - [16]uint32{0x00000000, 0xa000ae7e, 0x0003b011, 0xa0031e6f, 0x507f841b, 0xf07f2a65, 0x507c340a, 0xf07c9a74, 0x8420e01d, 0x24204e63, 0x8423500c, 0x2423fe72, 0xd45f6406, 0x745fca78, 0xd45cd417, 0x745c7a69}, - [16]uint32{0x3f800000, 0x3fd00057, 0x3f8001d8, 0x3fd0018f, 0x3fa83fc2, 0x3ff83f95, 0x3fa83e1a, 0x3ff83e4d, 0x3fc21070, 0x3f921027, 0x3fc211a8, 0x3f9211ff, 0x3fea2fb2, 0x3fba2fe5, 0x3fea2e6a, 0x3fba2e3d}, - uint32(0xfff80000), - [21]string{"0xb3", "0x22", "0xae", "0x53", "0x2e", "0xe0", "0x89", "0x4f", "0xce", "0x5e", "0xf9", "0xb6", "0x4d", "0x6b", "0xc2", "0x61", "0x80", "0x5f", "0x9f", "0x9c", "0x00"}}, - { - /* No.839 delta:700 weight:1591 */ - 11213, - 83, - 13, - 4, - [16]uint32{0x00000000, 0xdcadd318, 0x250ff507, 0xf9a2261f, 0x47203477, 0x9b8de76f, 0x622fc170, 0xbe821268, 0x00003de6, 0xdcadeefe, 0x250fc8e1, 0xf9a21bf9, 0x47200991, 0x9b8dda89, 0x622ffc96, 0xbe822f8e}, - [16]uint32{0x00000000, 0x2072dd5a, 0x00037317, 0x2071ae4d, 0x10014202, 0x30739f58, 0x10023115, 0x3070ec4f, 0x01038413, 0x21715949, 0x0100f704, 0x21722a5e, 0x1102c611, 0x31701b4b, 0x1101b506, 0x3173685c}, - [16]uint32{0x3f800000, 0x3f90396e, 0x3f8001b9, 0x3f9038d7, 0x3f8800a1, 0x3f9839cf, 0x3f880118, 0x3f983876, 0x3f8081c2, 0x3f90b8ac, 0x3f80807b, 0x3f90b915, 0x3f888163, 0x3f98b80d, 0x3f8880da, 0x3f98b9b4}, - uint32(0xfff80000), - [21]string{"0x16", "0x64", "0x67", "0x4e", "0x86", "0xef", "0x35", "0x73", "0xa7", "0xc5", "0x3c", "0xa3", "0x6a", "0xb4", "0x27", "0x9d", "0xaf", "0x9c", "0xd3", "0x4e", "0x00"}}, - { - /* No.840 delta:671 weight:1325 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x761114a8, 0x09a96e50, 0x7fb87af8, 0xef003480, 0x99112028, 0xe6a95ad0, 0x90b84e78, 0x0000de00, 0x7611caa8, 0x09a9b050, 0x7fb8a4f8, 0xef00ea80, 0x9911fe28, 0xe6a984d0, 0x90b89078}, - [16]uint32{0x00000000, 0x80021077, 0x00024692, 0x800056e5, 0x30012031, 0xb0033046, 0x300366a3, 0xb00176d4, 0x100028e9, 0x9002389e, 0x10026e7b, 0x90007e0c, 0x200108d8, 0xa00318af, 0x20034e4a, 0xa0015e3d}, - [16]uint32{0x3f800000, 0x3fc00108, 0x3f800123, 0x3fc0002b, 0x3f980090, 0x3fd80198, 0x3f9801b3, 0x3fd800bb, 0x3f880014, 0x3fc8011c, 0x3f880137, 0x3fc8003f, 0x3f900084, 0x3fd0018c, 0x3f9001a7, 0x3fd000af}, - uint32(0xfff80000), - [21]string{"0x02", "0x26", "0xb1", "0x7f", "0xa1", "0x8e", "0x79", "0x25", "0x4f", "0xb8", "0x82", "0x68", "0x33", "0xac", "0xfc", "0x63", "0x69", "0x28", "0xfe", "0x32", "0x00"}}, - { - /* No.841 delta:869 weight:1569 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x2623395d, 0xdf6f2fbd, 0xf94c16e0, 0x57903492, 0x71b30dcf, 0x88ff1b2f, 0xaedc2272, 0x0000ed29, 0x2623d474, 0xdf6fc294, 0xf94cfbc9, 0x5790d9bb, 0x71b3e0e6, 0x88fff606, 0xaedccf5b}, - [16]uint32{0x00000000, 0x10034135, 0x102012d9, 0x002353ec, 0x42019807, 0x5202d932, 0x52218ade, 0x4222cbeb, 0x50010836, 0x40024903, 0x40211aef, 0x50225bda, 0x12009031, 0x0203d104, 0x022082e8, 0x1223c3dd}, - [16]uint32{0x3f800000, 0x3f8801a0, 0x3f881009, 0x3f8011a9, 0x3fa100cc, 0x3fa9016c, 0x3fa910c5, 0x3fa11165, 0x3fa80084, 0x3fa00124, 0x3fa0108d, 0x3fa8112d, 0x3f890048, 0x3f8101e8, 0x3f811041, 0x3f8911e1}, - uint32(0xfff80000), - [21]string{"0xfc", "0xaa", "0x84", "0x86", "0xbe", "0x50", "0x04", "0x0b", "0xf6", "0x0d", "0xc2", "0xe8", "0x42", "0x16", "0xfc", "0x6d", "0x4b", "0x38", "0xc2", "0x8f", "0x00"}}, - { - /* No.842 delta:1062 weight:1435 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xd02539c2, 0x6f4a6813, 0xbf6f51d1, 0x12e034ae, 0xc2c50d6c, 0x7daa5cbd, 0xad8f657f, 0x0000f8fe, 0xd025c13c, 0x6f4a90ed, 0xbf6fa92f, 0x12e0cc50, 0xc2c5f592, 0x7daaa443, 0xad8f9d81}, - [16]uint32{0x00000000, 0x004285de, 0x20001c19, 0x204299c7, 0x4000020f, 0x404287d1, 0x60001e16, 0x60429bc8, 0x1000381b, 0x1042bdc5, 0x30002402, 0x3042a1dc, 0x50003a14, 0x5042bfca, 0x7000260d, 0x7042a3d3}, - [16]uint32{0x3f800000, 0x3f802142, 0x3f90000e, 0x3f90214c, 0x3fa00001, 0x3fa02143, 0x3fb0000f, 0x3fb0214d, 0x3f88001c, 0x3f88215e, 0x3f980012, 0x3f982150, 0x3fa8001d, 0x3fa8215f, 0x3fb80013, 0x3fb82151}, - uint32(0xfff80000), - [21]string{"0xba", "0x66", "0xb4", "0xd3", "0x70", "0x28", "0x61", "0xbe", "0xab", "0x15", "0x4a", "0x2f", "0xd5", "0x05", "0x55", "0x55", "0xcc", "0x4b", "0xd9", "0x3f", "0x00"}}, - { - /* No.843 delta:3096 weight:651 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x75cf93da, 0x68a27eab, 0x1d6ded71, 0x541034ba, 0x21dfa760, 0x3cb24a11, 0x497dd9cb, 0x0000fd22, 0x75cf6ef8, 0x68a28389, 0x1d6d1053, 0x5410c998, 0x21df5a42, 0x3cb2b733, 0x497d24e9}, - [16]uint32{0x00000000, 0x92a881ff, 0x3082a019, 0xa22a21e6, 0x4200e20d, 0xd0a863f2, 0x72824214, 0xe02ac3eb, 0xc6014de1, 0x54a9cc1e, 0xf683edf8, 0x642b6c07, 0x8401afec, 0x16a92e13, 0xb4830ff5, 0x262b8e0a}, - [16]uint32{0x3f800000, 0x3fc95440, 0x3f984150, 0x3fd11510, 0x3fa10071, 0x3fe85431, 0x3fb94121, 0x3ff01561, 0x3fe300a6, 0x3faa54e6, 0x3ffb41f6, 0x3fb215b6, 0x3fc200d7, 0x3f8b5497, 0x3fda4187, 0x3f9315c7}, - uint32(0xfff80000), - [21]string{"0x7a", "0x00", "0x9f", "0x11", "0x3f", "0x37", "0x5f", "0x73", "0x7d", "0x43", "0x3a", "0x5c", "0x1c", "0xd3", "0x5c", "0xa2", "0x9d", "0xf7", "0x62", "0xde", "0x00"}}, - { - /* No.844 delta:767 weight:1483 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0x8e2486b7, 0x79ff3e78, 0xf7dbb8cf, 0xeee034c1, 0x60c4b276, 0x971f0ab9, 0x193b8c0e, 0x0000e1f0, 0x8e246747, 0x79ffdf88, 0xf7db593f, 0xeee0d531, 0x60c45386, 0x971feb49, 0x193b6dfe}, - [16]uint32{0x00000000, 0x08359dd3, 0x20020d7e, 0x283790ad, 0x00012a0a, 0x0834b7d9, 0x20032774, 0x2836baa7, 0x2001b60b, 0x28342bd8, 0x0003bb75, 0x083626a6, 0x20009c01, 0x283501d2, 0x0002917f, 0x08370cac}, - [16]uint32{0x3f800000, 0x3f841ace, 0x3f900106, 0x3f941bc8, 0x3f800095, 0x3f841a5b, 0x3f900193, 0x3f941b5d, 0x3f9000db, 0x3f941a15, 0x3f8001dd, 0x3f841b13, 0x3f90004e, 0x3f941a80, 0x3f800148, 0x3f841b86}, - uint32(0xfff80000), - [21]string{"0x40", "0xf3", "0xef", "0xfd", "0x9b", "0x3d", "0x5a", "0xda", "0x01", "0x31", "0xf4", "0xc3", "0x06", "0x28", "0x4c", "0x73", "0xb6", "0xec", "0xca", "0xa9", "0x00"}}, - { - /* No.845 delta:930 weight:1421 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0x8645d8e2, 0xa671fb04, 0x203423e6, 0xc40034df, 0x4245ec3d, 0x6271cfdb, 0xe4341739, 0x00009772, 0x86454f90, 0xa6716c76, 0x2034b494, 0xc400a3ad, 0x42457b4f, 0x627158a9, 0xe434804b}, - [16]uint32{0x00000000, 0x80030cd5, 0x0002ec77, 0x8001e0a2, 0x700000ff, 0xf0030c2a, 0x7002ec88, 0xf001e05d, 0x14000010, 0x94030cc5, 0x1402ec67, 0x9401e0b2, 0x640000ef, 0xe4030c3a, 0x6402ec98, 0xe401e04d}, - [16]uint32{0x3f800000, 0x3fc00186, 0x3f800176, 0x3fc000f0, 0x3fb80000, 0x3ff80186, 0x3fb80176, 0x3ff800f0, 0x3f8a0000, 0x3fca0186, 0x3f8a0176, 0x3fca00f0, 0x3fb20000, 0x3ff20186, 0x3fb20176, 0x3ff200f0}, - uint32(0xfff80000), - [21]string{"0xeb", "0x2a", "0x37", "0xbe", "0xf9", "0x32", "0xb1", "0x5c", "0x75", "0x16", "0x97", "0x0f", "0xeb", "0x33", "0x6f", "0xc6", "0x6a", "0xf5", "0xe6", "0x9c", "0x00"}}, - { - /* No.846 delta:623 weight:1511 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xa0078cce, 0xd016dc50, 0x7011509e, 0x32e034ee, 0x92e7b820, 0xe2f6e8be, 0x42f16470, 0x0000d5b3, 0xa007597d, 0xd01609e3, 0x7011852d, 0x32e0e15d, 0x92e76d93, 0xe2f63d0d, 0x42f1b1c3}, - [16]uint32{0x00000000, 0x405559de, 0x006071c9, 0x40352817, 0x0018a20f, 0x404dfbd1, 0x0078d3c6, 0x402d8a18, 0x2026110b, 0x607348d5, 0x204660c2, 0x6013391c, 0x203eb304, 0x606beada, 0x205ec2cd, 0x600b9b13}, - [16]uint32{0x3f800000, 0x3fa02aac, 0x3f803038, 0x3fa01a94, 0x3f800c51, 0x3fa026fd, 0x3f803c69, 0x3fa016c5, 0x3f901308, 0x3fb039a4, 0x3f902330, 0x3fb0099c, 0x3f901f59, 0x3fb035f5, 0x3f902f61, 0x3fb005cd}, - uint32(0xfff80000), - [21]string{"0xe7", "0x59", "0xd2", "0x67", "0xd3", "0x39", "0x05", "0x27", "0xef", "0xec", "0x00", "0x28", "0xcd", "0xd1", "0x4e", "0x01", "0x8e", "0xd8", "0xdb", "0xc4", "0x00"}}, - { - /* No.847 delta:1300 weight:1433 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0xaad29864, 0x6095e27f, 0xca477a1b, 0xccd034ff, 0x6602ac9b, 0xac45d680, 0x06974ee4, 0x0000dbaa, 0xaad243ce, 0x609539d5, 0xca47a1b1, 0xccd0ef55, 0x66027731, 0xac450d2a, 0x0697954e}, - [16]uint32{0x00000000, 0x0074009e, 0x386a6133, 0x381e61ad, 0x000b400a, 0x007f4094, 0x38612139, 0x381521a7, 0x00081017, 0x007c1089, 0x38627124, 0x381671ba, 0x0003501d, 0x00775083, 0x3869312e, 0x381d31b0}, - [16]uint32{0x3f800000, 0x3f803a00, 0x3f9c3530, 0x3f9c0f30, 0x3f8005a0, 0x3f803fa0, 0x3f9c3090, 0x3f9c0a90, 0x3f800408, 0x3f803e08, 0x3f9c3138, 0x3f9c0b38, 0x3f8001a8, 0x3f803ba8, 0x3f9c3498, 0x3f9c0e98}, - uint32(0xfff80000), - [21]string{"0x0a", "0x68", "0x3c", "0x38", "0xf5", "0xc0", "0x88", "0xe7", "0x47", "0x50", "0x79", "0x90", "0xed", "0x72", "0x83", "0x30", "0xad", "0xd9", "0x22", "0x8c", "0x00"}}, - { - /* No.848 delta:722 weight:1627 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xee81bc3b, 0x3973624f, 0xd7f2de74, 0x32a03501, 0xdc21893a, 0x0bd3574e, 0xe552eb75, 0x0000cffb, 0xee8173c0, 0x3973adb4, 0xd7f2118f, 0x32a0fafa, 0xdc2146c1, 0x0bd398b5, 0xe552248e}, - [16]uint32{0x00000000, 0xc008285f, 0x00043512, 0xc00c1d4d, 0x1002058b, 0xd00a2dd4, 0x10063099, 0xd00e18c6, 0x2000001e, 0xe0082841, 0x2004350c, 0xe00c1d53, 0x30020595, 0xf00a2dca, 0x30063087, 0xf00e18d8}, - [16]uint32{0x3f800000, 0x3fe00414, 0x3f80021a, 0x3fe0060e, 0x3f880102, 0x3fe80516, 0x3f880318, 0x3fe8070c, 0x3f900000, 0x3ff00414, 0x3f90021a, 0x3ff0060e, 0x3f980102, 0x3ff80516, 0x3f980318, 0x3ff8070c}, - uint32(0xfff80000), - [21]string{"0x2a", "0xdb", "0xc4", "0x16", "0x10", "0x0b", "0x68", "0xa3", "0xc7", "0xe6", "0xcf", "0x00", "0xca", "0x83", "0xba", "0x07", "0xbf", "0x04", "0x1d", "0x4c", "0x00"}}, - { - /* No.849 delta:760 weight:1487 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x9f024afb, 0xec451fb7, 0x7347554c, 0xd2f03513, 0x4df27fe8, 0x3eb52aa4, 0xa1b7605f, 0x00006f11, 0x9f0225ea, 0xec4570a6, 0x73473a5d, 0xd2f05a02, 0x4df210f9, 0x3eb545b5, 0xa1b70f4e}, - [16]uint32{0x00000000, 0x004ca336, 0x60228151, 0x606e2267, 0x4007887b, 0x404b2b4d, 0x2025092a, 0x2069aa1c, 0x00025018, 0x004ef32e, 0x6020d149, 0x606c727f, 0x4005d863, 0x40497b55, 0x20275932, 0x206bfa04}, - [16]uint32{0x3f800000, 0x3f802651, 0x3fb01140, 0x3fb03711, 0x3fa003c4, 0x3fa02595, 0x3f901284, 0x3f9034d5, 0x3f800128, 0x3f802779, 0x3fb01068, 0x3fb03639, 0x3fa002ec, 0x3fa024bd, 0x3f9013ac, 0x3f9035fd}, - uint32(0xfff80000), - [21]string{"0x3b", "0xe3", "0xfb", "0x6d", "0xb5", "0x84", "0x90", "0x47", "0xff", "0x99", "0x57", "0x50", "0xb7", "0xba", "0x05", "0x6d", "0x5b", "0x1a", "0x18", "0x1d", "0x00"}}, - { - /* No.850 delta:808 weight:1517 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x07823872, 0xa954f449, 0xaed6cc3b, 0x4eb03520, 0x49320d52, 0xe7e4c169, 0xe066f91b, 0x00005c52, 0x07826420, 0xa954a81b, 0xaed69069, 0x4eb06972, 0x49325100, 0xe7e49d3b, 0xe066a549}, - [16]uint32{0x00000000, 0xa0018217, 0x2044609c, 0x8045e28b, 0x40020812, 0xe0038a05, 0x6046688e, 0xc047ea99, 0x400190b8, 0xe00012af, 0x6045f024, 0xc0447233, 0x000398aa, 0xa0021abd, 0x2047f836, 0x80467a21}, - [16]uint32{0x3f800000, 0x3fd000c1, 0x3f902230, 0x3fc022f1, 0x3fa00104, 0x3ff001c5, 0x3fb02334, 0x3fe023f5, 0x3fa000c8, 0x3ff00009, 0x3fb022f8, 0x3fe02239, 0x3f8001cc, 0x3fd0010d, 0x3f9023fc, 0x3fc0233d}, - uint32(0xfff80000), - [21]string{"0x91", "0x3f", "0xc5", "0x59", "0xd5", "0x91", "0xe5", "0x60", "0x04", "0x4e", "0x61", "0x3e", "0xa5", "0xa1", "0xfa", "0x46", "0x8f", "0x8f", "0x18", "0x0c", "0x00"}}, - { - /* No.851 delta:779 weight:1677 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0xe735946a, 0x0cb65430, 0xeb83c05a, 0xb9e03531, 0x5ed5a15b, 0xb5566101, 0x5263f56b, 0x000015f2, 0xe7358198, 0x0cb641c2, 0xeb83d5a8, 0xb9e020c3, 0x5ed5b4a9, 0xb55674f3, 0x5263e099}, - [16]uint32{0x00000000, 0x4040f99e, 0xf0014567, 0xb041bcf9, 0x40108494, 0x00507d0a, 0xb011c1f3, 0xf051386d, 0x30002016, 0x7040d988, 0xc0016571, 0x80419cef, 0x7010a482, 0x30505d1c, 0x8011e1e5, 0xc051187b}, - [16]uint32{0x3f800000, 0x3fa0207c, 0x3ff800a2, 0x3fd820de, 0x3fa00842, 0x3f80283e, 0x3fd808e0, 0x3ff8289c, 0x3f980010, 0x3fb8206c, 0x3fe000b2, 0x3fc020ce, 0x3fb80852, 0x3f98282e, 0x3fc008f0, 0x3fe0288c}, - uint32(0xfff80000), - [21]string{"0x0c", "0xa9", "0xbe", "0x58", "0xb8", "0x9d", "0x41", "0x22", "0x0f", "0xd8", "0xe8", "0x26", "0x54", "0x2d", "0x6e", "0x3d", "0xae", "0xa8", "0xe9", "0x83", "0x00"}}, - { - /* No.852 delta:1020 weight:1639 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0x0fd1901a, 0x960dc7ed, 0x99dc57f7, 0x32603546, 0x3db1a55c, 0xa46df2ab, 0xabbc62b1, 0x00002a86, 0x0fd1ba9c, 0x960ded6b, 0x99dc7d71, 0x32601fc0, 0x3db18fda, 0xa46dd82d, 0xabbc4837}, - [16]uint32{0x00000000, 0x400398d4, 0x2400cb9f, 0x6403534b, 0x6000619d, 0x2003f949, 0x4400aa02, 0x040332d6, 0x101c2407, 0x501fbcd3, 0x341cef98, 0x741f774c, 0x701c459a, 0x301fdd4e, 0x541c8e05, 0x141f16d1}, - [16]uint32{0x3f800000, 0x3fa001cc, 0x3f920065, 0x3fb201a9, 0x3fb00030, 0x3f9001fc, 0x3fa20055, 0x3f820199, 0x3f880e12, 0x3fa80fde, 0x3f9a0e77, 0x3fba0fbb, 0x3fb80e22, 0x3f980fee, 0x3faa0e47, 0x3f8a0f8b}, - uint32(0xfff80000), - [21]string{"0xe9", "0x9b", "0x7c", "0xe6", "0x2f", "0x31", "0x8a", "0xbf", "0x21", "0x64", "0x7e", "0x46", "0xbb", "0x6c", "0xad", "0xf1", "0xc9", "0x37", "0xc7", "0x43", "0x00"}}, - { - /* No.853 delta:1314 weight:1621 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xfb9d60b0, 0x14e6ab38, 0xef7bcb88, 0x69203557, 0x92bd55e7, 0x7dc69e6f, 0x865bfedf, 0x0000969c, 0xfb9df62c, 0x14e63da4, 0xef7b5d14, 0x6920a3cb, 0x92bdc37b, 0x7dc608f3, 0x865b6843}, - [16]uint32{0x00000000, 0x004708f2, 0x042a0c1c, 0x046d04ee, 0x007e0837, 0x003900c5, 0x0454042b, 0x04130cd9, 0x2002301e, 0x204538ec, 0x24283c02, 0x246f34f0, 0x207c3829, 0x203b30db, 0x24563435, 0x24113cc7}, - [16]uint32{0x3f800000, 0x3f802384, 0x3f821506, 0x3f823682, 0x3f803f04, 0x3f801c80, 0x3f822a02, 0x3f820986, 0x3f900118, 0x3f90229c, 0x3f92141e, 0x3f92379a, 0x3f903e1c, 0x3f901d98, 0x3f922b1a, 0x3f92089e}, - uint32(0xfff80000), - [21]string{"0x7d", "0x68", "0x59", "0xb8", "0x79", "0x4c", "0x69", "0x5a", "0xf0", "0xb4", "0x33", "0xc9", "0x73", "0xcd", "0x09", "0xfc", "0x15", "0x44", "0xaa", "0xb1", "0x00"}}, - { - /* No.854 delta:1095 weight:1351 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0x01ebabda, 0x2d7e4768, 0x2c95ecb2, 0xa2d03563, 0xa33b9eb9, 0x8fae720b, 0x8e45d9d1, 0x0000bfca, 0x01eb1410, 0x2d7ef8a2, 0x2c955378, 0xa2d08aa9, 0xa33b2173, 0x8faecdc1, 0x8e45661b}, - [16]uint32{0x00000000, 0x2047d436, 0x303201ae, 0x1075d598, 0x602a6404, 0x406db032, 0x501865aa, 0x705fb19c, 0x00020099, 0x2045d4af, 0x30300137, 0x1077d501, 0x6028649d, 0x406fb0ab, 0x501a6533, 0x705db105}, - [16]uint32{0x3f800000, 0x3f9023ea, 0x3f981900, 0x3f883aea, 0x3fb01532, 0x3fa036d8, 0x3fa80c32, 0x3fb82fd8, 0x3f800100, 0x3f9022ea, 0x3f981800, 0x3f883bea, 0x3fb01432, 0x3fa037d8, 0x3fa80d32, 0x3fb82ed8}, - uint32(0xfff80000), - [21]string{"0x3b", "0xfb", "0xf7", "0x30", "0xe6", "0x76", "0xdd", "0x7a", "0x52", "0x4c", "0x32", "0x29", "0x5c", "0x6b", "0xa9", "0x38", "0x4f", "0xab", "0x5f", "0x6e", "0x00"}}, - { - /* No.855 delta:1459 weight:1741 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0xbe48330e, 0x523806b5, 0xec7035bb, 0xaba03572, 0x15e8067c, 0xf99833c7, 0x47d000c9, 0x00006aba, 0xbe4859b4, 0x52386c0f, 0xec705f01, 0xaba05fc8, 0x15e86cc6, 0xf998597d, 0x47d06a73}, - [16]uint32{0x00000000, 0x40140c5e, 0x328c1815, 0x7298144b, 0x005581d6, 0x40418d88, 0x32d999c3, 0x72cd959d, 0x0042001c, 0x40560c42, 0x32ce1809, 0x72da1457, 0x001781ca, 0x40038d94, 0x329b99df, 0x728f9581}, - [16]uint32{0x3f800000, 0x3fa00a06, 0x3f99460c, 0x3fb94c0a, 0x3f802ac0, 0x3fa020c6, 0x3f996ccc, 0x3fb966ca, 0x3f802100, 0x3fa02b06, 0x3f99670c, 0x3fb96d0a, 0x3f800bc0, 0x3fa001c6, 0x3f994dcc, 0x3fb947ca}, - uint32(0xfff80000), - [21]string{"0xe8", "0x70", "0x31", "0x7f", "0x52", "0x23", "0x6c", "0xd5", "0x38", "0x42", "0xbf", "0x4e", "0xd2", "0xbf", "0xb2", "0xb9", "0x9f", "0xaa", "0x8d", "0x86", "0x00"}}, - { - /* No.856 delta:1176 weight:1489 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0x771de0bc, 0x487dcba4, 0x3f602b18, 0xa9803585, 0xde9dd539, 0xe1fdfe21, 0x96e01e9d, 0x00007036, 0x771d908a, 0x487dbb92, 0x3f605b2e, 0xa98045b3, 0xde9da50f, 0xe1fd8e17, 0x96e06eab}, - [16]uint32{0x00000000, 0x29000412, 0xe805e89b, 0xc105ec89, 0x200380d6, 0x090384c4, 0xc806684d, 0xe1066c5f, 0x4010801a, 0x69108408, 0xa8156881, 0x81156c93, 0x601300cc, 0x491304de, 0x8816e857, 0xa116ec45}, - [16]uint32{0x3f800000, 0x3f948002, 0x3ff402f4, 0x3fe082f6, 0x3f9001c0, 0x3f8481c2, 0x3fe40334, 0x3ff08336, 0x3fa00840, 0x3fb48842, 0x3fd40ab4, 0x3fc08ab6, 0x3fb00980, 0x3fa48982, 0x3fc40b74, 0x3fd08b76}, - uint32(0xfff80000), - [21]string{"0xa1", "0x85", "0xa4", "0x74", "0x47", "0x22", "0xb1", "0xca", "0xcf", "0x61", "0x87", "0x50", "0xfa", "0xc0", "0x6c", "0x9f", "0x12", "0x5b", "0xbb", "0x6c", "0x00"}}, - { - /* No.857 delta:1294 weight:1559 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x973e91db, 0x489ce950, 0xdfa2788b, 0x63603592, 0xf45ea449, 0x2bfcdcc2, 0xbcc24d19, 0x00009981, 0x973e085a, 0x489c70d1, 0xdfa2e10a, 0x6360ac13, 0xf45e3dc8, 0x2bfc4543, 0xbcc2d498}, - [16]uint32{0x00000000, 0xc468431a, 0x10647437, 0xd40c372d, 0x001a8205, 0xc472c11f, 0x107ef632, 0xd416b528, 0x1000300b, 0xd4687311, 0x0064443c, 0xc40c0726, 0x101ab20e, 0xd472f114, 0x007ec639, 0xc4168523}, - [16]uint32{0x3f800000, 0x3fe23421, 0x3f88323a, 0x3fea061b, 0x3f800d41, 0x3fe23960, 0x3f883f7b, 0x3fea0b5a, 0x3f880018, 0x3fea3439, 0x3f803222, 0x3fe20603, 0x3f880d59, 0x3fea3978, 0x3f803f63, 0x3fe20b42}, - uint32(0xfff80000), - [21]string{"0xfd", "0x07", "0x97", "0x8b", "0x67", "0x71", "0xde", "0x8a", "0xb5", "0xd0", "0xc0", "0xf1", "0x88", "0xc2", "0xbd", "0x8b", "0x48", "0xac", "0x7f", "0x21", "0x00"}}, - { - /* No.858 delta:779 weight:1681 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xf669042d, 0xed50870f, 0x1b398322, 0x139035ae, 0xe5f93183, 0xfec0b2a1, 0x08a9b68c, 0x00008bb7, 0xf6698f9a, 0xed500cb8, 0x1b390895, 0x1390be19, 0xe5f9ba34, 0xfec03916, 0x08a93d3b}, - [16]uint32{0x00000000, 0x001e0c56, 0x004a16aa, 0x00541afc, 0x30234817, 0x303d4441, 0x30695ebd, 0x307752eb, 0x30025843, 0x301c5415, 0x30484ee9, 0x305642bf, 0x00211054, 0x003f1c02, 0x006b06fe, 0x00750aa8}, - [16]uint32{0x3f800000, 0x3f800f06, 0x3f80250b, 0x3f802a0d, 0x3f9811a4, 0x3f981ea2, 0x3f9834af, 0x3f983ba9, 0x3f98012c, 0x3f980e2a, 0x3f982427, 0x3f982b21, 0x3f801088, 0x3f801f8e, 0x3f803583, 0x3f803a85}, - uint32(0xfff80000), - [21]string{"0xc1", "0x52", "0xc1", "0x57", "0x42", "0xd5", "0xf8", "0x98", "0x38", "0xbd", "0xd4", "0xb4", "0x05", "0x06", "0x0f", "0xb6", "0xd7", "0xa7", "0x1d", "0xf2", "0x00"}}, - { - /* No.859 delta:956 weight:1207 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0xe97116c4, 0x33c94c1d, 0xdab85ad9, 0x305035b0, 0xd9212374, 0x039979ad, 0xeae86f69, 0x0000ea7b, 0xe971fcbf, 0x33c9a666, 0xdab8b0a2, 0x3050dfcb, 0xd921c90f, 0x039993d6, 0xeae88512}, - [16]uint32{0x00000000, 0x000341dd, 0x4000118c, 0x40035051, 0x100338a6, 0x1000797b, 0x5003292a, 0x500068f7, 0x10023402, 0x100175df, 0x5002258e, 0x50016453, 0x00010ca4, 0x00024d79, 0x40011d28, 0x40025cf5}, - [16]uint32{0x3f800000, 0x3f8001a0, 0x3fa00008, 0x3fa001a8, 0x3f88019c, 0x3f88003c, 0x3fa80194, 0x3fa80034, 0x3f88011a, 0x3f8800ba, 0x3fa80112, 0x3fa800b2, 0x3f800086, 0x3f800126, 0x3fa0008e, 0x3fa0012e}, - uint32(0xfff80000), - [21]string{"0x79", "0x3c", "0x21", "0x5c", "0xd4", "0xcf", "0x6f", "0x09", "0x5e", "0xa0", "0x97", "0xcc", "0x76", "0x83", "0x9e", "0xb3", "0x4e", "0x00", "0xeb", "0x73", "0x00"}}, - { - /* No.860 delta:983 weight:1513 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0x0e245ebd, 0xeff14ad1, 0xe1d5146c, 0x1a7035c0, 0x14546b7d, 0xf5817f11, 0xfba521ac, 0x00007c15, 0x0e2422a8, 0xeff136c4, 0xe1d56879, 0x1a7049d5, 0x14541768, 0xf5810304, 0xfba55db9}, - [16]uint32{0x00000000, 0x58f4143f, 0x00021c4a, 0x58f60875, 0x043c0a06, 0x5cc81e39, 0x043e164c, 0x5cca0273, 0x00234814, 0x58d75c2b, 0x0021545e, 0x58d54061, 0x041f4212, 0x5ceb562d, 0x041d5e58, 0x5ce94a67}, - [16]uint32{0x3f800000, 0x3fac7a0a, 0x3f80010e, 0x3fac7b04, 0x3f821e05, 0x3fae640f, 0x3f821f0b, 0x3fae6501, 0x3f8011a4, 0x3fac6bae, 0x3f8010aa, 0x3fac6aa0, 0x3f820fa1, 0x3fae75ab, 0x3f820eaf, 0x3fae74a5}, - uint32(0xfff80000), - [21]string{"0x5f", "0xdc", "0xbd", "0x29", "0x0d", "0x42", "0xe3", "0x7f", "0x25", "0x3a", "0x82", "0xef", "0xeb", "0x90", "0xee", "0xb7", "0xd5", "0x76", "0x12", "0xcb", "0x00"}}, - { - /* No.861 delta:731 weight:1489 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0x7999a149, 0xc1bc8ad0, 0xb8252b99, 0xa2e035db, 0xdb799492, 0x635cbf0b, 0x1ac51e42, 0x00002e49, 0x79998f00, 0xc1bca499, 0xb82505d0, 0xa2e01b92, 0xdb79badb, 0x635c9142, 0x1ac5300b}, - [16]uint32{0x00000000, 0x007488b6, 0x4000317c, 0x4074b9ca, 0x6001a04d, 0x607528fb, 0x20019131, 0x20751987, 0x6002419f, 0x6076c929, 0x200270e3, 0x2076f855, 0x0003e1d2, 0x00776964, 0x4003d0ae, 0x40775818}, - [16]uint32{0x3f800000, 0x3f803a44, 0x3fa00018, 0x3fa03a5c, 0x3fb000d0, 0x3fb03a94, 0x3f9000c8, 0x3f903a8c, 0x3fb00120, 0x3fb03b64, 0x3f900138, 0x3f903b7c, 0x3f8001f0, 0x3f803bb4, 0x3fa001e8, 0x3fa03bac}, - uint32(0xfff80000), - [21]string{"0x76", "0xe9", "0x83", "0x20", "0x49", "0xec", "0x86", "0xea", "0x99", "0x32", "0xdb", "0x54", "0x92", "0x99", "0x5b", "0x5d", "0x98", "0x5e", "0x63", "0x13", "0x00"}}, - { - /* No.862 delta:1141 weight:1621 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x10b14888, 0xead94d30, 0xfa6805b8, 0xed6035ec, 0xfdd17d64, 0x07b978dc, 0x17083054, 0x0000ac0f, 0x10b1e487, 0xead9e13f, 0xfa68a9b7, 0xed6099e3, 0xfdd1d16b, 0x07b9d4d3, 0x17089c5b}, - [16]uint32{0x00000000, 0x9410c0b6, 0x2002c893, 0xb4120825, 0x20016148, 0xb411a1fe, 0x0003a9db, 0x9413696d, 0x407fe017, 0xd46f20a1, 0x607d2884, 0xf46de832, 0x607e815f, 0xf46e41e9, 0x407c49cc, 0xd46c897a}, - [16]uint32{0x3f800000, 0x3fca0860, 0x3f900164, 0x3fda0904, 0x3f9000b0, 0x3fda08d0, 0x3f8001d4, 0x3fca09b4, 0x3fa03ff0, 0x3fea3790, 0x3fb03e94, 0x3ffa36f4, 0x3fb03f40, 0x3ffa3720, 0x3fa03e24, 0x3fea3644}, - uint32(0xfff80000), - [21]string{"0x2d", "0x56", "0x85", "0x1c", "0x96", "0x52", "0xef", "0xf5", "0xaa", "0x3d", "0xf7", "0x74", "0xed", "0x2c", "0x37", "0xce", "0xec", "0xe6", "0xbc", "0x8a", "0x00"}}, - { - /* No.863 delta:1001 weight:1425 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x59bce008, 0xd8404bfa, 0x81fcabf2, 0xc1a035ff, 0x981cd5f7, 0x19e07e05, 0x405c9e0d, 0x000063f5, 0x59bc83fd, 0xd840280f, 0x81fcc807, 0xc1a0560a, 0x981cb602, 0x19e01df0, 0x405cfdf8}, - [16]uint32{0x00000000, 0x002d08ba, 0x00542c71, 0x007924cb, 0x0004341e, 0x00293ca4, 0x0050186f, 0x007d10d5, 0x110111e8, 0x112c1952, 0x11553d99, 0x11783523, 0x110525f6, 0x11282d4c, 0x11510987, 0x117c013d}, - [16]uint32{0x3f800000, 0x3f801684, 0x3f802a16, 0x3f803c92, 0x3f80021a, 0x3f80149e, 0x3f80280c, 0x3f803e88, 0x3f888088, 0x3f88960c, 0x3f88aa9e, 0x3f88bc1a, 0x3f888292, 0x3f889416, 0x3f88a884, 0x3f88be00}, - uint32(0xfff80000), - [21]string{"0xcc", "0x22", "0x57", "0xe8", "0xc9", "0x5c", "0xeb", "0x4c", "0x25", "0x7d", "0x58", "0x73", "0x0b", "0x07", "0xda", "0x05", "0x8c", "0x89", "0xc8", "0x64", "0x00"}}, - { - /* No.864 delta:1314 weight:1519 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0xdf30e092, 0x48956890, 0x97a58802, 0x10903608, 0xcfa0d69a, 0x58055e98, 0x8735be0a, 0x00007231, 0xdf3092a3, 0x48951aa1, 0x97a5fa33, 0x10904439, 0xcfa0a4ab, 0x58052ca9, 0x8735cc3b}, - [16]uint32{0x00000000, 0xc07d1c5a, 0x200221f7, 0xe07f3dad, 0x00670903, 0xc01a1559, 0x206528f4, 0xe01834ae, 0x001841c8, 0xc0655d92, 0x201a603f, 0xe0677c65, 0x007f48cb, 0xc0025491, 0x207d693c, 0xe0007566}, - [16]uint32{0x3f800000, 0x3fe03e8e, 0x3f900110, 0x3ff03f9e, 0x3f803384, 0x3fe00d0a, 0x3f903294, 0x3ff00c1a, 0x3f800c20, 0x3fe032ae, 0x3f900d30, 0x3ff033be, 0x3f803fa4, 0x3fe0012a, 0x3f903eb4, 0x3ff0003a}, - uint32(0xfff80000), - [21]string{"0xe0", "0x27", "0x66", "0x12", "0x3c", "0xb7", "0xa4", "0xb4", "0xd5", "0x59", "0xc5", "0xe2", "0xb3", "0x88", "0x48", "0x8a", "0xd4", "0xb7", "0xe7", "0x30", "0x00"}}, - { - /* No.865 delta:942 weight:987 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0xcae33203, 0x6dac87eb, 0xa74fb5e8, 0x35503619, 0xffb3041a, 0x58fcb1f2, 0x921f83f1, 0x0000a0f6, 0xcae392f5, 0x6dac271d, 0xa74f151e, 0x355096ef, 0xffb3a4ec, 0x58fc1104, 0x921f2307}, - [16]uint32{0x00000000, 0x006200ba, 0x401100d3, 0x40730069, 0x400ee0be, 0x406ce004, 0x001fe06d, 0x007de0d7, 0x10190010, 0x107b00aa, 0x500800c3, 0x506a0079, 0x5017e0ae, 0x5075e014, 0x1006e07d, 0x1064e0c7}, - [16]uint32{0x3f800000, 0x3f803100, 0x3fa00880, 0x3fa03980, 0x3fa00770, 0x3fa03670, 0x3f800ff0, 0x3f803ef0, 0x3f880c80, 0x3f883d80, 0x3fa80400, 0x3fa83500, 0x3fa80bf0, 0x3fa83af0, 0x3f880370, 0x3f883270}, - uint32(0xfff80000), - [21]string{"0x7a", "0xc2", "0x27", "0x92", "0xec", "0x83", "0x41", "0x36", "0x20", "0x1e", "0x63", "0x6f", "0x5a", "0x73", "0xb9", "0xe7", "0xe5", "0x5f", "0xae", "0xc2", "0x00"}}, - { - /* No.866 delta:903 weight:1561 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x6fbfa028, 0x651705ec, 0x0aa8a5c4, 0xb0303621, 0xdf8f9609, 0xd52733cd, 0xba9893e5, 0x0000fdf9, 0x6fbf5dd1, 0x6517f815, 0x0aa8583d, 0xb030cbd8, 0xdf8f6bf0, 0xd527ce34, 0xba986e1c}, - [16]uint32{0x00000000, 0x204c0152, 0x0002d1dd, 0x204ed08f, 0x40208403, 0x606c8551, 0x402255de, 0x606e548c, 0x001187f7, 0x205d86a5, 0x0013562a, 0x205f5778, 0x403103f4, 0x607d02a6, 0x4033d229, 0x607fd37b}, - [16]uint32{0x3f800000, 0x3f902600, 0x3f800168, 0x3f902768, 0x3fa01042, 0x3fb03642, 0x3fa0112a, 0x3fb0372a, 0x3f8008c3, 0x3f902ec3, 0x3f8009ab, 0x3f902fab, 0x3fa01881, 0x3fb03e81, 0x3fa019e9, 0x3fb03fe9}, - uint32(0xfff80000), - [21]string{"0xb6", "0xc5", "0x1d", "0x52", "0x4e", "0x27", "0x15", "0xf8", "0x3f", "0x41", "0x0a", "0x93", "0x64", "0xdd", "0xdc", "0x0b", "0x9a", "0x6e", "0x4c", "0x53", "0x00"}}, - { - /* No.867 delta:995 weight:1579 */ - 11213, - 34, - 13, - 4, - [16]uint32{0x00000000, 0xe997bc00, 0x40346e90, 0xa9a3d290, 0x68f03633, 0x81678a33, 0x28c458a3, 0xc153e4a3, 0x00003483, 0xe9978883, 0x40345a13, 0xa9a3e613, 0x68f002b0, 0x8167beb0, 0x28c46c20, 0xc153d020}, - [16]uint32{0x00000000, 0xb0061bf4, 0x005d0d9d, 0xb05b1669, 0x0002b812, 0xb004a3e6, 0x005fb58f, 0xb059ae7b, 0x403c0158, 0xf03a1aac, 0x40610cc5, 0xf0671731, 0x403eb94a, 0xf038a2be, 0x4063b4d7, 0xf065af23}, - [16]uint32{0x3f800000, 0x3fd8030d, 0x3f802e86, 0x3fd82d8b, 0x3f80015c, 0x3fd80251, 0x3f802fda, 0x3fd82cd7, 0x3fa01e00, 0x3ff81d0d, 0x3fa03086, 0x3ff8338b, 0x3fa01f5c, 0x3ff81c51, 0x3fa031da, 0x3ff832d7}, - uint32(0xfff80000), - [21]string{"0x6a", "0x0d", "0x6e", "0x70", "0xac", "0x49", "0x3a", "0xdd", "0x75", "0xec", "0xe6", "0xae", "0xa7", "0x25", "0x75", "0xd9", "0xca", "0xd2", "0x30", "0xc2", "0x00"}}, - { - /* No.868 delta:2268 weight:1323 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0xdc7cb726, 0x38617a10, 0xe41dcd36, 0x1a40364a, 0xc63c816c, 0x22214c5a, 0xfe5dfb7c, 0x000044f9, 0xdc7cf3df, 0x38613ee9, 0xe41d89cf, 0x1a4072b3, 0xc63cc595, 0x222108a3, 0xfe5dbf85}, - [16]uint32{0x00000000, 0x44390bb6, 0x7048083c, 0x3471038a, 0x0c4041bb, 0x48794a0d, 0x7c084987, 0x38314231, 0x020855c3, 0x46315e75, 0x72405dff, 0x36795649, 0x0e481478, 0x4a711fce, 0x7e001c44, 0x3a3917f2}, - [16]uint32{0x3f800000, 0x3fa21c85, 0x3fb82404, 0x3f9a3881, 0x3f862020, 0x3fa43ca5, 0x3fbe0424, 0x3f9c18a1, 0x3f81042a, 0x3fa318af, 0x3fb9202e, 0x3f9b3cab, 0x3f87240a, 0x3fa5388f, 0x3fbf000e, 0x3f9d1c8b}, - uint32(0xfff80000), - [21]string{"0x4a", "0x0e", "0xd2", "0x58", "0x0d", "0x8a", "0xd5", "0x98", "0x04", "0xe8", "0x45", "0x15", "0x8d", "0xbf", "0xbc", "0x47", "0x75", "0x57", "0x51", "0xbb", "0x00"}}, - { - /* No.869 delta:946 weight:989 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0xceec2799, 0xd9de0701, 0x17322098, 0x17503659, 0xd9bc11c0, 0xce8e3158, 0x006216c1, 0x00004052, 0xceec67cb, 0xd9de4753, 0x173260ca, 0x1750760b, 0xd9bc5192, 0xce8e710a, 0x00625693}, - [16]uint32{0x00000000, 0x1073887f, 0x003c811d, 0x104f0962, 0x04004c19, 0x1473c466, 0x043ccd04, 0x144f457b, 0x007079d6, 0x1003f1a9, 0x004cf8cb, 0x103f70b4, 0x047035cf, 0x1403bdb0, 0x044cb4d2, 0x143f3cad}, - [16]uint32{0x3f800000, 0x3f8839c4, 0x3f801e40, 0x3f882784, 0x3f820026, 0x3f8a39e2, 0x3f821e66, 0x3f8a27a2, 0x3f80383c, 0x3f8801f8, 0x3f80267c, 0x3f881fb8, 0x3f82381a, 0x3f8a01de, 0x3f82265a, 0x3f8a1f9e}, - uint32(0xfff80000), - [21]string{"0xf7", "0xbb", "0x17", "0x9f", "0x1d", "0x34", "0xfd", "0xfd", "0x62", "0x4b", "0x8c", "0xf4", "0xa0", "0x16", "0xe6", "0x9d", "0x9c", "0x85", "0x41", "0x5d", "0x00"}}, - { - /* No.870 delta:642 weight:1347 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0xc995bfae, 0xa256e02b, 0x6bc35f85, 0x20d03669, 0xe94589c7, 0x8286d642, 0x4b1369ec, 0x0000c57d, 0xc9957ad3, 0xa2562556, 0x6bc39af8, 0x20d0f314, 0xe9454cba, 0x8286133f, 0x4b13ac91}, - [16]uint32{0x00000000, 0x09025252, 0x0403217c, 0x0d01732e, 0x2002080b, 0x29005a59, 0x24012977, 0x2d037b25, 0x1000100d, 0x1902425f, 0x14033171, 0x1d016323, 0x30021806, 0x39004a54, 0x3401397a, 0x3d036b28}, - [16]uint32{0x3f800000, 0x3f848129, 0x3f820190, 0x3f8680b9, 0x3f900104, 0x3f94802d, 0x3f920094, 0x3f9681bd, 0x3f880008, 0x3f8c8121, 0x3f8a0198, 0x3f8e80b1, 0x3f98010c, 0x3f9c8025, 0x3f9a009c, 0x3f9e81b5}, - uint32(0xfff80000), - [21]string{"0xb4", "0xa9", "0x35", "0xad", "0xf3", "0xa9", "0x37", "0xdc", "0x5a", "0x13", "0x87", "0x6a", "0x41", "0x36", "0x38", "0x20", "0xa3", "0x72", "0xac", "0x6b", "0x00"}}, - { - /* No.871 delta:964 weight:747 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x9a4c8644, 0xb9bb929f, 0x23f714db, 0x89a0367e, 0x13ecb03a, 0x301ba4e1, 0xaa5722a5, 0x00005b8e, 0x9a4cddca, 0xb9bbc911, 0x23f74f55, 0x89a06df0, 0x13ecebb4, 0x301bff6f, 0xaa57792b}, - [16]uint32{0x00000000, 0x0024021f, 0x4002541c, 0x40265603, 0x10052cce, 0x10212ed1, 0x500778d2, 0x50237acd, 0x90428d0b, 0x90668f14, 0xd040d917, 0xd064db08, 0x8047a1c5, 0x8063a3da, 0xc045f5d9, 0xc061f7c6}, - [16]uint32{0x3f800000, 0x3f801201, 0x3fa0012a, 0x3fa0132b, 0x3f880296, 0x3f881097, 0x3fa803bc, 0x3fa811bd, 0x3fc82146, 0x3fc83347, 0x3fe8206c, 0x3fe8326d, 0x3fc023d0, 0x3fc031d1, 0x3fe022fa, 0x3fe030fb}, - uint32(0xfff80000), - [21]string{"0x6f", "0xf0", "0xf9", "0x07", "0x81", "0xff", "0xbf", "0xe7", "0xde", "0x62", "0x6d", "0x91", "0x9b", "0x5e", "0x9c", "0x7a", "0x93", "0x0b", "0x24", "0xd8", "0x00"}}, - { - /* No.872 delta:639 weight:1661 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xabf0eda5, 0x019669b4, 0xaa668411, 0x20e03687, 0x8b10db22, 0x21765f33, 0x8a86b296, 0x000013b0, 0xabf0fe15, 0x01967a04, 0xaa6697a1, 0x20e02537, 0x8b10c892, 0x21764c83, 0x8a86a126}, - [16]uint32{0x00000000, 0x40082add, 0x00047a8c, 0x400c5051, 0x60403c05, 0x204816d8, 0x60444689, 0x204c6c54, 0x5064840a, 0x106caed7, 0x5060fe86, 0x1068d45b, 0x3024b80f, 0x702c92d2, 0x3020c283, 0x7028e85e}, - [16]uint32{0x3f800000, 0x3fa00415, 0x3f80023d, 0x3fa00628, 0x3fb0201e, 0x3f90240b, 0x3fb02223, 0x3f902636, 0x3fa83242, 0x3f883657, 0x3fa8307f, 0x3f88346a, 0x3f98125c, 0x3fb81649, 0x3f981061, 0x3fb81474}, - uint32(0xfff80000), - [21]string{"0x5e", "0x0f", "0x90", "0xe4", "0x27", "0x62", "0xe7", "0x76", "0xdf", "0xac", "0xe5", "0x05", "0x37", "0x2b", "0xf7", "0xcf", "0x1b", "0x97", "0x61", "0x9d", "0x00"}}, - { - /* No.873 delta:1277 weight:1617 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x92223d35, 0xc803359d, 0x5a2108a8, 0xbbc03699, 0x29e20bac, 0x73c30304, 0xe1e13e31, 0x00007ecb, 0x922243fe, 0xc8034b56, 0x5a217663, 0xbbc04852, 0x29e27567, 0x73c37dcf, 0xe1e140fa}, - [16]uint32{0x00000000, 0x166c40fa, 0x1072c1db, 0x061e8121, 0x0048201c, 0x162460e6, 0x103ae1c7, 0x0656a13d, 0x0024804a, 0x1648c0b0, 0x10564191, 0x063a016b, 0x006ca056, 0x1600e0ac, 0x101e618d, 0x06722177}, - [16]uint32{0x3f800000, 0x3f8b3620, 0x3f883960, 0x3f830f40, 0x3f802410, 0x3f8b1230, 0x3f881d70, 0x3f832b50, 0x3f801240, 0x3f8b2460, 0x3f882b20, 0x3f831d00, 0x3f803650, 0x3f8b0070, 0x3f880f30, 0x3f833910}, - uint32(0xfff80000), - [21]string{"0x9a", "0x75", "0xc2", "0x26", "0x42", "0x6d", "0xd3", "0x58", "0xa0", "0x0c", "0xc5", "0xe4", "0x5b", "0xa8", "0x66", "0x13", "0xc6", "0x7b", "0x9d", "0x53", "0x00"}}, - { - /* No.874 delta:1547 weight:1545 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x2101072b, 0x9f9b424d, 0xbe9a4566, 0xdb7036af, 0xfa713184, 0x44eb74e2, 0x65ea73c9, 0x0000e270, 0x2101e55b, 0x9f9ba03d, 0xbe9aa716, 0xdb70d4df, 0xfa71d3f4, 0x44eb9692, 0x65ea91b9}, - [16]uint32{0x00000000, 0x004e80bd, 0x0072611b, 0x003ce1a6, 0x006c0158, 0x002281e5, 0x001e6043, 0x0050e0fe, 0x00022094, 0x004ca029, 0x0070418f, 0x003ec132, 0x006e21cc, 0x0020a171, 0x001c40d7, 0x0052c06a}, - [16]uint32{0x3f800000, 0x3f802740, 0x3f803930, 0x3f801e70, 0x3f803600, 0x3f801140, 0x3f800f30, 0x3f802870, 0x3f800110, 0x3f802650, 0x3f803820, 0x3f801f60, 0x3f803710, 0x3f801050, 0x3f800e20, 0x3f802960}, - uint32(0xfff80000), - [21]string{"0xf7", "0x13", "0xbd", "0x63", "0x07", "0xbe", "0xd7", "0x1e", "0xc7", "0x67", "0xb4", "0xe2", "0xd4", "0xfa", "0x66", "0x2a", "0xd0", "0x05", "0x26", "0x60", "0x00"}}, - { - /* No.875 delta:1557 weight:1661 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0xfb67e68a, 0x70384856, 0x8b5faedc, 0x96d036b7, 0x6db7d03d, 0xe6e87ee1, 0x1d8f986b, 0x0000b1b9, 0xfb675733, 0x7038f9ef, 0x8b5f1f65, 0x96d0870e, 0x6db76184, 0xe6e8cf58, 0x1d8f29d2}, - [16]uint32{0x00000000, 0x20204d1e, 0x16fb0414, 0x36db490a, 0x2444c132, 0x04648c2c, 0x32bfc526, 0x129f8838, 0x5000a017, 0x7020ed09, 0x46fba403, 0x66dbe91d, 0x74446125, 0x54642c3b, 0x62bf6531, 0x429f282f}, - [16]uint32{0x3f800000, 0x3f901026, 0x3f8b7d82, 0x3f9b6da4, 0x3f922260, 0x3f823246, 0x3f995fe2, 0x3f894fc4, 0x3fa80050, 0x3fb81076, 0x3fa37dd2, 0x3fb36df4, 0x3fba2230, 0x3faa3216, 0x3fb15fb2, 0x3fa14f94}, - uint32(0xfff80000), - [21]string{"0x1b", "0x2c", "0xda", "0xc0", "0xcd", "0x57", "0x5c", "0xa3", "0x5e", "0x5e", "0xb6", "0x64", "0xe9", "0xb0", "0xbf", "0x11", "0x71", "0xbf", "0xaa", "0xd6", "0x00"}}, - { - /* No.876 delta:908 weight:1165 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x525ea5b4, 0xab0118d9, 0xf95fbd6d, 0x362036c9, 0x647e937d, 0x9d212e10, 0xcf7f8ba4, 0x00008bac, 0x525e2e18, 0xab019375, 0xf95f36c1, 0x3620bd65, 0x647e18d1, 0x9d21a5bc, 0xcf7f0008}, - [16]uint32{0x00000000, 0x004d0713, 0x7703101f, 0x774e170c, 0x0002d338, 0x004fd42b, 0x7701c327, 0x774cc434, 0x00017805, 0x004c7f16, 0x7702681a, 0x774f6f09, 0x0003ab3d, 0x004eac2e, 0x7700bb22, 0x774dbc31}, - [16]uint32{0x3f800000, 0x3f802683, 0x3fbb8188, 0x3fbba70b, 0x3f800169, 0x3f8027ea, 0x3fbb80e1, 0x3fbba662, 0x3f8000bc, 0x3f80263f, 0x3fbb8134, 0x3fbba7b7, 0x3f8001d5, 0x3f802756, 0x3fbb805d, 0x3fbba6de}, - uint32(0xfff80000), - [21]string{"0x26", "0x50", "0x8b", "0xaa", "0x16", "0x7c", "0x00", "0x6b", "0x02", "0xc1", "0xeb", "0xe8", "0x05", "0xbf", "0xb1", "0xbd", "0xc0", "0x77", "0x65", "0x5d", "0x00"}}, - { - /* No.877 delta:877 weight:1003 */ - 11213, - 70, - 13, - 4, - [16]uint32{0x00000000, 0x2f911523, 0xd308881f, 0xfc999d3c, 0x8e1036da, 0xa18123f9, 0x5d18bec5, 0x7289abe6, 0x00002e80, 0x2f913ba3, 0xd308a69f, 0xfc99b3bc, 0x8e10185a, 0xa1810d79, 0x5d189045, 0x72898566}, - [16]uint32{0x00000000, 0x1065da1b, 0x50130aca, 0x4076d0d1, 0x50088075, 0x406d5a6e, 0x001b8abf, 0x107e50a4, 0x00482196, 0x102dfb8d, 0x505b2b5c, 0x403ef147, 0x5040a1e3, 0x40257bf8, 0x0053ab29, 0x10367132}, - [16]uint32{0x3f800000, 0x3f8832ed, 0x3fa80985, 0x3fa03b68, 0x3fa80440, 0x3fa036ad, 0x3f800dc5, 0x3f883f28, 0x3f802410, 0x3f8816fd, 0x3fa82d95, 0x3fa01f78, 0x3fa82050, 0x3fa012bd, 0x3f8029d5, 0x3f881b38}, - uint32(0xfff80000), - [21]string{"0x99", "0x0b", "0x82", "0xb9", "0x1d", "0xce", "0xe8", "0x83", "0xe3", "0xe2", "0x8c", "0x18", "0xa0", "0x47", "0x49", "0x75", "0x3b", "0xb7", "0x0d", "0xd9", "0x00"}}, - { - /* No.878 delta:860 weight:1667 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x93d31824, 0x7ca5708d, 0xef7668a9, 0xef6036ec, 0x7cb32ec8, 0x93c54661, 0x00165e45, 0x0000abb1, 0x93d3b395, 0x7ca5db3c, 0xef76c318, 0xef609d5d, 0x7cb38579, 0x93c5edd0, 0x0016f5f4}, - [16]uint32{0x00000000, 0x0002e1b2, 0x100081de, 0x1002606c, 0x30009104, 0x300270b6, 0x200010da, 0x2002f168, 0x64804017, 0x6482a1a5, 0x7480c1c9, 0x7482207b, 0x5480d113, 0x548230a1, 0x448050cd, 0x4482b17f}, - [16]uint32{0x3f800000, 0x3f800170, 0x3f880040, 0x3f880130, 0x3f980048, 0x3f980138, 0x3f900008, 0x3f900178, 0x3fb24020, 0x3fb24150, 0x3fba4060, 0x3fba4110, 0x3faa4068, 0x3faa4118, 0x3fa24028, 0x3fa24158}, - uint32(0xfff80000), - [21]string{"0x6d", "0x1b", "0xb1", "0x33", "0x2d", "0xc0", "0x59", "0x30", "0x13", "0xcb", "0x07", "0x05", "0xb2", "0x03", "0x87", "0x09", "0x48", "0xc5", "0x27", "0xae", "0x00"}}, - { - /* No.879 delta:1043 weight:1415 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xd85b0140, 0xe0c80f47, 0x38930e07, 0xafb036fb, 0x77eb37bb, 0x4f7839bc, 0x972338fc, 0x0000d26a, 0xd85bd32a, 0xe0c8dd2d, 0x3893dc6d, 0xafb0e491, 0x77ebe5d1, 0x4f78ebd6, 0x9723ea96}, - [16]uint32{0x00000000, 0x40022d36, 0x205c10f5, 0x605e3dc3, 0x5008001d, 0x100a2d2b, 0x705410e8, 0x30563dde, 0x400104b3, 0x00032985, 0x605d1446, 0x205f3970, 0x100904ae, 0x500b2998, 0x3055145b, 0x7057396d}, - [16]uint32{0x3f800000, 0x3fa00116, 0x3f902e08, 0x3fb02f1e, 0x3fa80400, 0x3f880516, 0x3fb82a08, 0x3f982b1e, 0x3fa00082, 0x3f800194, 0x3fb02e8a, 0x3f902f9c, 0x3f880482, 0x3fa80594, 0x3f982a8a, 0x3fb82b9c}, - uint32(0xfff80000), - [21]string{"0x46", "0x33", "0x05", "0xd4", "0x65", "0x7a", "0xee", "0xe4", "0x96", "0x70", "0x97", "0xd2", "0x5c", "0x46", "0x2c", "0x9c", "0x86", "0x9a", "0x5c", "0x0f", "0x00"}}, - { - /* No.880 delta:892 weight:1667 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0x74bfc8fe, 0x020f0ad0, 0x76b0c22e, 0xcef03703, 0xba4ffffd, 0xccff3dd3, 0xb840f52d, 0x000080e4, 0x74bf481a, 0x020f8a34, 0x76b042ca, 0xcef0b7e7, 0xba4f7f19, 0xccffbd37, 0xb84075c9}, - [16]uint32{0x00000000, 0x100240ba, 0x4003206f, 0x500160d5, 0x7001001e, 0x600340a4, 0x30022071, 0x200060cb, 0x6000a418, 0x7002e4a2, 0x20038477, 0x3001c4cd, 0x1001a406, 0x0003e4bc, 0x50028469, 0x4000c4d3}, - [16]uint32{0x3f800000, 0x3f880120, 0x3fa00190, 0x3fa800b0, 0x3fb80080, 0x3fb001a0, 0x3f980110, 0x3f900030, 0x3fb00052, 0x3fb80172, 0x3f9001c2, 0x3f9800e2, 0x3f8800d2, 0x3f8001f2, 0x3fa80142, 0x3fa00062}, - uint32(0xfff80000), - [21]string{"0x7a", "0xd9", "0x60", "0xbc", "0x28", "0x8d", "0xd8", "0xe0", "0x58", "0x52", "0x81", "0xfb", "0xfc", "0xb8", "0x29", "0x91", "0xda", "0x00", "0x36", "0x31", "0x00"}}, - { - /* No.881 delta:2436 weight:1101 */ - 11213, - 6, - 13, - 4, - [16]uint32{0x00000000, 0x48393825, 0x674d786c, 0x2f744049, 0xb930371d, 0xf1090f38, 0xde7d4f71, 0x96447754, 0x0000a104, 0x48399921, 0x674dd968, 0x2f74e14d, 0xb9309619, 0xf109ae3c, 0xde7dee75, 0x9644d650}, - [16]uint32{0x00000000, 0xe04051f6, 0x4c301e29, 0xac704fdf, 0xa2242a12, 0x42647be4, 0xee14343b, 0x0e5465cd, 0x09022011, 0xe94271e7, 0x45323e38, 0xa5726fce, 0xab260a03, 0x4b665bf5, 0xe716142a, 0x075645dc}, - [16]uint32{0x3f800000, 0x3ff02028, 0x3fa6180f, 0x3fd63827, 0x3fd11215, 0x3fa1323d, 0x3ff70a1a, 0x3f872a32, 0x3f848110, 0x3ff4a138, 0x3fa2991f, 0x3fd2b937, 0x3fd59305, 0x3fa5b32d, 0x3ff38b0a, 0x3f83ab22}, - uint32(0xfff80000), - [21]string{"0x78", "0x09", "0x2d", "0x93", "0x6c", "0x36", "0x91", "0x06", "0x4d", "0x4a", "0xca", "0x78", "0xf7", "0xdb", "0xf1", "0xde", "0xd8", "0x1e", "0x73", "0x47", "0x00"}}, - { - /* No.882 delta:775 weight:1661 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xd2458a0b, 0xd58ec846, 0x07cb424d, 0x60803722, 0xb2c5bd29, 0xb50eff64, 0x674b756f, 0x000003ad, 0xd24589a6, 0xd58ecbeb, 0x07cb41e0, 0x6080348f, 0xb2c5be84, 0xb50efcc9, 0x674b76c2}, - [16]uint32{0x00000000, 0x1022117e, 0x0069dd8f, 0x104bccf1, 0x10482009, 0x006a3177, 0x1021fd86, 0x0003ecf8, 0xc0100405, 0xd032157b, 0xc079d98a, 0xd05bc8f4, 0xd058240c, 0xc07a3572, 0xd031f983, 0xc013e8fd}, - [16]uint32{0x3f800000, 0x3f881108, 0x3f8034ee, 0x3f8825e6, 0x3f882410, 0x3f803518, 0x3f8810fe, 0x3f8001f6, 0x3fe00802, 0x3fe8190a, 0x3fe03cec, 0x3fe82de4, 0x3fe82c12, 0x3fe03d1a, 0x3fe818fc, 0x3fe009f4}, - uint32(0xfff80000), - [21]string{"0x9d", "0x1c", "0x6d", "0x5a", "0x84", "0xb3", "0x8b", "0x29", "0xf8", "0x89", "0x8f", "0x04", "0xd8", "0x7a", "0x22", "0xf3", "0xab", "0xab", "0x3a", "0xae", "0x00"}}, - { - /* No.883 delta:1347 weight:1721 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xc401bf67, 0x51424b5e, 0x9543f439, 0x39e03731, 0xfde18856, 0x68a27c6f, 0xaca3c308, 0x000054d0, 0xc401ebb7, 0x51421f8e, 0x9543a0e9, 0x39e063e1, 0xfde1dc86, 0x68a228bf, 0xaca397d8}, - [16]uint32{0x00000000, 0x104940d3, 0x407ac182, 0x50338151, 0x3005515f, 0x204c118c, 0x707f90dd, 0x6036d00e, 0x202e2818, 0x306768cb, 0x6054e99a, 0x701da949, 0x102b7947, 0x00623994, 0x5051b8c5, 0x4018f816}, - [16]uint32{0x3f800000, 0x3f8824a0, 0x3fa03d60, 0x3fa819c0, 0x3f9802a8, 0x3f902608, 0x3fb83fc8, 0x3fb01b68, 0x3f901714, 0x3f9833b4, 0x3fb02a74, 0x3fb80ed4, 0x3f8815bc, 0x3f80311c, 0x3fa828dc, 0x3fa00c7c}, - uint32(0xfff80000), - [21]string{"0xe2", "0x8a", "0x83", "0xdf", "0xec", "0x34", "0xc5", "0x13", "0x88", "0xac", "0x81", "0xad", "0xfe", "0x64", "0x4c", "0xc5", "0x66", "0xc5", "0x74", "0x1e", "0x00"}}, - { - /* No.884 delta:1636 weight:1539 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0x5d7c2fec, 0xdbe83f7c, 0x86941090, 0x7d103740, 0x206c18ac, 0xa6f8083c, 0xfb8427d0, 0x0000c3ee, 0x5d7cec02, 0xdbe8fc92, 0x8694d37e, 0x7d10f4ae, 0x206cdb42, 0xa6f8cbd2, 0xfb84e43e}, - [16]uint32{0x00000000, 0x480ea25f, 0x70c20a1a, 0x38cca845, 0x43881511, 0x0b86b74e, 0x334a1f0b, 0x7b44bd54, 0x20160133, 0x6818a36c, 0x50d40b29, 0x18daa976, 0x639e1422, 0x2b90b67d, 0x135c1e38, 0x5b52bc67}, - [16]uint32{0x3f800000, 0x3fa40751, 0x3fb86105, 0x3f9c6654, 0x3fa1c40a, 0x3f85c35b, 0x3f99a50f, 0x3fbda25e, 0x3f900b00, 0x3fb40c51, 0x3fa86a05, 0x3f8c6d54, 0x3fb1cf0a, 0x3f95c85b, 0x3f89ae0f, 0x3fada95e}, - uint32(0xfff80000), - [21]string{"0xf9", "0x2e", "0x2f", "0x68", "0x78", "0x1f", "0x32", "0x86", "0x69", "0x52", "0xf1", "0x23", "0xce", "0xd5", "0x12", "0xe0", "0x9f", "0xf7", "0xdd", "0x9e", "0x00"}}, - { - /* No.885 delta:724 weight:1505 */ - 11213, - 86, - 13, - 4, - [16]uint32{0x00000000, 0xa64c89b4, 0x7dfc4bdb, 0xdbb0c26f, 0x74e03759, 0xd2acbeed, 0x091c7c82, 0xaf50f536, 0x0000f7e6, 0xa64c7e52, 0x7dfcbc3d, 0xdbb03589, 0x74e0c0bf, 0xd2ac490b, 0x091c8b64, 0xaf5002d0}, - [16]uint32{0x00000000, 0x006421d6, 0xb000c01f, 0xb064e1c9, 0x0002918e, 0x0066b058, 0xb0025191, 0xb0667047, 0x0010181b, 0x007439cd, 0xb010d804, 0xb074f9d2, 0x00128995, 0x0076a843, 0xb012498a, 0xb076685c}, - [16]uint32{0x3f800000, 0x3f803210, 0x3fd80060, 0x3fd83270, 0x3f800148, 0x3f803358, 0x3fd80128, 0x3fd83338, 0x3f80080c, 0x3f803a1c, 0x3fd8086c, 0x3fd83a7c, 0x3f800944, 0x3f803b54, 0x3fd80924, 0x3fd83b34}, - uint32(0xfff80000), - [21]string{"0x1a", "0x4a", "0xd2", "0x74", "0x26", "0x98", "0x8d", "0xd8", "0x6d", "0xbc", "0xcf", "0xa9", "0xc2", "0xa0", "0x46", "0x66", "0xf3", "0x2f", "0xa0", "0x67", "0x00"}}, - { - /* No.886 delta:923 weight:1503 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0xa4699f96, 0x470c0e97, 0xe3659101, 0x57003765, 0xf369a8f3, 0x100c39f2, 0xb465a664, 0x0000b2c4, 0xa4692d52, 0x470cbc53, 0xe36523c5, 0x570085a1, 0xf3691a37, 0x100c8b36, 0xb46514a0}, - [16]uint32{0x00000000, 0x203ac79a, 0x0000ec11, 0x203a2b8b, 0x0003e013, 0x20392789, 0x00030c02, 0x2039cb98, 0x103631f4, 0x300cf66e, 0x1036dde5, 0x300c1a7f, 0x1035d1e7, 0x300f167d, 0x10353df6, 0x300ffa6c}, - [16]uint32{0x3f800000, 0x3f901d63, 0x3f800076, 0x3f901d15, 0x3f8001f0, 0x3f901c93, 0x3f800186, 0x3f901ce5, 0x3f881b18, 0x3f98067b, 0x3f881b6e, 0x3f98060d, 0x3f881ae8, 0x3f98078b, 0x3f881a9e, 0x3f9807fd}, - uint32(0xfff80000), - [21]string{"0xa9", "0x3c", "0x68", "0x0f", "0xe0", "0xbf", "0x83", "0xab", "0xc1", "0xf5", "0xac", "0x05", "0x00", "0xda", "0xce", "0xc0", "0x28", "0x28", "0xf8", "0x2c", "0x00"}}, - { - /* No.887 delta:1672 weight:1567 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0xdf576555, 0x6ff90ea8, 0xb0ae6bfd, 0x6f70377b, 0xb027522e, 0x008939d3, 0xdfde5c86, 0x00000e20, 0xdf576b75, 0x6ff90088, 0xb0ae65dd, 0x6f70395b, 0xb0275c0e, 0x008937f3, 0xdfde52a6}, - [16]uint32{0x00000000, 0x1024419e, 0x00428131, 0x1066c0af, 0x0002805c, 0x1026c1c2, 0x0040016d, 0x106440f3, 0x4020009a, 0x50044104, 0x406281ab, 0x5046c035, 0x402280c6, 0x5006c158, 0x406001f7, 0x50444069}, - [16]uint32{0x3f800000, 0x3f881220, 0x3f802140, 0x3f883360, 0x3f800140, 0x3f881360, 0x3f802000, 0x3f883220, 0x3fa01000, 0x3fa80220, 0x3fa03140, 0x3fa82360, 0x3fa01140, 0x3fa80360, 0x3fa03000, 0x3fa82220}, - uint32(0xfff80000), - [21]string{"0xb2", "0xec", "0x94", "0x35", "0x86", "0x06", "0xc1", "0x46", "0xde", "0xff", "0x2f", "0x7b", "0x10", "0x42", "0x33", "0x8b", "0xe2", "0x4d", "0x26", "0x77", "0x00"}}, - { - /* No.888 delta:1280 weight:1649 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x3600b146, 0xc252ecd9, 0xf4525d9f, 0x04a03780, 0x32a086c6, 0xc6f2db59, 0xf0f26a1f, 0x00001d19, 0x3600ac5f, 0xc252f1c0, 0xf4524086, 0x04a02a99, 0x32a09bdf, 0xc6f2c640, 0xf0f27706}, - [16]uint32{0x00000000, 0x104c4172, 0x2806612f, 0x384a205d, 0x102881c3, 0x0064c0b1, 0x382ee0ec, 0x2862a19e, 0x00152014, 0x10596166, 0x2813413b, 0x385f0049, 0x103da1d7, 0x0071e0a5, 0x383bc0f8, 0x2877818a}, - [16]uint32{0x3f800000, 0x3f882620, 0x3f940330, 0x3f9c2510, 0x3f881440, 0x3f803260, 0x3f9c1770, 0x3f943150, 0x3f800a90, 0x3f882cb0, 0x3f9409a0, 0x3f9c2f80, 0x3f881ed0, 0x3f8038f0, 0x3f9c1de0, 0x3f943bc0}, - uint32(0xfff80000), - [21]string{"0x40", "0x4b", "0xbd", "0x28", "0x18", "0xcb", "0xba", "0x84", "0x95", "0x0e", "0xe7", "0x0a", "0xa4", "0x1c", "0x91", "0xa7", "0x68", "0x09", "0xa3", "0x89", "0x00"}}, - { - /* No.889 delta:908 weight:1475 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xae03f020, 0x88158c81, 0x26167ca1, 0xa4903790, 0x0a93c7b0, 0x2c85bb11, 0x82864b31, 0x0000f452, 0xae030472, 0x881578d3, 0x261688f3, 0xa490c3c2, 0x0a9333e2, 0x2c854f43, 0x8286bf63}, - [16]uint32{0x00000000, 0x41649c96, 0x6010e019, 0x21747c8f, 0x000248a4, 0x4166d432, 0x6012a8bd, 0x2176342b, 0x0001a0cc, 0x41653c5a, 0x601140d5, 0x2175dc43, 0x0003e868, 0x416774fe, 0x60130871, 0x217794e7}, - [16]uint32{0x3f800000, 0x3fa0b24e, 0x3fb00870, 0x3f90ba3e, 0x3f800124, 0x3fa0b36a, 0x3fb00954, 0x3f90bb1a, 0x3f8000d0, 0x3fa0b29e, 0x3fb008a0, 0x3f90baee, 0x3f8001f4, 0x3fa0b3ba, 0x3fb00984, 0x3f90bbca}, - uint32(0xfff80000), - [21]string{"0x65", "0x3c", "0x8d", "0x5d", "0x79", "0x41", "0xa4", "0x16", "0x4b", "0x05", "0xef", "0xb2", "0x0b", "0x14", "0xcf", "0xe2", "0x80", "0xd7", "0x0c", "0xb4", "0x00"}}, - { - /* No.890 delta:643 weight:1457 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x238b0ca4, 0x55ac7b2a, 0x7627778e, 0x39c037a3, 0x1a4b3b07, 0x6c6c4c89, 0x4fe7402d, 0x0000e5e3, 0x238be947, 0x55ac9ec9, 0x7627926d, 0x39c0d240, 0x1a4bdee4, 0x6c6ca96a, 0x4fe7a5ce}, - [16]uint32{0x00000000, 0x800011dd, 0x04004802, 0x840059df, 0x3000a10b, 0xb000b0d6, 0x3400e909, 0xb400f8d4, 0x50201803, 0xd02009de, 0x54205001, 0xd42041dc, 0x6020b908, 0xe020a8d5, 0x6420f10a, 0xe420e0d7}, - [16]uint32{0x3f800000, 0x3fc00008, 0x3f820024, 0x3fc2002c, 0x3f980050, 0x3fd80058, 0x3f9a0074, 0x3fda007c, 0x3fa8100c, 0x3fe81004, 0x3faa1028, 0x3fea1020, 0x3fb0105c, 0x3ff01054, 0x3fb21078, 0x3ff21070}, - uint32(0xfff80000), - [21]string{"0x8f", "0xea", "0x98", "0xdf", "0xa6", "0x1c", "0x0f", "0x0d", "0x79", "0xa1", "0xc6", "0x02", "0x07", "0x7f", "0x14", "0x33", "0xd8", "0x0e", "0x94", "0x64", "0x00"}}, - { - /* No.891 delta:1674 weight:1569 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xad75cf3d, 0x30d354ea, 0x9da69bd7, 0x321037b5, 0x9f65f888, 0x02c3635f, 0xafb6ac62, 0x0000b953, 0xad75766e, 0x30d3edb9, 0x9da62284, 0x32108ee6, 0x9f6541db, 0x02c3da0c, 0xafb61531}, - [16]uint32{0x00000000, 0x083a4196, 0x141981b3, 0x1c23c025, 0x202165da, 0x281b244c, 0x3438e469, 0x3c02a5ff, 0x045c421d, 0x0c66038b, 0x1045c3ae, 0x187f8238, 0x247d27c7, 0x2c476651, 0x3064a674, 0x385ee7e2}, - [16]uint32{0x3f800000, 0x3f841d20, 0x3f8a0cc0, 0x3f8e11e0, 0x3f9010b2, 0x3f940d92, 0x3f9a1c72, 0x3f9e0152, 0x3f822e21, 0x3f863301, 0x3f8822e1, 0x3f8c3fc1, 0x3f923e93, 0x3f9623b3, 0x3f983253, 0x3f9c2f73}, - uint32(0xfff80000), - [21]string{"0x98", "0x7a", "0xd9", "0x05", "0x17", "0xd1", "0x62", "0x59", "0x4d", "0xd3", "0x35", "0xce", "0xfb", "0x12", "0x97", "0xda", "0x4d", "0xc4", "0x93", "0x5b", "0x00"}}, - { - /* No.892 delta:1016 weight:1443 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x0b888a5e, 0xada6e64b, 0xa62e6c15, 0xfd7037c0, 0xf6f8bd9e, 0x50d6d18b, 0x5b5e5bd5, 0x00003e9b, 0x0b88b4c5, 0xada6d8d0, 0xa62e528e, 0xfd70095b, 0xf6f88305, 0x50d6ef10, 0x5b5e654e}, - [16]uint32{0x00000000, 0x403bc1f2, 0x1075009d, 0x504ec16f, 0x406a2955, 0x0051e8a7, 0x501f29c8, 0x1024e83a, 0x0040107f, 0x407bd18d, 0x103510e2, 0x500ed110, 0x402a392a, 0x0011f8d8, 0x505f39b7, 0x1064f845}, - [16]uint32{0x3f800000, 0x3fa01de0, 0x3f883a80, 0x3fa82760, 0x3fa03514, 0x3f8028f4, 0x3fa80f94, 0x3f881274, 0x3f802008, 0x3fa03de8, 0x3f881a88, 0x3fa80768, 0x3fa0151c, 0x3f8008fc, 0x3fa82f9c, 0x3f88327c}, - uint32(0xfff80000), - [21]string{"0x63", "0x72", "0xc9", "0x74", "0xba", "0x62", "0xd2", "0x96", "0x51", "0x2e", "0xdd", "0xf8", "0x53", "0x64", "0xfc", "0xf4", "0x6b", "0x13", "0x78", "0xc4", "0x00"}}, - { - /* No.893 delta:865 weight:1265 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x7f50c9eb, 0x9b5918ee, 0xe409d105, 0x30c037d3, 0x4f90fe38, 0xab992f3d, 0xd4c9e6d6, 0x00009a06, 0x7f5053ed, 0x9b5982e8, 0xe4094b03, 0x30c0add5, 0x4f90643e, 0xab99b53b, 0xd4c97cd0}, - [16]uint32{0x00000000, 0x602dbd76, 0x000271ec, 0x602fcc9a, 0x106001bf, 0x704dbcc9, 0x10627053, 0x704fcd25, 0x40342015, 0x20199d63, 0x403651f9, 0x201bec8f, 0x505421aa, 0x30799cdc, 0x50565046, 0x307bed30}, - [16]uint32{0x3f800000, 0x3fb016de, 0x3f800138, 0x3fb017e6, 0x3f883000, 0x3fb826de, 0x3f883138, 0x3fb827e6, 0x3fa01a10, 0x3f900cce, 0x3fa01b28, 0x3f900df6, 0x3fa82a10, 0x3f983cce, 0x3fa82b28, 0x3f983df6}, - uint32(0xfff80000), - [21]string{"0xe8", "0xf7", "0xbd", "0xf3", "0x50", "0x5d", "0x9e", "0x9b", "0x5f", "0x7f", "0xf9", "0x90", "0xd4", "0x32", "0x21", "0x45", "0x1d", "0x18", "0xab", "0x35", "0x00"}}, - { - /* No.894 delta:895 weight:1277 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x0e5c0fd0, 0xcc5d1aae, 0xc201157e, 0xbb5037ea, 0xb50c383a, 0x770d2d44, 0x79512294, 0x00008153, 0x0e5c8e83, 0xcc5d9bfd, 0xc201942d, 0xbb50b6b9, 0xb50cb969, 0x770dac17, 0x7951a3c7}, - [16]uint32{0x00000000, 0x100204f6, 0x8000036a, 0x9002079c, 0x40401013, 0x504214e5, 0xc0401379, 0xd042178f, 0x20026011, 0x300064e7, 0xa002637b, 0xb000678d, 0x60427002, 0x704074f4, 0xe0427368, 0xf040779e}, - [16]uint32{0x3f800000, 0x3f880102, 0x3fc00001, 0x3fc80103, 0x3fa02008, 0x3fa8210a, 0x3fe02009, 0x3fe8210b, 0x3f900130, 0x3f980032, 0x3fd00131, 0x3fd80033, 0x3fb02138, 0x3fb8203a, 0x3ff02139, 0x3ff8203b}, - uint32(0xfff80000), - [21]string{"0x8e", "0xed", "0xe7", "0xf8", "0x4d", "0xd1", "0x04", "0x39", "0x64", "0x70", "0xe1", "0xd9", "0xf5", "0x67", "0xa6", "0x26", "0x30", "0x7c", "0xe5", "0xff", "0x00"}}, - { - /* No.895 delta:817 weight:1523 */ - 11213, - 76, - 13, - 4, - [16]uint32{0x00000000, 0xf844b6dc, 0x9cb6cb70, 0x64f27dac, 0x15f037f1, 0xedb4812d, 0x8946fc81, 0x71024a5d, 0x00007d61, 0xf844cbbd, 0x9cb6b611, 0x64f200cd, 0x15f04a90, 0xedb4fc4c, 0x894681e0, 0x7102373c}, - [16]uint32{0x00000000, 0x0048731f, 0x00031245, 0x004b615a, 0x1000121d, 0x10486102, 0x10030058, 0x104b7347, 0x41010a19, 0x41497906, 0x4102185c, 0x414a6b43, 0x51011804, 0x51496b1b, 0x51020a41, 0x514a795e}, - [16]uint32{0x3f800000, 0x3f802439, 0x3f800189, 0x3f8025b0, 0x3f880009, 0x3f882430, 0x3f880180, 0x3f8825b9, 0x3fa08085, 0x3fa0a4bc, 0x3fa0810c, 0x3fa0a535, 0x3fa8808c, 0x3fa8a4b5, 0x3fa88105, 0x3fa8a53c}, - uint32(0xfff80000), - [21]string{"0x19", "0x01", "0xd5", "0xa7", "0x8e", "0xc7", "0xba", "0x0b", "0x80", "0x7a", "0x46", "0xe2", "0xe1", "0x65", "0x58", "0x20", "0x6c", "0xdc", "0x9f", "0x80", "0x00"}}, - { - /* No.896 delta:766 weight:1697 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x4280f05e, 0x7e953e4f, 0x3c15ce11, 0x9d303808, 0xdfb0c856, 0xe3a50647, 0xa125f619, 0x0000d302, 0x4280235c, 0x7e95ed4d, 0x3c151d13, 0x9d30eb0a, 0xdfb01b54, 0xe3a5d545, 0xa125251b}, - [16]uint32{0x00000000, 0x005a1cbd, 0x400206be, 0x40581a03, 0x2002a648, 0x2058baf5, 0x6000a0f6, 0x605abc4b, 0x70000602, 0x705a1abf, 0x300200bc, 0x30581c01, 0x5002a04a, 0x5058bcf7, 0x1000a6f4, 0x105aba49}, - [16]uint32{0x3f800000, 0x3f802d0e, 0x3fa00103, 0x3fa02c0d, 0x3f900153, 0x3f902c5d, 0x3fb00050, 0x3fb02d5e, 0x3fb80003, 0x3fb82d0d, 0x3f980100, 0x3f982c0e, 0x3fa80150, 0x3fa82c5e, 0x3f880053, 0x3f882d5d}, - uint32(0xfff80000), - [21]string{"0xcb", "0x41", "0xf8", "0x2b", "0xc1", "0xcb", "0x02", "0xad", "0x9b", "0x57", "0x0b", "0x0d", "0x19", "0x10", "0x07", "0x84", "0xe1", "0x0c", "0xdd", "0x13", "0x00"}}, - { - /* No.897 delta:1308 weight:1485 */ - 11213, - 24, - 13, - 4, - [16]uint32{0x00000000, 0x18d2549c, 0xe6510e00, 0xfe835a9c, 0x56c03815, 0x4e126c89, 0xb0913615, 0xa8436289, 0x00005031, 0x18d204ad, 0xe6515e31, 0xfe830aad, 0x56c06824, 0x4e123cb8, 0xb0916624, 0xa84332b8}, - [16]uint32{0x00000000, 0x005999f6, 0x0036015c, 0x006f98aa, 0x806fa8f3, 0x80363105, 0x8059a9af, 0x80003059, 0x0010101f, 0x004989e9, 0x00261143, 0x007f88b5, 0x807fb8ec, 0x8026211a, 0x8049b9b0, 0x80102046}, - [16]uint32{0x3f800000, 0x3f802ccc, 0x3f801b00, 0x3f8037cc, 0x3fc037d4, 0x3fc01b18, 0x3fc02cd4, 0x3fc00018, 0x3f800808, 0x3f8024c4, 0x3f801308, 0x3f803fc4, 0x3fc03fdc, 0x3fc01310, 0x3fc024dc, 0x3fc00810}, - uint32(0xfff80000), - [21]string{"0x11", "0x95", "0x69", "0xb5", "0x2b", "0x22", "0x89", "0xa2", "0xd7", "0xb0", "0x59", "0x2e", "0x85", "0xdb", "0xb6", "0xe2", "0xb9", "0x66", "0xb0", "0x54", "0x00"}}, - { - /* No.898 delta:1407 weight:1237 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x20934c7f, 0x3c845717, 0x1c171b68, 0x61203822, 0x41b3745d, 0x5da46f35, 0x7d37234a, 0x0000d5cf, 0x209399b0, 0x3c8482d8, 0x1c17cea7, 0x6120eded, 0x41b3a192, 0x5da4bafa, 0x7d37f685}, - [16]uint32{0x00000000, 0x200404ba, 0x001201cc, 0x20160576, 0x100c0158, 0x300805e2, 0x101e0094, 0x301a042e, 0x0002019f, 0x20060525, 0x00100053, 0x201404e9, 0x100e00c7, 0x300a047d, 0x101c010b, 0x301805b1}, - [16]uint32{0x3f800000, 0x3f900202, 0x3f800900, 0x3f900b02, 0x3f880600, 0x3f980402, 0x3f880f00, 0x3f980d02, 0x3f800100, 0x3f900302, 0x3f800800, 0x3f900a02, 0x3f880700, 0x3f980502, 0x3f880e00, 0x3f980c02}, - uint32(0xfff80000), - [21]string{"0xc2", "0x27", "0xa5", "0x56", "0x04", "0x8a", "0x60", "0x0e", "0xc9", "0xfc", "0x8d", "0x96", "0xf8", "0xf7", "0xe9", "0xf1", "0x94", "0x01", "0x2f", "0xa9", "0x00"}}, - { - /* No.899 delta:1211 weight:1599 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x804bac80, 0x3bdce360, 0xbb974fe0, 0xc8a03833, 0x48eb94b3, 0xf37cdb53, 0x733777d3, 0x00008e00, 0x804b2280, 0x3bdc6d60, 0xbb97c1e0, 0xc8a0b633, 0x48eb1ab3, 0xf37c5553, 0x7337f9d3}, - [16]uint32{0x00000000, 0xc842105e, 0x708be065, 0xb8c9f03b, 0x802080ca, 0x48629094, 0xf0ab60af, 0x38e970f1, 0x100061f8, 0xd84271a6, 0x608b819d, 0xa8c991c3, 0x9020e132, 0x5862f16c, 0xe0ab0157, 0x28e91109}, - [16]uint32{0x3f800000, 0x3fe42108, 0x3fb845f0, 0x3fdc64f8, 0x3fc01040, 0x3fa43148, 0x3ff855b0, 0x3f9c74b8, 0x3f880030, 0x3fec2138, 0x3fb045c0, 0x3fd464c8, 0x3fc81070, 0x3fac3178, 0x3ff05580, 0x3f947488}, - uint32(0xfff80000), - [21]string{"0x75", "0x0a", "0xa9", "0xc3", "0x18", "0x01", "0xc5", "0x9a", "0x69", "0x77", "0x21", "0x73", "0x22", "0x02", "0xe0", "0x66", "0x65", "0x5d", "0x56", "0x69", "0x00"}}, - { - /* No.900 delta:719 weight:1677 */ - 11213, - 67, - 13, - 4, - [16]uint32{0x00000000, 0xb0f6ced9, 0x3eb012d9, 0x8e46dc00, 0x13803841, 0xa376f698, 0x2d302a98, 0x9dc6e441, 0x0000a437, 0xb0f66aee, 0x3eb0b6ee, 0x8e467837, 0x13809c76, 0xa37652af, 0x2d308eaf, 0x9dc64076}, - [16]uint32{0x00000000, 0x004e5152, 0x000220de, 0x004c718c, 0x1008307b, 0x10466129, 0x100a10a5, 0x104441f7, 0x200011b0, 0x204e40e2, 0x2002316e, 0x204c603c, 0x300821cb, 0x30467099, 0x300a0115, 0x30445047}, - [16]uint32{0x3f800000, 0x3f802728, 0x3f800110, 0x3f802638, 0x3f880418, 0x3f882330, 0x3f880508, 0x3f882220, 0x3f900008, 0x3f902720, 0x3f900118, 0x3f902630, 0x3f980410, 0x3f982338, 0x3f980500, 0x3f982228}, - uint32(0xfff80000), - [21]string{"0x71", "0xc1", "0xa1", "0xd7", "0xb5", "0x0a", "0x8f", "0xa3", "0x9f", "0x97", "0x83", "0xee", "0x91", "0xc0", "0x93", "0x3d", "0x41", "0xcb", "0xd8", "0x7f", "0x00"}}, - { - /* No.901 delta:1075 weight:1597 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0xa8081b78, 0xa66644d0, 0x0e6e5fa8, 0x52003850, 0xfa082328, 0xf4667c80, 0x5c6e67f8, 0x0000639d, 0xa80878e5, 0xa666274d, 0x0e6e3c35, 0x52005bcd, 0xfa0840b5, 0xf4661f1d, 0x5c6e0465}, - [16]uint32{0x00000000, 0x0047a5fe, 0x02030a12, 0x0244afec, 0x30004c0d, 0x3047e9f3, 0x3203461f, 0x3244e3e1, 0x1000101b, 0x1047b5e5, 0x12031a09, 0x1244bff7, 0x20005c16, 0x2047f9e8, 0x22035604, 0x2244f3fa}, - [16]uint32{0x3f800000, 0x3f8023d2, 0x3f810185, 0x3f812257, 0x3f980026, 0x3f9823f4, 0x3f9901a3, 0x3f992271, 0x3f880008, 0x3f8823da, 0x3f89018d, 0x3f89225f, 0x3f90002e, 0x3f9023fc, 0x3f9101ab, 0x3f912279}, - uint32(0xfff80000), - [21]string{"0xd4", "0x3f", "0x50", "0xa2", "0xbe", "0x62", "0xf3", "0x9b", "0x91", "0x55", "0xae", "0x32", "0x34", "0x12", "0x2d", "0x75", "0x83", "0x63", "0x38", "0xe8", "0x00"}}, - { - /* No.902 delta:2650 weight:883 */ - 11213, - 5, - 13, - 4, - [16]uint32{0x00000000, 0xaa853d9c, 0x1a926eb5, 0xb0175329, 0x14603866, 0xbee505fa, 0x0ef256d3, 0xa4776b4f, 0x00006536, 0xaa8558aa, 0x1a920b83, 0xb017361f, 0x14605d50, 0xbee560cc, 0x0ef233e5, 0xa4770e79}, - [16]uint32{0x00000000, 0x9d1061bf, 0x41542015, 0xdc4441aa, 0x0bc2006d, 0x96d261d2, 0x4a962078, 0xd78641c7, 0xa40840a5, 0x3918211a, 0xe55c60b0, 0x784c010f, 0xafca40c8, 0x32da2177, 0xee9e60dd, 0x738e0162}, - [16]uint32{0x3f800000, 0x3fce8830, 0x3fa0aa10, 0x3fee2220, 0x3f85e100, 0x3fcb6930, 0x3fa54b10, 0x3febc320, 0x3fd20420, 0x3f9c8c10, 0x3ff2ae30, 0x3fbc2600, 0x3fd7e520, 0x3f996d10, 0x3ff74f30, 0x3fb9c700}, - uint32(0xfff80000), - [21]string{"0x9a", "0xa4", "0x66", "0x7b", "0xdb", "0x3f", "0xed", "0xae", "0x44", "0xc9", "0xa4", "0x49", "0x73", "0x49", "0x02", "0xfa", "0x57", "0x3e", "0xe2", "0x61", "0x00"}}, - { - /* No.903 delta:812 weight:983 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0x0382458a, 0xf8b7322f, 0xfb3577a5, 0x55f03878, 0x56727df2, 0xad470a57, 0xaec54fdd, 0x000017e7, 0x0382526d, 0xf8b725c8, 0xfb356042, 0x55f02f9f, 0x56726a15, 0xad471db0, 0xaec5583a}, - [16]uint32{0x00000000, 0x00c8109a, 0x000370ed, 0x00cb6077, 0x403e22f1, 0x40f6326b, 0x403d521c, 0x40f54286, 0x32075048, 0x32cf40d2, 0x320420a5, 0x32cc303f, 0x723972b9, 0x72f16223, 0x723a0254, 0x72f212ce}, - [16]uint32{0x3f800000, 0x3f806408, 0x3f8001b8, 0x3f8065b0, 0x3fa01f11, 0x3fa07b19, 0x3fa01ea9, 0x3fa07aa1, 0x3f9903a8, 0x3f9967a0, 0x3f990210, 0x3f996618, 0x3fb91cb9, 0x3fb978b1, 0x3fb91d01, 0x3fb97909}, - uint32(0xfff80000), - [21]string{"0xd1", "0x19", "0xab", "0x71", "0xdb", "0x7c", "0xee", "0x39", "0x56", "0x2b", "0xde", "0x28", "0x93", "0x0e", "0xa4", "0x22", "0x8c", "0x36", "0xa3", "0x2b", "0x00"}}, - { - /* No.904 delta:1355 weight:1605 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x17a2e89d, 0xedc2917b, 0xfa6079e6, 0x0be03886, 0x1c42d01b, 0xe622a9fd, 0xf1804160, 0x0000ea55, 0x17a202c8, 0xedc27b2e, 0xfa6093b3, 0x0be0d2d3, 0x1c423a4e, 0xe62243a8, 0xf180ab35}, - [16]uint32{0x00000000, 0x202295fa, 0x005408df, 0x20769d25, 0x002812f3, 0x200a8709, 0x007c1a2c, 0x205e8fd6, 0x60038112, 0x402114e8, 0x605789cd, 0x40751c37, 0x602b93e1, 0x4009061b, 0x607f9b3e, 0x405d0ec4}, - [16]uint32{0x3f800000, 0x3f90114a, 0x3f802a04, 0x3f903b4e, 0x3f801409, 0x3f900543, 0x3f803e0d, 0x3f902f47, 0x3fb001c0, 0x3fa0108a, 0x3fb02bc4, 0x3fa03a8e, 0x3fb015c9, 0x3fa00483, 0x3fb03fcd, 0x3fa02e87}, - uint32(0xfff80000), - [21]string{"0x13", "0x1b", "0xd4", "0x18", "0x38", "0x92", "0x96", "0xc3", "0xe3", "0x4c", "0x73", "0x57", "0xdc", "0xa0", "0xb1", "0x0a", "0xcd", "0xa2", "0x30", "0xab", "0x00"}}, - { - /* No.905 delta:717 weight:1263 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0xb962e9ba, 0xf77748a5, 0x4e15a11f, 0x58b03895, 0xe1d2d12f, 0xafc77030, 0x16a5998a, 0x000038ca, 0xb962d170, 0xf777706f, 0x4e1599d5, 0x58b0005f, 0xe1d2e9e5, 0xafc748fa, 0x16a5a140}, - [16]uint32{0x00000000, 0x1002921a, 0x140019f6, 0x04028bec, 0x3003481e, 0x2001da04, 0x240351e8, 0x3401c3f2, 0x1001496b, 0x0003db71, 0x0401509d, 0x1403c287, 0x20020175, 0x3000936f, 0x34021883, 0x24008a99}, - [16]uint32{0x3f800000, 0x3f880149, 0x3f8a000c, 0x3f820145, 0x3f9801a4, 0x3f9000ed, 0x3f9201a8, 0x3f9a00e1, 0x3f8800a4, 0x3f8001ed, 0x3f8200a8, 0x3f8a01e1, 0x3f900100, 0x3f980049, 0x3f9a010c, 0x3f920045}, - uint32(0xfff80000), - [21]string{"0x82", "0x14", "0xd4", "0xfa", "0xa8", "0xd1", "0x99", "0x85", "0x15", "0xf6", "0x01", "0x5d", "0x2a", "0xc0", "0x39", "0x54", "0xec", "0x21", "0x02", "0x9f", "0x00"}}, - { - /* No.906 delta:1055 weight:1313 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xd2ca0608, 0x6c800286, 0xbe4a048e, 0x517038a2, 0x83ba3eaa, 0x3df03a24, 0xef3a3c2c, 0x0000e21f, 0xd2cae417, 0x6c80e099, 0xbe4ae691, 0x5170dabd, 0x83badcb5, 0x3df0d83b, 0xef3ade33}, - [16]uint32{0x00000000, 0x9046497c, 0x200b010a, 0xb04d4876, 0x000208ad, 0x904441d1, 0x200909a7, 0xb04f40db, 0x340023df, 0xa4466aa3, 0x140b22d5, 0x844d6ba9, 0x34022b72, 0xa444620e, 0x14092a78, 0x844f6304}, - [16]uint32{0x3f800000, 0x3fc82324, 0x3f900580, 0x3fd826a4, 0x3f800104, 0x3fc82220, 0x3f900484, 0x3fd827a0, 0x3f9a0011, 0x3fd22335, 0x3f8a0591, 0x3fc226b5, 0x3f9a0115, 0x3fd22231, 0x3f8a0495, 0x3fc227b1}, - uint32(0xfff80000), - [21]string{"0x3a", "0x9c", "0xd6", "0x23", "0xee", "0x9e", "0xb1", "0x0e", "0x82", "0xd6", "0x79", "0x8b", "0xce", "0x53", "0xd2", "0xf4", "0x43", "0xb0", "0xad", "0xe6", "0x00"}}, - { - /* No.907 delta:1949 weight:1419 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0x6e5afa56, 0x87968859, 0xe9cc720f, 0x83c038b5, 0xed9ac2e3, 0x0456b0ec, 0x6a0c4aba, 0x00001a7c, 0x6e5ae02a, 0x87969225, 0xe9cc6873, 0x83c022c9, 0xed9ad89f, 0x0456aa90, 0x6a0c50c6}, - [16]uint32{0x00000000, 0x32028552, 0x2895831d, 0x1a97064f, 0x533a0154, 0x61388406, 0x7baf8249, 0x49ad071b, 0x085c001c, 0x3a5e854e, 0x20c98301, 0x12cb0653, 0x5b660148, 0x6964841a, 0x73f38255, 0x41f10707}, - [16]uint32{0x3f800000, 0x3f990142, 0x3f944ac1, 0x3f8d4b83, 0x3fa99d00, 0x3fb09c42, 0x3fbdd7c1, 0x3fa4d683, 0x3f842e00, 0x3f9d2f42, 0x3f9064c1, 0x3f896583, 0x3fadb300, 0x3fb4b242, 0x3fb9f9c1, 0x3fa0f883}, - uint32(0xfff80000), - [21]string{"0x35", "0x2b", "0x78", "0x79", "0xde", "0x59", "0x34", "0x27", "0x4c", "0xcb", "0x80", "0xd0", "0x43", "0x4c", "0x55", "0x1a", "0xa6", "0x38", "0xc6", "0xff", "0x00"}}, - { - /* No.908 delta:924 weight:1557 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0x7bd98a7a, 0x491ad314, 0x32c3596e, 0x5fb038c7, 0x2469b2bd, 0x16aaebd3, 0x6d7361a9, 0x0000f01a, 0x7bd97a60, 0x491a230e, 0x32c3a974, 0x5fb0c8dd, 0x246942a7, 0x16aa1bc9, 0x6d7391b3}, - [16]uint32{0x00000000, 0x3064419a, 0x006ec436, 0x300a85ac, 0x00416015, 0x3025218f, 0x002fa423, 0x304be5b9, 0x00012c71, 0x30656deb, 0x006fe847, 0x300ba9dd, 0x00404c64, 0x30240dfe, 0x002e8852, 0x304ac9c8}, - [16]uint32{0x3f800000, 0x3f983220, 0x3f803762, 0x3f980542, 0x3f8020b0, 0x3f981290, 0x3f8017d2, 0x3f9825f2, 0x3f800096, 0x3f9832b6, 0x3f8037f4, 0x3f9805d4, 0x3f802026, 0x3f981206, 0x3f801744, 0x3f982564}, - uint32(0xfff80000), - [21]string{"0xca", "0x8f", "0x1a", "0xc1", "0xdf", "0xf4", "0x8c", "0x58", "0xfb", "0xe7", "0x6f", "0xe4", "0xb0", "0x10", "0xe8", "0x2c", "0xe5", "0x39", "0xbc", "0xdc", "0x00"}}, - { - /* No.909 delta:1014 weight:1413 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0xd07f9b50, 0x49522570, 0x992dbe20, 0x89f038d1, 0x598fa381, 0xc0a21da1, 0x10dd86f1, 0x00009c90, 0xd07f07c0, 0x4952b9e0, 0x992d22b0, 0x89f0a441, 0x598f3f11, 0xc0a28131, 0x10dd1a61}, - [16]uint32{0x00000000, 0x0a6e2e9e, 0x200401b2, 0x2a6a2f2c, 0x410a1bf8, 0x4b643566, 0x610e1a4a, 0x6b6034d4, 0x0002001f, 0x0a6c2e81, 0x200601ad, 0x2a682f33, 0x41081be7, 0x4b663579, 0x610c1a55, 0x6b6234cb}, - [16]uint32{0x3f800000, 0x3f853717, 0x3f900200, 0x3f953517, 0x3fa0850d, 0x3fa5b21a, 0x3fb0870d, 0x3fb5b01a, 0x3f800100, 0x3f853617, 0x3f900300, 0x3f953417, 0x3fa0840d, 0x3fa5b31a, 0x3fb0860d, 0x3fb5b11a}, - uint32(0xfff80000), - [21]string{"0x17", "0x02", "0x18", "0x2e", "0x37", "0xa3", "0x90", "0x44", "0xbe", "0x58", "0xff", "0xf4", "0xac", "0x5f", "0xf3", "0x64", "0x8a", "0xe2", "0xbd", "0x87", "0x00"}}, - { - /* No.910 delta:797 weight:1681 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x2cf7d117, 0xaa22979d, 0x86d5468a, 0xf6f038e1, 0xda07e9f6, 0x5cd2af7c, 0x70257e6b, 0x0000d6b6, 0x2cf707a1, 0xaa22412b, 0x86d5903c, 0xf6f0ee57, 0xda073f40, 0x5cd279ca, 0x7025a8dd}, - [16]uint32{0x00000000, 0x600c1c93, 0x20036fec, 0x400f737f, 0x00005008, 0x600c4c9b, 0x20033fe4, 0x400f2377, 0x02010202, 0x620d1e91, 0x22026dee, 0x420e717d, 0x0201520a, 0x620d4e99, 0x22023de6, 0x420e2175}, - [16]uint32{0x3f800000, 0x3fb0060e, 0x3f9001b7, 0x3fa007b9, 0x3f800028, 0x3fb00626, 0x3f90019f, 0x3fa00791, 0x3f810081, 0x3fb1068f, 0x3f910136, 0x3fa10738, 0x3f8100a9, 0x3fb106a7, 0x3f91011e, 0x3fa10710}, - uint32(0xfff80000), - [21]string{"0xdb", "0x91", "0xb4", "0x1a", "0x00", "0xc3", "0xa6", "0x42", "0x40", "0x10", "0x23", "0xbb", "0xc7", "0x28", "0xc8", "0xca", "0xf9", "0x45", "0x24", "0xcd", "0x00"}}, - { - /* No.911 delta:2273 weight:1221 */ - 11213, - 7, - 13, - 4, - [16]uint32{0x00000000, 0xc00b3209, 0xb625fef8, 0x762eccf1, 0x75a038f0, 0xb5ab0af9, 0xc385c608, 0x038ef401, 0x0000d8cd, 0xc00beac4, 0xb6252635, 0x762e143c, 0x75a0e03d, 0xb5abd234, 0xc3851ec5, 0x038e2ccc}, - [16]uint32{0x00000000, 0x86184436, 0x05e801e9, 0x83f045df, 0x0e08235c, 0x8810676a, 0x0be022b5, 0x8df86683, 0x1184201a, 0x979c642c, 0x146c21f3, 0x927465c5, 0x1f8c0346, 0x99944770, 0x1a6402af, 0x9c7c4699}, - [16]uint32{0x3f800000, 0x3fc30c22, 0x3f82f400, 0x3fc1f822, 0x3f870411, 0x3fc40833, 0x3f85f011, 0x3fc6fc33, 0x3f88c210, 0x3fcbce32, 0x3f8a3610, 0x3fc93a32, 0x3f8fc601, 0x3fccca23, 0x3f8d3201, 0x3fce3e23}, - uint32(0xfff80000), - [21]string{"0x9a", "0xf8", "0xaf", "0x40", "0x07", "0x33", "0xd7", "0x24", "0x78", "0xa0", "0xb7", "0x39", "0xee", "0xea", "0x4e", "0xdc", "0xa4", "0xf0", "0x99", "0x97", "0x00"}}, - { - /* No.912 delta:776 weight:1251 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x69723443, 0x9ccbcbe1, 0xf5b9ffa2, 0x3f803900, 0x56f20d43, 0xa34bf2e1, 0xca39c6a2, 0x00005615, 0x69726256, 0x9ccb9df4, 0xf5b9a9b7, 0x3f806f15, 0x56f25b56, 0xa34ba4f4, 0xca3990b7}, - [16]uint32{0x00000000, 0x306c01d6, 0x7010186a, 0x407c19bc, 0x1000000f, 0x206c01d9, 0x60101865, 0x507c19b3, 0x30126803, 0x007e69d5, 0x40027069, 0x706e71bf, 0x2012680c, 0x107e69da, 0x50027066, 0x606e71b0}, - [16]uint32{0x3f800000, 0x3f983600, 0x3fb8080c, 0x3fa03e0c, 0x3f880000, 0x3f903600, 0x3fb0080c, 0x3fa83e0c, 0x3f980934, 0x3f803f34, 0x3fa00138, 0x3fb83738, 0x3f900934, 0x3f883f34, 0x3fa80138, 0x3fb03738}, - uint32(0xfff80000), - [21]string{"0x31", "0xc2", "0x29", "0x31", "0x50", "0x48", "0xc0", "0x28", "0xcb", "0xf4", "0x4e", "0x85", "0x34", "0x1f", "0x9c", "0x6d", "0x87", "0x74", "0x4a", "0x53", "0x00"}}, - { - /* No.913 delta:1046 weight:1627 */ - 11213, - 29, - 13, - 4, - [16]uint32{0x00000000, 0xe69b092d, 0x13cc2719, 0xf5572e34, 0xaeb0391e, 0x482b3033, 0xbd7c1e07, 0x5be7172a, 0x000099ac, 0xe69b9081, 0x13ccbeb5, 0xf557b798, 0xaeb0a0b2, 0x482ba99f, 0xbd7c87ab, 0x5be78e86}, - [16]uint32{0x00000000, 0x10440492, 0x1020281d, 0x00642c8f, 0x40021404, 0x50461096, 0x50223c19, 0x4066388b, 0x60002011, 0x70442483, 0x7020080c, 0x60640c9e, 0x20023415, 0x30463087, 0x30221c08, 0x2066189a}, - [16]uint32{0x3f800000, 0x3f882202, 0x3f881014, 0x3f803216, 0x3fa0010a, 0x3fa82308, 0x3fa8111e, 0x3fa0331c, 0x3fb00010, 0x3fb82212, 0x3fb81004, 0x3fb03206, 0x3f90011a, 0x3f982318, 0x3f98110e, 0x3f90330c}, - uint32(0xfff80000), - [21]string{"0x6c", "0x37", "0xba", "0x5b", "0x59", "0xa3", "0xaf", "0x4a", "0x5a", "0x88", "0xe8", "0xcb", "0xdd", "0x01", "0xb1", "0x43", "0x5e", "0xef", "0x77", "0x94", "0x00"}}, - { - /* No.914 delta:2006 weight:1599 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0x06a8c348, 0x870b76be, 0x81a3b5f6, 0xd2f0392c, 0xd458fa64, 0x55fb4f92, 0x53538cda, 0x0000387e, 0x06a8fb36, 0x870b4ec0, 0x81a38d88, 0xd2f00152, 0xd458c21a, 0x55fb77ec, 0x5353b4a4}, - [16]uint32{0x00000000, 0x307041fb, 0x00480055, 0x303841ae, 0x000801c3, 0x30784038, 0x00400196, 0x3030406d, 0x3002c110, 0x007280eb, 0x304ac145, 0x003a80be, 0x300ac0d3, 0x007a8128, 0x3042c086, 0x0032817d}, - [16]uint32{0x3f800000, 0x3f983820, 0x3f802400, 0x3f981c20, 0x3f800400, 0x3f983c20, 0x3f802000, 0x3f981820, 0x3f980160, 0x3f803940, 0x3f982560, 0x3f801d40, 0x3f980560, 0x3f803d40, 0x3f982160, 0x3f801940}, - uint32(0xfff80000), - [21]string{"0x89", "0x1c", "0x8c", "0xf1", "0x0d", "0x28", "0x10", "0x53", "0xf3", "0xa9", "0x16", "0xb2", "0x3b", "0x95", "0xa6", "0xaf", "0x5d", "0x9a", "0x2d", "0xde", "0x00"}}, - { - /* No.915 delta:1823 weight:1495 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x19892a20, 0xc316f4bf, 0xda9fde9f, 0xb7a0393c, 0xae29131c, 0x74b6cd83, 0x6d3fe7a3, 0x0000656b, 0x19894f4b, 0xc31691d4, 0xda9fbbf4, 0xb7a05c57, 0xae297677, 0x74b6a8e8, 0x6d3f82c8}, - [16]uint32{0x00000000, 0x11e00414, 0x41ab6809, 0x504b6c1d, 0x80102012, 0x91f02406, 0xc1bb481b, 0xd05b4c0f, 0x09b07018, 0x1850740c, 0x481b1811, 0x59fb1c05, 0x89a0500a, 0x9840541e, 0xc80b3803, 0xd9eb3c17}, - [16]uint32{0x3f800000, 0x3f88f002, 0x3fa0d5b4, 0x3fa825b6, 0x3fc00810, 0x3fc8f812, 0x3fe0dda4, 0x3fe82da6, 0x3f84d838, 0x3f8c283a, 0x3fa40d8c, 0x3facfd8e, 0x3fc4d028, 0x3fcc202a, 0x3fe4059c, 0x3fecf59e}, - uint32(0xfff80000), - [21]string{"0x31", "0xfe", "0x01", "0xe9", "0xa1", "0x8b", "0x5d", "0x5c", "0x60", "0xc8", "0xbb", "0x2c", "0x8e", "0x0e", "0x6b", "0x9b", "0x38", "0xc0", "0x52", "0x60", "0x00"}}, - { - /* No.916 delta:1420 weight:1589 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x949c5ab7, 0x6d95dac7, 0xf9098070, 0x00203945, 0x94bc63f2, 0x6db5e382, 0xf929b935, 0x0000c923, 0x949c9394, 0x6d9513e4, 0xf9094953, 0x0020f066, 0x94bcaad1, 0x6db52aa1, 0xf9297016}, - [16]uint32{0x00000000, 0x407e0cb2, 0xc060221c, 0x801e2eae, 0x4000b034, 0x007ebc86, 0x80609228, 0xc01e9e9a, 0x4002a01d, 0x007cacaf, 0x80628201, 0xc01c8eb3, 0x00021029, 0x407c1c9b, 0xc0623235, 0x801c3e87}, - [16]uint32{0x3f800000, 0x3fa03f06, 0x3fe03011, 0x3fc00f17, 0x3fa00058, 0x3f803f5e, 0x3fc03049, 0x3fe00f4f, 0x3fa00150, 0x3f803e56, 0x3fc03141, 0x3fe00e47, 0x3f800108, 0x3fa03e0e, 0x3fe03119, 0x3fc00e1f}, - uint32(0xfff80000), - [21]string{"0x59", "0x71", "0x9b", "0xbc", "0xa2", "0xc0", "0xbf", "0xa2", "0x8f", "0x10", "0x20", "0x9b", "0xf4", "0xe8", "0x04", "0x89", "0xcc", "0x7c", "0x99", "0xff", "0x00"}}, - { - /* No.917 delta:2000 weight:1653 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0xd4684509, 0xd840f0fd, 0x0c28b5f4, 0x4170395a, 0x95187c53, 0x9930c9a7, 0x4d588cae, 0x000058cd, 0xd4681dc4, 0xd840a830, 0x0c28ed39, 0x41706197, 0x9518249e, 0x9930916a, 0x4d58d463}, - [16]uint32{0x00000000, 0x40750356, 0x006ec0da, 0x401bc38c, 0x00020149, 0x4077021f, 0x006cc193, 0x4019c2c5, 0x000001fd, 0x407502ab, 0x006ec127, 0x401bc271, 0x000200b4, 0x407703e2, 0x006cc06e, 0x4019c338}, - [16]uint32{0x3f800000, 0x3fa03a81, 0x3f803760, 0x3fa00de1, 0x3f800100, 0x3fa03b81, 0x3f803660, 0x3fa00ce1, 0x3f800000, 0x3fa03a81, 0x3f803760, 0x3fa00de1, 0x3f800100, 0x3fa03b81, 0x3f803660, 0x3fa00ce1}, - uint32(0xfff80000), - [21]string{"0x2a", "0x32", "0xe1", "0x53", "0x09", "0xfe", "0x23", "0x37", "0xd7", "0x7f", "0x96", "0x73", "0xca", "0x94", "0xa4", "0x8e", "0x30", "0x7b", "0xaa", "0x1f", "0x00"}}, - { - /* No.918 delta:704 weight:1657 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0x1faf3cf6, 0x19cbd677, 0x0664ea81, 0x65803965, 0x7a2f0593, 0x7c4bef12, 0x63e4d3e4, 0x0000c185, 0x1faffd73, 0x19cb17f2, 0x06642b04, 0x6580f8e0, 0x7a2fc416, 0x7c4b2e97, 0x63e41261}, - [16]uint32{0x00000000, 0x00501036, 0x8024885f, 0x80749869, 0x40208e0b, 0x40709e3d, 0xc0040654, 0xc0541662, 0x400921c6, 0x405931f0, 0xc02da999, 0xc07db9af, 0x0029afcd, 0x0079bffb, 0x800d2792, 0x805d37a4}, - [16]uint32{0x3f800000, 0x3f802808, 0x3fc01244, 0x3fc03a4c, 0x3fa01047, 0x3fa0384f, 0x3fe00203, 0x3fe02a0b, 0x3fa00490, 0x3fa02c98, 0x3fe016d4, 0x3fe03edc, 0x3f8014d7, 0x3f803cdf, 0x3fc00693, 0x3fc02e9b}, - uint32(0xfff80000), - [21]string{"0x1d", "0x40", "0xd5", "0xde", "0x90", "0x3d", "0xd9", "0x0c", "0xb4", "0x2f", "0x65", "0x87", "0xc4", "0x45", "0xa7", "0xe1", "0x7f", "0x54", "0x95", "0x81", "0x00"}}, - { - /* No.919 delta:735 weight:1499 */ - 11213, - 81, - 13, - 4, - [16]uint32{0x00000000, 0x12a59b94, 0xa9d3b085, 0xbb762b11, 0xd470397f, 0xc6d5a2eb, 0x7da389fa, 0x6f06126e, 0x0000166e, 0x12a58dfa, 0xa9d3a6eb, 0xbb763d7f, 0xd4702f11, 0xc6d5b485, 0x7da39f94, 0x6f060400}, - [16]uint32{0x00000000, 0x9007039e, 0x0002c19c, 0x9005c202, 0x4001a1d8, 0xd006a246, 0x40036044, 0xd00463da, 0x4001901d, 0xd0069383, 0x40035181, 0xd004521f, 0x000031c5, 0x9007325b, 0x0002f059, 0x9005f3c7}, - [16]uint32{0x3f800000, 0x3fc80381, 0x3f800160, 0x3fc802e1, 0x3fa000d0, 0x3fe80351, 0x3fa001b0, 0x3fe80231, 0x3fa000c8, 0x3fe80349, 0x3fa001a8, 0x3fe80229, 0x3f800018, 0x3fc80399, 0x3f800178, 0x3fc802f9}, - uint32(0xfff80000), - [21]string{"0x49", "0x55", "0x54", "0x81", "0xbe", "0x6f", "0xcf", "0xed", "0x41", "0x9c", "0xb6", "0x47", "0x23", "0x3b", "0x77", "0x7f", "0xde", "0x1c", "0x57", "0xab", "0x00"}}, - { - /* No.920 delta:870 weight:1243 */ - 11213, - 45, - 13, - 4, - [16]uint32{0x00000000, 0xac10cf4d, 0xdbf6aa04, 0x77e66549, 0x1c003986, 0xb010f6cb, 0xc7f69382, 0x6be65ccf, 0x0000f93f, 0xac103672, 0xdbf6533b, 0x77e69c76, 0x1c00c0b9, 0xb0100ff4, 0xc7f66abd, 0x6be6a5f0}, - [16]uint32{0x00000000, 0x4004021e, 0x4008b84d, 0x000cba53, 0x10001606, 0x50041418, 0x5008ae4b, 0x100cac55, 0x40200a07, 0x00240819, 0x0028b24a, 0x402cb054, 0x50201c01, 0x10241e1f, 0x1028a44c, 0x502ca652}, - [16]uint32{0x3f800000, 0x3fa00201, 0x3fa0045c, 0x3f80065d, 0x3f88000b, 0x3fa8020a, 0x3fa80457, 0x3f880656, 0x3fa01005, 0x3f801204, 0x3f801459, 0x3fa01658, 0x3fa8100e, 0x3f88120f, 0x3f881452, 0x3fa81653}, - uint32(0xfff80000), - [21]string{"0x59", "0xf0", "0xd5", "0x28", "0x4c", "0xa6", "0x2c", "0x77", "0xa5", "0x16", "0xa6", "0x45", "0x93", "0x10", "0xe2", "0x5f", "0xa3", "0x24", "0x17", "0xfd", "0x00"}}, - { - /* No.921 delta:1051 weight:1399 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x5e21320e, 0x77c09860, 0x29e1aa6e, 0x5420399f, 0x0a010b91, 0x23e0a1ff, 0x7dc193f1, 0x00005740, 0x5e21654e, 0x77c0cf20, 0x29e1fd2e, 0x54206edf, 0x0a015cd1, 0x23e0f6bf, 0x7dc1c4b1}, - [16]uint32{0x00000000, 0x1054e936, 0x322d21ed, 0x2279c8db, 0x2006b821, 0x30525117, 0x122b99cc, 0x027f70fa, 0x00426c1f, 0x10168529, 0x326f4df2, 0x223ba4c4, 0x2044d43e, 0x30103d08, 0x1269f5d3, 0x023d1ce5}, - [16]uint32{0x3f800000, 0x3f882a74, 0x3f991690, 0x3f913ce4, 0x3f90035c, 0x3f982928, 0x3f8915cc, 0x3f813fb8, 0x3f802136, 0x3f880b42, 0x3f9937a6, 0x3f911dd2, 0x3f90226a, 0x3f98081e, 0x3f8934fa, 0x3f811e8e}, - uint32(0xfff80000), - [21]string{"0x78", "0x1b", "0xef", "0xa3", "0x61", "0xb9", "0x45", "0xff", "0x40", "0x84", "0xe8", "0x32", "0x68", "0x8c", "0x00", "0x3d", "0x23", "0x71", "0xe2", "0x8e", "0x00"}}, - { - /* No.922 delta:2881 weight:761 */ - 11213, - 4, - 13, - 4, - [16]uint32{0x00000000, 0x27d96f1a, 0xcb1b02e1, 0xecc26dfb, 0x2c7039aa, 0x0ba956b0, 0xe76b3b4b, 0xc0b25451, 0x00006c57, 0x27d9034d, 0xcb1b6eb6, 0xecc201ac, 0x2c7055fd, 0x0ba93ae7, 0xe76b571c, 0xc0b23806}, - [16]uint32{0x00000000, 0xb04c6089, 0xd020009a, 0x606c6013, 0x83200107, 0x336c618e, 0x5300019d, 0xe34c6114, 0xa00001eb, 0x104c6162, 0x70200171, 0xc06c61f8, 0x232000ec, 0x936c6065, 0xf3000076, 0x434c60ff}, - [16]uint32{0x3f800000, 0x3fd82630, 0x3fe81000, 0x3fb03630, 0x3fc19000, 0x3f99b630, 0x3fa98000, 0x3ff1a630, 0x3fd00000, 0x3f882630, 0x3fb81000, 0x3fe03630, 0x3f919000, 0x3fc9b630, 0x3ff98000, 0x3fa1a630}, - uint32(0xfff80000), - [21]string{"0xb9", "0x49", "0x4d", "0x4a", "0xa6", "0x04", "0x0e", "0x38", "0x2d", "0x7a", "0x63", "0xd1", "0x1a", "0x17", "0x69", "0x38", "0x91", "0xf0", "0xd4", "0x22", "0x00"}}, - { - /* No.923 delta:766 weight:1615 */ - 11213, - 56, - 13, - 4, - [16]uint32{0x00000000, 0x2eb52232, 0xcff77d60, 0xe1425f52, 0x013039b0, 0x2f851b82, 0xcec744d0, 0xe07266e2, 0x00000fb0, 0x2eb52d82, 0xcff772d0, 0xe14250e2, 0x01303600, 0x2f851432, 0xcec74b60, 0xe0726952}, - [16]uint32{0x00000000, 0x80007177, 0x2003818d, 0xa003f0fa, 0x600005b4, 0xe00074c3, 0x40038439, 0xc003f54e, 0x3001d11d, 0xb001a06a, 0x10025090, 0x900221e7, 0x5001d4a9, 0xd001a5de, 0x70025524, 0xf0022453}, - [16]uint32{0x3f800000, 0x3fc00038, 0x3f9001c0, 0x3fd001f8, 0x3fb00002, 0x3ff0003a, 0x3fa001c2, 0x3fe001fa, 0x3f9800e8, 0x3fd800d0, 0x3f880128, 0x3fc80110, 0x3fa800ea, 0x3fe800d2, 0x3fb8012a, 0x3ff80112}, - uint32(0xfff80000), - [21]string{"0xfd", "0xab", "0x50", "0x7a", "0x93", "0x98", "0x94", "0xf0", "0xc2", "0x5c", "0xba", "0xa5", "0x21", "0x4d", "0x2c", "0x76", "0x19", "0x5a", "0xe9", "0xea", "0x00"}}, - { - /* No.924 delta:704 weight:1521 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xdc1efe13, 0xbf95f776, 0x638b0965, 0xe9e039c1, 0x35fec7d2, 0x5675ceb7, 0x8a6b30a4, 0x00003580, 0xdc1ecb93, 0xbf95c2f6, 0x638b3ce5, 0xe9e00c41, 0x35fef252, 0x5675fb37, 0x8a6b0524}, - [16]uint32{0x00000000, 0x0058195f, 0xb0042103, 0xb05c385c, 0x106010a9, 0x103809f6, 0xa06431aa, 0xa03c28f5, 0x000c0284, 0x00541bdb, 0xb0082387, 0xb0503ad8, 0x106c122d, 0x10340b72, 0xa068332e, 0xa0302a71}, - [16]uint32{0x3f800000, 0x3f802c0c, 0x3fd80210, 0x3fd82e1c, 0x3f883008, 0x3f881c04, 0x3fd03218, 0x3fd01e14, 0x3f800601, 0x3f802a0d, 0x3fd80411, 0x3fd8281d, 0x3f883609, 0x3f881a05, 0x3fd03419, 0x3fd01815}, - uint32(0xfff80000), - [21]string{"0x13", "0x7c", "0x3a", "0xd0", "0x16", "0xae", "0x8a", "0xfa", "0x1a", "0x32", "0x09", "0xe8", "0xd6", "0x96", "0x1b", "0x20", "0x21", "0xba", "0xc6", "0x78", "0x00"}}, - { - /* No.925 delta:1271 weight:1659 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x5ce06fc7, 0xc249e6dc, 0x9ea9891b, 0x22c039d1, 0x7e205616, 0xe089df0d, 0xbc69b0ca, 0x00006e32, 0x5ce001f5, 0xc24988ee, 0x9ea9e729, 0x22c057e3, 0x7e203824, 0xe089b13f, 0xbc69def8}, - [16]uint32{0x00000000, 0xc0194996, 0x006a7014, 0xc0733982, 0x4008100c, 0x8011599a, 0x40626018, 0x807b298e, 0x8005a10b, 0x401ce89d, 0x806fd11f, 0x40769889, 0xc00db107, 0x0014f891, 0xc067c113, 0x007e8885}, - [16]uint32{0x3f800000, 0x3fe00ca4, 0x3f803538, 0x3fe0399c, 0x3fa00408, 0x3fc008ac, 0x3fa03130, 0x3fc03d94, 0x3fc002d0, 0x3fa00e74, 0x3fc037e8, 0x3fa03b4c, 0x3fe006d8, 0x3f800a7c, 0x3fe033e0, 0x3f803f44}, - uint32(0xfff80000), - [21]string{"0xa6", "0x8f", "0x0c", "0x11", "0x49", "0xce", "0x8e", "0x91", "0x3c", "0x5b", "0x93", "0xcd", "0x33", "0x49", "0x36", "0x93", "0x8c", "0xa9", "0x32", "0x99", "0x00"}}, - { - /* No.926 delta:2075 weight:1247 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x3d16ef93, 0x7a0154b5, 0x4717bb26, 0x4f7039e0, 0x7266d673, 0x35716d55, 0x086782c6, 0x00009ba0, 0x3d167433, 0x7a01cf15, 0x47172086, 0x4f70a240, 0x72664dd3, 0x3571f6f5, 0x08671966}, - [16]uint32{0x00000000, 0x7dc4355e, 0x18122071, 0x65d6152f, 0x1447e018, 0x6983d546, 0x0c55c069, 0x7191f537, 0x00e880e5, 0x7d2cb5bb, 0x18faa094, 0x653e95ca, 0x14af60fd, 0x696b55a3, 0x0cbd408c, 0x717975d2}, - [16]uint32{0x3f800000, 0x3fbee21a, 0x3f8c0910, 0x3fb2eb0a, 0x3f8a23f0, 0x3fb4c1ea, 0x3f862ae0, 0x3fb8c8fa, 0x3f807440, 0x3fbe965a, 0x3f8c7d50, 0x3fb29f4a, 0x3f8a57b0, 0x3fb4b5aa, 0x3f865ea0, 0x3fb8bcba}, - uint32(0xfff80000), - [21]string{"0xf8", "0xb1", "0xdf", "0x95", "0x99", "0x4e", "0xe8", "0x05", "0x6c", "0xe6", "0x9c", "0x66", "0xf3", "0x24", "0xa9", "0xb2", "0xff", "0xac", "0xaf", "0x04", "0x00"}}, - { - /* No.927 delta:738 weight:1261 */ - 11213, - 78, - 13, - 4, - [16]uint32{0x00000000, 0x9855fd8a, 0x1574193b, 0x8d21e4b1, 0x06f039fb, 0x9ea5c471, 0x138420c0, 0x8bd1dd4a, 0x0000f562, 0x985508e8, 0x1574ec59, 0x8d2111d3, 0x06f0cc99, 0x9ea53113, 0x1384d5a2, 0x8bd12828}, - [16]uint32{0x00000000, 0xa002139e, 0x2010885d, 0x80129bc3, 0x22010cc9, 0x82031f57, 0x02118494, 0xa213970a, 0x00081381, 0xa00a001f, 0x20189bdc, 0x801a8842, 0x22091f48, 0x820b0cd6, 0x02199715, 0xa21b848b}, - [16]uint32{0x3f800000, 0x3fd00109, 0x3f900844, 0x3fc0094d, 0x3f910086, 0x3fc1018f, 0x3f8108c2, 0x3fd109cb, 0x3f800409, 0x3fd00500, 0x3f900c4d, 0x3fc00d44, 0x3f91048f, 0x3fc10586, 0x3f810ccb, 0x3fd10dc2}, - uint32(0xfff80000), - [21]string{"0x92", "0xb4", "0x0b", "0xe3", "0x6e", "0xf5", "0xce", "0x02", "0x7c", "0x80", "0x23", "0xa5", "0xf4", "0xd1", "0x38", "0x5d", "0xa4", "0xe3", "0xde", "0x2c", "0x00"}}, - { - /* No.928 delta:962 weight:1531 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0xc3ad8fae, 0x6da90795, 0xae04883b, 0xe8703a05, 0x2bddb5ab, 0x85d93d90, 0x4674b23e, 0x00004835, 0xc3adc79b, 0x6da94fa0, 0xae04c00e, 0xe8707230, 0x2bddfd9e, 0x85d975a5, 0x4674fa0b}, - [16]uint32{0x00000000, 0x00421c5e, 0x4002d342, 0x4040cf1c, 0x60008667, 0x60429a39, 0x20025525, 0x2040497b, 0x30000011, 0x30421c4f, 0x7002d353, 0x7040cf0d, 0x50008676, 0x50429a28, 0x10025534, 0x1040496a}, - [16]uint32{0x3f800000, 0x3f80210e, 0x3fa00169, 0x3fa02067, 0x3fb00043, 0x3fb0214d, 0x3f90012a, 0x3f902024, 0x3f980000, 0x3f98210e, 0x3fb80169, 0x3fb82067, 0x3fa80043, 0x3fa8214d, 0x3f88012a, 0x3f882024}, - uint32(0xfff80000), - [21]string{"0x5e", "0xce", "0xaf", "0xae", "0x77", "0xf2", "0xa2", "0xd7", "0xa6", "0xdd", "0x12", "0xf6", "0x3a", "0xb7", "0xe6", "0x61", "0x64", "0xef", "0x6c", "0xa9", "0x00"}}, - { - /* No.929 delta:1454 weight:1605 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x774ff63f, 0x9bf1af7d, 0xecbe5942, 0xe3a03a11, 0x94efcc2e, 0x7851956c, 0x0f1e6353, 0x0000d2e0, 0x774f24df, 0x9bf17d9d, 0xecbe8ba2, 0xe3a0e8f1, 0x94ef1ece, 0x7851478c, 0x0f1eb1b3}, - [16]uint32{0x00000000, 0x48742c54, 0x40089017, 0x087cbc43, 0x004e020c, 0x483a2e58, 0x4046921b, 0x0832be4f, 0x60208402, 0x2854a856, 0x20281415, 0x685c3841, 0x606e860e, 0x281aaa5a, 0x20661619, 0x68123a4d}, - [16]uint32{0x3f800000, 0x3fa43a16, 0x3fa00448, 0x3f843e5e, 0x3f802701, 0x3fa41d17, 0x3fa02349, 0x3f84195f, 0x3fb01042, 0x3f942a54, 0x3f90140a, 0x3fb42e1c, 0x3fb03743, 0x3f940d55, 0x3f90330b, 0x3fb4091d}, - uint32(0xfff80000), - [21]string{"0x76", "0x9c", "0x91", "0x4d", "0xa2", "0xa8", "0xf9", "0x01", "0xe6", "0x0b", "0xab", "0x8c", "0xbd", "0x36", "0xec", "0xaf", "0x4b", "0x4a", "0x33", "0x12", "0x00"}}, - { - /* No.930 delta:1534 weight:1569 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x0bb95810, 0xfc56c990, 0xf7ef9180, 0xc7b03a2f, 0xcc09623f, 0x3be6f3bf, 0x305fabaf, 0x00008926, 0x0bb9d136, 0xfc5640b6, 0xf7ef18a6, 0xc7b0b309, 0xcc09eb19, 0x3be67a99, 0x305f2289}, - [16]uint32{0x00000000, 0x0f1d10fa, 0x08a8401c, 0x07b550e6, 0x0080f12e, 0x0f9de1d4, 0x0828b132, 0x0735a1c8, 0x00428d4f, 0x0f5f9db5, 0x08eacd53, 0x07f7dda9, 0x00c27c61, 0x0fdf6c9b, 0x086a3c7d, 0x07772c87}, - [16]uint32{0x3f800000, 0x3f878e88, 0x3f845420, 0x3f83daa8, 0x3f804078, 0x3f87cef0, 0x3f841458, 0x3f839ad0, 0x3f802146, 0x3f87afce, 0x3f847566, 0x3f83fbee, 0x3f80613e, 0x3f87efb6, 0x3f84351e, 0x3f83bb96}, - uint32(0xfff80000), - [21]string{"0x0d", "0x50", "0xfb", "0x98", "0x56", "0x1e", "0x80", "0xa3", "0x6b", "0xbb", "0x73", "0x98", "0x58", "0x03", "0xe9", "0x99", "0x03", "0x7a", "0x9d", "0x06", "0x00"}}, - { - /* No.931 delta:680 weight:1409 */ - 11213, - 90, - 13, - 4, - [16]uint32{0x00000000, 0xc50443ac, 0x77dfd5c7, 0xb2db966b, 0xc2503a3a, 0x07547996, 0xb58feffd, 0x708bac51, 0x00002bc2, 0xc504686e, 0x77dffe05, 0xb2dbbda9, 0xc25011f8, 0x07545254, 0xb58fc43f, 0x708b8793}, - [16]uint32{0x00000000, 0x0071f215, 0x300dc41e, 0x307c360b, 0x5053a9da, 0x50225bcf, 0x605e6dc4, 0x602f9fd1, 0x402ce109, 0x405d131c, 0x70212517, 0x7050d702, 0x107f48d3, 0x100ebac6, 0x20728ccd, 0x20037ed8}, - [16]uint32{0x3f800000, 0x3f8038f9, 0x3f9806e2, 0x3f983e1b, 0x3fa829d4, 0x3fa8112d, 0x3fb02f36, 0x3fb017cf, 0x3fa01670, 0x3fa02e89, 0x3fb81092, 0x3fb8286b, 0x3f883fa4, 0x3f88075d, 0x3f903946, 0x3f9001bf}, - uint32(0xfff80000), - [21]string{"0x5d", "0x06", "0x30", "0x79", "0x6d", "0xa1", "0x6a", "0x97", "0x54", "0x2e", "0x83", "0xa5", "0x1b", "0xa3", "0x00", "0xa7", "0x4e", "0xce", "0x4d", "0x93", "0x00"}}, - { - /* No.932 delta:774 weight:1557 */ - 11213, - 68, - 13, - 4, - [16]uint32{0x00000000, 0xd99c677b, 0xcff1bacd, 0x166dddb6, 0xe7703a48, 0x3eec5d33, 0x28818085, 0xf11de7fe, 0x0000a030, 0xd99cc74b, 0xcff11afd, 0x166d7d86, 0xe7709a78, 0x3eecfd03, 0x288120b5, 0xf11d47ce}, - [16]uint32{0x00000000, 0xa4426e5e, 0x3003229b, 0x94414cc5, 0x1000120a, 0xb4427c54, 0x20033091, 0x84415ecf, 0x24000159, 0x80426f07, 0x140323c2, 0xb0414d9c, 0x34001353, 0x90427d0d, 0x040331c8, 0xa0415f96}, - [16]uint32{0x3f800000, 0x3fd22137, 0x3f980191, 0x3fca20a6, 0x3f880009, 0x3fda213e, 0x3f900198, 0x3fc220af, 0x3f920000, 0x3fc02137, 0x3f8a0191, 0x3fd820a6, 0x3f9a0009, 0x3fc8213e, 0x3f820198, 0x3fd020af}, - uint32(0xfff80000), - [21]string{"0x20", "0x43", "0xd4", "0x7f", "0xde", "0xde", "0x20", "0xe2", "0xd6", "0xf9", "0x70", "0x2b", "0xb9", "0xc6", "0xa9", "0x49", "0x4b", "0x27", "0x31", "0x41", "0x00"}}, - { - /* No.933 delta:595 weight:1765 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0xdd80bfa7, 0x59ad25be, 0x842d9a19, 0x7b903a57, 0xa61085f0, 0x223d1fe9, 0xffbda04e, 0x000058b3, 0xdd80e714, 0x59ad7d0d, 0x842dc2aa, 0x7b9062e4, 0xa610dd43, 0x223d475a, 0xffbdf8fd}, - [16]uint32{0x00000000, 0x2043087e, 0x0002a66a, 0x2041ae14, 0x2000dabf, 0x0043d2c1, 0x20027cd5, 0x004174ab, 0x1000a016, 0x3043a868, 0x1002067c, 0x30410e02, 0x30007aa9, 0x104372d7, 0x3002dcc3, 0x1041d4bd}, - [16]uint32{0x3f800000, 0x3f902184, 0x3f800153, 0x3f9020d7, 0x3f90006d, 0x3f8021e9, 0x3f90013e, 0x3f8020ba, 0x3f880050, 0x3f9821d4, 0x3f880103, 0x3f982087, 0x3f98003d, 0x3f8821b9, 0x3f98016e, 0x3f8820ea}, - uint32(0xfff80000), - [21]string{"0x59", "0xad", "0x2b", "0x01", "0x90", "0x4d", "0xf3", "0x0a", "0x44", "0xf6", "0x7a", "0xb1", "0xe0", "0x93", "0x90", "0x44", "0xb6", "0x7a", "0x52", "0xf2", "0x00"}}, - { - /* No.934 delta:1003 weight:1569 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x845889d5, 0x3e647ff0, 0xba3cf625, 0xb7e03a67, 0x33b8b3b2, 0x89844597, 0x0ddccc42, 0x0000bc10, 0x845835c5, 0x3e64c3e0, 0xba3c4a35, 0xb7e08677, 0x33b80fa2, 0x8984f987, 0x0ddc7052}, - [16]uint32{0x00000000, 0x0004d9d6, 0x5008361f, 0x500cefc9, 0x10224bfb, 0x1026922d, 0x402a7de4, 0x402ea432, 0x0002401a, 0x000699cc, 0x500a7605, 0x500eafd3, 0x10200be1, 0x1024d237, 0x40283dfe, 0x402ce428}, - [16]uint32{0x3f800000, 0x3f80026c, 0x3fa8041b, 0x3fa80677, 0x3f881125, 0x3f881349, 0x3fa0153e, 0x3fa01752, 0x3f800120, 0x3f80034c, 0x3fa8053b, 0x3fa80757, 0x3f881005, 0x3f881269, 0x3fa0141e, 0x3fa01672}, - uint32(0xfff80000), - [21]string{"0xd3", "0xac", "0x18", "0xf5", "0xa5", "0x47", "0x0f", "0xd4", "0x4f", "0x5e", "0x17", "0x01", "0x44", "0x36", "0x9c", "0x43", "0xb4", "0xcc", "0x68", "0x79", "0x00"}}, - { - /* No.935 delta:1449 weight:1699 */ - 11213, - 85, - 13, - 4, - [16]uint32{0x00000000, 0x5e5eed4f, 0x3893f32d, 0x66cd1e62, 0xd2e03a7f, 0x8cbed730, 0xea73c952, 0xb42d241d, 0x00002bd1, 0x5e5ec69e, 0x3893d8fc, 0x66cd35b3, 0xd2e011ae, 0x8cbefce1, 0xea73e283, 0xb42d0fcc}, - [16]uint32{0x00000000, 0x203800dd, 0x00074116, 0x203f41cb, 0x2001003f, 0x003900e2, 0x20064129, 0x003e41f4, 0x0004c039, 0x203cc0e4, 0x0003812f, 0x203b81f2, 0x2005c006, 0x003dc0db, 0x20028110, 0x003a81cd}, - [16]uint32{0x3f800000, 0x3f901c00, 0x3f8003a0, 0x3f901fa0, 0x3f900080, 0x3f801c80, 0x3f900320, 0x3f801f20, 0x3f800260, 0x3f901e60, 0x3f8001c0, 0x3f901dc0, 0x3f9002e0, 0x3f801ee0, 0x3f900140, 0x3f801d40}, - uint32(0xfff80000), - [21]string{"0x1d", "0x13", "0x2b", "0xba", "0x03", "0xf2", "0x4f", "0x61", "0x68", "0x6b", "0x69", "0x21", "0xda", "0x0b", "0x3f", "0x6d", "0x17", "0xd2", "0xf4", "0xbd", "0x00"}}, - { - /* No.936 delta:896 weight:1561 */ - 11213, - 91, - 13, - 4, - [16]uint32{0x00000000, 0xacfcdf03, 0x696f497f, 0xc593967c, 0x1f303a87, 0xb3cce584, 0x765f73f8, 0xdaa3acfb, 0x0000f6f0, 0xacfc29f3, 0x696fbf8f, 0xc593608c, 0x1f30cc77, 0xb3cc1374, 0x765f8508, 0xdaa35a0b}, - [16]uint32{0x00000000, 0x007400d5, 0x004320f6, 0x00372023, 0x0429e86c, 0x045de8b9, 0x046ac89a, 0x041ec84f, 0x50180018, 0x506c00cd, 0x505b20ee, 0x502f203b, 0x5431e874, 0x5445e8a1, 0x5472c882, 0x5406c857}, - [16]uint32{0x3f800000, 0x3f803a00, 0x3f802190, 0x3f801b90, 0x3f8214f4, 0x3f822ef4, 0x3f823564, 0x3f820f64, 0x3fa80c00, 0x3fa83600, 0x3fa82d90, 0x3fa81790, 0x3faa18f4, 0x3faa22f4, 0x3faa3964, 0x3faa0364}, - uint32(0xfff80000), - [21]string{"0x8b", "0xee", "0xc6", "0x63", "0x17", "0x86", "0x00", "0x9f", "0xae", "0x33", "0x55", "0x42", "0xb3", "0xe7", "0x14", "0xed", "0x27", "0xe1", "0x5d", "0xab", "0x00"}}, - { - /* No.937 delta:1479 weight:1795 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0x90905875, 0x19772e9d, 0x89e776e8, 0x3e803a92, 0xae1062e7, 0x27f7140f, 0xb7674c7a, 0x00001b06, 0x90904373, 0x1977359b, 0x89e76dee, 0x3e802194, 0xae1079e1, 0x27f70f09, 0xb767577c}, - [16]uint32{0x00000000, 0x0694901a, 0x52f26765, 0x5466f77f, 0x005a60a9, 0x06cef0b3, 0x52a807cc, 0x543c97d6, 0x007ae21b, 0x06ee7201, 0x5288857e, 0x541c1564, 0x002082b2, 0x06b412a8, 0x52d2e5d7, 0x544675cd}, - [16]uint32{0x3f800000, 0x3f834a48, 0x3fa97933, 0x3faa337b, 0x3f802d30, 0x3f836778, 0x3fa95403, 0x3faa1e4b, 0x3f803d71, 0x3f837739, 0x3fa94442, 0x3faa0e0a, 0x3f801041, 0x3f835a09, 0x3fa96972, 0x3faa233a}, - uint32(0xfff80000), - [21]string{"0x00", "0xce", "0x34", "0xca", "0x07", "0x25", "0x86", "0xd5", "0x72", "0x75", "0xb7", "0x67", "0xef", "0xe0", "0x01", "0xda", "0x79", "0x38", "0xb6", "0x0b", "0x00"}}, - { - /* No.938 delta:3091 weight:585 */ - 11213, - 3, - 13, - 4, - [16]uint32{0x00000000, 0x25ed51db, 0xcf7ef76a, 0xea93a6b1, 0xf8403aa5, 0xddad6b7e, 0x373ecdcf, 0x12d39c14, 0x00005a2e, 0x25ed0bf5, 0xcf7ead44, 0xea93fc9f, 0xf840608b, 0xddad3150, 0x373e97e1, 0x12d3c63a}, - [16]uint32{0x00000000, 0xb95800b5, 0x822010d7, 0x3b781062, 0x4482440c, 0xfdda44b9, 0xc6a254db, 0x7ffa546e, 0x4bc0c15a, 0xf298c1ef, 0xc9e0d18d, 0x70b8d138, 0x0f428556, 0xb61a85e3, 0x8d629581, 0x343a9534}, - [16]uint32{0x3f800000, 0x3fdcac00, 0x3fc11008, 0x3f9dbc08, 0x3fa24122, 0x3ffeed22, 0x3fe3512a, 0x3fbffd2a, 0x3fa5e060, 0x3ff94c60, 0x3fe4f068, 0x3fb85c68, 0x3f87a142, 0x3fdb0d42, 0x3fc6b14a, 0x3f9a1d4a}, - uint32(0xfff80000), - [21]string{"0xb2", "0x4b", "0x93", "0xc3", "0x60", "0x8f", "0xd6", "0xa5", "0xae", "0xde", "0x58", "0x7a", "0x8b", "0xbb", "0x6d", "0xe4", "0xc1", "0x90", "0x97", "0x38", "0x00"}}, - { - /* No.939 delta:2163 weight:1277 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x4c008da2, 0x825f20bf, 0xce5fad1d, 0x13103ab0, 0x5f10b712, 0x914f1a0f, 0xdd4f97ad, 0x00006480, 0x4c00e922, 0x825f443f, 0xce5fc99d, 0x13105e30, 0x5f10d392, 0x914f7e8f, 0xdd4ff32d}, - [16]uint32{0x00000000, 0x0c21c0d6, 0x026b01f3, 0x0e4ac125, 0x0325e194, 0x0f042142, 0x014ee067, 0x0d6f20b1, 0x6221c0fa, 0x6e00002c, 0x604ac109, 0x6c6b01df, 0x6104216e, 0x6d25e1b8, 0x636f209d, 0x6f4ee04b}, - [16]uint32{0x3f800000, 0x3f8610e0, 0x3f813580, 0x3f872560, 0x3f8192f0, 0x3f878210, 0x3f80a770, 0x3f86b790, 0x3fb110e0, 0x3fb70000, 0x3fb02560, 0x3fb63580, 0x3fb08210, 0x3fb692f0, 0x3fb1b790, 0x3fb7a770}, - uint32(0xfff80000), - [21]string{"0x7a", "0xc5", "0x6c", "0x9b", "0x7c", "0x7a", "0x5b", "0xbe", "0xb6", "0x51", "0xc0", "0x41", "0x99", "0x2e", "0x23", "0xc5", "0x72", "0x0b", "0xb1", "0x40", "0x00"}}, - { - /* No.940 delta:840 weight:1609 */ - 11213, - 84, - 13, - 4, - [16]uint32{0x00000000, 0xcad35095, 0xd32c50cc, 0x19ff0059, 0x8b103acf, 0x41c36a5a, 0x583c6a03, 0x92ef3a96, 0x0000bc0f, 0xcad3ec9a, 0xd32cecc3, 0x19ffbc56, 0x8b1086c0, 0x41c3d655, 0x583cd60c, 0x92ef8699}, - [16]uint32{0x00000000, 0x206ef075, 0x20198fdf, 0x00777faa, 0x00021108, 0x206ce17d, 0x201b9ed7, 0x00756ea2, 0x001c06a4, 0x2072f6d1, 0x2005897b, 0x006b790e, 0x001e17ac, 0x2070e7d9, 0x20079873, 0x00696806}, - [16]uint32{0x3f800000, 0x3f903778, 0x3f900cc7, 0x3f803bbf, 0x3f800108, 0x3f903670, 0x3f900dcf, 0x3f803ab7, 0x3f800e03, 0x3f90397b, 0x3f9002c4, 0x3f8035bc, 0x3f800f0b, 0x3f903873, 0x3f9003cc, 0x3f8034b4}, - uint32(0xfff80000), - [21]string{"0xfc", "0x1d", "0xb4", "0x6b", "0x37", "0x39", "0xe3", "0x8e", "0xbc", "0x8a", "0x2a", "0xea", "0x1c", "0x2e", "0xe5", "0x60", "0x43", "0x48", "0xab", "0x75", "0x00"}}, - { - /* No.941 delta:926 weight:1631 */ - 11213, - 41, - 13, - 4, - [16]uint32{0x00000000, 0x2a017785, 0xdc59f51d, 0xf6588298, 0x14103ad9, 0x3e114d5c, 0xc849cfc4, 0xe248b841, 0x0000c6db, 0x2a01b15e, 0xdc5933c6, 0xf6584443, 0x1410fc02, 0x3e118b87, 0xc849091f, 0xe2487e9a}, - [16]uint32{0x00000000, 0x402206ba, 0x104d10b4, 0x506f160e, 0x006760f3, 0x40456649, 0x102a7047, 0x500876fd, 0x0002401b, 0x402046a1, 0x104f50af, 0x506d5615, 0x006520e8, 0x40472652, 0x1028305c, 0x500a36e6}, - [16]uint32{0x3f800000, 0x3fa01103, 0x3f882688, 0x3fa8378b, 0x3f8033b0, 0x3fa022b3, 0x3f881538, 0x3fa8043b, 0x3f800120, 0x3fa01023, 0x3f8827a8, 0x3fa836ab, 0x3f803290, 0x3fa02393, 0x3f881418, 0x3fa8051b}, - uint32(0xfff80000), - [21]string{"0xdd", "0x0a", "0x49", "0xfa", "0x1e", "0x8c", "0xe0", "0xf9", "0x86", "0xf1", "0xa5", "0x70", "0x75", "0xa9", "0xf6", "0x7c", "0xb1", "0x87", "0x42", "0xd4", "0x00"}}, - { - /* No.942 delta:1159 weight:1167 */ - 11213, - 40, - 13, - 4, - [16]uint32{0x00000000, 0x69fb4557, 0x377450e0, 0x5e8f15b7, 0x69c03ae9, 0x003b7fbe, 0x5eb46a09, 0x374f2f5e, 0x0000d8b6, 0x69fb9de1, 0x37748856, 0x5e8fcd01, 0x69c0e25f, 0x003ba708, 0x5eb4b2bf, 0x374ff7e8}, - [16]uint32{0x00000000, 0x006c00d4, 0x4002e0bb, 0x406ee06f, 0x401071ec, 0x407c7138, 0x00129157, 0x007e9183, 0x0003701c, 0x006f70c8, 0x400190a7, 0x406d9073, 0x401301f0, 0x407f0124, 0x0011e14b, 0x007de19f}, - [16]uint32{0x3f800000, 0x3f803600, 0x3fa00170, 0x3fa03770, 0x3fa00838, 0x3fa03e38, 0x3f800948, 0x3f803f48, 0x3f8001b8, 0x3f8037b8, 0x3fa000c8, 0x3fa036c8, 0x3fa00980, 0x3fa03f80, 0x3f8008f0, 0x3f803ef0}, - uint32(0xfff80000), - [21]string{"0xb8", "0x40", "0xda", "0x5a", "0x09", "0x2d", "0xd6", "0xda", "0xa0", "0x2b", "0x8b", "0xa5", "0x40", "0x02", "0xe9", "0x8b", "0x07", "0x4a", "0x1d", "0x49", "0x00"}}, - { - /* No.943 delta:1597 weight:1677 */ - 11213, - 14, - 13, - 4, - [16]uint32{0x00000000, 0x14e9600c, 0xbabee6f3, 0xae5786ff, 0x7f403afc, 0x6ba95af0, 0xc5fedc0f, 0xd117bc03, 0x00003392, 0x14e9539e, 0xbabed561, 0xae57b56d, 0x7f40096e, 0x6ba96962, 0xc5feef9d, 0xd1178f91}, - [16]uint32{0x00000000, 0x0a008496, 0x040480c7, 0x0e040451, 0x010241ba, 0x0b02c52c, 0x0506c17d, 0x0f0645eb, 0x008a9002, 0x0a8a1494, 0x048e10c5, 0x0e8e9453, 0x0188d1b8, 0x0b88552e, 0x058c517f, 0x0f8cd5e9}, - [16]uint32{0x3f800000, 0x3f850042, 0x3f820240, 0x3f870202, 0x3f808120, 0x3f858162, 0x3f828360, 0x3f878322, 0x3f804548, 0x3f85450a, 0x3f824708, 0x3f87474a, 0x3f80c468, 0x3f85c42a, 0x3f82c628, 0x3f87c66a}, - uint32(0xfff80000), - [21]string{"0x97", "0x89", "0xa8", "0x4e", "0x5f", "0x71", "0x52", "0xbf", "0x93", "0xd6", "0x28", "0x77", "0x78", "0x47", "0xad", "0xc6", "0xd6", "0xd0", "0x3e", "0xd5", "0x00"}}, - { - /* No.944 delta:936 weight:1299 */ - 11213, - 72, - 13, - 4, - [16]uint32{0x00000000, 0x83ab720e, 0xf495de76, 0x773eac78, 0x92703b0a, 0x11db4904, 0x66e5e57c, 0xe54e9772, 0x00000aea, 0x83ab78e4, 0xf495d49c, 0x773ea692, 0x927031e0, 0x11db43ee, 0x66e5ef96, 0xe54e9d98}, - [16]uint32{0x00000000, 0x00094035, 0x004150b6, 0x00481083, 0x20220012, 0x202b4027, 0x206350a4, 0x206a1091, 0x1000101e, 0x1009502b, 0x104140a8, 0x1048009d, 0x3022100c, 0x302b5039, 0x306340ba, 0x306a008f}, - [16]uint32{0x3f800000, 0x3f8004a0, 0x3f8020a8, 0x3f802408, 0x3f901100, 0x3f9015a0, 0x3f9031a8, 0x3f903508, 0x3f880008, 0x3f8804a8, 0x3f8820a0, 0x3f882400, 0x3f981108, 0x3f9815a8, 0x3f9831a0, 0x3f983500}, - uint32(0xfff80000), - [21]string{"0xfd", "0x35", "0x0d", "0x23", "0x9b", "0xc6", "0x2b", "0xf2", "0x83", "0xb6", "0x66", "0x06", "0x09", "0x6e", "0x8e", "0x64", "0xb4", "0xe4", "0x89", "0x0c", "0x00"}}, - { - /* No.945 delta:1075 weight:1373 */ - 11213, - 32, - 13, - 4, - [16]uint32{0x00000000, 0xeac0da70, 0x951dd726, 0x7fdd0d56, 0x24e03b18, 0xce20e168, 0xb1fdec3e, 0x5b3d364e, 0x00005fca, 0xeac085ba, 0x951d88ec, 0x7fdd529c, 0x24e064d2, 0xce20bea2, 0xb1fdb3f4, 0x5b3d6984}, - [16]uint32{0x00000000, 0x1402dc95, 0x10006809, 0x0402b49c, 0x4000681a, 0x5402b48f, 0x50000013, 0x4402dc86, 0x0044382c, 0x1446e4b9, 0x10445025, 0x04468cb0, 0x40445036, 0x54468ca3, 0x5044383f, 0x4446e4aa}, - [16]uint32{0x3f800000, 0x3f8a016e, 0x3f880034, 0x3f82015a, 0x3fa00034, 0x3faa015a, 0x3fa80000, 0x3fa2016e, 0x3f80221c, 0x3f8a2372, 0x3f882228, 0x3f822346, 0x3fa02228, 0x3faa2346, 0x3fa8221c, 0x3fa22372}, - uint32(0xfff80000), - [21]string{"0xc5", "0x5f", "0x67", "0xeb", "0xdd", "0xeb", "0x9b", "0x73", "0x78", "0xf7", "0x20", "0x56", "0xe3", "0x22", "0xfd", "0x3d", "0x3b", "0x31", "0x1c", "0xcd", "0x00"}}, - { - /* No.946 delta:1219 weight:1611 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0xe814e250, 0xea9f56e4, 0x028bb4b4, 0x8bd03b2f, 0x63c4d97f, 0x614f6dcb, 0x895b8f9b, 0x00009c80, 0xe8147ed0, 0xea9fca64, 0x028b2834, 0x8bd0a7af, 0x63c445ff, 0x614ff14b, 0x895b131b}, - [16]uint32{0x00000000, 0x5066009a, 0x001a601d, 0x507c6087, 0x012846bf, 0x514e4625, 0x013226a2, 0x51542638, 0x40000404, 0x1066049e, 0x401a6419, 0x107c6483, 0x412842bb, 0x114e4221, 0x413222a6, 0x1154223c}, - [16]uint32{0x3f800000, 0x3fa83300, 0x3f800d30, 0x3fa83e30, 0x3f809423, 0x3fa8a723, 0x3f809913, 0x3fa8aa13, 0x3fa00002, 0x3f883302, 0x3fa00d32, 0x3f883e32, 0x3fa09421, 0x3f88a721, 0x3fa09911, 0x3f88aa11}, - uint32(0xfff80000), - [21]string{"0xe7", "0x20", "0x08", "0x62", "0x22", "0x96", "0x19", "0x05", "0xe3", "0x63", "0x10", "0x02", "0x56", "0x5d", "0xb5", "0x7e", "0x82", "0x37", "0xd5", "0x8d", "0x00"}}, - { - /* No.947 delta:930 weight:1221 */ - 11213, - 36, - 13, - 4, - [16]uint32{0x00000000, 0xc10af2ab, 0xa862f137, 0x6968039c, 0x3d503b35, 0xfc5ac99e, 0x9532ca02, 0x543838a9, 0x0000b8f0, 0xc10a4a5b, 0xa86249c7, 0x6968bb6c, 0x3d5083c5, 0xfc5a716e, 0x953272f2, 0x54388059}, - [16]uint32{0x00000000, 0x18002cb2, 0xc05c6099, 0xd85c4c2b, 0x50274017, 0x48276ca5, 0x907b208e, 0x887b0c3c, 0x00023091, 0x18021c23, 0xc05e5008, 0xd85e7cba, 0x50257086, 0x48255c34, 0x9079101f, 0x88793cad}, - [16]uint32{0x3f800000, 0x3f8c0016, 0x3fe02e30, 0x3fec2e26, 0x3fa813a0, 0x3fa413b6, 0x3fc83d90, 0x3fc43d86, 0x3f800118, 0x3f8c010e, 0x3fe02f28, 0x3fec2f3e, 0x3fa812b8, 0x3fa412ae, 0x3fc83c88, 0x3fc43c9e}, - uint32(0xfff80000), - [21]string{"0xa4", "0x47", "0x3f", "0x17", "0x81", "0x90", "0xf4", "0x5e", "0xfa", "0xc9", "0x42", "0x7d", "0xde", "0x74", "0x0d", "0x1d", "0xc7", "0xd7", "0x8d", "0x36", "0x00"}}, - { - /* No.948 delta:856 weight:1579 */ - 11213, - 82, - 13, - 4, - [16]uint32{0x00000000, 0xa0bd0c75, 0x788cd063, 0xd831dc16, 0x60d03b48, 0xc06d373d, 0x185ceb2b, 0xb8e1e75e, 0x0000647b, 0xa0bd680e, 0x788cb418, 0xd831b86d, 0x60d05f33, 0xc06d5346, 0x185c8f50, 0xb8e18325}, - [16]uint32{0x00000000, 0x2023891d, 0x00422427, 0x2061ad3a, 0x20016012, 0x0022e90f, 0x20434435, 0x0060cd28, 0x0001f013, 0x2022790e, 0x0043d434, 0x20605d29, 0x20009001, 0x0023191c, 0x2042b426, 0x00613d3b}, - [16]uint32{0x3f800000, 0x3f9011c4, 0x3f802112, 0x3f9030d6, 0x3f9000b0, 0x3f801174, 0x3f9021a2, 0x3f803066, 0x3f8000f8, 0x3f90113c, 0x3f8021ea, 0x3f90302e, 0x3f900048, 0x3f80118c, 0x3f90215a, 0x3f80309e}, - uint32(0xfff80000), - [21]string{"0xcd", "0x8f", "0x2a", "0x05", "0x56", "0xf2", "0x13", "0x22", "0x6c", "0xbf", "0x57", "0x10", "0xc4", "0x86", "0xf3", "0x20", "0xc2", "0xc3", "0xc6", "0xce", "0x00"}}, - { - /* No.949 delta:878 weight:1241 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xa54c68ba, 0x109b8788, 0xb5d7ef32, 0x77a03b57, 0xd2ec53ed, 0x673bbcdf, 0xc277d465, 0x0000dcdd, 0xa54cb467, 0x109b5b55, 0xb5d733ef, 0x77a0e78a, 0xd2ec8f30, 0x673b6002, 0xc27708b8}, - [16]uint32{0x00000000, 0x105c4212, 0x70024114, 0x605e0306, 0x200305a9, 0x305f47bb, 0x500144bd, 0x405d06af, 0x20020418, 0x305e460a, 0x5000450c, 0x405c071e, 0x000101b1, 0x105d43a3, 0x700340a5, 0x605f02b7}, - [16]uint32{0x3f800000, 0x3f882e21, 0x3fb80120, 0x3fb02f01, 0x3f900182, 0x3f982fa3, 0x3fa800a2, 0x3fa02e83, 0x3f900102, 0x3f982f23, 0x3fa80022, 0x3fa02e03, 0x3f800080, 0x3f882ea1, 0x3fb801a0, 0x3fb02f81}, - uint32(0xfff80000), - [21]string{"0xcd", "0x06", "0xad", "0x5c", "0x2d", "0xec", "0xc6", "0x31", "0x5f", "0x3b", "0x3c", "0xe8", "0xfa", "0xb0", "0xe8", "0xc9", "0xdf", "0x58", "0x53", "0xed", "0x00"}}, - { - /* No.950 delta:882 weight:1399 */ - 11213, - 79, - 13, - 4, - [16]uint32{0x00000000, 0x2f5cd4a4, 0x7948350c, 0x5614e1a8, 0x6a303b65, 0x456cefc1, 0x13780e69, 0x3c24dacd, 0x0000d9bb, 0x2f5c0d1f, 0x7948ecb7, 0x56143813, 0x6a30e2de, 0x456c367a, 0x1378d7d2, 0x3c240376}, - [16]uint32{0x00000000, 0x200e209a, 0x00520db5, 0x205c2d2f, 0x00001416, 0x200e348c, 0x005219a3, 0x205c3939, 0x40238401, 0x602da49b, 0x407189b4, 0x607fa92e, 0x40239017, 0x602db08d, 0x40719da2, 0x607fbd38}, - [16]uint32{0x3f800000, 0x3f900710, 0x3f802906, 0x3f902e16, 0x3f80000a, 0x3f90071a, 0x3f80290c, 0x3f902e1c, 0x3fa011c2, 0x3fb016d2, 0x3fa038c4, 0x3fb03fd4, 0x3fa011c8, 0x3fb016d8, 0x3fa038ce, 0x3fb03fde}, - uint32(0xfff80000), - [21]string{"0x14", "0xd0", "0x07", "0x41", "0x65", "0x1c", "0x64", "0x4a", "0x0c", "0x43", "0x6c", "0xe9", "0x7c", "0x51", "0x53", "0x2e", "0xd2", "0x00", "0x6e", "0xa4", "0x00"}}, - { - /* No.951 delta:1067 weight:1489 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0xc759983f, 0x2995e606, 0xeecc7e39, 0x88703b71, 0x4f29a34e, 0xa1e5dd77, 0x66bc4548, 0x0000ba9a, 0xc75922a5, 0x29955c9c, 0xeeccc4a3, 0x887081eb, 0x4f2919d4, 0xa1e567ed, 0x66bcffd2}, - [16]uint32{0x00000000, 0x881ccc5a, 0x10631194, 0x987fddce, 0x00024813, 0x881e8449, 0x10615987, 0x987d95dd, 0x20115e05, 0xa80d925f, 0x30724f91, 0xb86e83cb, 0x20131616, 0xa80fda4c, 0x30700782, 0xb86ccbd8}, - [16]uint32{0x3f800000, 0x3fc40e66, 0x3f883188, 0x3fcc3fee, 0x3f800124, 0x3fc40f42, 0x3f8830ac, 0x3fcc3eca, 0x3f9008af, 0x3fd406c9, 0x3f983927, 0x3fdc3741, 0x3f90098b, 0x3fd407ed, 0x3f983803, 0x3fdc3665}, - uint32(0xfff80000), - [21]string{"0x82", "0xc1", "0xae", "0x62", "0x4b", "0x46", "0xf4", "0x5b", "0x4f", "0xde", "0x1c", "0x03", "0xf5", "0x45", "0xc0", "0xf1", "0xeb", "0xd9", "0xfb", "0xa1", "0x00"}}, - { - /* No.952 delta:1981 weight:1575 */ - 11213, - 75, - 13, - 4, - [16]uint32{0x00000000, 0x3cfa56da, 0xfda3a2fc, 0xc159f426, 0xb2403b80, 0x8eba6d5a, 0x4fe3997c, 0x7319cfa6, 0x0000e3ab, 0x3cfab571, 0xfda34157, 0xc159178d, 0xb240d82b, 0x8eba8ef1, 0x4fe37ad7, 0x73192c0d}, - [16]uint32{0x00000000, 0x01640595, 0x0052005e, 0x013605cb, 0x00000189, 0x0164041c, 0x005201d7, 0x01360442, 0xc0820014, 0xc1e60581, 0xc0d0004a, 0xc1b405df, 0xc082019d, 0xc1e60408, 0xc0d001c3, 0xc1b40456}, - [16]uint32{0x3f800000, 0x3f80b202, 0x3f802900, 0x3f809b02, 0x3f800000, 0x3f80b202, 0x3f802900, 0x3f809b02, 0x3fe04100, 0x3fe0f302, 0x3fe06800, 0x3fe0da02, 0x3fe04100, 0x3fe0f302, 0x3fe06800, 0x3fe0da02}, - uint32(0xfff80000), - [21]string{"0x14", "0x5e", "0xff", "0x94", "0x14", "0x96", "0x13", "0x94", "0x6c", "0xb0", "0xe4", "0xd9", "0x23", "0x8a", "0x50", "0xad", "0x2f", "0x90", "0x11", "0x2d", "0x00"}}, - { - /* No.953 delta:937 weight:1093 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0xe3b50553, 0x263c7a97, 0xc5897fc4, 0x9d303b97, 0x7e853ec4, 0xbb0c4100, 0x58b94453, 0x00008b51, 0xe3b58e02, 0x263cf1c6, 0xc589f495, 0x9d30b0c6, 0x7e85b595, 0xbb0cca51, 0x58b9cf02}, - [16]uint32{0x00000000, 0x0068117e, 0x401401db, 0x407c10a5, 0x005485f4, 0x003c948a, 0x4040842f, 0x40289551, 0x00304081, 0x005851ff, 0x4024415a, 0x404c5024, 0x0064c575, 0x000cd40b, 0x4070c4ae, 0x4018d5d0}, - [16]uint32{0x3f800000, 0x3f803408, 0x3fa00a00, 0x3fa03e08, 0x3f802a42, 0x3f801e4a, 0x3fa02042, 0x3fa0144a, 0x3f801820, 0x3f802c28, 0x3fa01220, 0x3fa02628, 0x3f803262, 0x3f80066a, 0x3fa03862, 0x3fa00c6a}, - uint32(0xfff80000), - [21]string{"0x73", "0xc3", "0x78", "0x71", "0x90", "0xd6", "0xa2", "0xd7", "0x23", "0x48", "0xd2", "0x19", "0x05", "0x65", "0x86", "0x82", "0x36", "0x70", "0x97", "0x56", "0x00"}}, - { - /* No.954 delta:855 weight:707 */ - 11213, - 71, - 13, - 4, - [16]uint32{0x00000000, 0x53612589, 0x4c7bc33b, 0x1f1ae6b2, 0x63603ba9, 0x30011e20, 0x2f1bf892, 0x7c7add1b, 0x0000963b, 0x5361b3b2, 0x4c7b5500, 0x1f1a7089, 0x6360ad92, 0x3001881b, 0x2f1b6ea9, 0x7c7a4b20}, - [16]uint32{0x00000000, 0x806247d6, 0x102019f1, 0x90425e27, 0x10440055, 0x90264783, 0x006419a4, 0x80065e72, 0x001b020e, 0x807945d8, 0x103b1bff, 0x90595c29, 0x105f025b, 0x903d458d, 0x007f1baa, 0x801d5c7c}, - [16]uint32{0x3f800000, 0x3fc03123, 0x3f88100c, 0x3fc8212f, 0x3f882200, 0x3fc81323, 0x3f80320c, 0x3fc0032f, 0x3f800d81, 0x3fc03ca2, 0x3f881d8d, 0x3fc82cae, 0x3f882f81, 0x3fc81ea2, 0x3f803f8d, 0x3fc00eae}, - uint32(0xfff80000), - [21]string{"0xbe", "0xd1", "0x0f", "0x8e", "0x57", "0x0c", "0x66", "0x0c", "0x44", "0x94", "0x07", "0x09", "0x24", "0x16", "0xe6", "0x73", "0x92", "0xb0", "0x70", "0x75", "0x00"}}, - { - /* No.955 delta:843 weight:1195 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x43138caf, 0x48d56c1a, 0x0bc6e0b5, 0xd0103bb0, 0x9303b71f, 0x98c557aa, 0xdbd6db05, 0x00004cbd, 0x4313c012, 0x48d520a7, 0x0bc6ac08, 0xd010770d, 0x9303fba2, 0x98c51b17, 0xdbd697b8}, - [16]uint32{0x00000000, 0x0001815a, 0x206c91b1, 0x206d10eb, 0x14790c18, 0x14788d42, 0x34159da9, 0x34141cf3, 0x00207a1e, 0x0021fb44, 0x204cebaf, 0x204d6af5, 0x14597606, 0x1458f75c, 0x3435e7b7, 0x343466ed}, - [16]uint32{0x3f800000, 0x3f8000c0, 0x3f903648, 0x3f903688, 0x3f8a3c86, 0x3f8a3c46, 0x3f9a0ace, 0x3f9a0a0e, 0x3f80103d, 0x3f8010fd, 0x3f902675, 0x3f9026b5, 0x3f8a2cbb, 0x3f8a2c7b, 0x3f9a1af3, 0x3f9a1a33}, - uint32(0xfff80000), - [21]string{"0x9b", "0xf2", "0x0b", "0x07", "0x85", "0x79", "0x9a", "0xce", "0x3d", "0x95", "0x89", "0x3d", "0xec", "0xef", "0x79", "0x90", "0x73", "0x41", "0xdd", "0x75", "0x00"}}, - { - /* No.956 delta:823 weight:1597 */ - 11213, - 57, - 13, - 4, - [16]uint32{0x00000000, 0x9a3a3e3e, 0x1998b064, 0x83a28e5a, 0xb7d03bc0, 0x2dea05fe, 0xae488ba4, 0x3472b59a, 0x0000de24, 0x9a3ae01a, 0x19986e40, 0x83a2507e, 0xb7d0e5e4, 0x2deadbda, 0xae485580, 0x34726bbe}, - [16]uint32{0x00000000, 0x504f0557, 0x000282d1, 0x504d8786, 0x10024c83, 0x404d49d4, 0x1000ce52, 0x404fcb05, 0x1001401b, 0x404e454c, 0x1003c2ca, 0x404cc79d, 0x00030c98, 0x504c09cf, 0x00018e49, 0x504e8b1e}, - [16]uint32{0x3f800000, 0x3fa82782, 0x3f800141, 0x3fa826c3, 0x3f880126, 0x3fa026a4, 0x3f880067, 0x3fa027e5, 0x3f8800a0, 0x3fa02722, 0x3f8801e1, 0x3fa02663, 0x3f800186, 0x3fa82604, 0x3f8000c7, 0x3fa82745}, - uint32(0xfff80000), - [21]string{"0x5c", "0xae", "0xd3", "0x8b", "0x85", "0xb0", "0x7d", "0xbd", "0xb3", "0x66", "0x22", "0xae", "0x00", "0x60", "0xe9", "0x6d", "0x96", "0x41", "0xf3", "0x7f", "0x00"}}, - { - /* No.957 delta:949 weight:1775 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0x1ef8a728, 0x69eaf6ef, 0x771251c7, 0x5f303bdc, 0x41c89cf4, 0x36dacd33, 0x28226a1b, 0x000034e7, 0x1ef893cf, 0x69eac208, 0x77126520, 0x5f300f3b, 0x41c8a813, 0x36daf9d4, 0x28225efc}, - [16]uint32{0x00000000, 0x100624be, 0x00073de5, 0x1001195b, 0x00009006, 0x1006b4b8, 0x0007ade3, 0x1001895d, 0x3045d012, 0x2043f4ac, 0x3042edf7, 0x2044c949, 0x30454014, 0x204364aa, 0x30427df1, 0x2044594f}, - [16]uint32{0x3f800000, 0x3f880312, 0x3f80039e, 0x3f88008c, 0x3f800048, 0x3f88035a, 0x3f8003d6, 0x3f8800c4, 0x3f9822e8, 0x3f9021fa, 0x3f982176, 0x3f902264, 0x3f9822a0, 0x3f9021b2, 0x3f98213e, 0x3f90222c}, - uint32(0xfff80000), - [21]string{"0x85", "0xa2", "0xfd", "0xa8", "0xcb", "0x55", "0xdb", "0xdb", "0x8c", "0x5d", "0x4a", "0xa2", "0x67", "0x5a", "0x5c", "0xe2", "0x5d", "0x77", "0x42", "0x2c", "0x00"}}, - { - /* No.958 delta:790 weight:1737 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xde2c6294, 0xa751bc81, 0x797dde15, 0x99803bed, 0x47ac5979, 0x3ed1876c, 0xe0fde5f8, 0x0000ecb6, 0xde2c8e22, 0xa7515037, 0x797d32a3, 0x9980d75b, 0x47acb5cf, 0x3ed16bda, 0xe0fd094e}, - [16]uint32{0x00000000, 0x08044116, 0x60025871, 0x68061967, 0x100109fd, 0x180548eb, 0x7003518c, 0x7807109a, 0x600160cd, 0x680521db, 0x000338bc, 0x080779aa, 0x70006930, 0x78042826, 0x10023141, 0x18067057}, - [16]uint32{0x3f800000, 0x3f840220, 0x3fb0012c, 0x3fb4030c, 0x3f880084, 0x3f8c02a4, 0x3fb801a8, 0x3fbc0388, 0x3fb000b0, 0x3fb40290, 0x3f80019c, 0x3f8403bc, 0x3fb80034, 0x3fbc0214, 0x3f880118, 0x3f8c0338}, - uint32(0xfff80000), - [21]string{"0x6e", "0xf4", "0x6e", "0x9e", "0xa9", "0x43", "0x31", "0x8e", "0xcd", "0xb9", "0xa9", "0x99", "0xa5", "0x2a", "0x29", "0xac", "0xb7", "0x15", "0x1b", "0x8e", "0x00"}}, - { - /* No.959 delta:1603 weight:1701 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0xb116b958, 0xed3a2360, 0x5c2c9a38, 0xbdb03bfc, 0x0ca682a4, 0x508a189c, 0xe19ca1c4, 0x00001cae, 0xb116a5f6, 0xed3a3fce, 0x5c2c8696, 0xbdb02752, 0x0ca69e0a, 0x508a0432, 0xe19cbd6a}, - [16]uint32{0x00000000, 0x006d8195, 0x20308107, 0x205d0092, 0x001200af, 0x007f813a, 0x202281a8, 0x204f003d, 0x308a801c, 0x30e70189, 0x10ba011b, 0x10d7808e, 0x309880b3, 0x30f50126, 0x10a801b4, 0x10c58021}, - [16]uint32{0x3f800000, 0x3f8036c0, 0x3f901840, 0x3f902e80, 0x3f800900, 0x3f803fc0, 0x3f901140, 0x3f902780, 0x3f984540, 0x3f987380, 0x3f885d00, 0x3f886bc0, 0x3f984c40, 0x3f987a80, 0x3f885400, 0x3f8862c0}, - uint32(0xfff80000), - [21]string{"0xde", "0x4c", "0xc3", "0x71", "0x96", "0x2c", "0xa8", "0x4a", "0x11", "0x7e", "0x09", "0x07", "0xd3", "0x6c", "0x3e", "0x22", "0x12", "0x27", "0xd5", "0xfb", "0x00"}}, - { - /* No.960 delta:962 weight:1181 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x823e01ff, 0x925c2d85, 0x10622c7a, 0x90c03c02, 0x12fe3dfd, 0x029c1187, 0x80a21078, 0x00000d8d, 0x823e0c72, 0x925c2008, 0x106221f7, 0x90c0318f, 0x12fe3070, 0x029c1c0a, 0x80a21df5}, - [16]uint32{0x00000000, 0x0805895a, 0x6018386b, 0x681db131, 0x00560016, 0x0853894c, 0x604e387d, 0x684bb127, 0x00022ce8, 0x0807a5b2, 0x601a1483, 0x681f9dd9, 0x00542cfe, 0x0851a5a4, 0x604c1495, 0x68499dcf}, - [16]uint32{0x3f800000, 0x3f8402c4, 0x3fb00c1c, 0x3fb40ed8, 0x3f802b00, 0x3f8429c4, 0x3fb0271c, 0x3fb425d8, 0x3f800116, 0x3f8403d2, 0x3fb00d0a, 0x3fb40fce, 0x3f802a16, 0x3f8428d2, 0x3fb0260a, 0x3fb424ce}, - uint32(0xfff80000), - [21]string{"0x61", "0x11", "0xd7", "0x89", "0x88", "0x7f", "0x4a", "0x3e", "0xac", "0xd5", "0xe8", "0x18", "0x88", "0xa7", "0xb8", "0x27", "0xad", "0x2b", "0x4e", "0xba", "0x00"}}, - { - /* No.961 delta:1479 weight:1125 */ - 11213, - 87, - 13, - 4, - [16]uint32{0x00000000, 0x7ef1fb89, 0x0a91c798, 0x74603c11, 0xc5303c19, 0xbbc1c790, 0xcfa1fb81, 0xb1500008, 0x0000a9c9, 0x7ef15240, 0x0a916e51, 0x746095d8, 0xc53095d0, 0xbbc16e59, 0xcfa15248, 0xb150a9c1}, - [16]uint32{0x00000000, 0x004620b7, 0x10320034, 0x10742083, 0x000a013b, 0x004c218c, 0x1038010f, 0x107e21b8, 0x1048007c, 0x100e20cb, 0x007a0048, 0x003c20ff, 0x10420147, 0x100421f0, 0x00700173, 0x003621c4}, - [16]uint32{0x3f800000, 0x3f802310, 0x3f881900, 0x3f883a10, 0x3f800500, 0x3f802610, 0x3f881c00, 0x3f883f10, 0x3f882400, 0x3f880710, 0x3f803d00, 0x3f801e10, 0x3f882100, 0x3f880210, 0x3f803800, 0x3f801b10}, - uint32(0xfff80000), - [21]string{"0xca", "0x42", "0xd2", "0x86", "0x08", "0xd3", "0xfc", "0x7d", "0x3c", "0x6a", "0x59", "0x33", "0xae", "0x51", "0x75", "0x8a", "0xcd", "0x11", "0xa6", "0x40", "0x00"}}, - { - /* No.962 delta:880 weight:1671 */ - 11213, - 42, - 13, - 4, - [16]uint32{0x00000000, 0x8e08dc8f, 0x37744984, 0xb97c950b, 0x21403c20, 0xaf48e0af, 0x163475a4, 0x983ca92b, 0x0000bbb1, 0x8e08673e, 0x3774f235, 0xb97c2eba, 0x21408791, 0xaf485b1e, 0x1634ce15, 0x983c129a}, - [16]uint32{0x00000000, 0x022615fa, 0x600240f6, 0x6224550c, 0x40018c01, 0x422799fb, 0x2003ccf7, 0x2225d90d, 0x20022804, 0x22243dfe, 0x400068f2, 0x42267d08, 0x6003a405, 0x6225b1ff, 0x0001e4f3, 0x0227f109}, - [16]uint32{0x3f800000, 0x3f81130a, 0x3fb00120, 0x3fb1122a, 0x3fa000c6, 0x3fa113cc, 0x3f9001e6, 0x3f9112ec, 0x3f900114, 0x3f91121e, 0x3fa00034, 0x3fa1133e, 0x3fb001d2, 0x3fb112d8, 0x3f8000f2, 0x3f8113f8}, - uint32(0xfff80000), - [21]string{"0x96", "0xde", "0x53", "0x85", "0xea", "0x53", "0xe5", "0xd2", "0x64", "0xfb", "0x05", "0x44", "0x38", "0x5f", "0x5d", "0x2b", "0x3f", "0xb7", "0x03", "0x99", "0x00"}}, - { - /* No.963 delta:1120 weight:1363 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0x77376ab2, 0x0e4e8b2e, 0x7979e19c, 0x5f403c36, 0x28775684, 0x510eb718, 0x2639ddaa, 0x0000c86c, 0x7737a2de, 0x0e4e4342, 0x797929f0, 0x5f40f45a, 0x28779ee8, 0x510e7f74, 0x263915c6}, - [16]uint32{0x00000000, 0x10c4b09d, 0x00716983, 0x10b5d91e, 0x001e540f, 0x10dae492, 0x006f3d8c, 0x10ab8d11, 0x00020607, 0x10c6b69a, 0x00736f84, 0x10b7df19, 0x001c5208, 0x10d8e295, 0x006d3b8b, 0x10a98b16}, - [16]uint32{0x3f800000, 0x3f886258, 0x3f8038b4, 0x3f885aec, 0x3f800f2a, 0x3f886d72, 0x3f80379e, 0x3f8855c6, 0x3f800103, 0x3f88635b, 0x3f8039b7, 0x3f885bef, 0x3f800e29, 0x3f886c71, 0x3f80369d, 0x3f8854c5}, - uint32(0xfff80000), - [21]string{"0x12", "0x77", "0xab", "0x09", "0xb7", "0x3d", "0x56", "0xb0", "0x95", "0x43", "0x6b", "0xf4", "0x98", "0x8b", "0x96", "0xae", "0x55", "0xca", "0xf2", "0x93", "0x00"}}, - { - /* No.964 delta:1539 weight:1665 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x7d52994e, 0x10f7783f, 0x6da5e171, 0x79303c47, 0x0462a509, 0x69c74478, 0x1495dd36, 0x0000d21c, 0x7d524b52, 0x10f7aa23, 0x6da5336d, 0x7930ee5b, 0x04627715, 0x69c79664, 0x14950f2a}, - [16]uint32{0x00000000, 0x483440d6, 0x0053119f, 0x48675149, 0x007e01b8, 0x484a416e, 0x002d1027, 0x481950f1, 0x00220014, 0x481640c2, 0x0071118b, 0x4845515d, 0x005c01ac, 0x4868417a, 0x000f1033, 0x483b50e5}, - [16]uint32{0x3f800000, 0x3fa41a20, 0x3f802988, 0x3fa433a8, 0x3f803f00, 0x3fa42520, 0x3f801688, 0x3fa40ca8, 0x3f801100, 0x3fa40b20, 0x3f803888, 0x3fa422a8, 0x3f802e00, 0x3fa43420, 0x3f800788, 0x3fa41da8}, - uint32(0xfff80000), - [21]string{"0x2d", "0xf0", "0xbd", "0x5d", "0x6c", "0x39", "0x6c", "0xb0", "0xcf", "0x9a", "0x8a", "0x8d", "0xee", "0x8d", "0x24", "0x7a", "0x49", "0xf6", "0xcd", "0xfa", "0x00"}}, - { - /* No.965 delta:957 weight:1649 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0xeb14b79a, 0xdcae4b55, 0x37bafccf, 0xf5303c51, 0x1e248bcb, 0x299e7704, 0xc28ac09e, 0x000028d2, 0xeb149f48, 0xdcae6387, 0x37bad41d, 0xf5301483, 0x1e24a319, 0x299e5fd6, 0xc28ae84c}, - [16]uint32{0x00000000, 0x017428fe, 0x004bc17c, 0x013fe982, 0x100e1068, 0x117a3896, 0x1045d114, 0x1131f9ea, 0x0003a017, 0x017788e9, 0x0048616b, 0x013c4995, 0x100db07f, 0x11799881, 0x10467103, 0x113259fd}, - [16]uint32{0x3f800000, 0x3f80ba14, 0x3f8025e0, 0x3f809ff4, 0x3f880708, 0x3f88bd1c, 0x3f8822e8, 0x3f8898fc, 0x3f8001d0, 0x3f80bbc4, 0x3f802430, 0x3f809e24, 0x3f8806d8, 0x3f88bccc, 0x3f882338, 0x3f88992c}, - uint32(0xfff80000), - [21]string{"0x97", "0x63", "0x6b", "0xac", "0x42", "0xef", "0xde", "0x76", "0x95", "0x50", "0x98", "0x93", "0xa0", "0x18", "0x57", "0x6e", "0xdf", "0x2e", "0xc3", "0xd1", "0x00"}}, - { - /* No.966 delta:837 weight:881 */ - 11213, - 59, - 13, - 4, - [16]uint32{0x00000000, 0x4181301b, 0x9b3e09fc, 0xdabf39e7, 0x84503c6d, 0xc5d10c76, 0x1f6e3591, 0x5eef058a, 0x00006d07, 0x41815d1c, 0x9b3e64fb, 0xdabf54e0, 0x8450516a, 0xc5d16171, 0x1f6e5896, 0x5eef688d}, - [16]uint32{0x00000000, 0x000775f2, 0x411944b1, 0x411e3143, 0x0002446c, 0x0005319e, 0x411b00dd, 0x411c752f, 0x704281ca, 0x7045f438, 0x315bc57b, 0x315cb089, 0x7040c5a6, 0x7047b054, 0x31598117, 0x315ef4e5}, - [16]uint32{0x3f800000, 0x3f8003ba, 0x3fa08ca2, 0x3fa08f18, 0x3f800122, 0x3f800298, 0x3fa08d80, 0x3fa08e3a, 0x3fb82140, 0x3fb822fa, 0x3f98ade2, 0x3f98ae58, 0x3fb82062, 0x3fb823d8, 0x3f98acc0, 0x3f98af7a}, - uint32(0xfff80000), - [21]string{"0x1a", "0x99", "0xbe", "0x6a", "0xe1", "0x67", "0x72", "0x53", "0x69", "0xe6", "0x91", "0xbd", "0x09", "0x6a", "0x9c", "0x88", "0x5b", "0xc4", "0x75", "0x61", "0x00"}}, - { - /* No.967 delta:1449 weight:1463 */ - 11213, - 65, - 13, - 4, - [16]uint32{0x00000000, 0x374eb8dd, 0x89560b74, 0xbe18b3a9, 0xbf603c7f, 0x882e84a2, 0x3636370b, 0x01788fd6, 0x00003e9d, 0x374e8640, 0x895635e9, 0xbe188d34, 0xbf6002e2, 0x882eba3f, 0x36360996, 0x0178b14b}, - [16]uint32{0x00000000, 0x205d815f, 0x0043e06e, 0x201e6131, 0x0002406a, 0x205fc135, 0x0041a004, 0x201c215b, 0x00024019, 0x205fc146, 0x0041a077, 0x201c2128, 0x00000073, 0x205d812c, 0x0043e01d, 0x201e6142}, - [16]uint32{0x3f800000, 0x3f902ec0, 0x3f8021f0, 0x3f900f30, 0x3f800120, 0x3f902fe0, 0x3f8020d0, 0x3f900e10, 0x3f800120, 0x3f902fe0, 0x3f8020d0, 0x3f900e10, 0x3f800000, 0x3f902ec0, 0x3f8021f0, 0x3f900f30}, - uint32(0xfff80000), - [21]string{"0x87", "0x0c", "0xb2", "0x9e", "0xdc", "0x03", "0x0d", "0x67", "0x39", "0x70", "0x45", "0x6b", "0xa8", "0x37", "0x6d", "0x4d", "0x3c", "0x07", "0x5d", "0x6f", "0x00"}}, - { - /* No.968 delta:1109 weight:1487 */ - 11213, - 31, - 13, - 4, - [16]uint32{0x00000000, 0x57a9d15f, 0xef4a74c4, 0xb8e3a59b, 0xcaf03c8e, 0x9d59edd1, 0x25ba484a, 0x72139915, 0x00005df9, 0x57a98ca6, 0xef4a293d, 0xb8e3f862, 0xcaf06177, 0x9d59b028, 0x25ba15b3, 0x7213c4ec}, - [16]uint32{0x00000000, 0x00781212, 0x00464e0e, 0x003e5c1c, 0x00044a1a, 0x007c5808, 0x00420414, 0x003a1606, 0x3f6042a3, 0x3f1850b1, 0x3f260cad, 0x3f5e1ebf, 0x3f6408b9, 0x3f1c1aab, 0x3f2246b7, 0x3f5a54a5}, - [16]uint32{0x3f800000, 0x3f803c09, 0x3f802327, 0x3f801f2e, 0x3f800225, 0x3f803e2c, 0x3f802102, 0x3f801d0b, 0x3f9fb021, 0x3f9f8c28, 0x3f9f9306, 0x3f9faf0f, 0x3f9fb204, 0x3f9f8e0d, 0x3f9f9123, 0x3f9fad2a}, - uint32(0xfff80000), - [21]string{"0x3a", "0xb2", "0x32", "0xbb", "0xfe", "0xf7", "0x77", "0xd5", "0x68", "0xf3", "0x62", "0x3d", "0x57", "0x36", "0x20", "0x51", "0x2d", "0xe5", "0x70", "0x47", "0x00"}}, - { - /* No.969 delta:887 weight:1615 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0xf43cab70, 0xd58f3045, 0x21b39b35, 0x73403c9a, 0x877c97ea, 0xa6cf0cdf, 0x52f3a7af, 0x00008ec2, 0xf43c25b2, 0xd58fbe87, 0x21b315f7, 0x7340b258, 0x877c1928, 0xa6cf821d, 0x52f3296d}, - [16]uint32{0x00000000, 0x402c4092, 0x006d57bc, 0x4041172e, 0x0010c60a, 0x403c8698, 0x007d91b6, 0x4051d124, 0x020141cb, 0x422d0159, 0x026c1677, 0x424056e5, 0x021187c1, 0x423dc753, 0x027cd07d, 0x425090ef}, - [16]uint32{0x3f800000, 0x3fa01620, 0x3f8036ab, 0x3fa0208b, 0x3f800863, 0x3fa01e43, 0x3f803ec8, 0x3fa028e8, 0x3f8100a0, 0x3fa11680, 0x3f81360b, 0x3fa1202b, 0x3f8108c3, 0x3fa11ee3, 0x3f813e68, 0x3fa12848}, - uint32(0xfff80000), - [21]string{"0x96", "0xc8", "0xaa", "0xf4", "0x82", "0xc6", "0xf9", "0xbc", "0xfd", "0x82", "0x6b", "0x79", "0xbe", "0x32", "0xb9", "0x0c", "0xe8", "0x45", "0xbe", "0x78", "0x00"}}, - { - /* No.970 delta:1059 weight:1539 */ - 11213, - 27, - 13, - 4, - [16]uint32{0x00000000, 0x6571b6e5, 0xefc43754, 0x8ab581b1, 0x2b203ca8, 0x4e518a4d, 0xc4e40bfc, 0xa195bd19, 0x00001fa9, 0x6571a94c, 0xefc428fd, 0x8ab59e18, 0x2b202301, 0x4e5195e4, 0xc4e41455, 0xa195a2b0}, - [16]uint32{0x00000000, 0x010300be, 0x40800b09, 0x41830bb7, 0x7080c015, 0x7183c0ab, 0x3000cb1c, 0x3103cba2, 0x90000387, 0x91030339, 0xd080088e, 0xd1830830, 0xe080c392, 0xe183c32c, 0xa000c89b, 0xa103c825}, - [16]uint32{0x3f800000, 0x3f808180, 0x3fa04005, 0x3fa0c185, 0x3fb84060, 0x3fb8c1e0, 0x3f980065, 0x3f9881e5, 0x3fc80001, 0x3fc88181, 0x3fe84004, 0x3fe8c184, 0x3ff04061, 0x3ff0c1e1, 0x3fd00064, 0x3fd081e4}, - uint32(0xfff80000), - [21]string{"0x54", "0x40", "0x2c", "0xe4", "0x8e", "0x0d", "0x36", "0x5e", "0xdc", "0xe7", "0x18", "0xcd", "0xbf", "0xc2", "0x39", "0x54", "0xc0", "0xc3", "0x15", "0x70", "0x00"}}, - { - /* No.971 delta:851 weight:1597 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x8800f040, 0x0be6faea, 0x83e60aaa, 0x00e03cb7, 0x88e0ccf7, 0x0b06c65d, 0x8306361d, 0x00007105, 0x88008145, 0x0be68bef, 0x83e67baf, 0x00e04db2, 0x88e0bdf2, 0x0b06b758, 0x83064718}, - [16]uint32{0x00000000, 0x507d197a, 0x0003280c, 0x507e3176, 0x0053300f, 0x502e2975, 0x00501803, 0x502d0179, 0x10007013, 0x407d6969, 0x1003581f, 0x407e4165, 0x1053401c, 0x402e5966, 0x10506810, 0x402d716a}, - [16]uint32{0x3f800000, 0x3fa83e8c, 0x3f800194, 0x3fa83f18, 0x3f802998, 0x3fa81714, 0x3f80280c, 0x3fa81680, 0x3f880038, 0x3fa03eb4, 0x3f8801ac, 0x3fa03f20, 0x3f8829a0, 0x3fa0172c, 0x3f882834, 0x3fa016b8}, - uint32(0xfff80000), - [21]string{"0xa3", "0x55", "0x1b", "0x41", "0x34", "0xc6", "0xcd", "0xb7", "0xd7", "0x9e", "0x95", "0xd2", "0xf2", "0xdc", "0xd4", "0xee", "0x99", "0x5e", "0x4a", "0x2f", "0x00"}}, - { - /* No.972 delta:1719 weight:1453 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0x03e1bd8f, 0xcb9e2ef1, 0xc87f937e, 0x46303cc0, 0x45d1814f, 0x8dae1231, 0x8e4fafbe, 0x0000516d, 0x03e1ece2, 0xcb9e7f9c, 0xc87fc213, 0x46306dad, 0x45d1d022, 0x8dae435c, 0x8e4ffed3}, - [16]uint32{0x00000000, 0x006c80ba, 0x001000c7, 0x007c807d, 0x00020036, 0x006e808c, 0x001200f1, 0x007e804b, 0x2400001e, 0x246c80a4, 0x241000d9, 0x247c8063, 0x24020028, 0x246e8092, 0x241200ef, 0x247e8055}, - [16]uint32{0x3f800000, 0x3f803640, 0x3f800800, 0x3f803e40, 0x3f800100, 0x3f803740, 0x3f800900, 0x3f803f40, 0x3f920000, 0x3f923640, 0x3f920800, 0x3f923e40, 0x3f920100, 0x3f923740, 0x3f920900, 0x3f923f40}, - uint32(0xfff80000), - [21]string{"0x4f", "0xcf", "0x7a", "0x57", "0xd6", "0xb7", "0x5b", "0x2c", "0xef", "0x78", "0x72", "0x23", "0x47", "0x2c", "0xa1", "0xd1", "0x7f", "0x2a", "0xec", "0x6c", "0x00"}}, - { - /* No.973 delta:1474 weight:1681 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0x306cafe8, 0xade74fdc, 0x9d8be034, 0xd0603cd5, 0xe00c933d, 0x7d877309, 0x4debdce1, 0x0000765d, 0x306cd9b5, 0xade73981, 0x9d8b9669, 0xd0604a88, 0xe00ce560, 0x7d870554, 0x4debaabc}, - [16]uint32{0x00000000, 0x1070b952, 0x500f2c0c, 0x407f955e, 0x40022419, 0x50729d4b, 0x100d0815, 0x007db147, 0x00020803, 0x1072b151, 0x500d240f, 0x407d9d5d, 0x40002c1a, 0x50709548, 0x100f0016, 0x007fb944}, - [16]uint32{0x3f800000, 0x3f88385c, 0x3fa80796, 0x3fa03fca, 0x3fa00112, 0x3fa8394e, 0x3f880684, 0x3f803ed8, 0x3f800104, 0x3f883958, 0x3fa80692, 0x3fa03ece, 0x3fa00016, 0x3fa8384a, 0x3f880780, 0x3f803fdc}, - uint32(0xfff80000), - [21]string{"0x7f", "0x46", "0x86", "0x32", "0x93", "0x96", "0xf0", "0x4e", "0xd5", "0xc4", "0x89", "0x88", "0x70", "0x99", "0xce", "0xdd", "0x87", "0xe5", "0xf9", "0x54", "0x00"}}, - { - /* No.974 delta:1233 weight:1681 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x94442f37, 0xe8387743, 0x7c7c5874, 0x25b03ce0, 0xb1f413d7, 0xcd884ba3, 0x59cc6494, 0x00001976, 0x94443641, 0xe8386e35, 0x7c7c4102, 0x25b02596, 0xb1f40aa1, 0xcd8852d5, 0x59cc7de2}, - [16]uint32{0x00000000, 0x10020172, 0x6011448d, 0x701345ff, 0x00472011, 0x10452163, 0x6056649c, 0x705465ee, 0x4015020c, 0x5017037e, 0x20044681, 0x300647f3, 0x4052221d, 0x5050236f, 0x20436690, 0x304167e2}, - [16]uint32{0x3f800000, 0x3f880100, 0x3fb008a2, 0x3fb809a2, 0x3f802390, 0x3f882290, 0x3fb02b32, 0x3fb82a32, 0x3fa00a81, 0x3fa80b81, 0x3f900223, 0x3f980323, 0x3fa02911, 0x3fa82811, 0x3f9021b3, 0x3f9820b3}, - uint32(0xfff80000), - [21]string{"0xb9", "0x83", "0xa5", "0x9e", "0xf4", "0x9d", "0x91", "0x78", "0xe5", "0xda", "0x65", "0xc5", "0xef", "0xeb", "0x86", "0x2d", "0x97", "0xe2", "0x83", "0xdc", "0x00"}}, - { - /* No.975 delta:761 weight:1603 */ - 11213, - 61, - 13, - 4, - [16]uint32{0x00000000, 0x3b4f9cba, 0x8d675d9d, 0xb628c127, 0xdb303cf1, 0xe07fa04b, 0x5657616c, 0x6d18fdd6, 0x00007e3f, 0x3b4fe285, 0x8d6723a2, 0xb628bf18, 0xdb3042ce, 0xe07fde74, 0x56571f53, 0x6d1883e9}, - [16]uint32{0x00000000, 0x40a6185e, 0x4004660f, 0x00a27e51, 0x3042801b, 0x70e49845, 0x7046e614, 0x30e0fe4a, 0x0002c068, 0x40a4d836, 0x4006a667, 0x00a0be39, 0x30404073, 0x70e6582d, 0x7044267c, 0x30e23e22}, - [16]uint32{0x3f800000, 0x3fa0530c, 0x3fa00233, 0x3f80513f, 0x3f982140, 0x3fb8724c, 0x3fb82373, 0x3f98707f, 0x3f800160, 0x3fa0526c, 0x3fa00353, 0x3f80505f, 0x3f982020, 0x3fb8732c, 0x3fb82213, 0x3f98711f}, - uint32(0xfff80000), - [21]string{"0x6e", "0x07", "0x0d", "0xd1", "0x7b", "0xf1", "0xea", "0x65", "0xa5", "0x15", "0xff", "0x2d", "0x12", "0x1b", "0x9e", "0x7e", "0xdf", "0x47", "0x6c", "0x65", "0x00"}}, - { - /* No.976 delta:1015 weight:1371 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xcf601c93, 0x909e446d, 0x5ffe58fe, 0xb3403d00, 0x7c202193, 0x23de796d, 0xecbe65fe, 0x0000642b, 0xcf6078b8, 0x909e2046, 0x5ffe3cd5, 0xb340592b, 0x7c2045b8, 0x23de1d46, 0xecbe01d5}, - [16]uint32{0x00000000, 0x1802833a, 0x20031037, 0x3801930d, 0x0080912c, 0x18821216, 0x2083811b, 0x38810221, 0x60044152, 0x7806c268, 0x40075165, 0x5805d25f, 0x6084d07e, 0x78865344, 0x4087c049, 0x58854373}, - [16]uint32{0x3f800000, 0x3f8c0141, 0x3f900188, 0x3f9c00c9, 0x3f804048, 0x3f8c4109, 0x3f9041c0, 0x3f9c4081, 0x3fb00220, 0x3fbc0361, 0x3fa003a8, 0x3fac02e9, 0x3fb04268, 0x3fbc4329, 0x3fa043e0, 0x3fac42a1}, - uint32(0xfff80000), - [21]string{"0x23", "0xd9", "0x56", "0x98", "0xd4", "0xd8", "0x78", "0x06", "0x14", "0xdf", "0x48", "0xf6", "0x02", "0x67", "0xe6", "0x90", "0x5f", "0x78", "0x93", "0x2a", "0x00"}}, - { - /* No.977 delta:1037 weight:1371 */ - 11213, - 33, - 13, - 4, - [16]uint32{0x00000000, 0xf0d58dae, 0xf04fb78c, 0x009a3a22, 0xe6003d17, 0x16d5b0b9, 0x164f8a9b, 0xe69a0735, 0x00009310, 0xf0d51ebe, 0xf04f249c, 0x009aa932, 0xe600ae07, 0x16d523a9, 0x164f198b, 0xe69a9425}, - [16]uint32{0x00000000, 0x081229fa, 0xa06e31ec, 0xa87c1816, 0x20022a7f, 0x28100385, 0x806c1b93, 0x887e3269, 0x0002e81b, 0x0810c1e1, 0xa06cd9f7, 0xa87ef00d, 0x2000c264, 0x2812eb9e, 0x806ef388, 0x887cda72}, - [16]uint32{0x3f800000, 0x3f840914, 0x3fd03718, 0x3fd43e0c, 0x3f900115, 0x3f940801, 0x3fc0360d, 0x3fc43f19, 0x3f800174, 0x3f840860, 0x3fd0366c, 0x3fd43f78, 0x3f900061, 0x3f940975, 0x3fc03779, 0x3fc43e6d}, - uint32(0xfff80000), - [21]string{"0x75", "0x00", "0x5d", "0xc8", "0xc9", "0x7e", "0x25", "0x74", "0xa3", "0x2d", "0x79", "0xe6", "0x5e", "0x58", "0xfd", "0x98", "0x29", "0xb1", "0xf2", "0x72", "0x00"}}, - { - /* No.978 delta:840 weight:1675 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xf880e01d, 0x562b0c44, 0xaeabec59, 0x80103d25, 0x7890dd38, 0xd63b3161, 0x2ebbd17c, 0x00002fba, 0xf880cfa7, 0x562b23fe, 0xaeabc3e3, 0x8010129f, 0x7890f282, 0xd63b1edb, 0x2ebbfec6}, - [16]uint32{0x00000000, 0x2074199f, 0x400308d1, 0x6077114e, 0x4000f085, 0x6074e91a, 0x0003f854, 0x2077e1cb, 0x0000198c, 0x20740013, 0x4003115d, 0x607708c2, 0x4000e909, 0x6074f096, 0x0003e1d8, 0x2077f847}, - [16]uint32{0x3f800000, 0x3f903a0c, 0x3fa00184, 0x3fb03b88, 0x3fa00078, 0x3fb03a74, 0x3f8001fc, 0x3f903bf0, 0x3f80000c, 0x3f903a00, 0x3fa00188, 0x3fb03b84, 0x3fa00074, 0x3fb03a78, 0x3f8001f0, 0x3f903bfc}, - uint32(0xfff80000), - [21]string{"0x39", "0xe6", "0x16", "0xed", "0x3c", "0x54", "0x79", "0xcf", "0xa5", "0x66", "0xf2", "0xc0", "0x54", "0x55", "0x13", "0xb5", "0xb9", "0xe7", "0x3a", "0xe2", "0x00"}}, - { - /* No.979 delta:634 weight:1577 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0x4c83783a, 0x955526c4, 0xd9d65efe, 0xca403d37, 0x86c3450d, 0x5f151bf3, 0x139663c9, 0x00002cd1, 0x4c8354eb, 0x95550a15, 0xd9d6722f, 0xca4011e6, 0x86c369dc, 0x5f153722, 0x13964f18}, - [16]uint32{0x00000000, 0x007d007d, 0x4001fa13, 0x407cfa6e, 0x10010419, 0x107c0464, 0x5000fe0a, 0x507dfe77, 0x900c11b6, 0x907111cb, 0xd00deba5, 0xd070ebd8, 0x800d15af, 0x807015d2, 0xc00cefbc, 0xc071efc1}, - [16]uint32{0x3f800000, 0x3f803e80, 0x3fa000fd, 0x3fa03e7d, 0x3f880082, 0x3f883e02, 0x3fa8007f, 0x3fa83eff, 0x3fc80608, 0x3fc83888, 0x3fe806f5, 0x3fe83875, 0x3fc0068a, 0x3fc0380a, 0x3fe00677, 0x3fe038f7}, - uint32(0xfff80000), - [21]string{"0xb1", "0x74", "0xe8", "0x25", "0x8d", "0xb3", "0x12", "0x64", "0xd4", "0x84", "0xdb", "0x2a", "0x1c", "0xcb", "0x24", "0xa8", "0xf3", "0x75", "0xc1", "0x85", "0x00"}}, - { - /* No.980 delta:1683 weight:1733 */ - 11213, - 43, - 13, - 4, - [16]uint32{0x00000000, 0xbe846eb9, 0xeb5f256c, 0x55db4bd5, 0x80703d40, 0x3ef453f9, 0x6b2f182c, 0xd5ab7695, 0x0000ce07, 0xbe84a0be, 0xeb5feb6b, 0x55db85d2, 0x8070f347, 0x3ef49dfe, 0x6b2fd62b, 0xd5abb892}, - [16]uint32{0x00000000, 0x40640196, 0x005201a7, 0x40360031, 0x003c016d, 0x405800fb, 0x006e00ca, 0x400a015c, 0x000280e5, 0x40668173, 0x00508142, 0x403480d4, 0x003e8188, 0x405a801e, 0x006c802f, 0x400881b9}, - [16]uint32{0x3f800000, 0x3fa03200, 0x3f802900, 0x3fa01b00, 0x3f801e00, 0x3fa02c00, 0x3f803700, 0x3fa00500, 0x3f800140, 0x3fa03340, 0x3f802840, 0x3fa01a40, 0x3f801f40, 0x3fa02d40, 0x3f803640, 0x3fa00440}, - uint32(0xfff80000), - [21]string{"0x4f", "0xc7", "0xc4", "0x88", "0x83", "0xbc", "0x79", "0x9c", "0x8c", "0x16", "0xc0", "0x6b", "0x2e", "0x0c", "0xff", "0x3d", "0x26", "0x03", "0x35", "0x3f", "0x00"}}, - { - /* No.981 delta:885 weight:1711 */ - 11213, - 49, - 13, - 4, - [16]uint32{0x00000000, 0xa7b8a085, 0x1ce8a673, 0xbb5006f6, 0x6a003d5d, 0xcdb89dd8, 0x76e89b2e, 0xd1503bab, 0x0000e8ba, 0xa7b8483f, 0x1ce84ec9, 0xbb50ee4c, 0x6a00d5e7, 0xcdb87562, 0x76e87394, 0xd150d311}, - [16]uint32{0x00000000, 0x44038015, 0x3002c1ce, 0x740141db, 0x10000899, 0x5403888c, 0x2002c957, 0x64014942, 0x400010d4, 0x040390c1, 0x7002d11a, 0x3401510f, 0x5000184d, 0x14039858, 0x6002d983, 0x24015996}, - [16]uint32{0x3f800000, 0x3fa201c0, 0x3f980160, 0x3fba00a0, 0x3f880004, 0x3faa01c4, 0x3f900164, 0x3fb200a4, 0x3fa00008, 0x3f8201c8, 0x3fb80168, 0x3f9a00a8, 0x3fa8000c, 0x3f8a01cc, 0x3fb0016c, 0x3f9200ac}, - uint32(0xfff80000), - [21]string{"0xb7", "0xf2", "0x77", "0x08", "0x19", "0x24", "0xde", "0x9b", "0x4c", "0xa4", "0x27", "0x55", "0xcc", "0xbd", "0xcf", "0x36", "0x60", "0x24", "0x6e", "0xf9", "0x00"}}, - { - /* No.982 delta:1437 weight:1649 */ - 11213, - 19, - 13, - 4, - [16]uint32{0x00000000, 0x5b082372, 0xecfaa110, 0xb7f28262, 0xb9603d6d, 0xe2681e1f, 0x559a9c7d, 0x0e92bf0f, 0x00000dce, 0x5b082ebc, 0xecfaacde, 0xb7f28fac, 0xb96030a3, 0xe26813d1, 0x559a91b3, 0x0e92b2c1}, - [16]uint32{0x00000000, 0x0465d0fa, 0x205a0851, 0x243fd8ab, 0x0002618c, 0x0467b176, 0x205869dd, 0x243db927, 0x2034759e, 0x2451a564, 0x006e7dcf, 0x040bad35, 0x20361412, 0x2453c4e8, 0x006c1c43, 0x0409ccb9}, - [16]uint32{0x3f800000, 0x3f8232e8, 0x3f902d04, 0x3f921fec, 0x3f800130, 0x3f8233d8, 0x3f902c34, 0x3f921edc, 0x3f901a3a, 0x3f9228d2, 0x3f80373e, 0x3f8205d6, 0x3f901b0a, 0x3f9229e2, 0x3f80360e, 0x3f8204e6}, - uint32(0xfff80000), - [21]string{"0x50", "0xd4", "0x64", "0xa2", "0x67", "0xe0", "0xb9", "0x8f", "0x48", "0x29", "0x98", "0x90", "0x49", "0x90", "0x8f", "0xd0", "0x48", "0x74", "0x94", "0xda", "0x00"}}, - { - /* No.983 delta:1657 weight:1581 */ - 11213, - 13, - 13, - 4, - [16]uint32{0x00000000, 0xa1cd030d, 0xd768efcf, 0x76a5ecc2, 0x12e03d7b, 0xb32d3e76, 0xc588d2b4, 0x6445d1b9, 0x00004b8e, 0xa1cd4883, 0xd768a441, 0x76a5a74c, 0x12e076f5, 0xb32d75f8, 0xc588993a, 0x64459a37}, - [16]uint32{0x00000000, 0x08ae891a, 0x4702c06d, 0x4fac4977, 0x406c91fe, 0x48c218e4, 0x076e5193, 0x0fc0d889, 0x04092014, 0x0ca7a90e, 0x430be079, 0x4ba56963, 0x4465b1ea, 0x4ccb38f0, 0x03677187, 0x0bc9f89d}, - [16]uint32{0x3f800000, 0x3f845744, 0x3fa38160, 0x3fa7d624, 0x3fa03648, 0x3fa4610c, 0x3f83b728, 0x3f87e06c, 0x3f820490, 0x3f8653d4, 0x3fa185f0, 0x3fa5d2b4, 0x3fa232d8, 0x3fa6659c, 0x3f81b3b8, 0x3f85e4fc}, - uint32(0xfff80000), - [21]string{"0x4e", "0x2e", "0x5e", "0x22", "0x88", "0x4e", "0x89", "0x85", "0xdb", "0xc7", "0x4b", "0xfa", "0xfa", "0x2f", "0xe9", "0xb9", "0xa0", "0x87", "0x0b", "0xe0", "0x00"}}, - { - /* No.984 delta:943 weight:1061 */ - 11213, - 50, - 13, - 4, - [16]uint32{0x00000000, 0x56d379be, 0x60afff41, 0x367c86ff, 0x7af03d86, 0x2c234438, 0x1a5fc2c7, 0x4c8cbb79, 0x00004080, 0x56d3393e, 0x60afbfc1, 0x367cc67f, 0x7af07d06, 0x2c2304b8, 0x1a5f8247, 0x4c8cfbf9}, - [16]uint32{0x00000000, 0x004ec147, 0x1003416b, 0x104d802c, 0x0400c05a, 0x044e011d, 0x14038131, 0x144d4076, 0x000210b3, 0x004cd1f4, 0x100151d8, 0x104f909f, 0x0402d0e9, 0x044c11ae, 0x14019182, 0x144f50c5}, - [16]uint32{0x3f800000, 0x3f802760, 0x3f8801a0, 0x3f8826c0, 0x3f820060, 0x3f822700, 0x3f8a01c0, 0x3f8a26a0, 0x3f800108, 0x3f802668, 0x3f8800a8, 0x3f8827c8, 0x3f820168, 0x3f822608, 0x3f8a00c8, 0x3f8a27a8}, - uint32(0xfff80000), - [21]string{"0xbb", "0xcc", "0x78", "0x68", "0xdb", "0x33", "0xd1", "0x39", "0x94", "0xaf", "0xa5", "0x75", "0x48", "0xe4", "0x9f", "0x4d", "0x6d", "0x5d", "0xea", "0x77", "0x00"}}, - { - /* No.985 delta:1309 weight:1651 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x13a03e56, 0xb84511b0, 0xabe52fe6, 0x53203d90, 0x408003c6, 0xeb652c20, 0xf8c51276, 0x0000f467, 0x13a0ca31, 0xb845e5d7, 0xabe5db81, 0x5320c9f7, 0x4080f7a1, 0xeb65d847, 0xf8c5e611}, - [16]uint32{0x00000000, 0x004c209a, 0x0038e0f9, 0x0074c063, 0x49c71152, 0x498b31c8, 0x49fff1ab, 0x49b3d131, 0x001a410d, 0x00566197, 0x0022a1f4, 0x006e816e, 0x49dd505f, 0x499170c5, 0x49e5b0a6, 0x49a9903c}, - [16]uint32{0x3f800000, 0x3f802610, 0x3f801c70, 0x3f803a60, 0x3fa4e388, 0x3fa4c598, 0x3fa4fff8, 0x3fa4d9e8, 0x3f800d20, 0x3f802b30, 0x3f801150, 0x3f803740, 0x3fa4eea8, 0x3fa4c8b8, 0x3fa4f2d8, 0x3fa4d4c8}, - uint32(0xfff80000), - [21]string{"0xac", "0xb5", "0x11", "0x49", "0xd3", "0x22", "0xd4", "0xf1", "0xf5", "0xb1", "0xa3", "0x83", "0xff", "0xaa", "0x1a", "0xa5", "0xd1", "0x5d", "0x58", "0xe2", "0x00"}}, - { - /* No.986 delta:903 weight:1253 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0xda52c69e, 0x60703bb7, 0xba22fd29, 0x23b03dad, 0xf9e2fb33, 0x43c0061a, 0x9992c084, 0x00005959, 0xda529fc7, 0x607062ee, 0xba22a470, 0x23b064f4, 0xf9e2a26a, 0x43c05f43, 0x999299dd}, - [16]uint32{0x00000000, 0x100c05d2, 0x0002615b, 0x100e6489, 0x40000036, 0x500c05e4, 0x4002616d, 0x500e64bf, 0x20019173, 0x300d94a1, 0x2003f028, 0x300ff5fa, 0x60019145, 0x700d9497, 0x6003f01e, 0x700ff5cc}, - [16]uint32{0x3f800000, 0x3f880602, 0x3f800130, 0x3f880732, 0x3fa00000, 0x3fa80602, 0x3fa00130, 0x3fa80732, 0x3f9000c8, 0x3f9806ca, 0x3f9001f8, 0x3f9807fa, 0x3fb000c8, 0x3fb806ca, 0x3fb001f8, 0x3fb807fa}, - uint32(0xfff80000), - [21]string{"0x38", "0xd5", "0x50", "0xea", "0xe2", "0x6f", "0x1d", "0x37", "0x12", "0xfa", "0x61", "0xde", "0xc0", "0xa6", "0x6e", "0x98", "0xde", "0x20", "0xe6", "0xdc", "0x00"}}, - { - /* No.987 delta:1064 weight:1451 */ - 11213, - 28, - 13, - 4, - [16]uint32{0x00000000, 0x12a26653, 0x713659fa, 0x63943fa9, 0x12103dbf, 0x00b25bec, 0x63266445, 0x71840216, 0x0000f386, 0x12a295d5, 0x7136aa7c, 0x6394cc2f, 0x1210ce39, 0x00b2a86a, 0x632697c3, 0x7184f190}, - [16]uint32{0x00000000, 0x405c5094, 0x600428b1, 0x20587825, 0x725421b9, 0x3208712d, 0x12500908, 0x520c599c, 0x4000206f, 0x005c70fb, 0x200408de, 0x6058584a, 0x325401d6, 0x72085142, 0x52502967, 0x120c79f3}, - [16]uint32{0x3f800000, 0x3fa02e28, 0x3fb00214, 0x3f902c3c, 0x3fb92a10, 0x3f990438, 0x3f892804, 0x3fa9062c, 0x3fa00010, 0x3f802e38, 0x3f900204, 0x3fb02c2c, 0x3f992a00, 0x3fb90428, 0x3fa92814, 0x3f89063c}, - uint32(0xfff80000), - [21]string{"0x96", "0x6f", "0xdc", "0x35", "0xbf", "0x01", "0x2b", "0xaf", "0x1f", "0xc8", "0x81", "0x34", "0x3b", "0x8d", "0x10", "0xc4", "0x1a", "0xe9", "0x1c", "0x05", "0x00"}}, - { - /* No.988 delta:917 weight:1565 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xfa553dde, 0x803150b8, 0x7a646d66, 0xe7803dc0, 0x1dd5001e, 0x67b16d78, 0x9de450a6, 0x0000ac65, 0xfa5591bb, 0x8031fcdd, 0x7a64c103, 0xe78091a5, 0x1dd5ac7b, 0x67b1c11d, 0x9de4fcc3}, - [16]uint32{0x00000000, 0x0074b055, 0x000a1637, 0x007ea662, 0x1003461e, 0x1077f64b, 0x10095029, 0x107de07c, 0x00020813, 0x0076b846, 0x00081e24, 0x007cae71, 0x10014e0d, 0x1075fe58, 0x100b583a, 0x107fe86f}, - [16]uint32{0x3f800000, 0x3f803a58, 0x3f80050b, 0x3f803f53, 0x3f8801a3, 0x3f883bfb, 0x3f8804a8, 0x3f883ef0, 0x3f800104, 0x3f803b5c, 0x3f80040f, 0x3f803e57, 0x3f8800a7, 0x3f883aff, 0x3f8805ac, 0x3f883ff4}, - uint32(0xfff80000), - [21]string{"0x8b", "0x47", "0x1b", "0x8d", "0x2e", "0x72", "0x41", "0x0a", "0xe9", "0x54", "0x9c", "0xfa", "0x02", "0xc3", "0xf4", "0x99", "0x4c", "0x00", "0xcb", "0x30", "0x00"}}, - { - /* No.989 delta:866 weight:1649 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x0c0d9229, 0x5db5a2ec, 0x51b830c5, 0xf2a03dd9, 0xfeadaff0, 0xaf159f35, 0xa3180d1c, 0x00004772, 0x0c0dd55b, 0x5db5e59e, 0x51b877b7, 0xf2a07aab, 0xfeade882, 0xaf15d847, 0xa3184a6e}, - [16]uint32{0x00000000, 0x00619096, 0xa00988f9, 0xa068186f, 0x0000b011, 0x00612087, 0xa00938e8, 0xa068a87e, 0x0020100b, 0x0041809d, 0xa02998f2, 0xa0480864, 0x0020a01a, 0x0041308c, 0xa02928e3, 0xa048b875}, - [16]uint32{0x3f800000, 0x3f8030c8, 0x3fd004c4, 0x3fd0340c, 0x3f800058, 0x3f803090, 0x3fd0049c, 0x3fd03454, 0x3f801008, 0x3f8020c0, 0x3fd014cc, 0x3fd02404, 0x3f801050, 0x3f802098, 0x3fd01494, 0x3fd0245c}, - uint32(0xfff80000), - [21]string{"0xf3", "0x7f", "0xa0", "0x60", "0x37", "0x61", "0x2e", "0x49", "0x4c", "0x37", "0x46", "0x4b", "0x42", "0x38", "0xa6", "0x56", "0xac", "0xdd", "0x14", "0x02", "0x00"}}, - { - /* No.990 delta:2165 weight:1349 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xd6b9415c, 0x5d3a2870, 0x8b83692c, 0x19103de3, 0xcfa97cbf, 0x442a1593, 0x929354cf, 0x0000dcdc, 0xd6b99d80, 0x5d3af4ac, 0x8b83b5f0, 0x1910e13f, 0xcfa9a063, 0x442ac94f, 0x92938813}, - [16]uint32{0x00000000, 0x1663371e, 0x0882017b, 0x1ee13665, 0x018a208f, 0x17e91791, 0x090821f4, 0x1f6b16ea, 0x1481b058, 0x02e28746, 0x1c03b123, 0x0a60863d, 0x150b90d7, 0x0368a7c9, 0x1d8991ac, 0x0beaa6b2}, - [16]uint32{0x3f800000, 0x3f8b319b, 0x3f844100, 0x3f8f709b, 0x3f80c510, 0x3f8bf48b, 0x3f848410, 0x3f8fb58b, 0x3f8a40d8, 0x3f817143, 0x3f8e01d8, 0x3f853043, 0x3f8a85c8, 0x3f81b453, 0x3f8ec4c8, 0x3f85f553}, - uint32(0xfff80000), - [21]string{"0xf2", "0xab", "0xde", "0x57", "0xa6", "0xe6", "0x5c", "0xcb", "0x2e", "0x36", "0xa3", "0x28", "0x15", "0x52", "0xc2", "0xe4", "0x85", "0xe2", "0x6c", "0xcc", "0x00"}}, - { - /* No.991 delta:1835 weight:1527 */ - 11213, - 11, - 13, - 4, - [16]uint32{0x00000000, 0x57c58a32, 0x84bf9633, 0xd37a1c01, 0x26003dff, 0x71c5b7cd, 0xa2bfabcc, 0xf57a21fe, 0x00008714, 0x57c50d26, 0x84bf1127, 0xd37a9b15, 0x2600baeb, 0x71c530d9, 0xa2bf2cd8, 0xf57aa6ea}, - [16]uint32{0x00000000, 0x0946197e, 0x0c2400ef, 0x05621991, 0x018c238a, 0x08ca3af4, 0x0da82365, 0x04ee3a1b, 0x20029009, 0x29448977, 0x2c2690e6, 0x25608998, 0x218eb383, 0x28c8aafd, 0x2daab36c, 0x24ecaa12}, - [16]uint32{0x3f800000, 0x3f84a30c, 0x3f861200, 0x3f82b10c, 0x3f80c611, 0x3f84651d, 0x3f86d411, 0x3f82771d, 0x3f900148, 0x3f94a244, 0x3f961348, 0x3f92b044, 0x3f90c759, 0x3f946455, 0x3f96d559, 0x3f927655}, - uint32(0xfff80000), - [21]string{"0x50", "0x42", "0x69", "0x0b", "0x7b", "0xb2", "0xe3", "0x3c", "0xf2", "0x9e", "0x8c", "0x10", "0x4c", "0x6b", "0xa0", "0xdb", "0xa3", "0x43", "0xc7", "0x5d", "0x00"}}, - { - /* No.992 delta:1469 weight:1613 */ - 11213, - 16, - 13, - 4, - [16]uint32{0x00000000, 0xe0455c89, 0xe2f3c7fe, 0x02b69b77, 0x27d03e0d, 0xc7956284, 0xc523f9f3, 0x2566a57a, 0x00007033, 0xe0452cba, 0xe2f3b7cd, 0x02b6eb44, 0x27d04e3e, 0xc79512b7, 0xc52389c0, 0x2566d549}, - [16]uint32{0x00000000, 0x205ee05a, 0x006a609c, 0x203480c6, 0x4048b803, 0x60165859, 0x4022d89f, 0x607c38c5, 0x30208010, 0x107e604a, 0x304ae08c, 0x101400d6, 0x70683813, 0x5036d849, 0x7002588f, 0x505cb8d5}, - [16]uint32{0x3f800000, 0x3f902f70, 0x3f803530, 0x3f901a40, 0x3fa0245c, 0x3fb00b2c, 0x3fa0116c, 0x3fb03e1c, 0x3f981040, 0x3f883f30, 0x3f982570, 0x3f880a00, 0x3fb8341c, 0x3fa81b6c, 0x3fb8012c, 0x3fa82e5c}, - uint32(0xfff80000), - [21]string{"0x59", "0x9d", "0xe1", "0x1c", "0xa7", "0x21", "0x81", "0xe1", "0xe8", "0x12", "0x16", "0x3e", "0x4f", "0xaa", "0x18", "0x27", "0x1d", "0xa6", "0x7b", "0x75", "0x00"}}, - { - /* No.993 delta:2176 weight:1275 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0x402e4ffd, 0xfac4555b, 0xbaea1aa6, 0x70303e1b, 0x301e71e6, 0x8af46b40, 0xcada24bd, 0x000055ca, 0x402e1a37, 0xfac40091, 0xbaea4f6c, 0x70306bd1, 0x301e242c, 0x8af43e8a, 0xcada7177}, - [16]uint32{0x00000000, 0x0f12905e, 0x4182c14b, 0x4e905115, 0x2900bde2, 0x26122dbc, 0x68827ca9, 0x6790ecf7, 0x00809048, 0x0f920016, 0x41025103, 0x4e10c15d, 0x29802daa, 0x2692bdf4, 0x6802ece1, 0x67107cbf}, - [16]uint32{0x3f800000, 0x3f878948, 0x3fa0c160, 0x3fa74828, 0x3f94805e, 0x3f930916, 0x3fb4413e, 0x3fb3c876, 0x3f804048, 0x3f87c900, 0x3fa08128, 0x3fa70860, 0x3f94c016, 0x3f93495e, 0x3fb40176, 0x3fb3883e}, - uint32(0xfff80000), - [21]string{"0xda", "0xc3", "0xc4", "0x50", "0x70", "0x11", "0xfb", "0xc9", "0x32", "0xd0", "0xdb", "0x1f", "0xba", "0x1b", "0x51", "0xe7", "0xa0", "0xb8", "0x42", "0xf2", "0x00"}}, - { - /* No.994 delta:2034 weight:1291 */ - 11213, - 9, - 13, - 4, - [16]uint32{0x00000000, 0x2d4ba9e4, 0x99e7ca34, 0xb4ac63d0, 0xe6603e2f, 0xcb2b97cb, 0x7f87f41b, 0x52cc5dff, 0x0000096c, 0x2d4ba088, 0x99e7c358, 0xb4ac6abc, 0xe6603743, 0xcb2b9ea7, 0x7f87fd77, 0x52cc5493}, - [16]uint32{0x00000000, 0x48a2707e, 0xa18108ad, 0xe92378d3, 0x42152058, 0x0ab75026, 0xe39428f5, 0xab36588b, 0x1d34200c, 0x55965072, 0xbcb528a1, 0xf41758df, 0x5f210054, 0x1783702a, 0xfea008f9, 0xb6027887}, - [16]uint32{0x3f800000, 0x3fa45138, 0x3fd0c084, 0x3ff491bc, 0x3fa10a90, 0x3f855ba8, 0x3ff1ca14, 0x3fd59b2c, 0x3f8e9a10, 0x3faacb28, 0x3fde5a94, 0x3ffa0bac, 0x3faf9080, 0x3f8bc1b8, 0x3fff5004, 0x3fdb013c}, - uint32(0xfff80000), - [21]string{"0xee", "0xcd", "0xab", "0xb0", "0x16", "0xc7", "0xf4", "0x12", "0xd0", "0x35", "0x84", "0x47", "0xd5", "0x24", "0x8a", "0x30", "0xd8", "0x81", "0x6e", "0x9e", "0x00"}}, - { - /* No.995 delta:1441 weight:1543 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x398c3c50, 0x486ef548, 0x71e2c918, 0xb2c03e32, 0x8b4c0262, 0xfaaecb7a, 0xc322f72a, 0x0000ccac, 0x398cf0fc, 0x486e39e4, 0x71e205b4, 0xb2c0f29e, 0x8b4ccece, 0xfaae07d6, 0xc3223b86}, - [16]uint32{0x00000000, 0x003dec9f, 0x531d00c3, 0x5320ec5c, 0x00028405, 0x003f689a, 0x531f84c6, 0x53226859, 0x006810eb, 0x0055fc74, 0x53751028, 0x5348fcb7, 0x006a94ee, 0x00577871, 0x5377942d, 0x534a78b2}, - [16]uint32{0x3f800000, 0x3f801ef6, 0x3fa98e80, 0x3fa99076, 0x3f800142, 0x3f801fb4, 0x3fa98fc2, 0x3fa99134, 0x3f803408, 0x3f802afe, 0x3fa9ba88, 0x3fa9a47e, 0x3f80354a, 0x3f802bbc, 0x3fa9bbca, 0x3fa9a53c}, - uint32(0xfff80000), - [21]string{"0x52", "0xf0", "0xd6", "0x26", "0x25", "0xfc", "0xba", "0xdc", "0x2b", "0x1c", "0xfd", "0x52", "0xef", "0x56", "0xa7", "0x5e", "0x6e", "0x6f", "0x7f", "0x2f", "0x00"}}, - { - /* No.996 delta:1224 weight:1541 */ - 11213, - 21, - 13, - 4, - [16]uint32{0x00000000, 0x4fc065a2, 0x11de5350, 0x5e1e36f2, 0x80d03e43, 0xcf105be1, 0x910e6d13, 0xdece08b1, 0x000031d0, 0x4fc05472, 0x11de6280, 0x5e1e0722, 0x80d00f93, 0xcf106a31, 0x910e5cc3, 0xdece3961}, - [16]uint32{0x00000000, 0x38637996, 0x004ce1fd, 0x382f986b, 0x0031815a, 0x3852f8cc, 0x007d60a7, 0x381e1931, 0x50103d8e, 0x68734418, 0x505cdc73, 0x683fa5e5, 0x5021bcd4, 0x6842c542, 0x506d5d29, 0x680e24bf}, - [16]uint32{0x3f800000, 0x3f9c31bc, 0x3f802670, 0x3f9c17cc, 0x3f8018c0, 0x3f9c297c, 0x3f803eb0, 0x3f9c0f0c, 0x3fa8081e, 0x3fb439a2, 0x3fa82e6e, 0x3fb41fd2, 0x3fa810de, 0x3fb42162, 0x3fa836ae, 0x3fb40712}, - uint32(0xfff80000), - [21]string{"0xdc", "0x78", "0x3d", "0xc3", "0xe6", "0xc3", "0x7e", "0xd4", "0xf2", "0x1b", "0x10", "0xd2", "0x29", "0x40", "0x28", "0x8d", "0xd5", "0xa3", "0x08", "0x80", "0x00"}}, - { - /* No.997 delta:1252 weight:1509 */ - 11213, - 20, - 13, - 4, - [16]uint32{0x00000000, 0xbe0f3f8f, 0xa45ae090, 0x1a55df1f, 0xff603e52, 0x416f01dd, 0x5b3adec2, 0xe535e14d, 0x0000b887, 0xbe0f8708, 0xa45a5817, 0x1a556798, 0xff6086d5, 0x416fb95a, 0x5b3a6645, 0xe53559ca}, - [16]uint32{0x00000000, 0x505525da, 0x40503e9c, 0x10051b46, 0x30000405, 0x605521df, 0x70503a99, 0x20051f43, 0x4034601d, 0x106145c7, 0x00645e81, 0x50317b5b, 0x70346418, 0x206141c2, 0x30645a84, 0x60317f5e}, - [16]uint32{0x3f800000, 0x3fa82a92, 0x3fa0281f, 0x3f88028d, 0x3f980002, 0x3fb02a90, 0x3fb8281d, 0x3f90028f, 0x3fa01a30, 0x3f8830a2, 0x3f80322f, 0x3fa818bd, 0x3fb81a32, 0x3f9030a0, 0x3f98322d, 0x3fb018bf}, - uint32(0xfff80000), - [21]string{"0x4b", "0xb4", "0xc0", "0xcf", "0x10", "0x10", "0xe5", "0xbe", "0x52", "0x97", "0x9c", "0xfb", "0x84", "0x77", "0xac", "0x7d", "0xce", "0xbf", "0x3d", "0xe9", "0x00"}}, - { - /* No.998 delta:951 weight:1607 */ - 11213, - 63, - 13, - 4, - [16]uint32{0x00000000, 0xab26c38a, 0x3b2110a4, 0x9007d32e, 0x1ab03e68, 0xb196fde2, 0x21912ecc, 0x8ab7ed46, 0x0000eef0, 0xab262d7a, 0x3b21fe54, 0x90073dde, 0x1ab0d098, 0xb1961312, 0x2191c03c, 0x8ab703b6}, - [16]uint32{0x00000000, 0x107e11df, 0x00022151, 0x107c308e, 0x0000a087, 0x107eb158, 0x000281d6, 0x107c9009, 0x10410014, 0x003f11cb, 0x10432145, 0x003d309a, 0x1041a093, 0x003fb14c, 0x104381c2, 0x003d901d}, - [16]uint32{0x3f800000, 0x3f883f08, 0x3f800110, 0x3f883e18, 0x3f800050, 0x3f883f58, 0x3f800140, 0x3f883e48, 0x3f882080, 0x3f801f88, 0x3f882190, 0x3f801e98, 0x3f8820d0, 0x3f801fd8, 0x3f8821c0, 0x3f801ec8}, - uint32(0xfff80000), - [21]string{"0xc2", "0x2d", "0x49", "0xe6", "0x56", "0x03", "0xdb", "0xb2", "0x23", "0x87", "0x52", "0x0e", "0x60", "0x23", "0x17", "0x60", "0x05", "0x1c", "0x6b", "0xab", "0x00"}}, - { - /* No.999 delta:711 weight:1373 */ - 11213, - 69, - 13, - 4, - [16]uint32{0x00000000, 0x37bdff24, 0x0ab1eda4, 0x3d0c1280, 0xdc403e7c, 0xebfdc158, 0xd6f1d3d8, 0xe14c2cfc, 0x0000b8d4, 0x37bd47f0, 0x0ab15570, 0x3d0caa54, 0xdc4086a8, 0xebfd798c, 0xd6f16b0c, 0xe14c9428}, - [16]uint32{0x00000000, 0x2040485b, 0x440002fe, 0x64404aa5, 0x1003009c, 0x304348c7, 0x54030262, 0x74434a39, 0x20020014, 0x0042484f, 0x640202ea, 0x44424ab1, 0x30010088, 0x104148d3, 0x74010276, 0x54414a2d}, - [16]uint32{0x3f800000, 0x3f902024, 0x3fa20001, 0x3fb22025, 0x3f880180, 0x3f9821a4, 0x3faa0181, 0x3fba21a5, 0x3f900100, 0x3f802124, 0x3fb20101, 0x3fa22125, 0x3f980080, 0x3f8820a4, 0x3fba0081, 0x3faa20a5}, - uint32(0xfff80000), - [21]string{"0x91", "0x30", "0x74", "0xbb", "0x12", "0x0e", "0x01", "0x97", "0x0f", "0xfc", "0x3c", "0xd1", "0x3a", "0x5f", "0x41", "0x9f", "0x5a", "0xed", "0x3a", "0x65", "0x00"}}, - { - /* No.1000 delta:1182 weight:1397 */ - 11213, - 35, - 13, - 4, - [16]uint32{0x00000000, 0xece9e6b0, 0x0ee6a1fd, 0xe20f474d, 0xe2903e83, 0x0e79d833, 0xec769f7e, 0x009f79ce, 0x000025fa, 0xece9c34a, 0x0ee68407, 0xe20f62b7, 0xe2901b79, 0x0e79fdc9, 0xec76ba84, 0x009f5c34}, - [16]uint32{0x00000000, 0x05241196, 0x006c013b, 0x054810ad, 0x000201b3, 0x05261025, 0x006e0088, 0x054a111e, 0x0070a01f, 0x0554b189, 0x001ca124, 0x0538b0b2, 0x0072a1ac, 0x0556b03a, 0x001ea097, 0x053ab101}, - [16]uint32{0x3f800000, 0x3f829208, 0x3f803600, 0x3f82a408, 0x3f800100, 0x3f829308, 0x3f803700, 0x3f82a508, 0x3f803850, 0x3f82aa58, 0x3f800e50, 0x3f829c58, 0x3f803950, 0x3f82ab58, 0x3f800f50, 0x3f829d58}, - uint32(0xfff80000), - [21]string{"0xcb", "0xa4", "0x05", "0x4c", "0xed", "0x7d", "0xf8", "0x46", "0x3e", "0x6b", "0x6c", "0xaf", "0x66", "0x0e", "0x5d", "0x83", "0xed", "0x4a", "0x0c", "0xf8", "0x00"}}, - { - /* No.1001 delta:1402 weight:1623 */ - 11213, - 18, - 13, - 4, - [16]uint32{0x00000000, 0x65d47cf2, 0xbc6fb880, 0xd9bbc472, 0x39603e98, 0x5cb4426a, 0x850f8618, 0xe0dbfaea, 0x00007893, 0x65d40461, 0xbc6fc013, 0xd9bbbce1, 0x3960460b, 0x5cb43af9, 0x850ffe8b, 0xe0db8279}, - [16]uint32{0x00000000, 0x007c1df6, 0x20220055, 0x205e1da3, 0x4070901a, 0x400c8dec, 0x6052904f, 0x602e8db9, 0x20313201, 0x204d2ff7, 0x00133254, 0x006f2fa2, 0x6041a21b, 0x603dbfed, 0x4063a24e, 0x401fbfb8}, - [16]uint32{0x3f800000, 0x3f803e0e, 0x3f901100, 0x3f902f0e, 0x3fa03848, 0x3fa00646, 0x3fb02948, 0x3fb01746, 0x3f901899, 0x3f902697, 0x3f800999, 0x3f803797, 0x3fb020d1, 0x3fb01edf, 0x3fa031d1, 0x3fa00fdf}, - uint32(0xfff80000), - [21]string{"0x95", "0x61", "0x30", "0xa8", "0xaa", "0x5b", "0x65", "0x91", "0xda", "0xd3", "0x37", "0xf0", "0xee", "0x4c", "0xfc", "0xac", "0xd8", "0x66", "0xd9", "0x23", "0x00"}}, - { - /* No.1002 delta:693 weight:1709 */ - 11213, - 77, - 13, - 4, - [16]uint32{0x00000000, 0x935cb27b, 0x2a0e6ab1, 0xb952d8ca, 0x84103eab, 0x174c8cd0, 0xae1e541a, 0x3d42e661, 0x0000cdf0, 0x935c7f8b, 0x2a0ea741, 0xb952153a, 0x8410f35b, 0x174c4120, 0xae1e99ea, 0x3d422b91}, - [16]uint32{0x00000000, 0x440304fa, 0x5002869d, 0x14018267, 0x7001a21f, 0x3402a6e5, 0x20032482, 0x64002078, 0x200000b6, 0x6403044c, 0x7002862b, 0x340182d1, 0x5001a2a9, 0x1402a653, 0x00032434, 0x440020ce}, - [16]uint32{0x3f800000, 0x3fa20182, 0x3fa80143, 0x3f8a00c1, 0x3fb800d1, 0x3f9a0153, 0x3f900192, 0x3fb20010, 0x3f900000, 0x3fb20182, 0x3fb80143, 0x3f9a00c1, 0x3fa800d1, 0x3f8a0153, 0x3f800192, 0x3fa20010}, - uint32(0xfff80000), - [21]string{"0x03", "0x1f", "0x94", "0xbf", "0xcb", "0x72", "0x3c", "0xba", "0x76", "0x33", "0xf3", "0x7b", "0x66", "0x5e", "0xd4", "0x6f", "0xf9", "0x08", "0x33", "0xb1", "0x00"}}, - { - /* No.1003 delta:1158 weight:1719 */ - 11213, - 25, - 13, - 4, - [16]uint32{0x00000000, 0x66de1e00, 0x444a40d4, 0x22945ed4, 0x9e203ebd, 0xf8fe20bd, 0xda6a7e69, 0xbcb46069, 0x00001425, 0x66de0a25, 0x444a54f1, 0x22944af1, 0x9e202a98, 0xf8fe3498, 0xda6a6a4c, 0xbcb4744c}, - [16]uint32{0x00000000, 0x4065799e, 0x00740478, 0x40117de6, 0x1048e0e3, 0x502d997d, 0x103ce49b, 0x50599d05, 0x00095137, 0x406c28a9, 0x007d554f, 0x40182cd1, 0x1041b1d4, 0x5024c84a, 0x1035b5ac, 0x5050cc32}, - [16]uint32{0x3f800000, 0x3fa032bc, 0x3f803a02, 0x3fa008be, 0x3f882470, 0x3fa816cc, 0x3f881e72, 0x3fa82cce, 0x3f8004a8, 0x3fa03614, 0x3f803eaa, 0x3fa00c16, 0x3f8820d8, 0x3fa81264, 0x3f881ada, 0x3fa82866}, - uint32(0xfff80000), - [21]string{"0x7f", "0x65", "0x58", "0x21", "0x4c", "0x14", "0x8a", "0xd2", "0xa1", "0x21", "0x5b", "0x13", "0xb9", "0xfd", "0xa5", "0xd8", "0x80", "0x6c", "0x86", "0x8f", "0x00"}}, - { - /* No.1004 delta:977 weight:1537 */ - 11213, - 52, - 13, - 4, - [16]uint32{0x00000000, 0xd8123379, 0xdf032245, 0x0711113c, 0xb6203ec2, 0x6e320dbb, 0x69231c87, 0xb1312ffe, 0x00006693, 0xd81255ea, 0xdf0344d6, 0x071177af, 0xb6205851, 0x6e326b28, 0x69237a14, 0xb131496d}, - [16]uint32{0x00000000, 0x0043987f, 0x50022d73, 0x5041b50c, 0x1001c019, 0x10425866, 0x4003ed6a, 0x40407515, 0x400010e4, 0x4043889b, 0x10023d97, 0x1041a5e8, 0x5001d0fd, 0x50424882, 0x0003fd8e, 0x004065f1}, - [16]uint32{0x3f800000, 0x3f8021cc, 0x3fa80116, 0x3fa820da, 0x3f8800e0, 0x3f88212c, 0x3fa001f6, 0x3fa0203a, 0x3fa00008, 0x3fa021c4, 0x3f88011e, 0x3f8820d2, 0x3fa800e8, 0x3fa82124, 0x3f8001fe, 0x3f802032}, - uint32(0xfff80000), - [21]string{"0xad", "0x18", "0xd7", "0x99", "0x00", "0x36", "0x14", "0x49", "0x7f", "0x75", "0x51", "0x24", "0x51", "0x03", "0x15", "0x5d", "0x14", "0x52", "0x7f", "0x31", "0x00"}}, - { - /* No.1005 delta:1179 weight:1511 */ - 11213, - 26, - 13, - 4, - [16]uint32{0x00000000, 0x4af1f165, 0x346107f5, 0x7e90f690, 0x83c03eda, 0xc931cfbf, 0xb7a1392f, 0xfd50c84a, 0x00006419, 0x4af1957c, 0x346163ec, 0x7e909289, 0x83c05ac3, 0xc931aba6, 0xb7a15d36, 0xfd50ac53}, - [16]uint32{0x00000000, 0x805a19ba, 0x00020409, 0x80581db3, 0x8016900e, 0x004c89b4, 0x80149407, 0x004e8dbd, 0x102b1806, 0x907101bc, 0x10291c0f, 0x907305b5, 0x903d8808, 0x106791b2, 0x903f8c01, 0x106595bb}, - [16]uint32{0x3f800000, 0x3fc02d0c, 0x3f800102, 0x3fc02c0e, 0x3fc00b48, 0x3f802644, 0x3fc00a4a, 0x3f802746, 0x3f88158c, 0x3fc83880, 0x3f88148e, 0x3fc83982, 0x3fc81ec4, 0x3f8833c8, 0x3fc81fc6, 0x3f8832ca}, - uint32(0xfff80000), - [21]string{"0xe8", "0x03", "0x45", "0xd6", "0x70", "0xfb", "0x98", "0x3d", "0x59", "0xeb", "0x1c", "0xe9", "0xd9", "0x0f", "0xe7", "0xbc", "0x10", "0x45", "0x5a", "0x00", "0x00"}}, - { - /* No.1006 delta:909 weight:1627 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xdf4ec65d, 0x6fd001dd, 0xb09ec780, 0xd7603eef, 0x082ef8b2, 0xb8b03f32, 0x67fef96f, 0x0000557d, 0xdf4e9320, 0x6fd054a0, 0xb09e92fd, 0xd7606b92, 0x082eadcf, 0xb8b06a4f, 0x67feac12}, - [16]uint32{0x00000000, 0x20841df2, 0x10038824, 0x308795d6, 0x1000695e, 0x308474ac, 0x0003e17a, 0x2087fc88, 0x10007a5f, 0x308467ad, 0x0003f27b, 0x2087ef89, 0x00001301, 0x20840ef3, 0x10039b25, 0x308786d7}, - [16]uint32{0x3f800000, 0x3f90420e, 0x3f8801c4, 0x3f9843ca, 0x3f880034, 0x3f98423a, 0x3f8001f0, 0x3f9043fe, 0x3f88003d, 0x3f984233, 0x3f8001f9, 0x3f9043f7, 0x3f800009, 0x3f904207, 0x3f8801cd, 0x3f9843c3}, - uint32(0xfff80000), - [21]string{"0x9c", "0xd2", "0xe0", "0xea", "0x62", "0x1f", "0xb7", "0xb8", "0xb4", "0x2e", "0xfb", "0xd2", "0x3a", "0x34", "0xec", "0xf7", "0x58", "0xdc", "0x53", "0x94", "0x00"}}, - { - /* No.1007 delta:859 weight:1541 */ - 11213, - 46, - 13, - 4, - [16]uint32{0x00000000, 0x719d4b9a, 0x7743ef08, 0x06dea492, 0x85c03efc, 0xf45d7566, 0xf283d1f4, 0x831e9a6e, 0x00006f1f, 0x719d2485, 0x77438017, 0x06decb8d, 0x85c051e3, 0xf45d1a79, 0xf283beeb, 0x831ef571}, - [16]uint32{0x00000000, 0x2002a096, 0xd04421ff, 0xf0468169, 0x30036834, 0x1001c8a2, 0xe04749cb, 0xc045e95d, 0x3000821e, 0x10022288, 0xe044a3e1, 0xc0460377, 0x0003ea2a, 0x20014abc, 0xd047cbd5, 0xf0456b43}, - [16]uint32{0x3f800000, 0x3f900150, 0x3fe82210, 0x3ff82340, 0x3f9801b4, 0x3f8800e4, 0x3ff023a4, 0x3fe022f4, 0x3f980041, 0x3f880111, 0x3ff02251, 0x3fe02301, 0x3f8001f5, 0x3f9000a5, 0x3fe823e5, 0x3ff822b5}, - uint32(0xfff80000), - [21]string{"0x64", "0xf6", "0x68", "0x6a", "0x66", "0x60", "0xbc", "0xe5", "0xc6", "0x04", "0x1c", "0xf0", "0xbe", "0x8c", "0xd1", "0x28", "0x9a", "0x42", "0x5a", "0x44", "0x00"}}, - { - /* No.1008 delta:1020 weight:1707 */ - 11213, - 38, - 13, - 4, - [16]uint32{0x00000000, 0x64e6a475, 0x2721e5e3, 0x43c74196, 0xa4503f0a, 0xc0b69b7f, 0x8371dae9, 0xe7977e9c, 0x00009eaf, 0x64e63ada, 0x27217b4c, 0x43c7df39, 0xa450a1a5, 0xc0b605d0, 0x83714446, 0xe797e033}, - [16]uint32{0x00000000, 0x00449c1a, 0x003ee591, 0x007a798b, 0x0024a1c4, 0x00603dde, 0x001a4455, 0x005ed84f, 0x200290dc, 0x20460cc6, 0x203c754d, 0x2078e957, 0x20263118, 0x2062ad02, 0x2018d489, 0x205c4893}, - [16]uint32{0x3f800000, 0x3f80224e, 0x3f801f72, 0x3f803d3c, 0x3f801250, 0x3f80301e, 0x3f800d22, 0x3f802f6c, 0x3f900148, 0x3f902306, 0x3f901e3a, 0x3f903c74, 0x3f901318, 0x3f903156, 0x3f900c6a, 0x3f902e24}, - uint32(0xfff80000), - [21]string{"0x5e", "0x4f", "0x86", "0x59", "0x9d", "0x79", "0xa6", "0x37", "0x89", "0x44", "0xc1", "0x1b", "0x70", "0x49", "0x0d", "0x1a", "0x46", "0x86", "0x71", "0x48", "0x00"}}, - { - /* No.1009 delta:884 weight:1567 */ - 11213, - 66, - 13, - 4, - [16]uint32{0x00000000, 0xa3cca0d9, 0x34b21388, 0x977eb351, 0x35b03f15, 0x967c9fcc, 0x01022c9d, 0xa2ce8c44, 0x0000bd86, 0xa3cc1d5f, 0x34b2ae0e, 0x977e0ed7, 0x35b08293, 0x967c224a, 0x0102911b, 0xa2ce31c2}, - [16]uint32{0x00000000, 0x0400d813, 0x4000c215, 0x44001a06, 0x0000c119, 0x0400190a, 0x4000030c, 0x4400db1f, 0x104f00b4, 0x144fd8a7, 0x504fc2a1, 0x544f1ab2, 0x104fc1ad, 0x144f19be, 0x504f03b8, 0x544fdbab}, - [16]uint32{0x3f800000, 0x3f82006c, 0x3fa00061, 0x3fa2000d, 0x3f800060, 0x3f82000c, 0x3fa00001, 0x3fa2006d, 0x3f882780, 0x3f8a27ec, 0x3fa827e1, 0x3faa278d, 0x3f8827e0, 0x3f8a278c, 0x3fa82781, 0x3faa27ed}, - uint32(0xfff80000), - [21]string{"0x04", "0xdd", "0x2f", "0x05", "0xc0", "0x8d", "0xaa", "0x43", "0x80", "0x26", "0x26", "0x77", "0x1e", "0x57", "0x21", "0x6d", "0x6b", "0x5e", "0xed", "0x4e", "0x00"}}, - { - /* No.1010 delta:968 weight:1215 */ - 11213, - 39, - 13, - 4, - [16]uint32{0x00000000, 0x246fd8c7, 0x1648eb43, 0x32273384, 0x74b03f2b, 0x50dfe7ec, 0x62f8d468, 0x46970caf, 0x0000349d, 0x246fec5a, 0x1648dfde, 0x32270719, 0x74b00bb6, 0x50dfd371, 0x62f8e0f5, 0x46973832}, - [16]uint32{0x00000000, 0x101c09d6, 0x00224b82, 0x103e4254, 0x20032098, 0x301f294e, 0x20216b1a, 0x303d62cc, 0x02034575, 0x121f4ca3, 0x02210ef7, 0x123d0721, 0x220065ed, 0x321c6c3b, 0x22222e6f, 0x323e27b9}, - [16]uint32{0x3f800000, 0x3f880e04, 0x3f801125, 0x3f881f21, 0x3f900190, 0x3f980f94, 0x3f9010b5, 0x3f981eb1, 0x3f8101a2, 0x3f890fa6, 0x3f811087, 0x3f891e83, 0x3f910032, 0x3f990e36, 0x3f911117, 0x3f991f13}, - uint32(0xfff80000), - [21]string{"0x87", "0xb8", "0x98", "0x35", "0x2f", "0x33", "0x93", "0x55", "0x85", "0x4f", "0x7d", "0x55", "0x8c", "0xd8", "0x6e", "0x40", "0x36", "0x11", "0xd6", "0xbf", "0x00"}}, - { - /* No.1011 delta:1031 weight:1603 */ - 11213, - 47, - 13, - 4, - [16]uint32{0x00000000, 0x99459dbf, 0x36f38a5f, 0xafb617e0, 0xbd903f3d, 0x24d5a282, 0x8b63b562, 0x122628dd, 0x00005dd9, 0x9945c066, 0x36f3d786, 0xafb64a39, 0xbd9062e4, 0x24d5ff5b, 0x8b63e8bb, 0x12267504}, - [16]uint32{0x00000000, 0x5800e376, 0x041e001d, 0x5c1ee36b, 0x2002a0ac, 0x780243da, 0x241ca0b1, 0x7c1c43c7, 0x0000100e, 0x5800f378, 0x041e1013, 0x5c1ef365, 0x2002b0a2, 0x780253d4, 0x241cb0bf, 0x7c1c53c9}, - [16]uint32{0x3f800000, 0x3fac0071, 0x3f820f00, 0x3fae0f71, 0x3f900150, 0x3fbc0121, 0x3f920e50, 0x3fbe0e21, 0x3f800008, 0x3fac0079, 0x3f820f08, 0x3fae0f79, 0x3f900158, 0x3fbc0129, 0x3f920e58, 0x3fbe0e29}, - uint32(0xfff80000), - [21]string{"0x79", "0x1c", "0xf0", "0x7f", "0xbb", "0xba", "0xf7", "0x96", "0xd2", "0x9b", "0x3f", "0xcc", "0xfb", "0x8a", "0x0b", "0xfc", "0xd1", "0xda", "0xd2", "0xf1", "0x00"}}, - { - /* No.1012 delta:961 weight:1615 */ - 11213, - 53, - 13, - 4, - [16]uint32{0x00000000, 0x26d3f377, 0x83bfd053, 0xa56c2324, 0x05203f4f, 0x23f3cc38, 0x869fef1c, 0xa04c1c6b, 0x0000f930, 0x26d30a47, 0x83bf2963, 0xa56cda14, 0x0520c67f, 0x23f33508, 0x869f162c, 0xa04ce55b}, - [16]uint32{0x00000000, 0x00749c17, 0x400851e2, 0x407ccdf5, 0x0002801b, 0x00761c0c, 0x400ad1f9, 0x407e4dee, 0x4001d006, 0x40754c11, 0x000981e4, 0x007d1df3, 0x4003501d, 0x4077cc0a, 0x000b01ff, 0x007f9de8}, - [16]uint32{0x3f800000, 0x3f803a4e, 0x3fa00428, 0x3fa03e66, 0x3f800140, 0x3f803b0e, 0x3fa00568, 0x3fa03f26, 0x3fa000e8, 0x3fa03aa6, 0x3f8004c0, 0x3f803e8e, 0x3fa001a8, 0x3fa03be6, 0x3f800580, 0x3f803fce}, - uint32(0xfff80000), - [21]string{"0x4e", "0x79", "0xfc", "0xaa", "0x1b", "0xbc", "0x49", "0x5a", "0xf7", "0xb0", "0x6a", "0xa1", "0xad", "0x12", "0x25", "0x41", "0xf8", "0xdb", "0xf7", "0x4c", "0x00"}}, - { - /* No.1013 delta:2148 weight:1319 */ - 11213, - 8, - 13, - 4, - [16]uint32{0x00000000, 0xc5719a74, 0x3ff46178, 0xfa85fb0c, 0xddc03f5a, 0x18b1a52e, 0xe2345e22, 0x2745c456, 0x0000de60, 0xc5714414, 0x3ff4bf18, 0xfa85256c, 0xddc0e13a, 0x18b17b4e, 0xe2348042, 0x27451a36}, - [16]uint32{0x00000000, 0x0e8888ff, 0x48fe3894, 0x4676b06b, 0x110030e5, 0x1f88b81a, 0x59fe0871, 0x5776808e, 0x10400802, 0x1ec880fd, 0x58be3096, 0x5636b869, 0x014038e7, 0x0fc8b018, 0x49be0073, 0x4736888c}, - [16]uint32{0x3f800000, 0x3f874444, 0x3fa47f1c, 0x3fa33b58, 0x3f888018, 0x3f8fc45c, 0x3facff04, 0x3fabbb40, 0x3f882004, 0x3f8f6440, 0x3fac5f18, 0x3fab1b5c, 0x3f80a01c, 0x3f87e458, 0x3fa4df00, 0x3fa39b44}, - uint32(0xfff80000), - [21]string{"0x91", "0x71", "0xf1", "0xf7", "0xcc", "0xd3", "0xf1", "0xeb", "0x3b", "0xbe", "0x48", "0xce", "0xf7", "0x31", "0x6f", "0xb2", "0x36", "0xe6", "0xcf", "0xba", "0x00"}}, - { - /* No.1014 delta:1054 weight:1197 */ - 11213, - 44, - 13, - 4, - [16]uint32{0x00000000, 0x7e6cd2cd, 0x7daaad80, 0x03c67f4d, 0x34203f60, 0x4a4cedad, 0x498a92e0, 0x37e6402d, 0x00003fd5, 0x7e6ced18, 0x7daa9255, 0x03c64098, 0x342000b5, 0x4a4cd278, 0x498aad35, 0x37e67ff8}, - [16]uint32{0x00000000, 0x2ca4c41a, 0x002f0993, 0x2c8bcd89, 0x0002013d, 0x2ca6c527, 0x002d08ae, 0x2c89ccb4, 0x00438806, 0x2ce74c1c, 0x006c8195, 0x2cc8458f, 0x0041893b, 0x2ce54d21, 0x006e80a8, 0x2cca44b2}, - [16]uint32{0x3f800000, 0x3f965262, 0x3f801784, 0x3f9645e6, 0x3f800100, 0x3f965362, 0x3f801684, 0x3f9644e6, 0x3f8021c4, 0x3f9673a6, 0x3f803640, 0x3f966422, 0x3f8020c4, 0x3f9672a6, 0x3f803740, 0x3f966522}, - uint32(0xfff80000), - [21]string{"0xf3", "0xd2", "0xdf", "0x25", "0xcb", "0x53", "0xec", "0x3a", "0xe7", "0x9a", "0xb2", "0xaf", "0xd0", "0xf8", "0x9d", "0x10", "0x85", "0xa5", "0xc2", "0x2b", "0x00"}}, - { - /* No.1015 delta:1206 weight:1699 */ - 11213, - 22, - 13, - 4, - [16]uint32{0x00000000, 0x4d3b8c26, 0x09dcafe9, 0x44e723cf, 0xc6403f72, 0x8b7bb354, 0xcf9c909b, 0x82a71cbd, 0x00007f56, 0x4d3bf370, 0x09dcd0bf, 0x44e75c99, 0xc6404024, 0x8b7bcc02, 0xcf9cefcd, 0x82a763eb}, - [16]uint32{0x00000000, 0x082311fc, 0x106441b1, 0x1847504d, 0x4021c11a, 0x4802d0e6, 0x504580ab, 0x58669157, 0x0041001f, 0x086211e3, 0x102541ae, 0x18065052, 0x4060c105, 0x4843d0f9, 0x500480b4, 0x58279148}, - [16]uint32{0x3f800000, 0x3f841188, 0x3f883220, 0x3f8c23a8, 0x3fa010e0, 0x3fa40168, 0x3fa822c0, 0x3fac3348, 0x3f802080, 0x3f843108, 0x3f8812a0, 0x3f8c0328, 0x3fa03060, 0x3fa421e8, 0x3fa80240, 0x3fac13c8}, - uint32(0xfff80000), - [21]string{"0xa8", "0x7e", "0xd5", "0x7b", "0x14", "0x3f", "0xcb", "0x47", "0xbd", "0x68", "0xf8", "0x0f", "0x06", "0x31", "0x8c", "0x36", "0xa8", "0xb3", "0xeb", "0x26", "0x00"}}, - { - /* No.1016 delta:867 weight:1603 */ - 11213, - 92, - 13, - 4, - [16]uint32{0x00000000, 0xebb78496, 0x7c29fda1, 0x979e7937, 0x69603f85, 0x82d7bb13, 0x1549c224, 0xfefe46b2, 0x00006b30, 0xebb7efa6, 0x7c299691, 0x979e1207, 0x696054b5, 0x82d7d023, 0x1549a914, 0xfefe2d82}, - [16]uint32{0x00000000, 0xa02a01fe, 0x007f0055, 0xa05501ab, 0x40021109, 0xe02810f7, 0x407d115c, 0xe05710a2, 0xa0201018, 0x000a11e6, 0xa05f104d, 0x007511b3, 0xe0220111, 0x400800ef, 0xe05d0144, 0x407700ba}, - [16]uint32{0x3f800000, 0x3fd01500, 0x3f803f80, 0x3fd02a80, 0x3fa00108, 0x3ff01408, 0x3fa03e88, 0x3ff02b88, 0x3fd01008, 0x3f800508, 0x3fd02f88, 0x3f803a88, 0x3ff01100, 0x3fa00400, 0x3ff02e80, 0x3fa03b80}, - uint32(0xfff80000), - [21]string{"0x82", "0x08", "0x6b", "0x6e", "0xb3", "0xcd", "0xe1", "0x30", "0xed", "0xd8", "0x57", "0x2d", "0x79", "0x60", "0xcb", "0xd7", "0xc6", "0xa6", "0x66", "0xd6", "0x00"}}, - { - /* No.1017 delta:1226 weight:1601 */ - 11213, - 23, - 13, - 4, - [16]uint32{0x00000000, 0xe28ad03e, 0xa9d5d7de, 0x4b5f07e0, 0xa9403f9d, 0x4bcaefa3, 0x0095e843, 0xe21f387d, 0x00005790, 0xe28a87ae, 0xa9d5804e, 0x4b5f5070, 0xa940680d, 0x4bcab833, 0x0095bfd3, 0xe21f6fed}, - [16]uint32{0x00000000, 0x006ff0f6, 0x00cb11db, 0x00a4e12d, 0x0035581c, 0x005aa8ea, 0x00fe49c7, 0x0091b931, 0x40004018, 0x406fb0ee, 0x40cb51c3, 0x40a4a135, 0x40351804, 0x405ae8f2, 0x40fe09df, 0x4091f929}, - [16]uint32{0x3f800000, 0x3f8037f8, 0x3f806588, 0x3f805270, 0x3f801aac, 0x3f802d54, 0x3f807f24, 0x3f8048dc, 0x3fa00020, 0x3fa037d8, 0x3fa065a8, 0x3fa05250, 0x3fa01a8c, 0x3fa02d74, 0x3fa07f04, 0x3fa048fc}, - uint32(0xfff80000), - [21]string{"0x2b", "0x5f", "0x37", "0xcc", "0xd1", "0xdc", "0x4e", "0x8c", "0x27", "0x03", "0x2d", "0x5e", "0x37", "0xa0", "0x70", "0xf7", "0x83", "0x13", "0x23", "0xc3", "0x00"}}, - { - /* No.1018 delta:1677 weight:1643 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x9237e603, 0x29a9dcee, 0xbb9e3aed, 0xee203fa7, 0x7c17d9a4, 0xc789e349, 0x55be054a, 0x0000bdfe, 0x92375bfd, 0x29a96110, 0xbb9e8713, 0xee208259, 0x7c17645a, 0xc7895eb7, 0x55beb8b4}, - [16]uint32{0x00000000, 0x001c00de, 0x4230812f, 0x422c81f1, 0x0000007a, 0x001c00a4, 0x42308155, 0x422c818b, 0x0020001d, 0x003c00c3, 0x42108132, 0x420c81ec, 0x00200067, 0x003c00b9, 0x42108148, 0x420c8196}, - [16]uint32{0x3f800000, 0x3f800e00, 0x3fa11840, 0x3fa11640, 0x3f800000, 0x3f800e00, 0x3fa11840, 0x3fa11640, 0x3f801000, 0x3f801e00, 0x3fa10840, 0x3fa10640, 0x3f801000, 0x3f801e00, 0x3fa10840, 0x3fa10640}, - uint32(0xfff80000), - [21]string{"0xdb", "0xc2", "0xfc", "0x35", "0xdf", "0xb4", "0x75", "0x74", "0x61", "0xc5", "0x18", "0xb4", "0x47", "0xdd", "0xbb", "0x1e", "0xad", "0x7d", "0x57", "0x23", "0x00"}}, - { - /* No.1019 delta:1941 weight:1341 */ - 11213, - 10, - 13, - 4, - [16]uint32{0x00000000, 0x0d026f1a, 0x27bc1805, 0x2abe771f, 0x34803fb6, 0x398250ac, 0x133c27b3, 0x1e3e48a9, 0x000093a9, 0x0d02fcb3, 0x27bc8bac, 0x2abee4b6, 0x3480ac1f, 0x3982c305, 0x133cb41a, 0x1e3edb00}, - [16]uint32{0x00000000, 0x18511afc, 0x080c8097, 0x105d9a6b, 0x403801fe, 0x58691b02, 0x48348169, 0x50659b95, 0x858400ff, 0x9dd51a03, 0x8d888068, 0x95d99a94, 0xc5bc0101, 0xdded1bfd, 0xcdb08196, 0xd5e19b6a}, - [16]uint32{0x3f800000, 0x3f8c288d, 0x3f840640, 0x3f882ecd, 0x3fa01c00, 0x3fac348d, 0x3fa41a40, 0x3fa832cd, 0x3fc2c200, 0x3fceea8d, 0x3fc6c440, 0x3fcaeccd, 0x3fe2de00, 0x3feef68d, 0x3fe6d840, 0x3feaf0cd}, - uint32(0xfff80000), - [21]string{"0x22", "0x7f", "0x5c", "0x66", "0xc3", "0xd8", "0x5a", "0xb7", "0x92", "0xf3", "0xd4", "0x9f", "0x85", "0xc6", "0x12", "0xb7", "0x76", "0xd1", "0x68", "0x03", "0x00"}}, - { - /* No.1020 delta:721 weight:1605 */ - 11213, - 73, - 13, - 4, - [16]uint32{0x00000000, 0xca7ce2f6, 0x8b08826e, 0x41746098, 0x6a403fca, 0xa03cdd3c, 0xe148bda4, 0x2b345f52, 0x00005812, 0xca7cbae4, 0x8b08da7c, 0x4174388a, 0x6a4067d8, 0xa03c852e, 0xe148e5b6, 0x2b340740}, - [16]uint32{0x00000000, 0x004f86d3, 0x00028151, 0x004d0782, 0x60041418, 0x604b92cb, 0x60069549, 0x6049139a, 0x2024014c, 0x206b879f, 0x2026801d, 0x206906ce, 0x40201554, 0x406f9387, 0x40229405, 0x406d12d6}, - [16]uint32{0x3f800000, 0x3f8027c3, 0x3f800140, 0x3f802683, 0x3fb0020a, 0x3fb025c9, 0x3fb0034a, 0x3fb02489, 0x3f901200, 0x3f9035c3, 0x3f901340, 0x3f903483, 0x3fa0100a, 0x3fa037c9, 0x3fa0114a, 0x3fa03689}, - uint32(0xfff80000), - [21]string{"0x0f", "0x36", "0x87", "0xb5", "0xbb", "0xa8", "0xa4", "0x64", "0x54", "0xf7", "0x51", "0x2d", "0xe6", "0x78", "0xae", "0xe4", "0xe5", "0x43", "0xa3", "0x71", "0x00"}}, - { - /* No.1021 delta:992 weight:1597 */ - 11213, - 62, - 13, - 4, - [16]uint32{0x00000000, 0x17394480, 0x757dbcc8, 0x6244f848, 0x62203fd7, 0x75197b57, 0x175d831f, 0x0064c79f, 0x00001bd6, 0x17395f56, 0x757da71e, 0x6244e39e, 0x62202401, 0x75196081, 0x175d98c9, 0x0064dc49}, - [16]uint32{0x00000000, 0x00ec09b2, 0x08028f55, 0x08ee86e7, 0x0003da8f, 0x00efd33d, 0x080155da, 0x08ed5c68, 0x3011a80a, 0x30fda1b8, 0x3813275f, 0x38ff2eed, 0x30127285, 0x30fe7b37, 0x3810fdd0, 0x38fcf462}, - [16]uint32{0x3f800000, 0x3f807604, 0x3f840147, 0x3f847743, 0x3f8001ed, 0x3f8077e9, 0x3f8400aa, 0x3f8476ae, 0x3f9808d4, 0x3f987ed0, 0x3f9c0993, 0x3f9c7f97, 0x3f980939, 0x3f987f3d, 0x3f9c087e, 0x3f9c7e7a}, - uint32(0xfff80000), - [21]string{"0xf4", "0xfd", "0xec", "0xfd", "0x45", "0xc7", "0xec", "0x82", "0x3b", "0x2a", "0x7c", "0xc0", "0x6f", "0x12", "0xa9", "0xa3", "0xe0", "0x0b", "0xa5", "0x20", "0x00"}}, - { - /* No.1022 delta:1082 weight:1417 */ - 11213, - 30, - 13, - 4, - [16]uint32{0x00000000, 0xb5f7cf48, 0xa67ec37a, 0x13890c32, 0x47903fe6, 0xf267f0ae, 0xe1eefc9c, 0x541933d4, 0x0000a5fe, 0xb5f76ab6, 0xa67e6684, 0x1389a9cc, 0x47909a18, 0xf2675550, 0xe1ee5962, 0x5419962a}, - [16]uint32{0x00000000, 0x0f637917, 0x008ab0d5, 0x0fe9c9c2, 0x0054c11e, 0x0f37b809, 0x00de71cb, 0x0fbd08dc, 0x0003701b, 0x0f60090c, 0x0089c0ce, 0x0feab9d9, 0x0057b105, 0x0f34c812, 0x00dd01d0, 0x0fbe78c7}, - [16]uint32{0x3f800000, 0x3f87b1bc, 0x3f804558, 0x3f87f4e4, 0x3f802a60, 0x3f879bdc, 0x3f806f38, 0x3f87de84, 0x3f8001b8, 0x3f87b004, 0x3f8044e0, 0x3f87f55c, 0x3f802bd8, 0x3f879a64, 0x3f806e80, 0x3f87df3c}, - uint32(0xfff80000), - [21]string{"0x08", "0x98", "0x08", "0x9b", "0xec", "0xc6", "0x5c", "0x9c", "0xbc", "0x51", "0xb5", "0x3d", "0xd8", "0x3c", "0xda", "0xed", "0xc3", "0x45", "0x06", "0x9b", "0x00"}}, - { - /* No.1023 delta:1423 weight:1727 */ - 11213, - 17, - 13, - 4, - [16]uint32{0x00000000, 0x97f9e40f, 0xa8734c40, 0x3f8aa84f, 0x40303ff2, 0xd7c9dbfd, 0xe84373b2, 0x7fba97bd, 0x0000577b, 0x97f9b374, 0xa8731b3b, 0x3f8aff34, 0x40306889, 0xd7c98c86, 0xe84324c9, 0x7fbac0c6}, - [16]uint32{0x00000000, 0x00c410ba, 0x20630b2d, 0x20a71b97, 0x0011ca04, 0x00d5dabe, 0x2072c129, 0x20b6d193, 0xa0242a1b, 0xa0e03aa1, 0x80472136, 0x8083318c, 0xa035e01f, 0xa0f1f0a5, 0x8056eb32, 0x8092fb88}, - [16]uint32{0x3f800000, 0x3f806208, 0x3f903185, 0x3f90538d, 0x3f8008e5, 0x3f806aed, 0x3f903960, 0x3f905b68, 0x3fd01215, 0x3fd0701d, 0x3fc02390, 0x3fc04198, 0x3fd01af0, 0x3fd078f8, 0x3fc02b75, 0x3fc0497d}, - uint32(0xfff80000), - [21]string{"0x09", "0xb8", "0x79", "0xb8", "0xb7", "0x72", "0xff", "0x62", "0x1d", "0xba", "0xc4", "0x21", "0x33", "0x96", "0xd3", "0x97", "0x35", "0x3b", "0x9d", "0x69", "0x00"}}, -} - -const mtgpdc_params_11213_num = 1023 diff --git a/opencl/oclRAND/mtgp32_typedef.txt b/opencl/oclRAND/mtgp32_typedef.txt index a48bace..c3f79ad 100644 --- a/opencl/oclRAND/mtgp32_typedef.txt +++ b/opencl/oclRAND/mtgp32_typedef.txt @@ -35,6 +35,7 @@ type MTGP32dc_params_array_ptr struct { Status_size int GroupSize int GroupCount int + ClCtx *cl.Context } func NewMTGPParams() *MTGP32dc_params_array_ptr { @@ -55,7 +56,7 @@ func (p *MTGP32dc_params_array_ptr) GetMTGPArrays() { pos_array := make([]int, p.GroupCount) sh1_array := make([]int, p.GroupCount) sh2_array := make([]int, p.GroupCount) - status_array := make([]uint32, MTGPDC_N * p.GroupCount) + status_array := make([]uint32, (MTGPDC_N * p.GroupCount)) for i := 0; i < p.GroupCount; i++ { for j := 0; j < MTGPDC_TS; j++ { rec_array[(i*MTGPDC_TS)+j] = MTGP32_params_fast_[i].tbl[j] @@ -121,6 +122,7 @@ func (p *MTGP32dc_params_array_ptr) CreateParamBuffers(context *cl.Context) { if err != nil { log.Fatalln("Unable to create buffer for MTGP32 status array!") } + p.SetContext(context) } func (p *MTGP32dc_params_array_ptr) LoadAllParamBuffersToDevice(eventWaitList []*cl.Event) ([]*cl.Event, error) { @@ -222,17 +224,29 @@ func (p *MTGP32dc_params_array_ptr) GetStatusArray() []uint32 { } func (p *MTGP32dc_params_array_ptr) SetGroupSize(in int) { - p.GroupSize = in + p.GroupSize = in } func (p *MTGP32dc_params_array_ptr) GetGroupSize() int { - return p.GroupSize + return p.GroupSize } func (p *MTGP32dc_params_array_ptr) SetGroupCount(in int) { - p.GroupCount = in + p.GroupCount = in } func (p *MTGP32dc_params_array_ptr) GetGroupCount() int { - return p.GroupCount + return p.GroupCount +} + +func (p *MTGP32dc_params_array_ptr) RecommendSize() int { + return 12 * p.GroupCount * MTGPDC_TN +} + +func (p *MTGP32dc_params_array_ptr) SetContext(context *cl.Context) { + p.ClCtx = context +} + +func (p *MTGP32dc_params_array_ptr) GetContext() *cl.Context { + return p.ClCtx } diff --git a/opencl/oclRAND/mtgp32dc-params-11213.go b/opencl/oclRAND/mtgp32dc-params-11213.go new file mode 100644 index 0000000..f84dac0 --- /dev/null +++ b/opencl/oclRAND/mtgp32dc-params-11213.go @@ -0,0 +1,11269 @@ +package oclRAND + +var MTGP32_params_fast_11213 = []MTGP32dc_params_fast_t{ + { + /* No.0 delta:1924 weight:1595 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x4f909277,0xd506358c,0x9a96a7fb,0xecc00000,0xa3509277,0x39c6358c,0x7656a7fb,0x00009fd9,0x4f900dae,0xd506aa55,0x9a963822,0xecc09fd9,0xa3500dae,0x39c6aa55,0x76563822}, + [16]uint32{0x00000000,0x007c4132,0x2b4020ed,0x2b3c61df,0x000240a5,0x007e0197,0x2b426048,0x2b3e217a,0x00414015,0x003d0127,0x2b0160f8,0x2b7d21ca,0x004300b0,0x003f4182,0x2b03205d,0x2b7f616f}, + [16]uint32{0x3f800000,0x3f803e20,0x3f95a010,0x3f959e30,0x3f800120,0x3f803f00,0x3f95a130,0x3f959f10,0x3f8020a0,0x3f801e80,0x3f9580b0,0x3f95be90,0x3f802180,0x3f801fa0,0x3f958190,0x3f95bfb0}, + uint32(0xfff80000), + [21]string{"0x43","0x93","0x2a","0x2d","0x4c","0xab","0x4c","0xd3","0x8f","0xfb","0x1e","0xdd","0x5e","0x1a","0xbb","0x08","0x92","0x84","0x17","0x63","0x00"} }, + { + /* No.1 delta:2138 weight:1245 */ + 11213, + 36, + 13, + 4, + [16]uint32{0x00000000,0x04e7bdd9,0xbd4135d8,0xb9a68801,0xf0c00015,0xf427bdcc,0x4d8135cd,0x49668814,0x0000e79e,0x04e75a47,0xbd41d246,0xb9a66f9f,0xf0c0e78b,0xf4275a52,0x4d81d253,0x49666f8a}, + [16]uint32{0x00000000,0x007802fe,0x0084013b,0x00fc03c5,0x00060156,0x007e03a8,0x0082006d,0x00fa0293,0x0004001a,0x007c02e4,0x00800121,0x00f803df,0x0002014c,0x007a03b2,0x00860077,0x00fe0289}, + [16]uint32{0x3f800000,0x3f803c01,0x3f804200,0x3f807e01,0x3f800300,0x3f803f01,0x3f804100,0x3f807d01,0x3f800200,0x3f803e01,0x3f804000,0x3f807c01,0x3f800100,0x3f803d01,0x3f804300,0x3f807f01}, + uint32(0xfff80000), + [21]string{"0xda","0xdf","0x57","0xe8","0xbe","0xba","0x9b","0x01","0x23","0xe2","0x5d","0x4b","0x41","0xf7","0xb2","0x6b","0x77","0x6f","0x03","0xd0","0x00"} }, + { + /* No.2 delta:3099 weight:651 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x7f1f322e,0xd937af30,0xa6289d1e,0x0940002c,0x765f3202,0xd077af1c,0xaf689d32,0x00001134,0x7f1f231a,0xd937be04,0xa6288c2a,0x09401118,0x765f2336,0xd077be28,0xaf688c06}, + [16]uint32{0x00000000,0x824a98bb,0x24000749,0xa64a9ff2,0x49208c71,0xcb6a14ca,0x6d208b38,0xef6a1383,0x0cd00f55,0x8e9a97ee,0x28d0081c,0xaa9a90a7,0x45f08324,0xc7ba1b9f,0x61f0846d,0xe3ba1cd6}, + [16]uint32{0x3f800000,0x3fc1254c,0x3f920003,0x3fd3254f,0x3fa49046,0x3fe5b50a,0x3fb69045,0x3ff7b509,0x3f866807,0x3fc74d4b,0x3f946804,0x3fd54d48,0x3fa2f841,0x3fe3dd0d,0x3fb0f842,0x3ff1dd0e}, + uint32(0xfff80000), + [21]string{"0x6f","0xaa","0x42","0x5f","0x0c","0xc0","0x2d","0x43","0xf7","0xd3","0x08","0xe8","0xa4","0xf5","0x90","0xf9","0x21","0x33","0x77","0x99","0x00"} }, + { + /* No.3 delta:1149 weight:1465 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x62e3424e,0xefb75beb,0x8d5419a5,0x40100039,0x22f34277,0xafa75bd2,0xcd44199c,0x000028cd,0x62e36a83,0xefb77326,0x8d543168,0x401028f4,0x22f36aba,0xafa7731f,0xcd443151}, + [16]uint32{0x00000000,0x2047d296,0x600c0c1f,0x404bde89,0x3022e17a,0x106533ec,0x502eed65,0x70693ff3,0x0003c01d,0x2044128b,0x600fcc02,0x40481e94,0x30212167,0x1066f3f1,0x502d2d78,0x706affee}, + [16]uint32{0x3f800000,0x3f9023e9,0x3fb00606,0x3fa025ef,0x3f981170,0x3f883299,0x3fa81776,0x3fb8349f,0x3f8001e0,0x3f902209,0x3fb007e6,0x3fa0240f,0x3f981090,0x3f883379,0x3fa81696,0x3fb8357f}, + uint32(0xfff80000), + [21]string{"0xfb","0x19","0xb8","0xaa","0x2c","0x32","0xc9","0x9e","0x0d","0xae","0xf2","0x6e","0x0e","0xe4","0x9b","0x81","0x41","0xe7","0xa0","0xb4","0x00"} }, + { + /* No.4 delta:1024 weight:1407 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x477707e5,0x4312f2cf,0x0465f52a,0x7c10004e,0x3b6707ab,0x3f02f281,0x7875f564,0x0000fcc0,0x4777fb25,0x43120e0f,0x046509ea,0x7c10fc8e,0x3b67fb6b,0x3f020e41,0x787509a4}, + [16]uint32{0x00000000,0x600c0cde,0x000c9193,0x60009d4d,0x4000d35f,0x200cdf81,0x400c42cc,0x20004e12,0x10408219,0x704c8ec7,0x104c138a,0x70401f54,0x50405146,0x304c5d98,0x504cc0d5,0x3040cc0b}, + [16]uint32{0x3f800000,0x3fb00606,0x3f800648,0x3fb0004e,0x3fa00069,0x3f90066f,0x3fa00621,0x3f900027,0x3f882041,0x3fb82647,0x3f882609,0x3fb8200f,0x3fa82028,0x3f98262e,0x3fa82660,0x3f982066}, + uint32(0xfff80000), + [21]string{"0xaa","0x61","0xae","0x97","0xb0","0xc9","0x61","0x3b","0x8c","0x50","0xd3","0xba","0xe7","0x18","0xe0","0xe4","0xd0","0xfb","0x02","0xc8","0x00"} }, + { + /* No.5 delta:935 weight:1239 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x16f2897a,0x078f68af,0x117de1d5,0xe1100050,0xf7e2892a,0xe69f68ff,0xf06de185,0x00005520,0x16f2dc5a,0x078f3d8f,0x117db4f5,0xe1105570,0xf7e2dc0a,0xe69f3ddf,0xf06db4a5}, + [16]uint32{0x00000000,0x6006f596,0x00a6008a,0x60a0f51c,0x2002a409,0x4004519f,0x20a4a483,0x40a25115,0x2001e8ee,0x40071d78,0x20a7e864,0x40a11df2,0x00034ce7,0x6005b971,0x00a54c6d,0x60a3b9fb}, + [16]uint32{0x3f800000,0x3fb0037a,0x3f805300,0x3fb0507a,0x3f900152,0x3fa00228,0x3f905252,0x3fa05128,0x3f9000f4,0x3fa0038e,0x3f9053f4,0x3fa0508e,0x3f8001a6,0x3fb002dc,0x3f8052a6,0x3fb051dc}, + uint32(0xfff80000), + [21]string{"0x75","0xae","0x88","0x03","0x75","0xde","0x93","0x7e","0xa0","0x4e","0xfd","0xb2","0x06","0x47","0x4c","0x5a","0x7f","0xa6","0x68","0xf0","0x00"} }, + { + /* No.6 delta:2636 weight:1479 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xa236b2f7,0x673cd97c,0xc50a6b8b,0x0740006f,0xa576b298,0x607cd913,0xc24a6be4,0x0000a23f,0xa23610c8,0x673c7b43,0xc50ac9b4,0x0740a250,0xa57610a7,0x607c7b2c,0xc24ac9db}, + [16]uint32{0x00000000,0x0003441a,0x1002681f,0x10012c05,0x2000b20d,0x2003f617,0x3002da12,0x30019e08,0x2000001b,0x20034401,0x30026804,0x30012c1e,0x0000b216,0x0003f60c,0x1002da09,0x10019e13}, + [16]uint32{0x3f800000,0x3f8001a2,0x3f880134,0x3f880096,0x3f900059,0x3f9001fb,0x3f98016d,0x3f9800cf,0x3f900000,0x3f9001a2,0x3f980134,0x3f980096,0x3f800059,0x3f8001fb,0x3f88016d,0x3f8800cf}, + uint32(0xfff80000), + [21]string{"0xff","0xdb","0x7b","0xc1","0xcb","0xf5","0x52","0x32","0x4d","0x74","0xd0","0xbb","0x88","0x29","0x89","0x26","0xba","0x41","0x92","0xe3","0x00"} }, + { + /* No.7 delta:1036 weight:1615 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x13dc0d56,0xfcc23381,0xef1e3ed7,0x65e00072,0x763c0d24,0x992233f3,0x8afe3ea5,0x00003944,0x13dc3412,0xfcc20ac5,0xef1e0793,0x65e03936,0x763c3460,0x99220ab7,0x8afe07e1}, + [16]uint32{0x00000000,0x304c1192,0x0002c01d,0x304ed18f,0x60482c07,0x50043d95,0x604aec1a,0x5006fd88,0x600001c4,0x504c1056,0x6002c1d9,0x504ed04b,0x00482dc3,0x30043c51,0x004aedde,0x3006fc4c}, + [16]uint32{0x3f800000,0x3f982608,0x3f800160,0x3f982768,0x3fb02416,0x3fa8021e,0x3fb02576,0x3fa8037e,0x3fb00000,0x3fa82608,0x3fb00160,0x3fa82768,0x3f802416,0x3f98021e,0x3f802576,0x3f98037e}, + uint32(0xfff80000), + [21]string{"0xf5","0x20","0xa8","0x18","0xff","0xcc","0xac","0xc9","0x44","0xd4","0x78","0x19","0x0a","0x78","0x20","0x63","0xe8","0x72","0x36","0x71","0x00"} }, + { + /* No.8 delta:1185 weight:1437 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x8ffabd15,0x251190b0,0xaaeb2da5,0x6180008a,0xee7abd9f,0x4491903a,0xcb6b2d2f,0x00003391,0x8ffa8e84,0x2511a321,0xaaeb1e34,0x6180331b,0xee7a8e0e,0x4491a3ab,0xcb6b1ebe}, + [16]uint32{0x00000000,0x087422da,0x0002d1fd,0x0876f327,0x9010009e,0x98642244,0x9012d163,0x9866f3b9,0x506880d6,0x581ca20c,0x506a512b,0x581e73f1,0xc0788048,0xc80ca292,0xc07a51b5,0xc80e736f}, + [16]uint32{0x3f800000,0x3f843a11,0x3f800168,0x3f843b79,0x3fc80800,0x3fcc3211,0x3fc80968,0x3fcc3379,0x3fa83440,0x3fac0e51,0x3fa83528,0x3fac0f39,0x3fe03c40,0x3fe40651,0x3fe03d28,0x3fe40739}, + uint32(0xfff80000), + [21]string{"0xe8","0x7d","0x49","0xd8","0x59","0xcb","0xa2","0xaa","0xce","0xb9","0xd8","0xd9","0x4e","0x89","0xff","0x1e","0xc6","0x5c","0x9c","0x62","0x00"} }, + { + /* No.9 delta:940 weight:1557 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x75b471ab,0xa13c72ac,0xd4880307,0x64d00099,0x11647132,0xc5ec7235,0xb058039e,0x00007a74,0x75b40bdf,0xa13c08d8,0xd4887973,0x64d07aed,0x11640b46,0xc5ec0841,0xb05879ea}, + [16]uint32{0x00000000,0x0001f4d5,0x104e140e,0x104fe0db,0x20022818,0x2003dccd,0x304c3c16,0x304dc8c3,0x2000278c,0x2001d359,0x304e3382,0x304fc757,0x00020f94,0x0003fb41,0x104c1b9a,0x104def4f}, + [16]uint32{0x3f800000,0x3f8000fa,0x3f88270a,0x3f8827f0,0x3f900114,0x3f9001ee,0x3f98261e,0x3f9826e4,0x3f900013,0x3f9000e9,0x3f982719,0x3f9827e3,0x3f800107,0x3f8001fd,0x3f88260d,0x3f8826f7}, + uint32(0xfff80000), + [21]string{"0xf3","0x2e","0xad","0xf6","0x6f","0x50","0x04","0xb1","0x67","0x86","0x75","0x45","0x70","0x60","0x5d","0x63","0xaf","0x93","0x7f","0xa0","0x00"} }, + { + /* No.10 delta:2070 weight:1315 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0xaff041eb,0x194d1f47,0xb6bd5eac,0x58a000a5,0xf750414e,0x41ed1fe2,0xee1d5e09,0x0000bcbf,0xaff0fd54,0x194da3f8,0xb6bde213,0x58a0bc1a,0xf750fdf1,0x41eda35d,0xee1de2b6}, + [16]uint32{0x00000000,0x1082801b,0x0800e183,0x18826198,0x009c291f,0x101ea904,0x089cc89c,0x181e4887,0x60002519,0x7082a502,0x6800c49a,0x78824481,0x609c0c06,0x701e8c1d,0x689ced85,0x781e6d9e}, + [16]uint32{0x3f800000,0x3f884140,0x3f840070,0x3f8c4130,0x3f804e14,0x3f880f54,0x3f844e64,0x3f8c0f24,0x3fb00012,0x3fb84152,0x3fb40062,0x3fbc4122,0x3fb04e06,0x3fb80f46,0x3fb44e76,0x3fbc0f36}, + uint32(0xfff80000), + [21]string{"0x5d","0x09","0x8c","0x60","0x3e","0xd8","0x24","0xaf","0x49","0xc9","0xa3","0x2e","0xab","0x4f","0xb4","0xe6","0x15","0x68","0xd1","0x47","0x00"} }, + { + /* No.11 delta:1515 weight:1659 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x98993010,0xd2526ec9,0x4acb5ed9,0x148000b8,0x8c1930a8,0xc6d26e71,0x5e4b5e61,0x00004381,0x98997391,0xd2522d48,0x4acb1d58,0x14804339,0x8c197329,0xc6d22df0,0x5e4b1de0}, + [16]uint32{0x00000000,0x1f8f2033,0x2051c174,0x3fdee147,0x2121601a,0x3eae4029,0x0170a16e,0x1eff815d,0x00412412,0x1fce0421,0x2010e566,0x3f9fc555,0x21604408,0x3eef643b,0x0131857c,0x1ebea54f}, + [16]uint32{0x3f800000,0x3f8fc790,0x3f9028e0,0x3f9fef70,0x3f9090b0,0x3f9f5720,0x3f80b850,0x3f8f7fc0,0x3f802092,0x3f8fe702,0x3f900872,0x3f9fcfe2,0x3f90b022,0x3f9f77b2,0x3f8098c2,0x3f8f5f52}, + uint32(0xfff80000), + [21]string{"0xbe","0x72","0x05","0x26","0xcb","0xaa","0x6d","0x25","0xac","0xaf","0x9c","0x2f","0xe1","0xe7","0x35","0x3c","0x6e","0x4e","0x4b","0x24","0x00"} }, + { + /* No.12 delta:820 weight:1581 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xddfffc66,0x11479e19,0xccb8627f,0x8d1000c6,0x50effca0,0x9c579edf,0x41a862b9,0x00004882,0xddffb4e4,0x1147d69b,0xccb82afd,0x8d104844,0x50efb422,0x9c57d65d,0x41a82a3b}, + [16]uint32{0x00000000,0x000d341f,0x7001d194,0x700ce58b,0x0122201d,0x012f1402,0x7123f189,0x712ec596,0x040d80b7,0x0400b4a8,0x740c5123,0x7401653c,0x052fa0aa,0x052294b5,0x752e713e,0x75234521}, + [16]uint32{0x3f800000,0x3f80069a,0x3fb800e8,0x3fb80672,0x3f809110,0x3f80978a,0x3fb891f8,0x3fb89762,0x3f8206c0,0x3f82005a,0x3fba0628,0x3fba00b2,0x3f8297d0,0x3f82914a,0x3fba9738,0x3fba91a2}, + uint32(0xfff80000), + [21]string{"0x6e","0xf5","0x55","0xa0","0x30","0x84","0x66","0xdc","0xa6","0x4a","0x52","0xe1","0xd8","0x99","0x66","0x12","0xd7","0x4b","0x83","0x2c","0x00"} }, + { + /* No.13 delta:707 weight:1529 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0x9b47b275,0x3b5e5ca5,0xa019eed0,0x72c000d6,0xe987b2a3,0x499e5c73,0xd2d9ee06,0x000090c6,0x9b4722b3,0x3b5ecc63,0xa0197e16,0x72c09010,0xe9872265,0x499eccb5,0xd2d97ec0}, + [16]uint32{0x00000000,0x2068289d,0x10121266,0x307a3afb,0x201641bf,0x007e6922,0x300453d9,0x106c7b44,0x00120017,0x207a288a,0x10001271,0x30683aec,0x200441a8,0x006c6935,0x301653ce,0x107e7b53}, + [16]uint32{0x3f800000,0x3f903414,0x3f880909,0x3f983d1d,0x3f900b20,0x3f803f34,0x3f980229,0x3f88363d,0x3f800900,0x3f903d14,0x3f880009,0x3f98341d,0x3f900220,0x3f803634,0x3f980b29,0x3f883f3d}, + uint32(0xfff80000), + [21]string{"0x24","0xca","0x5b","0xd7","0x52","0x91","0x29","0xca","0xa8","0x9b","0x1b","0x5e","0xb6","0x1d","0x1e","0x72","0x3d","0x9d","0xdb","0x31","0x00"} }, + { + /* No.14 delta:740 weight:1357 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0xa4ded64e,0xeb88426b,0x4f569425,0x56d000e9,0xf20ed6a7,0xbd584282,0x198694cc,0x0000e140,0xa4de370e,0xeb88a32b,0x4f567565,0x56d0e1a9,0xf20e37e7,0xbd58a3c2,0x1986758c}, + [16]uint32{0x00000000,0x00031972,0x20046011,0x20077963,0x40081018,0x400b096a,0x600c7009,0x600f697b,0x4140013c,0x4143184e,0x6144612d,0x6147785f,0x01481124,0x014b0856,0x214c7135,0x214f6847}, + [16]uint32{0x3f800000,0x3f80018c,0x3f900230,0x3f9003bc,0x3fa00408,0x3fa00584,0x3fb00638,0x3fb007b4,0x3fa0a000,0x3fa0a18c,0x3fb0a230,0x3fb0a3bc,0x3f80a408,0x3f80a584,0x3f90a638,0x3f90a7b4}, + uint32(0xfff80000), + [21]string{"0xc3","0x74","0x1c","0x60","0x3b","0xf4","0xad","0x34","0x2e","0x3d","0xf9","0xde","0x63","0x53","0xf9","0xe5","0xcf","0x78","0x9a","0x9d","0x00"} }, + { + /* No.15 delta:1412 weight:1175 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xd5f40b06,0x9e909b5e,0x4b649058,0xd5b000f1,0x00440bf7,0x4b209baf,0x9ed490a9,0x00006d10,0xd5f46616,0x9e90f64e,0x4b64fd48,0xd5b06de1,0x004466e7,0x4b20f6bf,0x9ed4fdb9}, + [16]uint32{0x00000000,0x0035813a,0x104ac0ec,0x107f41d6,0x00024054,0x0037c16e,0x104880b8,0x107d0182,0x100040a4,0x1035c19e,0x004a8048,0x007f0172,0x100200f0,0x103781ca,0x0048c01c,0x007d4126}, + [16]uint32{0x3f800000,0x3f801ac0,0x3f882560,0x3f883fa0,0x3f800120,0x3f801be0,0x3f882440,0x3f883e80,0x3f880020,0x3f881ae0,0x3f802540,0x3f803f80,0x3f880100,0x3f881bc0,0x3f802460,0x3f803ea0}, + uint32(0xfff80000), + [21]string{"0x1c","0xc5","0xf3","0xcc","0xc0","0xa1","0xf5","0x12","0xe1","0x21","0x45","0x6c","0x8c","0xe8","0x81","0x31","0xc4","0x16","0xc8","0x01","0x00"} }, + { + /* No.16 delta:829 weight:1511 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0x6a4ed196,0x75986580,0x1fd6b416,0xb6f00102,0xdcbed094,0xc3686482,0xa926b514,0x0000ff65,0x6a4e2ef3,0x75989ae5,0x1fd64b73,0xb6f0fe67,0xdcbe2ff1,0xc3689be7,0xa9264a71}, + [16]uint32{0x00000000,0x4024d5d3,0x4060c1ff,0x0044142c,0x003141b5,0x40159466,0x4051804a,0x00755599,0x000241de,0x4026940d,0x40628021,0x004655f2,0x0033006b,0x4017d5b8,0x4053c194,0x00771447}, + [16]uint32{0x3f800000,0x3fa0126a,0x3fa03060,0x3f80220a,0x3f8018a0,0x3fa00aca,0x3fa028c0,0x3f803aaa,0x3f800120,0x3fa0134a,0x3fa03140,0x3f80232a,0x3f801980,0x3fa00bea,0x3fa029e0,0x3f803b8a}, + uint32(0xfff80000), + [21]string{"0x90","0xef","0xab","0xea","0x9a","0x3e","0x54","0x08","0xd7","0x59","0x31","0x77","0x70","0x41","0x3a","0x49","0x1d","0x02","0xc8","0x4d","0x00"} }, + { + /* No.17 delta:939 weight:1249 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x9b6dd2da,0x7a47766d,0xe12aa4b7,0x28b00115,0xb3ddd3cf,0x52f77778,0xc99aa5a2,0x0000ac7e,0x9b6d7ea4,0x7a47da13,0xe12a08c9,0x28b0ad6b,0xb3dd7fb1,0x52f7db06,0xc99a09dc}, + [16]uint32{0x00000000,0x0074455a,0x10038197,0x1077c4cd,0x00027014,0x0076354e,0x1001f183,0x1075b4d9,0x100a0011,0x107e454b,0x00098186,0x007dc4dc,0x10087005,0x107c355f,0x000bf192,0x007fb4c8}, + [16]uint32{0x3f800000,0x3f803a22,0x3f8801c0,0x3f883be2,0x3f800138,0x3f803b1a,0x3f8800f8,0x3f883ada,0x3f880500,0x3f883f22,0x3f8004c0,0x3f803ee2,0x3f880438,0x3f883e1a,0x3f8005f8,0x3f803fda}, + uint32(0xfff80000), + [21]string{"0x1d","0x4d","0xd6","0x26","0x63","0x10","0x49","0x3c","0xd2","0x16","0xf9","0xb1","0xc2","0x24","0x34","0xcf","0x7d","0x43","0x28","0xcb","0x00"} }, + { + /* No.18 delta:1038 weight:1423 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xb32bc1dd,0x940d95ad,0x27265470,0x4bb0012e,0xf89bc0f3,0xdfbd9483,0x6c96555e,0x0000d383,0xb32b125e,0x940d462e,0x272687f3,0x4bb0d2ad,0xf89b1370,0xdfbd4700,0x6c9686dd}, + [16]uint32{0x00000000,0x100c2016,0x0003a04f,0x100f8059,0x2040861d,0x304ca60b,0x20432652,0x304f0644,0x0050ea1f,0x105cca09,0x00534a50,0x105f6a46,0x20106c02,0x301c4c14,0x2013cc4d,0x301fec5b}, + [16]uint32{0x3f800000,0x3f880610,0x3f8001d0,0x3f8807c0,0x3f902043,0x3f982653,0x3f902193,0x3f982783,0x3f802875,0x3f882e65,0x3f8029a5,0x3f882fb5,0x3f900836,0x3f980e26,0x3f9009e6,0x3f980ff6}, + uint32(0xfff80000), + [21]string{"0x64","0x79","0xc7","0x6f","0xcc","0x48","0x7c","0x0a","0x43","0xe9","0x95","0xcd","0x1c","0x2d","0xa0","0xc0","0x7e","0x12","0xc2","0xf7","0x00"} }, + { + /* No.19 delta:2427 weight:765 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0xbd514c94,0xd2534abd,0x6f020629,0xbf20013d,0x02714da9,0x6d734b80,0xd0220714,0x00002d73,0xbd5161e7,0xd25367ce,0x6f022b5a,0xbf202c4e,0x027160da,0x6d7366f3,0xd0222a67}, + [16]uint32{0x00000000,0x19a54197,0x106021ca,0x09c5605d,0x101000ff,0x09b54168,0x00702135,0x19d560a2,0x004800b0,0x19ed4127,0x1028217a,0x098d60ed,0x1058004f,0x09fd41d8,0x00382185,0x199d6012}, + [16]uint32{0x3f800000,0x3f8cd2a0,0x3f883010,0x3f84e2b0,0x3f880800,0x3f84daa0,0x3f803810,0x3f8ceab0,0x3f802400,0x3f8cf6a0,0x3f881410,0x3f84c6b0,0x3f882c00,0x3f84fea0,0x3f801c10,0x3f8cceb0}, + uint32(0xfff80000), + [21]string{"0x7d","0x7c","0x61","0x34","0xcc","0xaf","0xb1","0x1c","0xa1","0xe8","0x1d","0xb4","0xa9","0x8f","0x15","0x98","0xd1","0xba","0x42","0x9b","0x00"} }, + { + /* No.20 delta:1784 weight:1485 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0xfeb307f4,0x3c1e7eea,0xc2ad791e,0x33d00140,0xcd6306b4,0x0fce7faa,0xf17d785e,0x00007ab3,0xfeb37d47,0x3c1e0459,0xc2ad03ad,0x33d07bf3,0xcd637c07,0x0fce0519,0xf17d02ed}, + [16]uint32{0x00000000,0x0ae69956,0x54269098,0x5ec009ce,0x304007d5,0x3aa69e83,0x6466974d,0x6e800e1b,0x0059801d,0x0abf194b,0x547f1085,0x5e9989d3,0x301987c8,0x3aff1e9e,0x643f1750,0x6ed98e06}, + [16]uint32{0x3f800000,0x3f85734c,0x3faa1348,0x3faf6004,0x3f982003,0x3f9d534f,0x3fb2334b,0x3fb74007,0x3f802cc0,0x3f855f8c,0x3faa3f88,0x3faf4cc4,0x3f980cc3,0x3f9d7f8f,0x3fb21f8b,0x3fb76cc7}, + uint32(0xfff80000), + [21]string{"0x3f","0xcf","0x58","0xca","0x42","0x13","0xe5","0xd0","0x0f","0x09","0x0b","0x67","0x5b","0xb8","0x8c","0x3d","0x2c","0xd8","0xef","0x68","0x00"} }, + { + /* No.21 delta:974 weight:1601 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0x2554da2a,0xc20d8e4e,0xe7595464,0xd500015a,0xf054db70,0x170d8f14,0x3259553e,0x0000b8c9,0x255462e3,0xc20d3687,0xe759ecad,0xd500b993,0xf05463b9,0x170d37dd,0x3259edf7}, + [16]uint32{0x00000000,0x000264d6,0x00010c23,0x000368f5,0x102ca1fb,0x102ec52d,0x102dadd8,0x102fc90e,0xf01c200a,0xf01e44dc,0xf01d2c29,0xf01f48ff,0xe03081f1,0xe032e527,0xe0318dd2,0xe033e904}, + [16]uint32{0x3f800000,0x3f800132,0x3f800086,0x3f8001b4,0x3f881650,0x3f881762,0x3f8816d6,0x3f8817e4,0x3ff80e10,0x3ff80f22,0x3ff80e96,0x3ff80fa4,0x3ff01840,0x3ff01972,0x3ff018c6,0x3ff019f4}, + uint32(0xfff80000), + [21]string{"0x49","0xb2","0x44","0x10","0x53","0x58","0xa0","0x92","0xcc","0x3a","0xbc","0x4f","0x77","0x55","0xeb","0x20","0xc6","0xbf","0x94","0x54","0x00"} }, + { + /* No.22 delta:3113 weight:577 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x1c0fe41b,0x17e3e180,0x0bec059b,0x3210016f,0x2e1fe574,0x25f3e0ef,0x39fc04f4,0x0000f40c,0x1c0f1017,0x17e3158c,0x0becf197,0x3210f563,0x2e1f1178,0x25f314e3,0x39fcf0f8}, + [16]uint32{0x00000000,0x8800a03e,0x4c6061c3,0xc460c1fd,0x0e210048,0x8621a076,0x4241618b,0xca41c1b5,0x84304150,0x0c30e16e,0xc8502093,0x405080ad,0x8a114118,0x0211e126,0xc67120db,0x4e7180e5}, + [16]uint32{0x3f800000,0x3fc40050,0x3fa63030,0x3fe23060,0x3f871080,0x3fc310d0,0x3fa120b0,0x3fe520e0,0x3fc21820,0x3f861870,0x3fe42810,0x3fa02840,0x3fc508a0,0x3f8108f0,0x3fe33890,0x3fa738c0}, + uint32(0xfff80000), + [21]string{"0xd3","0x3b","0x23","0x49","0xd1","0x4b","0xe8","0xf0","0x12","0xf9","0x95","0xf9","0x30","0x1c","0xa0","0xc1","0xa7","0xc7","0xb2","0xb2","0x00"} }, + { + /* No.23 delta:2078 weight:1299 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x81f19cc8,0x40d67766,0xc127ebae,0xbbb0017f,0x3a419db7,0xfb667619,0x7a97ead1,0x00003964,0x81f1a5ac,0x40d64e02,0xc127d2ca,0xbbb0381b,0x3a41a4d3,0xfb664f7d,0x7a97d3b5}, + [16]uint32{0x00000000,0x0106027a,0x0024013f,0x01220345,0x0070002b,0x01760251,0x00540114,0x0152036e,0x004c00bd,0x014a02c7,0x00680182,0x016e03f8,0x003c0096,0x013a02ec,0x001801a9,0x011e03d3}, + [16]uint32{0x3f800000,0x3f808301,0x3f801200,0x3f809101,0x3f803800,0x3f80bb01,0x3f802a00,0x3f80a901,0x3f802600,0x3f80a501,0x3f803400,0x3f80b701,0x3f801e00,0x3f809d01,0x3f800c00,0x3f808f01}, + uint32(0xfff80000), + [21]string{"0x75","0x55","0x0b","0x56","0x9a","0x7d","0xe4","0xa5","0x47","0x15","0x33","0xb5","0x32","0x55","0x1d","0xbd","0x42","0x5c","0x06","0xb4","0x00"} }, + { + /* No.24 delta:765 weight:721 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0xa44b9eb8,0xb66d2770,0x1226b9c8,0xa7400180,0x030b9f38,0x112d26f0,0xb566b848,0x000093e2,0xa44b0d5a,0xb66db492,0x12262a2a,0xa7409262,0x030b0cda,0x112db512,0xb5662baa}, + [16]uint32{0x00000000,0x206c4d57,0x40044405,0x60680952,0x7042401b,0x502e0d4c,0x3046041e,0x102a4949,0x70200204,0x504c4f53,0x30244601,0x10480b56,0x0062421f,0x200e0f48,0x4066061a,0x600a4b4d}, + [16]uint32{0x3f800000,0x3f903626,0x3fa00222,0x3fb03404,0x3fb82120,0x3fa81706,0x3f982302,0x3f881524,0x3fb81001,0x3fa82627,0x3f981223,0x3f882405,0x3f803121,0x3f900707,0x3fa03303,0x3fb00525}, + uint32(0xfff80000), + [21]string{"0x7f","0xad","0x7b","0xd7","0x2d","0x36","0xd7","0x2e","0xea","0xde","0x5a","0x26","0xe0","0x66","0x33","0x76","0x48","0x3d","0x70","0x76","0x00"} }, + { + /* No.25 delta:1491 weight:1691 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xa197c538,0x2189e50a,0x801e2032,0xbe900193,0x1f07c4ab,0x9f19e499,0x3e8e21a1,0x000019a2,0xa197dc9a,0x2189fca8,0x801e3990,0xbe901831,0x1f07dd09,0x9f19fd3b,0x3e8e3803}, + [16]uint32{0x00000000,0x0cb682dc,0x21840a6e,0x2d3288b2,0x0050d01d,0x0ce652c1,0x21d4da73,0x2d6258af,0x00201614,0x0c9694c8,0x21a41c7a,0x2d129ea6,0x0070c609,0x0cc644d5,0x21f4cc67,0x2d424ebb}, + [16]uint32{0x3f800000,0x3f865b41,0x3f90c205,0x3f969944,0x3f802868,0x3f867329,0x3f90ea6d,0x3f96b12c,0x3f80100b,0x3f864b4a,0x3f90d20e,0x3f96894f,0x3f803863,0x3f866322,0x3f90fa66,0x3f96a127}, + uint32(0xfff80000), + [21]string{"0x23","0x39","0x98","0xe2","0x20","0xce","0x7e","0x4a","0xf3","0x5f","0x8a","0xa2","0x7c","0xaf","0x4c","0x20","0x4b","0x3c","0x2a","0x3e","0x00"} }, + { + /* No.26 delta:1271 weight:1733 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0xd060775e,0xa2b1b9c5,0x72d1ce9b,0x97f001a8,0x479076f6,0x3541b86d,0xe521cf33,0x0000a701,0xd060d05f,0xa2b11ec4,0x72d1699a,0x97f0a6a9,0x4790d1f7,0x35411f6c,0xe5216832}, + [16]uint32{0x00000000,0x1c6bc8f4,0x006c38db,0x1c07f02f,0x00501012,0x1c3bd8e6,0x003c28c9,0x1c57e03d,0x000f2417,0x1c64ece3,0x00631ccc,0x1c08d438,0x005f3405,0x1c34fcf1,0x00330cde,0x1c58c42a}, + [16]uint32{0x3f800000,0x3f8e35e4,0x3f80361c,0x3f8e03f8,0x3f802808,0x3f8e1dec,0x3f801e14,0x3f8e2bf0,0x3f800792,0x3f8e3276,0x3f80318e,0x3f8e046a,0x3f802f9a,0x3f8e1a7e,0x3f801986,0x3f8e2c62}, + uint32(0xfff80000), + [21]string{"0x2b","0x91","0x85","0xa8","0xca","0xa6","0x3a","0xf1","0x2d","0xea","0x12","0x7d","0x47","0xb4","0x80","0x80","0x0e","0x7b","0x4f","0x67","0x00"} }, + { + /* No.27 delta:1231 weight:1525 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x7afaa5cb,0xf61d93c3,0x8ce73608,0xca1001bc,0xb0eaa477,0x3c0d927f,0x46f737b4,0x0000830c,0x7afa26c7,0xf61d10cf,0x8ce7b504,0xca1082b0,0xb0ea277b,0x3c0d1173,0x46f7b4b8}, + [16]uint32{0x00000000,0x09255812,0x004cc81c,0x0969900e,0x10a0480d,0x1985101f,0x10ec8011,0x19c9d803,0x00209a18,0x0905c20a,0x006c5204,0x09490a16,0x1080d215,0x19a58a07,0x10cc1a09,0x19e9421b}, + [16]uint32{0x3f800000,0x3f8492ac,0x3f802664,0x3f84b4c8,0x3f885024,0x3f8cc288,0x3f887640,0x3f8ce4ec,0x3f80104d,0x3f8482e1,0x3f803629,0x3f84a485,0x3f884069,0x3f8cd2c5,0x3f88660d,0x3f8cf4a1}, + uint32(0xfff80000), + [21]string{"0x3a","0x40","0x03","0x20","0xef","0x18","0x5a","0xe5","0x2a","0x38","0xb1","0xf0","0x41","0xf4","0x32","0x78","0xa2","0x41","0xdc","0x93","0x00"} }, + { + /* No.28 delta:1090 weight:1601 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x37b07ae5,0x1e34ad30,0x2984d7d5,0xa54001cc,0x92f07b29,0xbb74acfc,0x8cc4d619,0x00009771,0x37b0ed94,0x1e343a41,0x298440a4,0xa54096bd,0x92f0ec58,0xbb743b8d,0x8cc44168}, + [16]uint32{0x00000000,0x80503416,0x007c0c1a,0x802c380c,0x0003646b,0x8053507d,0x007f6871,0x802f5c67,0x00002c05,0x80501813,0x007c201f,0x802c1409,0x0003486e,0x80537c78,0x007f4474,0x802f7062}, + [16]uint32{0x3f800000,0x3fc0281a,0x3f803e06,0x3fc0161c,0x3f8001b2,0x3fc029a8,0x3f803fb4,0x3fc017ae,0x3f800016,0x3fc0280c,0x3f803e10,0x3fc0160a,0x3f8001a4,0x3fc029be,0x3f803fa2,0x3fc017b8}, + uint32(0xfff80000), + [21]string{"0x2e","0x51","0xa2","0xb0","0x84","0xe2","0x9b","0x71","0x83","0xc5","0x6d","0xe2","0x0e","0xb2","0x3e","0xe3","0x35","0x5e","0x59","0x0b","0x00"} }, + { + /* No.29 delta:1026 weight:985 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x098de739,0x1e064906,0x178bae3f,0x0fb001de,0x063de6e7,0x11b648d8,0x183bafe1,0x000062cb,0x098d85f2,0x1e062bcd,0x178bccf4,0x0fb06315,0x063d842c,0x11b62a13,0x183bcd2a}, + [16]uint32{0x00000000,0x206d117f,0x201209fe,0x007f1881,0x000180fc,0x206c9183,0x20138902,0x007e987d,0x2010c016,0x007dd169,0x0002c9e8,0x206fd897,0x201140ea,0x007c5195,0x00034914,0x206e586b}, + [16]uint32{0x3f800000,0x3f903688,0x3f900904,0x3f803f8c,0x3f8000c0,0x3f903648,0x3f9009c4,0x3f803f4c,0x3f900860,0x3f803ee8,0x3f800164,0x3f9037ec,0x3f9008a0,0x3f803e28,0x3f8001a4,0x3f90372c}, + uint32(0xfff80000), + [21]string{"0x06","0x77","0xd1","0x7e","0xdc","0xf3","0x70","0x1c","0x50","0xd7","0x02","0x4b","0x90","0x4c","0x30","0xef","0x1a","0xfc","0x80","0xf2","0x00"} }, + { + /* No.30 delta:1006 weight:1433 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0xe98943f8,0x1d8008b8,0xf4094b40,0x897001e6,0x60f9421e,0x94f0095e,0x7d794aa6,0x00000d37,0xe9894ecf,0x1d80058f,0xf4094677,0x89700cd1,0x60f94f29,0x94f00469,0x7d794791}, + [16]uint32{0x00000000,0x60006e16,0x802610db,0xe0267ecd,0x00035407,0x60033a11,0x802544dc,0xe0252aca,0x4068e812,0x20688604,0xc04ef8c9,0xa04e96df,0x406bbc15,0x206bd203,0xc04dacce,0xa04dc2d8}, + [16]uint32{0x3f800000,0x3fb00037,0x3fc01308,0x3ff0133f,0x3f8001aa,0x3fb0019d,0x3fc012a2,0x3ff01295,0x3fa03474,0x3f903443,0x3fe0277c,0x3fd0274b,0x3fa035de,0x3f9035e9,0x3fe026d6,0x3fd026e1}, + uint32(0xfff80000), + [21]string{"0x6c","0x35","0x43","0x19","0x5c","0x54","0xcc","0x5d","0x7f","0x18","0xa9","0xf1","0xa9","0x02","0x57","0x08","0x33","0x68","0x15","0x6f","0x00"} }, + { + /* No.31 delta:2643 weight:851 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x9a117ca4,0x10aad759,0x8abbabfd,0x344001fe,0xae517d5a,0x24ead6a7,0xbefbaa03,0x00005300,0x9a112fa4,0x10aa8459,0x8abbf8fd,0x344052fe,0xae512e5a,0x24ea85a7,0xbefbf903}, + [16]uint32{0x00000000,0x13fd6396,0xc008012f,0xd3f562b9,0x2c0a0612,0x3ff76584,0xec02073d,0xffff64ab,0x0e50429c,0x1dad210a,0xce5843b3,0xdda52025,0x225a448e,0x31a72718,0xe25245a1,0xf1af2637}, + [16]uint32{0x3f800000,0x3f89feb1,0x3fe00400,0x3fe9fab1,0x3f960503,0x3f9ffbb2,0x3ff60103,0x3fffffb2,0x3f872821,0x3f8ed690,0x3fe72c21,0x3feed290,0x3f912d22,0x3f98d393,0x3ff12922,0x3ff8d793}, + uint32(0xfff80000), + [21]string{"0xbe","0xdb","0xc1","0x19","0xc3","0x76","0x96","0x70","0x64","0x79","0xf9","0x78","0x33","0x36","0x98","0xc5","0x84","0x29","0x62","0x9b","0x00"} }, + { + /* No.32 delta:931 weight:1201 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x5c03fe6b,0xf980c4cd,0xa5833aa6,0xd1800200,0x8d83fc6b,0x2800c6cd,0x740338a6,0x00005e80,0x5c03a0eb,0xf9809a4d,0xa5836426,0xd1805c80,0x8d83a2eb,0x2800984d,0x74036626}, + [16]uint32{0x00000000,0x440311b6,0x50014125,0x14025093,0x30806002,0x748371b4,0x60812127,0x24823091,0x2001518f,0x64024039,0x700010aa,0x3403011c,0x1081318d,0x5482203b,0x408070a8,0x0483611e}, + [16]uint32{0x3f800000,0x3fa20188,0x3fa800a0,0x3f8a0128,0x3f984030,0x3fba41b8,0x3fb04090,0x3f924118,0x3f9000a8,0x3fb20120,0x3fb80008,0x3f9a0180,0x3f884098,0x3faa4110,0x3fa04038,0x3f8241b0}, + uint32(0xfff80000), + [21]string{"0x88","0x0a","0xba","0xc7","0x94","0x4a","0x94","0xdb","0x00","0x44","0xcd","0xb3","0xf7","0x4b","0x3f","0x58","0xf1","0xe2","0x5d","0xa8","0x00"} }, + { + /* No.33 delta:2638 weight:897 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x4799d6f6,0xa319c120,0xe48017d6,0x5ac00217,0x1d59d4e1,0xf9d9c337,0xbe4015c1,0x00004ab0,0x47999c46,0xa3198b90,0xe4805d66,0x5ac048a7,0x1d599e51,0xf9d98987,0xbe405f71}, + [16]uint32{0x00000000,0x9080001d,0xb90703ee,0x298703f3,0x4820e8c7,0xd8a0e8da,0xf127eb29,0x61a7eb34,0x82f810ab,0x127810b6,0x3bff1345,0xab7f1358,0xcad8f86c,0x5a58f871,0x73dffb82,0xe35ffb9f}, + [16]uint32{0x3f800000,0x3fc84000,0x3fdc8381,0x3f94c381,0x3fa41074,0x3fec5074,0x3ff893f5,0x3fb0d3f5,0x3fc17c08,0x3f893c08,0x3f9dff89,0x3fd5bf89,0x3fe56c7c,0x3fad2c7c,0x3fb9effd,0x3ff1affd}, + uint32(0xfff80000), + [21]string{"0xa1","0xd1","0x5b","0x36","0xed","0x69","0x7c","0xd5","0x59","0x6f","0x3d","0xb6","0xeb","0xc7","0x5a","0xa6","0x25","0xb1","0xde","0x82","0x00"} }, + { + /* No.34 delta:2636 weight:929 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x3c08004a,0x7d62e150,0x416ae11a,0xa1c00225,0x9dc8026f,0xdca2e375,0xe0aae33f,0x000090a6,0x3c0890ec,0x7d6271f6,0x416a71bc,0xa1c09283,0x9dc892c9,0xdca273d3,0xe0aa7399}, + [16]uint32{0x00000000,0xa470699a,0x1202409c,0xb6722906,0xe1d34561,0x45a32cfb,0xf3d105fd,0x57a16c67,0x5f304155,0xfb4028cf,0x4d3201c9,0xe9426853,0xbee30434,0x1a936dae,0xace144a8,0x08912d32}, + [16]uint32{0x3f800000,0x3fd23834,0x3f890120,0x3fdb3914,0x3ff0e9a2,0x3fa2d196,0x3ff9e882,0x3fabd0b6,0x3faf9820,0x3ffda014,0x3fa69900,0x3ff4a134,0x3fdf7182,0x3f8d49b6,0x3fd670a2,0x3f844896}, + uint32(0xfff80000), + [21]string{"0x19","0x24","0xa9","0x32","0x47","0xfb","0xc5","0x02","0xd0","0x5a","0xd6","0x29","0xb7","0x28","0xc1","0x1d","0x3f","0x73","0x88","0xe1","0x00"} }, + { + /* No.35 delta:1232 weight:1687 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x3edd78fb,0x2bc6abe4,0x151bd31f,0x3f400231,0x019d7aca,0x1486a9d5,0x2a5bd12e,0x00002ae9,0x3edd5212,0x2bc6810d,0x151bf9f6,0x3f4028d8,0x019d5023,0x1486833c,0x2a5bfbc7}, + [16]uint32{0x00000000,0x0824a87e,0x4048c809,0x486c6077,0x5039801d,0x581d2863,0x10714814,0x1855e06a,0x000e7145,0x082ad93b,0x4046b94c,0x48621132,0x5037f158,0x58135926,0x107f3951,0x185b912f}, + [16]uint32{0x3f800000,0x3f841254,0x3fa02464,0x3fa43630,0x3fa81cc0,0x3fac0e94,0x3f8838a4,0x3f8c2af0,0x3f800738,0x3f84156c,0x3fa0235c,0x3fa43108,0x3fa81bf8,0x3fac09ac,0x3f883f9c,0x3f8c2dc8}, + uint32(0xfff80000), + [21]string{"0xa9","0x98","0x5d","0xcc","0x59","0xa5","0x1a","0x00","0xc7","0x87","0x68","0x82","0xf4","0x04","0x8b","0xc3","0xa3","0x0c","0x1e","0x53","0x00"} }, + { + /* No.36 delta:786 weight:1663 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0x94ee5ba3,0x071342e5,0x93fd1946,0x7cd00242,0xe83e59e1,0x7bc340a7,0xef2d1b04,0x0000e533,0x94eebe90,0x0713a7d6,0x93fdfc75,0x7cd0e771,0xe83ebcd2,0x7bc3a594,0xef2dfe37}, + [16]uint32{0x00000000,0x1001c81e,0x8005654f,0x9004ad51,0x00023019,0x1003f807,0x80075556,0x90069d48,0x40008195,0x5001498b,0xc005e4da,0xd0042cc4,0x4002b18c,0x50037992,0xc007d4c3,0xd0061cdd}, + [16]uint32{0x3f800000,0x3f8800e4,0x3fc002b2,0x3fc80256,0x3f800118,0x3f8801fc,0x3fc003aa,0x3fc8034e,0x3fa00040,0x3fa800a4,0x3fe002f2,0x3fe80216,0x3fa00158,0x3fa801bc,0x3fe003ea,0x3fe8030e}, + uint32(0xfff80000), + [21]string{"0xbc","0xac","0x40","0xe1","0xa4","0xcf","0x68","0x57","0x92","0x5d","0xc9","0xb3","0x6f","0xd5","0x5b","0x1b","0xac","0x54","0xa1","0x77","0x00"} }, + { + /* No.37 delta:2265 weight:1225 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0xcd0f688b,0xf8f41039,0x35fb78b2,0x5f400250,0x924f6adb,0xa7b41269,0x6abb7ae2,0x0000f07f,0xcd0f98f4,0xf8f4e046,0x35fb88cd,0x5f40f22f,0x924f9aa4,0xa7b4e216,0x6abb8a9d}, + [16]uint32{0x00000000,0x09832156,0x0c00c8d3,0x0583e985,0x0e88499a,0x070b68cc,0x02888149,0x0b0ba01f,0x1680886e,0x1f03a938,0x1a8040bd,0x130361eb,0x1808c1f4,0x118be0a2,0x14080927,0x1d8b2871}, + [16]uint32{0x3f800000,0x3f84c190,0x3f860064,0x3f82c1f4,0x3f874424,0x3f8385b4,0x3f814440,0x3f8585d0,0x3f8b4044,0x3f8f81d4,0x3f8d4020,0x3f8981b0,0x3f8c0460,0x3f88c5f0,0x3f8a0404,0x3f8ec594}, + uint32(0xfff80000), + [21]string{"0x61","0xcc","0x16","0xa5","0xdd","0xbe","0xe2","0x88","0x85","0x5d","0x84","0x1d","0xae","0x86","0x9e","0x5a","0x80","0xf1","0x6b","0x64","0x00"} }, + { + /* No.38 delta:2677 weight:905 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x42e3bb47,0x9e764ebc,0xdc95f5fb,0x4de0026f,0x0f03b928,0xd3964cd3,0x9175f794,0x00006bb7,0x42e3d0f0,0x9e76250b,0xdc959e4c,0x4de069d8,0x0f03d29f,0xd3962764,0x91759c23}, + [16]uint32{0x00000000,0x224f1092,0xa0508803,0x821f9891,0xa028403a,0x826750a8,0x0078c839,0x2237d8ab,0x4220e01e,0x606ff08c,0xe270681d,0xc03f788f,0xe208a024,0xc047b0b6,0x42582827,0x601738b5}, + [16]uint32{0x3f800000,0x3f912788,0x3fd02844,0x3fc10fcc,0x3fd01420,0x3fc133a8,0x3f803c64,0x3f911bec,0x3fa11070,0x3fb037f8,0x3ff13834,0x3fe01fbc,0x3ff10450,0x3fe023d8,0x3fa12c14,0x3fb00b9c}, + uint32(0xfff80000), + [21]string{"0x84","0x26","0x0e","0x3e","0x1b","0xc1","0xf1","0x19","0xe5","0x93","0xf4","0x85","0x7e","0x2f","0x17","0x2e","0x58","0xd9","0x6f","0x9a","0x00"} }, + { + /* No.39 delta:786 weight:667 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x676d51d0,0xf68c5350,0x91e10280,0x0650027f,0x613d53af,0xf0dc512f,0x97b100ff,0x000019cd,0x676d481d,0xf68c4a9d,0x91e11b4d,0x06501bb2,0x613d4a62,0xf0dc48e2,0x97b11932}, + [16]uint32{0x00000000,0x5167c43f,0x000671a9,0x5161b596,0x004105ed,0x5126c1d2,0x00477444,0x5120b07b,0x43820068,0x12e5c457,0x438471c1,0x12e3b5fe,0x43c30585,0x12a4c1ba,0x43c5742c,0x12a2b013}, + [16]uint32{0x3f800000,0x3fa8b3e2,0x3f800338,0x3fa8b0da,0x3f802082,0x3fa89360,0x3f8023ba,0x3fa89058,0x3fa1c100,0x3f8972e2,0x3fa1c238,0x3f8971da,0x3fa1e182,0x3f895260,0x3fa1e2ba,0x3f895158}, + uint32(0xfff80000), + [21]string{"0xe3","0xa3","0x8f","0xb6","0xe8","0xba","0x04","0x11","0xbf","0x43","0xc9","0x1f","0x8d","0x61","0xe8","0x61","0xb3","0x99","0xfe","0xaf","0x00"} }, + { + /* No.40 delta:745 weight:1705 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0x6f7fb8fe,0x4386db54,0x2cf963aa,0xef600289,0x801fba77,0xace6d9dd,0xc3996123,0x0000b944,0x6f7f01ba,0x43866210,0x2cf9daee,0xef60bbcd,0x801f0333,0xace66099,0xc399d867}, + [16]uint32{0x00000000,0x1000e41e,0x3021c209,0x20212617,0x50001606,0x4000f218,0x6021d40f,0x70213011,0x30000113,0x2000e50d,0x0021c31a,0x10212704,0x60001715,0x7000f30b,0x5021d51c,0x40213102}, + [16]uint32{0x3f800000,0x3f880072,0x3f9810e1,0x3f901093,0x3fa8000b,0x3fa00079,0x3fb010ea,0x3fb81098,0x3f980000,0x3f900072,0x3f8010e1,0x3f881093,0x3fb0000b,0x3fb80079,0x3fa810ea,0x3fa01098}, + uint32(0xfff80000), + [21]string{"0xc0","0x16","0xdd","0x23","0x9e","0xdf","0x73","0x5b","0x4c","0xc1","0x3b","0xb8","0x4e","0xf9","0x1a","0x07","0xc5","0x25","0x31","0x02","0x00"} }, + { + /* No.41 delta:1262 weight:1689 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0x9f1bdb6d,0x8180e703,0x1e9b3c6e,0x1ac00292,0x85dbd9ff,0x9b40e591,0x045b3efc,0x00007a0d,0x9f1ba160,0x81809d0e,0x1e9b4663,0x1ac0789f,0x85dba3f2,0x9b409f9c,0x045b44f1}, + [16]uint32{0x00000000,0x007e003a,0x00628151,0x001c816b,0x38a801e5,0x38d601df,0x38ca80b4,0x38b4808e,0x0002a118,0x007ca122,0x00602049,0x001e2073,0x38aaa0fd,0x38d4a0c7,0x38c821ac,0x38b62196}, + [16]uint32{0x3f800000,0x3f803f00,0x3f803140,0x3f800e40,0x3f9c5400,0x3f9c6b00,0x3f9c6540,0x3f9c5a40,0x3f800150,0x3f803e50,0x3f803010,0x3f800f10,0x3f9c5550,0x3f9c6a50,0x3f9c6410,0x3f9c5b10}, + uint32(0xfff80000), + [21]string{"0xe6","0x9b","0xca","0x13","0x53","0x35","0xe1","0xcd","0x81","0x66","0x78","0xbe","0xc1","0x5c","0x46","0x67","0xa5","0xbe","0xf3","0x4c","0x00"} }, + { + /* No.42 delta:2137 weight:1311 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x610b70db,0x55576aea,0x345c1a31,0xf8a002aa,0x99ab7271,0xadf76840,0xccfc189b,0x0000dbb3,0x610bab68,0x5557b159,0x345cc182,0xf8a0d919,0x99aba9c2,0xadf7b3f3,0xccfcc328}, + [16]uint32{0x00000000,0x2c80f07a,0x0d71214d,0x21f1d137,0x67010013,0x4b81f069,0x6a70215e,0x46f0d124,0x03c0e921,0x2f40195b,0x0eb1c86c,0x22313816,0x64c1e932,0x48411948,0x69b0c87f,0x45303805}, + [16]uint32{0x3f800000,0x3f964078,0x3f86b890,0x3f90f8e8,0x3fb38080,0x3fa5c0f8,0x3fb53810,0x3fa37868,0x3f81e074,0x3f97a00c,0x3f8758e4,0x3f91189c,0x3fb260f4,0x3fa4208c,0x3fb4d864,0x3fa2981c}, + uint32(0xfff80000), + [21]string{"0xce","0x58","0x3a","0xdd","0xda","0x30","0x1a","0x13","0xf0","0x74","0xa1","0xfc","0x0d","0x09","0x89","0xba","0x95","0x5b","0xbc","0x05","0x00"} }, + { + /* No.43 delta:3542 weight:1399 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0x903af7e2,0xbc53f76e,0x2c69008c,0x47d002b6,0xd7eaf554,0xfb83f5d8,0x6bb9023a,0x00002113,0x903ad6f1,0xbc53d67d,0x2c69219f,0x47d023a5,0xd7ead447,0xfb83d4cb,0x6bb92329}, + [16]uint32{0x00000000,0x0102809a,0x000001b3,0x01028129,0x0000016d,0x010281f7,0x000000de,0x01028044,0x0000801d,0x01020087,0x000081ae,0x01020134,0x00008170,0x010201ea,0x000080c3,0x01020059}, + [16]uint32{0x3f800000,0x3f808140,0x3f800000,0x3f808140,0x3f800000,0x3f808140,0x3f800000,0x3f808140,0x3f800040,0x3f808100,0x3f800040,0x3f808100,0x3f800040,0x3f808100,0x3f800040,0x3f808100}, + uint32(0xfff80000), + [21]string{"0x7e","0x35","0x4c","0x0a","0x5d","0x28","0x1a","0xea","0x31","0xd8","0x9a","0xab","0xbe","0xfd","0xb4","0x88","0x86","0xdd","0xf1","0x63","0x00"} }, + { + /* No.44 delta:1029 weight:1639 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x067fc6ad,0x97c590e7,0x91ba564a,0x9d0002c0,0x9b7fc46d,0x0ac59227,0x0cba548a,0x00002c42,0x067feaef,0x97c5bca5,0x91ba7a08,0x9d002e82,0x9b7fe82f,0x0ac5be65,0x0cba78c8}, + [16]uint32{0x00000000,0x1073e352,0x000301a9,0x1070e2fb,0x403d181e,0x504efb4c,0x403e19b7,0x504dfae5,0x01042383,0x1177c0d1,0x0107222a,0x1174c178,0x41393b9d,0x514ad8cf,0x413a3a34,0x5149d966}, + [16]uint32{0x3f800000,0x3f8839f1,0x3f800180,0x3f883871,0x3fa01e8c,0x3fa8277d,0x3fa01f0c,0x3fa826fd,0x3f808211,0x3f88bbe0,0x3f808391,0x3f88ba60,0x3fa09c9d,0x3fa8a56c,0x3fa09d1d,0x3fa8a4ec}, + uint32(0xfff80000), + [21]string{"0xf0","0x72","0x85","0x59","0x14","0x29","0xb0","0x54","0x97","0xb5","0x08","0x91","0x41","0x02","0x93","0xa3","0xd1","0x61","0xf7","0x56","0x00"} }, + { + /* No.45 delta:758 weight:1579 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x293a9a50,0x911e56b5,0xb824cce5,0xed8002df,0xc4ba988f,0x7c9e546a,0x55a4ce3a,0x0000fe7c,0x293a642c,0x911ea8c9,0xb8243299,0xed80fca3,0xc4ba66f3,0x7c9eaa16,0x55a43046}, + [16]uint32{0x00000000,0x2006607a,0x00001259,0x20067223,0x10224205,0x3024227f,0x1022505c,0x30243026,0x1102f9ab,0x310499d1,0x1102ebf2,0x31048b88,0x0120bbae,0x2126dbd4,0x0120a9f7,0x2126c98d}, + [16]uint32{0x3f800000,0x3f900330,0x3f800009,0x3f900339,0x3f881121,0x3f981211,0x3f881128,0x3f981218,0x3f88817c,0x3f98824c,0x3f888175,0x3f988245,0x3f80905d,0x3f90936d,0x3f809054,0x3f909364}, + uint32(0xfff80000), + [21]string{"0x45","0xa1","0x36","0xfd","0x29","0xae","0x9d","0x89","0x66","0xc1","0x52","0x23","0xab","0x49","0x91","0x54","0x97","0x2d","0xe8","0xab","0x00"} }, + { + /* No.46 delta:740 weight:1653 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0xc2bfb3ee,0x1e17102e,0xdca8a3c0,0x56a002e6,0x941fb108,0x48b712c8,0x8a08a126,0x000030c2,0xc2bf832c,0x1e1720ec,0xdca89302,0x56a03224,0x941f81ca,0x48b7220a,0x8a0891e4}, + [16]uint32{0x00000000,0x10238477,0x0000c015,0x10234462,0x026089fd,0x12430d8a,0x026049e8,0x1243cd9f,0xc044320b,0xd067b67c,0xc044f21e,0xd0677669,0xc224bbf6,0xd2073f81,0xc2247be3,0xd207ff94}, + [16]uint32{0x3f800000,0x3f8811c2,0x3f800060,0x3f8811a2,0x3f813044,0x3f892186,0x3f813024,0x3f8921e6,0x3fe02219,0x3fe833db,0x3fe02279,0x3fe833bb,0x3fe1125d,0x3fe9039f,0x3fe1123d,0x3fe903ff}, + uint32(0xfff80000), + [21]string{"0xbc","0x35","0xb5","0xf4","0x1c","0x83","0xb1","0x43","0x2f","0xbc","0x98","0xc0","0x2d","0x75","0x1c","0xf7","0xa7","0x58","0x91","0xef","0x00"} }, + { + /* No.47 delta:1023 weight:1339 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x103bbf40,0x47cf4a25,0x57f4f565,0xa17002f9,0xb14bbdb9,0xe6bf48dc,0xf684f79c,0x000043a1,0x103bfce1,0x47cf0984,0x57f4b6c4,0xa1704158,0xb14bfe18,0xe6bf0b7d,0xf684b43d}, + [16]uint32{0x00000000,0x400061b6,0x601e2a1a,0x201e4bac,0x40090073,0x000961c5,0x20172a69,0x60174bdf,0x10002118,0x500040ae,0x701e0b02,0x301e6ab4,0x5009216b,0x100940dd,0x30170b71,0x70176ac7}, + [16]uint32{0x3f800000,0x3fa00030,0x3fb00f15,0x3f900f25,0x3fa00480,0x3f8004b0,0x3f900b95,0x3fb00ba5,0x3f880010,0x3fa80020,0x3fb80f05,0x3f980f35,0x3fa80490,0x3f8804a0,0x3f980b85,0x3fb80bb5}, + uint32(0xfff80000), + [21]string{"0x35","0xfc","0x27","0xb0","0x9a","0x8d","0x46","0x03","0xc5","0x29","0xf2","0x0e","0x1d","0x9f","0xa6","0xc1","0xfb","0x8b","0x60","0x83","0x00"} }, + { + /* No.48 delta:914 weight:1427 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x881827c4,0xf677e94d,0x7e6fce89,0x27900300,0xaf8824c4,0xd1e7ea4d,0x59ffcd89,0x0000042e,0x881823ea,0xf677ed63,0x7e6fcaa7,0x2790072e,0xaf8820ea,0xd1e7ee63,0x59ffc9a7}, + [16]uint32{0x00000000,0x2807115b,0x208271f5,0x088560ae,0x00819c78,0x28868d23,0x2003ed8d,0x0804fcd6,0x0040c0cc,0x2847d197,0x20c2b139,0x08c5a062,0x00c15cb4,0x28c64def,0x20432d41,0x08443c1a}, + [16]uint32{0x3f800000,0x3f940388,0x3f904138,0x3f8442b0,0x3f8040ce,0x3f944346,0x3f9001f6,0x3f84027e,0x3f802060,0x3f9423e8,0x3f906158,0x3f8462d0,0x3f8060ae,0x3f946326,0x3f902196,0x3f84221e}, + uint32(0xfff80000), + [21]string{"0xb1","0xcb","0x4d","0x0a","0x50","0x26","0x0e","0x75","0xee","0xf1","0x61","0xbe","0x7a","0x0c","0xff","0xfa","0x59","0x3f","0xbb","0xbb","0x00"} }, + { + /* No.49 delta:1496 weight:1687 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x97d0a142,0x5c5a83fc,0xcb8a22be,0x83f0031d,0x1420a25f,0xdfaa80e1,0x487a21a3,0x00005114,0x97d0f056,0x5c5ad2e8,0xcb8a73aa,0x83f05209,0x1420f34b,0xdfaad1f5,0x487a70b7}, + [16]uint32{0x00000000,0xc94004fa,0x202c881d,0xe96c8ce7,0x00712561,0xc931219b,0x205dad7c,0xe91da986,0x109e1016,0xd9de14ec,0x30b2980b,0xf9f29cf1,0x10ef3577,0xd9af318d,0x30c3bd6a,0xf983b990}, + [16]uint32{0x3f800000,0x3fe4a002,0x3f901644,0x3ff4b646,0x3f803892,0x3fe49890,0x3f902ed6,0x3ff48ed4,0x3f884f08,0x3fecef0a,0x3f98594c,0x3ffcf94e,0x3f88779a,0x3fecd798,0x3f9861de,0x3ffcc1dc}, + uint32(0xfff80000), + [21]string{"0xc7","0x1f","0xb6","0x33","0x7b","0xc0","0xe2","0x07","0x61","0x31","0xf3","0x6b","0xc4","0x02","0xee","0xb8","0xf5","0xde","0x86","0xfb","0x00"} }, + { + /* No.50 delta:1017 weight:1379 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x8a72e209,0x80064108,0x0a74a301,0x2a700329,0xa002e120,0xaa764221,0x2004a028,0x0000276e,0x8a72c567,0x80066666,0x0a74846f,0x2a702447,0xa002c64e,0xaa76654f,0x20048746}, + [16]uint32{0x00000000,0x60030972,0x281ea939,0x481da04b,0x5000de16,0x3003d764,0x781e772f,0x181d7e5d,0x1000841e,0x70038d6c,0x381e2d27,0x581d2455,0x40005a08,0x2003537a,0x681ef331,0x081dfa43}, + [16]uint32{0x3f800000,0x3fb00184,0x3f940f54,0x3fa40ed0,0x3fa8006f,0x3f9801eb,0x3fbc0f3b,0x3f8c0ebf,0x3f880042,0x3fb801c6,0x3f9c0f16,0x3fac0e92,0x3fa0002d,0x3f9001a9,0x3fb40f79,0x3f840efd}, + uint32(0xfff80000), + [21]string{"0xcf","0xe0","0xdd","0xe5","0xc6","0xd8","0x52","0x00","0x6d","0xb3","0x72","0xaa","0xa6","0x9d","0xce","0x2e","0xa2","0x63","0x0b","0x0d","0x00"} }, + { + /* No.51 delta:2045 weight:1309 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x7ba353c2,0x72444e05,0x09e71dc7,0xe8e0033b,0x934350f9,0x9aa44d3e,0xe1071efc,0x0000fa95,0x7ba3a957,0x7244b490,0x09e7e752,0xe8e0f9ae,0x9343aa6c,0x9aa4b7ab,0xe107e469}, + [16]uint32{0x00000000,0x24188114,0x2314009a,0x070c818e,0x9618202c,0xb200a138,0xb50c20b6,0x9114a1a2,0x0c2438e1,0x283cb9f5,0x2f30387b,0x0b28b96f,0x9a3c18cd,0xbe2499d9,0xb9281857,0x9d309943}, + [16]uint32{0x3f800000,0x3f920c40,0x3f918a00,0x3f838640,0x3fcb0c10,0x3fd90050,0x3fda8610,0x3fc88a50,0x3f86121c,0x3f941e5c,0x3f97981c,0x3f85945c,0x3fcd1e0c,0x3fdf124c,0x3fdc940c,0x3fce984c}, + uint32(0xfff80000), + [21]string{"0x70","0xc6","0x77","0xbf","0xe4","0x1a","0x82","0x0a","0x8a","0x5b","0x2a","0x93","0x4f","0x09","0xb7","0x9f","0x7f","0x0f","0x33","0xc9","0x00"} }, + { + /* No.52 delta:839 weight:1583 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x674726ea,0x27a13070,0x40e6169a,0x1bc0034a,0x7c8725a0,0x3c61333a,0x5b2615d0,0x00006a2b,0x67474cc1,0x27a15a5b,0x40e67cb1,0x1bc06961,0x7c874f8b,0x3c615911,0x5b267ffb}, + [16]uint32{0x00000000,0x41028416,0x4000140f,0x01029019,0x1000121b,0x5102960d,0x50000614,0x11028202,0x90401c03,0xd1429815,0xd040080c,0x91428c1a,0x80400e18,0xc1428a0e,0xc0401a17,0x81429e01}, + [16]uint32{0x3f800000,0x3fa08142,0x3fa0000a,0x3f808148,0x3f880009,0x3fa8814b,0x3fa80003,0x3f888141,0x3fc8200e,0x3fe8a14c,0x3fe82004,0x3fc8a146,0x3fc02007,0x3fe0a145,0x3fe0200d,0x3fc0a14f}, + uint32(0xfff80000), + [21]string{"0x14","0x30","0xd7","0x1b","0xa4","0xa0","0x00","0x4f","0x40","0x49","0xc4","0x4f","0x7f","0x8b","0x76","0x18","0xd7","0x6a","0xfd","0x81","0x00"} }, + { + /* No.53 delta:769 weight:1553 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xd85e8608,0xa7b19d3c,0x7fef1b34,0x81a00358,0x59fe8550,0x26119e64,0xfe4f186c,0x000048bb,0xd85eceb3,0xa7b1d587,0x7fef538f,0x81a04be3,0x59fecdeb,0x2611d6df,0xfe4f50d7}, + [16]uint32{0x00000000,0x402c0417,0x40019731,0x002d9326,0x0068848c,0x4044809b,0x406913bd,0x004517aa,0x3008e615,0x7024e202,0x70097124,0x30257533,0x30606299,0x704c668e,0x7061f5a8,0x304df1bf}, + [16]uint32{0x3f800000,0x3fa01602,0x3fa000cb,0x3f8016c9,0x3f803442,0x3fa02240,0x3fa03489,0x3f80228b,0x3f980473,0x3fb81271,0x3fb804b8,0x3f9812ba,0x3f983031,0x3fb82633,0x3fb830fa,0x3f9826f8}, + uint32(0xfff80000), + [21]string{"0xd6","0x8f","0x13","0x03","0x40","0x7a","0xe8","0x41","0xe3","0x27","0x5b","0x23","0x49","0x63","0x1b","0x16","0x6a","0xa2","0x14","0x04","0x00"} }, + { + /* No.54 delta:951 weight:1563 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0xf09fc6c7,0xf0b7937f,0x002855b8,0x29700360,0xd9efc5a7,0xd9c7901f,0x295856d8,0x00002334,0xf09fe5f3,0xf0b7b04b,0x0028768c,0x29702054,0xd9efe693,0xd9c7b32b,0x295875ec}, + [16]uint32{0x00000000,0x900c71be,0x204dbc0a,0xb041cdb4,0x0020a5f7,0x902cd449,0x206d19fd,0xb0616843,0x2000300f,0xb00c41b1,0x004d8c05,0x9041fdbb,0x202095f8,0xb02ce446,0x006d29f2,0x9061584c}, + [16]uint32{0x3f800000,0x3fc80638,0x3f9026de,0x3fd820e6,0x3f801052,0x3fc8166a,0x3f90368c,0x3fd830b4,0x3f900018,0x3fd80620,0x3f8026c6,0x3fc820fe,0x3f90104a,0x3fd81672,0x3f803694,0x3fc830ac}, + uint32(0xfff80000), + [21]string{"0xf8","0xc0","0x25","0xb4","0xda","0x06","0xca","0xc7","0x17","0x31","0xd6","0x67","0x69","0x44","0xeb","0x40","0x1f","0x0d","0xb7","0xc8","0x00"} }, + { + /* No.55 delta:820 weight:651 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x57316eba,0x26094031,0x71382e8b,0xe8700378,0xbf416dc2,0xce794349,0x99482df3,0x000012ad,0x57317c17,0x2609529c,0x71383c26,0xe87011d5,0xbf417f6f,0xce7951e4,0x99483f5e}, + [16]uint32{0x00000000,0x48301d92,0x2c04420b,0x64345f99,0x0228401d,0x4a185d8f,0x2e2c0216,0x661c1f84,0x21510062,0x69611df0,0x0d554269,0x45655ffb,0x2379407f,0x6b495ded,0x0f7d0274,0x474d1fe6}, + [16]uint32{0x3f800000,0x3fa4180e,0x3f960221,0x3fb21a2f,0x3f811420,0x3fa50c2e,0x3f971601,0x3fb30e0f,0x3f90a880,0x3fb4b08e,0x3f86aaa1,0x3fa2b2af,0x3f91bca0,0x3fb5a4ae,0x3f87be81,0x3fa3a68f}, + uint32(0xfff80000), + [21]string{"0x7e","0x9c","0x5e","0x32","0xc0","0x16","0x45","0xbd","0x76","0x10","0xe1","0xbf","0x45","0x88","0x55","0xbd","0x7d","0x2a","0x9a","0x13","0x00"} }, + { + /* No.56 delta:985 weight:1247 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0xd8c9f7ef,0x678c6234,0xbf4595db,0xedc00381,0x3509f46e,0x8a4c61b5,0x5285965a,0x000064df,0xd8c99330,0x678c06eb,0xbf45f104,0xedc0675e,0x350990b1,0x8a4c056a,0x5285f285}, + [16]uint32{0x00000000,0x404d099a,0x10636cac,0x502e6536,0x01078014,0x414a898e,0x1164ecb8,0x5129e522,0x000220ad,0x404f2937,0x10614c01,0x502c459b,0x0105a0b9,0x4148a923,0x1166cc15,0x512bc58f}, + [16]uint32{0x3f800000,0x3fa02684,0x3f8831b6,0x3fa81732,0x3f8083c0,0x3fa0a544,0x3f88b276,0x3fa894f2,0x3f800110,0x3fa02794,0x3f8830a6,0x3fa81622,0x3f8082d0,0x3fa0a454,0x3f88b366,0x3fa895e2}, + uint32(0xfff80000), + [21]string{"0x47","0x79","0x4f","0x24","0x4f","0x28","0x51","0x55","0xe6","0x00","0xb2","0x92","0x43","0x2e","0xef","0x24","0x53","0x4b","0x89","0xae","0x00"} }, + { + /* No.57 delta:2159 weight:1381 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x7a54ffc0,0x46d69d10,0x3c8262d0,0xae80039c,0xd4d4fc5c,0xe8569e8c,0x9202614c,0x00006126,0x7a549ee6,0x46d6fc36,0x3c8203f6,0xae8062ba,0xd4d49d7a,0xe856ffaa,0x9202006a}, + [16]uint32{0x00000000,0x648d905b,0x1720008f,0x73ad90d4,0x08090109,0x6c849152,0x1f290186,0x7ba491dd,0x4884300c,0x2c09a057,0x5fa43083,0x3b29a0d8,0x408d3105,0x2400a15e,0x57ad318a,0x3320a1d1}, + [16]uint32{0x3f800000,0x3fb246c8,0x3f8b9000,0x3fb9d6c8,0x3f840480,0x3fb64248,0x3f8f9480,0x3fbdd248,0x3fa44218,0x3f9604d0,0x3fafd218,0x3f9d94d0,0x3fa04698,0x3f920050,0x3fabd698,0x3f999050}, + uint32(0xfff80000), + [21]string{"0x65","0x7d","0x27","0xa8","0x7d","0x8d","0x8f","0x40","0xf6","0x00","0x92","0x6e","0xb9","0x2c","0x8f","0x1f","0xf7","0xcd","0xf8","0xf8","0x00"} }, + { + /* No.58 delta:960 weight:1657 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0x39030bf4,0xdc4c74cc,0xe54f7f38,0x384003a5,0x01430851,0xe40c7769,0xdd0f7c9d,0x0000d6eb,0x3903dd1f,0xdc4ca227,0xe54fa9d3,0x3840d54e,0x0143deba,0xe40ca182,0xdd0faa76}, + [16]uint32{0x00000000,0x4036ac1a,0x506559cc,0x1053f5d6,0x0002501b,0x4034fc01,0x506709d7,0x1051a5cd,0x30280592,0x701ea988,0x604d5c5e,0x207bf044,0x302a5589,0x701cf993,0x604f0c45,0x2079a05f}, + [16]uint32{0x3f800000,0x3fa01b56,0x3fa832ac,0x3f8829fa,0x3f800128,0x3fa01a7e,0x3fa83384,0x3f8828d2,0x3f981402,0x3fb80f54,0x3fb026ae,0x3f903df8,0x3f98152a,0x3fb80e7c,0x3fb02786,0x3f903cd0}, + uint32(0xfff80000), + [21]string{"0x22","0xa6","0x3d","0x5c","0x9c","0x64","0xc4","0x1a","0x87","0xbc","0x5a","0x8b","0x20","0xf8","0x21","0x9e","0x1f","0xf6","0xcd","0xcc","0x00"} }, + { + /* No.59 delta:756 weight:1633 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0xe9579f78,0xecb6987d,0x05e10705,0xdd5003bf,0x34079cc7,0x31e69bc2,0xd8b104ba,0x00008eff,0xe9571187,0xecb61682,0x05e189fa,0xdd508d40,0x34071238,0x31e6153d,0xd8b18a45}, + [16]uint32{0x00000000,0x8004081d,0x300b8a16,0xb00f820b,0x20025234,0xa0065a29,0x1009d822,0x900dd03f,0x3000f0b8,0xb004f8a5,0x000b7aae,0x800f72b3,0x1002a28c,0x9006aa91,0x2009289a,0xa00d2087}, + [16]uint32{0x3f800000,0x3fc00204,0x3f9805c5,0x3fd807c1,0x3f900129,0x3fd0032d,0x3f8804ec,0x3fc806e8,0x3f980078,0x3fd8027c,0x3f8005bd,0x3fc007b9,0x3f880151,0x3fc80355,0x3f900494,0x3fd00690}, + uint32(0xfff80000), + [21]string{"0x85","0x15","0x62","0xa4","0x84","0x38","0x47","0xdf","0x75","0x59","0xe1","0x04","0xe4","0xca","0xb9","0x9c","0x18","0x22","0x13","0xe3","0x00"} }, + { + /* No.60 delta:884 weight:1491 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0x2b4ddbaa,0x62581d43,0x4915c6e9,0xb02003cc,0x9b6dd866,0xd2781e8f,0xf935c525,0x0000065e,0x2b4dddf4,0x62581b1d,0x4915c0b7,0xb0200592,0x9b6dde38,0xd27818d1,0xf935c37b}, + [16]uint32{0x00000000,0x4857d1f3,0x006c189c,0x483bc96f,0x00109016,0x484741e5,0x007c888a,0x482b5979,0x0042e11e,0x481530ed,0x002ef982,0x48792871,0x00527108,0x4805a0fb,0x003e6994,0x4869b867}, + [16]uint32{0x3f800000,0x3fa42be8,0x3f80360c,0x3fa41de4,0x3f800848,0x3fa423a0,0x3f803e44,0x3fa415ac,0x3f802170,0x3fa40a98,0x3f80177c,0x3fa43c94,0x3f802938,0x3fa402d0,0x3f801f34,0x3fa434dc}, + uint32(0xfff80000), + [21]string{"0x39","0x31","0x69","0x5e","0x7e","0x10","0xb8","0xaa","0x3a","0x98","0x1c","0x5b","0xff","0x82","0x62","0x56","0xa4","0x6d","0x74","0xcb","0x00"} }, + { + /* No.61 delta:906 weight:1689 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0x91a3a21f,0x5fe47590,0xce47d78f,0x4ae003d2,0xdb43a1cd,0x15047642,0x84a7d45d,0x0000207b,0x91a38264,0x5fe455eb,0xce47f7f4,0x4ae023a9,0xdb4381b6,0x15045639,0x84a7f426}, + [16]uint32{0x00000000,0x0003183a,0x685560d6,0x685678ec,0x00080811,0x000b102b,0x685d68c7,0x685e70fd,0x10414608,0x10425e32,0x781426de,0x78173ee4,0x10494e19,0x104a5623,0x781c2ecf,0x781f36f5}, + [16]uint32{0x3f800000,0x3f80018c,0x3fb42ab0,0x3fb42b3c,0x3f800404,0x3f800588,0x3fb42eb4,0x3fb42f38,0x3f8820a3,0x3f88212f,0x3fbc0a13,0x3fbc0b9f,0x3f8824a7,0x3f88252b,0x3fbc0e17,0x3fbc0f9b}, + uint32(0xfff80000), + [21]string{"0x57","0x3c","0x84","0xe5","0x98","0xdb","0x39","0x4a","0xeb","0xa4","0x81","0x6b","0x09","0x0d","0xc0","0xe8","0xe9","0x35","0x36","0xb6","0x00"} }, + { + /* No.62 delta:1119 weight:1595 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0x7c95ddbe,0xbc1eaeaf,0xc08b7311,0xc13003e8,0xbda5de56,0x7d2ead47,0x01bb70f9,0x00001cd3,0x7c95c16d,0xbc1eb27c,0xc08b6fc2,0xc1301f3b,0xbda5c285,0x7d2eb194,0x01bb6c2a}, + [16]uint32{0x00000000,0x20449212,0x2026c1f4,0x006253e6,0x1008101b,0x304c8209,0x302ed1ef,0x106a43fd,0x00035008,0x2047c21a,0x202591fc,0x006103ee,0x100b4013,0x304fd201,0x302d81e7,0x106913f5}, + [16]uint32{0x3f800000,0x3f902249,0x3f901360,0x3f803129,0x3f880408,0x3f982641,0x3f981768,0x3f883521,0x3f8001a8,0x3f9023e1,0x3f9012c8,0x3f803081,0x3f8805a0,0x3f9827e9,0x3f9816c0,0x3f883489}, + uint32(0xfff80000), + [21]string{"0x15","0x36","0x2b","0xe9","0xbe","0xfc","0x35","0x7f","0x43","0x78","0xb2","0xe9","0x1b","0x6f","0xe1","0x9a","0x31","0x7e","0xa7","0xa5","0x00"} }, + { + /* No.63 delta:1018 weight:1315 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0xf4c75a08,0x33451618,0xc7824c10,0x1a2003fc,0xeee759f4,0x296515e4,0xdda24fec,0x0000bc07,0xf4c7e60f,0x3345aa1f,0xc782f017,0x1a20bffb,0xeee7e5f3,0x2965a9e3,0xdda2f3eb}, + [16]uint32{0x00000000,0x0154993e,0x102e04dc,0x117a9de2,0x00562016,0x0102b928,0x107824ca,0x112cbdf4,0x00028084,0x015619ba,0x102c8458,0x11781d66,0x0054a092,0x010039ac,0x107aa44e,0x112e3d70}, + [16]uint32{0x3f800000,0x3f80aa4c,0x3f881702,0x3f88bd4e,0x3f802b10,0x3f80815c,0x3f883c12,0x3f88965e,0x3f800140,0x3f80ab0c,0x3f881642,0x3f88bc0e,0x3f802a50,0x3f80801c,0x3f883d52,0x3f88971e}, + uint32(0xfff80000), + [21]string{"0x0b","0x34","0x5c","0x8b","0x80","0x6e","0x98","0xde","0x54","0x2d","0xbc","0xd0","0x18","0x38","0x01","0x6b","0x27","0x70","0x53","0x67","0x00"} }, + { + /* No.64 delta:1089 weight:1641 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x320f354d,0x4b52ac78,0x795d9935,0x1be00405,0x29ef3148,0x50b2a87d,0x62bd9d30,0x0000f8ea,0x320fcda7,0x4b525492,0x795d61df,0x1be0fcef,0x29efc9a2,0x50b25097,0x62bd65da}, + [16]uint32{0x00000000,0x00441014,0x0168282f,0x012c383b,0x205018c9,0x201408dd,0x213830e6,0x217c20f2,0x0060788e,0x0024689a,0x010850a1,0x014c40b5,0x20306047,0x20747053,0x21584868,0x211c587c}, + [16]uint32{0x3f800000,0x3f802208,0x3f80b414,0x3f80961c,0x3f90280c,0x3f900a04,0x3f909c18,0x3f90be10,0x3f80303c,0x3f801234,0x3f808428,0x3f80a620,0x3f901830,0x3f903a38,0x3f90ac24,0x3f908e2c}, + uint32(0xfff80000), + [21]string{"0x0b","0x75","0x3a","0x0f","0x25","0x1b","0x1e","0x62","0x79","0xde","0x49","0xe4","0x67","0xde","0x19","0x1c","0x07","0x87","0xb7","0x03","0x00"} }, + { + /* No.65 delta:714 weight:1595 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xc4cfa437,0xb22d512f,0x76e2f518,0x1fb00411,0xdb7fa026,0xad9d553e,0x6952f109,0x0000b641,0xc4cf1276,0xb22de76e,0x76e24359,0x1fb0b250,0xdb7f1667,0xad9de37f,0x69524748}, + [16]uint32{0x00000000,0x0003499a,0x904c1025,0x904f59bf,0x60086118,0x600b2882,0xf044713d,0xf04738a7,0x00009815,0x0003d18f,0x904c8830,0x904fc1aa,0x6008f90d,0x600bb097,0xf044e928,0xf047a0b2}, + [16]uint32{0x3f800000,0x3f8001a4,0x3fc82608,0x3fc827ac,0x3fb00430,0x3fb00594,0x3ff82238,0x3ff8239c,0x3f80004c,0x3f8001e8,0x3fc82644,0x3fc827e0,0x3fb0047c,0x3fb005d8,0x3ff82274,0x3ff823d0}, + uint32(0xfff80000), + [21]string{"0xc2","0xcd","0xc7","0x28","0xfa","0x9f","0xe4","0x82","0x5d","0x7c","0x58","0x33","0x83","0xa7","0x2d","0xd5","0x6e","0x00","0xce","0x8b","0x00"} }, + { + /* No.66 delta:1489 weight:1775 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x27ac5b8e,0x7da1bc19,0x5a0de797,0xc1d00429,0xe67c5fa7,0xbc71b830,0x9bdde3be,0x0000f5b6,0x27acae38,0x7da149af,0x5a0d1221,0xc1d0f19f,0xe67caa11,0xbc714d86,0x9bdd1608}, + [16]uint32{0x00000000,0x486c4874,0x0249557f,0x4a251d0b,0x107c8402,0x5810cc76,0x1235d17d,0x5a599909,0x1003f025,0x586fb851,0x124aa55a,0x5a26ed2e,0x007f7427,0x48133c53,0x02362158,0x4a5a692c}, + [16]uint32{0x3f800000,0x3fa43624,0x3f8124aa,0x3fa5128e,0x3f883e42,0x3fac0866,0x3f891ae8,0x3fad2ccc,0x3f8801f8,0x3fac37dc,0x3f892552,0x3fad1376,0x3f803fba,0x3fa4099e,0x3f811b10,0x3fa52d34}, + uint32(0xfff80000), + [21]string{"0x96","0xb5","0xb1","0x05","0x1a","0xe3","0x5f","0x00","0x61","0x64","0xea","0x66","0xa3","0x2b","0xe1","0x35","0xb4","0x7d","0x59","0xd2","0x00"} }, + { + /* No.67 delta:723 weight:1463 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0xfc1f1f2f,0xc4d2cb0e,0x38cdd421,0xc2b00437,0x3eaf1b18,0x0662cf39,0xfa7dd016,0x0000a8c0,0xfc1fb7ef,0xc4d263ce,0x38cd7ce1,0xc2b0acf7,0x3eafb3d8,0x066267f9,0xfa7d78d6}, + [16]uint32{0x00000000,0x00641c81,0x340b711d,0x346f6d9c,0x1015e41f,0x1071f89e,0x241e9502,0x247a8983,0x00028e08,0x00669289,0x3409ff15,0x346de394,0x10176a17,0x10737696,0x241c1b0a,0x2478078b}, + [16]uint32{0x3f800000,0x3f80320e,0x3f9a05b8,0x3f9a37b6,0x3f880af2,0x3f8838fc,0x3f920f4a,0x3f923d44,0x3f800147,0x3f803349,0x3f9a04ff,0x3f9a36f1,0x3f880bb5,0x3f8839bb,0x3f920e0d,0x3f923c03}, + uint32(0xfff80000), + [21]string{"0xf4","0x2a","0x3e","0xd7","0x86","0x3d","0xa0","0x67","0x25","0xa6","0xa8","0x85","0x72","0xca","0x5c","0x60","0xcc","0xc8","0x6f","0x35","0x00"} }, + { + /* No.68 delta:1693 weight:1443 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x13299b1c,0x63241401,0x700d8f1d,0x42600440,0x51499f5c,0x21441041,0x326d8b5d,0x00001370,0x1329886c,0x63240771,0x700d9c6d,0x42601730,0x51498c2c,0x21440331,0x326d982d}, + [16]uint32{0x00000000,0x21a4819e,0x153ae095,0x349e610b,0x40056146,0x61a1e0d8,0x553f81d3,0x749b004d,0x180164bc,0x39a5e522,0x0d3b8429,0x2c9f05b7,0x580405fa,0x79a08464,0x4d3ee56f,0x6c9a64f1}, + [16]uint32{0x3f800000,0x3f90d240,0x3f8a9d70,0x3f9a4f30,0x3fa002b0,0x3fb0d0f0,0x3faa9fc0,0x3fba4d80,0x3f8c00b2,0x3f9cd2f2,0x3f869dc2,0x3f964f82,0x3fac0202,0x3fbcd042,0x3fa69f72,0x3fb64d32}, + uint32(0xfff80000), + [21]string{"0xd1","0x71","0x93","0x13","0xcd","0x52","0x65","0x76","0x85","0x6a","0x2e","0xb7","0xf3","0x0b","0x49","0x99","0x86","0x3d","0x92","0x0d","0x00"} }, + { + /* No.69 delta:1307 weight:1479 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x07c30918,0x94343ae4,0x93f733fc,0x6db00450,0x6a730d48,0xf9843eb4,0xfe4737ac,0x00007d59,0x07c37441,0x943447bd,0x93f74ea5,0x6db07909,0x6a737011,0xf98443ed,0xfe474af5}, + [16]uint32{0x00000000,0x4075907e,0x004c410c,0x4039d172,0x002f09cd,0x405a99b3,0x006348c1,0x4016d8bf,0x4008b006,0x007d2078,0x4044f10a,0x00316174,0x4027b9cb,0x005229b5,0x406bf8c7,0x001e68b9}, + [16]uint32{0x3f800000,0x3fa03ac8,0x3f802620,0x3fa01ce8,0x3f801784,0x3fa02d4c,0x3f8031a4,0x3fa00b6c,0x3fa00458,0x3f803e90,0x3fa02278,0x3f8018b0,0x3fa013dc,0x3f802914,0x3fa035fc,0x3f800f34}, + uint32(0xfff80000), + [21]string{"0xf5","0x02","0x42","0xbf","0xf1","0xcd","0x2a","0xe7","0xcc","0x16","0x29","0xd9","0xdf","0x4c","0x1b","0x8a","0xd2","0xe3","0x42","0x87","0x00"} }, + { + /* No.70 delta:2277 weight:1275 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x7556a31c,0xe17eb988,0x94281a94,0x85000461,0xf056a77d,0x647ebde9,0x11281ef5,0x0000a401,0x7556071d,0xe17e1d89,0x9428be95,0x8500a060,0xf056037c,0x647e19e8,0x1128baf4}, + [16]uint32{0x00000000,0x4a8384f2,0x14b0012d,0x5e3385df,0x18488015,0x52cb04e7,0x0cf88138,0x467b05ca,0x4800403a,0x0283c4c8,0x5cb04117,0x1633c5e5,0x5048c02f,0x1acb44dd,0x44f8c102,0x0e7b45f0}, + [16]uint32{0x3f800000,0x3fa541c2,0x3f8a5800,0x3faf19c2,0x3f8c2440,0x3fa96582,0x3f867c40,0x3fa33d82,0x3fa40020,0x3f8141e2,0x3fae5820,0x3f8b19e2,0x3fa82460,0x3f8d65a2,0x3fa27c60,0x3f873da2}, + uint32(0xfff80000), + [21]string{"0x1e","0x51","0xac","0x8a","0x9d","0x34","0x89","0x83","0x73","0xe5","0x49","0x94","0x37","0x11","0x32","0x2d","0x8a","0xb6","0xcd","0x96","0x00"} }, + { + /* No.71 delta:1215 weight:1591 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0xc94d3c2c,0x2e401a94,0xe70d26b8,0x50100470,0x995d385c,0x7e501ee4,0xb71d22c8,0x00006b09,0xc94d5725,0x2e40719d,0xe70d4db1,0x50106f79,0x995d5355,0x7e5075ed,0xb71d49c1}, + [16]uint32{0x00000000,0x0826883a,0x005840e9,0x087ec8d3,0x205c05d1,0x287a8deb,0x20044538,0x2822cd02,0x11089817,0x192e102d,0x1150d8fe,0x197650c4,0x31549dc6,0x397215fc,0x310cdd2f,0x392a5515}, + [16]uint32{0x3f800000,0x3f841344,0x3f802c20,0x3f843f64,0x3f902e02,0x3f943d46,0x3f900222,0x3f941166,0x3f88844c,0x3f8c9708,0x3f88a86c,0x3f8cbb28,0x3f98aa4e,0x3f9cb90a,0x3f98866e,0x3f9c952a}, + uint32(0xfff80000), + [21]string{"0x4f","0x05","0x82","0x20","0xf4","0x8d","0x2d","0xe9","0x1c","0xd5","0x73","0x15","0xb0","0xaa","0xf2","0x4f","0x30","0x04","0x96","0xb4","0x00"} }, + { + /* No.72 delta:652 weight:1403 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x291f4139,0xe6434801,0xcf5c0938,0xe4b0048a,0xcdaf45b3,0x02f34c8b,0x2bec0db2,0x00008ad9,0x291fcbe0,0xe643c2d8,0xcf5c83e1,0xe4b08e53,0xcdafcf6a,0x02f3c652,0x2bec876b}, + [16]uint32{0x00000000,0x0063c957,0x802cb41b,0x804f7d4c,0x0431412d,0x0452887a,0x841df536,0x847e3c61,0x000231d1,0x0061f886,0x802e85ca,0x804d4c9d,0x043370fc,0x0450b9ab,0x841fc4e7,0x847c0db0}, + [16]uint32{0x3f800000,0x3f8031e4,0x3fc0165a,0x3fc027be,0x3f8218a0,0x3f822944,0x3fc20efa,0x3fc23f1e,0x3f800118,0x3f8030fc,0x3fc01742,0x3fc026a6,0x3f8219b8,0x3f82285c,0x3fc20fe2,0x3fc23e06}, + uint32(0xfff80000), + [21]string{"0x6f","0x2d","0x27","0x79","0xae","0xd3","0x36","0x85","0x65","0x0d","0x5d","0xb5","0xac","0x24","0x89","0xe2","0x2e","0xbe","0x97","0xb4","0x00"} }, + { + /* No.73 delta:1101 weight:1763 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x560d2adb,0xb2127f1a,0xe41f55c1,0x51300499,0x073d2e42,0xe3227b83,0xb52f5158,0x0000abdc,0x560d8107,0xb212d4c6,0xe41ffe1d,0x5130af45,0x073d859e,0xe322d05f,0xb52ffa84}, + [16]uint32{0x00000000,0x0050e576,0x600041bb,0x6050a4cd,0xb00138e7,0xb051dd91,0xd001795c,0xd0519c2a,0x30181083,0x3048f5f5,0x50185138,0x5048b44e,0x80192864,0x8049cd12,0xe01969df,0xe0498ca9}, + [16]uint32{0x3f800000,0x3f802872,0x3fb00020,0x3fb02852,0x3fd8009c,0x3fd828ee,0x3fe800bc,0x3fe828ce,0x3f980c08,0x3f98247a,0x3fa80c28,0x3fa8245a,0x3fc00c94,0x3fc024e6,0x3ff00cb4,0x3ff024c6}, + uint32(0xfff80000), + [21]string{"0x24","0xa9","0xfe","0xbb","0x8f","0x2a","0x81","0xe7","0x73","0x37","0xb9","0x39","0x98","0x66","0x5c","0x81","0x55","0xb9","0x0e","0x19","0x00"} }, + { + /* No.74 delta:876 weight:905 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0x5af2542e,0x5bb7bc50,0x0145e87e,0x331004a3,0x69e2508d,0x68a7b8f3,0x3255ecdd,0x0000f93b,0x5af2ad15,0x5bb7456b,0x01451145,0x3310fd98,0x69e2a9b6,0x68a741c8,0x325515e6}, + [16]uint32{0x00000000,0x404c409a,0x0040115f,0x400c51c5,0x00676079,0x402b20e3,0x00277126,0x406b31bc,0x000eb018,0x4042f082,0x004ea147,0x4002e1dd,0x0069d061,0x402590fb,0x0029c13e,0x406581a4}, + [16]uint32{0x3f800000,0x3fa02620,0x3f802008,0x3fa00628,0x3f8033b0,0x3fa01590,0x3f8013b8,0x3fa03598,0x3f800758,0x3fa02178,0x3f802750,0x3fa00170,0x3f8034e8,0x3fa012c8,0x3f8014e0,0x3fa032c0}, + uint32(0xfff80000), + [21]string{"0x6c","0xbd","0x29","0xe3","0x65","0xd4","0x88","0x90","0x6f","0x21","0x6e","0xed","0x6d","0x9a","0xf6","0xfe","0x97","0xbe","0x58","0x4b","0x00"} }, + { + /* No.75 delta:885 weight:1253 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x5e39eadc,0xa9b23c93,0xf78bd64f,0xe1e004b7,0xbfd9ee6b,0x48523824,0x166bd2f8,0x00008ac0,0x5e39601c,0xa9b2b653,0xf78b5c8f,0xe1e08e77,0xbfd964ab,0x4852b2e4,0x166b5838}, + [16]uint32{0x00000000,0x400301de,0xd000c86d,0x9003c9b3,0x40106097,0x00136149,0x9010a8fa,0xd013a924,0xc0008019,0x800381c7,0x10004874,0x500349aa,0x8010e08e,0xc013e150,0x501028e3,0x1013293d}, + [16]uint32{0x3f800000,0x3fa00180,0x3fe80064,0x3fc801e4,0x3fa00830,0x3f8009b0,0x3fc80854,0x3fe809d4,0x3fe00040,0x3fc001c0,0x3f880024,0x3fa801a4,0x3fc00870,0x3fe009f0,0x3fa80814,0x3f880994}, + uint32(0xfff80000), + [21]string{"0x60","0xba","0x71","0x72","0x3a","0x97","0x88","0x75","0x5e","0x45","0xcf","0xe5","0x59","0xa2","0x0c","0xd8","0xdf","0x65","0x87","0x19","0x00"} }, + { + /* No.76 delta:2153 weight:1269 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x3206c523,0x1c0d4583,0x2e0b80a0,0xec9004cd,0xde96c1ee,0xf09d414e,0xc29b846d,0x0000d57e,0x3206105d,0x1c0d90fd,0x2e0b55de,0xec90d1b3,0xde961490,0xf09d9430,0xc29b5113}, + [16]uint32{0x00000000,0x034309f2,0x10040b87,0x13470275,0x0800401e,0x0b4349ec,0x18044b99,0x1b47426b,0x272120ed,0x2462291f,0x37252b6a,0x34662298,0x2f2160f3,0x2c626901,0x3f256b74,0x3c666286}, + [16]uint32{0x3f800000,0x3f81a184,0x3f880205,0x3f89a381,0x3f840020,0x3f85a1a4,0x3f8c0225,0x3f8da3a1,0x3f939090,0x3f923114,0x3f9b9295,0x3f9a3311,0x3f9790b0,0x3f963134,0x3f9f92b5,0x3f9e3331}, + uint32(0xfff80000), + [21]string{"0x77","0xa5","0x9d","0xbd","0xae","0xa2","0xaa","0x67","0xc1","0x01","0xdd","0x6f","0x89","0x9b","0xb6","0x7a","0xfd","0x3d","0x4a","0xb0","0x00"} }, + { + /* No.77 delta:1132 weight:1669 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x35724a27,0x53a7ed07,0x66d5a720,0xff8004de,0xcaf24ef9,0xac27e9d9,0x9955a3fe,0x0000e9f3,0x3572a3d4,0x53a704f4,0x66d54ed3,0xff80ed2d,0xcaf2a70a,0xac27002a,0x99554a0d}, + [16]uint32{0x00000000,0x18371172,0x4000108e,0x583701fc,0x0048f0fa,0x187fe188,0x4048e074,0x587ff106,0x007a08dd,0x184d19af,0x407a1853,0x584d0921,0x0032f827,0x1805e955,0x4032e8a9,0x5805f9db}, + [16]uint32{0x3f800000,0x3f8c1b88,0x3fa00008,0x3fac1b80,0x3f802478,0x3f8c3ff0,0x3fa02470,0x3fac3ff8,0x3f803d04,0x3f8c268c,0x3fa03d0c,0x3fac2684,0x3f80197c,0x3f8c02f4,0x3fa01974,0x3fac02fc}, + uint32(0xfff80000), + [21]string{"0x85","0xdd","0xb3","0x21","0x23","0x3b","0x83","0xad","0x64","0x33","0x12","0x30","0x80","0xf8","0x38","0xfc","0x83","0x12","0x88","0x20","0x00"} }, + { + /* No.78 delta:1199 weight:1651 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0xd89eace9,0x2735054e,0xffaba9a7,0xbdd004ea,0x654ea803,0x9ae501a4,0x427bad4d,0x0000497f,0xd89ee596,0x27354c31,0xffabe0d8,0xbdd04d95,0x654ee17c,0x9ae548db,0x427be432}, + [16]uint32{0x00000000,0x00390194,0x0078e00b,0x0041e19f,0xd010193a,0xd02918ae,0xd068f931,0xd051f8a5,0x10090419,0x1030058d,0x1071e412,0x1048e586,0xc0191d23,0xc0201cb7,0xc061fd28,0xc058fcbc}, + [16]uint32{0x3f800000,0x3f801c80,0x3f803c70,0x3f8020f0,0x3fe8080c,0x3fe8148c,0x3fe8347c,0x3fe828fc,0x3f880482,0x3f881802,0x3f8838f2,0x3f882472,0x3fe00c8e,0x3fe0100e,0x3fe030fe,0x3fe02c7e}, + uint32(0xfff80000), + [21]string{"0x08","0xa7","0x35","0x7c","0xcf","0x56","0x3b","0xc3","0x85","0x5b","0xc7","0xc0","0x5d","0x90","0x74","0xe6","0xcc","0xb0","0xb1","0xfd","0x00"} }, + { + /* No.79 delta:892 weight:1675 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0x0434b892,0x79823e0d,0x7db6869f,0xa4e004f5,0xa0d4bc67,0xdd623af8,0xd956826a,0x000060f0,0x0434d862,0x79825efd,0x7db6e66f,0xa4e06405,0xa0d4dc97,0xdd625a08,0xd956e29a}, + [16]uint32{0x00000000,0x000b801a,0x18405819,0x184bd803,0x00022c07,0x0009ac1d,0x1842741e,0x1849f404,0x400315d5,0x400895cf,0x58434dcc,0x5848cdd6,0x400139d2,0x400ab9c8,0x584161cb,0x584ae1d1}, + [16]uint32{0x3f800000,0x3f8005c0,0x3f8c202c,0x3f8c25ec,0x3f800116,0x3f8004d6,0x3f8c213a,0x3f8c24fa,0x3fa0018a,0x3fa0044a,0x3fac21a6,0x3fac2466,0x3fa0009c,0x3fa0055c,0x3fac20b0,0x3fac2570}, + uint32(0xfff80000), + [21]string{"0xf2","0x33","0x90","0x14","0xd2","0xa7","0x36","0xf6","0x35","0x60","0x0e","0xf6","0x5a","0xdf","0x90","0x11","0xaf","0x95","0x8a","0x3b","0x00"} }, + { + /* No.80 delta:1111 weight:1547 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x7cf58980,0x9082a4b0,0xec772d30,0x52d0050d,0x2e258c8d,0xc252a1bd,0xbea7283d,0x000017b4,0x7cf59e34,0x9082b304,0xec773a84,0x52d012b9,0x2e259b39,0xc252b609,0xbea73f89}, + [16]uint32{0x00000000,0x006810fa,0x00049929,0x006c89d3,0x4002109c,0x406a0066,0x400689b5,0x406e994f,0x40018936,0x406999cc,0x4005101f,0x406d00e5,0x000399aa,0x006b8950,0x00070083,0x006f1079}, + [16]uint32{0x3f800000,0x3f803408,0x3f80024c,0x3f803644,0x3fa00108,0x3fa03500,0x3fa00344,0x3fa0374c,0x3fa000c4,0x3fa034cc,0x3fa00288,0x3fa03680,0x3f8001cc,0x3f8035c4,0x3f800380,0x3f803788}, + uint32(0xfff80000), + [21]string{"0x04","0xb7","0x35","0x5a","0x80","0x90","0x46","0x94","0x03","0x85","0xfe","0x64","0x9d","0xcc","0x88","0x0d","0xfa","0xef","0xbb","0x76","0x00"} }, + { + /* No.81 delta:1067 weight:1455 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x6079553d,0xde15d819,0xbe6c8d24,0xe7b0051a,0x87c95027,0x39a5dd03,0x59dc883e,0x0000cde0,0x607998dd,0xde1515f9,0xbe6c40c4,0xe7b0c8fa,0x87c99dc7,0x39a510e3,0x59dc45de}, + [16]uint32{0x00000000,0x0014109a,0x60246415,0x6030748f,0x1052207c,0x104630e6,0x70764469,0x706254f3,0x00412001,0x0055309b,0x60654414,0x6071548e,0x1013007d,0x100710e7,0x70376468,0x702374f2}, + [16]uint32{0x3f800000,0x3f800a08,0x3fb01232,0x3fb0183a,0x3f882910,0x3f882318,0x3fb83b22,0x3fb8312a,0x3f802090,0x3f802a98,0x3fb032a2,0x3fb038aa,0x3f880980,0x3f880388,0x3fb81bb2,0x3fb811ba}, + uint32(0xfff80000), + [21]string{"0xd4","0x7c","0x86","0xf0","0x36","0x3f","0x03","0x44","0x41","0x4f","0xa2","0x9f","0x4b","0x03","0x50","0xcc","0xba","0x69","0x39","0x97","0x00"} }, + { + /* No.82 delta:811 weight:1339 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xcce813fe,0x2dbec8f0,0xe156db0e,0xc7000522,0x0be816dc,0xeabecdd2,0x2656de2c,0x0000eb42,0xcce8f8bc,0x2dbe23b2,0xe156304c,0xc700ee60,0x0be8fd9e,0xeabe2690,0x2656356e}, + [16]uint32{0x00000000,0x07621833,0x0a02c005,0x0d60d836,0x00f080d4,0x079298e7,0x0af240d1,0x0d9058e2,0x0003007b,0x07611848,0x0a01c07e,0x0d63d84d,0x00f380af,0x0791989c,0x0af140aa,0x0d935899}, + [16]uint32{0x3f800000,0x3f83b10c,0x3f850160,0x3f86b06c,0x3f807840,0x3f83c94c,0x3f857920,0x3f86c82c,0x3f800180,0x3f83b08c,0x3f8500e0,0x3f86b1ec,0x3f8079c0,0x3f83c8cc,0x3f8578a0,0x3f86c9ac}, + uint32(0xfff80000), + [21]string{"0x6f","0x0a","0xa8","0x49","0xe5","0x73","0xb3","0x24","0x00","0xaa","0xd2","0xbe","0x44","0x6a","0x7b","0x67","0x2f","0xbe","0x5f","0x02","0x00"} }, + { + /* No.83 delta:882 weight:1645 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x0433906c,0xa3bc9f1a,0xa78f0f76,0x2420053a,0x20139556,0x879c9a20,0x83af0a4c,0x00008edc,0x04331eb0,0xa3bc11c6,0xa78f81aa,0x24208be6,0x20131b8a,0x879c14fc,0x83af8490}, + [16]uint32{0x00000000,0x0440301b,0x10000895,0x1440388e,0x84024037,0x8042702c,0x940248a2,0x904278b9,0x4020201a,0x44601001,0x5020288f,0x54601894,0xc422602d,0xc0625036,0xd42268b8,0xd06258a3}, + [16]uint32{0x3f800000,0x3f822018,0x3f880004,0x3f8a201c,0x3fc20120,0x3fc02138,0x3fca0124,0x3fc8213c,0x3fa01010,0x3fa23008,0x3fa81014,0x3faa300c,0x3fe21130,0x3fe03128,0x3fea1134,0x3fe8312c}, + uint32(0xfff80000), + [21]string{"0x8b","0x04","0x62","0xcc","0x60","0xe5","0x43","0xbf","0x8b","0x19","0x87","0x92","0x22","0x34","0x6c","0xb0","0x7b","0x42","0x5f","0x43","0x00"} }, + { + /* No.84 delta:830 weight:1133 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xbe99f4e9,0xfd60a36e,0x43f95787,0x43e00547,0xfd79f1ae,0xbe80a629,0x001952c0,0x000095ae,0xbe996147,0xfd6036c0,0x43f9c229,0x43e090e9,0xfd796400,0xbe803387,0x0019c76e}, + [16]uint32{0x00000000,0x107c111b,0x0041587f,0x103d4964,0x6042c325,0x703ed23e,0x60039b5a,0x707f8a41,0x006029e8,0x101c38f3,0x00217197,0x105d608c,0x6022eacd,0x705efbd6,0x6063b2b2,0x701fa3a9}, + [16]uint32{0x3f800000,0x3f883e08,0x3f8020ac,0x3f881ea4,0x3fb02161,0x3fb81f69,0x3fb001cd,0x3fb83fc5,0x3f803014,0x3f880e1c,0x3f8010b8,0x3f882eb0,0x3fb01175,0x3fb82f7d,0x3fb031d9,0x3fb80fd1}, + uint32(0xfff80000), + [21]string{"0x2d","0xfa","0x77","0x28","0x17","0x09","0x3a","0x65","0x8d","0xf8","0x6b","0x36","0xcd","0xc2","0xd0","0xbc","0x4b","0xb4","0xd7","0x62","0x00"} }, + { + /* No.85 delta:1093 weight:1403 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xc523f0a7,0xa559b351,0x607a43f6,0x80c00550,0x45e3f5f7,0x2599b601,0xe0ba46a6,0x0000cfc3,0xc5233f64,0xa5597c92,0x607a8c35,0x80c0ca93,0x45e33a34,0x259979c2,0xe0ba8965}, + [16]uint32{0x00000000,0xa040113e,0x006639a3,0xa026289d,0x10440018,0xb0041126,0x102239bb,0xb0622885,0x004014b4,0xa000058a,0x00262d17,0xa0663c29,0x100414ac,0xb0440592,0x10622d0f,0xb0223c31}, + [16]uint32{0x3f800000,0x3fd02008,0x3f80331c,0x3fd01314,0x3f882200,0x3fd80208,0x3f88111c,0x3fd83114,0x3f80200a,0x3fd00002,0x3f801316,0x3fd0331e,0x3f88020a,0x3fd82202,0x3f883116,0x3fd8111e}, + uint32(0xfff80000), + [21]string{"0xf8","0x53","0xb6","0xd8","0xc2","0x2e","0xe8","0x92","0x09","0xc8","0xe5","0xc2","0x2f","0xaa","0x91","0x62","0x04","0x6f","0xb5","0xb3","0x00"} }, + { + /* No.86 delta:828 weight:1503 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0xf1a04143,0xe2f3966d,0x1353d72e,0xcea0056c,0x3f00442f,0x2c539301,0xddf3d242,0x0000a274,0xf1a0e337,0xe2f33419,0x1353755a,0xcea0a718,0x3f00e65b,0x2c533175,0xddf37036}, + [16]uint32{0x00000000,0x30214876,0x00001c0b,0x3021547d,0x200c31d8,0x102d79ae,0x200c2dd3,0x102d65a5,0x100201ff,0x20234989,0x10021df4,0x20235582,0x300e3027,0x002f7851,0x300e2c2c,0x002f645a}, + [16]uint32{0x3f800000,0x3f9810a4,0x3f80000e,0x3f9810aa,0x3f900618,0x3f8816bc,0x3f900616,0x3f8816b2,0x3f880100,0x3f9011a4,0x3f88010e,0x3f9011aa,0x3f980718,0x3f8017bc,0x3f980716,0x3f8017b2}, + uint32(0xfff80000), + [21]string{"0xc6","0xaf","0x7a","0x2f","0x8a","0x20","0x8f","0x4a","0x23","0x5e","0x76","0xae","0x77","0xae","0x14","0xe3","0xda","0x07","0x11","0xc7","0x00"} }, + { + /* No.87 delta:607 weight:1543 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0xa4b76d7c,0x45c400c4,0xe1736db8,0x0d300578,0xa9876804,0x48f405bc,0xec4368c0,0x0000422b,0xa4b72f57,0x45c442ef,0xe1732f93,0x0d304753,0xa9872a2f,0x48f44797,0xec432aeb}, + [16]uint32{0x00000000,0xb8015572,0x5000389b,0xe8016de9,0x00401611,0xb8414363,0x50402e8a,0xe8417bf8,0x30002424,0x88017156,0x60001cbf,0xd80149cd,0x30403235,0x88416747,0x60400aae,0xd8415fdc}, + [16]uint32{0x3f800000,0x3fdc00aa,0x3fa8001c,0x3ff400b6,0x3f80200b,0x3fdc20a1,0x3fa82017,0x3ff420bd,0x3f980012,0x3fc400b8,0x3fb0000e,0x3fec00a4,0x3f982019,0x3fc420b3,0x3fb02005,0x3fec20af}, + uint32(0xfff80000), + [21]string{"0x64","0xe3","0xa5","0xfc","0xf9","0x14","0x87","0xba","0xca","0xba","0xcd","0xfe","0xb0","0xc6","0x7c","0xfa","0xc2","0xf1","0xfc","0xff","0x00"} }, + { + /* No.88 delta:1382 weight:1193 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0xd20be97d,0xb3aca4a3,0x61a74dde,0xa690058e,0x749becf3,0x153ca12d,0xc7374850,0x0000b111,0xd20b586c,0xb3ac15b2,0x61a7fccf,0xa690b49f,0x749b5de2,0x153c103c,0xc737f941}, + [16]uint32{0x00000000,0x10024a1d,0x30000417,0x20024e0a,0x0040001b,0x10424a06,0x3040040c,0x20424e11,0x2000080f,0x30024212,0x10000c18,0x00024605,0x20400814,0x30424209,0x10400c03,0x0042461e}, + [16]uint32{0x3f800000,0x3f880125,0x3f980002,0x3f900127,0x3f802000,0x3f882125,0x3f982002,0x3f902127,0x3f900004,0x3f980121,0x3f880006,0x3f800123,0x3f902004,0x3f982121,0x3f882006,0x3f802123}, + uint32(0xfff80000), + [21]string{"0xed","0xf6","0x52","0x4a","0x5a","0x45","0xb6","0xb6","0xfa","0xcf","0x99","0x71","0xde","0x31","0xe2","0x46","0xc7","0x6b","0x19","0x13","0x00"} }, + { + /* No.89 delta:1180 weight:1491 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x2de6b803,0x8b7e4ab5,0xa698f2b6,0x2ff00595,0x0216bd96,0xa48e4f20,0x8968f723,0x00004dc6,0x2de6f5c5,0x8b7e0773,0xa698bf70,0x2ff04853,0x0216f050,0xa48e02e6,0x8968bae5}, + [16]uint32{0x00000000,0x0016287a,0x005e21b9,0x004809c3,0x10390011,0x102f286b,0x106721a8,0x107109d2,0x4020fa8f,0x4036d2f5,0x407edb36,0x4068f34c,0x5019fa9e,0x500fd2e4,0x5047db27,0x5051f35d}, + [16]uint32{0x3f800000,0x3f800b14,0x3f802f10,0x3f802404,0x3f881c80,0x3f881794,0x3f883390,0x3f883884,0x3fa0107d,0x3fa01b69,0x3fa03f6d,0x3fa03479,0x3fa80cfd,0x3fa807e9,0x3fa823ed,0x3fa828f9}, + uint32(0xfff80000), + [21]string{"0x26","0xf5","0x2a","0xf0","0x1f","0x39","0x50","0x05","0xe0","0x65","0xe0","0xb7","0xc1","0x91","0xba","0xbe","0x20","0x11","0x69","0x66","0x00"} }, + { + /* No.90 delta:895 weight:1613 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0xbbe1a4c8,0x719d09e5,0xca7cad2d,0x189005a8,0xa371a160,0x690d0c4d,0xd2eca885,0x00007129,0xbbe1d5e1,0x719d78cc,0xca7cdc04,0x18907481,0xa371d049,0x690d7d64,0xd2ecd9ac}, + [16]uint32{0x00000000,0x403ac91e,0x501d2402,0x1027ed1c,0x0003f418,0x40393d06,0x501ed01a,0x10241904,0x0021118e,0x401bd890,0x503c358c,0x1006fc92,0x0022e596,0x40182c88,0x503fc194,0x1005088a}, + [16]uint32{0x3f800000,0x3fa01d64,0x3fa80e92,0x3f8813f6,0x3f8001fa,0x3fa01c9e,0x3fa80f68,0x3f88120c,0x3f801088,0x3fa00dec,0x3fa81e1a,0x3f88037e,0x3f801172,0x3fa00c16,0x3fa81fe0,0x3f880284}, + uint32(0xfff80000), + [21]string{"0x52","0x4a","0x20","0x7e","0x06","0x76","0xc3","0x1a","0x7c","0x32","0x80","0x84","0x2a","0xe2","0x61","0xa1","0x40","0x18","0xf9","0xdf","0x00"} }, + { + /* No.91 delta:780 weight:1635 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0x03cba17f,0x54ce7bbd,0x5705dac2,0xb42005b7,0xb7eba4c8,0xe0ee7e0a,0xe325df75,0x0000327f,0x03cb9300,0x54ce49c2,0x5705e8bd,0xb42037c8,0xb7eb96b7,0xe0ee4c75,0xe325ed0a}, + [16]uint32{0x00000000,0x3403405a,0x1000c111,0x2403814b,0x0000d014,0x3403904e,0x10001105,0x2403515f,0x04000408,0x30034452,0x1400c519,0x20038543,0x0400d41c,0x30039446,0x1400150d,0x20035557}, + [16]uint32{0x3f800000,0x3f9a01a0,0x3f880060,0x3f9201c0,0x3f800068,0x3f9a01c8,0x3f880008,0x3f9201a8,0x3f820002,0x3f9801a2,0x3f8a0062,0x3f9001c2,0x3f82006a,0x3f9801ca,0x3f8a000a,0x3f9001aa}, + uint32(0xfff80000), + [21]string{"0xed","0x70","0xe5","0x8e","0x42","0xde","0x26","0x57","0xe7","0x69","0xad","0xce","0x2b","0xdb","0x32","0x6d","0xe3","0x81","0xa5","0xcb","0x00"} }, + { + /* No.92 delta:723 weight:1653 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0x8e16d78b,0x6475cd40,0xea631acb,0xef6005c1,0x6176d24a,0x8b15c881,0x05031f0a,0x0000c64c,0x8e1611c7,0x64750b0c,0xea63dc87,0xef60c38d,0x61761406,0x8b150ecd,0x0503d946}, + [16]uint32{0x00000000,0x0006157d,0x3008494f,0x300e5c32,0x000281c6,0x000494bb,0x300ac889,0x300cddf4,0x40008459,0x40069124,0x7008cd16,0x700ed86b,0x4002059f,0x400410e2,0x700a4cd0,0x700c59ad}, + [16]uint32{0x3f800000,0x3f80030a,0x3f980424,0x3f98072e,0x3f800140,0x3f80024a,0x3f980564,0x3f98066e,0x3fa00042,0x3fa00348,0x3fb80466,0x3fb8076c,0x3fa00102,0x3fa00208,0x3fb80526,0x3fb8062c}, + uint32(0xfff80000), + [21]string{"0xc2","0x1f","0xf1","0xdf","0x5c","0xfe","0x71","0xcc","0x49","0x9f","0x31","0x60","0x70","0x60","0xf6","0x07","0xfe","0xac","0xe8","0x47","0x00"} }, + { + /* No.93 delta:575 weight:1639 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x3d168a5a,0xef7b6b30,0xd26de16a,0xeda005d7,0xd0b68f8d,0x02db6ee7,0x3fcde4bd,0x00005226,0x3d16d87c,0xef7b3916,0xd26db34c,0xeda057f1,0xd0b6ddab,0x02db3cc1,0x3fcdb69b}, + [16]uint32{0x00000000,0x4003c13a,0x10004815,0x5003892f,0x4020101c,0x0023d126,0x50205809,0x10239933,0x60002c17,0x2003ed2d,0x70006402,0x3003a538,0x20203c0b,0x6023fd31,0x3020741e,0x7023b524}, + [16]uint32{0x3f800000,0x3fa001e0,0x3f880024,0x3fa801c4,0x3fa01008,0x3f8011e8,0x3fa8102c,0x3f8811cc,0x3fb00016,0x3f9001f6,0x3fb80032,0x3f9801d2,0x3f90101e,0x3fb011fe,0x3f98103a,0x3fb811da}, + uint32(0xfff80000), + [21]string{"0x0f","0xe1","0x48","0x51","0x21","0xf0","0x2d","0xc4","0x7c","0xec","0x9f","0x73","0x68","0x9d","0x0b","0xdf","0x77","0x24","0xcb","0x77","0x00"} }, + { + /* No.94 delta:1168 weight:1445 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x100553e0,0x60a5e657,0x70a0b5b7,0x188005ee,0x0885560e,0x7825e3b9,0x6820b059,0x000077ef,0x1005240f,0x60a591b8,0x70a0c258,0x18807201,0x088521e1,0x78259456,0x6820c7b6}, + [16]uint32{0x00000000,0x20040036,0x00428925,0x20468913,0x2043401f,0x00474029,0x2001c93a,0x0005c90c,0x604848e4,0x404c48d2,0x600ac1c1,0x400ec1f7,0x400b08fb,0x600f08cd,0x404981de,0x604d81e8}, + [16]uint32{0x3f800000,0x3f900200,0x3f802144,0x3f902344,0x3f9021a0,0x3f8023a0,0x3f9000e4,0x3f8002e4,0x3fb02424,0x3fa02624,0x3fb00560,0x3fa00760,0x3fa00584,0x3fb00784,0x3fa024c0,0x3fb026c0}, + uint32(0xfff80000), + [21]string{"0xaa","0x81","0xeb","0x85","0xab","0x03","0xbb","0x80","0x2e","0x38","0x36","0x94","0xb2","0x7b","0xd5","0x39","0x3f","0x8f","0x44","0x22","0x00"} }, + { + /* No.95 delta:874 weight:1655 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xa9f511af,0xe424f2f4,0x4dd1e35b,0x17c005f3,0xbe35145c,0xf3e4f707,0x5a11e6a8,0x00000d8b,0xa9f51c24,0xe424ff7f,0x4dd1eed0,0x17c00878,0xbe3519d7,0xf3e4fa8c,0x5a11eb23}, + [16]uint32{0x00000000,0x908240ba,0x00030d87,0x90814d3d,0x1080101f,0x800250a5,0x10831d98,0x80015d22,0x3012920e,0xa090d2b4,0x30119f89,0xa093df33,0x20928211,0xb010c2ab,0x20918f96,0xb013cf2c}, + [16]uint32{0x3f800000,0x3fc84120,0x3f800186,0x3fc840a6,0x3f884008,0x3fc00128,0x3f88418e,0x3fc000ae,0x3f980949,0x3fd04869,0x3f9808cf,0x3fd049ef,0x3f904941,0x3fd80861,0x3f9048c7,0x3fd809e7}, + uint32(0xfff80000), + [21]string{"0xa0","0xed","0x8a","0xea","0x95","0xb5","0x41","0xea","0xbb","0xc9","0x2a","0x0a","0x89","0x15","0x5b","0x68","0x5b","0xb0","0x11","0x6d","0x00"} }, + { + /* No.96 delta:861 weight:1191 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0x77c881e2,0xe42dd114,0x93e550f6,0x8be00606,0xfc2887e4,0x6fcdd712,0x180556f0,0x00008be7,0x77c80a05,0xe42d5af3,0x93e5db11,0x8be08de1,0xfc280c03,0x6fcd5cf5,0x1805dd17}, + [16]uint32{0x00000000,0x0077459e,0x4008115b,0x407f54c5,0x500201cd,0x50754453,0x100a1096,0x107d5508,0x000a00c7,0x007d4559,0x4002119c,0x40755402,0x5008010a,0x507f4494,0x10001051,0x107755cf}, + [16]uint32{0x3f800000,0x3f803ba2,0x3fa00408,0x3fa03faa,0x3fa80100,0x3fa83aa2,0x3f880508,0x3f883eaa,0x3f800500,0x3f803ea2,0x3fa00108,0x3fa03aaa,0x3fa80400,0x3fa83fa2,0x3f880008,0x3f883baa}, + uint32(0xfff80000), + [21]string{"0x33","0x7e","0x21","0x5c","0x53","0x94","0xc7","0x17","0x10","0x34","0x52","0x6f","0x67","0x0e","0x45","0x13","0xbf","0xca","0x19","0xe8","0x00"} }, + { + /* No.97 delta:2676 weight:853 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0xbd6a2668,0xcc9d55b7,0x71f773df,0x3110061c,0x8c7a2074,0xfd8d53ab,0x40e775c3,0x00008fa3,0xbd6aa9cb,0xcc9dda14,0x71f7fc7c,0x311089bf,0x8c7aafd7,0xfd8ddc08,0x40e7fa60}, + [16]uint32{0x00000000,0x8e8000fa,0x4181077f,0xcf010785,0x0c81e018,0x8201e0e2,0x4d00e767,0xc380e79d,0x02806af4,0x8c006a0e,0x43016d8b,0xcd816d71,0x0e018aec,0x80818a16,0x4f808d93,0xc1008d69}, + [16]uint32{0x3f800000,0x3fc74000,0x3fa0c083,0x3fe78083,0x3f8640f0,0x3fc100f0,0x3fa68073,0x3fe1c073,0x3f814035,0x3fc60035,0x3fa180b6,0x3fe6c0b6,0x3f8700c5,0x3fc040c5,0x3fa7c046,0x3fe08046}, + uint32(0xfff80000), + [21]string{"0x38","0x47","0x11","0xb2","0x01","0x45","0xb4","0xc5","0x3c","0xee","0x80","0x03","0x22","0xf6","0xc5","0x68","0x67","0x28","0xe1","0xf0","0x00"} }, + { + /* No.98 delta:827 weight:1491 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x0915d02d,0x72064141,0x7b13916c,0x2840062e,0x2155d603,0x5a46476f,0x53539742,0x0000b9fc,0x091569d1,0x7206f8bd,0x7b132890,0x2840bfd2,0x21556fff,0x5a46fe93,0x53532ebe}, + [16]uint32{0x00000000,0x083d1115,0x0002041c,0x083f1509,0x0001ae5b,0x083cbf4e,0x0003aa47,0x083ebb52,0x2004c174,0x2839d061,0x2006c568,0x283bd47d,0x20056f2f,0x28387e3a,0x20076b33,0x283a7a26}, + [16]uint32{0x3f800000,0x3f841e88,0x3f800102,0x3f841f8a,0x3f8000d7,0x3f841e5f,0x3f8001d5,0x3f841f5d,0x3f900260,0x3f941ce8,0x3f900362,0x3f941dea,0x3f9002b7,0x3f941c3f,0x3f9003b5,0x3f941d3d}, + uint32(0xfff80000), + [21]string{"0xca","0x80","0x3a","0x23","0x9d","0x6c","0x94","0x61","0x87","0xfb","0xb8","0xf2","0xda","0xec","0x64","0x91","0x28","0x87","0x26","0xd6","0x00"} }, + { + /* No.99 delta:708 weight:1311 */ + 11213, + 64, + 13, + 4, + [16]uint32{0x00000000,0xce20c03e,0x994236e0,0x5762f6de,0xc9300632,0x0710c60c,0x507230d2,0x9e52f0ec,0x0000a7af,0xce206791,0x9942914f,0x57625171,0xc930a19d,0x071061a3,0x5072977d,0x9e525743}, + [16]uint32{0x00000000,0x4101741e,0x8020818b,0xc121f595,0x40033011,0x0102440f,0xc023b19a,0x8122c584,0x000101fc,0x410075e2,0x80218077,0xc120f469,0x400231ed,0x010345f3,0xc022b066,0x8123c478}, + [16]uint32{0x3f800000,0x3fa080ba,0x3fc01040,0x3fe090fa,0x3fa00198,0x3f808122,0x3fe011d8,0x3fc09162,0x3f800080,0x3fa0803a,0x3fc010c0,0x3fe0907a,0x3fa00118,0x3f8081a2,0x3fe01158,0x3fc091e2}, + uint32(0xfff80000), + [21]string{"0xdf","0xbf","0x75","0x14","0x07","0x6a","0xc5","0x64","0x4f","0xc6","0xe3","0x60","0x4e","0x50","0xe0","0xa1","0x15","0x2e","0x91","0x98","0x00"} }, + { + /* No.100 delta:1786 weight:1467 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x981c6d4d,0xc6e26a11,0x5efe075c,0xddc00649,0x45dc6b04,0x1b226c58,0x833e0115,0x0000ca50,0x981ca71d,0xc6e2a041,0x5efecd0c,0xddc0cc19,0x45dca154,0x1b22a608,0x833ecb45}, + [16]uint32{0x00000000,0x20c503f2,0x005801d7,0x209d0225,0x006c0011,0x20a903e3,0x003401c6,0x20f10234,0x000500a9,0x20c0035b,0x005d017e,0x2098028c,0x006900b8,0x20ac034a,0x0031016f,0x20f4029d}, + [16]uint32{0x3f800000,0x3f906281,0x3f802c00,0x3f904e81,0x3f803600,0x3f905481,0x3f801a00,0x3f907881,0x3f800280,0x3f906001,0x3f802e80,0x3f904c01,0x3f803480,0x3f905601,0x3f801880,0x3f907a01}, + uint32(0xfff80000), + [21]string{"0x6c","0x2a","0xd8","0xe1","0xb3","0x20","0xd0","0xd8","0xb2","0x06","0x11","0x6f","0xd5","0x68","0xed","0xd8","0xf6","0xd8","0x6a","0x7f","0x00"} }, + { + /* No.101 delta:615 weight:1671 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0x2fc3606f,0x866cdf27,0xa9afbf48,0x5a500657,0x75936638,0xdc3cd970,0xf3ffb91f,0x000086e4,0x2fc3e68b,0x866c59c3,0xa9af39ac,0x5a5080b3,0x7593e0dc,0xdc3c5f94,0xf3ff3ffb}, + [16]uint32{0x00000000,0x0003c9f5,0x503ca9b1,0x503f6044,0x0040501e,0x004399eb,0x507cf9af,0x507f305a,0x10101326,0x1013dad3,0x402cba97,0x402f7362,0x10504338,0x10538acd,0x406cea89,0x406f237c}, + [16]uint32{0x3f800000,0x3f8001e4,0x3fa81e54,0x3fa81fb0,0x3f802028,0x3f8021cc,0x3fa83e7c,0x3fa83f98,0x3f880809,0x3f8809ed,0x3fa0165d,0x3fa017b9,0x3f882821,0x3f8829c5,0x3fa03675,0x3fa03791}, + uint32(0xfff80000), + [21]string{"0x09","0xb2","0xd9","0x88","0x39","0x98","0x64","0xbb","0x2b","0x23","0x3f","0x58","0xc9","0x59","0xb2","0x4f","0xbf","0xa5","0x49","0x32","0x00"} }, + { + /* No.102 delta:1133 weight:1553 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x3b16c68a,0x56b5b9f3,0x6da37f79,0xdde00663,0xe6f6c0e9,0x8b55bf90,0xb043791a,0x0000b22c,0x3b1674a6,0x56b50bdf,0x6da3cd55,0xdde0b44f,0xe6f672c5,0x8b550dbc,0xb043cb36}, + [16]uint32{0x00000000,0x0050209e,0x20042152,0x205401cc,0x512001e5,0x5170217b,0x712420b7,0x71740029,0x8008080f,0x80582891,0xa00c295d,0xa05c09c3,0xd12809ea,0xd1782974,0xf12c28b8,0xf17c0826}, + [16]uint32{0x3f800000,0x3f802810,0x3f900210,0x3f902a00,0x3fa89000,0x3fa8b810,0x3fb89210,0x3fb8ba00,0x3fc00404,0x3fc02c14,0x3fd00614,0x3fd02e04,0x3fe89404,0x3fe8bc14,0x3ff89614,0x3ff8be04}, + uint32(0xfff80000), + [21]string{"0x3b","0x5d","0x87","0x3e","0x94","0x58","0x84","0xcc","0x7e","0x4e","0xde","0xc6","0x0c","0x67","0x79","0xfc","0x9f","0x6d","0x46","0xbd","0x00"} }, + { + /* No.103 delta:811 weight:1325 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xd5a39580,0x4e8f650d,0x9b2cf08d,0x0970067f,0xdcd393ff,0x47ff6372,0x925cf6f2,0x0000763a,0xd5a3e3ba,0x4e8f1337,0x9b2c86b7,0x09707045,0xdcd3e5c5,0x47ff1548,0x925c80c8}, + [16]uint32{0x00000000,0x45650a5f,0x007910dc,0x451c1a83,0x00051015,0x45601a4a,0x007c00c9,0x45190a96,0x5a046011,0x1f616a4e,0x5a7d70cd,0x1f187a92,0x5a017004,0x1f647a5b,0x5a7860d8,0x1f1d6a87}, + [16]uint32{0x3f800000,0x3fa2b285,0x3f803c88,0x3fa28e0d,0x3f800288,0x3fa2b00d,0x3f803e00,0x3fa28c85,0x3fad0230,0x3f8fb0b5,0x3fad3eb8,0x3f8f8c3d,0x3fad00b8,0x3f8fb23d,0x3fad3c30,0x3f8f8eb5}, + uint32(0xfff80000), + [21]string{"0x6f","0x58","0x8b","0x82","0xd5","0x56","0xd7","0xf2","0x15","0xea","0x59","0xc4","0x57","0xcc","0xfd","0x6c","0x15","0xb2","0xb8","0xe6","0x00"} }, + { + /* No.104 delta:909 weight:1351 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x9e28fdaf,0xa1b52cd6,0x3f9dd179,0xb720068d,0x2908fb22,0x16952a5b,0x88bdd7f4,0x0000f73d,0x9e280a92,0xa1b5dbeb,0x3f9d2644,0xb720f1b0,0x29080c1f,0x1695dd66,0x88bd20c9}, + [16]uint32{0x00000000,0x00a718d2,0x40620151,0x40c51983,0x04400086,0x04e71854,0x442201d7,0x44851905,0x21098019,0x21ae98cb,0x616b8148,0x61cc999a,0x2549809f,0x25ee984d,0x652b81ce,0x658c991c}, + [16]uint32{0x3f800000,0x3f80538c,0x3fa03100,0x3fa0628c,0x3f822000,0x3f82738c,0x3fa21100,0x3fa2428c,0x3f9084c0,0x3f90d74c,0x3fb0b5c0,0x3fb0e64c,0x3f92a4c0,0x3f92f74c,0x3fb295c0,0x3fb2c64c}, + uint32(0xfff80000), + [21]string{"0x15","0x66","0xae","0x57","0x60","0x6c","0xc6","0x24","0xbc","0x0d","0xc3","0xd2","0xf9","0x60","0xc8","0x33","0x56","0x5b","0x5c","0x9e","0x00"} }, + { + /* No.105 delta:1214 weight:1739 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x1881a49b,0x3034feaa,0x28b55a31,0x9ba00692,0x8321a209,0xab94f838,0xb3155ca3,0x00008b7d,0x18812fe6,0x303475d7,0x28b5d14c,0x9ba08def,0x83212974,0xab947345,0xb315d7de}, + [16]uint32{0x00000000,0xa00c0172,0x504021ff,0xf04c208d,0x6018048e,0xc01405fc,0x30582571,0x90542403,0x007840db,0xa07441a9,0x50386124,0xf0346056,0x60604455,0xc06c4527,0x302065aa,0x902c64d8}, + [16]uint32{0x3f800000,0x3fd00600,0x3fa82010,0x3ff82610,0x3fb00c02,0x3fe00a02,0x3f982c12,0x3fc82a12,0x3f803c20,0x3fd03a20,0x3fa81c30,0x3ff81a30,0x3fb03022,0x3fe03622,0x3f981032,0x3fc81632}, + uint32(0xfff80000), + [21]string{"0x3d","0xee","0x4f","0xc8","0x97","0xc3","0x5d","0x81","0xe2","0xee","0xd8","0xfe","0x39","0x57","0x22","0xe1","0x6b","0x53","0xef","0x01","0x00"} }, + { + /* No.106 delta:1179 weight:1561 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x24c5846f,0x36a1a146,0x12642529,0xf43006ab,0xd0f582c4,0xc291a7ed,0xe6542382,0x0000698b,0x24c5ede4,0x36a1c8cd,0x12644ca2,0xf4306f20,0xd0f5eb4f,0xc291ce66,0xe6544a09}, + [16]uint32{0x00000000,0x0064ce12,0x80389018,0x805c5e0a,0x10030803,0x1067c611,0x903b981b,0x905f5609,0x1000fc01,0x10643213,0x90386c19,0x905ca20b,0x0003f402,0x00673a10,0x803b641a,0x805faa08}, + [16]uint32{0x3f800000,0x3f803267,0x3fc01c48,0x3fc02e2f,0x3f880184,0x3f8833e3,0x3fc81dcc,0x3fc82fab,0x3f88007e,0x3f883219,0x3fc81c36,0x3fc82e51,0x3f8001fa,0x3f80339d,0x3fc01db2,0x3fc02fd5}, + uint32(0xfff80000), + [21]string{"0xb7","0xa8","0x13","0x1a","0x7b","0xa0","0xe7","0x3f","0x3d","0xd3","0x79","0x84","0x0c","0x9e","0xc3","0xc7","0xaf","0xe4","0xc5","0x89","0x00"} }, + { + /* No.107 delta:1739 weight:1481 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0xee4529e6,0x874b1cc0,0x690e3526,0x976006bc,0x79252f5a,0x102b1a7c,0xfe6e339a,0x0000ad84,0xee458462,0x874bb144,0x690e98a2,0x9760ab38,0x792582de,0x102bb7f8,0xfe6e9e1e}, + [16]uint32{0x00000000,0x4064011d,0x007e01ab,0x401a00b6,0x000201f3,0x406600ee,0x007c0058,0x40180145,0x0000013c,0x40640021,0x007e0097,0x401a018a,0x000200cf,0x406601d2,0x007c0164,0x40180079}, + [16]uint32{0x3f800000,0x3fa03200,0x3f803f00,0x3fa00d00,0x3f800100,0x3fa03300,0x3f803e00,0x3fa00c00,0x3f800000,0x3fa03200,0x3f803f00,0x3fa00d00,0x3f800100,0x3fa03300,0x3f803e00,0x3fa00c00}, + uint32(0xfff80000), + [21]string{"0x1d","0x5d","0x6c","0x4c","0xff","0xe9","0xda","0x62","0xb7","0x42","0xb0","0x5c","0x89","0x06","0x2f","0x9e","0xdd","0xbd","0x57","0xb4","0x00"} }, + { + /* No.108 delta:702 weight:1537 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xa61eb29f,0xe4028f27,0x421c3db8,0xe31006c9,0x450eb456,0x071289ee,0xa10c3b71,0x000034cf,0xa61e8650,0xe402bbe8,0x421c0977,0xe3103206,0x450e8099,0x0712bd21,0xa10c0fbe}, + [16]uint32{0x00000000,0x306c40f5,0x0052410e,0x303e01fb,0x10920342,0x20fe43b7,0x10c0424c,0x20ac02b9,0x200800c3,0x10644036,0x205a41cd,0x10360138,0x309a0381,0x00f64374,0x30c8428f,0x00a4027a}, + [16]uint32{0x3f800000,0x3f983620,0x3f802920,0x3f981f00,0x3f884901,0x3f907f21,0x3f886021,0x3f905601,0x3f900400,0x3f883220,0x3f902d20,0x3f881b00,0x3f984d01,0x3f807b21,0x3f986421,0x3f805201}, + uint32(0xfff80000), + [21]string{"0x4c","0xe2","0x2a","0x1c","0x8e","0xad","0xc1","0x99","0x25","0xec","0x54","0xf7","0x2f","0x18","0x4f","0x98","0xaa","0xe2","0x63","0xaa","0x00"} }, + { + /* No.109 delta:1143 weight:1537 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x4f009f44,0xec9355d5,0xa393ca91,0xfc0006d8,0xb300999c,0x1093530d,0x5f93cc49,0x0000fd15,0x4f006251,0xec93a8c0,0xa3933784,0xfc00fbcd,0xb3006489,0x1093ae18,0x5f93315c}, + [16]uint32{0x00000000,0x400e1032,0x00092919,0x4007392b,0x006c38a7,0x40622895,0x006511be,0x406b018c,0x4052e15f,0x005cf16d,0x405bc846,0x0055d874,0x403ed9f8,0x0030c9ca,0x4037f0e1,0x0039e0d3}, + [16]uint32{0x3f800000,0x3fa00708,0x3f800494,0x3fa0039c,0x3f80361c,0x3fa03114,0x3f803288,0x3fa03580,0x3fa02970,0x3f802e78,0x3fa02de4,0x3f802aec,0x3fa01f6c,0x3f801864,0x3fa01bf8,0x3f801cf0}, + uint32(0xfff80000), + [21]string{"0x15","0xc6","0x81","0xbd","0xc5","0x3a","0xd0","0xc7","0x24","0xad","0x87","0x5f","0x74","0xa5","0xb7","0xc1","0x6d","0xc6","0x85","0xdc","0x00"} }, + { + /* No.110 delta:910 weight:1209 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0xf914b93f,0x23aeca7f,0xdaba7340,0x44e006e2,0xbdf4bfdd,0x674ecc9d,0x9e5a75a2,0x0000456f,0xf914fc50,0x23ae8f10,0xdaba362f,0x44e0438d,0xbdf4fab2,0x674e89f2,0x9e5a30cd}, + [16]uint32{0x00000000,0x406d91d2,0x10023de6,0x506fac34,0x1000511a,0x506dc0c8,0x00026cfc,0x406ffd2e,0x40184c07,0x0075ddd5,0x501a71e1,0x1077e033,0x50181d1d,0x10758ccf,0x401a20fb,0x0077b129}, + [16]uint32{0x3f800000,0x3fa036c8,0x3f88011e,0x3fa837d6,0x3f880028,0x3fa836e0,0x3f800136,0x3fa037fe,0x3fa00c26,0x3f803aee,0x3fa80d38,0x3f883bf0,0x3fa80c0e,0x3f883ac6,0x3fa00d10,0x3f803bd8}, + uint32(0xfff80000), + [21]string{"0x83","0x91","0x1a","0xa2","0x3a","0x01","0xc4","0x60","0xfe","0xfc","0xd0","0x70","0x7b","0xef","0x38","0x48","0x8f","0x98","0xfa","0x44","0x00"} }, + { + /* No.111 delta:587 weight:1251 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0xec78402c,0xf8d2123a,0x14aa5216,0xb61006ff,0x5a6846d3,0x4ec214c5,0xa2ba54e9,0x0000e95f,0xec78a973,0xf8d2fb65,0x14aabb49,0xb610efa0,0x5a68af8c,0x4ec2fd9a,0xa2babdb6}, + [16]uint32{0x00000000,0x40028d76,0x50044a0b,0x1006c77d,0x6001c20f,0x20034f79,0x30058804,0x70070572,0x200065e7,0x6002e891,0x70042fec,0x3006a29a,0x4001a7e8,0x00032a9e,0x1005ede3,0x50076095}, + [16]uint32{0x3f800000,0x3fa00146,0x3fa80225,0x3f880363,0x3fb000e1,0x3f9001a7,0x3f9802c4,0x3fb80382,0x3f900032,0x3fb00174,0x3fb80217,0x3f980351,0x3fa000d3,0x3f800195,0x3f8802f6,0x3fa803b0}, + uint32(0xfff80000), + [21]string{"0x90","0xec","0x33","0x35","0xf4","0x57","0xba","0x69","0x2a","0xd4","0xb9","0x92","0x2f","0xb6","0x45","0x3c","0x1d","0x82","0xbc","0xcc","0x00"} }, + { + /* No.112 delta:733 weight:1123 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xf03b5e04,0xfbe77025,0x0bdc2e21,0xec900702,0x1cab5906,0x17777727,0xe74c2923,0x00008094,0xf03bde90,0xfbe7f0b1,0x0bdcaeb5,0xec908796,0x1cabd992,0x1777f7b3,0xe74ca9b7}, + [16]uint32{0x00000000,0x406c0cf7,0x50414e9a,0x102d426d,0x00401411,0x402c18e6,0x50015a8b,0x106d567c,0x60098402,0x206588f5,0x3048ca98,0x7024c66f,0x60499013,0x20259ce4,0x3008de89,0x7064d27e}, + [16]uint32{0x3f800000,0x3fa03606,0x3fa820a7,0x3f8816a1,0x3f80200a,0x3fa0160c,0x3fa800ad,0x3f8836ab,0x3fb004c2,0x3f9032c4,0x3f982465,0x3fb81263,0x3fb024c8,0x3f9012ce,0x3f98046f,0x3fb83269}, + uint32(0xfff80000), + [21]string{"0x21","0xcc","0x88","0xfe","0xbf","0x09","0xdb","0xf4","0xcc","0xac","0xb9","0x48","0xc6","0x11","0x42","0x45","0x08","0xcf","0x55","0xf8","0x00"} }, + { + /* No.113 delta:961 weight:1485 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0xf8e15148,0xcf71a664,0x3790f72c,0x55a0071e,0xad415656,0x9ad1a17a,0x6230f032,0x00004daa,0xf8e11ce2,0xcf71ebce,0x3790ba86,0x55a04ab4,0xad411bfc,0x9ad1ecd0,0x6230bd98}, + [16]uint32{0x00000000,0x20142173,0x50001eed,0x70143f9e,0x007e01db,0x206a20a8,0x507e1f36,0x706a3e45,0x00029019,0x2016b16a,0x50028ef4,0x7016af87,0x007c91c2,0x2068b0b1,0x507c8f2f,0x7068ae5c}, + [16]uint32{0x3f800000,0x3f900a10,0x3fa8000f,0x3fb80a1f,0x3f803f00,0x3f903510,0x3fa83f0f,0x3fb8351f,0x3f800148,0x3f900b58,0x3fa80147,0x3fb80b57,0x3f803e48,0x3f903458,0x3fa83e47,0x3fb83457}, + uint32(0xfff80000), + [21]string{"0x9f","0xa0","0xe0","0xda","0x23","0xbf","0xa1","0xb7","0xb0","0xeb","0x5d","0xf4","0x6e","0xcb","0xa1","0x43","0xf7","0x9b","0x0e","0x6c","0x00"} }, + { + /* No.114 delta:1259 weight:1687 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0x3f45045b,0x4e9e0af7,0x71db0eac,0x6140072d,0x5e050376,0x2fde0dda,0x109b0981,0x0000e7b0,0x3f45e3eb,0x4e9eed47,0x71dbe91c,0x6140e09d,0x5e05e4c6,0x2fdeea6a,0x109bee31}, + [16]uint32{0x00000000,0x300c059a,0x405e408f,0x70524515,0x20285cdc,0x10245946,0x60761c53,0x507a19c9,0x24482218,0x14442782,0x64166297,0x541a670d,0x04607ec4,0x346c7b5e,0x443e3e4b,0x74323bd1}, + [16]uint32{0x3f800000,0x3f980602,0x3fa02f20,0x3fb82922,0x3f90142e,0x3f88122c,0x3fb03b0e,0x3fa83d0c,0x3f922411,0x3f8a2213,0x3fb20b31,0x3faa0d33,0x3f82303f,0x3f9a363d,0x3fa21f1f,0x3fba191d}, + uint32(0xfff80000), + [21]string{"0xf4","0x32","0x1b","0x7a","0xe6","0x66","0x05","0xfc","0x41","0xb9","0x19","0x2a","0x8f","0xba","0x14","0xbe","0x8d","0x4f","0xd4","0x55","0x00"} }, + { + /* No.115 delta:1749 weight:1509 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0xc9a19456,0xd71166f0,0x1eb0f2a6,0xdd60073e,0x14c19368,0x0a7161ce,0xc3d0f598,0x00002adc,0xc9a1be8a,0xd7114c2c,0x1eb0d87a,0xdd602de2,0x14c1b9b4,0x0a714b12,0xc3d0df44}, + [16]uint32{0x00000000,0x42ac41fb,0x1080a407,0x522ce5fc,0x08448816,0x4ae8c9ed,0x18c42c11,0x5a686dea,0x20600822,0x62cc49d9,0x30e0ac25,0x724cedde,0x28248034,0x6a88c1cf,0x38a42433,0x7a0865c8}, + [16]uint32{0x3f800000,0x3fa15620,0x3f884052,0x3fa91672,0x3f842244,0x3fa57464,0x3f8c6216,0x3fad3436,0x3f903004,0x3fb16624,0x3f987056,0x3fb92676,0x3f941240,0x3fb54460,0x3f9c5212,0x3fbd0432}, + uint32(0xfff80000), + [21]string{"0x45","0xb5","0x72","0x39","0xb8","0xc6","0x3e","0xc7","0x26","0xde","0x33","0xeb","0xc0","0xc2","0x54","0xfa","0x37","0x18","0x9c","0xc9","0x00"} }, + { + /* No.116 delta:881 weight:973 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x43507563,0x0a62d22e,0x4932a74d,0xc2b00743,0x81e07220,0xc8d2d56d,0x8b82a00e,0x0000b615,0x4350c376,0x0a62643b,0x49321158,0xc2b0b156,0x81e0c435,0xc8d26378,0x8b82161b}, + [16]uint32{0x00000000,0x4000989f,0x0803e4ee,0x48037c71,0x0021cc48,0x402154d7,0x082228a6,0x4822b039,0x20023124,0x6002a9bb,0x2801d5ca,0x68014d55,0x2023fd6c,0x602365f3,0x28201982,0x6820811d}, + [16]uint32{0x3f800000,0x3fa0004c,0x3f8401f2,0x3fa401be,0x3f8010e6,0x3fa010aa,0x3f841114,0x3fa41158,0x3f900118,0x3fb00154,0x3f9400ea,0x3fb400a6,0x3f9011fe,0x3fb011b2,0x3f94100c,0x3fb41040}, + uint32(0xfff80000), + [21]string{"0x36","0x5e","0x9b","0x40","0x8b","0x86","0xee","0x44","0xd5","0x89","0xa1","0x27","0x1e","0xb0","0x35","0x38","0x90","0x44","0xf0","0x85","0x00"} }, + { + /* No.117 delta:1063 weight:1401 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0xf3e49888,0x5ca452bc,0xaf40ca34,0xb9300752,0x4ad49fda,0xe59455ee,0x1670cd66,0x00008d1b,0xf3e41593,0x5ca4dfa7,0xaf40472f,0xb9308a49,0x4ad412c1,0xe594d8f5,0x1670407d}, + [16]uint32{0x00000000,0x800249d4,0x10814a9e,0x9083034a,0x10201192,0x90225846,0x00a15b0c,0x80a312d8,0x6001201d,0xe00369c9,0x70806a83,0xf0822357,0x7021318f,0xf023785b,0x60a07b11,0xe0a232c5}, + [16]uint32{0x3f800000,0x3fc00124,0x3f8840a5,0x3fc84181,0x3f881008,0x3fc8112c,0x3f8050ad,0x3fc05189,0x3fb00090,0x3ff001b4,0x3fb84035,0x3ff84111,0x3fb81098,0x3ff811bc,0x3fb0503d,0x3ff05119}, + uint32(0xfff80000), + [21]string{"0x60","0xed","0xc6","0xf3","0xc6","0x80","0xb1","0x3b","0xc1","0x64","0x78","0x4b","0x3f","0x63","0xbd","0x7b","0xc4","0x0c","0xd9","0x39","0x00"} }, + { + /* No.118 delta:1137 weight:1497 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x71930aea,0x570aa1e5,0x2699ab0f,0xcc600761,0xbdf30d8b,0x9b6aa684,0xeaf9ac6e,0x00005787,0x71935d6d,0x570af662,0x2699fc88,0xcc6050e6,0xbdf35a0c,0x9b6af103,0xeaf9fbe9}, + [16]uint32{0x00000000,0x0045283e,0x00010852,0x0044206c,0x102c0195,0x106929ab,0x102d09c7,0x106821f9,0x0000441f,0x00456c21,0x00014c4d,0x00446473,0x102c458a,0x10696db4,0x102d4dd8,0x106865e6}, + [16]uint32{0x3f800000,0x3f802294,0x3f800084,0x3f802210,0x3f881600,0x3f883494,0x3f881684,0x3f883410,0x3f800022,0x3f8022b6,0x3f8000a6,0x3f802232,0x3f881622,0x3f8834b6,0x3f8816a6,0x3f883432}, + uint32(0xfff80000), + [21]string{"0x3f","0x85","0x79","0x0e","0x9f","0xcf","0x7a","0xf1","0x61","0x7a","0x2f","0x3e","0x53","0x2c","0xba","0x5f","0x95","0x72","0xb1","0xaf","0x00"} }, + { + /* No.119 delta:2081 weight:1319 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x5de13e8c,0xaf27000d,0xf2c63e81,0xe4c00772,0xb92139fe,0x4be7077f,0x160639f3,0x0000339b,0x5de10d17,0xaf273396,0xf2c60d1a,0xe4c034e9,0xb9210a65,0x4be734e4,0x16060a68}, + [16]uint32{0x00000000,0x0cfc0054,0x0a801c7b,0x067c1c2f,0x06b26091,0x0a4e60c5,0x0c327cea,0x00ce7cbe,0x06038017,0x0aff8043,0x0c839c6c,0x007f9c38,0x00b1e086,0x0c4de0d2,0x0a31fcfd,0x06cdfca9}, + [16]uint32{0x3f800000,0x3f867e00,0x3f85400e,0x3f833e0e,0x3f835930,0x3f852730,0x3f86193e,0x3f80673e,0x3f8301c0,0x3f857fc0,0x3f8641ce,0x3f803fce,0x3f8058f0,0x3f8626f0,0x3f8518fe,0x3f8366fe}, + uint32(0xfff80000), + [21]string{"0x0d","0x39","0xf3","0x78","0x89","0x68","0xeb","0xd5","0x15","0x9f","0x5c","0x20","0xc1","0x91","0x35","0xe8","0x14","0x9a","0x0a","0x34","0x00"} }, + { + /* No.120 delta:938 weight:1729 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x5ad5c7fc,0x50877aee,0x0a52bd12,0x0f400787,0x5595c07b,0x5fc77d69,0x0512ba95,0x0000b61e,0x5ad571e2,0x5087ccf0,0x0a520b0c,0x0f40b199,0x55957665,0x5fc7cb77,0x05120c8b}, + [16]uint32{0x00000000,0x00234632,0x000208b7,0x00214e85,0x206c297e,0x204f6f4c,0x206e21c9,0x204d67fb,0x90145093,0x903716a1,0x90165824,0x90351e16,0xb07879ed,0xb05b3fdf,0xb07a715a,0xb0593768}, + [16]uint32{0x3f800000,0x3f8011a3,0x3f800104,0x3f8010a7,0x3f903614,0x3f9027b7,0x3f903710,0x3f9026b3,0x3fc80a28,0x3fc81b8b,0x3fc80b2c,0x3fc81a8f,0x3fd83c3c,0x3fd82d9f,0x3fd83d38,0x3fd82c9b}, + uint32(0xfff80000), + [21]string{"0x53","0x85","0x3f","0x41","0x21","0x4b","0x43","0x04","0x88","0x1d","0x85","0xcd","0x7c","0xf6","0x24","0x1b","0x9b","0x62","0xb7","0xbc","0x00"} }, + { + /* No.121 delta:1254 weight:1595 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xf4721b6f,0x38780238,0xcc0a1957,0x0a800791,0xfef21cfe,0x32f805a9,0xc68a1ec6,0x00008e00,0xf472956f,0x38788c38,0xcc0a9757,0x0a808991,0xfef292fe,0x32f88ba9,0xc68a90c6}, + [16]uint32{0x00000000,0x105500de,0x504089f2,0x4015892c,0x2010110b,0x304511d5,0x705098f9,0x60059827,0x00644410,0x103144ce,0x5024cde2,0x4071cd3c,0x2074551b,0x302155c5,0x7034dce9,0x6061dc37}, + [16]uint32{0x3f800000,0x3f882a80,0x3fa82044,0x3fa00ac4,0x3f900808,0x3f982288,0x3fb8284c,0x3fb002cc,0x3f803222,0x3f8818a2,0x3fa81266,0x3fa038e6,0x3f903a2a,0x3f9810aa,0x3fb81a6e,0x3fb030ee}, + uint32(0xfff80000), + [21]string{"0x25","0xb4","0x83","0xd2","0x14","0x30","0xa0","0x57","0x76","0x91","0x93","0x5e","0x6b","0x3a","0x16","0x61","0x4b","0x33","0xd7","0x9d","0x00"} }, + { + /* No.122 delta:2273 weight:1235 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x687364d2,0xba9856f7,0xd2eb3225,0x654007a9,0x0d33637b,0xdfd8515e,0xb7ab358c,0x00009222,0x6873f6f0,0xba98c4d5,0xd2eba007,0x6540958b,0x0d33f159,0xdfd8c37c,0xb7aba7ae}, + [16]uint32{0x00000000,0x247a41dc,0x3b8c83a3,0x1ff6c27f,0x804ca051,0xa436e18d,0xbbc023f2,0x9fba622e,0x29340c18,0x0d4e4dc4,0x12b88fbb,0x36c2ce67,0xa978ac49,0x8d02ed95,0x92f42fea,0xb68e6e36}, + [16]uint32{0x3f800000,0x3f923d20,0x3f9dc641,0x3f8ffb61,0x3fc02650,0x3fd21b70,0x3fdde011,0x3fcfdd31,0x3f949a06,0x3f86a726,0x3f895c47,0x3f9b6167,0x3fd4bc56,0x3fc68176,0x3fc97a17,0x3fdb4737}, + uint32(0xfff80000), + [21]string{"0x16","0xe5","0x70","0x73","0xbe","0x32","0xee","0x39","0x6b","0x15","0xd3","0x8f","0xfb","0xb6","0xa5","0x64","0xa6","0x28","0x10","0x42","0x00"} }, + { + /* No.123 delta:887 weight:1675 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x9ffafe84,0x081afe71,0x97e000f5,0xb02007bf,0x2fdaf93b,0xb83af9ce,0x27c0074a,0x000053a9,0x9ffaad2d,0x081aadd8,0x97e0535c,0xb0205416,0x2fdaaa92,0xb83aaa67,0x27c054e3}, + [16]uint32{0x00000000,0x5024f876,0x4002e819,0x1026106f,0x00020174,0x5026f902,0x4000e96d,0x1024111b,0x008101f0,0x50a5f986,0x4083e9e9,0x10a7119f,0x00830084,0x50a7f8f2,0x4081e89d,0x10a510eb}, + [16]uint32{0x3f800000,0x3fa8127c,0x3fa00174,0x3f881308,0x3f800100,0x3fa8137c,0x3fa00074,0x3f881208,0x3f804080,0x3fa852fc,0x3fa041f4,0x3f885388,0x3f804180,0x3fa853fc,0x3fa040f4,0x3f885288}, + uint32(0xfff80000), + [21]string{"0xf7","0xea","0x73","0x84","0x56","0x0b","0xb3","0x0b","0x8a","0x6d","0x5f","0xd0","0xca","0xd9","0x28","0x47","0x7c","0x3a","0x53","0xfa","0x00"} }, + { + /* No.124 delta:667 weight:1687 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xbed9237e,0xe52a7947,0x5bf35a39,0x730007cd,0xcdd924b3,0x962a7e8a,0x28f35df4,0x0000f310,0xbed9d06e,0xe52a8a57,0x5bf3a929,0x7300f4dd,0xcdd9d7a3,0x962a8d9a,0x28f3aee4}, + [16]uint32{0x00000000,0x00020dde,0x2000c18a,0x2002cc54,0x5040601b,0x50426dc5,0x7040a191,0x7042ac4f,0x600c200d,0x600e2dd3,0x400ce187,0x400eec59,0x304c4016,0x304e4dc8,0x104c819c,0x104e8c42}, + [16]uint32{0x3f800000,0x3f800106,0x3f900060,0x3f900166,0x3fa82030,0x3fa82136,0x3fb82050,0x3fb82156,0x3fb00610,0x3fb00716,0x3fa00670,0x3fa00776,0x3f982620,0x3f982726,0x3f882640,0x3f882746}, + uint32(0xfff80000), + [21]string{"0x03","0x26","0x66","0x84","0x6a","0xdf","0x3c","0x27","0x3e","0xa5","0x4e","0x5a","0x89","0x62","0x3c","0x64","0xa4","0x63","0x62","0x6c","0x00"} }, + { + /* No.125 delta:3095 weight:631 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xaf97f659,0xe63edaa4,0x49a92cfd,0x1cd007d8,0xb347f181,0xfaeedd7c,0x55792b25,0x0000f83b,0xaf970e62,0xe63e229f,0x49a9d4c6,0x1cd0ffe3,0xb34709ba,0xfaee2547,0x5579d31e}, + [16]uint32{0x00000000,0x80348027,0x8830479e,0x0804c7b9,0xeb8801ec,0x6bbc81cb,0x63b84672,0xe38cc655,0x0fd8801a,0x8fec003d,0x87e8c784,0x07dc47a3,0xe45081f6,0x646401d1,0x6c60c668,0xec54464f}, + [16]uint32{0x3f800000,0x3fc01a40,0x3fc41823,0x3f840263,0x3ff5c400,0x3fb5de40,0x3fb1dc23,0x3ff1c663,0x3f87ec40,0x3fc7f600,0x3fc3f463,0x3f83ee23,0x3ff22840,0x3fb23200,0x3fb63063,0x3ff62a23}, + uint32(0xfff80000), + [21]string{"0xb5","0xd4","0xc7","0xbc","0x65","0xb7","0x30","0x68","0x6a","0x83","0x03","0x7c","0x40","0x97","0x66","0x5c","0x4c","0x77","0xf7","0x13","0x00"} }, + { + /* No.126 delta:1826 weight:1491 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0xbb3fabf7,0xc77376e1,0x7c4cdd16,0x220007e0,0x993fac17,0xe5737101,0x5e4cdaf6,0x0000b280,0xbb3f1977,0xc773c461,0x7c4c6f96,0x2200b560,0x993f1e97,0xe573c381,0x5e4c6876}, + [16]uint32{0x00000000,0x48e1e99a,0x046541af,0x4c84a835,0x008f02c4,0x486eeb5e,0x04ea436b,0x4c0baaf1,0x40a23019,0x0843d983,0x44c771b6,0x0c26982c,0x402d32dd,0x08ccdb47,0x44487372,0x0ca99ae8}, + [16]uint32{0x3f800000,0x3fa470f4,0x3f8232a0,0x3fa64254,0x3f804781,0x3fa43775,0x3f827521,0x3fa605d5,0x3fa05118,0x3f8421ec,0x3fa263b8,0x3f86134c,0x3fa01699,0x3f84666d,0x3fa22439,0x3f8654cd}, + uint32(0xfff80000), + [21]string{"0x84","0x07","0xf5","0x68","0xec","0x9b","0xa3","0xb0","0x2b","0x79","0x21","0x0e","0xc5","0x1e","0xa0","0xdf","0x36","0x4e","0x70","0xcf","0x00"} }, + { + /* No.127 delta:977 weight:1317 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x63f0c30e,0x083a1093,0x6bcad39d,0x104007f8,0x73b0c4f6,0x187a176b,0x7b8ad465,0x0000dfbf,0x63f01cb1,0x083acf2c,0x6bca0c22,0x1040d847,0x73b01b49,0x187ac8d4,0x7b8a0bda}, + [16]uint32{0x00000000,0x00463d7e,0x4001620d,0x40475f73,0x34006019,0x34465d67,0x74010214,0x74473f6a,0x61002826,0x61461558,0x21014a2b,0x21477755,0x5500483f,0x55467541,0x15012a32,0x1547174c}, + [16]uint32{0x3f800000,0x3f80231e,0x3fa000b1,0x3fa023af,0x3f9a0030,0x3f9a232e,0x3fba0081,0x3fba239f,0x3fb08014,0x3fb0a30a,0x3f9080a5,0x3f90a3bb,0x3faa8024,0x3faaa33a,0x3f8a8095,0x3f8aa38b}, + uint32(0xfff80000), + [21]string{"0x7b","0x49","0x48","0xac","0x0e","0x29","0x12","0xd6","0xb9","0x98","0xe4","0x38","0x8b","0x47","0x4f","0x4b","0x6d","0xa3","0x6b","0x2d","0x00"} }, + { + /* No.128 delta:691 weight:1641 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x5473c0b0,0x0f5cfd3e,0x5b2f3d8e,0x2c20080c,0x7853c8bc,0x237cf532,0x770f3582,0x0000cc52,0x54730ce2,0x0f5c316c,0x5b2ff1dc,0x2c20c45e,0x785304ee,0x237c3960,0x770ff9d0}, + [16]uint32{0x00000000,0x404c8097,0x00037003,0x404ff094,0x100805ca,0x5044855d,0x100b75c9,0x5047f55e,0x4000113c,0x004c91ab,0x4003613f,0x004fe1a8,0x500814f6,0x10449461,0x500b64f5,0x1047e462}, + [16]uint32{0x3f800000,0x3fa02640,0x3f8001b8,0x3fa027f8,0x3f880402,0x3fa82242,0x3f8805ba,0x3fa823fa,0x3fa00008,0x3f802648,0x3fa001b0,0x3f8027f0,0x3fa8040a,0x3f88224a,0x3fa805b2,0x3f8823f2}, + uint32(0xfff80000), + [21]string{"0x0c","0x35","0x0e","0x67","0x61","0x0d","0xf3","0xdc","0xd8","0x29","0x50","0xe8","0xaf","0xff","0x6f","0x88","0xcf","0xa3","0x3e","0xfa","0x00"} }, + { + /* No.129 delta:1085 weight:1313 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0xda085890,0x01457dcf,0xdb4d255f,0x46f0081a,0x9cf8508a,0x47b575d5,0x9dbd2d45,0x00000630,0xda085ea0,0x01457bff,0xdb4d236f,0x46f00e2a,0x9cf856ba,0x47b573e5,0x9dbd2b75}, + [16]uint32{0x00000000,0x102499ba,0x007c0406,0x10589dbc,0x00021107,0x102688bd,0x007e1501,0x105a8cbb,0xe08e4133,0xf0aad889,0xe0f24535,0xf0d6dc8f,0xe08c5034,0xf0a8c98e,0xe0f05432,0xf0d4cd88}, + [16]uint32{0x3f800000,0x3f88124c,0x3f803e02,0x3f882c4e,0x3f800108,0x3f881344,0x3f803f0a,0x3f882d46,0x3ff04720,0x3ff8556c,0x3ff07922,0x3ff86b6e,0x3ff04628,0x3ff85464,0x3ff0782a,0x3ff86a66}, + uint32(0xfff80000), + [21]string{"0xc2","0xbe","0xfc","0xa1","0xa9","0xa7","0xe1","0x8c","0x54","0x80","0x2f","0x61","0x16","0xca","0x97","0x26","0xb0","0x77","0xd4","0xcf","0x00"} }, + { + /* No.130 delta:1766 weight:1661 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0x7a7a5fa4,0xa616acc6,0xdc6cf362,0xff400828,0x853a578c,0x5956a4ee,0x232cfb4a,0x000071f3,0x7a7a2e57,0xa616dd35,0xdc6c8291,0xff4079db,0x853a267f,0x5956d51d,0x232c8ab9}, + [16]uint32{0x00000000,0x866528b2,0x0c7020fd,0x8a15084f,0x004361a9,0x8626491b,0x0c334154,0x8a5669e6,0x02018121,0x8464a993,0x0e71a1dc,0x8814896e,0x0242e088,0x8427c83a,0x0e32c075,0x8857e8c7}, + [16]uint32{0x3f800000,0x3fc33294,0x3f863810,0x3fc50a84,0x3f8021b0,0x3fc31324,0x3f8619a0,0x3fc52b34,0x3f8100c0,0x3fc23254,0x3f8738d0,0x3fc40a44,0x3f812170,0x3fc213e4,0x3f871960,0x3fc42bf4}, + uint32(0xfff80000), + [21]string{"0x24","0x7e","0x0d","0x64","0xeb","0x06","0x35","0x8c","0x85","0xd0","0xa6","0x24","0x9f","0xeb","0x93","0x0b","0xb5","0x7a","0x20","0xa7","0x00"} }, + { + /* No.131 delta:704 weight:1621 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0x3e922477,0x359f388b,0x0b0d1cfc,0x17a00835,0x29322c42,0x223f30be,0x1cad14c9,0x00001efd,0x3e923a8a,0x359f2676,0x0b0d0201,0x17a016c8,0x293232bf,0x223f2e43,0x1cad0a34}, + [16]uint32{0x00000000,0x4c650012,0x022da0e3,0x4e48a0f1,0x0044102f,0x4c21103d,0x0269b0cc,0x4e0cb0de,0x0020fdb5,0x4c45fda7,0x020d5d56,0x4e685d44,0x0064ed9a,0x4c01ed88,0x02494d79,0x4e2c4d6b}, + [16]uint32{0x3f800000,0x3fa63280,0x3f8116d0,0x3fa72450,0x3f802208,0x3fa61088,0x3f8134d8,0x3fa70658,0x3f80107e,0x3fa622fe,0x3f8106ae,0x3fa7342e,0x3f803276,0x3fa600f6,0x3f8124a6,0x3fa71626}, + uint32(0xfff80000), + [21]string{"0xc3","0x01","0xf9","0xeb","0xa0","0x0a","0xd9","0x04","0x35","0x26","0x4e","0xeb","0xe1","0xa6","0xf4","0x6b","0x3e","0xe2","0x63","0x5c","0x00"} }, + { + /* No.132 delta:945 weight:1681 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0x1b464ade,0x87a5d98b,0x9ce39355,0xda700843,0xc136429d,0x5dd5d1c8,0x46939b16,0x00004dfa,0x1b460724,0x87a59471,0x9ce3deaf,0xda7045b9,0xc1360f67,0x5dd59c32,0x4693d6ec}, + [16]uint32{0x00000000,0x204d093a,0x50022059,0x704f2963,0x303049ad,0x107d4097,0x603269f4,0x407f60ce,0x5001088b,0x704c01b1,0x000328d2,0x204e21e8,0x60314126,0x407c481c,0x3033617f,0x107e6845}, + [16]uint32{0x3f800000,0x3f902684,0x3fa80110,0x3fb82794,0x3f981824,0x3f883ea0,0x3fb01934,0x3fa03fb0,0x3fa80084,0x3fb82600,0x3f800194,0x3f902710,0x3fb018a0,0x3fa03e24,0x3f9819b0,0x3f883f34}, + uint32(0xfff80000), + [21]string{"0xb4","0x6d","0xa1","0xb3","0x8f","0xe5","0x1b","0xa2","0x02","0xc6","0xab","0xb1","0x90","0x5e","0x18","0x29","0x79","0x33","0xeb","0x3b","0x00"} }, + { + /* No.133 delta:1586 weight:1619 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0xe767c596,0x5528e484,0xb24f2112,0x9a800850,0x7de7cdc6,0xcfa8ecd4,0x28cf2942,0x00007135,0xe767b4a3,0x552895b1,0xb24f5027,0x9a807965,0x7de7bcf3,0xcfa89de1,0x28cf5877}, + [16]uint32{0x00000000,0x099010de,0x2784a18b,0x2e14b155,0x140a4876,0x1d9a58a8,0x338ee9fd,0x3a1ef923,0x006a207a,0x09fa30a4,0x27ee81f1,0x2e7e912f,0x1460680c,0x1df078d2,0x33e4c987,0x3a74d959}, + [16]uint32{0x3f800000,0x3f84c808,0x3f93c250,0x3f970a58,0x3f8a0524,0x3f8ecd2c,0x3f99c774,0x3f9d0f7c,0x3f803510,0x3f84fd18,0x3f93f740,0x3f973f48,0x3f8a3034,0x3f8ef83c,0x3f99f264,0x3f9d3a6c}, + uint32(0xfff80000), + [21]string{"0x88","0x24","0x80","0xd9","0xf7","0x5d","0x33","0x6e","0x29","0x40","0x2a","0xbe","0x1c","0x91","0x53","0x7d","0xcf","0x99","0xa8","0x74","0x00"} }, + { + /* No.134 delta:607 weight:1541 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0xb1f1c8f6,0x117327cd,0xa082ef3b,0xd5c00860,0x6431c096,0xc4b32fad,0x7542e75b,0x00008802,0xb1f140f4,0x1173afcf,0xa0826739,0xd5c08062,0x64314894,0xc4b3a7af,0x75426f59}, + [16]uint32{0x00000000,0x0020701f,0x205cd976,0x207ca969,0x4000c018,0x4020b007,0x605c196e,0x607c6971,0x00401c1c,0x00606c03,0x201cc56a,0x203cb575,0x4040dc04,0x4060ac1b,0x601c0572,0x603c756d}, + [16]uint32{0x3f800000,0x3f801038,0x3f902e6c,0x3f903e54,0x3fa00060,0x3fa01058,0x3fb02e0c,0x3fb03e34,0x3f80200e,0x3f803036,0x3f900e62,0x3f901e5a,0x3fa0206e,0x3fa03056,0x3fb00e02,0x3fb01e3a}, + uint32(0xfff80000), + [21]string{"0xff","0x78","0x00","0xdd","0xe1","0xe1","0xcb","0x7d","0xfb","0x5a","0xbf","0x61","0xcc","0x53","0xae","0xf9","0xbb","0x22","0x95","0x3d","0x00"} }, + { + /* No.135 delta:1216 weight:1481 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x2efc7b65,0xd5ed2bc8,0xfb1150ad,0xff90087c,0xd16c7319,0x2a7d23b4,0x048158d1,0x000011a9,0x2efc6acc,0xd5ed3a61,0xfb114104,0xff9019d5,0xd16c62b0,0x2a7d321d,0x04814978}, + [16]uint32{0x00000000,0x30022096,0x10040ddf,0x20062d49,0x10008108,0x2002a19e,0x00048cd7,0x3006ac41,0x60184015,0x501a6083,0x701c4dca,0x401e6d5c,0x7018c11d,0x401ae18b,0x601cccc2,0x501eec54}, + [16]uint32{0x3f800000,0x3f980110,0x3f880206,0x3f900316,0x3f880040,0x3f900150,0x3f800246,0x3f980356,0x3fb00c20,0x3fa80d30,0x3fb80e26,0x3fa00f36,0x3fb80c60,0x3fa00d70,0x3fb00e66,0x3fa80f76}, + uint32(0xfff80000), + [21]string{"0x5b","0x58","0xff","0x3f","0x25","0x71","0x1b","0x41","0xf4","0xac","0xf6","0xd0","0x44","0xdd","0x3d","0x65","0xb9","0x91","0xb3","0x64","0x00"} }, + { + /* No.136 delta:915 weight:1245 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xf6ee1897,0x8bd48878,0x7d3a90ef,0x4e20088a,0xb8ce101d,0xc5f480f2,0x331a9865,0x0000ef87,0xf6eef710,0x8bd467ff,0x7d3a7f68,0x4e20e70d,0xb8ceff9a,0xc5f46f75,0x331a77e2}, + [16]uint32{0x00000000,0x00123032,0x4004005e,0x4016306c,0x10012419,0x1013142b,0x50052447,0x50171475,0x2020f01c,0x2032c02e,0x6024f042,0x6036c070,0x3021d405,0x3033e437,0x7025d45b,0x7037e469}, + [16]uint32{0x3f800000,0x3f800918,0x3fa00200,0x3fa00b18,0x3f880092,0x3f88098a,0x3fa80292,0x3fa80b8a,0x3f901078,0x3f901960,0x3fb01278,0x3fb01b60,0x3f9810ea,0x3f9819f2,0x3fb812ea,0x3fb81bf2}, + uint32(0xfff80000), + [21]string{"0xd0","0x2f","0xaa","0xb2","0x0e","0xf8","0x08","0x6a","0x9a","0xa7","0xc7","0xdb","0xc7","0x2a","0x01","0x6d","0xba","0x24","0x6f","0xc6","0x00"} }, + { + /* No.137 delta:1408 weight:1561 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0x58bdda30,0x08dab14b,0x50676b7b,0xff20089e,0xa79dd2ae,0xf7fab9d5,0xaf4763e5,0x0000596d,0x58bd835d,0x08dae826,0x50673216,0xff2051f3,0xa79d8bc3,0xf7fae0b8,0xaf473a88}, + [16]uint32{0x00000000,0x0054247e,0x10139d12,0x1047b96c,0x60482015,0x601c046b,0x705bbd07,0x700f9979,0x201f890a,0x204bad74,0x300c1418,0x30583066,0x4057a91f,0x40038d61,0x5044340d,0x50101073}, + [16]uint32{0x3f800000,0x3f802a12,0x3f8809ce,0x3f8823dc,0x3fb02410,0x3fb00e02,0x3fb82dde,0x3fb807cc,0x3f900fc4,0x3f9025d6,0x3f98060a,0x3f982c18,0x3fa02bd4,0x3fa001c6,0x3fa8221a,0x3fa80808}, + uint32(0xfff80000), + [21]string{"0xc2","0x03","0x9f","0xf3","0xff","0x15","0xdc","0x23","0x3b","0x01","0xbe","0x8f","0x1d","0x7a","0x00","0xfd","0xcd","0x06","0xea","0xd1","0x00"} }, + { + /* No.138 delta:1148 weight:1595 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0xd2c7bfa4,0xbdd43421,0x6f138b85,0x169008a8,0xc457b70c,0xab443c89,0x7983832d,0x0000d08f,0xd2c76f2b,0xbdd4e4ae,0x6f135b0a,0x1690d827,0xc4576783,0xab44ec06,0x798353a2}, + [16]uint32{0x00000000,0x101f7156,0x00274394,0x103832c2,0x004ec0fc,0x1051b1aa,0x00698368,0x1076f23e,0x600c823d,0x7013f36b,0x602bc1a9,0x7034b0ff,0x604242c1,0x705d3397,0x60650155,0x707a7003}, + [16]uint32{0x3f800000,0x3f880fb8,0x3f8013a1,0x3f881c19,0x3f802760,0x3f8828d8,0x3f8034c1,0x3f883b79,0x3fb00641,0x3fb809f9,0x3fb015e0,0x3fb81a58,0x3fb02121,0x3fb82e99,0x3fb03280,0x3fb83d38}, + uint32(0xfff80000), + [21]string{"0x82","0xce","0x83","0x96","0x5a","0xc8","0xee","0x6a","0xea","0x48","0xc3","0x82","0x83","0xbb","0xa6","0x50","0x47","0x9a","0xb8","0x57","0x00"} }, + { + /* No.139 delta:806 weight:1289 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x167bdfc7,0xd623904f,0xc0584f88,0xb8f008be,0xae8bd779,0x6ed398f1,0x78a84736,0x000012ed,0x167bcd2a,0xd62382a2,0xc0585d65,0xb8f01a53,0xae8bc594,0x6ed38a1c,0x78a855db}, + [16]uint32{0x00000000,0x1070993d,0x0002147e,0x10728d43,0x404085b8,0x50301c85,0x404291c6,0x503208fb,0x00010807,0x1071913a,0x00031c79,0x10738544,0x40418dbf,0x50311482,0x404399c1,0x503300fc}, + [16]uint32{0x3f800000,0x3f88384c,0x3f80010a,0x3f883946,0x3fa02042,0x3fa8180e,0x3fa02148,0x3fa81904,0x3f800084,0x3f8838c8,0x3f80018e,0x3f8839c2,0x3fa020c6,0x3fa8188a,0x3fa021cc,0x3fa81980}, + uint32(0xfff80000), + [21]string{"0x0b","0x53","0x7d","0x77","0x88","0xbe","0xf7","0xe0","0xab","0x5e","0x31","0x24","0xee","0x24","0xd6","0x65","0x85","0x33","0xf4","0xc6","0x00"} }, + { + /* No.140 delta:708 weight:1653 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0xa843165f,0xfd791587,0x553a03d8,0xb6d008c3,0x1e931e9c,0x4ba91d44,0xe3ea0b1b,0x00007382,0xa84365dd,0xfd796605,0x553a705a,0xb6d07b41,0x1e936d1e,0x4ba96ec6,0xe3ea7899}, + [16]uint32{0x00000000,0x00032c13,0x4000a36f,0x40038f7c,0xf00000f7,0xf0032ce4,0xb000a398,0xb0038f8b,0x10006816,0x10034405,0x5000cb79,0x5003e76a,0xe00068e1,0xe00344f2,0xa000cb8e,0xa003e79d}, + [16]uint32{0x3f800000,0x3f800196,0x3fa00051,0x3fa001c7,0x3ff80000,0x3ff80196,0x3fd80051,0x3fd801c7,0x3f880034,0x3f8801a2,0x3fa80065,0x3fa801f3,0x3ff00034,0x3ff001a2,0x3fd00065,0x3fd001f3}, + uint32(0xfff80000), + [21]string{"0x8a","0x61","0xc1","0x12","0xfb","0x34","0x22","0xe4","0xea","0xfd","0x6a","0x85","0x6e","0x31","0x31","0xe0","0x83","0x16","0x29","0x46","0x00"} }, + { + /* No.141 delta:999 weight:979 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0x704436df,0x3cf475e1,0x4cb0433e,0x82c008dc,0xf2843e03,0xbe347d3d,0xce704be2,0x0000a242,0x7044949d,0x3cf4d7a3,0x4cb0e17c,0x82c0aa9e,0xf2849c41,0xbe34df7f,0xce70e9a0}, + [16]uint32{0x00000000,0x0023d9b6,0x0054015b,0x0077d8ed,0x27d021f1,0x27f3f847,0x278420aa,0x27a7f91c,0x0a0a2118,0x0a29f8ae,0x0a5e2043,0x0a7df9f5,0x2dda00e9,0x2df9d95f,0x2d8e01b2,0x2dadd804}, + [16]uint32{0x3f800000,0x3f8011ec,0x3f802a00,0x3f803bec,0x3f93e810,0x3f93f9fc,0x3f93c210,0x3f93d3fc,0x3f850510,0x3f8514fc,0x3f852f10,0x3f853efc,0x3f96ed00,0x3f96fcec,0x3f96c700,0x3f96d6ec}, + uint32(0xfff80000), + [21]string{"0x15","0x85","0xd9","0x08","0x97","0x45","0xfd","0x4a","0x34","0x36","0x05","0xdf","0xdc","0xe2","0x28","0x04","0x9b","0x16","0xc3","0x00","0x00"} }, + { + /* No.142 delta:602 weight:1747 */ + 11213, + 75, + 13, + 4, + [16]uint32{0x00000000,0xb6dda24b,0x671fd84c,0xd1c27a07,0x66a008e9,0xd07daaa2,0x01bfd0a5,0xb76272ee,0x00006563,0xb6ddc728,0x671fbd2f,0xd1c21f64,0x66a06d8a,0xd07dcfc1,0x01bfb5c6,0xb762178d}, + [16]uint32{0x00000000,0x0801011f,0x40040106,0x48050019,0x0020cfdd,0x0821cec2,0x4024cedb,0x4825cfc4,0x10001c18,0x18011d07,0x50041d1e,0x58051c01,0x1020d3c5,0x1821d2da,0x5024d2c3,0x5825d3dc}, + [16]uint32{0x3f800000,0x3f840080,0x3fa00200,0x3fa40280,0x3f801067,0x3f8410e7,0x3fa01267,0x3fa412e7,0x3f88000e,0x3f8c008e,0x3fa8020e,0x3fac028e,0x3f881069,0x3f8c10e9,0x3fa81269,0x3fac12e9}, + uint32(0xfff80000), + [21]string{"0xd2","0xa3","0xa9","0x60","0x33","0x46","0x34","0x7a","0xa5","0x3c","0x04","0x27","0x4d","0x40","0xa4","0xb7","0xc0","0x45","0xc2","0xf2","0x00"} }, + { + /* No.143 delta:1765 weight:1617 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0x989cafc6,0x80343f5b,0x18a8909d,0x3d4008f0,0xa5dca736,0xbd7437ab,0x25e8986d,0x0000873e,0x989c28f8,0x8034b865,0x18a817a3,0x3d408fce,0xa5dc2008,0xbd74b095,0x25e81f53}, + [16]uint32{0x00000000,0x6b6020fa,0x2218c043,0x4978e0b9,0x6003218c,0x0b630176,0x421be1cf,0x297bc135,0x4088a010,0x2be880ea,0x62906053,0x09f040a9,0x208b819c,0x4beba166,0x029341df,0x69f36125}, + [16]uint32{0x3f800000,0x3fb5b010,0x3f910c60,0x3fa4bc70,0x3fb00190,0x3f85b180,0x3fa10df0,0x3f94bde0,0x3fa04450,0x3f95f440,0x3fb14830,0x3f84f820,0x3f9045c0,0x3fa5f5d0,0x3f8149a0,0x3fb4f9b0}, + uint32(0xfff80000), + [21]string{"0x5d","0x7b","0x8e","0x78","0xae","0x8f","0x26","0xae","0x7a","0xb2","0x3d","0x45","0x25","0xfa","0x23","0x36","0x5c","0xd4","0x99","0x12","0x00"} }, + { + /* No.144 delta:884 weight:1707 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0xd9cdefd4,0xf3e209ac,0x2a2fe678,0xa8900905,0x715de6d1,0x5b7200a9,0x82bfef7d,0x00004eeb,0xd9cda13f,0xf3e24747,0x2a2fa893,0xa89047ee,0x715da83a,0x5b724e42,0x82bfa196}, + [16]uint32{0x00000000,0x200fa85a,0x0074809f,0x207b28c5,0x4043441c,0x604cec46,0x4037c483,0x60386cd9,0x00024017,0x200de84d,0x0076c088,0x207968d2,0x4041040b,0x604eac51,0x40358494,0x603a2cce}, + [16]uint32{0x3f800000,0x3f9007d4,0x3f803a40,0x3f903d94,0x3fa021a2,0x3fb02676,0x3fa01be2,0x3fb01c36,0x3f800120,0x3f9006f4,0x3f803b60,0x3f903cb4,0x3fa02082,0x3fb02756,0x3fa01ac2,0x3fb01d16}, + uint32(0xfff80000), + [21]string{"0x09","0xbe","0x73","0x0d","0x54","0x0c","0xac","0xda","0x00","0x3d","0xa5","0xe1","0x05","0xcd","0xd4","0x30","0xec","0x1e","0x1c","0x13","0x00"} }, + { + /* No.145 delta:894 weight:1007 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0x4a30df1a,0x68613901,0x2251e61b,0x4f200919,0x0510d603,0x27413018,0x6d71ef02,0x0000747c,0x4a30ab66,0x68614d7d,0x22519267,0x4f207d65,0x0510a27f,0x27414464,0x6d719b7e}, + [16]uint32{0x00000000,0x006c19f2,0x0e40882b,0x0e2c91d9,0x04c0040e,0x04ac1dfc,0x0a808c25,0x0aec95d7,0x0bc0405f,0x0bac59ad,0x0580c874,0x05ecd186,0x0f004451,0x0f6c5da3,0x0140cc7a,0x012cd588}, + [16]uint32{0x3f800000,0x3f80360c,0x3f872044,0x3f871648,0x3f826002,0x3f82560e,0x3f854046,0x3f85764a,0x3f85e020,0x3f85d62c,0x3f82c064,0x3f82f668,0x3f878022,0x3f87b62e,0x3f80a066,0x3f80966a}, + uint32(0xfff80000), + [21]string{"0xb4","0x19","0x71","0x8c","0x48","0x30","0x79","0xde","0x01","0x63","0xe1","0x7e","0x4c","0xce","0x2f","0x84","0xe5","0x58","0x95","0xd4","0x00"} }, + { + /* No.146 delta:604 weight:1733 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x0039c62e,0xcd8ee945,0xcdb72f6b,0xba000927,0xba39cf09,0x778ee062,0x77b7264c,0x0000b53e,0x00397310,0xcd8e5c7b,0xcdb79a55,0xba00bc19,0xba397a37,0x778e555c,0x77b79372}, + [16]uint32{0x00000000,0x11048bfa,0x3013f01d,0x21177be7,0x50006411,0x4104efeb,0x6013940c,0x71171ff6,0x6001209f,0x7105ab65,0x5012d082,0x41165b78,0x3001448e,0x2105cf74,0x0012b493,0x11163f69}, + [16]uint32{0x3f800000,0x3f888245,0x3f9809f8,0x3f908bbd,0x3fa80032,0x3fa08277,0x3fb009ca,0x3fb88b8f,0x3fb00090,0x3fb882d5,0x3fa80968,0x3fa08b2d,0x3f9800a2,0x3f9082e7,0x3f80095a,0x3f888b1f}, + uint32(0xfff80000), + [21]string{"0x6c","0x4c","0x5a","0xeb","0x13","0x2e","0xdb","0xc6","0x8d","0x7c","0x6b","0xa3","0x75","0x22","0xa4","0x2d","0x14","0xbc","0xde","0x56","0x00"} }, + { + /* No.147 delta:960 weight:1163 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0x43b4ae5b,0x76e80719,0x355ca942,0xdf100930,0x9ca4a76b,0xa9f80e29,0xea4ca072,0x0000673e,0x43b4c965,0x76e86027,0x355cce7c,0xdf106e0e,0x9ca4c055,0xa9f86917,0xea4cc74c}, + [16]uint32{0x00000000,0x0005f1de,0x00021107,0x0007e0d9,0x547e5191,0x547ba04f,0x547c4096,0x5479b148,0x8022012c,0x8027f0f2,0x8020102b,0x8025e1f5,0xd45c50bd,0xd459a163,0xd45e41ba,0xd45bb064}, + [16]uint32{0x3f800000,0x3f8002f8,0x3f800108,0x3f8003f0,0x3faa3f28,0x3faa3dd0,0x3faa3e20,0x3faa3cd8,0x3fc01100,0x3fc013f8,0x3fc01008,0x3fc012f0,0x3fea2e28,0x3fea2cd0,0x3fea2f20,0x3fea2dd8}, + uint32(0xfff80000), + [21]string{"0x8a","0x3e","0x0b","0xb1","0x58","0x61","0xa0","0x53","0xdf","0xf6","0x62","0x32","0xbe","0x8c","0x82","0x52","0x0d","0x83","0x86","0x83","0x00"} }, + { + /* No.148 delta:901 weight:1609 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0xfb134e5d,0x92dacb87,0x69c985da,0x1a50094b,0xe1434716,0x888ac2cc,0x73998c91,0x00000bda,0xfb134587,0x92dac05d,0x69c98e00,0x1a500291,0xe1434ccc,0x888ac916,0x7399874b}, + [16]uint32{0x00000000,0x4003bff3,0x500059bf,0x1003e64c,0x30020205,0x7001bdf6,0x60025bba,0x2001e449,0x00026032,0x4001dfc1,0x5002398d,0x1001867e,0x30006237,0x7003ddc4,0x60003b88,0x2003847b}, + [16]uint32{0x3f800000,0x3fa001df,0x3fa8002c,0x3f8801f3,0x3f980101,0x3fb800de,0x3fb0012d,0x3f9000f2,0x3f800130,0x3fa000ef,0x3fa8011c,0x3f8800c3,0x3f980031,0x3fb801ee,0x3fb0001d,0x3f9001c2}, + uint32(0xfff80000), + [21]string{"0xed","0x19","0x5c","0x48","0x36","0x04","0xa5","0x0d","0x32","0x2c","0x92","0xd7","0xf6","0x35","0x06","0x7d","0xb8","0x72","0x6a","0x9e","0x00"} }, + { + /* No.149 delta:1073 weight:1557 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0xdd6ff907,0x1b8687a5,0xc6e97ea2,0xa6200958,0x7b4ff05f,0xbda68efd,0x60c977fa,0x000050b0,0xdd6fa9b7,0x1b86d715,0xc6e92e12,0xa62059e8,0x7b4fa0ef,0xbda6de4d,0x60c9274a}, + [16]uint32{0x00000000,0x4014141a,0x107ca00b,0x5068b411,0x00028813,0x40169c09,0x107e2818,0x506a3c02,0x1000116d,0x50140577,0x007cb166,0x4068a57c,0x1002997e,0x50168d64,0x007e3975,0x406a2d6f}, + [16]uint32{0x3f800000,0x3fa00a0a,0x3f883e50,0x3fa8345a,0x3f800144,0x3fa00b4e,0x3f883f14,0x3fa8351e,0x3f880008,0x3fa80a02,0x3f803e58,0x3fa03452,0x3f88014c,0x3fa80b46,0x3f803f1c,0x3fa03516}, + uint32(0xfff80000), + [21]string{"0xb2","0xbf","0x1a","0x47","0x01","0x3a","0x6d","0xd8","0xca","0x8c","0x43","0x5e","0x9e","0x18","0x90","0xa5","0x15","0x8d","0x50","0x00","0x00"} }, + { + /* No.150 delta:626 weight:1459 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xd8f56f8e,0xa51a2f65,0x7def40eb,0x0e800961,0xd67566ef,0xab9a2604,0x736f498a,0x00005f13,0xd8f5309d,0xa51a7076,0x7def1ff8,0x0e805672,0xd67539fc,0xab9a7917,0x736f1699}, + [16]uint32{0x00000000,0x406dc45a,0x5011893c,0x107c4d66,0x004384ad,0x402e40f7,0x50520d91,0x103fc9cb,0x006340c9,0x400e8493,0x5072c9f5,0x101f0daf,0x0020c464,0x404d003e,0x50314d58,0x105c8902}, + [16]uint32{0x3f800000,0x3fa036e2,0x3fa808c4,0x3f883e26,0x3f8021c2,0x3fa01720,0x3fa82906,0x3f881fe4,0x3f8031a0,0x3fa00742,0x3fa83964,0x3f880f86,0x3f801062,0x3fa02680,0x3fa818a6,0x3f882e44}, + uint32(0xfff80000), + [21]string{"0x81","0x66","0xc0","0x11","0xf2","0x1e","0x67","0x18","0x8d","0x9f","0x75","0x54","0x6b","0x1a","0x5f","0x67","0xf0","0xe9","0x1a","0xdc","0x00"} }, + { + /* No.151 delta:787 weight:1455 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0xc047ffe2,0xbb464990,0x7b01b672,0xb5900979,0x75d7f69b,0x0ed640e9,0xce91bf0b,0x0000a703,0xc04758e1,0xbb46ee93,0x7b011171,0xb590ae7a,0x75d75198,0x0ed6e7ea,0xce911808}, + [16]uint32{0x00000000,0x0002a1fe,0x700cbbd2,0x700e1a2c,0x40440016,0x4046a1e8,0x3048bbc4,0x304a1a3a,0x2001701b,0x2003d1e5,0x500dcbc9,0x500f6a37,0x6045700d,0x6047d1f3,0x1049cbdf,0x104b6a21}, + [16]uint32{0x3f800000,0x3f800150,0x3fb8065d,0x3fb8070d,0x3fa02200,0x3fa02350,0x3f98245d,0x3f98250d,0x3f9000b8,0x3f9001e8,0x3fa806e5,0x3fa807b5,0x3fb022b8,0x3fb023e8,0x3f8824e5,0x3f8825b5}, + uint32(0xfff80000), + [21]string{"0x02","0x9f","0x13","0x9e","0x40","0x74","0xd9","0x43","0xb3","0x32","0xf0","0x44","0x3a","0x4a","0xee","0xd4","0x2e","0x2a","0x08","0x78","0x00"} }, + { + /* No.152 delta:2273 weight:1239 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0xd3754bf9,0x602e9050,0xb35bdba9,0x78100988,0xab654271,0x183e99d8,0xcb4bd221,0x0000d221,0xd37599d8,0x602e4271,0xb35b0988,0x7810dba9,0xab659050,0x183e4bf9,0xcb4b0000}, + [16]uint32{0x00000000,0x2c855e1a,0x38182087,0x149d7e9d,0xb0000011,0x9c855e0b,0x88182096,0xa49d7e8c,0x0a898a1e,0x260cd404,0x3291aa99,0x1e14f483,0xba898a0f,0x960cd415,0x8291aa88,0xae14f492}, + [16]uint32{0x3f800000,0x3f9642af,0x3f9c0c10,0x3f8a4ebf,0x3fd80000,0x3fce42af,0x3fc40c10,0x3fd24ebf,0x3f8544c5,0x3f93066a,0x3f9948d5,0x3f8f0a7a,0x3fdd44c5,0x3fcb066a,0x3fc148d5,0x3fd70a7a}, + uint32(0xfff80000), + [21]string{"0x74","0xe0","0xac","0xfc","0x8c","0x6a","0xf9","0x80","0x8c","0x13","0xa4","0xb5","0x63","0x77","0xdc","0xb5","0x3d","0xab","0x49","0xd7","0x00"} }, + { + /* No.153 delta:871 weight:1143 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xfedc74b0,0xaee6d14b,0x503aa5fb,0xce20099e,0x30fc7d2e,0x60c6d8d5,0x9e1aac65,0x0000ae3e,0xfedcda8e,0xaee67f75,0x503a0bc5,0xce20a7a0,0x30fcd310,0x60c676eb,0x9e1a025b}, + [16]uint32{0x00000000,0x00545892,0x0002459d,0x00561d0f,0x4200321a,0x42546a88,0x42027787,0x42562f15,0xa010630e,0xa0443b9c,0xa0122693,0xa0467e01,0xe2105114,0xe2440986,0xe2121489,0xe2464c1b}, + [16]uint32{0x3f800000,0x3f802a2c,0x3f800122,0x3f802b0e,0x3fa10019,0x3fa12a35,0x3fa1013b,0x3fa12b17,0x3fd00831,0x3fd0221d,0x3fd00913,0x3fd0233f,0x3ff10828,0x3ff12204,0x3ff1090a,0x3ff12326}, + uint32(0xfff80000), + [21]string{"0x78","0xb7","0xc4","0x5a","0x2d","0x30","0xeb","0xa8","0x00","0xa7","0xd4","0x75","0x85","0x8f","0x9c","0x97","0x0c","0x23","0x95","0xb0","0x00"} }, + { + /* No.154 delta:680 weight:1645 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xf2f6c7de,0xab19ce85,0x59ef095b,0xbc3009a5,0x4ec6ce7b,0x1729c720,0xe5df00fe,0x00004ae2,0xf2f68d3c,0xab198467,0x59ef43b9,0xbc304347,0x4ec68499,0x17298dc2,0xe5df4a1c}, + [16]uint32{0x00000000,0x6074301d,0x0050108c,0x60242091,0x0024ac05,0x60509c18,0x0074bc89,0x60008c94,0x20092003,0x407d101e,0x2059308f,0x402d0092,0x202d8c06,0x4059bc1b,0x207d9c8a,0x4009ac97}, + [16]uint32{0x3f800000,0x3fb03a18,0x3f802808,0x3fb01210,0x3f801256,0x3fb0284e,0x3f803a5e,0x3fb00046,0x3f900490,0x3fa03e88,0x3f902c98,0x3fa01680,0x3f9016c6,0x3fa02cde,0x3f903ece,0x3fa004d6}, + uint32(0xfff80000), + [21]string{"0xec","0x69","0xee","0x1e","0xad","0x69","0x24","0x8c","0xc7","0x98","0x5a","0xd4","0x98","0xfd","0xb3","0xc1","0xe0","0xfa","0x9e","0xf3","0x00"} }, + { + /* No.155 delta:1483 weight:1731 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x6773f0aa,0xe4e35e87,0x8390ae2d,0xeb2009b3,0x8c53f919,0x0fc35734,0x68b0a79e,0x0000f41b,0x677304b1,0xe4e3aa9c,0x83905a36,0xeb20fda8,0x8c530d02,0x0fc3a32f,0x68b05385}, + [16]uint32{0x00000000,0x082689de,0x40412a3b,0x4867a3e5,0x003b7a17,0x081df3c9,0x407a502c,0x485cd9f2,0x4006001d,0x482089c3,0x00472a26,0x0861a3f8,0x403d7a0a,0x481bf3d4,0x007c5031,0x085ad9ef}, + [16]uint32{0x3f800000,0x3f841344,0x3fa02095,0x3fa433d1,0x3f801dbd,0x3f840ef9,0x3fa03d28,0x3fa42e6c,0x3fa00300,0x3fa41044,0x3f802395,0x3f8430d1,0x3fa01ebd,0x3fa40df9,0x3f803e28,0x3f842d6c}, + uint32(0xfff80000), + [21]string{"0x91","0x6b","0x3e","0xd5","0xba","0xef","0xf4","0xa8","0xf8","0x4f","0x70","0xfd","0x6c","0x0f","0x76","0x88","0xd4","0x1d","0xcf","0x43","0x00"} }, + { + /* No.156 delta:733 weight:1193 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0xc46496aa,0x6333d0ee,0xa7574644,0xd33009c1,0x17549f6b,0xb003d92f,0x74674f85,0x00005202,0xc464c4a8,0x633382ec,0xa7571446,0xd3305bc3,0x1754cd69,0xb0038b2d,0x74671d87}, + [16]uint32{0x00000000,0x106c1592,0xc034481b,0xd0585d89,0x1110946a,0x017c81f8,0xd124dc71,0xc148c9e3,0x2062041e,0x300e118c,0xe0564c05,0xf03a5997,0x31729074,0x211e85e6,0xf146d86f,0xe12acdfd}, + [16]uint32{0x3f800000,0x3f88360a,0x3fe01a24,0x3fe82c2e,0x3f88884a,0x3f80be40,0x3fe8926e,0x3fe0a464,0x3f903102,0x3f980708,0x3ff02b26,0x3ff81d2c,0x3f98b948,0x3f908f42,0x3ff8a36c,0x3ff09566}, + uint32(0xfff80000), + [21]string{"0xfb","0x19","0xfa","0xea","0x83","0x92","0x82","0x21","0xbb","0x01","0xbd","0xb5","0xbd","0xca","0xb0","0xf6","0x77","0x93","0x35","0xe5","0x00"} }, + { + /* No.157 delta:880 weight:975 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0xb3f72ee5,0x0d4a781f,0xbebd56fa,0x32e009d2,0x81172737,0x3faa71cd,0x8c5d5f28,0x00008f44,0xb3f7a1a1,0x0d4af75b,0xbebdd9be,0x32e08696,0x8117a873,0x3faafe89,0x8c5dd06c}, + [16]uint32{0x00000000,0x1160d07b,0x3980408e,0x28e090f5,0x0e5100d7,0x1f31d0ac,0x37d14059,0x26b19022,0x43c8e012,0x52a83069,0x7a48a09c,0x6b2870e7,0x4d99e0c5,0x5cf930be,0x7419a04b,0x65797030}, + [16]uint32{0x3f800000,0x3f88b068,0x3f9cc020,0x3f947048,0x3f872880,0x3f8f98e8,0x3f9be8a0,0x3f9358c8,0x3fa1e470,0x3fa95418,0x3fbd2450,0x3fb59438,0x3fa6ccf0,0x3fae7c98,0x3fba0cd0,0x3fb2bcb8}, + uint32(0xfff80000), + [21]string{"0xe8","0x4a","0xb3","0x87","0xe1","0x48","0xc9","0x8e","0xef","0x24","0x1e","0xda","0x9b","0x0f","0x74","0x19","0x5e","0x98","0x31","0xf0","0x00"} }, + { + /* No.158 delta:663 weight:1719 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x403d0e8e,0x336bfa3e,0x7356f4b0,0xd48009e9,0x94bd0767,0xe7ebf3d7,0xa7d6fd59,0x00000ddd,0x403d0353,0x336bf7e3,0x7356f96d,0xd4800434,0x94bd0aba,0xe7ebfe0a,0xa7d6f084}, + [16]uint32{0x00000000,0x501a59b6,0x7004582a,0x201e019c,0x000325ad,0x50197c1b,0x70077d87,0x201d2431,0x30544063,0x604e19d5,0x40501849,0x104a41ff,0x305765ce,0x604d3c78,0x40533de4,0x10496452}, + [16]uint32{0x3f800000,0x3fa80d2c,0x3fb8022c,0x3f900f00,0x3f800192,0x3fa80cbe,0x3fb803be,0x3f900e92,0x3f982a20,0x3fb0270c,0x3fa0280c,0x3f882520,0x3f982bb2,0x3fb0269e,0x3fa0299e,0x3f8824b2}, + uint32(0xfff80000), + [21]string{"0xed","0xea","0xb8","0x18","0xc8","0x76","0x78","0xc5","0x42","0x78","0x5e","0xb8","0xe7","0x06","0xb4","0xbf","0x24","0x82","0xa2","0x30","0x00"} }, + { + /* No.159 delta:1845 weight:1483 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x4d99df0f,0x05f964c0,0x4860bbcf,0xbee009fc,0xf379d6f3,0xbb196d3c,0xf680b233,0x00007b31,0x4d99a43e,0x05f91ff1,0x4860c0fe,0xbee072cd,0xf379adc2,0xbb19160d,0xf680c902}, + [16]uint32{0x00000000,0x58cc8356,0x26780415,0x7eb48743,0x4200501f,0x1accd349,0x6478540a,0x3cb4d75c,0x081541f4,0x50d9c2a2,0x2e6d45e1,0x76a1c6b7,0x4a1511eb,0x12d992bd,0x6c6d15fe,0x34a196a8}, + [16]uint32{0x3f800000,0x3fac6641,0x3f933c02,0x3fbf5a43,0x3fa10028,0x3f8d6669,0x3fb23c2a,0x3f9e5a6b,0x3f840aa0,0x3fa86ce1,0x3f9736a2,0x3fbb50e3,0x3fa50a88,0x3f896cc9,0x3fb6368a,0x3f9a50cb}, + uint32(0xfff80000), + [21]string{"0xe0","0x6e","0xee","0x13","0x9c","0xda","0xb8","0x10","0x90","0x8b","0x5f","0x38","0x70","0xda","0x77","0xae","0x88","0x80","0xfa","0x25","0x00"} }, + { + /* No.160 delta:701 weight:1237 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x533b8e4b,0x04e41c3b,0x57df9270,0x93200a0c,0xc01b8447,0x97c41637,0xc4ff987c,0x00001b54,0x533b951f,0x04e4076f,0x57df8924,0x93201158,0xc01b9f13,0x97c40d63,0xc4ff8328}, + [16]uint32{0x00000000,0x106fb1bd,0x9040018f,0x802fb032,0x5032405b,0x405df1e6,0xc07241d4,0xd01df069,0x004a780e,0x1025c9b3,0x900a7981,0x8065c83c,0x50783855,0x401789e8,0xc03839da,0xd0578867}, + [16]uint32{0x3f800000,0x3f8837d8,0x3fc82000,0x3fc017d8,0x3fa81920,0x3fa02ef8,0x3fe03920,0x3fe80ef8,0x3f80253c,0x3f8812e4,0x3fc8053c,0x3fc032e4,0x3fa83c1c,0x3fa00bc4,0x3fe01c1c,0x3fe82bc4}, + uint32(0xfff80000), + [21]string{"0x7e","0x9c","0x0e","0x2e","0x61","0x72","0xa8","0x37","0x50","0x74","0xe3","0xa9","0x39","0xd8","0x5e","0x44","0xd8","0xaa","0x0a","0x3a","0x00"} }, + { + /* No.161 delta:1210 weight:1361 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0xda18d8f3,0x864b1d8a,0x5c53c579,0x8ff00a12,0x55e8d2e1,0x09bb1798,0xd3a3cf6b,0x00000ad1,0xda18d222,0x864b175b,0x5c53cfa8,0x8ff000c3,0x55e8d830,0x09bb1d49,0xd3a3c5ba}, + [16]uint32{0x00000000,0x006d79f2,0x0052d5c7,0x003fac35,0x0009b6eb,0x0064cf19,0x005b632c,0x00361ade,0x4201ac05,0x426cd5f7,0x425379c2,0x423e0030,0x42081aee,0x4265631c,0x425acf29,0x4237b6db}, + [16]uint32{0x3f800000,0x3f8036bc,0x3f80296a,0x3f801fd6,0x3f8004db,0x3f803267,0x3f802db1,0x3f801b0d,0x3fa100d6,0x3fa1366a,0x3fa129bc,0x3fa11f00,0x3fa1040d,0x3fa132b1,0x3fa12d67,0x3fa11bdb}, + uint32(0xfff80000), + [21]string{"0xca","0x08","0xd3","0xcf","0xb4","0x8a","0x29","0x9a","0x0c","0xbf","0xff","0x3b","0x35","0x66","0x50","0x68","0xc1","0x0b","0x60","0xef","0x00"} }, + { + /* No.162 delta:795 weight:1449 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0xbcdfb5d0,0xc8fddc0c,0x742269dc,0xbca00a22,0x007fbff2,0x745dd62e,0xc88263fe,0x0000e6c3,0xbcdf5313,0xc8fd3acf,0x74228f1f,0xbca0ece1,0x007f5931,0x745d30ed,0xc882853d}, + [16]uint32{0x00000000,0x00124092,0x200000f4,0x20124066,0x1001919b,0x1013d109,0x3001916f,0x3013d1fd,0x90006878,0x901228ea,0xb000688c,0xb012281e,0x8001f9e3,0x8013b971,0xa001f917,0xa013b985}, + [16]uint32{0x3f800000,0x3f800920,0x3f900000,0x3f900920,0x3f8800c8,0x3f8809e8,0x3f9800c8,0x3f9809e8,0x3fc80034,0x3fc80914,0x3fd80034,0x3fd80914,0x3fc000fc,0x3fc009dc,0x3fd000fc,0x3fd009dc}, + uint32(0xfff80000), + [21]string{"0x72","0xc8","0xed","0xae","0x2a","0x9b","0xef","0x90","0x98","0x10","0x0e","0xa2","0x98","0x6e","0xc4","0x9f","0x4e","0x30","0x0c","0x95","0x00"} }, + { + /* No.163 delta:2431 weight:1043 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0x22ab4cf9,0x4d93d360,0x6f389f99,0xe3e00a3f,0xc14b46c6,0xae73d95f,0x8cd895a6,0x0000213d,0x22ab6dc4,0x4d93f25d,0x6f38bea4,0xe3e02b02,0xc14b67fb,0xae73f862,0x8cd8b49b}, + [16]uint32{0x00000000,0x9eb058d6,0xe1c02c0f,0x7f7074d9,0x70888d5e,0xee38d588,0x9148a151,0x0ff8f987,0x16084c1b,0x88b814cd,0xf7c86014,0x697838c2,0x6680c145,0xf8309993,0x8740ed4a,0x19f0b59c}, + [16]uint32{0x3f800000,0x3fcf582c,0x3ff0e016,0x3fbfb83a,0x3fb84446,0x3ff71c6a,0x3fc8a450,0x3f87fc7c,0x3f8b0426,0x3fc45c0a,0x3ffbe430,0x3fb4bc1c,0x3fb34060,0x3ffc184c,0x3fc3a076,0x3f8cf85a}, + uint32(0xfff80000), + [21]string{"0xd2","0x4a","0xaf","0xe3","0x55","0xc3","0xfa","0x9a","0x5e","0xb9","0xbc","0x94","0x33","0xf2","0x6c","0xa1","0xee","0xc7","0xa1","0x72","0x00"} }, + { + /* No.164 delta:2864 weight:779 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0x930e07df,0xe7b13610,0x74bf31cf,0x3b500a4f,0xa85e0d90,0xdce13c5f,0x4fef3b80,0x0000c7c0,0x930ec01f,0xe7b1f1d0,0x74bff60f,0x3b50cd8f,0xa85eca50,0xdce1fb9f,0x4feffc40}, + [16]uint32{0x00000000,0x9e6701be,0x3079c5f2,0xae1ec44c,0x1220219b,0x8c472025,0x2259e469,0xbc3ee5d7,0x08808d8e,0x96e78c30,0x38f9487c,0xa69e49c2,0x1aa0ac15,0x84c7adab,0x2ad969e7,0xb4be6859}, + [16]uint32{0x3f800000,0x3fcf3380,0x3f983ce2,0x3fd70f62,0x3f891010,0x3fc62390,0x3f912cf2,0x3fde1f72,0x3f844046,0x3fcb73c6,0x3f9c7ca4,0x3fd34f24,0x3f8d5056,0x3fc263d6,0x3f956cb4,0x3fda5f34}, + uint32(0xfff80000), + [21]string{"0x6e","0x02","0x89","0x09","0x39","0xd5","0xf9","0x3d","0x6d","0x6b","0x67","0x1e","0x31","0x28","0x71","0xbd","0x6d","0xf7","0xbd","0x39","0x00"} }, + { + /* No.165 delta:1244 weight:1685 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0x255f9767,0xd34967dc,0xf616f0bb,0x64000a53,0x415f9d34,0xb7496d8f,0x9216fae8,0x0000db64,0x255f4c03,0xd349bcb8,0xf6162bdf,0x6400d137,0x415f4650,0xb749b6eb,0x9216218c}, + [16]uint32{0x00000000,0x40245894,0xc0466d97,0x80623503,0x00450011,0x40615885,0xc0036d86,0x80273512,0x0002440b,0x40261c9f,0xc044299c,0x80607108,0x0047441a,0x40631c8e,0xc001298d,0x80257119}, + [16]uint32{0x3f800000,0x3fa0122c,0x3fe02336,0x3fc0311a,0x3f802280,0x3fa030ac,0x3fe001b6,0x3fc0139a,0x3f800122,0x3fa0130e,0x3fe02214,0x3fc03038,0x3f8023a2,0x3fa0318e,0x3fe00094,0x3fc012b8}, + uint32(0xfff80000), + [21]string{"0x24","0x46","0xd1","0x9b","0xe1","0xfc","0x9e","0xe4","0xef","0xb2","0x97","0x74","0xdc","0x89","0x9d","0x7b","0xbc","0x51","0x66","0xeb","0x00"} }, + { + /* No.166 delta:975 weight:1321 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x9eebf48a,0xc2268cb3,0x5ccd7839,0xf3d00a66,0x6d3bfeec,0x31f686d5,0xaf1d725f,0x000006fd,0x9eebf277,0xc2268a4e,0x5ccd7ec4,0xf3d00c9b,0x6d3bf811,0x31f68028,0xaf1d74a2}, + [16]uint32{0x00000000,0x6041241e,0x40030919,0x20422d07,0x203c71f4,0x407d55ea,0x603f78ed,0x007e5cf3,0x4020680b,0x20614c15,0x00236112,0x6062450c,0x601c19ff,0x005d3de1,0x201f10e6,0x405e34f8}, + [16]uint32{0x3f800000,0x3fb02092,0x3fa00184,0x3f902116,0x3f901e38,0x3fa03eaa,0x3fb01fbc,0x3f803f2e,0x3fa01034,0x3f9030a6,0x3f8011b0,0x3fb03122,0x3fb00e0c,0x3f802e9e,0x3f900f88,0x3fa02f1a}, + uint32(0xfff80000), + [21]string{"0x66","0x41","0xa4","0xda","0xc7","0xc0","0x9a","0x46","0x41","0x04","0x63","0x70","0x97","0xc0","0x79","0xcd","0xc4","0xe3","0x25","0x6c","0x00"} }, + { + /* No.167 delta:822 weight:1569 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x82155f47,0x6ecf1b68,0xecda442f,0x26b00a77,0xa4a55530,0x487f111f,0xca6a4e58,0x0000b1cf,0x8215ee88,0x6ecfaaa7,0xecdaf5e0,0x26b0bbb8,0xa4a5e4ff,0x487fa0d0,0xca6aff97}, + [16]uint32{0x00000000,0x00741c12,0x002010e6,0x00540cf4,0x10038215,0x10779e07,0x102392f3,0x10578ee1,0x2001820e,0x20759e1c,0x202192e8,0x20558efa,0x3002001b,0x30761c09,0x302210fd,0x30560cef}, + [16]uint32{0x3f800000,0x3f803a0e,0x3f801008,0x3f802a06,0x3f8801c1,0x3f883bcf,0x3f8811c9,0x3f882bc7,0x3f9000c1,0x3f903acf,0x3f9010c9,0x3f902ac7,0x3f980100,0x3f983b0e,0x3f981108,0x3f982b06}, + uint32(0xfff80000), + [21]string{"0x0b","0x4f","0x62","0x95","0x75","0x0b","0x08","0x87","0xec","0x7c","0xff","0x1c","0xaa","0xf5","0x0c","0x88","0xa4","0xcf","0x35","0x71","0x00"} }, + { + /* No.168 delta:2479 weight:1075 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0xb2b1de9a,0x3cd6fd93,0x8e672309,0x66a00a8a,0xd411d410,0x5a76f719,0xe8c72983,0x0000316f,0xb2b1eff5,0x3cd6ccfc,0x8e671266,0x66a03be5,0xd411e57f,0x5a76c676,0xe8c718ec}, + [16]uint32{0x00000000,0xf87321b4,0x0215c11e,0xfa66e0aa,0x30c06818,0xc8b349ac,0x32d5a906,0xcaa688b2,0x30b60413,0xc8c525a7,0x32a3c50d,0xcad0e4b9,0x00766c0b,0xf8054dbf,0x0263ad15,0xfa108ca1}, + [16]uint32{0x3f800000,0x3ffc3990,0x3f810ae0,0x3ffd3370,0x3f986034,0x3fe459a4,0x3f996ad4,0x3fe55344,0x3f985b02,0x3fe46292,0x3f9951e2,0x3fe56872,0x3f803b36,0x3ffc02a6,0x3f8131d6,0x3ffd0846}, + uint32(0xfff80000), + [21]string{"0xe2","0xcf","0x0e","0x1e","0xa2","0xe7","0xf0","0xe2","0x9d","0x80","0x77","0xba","0xb6","0x20","0xa9","0x8a","0x3c","0xfe","0xda","0x1d","0x00"} }, + { + /* No.169 delta:1568 weight:1675 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0xccc1bd43,0x3fe6a0cd,0xf3271d8e,0x46b00a9e,0x8a71b7dd,0x7956aa53,0xb5971710,0x00006731,0xccc1da72,0x3fe6c7fc,0xf3277abf,0x46b06daf,0x8a71d0ec,0x7956cd62,0xb5977021}, + [16]uint32{0x00000000,0x08811f14,0x011d01d1,0x099c1ec5,0x8006ce1f,0x8887d10b,0x811bcfce,0x899ad0da,0x048001fc,0x0c011ee8,0x059d002d,0x0d1c1f39,0x8486cfe3,0x8c07d0f7,0x859bce32,0x8d1ad126}, + [16]uint32{0x3f800000,0x3f84408f,0x3f808e80,0x3f84ce0f,0x3fc00367,0x3fc443e8,0x3fc08de7,0x3fc4cd68,0x3f824000,0x3f86008f,0x3f82ce80,0x3f868e0f,0x3fc24367,0x3fc603e8,0x3fc2cde7,0x3fc68d68}, + uint32(0xfff80000), + [21]string{"0x36","0x03","0x1e","0xd8","0xe1","0x52","0x01","0x67","0x0e","0x46","0xc9","0x8c","0x5b","0x72","0xf4","0x1b","0xd0","0xcc","0x90","0x66","0x00"} }, + { + /* No.170 delta:887 weight:1169 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0x204cedf9,0x665b37f8,0x4617da01,0x6cd00aa0,0x4c9ce759,0x0a8b3d58,0x2ac7d0a1,0x00003dab,0x204cd052,0x665b0a53,0x4617e7aa,0x6cd0370b,0x4c9cdaf2,0x0a8b00f3,0x2ac7ed0a}, + [16]uint32{0x00000000,0x002e2b75,0x700212a9,0x702c39dc,0x0002f80a,0x002cd37f,0x7000eaa3,0x702ec1d6,0x600c0412,0x60222f67,0x100e16bb,0x10203dce,0x600efc18,0x6020d76d,0x100ceeb1,0x1022c5c4}, + [16]uint32{0x3f800000,0x3f801715,0x3fb80109,0x3fb8161c,0x3f80017c,0x3f801669,0x3fb80075,0x3fb81760,0x3fb00602,0x3fb01117,0x3f88070b,0x3f88101e,0x3fb0077e,0x3fb0106b,0x3f880677,0x3f881162}, + uint32(0xfff80000), + [21]string{"0x09","0x30","0x36","0x45","0x63","0x72","0x06","0x8f","0x3a","0xd2","0xc5","0x1a","0x3f","0x29","0x2a","0xf1","0x62","0x72","0xb4","0x65","0x00"} }, + { + /* No.171 delta:736 weight:1515 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0x179d8c42,0xa333f12e,0xb4ae7d6c,0x9cc00abf,0x8b5d86fd,0x3ff3fb91,0x286e77d3,0x0000f0c5,0x179d7c87,0xa33301eb,0xb4ae8da9,0x9cc0fa7a,0x8b5d7638,0x3ff30b54,0x286e8716}, + [16]uint32{0x00000000,0x8002113f,0x0082696e,0x80807851,0x4000394d,0xc0022872,0x40825023,0xc080411c,0x00481046,0x804a0179,0x00ca7928,0x80c86817,0x4048290b,0xc04a3834,0x40ca4065,0xc0c8515a}, + [16]uint32{0x3f800000,0x3fc00108,0x3f804134,0x3fc0403c,0x3fa0001c,0x3fe00114,0x3fa04128,0x3fe04020,0x3f802408,0x3fc02500,0x3f80653c,0x3fc06434,0x3fa02414,0x3fe0251c,0x3fa06520,0x3fe06428}, + uint32(0xfff80000), + [21]string{"0xb1","0xdc","0x86","0xb7","0x63","0x4f","0xd7","0xb9","0xfd","0x4e","0x0f","0x84","0x3f","0x56","0xd4","0xde","0xa1","0x15","0x74","0x63","0x00"} }, + { + /* No.172 delta:864 weight:1317 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0xf8a54642,0x32b17565,0xca143327,0x31d00ac8,0xc9754c8a,0x03617fad,0xfbc439ef,0x00003df6,0xf8a57bb4,0x32b14893,0xca140ed1,0x31d0373e,0xc975717c,0x0361425b,0xfbc40419}, + [16]uint32{0x00000000,0x0802d814,0x4001806f,0x4803587b,0x1001f7b5,0x18032fa1,0x500077da,0x5802afce,0x20019189,0x2803499d,0x600011e6,0x6802c9f2,0x3000663c,0x3802be28,0x7001e653,0x78033e47}, + [16]uint32{0x3f800000,0x3f84016c,0x3fa000c0,0x3fa401ac,0x3f8800fb,0x3f8c0197,0x3fa8003b,0x3fac0157,0x3f9000c8,0x3f9401a4,0x3fb00008,0x3fb40164,0x3f980033,0x3f9c015f,0x3fb800f3,0x3fbc019f}, + uint32(0xfff80000), + [21]string{"0x4a","0x6e","0x2f","0x88","0x4c","0x33","0x7b","0xbb","0xe2","0x96","0xe6","0xf1","0xaf","0xba","0x1b","0xee","0x2a","0x1a","0xe1","0xa6","0x00"} }, + { + /* No.173 delta:722 weight:1525 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x07c60bc2,0x5e3370e7,0x59f57b25,0xa9000adb,0xaec60119,0xf7337a3c,0xf0f571fe,0x00007779,0x07c67cbb,0x5e33079e,0x59f50c5c,0xa9007da2,0xaec67660,0xf7330d45,0xf0f50687}, + [16]uint32{0x00000000,0x00641895,0x1012440a,0x10765c9f,0x0003c213,0x0067da86,0x10118619,0x10759e8c,0x50000011,0x50641884,0x4012441b,0x40765c8e,0x5003c202,0x5067da97,0x40118608,0x40759e9d}, + [16]uint32{0x3f800000,0x3f80320c,0x3f880922,0x3f883b2e,0x3f8001e1,0x3f8033ed,0x3f8808c3,0x3f883acf,0x3fa80000,0x3fa8320c,0x3fa00922,0x3fa03b2e,0x3fa801e1,0x3fa833ed,0x3fa008c3,0x3fa03acf}, + uint32(0xfff80000), + [21]string{"0x88","0x54","0x4e","0x54","0xfc","0x97","0x1d","0xee","0x8c","0x35","0x96","0x45","0x39","0x47","0x01","0x41","0x49","0xf9","0xcc","0x13","0x00"} }, + { + /* No.174 delta:2446 weight:1169 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0x7013cfde,0xefc0532c,0x9fd39cf2,0x44000aed,0x3413c533,0xabc059c1,0xdbd3961f,0x0000c8ca,0x70130714,0xefc09be6,0x9fd35438,0x4400c227,0x34130df9,0xabc0910b,0xdbd35ed5}, + [16]uint32{0x00000000,0xf209a07a,0x0ce0201c,0xfee98066,0x424e80c8,0xb04720b2,0x4eaea0d4,0xbca700ae,0x034ca48f,0xf14504f5,0x0fac8493,0xfda524e9,0x41022447,0xb30b843d,0x4de2045b,0xbfeba421}, + [16]uint32{0x3f800000,0x3ff904d0,0x3f867010,0x3fff74c0,0x3fa12740,0x3fd82390,0x3fa75750,0x3fde5380,0x3f81a652,0x3ff8a282,0x3f87d642,0x3ffed292,0x3fa08112,0x3fd985c2,0x3fa6f102,0x3fdff5d2}, + uint32(0xfff80000), + [21]string{"0x13","0x0d","0x73","0x24","0x2d","0xe1","0x34","0x35","0x61","0x80","0x9d","0x5b","0x96","0xec","0xac","0x0a","0x74","0x51","0x84","0xe0","0x00"} }, + { + /* No.175 delta:2035 weight:1341 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xf5158300,0xcf4b2e46,0x3a5ead46,0xcfe00afa,0x3af589fa,0x00ab24bc,0xf5bea7bc,0x00006481,0xf515e781,0xcf4b4ac7,0x3a5ec9c7,0xcfe06e7b,0x3af5ed7b,0x00ab403d,0xf5bec33d}, + [16]uint32{0x00000000,0x066611dd,0x4038015e,0x465e1083,0x40780137,0x461e10ea,0x00400069,0x062611b4,0x003000c5,0x06561118,0x4008019b,0x466e1046,0x404801f2,0x462e102f,0x007000ac,0x06161171}, + [16]uint32{0x3f800000,0x3f833308,0x3fa01c00,0x3fa32f08,0x3fa03c00,0x3fa30f08,0x3f802000,0x3f831308,0x3f801800,0x3f832b08,0x3fa00400,0x3fa33708,0x3fa02400,0x3fa31708,0x3f803800,0x3f830b08}, + uint32(0xfff80000), + [21]string{"0x97","0xdb","0x01","0xc1","0xf7","0x06","0x48","0x6f","0x2d","0x16","0x52","0x4d","0x8d","0x90","0xea","0xbf","0x42","0x39","0xde","0xc6","0x00"} }, + { + /* No.176 delta:677 weight:1749 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0x2c5dfd73,0x32ebbb4c,0x1eb6463f,0xaa100b0b,0x864df678,0x98fbb047,0xb4a64d34,0x0000c001,0x2c5d3d72,0x32eb7b4d,0x1eb6863e,0xaa10cb0a,0x864d3679,0x98fb7046,0xb4a68d35}, + [16]uint32{0x00000000,0x04033977,0x010221e2,0x05011895,0x20020c11,0x24013566,0x21002df3,0x25031484,0xa101801e,0xa502b969,0xa003a1fc,0xa400988b,0x81038c0f,0x8500b578,0x8001aded,0x8402949a}, + [16]uint32{0x3f800000,0x3f82019c,0x3f808110,0x3f82808c,0x3f900106,0x3f92009a,0x3f908016,0x3f92818a,0x3fd080c0,0x3fd2815c,0x3fd001d0,0x3fd2004c,0x3fc081c6,0x3fc2805a,0x3fc000d6,0x3fc2014a}, + uint32(0xfff80000), + [21]string{"0x60","0x52","0xb4","0x25","0xa0","0xd9","0xbc","0x6c","0x91","0x27","0x2f","0x09","0x47","0x69","0xd1","0x4f","0x6d","0x77","0x92","0xa4","0x00"} }, + { + /* No.177 delta:916 weight:1259 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x0edb5b50,0x2243d5fb,0x2c988eab,0xe1a00b10,0xef7b5040,0xc3e3deeb,0xcd3885bb,0x0000692e,0x0edb327e,0x2243bcd5,0x2c98e785,0xe1a0623e,0xef7b396e,0xc3e3b7c5,0xcd38ec95}, + [16]uint32{0x00000000,0x0063f81e,0x50200803,0x5043f01d,0x40000014,0x4063f80a,0x10200817,0x1043f009,0x2040021c,0x2023fa02,0x70600a1f,0x7003f201,0x60400208,0x6023fa16,0x30600a0b,0x3003f215}, + [16]uint32{0x3f800000,0x3f8031fc,0x3fa81004,0x3fa821f8,0x3fa00000,0x3fa031fc,0x3f881004,0x3f8821f8,0x3f902001,0x3f9011fd,0x3fb83005,0x3fb801f9,0x3fb02001,0x3fb011fd,0x3f983005,0x3f9801f9}, + uint32(0xfff80000), + [21]string{"0x60","0x25","0x79","0xde","0xf6","0xe8","0x56","0x6f","0xaf","0xf7","0xdc","0x78","0x78","0xa5","0x6d","0xed","0x68","0x2f","0x7b","0x92","0x00"} }, + { + /* No.178 delta:650 weight:1481 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0xbb2934b3,0x5d9e85db,0xe6b7b168,0x43600b20,0xf8493f93,0x1efe8efb,0xa5d7ba48,0x0000631f,0xbb2957ac,0x5d9ee6c4,0xe6b7d277,0x4360683f,0xf8495c8c,0x1efeede4,0xa5d7d957}, + [16]uint32{0x00000000,0x00531dbe,0x401011fc,0x40430c42,0x00508097,0x00039d29,0x4040916b,0x40138cd5,0x201c69ad,0x204f7413,0x600c7851,0x605f65ef,0x204ce93a,0x201ff484,0x605cf8c6,0x600fe578}, + [16]uint32{0x3f800000,0x3f80298e,0x3fa00808,0x3fa02186,0x3f802840,0x3f8001ce,0x3fa02048,0x3fa009c6,0x3f900e34,0x3f9027ba,0x3fb0063c,0x3fb02fb2,0x3f902674,0x3f900ffa,0x3fb02e7c,0x3fb007f2}, + uint32(0xfff80000), + [21]string{"0xc1","0x4b","0x2e","0x05","0xf5","0x1d","0x5c","0x01","0xb2","0xb4","0xf8","0xe8","0xe0","0xdc","0x65","0xee","0x85","0x3a","0x54","0x2a","0x00"} }, + { + /* No.179 delta:1090 weight:1633 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x3208ef45,0x55becd4e,0x67b6220b,0x01b00b3e,0x33b8e47b,0x540ec670,0x66062935,0x0000dec1,0x32083184,0x55be138f,0x67b6fcca,0x01b0d5ff,0x33b83aba,0x540e18b1,0x6606f7f4}, + [16]uint32{0x00000000,0x161c41de,0x001700a3,0x160b417d,0x000011af,0x161c5071,0x0017110c,0x160b50d2,0x004881fa,0x1654c024,0x005f8159,0x1643c087,0x00489055,0x1654d18b,0x005f90f6,0x1643d128}, + [16]uint32{0x3f800000,0x3f8b0e20,0x3f800b80,0x3f8b05a0,0x3f800008,0x3f8b0e28,0x3f800b88,0x3f8b05a8,0x3f802440,0x3f8b2a60,0x3f802fc0,0x3f8b21e0,0x3f802448,0x3f8b2a68,0x3f802fc8,0x3f8b21e8}, + uint32(0xfff80000), + [21]string{"0x74","0xa1","0xe2","0x05","0xf7","0x40","0x90","0xcb","0x54","0x07","0x93","0x7a","0xc0","0xc1","0x78","0x0e","0x6d","0x04","0xcc","0x35","0x00"} }, + { + /* No.180 delta:1121 weight:1579 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x505c5b53,0xcdee4615,0x9db21d46,0xa8400b4c,0xf81c501f,0x65ae4d59,0x35f2160a,0x00007394,0x505c28c7,0xcdee3581,0x9db26ed2,0xa84078d8,0xf81c238b,0x65ae3ecd,0x35f2659e}, + [16]uint32{0x00000000,0x007e01b6,0x0003c171,0x007dc0c7,0x2011c062,0x206fc1d4,0x20120113,0x206c00a5,0x00003018,0x007e31ae,0x0003f169,0x007df0df,0x2011f07a,0x206ff1cc,0x2012310b,0x206c30bd}, + [16]uint32{0x3f800000,0x3f803f00,0x3f8001e0,0x3f803ee0,0x3f9008e0,0x3f9037e0,0x3f900900,0x3f903600,0x3f800018,0x3f803f18,0x3f8001f8,0x3f803ef8,0x3f9008f8,0x3f9037f8,0x3f900918,0x3f903618}, + uint32(0xfff80000), + [21]string{"0x20","0x14","0xed","0x53","0xf0","0xa3","0x58","0x5e","0x39","0x5c","0x10","0x47","0x72","0x36","0x5d","0x27","0xd4","0x0a","0x93","0x09","0x00"} }, + { + /* No.181 delta:1270 weight:1603 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0x77d67f0d,0x76f2a9b5,0x0124d6b8,0x83500b50,0xf486745d,0xf5a2a2e5,0x8274dde8,0x00005afa,0x77d625f7,0x76f2f34f,0x01248c42,0x835051aa,0xf4862ea7,0xf5a2f81f,0x82748712}, + [16]uint32{0x00000000,0x08261d9a,0x2049a073,0x286fbde9,0x006e03e7,0x08481e7d,0x2027a394,0x2801be0e,0x3008601b,0x382e7d81,0x1041c068,0x1867ddf2,0x306663fc,0x38407e66,0x102fc38f,0x1809de15}, + [16]uint32{0x3f800000,0x3f84130e,0x3f9024d0,0x3f9437de,0x3f803701,0x3f84240f,0x3f9013d1,0x3f9400df,0x3f980430,0x3f9c173e,0x3f8820e0,0x3f8c33ee,0x3f983331,0x3f9c203f,0x3f8817e1,0x3f8c04ef}, + uint32(0xfff80000), + [21]string{"0xdc","0x4d","0x79","0x4b","0xba","0xd4","0x51","0x7b","0x82","0x70","0x29","0xec","0xaa","0x5c","0xe7","0x0b","0x6f","0xb9","0x88","0x84","0x00"} }, + { + /* No.182 delta:1434 weight:1199 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x7c783189,0xe762da2e,0x9b1aeba7,0x73c00b6d,0x0fb83ae4,0x94a2d143,0xe8dae0ca,0x0000f2df,0x7c78c356,0xe76228f1,0x9b1a1978,0x73c0f9b2,0x0fb8c83b,0x94a2239c,0xe8da1215}, + [16]uint32{0x00000000,0x20020696,0x016200f4,0x21600662,0x540020c7,0x74022651,0x55622033,0x756026a5,0x0400806b,0x240286fd,0x0562809f,0x25608609,0x5000a0ac,0x7002a63a,0x5162a058,0x7160a6ce}, + [16]uint32{0x3f800000,0x3f900103,0x3f80b100,0x3f90b003,0x3faa0010,0x3fba0113,0x3faab110,0x3fbab013,0x3f820040,0x3f920143,0x3f82b140,0x3f92b043,0x3fa80050,0x3fb80153,0x3fa8b150,0x3fb8b053}, + uint32(0xfff80000), + [21]string{"0xf6","0x60","0xc0","0x9d","0x81","0x56","0xe5","0x79","0x7c","0xcb","0xee","0x7a","0xd9","0x6a","0x60","0x34","0x7d","0x2f","0x65","0xe0","0x00"} }, + { + /* No.183 delta:1029 weight:1561 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0xfd44e4d2,0xf1f56eb4,0x0cb18a66,0x2ba00b7e,0xd6e4efac,0xda5565ca,0x27118118,0x0000dc8f,0xfd44385d,0xf1f5b23b,0x0cb156e9,0x2ba0d7f1,0xd6e43323,0xda55b945,0x27115d97}, + [16]uint32{0x00000000,0x007c21fe,0x100400cc,0x10782132,0x000310e7,0x007f3119,0x1007102b,0x107b31d5,0x0000181a,0x007c39e4,0x100418d6,0x10783928,0x000308fd,0x007f2903,0x10070831,0x107b29cf}, + [16]uint32{0x3f800000,0x3f803e10,0x3f880200,0x3f883c10,0x3f800188,0x3f803f98,0x3f880388,0x3f883d98,0x3f80000c,0x3f803e1c,0x3f88020c,0x3f883c1c,0x3f800184,0x3f803f94,0x3f880384,0x3f883d94}, + uint32(0xfff80000), + [21]string{"0xe5","0x4f","0x1f","0x15","0xf6","0x89","0xa6","0xd9","0x04","0xe3","0xd0","0x6e","0x01","0x48","0x08","0x36","0x7f","0x71","0x9a","0x8d","0x00"} }, + { + /* No.184 delta:624 weight:1571 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xcfea1ce0,0x16085e8e,0xd9e2426e,0x11500b80,0xdeba1760,0x0758550e,0xc8b249ee,0x000041d7,0xcfea5d37,0x16081f59,0xd9e203b9,0x11504a57,0xdeba56b7,0x075814d9,0xc8b20839}, + [16]uint32{0x00000000,0x1079913a,0x000328c7,0x107ab9fd,0x4062f00b,0x501b6131,0x4061d8cc,0x501849f6,0x90240809,0x805d9933,0x902720ce,0x805eb1f4,0xd046f802,0xc03f6938,0xd045d0c5,0xc03c41ff}, + [16]uint32{0x3f800000,0x3f883cc8,0x3f800194,0x3f883d5c,0x3fa03178,0x3fa80db0,0x3fa030ec,0x3fa80c24,0x3fc81204,0x3fc02ecc,0x3fc81390,0x3fc02f58,0x3fe8237c,0x3fe01fb4,0x3fe822e8,0x3fe01e20}, + uint32(0xfff80000), + [21]string{"0x51","0x66","0xe5","0x17","0xfb","0x72","0x1d","0x3c","0xa5","0xf3","0x76","0x62","0x85","0x05","0xb1","0xaa","0x24","0xe7","0x36","0xc5","0x00"} }, + { + /* No.185 delta:1091 weight:1671 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0x280b74b6,0x7d7b3c94,0x55704822,0xece00b99,0xc4eb7f2f,0x919b370d,0xb99043bb,0x0000dbc1,0x280baf77,0x7d7be755,0x557093e3,0xece0d058,0xc4eba4ee,0x919beccc,0xb990987a}, + [16]uint32{0x00000000,0x300c001a,0x0042b911,0x304eb90b,0x00418416,0x304d840c,0x00033d07,0x300f3d1d,0x6000c7a3,0x500cc7b9,0x60427eb2,0x504e7ea8,0x604143b5,0x504d43af,0x6003faa4,0x500ffabe}, + [16]uint32{0x3f800000,0x3f980600,0x3f80215c,0x3f98275c,0x3f8020c2,0x3f9826c2,0x3f80019e,0x3f98079e,0x3fb00063,0x3fa80663,0x3fb0213f,0x3fa8273f,0x3fb020a1,0x3fa826a1,0x3fb001fd,0x3fa807fd}, + uint32(0xfff80000), + [21]string{"0xf2","0xd6","0x37","0x24","0x51","0x91","0xc6","0x90","0xa9","0xbc","0x8d","0x34","0x24","0xf7","0xee","0x28","0xd5","0xf8","0xe1","0xfe","0x00"} }, + { + /* No.186 delta:1106 weight:1387 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0xd113dd47,0xed0d5ed0,0x3c1e8397,0xbd300bac,0x6c23d6eb,0x503d557c,0x812e883b,0x00000b0f,0xd113d648,0xed0d55df,0x3c1e8898,0xbd3000a3,0x6c23dde4,0x503d5e73,0x812e8334}, + [16]uint32{0x00000000,0x005ef41e,0x70252012,0x707bd40c,0x00051809,0x005bec17,0x7020381b,0x707ecc05,0x1046212d,0x1018d533,0x6063013f,0x603df521,0x10433924,0x101dcd3a,0x60661936,0x6038ed28}, + [16]uint32{0x3f800000,0x3f802f7a,0x3fb81290,0x3fb83dea,0x3f80028c,0x3f802df6,0x3fb8101c,0x3fb83f66,0x3f882310,0x3f880c6a,0x3fb03180,0x3fb01efa,0x3f88219c,0x3f880ee6,0x3fb0330c,0x3fb01c76}, + uint32(0xfff80000), + [21]string{"0x89","0xd2","0x06","0x89","0xe4","0xb6","0x3e","0xc0","0x18","0xec","0x1d","0x2c","0x18","0xf9","0xa8","0x97","0x03","0x1e","0xe8","0x52","0x00"} }, + { + /* No.187 delta:1132 weight:1531 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x8fdbb324,0x981dfafd,0x17c649d9,0x40600bb8,0xcfbbb89c,0xd87df145,0x57a64261,0x00002fea,0x8fdb9cce,0x981dd517,0x17c66633,0x40602452,0xcfbb9776,0xd87ddeaf,0x57a66d8b}, + [16]uint32{0x00000000,0x0839de56,0x107c681f,0x1845b649,0x0041500e,0x08788e58,0x103d3811,0x1804e647,0x00641053,0x085dce05,0x1018784c,0x1821a61a,0x0025405d,0x081c9e0b,0x10592842,0x1860f614}, + [16]uint32{0x3f800000,0x3f841cef,0x3f883e34,0x3f8c22db,0x3f8020a8,0x3f843c47,0x3f881e9c,0x3f8c0273,0x3f803208,0x3f842ee7,0x3f880c3c,0x3f8c10d3,0x3f8012a0,0x3f840e4f,0x3f882c94,0x3f8c307b}, + uint32(0xfff80000), + [21]string{"0x2a","0x5f","0x68","0xfa","0xbd","0xf8","0x19","0xd5","0x40","0xb1","0x39","0x22","0x43","0xa7","0xcc","0xd9","0x05","0x43","0x7c","0x15","0x00"} }, + { + /* No.188 delta:1040 weight:1601 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0xad234f29,0xa8c21258,0x05e15d71,0xe5c00bc2,0x48e344eb,0x4d02199a,0xe02156b3,0x000075a9,0xad233a80,0xa8c267f1,0x05e128d8,0xe5c07e6b,0x48e33142,0x4d026c33,0xe021231a}, + [16]uint32{0x00000000,0x003d9c1e,0x0002b01c,0x003f2c02,0x21008014,0x213d1c0a,0x21023008,0x213fac16,0x403c040f,0x40019811,0x403eb413,0x4003280d,0x613c841b,0x61011805,0x613e3407,0x6103a819}, + [16]uint32{0x3f800000,0x3f801ece,0x3f800158,0x3f801f96,0x3f908040,0x3f909e8e,0x3f908118,0x3f909fd6,0x3fa01e02,0x3fa000cc,0x3fa01f5a,0x3fa00194,0x3fb09e42,0x3fb0808c,0x3fb09f1a,0x3fb081d4}, + uint32(0xfff80000), + [21]string{"0x3e","0xa4","0x26","0xb3","0x94","0x22","0x87","0xf4","0x15","0x2e","0x07","0x74","0xc9","0xee","0xfe","0x50","0xc9","0x7a","0x8c","0x37","0x00"} }, + { + /* No.189 delta:733 weight:1605 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x11d23732,0xb9ce7b60,0xa81c4c52,0x9ed00bde,0x8f023cec,0x271e70be,0x36cc478c,0x00007cb5,0x11d24b87,0xb9ce07d5,0xa81c30e7,0x9ed0776b,0x8f024059,0x271e0c0b,0x36cc3b39}, + [16]uint32{0x00000000,0x2802001b,0x500081d1,0x780281ca,0x00023165,0x2800317e,0x5002b0b4,0x7800b0af,0x20001618,0x08021603,0x700097c9,0x580297d2,0x2002277d,0x08002766,0x7002a6ac,0x5800a6b7}, + [16]uint32{0x3f800000,0x3f940100,0x3fa80040,0x3fbc0140,0x3f800118,0x3f940018,0x3fa80158,0x3fbc0058,0x3f90000b,0x3f84010b,0x3fb8004b,0x3fac014b,0x3f900113,0x3f840013,0x3fb80153,0x3fac0053}, + uint32(0xfff80000), + [21]string{"0x99","0x50","0x99","0xc6","0x2d","0x5d","0x37","0x23","0x1e","0xc8","0x4e","0x80","0xad","0xdc","0xfc","0x85","0x61","0x88","0x59","0x55","0x00"} }, + { + /* No.190 delta:841 weight:1165 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0x7f42d515,0x73d3e490,0x0c913185,0x38e00be1,0x47a2def4,0x4b33ef71,0x34713a64,0x00001fa0,0x7f42cab5,0x73d3fb30,0x0c912e25,0x38e01441,0x47a2c154,0x4b33f0d1,0x347125c4}, + [16]uint32{0x00000000,0x382491de,0x704f89b9,0x486b1867,0x000206bf,0x38269761,0x704d8f06,0x48691ed8,0x1003c19d,0x28275043,0x604c4824,0x5868d9fa,0x1001c722,0x282556fc,0x604e4e9b,0x586adf45}, + [16]uint32{0x3f800000,0x3f9c1248,0x3fb827c4,0x3fa4358c,0x3f800103,0x3f9c134b,0x3fb826c7,0x3fa4348f,0x3f8801e0,0x3f9413a8,0x3fb02624,0x3fac346c,0x3f8800e3,0x3f9412ab,0x3fb02727,0x3fac356f}, + uint32(0xfff80000), + [21]string{"0x9c","0xba","0x5c","0x8d","0x1f","0x35","0x67","0xd1","0x3e","0xfd","0xeb","0xad","0x1a","0x7d","0xa1","0xdb","0x36","0x7a","0x53","0xdb","0x00"} }, + { + /* No.191 delta:684 weight:1773 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0x1a68bb25,0x99cfab64,0x83a71041,0xf5400bf8,0xef28b0dd,0x6c8fa09c,0x76e71bb9,0x00000bdb,0x1a68b0fe,0x99cfa0bf,0x83a71b9a,0xf5400023,0xef28bb06,0x6c8fab47,0x76e71062}, + [16]uint32{0x00000000,0x680ca41d,0x400338c9,0x280f9cd4,0x1003415e,0x780fe543,0x50007997,0x380cdd8a,0x000300b2,0x680fa4af,0x4000387b,0x280c9c66,0x100041ec,0x780ce5f1,0x50037925,0x380fdd38}, + [16]uint32{0x3f800000,0x3fb40652,0x3fa0019c,0x3f9407ce,0x3f8801a0,0x3fbc07f2,0x3fa8003c,0x3f9c066e,0x3f800180,0x3fb407d2,0x3fa0001c,0x3f94064e,0x3f880020,0x3fbc0672,0x3fa801bc,0x3f9c07ee}, + uint32(0xfff80000), + [21]string{"0x57","0xb1","0x39","0xad","0x77","0xf6","0x11","0xab","0x8e","0x87","0xbd","0x92","0xe6","0x1c","0x36","0x3f","0x11","0x36","0x4b","0x13","0x00"} }, + { + /* No.192 delta:760 weight:1213 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xa615d0a5,0x36265494,0x90338431,0x4cc00c07,0xead5dca2,0x7ae65893,0xdcf38836,0x0000b3d1,0xa6156374,0x3626e745,0x903337e0,0x4cc0bfd6,0xead56f73,0x7ae6eb42,0xdcf33be7}, + [16]uint32{0x00000000,0x103e2c7e,0x400109b1,0x503f25cf,0x00023c18,0x103c1066,0x400335a9,0x503d19d7,0x5040180c,0x407e3472,0x104111bd,0x007f3dc3,0x50422414,0x407c086a,0x10432da5,0x007d01db}, + [16]uint32{0x3f800000,0x3f881f16,0x3fa00084,0x3fa81f92,0x3f80011e,0x3f881e08,0x3fa0019a,0x3fa81e8c,0x3fa8200c,0x3fa03f1a,0x3f882088,0x3f803f9e,0x3fa82112,0x3fa03e04,0x3f882196,0x3f803e80}, + uint32(0xfff80000), + [21]string{"0xd8","0xc1","0x31","0x89","0x51","0xc4","0x64","0x36","0x0a","0x93","0x66","0x13","0xb2","0x95","0xaa","0xc1","0xc3","0xc0","0xb8","0x8b","0x00"} }, + { + /* No.193 delta:1152 weight:1405 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x2a562cc2,0x5301e69e,0x7957ca5c,0x56500c10,0x7c0620d2,0x0551ea8e,0x2f07c64c,0x00005e85,0x2a567247,0x5301b81b,0x795794d9,0x56505295,0x7c067e57,0x0551b40b,0x2f0798c9}, + [16]uint32{0x00000000,0x0074a472,0x002b317b,0x005f9509,0x000845d7,0x007ce1a5,0x002374ac,0x0057d0de,0x188c149f,0x18f8b0ed,0x18a725e4,0x18d38196,0x18845148,0x18f0f53a,0x18af6033,0x18dbc441}, + [16]uint32{0x3f800000,0x3f803a52,0x3f801598,0x3f802fca,0x3f800422,0x3f803e70,0x3f8011ba,0x3f802be8,0x3f8c460a,0x3f8c7c58,0x3f8c5392,0x3f8c69c0,0x3f8c4228,0x3f8c787a,0x3f8c57b0,0x3f8c6de2}, + uint32(0xfff80000), + [21]string{"0xd9","0x61","0xf1","0xb6","0x98","0x11","0x7c","0xe3","0x44","0x58","0xdf","0x98","0xd0","0xad","0x22","0x7d","0x82","0x7f","0x7d","0x68","0x00"} }, + { + /* No.194 delta:830 weight:741 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x8cd9e453,0xa9431e7a,0x259afa29,0xb3700c2d,0x3fa9e87e,0x1a331257,0x96eaf604,0x0000f7a7,0x8cd913f4,0xa943e9dd,0x259a0d8e,0xb370fb8a,0x3fa91fd9,0x1a33e5f0,0x96ea01a3}, + [16]uint32{0x00000000,0x90a5295b,0x204211b1,0xb0e738ea,0x40400013,0xd0e52948,0x600211a2,0xf0a738f9,0x20205854,0xb085710f,0x006249e5,0x90c760be,0x60605847,0xf0c5711c,0x402249f6,0xd08760ad}, + [16]uint32{0x3f800000,0x3fc85294,0x3f902108,0x3fd8739c,0x3fa02000,0x3fe87294,0x3fb00108,0x3ff8539c,0x3f90102c,0x3fd842b8,0x3f803124,0x3fc863b0,0x3fb0302c,0x3ff862b8,0x3fa01124,0x3fe843b0}, + uint32(0xfff80000), + [21]string{"0x48","0x4b","0x3d","0x12","0xa2","0x94","0xb1","0x8c","0xf5","0xfb","0xa5","0xaf","0x07","0xa0","0xdb","0xe9","0xfa","0x44","0xed","0xb7","0x00"} }, + { + /* No.195 delta:2879 weight:775 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0xff682600,0xf74c4baa,0x08246daa,0x24100c3b,0xdb782a3b,0xd35c4791,0x2c346191,0x0000ffe5,0xff68d9e5,0xf74cb44f,0x0824924f,0x2410f3de,0xdb78d5de,0xd35cb874,0x2c349e74}, + [16]uint32{0x00000000,0xc030959e,0x9050a099,0x50603507,0x802601ba,0x40169424,0x1076a123,0xd04634bd,0xf014ce13,0x30245b8d,0x60446e8a,0xa074fb14,0x7032cfa9,0xb0025a37,0xe0626f30,0x2052faae}, + [16]uint32{0x3f800000,0x3fe0184a,0x3fc82850,0x3fa8301a,0x3fc01300,0x3fa00b4a,0x3f883b50,0x3fe8231a,0x3ff80a67,0x3f98122d,0x3fb02237,0x3fd03a7d,0x3fb81967,0x3fd8012d,0x3ff03137,0x3f90297d}, + uint32(0xfff80000), + [21]string{"0x3d","0xf6","0x9a","0x6e","0x6b","0x65","0x93","0x08","0x5e","0x4b","0x6a","0x30","0xfd","0x5d","0x93","0x81","0x59","0xda","0xe1","0x46","0x00"} }, + { + /* No.196 delta:949 weight:1287 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x7d54e010,0x9f44b63a,0xe210562a,0xd9500c42,0xa404ec52,0x4614ba78,0x3b405a68,0x0000e124,0x7d540134,0x9f44571e,0xe210b70e,0xd950ed66,0xa4040d76,0x46145b5c,0x3b40bb4c}, + [16]uint32{0x00000000,0x207e16bb,0x1030a309,0x304eb5b2,0x0063c14f,0x201dd7f4,0x10536246,0x302d74fd,0x0002a401,0x207cb2ba,0x10320708,0x304c11b3,0x0061654e,0x201f73f5,0x1051c647,0x302fd0fc}, + [16]uint32{0x3f800000,0x3f903f0b,0x3f881851,0x3f98275a,0x3f8031e0,0x3f900eeb,0x3f8829b1,0x3f9816ba,0x3f800152,0x3f903e59,0x3f881903,0x3f982608,0x3f8030b2,0x3f900fb9,0x3f8828e3,0x3f9817e8}, + uint32(0xfff80000), + [21]string{"0xef","0x4e","0xef","0x76","0x36","0xad","0x27","0xbf","0xbe","0xf2","0xb6","0x37","0x72","0xee","0x0d","0xf6","0xc0","0x73","0x4e","0xcb","0x00"} }, + { + /* No.197 delta:1232 weight:1565 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x03ab6700,0x3a6567b0,0x39ce00b0,0x81b00c5d,0x821b6b5d,0xbbd56bed,0xb87e0ced,0x0000770e,0x03ab100e,0x3a6510be,0x39ce77be,0x81b07b53,0x821b1c53,0xbbd51ce3,0xb87e7be3}, + [16]uint32{0x00000000,0x202e803a,0x0002114e,0x202c9174,0x80382018,0xa016a022,0x803a3156,0xa014b16c,0x406830c8,0x6046b0f2,0x406a2186,0x6044a1bc,0xc05010d0,0xe07e90ea,0xc052019e,0xe07c81a4}, + [16]uint32{0x3f800000,0x3f901740,0x3f800108,0x3f901648,0x3fc01c10,0x3fd00b50,0x3fc01d18,0x3fd00a58,0x3fa03418,0x3fb02358,0x3fa03510,0x3fb02250,0x3fe02808,0x3ff03f48,0x3fe02900,0x3ff03e40}, + uint32(0xfff80000), + [21]string{"0x0f","0xde","0x34","0x7f","0xb2","0x37","0x9a","0xef","0x08","0x8e","0x0d","0x5d","0x68","0xdf","0xfd","0x51","0x8e","0xe6","0x31","0x13","0x00"} }, + { + /* No.198 delta:2483 weight:1073 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0x61924bce,0x6cc60700,0x0d544cce,0x93700c63,0xf2e247ad,0xffb60b63,0x9e2440ad,0x00001b81,0x6192504f,0x6cc61c81,0x0d54574f,0x937017e2,0xf2e25c2c,0xffb610e2,0x9e245b2c}, + [16]uint32{0x00000000,0x83d01574,0x1b0a01de,0x98da14aa,0x0e262003,0x8df63577,0x152c21dd,0x96fc34a9,0x1e181411,0x9dc80165,0x051215cf,0x86c200bb,0x103e3412,0x93ee2166,0x0b3435cc,0x88e420b8}, + [16]uint32{0x3f800000,0x3fc1e80a,0x3f8d8500,0x3fcc6d0a,0x3f871310,0x3fc6fb1a,0x3f8a9610,0x3fcb7e1a,0x3f8f0c0a,0x3fcee400,0x3f82890a,0x3fc36100,0x3f881f1a,0x3fc9f710,0x3f859a1a,0x3fc47210}, + uint32(0xfff80000), + [21]string{"0xa6","0x78","0x00","0x0c","0x62","0x97","0x94","0x6c","0xb7","0xf6","0xbc","0x41","0xb1","0x29","0xe5","0x9c","0x5f","0x37","0xaa","0x79","0x00"} }, + { + /* No.199 delta:3090 weight:657 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x4b70564e,0x58ad48a7,0x13dd1ee9,0xbaa00c75,0xf1d05a3b,0xe20d44d2,0xa97d129c,0x0000d9bf,0x4b708ff1,0x58ad9118,0x13ddc756,0xbaa0d5ca,0xf1d08384,0xe20d9d6d,0xa97dcb23}, + [16]uint32{0x00000000,0xb0f01e5e,0x08c04155,0xb8305f0b,0xc0085078,0x70f84e26,0xc8c8112d,0x78380f73,0x3618200f,0x86e83e51,0x3ed8615a,0x8e287f04,0xf6107077,0x46e06e29,0xfed03122,0x4e202f7c}, + [16]uint32{0x3f800000,0x3fd8780f,0x3f846020,0x3fdc182f,0x3fe00428,0x3fb87c27,0x3fe46408,0x3fbc1c07,0x3f9b0c10,0x3fc3741f,0x3f9f6c30,0x3fc7143f,0x3ffb0838,0x3fa37037,0x3fff6818,0x3fa71017}, + uint32(0xfff80000), + [21]string{"0x77","0x27","0xbd","0xef","0xef","0x2a","0x66","0xc1","0xb7","0x5e","0x51","0x52","0x94","0xd0","0xf8","0x35","0xfa","0x0d","0x43","0x0a","0x00"} }, + { + /* No.200 delta:740 weight:741 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x8f869099,0x3346f936,0xbcc069af,0x55700c8a,0xdaf69c13,0x6636f5bc,0xe9b06525,0x000036a5,0x8f86a63c,0x3346cf93,0xbcc05f0a,0x55703a2f,0xdaf6aab6,0x6636c319,0xe9b05380}, + [16]uint32{0x00000000,0x704c0036,0x20620511,0x502e0527,0x103101cb,0x607d01fd,0x305304da,0x401f04ec,0x6003a014,0x104fa022,0x4061a505,0x302da533,0x7032a1df,0x007ea1e9,0x5050a4ce,0x201ca4f8}, + [16]uint32{0x3f800000,0x3fb82600,0x3f903102,0x3fa81702,0x3f881880,0x3fb03e80,0x3f982982,0x3fa00f82,0x3fb001d0,0x3f8827d0,0x3fa030d2,0x3f9816d2,0x3fb81950,0x3f803f50,0x3fa82852,0x3f900e52}, + uint32(0xfff80000), + [21]string{"0xf2","0xbb","0xb7","0x23","0x62","0xc4","0x51","0x55","0x4e","0xfd","0x6a","0xa0","0x00","0x9a","0x5f","0x5c","0xc9","0x8b","0xe1","0xad","0x00"} }, + { + /* No.201 delta:1425 weight:1547 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0x135e711b,0x4f1a6841,0x5c44195a,0x29b00c9f,0x3aee7d84,0x66aa64de,0x75f415c5,0x0000262f,0x135e5734,0x4f1a4e6e,0x5c443f75,0x29b02ab0,0x3aee5bab,0x66aa42f1,0x75f433ea}, + [16]uint32{0x00000000,0x2ced025e,0x33d864e2,0x1f3566bc,0x0052e20a,0x2cbfe054,0x338a86e8,0x1f6784b6,0x004c5c0d,0x2ca15e53,0x339438ef,0x1f793ab1,0x001ebe07,0x2cf3bc59,0x33c6dae5,0x1f2bd8bb}, + [16]uint32{0x3f800000,0x3f967681,0x3f99ec32,0x3f8f9ab3,0x3f802971,0x3f965ff0,0x3f99c543,0x3f8fb3c2,0x3f80262e,0x3f9650af,0x3f99ca1c,0x3f8fbc9d,0x3f800f5f,0x3f9679de,0x3f99e36d,0x3f8f95ec}, + uint32(0xfff80000), + [21]string{"0x2e","0x3f","0x27","0x5d","0xc5","0x8f","0xb5","0x58","0xd9","0x3d","0x14","0x9e","0x59","0x07","0x1b","0x89","0xab","0xd6","0x1b","0x36","0x00"} }, + { + /* No.202 delta:1120 weight:1567 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0xac59e4f5,0x4a749b39,0xe62d7fcc,0x14200cad,0xb879e858,0x5e549794,0xf20d7361,0x000000e9,0xac59e41c,0x4a749bd0,0xe62d7f25,0x14200c44,0xb879e8b1,0x5e54977d,0xf20d7388}, + [16]uint32{0x00000000,0x007c19d6,0x000240f9,0x007e592f,0x0023e00b,0x005ff9dd,0x0021a0f2,0x005db924,0x1041101f,0x103d09c9,0x104350e6,0x103f4930,0x1062f014,0x101ee9c2,0x1060b0ed,0x101ca93b}, + [16]uint32{0x3f800000,0x3f803e0c,0x3f800120,0x3f803f2c,0x3f8011f0,0x3f802ffc,0x3f8010d0,0x3f802edc,0x3f882088,0x3f881e84,0x3f8821a8,0x3f881fa4,0x3f883178,0x3f880f74,0x3f883058,0x3f880e54}, + uint32(0xfff80000), + [21]string{"0xea","0x36","0xa9","0xe3","0x3a","0x26","0xb0","0x23","0x4f","0xf2","0x04","0xc7","0x80","0x6f","0x26","0x1b","0xc0","0xd5","0x12","0x07","0x00"} }, + { + /* No.203 delta:753 weight:719 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x1ff43116,0x3ca75344,0x23536252,0xac600cb8,0xb3943dae,0x90c75ffc,0x8f336eea,0x0000ec4c,0x1ff4dd5a,0x3ca7bf08,0x23538e1e,0xac60e0f4,0xb394d1e2,0x90c7b3b0,0x8f3382a6}, + [16]uint32{0x00000000,0x4044a13d,0x202280c3,0x606621fe,0x5013e1ba,0x10574087,0x70316179,0x3075c044,0x300809f5,0x704ca8c8,0x102a8936,0x506e280b,0x601be84f,0x205f4972,0x4039688c,0x007dc9b1}, + [16]uint32{0x3f800000,0x3fa02250,0x3f901140,0x3fb03310,0x3fa809f0,0x3f882ba0,0x3fb818b0,0x3f983ae0,0x3f980404,0x3fb82654,0x3f881544,0x3fa83714,0x3fb00df4,0x3f902fa4,0x3fa01cb4,0x3f803ee4}, + uint32(0xfff80000), + [21]string{"0x67","0xa5","0xb8","0x3b","0xd2","0xe3","0x32","0x76","0x7e","0x2c","0xc8","0x24","0x35","0x26","0x61","0x3e","0x98","0x93","0xaa","0x04","0x00"} }, + { + /* No.204 delta:2490 weight:1505 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0x5eafb656,0xb33f8c5e,0xed903a08,0x1c600ccc,0x42cfba9a,0xaf5f8092,0xf1f036c4,0x000062ca,0x5eafd49c,0xb33fee94,0xed9058c2,0x1c606e06,0x42cfd850,0xaf5fe258,0xf1f0540e}, + [16]uint32{0x00000000,0x3002c1b3,0x000251dd,0x3000906e,0x40008016,0x700241a5,0x4002d1cb,0x70001078,0x0001935a,0x300352e9,0x0003c287,0x30010334,0x4001134c,0x7003d2ff,0x40034291,0x70018322}, + [16]uint32{0x3f800000,0x3f980160,0x3f800128,0x3f980048,0x3fa00040,0x3fb80120,0x3fa00168,0x3fb80008,0x3f8000c9,0x3f9801a9,0x3f8001e1,0x3f980081,0x3fa00089,0x3fb801e9,0x3fa001a1,0x3fb800c1}, + uint32(0xfff80000), + [21]string{"0x1e","0x97","0x10","0x94","0x21","0xb5","0xf6","0x23","0xac","0xeb","0x87","0x1b","0xfe","0x7d","0x9a","0xb2","0xe0","0x55","0x2e","0x99","0x00"} }, + { + /* No.205 delta:1418 weight:1259 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0xb013d5ad,0x92b7f4e1,0x22a4214c,0xee400cdd,0x5e53d970,0x7cf7f83c,0xcce42d91,0x00002e80,0xb013fb2d,0x92b7da61,0x22a40fcc,0xee40225d,0x5e53f7f0,0x7cf7d6bc,0xcce40311}, + [16]uint32{0x00000000,0x004280f7,0x200501c2,0x20478135,0x1000018b,0x1042817c,0x30050049,0x304780be,0x100301d1,0x10418126,0x30060013,0x304480e4,0x0003005a,0x004180ad,0x20060198,0x2044816f}, + [16]uint32{0x3f800000,0x3f802140,0x3f900280,0x3f9023c0,0x3f880000,0x3f882140,0x3f980280,0x3f9823c0,0x3f880180,0x3f8820c0,0x3f980300,0x3f982240,0x3f800180,0x3f8020c0,0x3f900300,0x3f902240}, + uint32(0xfff80000), + [21]string{"0x9c","0x84","0x7d","0x4e","0xc8","0xee","0xe3","0x0a","0x73","0x0a","0x36","0x27","0x06","0xf5","0x9b","0x70","0xdb","0x20","0xd2","0x7c","0x00"} }, + { + /* No.206 delta:835 weight:1117 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0xabe51a17,0x92f9658b,0x391c7f9c,0xf5300cec,0x5ed516fb,0x67c96967,0xcc2c7370,0x0000c823,0xabe5d234,0x92f9ada8,0x391cb7bf,0xf530c4cf,0x5ed5ded8,0x67c9a144,0xcc2cbb53}, + [16]uint32{0x00000000,0xc000201f,0x00020415,0xc002240a,0x1000820c,0xd000a213,0x10028619,0xd002a606,0x60004812,0xa000680d,0x60024c07,0xa0026c18,0x7000ca1e,0xb000ea01,0x7002ce0b,0xb002ee14}, + [16]uint32{0x3f800000,0x3fe00010,0x3f800102,0x3fe00112,0x3f880041,0x3fe80051,0x3f880143,0x3fe80153,0x3fb00024,0x3fd00034,0x3fb00126,0x3fd00136,0x3fb80065,0x3fd80075,0x3fb80167,0x3fd80177}, + uint32(0xfff80000), + [21]string{"0x69","0xf5","0xd3","0xed","0xb9","0x43","0x3a","0x4a","0x87","0xe0","0xc1","0x10","0x6c","0xb0","0x55","0x6c","0xd4","0x9e","0xe5","0x90","0x00"} }, + { + /* No.207 delta:670 weight:1477 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0x00a0fbb0,0xe2484b5d,0xe2e8b0ed,0x40d00cfc,0x4070f74c,0xa29847a1,0xa238bc11,0x0000f40d,0x00a00fbd,0xe248bf50,0xe2e844e0,0x40d0f8f1,0x40700341,0xa298b3ac,0xa238481c}, + [16]uint32{0x00000000,0x000253fe,0x0048217a,0x004a7284,0x120408ad,0x12065b53,0x124c29d7,0x124e7a29,0x1040c1bc,0x10429242,0x1008e0c6,0x100ab338,0x0244c911,0x02469aef,0x020ce86b,0x020ebb95}, + [16]uint32{0x3f800000,0x3f800129,0x3f802410,0x3f802539,0x3f890204,0x3f89032d,0x3f892614,0x3f89273d,0x3f882060,0x3f882149,0x3f880470,0x3f880559,0x3f812264,0x3f81234d,0x3f810674,0x3f81075d}, + uint32(0xfff80000), + [21]string{"0x99","0x83","0x87","0x20","0xf2","0x97","0x99","0xd5","0xd2","0x77","0x6e","0xb7","0x02","0x7a","0xa4","0xd0","0xc9","0x3e","0xe7","0x8b","0x00"} }, + { + /* No.208 delta:827 weight:747 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x6ab7503d,0x78c35ee8,0x12740ed5,0x0a200d05,0x60975d38,0x72e353ed,0x185403d0,0x0000d2c7,0x6ab782fa,0x78c38c2f,0x1274dc12,0x0a20dfc2,0x60978fff,0x72e3812a,0x1854d117}, + [16]uint32{0x00000000,0x0c9e017b,0x01503585,0x0dce34fe,0x02020073,0x0e9c0108,0x035235f6,0x0fcc348d,0x0040893c,0x0cde8847,0x0110bcb9,0x0d8ebdc2,0x0242894f,0x0edc8834,0x0312bcca,0x0f8cbdb1}, + [16]uint32{0x3f800000,0x3f864f00,0x3f80a81a,0x3f86e71a,0x3f810100,0x3f874e00,0x3f81a91a,0x3f87e61a,0x3f802044,0x3f866f44,0x3f80885e,0x3f86c75e,0x3f812144,0x3f876e44,0x3f81895e,0x3f87c65e}, + uint32(0xfff80000), + [21]string{"0x8f","0x72","0x12","0x18","0x88","0x56","0x56","0x47","0xc7","0x52","0x17","0xcf","0x89","0x98","0x5f","0xc8","0x8b","0x6c","0x5f","0xe5","0x00"} }, + { + /* No.209 delta:755 weight:1449 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x71586746,0xfa76fda6,0x8b2e9ae0,0xe0d00d16,0x91886a50,0x1aa6f0b0,0x6bfe97f6,0x00000411,0x71586357,0xfa76f9b7,0x8b2e9ef1,0xe0d00907,0x91886e41,0x1aa6f4a1,0x6bfe93e7}, + [16]uint32{0x00000000,0x10834dd3,0x7001a5de,0x6082e80d,0x4021601b,0x50a22dc8,0x3020c5c5,0x20a38816,0x6001f121,0x7082bcf2,0x100054ff,0x0083192c,0x2020913a,0x30a3dce9,0x502134e4,0x40a27937}, + [16]uint32{0x3f800000,0x3f8841a6,0x3fb800d2,0x3fb04174,0x3fa010b0,0x3fa85116,0x3f981062,0x3f9051c4,0x3fb000f8,0x3fb8415e,0x3f88002a,0x3f80418c,0x3f901048,0x3f9851ee,0x3fa8109a,0x3fa0513c}, + uint32(0xfff80000), + [21]string{"0xd7","0xad","0x88","0x14","0x6e","0x50","0xe8","0xc2","0x45","0x39","0x5f","0x00","0xb8","0x4b","0xf8","0x7f","0xa4","0x5b","0xad","0xac","0x00"} }, + { + /* No.210 delta:586 weight:1381 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0xb126e2d0,0xeb81c72e,0x5aa725fe,0x05000d23,0xb426eff3,0xee81ca0d,0x5fa728dd,0x0000b8f6,0xb1265a26,0xeb817fd8,0x5aa79d08,0x0500b5d5,0xb4265705,0xee8172fb,0x5fa7902b}, + [16]uint32{0x00000000,0x21001656,0x0002b01a,0x2102a64c,0x40000143,0x61001715,0x4002b159,0x6102a70f,0x900c082e,0xb10c1e78,0x900eb834,0xb10eae62,0xd00c096d,0xf10c1f3b,0xd00eb977,0xf10eaf21}, + [16]uint32{0x3f800000,0x3f90800b,0x3f800158,0x3f908153,0x3fa00000,0x3fb0800b,0x3fa00158,0x3fb08153,0x3fc80604,0x3fd8860f,0x3fc8075c,0x3fd88757,0x3fe80604,0x3ff8860f,0x3fe8075c,0x3ff88757}, + uint32(0xfff80000), + [21]string{"0x9f","0x18","0x29","0xdb","0xe3","0xe7","0x0c","0xf9","0xe8","0x52","0x7f","0xe7","0x53","0x58","0x10","0xfa","0x39","0x2b","0x01","0x90","0x00"} }, + { + /* No.211 delta:583 weight:1397 */ + 11213, + 81, + 13, + 4, + [16]uint32{0x00000000,0x882e2760,0x600360c7,0xe82d47a7,0x87b00d33,0x0f9e2a53,0xe7b36df4,0x6f9d4a94,0x00005355,0x882e7435,0x60033392,0xe82d14f2,0x87b05e66,0x0f9e7906,0xe7b33ea1,0x6f9d19c1}, + [16]uint32{0x00000000,0x31648495,0x0001981a,0x31651c8f,0x202c0199,0x1148850c,0x202d9983,0x11491d16,0x002220a7,0x3146a432,0x0023b8bd,0x31473c28,0x200e213e,0x116aa5ab,0x200fb924,0x116b3db1}, + [16]uint32{0x3f800000,0x3f98b242,0x3f8000cc,0x3f98b28e,0x3f901600,0x3f88a442,0x3f9016cc,0x3f88a48e,0x3f801110,0x3f98a352,0x3f8011dc,0x3f98a39e,0x3f900710,0x3f88b552,0x3f9007dc,0x3f88b59e}, + uint32(0xfff80000), + [21]string{"0x6b","0x2c","0xdf","0x43","0x83","0xbf","0xec","0x70","0x70","0x52","0x2c","0x4d","0x48","0x48","0xe3","0xfa","0x5a","0x93","0x0a","0x33","0x00"} }, + { + /* No.212 delta:1186 weight:1545 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x8d36105b,0xc4199cb9,0x492f8ce2,0xd2900d49,0x5fa61d12,0x168991f0,0x9bbf81ab,0x00002cf7,0x8d363cac,0xc419b04e,0x492fa015,0xd29021be,0x5fa631e5,0x1689bd07,0x9bbfad5c}, + [16]uint32{0x00000000,0x80002a1a,0x02032619,0x82030c03,0x3002c187,0xb002eb9d,0x3201e79e,0xb201cd84,0x0003a6a5,0x80038cbf,0x020080bc,0x8200aaa6,0x30016722,0xb0014d38,0x3202413b,0xb2026b21}, + [16]uint32{0x3f800000,0x3fc00015,0x3f810193,0x3fc10186,0x3f980160,0x3fd80175,0x3f9900f3,0x3fd900e6,0x3f8001d3,0x3fc001c6,0x3f810040,0x3fc10055,0x3f9800b3,0x3fd800a6,0x3f990120,0x3fd90135}, + uint32(0xfff80000), + [21]string{"0x6d","0x67","0xa8","0xbe","0xe2","0x5e","0xa1","0x6a","0xa9","0x0e","0x34","0x31","0x87","0xf7","0xac","0x44","0xfa","0x7e","0x41","0xa2","0x00"} }, + { + /* No.213 delta:825 weight:1579 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x01838606,0x71d01ded,0x70539beb,0x96f00d57,0x97738b51,0xe72010ba,0xe6a396bc,0x0000ea71,0x01836c77,0x71d0f79c,0x7053719a,0x96f0e726,0x97736120,0xe720facb,0xe6a37ccd}, + [16]uint32{0x00000000,0x10026332,0x70001817,0x60027b25,0x100100bb,0x00036389,0x600118ac,0x70037b9e,0x40806053,0x50820361,0x30807844,0x20821b76,0x508160e8,0x408303da,0x208178ff,0x30831bcd}, + [16]uint32{0x3f800000,0x3f880131,0x3fb8000c,0x3fb0013d,0x3f880080,0x3f8001b1,0x3fb0008c,0x3fb801bd,0x3fa04030,0x3fa84101,0x3f98403c,0x3f90410d,0x3fa840b0,0x3fa04181,0x3f9040bc,0x3f98418d}, + uint32(0xfff80000), + [21]string{"0x09","0x23","0x73","0x01","0xff","0x14","0x1c","0xa3","0xf0","0x4d","0xdc","0x38","0x05","0x50","0xb2","0x09","0x8b","0xad","0xa8","0x46","0x00"} }, + { + /* No.214 delta:948 weight:969 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x0bf25cfd,0x74c8e46d,0x7f3ab890,0x1f800d6e,0x14725193,0x6b48e903,0x60bab5fe,0x0000b8f9,0x0bf2e404,0x74c85c94,0x7f3a0069,0x1f80b597,0x1472e96a,0x6b4851fa,0x60ba0d07}, + [16]uint32{0x00000000,0xa05040b6,0x0003900c,0xa053d0ba,0x20501012,0x800050a4,0x2053801e,0x8003c0a8,0x20206419,0x807024af,0x2023f415,0x8073b4a3,0x0070740b,0xa02034bd,0x0073e407,0xa023a4b1}, + [16]uint32{0x3f800000,0x3fd02820,0x3f8001c8,0x3fd029e8,0x3f902808,0x3fc00028,0x3f9029c0,0x3fc001e0,0x3f901032,0x3fc03812,0x3f9011fa,0x3fc039da,0x3f80383a,0x3fd0101a,0x3f8039f2,0x3fd011d2}, + uint32(0xfff80000), + [21]string{"0xe4","0xd6","0x8f","0x32","0xa8","0x42","0xef","0xb6","0x9d","0x5a","0xcf","0x60","0xfd","0x88","0x3d","0xce","0xef","0xfe","0x15","0x79","0x00"} }, + { + /* No.215 delta:1475 weight:1683 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xd53ab74c,0xc7105e0d,0x122ae941,0x45400d7a,0x907aba36,0x82505377,0x576ae43b,0x00000c2c,0xd53abb60,0xc7105221,0x122ae56d,0x45400156,0x907ab61a,0x82505f5b,0x576ae817}, + [16]uint32{0x00000000,0x08441ad6,0x00446303,0x080079d5,0x205671b2,0x28126b64,0x201212b1,0x28560867,0x0031190f,0x087503d9,0x00757a0c,0x083160da,0x206768bd,0x2823726b,0x20230bbe,0x28671168}, + [16]uint32{0x3f800000,0x3f84220d,0x3f802231,0x3f84003c,0x3f902b38,0x3f940935,0x3f900909,0x3f942b04,0x3f80188c,0x3f843a81,0x3f803abd,0x3f8418b0,0x3f9033b4,0x3f9411b9,0x3f901185,0x3f943388}, + uint32(0xfff80000), + [21]string{"0xe7","0x59","0xda","0xc8","0x4b","0xb3","0x0f","0x1e","0xfa","0x17","0xe2","0x51","0x72","0xbe","0xed","0xc6","0x33","0x46","0x33","0xb0","0x00"} }, + { + /* No.216 delta:837 weight:1593 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0xb808e5ef,0x7155b0d3,0xc95d553c,0x93700d87,0x2b78e868,0xe225bd54,0x5a2d58bb,0x0000e70d,0xb80802e2,0x715557de,0xc95db231,0x9370ea8a,0x2b780f65,0xe2255a59,0x5a2dbfb6}, + [16]uint32{0x00000000,0x0002041f,0x0001e013,0x0003e40c,0x20040348,0x20060757,0x2005e35b,0x2007e744,0x706c09ea,0x706e0df5,0x706de9f9,0x706fede6,0x50680aa2,0x506a0ebd,0x5069eab1,0x506beeae}, + [16]uint32{0x3f800000,0x3f800102,0x3f8000f0,0x3f8001f2,0x3f900201,0x3f900303,0x3f9002f1,0x3f9003f3,0x3fb83604,0x3fb83706,0x3fb836f4,0x3fb837f6,0x3fa83405,0x3fa83507,0x3fa834f5,0x3fa835f7}, + uint32(0xfff80000), + [21]string{"0x3a","0x6e","0xf3","0x8e","0xf1","0x1f","0x2e","0xf7","0xc1","0x1b","0x4c","0x25","0xdd","0x03","0x57","0x41","0x04","0x3d","0x01","0xdd","0x00"} }, + { + /* No.217 delta:1108 weight:1531 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0x38b9e580,0x253c3d68,0x1d85d8e8,0xcbd00d91,0xf369e811,0xeeec30f9,0xd655d579,0x0000fd0b,0x38b9188b,0x253cc063,0x1d8525e3,0xcbd0f09a,0xf369151a,0xeeeccdf2,0xd6552872}, + [16]uint32{0x00000000,0x046d09b2,0x407401d7,0x44190865,0x000911c9,0x0464187b,0x407d101e,0x441019ac,0x4000201c,0x446d29ae,0x007421cb,0x04192879,0x400931d5,0x44643867,0x007d3002,0x041039b0}, + [16]uint32{0x3f800000,0x3f823684,0x3fa03a00,0x3fa20c84,0x3f800488,0x3f82320c,0x3fa03e88,0x3fa2080c,0x3fa00010,0x3fa23694,0x3f803a10,0x3f820c94,0x3fa00498,0x3fa2321c,0x3f803e98,0x3f82081c}, + uint32(0xfff80000), + [21]string{"0xc8","0x6c","0x27","0x5f","0xec","0xc7","0xf5","0x3a","0xbf","0xb3","0x55","0xa1","0xa1","0x9f","0x60","0x19","0xac","0x5f","0x18","0x71","0x00"} }, + { + /* No.218 delta:894 weight:1525 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0x0b862a98,0x1606e550,0x1d80cfc8,0x9d500da0,0x96d62738,0x8b56e8f0,0x80d0c268,0x00001599,0x0b863f01,0x1606f0c9,0x1d80da51,0x9d501839,0x96d632a1,0x8b56fd69,0x80d0d7f1}, + [16]uint32{0x00000000,0x001941be,0x5065607d,0x507c21c3,0x10030172,0x101a40cc,0x4066610f,0x407f20b1,0x000251b6,0x001b1008,0x506731cb,0x507e7075,0x100150c4,0x1018117a,0x406430b9,0x407d7107}, + [16]uint32{0x3f800000,0x3f800ca0,0x3fa832b0,0x3fa83e10,0x3f880180,0x3f880d20,0x3fa03330,0x3fa03f90,0x3f800128,0x3f800d88,0x3fa83398,0x3fa83f38,0x3f8800a8,0x3f880c08,0x3fa03218,0x3fa03eb8}, + uint32(0xfff80000), + [21]string{"0x1b","0x9b","0xe2","0x40","0x50","0x35","0x38","0x4a","0xd9","0x2f","0xe4","0x23","0x03","0xd4","0xb9","0xf8","0xa8","0xab","0x0f","0x6a","0x00"} }, + { + /* No.219 delta:891 weight:1533 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x9f9392da,0xcdd2dfef,0x52414d35,0x22900dbd,0xbd039f67,0xef42d252,0x70d14088,0x0000c2d2,0x9f935008,0xcdd21d3d,0x52418fe7,0x2290cf6f,0xbd035db5,0xef421080,0x70d1825a}, + [16]uint32{0x00000000,0x600600b6,0x0002491d,0x600449ab,0x00016079,0x600760cf,0x00032964,0x600529d2,0x1000501f,0x700650a9,0x10021902,0x700419b4,0x10013066,0x700730d0,0x1003797b,0x700579cd}, + [16]uint32{0x3f800000,0x3fb00300,0x3f800124,0x3fb00224,0x3f8000b0,0x3fb003b0,0x3f800194,0x3fb00294,0x3f880028,0x3fb80328,0x3f88010c,0x3fb8020c,0x3f880098,0x3fb80398,0x3f8801bc,0x3fb802bc}, + uint32(0xfff80000), + [21]string{"0x82","0xfc","0xf1","0xdf","0xe8","0x96","0x44","0x45","0x91","0xae","0x27","0xda","0x06","0x1d","0x00","0xaf","0x72","0x2d","0xa6","0xa3","0x00"} }, + { + /* No.220 delta:978 weight:1467 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x236a1f70,0x764e5295,0x55244de5,0xdbf00dc8,0xf89a12b8,0xadbe5f5d,0x8ed4402d,0x0000c9bc,0x236ad6cc,0x764e9b29,0x55248459,0xdbf0c474,0xf89adb04,0xadbe96e1,0x8ed48991}, + [16]uint32{0x00000000,0x022d91fa,0x1002207c,0x122fb186,0x5031860e,0x521c17f4,0x4033a672,0x421e3788,0x00114401,0x023cd5fb,0x1013647d,0x123ef587,0x5020c20f,0x520d53f5,0x4022e273,0x420f7389}, + [16]uint32{0x3f800000,0x3f8116c8,0x3f880110,0x3f8917d8,0x3fa818c3,0x3fa90e0b,0x3fa019d3,0x3fa10f1b,0x3f8008a2,0x3f811e6a,0x3f8809b2,0x3f891f7a,0x3fa81061,0x3fa906a9,0x3fa01171,0x3fa107b9}, + uint32(0xfff80000), + [21]string{"0x33","0x7b","0x46","0xd2","0xbc","0xf8","0x2c","0x88","0xcc","0xf9","0x40","0x12","0x7d","0x61","0x89","0xb2","0xe7","0x15","0x55","0xb6","0x00"} }, + { + /* No.221 delta:602 weight:1579 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x395966ee,0x6cbf26f7,0x55e64019,0xff500dd8,0xc6096b36,0x93ef2b2f,0xaab64dc1,0x00004fb5,0x3959295b,0x6cbf6942,0x55e60fac,0xff50426d,0xc6092483,0x93ef649a,0xaab60274}, + [16]uint32{0x00000000,0x3002919e,0x00025a59,0x3000cbc7,0x0401201c,0x3403b182,0x04037a45,0x3401ebdb,0x20000b12,0x10029a8c,0x2002514b,0x1000c0d5,0x24012b0e,0x1403ba90,0x24037157,0x1401e0c9}, + [16]uint32{0x3f800000,0x3f980148,0x3f80012d,0x3f980065,0x3f820090,0x3f9a01d8,0x3f8201bd,0x3f9a00f5,0x3f900005,0x3f88014d,0x3f900128,0x3f880060,0x3f920095,0x3f8a01dd,0x3f9201b8,0x3f8a00f0}, + uint32(0xfff80000), + [21]string{"0xbf","0x26","0xe4","0x1e","0xa2","0x93","0x19","0x22","0x0d","0xa0","0x15","0x2f","0xc9","0x3c","0x83","0x07","0x28","0xf5","0x52","0x45","0x00"} }, + { + /* No.222 delta:1212 weight:1493 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x77f6a878,0xb8df422f,0xcf29ea57,0xa9000deb,0xdef6a593,0x11df4fc4,0x6629e7bc,0x0000e4d2,0x77f64caa,0xb8dfa6fd,0xcf290e85,0xa900e939,0xdef64141,0x11dfab16,0x6629036e}, + [16]uint32{0x00000000,0x00255176,0x001245c7,0x003714b1,0x4824480b,0x4801197d,0x48360dcc,0x48135cba,0x0042a01f,0x0067f169,0x0050e5d8,0x0075b4ae,0x4866e814,0x4843b962,0x4874add3,0x4851fca5}, + [16]uint32{0x3f800000,0x3f8012a8,0x3f800922,0x3f801b8a,0x3fa41224,0x3fa4008c,0x3fa41b06,0x3fa409ae,0x3f802150,0x3f8033f8,0x3f802872,0x3f803ada,0x3fa43374,0x3fa421dc,0x3fa43a56,0x3fa428fe}, + uint32(0xfff80000), + [21]string{"0x73","0x81","0xfa","0xca","0x9b","0x8c","0x56","0x79","0xac","0xde","0xd7","0x97","0x4a","0x95","0x2d","0xac","0xaf","0x7a","0xd7","0xfd","0x00"} }, + { + /* No.223 delta:702 weight:1671 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x4a8a3f8e,0x8cb6604e,0xc63c5fc0,0x13c00df0,0x594a327e,0x9f766dbe,0xd5fc5230,0x00001edd,0x4a8a2153,0x8cb67e93,0xc63c411d,0x13c0132d,0x594a2ca3,0x9f767363,0xd5fc4ced}, + [16]uint32{0x00000000,0x1006109e,0x00401077,0x104600e9,0x0002280b,0x10043895,0x0042387c,0x104428e2,0x3000821f,0x20069281,0x30409268,0x204682f6,0x3002aa14,0x2004ba8a,0x3042ba63,0x2044aafd}, + [16]uint32{0x3f800000,0x3f880308,0x3f802008,0x3f882300,0x3f800114,0x3f88021c,0x3f80211c,0x3f882214,0x3f980041,0x3f900349,0x3f982049,0x3f902341,0x3f980155,0x3f90025d,0x3f98215d,0x3f902255}, + uint32(0xfff80000), + [21]string{"0x66","0x5a","0xdb","0xfa","0x2e","0xdd","0x15","0x6f","0x21","0xb3","0x08","0x1a","0x9f","0xf4","0xca","0x85","0x6e","0x6c","0xf1","0x8b","0x00"} }, + { + /* No.224 delta:1058 weight:1543 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x804482da,0x202f737b,0xa06bf1a1,0x84a00e0c,0x04e48cd6,0xa48f7d77,0x24cbffad,0x00007fee,0x8044fd34,0x202f0c95,0xa06b8e4f,0x84a071e2,0x04e4f338,0xa48f0299,0x24cb8043}, + [16]uint32{0x00000000,0x005e00fa,0x0c4c9193,0x0c129169,0x000a180d,0x005418f7,0x0c46899e,0x0c188964,0x00027011,0x005c70eb,0x0c4ee182,0x0c10e178,0x0008681c,0x005668e6,0x0c44f98f,0x0c1af975}, + [16]uint32{0x3f800000,0x3f802f00,0x3f862648,0x3f860948,0x3f80050c,0x3f802a0c,0x3f862344,0x3f860c44,0x3f800138,0x3f802e38,0x3f862770,0x3f860870,0x3f800434,0x3f802b34,0x3f86227c,0x3f860d7c}, + uint32(0xfff80000), + [21]string{"0xbe","0xa2","0x6b","0x7e","0xe7","0x1c","0x3a","0xcf","0xce","0xb8","0xc6","0x54","0x6e","0x94","0xb2","0x2e","0xe3","0x9c","0x91","0x68","0x00"} }, + { + /* No.225 delta:2138 weight:1359 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x3e90494e,0xbc17bf5f,0x8287f611,0x14400e13,0x2ad0475d,0xa857b14c,0x96c7f802,0x00007c06,0x3e903548,0xbc17c359,0x82878a17,0x14407215,0x2ad03b5b,0xa857cd4a,0x96c78404}, + [16]uint32{0x00000000,0x58041376,0x14286614,0x4c2c7562,0x42004ea8,0x1a045dde,0x562828bc,0x0e2c3bca,0x6c00413f,0x34045249,0x7828272b,0x202c345d,0x2e000f97,0x76041ce1,0x3a286983,0x622c7af5}, + [16]uint32{0x3f800000,0x3fac0209,0x3f8a1433,0x3fa6163a,0x3fa10027,0x3f8d022e,0x3fab1414,0x3f87161d,0x3fb60020,0x3f9a0229,0x3fbc1413,0x3f90161a,0x3f970007,0x3fbb020e,0x3f9d1434,0x3fb1163d}, + uint32(0xfff80000), + [21]string{"0xd7","0x40","0x51","0x63","0x1e","0xeb","0x82","0x1f","0xe6","0xec","0xc3","0xcc","0x79","0x9d","0x0a","0x57","0xff","0x3c","0xb9","0xa8","0x00"} }, + { + /* No.226 delta:616 weight:1675 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xfd1bd24f,0xf3f9ff78,0x0ee22d37,0xedb00e2b,0x10abdc64,0x1e49f153,0xe352231c,0x00003a6a,0xfd1be825,0xf3f9c512,0x0ee2175d,0xedb03441,0x10abe60e,0x1e49cb39,0xe3521976}, + [16]uint32{0x00000000,0x400110b6,0x1010f815,0x5011e8a3,0x2024c20a,0x6025d2bc,0x30343a1f,0x70352aa9,0x4001c15e,0x0000d1e8,0x5011394b,0x101029fd,0x60250354,0x202413e2,0x7035fb41,0x3034ebf7}, + [16]uint32{0x3f800000,0x3fa00088,0x3f88087c,0x3fa808f4,0x3f901261,0x3fb012e9,0x3f981a1d,0x3fb81a95,0x3fa000e0,0x3f800068,0x3fa8089c,0x3f880814,0x3fb01281,0x3f901209,0x3fb81afd,0x3f981a75}, + uint32(0xfff80000), + [21]string{"0xe3","0x47","0xc7","0xb8","0xe5","0x9f","0x82","0x92","0xc8","0x0d","0x68","0x3b","0x78","0xd6","0x97","0x3d","0xe8","0x4e","0x01","0xa6","0x00"} }, + { + /* No.227 delta:692 weight:1731 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x6da145eb,0x9b35488c,0xf6940d67,0x39000e3d,0x54a14bd6,0xa23546b1,0xcf94035a,0x00001f6e,0x6da15a85,0x9b3557e2,0xf6941209,0x39001153,0x54a154b8,0xa23559df,0xcf941c34}, + [16]uint32{0x00000000,0x100311fb,0x40023a07,0x50012bfc,0x40002412,0x500335e9,0x00021e15,0x10010fee,0x3000801d,0x200391e6,0x7002ba1a,0x6001abe1,0x7000a40f,0x6003b5f4,0x30029e08,0x20018ff3}, + [16]uint32{0x3f800000,0x3f880188,0x3fa0011d,0x3fa80095,0x3fa00012,0x3fa8019a,0x3f80010f,0x3f880087,0x3f980040,0x3f9001c8,0x3fb8015d,0x3fb000d5,0x3fb80052,0x3fb001da,0x3f98014f,0x3f9000c7}, + uint32(0xfff80000), + [21]string{"0x44","0xcc","0x15","0x5b","0xe6","0x5e","0x83","0x55","0x84","0xf9","0xce","0xc8","0xa2","0x6f","0x0c","0xff","0x71","0xc1","0x9f","0x0b","0x00"} }, + { + /* No.228 delta:2153 weight:1377 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x51f9dadd,0xa2f375d5,0xf30aaf08,0x0c100e49,0x5de9d494,0xaee37b9c,0xff1aa141,0x000074c6,0x51f9ae1b,0xa2f30113,0xf30adbce,0x0c107a8f,0x5de9a052,0xaee30f5a,0xff1ad587}, + [16]uint32{0x00000000,0x267510b2,0x712609d7,0x57531965,0x1402001f,0x327710ad,0x652409c8,0x4351197a,0xad185203,0x8b6d42b1,0xdc3e5bd4,0xfa4b4b66,0xb91a521c,0x9f6f42ae,0xc83c5bcb,0xee494b79}, + [16]uint32{0x3f800000,0x3f933a88,0x3fb89304,0x3faba98c,0x3f8a0100,0x3f993b88,0x3fb29204,0x3fa1a88c,0x3fd68c29,0x3fc5b6a1,0x3fee1f2d,0x3ffd25a5,0x3fdc8d29,0x3fcfb7a1,0x3fe41e2d,0x3ff724a5}, + uint32(0xfff80000), + [21]string{"0x12","0xbb","0xe9","0xb1","0xe2","0xeb","0x7f","0xee","0xab","0x7a","0xff","0x95","0x21","0x30","0xf0","0xe2","0x19","0x07","0x21","0x7c","0x00"} }, + { + /* No.229 delta:1599 weight:1619 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0xde4e5727,0x27620ea0,0xf92c5987,0xed300e53,0x337e5974,0xca5200f3,0x141c57d4,0x00001e91,0xde4e49b6,0x27621031,0xf92c4716,0xed3010c2,0x337e47e5,0xca521e62,0x141c4945}, + [16]uint32{0x00000000,0x08962914,0x900110df,0x989739cb,0x0041601c,0x08d74908,0x904070c3,0x98d659d7,0x50014112,0x58976806,0xc00051cd,0xc89678d9,0x5040210e,0x58d6081a,0xc04131d1,0xc8d718c5}, + [16]uint32{0x3f800000,0x3f844b14,0x3fc80088,0x3fcc4b9c,0x3f8020b0,0x3f846ba4,0x3fc82038,0x3fcc6b2c,0x3fa800a0,0x3fac4bb4,0x3fe00028,0x3fe44b3c,0x3fa82010,0x3fac6b04,0x3fe02098,0x3fe46b8c}, + uint32(0xfff80000), + [21]string{"0x2a","0xa2","0x16","0xca","0x49","0x08","0xa1","0x51","0xd3","0xd5","0x61","0xe9","0x08","0xcb","0x4d","0x45","0x5e","0x1b","0xad","0x1c","0x00"} }, + { + /* No.230 delta:1191 weight:1545 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x194b78e6,0x6f1d3bb7,0x76564351,0xabb00e6d,0xb2fb768b,0xc4ad35da,0xdde64d3c,0x00009530,0x194bedd6,0x6f1dae87,0x7656d661,0xabb09b5d,0xb2fbe3bb,0xc4ada0ea,0xdde6d80c}, + [16]uint32{0x00000000,0x602667de,0x0055807d,0x6073e7a3,0x100a1805,0x702c7fdb,0x105f9878,0x7079ffa6,0x0002458c,0x60242252,0x0057c5f1,0x6071a22f,0x10085d89,0x702e3a57,0x105dddf4,0x707bba2a}, + [16]uint32{0x3f800000,0x3fb01333,0x3f802ac0,0x3fb039f3,0x3f88050c,0x3fb8163f,0x3f882fcc,0x3fb83cff,0x3f800122,0x3fb01211,0x3f802be2,0x3fb038d1,0x3f88042e,0x3fb8171d,0x3f882eee,0x3fb83ddd}, + uint32(0xfff80000), + [21]string{"0x62","0x34","0x3d","0x24","0x5d","0x6b","0xfd","0x1f","0xea","0x46","0xba","0x4e","0xb4","0x16","0xfd","0x63","0xf8","0x2d","0x94","0xfa","0x00"} }, + { + /* No.231 delta:1759 weight:1557 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0xa9aa6236,0xb8d54cd0,0x117f2ee6,0x92100e78,0x3bba6c4e,0x2ac542a8,0x836f209e,0x00003edb,0xa9aa5ced,0xb8d5720b,0x117f103d,0x921030a3,0x3bba5295,0x2ac57c73,0x836f1e45}, + [16]uint32{0x00000000,0x6c129416,0x5880901b,0x3492040d,0xc11100f2,0xad0394e4,0x999190e9,0xf58304ff,0x08b04183,0x64a2d595,0x5030d198,0x3c22458e,0xc9a14171,0xa5b3d567,0x9121d16a,0xfd33457c}, + [16]uint32{0x3f800000,0x3fb6094a,0x3fac4048,0x3f9a4902,0x3fe08880,0x3fd681ca,0x3fccc8c8,0x3ffac182,0x3f845820,0x3fb2516a,0x3fa81868,0x3f9e1122,0x3fe4d0a0,0x3fd2d9ea,0x3fc890e8,0x3ffe99a2}, + uint32(0xfff80000), + [21]string{"0xc5","0x66","0xfd","0xf5","0x39","0x9a","0x81","0xf8","0x17","0x8b","0x0c","0xd1","0x39","0xa7","0xb8","0x7f","0x48","0xb7","0x37","0x1d","0x00"} }, + { + /* No.232 delta:1474 weight:1163 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xe68d94c3,0xca52dfa6,0x2cdf4b65,0x94d00e81,0x725d9a42,0x5e82d127,0xb80f45e4,0x000055a0,0xe68dc163,0xca528a06,0x2cdf1ec5,0x94d05b21,0x725dcfe2,0x5e828487,0xb80f1044}, + [16]uint32{0x00000000,0x107d2196,0x000301af,0x107e2039,0x20200014,0x305d2182,0x202301bb,0x305e202d,0x00408086,0x103da110,0x00438129,0x103ea0bf,0x20608092,0x301da104,0x2063813d,0x301ea0ab}, + [16]uint32{0x3f800000,0x3f883e90,0x3f800180,0x3f883f10,0x3f901000,0x3f982e90,0x3f901180,0x3f982f10,0x3f802040,0x3f881ed0,0x3f8021c0,0x3f881f50,0x3f903040,0x3f980ed0,0x3f9031c0,0x3f980f50}, + uint32(0xfff80000), + [21]string{"0x0d","0x8f","0xf6","0xb5","0x00","0x2c","0x82","0x15","0x41","0xd9","0x7e","0x26","0x8a","0xbf","0xde","0x9d","0xce","0x09","0xa6","0x52","0x00"} }, + { + /* No.233 delta:1710 weight:1477 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xfaa4c149,0x0a815e24,0xf0259f6d,0x48a00e96,0xb204cfdf,0x422150b2,0xb88591fb,0x000046a7,0xfaa487ee,0x0a811883,0xf025d9ca,0x48a04831,0xb2048978,0x42211615,0xb885d75c}, + [16]uint32{0x00000000,0x4687105e,0x0d572a02,0x4bd03a5c,0x09024807,0x4f855859,0x04556205,0x42d2725b,0x0104001f,0x47831041,0x0c532a1d,0x4ad43a43,0x08064818,0x4e815846,0x0551621a,0x43d67244}, + [16]uint32{0x3f800000,0x3fa34388,0x3f86ab95,0x3fa5e81d,0x3f848124,0x3fa7c2ac,0x3f822ab1,0x3fa16939,0x3f808200,0x3fa3c188,0x3f862995,0x3fa56a1d,0x3f840324,0x3fa740ac,0x3f82a8b1,0x3fa1eb39}, + uint32(0xfff80000), + [21]string{"0xc1","0x62","0xd4","0xf4","0x4d","0x8c","0xb8","0x20","0x0e","0xb1","0x1e","0x69","0x92","0xcb","0xfa","0xaf","0x15","0x8d","0x27","0x1d","0x00"} }, + { + /* No.234 delta:1697 weight:1443 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x87b7826a,0xc475bc43,0x43c23e29,0x24800eab,0xa3378cc1,0xe0f5b2e8,0x67423082,0x0000d36a,0x87b75100,0xc4756f29,0x43c2ed43,0x2480ddc1,0xa3375fab,0xe0f56182,0x6742e3e8}, + [16]uint32{0x00000000,0x0f09897a,0x4155e01f,0x4e5c6965,0x0080392e,0x0f89b054,0x41d5d931,0x4edc504b,0x0048a403,0x0f412d79,0x411d441c,0x4e14cd66,0x00c89d2d,0x0fc11457,0x419d7d32,0x4e94f448}, + [16]uint32{0x3f800000,0x3f8784c4,0x3fa0aaf0,0x3fa72e34,0x3f80401c,0x3f87c4d8,0x3fa0eaec,0x3fa76e28,0x3f802452,0x3f87a096,0x3fa08ea2,0x3fa70a66,0x3f80644e,0x3f87e08a,0x3fa0cebe,0x3fa74a7a}, + uint32(0xfff80000), + [21]string{"0x84","0x56","0xa8","0xb2","0x6f","0x3d","0x04","0x3a","0x11","0x3c","0x50","0x4b","0xe0","0x99","0xa4","0x12","0xda","0x3f","0xfb","0x81","0x00"} }, + { + /* No.235 delta:796 weight:1591 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0x99ea585a,0x057b62ab,0x9c913af1,0x03900eb2,0x9a7a56e8,0x06eb6c19,0x9f013443,0x0000556f,0x99ea0d35,0x057b37c4,0x9c916f9e,0x03905bdd,0x9a7a0387,0x06eb3976,0x9f01612c}, + [16]uint32{0x00000000,0x2142a81a,0x800225b6,0xa1408dac,0x00030965,0x2141a17f,0x80012cd3,0xa14384c9,0x0800300b,0x29429811,0x880215bd,0xa940bda7,0x0803396e,0x29419174,0x88011cd8,0xa943b4c2}, + [16]uint32{0x3f800000,0x3f90a154,0x3fc00112,0x3fd0a046,0x3f800184,0x3f90a0d0,0x3fc00096,0x3fd0a1c2,0x3f840018,0x3f94a14c,0x3fc4010a,0x3fd4a05e,0x3f84019c,0x3f94a0c8,0x3fc4008e,0x3fd4a1da}, + uint32(0xfff80000), + [21]string{"0xd5","0x6f","0x5c","0x04","0x37","0x62","0xa3","0x86","0xe3","0x2e","0xd5","0x2a","0xf9","0x33","0xc6","0x05","0x8e","0x64","0x05","0xb7","0x00"} }, + { + /* No.236 delta:991 weight:1467 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0xaf21b504,0xa5813444,0x0aa08140,0xe0600ecd,0x4f41bbc9,0x45e13a89,0xeac08f8d,0x0000f230,0xaf214734,0xa581c674,0x0aa07370,0xe060fcfd,0x4f4149f9,0x45e1c8b9,0xeac07dbd}, + [16]uint32{0x00000000,0x00430d1a,0xb00140ef,0xb0424df5,0x400165f8,0x404268e2,0xf0002517,0xf043280d,0x20024432,0x20414928,0x900304dd,0x904009c7,0x600321ca,0x60402cd0,0xd0026125,0xd0416c3f}, + [16]uint32{0x3f800000,0x3f802186,0x3fd800a0,0x3fd82126,0x3fa000b2,0x3fa02134,0x3ff80012,0x3ff82194,0x3f900122,0x3f9020a4,0x3fc80182,0x3fc82004,0x3fb00190,0x3fb02016,0x3fe80130,0x3fe820b6}, + uint32(0xfff80000), + [21]string{"0x08","0x23","0x32","0x65","0xad","0x77","0xc1","0xe9","0xfa","0x97","0xa8","0xe8","0xfa","0x5e","0xa7","0xfa","0x8c","0x95","0x7e","0x83","0x00"} }, + { + /* No.237 delta:735 weight:677 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x4f2644c0,0x34a648ac,0x7b800c6c,0x8dd00ed7,0xc2f64a17,0xb976467b,0xf65002bb,0x00004ef0,0x4f260a30,0x34a6065c,0x7b80429c,0x8dd04027,0xc2f604e7,0xb976088b,0xf6504c4b}, + [16]uint32{0x00000000,0x4cf610d5,0x439d0047,0x0f6b1092,0x02d00d6d,0x4e261db8,0x414d0d2a,0x0dbb1dff,0x00798016,0x4c8f90c3,0x43e48051,0x0f129084,0x02a98d7b,0x4e5f9dae,0x41348d3c,0x0dc29de9}, + [16]uint32{0x3f800000,0x3fa67b08,0x3fa1ce80,0x3f87b588,0x3f816806,0x3fa7130e,0x3fa0a686,0x3f86dd8e,0x3f803cc0,0x3fa647c8,0x3fa1f240,0x3f878948,0x3f8154c6,0x3fa72fce,0x3fa09a46,0x3f86e14e}, + uint32(0xfff80000), + [21]string{"0x85","0xf6","0x81","0x30","0x53","0x61","0x3f","0x78","0xaf","0xfb","0xcb","0x42","0x18","0xea","0x66","0xf7","0x00","0xb6","0x51","0x2a","0x00"} }, + { + /* No.238 delta:1646 weight:1631 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x28a1b51b,0xbc17178b,0x94b6a290,0x0f500ee9,0x27f1bbf2,0xb3471962,0x9be6ac79,0x00005fbe,0x28a1eaa5,0xbc174835,0x94b6fd2e,0x0f505157,0x27f1e44c,0xb34746dc,0x9be6f3c7}, + [16]uint32{0x00000000,0x080edc5a,0x210608d4,0x2908d48e,0x000ad00c,0x08040c56,0x210cd8d8,0x29020482,0x60496c11,0x6847b04b,0x414f64c5,0x4941b89f,0x6043bc1d,0x684d6047,0x4145b4c9,0x494b6893}, + [16]uint32{0x3f800000,0x3f84076e,0x3f908304,0x3f94846a,0x3f800568,0x3f840206,0x3f90866c,0x3f948102,0x3fb024b6,0x3fb423d8,0x3fa0a7b2,0x3fa4a0dc,0x3fb021de,0x3fb426b0,0x3fa0a2da,0x3fa4a5b4}, + uint32(0xfff80000), + [21]string{"0x85","0x16","0x1a","0x04","0xc7","0x8c","0xaa","0xe7","0x0f","0x71","0x74","0x2d","0xcd","0xbf","0xec","0xeb","0x55","0x2d","0x65","0xad","0x00"} }, + { + /* No.239 delta:921 weight:1259 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0xc2571fd3,0x43f1fa5c,0x81a6e58f,0x00d00ef5,0xc2871126,0x4321f4a9,0x8176eb7a,0x000065ce,0xc2577a1d,0x43f19f92,0x81a68041,0x00d06b3b,0xc28774e8,0x43219167,0x81768eb4}, + [16]uint32{0x00000000,0x004e991c,0x00034177,0x004dd86b,0x40500103,0x401e981f,0x40534074,0x401dd968,0x2040e418,0x200e7d04,0x2043a56f,0x200d3c73,0x6010e51b,0x605e7c07,0x6013a46c,0x605d3d70}, + [16]uint32{0x3f800000,0x3f80274c,0x3f8001a0,0x3f8026ec,0x3fa02800,0x3fa00f4c,0x3fa029a0,0x3fa00eec,0x3f902072,0x3f90073e,0x3f9021d2,0x3f90069e,0x3fb00872,0x3fb02f3e,0x3fb009d2,0x3fb02e9e}, + uint32(0xfff80000), + [21]string{"0x08","0x7b","0xe5","0x96","0x58","0x63","0x7b","0xa7","0x0b","0xcf","0x64","0x7f","0xe5","0xf7","0xbc","0x0c","0x66","0x46","0x6a","0x7e","0x00"} }, + { + /* No.240 delta:777 weight:1607 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0x7afb4c42,0xb4b78f4b,0xce4cc309,0x91a00f01,0xeb5b4343,0x2517804a,0x5feccc08,0x0000e97f,0x7afba53d,0xb4b76634,0xce4c2a76,0x91a0e67e,0xeb5baa3c,0x25176935,0x5fec2577}, + [16]uint32{0x00000000,0x504a0016,0x80005ce4,0xd04a5cf2,0x0002040e,0x50480418,0x800258ea,0xd04858fc,0x40003a0b,0x104a3a1d,0xc00066ef,0x904a66f9,0x40023e05,0x10483e13,0xc00262e1,0x904862f7}, + [16]uint32{0x3f800000,0x3fa82500,0x3fc0002e,0x3fe8252e,0x3f800102,0x3fa82402,0x3fc0012c,0x3fe8242c,0x3fa0001d,0x3f88251d,0x3fe00033,0x3fc82533,0x3fa0011f,0x3f88241f,0x3fe00131,0x3fc82431}, + uint32(0xfff80000), + [21]string{"0x7d","0xc6","0x75","0x54","0xc8","0xc1","0xba","0xe6","0x6d","0xc2","0x62","0xa9","0xad","0x80","0x06","0x6f","0x52","0x9f","0x84","0x48","0x00"} }, + { + /* No.241 delta:2880 weight:821 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0xbbc180f5,0x82b154f4,0x3970d401,0xc7d00f1a,0x7c118fef,0x45615bee,0xfea0db1b,0x000098e9,0xbbc1181c,0x82b1cc1d,0x39704ce8,0xc7d097f3,0x7c111706,0x4561c307,0xfea043f2}, + [16]uint32{0x00000000,0x886b015a,0x0803c5ad,0x8068c4f7,0x4c0d802f,0xc4668175,0x440e4582,0xcc6544d8,0x422a0813,0xca410949,0x4a29cdbe,0xc242cce4,0x0e27883c,0x864c8966,0x06244d91,0x8e4f4ccb}, + [16]uint32{0x3f800000,0x3fc43580,0x3f8401e2,0x3fc03462,0x3fa606c0,0x3fe23340,0x3fa20722,0x3fe632a2,0x3fa11504,0x3fe52084,0x3fa514e6,0x3fe12166,0x3f8713c4,0x3fc32644,0x3f831226,0x3fc727a6}, + uint32(0xfff80000), + [21]string{"0xd3","0x96","0x70","0x46","0x95","0xf4","0x96","0xb6","0xa1","0x5b","0xec","0x17","0xc7","0x4c","0xe6","0x33","0x1b","0x16","0x1d","0x79","0x00"} }, + { + /* No.242 delta:1388 weight:1649 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xf70ad49c,0x3721e624,0xc02b32b8,0xecb00f20,0x1bbadbbc,0xdb91e904,0x2c9b3d98,0x0000cf92,0xf70a1b0e,0x372129b6,0xc02bfd2a,0xecb0c0b2,0x1bba142e,0xdb912696,0x2c9bf20a}, + [16]uint32{0x00000000,0x4054e153,0x207a0102,0x602ee051,0x4035641a,0x00618549,0x604f6518,0x201b844b,0x00501812,0x4004f941,0x202a1910,0x607ef843,0x40657c08,0x00319d5b,0x601f7d0a,0x204b9c59}, + [16]uint32{0x3f800000,0x3fa02a70,0x3f903d00,0x3fb01770,0x3fa01ab2,0x3f8030c2,0x3fb027b2,0x3f900dc2,0x3f80280c,0x3fa0027c,0x3f90150c,0x3fb03f7c,0x3fa032be,0x3f8018ce,0x3fb00fbe,0x3f9025ce}, + uint32(0xfff80000), + [21]string{"0x21","0xa5","0x6f","0x7b","0xe2","0xe3","0x9a","0x38","0x8d","0x3b","0xad","0x35","0x7d","0x5b","0x6c","0xd5","0x14","0x7f","0x83","0x43","0x00"} }, + { + /* No.243 delta:822 weight:715 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x5c622cc8,0xd18006f0,0x8de22a38,0xb6c00f33,0xeaa223fb,0x674009c3,0x3b22250b,0x00006b6b,0x5c6247a3,0xd1806d9b,0x8de24153,0xb6c06458,0xeaa24890,0x674062a8,0x3b224e60}, + [16]uint32{0x00000000,0x0043b215,0x104205bf,0x1001b7aa,0x0de0001b,0x0da3b20e,0x1da205a4,0x1de1b7b1,0x20c10146,0x2082b353,0x308304f9,0x30c0b6ec,0x2d21015d,0x2d62b348,0x3d6304e2,0x3d20b6f7}, + [16]uint32{0x3f800000,0x3f8021d9,0x3f882102,0x3f8800db,0x3f86f000,0x3f86d1d9,0x3f8ed102,0x3f8ef0db,0x3f906080,0x3f904159,0x3f984182,0x3f98605b,0x3f969080,0x3f96b159,0x3f9eb182,0x3f9e905b}, + uint32(0xfff80000), + [21]string{"0x53","0x4d","0x4a","0xc1","0x80","0xb0","0x11","0x78","0x0b","0xb8","0x0d","0xac","0xd2","0x38","0x5b","0x1c","0xc4","0x45","0xb9","0xd9","0x00"} }, + { + /* No.244 delta:1331 weight:1553 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xb107a6a0,0x6b935e95,0xda94f835,0xa6b00f4e,0x17b7a9ee,0xcd2351db,0x7c24f77b,0x000004d0,0xb107a270,0x6b935a45,0xda94fce5,0xa6b00b9e,0x17b7ad3e,0xcd23550b,0x7c24f3ab}, + [16]uint32{0x00000000,0x34509156,0x104b48a5,0x241bd9f3,0x0023b194,0x347320c2,0x1068f931,0x24386867,0x0046240d,0x3416b55b,0x100d6ca8,0x245dfdfe,0x00659599,0x343504cf,0x102edd3c,0x247e4c6a}, + [16]uint32{0x3f800000,0x3f9a2848,0x3f8825a4,0x3f920dec,0x3f8011d8,0x3f9a3990,0x3f88347c,0x3f921c34,0x3f802312,0x3f9a0b5a,0x3f8806b6,0x3f922efe,0x3f8032ca,0x3f9a1a82,0x3f88176e,0x3f923f26}, + uint32(0xfff80000), + [21]string{"0xc1","0x2c","0x81","0xd7","0x86","0x64","0xb1","0x2b","0x64","0x0d","0x03","0xf6","0x5c","0x83","0x00","0x2a","0xbc","0xea","0xdc","0x0f","0x00"} }, + { + /* No.245 delta:1052 weight:1575 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x897f1ecc,0x20523dfa,0xa92d2336,0xcc300f52,0x454f119e,0xec6232a8,0x651d2c64,0x0000802c,0x897f9ee0,0x2052bdd6,0xa92da31a,0xcc308f7e,0x454f91b2,0xec62b284,0x651dac48}, + [16]uint32{0x00000000,0x4049c135,0x600005fa,0x2049c4cf,0x800080f6,0xc04941c3,0xe000850c,0xa0494439,0x00001090,0x4049d1a5,0x6000156a,0x2049d45f,0x80009066,0xc0495153,0xe000959c,0xa04954a9}, + [16]uint32{0x3f800000,0x3fa024e0,0x3fb00002,0x3f9024e2,0x3fc00040,0x3fe024a0,0x3ff00042,0x3fd024a2,0x3f800008,0x3fa024e8,0x3fb0000a,0x3f9024ea,0x3fc00048,0x3fe024a8,0x3ff0004a,0x3fd024aa}, + uint32(0xfff80000), + [21]string{"0x34","0xf6","0x87","0x19","0x71","0x96","0xeb","0x10","0x2c","0x0c","0x30","0xf6","0x48","0x8c","0x49","0x9b","0x14","0x7f","0xfa","0x83","0x00"} }, + { + /* No.246 delta:866 weight:1437 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0x8bfba319,0x05d4ddb9,0x8e2f7ea0,0x48900f6a,0xc36bac73,0x4d44d2d3,0xc6bf71ca,0x0000411a,0x8bfbe203,0x05d49ca3,0x8e2f3fba,0x48904e70,0xc36bed69,0x4d4493c9,0xc6bf30d0}, + [16]uint32{0x00000000,0x0318b3f6,0x68390a3f,0x6b21b9c9,0x606462a2,0x637cd154,0x085d689d,0x0b45db6b,0x001181d2,0x03093224,0x68288bed,0x6b30381b,0x6075e370,0x636d5086,0x084ce94f,0x0b545ab9}, + [16]uint32{0x3f800000,0x3f818c59,0x3fb41c85,0x3fb590dc,0x3fb03231,0x3fb1be68,0x3f842eb4,0x3f85a2ed,0x3f8008c0,0x3f818499,0x3fb41445,0x3fb5981c,0x3fb03af1,0x3fb1b6a8,0x3f842674,0x3f85aa2d}, + uint32(0xfff80000), + [21]string{"0xd8","0xaa","0x8c","0x91","0xd1","0x94","0x8a","0x56","0x8b","0xf4","0xbf","0xff","0x90","0xb6","0x8c","0x6e","0x55","0xfc","0xf6","0x1e","0x00"} }, + { + /* No.247 delta:1081 weight:1351 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x4038e490,0x927decbe,0xd245082e,0xaf700f77,0xef48ebe7,0x3d0de3c9,0x7d350759,0x0000e3af,0x4038073f,0x927d0f11,0xd245eb81,0xaf70ecd8,0xef480848,0x3d0d0066,0x7d35e4f6}, + [16]uint32{0x00000000,0x00745192,0x004a196d,0x003e48ff,0x00098019,0x007dd18b,0x00439974,0x0037c8e6,0x2080298c,0x20f4781e,0x20ca30e1,0x20be6173,0x2089a995,0x20fdf807,0x20c3b0f8,0x20b7e16a}, + [16]uint32{0x3f800000,0x3f803a28,0x3f80250c,0x3f801f24,0x3f8004c0,0x3f803ee8,0x3f8021cc,0x3f801be4,0x3f904014,0x3f907a3c,0x3f906518,0x3f905f30,0x3f9044d4,0x3f907efc,0x3f9061d8,0x3f905bf0}, + uint32(0xfff80000), + [21]string{"0x81","0x97","0x5b","0xe9","0x62","0x18","0xbd","0x08","0xff","0xc4","0x8f","0xf2","0xcc","0xba","0xb8","0x1c","0xe3","0xa5","0x8b","0x68","0x00"} }, + { + /* No.248 delta:917 weight:1245 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0xf6306c98,0x83db0b6e,0x75eb67f6,0x1c800f86,0xeab0631e,0x9f5b04e8,0x696b6870,0x000099c0,0xf630f558,0x83db92ae,0x75ebfe36,0x1c809646,0xeab0fade,0x9f5b9d28,0x696bf1b0}, + [16]uint32{0x00000000,0x204c216b,0x400000bc,0x604c21d7,0x5030c811,0x707ce97a,0x1030c8ad,0x307ce9c6,0x40010804,0x604d296f,0x000108b8,0x204d29d3,0x1031c015,0x307de17e,0x5031c0a9,0x707de1c2}, + [16]uint32{0x3f800000,0x3f902610,0x3fa00000,0x3fb02610,0x3fa81864,0x3fb83e74,0x3f881864,0x3f983e74,0x3fa00084,0x3fb02694,0x3f800084,0x3f902694,0x3f8818e0,0x3f983ef0,0x3fa818e0,0x3fb83ef0}, + uint32(0xfff80000), + [21]string{"0x49","0x62","0x20","0xf2","0xe9","0xcd","0x93","0x52","0xa3","0xfd","0x81","0x9b","0xf7","0xcb","0x48","0x7c","0x53","0xf4","0xd1","0x96","0x00"} }, + { + /* No.249 delta:3104 weight:611 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xfe07e67a,0x0d725357,0xf375b52d,0x7ea00f98,0x80a7e9e2,0x73d25ccf,0x8dd5bab5,0x0000a8bb,0xfe074ec1,0x0d72fbec,0xf3751d96,0x7ea0a723,0x80a74159,0x73d2f474,0x8dd5120e}, + [16]uint32{0x00000000,0x0200b4eb,0x08d2409e,0x0ad2f475,0xb041120c,0xb241a6e7,0xb8935292,0xba93e679,0x28008013,0x2a0034f8,0x20d2c08d,0x22d27466,0x9841921f,0x9a4126f4,0x9093d281,0x9293666a}, + [16]uint32{0x3f800000,0x3f81005a,0x3f846920,0x3f85697a,0x3fd82089,0x3fd920d3,0x3fdc49a9,0x3fdd49f3,0x3f940040,0x3f95001a,0x3f906960,0x3f91693a,0x3fcc20c9,0x3fcd2093,0x3fc849e9,0x3fc949b3}, + uint32(0xfff80000), + [21]string{"0xc5","0xe0","0xf8","0xcc","0xa0","0x0e","0x7d","0x9b","0x3c","0xa5","0x41","0x95","0x21","0xf6","0x26","0x8e","0x33","0xf4","0x75","0x77","0x00"} }, + { + /* No.250 delta:869 weight:1669 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0xc43f1bd2,0x06294d87,0xc2165655,0xffd00fa3,0x3bef1471,0xf9f94224,0x3dc659f6,0x00001d94,0xc43f0646,0x06295013,0xc2164bc1,0xffd01237,0x3bef09e5,0xf9f95fb0,0x3dc64462}, + [16]uint32{0x00000000,0x306c79d6,0x0003428f,0x306f3b59,0x703813be,0x40546a68,0x703b5131,0x405728e7,0x1028401c,0x204439ca,0x102b0293,0x20477b45,0x601053a2,0x507c2a74,0x6013112d,0x507f68fb}, + [16]uint32{0x3f800000,0x3f98363c,0x3f8001a1,0x3f98379d,0x3fb81c09,0x3fa02a35,0x3fb81da8,0x3fa02b94,0x3f881420,0x3f90221c,0x3f881581,0x3f9023bd,0x3fb00829,0x3fa83e15,0x3fb00988,0x3fa83fb4}, + uint32(0xfff80000), + [21]string{"0x9d","0x68","0xef","0xad","0x03","0x83","0x62","0x0c","0x79","0x30","0xd2","0x34","0x90","0x4e","0xb3","0x38","0xdc","0x59","0x79","0xd2","0x00"} }, + { + /* No.251 delta:1162 weight:1717 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0xe894c623,0x4d24d22d,0xa5b0140e,0x8ee00fbc,0x6674c99f,0xc3c4dd91,0x2b501bb2,0x00005afc,0xe8949cdf,0x4d2488d1,0xa5b04ef2,0x8ee05540,0x66749363,0xc3c4876d,0x2b50414e}, + [16]uint32{0x00000000,0x110c053a,0x404a21cf,0x514624f5,0x3040a0dc,0x214ca5e6,0x700a8113,0x61068429,0x00062071,0x110a254b,0x404c01be,0x51400484,0x304680ad,0x214a8597,0x700ca162,0x6100a458}, + [16]uint32{0x3f800000,0x3f888602,0x3fa02510,0x3fa8a312,0x3f982050,0x3f90a652,0x3fb80540,0x3fb08342,0x3f800310,0x3f888512,0x3fa02600,0x3fa8a002,0x3f982340,0x3f90a542,0x3fb80650,0x3fb08052}, + uint32(0xfff80000), + [21]string{"0x79","0x69","0xf5","0xba","0x26","0x51","0xcd","0x20","0x6e","0x16","0x6f","0x8b","0xac","0x8d","0xf4","0xbe","0xaa","0xa1","0x19","0xb4","0x00"} }, + { + /* No.252 delta:1583 weight:1609 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x8a792ec4,0xfe8e1123,0x74f73fe7,0xab800fc3,0x21f92107,0x550e1ee0,0xdf773024,0x0000e184,0x8a79cf40,0xfe8ef0a7,0x74f7de63,0xab80ee47,0x21f9c083,0x550eff64,0xdf77d1a0}, + [16]uint32{0x00000000,0x84a648b2,0x005a030a,0x84fc4bb8,0x593d009c,0xdd9b482e,0x59670396,0xddc14b24,0x10008353,0x94a6cbe1,0x105a8059,0x94fcc8eb,0x493d83cf,0xcd9bcb7d,0x496780c5,0xcdc1c877}, + [16]uint32{0x3f800000,0x3fc25324,0x3f802d01,0x3fc27e25,0x3fac9e80,0x3feecda4,0x3facb381,0x3feee0a5,0x3f880041,0x3fca5365,0x3f882d40,0x3fca7e64,0x3fa49ec1,0x3fe6cde5,0x3fa4b3c0,0x3fe6e0e4}, + uint32(0xfff80000), + [21]string{"0xbb","0xd6","0x98","0x2a","0x1f","0x07","0x0d","0x35","0xa2","0x37","0x88","0xe4","0x31","0xe7","0xea","0x27","0xc8","0x07","0x91","0x6a","0x00"} }, + { + /* No.253 delta:721 weight:1577 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0x3e850aef,0xd60ef703,0xe88bfdec,0x14400fd1,0x2ac5053e,0xc24ef8d2,0xfccbf23d,0x0000412b,0x3e854bc4,0xd60eb628,0xe88bbcc7,0x14404efa,0x2ac54415,0xc24eb9f9,0xfccbb316}, + [16]uint32{0x00000000,0x000231ba,0x2064c13f,0x2066f085,0x30080017,0x300a31ad,0x106cc128,0x106ef092,0x2000a80b,0x200299b1,0x00646934,0x0066588e,0x1008a81c,0x100a99a6,0x306c6923,0x306e5899}, + [16]uint32{0x3f800000,0x3f800118,0x3f903260,0x3f903378,0x3f980400,0x3f980518,0x3f883660,0x3f883778,0x3f900054,0x3f90014c,0x3f803234,0x3f80332c,0x3f880454,0x3f88054c,0x3f983634,0x3f98372c}, + uint32(0xfff80000), + [21]string{"0x0f","0x5c","0x5d","0x61","0x52","0x2d","0xf2","0x5f","0xa2","0x7e","0x9b","0xd4","0xa5","0x3a","0xc0","0xf5","0x0c","0x06","0x70","0xbd","0x00"} }, + { + /* No.254 delta:711 weight:1425 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0xb21db8e2,0xd4e65389,0x66fbeb6b,0x61700fed,0xd36db70f,0xb5965c64,0x078be486,0x00007046,0xb21dc8a4,0xd4e623cf,0x66fb9b2d,0x61707fab,0xd36dc749,0xb5962c22,0x078b94c0}, + [16]uint32{0x00000000,0x80021f16,0x1800041c,0x98021b0a,0x20100011,0xa0121f07,0x3810040d,0xb8121b1b,0xc000101a,0x40020f0c,0xd8001406,0x58020b10,0xe010100b,0x60120f1d,0xf8101417,0x78120b01}, + [16]uint32{0x3f800000,0x3fc0010f,0x3f8c0002,0x3fcc010d,0x3f900800,0x3fd0090f,0x3f9c0802,0x3fdc090d,0x3fe00008,0x3fa00107,0x3fec000a,0x3fac0105,0x3ff00808,0x3fb00907,0x3ffc080a,0x3fbc0905}, + uint32(0xfff80000), + [21]string{"0x86","0xc9","0x7c","0x93","0x6b","0x18","0xc2","0x59","0xcd","0x8e","0x32","0x73","0x35","0x8d","0x77","0x06","0xdf","0xbd","0xea","0x12","0x00"} }, + { + /* No.255 delta:933 weight:1313 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x349456a5,0x5a59f264,0x6ecda4c1,0x6b000ffb,0x5f94595e,0x3159fd9f,0x05cdab3a,0x0000e642,0x3494b0e7,0x5a591426,0x6ecd4283,0x6b00e9b9,0x5f94bf1c,0x31591bdd,0x05cd4d78}, + [16]uint32{0x00000000,0xa064199d,0x00028c09,0xa0669594,0x0070160c,0xa0140f91,0x00729a05,0xa0168398,0x202d0013,0x8049198e,0x202f8c1a,0x804b9587,0x205d161f,0x80390f82,0x205f9a16,0x803b838b}, + [16]uint32{0x3f800000,0x3fd0320c,0x3f800146,0x3fd0334a,0x3f80380b,0x3fd00a07,0x3f80394d,0x3fd00b41,0x3f901680,0x3fc0248c,0x3f9017c6,0x3fc025ca,0x3f902e8b,0x3fc01c87,0x3f902fcd,0x3fc01dc1}, + uint32(0xfff80000), + [21]string{"0x45","0x8b","0x9e","0x01","0x37","0x33","0x2f","0x18","0xc2","0x03","0x68","0x8a","0x70","0xc5","0x62","0xdb","0xcc","0xa0","0x2d","0x43","0x00"} }, + { + /* No.256 delta:605 weight:1801 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x342137e7,0x86f5904e,0xb2d4a7a9,0x1f30100c,0x2b1127eb,0x99c58042,0xade4b7a5,0x0000f1e9,0x3421c60e,0x86f561a7,0xb2d45640,0x1f30e1e5,0x2b11d602,0x99c571ab,0xade4464c}, + [16]uint32{0x00000000,0x6054283e,0x402c6d03,0x2078453d,0x00032984,0x605701ba,0x402f4487,0x207b6cb9,0x00441390,0x60103bae,0x40687e93,0x203c56ad,0x00473a14,0x6013122a,0x406b5717,0x203f7f29}, + [16]uint32{0x3f800000,0x3fb02a14,0x3fa01636,0x3f903c22,0x3f800194,0x3fb02b80,0x3fa017a2,0x3f903db6,0x3f802209,0x3fb0081d,0x3fa0343f,0x3f901e2b,0x3f80239d,0x3fb00989,0x3fa035ab,0x3f901fbf}, + uint32(0xfff80000), + [21]string{"0x6a","0x8c","0x53","0xa9","0x17","0xee","0xbd","0x72","0x95","0x5a","0xce","0xd3","0x11","0x5d","0xa2","0x36","0xea","0x74","0x99","0x2a","0x00"} }, + { + /* No.257 delta:863 weight:1373 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xb7066e36,0x2c98dbac,0x9b9eb59a,0x9b101010,0x2c167e26,0xb788cbbc,0x008ea58a,0x00006100,0xb7060f36,0x2c98baac,0x9b9ed49a,0x9b107110,0x2c161f26,0xb788aabc,0x008ec48a}, + [16]uint32{0x00000000,0x20401155,0x101c1407,0x305c0552,0x1072a07c,0x3032b129,0x006eb47b,0x202ea52e,0x50204163,0x70605036,0x403c5564,0x607c4431,0x4052e11f,0x6012f04a,0x504ef518,0x700ee44d}, + [16]uint32{0x3f800000,0x3f902008,0x3f880e0a,0x3f982e02,0x3f883950,0x3f981958,0x3f80375a,0x3f901752,0x3fa81020,0x3fb83028,0x3fa01e2a,0x3fb03e22,0x3fa02970,0x3fb00978,0x3fa8277a,0x3fb80772}, + uint32(0xfff80000), + [21]string{"0xc8","0xf8","0xe1","0x6d","0x99","0xea","0x62","0x89","0x5e","0xf6","0x2a","0x05","0x18","0x72","0x7f","0x94","0xd4","0xbc","0x43","0x2f","0x00"} }, + { + /* No.258 delta:844 weight:1611 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x360179e6,0x7d8f574e,0x4b8e2ea8,0xe3e01029,0xd5e169cf,0x9e6f4767,0xa86e3e81,0x0000388d,0x3601416b,0x7d8f6fc3,0x4b8e1625,0xe3e028a4,0xd5e15142,0x9e6f7fea,0xa86e060c}, + [16]uint32{0x00000000,0x0002359a,0x38042137,0x380614ad,0x2001a0a4,0x2003953e,0x18058193,0x1807b409,0x10408054,0x1042b5ce,0x2844a163,0x284694f9,0x304120f0,0x3043156a,0x084501c7,0x0847345d}, + [16]uint32{0x3f800000,0x3f80011a,0x3f9c0210,0x3f9c030a,0x3f9000d0,0x3f9001ca,0x3f8c02c0,0x3f8c03da,0x3f882040,0x3f88215a,0x3f942250,0x3f94234a,0x3f982090,0x3f98218a,0x3f842280,0x3f84239a}, + uint32(0xfff80000), + [21]string{"0xfb","0xdc","0xb0","0x3d","0x31","0x8e","0x11","0xf1","0x4a","0x02","0xb2","0x55","0xda","0xae","0x59","0x8f","0x1a","0x96","0x73","0x1d","0x00"} }, + { + /* No.259 delta:992 weight:1607 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0xd8eeb2ae,0xbb27aba5,0x63c9190b,0x0a701030,0xd29ea29e,0xb157bb95,0x69b9093b,0x0000f6ce,0xd8ee4460,0xbb275d6b,0x63c9efc5,0x0a70e6fe,0xd29e5450,0xb1574d5b,0x69b9fff5}, + [16]uint32{0x00000000,0x406b805a,0x105c4107,0x5037c15d,0x00020011,0x4069804b,0x105e4116,0x5035c14c,0x000360ee,0x4068e0b4,0x105f21e9,0x5034a1b3,0x000160ff,0x406ae0a5,0x105d21f8,0x5036a1a2}, + [16]uint32{0x3f800000,0x3fa035c0,0x3f882e20,0x3fa81be0,0x3f800100,0x3fa034c0,0x3f882f20,0x3fa81ae0,0x3f8001b0,0x3fa03470,0x3f882f90,0x3fa81a50,0x3f8000b0,0x3fa03570,0x3f882e90,0x3fa81b50}, + uint32(0xfff80000), + [21]string{"0xf3","0xf4","0xf3","0x13","0xb4","0xd8","0xeb","0xf3","0xc0","0xd5","0xea","0x82","0xf4","0x00","0xb5","0x10","0xcf","0xe7","0x19","0x71","0x00"} }, + { + /* No.260 delta:1024 weight:1663 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0xd7afe2a0,0xd521d695,0x028e3435,0xdfb0104f,0x081ff2ef,0x0a91c6da,0xdd3e247a,0x00007d7d,0xd7af9fdd,0xd521abe8,0x028e4948,0xdfb06d32,0x081f8f92,0x0a91bba7,0xdd3e5907}, + [16]uint32{0x00000000,0x346a0796,0x005c830f,0x34368499,0x00720015,0x34180783,0x002e831a,0x3444848c,0x00030169,0x346906ff,0x005f8266,0x343585f0,0x0071017c,0x341b06ea,0x002d8273,0x344785e5}, + [16]uint32{0x3f800000,0x3f9a3503,0x3f802e41,0x3f9a1b42,0x3f803900,0x3f9a0c03,0x3f801741,0x3f9a2242,0x3f800180,0x3f9a3483,0x3f802fc1,0x3f9a1ac2,0x3f803880,0x3f9a0d83,0x3f8016c1,0x3f9a23c2}, + uint32(0xfff80000), + [21]string{"0xa1","0x73","0x91","0x1d","0x3a","0x48","0xba","0xbe","0x46","0x5c","0xa1","0x3d","0x32","0x83","0x48","0xcb","0xb5","0x5e","0x31","0xec","0x00"} }, + { + /* No.261 delta:1296 weight:1559 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xb4eadce0,0xf6b33791,0x4259eb71,0x5370105f,0xe79accbf,0xa5c327ce,0x1129fb2e,0x00005bbe,0xb4ea875e,0xf6b36c2f,0x4259b0cf,0x53704be1,0xe79a9701,0xa5c37c70,0x1129a090}, + [16]uint32{0x00000000,0x003c00f2,0x00526c15,0x006e6ce7,0x444121d8,0x447d212a,0x44134dcd,0x442f4d3f,0x5040517b,0x507c5189,0x50123d6e,0x502e3d9c,0x140170a3,0x143d7051,0x14531cb6,0x146f1c44}, + [16]uint32{0x3f800000,0x3f801e00,0x3f802936,0x3f803736,0x3fa22090,0x3fa23e90,0x3fa209a6,0x3fa217a6,0x3fa82028,0x3fa83e28,0x3fa8091e,0x3fa8171e,0x3f8a00b8,0x3f8a1eb8,0x3f8a298e,0x3f8a378e}, + uint32(0xfff80000), + [21]string{"0x39","0xec","0xa1","0x9c","0xfe","0x15","0x24","0x8f","0x79","0x2a","0xe2","0x1b","0x4b","0x1f","0x3b","0x93","0xc2","0xf8","0xfe","0x28","0x00"} }, + { + /* No.262 delta:1036 weight:1361 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x2b06a8a3,0x088b8a7e,0x238d22dd,0x84a0106f,0xafa6b8cc,0x8c2b9a11,0xa72d32b2,0x00007f70,0x2b06d7d3,0x088bf50e,0x238d5dad,0x84a06f1f,0xafa6c7bc,0x8c2be561,0xa72d4dc2}, + [16]uint32{0x00000000,0x104ea5f6,0x0002781c,0x104cddea,0x2014148f,0x305ab179,0x20166c93,0x3058c965,0x4004020e,0x504aa7f8,0x40067a12,0x5048dfe4,0x60101681,0x705eb377,0x60126e9d,0x705ccb6b}, + [16]uint32{0x3f800000,0x3f882752,0x3f80013c,0x3f88266e,0x3f900a0a,0x3f982d58,0x3f900b36,0x3f982c64,0x3fa00201,0x3fa82553,0x3fa0033d,0x3fa8246f,0x3fb0080b,0x3fb82f59,0x3fb00937,0x3fb82e65}, + uint32(0xfff80000), + [21]string{"0x8c","0xc5","0x0c","0x35","0x11","0x9b","0x8d","0x08","0xef","0x18","0xf5","0x67","0x99","0x5d","0x0b","0x26","0x1e","0xca","0x92","0x53","0x00"} }, + { + /* No.263 delta:2453 weight:1089 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0x458429b4,0x7cef26c1,0x396b0f75,0x4320107b,0x06a439cf,0x3fcf36ba,0x7a4b1f0e,0x0000f056,0x4584d9e2,0x7cefd697,0x396bff23,0x4320e02d,0x06a4c999,0x3fcfc6ec,0x7a4bef58}, + [16]uint32{0x00000000,0xf34c009a,0x2c8290eb,0xdfce9071,0x0c60dc1d,0xff2cdc87,0x20e24cf6,0xd3ae4c6c,0x8100a015,0x724ca08f,0xad8230fe,0x5ece3064,0x8d607c08,0x7e2c7c92,0xa1e2ece3,0x52aeec79}, + [16]uint32{0x3f800000,0x3ff9a600,0x3f964148,0x3fefe748,0x3f86306e,0x3fff966e,0x3f907126,0x3fe9d726,0x3fc08050,0x3fb92650,0x3fd6c118,0x3faf6718,0x3fc6b03e,0x3fbf163e,0x3fd0f176,0x3fa95776}, + uint32(0xfff80000), + [21]string{"0x94","0x05","0x08","0x43","0xc1","0xf2","0xec","0xc6","0x72","0xf9","0x7b","0x5f","0x0b","0xb7","0x20","0x90","0xa1","0x0c","0x05","0xc3","0x00"} }, + { + /* No.264 delta:2296 weight:1275 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x6d36c21f,0x2d55d337,0x40631128,0x40101082,0x2d26d29d,0x6d45c3b5,0x007301aa,0x0000fec9,0x6d363cd6,0x2d552dfe,0x4063efe1,0x4010ee4b,0x2d262c54,0x6d453d7c,0x0073ff63}, + [16]uint32{0x00000000,0x91d0823c,0x01433183,0x9093b3bf,0x08238018,0x99f30224,0x0960b19b,0x98b033a7,0x284041e9,0xb990c3d5,0x2903706a,0xb8d3f256,0x2063c1f1,0xb1b343cd,0x2120f072,0xb0f0724e}, + [16]uint32{0x3f800000,0x3fc8e841,0x3f80a198,0x3fc849d9,0x3f8411c0,0x3fccf981,0x3f84b058,0x3fcc5819,0x3f942020,0x3fdcc861,0x3f9481b8,0x3fdc69f9,0x3f9031e0,0x3fd8d9a1,0x3f909078,0x3fd87839}, + uint32(0xfff80000), + [21]string{"0xb5","0xe7","0x9a","0xf6","0x8c","0xb1","0x53","0x83","0xaa","0xdc","0x4f","0xd1","0x27","0xbd","0x92","0xce","0x9a","0x97","0xf6","0x5d","0x00"} }, + { + /* No.265 delta:1158 weight:1607 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0xc81c6b49,0x43c14ad1,0x8bdd2198,0x4bf01098,0x83ec7bd1,0x08315a49,0xc02d3100,0x0000415a,0xc81c2a13,0x43c10b8b,0x8bdd60c2,0x4bf051c2,0x83ec3a8b,0x08311b13,0xc02d705a}, + [16]uint32{0x00000000,0x407d1df6,0x002288e3,0x405f9515,0x004109da,0x403c142c,0x00638139,0x401e9ccf,0x400090de,0x007d8d28,0x4022183d,0x005f05cb,0x40419904,0x003c84f2,0x406311e7,0x001e0c11}, + [16]uint32{0x3f800000,0x3fa03e8e,0x3f801144,0x3fa02fca,0x3f802084,0x3fa01e0a,0x3f8031c0,0x3fa00f4e,0x3fa00048,0x3f803ec6,0x3fa0110c,0x3f802f82,0x3fa020cc,0x3f801e42,0x3fa03188,0x3f800f06}, + uint32(0xfff80000), + [21]string{"0x8d","0x79","0x23","0x39","0x76","0x1c","0x07","0xdc","0x6e","0x0b","0x77","0xe9","0xca","0xc2","0x1e","0xd5","0x38","0x40","0xdc","0x78","0x00"} }, + { + /* No.266 delta:846 weight:1549 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0xfafaddf3,0x7291565f,0x886b8bac,0xcf0010ac,0x35facd5f,0xbd9146f3,0x476b9b00,0x0000950e,0xfafa48fd,0x7291c351,0x886b1ea2,0xcf0085a2,0x35fa5851,0xbd91d3fd,0x476b0e0e}, + [16]uint32{0x00000000,0x00412d7a,0x20048415,0x2045a96f,0x402211bc,0x40633cc6,0x602695a9,0x6067b8d3,0x00020117,0x00432c6d,0x20068502,0x2047a878,0x402010ab,0x40613dd1,0x602494be,0x6065b9c4}, + [16]uint32{0x3f800000,0x3f802096,0x3f900242,0x3f9022d4,0x3fa01108,0x3fa0319e,0x3fb0134a,0x3fb033dc,0x3f800100,0x3f802196,0x3f900342,0x3f9023d4,0x3fa01008,0x3fa0309e,0x3fb0124a,0x3fb032dc}, + uint32(0xfff80000), + [21]string{"0x62","0xdc","0x6e","0x67","0x1c","0xbc","0xab","0x5f","0xd4","0x36","0x3c","0x45","0x2a","0xee","0x29","0xad","0xcd","0xf4","0x0e","0x8b","0x00"} }, + { + /* No.267 delta:913 weight:1567 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0x4f356cb4,0x0cbf6d0c,0x438a01b8,0x18b010b3,0x57857c07,0x140f7dbf,0x5b3a110b,0x000019a5,0x4f357511,0x0cbf74a9,0x438a181d,0x18b00916,0x578565a2,0x140f641a,0x5b3a08ae}, + [16]uint32{0x00000000,0x00048272,0x02005f69,0x0204dd1b,0x0403b813,0x04073a61,0x0603e77a,0x06076508,0x20001016,0x20049264,0x22004f7f,0x2204cd0d,0x2403a805,0x24072a77,0x2603f76c,0x2607751e}, + [16]uint32{0x3f800000,0x3f800241,0x3f81002f,0x3f81026e,0x3f8201dc,0x3f82039d,0x3f8301f3,0x3f8303b2,0x3f900008,0x3f900249,0x3f910027,0x3f910266,0x3f9201d4,0x3f920395,0x3f9301fb,0x3f9303ba}, + uint32(0xfff80000), + [21]string{"0x30","0x6f","0xbb","0x9a","0x32","0xf0","0x90","0xbb","0x63","0x06","0xf6","0x11","0x8c","0xd3","0xfc","0x59","0xbd","0x92","0xbe","0x9a","0x00"} }, + { + /* No.268 delta:1119 weight:1599 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x9541706b,0xd1114ada,0x44503ab1,0x1cc010c0,0x898160ab,0xcdd15a1a,0x58902a71,0x00006fc3,0x95411fa8,0xd1112519,0x44505572,0x1cc07f03,0x89810f68,0xcdd135d9,0x589045b2}, + [16]uint32{0x00000000,0x122f889e,0x0047c15c,0x126849c2,0x00016049,0x122ee8d7,0x0046a115,0x1269298b,0x00001003,0x122f989d,0x0047d15f,0x126859c1,0x0001704a,0x122ef8d4,0x0046b116,0x12693988}, + [16]uint32{0x3f800000,0x3f8917c4,0x3f8023e0,0x3f893424,0x3f8000b0,0x3f891774,0x3f802350,0x3f893494,0x3f800008,0x3f8917cc,0x3f8023e8,0x3f89342c,0x3f8000b8,0x3f89177c,0x3f802358,0x3f89349c}, + uint32(0xfff80000), + [21]string{"0xda","0x1c","0xfa","0x88","0x67","0x70","0x8b","0xf7","0x03","0x1b","0x66","0x13","0x62","0xdd","0x6d","0xeb","0xad","0xfa","0xf2","0x5b","0x00"} }, + { + /* No.269 delta:1697 weight:1573 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x4d9d43f2,0xaef042ac,0xe36d015e,0xed2010d6,0xa0bd5324,0x43d0527a,0x0e4d1188,0x0000ade0,0x4d9dee12,0xaef0ef4c,0xe36dacbe,0xed20bd36,0xa0bdfec4,0x43d0ff9a,0x0e4dbc68}, + [16]uint32{0x00000000,0x4b91e1dd,0x0d05a42b,0x469445f6,0x0100484c,0x4a91a991,0x0c05ec67,0x47940dba,0x0463801f,0x4ff261c2,0x09662434,0x42f7c5e9,0x0563c853,0x4ef2298e,0x08666c78,0x43f78da5}, + [16]uint32{0x3f800000,0x3fa5c8f0,0x3f8682d2,0x3fa34a22,0x3f808024,0x3fa548d4,0x3f8602f6,0x3fa3ca06,0x3f8231c0,0x3fa7f930,0x3f84b312,0x3fa17be2,0x3f82b1e4,0x3fa77914,0x3f843336,0x3fa1fbc6}, + uint32(0xfff80000), + [21]string{"0x5c","0xd8","0x63","0xbe","0xba","0x24","0x1c","0x39","0x86","0xd4","0x6a","0xa6","0x66","0x0d","0x5c","0x89","0x96","0x7c","0x26","0x0d","0x00"} }, + { + /* No.270 delta:756 weight:1637 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0xabb61e82,0xc736718e,0x6c806f0c,0x094010e1,0xa2f60e63,0xce76616f,0x65c07fed,0x000015ec,0xabb60b6e,0xc7366462,0x6c807ae0,0x0940050d,0xa2f61b8f,0xce767483,0x65c06a01}, + [16]uint32{0x00000000,0x112e80f6,0x0045b007,0x116b30f1,0x00020c18,0x112c8cee,0x0047bc1f,0x11693ce9,0x1000580c,0x012ed8fa,0x1045e80b,0x016b68fd,0x10025414,0x012cd4e2,0x1047e413,0x016964e5}, + [16]uint32{0x3f800000,0x3f889740,0x3f8022d8,0x3f88b598,0x3f800106,0x3f889646,0x3f8023de,0x3f88b49e,0x3f88002c,0x3f80976c,0x3f8822f4,0x3f80b5b4,0x3f88012a,0x3f80966a,0x3f8823f2,0x3f80b4b2}, + uint32(0xfff80000), + [21]string{"0xd0","0xe9","0x18","0x44","0xaf","0x9f","0x2f","0x8a","0xd3","0xb5","0x95","0x44","0xbb","0x80","0x3d","0x72","0xbd","0x1e","0x62","0xad","0x00"} }, + { + /* No.271 delta:1600 weight:1575 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x70c8924a,0x9c076e90,0xeccffcda,0x5f0010fa,0x2fc882b0,0xc3077e6a,0xb3cfec20,0x00008d22,0x70c81f68,0x9c07e3b2,0xeccf71f8,0x5f009dd8,0x2fc80f92,0xc307f348,0xb3cf6102}, + [16]uint32{0x00000000,0x007c00bd,0x2004008e,0x20780033,0x00020017,0x007e00aa,0x20060099,0x207a0024,0x004001cc,0x003c0171,0x20440142,0x203801ff,0x004201db,0x003e0166,0x20460155,0x203a01e8}, + [16]uint32{0x3f800000,0x3f803e00,0x3f900200,0x3f903c00,0x3f800100,0x3f803f00,0x3f900300,0x3f903d00,0x3f802000,0x3f801e00,0x3f902200,0x3f901c00,0x3f802100,0x3f801f00,0x3f902300,0x3f901d00}, + uint32(0xfff80000), + [21]string{"0xe4","0x54","0xe8","0xd1","0xa5","0xea","0x2d","0x86","0x55","0xac","0x70","0xd0","0x6d","0x7c","0x84","0xc1","0xdb","0xbe","0x53","0x9a","0x00"} }, + { + /* No.272 delta:728 weight:1065 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xc21c2ebb,0xf24cb725,0x3050999e,0xd1a0110a,0x13bc3fb1,0x23eca62f,0xe1f08894,0x00005f5d,0xc21c71e6,0xf24ce878,0x3050c6c3,0xd1a04e57,0x13bc60ec,0x23ecf972,0xe1f0d7c9}, + [16]uint32{0x00000000,0x784401f7,0x18008c1d,0x60448dea,0x10444818,0x680049ef,0x0844c405,0x7000c5f2,0x200ba06b,0x584fa19c,0x380b2c76,0x404f2d81,0x304fe873,0x480be984,0x284f646e,0x500b6599}, + [16]uint32{0x3f800000,0x3fbc2200,0x3f8c0046,0x3fb02246,0x3f882224,0x3fb40024,0x3f842262,0x3fb80062,0x3f9005d0,0x3fac27d0,0x3f9c0596,0x3fa02796,0x3f9827f4,0x3fa405f4,0x3f9427b2,0x3fa805b2}, + uint32(0xfff80000), + [21]string{"0xdd","0x63","0xa5","0x3a","0x9a","0x9b","0x18","0xeb","0xf0","0x0c","0x73","0x50","0xb9","0x71","0x9e","0x6e","0x27","0x9e","0x31","0x4a","0x00"} }, + { + /* No.273 delta:1358 weight:1725 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0xda0ac527,0x6467f2c3,0xbe6d37e4,0xce701116,0x147ad431,0xaa17e3d5,0x701d26f2,0x0000b1f7,0xda0a74d0,0x64674334,0xbe6d8613,0xce70a0e1,0x147a65c6,0xaa175222,0x701d9705}, + [16]uint32{0x00000000,0x01746c56,0x005ac03c,0x012eac6a,0x50580017,0x512c6c41,0x5002c02b,0x5176ac7d,0x002c8c18,0x0158e04e,0x00764c24,0x01022072,0x50748c0f,0x5100e059,0x502e4c33,0x515a2065}, + [16]uint32{0x3f800000,0x3f80ba36,0x3f802d60,0x3f809756,0x3fa82c00,0x3fa89636,0x3fa80160,0x3fa8bb56,0x3f801646,0x3f80ac70,0x3f803b26,0x3f808110,0x3fa83a46,0x3fa88070,0x3fa81726,0x3fa8ad10}, + uint32(0xfff80000), + [21]string{"0x44","0x41","0xba","0xab","0xdc","0xf8","0xf7","0xcd","0x33","0x44","0x35","0xe2","0x3b","0xc0","0x47","0x81","0x9e","0x05","0x22","0xd7","0x00"} }, + { + /* No.274 delta:1122 weight:787 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0xce9bde90,0x699bdce0,0xa7000270,0xa0801120,0x6e1bcfb0,0xc91bcdc0,0x07801350,0x00009101,0xce9b4f91,0x699b4de1,0xa7009371,0xa0808021,0x6e1b5eb1,0xc91b5cc1,0x07808251}, + [16]uint32{0x00000000,0x002ca953,0x44104016,0x443ce945,0x0823099b,0x080fa0c8,0x4c33498d,0x4c1fe0de,0x0078806a,0x00542939,0x4468c07c,0x4444692f,0x085b89f1,0x087720a2,0x4c4bc9e7,0x4c6760b4}, + [16]uint32{0x3f800000,0x3f801654,0x3fa20820,0x3fa21e74,0x3f841184,0x3f8407d0,0x3fa619a4,0x3fa60ff0,0x3f803c40,0x3f802a14,0x3fa23460,0x3fa22234,0x3f842dc4,0x3f843b90,0x3fa625e4,0x3fa633b0}, + uint32(0xfff80000), + [21]string{"0xf9","0x2c","0x8f","0xd2","0xf9","0x88","0x4d","0x07","0xb0","0xea","0x2d","0x5c","0xad","0xcb","0xb3","0x0d","0xd1","0x1e","0x5a","0x63","0x00"} }, + { + /* No.275 delta:950 weight:1249 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x7e6d7d4f,0x69588448,0x1735f907,0x2fd0113b,0x51bd6c74,0x46889573,0x38e5e83c,0x0000563b,0x7e6d2b74,0x6958d273,0x1735af3c,0x2fd04700,0x51bd3a4f,0x4688c348,0x38e5be07}, + [16]uint32{0x00000000,0x000678d2,0x000a29b5,0x000c5167,0x04011c18,0x040764ca,0x040b35ad,0x040d4d7f,0x6039981b,0x603fe0c9,0x6033b1ae,0x6035c97c,0x64388403,0x643efcd1,0x6432adb6,0x6434d564}, + [16]uint32{0x3f800000,0x3f80033c,0x3f800514,0x3f800628,0x3f82008e,0x3f8203b2,0x3f82059a,0x3f8206a6,0x3fb01ccc,0x3fb01ff0,0x3fb019d8,0x3fb01ae4,0x3fb21c42,0x3fb21f7e,0x3fb21956,0x3fb21a6a}, + uint32(0xfff80000), + [21]string{"0xb4","0x0a","0x68","0xbf","0x57","0xdf","0x2f","0x96","0xc5","0xfb","0xb2","0x72","0xaf","0x76","0x35","0xd9","0x37","0x35","0xff","0x40","0x00"} }, + { + /* No.276 delta:1838 weight:1567 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x8b4d8ae9,0x70653340,0xfb28b9a9,0x3e801148,0xb5cd9ba1,0x4ee52208,0xc5a8a8e1,0x00002645,0x8b4dacac,0x70651505,0xfb289fec,0x3e80370d,0xb5cdbde4,0x4ee5044d,0xc5a88ea4}, + [16]uint32{0x00000000,0x0a04137a,0x20020411,0x2a06176b,0x05041cbe,0x0f000fc4,0x250618af,0x2f020bd5,0x40c60c06,0x4ac21f7c,0x60c40817,0x6ac01b6d,0x45c210b8,0x4fc603c2,0x65c014a9,0x6fc407d3}, + [16]uint32{0x3f800000,0x3f850209,0x3f900102,0x3f95030b,0x3f82820e,0x3f878007,0x3f92830c,0x3f978105,0x3fa06306,0x3fa5610f,0x3fb06204,0x3fb5600d,0x3fa2e108,0x3fa7e301,0x3fb2e00a,0x3fb7e203}, + uint32(0xfff80000), + [21]string{"0x94","0xe1","0x7d","0x1d","0x8d","0x35","0x00","0xf2","0x61","0x59","0x41","0x7c","0x87","0x05","0xa8","0xe8","0xb7","0x2b","0xfd","0x93","0x00"} }, + { + /* No.277 delta:1254 weight:1607 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0xd0891025,0x727f3781,0xa2f627a4,0x46a0115d,0x96290178,0x34df26dc,0xe45636f9,0x00006a97,0xd0897ab2,0x727f5d16,0xa2f64d33,0x46a07bca,0x96296bef,0x34df4c4b,0xe4565c6e}, + [16]uint32{0x00000000,0x00456212,0x103acf0c,0x107fad1e,0x000328af,0x00464abd,0x1039e7a3,0x107c85b1,0x6024c4c4,0x6061a6d6,0x701e0bc8,0x705b69da,0x6027ec6b,0x60628e79,0x701d2367,0x70584175}, + [16]uint32{0x3f800000,0x3f8022b1,0x3f881d67,0x3f883fd6,0x3f800194,0x3f802325,0x3f881cf3,0x3f883e42,0x3fb01262,0x3fb030d3,0x3fb80f05,0x3fb82db4,0x3fb013f6,0x3fb03147,0x3fb80e91,0x3fb82c20}, + uint32(0xfff80000), + [21]string{"0x5b","0x30","0x99","0x8d","0xb2","0x61","0xf4","0x48","0x1b","0x40","0x8e","0xa6","0x36","0x25","0xf0","0x06","0xce","0xc1","0x2f","0xfb","0x00"} }, + { + /* No.278 delta:782 weight:1549 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0x2309b04c,0x25f485a4,0x06fd35e8,0xcc50116d,0xef59a121,0xe9a494c9,0xcaad2485,0x00003120,0x2309816c,0x25f4b484,0x06fd04c8,0xcc50204d,0xef599001,0xe9a4a5e9,0xcaad15a5}, + [16]uint32{0x00000000,0x4003f13a,0x4006199d,0x0005e8a7,0x80104014,0xc013b12e,0xc0165989,0x8015a8b3,0x000280c2,0x400171f8,0x4004995f,0x00076865,0x8012c0d6,0xc01131ec,0xc014d94b,0x80172871}, + [16]uint32{0x3f800000,0x3fa001f8,0x3fa0030c,0x3f8002f4,0x3fc00820,0x3fe009d8,0x3fe00b2c,0x3fc00ad4,0x3f800140,0x3fa000b8,0x3fa0024c,0x3f8003b4,0x3fc00960,0x3fe00898,0x3fe00a6c,0x3fc00b94}, + uint32(0xfff80000), + [21]string{"0x98","0x6c","0x92","0x22","0xba","0x4a","0x8c","0x3f","0x27","0xbc","0x64","0x8e","0x0c","0x12","0xfc","0x5d","0x2e","0xb9","0x5d","0x2d","0x00"} }, + { + /* No.279 delta:964 weight:1583 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0x64b5ae78,0xddc790e6,0xb9723e9e,0xb280117a,0xd635bf02,0x6f47819c,0x0bf22fe4,0x0000343e,0x64b59a46,0xddc7a4d8,0xb9720aa0,0xb2802544,0xd6358b3c,0x6f47b5a2,0x0bf21bda}, + [16]uint32{0x00000000,0x202c40d5,0x000214bf,0x202e546a,0x70182913,0x503469c6,0x701a3dac,0x50367d79,0x00002838,0x202c68ed,0x00023c87,0x202e7c52,0x7018012b,0x503441fe,0x701a1594,0x50365541}, + [16]uint32{0x3f800000,0x3f901620,0x3f80010a,0x3f90172a,0x3fb80c14,0x3fa81a34,0x3fb80d1e,0x3fa81b3e,0x3f800014,0x3f901634,0x3f80011e,0x3f90173e,0x3fb80c00,0x3fa81a20,0x3fb80d0a,0x3fa81b2a}, + uint32(0xfff80000), + [21]string{"0x00","0x2b","0x78","0xb7","0x08","0x0d","0x4a","0xdd","0xda","0xb1","0x47","0xe7","0x4e","0xf9","0xfd","0x3f","0xcb","0xd1","0x68","0x60","0x00"} }, + { + /* No.280 delta:891 weight:1215 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0x80f61612,0xe0421e2f,0x60b4083d,0xff601181,0x7f960793,0x1f220fae,0x9fd419bc,0x0000cd04,0x80f6db16,0xe042d32b,0x60b4c539,0xff60dc85,0x7f96ca97,0x1f22c2aa,0x9fd4d4b8}, + [16]uint32{0x00000000,0x200a8bfa,0x00021119,0x20089ae3,0x88010051,0xa80b8bab,0x88031148,0xa8099ab2,0x0803801f,0x28090be5,0x08019106,0x280b1afc,0x8002804e,0xa0080bb4,0x80009157,0xa00a1aad}, + [16]uint32{0x3f800000,0x3f900545,0x3f800108,0x3f90044d,0x3fc40080,0x3fd405c5,0x3fc40188,0x3fd404cd,0x3f8401c0,0x3f940485,0x3f8400c8,0x3f94058d,0x3fc00140,0x3fd00405,0x3fc00048,0x3fd0050d}, + uint32(0xfff80000), + [21]string{"0xe0","0x92","0x4f","0xbe","0x53","0xa9","0x47","0x7a","0x31","0x29","0xb2","0x7d","0xb5","0xd6","0x3c","0x0e","0x44","0x1c","0x2a","0x9f","0x00"} }, + { + /* No.281 delta:718 weight:1617 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xd0eacbf9,0x6f9819c7,0xbf72d23e,0x24301190,0xf4dada69,0x4ba80857,0x9b42c3ae,0x00003866,0xd0eaf39f,0x6f9821a1,0xbf72ea58,0x243029f6,0xf4dae20f,0x4ba83031,0x9b42fbc8}, + [16]uint32{0x00000000,0x30441012,0x2020d0e6,0x1064c0f4,0x0015400a,0x30515018,0x203590ec,0x107180fe,0x10063009,0x2042201b,0x3026e0ef,0x0062f0fd,0x10137003,0x20576011,0x3033a0e5,0x0077b0f7}, + [16]uint32{0x3f800000,0x3f982208,0x3f901068,0x3f883260,0x3f800aa0,0x3f9828a8,0x3f901ac8,0x3f8838c0,0x3f880318,0x3f902110,0x3f981370,0x3f803178,0x3f8809b8,0x3f902bb0,0x3f9819d0,0x3f803bd8}, + uint32(0xfff80000), + [21]string{"0x05","0x57","0xfa","0xe9","0xae","0x63","0x42","0x79","0x73","0x85","0x07","0xdd","0x6f","0xfc","0x41","0x80","0xac","0x70","0x23","0xbb","0x00"} }, + { + /* No.282 delta:753 weight:1359 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x224604fe,0x681e2258,0x4a5826a6,0x148011a3,0x36c6155d,0x7c9e33fb,0x5ed83705,0x000032ce,0x22463630,0x681e1096,0x4a581468,0x1480236d,0x36c62793,0x7c9e0135,0x5ed805cb}, + [16]uint32{0x00000000,0x0005003e,0x200081a5,0x2005819b,0x000200f4,0x000700ca,0x20028151,0x2007816f,0x3020281d,0x30252823,0x1020a9b8,0x1025a986,0x302228e9,0x302728d7,0x1022a94c,0x1027a972}, + [16]uint32{0x3f800000,0x3f800280,0x3f900040,0x3f9002c0,0x3f800100,0x3f800380,0x3f900140,0x3f9003c0,0x3f981014,0x3f981294,0x3f881054,0x3f8812d4,0x3f981114,0x3f981394,0x3f881154,0x3f8813d4}, + uint32(0xfff80000), + [21]string{"0x3f","0xd5","0xce","0x0a","0x76","0x47","0x21","0x51","0xd3","0x4e","0xaa","0xe4","0x2a","0xed","0x46","0xa5","0x91","0xd8","0x9f","0x2f","0x00"} }, + { + /* No.283 delta:947 weight:1779 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0xaec76b1f,0x658b179b,0xcb4c7c84,0xe21011b0,0x4cd77aaf,0x879b062b,0x295c6d34,0x00006807,0xaec70318,0x658b7f9c,0xcb4c1483,0xe21079b7,0x4cd712a8,0x879b6e2c,0x295c0533}, + [16]uint32{0x00000000,0x003d799a,0x4056040c,0x406b7d96,0x00021015,0x003f698f,0x40541419,0x40696d83,0x10503202,0x106d4b98,0x5006360e,0x503b4f94,0x10522217,0x106f5b8d,0x5004261b,0x50395f81}, + [16]uint32{0x3f800000,0x3f801ebc,0x3fa02b02,0x3fa035be,0x3f800108,0x3f801fb4,0x3fa02a0a,0x3fa034b6,0x3f882819,0x3f8836a5,0x3fa8031b,0x3fa81da7,0x3f882911,0x3f8837ad,0x3fa80213,0x3fa81caf}, + uint32(0xfff80000), + [21]string{"0x2b","0x0f","0xe1","0xde","0xb8","0x2e","0x98","0xe4","0x72","0xda","0x9f","0xbe","0xd4","0x7e","0x12","0x72","0x2a","0xbf","0xc0","0xbd","0x00"} }, + { + /* No.284 delta:1490 weight:1675 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x619dbdb3,0xf6a0f779,0x973d4aca,0x9f3011c2,0xfeadac71,0x6990e6bb,0x080d5b08,0x0000aa9b,0x619d1728,0xf6a05de2,0x973de051,0x9f30bb59,0xfead06ea,0x69904c20,0x080df193}, + [16]uint32{0x00000000,0x0ec1421c,0x1194a576,0x1f55e76a,0x005c0501,0x0e9d471d,0x11c8a077,0x1f09e26b,0x0106c1be,0x0fc783a2,0x109264c8,0x1e5326d4,0x015ac4bf,0x0f9b86a3,0x10ce61c9,0x1e0f23d5}, + [16]uint32{0x3f800000,0x3f8760a1,0x3f88ca52,0x3f8faaf3,0x3f802e02,0x3f874ea3,0x3f88e450,0x3f8f84f1,0x3f808360,0x3f87e3c1,0x3f884932,0x3f8f2993,0x3f80ad62,0x3f87cdc3,0x3f886730,0x3f8f0791}, + uint32(0xfff80000), + [21]string{"0x6a","0x53","0xfa","0x26","0x33","0xa8","0x93","0x37","0xfc","0x50","0xa0","0xf2","0xff","0xaf","0x75","0x8f","0xcd","0x66","0xd2","0xb9","0x00"} }, + { + /* No.285 delta:3095 weight:661 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xe7c9b0cb,0xc5282bcc,0x22e19b07,0x3c1011dc,0xdbd9a117,0xf9383a10,0x1ef18adb,0x0000e809,0xe7c958c2,0xc528c3c5,0x22e1730e,0x3c10f9d5,0xdbd9491e,0xf938d219,0x1ef162d2}, + [16]uint32{0x00000000,0x8e5e0433,0x24138167,0xaa4d8554,0xfa41240b,0x741f2038,0xde52a56c,0x500ca15f,0x4a20808e,0xc47e84bd,0x6e3301e9,0xe06d05da,0xb061a485,0x3e3fa0b6,0x947225e2,0x1a2c21d1}, + [16]uint32{0x3f800000,0x3fc72f02,0x3f9209c0,0x3fd526c2,0x3ffd2092,0x3fba0f90,0x3fef2952,0x3fa80650,0x3fa51040,0x3fe23f42,0x3fb71980,0x3ff03682,0x3fd830d2,0x3f9f1fd0,0x3fca3912,0x3f8d1610}, + uint32(0xfff80000), + [21]string{"0x85","0x07","0x92","0x11","0xb5","0x99","0xaf","0xf3","0xd4","0x48","0xd2","0x4f","0xc5","0x5e","0x14","0xe7","0xbf","0x6a","0xdc","0x72","0x00"} }, + { + /* No.286 delta:583 weight:1681 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xd114fb9b,0x52af99ff,0x83bb6264,0x63d011ed,0xb2c4ea76,0x317f8812,0xe06b7389,0x0000aee3,0xd1145578,0x52af371c,0x83bbcc87,0x63d0bf0e,0xb2c44495,0x317f26f1,0xe06bdd6a}, + [16]uint32{0x00000000,0x400308d3,0xa0016539,0xe0026dea,0x1000a99e,0x5003a14d,0xb001cca7,0xf002c474,0xc000201b,0x800328c8,0x60014522,0x20024df1,0xd0008985,0x90038156,0x7001ecbc,0x3002e46f}, + [16]uint32{0x3f800000,0x3fa00184,0x3fd000b2,0x3ff00136,0x3f880054,0x3fa801d0,0x3fd800e6,0x3ff80162,0x3fe00010,0x3fc00194,0x3fb000a2,0x3f900126,0x3fe80044,0x3fc801c0,0x3fb800f6,0x3f980172}, + uint32(0xfff80000), + [21]string{"0x59","0xc7","0x8f","0x55","0x07","0x75","0xd0","0xc9","0x26","0x6c","0x4f","0x0b","0xb9","0x98","0x3f","0xf3","0xa7","0x43","0x2b","0x28","0x00"} }, + { + /* No.287 delta:2333 weight:1651 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0xa6e6a28f,0xcea8da4b,0x684e78c4,0x7e2011f5,0xd8c6b37a,0xb088cbbe,0x166e6931,0x0000594d,0xa6e6fbc2,0xcea88306,0x684e2189,0x7e2048b8,0xd8c6ea37,0xb08892f3,0x166e307c}, + [16]uint32{0x00000000,0x000d841a,0x00000073,0x000d8469,0x01200016,0x012d840c,0x01200065,0x012d847f,0x100001a4,0x100d85be,0x100001d7,0x100d85cd,0x112001b2,0x112d85a8,0x112001c1,0x112d85db}, + [16]uint32{0x3f800000,0x3f8006c2,0x3f800000,0x3f8006c2,0x3f809000,0x3f8096c2,0x3f809000,0x3f8096c2,0x3f880000,0x3f8806c2,0x3f880000,0x3f8806c2,0x3f889000,0x3f8896c2,0x3f889000,0x3f8896c2}, + uint32(0xfff80000), + [21]string{"0x95","0x93","0x90","0x58","0x58","0xc5","0xf4","0x07","0x73","0xc9","0x6e","0x56","0x93","0x99","0x69","0x69","0x63","0x32","0xfc","0xcd","0x00"} }, + { + /* No.288 delta:904 weight:1651 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x9b7f9dd5,0xb4d1a31b,0x2fae3ece,0x30001203,0xab7f8fd6,0x84d1b118,0x1fae2ccd,0x00005429,0x9b7fc9fc,0xb4d1f732,0x2fae6ae7,0x3000462a,0xab7fdbff,0x84d1e531,0x1fae78e4}, + [16]uint32{0x00000000,0x00543bfa,0x200aa815,0x205e93ef,0xc0202419,0xc0741fe3,0xe02a8c0c,0xe07eb7f6,0x00036807,0x005753fd,0x2009c012,0x205dfbe8,0xc0234c1e,0xc07777e4,0xe029e40b,0xe07ddff1}, + [16]uint32{0x3f800000,0x3f802a1d,0x3f900554,0x3f902f49,0x3fe01012,0x3fe03a0f,0x3ff01546,0x3ff03f5b,0x3f8001b4,0x3f802ba9,0x3f9004e0,0x3f902efd,0x3fe011a6,0x3fe03bbb,0x3ff014f2,0x3ff03eef}, + uint32(0xfff80000), + [21]string{"0x4b","0x8d","0x51","0xbb","0x0f","0x66","0x85","0xe2","0xee","0x64","0xad","0xbc","0xe9","0xed","0x1c","0xf6","0xd4","0x8b","0xfc","0x06","0x00"} }, + { + /* No.289 delta:902 weight:1623 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0xf3d2ad48,0x862006c8,0x75f2ab80,0x04e0121c,0xf732bf54,0x82c014d4,0x7112b99c,0x0000c395,0xf3d26edd,0x8620c55d,0x75f26815,0x04e0d189,0xf7327cc1,0x82c0d741,0x71127a09}, + [16]uint32{0x00000000,0xe80819be,0x0046189b,0xe84e0125,0x0035f014,0xe83de9aa,0x0073e88f,0xe87bf131,0x00031910,0xe80b00ae,0x0045018b,0xe84d1835,0x0036e904,0xe83ef0ba,0x0070f19f,0xe878e821}, + [16]uint32{0x3f800000,0x3ff4040c,0x3f80230c,0x3ff42700,0x3f801af8,0x3ff41ef4,0x3f8039f4,0x3ff43df8,0x3f80018c,0x3ff40580,0x3f802280,0x3ff4268c,0x3f801b74,0x3ff41f78,0x3f803878,0x3ff43c74}, + uint32(0xfff80000), + [21]string{"0xae","0xf8","0x4a","0x6c","0xc4","0xdb","0x75","0x9f","0x35","0x59","0x15","0x31","0x28","0x48","0x4d","0x2a","0x4d","0x55","0xff","0x19","0x00"} }, + { + /* No.290 delta:944 weight:1727 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xfbcc3f05,0x04249a13,0xffe8a516,0xfec0122c,0x050c2d29,0xfae4883f,0x0128b73a,0x00009b2a,0xfbcca42f,0x04240139,0xffe83e3c,0xfec08906,0x050cb603,0xfae41315,0x01282c10}, + [16]uint32{0x00000000,0x0042281e,0x20021065,0x2040387b,0x10001707,0x10423f19,0x30020762,0x30402f7c,0x80000156,0x80422948,0xa0021133,0xa040392d,0x90001651,0x90423e4f,0xb0020634,0xb0402e2a}, + [16]uint32{0x3f800000,0x3f802114,0x3f900108,0x3f90201c,0x3f88000b,0x3f88211f,0x3f980103,0x3f982017,0x3fc00000,0x3fc02114,0x3fd00108,0x3fd0201c,0x3fc8000b,0x3fc8211f,0x3fd80103,0x3fd82017}, + uint32(0xfff80000), + [21]string{"0xd4","0xd6","0xb1","0x99","0x08","0xa8","0x90","0x00","0x71","0xcc","0xa0","0x44","0x61","0xd7","0x04","0x86","0xa4","0x9b","0xa2","0x7c","0x00"} }, + { + /* No.291 delta:1190 weight:1597 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0xf3b4ed24,0xdef22bdc,0x2d46c6f8,0x28f01237,0xdb44ff13,0xf60239eb,0x05b6d4cf,0x00008792,0xf3b46ab6,0xdef2ac4e,0x2d46416a,0x28f095a5,0xdb447881,0xf602be79,0x05b6535d}, + [16]uint32{0x00000000,0x344c0816,0x00402d67,0x340c2571,0x106819d5,0x242411c3,0x102834b2,0x24643ca4,0x105d0014,0x24110802,0x101d2d73,0x24512565,0x003519c1,0x347911d7,0x007534a6,0x34393cb0}, + [16]uint32{0x3f800000,0x3f9a2604,0x3f802016,0x3f9a0612,0x3f88340c,0x3f921208,0x3f88141a,0x3f92321e,0x3f882e80,0x3f920884,0x3f880e96,0x3f922892,0x3f801a8c,0x3f9a3c88,0x3f803a9a,0x3f9a1c9e}, + uint32(0xfff80000), + [21]string{"0x80","0x71","0x1d","0x30","0x3e","0x00","0x11","0x0a","0x22","0xba","0x95","0xe8","0xd9","0xde","0x23","0x06","0xd8","0x66","0x7b","0xf1","0x00"} }, + { + /* No.292 delta:2057 weight:1297 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x76d6388e,0x0d4dedf7,0x7b9bd579,0x09d0124f,0x7f062ac1,0x049dffb8,0x724bc736,0x00004430,0x76d67cbe,0x0d4da9c7,0x7b9b9149,0x09d0567f,0x7f066ef1,0x049dbb88,0x724b8306}, + [16]uint32{0x00000000,0x30a50892,0x0e304027,0x3e9548b5,0xf1907209,0xc1357a9b,0xffa0322e,0xcf053abc,0x402243cd,0x70874b5f,0x4e1203ea,0x7eb70b78,0xb1b231c4,0x81173956,0xbf8271e3,0x8f277971}, + [16]uint32{0x3f800000,0x3f985284,0x3f871820,0x3f9f4aa4,0x3ff8c839,0x3fe09abd,0x3fffd019,0x3fe7829d,0x3fa01121,0x3fb843a5,0x3fa70901,0x3fbf5b85,0x3fd8d918,0x3fc08b9c,0x3fdfc138,0x3fc793bc}, + uint32(0xfff80000), + [21]string{"0xb8","0x0c","0x99","0x53","0x57","0x6e","0x5e","0xa5","0x36","0x91","0xa1","0xa1","0x4b","0xd9","0x7f","0xfc","0xb6","0x6e","0x0b","0xcd","0x00"} }, + { + /* No.293 delta:832 weight:693 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x14933608,0x74422a10,0x60d11c18,0x5b701258,0x4fe32450,0x2f323848,0x3ba10e40,0x00008f9e,0x1493b996,0x7442a58e,0x60d19386,0x5b709dc6,0x4fe3abce,0x2f32b7d6,0x3ba181de}, + [16]uint32{0x00000000,0x024d06f3,0x0042201c,0x020f26ef,0x6078100e,0x623516fd,0x603a3012,0x627736e1,0x201041f7,0x225d4704,0x205261eb,0x221f6718,0x406851f9,0x4225570a,0x402a71e5,0x42677716}, + [16]uint32{0x3f800000,0x3f812683,0x3f802110,0x3f810793,0x3fb03c08,0x3fb11a8b,0x3fb01d18,0x3fb13b9b,0x3f900820,0x3f912ea3,0x3f902930,0x3f910fb3,0x3fa03428,0x3fa112ab,0x3fa01538,0x3fa133bb}, + uint32(0xfff80000), + [21]string{"0x59","0x1e","0x1b","0x5c","0xdd","0x6e","0x9b","0x3c","0x61","0xef","0x52","0x51","0x06","0x7d","0x37","0x69","0xbc","0x02","0x4e","0xae","0x00"} }, + { + /* No.294 delta:1075 weight:1641 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0xd240a087,0x0d7c4b77,0xdf3cebf0,0x9200126c,0x4040b2eb,0x9f7c591b,0x4d3cf99c,0x0000e34c,0xd24043cb,0x0d7ca83b,0xdf3c08bc,0x9200f120,0x404051a7,0x9f7cba57,0x4d3c1ad0}, + [16]uint32{0x00000000,0x004054da,0x4003013f,0x404355e5,0x0167684d,0x01273c97,0x41646972,0x41243da8,0x203cb990,0x207ced4a,0x603fb8af,0x607fec75,0x215bd1dd,0x211b8507,0x6158d0e2,0x61188438}, + [16]uint32{0x3f800000,0x3f80202a,0x3fa00180,0x3fa021aa,0x3f80b3b4,0x3f80939e,0x3fa0b234,0x3fa0921e,0x3f901e5c,0x3f903e76,0x3fb01fdc,0x3fb03ff6,0x3f90ade8,0x3f908dc2,0x3fb0ac68,0x3fb08c42}, + uint32(0xfff80000), + [21]string{"0xc0","0xfa","0x1f","0x55","0x3f","0xba","0x1f","0x2b","0xbe","0x72","0x99","0x33","0x7d","0x40","0xd0","0x51","0x33","0x34","0x9c","0xf4","0x00"} }, + { + /* No.295 delta:1186 weight:1657 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0xc7df60ac,0x6a1ad971,0xadc5b9dd,0x76c01270,0xb11f72dc,0x1cdacb01,0xdb05abad,0x000085a7,0xc7dfe50b,0x6a1a5cd6,0xadc53c7a,0x76c097d7,0xb11ff77b,0x1cda4ea6,0xdb052e0a}, + [16]uint32{0x00000000,0x00055956,0x00027175,0x00072823,0x3078c818,0x307d914e,0x307ab96d,0x307fe03b,0x0040001d,0x0045594b,0x00427168,0x0047283e,0x3038c805,0x303d9153,0x303ab970,0x303fe026}, + [16]uint32{0x3f800000,0x3f8002ac,0x3f800138,0x3f800394,0x3f983c64,0x3f983ec8,0x3f983d5c,0x3f983ff0,0x3f802000,0x3f8022ac,0x3f802138,0x3f802394,0x3f981c64,0x3f981ec8,0x3f981d5c,0x3f981ff0}, + uint32(0xfff80000), + [21]string{"0xd3","0xe7","0x86","0x9b","0xe3","0x0a","0x21","0x7d","0x7d","0x27","0x36","0x03","0x1d","0x93","0xef","0xe6","0x00","0x1e","0xd7","0xd0","0x00"} }, + { + /* No.296 delta:1412 weight:1597 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0x23b04c56,0x4d815b5f,0x6e311709,0x40f0128b,0x63405edd,0x0d7149d4,0x2ec10582,0x00002283,0x23b06ed5,0x4d8179dc,0x6e31358a,0x40f03008,0x63407c5e,0x0d716b57,0x2ec12701}, + [16]uint32{0x00000000,0x5084d83e,0x007c401c,0x50f89822,0x40030dba,0x1087d584,0x407f4da6,0x10fb9598,0x40004919,0x10849127,0x407c0905,0x10f8d13b,0x000344a3,0x50879c9d,0x007f04bf,0x50fbdc81}, + [16]uint32{0x3f800000,0x3fa8426c,0x3f803e20,0x3fa87c4c,0x3fa00186,0x3f8843ea,0x3fa03fa6,0x3f887dca,0x3fa00024,0x3f884248,0x3fa03e04,0x3f887c68,0x3f8001a2,0x3fa843ce,0x3f803f82,0x3fa87dee}, + uint32(0xfff80000), + [21]string{"0x92","0x7d","0x94","0x21","0x4b","0x3a","0x32","0x48","0xf6","0x7a","0x9a","0xec","0xd7","0xb6","0x56","0xfc","0xc9","0x34","0x67","0xb1","0x00"} }, + { + /* No.297 delta:763 weight:1457 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xb7a54f1e,0xa71f8dd6,0x10bac2c8,0x1ba01298,0xac055d86,0xbcbf9f4e,0x0b1ad050,0x0000142d,0xb7a55b33,0xa71f99fb,0x10bad6e5,0x1ba006b5,0xac0549ab,0xbcbf8b63,0x0b1ac47d}, + [16]uint32{0x00000000,0x58680016,0x20711899,0x7819188f,0x105cce7c,0x4834ce6a,0x302dd6e5,0x6845d6f3,0x006a187a,0x5802186c,0x201b00e3,0x787300f5,0x1036d606,0x485ed610,0x3047ce9f,0x682fce89}, + [16]uint32{0x3f800000,0x3fac3400,0x3f90388c,0x3fbc0c8c,0x3f882e67,0x3fa41a67,0x3f9816eb,0x3fb422eb,0x3f80350c,0x3fac010c,0x3f900d80,0x3fbc3980,0x3f881b6b,0x3fa42f6b,0x3f9823e7,0x3fb417e7}, + uint32(0xfff80000), + [21]string{"0x93","0xe2","0xc7","0x95","0xfa","0x46","0xe7","0xb4","0x33","0x62","0xbc","0x1b","0xa4","0x2a","0x04","0x02","0x8b","0xdd","0x23","0x94","0x00"} }, + { + /* No.298 delta:967 weight:1527 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0xb982e373,0xc724b811,0x7ea65b62,0x87c012ac,0x3e42f1df,0x40e4aabd,0xf96649ce,0x00003985,0xb982daf6,0xc7248194,0x7ea662e7,0x87c02b29,0x3e42c85a,0x40e49338,0xf966704b}, + [16]uint32{0x00000000,0x0842bb3a,0x1002e6c3,0x18405df9,0x0000409e,0x0842fba4,0x1002a65d,0x18401d67,0x2001801b,0x28433b21,0x300366d8,0x3841dde2,0x2001c085,0x28437bbf,0x30032646,0x38419d7c}, + [16]uint32{0x3f800000,0x3f84215d,0x3f880173,0x3f8c202e,0x3f800020,0x3f84217d,0x3f880153,0x3f8c200e,0x3f9000c0,0x3f94219d,0x3f9801b3,0x3f9c20ee,0x3f9000e0,0x3f9421bd,0x3f980193,0x3f9c20ce}, + uint32(0xfff80000), + [21]string{"0x83","0x91","0x32","0xcf","0x3d","0x1d","0x50","0x21","0x0f","0x8f","0x38","0x19","0x7c","0x4a","0x0d","0xb5","0xfd","0x7d","0x82","0xf3","0x00"} }, + { + /* No.299 delta:962 weight:1567 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0xc27cca59,0x4c189d3f,0x8e645766,0x150012be,0xd77cd8e7,0x59188f81,0x9b6445d8,0x0000c223,0xc27c087a,0x4c185f1c,0x8e649545,0x1500d09d,0xd77c1ac4,0x59184da2,0x9b6487fb}, + [16]uint32{0x00000000,0x302f041e,0x30402c73,0x006f286d,0x00020df6,0x302d09e8,0x30422185,0x006d259b,0x103d240c,0x20122012,0x207d087f,0x10520c61,0x103f29fa,0x20102de4,0x207f0589,0x10500197}, + [16]uint32{0x3f800000,0x3f981782,0x3f982016,0x3f803794,0x3f800106,0x3f981684,0x3f982110,0x3f803692,0x3f881e92,0x3f900910,0x3f903e84,0x3f882906,0x3f881f94,0x3f900816,0x3f903f82,0x3f882800}, + uint32(0xfff80000), + [21]string{"0x47","0xce","0x43","0x26","0xfa","0xae","0x02","0x83","0x8f","0x1b","0x8f","0x36","0xea","0x52","0x53","0x47","0x2a","0x67","0xd8","0x6a","0x00"} }, + { + /* No.300 delta:1760 weight:1591 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x3f026d07,0x19579ecc,0x2655f3cb,0xacd012c9,0x93d27fce,0xb5878c05,0x8a85e102,0x0000ef47,0x3f028240,0x1957718b,0x26551c8c,0xacd0fd8e,0x93d29089,0xb5876342,0x8a850e45}, + [16]uint32{0x00000000,0x2069c1ba,0x401c61ee,0x6075a054,0x000a0195,0x2063c02f,0x4016607b,0x607fa1c1,0x60010186,0x4068c03c,0x201d6068,0x0074a1d2,0x600b0013,0x4062c1a9,0x201761fd,0x007ea047}, + [16]uint32{0x3f800000,0x3f9034e0,0x3fa00e30,0x3fb03ad0,0x3f800500,0x3f9031e0,0x3fa00b30,0x3fb03fd0,0x3fb00080,0x3fa03460,0x3f900eb0,0x3f803a50,0x3fb00580,0x3fa03160,0x3f900bb0,0x3f803f50}, + uint32(0xfff80000), + [21]string{"0x1d","0x00","0x02","0x17","0x1b","0x97","0xf7","0x0a","0xa3","0xe8","0x85","0x28","0x9a","0x23","0xda","0xb4","0x36","0x75","0x8e","0x11","0x00"} }, + { + /* No.301 delta:1047 weight:1545 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0xd43bf17f,0xe7f5581a,0x33cea965,0x2c1012d5,0xf82be3aa,0xcbe54acf,0x1fdebbb0,0x00006475,0xd43b950a,0xe7f53c6f,0x33cecd10,0x2c1076a0,0xf82b87df,0xcbe52eba,0x1fdedfc5}, + [16]uint32{0x00000000,0x457f8936,0x04112862,0x416ea154,0x000241db,0x457dc8ed,0x041369b9,0x416ce08f,0x0003e112,0x457c6824,0x0412c970,0x416d4046,0x0001a0c9,0x457e29ff,0x041088ab,0x416f019d}, + [16]uint32{0x3f800000,0x3fa2bfc4,0x3f820894,0x3fa0b750,0x3f800120,0x3fa2bee4,0x3f8209b4,0x3fa0b670,0x3f8001f0,0x3fa2be34,0x3f820964,0x3fa0b6a0,0x3f8000d0,0x3fa2bf14,0x3f820844,0x3fa0b780}, + uint32(0xfff80000), + [21]string{"0x75","0x8c","0xb1","0x8e","0x7c","0x9b","0xdd","0xca","0xc7","0x29","0xc4","0xe2","0x01","0x90","0x5c","0x6b","0xbf","0x62","0xa1","0xc0","0x00"} }, + { + /* No.302 delta:890 weight:1167 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0x018e6586,0x580ecd60,0x5980a8e6,0xc71012e8,0xc69e776e,0x9f1edf88,0x9e90ba0e,0x0000d017,0x018eb591,0x580e1d77,0x598078f1,0xc710c2ff,0xc69ea779,0x9f1e0f9f,0x9e906a19}, + [16]uint32{0x00000000,0x004729d5,0x00011011,0x004639c4,0x8202309a,0x8245194f,0x8203208b,0x8244095e,0x50020409,0x50452ddc,0x50031418,0x50443dcd,0xd2003493,0xd2471d46,0xd2012482,0xd2460d57}, + [16]uint32{0x3f800000,0x3f802394,0x3f800088,0x3f80231c,0x3fc10118,0x3fc1228c,0x3fc10190,0x3fc12204,0x3fa80102,0x3fa82296,0x3fa8018a,0x3fa8221e,0x3fe9001a,0x3fe9238e,0x3fe90092,0x3fe92306}, + uint32(0xfff80000), + [21]string{"0x0c","0x95","0xf2","0x1f","0x1c","0x57","0x62","0x5a","0xbe","0xa0","0x3b","0xf3","0xa3","0xd9","0xb9","0x39","0x25","0x5a","0x07","0x95","0x00"} }, + { + /* No.303 delta:1427 weight:1213 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x1456d307,0x08679ffe,0x1c314cf9,0xfe0012fd,0xea56c1fa,0xf6678d03,0xe2315e04,0x0000b8b5,0x14566bb2,0x0867274b,0x1c31f44c,0xfe00aa48,0xea56794f,0xf66735b6,0xe231e6b1}, + [16]uint32{0x00000000,0x204c0072,0x203001b1,0x007c01c3,0x0003008d,0x204f00ff,0x2033013c,0x007f014e,0x00120018,0x205e006a,0x202201a9,0x006e01db,0x00110095,0x205d00e7,0x20210124,0x006d0156}, + [16]uint32{0x3f800000,0x3f902600,0x3f901800,0x3f803e00,0x3f800180,0x3f902780,0x3f901980,0x3f803f80,0x3f800900,0x3f902f00,0x3f901100,0x3f803700,0x3f800880,0x3f902e80,0x3f901080,0x3f803680}, + uint32(0xfff80000), + [21]string{"0x9c","0xbd","0x22","0x1a","0xd8","0x36","0xbc","0xc1","0x67","0x4b","0xed","0xae","0x29","0x91","0x71","0xed","0x8c","0xc3","0xf2","0x02","0x00"} }, + { + /* No.304 delta:1858 weight:1583 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x2e925e9d,0x11274489,0x3fb51a14,0x7250130c,0x5cc24d91,0x63775785,0x4de50918,0x00000a61,0x2e9254fc,0x11274ee8,0x3fb51075,0x7250196d,0x5cc247f0,0x63775de4,0x4de50379}, + [16]uint32{0x00000000,0x088d213e,0x1642c1bd,0x1ecfe083,0x0441f115,0x0cccd02b,0x120330a8,0x1a8e1196,0x084aa014,0x00c7812a,0x1e0861a9,0x16854097,0x0c0b5101,0x0486703f,0x1a4990bc,0x12c4b182}, + [16]uint32{0x3f800000,0x3f844690,0x3f8b2160,0x3f8f67f0,0x3f8220f8,0x3f866668,0x3f890198,0x3f8d4708,0x3f842550,0x3f8063c0,0x3f8f0430,0x3f8b42a0,0x3f8605a8,0x3f824338,0x3f8d24c8,0x3f896258}, + uint32(0xfff80000), + [21]string{"0xc8","0xb0","0x37","0xab","0x1e","0x72","0x05","0x42","0xc1","0xa1","0xea","0xa1","0x70","0x0c","0x00","0x43","0x64","0x93","0x35","0xbb","0x00"} }, + { + /* No.305 delta:802 weight:1487 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0xcbc49a4f,0xeb3fc8c9,0x20fb5286,0x89b0131b,0x42748954,0x628fdbd2,0xa94b419d,0x0000db70,0xcbc4413f,0xeb3f13b9,0x20fb89f6,0x89b0c86b,0x42745224,0x628f00a2,0xa94b9aed}, + [16]uint32{0x00000000,0x4c3e591a,0x4401a331,0x083ffa2b,0x10024e57,0x5c3c174d,0x5403ed66,0x183db47c,0x10011203,0x5c3f4b19,0x5400b132,0x183ee828,0x00035c54,0x4c3d054e,0x4402ff65,0x083ca67f}, + [16]uint32{0x3f800000,0x3fa61f2c,0x3fa200d1,0x3f841ffd,0x3f880127,0x3fae1e0b,0x3faa01f6,0x3f8c1eda,0x3f880089,0x3fae1fa5,0x3faa0058,0x3f8c1f74,0x3f8001ae,0x3fa61e82,0x3fa2017f,0x3f841e53}, + uint32(0xfff80000), + [21]string{"0x8a","0xf2","0x95","0xa2","0x6a","0xf2","0xd1","0x1e","0x6e","0xce","0x7a","0x6c","0x06","0xd0","0x5a","0x97","0x8f","0xfc","0x55","0x9b","0x00"} }, + { + /* No.306 delta:2270 weight:1221 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x0ffdf430,0x9805d495,0x97f820a5,0x34d01329,0x3b2de719,0xacd5c7bc,0xa328338c,0x0000cf90,0x0ffd3ba0,0x98051b05,0x97f8ef35,0x34d0dcb9,0x3b2d2889,0xacd5082c,0xa328fc1c}, + [16]uint32{0x00000000,0x38481ade,0x0a0007ed,0x32481d33,0x10216f15,0x286975cb,0x1a2168f8,0x22697226,0x7048ac12,0x4800b6cc,0x7a48abff,0x4200b121,0x6069c307,0x5821d9d9,0x6a69c4ea,0x5221de34}, + [16]uint32{0x3f800000,0x3f9c240d,0x3f850003,0x3f99240e,0x3f8810b7,0x3f9434ba,0x3f8d10b4,0x3f9134b9,0x3fb82456,0x3fa4005b,0x3fbd2455,0x3fa10058,0x3fb034e1,0x3fac10ec,0x3fb534e2,0x3fa910ef}, + uint32(0xfff80000), + [21]string{"0xa3","0x6a","0xa6","0x01","0x38","0x7b","0xcc","0x4b","0xb3","0x80","0x46","0xcb","0x97","0x62","0xc4","0x0b","0x6d","0x5b","0x89","0x37","0x00"} }, + { + /* No.307 delta:795 weight:1601 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0x9c198fc0,0x58693458,0xc470bb98,0x23d01337,0xbfc99cf7,0x7bb9276f,0xe7a0a8af,0x0000bc9d,0x9c19335d,0x586988c5,0xc4700705,0x23d0afaa,0xbfc9206a,0x7bb99bf2,0xe7a01432}, + [16]uint32{0x00000000,0x0435a092,0x80702809,0x8445889b,0x0020a816,0x04150884,0x8050801f,0x8465208d,0x0042900e,0x0477309c,0x8032b807,0x84071895,0x00623818,0x0457988a,0x80121011,0x8427b083}, + [16]uint32{0x3f800000,0x3f821ad0,0x3fc03814,0x3fc222c4,0x3f801054,0x3f820a84,0x3fc02840,0x3fc23290,0x3f802148,0x3f823b98,0x3fc0195c,0x3fc2038c,0x3f80311c,0x3f822bcc,0x3fc00908,0x3fc213d8}, + uint32(0xfff80000), + [21]string{"0x19","0xa6","0x69","0x4d","0x2e","0x6e","0xce","0x8b","0xca","0x9f","0xd0","0x79","0xfd","0xc0","0xfd","0x13","0xdc","0xec","0xe8","0x20","0x00"} }, + { + /* No.308 delta:590 weight:1743 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x8227645c,0x754c4fdb,0xf76b2b87,0xf780134e,0x75a77712,0x82cc5c95,0x00eb38c9,0x00005db0,0x822739ec,0x754c126b,0xf76b7637,0xf7804efe,0x75a72aa2,0x82cc0125,0x00eb6579}, + [16]uint32{0x00000000,0x7002a21b,0xa0000416,0xd002a60d,0x40018172,0x30032369,0xe0018564,0x9003277f,0x0002101a,0x7000b201,0xa002140c,0xd000b617,0x40039168,0x30013373,0xe003957e,0x90013765}, + [16]uint32{0x3f800000,0x3fb80151,0x3fd00002,0x3fe80153,0x3fa000c0,0x3f980191,0x3ff000c2,0x3fc80193,0x3f800108,0x3fb80059,0x3fd0010a,0x3fe8005b,0x3fa001c8,0x3f980099,0x3ff001ca,0x3fc8009b}, + uint32(0xfff80000), + [21]string{"0x24","0xbe","0xf6","0x8b","0xa2","0x9e","0xd6","0x87","0x4b","0xbe","0x7d","0xa5","0x0d","0xe7","0x79","0x1e","0x9a","0x6b","0xbf","0x73","0x00"} }, + { + /* No.309 delta:873 weight:1579 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x8b01278d,0x28979c3d,0xa396bbb0,0x4b50135d,0xc05134d0,0x63c78f60,0xe8c6a8ed,0x0000d66c,0x8b01f1e1,0x28974a51,0xa3966ddc,0x4b50c531,0xc051e2bc,0x63c7590c,0xe8c67e81}, + [16]uint32{0x00000000,0x0143e0fa,0xd0000415,0xd143e4ef,0xc000380b,0xc143d8f1,0x10003c1e,0x1143dce4,0x40000318,0x4143e3e2,0x9000070d,0x9143e7f7,0x80003b13,0x8143dbe9,0x50003f06,0x5143dffc}, + [16]uint32{0x3f800000,0x3f80a1f0,0x3fe80002,0x3fe8a1f2,0x3fe0001c,0x3fe0a1ec,0x3f88001e,0x3f88a1ee,0x3fa00001,0x3fa0a1f1,0x3fc80003,0x3fc8a1f3,0x3fc0001d,0x3fc0a1ed,0x3fa8001f,0x3fa8a1ef}, + uint32(0xfff80000), + [21]string{"0x22","0x31","0x98","0x10","0x8a","0x36","0x12","0xd8","0x2b","0xf9","0xfb","0x86","0x15","0x7b","0x39","0xa3","0x4b","0x3a","0xd6","0x6e","0x00"} }, + { + /* No.310 delta:869 weight:999 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0xe34e1c12,0x209c21dc,0xc3d23dce,0x2d101365,0xce5e0f77,0x0d8c32b9,0xeec22eab,0x00000660,0xe34e1a72,0x209c27bc,0xc3d23bae,0x2d101505,0xce5e0917,0x0d8c34d9,0xeec228cb}, + [16]uint32{0x00000000,0x3043083d,0x2002a91a,0x1041a127,0x1002fc16,0x2041f42b,0x3000550c,0x00435d31,0x50002014,0x60432829,0x7002890e,0x40418133,0x4002dc02,0x7041d43f,0x60007518,0x50437d25}, + [16]uint32{0x3f800000,0x3f982184,0x3f900154,0x3f8820d0,0x3f88017e,0x3f9020fa,0x3f98002a,0x3f8021ae,0x3fa80010,0x3fb02194,0x3fb80144,0x3fa020c0,0x3fa0016e,0x3fb820ea,0x3fb0003a,0x3fa821be}, + uint32(0xfff80000), + [21]string{"0x62","0x66","0x00","0x51","0x21","0xb0","0x79","0x50","0xd5","0x85","0x99","0x1a","0x20","0x58","0xb6","0xa2","0x13","0x7a","0x09","0x2a","0x00"} }, + { + /* No.311 delta:725 weight:1501 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x478a7f0d,0x8ad13ad0,0xcd5b45dd,0xb810137b,0xff9a6c76,0x32c129ab,0x754b56a6,0x0000d27e,0x478aad73,0x8ad1e8ae,0xcd5b97a3,0xb810c105,0xff9abe08,0x32c1fbd5,0x754b84d8}, + [16]uint32{0x00000000,0x380203d3,0x100021fc,0x2802222f,0x82010d5b,0xba030e88,0x92012ca7,0xaa032f74,0x80002142,0xb8022291,0x900000be,0xa802036d,0x02012c19,0x3a032fca,0x12010de5,0x2a030e36}, + [16]uint32{0x3f800000,0x3f9c0101,0x3f880010,0x3f940111,0x3fc10086,0x3fdd0187,0x3fc90096,0x3fd50197,0x3fc00010,0x3fdc0111,0x3fc80000,0x3fd40101,0x3f810096,0x3f9d0197,0x3f890086,0x3f950187}, + uint32(0xfff80000), + [21]string{"0x98","0x56","0x66","0xc5","0x07","0xed","0x45","0x13","0x3f","0x85","0xa8","0x5e","0xd3","0x70","0xc4","0x18","0x48","0x6d","0x62","0x63","0x00"} }, + { + /* No.312 delta:1534 weight:1411 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x00b4ab14,0xb562a900,0xb5d60214,0xa1301388,0xa184b89c,0x1452ba88,0x14e6119c,0x00008fd9,0x00b424cd,0xb56226d9,0xb5d68dcd,0xa1309c51,0xa1843745,0x14523551,0x14e69e45}, + [16]uint32{0x00000000,0x042b017a,0x800a25e6,0x8421249c,0x106411fd,0x144f1087,0x906e341b,0x94453561,0x20026016,0x2429616c,0xa00845f0,0xa423448a,0x306671eb,0x344d7091,0xb06c540d,0xb4475577}, + [16]uint32{0x3f800000,0x3f821580,0x3fc00512,0x3fc21092,0x3f883208,0x3f8a2788,0x3fc8371a,0x3fca229a,0x3f900130,0x3f9214b0,0x3fd00422,0x3fd211a2,0x3f983338,0x3f9a26b8,0x3fd8362a,0x3fda23aa}, + uint32(0xfff80000), + [21]string{"0x0e","0x08","0x24","0x45","0x72","0x8c","0xef","0x0b","0x3a","0xbe","0xef","0xf3","0x47","0x01","0x4b","0x04","0xd2","0x27","0x27","0x7e","0x00"} }, + { + /* No.313 delta:837 weight:1555 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x6d665276,0x652e079c,0x084855ea,0x16101395,0x7b7641e3,0x733e1409,0x1e58467f,0x0000074a,0x6d66553c,0x652e00d6,0x084852a0,0x161014df,0x7b7646a9,0x733e1343,0x1e584135}, + [16]uint32{0x00000000,0x100468b6,0x20025c95,0x30063423,0x00019019,0x1005f8af,0x2003cc8c,0x3007a43a,0x6000240e,0x70044cb8,0x4002789b,0x5006102d,0x6001b417,0x7005dca1,0x4003e882,0x50078034}, + [16]uint32{0x3f800000,0x3f880234,0x3f90012e,0x3f98031a,0x3f8000c8,0x3f8802fc,0x3f9001e6,0x3f9803d2,0x3fb00012,0x3fb80226,0x3fa0013c,0x3fa80308,0x3fb000da,0x3fb802ee,0x3fa001f4,0x3fa803c0}, + uint32(0xfff80000), + [21]string{"0x05","0xb8","0xd1","0xe6","0xec","0x01","0xf4","0x0b","0x19","0x45","0xe7","0x27","0x9f","0xa7","0x63","0x05","0x6b","0xe9","0xe5","0x36","0x00"} }, + { + /* No.314 delta:897 weight:983 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x16dc0e50,0xe4c764a4,0xf21b6af4,0x8a9013a9,0x9c4c1df9,0x6e57770d,0x788b795d,0x00006fcc,0x16dc619c,0xe4c70b68,0xf21b0538,0x8a907c65,0x9c4c7235,0x6e5718c1,0x788b1691}, + [16]uint32{0x00000000,0x50000057,0x69110819,0x3911084e,0x4003b013,0x1003b044,0x2912b80a,0x7912b85d,0x400040f8,0x100040af,0x291148e1,0x791148b6,0x0003f0eb,0x5003f0bc,0x6912f8f2,0x3912f8a5}, + [16]uint32{0x3f800000,0x3fa80000,0x3fb48884,0x3f9c8884,0x3fa001d8,0x3f8801d8,0x3f94895c,0x3fbc895c,0x3fa00020,0x3f880020,0x3f9488a4,0x3fbc88a4,0x3f8001f8,0x3fa801f8,0x3fb4897c,0x3f9c897c}, + uint32(0xfff80000), + [21]string{"0xd9","0x1b","0x73","0x16","0x98","0x53","0x60","0xca","0xdb","0x7d","0xfd","0x3e","0x0f","0x70","0x73","0x9f","0xa5","0x47","0x51","0x7b","0x00"} }, + { + /* No.315 delta:769 weight:1561 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0x4728414d,0x255cb3ed,0x6274f2a0,0x23b013b0,0x649852fd,0x06eca05d,0x41c4e110,0x00008881,0x4728c9cc,0x255c3b6c,0x62747a21,0x23b09b31,0x6498da7c,0x06ec28dc,0x41c46991}, + [16]uint32{0x00000000,0x00168d1f,0x000aef0b,0x001c6214,0x400360f3,0x4015edec,0x40098ff8,0x401f02e7,0x20142006,0x2002ad19,0x201ecf0d,0x20084212,0x601740f5,0x6001cdea,0x601daffe,0x600b22e1}, + [16]uint32{0x3f800000,0x3f800b46,0x3f800577,0x3f800e31,0x3fa001b0,0x3fa00af6,0x3fa004c7,0x3fa00f81,0x3f900a10,0x3f900156,0x3f900f67,0x3f900421,0x3fb00ba0,0x3fb000e6,0x3fb00ed7,0x3fb00591}, + uint32(0xfff80000), + [21]string{"0x71","0xed","0xd0","0xe5","0x86","0xff","0x04","0x4f","0x0d","0xc7","0x47","0x80","0xe7","0xed","0xfb","0x64","0x23","0xc3","0x09","0x9f","0x00"} }, + { + /* No.316 delta:1571 weight:1533 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x478766bf,0x9d080954,0xda8f6feb,0xa0d013c8,0xe7577577,0x3dd81a9c,0x7a5f7c23,0x0000938f,0x4787f530,0x9d089adb,0xda8ffc64,0xa0d08047,0xe757e6f8,0x3dd88913,0x7a5fefac}, + [16]uint32{0x00000000,0x103992f2,0x00530191,0x106a9363,0x41f84817,0x51c1dae5,0x41ab4986,0x5192db74,0xa0108208,0xb02910fa,0xa0438399,0xb07a116b,0xe1e8ca1f,0xf1d158ed,0xe1bbcb8e,0xf182597c}, + [16]uint32{0x3f800000,0x3f881cc9,0x3f802980,0x3f883549,0x3fa0fc24,0x3fa8e0ed,0x3fa0d5a4,0x3fa8c96d,0x3fd00841,0x3fd81488,0x3fd021c1,0x3fd83d08,0x3ff0f465,0x3ff8e8ac,0x3ff0dde5,0x3ff8c12c}, + uint32(0xfff80000), + [21]string{"0x8e","0x5b","0x93","0xaa","0xef","0xef","0x2b","0x60","0x7f","0x6f","0xbb","0x32","0x2a","0xf3","0x5c","0x7a","0x85","0x28","0x14","0xb3","0x00"} }, + { + /* No.317 delta:797 weight:987 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0xf7e1c4a2,0x1e587863,0xe9b9bcc1,0x563013df,0xa1d1d77d,0x48686bbc,0xbf89af1e,0x00001394,0xf7e1d736,0x1e586bf7,0xe9b9af55,0x5630004b,0xa1d1c4e9,0x48687828,0xbf89bc8a}, + [16]uint32{0x00000000,0x07f01055,0x4d0a1891,0x4afa08c4,0x0860c96c,0x0f90d939,0x456ad1fd,0x429ac1a8,0x90c0081f,0x9730184a,0xddca108e,0xda3a00db,0x98a0c173,0x9f50d126,0xd5aad9e2,0xd25ac9b7}, + [16]uint32{0x3f800000,0x3f83f808,0x3fa6850c,0x3fa57d04,0x3f843064,0x3f87c86c,0x3fa2b568,0x3fa14d60,0x3fc86004,0x3fcb980c,0x3feee508,0x3fed1d00,0x3fcc5060,0x3fcfa868,0x3fead56c,0x3fe92d64}, + uint32(0xfff80000), + [21]string{"0x1b","0x30","0x07","0x24","0x04","0xf5","0x67","0x3f","0x7e","0xd5","0x57","0x9b","0x73","0x1b","0xd8","0xc0","0x7a","0x2e","0xf6","0x14","0x00"} }, + { + /* No.318 delta:704 weight:1405 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0x9529c577,0xc83c7399,0x5d15b6ee,0xefb013e0,0x7a99d697,0x278c6079,0xb2a5a50e,0x0000e239,0x9529274e,0xc83c91a0,0x5d1554d7,0xefb0f1d9,0x7a9934ae,0x278c8240,0xb2a54737}, + [16]uint32{0x00000000,0xa40209b3,0x51006095,0xf5026926,0x80740887,0x24760134,0xd1746812,0x757661a1,0x0042219f,0xa440282c,0x5142410a,0xf54048b9,0x80362918,0x243420ab,0xd136498d,0x7534403e}, + [16]uint32{0x3f800000,0x3fd20104,0x3fa88030,0x3ffa8134,0x3fc03a04,0x3f923b00,0x3fe8ba34,0x3fbabb30,0x3f802110,0x3fd22014,0x3fa8a120,0x3ffaa024,0x3fc01b14,0x3f921a10,0x3fe89b24,0x3fba9a20}, + uint32(0xfff80000), + [21]string{"0xf1","0x57","0x29","0xfc","0x60","0x9e","0xd0","0x93","0x68","0x21","0x36","0x83","0xbf","0x33","0x33","0x45","0x83","0x30","0x85","0x00","0x00"} }, + { + /* No.319 delta:1947 weight:1519 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0xbad4c9df,0xc6af05e7,0x7c7bcc38,0x680013f3,0xd2d4da2c,0xaeaf1614,0x147bdfcb,0x00004bee,0xbad48231,0xc6af4e09,0x7c7b87d6,0x6800581d,0xd2d491c2,0xaeaf5dfa,0x147b9425}, + [16]uint32{0x00000000,0x0e4422ba,0x40802d79,0x4ec40fc3,0x0184080e,0x0fc02ab4,0x41042577,0x4f4007cd,0x0941ea0b,0x0705c8b1,0x49c1c772,0x4785e5c8,0x08c5e205,0x0681c0bf,0x4845cf7c,0x4601edc6}, + [16]uint32{0x3f800000,0x3f872211,0x3fa04016,0x3fa76207,0x3f80c204,0x3f87e015,0x3fa08212,0x3fa7a003,0x3f84a0f5,0x3f8382e4,0x3fa4e0e3,0x3fa3c2f2,0x3f8462f1,0x3f8340e0,0x3fa422e7,0x3fa300f6}, + uint32(0xfff80000), + [21]string{"0x58","0xb2","0xf4","0xf5","0xd7","0x57","0x9e","0x1c","0x57","0x25","0xfa","0xee","0x3f","0x39","0x72","0x4c","0x05","0x26","0x40","0x8e","0x00"} }, + { + /* No.320 delta:1343 weight:1707 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x95687d9e,0xe12eee39,0x744693a7,0x00f01403,0x9598699d,0xe1defa3a,0x74b687a4,0x00004df2,0x9568306c,0xe12ea3cb,0x7446de55,0x00f059f1,0x9598246f,0xe1deb7c8,0x74b6ca56}, + [16]uint32{0x00000000,0x00304112,0x000c8057,0x003cc145,0x0002018b,0x00324099,0x000e81dc,0x003ec0ce,0x0071015f,0x0041404d,0x007d8108,0x004dc01a,0x007300d4,0x004341c6,0x007f8083,0x004fc191}, + [16]uint32{0x3f800000,0x3f801820,0x3f800640,0x3f801e60,0x3f800100,0x3f801920,0x3f800740,0x3f801f60,0x3f803880,0x3f8020a0,0x3f803ec0,0x3f8026e0,0x3f803980,0x3f8021a0,0x3f803fc0,0x3f8027e0}, + uint32(0xfff80000), + [21]string{"0x3d","0x98","0x7f","0xba","0x4c","0x07","0x45","0x40","0x8d","0x87","0x77","0xdc","0x7b","0xd4","0xba","0x42","0x41","0xfd","0x7a","0xf3","0x00"} }, + { + /* No.321 delta:763 weight:1119 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0x9aa13a36,0x3e3a4f1f,0xa49b7529,0x0b401415,0x91e12e23,0x357a5b0a,0xafdb613c,0x000016d1,0x9aa12ce7,0x3e3a59ce,0xa49b63f8,0x0b4002c4,0x91e138f2,0x357a4ddb,0xafdb77ed}, + [16]uint32{0x00000000,0x103a1d72,0x10460014,0x007c1d66,0x0041080f,0x107b157d,0x1007081b,0x003d1569,0x0062700a,0x10586d78,0x1024701e,0x001e6d6c,0x00237805,0x10196577,0x10657811,0x005f6563}, + [16]uint32{0x3f800000,0x3f881d0e,0x3f882300,0x3f803e0e,0x3f802084,0x3f883d8a,0x3f880384,0x3f801e8a,0x3f803138,0x3f882c36,0x3f881238,0x3f800f36,0x3f8011bc,0x3f880cb2,0x3f8832bc,0x3f802fb2}, + uint32(0xfff80000), + [21]string{"0x3f","0x7f","0x60","0xab","0x7f","0x82","0x81","0x09","0xd4","0xa6","0x94","0x58","0x17","0xb3","0xc7","0x2a","0x79","0xaa","0x29","0x1e","0x00"} }, + { + /* No.322 delta:2883 weight:821 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0xe0fb1a8f,0xa6843748,0x467f2dc7,0x4b20142c,0xabdb0ea3,0xeda42364,0x0d5f39eb,0x00002dcb,0xe0fb3744,0xa6841a83,0x467f000c,0x4b2039e7,0xabdb2368,0xeda40eaf,0x0d5f1420}, + [16]uint32{0x00000000,0x1a03e997,0x0e120811,0x1411e186,0x096200d5,0x1361e942,0x077008c4,0x1d73e153,0x80020c8f,0x9a01e518,0x8e10049e,0x9413ed09,0x89600c5a,0x9363e5cd,0x8772044b,0x9d71eddc}, + [16]uint32{0x3f800000,0x3f8d01f4,0x3f870904,0x3f8a08f0,0x3f84b100,0x3f89b0f4,0x3f83b804,0x3f8eb9f0,0x3fc00106,0x3fcd00f2,0x3fc70802,0x3fca09f6,0x3fc4b006,0x3fc9b1f2,0x3fc3b902,0x3fceb8f6}, + uint32(0xfff80000), + [21]string{"0x07","0x40","0x26","0xee","0x41","0x3e","0x36","0x8f","0x2b","0x61","0xbe","0xa5","0xb4","0xc1","0xdb","0x90","0x7f","0x30","0x55","0x08","0x00"} }, + { + /* No.323 delta:787 weight:1255 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0xc201724a,0xbd7f5d87,0x7f7e2fcd,0xc0b01432,0x02b16678,0x7dcf49b5,0xbfce3bff,0x0000d10c,0xc201a346,0xbd7f8c8b,0x7f7efec1,0xc0b0c53e,0x02b1b774,0x7dcf98b9,0xbfceeaf3}, + [16]uint32{0x00000000,0x2003097e,0x2000e049,0x0003e937,0x100409ab,0x300700d5,0x3004e9e2,0x1007e09c,0x6004001a,0x40070964,0x4004e053,0x6007e92d,0x700009b1,0x500300cf,0x5000e9f8,0x7003e086}, + [16]uint32{0x3f800000,0x3f900184,0x3f900070,0x3f8001f4,0x3f880204,0x3f980380,0x3f980274,0x3f8803f0,0x3fb00200,0x3fa00384,0x3fa00270,0x3fb003f4,0x3fb80004,0x3fa80180,0x3fa80074,0x3fb801f0}, + uint32(0xfff80000), + [21]string{"0x3c","0x1d","0xc8","0x48","0xca","0x0e","0x2b","0x39","0x42","0x3d","0x4c","0xff","0x69","0xac","0xff","0xe8","0xf7","0xa9","0xe2","0x6c","0x00"} }, + { + /* No.324 delta:795 weight:1553 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0x3c65716d,0x511a1b1b,0x6d7f6a76,0x6420144e,0x58456523,0x353a0f55,0x095f7e38,0x0000c620,0x3c65b74d,0x511add3b,0x6d7fac56,0x6420d26e,0x5845a303,0x353ac975,0x095fb818}, + [16]uint32{0x00000000,0x0005193e,0x0002b037,0x0007a909,0x0043901c,0x00468922,0x0041202b,0x00443915,0x282110a3,0x2824099d,0x2823a094,0x2826b9aa,0x286280bf,0x28679981,0x28603088,0x286529b6}, + [16]uint32{0x3f800000,0x3f80028c,0x3f800158,0x3f8003d4,0x3f8021c8,0x3f802344,0x3f802090,0x3f80221c,0x3f941088,0x3f941204,0x3f9411d0,0x3f94135c,0x3f943140,0x3f9433cc,0x3f943018,0x3f943294}, + uint32(0xfff80000), + [21]string{"0x6b","0x7e","0x85","0x2e","0xce","0x11","0x4b","0xad","0xcd","0x12","0x16","0xd1","0xb1","0xeb","0x8a","0x25","0xa8","0xfa","0xe8","0x1e","0x00"} }, + { + /* No.325 delta:1620 weight:1585 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x1c3439f2,0x2cb4051e,0x30803cec,0x12901459,0x0ea42dab,0x3e241147,0x221028b5,0x00005f03,0x1c3466f1,0x2cb45a1d,0x308063ef,0x12904b5a,0x0ea472a8,0x3e244e44,0x221077b6}, + [16]uint32{0x00000000,0x00f80992,0xc20402dc,0xc2fc0b4e,0x200c8011,0x20f48983,0xe20882cd,0xe2f08b5f,0x1000440b,0x10f84d99,0xd20446d7,0xd2fc4f45,0x300cc41a,0x30f4cd88,0xf208c6c6,0xf2f0cf54}, + [16]uint32{0x3f800000,0x3f807c04,0x3fe10201,0x3fe17e05,0x3f900640,0x3f907a44,0x3ff10441,0x3ff17845,0x3f880022,0x3f887c26,0x3fe90223,0x3fe97e27,0x3f980662,0x3f987a66,0x3ff90463,0x3ff97867}, + uint32(0xfff80000), + [21]string{"0x14","0x85","0x7c","0xf8","0xd2","0x0e","0x6b","0x76","0x39","0x54","0x41","0x6f","0x01","0xf9","0x76","0x71","0x51","0xc6","0x4a","0x7a","0x00"} }, + { + /* No.326 delta:1192 weight:1299 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x96676930,0x1ebf2087,0x88d849b7,0xe8001466,0x7e677d56,0xf6bf34e1,0x60d85dd1,0x00003950,0x96675060,0x1ebf19d7,0x88d870e7,0xe8002d36,0x7e674406,0xf6bf0db1,0x60d86481}, + [16]uint32{0x00000000,0x0026ca1c,0x004350b3,0x00659aaf,0x2108e059,0x212e2a45,0x214bb0ea,0x216d7af6,0x00024012,0x00248a0e,0x004110a1,0x0067dabd,0x210aa04b,0x212c6a57,0x2149f0f8,0x216f3ae4}, + [16]uint32{0x3f800000,0x3f801365,0x3f8021a8,0x3f8032cd,0x3f908470,0x3f909715,0x3f90a5d8,0x3f90b6bd,0x3f800120,0x3f801245,0x3f802088,0x3f8033ed,0x3f908550,0x3f909635,0x3f90a4f8,0x3f90b79d}, + uint32(0xfff80000), + [21]string{"0x4f","0x3b","0x08","0x33","0xa8","0xee","0x2e","0x08","0xcf","0x9c","0x3b","0x52","0x0b","0xa7","0x35","0xfc","0xdb","0x1d","0xe8","0x24","0x00"} }, + { + /* No.327 delta:1536 weight:1647 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x8bc3dfcb,0x91944dcf,0x1a579204,0x4c101471,0xc7d3cbba,0xdd8459be,0x56478675,0x000012f3,0x8bc3cd38,0x91945f3c,0x1a5780f7,0x4c100682,0xc7d3d949,0xdd844b4d,0x56479486}, + [16]uint32{0x00000000,0x0057a0dc,0x0078411f,0x002fe1c3,0x100441ab,0x1053e177,0x107c00b4,0x102ba068,0x1000007e,0x1057a0a2,0x10784161,0x102fe1bd,0x000441d5,0x0053e109,0x007c00ca,0x002ba016}, + [16]uint32{0x3f800000,0x3f802bd0,0x3f803c20,0x3f8017f0,0x3f880220,0x3f8829f0,0x3f883e00,0x3f8815d0,0x3f880000,0x3f882bd0,0x3f883c20,0x3f8817f0,0x3f800220,0x3f8029f0,0x3f803e00,0x3f8015d0}, + uint32(0xfff80000), + [21]string{"0xf8","0x64","0x08","0xa2","0x57","0xd1","0x81","0xf2","0x8a","0x27","0xab","0x84","0x7d","0xb0","0x0b","0xe5","0x22","0x66","0x24","0x1d","0x00"} }, + { + /* No.328 delta:1074 weight:779 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x48a4e13a,0x0f8b032c,0x472fe216,0xa9701488,0xe1d4f5b2,0xa6fb17a4,0xee5ff69e,0x000021ce,0x48a4c0f4,0x0f8b22e2,0x472fc3d8,0xa9703546,0xe1d4d47c,0xa6fb366a,0xee5fd750}, + [16]uint32{0x00000000,0x08658037,0x00184019,0x087dc02e,0x0003016d,0x0866815a,0x001b4174,0x087ec143,0x40241ba8,0x48419b9f,0x403c5bb1,0x4859db86,0x40271ac5,0x48429af2,0x403f5adc,0x485adaeb}, + [16]uint32{0x3f800000,0x3f8432c0,0x3f800c20,0x3f843ee0,0x3f800180,0x3f843340,0x3f800da0,0x3f843f60,0x3fa0120d,0x3fa420cd,0x3fa01e2d,0x3fa42ced,0x3fa0138d,0x3fa4214d,0x3fa01fad,0x3fa42d6d}, + uint32(0xfff80000), + [21]string{"0x5d","0xa9","0xf2","0x8d","0x87","0x47","0x78","0x7c","0x72","0xda","0x47","0x7c","0xfd","0xdc","0x62","0x66","0xcb","0x82","0x28","0x6b","0x00"} }, + { + /* No.329 delta:1431 weight:1593 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0x52b71d7c,0x4f1c5a83,0x1dab47ff,0x9630149b,0xc48709e7,0xd92c4e18,0x8b9b5364,0x00004833,0x52b7554f,0x4f1c12b0,0x1dab0fcc,0x96305ca8,0xc48741d4,0xd92c062b,0x8b9b1b57}, + [16]uint32{0x00000000,0x007ae0b2,0x10440c15,0x103eeca7,0xa084100e,0xa0fef0bc,0xb0c01c1b,0xb0bafca9,0x10310011,0x104be0a3,0x00750c04,0x000fecb6,0xb0b5101f,0xb0cff0ad,0xa0f11c0a,0xa08bfcb8}, + [16]uint32{0x3f800000,0x3f803d70,0x3f882206,0x3f881f76,0x3fd04208,0x3fd07f78,0x3fd8600e,0x3fd85d7e,0x3f881880,0x3f8825f0,0x3f803a86,0x3f8007f6,0x3fd85a88,0x3fd867f8,0x3fd0788e,0x3fd045fe}, + uint32(0xfff80000), + [21]string{"0x4b","0x4c","0x4a","0x92","0x08","0x7a","0x0d","0x81","0xbe","0x69","0xe8","0x71","0xcb","0xdf","0x9c","0xad","0x46","0x94","0x0a","0x2f","0x00"} }, + { + /* No.330 delta:1014 weight:1347 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xb9ac6e8d,0x4ade8d84,0xf372e309,0xa47014a3,0x1ddc7a2e,0xeeae9927,0x5702f7aa,0x000051d7,0xb9ac3f5a,0x4adedc53,0xf372b2de,0xa4704574,0x1ddc2bf9,0xeeaec8f0,0x5702a67d}, + [16]uint32{0x00000000,0x104c047a,0x900a898b,0x80468df1,0x30022057,0x204e242d,0xa008a9dc,0xb044ada6,0x30018033,0x204d8449,0xa00b09b8,0xb0470dc2,0x0003a064,0x104fa41e,0x900929ef,0x80452d95}, + [16]uint32{0x3f800000,0x3f882602,0x3fc80544,0x3fc02346,0x3f980110,0x3f902712,0x3fd00454,0x3fd82256,0x3f9800c0,0x3f9026c2,0x3fd00584,0x3fd82386,0x3f8001d0,0x3f8827d2,0x3fc80494,0x3fc02296}, + uint32(0xfff80000), + [21]string{"0xfb","0x45","0x9c","0x16","0xf7","0x4b","0x41","0x51","0x56","0x25","0x8d","0xac","0x08","0x7e","0xf6","0x74","0x59","0x43","0x10","0x3a","0x00"} }, + { + /* No.331 delta:942 weight:1487 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0x4f381880,0x42fe1804,0x0dc60084,0x44a014b6,0x0b980c36,0x065e0cb2,0x49661432,0x0000f4e4,0x4f38ec64,0x42feece0,0x0dc6f460,0x44a0e052,0x0b98f8d2,0x065ef856,0x4966e0d6}, + [16]uint32{0x00000000,0x102441bf,0x2052801d,0x3076c1a2,0x00024c05,0x10260dba,0x2050cc18,0x30748da7,0x201c65cc,0x30382473,0x004ee5d1,0x106aa46e,0x201e29c9,0x303a6876,0x004ca9d4,0x1068e86b}, + [16]uint32{0x3f800000,0x3f881220,0x3f902940,0x3f983b60,0x3f800126,0x3f881306,0x3f902866,0x3f983a46,0x3f900e32,0x3f981c12,0x3f802772,0x3f883552,0x3f900f14,0x3f981d34,0x3f802654,0x3f883474}, + uint32(0xfff80000), + [21]string{"0x9f","0x3c","0x4e","0x68","0xc4","0xf3","0xb7","0x86","0xdd","0xe6","0x06","0x02","0x74","0x0b","0x88","0xbb","0xa0","0x54","0x7d","0xc6","0x00"} }, + { + /* No.332 delta:1315 weight:1465 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0xd9ebe020,0xbcf2d8aa,0x6519388a,0xa8e014c6,0x710bf4e6,0x1412cc6c,0xcdf92c4c,0x00001a2d,0xd9ebfa0d,0xbcf2c287,0x651922a7,0xa8e00eeb,0x710beecb,0x1412d641,0xcdf93661}, + [16]uint32{0x00000000,0x0041d1f6,0x003c282f,0x007df9d9,0x82728135,0x823350c3,0x824ea91a,0x820f78ec,0x0002219b,0x0043f06d,0x003e09b4,0x007fd842,0x8270a0ae,0x82317158,0x824c8881,0x820d5977}, + [16]uint32{0x3f800000,0x3f8020e8,0x3f801e14,0x3f803efc,0x3fc13940,0x3fc119a8,0x3fc12754,0x3fc107bc,0x3f800110,0x3f8021f8,0x3f801f04,0x3f803fec,0x3fc13850,0x3fc118b8,0x3fc12644,0x3fc106ac}, + uint32(0xfff80000), + [21]string{"0x07","0x6d","0xbc","0xfd","0x70","0x7b","0x0f","0x98","0xc9","0x68","0xda","0x90","0x90","0x27","0x32","0x15","0xf5","0x14","0x0c","0x29","0x00"} }, + { + /* No.333 delta:820 weight:1577 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0xe096b9be,0xdcdb6ce8,0x3c4dd556,0xa7a014d6,0x4736ad68,0x7b7b783e,0x9bedc180,0x00000186,0xe096b838,0xdcdb6d6e,0x3c4dd4d0,0xa7a01550,0x4736acee,0x7b7b79b8,0x9bedc006}, + [16]uint32{0x00000000,0x5000a013,0x0002357a,0x50029569,0xa044041e,0xf044a40d,0xa0463164,0xf0469177,0x10012a15,0x40018a06,0x10031f6f,0x4003bf7c,0xb0452e0b,0xe0458e18,0xb0471b71,0xe047bb62}, + [16]uint32{0x3f800000,0x3fa80050,0x3f80011a,0x3fa8014a,0x3fd02202,0x3ff82252,0x3fd02318,0x3ff82348,0x3f880095,0x3fa000c5,0x3f88018f,0x3fa001df,0x3fd82297,0x3ff022c7,0x3fd8238d,0x3ff023dd}, + uint32(0xfff80000), + [21]string{"0xde","0x1b","0xa2","0x18","0xa3","0x83","0xee","0xf9","0x62","0xfc","0xdf","0x4e","0x92","0x5e","0x6a","0xed","0x9d","0xc5","0x62","0xb1","0x00"} }, + { + /* No.334 delta:1674 weight:1425 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0x0243c96b,0x115a5aa7,0x131993cc,0xfe0014ea,0xfc43dd81,0xef5a4e4d,0xed198726,0x0000ad8a,0x024364e1,0x115af72d,0x13193e46,0xfe00b960,0xfc43700b,0xef5ae3c7,0xed192aac}, + [16]uint32{0x00000000,0x002c01ba,0x004100df,0x006d0165,0x30080068,0x302401d2,0x304900b7,0x3065010d,0x20000018,0x202c01a2,0x204100c7,0x206d017d,0x10080070,0x102401ca,0x104900af,0x10650115}, + [16]uint32{0x3f800000,0x3f801600,0x3f802080,0x3f803680,0x3f980400,0x3f981200,0x3f982480,0x3f983280,0x3f900000,0x3f901600,0x3f902080,0x3f903680,0x3f880400,0x3f881200,0x3f882480,0x3f883280}, + uint32(0xfff80000), + [21]string{"0xb4","0xae","0xea","0x67","0xc4","0xae","0x5b","0x04","0x54","0xea","0x0d","0x15","0xe5","0x54","0x57","0x6f","0xe7","0xf7","0x7e","0x99","0x00"} }, + { + /* No.335 delta:1075 weight:1679 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x51638d87,0xe085c9f6,0xb1e64471,0xb68014f8,0xe7e3997f,0x5605dd0e,0x07665089,0x00007b51,0x5163f6d6,0xe085b2a7,0xb1e63f20,0xb6806fa9,0xe7e3e22e,0x5605a65f,0x07662bd8}, + [16]uint32{0x00000000,0x40386133,0x00640036,0x405c6105,0x0801600f,0x4839013c,0x08656039,0x485d010a,0x0003015b,0x403b6068,0x0067016d,0x405f605e,0x08026154,0x483a0067,0x08666162,0x485e0051}, + [16]uint32{0x3f800000,0x3fa01c30,0x3f803200,0x3fa02e30,0x3f8400b0,0x3fa41c80,0x3f8432b0,0x3fa42e80,0x3f800180,0x3fa01db0,0x3f803380,0x3fa02fb0,0x3f840130,0x3fa41d00,0x3f843330,0x3fa42f00}, + uint32(0xfff80000), + [21]string{"0x0b","0x36","0x2f","0x64","0x4c","0x2c","0xf2","0x85","0xc3","0x18","0x3a","0x0b","0x27","0x8e","0x6b","0xff","0x2a","0xaf","0xb1","0xa1","0x00"} }, + { + /* No.336 delta:1464 weight:1505 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xd4f52a80,0xca4a05ad,0x1ebf2f2d,0x12b0150f,0xc6453f8f,0xd8fa10a2,0x0c0f3a22,0x00003ef1,0xd4f51471,0xca4a3b5c,0x1ebf11dc,0x12b02bfe,0xc645017e,0xd8fa2e53,0x0c0f04d3}, + [16]uint32{0x00000000,0x0067293e,0x503b404a,0x505c6974,0x001e11b7,0x00793889,0x502551fd,0x504278c3,0x0005001b,0x00622925,0x503e4051,0x5059696f,0x001b11ac,0x007c3892,0x502051e6,0x504778d8}, + [16]uint32{0x3f800000,0x3f803394,0x3fa81da0,0x3fa82e34,0x3f800f08,0x3f803c9c,0x3fa812a8,0x3fa8213c,0x3f800280,0x3f803114,0x3fa81f20,0x3fa82cb4,0x3f800d88,0x3f803e1c,0x3fa81028,0x3fa823bc}, + uint32(0xfff80000), + [21]string{"0xad","0x6a","0xc9","0xf1","0xb0","0xb0","0xaf","0x19","0x40","0x96","0x82","0xbd","0x6b","0x7f","0xd6","0x80","0x4f","0xc9","0xe2","0xb4","0x00"} }, + { + /* No.337 delta:1298 weight:1167 */ + 11213, + 36, + 13, + 4, + [16]uint32{0x00000000,0xb6de49a0,0x3acc1f09,0x8c1256a9,0xf690151b,0x404e5cbb,0xcc5c0a12,0x7a8243b2,0x00004270,0xb6de0bd0,0x3acc5d79,0x8c1214d9,0xf690576b,0x404e1ecb,0xcc5c4862,0x7a8201c2}, + [16]uint32{0x00000000,0x007e419e,0x000200d5,0x007c414b,0x100101ba,0x107f4024,0x1003016f,0x107d40f1,0x0001e019,0x007fa187,0x0003e0cc,0x007da152,0x1000e1a3,0x107ea03d,0x1002e176,0x107ca0e8}, + [16]uint32{0x3f800000,0x3f803f20,0x3f800100,0x3f803e20,0x3f880080,0x3f883fa0,0x3f880180,0x3f883ea0,0x3f8000f0,0x3f803fd0,0x3f8001f0,0x3f803ed0,0x3f880070,0x3f883f50,0x3f880170,0x3f883e50}, + uint32(0xfff80000), + [21]string{"0x78","0xa4","0xac","0x37","0xf1","0x2d","0xc7","0xe4","0x78","0x4d","0x40","0xea","0x5f","0xb5","0x65","0x8c","0xb3","0xfe","0x6e","0x11","0x00"} }, + { + /* No.338 delta:1869 weight:1493 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x557ccf79,0x92c336a6,0xc7bff9df,0xceb01526,0x9bccda5f,0x5c732380,0x090fecf9,0x000054db,0x557c9ba2,0x92c3627d,0xc7bfad04,0xceb041fd,0x9bcc8e84,0x5c73775b,0x090fb822}, + [16]uint32{0x00000000,0x9907821a,0x2113e1ad,0xb81463b7,0x28806039,0xb187e223,0x09938194,0x9094038e,0x7064d35e,0xe9635144,0x517732f3,0xc870b0e9,0x58e4b367,0xc1e3317d,0x79f752ca,0xe0f0d0d0}, + [16]uint32{0x3f800000,0x3fcc83c1,0x3f9089f0,0x3fdc0a31,0x3f944030,0x3fd8c3f1,0x3f84c9c0,0x3fc84a01,0x3fb83269,0x3ff4b1a8,0x3fa8bb99,0x3fe43858,0x3fac7259,0x3fe0f198,0x3fbcfba9,0x3ff07868}, + uint32(0xfff80000), + [21]string{"0xce","0x65","0xce","0xc4","0x70","0xc0","0x87","0xff","0x4d","0x30","0x57","0xe1","0x4e","0x54","0x2a","0x2e","0x65","0x2d","0x07","0xd9","0x00"} }, + { + /* No.339 delta:802 weight:1691 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0xe347fae3,0xaa93278b,0x49d4dd68,0xbcb01531,0x5ff7efd2,0x162332ba,0xf564c859,0x000084b0,0xe3477e53,0xaa93a33b,0x49d459d8,0xbcb09181,0x5ff76b62,0x1623b60a,0xf5644ce9}, + [16]uint32{0x00000000,0x01401c77,0x10000206,0x11401e71,0x9000019b,0x91401dec,0x8000039d,0x81401fea,0x3101a0f2,0x3041bc85,0x2101a2f4,0x2041be83,0xa101a169,0xa041bd1e,0xb101a36f,0xb041bf18}, + [16]uint32{0x3f800000,0x3f80a00e,0x3f880001,0x3f88a00f,0x3fc80000,0x3fc8a00e,0x3fc00001,0x3fc0a00f,0x3f9880d0,0x3f9820de,0x3f9080d1,0x3f9020df,0x3fd080d0,0x3fd020de,0x3fd880d1,0x3fd820df}, + uint32(0xfff80000), + [21]string{"0xc1","0x7e","0xb1","0x45","0xa6","0x8c","0x0c","0xa0","0xc5","0x7f","0x0f","0xc0","0x8a","0x9e","0xb3","0x56","0x33","0x68","0x3b","0x18","0x00"} }, + { + /* No.340 delta:2189 weight:1223 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xc7331da0,0x6241ad6d,0xa572b0cd,0x11b0154f,0xd68308ef,0x73f1b822,0xb4c2a582,0x00007d34,0xc7336094,0x6241d059,0xa572cdf9,0x11b0687b,0xd68375db,0x73f1c516,0xb4c2d8b6}, + [16]uint32{0x00000000,0x0d02153a,0x0a004409,0x07025133,0x038372be,0x0e816784,0x098336b7,0x0481238d,0x01001a1c,0x0c020f26,0x0b005e15,0x06024b2f,0x028368a2,0x0f817d98,0x08832cab,0x05813991}, + [16]uint32{0x3f800000,0x3f86810a,0x3f850022,0x3f838128,0x3f81c1b9,0x3f8740b3,0x3f84c19b,0x3f824091,0x3f80800d,0x3f860107,0x3f85802f,0x3f830125,0x3f8141b4,0x3f87c0be,0x3f844196,0x3f82c09c}, + uint32(0xfff80000), + [21]string{"0xd7","0x99","0xdc","0x3d","0xe6","0x75","0xb5","0x4d","0xc6","0x0a","0x51","0x47","0xac","0x0f","0x03","0x6f","0xec","0x35","0x6b","0x7a","0x00"} }, + { + /* No.341 delta:1415 weight:1677 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0xe5a8fe2d,0x99e7dc90,0x7c4f22bd,0x7d101555,0x98b8eb78,0xe4f7c9c5,0x015f37e8,0x00008141,0xe5a87f6c,0x99e75dd1,0x7c4fa3fc,0x7d109414,0x98b86a39,0xe4f74884,0x015fb6a9}, + [16]uint32{0x00000000,0x006c4197,0x001001f2,0x007c4065,0x000200aa,0x006e413d,0x00120158,0x007e40cf,0x1043801c,0x102fc18b,0x105381ee,0x103fc079,0x104180b6,0x102dc121,0x10518144,0x103dc0d3}, + [16]uint32{0x3f800000,0x3f803620,0x3f800800,0x3f803e20,0x3f800100,0x3f803720,0x3f800900,0x3f803f20,0x3f8821c0,0x3f8817e0,0x3f8829c0,0x3f881fe0,0x3f8820c0,0x3f8816e0,0x3f8828c0,0x3f881ee0}, + uint32(0xfff80000), + [21]string{"0x61","0x5c","0xdd","0x3f","0xcb","0x58","0xda","0xf6","0x62","0xe9","0x0d","0xb8","0x14","0xbd","0x63","0x5b","0x3e","0xb3","0x37","0xce","0x00"} }, + { + /* No.342 delta:706 weight:1683 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0x72c9c252,0xa7c90593,0xd500c7c1,0x6f701562,0x1db9d730,0xc8b910f1,0xba70d2a3,0x0000a0f4,0x72c962a6,0xa7c9a567,0xd5006735,0x6f70b596,0x1db977c4,0xc8b9b005,0xba707257}, + [16]uint32{0x00000000,0x4002049e,0x4410ce1d,0x0412ca83,0x1009e50a,0x500be194,0x54192b17,0x141b2f89,0x4001ac65,0x0003a8fb,0x04116278,0x441366e6,0x5008496f,0x100a4df1,0x14188772,0x541a83ec}, + [16]uint32{0x3f800000,0x3fa00102,0x3fa20867,0x3f820965,0x3f8804f2,0x3fa805f0,0x3faa0c95,0x3f8a0d97,0x3fa000d6,0x3f8001d4,0x3f8208b1,0x3fa209b3,0x3fa80424,0x3f880526,0x3f8a0c43,0x3faa0d41}, + uint32(0xfff80000), + [21]string{"0xac","0x26","0x73","0x72","0xdc","0x6b","0xa4","0x2c","0xdb","0x49","0x64","0xd3","0x82","0x95","0x07","0x34","0xee","0x5c","0xc9","0x8b","0x00"} }, + { + /* No.343 delta:1208 weight:1535 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x469f7107,0x71bce1ea,0x372390ed,0x05c01570,0x435f6477,0x747cf49a,0x32e3859d,0x00000429,0x469f752e,0x71bce5c3,0x372394c4,0x05c01159,0x435f605e,0x747cf0b3,0x32e381b4}, + [16]uint32{0x00000000,0x0051133a,0xa0000017,0xa051132d,0x30188495,0x304997af,0x90188482,0x904997b8,0x00899c11,0x00d88f2b,0xa0899c06,0xa0d88f3c,0x30911884,0x30c00bbe,0x90911893,0x90c00ba9}, + [16]uint32{0x3f800000,0x3f802889,0x3fd00000,0x3fd02889,0x3f980c42,0x3f9824cb,0x3fc80c42,0x3fc824cb,0x3f8044ce,0x3f806c47,0x3fd044ce,0x3fd06c47,0x3f98488c,0x3f986005,0x3fc8488c,0x3fc86005}, + uint32(0xfff80000), + [21]string{"0x6b","0x61","0x0b","0x45","0x93","0xc7","0x5b","0x8e","0xaf","0x89","0x6d","0x89","0xff","0xb6","0x38","0x9e","0x2e","0xee","0x76","0x8f","0x00"} }, + { + /* No.344 delta:1500 weight:1641 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x8bc3dfcb,0x91944dcf,0x1a579204,0x4c101581,0xc7d3ca4a,0xdd84584e,0x56478785,0x000012f3,0x8bc3cd38,0x91945f3c,0x1a5780f7,0x4c100772,0xc7d3d8b9,0xdd844abd,0x56479576}, + [16]uint32{0x00000000,0x004c809c,0x0038c1a2,0x0074413e,0x00084076,0x0044c0ea,0x003081d4,0x007c0148,0x22100010,0x225c808c,0x2228c1b2,0x2264412e,0x22184066,0x2254c0fa,0x222081c4,0x226c0158}, + [16]uint32{0x3f800000,0x3f802640,0x3f801c60,0x3f803a20,0x3f800420,0x3f802260,0x3f801840,0x3f803e00,0x3f910800,0x3f912e40,0x3f911460,0x3f913220,0x3f910c20,0x3f912a60,0x3f911040,0x3f913600}, + uint32(0xfff80000), + [21]string{"0x8b","0x8d","0x88","0xed","0x19","0xc2","0x91","0xc6","0xd2","0x10","0x21","0xea","0xf5","0x4b","0x24","0x19","0x15","0x85","0x9c","0x0d","0x00"} }, + { + /* No.345 delta:874 weight:1661 */ + 11213, + 75, + 13, + 4, + [16]uint32{0x00000000,0xa6151454,0xff23562b,0x5936427f,0xf260159a,0x547501ce,0x0d4343b1,0xab5657e5,0x00005ee0,0xa6154ab4,0xff2308cb,0x59361c9f,0xf2604b7a,0x54755f2e,0x0d431d51,0xab560905}, + [16]uint32{0x00000000,0x9010c13b,0x20020407,0xb012c53c,0x400032d6,0xd010f3ed,0x600236d1,0xf012f7ea,0x0001981e,0x90115925,0x20039c19,0xb0135d22,0x4001aac8,0xd0116bf3,0x6003aecf,0xf0136ff4}, + [16]uint32{0x3f800000,0x3fc80860,0x3f900102,0x3fd80962,0x3fa00019,0x3fe80879,0x3fb0011b,0x3ff8097b,0x3f8000cc,0x3fc808ac,0x3f9001ce,0x3fd809ae,0x3fa000d5,0x3fe808b5,0x3fb001d7,0x3ff809b7}, + uint32(0xfff80000), + [21]string{"0xe5","0xb9","0xf4","0xf6","0xd6","0x20","0x83","0x08","0x4b","0xfe","0x22","0xa5","0x3e","0xe1","0xfa","0xc1","0x74","0x64","0xc1","0xd4","0x00"} }, + { + /* No.346 delta:668 weight:1631 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0x6cdca230,0x1e5aef28,0x72864d18,0xff5015aa,0x938cb79a,0xe10afa82,0x8dd658b2,0x0000a0f4,0x6cdc02c4,0x1e5a4fdc,0x7286edec,0xff50b55e,0x938c176e,0xe10a5a76,0x8dd6f846}, + [16]uint32{0x00000000,0x50031033,0x4000e967,0x1003f954,0x0016840e,0x5015943d,0x40166d69,0x10157d5a,0x00021c02,0x50010c31,0x4002f565,0x1001e556,0x0014980c,0x5017883f,0x4014716b,0x10176158}, + [16]uint32{0x3f800000,0x3fa80188,0x3fa00074,0x3f8801fc,0x3f800b42,0x3fa80aca,0x3fa00b36,0x3f880abe,0x3f80010e,0x3fa80086,0x3fa0017a,0x3f8800f2,0x3f800a4c,0x3fa80bc4,0x3fa00a38,0x3f880bb0}, + uint32(0xfff80000), + [21]string{"0x16","0xc9","0xc2","0xe3","0xc9","0x45","0xe3","0x66","0x08","0x01","0xb7","0x05","0xc4","0x33","0xde","0xa4","0x72","0x32","0x0c","0x60","0x00"} }, + { + /* No.347 delta:672 weight:1377 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0x64f6ccf6,0xa5446450,0xc1b2a8a6,0xc7e015bb,0xa316d94d,0x62a471eb,0x0652bd1d,0x0000ba59,0x64f676af,0xa544de09,0xc1b212ff,0xc7e0afe2,0xa3166314,0x62a4cbb2,0x06520744}, + [16]uint32{0x00000000,0x1038517d,0x9062008e,0x805a51f3,0x004064af,0x107835d2,0x90226421,0x801a355c,0x20208015,0x3018d168,0xb042809b,0xa07ad1e6,0x2060e4ba,0x3058b5c7,0xb002e434,0xa03ab549}, + [16]uint32{0x3f800000,0x3f881c28,0x3fc83100,0x3fc02d28,0x3f802032,0x3f883c1a,0x3fc81132,0x3fc00d1a,0x3f901040,0x3f980c68,0x3fd82140,0x3fd03d68,0x3f903072,0x3f982c5a,0x3fd80172,0x3fd01d5a}, + uint32(0xfff80000), + [21]string{"0x85","0xa9","0x7e","0x54","0xab","0x3e","0x90","0xf7","0xf7","0x23","0x6e","0xa4","0xc4","0x27","0x65","0xe3","0xda","0x9b","0x92","0xdf","0x00"} }, + { + /* No.348 delta:580 weight:1491 */ + 11213, + 81, + 13, + 4, + [16]uint32{0x00000000,0x6280169c,0x54214e05,0x36a15899,0x513015c8,0x33b00354,0x05115bcd,0x67914d51,0x0000a747,0x6280b1db,0x5421e942,0x36a1ffde,0x5130b28f,0x33b0a413,0x0511fc8a,0x6791ea16}, + [16]uint32{0x00000000,0x204441be,0x500204e2,0x7046455c,0x180101d8,0x38454066,0x4803053a,0x68474484,0x0002126c,0x204653d2,0x5000168e,0x70445730,0x180313b4,0x3847520a,0x48011756,0x684556e8}, + [16]uint32{0x3f800000,0x3f902220,0x3fa80102,0x3fb82322,0x3f8c0080,0x3f9c22a0,0x3fa40182,0x3fb423a2,0x3f800109,0x3f902329,0x3fa8000b,0x3fb8222b,0x3f8c0189,0x3f9c23a9,0x3fa4008b,0x3fb422ab}, + uint32(0xfff80000), + [21]string{"0x72","0xe8","0x94","0x01","0x7c","0xd8","0x51","0xed","0xa5","0xfb","0xb8","0x7b","0x35","0xc5","0xa7","0xaa","0x1f","0x3b","0xb8","0x2b","0x00"} }, + { + /* No.349 delta:846 weight:1637 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0xe7441d0e,0x0fc4362c,0xe8802b22,0xc44015df,0x230408d1,0xcb8423f3,0x2cc03efd,0x000008b0,0xe74415be,0x0fc43e9c,0xe8802392,0xc4401d6f,0x23040061,0xcb842b43,0x2cc0364d}, + [16]uint32{0x00000000,0x100330b2,0x8001a194,0x90029126,0x5000dc15,0x4003eca7,0xd0017d81,0xc0024d33,0x4000140f,0x500324bd,0xc001b59b,0xd0028529,0x1000c81a,0x0003f8a8,0x9001698e,0x8002593c}, + [16]uint32{0x3f800000,0x3f880198,0x3fc000d0,0x3fc80148,0x3fa8006e,0x3fa001f6,0x3fe800be,0x3fe00126,0x3fa0000a,0x3fa80192,0x3fe000da,0x3fe80142,0x3f880064,0x3f8001fc,0x3fc800b4,0x3fc0012c}, + uint32(0xfff80000), + [21]string{"0x5c","0xa1","0x5f","0x80","0x8d","0x97","0x0a","0xef","0x81","0xeb","0x8f","0x27","0x82","0xff","0x97","0x46","0xab","0xd8","0xa0","0xb6","0x00"} }, + { + /* No.350 delta:2671 weight:847 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x697b76cd,0xbc944c5f,0xd5ef3a92,0xa4b015e2,0xcdcb632f,0x182459bd,0x715f2f70,0x0000113d,0x697b67f0,0xbc945d62,0xd5ef2baf,0xa4b004df,0xcdcb7212,0x18244880,0x715f3e4d}, + [16]uint32{0x00000000,0x9604f13a,0x0c4aa42b,0x9a4e5511,0x0b2c0417,0x9d28f52d,0x0766a03c,0x91625106,0x07142084,0x9110d1be,0x0b5e84af,0x9d5a7595,0x0c382493,0x9a3cd5a9,0x007280b8,0x96767182}, + [16]uint32{0x3f800000,0x3fcb0278,0x3f862552,0x3fcd272a,0x3f859602,0x3fce947a,0x3f83b350,0x3fc8b128,0x3f838a10,0x3fc88868,0x3f85af42,0x3fcead3a,0x3f861c12,0x3fcd1e6a,0x3f803940,0x3fcb3b38}, + uint32(0xfff80000), + [21]string{"0xf9","0xc5","0x41","0xba","0xb9","0x62","0xc3","0x80","0x73","0xc1","0xf6","0xc6","0x28","0x01","0x75","0x10","0x4a","0x59","0xaa","0x76","0x00"} }, + { + /* No.351 delta:884 weight:1701 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0xd5645896,0x731c013c,0xa67859aa,0x162015f1,0xc3444d67,0x653c14cd,0xb0584c5b,0x00004a2c,0xd56412ba,0x731c4b10,0xa6781386,0x16205fdd,0xc344074b,0x653c5ee1,0xb0580677}, + [16]uint32{0x00000000,0x41424556,0x70002053,0x31426505,0x3002c01e,0x71408548,0x4002e04d,0x0140a51b,0x20007219,0x6142374f,0x5000524a,0x1142171c,0x1002b207,0x5140f751,0x60029254,0x2140d702}, + [16]uint32{0x3f800000,0x3fa0a122,0x3fb80010,0x3f98a132,0x3f980160,0x3fb8a042,0x3fa00170,0x3f80a052,0x3f900039,0x3fb0a11b,0x3fa80029,0x3f88a10b,0x3f880159,0x3fa8a07b,0x3fb00149,0x3f90a06b}, + uint32(0xfff80000), + [21]string{"0x6e","0x2b","0xde","0x14","0x2d","0xc6","0x7c","0x00","0x5d","0x85","0xf5","0xbd","0x5a","0xb3","0x43","0x8c","0x46","0xf2","0x80","0xa2","0x00"} }, + { + /* No.352 delta:1012 weight:1759 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0x8d0371f4,0x25227130,0xa82100c4,0xb8e0160d,0x35e367f9,0x9dc2673d,0x10c116c9,0x00003be5,0x8d034a11,0x25224ad5,0xa8213b21,0xb8e02de8,0x35e35c1c,0x9dc25cd8,0x10c12d2c}, + [16]uint32{0x00000000,0x102761be,0x007611f1,0x1051704f,0x00484bfb,0x106f2a45,0x003e5a0a,0x10193bb4,0x48001806,0x582779b8,0x487609f7,0x58516849,0x484853fd,0x586f3243,0x483e420c,0x581923b2}, + [16]uint32{0x3f800000,0x3f8813b0,0x3f803b08,0x3f8828b8,0x3f802425,0x3f883795,0x3f801f2d,0x3f880c9d,0x3fa4000c,0x3fac13bc,0x3fa43b04,0x3fac28b4,0x3fa42429,0x3fac3799,0x3fa41f21,0x3fac0c91}, + uint32(0xfff80000), + [21]string{"0x14","0x60","0xb3","0x50","0x2c","0x67","0xc9","0xec","0x2a","0x2b","0xcf","0xc2","0x36","0xbf","0xe3","0xbc","0xe8","0xa7","0x8b","0x14","0x00"} }, + { + /* No.353 delta:865 weight:1537 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0xf28f5762,0x10a3e4bb,0xe22cb3d9,0xa1b01610,0x533f4172,0xb113f2ab,0x439ca5c9,0x0000b547,0xf28fe225,0x10a351fc,0xe22c069e,0xa1b0a357,0x533ff435,0xb11347ec,0x439c108e}, + [16]uint32{0x00000000,0x502c0937,0x1401c011,0x442dc926,0x00035008,0x502f593f,0x14029019,0x442e992e,0x5000020c,0x002c0b3b,0x4401c21d,0x142dcb2a,0x50035204,0x002f5b33,0x44029215,0x142e9b22}, + [16]uint32{0x3f800000,0x3fa81604,0x3f8a00e0,0x3fa216e4,0x3f8001a8,0x3fa817ac,0x3f8a0148,0x3fa2174c,0x3fa80001,0x3f801605,0x3fa200e1,0x3f8a16e5,0x3fa801a9,0x3f8017ad,0x3fa20149,0x3f8a174d}, + uint32(0xfff80000), + [21]string{"0x8b","0x2a","0x0c","0xdc","0x72","0xbd","0x5b","0xbd","0xce","0x57","0x2b","0x56","0xfe","0x29","0x1c","0x90","0xe2","0x89","0x78","0x37","0x00"} }, + { + /* No.354 delta:1086 weight:1395 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x2a73898b,0x2bc778a1,0x01b4f12a,0xc0101625,0xea639fae,0xebd76e84,0xc1a4e70f,0x00005fa6,0x2a73d62d,0x2bc72707,0x01b4ae8c,0xc0104983,0xea63c008,0xebd73122,0xc1a4b8a9}, + [16]uint32{0x00000000,0x00548076,0x6158a151,0x610c2127,0x0023f032,0x00777044,0x617b5163,0x612fd115,0x0003141c,0x0057946a,0x615bb54d,0x610f353b,0x0020e42e,0x00746458,0x6178457f,0x612cc509}, + [16]uint32{0x3f800000,0x3f802a40,0x3fb0ac50,0x3fb08610,0x3f8011f8,0x3f803bb8,0x3fb0bda8,0x3fb097e8,0x3f80018a,0x3f802bca,0x3fb0adda,0x3fb0879a,0x3f801072,0x3f803a32,0x3fb0bc22,0x3fb09662}, + uint32(0xfff80000), + [21]string{"0xc1","0x4f","0x6a","0x0d","0x5d","0xd0","0x28","0xff","0x27","0x0d","0x1c","0xa0","0xd3","0x5d","0xe6","0x18","0x2c","0x28","0x48","0x32","0x00"} }, + { + /* No.355 delta:860 weight:1565 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0xb757ab7c,0x584f0020,0xef18ab5c,0x27201630,0x9077bd4c,0x7f6f1610,0xc838bd6c,0x0000df99,0xb75774e5,0x584fdfb9,0xef1874c5,0x2720c9a9,0x907762d5,0x7f6fc989,0xc83862f5}, + [16]uint32{0x00000000,0x1020605a,0x700105ec,0x602165b6,0xe0001003,0xf0207059,0x900115ef,0x802175b5,0x6000001e,0x70206044,0x100105f2,0x002165a8,0x8000101d,0x90207047,0xf00115f1,0xe02175ab}, + [16]uint32{0x3f800000,0x3f881030,0x3fb80082,0x3fb010b2,0x3ff00008,0x3ff81038,0x3fc8008a,0x3fc010ba,0x3fb00000,0x3fb81030,0x3f880082,0x3f8010b2,0x3fc00008,0x3fc81038,0x3ff8008a,0x3ff010ba}, + uint32(0xfff80000), + [21]string{"0x34","0x86","0x19","0x26","0xaa","0xfd","0xd4","0xd7","0xa8","0xb6","0x9e","0xb2","0xcc","0xd0","0x06","0xe7","0xbf","0x58","0x55","0x64","0x00"} }, + { + /* No.356 delta:1005 weight:1725 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xe2ad09a9,0x031bb3d5,0xe1b6ba7c,0xed301640,0x0f9d1fe9,0xee2ba595,0x0c86ac3c,0x00007c4a,0xe2ad75e3,0x031bcf9f,0xe1b6c636,0xed306a0a,0x0f9d63a3,0xee2bd9df,0x0c86d076}, + [16]uint32{0x00000000,0x507c185e,0x300a0519,0x60761d47,0x100217eb,0x407e0fb5,0x200812f2,0x70740aac,0x1001021d,0x407d1a43,0x200b0704,0x70771f5a,0x000315f6,0x507f0da8,0x300910ef,0x607508b1}, + [16]uint32{0x3f800000,0x3fa83e0c,0x3f980502,0x3fb03b0e,0x3f88010b,0x3fa03f07,0x3f900409,0x3fb83a05,0x3f880081,0x3fa03e8d,0x3f900583,0x3fb83b8f,0x3f80018a,0x3fa83f86,0x3f980488,0x3fb03a84}, + uint32(0xfff80000), + [21]string{"0xe0","0x2a","0xe4","0x2c","0xf9","0xbe","0x0e","0xec","0x9d","0x4a","0x95","0x02","0x1e","0x7d","0x34","0x1d","0x1f","0xc5","0xe7","0x34","0x00"} }, + { + /* No.357 delta:1742 weight:1501 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0xa0a72c62,0x05e61d1e,0xa541317c,0x67d01659,0xc7773a3b,0x62360b47,0xc2912725,0x0000957f,0xa0a7b91d,0x05e68861,0xa541a403,0x67d08326,0xc777af44,0x62369e38,0xc291b25a}, + [16]uint32{0x00000000,0x281150de,0x404c418a,0x685d1154,0x080d040b,0x201c54d5,0x48414581,0x6050155f,0x90e041c6,0xb8f11118,0xd0ac004c,0xf8bd5092,0x98ed45cd,0xb0fc1513,0xd8a10447,0xf0b05499}, + [16]uint32{0x3f800000,0x3f9408a8,0x3fa02620,0x3fb42e88,0x3f840682,0x3f900e2a,0x3fa420a2,0x3fb0280a,0x3fc87020,0x3fdc7888,0x3fe85600,0x3ffc5ea8,0x3fcc76a2,0x3fd87e0a,0x3fec5082,0x3ff8582a}, + uint32(0xfff80000), + [21]string{"0x85","0xbb","0xe2","0x15","0x0a","0xf7","0x0d","0xd8","0x7b","0x9c","0x37","0x41","0x74","0x35","0x37","0xb4","0xf8","0x43","0x55","0xb0","0x00"} }, + { + /* No.358 delta:917 weight:1591 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0xf655e780,0xce108c27,0x38456ba7,0xf8a0166d,0x0ef5f1ed,0x36b09a4a,0xc0e57dca,0x00009a4a,0xf6557dca,0xce10166d,0x3845f1ed,0xf8a08c27,0x0ef56ba7,0x36b00000,0xc0e5e780}, + [16]uint32{0x00000000,0x007413fa,0x000a0c19,0x007e1fe3,0x0011081f,0x00651be5,0x001b0406,0x006f17fc,0x4030a0f2,0x4044b308,0x403aaceb,0x404ebf11,0x4021a8ed,0x4055bb17,0x402ba4f4,0x405fb70e}, + [16]uint32{0x3f800000,0x3f803a09,0x3f800506,0x3f803f0f,0x3f800884,0x3f80328d,0x3f800d82,0x3f80378b,0x3fa01850,0x3fa02259,0x3fa01d56,0x3fa0275f,0x3fa010d4,0x3fa02add,0x3fa015d2,0x3fa02fdb}, + uint32(0xfff80000), + [21]string{"0x4a","0x7e","0x0d","0x83","0xdc","0xd9","0x45","0xd7","0xd7","0xea","0xfa","0x38","0xae","0xc1","0xed","0x09","0x5d","0xf8","0x6e","0x1c","0x00"} }, + { + /* No.359 delta:988 weight:1719 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0x39ff8e1e,0x052720a1,0x3cd8aebf,0xca501672,0xf3af986c,0xcf7736d3,0xf688b8cd,0x00001f50,0x39ff914e,0x05273ff1,0x3cd8b1ef,0xca500922,0xf3af873c,0xcf772983,0xf688a79d}, + [16]uint32{0x00000000,0x602c709a,0x101a202f,0x703650b5,0x0064c159,0x6048b1c3,0x107ee176,0x705291ec,0x0003c801,0x602fb89b,0x1019e82e,0x703598b4,0x00670958,0x604b79c2,0x107d2977,0x705159ed}, + [16]uint32{0x3f800000,0x3fb01638,0x3f880d10,0x3fb81b28,0x3f803260,0x3fb02458,0x3f883f70,0x3fb82948,0x3f8001e4,0x3fb017dc,0x3f880cf4,0x3fb81acc,0x3f803384,0x3fb025bc,0x3f883e94,0x3fb828ac}, + uint32(0xfff80000), + [21]string{"0x6f","0x5b","0x81","0x0e","0x88","0xf9","0x5d","0x76","0x87","0x44","0xb2","0x5a","0xd9","0x1e","0x0c","0x85","0x4a","0xa6","0xa6","0x50","0x00"} }, + { + /* No.360 delta:1132 weight:1663 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xde530426,0x95ff5ef7,0x4bac5ad1,0xd1f01682,0x0fa312a4,0x440f4875,0x9a5c4c53,0x0000dea0,0xde53da86,0x95ff8057,0x4bac8471,0xd1f0c822,0x0fa3cc04,0x440f96d5,0x9a5c92f3}, + [16]uint32{0x00000000,0x0044015c,0x00330035,0x00770169,0x21b9c1a2,0x21fdc0fe,0x218ac197,0x21cec0cb,0x0020301d,0x00643141,0x00133028,0x00573174,0x2199f1bf,0x21ddf0e3,0x21aaf18a,0x21eef0d6}, + [16]uint32{0x3f800000,0x3f802200,0x3f801980,0x3f803b80,0x3f90dce0,0x3f90fee0,0x3f90c560,0x3f90e760,0x3f801018,0x3f803218,0x3f800998,0x3f802b98,0x3f90ccf8,0x3f90eef8,0x3f90d578,0x3f90f778}, + uint32(0xfff80000), + [21]string{"0xe4","0xa2","0x91","0x75","0x75","0x5f","0x6f","0xcc","0x85","0x64","0x78","0xdd","0x14","0x7e","0xcc","0x18","0xf4","0x0c","0x08","0xe3","0x00"} }, + { + /* No.361 delta:769 weight:1621 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0x78161af6,0x17c5d7ee,0x6fd3cd18,0x78f0169b,0x00e60c6d,0x6f35c175,0x1723db83,0x00000185,0x78161b73,0x17c5d66b,0x6fd3cc9d,0x78f0171e,0x00e60de8,0x6f35c0f0,0x1723da06}, + [16]uint32{0x00000000,0x300d07b6,0x0021ca1a,0x302ccdac,0x70001f45,0x400d18f3,0x7021d55f,0x402cd2e9,0x20001194,0x100d1622,0x2021db8e,0x102cdc38,0x50000ed1,0x600d0967,0x5021c4cb,0x602cc37d}, + [16]uint32{0x3f800000,0x3f980683,0x3f8010e5,0x3f981666,0x3fb8000f,0x3fa0068c,0x3fb810ea,0x3fa01669,0x3f900008,0x3f88068b,0x3f9010ed,0x3f88166e,0x3fa80007,0x3fb00684,0x3fa810e2,0x3fb01661}, + uint32(0xfff80000), + [21]string{"0x10","0x6d","0x31","0xe8","0x2c","0xfe","0x25","0xff","0xd4","0xc5","0x51","0x0b","0x5a","0xb8","0x88","0xb6","0x5f","0x91","0xe3","0xa1","0x00"} }, + { + /* No.362 delta:721 weight:1605 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0x4a126c87,0x2c51b2ae,0x6643de29,0xe29016af,0xa8827a28,0xcec1a401,0x84d3c886,0x0000d2fd,0x4a12be7a,0x2c516053,0x66430cd4,0xe290c452,0xa882a8d5,0xcec176fc,0x84d31a7b}, + [16]uint32{0x00000000,0x0874707f,0x0063cc03,0x0817bc7c,0x101820da,0x186c50a5,0x107becd9,0x180f9ca6,0x00110011,0x0865706e,0x0072cc12,0x0806bc6d,0x100920cb,0x187d50b4,0x106aecc8,0x181e9cb7}, + [16]uint32{0x3f800000,0x3f843a38,0x3f8031e6,0x3f840bde,0x3f880c10,0x3f8c3628,0x3f883df6,0x3f8c07ce,0x3f800880,0x3f8432b8,0x3f803966,0x3f84035e,0x3f880490,0x3f8c3ea8,0x3f883576,0x3f8c0f4e}, + uint32(0xfff80000), + [21]string{"0xc6","0x3f","0x57","0xc9","0x84","0x7a","0xfe","0x04","0xa0","0x91","0xba","0xea","0xb4","0xec","0x03","0x62","0x0a","0x8b","0xb5","0x90","0x00"} }, + { + /* No.363 delta:909 weight:957 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x03661a42,0x87294fa0,0x844f55e2,0x87b016b1,0x84d60cf3,0x00995911,0x03ff4353,0x00006897,0x036672d5,0x87292737,0x844f3d75,0x87b07e26,0x84d66464,0x00993186,0x03ff2bc4}, + [16]uint32{0x00000000,0x101602db,0x0201841c,0x121786c7,0x00405013,0x105652c8,0x0241d40f,0x1257d6d4,0x10020016,0x001402cd,0x1203840a,0x021586d1,0x10425005,0x005452de,0x1243d419,0x0255d6c2}, + [16]uint32{0x3f800000,0x3f880b01,0x3f8100c2,0x3f890bc3,0x3f802028,0x3f882b29,0x3f8120ea,0x3f892beb,0x3f880100,0x3f800a01,0x3f8901c2,0x3f810ac3,0x3f882128,0x3f802a29,0x3f8921ea,0x3f812aeb}, + uint32(0xfff80000), + [21]string{"0x7a","0x5d","0xdd","0x4b","0xea","0x67","0x23","0x48","0xe6","0xf0","0x1d","0x7d","0x70","0xc2","0xb6","0x1a","0x1f","0x0b","0x6e","0x1c","0x00"} }, + { + /* No.364 delta:1121 weight:1379 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xf75fa322,0x25af2d0a,0xd2f08e28,0x9b1016c8,0x6c4fb5ea,0xbebf3bc2,0x49e098e0,0x00002571,0xf75f8653,0x25af087b,0xd2f0ab59,0x9b1033b9,0x6c4f909b,0xbebf1eb3,0x49e0bd91}, + [16]uint32{0x00000000,0x4846b97e,0x600400f4,0x2842b98a,0x0040a16b,0x48061815,0x6044a19f,0x280218e1,0x00036218,0x4845db66,0x600762ec,0x2841db92,0x0043c373,0x48057a0d,0x6047c387,0x28017af9}, + [16]uint32{0x3f800000,0x3fa4235c,0x3fb00200,0x3f94215c,0x3f802050,0x3fa4030c,0x3fb02250,0x3f94010c,0x3f8001b1,0x3fa422ed,0x3fb003b1,0x3f9420ed,0x3f8021e1,0x3fa402bd,0x3fb023e1,0x3f9400bd}, + uint32(0xfff80000), + [21]string{"0x1d","0x8e","0x0a","0xda","0xaf","0x74","0xe0","0xed","0x73","0xff","0xd0","0x1e","0x9c","0x74","0x10","0xfa","0x70","0x03","0x50","0x44","0x00"} }, + { + /* No.365 delta:746 weight:1697 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0xe80f1cc0,0xd0da24f8,0x38d53838,0xffc016dd,0x17cf0a1d,0x2f1a3225,0xc7152ee5,0x00002907,0xe80f35c7,0xd0da0dff,0x38d5113f,0xffc03fda,0x17cf231a,0x2f1a1b22,0xc71507e2}, + [16]uint32{0x00000000,0x006e5c92,0x00021394,0x006c4f06,0x20b0b138,0x20deedaa,0x20b2a2ac,0x20dcfe3e,0x00102091,0x007e7c03,0x00123305,0x007c6f97,0x20a091a9,0x20cecd3b,0x20a2823d,0x20ccdeaf}, + [16]uint32{0x3f800000,0x3f80372e,0x3f800109,0x3f803627,0x3f905858,0x3f906f76,0x3f905951,0x3f906e7f,0x3f800810,0x3f803f3e,0x3f800919,0x3f803e37,0x3f905048,0x3f906766,0x3f905141,0x3f90666f}, + uint32(0xfff80000), + [21]string{"0xb9","0xf4","0x84","0x25","0xe9","0xaf","0xca","0xa9","0x05","0x9e","0x09","0xdf","0xc1","0xc2","0xff","0x5d","0x9c","0xec","0x16","0xec","0x00"} }, + { + /* No.366 delta:1013 weight:1599 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0x240769b0,0xadd4325d,0x89d35bed,0xe4b016e0,0xc0b77f50,0x496424bd,0x6d634d0d,0x000021ea,0x2407485a,0xadd413b7,0x89d37a07,0xe4b0370a,0xc0b75eba,0x49640557,0x6d636ce7}, + [16]uint32{0x00000000,0x004ca13c,0x2918de15,0x29547f29,0x00353076,0x0079914a,0x292dee63,0x29614f5f,0x0004f0de,0x004851e2,0x291c2ecb,0x29508ff7,0x0031c0a8,0x007d6194,0x29291ebd,0x2965bf81}, + [16]uint32{0x3f800000,0x3f802650,0x3f948c6f,0x3f94aa3f,0x3f801a98,0x3f803cc8,0x3f9496f7,0x3f94b0a7,0x3f800278,0x3f802428,0x3f948e17,0x3f94a847,0x3f8018e0,0x3f803eb0,0x3f94948f,0x3f94b2df}, + uint32(0xfff80000), + [21]string{"0xb8","0x5b","0x3b","0x53","0xa9","0x4b","0x2d","0x9b","0x80","0x3f","0x17","0x1b","0x48","0xc0","0xcd","0x5a","0xb6","0x7d","0x93","0x54","0x00"} }, + { + /* No.367 delta:1230 weight:1517 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x570b7517,0x07ae9069,0x50a5e57e,0x143016fc,0x433b63eb,0x139e8695,0x4495f382,0x0000f479,0x570b816e,0x07ae6410,0x50a51107,0x1430e285,0x433b9792,0x139e72ec,0x449507fb}, + [16]uint32{0x00000000,0x005409be,0x201a613c,0x204e6882,0x200b22a4,0x205f2b1a,0x00114398,0x00454a26,0x40000011,0x405409af,0x601a612d,0x604e6893,0x600b22b5,0x605f2b0b,0x40114389,0x40454a37}, + [16]uint32{0x3f800000,0x3f802a04,0x3f900d30,0x3f902734,0x3f900591,0x3f902f95,0x3f8008a1,0x3f8022a5,0x3fa00000,0x3fa02a04,0x3fb00d30,0x3fb02734,0x3fb00591,0x3fb02f95,0x3fa008a1,0x3fa022a5}, + uint32(0xfff80000), + [21]string{"0x51","0x56","0x7a","0x39","0xc7","0xe7","0x00","0xdd","0x43","0x09","0xc8","0xa3","0x0a","0x02","0x38","0xfb","0x23","0x3a","0xe0","0xea","0x00"} }, + { + /* No.368 delta:1742 weight:1575 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0xbbb1bd4d,0x22f590fd,0x99442db0,0xe220170e,0x5991aa43,0xc0d587f3,0x7b643abe,0x00005856,0xbbb1e51b,0x22f5c8ab,0x994475e6,0xe2204f58,0x5991f215,0xc0d5dfa5,0x7b6462e8}, + [16]uint32{0x00000000,0x16287a36,0x10744419,0x065c3e2f,0x0a02201d,0x1c2a5a2b,0x1a766404,0x0c5e1e32,0x020c0307,0x14247931,0x1278471e,0x04503d28,0x080e231a,0x1e26592c,0x187a6703,0x0e521d35}, + [16]uint32{0x3f800000,0x3f8b143d,0x3f883a22,0x3f832e1f,0x3f850110,0x3f8e152d,0x3f8d3b32,0x3f862f0f,0x3f810601,0x3f8a123c,0x3f893c23,0x3f82281e,0x3f840711,0x3f8f132c,0x3f8c3d33,0x3f87290e}, + uint32(0xfff80000), + [21]string{"0xa1","0x4d","0xf4","0x27","0x3c","0x05","0x11","0x88","0x1e","0x46","0xa9","0x99","0x67","0xbc","0x85","0xbf","0x28","0x84","0x2e","0x5c","0x00"} }, + { + /* No.369 delta:726 weight:1493 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xc95e3084,0xc197c8f4,0x08c9f870,0x1ba01716,0xd2fe2792,0xda37dfe2,0x1369ef66,0x000044e4,0xc95e7460,0xc1978c10,0x08c9bc94,0x1ba053f2,0xd2fe6376,0xda379b06,0x1369ab82}, + [16]uint32{0x00000000,0x10220dfd,0x2041f206,0x3063fffb,0x00028011,0x10208dec,0x20437217,0x30617fea,0x20080e74,0x302a0389,0x0049fc72,0x106bf18f,0x200a8e65,0x30288398,0x004b7c63,0x1069719e}, + [16]uint32{0x3f800000,0x3f881106,0x3f9020f9,0x3f9831ff,0x3f800140,0x3f881046,0x3f9021b9,0x3f9830bf,0x3f900407,0x3f981501,0x3f8024fe,0x3f8835f8,0x3f900547,0x3f981441,0x3f8025be,0x3f8834b8}, + uint32(0xfff80000), + [21]string{"0xab","0xeb","0x3a","0x5e","0x71","0xac","0x42","0xdc","0x1f","0x31","0x75","0xad","0xa3","0x48","0x3e","0x93","0xe1","0xac","0xf7","0x8e","0x00"} }, + { + /* No.370 delta:1803 weight:1429 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0xce97c038,0xe6b97d49,0x282ebd71,0x82901720,0x4c07d718,0x64296a69,0xaabeaa51,0x0000a04b,0xce976073,0xe6b9dd02,0x282e1d3a,0x8290b76b,0x4c077753,0x6429ca22,0xaabe0a1a}, + [16]uint32{0x00000000,0x0d698b3e,0x02424bf5,0x0f2bc0cb,0x00c013b9,0x0da99887,0x0282584c,0x0febd372,0x00520378,0x0d3b8846,0x0210488d,0x0f79c3b3,0x009210c1,0x0dfb9bff,0x02d05b34,0x0fb9d00a}, + [16]uint32{0x3f800000,0x3f86b4c5,0x3f812125,0x3f8795e0,0x3f806009,0x3f86d4cc,0x3f81412c,0x3f87f5e9,0x3f802901,0x3f869dc4,0x3f810824,0x3f87bce1,0x3f804908,0x3f86fdcd,0x3f81682d,0x3f87dce8}, + uint32(0xfff80000), + [21]string{"0x62","0x9e","0x2a","0xf0","0xed","0xa4","0x3b","0x1b","0x80","0xbf","0xea","0x22","0x10","0x9b","0xb1","0xae","0x96","0xc1","0xb4","0x25","0x00"} }, + { + /* No.371 delta:909 weight:1601 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x92531619,0x1b699f68,0x893a8971,0xef301737,0x7d63012e,0xf459885f,0x660a9e46,0x000088cc,0x92539ed5,0x1b6917a4,0x893a01bd,0xef309ffb,0x7d6389e2,0xf4590093,0x660a168a}, + [16]uint32{0x00000000,0x40556436,0x604e63cf,0x201b07f9,0x1002001d,0x5057642b,0x704c63d2,0x301907e4,0x0003841a,0x4056e02c,0x604de7d5,0x201883e3,0x10018407,0x5054e031,0x704fe7c8,0x301a83fe}, + [16]uint32{0x3f800000,0x3fa02ab2,0x3fb02731,0x3f900d83,0x3f880100,0x3fa82bb2,0x3fb82631,0x3f980c83,0x3f8001c2,0x3fa02b70,0x3fb026f3,0x3f900c41,0x3f8800c2,0x3fa82a70,0x3fb827f3,0x3f980d41}, + uint32(0xfff80000), + [21]string{"0xab","0xcb","0x82","0x30","0xa8","0xd3","0x6a","0xa1","0x5b","0xdf","0x89","0xb8","0x21","0xa0","0xba","0x8f","0xe8","0xd6","0xd2","0x8d","0x00"} }, + { + /* No.372 delta:1110 weight:1457 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x9ea2eb89,0x9a5249dc,0x04f0a255,0x84c0174f,0x1a62fcc6,0x1e925e93,0x8030b51a,0x00000697,0x9ea2ed1e,0x9a524f4b,0x04f0a4c2,0x84c011d8,0x1a62fa51,0x1e925804,0x8030b38d}, + [16]uint32{0x00000000,0x107d1296,0x010344fa,0x117e566c,0x0002b9f3,0x107fab65,0x0101fd09,0x117cef9f,0x50032807,0x407e3a91,0x51006cfd,0x417d7e6b,0x500191f4,0x407c8362,0x5102d50e,0x417fc798}, + [16]uint32{0x3f800000,0x3f883e89,0x3f8081a2,0x3f88bf2b,0x3f80015c,0x3f883fd5,0x3f8080fe,0x3f88be77,0x3fa80194,0x3fa03f1d,0x3fa88036,0x3fa0bebf,0x3fa800c8,0x3fa03e41,0x3fa8816a,0x3fa0bfe3}, + uint32(0xfff80000), + [21]string{"0x15","0x2e","0x1b","0x3e","0x9b","0xda","0x1c","0xff","0x98","0x29","0xb1","0x7e","0xf5","0x47","0x1c","0xbc","0x67","0x3b","0xd0","0x4a","0x00"} }, + { + /* No.373 delta:890 weight:725 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0xf453124c,0x9133123d,0x65600071,0x6d601757,0x9933051b,0xfc53056a,0x08001726,0x00000732,0xf453157e,0x9133150f,0x65600743,0x6d601065,0x99330229,0xfc530258,0x08001014}, + [16]uint32{0x00000000,0x002f04d5,0x440d9817,0x44229cc2,0x0049b01f,0x0066b4ca,0x44442808,0x446b2cdd,0x200c8013,0x202384c6,0x64011804,0x642e1cd1,0x2045300c,0x206a34d9,0x6448a81b,0x6467acce}, + [16]uint32{0x3f800000,0x3f801782,0x3fa206cc,0x3fa2114e,0x3f8024d8,0x3f80335a,0x3fa22214,0x3fa23596,0x3f900640,0x3f9011c2,0x3fb2008c,0x3fb2170e,0x3f902298,0x3f90351a,0x3fb22454,0x3fb233d6}, + uint32(0xfff80000), + [21]string{"0x23","0x25","0x32","0x61","0x6d","0x7c","0xe0","0x06","0x40","0x4b","0x1c","0x66","0x52","0x30","0x1f","0xee","0xa1","0x54","0xc1","0xab","0x00"} }, + { + /* No.374 delta:919 weight:915 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0x9e5812ea,0xe62fe6ba,0x7877f450,0x30c0176d,0xae980587,0xd6eff1d7,0x48b7e33d,0x00002e3e,0x9e583cd4,0xe62fc884,0x7877da6e,0x30c03953,0xae982bb9,0xd6efdfe9,0x48b7cd03}, + [16]uint32{0x00000000,0x0077909a,0x400a8817,0x407d188d,0x4000e41f,0x40777485,0x000a6c08,0x007dfc92,0x404311c6,0x4034815c,0x004999d1,0x003e094b,0x0043f5d9,0x00346543,0x40497dce,0x403eed54}, + [16]uint32{0x3f800000,0x3f803bc8,0x3fa00544,0x3fa03e8c,0x3fa00072,0x3fa03bba,0x3f800536,0x3f803efe,0x3fa02188,0x3fa01a40,0x3f8024cc,0x3f801f04,0x3f8021fa,0x3f801a32,0x3fa024be,0x3fa01f76}, + uint32(0xfff80000), + [21]string{"0x6f","0x7d","0xf0","0x37","0xf9","0x32","0xc2","0x38","0x87","0x2f","0xac","0xd8","0xea","0x5e","0xcc","0x2a","0x14","0xb2","0x55","0xcc","0x00"} }, + { + /* No.375 delta:1049 weight:1571 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0x04209f4c,0x6f150bce,0x6b359482,0xdb501770,0xdf70883c,0xb4451cbe,0xb06583f2,0x000010de,0x04208f92,0x6f151b10,0x6b35845c,0xdb5007ae,0xdf7098e2,0xb4450c60,0xb065932c}, + [16]uint32{0x00000000,0x6065e433,0x0002881a,0x60676c29,0x70e108e2,0x1084ecd1,0x70e380f8,0x108664cb,0x0109621b,0x616c8628,0x010bea01,0x616e0e32,0x71e86af9,0x118d8eca,0x71eae2e3,0x118f06d0}, + [16]uint32{0x3f800000,0x3fb032f2,0x3f800144,0x3fb033b6,0x3fb87084,0x3f884276,0x3fb871c0,0x3f884332,0x3f8084b1,0x3fb0b643,0x3f8085f5,0x3fb0b707,0x3fb8f435,0x3f88c6c7,0x3fb8f571,0x3f88c783}, + uint32(0xfff80000), + [21]string{"0x35","0x60","0x49","0xb8","0x2a","0x1d","0x72","0x07","0x1f","0xe0","0x0d","0x14","0xc1","0xb7","0x9d","0x98","0x9e","0x0d","0x5b","0xd0","0x00"} }, + { + /* No.376 delta:944 weight:1451 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0xbc72f163,0x2dfbf47d,0x9189051e,0xb1b0178e,0x0dc2e6ed,0x9c4be3f3,0x20391290,0x0000b3b4,0xbc7242d7,0x2dfb47c9,0x9189b6aa,0xb1b0a43a,0x0dc25559,0x9c4b5047,0x2039a124}, + [16]uint32{0x00000000,0x10560972,0x04086049,0x145e693b,0x30042016,0x20522964,0x340c405f,0x245a492d,0x0002140c,0x10541d7e,0x040a7445,0x145c7d37,0x3006341a,0x20503d68,0x340e5453,0x24585d21}, + [16]uint32{0x3f800000,0x3f882b04,0x3f820430,0x3f8a2f34,0x3f980210,0x3f902914,0x3f9a0620,0x3f922d24,0x3f80010a,0x3f882a0e,0x3f82053a,0x3f8a2e3e,0x3f98031a,0x3f90281e,0x3f9a072a,0x3f922c2e}, + uint32(0xfff80000), + [21]string{"0xd0","0xf5","0x67","0x95","0x9d","0x13","0xd7","0x1d","0xe7","0xaa","0xf3","0xf9","0xa9","0x7f","0x6d","0x0a","0x13","0xc4","0xc6","0x41","0x00"} }, + { + /* No.377 delta:1088 weight:1285 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x5cc92a03,0x05adcc7e,0x5964e67d,0x84f0179f,0xd8393d9c,0x815ddbe1,0xdd94f1e2,0x000074d7,0x5cc95ed4,0x05adb8a9,0x596492aa,0x84f06348,0xd839494b,0x815daf36,0xdd948535}, + [16]uint32{0x00000000,0x007d1db6,0x80603213,0x801d2fa5,0x00021409,0x007f09bf,0x8062261a,0x801f3bac,0x00034808,0x007e55be,0x80637a1b,0x801e67ad,0x00015c01,0x007c41b7,0x80616e12,0x801c73a4}, + [16]uint32{0x3f800000,0x3f803e8e,0x3fc03019,0x3fc00e97,0x3f80010a,0x3f803f84,0x3fc03113,0x3fc00f9d,0x3f8001a4,0x3f803f2a,0x3fc031bd,0x3fc00f33,0x3f8000ae,0x3f803e20,0x3fc030b7,0x3fc00e39}, + uint32(0xfff80000), + [21]string{"0x31","0xac","0x55","0xef","0xb3","0x54","0x1b","0x51","0xe0","0x64","0xc0","0xcc","0x09","0x1f","0x95","0xb6","0x75","0x9e","0x9f","0x3a","0x00"} }, + { + /* No.378 delta:824 weight:729 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0xf4f93c6a,0x8692c625,0x726bfa4f,0x29e017a1,0xdd192bcb,0xaf72d184,0x5b8bedee,0x0000a26b,0xf4f99e01,0x8692644e,0x726b5824,0x29e0b5ca,0xdd1989a0,0xaf7273ef,0x5b8b4f85}, + [16]uint32{0x00000000,0x503005de,0x087d481c,0x584d4dc2,0x0068340b,0x505831d5,0x08157c17,0x582579c9,0x48000013,0x183005cd,0x407d480f,0x104d4dd1,0x48683418,0x185831c6,0x40157c04,0x102579da}, + [16]uint32{0x3f800000,0x3fa81802,0x3f843ea4,0x3fac26a6,0x3f80341a,0x3fa82c18,0x3f840abe,0x3fac12bc,0x3fa40000,0x3f8c1802,0x3fa03ea4,0x3f8826a6,0x3fa4341a,0x3f8c2c18,0x3fa00abe,0x3f8812bc}, + uint32(0xfff80000), + [21]string{"0x31","0x0d","0x9b","0x5d","0xb9","0xe2","0xc6","0x14","0xa1","0x82","0x69","0x5e","0xb0","0xd0","0x2a","0xf8","0x03","0x22","0x85","0xff","0x00"} }, + { + /* No.379 delta:2050 weight:1585 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x9952c50d,0xedce1744,0x749cd249,0x08c017b5,0x9192d2b8,0xe50e00f1,0x7c5cc5fc,0x00003690,0x9952f39d,0xedce21d4,0x749ce4d9,0x08c02125,0x9192e428,0xe50e3661,0x7c5cf36c}, + [16]uint32{0x00000000,0x405ce3d3,0x00520074,0x400ee3a7,0x00280196,0x4074e245,0x007a01e2,0x4026e231,0x741001bd,0x344ce26e,0x744201c9,0x341ee21a,0x7438002b,0x3464e3f8,0x746a005f,0x3436e38c}, + [16]uint32{0x3f800000,0x3fa02e71,0x3f802900,0x3fa00771,0x3f801400,0x3fa03a71,0x3f803d00,0x3fa01371,0x3fba0800,0x3f9a2671,0x3fba2100,0x3f9a0f71,0x3fba1c00,0x3f9a3271,0x3fba3500,0x3f9a1b71}, + uint32(0xfff80000), + [21]string{"0xcb","0x23","0x2d","0xee","0x59","0x7d","0xc7","0x51","0x3a","0x51","0x5c","0xa9","0xa0","0x85","0xac","0xc6","0x53","0xf4","0xd9","0x8f","0x00"} }, + { + /* No.380 delta:734 weight:755 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x3a4dd5b2,0x9f753afe,0xa538ef4c,0x6d4017c6,0x570dc274,0xf2352d38,0xc878f88a,0x00003f8f,0x3a4dea3d,0x9f750571,0xa538d0c3,0x6d402849,0x570dfdfb,0xf23512b7,0xc878c705}, + [16]uint32{0x00000000,0x41e8019a,0x51420043,0x10aa01d9,0x0c11a13c,0x4df9a0a6,0x5d53a17f,0x1cbba0e5,0x0144a217,0x40aca38d,0x5006a254,0x11eea3ce,0x0d55032b,0x4cbd02b1,0x5c170368,0x1dff02f2}, + [16]uint32{0x3f800000,0x3fa0f400,0x3fa8a100,0x3f885500,0x3f8608d0,0x3fa6fcd0,0x3faea9d0,0x3f8e5dd0,0x3f80a251,0x3fa05651,0x3fa80351,0x3f88f751,0x3f86aa81,0x3fa65e81,0x3fae0b81,0x3f8eff81}, + uint32(0xfff80000), + [21]string{"0x02","0x93","0x13","0xd2","0x2d","0xc3","0xcf","0xcb","0x72","0x8d","0xed","0x7d","0x79","0x71","0x4c","0x5d","0xf2","0x35","0x52","0xc4","0x00"} }, + { + /* No.381 delta:695 weight:1327 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0x4a2d336a,0xcbcd0b4d,0x81e03827,0x3c4017d2,0x766d24b8,0xf78d1c9f,0xbda02ff5,0x00003940,0x4a2d0a2a,0xcbcd320d,0x81e00167,0x3c402e92,0x766d1df8,0xf78d25df,0xbda016b5}, + [16]uint32{0x00000000,0x406c491f,0x0018165c,0x40745f43,0x5a8c40bd,0x1ae009a2,0x5a9456e1,0x1af81ffe,0x40080196,0x00644889,0x401017ca,0x007c5ed5,0x1a84412b,0x5ae80834,0x1a9c5777,0x5af01e68}, + [16]uint32{0x3f800000,0x3fa03624,0x3f800c0b,0x3fa03a2f,0x3fad4620,0x3f8d7004,0x3fad4a2b,0x3f8d7c0f,0x3fa00400,0x3f803224,0x3fa0080b,0x3f803e2f,0x3f8d4220,0x3fad7404,0x3f8d4e2b,0x3fad780f}, + uint32(0xfff80000), + [21]string{"0x68","0xc4","0x49","0x1c","0x51","0x0b","0xd4","0xe5","0xf4","0xe0","0x12","0xf8","0xfa","0xd2","0x93","0x37","0x42","0x7a","0x25","0x28","0x00"} }, + { + /* No.382 delta:1075 weight:1435 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0xb1b67f06,0x407a2626,0xf1cc5920,0xf21017e8,0x43a668ee,0xb26a31ce,0x03dc4ec8,0x00004cda,0xb1b633dc,0x407a6afc,0xf1cc15fa,0xf2105b32,0x43a62434,0xb26a7d14,0x03dc0212}, + [16]uint32{0x00000000,0x004611bb,0x2002c02d,0x2044d196,0x20032074,0x204531cf,0x0001e059,0x0047f1e2,0x0002109e,0x00440125,0x2000d0b3,0x2046c108,0x200130ea,0x20472151,0x0003f0c7,0x0045e17c}, + [16]uint32{0x3f800000,0x3f802308,0x3f900160,0x3f902268,0x3f900190,0x3f902298,0x3f8000f0,0x3f8023f8,0x3f800108,0x3f802200,0x3f900068,0x3f902360,0x3f900098,0x3f902390,0x3f8001f8,0x3f8022f0}, + uint32(0xfff80000), + [21]string{"0x19","0xfc","0x70","0xab","0x75","0x6b","0x2f","0xe6","0x9d","0xe6","0xda","0xd0","0xf4","0x08","0xd7","0xb2","0xc5","0xfa","0xbc","0xe7","0x00"} }, + { + /* No.383 delta:1078 weight:1421 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x9ea2eb89,0x9a5249dc,0x04f0a255,0x84c017ff,0x1a62fc76,0x1e925e23,0x8030b5aa,0x00000697,0x9ea2ed1e,0x9a524f4b,0x04f0a4c2,0x84c01168,0x1a62fae1,0x1e9258b4,0x8030b33d}, + [16]uint32{0x00000000,0x800d0816,0x40274a07,0xc02a4211,0x4002e9e2,0xc00fe1f4,0x0025a3e5,0x8028abf3,0x4001d089,0xc00cd89f,0x00269a8e,0x802b9298,0x0003396b,0x800e317d,0x4024736c,0xc0297b7a}, + [16]uint32{0x3f800000,0x3fc00684,0x3fa013a5,0x3fe01521,0x3fa00174,0x3fe007f0,0x3f8012d1,0x3fc01455,0x3fa000e8,0x3fe0066c,0x3f80134d,0x3fc015c9,0x3f80019c,0x3fc00718,0x3fa01239,0x3fe014bd}, + uint32(0xfff80000), + [21]string{"0x47","0xdd","0x7a","0x23","0xe4","0x00","0xb0","0x59","0xae","0xb2","0xdf","0xfd","0x21","0x35","0xb9","0xdd","0xe9","0x91","0x8e","0xd1","0x00"} }, + { + /* No.384 delta:614 weight:1663 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x789bd9b9,0xe1471eb4,0x99dcc70d,0x92401808,0xeadbc1b1,0x730706bc,0x0b9cdf05,0x0000cbdb,0x789b1262,0xe147d56f,0x99dc0cd6,0x9240d3d3,0xeadb0a6a,0x7307cd67,0x0b9c14de}, + [16]uint32{0x00000000,0x00421735,0x5130081e,0x51721f2b,0x00037267,0x00416552,0x51337a79,0x51716d4c,0x201c080f,0x205e1f3a,0x712c0011,0x716e1724,0x201f7a68,0x205d6d5d,0x712f7276,0x716d6543}, + [16]uint32{0x3f800000,0x3f80210b,0x3fa89804,0x3fa8b90f,0x3f8001b9,0x3f8020b2,0x3fa899bd,0x3fa8b8b6,0x3f900e04,0x3f902f0f,0x3fb89600,0x3fb8b70b,0x3f900fbd,0x3f902eb6,0x3fb897b9,0x3fb8b6b2}, + uint32(0xfff80000), + [21]string{"0xf5","0x82","0x42","0x91","0xec","0xcf","0x55","0x4c","0x99","0x8d","0x85","0xa5","0xbe","0x5b","0xd2","0xc7","0xe7","0x67","0x93","0x4d","0x00"} }, + { + /* No.385 delta:1194 weight:1183 */ + 11213, + 36, + 13, + 4, + [16]uint32{0x00000000,0x42c7329a,0x61c85650,0x230f64ca,0xc3e01810,0x81272a8a,0xa2284e40,0xe0ef7cda,0x00005450,0x42c766ca,0x61c80200,0x230f309a,0xc3e04c40,0x81277eda,0xa2281a10,0xe0ef288a}, + [16]uint32{0x00000000,0x006e85ff,0x2013c012,0x207d45ed,0x0003af3c,0x006d2ac3,0x20106f2e,0x207eead1,0x00004017,0x006ec5e8,0x20138005,0x207d05fa,0x0003ef2b,0x006d6ad4,0x20102f39,0x207eaac6}, + [16]uint32{0x3f800000,0x3f803742,0x3f9009e0,0x3f903ea2,0x3f8001d7,0x3f803695,0x3f900837,0x3f903f75,0x3f800020,0x3f803762,0x3f9009c0,0x3f903e82,0x3f8001f7,0x3f8036b5,0x3f900817,0x3f903f55}, + uint32(0xfff80000), + [21]string{"0x73","0x10","0xc3","0x30","0xe6","0xff","0xe1","0x72","0x2d","0x2f","0xd3","0xcc","0xf0","0x3f","0xc6","0xa4","0x5d","0x80","0x4a","0x2e","0x00"} }, + { + /* No.386 delta:1854 weight:1525 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x07bb317a,0x40213aa8,0x479a0bd2,0xa250182b,0xa5eb2951,0xe2712283,0xe5ca13f9,0x000070c0,0x07bb41ba,0x40214a68,0x479a7b12,0xa25068eb,0xa5eb5991,0xe2715243,0xe5ca6339}, + [16]uint32{0x00000000,0x0d0e8dfe,0x0883c857,0x058d45a9,0x0e904963,0x039ec49d,0x06138134,0x0b1d0cca,0x21ad841a,0x2ca309e4,0x292e4c4d,0x2420c1b3,0x2f3dcd79,0x22334087,0x27be052e,0x2ab088d0}, + [16]uint32{0x3f800000,0x3f868746,0x3f8441e4,0x3f82c6a2,0x3f874824,0x3f81cf62,0x3f8309c0,0x3f858e86,0x3f90d6c2,0x3f965184,0x3f949726,0x3f921060,0x3f979ee6,0x3f9119a0,0x3f93df02,0x3f955844}, + uint32(0xfff80000), + [21]string{"0x98","0x61","0xd2","0x1b","0xb5","0x8e","0x0a","0x6e","0xcd","0xb3","0x70","0xf9","0x2e","0x52","0x5d","0x61","0xfb","0xd9","0x99","0xc0","0x00"} }, + { + /* No.387 delta:761 weight:1663 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x51346d03,0x2b2d40e1,0x7a192de2,0x50001831,0x01347532,0x7b2d58d0,0x2a1935d3,0x00009492,0x5134f991,0x2b2dd473,0x7a19b970,0x50008ca3,0x0134e1a0,0x7b2dcc42,0x2a19a141}, + [16]uint32{0x00000000,0x00663497,0x60000dbb,0x6066392c,0x20002572,0x206611e5,0x400028c9,0x40661c5e,0x50023c0d,0x5064089a,0x300231b6,0x30640521,0x7002197f,0x70642de8,0x100214c4,0x10642053}, + [16]uint32{0x3f800000,0x3f80331a,0x3fb00006,0x3fb0331c,0x3f900012,0x3f903308,0x3fa00014,0x3fa0330e,0x3fa8011e,0x3fa83204,0x3f980118,0x3f983202,0x3fb8010c,0x3fb83216,0x3f88010a,0x3f883210}, + uint32(0xfff80000), + [21]string{"0xec","0xef","0xbe","0x73","0xaa","0x5e","0x52","0xe9","0xe7","0x75","0x1d","0x4b","0x52","0xcc","0x2b","0xa9","0x97","0x9b","0x11","0x9c","0x00"} }, + { + /* No.388 delta:1533 weight:1351 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0xe8a1238a,0x12bbf47c,0xfa1ad7f6,0x73b0184c,0x9b113bc6,0x610bec30,0x89aacfba,0x00005821,0xe8a17bab,0x12bbac5d,0xfa1a8fd7,0x73b0406d,0x9b1163e7,0x610bb411,0x89aa979b}, + [16]uint32{0x00000000,0x0839217d,0x006c81d2,0x0855a0af,0x00122003,0x082b017e,0x007ea1d1,0x084780ac,0x00022018,0x083b0165,0x006ea1ca,0x085780b7,0x0010001b,0x08292166,0x007c81c9,0x0845a0b4}, + [16]uint32{0x3f800000,0x3f841c90,0x3f803640,0x3f842ad0,0x3f800910,0x3f841580,0x3f803f50,0x3f8423c0,0x3f800110,0x3f841d80,0x3f803750,0x3f842bc0,0x3f800800,0x3f841490,0x3f803e40,0x3f8422d0}, + uint32(0xfff80000), + [21]string{"0x92","0x60","0x0d","0x80","0xe9","0x33","0x2d","0x46","0x2b","0xf2","0xb4","0x32","0x74","0x9b","0xf8","0x99","0xf8","0xc3","0x2e","0x86","0x00"} }, + { + /* No.389 delta:873 weight:1257 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0x9fbb556e,0xb88be20a,0x2730b764,0x35c01850,0xaa7b4d3e,0x8d4bfa5a,0x12f0af34,0x0000bc4d,0x9fbbe923,0xb88b5e47,0x27300b29,0x35c0a41d,0xaa7bf173,0x8d4b4617,0x12f01379}, + [16]uint32{0x00000000,0x71341c1e,0x104378c2,0x617764dc,0x0001e91b,0x7135f505,0x104291d9,0x61768dc7,0x102424ce,0x611038d0,0x00675c0c,0x71534012,0x1025cdd5,0x6111d1cb,0x0066b517,0x7152a909}, + [16]uint32{0x3f800000,0x3fb89a0e,0x3f8821bc,0x3fb0bbb2,0x3f8000f4,0x3fb89afa,0x3f882148,0x3fb0bb46,0x3f881212,0x3fb0881c,0x3f8033ae,0x3fb8a9a0,0x3f8812e6,0x3fb088e8,0x3f80335a,0x3fb8a954}, + uint32(0xfff80000), + [21]string{"0x0d","0x4f","0x87","0x46","0x77","0xdc","0xa2","0xd6","0x85","0x1a","0x61","0xa3","0x3e","0x03","0x0f","0xe7","0xc8","0xb9","0x0a","0x8d","0x00"} }, + { + /* No.390 delta:2038 weight:1291 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x5164b2ef,0x2c1644e0,0x7d72f60f,0xd410186b,0x8574aa84,0xf8065c8b,0xa962ee64,0x0000382d,0x51648ac2,0x2c167ccd,0x7d72ce22,0xd4102046,0x857492a9,0xf80664a6,0xa962d649}, + [16]uint32{0x00000000,0x1228803c,0x0b08d5cb,0x192055f7,0x0f64c15f,0x1d4c4163,0x046c1494,0x164494a8,0x32604199,0x2048c1a5,0x39689452,0x2b40146e,0x3d0480c6,0x2f2c00fa,0x360c550d,0x2424d531}, + [16]uint32{0x3f800000,0x3f891440,0x3f85846a,0x3f8c902a,0x3f87b260,0x3f8ea620,0x3f82360a,0x3f8b224a,0x3f993020,0x3f902460,0x3f9cb44a,0x3f95a00a,0x3f9e8240,0x3f979600,0x3f9b062a,0x3f92126a}, + uint32(0xfff80000), + [21]string{"0x32","0x79","0x3b","0xa6","0x82","0x51","0x24","0x1e","0xe8","0x3c","0xb9","0x62","0x18","0x8d","0x76","0x6e","0x20","0xc4","0x51","0xf8","0x00"} }, + { + /* No.391 delta:1140 weight:1415 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xc9aa39b4,0xc7d85494,0x0e726d20,0x2cc0187a,0xe56a21ce,0xeb184cee,0x22b2755a,0x00005a62,0xc9aa63d6,0xc7d80ef6,0x0e723742,0x2cc04218,0xe56a7bac,0xeb18168c,0x22b22f38}, + [16]uint32{0x00000000,0x60029c1d,0xb00da012,0xd00f3c0f,0x0002010e,0x60009d13,0xb00fa11c,0xd00d3d01,0x00501135,0x60528d28,0xb05db127,0xd05f2d3a,0x0052103b,0x60508c26,0xb05fb029,0xd05d2c34}, + [16]uint32{0x3f800000,0x3fb0014e,0x3fd806d0,0x3fe8079e,0x3f800100,0x3fb0004e,0x3fd807d0,0x3fe8069e,0x3f802808,0x3fb02946,0x3fd82ed8,0x3fe82f96,0x3f802908,0x3fb02846,0x3fd82fd8,0x3fe82e96}, + uint32(0xfff80000), + [21]string{"0x69","0x24","0xff","0x79","0xe9","0x53","0xd5","0x66","0xbd","0x7a","0x4d","0x67","0xd3","0x60","0x34","0x64","0x08","0x18","0x9f","0x93","0x00"} }, + { + /* No.392 delta:2336 weight:1173 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x14bfc97b,0x293ec8a0,0x3d8101db,0x39d0188f,0x2d6fd1f4,0x10eed02f,0x04511954,0x00008d1e,0x14bf4465,0x293e45be,0x3d818cc5,0x39d09591,0x2d6f5cea,0x10ee5d31,0x0451944a}, + [16]uint32{0x00000000,0xe0c6035e,0x1c3a4547,0xfcfc4619,0x021307e3,0xe2d504bd,0x1e2942a4,0xfeef41fa,0x0041c16b,0xe087c235,0x1c7b842c,0xfcbd8772,0x0252c688,0xe294c5d6,0x1e6883cf,0xfeae8091}, + [16]uint32{0x3f800000,0x3ff06301,0x3f8e1d22,0x3ffe7e23,0x3f810983,0x3ff16a82,0x3f8f14a1,0x3fff77a0,0x3f8020e0,0x3ff043e1,0x3f8e3dc2,0x3ffe5ec3,0x3f812963,0x3ff14a62,0x3f8f3441,0x3fff5740}, + uint32(0xfff80000), + [21]string{"0xa1","0xc3","0xef","0xa2","0xbd","0xe7","0xcf","0xfc","0xfd","0x80","0x13","0x97","0xa4","0x66","0x96","0x1e","0xdd","0x51","0xed","0xf0","0x00"} }, + { + /* No.393 delta:871 weight:1573 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0xda1efd75,0x44ba0c25,0x9ea4f150,0x9970189f,0x436ee5ea,0xddca14ba,0x07d4e9cf,0x00008611,0xda1e7b64,0x44ba8a34,0x9ea47741,0x99709e8e,0x436e63fb,0xddca92ab,0x07d46fde}, + [16]uint32{0x00000000,0x000301ff,0xa000c1bd,0xa003c042,0x00006817,0x000369e8,0xa000a9aa,0xa003a855,0x2054861a,0x205787e5,0x805447a7,0x80574658,0x2054ee0d,0x2057eff2,0x80542fb0,0x80572e4f}, + [16]uint32{0x3f800000,0x3f800180,0x3fd00060,0x3fd001e0,0x3f800034,0x3f8001b4,0x3fd00054,0x3fd001d4,0x3f902a43,0x3f902bc3,0x3fc02a23,0x3fc02ba3,0x3f902a77,0x3f902bf7,0x3fc02a17,0x3fc02b97}, + uint32(0xfff80000), + [21]string{"0xc1","0xf0","0x4a","0x60","0x21","0xed","0xe8","0x38","0xd1","0xac","0x26","0xbf","0xde","0xc7","0xed","0xa3","0xc7","0xe6","0x06","0x38","0x00"} }, + { + /* No.394 delta:1517 weight:1705 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x786dc002,0x7926fdb6,0x014b3db4,0xaf2018aa,0xd74dd8a8,0xd606e51c,0xae6b251e,0x0000c70a,0x786d0708,0x79263abc,0x014bfabe,0xaf20dfa0,0xd74d1fa2,0xd6062216,0xae6be214}, + [16]uint32{0x00000000,0x484b915b,0x0047f8d8,0x480c6983,0x440a809d,0x0c4111c6,0x444d7845,0x0c06e91e,0x02282116,0x4a63b04d,0x026fd9ce,0x4a244895,0x4622a18b,0x0e6930d0,0x46655953,0x0e2ec808}, + [16]uint32{0x3f800000,0x3fa425c8,0x3f8023fc,0x3fa40634,0x3fa20540,0x3f862088,0x3fa226bc,0x3f860374,0x3f811410,0x3fa531d8,0x3f8137ec,0x3fa51224,0x3fa31150,0x3f873498,0x3fa332ac,0x3f871764}, + uint32(0xfff80000), + [21]string{"0xbc","0xf2","0xae","0x6c","0x1a","0x34","0x9b","0x5d","0x7c","0x65","0x7b","0x77","0x57","0x31","0xaa","0x37","0x42","0xe0","0x3f","0x31","0x00"} }, + { + /* No.395 delta:1035 weight:1367 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x143d8e44,0x3d637843,0x295ef607,0x8a3018bd,0x9e0d96f9,0xb75360fe,0xa36eeeba,0x00009dc3,0x143d1387,0x3d63e580,0x295e6bc4,0x8a30857e,0x9e0d0b3a,0xb753fd3d,0xa36e7379}, + [16]uint32{0x00000000,0x00037416,0x20440409,0x2047701f,0x1010121b,0x1013660d,0x30541612,0x30576204,0x4066b1ce,0x4065c5d8,0x6022b5c7,0x6021c1d1,0x5076a3d5,0x5075d7c3,0x7032a7dc,0x7031d3ca}, + [16]uint32{0x3f800000,0x3f8001ba,0x3f902202,0x3f9023b8,0x3f880809,0x3f8809b3,0x3f982a0b,0x3f982bb1,0x3fa03358,0x3fa032e2,0x3fb0115a,0x3fb010e0,0x3fa83b51,0x3fa83aeb,0x3fb81953,0x3fb818e9}, + uint32(0xfff80000), + [21]string{"0x15","0x55","0xb5","0x38","0xbd","0x13","0xe4","0xa7","0xd1","0x20","0x66","0x03","0x26","0x71","0x19","0xfa","0x2c","0x03","0xeb","0xcb","0x00"} }, + { + /* No.396 delta:722 weight:1445 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x6552a43b,0x4a6b1404,0x2f39b03f,0x9a7018c3,0xff22bcf8,0xd01b0cc7,0xb549a8fc,0x0000fe80,0x65525abb,0x4a6bea84,0x2f394ebf,0x9a70e643,0xff224278,0xd01bf247,0xb549567c}, + [16]uint32{0x00000000,0x103e11be,0x0003044b,0x103d15f5,0x503b3654,0x400527ea,0x5038321f,0x400623a1,0x0002bc06,0x103cadb8,0x0001b84d,0x103fa9f3,0x50398a52,0x40079bec,0x503a8e19,0x40049fa7}, + [16]uint32{0x3f800000,0x3f881f08,0x3f800182,0x3f881e8a,0x3fa81d9b,0x3fa00293,0x3fa81c19,0x3fa00311,0x3f80015e,0x3f881e56,0x3f8000dc,0x3f881fd4,0x3fa81cc5,0x3fa003cd,0x3fa81d47,0x3fa0024f}, + uint32(0xfff80000), + [21]string{"0xad","0x8a","0xfd","0x27","0xb8","0x3e","0x15","0x8a","0x49","0x48","0xd9","0xd7","0x59","0x94","0xb0","0x87","0xfc","0x57","0x26","0xf4","0x00"} }, + { + /* No.397 delta:840 weight:1603 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x669d918e,0xdcb4eaab,0xba297b25,0x581018d3,0x3e8d895d,0x84a4f278,0xe23963f6,0x00000e05,0x669d9f8b,0xdcb4e4ae,0xba297520,0x581016d6,0x3e8d8758,0x84a4fc7d,0xe2396df3}, + [16]uint32{0x00000000,0xa0215816,0x2001aab4,0x8020f2a2,0x002258ee,0xa00300f8,0x2023f25a,0x8002aa4c,0x4000621e,0xe0213a08,0x6001c8aa,0xc02090bc,0x40223af0,0xe00362e6,0x60239044,0xc002c852}, + [16]uint32{0x3f800000,0x3fd010ac,0x3f9000d5,0x3fc01079,0x3f80112c,0x3fd00180,0x3f9011f9,0x3fc00155,0x3fa00031,0x3ff0109d,0x3fb000e4,0x3fe01048,0x3fa0111d,0x3ff001b1,0x3fb011c8,0x3fe00164}, + uint32(0xfff80000), + [21]string{"0x75","0x9a","0x24","0xfc","0x18","0x38","0x61","0xb9","0xb3","0x13","0xb4","0xcb","0xd5","0xae","0xfa","0x52","0x8f","0x60","0x2a","0x4f","0x00"} }, + { + /* No.398 delta:1725 weight:1293 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x46ab68d5,0x5c04de2b,0x1aafb6fe,0xe52018ec,0xa38b7039,0xb924c6c7,0xff8fae12,0x00009d52,0x46abf587,0x5c044379,0x1aaf2bac,0xe52085be,0xa38bed6b,0xb9245b95,0xff8f3340}, + [16]uint32{0x00000000,0x007c01d6,0x004400f5,0x00380123,0x0000015f,0x007c0089,0x004401aa,0x0038007c,0x0041001e,0x003d01c8,0x000500eb,0x0079013d,0x00410141,0x003d0097,0x000501b4,0x00790062}, + [16]uint32{0x3f800000,0x3f803e00,0x3f802200,0x3f801c00,0x3f800000,0x3f803e00,0x3f802200,0x3f801c00,0x3f802080,0x3f801e80,0x3f800280,0x3f803c80,0x3f802080,0x3f801e80,0x3f800280,0x3f803c80}, + uint32(0xfff80000), + [21]string{"0xdb","0x63","0x57","0xb1","0xff","0x25","0x5b","0x3f","0xb8","0x43","0xa0","0x6d","0x1c","0x80","0x82","0x9d","0x33","0x74","0x52","0xf1","0x00"} }, + { + /* No.399 delta:780 weight:1553 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0x1807b5d7,0x79b56b4c,0x61b2de9b,0x334018f9,0x2b47ad2e,0x4af573b5,0x52f2c662,0x0000df01,0x18076ad6,0x79b5b44d,0x61b2019a,0x3340c7f8,0x2b47722f,0x4af5acb4,0x52f21963}, + [16]uint32{0x00000000,0x00040952,0x60212011,0x60252943,0x10001526,0x10041c74,0x70213537,0x70253c65,0x40000a1a,0x40040348,0x20212a0b,0x20252359,0x50001f3c,0x5004166e,0x30213f2d,0x3025367f}, + [16]uint32{0x3f800000,0x3f800204,0x3fb01090,0x3fb01294,0x3f88000a,0x3f88020e,0x3fb8109a,0x3fb8129e,0x3fa00005,0x3fa00201,0x3f901095,0x3f901291,0x3fa8000f,0x3fa8020b,0x3f98109f,0x3f98129b}, + uint32(0xfff80000), + [21]string{"0x3d","0xe1","0x0e","0xa7","0x85","0xab","0xc6","0xe8","0x6f","0x4b","0xcd","0xbb","0xd5","0xa4","0x09","0xa9","0x26","0x43","0xbc","0xfe","0x00"} }, + { + /* No.400 delta:2266 weight:1249 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0xe2dbfe7d,0xd0e935c8,0x3232cbb5,0xff001901,0x1ddbe77c,0x2fe92cc9,0xcd32d2b4,0x0000f8d9,0xe2db06a4,0xd0e9cd11,0x3232336c,0xff00e1d8,0x1ddb1fa5,0x2fe9d410,0xcd322a6d}, + [16]uint32{0x00000000,0x0a4380b6,0x120148e9,0x1842c85f,0x2140981d,0x2b0318ab,0x3341d0f4,0x39025042,0x700000a7,0x7a438011,0x6201484e,0x6842c8f8,0x514098ba,0x5b03180c,0x4341d053,0x490250e5}, + [16]uint32{0x3f800000,0x3f8521c0,0x3f8900a4,0x3f8c2164,0x3f90a04c,0x3f95818c,0x3f99a0e8,0x3f9c8128,0x3fb80000,0x3fbd21c0,0x3fb100a4,0x3fb42164,0x3fa8a04c,0x3fad818c,0x3fa1a0e8,0x3fa48128}, + uint32(0xfff80000), + [21]string{"0x36","0x58","0x6f","0x1a","0x58","0x7f","0x55","0xac","0x11","0x3e","0x26","0x32","0x97","0xb7","0x1a","0x18","0x6a","0x72","0x2a","0xbe","0x00"} }, + { + /* No.401 delta:2650 weight:873 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0xe1aed356,0x5e9f273a,0xbf31f46c,0xa2e01919,0x434eca4f,0xfc7f3e23,0x1dd1ed75,0x000081de,0xe1ae5288,0x5e9fa6e4,0xbf3175b2,0xa2e098c7,0x434e4b91,0xfc7fbffd,0x1dd16cab}, + [16]uint32{0x00000000,0xc0706532,0x280209b8,0xe8726c8a,0xd6906019,0x16e0052b,0xfe9269a1,0x3ee20c93,0x22991407,0xe2e97135,0x0a9b1dbf,0xcaeb788d,0xf409741e,0x3479112c,0xdc0b7da6,0x1c7b1894}, + [16]uint32{0x3f800000,0x3fe03832,0x3f940104,0x3ff43936,0x3feb4830,0x3f8b7002,0x3fff4934,0x3f9f7106,0x3f914c8a,0x3ff174b8,0x3f854d8e,0x3fe575bc,0x3ffa04ba,0x3f9a3c88,0x3fee05be,0x3f8e3d8c}, + uint32(0xfff80000), + [21]string{"0x33","0x8e","0xa6","0x98","0x68","0xf0","0x3f","0x0f","0xc5","0xf7","0x8e","0x62","0x24","0xf2","0x8f","0x37","0x53","0xf4","0x2d","0x6b","0x00"} }, + { + /* No.402 delta:983 weight:1731 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x94aa7ca2,0x2140e274,0xb5ea9ed6,0x6c201925,0xf88a6587,0x4d60fb51,0xd9ca87f3,0x0000da27,0x94aaa685,0x21403853,0xb5ea44f1,0x6c20c302,0xf88abfa0,0x4d602176,0xd9ca5dd4}, + [16]uint32{0x00000000,0x602ba1b2,0x00026179,0x6029c0cb,0x810800a4,0xe123a116,0x810a61dd,0xe121c06f,0x8080401e,0xe0abe1ac,0x80822167,0xe0a980d5,0x018840ba,0x61a3e108,0x018a21c3,0x61a18071}, + [16]uint32{0x3f800000,0x3fb015d0,0x3f800130,0x3fb014e0,0x3fc08400,0x3ff091d0,0x3fc08530,0x3ff090e0,0x3fc04020,0x3ff055f0,0x3fc04110,0x3ff054c0,0x3f80c420,0x3fb0d1f0,0x3f80c510,0x3fb0d0c0}, + uint32(0xfff80000), + [21]string{"0xbc","0x77","0xad","0x3a","0x86","0x5e","0x7c","0xff","0xfe","0x2c","0x07","0x2b","0xa9","0xfb","0xb0","0xae","0x84","0x09","0xe6","0xa8","0x00"} }, + { + /* No.403 delta:688 weight:1461 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xb1e47e54,0x0bb002f8,0xba547cac,0x3fa0193d,0x8e446769,0x34101bc5,0x85f46591,0x0000b2a5,0xb1e4ccf1,0x0bb0b05d,0xba54ce09,0x3fa0ab98,0x8e44d5cc,0x3410a960,0x85f4d734}, + [16]uint32{0x00000000,0xdc142153,0x2262019a,0xfe7620c9,0x0068e026,0xdc7cc175,0x220ae1bc,0xfe1ec0ef,0x0012381d,0xdc06194e,0x22703987,0xfe6418d4,0x007ad83b,0xdc6ef968,0x2218d9a1,0xfe0cf8f2}, + [16]uint32{0x3f800000,0x3fee0a10,0x3f913100,0x3fff3b10,0x3f803470,0x3fee3e60,0x3f910570,0x3fff0f60,0x3f80091c,0x3fee030c,0x3f91381c,0x3fff320c,0x3f803d6c,0x3fee377c,0x3f910c6c,0x3fff067c}, + uint32(0xfff80000), + [21]string{"0xf3","0x99","0xfd","0x47","0xca","0x52","0x7b","0x4e","0xc2","0x1a","0x72","0x95","0xdb","0x1a","0xe5","0x0f","0x58","0x17","0xb9","0x96","0x00"} }, + { + /* No.404 delta:2158 weight:1325 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xf3fd55b8,0xf999547e,0x0a6401c6,0x27401949,0xd4bd4cf1,0xded94d37,0x2d24188f,0x0000b353,0xf3fde6eb,0xf999e72d,0x0a64b295,0x2740aa1a,0xd4bdffa2,0xded9fe64,0x2d24abdc}, + [16]uint32{0x00000000,0x0c526f12,0x1500841c,0x1952eb0e,0x0b180c01,0x074a6313,0x1e18881d,0x124ae70f,0x24487005,0x281a1f17,0x3148f419,0x3d1a9b0b,0x2f507c04,0x23021316,0x3a50f818,0x3602970a}, + [16]uint32{0x3f800000,0x3f862937,0x3f8a8042,0x3f8ca975,0x3f858c06,0x3f83a531,0x3f8f0c44,0x3f892573,0x3f922438,0x3f940d0f,0x3f98a47a,0x3f9e8d4d,0x3f97a83e,0x3f918109,0x3f9d287c,0x3f9b014b}, + uint32(0xfff80000), + [21]string{"0xc3","0x74","0x74","0x92","0x5b","0x70","0x8c","0x5d","0xe8","0x35","0xf4","0xb0","0xa9","0x24","0xe6","0x54","0xba","0x40","0xcf","0x0f","0x00"} }, + { + /* No.405 delta:938 weight:1185 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x52862043,0xd780840d,0x8506a44e,0xe4d01955,0xb6563916,0x33509d58,0x61d6bd1b,0x0000efed,0x5286cfae,0xd7806be0,0x85064ba3,0xe4d0f6b8,0xb656d6fb,0x335072b5,0x61d652f6}, + [16]uint32{0x00000000,0x404f4096,0x00024c9d,0x404d0c0b,0x206cb002,0x6023f094,0x206efc9f,0x6021bc09,0x400bc211,0x00448287,0x40098e8c,0x0046ce1a,0x60677213,0x20283285,0x60653e8e,0x202a7e18}, + [16]uint32{0x3f800000,0x3fa027a0,0x3f800126,0x3fa02686,0x3f903658,0x3fb011f8,0x3f90377e,0x3fb010de,0x3fa005e1,0x3f802241,0x3fa004c7,0x3f802367,0x3fb033b9,0x3f901419,0x3fb0329f,0x3f90153f}, + uint32(0xfff80000), + [21]string{"0x7f","0xf9","0x6d","0x9a","0xea","0xa3","0xf9","0xf2","0xbb","0x37","0x32","0x5e","0x26","0x79","0xd2","0x7a","0x4b","0xd5","0x7f","0xe8","0x00"} }, + { + /* No.406 delta:1252 weight:1757 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0xe880a2a5,0x895e81f7,0x61de2352,0x13e01963,0xfb60bbc6,0x9abe9894,0x723e3a31,0x00009436,0xe8803693,0x895e15c1,0x61deb764,0x13e08d55,0xfb602ff0,0x9abe0ca2,0x723eae07}, + [16]uint32{0x00000000,0x206478da,0x004f0046,0x202b789c,0x400c4404,0x60683cde,0x40434442,0x60273c98,0x00301137,0x205469ed,0x007f1171,0x201b69ab,0x403c5533,0x60582de9,0x40735575,0x60172daf}, + [16]uint32{0x3f800000,0x3f90323c,0x3f802780,0x3f9015bc,0x3fa00622,0x3fb0341e,0x3fa021a2,0x3fb0139e,0x3f801808,0x3f902a34,0x3f803f88,0x3f900db4,0x3fa01e2a,0x3fb02c16,0x3fa039aa,0x3fb00b96}, + uint32(0xfff80000), + [21]string{"0x97","0xea","0xc7","0x0e","0x13","0x4a","0x4a","0xde","0xa5","0x17","0x77","0x45","0xc4","0xc5","0x87","0x34","0x14","0x87","0x57","0x42","0x00"} }, + { + /* No.407 delta:783 weight:1331 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0xd707084f,0x9ed93c29,0x49de3466,0x96f01970,0x41f7113f,0x08292559,0xdf2e2d16,0x000051e5,0xd70759aa,0x9ed96dcc,0x49de6583,0x96f04895,0x41f740da,0x082974bc,0xdf2e7cf3}, + [16]uint32{0x00000000,0x0054c37a,0xa07a1991,0xa02edaeb,0x00030014,0x0057c36e,0xa0791985,0xa02ddaff,0x00009017,0x0054536d,0xa07a8986,0xa02e4afc,0x00039003,0x00575379,0xa0798992,0xa02d4ae8}, + [16]uint32{0x3f800000,0x3f802a61,0x3fd03d0c,0x3fd0176d,0x3f800180,0x3f802be1,0x3fd03c8c,0x3fd016ed,0x3f800048,0x3f802a29,0x3fd03d44,0x3fd01725,0x3f8001c8,0x3f802ba9,0x3fd03cc4,0x3fd016a5}, + uint32(0xfff80000), + [21]string{"0x35","0xaa","0x33","0x13","0x1e","0x49","0x0f","0x90","0x67","0x81","0x1c","0x7d","0x0f","0xbb","0xe4","0x70","0x38","0x4a","0x04","0x5f","0x00"} }, + { + /* No.408 delta:1682 weight:1569 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0xa312a06e,0x7f135ca4,0xdc01fcca,0x01a0198e,0xa2b2b9e0,0x7eb3452a,0xdda1e544,0x000036a9,0xa31296c7,0x7f136a0d,0xdc01ca63,0x01a02f27,0xa2b28f49,0x7eb37383,0xdda1d3ed}, + [16]uint32{0x00000000,0x004c01d3,0x4020013f,0x406c00ec,0x2021002d,0x206d01fe,0x60010112,0x604d00c1,0x00000077,0x004c01a4,0x40200148,0x406c009b,0x2021005a,0x206d0189,0x60010165,0x604d00b6}, + [16]uint32{0x3f800000,0x3f802600,0x3fa01000,0x3fa03600,0x3f901080,0x3f903680,0x3fb00080,0x3fb02680,0x3f800000,0x3f802600,0x3fa01000,0x3fa03600,0x3f901080,0x3f903680,0x3fb00080,0x3fb02680}, + uint32(0xfff80000), + [21]string{"0xa8","0xbf","0x78","0xce","0x3e","0xe9","0x50","0xd4","0x3a","0x88","0x2f","0xbe","0x47","0x8e","0x68","0xc1","0x47","0x4f","0x76","0x96","0x00"} }, + { + /* No.409 delta:1013 weight:1173 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x247e8d9b,0xac3b09dc,0x88458447,0xd0701993,0xf40e9408,0x7c4b104f,0x58359dd4,0x000001f0,0x247e8c6b,0xac3b082c,0x884585b7,0xd0701863,0xf40e95f8,0x7c4b11bf,0x58359c24}, + [16]uint32{0x00000000,0x3041455a,0x8002664e,0xb0432314,0x5001b076,0x6040f52c,0xd003d638,0xe0429362,0x04005419,0x34411143,0x84023257,0xb443770d,0x5401e46f,0x6440a135,0xd4038221,0xe442c77b}, + [16]uint32{0x3f800000,0x3f9820a2,0x3fc00133,0x3fd82191,0x3fa800d8,0x3fb0207a,0x3fe801eb,0x3ff02149,0x3f82002a,0x3f9a2088,0x3fc20119,0x3fda21bb,0x3faa00f2,0x3fb22050,0x3fea01c1,0x3ff22163}, + uint32(0xfff80000), + [21]string{"0xf0","0xc1","0x7d","0x8b","0xe2","0x9e","0x59","0x35","0x96","0x48","0xd0","0x14","0x5e","0x8f","0x0b","0x36","0x00","0xce","0xf1","0x71","0x00"} }, + { + /* No.410 delta:1115 weight:1363 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x8192a8cc,0xa56576fc,0x24f7de30,0xbca019ad,0x3d32b161,0x19c56f51,0x9857c79d,0x00009b4e,0x81923382,0xa565edb2,0x24f7457e,0xbca082e3,0x3d322a2f,0x19c5f41f,0x98575cd3}, + [16]uint32{0x00000000,0x10349155,0x406750ae,0x5053c1fb,0x4002640c,0x5036f559,0x006534a2,0x1051a5f7,0x40012418,0x5035b54d,0x006674b6,0x1052e5e3,0x00034014,0x1037d141,0x406410ba,0x505081ef}, + [16]uint32{0x3f800000,0x3f881a48,0x3fa033a8,0x3fa829e0,0x3fa00132,0x3fa81b7a,0x3f80329a,0x3f8828d2,0x3fa00092,0x3fa81ada,0x3f80333a,0x3f882972,0x3f8001a0,0x3f881be8,0x3fa03208,0x3fa82840}, + uint32(0xfff80000), + [21]string{"0x15","0x0b","0x2c","0xe6","0xe0","0x4c","0x62","0xc1","0x40","0x7a","0x71","0x13","0xea","0xbd","0x9d","0x38","0xd7","0x7f","0xa8","0xac","0x00"} }, + { + /* No.411 delta:1393 weight:1675 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0xa0095e24,0xfab39763,0x5abac947,0xb28019b8,0x1289479c,0x48338edb,0xe83ad0ff,0x00009b6b,0xa009c54f,0xfab30c08,0x5aba522c,0xb28082d3,0x1289dcf7,0x483315b0,0xe83a4b94}, + [16]uint32{0x00000000,0x4a5decba,0x00562411,0x4a0bc8ab,0x4406e13e,0x0e5b0d84,0x4450c52f,0x0e0d2995,0x007880b8,0x4a256c02,0x002ea4a9,0x4a734813,0x447e6186,0x0e238d3c,0x44284597,0x0e75a92d}, + [16]uint32{0x3f800000,0x3fa52ef6,0x3f802b12,0x3fa505e4,0x3fa20370,0x3f872d86,0x3fa22862,0x3f870694,0x3f803c40,0x3fa512b6,0x3f801752,0x3fa539a4,0x3fa23f30,0x3f8711c6,0x3fa21422,0x3f873ad4}, + uint32(0xfff80000), + [21]string{"0xdb","0x9e","0xc8","0xb1","0xe3","0x0b","0x69","0x0d","0xf1","0x8a","0x58","0x17","0xc1","0xe2","0xaa","0xad","0x52","0x36","0x28","0x41","0x00"} }, + { + /* No.412 delta:911 weight:1285 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0xa1135c19,0xa2371c1f,0x03244006,0x8bc019c2,0x2ad345db,0x29f705dd,0x88e459c4,0x0000e704,0xa113bb1d,0xa237fb1b,0x0324a702,0x8bc0fec6,0x2ad3a2df,0x29f7e2d9,0x88e4bec0}, + [16]uint32{0x00000000,0x1003ab1e,0x1000e015,0x00034b0b,0x4068580c,0x506bf312,0x5068b819,0x406b1307,0x7074100e,0x6077bb10,0x6074f01b,0x70775b05,0x301c4802,0x201fe31c,0x201ca817,0x301f0309}, + [16]uint32{0x3f800000,0x3f8801d5,0x3f880070,0x3f8001a5,0x3fa0342c,0x3fa835f9,0x3fa8345c,0x3fa03589,0x3fb83a08,0x3fb03bdd,0x3fb03a78,0x3fb83bad,0x3f980e24,0x3f900ff1,0x3f900e54,0x3f980f81}, + uint32(0xfff80000), + [21]string{"0xe2","0xff","0x51","0x6a","0x3c","0x06","0xde","0x51","0x5b","0x4f","0x25","0xc4","0x5a","0x0a","0x5d","0x3f","0xa9","0x40","0x0f","0xf0","0x00"} }, + { + /* No.413 delta:1113 weight:1727 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x3c2bcd99,0x2b6fe7c4,0x17442a5d,0x496019d0,0x754bd449,0x620ffe14,0x5e24338d,0x00007a55,0x3c2bb7cc,0x2b6f9d91,0x17445008,0x49606385,0x754bae1c,0x620f8441,0x5e2449d8}, + [16]uint32{0x00000000,0x105c81be,0x00228dab,0x107e0c15,0x10023017,0x005eb1a9,0x1020bdbc,0x007c3c02,0x20020014,0x305e81aa,0x20208dbf,0x307c0c01,0x30003003,0x205cb1bd,0x3022bda8,0x207e3c16}, + [16]uint32{0x3f800000,0x3f882e40,0x3f801146,0x3f883f06,0x3f880118,0x3f802f58,0x3f88105e,0x3f803e1e,0x3f900100,0x3f982f40,0x3f901046,0x3f983e06,0x3f980018,0x3f902e58,0x3f98115e,0x3f903f1e}, + uint32(0xfff80000), + [21]string{"0xa2","0xe7","0x43","0xe5","0x82","0x36","0xdc","0xe3","0x6e","0xe2","0x55","0xd8","0xfe","0x7c","0x4c","0x56","0xc4","0x20","0x1b","0xe2","0x00"} }, + { + /* No.414 delta:1720 weight:1681 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0x61318219,0x38a5e2e3,0x599460fa,0x2a0019e9,0x4b319bf0,0x12a5fb0a,0x73947913,0x00003497,0x6131b68e,0x38a5d674,0x5994546d,0x2a002d7e,0x4b31af67,0x12a5cf9d,0x73944d84}, + [16]uint32{0x00000000,0x003c01ba,0x6022c1eb,0x601ec051,0x106141d6,0x105d406c,0x7043803d,0x707f8187,0x000260b7,0x003e610d,0x6020a15c,0x601ca0e6,0x10632161,0x105f20db,0x7041e08a,0x707de130}, + [16]uint32{0x3f800000,0x3f801e00,0x3fb01160,0x3fb00f60,0x3f8830a0,0x3f882ea0,0x3fb821c0,0x3fb83fc0,0x3f800130,0x3f801f30,0x3fb01050,0x3fb00e50,0x3f883190,0x3f882f90,0x3fb820f0,0x3fb83ef0}, + uint32(0xfff80000), + [21]string{"0x0e","0x4f","0x4e","0x4b","0x3f","0xba","0x64","0x69","0x9d","0xf0","0x3a","0x12","0x3d","0xd1","0xe8","0x04","0x82","0x7a","0x67","0xe8","0x00"} }, + { + /* No.415 delta:776 weight:1311 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xf9a60b27,0xa0ea6250,0x594c6977,0xdee019f9,0x274612de,0x7e0a7ba9,0x87ac708e,0x00003ca0,0xf9a63787,0xa0ea5ef0,0x594c55d7,0xdee02559,0x27462e7e,0x7e0a4709,0x87ac4c2e}, + [16]uint32{0x00000000,0x606091b3,0x40302129,0x2050b09a,0x10440165,0x702490d6,0x5074204c,0x3014b1ff,0x5008405c,0x3068d1ef,0x10386175,0x7058f0c6,0x404c4139,0x202cd08a,0x007c6010,0x601cf1a3}, + [16]uint32{0x3f800000,0x3fb03048,0x3fa01810,0x3f902858,0x3f882200,0x3fb81248,0x3fa83a10,0x3f980a58,0x3fa80420,0x3f983468,0x3f881c30,0x3fb82c78,0x3fa02620,0x3f901668,0x3f803e30,0x3fb00e78}, + uint32(0xfff80000), + [21]string{"0xa1","0x33","0x08","0x47","0xcc","0x62","0xe4","0x95","0xe2","0x64","0xa2","0x48","0xf9","0x1a","0x10","0xd3","0xd1","0xe8","0xd9","0xc2","0x00"} }, + { + /* No.416 delta:1715 weight:1591 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x004285ba,0xc559b40b,0xc51b31b1,0xbb901a0c,0xbbd29fb6,0x7ec9ae07,0x7e8b2bbd,0x00004bd6,0x0042ce6c,0xc559ffdd,0xc51b7a67,0xbb9051da,0xbbd2d460,0x7ec9e5d1,0x7e8b606b}, + [16]uint32{0x00000000,0x0174813a,0x680800d3,0x697c81e9,0x005a01dc,0x012e80e6,0x6852010f,0x69268035,0x0024001f,0x01508125,0x682c00cc,0x695881f6,0x007e01c3,0x010a80f9,0x68760110,0x6902802a}, + [16]uint32{0x3f800000,0x3f80ba40,0x3fb40400,0x3fb4be40,0x3f802d00,0x3f809740,0x3fb42900,0x3fb49340,0x3f801200,0x3f80a840,0x3fb41600,0x3fb4ac40,0x3f803f00,0x3f808540,0x3fb43b00,0x3fb48140}, + uint32(0xfff80000), + [21]string{"0x78","0xc2","0x13","0xe8","0x63","0xa1","0x0a","0x39","0x4f","0x07","0x47","0x49","0x07","0xd9","0xa7","0x1e","0x0d","0x3f","0x92","0x15","0x00"} }, + { + /* No.417 delta:1194 weight:1671 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x198b5884,0x2bad330c,0x32266b88,0x1db01a18,0x043b429c,0x361d2914,0x2f967190,0x0000fa5b,0x198ba2df,0x2badc957,0x322691d3,0x1db0e043,0x043bb8c7,0x361dd34f,0x2f968bcb}, + [16]uint32{0x00000000,0x287ca0b6,0x24d2010d,0x0caea1bb,0x005a4014,0x2826e0a2,0x24884119,0x0cf4e1af,0x3048d47e,0x183474c8,0x149ad573,0x3ce675c5,0x3012946a,0x186e34dc,0x14c09567,0x3cbc35d1}, + [16]uint32{0x3f800000,0x3f943e50,0x3f926900,0x3f865750,0x3f802d20,0x3f941370,0x3f924420,0x3f867a70,0x3f98246a,0x3f8c1a3a,0x3f8a4d6a,0x3f9e733a,0x3f98094a,0x3f8c371a,0x3f8a604a,0x3f9e5e1a}, + uint32(0xfff80000), + [21]string{"0x98","0xd1","0xda","0x5a","0x80","0x18","0xbd","0xae","0x24","0x02","0x8c","0x67","0x6d","0xbc","0x97","0xd5","0x50","0x94","0x3f","0xc1","0x00"} }, + { + /* No.418 delta:867 weight:1673 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0xd090b11f,0x8d9806df,0x5d08b7c0,0x6f201a25,0xbfb0ab3a,0xe2b81cfa,0x3228ade5,0x0000721c,0xd090c303,0x8d9874c3,0x5d08c5dc,0x6f206839,0xbfb0d926,0xe2b86ee6,0x3228dff9}, + [16]uint32{0x00000000,0x30610032,0x8044460e,0xb025463c,0x0002e295,0x3063e2a7,0x8046a49b,0xb027a4a9,0x00018de8,0x30608dda,0x8045cbe6,0xb024cbd4,0x00036f7d,0x30626f4f,0x80472973,0xb0262941}, + [16]uint32{0x3f800000,0x3f983080,0x3fc02223,0x3fd812a3,0x3f800171,0x3f9831f1,0x3fc02352,0x3fd813d2,0x3f8000c6,0x3f983046,0x3fc022e5,0x3fd81265,0x3f8001b7,0x3f983137,0x3fc02394,0x3fd81314}, + uint32(0xfff80000), + [21]string{"0xb5","0x6e","0x06","0xe7","0xf1","0xb2","0xef","0x9e","0x92","0xaf","0xbc","0xad","0x80","0xc6","0x58","0x7e","0xd2","0x18","0xa5","0x7b","0x00"} }, + { + /* No.419 delta:1693 weight:1439 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0xea68a7ff,0x03799b91,0xe9113c6e,0x92f01a33,0x7898bdcc,0x918981a2,0x7be1265d,0x0000e0b0,0xea68474f,0x03797b21,0xe911dcde,0x92f0fa83,0x78985d7c,0x91896112,0x7be1c6ed}, + [16]uint32{0x00000000,0x283e821a,0x00520054,0x286c824e,0x00020036,0x283c822c,0x00500062,0x286e8278,0x401000a7,0x682e82bd,0x404200f3,0x687c82e9,0x40120091,0x682c828b,0x404000c5,0x687e82df}, + [16]uint32{0x3f800000,0x3f941f41,0x3f802900,0x3f943641,0x3f800100,0x3f941e41,0x3f802800,0x3f943741,0x3fa00800,0x3fb41741,0x3fa02100,0x3fb43e41,0x3fa00900,0x3fb41641,0x3fa02000,0x3fb43f41}, + uint32(0xfff80000), + [21]string{"0x3d","0x08","0x4c","0x67","0xfc","0x9c","0x48","0xe9","0x46","0x4b","0x9a","0xc0","0x56","0xd4","0x48","0xbf","0x57","0x04","0x85","0x7b","0x00"} }, + { + /* No.420 delta:795 weight:1591 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0x255d4f5c,0x5cd2db7e,0x798f9422,0xa9201a4f,0x8c7d5513,0xf5f2c131,0xd0af8e6d,0x0000cb40,0x255d841c,0x5cd2103e,0x798f5f62,0xa920d10f,0x8c7d9e53,0xf5f20a71,0xd0af452d}, + [16]uint32{0x00000000,0x5021117e,0x084011f9,0x58610087,0x9000001a,0xc0211164,0x984011e3,0xc861009d,0x40020cb7,0x10231dc9,0x48421d4e,0x18630c30,0xd0020cad,0x80231dd3,0xd8421d54,0x88630c2a}, + [16]uint32{0x3f800000,0x3fa81088,0x3f842008,0x3fac3080,0x3fc80000,0x3fe01088,0x3fcc2008,0x3fe43080,0x3fa00106,0x3f88118e,0x3fa4210e,0x3f8c3186,0x3fe80106,0x3fc0118e,0x3fec210e,0x3fc43186}, + uint32(0xfff80000), + [21]string{"0x74","0x32","0x9a","0x95","0xe8","0xe5","0x81","0x16","0x6f","0x6f","0x8c","0x54","0xef","0xc7","0x6d","0x3c","0xe4","0x6d","0xb0","0x78","0x00"} }, + { + /* No.421 delta:1100 weight:1723 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x37fb03b4,0xdf064fab,0xe8fd4c1f,0xdf801a56,0xe87b19e2,0x008655fd,0x377d5649,0x000089fe,0x37fb8a4a,0xdf06c655,0xe8fdc5e1,0xdf8093a8,0xe87b901c,0x0086dc03,0x377ddfb7}, + [16]uint32{0x00000000,0x00448097,0x1002018c,0x1046811b,0x000260ef,0x0046e078,0x10006163,0x1044e1f4,0x0003e1bc,0x0047612b,0x1001e030,0x104560a7,0x00018153,0x004501c4,0x100380df,0x10470048}, + [16]uint32{0x3f800000,0x3f802240,0x3f880100,0x3f882340,0x3f800130,0x3f802370,0x3f880030,0x3f882270,0x3f8001f0,0x3f8023b0,0x3f8800f0,0x3f8822b0,0x3f8000c0,0x3f802280,0x3f8801c0,0x3f882380}, + uint32(0xfff80000), + [21]string{"0xce","0xc9","0x70","0x4d","0x28","0x45","0xcd","0x59","0x03","0x6b","0x34","0x1c","0xc7","0x4b","0xe8","0x03","0x11","0x1a","0x99","0xd3","0x00"} }, + { + /* No.422 delta:814 weight:1609 */ + 11213, + 81, + 13, + 4, + [16]uint32{0x00000000,0x3863afab,0x2366d254,0x1b057dff,0xc9301a6b,0xf153b5c0,0xea56c83f,0xd2356794,0x0000630c,0x3863cca7,0x2366b158,0x1b051ef3,0xc9307967,0xf153d6cc,0xea56ab33,0xd2350498}, + [16]uint32{0x00000000,0x80005053,0x402000ba,0xc02050e9,0x4003e077,0xc003b024,0x0023e0cd,0x8023b09e,0x50000118,0xd000514b,0x102001a2,0x902051f1,0x1003e16f,0x9003b13c,0x5023e1d5,0xd023b186}, + [16]uint32{0x3f800000,0x3fc00028,0x3fa01000,0x3fe01028,0x3fa001f0,0x3fe001d8,0x3f8011f0,0x3fc011d8,0x3fa80000,0x3fe80028,0x3f881000,0x3fc81028,0x3f8801f0,0x3fc801d8,0x3fa811f0,0x3fe811d8}, + uint32(0xfff80000), + [21]string{"0xe1","0x6e","0xa6","0x29","0xce","0xac","0x56","0x2c","0x51","0xf5","0xed","0x2b","0x0c","0xa5","0x65","0xf4","0xb5","0xae","0x43","0x81","0x00"} }, + { + /* No.423 delta:804 weight:1751 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x37fb03b4,0xdf064fab,0xe8fd4c1f,0xdf801a76,0xe87b19c2,0x008655dd,0x377d5669,0x000089fe,0x37fb8a4a,0xdf06c655,0xe8fdc5e1,0xdf809388,0xe87b903c,0x0086dc23,0x377ddf97}, + [16]uint32{0x00000000,0x20016137,0x1002543b,0x3003350c,0x50008425,0x7001e512,0x4002d01e,0x6003b129,0x4400a80f,0x6401c938,0x5402fc34,0x74039d03,0x14002c2a,0x34014d1d,0x04027811,0x24031926}, + [16]uint32{0x3f800000,0x3f9000b0,0x3f88012a,0x3f98019a,0x3fa80042,0x3fb800f2,0x3fa00168,0x3fb001d8,0x3fa20054,0x3fb200e4,0x3faa017e,0x3fba01ce,0x3f8a0016,0x3f9a00a6,0x3f82013c,0x3f92018c}, + uint32(0xfff80000), + [21]string{"0x3c","0x2c","0x9b","0xc9","0xdb","0x8e","0x3d","0x36","0x5d","0xdf","0xa0","0xeb","0x2c","0x11","0x71","0xa9","0xc5","0xb3","0x48","0x7e","0x00"} }, + { + /* No.424 delta:3104 weight:631 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xd90825a7,0x47df8dbf,0x9ed7a818,0x45701a8e,0x9c783f29,0x02af9731,0xdba7b296,0x00002d8c,0xd908082b,0x47dfa033,0x9ed78594,0x45703702,0x9c7812a5,0x02afbabd,0xdba79f1a}, + [16]uint32{0x00000000,0xfd6002c1,0x10b500c3,0xedd50202,0x4049100d,0xbd2912cc,0x50fc10ce,0xad9c120f,0xd000e011,0x2d60e2d0,0xc0b5e0d2,0x3dd5e213,0x9049f01c,0x6d29f2dd,0x80fcf0df,0x7d9cf21e}, + [16]uint32{0x3f800000,0x3ffeb001,0x3f885a80,0x3ff6ea81,0x3fa02488,0x3fde9489,0x3fa87e08,0x3fd6ce09,0x3fe80070,0x3f96b071,0x3fe05af0,0x3f9eeaf1,0x3fc824f8,0x3fb694f9,0x3fc07e78,0x3fbece79}, + uint32(0xfff80000), + [21]string{"0x15","0x8e","0x88","0xbb","0xf9","0x37","0x89","0xe6","0xd7","0x5b","0xc9","0xfd","0x54","0x36","0x12","0x84","0x7d","0x9a","0x74","0x37","0x00"} }, + { + /* No.425 delta:1053 weight:1527 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0x6b29794b,0x0da3033f,0x668a7a74,0xc3101a90,0xa83963db,0xceb319af,0xa59a60e4,0x00002517,0x6b295c5c,0x0da32628,0x668a5f63,0xc3103f87,0xa83946cc,0xceb33cb8,0xa59a45f3}, + [16]uint32{0x00000000,0x804180de,0x40440539,0xc00585e7,0x20404108,0xa001c1d6,0x60044431,0xe045c4ef,0x20702015,0xa031a0cb,0x6034252c,0xe075a5f2,0x0030611d,0x8071e1c3,0x40746424,0xc035e4fa}, + [16]uint32{0x3f800000,0x3fc020c0,0x3fa02202,0x3fe002c2,0x3f902020,0x3fd000e0,0x3fb00222,0x3ff022e2,0x3f903810,0x3fd018d0,0x3fb01a12,0x3ff03ad2,0x3f801830,0x3fc038f0,0x3fa03a32,0x3fe01af2}, + uint32(0xfff80000), + [21]string{"0xe9","0x03","0xeb","0x9e","0x61","0xab","0xc2","0x9b","0x13","0x95","0xb0","0x67","0x7d","0x21","0x0a","0xc5","0x77","0xe9","0xe1","0x5b","0x00"} }, + { + /* No.426 delta:894 weight:1671 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x7516d380,0x0bb65d81,0x7ea08e01,0x3b101aa3,0x4e06c923,0x30a64722,0x45b094a2,0x000040e3,0x75169363,0x0bb61d62,0x7ea0cee2,0x3b105a40,0x4e0689c0,0x30a607c1,0x45b0d441}, + [16]uint32{0x00000000,0x4016c0d6,0x0041403c,0x405780ea,0x0002460f,0x401486d9,0x00430633,0x4055c6e5,0x1005041b,0x5013c4cd,0x10444427,0x505284f1,0x10074214,0x501182c2,0x10460228,0x5050c2fe}, + [16]uint32{0x3f800000,0x3fa00b60,0x3f8020a0,0x3fa02bc0,0x3f800123,0x3fa00a43,0x3f802183,0x3fa02ae3,0x3f880282,0x3fa809e2,0x3f882222,0x3fa82942,0x3f8803a1,0x3fa808c1,0x3f882301,0x3fa82861}, + uint32(0xfff80000), + [21]string{"0xdc","0x93","0x3f","0x7f","0x9a","0x0e","0xc2","0xb9","0x81","0x8d","0x3e","0x41","0x06","0x30","0xdf","0x25","0xa2","0xec","0x32","0x10","0x00"} }, + { + /* No.427 delta:1635 weight:1469 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x0e897e65,0x138eb418,0x1d07ca7d,0x8f201abf,0x81a964da,0x9caeaea7,0x9227d0c2,0x00008a40,0x0e89f425,0x138e3e58,0x1d07403d,0x8f2090ff,0x81a9ee9a,0x9cae24e7,0x92275a82}, + [16]uint32{0x00000000,0x6e5c1116,0x00052033,0x6e593125,0x1901809d,0x775d918b,0x1904a0ae,0x7758b1b8,0x1163c81a,0x7f3fd90c,0x1166e829,0x7f3af93f,0x08624887,0x663e5991,0x086768b4,0x663b79a2}, + [16]uint32{0x3f800000,0x3fb72e08,0x3f800290,0x3fb72c98,0x3f8c80c0,0x3fbbaec8,0x3f8c8250,0x3fbbac58,0x3f88b1e4,0x3fbf9fec,0x3f88b374,0x3fbf9d7c,0x3f843124,0x3fb31f2c,0x3f8433b4,0x3fb31dbc}, + uint32(0xfff80000), + [21]string{"0xe4","0xfa","0x76","0x5f","0xbf","0x62","0x4a","0x27","0x8a","0xbe","0xbd","0x36","0xae","0xef","0x0a","0x51","0x71","0xbd","0xbb","0x53","0x00"} }, + { + /* No.428 delta:2647 weight:869 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x43527f08,0x9d9bc601,0xdec9b909,0x62d01ac0,0x218265c8,0xff4bdcc1,0xbc19a3c9,0x000031e0,0x43524ee8,0x9d9bf7e1,0xdec988e9,0x62d02b20,0x21825428,0xff4bed21,0xbc199229}, + [16]uint32{0x00000000,0xc0650c7a,0x3860005f,0xf8050c25,0x0c18851c,0xcc7d8966,0x34788543,0xf41d8939,0x18204149,0xd8454d33,0x20404116,0xe0254d6c,0x1438c455,0xd45dc82f,0x2c58c40a,0xec3dc870}, + [16]uint32{0x3f800000,0x3fe03286,0x3f9c3000,0x3ffc0286,0x3f860c42,0x3fe63ec4,0x3f9a3c42,0x3ffa0ec4,0x3f8c1020,0x3fec22a6,0x3f902020,0x3ff012a6,0x3f8a1c62,0x3fea2ee4,0x3f962c62,0x3ff61ee4}, + uint32(0xfff80000), + [21]string{"0x93","0x26","0x3d","0x15","0xb2","0xad","0xa9","0x17","0x31","0xc4","0x4b","0x19","0xf2","0xcd","0x2a","0x53","0xf7","0x46","0x04","0x86","0x00"} }, + { + /* No.429 delta:574 weight:1741 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0x78bfa3bb,0xb26daf1b,0xcad20ca0,0x8c901ad9,0xf42fb962,0x3efdb5c2,0x46421679,0x000057cd,0x78bff476,0xb26df8d6,0xcad25b6d,0x8c904d14,0xf42feeaf,0x3efde20f,0x464241b4}, + [16]uint32{0x00000000,0x407ec892,0x0003b8cb,0x407d7059,0x00205005,0x405e9897,0x0023e8ce,0x405d205c,0x60100204,0x206eca96,0x6013bacf,0x206d725d,0x60305201,0x204e9a93,0x6033eaca,0x204d2258}, + [16]uint32{0x3f800000,0x3fa03f64,0x3f8001dc,0x3fa03eb8,0x3f801028,0x3fa02f4c,0x3f8011f4,0x3fa02e90,0x3fb00801,0x3f903765,0x3fb009dd,0x3f9036b9,0x3fb01829,0x3f90274d,0x3fb019f5,0x3f902691}, + uint32(0xfff80000), + [21]string{"0xf6","0xa3","0x4d","0x6c","0xcc","0x76","0xeb","0x15","0x04","0xa7","0xd2","0x15","0xe5","0x85","0xa1","0x29","0xed","0x3a","0xd8","0x51","0x00"} }, + { + /* No.430 delta:1044 weight:1679 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x7f3e4b3c,0x3db50e58,0x428b4564,0xe4101aea,0x9b2e51d6,0xd9a514b2,0xa69b5f8e,0x0000d877,0x7f3e934b,0x3db5d62f,0x428b9d13,0xe410c29d,0x9b2e89a1,0xd9a5ccc5,0xa69b87f9}, + [16]uint32{0x00000000,0x101e1117,0x41021eed,0x511c0ffa,0x0000106e,0x101e0179,0x41020e83,0x511c1f94,0x30230012,0x203d1105,0x71211eff,0x613f0fe8,0x3023107c,0x203d016b,0x71210e91,0x613f1f86}, + [16]uint32{0x3f800000,0x3f880f08,0x3fa0810f,0x3fa88e07,0x3f800008,0x3f880f00,0x3fa08107,0x3fa88e0f,0x3f981180,0x3f901e88,0x3fb8908f,0x3fb09f87,0x3f981188,0x3f901e80,0x3fb89087,0x3fb09f8f}, + uint32(0xfff80000), + [21]string{"0x31","0x88","0xd4","0xfd","0x08","0xd5","0x86","0x97","0xb7","0xc8","0xf4","0xee","0x84","0x1e","0x7a","0x4d","0x9c","0x4b","0xb3","0xb0","0x00"} }, + { + /* No.431 delta:987 weight:967 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0x2c1a5d06,0x76bc8d6b,0x5aa6d06d,0x34c01af1,0x18da47f7,0x427c979a,0x6e66ca9c,0x0000659c,0x2c1a389a,0x76bce8f7,0x5aa6b5f1,0x34c07f6d,0x18da226b,0x427cf206,0x6e66af00}, + [16]uint32{0x00000000,0x006c313e,0x00038909,0x006fb837,0x0401012c,0x046d3012,0x04028825,0x046eb91b,0x2032214d,0x205e1073,0x2031a844,0x205d997a,0x24332061,0x245f115f,0x2430a968,0x245c9856}, + [16]uint32{0x3f800000,0x3f803618,0x3f8001c4,0x3f8037dc,0x3f820080,0x3f823698,0x3f820144,0x3f82375c,0x3f901910,0x3f902f08,0x3f9018d4,0x3f902ecc,0x3f921990,0x3f922f88,0x3f921854,0x3f922e4c}, + uint32(0xfff80000), + [21]string{"0xa8","0x3a","0x69","0x50","0x5c","0x5c","0xa1","0xaf","0x0b","0x54","0xee","0xb0","0x76","0x02","0xae","0x8b","0x6e","0x77","0xe7","0x55","0x00"} }, + { + /* No.432 delta:1531 weight:1641 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x1adf62b5,0x18570b8b,0x0288693e,0x89001b01,0x93df79b4,0x9157108a,0x8b88723f,0x000025aa,0x1adf471f,0x18572e21,0x02884c94,0x89003eab,0x93df5c1e,0x91573520,0x8b885795}, + [16]uint32{0x00000000,0x0e9e017a,0x00610113,0x0eff0069,0x00580148,0x0ec60032,0x0039005b,0x0ea70121,0x0004e182,0x0e9ae0f8,0x0065e091,0x0efbe1eb,0x005ce0ca,0x0ec2e1b0,0x003de1d9,0x0ea3e0a3}, + [16]uint32{0x3f800000,0x3f874f00,0x3f803080,0x3f877f80,0x3f802c00,0x3f876300,0x3f801c80,0x3f875380,0x3f800270,0x3f874d70,0x3f8032f0,0x3f877df0,0x3f802e70,0x3f876170,0x3f801ef0,0x3f8751f0}, + uint32(0xfff80000), + [21]string{"0x8d","0xe9","0x17","0xb7","0x70","0xfc","0xcc","0x88","0xdc","0x5e","0x6c","0x4d","0x30","0xdc","0x8e","0xf8","0x2b","0x2f","0xf6","0xb6","0x00"} }, + { + /* No.433 delta:839 weight:1293 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x3bd71db2,0x48ca34cb,0x731d2979,0x27101b15,0x1cc706a7,0x6fda2fde,0x540d326c,0x0000081e,0x3bd715ac,0x48ca3cd5,0x731d2167,0x2710130b,0x1cc70eb9,0x6fda27c0,0x540d3a72}, + [16]uint32{0x00000000,0x90630612,0x004c00fb,0x902f06e9,0x0027c1aa,0x9044c7b8,0x006bc151,0x9008c743,0x1820532e,0x8843553c,0x186c53d5,0x880f55c7,0x18079284,0x88649496,0x184b927f,0x8828946d}, + [16]uint32{0x3f800000,0x3fc83183,0x3f802600,0x3fc81783,0x3f8013e0,0x3fc82263,0x3f8035e0,0x3fc80463,0x3f8c1029,0x3fc421aa,0x3f8c3629,0x3fc407aa,0x3f8c03c9,0x3fc4324a,0x3f8c25c9,0x3fc4144a}, + uint32(0xfff80000), + [21]string{"0xab","0x47","0x41","0x3a","0x1f","0x1f","0x5c","0x24","0x61","0x69","0x71","0xa7","0x97","0xdd","0xb6","0xe9","0x5e","0x9f","0xf3","0x45","0x00"} }, + { + /* No.434 delta:1393 weight:1441 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xd67e23e4,0x16517cf4,0xc02f5f10,0x02f01b25,0xd48e38c1,0x14a167d1,0xc2df4435,0x00000830,0xd67e2bd4,0x165174c4,0xc02f5720,0x02f01315,0xd48e30f1,0x14a16fe1,0xc2df4c05}, + [16]uint32{0x00000000,0x205e48da,0x402a61b7,0x6074296d,0x60288538,0x4076cde2,0x2002e48f,0x005cac55,0x404ab18b,0x6014f951,0x0060d03c,0x203e98e6,0x206234b3,0x003c7c69,0x60485504,0x40161dde}, + [16]uint32{0x3f800000,0x3f902f24,0x3fa01530,0x3fb03a14,0x3fb01442,0x3fa03b66,0x3f900172,0x3f802e56,0x3fa02558,0x3fb00a7c,0x3f803068,0x3f901f4c,0x3f90311a,0x3f801e3e,0x3fb0242a,0x3fa00b0e}, + uint32(0xfff80000), + [21]string{"0x31","0xc3","0x14","0x4a","0xc5","0xa4","0x7d","0x37","0x3e","0x1b","0xe0","0x5a","0x1c","0x8e","0x39","0xf2","0x4a","0x5f","0xe5","0x18","0x00"} }, + { + /* No.435 delta:1506 weight:1529 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0xe8f6d4d6,0x1f9921a7,0xf76ff571,0xafa01b37,0x4756cfe1,0xb0393a90,0x58cfee46,0x0000e946,0xe8f63d90,0x1f99c8e1,0xf76f1c37,0xafa0f271,0x475626a7,0xb039d3d6,0x58cf0700}, + [16]uint32{0x00000000,0x2865415a,0x4002c982,0x686788d8,0x3070e1d3,0x1815a089,0x70722851,0x5817690b,0x00687156,0x280d300c,0x406ab8d4,0x680ff98e,0x30189085,0x187dd1df,0x701a5907,0x587f185d}, + [16]uint32{0x3f800000,0x3f9432a0,0x3fa00164,0x3fb433c4,0x3f983870,0x3f8c0ad0,0x3fb83914,0x3fac0bb4,0x3f803438,0x3f940698,0x3fa0355c,0x3fb407fc,0x3f980c48,0x3f8c3ee8,0x3fb80d2c,0x3fac3f8c}, + uint32(0xfff80000), + [21]string{"0x30","0xa9","0xe2","0x5b","0xe5","0xa1","0x47","0xfd","0x4b","0x6c","0x8a","0x14","0x23","0xe0","0x8f","0xef","0xcb","0xe8","0x90","0x2f","0x00"} }, + { + /* No.436 delta:1226 weight:1523 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x557fb620,0x6c5a80b0,0x39253690,0x42801b40,0x17ffad60,0x2eda9bf0,0x7ba52dd0,0x00005ec4,0x557fe8e4,0x6c5ade74,0x39256854,0x42804584,0x17fff3a4,0x2edac534,0x7ba57314}, + [16]uint32{0x00000000,0x006da17b,0x400a6152,0x4067c029,0x0402009c,0x046fa1e7,0x440861ce,0x4465c0b5,0xd0106016,0xd07dc16d,0x901a0144,0x9077a03f,0xd412608a,0xd47fc1f1,0x941801d8,0x9475a0a3}, + [16]uint32{0x3f800000,0x3f8036d0,0x3fa00530,0x3fa033e0,0x3f820100,0x3f8237d0,0x3fa20430,0x3fa232e0,0x3fe80830,0x3fe83ee0,0x3fc80d00,0x3fc83bd0,0x3fea0930,0x3fea3fe0,0x3fca0c00,0x3fca3ad0}, + uint32(0xfff80000), + [21]string{"0x08","0x12","0xb6","0xd0","0x24","0x49","0xa5","0x85","0x4b","0xb2","0xf1","0x9b","0x2c","0x64","0xbf","0xb1","0x6f","0xd1","0xeb","0xda","0x00"} }, + { + /* No.437 delta:650 weight:1717 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0x36d515bc,0x557945ab,0x63ac5017,0xb4701b5b,0x82a50ee7,0xe1095ef0,0xd7dc4b4c,0x0000845f,0x36d591e3,0x5579c1f4,0x63acd448,0xb4709f04,0x82a58ab8,0xe109daaf,0xd7dccf13}, + [16]uint32{0x00000000,0x2002b91b,0x80006411,0xa002dd0a,0x400011d6,0x6002a8cd,0xc00075c7,0xe002ccdc,0x20011812,0x0003a109,0xa0017c03,0x8003c518,0x600109c4,0x4003b0df,0xe0016dd5,0xc003d4ce}, + [16]uint32{0x3f800000,0x3f90015c,0x3fc00032,0x3fd0016e,0x3fa00008,0x3fb00154,0x3fe0003a,0x3ff00166,0x3f90008c,0x3f8001d0,0x3fd000be,0x3fc001e2,0x3fb00084,0x3fa001d8,0x3ff000b6,0x3fe001ea}, + uint32(0xfff80000), + [21]string{"0x1e","0x01","0x6d","0x92","0x46","0x9d","0x77","0x5f","0x99","0x39","0x34","0x1e","0x83","0xd4","0x50","0x06","0xba","0xf4","0x06","0xc5","0x00"} }, + { + /* No.438 delta:768 weight:1315 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0xc4e1fbbb,0x1f16f6c1,0xdbf70d7a,0xce201b6c,0x0ac1e0d7,0xd136edad,0x15d71616,0x00007f3f,0xc4e18484,0x1f1689fe,0xdbf77245,0xce206453,0x0ac19fe8,0xd1369292,0x15d76929}, + [16]uint32{0x00000000,0x40041072,0x2029710b,0x602d6179,0x280400ed,0x6800109f,0x082d71e6,0x48296194,0x000081f0,0x40049182,0x2029f0fb,0x602de089,0x2804811d,0x6800916f,0x082df016,0x4829e064}, + [16]uint32{0x3f800000,0x3fa00208,0x3f9014b8,0x3fb016b0,0x3f940200,0x3fb40008,0x3f8416b8,0x3fa414b0,0x3f800040,0x3fa00248,0x3f9014f8,0x3fb016f0,0x3f940240,0x3fb40048,0x3f8416f8,0x3fa414f0}, + uint32(0xfff80000), + [21]string{"0xb5","0x2e","0xf9","0xc4","0x1f","0x96","0x80","0x45","0xea","0x23","0x83","0x02","0x10","0x9c","0x4e","0x87","0xf1","0x13","0xd8","0xc5","0x00"} }, + { + /* No.439 delta:1209 weight:1595 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0xd0453d45,0xa2f377d4,0x72b64a91,0x4ed01b75,0x9e952630,0xec236ca1,0x3c6651e4,0x00006db6,0xd04550f3,0xa2f31a62,0x72b62727,0x4ed076c3,0x9e954b86,0xec230117,0x3c663c52}, + [16]uint32{0x00000000,0xc00de97a,0x020145e3,0xc20cac99,0x405ce122,0x80510858,0x425da4c1,0x82504dbb,0x00609dfe,0xc06d7484,0x0261d81d,0xc26c3167,0x403c7cdc,0x803195a6,0x423d393f,0x8230d045}, + [16]uint32{0x3f800000,0x3fe006f4,0x3f8100a2,0x3fe10656,0x3fa02e70,0x3fc02884,0x3fa12ed2,0x3fc12826,0x3f80304e,0x3fe036ba,0x3f8130ec,0x3fe13618,0x3fa01e3e,0x3fc018ca,0x3fa11e9c,0x3fc11868}, + uint32(0xfff80000), + [21]string{"0x16","0xcc","0xdf","0x96","0x0d","0x0c","0x8d","0x9d","0x4c","0xe0","0xb7","0x30","0xd3","0xe2","0xba","0xde","0x4f","0xd2","0x13","0xb1","0x00"} }, + { + /* No.440 delta:661 weight:1719 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0xecde6bb9,0x18155470,0xf4cb3fc9,0x03e01b89,0xef3e7030,0x1bf54ff9,0xf72b2440,0x0000d089,0xecdebb30,0x181584f9,0xf4cbef40,0x03e0cb00,0xef3ea0b9,0x1bf59f70,0xf72bf4c9}, + [16]uint32{0x00000000,0xb0078c1a,0x2022e34f,0x90256f55,0x00020012,0xb0058c08,0x2020e35d,0x90276f47,0x10601010,0xa0679c0a,0x3042f35f,0x80457f45,0x10621002,0xa0659c18,0x3040f34d,0x80477f57}, + [16]uint32{0x3f800000,0x3fd803c6,0x3f901171,0x3fc812b7,0x3f800100,0x3fd802c6,0x3f901071,0x3fc813b7,0x3f883008,0x3fd033ce,0x3f982179,0x3fc022bf,0x3f883108,0x3fd032ce,0x3f982079,0x3fc023bf}, + uint32(0xfff80000), + [21]string{"0x02","0x84","0xb3","0x29","0xd9","0x66","0x77","0xde","0xd3","0xde","0x2c","0x98","0xba","0x8d","0xd0","0x9f","0xa3","0xa5","0xa6","0x62","0x00"} }, + { + /* No.441 delta:896 weight:1197 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0x74b73a0a,0x02330f4f,0x76843545,0x6ff01b95,0x1b47219f,0x6dc314da,0x19742ed0,0x000064da,0x74b75ed0,0x02336b95,0x7684519f,0x6ff07f4f,0x1b474545,0x6dc37000,0x19744a0a}, + [16]uint32{0x00000000,0x100f7056,0x40229c0d,0x502dec5b,0x106a00f9,0x006570af,0x50489cf4,0x4047eca2,0x000283c1,0x100df397,0x40201fcc,0x502f6f9a,0x10688338,0x0067f36e,0x504a1f35,0x40456f63}, + [16]uint32{0x3f800000,0x3f8807b8,0x3fa0114e,0x3fa816f6,0x3f883500,0x3f8032b8,0x3fa8244e,0x3fa023f6,0x3f800141,0x3f8806f9,0x3fa0100f,0x3fa817b7,0x3f883441,0x3f8033f9,0x3fa8250f,0x3fa022b7}, + uint32(0xfff80000), + [21]string{"0x8f","0x1e","0x77","0x99","0xde","0x44","0x8e","0x66","0xcc","0x6e","0x8e","0xfa","0xe2","0xdf","0x89","0x94","0x86","0xbd","0x7f","0xfb","0x00"} }, + { + /* No.442 delta:1044 weight:1603 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0xf2acd20d,0x2e78f6ac,0xdcd424a1,0x11c01ba2,0xe36cc9af,0x3fb8ed0e,0xcd143f03,0x00003333,0xf2ace13e,0x2e78c59f,0xdcd41792,0x11c02891,0xe36cfa9c,0x3fb8de3d,0xcd140c30}, + [16]uint32{0x00000000,0x600423fa,0x300230fc,0x50061306,0x3001c0a3,0x5005e359,0x0003f05f,0x6007d3a5,0x1403b116,0x740792ec,0x240181ea,0x4405a210,0x240271b5,0x4406524f,0x14004149,0x740462b3}, + [16]uint32{0x3f800000,0x3fb00211,0x3f980118,0x3fa80309,0x3f9800e0,0x3fa802f1,0x3f8001f8,0x3fb003e9,0x3f8a01d8,0x3fba03c9,0x3f9200c0,0x3fa202d1,0x3f920138,0x3fa20329,0x3f8a0020,0x3fba0231}, + uint32(0xfff80000), + [21]string{"0x61","0x3f","0x9c","0x01","0xef","0xb0","0xd2","0x20","0x2e","0x27","0xf6","0xbd","0x73","0xbc","0x66","0x3a","0x0b","0xac","0x78","0xe5","0x00"} }, + { + /* No.443 delta:1046 weight:1629 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x142cd4e2,0x5c38fde5,0x48142907,0x7a401bb1,0x6e6ccf53,0x2678e654,0x325432b6,0x0000fb50,0x142c2fb2,0x5c3806b5,0x4814d257,0x7a40e0e1,0x6e6c3403,0x26781d04,0x3254c9e6}, + [16]uint32{0x00000000,0x004de1de,0x800ec185,0x8043205b,0x000200b4,0x004fe16a,0x800cc131,0x804120ef,0x240c001d,0x2441e1c3,0xa402c198,0xa44f2046,0x240e00a9,0x2443e177,0xa400c12c,0xa44d20f2}, + [16]uint32{0x3f800000,0x3f8026f0,0x3fc00760,0x3fc02190,0x3f800100,0x3f8027f0,0x3fc00660,0x3fc02090,0x3f920600,0x3f9220f0,0x3fd20160,0x3fd22790,0x3f920700,0x3f9221f0,0x3fd20060,0x3fd22690}, + uint32(0xfff80000), + [21]string{"0x65","0x13","0x59","0x24","0xc4","0xfb","0xe5","0xe6","0xe1","0x9a","0x95","0x21","0xdb","0x47","0x93","0x4d","0xd3","0xb3","0x91","0xcc","0x00"} }, + { + /* No.444 delta:669 weight:1447 */ + 11213, + 81, + 13, + 4, + [16]uint32{0x00000000,0x053e5913,0xae3d13ce,0xab034add,0x5ae01bc7,0x5fde42d4,0xf4dd0809,0xf1e3511a,0x0000b142,0x053ee851,0xae3da28c,0xab03fb9f,0x5ae0aa85,0x5fdef396,0xf4ddb94b,0xf1e3e058}, + [16]uint32{0x00000000,0x3001c83d,0x20032cc9,0x1002e4f4,0x0002349a,0x3003fca7,0x20011853,0x1000d06e,0x6000001c,0x5001c821,0x40032cd5,0x7002e4e8,0x60023486,0x5003fcbb,0x4001184f,0x7000d072}, + [16]uint32{0x3f800000,0x3f9800e4,0x3f900196,0x3f880172,0x3f80011a,0x3f9801fe,0x3f90008c,0x3f880068,0x3fb00000,0x3fa800e4,0x3fa00196,0x3fb80172,0x3fb0011a,0x3fa801fe,0x3fa0008c,0x3fb80068}, + uint32(0xfff80000), + [21]string{"0x2b","0x33","0x3a","0xe8","0xf0","0x8a","0xb9","0xc8","0x97","0xec","0xc2","0xca","0x81","0x45","0x89","0x05","0xd4","0x8b","0x2e","0xa9","0x00"} }, + { + /* No.445 delta:1946 weight:1335 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0x1c4b156c,0x39a6b0f0,0x25eda59c,0x91b01bd0,0x8dfb0ebc,0xa816ab20,0xb45dbe4c,0x00004b50,0x1c4b5e3c,0x39a6fba0,0x25edeecc,0x91b05080,0x8dfb45ec,0xa816e070,0xb45df51c}, + [16]uint32{0x00000000,0x0a958997,0x0f02a212,0x05972b85,0x00801026,0x0a1599b1,0x0f82b234,0x05173ba3,0x44180c15,0x4e8d8582,0x4b1aae07,0x418f2790,0x44981c33,0x4e0d95a4,0x4b9abe21,0x410f37b6}, + [16]uint32{0x3f800000,0x3f854ac4,0x3f878151,0x3f82cb95,0x3f804008,0x3f850acc,0x3f87c159,0x3f828b9d,0x3fa20c06,0x3fa746c2,0x3fa58d57,0x3fa0c793,0x3fa24c0e,0x3fa706ca,0x3fa5cd5f,0x3fa0879b}, + uint32(0xfff80000), + [21]string{"0x16","0x8a","0x65","0x8e","0x09","0x67","0xbe","0x3b","0xba","0x27","0xec","0xf7","0xa1","0x87","0x82","0x1b","0x4e","0xea","0x8d","0x1f","0x00"} }, + { + /* No.446 delta:2283 weight:1213 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x196d7152,0x70b7638d,0x69da12df,0x0f501be1,0x163d6ab3,0x7fe7786c,0x668a093e,0x00005fc3,0x196d2e91,0x70b73c4e,0x69da4d1c,0x0f504422,0x163d3570,0x7fe727af,0x668a56fd}, + [16]uint32{0x00000000,0x241580d6,0x22100542,0x06058594,0x19c021dc,0x3dd5a10a,0x3bd0249e,0x1fc5a448,0x0c160027,0x280380f1,0x2e060565,0x0a1385b3,0x15d621fb,0x31c3a12d,0x37c624b9,0x13d3a46f}, + [16]uint32{0x3f800000,0x3f920ac0,0x3f910802,0x3f8302c2,0x3f8ce010,0x3f9eead0,0x3f9de812,0x3f8fe2d2,0x3f860b00,0x3f9401c0,0x3f970302,0x3f8509c2,0x3f8aeb10,0x3f98e1d0,0x3f9be312,0x3f89e9d2}, + uint32(0xfff80000), + [21]string{"0xe0","0x34","0x97","0x6e","0x7b","0xab","0x93","0x95","0xb6","0x3c","0x37","0x45","0x72","0xbf","0xbd","0x20","0xa9","0x0e","0x06","0x5b","0x00"} }, + { + /* No.447 delta:940 weight:1651 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x378ab458,0x999d98e1,0xae172cb9,0x17b01bfc,0x203aafa4,0x8e2d831d,0xb9a73745,0x000086af,0x378a32f7,0x999d1e4e,0xae17aa16,0x17b09d53,0x203a290b,0x8e2d05b2,0xb9a7b1ea}, + [16]uint32{0x00000000,0x80009816,0x400c0eac,0xc00c96ba,0x00139604,0x80130e12,0x401f98a8,0xc01f00be,0x00031418,0x80038c0e,0x400f1ab4,0xc00f82a2,0x0010821c,0x80101a0a,0x401c8cb0,0xc01c14a6}, + [16]uint32{0x3f800000,0x3fc0004c,0x3fa00607,0x3fe0064b,0x3f8009cb,0x3fc00987,0x3fa00fcc,0x3fe00f80,0x3f80018a,0x3fc001c6,0x3fa0078d,0x3fe007c1,0x3f800841,0x3fc0080d,0x3fa00e46,0x3fe00e0a}, + uint32(0xfff80000), + [21]string{"0xe7","0x7e","0x5f","0x3f","0x63","0x46","0xb4","0x5e","0x55","0xe4","0xbe","0x63","0x84","0x07","0x66","0x97","0x54","0x8d","0x57","0xc8","0x00"} }, + { + /* No.448 delta:773 weight:1505 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x887f6254,0x5c60053c,0xd41f6768,0x5c701c0b,0xd40f7e5f,0x00101937,0x886f7b63,0x000077da,0x887f158e,0x5c6072e6,0xd41f10b2,0x5c706bd1,0xd40f0985,0x00106eed,0x886f0cb9}, + [16]uint32{0x00000000,0xc102113a,0x2081016d,0xe1831057,0xa00031de,0x610220e4,0x808130b3,0x41832189,0x4000601d,0x81027127,0x60816170,0xa183704a,0xe00051c3,0x210240f9,0xc08150ae,0x01834194}, + [16]uint32{0x3f800000,0x3fe08108,0x3f904080,0x3ff0c188,0x3fd00018,0x3fb08110,0x3fc04098,0x3fa0c190,0x3fa00030,0x3fc08138,0x3fb040b0,0x3fd0c1b8,0x3ff00028,0x3f908120,0x3fe040a8,0x3f80c1a0}, + uint32(0xfff80000), + [21]string{"0x52","0x3b","0xa8","0xb8","0xa4","0x44","0xdb","0x43","0xd2","0xa1","0xd3","0xd4","0x80","0x7e","0x9e","0xeb","0x10","0x02","0xa7","0x3d","0x00"} }, + { + /* No.449 delta:1695 weight:1347 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x5e96a7dd,0xd58d224d,0x8b1b8590,0xd4801c15,0x8a16bbc8,0x010d3e58,0x5f9b9985,0x000052a0,0x5e96f57d,0xd58d70ed,0x8b1bd730,0xd4804eb5,0x8a16e968,0x010d6cf8,0x5f9bcb25}, + [16]uint32{0x00000000,0x8045a132,0x004e104c,0x800bb17e,0x530821a9,0xd34d809b,0x534631e5,0xd30390d7,0x0d207078,0x8d65d14a,0x0d6e6034,0x8d2bc106,0x5e2851d1,0xde6df0e3,0x5e66419d,0xde23e0af}, + [16]uint32{0x3f800000,0x3fc022d0,0x3f802708,0x3fc005d8,0x3fa98410,0x3fe9a6c0,0x3fa9a318,0x3fe981c8,0x3f869038,0x3fc6b2e8,0x3f86b730,0x3fc695e0,0x3faf1428,0x3fef36f8,0x3faf3320,0x3fef11f0}, + uint32(0xfff80000), + [21]string{"0xc3","0xbf","0x9f","0xb6","0xc5","0x31","0x9b","0x86","0x9a","0x6d","0x96","0x67","0x5b","0xec","0x24","0xb7","0x3e","0xd3","0xe0","0x07","0x00"} }, + { + /* No.450 delta:1302 weight:1591 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x91534dd5,0x8670ccfb,0x1723812e,0xdab01c26,0x4be351f3,0x5cc0d0dd,0xcd939d08,0x0000308b,0x91537d5e,0x8670fc70,0x1723b1a5,0xdab02cad,0x4be36178,0x5cc0e056,0xcd93ad83}, + [16]uint32{0x00000000,0x0065417c,0x240e846e,0x246bc512,0x00222089,0x004761f5,0x242ca4e7,0x2449e59b,0x2010003d,0x20754141,0x041e8453,0x047bc52f,0x203220b4,0x205761c8,0x043ca4da,0x0459e5a6}, + [16]uint32{0x3f800000,0x3f8032a0,0x3f920742,0x3f9235e2,0x3f801110,0x3f8023b0,0x3f921652,0x3f9224f2,0x3f900800,0x3f903aa0,0x3f820f42,0x3f823de2,0x3f901910,0x3f902bb0,0x3f821e52,0x3f822cf2}, + uint32(0xfff80000), + [21]string{"0x67","0x48","0x0f","0xce","0x04","0x1c","0x7a","0x4a","0xb8","0xdb","0xa3","0x1f","0x34","0x33","0xac","0x96","0x18","0x13","0xb5","0x20","0x00"} }, + { + /* No.451 delta:774 weight:1351 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0x8dfdec88,0x42759c86,0xcf88700e,0xd7801c3e,0x5a7df0b6,0x95f580b8,0x18086c30,0x0000426d,0x8dfdaee5,0x4275deeb,0xcf883263,0xd7805e53,0x5a7db2db,0x95f5c2d5,0x18082e5d}, + [16]uint32{0x00000000,0x0f951152,0x004a4883,0x0fdf59d1,0x00321c17,0x0fa70d45,0x00785494,0x0fed45c6,0x5618001a,0x598d1148,0x56524899,0x59c759cb,0x562a1c0d,0x59bf0d5f,0x5660548e,0x59f545dc}, + [16]uint32{0x3f800000,0x3f87ca88,0x3f802524,0x3f87efac,0x3f80190e,0x3f87d386,0x3f803c2a,0x3f87f6a2,0x3fab0c00,0x3facc688,0x3fab2924,0x3face3ac,0x3fab150e,0x3facdf86,0x3fab302a,0x3facfaa2}, + uint32(0xfff80000), + [21]string{"0xad","0x39","0x35","0x49","0x70","0xc4","0xa9","0x33","0x85","0xa8","0x0b","0x37","0x54","0x33","0xbb","0x71","0x02","0xa4","0x96","0xea","0x00"} }, + { + /* No.452 delta:726 weight:1365 */ + 11213, + 64, + 13, + 4, + [16]uint32{0x00000000,0x9be3fbc9,0x04688a47,0x9f8b718e,0x47d01c47,0xdc33e78e,0x43b89600,0xd85b6dc9,0x00008529,0x9be37ee0,0x04680f6e,0x9f8bf4a7,0x47d0996e,0xdc3362a7,0x43b81329,0xd85be8e0}, + [16]uint32{0x00000000,0x6101697a,0x24001fbe,0x450176c4,0x0002101d,0x61037967,0x24020fa3,0x450366d9,0x3005cccf,0x5104a5b5,0x1405d371,0x7504ba0b,0x3007dcd2,0x5106b5a8,0x1407c36c,0x7506aa16}, + [16]uint32{0x3f800000,0x3fb080b4,0x3f92000f,0x3fa280bb,0x3f800108,0x3fb081bc,0x3f920107,0x3fa281b3,0x3f9802e6,0x3fa88252,0x3f8a02e9,0x3fba825d,0x3f9803ee,0x3fa8835a,0x3f8a03e1,0x3fba8355}, + uint32(0xfff80000), + [21]string{"0xd1","0xa0","0x4f","0x52","0xcc","0x74","0xcd","0x0d","0xf0","0x50","0xda","0x06","0xe6","0x16","0xb3","0x08","0x75","0x4e","0xa7","0xe1","0x00"} }, + { + /* No.453 delta:977 weight:1675 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x3202f4e6,0xbba89e7a,0x89aa6a9c,0x26a01c5e,0x14a2e8b8,0x9d088224,0xaf0a76c2,0x0000ce49,0x32023aaf,0xbba85033,0x89aaa4d5,0x26a0d217,0x14a226f1,0x9d084c6d,0xaf0ab88b}, + [16]uint32{0x00000000,0x6872097f,0x000320e5,0x6871299a,0x00710056,0x68030929,0x007220b3,0x680029cc,0xa001881b,0xc8738164,0xa002a8fe,0xc870a181,0xa070884d,0xc8028132,0xa073a8a8,0xc801a1d7}, + [16]uint32{0x3f800000,0x3fb43904,0x3f800190,0x3fb43894,0x3f803880,0x3fb40184,0x3f803910,0x3fb40014,0x3fd000c4,0x3fe439c0,0x3fd00154,0x3fe43850,0x3fd03844,0x3fe40140,0x3fd039d4,0x3fe400d0}, + uint32(0xfff80000), + [21]string{"0x9a","0x39","0x76","0xe0","0x00","0xe4","0xad","0x40","0x6d","0xbc","0x26","0x84","0xc1","0x11","0x26","0x3e","0x39","0x81","0x75","0x5e","0x00"} }, + { + /* No.454 delta:2877 weight:859 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0xb26c64aa,0x948e3b5e,0x26e25ff4,0x66a01c69,0xd4cc78c3,0xf22e2737,0x4042439d,0x0000d341,0xb26cb7eb,0x948ee81f,0x26e28cb5,0x66a0cf28,0xd4ccab82,0xf22ef476,0x404290dc}, + [16]uint32{0x00000000,0xe5365b96,0x0d2c001c,0xe81a5b8a,0x0fd203f1,0xeae45867,0x02fe03ed,0xe7c8587b,0x8004461e,0x65321d88,0x8d284602,0x681e1d94,0x8fd645ef,0x6ae01e79,0x82fa45f3,0x67cc1e65}, + [16]uint32{0x3f800000,0x3ff29b2d,0x3f869600,0x3ff40d2d,0x3f87e901,0x3ff5722c,0x3f817f01,0x3ff3e42c,0x3fc00223,0x3fb2990e,0x3fc69423,0x3fb40f0e,0x3fc7eb22,0x3fb5700f,0x3fc17d22,0x3fb3e60f}, + uint32(0xfff80000), + [21]string{"0xc1","0x8a","0x93","0xc3","0x26","0x42","0x3a","0xdc","0x79","0xb1","0x2a","0x11","0xd4","0xac","0xc3","0xf9","0xfa","0x71","0x61","0x9a","0x00"} }, + { + /* No.455 delta:681 weight:1617 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0xe9a7fd5d,0x7e4e5765,0x97e9aa38,0x28701c79,0xc1d7e124,0x563e4b1c,0xbf99b641,0x000080d7,0xe9a77d8a,0x7e4ed7b2,0x97e92aef,0x28709cae,0xc1d761f3,0x563ecbcb,0xbf993696}, + [16]uint32{0x00000000,0x300363d7,0x1000cc03,0x2003afd4,0x40000a0e,0x700369d9,0x5000c60d,0x6003a5da,0xa000080b,0x90036bdc,0xb000c408,0x8003a7df,0xe0000205,0xd00361d2,0xf000ce06,0xc003add1}, + [16]uint32{0x3f800000,0x3f9801b1,0x3f880066,0x3f9001d7,0x3fa00005,0x3fb801b4,0x3fa80063,0x3fb001d2,0x3fd00004,0x3fc801b5,0x3fd80062,0x3fc001d3,0x3ff00001,0x3fe801b0,0x3ff80067,0x3fe001d6}, + uint32(0xfff80000), + [21]string{"0xd5","0x14","0x04","0xa9","0x05","0x77","0x56","0x00","0x9b","0x45","0x3c","0xb7","0x4c","0x3f","0x61","0x70","0x89","0x78","0x8d","0x54","0x00"} }, + { + /* No.456 delta:1708 weight:1567 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xb252a23e,0x1bc3b15c,0xa9911362,0x1bb01c87,0xa9e2beb9,0x0073addb,0xb2210fe5,0x0000202e,0xb2528210,0x1bc39172,0xa991334c,0x1bb03ca9,0xa9e29e97,0x00738df5,0xb2212fcb}, + [16]uint32{0x00000000,0x2c1b011a,0x80058011,0xac1e810b,0x0d102512,0x210b2408,0x8d15a503,0xa10ea419,0x020085bc,0x2e1b84a6,0x820505ad,0xae1e04b7,0x0f10a0ae,0x230ba1b4,0x8f1520bf,0xa30e21a5}, + [16]uint32{0x3f800000,0x3f960d80,0x3fc002c0,0x3fd60f40,0x3f868812,0x3f908592,0x3fc68ad2,0x3fd08752,0x3f810042,0x3f970dc2,0x3fc10282,0x3fd70f02,0x3f878850,0x3f9185d0,0x3fc78a90,0x3fd18710}, + uint32(0xfff80000), + [21]string{"0xfe","0xf5","0x65","0x22","0x34","0x59","0xa4","0x03","0x8f","0x5c","0x1f","0xda","0xfe","0xda","0xb8","0x69","0xf8","0x0a","0xde","0xe6","0x00"} }, + { + /* No.457 delta:860 weight:1561 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0xad2d4d15,0x64c8b75e,0xc9e5fa4b,0xcad01c96,0x67fd5183,0xae18abc8,0x0335e6dd,0x00001b43,0xad2d5656,0x64c8ac1d,0xc9e5e108,0xcad007d5,0x67fd4ac0,0xae18b08b,0x0335fd9e}, + [16]uint32{0x00000000,0x0002afba,0xc048c115,0xc04a6eaf,0x400431e3,0x40069e59,0x804cf0f6,0x804e5f4c,0x00016145,0x0003ceff,0xc049a050,0xc04b0fea,0x400550a6,0x4007ff1c,0x804d91b3,0x804f3e09}, + [16]uint32{0x3f800000,0x3f800157,0x3fe02460,0x3fe02537,0x3fa00218,0x3fa0034f,0x3fc02678,0x3fc0272f,0x3f8000b0,0x3f8001e7,0x3fe024d0,0x3fe02587,0x3fa002a8,0x3fa003ff,0x3fc026c8,0x3fc0279f}, + uint32(0xfff80000), + [21]string{"0x8c","0x2e","0x2b","0x31","0x16","0x38","0xd4","0x83","0x1c","0x8a","0xfc","0x4f","0xa3","0xe7","0x93","0xbc","0xc8","0x5f","0xa8","0x52","0x00"} }, + { + /* No.458 delta:1676 weight:1533 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x79fa442f,0xf4897b00,0x8d733f2f,0x2e401cac,0x57ba5883,0xdac967ac,0xa3332383,0x00005efb,0x79fa1ad4,0xf48925fb,0x8d7361d4,0x2e404257,0x57ba0678,0xdac93957,0xa3337d78}, + [16]uint32{0x00000000,0x0c6178b6,0x7034c021,0x7c55b897,0x010aa18b,0x0d6bd93d,0x713e61aa,0x7d5f191c,0x0c1c0404,0x007d7cb2,0x7c28c425,0x7049bc93,0x0d16a58f,0x0177dd39,0x7d2265ae,0x71431d18}, + [16]uint32{0x3f800000,0x3f8630bc,0x3fb81a60,0x3fbe2adc,0x3f808550,0x3f86b5ec,0x3fb89f30,0x3fbeaf8c,0x3f860e02,0x3f803ebe,0x3fbe1462,0x3fb824de,0x3f868b52,0x3f80bbee,0x3fbe9132,0x3fb8a18e}, + uint32(0xfff80000), + [21]string{"0xaf","0xfd","0x1f","0x6b","0xc7","0x3c","0xbf","0xbe","0x3f","0xb9","0xf5","0x1b","0x89","0xa6","0xc1","0xc5","0xc0","0x6f","0x8d","0x88","0x00"} }, + { + /* No.459 delta:2859 weight:827 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0x966cdd4d,0x2dcf6a78,0xbba3b735,0x50c01cba,0xc6acc1f7,0x7d0f76c2,0xeb63ab8f,0x00007e6d,0x966ca320,0x2dcf1415,0xbba3c958,0x50c062d7,0xc6acbf9a,0x7d0f08af,0xeb63d5e2}, + [16]uint32{0x00000000,0x90c2e156,0x398a8087,0xa94861d1,0x34102fed,0xa4d2cebb,0x0d9aaf6a,0x9d584e3c,0x8c00e21e,0x1cc20348,0xb58a6299,0x254883cf,0xb810cdf3,0x28d22ca5,0x819a4d74,0x1158ac22}, + [16]uint32{0x3f800000,0x3fc86170,0x3f9cc540,0x3fd4a430,0x3f9a0817,0x3fd26967,0x3f86cd57,0x3fceac27,0x3fc60071,0x3f8e6101,0x3fdac531,0x3f92a441,0x3fdc0866,0x3f946916,0x3fc0cd26,0x3f88ac56}, + uint32(0xfff80000), + [21]string{"0xa1","0x48","0x6f","0xb4","0x98","0x4a","0xc0","0x55","0x79","0xdf","0x91","0x6f","0x8d","0xfb","0xf8","0x83","0x2a","0x8c","0x08","0xe3","0x00"} }, + { + /* No.460 delta:3091 weight:655 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xf7f86c95,0x6bcc71ce,0x9c341d5b,0x5d901cc1,0xaa687054,0x365c6d0f,0xc1a4019a,0x00004c13,0xf7f82086,0x6bcc3ddd,0x9c345148,0x5d9050d2,0xaa683c47,0x365c211c,0xc1a44d89}, + [16]uint32{0x00000000,0xef0005af,0x1362b07d,0xfc62b5d2,0x50614171,0xbf6144de,0x4303f10c,0xac03f4a3,0x09822615,0xe68223ba,0x1ae09668,0xf5e093c7,0x59e36764,0xb6e362cb,0x4a81d719,0xa581d2b6}, + [16]uint32{0x3f800000,0x3ff78002,0x3f89b158,0x3ffe315a,0x3fa830a0,0x3fdfb0a2,0x3fa181f8,0x3fd601fa,0x3f84c113,0x3ff34111,0x3f8d704b,0x3ffaf049,0x3facf1b3,0x3fdb71b1,0x3fa540eb,0x3fd2c0e9}, + uint32(0xfff80000), + [21]string{"0xd8","0x49","0xac","0x16","0x01","0x46","0x55","0xa8","0x4b","0xb8","0x6e","0x39","0x40","0x02","0x2d","0x70","0x6d","0x36","0x2d","0x52","0x00"} }, + { + /* No.461 delta:1147 weight:1403 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xdbd3783d,0xbe49cbc8,0x659ab3f5,0xed501cdd,0x368364e0,0x5319d715,0x88caaf28,0x00005530,0xdbd32d0d,0xbe499ef8,0x659ae6c5,0xed5049ed,0x368331d0,0x53198225,0x88cafa18}, + [16]uint32{0x00000000,0xa3396c7e,0x005264ec,0xa36b0892,0x00028606,0xa33bea78,0x0050e2ea,0xa3698e94,0x0034801d,0xa30dec63,0x0066e4f1,0xa35f888f,0x0036061b,0xa30f6a65,0x006462f7,0xa35d0e89}, + [16]uint32{0x3f800000,0x3fd19cb6,0x3f802932,0x3fd1b584,0x3f800143,0x3fd19df5,0x3f802871,0x3fd1b4c7,0x3f801a40,0x3fd186f6,0x3f803372,0x3fd1afc4,0x3f801b03,0x3fd187b5,0x3f803231,0x3fd1ae87}, + uint32(0xfff80000), + [21]string{"0xa0","0x0c","0xaf","0xc1","0x62","0x6d","0x77","0x93","0x39","0x49","0x43","0xa1","0x6f","0xcd","0xd2","0xe0","0x82","0x21","0x82","0x00","0x00"} }, + { + /* No.462 delta:1650 weight:1547 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xde2dcf6b,0x3af4f8e1,0xe4d9378a,0xbe901ce6,0x60bdd38d,0x8464e407,0x5a492b6c,0x0000829f,0xde2d4df4,0x3af47a7e,0xe4d9b515,0xbe909e79,0x60bd5112,0x84646698,0x5a49a9f3}, + [16]uint32{0x00000000,0x0901583c,0x05ad222d,0x0cac7a11,0x018240de,0x088318e2,0x042f62f3,0x0d2e3acf,0x40124219,0x49131a25,0x45bf6034,0x4cbe3808,0x419002c7,0x48915afb,0x443d20ea,0x4d3c78d6}, + [16]uint32{0x3f800000,0x3f8480ac,0x3f82d691,0x3f86563d,0x3f80c120,0x3f84418c,0x3f8217b1,0x3f86971d,0x3fa00921,0x3fa4898d,0x3fa2dfb0,0x3fa65f1c,0x3fa0c801,0x3fa448ad,0x3fa21e90,0x3fa69e3c}, + uint32(0xfff80000), + [21]string{"0x8e","0x3a","0x8d","0x78","0x09","0x9d","0xe5","0x21","0x70","0xc8","0x56","0xf3","0x4a","0xd3","0xf0","0x79","0x72","0xea","0x34","0x2b","0x00"} }, + { + /* No.463 delta:1698 weight:1635 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0x3ea32c98,0xa2768504,0x9cd5a99c,0xb3701cf6,0x8dd3306e,0x110699f2,0x2fa5b56a,0x00001c59,0x3ea330c1,0xa276995d,0x9cd5b5c5,0xb37000af,0x8dd32c37,0x110685ab,0x2fa5a933}, + [16]uint32{0x00000000,0x005e605a,0x403001ef,0x406e61b5,0x00620071,0x003c602b,0x4052019e,0x400c61c4,0x00020048,0x005c6012,0x403201a7,0x406c61fd,0x00600039,0x003e6063,0x405001d6,0x400e618c}, + [16]uint32{0x3f800000,0x3f802f30,0x3fa01800,0x3fa03730,0x3f803100,0x3f801e30,0x3fa02900,0x3fa00630,0x3f800100,0x3f802e30,0x3fa01900,0x3fa03630,0x3f803000,0x3f801f30,0x3fa02800,0x3fa00730}, + uint32(0xfff80000), + [21]string{"0xa4","0xe1","0x31","0xab","0xca","0x6a","0x42","0x05","0x4d","0x09","0xc5","0x2d","0x81","0xcc","0x0d","0x32","0x77","0x2e","0x23","0x6d","0x00"} }, + { + /* No.464 delta:994 weight:1683 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x6ab86193,0x33d2fced,0x596a9d7e,0x3bd01d03,0x51687c90,0x0802e1ee,0x62ba807d,0x0000cbf6,0x6ab8aa65,0x33d2371b,0x596a5688,0x3bd0d6f5,0x5168b766,0x08022a18,0x62ba4b8b}, + [16]uint32{0x00000000,0x101fc3ba,0x000200d7,0x101dc36d,0xc040c084,0xd05f033e,0xc042c053,0xd05d03e9,0x3818003b,0x2807c381,0x381a00ec,0x2805c356,0xf858c0bf,0xe8470305,0xf85ac068,0xe84503d2}, + [16]uint32{0x3f800000,0x3f880fe1,0x3f800100,0x3f880ee1,0x3fe02060,0x3fe82f81,0x3fe02160,0x3fe82e81,0x3f9c0c00,0x3f9403e1,0x3f9c0d00,0x3f9402e1,0x3ffc2c60,0x3ff42381,0x3ffc2d60,0x3ff42281}, + uint32(0xfff80000), + [21]string{"0x65","0x41","0x75","0x17","0xf0","0x67","0x8d","0x81","0x45","0x3f","0xae","0xf9","0xc4","0x4a","0xda","0x19","0x1a","0x50","0x12","0xff","0x00"} }, + { + /* No.465 delta:1002 weight:1417 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0x7e8c4d8d,0x0204aa47,0x7c88e7ca,0x8f401d1f,0xf1cc5092,0x8d44b758,0xf3c8fad5,0x0000df1b,0x7e8c9296,0x0204755c,0x7c8838d1,0x8f40c204,0xf1cc8f89,0x8d446843,0xf3c825ce}, + [16]uint32{0x00000000,0x10002832,0x4800201d,0x5800082f,0xa1001229,0xb1003a1b,0xe9003234,0xf9001a06,0xe0000401,0xf0002c33,0xa800241c,0xb8000c2e,0x41001628,0x51003e1a,0x09003635,0x19001e07}, + [16]uint32{0x3f800000,0x3f880014,0x3fa40010,0x3fac0004,0x3fd08009,0x3fd8801d,0x3ff48019,0x3ffc800d,0x3ff00002,0x3ff80016,0x3fd40012,0x3fdc0006,0x3fa0800b,0x3fa8801f,0x3f84801b,0x3f8c800f}, + uint32(0xfff80000), + [21]string{"0xcb","0xd2","0x42","0x56","0xac","0xd3","0xc2","0x53","0x5c","0xf0","0x3f","0xae","0x10","0x6e","0x1a","0x1a","0x95","0x0d","0xc4","0xfe","0x00"} }, + { + /* No.466 delta:1116 weight:1429 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xe8a2def6,0x6697b821,0x8e3566d7,0x98701d28,0x70d2c3de,0xfee7a509,0x16457bff,0x0000b64a,0xe8a268bc,0x66970e6b,0x8e35d09d,0x9870ab62,0x70d27594,0xfee71343,0x1645cdb5}, + [16]uint32{0x00000000,0x581c021a,0x200281ff,0x781e83e5,0x0003550e,0x581f5714,0x2001d4f1,0x781dd6eb,0x02240015,0x5a38020f,0x222681ea,0x7a3a83f0,0x0227551b,0x5a3b5701,0x2225d4e4,0x7a39d6fe}, + [16]uint32{0x3f800000,0x3fac0e01,0x3f900140,0x3fbc0f41,0x3f8001aa,0x3fac0fab,0x3f9000ea,0x3fbc0eeb,0x3f811200,0x3fad1c01,0x3f911340,0x3fbd1d41,0x3f8113aa,0x3fad1dab,0x3f9112ea,0x3fbd1ceb}, + uint32(0xfff80000), + [21]string{"0x8d","0x16","0x92","0xc4","0xde","0xb4","0x29","0xc1","0x8e","0xea","0x8e","0xe6","0x47","0xa0","0x78","0x42","0x18","0x3d","0x05","0x7d","0x00"} }, + { + /* No.467 delta:762 weight:1591 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0x30431de8,0xf4246d55,0xc46770bd,0xcca01d38,0xfce300d0,0x3884706d,0x08c76d85,0x00000155,0x30431cbd,0xf4246c00,0xc46771e8,0xcca01c6d,0xfce30185,0x38847138,0x08c76cd0}, + [16]uint32{0x00000000,0x005c993b,0x0003588e,0x005fc1b5,0x0002a01c,0x005e3927,0x0001f892,0x005d61a9,0x20103008,0x204ca933,0x20136886,0x204ff1bd,0x20129014,0x204e092f,0x2011c89a,0x204d51a1}, + [16]uint32{0x3f800000,0x3f802e4c,0x3f8001ac,0x3f802fe0,0x3f800150,0x3f802f1c,0x3f8000fc,0x3f802eb0,0x3f900818,0x3f902654,0x3f9009b4,0x3f9027f8,0x3f900948,0x3f902704,0x3f9008e4,0x3f9026a8}, + uint32(0xfff80000), + [21]string{"0xc3","0x53","0xa2","0x6c","0x7b","0x6b","0x11","0xcb","0x82","0x73","0x97","0x3a","0x25","0x79","0x35","0x90","0x85","0x92","0x32","0xa3","0x00"} }, + { + /* No.468 delta:1074 weight:1391 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x1836f48e,0x1958a0d1,0x016e545f,0x8e001d40,0x9636e9ce,0x9758bd91,0x8f6e491f,0x00006285,0x1836960b,0x1958c254,0x016e36da,0x8e007fc5,0x96368b4b,0x9758df14,0x8f6e2b9a}, + [16]uint32{0x00000000,0x400da476,0x304444d5,0x7049e0a3,0x10132148,0x501e853e,0x2057659d,0x605ac1eb,0x0023a17f,0x402e0509,0x3067e5aa,0x706a41dc,0x10308037,0x503d2441,0x2074c4e2,0x60796094}, + [16]uint32{0x3f800000,0x3fa006d2,0x3f982222,0x3fb824f0,0x3f880990,0x3fa80f42,0x3f902bb2,0x3fb02d60,0x3f8011d0,0x3fa01702,0x3f9833f2,0x3fb83520,0x3f881840,0x3fa81e92,0x3f903a62,0x3fb03cb0}, + uint32(0xfff80000), + [21]string{"0xa6","0xe2","0x37","0x6d","0xb3","0xb4","0xf8","0x37","0x2e","0x27","0xa3","0xd0","0x12","0xa1","0x16","0x1d","0x94","0x5b","0x07","0xb1","0x00"} }, + { + /* No.469 delta:982 weight:1581 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x965ae253,0xe70f4509,0x7155a75a,0x64a01d5b,0xf2faff08,0x83af5852,0x15f5ba01,0x0000bf56,0x965a5d05,0xe70ffa5f,0x7155180c,0x64a0a20d,0xf2fa405e,0x83afe704,0x15f50557}, + [16]uint32{0x00000000,0x200240f2,0x240051d7,0x04021125,0x1406d09c,0x3404906e,0x3006814b,0x1004c1b9,0x1013e01a,0x3011a0e8,0x3413b1cd,0x1411f13f,0x04153086,0x24177074,0x20156151,0x001721a3}, + [16]uint32{0x3f800000,0x3f900120,0x3f920028,0x3f820108,0x3f8a0368,0x3f9a0248,0x3f980340,0x3f880260,0x3f8809f0,0x3f9808d0,0x3f9a09d8,0x3f8a08f8,0x3f820a98,0x3f920bb8,0x3f900ab0,0x3f800b90}, + uint32(0xfff80000), + [21]string{"0x08","0xc2","0xc2","0xbf","0xba","0x73","0xe8","0x04","0x76","0xa9","0x5b","0x1a","0xad","0xea","0x5d","0x5a","0x98","0xb9","0xba","0x85","0x00"} }, + { + /* No.470 delta:997 weight:1427 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x57991792,0xd2b792b3,0x852e8521,0x02e01d68,0x55790afa,0xd0578fdb,0x87ce9849,0x000085ae,0x5799923c,0xd2b7171d,0x852e008f,0x02e098c6,0x55798f54,0xd0570a75,0x87ce1de7}, + [16]uint32{0x00000000,0x402d0552,0x0002c915,0x402fcc47,0x40467019,0x006b754b,0x4044b90c,0x0069bc5e,0x10b30c1a,0x509e0948,0x10b1c50f,0x509cc05d,0x50f57c03,0x10d87951,0x50f7b516,0x10dab044}, + [16]uint32{0x3f800000,0x3fa01682,0x3f800164,0x3fa017e6,0x3fa02338,0x3f8035ba,0x3fa0225c,0x3f8034de,0x3f885986,0x3fa84f04,0x3f8858e2,0x3fa84e60,0x3fa87abe,0x3f886c3c,0x3fa87bda,0x3f886d58}, + uint32(0xfff80000), + [21]string{"0xb6","0xab","0xb8","0x8e","0x22","0xc6","0xc1","0xf1","0xd8","0x58","0x6d","0x23","0x10","0x08","0x4b","0x05","0x84","0x5d","0xba","0xc4","0x00"} }, + { + /* No.471 delta:1497 weight:1575 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x4ab0bf22,0x834b4b03,0xc9fbf421,0xfd201d7c,0xb790a25e,0x7e6b567f,0x34dbe95d,0x00005885,0x4ab0e7a7,0x834b1386,0xc9fbaca4,0xfd2045f9,0xb790fadb,0x7e6b0efa,0x34dbb1d8}, + [16]uint32{0x00000000,0x0c14987e,0x52f8e4ea,0x5eec7c94,0x004008d6,0x0c5490a8,0x52b8ec3c,0x5eac7442,0x0063e01f,0x0c777861,0x529b04f5,0x5e8f9c8b,0x0023e8c9,0x0c3770b7,0x52db0c23,0x5ecf945d}, + [16]uint32{0x3f800000,0x3f860a4c,0x3fa97c72,0x3faf763e,0x3f802004,0x3f862a48,0x3fa95c76,0x3faf563a,0x3f8031f0,0x3f863bbc,0x3fa94d82,0x3faf47ce,0x3f8011f4,0x3f861bb8,0x3fa96d86,0x3faf67ca}, + uint32(0xfff80000), + [21]string{"0x3f","0x76","0x21","0x59","0xf5","0x5e","0x78","0x7a","0xc1","0x86","0x48","0x8d","0x51","0x11","0x8a","0x29","0xa0","0x2f","0x4f","0x52","0x00"} }, + { + /* No.472 delta:1546 weight:1671 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x3c6f0fba,0x5b32d4c5,0x675ddb7f,0x20801d89,0x1cef1233,0x7bb2c94c,0x47ddc6f6,0x00006cad,0x3c6f6317,0x5b32b868,0x675db7d2,0x20807124,0x1cef7e9e,0x7bb2a5e1,0x47ddaa5b}, + [16]uint32{0x00000000,0xa0d64076,0x2054202f,0x80826059,0x003c098a,0xa0ea49fc,0x206829a5,0x80be69d3,0x20340012,0x80e24064,0x0060203d,0xa0b6604b,0x20080998,0x80de49ee,0x005c29b7,0xa08a69c1}, + [16]uint32{0x3f800000,0x3fd06b20,0x3f902a10,0x3fc04130,0x3f801e04,0x3fd07524,0x3f903414,0x3fc05f34,0x3f901a00,0x3fc07120,0x3f803010,0x3fd05b30,0x3f900404,0x3fc06f24,0x3f802e14,0x3fd04534}, + uint32(0xfff80000), + [21]string{"0x4b","0x84","0x52","0xf4","0xd4","0x3a","0xf0","0x78","0xc5","0xe1","0xa3","0xd3","0xdd","0x9c","0x43","0x2f","0xbf","0xe2","0x0b","0xbb","0x00"} }, + { + /* No.473 delta:592 weight:1593 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0x06b61206,0x99dff500,0x9f69e706,0x29701d90,0x2fc60f96,0xb0afe890,0xb619fa96,0x000061d0,0x06b673d6,0x99df94d0,0x9f6986d6,0x29707c40,0x2fc66e46,0xb0af8940,0xb6199b46}, + [16]uint32{0x00000000,0x20426f15,0x40101c0f,0x6052731a,0x0002860b,0x2040e91e,0x40129a04,0x6050f511,0xc0015601,0xe0433914,0x80114a0e,0xa053251b,0xc003d00a,0xe041bf1f,0x8013cc05,0xa051a310}, + [16]uint32{0x3f800000,0x3f902137,0x3fa0080e,0x3fb02939,0x3f800143,0x3f902074,0x3fa0094d,0x3fb0287a,0x3fe000ab,0x3ff0219c,0x3fc008a5,0x3fd02992,0x3fe001e8,0x3ff020df,0x3fc009e6,0x3fd028d1}, + uint32(0xfff80000), + [21]string{"0xec","0x8a","0x48","0x6b","0x4d","0xf5","0xc2","0x21","0x1b","0x26","0xab","0x20","0xda","0x44","0xaf","0x66","0x0f","0xc7","0x91","0x68","0x00"} }, + { + /* No.474 delta:1484 weight:1665 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x4a404019,0x6200ed9f,0x2840ad86,0x5f701da0,0x15305db9,0x3d70f03f,0x7730b026,0x000080de,0x4a40c0c7,0x62006d41,0x28402d58,0x5f709d7e,0x1530dd67,0x3d7070e1,0x773030f8}, + [16]uint32{0x00000000,0x0604021a,0x000151d3,0x060553c9,0x00605025,0x0664523f,0x006101f6,0x066503ec,0x00401801,0x06441a1b,0x004149d2,0x06454bc8,0x00204824,0x06244a3e,0x002119f7,0x06251bed}, + [16]uint32{0x3f800000,0x3f830201,0x3f8000a8,0x3f8302a9,0x3f803028,0x3f833229,0x3f803080,0x3f833281,0x3f80200c,0x3f83220d,0x3f8020a4,0x3f8322a5,0x3f801024,0x3f831225,0x3f80108c,0x3f83128d}, + uint32(0xfff80000), + [21]string{"0xd5","0x07","0x86","0x6a","0xf3","0xf9","0xb4","0xfd","0x66","0x09","0x32","0xf8","0x34","0x16","0x71","0x7b","0x8c","0x00","0x39","0xec","0x00"} }, + { + /* No.475 delta:830 weight:1563 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x4d5a359d,0x74795c1b,0x39236986,0xdd501dbb,0x900a2826,0xa92941a0,0xe473743d,0x0000d2bf,0x4d5ae722,0x74798ea4,0x3923bb39,0xdd50cf04,0x900afa99,0xa929931f,0xe473a682}, + [16]uint32{0x00000000,0x4001e5f5,0x200281fe,0x6003640b,0x3003c5b1,0x70022044,0x1001444f,0x5000a1ba,0x0003045c,0x4002e1a9,0x200185a2,0x60006057,0x3000c1ed,0x70012418,0x10024013,0x5003a5e6}, + [16]uint32{0x3f800000,0x3fa000f2,0x3f900140,0x3fb001b2,0x3f9801e2,0x3fb80110,0x3f8800a2,0x3fa80050,0x3f800182,0x3fa00170,0x3f9000c2,0x3fb00030,0x3f980060,0x3fb80092,0x3f880120,0x3fa801d2}, + uint32(0xfff80000), + [21]string{"0xe9","0x4d","0x06","0xe7","0xbe","0x86","0x9c","0xcb","0x53","0xa2","0x6c","0x00","0xb5","0x04","0xa1","0x88","0xe1","0x00","0x63","0x02","0x00"} }, + { + /* No.476 delta:1031 weight:1603 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xc2e33ade,0xed885798,0x2f6b6d46,0x44c01dc8,0x86232716,0xa9484a50,0x6bab708e,0x0000f315,0xc2e3c9cb,0xed88a48d,0x2f6b9e53,0x44c0eedd,0x8623d403,0xa948b945,0x6bab839b}, + [16]uint32{0x00000000,0x800d0e3e,0x00252155,0x80282f6b,0x10472307,0x904a2d39,0x10620252,0x906f0c6c,0x00031017,0x800e1e29,0x00263142,0x802b3f7c,0x10443310,0x90493d2e,0x10611245,0x906c1c7b}, + [16]uint32{0x3f800000,0x3fc00687,0x3f801290,0x3fc01417,0x3f882391,0x3fc82516,0x3f883101,0x3fc83786,0x3f800188,0x3fc0070f,0x3f801318,0x3fc0159f,0x3f882219,0x3fc8249e,0x3f883089,0x3fc8360e}, + uint32(0xfff80000), + [21]string{"0x4a","0x30","0x35","0x89","0xd9","0x2e","0xb6","0xe1","0xe4","0xbc","0x08","0x82","0x8f","0x3c","0x33","0x86","0x05","0x31","0xf8","0x50","0x00"} }, + { + /* No.477 delta:1735 weight:1445 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0x55099ce0,0x7b86d53c,0x2e8f49dc,0xcca01dde,0x99a9813e,0xb726c8e2,0xe22f5402,0x00008290,0x55091e70,0x7b8657ac,0x2e8fcb4c,0xcca09f4e,0x99a903ae,0xb7264a72,0xe22fd692}, + [16]uint32{0x00000000,0x06052037,0x10423c74,0x16471c43,0x016c608c,0x076940bb,0x112e5cf8,0x172b7ccf,0x0a20801d,0x0c25a02a,0x1a62bc69,0x1c679c5e,0x0b4ce091,0x0d49c0a6,0x1b0edce5,0x1d0bfcd2}, + [16]uint32{0x3f800000,0x3f830290,0x3f88211e,0x3f8b238e,0x3f80b630,0x3f83b4a0,0x3f88972e,0x3f8b95be,0x3f851040,0x3f8612d0,0x3f8d315e,0x3f8e33ce,0x3f85a670,0x3f86a4e0,0x3f8d876e,0x3f8e85fe}, + uint32(0xfff80000), + [21]string{"0x56","0x92","0xc7","0x71","0xc4","0xe9","0x4d","0x92","0xdc","0xbb","0x7f","0xca","0x0d","0xc7","0xe1","0x44","0xde","0x50","0xe1","0xd1","0x00"} }, + { + /* No.478 delta:2293 weight:1169 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x03773cb0,0x5ab6d4e0,0x59c1e850,0x1b401de9,0x18372159,0x41f6c909,0x4281f5b9,0x000004f2,0x03773842,0x5ab6d012,0x59c1eca2,0x1b40191b,0x183725ab,0x41f6cdfb,0x4281f14b}, + [16]uint32{0x00000000,0xa75012d6,0x2c5c1073,0x8b0c02a5,0x02da413c,0xa58a53ea,0x2e86514f,0x89d64399,0x22bc6018,0x85ec72ce,0x0ee0706b,0xa9b062bd,0x20662124,0x873633f2,0x0c3a3157,0xab6a2381}, + [16]uint32{0x3f800000,0x3fd3a809,0x3f962e08,0x3fc58601,0x3f816d20,0x3fd2c529,0x3f974328,0x3fc4eb21,0x3f915e30,0x3fc2f639,0x3f877038,0x3fd4d831,0x3f903310,0x3fc39b19,0x3f861d18,0x3fd5b511}, + uint32(0xfff80000), + [21]string{"0x2b","0x0a","0x30","0xdf","0x64","0x4e","0xf5","0x76","0xac","0x6c","0x8c","0xbc","0x7f","0x19","0x7e","0x4f","0x81","0x59","0x5d","0xa6","0x00"} }, + { + /* No.479 delta:791 weight:1715 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x539b6779,0xda60077c,0x89fb6005,0x2ea01dfd,0x7d3b7a84,0xf4c01a81,0xa75b7df8,0x00008ebd,0x539be9c4,0xda6089c1,0x89fbeeb8,0x2ea09340,0x7d3bf439,0xf4c0943c,0xa75bf345}, + [16]uint32{0x00000000,0x0074511a,0x14901889,0x14e44993,0x000a11cb,0x007e40d1,0x149a0942,0x14ee5858,0x0003001c,0x00775106,0x14931895,0x14e7498f,0x000911d7,0x007d40cd,0x1499095e,0x14ed5844}, + [16]uint32{0x3f800000,0x3f803a28,0x3f8a480c,0x3f8a7224,0x3f800508,0x3f803f20,0x3f8a4d04,0x3f8a772c,0x3f800180,0x3f803ba8,0x3f8a498c,0x3f8a73a4,0x3f800488,0x3f803ea0,0x3f8a4c84,0x3f8a76ac}, + uint32(0xfff80000), + [21]string{"0x0d","0x78","0xe7","0xaa","0x59","0xa3","0x84","0x11","0xef","0x4d","0x42","0x34","0xd3","0x52","0x22","0x2f","0x7c","0xce","0xac","0x83","0x00"} }, + { + /* No.480 delta:1595 weight:1647 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0xbd2c5e77,0xb22dc09c,0x0f019eeb,0x3bb01e08,0x869c407f,0x899dde94,0x34b180e3,0x0000c58d,0xbd2c9bfa,0xb22d0511,0x0f015b66,0x3bb0db85,0x869c85f2,0x899d1b19,0x34b1456e}, + [16]uint32{0x00000000,0x086d0b5a,0x0812c0b7,0x007fcbed,0x3073801e,0x381e8b44,0x386140a9,0x300c4bf3,0x4072c0e6,0x481fcbbc,0x48600051,0x400d0b0b,0x700140f8,0x786c4ba2,0x7813804f,0x707e8b15}, + [16]uint32{0x3f800000,0x3f843685,0x3f840960,0x3f803fe5,0x3f9839c0,0x3f9c0f45,0x3f9c30a0,0x3f980625,0x3fa03960,0x3fa40fe5,0x3fa43000,0x3fa00685,0x3fb800a0,0x3fbc3625,0x3fbc09c0,0x3fb83f45}, + uint32(0xfff80000), + [21]string{"0xa5","0xd7","0xca","0x72","0xf2","0x58","0xa0","0x42","0x12","0xcf","0x8c","0x91","0xdf","0xbb","0x30","0x7d","0x2e","0xcd","0xf7","0x31","0x00"} }, + { + /* No.481 delta:661 weight:1585 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0x8706d6f8,0x9a56f601,0x1d5020f9,0xa3201e10,0x2426c8e8,0x3976e811,0xbe703ee9,0x0000aace,0x87067c36,0x9a565ccf,0x1d508a37,0xa320b4de,0x24266226,0x397642df,0xbe709427}, + [16]uint32{0x00000000,0x003ad475,0x1003c1d2,0x103915a7,0x1000300a,0x103ae47f,0x0003f1d8,0x003925ad,0xb00486da,0xb03e52af,0xa0074708,0xa03d937d,0xa004b6d0,0xa03e62a5,0xb0077702,0xb03da377}, + [16]uint32{0x3f800000,0x3f801d6a,0x3f8801e0,0x3f881c8a,0x3f880018,0x3f881d72,0x3f8001f8,0x3f801c92,0x3fd80243,0x3fd81f29,0x3fd003a3,0x3fd01ec9,0x3fd0025b,0x3fd01f31,0x3fd803bb,0x3fd81ed1}, + uint32(0xfff80000), + [21]string{"0x8b","0x7f","0x7e","0x4f","0xc3","0x10","0x72","0x81","0x14","0xfe","0xb0","0x5b","0x7e","0x02","0x7d","0x2c","0x67","0x07","0x22","0x64","0x00"} }, + { + /* No.482 delta:1427 weight:1483 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0xe4a1391a,0x8e203bc0,0x6a8102da,0x9ed01e29,0x7a712733,0x10f025e9,0xf4511cf3,0x0000aa49,0xe4a19353,0x8e209189,0x6a81a893,0x9ed0b460,0x7a718d7a,0x10f08fa0,0xf451b6ba}, + [16]uint32{0x00000000,0x0055a05a,0x002d21dc,0x00788186,0x0024e04d,0x00714017,0x0009c191,0x005c61cb,0x26012068,0x26548032,0x262c01b4,0x2679a1ee,0x2625c025,0x2670607f,0x2608e1f9,0x265d41a3}, + [16]uint32{0x3f800000,0x3f802ad0,0x3f801690,0x3f803c40,0x3f801270,0x3f8038a0,0x3f8004e0,0x3f802e30,0x3f930090,0x3f932a40,0x3f931600,0x3f933cd0,0x3f9312e0,0x3f933830,0x3f930470,0x3f932ea0}, + uint32(0xfff80000), + [21]string{"0xf3","0x09","0x00","0xdd","0x80","0x3f","0x75","0x9a","0xc3","0x5c","0x4f","0x26","0x48","0x9d","0xf9","0x76","0x59","0xa1","0xf3","0xbd","0x00"} }, + { + /* No.483 delta:895 weight:1643 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x4cfacd5b,0x27cd4160,0x6b378c3b,0xa8b01e31,0xe44ad36a,0x8f7d5f51,0xc387920a,0x000098a4,0x4cfa55ff,0x27cdd9c4,0x6b37149f,0xa8b08695,0xe44a4bce,0x8f7dc7f5,0xc3870aae}, + [16]uint32{0x00000000,0x014440bf,0x2002818d,0x2146c132,0x00031944,0x014759fb,0x200198c9,0x2145d876,0x1000c0a8,0x11448017,0x30024125,0x3146019a,0x1003d9ec,0x11479953,0x30015861,0x314518de}, + [16]uint32{0x3f800000,0x3f80a220,0x3f900140,0x3f90a360,0x3f80018c,0x3f80a3ac,0x3f9000cc,0x3f90a2ec,0x3f880060,0x3f88a240,0x3f980120,0x3f98a300,0x3f8801ec,0x3f88a3cc,0x3f9800ac,0x3f98a28c}, + uint32(0xfff80000), + [21]string{"0x89","0x3f","0x9f","0xbf","0x6d","0xff","0x9f","0x6c","0xfd","0x8e","0xef","0x64","0x30","0xad","0xc5","0x03","0x35","0xe5","0xe9","0xe4","0x00"} }, + { + /* No.484 delta:1190 weight:1435 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0xf2958c1f,0xcd7d7078,0x3fe8fc67,0x8e601e49,0x7cf59256,0x431d6e31,0xb188e22e,0x0000eabe,0xf29566a1,0xcd7d9ac6,0x3fe816d9,0x8e60f4f7,0x7cf578e8,0x431d848f,0xb1880890}, + [16]uint32{0x00000000,0x4815193e,0x00495842,0x485c417c,0x00383075,0x482d294b,0x00716837,0x48647109,0x000d0013,0x4818192d,0x00445851,0x4851416f,0x00353066,0x48202958,0x007c6824,0x4869711a}, + [16]uint32{0x3f800000,0x3fa40a8c,0x3f8024ac,0x3fa42e20,0x3f801c18,0x3fa41694,0x3f8038b4,0x3fa43238,0x3f800680,0x3fa40c0c,0x3f80222c,0x3fa428a0,0x3f801a98,0x3fa41014,0x3f803e34,0x3fa434b8}, + uint32(0xfff80000), + [21]string{"0x54","0xe9","0x22","0x78","0x5d","0xe4","0xa7","0xbc","0x18","0x76","0xac","0x5b","0x66","0x30","0xbb","0x80","0xb4","0xa7","0xc2","0x63","0x00"} }, + { + /* No.485 delta:1384 weight:1657 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0x5a57ad1b,0x036a3d74,0x593d906f,0x6e801e5f,0x34d7b344,0x6dea232b,0x37bd8e30,0x0000d457,0x5a57794c,0x036ae923,0x593d4438,0x6e80ca08,0x34d76713,0x6deaf77c,0x37bd5a67}, + [16]uint32{0x00000000,0x40245dbe,0x107e60d7,0x505a3d69,0x1020141c,0x500449a2,0x005e74cb,0x407a2975,0x0040581f,0x406405a1,0x103e38c8,0x501a6576,0x10604c03,0x504411bd,0x001e2cd4,0x403a716a}, + [16]uint32{0x3f800000,0x3fa0122e,0x3f883f30,0x3fa82d1e,0x3f88100a,0x3fa80224,0x3f802f3a,0x3fa03d14,0x3f80202c,0x3fa03202,0x3f881f1c,0x3fa80d32,0x3f883026,0x3fa82208,0x3f800f16,0x3fa01d38}, + uint32(0xfff80000), + [21]string{"0x86","0x73","0xee","0xd6","0x35","0x0a","0x6e","0x88","0x98","0x23","0x58","0x03","0xcd","0x66","0x13","0xda","0x6f","0xf4","0xa8","0x9c","0x00"} }, + { + /* No.486 delta:789 weight:981 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0xb85eea7e,0xcc10c616,0x744e2c68,0x21901e68,0x99cef416,0xed80d87e,0x55de3200,0x00004652,0xb85eac2c,0xcc108044,0x744e6a3a,0x2190583a,0x99ceb244,0xed809e2c,0x55de7452}, + [16]uint32{0x00000000,0x0046c133,0x2003020f,0x2045c33c,0xa0141115,0xa052d026,0x8017131a,0x8051d229,0x5000881b,0x50464928,0x70038a14,0x70454b27,0xf014990e,0xf052583d,0xd0179b01,0xd0515a32}, + [16]uint32{0x3f800000,0x3f802360,0x3f900181,0x3f9022e1,0x3fd00a08,0x3fd02968,0x3fc00b89,0x3fc028e9,0x3fa80044,0x3fa82324,0x3fb801c5,0x3fb822a5,0x3ff80a4c,0x3ff8292c,0x3fe80bcd,0x3fe828ad}, + uint32(0xfff80000), + [21]string{"0x39","0xa7","0x43","0x82","0x10","0xf1","0x92","0xf4","0x2f","0x72","0x84","0x17","0x0b","0xc0","0xf2","0x11","0x07","0x37","0x0a","0x5f","0x00"} }, + { + /* No.487 delta:809 weight:1233 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x9d9a9223,0x96c66987,0x0b5cfba4,0x5e301e79,0xc3aa8c5a,0xc8f677fe,0x556ce5dd,0x00005333,0x9d9ac110,0x96c63ab4,0x0b5ca897,0x5e304d4a,0xc3aadf69,0xc8f624cd,0x556cb6ee}, + [16]uint32{0x00000000,0x80022115,0x100280ff,0x9000a1ea,0x00022151,0x80000044,0x1000a1ae,0x900280bb,0x2002d816,0xa000f903,0x300058e9,0xb00279fc,0x2000f947,0xa002d852,0x300279b8,0xb00058ad}, + [16]uint32{0x3f800000,0x3fc00110,0x3f880140,0x3fc80050,0x3f800110,0x3fc00000,0x3f880050,0x3fc80140,0x3f90016c,0x3fd0007c,0x3f98002c,0x3fd8013c,0x3f90007c,0x3fd0016c,0x3f98013c,0x3fd8002c}, + uint32(0xfff80000), + [21]string{"0x7e","0xb6","0xab","0x08","0x94","0x26","0x29","0x6d","0x64","0x90","0x30","0x0b","0xf2","0x59","0x96","0x33","0x0c","0x56","0x49","0x6e","0x00"} }, + { + /* No.488 delta:767 weight:1605 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x83dbce25,0x0f7c1229,0x8ca7dc0c,0xf4401e86,0x779bd0a3,0xfb3c0caf,0x78e7c28a,0x00008620,0x83db4805,0x0f7c9409,0x8ca75a2c,0xf44098a6,0x779b5683,0xfb3c8a8f,0x78e744aa}, + [16]uint32{0x00000000,0x0068101e,0x00020509,0x006a1517,0x8029900b,0x80418015,0x802b9502,0x8043851c,0x10014807,0x10695819,0x10034d0e,0x106b5d10,0x9028d80c,0x9040c812,0x902add05,0x9042cd1b}, + [16]uint32{0x3f800000,0x3f803408,0x3f800102,0x3f80350a,0x3fc014c8,0x3fc020c0,0x3fc015ca,0x3fc021c2,0x3f8800a4,0x3f8834ac,0x3f8801a6,0x3f8835ae,0x3fc8146c,0x3fc82064,0x3fc8156e,0x3fc82166}, + uint32(0xfff80000), + [21]string{"0x8d","0xa5","0x7f","0x9e","0x3f","0x68","0x4c","0xbb","0xb0","0x3c","0xf5","0x1f","0x8a","0xe6","0xaf","0x78","0xbc","0x05","0x6b","0x83","0x00"} }, + { + /* No.489 delta:659 weight:1469 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0x965af929,0x55575ec4,0xc30da7ed,0x1b301e90,0x8d6ae7b9,0x4e674054,0xd83db97d,0x0000d995,0x965a20bc,0x55578751,0xc30d7e78,0x1b30c705,0x8d6a3e2c,0x4e6799c1,0xd83d60e8}, + [16]uint32{0x00000000,0x4003ec1e,0x10031935,0x5000f52b,0x001029b2,0x4013c5ac,0x10133087,0x5010dc99,0x80001213,0xc003fe0d,0x90030b26,0xd000e738,0x80103ba1,0xc013d7bf,0x90132294,0xd010ce8a}, + [16]uint32{0x3f800000,0x3fa001f6,0x3f88018c,0x3fa8007a,0x3f800814,0x3fa009e2,0x3f880998,0x3fa8086e,0x3fc00009,0x3fe001ff,0x3fc80185,0x3fe80073,0x3fc0081d,0x3fe009eb,0x3fc80991,0x3fe80867}, + uint32(0xfff80000), + [21]string{"0x86","0x7f","0xad","0xde","0xa5","0x0a","0x4a","0x94","0x67","0xe3","0xcf","0x91","0xe1","0xc5","0x2e","0x2e","0x81","0x54","0xf4","0x76","0x00"} }, + { + /* No.490 delta:2006 weight:1357 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x2c3a57a8,0x7d913669,0x51ab61c1,0x8bc01ea9,0xa7fa4901,0xf65128c0,0xda6b7f68,0x0000fb64,0x2c3aaccc,0x7d91cd0d,0x51ab9aa5,0x8bc0e5cd,0xa7fab265,0xf651d3a4,0xda6b840c}, + [16]uint32{0x00000000,0x21a4a05e,0x0a8105db,0x2b25a585,0x0494814a,0x25302114,0x0e158491,0x2fb124cf,0x6090251d,0x41348543,0x6a1120c6,0x4bb58098,0x6404a457,0x45a00409,0x6e85a18c,0x4f2101d2}, + [16]uint32{0x3f800000,0x3f90d250,0x3f854082,0x3f9592d2,0x3f824a40,0x3f929810,0x3f870ac2,0x3f97d892,0x3fb04812,0x3fa09a42,0x3fb50890,0x3fa5dac0,0x3fb20252,0x3fa2d002,0x3fb742d0,0x3fa79080}, + uint32(0xfff80000), + [21]string{"0xf4","0x0f","0xf1","0x1f","0xed","0xdf","0xba","0x86","0xea","0x9b","0xa8","0x8b","0x2f","0x20","0x30","0x95","0xb0","0x77","0x5c","0xdf","0x00"} }, + { + /* No.491 delta:1573 weight:1665 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x4eff2c33,0xed467d5f,0xa3b9516c,0x71701eba,0x3f8f3289,0x9c3663e5,0xd2c94fd6,0x00008ae3,0x4effa6d0,0xed46f7bc,0xa3b9db8f,0x71709459,0x3f8fb86a,0x9c36e906,0xd2c9c535}, + [16]uint32{0x00000000,0x0838791a,0x80101447,0x88286d5d,0xaae4a1e4,0xa2dcd8fe,0x2af4b5a3,0x22ccccb9,0x00714116,0x0849380c,0x80615551,0x88592c4b,0xaa95e0f2,0xa2ad99e8,0x2a85f4b5,0x22bd8daf}, + [16]uint32{0x3f800000,0x3f841c3c,0x3fc0080a,0x3fc41436,0x3fd57250,0x3fd16e6c,0x3f957a5a,0x3f916666,0x3f8038a0,0x3f84249c,0x3fc030aa,0x3fc42c96,0x3fd54af0,0x3fd156cc,0x3f9542fa,0x3f915ec6}, + uint32(0xfff80000), + [21]string{"0x43","0x78","0xfc","0x4c","0xe1","0x28","0x2a","0x91","0x6f","0x5d","0x7e","0x43","0x67","0x9f","0x17","0x74","0xb9","0xdb","0xa8","0x88","0x00"} }, + { + /* No.492 delta:1070 weight:1409 */ + 11213, + 64, + 13, + 4, + [16]uint32{0x00000000,0xe9cd57ea,0x44cf19b4,0xad024e5e,0x56201ec3,0xbfed4929,0x12ef0777,0xfb22509d,0x0000116d,0xe9cd4687,0x44cf08d9,0xad025f33,0x56200fae,0xbfed5844,0x12ef161a,0xfb2241f0}, + [16]uint32{0x00000000,0x5002c79a,0x00032c0d,0x5001eb97,0x304c83cc,0x604e4456,0x304fafc1,0x604d685b,0x5003880f,0x00014f95,0x5000a402,0x00026398,0x604f0bc3,0x304dcc59,0x604c27ce,0x304ee054}, + [16]uint32{0x3f800000,0x3fa80163,0x3f800196,0x3fa800f5,0x3f982641,0x3fb02722,0x3f9827d7,0x3fb026b4,0x3fa801c4,0x3f8000a7,0x3fa80052,0x3f800131,0x3fb02785,0x3f9826e6,0x3fb02613,0x3f982770}, + uint32(0xfff80000), + [21]string{"0x24","0x8c","0x8b","0x31","0xdd","0x5d","0xe3","0xe4","0x00","0x26","0x0e","0x6c","0x42","0xd3","0x46","0xe7","0xbd","0xe8","0x67","0x1a","0x00"} }, + { + /* No.493 delta:1753 weight:1735 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x02767588,0xd0730661,0xd20573e9,0xea701edc,0xe8066b54,0x3a0318bd,0x38756d35,0x0000b317,0x0276c69f,0xd073b576,0xd205c0fe,0xea70adcb,0xe806d843,0x3a03abaa,0x3875de22}, + [16]uint32{0x00000000,0x4006005e,0x00020072,0x4004002c,0x00000114,0x4006014a,0x00020166,0x40040138,0x10200041,0x5026001f,0x10220033,0x5024006d,0x10200155,0x5026010b,0x10220127,0x50240179}, + [16]uint32{0x3f800000,0x3fa00300,0x3f800100,0x3fa00200,0x3f800000,0x3fa00300,0x3f800100,0x3fa00200,0x3f881000,0x3fa81300,0x3f881100,0x3fa81200,0x3f881000,0x3fa81300,0x3f881100,0x3fa81200}, + uint32(0xfff80000), + [21]string{"0xfb","0x9b","0x0c","0xbf","0x75","0x1e","0xf4","0x4d","0xef","0xcf","0x64","0x01","0xe6","0x8d","0x4a","0x9d","0x74","0x82","0xa5","0xda","0x00"} }, + { + /* No.494 delta:709 weight:1577 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0xd24d494b,0x90952c70,0x42d8653b,0xf1f01ee5,0x23bd57ae,0x61653295,0xb3287bde,0x00009a06,0xd24dd34d,0x9095b676,0x42d8ff3d,0xf1f084e3,0x23bdcda8,0x6165a893,0xb328e1d8}, + [16]uint32{0x00000000,0x701e4a16,0x0044181b,0x705a520d,0x20020581,0x501c4f97,0x20461d9a,0x5058578c,0x0003f013,0x701dba05,0x0047e808,0x7059a21e,0x2001f592,0x501fbf84,0x2045ed89,0x505ba79f}, + [16]uint32{0x3f800000,0x3fb80f25,0x3f80220c,0x3fb82d29,0x3f900102,0x3fa80e27,0x3f90230e,0x3fa82c2b,0x3f8001f8,0x3fb80edd,0x3f8023f4,0x3fb82cd1,0x3f9000fa,0x3fa80fdf,0x3f9022f6,0x3fa82dd3}, + uint32(0xfff80000), + [21]string{"0xb7","0xb7","0x54","0x7d","0x9e","0x50","0x47","0x13","0xf5","0x7c","0x05","0x29","0xdd","0x89","0x3b","0x34","0xd7","0x53","0x65","0x79","0x00"} }, + { + /* No.495 delta:1028 weight:1515 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x2fb43edf,0x2e937a41,0x0127449e,0x2a201efc,0x05942023,0x04b364bd,0x2b075a62,0x0000280c,0x2fb416d3,0x2e93524d,0x01276c92,0x2a2036f0,0x0594082f,0x04b34cb1,0x2b07726e}, + [16]uint32{0x00000000,0x001401b6,0x20021c51,0x20161de7,0x204180b2,0x20558104,0x00439ce3,0x00579d55,0x00138018,0x000781ae,0x20119c49,0x20059dff,0x205200aa,0x2046011c,0x00501cfb,0x00441d4d}, + [16]uint32{0x3f800000,0x3f800a00,0x3f90010e,0x3f900b0e,0x3f9020c0,0x3f902ac0,0x3f8021ce,0x3f802bce,0x3f8009c0,0x3f8003c0,0x3f9008ce,0x3f9002ce,0x3f902900,0x3f902300,0x3f80280e,0x3f80220e}, + uint32(0xfff80000), + [21]string{"0x4a","0x8b","0x2b","0xb5","0xdb","0x72","0x65","0xb0","0x8e","0xe3","0x03","0x95","0x6a","0xe2","0x5b","0x6c","0xe7","0xa9","0xbe","0xab","0x00"} }, + { + /* No.496 delta:752 weight:939 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0xa4c1cbc4,0x361ad6d9,0x92db1d1d,0xcfa01f0b,0x6b61d4cf,0xf9bac9d2,0x5d7b0216,0x00007250,0xa4c1b994,0x361aa489,0x92db6f4d,0xcfa06d5b,0x6b61a69f,0xf9babb82,0x5d7b7046}, + [16]uint32{0x00000000,0x0002515e,0x004b220a,0x00497354,0x400522b9,0x400773e7,0x404e00b3,0x404c51ed,0x30059904,0x3007c85a,0x304ebb0e,0x304cea50,0x7000bbbd,0x7002eae3,0x704b99b7,0x7049c8e9}, + [16]uint32{0x3f800000,0x3f800128,0x3f802591,0x3f8024b9,0x3fa00291,0x3fa003b9,0x3fa02700,0x3fa02628,0x3f9802cc,0x3f9803e4,0x3f98275d,0x3f982675,0x3fb8005d,0x3fb80175,0x3fb825cc,0x3fb824e4}, + uint32(0xfff80000), + [21]string{"0xa1","0x8c","0x80","0x23","0xeb","0xa3","0xb8","0x86","0xd7","0xc0","0x2b","0xe6","0xf1","0x09","0x7d","0x9c","0xef","0xeb","0xee","0xae","0x00"} }, + { + /* No.497 delta:1099 weight:1519 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x271f9562,0xbbf030da,0x9cefa5b8,0xb7701f10,0x906f8a72,0x0c802fca,0x2b9fbaa8,0x0000198d,0x271f8cef,0xbbf02957,0x9cefbc35,0xb770069d,0x906f93ff,0x0c803647,0x2b9fa325}, + [16]uint32{0x00000000,0x800ba41e,0xf010fd4d,0x701b5953,0x0003c6b9,0x800862a7,0xf0133bf4,0x70189fea,0x20081606,0xa003b218,0xd018eb4b,0x50134f55,0x200bd0bf,0xa00074a1,0xd01b2df2,0x501089ec}, + [16]uint32{0x3f800000,0x3fc005d2,0x3ff8087e,0x3fb80dac,0x3f8001e3,0x3fc00431,0x3ff8099d,0x3fb80c4f,0x3f90040b,0x3fd001d9,0x3fe80c75,0x3fa809a7,0x3f9005e8,0x3fd0003a,0x3fe80d96,0x3fa80844}, + uint32(0xfff80000), + [21]string{"0x27","0xc2","0x53","0x1a","0x1b","0xd5","0xc1","0x6f","0xd2","0xbb","0xb2","0xc3","0x27","0xd1","0xb9","0x8f","0xcd","0x32","0x22","0x81","0x00"} }, + { + /* No.498 delta:1303 weight:1655 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x1733fa30,0xe70844d6,0xf03bbee6,0x35701f23,0x2243e513,0xd2785bf5,0xc54ba1c5,0x00005582,0x1733afb2,0xe7081154,0xf03beb64,0x35704aa1,0x2243b091,0xd2780e77,0xc54bf447}, + [16]uint32{0x00000000,0x184428f6,0x007b940e,0x183fbcf8,0x0006500d,0x184278fb,0x007dc403,0x1839ecf5,0x30085014,0x284c78e2,0x3073c41a,0x2837ecec,0x300e0019,0x284a28ef,0x30759417,0x2831bce1}, + [16]uint32{0x3f800000,0x3f8c2214,0x3f803dca,0x3f8c1fde,0x3f800328,0x3f8c213c,0x3f803ee2,0x3f8c1cf6,0x3f980428,0x3f94263c,0x3f9839e2,0x3f941bf6,0x3f980700,0x3f942514,0x3f983aca,0x3f9418de}, + uint32(0xfff80000), + [21]string{"0x03","0x29","0x0f","0x56","0xb2","0x78","0x76","0x1a","0x98","0x00","0x16","0xe4","0x87","0x2b","0xd0","0xea","0x7e","0x3d","0x1a","0x34","0x00"} }, + { + /* No.499 delta:975 weight:939 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0x31621f00,0x006813a0,0x310a0ca0,0xed401f38,0xdc220038,0xed280c98,0xdc4a1398,0x00004b3d,0x3162543d,0x0068589d,0x310a479d,0xed405405,0xdc224b05,0xed2847a5,0xdc4a58a5}, + [16]uint32{0x00000000,0x2d009196,0x00984bdf,0x2d98da49,0x080ea1d9,0x250e304f,0x0896ea06,0x25967b90,0x2074060a,0x0d74979c,0x20ec4dd5,0x0decdc43,0x287aa7d3,0x057a3645,0x28e2ec0c,0x05e27d9a}, + [16]uint32{0x3f800000,0x3f968048,0x3f804c25,0x3f96cc6d,0x3f840750,0x3f928718,0x3f844b75,0x3f92cb3d,0x3f903a03,0x3f86ba4b,0x3f907626,0x3f86f66e,0x3f943d53,0x3f82bd1b,0x3f947176,0x3f82f13e}, + uint32(0xfff80000), + [21]string{"0x62","0x1f","0x93","0x6c","0xc5","0x17","0x97","0x43","0x43","0x22","0x46","0x0f","0xe9","0x69","0xff","0x1c","0x86","0xe4","0xca","0x55","0x00"} }, + { + /* No.500 delta:842 weight:1647 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0xdefa9e3b,0xb4c11010,0x6a3b8e2b,0xe5a01f43,0x3b5a8178,0x51610f53,0x8f9b9168,0x0000857c,0xdefa1b47,0xb4c1956c,0x6a3b0b57,0xe5a09a3f,0x3b5a0404,0x51618a2f,0x8f9b1414}, + [16]uint32{0x00000000,0x29800f9a,0x80038465,0xa9838bff,0x4040381c,0x69c03786,0xc043bc79,0xe9c3b3e3,0x40000411,0x69800b8b,0xc0038074,0xe9838fee,0x00403c0d,0x29c03397,0x8043b868,0xa9c3b7f2}, + [16]uint32{0x3f800000,0x3f94c007,0x3fc001c2,0x3fd4c1c5,0x3fa0201c,0x3fb4e01b,0x3fe021de,0x3ff4e1d9,0x3fa00002,0x3fb4c005,0x3fe001c0,0x3ff4c1c7,0x3f80201e,0x3f94e019,0x3fc021dc,0x3fd4e1db}, + uint32(0xfff80000), + [21]string{"0x37","0x79","0xef","0x11","0xfa","0xbb","0xd1","0x60","0x6a","0x27","0x2d","0x86","0x86","0xe6","0xc0","0x06","0x38","0x2a","0x2f","0xd9","0x00"} }, + { + /* No.501 delta:1691 weight:1569 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x1d0833ab,0x1a2e9cbe,0x0726af15,0xed401f5d,0xf0482cf6,0xf76e83e3,0xea66b048,0x00000923,0x1d083a88,0x1a2e959d,0x0726a636,0xed40167e,0xf04825d5,0xf76e8ac0,0xea66b96b}, + [16]uint32{0x00000000,0x0b4a0674,0x172a7607,0x1c607073,0x120c01cb,0x194607bf,0x052677cc,0x0e6c71b8,0x01089009,0x0a42967d,0x1622e60e,0x1d68e07a,0x130491c2,0x184e97b6,0x042ee7c5,0x0f64e1b1}, + [16]uint32{0x3f800000,0x3f85a503,0x3f8b953b,0x3f8e3038,0x3f890600,0x3f8ca303,0x3f82933b,0x3f873638,0x3f808448,0x3f85214b,0x3f8b1173,0x3f8eb470,0x3f898248,0x3f8c274b,0x3f821773,0x3f87b270}, + uint32(0xfff80000), + [21]string{"0x84","0xae","0x26","0x5d","0x95","0x7a","0xf4","0x77","0x7d","0x0d","0xaa","0x7b","0x7d","0x47","0xc2","0xf8","0xbe","0x0a","0x1b","0x73","0x00"} }, + { + /* No.502 delta:738 weight:1295 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x94c874ca,0x9fe20cc4,0x0b2a780e,0xa5b01f6e,0x31786ba4,0x3a5213aa,0xae9a6760,0x0000862d,0x94c8f2e7,0x9fe28ae9,0x0b2afe23,0xa5b09943,0x3178ed89,0x3a529587,0xae9ae14d}, + [16]uint32{0x00000000,0xb0524a12,0x420c81f1,0xf25ecbe3,0x00201169,0xb0725b7b,0x422c9098,0xf27eda8a,0x0049718c,0xb01b3b9e,0x4245f07d,0xf217ba6f,0x006960e5,0xb03b2af7,0x4265e114,0xf237ab06}, + [16]uint32{0x3f800000,0x3fd82925,0x3fa10640,0x3ff92f65,0x3f801008,0x3fd8392d,0x3fa11648,0x3ff93f6d,0x3f8024b8,0x3fd80d9d,0x3fa122f8,0x3ff90bdd,0x3f8034b0,0x3fd81d95,0x3fa132f0,0x3ff91bd5}, + uint32(0xfff80000), + [21]string{"0xf4","0xff","0x04","0x85","0x9a","0x6f","0x4a","0x9a","0x26","0x75","0xb2","0x6c","0xd6","0x26","0x47","0xc0","0x62","0x9b","0xe7","0x2e","0x00"} }, + { + /* No.503 delta:2181 weight:1281 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x259c0784,0xe28c721e,0xc710759a,0x25401f7f,0x00dc18fb,0xc7cc6d61,0xe2506ae5,0x00004b77,0x259c4cf3,0xe28c3969,0xc7103eed,0x25405408,0x00dc538c,0xc7cc2616,0xe2502192}, + [16]uint32{0x00000000,0x090deb3e,0x87b08223,0x8ebd691d,0x210a9879,0x28077347,0xa6ba1a5a,0xafb7f164,0x40316418,0x493c8f26,0xc781e63b,0xce8c0d05,0x613bfc61,0x6836175f,0xe68b7e42,0xef86957c}, + [16]uint32{0x3f800000,0x3f8486f5,0x3fc3d841,0x3fc75eb4,0x3f90854c,0x3f9403b9,0x3fd35d0d,0x3fd7dbf8,0x3fa018b2,0x3fa49e47,0x3fe3c0f3,0x3fe74606,0x3fb09dfe,0x3fb41b0b,0x3ff345bf,0x3ff7c34a}, + uint32(0xfff80000), + [21]string{"0xc7","0xf7","0x07","0xf3","0x63","0x0c","0x7c","0x71","0xf2","0x55","0x74","0x61","0xbf","0x57","0xb6","0xdf","0x32","0x37","0x21","0x96","0x00"} }, + { + /* No.504 delta:766 weight:1267 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x9f43d775,0x7b36ec44,0xe4753b31,0x74d01f8c,0xeb93c8f9,0x0fe6f3c8,0x90a524bd,0x00005f7d,0x9f438808,0x7b36b339,0xe475644c,0x74d040f1,0xeb939784,0x0fe6acb5,0x90a57bc0}, + [16]uint32{0x00000000,0x2060b0f7,0x10022a24,0x30629ad3,0x014d20fb,0x212d900c,0x114f0adf,0x312fba28,0x00648019,0x200430ee,0x1066aa3d,0x30061aca,0x0129a0e2,0x21491015,0x112b8ac6,0x314b3a31}, + [16]uint32{0x3f800000,0x3f903058,0x3f880115,0x3f98314d,0x3f80a690,0x3f9096c8,0x3f88a785,0x3f9897dd,0x3f803240,0x3f900218,0x3f883355,0x3f98030d,0x3f8094d0,0x3f90a488,0x3f8895c5,0x3f98a59d}, + uint32(0xfff80000), + [21]string{"0x06","0x85","0x1b","0xdf","0x27","0xea","0x66","0x92","0x13","0x05","0x26","0x34","0xeb","0x54","0x5d","0x3e","0xfb","0xbb","0xf7","0x9b","0x00"} }, + { + /* No.505 delta:979 weight:1611 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x55df1c42,0x8ec3866e,0xdb1c9a2c,0x1b901f95,0x4e4f03d7,0x955399fb,0xc08c85b9,0x00009220,0x55df8e62,0x8ec3144e,0xdb1c080c,0x1b908db5,0x4e4f91f7,0x95530bdb,0xc08c1799}, + [16]uint32{0x00000000,0x380c955a,0x020248b3,0x3a0edde9,0x20025374,0x180ec62e,0x22001bc7,0x1a0c8e9d,0x0003d32f,0x380f4675,0x02019b9c,0x3a0d0ec6,0x2001805b,0x180d1501,0x2203c8e8,0x1a0f5db2}, + [16]uint32{0x3f800000,0x3f9c064a,0x3f810124,0x3f9d076e,0x3f900129,0x3f8c0763,0x3f91000d,0x3f8d0647,0x3f8001e9,0x3f9c07a3,0x3f8100cd,0x3f9d0687,0x3f9000c0,0x3f8c068a,0x3f9101e4,0x3f8d07ae}, + uint32(0xfff80000), + [21]string{"0x23","0x3c","0x47","0x37","0x48","0xb7","0x8d","0x06","0xe7","0xe9","0x33","0x18","0xc6","0xd8","0xf4","0x2b","0x78","0x66","0x85","0xa7","0x00"} }, + { + /* No.506 delta:855 weight:1625 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0x170efc48,0x3770a1e3,0x207e5dab,0x24701fa9,0x337ee3e1,0x1300be4a,0x040e4202,0x00002a96,0x170ed6de,0x37708b75,0x207e773d,0x2470353f,0x337ec977,0x130094dc,0x040e6894}, + [16]uint32{0x00000000,0x00060af6,0x0482020d,0x048408fb,0x0002d201,0x0004d8f7,0x0480d00c,0x0486dafa,0x10409885,0x10469273,0x14c29a88,0x14c4907e,0x10424a84,0x10444072,0x14c04889,0x14c6427f}, + [16]uint32{0x3f800000,0x3f800305,0x3f824101,0x3f824204,0x3f800169,0x3f80026c,0x3f824068,0x3f82436d,0x3f88204c,0x3f882349,0x3f8a614d,0x3f8a6248,0x3f882125,0x3f882220,0x3f8a6024,0x3f8a6321}, + uint32(0xfff80000), + [21]string{"0x64","0x5b","0x4e","0x08","0x23","0x49","0x7e","0x85","0x00","0x16","0x27","0x0a","0x54","0x38","0xfc","0x4a","0x36","0xe2","0xe3","0xbe","0x00"} }, + { + /* No.507 delta:1930 weight:1461 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0x3a0ab12a,0x860dc6e0,0xbc0777ca,0xa5001fbe,0x9f0aae94,0x230dd95e,0x19076874,0x0000b52e,0x3a0a0404,0x860d73ce,0xbc07c2e4,0xa500aa90,0x9f0a1bba,0x230d6c70,0x1907dd5a}, + [16]uint32{0x00000000,0x34803133,0x0840201a,0x3cc01129,0x400180a8,0x7481b19b,0x4841a0b2,0x7cc19181,0x228c2dac,0x160c1c9f,0x2acc0db6,0x1e4c3c85,0x628dad04,0x560d9c37,0x6acd8d1e,0x5e4dbc2d}, + [16]uint32{0x3f800000,0x3f9a4018,0x3f842010,0x3f9e6008,0x3fa000c0,0x3fba40d8,0x3fa420d0,0x3fbe60c8,0x3f914616,0x3f8b060e,0x3f956606,0x3f8f261e,0x3fb146d6,0x3fab06ce,0x3fb566c6,0x3faf26de}, + uint32(0xfff80000), + [21]string{"0xca","0x23","0xf1","0x6b","0x02","0x95","0x73","0x85","0xc6","0xbc","0xb6","0xc0","0xb7","0xc8","0xe9","0xab","0x24","0xe5","0x9c","0xbc","0x00"} }, + { + /* No.508 delta:1148 weight:1473 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x3e476448,0x2d19b410,0x135ed058,0x77701fc7,0x49377b8f,0x5a69abd7,0x642ecf9f,0x000014ac,0x3e4770e4,0x2d19a0bc,0x135ec4f4,0x77700b6b,0x49376f23,0x5a69bf7b,0x642edb33}, + [16]uint32{0x00000000,0x054cc11e,0x003a7ab1,0x0576bbaf,0x00dc8b87,0x05904a99,0x00e6f136,0x05aa3028,0x00034012,0x054f810c,0x00393aa3,0x0575fbbd,0x00dfcb95,0x05930a8b,0x00e5b124,0x05a9703a}, + [16]uint32{0x3f800000,0x3f82a660,0x3f801d3d,0x3f82bb5d,0x3f806e45,0x3f82c825,0x3f807378,0x3f82d518,0x3f8001a0,0x3f82a7c0,0x3f801c9d,0x3f82bafd,0x3f806fe5,0x3f82c985,0x3f8072d8,0x3f82d4b8}, + uint32(0xfff80000), + [21]string{"0x2e","0xa7","0xb8","0x82","0x69","0xd0","0xd3","0x6f","0x5a","0x01","0xd6","0x28","0xdc","0x82","0xed","0x83","0xc8","0x07","0x5a","0x0b","0x00"} }, + { + /* No.509 delta:925 weight:1687 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0x7b4a4f00,0xbacb592f,0xc181162f,0x9ca01fd3,0xe7ea50d3,0x266b46fc,0x5d2109fc,0x00000c91,0x7b4a4391,0xbacb55be,0xc1811abe,0x9ca01342,0xe7ea5c42,0x266b4a6d,0x5d21056d}, + [16]uint32{0x00000000,0x4003bc12,0x80244a47,0xc027f655,0x0000580a,0x4003e418,0x8024124d,0xc027ae5f,0x4000058e,0x0003b99c,0xc0244fc9,0x8027f3db,0x40005d84,0x0003e196,0xc02417c3,0x8027abd1}, + [16]uint32{0x3f800000,0x3fa001de,0x3fc01225,0x3fe013fb,0x3f80002c,0x3fa001f2,0x3fc01209,0x3fe013d7,0x3fa00002,0x3f8001dc,0x3fe01227,0x3fc013f9,0x3fa0002e,0x3f8001f0,0x3fe0120b,0x3fc013d5}, + uint32(0xfff80000), + [21]string{"0xce","0x41","0xdf","0xa3","0xed","0x34","0x9e","0x0d","0xcd","0xe8","0x7a","0xaa","0x8c","0xf2","0x32","0xd8","0xa7","0x47","0x5f","0xdc","0x00"} }, + { + /* No.510 delta:871 weight:1739 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xe9b1101c,0xaa673461,0x43d6247d,0x2c101fe6,0xc5a10ffa,0x86772b87,0x6fc63b9b,0x0000fe72,0xe9b1ee6e,0xaa67ca13,0x43d6da0f,0x2c10e194,0xc5a1f188,0x8677d5f5,0x6fc6c5e9}, + [16]uint32{0x00000000,0x20256a3e,0x20000c51,0x0025666f,0x200230f6,0x00275ac8,0x00023ca7,0x20275699,0x1000215a,0x30254b64,0x30002d0b,0x10254735,0x300211ac,0x10277b92,0x10021dfd,0x302777c3}, + [16]uint32{0x3f800000,0x3f9012b5,0x3f900006,0x3f8012b3,0x3f900118,0x3f8013ad,0x3f80011e,0x3f9013ab,0x3f880010,0x3f9812a5,0x3f980016,0x3f8812a3,0x3f980108,0x3f8813bd,0x3f88010e,0x3f9813bb}, + uint32(0xfff80000), + [21]string{"0xc6","0x00","0x8d","0x5d","0x6f","0xe5","0x56","0x01","0xd3","0xc9","0xee","0xa0","0x9d","0xf4","0xa3","0x87","0x70","0xf3","0x36","0x88","0x00"} }, + { + /* No.511 delta:824 weight:741 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x26a409c0,0xbfab6fe5,0x990f6625,0xc0801ffd,0xe624163d,0x7f2b7018,0x598f79d8,0x000072a2,0x26a47b62,0xbfab1d47,0x990f1487,0xc0806d5f,0xe624649f,0x7f2b02ba,0x598f0b7a}, + [16]uint32{0x00000000,0x38c204d7,0x204b8134,0x188985e3,0x0270160f,0x3ab212d8,0x223b973b,0x1af993ec,0x004a021d,0x388806ca,0x20018329,0x18c387fe,0x023a1412,0x3af810c5,0x22719526,0x1ab391f1}, + [16]uint32{0x3f800000,0x3f9c6102,0x3f9025c0,0x3f8c44c2,0x3f81380b,0x3f9d5909,0x3f911dcb,0x3f8d7cc9,0x3f802501,0x3f9c4403,0x3f9000c1,0x3f8c61c3,0x3f811d0a,0x3f9d7c08,0x3f9138ca,0x3f8d59c8}, + uint32(0xfff80000), + [21]string{"0xdb","0xf1","0x57","0xcc","0xf3","0xd1","0xab","0x93","0xd9","0xfd","0xd6","0xc0","0x7b","0x7e","0x6c","0x10","0x59","0x56","0x7c","0x00","0x00"} }, + { + /* No.512 delta:1155 weight:1527 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0x87785293,0x27be9c94,0xa0c6ce07,0xbd00200e,0x3a78729d,0x9abebc9a,0x1dc6ee09,0x00002d9f,0x87787f0c,0x27beb10b,0xa0c6e398,0xbd000d91,0x3a785f02,0x9abe9105,0x1dc6c396}, + [16]uint32{0x00000000,0x62048374,0x106b4159,0x726fc22d,0x004028de,0x6244abaa,0x102b6987,0x722feaf3,0x40040c1c,0x22008f68,0x506f4d45,0x326bce31,0x404424c2,0x2240a7b6,0x502f659b,0x322be6ef}, + [16]uint32{0x3f800000,0x3fb10241,0x3f8835a0,0x3fb937e1,0x3f802014,0x3fb12255,0x3f8815b4,0x3fb917f5,0x3fa00206,0x3f910047,0x3fa837a6,0x3f9935e7,0x3fa02212,0x3f912053,0x3fa817b2,0x3f9915f3}, + uint32(0xfff80000), + [21]string{"0x2f","0xf5","0x9f","0xfd","0x60","0xbf","0x71","0x7b","0x30","0x49","0xf0","0x60","0x3d","0xf9","0xdb","0x5f","0xfd","0x35","0xd9","0xf4","0x00"} }, + { + /* No.513 delta:2160 weight:1327 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xce66cb8e,0xa5b50647,0x6bd3cdc9,0xeae0201c,0x2486eb92,0x4f55265b,0x8133edd5,0x00008c09,0xce664787,0xa5b58a4e,0x6bd341c0,0xeae0ac15,0x2486679b,0x4f55aa52,0x813361dc}, + [16]uint32{0x00000000,0x0e84f4b6,0x01001bca,0x0f84ef7c,0x40a40413,0x4e20f0a5,0x41a41fd9,0x4f20eb6f,0x86a80402,0x882cf0b4,0x87a81fc8,0x892ceb7e,0xc60c0011,0xc888f4a7,0xc70c1bdb,0xc988ef6d}, + [16]uint32{0x3f800000,0x3f87427a,0x3f80800d,0x3f87c277,0x3fa05202,0x3fa71078,0x3fa0d20f,0x3fa79075,0x3fc35402,0x3fc41678,0x3fc3d40f,0x3fc49675,0x3fe30600,0x3fe4447a,0x3fe3860d,0x3fe4c477}, + uint32(0xfff80000), + [21]string{"0x86","0xe7","0x33","0x4f","0x95","0x55","0xe5","0x2f","0x2f","0xf0","0x98","0xae","0x89","0x27","0x8b","0x3b","0xea","0xa5","0xd2","0x3c","0x00"} }, + { + /* No.514 delta:932 weight:1229 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x2cf347b3,0xf0355ca5,0xdcc61b16,0xeb70202e,0xc783679d,0x1b457c8b,0x37b63b38,0x0000e034,0x2cf3a787,0xf035bc91,0xdcc6fb22,0xeb70c01a,0xc78387a9,0x1b459cbf,0x37b6db0c}, + [16]uint32{0x00000000,0x202c15d2,0x1020a18d,0x300cb45f,0x8027601c,0xa00b75ce,0x9007c191,0xb02bd443,0x00023219,0x202e27cb,0x10229394,0x300e8646,0x80255205,0xa00947d7,0x9005f388,0xb029e65a}, + [16]uint32{0x3f800000,0x3f90160a,0x3f881050,0x3f98065a,0x3fc013b0,0x3fd005ba,0x3fc803e0,0x3fd815ea,0x3f800119,0x3f901713,0x3f881149,0x3f980743,0x3fc012a9,0x3fd004a3,0x3fc802f9,0x3fd814f3}, + uint32(0xfff80000), + [21]string{"0x73","0xd0","0xc5","0x1c","0xc2","0x8b","0x63","0x1f","0x12","0x4a","0xf1","0x31","0x9e","0x05","0xc2","0x9f","0x40","0xdd","0xa6","0x69","0x00"} }, + { + /* No.515 delta:1421 weight:1681 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0x70c0ae96,0xca93687c,0xba53c6ea,0x10302035,0x60f08ea3,0xdaa34849,0xaa63e6df,0x00005744,0x70c0f9d2,0xca933f38,0xba5391ae,0x10307771,0x60f0d9e7,0xdaa31f0d,0xaa63b19b}, + [16]uint32{0x00000000,0x20036036,0x3000001b,0x1003602d,0x308d212a,0x108e411c,0x008d2131,0x208e4107,0x000000c5,0x200360f3,0x300000de,0x100360e8,0x308d21ef,0x108e41d9,0x008d21f4,0x208e41c2}, + [16]uint32{0x3f800000,0x3f9001b0,0x3f980000,0x3f8801b0,0x3f984690,0x3f884720,0x3f804690,0x3f904720,0x3f800000,0x3f9001b0,0x3f980000,0x3f8801b0,0x3f984690,0x3f884720,0x3f804690,0x3f904720}, + uint32(0xfff80000), + [21]string{"0x5e","0x19","0x83","0x9a","0xe2","0x58","0x35","0x9a","0x2e","0xc6","0x5c","0x6f","0x0c","0x99","0xfa","0x23","0x0b","0xc8","0x65","0x5e","0x00"} }, + { + /* No.516 delta:2642 weight:857 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x1884afd0,0x6afbbc31,0x727f13e1,0xa540204a,0xbdc48f9a,0xcfbb9c7b,0xd73f33ab,0x00002020,0x18848ff0,0x6afb9c11,0x727f33c1,0xa540006a,0xbdc4afba,0xcfbbbc5b,0xd73f138b}, + [16]uint32{0x00000000,0xeb40121c,0x5a2883e3,0xb16891ff,0x55180235,0xbe581029,0x0f3081d6,0xe47093ca,0x14a20127,0xffe2133b,0x4e8a82c4,0xa5ca90d8,0x41ba0312,0xaafa110e,0x1b9280f1,0xf0d292ed}, + [16]uint32{0x3f800000,0x3ff5a009,0x3fad1441,0x3fd8b448,0x3faa8c01,0x3fdf2c08,0x3f879840,0x3ff23849,0x3f8a5100,0x3ffff109,0x3fa74541,0x3fd2e548,0x3fa0dd01,0x3fd57d08,0x3f8dc940,0x3ff86949}, + uint32(0xfff80000), + [21]string{"0x8a","0xd8","0xe6","0x8c","0x89","0x7d","0xc4","0x12","0x88","0x81","0x6b","0x92","0xa8","0x51","0xf8","0x3c","0x43","0x95","0x28","0x13","0x00"} }, + { + /* No.517 delta:3108 weight:621 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x08e91d00,0x2e92e32f,0x267bfe2f,0x8c202052,0x84c93d52,0xa2b2c37d,0xaa5bde7d,0x00001bb1,0x08e906b1,0x2e92f89e,0x267be59e,0x8c203be3,0x84c926e3,0xa2b2d8cc,0xaa5bc5cc}, + [16]uint32{0x00000000,0xd14a003a,0x24112134,0xf55b210e,0x0e39449d,0xdf7344a7,0x2a2865a9,0xfb626593,0x21d8588c,0xf09258b6,0x05c979b8,0xd4837982,0x2fe11c11,0xfeab1c2b,0x0bf03d25,0xdaba3d1f}, + [16]uint32{0x3f800000,0x3fe8a500,0x3f920890,0x3ffaad90,0x3f871ca2,0x3fefb9a2,0x3f951432,0x3ffdb132,0x3f90ec2c,0x3ff8492c,0x3f82e4bc,0x3fea41bc,0x3f97f08e,0x3fff558e,0x3f85f81e,0x3fed5d1e}, + uint32(0xfff80000), + [21]string{"0x87","0xc2","0x43","0xa0","0xbf","0x42","0xc6","0x5a","0x3d","0xbd","0x8f","0x7b","0x96","0x17","0x9f","0xe7","0x83","0xff","0xfe","0xfd","0x00"} }, + { + /* No.518 delta:1221 weight:1699 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0xbe7c1fc3,0x2c7bf787,0x9207e844,0xc6702065,0x780c3fa6,0xea0bd7e2,0x5477c821,0x0000ece0,0xbe7cf323,0x2c7b1b67,0x920704a4,0xc670cc85,0x780cd346,0xea0b3b02,0x547724c1}, + [16]uint32{0x00000000,0x4061481a,0x0074068f,0x40154e95,0x04148dd6,0x4475c5cc,0x04608b59,0x4401c343,0x80083004,0xc069781e,0x807c368b,0xc01d7e91,0x841cbdd2,0xc47df5c8,0x8468bb5d,0xc409f347}, + [16]uint32{0x3f800000,0x3fa030a4,0x3f803a03,0x3fa00aa7,0x3f820a46,0x3fa23ae2,0x3f823045,0x3fa200e1,0x3fc00418,0x3fe034bc,0x3fc03e1b,0x3fe00ebf,0x3fc20e5e,0x3fe23efa,0x3fc2345d,0x3fe204f9}, + uint32(0xfff80000), + [21]string{"0xaa","0x0e","0xfd","0x66","0x1e","0xcb","0x06","0x51","0x18","0x32","0x59","0x68","0x00","0x67","0x96","0x9a","0x6c","0x1d","0xe4","0xf5","0x00"} }, + { + /* No.519 delta:868 weight:1283 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0xe80ff725,0x5677fca4,0xbe780b81,0x72b02078,0x9abfd75d,0x24c7dcdc,0xccc82bf9,0x0000939b,0xe80f64be,0x56776f3f,0xbe78981a,0x72b0b3e3,0x9abf44c6,0x24c74f47,0xccc8b862}, + [16]uint32{0x00000000,0x007c121e,0x00121bca,0x006e09d4,0x40021611,0x407e040f,0x40100ddb,0x406c1fc5,0x1001225c,0x107d3042,0x10133996,0x106f2b88,0x5003344d,0x507f2653,0x50112f87,0x506d3d99}, + [16]uint32{0x3f800000,0x3f803e09,0x3f80090d,0x3f803704,0x3fa0010b,0x3fa03f02,0x3fa00806,0x3fa0360f,0x3f880091,0x3f883e98,0x3f88099c,0x3f883795,0x3fa8019a,0x3fa83f93,0x3fa80897,0x3fa8369e}, + uint32(0xfff80000), + [21]string{"0x5e","0x97","0xad","0x3e","0x61","0xfb","0x49","0x2d","0x78","0x49","0xf1","0x71","0xc5","0xc7","0x21","0x22","0xde","0x54","0x98","0x49","0x00"} }, + { + /* No.520 delta:940 weight:1315 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x6b3e4fd6,0x3212cc5c,0x592c838a,0x61b0208c,0x0a8e6f5a,0x53a2ecd0,0x389ca306,0x0000af84,0x6b3ee052,0x321263d8,0x592c2c0e,0x61b08f08,0x0a8ec0de,0x53a24354,0x389c0c82}, + [16]uint32{0x00000000,0x0464813f,0x0079406e,0x041dc151,0x40264844,0x4442c97b,0x405f082a,0x443b8915,0x00047912,0x0460f82d,0x007d397c,0x0419b843,0x40223156,0x4446b069,0x405b7138,0x443ff007}, + [16]uint32{0x3f800000,0x3f823240,0x3f803ca0,0x3f820ee0,0x3fa01324,0x3fa22164,0x3fa02f84,0x3fa21dc4,0x3f80023c,0x3f82307c,0x3f803e9c,0x3f820cdc,0x3fa01118,0x3fa22358,0x3fa02db8,0x3fa21ff8}, + uint32(0xfff80000), + [21]string{"0x95","0xf9","0x4c","0xf4","0x9f","0xcb","0x0b","0xf9","0xe6","0x3b","0x7a","0xd5","0x04","0x1c","0x90","0xdc","0x09","0xd7","0xf4","0x25","0x00"} }, + { + /* No.521 delta:751 weight:1163 */ + 11213, + 58, + 13, + 4, + [16]uint32{0x00000000,0xc76cbb46,0x460db42c,0x81610f6a,0xf1e02090,0x368c9bd6,0xb7ed94bc,0x70812ffa,0x0000287a,0xc76c933c,0x460d9c56,0x81612710,0xf1e008ea,0x368cb3ac,0xb7edbcc6,0x70810780}, + [16]uint32{0x00000000,0x000751fd,0x0003431e,0x000412e3,0x5008e018,0x500fb1e5,0x500ba306,0x500cf2fb,0x2018760a,0x201f27f7,0x201b3514,0x201c64e9,0x70109612,0x7017c7ef,0x7013d50c,0x701484f1}, + [16]uint32{0x3f800000,0x3f8003a8,0x3f8001a1,0x3f800209,0x3fa80470,0x3fa807d8,0x3fa805d1,0x3fa80679,0x3f900c3b,0x3f900f93,0x3f900d9a,0x3f900e32,0x3fb8084b,0x3fb80be3,0x3fb809ea,0x3fb80a42}, + uint32(0xfff80000), + [21]string{"0xdf","0x20","0xca","0xe9","0xfa","0xaf","0x33","0xf7","0xcf","0xe9","0xd9","0x75","0x19","0xee","0xfb","0x13","0x5f","0xc4","0xe8","0x07","0x00"} }, + { + /* No.522 delta:1021 weight:1541 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xee60dd0c,0xe2bf0b40,0x0cdfd64c,0x918020ac,0x7fe0fda0,0x733f2bec,0x9d5ff6e0,0x00007f2b,0xee60a227,0xe2bf746b,0x0cdfa967,0x91805f87,0x7fe0828b,0x733f54c7,0x9d5f89cb}, + [16]uint32{0x00000000,0x300281f6,0x5001009f,0x60038169,0x0002601c,0x3000e1ea,0x50036083,0x6001e175,0x60004818,0x5002c9ee,0x30014887,0x0003c971,0x60022804,0x5000a9f2,0x3003289b,0x0001a96d}, + [16]uint32{0x3f800000,0x3f980140,0x3fa80080,0x3fb001c0,0x3f800130,0x3f980070,0x3fa801b0,0x3fb000f0,0x3fb00024,0x3fa80164,0x3f9800a4,0x3f8001e4,0x3fb00114,0x3fa80054,0x3f980194,0x3f8000d4}, + uint32(0xfff80000), + [21]string{"0xb6","0x42","0xb3","0x91","0x61","0x41","0x63","0x9a","0x5a","0xf2","0x92","0xba","0x92","0xfa","0x26","0xee","0xeb","0xa2","0x67","0xa9","0x00"} }, + { + /* No.523 delta:866 weight:1625 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0xca08d772,0xc1b4ae65,0x0bbc7917,0xcc2020b5,0x0628f7c7,0x0d948ed0,0xc79c59a2,0x000047a0,0xca0890d2,0xc1b4e9c5,0x0bbc3eb7,0xcc206715,0x0628b067,0x0d94c970,0xc79c1e02}, + [16]uint32{0x00000000,0x10041e1a,0x20039039,0x30078e23,0x00012196,0x10053f8c,0x2002b1af,0x3006afb5,0x1000707e,0x00046e64,0x3003e047,0x2007fe5d,0x100151e8,0x00054ff2,0x3002c1d1,0x2006dfcb}, + [16]uint32{0x3f800000,0x3f88020f,0x3f9001c8,0x3f9803c7,0x3f800090,0x3f88029f,0x3f900158,0x3f980357,0x3f880038,0x3f800237,0x3f9801f0,0x3f9003ff,0x3f8800a8,0x3f8002a7,0x3f980160,0x3f90036f}, + uint32(0xfff80000), + [21]string{"0x3d","0xcb","0xcc","0x7b","0xa0","0xbf","0x2a","0xf5","0x90","0x94","0xdd","0x67","0x81","0x76","0x1e","0x40","0xda","0x4e","0x1d","0xa3","0x00"} }, + { + /* No.524 delta:1005 weight:1233 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x73945edf,0xcf5c4fe1,0xbcc8113e,0x06e020ce,0x75747e11,0xc9bc6f2f,0xba2831f0,0x000043fd,0x73941d22,0xcf5c0c1c,0xbcc852c3,0x06e06333,0x75743dec,0xc9bc2cd2,0xba28720d}, + [16]uint32{0x00000000,0x006ad0b2,0x08440986,0x082ed934,0x1002801a,0x106850a8,0x1846899c,0x182c592e,0x00001a9f,0x006aca2d,0x08441319,0x082ec3ab,0x10029a85,0x10684a37,0x18469303,0x182c43b1}, + [16]uint32{0x3f800000,0x3f803568,0x3f842204,0x3f84176c,0x3f880140,0x3f883428,0x3f8c2344,0x3f8c162c,0x3f80000d,0x3f803565,0x3f842209,0x3f841761,0x3f88014d,0x3f883425,0x3f8c2349,0x3f8c1621}, + uint32(0xfff80000), + [21]string{"0x3f","0x15","0xdb","0xe5","0xf3","0xfd","0x2e","0x67","0x96","0xa0","0xbc","0xee","0x9b","0x8c","0xe6","0x82","0x10","0x50","0x4f","0xaf","0x00"} }, + { + /* No.525 delta:696 weight:1293 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0x8619f1d5,0x2306a2ae,0xa51f537b,0xac2020d7,0x2a39d102,0x8f268279,0x093f73ac,0x00000901,0x8619f8d4,0x2306abaf,0xa51f5a7a,0xac2029d6,0x2a39d803,0x8f268b78,0x093f7aad}, + [16]uint32{0x00000000,0x30760532,0x200b0011,0x107d0523,0x00413418,0x3037312a,0x204a3409,0x103c313b,0x0021600e,0x3057653c,0x202a601f,0x105c652d,0x00605416,0x30165124,0x206b5407,0x101d5135}, + [16]uint32{0x3f800000,0x3f983b02,0x3f900580,0x3f883e82,0x3f80209a,0x3f981b98,0x3f90251a,0x3f881e18,0x3f8010b0,0x3f982bb2,0x3f901530,0x3f882e32,0x3f80302a,0x3f980b28,0x3f9035aa,0x3f880ea8}, + uint32(0xfff80000), + [21]string{"0xd0","0x25","0xe2","0xae","0x30","0x67","0x30","0xa6","0x0e","0x2a","0xaa","0x14","0x30","0x01","0x17","0x1d","0x6e","0x2b","0x04","0x42","0x00"} }, + { + /* No.526 delta:919 weight:1573 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0xecd500d4,0x0b96a1db,0xe743a10f,0xcaf020e0,0x26252034,0xc166813b,0x2db381ef,0x0000b14e,0xecd5b19a,0x0b961095,0xe7431041,0xcaf091ae,0x2625917a,0xc1663075,0x2db330a1}, + [16]uint32{0x00000000,0x305de097,0x200200a5,0x105fe032,0x00034c18,0x305eac8f,0x20014cbd,0x105cac2a,0x50050019,0x6058e08e,0x700700bc,0x405ae02b,0x50064c01,0x605bac96,0x70044ca4,0x4059ac33}, + [16]uint32{0x3f800000,0x3f982ef0,0x3f900100,0x3f882ff0,0x3f8001a6,0x3f982f56,0x3f9000a6,0x3f882e56,0x3fa80280,0x3fb02c70,0x3fb80380,0x3fa02d70,0x3fa80326,0x3fb02dd6,0x3fb80226,0x3fa02cd6}, + uint32(0xfff80000), + [21]string{"0xff","0x22","0xd9","0x6c","0xc5","0xcd","0xd0","0xa0","0xcf","0x50","0xd6","0x1a","0xa1","0xc2","0x11","0x9e","0x9c","0xa9","0xcc","0xae","0x00"} }, + { + /* No.527 delta:1935 weight:1457 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0xfc225ba0,0x742ebe4f,0x880ce5ef,0x4c4020fb,0xb0627b5b,0x386e9eb4,0xc44cc514,0x00003ee1,0xfc226541,0x742e80ae,0x880cdb0e,0x4c401e1a,0xb06245ba,0x386ea055,0xc44cfbf5}, + [16]uint32{0x00000000,0x0c2409be,0x28012182,0x2425283c,0x10008416,0x1c248da8,0x3801a594,0x3425ac2a,0x0a13840f,0x06378db1,0x2212a58d,0x2e36ac33,0x1a130019,0x163709a7,0x3212219b,0x3e362825}, + [16]uint32{0x3f800000,0x3f861204,0x3f940090,0x3f921294,0x3f880042,0x3f8e1246,0x3f9c00d2,0x3f9a12d6,0x3f8509c2,0x3f831bc6,0x3f910952,0x3f971b56,0x3f8d0980,0x3f8b1b84,0x3f990910,0x3f9f1b14}, + uint32(0xfff80000), + [21]string{"0xaf","0x0c","0xcc","0xd1","0x2b","0x2a","0xb8","0xdc","0xfe","0x84","0x16","0xda","0x8d","0x9a","0x6e","0xfc","0xed","0xe8","0xb4","0xab","0x00"} }, + { + /* No.528 delta:1000 weight:1189 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x2de15ca2,0x0cef7303,0x210e2fa1,0x22702103,0x0f917da1,0x2e9f5200,0x037e0ea2,0x000086e4,0x2de1da46,0x0ceff5e7,0x210ea945,0x2270a7e7,0x0f91fb45,0x2e9fd4e4,0x037e8846}, + [16]uint32{0x00000000,0x182e01de,0x0002b097,0x182cb149,0x0009e012,0x1827e1cc,0x000b5085,0x1825515b,0x400e019f,0x58200041,0x400cb108,0x5822b0d6,0x4007e18d,0x5829e053,0x4005511a,0x582b50c4}, + [16]uint32{0x3f800000,0x3f8c1700,0x3f800158,0x3f8c1658,0x3f8004f0,0x3f8c13f0,0x3f8005a8,0x3f8c12a8,0x3fa00700,0x3fac1000,0x3fa00658,0x3fac1158,0x3fa003f0,0x3fac14f0,0x3fa002a8,0x3fac15a8}, + uint32(0xfff80000), + [21]string{"0x99","0xa0","0xc4","0xb6","0x54","0xa9","0x6d","0x83","0x09","0x43","0xf9","0x31","0x8d","0xcd","0x34","0xfb","0x24","0xf7","0x6e","0x54","0x00"} }, + { + /* No.529 delta:829 weight:1699 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x71cae969,0x0fef3654,0x7e25df3d,0x21402113,0x508ac87a,0x2eaf1747,0x5f65fe2e,0x0000dd55,0x71ca343c,0x0fefeb01,0x7e250268,0x2140fc46,0x508a152f,0x2eafca12,0x5f65237b}, + [16]uint32{0x00000000,0x80020492,0x400201b6,0xc0000524,0x200001ef,0xa002057d,0x60020059,0xe00004cb,0x05218811,0x85238c83,0x452389a7,0xc5218d35,0x252189fe,0xa5238d6c,0x65238848,0xe5218cda}, + [16]uint32{0x3f800000,0x3fc00102,0x3fa00100,0x3fe00002,0x3f900000,0x3fd00102,0x3fb00100,0x3ff00002,0x3f8290c4,0x3fc291c6,0x3fa291c4,0x3fe290c6,0x3f9290c4,0x3fd291c6,0x3fb291c4,0x3ff290c6}, + uint32(0xfff80000), + [21]string{"0x16","0x3a","0xc1","0x00","0xdc","0xf2","0x82","0x39","0x11","0x7d","0xe6","0x33","0xc3","0xad","0x09","0x5a","0xfe","0x5a","0x22","0xff","0x00"} }, + { + /* No.530 delta:881 weight:1203 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x3e4c2af6,0xad4ff67e,0x9303dc88,0xe0a02120,0xdeec0bd6,0x4defd75e,0x73a3fda8,0x0000f19a,0x3e4cdb6c,0xad4f07e4,0x93032d12,0xe0a0d0ba,0xdeecfa4c,0x4def26c4,0x73a30c32}, + [16]uint32{0x00000000,0x00655e1d,0x611d611a,0x61783f07,0x000341a5,0x00661fb8,0x611e20bf,0x617b7ea2,0x0044c176,0x00219f6b,0x6159a06c,0x613cfe71,0x004780d3,0x0022dece,0x615ae1c9,0x613fbfd4}, + [16]uint32{0x3f800000,0x3f8032af,0x3fb08eb0,0x3fb0bc1f,0x3f8001a0,0x3f80330f,0x3fb08f10,0x3fb0bdbf,0x3f802260,0x3f8010cf,0x3fb0acd0,0x3fb09e7f,0x3f8023c0,0x3f80116f,0x3fb0ad70,0x3fb09fdf}, + uint32(0xfff80000), + [21]string{"0x2f","0xb6","0x72","0x3f","0x72","0x6a","0xb8","0x55","0x63","0xff","0xf8","0xd0","0xaa","0x76","0x69","0x80","0x03","0x44","0x7b","0x3a","0x00"} }, + { + /* No.531 delta:890 weight:1451 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x3508c08f,0x598443ed,0x6c8c8362,0xb8002138,0x8d08e1b7,0xe18462d5,0xd48ca25a,0x000092b0,0x3508523f,0x5984d15d,0x6c8c11d2,0xb800b388,0x8d087307,0xe184f065,0xd48c30ea}, + [16]uint32{0x00000000,0x40029cbd,0x10060ce3,0x5004905e,0x000300fb,0x40019c46,0x10050c18,0x500790a5,0x1000180c,0x500284b1,0x000614ef,0x40048852,0x100318f7,0x5001844a,0x00051414,0x400788a9}, + [16]uint32{0x3f800000,0x3fa0014e,0x3f880306,0x3fa80248,0x3f800180,0x3fa000ce,0x3f880286,0x3fa803c8,0x3f88000c,0x3fa80142,0x3f80030a,0x3fa00244,0x3f88018c,0x3fa800c2,0x3f80028a,0x3fa003c4}, + uint32(0xfff80000), + [21]string{"0x75","0xfe","0x4f","0xb9","0xda","0xd1","0x10","0x9a","0x79","0xe3","0x31","0x2e","0x8c","0x51","0xf6","0x90","0x4f","0xda","0x2e","0xa0","0x00"} }, + { + /* No.532 delta:943 weight:1581 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0xa90fb87a,0x3ce8537c,0x95e7eb06,0xf620214e,0x5f2f9934,0xcac87232,0x63c7ca48,0x000048da,0xa90ff0a0,0x3ce81ba6,0x95e7a3dc,0xf6206994,0x5f2fd1ee,0xcac83ae8,0x63c78292}, + [16]uint32{0x00000000,0x00420055,0x0003419e,0x004141cb,0x0000881a,0x0042884f,0x0003c984,0x0041c9d1,0x203c3138,0x207e316d,0x203f70a6,0x207d70f3,0x203cb922,0x207eb977,0x203ff8bc,0x207df8e9}, + [16]uint32{0x3f800000,0x3f802100,0x3f8001a0,0x3f8020a0,0x3f800044,0x3f802144,0x3f8001e4,0x3f8020e4,0x3f901e18,0x3f903f18,0x3f901fb8,0x3f903eb8,0x3f901e5c,0x3f903f5c,0x3f901ffc,0x3f903efc}, + uint32(0xfff80000), + [21]string{"0x4f","0xc3","0x64","0xeb","0x40","0x4f","0x3b","0xf9","0x5b","0x6b","0xcf","0x99","0xd4","0xef","0x0d","0xc6","0xb1","0xe5","0x04","0xd1","0x00"} }, + { + /* No.533 delta:2031 weight:1369 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x88568c8f,0xf3727684,0x7b24fa0b,0xe940215e,0x6116add1,0x1a3257da,0x9264db55,0x00001ac7,0x88569648,0xf3726c43,0x7b24e0cc,0xe9403b99,0x6116b716,0x1a324d1d,0x9264c192}, + [16]uint32{0x00000000,0x05358432,0x0c80040b,0x09b58039,0x158c3186,0x10b9b5b4,0x190c358d,0x1c39b1bf,0x204625f5,0x2573a1c7,0x2cc621fe,0x29f3a5cc,0x35ca1473,0x30ff9041,0x394a1078,0x3c7f944a}, + [16]uint32{0x3f800000,0x3f829ac2,0x3f864002,0x3f84dac0,0x3f8ac618,0x3f885cda,0x3f8c861a,0x3f8e1cd8,0x3f902312,0x3f92b9d0,0x3f966310,0x3f94f9d2,0x3f9ae50a,0x3f987fc8,0x3f9ca508,0x3f9e3fca}, + uint32(0xfff80000), + [21]string{"0x29","0xa5","0x53","0x15","0xb5","0x8e","0x70","0x08","0x7b","0xc3","0x1f","0xfe","0x48","0x8b","0xfb","0x91","0x3a","0x6d","0x5d","0x7a","0x00"} }, + { + /* No.534 delta:1133 weight:1449 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0x109f073d,0x4d854320,0x5d1a441d,0x8c50216e,0x9ccf2653,0xc1d5624e,0xd14a6573,0x00006145,0x109f6678,0x4d852265,0x5d1a2558,0x8c50402b,0x9ccf4716,0xc1d5030b,0xd14a0436}, + [16]uint32{0x00000000,0x02071b7e,0x004ca419,0x024bbf67,0x00024096,0x02055be8,0x004ee48f,0x0249fff1,0x4018300c,0x421f2b72,0x40549415,0x42538f6b,0x401a709a,0x421d6be4,0x4056d483,0x4251cffd}, + [16]uint32{0x3f800000,0x3f81038d,0x3f802652,0x3f8125df,0x3f800120,0x3f8102ad,0x3f802772,0x3f8124ff,0x3fa00c18,0x3fa10f95,0x3fa02a4a,0x3fa129c7,0x3fa00d38,0x3fa10eb5,0x3fa02b6a,0x3fa128e7}, + uint32(0xfff80000), + [21]string{"0x40","0x8f","0x2f","0xbe","0x50","0x9c","0x0b","0xc9","0x23","0x60","0xce","0xe2","0x8c","0x7d","0x0e","0x13","0x80","0x29","0xa5","0x8e","0x00"} }, + { + /* No.535 delta:900 weight:1519 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0xfcab2249,0x1301a5c1,0xefaa8788,0x0eb02179,0xf21b0330,0x1db184b8,0xe11aa6f1,0x0000d9b7,0xfcabfbfe,0x13017c76,0xefaa5e3f,0x0eb0f8ce,0xf21bda87,0x1db15d0f,0xe11a7f46}, + [16]uint32{0x00000000,0x004390da,0x20035e03,0x2040ced9,0x5008e1d7,0x504b710d,0x700bbfd4,0x70482f0e,0x0000a046,0x0043309c,0x2003fe45,0x20406e9f,0x50084191,0x504bd14b,0x700b1f92,0x70488f48}, + [16]uint32{0x3f800000,0x3f8021c8,0x3f9001af,0x3f902067,0x3fa80470,0x3fa825b8,0x3fb805df,0x3fb82417,0x3f800050,0x3f802198,0x3f9001ff,0x3f902037,0x3fa80420,0x3fa825e8,0x3fb8058f,0x3fb82447}, + uint32(0xfff80000), + [21]string{"0x0e","0x7c","0xd8","0xbf","0x93","0x39","0x20","0x31","0x2b","0x29","0x2f","0xad","0xe5","0x60","0x07","0x06","0xf0","0xce","0xbf","0xda","0x00"} }, + { + /* No.536 delta:1464 weight:1661 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xfb4ed716,0x133c8328,0xe872543e,0x99b0218f,0x62fef699,0x8a8ca2a7,0x71c275b1,0x000072aa,0xfb4ea5bc,0x133cf182,0xe8722694,0x99b05325,0x62fe8433,0x8a8cd00d,0x71c2071b}, + [16]uint32{0x00000000,0x004029fe,0x4e64e0d8,0x4e24c926,0xc21b4074,0xc25b698a,0x8c7fa0ac,0x8c3f8952,0x003a4175,0x007a688b,0x4e5ea1ad,0x4e1e8853,0xc2210101,0xc26128ff,0x8c45e1d9,0x8c05c827}, + [16]uint32{0x3f800000,0x3f802014,0x3fa73270,0x3fa71264,0x3fe10da0,0x3fe12db4,0x3fc63fd0,0x3fc61fc4,0x3f801d20,0x3f803d34,0x3fa72f50,0x3fa70f44,0x3fe11080,0x3fe13094,0x3fc622f0,0x3fc602e4}, + uint32(0xfff80000), + [21]string{"0x8c","0x97","0xe4","0xbd","0x3c","0x81","0x04","0xdc","0xcd","0x97","0x82","0x0c","0xad","0x62","0xe3","0xb7","0xf2","0x3d","0xf6","0x61","0x00"} }, + { + /* No.537 delta:2148 weight:1369 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x5bfd1d30,0x60d1a7a5,0x3b2cba95,0xfed02196,0xa52d3ca6,0x9e018633,0xc5fc9b03,0x00002e81,0x5bfd33b1,0x60d18924,0x3b2c9414,0xfed00f17,0xa52d1227,0x9e01a8b2,0xc5fcb582}, + [16]uint32{0x00000000,0x1c0034f4,0x0208080e,0x1e083cfa,0x09040018,0x150434ec,0x0b0c0816,0x170c3ce2,0x1220a206,0x0e2096f2,0x1028aa08,0x0c289efc,0x1b24a21e,0x072496ea,0x192caa10,0x052c9ee4}, + [16]uint32{0x3f800000,0x3f8e001a,0x3f810404,0x3f8f041e,0x3f848200,0x3f8a821a,0x3f858604,0x3f8b861e,0x3f891051,0x3f87104b,0x3f881455,0x3f86144f,0x3f8d9251,0x3f83924b,0x3f8c9655,0x3f82964f}, + uint32(0xfff80000), + [21]string{"0xc2","0x36","0xf2","0x66","0xcc","0x1b","0x1c","0x2a","0x20","0xa7","0x46","0x50","0xec","0xd2","0xd6","0x0e","0x5b","0x83","0x2e","0xcd","0x00"} }, + { + /* No.538 delta:708 weight:1613 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0x9cb14c88,0xfa6f7a45,0x66de36cd,0x50a021a6,0xcc116d2e,0xaacf5be3,0x367e176b,0x0000b83e,0x9cb1f4b6,0xfa6fc27b,0x66de8ef3,0x50a09998,0xcc11d510,0xaacfe3dd,0x367eaf55}, + [16]uint32{0x00000000,0x0023433e,0x001028b1,0x00336b8f,0x2100d0b2,0x2123938c,0x2110f803,0x2133bb3d,0x40004616,0x40230528,0x40106ea7,0x40332d99,0x610096a4,0x6123d59a,0x6110be15,0x6133fd2b}, + [16]uint32{0x3f800000,0x3f8011a1,0x3f800814,0x3f8019b5,0x3f908068,0x3f9091c9,0x3f90887c,0x3f9099dd,0x3fa00023,0x3fa01182,0x3fa00837,0x3fa01996,0x3fb0804b,0x3fb091ea,0x3fb0885f,0x3fb099fe}, + uint32(0xfff80000), + [21]string{"0x23","0x66","0x6a","0xe2","0x68","0x07","0x37","0x50","0xd0","0xf9","0xac","0xbb","0x10","0x29","0xcf","0x1f","0x11","0x14","0xfd","0x53","0x00"} }, + { + /* No.539 delta:595 weight:1545 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0xd0895f38,0xfd6b6245,0x2de23d7d,0x6b4021b2,0xbbc97e8a,0x962b43f7,0x46a21ccf,0x0000d42b,0xd0898b13,0xfd6bb66e,0x2de2e956,0x6b40f599,0xbbc9aaa1,0x962b97dc,0x46a2c8e4}, + [16]uint32{0x00000000,0x4401541b,0x1802419d,0x5c031586,0x40402612,0x04417209,0x5842678f,0x1c433394,0x2002b803,0x6403ec18,0x3800f99e,0x7c01ad85,0x60429e11,0x2443ca0a,0x7840df8c,0x3c418b97}, + [16]uint32{0x3f800000,0x3fa200aa,0x3f8c0120,0x3fae018a,0x3fa02013,0x3f8220b9,0x3fac2133,0x3f8e2199,0x3f90015c,0x3fb201f6,0x3f9c007c,0x3fbe00d6,0x3fb0214f,0x3f9221e5,0x3fbc206f,0x3f9e20c5}, + uint32(0xfff80000), + [21]string{"0x35","0x85","0x51","0x8f","0xfb","0x07","0x00","0x28","0xad","0xf3","0xa5","0xc0","0xd7","0x38","0x07","0x26","0xc5","0xab","0xba","0x9a","0x00"} }, + { + /* No.540 delta:1110 weight:1529 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x21135886,0x8c1229fd,0xad01717b,0x3d8021ce,0x1c937948,0xb1920833,0x908150b5,0x00008e94,0x2113d612,0x8c12a769,0xad01ffef,0x3d80af5a,0x1c93f7dc,0xb19286a7,0x9081de21}, + [16]uint32{0x00000000,0xb04e16d2,0x78605ae3,0xc82e4c31,0x400c2c05,0xf0423ad7,0x386c76e6,0x88226034,0x0002021d,0xb04c14cf,0x786258fe,0xc82c4e2c,0x400e2e18,0xf04038ca,0x386e74fb,0x88206229}, + [16]uint32{0x3f800000,0x3fd8270b,0x3fbc302d,0x3fe41726,0x3fa00616,0x3ff8211d,0x3f9c363b,0x3fc41130,0x3f800101,0x3fd8260a,0x3fbc312c,0x3fe41627,0x3fa00717,0x3ff8201c,0x3f9c373a,0x3fc41031}, + uint32(0xfff80000), + [21]string{"0x37","0x49","0x93","0x4e","0x5c","0x24","0xa2","0x0b","0x56","0x99","0x3f","0xad","0xe4","0x97","0xd9","0xbd","0x4d","0xb1","0x8b","0x91","0x00"} }, + { + /* No.541 delta:2067 weight:1351 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x5a2ff8fe,0x326dc2b6,0x68423a48,0x037021d3,0x595fd92d,0x311de365,0x6b321b9b,0x0000b75e,0x5a2f4fa0,0x326d75e8,0x68428d16,0x0370968d,0x595f6e73,0x311d543b,0x6b32acc5}, + [16]uint32{0x00000000,0x287f21ba,0x0e0446ee,0x267b6754,0x01f28422,0x298da598,0x0ff6c2cc,0x2789e376,0x09008087,0x217fa13d,0x0704c669,0x2f7be7d3,0x08f204a5,0x208d251f,0x06f6424b,0x2e8963f1}, + [16]uint32{0x3f800000,0x3f943f90,0x3f870223,0x3f933db3,0x3f80f942,0x3f94c6d2,0x3f87fb61,0x3f93c4f1,0x3f848040,0x3f90bfd0,0x3f838263,0x3f97bdf3,0x3f847902,0x3f904692,0x3f837b21,0x3f9744b1}, + uint32(0xfff80000), + [21]string{"0x53","0x34","0x92","0xf8","0x0f","0x41","0x89","0x50","0x59","0x43","0x6c","0x71","0x00","0x5d","0xa3","0xa5","0x2c","0x54","0x1b","0xf0","0x00"} }, + { + /* No.542 delta:1168 weight:1381 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xc3ba3870,0xc960e4c4,0x0adadcb4,0x2b3021e6,0xe88a1996,0xe250c522,0x21eafd52,0x00001b17,0xc3ba2367,0xc960ffd3,0x0adac7a3,0x2b303af1,0xe88a0281,0xe250de35,0x21eae645}, + [16]uint32{0x00000000,0x00248d1e,0x0003b08a,0x00273d94,0x0a208012,0x0a040d0c,0x0a233098,0x0a07bd86,0x02048187,0x02200c99,0x0207310d,0x0223bc13,0x08240195,0x08008c8b,0x0827b11f,0x08033c01}, + [16]uint32{0x3f800000,0x3f801246,0x3f8001d8,0x3f80139e,0x3f851040,0x3f850206,0x3f851198,0x3f8503de,0x3f810240,0x3f811006,0x3f810398,0x3f8111de,0x3f841200,0x3f840046,0x3f8413d8,0x3f84019e}, + uint32(0xfff80000), + [21]string{"0xff","0x49","0x62","0x3a","0x76","0x10","0xd1","0xe2","0xb9","0x1b","0x7e","0x0a","0x40","0xa0","0xd8","0x64","0x1c","0x13","0x9e","0x1c","0x00"} }, + { + /* No.543 delta:676 weight:1575 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0x1ddf4c5e,0x8884e2ee,0x955baeb0,0x6d0021f5,0x70df6dab,0xe584c31b,0xf85b8f45,0x00001c20,0x1ddf507e,0x8884fece,0x955bb290,0x6d003dd5,0x70df718b,0xe584df3b,0xf85b9365}, + [16]uint32{0x00000000,0x5026c9de,0x4048010d,0x106ec8d3,0x400292ef,0x10245b31,0x004a93e2,0x506c5a3c,0x4001ca0a,0x102703d4,0x0049cb07,0x506f02d9,0x000358e5,0x5025913b,0x404b59e8,0x106d9036}, + [16]uint32{0x3f800000,0x3fa81364,0x3fa02400,0x3f883764,0x3fa00149,0x3f88122d,0x3f802549,0x3fa8362d,0x3fa000e5,0x3f881381,0x3f8024e5,0x3fa83781,0x3f8001ac,0x3fa812c8,0x3fa025ac,0x3f8836c8}, + uint32(0xfff80000), + [21]string{"0x0a","0x84","0x89","0xe8","0x9d","0xbf","0x19","0xc9","0xb3","0x63","0x6a","0xdf","0x85","0xe2","0x29","0x03","0x9a","0x2d","0x8f","0xf7","0x00"} }, + { + /* No.544 delta:1742 weight:1469 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0x1db1d24c,0x3eec97d6,0x235d459a,0xbff02201,0xa241f04d,0x811cb5d7,0x9cad679b,0x0000db96,0x1db109da,0x3eec4c40,0x235d9e0c,0xbff0f997,0xa2412bdb,0x811c6e41,0x9cadbc0d}, + [16]uint32{0x00000000,0x31384436,0x40c001b9,0x71f8458f,0x38b8807e,0x0980c448,0x787881c7,0x4940c5f1,0x52081018,0x6330542e,0x12c811a1,0x23f05597,0x6ab09066,0x5b88d450,0x2a7091df,0x1b48d5e9}, + [16]uint32{0x3f800000,0x3f989c22,0x3fa06000,0x3fb8fc22,0x3f9c5c40,0x3f84c062,0x3fbc3c40,0x3fa4a062,0x3fa90408,0x3fb1982a,0x3f896408,0x3f91f82a,0x3fb55848,0x3fadc46a,0x3f953848,0x3f8da46a}, + uint32(0xfff80000), + [21]string{"0x5d","0x57","0x9f","0xb9","0x09","0x68","0xaa","0x32","0x0b","0x19","0x00","0x5f","0xc2","0x02","0x33","0x83","0xc0","0x88","0xca","0x73","0x00"} }, + { + /* No.545 delta:830 weight:723 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0xee61c1c7,0x48d9eb95,0xa6b82a52,0xf9a02216,0x17c1e3d1,0xb179c983,0x5f180844,0x00006f97,0xee61ae50,0x48d98402,0xa6b845c5,0xf9a04d81,0x17c18c46,0xb179a614,0x5f1867d3}, + [16]uint32{0x00000000,0x10411315,0x603f901b,0x707e830e,0x102415f1,0x006506e4,0x701b85ea,0x605a96ff,0x10ac8194,0x00ed9281,0x7093118f,0x60d2029a,0x00889465,0x10c98770,0x60b7047e,0x70f6176b}, + [16]uint32{0x3f800000,0x3f882089,0x3fb01fc8,0x3fb83f41,0x3f88120a,0x3f803283,0x3fb80dc2,0x3fb02d4b,0x3f885640,0x3f8076c9,0x3fb84988,0x3fb06901,0x3f80444a,0x3f8864c3,0x3fb05b82,0x3fb87b0b}, + uint32(0xfff80000), + [21]string{"0xb5","0x09","0x80","0x60","0xc1","0x22","0xe5","0x13","0xa4","0x13","0x8a","0xcf","0x38","0xeb","0x40","0xb5","0x3e","0x96","0x89","0x04","0x00"} }, + { + /* No.546 delta:2306 weight:1231 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x9557ec1a,0x9e675f66,0x0b30b37c,0x2380222d,0xb6d7ce37,0xbde77d4b,0x28b09151,0x00002e09,0x9557c213,0x9e67716f,0x0b309d75,0x23800c24,0xb6d7e03e,0xbde75342,0x28b0bf58}, + [16]uint32{0x00000000,0x246a61f2,0x17e8907f,0x3382f18d,0x0d101161,0x297a7093,0x1af8811e,0x3e92e0ec,0x1a850135,0x3eef60c7,0x0d6d914a,0x2907f0b8,0x17951054,0x33ff71a6,0x007d802b,0x2417e1d9}, + [16]uint32{0x3f800000,0x3f923530,0x3f8bf448,0x3f99c178,0x3f868808,0x3f94bd38,0x3f8d7c40,0x3f9f4970,0x3f8d4280,0x3f9f77b0,0x3f86b6c8,0x3f9483f8,0x3f8bca88,0x3f99ffb8,0x3f803ec0,0x3f920bf0}, + uint32(0xfff80000), + [21]string{"0xf5","0x78","0xf8","0x7a","0xea","0xe8","0x7e","0x79","0x68","0x19","0x03","0xe7","0x2e","0x31","0x48","0x7f","0x24","0x1f","0xef","0xc1","0x00"} }, + { + /* No.547 delta:819 weight:1241 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x124cbc0f,0x7941082e,0x6b0db421,0xebc0223b,0xf98c9e34,0x92812a15,0x80cd961a,0x0000f4d0,0x124c48df,0x7941fcfe,0x6b0d40f1,0xebc0d6eb,0xf98c6ae4,0x9281dec5,0x80cd62ca}, + [16]uint32{0x00000000,0x4102013b,0x20022839,0x61002902,0xc001e047,0x8103e17c,0xe003c87e,0xa101c945,0x00402008,0x41422133,0x20420831,0x6140090a,0xc041c04f,0x8143c174,0xe043e876,0xa141e94d}, + [16]uint32{0x3f800000,0x3fa08100,0x3f900114,0x3fb08014,0x3fe000f0,0x3fc081f0,0x3ff001e4,0x3fd080e4,0x3f802010,0x3fa0a110,0x3f902104,0x3fb0a004,0x3fe020e0,0x3fc0a1e0,0x3ff021f4,0x3fd0a0f4}, + uint32(0xfff80000), + [21]string{"0xd8","0xd7","0xda","0x57","0xb2","0x55","0x76","0xb0","0x45","0x38","0x12","0x5b","0xeb","0x97","0x49","0xe6","0x15","0x53","0xc2","0x46","0x00"} }, + { + /* No.548 delta:1676 weight:1543 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0xf4586abb,0xe4feef64,0x10a685df,0xd8002240,0x2c5848fb,0x3cfecd24,0xc8a6a79f,0x0000ad37,0xf458c78c,0xe4fe4253,0x10a628e8,0xd8008f77,0x2c58e5cc,0x3cfe6013,0xc8a60aa8}, + [16]uint32{0x00000000,0x001451de,0x00420055,0x0056518b,0x0010007c,0x000451a2,0x00520029,0x004651f7,0x100000bf,0x10145161,0x104200ea,0x10565134,0x101000c3,0x1004511d,0x10520096,0x10465148}, + [16]uint32{0x3f800000,0x3f800a28,0x3f802100,0x3f802b28,0x3f800800,0x3f800228,0x3f802900,0x3f802328,0x3f880000,0x3f880a28,0x3f882100,0x3f882b28,0x3f880800,0x3f880228,0x3f882900,0x3f882328}, + uint32(0xfff80000), + [21]string{"0x2d","0x27","0x80","0xf8","0x2f","0xd3","0xe0","0x35","0x59","0x1e","0xbf","0xa6","0xf9","0x0b","0xce","0x96","0xec","0x01","0xbc","0xd2","0x00"} }, + { + /* No.549 delta:1031 weight:1483 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x0d932aec,0x3a81cfe8,0x3712e504,0x7b202257,0x76b308bb,0x41a1edbf,0x4c32c753,0x00000174,0x0d932b98,0x3a81ce9c,0x3712e470,0x7b202323,0x76b309cf,0x41a1eccb,0x4c32c627}, + [16]uint32{0x00000000,0x402c71de,0x406e6003,0x004211dd,0x0002a417,0x402ed5c9,0x406cc414,0x0040b5ca,0x1062d615,0x504ea7cb,0x500cb616,0x1020c7c8,0x10607202,0x504c03dc,0x500e1201,0x102263df}, + [16]uint32{0x3f800000,0x3fa01638,0x3fa03730,0x3f802108,0x3f800152,0x3fa0176a,0x3fa03662,0x3f80205a,0x3f88316b,0x3fa82753,0x3fa8065b,0x3f881063,0x3f883039,0x3fa82601,0x3fa80709,0x3f881131}, + uint32(0xfff80000), + [21]string{"0x02","0xd6","0xe1","0x55","0xc4","0x13","0x0e","0x73","0x9a","0xe4","0x74","0x49","0x61","0x30","0x0f","0xdc","0x10","0xcc","0xdf","0x9e","0x00"} }, + { + /* No.550 delta:1409 weight:1553 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0x695f4080,0x98f256d6,0xf1ad1656,0xaee02263,0xc7bf62e3,0x361274b5,0x5f4d3435,0x00006737,0x695f27b7,0x98f231e1,0xf1ad7161,0xaee04554,0xc7bf05d4,0x36121382,0x5f4d5302}, + [16]uint32{0x00000000,0x085780b6,0x201d617c,0x284ae1ca,0x00024112,0x0855c1a4,0x201f206e,0x2848a0d8,0x0001001b,0x085680ad,0x201c6167,0x284be1d1,0x00034109,0x0854c1bf,0x201e2075,0x2849a0c3}, + [16]uint32{0x3f800000,0x3f842bc0,0x3f900eb0,0x3f942570,0x3f800120,0x3f842ae0,0x3f900f90,0x3f942450,0x3f800080,0x3f842b40,0x3f900e30,0x3f9425f0,0x3f8001a0,0x3f842a60,0x3f900f10,0x3f9424d0}, + uint32(0xfff80000), + [21]string{"0x30","0xdd","0x63","0x3b","0xc8","0xfa","0xb2","0x63","0x72","0xe1","0xfc","0x6d","0xe7","0x00","0xb4","0x1b","0xdf","0x93","0xe1","0x92","0x00"} }, + { + /* No.551 delta:2268 weight:1229 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x0b958c40,0x6147f0e1,0x6ad27ca1,0xb370227d,0xb8e5ae3d,0xd237d29c,0xd9a25edc,0x0000ff96,0x0b9573d6,0x61470f77,0x6ad28337,0xb370ddeb,0xb8e551ab,0xd2372d0a,0xd9a2a14a}, + [16]uint32{0x00000000,0x0e1a0136,0x228d2094,0x2c9721a2,0x104009ed,0x1e5a08db,0x32cd2979,0x3cd7284f,0x4103c013,0x4f19c125,0x638ee087,0x6d94e1b1,0x5143c9fe,0x5f59c8c8,0x73cee96a,0x7dd4e85c}, + [16]uint32{0x3f800000,0x3f870d00,0x3f914690,0x3f964b90,0x3f882004,0x3f8f2d04,0x3f996694,0x3f9e6b94,0x3fa081e0,0x3fa78ce0,0x3fb1c770,0x3fb6ca70,0x3fa8a1e4,0x3faface4,0x3fb9e774,0x3fbeea74}, + uint32(0xfff80000), + [21]string{"0x20","0x02","0x63","0x23","0x8a","0x32","0x10","0xf2","0xca","0x39","0x5f","0x26","0xa0","0x22","0x0e","0x1a","0xde","0x1d","0xbe","0x76","0x00"} }, + { + /* No.552 delta:1408 weight:1223 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xde290d7b,0xbe0f8a5a,0x60268721,0x8a002282,0x54292ff9,0x340fa8d8,0xea26a5a3,0x00004e5d,0xde294326,0xbe0fc407,0x6026c97c,0x8a006cdf,0x542961a4,0x340fe685,0xea26ebfe}, + [16]uint32{0x00000000,0x005e5197,0x2a3001d1,0x2a6e5046,0x00160019,0x0048518e,0x2a2601c8,0x2a78505f,0x0002400d,0x005c119a,0x2a3241dc,0x2a6c104b,0x00144014,0x004a1183,0x2a2441c5,0x2a7a1052}, + [16]uint32{0x3f800000,0x3f802f28,0x3f951800,0x3f953728,0x3f800b00,0x3f802428,0x3f951300,0x3f953c28,0x3f800120,0x3f802e08,0x3f951920,0x3f953608,0x3f800a20,0x3f802508,0x3f951220,0x3f953d08}, + uint32(0xfff80000), + [21]string{"0x0f","0xed","0x1d","0x72","0xc8","0xee","0xfe","0x5a","0x4e","0x1a","0xc3","0x4e","0xa8","0x76","0xc0","0xfe","0xe8","0x35","0xac","0xab","0x00"} }, + { + /* No.553 delta:1650 weight:1523 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x9ca1406d,0xb6bfd945,0x2a1e9928,0x3cb02292,0xa01162ff,0x8a0ffbd7,0x16aebbba,0x0000f10a,0x9ca1b167,0xb6bf284f,0x2a1e6822,0x3cb0d398,0xa01193f5,0x8a0f0add,0x16ae4ab0}, + [16]uint32{0x00000000,0x0dd22e9a,0x31c22073,0x3c100ee9,0x2083a08d,0x2d518e17,0x114180fe,0x1c93ae64,0x0301a055,0x0ed38ecf,0x32c38026,0x3f11aebc,0x238200d8,0x2e502e42,0x124020ab,0x1f920e31}, + [16]uint32{0x3f800000,0x3f86e917,0x3f98e110,0x3f9e0807,0x3f9041d0,0x3f96a8c7,0x3f88a0c0,0x3f8e49d7,0x3f8180d0,0x3f8769c7,0x3f9961c0,0x3f9f88d7,0x3f91c100,0x3f972817,0x3f892010,0x3f8fc907}, + uint32(0xfff80000), + [21]string{"0x9e","0x3b","0xd3","0x59","0x77","0x60","0x67","0x46","0x36","0x62","0xda","0x24","0x08","0x5b","0x66","0x1c","0x9d","0x6a","0xef","0x30","0x00"} }, + { + /* No.554 delta:1729 weight:1621 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x891fe769,0x5d23546f,0xd43cb306,0x921022ad,0x1b0fc5c4,0xcf3376c2,0x462c91ab,0x0000bcff,0x891f5b96,0x5d23e890,0xd43c0ff9,0x92109e52,0x1b0f793b,0xcf33ca3d,0x462c2d54}, + [16]uint32{0x00000000,0x00422076,0x90344094,0x907660e2,0x2c14001a,0x2c56206c,0xbc20408e,0xbc6260f8,0x000221eb,0x0040019d,0x9036617f,0x90744109,0x2c1621f1,0x2c540187,0xbc226165,0xbc604113}, + [16]uint32{0x3f800000,0x3f802110,0x3fc81a20,0x3fc83b30,0x3f960a00,0x3f962b10,0x3fde1020,0x3fde3130,0x3f800110,0x3f802000,0x3fc81b30,0x3fc83a20,0x3f960b10,0x3f962a00,0x3fde1130,0x3fde3020}, + uint32(0xfff80000), + [21]string{"0xbe","0x6c","0xf3","0xfd","0xe9","0x01","0x45","0x29","0xbd","0xfd","0x6f","0x6f","0x2f","0x4a","0xf2","0xb2","0xa9","0x6b","0xda","0x3a","0x00"} }, + { + /* No.555 delta:991 weight:1627 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0x0f9e99c8,0x04d29090,0x0b4c0958,0xbd8022bb,0xb21ebb73,0xb952b22b,0xb6cc2be3,0x0000d220,0x0f9e4be8,0x04d242b0,0x0b4cdb78,0xbd80f09b,0xb21e6953,0xb952600b,0xb6ccf9c3}, + [16]uint32{0x00000000,0x30021c3e,0x0002001b,0x30001c25,0x404d2201,0x704f3e3f,0x404f221a,0x704d3e24,0x507e3086,0x607c2cb8,0x507c309d,0x607e2ca3,0x10331287,0x20310eb9,0x1031129c,0x20330ea2}, + [16]uint32{0x3f800000,0x3f98010e,0x3f800100,0x3f98000e,0x3fa02691,0x3fb8279f,0x3fa02791,0x3fb8269f,0x3fa83f18,0x3fb03e16,0x3fa83e18,0x3fb03f16,0x3f881989,0x3f901887,0x3f881889,0x3f901987}, + uint32(0xfff80000), + [21]string{"0xf3","0x38","0x30","0x54","0x0e","0x91","0xf8","0x1e","0x23","0xc7","0x58","0x59","0x9b","0x08","0x33","0x2f","0xeb","0xe2","0x06","0xe2","0x00"} }, + { + /* No.556 delta:1172 weight:1635 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0x7ab2da65,0xe01f151e,0x9aadcf7b,0x240022ce,0x5eb2f8ab,0xc41f37d0,0xbeadedb5,0x000051cb,0x7ab28bae,0xe01f44d5,0x9aad9eb0,0x24007305,0x5eb2a960,0xc41f661b,0xbeadbc7e}, + [16]uint32{0x00000000,0x70402df2,0x0065041b,0x702529e9,0x001abc78,0x705a918a,0x007fb863,0x703f9591,0x00028d61,0x7042a093,0x0067897a,0x7027a488,0x00183119,0x70581ceb,0x007d3502,0x703d18f0}, + [16]uint32{0x3f800000,0x3fb82016,0x3f803282,0x3fb81294,0x3f800d5e,0x3fb82d48,0x3f803fdc,0x3fb81fca,0x3f800146,0x3fb82150,0x3f8033c4,0x3fb813d2,0x3f800c18,0x3fb82c0e,0x3f803e9a,0x3fb81e8c}, + uint32(0xfff80000), + [21]string{"0xa1","0x68","0x0b","0xdb","0x03","0xc0","0xb3","0x79","0x39","0xd3","0x9c","0x3f","0x3b","0x83","0x22","0x78","0xc3","0xaf","0x50","0x74","0x00"} }, + { + /* No.557 delta:1072 weight:1203 */ + 11213, + 36, + 13, + 4, + [16]uint32{0x00000000,0x0361420c,0x032db76a,0x004cf566,0xa68022d2,0xa5e160de,0xa5ad95b8,0xa6ccd7b4,0x000022af,0x036160a3,0x032d95c5,0x004cd7c9,0xa680007d,0xa5e14271,0xa5adb717,0xa6ccf51b}, + [16]uint32{0x00000000,0x203ecb3a,0x4003a951,0x603d626b,0x800000c5,0xa03ecbff,0xc003a994,0xe03d62ae,0x4000690c,0x603ea236,0x0003c05d,0x203d0b67,0xc00069c9,0xe03ea2f3,0x8003c098,0xa03d0ba2}, + [16]uint32{0x3f800000,0x3f901f65,0x3fa001d4,0x3fb01eb1,0x3fc00000,0x3fd01f65,0x3fe001d4,0x3ff01eb1,0x3fa00034,0x3fb01f51,0x3f8001e0,0x3f901e85,0x3fe00034,0x3ff01f51,0x3fc001e0,0x3fd01e85}, + uint32(0xfff80000), + [21]string{"0xe1","0x4b","0x8a","0x46","0x7f","0x4c","0x9f","0xbc","0xb6","0x0d","0x39","0x66","0x06","0xd0","0x1f","0x14","0x60","0xdd","0xe6","0x36","0x00"} }, + { + /* No.558 delta:1131 weight:1691 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x9cdcd095,0xe7ba2488,0x7b66f41d,0xda6022ec,0x46bcf279,0x3dda0664,0xa106d6f1,0x00002257,0x9cdcf2c2,0xe7ba06df,0x7b66d64a,0xda6000bb,0x46bcd02e,0x3dda2433,0xa106f4a6}, + [16]uint32{0x00000000,0x101da8de,0x2027f16c,0x303a59b2,0x0041f1b5,0x105c596b,0x206600d9,0x307ba807,0x00312816,0x102c80c8,0x2016d97a,0x300b71a4,0x0070d9a3,0x106d717d,0x205728cf,0x304a8011}, + [16]uint32{0x3f800000,0x3f880ed4,0x3f9013f8,0x3f981d2c,0x3f8020f8,0x3f882e2c,0x3f903300,0x3f983dd4,0x3f801894,0x3f881640,0x3f900b6c,0x3f9805b8,0x3f80386c,0x3f8836b8,0x3f902b94,0x3f982540}, + uint32(0xfff80000), + [21]string{"0x1c","0x93","0x74","0xb4","0xe8","0x21","0x0c","0x01","0xf9","0xa5","0xf3","0x38","0x74","0xcb","0x7f","0xec","0x8f","0xe6","0x0c","0xa7","0x00"} }, + { + /* No.559 delta:1644 weight:1465 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x6e552ab0,0xce5848d0,0xa00d6260,0x451022f2,0x2b450842,0x8b486a22,0xe51d4092,0x000081a6,0x6e55ab16,0xce58c976,0xa00de3c6,0x4510a354,0x2b4589e4,0x8b48eb84,0xe51dc134}, + [16]uint32{0x00000000,0x086f4d97,0x2072340a,0x281d799d,0x11004011,0x196f0d86,0x3172741b,0x391d398c,0x208899e5,0x28e7d472,0x00faadef,0x0895e078,0x3188d9f4,0x39e79463,0x11faedfe,0x1995a069}, + [16]uint32{0x3f800000,0x3f8437a6,0x3f90391a,0x3f940ebc,0x3f888020,0x3f8cb786,0x3f98b93a,0x3f9c8e9c,0x3f90444c,0x3f9473ea,0x3f807d56,0x3f844af0,0x3f98c46c,0x3f9cf3ca,0x3f88fd76,0x3f8ccad0}, + uint32(0xfff80000), + [21]string{"0x3d","0xc3","0x9a","0x1e","0xc7","0x7f","0x5b","0xa4","0x5a","0xc9","0x17","0x9f","0xeb","0x61","0xe8","0x87","0x65","0x30","0xd8","0xfc","0x00"} }, + { + /* No.560 delta:735 weight:1721 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0x2143c00e,0x0f98a6f3,0x2edb66fd,0x1f50230c,0x3e13e302,0x10c885ff,0x318b45f1,0x00004f2d,0x21438f23,0x0f98e9de,0x2edb29d0,0x1f506c21,0x3e13ac2f,0x10c8cad2,0x318b0adc}, + [16]uint32{0x00000000,0x006489f2,0x20041009,0x206099fb,0x0003d1d7,0x00675825,0x2007c1de,0x2063482c,0x0021301c,0x0045b9ee,0x20252015,0x2041a9e7,0x0022e1cb,0x00466839,0x2026f1c2,0x20427830}, + [16]uint32{0x3f800000,0x3f803244,0x3f900208,0x3f90304c,0x3f8001e8,0x3f8033ac,0x3f9003e0,0x3f9031a4,0x3f801098,0x3f8022dc,0x3f901290,0x3f9020d4,0x3f801170,0x3f802334,0x3f901378,0x3f90213c}, + uint32(0xfff80000), + [21]string{"0xd2","0x04","0x0d","0x01","0x85","0xc5","0x27","0xee","0x50","0x7c","0x98","0xec","0xf2","0x37","0x50","0x61","0xbf","0x7a","0xd4","0xa2","0x00"} }, + { + /* No.561 delta:740 weight:1499 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x0784b100,0xdced0f87,0xdb69be87,0x8440231f,0x83c4921f,0x58ad2c98,0x5f299d98,0x0000dd1a,0x07846c1a,0xdcedd29d,0xdb69639d,0x8440fe05,0x83c44f05,0x58adf182,0x5f294082}, + [16]uint32{0x00000000,0x017f10fa,0x00030137,0x017c11cd,0x000082f4,0x017f920e,0x000383c3,0x017c9339,0x40181a3f,0x41670ac5,0x401b1b08,0x41640bf2,0x401898cb,0x41678831,0x401b99fc,0x41648906}, + [16]uint32{0x3f800000,0x3f80bf88,0x3f800180,0x3f80be08,0x3f800041,0x3f80bfc9,0x3f8001c1,0x3f80be49,0x3fa00c0d,0x3fa0b385,0x3fa00d8d,0x3fa0b205,0x3fa00c4c,0x3fa0b3c4,0x3fa00dcc,0x3fa0b244}, + uint32(0xfff80000), + [21]string{"0x30","0x3c","0x36","0x0f","0x05","0xe0","0x61","0x46","0x56","0x97","0xa3","0x00","0x30","0xf5","0xd3","0x23","0x94","0x2b","0x47","0x3c","0x00"} }, + { + /* No.562 delta:968 weight:951 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0x8f1b238d,0xdd9f709b,0x52845316,0x29802322,0xa69b00af,0xf41f53b9,0x7b047034,0x0000cb2a,0x8f1be8a7,0xdd9fbbb1,0x5284983c,0x2980e808,0xa69bcb85,0xf41f9893,0x7b04bb1e}, + [16]uint32{0x00000000,0x1fec1dba,0x127831f7,0x0d942c4d,0x0044020e,0x1fa81fb4,0x123c33f9,0x0dd02e43,0x222a100f,0x3dc60db5,0x305221f8,0x2fbe3c42,0x226e1201,0x3d820fbb,0x301623f6,0x2ffa3e4c}, + [16]uint32{0x3f800000,0x3f8ff60e,0x3f893c18,0x3f86ca16,0x3f802201,0x3f8fd40f,0x3f891e19,0x3f86e817,0x3f911508,0x3f9ee306,0x3f982910,0x3f97df1e,0x3f913709,0x3f9ec107,0x3f980b11,0x3f97fd1f}, + uint32(0xfff80000), + [21]string{"0x45","0x03","0x69","0x38","0xda","0x8b","0x25","0x4a","0xba","0xa1","0xa2","0x9b","0xb5","0xa4","0x62","0x5c","0x99","0x6e","0x9c","0x32","0x00"} }, + { + /* No.563 delta:666 weight:1507 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x4e44098f,0x8d3b9783,0xc37f9e0c,0xb620233c,0xf8642ab3,0x3b1bb4bf,0x755fbd30,0x0000c6a3,0x4e44cf2c,0x8d3b5120,0xc37f58af,0xb620e59f,0xf864ec10,0x3b1b721c,0x755f7b93}, + [16]uint32{0x00000000,0x01220db6,0x40007443,0x412279f5,0x800041dd,0x81224c6b,0xc000359e,0xc1223828,0x1000268f,0x11222b39,0x500052cc,0x51225f7a,0x90006752,0x91226ae4,0xd0001311,0xd1221ea7}, + [16]uint32{0x3f800000,0x3f809106,0x3fa0003a,0x3fa0913c,0x3fc00020,0x3fc09126,0x3fe0001a,0x3fe0911c,0x3f880013,0x3f889115,0x3fa80029,0x3fa8912f,0x3fc80033,0x3fc89135,0x3fe80009,0x3fe8910f}, + uint32(0xfff80000), + [21]string{"0xf8","0x1a","0xf3","0x78","0xed","0xf4","0x03","0x64","0xe4","0x52","0x5d","0x91","0xed","0x75","0x6b","0xba","0x7b","0x43","0xa1","0xe8","0x00"} }, + { + /* No.564 delta:647 weight:1181 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xd8f33a9b,0xe3af3f77,0x3b5c05ec,0xf1c02349,0x293319d2,0x126f1c3e,0xca9c26a5,0x000070ee,0xd8f34a75,0xe3af4f99,0x3b5c7502,0xf1c053a7,0x2933693c,0x126f6cd0,0xca9c564b}, + [16]uint32{0x00000000,0x3013e452,0x4040028c,0x7053e6de,0x0020801d,0x3033644f,0x40608291,0x707366c3,0x1041841b,0x20526049,0x50018697,0x601262c5,0x10610406,0x2072e054,0x5021068a,0x6032e2d8}, + [16]uint32{0x3f800000,0x3f9809f2,0x3fa02001,0x3fb829f3,0x3f801040,0x3f9819b2,0x3fa03041,0x3fb839b3,0x3f8820c2,0x3f902930,0x3fa800c3,0x3fb00931,0x3f883082,0x3f903970,0x3fa81083,0x3fb01971}, + uint32(0xfff80000), + [21]string{"0xb5","0x13","0x27","0x77","0xaf","0x8d","0x32","0xf7","0x82","0xc0","0xb7","0xdb","0x9b","0x69","0x02","0xe8","0x60","0xd8","0x8b","0x4e","0x00"} }, + { + /* No.565 delta:826 weight:1527 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x1254c38d,0xa41cd251,0xb64811dc,0x16e02356,0x04b4e0db,0xb2fcf107,0xa0a8328a,0x00007e13,0x1254bd9e,0xa41cac42,0xb6486fcf,0x16e05d45,0x04b49ec8,0xb2fc8f14,0xa0a84c99}, + [16]uint32{0x00000000,0x204e193e,0x102de103,0x3063f83d,0x202000e7,0x006e19d9,0x300de1e4,0x1043f8da,0x00021134,0x204c080a,0x102ff037,0x3061e909,0x202211d3,0x006c08ed,0x300ff0d0,0x1041e9ee}, + [16]uint32{0x3f800000,0x3f90270c,0x3f8816f0,0x3f9831fc,0x3f901000,0x3f80370c,0x3f9806f0,0x3f8821fc,0x3f800108,0x3f902604,0x3f8817f8,0x3f9830f4,0x3f901108,0x3f803604,0x3f9807f8,0x3f8820f4}, + uint32(0xfff80000), + [21]string{"0x07","0x92","0xf4","0xe5","0x4a","0xfe","0xbc","0xe8","0x6d","0xb3","0x5d","0x71","0xcf","0x66","0xda","0x67","0xef","0xd0","0x6e","0x46","0x00"} }, + { + /* No.566 delta:1403 weight:1689 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x65b804b0,0xe888ba20,0x8d30be90,0x9e002361,0xfbb827d1,0x76889941,0x13309df1,0x00009326,0x65b89796,0xe8882906,0x8d302db6,0x9e00b047,0xfbb8b4f7,0x76880a67,0x13300ed7}, + [16]uint32{0x00000000,0x0034019a,0x000000e9,0x00340173,0x102001b4,0x1014002e,0x1020015d,0x101400c7,0x100200bf,0x10360125,0x10020056,0x103601cc,0x0022010b,0x00160091,0x002201e2,0x00160078}, + [16]uint32{0x3f800000,0x3f801a00,0x3f800000,0x3f801a00,0x3f881000,0x3f880a00,0x3f881000,0x3f880a00,0x3f880100,0x3f881b00,0x3f880100,0x3f881b00,0x3f801100,0x3f800b00,0x3f801100,0x3f800b00}, + uint32(0xfff80000), + [21]string{"0x66","0xf9","0x0d","0xb5","0xaf","0x59","0x83","0x07","0x61","0x44","0x4d","0xc5","0x98","0xb6","0x8d","0x8f","0x48","0x7f","0x60","0x1f","0x00"} }, + { + /* No.567 delta:576 weight:1617 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x058d67ed,0x97f5a577,0x9278c29a,0x00502373,0x05dd449e,0x97a58604,0x9228e1e9,0x000090d7,0x058df73a,0x97f535a0,0x9278524d,0x0050b3a4,0x05ddd449,0x97a516d3,0x9228713e}, + [16]uint32{0x00000000,0x8041081b,0x40022067,0xc043287c,0x08027808,0x88437013,0x4800586f,0xc8415074,0x10004429,0x90414c32,0x5002644e,0xd0436c55,0x18023c21,0x9843343a,0x58001c46,0xd841145d}, + [16]uint32{0x3f800000,0x3fc02084,0x3fa00110,0x3fe02194,0x3f84013c,0x3fc421b8,0x3fa4002c,0x3fe420a8,0x3f880022,0x3fc820a6,0x3fa80132,0x3fe821b6,0x3f8c011e,0x3fcc219a,0x3fac000e,0x3fec208a}, + uint32(0xfff80000), + [21]string{"0x84","0x43","0xbf","0xce","0x07","0x13","0x49","0x6f","0x49","0xe5","0xae","0x16","0x42","0x85","0x1d","0x87","0x8c","0x9e","0xc4","0x81","0x00"} }, + { + /* No.568 delta:916 weight:1657 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xc51212ca,0xd8436746,0x1d51758c,0xed102385,0x2802314f,0x355344c3,0xf0415609,0x00000421,0xc51216eb,0xd8436367,0x1d5171ad,0xed1027a4,0x2802356e,0x355340e2,0xf0415228}, + [16]uint32{0x00000000,0x4025fc1a,0x00414afe,0x4064b6e4,0x00031143,0x4026ed59,0x00425bbd,0x4067a7a7,0x90001c01,0xd025e01b,0x904156ff,0xd064aae5,0x90030d42,0xd026f158,0x904247bc,0xd067bba6}, + [16]uint32{0x3f800000,0x3fa012fe,0x3f8020a5,0x3fa0325b,0x3f800188,0x3fa01376,0x3f80212d,0x3fa033d3,0x3fc8000e,0x3fe812f0,0x3fc820ab,0x3fe83255,0x3fc80186,0x3fe81378,0x3fc82123,0x3fe833dd}, + uint32(0xfff80000), + [21]string{"0x06","0xa6","0xbe","0x0a","0x82","0x60","0xac","0x55","0xa0","0x75","0xe5","0x40","0x55","0xe8","0x01","0x2c","0x1c","0x2b","0xba","0x97","0x00"} }, + { + /* No.569 delta:868 weight:1715 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xe60c22f0,0x40821976,0xa68e3b86,0xc6d02397,0x20dc0167,0x86523ae1,0x605e1811,0x00000fc3,0xe60c2d33,0x408216b5,0xa68e3445,0xc6d02c54,0x20dc0ea4,0x86523522,0x605e17d2}, + [16]uint32{0x00000000,0x8040b4b2,0x2003402c,0xa043f49e,0x30005a04,0xb040eeb6,0x10031a28,0x9043ae9a,0x00426405,0x8002d0b7,0x20412429,0xa001909b,0x30423e01,0xb0028ab3,0x10417e2d,0x9001ca9f}, + [16]uint32{0x3f800000,0x3fc0205a,0x3f9001a0,0x3fd021fa,0x3f98002d,0x3fd82077,0x3f88018d,0x3fc821d7,0x3f802132,0x3fc00168,0x3f902092,0x3fd000c8,0x3f98211f,0x3fd80145,0x3f8820bf,0x3fc800e5}, + uint32(0xfff80000), + [21]string{"0x22","0xe9","0x16","0x97","0x46","0x82","0x83","0xc3","0xa6","0x1c","0x42","0xb5","0x41","0xa1","0x2a","0x37","0x70","0x03","0x2d","0xda","0x00"} }, + { + /* No.570 delta:796 weight:973 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0x3f4a19c2,0xfabc4f03,0xc5f656c1,0xa27023a3,0x9d3a3a61,0x58cc6ca0,0x67867562,0x00007570,0x3f4a6cb2,0xfabc3a73,0xc5f623b1,0xa27056d3,0x9d3a4f11,0x58cc19d0,0x67860012}, + [16]uint32{0x00000000,0x0031e45d,0x406cac0a,0x405d4857,0x40300619,0x4001e244,0x005caa13,0x006d4e4e,0x800210bf,0x8033f4e2,0xc06ebcb5,0xc05f58e8,0xc03216a6,0xc003f2fb,0x805ebaac,0x806f5ef1}, + [16]uint32{0x3f800000,0x3f8018f2,0x3fa03656,0x3fa02ea4,0x3fa01803,0x3fa000f1,0x3f802e55,0x3f8036a7,0x3fc00108,0x3fc019fa,0x3fe0375e,0x3fe02fac,0x3fe0190b,0x3fe001f9,0x3fc02f5d,0x3fc037af}, + uint32(0xfff80000), + [21]string{"0xf9","0x5d","0x51","0xa5","0xd3","0xf1","0x85","0x34","0x9d","0x12","0xd1","0xc6","0xfc","0x3f","0xb8","0xfa","0xea","0x1e","0x7d","0xb3","0x00"} }, + { + /* No.571 delta:846 weight:1529 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0xdc4991bd,0x37ab9327,0xebe2029a,0x431023b0,0x9f59b20d,0x74bbb097,0xa8f2212a,0x00006306,0xdc49f2bb,0x37abf021,0xebe2619c,0x431040b6,0x9f59d10b,0x74bbd391,0xa8f2422c}, + [16]uint32{0x00000000,0x10371416,0x50428454,0x40759042,0x00029818,0x10358c0e,0x50401c4c,0x4077085a,0x4008007f,0x503f1469,0x104a842b,0x007d903d,0x400a9867,0x503d8c71,0x10481c33,0x007f0825}, + [16]uint32{0x3f800000,0x3f881b8a,0x3fa82142,0x3fa03ac8,0x3f80014c,0x3f881ac6,0x3fa8200e,0x3fa03b84,0x3fa00400,0x3fa81f8a,0x3f882542,0x3f803ec8,0x3fa0054c,0x3fa81ec6,0x3f88240e,0x3f803f84}, + uint32(0xfff80000), + [21]string{"0x23","0x2f","0xfa","0x7c","0x6d","0x77","0x53","0x6d","0xac","0x09","0xb7","0x89","0xb8","0x19","0x39","0x54","0x0e","0x52","0x21","0x2c","0x00"} }, + { + /* No.572 delta:1688 weight:1633 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0x87785293,0x27be9c94,0xa0c6ce07,0xbd0023ce,0x3a78715d,0x9abebf5a,0x1dc6edc9,0x00002d9f,0x87787f0c,0x27beb10b,0xa0c6e398,0xbd000e51,0x3a785cc2,0x9abe92c5,0x1dc6c056}, + [16]uint32{0x00000000,0x005e01b4,0x2009009f,0x2057012b,0x240c00b7,0x24520103,0x04050028,0x045b019c,0x002101f5,0x007f0041,0x2028016a,0x207600de,0x242d0142,0x247300f6,0x042401dd,0x047a0069}, + [16]uint32{0x3f800000,0x3f802f00,0x3f900480,0x3f902b80,0x3f920600,0x3f922900,0x3f820280,0x3f822d80,0x3f801080,0x3f803f80,0x3f901400,0x3f903b00,0x3f921680,0x3f923980,0x3f821200,0x3f823d00}, + uint32(0xfff80000), + [21]string{"0x8f","0xdd","0xeb","0xcd","0x16","0x11","0x15","0x3c","0xc3","0xfd","0x4b","0x96","0x25","0xd8","0x41","0xc4","0x48","0x70","0x1e","0x7c","0x00"} }, + { + /* No.573 delta:677 weight:1389 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xbddf0a8f,0xe43de34b,0x59e2e9c4,0xcca023d8,0x717f2957,0x289dc093,0x9542ca1c,0x0000504c,0xbddf5ac3,0xe43db307,0x59e2b988,0xcca07394,0x717f791b,0x289d90df,0x95429a50}, + [16]uint32{0x00000000,0x00542972,0x1021560d,0x10757f7f,0x104a1154,0x101e3826,0x006b4759,0x003f6e2b,0x45800813,0x45d42161,0x55a15e1e,0x55f5776c,0x55ca1947,0x559e3035,0x45eb4f4a,0x45bf6638}, + [16]uint32{0x3f800000,0x3f802a14,0x3f8810ab,0x3f883abf,0x3f882508,0x3f880f1c,0x3f8035a3,0x3f801fb7,0x3fa2c004,0x3fa2ea10,0x3faad0af,0x3faafabb,0x3faae50c,0x3faacf18,0x3fa2f5a7,0x3fa2dfb3}, + uint32(0xfff80000), + [21]string{"0x02","0x57","0x6d","0xc8","0x62","0x76","0x80","0x82","0x3f","0xcf","0x0d","0x54","0x42","0x8d","0x13","0x24","0xba","0x5a","0x6b","0xc8","0x00"} }, + { + /* No.574 delta:851 weight:1495 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x8f6a848c,0xa22ca200,0x2d46268c,0x473023e1,0xc85aa76d,0xe51c81e1,0x6a76056d,0x0000b6a3,0x8f6a322f,0xa22c14a3,0x2d46902f,0x47309542,0xc85a11ce,0xe51c3742,0x6a76b3ce}, + [16]uint32{0x00000000,0x00420d9a,0x80084d66,0x804a40fc,0x004161c3,0x00036c59,0x80492ca5,0x800b213f,0x300020b7,0x30422d2d,0xb0086dd1,0xb04a604b,0x30414174,0x30034cee,0xb0490c12,0xb00b0188}, + [16]uint32{0x3f800000,0x3f802106,0x3fc00426,0x3fc02520,0x3f8020b0,0x3f8001b6,0x3fc02496,0x3fc00590,0x3f980010,0x3f982116,0x3fd80436,0x3fd82530,0x3f9820a0,0x3f9801a6,0x3fd82486,0x3fd80580}, + uint32(0xfff80000), + [21]string{"0xc2","0x52","0xcb","0xb7","0xa5","0x4e","0xd3","0xc2","0x91","0x42","0x07","0x12","0x03","0xc0","0x21","0xeb","0xa1","0x31","0x0e","0xe1","0x00"} }, + { + /* No.575 delta:897 weight:1805 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x4fa8d5e7,0xf50c0d09,0xbaa4d8ee,0x16b023fa,0x5918f61d,0xe3bc2ef3,0xac14fb14,0x0000edb9,0x4fa8385e,0xf50ce0b0,0xbaa43557,0x16b0ce43,0x59181ba4,0xe3bcc34a,0xac1416ad}, + [16]uint32{0x00000000,0x580f1812,0x0002136e,0x580d0b7c,0x60002c13,0x380f3401,0x60023f7d,0x380d276f,0x40100016,0x181f1804,0x40121378,0x181d0b6a,0x20102c05,0x781f3417,0x20123f6b,0x781d2779}, + [16]uint32{0x3f800000,0x3fac078c,0x3f800109,0x3fac0685,0x3fb00016,0x3f9c079a,0x3fb0011f,0x3f9c0693,0x3fa00800,0x3f8c0f8c,0x3fa00909,0x3f8c0e85,0x3f900816,0x3fbc0f9a,0x3f90091f,0x3fbc0e93}, + uint32(0xfff80000), + [21]string{"0x68","0xed","0xf0","0x2b","0x1e","0x97","0x38","0xd1","0x43","0x1d","0x85","0xb1","0xeb","0x5a","0x00","0xa6","0x59","0x98","0x1f","0xd1","0x00"} }, + { + /* No.576 delta:1985 weight:1777 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xf228822a,0x4d2e7685,0xbf06f4af,0xb590240b,0x47b8a621,0xf8be528e,0x0a96d0a4,0x0000318d,0xf228b3a7,0x4d2e4708,0xbf06c522,0xb5901586,0x47b897ac,0xf8be6303,0x0a96e129}, + [16]uint32{0x00000000,0x087408dd,0x0040003b,0x083408e6,0x002a00be,0x085e0863,0x006a0085,0x081e0858,0x300001d7,0x3874090a,0x304001ec,0x38340931,0x302a0169,0x385e09b4,0x306a0152,0x381e098f}, + [16]uint32{0x3f800000,0x3f843a04,0x3f802000,0x3f841a04,0x3f801500,0x3f842f04,0x3f803500,0x3f840f04,0x3f980000,0x3f9c3a04,0x3f982000,0x3f9c1a04,0x3f981500,0x3f9c2f04,0x3f983500,0x3f9c0f04}, + uint32(0xfff80000), + [21]string{"0x09","0x87","0xd9","0xe5","0x26","0xb3","0x73","0x57","0xf0","0xae","0x93","0xaf","0x0c","0x9d","0x86","0x56","0xcd","0xe6","0x02","0x5f","0x00"} }, + { + /* No.577 delta:718 weight:1687 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x5ae91cbe,0x3ba1ba41,0x6148a6ff,0x6d70241a,0x379938a4,0x56d19e5b,0x0c3882e5,0x00005993,0x5ae9452d,0x3ba1e3d2,0x6148ff6c,0x6d707d89,0x37996137,0x56d1c7c8,0x0c38db76}, + [16]uint32{0x00000000,0x9002419a,0x100221ef,0x80006075,0x51010016,0xc103418c,0x410321f9,0xd1016063,0x41009004,0xd102d19e,0x5102b1eb,0xc100f071,0x10019012,0x8003d188,0x0003b1fd,0x9001f067}, + [16]uint32{0x3f800000,0x3fc80120,0x3f880110,0x3fc00030,0x3fa88080,0x3fe081a0,0x3fa08190,0x3fe880b0,0x3fa08048,0x3fe88168,0x3fa88158,0x3fe08078,0x3f8800c8,0x3fc001e8,0x3f8001d8,0x3fc800f8}, + uint32(0xfff80000), + [21]string{"0x05","0x42","0x99","0x58","0x2f","0x1c","0x8f","0xa9","0xa5","0x51","0xa8","0x1a","0xdc","0x69","0xd2","0x5c","0xe0","0x84","0x07","0xb3","0x00"} }, + { + /* No.578 delta:2667 weight:885 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x13fc4637,0x01ff15f1,0x120353c6,0x32e02426,0x211c6211,0x331f31d7,0x20e377e0,0x00004435,0x13fc0202,0x01ff51c4,0x120317f3,0x32e06013,0x211c2624,0x331f75e2,0x20e333d5}, + [16]uint32{0x00000000,0xa604c57a,0xfe2241bc,0x582684c6,0x541c0112,0xf218c468,0xaa3e40ae,0x0c3a85d4,0x2080ae17,0x86846b6d,0xdea2efab,0x78a62ad1,0x749caf05,0xd2986a7f,0x8abeeeb9,0x2cba2bc3}, + [16]uint32{0x3f800000,0x3fd30262,0x3fff1120,0x3fac1342,0x3faa0e00,0x3ff90c62,0x3fd51f20,0x3f861d42,0x3f904057,0x3fc34235,0x3fef5177,0x3fbc5315,0x3fba4e57,0x3fe94c35,0x3fc55f77,0x3f965d15}, + uint32(0xfff80000), + [21]string{"0x56","0x99","0x67","0xcb","0xdf","0x58","0xa1","0x0b","0xa3","0xe9","0x9c","0x2b","0x01","0xd1","0x12","0xd9","0xf7","0x2a","0xf1","0x3a","0x00"} }, + { + /* No.579 delta:692 weight:1623 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xce93380c,0x85dab300,0x4b498b0c,0x7dc02437,0xb3531c3b,0xf81a9737,0x3689af3b,0x00005cd3,0xce9364df,0x85daefd3,0x4b49d7df,0x7dc078e4,0xb35340e8,0xf81acbe4,0x3689f3e8}, + [16]uint32{0x00000000,0x1003c63e,0x0100121d,0x1103d423,0x40116348,0x5012a576,0x41117155,0x5112b76b,0x2000201f,0x3003e621,0x21003202,0x3103f43c,0x60114357,0x70128569,0x6111514a,0x71129774}, + [16]uint32{0x3f800000,0x3f8801e3,0x3f808009,0x3f8881ea,0x3fa008b1,0x3fa80952,0x3fa088b8,0x3fa8895b,0x3f900010,0x3f9801f3,0x3f908019,0x3f9881fa,0x3fb008a1,0x3fb80942,0x3fb088a8,0x3fb8894b}, + uint32(0xfff80000), + [21]string{"0xb8","0x23","0xe8","0xb7","0xf8","0xb5","0x9f","0x83","0x18","0x3f","0xe1","0xe1","0x03","0xf5","0x55","0xb1","0xdf","0x92","0x20","0xb2","0x00"} }, + { + /* No.580 delta:1067 weight:1601 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0xb1a4c3ee,0xb18ff085,0x002b336b,0xe0402447,0x51e4e7a9,0x51cfd4c2,0xe06b172c,0x0000819d,0xb1a44273,0xb18f7118,0x002bb2f6,0xe040a5da,0x51e46634,0x51cf555f,0xe06b96b1}, + [16]uint32{0x00000000,0x40241a1a,0x100161b1,0x50257bab,0x4000119c,0x00240b86,0x5001702d,0x10256a37,0x011110e5,0x41350aff,0x11107154,0x51346b4e,0x41110179,0x01351b63,0x511060c8,0x11347ad2}, + [16]uint32{0x3f800000,0x3fa0120d,0x3f8800b0,0x3fa812bd,0x3fa00008,0x3f801205,0x3fa800b8,0x3f8812b5,0x3f808888,0x3fa09a85,0x3f888838,0x3fa89a35,0x3fa08880,0x3f809a8d,0x3fa88830,0x3f889a3d}, + uint32(0xfff80000), + [21]string{"0x9b","0x60","0xfb","0x33","0xf5","0x44","0xfc","0x28","0xbf","0x2c","0x87","0x95","0x5f","0xa9","0x2d","0x20","0x1a","0xff","0xef","0xae","0x00"} }, + { + /* No.581 delta:1337 weight:1507 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0x111e2100,0x8a566841,0x9b484941,0x14c02452,0x05de0552,0x9e964c13,0x8f886d13,0x00003262,0x111e1362,0x8a565a23,0x9b487b23,0x14c01630,0x05de3730,0x9e967e71,0x8f885f71}, + [16]uint32{0x00000000,0x118a039e,0x0049f11b,0x11c3f285,0x82085039,0x938253a7,0x8241a122,0x93cba2bc,0x0025d014,0x11afd38a,0x006c210f,0x11e62291,0x822d802d,0x93a783b3,0x82647136,0x93ee72a8}, + [16]uint32{0x3f800000,0x3f88c501,0x3f8024f8,0x3f88e1f9,0x3fc10428,0x3fc9c129,0x3fc120d0,0x3fc9e5d1,0x3f8012e8,0x3f88d7e9,0x3f803610,0x3f88f311,0x3fc116c0,0x3fc9d3c1,0x3fc13238,0x3fc9f739}, + uint32(0xfff80000), + [21]string{"0xd8","0x9f","0x8b","0xee","0xda","0x62","0x7c","0x98","0xda","0x49","0x6b","0x6b","0x52","0xcf","0xc3","0x19","0x44","0xa6","0x49","0x63","0x00"} }, + { + /* No.582 delta:2046 weight:1311 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x91fd9faa,0xedf45b1b,0x7c09c4b1,0x4aa02460,0xdb5dbbca,0xa7547f7b,0x36a9e0d1,0x0000288f,0x91fdb725,0xedf47394,0x7c09ec3e,0x4aa00cef,0xdb5d9345,0xa75457f4,0x36a9c85e}, + [16]uint32{0x00000000,0x0f128396,0x10cd0079,0x1fdf83ef,0x1060d203,0x1f725195,0x00add27a,0x0fbf51ec,0x08b049d4,0x07a2ca42,0x187d49ad,0x176fca3b,0x18d09bd7,0x17c21841,0x081d9bae,0x070f1838}, + [16]uint32{0x3f800000,0x3f878941,0x3f886680,0x3f8fefc1,0x3f883069,0x3f8fb928,0x3f8056e9,0x3f87dfa8,0x3f845824,0x3f83d165,0x3f8c3ea4,0x3f8bb7e5,0x3f8c684d,0x3f8be10c,0x3f840ecd,0x3f83878c}, + uint32(0xfff80000), + [21]string{"0xf9","0x39","0x19","0x57","0x14","0xbc","0xca","0xd3","0x8c","0xcf","0xcf","0xdd","0x71","0x49","0x91","0x82","0x74","0xac","0x6c","0x67","0x00"} }, + { + /* No.583 delta:997 weight:1675 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x0037248a,0xe0b4f02c,0xe083d4a6,0xe0002479,0xe03700f3,0x00b4d455,0x0083f0df,0x00009577,0x0037b1fd,0xe0b4655b,0xe08341d1,0xe000b10e,0xe0379584,0x00b44122,0x008365a8}, + [16]uint32{0x00000000,0x41240855,0x4000814c,0x01248919,0x4008401a,0x012c484f,0x0008c156,0x412cc903,0x40007008,0x0124785d,0x0000f144,0x4124f911,0x00083012,0x412c3847,0x4008b15e,0x012cb90b}, + [16]uint32{0x3f800000,0x3fa09204,0x3fa00040,0x3f809244,0x3fa00420,0x3f809624,0x3f800460,0x3fa09664,0x3fa00038,0x3f80923c,0x3f800078,0x3fa0927c,0x3f800418,0x3fa0961c,0x3fa00458,0x3f80965c}, + uint32(0xfff80000), + [21]string{"0x5f","0xa4","0x83","0x10","0x49","0xa7","0x5c","0x56","0x7d","0x75","0x23","0x1d","0x8c","0x2e","0xf7","0x22","0x57","0xd1","0xed","0xda","0x00"} }, + { + /* No.584 delta:1031 weight:1783 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xe9b1101c,0xaa673461,0x43d6247d,0x2c102486,0xc5a1349a,0x867710e7,0x6fc600fb,0x0000fe72,0xe9b1ee6e,0xaa67ca13,0x43d6da0f,0x2c10daf4,0xc5a1cae8,0x8677ee95,0x6fc6fe89}, + [16]uint32{0x00000000,0x0003f11e,0x40243211,0x4027c30f,0x40004d16,0x4003bc08,0x00247f07,0x00278e19,0x30000018,0x3003f106,0x70243209,0x7027c317,0x70004d0e,0x7003bc10,0x30247f1f,0x30278e01}, + [16]uint32{0x3f800000,0x3f8001f8,0x3fa01219,0x3fa013e1,0x3fa00026,0x3fa001de,0x3f80123f,0x3f8013c7,0x3f980000,0x3f9801f8,0x3fb81219,0x3fb813e1,0x3fb80026,0x3fb801de,0x3f98123f,0x3f9813c7}, + uint32(0xfff80000), + [21]string{"0x34","0xcc","0x2b","0x12","0x90","0xca","0x98","0x8a","0x0e","0x1a","0xf3","0x03","0x4d","0xbe","0xb0","0xec","0x3d","0x7b","0x4f","0x4d","0x00"} }, + { + /* No.585 delta:1210 weight:1565 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0xff2d7f66,0xcbc1108c,0x34ec6fea,0xd400249b,0x2b2d5bfd,0x1fc13417,0xe0ec4b71,0x00006562,0xff2d1a04,0xcbc175ee,0x34ec0a88,0xd40041f9,0x2b2d3e9f,0x1fc15175,0xe0ec2e13}, + [16]uint32{0x00000000,0x4825b032,0x004161f4,0x4864d1c6,0x0020601c,0x4805d02e,0x006101e8,0x4844b1da,0x10130c01,0x5836bc33,0x10526df5,0x5877ddc7,0x10336c1d,0x5816dc2f,0x10720de9,0x5857bddb}, + [16]uint32{0x3f800000,0x3fa412d8,0x3f8020b0,0x3fa43268,0x3f801030,0x3fa402e8,0x3f803080,0x3fa42258,0x3f880986,0x3fac1b5e,0x3f882936,0x3fac3bee,0x3f8819b6,0x3fac0b6e,0x3f883906,0x3fac2bde}, + uint32(0xfff80000), + [21]string{"0x4e","0xf2","0x1f","0x4d","0xc3","0x9e","0xb9","0x8d","0x8a","0x34","0x06","0xfe","0x37","0x71","0xea","0x47","0xb1","0x8a","0xba","0xcd","0x00"} }, + { + /* No.586 delta:1070 weight:1463 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x3be7d0a0,0x3506e62a,0x0ee1368a,0x1cc024aa,0x2727f40a,0x29c6c280,0x12211220,0x0000dfba,0x3be70f1a,0x35063990,0x0ee1e930,0x1cc0fb10,0x27272bb0,0x29c61d3a,0x1221cd9a}, + [16]uint32{0x00000000,0x004600f5,0x00482189,0x000e217c,0x0102101b,0x014410ee,0x014a3192,0x010c3167,0x0002001e,0x004400eb,0x004a2197,0x000c2162,0x01001005,0x014610f0,0x0148318c,0x010e3179}, + [16]uint32{0x3f800000,0x3f802300,0x3f802410,0x3f800710,0x3f808108,0x3f80a208,0x3f80a518,0x3f808618,0x3f800100,0x3f802200,0x3f802510,0x3f800610,0x3f808008,0x3f80a308,0x3f80a418,0x3f808718}, + uint32(0xfff80000), + [21]string{"0x23","0x07","0xea","0x91","0x71","0xbe","0xb3","0x40","0x97","0xea","0x80","0xf3","0x60","0xf0","0x5c","0xc4","0x25","0x5e","0x63","0xb3","0x00"} }, + { + /* No.587 delta:790 weight:985 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0xe507a764,0xbd470523,0x5840a247,0x071024bc,0xe21783d8,0xba57219f,0x5f5086fb,0x00006a57,0xe507cd33,0xbd476f74,0x5840c810,0x07104eeb,0xe217e98f,0xba574bc8,0x5f50ecac}, + [16]uint32{0x00000000,0x100dc492,0x32022369,0x220fe7fb,0x4020001e,0x502dc48c,0x72222377,0x622fe7e5,0x20541426,0x3059d0b4,0x1256374f,0x025bf3dd,0x60741438,0x7079d0aa,0x52763751,0x427bf3c3}, + [16]uint32{0x3f800000,0x3f8806e2,0x3f990111,0x3f9107f3,0x3fa01000,0x3fa816e2,0x3fb91111,0x3fb117f3,0x3f902a0a,0x3f982ce8,0x3f892b1b,0x3f812df9,0x3fb03a0a,0x3fb83ce8,0x3fa93b1b,0x3fa13df9}, + uint32(0xfff80000), + [21]string{"0x4f","0x1a","0xf7","0xeb","0xac","0x14","0x00","0x08","0xf6","0x70","0x27","0x49","0x53","0x85","0x8a","0x65","0x64","0x96","0x6c","0xf8","0x00"} }, + { + /* No.588 delta:995 weight:731 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x9d944760,0x0dc28bf0,0x9056cc90,0xcf1024ca,0x528463aa,0xc2d2af3a,0x5f46e85a,0x00008812,0x9d94cf72,0x0dc203e2,0x90564482,0xcf10acd8,0x5284ebb8,0xc2d22728,0x5f466048}, + [16]uint32{0x00000000,0x009370ff,0x0084100d,0x001760f2,0x64221014,0x64b160eb,0x64a60019,0x643570e6,0x00188877,0x008bf888,0x009c987a,0x000fe885,0x643a9863,0x64a9e89c,0x64be886e,0x642df891}, + [16]uint32{0x3f800000,0x3f8049b8,0x3f804208,0x3f800bb0,0x3fb21108,0x3fb258b0,0x3fb25300,0x3fb21ab8,0x3f800c44,0x3f8045fc,0x3f804e4c,0x3f8007f4,0x3fb21d4c,0x3fb254f4,0x3fb25f44,0x3fb216fc}, + uint32(0xfff80000), + [21]string{"0x7b","0xb1","0xab","0xba","0x95","0x4b","0xee","0xd4","0x3d","0x12","0x9e","0xae","0xc2","0x8c","0xaf","0x4b","0xaa","0xd7","0x10","0x18","0x00"} }, + { + /* No.589 delta:1028 weight:1399 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x926f102b,0xa94f801e,0x3b209035,0xcf4024dc,0x5d2f34f7,0x660fa4c2,0xf460b4e9,0x00002535,0x926f351e,0xa94fa52b,0x3b20b500,0xcf4001e9,0x5d2f11c2,0x660f81f7,0xf46091dc}, + [16]uint32{0x00000000,0x20650536,0x005ee5a5,0x203be093,0x40174c19,0x6072492f,0x4049a9bc,0x602cac8a,0x00034e1b,0x20664b2d,0x005dabbe,0x2038ae88,0x40140202,0x60710734,0x404ae7a7,0x602fe291}, + [16]uint32{0x3f800000,0x3f903282,0x3f802f72,0x3f901df0,0x3fa00ba6,0x3fb03924,0x3fa024d4,0x3fb01656,0x3f8001a7,0x3f903325,0x3f802ed5,0x3f901c57,0x3fa00a01,0x3fb03883,0x3fa02573,0x3fb017f1}, + uint32(0xfff80000), + [21]string{"0x83","0x6a","0xfd","0x6e","0x8b","0x3f","0xbe","0x9f","0xbb","0xba","0xc5","0xea","0x11","0x3a","0xc0","0xc3","0xef","0xec","0xb7","0x3e","0x00"} }, + { + /* No.590 delta:1184 weight:1509 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x7ec2da9f,0xb2a21c05,0xcc60c69a,0x3e8024ec,0x4042fe73,0x8c2238e9,0xf2e0e276,0x00007c8a,0x7ec2a615,0xb2a2608f,0xcc60ba10,0x3e805866,0x404282f9,0x8c224463,0xf2e09efc}, + [16]uint32{0x00000000,0x5036b156,0x103e2e03,0x40089f55,0x00206407,0x5016d551,0x101e4a04,0x4028fb52,0x10408018,0x4076314e,0x007eae1b,0x50481f4d,0x1060e41f,0x40565549,0x005eca1c,0x50687b4a}, + [16]uint32{0x3f800000,0x3fa81b58,0x3f881f17,0x3fa0044f,0x3f801032,0x3fa80b6a,0x3f880f25,0x3fa0147d,0x3f882040,0x3fa03b18,0x3f803f57,0x3fa8240f,0x3f883072,0x3fa02b2a,0x3f802f65,0x3fa8343d}, + uint32(0xfff80000), + [21]string{"0xc6","0x0e","0x52","0xeb","0x49","0xf4","0x46","0x7e","0x6a","0x32","0xeb","0x29","0x18","0xfd","0x14","0xc9","0xf7","0x92","0x81","0x67","0x00"} }, + { + /* No.591 delta:1437 weight:1635 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0x7c0b221b,0x06bf4edf,0x7ab46cc4,0xd8b024f0,0xa4bb06eb,0xde0f6a2f,0xa2044834,0x000082de,0x7c0ba0c5,0x06bfcc01,0x7ab4ee1a,0xd8b0a62e,0xa4bb8435,0xde0fe8f1,0xa204caea}, + [16]uint32{0x00000000,0x442d0c9e,0x20538de9,0x647e8177,0x20373403,0x641a389d,0x0064b9ea,0x4449b574,0x00181992,0x4435150c,0x204b947b,0x646698e5,0x202f2d91,0x6402210f,0x007ca078,0x4451ace6}, + [16]uint32{0x3f800000,0x3fa21686,0x3f9029c6,0x3fb23f40,0x3f901b9a,0x3fb20d1c,0x3f80325c,0x3fa224da,0x3f800c0c,0x3fa21a8a,0x3f9025ca,0x3fb2334c,0x3f901796,0x3fb20110,0x3f803e50,0x3fa228d6}, + uint32(0xfff80000), + [21]string{"0xce","0x5c","0x8e","0x30","0xda","0x87","0xc7","0x78","0x6b","0xc1","0xef","0xcf","0x9f","0xdb","0x43","0x64","0x0c","0x85","0xf5","0x5d","0x00"} }, + { + /* No.592 delta:1237 weight:1641 */ + 11213, + 75, + 13, + 4, + [16]uint32{0x00000000,0x9cd3418d,0x00dacc27,0x9c098daa,0xca002509,0x56d36484,0xcadae92e,0x5609a8a3,0x000048d7,0x9cd3095a,0x00da84f0,0x9c09c57d,0xca006dde,0x56d32c53,0xcadaa1f9,0x5609e074}, + [16]uint32{0x00000000,0x002300fe,0x000501fd,0x00260103,0x006b81a6,0x00488158,0x006e805b,0x004d80a5,0x0000a097,0x0023a069,0x0005a16a,0x0026a194,0x006b2131,0x004821cf,0x006e20cc,0x004d2032}, + [16]uint32{0x3f800000,0x3f801180,0x3f800280,0x3f801300,0x3f8035c0,0x3f802440,0x3f803740,0x3f8026c0,0x3f800050,0x3f8011d0,0x3f8002d0,0x3f801350,0x3f803590,0x3f802410,0x3f803710,0x3f802690}, + uint32(0xfff80000), + [21]string{"0x2a","0x59","0xaf","0xc9","0xf3","0x7c","0x73","0xcc","0x2c","0x98","0x5d","0x1f","0x78","0xeb","0x3a","0xbb","0x1a","0x2c","0x00","0xf3","0x00"} }, + { + /* No.593 delta:851 weight:1233 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x8d9eb4ed,0x798b2d00,0xf41599ed,0xe3702511,0x6eee91fc,0x9afb0811,0x1765bcfc,0x0000d290,0x8d9e667d,0x798bff90,0xf4154b7d,0xe370f781,0x6eee436c,0x9afbda81,0x17656e6c}, + [16]uint32{0x00000000,0xd005535e,0x206180fb,0xf064d3a5,0x000095dd,0xd005c683,0x20611526,0xf0644678,0x6006200a,0xb0037354,0x4067a0f1,0x9062f3af,0x6006b5d7,0xb003e689,0x4067352c,0x90626672}, + [16]uint32{0x3f800000,0x3fe802a9,0x3f9030c0,0x3ff83269,0x3f80004a,0x3fe802e3,0x3f90308a,0x3ff83223,0x3fb00310,0x3fd801b9,0x3fa033d0,0x3fc83179,0x3fb0035a,0x3fd801f3,0x3fa0339a,0x3fc83133}, + uint32(0xfff80000), + [21]string{"0xaf","0x54","0xe4","0x6d","0xed","0xa3","0x9c","0x8c","0xc3","0xc7","0x4c","0xb2","0x74","0x58","0x7a","0x2b","0x05","0x1a","0x2c","0x1f","0x00"} }, + { + /* No.594 delta:964 weight:1441 */ + 11213, + 64, + 13, + 4, + [16]uint32{0x00000000,0x999400a5,0xb9a6fae0,0x2032fa45,0xbf60252a,0x26f4258f,0x06c6dfca,0x9f52df6f,0x00008203,0x999482a6,0xb9a678e3,0x20327846,0xbf60a729,0x26f4a78c,0x06c65dc9,0x9f525d6c}, + [16]uint32{0x00000000,0x004a009a,0x0003806d,0x004980f7,0x20169013,0x205c9089,0x2015107e,0x205f10e4,0x000271cb,0x00487151,0x0001f1a6,0x004bf13c,0x2014e1d8,0x205ee142,0x201761b5,0x205d612f}, + [16]uint32{0x3f800000,0x3f802500,0x3f8001c0,0x3f8024c0,0x3f900b48,0x3f902e48,0x3f900a88,0x3f902f88,0x3f800138,0x3f802438,0x3f8000f8,0x3f8025f8,0x3f900a70,0x3f902f70,0x3f900bb0,0x3f902eb0}, + uint32(0xfff80000), + [21]string{"0x5c","0x42","0x3e","0xc4","0xe2","0x2c","0x70","0xd5","0x10","0x6b","0x3c","0xf4","0x07","0x5b","0x40","0x12","0x9e","0x84","0xac","0x92","0x00"} }, + { + /* No.595 delta:1005 weight:1563 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0x1e48f78e,0x7ad5bf5f,0x649d48d1,0x14602530,0x0a28d2be,0x6eb59a6f,0x70fd6de1,0x0000a249,0x1e4855c7,0x7ad51d16,0x649dea98,0x14608779,0x0a2870f7,0x6eb53826,0x70fdcfa8}, + [16]uint32{0x00000000,0x0006007a,0x208079ae,0x208679d4,0x0050290b,0x00562971,0x20d050a5,0x20d650df,0x00006023,0x00066059,0x2080198d,0x208619f7,0x00504928,0x00564952,0x20d03086,0x20d630fc}, + [16]uint32{0x3f800000,0x3f800300,0x3f90403c,0x3f90433c,0x3f802814,0x3f802b14,0x3f906828,0x3f906b28,0x3f800030,0x3f800330,0x3f90400c,0x3f90430c,0x3f802824,0x3f802b24,0x3f906818,0x3f906b18}, + uint32(0xfff80000), + [21]string{"0x00","0xf7","0x75","0x4f","0xb4","0xbc","0xf9","0x6b","0xcc","0x2e","0xe9","0x87","0x9d","0x13","0xfa","0x99","0x0b","0x3b","0xd4","0x30","0x00"} }, + { + /* No.596 delta:1574 weight:1671 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0x2c2cbe52,0x1b48725a,0x3764cc08,0xd140254e,0xfd6c9b1c,0xca085714,0xe624e946,0x0000c506,0x2c2c7b54,0x1b48b75c,0x3764090e,0xd140e048,0xfd6c5e1a,0xca089212,0xe6242c40}, + [16]uint32{0x00000000,0x003001f7,0x000c0074,0x003c0183,0x00400172,0x00700085,0x004c0106,0x007c00f1,0x00020053,0x003201a4,0x000e0027,0x003e01d0,0x00420121,0x007200d6,0x004e0155,0x007e00a2}, + [16]uint32{0x3f800000,0x3f801800,0x3f800600,0x3f801e00,0x3f802000,0x3f803800,0x3f802600,0x3f803e00,0x3f800100,0x3f801900,0x3f800700,0x3f801f00,0x3f802100,0x3f803900,0x3f802700,0x3f803f00}, + uint32(0xfff80000), + [21]string{"0xe7","0x43","0x7b","0x38","0x3d","0x4f","0xb3","0x76","0x06","0x90","0xcc","0x06","0x32","0x39","0x55","0xb7","0xf4","0xa4","0x3d","0x6f","0x00"} }, + { + /* No.597 delta:995 weight:1485 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xcb21f7ef,0xd7194c56,0x1c38bbb9,0x91602552,0x5a41d2bd,0x46796904,0x8d589eeb,0x00007dc9,0xcb218a26,0xd719319f,0x1c38c670,0x9160589b,0x5a41af74,0x467914cd,0x8d58e322}, + [16]uint32{0x00000000,0x007720b3,0x004b361c,0x003c16af,0x08010176,0x087621c5,0x084a376a,0x083d17d9,0x000ab008,0x007d90bb,0x00418614,0x0036a6a7,0x080bb17e,0x087c91cd,0x08408762,0x0837a7d1}, + [16]uint32{0x3f800000,0x3f803b90,0x3f80259b,0x3f801e0b,0x3f840080,0x3f843b10,0x3f84251b,0x3f841e8b,0x3f800558,0x3f803ec8,0x3f8020c3,0x3f801b53,0x3f8405d8,0x3f843e48,0x3f842043,0x3f841bd3}, + uint32(0xfff80000), + [21]string{"0xc8","0xb0","0x59","0x75","0xcb","0xc1","0x69","0xac","0xe3","0x25","0xef","0xa3","0xd2","0x9a","0xe1","0x92","0xaa","0x78","0xfb","0xee","0x00"} }, + { + /* No.598 delta:973 weight:1701 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x2b424337,0xf5abe468,0xdee9a75f,0xa8e0256c,0x83a2665b,0x5d4bc104,0x76098233,0x0000829b,0x2b42c1ac,0xf5ab66f3,0xdee925c4,0xa8e0a7f7,0x83a2e4c0,0x5d4b439f,0x760900a8}, + [16]uint32{0x00000000,0x0047195e,0x0402f3ab,0x0445eaf5,0x0002c139,0x0045d867,0x04003292,0x04472bcc,0x20418171,0x2006982f,0x244372da,0x24046b84,0x20434048,0x20045916,0x2441b3e3,0x2406aabd}, + [16]uint32{0x3f800000,0x3f80238c,0x3f820179,0x3f8222f5,0x3f800160,0x3f8022ec,0x3f820019,0x3f822395,0x3f9020c0,0x3f90034c,0x3f9221b9,0x3f920235,0x3f9021a0,0x3f90022c,0x3f9220d9,0x3f920355}, + uint32(0xfff80000), + [21]string{"0xfd","0xa6","0x08","0xa1","0x34","0x48","0xd8","0x48","0x0e","0x32","0x30","0x35","0x46","0x2b","0x49","0x5d","0x98","0xf4","0xc3","0xcf","0x00"} }, + { + /* No.599 delta:651 weight:1201 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xee34b5e5,0xede22038,0x03d695dd,0x48f02572,0xa6c49097,0xa512054a,0x4b26b0af,0x000031ad,0xee348448,0xede21195,0x03d6a470,0x48f014df,0xa6c4a13a,0xa51234e7,0x4b268102}, + [16]uint32{0x00000000,0x4058881e,0x0023c28c,0x407b4a92,0x0130217f,0x4168a961,0x0113e3f3,0x414b6bed,0x20130019,0x604b8807,0x2030c295,0x60684a8b,0x21232166,0x617ba978,0x2100e3ea,0x61586bf4}, + [16]uint32{0x3f800000,0x3fa02c44,0x3f8011e1,0x3fa03da5,0x3f809810,0x3fa0b454,0x3f8089f1,0x3fa0a5b5,0x3f900980,0x3fb025c4,0x3f901861,0x3fb03425,0x3f909190,0x3fb0bdd4,0x3f908071,0x3fb0ac35}, + uint32(0xfff80000), + [21]string{"0x04","0x3f","0xe7","0x7f","0x3a","0xdb","0xae","0x81","0xfd","0x93","0xb4","0x48","0x60","0xee","0xd9","0xb7","0x98","0x19","0x09","0x2e","0x00"} }, + { + /* No.600 delta:1387 weight:1713 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xb65f7d7c,0xa8d0a065,0x1e8fdd19,0x12002580,0xa45f58fc,0xbad085e5,0x0c8ff899,0x00001877,0xb65f650b,0xa8d0b812,0x1e8fc56e,0x12003df7,0xa45f408b,0xbad09d92,0x0c8fe0ee}, + [16]uint32{0x00000000,0x2c67e5b6,0x006601e7,0x2c01e451,0x5004115f,0x7c63f4e9,0x506210b8,0x7c05f50e,0x040a7806,0x286d9db0,0x046c79e1,0x280b9c57,0x540e6959,0x78698cef,0x546868be,0x780f8d08}, + [16]uint32{0x3f800000,0x3f9633f2,0x3f803300,0x3f9600f2,0x3fa80208,0x3fbe31fa,0x3fa83108,0x3fbe02fa,0x3f82053c,0x3f9436ce,0x3f82363c,0x3f9405ce,0x3faa0734,0x3fbc34c6,0x3faa3434,0x3fbc07c6}, + uint32(0xfff80000), + [21]string{"0x79","0xf0","0x41","0x84","0x97","0x13","0xbb","0xe5","0x60","0xcc","0x7f","0x22","0x69","0x0d","0xe7","0x2c","0x76","0x70","0x2a","0x62","0x00"} }, + { + /* No.601 delta:823 weight:1563 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x54749ca5,0x6435fceb,0x3041604e,0x76a02591,0x22d4b934,0x1295d97a,0x46e145df,0x00003f82,0x5474a327,0x6435c369,0x30415fcc,0x76a01a13,0x22d486b6,0x1295e6f8,0x46e17a5d}, + [16]uint32{0x00000000,0x2116cd97,0x00251543,0x2133d8d4,0x0002f21f,0x21143f88,0x0027e75c,0x21312acb,0x10404012,0x31568d85,0x10655551,0x317398c6,0x1042b20d,0x31547f9a,0x1067a74e,0x31716ad9}, + [16]uint32{0x3f800000,0x3f908b66,0x3f80128a,0x3f9099ec,0x3f800179,0x3f908a1f,0x3f8013f3,0x3f909895,0x3f882020,0x3f98ab46,0x3f8832aa,0x3f98b9cc,0x3f882159,0x3f98aa3f,0x3f8833d3,0x3f98b8b5}, + uint32(0xfff80000), + [21]string{"0xb2","0xa7","0x9e","0xdb","0x67","0x54","0x9d","0x5f","0x3c","0xd7","0xcd","0x32","0xe0","0xf1","0x5e","0x15","0xac","0x11","0xc3","0x90","0x00"} }, + { + /* No.602 delta:1045 weight:1421 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0xced295ce,0x9b250664,0x55f793aa,0xb99025a0,0x7742b06e,0x22b523c4,0xec67b60a,0x00008fff,0xced21a31,0x9b25899b,0x55f71c55,0xb990aa5f,0x77423f91,0x22b5ac3b,0xec6739f5}, + [16]uint32{0x00000000,0x3037081a,0x0040d0d6,0x3077d8cc,0x000e6a15,0x3039620f,0x004ebac3,0x3079b2d9,0x20026132,0x10356928,0x2042b1e4,0x1075b9fe,0x200c0b27,0x103b033d,0x204cdbf1,0x107bd3eb}, + [16]uint32{0x3f800000,0x3f981b84,0x3f802068,0x3f983bec,0x3f800735,0x3f981cb1,0x3f80275d,0x3f983cd9,0x3f900130,0x3f881ab4,0x3f902158,0x3f883adc,0x3f900605,0x3f881d81,0x3f90266d,0x3f883de9}, + uint32(0xfff80000), + [21]string{"0xb7","0x69","0x8a","0x1b","0x23","0x0e","0x52","0xfe","0xb0","0x06","0x8e","0x54","0x62","0x96","0xff","0x4e","0x99","0xda","0xb2","0x76","0x00"} }, + { + /* No.603 delta:1118 weight:1471 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0x57c64060,0xd9f2496f,0x8e34090f,0x6a4025b0,0x3d8665d0,0xb3b26cdf,0xe4742cbf,0x0000a7fb,0x57c6e79b,0xd9f2ee94,0x8e34aef4,0x6a40824b,0x3d86c22b,0xb3b2cb24,0xe4748b44}, + [16]uint32{0x00000000,0x002c2956,0x005a31ef,0x007618b9,0x0009606d,0x0025493b,0x00535182,0x007f78d4,0x410479e7,0x412850b1,0x415e4808,0x4172615e,0x410d198a,0x412130dc,0x41572865,0x417b0133}, + [16]uint32{0x3f800000,0x3f801614,0x3f802d18,0x3f803b0c,0x3f8004b0,0x3f8012a4,0x3f8029a8,0x3f803fbc,0x3fa0823c,0x3fa09428,0x3fa0af24,0x3fa0b930,0x3fa0868c,0x3fa09098,0x3fa0ab94,0x3fa0bd80}, + uint32(0xfff80000), + [21]string{"0xba","0xf7","0xbc","0x44","0xdf","0x33","0xe7","0xfb","0xab","0xb6","0xc9","0x4f","0x00","0xa8","0xe9","0x5b","0x58","0xe9","0x70","0x90","0x00"} }, + { + /* No.604 delta:936 weight:1635 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x9c8048c4,0x768a1136,0xea0a59f2,0x60a025c6,0xfc206d02,0x162a34f0,0x8aaa7c34,0x00005492,0x9c801c56,0x768a45a4,0xea0a0d60,0x60a07154,0xfc203990,0x162a6062,0x8aaa28a6}, + [16]uint32{0x00000000,0x20058a13,0x002278fc,0x2027f2ef,0x5000661b,0x7005ec08,0x50221ee7,0x702794f4,0x5000200a,0x7005aa19,0x502258f6,0x7027d2e5,0x00004611,0x2005cc02,0x00223eed,0x2027b4fe}, + [16]uint32{0x3f800000,0x3f9002c5,0x3f80113c,0x3f9013f9,0x3fa80033,0x3fb802f6,0x3fa8110f,0x3fb813ca,0x3fa80010,0x3fb802d5,0x3fa8112c,0x3fb813e9,0x3f800023,0x3f9002e6,0x3f80111f,0x3f9013da}, + uint32(0xfff80000), + [21]string{"0x08","0x3e","0x62","0xc3","0x49","0xd3","0xf0","0xf6","0xc2","0x80","0xc3","0x06","0xbf","0x53","0x2b","0xec","0x95","0xd9","0xda","0x0f","0x00"} }, + { + /* No.605 delta:1103 weight:1361 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0x6f5407f2,0xfce50ba0,0x93b10c52,0x2e7025db,0x41242229,0xd2952e7b,0xbdc12989,0x0000f0f0,0x6f54f702,0xfce5fb50,0x93b1fca2,0x2e70d52b,0x4124d2d9,0xd295de8b,0xbdc1d979}, + [16]uint32{0x00000000,0x304e09d6,0x000211bf,0x304c1869,0x2012401a,0x105c49cc,0x201051a5,0x105e5873,0x10410104,0x200f08d2,0x104310bb,0x200d196d,0x3053411e,0x001d48c8,0x305150a1,0x001f5977}, + [16]uint32{0x3f800000,0x3f982704,0x3f800108,0x3f98260c,0x3f900920,0x3f882e24,0x3f900828,0x3f882f2c,0x3f882080,0x3f900784,0x3f882188,0x3f90068c,0x3f9829a0,0x3f800ea4,0x3f9828a8,0x3f800fac}, + uint32(0xfff80000), + [21]string{"0x5f","0x6c","0xcc","0x8b","0x15","0xe0","0xc0","0x17","0x74","0x39","0x8a","0xda","0x5a","0xba","0x72","0xf0","0x0b","0xde","0x4a","0x8d","0x00"} }, + { + /* No.606 delta:1146 weight:1309 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xd9ee8680,0x9dfedd30,0x44105bb0,0x8bf025e1,0x521ea361,0x160ef8d1,0xcfe07e51,0x00006d60,0xd9eeebe0,0x9dfeb050,0x441036d0,0x8bf04881,0x521ece01,0x160e95b1,0xcfe01331}, + [16]uint32{0x00000000,0x606b807e,0x00540155,0x603f812b,0x400261ec,0x2069e192,0x405660b9,0x203de0c7,0x0002601d,0x6069e063,0x00566148,0x603de136,0x400001f1,0x206b818f,0x405400a4,0x203f80da}, + [16]uint32{0x3f800000,0x3fb035c0,0x3f802a00,0x3fb01fc0,0x3fa00130,0x3f9034f0,0x3fa02b30,0x3f901ef0,0x3f800130,0x3fb034f0,0x3f802b30,0x3fb01ef0,0x3fa00000,0x3f9035c0,0x3fa02a00,0x3f901fc0}, + uint32(0xfff80000), + [21]string{"0x2e","0x47","0xd8","0xc5","0xd0","0x3e","0xab","0xe6","0x04","0x41","0x7d","0x2b","0xe3","0xb7","0xb6","0x5f","0x30","0x4a","0x2a","0xe8","0x00"} }, + { + /* No.607 delta:855 weight:1683 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x74e60bda,0x86e864df,0xf20e6f05,0x7f0025fc,0x0be62e26,0xf9e84123,0x8d0e4af9,0x00004467,0x74e64fbd,0x86e820b8,0xf20e2b62,0x7f00619b,0x0be66a41,0xf9e80544,0x8d0e0e9e}, + [16]uint32{0x00000000,0x00021096,0x201ca06b,0x201eb0fd,0x00590e11,0x005b1e87,0x2045ae7a,0x2047beec,0x0010cfae,0x0012df38,0x200c6fc5,0x200e7f53,0x0049c1bf,0x004bd129,0x205561d4,0x20577142}, + [16]uint32{0x3f800000,0x3f800108,0x3f900e50,0x3f900f58,0x3f802c87,0x3f802d8f,0x3f9022d7,0x3f9023df,0x3f800867,0x3f80096f,0x3f900637,0x3f90073f,0x3f8024e0,0x3f8025e8,0x3f902ab0,0x3f902bb8}, + uint32(0xfff80000), + [21]string{"0xcc","0x7f","0x57","0x67","0xe0","0x2b","0x93","0x72","0x25","0x14","0x8e","0xfb","0xab","0x9d","0x9e","0x84","0xe8","0x13","0xf3","0xc7","0x00"} }, + { + /* No.608 delta:1082 weight:1415 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0xfcbfc022,0xc765e810,0x3bda2832,0xa6d0260e,0x5a6fe62c,0x61b5ce1e,0x9d0a0e3c,0x00002cf4,0xfcbfecd6,0xc765c4e4,0x3bda04c6,0xa6d00afa,0x5a6fcad8,0x61b5e2ea,0x9d0a22c8}, + [16]uint32{0x00000000,0x00483c71,0x003e080f,0x0076347e,0x10081014,0x10402c65,0x1036181b,0x107e246a,0x10034406,0x104b7877,0x103d4c09,0x10757078,0x000b5412,0x00436863,0x00355c1d,0x007d606c}, + [16]uint32{0x3f800000,0x3f80241e,0x3f801f04,0x3f803b1a,0x3f880408,0x3f882016,0x3f881b0c,0x3f883f12,0x3f8801a2,0x3f8825bc,0x3f881ea6,0x3f883ab8,0x3f8005aa,0x3f8021b4,0x3f801aae,0x3f803eb0}, + uint32(0xfff80000), + [21]string{"0x99","0x9f","0xab","0xfc","0x24","0xf3","0x5b","0xa0","0xcb","0xa1","0x5c","0xb0","0xed","0x9a","0x76","0x00","0x0c","0xca","0x96","0x56","0x00"} }, + { + /* No.609 delta:2869 weight:817 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0xfb16ba9d,0x3cb695cd,0xc7a02f50,0xb0702611,0x4b669c8c,0x8cc6b3dc,0x77d00941,0x00007d23,0xfb16c7be,0x3cb6e8ee,0xc7a05273,0xb0705b32,0x4b66e1af,0x8cc6ceff,0x77d07462}, + [16]uint32{0x00000000,0xc85c1356,0x0c609102,0xc43c8254,0x6824287a,0xa0783b2c,0x6444b978,0xac18aa2e,0x0a00019d,0xc25c12cb,0x0660909f,0xce3c83c9,0x622429e7,0xaa783ab1,0x6e44b8e5,0xa618abb3}, + [16]uint32{0x3f800000,0x3fe42e09,0x3f863048,0x3fe21e41,0x3fb41214,0x3fd03c1d,0x3fb2225c,0x3fd60c55,0x3f850000,0x3fe12e09,0x3f833048,0x3fe71e41,0x3fb11214,0x3fd53c1d,0x3fb7225c,0x3fd30c55}, + uint32(0xfff80000), + [21]string{"0xc5","0xea","0xe7","0x52","0xe0","0x2c","0x43","0x7d","0x40","0x3d","0x1a","0x11","0xaa","0xe6","0x80","0xa7","0xb5","0xde","0x68","0x23","0x00"} }, + { + /* No.610 delta:887 weight:1295 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x0ebbeaf0,0x22eaefc6,0x2c510536,0x5ff0262a,0x514bccda,0x7d1ac9ec,0x73a1231c,0x000081df,0x0ebb6b2f,0x22ea6e19,0x2c5184e9,0x5ff0a7f5,0x514b4d05,0x7d1a4833,0x73a1a2c3}, + [16]uint32{0x00000000,0x2026501f,0x1003a80b,0x3025f814,0x41021419,0x61244406,0x5101bc12,0x7127ec0d,0x00020d96,0x20245d89,0x1001a59d,0x3027f582,0x4100198f,0x61264990,0x5103b184,0x7125e19b}, + [16]uint32{0x3f800000,0x3f901328,0x3f8801d4,0x3f9812fc,0x3fa0810a,0x3fb09222,0x3fa880de,0x3fb893f6,0x3f800106,0x3f90122e,0x3f8800d2,0x3f9813fa,0x3fa0800c,0x3fb09324,0x3fa881d8,0x3fb892f0}, + uint32(0xfff80000), + [21]string{"0x6e","0x23","0xda","0xaf","0xad","0x9d","0xd2","0x68","0xd9","0xd8","0x84","0xb3","0x63","0x4c","0xba","0xde","0xc0","0x1f","0xb4","0x21","0x00"} }, + { + /* No.611 delta:771 weight:1551 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xa79f7ea7,0x932ad413,0x34b5aab4,0xcc50263b,0x6bcf589c,0x5f7af228,0xf8e58c8f,0x00008563,0xa79ffbc4,0x932a5170,0x34b52fd7,0xcc50a358,0x6bcfddff,0x5f7a774b,0xf8e509ec}, + [16]uint32{0x00000000,0x202215f5,0x50240416,0x700611e3,0xe024201b,0xc00635ee,0xb000240d,0x902231f8,0x40400024,0x606215d1,0x10640432,0x304611c7,0xa064203f,0x804635ca,0xf0402429,0xd06231dc}, + [16]uint32{0x3f800000,0x3f90110a,0x3fa81202,0x3fb80308,0x3ff01210,0x3fe0031a,0x3fd80012,0x3fc81118,0x3fa02000,0x3fb0310a,0x3f883202,0x3f982308,0x3fd03210,0x3fc0231a,0x3ff82012,0x3fe83118}, + uint32(0xfff80000), + [21]string{"0xfb","0xcc","0x8c","0xe9","0x4d","0x94","0x92","0x14","0x0d","0xf4","0x49","0x43","0x37","0x7b","0xee","0x2d","0x09","0x84","0x27","0x6e","0x00"} }, + { + /* No.612 delta:1721 weight:1683 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x608bed53,0xdaa13f6c,0xba2ad23f,0x06102645,0x669bcb16,0xdcb11929,0xbc3af47a,0x00006462,0x608b8931,0xdaa15b0e,0xba2ab65d,0x06104227,0x669baf74,0xdcb17d4b,0xbc3a9018}, + [16]uint32{0x00000000,0x007001d3,0x000c019c,0x007c004f,0x0000804d,0x0070819e,0x000c81d1,0x007c8002,0x002a4017,0x005a41c4,0x0026418b,0x00564058,0x002ac05a,0x005ac189,0x0026c1c6,0x0056c015}, + [16]uint32{0x3f800000,0x3f803800,0x3f800600,0x3f803e00,0x3f800040,0x3f803840,0x3f800640,0x3f803e40,0x3f801520,0x3f802d20,0x3f801320,0x3f802b20,0x3f801560,0x3f802d60,0x3f801360,0x3f802b60}, + uint32(0xfff80000), + [21]string{"0x86","0x13","0x4c","0x43","0xa4","0xd1","0x89","0x22","0x7e","0x2b","0xc1","0x6f","0xbb","0xa2","0xfb","0xad","0x01","0x59","0x8b","0x69","0x00"} }, + { + /* No.613 delta:1309 weight:1651 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x8725599c,0xcc344751,0x4b111ecd,0x3400265f,0xb3257fc3,0xf834610e,0x7f113892,0x00002a3f,0x872573a3,0xcc346d6e,0x4b1134f2,0x34000c60,0xb32555fc,0xf8344b31,0x7f1112ad}, + [16]uint32{0x00000000,0x5004847e,0x20401c05,0x7044987b,0x107e0014,0x407a846a,0x303e1c11,0x603a986f,0x0056c022,0x5052445c,0x2016dc27,0x70125859,0x1028c036,0x402c4448,0x3068dc33,0x606c584d}, + [16]uint32{0x3f800000,0x3fa80242,0x3f90200e,0x3fb8224c,0x3f883f00,0x3fa03d42,0x3f981f0e,0x3fb01d4c,0x3f802b60,0x3fa82922,0x3f900b6e,0x3fb8092c,0x3f881460,0x3fa01622,0x3f98346e,0x3fb0362c}, + uint32(0xfff80000), + [21]string{"0xa7","0xd5","0x92","0x22","0x73","0x00","0x0b","0xe0","0x53","0xb8","0x04","0x95","0xf2","0xbe","0xdb","0x95","0x68","0xb1","0x94","0x18","0x00"} }, + { + /* No.614 delta:2905 weight:769 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0x638e4117,0xecbfe499,0x8f31a58e,0x81302667,0xe2be6770,0x6d8fc2fe,0x0e0183e9,0x00000cf7,0x638e4de0,0xecbfe86e,0x8f31a979,0x81302a90,0xe2be6b87,0x6d8fce09,0x0e018f1e}, + [16]uint32{0x00000000,0x90f0923a,0x0c290014,0x9cd9922e,0x127a9006,0x828a023c,0x1e539012,0x8ea30228,0x0820050d,0x98d09737,0x04090519,0x94f99723,0x1a5a950b,0x8aaa0731,0x1673951f,0x86830725}, + [16]uint32{0x3f800000,0x3fc87849,0x3f861480,0x3fce6cc9,0x3f893d48,0x3fc14501,0x3f8f29c8,0x3fc75181,0x3f841002,0x3fcc684b,0x3f820482,0x3fca7ccb,0x3f8d2d4a,0x3fc55503,0x3f8b39ca,0x3fc34183}, + uint32(0xfff80000), + [21]string{"0x1d","0x1a","0x3b","0xef","0x38","0x1f","0x12","0x0b","0x21","0x12","0x98","0xd8","0x8f","0xc9","0x9f","0xfb","0x4b","0xbe","0x6b","0x92","0x00"} }, + { + /* No.615 delta:1665 weight:1565 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xf4088f50,0x4b8225bc,0xbf8aaaec,0xa480267f,0x5088a92f,0xef0203c3,0x1b0a8c93,0x00009f95,0xf40810c5,0x4b82ba29,0xbf8a3579,0xa480b9ea,0x508836ba,0xef029c56,0x1b0a1306}, + [16]uint32{0x00000000,0x0d4660da,0x035a40d9,0x0e1c2003,0x03c0f0a4,0x0e86907e,0x009ab07d,0x0ddcd0a7,0x010441a8,0x0c422172,0x025e0171,0x0f1861ab,0x02c4b10c,0x0f82d1d6,0x019ef1d5,0x0cd8910f}, + [16]uint32{0x3f800000,0x3f86a330,0x3f81ad20,0x3f870e10,0x3f81e078,0x3f874348,0x3f804d58,0x3f86ee68,0x3f808220,0x3f862110,0x3f812f00,0x3f878c30,0x3f816258,0x3f87c168,0x3f80cf78,0x3f866c48}, + uint32(0xfff80000), + [21]string{"0xa4","0xc4","0xa6","0xfb","0x2f","0x2e","0xa7","0xd2","0xc7","0x23","0x3e","0x43","0xb2","0x17","0x37","0x40","0xa6","0x54","0xfa","0x59","0x00"} }, + { + /* No.616 delta:867 weight:1503 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0x92bb52eb,0x65a9b7fe,0xf712e515,0xa7f02689,0x354b7462,0xc2599177,0x50e2c39c,0x0000f6d6,0x92bba43d,0x65a94128,0xf71213c3,0xa7f0d05f,0x354b82b4,0xc25967a1,0x50e2354a}, + [16]uint32{0x00000000,0xc0609df6,0x00025b53,0xc062c6a5,0x0022421d,0xc042dfeb,0x0020194e,0xc04084b8,0x20020202,0xe0629ff4,0x20005951,0xe060c4a7,0x2020401f,0xe040dde9,0x20221b4c,0xe04286ba}, + [16]uint32{0x3f800000,0x3fe0304e,0x3f80012d,0x3fe03163,0x3f801121,0x3fe0216f,0x3f80100c,0x3fe02042,0x3f900101,0x3ff0314f,0x3f90002c,0x3ff03062,0x3f901020,0x3ff0206e,0x3f90110d,0x3ff02143}, + uint32(0xfff80000), + [21]string{"0x85","0x04","0xca","0xaf","0x94","0xdd","0x85","0xe1","0xcb","0x14","0x33","0x83","0x79","0x98","0x3c","0x75","0xc4","0x49","0xfd","0x6b","0x00"} }, + { + /* No.617 delta:1676 weight:1639 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0x27527d8e,0xcb473f15,0xec15429b,0xf250269a,0xd5025b14,0x3917198f,0x1e456401,0x0000c47a,0x2752b9f4,0xcb47fb6f,0xec1586e1,0xf250e2e0,0xd5029f6e,0x3917ddf5,0x1e45a07b}, + [16]uint32{0x00000000,0x006c2155,0x00034073,0x006f6126,0x0204c1f8,0x0268e0ad,0x0207818b,0x026ba0de,0x0000c137,0x006ce062,0x00038144,0x006fa011,0x020400cf,0x0268219a,0x020740bc,0x026b61e9}, + [16]uint32{0x3f800000,0x3f803610,0x3f8001a0,0x3f8037b0,0x3f810260,0x3f813470,0x3f8103c0,0x3f8135d0,0x3f800060,0x3f803670,0x3f8001c0,0x3f8037d0,0x3f810200,0x3f813410,0x3f8103a0,0x3f8135b0}, + uint32(0xfff80000), + [21]string{"0xbf","0x62","0x44","0x02","0x13","0xf1","0xcc","0xa4","0x9c","0xb4","0xde","0x95","0x97","0x5c","0x54","0x98","0x60","0x15","0x39","0x8e","0x00"} }, + { + /* No.618 delta:1717 weight:1347 */ + 11213, + 64, + 13, + 4, + [16]uint32{0x00000000,0xd81946d0,0x6175779c,0xb96c314c,0xbbd026a6,0x63c96076,0xdaa5513a,0x02bc17ea,0x00006fcc,0xd819291c,0x61751850,0xb96c5e80,0xbbd0496a,0x63c90fba,0xdaa53ef6,0x02bc7826}, + [16]uint32{0x00000000,0x000200bf,0x00000082,0x0002003d,0x2069019a,0x206b0125,0x20690118,0x206b01a7,0x401c01b6,0x401e0109,0x401c0134,0x401e018b,0x6075002c,0x60770093,0x607500ae,0x60770011}, + [16]uint32{0x3f800000,0x3f800100,0x3f800000,0x3f800100,0x3f903480,0x3f903580,0x3f903480,0x3f903580,0x3fa00e00,0x3fa00f00,0x3fa00e00,0x3fa00f00,0x3fb03a80,0x3fb03b80,0x3fb03a80,0x3fb03b80}, + uint32(0xfff80000), + [21]string{"0xa4","0x2e","0xda","0xaa","0x55","0x3d","0x86","0x11","0x7e","0x49","0xe4","0xda","0x66","0x35","0x26","0x31","0x60","0x1d","0x6b","0x98","0x00"} }, + { + /* No.619 delta:947 weight:1595 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x524682db,0xd7d886be,0x859e0465,0xd2d026b0,0x8096a46b,0x0508a00e,0x574e22d5,0x0000107f,0x524692a4,0xd7d896c1,0x859e141a,0xd2d036cf,0x8096b414,0x0508b071,0x574e32aa}, + [16]uint32{0x00000000,0x1025f9de,0x20032c4d,0x3026d593,0x20005867,0x3025a1b9,0x0003742a,0x10268df4,0x4003930f,0x50266ad1,0x6000bf42,0x7025469c,0x6003cb68,0x702632b6,0x4000e725,0x50251efb}, + [16]uint32{0x3f800000,0x3f8812fc,0x3f900196,0x3f98136a,0x3f90002c,0x3f9812d0,0x3f8001ba,0x3f881346,0x3fa001c9,0x3fa81335,0x3fb0005f,0x3fb812a3,0x3fb001e5,0x3fb81319,0x3fa00073,0x3fa8128f}, + uint32(0xfff80000), + [21]string{"0x00","0x3e","0xce","0x51","0xcd","0x78","0x94","0x20","0xf3","0x7c","0x06","0xeb","0x07","0x19","0x06","0xf4","0x58","0xb5","0xee","0x24","0x00"} }, + { + /* No.620 delta:3092 weight:635 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xd60ac9f0,0x7c1657f0,0xaa1c9e00,0x949026ce,0x429aef3e,0xe886713e,0x3e8cb8ce,0x00000714,0xd60acee4,0x7c1650e4,0xaa1c9914,0x949021da,0x429ae82a,0xe886762a,0x3e8cbfda}, + [16]uint32{0x00000000,0x83d099df,0x312020b2,0xb2f0b96d,0x10c0058a,0x93109c55,0x21e02538,0xa230bce7,0x0a880014,0x895899cb,0x3ba820a6,0xb878b979,0x1a48059e,0x99989c41,0x2b68252c,0xa8b8bcf3}, + [16]uint32{0x3f800000,0x3fc1e84c,0x3f989010,0x3fd9785c,0x3f886002,0x3fc9884e,0x3f90f012,0x3fd1185e,0x3f854400,0x3fc4ac4c,0x3f9dd410,0x3fdc3c5c,0x3f8d2402,0x3fcccc4e,0x3f95b412,0x3fd45c5e}, + uint32(0xfff80000), + [21]string{"0x23","0xec","0xeb","0x2e","0xe4","0x47","0xc9","0x4f","0xe6","0x31","0xc7","0x30","0xcd","0x95","0xe9","0x0f","0x83","0xde","0xc0","0x16","0x00"} }, + { + /* No.621 delta:655 weight:1715 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0xbb48eeca,0x663d6af7,0xdd75843d,0x362026d8,0x8d68c812,0x501d4c2f,0xeb55a2e5,0x0000620c,0xbb488cc6,0x663d08fb,0xdd75e631,0x362044d4,0x8d68aa1e,0x501d2e23,0xeb55c0e9}, + [16]uint32{0x00000000,0x2075849d,0x000370aa,0x2076f437,0x10388368,0x304d07f5,0x103bf3c2,0x304e775f,0x0000a403,0x2075209e,0x0003d4a9,0x20765034,0x1038276b,0x304da3f6,0x103b57c1,0x304ed35c}, + [16]uint32{0x3f800000,0x3f903ac2,0x3f8001b8,0x3f903b7a,0x3f881c41,0x3f982683,0x3f881df9,0x3f98273b,0x3f800052,0x3f903a90,0x3f8001ea,0x3f903b28,0x3f881c13,0x3f9826d1,0x3f881dab,0x3f982769}, + uint32(0xfff80000), + [21]string{"0xfc","0xa0","0x47","0x6e","0xa0","0x27","0x3f","0xf9","0x1b","0xcd","0x1d","0xe5","0x8c","0xb8","0x30","0xc3","0x1a","0x76","0x3b","0x21","0x00"} }, + { + /* No.622 delta:1514 weight:1541 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0x5eef6293,0x4e715698,0x109e340b,0x08b026e2,0x565f4471,0x46c1707a,0x182e12e9,0x00002fa5,0x5eef4d36,0x4e71793d,0x109e1bae,0x08b00947,0x565f6bd4,0x46c15fdf,0x182e3d4c}, + [16]uint32{0x00000000,0x1037c99e,0x402820a2,0x501fe93c,0x10342157,0x0003e8c9,0x501c01f5,0x402bc86b,0x50559048,0x406259d6,0x107db0ea,0x004a7974,0x4061b11f,0x50567881,0x004991bd,0x107e5823}, + [16]uint32{0x3f800000,0x3f881be4,0x3fa01410,0x3fa80ff4,0x3f881a10,0x3f8001f4,0x3fa80e00,0x3fa015e4,0x3fa82ac8,0x3fa0312c,0x3f883ed8,0x3f80253c,0x3fa030d8,0x3fa82b3c,0x3f8024c8,0x3f883f2c}, + uint32(0xfff80000), + [21]string{"0x7b","0xfd","0xca","0x16","0x74","0x8c","0x4c","0x1d","0x00","0x41","0x9d","0xa7","0x79","0xe3","0xf8","0x58","0xb7","0x27","0x3f","0xe4","0x00"} }, + { + /* No.623 delta:755 weight:1729 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0x46cbd438,0x280f1161,0x6ec4c559,0x4fa026f1,0x096bf2c9,0x67af3790,0x2164e3a8,0x0000c6ea,0x46cb12d2,0x280fd78b,0x6ec403b3,0x4fa0e01b,0x096b3423,0x67aff17a,0x21642542}, + [16]uint32{0x00000000,0xa86058be,0x0003805b,0xa863d8e5,0x0030220a,0xa8507ab4,0x0033a251,0xa853faef,0x1004201d,0xb86478a3,0x1007a046,0xb867f8f8,0x10340217,0xb8545aa9,0x1037824c,0xb857daf2}, + [16]uint32{0x3f800000,0x3fd4302c,0x3f8001c0,0x3fd431ec,0x3f801811,0x3fd4283d,0x3f8019d1,0x3fd429fd,0x3f880210,0x3fdc323c,0x3f8803d0,0x3fdc33fc,0x3f881a01,0x3fdc2a2d,0x3f881bc1,0x3fdc2bed}, + uint32(0xfff80000), + [21]string{"0xb5","0x92","0x01","0x70","0x20","0xd6","0xbb","0x69","0x99","0x3a","0x90","0x4f","0xdc","0xc2","0x17","0x8f","0x8e","0x43","0x14","0x35","0x00"} }, + { + /* No.624 delta:2168 weight:1255 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x9eace3f4,0xcd23c2aa,0x538f215e,0xd1f02700,0x4f5cc4f4,0x1cd3e5aa,0x827f065e,0x00007152,0x9eac92a6,0xcd23b3f8,0x538f500c,0xd1f05652,0x4f5cb5a6,0x1cd394f8,0x827f770c}, + [16]uint32{0x00000000,0x214389db,0x0a026412,0x2b41edc9,0x00704388,0x2133ca53,0x0a72279a,0x2b31ae41,0xb8184165,0x995bc8be,0xb21a2577,0x9359acac,0xb86802ed,0x992b8b36,0xb26a66ff,0x9329ef24}, + [16]uint32{0x3f800000,0x3f90a1c4,0x3f850132,0x3f95a0f6,0x3f803821,0x3f9099e5,0x3f853913,0x3f9598d7,0x3fdc0c20,0x3fccade4,0x3fd90d12,0x3fc9acd6,0x3fdc3401,0x3fcc95c5,0x3fd93533,0x3fc994f7}, + uint32(0xfff80000), + [21]string{"0x7e","0xad","0xfe","0x4e","0x67","0xee","0x0a","0x39","0xeb","0xf2","0xd2","0x5c","0xec","0x45","0x85","0x3a","0x75","0xf3","0x25","0xe7","0x00"} }, + { + /* No.625 delta:811 weight:939 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0x8a37e969,0x8613fabb,0x0c2413d2,0x84102713,0x0e27ce7a,0x0203dda8,0x883434c1,0x0000b09b,0x8a3759f2,0x86134a20,0x0c24a349,0x84109788,0x0e277ee1,0x02036d33,0x8834845a}, + [16]uint32{0x00000000,0x004fe57f,0x501101dd,0x505ee4a2,0x1048942e,0x10077151,0x405995f3,0x4016708c,0x50034014,0x504ca56b,0x001241c9,0x005da4b6,0x404bd43a,0x40043145,0x105ad5e7,0x10153098}, + [16]uint32{0x3f800000,0x3f8027f2,0x3fa80880,0x3fa82f72,0x3f88244a,0x3f8803b8,0x3fa02cca,0x3fa00b38,0x3fa801a0,0x3fa82652,0x3f800920,0x3f802ed2,0x3fa025ea,0x3fa00218,0x3f882d6a,0x3f880a98}, + uint32(0xfff80000), + [21]string{"0x15","0x91","0x6c","0x2d","0x1f","0x9b","0x63","0x02","0xed","0x7e","0x94","0xe9","0x8a","0x87","0x9c","0xf7","0x9c","0x6a","0x57","0xe8","0x00"} }, + { + /* No.626 delta:905 weight:729 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x487ef5e9,0x5ebf8ee5,0x16c17b0c,0xecd0272a,0xa4aed2c3,0xb26fa9cf,0xfa115c26,0x00002da5,0x487ed84c,0x5ebfa340,0x16c156a9,0xecd00a8f,0xa4aeff66,0xb26f846a,0xfa117183}, + [16]uint32{0x00000000,0x081c1ed7,0x0561001b,0x0d7d1ecc,0x40884802,0x489456d5,0x45e94819,0x4df556ce,0x004201a7,0x085e1f70,0x052301bc,0x0d3f1f6b,0x40ca49a5,0x48d65772,0x45ab49be,0x4db75769}, + [16]uint32{0x3f800000,0x3f840e0f,0x3f82b080,0x3f86be8f,0x3fa04424,0x3fa44a2b,0x3fa2f4a4,0x3fa6faab,0x3f802100,0x3f842f0f,0x3f829180,0x3f869f8f,0x3fa06524,0x3fa46b2b,0x3fa2d5a4,0x3fa6dbab}, + uint32(0xfff80000), + [21]string{"0xbf","0x0b","0xe8","0x6e","0xd2","0xb2","0x2e","0xfd","0x0a","0xcf","0x83","0x75","0xe1","0x95","0x9c","0xfc","0x24","0xf1","0x86","0xdc","0x00"} }, + { + /* No.627 delta:708 weight:1509 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0x7c8307e4,0x72c9b5f4,0x0e4ab210,0x75f02730,0x097320d4,0x073992c4,0x7bba9520,0x000049f7,0x7c834e13,0x72c9fc03,0x0e4afbe7,0x75f06ec7,0x09736923,0x0739db33,0x7bbadcd7}, + [16]uint32{0x00000000,0x4004201e,0x20024b2a,0x60066b34,0x7042e276,0x3046c268,0x5040a95c,0x10448942,0x10001005,0x5004301b,0x30025b2f,0x70067b31,0x6042f273,0x2046d26d,0x4040b959,0x00449947}, + [16]uint32{0x3f800000,0x3fa00210,0x3f900125,0x3fb00335,0x3fb82171,0x3f982361,0x3fa82054,0x3f882244,0x3f880008,0x3fa80218,0x3f98012d,0x3fb8033d,0x3fb02179,0x3f902369,0x3fa0205c,0x3f80224c}, + uint32(0xfff80000), + [21]string{"0x1b","0x67","0xbd","0xdc","0x43","0x72","0x4b","0xf1","0x2d","0xbf","0x1f","0x32","0xad","0x1f","0x77","0x96","0x0c","0x80","0xbb","0x03","0x00"} }, + { + /* No.628 delta:1122 weight:1799 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x09bcd29a,0x52ed8467,0x5b5156fd,0xf4902743,0xfd2cf5d9,0xa67da324,0xafc171be,0x00004b29,0x09bc99b3,0x52edcf4e,0x5b511dd4,0xf4906c6a,0xfd2cbef0,0xa67de80d,0xafc13a97}, + [16]uint32{0x00000000,0x4820c11e,0x800061cc,0xc820a0d2,0x1008d008,0x58281116,0x9008b1c4,0xd82870da,0x40022019,0x0822e107,0xc00241d5,0x882280cb,0x500af011,0x182a310f,0xd00a91dd,0x982a50c3}, + [16]uint32{0x3f800000,0x3fa41060,0x3fc00030,0x3fe41050,0x3f880468,0x3fac1408,0x3fc80458,0x3fec1438,0x3fa00110,0x3f841170,0x3fe00120,0x3fc41140,0x3fa80578,0x3f8c1518,0x3fe80548,0x3fcc1528}, + uint32(0xfff80000), + [21]string{"0x0e","0xa2","0x1d","0xef","0x2f","0x58","0x86","0x12","0xe8","0xf5","0x25","0x41","0x7e","0x5f","0xca","0xf2","0xe4","0x42","0xdf","0xc6","0x00"} }, + { + /* No.629 delta:811 weight:1603 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0x3cb77a18,0x4828f6f5,0x749f8ced,0x5f302750,0x63875d48,0x1718d1a5,0x2bafabbd,0x0000ef80,0x3cb79598,0x48281975,0x749f636d,0x5f30c8d0,0x6387b2c8,0x17183e25,0x2baf443d}, + [16]uint32{0x00000000,0x204c84b2,0x40021f46,0x604e9bf4,0x40018205,0x604d06b7,0x00039d43,0x204f19f1,0x1000401b,0x304cc4a9,0x50025f5d,0x704edbef,0x5001c21e,0x704d46ac,0x1003dd58,0x304f59ea}, + [16]uint32{0x3f800000,0x3f902642,0x3fa0010f,0x3fb0274d,0x3fa000c1,0x3fb02683,0x3f8001ce,0x3f90278c,0x3f880020,0x3f982662,0x3fa8012f,0x3fb8276d,0x3fa800e1,0x3fb826a3,0x3f8801ee,0x3f9827ac}, + uint32(0xfff80000), + [21]string{"0xdd","0x8b","0x4d","0xe4","0x27","0x29","0x42","0x47","0x53","0xda","0x4a","0xe9","0xa2","0x5c","0x0b","0x9e","0xbc","0x68","0xe6","0x1f","0x00"} }, + { + /* No.630 delta:1016 weight:1229 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0x5f47ce13,0xfffc577f,0xa0bb996c,0xad70276a,0xf237e979,0x528c7015,0x0dcbbe06,0x000036dd,0x5f47f8ce,0xfffc61a2,0xa0bbafb1,0xad7011b7,0xf237dfa4,0x528c46c8,0x0dcb88db}, + [16]uint32{0x00000000,0x4420185f,0x100600f1,0x542618ae,0x00028194,0x442299cb,0x10048165,0x5424993a,0x00010407,0x44211c58,0x100704f6,0x54271ca9,0x00038593,0x44239dcc,0x10058562,0x54259d3d}, + [16]uint32{0x3f800000,0x3fa2100c,0x3f880300,0x3faa130c,0x3f800140,0x3fa2114c,0x3f880240,0x3faa124c,0x3f800082,0x3fa2108e,0x3f880382,0x3faa138e,0x3f8001c2,0x3fa211ce,0x3f8802c2,0x3faa12ce}, + uint32(0xfff80000), + [21]string{"0xfb","0x6d","0x75","0xc1","0x1e","0xc6","0x12","0x58","0xf7","0x25","0x03","0xec","0xb7","0x75","0xd0","0xf4","0xcd","0x3f","0xf4","0xfb","0x00"} }, + { + /* No.631 delta:995 weight:1673 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x6df50ec3,0xc3232dde,0xaed6231d,0x9aa0277b,0xf75529b8,0x59830aa5,0x34760466,0x0000d47e,0x6df5dabd,0xc323f9a0,0xaed6f763,0x9aa0f305,0xf755fdc6,0x5983dedb,0x3476d018}, + [16]uint32{0x00000000,0x0003ac1e,0xa06835b1,0xa06b99af,0x00602047,0x00638c59,0xa00815f6,0xa00bb9e8,0x1000152c,0x1003b932,0xb068209d,0xb06b8c83,0x1060356b,0x10639975,0xb00800da,0xb00bacc4}, + [16]uint32{0x3f800000,0x3f8001d6,0x3fd0341a,0x3fd035cc,0x3f803010,0x3f8031c6,0x3fd0040a,0x3fd005dc,0x3f88000a,0x3f8801dc,0x3fd83410,0x3fd835c6,0x3f88301a,0x3f8831cc,0x3fd80400,0x3fd805d6}, + uint32(0xfff80000), + [21]string{"0x73","0xf9","0x58","0x94","0xcb","0x1d","0x35","0x64","0x04","0x56","0xc7","0x7d","0x7f","0x0a","0x8a","0xfe","0x8b","0xe0","0x33","0x84","0x00"} }, + { + /* No.632 delta:773 weight:1473 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0x20f1fa99,0xd6561500,0xf6a7ef99,0xf8b0278b,0xd841dd12,0x2ee6328b,0x0e17c812,0x000065ac,0x20f19f35,0xd65670ac,0xf6a78a35,0xf8b04227,0xd841b8be,0x2ee65727,0x0e17adbe}, + [16]uint32{0x00000000,0x1041a0fd,0x8011218c,0x90508171,0x40008092,0x5041206f,0xc011a11e,0xd05001e3,0x0128e128,0x116941d5,0x8139c0a4,0x91786059,0x412861ba,0x5169c147,0xc1394036,0xd178e0cb}, + [16]uint32{0x3f800000,0x3f8820d0,0x3fc00890,0x3fc82840,0x3fa00040,0x3fa82090,0x3fe008d0,0x3fe82800,0x3f809470,0x3f88b4a0,0x3fc09ce0,0x3fc8bc30,0x3fa09430,0x3fa8b4e0,0x3fe09ca0,0x3fe8bc70}, + uint32(0xfff80000), + [21]string{"0x5d","0xc5","0x75","0x67","0xa0","0x3e","0x52","0x15","0x0b","0x40","0x3c","0x18","0x56","0x6e","0x2b","0xe7","0x5f","0x39","0x75","0xec","0x00"} }, + { + /* No.633 delta:860 weight:1601 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0x56a2fcc0,0x37bccf56,0x611e3396,0x91f02796,0xc752db56,0xa64ce8c0,0xf0ee1400,0x0000b0e1,0x56a24c21,0x37bc7fb7,0x611e8377,0x91f09777,0xc7526bb7,0xa64c5821,0xf0eea4e1}, + [16]uint32{0x00000000,0x4008509a,0x1000116f,0x500841f5,0x200341a4,0x600b113e,0x300350cb,0x700b0051,0x004200d7,0x404a504d,0x104211b8,0x504a4122,0x20414173,0x604911e9,0x3041501c,0x70490086}, + [16]uint32{0x3f800000,0x3fa00428,0x3f880008,0x3fa80420,0x3f9001a0,0x3fb00588,0x3f9801a8,0x3fb80580,0x3f802100,0x3fa02528,0x3f882108,0x3fa82520,0x3f9020a0,0x3fb02488,0x3f9820a8,0x3fb82480}, + uint32(0xfff80000), + [21]string{"0xf9","0xf3","0xe7","0x61","0x2a","0xc7","0x69","0xa4","0xdd","0x59","0xbd","0x87","0x5b","0xce","0x3c","0x7c","0x4b","0x51","0x48","0x74","0x00"} }, + { + /* No.634 delta:2645 weight:917 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x469ad979,0x10db26c0,0x5641ffb9,0xed8027a1,0xab1afed8,0xfd5b0161,0xbbc1d818,0x00003231,0x469aeb48,0x10db14f1,0x5641cd88,0xed801590,0xab1acce9,0xfd5b3350,0xbbc1ea29}, + [16]uint32{0x00000000,0x848023d6,0xe581008b,0x6101235d,0x3201034c,0xb681209a,0xd78003c7,0x53002011,0x4049402f,0xc4c963f9,0xa5c840a4,0x21486372,0x72484363,0xf6c860b5,0x97c943e8,0x1349603e}, + [16]uint32{0x3f800000,0x3fc24011,0x3ff2c080,0x3fb08091,0x3f990081,0x3fdb4090,0x3febc001,0x3fa98010,0x3fa024a0,0x3fe264b1,0x3fd2e420,0x3f90a431,0x3fb92421,0x3ffb6430,0x3fcbe4a1,0x3f89a4b0}, + uint32(0xfff80000), + [21]string{"0x3c","0xf6","0x19","0x43","0x69","0xb5","0x9f","0xd7","0x1b","0x13","0xbf","0x21","0xc0","0x28","0xc9","0x50","0xd4","0x49","0xbc","0xa9","0x00"} }, + { + /* No.635 delta:1122 weight:1499 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x572e332c,0x2f6e1d16,0x78402e3a,0x8ea027b5,0xd98e1499,0xa1ce3aa3,0xf6e0098f,0x0000cacb,0x572ef9e7,0x2f6ed7dd,0x7840e4f1,0x8ea0ed7e,0xd98ede52,0xa1cef068,0xf6e0c344}, + [16]uint32{0x00000000,0x301ea87a,0x606af135,0x5074594f,0x006b2509,0x30758d73,0x6001d43c,0x501f7c46,0x00026010,0x301cc86a,0x60689125,0x5076395f,0x00694519,0x3077ed63,0x6003b42c,0x501d1c56}, + [16]uint32{0x3f800000,0x3f980f54,0x3fb03578,0x3fa83a2c,0x3f803592,0x3f983ac6,0x3fb000ea,0x3fa80fbe,0x3f800130,0x3f980e64,0x3fb03448,0x3fa83b1c,0x3f8034a2,0x3f983bf6,0x3fb001da,0x3fa80e8e}, + uint32(0xfff80000), + [21]string{"0x60","0x69","0xd8","0x82","0xcc","0x6f","0xdd","0x11","0xa4","0x9a","0x4c","0x20","0x8b","0xec","0xf9","0x89","0x5a","0x12","0xf1","0xa8","0x00"} }, + { + /* No.636 delta:773 weight:725 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0xb8034d5a,0xda3d4934,0x623e046e,0xe99027cc,0x51936a96,0x33ad6ef8,0x8bae23a2,0x0000dd52,0xb8039008,0xda3d9466,0x623ed93c,0xe990fa9e,0x5193b7c4,0x33adb3aa,0x8baefef0}, + [16]uint32{0x00000000,0x4a449037,0x400110c3,0x0a4580f4,0x4022e19d,0x0a6671aa,0x0023f15e,0x4a676169,0x00501053,0x4a148064,0x40510090,0x0a1590a7,0x4072f1ce,0x0a3661f9,0x0073e10d,0x4a37713a}, + [16]uint32{0x3f800000,0x3fa52248,0x3fa00088,0x3f8522c0,0x3fa01170,0x3f853338,0x3f8011f8,0x3fa533b0,0x3f802808,0x3fa50a40,0x3fa02880,0x3f850ac8,0x3fa03978,0x3f851b30,0x3f8039f0,0x3fa51bb8}, + uint32(0xfff80000), + [21]string{"0xba","0x25","0x13","0xc4","0x8a","0xf6","0xa7","0x55","0x70","0xda","0xf1","0x17","0x77","0x0a","0xb6","0x83","0x4a","0x69","0x45","0x45","0x00"} }, + { + /* No.637 delta:1366 weight:1673 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xcab590cf,0x36b4510d,0xfc01c1c2,0x092027d0,0xc395b71f,0x3f9476dd,0xf521e612,0x00008eca,0xcab51e05,0x36b4dfc7,0xfc014f08,0x0920a91a,0xc39539d5,0x3f94f817,0xf52168d8}, + [16]uint32{0x00000000,0x3030be3a,0x20186835,0x1028d60f,0x002ea366,0x301e1d5c,0x2036cb53,0x10067569,0x0042e071,0x30725e4b,0x205a8844,0x106a367e,0x006c4317,0x305cfd2d,0x20742b22,0x10449518}, + [16]uint32{0x3f800000,0x3f98185f,0x3f900c34,0x3f88146b,0x3f801751,0x3f980f0e,0x3f901b65,0x3f88033a,0x3f802170,0x3f98392f,0x3f902d44,0x3f88351b,0x3f803621,0x3f982e7e,0x3f903a15,0x3f88224a}, + uint32(0xfff80000), + [21]string{"0x3b","0x38","0xc3","0x65","0x23","0xa7","0x44","0xf8","0x5f","0xd8","0xad","0x75","0x16","0x73","0xfc","0x48","0xf6","0x8f","0xfd","0x7e","0x00"} }, + { + /* No.638 delta:736 weight:1685 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x904eccf5,0x728dead9,0xe2c3262c,0x207027ee,0xb03eeb1b,0x52fdcd37,0xc2b301c2,0x0000dbf1,0x904e1704,0x728d3128,0xe2c3fddd,0x2070fc1f,0xb03e30ea,0x52fd16c6,0xc2b3da33}, + [16]uint32{0x00000000,0x800018f6,0x4000e1ac,0xc000f95a,0x00a01772,0x80a00f84,0x40a0f6de,0xc0a0ee28,0x2041810b,0xa04199fd,0x604160a7,0xe0417851,0x20e19679,0xa0e18e8f,0x60e177d5,0xe0e16f23}, + [16]uint32{0x3f800000,0x3fc0000c,0x3fa00070,0x3fe0007c,0x3f80500b,0x3fc05007,0x3fa0507b,0x3fe05077,0x3f9020c0,0x3fd020cc,0x3fb020b0,0x3ff020bc,0x3f9070cb,0x3fd070c7,0x3fb070bb,0x3ff070b7}, + uint32(0xfff80000), + [21]string{"0xfa","0x5e","0xdb","0x80","0xdb","0xe1","0x7e","0x69","0x3b","0xc1","0x34","0x78","0x15","0xc4","0x10","0x22","0x58","0xad","0xfa","0xe2","0x00"} }, + { + /* No.639 delta:800 weight:1301 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x664fa452,0x02335b44,0x647cff16,0x224027f0,0x440f83a2,0x20737cb4,0x463cd8e6,0x000095b6,0x664f31e4,0x0233cef2,0x647c6aa0,0x2240b246,0x440f1614,0x2073e902,0x463c4d50}, + [16]uint32{0x00000000,0x212ed537,0x1024115a,0x310ac46d,0x046461e8,0x254ab4df,0x144070b2,0x356ea585,0x2002459d,0x012c90aa,0x302654c7,0x110881f0,0x24662475,0x0548f142,0x3442352f,0x156ce018}, + [16]uint32{0x3f800000,0x3f90976a,0x3f881208,0x3f988562,0x3f823230,0x3f92a55a,0x3f8a2038,0x3f9ab752,0x3f900122,0x3f809648,0x3f98132a,0x3f888440,0x3f923312,0x3f82a478,0x3f9a211a,0x3f8ab670}, + uint32(0xfff80000), + [21]string{"0x8b","0xfb","0x7a","0xfd","0xa6","0xf3","0x61","0x3e","0x1d","0x73","0x73","0x21","0x1d","0x43","0x27","0x8b","0x5a","0x91","0x90","0xf8","0x00"} }, + { + /* No.640 delta:718 weight:1325 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x4b963850,0xb746833f,0xfcd0bb6f,0xadc02802,0xe6561052,0x1a86ab3d,0x5110936d,0x000056ab,0x4b966efb,0xb746d594,0xfcd0edc4,0xadc07ea9,0xe65646f9,0x1a86fd96,0x5110c5c6}, + [16]uint32{0x00000000,0x020cc8d7,0x804101e9,0x824dc93e,0x007284ab,0x027e4c7c,0x80338542,0x823f4d95,0x000849a7,0x02048170,0x8049484e,0x82458099,0x007acd0c,0x027605db,0x803bcce5,0x82370432}, + [16]uint32{0x3f800000,0x3f810664,0x3fc02080,0x3fc126e4,0x3f803942,0x3f813f26,0x3fc019c2,0x3fc11fa6,0x3f800424,0x3f810240,0x3fc024a4,0x3fc122c0,0x3f803d66,0x3f813b02,0x3fc01de6,0x3fc11b82}, + uint32(0xfff80000), + [21]string{"0xce","0x30","0x15","0x26","0x2c","0x47","0x2d","0x2e","0x6d","0x8d","0xec","0xae","0xbd","0x5c","0x67","0x93","0x37","0x66","0x61","0xd7","0x00"} }, + { + /* No.641 delta:1651 weight:1563 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xb4fd9d64,0xec73539a,0x588ecefe,0x2d802810,0x997db574,0xc1f37b8a,0x750ee6ee,0x0000d3da,0xb4fd4ebe,0xec738040,0x588e1d24,0x2d80fbca,0x997d66ae,0xc1f3a850,0x750e3534}, + [16]uint32{0x00000000,0x0d0ab813,0x00749c0b,0x0d7e2418,0x004ec206,0x0d447a15,0x003a5e0d,0x0d30e61e,0x004bb01a,0x0d410809,0x003f2c11,0x0d359402,0x0005721c,0x0d0fca0f,0x0071ee17,0x0d7b5604}, + [16]uint32{0x3f800000,0x3f86855c,0x3f803a4e,0x3f86bf12,0x3f802761,0x3f86a23d,0x3f801d2f,0x3f869873,0x3f8025d8,0x3f86a084,0x3f801f96,0x3f869aca,0x3f8002b9,0x3f8687e5,0x3f8038f7,0x3f86bdab}, + uint32(0xfff80000), + [21]string{"0x73","0xb5","0x98","0x13","0x31","0x72","0x05","0x95","0x46","0xd3","0xed","0x36","0xc7","0xec","0xc3","0xfb","0x0d","0x08","0x23","0x80","0x00"} }, + { + /* No.642 delta:2155 weight:1317 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x21d93e20,0x54e726bc,0x753e189c,0xf7502822,0xd6891602,0xa3b70e9e,0x826e30be,0x00005fc4,0x21d961e4,0x54e77978,0x753e4758,0xf75077e6,0xd68949c6,0xa3b7515a,0x826e6f7a}, + [16]uint32{0x00000000,0x0eda5135,0x0cc2440b,0x0218153e,0x2480c096,0x2a5a91a3,0x2842849d,0x2698d5a8,0x5ea4a612,0x507ef727,0x5266e219,0x5cbcb32c,0x7a246684,0x74fe37b1,0x76e6228f,0x783c73ba}, + [16]uint32{0x3f800000,0x3f876d28,0x3f866122,0x3f810c0a,0x3f924060,0x3f952d48,0x3f942142,0x3f934c6a,0x3faf5253,0x3fa83f7b,0x3fa93371,0x3fae5e59,0x3fbd1233,0x3fba7f1b,0x3fbb7311,0x3fbc1e39}, + uint32(0xfff80000), + [21]string{"0xee","0x5c","0x37","0x5e","0xb0","0x4a","0x6b","0x44","0xd4","0xc7","0x6a","0xac","0x2b","0xa5","0x44","0x49","0x39","0x04","0x9b","0x17","0x00"} }, + { + /* No.643 delta:975 weight:1667 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0xf1e0960f,0x045f6783,0xf5bff18c,0xcd502833,0x3cb0be3c,0xc90f4fb0,0x38efd9bf,0x00009e6a,0xf1e00865,0x045ff9e9,0xf5bf6fe6,0xcd50b659,0x3cb02056,0xc90fd1da,0x38ef47d5}, + [16]uint32{0x00000000,0x100cc07a,0x40060111,0x500ac16b,0x2050900c,0x305c5076,0x6056911d,0x705a5167,0x00020018,0x100ec062,0x40040109,0x5008c173,0x20529014,0x305e506e,0x60549105,0x7058517f}, + [16]uint32{0x3f800000,0x3f880660,0x3fa00300,0x3fa80560,0x3f902848,0x3f982e28,0x3fb02b48,0x3fb82d28,0x3f800100,0x3f880760,0x3fa00200,0x3fa80460,0x3f902948,0x3f982f28,0x3fb02a48,0x3fb82c28}, + uint32(0xfff80000), + [21]string{"0x96","0x37","0xd1","0xe7","0x6f","0x2b","0xd4","0x49","0xf8","0xff","0x12","0x3e","0xf6","0xd0","0xd8","0x5b","0x3d","0x6a","0xd7","0xa9","0x00"} }, + { + /* No.644 delta:903 weight:1567 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0x4f8925e6,0x52376c1d,0x1dbe49fb,0xa8d02842,0xe7590da4,0xfae7445f,0xb56e61b9,0x0000a095,0x4f898573,0x5237cc88,0x1dbee96e,0xa8d088d7,0xe759ad31,0xfae7e4ca,0xb56ec12c}, + [16]uint32{0x00000000,0x305c2915,0x0003497f,0x305f606a,0x00202013,0x307c0906,0x0023696c,0x307f4079,0x10003178,0x205c186d,0x10037807,0x205f5112,0x1020116b,0x207c387e,0x10235814,0x207f7101}, + [16]uint32{0x3f800000,0x3f982e14,0x3f8001a4,0x3f982fb0,0x3f801010,0x3f983e04,0x3f8011b4,0x3f983fa0,0x3f880018,0x3f902e0c,0x3f8801bc,0x3f902fa8,0x3f881008,0x3f903e1c,0x3f8811ac,0x3f903fb8}, + uint32(0xfff80000), + [21]string{"0xe3","0xec","0xd0","0x30","0x6e","0x1e","0x46","0xae","0x73","0xa6","0xf8","0xfc","0xd7","0x99","0xe0","0x67","0xe0","0x2d","0xc8","0x47","0x00"} }, + { + /* No.645 delta:660 weight:1647 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x625a8fef,0x5bb5921d,0x39ef1df2,0x64b02850,0x06eaa7bf,0x3f05ba4d,0x5d5f35a2,0x0000f31f,0x625a7cf0,0x5bb56102,0x39efeeed,0x64b0db4f,0x06ea54a0,0x3f054952,0x5d5fc6bd}, + [16]uint32{0x00000000,0x00441976,0x30039014,0x30478962,0x0002c20e,0x0046db78,0x3001521a,0x30454b6c,0x60221261,0x60660b17,0x50218275,0x50659b03,0x6020d06f,0x6064c919,0x5023407b,0x5067590d}, + [16]uint32{0x3f800000,0x3f80220c,0x3f9801c8,0x3f9823c4,0x3f800161,0x3f80236d,0x3f9800a9,0x3f9822a5,0x3fb01109,0x3fb03305,0x3fa810c1,0x3fa832cd,0x3fb01068,0x3fb03264,0x3fa811a0,0x3fa833ac}, + uint32(0xfff80000), + [21]string{"0xc1","0xa3","0x7d","0xf7","0x5d","0x61","0x9a","0x92","0xc2","0xd3","0x05","0x6e","0x90","0xdf","0x06","0xd1","0x8b","0x17","0xcc","0xc8","0x00"} }, + { + /* No.646 delta:932 weight:1495 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0xc783558b,0x053e9e10,0xc2bdcb9b,0xaba0286d,0x6c237de6,0xae9eb67d,0x691de3f6,0x00009934,0xc783ccbf,0x053e0724,0xc2bd52af,0xaba0b159,0x6c23e4d2,0xae9e2f49,0x691d7ac2}, + [16]uint32{0x00000000,0x000219dd,0x30040927,0x300610fa,0x401c001e,0x401e19c3,0x70180939,0x701a10e4,0x2048002b,0x204a19f6,0x104c090c,0x104e10d1,0x60540035,0x605619e8,0x50500912,0x505210cf}, + [16]uint32{0x3f800000,0x3f80010c,0x3f980204,0x3f980308,0x3fa00e00,0x3fa00f0c,0x3fb80c04,0x3fb80d08,0x3f902400,0x3f90250c,0x3f882604,0x3f882708,0x3fb02a00,0x3fb02b0c,0x3fa82804,0x3fa82908}, + uint32(0xfff80000), + [21]string{"0xb6","0xe6","0xae","0xba","0xb1","0xbd","0x85","0x3f","0x35","0x93","0xd3","0x77","0xc4","0xaf","0xc4","0x3f","0x63","0x88","0x7a","0x06","0x00"} }, + { + /* No.647 delta:1009 weight:1587 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0xaef5cae8,0xda0274b0,0x74f7be58,0x5b802872,0xf575e29a,0x81825cc2,0x2f77962a,0x0000b3f0,0xaef57918,0xda02c740,0x74f70da8,0x5b809b82,0xf575516a,0x8182ef32,0x2f7725da}, + [16]uint32{0x00000000,0x0002f95d,0x00034012,0x0001b94f,0x005c0144,0x005ef819,0x005f4156,0x005db80b,0x20081168,0x200ae835,0x200b517a,0x2009a827,0x2054102c,0x2056e971,0x2057503e,0x2055a963}, + [16]uint32{0x3f800000,0x3f80017c,0x3f8001a0,0x3f8000dc,0x3f802e00,0x3f802f7c,0x3f802fa0,0x3f802edc,0x3f900408,0x3f900574,0x3f9005a8,0x3f9004d4,0x3f902a08,0x3f902b74,0x3f902ba8,0x3f902ad4}, + uint32(0xfff80000), + [21]string{"0x95","0x71","0x09","0xed","0xeb","0x65","0x00","0x8e","0x3b","0x18","0xf8","0x93","0x84","0x59","0xc4","0x30","0x88","0xae","0x07","0x9c","0x00"} }, + { + /* No.648 delta:989 weight:1267 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x885ac586,0x39862d71,0xb1dce8f7,0x56d0288b,0xde8aed0d,0x6f5605fa,0xe70cc07c,0x00008ef1,0x885a4b77,0x3986a380,0xb1dc6606,0x56d0a67a,0xde8a63fc,0x6f568b0b,0xe70c4e8d}, + [16]uint32{0x00000000,0x31a6e852,0x0065313c,0x31c3d96e,0x000471f1,0x31a299a3,0x006140cd,0x31c7a89f,0x0003915e,0x31a5790c,0x0066a062,0x31c04830,0x0007e0af,0x31a108fd,0x0062d193,0x31c439c1}, + [16]uint32{0x3f800000,0x3f98d374,0x3f803298,0x3f98e1ec,0x3f800238,0x3f98d14c,0x3f8030a0,0x3f98e3d4,0x3f8001c8,0x3f98d2bc,0x3f803350,0x3f98e024,0x3f8003f0,0x3f98d084,0x3f803168,0x3f98e21c}, + uint32(0xfff80000), + [21]string{"0x4e","0x28","0x4c","0x03","0x8c","0x28","0x0d","0x68","0x02","0x09","0xab","0x02","0xe9","0xe7","0xe0","0xc3","0x21","0x8d","0xac","0xff","0x00"} }, + { + /* No.649 delta:576 weight:1629 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0xc2f9536b,0x29a16a0c,0xeb583967,0xc8702895,0x0a897bfe,0xe1d14299,0x232811f2,0x0000f870,0xc2f9ab1b,0x29a1927c,0xeb58c117,0xc870d0e5,0x0a89838e,0xe1d1bae9,0x2328e982}, + [16]uint32{0x00000000,0x80000413,0x5003cbcc,0xd003cfdf,0x30002018,0xb000240b,0x6003ebd4,0xe003efc7,0x2002200d,0xa002241e,0x7001ebc1,0xf001efd2,0x10020015,0x90020406,0x4001cbd9,0xc001cfca}, + [16]uint32{0x3f800000,0x3fc00002,0x3fa801e5,0x3fe801e7,0x3f980010,0x3fd80012,0x3fb001f5,0x3ff001f7,0x3f900110,0x3fd00112,0x3fb800f5,0x3ff800f7,0x3f880100,0x3fc80102,0x3fa000e5,0x3fe000e7}, + uint32(0xfff80000), + [21]string{"0x2d","0xff","0x0e","0xbc","0x3a","0x59","0x06","0x5c","0x5c","0xd8","0x67","0xc4","0xc0","0xbe","0x3f","0x92","0xd7","0x2b","0x36","0xaf","0x00"} }, + { + /* No.650 delta:942 weight:1667 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x6ce07665,0x165ee1ef,0x7abe978a,0x70f028a1,0x1c105ec4,0x66aec94e,0x0a4ebf2b,0x000061cf,0x6ce017aa,0x165e8020,0x7abef645,0x70f0496e,0x1c103f0b,0x66aea881,0x0a4edee4}, + [16]uint32{0x00000000,0x0066a016,0x0038fc14,0x005e5c02,0x501c160e,0x507ab618,0x5024ea1a,0x50424a0c,0x0010b807,0x00761811,0x00284413,0x004ee405,0x500cae09,0x506a0e1f,0x5034521d,0x5052f20b}, + [16]uint32{0x3f800000,0x3f803350,0x3f801c7e,0x3f802f2e,0x3fa80e0b,0x3fa83d5b,0x3fa81275,0x3fa82125,0x3f80085c,0x3f803b0c,0x3f801422,0x3f802772,0x3fa80657,0x3fa83507,0x3fa81a29,0x3fa82979}, + uint32(0xfff80000), + [21]string{"0xe2","0x43","0x36","0xd5","0x2d","0x13","0xee","0xbc","0x6f","0x79","0x79","0xde","0xe3","0xc4","0xb0","0x01","0xcc","0xc8","0x8c","0xf7","0x00"} }, + { + /* No.651 delta:2187 weight:1665 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xda5afb70,0x042345ef,0xde79be9f,0x4f6028b0,0x953ad3c0,0x4b436d5f,0x9119962f,0x0000b486,0xda5a4ff6,0x0423f169,0xde790a19,0x4f609c36,0x953a6746,0x4b43d9d9,0x911922a9}, + [16]uint32{0x00000000,0x4cad00d2,0x005e8149,0x4cf3819b,0x0050001a,0x4cfd00c8,0x000e8153,0x4ca38181,0x00400047,0x4ced0095,0x001e810e,0x4cb381dc,0x0010005d,0x4cbd008f,0x004e8114,0x4ce381c6}, + [16]uint32{0x3f800000,0x3fa65680,0x3f802f40,0x3fa679c0,0x3f802800,0x3fa67e80,0x3f800740,0x3fa651c0,0x3f802000,0x3fa67680,0x3f800f40,0x3fa659c0,0x3f800800,0x3fa65e80,0x3f802740,0x3fa671c0}, + uint32(0xfff80000), + [21]string{"0xf2","0x3d","0x63","0xaf","0x71","0x99","0x36","0xb4","0x61","0x70","0x83","0xf3","0x18","0xe4","0x2c","0xe5","0x4e","0x03","0x14","0x71","0x00"} }, + { + /* No.652 delta:964 weight:1539 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0xb7d60312,0xff1ee9fa,0x48c8eae8,0x887028c1,0x3fa62bd3,0x776ec13b,0xc0b8c229,0x000029b4,0xb7d62aa6,0xff1ec04e,0x48c8c35c,0x88700175,0x3fa60267,0x776ee88f,0xc0b8eb9d}, + [16]uint32{0x00000000,0x301e0036,0x00491011,0x30571027,0x0003641e,0x301d6428,0x004a740f,0x30547439,0x400ce01b,0x7012e02d,0x4045f00a,0x705bf03c,0x400f8405,0x70118433,0x40469414,0x70589422}, + [16]uint32{0x3f800000,0x3f980f00,0x3f802488,0x3f982b88,0x3f8001b2,0x3f980eb2,0x3f80253a,0x3f982a3a,0x3fa00670,0x3fb80970,0x3fa022f8,0x3fb82df8,0x3fa007c2,0x3fb808c2,0x3fa0234a,0x3fb82c4a}, + uint32(0xfff80000), + [21]string{"0xf5","0x91","0x72","0x0b","0xa3","0xea","0xc7","0x14","0x81","0xed","0x6c","0x30","0x33","0xc2","0x97","0x83","0x7d","0xcf","0x05","0x42","0x00"} }, + { + /* No.653 delta:3098 weight:643 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xddc0adac,0x43b11700,0x9e71baac,0xa22028d0,0x7fe0857c,0xe1913fd0,0x3c51927c,0x00006e8b,0xddc0c327,0x43b1798b,0x9e71d427,0xa220465b,0x7fe0ebf7,0xe191515b,0x3c51fcf7}, + [16]uint32{0x00000000,0x9000591f,0x88204611,0x18201f0e,0x05282016,0x95287909,0x8d086607,0x1d083f18,0x0cd0200c,0x9cd07913,0x84f0661d,0x14f03f02,0x09f8001a,0x99f85905,0x81d8460b,0x11d81f14}, + [16]uint32{0x3f800000,0x3fc8002c,0x3fc41023,0x3f8c100f,0x3f829410,0x3fca943c,0x3fc68433,0x3f8e841f,0x3f866810,0x3fce683c,0x3fc27833,0x3f8a781f,0x3f84fc00,0x3fccfc2c,0x3fc0ec23,0x3f88ec0f}, + uint32(0xfff80000), + [21]string{"0xce","0x2e","0xc1","0x55","0xbb","0x0d","0x5b","0x60","0x82","0xb4","0x3b","0x1f","0x8c","0xa4","0xe4","0xe6","0x12","0x61","0xa8","0x02","0x00"} }, + { + /* No.654 delta:660 weight:1559 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x372ceb15,0x20eeabe4,0x17c240f1,0x9b6028ed,0xac4cc3f8,0xbb8e8309,0x8ca2681c,0x0000a396,0x372c4883,0x20ee0872,0x17c2e367,0x9b608b7b,0xac4c606e,0xbb8e209f,0x8ca2cb8a}, + [16]uint32{0x00000000,0x180349d3,0x5002d0cc,0x4801991f,0x4000f186,0x5803b855,0x1002214a,0x08016899,0x3001c01d,0x280289ce,0x600310d1,0x78005902,0x7001319b,0x68027848,0x2003e157,0x3800a884}, + [16]uint32{0x3f800000,0x3f8c01a4,0x3fa80168,0x3fa400cc,0x3fa00078,0x3fac01dc,0x3f880110,0x3f8400b4,0x3f9800e0,0x3f940144,0x3fb00188,0x3fbc002c,0x3fb80098,0x3fb4013c,0x3f9001f0,0x3f9c0054}, + uint32(0xfff80000), + [21]string{"0x1a","0xac","0xaf","0x2f","0x31","0xd0","0x9e","0xf0","0xdb","0x32","0x7a","0xe2","0xa0","0x62","0xa9","0x42","0x6c","0xc9","0x3a","0xf4","0x00"} }, + { + /* No.655 delta:984 weight:735 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x9f8eb19b,0x006f0f4f,0x9fe1bed4,0x60f028fa,0xff7e9961,0x609f27b5,0xff11962e,0x0000f0f7,0x9f8e416c,0x006fffb8,0x9fe14e23,0x60f0d80d,0xff7e6996,0x609fd742,0xff1166d9}, + [16]uint32{0x00000000,0x002081b7,0x400590ca,0x4025117d,0x21034012,0x2123c1a5,0x6106d0d8,0x6126516f,0x00481008,0x006891bf,0x404d80c2,0x406d0175,0x214b501a,0x216bd1ad,0x614ec0d0,0x616e4167}, + [16]uint32{0x3f800000,0x3f801040,0x3fa002c8,0x3fa01288,0x3f9081a0,0x3f9091e0,0x3fb08368,0x3fb09328,0x3f802408,0x3f803448,0x3fa026c0,0x3fa03680,0x3f90a5a8,0x3f90b5e8,0x3fb0a760,0x3fb0b720}, + uint32(0xfff80000), + [21]string{"0x30","0xed","0x78","0x6c","0x1c","0x63","0x46","0xc8","0x3c","0x32","0xe8","0xf0","0x13","0xc4","0x0c","0x4b","0x2c","0x4a","0xcb","0x65","0x00"} }, + { + /* No.656 delta:1139 weight:1193 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0xddeeaede,0xa05f5e68,0x7db1f0b6,0x08002902,0xd5ee87dc,0xa85f776a,0x75b1d9b4,0x00000b50,0xddeea58e,0xa05f5538,0x7db1fbe6,0x08002252,0xd5ee8c8c,0xa85f7c3a,0x75b1d2e4}, + [16]uint32{0x00000000,0x00307875,0xc90110d2,0xc93168a7,0x0041518a,0x007129ff,0xc9404158,0xc970392d,0x000cc809,0x003cb07c,0xc90dd8db,0xc93da0ae,0x004d9983,0x007de1f6,0xc94c8951,0xc97cf124}, + [16]uint32{0x3f800000,0x3f80183c,0x3fe48088,0x3fe498b4,0x3f8020a8,0x3f803894,0x3fe4a020,0x3fe4b81c,0x3f800664,0x3f801e58,0x3fe486ec,0x3fe49ed0,0x3f8026cc,0x3f803ef0,0x3fe4a644,0x3fe4be78}, + uint32(0xfff80000), + [21]string{"0xde","0xd5","0x71","0xd5","0xd3","0x9c","0x67","0xe4","0x79","0xfd","0x5d","0xdd","0x42","0xaf","0xb9","0xeb","0x68","0x2f","0x52","0x80","0x00"} }, + { + /* No.657 delta:905 weight:1507 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x96993115,0xbb4b4097,0x2dd27182,0x0f202916,0x99b91803,0xb46b6981,0x22f25894,0x0000b8b4,0x969989a1,0xbb4bf823,0x2dd2c936,0x0f2091a2,0x99b9a0b7,0xb46bd135,0x22f2e020}, + [16]uint32{0x00000000,0x200348dd,0x000010c6,0x2003581b,0x7000b035,0x5003f8e8,0x7000a0f3,0x5003e82e,0x6000883f,0x4003c0e2,0x600098f9,0x4003d024,0x1000380a,0x300370d7,0x100028cc,0x30036011}, + [16]uint32{0x3f800000,0x3f9001a4,0x3f800008,0x3f9001ac,0x3fb80058,0x3fa801fc,0x3fb80050,0x3fa801f4,0x3fb00044,0x3fa001e0,0x3fb0004c,0x3fa001e8,0x3f88001c,0x3f9801b8,0x3f880014,0x3f9801b0}, + uint32(0xfff80000), + [21]string{"0x65","0xc7","0xa1","0x6f","0x11","0x9d","0x93","0x0d","0xf2","0x32","0xc9","0xa0","0x27","0x91","0x8a","0x29","0xf1","0x8f","0x9c","0x5f","0x00"} }, + { + /* No.658 delta:1013 weight:1233 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x509efe05,0x36821f44,0x661ce141,0xa9f0292f,0xf96ed72a,0x9f72366b,0xcfecc86e,0x00005040,0x509eae45,0x36824f04,0x661cb101,0xa9f0796f,0xf96e876a,0x9f72662b,0xcfec982e}, + [16]uint32{0x00000000,0x501f113f,0x00001869,0x501f0956,0x4000c011,0x101fd12e,0x4000d878,0x101fc947,0x10303c1a,0x402f2d25,0x10302473,0x402f354c,0x5030fc0b,0x002fed34,0x5030e462,0x002ff55d}, + [16]uint32{0x3f800000,0x3fa80f88,0x3f80000c,0x3fa80f84,0x3fa00060,0x3f880fe8,0x3fa0006c,0x3f880fe4,0x3f88181e,0x3fa01796,0x3f881812,0x3fa0179a,0x3fa8187e,0x3f8017f6,0x3fa81872,0x3f8017fa}, + uint32(0xfff80000), + [21]string{"0x0f","0x8f","0x4d","0x73","0x21","0x87","0xd2","0xc5","0x92","0x87","0x30","0x8a","0x4e","0xc7","0xe2","0x40","0xa3","0xd9","0xde","0x44","0x00"} }, + { + /* No.659 delta:766 weight:1541 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x1de8985e,0x622465ba,0x7fccfde4,0x8bf0293a,0x9618b164,0xe9d44c80,0xf43cd4de,0x00002c85,0x1de8b4db,0x6224493f,0x7fccd161,0x8bf005bf,0x96189de1,0xe9d46005,0xf43cf85b}, + [16]uint32{0x00000000,0x3027b1d7,0x006d24b5,0x304a9562,0x0001c50b,0x302674dc,0x006ce1be,0x304b5069,0x20000012,0x1027b1c5,0x206d24a7,0x104a9570,0x2001c519,0x102674ce,0x206ce1ac,0x104b507b}, + [16]uint32{0x3f800000,0x3f9813d8,0x3f803692,0x3f98254a,0x3f8000e2,0x3f98133a,0x3f803670,0x3f9825a8,0x3f900000,0x3f8813d8,0x3f903692,0x3f88254a,0x3f9000e2,0x3f88133a,0x3f903670,0x3f8825a8}, + uint32(0xfff80000), + [21]string{"0x19","0x49","0xd4","0x55","0x84","0x35","0xd9","0xd8","0x47","0x87","0xf4","0xd3","0x8b","0xac","0x7d","0x8e","0x59","0xf8","0x1c","0x97","0x00"} }, + { + /* No.660 delta:1168 weight:1519 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0xb4156412,0xcdb16655,0x79a40247,0x7cc02946,0xc8d54d54,0xb1714f13,0x05642b01,0x00001e30,0xb4157a22,0xcdb17865,0x79a41c77,0x7cc03776,0xc8d55364,0xb1715123,0x05643531}, + [16]uint32{0x00000000,0x506e89d4,0x2041b10b,0x702f38df,0x004810a2,0x50269976,0x2009a1a9,0x7067287d,0xb2085803,0xe266d1d7,0x9249e908,0xc22760dc,0xb24048a1,0xe22ec175,0x9201f9aa,0xc26f707e}, + [16]uint32{0x3f800000,0x3fa83744,0x3f9020d8,0x3fb8179c,0x3f802408,0x3fa8134c,0x3f9004d0,0x3fb83394,0x3fd9042c,0x3ff13368,0x3fc924f4,0x3fe113b0,0x3fd92024,0x3ff11760,0x3fc900fc,0x3fe137b8}, + uint32(0xfff80000), + [21]string{"0x39","0xed","0x0f","0x14","0x6c","0xe6","0xa8","0x2e","0x15","0x38","0xc1","0x5c","0xd2","0xef","0x93","0xf3","0xfe","0x7e","0x53","0x31","0x00"} }, + { + /* No.661 delta:917 weight:1167 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x8c4f0872,0x9593001b,0x19dc0869,0xd5802959,0x59cf212b,0x40132942,0xcc5c2130,0x0000e44a,0x8c4fec38,0x9593e451,0x19dcec23,0xd580cd13,0x59cfc561,0x4013cd08,0xcc5cc57a}, + [16]uint32{0x00000000,0x007e01fe,0x00203097,0x005e3169,0x3003004f,0x307d01b1,0x302330d8,0x305d3126,0x20028175,0x207c808b,0x2022b1e2,0x205cb01c,0x1001813a,0x107f80c4,0x1021b1ad,0x105fb053}, + [16]uint32{0x3f800000,0x3f803f00,0x3f801018,0x3f802f18,0x3f980180,0x3f983e80,0x3f981198,0x3f982e98,0x3f900140,0x3f903e40,0x3f901158,0x3f902e58,0x3f8800c0,0x3f883fc0,0x3f8810d8,0x3f882fd8}, + uint32(0xfff80000), + [21]string{"0x88","0x25","0x1a","0x00","0xae","0xf6","0xae","0x7b","0x20","0x83","0x3a","0x7b","0xd5","0x0b","0x23","0x81","0x82","0x42","0x0b","0x76","0x00"} }, + { + /* No.662 delta:955 weight:1471 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0xbc2bba97,0x62750fb7,0xde5eb520,0xfc102960,0x403b93f7,0x9e6526d7,0x224e9c40,0x00000e67,0xbc2bb4f0,0x627501d0,0xde5ebb47,0xfc102707,0x403b9d90,0x9e6528b0,0x224e9227}, + [16]uint32{0x00000000,0x88820612,0x0021d95e,0x88a3df4c,0x01023073,0x89803661,0x0123e92d,0x89a1ef3f,0x0003801c,0x8881860e,0x00225942,0x88a05f50,0x0101b06f,0x8983b67d,0x01206931,0x89a26f23}, + [16]uint32{0x3f800000,0x3fc44103,0x3f8010ec,0x3fc451ef,0x3f808118,0x3fc4c01b,0x3f8091f4,0x3fc4d0f7,0x3f8001c0,0x3fc440c3,0x3f80112c,0x3fc4502f,0x3f8080d8,0x3fc4c1db,0x3f809034,0x3fc4d137}, + uint32(0xfff80000), + [21]string{"0x63","0x09","0x9e","0x71","0xa3","0x44","0xd4","0x07","0x19","0x81","0x02","0x07","0x55","0x45","0x71","0x4d","0xfb","0x33","0x63","0x5a","0x00"} }, + { + /* No.663 delta:890 weight:1707 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x1f16f5e5,0xa734a9c3,0xb8225c26,0x37102979,0x2806dc9c,0x902480ba,0x8f32755f,0x00002f8b,0x1f16da6e,0xa7348648,0xb82273ad,0x371006f2,0x2806f317,0x9024af31,0x8f325ad4}, + [16]uint32{0x00000000,0x00010dba,0x087c2195,0x087d2c2f,0x60168012,0x60178da8,0x686aa187,0x686bac3d,0x4000004b,0x40010df1,0x487c21de,0x487d2c64,0x20168059,0x20178de3,0x286aa1cc,0x286bac76}, + [16]uint32{0x3f800000,0x3f800086,0x3f843e10,0x3f843e96,0x3fb00b40,0x3fb00bc6,0x3fb43550,0x3fb435d6,0x3fa00000,0x3fa00086,0x3fa43e10,0x3fa43e96,0x3f900b40,0x3f900bc6,0x3f943550,0x3f9435d6}, + uint32(0xfff80000), + [21]string{"0x6f","0x1e","0x41","0x32","0x63","0xd9","0xf9","0x94","0x8d","0x6d","0x44","0xb6","0x9f","0x43","0xb1","0x51","0x16","0x2d","0x37","0xd9","0x00"} }, + { + /* No.664 delta:667 weight:953 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0x654dce22,0x52a6d3bb,0x37eb1d99,0x6880298a,0x0dcde7a8,0x3a26fa31,0x5f6b3413,0x0000e7f9,0x654d29db,0x52a63442,0x37ebfa60,0x6880ce73,0x0dcd0051,0x3a261dc8,0x5f6bd3ea}, + [16]uint32{0x00000000,0x006e8135,0x480701a7,0x48698092,0x2018241a,0x2076a52f,0x681f25bd,0x6871a488,0x004a55d1,0x0024d4e4,0x484d5476,0x4823d543,0x205271cb,0x203cf0fe,0x6855706c,0x683bf159}, + [16]uint32{0x3f800000,0x3f803740,0x3fa40380,0x3fa434c0,0x3f900c12,0x3f903b52,0x3fb40f92,0x3fb438d2,0x3f80252a,0x3f80126a,0x3fa426aa,0x3fa411ea,0x3f902938,0x3f901e78,0x3fb42ab8,0x3fb41df8}, + uint32(0xfff80000), + [21]string{"0x85","0x3c","0x97","0x24","0x6e","0x85","0xd2","0xd6","0x08","0xf0","0x79","0x88","0xdb","0x11","0xd1","0x92","0xb0","0x34","0xaf","0xa9","0x00"} }, + { + /* No.665 delta:889 weight:1549 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x15a89dc0,0xdb3e289d,0xce96b55d,0xe660299d,0xf3c8b45d,0x3d5e0100,0x28f69cc0,0x00000834,0x15a895f4,0xdb3e20a9,0xce96bd69,0xe66021a9,0xf3c8bc69,0x3d5e0934,0x28f694f4}, + [16]uint32{0x00000000,0x3016f1de,0x000130cd,0x3017c113,0x5400a711,0x641656cf,0x540197dc,0x64176602,0x7000601b,0x401691c5,0x700150d6,0x4017a108,0x2400c70a,0x141636d4,0x2401f7c7,0x14170619}, + [16]uint32{0x3f800000,0x3f980b78,0x3f800098,0x3f980be0,0x3faa0053,0x3fb20b2b,0x3faa00cb,0x3fb20bb3,0x3fb80030,0x3fa00b48,0x3fb800a8,0x3fa00bd0,0x3f920063,0x3f8a0b1b,0x3f9200fb,0x3f8a0b83}, + uint32(0xfff80000), + [21]string{"0xa3","0x7f","0x49","0x35","0xd4","0xfe","0xce","0x04","0x1c","0x43","0x24","0x63","0xce","0x91","0xbf","0x69","0x54","0xd7","0xb1","0xf6","0x00"} }, + { + /* No.666 delta:2284 weight:1263 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x6a113d56,0xb7ea0d41,0xddfb3017,0xda4029ad,0xb05114fb,0x6daa24ec,0x07bb19ba,0x000061d0,0x6a115c86,0xb7ea6c91,0xddfb51c7,0xda40487d,0xb051752b,0x6daa453c,0x07bb786a}, + [16]uint32{0x00000000,0xc682109e,0x670701b9,0xa1851127,0x0ef8420d,0xc87a5293,0x69ff43b4,0xaf7d532a,0x1220202b,0xd4a230b5,0x75272192,0xb3a5310c,0x1cd86226,0xda5a72b8,0x7bdf639f,0xbd5d7301}, + [16]uint32{0x3f800000,0x3fe34108,0x3fb38380,0x3fd0c288,0x3f877c21,0x3fe43d29,0x3fb4ffa1,0x3fd7bea9,0x3f891010,0x3fea5118,0x3fba9390,0x3fd9d298,0x3f8e6c31,0x3fed2d39,0x3fbdefb1,0x3fdeaeb9}, + uint32(0xfff80000), + [21]string{"0x90","0x08","0xd5","0xc8","0xe3","0x3e","0x63","0xa1","0x3d","0x14","0x5b","0x05","0x5a","0x8f","0xd6","0x2d","0x14","0xd5","0x16","0xe6","0x00"} }, + { + /* No.667 delta:2054 weight:1275 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x47a1ad9a,0x419246d3,0x0633eb49,0x45f029b7,0x0251842d,0x04626f64,0x43c3c2fe,0x000025c4,0x47a1885e,0x41926317,0x0633ce8d,0x45f00c73,0x0251a1e9,0x04624aa0,0x43c3e73a}, + [16]uint32{0x00000000,0x1c034276,0x12e081f1,0x0ee3c387,0x2c509004,0x3053d272,0x3eb011f5,0x22b35383,0xc810001e,0xd4134268,0xdaf081ef,0xc6f3c399,0xe440901a,0xf843d26c,0xf6a011eb,0xeaa3539d}, + [16]uint32{0x3f800000,0x3f8e01a1,0x3f897040,0x3f8771e1,0x3f962848,0x3f9829e9,0x3f9f5808,0x3f9159a9,0x3fe40800,0x3fea09a1,0x3fed7840,0x3fe379e1,0x3ff22048,0x3ffc21e9,0x3ffb5008,0x3ff551a9}, + uint32(0xfff80000), + [21]string{"0x67","0x18","0x91","0xb1","0x28","0xa9","0x45","0xb6","0x69","0x1a","0xdb","0xea","0x65","0xf2","0x13","0x57","0x3c","0xfc","0x49","0x49","0x00"} }, + { + /* No.668 delta:941 weight:1633 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0x9baafc80,0x463c2adb,0xdd96d65b,0x4a3029c8,0xd19ad548,0x0c0c0313,0x97a6ff93,0x0000982b,0x9baa64ab,0x463cb2f0,0xdd964e70,0x4a30b1e3,0xd19a4d63,0x0c0c9b38,0x97a667b8}, + [16]uint32{0x00000000,0x206701be,0x4000a145,0x6067a0fb,0x2002301c,0x006531a2,0x60029159,0x406590e7,0x000040ef,0x20674151,0x4000e1aa,0x6067e014,0x200270f3,0x0065714d,0x6002d1b6,0x4065d008}, + [16]uint32{0x3f800000,0x3f903380,0x3fa00050,0x3fb033d0,0x3f900118,0x3f803298,0x3fb00148,0x3fa032c8,0x3f800020,0x3f9033a0,0x3fa00070,0x3fb033f0,0x3f900138,0x3f8032b8,0x3fb00168,0x3fa032e8}, + uint32(0xfff80000), + [21]string{"0x71","0x9b","0x16","0x1e","0x4d","0x5f","0x94","0xdd","0x57","0x62","0x07","0x20","0xda","0x27","0xf7","0x26","0xc6","0xe1","0x5c","0xc3","0x00"} }, + { + /* No.669 delta:1197 weight:1565 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0x7653274c,0x9a0ee346,0xec5dc40a,0x431029de,0x35430e92,0xd91eca98,0xaf4dedd4,0x0000a6ae,0x765381e2,0x9a0e45e8,0xec5d62a4,0x43108f70,0x3543a83c,0xd91e6c36,0xaf4d4b7a}, + [16]uint32{0x00000000,0x08004135,0x0401021c,0x0c014329,0x01000307,0x09004232,0x0501011b,0x0d01402e,0x600000ec,0x680041d9,0x640102f0,0x6c0143c5,0x610003eb,0x690042de,0x650101f7,0x6d0140c2}, + [16]uint32{0x3f800000,0x3f840020,0x3f820081,0x3f8600a1,0x3f808001,0x3f848021,0x3f828080,0x3f8680a0,0x3fb00000,0x3fb40020,0x3fb20081,0x3fb600a1,0x3fb08001,0x3fb48021,0x3fb28080,0x3fb680a0}, + uint32(0xfff80000), + [21]string{"0xa0","0x20","0xee","0x1b","0xe5","0x22","0xee","0x71","0xdc","0xfa","0xaa","0xbc","0x75","0xe0","0x1b","0x8d","0xa7","0x69","0x9d","0x44","0x00"} }, + { + /* No.670 delta:2148 weight:1399 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x539e5b65,0x8cf33dac,0xdf6d66c9,0x7fd029e8,0x2c4e728d,0xf3231444,0xa0bd4f21,0x00003083,0x539e6be6,0x8cf30d2f,0xdf6d564a,0x7fd0196b,0x2c4e420e,0xf32324c7,0xa0bd7fa2}, + [16]uint32{0x00000000,0x49912d53,0x0c0141d9,0x45906c8a,0x03808814,0x4a11a547,0x0f81c9cd,0x4610e49e,0x1aa44202,0x53356f51,0x16a503db,0x5f342e88,0x1924ca16,0x50b5e745,0x15258bcf,0x5cb4a69c}, + [16]uint32{0x3f800000,0x3fa4c896,0x3f8600a0,0x3fa2c836,0x3f81c044,0x3fa508d2,0x3f87c0e4,0x3fa30872,0x3f8d5221,0x3fa99ab7,0x3f8b5281,0x3faf9a17,0x3f8c9265,0x3fa85af3,0x3f8a92c5,0x3fae5a53}, + uint32(0xfff80000), + [21]string{"0xa6","0x6a","0x76","0x3a","0x31","0x11","0x47","0x0f","0xce","0x1c","0x53","0xdc","0xa5","0x33","0x08","0x6e","0x53","0xd0","0xaa","0x59","0x00"} }, + { + /* No.671 delta:762 weight:1521 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x0ca76d20,0xeb183a1f,0xe7bf573f,0x2a9029f3,0x263744d3,0xc18813ec,0xcd2f7ecc,0x00005eb0,0x0ca73390,0xeb1864af,0xe7bf098f,0x2a907743,0x26371a63,0xc1884d5c,0xcd2f207c}, + [16]uint32{0x00000000,0x08648995,0x30024156,0x3866c8c3,0x0002812e,0x086608bb,0x3000c078,0x386449ed,0x19172819,0x1173a18c,0x2915694f,0x2171e0da,0x1915a937,0x117120a2,0x2917e861,0x217361f4}, + [16]uint32{0x3f800000,0x3f843244,0x3f980120,0x3f9c3364,0x3f800140,0x3f843304,0x3f980060,0x3f9c3224,0x3f8c8b94,0x3f88b9d0,0x3f948ab4,0x3f90b8f0,0x3f8c8ad4,0x3f88b890,0x3f948bf4,0x3f90b9b0}, + uint32(0xfff80000), + [21]string{"0xab","0x20","0xd2","0x90","0xbc","0xb7","0x07","0xb5","0x34","0x98","0xad","0xa8","0x28","0x00","0xd0","0x90","0xd6","0xa8","0x5b","0xec","0x00"} }, + { + /* No.672 delta:944 weight:911 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0xb427dce0,0x2313c140,0x97341da0,0xc1702a08,0x7557f6e8,0xe263eb48,0x564437a8,0x00000abd,0xb427d65d,0x2313cbfd,0x9734171d,0xc17020b5,0x7557fc55,0xe263e1f5,0x56443d15}, + [16]uint32{0x00000000,0x005a4df6,0x2024d19c,0x207e9c6a,0x0003e00f,0x0059adf9,0x20273193,0x207d7c65,0x2041c01d,0x201b8deb,0x00651181,0x003f5c77,0x20422012,0x20186de4,0x0066f18e,0x003cbc78}, + [16]uint32{0x3f800000,0x3f802d26,0x3f901268,0x3f903f4e,0x3f8001f0,0x3f802cd6,0x3f901398,0x3f903ebe,0x3f9020e0,0x3f900dc6,0x3f803288,0x3f801fae,0x3f902110,0x3f900c36,0x3f803378,0x3f801e5e}, + uint32(0xfff80000), + [21]string{"0x9b","0x2f","0x9c","0xc9","0x8f","0x56","0x5a","0xd9","0x5c","0x62","0x58","0x41","0x7b","0x21","0xb5","0xaa","0x44","0xf6","0x64","0xe1","0x00"} }, + { + /* No.673 delta:754 weight:1631 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x0a463d08,0xd0b19a69,0xdaf7a761,0xcd002a15,0xc746171d,0x1db1b07c,0x17f78d74,0x000059be,0x0a4664b6,0xd0b1c3d7,0xdaf7fedf,0xcd0073ab,0xc7464ea3,0x1db1e9c2,0x17f7d4ca}, + [16]uint32{0x00000000,0x0003009e,0x400c91af,0x400f9131,0x11784a1a,0x117b4a84,0x5174dbb5,0x5177db2b,0x10450013,0x1046008d,0x504991bc,0x504a9122,0x013d4a09,0x013e4a97,0x4131dba6,0x4132db38}, + [16]uint32{0x3f800000,0x3f800180,0x3fa00648,0x3fa007c8,0x3f88bc25,0x3f88bda5,0x3fa8ba6d,0x3fa8bbed,0x3f882280,0x3f882300,0x3fa824c8,0x3fa82548,0x3f809ea5,0x3f809f25,0x3fa098ed,0x3fa0996d}, + uint32(0xfff80000), + [21]string{"0xf2","0xff","0x5e","0x68","0xc8","0x39","0x73","0x0b","0x05","0x36","0x4c","0x58","0x1c","0x20","0xff","0x3c","0xfd","0xd7","0xfb","0x2c","0x00"} }, + { + /* No.674 delta:724 weight:1401 */ + 11213, + 64, + 13, + 4, + [16]uint32{0x00000000,0xf01895c2,0xbd30a31c,0x4d2836de,0xe4402a28,0x1458bfea,0x59708934,0xa9681cf6,0x0000ec4e,0xf018798c,0xbd304f52,0x4d28da90,0xe440c666,0x145853a4,0x5970657a,0xa968f0b8}, + [16]uint32{0x00000000,0x20424d9f,0x0003c611,0x20418b8e,0x40010015,0x60434d8a,0x4002c604,0x60408b9b,0x100020d9,0x30426d46,0x1003e6c8,0x3041ab57,0x500120cc,0x70436d53,0x5002e6dd,0x7040ab42}, + [16]uint32{0x3f800000,0x3f902126,0x3f8001e3,0x3f9020c5,0x3fa00080,0x3fb021a6,0x3fa00163,0x3fb02045,0x3f880010,0x3f982136,0x3f8801f3,0x3f9820d5,0x3fa80090,0x3fb821b6,0x3fa80173,0x3fb82055}, + uint32(0xfff80000), + [21]string{"0x0a","0x7c","0xe4","0x8f","0xf6","0xf2","0x7d","0x30","0xf5","0xa8","0x68","0xad","0x29","0x95","0x29","0x7d","0xa3","0xc2","0x94","0x3d","0x00"} }, + { + /* No.675 delta:691 weight:1655 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x81ad5ebe,0x591d6a96,0xd8b03428,0xe7a02a3d,0x660d7483,0xbebd40ab,0x3f101e15,0x0000188b,0x81ad4635,0x591d721d,0xd8b02ca3,0xe7a032b6,0x660d6c08,0xbebd5820,0x3f10069e}, + [16]uint32{0x00000000,0x240285f6,0x000257d1,0x2400d227,0x1041040b,0x344381fd,0x104353da,0x3441d62c,0x80000013,0xa40285e5,0x800257c2,0xa400d234,0x90410418,0xb44381ee,0x904353c9,0xb441d63f}, + [16]uint32{0x3f800000,0x3f920142,0x3f80012b,0x3f920069,0x3f882082,0x3f9a21c0,0x3f8821a9,0x3f9a20eb,0x3fc00000,0x3fd20142,0x3fc0012b,0x3fd20069,0x3fc82082,0x3fda21c0,0x3fc821a9,0x3fda20eb}, + uint32(0xfff80000), + [21]string{"0x1b","0xf3","0xdd","0x2d","0xa2","0xf5","0x15","0x56","0x6c","0x03","0xd6","0xd5","0xe6","0x9f","0x09","0xc9","0xeb","0x04","0x1d","0x4c","0x00"} }, + { + /* No.676 delta:2888 weight:835 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0x27e8f1e6,0x2b07f0c0,0x0cef0126,0x53d02a40,0x7438dba6,0x78d7da80,0x5f3f2b66,0x00009ac7,0x27e86b21,0x2b076a07,0x0cef9be1,0x53d0b087,0x74384161,0x78d74047,0x5f3fb1a1}, + [16]uint32{0x00000000,0x804491b5,0x2608010e,0xa64c90bb,0x21414059,0xa105d1ec,0x07494157,0x870dd0e2,0x0dc50201,0x8d8193b4,0x2bcd030f,0xab8992ba,0x2c844258,0xacc0d3ed,0x0a8c4356,0x8ac8d2e3}, + [16]uint32{0x3f800000,0x3fc02248,0x3f930400,0x3fd32648,0x3f90a0a0,0x3fd082e8,0x3f83a4a0,0x3fc386e8,0x3f86e281,0x3fc6c0c9,0x3f95e681,0x3fd5c4c9,0x3f964221,0x3fd66069,0x3f854621,0x3fc56469}, + uint32(0xfff80000), + [21]string{"0x20","0x55","0x9f","0x52","0xcb","0xa8","0xf1","0xc3","0x40","0xf2","0xb5","0xb1","0x70","0x33","0xbe","0x42","0x35","0x35","0xf4","0x86","0x00"} }, + { + /* No.677 delta:1298 weight:1637 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0xf0dfaf34,0xc33fdbfa,0x33e074ce,0xd5502a52,0x258f8566,0x166ff1a8,0xe6b05e9c,0x0000a8cc,0xf0df07f8,0xc33f7336,0x33e0dc02,0xd550829e,0x258f2daa,0x166f5964,0xe6b0f650}, + [16]uint32{0x00000000,0x205265c7,0xc96c217e,0xe93e44b9,0x2401f19d,0x0453945a,0xed6dd0e3,0xcd3fb524,0x2024885c,0x0076ed9b,0xe948a922,0xc91acce5,0x042579c1,0x24771c06,0xcd4958bf,0xed1b3d78}, + [16]uint32{0x3f800000,0x3f902932,0x3fe4b610,0x3ff49f22,0x3f9200f8,0x3f8229ca,0x3ff6b6e8,0x3fe69fda,0x3f901244,0x3f803b76,0x3ff4a454,0x3fe48d66,0x3f8212bc,0x3f923b8e,0x3fe6a4ac,0x3ff68d9e}, + uint32(0xfff80000), + [21]string{"0x64","0x66","0x3c","0xa9","0xb6","0x90","0xd6","0x98","0x4a","0x59","0x3e","0xbb","0xc2","0x3c","0xdb","0x7d","0x16","0x26","0xf2","0x8e","0x00"} }, + { + /* No.678 delta:1656 weight:1613 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xfc93fa1c,0x9215d5e4,0x6e862ff8,0xefb02a61,0x1323d07d,0x7da5ff85,0x81360599,0x0000f9ef,0xfc9303f3,0x92152c0b,0x6e86d617,0xefb0d38e,0x13232992,0x7da5066a,0x8136fc76}, + [16]uint32{0x00000000,0x0daa0f5c,0x4242f663,0x4fe8f93f,0x400c580a,0x4da65756,0x024eae69,0x0fe4a135,0x1070012d,0x1dda0e71,0x5232f74e,0x5f98f812,0x507c5927,0x5dd6567b,0x123eaf44,0x1f94a018}, + [16]uint32{0x3f800000,0x3f86d507,0x3fa1217b,0x3fa7f47c,0x3fa0062c,0x3fa6d32b,0x3f812757,0x3f87f250,0x3f883800,0x3f8eed07,0x3fa9197b,0x3fafcc7c,0x3fa83e2c,0x3faeeb2b,0x3f891f57,0x3f8fca50}, + uint32(0xfff80000), + [21]string{"0xc7","0x96","0x75","0x81","0x05","0xf9","0x1f","0x2d","0x20","0xed","0x42","0xb6","0x7e","0xee","0x15","0xff","0x02","0xaf","0x37","0x62","0x00"} }, + { + /* No.679 delta:1225 weight:1667 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x378cf027,0x1f2d848f,0x28a174a8,0x65302a75,0x52bcda52,0x7a1daefa,0x4d915edd,0x0000fbb6,0x378c0b91,0x1f2d7f39,0x28a18f1e,0x6530d1c3,0x52bc21e4,0x7a1d554c,0x4d91a56b}, + [16]uint32{0x00000000,0x006e2034,0x00204496,0x004e64a2,0x5c98f0f1,0x5cf6d0c5,0x5cb8b467,0x5cd69453,0x2018413c,0x20766108,0x203805aa,0x2056259e,0x7c80b1cd,0x7cee91f9,0x7ca0f55b,0x7cced56f}, + [16]uint32{0x3f800000,0x3f803710,0x3f801022,0x3f802732,0x3fae4c78,0x3fae7b68,0x3fae5c5a,0x3fae6b4a,0x3f900c20,0x3f903b30,0x3f901c02,0x3f902b12,0x3fbe4058,0x3fbe7748,0x3fbe507a,0x3fbe676a}, + uint32(0xfff80000), + [21]string{"0xb5","0xb7","0x67","0x73","0xb6","0x8e","0xab","0x04","0x12","0xea","0x83","0x74","0xb2","0x65","0x91","0x82","0xe2","0x1a","0x28","0x13","0x00"} }, + { + /* No.680 delta:752 weight:1673 */ + 11213, + 75, + 13, + 4, + [16]uint32{0x00000000,0xd9bb6a3c,0xb144aa48,0x68ffc074,0x76d02a80,0xaf6b40bc,0xc79480c8,0x1e2feaf4,0x0000ceaa,0xd9bba496,0xb14464e2,0x68ff0ede,0x76d0e42a,0xaf6b8e16,0xc7944e62,0x1e2f245e}, + [16]uint32{0x00000000,0x000390b7,0x001010c6,0x00138071,0x5001017c,0x500291cb,0x501111ba,0x5012810d,0x900041df,0x9003d168,0x90105119,0x9013c1ae,0xc00140a3,0xc002d014,0xc0115065,0xc012c0d2}, + [16]uint32{0x3f800000,0x3f8001c8,0x3f800808,0x3f8009c0,0x3fa80080,0x3fa80148,0x3fa80888,0x3fa80940,0x3fc80020,0x3fc801e8,0x3fc80828,0x3fc809e0,0x3fe000a0,0x3fe00168,0x3fe008a8,0x3fe00960}, + uint32(0xfff80000), + [21]string{"0xaa","0x37","0x8c","0x9d","0x0d","0x3d","0x93","0x45","0xbd","0xf8","0xbe","0x46","0x7f","0x58","0xd5","0x06","0x44","0x13","0x58","0x1e","0x00"} }, + { + /* No.681 delta:955 weight:1563 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0xed428b4b,0x05612acc,0xe823a187,0x0d602a99,0xe022a1d2,0x08010055,0xe5438b1e,0x000021b3,0xed42aaf8,0x05610b7f,0xe8238034,0x0d600b2a,0xe0228061,0x080121e6,0xe543aaad}, + [16]uint32{0x00000000,0x413fa072,0x004610b6,0x4179b0c4,0x0003d01f,0x413c706d,0x0045c0a9,0x417a60db,0x000120bc,0x413e80ce,0x0047300a,0x41789078,0x0002f0a3,0x413d50d1,0x0044e015,0x417b4067}, + [16]uint32{0x3f800000,0x3fa09fd0,0x3f802308,0x3fa0bcd8,0x3f8001e8,0x3fa09e38,0x3f8022e0,0x3fa0bd30,0x3f800090,0x3fa09f40,0x3f802398,0x3fa0bc48,0x3f800178,0x3fa09ea8,0x3f802270,0x3fa0bda0}, + uint32(0xfff80000), + [21]string{"0x68","0xea","0x31","0xa4","0x56","0x04","0x96","0xc0","0xc5","0xbd","0xd1","0x72","0x45","0x87","0x79","0xb8","0x58","0xf6","0xf9","0x6a","0x00"} }, + { + /* No.682 delta:790 weight:1367 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0xa4d766a7,0x9c6bcbf0,0x38bcad57,0xe3902aae,0x47474c09,0x7ffbe15e,0xdb2c87f9,0x000047b5,0xa4d72112,0x9c6b8c45,0x38bceae2,0xe3906d1b,0x47470bbc,0x7ffba6eb,0xdb2cc04c}, + [16]uint32{0x00000000,0x004e9975,0x20620083,0x202c99f6,0x0012b012,0x005c2967,0x2070b091,0x203e29e4,0x20091808,0x2047817d,0x006b188b,0x002581fe,0x201ba81a,0x2055316f,0x0079a899,0x003731ec}, + [16]uint32{0x3f800000,0x3f80274c,0x3f903100,0x3f90164c,0x3f800958,0x3f802e14,0x3f903858,0x3f901f14,0x3f90048c,0x3f9023c0,0x3f80358c,0x3f8012c0,0x3f900dd4,0x3f902a98,0x3f803cd4,0x3f801b98}, + uint32(0xfff80000), + [21]string{"0x07","0x61","0x29","0xd6","0x6d","0x04","0xdc","0x6a","0xd2","0xa7","0x31","0x84","0xac","0x3e","0x56","0x58","0x0d","0x32","0x2d","0x88","0x00"} }, + { + /* No.683 delta:1454 weight:1495 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0x9afb758b,0xea3505c7,0x70ce704c,0xbb002ab0,0x21fb5f3b,0x51352f77,0xcbce5afc,0x00003d6b,0x9afb48e0,0xea3538ac,0x70ce4d27,0xbb0017db,0x21fb6250,0x5135121c,0xcbce6797}, + [16]uint32{0x00000000,0x107520de,0x004c40ef,0x10396031,0x000ca188,0x10798156,0x0040e167,0x1035c1b9,0x1100801d,0x0175a0c3,0x114cc0f2,0x0139e02c,0x110c2195,0x0179014b,0x1140617a,0x013541a4}, + [16]uint32{0x3f800000,0x3f883a90,0x3f802620,0x3f881cb0,0x3f800650,0x3f883cc0,0x3f802070,0x3f881ae0,0x3f888040,0x3f80bad0,0x3f88a660,0x3f809cf0,0x3f888610,0x3f80bc80,0x3f88a030,0x3f809aa0}, + uint32(0xfff80000), + [21]string{"0xca","0xd2","0x93","0xe4","0x1d","0xa3","0x1c","0x92","0x46","0x20","0x9f","0x5f","0xb5","0x70","0x28","0xcd","0xfb","0xd0","0x11","0x9b","0x00"} }, + { + /* No.684 delta:802 weight:891 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0xa14df0bb,0xdcdafd66,0x7d970ddd,0xab902ac8,0x0addda73,0x774ad7ae,0xd6072715,0x0000bfeb,0xa14d4f50,0xdcda428d,0x7d97b236,0xab909523,0x0add6598,0x774a6845,0xd60798fe}, + [16]uint32{0x00000000,0x63b451bb,0x80242906,0xe39078bd,0x20482511,0x43fc74aa,0xa06c0c17,0xc3d85dac,0x1600417f,0x75b410c4,0x96246879,0xf59039c2,0x3648646e,0x55fc35d5,0xb66c4d68,0xd5d81cd3}, + [16]uint32{0x3f800000,0x3fb1da28,0x3fc01214,0x3ff1c83c,0x3f902412,0x3fa1fe3a,0x3fd03606,0x3fe1ec2e,0x3f8b0020,0x3fbada08,0x3fcb1234,0x3ffac81c,0x3f9b2432,0x3faafe1a,0x3fdb3626,0x3feaec0e}, + uint32(0xfff80000), + [21]string{"0xef","0x08","0x48","0x27","0xc2","0x43","0xcd","0xa5","0x83","0x65","0x18","0xb6","0x08","0xb1","0x04","0xc9","0x9a","0x89","0x14","0xd8","0x00"} }, + { + /* No.685 delta:1202 weight:745 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x9d32cc08,0x7d8a0867,0xe0b8c46f,0xd4202ade,0x4912e6d6,0xa9aa22b9,0x3498eeb1,0x00009a9a,0x9d325692,0x7d8a92fd,0xe0b85ef5,0xd420b044,0x49127c4c,0xa9aab823,0x3498742b}, + [16]uint32{0x00000000,0x07f30f3d,0x0042091b,0x07b10626,0x3030801e,0x37c38f23,0x30728905,0x37818638,0x0060600f,0x07936f32,0x00226914,0x07d16629,0x3050e011,0x37a3ef2c,0x3012e90a,0x37e1e637}, + [16]uint32{0x3f800000,0x3f83f987,0x3f802104,0x3f83d883,0x3f981840,0x3f9be1c7,0x3f983944,0x3f9bc0c3,0x3f803030,0x3f83c9b7,0x3f801134,0x3f83e8b3,0x3f982870,0x3f9bd1f7,0x3f980974,0x3f9bf0f3}, + uint32(0xfff80000), + [21]string{"0x97","0x40","0xd9","0x81","0x9e","0xe9","0x63","0xd2","0x63","0x05","0xae","0x59","0x1a","0xa1","0x0c","0xd2","0xa8","0x17","0x82","0x23","0x00"} }, + { + /* No.686 delta:904 weight:1673 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0xab627736,0x32142b59,0x99765c6f,0xd2f02aeb,0x79925ddd,0xe0e401b2,0x4b867684,0x0000c039,0xab62b70f,0x3214eb60,0x99769c56,0xd2f0ead2,0x79929de4,0xe0e4c18b,0x4b86b6bd}, + [16]uint32{0x00000000,0x02211b32,0x0043b267,0x0262a955,0xa00300fc,0xa2221bce,0xa040b29b,0xa261a9a9,0x00010546,0x02201e74,0x0042b721,0x0263ac13,0xa00205ba,0xa2231e88,0xa041b7dd,0xa260acef}, + [16]uint32{0x3f800000,0x3f81108d,0x3f8021d9,0x3f813154,0x3fd00180,0x3fd1110d,0x3fd02059,0x3fd130d4,0x3f800082,0x3f81100f,0x3f80215b,0x3f8131d6,0x3fd00102,0x3fd1118f,0x3fd020db,0x3fd13056}, + uint32(0xfff80000), + [21]string{"0x38","0xfa","0x4f","0x2d","0x7b","0x44","0x2a","0xb4","0x9e","0x6e","0x01","0x28","0x70","0x80","0xf3","0xc6","0xce","0x7f","0x20","0x38","0x00"} }, + { + /* No.687 delta:2186 weight:1175 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xc845fc13,0x9a2a2643,0x526fda50,0xc1602af9,0x0925d6ea,0x5b4a0cba,0x930ff0a9,0x00002b90,0xc845d783,0x9a2a0dd3,0x526ff1c0,0xc1600169,0x0925fd7a,0x5b4a272a,0x930fdb39}, + [16]uint32{0x00000000,0x6832ca1a,0x88000a0f,0xe032c015,0x14010258,0x7c33c842,0x9c010857,0xf433c24d,0x00601c16,0x6852d60c,0x88601619,0xe052dc03,0x14611e4e,0x7c53d454,0x9c611441,0xf453de5b}, + [16]uint32{0x3f800000,0x3fb41965,0x3fc40005,0x3ff01960,0x3f8a0081,0x3fbe19e4,0x3fce0084,0x3ffa19e1,0x3f80300e,0x3fb4296b,0x3fc4300b,0x3ff0296e,0x3f8a308f,0x3fbe29ea,0x3fce308a,0x3ffa29ef}, + uint32(0xfff80000), + [21]string{"0xe8","0x72","0x5e","0x94","0xe6","0xaa","0xb6","0x99","0x4e","0x9a","0x2d","0x7b","0x67","0xd3","0xd9","0x27","0x9d","0x2b","0xea","0x4c","0x00"} }, + { + /* No.688 delta:775 weight:1283 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x1143d93c,0x70065e3b,0x61458707,0x6c002b02,0x7d43f23e,0x1c067539,0x0d45ac05,0x00006ed2,0x1143b7ee,0x700630e9,0x6145e9d5,0x6c0045d0,0x7d439cec,0x1c061beb,0x0d45c2d7}, + [16]uint32{0x00000000,0x007c11be,0x00027c1c,0x007e6da2,0x30340809,0x304819b7,0x30367415,0x304a65ab,0x40038416,0x407f95a8,0x4001f80a,0x407de9b4,0x70378c1f,0x704b9da1,0x7035f003,0x7049e1bd}, + [16]uint32{0x3f800000,0x3f803e08,0x3f80013e,0x3f803f36,0x3f981a04,0x3f98240c,0x3f981b3a,0x3f982532,0x3fa001c2,0x3fa03fca,0x3fa000fc,0x3fa03ef4,0x3fb81bc6,0x3fb825ce,0x3fb81af8,0x3fb824f0}, + uint32(0xfff80000), + [21]string{"0xf0","0x08","0xbc","0x82","0x1e","0x36","0x45","0xe3","0x23","0x4e","0x60","0xec","0x0a","0x38","0xe9","0xa3","0x1b","0xe6","0xb9","0x5b","0x00"} }, + { + /* No.689 delta:932 weight:1243 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x5c9f9e47,0xe07a90a6,0xbce50ee1,0x26d02b1b,0x7a4fb55c,0xc6aabbbd,0x9a3525fa,0x0000aae2,0x5c9f34a5,0xe07a3a44,0xbce5a403,0x26d081f9,0x7a4f1fbe,0xc6aa115f,0x9a358f18}, + [16]uint32{0x00000000,0x00448056,0x003908bf,0x007d88e9,0x201200c3,0x20568095,0x202b087c,0x206f882a,0x20001e14,0x20449e42,0x203916ab,0x207d96fd,0x00121ed7,0x00569e81,0x002b1668,0x006f963e}, + [16]uint32{0x3f800000,0x3f802240,0x3f801c84,0x3f803ec4,0x3f900900,0x3f902b40,0x3f901584,0x3f9037c4,0x3f90000f,0x3f90224f,0x3f901c8b,0x3f903ecb,0x3f80090f,0x3f802b4f,0x3f80158b,0x3f8037cb}, + uint32(0xfff80000), + [21]string{"0xa7","0x08","0x7c","0xd0","0x1d","0x5a","0x32","0x9e","0xbc","0xd4","0x96","0x9c","0x4e","0x30","0x2a","0x02","0xa6","0x8b","0x2f","0x33","0x00"} }, + { + /* No.690 delta:1022 weight:1573 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0x2e8b71e9,0x629da5de,0x4c16d437,0x28702b21,0x06fb5ac8,0x4aed8eff,0x6466ff16,0x00006e83,0x2e8b1f6a,0x629dcb5d,0x4c16bab4,0x287045a2,0x06fb344b,0x4aede07c,0x64669195}, + [16]uint32{0x00000000,0x400f41f6,0x400b2cb9,0x00046d4f,0x3003940b,0x700cd5fd,0x7008b8b2,0x3007f944,0x3000645e,0x700f25a8,0x700b48e7,0x30040911,0x0003f055,0x400cb1a3,0x4008dcec,0x00079d1a}, + [16]uint32{0x3f800000,0x3fa007a0,0x3fa00596,0x3f800236,0x3f9801ca,0x3fb8066a,0x3fb8045c,0x3f9803fc,0x3f980032,0x3fb80792,0x3fb805a4,0x3f980204,0x3f8001f8,0x3fa00658,0x3fa0046e,0x3f8003ce}, + uint32(0xfff80000), + [21]string{"0x55","0x4b","0xa5","0x55","0x16","0x56","0x00","0x07","0x52","0xab","0xe7","0x4a","0x79","0xb7","0x71","0xae","0xbf","0x09","0xe1","0xe3","0x00"} }, + { + /* No.691 delta:716 weight:1417 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0xa5e14faf,0xf40aed99,0x51eba236,0x54202b30,0xf1c1649f,0xa02ac6a9,0x05cb8906,0x0000550b,0xa5e11aa4,0xf40ab892,0x51ebf73d,0x54207e3b,0xf1c13194,0xa02a93a2,0x05cbdc0d}, + [16]uint32{0x00000000,0xf042189a,0x10066011,0xe044788b,0x20020406,0xd0401c9c,0x30046417,0xc0467c8d,0x00400af3,0xf0021269,0x10466ae2,0xe0047278,0x20420ef5,0xd000166f,0x30446ee4,0xc006767e}, + [16]uint32{0x3f800000,0x3ff8210c,0x3f880330,0x3ff0223c,0x3f900102,0x3fe8200e,0x3f980232,0x3fe0233e,0x3f802005,0x3ff80109,0x3f882335,0x3ff00239,0x3f902107,0x3fe8000b,0x3f982237,0x3fe0033b}, + uint32(0xfff80000), + [21]string{"0xeb","0x1f","0x92","0x14","0x93","0x32","0xc6","0xc7","0x67","0xa8","0x5e","0x73","0x83","0xc8","0xa1","0x90","0x95","0x78","0x82","0x7e","0x00"} }, + { + /* No.692 delta:1060 weight:1233 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0xb0e29cc7,0xf65cc601,0x46be5ac6,0x6a502b49,0xdab2b78e,0x9c0ced48,0x2cee718f,0x0000da6a,0xb0e246ad,0xf65c1c6b,0x46be80ac,0x6a50f123,0xdab26de4,0x9c0c3722,0x2ceeabe5}, + [16]uint32{0x00000000,0x00748d5a,0x000201dd,0x00768c87,0xe01c0905,0xe068845f,0xe01e08d8,0xe06a8582,0x50080014,0x507c8d4e,0x500a01c9,0x507e8c93,0xb0140911,0xb060844b,0xb01608cc,0xb0628596}, + [16]uint32{0x3f800000,0x3f803a46,0x3f800100,0x3f803b46,0x3ff00e04,0x3ff03442,0x3ff00f04,0x3ff03542,0x3fa80400,0x3fa83e46,0x3fa80500,0x3fa83f46,0x3fd80a04,0x3fd83042,0x3fd80b04,0x3fd83142}, + uint32(0xfff80000), + [21]string{"0xad","0x3d","0x85","0xdb","0xec","0x85","0xd5","0x0d","0x0b","0xbb","0xf0","0xf6","0x8c","0x35","0xb3","0x80","0xcb","0x1a","0x65","0x3d","0x00"} }, + { + /* No.693 delta:1458 weight:1553 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x89028909,0x09922e0d,0x8090a704,0x3e402b58,0xb742a251,0x37d20555,0xbed08c5c,0x00006f06,0x8902e60f,0x0992410b,0x8090c802,0x3e40445e,0xb742cd57,0x37d26a53,0xbed0e35a}, + [16]uint32{0x00000000,0x006e00ba,0x00130033,0x007d0089,0x0271012c,0x021f0196,0x0262011f,0x020c01a5,0x2003009c,0x206d0026,0x201000af,0x207e0015,0x227201b0,0x221c010a,0x22610183,0x220f0139}, + [16]uint32{0x3f800000,0x3f803700,0x3f800980,0x3f803e80,0x3f813880,0x3f810f80,0x3f813100,0x3f810600,0x3f900180,0x3f903680,0x3f900800,0x3f903f00,0x3f913900,0x3f910e00,0x3f913080,0x3f910780}, + uint32(0xfff80000), + [21]string{"0x6a","0x0e","0xf5","0xe4","0x8b","0x37","0x53","0xf6","0x37","0x13","0x48","0x6f","0xdc","0x7d","0xdb","0xb6","0xd0","0x7f","0x2b","0xb0","0x00"} }, + { + /* No.694 delta:963 weight:1487 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0xaa31eed0,0x68df0cb5,0xc2eee265,0xee802b61,0x44b1c5b1,0x865f27d4,0x2c6ec904,0x0000b330,0xaa315de0,0x68dfbf85,0xc2ee5155,0xee809851,0x44b17681,0x865f94e4,0x2c6e7a34}, + [16]uint32{0x00000000,0x200c7296,0x0002585b,0x200e2acd,0x30002015,0x100c5283,0x3002784e,0x100e0ad8,0x000162b2,0x200d1024,0x00033ae9,0x200f487f,0x300142a7,0x100d3031,0x30031afc,0x100f686a}, + [16]uint32{0x3f800000,0x3f900639,0x3f80012c,0x3f900715,0x3f980010,0x3f880629,0x3f98013c,0x3f880705,0x3f8000b1,0x3f900688,0x3f80019d,0x3f9007a4,0x3f9800a1,0x3f880698,0x3f98018d,0x3f8807b4}, + uint32(0xfff80000), + [21]string{"0x21","0xa8","0xf9","0xbc","0x0c","0x6c","0x8a","0xee","0xfc","0xf2","0x59","0x74","0x50","0xd0","0x23","0x18","0xdc","0xec","0xf1","0x78","0x00"} }, + { + /* No.695 delta:1033 weight:1507 */ + 11213, + 54, + 13, + 4, + [16]uint32{0x00000000,0xbeac6872,0x9f74d9c6,0x21d8b1b4,0x4f602b7d,0xf1cc430f,0xd014f2bb,0x6eb89ac9,0x00003c37,0xbeac5445,0x9f74e5f1,0x21d88d83,0x4f60174a,0xf1cc7f38,0xd014ce8c,0x6eb8a6fe}, + [16]uint32{0x00000000,0x0003d99a,0x600d321e,0x600eeb84,0x1041a203,0x10427b99,0x704c901d,0x704f4987,0x00002416,0x0003fd8c,0x600d1608,0x600ecf92,0x10418615,0x10425f8f,0x704cb40b,0x704f6d91}, + [16]uint32{0x3f800000,0x3f8001ec,0x3fb00699,0x3fb00775,0x3f8820d1,0x3f88213d,0x3fb82648,0x3fb827a4,0x3f800012,0x3f8001fe,0x3fb0068b,0x3fb00767,0x3f8820c3,0x3f88212f,0x3fb8265a,0x3fb827b6}, + uint32(0xfff80000), + [21]string{"0x03","0xfe","0xd3","0x09","0xa3","0x85","0x4f","0xea","0x6f","0xf7","0x00","0x48","0xfd","0x6f","0xfe","0xed","0x9f","0x5c","0x32","0xca","0x00"} }, + { + /* No.696 delta:1158 weight:1433 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x2d5d463e,0x2180bcea,0x0cddfad4,0x79202b87,0x547d6db9,0x58a0976d,0x75fdd153,0x00009b81,0x2d5dddbf,0x2180276b,0x0cdd6155,0x7920b006,0x547df638,0x58a00cec,0x75fd4ad2}, + [16]uint32{0x00000000,0x3084731e,0x00026803,0x30861b1d,0x20140a0a,0x10907914,0x20166209,0x10921117,0x0003deb6,0x3087ada8,0x0001b6b5,0x3085c5ab,0x2017d4bc,0x1093a7a2,0x2015bcbf,0x1091cfa1}, + [16]uint32{0x3f800000,0x3f984239,0x3f800134,0x3f98430d,0x3f900a05,0x3f88483c,0x3f900b31,0x3f884908,0x3f8001ef,0x3f9843d6,0x3f8000db,0x3f9842e2,0x3f900bea,0x3f8849d3,0x3f900ade,0x3f8848e7}, + uint32(0xfff80000), + [21]string{"0xca","0x95","0x82","0x4b","0x34","0xf2","0x37","0x66","0x84","0x94","0x93","0x26","0xfa","0xd0","0xe1","0x3e","0xb2","0xaf","0x59","0x1e","0x00"} }, + { + /* No.697 delta:721 weight:1497 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0xa00e95c3,0x5abe067b,0xfab093b8,0xf5502b95,0x555ebe56,0xafee2dee,0x0fe0b82d,0x0000be37,0xa00e2bf4,0x5abeb84c,0xfab02d8f,0xf55095a2,0x555e0061,0xafee93d9,0x0fe0061a}, + [16]uint32{0x00000000,0x204cacf5,0x005e6413,0x2012c8e6,0x002ca81e,0x206004eb,0x0072cc0d,0x203e60f8,0x0003280a,0x204f84ff,0x005d4c19,0x2011e0ec,0x002f8014,0x20632ce1,0x0071e407,0x203d48f2}, + [16]uint32{0x3f800000,0x3f902656,0x3f802f32,0x3f900964,0x3f801654,0x3f903002,0x3f803966,0x3f901f30,0x3f800194,0x3f9027c2,0x3f802ea6,0x3f9008f0,0x3f8017c0,0x3f903196,0x3f8038f2,0x3f901ea4}, + uint32(0xfff80000), + [21]string{"0xa5","0xe9","0x6e","0x20","0xc2","0x5c","0x26","0xa8","0x92","0x5f","0x7d","0x41","0xc8","0xa8","0x95","0x5f","0x5e","0x8e","0xe2","0x47","0x00"} }, + { + /* No.698 delta:689 weight:1667 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x6322d488,0xf80be38a,0x9b293702,0xeeb02ba2,0x8d92ff2a,0x16bbc828,0x75991ca0,0x00004232,0x632296ba,0xf80ba1b8,0x9b297530,0xeeb06990,0x8d92bd18,0x16bb8a1a,0x75995e92}, + [16]uint32{0x00000000,0x000419dd,0x402115e6,0x40250c3b,0x1400b40e,0x1404add3,0x5421a1e8,0x5425b835,0x1020b807,0x1024a1da,0x5001ade1,0x5005b43c,0x04200c09,0x042415d4,0x440119ef,0x44050032}, + [16]uint32{0x3f800000,0x3f80020c,0x3fa0108a,0x3fa01286,0x3f8a005a,0x3f8a0256,0x3faa10d0,0x3faa12dc,0x3f88105c,0x3f881250,0x3fa800d6,0x3fa802da,0x3f821006,0x3f82120a,0x3fa2008c,0x3fa20280}, + uint32(0xfff80000), + [21]string{"0x00","0xa5","0x0f","0xa6","0xbd","0x0c","0x32","0xa3","0x2e","0x2c","0x87","0xea","0x4c","0x5a","0x03","0x93","0xbf","0x99","0xcb","0x74","0x00"} }, + { + /* No.699 delta:1079 weight:1465 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x5434731b,0x39cd1ea0,0x6df96dbb,0x45802bb9,0x11b458a2,0x7c4d3519,0x28794602,0x00001d7b,0x54346e60,0x39cd03db,0x6df970c0,0x458036c2,0x11b445d9,0x7c4d2862,0x28795b79}, + [16]uint32{0x00000000,0x485d5455,0x4058202a,0x0805747f,0x006da1d8,0x4830f58d,0x403581f2,0x0868d5a7,0x00083004,0x48556451,0x4050102e,0x080d447b,0x006591dc,0x4838c589,0x403db1f6,0x0860e5a3}, + [16]uint32{0x3f800000,0x3fa42eaa,0x3fa02c10,0x3f8402ba,0x3f8036d0,0x3fa4187a,0x3fa01ac0,0x3f84346a,0x3f800418,0x3fa42ab2,0x3fa02808,0x3f8406a2,0x3f8032c8,0x3fa41c62,0x3fa01ed8,0x3f843072}, + uint32(0xfff80000), + [21]string{"0x89","0x23","0xd7","0x03","0x17","0x79","0x57","0xbe","0x96","0x69","0x86","0x88","0x36","0x9f","0x19","0x4d","0x7e","0x49","0x4b","0x46","0x00"} }, + { + /* No.700 delta:805 weight:1655 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x988f7805,0x33dbcd88,0xab54b58d,0x7c402bcf,0xe4cf53ca,0x4f9be647,0xd7149e42,0x00006460,0x988f1c65,0x33dba9e8,0xab54d1ed,0x7c404faf,0xe4cf37aa,0x4f9b8227,0xd714fa22}, + [16]uint32{0x00000000,0x007e5995,0x0002c1f3,0x007c9866,0x0001300c,0x007f6999,0x0003f1ff,0x007da86a,0x1000040d,0x107e5d98,0x1002c5fe,0x107c9c6b,0x10013401,0x107f6d94,0x1003f5f2,0x107dac67}, + [16]uint32{0x3f800000,0x3f803f2c,0x3f800160,0x3f803e4c,0x3f800098,0x3f803fb4,0x3f8001f8,0x3f803ed4,0x3f880002,0x3f883f2e,0x3f880162,0x3f883e4e,0x3f88009a,0x3f883fb6,0x3f8801fa,0x3f883ed6}, + uint32(0xfff80000), + [21]string{"0xf5","0x72","0x97","0xba","0x66","0x48","0x85","0xa2","0xc4","0x32","0xa0","0x9c","0xf6","0x3d","0x44","0x1c","0x63","0x05","0xaf","0xa2","0x00"} }, + { + /* No.701 delta:668 weight:1457 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x68380722,0xeed3df88,0x86ebd8aa,0xdb502bdb,0xb3682cf9,0x3583f453,0x5dbbf371,0x0000f040,0x6838f762,0xeed32fc8,0x86eb28ea,0xdb50db9b,0xb368dcb9,0x35830413,0x5dbb0331}, + [16]uint32{0x00000000,0x205610cb,0x0042841f,0x201494d4,0x80000191,0xa056115a,0x8042858e,0xa0149545,0x0041e85e,0x2017f895,0x00036c41,0x20557c8a,0x8041e9cf,0xa017f904,0x80036dd0,0xa0557d1b}, + [16]uint32{0x3f800000,0x3f902b08,0x3f802142,0x3f900a4a,0x3fc00000,0x3fd02b08,0x3fc02142,0x3fd00a4a,0x3f8020f4,0x3f900bfc,0x3f8001b6,0x3f902abe,0x3fc020f4,0x3fd00bfc,0x3fc001b6,0x3fd02abe}, + uint32(0xfff80000), + [21]string{"0x7d","0x3c","0x16","0xae","0xc7","0xa9","0x28","0xfa","0xee","0x23","0x6c","0x22","0xbe","0x25","0x00","0x7f","0xcd","0x78","0x74","0x26","0x00"} }, + { + /* No.702 delta:887 weight:1029 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0xfdc963ba,0xb2d94898,0x4f102b22,0x86b02be1,0x7b79485b,0x34696379,0xc9a000c3,0x000079af,0xfdc91a15,0xb2d93137,0x4f10528d,0x86b0524e,0x7b7931f4,0x34691ad6,0xc9a0796c}, + [16]uint32{0x00000000,0x073c61de,0x508a2111,0x57b640cf,0x08718295,0x0f4de34b,0x58fba384,0x5fc7c25a,0x4829001d,0x4f1561c3,0x18a3210c,0x1f9f40d2,0x40588288,0x4764e356,0x10d2a399,0x17eec247}, + [16]uint32{0x3f800000,0x3f839e30,0x3fa84510,0x3fabdb20,0x3f8438c1,0x3f87a6f1,0x3fac7dd1,0x3fafe3e1,0x3fa41480,0x3fa78ab0,0x3f8c5190,0x3f8fcfa0,0x3fa02c41,0x3fa3b271,0x3f886951,0x3f8bf761}, + uint32(0xfff80000), + [21]string{"0xdf","0xc2","0xd6","0x13","0x13","0x49","0x1a","0x72","0xf3","0xaa","0x72","0x78","0x6c","0x4a","0x4e","0xc2","0xbb","0x82","0x4b","0x8b","0x00"} }, + { + /* No.703 delta:901 weight:1683 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0x02a73e27,0x9a272486,0x98801aa1,0x31202bfd,0x338715da,0xab070f7b,0xa9a0315c,0x00005fcb,0x02a761ec,0x9a277b4d,0x9880456a,0x31207436,0x33874a11,0xab0750b0,0xa9a06e97}, + [16]uint32{0x00000000,0x006c659f,0x0002840a,0x006ee195,0x3100489c,0x316c2d03,0x3102cc96,0x316ea909,0x60049e12,0x6068fb8d,0x60061a18,0x606a7f87,0x5104d68e,0x5168b311,0x51065284,0x516a371b}, + [16]uint32{0x3f800000,0x3f803632,0x3f800142,0x3f803770,0x3f988024,0x3f98b616,0x3f988166,0x3f98b754,0x3fb0024f,0x3fb0347d,0x3fb0030d,0x3fb0353f,0x3fa8826b,0x3fa8b459,0x3fa88329,0x3fa8b51b}, + uint32(0xfff80000), + [21]string{"0x53","0xba","0x2c","0x08","0x90","0xe1","0x2b","0x4f","0xf2","0xa3","0xeb","0xae","0x44","0x57","0x3c","0xa3","0x45","0x55","0x16","0x80","0x00"} }, + { + /* No.704 delta:1419 weight:1587 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x090de45e,0x0a9e0c17,0x0393e849,0xf1c02c07,0xf8cdc859,0xfb5e2010,0xf253c44e,0x0000569a,0x090db2c4,0x0a9e5a8d,0x0393bed3,0xf1c07a9d,0xf8cd9ec3,0xfb5e768a,0xf25392d4}, + [16]uint32{0x00000000,0x005d00fe,0x34328105,0x346f81fb,0x0030808c,0x006d8072,0x34020189,0x345f0177,0x0002c0bd,0x005fc043,0x343041b8,0x346d4146,0x00324031,0x006f40cf,0x3400c134,0x345dc1ca}, + [16]uint32{0x3f800000,0x3f802e80,0x3f9a1940,0x3f9a37c0,0x3f801840,0x3f8036c0,0x3f9a0100,0x3f9a2f80,0x3f800160,0x3f802fe0,0x3f9a1820,0x3f9a36a0,0x3f801920,0x3f8037a0,0x3f9a0060,0x3f9a2ee0}, + uint32(0xfff80000), + [21]string{"0x5e","0x97","0x5a","0x2a","0xdb","0x36","0x22","0xa5","0x47","0xd3","0x1e","0xde","0xbd","0x08","0xd2","0x81","0x11","0x86","0x39","0x64","0x00"} }, + { + /* No.705 delta:1204 weight:1445 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x5e1277ff,0xa9545c45,0xf7462bba,0x26602c19,0x78725be6,0x8f34705c,0xd12607a3,0x000065d3,0x5e12122c,0xa9543996,0xf7464e69,0x266049ca,0x78723e35,0x8f34158f,0xd1266270}, + [16]uint32{0x00000000,0x705c7572,0x006693b1,0x703ae6c3,0x0002253a,0x705e5048,0x0064b68b,0x7038c3f9,0x1020840e,0x607cf17c,0x104617bf,0x601a62cd,0x1022a134,0x607ed446,0x10443285,0x601847f7}, + [16]uint32{0x3f800000,0x3fb82e3a,0x3f803349,0x3fb81d73,0x3f800112,0x3fb82f28,0x3f80325b,0x3fb81c61,0x3f881042,0x3fb03e78,0x3f88230b,0x3fb00d31,0x3f881150,0x3fb03f6a,0x3f882219,0x3fb00c23}, + uint32(0xfff80000), + [21]string{"0x4f","0x86","0x71","0xb2","0xd4","0xa3","0x83","0x4b","0xc0","0x11","0x40","0x6f","0xfc","0x2e","0xf6","0x9e","0xd8","0x97","0xb7","0x5d","0x00"} }, + { + /* No.706 delta:793 weight:1735 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0x31087562,0x34d312e9,0x05db678b,0x8bc02c23,0xbac85941,0xbf133eca,0x8e1b4ba8,0x0000e749,0x3108922b,0x34d3f5a0,0x05db80c2,0x8bc0cb6a,0xbac8be08,0xbf13d983,0x8e1bace1}, + [16]uint32{0x00000000,0x2023005d,0x00023026,0x2021307b,0x803c202f,0xa01f2072,0x803e1009,0xa01d1054,0x00101817,0x2033184a,0x00122831,0x2031286c,0x802c3838,0xa00f3865,0x802e081e,0xa00d0843}, + [16]uint32{0x3f800000,0x3f901180,0x3f800118,0x3f901098,0x3fc01e10,0x3fd00f90,0x3fc01f08,0x3fd00e88,0x3f80080c,0x3f90198c,0x3f800914,0x3f901894,0x3fc0161c,0x3fd0079c,0x3fc01704,0x3fd00684}, + uint32(0xfff80000), + [21]string{"0x0f","0xd9","0xb0","0xfc","0x1e","0x00","0x89","0x45","0x27","0x5d","0xb5","0xf6","0x8c","0xbb","0x86","0xc3","0x13","0x99","0xe6","0x66","0x00"} }, + { + /* No.707 delta:936 weight:1237 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0xfa2806ab,0x81164481,0x7b3e422a,0xca402c3b,0x30682a90,0x4b5668ba,0xb17e6e11,0x0000a345,0xfa28a5ee,0x8116e7c4,0x7b3ee16f,0xca408f7e,0x306889d5,0x4b56cbff,0xb17ecd54}, + [16]uint32{0x00000000,0x205c107a,0x202a0842,0x00761838,0x00492c74,0x20153c0e,0x20632436,0x003f344c,0x0002281b,0x205e3861,0x20282059,0x00743023,0x004b046f,0x20171415,0x20610c2d,0x003d1c57}, + [16]uint32{0x3f800000,0x3f902e08,0x3f901504,0x3f803b0c,0x3f802496,0x3f900a9e,0x3f903192,0x3f801f9a,0x3f800114,0x3f902f1c,0x3f901410,0x3f803a18,0x3f802582,0x3f900b8a,0x3f903086,0x3f801e8e}, + uint32(0xfff80000), + [21]string{"0x08","0x11","0x90","0xc1","0xd9","0x41","0xab","0x89","0x39","0xed","0xa1","0x0a","0x8f","0x5b","0xaf","0xc8","0x74","0x28","0x0e","0x4e","0x00"} }, + { + /* No.708 delta:709 weight:1555 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0x0354317d,0xf05fe7b9,0xf30bd6c4,0x2c102c4e,0x2f441d33,0xdc4fcbf7,0xdf1bfa8a,0x0000f02d,0x0354c150,0xf05f1794,0xf30b26e9,0x2c10dc63,0x2f44ed1e,0xdc4f3bda,0xdf1b0aa7}, + [16]uint32{0x00000000,0x20661c17,0x00419e8c,0x2027829b,0x000c00bf,0x206a1ca8,0x004d9e33,0x202b8224,0x4010400a,0x60765c1d,0x4051de86,0x6037c291,0x401c40b5,0x607a5ca2,0x405dde39,0x603bc22e}, + [16]uint32{0x3f800000,0x3f90330e,0x3f8020cf,0x3f9013c1,0x3f800600,0x3f90350e,0x3f8026cf,0x3f9015c1,0x3fa00820,0x3fb03b2e,0x3fa028ef,0x3fb01be1,0x3fa00e20,0x3fb03d2e,0x3fa02eef,0x3fb01de1}, + uint32(0xfff80000), + [21]string{"0x88","0xab","0x25","0x13","0xb4","0x11","0x86","0x57","0xc6","0x01","0xb8","0x21","0x08","0x7c","0x1d","0x67","0x80","0xb4","0x2c","0xa8","0x00"} }, + { + /* No.709 delta:671 weight:1423 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0x1a428927,0x5ceae995,0x46a860b2,0x07602c50,0x1d22a577,0x5b8ac5c5,0x41c84ce2,0x0000b850,0x1a423177,0x5cea51c5,0x46a8d8e2,0x07609400,0x1d221d27,0x5b8a7d95,0x41c8f4b2}, + [16]uint32{0x00000000,0x100640d2,0x10038adb,0x0005ca09,0x300020f6,0x20066024,0x2003aa2d,0x3005eaff,0x70000211,0x600642c3,0x600388ca,0x7005c818,0x400022e7,0x50066235,0x5003a83c,0x4005e8ee}, + [16]uint32{0x3f800000,0x3f880320,0x3f8801c5,0x3f8002e5,0x3f980010,0x3f900330,0x3f9001d5,0x3f9802f5,0x3fb80001,0x3fb00321,0x3fb001c4,0x3fb802e4,0x3fa00011,0x3fa80331,0x3fa801d4,0x3fa002f4}, + uint32(0xfff80000), + [21]string{"0x9e","0xff","0x79","0xe9","0x97","0xfd","0x27","0xef","0xde","0x6c","0x39","0x49","0xbf","0x17","0x1d","0x63","0xe8","0x65","0x29","0xee","0x00"} }, + { + /* No.710 delta:1669 weight:1535 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x5fdfc99f,0x813670b6,0xdee9b929,0xd4802c69,0x8b5fe5f6,0x55b65cdf,0x0a699540,0x0000dc79,0x5fdf15e6,0x8136accf,0xdee96550,0xd480f010,0x8b5f398f,0x55b680a6,0x0a694939}, + [16]uint32{0x00000000,0x311082da,0x18545d54,0x2944df8e,0x4030a43b,0x712026e1,0x5864f96f,0x69747bb5,0x08262409,0x3936a6d3,0x1072795d,0x2162fb87,0x48168032,0x790602e8,0x5042dd66,0x61525fbc}, + [16]uint32{0x3f800000,0x3f988841,0x3f8c2a2e,0x3f94a26f,0x3fa01852,0x3fb89013,0x3fac327c,0x3fb4ba3d,0x3f841312,0x3f9c9b53,0x3f88393c,0x3f90b17d,0x3fa40b40,0x3fbc8301,0x3fa8216e,0x3fb0a92f}, + uint32(0xfff80000), + [21]string{"0x74","0xac","0xd3","0x5b","0x58","0x5f","0xfd","0x6f","0x7b","0xd4","0x41","0x62","0x28","0x03","0x54","0xee","0x42","0x27","0xf7","0x66","0x00"} }, + { + /* No.711 delta:898 weight:1533 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x847b10ed,0xb36b738f,0x37106362,0x46c02c72,0xc2bb3c9f,0xf5ab5ffd,0x71d04f10,0x00009b57,0x847b8bba,0xb36be8d8,0x3710f835,0x46c0b725,0xc2bba7c8,0xf5abc4aa,0x71d0d447}, + [16]uint32{0x00000000,0x007c41da,0x4000106d,0x407c51b7,0x1043a4a9,0x103fe573,0x5043b4c4,0x503ff51e,0x0003c411,0x007f85cb,0x4003d47c,0x407f95a6,0x104060b8,0x103c2162,0x504070d5,0x503c310f}, + [16]uint32{0x3f800000,0x3f803e20,0x3fa00008,0x3fa03e28,0x3f8821d2,0x3f881ff2,0x3fa821da,0x3fa81ffa,0x3f8001e2,0x3f803fc2,0x3fa001ea,0x3fa03fca,0x3f882030,0x3f881e10,0x3fa82038,0x3fa81e18}, + uint32(0xfff80000), + [21]string{"0x9b","0x56","0xcc","0x7a","0xc8","0x35","0x62","0xc0","0xa8","0x27","0xfa","0xc5","0x59","0xb9","0x88","0x4e","0x69","0x60","0x9e","0x69","0x00"} }, + { + /* No.712 delta:1056 weight:1405 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x76cd7a5b,0x3a968880,0x4c5bf2db,0xe7b02c83,0x917d56d8,0xdd26a403,0xabebde58,0x0000d01b,0x76cdaa40,0x3a96589b,0x4c5b22c0,0xe7b0fc98,0x917d86c3,0xdd267418,0xabeb0e43}, + [16]uint32{0x00000000,0x046d217e,0x401f21d4,0x447200aa,0x000211f2,0x046f308c,0x401d3026,0x44701158,0x10501015,0x143d316b,0x504f31c1,0x542210bf,0x105201e7,0x143f2099,0x504d2033,0x5420014d}, + [16]uint32{0x3f800000,0x3f823690,0x3fa00f90,0x3fa23900,0x3f800108,0x3f823798,0x3fa00e98,0x3fa23808,0x3f882808,0x3f8a1e98,0x3fa82798,0x3faa1108,0x3f882900,0x3f8a1f90,0x3fa82690,0x3faa1000}, + uint32(0xfff80000), + [21]string{"0xc2","0xa1","0x44","0xd6","0x10","0x9a","0x3e","0x53","0x8e","0x42","0x06","0x0b","0xef","0x18","0xf2","0x33","0x96","0x04","0x95","0xba","0x00"} }, + { + /* No.713 delta:1692 weight:1621 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xf6f7da68,0x5a1ee0bf,0xace93ad7,0xa8702c95,0x5e87f6fd,0xf26ecc2a,0x04991642,0x0000d0ab,0xf6f70ac3,0x5a1e3014,0xace9ea7c,0xa870fc3e,0x5e872656,0xf26e1c81,0x0499c6e9}, + [16]uint32{0x00000000,0x647641b7,0x000201e6,0x64744051,0x2008015a,0x447e40ed,0x200a00bc,0x447c410b,0x000100c2,0x64774175,0x00030124,0x64754093,0x20090198,0x447f402f,0x200b007e,0x447d41c9}, + [16]uint32{0x3f800000,0x3fb23b20,0x3f800100,0x3fb23a20,0x3f900400,0x3fa23f20,0x3f900500,0x3fa23e20,0x3f800080,0x3fb23ba0,0x3f800180,0x3fb23aa0,0x3f900480,0x3fa23fa0,0x3f900580,0x3fa23ea0}, + uint32(0xfff80000), + [21]string{"0x2f","0x0c","0xb2","0xfa","0xd2","0x5c","0x6f","0xe7","0x76","0x83","0xc4","0x7b","0xd6","0x98","0x7e","0xc8","0x9f","0x48","0x4f","0x42","0x00"} }, + { + /* No.714 delta:779 weight:1605 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xe62f42c5,0x1428fce7,0xf207be22,0xe4e02ca7,0x02cf6e62,0xf0c8d040,0x16e79285,0x0000c353,0xe62f8196,0x14283fb4,0xf2077d71,0xe4e0eff4,0x02cfad31,0xf0c81313,0x16e751d6}, + [16]uint32{0x00000000,0x2005c0b2,0x0003007e,0x2006c0cc,0x10101811,0x3015d8a3,0x1013186f,0x3016d8dd,0x0040d409,0x204514bb,0x0043d477,0x204614c5,0x1050cc18,0x30550caa,0x1053cc66,0x30560cd4}, + [16]uint32{0x3f800000,0x3f9002e0,0x3f800180,0x3f900360,0x3f88080c,0x3f980aec,0x3f88098c,0x3f980b6c,0x3f80206a,0x3f90228a,0x3f8021ea,0x3f90230a,0x3f882866,0x3f982a86,0x3f8829e6,0x3f982b06}, + uint32(0xfff80000), + [21]string{"0x14","0xf0","0x00","0x03","0x12","0x65","0xd6","0xa0","0x2a","0x29","0x89","0x16","0xaf","0xe1","0x98","0x21","0xa7","0xba","0x73","0x40","0x00"} }, + { + /* No.715 delta:2154 weight:1395 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xfe7db2af,0x52a648d9,0xacdbfa76,0x7bd02cbc,0x85ad9e13,0x29766465,0xd70bd6ca,0x00006bc2,0xfe7dd96d,0x52a6231b,0xacdb91b4,0x7bd0477e,0x85adf5d1,0x29760fa7,0xd70bbd08}, + [16]uint32{0x00000000,0x1ac0ac96,0x528874ef,0x4848d879,0x089c4212,0x125cee84,0x5a1436fd,0x40d49a6b,0x90680015,0x8aa8ac83,0xc2e074fa,0xd820d86c,0x98f44207,0x8234ee91,0xca7c36e8,0xd0bc9a7e}, + [16]uint32{0x3f800000,0x3f8d6056,0x3fa9443a,0x3fa4246c,0x3f844e21,0x3f892e77,0x3fad0a1b,0x3fa06a4d,0x3fc83400,0x3fc55456,0x3fe1703a,0x3fec106c,0x3fcc7a21,0x3fc11a77,0x3fe53e1b,0x3fe85e4d}, + uint32(0xfff80000), + [21]string{"0x3f","0x51","0xd0","0x6e","0x1f","0xf0","0xb7","0x2b","0x01","0x11","0xd1","0x7e","0x50","0x28","0x42","0x84","0xbc","0xf7","0x57","0x30","0x00"} }, + { + /* No.716 delta:1054 weight:1583 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xafbe3c4c,0xbfeb6190,0x10555ddc,0xfe302cce,0x518e1082,0x41db4d5e,0xee657112,0x0000e99b,0xafbed5d7,0xbfeb880b,0x1055b447,0xfe30c555,0x518ef919,0x41dba4c5,0xee659889}, + [16]uint32{0x00000000,0x4004781c,0x80035399,0xc0072b85,0x20024016,0x6006380a,0xa001138f,0xe0056b93,0x20012103,0x6005591f,0xa002729a,0xe0060a86,0x00036115,0x40071909,0x8000328c,0xc0044a90}, + [16]uint32{0x3f800000,0x3fa0023c,0x3fc001a9,0x3fe00395,0x3f900120,0x3fb0031c,0x3fd00089,0x3ff002b5,0x3f900090,0x3fb002ac,0x3fd00139,0x3ff00305,0x3f8001b0,0x3fa0038c,0x3fc00019,0x3fe00225}, + uint32(0xfff80000), + [21]string{"0xed","0x74","0x8b","0xb0","0x4e","0xc2","0x0a","0x82","0x8d","0x6f","0x44","0x09","0x04","0x9d","0x89","0xa6","0x97","0x1b","0x37","0xec","0x00"} }, + { + /* No.717 delta:1418 weight:1007 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x3c23cb1d,0x69b35404,0x55909f19,0xade02cda,0x91c3e7c7,0xc45378de,0xf870b3c3,0x0000292f,0x3c23e232,0x69b37d2b,0x5590b636,0xade005f5,0x91c3cee8,0xc45351f1,0xf8709aec}, + [16]uint32{0x00000000,0x00ac81b2,0x1054813e,0x10f8008c,0x00600017,0x00cc81a5,0x10348129,0x1098009b,0x0011014a,0x00bd80f8,0x10458074,0x10e901c6,0x0071015d,0x00dd80ef,0x10258063,0x108901d1}, + [16]uint32{0x3f800000,0x3f805640,0x3f882a40,0x3f887c00,0x3f803000,0x3f806640,0x3f881a40,0x3f884c00,0x3f800880,0x3f805ec0,0x3f8822c0,0x3f887480,0x3f803880,0x3f806ec0,0x3f8812c0,0x3f884480}, + uint32(0xfff80000), + [21]string{"0xb7","0x05","0x1d","0x4f","0x98","0x88","0x8e","0x9c","0xae","0x16","0x64","0x7c","0x3e","0x6c","0x97","0xe3","0x0b","0x1b","0xa4","0xde","0x00"} }, + { + /* No.718 delta:820 weight:1629 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x9112c5eb,0x969abab1,0x07887f5a,0xffb02cec,0x6ea2e907,0x692a965d,0xf83853b6,0x0000032f,0x9112c6c4,0x969ab99e,0x07887c75,0xffb02fc3,0x6ea2ea28,0x692a9572,0xf8385099}, + [16]uint32{0x00000000,0x400473f2,0x1002815f,0x5006f2ad,0x30004015,0x700433e7,0x2002c14a,0x6006b2b8,0x00016a4e,0x400519bc,0x1003eb11,0x500798e3,0x30012a5b,0x700559a9,0x2003ab04,0x6007d8f6}, + [16]uint32{0x3f800000,0x3fa00239,0x3f880140,0x3fa80379,0x3f980020,0x3fb80219,0x3f900160,0x3fb00359,0x3f8000b5,0x3fa0028c,0x3f8801f5,0x3fa803cc,0x3f980095,0x3fb802ac,0x3f9001d5,0x3fb003ec}, + uint32(0xfff80000), + [21]string{"0x11","0x9b","0x2d","0x90","0x6a","0xf0","0xb5","0x99","0xb3","0x87","0xea","0x84","0xcd","0xba","0x5b","0x63","0x16","0xab","0x2b","0x28","0x00"} }, + { + /* No.719 delta:669 weight:1297 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x9c78eb92,0xb6d3e0ee,0x2aab0b7c,0x1dd02cf9,0x81a8c76b,0xab03cc17,0x377b2785,0x00009201,0x9c787993,0xb6d372ef,0x2aab997d,0x1dd0bef8,0x81a8556a,0xab035e16,0x377bb584}, + [16]uint32{0x00000000,0x00424855,0x46012276,0x46436a23,0x60042872,0x60466027,0x26050a04,0x26474251,0x0002858d,0x0040cdd8,0x4603a7fb,0x4641efae,0x6006adff,0x6044e5aa,0x26078f89,0x2645c7dc}, + [16]uint32{0x3f800000,0x3f802124,0x3fa30091,0x3fa321b5,0x3fb00214,0x3fb02330,0x3f930285,0x3f9323a1,0x3f800142,0x3f802066,0x3fa301d3,0x3fa320f7,0x3fb00356,0x3fb02272,0x3f9303c7,0x3f9322e3}, + uint32(0xfff80000), + [21]string{"0x77","0xf5","0x31","0x2a","0xb8","0xb1","0x26","0x31","0x52","0x1a","0x03","0xae","0x16","0xbf","0x19","0xf4","0x56","0x71","0xd8","0x18","0x00"} }, + { + /* No.720 delta:2860 weight:815 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0x2a128739,0x46c0915b,0x6cd21662,0xcac02d0e,0xe0d2aa37,0x8c00bc55,0xa6123b6c,0x00009c35,0x2a121b0c,0x46c00d6e,0x6cd28a57,0xcac0b13b,0xe0d23602,0x8c002060,0xa612a759}, + [16]uint32{0x00000000,0x498a89ff,0x94e0c209,0xdd6a4bf6,0x242688cd,0x6dac0132,0xb0c64ac4,0xf94cc33b,0x80902208,0xc91aabf7,0x1470e001,0x5dfa69fe,0xa4b6aac5,0xed3c233a,0x305668cc,0x79dce133}, + [16]uint32{0x3f800000,0x3fa4c544,0x3fca7061,0x3feeb525,0x3f921344,0x3fb6d600,0x3fd86325,0x3ffca661,0x3fc04811,0x3fe48d55,0x3f8a3870,0x3faefd34,0x3fd25b55,0x3ff69e11,0x3f982b34,0x3fbcee70}, + uint32(0xfff80000), + [21]string{"0xe3","0x70","0x35","0xc4","0x4d","0x27","0xea","0x55","0xe1","0x72","0xd8","0x77","0xae","0xf9","0x9e","0xc8","0xe4","0x05","0x0d","0x33","0x00"} }, + { + /* No.721 delta:1691 weight:1497 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0xe0c7a9c5,0xb5861ea4,0x5541b761,0x04d02d1d,0xe41784d8,0xb15633b9,0x51919a7c,0x0000a95f,0xe0c7009a,0xb586b7fb,0x55411e3e,0x04d08442,0xe4172d87,0xb1569ae6,0x51913323}, + [16]uint32{0x00000000,0x487581bb,0x0003014f,0x487680f4,0x00000111,0x487580aa,0x0003005e,0x487681e5,0x30128016,0x786701ad,0x30118159,0x786400e2,0x30128107,0x786700bc,0x30118048,0x786401f3}, + [16]uint32{0x3f800000,0x3fa43ac0,0x3f800180,0x3fa43b40,0x3f800000,0x3fa43ac0,0x3f800180,0x3fa43b40,0x3f980940,0x3fbc3380,0x3f9808c0,0x3fbc3200,0x3f980940,0x3fbc3380,0x3f9808c0,0x3fbc3200}, + uint32(0xfff80000), + [21]string{"0x3d","0x2f","0x3d","0x73","0x83","0x23","0x81","0xa8","0x1b","0x84","0x18","0x04","0xd6","0xb6","0x8d","0x28","0x1d","0x88","0x24","0x3f","0x00"} }, + { + /* No.722 delta:1154 weight:1387 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0xca209038,0x73a5c6f7,0xb98556cf,0xd9002d2b,0x1320bd13,0xaaa5ebdc,0x60857be4,0x00009a5f,0xca200a67,0x73a55ca8,0xb985cc90,0xd900b774,0x1320274c,0xaaa57183,0x6085e1bb}, + [16]uint32{0x00000000,0x00406b96,0x203c20fa,0x207c4b6c,0x20034212,0x20432984,0x003f62e8,0x007f097e,0x000304bb,0x00436f2d,0x203f2441,0x207f4fd7,0x200046a9,0x20402d3f,0x003c6653,0x007c0dc5}, + [16]uint32{0x3f800000,0x3f802035,0x3f901e10,0x3f903e25,0x3f9001a1,0x3f902194,0x3f801fb1,0x3f803f84,0x3f800182,0x3f8021b7,0x3f901f92,0x3f903fa7,0x3f900023,0x3f902016,0x3f801e33,0x3f803e06}, + uint32(0xfff80000), + [21]string{"0x24","0x7f","0x31","0xb7","0xd4","0x8a","0xfa","0x36","0x05","0x16","0xcb","0x7e","0xb9","0xed","0xf6","0xd2","0xe7","0xcc","0x3f","0xc9","0x00"} }, + { + /* No.723 delta:836 weight:1099 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x8f8a6d9c,0xf0241420,0x7fae79bc,0xe5302d3f,0x6aba40a3,0x1514391f,0x9a9e5483,0x00006eb0,0x8f8a032c,0xf0247a90,0x7fae170c,0xe530438f,0x6aba2e13,0x151457af,0x9a9e3a33}, + [16]uint32{0x00000000,0x0803c416,0x7003e19b,0x7800258d,0x2021024e,0x2822c658,0x5022e3d5,0x582127c3,0x70001324,0x7803d732,0x0003f2bf,0x080036a9,0x5021116a,0x5822d57c,0x2022f0f1,0x282134e7}, + [16]uint32{0x3f800000,0x3f8401e2,0x3fb801f0,0x3fbc0012,0x3f901081,0x3f941163,0x3fa81171,0x3fac1093,0x3fb80009,0x3fbc01eb,0x3f8001f9,0x3f84001b,0x3fa81088,0x3fac116a,0x3f901178,0x3f94109a}, + uint32(0xfff80000), + [21]string{"0x2b","0xec","0x0b","0x9a","0xca","0xbd","0x0d","0x5d","0xb6","0x58","0x00","0xb4","0x2d","0xfc","0x55","0x43","0xb4","0x4d","0xbb","0xee","0x00"} }, + { + /* No.724 delta:857 weight:1705 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0xf02ccf1e,0x34ba0cac,0xc496c3b2,0xded02d40,0x2efce25e,0xea6a21ec,0x1a46eef2,0x000099b4,0xf02c56aa,0x34ba9518,0xc4965a06,0xded0b4f4,0x2efc7bea,0xea6ab858,0x1a467746}, + [16]uint32{0x00000000,0x2000203b,0x1000f069,0x3000d052,0x020140f5,0x220160ce,0x1201b09c,0x320190a7,0x4046815e,0x6046a165,0x50467137,0x7046510c,0x4247c1ab,0x6247e190,0x524731c2,0x724711f9}, + [16]uint32{0x3f800000,0x3f900010,0x3f880078,0x3f980068,0x3f8100a0,0x3f9100b0,0x3f8900d8,0x3f9900c8,0x3fa02340,0x3fb02350,0x3fa82338,0x3fb82328,0x3fa123e0,0x3fb123f0,0x3fa92398,0x3fb92388}, + uint32(0xfff80000), + [21]string{"0x28","0x73","0x99","0x4b","0xde","0x9b","0xb6","0xb5","0x7e","0x65","0xf8","0x6f","0x75","0xc9","0x01","0x0d","0x9d","0x56","0x10","0xa4","0x00"} }, + { + /* No.725 delta:1512 weight:1635 */ + 11213, + 15, + 13, + 4, + [16]uint32{0x00000000,0x6db36d1f,0x504286cf,0x3df1ebd0,0x88c02d58,0xe5734047,0xd882ab97,0xb531c688,0x00002e4d,0x6db34352,0x5042a882,0x3df1c59d,0x88c00315,0xe5736e0a,0xd88285da,0xb531e8c5}, + [16]uint32{0x00000000,0x21b4a5f2,0x801c046d,0xa1a8a19f,0x00438c39,0x21f729cb,0x805f8854,0xa1eb2da6,0x4110481c,0x60a4edee,0xc10c4c71,0xe0b8e983,0x4153c425,0x60e761d7,0xc14fc048,0xe0fb65ba}, + [16]uint32{0x3f800000,0x3f90da52,0x3fc00e02,0x3fd0d450,0x3f8021c6,0x3f90fb94,0x3fc02fc4,0x3fd0f596,0x3fa08824,0x3fb05276,0x3fe08626,0x3ff05c74,0x3fa0a9e2,0x3fb073b0,0x3fe0a7e0,0x3ff07db2}, + uint32(0xfff80000), + [21]string{"0x96","0xec","0x77","0x29","0xfd","0xd0","0x3b","0x05","0x39","0x49","0x17","0x56","0xd8","0xc4","0x71","0x3a","0x7f","0x44","0x97","0x3c","0x00"} }, + { + /* No.726 delta:759 weight:1721 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0xc7d4366f,0x28c69961,0xef12af0e,0x79d02d6e,0xbe041b01,0x5116b40f,0x96c28260,0x00004364,0xc7d4750b,0x28c6da05,0xef12ec6a,0x79d06e0a,0xbe045865,0x5116f76b,0x96c2c104}, + [16]uint32{0x00000000,0x4c02195f,0x40001802,0x0c02015d,0x50021008,0x1c000957,0x1002080a,0x5c001155,0x2011001b,0x6c131944,0x60111819,0x2c130146,0x70131013,0x3c11094c,0x30130811,0x7c11114e}, + [16]uint32{0x3f800000,0x3fa6010c,0x3fa0000c,0x3f860100,0x3fa80108,0x3f8e0004,0x3f880104,0x3fae0008,0x3f900880,0x3fb6098c,0x3fb0088c,0x3f960980,0x3fb80988,0x3f9e0884,0x3f980984,0x3fbe0888}, + uint32(0xfff80000), + [21]string{"0x99","0x25","0xe3","0x79","0xb6","0x96","0xff","0x0e","0x9c","0x45","0xa9","0xab","0x0e","0x11","0x40","0x68","0x75","0xc5","0x85","0xb1","0x00"} }, + { + /* No.727 delta:592 weight:1695 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0x362c9c20,0x77692b6a,0x4145b74a,0x36f02d7f,0x00dcb15f,0x41990615,0x77b59a35,0x000028de,0x362cb4fe,0x776903b4,0x41459f94,0x36f005a1,0x00dc9981,0x41992ecb,0x77b5b2eb}, + [16]uint32{0x00000000,0x6002d8fa,0x0100300d,0x6102e8f7,0xe1008019,0x810258e3,0xe000b014,0x800268ee,0x50038412,0x30015ce8,0x5103b41f,0x31016ce5,0xb103040b,0xd101dcf1,0xb0033406,0xd001ecfc}, + [16]uint32{0x3f800000,0x3fb0016c,0x3f808018,0x3fb08174,0x3ff08040,0x3fc0812c,0x3ff00058,0x3fc00134,0x3fa801c2,0x3f9800ae,0x3fa881da,0x3f9880b6,0x3fd88182,0x3fe880ee,0x3fd8019a,0x3fe800f6}, + uint32(0xfff80000), + [21]string{"0x22","0xc6","0x11","0x96","0xb7","0x8b","0x4d","0x63","0x57","0x72","0x66","0x8e","0x64","0xc0","0xa5","0x18","0xb3","0x72","0x41","0x0b","0x00"} }, + { + /* No.728 delta:922 weight:1745 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xbd4db67b,0xea6c891a,0x57213f61,0xa7002d80,0x1a4d9bfb,0x4d6ca49a,0xf02112e1,0x00007d13,0xbd4dcb68,0xea6cf409,0x57214272,0xa7005093,0x1a4de6e8,0x4d6cd989,0xf0216ff2}, + [16]uint32{0x00000000,0x0813393e,0x00038d9d,0x0810b4a3,0x00027386,0x08114ab8,0x0001fe1b,0x0812c725,0x8050db79,0x8843e247,0x805356e4,0x88406fda,0x8052a8ff,0x884191c1,0x80512562,0x88421c5c}, + [16]uint32{0x3f800000,0x3f84099c,0x3f8001c6,0x3f84085a,0x3f800139,0x3f8408a5,0x3f8000ff,0x3f840963,0x3fc0286d,0x3fc421f1,0x3fc029ab,0x3fc42037,0x3fc02954,0x3fc420c8,0x3fc02892,0x3fc4210e}, + uint32(0xfff80000), + [21]string{"0x98","0x00","0x4c","0x9b","0xd6","0x72","0xea","0x9a","0xdb","0xb0","0x70","0xa0","0xb4","0x3c","0x76","0x55","0xc4","0xe1","0x43","0xa2","0x00"} }, + { + /* No.729 delta:841 weight:1487 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0x0f9aaea3,0xfca4ace6,0xf33e0245,0xed202d9b,0xe2ba8338,0x1184817d,0x1e1e2fde,0x000093ab,0x0f9a3d08,0xfca43f4d,0xf33e91ee,0xed20be30,0xe2ba1093,0x118412d6,0x1e1ebc75}, + [16]uint32{0x00000000,0xb01001fe,0x50002144,0xe01020ba,0x100201e2,0xa012001c,0x400220a6,0xf0122158,0x20001811,0x901019ef,0x70003955,0xc01038ab,0x300219f3,0x8012180d,0x600238b7,0xd0123949}, + [16]uint32{0x3f800000,0x3fd80800,0x3fa80010,0x3ff00810,0x3f880100,0x3fd00900,0x3fa00110,0x3ff80910,0x3f90000c,0x3fc8080c,0x3fb8001c,0x3fe0081c,0x3f98010c,0x3fc0090c,0x3fb0011c,0x3fe8091c}, + uint32(0xfff80000), + [21]string{"0xe6","0xa3","0x9a","0x05","0x35","0x58","0xf0","0x5a","0xe5","0xcc","0x22","0xed","0x5a","0x3f","0x5c","0xbf","0xe1","0x9f","0x78","0x4d","0x00"} }, + { + /* No.730 delta:905 weight:743 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0xc8ebe93e,0x7ac72e91,0xb22cc7af,0xc4a02da2,0x0c4bc49c,0xbe670333,0x768cea0d,0x0000ffff,0xc8eb16c1,0x7ac7d16e,0xb22c3850,0xc4a0d25d,0x0c4b3b63,0xbe67fccc,0x768c15f2}, + [16]uint32{0x00000000,0x8048043a,0x3051599c,0xb0195da6,0x10140012,0x905c0428,0x2045598e,0xa00d5db4,0x8024886d,0x006c8c57,0xb075d1f1,0x303dd5cb,0x9030887f,0x10788c45,0xa061d1e3,0x2029d5d9}, + [16]uint32{0x3f800000,0x3fc02402,0x3f9828ac,0x3fd80cae,0x3f880a00,0x3fc82e02,0x3f9022ac,0x3fd006ae,0x3fc01244,0x3f803646,0x3fd83ae8,0x3f981eea,0x3fc81844,0x3f883c46,0x3fd030e8,0x3f9014ea}, + uint32(0xfff80000), + [21]string{"0xd5","0xad","0x91","0x23","0xb9","0x14","0x30","0x2e","0x1f","0x13","0x85","0x35","0xfe","0x97","0x90","0xc7","0x02","0xcb","0xfd","0x1d","0x00"} }, + { + /* No.731 delta:1036 weight:1413 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x0bf6c4fb,0xdf105bcf,0xd4e69f34,0xed302dba,0xe6c6e941,0x32207675,0x39d6b28e,0x00007cd0,0x0bf6b82b,0xdf10271f,0xd4e6e3e4,0xed30516a,0xe6c69591,0x32200aa5,0x39d6ce5e}, + [16]uint32{0x00000000,0x402c4d5a,0x0072c149,0x405e8c13,0x00029217,0x402edf4d,0x0070535e,0x405c1e04,0x6028005c,0x20044d06,0x605ac115,0x20768c4f,0x602a924b,0x2006df11,0x60585302,0x20741e58}, + [16]uint32{0x3f800000,0x3fa01626,0x3f803960,0x3fa02f46,0x3f800149,0x3fa0176f,0x3f803829,0x3fa02e0f,0x3fb01400,0x3f900226,0x3fb02d60,0x3f903b46,0x3fb01549,0x3f90036f,0x3fb02c29,0x3f903a0f}, + uint32(0xfff80000), + [21]string{"0x83","0x3b","0x97","0xcc","0xa0","0xd0","0xa8","0x3d","0x8f","0xf8","0x5f","0xfb","0xd6","0x88","0xb8","0xfa","0x32","0x3d","0xf5","0x96","0x00"} }, + { + /* No.732 delta:822 weight:1581 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x6553c7b0,0xca67c2c8,0xaf340578,0x1df02dc2,0x78a3ea72,0xd797ef0a,0xb2c428ba,0x00009c81,0x65535b31,0xca675e49,0xaf3499f9,0x1df0b143,0x78a376f3,0xd797738b,0xb2c4b43b}, + [16]uint32{0x00000000,0x0122011e,0x100225c3,0x112024dd,0x10013006,0x11233118,0x000315c5,0x012114db,0x0041801a,0x01638104,0x1043a5d9,0x1161a4c7,0x1040b01c,0x1162b102,0x004295df,0x016094c1}, + [16]uint32{0x3f800000,0x3f809100,0x3f880112,0x3f889012,0x3f880098,0x3f889198,0x3f80018a,0x3f80908a,0x3f8020c0,0x3f80b1c0,0x3f8821d2,0x3f88b0d2,0x3f882058,0x3f88b158,0x3f80214a,0x3f80b04a}, + uint32(0xfff80000), + [21]string{"0xb7","0x1c","0xd7","0x84","0xd3","0x48","0x2d","0x54","0xf9","0x0b","0x4b","0x07","0x1b","0x72","0xac","0x2c","0x81","0x93","0xe5","0x76","0x00"} }, + { + /* No.733 delta:1410 weight:1587 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0xc44776d8,0xb6a8315e,0x72ef4786,0xb0302dda,0x74775b02,0x06981c84,0xc2df6a5c,0x00003f80,0xc4474958,0xb6a80ede,0x72ef7806,0xb030125a,0x74776482,0x06982304,0xc2df55dc}, + [16]uint32{0x00000000,0x2974c045,0x120489b6,0x3b7049f3,0x007a01f8,0x290ec1bd,0x127e884e,0x3b0a480b,0x00e8421e,0x299c825b,0x12eccba8,0x3b980bed,0x009243e6,0x29e683a3,0x1296ca50,0x3be20a15}, + [16]uint32{0x3f800000,0x3f94ba60,0x3f890244,0x3f9db824,0x3f803d00,0x3f948760,0x3f893f44,0x3f9d8524,0x3f807421,0x3f94ce41,0x3f897665,0x3f9dcc05,0x3f804921,0x3f94f341,0x3f894b65,0x3f9df105}, + uint32(0xfff80000), + [21]string{"0xa9","0x61","0x59","0x1b","0xc9","0xa2","0xb9","0x98","0xdf","0x17","0x2a","0x2b","0x89","0xe8","0x96","0x34","0xfd","0xcd","0xbb","0x42","0x00"} }, + { + /* No.734 delta:1846 weight:1417 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0xb0e7ff5a,0xb90cb420,0x09eb4b7a,0x86b02deb,0x3657d2b1,0x3fbc99cb,0x8f5b6691,0x00001060,0xb0e7ef3a,0xb90ca440,0x09eb5b1a,0x86b03d8b,0x3657c2d1,0x3fbc89ab,0x8f5b76f1}, + [16]uint32{0x00000000,0x8511e4b6,0x407a817f,0xc56b65c9,0x50126a0e,0xd5038eb8,0x1068eb71,0x95790fc7,0x18096214,0x9d1886a2,0x5873e36b,0xdd6207dd,0x481b081a,0xcd0aecac,0x08618965,0x8d706dd3}, + [16]uint32{0x3f800000,0x3fc288f2,0x3fa03d40,0x3fe2b5b2,0x3fa80935,0x3fea81c7,0x3f883475,0x3fcabc87,0x3f8c04b1,0x3fce8c43,0x3fac39f1,0x3feeb103,0x3fa40d84,0x3fe68576,0x3f8430c4,0x3fc6b836}, + uint32(0xfff80000), + [21]string{"0xe6","0xd1","0x6a","0xb3","0xd3","0x6a","0x3c","0xd4","0x60","0xf9","0x71","0x92","0xca","0x31","0xeb","0x82","0xb9","0xfe","0x4f","0xc2","0x00"} }, + { + /* No.735 delta:2475 weight:1071 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0xadfe4796,0xa371aa39,0x0e8fedaf,0x50602df5,0xfd9e6a63,0xf31187cc,0x5eefc05a,0x00000a3c,0xadfe4daa,0xa371a005,0x0e8fe793,0x506027c9,0xfd9e605f,0xf3118df0,0x5eefca66}, + [16]uint32{0x00000000,0xa743b892,0x0931020f,0xae72ba9d,0x21e08814,0x86a33086,0x28d18a1b,0x8f923289,0x806a001c,0x2729b88e,0x895b0213,0x2e18ba81,0xa18a8808,0x06c9309a,0xa8bb8a07,0x0ff83295}, + [16]uint32{0x3f800000,0x3fd3a1dc,0x3f849881,0x3fd7395d,0x3f90f044,0x3fc35198,0x3f9468c5,0x3fc7c919,0x3fc03500,0x3f9394dc,0x3fc4ad81,0x3f970c5d,0x3fd0c544,0x3f836498,0x3fd45dc5,0x3f87fc19}, + uint32(0xfff80000), + [21]string{"0x39","0x1d","0x79","0xdb","0xb2","0xd7","0x5c","0xb1","0xf2","0xc1","0xb7","0xf3","0x36","0x29","0xb8","0x43","0x70","0xaf","0xd2","0xb9","0x00"} }, + { + /* No.736 delta:716 weight:1529 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xb985165a,0xedf3e2ed,0x5476f4b7,0x82b02e05,0x3b35385f,0x6f43cce8,0xd6c6dab2,0x0000cd45,0xb985db1f,0xedf32fa8,0x547639f2,0x82b0e340,0x3b35f51a,0x6f4301ad,0xd6c617f7}, + [16]uint32{0x00000000,0x0042b41a,0x2800c155,0x2842754f,0xb02006dc,0xb062b2c6,0x9820c789,0x98627393,0x4000201b,0x40429401,0x6800e14e,0x68425554,0xf02026c7,0xf06292dd,0xd820e792,0xd8625388}, + [16]uint32{0x3f800000,0x3f80215a,0x3f940060,0x3f94213a,0x3fd81003,0x3fd83159,0x3fcc1063,0x3fcc3139,0x3fa00010,0x3fa0214a,0x3fb40070,0x3fb4212a,0x3ff81013,0x3ff83149,0x3fec1073,0x3fec3129}, + uint32(0xfff80000), + [21]string{"0x72","0x67","0x24","0x01","0xcd","0x16","0x85","0x06","0x88","0x93","0x31","0x0b","0xcd","0xd9","0xc1","0x40","0xa4","0xaf","0x17","0x16","0x00"} }, + { + /* No.737 delta:1000 weight:1433 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x4348dab8,0xb2c6cf40,0xf18e15f8,0xb7802e1b,0xf4c8f4a3,0x0546e15b,0x460e3be3,0x000057cf,0x43488d77,0xb2c6988f,0xf18e4237,0xb78079d4,0xf4c8a36c,0x0546b694,0x460e6c2c}, + [16]uint32{0x00000000,0x106040f6,0x0054754a,0x103435bc,0x000360c3,0x10632035,0x00571589,0x1037557f,0x042c8078,0x144cc08e,0x0478f532,0x1418b5c4,0x042fe0bb,0x144fa04d,0x047b95f1,0x141bd507}, + [16]uint32{0x3f800000,0x3f883020,0x3f802a3a,0x3f881a1a,0x3f8001b0,0x3f883190,0x3f802b8a,0x3f881baa,0x3f821640,0x3f8a2660,0x3f823c7a,0x3f8a0c5a,0x3f8217f0,0x3f8a27d0,0x3f823dca,0x3f8a0dea}, + uint32(0xfff80000), + [21]string{"0x1b","0x62","0x03","0xc1","0xba","0xe1","0x85","0x55","0xb2","0x0c","0xf7","0xc4","0x92","0xe4","0x04","0x94","0x45","0xbb","0xaf","0x83","0x00"} }, + { + /* No.738 delta:1086 weight:1481 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x2668eeaa,0x2fba33c8,0x09d2dd62,0x8aa02e21,0xacc8c08b,0xa51a1de9,0x8372f343,0x0000982b,0x26687681,0x2fbaabe3,0x09d24549,0x8aa0b60a,0xacc858a0,0xa51a85c2,0x83726b68}, + [16]uint32{0x00000000,0x403ced1e,0x4051520f,0x006dbf11,0x20218e03,0x601d631d,0x6070dc0c,0x204c3112,0x000a61e4,0x40368cfa,0x405b33eb,0x0067def5,0x202befe7,0x601702f9,0x607abde8,0x204650f6}, + [16]uint32{0x3f800000,0x3fa01e76,0x3fa028a9,0x3f8036df,0x3f9010c7,0x3fb00eb1,0x3fb0386e,0x3f902618,0x3f800530,0x3fa01b46,0x3fa02d99,0x3f8033ef,0x3f9015f7,0x3fb00b81,0x3fb03d5e,0x3f902328}, + uint32(0xfff80000), + [21]string{"0x2b","0x14","0x6e","0xa9","0x8e","0xd7","0xe6","0xd2","0x13","0x5b","0xaa","0x5a","0xc1","0x62","0x78","0x7d","0xa7","0xa1","0x50","0xa8","0x00"} }, + { + /* No.739 delta:664 weight:1561 */ + 11213, + 80, + 13, + 4, + [16]uint32{0x00000000,0x9e463afc,0x2fed8630,0xb1abbccc,0x40f02e3c,0xdeb614c0,0x6f1da80c,0xf15b92f0,0x00005e46,0x9e4664ba,0x2fedd876,0xb1abe28a,0x40f0707a,0xdeb64a86,0x6f1df64a,0xf15bccb6}, + [16]uint32{0x00000000,0x3003841b,0x000240cf,0x3001c4d4,0x1000481d,0x2003cc06,0x100208d2,0x20018cc9,0x04003401,0x3403b01a,0x040274ce,0x3401f0d5,0x14007c1c,0x2403f807,0x14023cd3,0x2401b8c8}, + [16]uint32{0x3f800000,0x3f9801c2,0x3f800120,0x3f9800e2,0x3f880024,0x3f9001e6,0x3f880104,0x3f9000c6,0x3f82001a,0x3f9a01d8,0x3f82013a,0x3f9a00f8,0x3f8a003e,0x3f9201fc,0x3f8a011e,0x3f9200dc}, + uint32(0xfff80000), + [21]string{"0xeb","0xb2","0xa2","0x3b","0x29","0xa9","0x79","0xd3","0x77","0x5a","0xb9","0x45","0xf0","0xce","0x90","0x4a","0x6e","0x43","0xd3","0x31","0x00"} }, + { + /* No.740 delta:823 weight:729 */ + 11213, + 88, + 13, + 4, + [16]uint32{0x00000000,0x2df9dab0,0x36db7996,0x1b22a326,0x96202e43,0xbbd9f4f3,0xa0fb57d5,0x8d028d65,0x0000ad61,0x2df977d1,0x36dbd4f7,0x1b220e47,0x96208322,0xbbd95992,0xa0fbfab4,0x8d022004}, + [16]uint32{0x00000000,0xa048ee12,0x0069871c,0xa021690e,0x4340120b,0xe308fc19,0x43299517,0xe3617b05,0xa5426c0d,0x050a821f,0xa52beb11,0x05630503,0xe6027e06,0x464a9014,0xe66bf91a,0x46231708}, + [16]uint32{0x3f800000,0x3fd02477,0x3f8034c3,0x3fd010b4,0x3fa1a009,0x3ff1847e,0x3fa194ca,0x3ff1b0bd,0x3fd2a136,0x3f828541,0x3fd295f5,0x3f82b182,0x3ff3013f,0x3fa32548,0x3ff335fc,0x3fa3118b}, + uint32(0xfff80000), + [21]string{"0x33","0x6e","0x8f","0xe1","0xb2","0x21","0x56","0x65","0xe5","0xbc","0x01","0x3d","0x33","0x2e","0x33","0x03","0x1f","0xce","0x5e","0x84","0x00"} }, + { + /* No.741 delta:818 weight:1265 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x790b895a,0x7c905d86,0x059bd4dc,0x23b02e5e,0x5abba704,0x5f2073d8,0x262bfa82,0x00003ab4,0x790bb3ee,0x7c906732,0x059bee68,0x23b014ea,0x5abb9db0,0x5f20496c,0x262bc036}, + [16]uint32{0x00000000,0x0065e415,0x8412002b,0x8477e43e,0x00021052,0x0067f447,0x84101079,0x8475f46c,0x40684809,0x400dac1c,0xc47a4822,0xc41fac37,0x406a585b,0x400fbc4e,0xc4785870,0xc41dbc65}, + [16]uint32{0x3f800000,0x3f8032f2,0x3fc20900,0x3fc23bf2,0x3f800108,0x3f8033fa,0x3fc20808,0x3fc23afa,0x3fa03424,0x3fa006d6,0x3fe23d24,0x3fe20fd6,0x3fa0352c,0x3fa007de,0x3fe23c2c,0x3fe20ede}, + uint32(0xfff80000), + [21]string{"0x68","0x46","0xd3","0x03","0x4a","0x57","0x92","0x46","0x61","0x92","0x43","0xe0","0x2f","0x44","0x8e","0x38","0xc7","0x76","0x71","0x3c","0x00"} }, + { + /* No.742 delta:1000 weight:1215 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0xb63840f5,0x5d974ebf,0xebaf0e4a,0x93a02e62,0x25986e97,0xce3760dd,0x780f2028,0x0000405f,0xb63800aa,0x5d970ee0,0xebaf4e15,0x93a06e3d,0x25982ec8,0xce372082,0x780f6077}, + [16]uint32{0x00000000,0x08016772,0x50200011,0x58216763,0x9001bc1c,0x9800db6e,0xc021bc0d,0xc820db7f,0x400015da,0x480172a8,0x102015cb,0x182172b9,0xd001a9c6,0xd800ceb4,0x8021a9d7,0x8820cea5}, + [16]uint32{0x3f800000,0x3f8400b3,0x3fa81000,0x3fac10b3,0x3fc800de,0x3fcc006d,0x3fe010de,0x3fe4106d,0x3fa0000a,0x3fa400b9,0x3f88100a,0x3f8c10b9,0x3fe800d4,0x3fec0067,0x3fc010d4,0x3fc41067}, + uint32(0xfff80000), + [21]string{"0xeb","0xaf","0x0f","0x23","0xc7","0x79","0x23","0x49","0xe6","0xf5","0x00","0xc0","0x07","0xb4","0x5f","0xcd","0x17","0x90","0x88","0xc9","0x00"} }, + { + /* No.743 delta:787 weight:1499 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x196bf88a,0xe0990c1f,0xf9f2f495,0x9d202e77,0x844bd6fd,0x7db92268,0x64d2dae2,0x00004be7,0x196bb36d,0xe09947f8,0xf9f2bf72,0x9d206590,0x844b9d1a,0x7db9698f,0x64d29105}, + [16]uint32{0x00000000,0x4071a3d7,0x500c1671,0x107db5a6,0x00411209,0x4030b1de,0x504d0478,0x103ca7af,0x0002001c,0x4073a3cb,0x500e166d,0x107fb5ba,0x00431215,0x4032b1c2,0x504f0464,0x103ea7b3}, + [16]uint32{0x3f800000,0x3fa038d1,0x3fa8060b,0x3f883eda,0x3f802089,0x3fa01858,0x3fa82682,0x3f881e53,0x3f800100,0x3fa039d1,0x3fa8070b,0x3f883fda,0x3f802189,0x3fa01958,0x3fa82782,0x3f881f53}, + uint32(0xfff80000), + [21]string{"0x64","0x9e","0x1e","0x3b","0x8b","0xb8","0xc5","0x56","0xf8","0x3d","0xf8","0xcc","0x45","0x12","0xb4","0xf8","0x16","0x73","0x1c","0x66","0x00"} }, + { + /* No.744 delta:1328 weight:1453 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x09404275,0x6a9808b1,0x63d84ac4,0x4c002e8e,0x45406cfb,0x2698263f,0x2fd8644a,0x00007727,0x09403552,0x6a987f96,0x63d83de3,0x4c0059a9,0x45401bdc,0x26985118,0x2fd8136d}, + [16]uint32{0x00000000,0x383444de,0x4006301c,0x783274c2,0x20029009,0x1836d4d7,0x6004a015,0x5830e4cb,0x0004e0ed,0x3830a433,0x4002d0f1,0x7836942f,0x200670e4,0x1832343a,0x600040f8,0x58340426}, + [16]uint32{0x3f800000,0x3f9c1a22,0x3fa00318,0x3fbc193a,0x3f900148,0x3f8c1b6a,0x3fb00250,0x3fac1872,0x3f800270,0x3f9c1852,0x3fa00168,0x3fbc1b4a,0x3f900338,0x3f8c191a,0x3fb00020,0x3fac1a02}, + uint32(0xfff80000), + [21]string{"0xb5","0xdb","0xe7","0xab","0x9a","0x9d","0xc1","0x9e","0x8d","0x73","0x1d","0x3a","0xcf","0x24","0x1a","0x54","0xb3","0xcb","0x09","0xac","0x00"} }, + { + /* No.745 delta:820 weight:925 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0x68c4353c,0xe9e86ef1,0x812c5bcd,0x50602e9e,0x38a41ba2,0xb988406f,0xd14c7553,0x00009943,0x68c4ac7f,0xe9e8f7b2,0x812cc28e,0x5060b7dd,0x38a482e1,0xb988d92c,0xd14cec10}, + [16]uint32{0x00000000,0x687d741e,0x4003c497,0x287eb089,0x5822619b,0x305f1585,0x1821a50c,0x705cd112,0x00020091,0x687f748f,0x4001c406,0x287cb018,0x5820610a,0x305d1514,0x1823a59d,0x705ed183}, + [16]uint32{0x3f800000,0x3fb43eba,0x3fa001e2,0x3f943f58,0x3fac1130,0x3f982f8a,0x3f8c10d2,0x3fb82e68,0x3f800100,0x3fb43fba,0x3fa000e2,0x3f943e58,0x3fac1030,0x3f982e8a,0x3f8c11d2,0x3fb82f68}, + uint32(0xfff80000), + [21]string{"0x79","0xa3","0xf9","0xc8","0xa6","0x34","0x0e","0x81","0xc5","0xbf","0x7e","0x81","0x88","0x5a","0x12","0x1a","0xa2","0xc6","0x3b","0xc0","0x00"} }, + { + /* No.746 delta:732 weight:1529 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0x93be21db,0x95f07927,0x064e58fc,0xc7002eaf,0x54be0f74,0x52f05788,0xc14e7653,0x000054f1,0x93be752a,0x95f02dd6,0x064e0c0d,0xc7007a5e,0x54be5b85,0x52f00379,0xc14e22a2}, + [16]uint32{0x00000000,0x6000d855,0x4002260a,0x2002fe5f,0x80008404,0xe0005c51,0xc002a20e,0xa0027a5b,0x0000199d,0x6000c1c8,0x40023f97,0x2002e7c2,0x80009d99,0xe00045cc,0xc002bb93,0xa00263c6}, + [16]uint32{0x3f800000,0x3fb0006c,0x3fa00113,0x3f90017f,0x3fc00042,0x3ff0002e,0x3fe00151,0x3fd0013d,0x3f80000c,0x3fb00060,0x3fa0011f,0x3f900173,0x3fc0004e,0x3ff00022,0x3fe0015d,0x3fd00131}, + uint32(0xfff80000), + [21]string{"0xce","0xd8","0x30","0xb3","0x7b","0xd1","0xe7","0xc7","0xd9","0x3a","0x7b","0xbd","0x6e","0xa2","0xf2","0x45","0xc2","0x88","0xa4","0xa1","0x00"} }, + { + /* No.747 delta:1133 weight:1553 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0xc6100b1d,0x744ae871,0xb25ae36c,0x2ef02eb1,0xe8e025ac,0x5abac6c0,0x9caacddd,0x00000996,0xc610028b,0x744ae1e7,0xb25aeafa,0x2ef02727,0xe8e02c3a,0x5abacf56,0x9caac44b}, + [16]uint32{0x00000000,0x0046f09a,0x620265d9,0x62449543,0x01020014,0x0144f08e,0x630065cd,0x63469557,0x100040ea,0x1046b070,0x72022533,0x7244d5a9,0x110240fe,0x1144b064,0x73002527,0x7346d5bd}, + [16]uint32{0x3f800000,0x3f802378,0x3fb10132,0x3fb1224a,0x3f808100,0x3f80a278,0x3fb18032,0x3fb1a34a,0x3f880020,0x3f882358,0x3fb90112,0x3fb9226a,0x3f888120,0x3f88a258,0x3fb98012,0x3fb9a36a}, + uint32(0xfff80000), + [21]string{"0xdc","0x97","0xd7","0x0a","0xf7","0xeb","0x23","0xa6","0x31","0x0d","0x07","0x1b","0x10","0x2f","0x6c","0x60","0x8b","0xe0","0x33","0x73","0x00"} }, + { + /* No.748 delta:1287 weight:1623 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xe931db10,0x2ddbfeb6,0xc4ea25a6,0x62a02ec7,0x8b91f5d7,0x4f7bd071,0xa64a0b61,0x0000cc53,0xe9311743,0x2ddb32e5,0xc4eae9f5,0x62a0e294,0x8b913984,0x4f7b1c22,0xa64ac732}, + [16]uint32{0x00000000,0x004280d2,0x6020e60c,0x606266de,0x20c8041a,0x208a84c8,0x40e8e216,0x40aa62c4,0x8424181b,0x846698c9,0xe404fe17,0xe4467ec5,0xa4ec1c01,0xa4ae9cd3,0xc4ccfa0d,0xc48e7adf}, + [16]uint32{0x3f800000,0x3f802140,0x3fb01073,0x3fb03133,0x3f906402,0x3f904542,0x3fa07471,0x3fa05531,0x3fc2120c,0x3fc2334c,0x3ff2027f,0x3ff2233f,0x3fd2760e,0x3fd2574e,0x3fe2667d,0x3fe2473d}, + uint32(0xfff80000), + [21]string{"0x0e","0x6e","0x4a","0xeb","0xd4","0x8d","0xdc","0x3a","0x42","0x57","0xe5","0x66","0x54","0x22","0x92","0xd3","0x99","0x5d","0xf1","0x2d","0x00"} }, + { + /* No.749 delta:867 weight:1183 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xd60e9140,0x97657349,0x416be209,0x7ea02ed8,0xa8aebf98,0xe9c55d91,0x3fcbccd1,0x00008b87,0xd60e1ac7,0x9765f8ce,0x416b698e,0x7ea0a55f,0xa8ae341f,0xe9c5d616,0x3fcb4756}, + [16]uint32{0x00000000,0x205e71b2,0x40231007,0x607d61b5,0x0004c21e,0x205ab3ac,0x4027d219,0x6079a3ab,0x0002171d,0x205c66af,0x4021071a,0x607f76a8,0x0006d503,0x2058a4b1,0x4025c504,0x607bb4b6}, + [16]uint32{0x3f800000,0x3f902f38,0x3fa01188,0x3fb03eb0,0x3f800261,0x3f902d59,0x3fa013e9,0x3fb03cd1,0x3f80010b,0x3f902e33,0x3fa01083,0x3fb03fbb,0x3f80036a,0x3f902c52,0x3fa012e2,0x3fb03dda}, + uint32(0xfff80000), + [21]string{"0x72","0x85","0x37","0xf3","0x30","0x30","0x84","0x16","0x6e","0xa3","0x9e","0xf1","0xff","0xb2","0x7d","0x92","0x42","0x17","0x26","0x18","0x00"} }, + { + /* No.750 delta:1453 weight:1637 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xe207e4aa,0x421628a0,0xa011cc0a,0xab502ee9,0x4957ca43,0xe9460649,0x0b41e2e3,0x0000f6d9,0xe2071273,0x4216de79,0xa0113ad3,0xab50d830,0x49573c9a,0xe946f090,0x0b41143a}, + [16]uint32{0x00000000,0xa80f5454,0x616000db,0xc96f548f,0x3002092a,0x980d5d7e,0x516209f1,0xf96d5da5,0x0064143c,0xa86b4068,0x610414e7,0xc90b40b3,0x30661d16,0x98694942,0x51061dcd,0xf9094999}, + [16]uint32{0x3f800000,0x3fd407aa,0x3fb0b000,0x3fe4b7aa,0x3f980104,0x3fcc06ae,0x3fa8b104,0x3ffcb6ae,0x3f80320a,0x3fd435a0,0x3fb0820a,0x3fe485a0,0x3f98330e,0x3fcc34a4,0x3fa8830e,0x3ffc84a4}, + uint32(0xfff80000), + [21]string{"0xf8","0xf0","0xc1","0xc1","0x00","0x82","0x5a","0xb8","0x78","0x47","0xf4","0x67","0x67","0xd6","0xe0","0x66","0xd1","0x4f","0xaf","0x1f","0x00"} }, + { + /* No.751 delta:838 weight:1123 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xf20dcbd4,0x089654b6,0xfa9b9f62,0xef602ef3,0x1d6de527,0xe7f67a45,0x15fbb191,0x00004ca7,0xf20d8773,0x08961811,0xfa9bd3c5,0xef606254,0x1d6da980,0xe7f636e2,0x15fbfd36}, + [16]uint32{0x00000000,0x506e0192,0x100287d9,0x406c864b,0x20003815,0x706e3987,0x3002bfcc,0x606cbe5e,0x10015006,0x406f5194,0x0003d7df,0x506dd64d,0x30016813,0x606f6981,0x2003efca,0x706dee58}, + [16]uint32{0x3f800000,0x3fa83700,0x3f880143,0x3fa03643,0x3f90001c,0x3fb8371c,0x3f98015f,0x3fb0365f,0x3f8800a8,0x3fa037a8,0x3f8001eb,0x3fa836eb,0x3f9800b4,0x3fb037b4,0x3f9001f7,0x3fb836f7}, + uint32(0xfff80000), + [21]string{"0xae","0xe2","0x24","0xe2","0xa6","0xf4","0x56","0xf2","0x53","0xec","0x19","0x48","0xf8","0x0c","0x03","0x23","0x26","0xc7","0xe9","0x10","0x00"} }, + { + /* No.752 delta:620 weight:1439 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0x01bea120,0x5ee2bf84,0x5f5c1ea4,0x8db02f06,0x8c0e8e26,0xd3529082,0xd2ec31a2,0x00007544,0x01bed464,0x5ee2cac0,0x5f5c6be0,0x8db05a42,0x8c0efb62,0xd352e5c6,0xd2ec44e6}, + [16]uint32{0x00000000,0x40048153,0x1040019e,0x504480cd,0x30029004,0x70061157,0x2042919a,0x604610c9,0x2020301f,0x6024b14c,0x30603181,0x7064b0d2,0x1022a01b,0x50262148,0x0062a185,0x406620d6}, + [16]uint32{0x3f800000,0x3fa00240,0x3f882000,0x3fa82240,0x3f980148,0x3fb80308,0x3f902148,0x3fb02308,0x3f901018,0x3fb01258,0x3f983018,0x3fb83258,0x3f881150,0x3fa81310,0x3f803150,0x3fa03310}, + uint32(0xfff80000), + [21]string{"0x8c","0xe5","0x46","0x3a","0x16","0x90","0xe3","0x1d","0xcc","0xd7","0x23","0x84","0xf7","0x70","0x9c","0x6f","0xf3","0x0f","0x4e","0xf9","0x00"} }, + { + /* No.753 delta:1676 weight:1579 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x81b84728,0x36d62cb5,0xb76e6b9d,0xf9002f19,0x78b86831,0xcfd603ac,0x4e6e4484,0x0000590d,0x81b81e25,0x36d675b8,0xb76e3290,0xf9007614,0x78b8313c,0xcfd65aa1,0x4e6e1d89}, + [16]uint32{0x00000000,0x0c18abfe,0x00622553,0x0c7a8ead,0x20805d4f,0x2c98f6b1,0x20e2781c,0x2cfad3e2,0x40900015,0x4c88abeb,0x40f22546,0x4cea8eb8,0x60105d5a,0x6c08f6a4,0x60727809,0x6c6ad3f7}, + [16]uint32{0x3f800000,0x3f860c55,0x3f803112,0x3f863d47,0x3f90402e,0x3f964c7b,0x3f90713c,0x3f967d69,0x3fa04800,0x3fa64455,0x3fa07912,0x3fa67547,0x3fb0082e,0x3fb6047b,0x3fb0393c,0x3fb63569}, + uint32(0xfff80000), + [21]string{"0x11","0xf7","0xb8","0x6e","0xab","0x18","0x86","0xa8","0x1d","0x51","0xd4","0x88","0x9b","0x91","0xb3","0x1b","0xcb","0x08","0x44","0xbc","0x00"} }, + { + /* No.754 delta:620 weight:1357 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0xe8d71056,0xa2339a43,0x4ae48a15,0xd6502f2e,0x3e873f78,0x7463b56d,0x9cb4a53b,0x000094c6,0xe8d78490,0xa2330e85,0x4ae41ed3,0xd650bbe8,0x3e87abbe,0x746321ab,0x9cb431fd}, + [16]uint32{0x00000000,0x18020235,0x10002492,0x080226a7,0x60003c0a,0x78023e3f,0x70001898,0x68021aad,0x021108dc,0x1a130ae9,0x12112c4e,0x0a132e7b,0x621134d6,0x7a1336e3,0x72111044,0x6a131271}, + [16]uint32{0x3f800000,0x3f8c0101,0x3f880012,0x3f840113,0x3fb0001e,0x3fbc011f,0x3fb8000c,0x3fb4010d,0x3f810884,0x3f8d0985,0x3f890896,0x3f850997,0x3fb1089a,0x3fbd099b,0x3fb90888,0x3fb50989}, + uint32(0xfff80000), + [21]string{"0xd3","0xa0","0xf4","0x6c","0x7a","0x5f","0x71","0x51","0x05","0xd4","0xaa","0x31","0xc2","0xe0","0xf0","0x56","0x09","0x62","0x12","0x48","0x00"} }, + { + /* No.755 delta:984 weight:1467 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0xd84ea056,0x6a6a36ab,0xb22496fd,0x6c702f3f,0xb43e8f69,0x061a1994,0xde54b9c2,0x0000a4ec,0xd84e04ba,0x6a6a9247,0xb2243211,0x6c708bd3,0xb43e2b85,0x061abd78,0xde541d2e}, + [16]uint32{0x00000000,0x0003e11e,0x005c4833,0x005fa92d,0x403c4d6f,0x403fac71,0x4060055c,0x4063e442,0x80101204,0x8013f31a,0x804c5a37,0x804fbb29,0xc02c5f6b,0xc02fbe75,0xc0701758,0xc073f646}, + [16]uint32{0x3f800000,0x3f8001f0,0x3f802e24,0x3f802fd4,0x3fa01e26,0x3fa01fd6,0x3fa03002,0x3fa031f2,0x3fc00809,0x3fc009f9,0x3fc0262d,0x3fc027dd,0x3fe0162f,0x3fe017df,0x3fe0380b,0x3fe039fb}, + uint32(0xfff80000), + [21]string{"0xae","0x60","0xaf","0x94","0x49","0x39","0x30","0xa8","0x46","0x13","0x39","0x52","0x64","0x09","0x67","0x43","0x5d","0x18","0x6d","0xa8","0x00"} }, + { + /* No.756 delta:643 weight:1603 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x8cfbdea7,0x18184f08,0x94e391af,0x45002f46,0xc9fbf1e1,0x5d18604e,0xd1e3bee9,0x0000e16f,0x8cfb3fc8,0x1818ae67,0x94e370c0,0x4500ce29,0xc9fb108e,0x5d188121,0xd1e35f86}, + [16]uint32{0x00000000,0x80034053,0x08003a05,0x88037a56,0x60030bc2,0xe0004b91,0x680331c7,0xe8007194,0x0012835c,0x8011c30f,0x0812b959,0x8811f90a,0x6011889e,0xe012c8cd,0x6811b29b,0xe812f2c8}, + [16]uint32{0x3f800000,0x3fc001a0,0x3f84001d,0x3fc401bd,0x3fb00185,0x3ff00025,0x3fb40198,0x3ff40038,0x3f800941,0x3fc008e1,0x3f84095c,0x3fc408fc,0x3fb008c4,0x3ff00964,0x3fb408d9,0x3ff40979}, + uint32(0xfff80000), + [21]string{"0xf8","0x4f","0xc4","0xfc","0x78","0xae","0xfe","0x5f","0xc6","0x4a","0x1e","0xed","0xe2","0x2c","0xb7","0x7f","0x92","0x71","0xe0","0x73","0x00"} }, + { + /* No.757 delta:3100 weight:641 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0xde26a3da,0x4b9a85d3,0x95bc2609,0x9d902f52,0x43b68c88,0xd60aaa81,0x082c095b,0x000029ec,0xde268a36,0x4b9aac3f,0x95bc0fe5,0x9d9006be,0x43b6a564,0xd60a836d,0x082c20b7}, + [16]uint32{0x00000000,0x244931ab,0x11142e02,0x355d1fa9,0xeb01081e,0xcf4839b5,0xfa15261c,0xde5c17b7,0xc0111013,0xe45821b8,0xd1053e11,0xf54c0fba,0x2b10180d,0x0f5929a6,0x3a04360f,0x1e4d07a4}, + [16]uint32{0x3f800000,0x3f922498,0x3f888a17,0x3f9aae8f,0x3ff58084,0x3fe7a41c,0x3ffd0a93,0x3fef2e0b,0x3fe00888,0x3ff22c10,0x3fe8829f,0x3ffaa607,0x3f95880c,0x3f87ac94,0x3f9d021b,0x3f8f2683}, + uint32(0xfff80000), + [21]string{"0xac","0x51","0x62","0xb7","0x65","0xd2","0x7d","0x54","0x73","0x0b","0xc4","0x5e","0xa5","0xfd","0x52","0xea","0x74","0x10","0xc0","0x94","0x00"} }, + { + /* No.758 delta:874 weight:703 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x2e8cbb1e,0xf4fa7474,0xda76cf6a,0xeea02f66,0xc02c9478,0x1a5a5b12,0x34d6e00c,0x000004c9,0x2e8cbfd7,0xf4fa70bd,0xda76cba3,0xeea02baf,0xc02c90b1,0x1a5a5fdb,0x34d6e4c5}, + [16]uint32{0x00000000,0x0813693b,0x6003b934,0x6810d00f,0x6092cdc8,0x6881a4f3,0x009174fc,0x08821dc7,0x3061d01d,0x3872b926,0x50626929,0x58710012,0x50f31dd5,0x58e074ee,0x30f0a4e1,0x38e3cdda}, + [16]uint32{0x3f800000,0x3f8409b4,0x3fb001dc,0x3fb40868,0x3fb04966,0x3fb440d2,0x3f8048ba,0x3f84410e,0x3f9830e8,0x3f9c395c,0x3fa83134,0x3fac3880,0x3fa8798e,0x3fac703a,0x3f987852,0x3f9c71e6}, + uint32(0xfff80000), + [21]string{"0xb7","0x80","0x01","0xda","0x6a","0x06","0xcb","0x0b","0x87","0xd1","0x72","0x09","0x85","0xbf","0xd7","0x96","0x7c","0x62","0xbc","0xbf","0x00"} }, + { + /* No.759 delta:683 weight:1685 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xdd4812d0,0x11d230dc,0xcc9a220c,0x29702f79,0xf4383da9,0x38a21fa5,0xe5ea0d75,0x000040b3,0xdd485263,0x11d2706f,0xcc9a62bf,0x29706fca,0xf4387d1a,0x38a25f16,0xe5ea4dc6}, + [16]uint32{0x00000000,0x802e0955,0x201fac1a,0xa031a54f,0x00021014,0x802c1941,0x201dbc0e,0xa033b55b,0x00015c12,0x802f5547,0x201ef008,0xa030f95d,0x00034c06,0x802d4553,0x201ce01c,0xa032e949}, + [16]uint32{0x3f800000,0x3fc01704,0x3f900fd6,0x3fd018d2,0x3f800108,0x3fc0160c,0x3f900ede,0x3fd019da,0x3f8000ae,0x3fc017aa,0x3f900f78,0x3fd0187c,0x3f8001a6,0x3fc016a2,0x3f900e70,0x3fd01974}, + uint32(0xfff80000), + [21]string{"0xa8","0x6f","0x18","0x09","0xdd","0x29","0xa7","0xe7","0xb7","0x2d","0x89","0x52","0x0d","0x53","0x3d","0x78","0xb4","0x58","0xe9","0x38","0x00"} }, + { + /* No.760 delta:1005 weight:1475 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x8017a48d,0x8fd0fcdf,0x0fc75852,0xa5b02f8e,0x25a78b03,0x2a60d351,0xaa7777dc,0x0000f42a,0x801750a7,0x8fd008f5,0x0fc7ac78,0xa5b0dba4,0x25a77f29,0x2a60277b,0xaa7783f6}, + [16]uint32{0x00000000,0x00020c96,0x102c695c,0x102e65ca,0x90080c65,0x900a00f3,0x80246539,0x802669af,0x30400414,0x30420882,0x206c6d48,0x206e61de,0xa0480871,0xa04a04e7,0xb064612d,0xb0666dbb}, + [16]uint32{0x3f800000,0x3f800106,0x3f881634,0x3f881732,0x3fc80406,0x3fc80500,0x3fc01232,0x3fc01334,0x3f982002,0x3f982104,0x3f903636,0x3f903730,0x3fd02404,0x3fd02502,0x3fd83230,0x3fd83336}, + uint32(0xfff80000), + [21]string{"0xff","0xa2","0xe7","0xa5","0xe8","0xbe","0x8c","0xd5","0x26","0x96","0x59","0x31","0x8c","0x7d","0x40","0xb1","0x0c","0xe5","0xfb","0xfd","0x00"} }, + { + /* No.761 delta:1058 weight:1427 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x2d507f27,0xc6c15eab,0xeb91218c,0xb1502f96,0x9c0050b1,0x7791713d,0x5ac10e1a,0x0000ff10,0x2d508037,0xc6c1a1bb,0xeb91de9c,0xb150d086,0x9c00afa1,0x77918e2d,0x5ac1f10a}, + [16]uint32{0x00000000,0x0074a8d6,0x100cc09f,0x10786849,0x000c9107,0x007839d1,0x10005198,0x1074f94e,0x5004041b,0x5070accd,0x4008c484,0x407c6c52,0x5008951c,0x507c3dca,0x40045583,0x4070fd55}, + [16]uint32{0x3f800000,0x3f803a54,0x3f880660,0x3f883c34,0x3f800648,0x3f803c1c,0x3f880028,0x3f883a7c,0x3fa80202,0x3fa83856,0x3fa00462,0x3fa03e36,0x3fa8044a,0x3fa83e1e,0x3fa0022a,0x3fa0387e}, + uint32(0xfff80000), + [21]string{"0xa0","0xda","0xbf","0x0f","0xe8","0x10","0x29","0x4c","0x5b","0x40","0xf2","0xa9","0x26","0x75","0xd9","0x59","0xfb","0x28","0xa7","0xdb","0x00"} }, + { + /* No.762 delta:913 weight:1687 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0xa9a41684,0xb7826690,0x1e267014,0xee402fa2,0x47e43926,0x59c24932,0xf0665fb6,0x000013c4,0xa9a40540,0xb7827554,0x1e2663d0,0xee403c66,0x47e42ae2,0x59c25af6,0xf0664c72}, + [16]uint32{0x00000000,0x3004017d,0x606401bb,0x506000c6,0x0002f0b5,0x3006f1c8,0x6066f10e,0x5062f073,0x600dc937,0x5009c84a,0x0069c88c,0x306dc9f1,0x600f3982,0x500b38ff,0x006b3839,0x306f3944}, + [16]uint32{0x3f800000,0x3f980200,0x3fb03200,0x3fa83000,0x3f800178,0x3f980378,0x3fb03378,0x3fa83178,0x3fb006e4,0x3fa804e4,0x3f8034e4,0x3f9836e4,0x3fb0079c,0x3fa8059c,0x3f80359c,0x3f98379c}, + uint32(0xfff80000), + [21]string{"0x0f","0xc5","0xcc","0x6a","0x0e","0x60","0x64","0x81","0x8e","0xc7","0x19","0xcd","0xee","0xc7","0xd4","0xb9","0x68","0xb7","0x4b","0xb4","0x00"} }, + { + /* No.763 delta:2142 weight:1293 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xb9a47aa6,0x51fcd1b1,0xe858ab17,0xae502fba,0x17f4551c,0xffacfe0b,0x460884ad,0x0000ea47,0xb9a490e1,0x51fc3bf6,0xe8584150,0xae50c5fd,0x17f4bf5b,0xffac144c,0x46086eea}, + [16]uint32{0x00000000,0x5aa5d176,0x43800143,0x1925d035,0x12408811,0x48e55967,0x51c08952,0x0b655824,0x8403240e,0xdea6f578,0xc783254d,0x9d26f43b,0x9643ac1f,0xcce67d69,0xd5c3ad5c,0x8f667c2a}, + [16]uint32{0x3f800000,0x3fad52e8,0x3fa1c000,0x3f8c92e8,0x3f892044,0x3fa472ac,0x3fa8e044,0x3f85b2ac,0x3fc20192,0x3fef537a,0x3fe3c192,0x3fce937a,0x3fcb21d6,0x3fe6733e,0x3feae1d6,0x3fc7b33e}, + uint32(0xfff80000), + [21]string{"0xd2","0xb8","0x4e","0xe7","0xa6","0x10","0x21","0xab","0x24","0x03","0x85","0xbb","0x24","0x3a","0x1e","0x48","0x95","0xfa","0xa8","0xf1","0x00"} }, + { + /* No.764 delta:755 weight:1573 */ + 11213, + 74, + 13, + 4, + [16]uint32{0x00000000,0x0b551f3f,0x7da19575,0x76f48a4a,0x37a02fc5,0x3cf530fa,0x4a01bab0,0x4154a58f,0x00000e6b,0x0b551154,0x7da19b1e,0x76f48421,0x37a021ae,0x3cf53e91,0x4a01b4db,0x4154abe4}, + [16]uint32{0x00000000,0x0016203b,0x4020e139,0x4036c102,0x106b08cd,0x107d28f6,0x504be9f4,0x505dc9cf,0x00032215,0x0015022e,0x4023c32c,0x4035e317,0x10682ad8,0x107e0ae3,0x5048cbe1,0x505eebda}, + [16]uint32{0x3f800000,0x3f800b10,0x3fa01070,0x3fa01b60,0x3f883584,0x3f883e94,0x3fa825f4,0x3fa82ee4,0x3f800191,0x3f800a81,0x3fa011e1,0x3fa01af1,0x3f883415,0x3f883f05,0x3fa82465,0x3fa82f75}, + uint32(0xfff80000), + [21]string{"0xf8","0x92","0x5e","0x29","0x78","0x15","0xc1","0xac","0x9d","0x42","0x22","0x73","0x2b","0x0c","0xd8","0x32","0x49","0xb8","0xa9","0x77","0x00"} }, + { + /* No.765 delta:1063 weight:1539 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0xf6bc68ab,0x1c11ba11,0xeaadd2ba,0x82b02fd3,0x740c4778,0x9ea195c2,0x681dfd69,0x0000cbbd,0xf6bca316,0x1c1171ac,0xeaad1907,0x82b0e46e,0x740c8cc5,0x9ea15e7f,0x681d36d4}, + [16]uint32{0x00000000,0x001f373e,0x10141138,0x100b2606,0x100c2013,0x1013172d,0x0018312b,0x00070615,0x4050101c,0x404f2722,0x50440124,0x505b361a,0x505c300f,0x50430731,0x40482137,0x40571609}, + [16]uint32{0x3f800000,0x3f800f9b,0x3f880a08,0x3f880593,0x3f880610,0x3f88098b,0x3f800c18,0x3f800383,0x3fa02808,0x3fa02793,0x3fa82200,0x3fa82d9b,0x3fa82e18,0x3fa82183,0x3fa02410,0x3fa02b8b}, + uint32(0xfff80000), + [21]string{"0x20","0xa5","0xeb","0xe7","0x1b","0xf8","0x66","0x6d","0x4d","0x66","0x7d","0x71","0x16","0xcd","0x5d","0x95","0x30","0xd8","0xea","0x29","0x00"} }, + { + /* No.766 delta:1224 weight:1629 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0xe13eec75,0xac2a5913,0x4d14b566,0x89c02fef,0x68fec39a,0x25ea76fc,0xc4d49a89,0x0000a3ae,0xe13e4fdb,0xac2afabd,0x4d1416c8,0x89c08c41,0x68fe6034,0x25ead552,0xc4d43927}, + [16]uint32{0x00000000,0x88264412,0x41002145,0xc9266557,0x10030011,0x98254403,0x51032154,0xd9256546,0x0040105a,0x88665448,0x4140311f,0xc966750d,0x1043104b,0x98655459,0x5143310e,0xd965751c}, + [16]uint32{0x3f800000,0x3fc41322,0x3fa08010,0x3fe49332,0x3f880180,0x3fcc12a2,0x3fa88190,0x3fec92b2,0x3f802008,0x3fc4332a,0x3fa0a018,0x3fe4b33a,0x3f882188,0x3fcc32aa,0x3fa8a198,0x3fecb2ba}, + uint32(0xfff80000), + [21]string{"0x07","0x8d","0x3d","0xa0","0xb4","0x21","0x83","0xb5","0x2e","0x53","0x24","0x11","0xbb","0x29","0x86","0xc0","0x6c","0x99","0x7a","0x44","0x00"} }, + { + /* No.767 delta:753 weight:1547 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xe6a76783,0xf3a1dafa,0x1506bd79,0xaf702ff8,0x49d7487b,0x5cd1f502,0xba769281,0x0000b619,0xe6a7d19a,0xf3a16ce3,0x15060b60,0xaf7099e1,0x49d7fe62,0x5cd1431b,0xba762498}, + [16]uint32{0x00000000,0x105c01df,0x504220b5,0x401e216a,0x00027c06,0x105e7dd9,0x50405cb3,0x401c5d6c,0x00012157,0x105d2088,0x504301e2,0x401f003d,0x00035d51,0x105f5c8e,0x50417de4,0x401d7c3b}, + [16]uint32{0x3f800000,0x3f882e00,0x3fa82110,0x3fa00f10,0x3f80013e,0x3f882f3e,0x3fa8202e,0x3fa00e2e,0x3f800090,0x3f882e90,0x3fa82180,0x3fa00f80,0x3f8001ae,0x3f882fae,0x3fa820be,0x3fa00ebe}, + uint32(0xfff80000), + [21]string{"0x19","0xb6","0x7c","0x66","0x55","0x1b","0x1a","0x74","0x9c","0xb1","0xe3","0x9b","0xe8","0x28","0xb0","0x8f","0x8d","0x42","0x53","0xcb","0x00"} }, + { + /* No.768 delta:573 weight:1621 */ + 11213, + 93, + 13, + 4, + [16]uint32{0x00000000,0x2d57cf1f,0xe0a066b6,0xcdf7a9a9,0xfb40300f,0xd617ff10,0x1be056b9,0x36b799a6,0x0000f084,0x2d573f9b,0xe0a09632,0xcdf7592d,0xfb40c08b,0xd6170f94,0x1be0a63d,0x36b76922}, + [16]uint32{0x00000000,0xe0021176,0x20422409,0xc040357f,0x000a2c12,0xe0083d64,0x2048081b,0xc04a196d,0x0162ba0a,0xe160ab7c,0x21209e03,0xc1228f75,0x01689618,0xe16a876e,0x212ab211,0xc128a367}, + [16]uint32{0x3f800000,0x3ff00108,0x3f902112,0x3fe0201a,0x3f800516,0x3ff0041e,0x3f902404,0x3fe0250c,0x3f80b15d,0x3ff0b055,0x3f90904f,0x3fe09147,0x3f80b44b,0x3ff0b543,0x3f909559,0x3fe09451}, + uint32(0xfff80000), + [21]string{"0x5f","0x80","0x31","0x8a","0xfe","0xe6","0x7c","0x35","0x1f","0xe5","0x12","0x50","0x4d","0x5c","0x15","0x22","0xfc","0xc6","0xa4","0xc6","0x00"} }, + { + /* No.769 delta:1220 weight:1657 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x48613428,0x8f1d3dfe,0xc77c09d6,0xbc703017,0xf411043f,0x336d0de9,0x7b0c39c1,0x0000d78c,0x4861e3a4,0x8f1dea72,0xc77cde5a,0xbc70e79b,0xf411d3b3,0x336dda65,0x7b0cee4d}, + [16]uint32{0x00000000,0x004a24da,0x0032b10f,0x007895d5,0x20226526,0x206841fc,0x2010d429,0x205af0f3,0x800809c4,0x80422d1e,0x803ab8cb,0x80709c11,0xa02a6ce2,0xa0604838,0xa018dded,0xa052f937}, + [16]uint32{0x3f800000,0x3f802512,0x3f801958,0x3f803c4a,0x3f901132,0x3f903420,0x3f90086a,0x3f902d78,0x3fc00404,0x3fc02116,0x3fc01d5c,0x3fc0384e,0x3fd01536,0x3fd03024,0x3fd00c6e,0x3fd0297c}, + uint32(0xfff80000), + [21]string{"0xe6","0x25","0xd1","0xf9","0xed","0x8a","0xc2","0xbe","0xdb","0xc7","0x9f","0x52","0xdc","0xfb","0xa2","0xf7","0xd1","0xb7","0x36","0xcd","0x00"} }, + { + /* No.770 delta:837 weight:1673 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x0cec7299,0x0080ea2e,0x0c6c98b7,0x1b503025,0x17bc42bc,0x1bd0da0b,0x173ca892,0x0000be5b,0x0cecccc2,0x00805475,0x0c6c26ec,0x1b508e7e,0x17bcfce7,0x1bd06450,0x173c16c9}, + [16]uint32{0x00000000,0x4802899a,0x4000811f,0x08020885,0x800060d6,0xc802e94c,0xc000e1c9,0x88026853,0x2003021c,0x68018b86,0x60038303,0x28010a99,0xa00362ca,0xe801eb50,0xe003e3d5,0xa8016a4f}, + [16]uint32{0x3f800000,0x3fa40144,0x3fa00040,0x3f840104,0x3fc00030,0x3fe40174,0x3fe00070,0x3fc40134,0x3f900181,0x3fb400c5,0x3fb001c1,0x3f940085,0x3fd001b1,0x3ff400f5,0x3ff001f1,0x3fd400b5}, + uint32(0xfff80000), + [21]string{"0x64","0x2b","0x99","0x22","0x9a","0x9e","0x38","0x4a","0xeb","0x73","0x6e","0xb2","0x5e","0x84","0x8c","0x4e","0x19","0x60","0x08","0x9d","0x00"} }, + { + /* No.771 delta:1426 weight:1635 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x6854f3c4,0x4700c943,0x2f543a87,0x36203036,0x5e74c3f2,0x7120f975,0x19740ab1,0x00003220,0x6854c1e4,0x4700fb63,0x2f5408a7,0x36200216,0x5e74f1d2,0x7120cb55,0x19743891}, + [16]uint32{0x00000000,0x004e8197,0x001241ae,0x005cc039,0x000000da,0x004e814d,0x00124174,0x005cc0e3,0x2018007f,0x205681e8,0x200a41d1,0x2044c046,0x201800a5,0x20568132,0x200a410b,0x2044c09c}, + [16]uint32{0x3f800000,0x3f802740,0x3f800920,0x3f802e60,0x3f800000,0x3f802740,0x3f800920,0x3f802e60,0x3f900c00,0x3f902b40,0x3f900520,0x3f902260,0x3f900c00,0x3f902b40,0x3f900520,0x3f902260}, + uint32(0xfff80000), + [21]string{"0x7d","0xab","0x83","0xbe","0x61","0x27","0x73","0xf0","0x5d","0x44","0xbe","0xee","0xb1","0xb0","0x91","0x73","0x49","0xba","0x94","0xad","0x00"} }, + { + /* No.772 delta:942 weight:1575 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0xda02d64a,0x9496c558,0x4e941312,0x2bc03043,0xf1c2e609,0xbf56f51b,0x65542351,0x0000c766,0xda02112c,0x9496023e,0x4e94d474,0x2bc0f725,0xf1c2216f,0xbf56327d,0x6554e437}, + [16]uint32{0x00000000,0x0062ceb2,0x60c51497,0x60a7da25,0x000201ba,0x0060cf08,0x60c7152d,0x60a5db9f,0x400031fc,0x4062ff4e,0x20c5256b,0x20a7ebd9,0x40023046,0x4060fef4,0x20c724d1,0x20a5ea63}, + [16]uint32{0x3f800000,0x3f803167,0x3fb0628a,0x3fb053ed,0x3f800100,0x3f803067,0x3fb0638a,0x3fb052ed,0x3fa00018,0x3fa0317f,0x3f906292,0x3f9053f5,0x3fa00118,0x3fa0307f,0x3f906392,0x3f9052f5}, + uint32(0xfff80000), + [21]string{"0xd6","0x07","0xaf","0x11","0xee","0x10","0xbc","0x93","0x45","0xec","0x49","0x20","0x82","0x5c","0x81","0x95","0x70","0xea","0x4f","0x24","0x00"} }, + { + /* No.773 delta:1334 weight:1777 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0x57ca9c79,0xf0e93050,0xa723ac29,0x1ca0305f,0x4b6aac26,0xec49000f,0xbb839c76,0x000097d7,0x57ca0bae,0xf0e9a787,0xa7233bfe,0x1ca0a788,0x4b6a3bf1,0xec4997d8,0xbb830ba1}, + [16]uint32{0x00000000,0x283c21de,0x205bc4cd,0x0867e513,0x3035781b,0x180959c5,0x106ebcd6,0x38529d08,0x0041ec0a,0x287dcdd4,0x201a28c7,0x08260919,0x30749411,0x1848b5cf,0x102f50dc,0x38137102}, + [16]uint32{0x3f800000,0x3f941e10,0x3f902de2,0x3f8433f2,0x3f981abc,0x3f8c04ac,0x3f88375e,0x3f9c294e,0x3f8020f6,0x3f943ee6,0x3f900d14,0x3f841304,0x3f983a4a,0x3f8c245a,0x3f8817a8,0x3f9c09b8}, + uint32(0xfff80000), + [21]string{"0x56","0xf9","0x68","0xde","0xe8","0x46","0x61","0x16","0xe3","0x69","0x27","0xa8","0x55","0xe4","0x4b","0xf9","0x24","0x95","0x9c","0x3d","0x00"} }, + { + /* No.774 delta:788 weight:1779 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xc0b4d540,0xccca8778,0x0c7e5238,0x82c0306a,0x4274e52a,0x4e0ab712,0x8ebe6252,0x0000d2e4,0xc0b407a4,0xccca559c,0x0c7e80dc,0x82c0e28e,0x427437ce,0x4e0a65f6,0x8ebeb0b6}, + [16]uint32{0x00000000,0x20208817,0x30001082,0x10209895,0x8510217f,0xa530a968,0xb51031fd,0x9530b9ea,0x40000cce,0x602084d9,0x70001c4c,0x5020945b,0xc5102db1,0xe530a5a6,0xf5103d33,0xd530b524}, + [16]uint32{0x3f800000,0x3f901044,0x3f980008,0x3f88104c,0x3fc28810,0x3fd29854,0x3fda8818,0x3fca985c,0x3fa00006,0x3fb01042,0x3fb8000e,0x3fa8104a,0x3fe28816,0x3ff29852,0x3ffa881e,0x3fea985a}, + uint32(0xfff80000), + [21]string{"0xb9","0xa9","0xe7","0x1c","0xf0","0x5b","0x2a","0xc9","0x37","0xc9","0x7a","0xa6","0xd4","0x4a","0x80","0xbc","0xfa","0xe6","0x84","0xd2","0x00"} }, + { + /* No.775 delta:908 weight:1351 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0x7217df4e,0x3e2c12b5,0x4c3bcdfb,0x7c603072,0x0e77ef3c,0x424c22c7,0x305bfd89,0x00009ebd,0x721741f3,0x3e2c8c08,0x4c3b5346,0x7c60aecf,0x0e777181,0x424cbc7a,0x305b6334}, + [16]uint32{0x00000000,0x2054581d,0x006e6117,0x203a390a,0x00120e0e,0x20465613,0x007c6f19,0x20283704,0x0003c5cf,0x20579dd2,0x006da4d8,0x2039fcc5,0x0011cbc1,0x204593dc,0x007faad6,0x202bf2cb}, + [16]uint32{0x3f800000,0x3f902a2c,0x3f803730,0x3f901d1c,0x3f800907,0x3f90232b,0x3f803e37,0x3f90141b,0x3f8001e2,0x3f902bce,0x3f8036d2,0x3f901cfe,0x3f8008e5,0x3f9022c9,0x3f803fd5,0x3f9015f9}, + uint32(0xfff80000), + [21]string{"0x29","0xb0","0x52","0x73","0x0b","0xbe","0x73","0x8a","0x64","0xbb","0x9c","0xfd","0xd8","0x30","0xc9","0xf5","0xca","0xef","0xb1","0xce","0x00"} }, + { + /* No.776 delta:2144 weight:1259 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x6e034128,0x0dfcc020,0x63ff8108,0xad503080,0xc35371a8,0xa0acf0a0,0xceafb188,0x000070f9,0x6e0331d1,0x0dfcb0d9,0x63fff1f1,0xad504079,0xc3530151,0xa0ac8059,0xceafc171}, + [16]uint32{0x00000000,0x4113087a,0x1aa94da5,0x5bba45df,0x2cf23ab3,0x6de132c9,0x365b7716,0x77487f6c,0x0f000117,0x4e13096d,0x15a94cb2,0x54ba44c8,0x23f23ba4,0x62e133de,0x395b7601,0x78487e7b}, + [16]uint32{0x3f800000,0x3fa08984,0x3f8d54a6,0x3faddd22,0x3f96791d,0x3fb6f099,0x3f9b2dbb,0x3fbba43f,0x3f878000,0x3fa70984,0x3f8ad4a6,0x3faa5d22,0x3f91f91d,0x3fb17099,0x3f9cadbb,0x3fbc243f}, + uint32(0xfff80000), + [21]string{"0x26","0x40","0x6a","0xc3","0x59","0x25","0xa3","0xf2","0x21","0x1b","0xa4","0x65","0x23","0xb0","0x50","0xbc","0x88","0xbd","0x27","0xfd","0x00"} }, + { + /* No.777 delta:762 weight:1025 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0x4434980f,0x3a259514,0x7e110d1b,0x8bb03096,0xcf84a899,0xb195a582,0xf5a13d8d,0x0000c015,0x4434581a,0x3a255501,0x7e11cd0e,0x8bb0f083,0xcf84688c,0xb1956597,0xf5a1fd98}, + [16]uint32{0x00000000,0x104c897a,0x60021c1f,0x704e9565,0x0002021d,0x104e8b67,0x60001e02,0x704c9778,0x4028ae1c,0x50642766,0x202ab203,0x30663b79,0x402aac01,0x5066257b,0x2028b01e,0x30643964}, + [16]uint32{0x3f800000,0x3f882644,0x3fb0010e,0x3fb8274a,0x3f800101,0x3f882745,0x3fb0000f,0x3fb8264b,0x3fa01457,0x3fa83213,0x3f901559,0x3f98331d,0x3fa01556,0x3fa83312,0x3f901458,0x3f98321c}, + uint32(0xfff80000), + [21]string{"0x26","0x58","0x69","0x9d","0xf9","0x4d","0x84","0x59","0x7f","0x2f","0x5d","0x95","0x15","0x69","0xb3","0xe4","0x63","0xd1","0x01","0xd0","0x00"} }, + { + /* No.778 delta:1053 weight:1429 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x403aeda5,0xb89b3499,0xf8a1d93c,0x863030ac,0xc60add09,0x3eab0435,0x7e91e990,0x000058f2,0x403ab557,0xb89b6c6b,0xf8a181ce,0x8630685e,0xc60a85fb,0x3eab5cc7,0x7e91b162}, + [16]uint32{0x00000000,0x004d11f6,0x200381f9,0x204e900f,0x01066132,0x014b70c4,0x2105e0cb,0x2148f13d,0x01310c1a,0x017c1dec,0x21328de3,0x217f9c15,0x00376d28,0x007a7cde,0x2034ecd1,0x2079fd27}, + [16]uint32{0x3f800000,0x3f802688,0x3f9001c0,0x3f902748,0x3f808330,0x3f80a5b8,0x3f9082f0,0x3f90a478,0x3f809886,0x3f80be0e,0x3f909946,0x3f90bfce,0x3f801bb6,0x3f803d3e,0x3f901a76,0x3f903cfe}, + uint32(0xfff80000), + [21]string{"0xaf","0x6c","0xd1","0xfd","0x66","0x44","0x06","0x5f","0x92","0x38","0x0a","0x51","0x68","0x55","0xec","0x41","0x89","0xce","0x87","0x6d","0x00"} }, + { + /* No.779 delta:969 weight:1305 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x95f85638,0xcc15ae7f,0x59edf847,0x0ba030bb,0x9e586683,0xc7b59ec4,0x524dc8fc,0x00004da0,0x95f81b98,0xcc15e3df,0x59edb5e7,0x0ba07d1b,0x9e582b23,0xc7b5d364,0x524d855c}, + [16]uint32{0x00000000,0x207483f6,0x006a01da,0x201e822c,0x10038149,0x307702bf,0x10698093,0x301d0365,0x000050a8,0x2074d35e,0x006a5172,0x201ed284,0x1003d1e1,0x30775217,0x1069d03b,0x301d53cd}, + [16]uint32{0x3f800000,0x3f903a41,0x3f803500,0x3f900f41,0x3f8801c0,0x3f983b81,0x3f8834c0,0x3f980e81,0x3f800028,0x3f903a69,0x3f803528,0x3f900f69,0x3f8801e8,0x3f983ba9,0x3f8834e8,0x3f980ea9}, + uint32(0xfff80000), + [21]string{"0xa4","0xb2","0xff","0x0b","0xbf","0xf7","0x2a","0x57","0xf1","0x47","0x2c","0x03","0x1b","0xee","0xb2","0xe2","0x38","0x2b","0x8f","0x82","0x00"} }, + { + /* No.780 delta:961 weight:1217 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0x064e300b,0x9b6d41ee,0x9d2371e5,0xe55030ca,0xe31e00c1,0x7e3d7124,0x7873412f,0x0000b361,0x064e836a,0x9b6df28f,0x9d23c284,0xe55083ab,0xe31eb3a0,0x7e3dc245,0x7873f24e}, + [16]uint32{0x00000000,0x005c9196,0x43980db1,0x43c49c27,0x00730019,0x002f918f,0x43eb0da8,0x43b79c3e,0x00084417,0x0054d581,0x439049a6,0x43ccd830,0x007b440e,0x0027d598,0x43e349bf,0x43bfd829}, + [16]uint32{0x3f800000,0x3f802e48,0x3fa1cc06,0x3fa1e24e,0x3f803980,0x3f8017c8,0x3fa1f586,0x3fa1dbce,0x3f800422,0x3f802a6a,0x3fa1c824,0x3fa1e66c,0x3f803da2,0x3f8013ea,0x3fa1f1a4,0x3fa1dfec}, + uint32(0xfff80000), + [21]string{"0xe4","0x57","0xc1","0xdb","0xe7","0x47","0xcf","0xc3","0x84","0x19","0xac","0x63","0x22","0xb2","0xa2","0x68","0x9f","0xfa","0xe8","0x13","0x00"} }, + { + /* No.781 delta:862 weight:1723 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x66a17256,0x2a0ef328,0x4caf817e,0xf29030dd,0x9431428b,0xd89ec3f5,0xbe3fb1a3,0x000018fd,0x66a16aab,0x2a0eebd5,0x4caf9983,0xf2902820,0x94315a76,0xd89edb08,0xbe3fa95e}, + [16]uint32{0x00000000,0x0002121e,0x00004607,0x00025419,0x403dc114,0x403fd30a,0x403d8713,0x403f950d,0x70512052,0x7053324c,0x70516655,0x7053744b,0x306ce146,0x306ef358,0x306ca741,0x306eb55f}, + [16]uint32{0x3f800000,0x3f800109,0x3f800023,0x3f80012a,0x3fa01ee0,0x3fa01fe9,0x3fa01ec3,0x3fa01fca,0x3fb82890,0x3fb82999,0x3fb828b3,0x3fb829ba,0x3f983670,0x3f983779,0x3f983653,0x3f98375a}, + uint32(0xfff80000), + [21]string{"0x71","0x2d","0xf6","0xbf","0x9e","0x0f","0x5a","0x80","0xca","0x7f","0x67","0x35","0x3c","0xdc","0x18","0x8d","0x09","0xa0","0xca","0xd8","0x00"} }, + { + /* No.782 delta:768 weight:1497 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x8ddebe9c,0x51cb8ab6,0xdc15342a,0xc81030e6,0x45ce8e7a,0x99dbba50,0x140504cc,0x00008de6,0x8dde337a,0x51cb0750,0xdc15b9cc,0xc810bd00,0x45ce039c,0x99db37b6,0x1405892a}, + [16]uint32{0x00000000,0x6020455b,0x00038839,0x6023cd62,0x114da816,0x716ded4d,0x114e202f,0x716e6574,0x008029a8,0x60a06cf3,0x0083a191,0x60a3e4ca,0x11cd81be,0x71edc4e5,0x11ce0987,0x71ee4cdc}, + [16]uint32{0x3f800000,0x3fb01022,0x3f8001c4,0x3fb011e6,0x3f88a6d4,0x3fb8b6f6,0x3f88a710,0x3fb8b732,0x3f804014,0x3fb05036,0x3f8041d0,0x3fb051f2,0x3f88e6c0,0x3fb8f6e2,0x3f88e704,0x3fb8f726}, + uint32(0xfff80000), + [21]string{"0x8c","0xaa","0x09","0xbc","0x86","0x48","0x02","0x9d","0x6f","0x30","0x6b","0x6d","0x17","0xc5","0xbc","0x8d","0x39","0xea","0x79","0x49","0x00"} }, + { + /* No.783 delta:961 weight:1663 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0x9843dafc,0xfdd2109a,0x6591ca66,0xe58030fa,0x7dc3ea06,0x18522060,0x8011fa9c,0x00002fbf,0x9843f543,0xfdd23f25,0x6591e5d9,0xe5801f45,0x7dc3c5b9,0x18520fdf,0x8011d523}, + [16]uint32{0x00000000,0x006c707c,0x4059016e,0x40357112,0x100e0898,0x106278e4,0x505709f6,0x503b798a,0x00030015,0x006f7069,0x405a017b,0x40367107,0x100d088d,0x106178f1,0x505409e3,0x5038799f}, + [16]uint32{0x3f800000,0x3f803638,0x3fa02c80,0x3fa01ab8,0x3f880704,0x3f88313c,0x3fa82b84,0x3fa81dbc,0x3f800180,0x3f8037b8,0x3fa02d00,0x3fa01b38,0x3f880684,0x3f8830bc,0x3fa82a04,0x3fa81c3c}, + uint32(0xfff80000), + [21]string{"0x14","0x86","0xa3","0x96","0x8a","0xae","0x77","0xe6","0x0c","0xb7","0xdc","0xce","0x14","0xd7","0xab","0x98","0xc0","0x67","0x3a","0xcc","0x00"} }, + { + /* No.784 delta:1173 weight:1629 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0xb920a94b,0x1f535a2b,0xa673f360,0x5cf03102,0xe5d09849,0x43a36b29,0xfa83c262,0x00005e55,0xb920f71e,0x1f53047e,0xa673ad35,0x5cf06f57,0xe5d0c61c,0x43a3357c,0xfa839c37}, + [16]uint32{0x00000000,0x106860fe,0x8508891b,0x9560e9e5,0x1017100d,0x007f70f3,0x951f9916,0x8577f9e8,0x406001f0,0x5008610e,0xc56888eb,0xd500e815,0x507711fd,0x401f7103,0xd57f98e6,0xc517f818}, + [16]uint32{0x3f800000,0x3f883430,0x3fc28444,0x3fcab074,0x3f880b88,0x3f803fb8,0x3fca8fcc,0x3fc2bbfc,0x3fa03000,0x3fa80430,0x3fe2b444,0x3fea8074,0x3fa83b88,0x3fa00fb8,0x3feabfcc,0x3fe28bfc}, + uint32(0xfff80000), + [21]string{"0x18","0x2f","0xea","0xf0","0x0b","0x6b","0x70","0x7b","0x34","0xf1","0x11","0xe3","0x37","0x94","0x1d","0x9b","0x47","0x7c","0xfc","0x6f","0x00"} }, + { + /* No.785 delta:754 weight:725 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x8e6006e8,0x2f91906d,0xa1f19685,0xa430311f,0x2a5037f7,0x8ba1a172,0x05c1a79a,0x0000dc9b,0x8e60da73,0x2f914cf6,0xa1f14a1e,0xa430ed84,0x2a50eb6c,0x8ba17de9,0x05c17b01}, + [16]uint32{0x00000000,0x707e0152,0x60028015,0x107c8147,0x5003880a,0x207d8958,0x3001081f,0x407f094d,0xd0404203,0xa03e4351,0xb042c216,0xc03cc344,0x8043ca09,0xf03dcb5b,0xe0414a1c,0x903f4b4e}, + [16]uint32{0x3f800000,0x3fb83f00,0x3fb00140,0x3f883e40,0x3fa801c4,0x3f903ec4,0x3f980084,0x3fa03f84,0x3fe82021,0x3fd01f21,0x3fd82161,0x3fe01e61,0x3fc021e5,0x3ff81ee5,0x3ff020a5,0x3fc81fa5}, + uint32(0xfff80000), + [21]string{"0xa7","0xe0","0xae","0x47","0xae","0x80","0xe4","0x09","0xe7","0x6c","0xba","0x8e","0xfc","0xe2","0x11","0xcc","0xdf","0x14","0x25","0x74","0x00"} }, + { + /* No.786 delta:743 weight:1217 */ + 11213, + 60, + 13, + 4, + [16]uint32{0x00000000,0x790b895a,0x7c905d86,0x059bd4dc,0x23b0312e,0x5abbb874,0x5f206ca8,0x262be5f2,0x00003ab4,0x790bb3ee,0x7c906732,0x059bee68,0x23b00b9a,0x5abb82c0,0x5f20561c,0x262bdf46}, + [16]uint32{0x00000000,0x004c625f,0x2082a015,0x20cec24a,0x102420cc,0x10684293,0x30a680d9,0x30eae286,0x002211b2,0x006e73ed,0x20a0b1a7,0x20ecd3f8,0x1006317e,0x104a5321,0x3084916b,0x30c8f334}, + [16]uint32{0x3f800000,0x3f802631,0x3f904150,0x3f906761,0x3f881210,0x3f883421,0x3f985340,0x3f987571,0x3f801108,0x3f803739,0x3f905058,0x3f907669,0x3f880318,0x3f882529,0x3f984248,0x3f986479}, + uint32(0xfff80000), + [21]string{"0x7c","0x29","0xc6","0xea","0x79","0x83","0x6b","0xe5","0x3e","0xb7","0x4b","0x60","0x7e","0xc7","0x7e","0x2d","0xa2","0x8d","0x01","0xa4","0x00"} }, + { + /* No.787 delta:672 weight:1573 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0x3d1fcedf,0x15073d04,0x2818f3db,0x7a70313f,0x476fffe0,0x6f770c3b,0x5268c2e4,0x0000a334,0x3d1f6deb,0x15079e30,0x281850ef,0x7a70920b,0x476f5cd4,0x6f77af0f,0x526861d0}, + [16]uint32{0x00000000,0x08ec5bd6,0x30025c11,0x38ee07c7,0x00025012,0x08ee0bc4,0x30000c03,0x38ec57d5,0x600420c9,0x68e87b1f,0x50067cd8,0x58ea270e,0x600670db,0x68ea2b0d,0x50042cca,0x58e8771c}, + [16]uint32{0x3f800000,0x3f84762d,0x3f98012e,0x3f9c7703,0x3f800128,0x3f847705,0x3f980006,0x3f9c762b,0x3fb00210,0x3fb4743d,0x3fa8033e,0x3fac7513,0x3fb00338,0x3fb47515,0x3fa80216,0x3fac743b}, + uint32(0xfff80000), + [21]string{"0x81","0x17","0xed","0xca","0x47","0xb2","0x2a","0xcc","0x79","0x10","0x4e","0x1d","0x6e","0x2a","0x18","0x53","0x51","0x7f","0x87","0x55","0x00"} }, + { + /* No.788 delta:3119 weight:595 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x3270e2e3,0x313b2b25,0x034bc9c6,0x19803145,0x2bf0d3a6,0x28bb1a60,0x1acbf883,0x00004b15,0x3270a9f6,0x313b6030,0x034b82d3,0x19807a50,0x2bf098b3,0x28bb5175,0x1acbb396}, + [16]uint32{0x00000000,0xe06201a3,0x142a0079,0xf44801da,0x08c0c16b,0xe8a2c0c8,0x1ceac112,0xfc88c0b1,0x20208818,0xc04289bb,0x340a8861,0xd46889c2,0x28e04973,0xc88248d0,0x3cca490a,0xdca848a9}, + [16]uint32{0x3f800000,0x3ff03100,0x3f8a1500,0x3ffa2400,0x3f846060,0x3ff45160,0x3f8e7560,0x3ffe4460,0x3f901044,0x3fe02144,0x3f9a0544,0x3fea3444,0x3f947024,0x3fe44124,0x3f9e6524,0x3fee5424}, + uint32(0xfff80000), + [21]string{"0x24","0x91","0x3f","0x38","0x15","0x1c","0x00","0x79","0x3c","0xcd","0xeb","0x78","0xa5","0xb1","0xd0","0xdf","0xb4","0x78","0x73","0x0b","0x00"} }, + { + /* No.789 delta:779 weight:1341 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x66a7aefd,0x2031efa7,0x4696415a,0x88503156,0xeef79fab,0xa861def1,0xcec6700c,0x00004147,0x66a7efba,0x2031aee0,0x4696001d,0x88507011,0xeef7deec,0xa8619fb6,0xcec6314b}, + [16]uint32{0x00000000,0x605800d5,0x90220616,0xf07a06c3,0x30424158,0x501a418d,0xa060474e,0xc038479b,0x00099401,0x605194d4,0x902b9217,0xf07392c2,0x304bd559,0x5013d58c,0xa069d34f,0xc031d39a}, + [16]uint32{0x3f800000,0x3fb02c00,0x3fc81103,0x3ff83d03,0x3f982120,0x3fa80d20,0x3fd03023,0x3fe01c23,0x3f8004ca,0x3fb028ca,0x3fc815c9,0x3ff839c9,0x3f9825ea,0x3fa809ea,0x3fd034e9,0x3fe018e9}, + uint32(0xfff80000), + [21]string{"0x83","0xd9","0xb1","0xf5","0xb7","0x1e","0xcd","0x02","0x95","0xab","0xfa","0x46","0x38","0xaa","0xdb","0xd5","0x5f","0xb7","0x0f","0x02","0x00"} }, + { + /* No.790 delta:1009 weight:1375 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xd3009b2d,0xf6de0a36,0x25de911b,0x00803166,0xd380aa4b,0xf65e3b50,0x255ea07d,0x0000fe53,0xd300657e,0xf6def465,0x25de6f48,0x0080cf35,0xd3805418,0xf65ec503,0x255e5e2e}, + [16]uint32{0x00000000,0x604c01be,0xe02821fc,0x80642042,0x0079c0ca,0x6035c174,0xe051e136,0x801de088,0x0006119f,0x604a1021,0xe02e3063,0x806231dd,0x007fd155,0x6033d0eb,0xe057f0a9,0x801bf117}, + [16]uint32{0x3f800000,0x3fb02600,0x3ff01410,0x3fc03210,0x3f803ce0,0x3fb01ae0,0x3ff028f0,0x3fc00ef0,0x3f800308,0x3fb02508,0x3ff01718,0x3fc03118,0x3f803fe8,0x3fb019e8,0x3ff02bf8,0x3fc00df8}, + uint32(0xfff80000), + [21]string{"0x66","0xf0","0xfc","0x95","0x59","0xac","0x7f","0xa0","0x86","0xe2","0x45","0x61","0x7d","0x9d","0xa4","0x42","0x54","0x1d","0x62","0xb6","0x00"} }, + { + /* No.791 delta:799 weight:1631 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x984d4dce,0xd3197c7c,0x4b5431b2,0x93b03171,0x0bfd7cbf,0x40a94d0d,0xd8e400c3,0x00006580,0x984d284e,0xd31919fc,0x4b545432,0x93b054f1,0x0bfd193f,0x40a9288d,0xd8e46543}, + [16]uint32{0x00000000,0x2100313a,0x2006080b,0x01063931,0xb00011ac,0x91002096,0x900619a7,0xb106289d,0x00401204,0x2140233e,0x20461a0f,0x01462b35,0xb04003a8,0x91403292,0x90460ba3,0xb1463a99}, + [16]uint32{0x3f800000,0x3f908018,0x3f900304,0x3f80831c,0x3fd80008,0x3fc88010,0x3fc8030c,0x3fd88314,0x3f802009,0x3f90a011,0x3f90230d,0x3f80a315,0x3fd82001,0x3fc8a019,0x3fc82305,0x3fd8a31d}, + uint32(0xfff80000), + [21]string{"0x1a","0x48","0x24","0x36","0xb2","0x6a","0xfc","0x6e","0x90","0x45","0x87","0x65","0xb5","0x3f","0x72","0xdb","0x04","0x6b","0x27","0x1a","0x00"} }, + { + /* No.792 delta:2000 weight:1417 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x76cd7a5b,0x3a968880,0x4c5bf2db,0xe7b03183,0x917d4bd8,0xdd26b903,0xabebc358,0x0000d01b,0x76cdaa40,0x3a96589b,0x4c5b22c0,0xe7b0e198,0x917d9bc3,0xdd266918,0xabeb1343}, + [16]uint32{0x00000000,0x0014a53e,0x701e80ca,0x700a25f4,0x00020032,0x0016a50c,0x701c80f8,0x700825c6,0x404000d5,0x4054a5eb,0x305e801f,0x304a2521,0x404200e7,0x4056a5d9,0x305c802d,0x30482513}, + [16]uint32{0x3f800000,0x3f800a52,0x3fb80f40,0x3fb80512,0x3f800100,0x3f800b52,0x3fb80e40,0x3fb80412,0x3fa02000,0x3fa02a52,0x3f982f40,0x3f982512,0x3fa02100,0x3fa02b52,0x3f982e40,0x3f982412}, + uint32(0xfff80000), + [21]string{"0xdf","0x52","0xc6","0xa6","0xe7","0xd1","0xbb","0x5e","0x82","0xd2","0x56","0x7b","0x34","0x62","0x02","0x2e","0x8a","0x7d","0xa0","0xf0","0x00"} }, + { + /* No.793 delta:1031 weight:1599 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x0f33f8b5,0x1f196f03,0x102a97b6,0xd8003196,0xd733c923,0xc7195e95,0xc82aa620,0x0000b1f1,0x0f334944,0x1f19def2,0x102a2647,0xd8008067,0xd73378d2,0xc719ef64,0xc82a17d1}, + [16]uint32{0x00000000,0x104990b6,0x005c016c,0x101591da,0x0002e01f,0x104b70a9,0x005ee173,0x101771c5,0x0001f1b8,0x1048610e,0x005df0d4,0x10146062,0x000311a7,0x104a8111,0x005f10cb,0x1016807d}, + [16]uint32{0x3f800000,0x3f8824c8,0x3f802e00,0x3f880ac8,0x3f800170,0x3f8825b8,0x3f802f70,0x3f880bb8,0x3f8000f8,0x3f882430,0x3f802ef8,0x3f880a30,0x3f800188,0x3f882540,0x3f802f88,0x3f880b40}, + uint32(0xfff80000), + [21]string{"0x62","0x20","0x35","0xdc","0x41","0x58","0xba","0xc6","0x82","0xa5","0xda","0xf3","0xb2","0xf1","0xef","0xfc","0xc8","0xd2","0x30","0x92","0x00"} }, + { + /* No.794 delta:1221 weight:1465 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x7afadb16,0x64cdd530,0x1e370e26,0x19f031a7,0x630aeab1,0x7d3de497,0x07c73f81,0x0000f2c0,0x7afa29d6,0x64cd27f0,0x1e37fce6,0x19f0c367,0x630a1871,0x7d3d1657,0x07c7cd41}, + [16]uint32{0x00000000,0x3025c356,0x60067aad,0x5023b9fb,0x10406402,0x2065a754,0x70461eaf,0x4063ddf9,0x00051268,0x3020d13e,0x600368c5,0x5026ab93,0x1045766a,0x2060b53c,0x70430cc7,0x4066cf91}, + [16]uint32{0x3f800000,0x3f9812e1,0x3fb0033d,0x3fa811dc,0x3f882032,0x3f9032d3,0x3fb8230f,0x3fa031ee,0x3f800289,0x3f981068,0x3fb001b4,0x3fa81355,0x3f8822bb,0x3f90305a,0x3fb82186,0x3fa03367}, + uint32(0xfff80000), + [21]string{"0xb3","0x8c","0x0a","0x5e","0xb1","0x44","0xa4","0x47","0x8f","0x6c","0x16","0x5a","0x0c","0x84","0x45","0x8a","0x30","0xb4","0xa9","0x8f","0x00"} }, + { + /* No.795 delta:866 weight:1655 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x2b6e1893,0x3aa6f805,0x11c8e096,0x313031ba,0x1a5e2929,0x0b96c9bf,0x20f8d12c,0x00009710,0x2b6e8f83,0x3aa66f15,0x11c87786,0x3130a6aa,0x1a5ebe39,0x0b965eaf,0x20f8463c}, + [16]uint32{0x00000000,0x2006e413,0x000229ff,0x2004cdec,0x10001a02,0x3006fe11,0x100233fd,0x3004d7ee,0x60440019,0x4042e40a,0x604629e6,0x4040cdf5,0x70441a1b,0x5042fe08,0x704633e4,0x5040d7f7}, + [16]uint32{0x3f800000,0x3f900372,0x3f800114,0x3f900266,0x3f88000d,0x3f98037f,0x3f880119,0x3f98026b,0x3fb02200,0x3fa02172,0x3fb02314,0x3fa02066,0x3fb8220d,0x3fa8217f,0x3fb82319,0x3fa8206b}, + uint32(0xfff80000), + [21]string{"0xae","0x10","0xf8","0x61","0xf3","0xbc","0x6b","0xed","0x3f","0xfe","0x5b","0x34","0xef","0x50","0x04","0x9d","0x58","0x38","0x62","0x04","0x00"} }, + { + /* No.796 delta:1066 weight:1613 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0xa010cdae,0x03de5640,0xa3ce9bee,0x416031c2,0xe170fc6c,0x42be6782,0xe2aeaa2c,0x000076eb,0xa010bb45,0x03de20ab,0xa3ceed05,0x41604729,0xe1708a87,0x42be1169,0xe2aedcc7}, + [16]uint32{0x00000000,0x1005549a,0x304c6014,0x2049348e,0x106ac401,0x006f909b,0x2026a415,0x3023f08f,0x10016812,0x00043c88,0x204d0806,0x30485c9c,0x006bac13,0x106ef889,0x3027cc07,0x2022989d}, + [16]uint32{0x3f800000,0x3f8802aa,0x3f982630,0x3f90249a,0x3f883562,0x3f8037c8,0x3f901352,0x3f9811f8,0x3f8800b4,0x3f80021e,0x3f902684,0x3f98242e,0x3f8035d6,0x3f88377c,0x3f9813e6,0x3f90114c}, + uint32(0xfff80000), + [21]string{"0x63","0x6a","0xb4","0xc4","0x16","0x81","0x2f","0xf4","0xd6","0x23","0x35","0x2c","0xd3","0xd0","0x72","0x56","0x83","0xe4","0x08","0x26","0x00"} }, + { + /* No.797 delta:976 weight:1693 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xe6b8c054,0xb3d41b91,0x556cdbc5,0x19d031dc,0xff68f188,0xaa042a4d,0x4cbcea19,0x0000d097,0xe6b810c3,0xb3d4cb06,0x556c0b52,0x19d0e14b,0xff68211f,0xaa04fada,0x4cbc3a8e}, + [16]uint32{0x00000000,0x04003e12,0x5000140e,0x54002a1c,0x900002a3,0x94003cb1,0xc00016ad,0xc40028bf,0xb0100019,0xb4103e0b,0xe0101417,0xe4102a05,0x201002ba,0x24103ca8,0x701016b4,0x741028a6}, + [16]uint32{0x3f800000,0x3f82001f,0x3fa8000a,0x3faa0015,0x3fc80001,0x3fca001e,0x3fe0000b,0x3fe20014,0x3fd80800,0x3fda081f,0x3ff0080a,0x3ff20815,0x3f900801,0x3f92081e,0x3fb8080b,0x3fba0814}, + uint32(0xfff80000), + [21]string{"0xdc","0x15","0x75","0xab","0x23","0xde","0x4b","0x39","0x98","0xfe","0xaf","0xdf","0xba","0xd8","0x57","0xf1","0x7c","0x2c","0x1b","0xde","0x00"} }, + { + /* No.798 delta:1013 weight:1599 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0x75967d97,0x6ee4ce50,0x1b72b3c7,0xfc8031ed,0x89164c7a,0x9264ffbd,0xe7f2822a,0x0000fb30,0x759686a7,0x6ee43560,0x1b7248f7,0xfc80cadd,0x8916b74a,0x9264048d,0xe7f2791a}, + [16]uint32{0x00000000,0x540b0856,0x2060c973,0x746bc125,0x90480c0b,0xc443045d,0xb028c578,0xe423cd2e,0x0002840c,0x54098c5a,0x20624d7f,0x74694529,0x904a8807,0xc4418051,0xb02a4174,0xe4214922}, + [16]uint32{0x3f800000,0x3faa0584,0x3f903064,0x3fba35e0,0x3fc82406,0x3fe22182,0x3fd81462,0x3ff211e6,0x3f800142,0x3faa04c6,0x3f903126,0x3fba34a2,0x3fc82544,0x3fe220c0,0x3fd81520,0x3ff210a4}, + uint32(0xfff80000), + [21]string{"0x59","0xe2","0x25","0x14","0xa2","0x7b","0x51","0xd4","0xee","0x11","0x99","0x37","0xdb","0x97","0xe1","0xca","0x54","0x44","0x09","0xbd","0x00"} }, + { + /* No.799 delta:2643 weight:883 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0xc6656f9f,0x199c52c8,0xdff93d57,0x466031f7,0x80055e68,0x5ffc633f,0x99990ca0,0x0000fd3a,0xc66592a5,0x199caff2,0xdff9c06d,0x4660cccd,0x8005a352,0x5ffc9e05,0x9999f19a}, + [16]uint32{0x00000000,0xa22500b6,0x14208118,0xb60581ae,0x1a100035,0xb8350083,0x0e30812d,0xac15819b,0x95964019,0x37b340af,0x81b6c101,0x2393c1b7,0x8f86402c,0x2da3409a,0x9ba6c134,0x3983c182}, + [16]uint32{0x3f800000,0x3fd11280,0x3f8a1040,0x3fdb02c0,0x3f8d0800,0x3fdc1a80,0x3f871840,0x3fd60ac0,0x3fcacb20,0x3f9bd9a0,0x3fc0db60,0x3f91c9e0,0x3fc7c320,0x3f96d1a0,0x3fcdd360,0x3f9cc1e0}, + uint32(0xfff80000), + [21]string{"0xed","0x6c","0xf0","0xbe","0x91","0x9b","0x82","0x55","0x81","0x47","0x0e","0xd8","0x02","0x39","0x04","0x9c","0x23","0xc5","0xa4","0x7a","0x00"} }, + { + /* No.800 delta:807 weight:1521 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xeca160b8,0x8f015ca1,0x63a03c19,0x7ca03200,0x900152b8,0xf3a16ea1,0x1f000e19,0x000082e3,0xeca1e25b,0x8f01de42,0x63a0befa,0x7ca0b0e3,0x9001d05b,0xf3a1ec42,0x1f008cfa}, + [16]uint32{0x00000000,0x401e0216,0x00024b6a,0x401c497c,0x11051947,0x511b1b51,0x1107522d,0x5119503b,0x00010204,0x401f0012,0x0003496e,0x401d4b78,0x11041b43,0x511a1955,0x11065029,0x5118523f}, + [16]uint32{0x3f800000,0x3fa00f01,0x3f800125,0x3fa00e24,0x3f88828c,0x3fa88d8d,0x3f8883a9,0x3fa88ca8,0x3f800081,0x3fa00f80,0x3f8001a4,0x3fa00ea5,0x3f88820d,0x3fa88d0c,0x3f888328,0x3fa88c29}, + uint32(0xfff80000), + [21]string{"0x20","0xa1","0x1b","0x58","0xd3","0xc0","0x8f","0xdd","0xc8","0xa8","0xd2","0xde","0x38","0xaa","0xf1","0xfe","0x43","0xff","0xcd","0xe3","0x00"} }, + { + /* No.801 delta:1758 weight:1601 */ + 11213, + 12, + 13, + 4, + [16]uint32{0x00000000,0x5a625a10,0x232758be,0x794502ae,0x82d03213,0xd8b26803,0xa1f76aad,0xfb9530bd,0x00003216,0x5a626806,0x23276aa8,0x794530b8,0x82d00005,0xd8b25a15,0xa1f758bb,0xfb9502ab}, + [16]uint32{0x00000000,0x84a561f6,0x1042809b,0x94e7e16d,0x01288114,0x858de0e2,0x116a018f,0x95cf6079,0x091981a4,0x8dbce052,0x195b013f,0x9dfe60c9,0x083100b0,0x8c946146,0x1873802b,0x9cd6e1dd}, + [16]uint32{0x3f800000,0x3fc252b0,0x3f882140,0x3fca73f0,0x3f809440,0x3fc2c6f0,0x3f88b500,0x3fcae7b0,0x3f848cc0,0x3fc6de70,0x3f8cad80,0x3fceff30,0x3f841880,0x3fc64a30,0x3f8c39c0,0x3fce6b70}, + uint32(0xfff80000), + [21]string{"0xd5","0x27","0xba","0xce","0xb3","0x85","0x59","0xe5","0xc8","0xe3","0x97","0x73","0x8e","0xc3","0x3e","0xef","0xac","0x4c","0xa3","0xa1","0x00"} }, + { + /* No.802 delta:922 weight:1533 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x0abb479f,0x299530f4,0x232e776b,0x3590322e,0x3f2b75b1,0x1c0502da,0x16be4545,0x00003c8d,0x0abb7b12,0x29950c79,0x232e4be6,0x35900ea3,0x3f2b493c,0x1c053e57,0x16be79c8}, + [16]uint32{0x00000000,0x007640fd,0x000a00b2,0x007c404f,0x50213805,0x505778f8,0x502b38b7,0x505d784a,0x00022019,0x007460e4,0x000820ab,0x007e6056,0x5023181c,0x505558e1,0x502918ae,0x505f5853}, + [16]uint32{0x3f800000,0x3f803b20,0x3f800500,0x3f803e20,0x3fa8109c,0x3fa82bbc,0x3fa8159c,0x3fa82ebc,0x3f800110,0x3f803a30,0x3f800410,0x3f803f30,0x3fa8118c,0x3fa82aac,0x3fa8148c,0x3fa82fac}, + uint32(0xfff80000), + [21]string{"0x74","0xcf","0xe4","0x03","0xe3","0x08","0xa1","0xe8","0x47","0x37","0x52","0x67","0x79","0x0c","0x6e","0xd3","0xf6","0x43","0x7b","0xb9","0x00"} }, + { + /* No.803 delta:970 weight:1003 */ + 11213, + 89, + 13, + 4, + [16]uint32{0x00000000,0x0c088765,0xac99bbcb,0xa0913cae,0xa5c0323f,0xa9c8b55a,0x095989f4,0x05510e91,0x0000024d,0x0c088528,0xac99b986,0xa0913ee3,0xa5c03072,0xa9c8b717,0x09598bb9,0x05510cdc}, + [16]uint32{0x00000000,0x47a7b8df,0x68a45b06,0x2f03e3d9,0x400109b4,0x07a6b16b,0x28a552b2,0x6f02ea6d,0x7090101a,0x3737a8c5,0x18344b1c,0x5f93f3c3,0x309119ae,0x7736a171,0x583542a8,0x1f92fa77}, + [16]uint32{0x3f800000,0x3fa3d3dc,0x3fb4522d,0x3f9781f1,0x3fa00084,0x3f83d358,0x3f9452a9,0x3fb78175,0x3fb84808,0x3f9b9bd4,0x3f8c1a25,0x3fafc9f9,0x3f98488c,0x3fbb9b50,0x3fac1aa1,0x3f8fc97d}, + uint32(0xfff80000), + [21]string{"0x88","0x0a","0xc2","0xe5","0x7a","0xb5","0x91","0x78","0x7a","0x44","0x03","0xd3","0xae","0x99","0x83","0xbd","0x08","0xfb","0x31","0x5c","0x00"} }, + { + /* No.804 delta:754 weight:1363 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0xbbc6a6ed,0xf745e84f,0x4c834ea2,0xe440324c,0x5f8694a1,0x1305da03,0xa8c37cee,0x0000003f,0xbbc6a6d2,0xf745e870,0x4c834e9d,0xe4403273,0x5f86949e,0x1305da3c,0xa8c37cd1}, + [16]uint32{0x00000000,0x800067f6,0x01033a0d,0x81035dfb,0x40008609,0xc000e1ff,0x4103bc04,0xc103dbf2,0x5002c21e,0xd002a5e8,0x5101f813,0xd1019fe5,0x10024417,0x900223e1,0x11017e1a,0x910119ec}, + [16]uint32{0x3f800000,0x3fc00033,0x3f80819d,0x3fc081ae,0x3fa00043,0x3fe00070,0x3fa081de,0x3fe081ed,0x3fa80161,0x3fe80152,0x3fa880fc,0x3fe880cf,0x3f880122,0x3fc80111,0x3f8880bf,0x3fc8808c}, + uint32(0xfff80000), + [21]string{"0x6f","0xd8","0x43","0xc4","0x8c","0x9b","0x48","0x62","0xfa","0x67","0xcb","0x19","0x6b","0xa8","0xe1","0xee","0xac","0xfb","0x9c","0xc4","0x00"} }, + { + /* No.805 delta:878 weight:1627 */ + 11213, + 48, + 13, + 4, + [16]uint32{0x00000000,0x9664e72f,0x44701dfa,0xd214fad5,0x07103250,0x9174d57f,0x43602faa,0xd504c885,0x0000caf7,0x96642dd8,0x4470d70d,0xd2143022,0x0710f8a7,0x91741f88,0x4360e55d,0xd5040272}, + [16]uint32{0x00000000,0x20055412,0x0008f05e,0x200da44c,0x00222e03,0x20277a11,0x002ade5d,0x202f8a4f,0x30000018,0x1005540a,0x3008f046,0x100da454,0x30222e1b,0x10277a09,0x302ade45,0x102f8a57}, + [16]uint32{0x3f800000,0x3f9002aa,0x3f800478,0x3f9006d2,0x3f801117,0x3f9013bd,0x3f80156f,0x3f9017c5,0x3f980000,0x3f8802aa,0x3f980478,0x3f8806d2,0x3f981117,0x3f8813bd,0x3f98156f,0x3f8817c5}, + uint32(0xfff80000), + [21]string{"0x7f","0xdb","0x48","0x77","0x81","0x32","0x34","0x75","0xb7","0x8b","0x80","0xf6","0x46","0x7a","0x2a","0xa6","0x28","0x66","0x71","0xf2","0x00"} }, + { + /* No.806 delta:790 weight:1135 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0xdf7087e0,0xd4f7d780,0x0b875060,0x3860326e,0xe710b58e,0xec97e5ee,0x33e7620e,0x0000e8fc,0xdf706f1c,0xd4f73f7c,0x0b87b89c,0x3860da92,0xe7105d72,0xec970d12,0x33e78af2}, + [16]uint32{0x00000000,0x000210bb,0x1001820d,0x100392b6,0x480900fe,0x480b1045,0x580882f3,0x580a9248,0x4000c174,0x4002d1cf,0x50014379,0x500353c2,0x0809c18a,0x080bd131,0x18084387,0x180a533c}, + [16]uint32{0x3f800000,0x3f800108,0x3f8800c1,0x3f8801c9,0x3fa40480,0x3fa40588,0x3fac0441,0x3fac0549,0x3fa00060,0x3fa00168,0x3fa800a1,0x3fa801a9,0x3f8404e0,0x3f8405e8,0x3f8c0421,0x3f8c0529}, + uint32(0xfff80000), + [21]string{"0xfa","0xef","0x9b","0x27","0xb1","0x8c","0x21","0x7d","0xe6","0x46","0x15","0x6c","0xb3","0x6b","0xba","0xa9","0x4a","0x02","0x41","0x4c","0x00"} }, + { + /* No.807 delta:1102 weight:761 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x554a2d17,0xf1444969,0xa40e647e,0x91f03278,0xc4ba1f6f,0x60b47b11,0x35fe5606,0x00006026,0x554a4d31,0xf144294f,0xa40e0458,0x91f0525e,0xc4ba7f49,0x60b41b37,0x35fe3620}, + [16]uint32{0x00000000,0x00628c5a,0x800401ab,0x80668df1,0x71010172,0x71638d28,0xf10500d9,0xf1678c83,0x4003401e,0x4061cc44,0xc00741b5,0xc065cdef,0x3102416c,0x3160cd36,0xb10640c7,0xb164cc9d}, + [16]uint32{0x3f800000,0x3f803146,0x3fc00200,0x3fc03346,0x3fb88080,0x3fb8b1c6,0x3ff88280,0x3ff8b3c6,0x3fa001a0,0x3fa030e6,0x3fe003a0,0x3fe032e6,0x3f988120,0x3f98b066,0x3fd88320,0x3fd8b266}, + uint32(0xfff80000), + [21]string{"0x56","0x61","0x8f","0x09","0xef","0x5c","0x30","0xdc","0x40","0xd0","0x9e","0xe6","0x92","0x9d","0x61","0x5d","0x16","0x8c","0x01","0x2f","0x00"} }, + { + /* No.808 delta:2004 weight:1653 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0x2df15ce5,0xcf48aa2c,0xe2b9f6c9,0x71903288,0x5c616e6d,0xbed898a4,0x9329c441,0x00004e1b,0x2df112fe,0xcf48e437,0xe2b9b8d2,0x71907c93,0x5c612076,0xbed8d6bf,0x93298a5a}, + [16]uint32{0x00000000,0x0002a19a,0x004c81f4,0x004e206e,0x085001b9,0x0852a023,0x081c804d,0x081e21d7,0x00280011,0x002aa18b,0x006481e5,0x0066207f,0x087801a8,0x087aa032,0x0834805c,0x083621c6}, + [16]uint32{0x3f800000,0x3f800150,0x3f802640,0x3f802710,0x3f842800,0x3f842950,0x3f840e40,0x3f840f10,0x3f801400,0x3f801550,0x3f803240,0x3f803310,0x3f843c00,0x3f843d50,0x3f841a40,0x3f841b10}, + uint32(0xfff80000), + [21]string{"0x99","0x97","0x4e","0xed","0x12","0x8b","0xec","0xf2","0xbb","0x81","0xe0","0x91","0x1c","0xd8","0x16","0x3b","0xc8","0xa6","0x67","0x1a","0x00"} }, + { + /* No.809 delta:1097 weight:1243 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0x0ead4746,0xedc30260,0xe36e4526,0x0cd03297,0x027d75d1,0xe11330f7,0xefbe77b1,0x000052c0,0x0ead1586,0xedc350a0,0xe36e17e6,0x0cd06057,0x027d2711,0xe1136237,0xefbe2571}, + [16]uint32{0x00000000,0xc0018afe,0x007c18bd,0xc07d9243,0x40030051,0x80028aaf,0x407f18ec,0x807e9212,0x8001414b,0x4000cbb5,0x807d59f6,0x407cd308,0xc002411a,0x0003cbe4,0xc07e59a7,0x007fd359}, + [16]uint32{0x3f800000,0x3fe000c5,0x3f803e0c,0x3fe03ec9,0x3fa00180,0x3fc00145,0x3fa03f8c,0x3fc03f49,0x3fc000a0,0x3fa00065,0x3fc03eac,0x3fa03e69,0x3fe00120,0x3f8001e5,0x3fe03f2c,0x3f803fe9}, + uint32(0xfff80000), + [21]string{"0x53","0x9d","0x15","0xec","0x0c","0x8f","0x50","0x9b","0x06","0x13","0x63","0xd7","0x20","0xa0","0x37","0xe3","0xb5","0x31","0x8d","0x59","0x00"} }, + { + /* No.810 delta:1986 weight:925 */ + 11213, + 51, + 13, + 4, + [16]uint32{0x00000000,0x92b74108,0x7385356f,0xe1327467,0x2ab032a5,0xb80773ad,0x593507ca,0xcb8246c2,0x000030cf,0x92b771c7,0x738505a0,0xe13244a8,0x2ab0026a,0xb8074362,0x59353705,0xcb82760d}, + [16]uint32{0x00000000,0x5000081e,0x200001af,0x700009b1,0x0000004c,0x50000852,0x200001e3,0x700009fd,0xc00000ba,0x900008a4,0xe0000115,0xb000090b,0xc00000f6,0x900008e8,0xe0000159,0xb0000947}, + [16]uint32{0x3f800000,0x3fa80004,0x3f900000,0x3fb80004,0x3f800000,0x3fa80004,0x3f900000,0x3fb80004,0x3fe00000,0x3fc80004,0x3ff00000,0x3fd80004,0x3fe00000,0x3fc80004,0x3ff00000,0x3fd80004}, + uint32(0xfff80000), + [21]string{"0xa3","0x6d","0x7c","0x6d","0xec","0xf1","0x21","0x0d","0x4d","0x42","0x61","0x56","0xc2","0x58","0xa6","0xaf","0xaa","0xba","0x41","0xfb","0x00"} }, + { + /* No.811 delta:911 weight:963 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0xd7591026,0xa84f7daa,0x7f166d8c,0xdea032bd,0x09f9229b,0x76ef4f17,0xa1b65f31,0x0000bfd4,0xd759aff2,0xa84fc27e,0x7f16d258,0xdea08d69,0x09f99d4f,0x76eff0c3,0xa1b6e0e5}, + [16]uint32{0x00000000,0x006d25fa,0x50280171,0x5045248b,0x201a10ff,0x20773505,0x7032118e,0x705f3474,0x200841bc,0x20656446,0x702040cd,0x704d6537,0x00125143,0x007f74b9,0x503a5032,0x505775c8}, + [16]uint32{0x3f800000,0x3f803692,0x3fa81400,0x3fa82292,0x3f900d08,0x3f903b9a,0x3fb81908,0x3fb82f9a,0x3f900420,0x3f9032b2,0x3fb81020,0x3fb826b2,0x3f800928,0x3f803fba,0x3fa81d28,0x3fa82bba}, + uint32(0xfff80000), + [21]string{"0x14","0x08","0x9b","0x06","0xda","0x10","0x86","0xf5","0xb3","0x33","0x2e","0xcd","0x4c","0xd8","0x51","0x8d","0x1f","0xc7","0x97","0x2c","0x00"} }, + { + /* No.812 delta:593 weight:1829 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x5fbcf51f,0x98b79a9a,0xc70b6f85,0x31f032cb,0x6e4cc7d4,0xa947a851,0xf6fb5d4e,0x00004edc,0x5fbcbbc3,0x98b7d446,0xc70b2159,0x31f07c17,0x6e4c8908,0xa947e68d,0xf6fb1392}, + [16]uint32{0x00000000,0x20022136,0x00021189,0x200030bf,0xc000010d,0xe002203b,0xc0021084,0xe00031b2,0x7003255d,0x5001046b,0x700134d4,0x500315e2,0xb0032450,0x90010566,0xb00135d9,0x900314ef}, + [16]uint32{0x3f800000,0x3f900110,0x3f800108,0x3f900018,0x3fe00000,0x3ff00110,0x3fe00108,0x3ff00018,0x3fb80192,0x3fa80082,0x3fb8009a,0x3fa8018a,0x3fd80192,0x3fc80082,0x3fd8009a,0x3fc8018a}, + uint32(0xfff80000), + [21]string{"0x23","0xe1","0x3b","0xbf","0x88","0x82","0xfd","0x93","0x73","0x76","0x16","0xa2","0x0b","0xd3","0x2f","0x00","0x97","0x8e","0x26","0x8e","0x00"} }, + { + /* No.813 delta:930 weight:1205 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x3151665e,0x5438759b,0x656913c5,0xd02032d8,0xe1715486,0x84184743,0xb549211d,0x0000a819,0x3151ce47,0x5438dd82,0x6569bbdc,0xd0209ac1,0xe171fc9f,0x8418ef5a,0xb5498904}, + [16]uint32{0x00000000,0xc066157a,0x000205af,0xc06410d5,0x20042866,0xe0623d1c,0x20062dc9,0xe06038b3,0x60141017,0xa072056d,0x601615b8,0xa07000c2,0x40103871,0x80762d0b,0x40123dde,0x807428a4}, + [16]uint32{0x3f800000,0x3fe0330a,0x3f800102,0x3fe03208,0x3f900214,0x3ff0311e,0x3f900316,0x3ff0301c,0x3fb00a08,0x3fd03902,0x3fb00b0a,0x3fd03800,0x3fa0081c,0x3fc03b16,0x3fa0091e,0x3fc03a14}, + uint32(0xfff80000), + [21]string{"0x15","0xd0","0x7f","0xe0","0x17","0xfb","0xd7","0x1a","0x42","0xe6","0x86","0x89","0xcb","0x17","0xf1","0x72","0xa1","0x2c","0x4f","0x56","0x00"} }, + { + /* No.814 delta:832 weight:1133 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0x5a0f9104,0x84a207db,0xdead96df,0xe80032e3,0xb20fa3e7,0x6ca23538,0x36ada43c,0x000002a9,0x5a0f93ad,0x84a20572,0xdead9476,0xe800304a,0xb20fa14e,0x6ca23791,0x36ada695}, + [16]uint32{0x00000000,0x30388412,0x1064181d,0x205c9c0f,0x00020269,0x303a867b,0x10661a74,0x205e9e66,0x14417001,0x2479f413,0x0425681c,0x341dec0e,0x14437268,0x247bf67a,0x04276a75,0x341fee67}, + [16]uint32{0x3f800000,0x3f981c42,0x3f88320c,0x3f902e4e,0x3f800101,0x3f981d43,0x3f88330d,0x3f902f4f,0x3f8a20b8,0x3f923cfa,0x3f8212b4,0x3f9a0ef6,0x3f8a21b9,0x3f923dfb,0x3f8213b5,0x3f9a0ff7}, + uint32(0xfff80000), + [21]string{"0xce","0xc8","0xec","0x83","0xcc","0x6e","0x8a","0x5b","0xcd","0x76","0xee","0xcb","0x66","0xcc","0x59","0x54","0xd8","0x02","0xbe","0x63","0x00"} }, + { + /* No.815 delta:776 weight:1615 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0xdc1ed819,0x09d68b28,0xd5c85331,0x020032fa,0xde1eeae3,0x0bd6b9d2,0xd7c861cb,0x0000da41,0xdc1e0258,0x09d65169,0xd5c88970,0x0200e8bb,0xde1e30a2,0x0bd66393,0xd7c8bb8a}, + [16]uint32{0x00000000,0x20021416,0x40401e0d,0x60420a1b,0x8001093a,0xa0031d2c,0xc0411737,0xe0430321,0x3000001e,0x10021408,0x70401e13,0x50420a05,0xb0010924,0x90031d32,0xf0411729,0xd043033f}, + [16]uint32{0x3f800000,0x3f90010a,0x3fa0200f,0x3fb02105,0x3fc00084,0x3fd0018e,0x3fe0208b,0x3ff02181,0x3f980000,0x3f88010a,0x3fb8200f,0x3fa82105,0x3fd80084,0x3fc8018e,0x3ff8208b,0x3fe82181}, + uint32(0xfff80000), + [21]string{"0xd0","0xb2","0x11","0x4c","0xc4","0xb1","0x60","0x79","0x60","0xc0","0x10","0x75","0x37","0x8e","0x88","0xb6","0xe2","0xd4","0x7a","0x88","0x00"} }, + { + /* No.816 delta:812 weight:1497 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x6fbfa028,0x651705ec,0x0aa8a5c4,0xb0303301,0xdf8f9329,0xd52736ed,0xba9896c5,0x0000fdf9,0x6fbf5dd1,0x6517f815,0x0aa8583d,0xb030cef8,0xdf8f6ed0,0xd527cb14,0xba986b3c}, + [16]uint32{0x00000000,0x20031b52,0x1000281d,0x3003334f,0x30000211,0x10031943,0x20002a0c,0x0003315e,0x09341216,0x29370944,0x19343a0b,0x39372159,0x39341007,0x19370b55,0x2934381a,0x09372348}, + [16]uint32{0x3f800000,0x3f90018d,0x3f880014,0x3f980199,0x3f980001,0x3f88018c,0x3f900015,0x3f800198,0x3f849a09,0x3f949b84,0x3f8c9a1d,0x3f9c9b90,0x3f9c9a08,0x3f8c9b85,0x3f949a1c,0x3f849b91}, + uint32(0xfff80000), + [21]string{"0xa6","0x71","0x3f","0xe7","0xae","0xc8","0xe7","0xa6","0x98","0x1a","0xb3","0x83","0xe3","0x9d","0xa5","0x96","0x59","0x48","0x7c","0x03","0x00"} }, + { + /* No.817 delta:996 weight:1399 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0x5d4b95b0,0x041181ae,0x595a141e,0xa1d03311,0xfc9ba6a1,0xa5c1b2bf,0xf88a270f,0x00008fb6,0x5d4b1a06,0x04110e18,0x595a9ba8,0xa1d0bca7,0xfc9b2917,0xa5c13d09,0xf88aa8b9}, + [16]uint32{0x00000000,0x805811da,0x007600e7,0x802e113d,0x000b103c,0x805301e6,0x007d10db,0x80250101,0x00022018,0x805a31c2,0x007420ff,0x802c3125,0x00093024,0x805121fe,0x007f30c3,0x80272119}, + [16]uint32{0x3f800000,0x3fc02c08,0x3f803b00,0x3fc01708,0x3f800588,0x3fc02980,0x3f803e88,0x3fc01280,0x3f800110,0x3fc02d18,0x3f803a10,0x3fc01618,0x3f800498,0x3fc02890,0x3f803f98,0x3fc01390}, + uint32(0xfff80000), + [21]string{"0xcf","0x0e","0xdc","0x27","0x59","0x80","0xe0","0x33","0xe0","0x1f","0x24","0x1d","0x47","0x14","0x50","0x74","0x9c","0x01","0x4d","0x71","0x00"} }, + { + /* No.818 delta:829 weight:1327 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x5d97761f,0xbcde4dd3,0xe1493bcc,0x71a03322,0x2c37453d,0xcd7e7ef1,0x90e908ee,0x00005ac4,0x5d972cdb,0xbcde1717,0xe1496108,0x71a069e6,0x2c371ff9,0xcd7e2435,0x90e9522a}, + [16]uint32{0x00000000,0x9005251f,0x40098156,0xd00ca449,0x1042e014,0x8047c50b,0x504b6142,0xc04e445d,0x20408045,0xb045a55a,0x60490113,0xf04c240c,0x30026051,0xa007454e,0x700be107,0xe00ec418}, + [16]uint32{0x3f800000,0x3fc80292,0x3fa004c0,0x3fe80652,0x3f882170,0x3fc023e2,0x3fa825b0,0x3fe02722,0x3f902040,0x3fd822d2,0x3fb02480,0x3ff82612,0x3f980130,0x3fd003a2,0x3fb805f0,0x3ff00762}, + uint32(0xfff80000), + [21]string{"0x26","0x1d","0x1e","0xb6","0xa5","0x64","0xa7","0x82","0x8c","0x79","0x69","0x7f","0x78","0xf5","0xc1","0xdb","0xbd","0x2b","0xa8","0x3d","0x00"} }, + { + /* No.819 delta:1173 weight:1521 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0x9978b429,0x6582d994,0xfcfa6dbd,0xe0703336,0x7908871f,0x85f2eaa2,0x1c8a5e8b,0x00006a05,0x9978de2c,0x6582b391,0xfcfa07b8,0xe0705933,0x7908ed1a,0x85f280a7,0x1c8a348e}, + [16]uint32{0x00000000,0x0024135e,0x10622635,0x1046356b,0x50d0500f,0x50f44351,0x40b2763a,0x40966564,0x50146608,0x50307556,0x4076403d,0x40525363,0x00c43607,0x00e02559,0x10a61032,0x1082036c}, + [16]uint32{0x3f800000,0x3f801209,0x3f883113,0x3f88231a,0x3fa86828,0x3fa87a21,0x3fa0593b,0x3fa04b32,0x3fa80a33,0x3fa8183a,0x3fa03b20,0x3fa02929,0x3f80621b,0x3f807012,0x3f885308,0x3f884101}, + uint32(0xfff80000), + [21]string{"0x82","0x3b","0x97","0xb1","0x32","0x4a","0xf9","0x10","0x95","0xf4","0x65","0x04","0x76","0x4e","0x65","0x45","0xdd","0x7b","0x7c","0x23","0x00"} }, + { + /* No.820 delta:1510 weight:1615 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xeca160b8,0x8f015ca1,0x63a03c19,0x7ca03340,0x900153f8,0xf3a16fe1,0x1f000f59,0x000082e3,0xeca1e25b,0x8f01de42,0x63a0befa,0x7ca0b1a3,0x9001d11b,0xf3a1ed02,0x1f008dba}, + [16]uint32{0x00000000,0x00684176,0x9017206a,0x907f611c,0x0012004b,0x007a413d,0x90052021,0x906d6157,0x00024008,0x006a017e,0x90156062,0x907d2114,0x00104043,0x00780135,0x90076029,0x906f215f}, + [16]uint32{0x3f800000,0x3f803420,0x3fc80b90,0x3fc83fb0,0x3f800900,0x3f803d20,0x3fc80290,0x3fc836b0,0x3f800120,0x3f803500,0x3fc80ab0,0x3fc83e90,0x3f800820,0x3f803c00,0x3fc803b0,0x3fc83790}, + uint32(0xfff80000), + [21]string{"0xc9","0x83","0x22","0x11","0x92","0xca","0x81","0x3e","0xd0","0x3c","0x03","0x94","0x75","0xb1","0xe3","0xa3","0x58","0xed","0x80","0xd0","0x00"} }, + { + /* No.821 delta:1468 weight:1661 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xb5a0ba7d,0xb63ed1c3,0x039e6bbe,0x90703351,0x25d0892c,0x264ee292,0x93ee58ef,0x0000f62b,0xb5a04c56,0xb63e27e8,0x039e9d95,0x9070c57a,0x25d07f07,0x264e14b9,0x93eeaec4}, + [16]uint32{0x00000000,0x407e513a,0x50115174,0x106f004e,0x00422c0c,0x403c7d36,0x50537d78,0x102d2c42,0x2002d415,0x607c852f,0x70138561,0x306dd45b,0x2040f819,0x603ea923,0x7051a96d,0x302ff857}, + [16]uint32{0x3f800000,0x3fa03f28,0x3fa808a8,0x3f883780,0x3f802116,0x3fa01e3e,0x3fa829be,0x3f881696,0x3f90016a,0x3fb03e42,0x3fb809c2,0x3f9836ea,0x3f90207c,0x3fb01f54,0x3fb828d4,0x3f9817fc}, + uint32(0xfff80000), + [21]string{"0xbd","0xe3","0xe0","0x4a","0x82","0x9a","0xd3","0x8c","0xc9","0x90","0xd1","0x09","0xc2","0xf7","0xb2","0x7c","0x72","0x90","0x60","0x55","0x00"} }, + { + /* No.822 delta:1931 weight:1379 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0xca46bedd,0x29517305,0xe317cdd8,0x9980336d,0x53c68db0,0xb0d14068,0x7a97feb5,0x00009a52,0xca46248f,0x2951e957,0xe317578a,0x9980a93f,0x53c617e2,0xb0d1da3a,0x7a9764e7}, + [16]uint32{0x00000000,0x4d517f56,0x40401411,0x0d116b47,0x401808ff,0x0d4977a9,0x00581cee,0x4d0963b8,0xc7ee700c,0x8abf0f5a,0x87ae641d,0xcaff1b4b,0x87f678f3,0xcaa707a5,0xc7b66ce2,0x8ae713b4}, + [16]uint32{0x3f800000,0x3fa6a8bf,0x3fa0200a,0x3f8688b5,0x3fa00c04,0x3f86a4bb,0x3f802c0e,0x3fa684b1,0x3fe3f738,0x3fc55f87,0x3fc3d732,0x3fe57f8d,0x3fc3fb3c,0x3fe55383,0x3fe3db36,0x3fc57389}, + uint32(0xfff80000), + [21]string{"0x62","0x59","0x00","0x08","0x09","0xac","0x26","0x12","0x01","0x06","0x8f","0xac","0x70","0x58","0x0a","0x50","0xc5","0xcf","0x56","0xad","0x00"} }, + { + /* No.823 delta:834 weight:1539 */ + 11213, + 55, + 13, + 4, + [16]uint32{0x00000000,0x0d9b6aba,0x74d72ee7,0x794c445d,0x72c03377,0x7f5b59cd,0x06171d90,0x0b8c772a,0x000051d7,0x0d9b3b6d,0x74d77f30,0x794c158a,0x72c062a0,0x7f5b081a,0x06174c47,0x0b8c26fd}, + [16]uint32{0x00000000,0x114790be,0x304c206d,0x210bb0d3,0x0002c61c,0x114556a2,0x304ee671,0x210976cf,0x00011007,0x114680b9,0x304d306a,0x210aa0d4,0x0003d61b,0x114446a5,0x304ff676,0x210866c8}, + [16]uint32{0x3f800000,0x3f88a3c8,0x3f982610,0x3f9085d8,0x3f800163,0x3f88a2ab,0x3f982773,0x3f9084bb,0x3f800088,0x3f88a340,0x3f982698,0x3f908550,0x3f8001eb,0x3f88a223,0x3f9827fb,0x3f908433}, + uint32(0xfff80000), + [21]string{"0xf0","0x81","0x43","0x0b","0x1e","0x48","0xcd","0xa4","0xf5","0xc4","0x2d","0x3f","0x2e","0xc4","0x04","0x34","0x7a","0xd4","0x51","0xe4","0x00"} }, + { + /* No.824 delta:1084 weight:1529 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0xa43f33f0,0x4fb4a6aa,0xeb8b955a,0xaab0338a,0x0e8f007a,0xe5049520,0x413ba6d0,0x0000492d,0xa43f7add,0x4fb4ef87,0xeb8bdc77,0xaab07aa7,0x0e8f4957,0xe504dc0d,0x413beffd}, + [16]uint32{0x00000000,0x2002c87c,0x50fd91ef,0x70ff5993,0x00401017,0x2042d86b,0x50bd81f8,0x70bf4984,0x60402b5d,0x4042e321,0x30bdbab2,0x10bf72ce,0x60003b4a,0x4002f336,0x30fdaaa5,0x10ff62d9}, + [16]uint32{0x3f800000,0x3f900164,0x3fa87ec8,0x3fb87fac,0x3f802008,0x3f90216c,0x3fa85ec0,0x3fb85fa4,0x3fb02015,0x3fa02171,0x3f985edd,0x3f885fb9,0x3fb0001d,0x3fa00179,0x3f987ed5,0x3f887fb1}, + uint32(0xfff80000), + [21]string{"0x10","0x09","0xac","0x98","0xcf","0x44","0x58","0x74","0x2b","0x11","0xe5","0x53","0xba","0xd4","0x07","0x57","0x47","0xc5","0x3e","0xbf","0x00"} }, + { + /* No.825 delta:935 weight:1259 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x77ffb15d,0x52d34888,0x252cf9d5,0x39903393,0x4e6f82ce,0x6b437b1b,0x1cbcca46,0x0000925c,0x77ff2301,0x52d3dad4,0x252c6b89,0x3990a1cf,0x4e6f1092,0x6b43e947,0x1cbc581a}, + [16]uint32{0x00000000,0x100441f6,0x700440d3,0x60000125,0x30021002,0x200651f4,0x400650d1,0x50021127,0x30013c1c,0x20057dea,0x40057ccf,0x50013d39,0x00032c1e,0x10076de8,0x70076ccd,0x60032d3b}, + [16]uint32{0x3f800000,0x3f880220,0x3fb80220,0x3fb00000,0x3f980108,0x3f900328,0x3fa00328,0x3fa80108,0x3f98009e,0x3f9002be,0x3fa002be,0x3fa8009e,0x3f800196,0x3f8803b6,0x3fb803b6,0x3fb00196}, + uint32(0xfff80000), + [21]string{"0xbf","0xa6","0x28","0x24","0xc4","0x2e","0x47","0x0c","0x86","0x38","0xf1","0xa4","0xc6","0x0e","0xd6","0x37","0x52","0x34","0x6c","0xa1","0x00"} }, + { + /* No.826 delta:625 weight:1373 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0x3e399f20,0x350e6d29,0x0b37f209,0x767033ab,0x4849ac8b,0x437e5e82,0x7d47c1a2,0x000033bb,0x3e39ac9b,0x350e5e92,0x0b37c1b2,0x76700010,0x48499f30,0x437e6d39,0x7d47f219}, + [16]uint32{0x00000000,0x304d159e,0x4029e0c2,0x7064f55c,0x80402019,0xb00d3587,0xc069c0db,0xf024d545,0x3020810b,0x006d9495,0x700961c9,0x40447457,0xb060a112,0x802db48c,0xf04941d0,0xc004544e}, + [16]uint32{0x3f800000,0x3f98268a,0x3fa014f0,0x3fb8327a,0x3fc02010,0x3fd8069a,0x3fe034e0,0x3ff8126a,0x3f981040,0x3f8036ca,0x3fb804b0,0x3fa0223a,0x3fd83050,0x3fc016da,0x3ff824a0,0x3fe0022a}, + uint32(0xfff80000), + [21]string{"0x6d","0x95","0x38","0xc0","0x12","0xc0","0x30","0x09","0x96","0x3d","0x80","0xfe","0x20","0x2d","0x6f","0x09","0x31","0xc6","0x93","0xba","0x00"} }, + { + /* No.827 delta:667 weight:913 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0x0cb6bfff,0xba01cbc4,0xb6b7743b,0xe32033be,0xef968c41,0x5921f87a,0x55974785,0x00007a41,0x0cb6c5be,0xba01b185,0xb6b70e7a,0xe32049ff,0xef96f600,0x5921823b,0x55973dc4}, + [16]uint32{0x00000000,0x10481edb,0x412001dc,0x51681f07,0x10052908,0x004d37d3,0x512528d4,0x416d360f,0x200211b6,0x304a0f6d,0x6122106a,0x716a0eb1,0x300738be,0x204f2665,0x71273962,0x616f27b9}, + [16]uint32{0x3f800000,0x3f88240f,0x3fa09000,0x3fa8b40f,0x3f880294,0x3f80269b,0x3fa89294,0x3fa0b69b,0x3f900108,0x3f982507,0x3fb09108,0x3fb8b507,0x3f98039c,0x3f902793,0x3fb8939c,0x3fb0b793}, + uint32(0xfff80000), + [21]string{"0x03","0x7a","0xee","0xc2","0x61","0xb3","0xa1","0x1f","0xca","0xa8","0xbb","0x26","0x2c","0x01","0xb1","0x48","0x51","0xa0","0x37","0x13","0x00"} }, + { + /* No.828 delta:2646 weight:895 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0x53a8de3a,0x1a76474c,0x49de9976,0xbab033c0,0xe918edfa,0xa0c6748c,0xf36eaab6,0x0000301f,0x53a8ee25,0x1a767753,0x49dea969,0xbab003df,0xe918dde5,0xa0c64493,0xf36e9aa9}, + [16]uint32{0x00000000,0x8cc291bf,0x82298142,0x0eeb10fd,0x6a60c1b4,0xe6a2500b,0xe84940f6,0x648bd149,0x0924e1e8,0x85e67057,0x8b0d60aa,0x07cff115,0x6344205c,0xef86b1e3,0xe16da11e,0x6daf30a1}, + [16]uint32{0x3f800000,0x3fc66148,0x3fc114c0,0x3f877588,0x3fb53060,0x3ff35128,0x3ff424a0,0x3fb245e8,0x3f849270,0x3fc2f338,0x3fc586b0,0x3f83e7f8,0x3fb1a210,0x3ff7c358,0x3ff0b6d0,0x3fb6d798}, + uint32(0xfff80000), + [21]string{"0xa1","0x21","0x6e","0x85","0x4a","0x3d","0x8a","0xa3","0xe3","0x37","0xf2","0xd1","0x69","0x44","0xb5","0x9c","0x3e","0xd7","0x33","0xa8","0x00"} }, + { + /* No.829 delta:2275 weight:1301 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0x23c11a1a,0xa308047b,0x80c91e61,0xec2033de,0xcfe129c4,0x4f2837a5,0x6ce92dbf,0x00006c47,0x23c1765d,0xa308683c,0x80c97226,0xec205f99,0xcfe14583,0x4f285be2,0x6ce941f8}, + [16]uint32{0x00000000,0x0d1395f2,0x66045c18,0x6b17c9ea,0x07a16019,0x0ab2f5eb,0x61a53c01,0x6cb6a9f3,0x21080407,0x2c1b91f5,0x470c581f,0x4a1fcded,0x26a9641e,0x2bbaf1ec,0x40ad3806,0x4dbeadf4}, + [16]uint32{0x3f800000,0x3f8689ca,0x3fb3022e,0x3fb58be4,0x3f83d0b0,0x3f85597a,0x3fb0d29e,0x3fb65b54,0x3f908402,0x3f960dc8,0x3fa3862c,0x3fa50fe6,0x3f9354b2,0x3f95dd78,0x3fa0569c,0x3fa6df56}, + uint32(0xfff80000), + [21]string{"0x95","0xf7","0x64","0x86","0xe1","0x89","0x77","0x67","0x1e","0x73","0x88","0xb4","0x00","0xc5","0x73","0x52","0x43","0xf0","0xe6","0xf0","0x00"} }, + { + /* No.830 delta:2155 weight:1353 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x8732db4c,0x52eb0569,0xd5d9de25,0x744033ee,0xf372e8a2,0x26ab3687,0xa199edcb,0x0000454c,0x87329e00,0x52eb4025,0xd5d99b69,0x744076a2,0xf372adee,0x26ab73cb,0xa199a887}, + [16]uint32{0x00000000,0x094903fc,0x2ac00406,0x238907fa,0x04bc1964,0x0df51a98,0x2e7c1d62,0x27351e9e,0x068602e1,0x0fcf011d,0x2c4606e7,0x250f051b,0x023a1b85,0x0b731879,0x28fa1f83,0x21b31c7f}, + [16]uint32{0x3f800000,0x3f84a481,0x3f956002,0x3f91c483,0x3f825e0c,0x3f86fa8d,0x3f973e0e,0x3f939a8f,0x3f834301,0x3f87e780,0x3f962303,0x3f928782,0x3f811d0d,0x3f85b98c,0x3f947d0f,0x3f90d98e}, + uint32(0xfff80000), + [21]string{"0x3c","0x15","0xa2","0x3a","0x13","0xe1","0x2b","0xa6","0x90","0x7d","0xc1","0xbf","0x09","0xf7","0x3e","0x98","0x65","0x2f","0x1f","0x72","0x00"} }, + { + /* No.831 delta:724 weight:1289 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x820171b2,0x006ede0a,0x826fafb8,0xdb0033f5,0x59014247,0xdb6eedff,0x596f9c4d,0x000013cd,0x8201627f,0x006ecdc7,0x826fbc75,0xdb002038,0x5901518a,0xdb6efe32,0x596f8f80}, + [16]uint32{0x00000000,0x40378cfd,0x00023011,0x4035bcec,0x10040025,0x50338cd8,0x10063034,0x5031bcc9,0x0001e81a,0x403664e7,0x0003d80b,0x403454f6,0x1005e83f,0x503264c2,0x1007d82e,0x503054d3}, + [16]uint32{0x3f800000,0x3fa01bc6,0x3f800118,0x3fa01ade,0x3f880200,0x3fa819c6,0x3f880318,0x3fa818de,0x3f8000f4,0x3fa01b32,0x3f8001ec,0x3fa01a2a,0x3f8802f4,0x3fa81932,0x3f8803ec,0x3fa8182a}, + uint32(0xfff80000), + [21]string{"0x4c","0x34","0x65","0x9a","0x7c","0x4c","0xcc","0x8a","0x4b","0xc4","0x7b","0x73","0xe2","0xc0","0x77","0xb6","0xb5","0x22","0x52","0x8a","0x00"} }, + { + /* No.832 delta:1702 weight:1773 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0xe90425c6,0x7b147cad,0x9210596b,0x59f0340d,0xb0f411cb,0x22e448a0,0xcbe06d66,0x0000b1fc,0xe904943a,0x7b14cd51,0x9210e897,0x59f085f1,0xb0f4a037,0x22e4f95c,0xcbe0dc9a}, + [16]uint32{0x00000000,0x181a025e,0x00000031,0x181a026f,0x400a01ac,0x581003f2,0x400a019d,0x581003c3,0x00020017,0x18180249,0x00020026,0x18180278,0x400801bb,0x581203e5,0x4008018a,0x581203d4}, + [16]uint32{0x3f800000,0x3f8c0d01,0x3f800000,0x3f8c0d01,0x3fa00500,0x3fac0801,0x3fa00500,0x3fac0801,0x3f800100,0x3f8c0c01,0x3f800100,0x3f8c0c01,0x3fa00400,0x3fac0901,0x3fa00400,0x3fac0901}, + uint32(0xfff80000), + [21]string{"0xbc","0xdc","0xef","0x4a","0xe3","0x61","0xf5","0xa6","0xee","0x0b","0x7e","0x34","0xff","0xf4","0xce","0x85","0xc9","0x02","0x83","0x77","0x00"} }, + { + /* No.833 delta:857 weight:1471 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x69a0516a,0x64f467e0,0x0d54368a,0x7c303419,0x15906573,0x18c453f9,0x71640293,0x0000b7eb,0x69a0e681,0x64f4d00b,0x0d548161,0x7c3083f2,0x1590d298,0x18c4e412,0x7164b578}, + [16]uint32{0x00000000,0x104e0416,0x106338fb,0x002d3ced,0x004dd9e5,0x1003ddf3,0x102ee11e,0x0060e508,0x00020322,0x104c0734,0x10613bd9,0x002f3fcf,0x004fdac7,0x1001ded1,0x102ce23c,0x0062e62a}, + [16]uint32{0x3f800000,0x3f882702,0x3f88319c,0x3f80169e,0x3f8026ec,0x3f8801ee,0x3f881770,0x3f803072,0x3f800101,0x3f882603,0x3f88309d,0x3f80179f,0x3f8027ed,0x3f8800ef,0x3f881671,0x3f803173}, + uint32(0xfff80000), + [21]string{"0xb6","0xa4","0xf0","0xda","0xe0","0xb3","0x34","0xa8","0xfb","0x12","0x26","0x0d","0x4d","0x4e","0xc8","0x0a","0x31","0x72","0xb0","0xbd","0x00"} }, + { + /* No.834 delta:1512 weight:1201 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0xebf425d3,0x2178e6ac,0xca8cc37f,0x1cd0342e,0xf72411fd,0x3da8d282,0xd65cf751,0x00007185,0xebf45456,0x21789729,0xca8cb2fa,0x1cd045ab,0xf7246078,0x3da8a307,0xd65c86d4}, + [16]uint32{0x00000000,0x0004a07e,0x000080ef,0x00042091,0x10420122,0x1046a15c,0x104281cd,0x104621b3,0x10010039,0x1005a047,0x100180d6,0x100520a8,0x0043011b,0x0047a165,0x004381f4,0x0047218a}, + [16]uint32{0x3f800000,0x3f800250,0x3f800040,0x3f800210,0x3f882100,0x3f882350,0x3f882140,0x3f882310,0x3f880080,0x3f8802d0,0x3f8800c0,0x3f880290,0x3f802180,0x3f8023d0,0x3f8021c0,0x3f802390}, + uint32(0xfff80000), + [21]string{"0xca","0x55","0x4b","0x4f","0x50","0x63","0xc0","0x5c","0xc1","0xcd","0x5f","0x21","0x2e","0x57","0x37","0x5c","0xb0","0x4f","0x2d","0x50","0x00"} }, + { + /* No.835 delta:1033 weight:1607 */ + 11213, + 37, + 13, + 4, + [16]uint32{0x00000000,0xd8d8169a,0xf0c12601,0x2819309b,0xf3703430,0x2ba822aa,0x03b11231,0xdb6904ab,0x000036a1,0xd8d8203b,0xf0c110a0,0x2819063a,0xf3700291,0x2ba8140b,0x03b12490,0xdb69320a}, + [16]uint32{0x00000000,0x005020d6,0x404c01b4,0x401c2162,0x900a61e5,0x905a4133,0xd0466051,0xd0164087,0x0002a04b,0x0052809d,0x404ea1ff,0x401e8129,0x9008c1ae,0x9058e178,0xd044c01a,0xd014e0cc}, + [16]uint32{0x3f800000,0x3f802810,0x3fa02600,0x3fa00e10,0x3fc80530,0x3fc82d20,0x3fe82330,0x3fe80b20,0x3f800150,0x3f802940,0x3fa02750,0x3fa00f40,0x3fc80460,0x3fc82c70,0x3fe82260,0x3fe80a70}, + uint32(0xfff80000), + [21]string{"0xca","0x00","0x58","0xcd","0xc6","0x49","0x16","0x0a","0xca","0xbc","0x00","0x7c","0x8f","0x3a","0x88","0x09","0x16","0x73","0xd4","0xfa","0x00"} }, + { + /* No.836 delta:1121 weight:1723 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0x45ef1573,0x8fc740c3,0xca2855b0,0x33703443,0x769f2130,0xbcb77480,0xf95861f3,0x00003e92,0x45ef2be1,0x8fc77e51,0xca286b22,0x33700ad1,0x769f1fa2,0xbcb74a12,0xf9585f61}, + [16]uint32{0x00000000,0x104e08d4,0x20025019,0x304c58cd,0x20013187,0x304f3953,0x0003619e,0x104d694a,0x70257408,0x606b7cdc,0x50272411,0x40692cc5,0x5024458f,0x406a4d5b,0x70261596,0x60681d42}, + [16]uint32{0x3f800000,0x3f882704,0x3f900128,0x3f98262c,0x3f900098,0x3f98279c,0x3f8001b0,0x3f8826b4,0x3fb812ba,0x3fb035be,0x3fa81392,0x3fa03496,0x3fa81222,0x3fa03526,0x3fb8130a,0x3fb0340e}, + uint32(0xfff80000), + [21]string{"0x43","0xeb","0x93","0x60","0xe1","0x81","0xf5","0x0d","0x33","0x3b","0x8b","0x07","0xd4","0x68","0xb2","0xd8","0xd6","0xb5","0x2e","0x82","0x00"} }, + { + /* No.837 delta:972 weight:1231 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x5fa33807,0x6959b830,0x36fa8037,0x1f50345d,0x40f30c5a,0x76098c6d,0x29aab46a,0x00008310,0x5fa3bb17,0x69593b20,0x36fa0327,0x1f50b74d,0x40f38f4a,0x76090f7d,0x29aa377a}, + [16]uint32{0x00000000,0x854cf1d5,0x2054408b,0xa518b15e,0x004239da,0x850ec80f,0x20167951,0xa55a8884,0x00024367,0x854eb2b2,0x205603ec,0xa51af239,0x00407abd,0x850c8b68,0x20143a36,0xa558cbe3}, + [16]uint32{0x3f800000,0x3fc2a678,0x3f902a20,0x3fd28c58,0x3f80211c,0x3fc28764,0x3f900b3c,0x3fd2ad44,0x3f800121,0x3fc2a759,0x3f902b01,0x3fd28d79,0x3f80203d,0x3fc28645,0x3f900a1d,0x3fd2ac65}, + uint32(0xfff80000), + [21]string{"0xf2","0x6d","0x75","0x79","0xbf","0x5c","0x57","0xac","0x36","0xcc","0x10","0xf7","0xf1","0x92","0x55","0x0c","0xc1","0x8a","0x2e","0x63","0x00"} }, + { + /* No.838 delta:799 weight:1619 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0xd4424727,0xe9b0500d,0x3df2172a,0x16b0346c,0xc2f2734b,0xff006461,0x2b422346,0x0000045a,0xd442437d,0xe9b05457,0x3df21370,0x16b03036,0xc2f27711,0xff00603b,0x2b42271c}, + [16]uint32{0x00000000,0xa000ae7e,0x0003b011,0xa0031e6f,0x507f841b,0xf07f2a65,0x507c340a,0xf07c9a74,0x8420e01d,0x24204e63,0x8423500c,0x2423fe72,0xd45f6406,0x745fca78,0xd45cd417,0x745c7a69}, + [16]uint32{0x3f800000,0x3fd00057,0x3f8001d8,0x3fd0018f,0x3fa83fc2,0x3ff83f95,0x3fa83e1a,0x3ff83e4d,0x3fc21070,0x3f921027,0x3fc211a8,0x3f9211ff,0x3fea2fb2,0x3fba2fe5,0x3fea2e6a,0x3fba2e3d}, + uint32(0xfff80000), + [21]string{"0xb3","0x22","0xae","0x53","0x2e","0xe0","0x89","0x4f","0xce","0x5e","0xf9","0xb6","0x4d","0x6b","0xc2","0x61","0x80","0x5f","0x9f","0x9c","0x00"} }, + { + /* No.839 delta:700 weight:1591 */ + 11213, + 83, + 13, + 4, + [16]uint32{0x00000000,0xdcadd318,0x250ff507,0xf9a2261f,0x47203477,0x9b8de76f,0x622fc170,0xbe821268,0x00003de6,0xdcadeefe,0x250fc8e1,0xf9a21bf9,0x47200991,0x9b8dda89,0x622ffc96,0xbe822f8e}, + [16]uint32{0x00000000,0x2072dd5a,0x00037317,0x2071ae4d,0x10014202,0x30739f58,0x10023115,0x3070ec4f,0x01038413,0x21715949,0x0100f704,0x21722a5e,0x1102c611,0x31701b4b,0x1101b506,0x3173685c}, + [16]uint32{0x3f800000,0x3f90396e,0x3f8001b9,0x3f9038d7,0x3f8800a1,0x3f9839cf,0x3f880118,0x3f983876,0x3f8081c2,0x3f90b8ac,0x3f80807b,0x3f90b915,0x3f888163,0x3f98b80d,0x3f8880da,0x3f98b9b4}, + uint32(0xfff80000), + [21]string{"0x16","0x64","0x67","0x4e","0x86","0xef","0x35","0x73","0xa7","0xc5","0x3c","0xa3","0x6a","0xb4","0x27","0x9d","0xaf","0x9c","0xd3","0x4e","0x00"} }, + { + /* No.840 delta:671 weight:1325 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x761114a8,0x09a96e50,0x7fb87af8,0xef003480,0x99112028,0xe6a95ad0,0x90b84e78,0x0000de00,0x7611caa8,0x09a9b050,0x7fb8a4f8,0xef00ea80,0x9911fe28,0xe6a984d0,0x90b89078}, + [16]uint32{0x00000000,0x80021077,0x00024692,0x800056e5,0x30012031,0xb0033046,0x300366a3,0xb00176d4,0x100028e9,0x9002389e,0x10026e7b,0x90007e0c,0x200108d8,0xa00318af,0x20034e4a,0xa0015e3d}, + [16]uint32{0x3f800000,0x3fc00108,0x3f800123,0x3fc0002b,0x3f980090,0x3fd80198,0x3f9801b3,0x3fd800bb,0x3f880014,0x3fc8011c,0x3f880137,0x3fc8003f,0x3f900084,0x3fd0018c,0x3f9001a7,0x3fd000af}, + uint32(0xfff80000), + [21]string{"0x02","0x26","0xb1","0x7f","0xa1","0x8e","0x79","0x25","0x4f","0xb8","0x82","0x68","0x33","0xac","0xfc","0x63","0x69","0x28","0xfe","0x32","0x00"} }, + { + /* No.841 delta:869 weight:1569 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x2623395d,0xdf6f2fbd,0xf94c16e0,0x57903492,0x71b30dcf,0x88ff1b2f,0xaedc2272,0x0000ed29,0x2623d474,0xdf6fc294,0xf94cfbc9,0x5790d9bb,0x71b3e0e6,0x88fff606,0xaedccf5b}, + [16]uint32{0x00000000,0x10034135,0x102012d9,0x002353ec,0x42019807,0x5202d932,0x52218ade,0x4222cbeb,0x50010836,0x40024903,0x40211aef,0x50225bda,0x12009031,0x0203d104,0x022082e8,0x1223c3dd}, + [16]uint32{0x3f800000,0x3f8801a0,0x3f881009,0x3f8011a9,0x3fa100cc,0x3fa9016c,0x3fa910c5,0x3fa11165,0x3fa80084,0x3fa00124,0x3fa0108d,0x3fa8112d,0x3f890048,0x3f8101e8,0x3f811041,0x3f8911e1}, + uint32(0xfff80000), + [21]string{"0xfc","0xaa","0x84","0x86","0xbe","0x50","0x04","0x0b","0xf6","0x0d","0xc2","0xe8","0x42","0x16","0xfc","0x6d","0x4b","0x38","0xc2","0x8f","0x00"} }, + { + /* No.842 delta:1062 weight:1435 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xd02539c2,0x6f4a6813,0xbf6f51d1,0x12e034ae,0xc2c50d6c,0x7daa5cbd,0xad8f657f,0x0000f8fe,0xd025c13c,0x6f4a90ed,0xbf6fa92f,0x12e0cc50,0xc2c5f592,0x7daaa443,0xad8f9d81}, + [16]uint32{0x00000000,0x004285de,0x20001c19,0x204299c7,0x4000020f,0x404287d1,0x60001e16,0x60429bc8,0x1000381b,0x1042bdc5,0x30002402,0x3042a1dc,0x50003a14,0x5042bfca,0x7000260d,0x7042a3d3}, + [16]uint32{0x3f800000,0x3f802142,0x3f90000e,0x3f90214c,0x3fa00001,0x3fa02143,0x3fb0000f,0x3fb0214d,0x3f88001c,0x3f88215e,0x3f980012,0x3f982150,0x3fa8001d,0x3fa8215f,0x3fb80013,0x3fb82151}, + uint32(0xfff80000), + [21]string{"0xba","0x66","0xb4","0xd3","0x70","0x28","0x61","0xbe","0xab","0x15","0x4a","0x2f","0xd5","0x05","0x55","0x55","0xcc","0x4b","0xd9","0x3f","0x00"} }, + { + /* No.843 delta:3096 weight:651 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x75cf93da,0x68a27eab,0x1d6ded71,0x541034ba,0x21dfa760,0x3cb24a11,0x497dd9cb,0x0000fd22,0x75cf6ef8,0x68a28389,0x1d6d1053,0x5410c998,0x21df5a42,0x3cb2b733,0x497d24e9}, + [16]uint32{0x00000000,0x92a881ff,0x3082a019,0xa22a21e6,0x4200e20d,0xd0a863f2,0x72824214,0xe02ac3eb,0xc6014de1,0x54a9cc1e,0xf683edf8,0x642b6c07,0x8401afec,0x16a92e13,0xb4830ff5,0x262b8e0a}, + [16]uint32{0x3f800000,0x3fc95440,0x3f984150,0x3fd11510,0x3fa10071,0x3fe85431,0x3fb94121,0x3ff01561,0x3fe300a6,0x3faa54e6,0x3ffb41f6,0x3fb215b6,0x3fc200d7,0x3f8b5497,0x3fda4187,0x3f9315c7}, + uint32(0xfff80000), + [21]string{"0x7a","0x00","0x9f","0x11","0x3f","0x37","0x5f","0x73","0x7d","0x43","0x3a","0x5c","0x1c","0xd3","0x5c","0xa2","0x9d","0xf7","0x62","0xde","0x00"} }, + { + /* No.844 delta:767 weight:1483 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0x8e2486b7,0x79ff3e78,0xf7dbb8cf,0xeee034c1,0x60c4b276,0x971f0ab9,0x193b8c0e,0x0000e1f0,0x8e246747,0x79ffdf88,0xf7db593f,0xeee0d531,0x60c45386,0x971feb49,0x193b6dfe}, + [16]uint32{0x00000000,0x08359dd3,0x20020d7e,0x283790ad,0x00012a0a,0x0834b7d9,0x20032774,0x2836baa7,0x2001b60b,0x28342bd8,0x0003bb75,0x083626a6,0x20009c01,0x283501d2,0x0002917f,0x08370cac}, + [16]uint32{0x3f800000,0x3f841ace,0x3f900106,0x3f941bc8,0x3f800095,0x3f841a5b,0x3f900193,0x3f941b5d,0x3f9000db,0x3f941a15,0x3f8001dd,0x3f841b13,0x3f90004e,0x3f941a80,0x3f800148,0x3f841b86}, + uint32(0xfff80000), + [21]string{"0x40","0xf3","0xef","0xfd","0x9b","0x3d","0x5a","0xda","0x01","0x31","0xf4","0xc3","0x06","0x28","0x4c","0x73","0xb6","0xec","0xca","0xa9","0x00"} }, + { + /* No.845 delta:930 weight:1421 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0x8645d8e2,0xa671fb04,0x203423e6,0xc40034df,0x4245ec3d,0x6271cfdb,0xe4341739,0x00009772,0x86454f90,0xa6716c76,0x2034b494,0xc400a3ad,0x42457b4f,0x627158a9,0xe434804b}, + [16]uint32{0x00000000,0x80030cd5,0x0002ec77,0x8001e0a2,0x700000ff,0xf0030c2a,0x7002ec88,0xf001e05d,0x14000010,0x94030cc5,0x1402ec67,0x9401e0b2,0x640000ef,0xe4030c3a,0x6402ec98,0xe401e04d}, + [16]uint32{0x3f800000,0x3fc00186,0x3f800176,0x3fc000f0,0x3fb80000,0x3ff80186,0x3fb80176,0x3ff800f0,0x3f8a0000,0x3fca0186,0x3f8a0176,0x3fca00f0,0x3fb20000,0x3ff20186,0x3fb20176,0x3ff200f0}, + uint32(0xfff80000), + [21]string{"0xeb","0x2a","0x37","0xbe","0xf9","0x32","0xb1","0x5c","0x75","0x16","0x97","0x0f","0xeb","0x33","0x6f","0xc6","0x6a","0xf5","0xe6","0x9c","0x00"} }, + { + /* No.846 delta:623 weight:1511 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xa0078cce,0xd016dc50,0x7011509e,0x32e034ee,0x92e7b820,0xe2f6e8be,0x42f16470,0x0000d5b3,0xa007597d,0xd01609e3,0x7011852d,0x32e0e15d,0x92e76d93,0xe2f63d0d,0x42f1b1c3}, + [16]uint32{0x00000000,0x405559de,0x006071c9,0x40352817,0x0018a20f,0x404dfbd1,0x0078d3c6,0x402d8a18,0x2026110b,0x607348d5,0x204660c2,0x6013391c,0x203eb304,0x606beada,0x205ec2cd,0x600b9b13}, + [16]uint32{0x3f800000,0x3fa02aac,0x3f803038,0x3fa01a94,0x3f800c51,0x3fa026fd,0x3f803c69,0x3fa016c5,0x3f901308,0x3fb039a4,0x3f902330,0x3fb0099c,0x3f901f59,0x3fb035f5,0x3f902f61,0x3fb005cd}, + uint32(0xfff80000), + [21]string{"0xe7","0x59","0xd2","0x67","0xd3","0x39","0x05","0x27","0xef","0xec","0x00","0x28","0xcd","0xd1","0x4e","0x01","0x8e","0xd8","0xdb","0xc4","0x00"} }, + { + /* No.847 delta:1300 weight:1433 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0xaad29864,0x6095e27f,0xca477a1b,0xccd034ff,0x6602ac9b,0xac45d680,0x06974ee4,0x0000dbaa,0xaad243ce,0x609539d5,0xca47a1b1,0xccd0ef55,0x66027731,0xac450d2a,0x0697954e}, + [16]uint32{0x00000000,0x0074009e,0x386a6133,0x381e61ad,0x000b400a,0x007f4094,0x38612139,0x381521a7,0x00081017,0x007c1089,0x38627124,0x381671ba,0x0003501d,0x00775083,0x3869312e,0x381d31b0}, + [16]uint32{0x3f800000,0x3f803a00,0x3f9c3530,0x3f9c0f30,0x3f8005a0,0x3f803fa0,0x3f9c3090,0x3f9c0a90,0x3f800408,0x3f803e08,0x3f9c3138,0x3f9c0b38,0x3f8001a8,0x3f803ba8,0x3f9c3498,0x3f9c0e98}, + uint32(0xfff80000), + [21]string{"0x0a","0x68","0x3c","0x38","0xf5","0xc0","0x88","0xe7","0x47","0x50","0x79","0x90","0xed","0x72","0x83","0x30","0xad","0xd9","0x22","0x8c","0x00"} }, + { + /* No.848 delta:722 weight:1627 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xee81bc3b,0x3973624f,0xd7f2de74,0x32a03501,0xdc21893a,0x0bd3574e,0xe552eb75,0x0000cffb,0xee8173c0,0x3973adb4,0xd7f2118f,0x32a0fafa,0xdc2146c1,0x0bd398b5,0xe552248e}, + [16]uint32{0x00000000,0xc008285f,0x00043512,0xc00c1d4d,0x1002058b,0xd00a2dd4,0x10063099,0xd00e18c6,0x2000001e,0xe0082841,0x2004350c,0xe00c1d53,0x30020595,0xf00a2dca,0x30063087,0xf00e18d8}, + [16]uint32{0x3f800000,0x3fe00414,0x3f80021a,0x3fe0060e,0x3f880102,0x3fe80516,0x3f880318,0x3fe8070c,0x3f900000,0x3ff00414,0x3f90021a,0x3ff0060e,0x3f980102,0x3ff80516,0x3f980318,0x3ff8070c}, + uint32(0xfff80000), + [21]string{"0x2a","0xdb","0xc4","0x16","0x10","0x0b","0x68","0xa3","0xc7","0xe6","0xcf","0x00","0xca","0x83","0xba","0x07","0xbf","0x04","0x1d","0x4c","0x00"} }, + { + /* No.849 delta:760 weight:1487 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x9f024afb,0xec451fb7,0x7347554c,0xd2f03513,0x4df27fe8,0x3eb52aa4,0xa1b7605f,0x00006f11,0x9f0225ea,0xec4570a6,0x73473a5d,0xd2f05a02,0x4df210f9,0x3eb545b5,0xa1b70f4e}, + [16]uint32{0x00000000,0x004ca336,0x60228151,0x606e2267,0x4007887b,0x404b2b4d,0x2025092a,0x2069aa1c,0x00025018,0x004ef32e,0x6020d149,0x606c727f,0x4005d863,0x40497b55,0x20275932,0x206bfa04}, + [16]uint32{0x3f800000,0x3f802651,0x3fb01140,0x3fb03711,0x3fa003c4,0x3fa02595,0x3f901284,0x3f9034d5,0x3f800128,0x3f802779,0x3fb01068,0x3fb03639,0x3fa002ec,0x3fa024bd,0x3f9013ac,0x3f9035fd}, + uint32(0xfff80000), + [21]string{"0x3b","0xe3","0xfb","0x6d","0xb5","0x84","0x90","0x47","0xff","0x99","0x57","0x50","0xb7","0xba","0x05","0x6d","0x5b","0x1a","0x18","0x1d","0x00"} }, + { + /* No.850 delta:808 weight:1517 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x07823872,0xa954f449,0xaed6cc3b,0x4eb03520,0x49320d52,0xe7e4c169,0xe066f91b,0x00005c52,0x07826420,0xa954a81b,0xaed69069,0x4eb06972,0x49325100,0xe7e49d3b,0xe066a549}, + [16]uint32{0x00000000,0xa0018217,0x2044609c,0x8045e28b,0x40020812,0xe0038a05,0x6046688e,0xc047ea99,0x400190b8,0xe00012af,0x6045f024,0xc0447233,0x000398aa,0xa0021abd,0x2047f836,0x80467a21}, + [16]uint32{0x3f800000,0x3fd000c1,0x3f902230,0x3fc022f1,0x3fa00104,0x3ff001c5,0x3fb02334,0x3fe023f5,0x3fa000c8,0x3ff00009,0x3fb022f8,0x3fe02239,0x3f8001cc,0x3fd0010d,0x3f9023fc,0x3fc0233d}, + uint32(0xfff80000), + [21]string{"0x91","0x3f","0xc5","0x59","0xd5","0x91","0xe5","0x60","0x04","0x4e","0x61","0x3e","0xa5","0xa1","0xfa","0x46","0x8f","0x8f","0x18","0x0c","0x00"} }, + { + /* No.851 delta:779 weight:1677 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0xe735946a,0x0cb65430,0xeb83c05a,0xb9e03531,0x5ed5a15b,0xb5566101,0x5263f56b,0x000015f2,0xe7358198,0x0cb641c2,0xeb83d5a8,0xb9e020c3,0x5ed5b4a9,0xb55674f3,0x5263e099}, + [16]uint32{0x00000000,0x4040f99e,0xf0014567,0xb041bcf9,0x40108494,0x00507d0a,0xb011c1f3,0xf051386d,0x30002016,0x7040d988,0xc0016571,0x80419cef,0x7010a482,0x30505d1c,0x8011e1e5,0xc051187b}, + [16]uint32{0x3f800000,0x3fa0207c,0x3ff800a2,0x3fd820de,0x3fa00842,0x3f80283e,0x3fd808e0,0x3ff8289c,0x3f980010,0x3fb8206c,0x3fe000b2,0x3fc020ce,0x3fb80852,0x3f98282e,0x3fc008f0,0x3fe0288c}, + uint32(0xfff80000), + [21]string{"0x0c","0xa9","0xbe","0x58","0xb8","0x9d","0x41","0x22","0x0f","0xd8","0xe8","0x26","0x54","0x2d","0x6e","0x3d","0xae","0xa8","0xe9","0x83","0x00"} }, + { + /* No.852 delta:1020 weight:1639 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0x0fd1901a,0x960dc7ed,0x99dc57f7,0x32603546,0x3db1a55c,0xa46df2ab,0xabbc62b1,0x00002a86,0x0fd1ba9c,0x960ded6b,0x99dc7d71,0x32601fc0,0x3db18fda,0xa46dd82d,0xabbc4837}, + [16]uint32{0x00000000,0x400398d4,0x2400cb9f,0x6403534b,0x6000619d,0x2003f949,0x4400aa02,0x040332d6,0x101c2407,0x501fbcd3,0x341cef98,0x741f774c,0x701c459a,0x301fdd4e,0x541c8e05,0x141f16d1}, + [16]uint32{0x3f800000,0x3fa001cc,0x3f920065,0x3fb201a9,0x3fb00030,0x3f9001fc,0x3fa20055,0x3f820199,0x3f880e12,0x3fa80fde,0x3f9a0e77,0x3fba0fbb,0x3fb80e22,0x3f980fee,0x3faa0e47,0x3f8a0f8b}, + uint32(0xfff80000), + [21]string{"0xe9","0x9b","0x7c","0xe6","0x2f","0x31","0x8a","0xbf","0x21","0x64","0x7e","0x46","0xbb","0x6c","0xad","0xf1","0xc9","0x37","0xc7","0x43","0x00"} }, + { + /* No.853 delta:1314 weight:1621 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xfb9d60b0,0x14e6ab38,0xef7bcb88,0x69203557,0x92bd55e7,0x7dc69e6f,0x865bfedf,0x0000969c,0xfb9df62c,0x14e63da4,0xef7b5d14,0x6920a3cb,0x92bdc37b,0x7dc608f3,0x865b6843}, + [16]uint32{0x00000000,0x004708f2,0x042a0c1c,0x046d04ee,0x007e0837,0x003900c5,0x0454042b,0x04130cd9,0x2002301e,0x204538ec,0x24283c02,0x246f34f0,0x207c3829,0x203b30db,0x24563435,0x24113cc7}, + [16]uint32{0x3f800000,0x3f802384,0x3f821506,0x3f823682,0x3f803f04,0x3f801c80,0x3f822a02,0x3f820986,0x3f900118,0x3f90229c,0x3f92141e,0x3f92379a,0x3f903e1c,0x3f901d98,0x3f922b1a,0x3f92089e}, + uint32(0xfff80000), + [21]string{"0x7d","0x68","0x59","0xb8","0x79","0x4c","0x69","0x5a","0xf0","0xb4","0x33","0xc9","0x73","0xcd","0x09","0xfc","0x15","0x44","0xaa","0xb1","0x00"} }, + { + /* No.854 delta:1095 weight:1351 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0x01ebabda,0x2d7e4768,0x2c95ecb2,0xa2d03563,0xa33b9eb9,0x8fae720b,0x8e45d9d1,0x0000bfca,0x01eb1410,0x2d7ef8a2,0x2c955378,0xa2d08aa9,0xa33b2173,0x8faecdc1,0x8e45661b}, + [16]uint32{0x00000000,0x2047d436,0x303201ae,0x1075d598,0x602a6404,0x406db032,0x501865aa,0x705fb19c,0x00020099,0x2045d4af,0x30300137,0x1077d501,0x6028649d,0x406fb0ab,0x501a6533,0x705db105}, + [16]uint32{0x3f800000,0x3f9023ea,0x3f981900,0x3f883aea,0x3fb01532,0x3fa036d8,0x3fa80c32,0x3fb82fd8,0x3f800100,0x3f9022ea,0x3f981800,0x3f883bea,0x3fb01432,0x3fa037d8,0x3fa80d32,0x3fb82ed8}, + uint32(0xfff80000), + [21]string{"0x3b","0xfb","0xf7","0x30","0xe6","0x76","0xdd","0x7a","0x52","0x4c","0x32","0x29","0x5c","0x6b","0xa9","0x38","0x4f","0xab","0x5f","0x6e","0x00"} }, + { + /* No.855 delta:1459 weight:1741 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0xbe48330e,0x523806b5,0xec7035bb,0xaba03572,0x15e8067c,0xf99833c7,0x47d000c9,0x00006aba,0xbe4859b4,0x52386c0f,0xec705f01,0xaba05fc8,0x15e86cc6,0xf998597d,0x47d06a73}, + [16]uint32{0x00000000,0x40140c5e,0x328c1815,0x7298144b,0x005581d6,0x40418d88,0x32d999c3,0x72cd959d,0x0042001c,0x40560c42,0x32ce1809,0x72da1457,0x001781ca,0x40038d94,0x329b99df,0x728f9581}, + [16]uint32{0x3f800000,0x3fa00a06,0x3f99460c,0x3fb94c0a,0x3f802ac0,0x3fa020c6,0x3f996ccc,0x3fb966ca,0x3f802100,0x3fa02b06,0x3f99670c,0x3fb96d0a,0x3f800bc0,0x3fa001c6,0x3f994dcc,0x3fb947ca}, + uint32(0xfff80000), + [21]string{"0xe8","0x70","0x31","0x7f","0x52","0x23","0x6c","0xd5","0x38","0x42","0xbf","0x4e","0xd2","0xbf","0xb2","0xb9","0x9f","0xaa","0x8d","0x86","0x00"} }, + { + /* No.856 delta:1176 weight:1489 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0x771de0bc,0x487dcba4,0x3f602b18,0xa9803585,0xde9dd539,0xe1fdfe21,0x96e01e9d,0x00007036,0x771d908a,0x487dbb92,0x3f605b2e,0xa98045b3,0xde9da50f,0xe1fd8e17,0x96e06eab}, + [16]uint32{0x00000000,0x29000412,0xe805e89b,0xc105ec89,0x200380d6,0x090384c4,0xc806684d,0xe1066c5f,0x4010801a,0x69108408,0xa8156881,0x81156c93,0x601300cc,0x491304de,0x8816e857,0xa116ec45}, + [16]uint32{0x3f800000,0x3f948002,0x3ff402f4,0x3fe082f6,0x3f9001c0,0x3f8481c2,0x3fe40334,0x3ff08336,0x3fa00840,0x3fb48842,0x3fd40ab4,0x3fc08ab6,0x3fb00980,0x3fa48982,0x3fc40b74,0x3fd08b76}, + uint32(0xfff80000), + [21]string{"0xa1","0x85","0xa4","0x74","0x47","0x22","0xb1","0xca","0xcf","0x61","0x87","0x50","0xfa","0xc0","0x6c","0x9f","0x12","0x5b","0xbb","0x6c","0x00"} }, + { + /* No.857 delta:1294 weight:1559 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x973e91db,0x489ce950,0xdfa2788b,0x63603592,0xf45ea449,0x2bfcdcc2,0xbcc24d19,0x00009981,0x973e085a,0x489c70d1,0xdfa2e10a,0x6360ac13,0xf45e3dc8,0x2bfc4543,0xbcc2d498}, + [16]uint32{0x00000000,0xc468431a,0x10647437,0xd40c372d,0x001a8205,0xc472c11f,0x107ef632,0xd416b528,0x1000300b,0xd4687311,0x0064443c,0xc40c0726,0x101ab20e,0xd472f114,0x007ec639,0xc4168523}, + [16]uint32{0x3f800000,0x3fe23421,0x3f88323a,0x3fea061b,0x3f800d41,0x3fe23960,0x3f883f7b,0x3fea0b5a,0x3f880018,0x3fea3439,0x3f803222,0x3fe20603,0x3f880d59,0x3fea3978,0x3f803f63,0x3fe20b42}, + uint32(0xfff80000), + [21]string{"0xfd","0x07","0x97","0x8b","0x67","0x71","0xde","0x8a","0xb5","0xd0","0xc0","0xf1","0x88","0xc2","0xbd","0x8b","0x48","0xac","0x7f","0x21","0x00"} }, + { + /* No.858 delta:779 weight:1681 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xf669042d,0xed50870f,0x1b398322,0x139035ae,0xe5f93183,0xfec0b2a1,0x08a9b68c,0x00008bb7,0xf6698f9a,0xed500cb8,0x1b390895,0x1390be19,0xe5f9ba34,0xfec03916,0x08a93d3b}, + [16]uint32{0x00000000,0x001e0c56,0x004a16aa,0x00541afc,0x30234817,0x303d4441,0x30695ebd,0x307752eb,0x30025843,0x301c5415,0x30484ee9,0x305642bf,0x00211054,0x003f1c02,0x006b06fe,0x00750aa8}, + [16]uint32{0x3f800000,0x3f800f06,0x3f80250b,0x3f802a0d,0x3f9811a4,0x3f981ea2,0x3f9834af,0x3f983ba9,0x3f98012c,0x3f980e2a,0x3f982427,0x3f982b21,0x3f801088,0x3f801f8e,0x3f803583,0x3f803a85}, + uint32(0xfff80000), + [21]string{"0xc1","0x52","0xc1","0x57","0x42","0xd5","0xf8","0x98","0x38","0xbd","0xd4","0xb4","0x05","0x06","0x0f","0xb6","0xd7","0xa7","0x1d","0xf2","0x00"} }, + { + /* No.859 delta:956 weight:1207 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0xe97116c4,0x33c94c1d,0xdab85ad9,0x305035b0,0xd9212374,0x039979ad,0xeae86f69,0x0000ea7b,0xe971fcbf,0x33c9a666,0xdab8b0a2,0x3050dfcb,0xd921c90f,0x039993d6,0xeae88512}, + [16]uint32{0x00000000,0x000341dd,0x4000118c,0x40035051,0x100338a6,0x1000797b,0x5003292a,0x500068f7,0x10023402,0x100175df,0x5002258e,0x50016453,0x00010ca4,0x00024d79,0x40011d28,0x40025cf5}, + [16]uint32{0x3f800000,0x3f8001a0,0x3fa00008,0x3fa001a8,0x3f88019c,0x3f88003c,0x3fa80194,0x3fa80034,0x3f88011a,0x3f8800ba,0x3fa80112,0x3fa800b2,0x3f800086,0x3f800126,0x3fa0008e,0x3fa0012e}, + uint32(0xfff80000), + [21]string{"0x79","0x3c","0x21","0x5c","0xd4","0xcf","0x6f","0x09","0x5e","0xa0","0x97","0xcc","0x76","0x83","0x9e","0xb3","0x4e","0x00","0xeb","0x73","0x00"} }, + { + /* No.860 delta:983 weight:1513 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0x0e245ebd,0xeff14ad1,0xe1d5146c,0x1a7035c0,0x14546b7d,0xf5817f11,0xfba521ac,0x00007c15,0x0e2422a8,0xeff136c4,0xe1d56879,0x1a7049d5,0x14541768,0xf5810304,0xfba55db9}, + [16]uint32{0x00000000,0x58f4143f,0x00021c4a,0x58f60875,0x043c0a06,0x5cc81e39,0x043e164c,0x5cca0273,0x00234814,0x58d75c2b,0x0021545e,0x58d54061,0x041f4212,0x5ceb562d,0x041d5e58,0x5ce94a67}, + [16]uint32{0x3f800000,0x3fac7a0a,0x3f80010e,0x3fac7b04,0x3f821e05,0x3fae640f,0x3f821f0b,0x3fae6501,0x3f8011a4,0x3fac6bae,0x3f8010aa,0x3fac6aa0,0x3f820fa1,0x3fae75ab,0x3f820eaf,0x3fae74a5}, + uint32(0xfff80000), + [21]string{"0x5f","0xdc","0xbd","0x29","0x0d","0x42","0xe3","0x7f","0x25","0x3a","0x82","0xef","0xeb","0x90","0xee","0xb7","0xd5","0x76","0x12","0xcb","0x00"} }, + { + /* No.861 delta:731 weight:1489 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0x7999a149,0xc1bc8ad0,0xb8252b99,0xa2e035db,0xdb799492,0x635cbf0b,0x1ac51e42,0x00002e49,0x79998f00,0xc1bca499,0xb82505d0,0xa2e01b92,0xdb79badb,0x635c9142,0x1ac5300b}, + [16]uint32{0x00000000,0x007488b6,0x4000317c,0x4074b9ca,0x6001a04d,0x607528fb,0x20019131,0x20751987,0x6002419f,0x6076c929,0x200270e3,0x2076f855,0x0003e1d2,0x00776964,0x4003d0ae,0x40775818}, + [16]uint32{0x3f800000,0x3f803a44,0x3fa00018,0x3fa03a5c,0x3fb000d0,0x3fb03a94,0x3f9000c8,0x3f903a8c,0x3fb00120,0x3fb03b64,0x3f900138,0x3f903b7c,0x3f8001f0,0x3f803bb4,0x3fa001e8,0x3fa03bac}, + uint32(0xfff80000), + [21]string{"0x76","0xe9","0x83","0x20","0x49","0xec","0x86","0xea","0x99","0x32","0xdb","0x54","0x92","0x99","0x5b","0x5d","0x98","0x5e","0x63","0x13","0x00"} }, + { + /* No.862 delta:1141 weight:1621 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x10b14888,0xead94d30,0xfa6805b8,0xed6035ec,0xfdd17d64,0x07b978dc,0x17083054,0x0000ac0f,0x10b1e487,0xead9e13f,0xfa68a9b7,0xed6099e3,0xfdd1d16b,0x07b9d4d3,0x17089c5b}, + [16]uint32{0x00000000,0x9410c0b6,0x2002c893,0xb4120825,0x20016148,0xb411a1fe,0x0003a9db,0x9413696d,0x407fe017,0xd46f20a1,0x607d2884,0xf46de832,0x607e815f,0xf46e41e9,0x407c49cc,0xd46c897a}, + [16]uint32{0x3f800000,0x3fca0860,0x3f900164,0x3fda0904,0x3f9000b0,0x3fda08d0,0x3f8001d4,0x3fca09b4,0x3fa03ff0,0x3fea3790,0x3fb03e94,0x3ffa36f4,0x3fb03f40,0x3ffa3720,0x3fa03e24,0x3fea3644}, + uint32(0xfff80000), + [21]string{"0x2d","0x56","0x85","0x1c","0x96","0x52","0xef","0xf5","0xaa","0x3d","0xf7","0x74","0xed","0x2c","0x37","0xce","0xec","0xe6","0xbc","0x8a","0x00"} }, + { + /* No.863 delta:1001 weight:1425 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x59bce008,0xd8404bfa,0x81fcabf2,0xc1a035ff,0x981cd5f7,0x19e07e05,0x405c9e0d,0x000063f5,0x59bc83fd,0xd840280f,0x81fcc807,0xc1a0560a,0x981cb602,0x19e01df0,0x405cfdf8}, + [16]uint32{0x00000000,0x002d08ba,0x00542c71,0x007924cb,0x0004341e,0x00293ca4,0x0050186f,0x007d10d5,0x110111e8,0x112c1952,0x11553d99,0x11783523,0x110525f6,0x11282d4c,0x11510987,0x117c013d}, + [16]uint32{0x3f800000,0x3f801684,0x3f802a16,0x3f803c92,0x3f80021a,0x3f80149e,0x3f80280c,0x3f803e88,0x3f888088,0x3f88960c,0x3f88aa9e,0x3f88bc1a,0x3f888292,0x3f889416,0x3f88a884,0x3f88be00}, + uint32(0xfff80000), + [21]string{"0xcc","0x22","0x57","0xe8","0xc9","0x5c","0xeb","0x4c","0x25","0x7d","0x58","0x73","0x0b","0x07","0xda","0x05","0x8c","0x89","0xc8","0x64","0x00"} }, + { + /* No.864 delta:1314 weight:1519 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0xdf30e092,0x48956890,0x97a58802,0x10903608,0xcfa0d69a,0x58055e98,0x8735be0a,0x00007231,0xdf3092a3,0x48951aa1,0x97a5fa33,0x10904439,0xcfa0a4ab,0x58052ca9,0x8735cc3b}, + [16]uint32{0x00000000,0xc07d1c5a,0x200221f7,0xe07f3dad,0x00670903,0xc01a1559,0x206528f4,0xe01834ae,0x001841c8,0xc0655d92,0x201a603f,0xe0677c65,0x007f48cb,0xc0025491,0x207d693c,0xe0007566}, + [16]uint32{0x3f800000,0x3fe03e8e,0x3f900110,0x3ff03f9e,0x3f803384,0x3fe00d0a,0x3f903294,0x3ff00c1a,0x3f800c20,0x3fe032ae,0x3f900d30,0x3ff033be,0x3f803fa4,0x3fe0012a,0x3f903eb4,0x3ff0003a}, + uint32(0xfff80000), + [21]string{"0xe0","0x27","0x66","0x12","0x3c","0xb7","0xa4","0xb4","0xd5","0x59","0xc5","0xe2","0xb3","0x88","0x48","0x8a","0xd4","0xb7","0xe7","0x30","0x00"} }, + { + /* No.865 delta:942 weight:987 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0xcae33203,0x6dac87eb,0xa74fb5e8,0x35503619,0xffb3041a,0x58fcb1f2,0x921f83f1,0x0000a0f6,0xcae392f5,0x6dac271d,0xa74f151e,0x355096ef,0xffb3a4ec,0x58fc1104,0x921f2307}, + [16]uint32{0x00000000,0x006200ba,0x401100d3,0x40730069,0x400ee0be,0x406ce004,0x001fe06d,0x007de0d7,0x10190010,0x107b00aa,0x500800c3,0x506a0079,0x5017e0ae,0x5075e014,0x1006e07d,0x1064e0c7}, + [16]uint32{0x3f800000,0x3f803100,0x3fa00880,0x3fa03980,0x3fa00770,0x3fa03670,0x3f800ff0,0x3f803ef0,0x3f880c80,0x3f883d80,0x3fa80400,0x3fa83500,0x3fa80bf0,0x3fa83af0,0x3f880370,0x3f883270}, + uint32(0xfff80000), + [21]string{"0x7a","0xc2","0x27","0x92","0xec","0x83","0x41","0x36","0x20","0x1e","0x63","0x6f","0x5a","0x73","0xb9","0xe7","0xe5","0x5f","0xae","0xc2","0x00"} }, + { + /* No.866 delta:903 weight:1561 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x6fbfa028,0x651705ec,0x0aa8a5c4,0xb0303621,0xdf8f9609,0xd52733cd,0xba9893e5,0x0000fdf9,0x6fbf5dd1,0x6517f815,0x0aa8583d,0xb030cbd8,0xdf8f6bf0,0xd527ce34,0xba986e1c}, + [16]uint32{0x00000000,0x204c0152,0x0002d1dd,0x204ed08f,0x40208403,0x606c8551,0x402255de,0x606e548c,0x001187f7,0x205d86a5,0x0013562a,0x205f5778,0x403103f4,0x607d02a6,0x4033d229,0x607fd37b}, + [16]uint32{0x3f800000,0x3f902600,0x3f800168,0x3f902768,0x3fa01042,0x3fb03642,0x3fa0112a,0x3fb0372a,0x3f8008c3,0x3f902ec3,0x3f8009ab,0x3f902fab,0x3fa01881,0x3fb03e81,0x3fa019e9,0x3fb03fe9}, + uint32(0xfff80000), + [21]string{"0xb6","0xc5","0x1d","0x52","0x4e","0x27","0x15","0xf8","0x3f","0x41","0x0a","0x93","0x64","0xdd","0xdc","0x0b","0x9a","0x6e","0x4c","0x53","0x00"} }, + { + /* No.867 delta:995 weight:1579 */ + 11213, + 34, + 13, + 4, + [16]uint32{0x00000000,0xe997bc00,0x40346e90,0xa9a3d290,0x68f03633,0x81678a33,0x28c458a3,0xc153e4a3,0x00003483,0xe9978883,0x40345a13,0xa9a3e613,0x68f002b0,0x8167beb0,0x28c46c20,0xc153d020}, + [16]uint32{0x00000000,0xb0061bf4,0x005d0d9d,0xb05b1669,0x0002b812,0xb004a3e6,0x005fb58f,0xb059ae7b,0x403c0158,0xf03a1aac,0x40610cc5,0xf0671731,0x403eb94a,0xf038a2be,0x4063b4d7,0xf065af23}, + [16]uint32{0x3f800000,0x3fd8030d,0x3f802e86,0x3fd82d8b,0x3f80015c,0x3fd80251,0x3f802fda,0x3fd82cd7,0x3fa01e00,0x3ff81d0d,0x3fa03086,0x3ff8338b,0x3fa01f5c,0x3ff81c51,0x3fa031da,0x3ff832d7}, + uint32(0xfff80000), + [21]string{"0x6a","0x0d","0x6e","0x70","0xac","0x49","0x3a","0xdd","0x75","0xec","0xe6","0xae","0xa7","0x25","0x75","0xd9","0xca","0xd2","0x30","0xc2","0x00"} }, + { + /* No.868 delta:2268 weight:1323 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0xdc7cb726,0x38617a10,0xe41dcd36,0x1a40364a,0xc63c816c,0x22214c5a,0xfe5dfb7c,0x000044f9,0xdc7cf3df,0x38613ee9,0xe41d89cf,0x1a4072b3,0xc63cc595,0x222108a3,0xfe5dbf85}, + [16]uint32{0x00000000,0x44390bb6,0x7048083c,0x3471038a,0x0c4041bb,0x48794a0d,0x7c084987,0x38314231,0x020855c3,0x46315e75,0x72405dff,0x36795649,0x0e481478,0x4a711fce,0x7e001c44,0x3a3917f2}, + [16]uint32{0x3f800000,0x3fa21c85,0x3fb82404,0x3f9a3881,0x3f862020,0x3fa43ca5,0x3fbe0424,0x3f9c18a1,0x3f81042a,0x3fa318af,0x3fb9202e,0x3f9b3cab,0x3f87240a,0x3fa5388f,0x3fbf000e,0x3f9d1c8b}, + uint32(0xfff80000), + [21]string{"0x4a","0x0e","0xd2","0x58","0x0d","0x8a","0xd5","0x98","0x04","0xe8","0x45","0x15","0x8d","0xbf","0xbc","0x47","0x75","0x57","0x51","0xbb","0x00"} }, + { + /* No.869 delta:946 weight:989 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0xceec2799,0xd9de0701,0x17322098,0x17503659,0xd9bc11c0,0xce8e3158,0x006216c1,0x00004052,0xceec67cb,0xd9de4753,0x173260ca,0x1750760b,0xd9bc5192,0xce8e710a,0x00625693}, + [16]uint32{0x00000000,0x1073887f,0x003c811d,0x104f0962,0x04004c19,0x1473c466,0x043ccd04,0x144f457b,0x007079d6,0x1003f1a9,0x004cf8cb,0x103f70b4,0x047035cf,0x1403bdb0,0x044cb4d2,0x143f3cad}, + [16]uint32{0x3f800000,0x3f8839c4,0x3f801e40,0x3f882784,0x3f820026,0x3f8a39e2,0x3f821e66,0x3f8a27a2,0x3f80383c,0x3f8801f8,0x3f80267c,0x3f881fb8,0x3f82381a,0x3f8a01de,0x3f82265a,0x3f8a1f9e}, + uint32(0xfff80000), + [21]string{"0xf7","0xbb","0x17","0x9f","0x1d","0x34","0xfd","0xfd","0x62","0x4b","0x8c","0xf4","0xa0","0x16","0xe6","0x9d","0x9c","0x85","0x41","0x5d","0x00"} }, + { + /* No.870 delta:642 weight:1347 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0xc995bfae,0xa256e02b,0x6bc35f85,0x20d03669,0xe94589c7,0x8286d642,0x4b1369ec,0x0000c57d,0xc9957ad3,0xa2562556,0x6bc39af8,0x20d0f314,0xe9454cba,0x8286133f,0x4b13ac91}, + [16]uint32{0x00000000,0x09025252,0x0403217c,0x0d01732e,0x2002080b,0x29005a59,0x24012977,0x2d037b25,0x1000100d,0x1902425f,0x14033171,0x1d016323,0x30021806,0x39004a54,0x3401397a,0x3d036b28}, + [16]uint32{0x3f800000,0x3f848129,0x3f820190,0x3f8680b9,0x3f900104,0x3f94802d,0x3f920094,0x3f9681bd,0x3f880008,0x3f8c8121,0x3f8a0198,0x3f8e80b1,0x3f98010c,0x3f9c8025,0x3f9a009c,0x3f9e81b5}, + uint32(0xfff80000), + [21]string{"0xb4","0xa9","0x35","0xad","0xf3","0xa9","0x37","0xdc","0x5a","0x13","0x87","0x6a","0x41","0x36","0x38","0x20","0xa3","0x72","0xac","0x6b","0x00"} }, + { + /* No.871 delta:964 weight:747 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x9a4c8644,0xb9bb929f,0x23f714db,0x89a0367e,0x13ecb03a,0x301ba4e1,0xaa5722a5,0x00005b8e,0x9a4cddca,0xb9bbc911,0x23f74f55,0x89a06df0,0x13ecebb4,0x301bff6f,0xaa57792b}, + [16]uint32{0x00000000,0x0024021f,0x4002541c,0x40265603,0x10052cce,0x10212ed1,0x500778d2,0x50237acd,0x90428d0b,0x90668f14,0xd040d917,0xd064db08,0x8047a1c5,0x8063a3da,0xc045f5d9,0xc061f7c6}, + [16]uint32{0x3f800000,0x3f801201,0x3fa0012a,0x3fa0132b,0x3f880296,0x3f881097,0x3fa803bc,0x3fa811bd,0x3fc82146,0x3fc83347,0x3fe8206c,0x3fe8326d,0x3fc023d0,0x3fc031d1,0x3fe022fa,0x3fe030fb}, + uint32(0xfff80000), + [21]string{"0x6f","0xf0","0xf9","0x07","0x81","0xff","0xbf","0xe7","0xde","0x62","0x6d","0x91","0x9b","0x5e","0x9c","0x7a","0x93","0x0b","0x24","0xd8","0x00"} }, + { + /* No.872 delta:639 weight:1661 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xabf0eda5,0x019669b4,0xaa668411,0x20e03687,0x8b10db22,0x21765f33,0x8a86b296,0x000013b0,0xabf0fe15,0x01967a04,0xaa6697a1,0x20e02537,0x8b10c892,0x21764c83,0x8a86a126}, + [16]uint32{0x00000000,0x40082add,0x00047a8c,0x400c5051,0x60403c05,0x204816d8,0x60444689,0x204c6c54,0x5064840a,0x106caed7,0x5060fe86,0x1068d45b,0x3024b80f,0x702c92d2,0x3020c283,0x7028e85e}, + [16]uint32{0x3f800000,0x3fa00415,0x3f80023d,0x3fa00628,0x3fb0201e,0x3f90240b,0x3fb02223,0x3f902636,0x3fa83242,0x3f883657,0x3fa8307f,0x3f88346a,0x3f98125c,0x3fb81649,0x3f981061,0x3fb81474}, + uint32(0xfff80000), + [21]string{"0x5e","0x0f","0x90","0xe4","0x27","0x62","0xe7","0x76","0xdf","0xac","0xe5","0x05","0x37","0x2b","0xf7","0xcf","0x1b","0x97","0x61","0x9d","0x00"} }, + { + /* No.873 delta:1277 weight:1617 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x92223d35,0xc803359d,0x5a2108a8,0xbbc03699,0x29e20bac,0x73c30304,0xe1e13e31,0x00007ecb,0x922243fe,0xc8034b56,0x5a217663,0xbbc04852,0x29e27567,0x73c37dcf,0xe1e140fa}, + [16]uint32{0x00000000,0x166c40fa,0x1072c1db,0x061e8121,0x0048201c,0x162460e6,0x103ae1c7,0x0656a13d,0x0024804a,0x1648c0b0,0x10564191,0x063a016b,0x006ca056,0x1600e0ac,0x101e618d,0x06722177}, + [16]uint32{0x3f800000,0x3f8b3620,0x3f883960,0x3f830f40,0x3f802410,0x3f8b1230,0x3f881d70,0x3f832b50,0x3f801240,0x3f8b2460,0x3f882b20,0x3f831d00,0x3f803650,0x3f8b0070,0x3f880f30,0x3f833910}, + uint32(0xfff80000), + [21]string{"0x9a","0x75","0xc2","0x26","0x42","0x6d","0xd3","0x58","0xa0","0x0c","0xc5","0xe4","0x5b","0xa8","0x66","0x13","0xc6","0x7b","0x9d","0x53","0x00"} }, + { + /* No.874 delta:1547 weight:1545 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x2101072b,0x9f9b424d,0xbe9a4566,0xdb7036af,0xfa713184,0x44eb74e2,0x65ea73c9,0x0000e270,0x2101e55b,0x9f9ba03d,0xbe9aa716,0xdb70d4df,0xfa71d3f4,0x44eb9692,0x65ea91b9}, + [16]uint32{0x00000000,0x004e80bd,0x0072611b,0x003ce1a6,0x006c0158,0x002281e5,0x001e6043,0x0050e0fe,0x00022094,0x004ca029,0x0070418f,0x003ec132,0x006e21cc,0x0020a171,0x001c40d7,0x0052c06a}, + [16]uint32{0x3f800000,0x3f802740,0x3f803930,0x3f801e70,0x3f803600,0x3f801140,0x3f800f30,0x3f802870,0x3f800110,0x3f802650,0x3f803820,0x3f801f60,0x3f803710,0x3f801050,0x3f800e20,0x3f802960}, + uint32(0xfff80000), + [21]string{"0xf7","0x13","0xbd","0x63","0x07","0xbe","0xd7","0x1e","0xc7","0x67","0xb4","0xe2","0xd4","0xfa","0x66","0x2a","0xd0","0x05","0x26","0x60","0x00"} }, + { + /* No.875 delta:1557 weight:1661 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0xfb67e68a,0x70384856,0x8b5faedc,0x96d036b7,0x6db7d03d,0xe6e87ee1,0x1d8f986b,0x0000b1b9,0xfb675733,0x7038f9ef,0x8b5f1f65,0x96d0870e,0x6db76184,0xe6e8cf58,0x1d8f29d2}, + [16]uint32{0x00000000,0x20204d1e,0x16fb0414,0x36db490a,0x2444c132,0x04648c2c,0x32bfc526,0x129f8838,0x5000a017,0x7020ed09,0x46fba403,0x66dbe91d,0x74446125,0x54642c3b,0x62bf6531,0x429f282f}, + [16]uint32{0x3f800000,0x3f901026,0x3f8b7d82,0x3f9b6da4,0x3f922260,0x3f823246,0x3f995fe2,0x3f894fc4,0x3fa80050,0x3fb81076,0x3fa37dd2,0x3fb36df4,0x3fba2230,0x3faa3216,0x3fb15fb2,0x3fa14f94}, + uint32(0xfff80000), + [21]string{"0x1b","0x2c","0xda","0xc0","0xcd","0x57","0x5c","0xa3","0x5e","0x5e","0xb6","0x64","0xe9","0xb0","0xbf","0x11","0x71","0xbf","0xaa","0xd6","0x00"} }, + { + /* No.876 delta:908 weight:1165 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x525ea5b4,0xab0118d9,0xf95fbd6d,0x362036c9,0x647e937d,0x9d212e10,0xcf7f8ba4,0x00008bac,0x525e2e18,0xab019375,0xf95f36c1,0x3620bd65,0x647e18d1,0x9d21a5bc,0xcf7f0008}, + [16]uint32{0x00000000,0x004d0713,0x7703101f,0x774e170c,0x0002d338,0x004fd42b,0x7701c327,0x774cc434,0x00017805,0x004c7f16,0x7702681a,0x774f6f09,0x0003ab3d,0x004eac2e,0x7700bb22,0x774dbc31}, + [16]uint32{0x3f800000,0x3f802683,0x3fbb8188,0x3fbba70b,0x3f800169,0x3f8027ea,0x3fbb80e1,0x3fbba662,0x3f8000bc,0x3f80263f,0x3fbb8134,0x3fbba7b7,0x3f8001d5,0x3f802756,0x3fbb805d,0x3fbba6de}, + uint32(0xfff80000), + [21]string{"0x26","0x50","0x8b","0xaa","0x16","0x7c","0x00","0x6b","0x02","0xc1","0xeb","0xe8","0x05","0xbf","0xb1","0xbd","0xc0","0x77","0x65","0x5d","0x00"} }, + { + /* No.877 delta:877 weight:1003 */ + 11213, + 70, + 13, + 4, + [16]uint32{0x00000000,0x2f911523,0xd308881f,0xfc999d3c,0x8e1036da,0xa18123f9,0x5d18bec5,0x7289abe6,0x00002e80,0x2f913ba3,0xd308a69f,0xfc99b3bc,0x8e10185a,0xa1810d79,0x5d189045,0x72898566}, + [16]uint32{0x00000000,0x1065da1b,0x50130aca,0x4076d0d1,0x50088075,0x406d5a6e,0x001b8abf,0x107e50a4,0x00482196,0x102dfb8d,0x505b2b5c,0x403ef147,0x5040a1e3,0x40257bf8,0x0053ab29,0x10367132}, + [16]uint32{0x3f800000,0x3f8832ed,0x3fa80985,0x3fa03b68,0x3fa80440,0x3fa036ad,0x3f800dc5,0x3f883f28,0x3f802410,0x3f8816fd,0x3fa82d95,0x3fa01f78,0x3fa82050,0x3fa012bd,0x3f8029d5,0x3f881b38}, + uint32(0xfff80000), + [21]string{"0x99","0x0b","0x82","0xb9","0x1d","0xce","0xe8","0x83","0xe3","0xe2","0x8c","0x18","0xa0","0x47","0x49","0x75","0x3b","0xb7","0x0d","0xd9","0x00"} }, + { + /* No.878 delta:860 weight:1667 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x93d31824,0x7ca5708d,0xef7668a9,0xef6036ec,0x7cb32ec8,0x93c54661,0x00165e45,0x0000abb1,0x93d3b395,0x7ca5db3c,0xef76c318,0xef609d5d,0x7cb38579,0x93c5edd0,0x0016f5f4}, + [16]uint32{0x00000000,0x0002e1b2,0x100081de,0x1002606c,0x30009104,0x300270b6,0x200010da,0x2002f168,0x64804017,0x6482a1a5,0x7480c1c9,0x7482207b,0x5480d113,0x548230a1,0x448050cd,0x4482b17f}, + [16]uint32{0x3f800000,0x3f800170,0x3f880040,0x3f880130,0x3f980048,0x3f980138,0x3f900008,0x3f900178,0x3fb24020,0x3fb24150,0x3fba4060,0x3fba4110,0x3faa4068,0x3faa4118,0x3fa24028,0x3fa24158}, + uint32(0xfff80000), + [21]string{"0x6d","0x1b","0xb1","0x33","0x2d","0xc0","0x59","0x30","0x13","0xcb","0x07","0x05","0xb2","0x03","0x87","0x09","0x48","0xc5","0x27","0xae","0x00"} }, + { + /* No.879 delta:1043 weight:1415 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xd85b0140,0xe0c80f47,0x38930e07,0xafb036fb,0x77eb37bb,0x4f7839bc,0x972338fc,0x0000d26a,0xd85bd32a,0xe0c8dd2d,0x3893dc6d,0xafb0e491,0x77ebe5d1,0x4f78ebd6,0x9723ea96}, + [16]uint32{0x00000000,0x40022d36,0x205c10f5,0x605e3dc3,0x5008001d,0x100a2d2b,0x705410e8,0x30563dde,0x400104b3,0x00032985,0x605d1446,0x205f3970,0x100904ae,0x500b2998,0x3055145b,0x7057396d}, + [16]uint32{0x3f800000,0x3fa00116,0x3f902e08,0x3fb02f1e,0x3fa80400,0x3f880516,0x3fb82a08,0x3f982b1e,0x3fa00082,0x3f800194,0x3fb02e8a,0x3f902f9c,0x3f880482,0x3fa80594,0x3f982a8a,0x3fb82b9c}, + uint32(0xfff80000), + [21]string{"0x46","0x33","0x05","0xd4","0x65","0x7a","0xee","0xe4","0x96","0x70","0x97","0xd2","0x5c","0x46","0x2c","0x9c","0x86","0x9a","0x5c","0x0f","0x00"} }, + { + /* No.880 delta:892 weight:1667 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0x74bfc8fe,0x020f0ad0,0x76b0c22e,0xcef03703,0xba4ffffd,0xccff3dd3,0xb840f52d,0x000080e4,0x74bf481a,0x020f8a34,0x76b042ca,0xcef0b7e7,0xba4f7f19,0xccffbd37,0xb84075c9}, + [16]uint32{0x00000000,0x100240ba,0x4003206f,0x500160d5,0x7001001e,0x600340a4,0x30022071,0x200060cb,0x6000a418,0x7002e4a2,0x20038477,0x3001c4cd,0x1001a406,0x0003e4bc,0x50028469,0x4000c4d3}, + [16]uint32{0x3f800000,0x3f880120,0x3fa00190,0x3fa800b0,0x3fb80080,0x3fb001a0,0x3f980110,0x3f900030,0x3fb00052,0x3fb80172,0x3f9001c2,0x3f9800e2,0x3f8800d2,0x3f8001f2,0x3fa80142,0x3fa00062}, + uint32(0xfff80000), + [21]string{"0x7a","0xd9","0x60","0xbc","0x28","0x8d","0xd8","0xe0","0x58","0x52","0x81","0xfb","0xfc","0xb8","0x29","0x91","0xda","0x00","0x36","0x31","0x00"} }, + { + /* No.881 delta:2436 weight:1101 */ + 11213, + 6, + 13, + 4, + [16]uint32{0x00000000,0x48393825,0x674d786c,0x2f744049,0xb930371d,0xf1090f38,0xde7d4f71,0x96447754,0x0000a104,0x48399921,0x674dd968,0x2f74e14d,0xb9309619,0xf109ae3c,0xde7dee75,0x9644d650}, + [16]uint32{0x00000000,0xe04051f6,0x4c301e29,0xac704fdf,0xa2242a12,0x42647be4,0xee14343b,0x0e5465cd,0x09022011,0xe94271e7,0x45323e38,0xa5726fce,0xab260a03,0x4b665bf5,0xe716142a,0x075645dc}, + [16]uint32{0x3f800000,0x3ff02028,0x3fa6180f,0x3fd63827,0x3fd11215,0x3fa1323d,0x3ff70a1a,0x3f872a32,0x3f848110,0x3ff4a138,0x3fa2991f,0x3fd2b937,0x3fd59305,0x3fa5b32d,0x3ff38b0a,0x3f83ab22}, + uint32(0xfff80000), + [21]string{"0x78","0x09","0x2d","0x93","0x6c","0x36","0x91","0x06","0x4d","0x4a","0xca","0x78","0xf7","0xdb","0xf1","0xde","0xd8","0x1e","0x73","0x47","0x00"} }, + { + /* No.882 delta:775 weight:1661 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xd2458a0b,0xd58ec846,0x07cb424d,0x60803722,0xb2c5bd29,0xb50eff64,0x674b756f,0x000003ad,0xd24589a6,0xd58ecbeb,0x07cb41e0,0x6080348f,0xb2c5be84,0xb50efcc9,0x674b76c2}, + [16]uint32{0x00000000,0x1022117e,0x0069dd8f,0x104bccf1,0x10482009,0x006a3177,0x1021fd86,0x0003ecf8,0xc0100405,0xd032157b,0xc079d98a,0xd05bc8f4,0xd058240c,0xc07a3572,0xd031f983,0xc013e8fd}, + [16]uint32{0x3f800000,0x3f881108,0x3f8034ee,0x3f8825e6,0x3f882410,0x3f803518,0x3f8810fe,0x3f8001f6,0x3fe00802,0x3fe8190a,0x3fe03cec,0x3fe82de4,0x3fe82c12,0x3fe03d1a,0x3fe818fc,0x3fe009f4}, + uint32(0xfff80000), + [21]string{"0x9d","0x1c","0x6d","0x5a","0x84","0xb3","0x8b","0x29","0xf8","0x89","0x8f","0x04","0xd8","0x7a","0x22","0xf3","0xab","0xab","0x3a","0xae","0x00"} }, + { + /* No.883 delta:1347 weight:1721 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xc401bf67,0x51424b5e,0x9543f439,0x39e03731,0xfde18856,0x68a27c6f,0xaca3c308,0x000054d0,0xc401ebb7,0x51421f8e,0x9543a0e9,0x39e063e1,0xfde1dc86,0x68a228bf,0xaca397d8}, + [16]uint32{0x00000000,0x104940d3,0x407ac182,0x50338151,0x3005515f,0x204c118c,0x707f90dd,0x6036d00e,0x202e2818,0x306768cb,0x6054e99a,0x701da949,0x102b7947,0x00623994,0x5051b8c5,0x4018f816}, + [16]uint32{0x3f800000,0x3f8824a0,0x3fa03d60,0x3fa819c0,0x3f9802a8,0x3f902608,0x3fb83fc8,0x3fb01b68,0x3f901714,0x3f9833b4,0x3fb02a74,0x3fb80ed4,0x3f8815bc,0x3f80311c,0x3fa828dc,0x3fa00c7c}, + uint32(0xfff80000), + [21]string{"0xe2","0x8a","0x83","0xdf","0xec","0x34","0xc5","0x13","0x88","0xac","0x81","0xad","0xfe","0x64","0x4c","0xc5","0x66","0xc5","0x74","0x1e","0x00"} }, + { + /* No.884 delta:1636 weight:1539 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0x5d7c2fec,0xdbe83f7c,0x86941090,0x7d103740,0x206c18ac,0xa6f8083c,0xfb8427d0,0x0000c3ee,0x5d7cec02,0xdbe8fc92,0x8694d37e,0x7d10f4ae,0x206cdb42,0xa6f8cbd2,0xfb84e43e}, + [16]uint32{0x00000000,0x480ea25f,0x70c20a1a,0x38cca845,0x43881511,0x0b86b74e,0x334a1f0b,0x7b44bd54,0x20160133,0x6818a36c,0x50d40b29,0x18daa976,0x639e1422,0x2b90b67d,0x135c1e38,0x5b52bc67}, + [16]uint32{0x3f800000,0x3fa40751,0x3fb86105,0x3f9c6654,0x3fa1c40a,0x3f85c35b,0x3f99a50f,0x3fbda25e,0x3f900b00,0x3fb40c51,0x3fa86a05,0x3f8c6d54,0x3fb1cf0a,0x3f95c85b,0x3f89ae0f,0x3fada95e}, + uint32(0xfff80000), + [21]string{"0xf9","0x2e","0x2f","0x68","0x78","0x1f","0x32","0x86","0x69","0x52","0xf1","0x23","0xce","0xd5","0x12","0xe0","0x9f","0xf7","0xdd","0x9e","0x00"} }, + { + /* No.885 delta:724 weight:1505 */ + 11213, + 86, + 13, + 4, + [16]uint32{0x00000000,0xa64c89b4,0x7dfc4bdb,0xdbb0c26f,0x74e03759,0xd2acbeed,0x091c7c82,0xaf50f536,0x0000f7e6,0xa64c7e52,0x7dfcbc3d,0xdbb03589,0x74e0c0bf,0xd2ac490b,0x091c8b64,0xaf5002d0}, + [16]uint32{0x00000000,0x006421d6,0xb000c01f,0xb064e1c9,0x0002918e,0x0066b058,0xb0025191,0xb0667047,0x0010181b,0x007439cd,0xb010d804,0xb074f9d2,0x00128995,0x0076a843,0xb012498a,0xb076685c}, + [16]uint32{0x3f800000,0x3f803210,0x3fd80060,0x3fd83270,0x3f800148,0x3f803358,0x3fd80128,0x3fd83338,0x3f80080c,0x3f803a1c,0x3fd8086c,0x3fd83a7c,0x3f800944,0x3f803b54,0x3fd80924,0x3fd83b34}, + uint32(0xfff80000), + [21]string{"0x1a","0x4a","0xd2","0x74","0x26","0x98","0x8d","0xd8","0x6d","0xbc","0xcf","0xa9","0xc2","0xa0","0x46","0x66","0xf3","0x2f","0xa0","0x67","0x00"} }, + { + /* No.886 delta:923 weight:1503 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0xa4699f96,0x470c0e97,0xe3659101,0x57003765,0xf369a8f3,0x100c39f2,0xb465a664,0x0000b2c4,0xa4692d52,0x470cbc53,0xe36523c5,0x570085a1,0xf3691a37,0x100c8b36,0xb46514a0}, + [16]uint32{0x00000000,0x203ac79a,0x0000ec11,0x203a2b8b,0x0003e013,0x20392789,0x00030c02,0x2039cb98,0x103631f4,0x300cf66e,0x1036dde5,0x300c1a7f,0x1035d1e7,0x300f167d,0x10353df6,0x300ffa6c}, + [16]uint32{0x3f800000,0x3f901d63,0x3f800076,0x3f901d15,0x3f8001f0,0x3f901c93,0x3f800186,0x3f901ce5,0x3f881b18,0x3f98067b,0x3f881b6e,0x3f98060d,0x3f881ae8,0x3f98078b,0x3f881a9e,0x3f9807fd}, + uint32(0xfff80000), + [21]string{"0xa9","0x3c","0x68","0x0f","0xe0","0xbf","0x83","0xab","0xc1","0xf5","0xac","0x05","0x00","0xda","0xce","0xc0","0x28","0x28","0xf8","0x2c","0x00"} }, + { + /* No.887 delta:1672 weight:1567 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0xdf576555,0x6ff90ea8,0xb0ae6bfd,0x6f70377b,0xb027522e,0x008939d3,0xdfde5c86,0x00000e20,0xdf576b75,0x6ff90088,0xb0ae65dd,0x6f70395b,0xb0275c0e,0x008937f3,0xdfde52a6}, + [16]uint32{0x00000000,0x1024419e,0x00428131,0x1066c0af,0x0002805c,0x1026c1c2,0x0040016d,0x106440f3,0x4020009a,0x50044104,0x406281ab,0x5046c035,0x402280c6,0x5006c158,0x406001f7,0x50444069}, + [16]uint32{0x3f800000,0x3f881220,0x3f802140,0x3f883360,0x3f800140,0x3f881360,0x3f802000,0x3f883220,0x3fa01000,0x3fa80220,0x3fa03140,0x3fa82360,0x3fa01140,0x3fa80360,0x3fa03000,0x3fa82220}, + uint32(0xfff80000), + [21]string{"0xb2","0xec","0x94","0x35","0x86","0x06","0xc1","0x46","0xde","0xff","0x2f","0x7b","0x10","0x42","0x33","0x8b","0xe2","0x4d","0x26","0x77","0x00"} }, + { + /* No.888 delta:1280 weight:1649 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x3600b146,0xc252ecd9,0xf4525d9f,0x04a03780,0x32a086c6,0xc6f2db59,0xf0f26a1f,0x00001d19,0x3600ac5f,0xc252f1c0,0xf4524086,0x04a02a99,0x32a09bdf,0xc6f2c640,0xf0f27706}, + [16]uint32{0x00000000,0x104c4172,0x2806612f,0x384a205d,0x102881c3,0x0064c0b1,0x382ee0ec,0x2862a19e,0x00152014,0x10596166,0x2813413b,0x385f0049,0x103da1d7,0x0071e0a5,0x383bc0f8,0x2877818a}, + [16]uint32{0x3f800000,0x3f882620,0x3f940330,0x3f9c2510,0x3f881440,0x3f803260,0x3f9c1770,0x3f943150,0x3f800a90,0x3f882cb0,0x3f9409a0,0x3f9c2f80,0x3f881ed0,0x3f8038f0,0x3f9c1de0,0x3f943bc0}, + uint32(0xfff80000), + [21]string{"0x40","0x4b","0xbd","0x28","0x18","0xcb","0xba","0x84","0x95","0x0e","0xe7","0x0a","0xa4","0x1c","0x91","0xa7","0x68","0x09","0xa3","0x89","0x00"} }, + { + /* No.889 delta:908 weight:1475 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xae03f020,0x88158c81,0x26167ca1,0xa4903790,0x0a93c7b0,0x2c85bb11,0x82864b31,0x0000f452,0xae030472,0x881578d3,0x261688f3,0xa490c3c2,0x0a9333e2,0x2c854f43,0x8286bf63}, + [16]uint32{0x00000000,0x41649c96,0x6010e019,0x21747c8f,0x000248a4,0x4166d432,0x6012a8bd,0x2176342b,0x0001a0cc,0x41653c5a,0x601140d5,0x2175dc43,0x0003e868,0x416774fe,0x60130871,0x217794e7}, + [16]uint32{0x3f800000,0x3fa0b24e,0x3fb00870,0x3f90ba3e,0x3f800124,0x3fa0b36a,0x3fb00954,0x3f90bb1a,0x3f8000d0,0x3fa0b29e,0x3fb008a0,0x3f90baee,0x3f8001f4,0x3fa0b3ba,0x3fb00984,0x3f90bbca}, + uint32(0xfff80000), + [21]string{"0x65","0x3c","0x8d","0x5d","0x79","0x41","0xa4","0x16","0x4b","0x05","0xef","0xb2","0x0b","0x14","0xcf","0xe2","0x80","0xd7","0x0c","0xb4","0x00"} }, + { + /* No.890 delta:643 weight:1457 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x238b0ca4,0x55ac7b2a,0x7627778e,0x39c037a3,0x1a4b3b07,0x6c6c4c89,0x4fe7402d,0x0000e5e3,0x238be947,0x55ac9ec9,0x7627926d,0x39c0d240,0x1a4bdee4,0x6c6ca96a,0x4fe7a5ce}, + [16]uint32{0x00000000,0x800011dd,0x04004802,0x840059df,0x3000a10b,0xb000b0d6,0x3400e909,0xb400f8d4,0x50201803,0xd02009de,0x54205001,0xd42041dc,0x6020b908,0xe020a8d5,0x6420f10a,0xe420e0d7}, + [16]uint32{0x3f800000,0x3fc00008,0x3f820024,0x3fc2002c,0x3f980050,0x3fd80058,0x3f9a0074,0x3fda007c,0x3fa8100c,0x3fe81004,0x3faa1028,0x3fea1020,0x3fb0105c,0x3ff01054,0x3fb21078,0x3ff21070}, + uint32(0xfff80000), + [21]string{"0x8f","0xea","0x98","0xdf","0xa6","0x1c","0x0f","0x0d","0x79","0xa1","0xc6","0x02","0x07","0x7f","0x14","0x33","0xd8","0x0e","0x94","0x64","0x00"} }, + { + /* No.891 delta:1674 weight:1569 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xad75cf3d,0x30d354ea,0x9da69bd7,0x321037b5,0x9f65f888,0x02c3635f,0xafb6ac62,0x0000b953,0xad75766e,0x30d3edb9,0x9da62284,0x32108ee6,0x9f6541db,0x02c3da0c,0xafb61531}, + [16]uint32{0x00000000,0x083a4196,0x141981b3,0x1c23c025,0x202165da,0x281b244c,0x3438e469,0x3c02a5ff,0x045c421d,0x0c66038b,0x1045c3ae,0x187f8238,0x247d27c7,0x2c476651,0x3064a674,0x385ee7e2}, + [16]uint32{0x3f800000,0x3f841d20,0x3f8a0cc0,0x3f8e11e0,0x3f9010b2,0x3f940d92,0x3f9a1c72,0x3f9e0152,0x3f822e21,0x3f863301,0x3f8822e1,0x3f8c3fc1,0x3f923e93,0x3f9623b3,0x3f983253,0x3f9c2f73}, + uint32(0xfff80000), + [21]string{"0x98","0x7a","0xd9","0x05","0x17","0xd1","0x62","0x59","0x4d","0xd3","0x35","0xce","0xfb","0x12","0x97","0xda","0x4d","0xc4","0x93","0x5b","0x00"} }, + { + /* No.892 delta:1016 weight:1443 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x0b888a5e,0xada6e64b,0xa62e6c15,0xfd7037c0,0xf6f8bd9e,0x50d6d18b,0x5b5e5bd5,0x00003e9b,0x0b88b4c5,0xada6d8d0,0xa62e528e,0xfd70095b,0xf6f88305,0x50d6ef10,0x5b5e654e}, + [16]uint32{0x00000000,0x403bc1f2,0x1075009d,0x504ec16f,0x406a2955,0x0051e8a7,0x501f29c8,0x1024e83a,0x0040107f,0x407bd18d,0x103510e2,0x500ed110,0x402a392a,0x0011f8d8,0x505f39b7,0x1064f845}, + [16]uint32{0x3f800000,0x3fa01de0,0x3f883a80,0x3fa82760,0x3fa03514,0x3f8028f4,0x3fa80f94,0x3f881274,0x3f802008,0x3fa03de8,0x3f881a88,0x3fa80768,0x3fa0151c,0x3f8008fc,0x3fa82f9c,0x3f88327c}, + uint32(0xfff80000), + [21]string{"0x63","0x72","0xc9","0x74","0xba","0x62","0xd2","0x96","0x51","0x2e","0xdd","0xf8","0x53","0x64","0xfc","0xf4","0x6b","0x13","0x78","0xc4","0x00"} }, + { + /* No.893 delta:865 weight:1265 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x7f50c9eb,0x9b5918ee,0xe409d105,0x30c037d3,0x4f90fe38,0xab992f3d,0xd4c9e6d6,0x00009a06,0x7f5053ed,0x9b5982e8,0xe4094b03,0x30c0add5,0x4f90643e,0xab99b53b,0xd4c97cd0}, + [16]uint32{0x00000000,0x602dbd76,0x000271ec,0x602fcc9a,0x106001bf,0x704dbcc9,0x10627053,0x704fcd25,0x40342015,0x20199d63,0x403651f9,0x201bec8f,0x505421aa,0x30799cdc,0x50565046,0x307bed30}, + [16]uint32{0x3f800000,0x3fb016de,0x3f800138,0x3fb017e6,0x3f883000,0x3fb826de,0x3f883138,0x3fb827e6,0x3fa01a10,0x3f900cce,0x3fa01b28,0x3f900df6,0x3fa82a10,0x3f983cce,0x3fa82b28,0x3f983df6}, + uint32(0xfff80000), + [21]string{"0xe8","0xf7","0xbd","0xf3","0x50","0x5d","0x9e","0x9b","0x5f","0x7f","0xf9","0x90","0xd4","0x32","0x21","0x45","0x1d","0x18","0xab","0x35","0x00"} }, + { + /* No.894 delta:895 weight:1277 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x0e5c0fd0,0xcc5d1aae,0xc201157e,0xbb5037ea,0xb50c383a,0x770d2d44,0x79512294,0x00008153,0x0e5c8e83,0xcc5d9bfd,0xc201942d,0xbb50b6b9,0xb50cb969,0x770dac17,0x7951a3c7}, + [16]uint32{0x00000000,0x100204f6,0x8000036a,0x9002079c,0x40401013,0x504214e5,0xc0401379,0xd042178f,0x20026011,0x300064e7,0xa002637b,0xb000678d,0x60427002,0x704074f4,0xe0427368,0xf040779e}, + [16]uint32{0x3f800000,0x3f880102,0x3fc00001,0x3fc80103,0x3fa02008,0x3fa8210a,0x3fe02009,0x3fe8210b,0x3f900130,0x3f980032,0x3fd00131,0x3fd80033,0x3fb02138,0x3fb8203a,0x3ff02139,0x3ff8203b}, + uint32(0xfff80000), + [21]string{"0x8e","0xed","0xe7","0xf8","0x4d","0xd1","0x04","0x39","0x64","0x70","0xe1","0xd9","0xf5","0x67","0xa6","0x26","0x30","0x7c","0xe5","0xff","0x00"} }, + { + /* No.895 delta:817 weight:1523 */ + 11213, + 76, + 13, + 4, + [16]uint32{0x00000000,0xf844b6dc,0x9cb6cb70,0x64f27dac,0x15f037f1,0xedb4812d,0x8946fc81,0x71024a5d,0x00007d61,0xf844cbbd,0x9cb6b611,0x64f200cd,0x15f04a90,0xedb4fc4c,0x894681e0,0x7102373c}, + [16]uint32{0x00000000,0x0048731f,0x00031245,0x004b615a,0x1000121d,0x10486102,0x10030058,0x104b7347,0x41010a19,0x41497906,0x4102185c,0x414a6b43,0x51011804,0x51496b1b,0x51020a41,0x514a795e}, + [16]uint32{0x3f800000,0x3f802439,0x3f800189,0x3f8025b0,0x3f880009,0x3f882430,0x3f880180,0x3f8825b9,0x3fa08085,0x3fa0a4bc,0x3fa0810c,0x3fa0a535,0x3fa8808c,0x3fa8a4b5,0x3fa88105,0x3fa8a53c}, + uint32(0xfff80000), + [21]string{"0x19","0x01","0xd5","0xa7","0x8e","0xc7","0xba","0x0b","0x80","0x7a","0x46","0xe2","0xe1","0x65","0x58","0x20","0x6c","0xdc","0x9f","0x80","0x00"} }, + { + /* No.896 delta:766 weight:1697 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x4280f05e,0x7e953e4f,0x3c15ce11,0x9d303808,0xdfb0c856,0xe3a50647,0xa125f619,0x0000d302,0x4280235c,0x7e95ed4d,0x3c151d13,0x9d30eb0a,0xdfb01b54,0xe3a5d545,0xa125251b}, + [16]uint32{0x00000000,0x005a1cbd,0x400206be,0x40581a03,0x2002a648,0x2058baf5,0x6000a0f6,0x605abc4b,0x70000602,0x705a1abf,0x300200bc,0x30581c01,0x5002a04a,0x5058bcf7,0x1000a6f4,0x105aba49}, + [16]uint32{0x3f800000,0x3f802d0e,0x3fa00103,0x3fa02c0d,0x3f900153,0x3f902c5d,0x3fb00050,0x3fb02d5e,0x3fb80003,0x3fb82d0d,0x3f980100,0x3f982c0e,0x3fa80150,0x3fa82c5e,0x3f880053,0x3f882d5d}, + uint32(0xfff80000), + [21]string{"0xcb","0x41","0xf8","0x2b","0xc1","0xcb","0x02","0xad","0x9b","0x57","0x0b","0x0d","0x19","0x10","0x07","0x84","0xe1","0x0c","0xdd","0x13","0x00"} }, + { + /* No.897 delta:1308 weight:1485 */ + 11213, + 24, + 13, + 4, + [16]uint32{0x00000000,0x18d2549c,0xe6510e00,0xfe835a9c,0x56c03815,0x4e126c89,0xb0913615,0xa8436289,0x00005031,0x18d204ad,0xe6515e31,0xfe830aad,0x56c06824,0x4e123cb8,0xb0916624,0xa84332b8}, + [16]uint32{0x00000000,0x005999f6,0x0036015c,0x006f98aa,0x806fa8f3,0x80363105,0x8059a9af,0x80003059,0x0010101f,0x004989e9,0x00261143,0x007f88b5,0x807fb8ec,0x8026211a,0x8049b9b0,0x80102046}, + [16]uint32{0x3f800000,0x3f802ccc,0x3f801b00,0x3f8037cc,0x3fc037d4,0x3fc01b18,0x3fc02cd4,0x3fc00018,0x3f800808,0x3f8024c4,0x3f801308,0x3f803fc4,0x3fc03fdc,0x3fc01310,0x3fc024dc,0x3fc00810}, + uint32(0xfff80000), + [21]string{"0x11","0x95","0x69","0xb5","0x2b","0x22","0x89","0xa2","0xd7","0xb0","0x59","0x2e","0x85","0xdb","0xb6","0xe2","0xb9","0x66","0xb0","0x54","0x00"} }, + { + /* No.898 delta:1407 weight:1237 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x20934c7f,0x3c845717,0x1c171b68,0x61203822,0x41b3745d,0x5da46f35,0x7d37234a,0x0000d5cf,0x209399b0,0x3c8482d8,0x1c17cea7,0x6120eded,0x41b3a192,0x5da4bafa,0x7d37f685}, + [16]uint32{0x00000000,0x200404ba,0x001201cc,0x20160576,0x100c0158,0x300805e2,0x101e0094,0x301a042e,0x0002019f,0x20060525,0x00100053,0x201404e9,0x100e00c7,0x300a047d,0x101c010b,0x301805b1}, + [16]uint32{0x3f800000,0x3f900202,0x3f800900,0x3f900b02,0x3f880600,0x3f980402,0x3f880f00,0x3f980d02,0x3f800100,0x3f900302,0x3f800800,0x3f900a02,0x3f880700,0x3f980502,0x3f880e00,0x3f980c02}, + uint32(0xfff80000), + [21]string{"0xc2","0x27","0xa5","0x56","0x04","0x8a","0x60","0x0e","0xc9","0xfc","0x8d","0x96","0xf8","0xf7","0xe9","0xf1","0x94","0x01","0x2f","0xa9","0x00"} }, + { + /* No.899 delta:1211 weight:1599 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x804bac80,0x3bdce360,0xbb974fe0,0xc8a03833,0x48eb94b3,0xf37cdb53,0x733777d3,0x00008e00,0x804b2280,0x3bdc6d60,0xbb97c1e0,0xc8a0b633,0x48eb1ab3,0xf37c5553,0x7337f9d3}, + [16]uint32{0x00000000,0xc842105e,0x708be065,0xb8c9f03b,0x802080ca,0x48629094,0xf0ab60af,0x38e970f1,0x100061f8,0xd84271a6,0x608b819d,0xa8c991c3,0x9020e132,0x5862f16c,0xe0ab0157,0x28e91109}, + [16]uint32{0x3f800000,0x3fe42108,0x3fb845f0,0x3fdc64f8,0x3fc01040,0x3fa43148,0x3ff855b0,0x3f9c74b8,0x3f880030,0x3fec2138,0x3fb045c0,0x3fd464c8,0x3fc81070,0x3fac3178,0x3ff05580,0x3f947488}, + uint32(0xfff80000), + [21]string{"0x75","0x0a","0xa9","0xc3","0x18","0x01","0xc5","0x9a","0x69","0x77","0x21","0x73","0x22","0x02","0xe0","0x66","0x65","0x5d","0x56","0x69","0x00"} }, + { + /* No.900 delta:719 weight:1677 */ + 11213, + 67, + 13, + 4, + [16]uint32{0x00000000,0xb0f6ced9,0x3eb012d9,0x8e46dc00,0x13803841,0xa376f698,0x2d302a98,0x9dc6e441,0x0000a437,0xb0f66aee,0x3eb0b6ee,0x8e467837,0x13809c76,0xa37652af,0x2d308eaf,0x9dc64076}, + [16]uint32{0x00000000,0x004e5152,0x000220de,0x004c718c,0x1008307b,0x10466129,0x100a10a5,0x104441f7,0x200011b0,0x204e40e2,0x2002316e,0x204c603c,0x300821cb,0x30467099,0x300a0115,0x30445047}, + [16]uint32{0x3f800000,0x3f802728,0x3f800110,0x3f802638,0x3f880418,0x3f882330,0x3f880508,0x3f882220,0x3f900008,0x3f902720,0x3f900118,0x3f902630,0x3f980410,0x3f982338,0x3f980500,0x3f982228}, + uint32(0xfff80000), + [21]string{"0x71","0xc1","0xa1","0xd7","0xb5","0x0a","0x8f","0xa3","0x9f","0x97","0x83","0xee","0x91","0xc0","0x93","0x3d","0x41","0xcb","0xd8","0x7f","0x00"} }, + { + /* No.901 delta:1075 weight:1597 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0xa8081b78,0xa66644d0,0x0e6e5fa8,0x52003850,0xfa082328,0xf4667c80,0x5c6e67f8,0x0000639d,0xa80878e5,0xa666274d,0x0e6e3c35,0x52005bcd,0xfa0840b5,0xf4661f1d,0x5c6e0465}, + [16]uint32{0x00000000,0x0047a5fe,0x02030a12,0x0244afec,0x30004c0d,0x3047e9f3,0x3203461f,0x3244e3e1,0x1000101b,0x1047b5e5,0x12031a09,0x1244bff7,0x20005c16,0x2047f9e8,0x22035604,0x2244f3fa}, + [16]uint32{0x3f800000,0x3f8023d2,0x3f810185,0x3f812257,0x3f980026,0x3f9823f4,0x3f9901a3,0x3f992271,0x3f880008,0x3f8823da,0x3f89018d,0x3f89225f,0x3f90002e,0x3f9023fc,0x3f9101ab,0x3f912279}, + uint32(0xfff80000), + [21]string{"0xd4","0x3f","0x50","0xa2","0xbe","0x62","0xf3","0x9b","0x91","0x55","0xae","0x32","0x34","0x12","0x2d","0x75","0x83","0x63","0x38","0xe8","0x00"} }, + { + /* No.902 delta:2650 weight:883 */ + 11213, + 5, + 13, + 4, + [16]uint32{0x00000000,0xaa853d9c,0x1a926eb5,0xb0175329,0x14603866,0xbee505fa,0x0ef256d3,0xa4776b4f,0x00006536,0xaa8558aa,0x1a920b83,0xb017361f,0x14605d50,0xbee560cc,0x0ef233e5,0xa4770e79}, + [16]uint32{0x00000000,0x9d1061bf,0x41542015,0xdc4441aa,0x0bc2006d,0x96d261d2,0x4a962078,0xd78641c7,0xa40840a5,0x3918211a,0xe55c60b0,0x784c010f,0xafca40c8,0x32da2177,0xee9e60dd,0x738e0162}, + [16]uint32{0x3f800000,0x3fce8830,0x3fa0aa10,0x3fee2220,0x3f85e100,0x3fcb6930,0x3fa54b10,0x3febc320,0x3fd20420,0x3f9c8c10,0x3ff2ae30,0x3fbc2600,0x3fd7e520,0x3f996d10,0x3ff74f30,0x3fb9c700}, + uint32(0xfff80000), + [21]string{"0x9a","0xa4","0x66","0x7b","0xdb","0x3f","0xed","0xae","0x44","0xc9","0xa4","0x49","0x73","0x49","0x02","0xfa","0x57","0x3e","0xe2","0x61","0x00"} }, + { + /* No.903 delta:812 weight:983 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0x0382458a,0xf8b7322f,0xfb3577a5,0x55f03878,0x56727df2,0xad470a57,0xaec54fdd,0x000017e7,0x0382526d,0xf8b725c8,0xfb356042,0x55f02f9f,0x56726a15,0xad471db0,0xaec5583a}, + [16]uint32{0x00000000,0x00c8109a,0x000370ed,0x00cb6077,0x403e22f1,0x40f6326b,0x403d521c,0x40f54286,0x32075048,0x32cf40d2,0x320420a5,0x32cc303f,0x723972b9,0x72f16223,0x723a0254,0x72f212ce}, + [16]uint32{0x3f800000,0x3f806408,0x3f8001b8,0x3f8065b0,0x3fa01f11,0x3fa07b19,0x3fa01ea9,0x3fa07aa1,0x3f9903a8,0x3f9967a0,0x3f990210,0x3f996618,0x3fb91cb9,0x3fb978b1,0x3fb91d01,0x3fb97909}, + uint32(0xfff80000), + [21]string{"0xd1","0x19","0xab","0x71","0xdb","0x7c","0xee","0x39","0x56","0x2b","0xde","0x28","0x93","0x0e","0xa4","0x22","0x8c","0x36","0xa3","0x2b","0x00"} }, + { + /* No.904 delta:1355 weight:1605 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x17a2e89d,0xedc2917b,0xfa6079e6,0x0be03886,0x1c42d01b,0xe622a9fd,0xf1804160,0x0000ea55,0x17a202c8,0xedc27b2e,0xfa6093b3,0x0be0d2d3,0x1c423a4e,0xe62243a8,0xf180ab35}, + [16]uint32{0x00000000,0x202295fa,0x005408df,0x20769d25,0x002812f3,0x200a8709,0x007c1a2c,0x205e8fd6,0x60038112,0x402114e8,0x605789cd,0x40751c37,0x602b93e1,0x4009061b,0x607f9b3e,0x405d0ec4}, + [16]uint32{0x3f800000,0x3f90114a,0x3f802a04,0x3f903b4e,0x3f801409,0x3f900543,0x3f803e0d,0x3f902f47,0x3fb001c0,0x3fa0108a,0x3fb02bc4,0x3fa03a8e,0x3fb015c9,0x3fa00483,0x3fb03fcd,0x3fa02e87}, + uint32(0xfff80000), + [21]string{"0x13","0x1b","0xd4","0x18","0x38","0x92","0x96","0xc3","0xe3","0x4c","0x73","0x57","0xdc","0xa0","0xb1","0x0a","0xcd","0xa2","0x30","0xab","0x00"} }, + { + /* No.905 delta:717 weight:1263 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0xb962e9ba,0xf77748a5,0x4e15a11f,0x58b03895,0xe1d2d12f,0xafc77030,0x16a5998a,0x000038ca,0xb962d170,0xf777706f,0x4e1599d5,0x58b0005f,0xe1d2e9e5,0xafc748fa,0x16a5a140}, + [16]uint32{0x00000000,0x1002921a,0x140019f6,0x04028bec,0x3003481e,0x2001da04,0x240351e8,0x3401c3f2,0x1001496b,0x0003db71,0x0401509d,0x1403c287,0x20020175,0x3000936f,0x34021883,0x24008a99}, + [16]uint32{0x3f800000,0x3f880149,0x3f8a000c,0x3f820145,0x3f9801a4,0x3f9000ed,0x3f9201a8,0x3f9a00e1,0x3f8800a4,0x3f8001ed,0x3f8200a8,0x3f8a01e1,0x3f900100,0x3f980049,0x3f9a010c,0x3f920045}, + uint32(0xfff80000), + [21]string{"0x82","0x14","0xd4","0xfa","0xa8","0xd1","0x99","0x85","0x15","0xf6","0x01","0x5d","0x2a","0xc0","0x39","0x54","0xec","0x21","0x02","0x9f","0x00"} }, + { + /* No.906 delta:1055 weight:1313 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xd2ca0608,0x6c800286,0xbe4a048e,0x517038a2,0x83ba3eaa,0x3df03a24,0xef3a3c2c,0x0000e21f,0xd2cae417,0x6c80e099,0xbe4ae691,0x5170dabd,0x83badcb5,0x3df0d83b,0xef3ade33}, + [16]uint32{0x00000000,0x9046497c,0x200b010a,0xb04d4876,0x000208ad,0x904441d1,0x200909a7,0xb04f40db,0x340023df,0xa4466aa3,0x140b22d5,0x844d6ba9,0x34022b72,0xa444620e,0x14092a78,0x844f6304}, + [16]uint32{0x3f800000,0x3fc82324,0x3f900580,0x3fd826a4,0x3f800104,0x3fc82220,0x3f900484,0x3fd827a0,0x3f9a0011,0x3fd22335,0x3f8a0591,0x3fc226b5,0x3f9a0115,0x3fd22231,0x3f8a0495,0x3fc227b1}, + uint32(0xfff80000), + [21]string{"0x3a","0x9c","0xd6","0x23","0xee","0x9e","0xb1","0x0e","0x82","0xd6","0x79","0x8b","0xce","0x53","0xd2","0xf4","0x43","0xb0","0xad","0xe6","0x00"} }, + { + /* No.907 delta:1949 weight:1419 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0x6e5afa56,0x87968859,0xe9cc720f,0x83c038b5,0xed9ac2e3,0x0456b0ec,0x6a0c4aba,0x00001a7c,0x6e5ae02a,0x87969225,0xe9cc6873,0x83c022c9,0xed9ad89f,0x0456aa90,0x6a0c50c6}, + [16]uint32{0x00000000,0x32028552,0x2895831d,0x1a97064f,0x533a0154,0x61388406,0x7baf8249,0x49ad071b,0x085c001c,0x3a5e854e,0x20c98301,0x12cb0653,0x5b660148,0x6964841a,0x73f38255,0x41f10707}, + [16]uint32{0x3f800000,0x3f990142,0x3f944ac1,0x3f8d4b83,0x3fa99d00,0x3fb09c42,0x3fbdd7c1,0x3fa4d683,0x3f842e00,0x3f9d2f42,0x3f9064c1,0x3f896583,0x3fadb300,0x3fb4b242,0x3fb9f9c1,0x3fa0f883}, + uint32(0xfff80000), + [21]string{"0x35","0x2b","0x78","0x79","0xde","0x59","0x34","0x27","0x4c","0xcb","0x80","0xd0","0x43","0x4c","0x55","0x1a","0xa6","0x38","0xc6","0xff","0x00"} }, + { + /* No.908 delta:924 weight:1557 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0x7bd98a7a,0x491ad314,0x32c3596e,0x5fb038c7,0x2469b2bd,0x16aaebd3,0x6d7361a9,0x0000f01a,0x7bd97a60,0x491a230e,0x32c3a974,0x5fb0c8dd,0x246942a7,0x16aa1bc9,0x6d7391b3}, + [16]uint32{0x00000000,0x3064419a,0x006ec436,0x300a85ac,0x00416015,0x3025218f,0x002fa423,0x304be5b9,0x00012c71,0x30656deb,0x006fe847,0x300ba9dd,0x00404c64,0x30240dfe,0x002e8852,0x304ac9c8}, + [16]uint32{0x3f800000,0x3f983220,0x3f803762,0x3f980542,0x3f8020b0,0x3f981290,0x3f8017d2,0x3f9825f2,0x3f800096,0x3f9832b6,0x3f8037f4,0x3f9805d4,0x3f802026,0x3f981206,0x3f801744,0x3f982564}, + uint32(0xfff80000), + [21]string{"0xca","0x8f","0x1a","0xc1","0xdf","0xf4","0x8c","0x58","0xfb","0xe7","0x6f","0xe4","0xb0","0x10","0xe8","0x2c","0xe5","0x39","0xbc","0xdc","0x00"} }, + { + /* No.909 delta:1014 weight:1413 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0xd07f9b50,0x49522570,0x992dbe20,0x89f038d1,0x598fa381,0xc0a21da1,0x10dd86f1,0x00009c90,0xd07f07c0,0x4952b9e0,0x992d22b0,0x89f0a441,0x598f3f11,0xc0a28131,0x10dd1a61}, + [16]uint32{0x00000000,0x0a6e2e9e,0x200401b2,0x2a6a2f2c,0x410a1bf8,0x4b643566,0x610e1a4a,0x6b6034d4,0x0002001f,0x0a6c2e81,0x200601ad,0x2a682f33,0x41081be7,0x4b663579,0x610c1a55,0x6b6234cb}, + [16]uint32{0x3f800000,0x3f853717,0x3f900200,0x3f953517,0x3fa0850d,0x3fa5b21a,0x3fb0870d,0x3fb5b01a,0x3f800100,0x3f853617,0x3f900300,0x3f953417,0x3fa0840d,0x3fa5b31a,0x3fb0860d,0x3fb5b11a}, + uint32(0xfff80000), + [21]string{"0x17","0x02","0x18","0x2e","0x37","0xa3","0x90","0x44","0xbe","0x58","0xff","0xf4","0xac","0x5f","0xf3","0x64","0x8a","0xe2","0xbd","0x87","0x00"} }, + { + /* No.910 delta:797 weight:1681 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x2cf7d117,0xaa22979d,0x86d5468a,0xf6f038e1,0xda07e9f6,0x5cd2af7c,0x70257e6b,0x0000d6b6,0x2cf707a1,0xaa22412b,0x86d5903c,0xf6f0ee57,0xda073f40,0x5cd279ca,0x7025a8dd}, + [16]uint32{0x00000000,0x600c1c93,0x20036fec,0x400f737f,0x00005008,0x600c4c9b,0x20033fe4,0x400f2377,0x02010202,0x620d1e91,0x22026dee,0x420e717d,0x0201520a,0x620d4e99,0x22023de6,0x420e2175}, + [16]uint32{0x3f800000,0x3fb0060e,0x3f9001b7,0x3fa007b9,0x3f800028,0x3fb00626,0x3f90019f,0x3fa00791,0x3f810081,0x3fb1068f,0x3f910136,0x3fa10738,0x3f8100a9,0x3fb106a7,0x3f91011e,0x3fa10710}, + uint32(0xfff80000), + [21]string{"0xdb","0x91","0xb4","0x1a","0x00","0xc3","0xa6","0x42","0x40","0x10","0x23","0xbb","0xc7","0x28","0xc8","0xca","0xf9","0x45","0x24","0xcd","0x00"} }, + { + /* No.911 delta:2273 weight:1221 */ + 11213, + 7, + 13, + 4, + [16]uint32{0x00000000,0xc00b3209,0xb625fef8,0x762eccf1,0x75a038f0,0xb5ab0af9,0xc385c608,0x038ef401,0x0000d8cd,0xc00beac4,0xb6252635,0x762e143c,0x75a0e03d,0xb5abd234,0xc3851ec5,0x038e2ccc}, + [16]uint32{0x00000000,0x86184436,0x05e801e9,0x83f045df,0x0e08235c,0x8810676a,0x0be022b5,0x8df86683,0x1184201a,0x979c642c,0x146c21f3,0x927465c5,0x1f8c0346,0x99944770,0x1a6402af,0x9c7c4699}, + [16]uint32{0x3f800000,0x3fc30c22,0x3f82f400,0x3fc1f822,0x3f870411,0x3fc40833,0x3f85f011,0x3fc6fc33,0x3f88c210,0x3fcbce32,0x3f8a3610,0x3fc93a32,0x3f8fc601,0x3fccca23,0x3f8d3201,0x3fce3e23}, + uint32(0xfff80000), + [21]string{"0x9a","0xf8","0xaf","0x40","0x07","0x33","0xd7","0x24","0x78","0xa0","0xb7","0x39","0xee","0xea","0x4e","0xdc","0xa4","0xf0","0x99","0x97","0x00"} }, + { + /* No.912 delta:776 weight:1251 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x69723443,0x9ccbcbe1,0xf5b9ffa2,0x3f803900,0x56f20d43,0xa34bf2e1,0xca39c6a2,0x00005615,0x69726256,0x9ccb9df4,0xf5b9a9b7,0x3f806f15,0x56f25b56,0xa34ba4f4,0xca3990b7}, + [16]uint32{0x00000000,0x306c01d6,0x7010186a,0x407c19bc,0x1000000f,0x206c01d9,0x60101865,0x507c19b3,0x30126803,0x007e69d5,0x40027069,0x706e71bf,0x2012680c,0x107e69da,0x50027066,0x606e71b0}, + [16]uint32{0x3f800000,0x3f983600,0x3fb8080c,0x3fa03e0c,0x3f880000,0x3f903600,0x3fb0080c,0x3fa83e0c,0x3f980934,0x3f803f34,0x3fa00138,0x3fb83738,0x3f900934,0x3f883f34,0x3fa80138,0x3fb03738}, + uint32(0xfff80000), + [21]string{"0x31","0xc2","0x29","0x31","0x50","0x48","0xc0","0x28","0xcb","0xf4","0x4e","0x85","0x34","0x1f","0x9c","0x6d","0x87","0x74","0x4a","0x53","0x00"} }, + { + /* No.913 delta:1046 weight:1627 */ + 11213, + 29, + 13, + 4, + [16]uint32{0x00000000,0xe69b092d,0x13cc2719,0xf5572e34,0xaeb0391e,0x482b3033,0xbd7c1e07,0x5be7172a,0x000099ac,0xe69b9081,0x13ccbeb5,0xf557b798,0xaeb0a0b2,0x482ba99f,0xbd7c87ab,0x5be78e86}, + [16]uint32{0x00000000,0x10440492,0x1020281d,0x00642c8f,0x40021404,0x50461096,0x50223c19,0x4066388b,0x60002011,0x70442483,0x7020080c,0x60640c9e,0x20023415,0x30463087,0x30221c08,0x2066189a}, + [16]uint32{0x3f800000,0x3f882202,0x3f881014,0x3f803216,0x3fa0010a,0x3fa82308,0x3fa8111e,0x3fa0331c,0x3fb00010,0x3fb82212,0x3fb81004,0x3fb03206,0x3f90011a,0x3f982318,0x3f98110e,0x3f90330c}, + uint32(0xfff80000), + [21]string{"0x6c","0x37","0xba","0x5b","0x59","0xa3","0xaf","0x4a","0x5a","0x88","0xe8","0xcb","0xdd","0x01","0xb1","0x43","0x5e","0xef","0x77","0x94","0x00"} }, + { + /* No.914 delta:2006 weight:1599 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0x06a8c348,0x870b76be,0x81a3b5f6,0xd2f0392c,0xd458fa64,0x55fb4f92,0x53538cda,0x0000387e,0x06a8fb36,0x870b4ec0,0x81a38d88,0xd2f00152,0xd458c21a,0x55fb77ec,0x5353b4a4}, + [16]uint32{0x00000000,0x307041fb,0x00480055,0x303841ae,0x000801c3,0x30784038,0x00400196,0x3030406d,0x3002c110,0x007280eb,0x304ac145,0x003a80be,0x300ac0d3,0x007a8128,0x3042c086,0x0032817d}, + [16]uint32{0x3f800000,0x3f983820,0x3f802400,0x3f981c20,0x3f800400,0x3f983c20,0x3f802000,0x3f981820,0x3f980160,0x3f803940,0x3f982560,0x3f801d40,0x3f980560,0x3f803d40,0x3f982160,0x3f801940}, + uint32(0xfff80000), + [21]string{"0x89","0x1c","0x8c","0xf1","0x0d","0x28","0x10","0x53","0xf3","0xa9","0x16","0xb2","0x3b","0x95","0xa6","0xaf","0x5d","0x9a","0x2d","0xde","0x00"} }, + { + /* No.915 delta:1823 weight:1495 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x19892a20,0xc316f4bf,0xda9fde9f,0xb7a0393c,0xae29131c,0x74b6cd83,0x6d3fe7a3,0x0000656b,0x19894f4b,0xc31691d4,0xda9fbbf4,0xb7a05c57,0xae297677,0x74b6a8e8,0x6d3f82c8}, + [16]uint32{0x00000000,0x11e00414,0x41ab6809,0x504b6c1d,0x80102012,0x91f02406,0xc1bb481b,0xd05b4c0f,0x09b07018,0x1850740c,0x481b1811,0x59fb1c05,0x89a0500a,0x9840541e,0xc80b3803,0xd9eb3c17}, + [16]uint32{0x3f800000,0x3f88f002,0x3fa0d5b4,0x3fa825b6,0x3fc00810,0x3fc8f812,0x3fe0dda4,0x3fe82da6,0x3f84d838,0x3f8c283a,0x3fa40d8c,0x3facfd8e,0x3fc4d028,0x3fcc202a,0x3fe4059c,0x3fecf59e}, + uint32(0xfff80000), + [21]string{"0x31","0xfe","0x01","0xe9","0xa1","0x8b","0x5d","0x5c","0x60","0xc8","0xbb","0x2c","0x8e","0x0e","0x6b","0x9b","0x38","0xc0","0x52","0x60","0x00"} }, + { + /* No.916 delta:1420 weight:1589 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x949c5ab7,0x6d95dac7,0xf9098070,0x00203945,0x94bc63f2,0x6db5e382,0xf929b935,0x0000c923,0x949c9394,0x6d9513e4,0xf9094953,0x0020f066,0x94bcaad1,0x6db52aa1,0xf9297016}, + [16]uint32{0x00000000,0x407e0cb2,0xc060221c,0x801e2eae,0x4000b034,0x007ebc86,0x80609228,0xc01e9e9a,0x4002a01d,0x007cacaf,0x80628201,0xc01c8eb3,0x00021029,0x407c1c9b,0xc0623235,0x801c3e87}, + [16]uint32{0x3f800000,0x3fa03f06,0x3fe03011,0x3fc00f17,0x3fa00058,0x3f803f5e,0x3fc03049,0x3fe00f4f,0x3fa00150,0x3f803e56,0x3fc03141,0x3fe00e47,0x3f800108,0x3fa03e0e,0x3fe03119,0x3fc00e1f}, + uint32(0xfff80000), + [21]string{"0x59","0x71","0x9b","0xbc","0xa2","0xc0","0xbf","0xa2","0x8f","0x10","0x20","0x9b","0xf4","0xe8","0x04","0x89","0xcc","0x7c","0x99","0xff","0x00"} }, + { + /* No.917 delta:2000 weight:1653 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0xd4684509,0xd840f0fd,0x0c28b5f4,0x4170395a,0x95187c53,0x9930c9a7,0x4d588cae,0x000058cd,0xd4681dc4,0xd840a830,0x0c28ed39,0x41706197,0x9518249e,0x9930916a,0x4d58d463}, + [16]uint32{0x00000000,0x40750356,0x006ec0da,0x401bc38c,0x00020149,0x4077021f,0x006cc193,0x4019c2c5,0x000001fd,0x407502ab,0x006ec127,0x401bc271,0x000200b4,0x407703e2,0x006cc06e,0x4019c338}, + [16]uint32{0x3f800000,0x3fa03a81,0x3f803760,0x3fa00de1,0x3f800100,0x3fa03b81,0x3f803660,0x3fa00ce1,0x3f800000,0x3fa03a81,0x3f803760,0x3fa00de1,0x3f800100,0x3fa03b81,0x3f803660,0x3fa00ce1}, + uint32(0xfff80000), + [21]string{"0x2a","0x32","0xe1","0x53","0x09","0xfe","0x23","0x37","0xd7","0x7f","0x96","0x73","0xca","0x94","0xa4","0x8e","0x30","0x7b","0xaa","0x1f","0x00"} }, + { + /* No.918 delta:704 weight:1657 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0x1faf3cf6,0x19cbd677,0x0664ea81,0x65803965,0x7a2f0593,0x7c4bef12,0x63e4d3e4,0x0000c185,0x1faffd73,0x19cb17f2,0x06642b04,0x6580f8e0,0x7a2fc416,0x7c4b2e97,0x63e41261}, + [16]uint32{0x00000000,0x00501036,0x8024885f,0x80749869,0x40208e0b,0x40709e3d,0xc0040654,0xc0541662,0x400921c6,0x405931f0,0xc02da999,0xc07db9af,0x0029afcd,0x0079bffb,0x800d2792,0x805d37a4}, + [16]uint32{0x3f800000,0x3f802808,0x3fc01244,0x3fc03a4c,0x3fa01047,0x3fa0384f,0x3fe00203,0x3fe02a0b,0x3fa00490,0x3fa02c98,0x3fe016d4,0x3fe03edc,0x3f8014d7,0x3f803cdf,0x3fc00693,0x3fc02e9b}, + uint32(0xfff80000), + [21]string{"0x1d","0x40","0xd5","0xde","0x90","0x3d","0xd9","0x0c","0xb4","0x2f","0x65","0x87","0xc4","0x45","0xa7","0xe1","0x7f","0x54","0x95","0x81","0x00"} }, + { + /* No.919 delta:735 weight:1499 */ + 11213, + 81, + 13, + 4, + [16]uint32{0x00000000,0x12a59b94,0xa9d3b085,0xbb762b11,0xd470397f,0xc6d5a2eb,0x7da389fa,0x6f06126e,0x0000166e,0x12a58dfa,0xa9d3a6eb,0xbb763d7f,0xd4702f11,0xc6d5b485,0x7da39f94,0x6f060400}, + [16]uint32{0x00000000,0x9007039e,0x0002c19c,0x9005c202,0x4001a1d8,0xd006a246,0x40036044,0xd00463da,0x4001901d,0xd0069383,0x40035181,0xd004521f,0x000031c5,0x9007325b,0x0002f059,0x9005f3c7}, + [16]uint32{0x3f800000,0x3fc80381,0x3f800160,0x3fc802e1,0x3fa000d0,0x3fe80351,0x3fa001b0,0x3fe80231,0x3fa000c8,0x3fe80349,0x3fa001a8,0x3fe80229,0x3f800018,0x3fc80399,0x3f800178,0x3fc802f9}, + uint32(0xfff80000), + [21]string{"0x49","0x55","0x54","0x81","0xbe","0x6f","0xcf","0xed","0x41","0x9c","0xb6","0x47","0x23","0x3b","0x77","0x7f","0xde","0x1c","0x57","0xab","0x00"} }, + { + /* No.920 delta:870 weight:1243 */ + 11213, + 45, + 13, + 4, + [16]uint32{0x00000000,0xac10cf4d,0xdbf6aa04,0x77e66549,0x1c003986,0xb010f6cb,0xc7f69382,0x6be65ccf,0x0000f93f,0xac103672,0xdbf6533b,0x77e69c76,0x1c00c0b9,0xb0100ff4,0xc7f66abd,0x6be6a5f0}, + [16]uint32{0x00000000,0x4004021e,0x4008b84d,0x000cba53,0x10001606,0x50041418,0x5008ae4b,0x100cac55,0x40200a07,0x00240819,0x0028b24a,0x402cb054,0x50201c01,0x10241e1f,0x1028a44c,0x502ca652}, + [16]uint32{0x3f800000,0x3fa00201,0x3fa0045c,0x3f80065d,0x3f88000b,0x3fa8020a,0x3fa80457,0x3f880656,0x3fa01005,0x3f801204,0x3f801459,0x3fa01658,0x3fa8100e,0x3f88120f,0x3f881452,0x3fa81653}, + uint32(0xfff80000), + [21]string{"0x59","0xf0","0xd5","0x28","0x4c","0xa6","0x2c","0x77","0xa5","0x16","0xa6","0x45","0x93","0x10","0xe2","0x5f","0xa3","0x24","0x17","0xfd","0x00"} }, + { + /* No.921 delta:1051 weight:1399 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x5e21320e,0x77c09860,0x29e1aa6e,0x5420399f,0x0a010b91,0x23e0a1ff,0x7dc193f1,0x00005740,0x5e21654e,0x77c0cf20,0x29e1fd2e,0x54206edf,0x0a015cd1,0x23e0f6bf,0x7dc1c4b1}, + [16]uint32{0x00000000,0x1054e936,0x322d21ed,0x2279c8db,0x2006b821,0x30525117,0x122b99cc,0x027f70fa,0x00426c1f,0x10168529,0x326f4df2,0x223ba4c4,0x2044d43e,0x30103d08,0x1269f5d3,0x023d1ce5}, + [16]uint32{0x3f800000,0x3f882a74,0x3f991690,0x3f913ce4,0x3f90035c,0x3f982928,0x3f8915cc,0x3f813fb8,0x3f802136,0x3f880b42,0x3f9937a6,0x3f911dd2,0x3f90226a,0x3f98081e,0x3f8934fa,0x3f811e8e}, + uint32(0xfff80000), + [21]string{"0x78","0x1b","0xef","0xa3","0x61","0xb9","0x45","0xff","0x40","0x84","0xe8","0x32","0x68","0x8c","0x00","0x3d","0x23","0x71","0xe2","0x8e","0x00"} }, + { + /* No.922 delta:2881 weight:761 */ + 11213, + 4, + 13, + 4, + [16]uint32{0x00000000,0x27d96f1a,0xcb1b02e1,0xecc26dfb,0x2c7039aa,0x0ba956b0,0xe76b3b4b,0xc0b25451,0x00006c57,0x27d9034d,0xcb1b6eb6,0xecc201ac,0x2c7055fd,0x0ba93ae7,0xe76b571c,0xc0b23806}, + [16]uint32{0x00000000,0xb04c6089,0xd020009a,0x606c6013,0x83200107,0x336c618e,0x5300019d,0xe34c6114,0xa00001eb,0x104c6162,0x70200171,0xc06c61f8,0x232000ec,0x936c6065,0xf3000076,0x434c60ff}, + [16]uint32{0x3f800000,0x3fd82630,0x3fe81000,0x3fb03630,0x3fc19000,0x3f99b630,0x3fa98000,0x3ff1a630,0x3fd00000,0x3f882630,0x3fb81000,0x3fe03630,0x3f919000,0x3fc9b630,0x3ff98000,0x3fa1a630}, + uint32(0xfff80000), + [21]string{"0xb9","0x49","0x4d","0x4a","0xa6","0x04","0x0e","0x38","0x2d","0x7a","0x63","0xd1","0x1a","0x17","0x69","0x38","0x91","0xf0","0xd4","0x22","0x00"} }, + { + /* No.923 delta:766 weight:1615 */ + 11213, + 56, + 13, + 4, + [16]uint32{0x00000000,0x2eb52232,0xcff77d60,0xe1425f52,0x013039b0,0x2f851b82,0xcec744d0,0xe07266e2,0x00000fb0,0x2eb52d82,0xcff772d0,0xe14250e2,0x01303600,0x2f851432,0xcec74b60,0xe0726952}, + [16]uint32{0x00000000,0x80007177,0x2003818d,0xa003f0fa,0x600005b4,0xe00074c3,0x40038439,0xc003f54e,0x3001d11d,0xb001a06a,0x10025090,0x900221e7,0x5001d4a9,0xd001a5de,0x70025524,0xf0022453}, + [16]uint32{0x3f800000,0x3fc00038,0x3f9001c0,0x3fd001f8,0x3fb00002,0x3ff0003a,0x3fa001c2,0x3fe001fa,0x3f9800e8,0x3fd800d0,0x3f880128,0x3fc80110,0x3fa800ea,0x3fe800d2,0x3fb8012a,0x3ff80112}, + uint32(0xfff80000), + [21]string{"0xfd","0xab","0x50","0x7a","0x93","0x98","0x94","0xf0","0xc2","0x5c","0xba","0xa5","0x21","0x4d","0x2c","0x76","0x19","0x5a","0xe9","0xea","0x00"} }, + { + /* No.924 delta:704 weight:1521 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xdc1efe13,0xbf95f776,0x638b0965,0xe9e039c1,0x35fec7d2,0x5675ceb7,0x8a6b30a4,0x00003580,0xdc1ecb93,0xbf95c2f6,0x638b3ce5,0xe9e00c41,0x35fef252,0x5675fb37,0x8a6b0524}, + [16]uint32{0x00000000,0x0058195f,0xb0042103,0xb05c385c,0x106010a9,0x103809f6,0xa06431aa,0xa03c28f5,0x000c0284,0x00541bdb,0xb0082387,0xb0503ad8,0x106c122d,0x10340b72,0xa068332e,0xa0302a71}, + [16]uint32{0x3f800000,0x3f802c0c,0x3fd80210,0x3fd82e1c,0x3f883008,0x3f881c04,0x3fd03218,0x3fd01e14,0x3f800601,0x3f802a0d,0x3fd80411,0x3fd8281d,0x3f883609,0x3f881a05,0x3fd03419,0x3fd01815}, + uint32(0xfff80000), + [21]string{"0x13","0x7c","0x3a","0xd0","0x16","0xae","0x8a","0xfa","0x1a","0x32","0x09","0xe8","0xd6","0x96","0x1b","0x20","0x21","0xba","0xc6","0x78","0x00"} }, + { + /* No.925 delta:1271 weight:1659 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x5ce06fc7,0xc249e6dc,0x9ea9891b,0x22c039d1,0x7e205616,0xe089df0d,0xbc69b0ca,0x00006e32,0x5ce001f5,0xc24988ee,0x9ea9e729,0x22c057e3,0x7e203824,0xe089b13f,0xbc69def8}, + [16]uint32{0x00000000,0xc0194996,0x006a7014,0xc0733982,0x4008100c,0x8011599a,0x40626018,0x807b298e,0x8005a10b,0x401ce89d,0x806fd11f,0x40769889,0xc00db107,0x0014f891,0xc067c113,0x007e8885}, + [16]uint32{0x3f800000,0x3fe00ca4,0x3f803538,0x3fe0399c,0x3fa00408,0x3fc008ac,0x3fa03130,0x3fc03d94,0x3fc002d0,0x3fa00e74,0x3fc037e8,0x3fa03b4c,0x3fe006d8,0x3f800a7c,0x3fe033e0,0x3f803f44}, + uint32(0xfff80000), + [21]string{"0xa6","0x8f","0x0c","0x11","0x49","0xce","0x8e","0x91","0x3c","0x5b","0x93","0xcd","0x33","0x49","0x36","0x93","0x8c","0xa9","0x32","0x99","0x00"} }, + { + /* No.926 delta:2075 weight:1247 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x3d16ef93,0x7a0154b5,0x4717bb26,0x4f7039e0,0x7266d673,0x35716d55,0x086782c6,0x00009ba0,0x3d167433,0x7a01cf15,0x47172086,0x4f70a240,0x72664dd3,0x3571f6f5,0x08671966}, + [16]uint32{0x00000000,0x7dc4355e,0x18122071,0x65d6152f,0x1447e018,0x6983d546,0x0c55c069,0x7191f537,0x00e880e5,0x7d2cb5bb,0x18faa094,0x653e95ca,0x14af60fd,0x696b55a3,0x0cbd408c,0x717975d2}, + [16]uint32{0x3f800000,0x3fbee21a,0x3f8c0910,0x3fb2eb0a,0x3f8a23f0,0x3fb4c1ea,0x3f862ae0,0x3fb8c8fa,0x3f807440,0x3fbe965a,0x3f8c7d50,0x3fb29f4a,0x3f8a57b0,0x3fb4b5aa,0x3f865ea0,0x3fb8bcba}, + uint32(0xfff80000), + [21]string{"0xf8","0xb1","0xdf","0x95","0x99","0x4e","0xe8","0x05","0x6c","0xe6","0x9c","0x66","0xf3","0x24","0xa9","0xb2","0xff","0xac","0xaf","0x04","0x00"} }, + { + /* No.927 delta:738 weight:1261 */ + 11213, + 78, + 13, + 4, + [16]uint32{0x00000000,0x9855fd8a,0x1574193b,0x8d21e4b1,0x06f039fb,0x9ea5c471,0x138420c0,0x8bd1dd4a,0x0000f562,0x985508e8,0x1574ec59,0x8d2111d3,0x06f0cc99,0x9ea53113,0x1384d5a2,0x8bd12828}, + [16]uint32{0x00000000,0xa002139e,0x2010885d,0x80129bc3,0x22010cc9,0x82031f57,0x02118494,0xa213970a,0x00081381,0xa00a001f,0x20189bdc,0x801a8842,0x22091f48,0x820b0cd6,0x02199715,0xa21b848b}, + [16]uint32{0x3f800000,0x3fd00109,0x3f900844,0x3fc0094d,0x3f910086,0x3fc1018f,0x3f8108c2,0x3fd109cb,0x3f800409,0x3fd00500,0x3f900c4d,0x3fc00d44,0x3f91048f,0x3fc10586,0x3f810ccb,0x3fd10dc2}, + uint32(0xfff80000), + [21]string{"0x92","0xb4","0x0b","0xe3","0x6e","0xf5","0xce","0x02","0x7c","0x80","0x23","0xa5","0xf4","0xd1","0x38","0x5d","0xa4","0xe3","0xde","0x2c","0x00"} }, + { + /* No.928 delta:962 weight:1531 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0xc3ad8fae,0x6da90795,0xae04883b,0xe8703a05,0x2bddb5ab,0x85d93d90,0x4674b23e,0x00004835,0xc3adc79b,0x6da94fa0,0xae04c00e,0xe8707230,0x2bddfd9e,0x85d975a5,0x4674fa0b}, + [16]uint32{0x00000000,0x00421c5e,0x4002d342,0x4040cf1c,0x60008667,0x60429a39,0x20025525,0x2040497b,0x30000011,0x30421c4f,0x7002d353,0x7040cf0d,0x50008676,0x50429a28,0x10025534,0x1040496a}, + [16]uint32{0x3f800000,0x3f80210e,0x3fa00169,0x3fa02067,0x3fb00043,0x3fb0214d,0x3f90012a,0x3f902024,0x3f980000,0x3f98210e,0x3fb80169,0x3fb82067,0x3fa80043,0x3fa8214d,0x3f88012a,0x3f882024}, + uint32(0xfff80000), + [21]string{"0x5e","0xce","0xaf","0xae","0x77","0xf2","0xa2","0xd7","0xa6","0xdd","0x12","0xf6","0x3a","0xb7","0xe6","0x61","0x64","0xef","0x6c","0xa9","0x00"} }, + { + /* No.929 delta:1454 weight:1605 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x774ff63f,0x9bf1af7d,0xecbe5942,0xe3a03a11,0x94efcc2e,0x7851956c,0x0f1e6353,0x0000d2e0,0x774f24df,0x9bf17d9d,0xecbe8ba2,0xe3a0e8f1,0x94ef1ece,0x7851478c,0x0f1eb1b3}, + [16]uint32{0x00000000,0x48742c54,0x40089017,0x087cbc43,0x004e020c,0x483a2e58,0x4046921b,0x0832be4f,0x60208402,0x2854a856,0x20281415,0x685c3841,0x606e860e,0x281aaa5a,0x20661619,0x68123a4d}, + [16]uint32{0x3f800000,0x3fa43a16,0x3fa00448,0x3f843e5e,0x3f802701,0x3fa41d17,0x3fa02349,0x3f84195f,0x3fb01042,0x3f942a54,0x3f90140a,0x3fb42e1c,0x3fb03743,0x3f940d55,0x3f90330b,0x3fb4091d}, + uint32(0xfff80000), + [21]string{"0x76","0x9c","0x91","0x4d","0xa2","0xa8","0xf9","0x01","0xe6","0x0b","0xab","0x8c","0xbd","0x36","0xec","0xaf","0x4b","0x4a","0x33","0x12","0x00"} }, + { + /* No.930 delta:1534 weight:1569 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x0bb95810,0xfc56c990,0xf7ef9180,0xc7b03a2f,0xcc09623f,0x3be6f3bf,0x305fabaf,0x00008926,0x0bb9d136,0xfc5640b6,0xf7ef18a6,0xc7b0b309,0xcc09eb19,0x3be67a99,0x305f2289}, + [16]uint32{0x00000000,0x0f1d10fa,0x08a8401c,0x07b550e6,0x0080f12e,0x0f9de1d4,0x0828b132,0x0735a1c8,0x00428d4f,0x0f5f9db5,0x08eacd53,0x07f7dda9,0x00c27c61,0x0fdf6c9b,0x086a3c7d,0x07772c87}, + [16]uint32{0x3f800000,0x3f878e88,0x3f845420,0x3f83daa8,0x3f804078,0x3f87cef0,0x3f841458,0x3f839ad0,0x3f802146,0x3f87afce,0x3f847566,0x3f83fbee,0x3f80613e,0x3f87efb6,0x3f84351e,0x3f83bb96}, + uint32(0xfff80000), + [21]string{"0x0d","0x50","0xfb","0x98","0x56","0x1e","0x80","0xa3","0x6b","0xbb","0x73","0x98","0x58","0x03","0xe9","0x99","0x03","0x7a","0x9d","0x06","0x00"} }, + { + /* No.931 delta:680 weight:1409 */ + 11213, + 90, + 13, + 4, + [16]uint32{0x00000000,0xc50443ac,0x77dfd5c7,0xb2db966b,0xc2503a3a,0x07547996,0xb58feffd,0x708bac51,0x00002bc2,0xc504686e,0x77dffe05,0xb2dbbda9,0xc25011f8,0x07545254,0xb58fc43f,0x708b8793}, + [16]uint32{0x00000000,0x0071f215,0x300dc41e,0x307c360b,0x5053a9da,0x50225bcf,0x605e6dc4,0x602f9fd1,0x402ce109,0x405d131c,0x70212517,0x7050d702,0x107f48d3,0x100ebac6,0x20728ccd,0x20037ed8}, + [16]uint32{0x3f800000,0x3f8038f9,0x3f9806e2,0x3f983e1b,0x3fa829d4,0x3fa8112d,0x3fb02f36,0x3fb017cf,0x3fa01670,0x3fa02e89,0x3fb81092,0x3fb8286b,0x3f883fa4,0x3f88075d,0x3f903946,0x3f9001bf}, + uint32(0xfff80000), + [21]string{"0x5d","0x06","0x30","0x79","0x6d","0xa1","0x6a","0x97","0x54","0x2e","0x83","0xa5","0x1b","0xa3","0x00","0xa7","0x4e","0xce","0x4d","0x93","0x00"} }, + { + /* No.932 delta:774 weight:1557 */ + 11213, + 68, + 13, + 4, + [16]uint32{0x00000000,0xd99c677b,0xcff1bacd,0x166dddb6,0xe7703a48,0x3eec5d33,0x28818085,0xf11de7fe,0x0000a030,0xd99cc74b,0xcff11afd,0x166d7d86,0xe7709a78,0x3eecfd03,0x288120b5,0xf11d47ce}, + [16]uint32{0x00000000,0xa4426e5e,0x3003229b,0x94414cc5,0x1000120a,0xb4427c54,0x20033091,0x84415ecf,0x24000159,0x80426f07,0x140323c2,0xb0414d9c,0x34001353,0x90427d0d,0x040331c8,0xa0415f96}, + [16]uint32{0x3f800000,0x3fd22137,0x3f980191,0x3fca20a6,0x3f880009,0x3fda213e,0x3f900198,0x3fc220af,0x3f920000,0x3fc02137,0x3f8a0191,0x3fd820a6,0x3f9a0009,0x3fc8213e,0x3f820198,0x3fd020af}, + uint32(0xfff80000), + [21]string{"0x20","0x43","0xd4","0x7f","0xde","0xde","0x20","0xe2","0xd6","0xf9","0x70","0x2b","0xb9","0xc6","0xa9","0x49","0x4b","0x27","0x31","0x41","0x00"} }, + { + /* No.933 delta:595 weight:1765 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0xdd80bfa7,0x59ad25be,0x842d9a19,0x7b903a57,0xa61085f0,0x223d1fe9,0xffbda04e,0x000058b3,0xdd80e714,0x59ad7d0d,0x842dc2aa,0x7b9062e4,0xa610dd43,0x223d475a,0xffbdf8fd}, + [16]uint32{0x00000000,0x2043087e,0x0002a66a,0x2041ae14,0x2000dabf,0x0043d2c1,0x20027cd5,0x004174ab,0x1000a016,0x3043a868,0x1002067c,0x30410e02,0x30007aa9,0x104372d7,0x3002dcc3,0x1041d4bd}, + [16]uint32{0x3f800000,0x3f902184,0x3f800153,0x3f9020d7,0x3f90006d,0x3f8021e9,0x3f90013e,0x3f8020ba,0x3f880050,0x3f9821d4,0x3f880103,0x3f982087,0x3f98003d,0x3f8821b9,0x3f98016e,0x3f8820ea}, + uint32(0xfff80000), + [21]string{"0x59","0xad","0x2b","0x01","0x90","0x4d","0xf3","0x0a","0x44","0xf6","0x7a","0xb1","0xe0","0x93","0x90","0x44","0xb6","0x7a","0x52","0xf2","0x00"} }, + { + /* No.934 delta:1003 weight:1569 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x845889d5,0x3e647ff0,0xba3cf625,0xb7e03a67,0x33b8b3b2,0x89844597,0x0ddccc42,0x0000bc10,0x845835c5,0x3e64c3e0,0xba3c4a35,0xb7e08677,0x33b80fa2,0x8984f987,0x0ddc7052}, + [16]uint32{0x00000000,0x0004d9d6,0x5008361f,0x500cefc9,0x10224bfb,0x1026922d,0x402a7de4,0x402ea432,0x0002401a,0x000699cc,0x500a7605,0x500eafd3,0x10200be1,0x1024d237,0x40283dfe,0x402ce428}, + [16]uint32{0x3f800000,0x3f80026c,0x3fa8041b,0x3fa80677,0x3f881125,0x3f881349,0x3fa0153e,0x3fa01752,0x3f800120,0x3f80034c,0x3fa8053b,0x3fa80757,0x3f881005,0x3f881269,0x3fa0141e,0x3fa01672}, + uint32(0xfff80000), + [21]string{"0xd3","0xac","0x18","0xf5","0xa5","0x47","0x0f","0xd4","0x4f","0x5e","0x17","0x01","0x44","0x36","0x9c","0x43","0xb4","0xcc","0x68","0x79","0x00"} }, + { + /* No.935 delta:1449 weight:1699 */ + 11213, + 85, + 13, + 4, + [16]uint32{0x00000000,0x5e5eed4f,0x3893f32d,0x66cd1e62,0xd2e03a7f,0x8cbed730,0xea73c952,0xb42d241d,0x00002bd1,0x5e5ec69e,0x3893d8fc,0x66cd35b3,0xd2e011ae,0x8cbefce1,0xea73e283,0xb42d0fcc}, + [16]uint32{0x00000000,0x203800dd,0x00074116,0x203f41cb,0x2001003f,0x003900e2,0x20064129,0x003e41f4,0x0004c039,0x203cc0e4,0x0003812f,0x203b81f2,0x2005c006,0x003dc0db,0x20028110,0x003a81cd}, + [16]uint32{0x3f800000,0x3f901c00,0x3f8003a0,0x3f901fa0,0x3f900080,0x3f801c80,0x3f900320,0x3f801f20,0x3f800260,0x3f901e60,0x3f8001c0,0x3f901dc0,0x3f9002e0,0x3f801ee0,0x3f900140,0x3f801d40}, + uint32(0xfff80000), + [21]string{"0x1d","0x13","0x2b","0xba","0x03","0xf2","0x4f","0x61","0x68","0x6b","0x69","0x21","0xda","0x0b","0x3f","0x6d","0x17","0xd2","0xf4","0xbd","0x00"} }, + { + /* No.936 delta:896 weight:1561 */ + 11213, + 91, + 13, + 4, + [16]uint32{0x00000000,0xacfcdf03,0x696f497f,0xc593967c,0x1f303a87,0xb3cce584,0x765f73f8,0xdaa3acfb,0x0000f6f0,0xacfc29f3,0x696fbf8f,0xc593608c,0x1f30cc77,0xb3cc1374,0x765f8508,0xdaa35a0b}, + [16]uint32{0x00000000,0x007400d5,0x004320f6,0x00372023,0x0429e86c,0x045de8b9,0x046ac89a,0x041ec84f,0x50180018,0x506c00cd,0x505b20ee,0x502f203b,0x5431e874,0x5445e8a1,0x5472c882,0x5406c857}, + [16]uint32{0x3f800000,0x3f803a00,0x3f802190,0x3f801b90,0x3f8214f4,0x3f822ef4,0x3f823564,0x3f820f64,0x3fa80c00,0x3fa83600,0x3fa82d90,0x3fa81790,0x3faa18f4,0x3faa22f4,0x3faa3964,0x3faa0364}, + uint32(0xfff80000), + [21]string{"0x8b","0xee","0xc6","0x63","0x17","0x86","0x00","0x9f","0xae","0x33","0x55","0x42","0xb3","0xe7","0x14","0xed","0x27","0xe1","0x5d","0xab","0x00"} }, + { + /* No.937 delta:1479 weight:1795 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0x90905875,0x19772e9d,0x89e776e8,0x3e803a92,0xae1062e7,0x27f7140f,0xb7674c7a,0x00001b06,0x90904373,0x1977359b,0x89e76dee,0x3e802194,0xae1079e1,0x27f70f09,0xb767577c}, + [16]uint32{0x00000000,0x0694901a,0x52f26765,0x5466f77f,0x005a60a9,0x06cef0b3,0x52a807cc,0x543c97d6,0x007ae21b,0x06ee7201,0x5288857e,0x541c1564,0x002082b2,0x06b412a8,0x52d2e5d7,0x544675cd}, + [16]uint32{0x3f800000,0x3f834a48,0x3fa97933,0x3faa337b,0x3f802d30,0x3f836778,0x3fa95403,0x3faa1e4b,0x3f803d71,0x3f837739,0x3fa94442,0x3faa0e0a,0x3f801041,0x3f835a09,0x3fa96972,0x3faa233a}, + uint32(0xfff80000), + [21]string{"0x00","0xce","0x34","0xca","0x07","0x25","0x86","0xd5","0x72","0x75","0xb7","0x67","0xef","0xe0","0x01","0xda","0x79","0x38","0xb6","0x0b","0x00"} }, + { + /* No.938 delta:3091 weight:585 */ + 11213, + 3, + 13, + 4, + [16]uint32{0x00000000,0x25ed51db,0xcf7ef76a,0xea93a6b1,0xf8403aa5,0xddad6b7e,0x373ecdcf,0x12d39c14,0x00005a2e,0x25ed0bf5,0xcf7ead44,0xea93fc9f,0xf840608b,0xddad3150,0x373e97e1,0x12d3c63a}, + [16]uint32{0x00000000,0xb95800b5,0x822010d7,0x3b781062,0x4482440c,0xfdda44b9,0xc6a254db,0x7ffa546e,0x4bc0c15a,0xf298c1ef,0xc9e0d18d,0x70b8d138,0x0f428556,0xb61a85e3,0x8d629581,0x343a9534}, + [16]uint32{0x3f800000,0x3fdcac00,0x3fc11008,0x3f9dbc08,0x3fa24122,0x3ffeed22,0x3fe3512a,0x3fbffd2a,0x3fa5e060,0x3ff94c60,0x3fe4f068,0x3fb85c68,0x3f87a142,0x3fdb0d42,0x3fc6b14a,0x3f9a1d4a}, + uint32(0xfff80000), + [21]string{"0xb2","0x4b","0x93","0xc3","0x60","0x8f","0xd6","0xa5","0xae","0xde","0x58","0x7a","0x8b","0xbb","0x6d","0xe4","0xc1","0x90","0x97","0x38","0x00"} }, + { + /* No.939 delta:2163 weight:1277 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x4c008da2,0x825f20bf,0xce5fad1d,0x13103ab0,0x5f10b712,0x914f1a0f,0xdd4f97ad,0x00006480,0x4c00e922,0x825f443f,0xce5fc99d,0x13105e30,0x5f10d392,0x914f7e8f,0xdd4ff32d}, + [16]uint32{0x00000000,0x0c21c0d6,0x026b01f3,0x0e4ac125,0x0325e194,0x0f042142,0x014ee067,0x0d6f20b1,0x6221c0fa,0x6e00002c,0x604ac109,0x6c6b01df,0x6104216e,0x6d25e1b8,0x636f209d,0x6f4ee04b}, + [16]uint32{0x3f800000,0x3f8610e0,0x3f813580,0x3f872560,0x3f8192f0,0x3f878210,0x3f80a770,0x3f86b790,0x3fb110e0,0x3fb70000,0x3fb02560,0x3fb63580,0x3fb08210,0x3fb692f0,0x3fb1b790,0x3fb7a770}, + uint32(0xfff80000), + [21]string{"0x7a","0xc5","0x6c","0x9b","0x7c","0x7a","0x5b","0xbe","0xb6","0x51","0xc0","0x41","0x99","0x2e","0x23","0xc5","0x72","0x0b","0xb1","0x40","0x00"} }, + { + /* No.940 delta:840 weight:1609 */ + 11213, + 84, + 13, + 4, + [16]uint32{0x00000000,0xcad35095,0xd32c50cc,0x19ff0059,0x8b103acf,0x41c36a5a,0x583c6a03,0x92ef3a96,0x0000bc0f,0xcad3ec9a,0xd32cecc3,0x19ffbc56,0x8b1086c0,0x41c3d655,0x583cd60c,0x92ef8699}, + [16]uint32{0x00000000,0x206ef075,0x20198fdf,0x00777faa,0x00021108,0x206ce17d,0x201b9ed7,0x00756ea2,0x001c06a4,0x2072f6d1,0x2005897b,0x006b790e,0x001e17ac,0x2070e7d9,0x20079873,0x00696806}, + [16]uint32{0x3f800000,0x3f903778,0x3f900cc7,0x3f803bbf,0x3f800108,0x3f903670,0x3f900dcf,0x3f803ab7,0x3f800e03,0x3f90397b,0x3f9002c4,0x3f8035bc,0x3f800f0b,0x3f903873,0x3f9003cc,0x3f8034b4}, + uint32(0xfff80000), + [21]string{"0xfc","0x1d","0xb4","0x6b","0x37","0x39","0xe3","0x8e","0xbc","0x8a","0x2a","0xea","0x1c","0x2e","0xe5","0x60","0x43","0x48","0xab","0x75","0x00"} }, + { + /* No.941 delta:926 weight:1631 */ + 11213, + 41, + 13, + 4, + [16]uint32{0x00000000,0x2a017785,0xdc59f51d,0xf6588298,0x14103ad9,0x3e114d5c,0xc849cfc4,0xe248b841,0x0000c6db,0x2a01b15e,0xdc5933c6,0xf6584443,0x1410fc02,0x3e118b87,0xc849091f,0xe2487e9a}, + [16]uint32{0x00000000,0x402206ba,0x104d10b4,0x506f160e,0x006760f3,0x40456649,0x102a7047,0x500876fd,0x0002401b,0x402046a1,0x104f50af,0x506d5615,0x006520e8,0x40472652,0x1028305c,0x500a36e6}, + [16]uint32{0x3f800000,0x3fa01103,0x3f882688,0x3fa8378b,0x3f8033b0,0x3fa022b3,0x3f881538,0x3fa8043b,0x3f800120,0x3fa01023,0x3f8827a8,0x3fa836ab,0x3f803290,0x3fa02393,0x3f881418,0x3fa8051b}, + uint32(0xfff80000), + [21]string{"0xdd","0x0a","0x49","0xfa","0x1e","0x8c","0xe0","0xf9","0x86","0xf1","0xa5","0x70","0x75","0xa9","0xf6","0x7c","0xb1","0x87","0x42","0xd4","0x00"} }, + { + /* No.942 delta:1159 weight:1167 */ + 11213, + 40, + 13, + 4, + [16]uint32{0x00000000,0x69fb4557,0x377450e0,0x5e8f15b7,0x69c03ae9,0x003b7fbe,0x5eb46a09,0x374f2f5e,0x0000d8b6,0x69fb9de1,0x37748856,0x5e8fcd01,0x69c0e25f,0x003ba708,0x5eb4b2bf,0x374ff7e8}, + [16]uint32{0x00000000,0x006c00d4,0x4002e0bb,0x406ee06f,0x401071ec,0x407c7138,0x00129157,0x007e9183,0x0003701c,0x006f70c8,0x400190a7,0x406d9073,0x401301f0,0x407f0124,0x0011e14b,0x007de19f}, + [16]uint32{0x3f800000,0x3f803600,0x3fa00170,0x3fa03770,0x3fa00838,0x3fa03e38,0x3f800948,0x3f803f48,0x3f8001b8,0x3f8037b8,0x3fa000c8,0x3fa036c8,0x3fa00980,0x3fa03f80,0x3f8008f0,0x3f803ef0}, + uint32(0xfff80000), + [21]string{"0xb8","0x40","0xda","0x5a","0x09","0x2d","0xd6","0xda","0xa0","0x2b","0x8b","0xa5","0x40","0x02","0xe9","0x8b","0x07","0x4a","0x1d","0x49","0x00"} }, + { + /* No.943 delta:1597 weight:1677 */ + 11213, + 14, + 13, + 4, + [16]uint32{0x00000000,0x14e9600c,0xbabee6f3,0xae5786ff,0x7f403afc,0x6ba95af0,0xc5fedc0f,0xd117bc03,0x00003392,0x14e9539e,0xbabed561,0xae57b56d,0x7f40096e,0x6ba96962,0xc5feef9d,0xd1178f91}, + [16]uint32{0x00000000,0x0a008496,0x040480c7,0x0e040451,0x010241ba,0x0b02c52c,0x0506c17d,0x0f0645eb,0x008a9002,0x0a8a1494,0x048e10c5,0x0e8e9453,0x0188d1b8,0x0b88552e,0x058c517f,0x0f8cd5e9}, + [16]uint32{0x3f800000,0x3f850042,0x3f820240,0x3f870202,0x3f808120,0x3f858162,0x3f828360,0x3f878322,0x3f804548,0x3f85450a,0x3f824708,0x3f87474a,0x3f80c468,0x3f85c42a,0x3f82c628,0x3f87c66a}, + uint32(0xfff80000), + [21]string{"0x97","0x89","0xa8","0x4e","0x5f","0x71","0x52","0xbf","0x93","0xd6","0x28","0x77","0x78","0x47","0xad","0xc6","0xd6","0xd0","0x3e","0xd5","0x00"} }, + { + /* No.944 delta:936 weight:1299 */ + 11213, + 72, + 13, + 4, + [16]uint32{0x00000000,0x83ab720e,0xf495de76,0x773eac78,0x92703b0a,0x11db4904,0x66e5e57c,0xe54e9772,0x00000aea,0x83ab78e4,0xf495d49c,0x773ea692,0x927031e0,0x11db43ee,0x66e5ef96,0xe54e9d98}, + [16]uint32{0x00000000,0x00094035,0x004150b6,0x00481083,0x20220012,0x202b4027,0x206350a4,0x206a1091,0x1000101e,0x1009502b,0x104140a8,0x1048009d,0x3022100c,0x302b5039,0x306340ba,0x306a008f}, + [16]uint32{0x3f800000,0x3f8004a0,0x3f8020a8,0x3f802408,0x3f901100,0x3f9015a0,0x3f9031a8,0x3f903508,0x3f880008,0x3f8804a8,0x3f8820a0,0x3f882400,0x3f981108,0x3f9815a8,0x3f9831a0,0x3f983500}, + uint32(0xfff80000), + [21]string{"0xfd","0x35","0x0d","0x23","0x9b","0xc6","0x2b","0xf2","0x83","0xb6","0x66","0x06","0x09","0x6e","0x8e","0x64","0xb4","0xe4","0x89","0x0c","0x00"} }, + { + /* No.945 delta:1075 weight:1373 */ + 11213, + 32, + 13, + 4, + [16]uint32{0x00000000,0xeac0da70,0x951dd726,0x7fdd0d56,0x24e03b18,0xce20e168,0xb1fdec3e,0x5b3d364e,0x00005fca,0xeac085ba,0x951d88ec,0x7fdd529c,0x24e064d2,0xce20bea2,0xb1fdb3f4,0x5b3d6984}, + [16]uint32{0x00000000,0x1402dc95,0x10006809,0x0402b49c,0x4000681a,0x5402b48f,0x50000013,0x4402dc86,0x0044382c,0x1446e4b9,0x10445025,0x04468cb0,0x40445036,0x54468ca3,0x5044383f,0x4446e4aa}, + [16]uint32{0x3f800000,0x3f8a016e,0x3f880034,0x3f82015a,0x3fa00034,0x3faa015a,0x3fa80000,0x3fa2016e,0x3f80221c,0x3f8a2372,0x3f882228,0x3f822346,0x3fa02228,0x3faa2346,0x3fa8221c,0x3fa22372}, + uint32(0xfff80000), + [21]string{"0xc5","0x5f","0x67","0xeb","0xdd","0xeb","0x9b","0x73","0x78","0xf7","0x20","0x56","0xe3","0x22","0xfd","0x3d","0x3b","0x31","0x1c","0xcd","0x00"} }, + { + /* No.946 delta:1219 weight:1611 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0xe814e250,0xea9f56e4,0x028bb4b4,0x8bd03b2f,0x63c4d97f,0x614f6dcb,0x895b8f9b,0x00009c80,0xe8147ed0,0xea9fca64,0x028b2834,0x8bd0a7af,0x63c445ff,0x614ff14b,0x895b131b}, + [16]uint32{0x00000000,0x5066009a,0x001a601d,0x507c6087,0x012846bf,0x514e4625,0x013226a2,0x51542638,0x40000404,0x1066049e,0x401a6419,0x107c6483,0x412842bb,0x114e4221,0x413222a6,0x1154223c}, + [16]uint32{0x3f800000,0x3fa83300,0x3f800d30,0x3fa83e30,0x3f809423,0x3fa8a723,0x3f809913,0x3fa8aa13,0x3fa00002,0x3f883302,0x3fa00d32,0x3f883e32,0x3fa09421,0x3f88a721,0x3fa09911,0x3f88aa11}, + uint32(0xfff80000), + [21]string{"0xe7","0x20","0x08","0x62","0x22","0x96","0x19","0x05","0xe3","0x63","0x10","0x02","0x56","0x5d","0xb5","0x7e","0x82","0x37","0xd5","0x8d","0x00"} }, + { + /* No.947 delta:930 weight:1221 */ + 11213, + 36, + 13, + 4, + [16]uint32{0x00000000,0xc10af2ab,0xa862f137,0x6968039c,0x3d503b35,0xfc5ac99e,0x9532ca02,0x543838a9,0x0000b8f0,0xc10a4a5b,0xa86249c7,0x6968bb6c,0x3d5083c5,0xfc5a716e,0x953272f2,0x54388059}, + [16]uint32{0x00000000,0x18002cb2,0xc05c6099,0xd85c4c2b,0x50274017,0x48276ca5,0x907b208e,0x887b0c3c,0x00023091,0x18021c23,0xc05e5008,0xd85e7cba,0x50257086,0x48255c34,0x9079101f,0x88793cad}, + [16]uint32{0x3f800000,0x3f8c0016,0x3fe02e30,0x3fec2e26,0x3fa813a0,0x3fa413b6,0x3fc83d90,0x3fc43d86,0x3f800118,0x3f8c010e,0x3fe02f28,0x3fec2f3e,0x3fa812b8,0x3fa412ae,0x3fc83c88,0x3fc43c9e}, + uint32(0xfff80000), + [21]string{"0xa4","0x47","0x3f","0x17","0x81","0x90","0xf4","0x5e","0xfa","0xc9","0x42","0x7d","0xde","0x74","0x0d","0x1d","0xc7","0xd7","0x8d","0x36","0x00"} }, + { + /* No.948 delta:856 weight:1579 */ + 11213, + 82, + 13, + 4, + [16]uint32{0x00000000,0xa0bd0c75,0x788cd063,0xd831dc16,0x60d03b48,0xc06d373d,0x185ceb2b,0xb8e1e75e,0x0000647b,0xa0bd680e,0x788cb418,0xd831b86d,0x60d05f33,0xc06d5346,0x185c8f50,0xb8e18325}, + [16]uint32{0x00000000,0x2023891d,0x00422427,0x2061ad3a,0x20016012,0x0022e90f,0x20434435,0x0060cd28,0x0001f013,0x2022790e,0x0043d434,0x20605d29,0x20009001,0x0023191c,0x2042b426,0x00613d3b}, + [16]uint32{0x3f800000,0x3f9011c4,0x3f802112,0x3f9030d6,0x3f9000b0,0x3f801174,0x3f9021a2,0x3f803066,0x3f8000f8,0x3f90113c,0x3f8021ea,0x3f90302e,0x3f900048,0x3f80118c,0x3f90215a,0x3f80309e}, + uint32(0xfff80000), + [21]string{"0xcd","0x8f","0x2a","0x05","0x56","0xf2","0x13","0x22","0x6c","0xbf","0x57","0x10","0xc4","0x86","0xf3","0x20","0xc2","0xc3","0xc6","0xce","0x00"} }, + { + /* No.949 delta:878 weight:1241 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xa54c68ba,0x109b8788,0xb5d7ef32,0x77a03b57,0xd2ec53ed,0x673bbcdf,0xc277d465,0x0000dcdd,0xa54cb467,0x109b5b55,0xb5d733ef,0x77a0e78a,0xd2ec8f30,0x673b6002,0xc27708b8}, + [16]uint32{0x00000000,0x105c4212,0x70024114,0x605e0306,0x200305a9,0x305f47bb,0x500144bd,0x405d06af,0x20020418,0x305e460a,0x5000450c,0x405c071e,0x000101b1,0x105d43a3,0x700340a5,0x605f02b7}, + [16]uint32{0x3f800000,0x3f882e21,0x3fb80120,0x3fb02f01,0x3f900182,0x3f982fa3,0x3fa800a2,0x3fa02e83,0x3f900102,0x3f982f23,0x3fa80022,0x3fa02e03,0x3f800080,0x3f882ea1,0x3fb801a0,0x3fb02f81}, + uint32(0xfff80000), + [21]string{"0xcd","0x06","0xad","0x5c","0x2d","0xec","0xc6","0x31","0x5f","0x3b","0x3c","0xe8","0xfa","0xb0","0xe8","0xc9","0xdf","0x58","0x53","0xed","0x00"} }, + { + /* No.950 delta:882 weight:1399 */ + 11213, + 79, + 13, + 4, + [16]uint32{0x00000000,0x2f5cd4a4,0x7948350c,0x5614e1a8,0x6a303b65,0x456cefc1,0x13780e69,0x3c24dacd,0x0000d9bb,0x2f5c0d1f,0x7948ecb7,0x56143813,0x6a30e2de,0x456c367a,0x1378d7d2,0x3c240376}, + [16]uint32{0x00000000,0x200e209a,0x00520db5,0x205c2d2f,0x00001416,0x200e348c,0x005219a3,0x205c3939,0x40238401,0x602da49b,0x407189b4,0x607fa92e,0x40239017,0x602db08d,0x40719da2,0x607fbd38}, + [16]uint32{0x3f800000,0x3f900710,0x3f802906,0x3f902e16,0x3f80000a,0x3f90071a,0x3f80290c,0x3f902e1c,0x3fa011c2,0x3fb016d2,0x3fa038c4,0x3fb03fd4,0x3fa011c8,0x3fb016d8,0x3fa038ce,0x3fb03fde}, + uint32(0xfff80000), + [21]string{"0x14","0xd0","0x07","0x41","0x65","0x1c","0x64","0x4a","0x0c","0x43","0x6c","0xe9","0x7c","0x51","0x53","0x2e","0xd2","0x00","0x6e","0xa4","0x00"} }, + { + /* No.951 delta:1067 weight:1489 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0xc759983f,0x2995e606,0xeecc7e39,0x88703b71,0x4f29a34e,0xa1e5dd77,0x66bc4548,0x0000ba9a,0xc75922a5,0x29955c9c,0xeeccc4a3,0x887081eb,0x4f2919d4,0xa1e567ed,0x66bcffd2}, + [16]uint32{0x00000000,0x881ccc5a,0x10631194,0x987fddce,0x00024813,0x881e8449,0x10615987,0x987d95dd,0x20115e05,0xa80d925f,0x30724f91,0xb86e83cb,0x20131616,0xa80fda4c,0x30700782,0xb86ccbd8}, + [16]uint32{0x3f800000,0x3fc40e66,0x3f883188,0x3fcc3fee,0x3f800124,0x3fc40f42,0x3f8830ac,0x3fcc3eca,0x3f9008af,0x3fd406c9,0x3f983927,0x3fdc3741,0x3f90098b,0x3fd407ed,0x3f983803,0x3fdc3665}, + uint32(0xfff80000), + [21]string{"0x82","0xc1","0xae","0x62","0x4b","0x46","0xf4","0x5b","0x4f","0xde","0x1c","0x03","0xf5","0x45","0xc0","0xf1","0xeb","0xd9","0xfb","0xa1","0x00"} }, + { + /* No.952 delta:1981 weight:1575 */ + 11213, + 75, + 13, + 4, + [16]uint32{0x00000000,0x3cfa56da,0xfda3a2fc,0xc159f426,0xb2403b80,0x8eba6d5a,0x4fe3997c,0x7319cfa6,0x0000e3ab,0x3cfab571,0xfda34157,0xc159178d,0xb240d82b,0x8eba8ef1,0x4fe37ad7,0x73192c0d}, + [16]uint32{0x00000000,0x01640595,0x0052005e,0x013605cb,0x00000189,0x0164041c,0x005201d7,0x01360442,0xc0820014,0xc1e60581,0xc0d0004a,0xc1b405df,0xc082019d,0xc1e60408,0xc0d001c3,0xc1b40456}, + [16]uint32{0x3f800000,0x3f80b202,0x3f802900,0x3f809b02,0x3f800000,0x3f80b202,0x3f802900,0x3f809b02,0x3fe04100,0x3fe0f302,0x3fe06800,0x3fe0da02,0x3fe04100,0x3fe0f302,0x3fe06800,0x3fe0da02}, + uint32(0xfff80000), + [21]string{"0x14","0x5e","0xff","0x94","0x14","0x96","0x13","0x94","0x6c","0xb0","0xe4","0xd9","0x23","0x8a","0x50","0xad","0x2f","0x90","0x11","0x2d","0x00"} }, + { + /* No.953 delta:937 weight:1093 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0xe3b50553,0x263c7a97,0xc5897fc4,0x9d303b97,0x7e853ec4,0xbb0c4100,0x58b94453,0x00008b51,0xe3b58e02,0x263cf1c6,0xc589f495,0x9d30b0c6,0x7e85b595,0xbb0cca51,0x58b9cf02}, + [16]uint32{0x00000000,0x0068117e,0x401401db,0x407c10a5,0x005485f4,0x003c948a,0x4040842f,0x40289551,0x00304081,0x005851ff,0x4024415a,0x404c5024,0x0064c575,0x000cd40b,0x4070c4ae,0x4018d5d0}, + [16]uint32{0x3f800000,0x3f803408,0x3fa00a00,0x3fa03e08,0x3f802a42,0x3f801e4a,0x3fa02042,0x3fa0144a,0x3f801820,0x3f802c28,0x3fa01220,0x3fa02628,0x3f803262,0x3f80066a,0x3fa03862,0x3fa00c6a}, + uint32(0xfff80000), + [21]string{"0x73","0xc3","0x78","0x71","0x90","0xd6","0xa2","0xd7","0x23","0x48","0xd2","0x19","0x05","0x65","0x86","0x82","0x36","0x70","0x97","0x56","0x00"} }, + { + /* No.954 delta:855 weight:707 */ + 11213, + 71, + 13, + 4, + [16]uint32{0x00000000,0x53612589,0x4c7bc33b,0x1f1ae6b2,0x63603ba9,0x30011e20,0x2f1bf892,0x7c7add1b,0x0000963b,0x5361b3b2,0x4c7b5500,0x1f1a7089,0x6360ad92,0x3001881b,0x2f1b6ea9,0x7c7a4b20}, + [16]uint32{0x00000000,0x806247d6,0x102019f1,0x90425e27,0x10440055,0x90264783,0x006419a4,0x80065e72,0x001b020e,0x807945d8,0x103b1bff,0x90595c29,0x105f025b,0x903d458d,0x007f1baa,0x801d5c7c}, + [16]uint32{0x3f800000,0x3fc03123,0x3f88100c,0x3fc8212f,0x3f882200,0x3fc81323,0x3f80320c,0x3fc0032f,0x3f800d81,0x3fc03ca2,0x3f881d8d,0x3fc82cae,0x3f882f81,0x3fc81ea2,0x3f803f8d,0x3fc00eae}, + uint32(0xfff80000), + [21]string{"0xbe","0xd1","0x0f","0x8e","0x57","0x0c","0x66","0x0c","0x44","0x94","0x07","0x09","0x24","0x16","0xe6","0x73","0x92","0xb0","0x70","0x75","0x00"} }, + { + /* No.955 delta:843 weight:1195 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x43138caf,0x48d56c1a,0x0bc6e0b5,0xd0103bb0,0x9303b71f,0x98c557aa,0xdbd6db05,0x00004cbd,0x4313c012,0x48d520a7,0x0bc6ac08,0xd010770d,0x9303fba2,0x98c51b17,0xdbd697b8}, + [16]uint32{0x00000000,0x0001815a,0x206c91b1,0x206d10eb,0x14790c18,0x14788d42,0x34159da9,0x34141cf3,0x00207a1e,0x0021fb44,0x204cebaf,0x204d6af5,0x14597606,0x1458f75c,0x3435e7b7,0x343466ed}, + [16]uint32{0x3f800000,0x3f8000c0,0x3f903648,0x3f903688,0x3f8a3c86,0x3f8a3c46,0x3f9a0ace,0x3f9a0a0e,0x3f80103d,0x3f8010fd,0x3f902675,0x3f9026b5,0x3f8a2cbb,0x3f8a2c7b,0x3f9a1af3,0x3f9a1a33}, + uint32(0xfff80000), + [21]string{"0x9b","0xf2","0x0b","0x07","0x85","0x79","0x9a","0xce","0x3d","0x95","0x89","0x3d","0xec","0xef","0x79","0x90","0x73","0x41","0xdd","0x75","0x00"} }, + { + /* No.956 delta:823 weight:1597 */ + 11213, + 57, + 13, + 4, + [16]uint32{0x00000000,0x9a3a3e3e,0x1998b064,0x83a28e5a,0xb7d03bc0,0x2dea05fe,0xae488ba4,0x3472b59a,0x0000de24,0x9a3ae01a,0x19986e40,0x83a2507e,0xb7d0e5e4,0x2deadbda,0xae485580,0x34726bbe}, + [16]uint32{0x00000000,0x504f0557,0x000282d1,0x504d8786,0x10024c83,0x404d49d4,0x1000ce52,0x404fcb05,0x1001401b,0x404e454c,0x1003c2ca,0x404cc79d,0x00030c98,0x504c09cf,0x00018e49,0x504e8b1e}, + [16]uint32{0x3f800000,0x3fa82782,0x3f800141,0x3fa826c3,0x3f880126,0x3fa026a4,0x3f880067,0x3fa027e5,0x3f8800a0,0x3fa02722,0x3f8801e1,0x3fa02663,0x3f800186,0x3fa82604,0x3f8000c7,0x3fa82745}, + uint32(0xfff80000), + [21]string{"0x5c","0xae","0xd3","0x8b","0x85","0xb0","0x7d","0xbd","0xb3","0x66","0x22","0xae","0x00","0x60","0xe9","0x6d","0x96","0x41","0xf3","0x7f","0x00"} }, + { + /* No.957 delta:949 weight:1775 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0x1ef8a728,0x69eaf6ef,0x771251c7,0x5f303bdc,0x41c89cf4,0x36dacd33,0x28226a1b,0x000034e7,0x1ef893cf,0x69eac208,0x77126520,0x5f300f3b,0x41c8a813,0x36daf9d4,0x28225efc}, + [16]uint32{0x00000000,0x100624be,0x00073de5,0x1001195b,0x00009006,0x1006b4b8,0x0007ade3,0x1001895d,0x3045d012,0x2043f4ac,0x3042edf7,0x2044c949,0x30454014,0x204364aa,0x30427df1,0x2044594f}, + [16]uint32{0x3f800000,0x3f880312,0x3f80039e,0x3f88008c,0x3f800048,0x3f88035a,0x3f8003d6,0x3f8800c4,0x3f9822e8,0x3f9021fa,0x3f982176,0x3f902264,0x3f9822a0,0x3f9021b2,0x3f98213e,0x3f90222c}, + uint32(0xfff80000), + [21]string{"0x85","0xa2","0xfd","0xa8","0xcb","0x55","0xdb","0xdb","0x8c","0x5d","0x4a","0xa2","0x67","0x5a","0x5c","0xe2","0x5d","0x77","0x42","0x2c","0x00"} }, + { + /* No.958 delta:790 weight:1737 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xde2c6294,0xa751bc81,0x797dde15,0x99803bed,0x47ac5979,0x3ed1876c,0xe0fde5f8,0x0000ecb6,0xde2c8e22,0xa7515037,0x797d32a3,0x9980d75b,0x47acb5cf,0x3ed16bda,0xe0fd094e}, + [16]uint32{0x00000000,0x08044116,0x60025871,0x68061967,0x100109fd,0x180548eb,0x7003518c,0x7807109a,0x600160cd,0x680521db,0x000338bc,0x080779aa,0x70006930,0x78042826,0x10023141,0x18067057}, + [16]uint32{0x3f800000,0x3f840220,0x3fb0012c,0x3fb4030c,0x3f880084,0x3f8c02a4,0x3fb801a8,0x3fbc0388,0x3fb000b0,0x3fb40290,0x3f80019c,0x3f8403bc,0x3fb80034,0x3fbc0214,0x3f880118,0x3f8c0338}, + uint32(0xfff80000), + [21]string{"0x6e","0xf4","0x6e","0x9e","0xa9","0x43","0x31","0x8e","0xcd","0xb9","0xa9","0x99","0xa5","0x2a","0x29","0xac","0xb7","0x15","0x1b","0x8e","0x00"} }, + { + /* No.959 delta:1603 weight:1701 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0xb116b958,0xed3a2360,0x5c2c9a38,0xbdb03bfc,0x0ca682a4,0x508a189c,0xe19ca1c4,0x00001cae,0xb116a5f6,0xed3a3fce,0x5c2c8696,0xbdb02752,0x0ca69e0a,0x508a0432,0xe19cbd6a}, + [16]uint32{0x00000000,0x006d8195,0x20308107,0x205d0092,0x001200af,0x007f813a,0x202281a8,0x204f003d,0x308a801c,0x30e70189,0x10ba011b,0x10d7808e,0x309880b3,0x30f50126,0x10a801b4,0x10c58021}, + [16]uint32{0x3f800000,0x3f8036c0,0x3f901840,0x3f902e80,0x3f800900,0x3f803fc0,0x3f901140,0x3f902780,0x3f984540,0x3f987380,0x3f885d00,0x3f886bc0,0x3f984c40,0x3f987a80,0x3f885400,0x3f8862c0}, + uint32(0xfff80000), + [21]string{"0xde","0x4c","0xc3","0x71","0x96","0x2c","0xa8","0x4a","0x11","0x7e","0x09","0x07","0xd3","0x6c","0x3e","0x22","0x12","0x27","0xd5","0xfb","0x00"} }, + { + /* No.960 delta:962 weight:1181 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x823e01ff,0x925c2d85,0x10622c7a,0x90c03c02,0x12fe3dfd,0x029c1187,0x80a21078,0x00000d8d,0x823e0c72,0x925c2008,0x106221f7,0x90c0318f,0x12fe3070,0x029c1c0a,0x80a21df5}, + [16]uint32{0x00000000,0x0805895a,0x6018386b,0x681db131,0x00560016,0x0853894c,0x604e387d,0x684bb127,0x00022ce8,0x0807a5b2,0x601a1483,0x681f9dd9,0x00542cfe,0x0851a5a4,0x604c1495,0x68499dcf}, + [16]uint32{0x3f800000,0x3f8402c4,0x3fb00c1c,0x3fb40ed8,0x3f802b00,0x3f8429c4,0x3fb0271c,0x3fb425d8,0x3f800116,0x3f8403d2,0x3fb00d0a,0x3fb40fce,0x3f802a16,0x3f8428d2,0x3fb0260a,0x3fb424ce}, + uint32(0xfff80000), + [21]string{"0x61","0x11","0xd7","0x89","0x88","0x7f","0x4a","0x3e","0xac","0xd5","0xe8","0x18","0x88","0xa7","0xb8","0x27","0xad","0x2b","0x4e","0xba","0x00"} }, + { + /* No.961 delta:1479 weight:1125 */ + 11213, + 87, + 13, + 4, + [16]uint32{0x00000000,0x7ef1fb89,0x0a91c798,0x74603c11,0xc5303c19,0xbbc1c790,0xcfa1fb81,0xb1500008,0x0000a9c9,0x7ef15240,0x0a916e51,0x746095d8,0xc53095d0,0xbbc16e59,0xcfa15248,0xb150a9c1}, + [16]uint32{0x00000000,0x004620b7,0x10320034,0x10742083,0x000a013b,0x004c218c,0x1038010f,0x107e21b8,0x1048007c,0x100e20cb,0x007a0048,0x003c20ff,0x10420147,0x100421f0,0x00700173,0x003621c4}, + [16]uint32{0x3f800000,0x3f802310,0x3f881900,0x3f883a10,0x3f800500,0x3f802610,0x3f881c00,0x3f883f10,0x3f882400,0x3f880710,0x3f803d00,0x3f801e10,0x3f882100,0x3f880210,0x3f803800,0x3f801b10}, + uint32(0xfff80000), + [21]string{"0xca","0x42","0xd2","0x86","0x08","0xd3","0xfc","0x7d","0x3c","0x6a","0x59","0x33","0xae","0x51","0x75","0x8a","0xcd","0x11","0xa6","0x40","0x00"} }, + { + /* No.962 delta:880 weight:1671 */ + 11213, + 42, + 13, + 4, + [16]uint32{0x00000000,0x8e08dc8f,0x37744984,0xb97c950b,0x21403c20,0xaf48e0af,0x163475a4,0x983ca92b,0x0000bbb1,0x8e08673e,0x3774f235,0xb97c2eba,0x21408791,0xaf485b1e,0x1634ce15,0x983c129a}, + [16]uint32{0x00000000,0x022615fa,0x600240f6,0x6224550c,0x40018c01,0x422799fb,0x2003ccf7,0x2225d90d,0x20022804,0x22243dfe,0x400068f2,0x42267d08,0x6003a405,0x6225b1ff,0x0001e4f3,0x0227f109}, + [16]uint32{0x3f800000,0x3f81130a,0x3fb00120,0x3fb1122a,0x3fa000c6,0x3fa113cc,0x3f9001e6,0x3f9112ec,0x3f900114,0x3f91121e,0x3fa00034,0x3fa1133e,0x3fb001d2,0x3fb112d8,0x3f8000f2,0x3f8113f8}, + uint32(0xfff80000), + [21]string{"0x96","0xde","0x53","0x85","0xea","0x53","0xe5","0xd2","0x64","0xfb","0x05","0x44","0x38","0x5f","0x5d","0x2b","0x3f","0xb7","0x03","0x99","0x00"} }, + { + /* No.963 delta:1120 weight:1363 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0x77376ab2,0x0e4e8b2e,0x7979e19c,0x5f403c36,0x28775684,0x510eb718,0x2639ddaa,0x0000c86c,0x7737a2de,0x0e4e4342,0x797929f0,0x5f40f45a,0x28779ee8,0x510e7f74,0x263915c6}, + [16]uint32{0x00000000,0x10c4b09d,0x00716983,0x10b5d91e,0x001e540f,0x10dae492,0x006f3d8c,0x10ab8d11,0x00020607,0x10c6b69a,0x00736f84,0x10b7df19,0x001c5208,0x10d8e295,0x006d3b8b,0x10a98b16}, + [16]uint32{0x3f800000,0x3f886258,0x3f8038b4,0x3f885aec,0x3f800f2a,0x3f886d72,0x3f80379e,0x3f8855c6,0x3f800103,0x3f88635b,0x3f8039b7,0x3f885bef,0x3f800e29,0x3f886c71,0x3f80369d,0x3f8854c5}, + uint32(0xfff80000), + [21]string{"0x12","0x77","0xab","0x09","0xb7","0x3d","0x56","0xb0","0x95","0x43","0x6b","0xf4","0x98","0x8b","0x96","0xae","0x55","0xca","0xf2","0x93","0x00"} }, + { + /* No.964 delta:1539 weight:1665 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x7d52994e,0x10f7783f,0x6da5e171,0x79303c47,0x0462a509,0x69c74478,0x1495dd36,0x0000d21c,0x7d524b52,0x10f7aa23,0x6da5336d,0x7930ee5b,0x04627715,0x69c79664,0x14950f2a}, + [16]uint32{0x00000000,0x483440d6,0x0053119f,0x48675149,0x007e01b8,0x484a416e,0x002d1027,0x481950f1,0x00220014,0x481640c2,0x0071118b,0x4845515d,0x005c01ac,0x4868417a,0x000f1033,0x483b50e5}, + [16]uint32{0x3f800000,0x3fa41a20,0x3f802988,0x3fa433a8,0x3f803f00,0x3fa42520,0x3f801688,0x3fa40ca8,0x3f801100,0x3fa40b20,0x3f803888,0x3fa422a8,0x3f802e00,0x3fa43420,0x3f800788,0x3fa41da8}, + uint32(0xfff80000), + [21]string{"0x2d","0xf0","0xbd","0x5d","0x6c","0x39","0x6c","0xb0","0xcf","0x9a","0x8a","0x8d","0xee","0x8d","0x24","0x7a","0x49","0xf6","0xcd","0xfa","0x00"} }, + { + /* No.965 delta:957 weight:1649 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0xeb14b79a,0xdcae4b55,0x37bafccf,0xf5303c51,0x1e248bcb,0x299e7704,0xc28ac09e,0x000028d2,0xeb149f48,0xdcae6387,0x37bad41d,0xf5301483,0x1e24a319,0x299e5fd6,0xc28ae84c}, + [16]uint32{0x00000000,0x017428fe,0x004bc17c,0x013fe982,0x100e1068,0x117a3896,0x1045d114,0x1131f9ea,0x0003a017,0x017788e9,0x0048616b,0x013c4995,0x100db07f,0x11799881,0x10467103,0x113259fd}, + [16]uint32{0x3f800000,0x3f80ba14,0x3f8025e0,0x3f809ff4,0x3f880708,0x3f88bd1c,0x3f8822e8,0x3f8898fc,0x3f8001d0,0x3f80bbc4,0x3f802430,0x3f809e24,0x3f8806d8,0x3f88bccc,0x3f882338,0x3f88992c}, + uint32(0xfff80000), + [21]string{"0x97","0x63","0x6b","0xac","0x42","0xef","0xde","0x76","0x95","0x50","0x98","0x93","0xa0","0x18","0x57","0x6e","0xdf","0x2e","0xc3","0xd1","0x00"} }, + { + /* No.966 delta:837 weight:881 */ + 11213, + 59, + 13, + 4, + [16]uint32{0x00000000,0x4181301b,0x9b3e09fc,0xdabf39e7,0x84503c6d,0xc5d10c76,0x1f6e3591,0x5eef058a,0x00006d07,0x41815d1c,0x9b3e64fb,0xdabf54e0,0x8450516a,0xc5d16171,0x1f6e5896,0x5eef688d}, + [16]uint32{0x00000000,0x000775f2,0x411944b1,0x411e3143,0x0002446c,0x0005319e,0x411b00dd,0x411c752f,0x704281ca,0x7045f438,0x315bc57b,0x315cb089,0x7040c5a6,0x7047b054,0x31598117,0x315ef4e5}, + [16]uint32{0x3f800000,0x3f8003ba,0x3fa08ca2,0x3fa08f18,0x3f800122,0x3f800298,0x3fa08d80,0x3fa08e3a,0x3fb82140,0x3fb822fa,0x3f98ade2,0x3f98ae58,0x3fb82062,0x3fb823d8,0x3f98acc0,0x3f98af7a}, + uint32(0xfff80000), + [21]string{"0x1a","0x99","0xbe","0x6a","0xe1","0x67","0x72","0x53","0x69","0xe6","0x91","0xbd","0x09","0x6a","0x9c","0x88","0x5b","0xc4","0x75","0x61","0x00"} }, + { + /* No.967 delta:1449 weight:1463 */ + 11213, + 65, + 13, + 4, + [16]uint32{0x00000000,0x374eb8dd,0x89560b74,0xbe18b3a9,0xbf603c7f,0x882e84a2,0x3636370b,0x01788fd6,0x00003e9d,0x374e8640,0x895635e9,0xbe188d34,0xbf6002e2,0x882eba3f,0x36360996,0x0178b14b}, + [16]uint32{0x00000000,0x205d815f,0x0043e06e,0x201e6131,0x0002406a,0x205fc135,0x0041a004,0x201c215b,0x00024019,0x205fc146,0x0041a077,0x201c2128,0x00000073,0x205d812c,0x0043e01d,0x201e6142}, + [16]uint32{0x3f800000,0x3f902ec0,0x3f8021f0,0x3f900f30,0x3f800120,0x3f902fe0,0x3f8020d0,0x3f900e10,0x3f800120,0x3f902fe0,0x3f8020d0,0x3f900e10,0x3f800000,0x3f902ec0,0x3f8021f0,0x3f900f30}, + uint32(0xfff80000), + [21]string{"0x87","0x0c","0xb2","0x9e","0xdc","0x03","0x0d","0x67","0x39","0x70","0x45","0x6b","0xa8","0x37","0x6d","0x4d","0x3c","0x07","0x5d","0x6f","0x00"} }, + { + /* No.968 delta:1109 weight:1487 */ + 11213, + 31, + 13, + 4, + [16]uint32{0x00000000,0x57a9d15f,0xef4a74c4,0xb8e3a59b,0xcaf03c8e,0x9d59edd1,0x25ba484a,0x72139915,0x00005df9,0x57a98ca6,0xef4a293d,0xb8e3f862,0xcaf06177,0x9d59b028,0x25ba15b3,0x7213c4ec}, + [16]uint32{0x00000000,0x00781212,0x00464e0e,0x003e5c1c,0x00044a1a,0x007c5808,0x00420414,0x003a1606,0x3f6042a3,0x3f1850b1,0x3f260cad,0x3f5e1ebf,0x3f6408b9,0x3f1c1aab,0x3f2246b7,0x3f5a54a5}, + [16]uint32{0x3f800000,0x3f803c09,0x3f802327,0x3f801f2e,0x3f800225,0x3f803e2c,0x3f802102,0x3f801d0b,0x3f9fb021,0x3f9f8c28,0x3f9f9306,0x3f9faf0f,0x3f9fb204,0x3f9f8e0d,0x3f9f9123,0x3f9fad2a}, + uint32(0xfff80000), + [21]string{"0x3a","0xb2","0x32","0xbb","0xfe","0xf7","0x77","0xd5","0x68","0xf3","0x62","0x3d","0x57","0x36","0x20","0x51","0x2d","0xe5","0x70","0x47","0x00"} }, + { + /* No.969 delta:887 weight:1615 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0xf43cab70,0xd58f3045,0x21b39b35,0x73403c9a,0x877c97ea,0xa6cf0cdf,0x52f3a7af,0x00008ec2,0xf43c25b2,0xd58fbe87,0x21b315f7,0x7340b258,0x877c1928,0xa6cf821d,0x52f3296d}, + [16]uint32{0x00000000,0x402c4092,0x006d57bc,0x4041172e,0x0010c60a,0x403c8698,0x007d91b6,0x4051d124,0x020141cb,0x422d0159,0x026c1677,0x424056e5,0x021187c1,0x423dc753,0x027cd07d,0x425090ef}, + [16]uint32{0x3f800000,0x3fa01620,0x3f8036ab,0x3fa0208b,0x3f800863,0x3fa01e43,0x3f803ec8,0x3fa028e8,0x3f8100a0,0x3fa11680,0x3f81360b,0x3fa1202b,0x3f8108c3,0x3fa11ee3,0x3f813e68,0x3fa12848}, + uint32(0xfff80000), + [21]string{"0x96","0xc8","0xaa","0xf4","0x82","0xc6","0xf9","0xbc","0xfd","0x82","0x6b","0x79","0xbe","0x32","0xb9","0x0c","0xe8","0x45","0xbe","0x78","0x00"} }, + { + /* No.970 delta:1059 weight:1539 */ + 11213, + 27, + 13, + 4, + [16]uint32{0x00000000,0x6571b6e5,0xefc43754,0x8ab581b1,0x2b203ca8,0x4e518a4d,0xc4e40bfc,0xa195bd19,0x00001fa9,0x6571a94c,0xefc428fd,0x8ab59e18,0x2b202301,0x4e5195e4,0xc4e41455,0xa195a2b0}, + [16]uint32{0x00000000,0x010300be,0x40800b09,0x41830bb7,0x7080c015,0x7183c0ab,0x3000cb1c,0x3103cba2,0x90000387,0x91030339,0xd080088e,0xd1830830,0xe080c392,0xe183c32c,0xa000c89b,0xa103c825}, + [16]uint32{0x3f800000,0x3f808180,0x3fa04005,0x3fa0c185,0x3fb84060,0x3fb8c1e0,0x3f980065,0x3f9881e5,0x3fc80001,0x3fc88181,0x3fe84004,0x3fe8c184,0x3ff04061,0x3ff0c1e1,0x3fd00064,0x3fd081e4}, + uint32(0xfff80000), + [21]string{"0x54","0x40","0x2c","0xe4","0x8e","0x0d","0x36","0x5e","0xdc","0xe7","0x18","0xcd","0xbf","0xc2","0x39","0x54","0xc0","0xc3","0x15","0x70","0x00"} }, + { + /* No.971 delta:851 weight:1597 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x8800f040,0x0be6faea,0x83e60aaa,0x00e03cb7,0x88e0ccf7,0x0b06c65d,0x8306361d,0x00007105,0x88008145,0x0be68bef,0x83e67baf,0x00e04db2,0x88e0bdf2,0x0b06b758,0x83064718}, + [16]uint32{0x00000000,0x507d197a,0x0003280c,0x507e3176,0x0053300f,0x502e2975,0x00501803,0x502d0179,0x10007013,0x407d6969,0x1003581f,0x407e4165,0x1053401c,0x402e5966,0x10506810,0x402d716a}, + [16]uint32{0x3f800000,0x3fa83e8c,0x3f800194,0x3fa83f18,0x3f802998,0x3fa81714,0x3f80280c,0x3fa81680,0x3f880038,0x3fa03eb4,0x3f8801ac,0x3fa03f20,0x3f8829a0,0x3fa0172c,0x3f882834,0x3fa016b8}, + uint32(0xfff80000), + [21]string{"0xa3","0x55","0x1b","0x41","0x34","0xc6","0xcd","0xb7","0xd7","0x9e","0x95","0xd2","0xf2","0xdc","0xd4","0xee","0x99","0x5e","0x4a","0x2f","0x00"} }, + { + /* No.972 delta:1719 weight:1453 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0x03e1bd8f,0xcb9e2ef1,0xc87f937e,0x46303cc0,0x45d1814f,0x8dae1231,0x8e4fafbe,0x0000516d,0x03e1ece2,0xcb9e7f9c,0xc87fc213,0x46306dad,0x45d1d022,0x8dae435c,0x8e4ffed3}, + [16]uint32{0x00000000,0x006c80ba,0x001000c7,0x007c807d,0x00020036,0x006e808c,0x001200f1,0x007e804b,0x2400001e,0x246c80a4,0x241000d9,0x247c8063,0x24020028,0x246e8092,0x241200ef,0x247e8055}, + [16]uint32{0x3f800000,0x3f803640,0x3f800800,0x3f803e40,0x3f800100,0x3f803740,0x3f800900,0x3f803f40,0x3f920000,0x3f923640,0x3f920800,0x3f923e40,0x3f920100,0x3f923740,0x3f920900,0x3f923f40}, + uint32(0xfff80000), + [21]string{"0x4f","0xcf","0x7a","0x57","0xd6","0xb7","0x5b","0x2c","0xef","0x78","0x72","0x23","0x47","0x2c","0xa1","0xd1","0x7f","0x2a","0xec","0x6c","0x00"} }, + { + /* No.973 delta:1474 weight:1681 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0x306cafe8,0xade74fdc,0x9d8be034,0xd0603cd5,0xe00c933d,0x7d877309,0x4debdce1,0x0000765d,0x306cd9b5,0xade73981,0x9d8b9669,0xd0604a88,0xe00ce560,0x7d870554,0x4debaabc}, + [16]uint32{0x00000000,0x1070b952,0x500f2c0c,0x407f955e,0x40022419,0x50729d4b,0x100d0815,0x007db147,0x00020803,0x1072b151,0x500d240f,0x407d9d5d,0x40002c1a,0x50709548,0x100f0016,0x007fb944}, + [16]uint32{0x3f800000,0x3f88385c,0x3fa80796,0x3fa03fca,0x3fa00112,0x3fa8394e,0x3f880684,0x3f803ed8,0x3f800104,0x3f883958,0x3fa80692,0x3fa03ece,0x3fa00016,0x3fa8384a,0x3f880780,0x3f803fdc}, + uint32(0xfff80000), + [21]string{"0x7f","0x46","0x86","0x32","0x93","0x96","0xf0","0x4e","0xd5","0xc4","0x89","0x88","0x70","0x99","0xce","0xdd","0x87","0xe5","0xf9","0x54","0x00"} }, + { + /* No.974 delta:1233 weight:1681 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x94442f37,0xe8387743,0x7c7c5874,0x25b03ce0,0xb1f413d7,0xcd884ba3,0x59cc6494,0x00001976,0x94443641,0xe8386e35,0x7c7c4102,0x25b02596,0xb1f40aa1,0xcd8852d5,0x59cc7de2}, + [16]uint32{0x00000000,0x10020172,0x6011448d,0x701345ff,0x00472011,0x10452163,0x6056649c,0x705465ee,0x4015020c,0x5017037e,0x20044681,0x300647f3,0x4052221d,0x5050236f,0x20436690,0x304167e2}, + [16]uint32{0x3f800000,0x3f880100,0x3fb008a2,0x3fb809a2,0x3f802390,0x3f882290,0x3fb02b32,0x3fb82a32,0x3fa00a81,0x3fa80b81,0x3f900223,0x3f980323,0x3fa02911,0x3fa82811,0x3f9021b3,0x3f9820b3}, + uint32(0xfff80000), + [21]string{"0xb9","0x83","0xa5","0x9e","0xf4","0x9d","0x91","0x78","0xe5","0xda","0x65","0xc5","0xef","0xeb","0x86","0x2d","0x97","0xe2","0x83","0xdc","0x00"} }, + { + /* No.975 delta:761 weight:1603 */ + 11213, + 61, + 13, + 4, + [16]uint32{0x00000000,0x3b4f9cba,0x8d675d9d,0xb628c127,0xdb303cf1,0xe07fa04b,0x5657616c,0x6d18fdd6,0x00007e3f,0x3b4fe285,0x8d6723a2,0xb628bf18,0xdb3042ce,0xe07fde74,0x56571f53,0x6d1883e9}, + [16]uint32{0x00000000,0x40a6185e,0x4004660f,0x00a27e51,0x3042801b,0x70e49845,0x7046e614,0x30e0fe4a,0x0002c068,0x40a4d836,0x4006a667,0x00a0be39,0x30404073,0x70e6582d,0x7044267c,0x30e23e22}, + [16]uint32{0x3f800000,0x3fa0530c,0x3fa00233,0x3f80513f,0x3f982140,0x3fb8724c,0x3fb82373,0x3f98707f,0x3f800160,0x3fa0526c,0x3fa00353,0x3f80505f,0x3f982020,0x3fb8732c,0x3fb82213,0x3f98711f}, + uint32(0xfff80000), + [21]string{"0x6e","0x07","0x0d","0xd1","0x7b","0xf1","0xea","0x65","0xa5","0x15","0xff","0x2d","0x12","0x1b","0x9e","0x7e","0xdf","0x47","0x6c","0x65","0x00"} }, + { + /* No.976 delta:1015 weight:1371 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xcf601c93,0x909e446d,0x5ffe58fe,0xb3403d00,0x7c202193,0x23de796d,0xecbe65fe,0x0000642b,0xcf6078b8,0x909e2046,0x5ffe3cd5,0xb340592b,0x7c2045b8,0x23de1d46,0xecbe01d5}, + [16]uint32{0x00000000,0x1802833a,0x20031037,0x3801930d,0x0080912c,0x18821216,0x2083811b,0x38810221,0x60044152,0x7806c268,0x40075165,0x5805d25f,0x6084d07e,0x78865344,0x4087c049,0x58854373}, + [16]uint32{0x3f800000,0x3f8c0141,0x3f900188,0x3f9c00c9,0x3f804048,0x3f8c4109,0x3f9041c0,0x3f9c4081,0x3fb00220,0x3fbc0361,0x3fa003a8,0x3fac02e9,0x3fb04268,0x3fbc4329,0x3fa043e0,0x3fac42a1}, + uint32(0xfff80000), + [21]string{"0x23","0xd9","0x56","0x98","0xd4","0xd8","0x78","0x06","0x14","0xdf","0x48","0xf6","0x02","0x67","0xe6","0x90","0x5f","0x78","0x93","0x2a","0x00"} }, + { + /* No.977 delta:1037 weight:1371 */ + 11213, + 33, + 13, + 4, + [16]uint32{0x00000000,0xf0d58dae,0xf04fb78c,0x009a3a22,0xe6003d17,0x16d5b0b9,0x164f8a9b,0xe69a0735,0x00009310,0xf0d51ebe,0xf04f249c,0x009aa932,0xe600ae07,0x16d523a9,0x164f198b,0xe69a9425}, + [16]uint32{0x00000000,0x081229fa,0xa06e31ec,0xa87c1816,0x20022a7f,0x28100385,0x806c1b93,0x887e3269,0x0002e81b,0x0810c1e1,0xa06cd9f7,0xa87ef00d,0x2000c264,0x2812eb9e,0x806ef388,0x887cda72}, + [16]uint32{0x3f800000,0x3f840914,0x3fd03718,0x3fd43e0c,0x3f900115,0x3f940801,0x3fc0360d,0x3fc43f19,0x3f800174,0x3f840860,0x3fd0366c,0x3fd43f78,0x3f900061,0x3f940975,0x3fc03779,0x3fc43e6d}, + uint32(0xfff80000), + [21]string{"0x75","0x00","0x5d","0xc8","0xc9","0x7e","0x25","0x74","0xa3","0x2d","0x79","0xe6","0x5e","0x58","0xfd","0x98","0x29","0xb1","0xf2","0x72","0x00"} }, + { + /* No.978 delta:840 weight:1675 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xf880e01d,0x562b0c44,0xaeabec59,0x80103d25,0x7890dd38,0xd63b3161,0x2ebbd17c,0x00002fba,0xf880cfa7,0x562b23fe,0xaeabc3e3,0x8010129f,0x7890f282,0xd63b1edb,0x2ebbfec6}, + [16]uint32{0x00000000,0x2074199f,0x400308d1,0x6077114e,0x4000f085,0x6074e91a,0x0003f854,0x2077e1cb,0x0000198c,0x20740013,0x4003115d,0x607708c2,0x4000e909,0x6074f096,0x0003e1d8,0x2077f847}, + [16]uint32{0x3f800000,0x3f903a0c,0x3fa00184,0x3fb03b88,0x3fa00078,0x3fb03a74,0x3f8001fc,0x3f903bf0,0x3f80000c,0x3f903a00,0x3fa00188,0x3fb03b84,0x3fa00074,0x3fb03a78,0x3f8001f0,0x3f903bfc}, + uint32(0xfff80000), + [21]string{"0x39","0xe6","0x16","0xed","0x3c","0x54","0x79","0xcf","0xa5","0x66","0xf2","0xc0","0x54","0x55","0x13","0xb5","0xb9","0xe7","0x3a","0xe2","0x00"} }, + { + /* No.979 delta:634 weight:1577 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0x4c83783a,0x955526c4,0xd9d65efe,0xca403d37,0x86c3450d,0x5f151bf3,0x139663c9,0x00002cd1,0x4c8354eb,0x95550a15,0xd9d6722f,0xca4011e6,0x86c369dc,0x5f153722,0x13964f18}, + [16]uint32{0x00000000,0x007d007d,0x4001fa13,0x407cfa6e,0x10010419,0x107c0464,0x5000fe0a,0x507dfe77,0x900c11b6,0x907111cb,0xd00deba5,0xd070ebd8,0x800d15af,0x807015d2,0xc00cefbc,0xc071efc1}, + [16]uint32{0x3f800000,0x3f803e80,0x3fa000fd,0x3fa03e7d,0x3f880082,0x3f883e02,0x3fa8007f,0x3fa83eff,0x3fc80608,0x3fc83888,0x3fe806f5,0x3fe83875,0x3fc0068a,0x3fc0380a,0x3fe00677,0x3fe038f7}, + uint32(0xfff80000), + [21]string{"0xb1","0x74","0xe8","0x25","0x8d","0xb3","0x12","0x64","0xd4","0x84","0xdb","0x2a","0x1c","0xcb","0x24","0xa8","0xf3","0x75","0xc1","0x85","0x00"} }, + { + /* No.980 delta:1683 weight:1733 */ + 11213, + 43, + 13, + 4, + [16]uint32{0x00000000,0xbe846eb9,0xeb5f256c,0x55db4bd5,0x80703d40,0x3ef453f9,0x6b2f182c,0xd5ab7695,0x0000ce07,0xbe84a0be,0xeb5feb6b,0x55db85d2,0x8070f347,0x3ef49dfe,0x6b2fd62b,0xd5abb892}, + [16]uint32{0x00000000,0x40640196,0x005201a7,0x40360031,0x003c016d,0x405800fb,0x006e00ca,0x400a015c,0x000280e5,0x40668173,0x00508142,0x403480d4,0x003e8188,0x405a801e,0x006c802f,0x400881b9}, + [16]uint32{0x3f800000,0x3fa03200,0x3f802900,0x3fa01b00,0x3f801e00,0x3fa02c00,0x3f803700,0x3fa00500,0x3f800140,0x3fa03340,0x3f802840,0x3fa01a40,0x3f801f40,0x3fa02d40,0x3f803640,0x3fa00440}, + uint32(0xfff80000), + [21]string{"0x4f","0xc7","0xc4","0x88","0x83","0xbc","0x79","0x9c","0x8c","0x16","0xc0","0x6b","0x2e","0x0c","0xff","0x3d","0x26","0x03","0x35","0x3f","0x00"} }, + { + /* No.981 delta:885 weight:1711 */ + 11213, + 49, + 13, + 4, + [16]uint32{0x00000000,0xa7b8a085,0x1ce8a673,0xbb5006f6,0x6a003d5d,0xcdb89dd8,0x76e89b2e,0xd1503bab,0x0000e8ba,0xa7b8483f,0x1ce84ec9,0xbb50ee4c,0x6a00d5e7,0xcdb87562,0x76e87394,0xd150d311}, + [16]uint32{0x00000000,0x44038015,0x3002c1ce,0x740141db,0x10000899,0x5403888c,0x2002c957,0x64014942,0x400010d4,0x040390c1,0x7002d11a,0x3401510f,0x5000184d,0x14039858,0x6002d983,0x24015996}, + [16]uint32{0x3f800000,0x3fa201c0,0x3f980160,0x3fba00a0,0x3f880004,0x3faa01c4,0x3f900164,0x3fb200a4,0x3fa00008,0x3f8201c8,0x3fb80168,0x3f9a00a8,0x3fa8000c,0x3f8a01cc,0x3fb0016c,0x3f9200ac}, + uint32(0xfff80000), + [21]string{"0xb7","0xf2","0x77","0x08","0x19","0x24","0xde","0x9b","0x4c","0xa4","0x27","0x55","0xcc","0xbd","0xcf","0x36","0x60","0x24","0x6e","0xf9","0x00"} }, + { + /* No.982 delta:1437 weight:1649 */ + 11213, + 19, + 13, + 4, + [16]uint32{0x00000000,0x5b082372,0xecfaa110,0xb7f28262,0xb9603d6d,0xe2681e1f,0x559a9c7d,0x0e92bf0f,0x00000dce,0x5b082ebc,0xecfaacde,0xb7f28fac,0xb96030a3,0xe26813d1,0x559a91b3,0x0e92b2c1}, + [16]uint32{0x00000000,0x0465d0fa,0x205a0851,0x243fd8ab,0x0002618c,0x0467b176,0x205869dd,0x243db927,0x2034759e,0x2451a564,0x006e7dcf,0x040bad35,0x20361412,0x2453c4e8,0x006c1c43,0x0409ccb9}, + [16]uint32{0x3f800000,0x3f8232e8,0x3f902d04,0x3f921fec,0x3f800130,0x3f8233d8,0x3f902c34,0x3f921edc,0x3f901a3a,0x3f9228d2,0x3f80373e,0x3f8205d6,0x3f901b0a,0x3f9229e2,0x3f80360e,0x3f8204e6}, + uint32(0xfff80000), + [21]string{"0x50","0xd4","0x64","0xa2","0x67","0xe0","0xb9","0x8f","0x48","0x29","0x98","0x90","0x49","0x90","0x8f","0xd0","0x48","0x74","0x94","0xda","0x00"} }, + { + /* No.983 delta:1657 weight:1581 */ + 11213, + 13, + 13, + 4, + [16]uint32{0x00000000,0xa1cd030d,0xd768efcf,0x76a5ecc2,0x12e03d7b,0xb32d3e76,0xc588d2b4,0x6445d1b9,0x00004b8e,0xa1cd4883,0xd768a441,0x76a5a74c,0x12e076f5,0xb32d75f8,0xc588993a,0x64459a37}, + [16]uint32{0x00000000,0x08ae891a,0x4702c06d,0x4fac4977,0x406c91fe,0x48c218e4,0x076e5193,0x0fc0d889,0x04092014,0x0ca7a90e,0x430be079,0x4ba56963,0x4465b1ea,0x4ccb38f0,0x03677187,0x0bc9f89d}, + [16]uint32{0x3f800000,0x3f845744,0x3fa38160,0x3fa7d624,0x3fa03648,0x3fa4610c,0x3f83b728,0x3f87e06c,0x3f820490,0x3f8653d4,0x3fa185f0,0x3fa5d2b4,0x3fa232d8,0x3fa6659c,0x3f81b3b8,0x3f85e4fc}, + uint32(0xfff80000), + [21]string{"0x4e","0x2e","0x5e","0x22","0x88","0x4e","0x89","0x85","0xdb","0xc7","0x4b","0xfa","0xfa","0x2f","0xe9","0xb9","0xa0","0x87","0x0b","0xe0","0x00"} }, + { + /* No.984 delta:943 weight:1061 */ + 11213, + 50, + 13, + 4, + [16]uint32{0x00000000,0x56d379be,0x60afff41,0x367c86ff,0x7af03d86,0x2c234438,0x1a5fc2c7,0x4c8cbb79,0x00004080,0x56d3393e,0x60afbfc1,0x367cc67f,0x7af07d06,0x2c2304b8,0x1a5f8247,0x4c8cfbf9}, + [16]uint32{0x00000000,0x004ec147,0x1003416b,0x104d802c,0x0400c05a,0x044e011d,0x14038131,0x144d4076,0x000210b3,0x004cd1f4,0x100151d8,0x104f909f,0x0402d0e9,0x044c11ae,0x14019182,0x144f50c5}, + [16]uint32{0x3f800000,0x3f802760,0x3f8801a0,0x3f8826c0,0x3f820060,0x3f822700,0x3f8a01c0,0x3f8a26a0,0x3f800108,0x3f802668,0x3f8800a8,0x3f8827c8,0x3f820168,0x3f822608,0x3f8a00c8,0x3f8a27a8}, + uint32(0xfff80000), + [21]string{"0xbb","0xcc","0x78","0x68","0xdb","0x33","0xd1","0x39","0x94","0xaf","0xa5","0x75","0x48","0xe4","0x9f","0x4d","0x6d","0x5d","0xea","0x77","0x00"} }, + { + /* No.985 delta:1309 weight:1651 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x13a03e56,0xb84511b0,0xabe52fe6,0x53203d90,0x408003c6,0xeb652c20,0xf8c51276,0x0000f467,0x13a0ca31,0xb845e5d7,0xabe5db81,0x5320c9f7,0x4080f7a1,0xeb65d847,0xf8c5e611}, + [16]uint32{0x00000000,0x004c209a,0x0038e0f9,0x0074c063,0x49c71152,0x498b31c8,0x49fff1ab,0x49b3d131,0x001a410d,0x00566197,0x0022a1f4,0x006e816e,0x49dd505f,0x499170c5,0x49e5b0a6,0x49a9903c}, + [16]uint32{0x3f800000,0x3f802610,0x3f801c70,0x3f803a60,0x3fa4e388,0x3fa4c598,0x3fa4fff8,0x3fa4d9e8,0x3f800d20,0x3f802b30,0x3f801150,0x3f803740,0x3fa4eea8,0x3fa4c8b8,0x3fa4f2d8,0x3fa4d4c8}, + uint32(0xfff80000), + [21]string{"0xac","0xb5","0x11","0x49","0xd3","0x22","0xd4","0xf1","0xf5","0xb1","0xa3","0x83","0xff","0xaa","0x1a","0xa5","0xd1","0x5d","0x58","0xe2","0x00"} }, + { + /* No.986 delta:903 weight:1253 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0xda52c69e,0x60703bb7,0xba22fd29,0x23b03dad,0xf9e2fb33,0x43c0061a,0x9992c084,0x00005959,0xda529fc7,0x607062ee,0xba22a470,0x23b064f4,0xf9e2a26a,0x43c05f43,0x999299dd}, + [16]uint32{0x00000000,0x100c05d2,0x0002615b,0x100e6489,0x40000036,0x500c05e4,0x4002616d,0x500e64bf,0x20019173,0x300d94a1,0x2003f028,0x300ff5fa,0x60019145,0x700d9497,0x6003f01e,0x700ff5cc}, + [16]uint32{0x3f800000,0x3f880602,0x3f800130,0x3f880732,0x3fa00000,0x3fa80602,0x3fa00130,0x3fa80732,0x3f9000c8,0x3f9806ca,0x3f9001f8,0x3f9807fa,0x3fb000c8,0x3fb806ca,0x3fb001f8,0x3fb807fa}, + uint32(0xfff80000), + [21]string{"0x38","0xd5","0x50","0xea","0xe2","0x6f","0x1d","0x37","0x12","0xfa","0x61","0xde","0xc0","0xa6","0x6e","0x98","0xde","0x20","0xe6","0xdc","0x00"} }, + { + /* No.987 delta:1064 weight:1451 */ + 11213, + 28, + 13, + 4, + [16]uint32{0x00000000,0x12a26653,0x713659fa,0x63943fa9,0x12103dbf,0x00b25bec,0x63266445,0x71840216,0x0000f386,0x12a295d5,0x7136aa7c,0x6394cc2f,0x1210ce39,0x00b2a86a,0x632697c3,0x7184f190}, + [16]uint32{0x00000000,0x405c5094,0x600428b1,0x20587825,0x725421b9,0x3208712d,0x12500908,0x520c599c,0x4000206f,0x005c70fb,0x200408de,0x6058584a,0x325401d6,0x72085142,0x52502967,0x120c79f3}, + [16]uint32{0x3f800000,0x3fa02e28,0x3fb00214,0x3f902c3c,0x3fb92a10,0x3f990438,0x3f892804,0x3fa9062c,0x3fa00010,0x3f802e38,0x3f900204,0x3fb02c2c,0x3f992a00,0x3fb90428,0x3fa92814,0x3f89063c}, + uint32(0xfff80000), + [21]string{"0x96","0x6f","0xdc","0x35","0xbf","0x01","0x2b","0xaf","0x1f","0xc8","0x81","0x34","0x3b","0x8d","0x10","0xc4","0x1a","0xe9","0x1c","0x05","0x00"} }, + { + /* No.988 delta:917 weight:1565 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xfa553dde,0x803150b8,0x7a646d66,0xe7803dc0,0x1dd5001e,0x67b16d78,0x9de450a6,0x0000ac65,0xfa5591bb,0x8031fcdd,0x7a64c103,0xe78091a5,0x1dd5ac7b,0x67b1c11d,0x9de4fcc3}, + [16]uint32{0x00000000,0x0074b055,0x000a1637,0x007ea662,0x1003461e,0x1077f64b,0x10095029,0x107de07c,0x00020813,0x0076b846,0x00081e24,0x007cae71,0x10014e0d,0x1075fe58,0x100b583a,0x107fe86f}, + [16]uint32{0x3f800000,0x3f803a58,0x3f80050b,0x3f803f53,0x3f8801a3,0x3f883bfb,0x3f8804a8,0x3f883ef0,0x3f800104,0x3f803b5c,0x3f80040f,0x3f803e57,0x3f8800a7,0x3f883aff,0x3f8805ac,0x3f883ff4}, + uint32(0xfff80000), + [21]string{"0x8b","0x47","0x1b","0x8d","0x2e","0x72","0x41","0x0a","0xe9","0x54","0x9c","0xfa","0x02","0xc3","0xf4","0x99","0x4c","0x00","0xcb","0x30","0x00"} }, + { + /* No.989 delta:866 weight:1649 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x0c0d9229,0x5db5a2ec,0x51b830c5,0xf2a03dd9,0xfeadaff0,0xaf159f35,0xa3180d1c,0x00004772,0x0c0dd55b,0x5db5e59e,0x51b877b7,0xf2a07aab,0xfeade882,0xaf15d847,0xa3184a6e}, + [16]uint32{0x00000000,0x00619096,0xa00988f9,0xa068186f,0x0000b011,0x00612087,0xa00938e8,0xa068a87e,0x0020100b,0x0041809d,0xa02998f2,0xa0480864,0x0020a01a,0x0041308c,0xa02928e3,0xa048b875}, + [16]uint32{0x3f800000,0x3f8030c8,0x3fd004c4,0x3fd0340c,0x3f800058,0x3f803090,0x3fd0049c,0x3fd03454,0x3f801008,0x3f8020c0,0x3fd014cc,0x3fd02404,0x3f801050,0x3f802098,0x3fd01494,0x3fd0245c}, + uint32(0xfff80000), + [21]string{"0xf3","0x7f","0xa0","0x60","0x37","0x61","0x2e","0x49","0x4c","0x37","0x46","0x4b","0x42","0x38","0xa6","0x56","0xac","0xdd","0x14","0x02","0x00"} }, + { + /* No.990 delta:2165 weight:1349 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xd6b9415c,0x5d3a2870,0x8b83692c,0x19103de3,0xcfa97cbf,0x442a1593,0x929354cf,0x0000dcdc,0xd6b99d80,0x5d3af4ac,0x8b83b5f0,0x1910e13f,0xcfa9a063,0x442ac94f,0x92938813}, + [16]uint32{0x00000000,0x1663371e,0x0882017b,0x1ee13665,0x018a208f,0x17e91791,0x090821f4,0x1f6b16ea,0x1481b058,0x02e28746,0x1c03b123,0x0a60863d,0x150b90d7,0x0368a7c9,0x1d8991ac,0x0beaa6b2}, + [16]uint32{0x3f800000,0x3f8b319b,0x3f844100,0x3f8f709b,0x3f80c510,0x3f8bf48b,0x3f848410,0x3f8fb58b,0x3f8a40d8,0x3f817143,0x3f8e01d8,0x3f853043,0x3f8a85c8,0x3f81b453,0x3f8ec4c8,0x3f85f553}, + uint32(0xfff80000), + [21]string{"0xf2","0xab","0xde","0x57","0xa6","0xe6","0x5c","0xcb","0x2e","0x36","0xa3","0x28","0x15","0x52","0xc2","0xe4","0x85","0xe2","0x6c","0xcc","0x00"} }, + { + /* No.991 delta:1835 weight:1527 */ + 11213, + 11, + 13, + 4, + [16]uint32{0x00000000,0x57c58a32,0x84bf9633,0xd37a1c01,0x26003dff,0x71c5b7cd,0xa2bfabcc,0xf57a21fe,0x00008714,0x57c50d26,0x84bf1127,0xd37a9b15,0x2600baeb,0x71c530d9,0xa2bf2cd8,0xf57aa6ea}, + [16]uint32{0x00000000,0x0946197e,0x0c2400ef,0x05621991,0x018c238a,0x08ca3af4,0x0da82365,0x04ee3a1b,0x20029009,0x29448977,0x2c2690e6,0x25608998,0x218eb383,0x28c8aafd,0x2daab36c,0x24ecaa12}, + [16]uint32{0x3f800000,0x3f84a30c,0x3f861200,0x3f82b10c,0x3f80c611,0x3f84651d,0x3f86d411,0x3f82771d,0x3f900148,0x3f94a244,0x3f961348,0x3f92b044,0x3f90c759,0x3f946455,0x3f96d559,0x3f927655}, + uint32(0xfff80000), + [21]string{"0x50","0x42","0x69","0x0b","0x7b","0xb2","0xe3","0x3c","0xf2","0x9e","0x8c","0x10","0x4c","0x6b","0xa0","0xdb","0xa3","0x43","0xc7","0x5d","0x00"} }, + { + /* No.992 delta:1469 weight:1613 */ + 11213, + 16, + 13, + 4, + [16]uint32{0x00000000,0xe0455c89,0xe2f3c7fe,0x02b69b77,0x27d03e0d,0xc7956284,0xc523f9f3,0x2566a57a,0x00007033,0xe0452cba,0xe2f3b7cd,0x02b6eb44,0x27d04e3e,0xc79512b7,0xc52389c0,0x2566d549}, + [16]uint32{0x00000000,0x205ee05a,0x006a609c,0x203480c6,0x4048b803,0x60165859,0x4022d89f,0x607c38c5,0x30208010,0x107e604a,0x304ae08c,0x101400d6,0x70683813,0x5036d849,0x7002588f,0x505cb8d5}, + [16]uint32{0x3f800000,0x3f902f70,0x3f803530,0x3f901a40,0x3fa0245c,0x3fb00b2c,0x3fa0116c,0x3fb03e1c,0x3f981040,0x3f883f30,0x3f982570,0x3f880a00,0x3fb8341c,0x3fa81b6c,0x3fb8012c,0x3fa82e5c}, + uint32(0xfff80000), + [21]string{"0x59","0x9d","0xe1","0x1c","0xa7","0x21","0x81","0xe1","0xe8","0x12","0x16","0x3e","0x4f","0xaa","0x18","0x27","0x1d","0xa6","0x7b","0x75","0x00"} }, + { + /* No.993 delta:2176 weight:1275 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0x402e4ffd,0xfac4555b,0xbaea1aa6,0x70303e1b,0x301e71e6,0x8af46b40,0xcada24bd,0x000055ca,0x402e1a37,0xfac40091,0xbaea4f6c,0x70306bd1,0x301e242c,0x8af43e8a,0xcada7177}, + [16]uint32{0x00000000,0x0f12905e,0x4182c14b,0x4e905115,0x2900bde2,0x26122dbc,0x68827ca9,0x6790ecf7,0x00809048,0x0f920016,0x41025103,0x4e10c15d,0x29802daa,0x2692bdf4,0x6802ece1,0x67107cbf}, + [16]uint32{0x3f800000,0x3f878948,0x3fa0c160,0x3fa74828,0x3f94805e,0x3f930916,0x3fb4413e,0x3fb3c876,0x3f804048,0x3f87c900,0x3fa08128,0x3fa70860,0x3f94c016,0x3f93495e,0x3fb40176,0x3fb3883e}, + uint32(0xfff80000), + [21]string{"0xda","0xc3","0xc4","0x50","0x70","0x11","0xfb","0xc9","0x32","0xd0","0xdb","0x1f","0xba","0x1b","0x51","0xe7","0xa0","0xb8","0x42","0xf2","0x00"} }, + { + /* No.994 delta:2034 weight:1291 */ + 11213, + 9, + 13, + 4, + [16]uint32{0x00000000,0x2d4ba9e4,0x99e7ca34,0xb4ac63d0,0xe6603e2f,0xcb2b97cb,0x7f87f41b,0x52cc5dff,0x0000096c,0x2d4ba088,0x99e7c358,0xb4ac6abc,0xe6603743,0xcb2b9ea7,0x7f87fd77,0x52cc5493}, + [16]uint32{0x00000000,0x48a2707e,0xa18108ad,0xe92378d3,0x42152058,0x0ab75026,0xe39428f5,0xab36588b,0x1d34200c,0x55965072,0xbcb528a1,0xf41758df,0x5f210054,0x1783702a,0xfea008f9,0xb6027887}, + [16]uint32{0x3f800000,0x3fa45138,0x3fd0c084,0x3ff491bc,0x3fa10a90,0x3f855ba8,0x3ff1ca14,0x3fd59b2c,0x3f8e9a10,0x3faacb28,0x3fde5a94,0x3ffa0bac,0x3faf9080,0x3f8bc1b8,0x3fff5004,0x3fdb013c}, + uint32(0xfff80000), + [21]string{"0xee","0xcd","0xab","0xb0","0x16","0xc7","0xf4","0x12","0xd0","0x35","0x84","0x47","0xd5","0x24","0x8a","0x30","0xd8","0x81","0x6e","0x9e","0x00"} }, + { + /* No.995 delta:1441 weight:1543 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x398c3c50,0x486ef548,0x71e2c918,0xb2c03e32,0x8b4c0262,0xfaaecb7a,0xc322f72a,0x0000ccac,0x398cf0fc,0x486e39e4,0x71e205b4,0xb2c0f29e,0x8b4ccece,0xfaae07d6,0xc3223b86}, + [16]uint32{0x00000000,0x003dec9f,0x531d00c3,0x5320ec5c,0x00028405,0x003f689a,0x531f84c6,0x53226859,0x006810eb,0x0055fc74,0x53751028,0x5348fcb7,0x006a94ee,0x00577871,0x5377942d,0x534a78b2}, + [16]uint32{0x3f800000,0x3f801ef6,0x3fa98e80,0x3fa99076,0x3f800142,0x3f801fb4,0x3fa98fc2,0x3fa99134,0x3f803408,0x3f802afe,0x3fa9ba88,0x3fa9a47e,0x3f80354a,0x3f802bbc,0x3fa9bbca,0x3fa9a53c}, + uint32(0xfff80000), + [21]string{"0x52","0xf0","0xd6","0x26","0x25","0xfc","0xba","0xdc","0x2b","0x1c","0xfd","0x52","0xef","0x56","0xa7","0x5e","0x6e","0x6f","0x7f","0x2f","0x00"} }, + { + /* No.996 delta:1224 weight:1541 */ + 11213, + 21, + 13, + 4, + [16]uint32{0x00000000,0x4fc065a2,0x11de5350,0x5e1e36f2,0x80d03e43,0xcf105be1,0x910e6d13,0xdece08b1,0x000031d0,0x4fc05472,0x11de6280,0x5e1e0722,0x80d00f93,0xcf106a31,0x910e5cc3,0xdece3961}, + [16]uint32{0x00000000,0x38637996,0x004ce1fd,0x382f986b,0x0031815a,0x3852f8cc,0x007d60a7,0x381e1931,0x50103d8e,0x68734418,0x505cdc73,0x683fa5e5,0x5021bcd4,0x6842c542,0x506d5d29,0x680e24bf}, + [16]uint32{0x3f800000,0x3f9c31bc,0x3f802670,0x3f9c17cc,0x3f8018c0,0x3f9c297c,0x3f803eb0,0x3f9c0f0c,0x3fa8081e,0x3fb439a2,0x3fa82e6e,0x3fb41fd2,0x3fa810de,0x3fb42162,0x3fa836ae,0x3fb40712}, + uint32(0xfff80000), + [21]string{"0xdc","0x78","0x3d","0xc3","0xe6","0xc3","0x7e","0xd4","0xf2","0x1b","0x10","0xd2","0x29","0x40","0x28","0x8d","0xd5","0xa3","0x08","0x80","0x00"} }, + { + /* No.997 delta:1252 weight:1509 */ + 11213, + 20, + 13, + 4, + [16]uint32{0x00000000,0xbe0f3f8f,0xa45ae090,0x1a55df1f,0xff603e52,0x416f01dd,0x5b3adec2,0xe535e14d,0x0000b887,0xbe0f8708,0xa45a5817,0x1a556798,0xff6086d5,0x416fb95a,0x5b3a6645,0xe53559ca}, + [16]uint32{0x00000000,0x505525da,0x40503e9c,0x10051b46,0x30000405,0x605521df,0x70503a99,0x20051f43,0x4034601d,0x106145c7,0x00645e81,0x50317b5b,0x70346418,0x206141c2,0x30645a84,0x60317f5e}, + [16]uint32{0x3f800000,0x3fa82a92,0x3fa0281f,0x3f88028d,0x3f980002,0x3fb02a90,0x3fb8281d,0x3f90028f,0x3fa01a30,0x3f8830a2,0x3f80322f,0x3fa818bd,0x3fb81a32,0x3f9030a0,0x3f98322d,0x3fb018bf}, + uint32(0xfff80000), + [21]string{"0x4b","0xb4","0xc0","0xcf","0x10","0x10","0xe5","0xbe","0x52","0x97","0x9c","0xfb","0x84","0x77","0xac","0x7d","0xce","0xbf","0x3d","0xe9","0x00"} }, + { + /* No.998 delta:951 weight:1607 */ + 11213, + 63, + 13, + 4, + [16]uint32{0x00000000,0xab26c38a,0x3b2110a4,0x9007d32e,0x1ab03e68,0xb196fde2,0x21912ecc,0x8ab7ed46,0x0000eef0,0xab262d7a,0x3b21fe54,0x90073dde,0x1ab0d098,0xb1961312,0x2191c03c,0x8ab703b6}, + [16]uint32{0x00000000,0x107e11df,0x00022151,0x107c308e,0x0000a087,0x107eb158,0x000281d6,0x107c9009,0x10410014,0x003f11cb,0x10432145,0x003d309a,0x1041a093,0x003fb14c,0x104381c2,0x003d901d}, + [16]uint32{0x3f800000,0x3f883f08,0x3f800110,0x3f883e18,0x3f800050,0x3f883f58,0x3f800140,0x3f883e48,0x3f882080,0x3f801f88,0x3f882190,0x3f801e98,0x3f8820d0,0x3f801fd8,0x3f8821c0,0x3f801ec8}, + uint32(0xfff80000), + [21]string{"0xc2","0x2d","0x49","0xe6","0x56","0x03","0xdb","0xb2","0x23","0x87","0x52","0x0e","0x60","0x23","0x17","0x60","0x05","0x1c","0x6b","0xab","0x00"} }, + { + /* No.999 delta:711 weight:1373 */ + 11213, + 69, + 13, + 4, + [16]uint32{0x00000000,0x37bdff24,0x0ab1eda4,0x3d0c1280,0xdc403e7c,0xebfdc158,0xd6f1d3d8,0xe14c2cfc,0x0000b8d4,0x37bd47f0,0x0ab15570,0x3d0caa54,0xdc4086a8,0xebfd798c,0xd6f16b0c,0xe14c9428}, + [16]uint32{0x00000000,0x2040485b,0x440002fe,0x64404aa5,0x1003009c,0x304348c7,0x54030262,0x74434a39,0x20020014,0x0042484f,0x640202ea,0x44424ab1,0x30010088,0x104148d3,0x74010276,0x54414a2d}, + [16]uint32{0x3f800000,0x3f902024,0x3fa20001,0x3fb22025,0x3f880180,0x3f9821a4,0x3faa0181,0x3fba21a5,0x3f900100,0x3f802124,0x3fb20101,0x3fa22125,0x3f980080,0x3f8820a4,0x3fba0081,0x3faa20a5}, + uint32(0xfff80000), + [21]string{"0x91","0x30","0x74","0xbb","0x12","0x0e","0x01","0x97","0x0f","0xfc","0x3c","0xd1","0x3a","0x5f","0x41","0x9f","0x5a","0xed","0x3a","0x65","0x00"} }, + { + /* No.1000 delta:1182 weight:1397 */ + 11213, + 35, + 13, + 4, + [16]uint32{0x00000000,0xece9e6b0,0x0ee6a1fd,0xe20f474d,0xe2903e83,0x0e79d833,0xec769f7e,0x009f79ce,0x000025fa,0xece9c34a,0x0ee68407,0xe20f62b7,0xe2901b79,0x0e79fdc9,0xec76ba84,0x009f5c34}, + [16]uint32{0x00000000,0x05241196,0x006c013b,0x054810ad,0x000201b3,0x05261025,0x006e0088,0x054a111e,0x0070a01f,0x0554b189,0x001ca124,0x0538b0b2,0x0072a1ac,0x0556b03a,0x001ea097,0x053ab101}, + [16]uint32{0x3f800000,0x3f829208,0x3f803600,0x3f82a408,0x3f800100,0x3f829308,0x3f803700,0x3f82a508,0x3f803850,0x3f82aa58,0x3f800e50,0x3f829c58,0x3f803950,0x3f82ab58,0x3f800f50,0x3f829d58}, + uint32(0xfff80000), + [21]string{"0xcb","0xa4","0x05","0x4c","0xed","0x7d","0xf8","0x46","0x3e","0x6b","0x6c","0xaf","0x66","0x0e","0x5d","0x83","0xed","0x4a","0x0c","0xf8","0x00"} }, + { + /* No.1001 delta:1402 weight:1623 */ + 11213, + 18, + 13, + 4, + [16]uint32{0x00000000,0x65d47cf2,0xbc6fb880,0xd9bbc472,0x39603e98,0x5cb4426a,0x850f8618,0xe0dbfaea,0x00007893,0x65d40461,0xbc6fc013,0xd9bbbce1,0x3960460b,0x5cb43af9,0x850ffe8b,0xe0db8279}, + [16]uint32{0x00000000,0x007c1df6,0x20220055,0x205e1da3,0x4070901a,0x400c8dec,0x6052904f,0x602e8db9,0x20313201,0x204d2ff7,0x00133254,0x006f2fa2,0x6041a21b,0x603dbfed,0x4063a24e,0x401fbfb8}, + [16]uint32{0x3f800000,0x3f803e0e,0x3f901100,0x3f902f0e,0x3fa03848,0x3fa00646,0x3fb02948,0x3fb01746,0x3f901899,0x3f902697,0x3f800999,0x3f803797,0x3fb020d1,0x3fb01edf,0x3fa031d1,0x3fa00fdf}, + uint32(0xfff80000), + [21]string{"0x95","0x61","0x30","0xa8","0xaa","0x5b","0x65","0x91","0xda","0xd3","0x37","0xf0","0xee","0x4c","0xfc","0xac","0xd8","0x66","0xd9","0x23","0x00"} }, + { + /* No.1002 delta:693 weight:1709 */ + 11213, + 77, + 13, + 4, + [16]uint32{0x00000000,0x935cb27b,0x2a0e6ab1,0xb952d8ca,0x84103eab,0x174c8cd0,0xae1e541a,0x3d42e661,0x0000cdf0,0x935c7f8b,0x2a0ea741,0xb952153a,0x8410f35b,0x174c4120,0xae1e99ea,0x3d422b91}, + [16]uint32{0x00000000,0x440304fa,0x5002869d,0x14018267,0x7001a21f,0x3402a6e5,0x20032482,0x64002078,0x200000b6,0x6403044c,0x7002862b,0x340182d1,0x5001a2a9,0x1402a653,0x00032434,0x440020ce}, + [16]uint32{0x3f800000,0x3fa20182,0x3fa80143,0x3f8a00c1,0x3fb800d1,0x3f9a0153,0x3f900192,0x3fb20010,0x3f900000,0x3fb20182,0x3fb80143,0x3f9a00c1,0x3fa800d1,0x3f8a0153,0x3f800192,0x3fa20010}, + uint32(0xfff80000), + [21]string{"0x03","0x1f","0x94","0xbf","0xcb","0x72","0x3c","0xba","0x76","0x33","0xf3","0x7b","0x66","0x5e","0xd4","0x6f","0xf9","0x08","0x33","0xb1","0x00"} }, + { + /* No.1003 delta:1158 weight:1719 */ + 11213, + 25, + 13, + 4, + [16]uint32{0x00000000,0x66de1e00,0x444a40d4,0x22945ed4,0x9e203ebd,0xf8fe20bd,0xda6a7e69,0xbcb46069,0x00001425,0x66de0a25,0x444a54f1,0x22944af1,0x9e202a98,0xf8fe3498,0xda6a6a4c,0xbcb4744c}, + [16]uint32{0x00000000,0x4065799e,0x00740478,0x40117de6,0x1048e0e3,0x502d997d,0x103ce49b,0x50599d05,0x00095137,0x406c28a9,0x007d554f,0x40182cd1,0x1041b1d4,0x5024c84a,0x1035b5ac,0x5050cc32}, + [16]uint32{0x3f800000,0x3fa032bc,0x3f803a02,0x3fa008be,0x3f882470,0x3fa816cc,0x3f881e72,0x3fa82cce,0x3f8004a8,0x3fa03614,0x3f803eaa,0x3fa00c16,0x3f8820d8,0x3fa81264,0x3f881ada,0x3fa82866}, + uint32(0xfff80000), + [21]string{"0x7f","0x65","0x58","0x21","0x4c","0x14","0x8a","0xd2","0xa1","0x21","0x5b","0x13","0xb9","0xfd","0xa5","0xd8","0x80","0x6c","0x86","0x8f","0x00"} }, + { + /* No.1004 delta:977 weight:1537 */ + 11213, + 52, + 13, + 4, + [16]uint32{0x00000000,0xd8123379,0xdf032245,0x0711113c,0xb6203ec2,0x6e320dbb,0x69231c87,0xb1312ffe,0x00006693,0xd81255ea,0xdf0344d6,0x071177af,0xb6205851,0x6e326b28,0x69237a14,0xb131496d}, + [16]uint32{0x00000000,0x0043987f,0x50022d73,0x5041b50c,0x1001c019,0x10425866,0x4003ed6a,0x40407515,0x400010e4,0x4043889b,0x10023d97,0x1041a5e8,0x5001d0fd,0x50424882,0x0003fd8e,0x004065f1}, + [16]uint32{0x3f800000,0x3f8021cc,0x3fa80116,0x3fa820da,0x3f8800e0,0x3f88212c,0x3fa001f6,0x3fa0203a,0x3fa00008,0x3fa021c4,0x3f88011e,0x3f8820d2,0x3fa800e8,0x3fa82124,0x3f8001fe,0x3f802032}, + uint32(0xfff80000), + [21]string{"0xad","0x18","0xd7","0x99","0x00","0x36","0x14","0x49","0x7f","0x75","0x51","0x24","0x51","0x03","0x15","0x5d","0x14","0x52","0x7f","0x31","0x00"} }, + { + /* No.1005 delta:1179 weight:1511 */ + 11213, + 26, + 13, + 4, + [16]uint32{0x00000000,0x4af1f165,0x346107f5,0x7e90f690,0x83c03eda,0xc931cfbf,0xb7a1392f,0xfd50c84a,0x00006419,0x4af1957c,0x346163ec,0x7e909289,0x83c05ac3,0xc931aba6,0xb7a15d36,0xfd50ac53}, + [16]uint32{0x00000000,0x805a19ba,0x00020409,0x80581db3,0x8016900e,0x004c89b4,0x80149407,0x004e8dbd,0x102b1806,0x907101bc,0x10291c0f,0x907305b5,0x903d8808,0x106791b2,0x903f8c01,0x106595bb}, + [16]uint32{0x3f800000,0x3fc02d0c,0x3f800102,0x3fc02c0e,0x3fc00b48,0x3f802644,0x3fc00a4a,0x3f802746,0x3f88158c,0x3fc83880,0x3f88148e,0x3fc83982,0x3fc81ec4,0x3f8833c8,0x3fc81fc6,0x3f8832ca}, + uint32(0xfff80000), + [21]string{"0xe8","0x03","0x45","0xd6","0x70","0xfb","0x98","0x3d","0x59","0xeb","0x1c","0xe9","0xd9","0x0f","0xe7","0xbc","0x10","0x45","0x5a","0x00","0x00"} }, + { + /* No.1006 delta:909 weight:1627 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xdf4ec65d,0x6fd001dd,0xb09ec780,0xd7603eef,0x082ef8b2,0xb8b03f32,0x67fef96f,0x0000557d,0xdf4e9320,0x6fd054a0,0xb09e92fd,0xd7606b92,0x082eadcf,0xb8b06a4f,0x67feac12}, + [16]uint32{0x00000000,0x20841df2,0x10038824,0x308795d6,0x1000695e,0x308474ac,0x0003e17a,0x2087fc88,0x10007a5f,0x308467ad,0x0003f27b,0x2087ef89,0x00001301,0x20840ef3,0x10039b25,0x308786d7}, + [16]uint32{0x3f800000,0x3f90420e,0x3f8801c4,0x3f9843ca,0x3f880034,0x3f98423a,0x3f8001f0,0x3f9043fe,0x3f88003d,0x3f984233,0x3f8001f9,0x3f9043f7,0x3f800009,0x3f904207,0x3f8801cd,0x3f9843c3}, + uint32(0xfff80000), + [21]string{"0x9c","0xd2","0xe0","0xea","0x62","0x1f","0xb7","0xb8","0xb4","0x2e","0xfb","0xd2","0x3a","0x34","0xec","0xf7","0x58","0xdc","0x53","0x94","0x00"} }, + { + /* No.1007 delta:859 weight:1541 */ + 11213, + 46, + 13, + 4, + [16]uint32{0x00000000,0x719d4b9a,0x7743ef08,0x06dea492,0x85c03efc,0xf45d7566,0xf283d1f4,0x831e9a6e,0x00006f1f,0x719d2485,0x77438017,0x06decb8d,0x85c051e3,0xf45d1a79,0xf283beeb,0x831ef571}, + [16]uint32{0x00000000,0x2002a096,0xd04421ff,0xf0468169,0x30036834,0x1001c8a2,0xe04749cb,0xc045e95d,0x3000821e,0x10022288,0xe044a3e1,0xc0460377,0x0003ea2a,0x20014abc,0xd047cbd5,0xf0456b43}, + [16]uint32{0x3f800000,0x3f900150,0x3fe82210,0x3ff82340,0x3f9801b4,0x3f8800e4,0x3ff023a4,0x3fe022f4,0x3f980041,0x3f880111,0x3ff02251,0x3fe02301,0x3f8001f5,0x3f9000a5,0x3fe823e5,0x3ff822b5}, + uint32(0xfff80000), + [21]string{"0x64","0xf6","0x68","0x6a","0x66","0x60","0xbc","0xe5","0xc6","0x04","0x1c","0xf0","0xbe","0x8c","0xd1","0x28","0x9a","0x42","0x5a","0x44","0x00"} }, + { + /* No.1008 delta:1020 weight:1707 */ + 11213, + 38, + 13, + 4, + [16]uint32{0x00000000,0x64e6a475,0x2721e5e3,0x43c74196,0xa4503f0a,0xc0b69b7f,0x8371dae9,0xe7977e9c,0x00009eaf,0x64e63ada,0x27217b4c,0x43c7df39,0xa450a1a5,0xc0b605d0,0x83714446,0xe797e033}, + [16]uint32{0x00000000,0x00449c1a,0x003ee591,0x007a798b,0x0024a1c4,0x00603dde,0x001a4455,0x005ed84f,0x200290dc,0x20460cc6,0x203c754d,0x2078e957,0x20263118,0x2062ad02,0x2018d489,0x205c4893}, + [16]uint32{0x3f800000,0x3f80224e,0x3f801f72,0x3f803d3c,0x3f801250,0x3f80301e,0x3f800d22,0x3f802f6c,0x3f900148,0x3f902306,0x3f901e3a,0x3f903c74,0x3f901318,0x3f903156,0x3f900c6a,0x3f902e24}, + uint32(0xfff80000), + [21]string{"0x5e","0x4f","0x86","0x59","0x9d","0x79","0xa6","0x37","0x89","0x44","0xc1","0x1b","0x70","0x49","0x0d","0x1a","0x46","0x86","0x71","0x48","0x00"} }, + { + /* No.1009 delta:884 weight:1567 */ + 11213, + 66, + 13, + 4, + [16]uint32{0x00000000,0xa3cca0d9,0x34b21388,0x977eb351,0x35b03f15,0x967c9fcc,0x01022c9d,0xa2ce8c44,0x0000bd86,0xa3cc1d5f,0x34b2ae0e,0x977e0ed7,0x35b08293,0x967c224a,0x0102911b,0xa2ce31c2}, + [16]uint32{0x00000000,0x0400d813,0x4000c215,0x44001a06,0x0000c119,0x0400190a,0x4000030c,0x4400db1f,0x104f00b4,0x144fd8a7,0x504fc2a1,0x544f1ab2,0x104fc1ad,0x144f19be,0x504f03b8,0x544fdbab}, + [16]uint32{0x3f800000,0x3f82006c,0x3fa00061,0x3fa2000d,0x3f800060,0x3f82000c,0x3fa00001,0x3fa2006d,0x3f882780,0x3f8a27ec,0x3fa827e1,0x3faa278d,0x3f8827e0,0x3f8a278c,0x3fa82781,0x3faa27ed}, + uint32(0xfff80000), + [21]string{"0x04","0xdd","0x2f","0x05","0xc0","0x8d","0xaa","0x43","0x80","0x26","0x26","0x77","0x1e","0x57","0x21","0x6d","0x6b","0x5e","0xed","0x4e","0x00"} }, + { + /* No.1010 delta:968 weight:1215 */ + 11213, + 39, + 13, + 4, + [16]uint32{0x00000000,0x246fd8c7,0x1648eb43,0x32273384,0x74b03f2b,0x50dfe7ec,0x62f8d468,0x46970caf,0x0000349d,0x246fec5a,0x1648dfde,0x32270719,0x74b00bb6,0x50dfd371,0x62f8e0f5,0x46973832}, + [16]uint32{0x00000000,0x101c09d6,0x00224b82,0x103e4254,0x20032098,0x301f294e,0x20216b1a,0x303d62cc,0x02034575,0x121f4ca3,0x02210ef7,0x123d0721,0x220065ed,0x321c6c3b,0x22222e6f,0x323e27b9}, + [16]uint32{0x3f800000,0x3f880e04,0x3f801125,0x3f881f21,0x3f900190,0x3f980f94,0x3f9010b5,0x3f981eb1,0x3f8101a2,0x3f890fa6,0x3f811087,0x3f891e83,0x3f910032,0x3f990e36,0x3f911117,0x3f991f13}, + uint32(0xfff80000), + [21]string{"0x87","0xb8","0x98","0x35","0x2f","0x33","0x93","0x55","0x85","0x4f","0x7d","0x55","0x8c","0xd8","0x6e","0x40","0x36","0x11","0xd6","0xbf","0x00"} }, + { + /* No.1011 delta:1031 weight:1603 */ + 11213, + 47, + 13, + 4, + [16]uint32{0x00000000,0x99459dbf,0x36f38a5f,0xafb617e0,0xbd903f3d,0x24d5a282,0x8b63b562,0x122628dd,0x00005dd9,0x9945c066,0x36f3d786,0xafb64a39,0xbd9062e4,0x24d5ff5b,0x8b63e8bb,0x12267504}, + [16]uint32{0x00000000,0x5800e376,0x041e001d,0x5c1ee36b,0x2002a0ac,0x780243da,0x241ca0b1,0x7c1c43c7,0x0000100e,0x5800f378,0x041e1013,0x5c1ef365,0x2002b0a2,0x780253d4,0x241cb0bf,0x7c1c53c9}, + [16]uint32{0x3f800000,0x3fac0071,0x3f820f00,0x3fae0f71,0x3f900150,0x3fbc0121,0x3f920e50,0x3fbe0e21,0x3f800008,0x3fac0079,0x3f820f08,0x3fae0f79,0x3f900158,0x3fbc0129,0x3f920e58,0x3fbe0e29}, + uint32(0xfff80000), + [21]string{"0x79","0x1c","0xf0","0x7f","0xbb","0xba","0xf7","0x96","0xd2","0x9b","0x3f","0xcc","0xfb","0x8a","0x0b","0xfc","0xd1","0xda","0xd2","0xf1","0x00"} }, + { + /* No.1012 delta:961 weight:1615 */ + 11213, + 53, + 13, + 4, + [16]uint32{0x00000000,0x26d3f377,0x83bfd053,0xa56c2324,0x05203f4f,0x23f3cc38,0x869fef1c,0xa04c1c6b,0x0000f930,0x26d30a47,0x83bf2963,0xa56cda14,0x0520c67f,0x23f33508,0x869f162c,0xa04ce55b}, + [16]uint32{0x00000000,0x00749c17,0x400851e2,0x407ccdf5,0x0002801b,0x00761c0c,0x400ad1f9,0x407e4dee,0x4001d006,0x40754c11,0x000981e4,0x007d1df3,0x4003501d,0x4077cc0a,0x000b01ff,0x007f9de8}, + [16]uint32{0x3f800000,0x3f803a4e,0x3fa00428,0x3fa03e66,0x3f800140,0x3f803b0e,0x3fa00568,0x3fa03f26,0x3fa000e8,0x3fa03aa6,0x3f8004c0,0x3f803e8e,0x3fa001a8,0x3fa03be6,0x3f800580,0x3f803fce}, + uint32(0xfff80000), + [21]string{"0x4e","0x79","0xfc","0xaa","0x1b","0xbc","0x49","0x5a","0xf7","0xb0","0x6a","0xa1","0xad","0x12","0x25","0x41","0xf8","0xdb","0xf7","0x4c","0x00"} }, + { + /* No.1013 delta:2148 weight:1319 */ + 11213, + 8, + 13, + 4, + [16]uint32{0x00000000,0xc5719a74,0x3ff46178,0xfa85fb0c,0xddc03f5a,0x18b1a52e,0xe2345e22,0x2745c456,0x0000de60,0xc5714414,0x3ff4bf18,0xfa85256c,0xddc0e13a,0x18b17b4e,0xe2348042,0x27451a36}, + [16]uint32{0x00000000,0x0e8888ff,0x48fe3894,0x4676b06b,0x110030e5,0x1f88b81a,0x59fe0871,0x5776808e,0x10400802,0x1ec880fd,0x58be3096,0x5636b869,0x014038e7,0x0fc8b018,0x49be0073,0x4736888c}, + [16]uint32{0x3f800000,0x3f874444,0x3fa47f1c,0x3fa33b58,0x3f888018,0x3f8fc45c,0x3facff04,0x3fabbb40,0x3f882004,0x3f8f6440,0x3fac5f18,0x3fab1b5c,0x3f80a01c,0x3f87e458,0x3fa4df00,0x3fa39b44}, + uint32(0xfff80000), + [21]string{"0x91","0x71","0xf1","0xf7","0xcc","0xd3","0xf1","0xeb","0x3b","0xbe","0x48","0xce","0xf7","0x31","0x6f","0xb2","0x36","0xe6","0xcf","0xba","0x00"} }, + { + /* No.1014 delta:1054 weight:1197 */ + 11213, + 44, + 13, + 4, + [16]uint32{0x00000000,0x7e6cd2cd,0x7daaad80,0x03c67f4d,0x34203f60,0x4a4cedad,0x498a92e0,0x37e6402d,0x00003fd5,0x7e6ced18,0x7daa9255,0x03c64098,0x342000b5,0x4a4cd278,0x498aad35,0x37e67ff8}, + [16]uint32{0x00000000,0x2ca4c41a,0x002f0993,0x2c8bcd89,0x0002013d,0x2ca6c527,0x002d08ae,0x2c89ccb4,0x00438806,0x2ce74c1c,0x006c8195,0x2cc8458f,0x0041893b,0x2ce54d21,0x006e80a8,0x2cca44b2}, + [16]uint32{0x3f800000,0x3f965262,0x3f801784,0x3f9645e6,0x3f800100,0x3f965362,0x3f801684,0x3f9644e6,0x3f8021c4,0x3f9673a6,0x3f803640,0x3f966422,0x3f8020c4,0x3f9672a6,0x3f803740,0x3f966522}, + uint32(0xfff80000), + [21]string{"0xf3","0xd2","0xdf","0x25","0xcb","0x53","0xec","0x3a","0xe7","0x9a","0xb2","0xaf","0xd0","0xf8","0x9d","0x10","0x85","0xa5","0xc2","0x2b","0x00"} }, + { + /* No.1015 delta:1206 weight:1699 */ + 11213, + 22, + 13, + 4, + [16]uint32{0x00000000,0x4d3b8c26,0x09dcafe9,0x44e723cf,0xc6403f72,0x8b7bb354,0xcf9c909b,0x82a71cbd,0x00007f56,0x4d3bf370,0x09dcd0bf,0x44e75c99,0xc6404024,0x8b7bcc02,0xcf9cefcd,0x82a763eb}, + [16]uint32{0x00000000,0x082311fc,0x106441b1,0x1847504d,0x4021c11a,0x4802d0e6,0x504580ab,0x58669157,0x0041001f,0x086211e3,0x102541ae,0x18065052,0x4060c105,0x4843d0f9,0x500480b4,0x58279148}, + [16]uint32{0x3f800000,0x3f841188,0x3f883220,0x3f8c23a8,0x3fa010e0,0x3fa40168,0x3fa822c0,0x3fac3348,0x3f802080,0x3f843108,0x3f8812a0,0x3f8c0328,0x3fa03060,0x3fa421e8,0x3fa80240,0x3fac13c8}, + uint32(0xfff80000), + [21]string{"0xa8","0x7e","0xd5","0x7b","0x14","0x3f","0xcb","0x47","0xbd","0x68","0xf8","0x0f","0x06","0x31","0x8c","0x36","0xa8","0xb3","0xeb","0x26","0x00"} }, + { + /* No.1016 delta:867 weight:1603 */ + 11213, + 92, + 13, + 4, + [16]uint32{0x00000000,0xebb78496,0x7c29fda1,0x979e7937,0x69603f85,0x82d7bb13,0x1549c224,0xfefe46b2,0x00006b30,0xebb7efa6,0x7c299691,0x979e1207,0x696054b5,0x82d7d023,0x1549a914,0xfefe2d82}, + [16]uint32{0x00000000,0xa02a01fe,0x007f0055,0xa05501ab,0x40021109,0xe02810f7,0x407d115c,0xe05710a2,0xa0201018,0x000a11e6,0xa05f104d,0x007511b3,0xe0220111,0x400800ef,0xe05d0144,0x407700ba}, + [16]uint32{0x3f800000,0x3fd01500,0x3f803f80,0x3fd02a80,0x3fa00108,0x3ff01408,0x3fa03e88,0x3ff02b88,0x3fd01008,0x3f800508,0x3fd02f88,0x3f803a88,0x3ff01100,0x3fa00400,0x3ff02e80,0x3fa03b80}, + uint32(0xfff80000), + [21]string{"0x82","0x08","0x6b","0x6e","0xb3","0xcd","0xe1","0x30","0xed","0xd8","0x57","0x2d","0x79","0x60","0xcb","0xd7","0xc6","0xa6","0x66","0xd6","0x00"} }, + { + /* No.1017 delta:1226 weight:1601 */ + 11213, + 23, + 13, + 4, + [16]uint32{0x00000000,0xe28ad03e,0xa9d5d7de,0x4b5f07e0,0xa9403f9d,0x4bcaefa3,0x0095e843,0xe21f387d,0x00005790,0xe28a87ae,0xa9d5804e,0x4b5f5070,0xa940680d,0x4bcab833,0x0095bfd3,0xe21f6fed}, + [16]uint32{0x00000000,0x006ff0f6,0x00cb11db,0x00a4e12d,0x0035581c,0x005aa8ea,0x00fe49c7,0x0091b931,0x40004018,0x406fb0ee,0x40cb51c3,0x40a4a135,0x40351804,0x405ae8f2,0x40fe09df,0x4091f929}, + [16]uint32{0x3f800000,0x3f8037f8,0x3f806588,0x3f805270,0x3f801aac,0x3f802d54,0x3f807f24,0x3f8048dc,0x3fa00020,0x3fa037d8,0x3fa065a8,0x3fa05250,0x3fa01a8c,0x3fa02d74,0x3fa07f04,0x3fa048fc}, + uint32(0xfff80000), + [21]string{"0x2b","0x5f","0x37","0xcc","0xd1","0xdc","0x4e","0x8c","0x27","0x03","0x2d","0x5e","0x37","0xa0","0x70","0xf7","0x83","0x13","0x23","0xc3","0x00"} }, + { + /* No.1018 delta:1677 weight:1643 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x9237e603,0x29a9dcee,0xbb9e3aed,0xee203fa7,0x7c17d9a4,0xc789e349,0x55be054a,0x0000bdfe,0x92375bfd,0x29a96110,0xbb9e8713,0xee208259,0x7c17645a,0xc7895eb7,0x55beb8b4}, + [16]uint32{0x00000000,0x001c00de,0x4230812f,0x422c81f1,0x0000007a,0x001c00a4,0x42308155,0x422c818b,0x0020001d,0x003c00c3,0x42108132,0x420c81ec,0x00200067,0x003c00b9,0x42108148,0x420c8196}, + [16]uint32{0x3f800000,0x3f800e00,0x3fa11840,0x3fa11640,0x3f800000,0x3f800e00,0x3fa11840,0x3fa11640,0x3f801000,0x3f801e00,0x3fa10840,0x3fa10640,0x3f801000,0x3f801e00,0x3fa10840,0x3fa10640}, + uint32(0xfff80000), + [21]string{"0xdb","0xc2","0xfc","0x35","0xdf","0xb4","0x75","0x74","0x61","0xc5","0x18","0xb4","0x47","0xdd","0xbb","0x1e","0xad","0x7d","0x57","0x23","0x00"} }, + { + /* No.1019 delta:1941 weight:1341 */ + 11213, + 10, + 13, + 4, + [16]uint32{0x00000000,0x0d026f1a,0x27bc1805,0x2abe771f,0x34803fb6,0x398250ac,0x133c27b3,0x1e3e48a9,0x000093a9,0x0d02fcb3,0x27bc8bac,0x2abee4b6,0x3480ac1f,0x3982c305,0x133cb41a,0x1e3edb00}, + [16]uint32{0x00000000,0x18511afc,0x080c8097,0x105d9a6b,0x403801fe,0x58691b02,0x48348169,0x50659b95,0x858400ff,0x9dd51a03,0x8d888068,0x95d99a94,0xc5bc0101,0xdded1bfd,0xcdb08196,0xd5e19b6a}, + [16]uint32{0x3f800000,0x3f8c288d,0x3f840640,0x3f882ecd,0x3fa01c00,0x3fac348d,0x3fa41a40,0x3fa832cd,0x3fc2c200,0x3fceea8d,0x3fc6c440,0x3fcaeccd,0x3fe2de00,0x3feef68d,0x3fe6d840,0x3feaf0cd}, + uint32(0xfff80000), + [21]string{"0x22","0x7f","0x5c","0x66","0xc3","0xd8","0x5a","0xb7","0x92","0xf3","0xd4","0x9f","0x85","0xc6","0x12","0xb7","0x76","0xd1","0x68","0x03","0x00"} }, + { + /* No.1020 delta:721 weight:1605 */ + 11213, + 73, + 13, + 4, + [16]uint32{0x00000000,0xca7ce2f6,0x8b08826e,0x41746098,0x6a403fca,0xa03cdd3c,0xe148bda4,0x2b345f52,0x00005812,0xca7cbae4,0x8b08da7c,0x4174388a,0x6a4067d8,0xa03c852e,0xe148e5b6,0x2b340740}, + [16]uint32{0x00000000,0x004f86d3,0x00028151,0x004d0782,0x60041418,0x604b92cb,0x60069549,0x6049139a,0x2024014c,0x206b879f,0x2026801d,0x206906ce,0x40201554,0x406f9387,0x40229405,0x406d12d6}, + [16]uint32{0x3f800000,0x3f8027c3,0x3f800140,0x3f802683,0x3fb0020a,0x3fb025c9,0x3fb0034a,0x3fb02489,0x3f901200,0x3f9035c3,0x3f901340,0x3f903483,0x3fa0100a,0x3fa037c9,0x3fa0114a,0x3fa03689}, + uint32(0xfff80000), + [21]string{"0x0f","0x36","0x87","0xb5","0xbb","0xa8","0xa4","0x64","0x54","0xf7","0x51","0x2d","0xe6","0x78","0xae","0xe4","0xe5","0x43","0xa3","0x71","0x00"} }, + { + /* No.1021 delta:992 weight:1597 */ + 11213, + 62, + 13, + 4, + [16]uint32{0x00000000,0x17394480,0x757dbcc8,0x6244f848,0x62203fd7,0x75197b57,0x175d831f,0x0064c79f,0x00001bd6,0x17395f56,0x757da71e,0x6244e39e,0x62202401,0x75196081,0x175d98c9,0x0064dc49}, + [16]uint32{0x00000000,0x00ec09b2,0x08028f55,0x08ee86e7,0x0003da8f,0x00efd33d,0x080155da,0x08ed5c68,0x3011a80a,0x30fda1b8,0x3813275f,0x38ff2eed,0x30127285,0x30fe7b37,0x3810fdd0,0x38fcf462}, + [16]uint32{0x3f800000,0x3f807604,0x3f840147,0x3f847743,0x3f8001ed,0x3f8077e9,0x3f8400aa,0x3f8476ae,0x3f9808d4,0x3f987ed0,0x3f9c0993,0x3f9c7f97,0x3f980939,0x3f987f3d,0x3f9c087e,0x3f9c7e7a}, + uint32(0xfff80000), + [21]string{"0xf4","0xfd","0xec","0xfd","0x45","0xc7","0xec","0x82","0x3b","0x2a","0x7c","0xc0","0x6f","0x12","0xa9","0xa3","0xe0","0x0b","0xa5","0x20","0x00"} }, + { + /* No.1022 delta:1082 weight:1417 */ + 11213, + 30, + 13, + 4, + [16]uint32{0x00000000,0xb5f7cf48,0xa67ec37a,0x13890c32,0x47903fe6,0xf267f0ae,0xe1eefc9c,0x541933d4,0x0000a5fe,0xb5f76ab6,0xa67e6684,0x1389a9cc,0x47909a18,0xf2675550,0xe1ee5962,0x5419962a}, + [16]uint32{0x00000000,0x0f637917,0x008ab0d5,0x0fe9c9c2,0x0054c11e,0x0f37b809,0x00de71cb,0x0fbd08dc,0x0003701b,0x0f60090c,0x0089c0ce,0x0feab9d9,0x0057b105,0x0f34c812,0x00dd01d0,0x0fbe78c7}, + [16]uint32{0x3f800000,0x3f87b1bc,0x3f804558,0x3f87f4e4,0x3f802a60,0x3f879bdc,0x3f806f38,0x3f87de84,0x3f8001b8,0x3f87b004,0x3f8044e0,0x3f87f55c,0x3f802bd8,0x3f879a64,0x3f806e80,0x3f87df3c}, + uint32(0xfff80000), + [21]string{"0x08","0x98","0x08","0x9b","0xec","0xc6","0x5c","0x9c","0xbc","0x51","0xb5","0x3d","0xd8","0x3c","0xda","0xed","0xc3","0x45","0x06","0x9b","0x00"} }, + { + /* No.1023 delta:1423 weight:1727 */ + 11213, + 17, + 13, + 4, + [16]uint32{0x00000000,0x97f9e40f,0xa8734c40,0x3f8aa84f,0x40303ff2,0xd7c9dbfd,0xe84373b2,0x7fba97bd,0x0000577b,0x97f9b374,0xa8731b3b,0x3f8aff34,0x40306889,0xd7c98c86,0xe84324c9,0x7fbac0c6}, + [16]uint32{0x00000000,0x00c410ba,0x20630b2d,0x20a71b97,0x0011ca04,0x00d5dabe,0x2072c129,0x20b6d193,0xa0242a1b,0xa0e03aa1,0x80472136,0x8083318c,0xa035e01f,0xa0f1f0a5,0x8056eb32,0x8092fb88}, + [16]uint32{0x3f800000,0x3f806208,0x3f903185,0x3f90538d,0x3f8008e5,0x3f806aed,0x3f903960,0x3f905b68,0x3fd01215,0x3fd0701d,0x3fc02390,0x3fc04198,0x3fd01af0,0x3fd078f8,0x3fc02b75,0x3fc0497d}, + uint32(0xfff80000), + [21]string{"0x09","0xb8","0x79","0xb8","0xb7","0x72","0xff","0x62","0x1d","0xba","0xc4","0x21","0x33","0x96","0xd3","0x97","0x35","0x3b","0x9d","0x69","0x00"} }, +} +const mtgpdc_params_11213_num = 1023 diff --git a/opencl/oclRAND/threefry.go b/opencl/oclRAND/threefry.go new file mode 100644 index 0000000..257627e --- /dev/null +++ b/opencl/oclRAND/threefry.go @@ -0,0 +1,89 @@ +package oclRAND + +import ( + "github.com/seeder-research/uMagNUS/opencl/cl" + + "log" + "unsafe" +) + +type THREEFRY_status_array_ptr struct { + Ini bool + Seed_Arr []uint64 + Status_key *cl.MemObject + Status_counter *cl.MemObject + Status_result *cl.MemObject + Status_tracker *cl.MemObject + Status_size int + GroupSize int + GroupCount int + ClCtx *cl.Context +} + +func NewTHREEFRYStatus() *THREEFRY_status_array_ptr { + q := new(THREEFRY_status_array_ptr) + q.Ini = false + q.Status_size = -1 + return q +} + +func (p *THREEFRY_status_array_ptr) SetContext(context *cl.Context) { + p.ClCtx = context +} + +func (p *THREEFRY_status_array_ptr) GetContext() *cl.Context { + return p.ClCtx +} + +func (p *THREEFRY_status_array_ptr) SetStatusSize(N int) { + p.Status_size = N +} + +func (p *THREEFRY_status_array_ptr) GetStatusSize() int { + return p.Status_size +} + +func (p *THREEFRY_status_array_ptr) CreateStatusBuffer(context *cl.Context) { + p.SetContext(context) + if p.Status_size <= 0 { + log.Fatalln("Unable to create buffer for THREEFRY status array: number of PRNGs is less than 1") + } + var err error + var testVar uint32 + p.Status_key, err = p.ClCtx.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(testVar))*4*p.Status_size, nil) + if err != nil { + log.Fatalln("Unable to create buffer for THREEFRY status key array!") + } + p.Status_counter, err = p.ClCtx.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(testVar))*4*p.Status_size, nil) + if err != nil { + log.Fatalln("Unable to create buffer for THREEFRY status counter array!") + } + p.Status_result, err = p.ClCtx.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(testVar))*4*p.Status_size, nil) + if err != nil { + log.Fatalln("Unable to create buffer for THREEFRY status result array!") + } + p.Status_tracker, err = p.ClCtx.CreateBufferUnsafe(cl.MemReadWrite, int(unsafe.Sizeof(testVar))*p.Status_size, nil) + if err != nil { + log.Fatalln("Unable to create buffer for THREEFRY status tracker array!") + } +} + +func (p *THREEFRY_status_array_ptr) SetGroupSize(in int) { + p.GroupSize = in +} + +func (p *THREEFRY_status_array_ptr) GetGroupSize() int { + return p.GroupSize +} + +func (p *THREEFRY_status_array_ptr) SetGroupCount(in int) { + p.GroupCount = in +} + +func (p *THREEFRY_status_array_ptr) GetGroupCount() int { + return p.GroupCount +} + +func (p *THREEFRY_status_array_ptr) RecommendSize() int { + return 16 * p.Status_size +} diff --git a/opencl/oclRAND/xorwow.go b/opencl/oclRAND/xorwow.go index 0001219..5e78e6f 100644 --- a/opencl/oclRAND/xorwow.go +++ b/opencl/oclRAND/xorwow.go @@ -25,11 +25,11 @@ func NewXORWOWStatus() *XORWOW_status_array_ptr { } func (p *XORWOW_status_array_ptr) SetContext(context *cl.Context) { - p.ClCtx = context + p.ClCtx = context } func (p *XORWOW_status_array_ptr) GetContext() *cl.Context { - return p.ClCtx + return p.ClCtx } func (p *XORWOW_status_array_ptr) SetStatusSize(N int) { @@ -70,5 +70,5 @@ func (p *XORWOW_status_array_ptr) GetGroupCount() int { } func (p *XORWOW_status_array_ptr) RecommendSize() int { - return 8 * p.Status_size + return 8 * p.Status_size } diff --git a/opencl/rng.go b/opencl/rng.go index 8d93ae8..38ba037 100644 --- a/opencl/rng.go +++ b/opencl/rng.go @@ -50,6 +50,11 @@ func NewGenerator(name string) *Generator { case "mrg32k3a": fmt.Println("mrg32k3a not yet implemented") return nil + case "threefry": + oclRAND.Init(ClCmdQueue, Synchronous, KernList) + var prng_ptr Prng_ + prng_ptr = NewTHREEFRYRNGParams() + return &Generator{Name: "threefry", PRNG: prng_ptr} case "xorwow": oclRAND.Init(ClCmdQueue, Synchronous, KernList) var prng_ptr Prng_ @@ -70,6 +75,11 @@ func (g *Generator) CreatePNG() { g.PRNG = prng_ptr case "mrg32k3a": fmt.Println("mrg32k3a not yet implemented") + case "threefry": + oclRAND.Init(ClCmdQueue, Synchronous, KernList) + var prng_ptr Prng_ + prng_ptr = NewTHREEFRYRNGParams() + g.PRNG = prng_ptr case "xorwow": oclRAND.Init(ClCmdQueue, Synchronous, KernList) var prng_ptr Prng_ @@ -214,7 +224,7 @@ func NewMTGPRNGParams() *oclRAND.MTGP32dc_params_array_ptr { var events_list []*cl.Event var event *cl.Event tmp := oclRAND.NewMTGPParams() - // maxNumGroups, max_size := ClCUnits, MTGP32_PARAM_NUM + //maxNumGroups, max_size := ClCUnits, MTGP32_PARAM_NUM maxNumGroups, max_size := 1, MTGP32_PARAM_NUM if maxNumGroups > max_size { maxNumGroups = max_size @@ -242,6 +252,16 @@ func NewMTGPRNGParams() *oclRAND.MTGP32dc_params_array_ptr { return tmp } +func NewTHREEFRYRNGParams() *oclRAND.THREEFRY_status_array_ptr { + tmp := oclRAND.NewTHREEFRYStatus() + tmp.SetGroupCount(ClCUnits) + tmp.SetGroupSize(ClPrefWGSz) + tmp.SetStatusSize(ClCUnits * ClPrefWGSz) + tmp.CreateStatusBuffer(ClCtx) + + return tmp +} + func NewXORWOWRNGParams() *oclRAND.XORWOW_status_array_ptr { tmp := oclRAND.NewXORWOWStatus() tmp.SetGroupCount(ClCUnits) diff --git a/test/rk4temperature.mx3 b/test/rk4temperature.mx3 index 2117f2d..ad88ce6 100644 --- a/test/rk4temperature.mx3 +++ b/test/rk4temperature.mx3 @@ -4,7 +4,7 @@ c := 10e-9 setcellsize(c, c, c) -setgridsize(768, 768, 1) +setgridsize(512, 512, 1) Msat = 1e6 Aex = 0