diff --git a/src/bitstream.cs b/src/bitstream.cs new file mode 100644 index 0000000..f563703 --- /dev/null +++ b/src/bitstream.cs @@ -0,0 +1,317 @@ +//----------------------------------------------------------------------------- +// Filename: bitstream.cs +// +// Description: Port of: +// - vp8/encoder/bitstream.c +// - vp8/encoder/bitstream.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 13 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; +using vp8_prob = System.Byte; +using vp8_writer = Vpx.Net.BOOL_CODER; + +namespace Vpx.Net +{ + public unsafe static class bitstream + { + /// + /// Base skip false probabilities for different Q indices. + /// + public static readonly int[] vp8cx_base_skip_false_prob = new int[128] + { + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 251, 248, 244, 240, + 236, 232, 229, 225, 221, 217, 213, 208, 204, 199, 194, 190, 187, 183, 179, + 175, 172, 168, 164, 160, 157, 153, 149, 145, 142, 138, 134, 130, 127, 124, + 120, 117, 114, 110, 107, 104, 101, 98, 95, 92, 89, 86, 83, 80, 77, + 74, 71, 68, 65, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, + 30, 28, 26, 24, 22, 20, 18, 16, + }; + + /// + /// Pack tokens into the bitstream using boolean encoder. + /// + public static void vp8_pack_tokens(vp8_writer* w, TOKENEXTRA* p, int xcount) + { + // TODO: Implement full token packing + // This requires vp8_token structure, vp8_extra_bit_struct, and related data + // For now, this is a placeholder + // The full implementation would: + // 1. Iterate through each token + // 2. Encode the token value using the coefficient tree + // 3. Encode extra bits if present + // 4. Handle EOB (End of Block) tokens + /* + TOKENEXTRA* stop = p + xcount; + uint split; + int shift; + int count = w->count; + uint range = w->range; + uint lowvalue = w->lowvalue; + + while (p < stop) + { + int t = p->token; + // vp8_token* a = vp8_coef_encodings + t; + // vp8_extra_bit_struct* b = vp8_extra_bits + t; + int i = 0; + byte pp = p->context_tree; + // int v = a->value; + // int n = a->Len; + + // ... token encoding logic here ... + ++p; + } + + w->count = count; + w->lowvalue = lowvalue; + w->range = range; + */ + } + + /// + /// Write partition size into 3 bytes. + /// + private static void write_partition_size(byte* cx_data, int size) + { + sbyte csize; + + csize = (sbyte)(size & 0xff); + *cx_data = (byte)csize; + csize = (sbyte)((size >> 8) & 0xff); + *(cx_data + 1) = (byte)csize; + csize = (sbyte)((size >> 16) & 0xff); + *(cx_data + 2) = (byte)csize; + } + + /// + /// Pack tokens into multiple partitions. + /// + private static void pack_tokens_into_partitions(VP8_COMP cpi, byte* cx_data, + byte* cx_data_end, int num_part) + { + // TODO: Implement multi-partition token packing + // This requires full VP8_COMP context with token lists + } + + /// + /// Update mode probabilities. + /// + private static void update_mode(vp8_writer* w, int n, vp8_token* tok, + sbyte* tree, vp8_prob* Pnew, + vp8_prob* Pcur, uint* bct, + uint* num_events) + { + // TODO: Implement mode probability update + // This requires tree probability computation functions + } + + /// + /// Update macroblock intra mode probabilities. + /// + private static void update_mbintra_mode_probs(VP8_COMP cpi) + { + // TODO: Implement intra mode probability updates + } + + /// + /// Write Y mode to bitstream. + /// + private static void write_ymode(vp8_writer* bc, int m, vp8_prob* p) + { + // TODO: Implement Y mode writing using vp8_ymode_tree + // treewriter.vp8_write_token(bc, entropymode.vp8_ymode_tree, p, + // entropymode.vp8_ymode_encodings + m); + } + + /// + /// Write keyframe Y mode to bitstream. + /// + private static void kfwrite_ymode(vp8_writer* bc, int m, vp8_prob* p) + { + // TODO: Implement keyframe Y mode writing + // treewriter.vp8_write_token(bc, entropymode.vp8_kf_ymode_tree, p, + // entropymode.vp8_kf_ymode_encodings + m); + } + + /// + /// Write UV mode to bitstream. + /// + private static void write_uv_mode(vp8_writer* bc, int m, vp8_prob* p) + { + // TODO: Implement UV mode writing + // treewriter.vp8_write_token(bc, entropymode.vp8_uv_mode_tree, p, + // entropymode.vp8_uv_mode_encodings + m); + } + + /// + /// Write B mode to bitstream. + /// + private static void write_bmode(vp8_writer* bc, int m, vp8_prob* p) + { + // TODO: Implement B mode writing + // treewriter.vp8_write_token(bc, entropymode.vp8_bmode_tree, p, + // entropymode.vp8_bmode_encodings + m); + } + + /// + /// Write split mode to bitstream. + /// + private static void write_split(vp8_writer* bc, int x) + { + // TODO: Implement split mode writing + // treewriter.vp8_write_token(bc, entropymode.vp8_mbsplit_tree, + // vp8_mbsplit_probs, + // vp8_mbsplit_encodings + x); + } + + /// + /// Write motion vector reference to bitstream. + /// + private static void write_mv_ref(vp8_writer* w, MB_PREDICTION_MODE m, vp8_prob* p) + { + // TODO: Implement MV reference writing + // treewriter.vp8_write_token(w, entropymode.vp8_mv_ref_tree, p, + // vp8_mv_ref_encoding_array + ((int)m - (int)MB_PREDICTION_MODE.NEARESTMV)); + } + + /// + /// Write sub motion vector reference to bitstream. + /// + private static void write_sub_mv_ref(vp8_writer* w, B_PREDICTION_MODE m, vp8_prob* p) + { + // TODO: Implement sub MV reference writing + // treewriter.vp8_write_token(w, vp8_sub_mv_ref_tree, p, + // vp8_sub_mv_ref_encoding_array + ((int)m - (int)B_PREDICTION_MODE.LEFT4X4)); + } + + /// + /// Write motion vector to bitstream. + /// + private static void write_mv(vp8_writer* w, MV* mv, int_mv* refmv, MV_CONTEXT* mvc) + { + // TODO: Implement motion vector writing + // MV e; + // e.row = (short)(mv->row - refmv->as_mv.row); + // e.col = (short)(mv->col - refmv->as_mv.col); + // encodemv.vp8_encode_motion_vector(w, &e, mvc); + } + + /// + /// Write macroblock features (segmentation) to bitstream. + /// + private static void write_mb_features(vp8_writer* w, MB_MODE_INFO* mi, MACROBLOCKD* x) + { + // TODO: Implement MB feature writing + // This requires proper tree writer functions + } + + /// + /// Convert reference frame counts to probabilities. + /// + public static void vp8_convert_rfct_to_prob(VP8_COMP cpi) + { + // TODO: Implement reference frame count to probability conversion + // This requires full VP8_COMP context + } + + /// + /// Calculate reference frame costs. + /// + public static void vp8_calc_ref_frame_costs(int* ref_frame_cost, int prob_intra, + int prob_last, int prob_garf) + { + ref_frame_cost[(int)MV_REFERENCE_FRAME.INTRA_FRAME] = + (int)treewriter.vp8_cost_zero((byte)prob_intra); + ref_frame_cost[(int)MV_REFERENCE_FRAME.LAST_FRAME] = + (int)(treewriter.vp8_cost_one((byte)prob_intra) + treewriter.vp8_cost_zero((byte)prob_last)); + ref_frame_cost[(int)MV_REFERENCE_FRAME.GOLDEN_FRAME] = + (int)(treewriter.vp8_cost_one((byte)prob_intra) + + treewriter.vp8_cost_one((byte)prob_last) + + treewriter.vp8_cost_zero((byte)prob_garf)); + ref_frame_cost[(int)MV_REFERENCE_FRAME.ALTREF_FRAME] = + (int)(treewriter.vp8_cost_one((byte)prob_intra) + + treewriter.vp8_cost_one((byte)prob_last) + + treewriter.vp8_cost_one((byte)prob_garf)); + } + + /// + /// Estimate entropy savings from probability updates. + /// + public static int vp8_estimate_entropy_savings(VP8_COMP cpi) + { + // TODO: Implement entropy savings estimation + // This requires full coefficient probability context + return 0; + } + + /// + /// Update coefficient probabilities. + /// + public static void vp8_update_coef_probs(VP8_COMP cpi) + { + // TODO: Implement coefficient probability updates + // This is a complex function that updates token probabilities + } + + /// + /// Pack inter frame modes and motion vectors. + /// + private static void pack_inter_mode_mvs(VP8_COMP cpi) + { + // TODO: Implement inter mode and MV packing + // This requires full VP8_COMP context with mode info + } + + /// + /// Write keyframe modes. + /// + private static void write_kfmodes(VP8_COMP cpi) + { + // TODO: Implement keyframe mode writing + // This iterates through all macroblocks and writes intra modes + } + + /// + /// Main function to pack bitstream. + /// This is the entry point for generating a VP8 frame bitstream. + /// + public static void vp8_pack_bitstream(VP8_COMP cpi, byte* dest, + byte* dest_end, ulong* size) + { + // TODO: Implement full bitstream packing + // This is the main entry point that: + // 1. Writes frame header + // 2. Writes segmentation and loop filter parameters + // 3. Writes quantization parameters + // 4. Writes mode probabilities + // 5. Writes coefficient probabilities + // 6. Writes macroblock data (modes, MVs, coefficients) + // 7. Manages multiple partitions + + // Placeholder implementation + *size = 0; + } + } +} diff --git a/src/block.cs b/src/block.cs new file mode 100644 index 0000000..04605fe --- /dev/null +++ b/src/block.cs @@ -0,0 +1,183 @@ +//----------------------------------------------------------------------------- +// Filename: block.cs +// +// Description: Port of: +// - vp8/encoder/block.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 09 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; + +namespace Vpx.Net +{ + public static class vp8_block + { + public const int MAX_MODES = 20; + public const int MAX_ERROR_BINS = 1024; + } + + public unsafe struct BLOCK + { + public short* src_diff; + public short* coeff; + + public short* quant; + public short* quant_fast; + public short* quant_shift; + public short* zbin; + public short* zrun_zbin_boost; + public short* round; + + public short zbin_extra; + + public byte** base_src; + public int src; + public int src_stride; + } + + public struct PARTITION_INFO + { + public int count; + public PARTITION_BMI[] bmi; + + public PARTITION_INFO() + { + bmi = new PARTITION_BMI[16]; + } + } + + public struct PARTITION_BMI + { + public B_PREDICTION_MODE mode; + public int_mv mv; + } + + public unsafe class MACROBLOCK + { + public short[] src_diff = new short[400]; + public short[] coeff = new short[400]; + public byte[] thismb = new byte[256]; + + public byte* thismb_ptr; + + public BLOCK[] block = new BLOCK[25]; + + public YV12_BUFFER_CONFIG src; + + public MACROBLOCKD e_mbd = new MACROBLOCKD(); + public PARTITION_INFO* partition_info; + public PARTITION_INFO* pi; + public PARTITION_INFO* pip; + + public int[] ref_frame_cost = new int[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + + public search_site* ss; + public int ss_count; + public int searches_per_step; + + public int errorperbit; + public int sadperbit16; + public int sadperbit4; + public int rddiv; + public int rdmult; + public uint* mb_activity_ptr; + public int* mb_norm_activity_ptr; + public int act_zbin_adj; + public int last_act_zbin_adj; + + public int*[] mvcost = new int*[2]; + public int*[] mvsadcost = new int*[2]; + public int* mbmode_cost; + public int* intra_uv_mode_cost; + public int* bmode_costs; + public int* inter_bmode_costs; + public int* token_costs; + + public int mv_col_min; + public int mv_col_max; + public int mv_row_min; + public int mv_row_max; + + public int skip; + + public uint encode_breakout; + + public sbyte* gf_active_ptr; + + public byte* active_ptr; + public MV_CONTEXT* mvc; + + public int optimize; + public int q_index; + public int is_skin; + public int denoise_zeromv; + + public int increase_denoising; + public MB_PREDICTION_MODE best_sse_inter_mode; + public int_mv best_sse_mv; + public MV_REFERENCE_FRAME best_reference_frame; + public MV_REFERENCE_FRAME best_zeromv_reference_frame; + public byte need_to_clamp_best_mvs; + + public int skip_true_count; + public uint[,,,] coef_counts; + public uint[,] MVcount; + public int[] ymode_count; + public int[] uv_mode_count; + public long prediction_error; + public long intra_error; + public int[] count_mb_ref_frame_usage; + + public int[] rd_thresh_mult; + public int[] rd_threshes; + public uint mbs_tested_so_far; + public uint[] mode_test_hit_counts; + public int zbin_mode_boost_enabled; + public int zbin_mode_boost; + public int last_zbin_mode_boost; + + public int last_zbin_over_quant; + public int zbin_over_quant; + public int[] error_bins; + + public void* short_fdct4x4; + public void* short_fdct8x4; + public void* short_walsh4x4; + public void* quantize_b; + + public uint mbs_zero_last_dot_suppress; + public int zero_last_dot_suppress; + + public MACROBLOCK() + { + coef_counts = new uint[entropy.BLOCK_TYPES, entropy.COEF_BANDS, + entropy.PREV_COEF_CONTEXTS, entropy.MAX_ENTROPY_TOKENS]; + MVcount = new uint[2, (int)MV_ENUM.MVvals]; + ymode_count = new int[blockd.VP8_YMODES]; + uv_mode_count = new int[blockd.VP8_UV_MODES]; + count_mb_ref_frame_usage = new int[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + rd_thresh_mult = new int[vp8_block.MAX_MODES]; + rd_threshes = new int[vp8_block.MAX_MODES]; + mode_test_hit_counts = new uint[vp8_block.MAX_MODES]; + error_bins = new int[vp8_block.MAX_ERROR_BINS]; + } + } +} diff --git a/src/dct.cs b/src/dct.cs new file mode 100644 index 0000000..af81a9e --- /dev/null +++ b/src/dct.cs @@ -0,0 +1,135 @@ +//----------------------------------------------------------------------------- +// Filename: dct.cs +// +// Description: Port of: +// - vp8/encoder/dct.c +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 17 Feb 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +namespace Vpx.Net +{ + public unsafe static class dct + { + public static void vp8_short_fdct4x4_c(short* input, short* output, int pitch) + { + int i; + int a1, b1, c1, d1; + short* ip = input; + short* op = output; + + for (i = 0; i < 4; ++i) + { + a1 = ((ip[0] + ip[3]) * 8); + b1 = ((ip[1] + ip[2]) * 8); + c1 = ((ip[1] - ip[2]) * 8); + d1 = ((ip[0] - ip[3]) * 8); + + op[0] = (short)(a1 + b1); + op[2] = (short)(a1 - b1); + + op[1] = (short)((c1 * 2217 + d1 * 5352 + 14500) >> 12); + op[3] = (short)((d1 * 2217 - c1 * 5352 + 7500) >> 12); + + ip += pitch / 2; + op += 4; + } + + ip = output; + op = output; + + for (i = 0; i < 4; ++i) + { + a1 = ip[0] + ip[12]; + b1 = ip[4] + ip[8]; + c1 = ip[4] - ip[8]; + d1 = ip[0] - ip[12]; + + op[0] = (short)((a1 + b1 + 7) >> 4); + op[8] = (short)((a1 - b1 + 7) >> 4); + + op[4] = (short)(((c1 * 2217 + d1 * 5352 + 12000) >> 16) + (d1 != 0 ? 1 : 0)); + op[12] = (short)((d1 * 2217 - c1 * 5352 + 51000) >> 16); + + ip++; + op++; + } + } + + public static void vp8_short_fdct8x4_c(short* input, short* output, int pitch) + { + vp8_short_fdct4x4_c(input, output, pitch); + vp8_short_fdct4x4_c(input + 4, output + 16, pitch); + } + + public static void vp8_short_walsh4x4_c(short* input, short* output, int pitch) + { + int i; + int a1, b1, c1, d1; + int a2, b2, c2, d2; + short* ip = input; + short* op = output; + + for (i = 0; i < 4; ++i) + { + a1 = ((ip[0] + ip[2]) * 4); + d1 = ((ip[1] + ip[3]) * 4); + c1 = ((ip[1] - ip[3]) * 4); + b1 = ((ip[0] - ip[2]) * 4); + + op[0] = (short)(a1 + d1 + (a1 != 0 ? 1 : 0)); + op[1] = (short)(b1 + c1); + op[2] = (short)(b1 - c1); + op[3] = (short)(a1 - d1); + ip += pitch / 2; + op += 4; + } + + ip = output; + op = output; + + for (i = 0; i < 4; ++i) + { + a1 = ip[0] + ip[8]; + d1 = ip[4] + ip[12]; + c1 = ip[4] - ip[12]; + b1 = ip[0] - ip[8]; + + a2 = a1 + d1; + b2 = b1 + c1; + c2 = b1 - c1; + d2 = a1 - d1; + + a2 += a2 < 0 ? 1 : 0; + b2 += b2 < 0 ? 1 : 0; + c2 += c2 < 0 ? 1 : 0; + d2 += d2 < 0 ? 1 : 0; + + op[0] = (short)((a2 + 3) >> 3); + op[4] = (short)((b2 + 3) >> 3); + op[8] = (short)((c2 + 3) >> 3); + op[12] = (short)((d2 + 3) >> 3); + + ip++; + op++; + } + } + } +} diff --git a/src/encodeframe.cs b/src/encodeframe.cs new file mode 100644 index 0000000..80056aa --- /dev/null +++ b/src/encodeframe.cs @@ -0,0 +1,323 @@ +//----------------------------------------------------------------------------- +// Filename: encodeframe.cs +// +// Description: Port of: +// - vp8/encoder/encodeframe.c +// - vp8/encoder/encodeframe.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 13 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; +using ENTROPY_CONTEXT = System.SByte; + +namespace Vpx.Net +{ + public unsafe static class encodeframe + { + // Activity masking constants + private const int VP8_ACTIVITY_AVG_MIN = 64; + private const int ALT_ACT_MEASURE = 1; + private const int ACT_MEDIAN = 0; + + // Reference offset for variance calculation + private static readonly byte[] VP8_VAR_OFFS = new byte[16] + { + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128 + }; + + #region Activity Masking + + /// + /// Original activity measure from Tim T's code. + /// Measures the variance of the current macroblock for activity masking. + /// + private static uint tt_activity_measure(VP8_COMP cpi, MACROBLOCK x) + { + uint act; + uint sse; + + // TODO: Compute 16x16 variance of source block + // act = vpx_variance16x16(x->src.y_buffer, x->src.y_stride, VP8_VAR_OFFS, 0, &sse); + act = 0; // Placeholder + act = act << 4; + + // If the region is flat, lower the activity some more + if (act < 8 << 12) + act = act < 5 << 12 ? act : (uint)(5 << 12); + + return act; + } + + /// + /// Alternative experimental activity measure. + /// + private static uint alt_activity_measure(VP8_COMP cpi, MACROBLOCK x, int use_dc_pred) + { + // TODO: Implement alternative activity measure using intra prediction + // return vp8_encode_intra(cpi, x, use_dc_pred); + return 0; // Placeholder + } + + /// + /// Measure the activity of the current macroblock. + /// Used for activity-based adaptive quantization. + /// + private static uint mb_activity_measure(VP8_COMP cpi, MACROBLOCK x, int mb_row, int mb_col) + { + uint mb_activity; + + if (ALT_ACT_MEASURE != 0) + { + int use_dc_pred = ((mb_col != 0) || (mb_row != 0)) && ((mb_col == 0) || (mb_row == 0)) ? 1 : 0; + // Use alternative activity measure + mb_activity = alt_activity_measure(cpi, x, use_dc_pred); + } + else + { + // Original activity measure + mb_activity = tt_activity_measure(cpi, x); + } + + if (mb_activity < VP8_ACTIVITY_AVG_MIN) + mb_activity = VP8_ACTIVITY_AVG_MIN; + + return mb_activity; + } + + /// + /// Calculate an average mb activity value for the frame. + /// + private static void calc_av_activity(VP8_COMP cpi, long activity_sum) + { + // TODO: Calculate average activity for frame + // Used for activity-based adaptive quantization + // cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs); + } + + /// + /// Apply activity masking to adjust quantization parameters. + /// Adjust zbin values based on macroblock activity to improve visual quality. + /// + public static void vp8_activity_masking(VP8_COMP cpi, MACROBLOCK x) + { + // TODO: Implement activity masking + // - Get activity value for current MB from activity map + // - Calculate adjustment factor based on activity vs average + // - Adjust zbin values in x->block[i].zbin_extra + // - Lower activity MBs get higher quantization (more compression) + // - Higher activity MBs get lower quantization (preserve detail) + } + + #endregion + + #region Macroblock Setup + + /// + /// Build block offsets for a macroblock. + /// Sets up pointer offsets for all blocks (Y, U, V) in the macroblock. + /// + public static void vp8_build_block_offsets(MACROBLOCK x) + { + // TODO: Setup block offsets + // - Calculate offsets for 16 Y blocks (4x4 each) + // - Calculate offsets for 4 U blocks (4x4 each) + // - Calculate offsets for 4 V blocks (4x4 each) + // These offsets are relative to the MB base pointer + } + + /// + /// Setup block pointers for a macroblock. + /// Initialize src, pred, diff pointers for all blocks in the macroblock. + /// + public static void vp8_setup_block_ptrs(MACROBLOCK x) + { + // TODO: Setup block pointers + // For each of the 24 blocks in a macroblock: + // - Set src pointer to source image data + // - Set pred pointer to prediction buffer + // - Set diff pointer to difference buffer + // - Set coeff pointer to coefficient buffer + // - Set quant pointer to quantization data + } + + #endregion + + #region Macroblock Encoding + + /// + /// Encode an INTRA macroblock. + /// Performs intra prediction, DCT, quantization, and tokenization. + /// + /// Rate (bits) used to encode the macroblock + public static int vp8cx_encode_intra_macroblock(VP8_COMP cpi, MACROBLOCK x, ref TOKENEXTRA t) + { + // TODO: Implement intra MB encoding + // 1. Perform intra prediction based on selected mode + // - For Y: DC_PRED, V_PRED, H_PRED, TM_PRED, or B_PRED (4x4) + // - For UV: DC_PRED, V_PRED, H_PRED, TM_PRED + // 2. Compute residual (src - pred) + // 3. Apply DCT transform + // 4. Quantize coefficients + // 5. Inverse quantize and IDCT for reconstruction + // 6. Tokenize coefficients for entropy coding + // 7. Update mode context and statistics + + return 0; // Return rate + } + + /// + /// Encode an INTER macroblock. + /// Performs motion compensation, DCT, quantization, and tokenization. + /// + /// Rate (bits) used to encode the macroblock + public static int vp8cx_encode_inter_macroblock(VP8_COMP cpi, MACROBLOCK x, ref TOKENEXTRA t, + int recon_yoffset, int recon_uvoffset, + int mb_row, int mb_col) + { + // TODO: Implement inter MB encoding + // 1. Perform motion compensation using selected MV and reference frame + // - Get prediction from reference frame at MV location + // 2. Compute residual (src - pred) + // 3. Apply DCT transform + // 4. Quantize coefficients + // 5. Inverse quantize and IDCT for reconstruction + // 6. Tokenize coefficients for entropy coding + // 7. Check for skipped MB (all coefficients quantize to zero) + // 8. Update motion vector context and statistics + + return 0; // Return rate + } + + /// + /// Encode a single macroblock (dispatch to intra or inter). + /// + private static void encode_macroblock(VP8_COMP cpi, MACROBLOCK x, ref TOKENEXTRA t, + int recon_yoffset, int recon_uvoffset, + int mb_row, int mb_col) + { + // TODO: Dispatch to appropriate encoding function + // - Check if current MB is intra or inter mode + // - Call vp8cx_encode_intra_macroblock or vp8cx_encode_inter_macroblock + // - Update reconstruction buffers + // - Update mode and coefficient statistics + } + + #endregion + + #region Frame Encoding + + /// + /// Encode a row of macroblocks. + /// + private static void encode_mb_row(VP8_COMP cpi, MACROBLOCK x, int mb_row, ref TOKENEXTRA tp) + { + // TODO: Encode one row of macroblocks + // For each MB in the row (mb_col = 0 to mb_cols-1): + // 1. Setup MB pointers and offsets + // 2. Perform mode decision (RD optimization or pickinter) + // 3. Encode the macroblock + // 4. Update loop filter masks + // 5. Move to next MB + } + + /// + /// Main frame encoding function. + /// This is the top-level entry point for encoding a complete frame. + /// + public static void vp8_encode_frame(VP8_COMP cpi) + { + // TODO: Main frame encoding loop + // High-level flow: + // + // 1. Frame Setup + // - Setup frame context (quantization, loop filter, etc.) + // - Initialize token buffers + // - Setup intra prediction border pixels if needed + // - Reset frame statistics + // + // 2. Activity Analysis (if enabled) + // - First pass: measure activity of each MB + // - Calculate average activity + // - Build activity map for adaptive quantization + // + // 3. Encode All Macroblocks + // - For each MB row: + // - For each MB in row: + // * Setup MB context + // * Perform mode decision (RD or non-RD) + // * Encode MB (transform, quantize, tokenize) + // * Update reconstruction + // * Update statistics + // + // 4. Frame Finalization + // - Update probability tables + // - Calculate rate and distortion + // - Update encoder state + // + // Key decisions made during encoding: + // - Intra vs Inter mode + // - For Intra: prediction mode (DC, V, H, TM, B_PRED) + // - For Inter: reference frame, motion vector, sub-pixel position + // - Quantization parameters (if activity masking enabled) + // - Skip flag (if residual is small enough) + // + // This function coordinates the entire encoding process and is called + // once per frame from the rate control loop. + + // TODO: Implement full frame encoding pipeline + // This is a large function (~400 lines in C) that needs to be + // broken down into the steps outlined above. + } + + #endregion + + #region Helper Functions + + /// + /// Adjust zbin values based on activity. + /// + private static void adjust_act_zbin(VP8_COMP cpi, MACROBLOCK x) + { + // TODO: Adjust quantizer zero-bin based on activity + // Called during activity masking to fine-tune quantization + } + + /// + /// Sum intra stats for the frame. + /// + private static void sum_intra_stats(VP8_COMP cpi, MACROBLOCK x) + { + // TODO: Accumulate intra mode statistics + // Used for probability updates and mode analysis + } + + /// + /// Setup block dequant values. + /// + private static void setup_block_dptrs(MACROBLOCKD x) + { + // TODO: Setup dequant pointers for all blocks in MB + } + + #endregion + } +} diff --git a/src/encodeintra.cs b/src/encodeintra.cs new file mode 100644 index 0000000..536bf8d --- /dev/null +++ b/src/encodeintra.cs @@ -0,0 +1,100 @@ +//----------------------------------------------------------------------------- +// Filename: encodeintra.cs +// +// Description: Port of: +// - vp8/encoder/encodeintra.c +// - vp8/encoder/encodeintra.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 13 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; + +namespace Vpx.Net +{ + public unsafe static class encodeintra + { + /// + /// Encode a macroblock as intra. + /// + /// VP8 compressor instance + /// Macroblock to encode + /// If true, use DC_PRED mode for 16x16; + /// otherwise use 4x4 modes + /// Intra prediction variance + public static int vp8_encode_intra(VP8_COMP cpi, MACROBLOCK x, int use_dc_pred) + { + // TODO: Implement full intra encoding + // This requires proper encoder context setup + return 0; + } + + /// + /// Encode a single 4x4 intra block. + /// + public static void vp8_encode_intra4x4block(MACROBLOCK x, int ib) + { + // TODO: Implement 4x4 intra block encoding + // This requires: + // 1. Intra prediction + // 2. Subtract prediction from source + // 3. Forward DCT + // 4. Quantization + // 5. Inverse DCT and reconstruction + } + + /// + /// Encode all 16 4x4 blocks in a macroblock using intra prediction. + /// + public static void vp8_encode_intra4x4mby(MACROBLOCK mb) + { + // TODO: Implement 4x4 intra macroblock encoding + // This requires proper block iteration and prediction + } + + /// + /// Encode 16x16 intra macroblock Y component. + /// + public static void vp8_encode_intra16x16mby(MACROBLOCK x) + { + // TODO: Implement 16x16 intra Y encoding + // This requires: + // 1. Build intra predictors + // 2. Subtract prediction + // 3. Transform + // 4. Quantize + // 5. Optional optimization + } + + /// + /// Encode 16x16 intra macroblock UV components. + /// + public static void vp8_encode_intra16x16mbuv(MACROBLOCK x) + { + // TODO: Implement 16x16 intra UV encoding + // This requires: + // 1. Build intra predictors for U and V + // 2. Subtract prediction + // 3. Transform + // 4. Quantize + // 5. Optional optimization + } + } +} diff --git a/src/encodemb.cs b/src/encodemb.cs new file mode 100644 index 0000000..289ab94 --- /dev/null +++ b/src/encodemb.cs @@ -0,0 +1,225 @@ +//----------------------------------------------------------------------------- +// Filename: encodemb.cs +// +// Description: Port of: +// - vp8/encoder/encodemb.c +// - vp8/encoder/encodemb.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 13 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; +using ENTROPY_CONTEXT = System.SByte; + +namespace Vpx.Net +{ + public unsafe static class encodemb + { + // RD optimization multipliers + private const int Y1_RD_MULT = 4; + private const int UV_RD_MULT = 2; + private const int Y2_RD_MULT = 16; + + private static readonly int[] plane_rd_mult = new int[4] + { + Y1_RD_MULT, Y2_RD_MULT, UV_RD_MULT, Y1_RD_MULT + }; + + private struct vp8_token_state + { + public int rate; + public int error; + public sbyte next; + public sbyte token; + public short qc; + } + + /// + /// Subtract a 4x4 block. + /// + public static void vp8_subtract_b(BLOCK* be, BLOCKD* bd, int pitch) + { + // TODO: Implement block subtraction + // vpx_subtract_block(4, 4, diff_ptr, pitch, src_ptr, src_stride, pred_ptr, pitch); + } + + /// + /// Subtract macroblock UV components. + /// + public static void vp8_subtract_mbuv(short* diff, byte* usrc, byte* vsrc, + int src_stride, byte* upred, + byte* vpred, int pred_stride) + { + // TODO: Implement UV subtraction + // vpx_subtract_block(8, 8, udiff, 8, usrc, src_stride, upred, pred_stride); + // vpx_subtract_block(8, 8, vdiff, 8, vsrc, src_stride, vpred, pred_stride); + } + + /// + /// Subtract macroblock Y component. + /// + public static void vp8_subtract_mby(short* diff, byte* src, int src_stride, + byte* pred, int pred_stride) + { + // TODO: Implement Y subtraction + // vpx_subtract_block(16, 16, diff, 16, src, src_stride, pred, pred_stride); + } + + /// + /// Subtract entire macroblock (Y + U + V). + /// + private static void vp8_subtract_mb(MACROBLOCK x) + { + // TODO: Implement full macroblock subtraction + } + + /// + /// Build DC block from 16 Y DC values. + /// + public static void vp8_build_dcblock(MACROBLOCK x) + { + // TODO: Implement DC block building + // Extract DC coefficients from 16 Y blocks + } + + /// + /// Transform macroblock UV components. + /// + public static void vp8_transform_mbuv(MACROBLOCK x) + { + // TODO: Implement UV transform + // Requires proper function pointer setup in MACROBLOCK + // for (int i = 16; i < 24; i += 2) + // { + // BLOCK* block = &x.block[i]; + // x.short_fdct8x4(block->src_diff, block->coeff, 16); + // } + } + + /// + /// Transform intra macroblock Y component. + /// + public static void vp8_transform_intra_mby(MACROBLOCK x) + { + // TODO: Implement intra Y transform + // Requires proper function pointer setup in MACROBLOCK + // for (int i = 0; i < 16; i += 2) + // { + // BLOCK* block = &x.block[i]; + // x.short_fdct8x4(block->src_diff, block->coeff, 32); + // } + // vp8_build_dcblock(x); + // BLOCK* block24 = &x.block[24]; + // x.short_walsh4x4(block24->src_diff, block24->coeff, 8); + } + + /// + /// Transform macroblock (Y + UV). + /// + public static void vp8_transform_mb(MACROBLOCK x) + { + // TODO: Implement full macroblock transform + // Requires proper function pointer setup in MACROBLOCK + } + + /// + /// Transform macroblock Y only. + /// + private static void transform_mby(MACROBLOCK x) + { + // TODO: Implement Y transform + // Requires proper function pointer setup in MACROBLOCK + } + + /// + /// Optimize a single block using rate-distortion optimization. + /// + private static void optimize_b(MACROBLOCK mb, int ib, int type, + ENTROPY_CONTEXT* a, ENTROPY_CONTEXT* l) + { + // TODO: Implement full RD optimization algorithm + // This is a complex function that performs Viterbi trellis optimization + // to find the best quantized coefficients for a block. + // For now, this is a placeholder that will need the full VP8_COMP context. + } + + /// + /// Check if 2nd order coefficients can be reset to zero. + /// + private static void check_reset_2nd_coeffs(ref MACROBLOCKD x, int type, + ENTROPY_CONTEXT* a, ENTROPY_CONTEXT* l) + { + // TODO: Implement 2nd order coefficient check + // This requires accessing BLOCKD array and dqcoeff + } + + /// + /// Optimize entire macroblock. + /// + private static void optimize_mb(MACROBLOCK x) + { + // TODO: Implement full macroblock optimization + // This requires the token_costs and other context from VP8_COMP + } + + /// + /// Optimize macroblock Y component. + /// + public static void vp8_optimize_mby(MACROBLOCK x) + { + // TODO: Implement Y optimization + // This is a placeholder for now + } + + /// + /// Optimize macroblock UV components. + /// + public static void vp8_optimize_mbuv(MACROBLOCK x) + { + // TODO: Implement UV optimization + // This is a placeholder for now + } + + /// + /// Encode inter 16x16 macroblock. + /// + public static void vp8_encode_inter16x16(MACROBLOCK x) + { + // TODO: Implement inter 16x16 encoding + // reconinter.vp8_build_inter_predictors_mb(ref x.e_mbd); + // vp8_subtract_mb(x); + // vp8_transform_mb(x); + // vp8_quantize_mb(x); + // if (x.optimize != 0) + // { + // optimize_mb(x); + // } + } + + /// + /// Encode inter 16x16 Y only (used by first pass). + /// + public static void vp8_encode_inter16x16y(MACROBLOCK x) + { + // TODO: Implement inter 16x16 Y encoding + // This is used by first pass encoding + } + } +} diff --git a/src/encodemv.cs b/src/encodemv.cs new file mode 100644 index 0000000..76545db --- /dev/null +++ b/src/encodemv.cs @@ -0,0 +1,177 @@ +//----------------------------------------------------------------------------- +// Filename: encodemv.cs +// +// Description: Port of: +// - vp8/encoder/encodemv.h +// - vp8/encoder/encodemv.c +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 17 Feb 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using vp8_prob = System.Byte; +using vp8_writer = Vpx.Net.BOOL_CODER; + +namespace Vpx.Net +{ + /// + /// Motion vector encoding for VP8 encoder. + /// NOTE: This is a skeleton implementation. Full encoder support requires + /// complete porting of VP8_COMP, MACROBLOCK structures and related encoder infrastructure. + /// + public unsafe static class encodemv + { + private const int MV_PROB_UPDATE_CORRECTION = -1; + + /// + /// Encode a single motion vector component. + /// + private static void encode_mvcomponent(ref vp8_writer w, int v, MV_CONTEXT mvc) + { + vp8_prob* p = stackalloc vp8_prob[(int)MV_ENUM.MVPcount]; + for (int i = 0; i < (int)MV_ENUM.MVPcount; i++) + { + p[i] = mvc.prob[i]; + } + + int x = v < 0 ? -v : v; + + if (x < (int)MV_ENUM.mvnum_short) + { + treewriter.vp8_write(ref w, 0, p[(int)MV_ENUM.mvpis_short]); + treewriter.vp8_treed_write(ref w, entropymode.vp8_small_mvtree, + p + (int)MV_ENUM.MVPshort, x, 3); + + if (x == 0) return; + } + else + { + int i = 0; + + treewriter.vp8_write(ref w, 1, p[(int)MV_ENUM.mvpis_short]); + + do + { + treewriter.vp8_write(ref w, (x >> i) & 1, p[(int)MV_ENUM.MVPbits + i]); + } while (++i < 3); + + i = (int)MV_ENUM.mvlong_width - 1; + + do + { + treewriter.vp8_write(ref w, (x >> i) & 1, p[(int)MV_ENUM.MVPbits + i]); + } while (--i > 3); + + if ((x & 0xFFF0) != 0) + { + treewriter.vp8_write(ref w, (x >> 3) & 1, p[(int)MV_ENUM.MVPbits + 3]); + } + } + + treewriter.vp8_write(ref w, v < 0 ? 1 : 0, p[(int)MV_ENUM.MVPsign]); + } + + /// + /// Encode a motion vector. + /// + public static void vp8_encode_motion_vector(ref vp8_writer w, ref int_mv mv, MV_CONTEXT[] mvc) + { + encode_mvcomponent(ref w, mv.as_mv.row >> 1, mvc[0]); + encode_mvcomponent(ref w, mv.as_mv.col >> 1, mvc[1]); + } + + /// + /// Calculate the cost of encoding a motion vector component. + /// + private static uint cost_mvcomponent(int v, MV_CONTEXT mvc) + { + vp8_prob* p = stackalloc vp8_prob[(int)MV_ENUM.MVPcount]; + for (int i = 0; i < (int)MV_ENUM.MVPcount; i++) + { + p[i] = mvc.prob[i]; + } + + int x = v; + uint cost; + + if (x < (int)MV_ENUM.mvnum_short) + { + cost = treewriter.vp8_cost_zero(p[(int)MV_ENUM.mvpis_short]) + + (uint)treewriter.vp8_treed_cost(entropymode.vp8_small_mvtree, + p + (int)MV_ENUM.MVPshort, x, 3); + + if (x == 0) return cost; + } + else + { + int i = 0; + cost = treewriter.vp8_cost_one(p[(int)MV_ENUM.mvpis_short]); + + do + { + cost += treewriter.vp8_cost_bit(p[(int)MV_ENUM.MVPbits + i], (x >> i) & 1); + } while (++i < 3); + + i = (int)MV_ENUM.mvlong_width - 1; + + do + { + cost += treewriter.vp8_cost_bit(p[(int)MV_ENUM.MVPbits + i], (x >> i) & 1); + } while (--i > 3); + + if ((x & 0xFFF0) != 0) + { + cost += treewriter.vp8_cost_bit(p[(int)MV_ENUM.MVPbits + 3], (x >> 3) & 1); + } + } + + return cost; + } + + /// + /// Build motion vector cost table for rate-distortion optimization. + /// NOTE: Requires complete MACROBLOCK structure. + /// + public static void vp8_build_component_cost_table(int*[] mvcost, MV_CONTEXT[] mvc, int[] mvc_flag) + { + systemdependent.vpx_clear_system_state(); + + // Skeleton implementation + // Full implementation requires proper mvcost array handling + if (mvc_flag[0] != 0) + { + // Build costs for row component + } + + if (mvc_flag[1] != 0) + { + // Build costs for column component + } + } + + /// + /// Write motion vector probabilities to bitstream. + /// NOTE: Requires complete VP8_COMP structure. + /// + // public static void vp8_write_mvprobs(VP8_COMP cpi) + // { + // // Full implementation requires complete VP8_COMP structure + // } + } +} diff --git a/src/entropy.cs b/src/entropy.cs index 724bbbc..978fd92 100644 --- a/src/entropy.cs +++ b/src/entropy.cs @@ -61,6 +61,11 @@ position within the 4x4 DCT. */ //const int vp8_mb_feature_data_bits[MB_LVL_MAX] = { 7, 6 }; public static readonly int[] vp8_mb_feature_data_bits = { 7, 6 }; + public static readonly int[] vp8_default_zig_zag1d = new int[16] + { + 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 + }; + public static void vp8_default_coef_probs(VP8_COMMON pc) { //memcpy(pc->fc.coef_probs, default_coef_probs, sizeof(default_coef_probs)); diff --git a/src/entropymode.cs b/src/entropymode.cs index 2b1d37b..1fcd826 100644 --- a/src/entropymode.cs +++ b/src/entropymode.cs @@ -79,6 +79,12 @@ public static class entropymode public static readonly vp8_tree_index[] vp8_small_mvtree = { 2, 8, 4, 6, -0, -1, -2, -3, 10, 12, -4, -5, -6, -7 }; + public static readonly vp8_token[] vp8_small_mvencodings = new vp8_token[8] + { + new vp8_token(0, 3), new vp8_token(1, 3), new vp8_token(2, 3), new vp8_token(3, 3), + new vp8_token(4, 3), new vp8_token(5, 3), new vp8_token(6, 3), new vp8_token(7, 3) + }; + public static readonly vp8_tree_index[] vp8_bmode_tree = /* INTRAMODECONTEXTNODE value */ { -1 * (int)B_PREDICTION_MODE.B_DC_PRED, 2, /* 0 = DC_NODE */ diff --git a/src/mcomp.cs b/src/mcomp.cs new file mode 100644 index 0000000..efd4501 --- /dev/null +++ b/src/mcomp.cs @@ -0,0 +1,425 @@ +//----------------------------------------------------------------------------- +// Filename: mcomp.cs +// +// Description: Port of: +// - vp8/encoder/mcomp.c +// - vp8/encoder/mcomp.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 13 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; + +namespace Vpx.Net +{ + public unsafe static class mcomp + { + // Motion search constants + public const int MAX_MVSEARCH_STEPS = 8; + public const int MAX_FULL_PEL_VAL = ((1 << MAX_MVSEARCH_STEPS) - 1); + public const int MAX_FIRST_STEP = (1 << (MAX_MVSEARCH_STEPS - 1)); + + #region Motion Vector Costing + + /// + /// Calculate bit cost of a motion vector. + /// Used to factor MV cost into rate-distortion optimization. + /// + public static int vp8_mv_bit_cost(ref int_mv mv, ref int_mv @ref, int** mvcost, int Weight) + { + // TODO: Calculate MV bit cost + // - Compute difference between mv and ref + // - Look up cost in mvcost tables (row and col) + // - Apply weight factor + // - Return weighted cost + // + // MV costing is based on the distribution of vectors in the previous + // frame and will tend to over-state the cost. The Weight parameter + // allows some account to be taken of prediction quality effects. + + return 0; // Placeholder + } + + /// + /// Calculate MV error cost (internal version with error_per_bit). + /// + private static int mv_err_cost(ref int_mv mv, ref int_mv @ref, int** mvcost, int error_per_bit) + { + // TODO: Calculate MV error cost + // Similar to vp8_mv_bit_cost but uses error_per_bit for RD optimization + // Returns 0 if mvcost is NULL + return 0; + } + + /// + /// Calculate MV SAD error cost (used for integer-pel search). + /// + private static int mvsad_err_cost(ref int_mv mv, ref int_mv @ref, int** mvsadcost, int error_per_bit) + { + // TODO: Calculate MV SAD cost + // Used during integer-pel motion search + // Returns 0 if mvsadcost is NULL + return 0; + } + + #endregion + + #region Search Site Initialization + + /// + /// Initialize diamond search motion compensation offsets. + /// Sets up 4-point diamond pattern search sites. + /// + public static void vp8_init_dsmotion_compensation(MACROBLOCK x, int stride) + { + // TODO: Initialize diamond search sites + // Generate offsets for 4 search sites per step: + // - North (0, -Len) + // - South (0, +Len) + // - West (-Len, 0) + // - East (+Len, 0) + // + // Start with Len = MAX_FIRST_STEP and halve each iteration + // Store in x->ss array with MV and buffer offset + // Set x->ss_count and x->searches_per_step + } + + /// + /// Initialize 8-point motion compensation offsets. + /// Sets up 8-point (3-step) search pattern sites. + /// + public static void vp8_init3smotion_compensation(MACROBLOCK x, int stride) + { + // TODO: Initialize 8-point search sites + // Generate offsets for 8 search sites per step: + // - 4 cardinal directions (N, S, E, W) + // - 4 diagonal directions (NE, NW, SE, SW) + // + // Start with Len = MAX_FIRST_STEP and halve each iteration + // Store in x->ss array with MV and buffer offset + // Set x->ss_count and x->searches_per_step + } + + #endregion + + #region Sub-Pixel Motion Search + + /// + /// Find best sub-pixel position iteratively. + /// Refines integer-pel MV to 1/4-pel accuracy using iterative search. + /// + public static int vp8_find_best_sub_pixel_step_iteratively( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv bestmv, ref int_mv ref_mv, + int error_per_bit, + /*vp8_variance_fn_ptr_t*/ IntPtr vfp, + int** mvcost, ref int distortion, ref uint sse) + { + // TODO: Implement iterative sub-pixel search + // + // Flow: + // 1. Start from integer-pel best MV + // 2. For each refinement level (1/2-pel, then 1/4-pel): + // - Test 8 surrounding positions + // - Calculate variance/sad at each position + // - Add MV cost to get total RD cost + // - Keep best position + // 3. Return best sub-pixel RD cost + // + // This is the high-quality sub-pel search used for RD optimization. + + distortion = 0; + sse = 0; + return 0; // Return best RD cost + } + + /// + /// Find best sub-pixel position (faster version). + /// Refines to 1/4-pel using direct computation. + /// + public static int vp8_find_best_sub_pixel_step( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv bestmv, ref int_mv ref_mv, + int error_per_bit, + /*vp8_variance_fn_ptr_t*/ IntPtr vfp, + int** mvcost, ref int distortion, ref uint sse) + { + // TODO: Implement fast sub-pixel search + // Similar to iterative version but uses optimized approach + // May test fewer positions or use different search pattern + + distortion = 0; + sse = 0; + return 0; + } + + /// + /// Find best half-pixel position only. + /// Refines integer MV to 1/2-pel accuracy (skips 1/4-pel). + /// + public static int vp8_find_best_half_pixel_step( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv bestmv, ref int_mv ref_mv, + int error_per_bit, + /*vp8_variance_fn_ptr_t*/ IntPtr vfp, + int** mvcost, ref int distortion, ref uint sse) + { + // TODO: Implement half-pixel search + // Only refine to 1/2-pel, skip 1/4-pel step + // Used for faster encoding modes + + distortion = 0; + sse = 0; + return 0; + } + + /// + /// Skip fractional MV search (use integer-pel only). + /// + public static int vp8_skip_fractional_mv_step( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv bestmv, ref int_mv ref_mv, + int error_per_bit, + /*vp8_variance_fn_ptr_t*/ IntPtr vfp, + int** mvcost, ref int distortion, ref uint sse) + { + // No sub-pixel refinement + // Just return cost of integer-pel MV + distortion = 0; + sse = 0; + return 0; + } + + #endregion + + #region Integer-Pel Motion Search + + /// + /// Hexagon search pattern. + /// Uses hex pattern for efficient motion search. + /// + public static int vp8_hex_search( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, ref int_mv best_mv, + int search_param, int sad_per_bit, + /*vp8_variance_fn_ptr_t*/ IntPtr vfp, + int** mvsadcost, ref int_mv center_mv) + { + // TODO: Implement hexagon search + // + // Hex search uses a hexagonal pattern: + // 1 + // 6 2 + // 5 3 + // 4 + // + // Algorithm: + // 1. Start from predicted MV (ref_mv) + // 2. Test 6 hex points around center + // 3. If better point found, move center and repeat + // 4. When no improvement, try smaller hex + // 5. Return best SAD + MV cost + + return 0; // Return best SAD + } + + /// + /// Diamond search pattern (C reference version). + /// Uses diamond pattern for motion search. + /// + public static int vp8_diamond_search_sad_c( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, ref int_mv best_mv, + int search_param, int sad_per_bit, ref int num00, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement diamond search + // + // Diamond pattern: + // 1 + // 4 2 + // 3 + // + // Algorithm: + // 1. Start from predicted MV + // 2. Test 4 diamond points + // 3. Move to best point and repeat + // 4. When center is best (num00), reduce step size + // 5. Continue until step size = 1 + // 6. Return best SAD + MV cost + + num00 = 0; + return 0; // Return best SAD + } + + /// + /// Diamond search with SADX4 optimization. + /// Uses SIMD to test 4 points simultaneously. + /// + public static int vp8_diamond_search_sadx4( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, ref int_mv best_mv, + int search_param, int sad_per_bit, ref int num00, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement SIMD-optimized diamond search + // Similar to diamond_search_sad_c but computes 4 SADs in parallel + // Requires SIMD/vectorization support + + num00 = 0; + return 0; + } + + /// + /// Full-pixel exhaustive search (C reference version). + /// Searches all positions in a square region. + /// + public static int vp8_full_search_sad_c( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, int sad_per_bit, int distance, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement full search + // + // Exhaustive search: + // 1. Define square search region around predicted MV + // Size = [-distance, +distance] in each direction + // 2. Test every integer position in region + // 3. Calculate SAD + MV cost for each + // 4. Keep track of best position + // 5. Return best SAD + cost + // + // This is the slowest but most thorough search method. + // Used for first pass or when quality is critical. + + return 0; // Return best SAD + } + + /// + /// Full search with SADX3 optimization. + /// Uses SIMD to test 3 positions simultaneously. + /// + public static int vp8_full_search_sadx3( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, int sad_per_bit, int distance, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement SIMD-optimized full search (3-wide) + // Process 3 positions per iteration using SIMD + return 0; + } + + /// + /// Full search with SADX8 optimization. + /// Uses SIMD to test 8 positions simultaneously. + /// + public static int vp8_full_search_sadx8( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, int sad_per_bit, int distance, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement SIMD-optimized full search (8-wide) + // Process 8 positions per iteration using wide SIMD + // Fastest full search variant + return 0; + } + + /// + /// Refining search around best MV (C reference version). + /// Small local search around a good MV candidate. + /// + public static int vp8_refining_search_sad_c( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, int sad_per_bit, int distance, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement refining search + // + // Refinement search: + // 1. Start from a good MV candidate + // 2. Search small region around it (usually ±1 or ±2) + // 3. Test all positions in refined region + // 4. Return best SAD + cost + // + // Used after coarse search to fine-tune the result. + + return 0; // Return best SAD + } + + /// + /// Refining search with SADX4 optimization. + /// + public static int vp8_refining_search_sadx4( + MACROBLOCK x, BLOCK b, BLOCKD d, + ref int_mv ref_mv, int sad_per_bit, int distance, + /*vp8_variance_fn_ptr_t*/ IntPtr fn_ptr, + int** mvcost, ref int_mv center_mv) + { + // TODO: Implement SIMD-optimized refining search + // Process 4 positions at a time + return 0; + } + + #endregion + + #region Helper Functions + + /// + /// Clamp MV to valid range. + /// + private static int clamp_mv_to_range(int mv, int min_val, int max_val) + { + if (mv < min_val) return min_val; + if (mv > max_val) return max_val; + return mv; + } + + /// + /// Check if MV is within search bounds. + /// + private static bool mv_is_in_bounds(ref int_mv mv, int mb_row, int mb_col, + int mb_rows, int mb_cols, int border) + { + // TODO: Check if MV points to valid reference location + // Must account for interpolation filter border requirements + return true; + } + + /// + /// Calculate SAD at a given MV position. + /// + private static uint calculate_sad(byte* src, int src_stride, + byte* ref_ptr, int ref_stride, + int width, int height) + { + // TODO: Calculate sum of absolute differences + // This will be replaced by optimized variance functions + return 0; + } + + #endregion + } +} diff --git a/src/modecosts.cs b/src/modecosts.cs new file mode 100644 index 0000000..7b297a1 --- /dev/null +++ b/src/modecosts.cs @@ -0,0 +1,112 @@ +//----------------------------------------------------------------------------- +// Filename: modecosts.cs +// +// Description: Port of: +// - modecosts.h +// - modecosts.c +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 17 Feb 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using vp8_prob = System.Byte; + +namespace Vpx.Net +{ + /// + /// Mode cost calculations for encoder rate-distortion optimization. + /// Computes the bit cost of using different prediction modes. + /// + public static class modecosts + { + /// + /// Initialize all mode costs for rate-distortion optimization. + /// Calculates the bit costs for various prediction modes based on probability trees. + /// + /// VP8 encoder context containing the cost structures + public unsafe static void vp8_init_mode_costs(VP8_COMP c) + { + VP8_COMMON x = c.common; + RD_COSTS rd_costs = c.rd_costs; + + // Calculate costs for block prediction modes (B_PRED mode) + // For each possible context (previous block modes) + for (int i = 0; i < blockd.VP8_BINTRAMODES; i++) + { + for (int j = 0; j < blockd.VP8_BINTRAMODES; j++) + { + fixed (vp8_prob* p = vp8_entropymodedata.vp8_kf_bmode_prob) + { + // Get pointer to the probability array for this context + vp8_prob* prob_ptr = p + (i * blockd.VP8_BINTRAMODES * (blockd.VP8_BINTRAMODES - 1)) + + (j * (blockd.VP8_BINTRAMODES - 1)); + + // Calculate costs for all possible block modes in this context + fixed (int* costs = &rd_costs.bmode_costs[i, j, 0]) + { + treewriter.vp8_cost_tokens(costs, prob_ptr, entropymode.vp8_bmode_tree); + } + } + } + } + + // Calculate costs for inter-frame block modes + fixed (vp8_prob* p = x.fc.bmode_prob) + fixed (int* costs = rd_costs.inter_bmode_costs) + { + treewriter.vp8_cost_tokens(costs, p, entropymode.vp8_bmode_tree); + } + + // Calculate costs for sub-MV reference modes + fixed (vp8_prob* p = x.fc.sub_mv_ref_prob) + fixed (int* costs = rd_costs.inter_bmode_costs) + { + treewriter.vp8_cost_tokens(costs, p, entropymode.vp8_sub_mv_ref_tree); + } + + // Calculate costs for macroblock Y mode (inter-frame) + fixed (vp8_prob* p = x.fc.ymode_prob) + fixed (int* costs = &rd_costs.mbmode_cost[1, 0]) + { + treewriter.vp8_cost_tokens(costs, p, entropymode.vp8_ymode_tree); + } + + // Calculate costs for macroblock Y mode (keyframe) + fixed (vp8_prob* p = vp8_entropymodedata.vp8_kf_ymode_prob) + fixed (int* costs = &rd_costs.mbmode_cost[0, 0]) + { + treewriter.vp8_cost_tokens(costs, p, entropymode.vp8_kf_ymode_tree); + } + + // Calculate costs for UV (chroma) mode (inter-frame) + fixed (vp8_prob* p = x.fc.uv_mode_prob) + fixed (int* costs = &rd_costs.intra_uv_mode_cost[1, 0]) + { + treewriter.vp8_cost_tokens(costs, p, entropymode.vp8_uv_mode_tree); + } + + // Calculate costs for UV (chroma) mode (keyframe) + fixed (vp8_prob* p = vp8_entropymodedata.vp8_kf_uv_mode_prob) + fixed (int* costs = &rd_costs.intra_uv_mode_cost[0, 0]) + { + treewriter.vp8_cost_tokens(costs, p, entropymode.vp8_uv_mode_tree); + } + } + } +} diff --git a/src/onyxe_int.cs b/src/onyxe_int.cs new file mode 100644 index 0000000..8dd6dd8 --- /dev/null +++ b/src/onyxe_int.cs @@ -0,0 +1,723 @@ +//----------------------------------------------------------------------------- +// Filename: onyxe_int.cs +// +// Description: Port of: +// - vp8/encoder/onyx_int.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 09 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; +using vp8_prob = System.Byte; +using vpx_rational = Vpx.Net.vpx_rational_t; +using vp8_writer = Vpx.Net.BOOL_CODER; + +namespace Vpx.Net +{ + public static class onyxe_int + { + public const int MIN_GF_INTERVAL = 4; + public const int DEFAULT_GF_INTERVAL = 7; + public const int KEY_FRAME_CONTEXT = 5; + public const int MAX_LAG_BUFFERS = 25; + public const int AF_THRESH = 25; + public const int AF_THRESH2 = 100; + public const int ARF_DECAY_THRESH = 12; + public const int MIN_THRESHMULT = 32; + public const int MAX_THRESHMULT = 512; + public const int GF_ZEROMV_ZBIN_BOOST = 12; + public const int LF_ZEROMV_ZBIN_BOOST = 6; + public const int MV_ZBIN_BOOST = 4; + public const int ZBIN_OQ_MAX = 192; + public const int TICKS_PER_SEC = 10000000; + } + + public class CODING_CONTEXT + { + public int kf_indicated; + public uint frames_since_key; + public uint frames_since_golden; + public int filter_level; + public int frames_till_gf_update_due; + public int[] recent_ref_frame_usage = new int[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + + public MV_CONTEXT[] mvc = new MV_CONTEXT[2]; + public int[,] mvcosts = new int[2, (int)MV_ENUM.MVvals + 1]; + + public vp8_prob[] ymode_prob = new vp8_prob[4]; + public vp8_prob[] uv_mode_prob = new vp8_prob[3]; + public vp8_prob[] kf_ymode_prob = new vp8_prob[4]; + public vp8_prob[] kf_uv_mode_prob = new vp8_prob[3]; + + public int[] ymode_count = new int[5]; + public int[] uv_mode_count = new int[4]; + + public int[] count_mb_ref_frame_usage = new int[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + + public int this_frame_percent_intra; + public int last_frame_percent_intra; + + public CODING_CONTEXT() + { + mvc[0] = new MV_CONTEXT(); + mvc[1] = new MV_CONTEXT(); + } + } + + public struct FIRSTPASS_STATS + { + public double frame; + public double intra_error; + public double coded_error; + public double ssim_weighted_pred_err; + public double pcnt_inter; + public double pcnt_motion; + public double pcnt_second_ref; + public double pcnt_neutral; + public double MVr; + public double mvr_abs; + public double MVc; + public double mvc_abs; + public double MVrv; + public double MVcv; + public double mv_in_out_count; + public double new_mv_count; + public double duration; + public double count; + } + + public struct ONEPASS_FRAMESTATS + { + public int frames_so_far; + public double frame_intra_error; + public double frame_coded_error; + public double frame_pcnt_inter; + public double frame_pcnt_motion; + public double frame_mvr; + public double frame_mvr_abs; + public double frame_mvc; + public double frame_mvc_abs; + } + + public enum THR_MODES + { + THR_ZERO1 = 0, + THR_DC = 1, + THR_NEAREST1 = 2, + THR_NEAR1 = 3, + THR_ZERO2 = 4, + THR_NEAREST2 = 5, + THR_ZERO3 = 6, + THR_NEAREST3 = 7, + THR_NEAR2 = 8, + THR_NEAR3 = 9, + THR_V_PRED = 10, + THR_H_PRED = 11, + THR_TM = 12, + THR_NEW1 = 13, + THR_NEW2 = 14, + THR_NEW3 = 15, + THR_SPLIT1 = 16, + THR_SPLIT2 = 17, + THR_SPLIT3 = 18, + THR_B_PRED = 19 + } + + public enum SEARCH_METHODS + { + DIAMOND = 0, + NSTEP = 1, + HEX = 2 + } + + public enum BLOCK_SIZE + { + BLOCK_16X8, + BLOCK_8X16, + BLOCK_8X8, + BLOCK_4X4, + BLOCK_16X16, + BLOCK_MAX_SEGMENTS + } + + public class SPEED_FEATURES + { + public int RD; + public SEARCH_METHODS search_method; + public int improved_quant; + public int improved_dct; + public int auto_filter; + public int recode_loop; + public int iterative_sub_pixel; + public int half_pixel_search; + public int quarter_pixel_search; + public int[] thresh_mult = new int[vp8_block.MAX_MODES]; + public int max_step_search_steps; + public int first_step; + public int optimize_coefficients; + public int use_fastquant_for_pick; + public int no_skip_block4x4_search; + public int improved_mv_pred; + } + + public class LAYER_CONTEXT + { + public double framerate; + public int target_bandwidth; + + public long starting_buffer_level; + public long optimal_buffer_level; + public long maximum_buffer_size; + public long starting_buffer_level_in_ms; + public long optimal_buffer_level_in_ms; + public long maximum_buffer_size_in_ms; + + public int avg_frame_size_for_layer; + + public long buffer_level; + public long bits_off_target; + + public long total_actual_bits; + public int total_target_vs_actual; + + public int worst_quality; + public int active_worst_quality; + public int best_quality; + public int active_best_quality; + + public int ni_av_qi; + public int ni_tot_qi; + public int ni_frames; + public int avg_frame_qindex; + + public double rate_correction_factor; + public double key_frame_rate_correction_factor; + public double gf_rate_correction_factor; + + public int zbin_over_quant; + + public int inter_frame_target; + public long total_byte_count; + + public int filter_level; + + public int frames_since_last_drop_overshoot; + + public int force_maxqp; + + public int last_frame_percent_intra; + + public int[] count_mb_ref_frame_usage = new int[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + + public int[] last_q = new int[2]; + } + + public class TWOPASS_RC + { + public uint section_intra_rating; + public double section_max_qfactor; + public uint next_iiratio; + public uint this_iiratio; + public FIRSTPASS_STATS total_stats; + public FIRSTPASS_STATS this_frame_stats; + public unsafe FIRSTPASS_STATS* stats_in; + public unsafe FIRSTPASS_STATS* stats_in_end; + public unsafe FIRSTPASS_STATS* stats_in_start; + public FIRSTPASS_STATS total_left_stats; + public int first_pass_done; + public long bits_left; + public long clip_bits_total; + public double avg_iiratio; + public double modified_error_total; + public double modified_error_used; + public double modified_error_left; + public double kf_intra_err_min; + public double gf_intra_err_min; + public int frames_to_key; + public int maxq_max_limit; + public int maxq_min_limit; + public int gf_decay_rate; + public int static_scene_max_gf_interval; + public int kf_bits; + public int gf_group_error_left; + public long kf_group_bits; + public long kf_group_error_left64; + public long gf_group_bits; + public int gf_bits; + public int alt_extra_bits; + public double est_max_qcorrection_factor; + } + + public unsafe class VP8_COMP + { + public short[,] Y1quant = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y1quant_shift = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y1zbin = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y1round = new short[VP8_COMMON.QINDEX_RANGE, 16]; + + public short[,] Y2quant = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y2quant_shift = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y2zbin = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y2round = new short[VP8_COMMON.QINDEX_RANGE, 16]; + + public short[,] UVquant = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] UVquant_shift = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] UVzbin = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] UVround = new short[VP8_COMMON.QINDEX_RANGE, 16]; + + public short[,] zrun_zbin_boost_y1 = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] zrun_zbin_boost_y2 = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] zrun_zbin_boost_uv = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y1quant_fast = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] Y2quant_fast = new short[VP8_COMMON.QINDEX_RANGE, 16]; + public short[,] UVquant_fast = new short[VP8_COMMON.QINDEX_RANGE, 16]; + + public MACROBLOCK mb = new MACROBLOCK(); + public VP8_COMMON common = new VP8_COMMON(); + public vp8_writer[] bc = new vp8_writer[9]; + + public VP8_CONFIG oxcf = new VP8_CONFIG(); + + public void* lookahead; + public void* source; + public void* alt_ref_source; + public void* last_source; + + public YV12_BUFFER_CONFIG* Source; + public YV12_BUFFER_CONFIG* un_scaled_source; + public YV12_BUFFER_CONFIG scaled_source; + public YV12_BUFFER_CONFIG* last_frame_unscaled_source; + + public uint frames_till_alt_ref_frame; + public int source_alt_ref_pending; + public int source_alt_ref_active; + public int is_src_frame_alt_ref; + + public int gold_is_last; + public int alt_is_last; + public int gold_is_alt; + + public YV12_BUFFER_CONFIG pick_lf_lvl_frame; + + public TOKENEXTRA* tok; + public uint tok_count; + + public uint frames_since_key; + public uint key_frame_frequency; + public uint this_key_frame_forced; + public uint next_key_frame_forced; + + public int ambient_err; + + public uint[] mode_check_freq = new uint[vp8_block.MAX_MODES]; + public int[] rd_baseline_thresh = new int[vp8_block.MAX_MODES]; + + public int RDMULT; + public int RDDIV; + + public CODING_CONTEXT coding_context = new CODING_CONTEXT(); + + public long last_prediction_error; + public long last_intra_error; + + public int this_frame_target; + public int projected_frame_size; + public int[] last_q = new int[2]; + + public double rate_correction_factor; + public double key_frame_rate_correction_factor; + public double gf_rate_correction_factor; + + public int frames_since_golden; + public int frames_till_gf_update_due; + public int current_gf_interval; + + public int gf_overspend_bits; + public int non_gf_bitrate_adjustment; + public int kf_overspend_bits; + public int kf_bitrate_adjustment; + public int max_gf_interval; + public int baseline_gf_interval; + public int active_arnr_frames; + + public long key_frame_count; + public int[] prior_key_frame_distance = new int[onyxe_int.KEY_FRAME_CONTEXT]; + + public int per_frame_bandwidth; + public int av_per_frame_bandwidth; + public int min_frame_bandwidth; + public int inter_frame_target; + public double output_framerate; + public long last_time_stamp_seen; + public long last_end_time_stamp_seen; + public long first_time_stamp_ever; + + public int ni_av_qi; + public int ni_tot_qi; + public int ni_frames; + public int avg_frame_qindex; + + public long total_byte_count; + + public int buffered_mode; + + public double framerate; + public double ref_framerate; + public long buffer_level; + public long bits_off_target; + + public int rolling_target_bits; + public int rolling_actual_bits; + + public int long_rolling_target_bits; + public int long_rolling_actual_bits; + + public long total_actual_bits; + public int total_target_vs_actual; + + public int worst_quality; + public int active_worst_quality; + public int best_quality; + public int active_best_quality; + + public int cq_target_quality; + + public int drop_frames_allowed; + public int drop_frame; + + public vp8_prob[,,,] frame_coef_probs = new vp8_prob[entropy.BLOCK_TYPES, entropy.COEF_BANDS, + entropy.PREV_COEF_CONTEXTS, entropy.ENTROPY_NODES]; + public sbyte[,,,] update_probs = new sbyte[entropy.BLOCK_TYPES, entropy.COEF_BANDS, + entropy.PREV_COEF_CONTEXTS, entropy.ENTROPY_NODES]; + + public uint[,,,,] frame_branch_ct = new uint[entropy.BLOCK_TYPES, entropy.COEF_BANDS, + entropy.PREV_COEF_CONTEXTS, entropy.ENTROPY_NODES, 2]; + + public int gfu_boost; + public int kf_boost; + public int last_boost; + + public int target_bandwidth; + public void* output_pkt_list; + + public int decimation_factor; + public int decimation_count; + + public int avg_encode_time; + public int avg_pick_mode_time; + public int Speed; + public int compressor_speed; + + public int auto_gold; + public int auto_adjust_gold_quantizer; + public int auto_worst_q; + public int cpu_used; + public int pass; + + public int prob_intra_coded; + public int prob_last_coded; + public int prob_gf_coded; + public int prob_skip_false; + public int[] last_skip_false_probs = new int[3]; + public int[] last_skip_probs_q = new int[3]; + public int[] recent_ref_frame_usage = new int[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + + public int this_frame_percent_intra; + public int last_frame_percent_intra; + + public int ref_frame_flags; + + public SPEED_FEATURES sf = new SPEED_FEATURES(); + + public int zeromv_count; + public int lf_zeromv_pct; + + public byte* skin_map; + + public byte* segmentation_map; + public sbyte[,] segment_feature_data = new sbyte[(int)MB_LVL_FEATURES.MB_LVL_MAX, + blockd.MAX_MB_SEGMENTS]; + public int[] segment_encode_breakout = new int[blockd.MAX_MB_SEGMENTS]; + + public byte* active_map; + public uint active_map_enabled; + + public int cyclic_refresh_mode_enabled; + public int cyclic_refresh_mode_max_mbs_perframe; + public int cyclic_refresh_mode_index; + public int cyclic_refresh_q; + public sbyte* cyclic_refresh_map; + public byte* consec_zero_last; + public byte* consec_zero_last_mvbias; + + public uint temporal_pattern_counter; + public int temporal_layer_id; + + public int mse_source_denoised; + + public int force_maxqp; + public int frames_since_last_drop_overshoot; + public int last_pred_err_mb; + + public int gf_update_onepass_cbr; + public int gf_interval_onepass_cbr; + public int gf_noboost_onepass_cbr; + + public TOKENLIST* tplist; + public uint[] partition_sz = new uint[onyx.MAX_PARTITIONS]; + public byte*[] partition_d = new byte*[onyx.MAX_PARTITIONS]; + public byte*[] partition_d_end = new byte*[onyx.MAX_PARTITIONS]; + + public void* find_fractional_mv_step; + public void* full_search_sad; + public void* refining_search_sad; + public void* diamond_search_sad; + public void*[] fn_ptr = new void*[(int)BLOCK_SIZE.BLOCK_MAX_SEGMENTS]; + public ulong time_receive_data; + public ulong time_compress_data; + public ulong time_pick_lpf; + public ulong time_encode_mb_row; + + public int[] base_skip_false_prob = new int[128]; + + public FRAME_CONTEXT lfc_n = new FRAME_CONTEXT(); + public FRAME_CONTEXT lfc_a = new FRAME_CONTEXT(); + public FRAME_CONTEXT lfc_g = new FRAME_CONTEXT(); + + public TWOPASS_RC twopass = new TWOPASS_RC(); + + public YV12_BUFFER_CONFIG alt_ref_buffer; + public YV12_BUFFER_CONFIG*[] frames = new YV12_BUFFER_CONFIG*[onyxe_int.MAX_LAG_BUFFERS]; + public int[] fixed_divide = new int[512]; + + public int b_calculate_psnr; + + public uint activity_avg; + public uint* mb_activity_map; + + public byte* gf_active_flags; + public int gf_active_count; + + public int output_partition; + + public int_mv* lfmv; + public int* lf_ref_frame_sign_bias; + public int* lf_ref_frame; + + public int force_next_frame_intra; + + public int droppable; + + public int initial_width; + public int initial_height; + + public uint current_layer; + public LAYER_CONTEXT[] layer_context = new LAYER_CONTEXT[vpx_encoder.VPX_TS_MAX_LAYERS]; + + public long[] frames_in_layer = new long[vpx_encoder.VPX_TS_MAX_LAYERS]; + public long[] bytes_in_layer = new long[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] sum_psnr = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] sum_psnr_p = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] total_error2 = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] total_error2_p = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] sum_ssim = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] sum_weights = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + + public double[] total_ssimg_y_in_layer = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] total_ssimg_u_in_layer = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] total_ssimg_v_in_layer = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + public double[] total_ssimg_all_in_layer = new double[vpx_encoder.VPX_TS_MAX_LAYERS]; + + public uint[] current_ref_frames = new uint[(int)MV_REFERENCE_FRAME.MAX_REF_FRAMES]; + public MV_REFERENCE_FRAME closest_reference_frame; + + public RD_COSTS rd_costs = new RD_COSTS(); + + public int use_roi_static_threshold; + + public int ext_refresh_frame_flags_pending; + + public VP8_COMP() + { + for (int i = 0; i < bc.Length; i++) + { + bc[i] = new vp8_writer(); + } + + for (int i = 0; i < layer_context.Length; i++) + { + layer_context[i] = new LAYER_CONTEXT(); + } + } + } + + public struct RD_COSTS + { + public int[,] mvcosts; + public int[,] mvsadcosts; + public int[,] mbmode_cost; + public int[,] intra_uv_mode_cost; + public int[,,] bmode_costs; + public int[] inter_bmode_costs; + public int[,,,] token_costs; + } + + public struct TOKENEXTRA + { + public byte token; + public byte extra; + public byte context_tree; + public byte skip_eob_node; + } + + public struct TOKENLIST + { + public unsafe TOKENEXTRA* start; + public unsafe TOKENEXTRA* stop; + } + + public enum VPX_SCALING + { + NORMAL = 0, + FOURFIVE = 1, + THREEFIVE = 2, + ONETWO = 3 + } + + public enum END_USAGE + { + USAGE_LOCAL_FILE_PLAYBACK = 0x0, + USAGE_STREAM_FROM_SERVER = 0x1, + USAGE_CONSTRAINED_QUALITY = 0x2, + USAGE_CONSTANT_QUALITY = 0x3 + } + + public enum MODE + { + MODE_REALTIME = 0x0, + MODE_GOODQUALITY = 0x1, + MODE_BESTQUALITY = 0x2, + MODE_FIRSTPASS = 0x3, + MODE_SECONDPASS = 0x4, + MODE_SECONDPASS_BEST = 0x5 + } + + public enum FRAMETYPE_FLAGS + { + FRAMEFLAGS_KEY = 1, + FRAMEFLAGS_GOLDEN = 2, + FRAMEFLAGS_ALTREF = 4 + } + + public class VP8_CONFIG + { + public int Version; + public int Width; + public int Height; + public vpx_rational timebase; + public uint target_bandwidth; + + public int noise_sensitivity; + + public int Sharpness; + public int cpu_used; + public uint rc_max_intra_bitrate_pct; + public uint gf_cbr_boost_pct; + public uint screen_content_mode; + + public int Mode; + + public int auto_key; + public int key_freq; + + public int allow_lag; + public int lag_in_frames; + + public int end_usage; + + public int under_shoot_pct; + public int over_shoot_pct; + + public long starting_buffer_level; + public long optimal_buffer_level; + public long maximum_buffer_size; + + public long starting_buffer_level_in_ms; + public long optimal_buffer_level_in_ms; + public long maximum_buffer_size_in_ms; + + public int fixed_q; + public int worst_allowed_q; + public int best_allowed_q; + public int cq_level; + + public int allow_spatial_resampling; + public int resample_down_water_mark; + public int resample_up_water_mark; + + public int allow_df; + public int drop_frames_water_mark; + + public int two_pass_vbrbias; + public int two_pass_vbrmin_section; + public int two_pass_vbrmax_section; + + public int play_alternate; + public int alt_freq; + public int alt_q; + public int key_q; + public int gold_q; + + public int multi_threaded; + public int token_partitions; + + public int encode_breakout; + + public uint error_resilient_mode; + + public int arnr_max_frames; + public int arnr_strength; + public int arnr_type; + + public vpx_fixed_buf_t two_pass_stats_in; + public unsafe void* output_pkt_list; + + public vp8e_tuning tuning; + + public uint number_of_layers; + public uint[] target_bitrate = new uint[vpx_encoder.VPX_TS_MAX_PERIODICITY]; + public uint[] rate_decimator = new uint[vpx_encoder.VPX_TS_MAX_PERIODICITY]; + public uint periodicity; + public uint[] layer_id = new uint[vpx_encoder.VPX_TS_MAX_PERIODICITY]; + } + + public struct search_site + { + public MV mv; + public int offset; + } + + public struct MB_ROW_COMP + { + public MACROBLOCK mb; + public int[] segment_counts; + public int totalrate; + } +} diff --git a/src/rdopt.cs b/src/rdopt.cs new file mode 100644 index 0000000..4166e1f --- /dev/null +++ b/src/rdopt.cs @@ -0,0 +1,495 @@ +//----------------------------------------------------------------------------- +// Filename: rdopt.cs +// +// Description: Port of: +// - vp8/encoder/rdopt.c +// - vp8/encoder/rdopt.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 13 Jan 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; +using ENTROPY_CONTEXT = System.SByte; + +namespace Vpx.Net +{ + public unsafe static class rdopt + { + // Rate-distortion cost macro + // RDCOST(RM, DM, R, D) = (((128 + (R) * (RM)) >> 8) + (DM) * (D)) + // RM = Rate multiplier, DM = Distortion multiplier, R = Rate, D = Distortion + private static int RDCOST(int RM, int DM, int R, int D) + { + return (((128 + R * RM) >> 8) + DM * D); + } + + // RD constants for different block types + private const int Y1_RD_MULT = 4; + private const int UV_RD_MULT = 2; + private const int Y2_RD_MULT = 16; + + // Auto speed threshold table + private static readonly int[] auto_speed_thresh = new int[17] + { + 1000, 200, 150, 130, 150, 125, 120, 115, 115, 115, 115, 115, + 115, 115, 115, 115, 105 + }; + + // Mode ordering for RD search + // Defines the order in which prediction modes are tested + // Optimized to test most likely modes first + private static readonly MB_PREDICTION_MODE[] vp8_mode_order = new MB_PREDICTION_MODE[] + { + MB_PREDICTION_MODE.ZEROMV, MB_PREDICTION_MODE.DC_PRED, + MB_PREDICTION_MODE.NEARESTMV, MB_PREDICTION_MODE.NEARMV, + MB_PREDICTION_MODE.ZEROMV, MB_PREDICTION_MODE.NEARESTMV, + MB_PREDICTION_MODE.ZEROMV, MB_PREDICTION_MODE.NEARESTMV, + MB_PREDICTION_MODE.NEARMV, MB_PREDICTION_MODE.NEARMV, + MB_PREDICTION_MODE.V_PRED, MB_PREDICTION_MODE.H_PRED, MB_PREDICTION_MODE.TM_PRED, + MB_PREDICTION_MODE.NEWMV, MB_PREDICTION_MODE.NEWMV, MB_PREDICTION_MODE.NEWMV, + MB_PREDICTION_MODE.SPLITMV, MB_PREDICTION_MODE.SPLITMV, MB_PREDICTION_MODE.SPLITMV, + MB_PREDICTION_MODE.B_PRED + }; + + // Reference frame order corresponding to mode order + private static readonly int[] vp8_ref_frame_order = new int[] + { + 1, 0, 1, 1, 2, 2, 3, 3, 2, 3, + 0, 0, 0, 1, 2, 3, 1, 2, 3, 0 + }; + + #region Helper Structures + + /// + /// Rate and distortion for a mode. + /// + private struct RATE_DISTORTION + { + public int rate2; // Total rate (Y + UV + overhead) + public int rate_y; // Y component rate + public int rate_uv; // UV component rate + public int distortion2; // Total distortion (Y + UV) + public int distortion_uv; // UV distortion + } + + /// + /// Best mode information. + /// + private struct BEST_MODE + { + public int yrd; // Y rate-distortion cost + public int rd; // Total rate-distortion cost + public int intra_rd; // Intra mode RD cost + public MB_MODE_INFO mbmode; // Mode info + // TODO: Add bmodes array for B_PRED + // TODO: Add partition info for SPLITMV + } + + #endregion + + #region Sorting Utilities + + /// + /// Insertion sort for integer array. + /// Used for sorting mode candidates by cost. + /// + public static void insertsortmv(int[] arr, int len) + { + for (int i = 1; i <= len - 1; ++i) + { + for (int j = 0; j < i; ++j) + { + if (arr[j] > arr[i]) + { + int temp = arr[i]; + for (int k = i; k > j; k--) + { + arr[k] = arr[k - 1]; + } + arr[j] = temp; + } + } + } + } + + /// + /// Insertion sort with associated indices. + /// Sorts SAD values while maintaining index correspondence. + /// + public static void insertsortsad(int[] arr, int[] idx, int len) + { + for (int i = 1; i <= len - 1; ++i) + { + for (int j = 0; j < i; ++j) + { + if (arr[j] > arr[i]) + { + int temp = arr[i]; + int tempi = idx[i]; + + for (int k = i; k > j; k--) + { + arr[k] = arr[k - 1]; + idx[k] = idx[k - 1]; + } + + arr[j] = temp; + idx[j] = tempi; + } + } + } + } + + #endregion + + #region RD Initialization + + /// + /// Initialize rate-distortion constants for given Q value. + /// Sets up RD multipliers and cost tables based on quantizer. + /// + public static void vp8_initialize_rd_consts(VP8_COMP cpi, MACROBLOCK x, int Qvalue) + { + // TODO: Initialize RD constants + // + // This function sets up the trade-off between rate and distortion: + // 1. Calculate RD multipliers based on Q + // - Higher Q = prefer lower rate (more compression) + // - Lower Q = prefer lower distortion (better quality) + // 2. Setup token costs for coefficient coding + // 3. Setup mode costs (inter/intra mode signaling) + // 4. Setup MV costs (motion vector signaling) + // 5. Calculate sad_per_bit values for motion search + // + // These constants are used throughout RD optimization to make + // rate-distortion trade-off decisions. + } + + /// + /// Initialize motion estimation constants. + /// + public static void vp8cx_initialize_me_consts(VP8_COMP cpi, int QIndex) + { + // TODO: Initialize motion estimation constants + // - Setup sad_per_bit tables + // - Initialize MV cost tables + // - Configure search parameters based on Q + } + + /// + /// Auto-select encoding speed based on frame statistics. + /// + public static void vp8_auto_select_speed(VP8_COMP cpi) + { + // TODO: Implement speed auto-selection + // Adjust encoding speed/quality trade-off based on: + // - Frame complexity + // - Available encoding time + // - Rate control requirements + } + + #endregion + + #region Plane Pointers + + /// + /// Get plane pointers for a frame buffer. + /// + public static void get_plane_pointers(YV12_BUFFER_CONFIG fb, + byte** plane, + uint recon_yoffset, + uint recon_uvoffset) + { + // TODO: Set up Y, U, V plane pointers + // plane[0] = fb->y_buffer + recon_yoffset; + // plane[1] = fb->u_buffer + recon_uvoffset; + // plane[2] = fb->v_buffer + recon_uvoffset; + } + + /// + /// Get predictor pointers for all reference frames. + /// + public static void get_predictor_pointers(VP8_COMP cpi, + byte**** plane, + uint recon_yoffset, + uint recon_uvoffset) + { + // TODO: Setup predictor pointers for each reference frame + // - LAST_FRAME + // - GOLDEN_FRAME + // - ALTREF_FRAME + // Based on which frames are available (ref_frame_flags) + } + + /// + /// Get reference frame search order. + /// + public static void get_reference_search_order(VP8_COMP cpi, int[] ref_frame_map) + { + // TODO: Build reference frame search order + // Order: INTRA, LAST, GOLDEN, ALTREF + // Based on which frames are enabled in ref_frame_flags + int i = 0; + ref_frame_map[i++] = (int)MV_REFERENCE_FRAME.INTRA_FRAME; + // Add available reference frames... + } + + #endregion + + #region Mode Decision - Intra + + /// + /// Rate-distortion based intra mode selection. + /// Tests all intra prediction modes and selects best based on RD cost. + /// + public static void vp8_rd_pick_intra_mode(MACROBLOCK x, ref int rate) + { + // TODO: Implement RD-based intra mode selection + // + // Flow: + // 1. Initialize best mode tracking + // 2. For each intra mode (DC_PRED, V_PRED, H_PRED, TM_PRED, B_PRED): + // a. Generate prediction + // b. Compute residual (src - pred) + // c. Transform and quantize + // d. Calculate distortion (reconstruction error) + // e. Calculate rate (bits needed for mode + coefficients) + // f. Compute RD cost = rate + lambda * distortion + // g. If best so far, save mode and cost + // 3. For B_PRED mode (4x4 intra): + // - Test each of 16 blocks independently + // - Select best 4x4 mode for each block + // - Sum up total RD cost + // 4. Select mode with lowest RD cost + // 5. Reconstruct using best mode + // 6. Return rate of best mode + // + // This is called for: + // - All macroblocks in key frames + // - Intra-coded MBs in inter frames + // - As a candidate in inter frame mode decision + + rate = 0; + } + + /// + /// Pick best intra mode for UV (chroma) component. + /// + private static void rd_pick_intra_mbuv_mode(MACROBLOCK x, ref int rate, ref int distortion) + { + // TODO: Test DC_PRED, V_PRED, H_PRED, TM_PRED for UV + // Similar to Y but only 4 modes, smaller 8x8 blocks + rate = 0; + distortion = 0; + } + + /// + /// Pick best 4x4 intra mode for a single block. + /// + private static void rd_pick_intra4x4_mode(MACROBLOCK x, int ib, ref B_PREDICTION_MODE best_mode, + ref int best_rd) + { + // TODO: Test all 10 B_PRED modes for 4x4 block + // - Above/Left context affects mode availability + // - Each mode has different prediction pattern + best_mode = B_PREDICTION_MODE.B_DC_PRED; + best_rd = 0; + } + + #endregion + + #region Mode Decision - Inter + + /// + /// Rate-distortion based inter mode selection. + /// Main function for inter-frame mode decision using RD optimization. + /// + public static void vp8_rd_pick_inter_mode(VP8_COMP cpi, MACROBLOCK x, + int recon_yoffset, int recon_uvoffset, + ref int returnrate, ref int returndistortion, + ref int returnintra, int mb_row, int mb_col) + { + // TODO: Implement RD-based inter mode selection + // + // This is the most complex function in the encoder! + // It evaluates all possible ways to encode a macroblock and picks the best. + // + // High-level flow: + // + // 1. Initialize + // - Setup predictor pointers for reference frames + // - Get near/nearest MV predictions + // - Initialize best mode tracking + // + // 2. Test Intra Mode + // - Call vp8_rd_pick_intra_mode + // - Calculate RD cost for intra coding + // - Save as initial best + // + // 3. For each reference frame (LAST, GOLDEN, ALTREF): + // For each inter mode in search order: + // + // a. ZEROMV mode: + // - Use (0,0) motion vector + // - Get prediction from reference + // - Calculate distortion and rate + // + // b. NEARESTMV / NEARMV modes: + // - Use predicted MV from neighboring MBs + // - Get prediction from reference + // - Calculate distortion and rate + // + // c. NEWMV mode: + // - Perform motion search to find best MV + // - Integer-pel search (diamond, hex, or full) + // - Sub-pixel refinement (1/2-pel and 1/4-pel) + // - Get prediction at best MV + // - Calculate distortion and rate (including MV cost) + // + // d. SPLITMV mode: + // - Partition MB into smaller blocks (16x8, 8x16, 8x8, 4x4) + // - Find best MV for each partition + // - Calculate total distortion and rate + // + // For each mode: + // - Transform and quantize residual + // - Calculate distortion (SSE or SAD) + // - Calculate rate (mode + MV + ref + coefficients) + // - Compute RD cost = rate + lambda * distortion + // - If better than current best, save mode and cost + // + // 4. Early termination checks: + // - If mode has zero residual (perfect prediction), done + // - If rate-distortion is much worse than best, skip remaining checks + // - Speed vs quality trade-offs + // + // 5. Select best mode: + // - Compare all tested modes + // - Select mode with lowest RD cost + // - Set final MB mode, MV, ref frame + // - Reconstruct MB with best mode + // + // 6. Return: + // - rate: bits needed to encode MB + // - distortion: reconstruction error + // - intra: whether intra mode was selected + // + // Key decisions made: + // - Intra vs Inter + // - Which reference frame (LAST/GOLDEN/ALTREF) + // - Which inter mode (ZERO/NEAREST/NEAR/NEW/SPLIT) + // - Motion vector (for NEW mode) + // - Partition type (for SPLIT mode) + // - Which coefficients to code (vs skip) + // + // This function is the heart of VP8 RD optimization and typically + // takes 60-80% of total encoding time. + + returnrate = 0; + returndistortion = 0; + returnintra = 0; + } + + /// + /// Perform motion search for NEWMV mode. + /// + private static int rd_pick_best_mbsegmentation(VP8_COMP cpi, MACROBLOCK x, + ref int_mv best_ref_mv, int best_rd, + int* mdcounts, ref int rate, + ref int distortion, int* returntotrate) + { + // TODO: Find best macroblock segmentation for SPLITMV + // Test different partition patterns and find optimal MV for each + return 0; + } + + #endregion + + #region Motion Vector Prediction + + /// + /// Predict motion vector from neighboring macroblocks. + /// + public static void vp8_mv_pred(VP8_COMP cpi, MACROBLOCKD xd, /*MODE_INFO*/ IntPtr here, + ref int_mv mvp, int refframe, int* ref_frame_sign_bias, + ref int sr, int[] near_sadidx) + { + // TODO: Implement MV prediction + // - Look at neighboring MBs (left, above, above-right, above-left) + // - Extract MVs from same reference frame + // - Calculate median or weighted prediction + // - Return predicted MV in mvp + } + + /// + /// Calculate SAD values for near MV candidates. + /// + public static void vp8_cal_sad(VP8_COMP cpi, MACROBLOCKD xd, MACROBLOCK x, + int recon_yoffset, int[] near_sadidx) + { + // TODO: Calculate SAD for near MV candidates + // Used to prioritize which near MVs to test first + } + + #endregion + + #region Utility Functions + + /// + /// Calculate UV sum of squared errors. + /// + public static int VP8_UVSSE(MACROBLOCK x) + { + // TODO: Calculate SSE for UV components + // Used in RD cost calculation + return 0; + } + + /// + /// Calculate cost of signaling a prediction mode. + /// + public static int vp8_cost_mv_ref(MB_PREDICTION_MODE m, int[] near_mv_ref_ct) + { + // TODO: Calculate mode signaling cost + // Different modes have different probabilities based on context + return 0; + } + + /// + /// Set macroblock mode and motion vector. + /// + public static void vp8_set_mbmode_and_mvs(MACROBLOCK x, MB_PREDICTION_MODE mb, ref int_mv mv) + { + // TODO: Set mode and MV for macroblock + // Update MB mode info structure + } + + /// + /// Fill token costs from probability tables. + /// + private static void fill_token_costs(int**** c, byte**** p) + { + // TODO: Convert coefficient probabilities to bit costs + // Used for calculating rate of coefficient coding + } + + #endregion + } +} diff --git a/src/systemdependent.cs b/src/systemdependent.cs index fd1fb70..95660d4 100644 --- a/src/systemdependent.cs +++ b/src/systemdependent.cs @@ -33,5 +33,11 @@ public static void vp8_machine_specific_config(VP8_COMMON ctx) { ctx.cpu_caps = 0; } + + public static void vpx_clear_system_state() + { + // On x86 platforms this would call emms instruction to clear MMX state + // Not needed in managed C# code + } } } diff --git a/src/tokenize.cs b/src/tokenize.cs new file mode 100644 index 0000000..1d970ce --- /dev/null +++ b/src/tokenize.cs @@ -0,0 +1,1242 @@ +//----------------------------------------------------------------------------- +// Filename: tokenize.cs +// +// Description: Port of: +// - tokenize.c +// - tokenize.h +// - dct_value_cost.h +// - dct_value_tokens.h +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 17 Feb 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using vp8_prob = System.Byte; + +namespace Vpx.Net +{ + public struct TOKENVALUE + { + public short Token; + public short Extra; + + public TOKENVALUE(short token, short extra) + { + Token = token; + Extra = extra; + } + } + + public static class tokenize + { + public const int DCT_MAX_VALUE = 2048; + + public static readonly short[] dct_value_cost = new short[4096] + { + 8285, 8277, 8267, 8259, 8253, 8245, 8226, 8218, 8212, 8204, 8194, 8186, 8180, + 8172, 8150, 8142, 8136, 8128, 8118, 8110, 8104, 8096, 8077, 8069, 8063, 8055, + 8045, 8037, 8031, 8023, 7997, 7989, 7983, 7975, 7965, 7957, 7951, 7943, 7924, + 7916, 7910, 7902, 7892, 7884, 7878, 7870, 7848, 7840, 7834, 7826, 7816, 7808, + 7802, 7794, 7775, 7767, 7761, 7753, 7743, 7735, 7729, 7721, 7923, 7915, 7909, + 7901, 7891, 7883, 7877, 7869, 7850, 7842, 7836, 7828, 7818, 7810, 7804, 7796, + 7774, 7766, 7760, 7752, 7742, 7734, 7728, 7720, 7701, 7693, 7687, 7679, 7669, + 7661, 7655, 7647, 7621, 7613, 7607, 7599, 7589, 7581, 7575, 7567, 7548, 7540, + 7534, 7526, 7516, 7508, 7502, 7494, 7472, 7464, 7458, 7450, 7440, 7432, 7426, + 7418, 7399, 7391, 7385, 7377, 7367, 7359, 7353, 7345, 7479, 7471, 7465, 7457, + 7447, 7439, 7433, 7425, 7406, 7398, 7392, 7384, 7374, 7366, 7360, 7352, 7330, + 7322, 7316, 7308, 7298, 7290, 7284, 7276, 7257, 7249, 7243, 7235, 7225, 7217, + 7211, 7203, 7177, 7169, 7163, 7155, 7145, 7137, 7131, 7123, 7104, 7096, 7090, + 7082, 7072, 7064, 7058, 7050, 7028, 7020, 7014, 7006, 6996, 6988, 6982, 6974, + 6955, 6947, 6941, 6933, 6923, 6915, 6909, 6901, 7632, 7624, 7618, 7610, 7600, + 7592, 7586, 7578, 7559, 7551, 7545, 7537, 7527, 7519, 7513, 7505, 7483, 7475, + 7469, 7461, 7451, 7443, 7437, 7429, 7410, 7402, 7396, 7388, 7378, 7370, 7364, + 7356, 7330, 7322, 7316, 7308, 7298, 7290, 7284, 7276, 7257, 7249, 7243, 7235, + 7225, 7217, 7211, 7203, 7181, 7173, 7167, 7159, 7149, 7141, 7135, 7127, 7108, + 7100, 7094, 7086, 7076, 7068, 7062, 7054, 7188, 7180, 7174, 7166, 7156, 7148, + 7142, 7134, 7115, 7107, 7101, 7093, 7083, 7075, 7069, 7061, 7039, 7031, 7025, + 7017, 7007, 6999, 6993, 6985, 6966, 6958, 6952, 6944, 6934, 6926, 6920, 6912, + 6886, 6878, 6872, 6864, 6854, 6846, 6840, 6832, 6813, 6805, 6799, 6791, 6781, + 6773, 6767, 6759, 6737, 6729, 6723, 6715, 6705, 6697, 6691, 6683, 6664, 6656, + 6650, 6642, 6632, 6624, 6618, 6610, 6812, 6804, 6798, 6790, 6780, 6772, 6766, + 6758, 6739, 6731, 6725, 6717, 6707, 6699, 6693, 6685, 6663, 6655, 6649, 6641, + 6631, 6623, 6617, 6609, 6590, 6582, 6576, 6568, 6558, 6550, 6544, 6536, 6510, + 6502, 6496, 6488, 6478, 6470, 6464, 6456, 6437, 6429, 6423, 6415, 6405, 6397, + 6391, 6383, 6361, 6353, 6347, 6339, 6329, 6321, 6315, 6307, 6288, 6280, 6274, + 6266, 6256, 6248, 6242, 6234, 6368, 6360, 6354, 6346, 6336, 6328, 6322, 6314, + 6295, 6287, 6281, 6273, 6263, 6255, 6249, 6241, 6219, 6211, 6205, 6197, 6187, + 6179, 6173, 6165, 6146, 6138, 6132, 6124, 6114, 6106, 6100, 6092, 6066, 6058, + 6052, 6044, 6034, 6026, 6020, 6012, 5993, 5985, 5979, 5971, 5961, 5953, 5947, + 5939, 5917, 5909, 5903, 5895, 5885, 5877, 5871, 5863, 5844, 5836, 5830, 5822, + 5812, 5804, 5798, 5790, 6697, 6689, 6683, 6675, 6665, 6657, 6651, 6643, 6624, + 6616, 6610, 6602, 6592, 6584, 6578, 6570, 6548, 6540, 6534, 6526, 6516, 6508, + 6502, 6494, 6475, 6467, 6461, 6453, 6443, 6435, 6429, 6421, 6395, 6387, 6381, + 6373, 6363, 6355, 6349, 6341, 6322, 6314, 6308, 6300, 6290, 6282, 6276, 6268, + 6246, 6238, 6232, 6224, 6214, 6206, 6200, 6192, 6173, 6165, 6159, 6151, 6141, + 6133, 6127, 6119, 6253, 6245, 6239, 6231, 6221, 6213, 6207, 6199, 6180, 6172, + 6166, 6158, 6148, 6140, 6134, 6126, 6104, 6096, 6090, 6082, 6072, 6064, 6058, + 6050, 6031, 6023, 6017, 6009, 5999, 5991, 5985, 5977, 5951, 5943, 5937, 5929, + 5919, 5911, 5905, 5897, 5878, 5870, 5864, 5856, 5846, 5838, 5832, 5824, 5802, + 5794, 5788, 5780, 5770, 5762, 5756, 5748, 5729, 5721, 5715, 5707, 5697, 5689, + 5683, 5675, 5877, 5869, 5863, 5855, 5845, 5837, 5831, 5823, 5804, 5796, 5790, + 5782, 5772, 5764, 5758, 5750, 5728, 5720, 5714, 5706, 5696, 5688, 5682, 5674, + 5655, 5647, 5641, 5633, 5623, 5615, 5609, 5601, 5575, 5567, 5561, 5553, 5543, + 5535, 5529, 5521, 5502, 5494, 5488, 5480, 5470, 5462, 5456, 5448, 5426, 5418, + 5412, 5404, 5394, 5386, 5380, 5372, 5353, 5345, 5339, 5331, 5321, 5313, 5307, + 5299, 5433, 5425, 5419, 5411, 5401, 5393, 5387, 5379, 5360, 5352, 5346, 5338, + 5328, 5320, 5314, 5306, 5284, 5276, 5270, 5262, 5252, 5244, 5238, 5230, 5211, + 5203, 5197, 5189, 5179, 5171, 5165, 5157, 5131, 5123, 5117, 5109, 5099, 5091, + 5085, 5077, 5058, 5050, 5044, 5036, 5026, 5018, 5012, 5004, 4982, 4974, 4968, + 4960, 4950, 4942, 4936, 4928, 4909, 4901, 4895, 4887, 4877, 4869, 4863, 4855, + 5586, 5578, 5572, 5564, 5554, 5546, 5540, 5532, 5513, 5505, 5499, 5491, 5481, + 5473, 5467, 5459, 5437, 5429, 5423, 5415, 5405, 5397, 5391, 5383, 5364, 5356, + 5350, 5342, 5332, 5324, 5318, 5310, 5284, 5276, 5270, 5262, 5252, 5244, 5238, + 5230, 5211, 5203, 5197, 5189, 5179, 5171, 5165, 5157, 5135, 5127, 5121, 5113, + 5103, 5095, 5089, 5081, 5062, 5054, 5048, 5040, 5030, 5022, 5016, 5008, 5142, + 5134, 5128, 5120, 5110, 5102, 5096, 5088, 5069, 5061, 5055, 5047, 5037, 5029, + 5023, 5015, 4993, 4985, 4979, 4971, 4961, 4953, 4947, 4939, 4920, 4912, 4906, + 4898, 4888, 4880, 4874, 4866, 4840, 4832, 4826, 4818, 4808, 4800, 4794, 4786, + 4767, 4759, 4753, 4745, 4735, 4727, 4721, 4713, 4691, 4683, 4677, 4669, 4659, + 4651, 4645, 4637, 4618, 4610, 4604, 4596, 4586, 4578, 4572, 4564, 4766, 4758, + 4752, 4744, 4734, 4726, 4720, 4712, 4693, 4685, 4679, 4671, 4661, 4653, 4647, + 4639, 4617, 4609, 4603, 4595, 4585, 4577, 4571, 4563, 4544, 4536, 4530, 4522, + 4512, 4504, 4498, 4490, 4464, 4456, 4450, 4442, 4432, 4424, 4418, 4410, 4391, + 4383, 4377, 4369, 4359, 4351, 4345, 4337, 4315, 4307, 4301, 4293, 4283, 4275, + 4269, 4261, 4242, 4234, 4228, 4220, 4210, 4202, 4196, 4188, 4322, 4314, 4308, + 4300, 4290, 4282, 4276, 4268, 4249, 4241, 4235, 4227, 4217, 4209, 4203, 4195, + 4173, 4165, 4159, 4151, 4141, 4133, 4127, 4119, 4100, 4092, 4086, 4078, 4068, + 4060, 4054, 4046, 4020, 4012, 4006, 3998, 3988, 3980, 3974, 3966, 3947, 3939, + 3933, 3925, 3915, 3907, 3901, 3893, 3871, 3863, 3857, 3849, 3839, 3831, 3825, + 3817, 3798, 3790, 3784, 3776, 3766, 3758, 3752, 3744, 6697, 6689, 6683, 6675, + 6665, 6657, 6651, 6643, 6624, 6616, 6610, 6602, 6592, 6584, 6578, 6570, 6548, + 6540, 6534, 6526, 6516, 6508, 6502, 6494, 6475, 6467, 6461, 6453, 6443, 6435, + 6429, 6421, 6395, 6387, 6381, 6373, 6363, 6355, 6349, 6341, 6322, 6314, 6308, + 6300, 6290, 6282, 6276, 6268, 6246, 6238, 6232, 6224, 6214, 6206, 6200, 6192, + 6173, 6165, 6159, 6151, 6141, 6133, 6127, 6119, 6253, 6245, 6239, 6231, 6221, + 6213, 6207, 6199, 6180, 6172, 6166, 6158, 6148, 6140, 6134, 6126, 6104, 6096, + 6090, 6082, 6072, 6064, 6058, 6050, 6031, 6023, 6017, 6009, 5999, 5991, 5985, + 5977, 5951, 5943, 5937, 5929, 5919, 5911, 5905, 5897, 5878, 5870, 5864, 5856, + 5846, 5838, 5832, 5824, 5802, 5794, 5788, 5780, 5770, 5762, 5756, 5748, 5729, + 5721, 5715, 5707, 5697, 5689, 5683, 5675, 5877, 5869, 5863, 5855, 5845, 5837, + 5831, 5823, 5804, 5796, 5790, 5782, 5772, 5764, 5758, 5750, 5728, 5720, 5714, + 5706, 5696, 5688, 5682, 5674, 5655, 5647, 5641, 5633, 5623, 5615, 5609, 5601, + 5575, 5567, 5561, 5553, 5543, 5535, 5529, 5521, 5502, 5494, 5488, 5480, 5470, + 5462, 5456, 5448, 5426, 5418, 5412, 5404, 5394, 5386, 5380, 5372, 5353, 5345, + 5339, 5331, 5321, 5313, 5307, 5299, 5433, 5425, 5419, 5411, 5401, 5393, 5387, + 5379, 5360, 5352, 5346, 5338, 5328, 5320, 5314, 5306, 5284, 5276, 5270, 5262, + 5252, 5244, 5238, 5230, 5211, 5203, 5197, 5189, 5179, 5171, 5165, 5157, 5131, + 5123, 5117, 5109, 5099, 5091, 5085, 5077, 5058, 5050, 5044, 5036, 5026, 5018, + 5012, 5004, 4982, 4974, 4968, 4960, 4950, 4942, 4936, 4928, 4909, 4901, 4895, + 4887, 4877, 4869, 4863, 4855, 5586, 5578, 5572, 5564, 5554, 5546, 5540, 5532, + 5513, 5505, 5499, 5491, 5481, 5473, 5467, 5459, 5437, 5429, 5423, 5415, 5405, + 5397, 5391, 5383, 5364, 5356, 5350, 5342, 5332, 5324, 5318, 5310, 5284, 5276, + 5270, 5262, 5252, 5244, 5238, 5230, 5211, 5203, 5197, 5189, 5179, 5171, 5165, + 5157, 5135, 5127, 5121, 5113, 5103, 5095, 5089, 5081, 5062, 5054, 5048, 5040, + 5030, 5022, 5016, 5008, 5142, 5134, 5128, 5120, 5110, 5102, 5096, 5088, 5069, + 5061, 5055, 5047, 5037, 5029, 5023, 5015, 4993, 4985, 4979, 4971, 4961, 4953, + 4947, 4939, 4920, 4912, 4906, 4898, 4888, 4880, 4874, 4866, 4840, 4832, 4826, + 4818, 4808, 4800, 4794, 4786, 4767, 4759, 4753, 4745, 4735, 4727, 4721, 4713, + 4691, 4683, 4677, 4669, 4659, 4651, 4645, 4637, 4618, 4610, 4604, 4596, 4586, + 4578, 4572, 4564, 4766, 4758, 4752, 4744, 4734, 4726, 4720, 4712, 4693, 4685, + 4679, 4671, 4661, 4653, 4647, 4639, 4617, 4609, 4603, 4595, 4585, 4577, 4571, + 4563, 4544, 4536, 4530, 4522, 4512, 4504, 4498, 4490, 4464, 4456, 4450, 4442, + 4432, 4424, 4418, 4410, 4391, 4383, 4377, 4369, 4359, 4351, 4345, 4337, 4315, + 4307, 4301, 4293, 4283, 4275, 4269, 4261, 4242, 4234, 4228, 4220, 4210, 4202, + 4196, 4188, 4322, 4314, 4308, 4300, 4290, 4282, 4276, 4268, 4249, 4241, 4235, + 4227, 4217, 4209, 4203, 4195, 4173, 4165, 4159, 4151, 4141, 4133, 4127, 4119, + 4100, 4092, 4086, 4078, 4068, 4060, 4054, 4046, 4020, 4012, 4006, 3998, 3988, + 3980, 3974, 3966, 3947, 3939, 3933, 3925, 3915, 3907, 3901, 3893, 3871, 3863, + 3857, 3849, 3839, 3831, 3825, 3817, 3798, 3790, 3784, 3776, 3766, 3758, 3752, + 3744, 4651, 4643, 4637, 4629, 4619, 4611, 4605, 4597, 4578, 4570, 4564, 4556, + 4546, 4538, 4532, 4524, 4502, 4494, 4488, 4480, 4470, 4462, 4456, 4448, 4429, + 4421, 4415, 4407, 4397, 4389, 4383, 4375, 4349, 4341, 4335, 4327, 4317, 4309, + 4303, 4295, 4276, 4268, 4262, 4254, 4244, 4236, 4230, 4222, 4200, 4192, 4186, + 4178, 4168, 4160, 4154, 4146, 4127, 4119, 4113, 4105, 4095, 4087, 4081, 4073, + 4207, 4199, 4193, 4185, 4175, 4167, 4161, 4153, 4134, 4126, 4120, 4112, 4102, + 4094, 4088, 4080, 4058, 4050, 4044, 4036, 4026, 4018, 4012, 4004, 3985, 3977, + 3971, 3963, 3953, 3945, 3939, 3931, 3905, 3897, 3891, 3883, 3873, 3865, 3859, + 3851, 3832, 3824, 3818, 3810, 3800, 3792, 3786, 3778, 3756, 3748, 3742, 3734, + 3724, 3716, 3710, 3702, 3683, 3675, 3669, 3661, 3651, 3643, 3637, 3629, 3831, + 3823, 3817, 3809, 3799, 3791, 3785, 3777, 3758, 3750, 3744, 3736, 3726, 3718, + 3712, 3704, 3682, 3674, 3668, 3660, 3650, 3642, 3636, 3628, 3609, 3601, 3595, + 3587, 3577, 3569, 3563, 3555, 3529, 3521, 3515, 3507, 3497, 3489, 3483, 3475, + 3456, 3448, 3442, 3434, 3424, 3416, 3410, 3402, 3380, 3372, 3366, 3358, 3348, + 3340, 3334, 3326, 3307, 3299, 3293, 3285, 3275, 3267, 3261, 3253, 3387, 3379, + 3373, 3365, 3355, 3347, 3341, 3333, 3314, 3306, 3300, 3292, 3282, 3274, 3268, + 3260, 3238, 3230, 3224, 3216, 3206, 3198, 3192, 3184, 3165, 3157, 3151, 3143, + 3133, 3125, 3119, 3111, 3085, 3077, 3071, 3063, 3053, 3045, 3039, 3031, 3012, + 3004, 2998, 2990, 2980, 2972, 2966, 2958, 2936, 2928, 2922, 2914, 2904, 2896, + 2890, 2882, 2863, 2855, 2849, 2841, 2831, 2823, 2817, 2809, 3540, 3532, 3526, + 3518, 3508, 3500, 3494, 3486, 3467, 3459, 3453, 3445, 3435, 3427, 3421, 3413, + 3391, 3383, 3377, 3369, 3359, 3351, 3345, 3337, 3318, 3310, 3304, 3296, 3286, + 3278, 3272, 3264, 3238, 3230, 3224, 3216, 3206, 3198, 3192, 3184, 3165, 3157, + 3151, 3143, 3133, 3125, 3119, 3111, 3089, 3081, 3075, 3067, 3057, 3049, 3043, + 3035, 3016, 3008, 3002, 2994, 2984, 2976, 2970, 2962, 3096, 3088, 3082, 3074, + 3064, 3056, 3050, 3042, 3023, 3015, 3009, 3001, 2991, 2983, 2977, 2969, 2947, + 2939, 2933, 2925, 2915, 2907, 2901, 2893, 2874, 2866, 2860, 2852, 2842, 2834, + 2828, 2820, 2794, 2786, 2780, 2772, 2762, 2754, 2748, 2740, 2721, 2713, 2707, + 2699, 2689, 2681, 2675, 2667, 2645, 2637, 2631, 2623, 2613, 2605, 2599, 2591, + 2572, 2564, 2558, 2550, 2540, 2532, 2526, 2518, 2720, 2712, 2706, 2698, 2688, + 2680, 2674, 2666, 2647, 2639, 2633, 2625, 2615, 2607, 2601, 2593, 2571, 2563, + 2557, 2549, 2539, 2531, 2525, 2517, 2498, 2490, 2484, 2476, 2466, 2458, 2452, + 2444, 2418, 2410, 2404, 2396, 2386, 2378, 2372, 2364, 2345, 2337, 2331, 2323, + 2313, 2305, 2299, 2291, 2269, 2261, 2255, 2247, 2237, 2229, 2223, 2215, 2196, + 2188, 2182, 2174, 2164, 2156, 2150, 2142, 2276, 2268, 2262, 2254, 2244, 2236, + 2230, 2222, 2203, 2195, 2189, 2181, 2171, 2163, 2157, 2149, 2127, 2119, 2113, + 2105, 2095, 2087, 2081, 2073, 2054, 2046, 2040, 2032, 2022, 2014, 2008, 2000, + 1974, 1966, 1960, 1952, 1942, 1934, 1928, 1920, 1901, 1893, 1887, 1879, 1869, + 1861, 1855, 1847, 1825, 1817, 1811, 1803, 1793, 1785, 1779, 1771, 1752, 1744, + 1738, 1730, 1720, 1712, 1706, 1698, 1897, 1883, 1860, 1846, 1819, 1805, 1782, + 1768, 1723, 1709, 1686, 1672, 1645, 1631, 1608, 1594, 1574, 1560, 1537, 1523, + 1496, 1482, 1459, 1445, 1400, 1386, 1363, 1349, 1322, 1308, 1285, 1271, 1608, + 1565, 1535, 1492, 1446, 1403, 1373, 1330, 1312, 1269, 1239, 1196, 1150, 1107, + 1077, 1034, 1291, 1218, 1171, 1098, 1015, 942, 895, 822, 953, 850, 729, + 626, 618, 431, 257, 257, 257, 257, 0, 255, 255, 255, 255, 429, + 616, 624, 727, 848, 951, 820, 893, 940, 1013, 1096, 1169, 1216, 1289, + 1032, 1075, 1105, 1148, 1194, 1237, 1267, 1310, 1328, 1371, 1401, 1444, 1490, + 1533, 1563, 1606, 1269, 1283, 1306, 1320, 1347, 1361, 1384, 1398, 1443, 1457, + 1480, 1494, 1521, 1535, 1558, 1572, 1592, 1606, 1629, 1643, 1670, 1684, 1707, + 1721, 1766, 1780, 1803, 1817, 1844, 1858, 1881, 1895, 1696, 1704, 1710, 1718, + 1728, 1736, 1742, 1750, 1769, 1777, 1783, 1791, 1801, 1809, 1815, 1823, 1845, + 1853, 1859, 1867, 1877, 1885, 1891, 1899, 1918, 1926, 1932, 1940, 1950, 1958, + 1964, 1972, 1998, 2006, 2012, 2020, 2030, 2038, 2044, 2052, 2071, 2079, 2085, + 2093, 2103, 2111, 2117, 2125, 2147, 2155, 2161, 2169, 2179, 2187, 2193, 2201, + 2220, 2228, 2234, 2242, 2252, 2260, 2266, 2274, 2140, 2148, 2154, 2162, 2172, + 2180, 2186, 2194, 2213, 2221, 2227, 2235, 2245, 2253, 2259, 2267, 2289, 2297, + 2303, 2311, 2321, 2329, 2335, 2343, 2362, 2370, 2376, 2384, 2394, 2402, 2408, + 2416, 2442, 2450, 2456, 2464, 2474, 2482, 2488, 2496, 2515, 2523, 2529, 2537, + 2547, 2555, 2561, 2569, 2591, 2599, 2605, 2613, 2623, 2631, 2637, 2645, 2664, + 2672, 2678, 2686, 2696, 2704, 2710, 2718, 2516, 2524, 2530, 2538, 2548, 2556, + 2562, 2570, 2589, 2597, 2603, 2611, 2621, 2629, 2635, 2643, 2665, 2673, 2679, + 2687, 2697, 2705, 2711, 2719, 2738, 2746, 2752, 2760, 2770, 2778, 2784, 2792, + 2818, 2826, 2832, 2840, 2850, 2858, 2864, 2872, 2891, 2899, 2905, 2913, 2923, + 2931, 2937, 2945, 2967, 2975, 2981, 2989, 2999, 3007, 3013, 3021, 3040, 3048, + 3054, 3062, 3072, 3080, 3086, 3094, 2960, 2968, 2974, 2982, 2992, 3000, 3006, + 3014, 3033, 3041, 3047, 3055, 3065, 3073, 3079, 3087, 3109, 3117, 3123, 3131, + 3141, 3149, 3155, 3163, 3182, 3190, 3196, 3204, 3214, 3222, 3228, 3236, 3262, + 3270, 3276, 3284, 3294, 3302, 3308, 3316, 3335, 3343, 3349, 3357, 3367, 3375, + 3381, 3389, 3411, 3419, 3425, 3433, 3443, 3451, 3457, 3465, 3484, 3492, 3498, + 3506, 3516, 3524, 3530, 3538, 2807, 2815, 2821, 2829, 2839, 2847, 2853, 2861, + 2880, 2888, 2894, 2902, 2912, 2920, 2926, 2934, 2956, 2964, 2970, 2978, 2988, + 2996, 3002, 3010, 3029, 3037, 3043, 3051, 3061, 3069, 3075, 3083, 3109, 3117, + 3123, 3131, 3141, 3149, 3155, 3163, 3182, 3190, 3196, 3204, 3214, 3222, 3228, + 3236, 3258, 3266, 3272, 3280, 3290, 3298, 3304, 3312, 3331, 3339, 3345, 3353, + 3363, 3371, 3377, 3385, 3251, 3259, 3265, 3273, 3283, 3291, 3297, 3305, 3324, + 3332, 3338, 3346, 3356, 3364, 3370, 3378, 3400, 3408, 3414, 3422, 3432, 3440, + 3446, 3454, 3473, 3481, 3487, 3495, 3505, 3513, 3519, 3527, 3553, 3561, 3567, + 3575, 3585, 3593, 3599, 3607, 3626, 3634, 3640, 3648, 3658, 3666, 3672, 3680, + 3702, 3710, 3716, 3724, 3734, 3742, 3748, 3756, 3775, 3783, 3789, 3797, 3807, + 3815, 3821, 3829, 3627, 3635, 3641, 3649, 3659, 3667, 3673, 3681, 3700, 3708, + 3714, 3722, 3732, 3740, 3746, 3754, 3776, 3784, 3790, 3798, 3808, 3816, 3822, + 3830, 3849, 3857, 3863, 3871, 3881, 3889, 3895, 3903, 3929, 3937, 3943, 3951, + 3961, 3969, 3975, 3983, 4002, 4010, 4016, 4024, 4034, 4042, 4048, 4056, 4078, + 4086, 4092, 4100, 4110, 4118, 4124, 4132, 4151, 4159, 4165, 4173, 4183, 4191, + 4197, 4205, 4071, 4079, 4085, 4093, 4103, 4111, 4117, 4125, 4144, 4152, 4158, + 4166, 4176, 4184, 4190, 4198, 4220, 4228, 4234, 4242, 4252, 4260, 4266, 4274, + 4293, 4301, 4307, 4315, 4325, 4333, 4339, 4347, 4373, 4381, 4387, 4395, 4405, + 4413, 4419, 4427, 4446, 4454, 4460, 4468, 4478, 4486, 4492, 4500, 4522, 4530, + 4536, 4544, 4554, 4562, 4568, 4576, 4595, 4603, 4609, 4617, 4627, 4635, 4641, + 4649, 3742, 3750, 3756, 3764, 3774, 3782, 3788, 3796, 3815, 3823, 3829, 3837, + 3847, 3855, 3861, 3869, 3891, 3899, 3905, 3913, 3923, 3931, 3937, 3945, 3964, + 3972, 3978, 3986, 3996, 4004, 4010, 4018, 4044, 4052, 4058, 4066, 4076, 4084, + 4090, 4098, 4117, 4125, 4131, 4139, 4149, 4157, 4163, 4171, 4193, 4201, 4207, + 4215, 4225, 4233, 4239, 4247, 4266, 4274, 4280, 4288, 4298, 4306, 4312, 4320, + 4186, 4194, 4200, 4208, 4218, 4226, 4232, 4240, 4259, 4267, 4273, 4281, 4291, + 4299, 4305, 4313, 4335, 4343, 4349, 4357, 4367, 4375, 4381, 4389, 4408, 4416, + 4422, 4430, 4440, 4448, 4454, 4462, 4488, 4496, 4502, 4510, 4520, 4528, 4534, + 4542, 4561, 4569, 4575, 4583, 4593, 4601, 4607, 4615, 4637, 4645, 4651, 4659, + 4669, 4677, 4683, 4691, 4710, 4718, 4724, 4732, 4742, 4750, 4756, 4764, 4562, + 4570, 4576, 4584, 4594, 4602, 4608, 4616, 4635, 4643, 4649, 4657, 4667, 4675, + 4681, 4689, 4711, 4719, 4725, 4733, 4743, 4751, 4757, 4765, 4784, 4792, 4798, + 4806, 4816, 4824, 4830, 4838, 4864, 4872, 4878, 4886, 4896, 4904, 4910, 4918, + 4937, 4945, 4951, 4959, 4969, 4977, 4983, 4991, 5013, 5021, 5027, 5035, 5045, + 5053, 5059, 5067, 5086, 5094, 5100, 5108, 5118, 5126, 5132, 5140, 5006, 5014, + 5020, 5028, 5038, 5046, 5052, 5060, 5079, 5087, 5093, 5101, 5111, 5119, 5125, + 5133, 5155, 5163, 5169, 5177, 5187, 5195, 5201, 5209, 5228, 5236, 5242, 5250, + 5260, 5268, 5274, 5282, 5308, 5316, 5322, 5330, 5340, 5348, 5354, 5362, 5381, + 5389, 5395, 5403, 5413, 5421, 5427, 5435, 5457, 5465, 5471, 5479, 5489, 5497, + 5503, 5511, 5530, 5538, 5544, 5552, 5562, 5570, 5576, 5584, 4853, 4861, 4867, + 4875, 4885, 4893, 4899, 4907, 4926, 4934, 4940, 4948, 4958, 4966, 4972, 4980, + 5002, 5010, 5016, 5024, 5034, 5042, 5048, 5056, 5075, 5083, 5089, 5097, 5107, + 5115, 5121, 5129, 5155, 5163, 5169, 5177, 5187, 5195, 5201, 5209, 5228, 5236, + 5242, 5250, 5260, 5268, 5274, 5282, 5304, 5312, 5318, 5326, 5336, 5344, 5350, + 5358, 5377, 5385, 5391, 5399, 5409, 5417, 5423, 5431, 5297, 5305, 5311, 5319, + 5329, 5337, 5343, 5351, 5370, 5378, 5384, 5392, 5402, 5410, 5416, 5424, 5446, + 5454, 5460, 5468, 5478, 5486, 5492, 5500, 5519, 5527, 5533, 5541, 5551, 5559, + 5565, 5573, 5599, 5607, 5613, 5621, 5631, 5639, 5645, 5653, 5672, 5680, 5686, + 5694, 5704, 5712, 5718, 5726, 5748, 5756, 5762, 5770, 5780, 5788, 5794, 5802, + 5821, 5829, 5835, 5843, 5853, 5861, 5867, 5875, 5673, 5681, 5687, 5695, 5705, + 5713, 5719, 5727, 5746, 5754, 5760, 5768, 5778, 5786, 5792, 5800, 5822, 5830, + 5836, 5844, 5854, 5862, 5868, 5876, 5895, 5903, 5909, 5917, 5927, 5935, 5941, + 5949, 5975, 5983, 5989, 5997, 6007, 6015, 6021, 6029, 6048, 6056, 6062, 6070, + 6080, 6088, 6094, 6102, 6124, 6132, 6138, 6146, 6156, 6164, 6170, 6178, 6197, + 6205, 6211, 6219, 6229, 6237, 6243, 6251, 6117, 6125, 6131, 6139, 6149, 6157, + 6163, 6171, 6190, 6198, 6204, 6212, 6222, 6230, 6236, 6244, 6266, 6274, 6280, + 6288, 6298, 6306, 6312, 6320, 6339, 6347, 6353, 6361, 6371, 6379, 6385, 6393, + 6419, 6427, 6433, 6441, 6451, 6459, 6465, 6473, 6492, 6500, 6506, 6514, 6524, + 6532, 6538, 6546, 6568, 6576, 6582, 6590, 6600, 6608, 6614, 6622, 6641, 6649, + 6655, 6663, 6673, 6681, 6687, 6695, 3742, 3750, 3756, 3764, 3774, 3782, 3788, + 3796, 3815, 3823, 3829, 3837, 3847, 3855, 3861, 3869, 3891, 3899, 3905, 3913, + 3923, 3931, 3937, 3945, 3964, 3972, 3978, 3986, 3996, 4004, 4010, 4018, 4044, + 4052, 4058, 4066, 4076, 4084, 4090, 4098, 4117, 4125, 4131, 4139, 4149, 4157, + 4163, 4171, 4193, 4201, 4207, 4215, 4225, 4233, 4239, 4247, 4266, 4274, 4280, + 4288, 4298, 4306, 4312, 4320, 4186, 4194, 4200, 4208, 4218, 4226, 4232, 4240, + 4259, 4267, 4273, 4281, 4291, 4299, 4305, 4313, 4335, 4343, 4349, 4357, 4367, + 4375, 4381, 4389, 4408, 4416, 4422, 4430, 4440, 4448, 4454, 4462, 4488, 4496, + 4502, 4510, 4520, 4528, 4534, 4542, 4561, 4569, 4575, 4583, 4593, 4601, 4607, + 4615, 4637, 4645, 4651, 4659, 4669, 4677, 4683, 4691, 4710, 4718, 4724, 4732, + 4742, 4750, 4756, 4764, 4562, 4570, 4576, 4584, 4594, 4602, 4608, 4616, 4635, + 4643, 4649, 4657, 4667, 4675, 4681, 4689, 4711, 4719, 4725, 4733, 4743, 4751, + 4757, 4765, 4784, 4792, 4798, 4806, 4816, 4824, 4830, 4838, 4864, 4872, 4878, + 4886, 4896, 4904, 4910, 4918, 4937, 4945, 4951, 4959, 4969, 4977, 4983, 4991, + 5013, 5021, 5027, 5035, 5045, 5053, 5059, 5067, 5086, 5094, 5100, 5108, 5118, + 5126, 5132, 5140, 5006, 5014, 5020, 5028, 5038, 5046, 5052, 5060, 5079, 5087, + 5093, 5101, 5111, 5119, 5125, 5133, 5155, 5163, 5169, 5177, 5187, 5195, 5201, + 5209, 5228, 5236, 5242, 5250, 5260, 5268, 5274, 5282, 5308, 5316, 5322, 5330, + 5340, 5348, 5354, 5362, 5381, 5389, 5395, 5403, 5413, 5421, 5427, 5435, 5457, + 5465, 5471, 5479, 5489, 5497, 5503, 5511, 5530, 5538, 5544, 5552, 5562, 5570, + 5576, 5584, 4853, 4861, 4867, 4875, 4885, 4893, 4899, 4907, 4926, 4934, 4940, + 4948, 4958, 4966, 4972, 4980, 5002, 5010, 5016, 5024, 5034, 5042, 5048, 5056, + 5075, 5083, 5089, 5097, 5107, 5115, 5121, 5129, 5155, 5163, 5169, 5177, 5187, + 5195, 5201, 5209, 5228, 5236, 5242, 5250, 5260, 5268, 5274, 5282, 5304, 5312, + 5318, 5326, 5336, 5344, 5350, 5358, 5377, 5385, 5391, 5399, 5409, 5417, 5423, + 5431, 5297, 5305, 5311, 5319, 5329, 5337, 5343, 5351, 5370, 5378, 5384, 5392, + 5402, 5410, 5416, 5424, 5446, 5454, 5460, 5468, 5478, 5486, 5492, 5500, 5519, + 5527, 5533, 5541, 5551, 5559, 5565, 5573, 5599, 5607, 5613, 5621, 5631, 5639, + 5645, 5653, 5672, 5680, 5686, 5694, 5704, 5712, 5718, 5726, 5748, 5756, 5762, + 5770, 5780, 5788, 5794, 5802, 5821, 5829, 5835, 5843, 5853, 5861, 5867, 5875, + 5673, 5681, 5687, 5695, 5705, 5713, 5719, 5727, 5746, 5754, 5760, 5768, 5778, + 5786, 5792, 5800, 5822, 5830, 5836, 5844, 5854, 5862, 5868, 5876, 5895, 5903, + 5909, 5917, 5927, 5935, 5941, 5949, 5975, 5983, 5989, 5997, 6007, 6015, 6021, + 6029, 6048, 6056, 6062, 6070, 6080, 6088, 6094, 6102, 6124, 6132, 6138, 6146, + 6156, 6164, 6170, 6178, 6197, 6205, 6211, 6219, 6229, 6237, 6243, 6251, 6117, + 6125, 6131, 6139, 6149, 6157, 6163, 6171, 6190, 6198, 6204, 6212, 6222, 6230, + 6236, 6244, 6266, 6274, 6280, 6288, 6298, 6306, 6312, 6320, 6339, 6347, 6353, + 6361, 6371, 6379, 6385, 6393, 6419, 6427, 6433, 6441, 6451, 6459, 6465, 6473, + 6492, 6500, 6506, 6514, 6524, 6532, 6538, 6546, 6568, 6576, 6582, 6590, 6600, + 6608, 6614, 6622, 6641, 6649, 6655, 6663, 6673, 6681, 6687, 6695, 5788, 5796, + 5802, 5810, 5820, 5828, 5834, 5842, 5861, 5869, 5875, 5883, 5893, 5901, 5907, + 5915, 5937, 5945, 5951, 5959, 5969, 5977, 5983, 5991, 6010, 6018, 6024, 6032, + 6042, 6050, 6056, 6064, 6090, 6098, 6104, 6112, 6122, 6130, 6136, 6144, 6163, + 6171, 6177, 6185, 6195, 6203, 6209, 6217, 6239, 6247, 6253, 6261, 6271, 6279, + 6285, 6293, 6312, 6320, 6326, 6334, 6344, 6352, 6358, 6366, 6232, 6240, 6246, + 6254, 6264, 6272, 6278, 6286, 6305, 6313, 6319, 6327, 6337, 6345, 6351, 6359, + 6381, 6389, 6395, 6403, 6413, 6421, 6427, 6435, 6454, 6462, 6468, 6476, 6486, + 6494, 6500, 6508, 6534, 6542, 6548, 6556, 6566, 6574, 6580, 6588, 6607, 6615, + 6621, 6629, 6639, 6647, 6653, 6661, 6683, 6691, 6697, 6705, 6715, 6723, 6729, + 6737, 6756, 6764, 6770, 6778, 6788, 6796, 6802, 6810, 6608, 6616, 6622, 6630, + 6640, 6648, 6654, 6662, 6681, 6689, 6695, 6703, 6713, 6721, 6727, 6735, 6757, + 6765, 6771, 6779, 6789, 6797, 6803, 6811, 6830, 6838, 6844, 6852, 6862, 6870, + 6876, 6884, 6910, 6918, 6924, 6932, 6942, 6950, 6956, 6964, 6983, 6991, 6997, + 7005, 7015, 7023, 7029, 7037, 7059, 7067, 7073, 7081, 7091, 7099, 7105, 7113, + 7132, 7140, 7146, 7154, 7164, 7172, 7178, 7186, 7052, 7060, 7066, 7074, 7084, + 7092, 7098, 7106, 7125, 7133, 7139, 7147, 7157, 7165, 7171, 7179, 7201, 7209, + 7215, 7223, 7233, 7241, 7247, 7255, 7274, 7282, 7288, 7296, 7306, 7314, 7320, + 7328, 7354, 7362, 7368, 7376, 7386, 7394, 7400, 7408, 7427, 7435, 7441, 7449, + 7459, 7467, 7473, 7481, 7503, 7511, 7517, 7525, 7535, 7543, 7549, 7557, 7576, + 7584, 7590, 7598, 7608, 7616, 7622, 7630, 6899, 6907, 6913, 6921, 6931, 6939, + 6945, 6953, 6972, 6980, 6986, 6994, 7004, 7012, 7018, 7026, 7048, 7056, 7062, + 7070, 7080, 7088, 7094, 7102, 7121, 7129, 7135, 7143, 7153, 7161, 7167, 7175, + 7201, 7209, 7215, 7223, 7233, 7241, 7247, 7255, 7274, 7282, 7288, 7296, 7306, + 7314, 7320, 7328, 7350, 7358, 7364, 7372, 7382, 7390, 7396, 7404, 7423, 7431, + 7437, 7445, 7455, 7463, 7469, 7477, 7343, 7351, 7357, 7365, 7375, 7383, 7389, + 7397, 7416, 7424, 7430, 7438, 7448, 7456, 7462, 7470, 7492, 7500, 7506, 7514, + 7524, 7532, 7538, 7546, 7565, 7573, 7579, 7587, 7597, 7605, 7611, 7619, 7645, + 7653, 7659, 7667, 7677, 7685, 7691, 7699, 7718, 7726, 7732, 7740, 7750, 7758, + 7764, 7772, 7794, 7802, 7808, 7816, 7826, 7834, 7840, 7848, 7867, 7875, 7881, + 7889, 7899, 7907, 7913, 7921, 7719, 7727, 7733, 7741, 7751, 7759, 7765, 7773, + 7792, 7800, 7806, 7814, 7824, 7832, 7838, 7846, 7868, 7876, 7882, 7890, 7900, + 7908, 7914, 7922, 7941, 7949, 7955, 7963, 7973, 7981, 7987, 7995, 8021, 8029, + 8035, 8043, 8053, 8061, 8067, 8075, 8094, 8102, 8108, 8116, 8126, 8134, 8140, + 8148, 8170, 8178, 8184, 8192, 8202, 8210, 8216, 8224, 8243, 8251, 8257, 8265, + 8275, + + + }; + + public static readonly TOKENVALUE[] dct_value_tokens = new TOKENVALUE[4096] + { + new TOKENVALUE(10, 3963), new TOKENVALUE(10, 3961), new TOKENVALUE(10, 3959), new TOKENVALUE(10, 3957), new TOKENVALUE(10, 3955), + new TOKENVALUE(10, 3953), new TOKENVALUE(10, 3951), new TOKENVALUE(10, 3949), new TOKENVALUE(10, 3947), new TOKENVALUE(10, 3945), + new TOKENVALUE(10, 3943), new TOKENVALUE(10, 3941), new TOKENVALUE(10, 3939), new TOKENVALUE(10, 3937), new TOKENVALUE(10, 3935), + new TOKENVALUE(10, 3933), new TOKENVALUE(10, 3931), new TOKENVALUE(10, 3929), new TOKENVALUE(10, 3927), new TOKENVALUE(10, 3925), + new TOKENVALUE(10, 3923), new TOKENVALUE(10, 3921), new TOKENVALUE(10, 3919), new TOKENVALUE(10, 3917), new TOKENVALUE(10, 3915), + new TOKENVALUE(10, 3913), new TOKENVALUE(10, 3911), new TOKENVALUE(10, 3909), new TOKENVALUE(10, 3907), new TOKENVALUE(10, 3905), + new TOKENVALUE(10, 3903), new TOKENVALUE(10, 3901), new TOKENVALUE(10, 3899), new TOKENVALUE(10, 3897), new TOKENVALUE(10, 3895), + new TOKENVALUE(10, 3893), new TOKENVALUE(10, 3891), new TOKENVALUE(10, 3889), new TOKENVALUE(10, 3887), new TOKENVALUE(10, 3885), + new TOKENVALUE(10, 3883), new TOKENVALUE(10, 3881), new TOKENVALUE(10, 3879), new TOKENVALUE(10, 3877), new TOKENVALUE(10, 3875), + new TOKENVALUE(10, 3873), new TOKENVALUE(10, 3871), new TOKENVALUE(10, 3869), new TOKENVALUE(10, 3867), new TOKENVALUE(10, 3865), + new TOKENVALUE(10, 3863), new TOKENVALUE(10, 3861), new TOKENVALUE(10, 3859), new TOKENVALUE(10, 3857), new TOKENVALUE(10, 3855), + new TOKENVALUE(10, 3853), new TOKENVALUE(10, 3851), new TOKENVALUE(10, 3849), new TOKENVALUE(10, 3847), new TOKENVALUE(10, 3845), + new TOKENVALUE(10, 3843), new TOKENVALUE(10, 3841), new TOKENVALUE(10, 3839), new TOKENVALUE(10, 3837), new TOKENVALUE(10, 3835), + new TOKENVALUE(10, 3833), new TOKENVALUE(10, 3831), new TOKENVALUE(10, 3829), new TOKENVALUE(10, 3827), new TOKENVALUE(10, 3825), + new TOKENVALUE(10, 3823), new TOKENVALUE(10, 3821), new TOKENVALUE(10, 3819), new TOKENVALUE(10, 3817), new TOKENVALUE(10, 3815), + new TOKENVALUE(10, 3813), new TOKENVALUE(10, 3811), new TOKENVALUE(10, 3809), new TOKENVALUE(10, 3807), new TOKENVALUE(10, 3805), + new TOKENVALUE(10, 3803), new TOKENVALUE(10, 3801), new TOKENVALUE(10, 3799), new TOKENVALUE(10, 3797), new TOKENVALUE(10, 3795), + new TOKENVALUE(10, 3793), new TOKENVALUE(10, 3791), new TOKENVALUE(10, 3789), new TOKENVALUE(10, 3787), new TOKENVALUE(10, 3785), + new TOKENVALUE(10, 3783), new TOKENVALUE(10, 3781), new TOKENVALUE(10, 3779), new TOKENVALUE(10, 3777), new TOKENVALUE(10, 3775), + new TOKENVALUE(10, 3773), new TOKENVALUE(10, 3771), new TOKENVALUE(10, 3769), new TOKENVALUE(10, 3767), new TOKENVALUE(10, 3765), + new TOKENVALUE(10, 3763), new TOKENVALUE(10, 3761), new TOKENVALUE(10, 3759), new TOKENVALUE(10, 3757), new TOKENVALUE(10, 3755), + new TOKENVALUE(10, 3753), new TOKENVALUE(10, 3751), new TOKENVALUE(10, 3749), new TOKENVALUE(10, 3747), new TOKENVALUE(10, 3745), + new TOKENVALUE(10, 3743), new TOKENVALUE(10, 3741), new TOKENVALUE(10, 3739), new TOKENVALUE(10, 3737), new TOKENVALUE(10, 3735), + new TOKENVALUE(10, 3733), new TOKENVALUE(10, 3731), new TOKENVALUE(10, 3729), new TOKENVALUE(10, 3727), new TOKENVALUE(10, 3725), + new TOKENVALUE(10, 3723), new TOKENVALUE(10, 3721), new TOKENVALUE(10, 3719), new TOKENVALUE(10, 3717), new TOKENVALUE(10, 3715), + new TOKENVALUE(10, 3713), new TOKENVALUE(10, 3711), new TOKENVALUE(10, 3709), new TOKENVALUE(10, 3707), new TOKENVALUE(10, 3705), + new TOKENVALUE(10, 3703), new TOKENVALUE(10, 3701), new TOKENVALUE(10, 3699), new TOKENVALUE(10, 3697), new TOKENVALUE(10, 3695), + new TOKENVALUE(10, 3693), new TOKENVALUE(10, 3691), new TOKENVALUE(10, 3689), new TOKENVALUE(10, 3687), new TOKENVALUE(10, 3685), + new TOKENVALUE(10, 3683), new TOKENVALUE(10, 3681), new TOKENVALUE(10, 3679), new TOKENVALUE(10, 3677), new TOKENVALUE(10, 3675), + new TOKENVALUE(10, 3673), new TOKENVALUE(10, 3671), new TOKENVALUE(10, 3669), new TOKENVALUE(10, 3667), new TOKENVALUE(10, 3665), + new TOKENVALUE(10, 3663), new TOKENVALUE(10, 3661), new TOKENVALUE(10, 3659), new TOKENVALUE(10, 3657), new TOKENVALUE(10, 3655), + new TOKENVALUE(10, 3653), new TOKENVALUE(10, 3651), new TOKENVALUE(10, 3649), new TOKENVALUE(10, 3647), new TOKENVALUE(10, 3645), + new TOKENVALUE(10, 3643), new TOKENVALUE(10, 3641), new TOKENVALUE(10, 3639), new TOKENVALUE(10, 3637), new TOKENVALUE(10, 3635), + new TOKENVALUE(10, 3633), new TOKENVALUE(10, 3631), new TOKENVALUE(10, 3629), new TOKENVALUE(10, 3627), new TOKENVALUE(10, 3625), + new TOKENVALUE(10, 3623), new TOKENVALUE(10, 3621), new TOKENVALUE(10, 3619), new TOKENVALUE(10, 3617), new TOKENVALUE(10, 3615), + new TOKENVALUE(10, 3613), new TOKENVALUE(10, 3611), new TOKENVALUE(10, 3609), new TOKENVALUE(10, 3607), new TOKENVALUE(10, 3605), + new TOKENVALUE(10, 3603), new TOKENVALUE(10, 3601), new TOKENVALUE(10, 3599), new TOKENVALUE(10, 3597), new TOKENVALUE(10, 3595), + new TOKENVALUE(10, 3593), new TOKENVALUE(10, 3591), new TOKENVALUE(10, 3589), new TOKENVALUE(10, 3587), new TOKENVALUE(10, 3585), + new TOKENVALUE(10, 3583), new TOKENVALUE(10, 3581), new TOKENVALUE(10, 3579), new TOKENVALUE(10, 3577), new TOKENVALUE(10, 3575), + new TOKENVALUE(10, 3573), new TOKENVALUE(10, 3571), new TOKENVALUE(10, 3569), new TOKENVALUE(10, 3567), new TOKENVALUE(10, 3565), + new TOKENVALUE(10, 3563), new TOKENVALUE(10, 3561), new TOKENVALUE(10, 3559), new TOKENVALUE(10, 3557), new TOKENVALUE(10, 3555), + new TOKENVALUE(10, 3553), new TOKENVALUE(10, 3551), new TOKENVALUE(10, 3549), new TOKENVALUE(10, 3547), new TOKENVALUE(10, 3545), + new TOKENVALUE(10, 3543), new TOKENVALUE(10, 3541), new TOKENVALUE(10, 3539), new TOKENVALUE(10, 3537), new TOKENVALUE(10, 3535), + new TOKENVALUE(10, 3533), new TOKENVALUE(10, 3531), new TOKENVALUE(10, 3529), new TOKENVALUE(10, 3527), new TOKENVALUE(10, 3525), + new TOKENVALUE(10, 3523), new TOKENVALUE(10, 3521), new TOKENVALUE(10, 3519), new TOKENVALUE(10, 3517), new TOKENVALUE(10, 3515), + new TOKENVALUE(10, 3513), new TOKENVALUE(10, 3511), new TOKENVALUE(10, 3509), new TOKENVALUE(10, 3507), new TOKENVALUE(10, 3505), + new TOKENVALUE(10, 3503), new TOKENVALUE(10, 3501), new TOKENVALUE(10, 3499), new TOKENVALUE(10, 3497), new TOKENVALUE(10, 3495), + new TOKENVALUE(10, 3493), new TOKENVALUE(10, 3491), new TOKENVALUE(10, 3489), new TOKENVALUE(10, 3487), new TOKENVALUE(10, 3485), + new TOKENVALUE(10, 3483), new TOKENVALUE(10, 3481), new TOKENVALUE(10, 3479), new TOKENVALUE(10, 3477), new TOKENVALUE(10, 3475), + new TOKENVALUE(10, 3473), new TOKENVALUE(10, 3471), new TOKENVALUE(10, 3469), new TOKENVALUE(10, 3467), new TOKENVALUE(10, 3465), + new TOKENVALUE(10, 3463), new TOKENVALUE(10, 3461), new TOKENVALUE(10, 3459), new TOKENVALUE(10, 3457), new TOKENVALUE(10, 3455), + new TOKENVALUE(10, 3453), new TOKENVALUE(10, 3451), new TOKENVALUE(10, 3449), new TOKENVALUE(10, 3447), new TOKENVALUE(10, 3445), + new TOKENVALUE(10, 3443), new TOKENVALUE(10, 3441), new TOKENVALUE(10, 3439), new TOKENVALUE(10, 3437), new TOKENVALUE(10, 3435), + new TOKENVALUE(10, 3433), new TOKENVALUE(10, 3431), new TOKENVALUE(10, 3429), new TOKENVALUE(10, 3427), new TOKENVALUE(10, 3425), + new TOKENVALUE(10, 3423), new TOKENVALUE(10, 3421), new TOKENVALUE(10, 3419), new TOKENVALUE(10, 3417), new TOKENVALUE(10, 3415), + new TOKENVALUE(10, 3413), new TOKENVALUE(10, 3411), new TOKENVALUE(10, 3409), new TOKENVALUE(10, 3407), new TOKENVALUE(10, 3405), + new TOKENVALUE(10, 3403), new TOKENVALUE(10, 3401), new TOKENVALUE(10, 3399), new TOKENVALUE(10, 3397), new TOKENVALUE(10, 3395), + new TOKENVALUE(10, 3393), new TOKENVALUE(10, 3391), new TOKENVALUE(10, 3389), new TOKENVALUE(10, 3387), new TOKENVALUE(10, 3385), + new TOKENVALUE(10, 3383), new TOKENVALUE(10, 3381), new TOKENVALUE(10, 3379), new TOKENVALUE(10, 3377), new TOKENVALUE(10, 3375), + new TOKENVALUE(10, 3373), new TOKENVALUE(10, 3371), new TOKENVALUE(10, 3369), new TOKENVALUE(10, 3367), new TOKENVALUE(10, 3365), + new TOKENVALUE(10, 3363), new TOKENVALUE(10, 3361), new TOKENVALUE(10, 3359), new TOKENVALUE(10, 3357), new TOKENVALUE(10, 3355), + new TOKENVALUE(10, 3353), new TOKENVALUE(10, 3351), new TOKENVALUE(10, 3349), new TOKENVALUE(10, 3347), new TOKENVALUE(10, 3345), + new TOKENVALUE(10, 3343), new TOKENVALUE(10, 3341), new TOKENVALUE(10, 3339), new TOKENVALUE(10, 3337), new TOKENVALUE(10, 3335), + new TOKENVALUE(10, 3333), new TOKENVALUE(10, 3331), new TOKENVALUE(10, 3329), new TOKENVALUE(10, 3327), new TOKENVALUE(10, 3325), + new TOKENVALUE(10, 3323), new TOKENVALUE(10, 3321), new TOKENVALUE(10, 3319), new TOKENVALUE(10, 3317), new TOKENVALUE(10, 3315), + new TOKENVALUE(10, 3313), new TOKENVALUE(10, 3311), new TOKENVALUE(10, 3309), new TOKENVALUE(10, 3307), new TOKENVALUE(10, 3305), + new TOKENVALUE(10, 3303), new TOKENVALUE(10, 3301), new TOKENVALUE(10, 3299), new TOKENVALUE(10, 3297), new TOKENVALUE(10, 3295), + new TOKENVALUE(10, 3293), new TOKENVALUE(10, 3291), new TOKENVALUE(10, 3289), new TOKENVALUE(10, 3287), new TOKENVALUE(10, 3285), + new TOKENVALUE(10, 3283), new TOKENVALUE(10, 3281), new TOKENVALUE(10, 3279), new TOKENVALUE(10, 3277), new TOKENVALUE(10, 3275), + new TOKENVALUE(10, 3273), new TOKENVALUE(10, 3271), new TOKENVALUE(10, 3269), new TOKENVALUE(10, 3267), new TOKENVALUE(10, 3265), + new TOKENVALUE(10, 3263), new TOKENVALUE(10, 3261), new TOKENVALUE(10, 3259), new TOKENVALUE(10, 3257), new TOKENVALUE(10, 3255), + new TOKENVALUE(10, 3253), new TOKENVALUE(10, 3251), new TOKENVALUE(10, 3249), new TOKENVALUE(10, 3247), new TOKENVALUE(10, 3245), + new TOKENVALUE(10, 3243), new TOKENVALUE(10, 3241), new TOKENVALUE(10, 3239), new TOKENVALUE(10, 3237), new TOKENVALUE(10, 3235), + new TOKENVALUE(10, 3233), new TOKENVALUE(10, 3231), new TOKENVALUE(10, 3229), new TOKENVALUE(10, 3227), new TOKENVALUE(10, 3225), + new TOKENVALUE(10, 3223), new TOKENVALUE(10, 3221), new TOKENVALUE(10, 3219), new TOKENVALUE(10, 3217), new TOKENVALUE(10, 3215), + new TOKENVALUE(10, 3213), new TOKENVALUE(10, 3211), new TOKENVALUE(10, 3209), new TOKENVALUE(10, 3207), new TOKENVALUE(10, 3205), + new TOKENVALUE(10, 3203), new TOKENVALUE(10, 3201), new TOKENVALUE(10, 3199), new TOKENVALUE(10, 3197), new TOKENVALUE(10, 3195), + new TOKENVALUE(10, 3193), new TOKENVALUE(10, 3191), new TOKENVALUE(10, 3189), new TOKENVALUE(10, 3187), new TOKENVALUE(10, 3185), + new TOKENVALUE(10, 3183), new TOKENVALUE(10, 3181), new TOKENVALUE(10, 3179), new TOKENVALUE(10, 3177), new TOKENVALUE(10, 3175), + new TOKENVALUE(10, 3173), new TOKENVALUE(10, 3171), new TOKENVALUE(10, 3169), new TOKENVALUE(10, 3167), new TOKENVALUE(10, 3165), + new TOKENVALUE(10, 3163), new TOKENVALUE(10, 3161), new TOKENVALUE(10, 3159), new TOKENVALUE(10, 3157), new TOKENVALUE(10, 3155), + new TOKENVALUE(10, 3153), new TOKENVALUE(10, 3151), new TOKENVALUE(10, 3149), new TOKENVALUE(10, 3147), new TOKENVALUE(10, 3145), + new TOKENVALUE(10, 3143), new TOKENVALUE(10, 3141), new TOKENVALUE(10, 3139), new TOKENVALUE(10, 3137), new TOKENVALUE(10, 3135), + new TOKENVALUE(10, 3133), new TOKENVALUE(10, 3131), new TOKENVALUE(10, 3129), new TOKENVALUE(10, 3127), new TOKENVALUE(10, 3125), + new TOKENVALUE(10, 3123), new TOKENVALUE(10, 3121), new TOKENVALUE(10, 3119), new TOKENVALUE(10, 3117), new TOKENVALUE(10, 3115), + new TOKENVALUE(10, 3113), new TOKENVALUE(10, 3111), new TOKENVALUE(10, 3109), new TOKENVALUE(10, 3107), new TOKENVALUE(10, 3105), + new TOKENVALUE(10, 3103), new TOKENVALUE(10, 3101), new TOKENVALUE(10, 3099), new TOKENVALUE(10, 3097), new TOKENVALUE(10, 3095), + new TOKENVALUE(10, 3093), new TOKENVALUE(10, 3091), new TOKENVALUE(10, 3089), new TOKENVALUE(10, 3087), new TOKENVALUE(10, 3085), + new TOKENVALUE(10, 3083), new TOKENVALUE(10, 3081), new TOKENVALUE(10, 3079), new TOKENVALUE(10, 3077), new TOKENVALUE(10, 3075), + new TOKENVALUE(10, 3073), new TOKENVALUE(10, 3071), new TOKENVALUE(10, 3069), new TOKENVALUE(10, 3067), new TOKENVALUE(10, 3065), + new TOKENVALUE(10, 3063), new TOKENVALUE(10, 3061), new TOKENVALUE(10, 3059), new TOKENVALUE(10, 3057), new TOKENVALUE(10, 3055), + new TOKENVALUE(10, 3053), new TOKENVALUE(10, 3051), new TOKENVALUE(10, 3049), new TOKENVALUE(10, 3047), new TOKENVALUE(10, 3045), + new TOKENVALUE(10, 3043), new TOKENVALUE(10, 3041), new TOKENVALUE(10, 3039), new TOKENVALUE(10, 3037), new TOKENVALUE(10, 3035), + new TOKENVALUE(10, 3033), new TOKENVALUE(10, 3031), new TOKENVALUE(10, 3029), new TOKENVALUE(10, 3027), new TOKENVALUE(10, 3025), + new TOKENVALUE(10, 3023), new TOKENVALUE(10, 3021), new TOKENVALUE(10, 3019), new TOKENVALUE(10, 3017), new TOKENVALUE(10, 3015), + new TOKENVALUE(10, 3013), new TOKENVALUE(10, 3011), new TOKENVALUE(10, 3009), new TOKENVALUE(10, 3007), new TOKENVALUE(10, 3005), + new TOKENVALUE(10, 3003), new TOKENVALUE(10, 3001), new TOKENVALUE(10, 2999), new TOKENVALUE(10, 2997), new TOKENVALUE(10, 2995), + new TOKENVALUE(10, 2993), new TOKENVALUE(10, 2991), new TOKENVALUE(10, 2989), new TOKENVALUE(10, 2987), new TOKENVALUE(10, 2985), + new TOKENVALUE(10, 2983), new TOKENVALUE(10, 2981), new TOKENVALUE(10, 2979), new TOKENVALUE(10, 2977), new TOKENVALUE(10, 2975), + new TOKENVALUE(10, 2973), new TOKENVALUE(10, 2971), new TOKENVALUE(10, 2969), new TOKENVALUE(10, 2967), new TOKENVALUE(10, 2965), + new TOKENVALUE(10, 2963), new TOKENVALUE(10, 2961), new TOKENVALUE(10, 2959), new TOKENVALUE(10, 2957), new TOKENVALUE(10, 2955), + new TOKENVALUE(10, 2953), new TOKENVALUE(10, 2951), new TOKENVALUE(10, 2949), new TOKENVALUE(10, 2947), new TOKENVALUE(10, 2945), + new TOKENVALUE(10, 2943), new TOKENVALUE(10, 2941), new TOKENVALUE(10, 2939), new TOKENVALUE(10, 2937), new TOKENVALUE(10, 2935), + new TOKENVALUE(10, 2933), new TOKENVALUE(10, 2931), new TOKENVALUE(10, 2929), new TOKENVALUE(10, 2927), new TOKENVALUE(10, 2925), + new TOKENVALUE(10, 2923), new TOKENVALUE(10, 2921), new TOKENVALUE(10, 2919), new TOKENVALUE(10, 2917), new TOKENVALUE(10, 2915), + new TOKENVALUE(10, 2913), new TOKENVALUE(10, 2911), new TOKENVALUE(10, 2909), new TOKENVALUE(10, 2907), new TOKENVALUE(10, 2905), + new TOKENVALUE(10, 2903), new TOKENVALUE(10, 2901), new TOKENVALUE(10, 2899), new TOKENVALUE(10, 2897), new TOKENVALUE(10, 2895), + new TOKENVALUE(10, 2893), new TOKENVALUE(10, 2891), new TOKENVALUE(10, 2889), new TOKENVALUE(10, 2887), new TOKENVALUE(10, 2885), + new TOKENVALUE(10, 2883), new TOKENVALUE(10, 2881), new TOKENVALUE(10, 2879), new TOKENVALUE(10, 2877), new TOKENVALUE(10, 2875), + new TOKENVALUE(10, 2873), new TOKENVALUE(10, 2871), new TOKENVALUE(10, 2869), new TOKENVALUE(10, 2867), new TOKENVALUE(10, 2865), + new TOKENVALUE(10, 2863), new TOKENVALUE(10, 2861), new TOKENVALUE(10, 2859), new TOKENVALUE(10, 2857), new TOKENVALUE(10, 2855), + new TOKENVALUE(10, 2853), new TOKENVALUE(10, 2851), new TOKENVALUE(10, 2849), new TOKENVALUE(10, 2847), new TOKENVALUE(10, 2845), + new TOKENVALUE(10, 2843), new TOKENVALUE(10, 2841), new TOKENVALUE(10, 2839), new TOKENVALUE(10, 2837), new TOKENVALUE(10, 2835), + new TOKENVALUE(10, 2833), new TOKENVALUE(10, 2831), new TOKENVALUE(10, 2829), new TOKENVALUE(10, 2827), new TOKENVALUE(10, 2825), + new TOKENVALUE(10, 2823), new TOKENVALUE(10, 2821), new TOKENVALUE(10, 2819), new TOKENVALUE(10, 2817), new TOKENVALUE(10, 2815), + new TOKENVALUE(10, 2813), new TOKENVALUE(10, 2811), new TOKENVALUE(10, 2809), new TOKENVALUE(10, 2807), new TOKENVALUE(10, 2805), + new TOKENVALUE(10, 2803), new TOKENVALUE(10, 2801), new TOKENVALUE(10, 2799), new TOKENVALUE(10, 2797), new TOKENVALUE(10, 2795), + new TOKENVALUE(10, 2793), new TOKENVALUE(10, 2791), new TOKENVALUE(10, 2789), new TOKENVALUE(10, 2787), new TOKENVALUE(10, 2785), + new TOKENVALUE(10, 2783), new TOKENVALUE(10, 2781), new TOKENVALUE(10, 2779), new TOKENVALUE(10, 2777), new TOKENVALUE(10, 2775), + new TOKENVALUE(10, 2773), new TOKENVALUE(10, 2771), new TOKENVALUE(10, 2769), new TOKENVALUE(10, 2767), new TOKENVALUE(10, 2765), + new TOKENVALUE(10, 2763), new TOKENVALUE(10, 2761), new TOKENVALUE(10, 2759), new TOKENVALUE(10, 2757), new TOKENVALUE(10, 2755), + new TOKENVALUE(10, 2753), new TOKENVALUE(10, 2751), new TOKENVALUE(10, 2749), new TOKENVALUE(10, 2747), new TOKENVALUE(10, 2745), + new TOKENVALUE(10, 2743), new TOKENVALUE(10, 2741), new TOKENVALUE(10, 2739), new TOKENVALUE(10, 2737), new TOKENVALUE(10, 2735), + new TOKENVALUE(10, 2733), new TOKENVALUE(10, 2731), new TOKENVALUE(10, 2729), new TOKENVALUE(10, 2727), new TOKENVALUE(10, 2725), + new TOKENVALUE(10, 2723), new TOKENVALUE(10, 2721), new TOKENVALUE(10, 2719), new TOKENVALUE(10, 2717), new TOKENVALUE(10, 2715), + new TOKENVALUE(10, 2713), new TOKENVALUE(10, 2711), new TOKENVALUE(10, 2709), new TOKENVALUE(10, 2707), new TOKENVALUE(10, 2705), + new TOKENVALUE(10, 2703), new TOKENVALUE(10, 2701), new TOKENVALUE(10, 2699), new TOKENVALUE(10, 2697), new TOKENVALUE(10, 2695), + new TOKENVALUE(10, 2693), new TOKENVALUE(10, 2691), new TOKENVALUE(10, 2689), new TOKENVALUE(10, 2687), new TOKENVALUE(10, 2685), + new TOKENVALUE(10, 2683), new TOKENVALUE(10, 2681), new TOKENVALUE(10, 2679), new TOKENVALUE(10, 2677), new TOKENVALUE(10, 2675), + new TOKENVALUE(10, 2673), new TOKENVALUE(10, 2671), new TOKENVALUE(10, 2669), new TOKENVALUE(10, 2667), new TOKENVALUE(10, 2665), + new TOKENVALUE(10, 2663), new TOKENVALUE(10, 2661), new TOKENVALUE(10, 2659), new TOKENVALUE(10, 2657), new TOKENVALUE(10, 2655), + new TOKENVALUE(10, 2653), new TOKENVALUE(10, 2651), new TOKENVALUE(10, 2649), new TOKENVALUE(10, 2647), new TOKENVALUE(10, 2645), + new TOKENVALUE(10, 2643), new TOKENVALUE(10, 2641), new TOKENVALUE(10, 2639), new TOKENVALUE(10, 2637), new TOKENVALUE(10, 2635), + new TOKENVALUE(10, 2633), new TOKENVALUE(10, 2631), new TOKENVALUE(10, 2629), new TOKENVALUE(10, 2627), new TOKENVALUE(10, 2625), + new TOKENVALUE(10, 2623), new TOKENVALUE(10, 2621), new TOKENVALUE(10, 2619), new TOKENVALUE(10, 2617), new TOKENVALUE(10, 2615), + new TOKENVALUE(10, 2613), new TOKENVALUE(10, 2611), new TOKENVALUE(10, 2609), new TOKENVALUE(10, 2607), new TOKENVALUE(10, 2605), + new TOKENVALUE(10, 2603), new TOKENVALUE(10, 2601), new TOKENVALUE(10, 2599), new TOKENVALUE(10, 2597), new TOKENVALUE(10, 2595), + new TOKENVALUE(10, 2593), new TOKENVALUE(10, 2591), new TOKENVALUE(10, 2589), new TOKENVALUE(10, 2587), new TOKENVALUE(10, 2585), + new TOKENVALUE(10, 2583), new TOKENVALUE(10, 2581), new TOKENVALUE(10, 2579), new TOKENVALUE(10, 2577), new TOKENVALUE(10, 2575), + new TOKENVALUE(10, 2573), new TOKENVALUE(10, 2571), new TOKENVALUE(10, 2569), new TOKENVALUE(10, 2567), new TOKENVALUE(10, 2565), + new TOKENVALUE(10, 2563), new TOKENVALUE(10, 2561), new TOKENVALUE(10, 2559), new TOKENVALUE(10, 2557), new TOKENVALUE(10, 2555), + new TOKENVALUE(10, 2553), new TOKENVALUE(10, 2551), new TOKENVALUE(10, 2549), new TOKENVALUE(10, 2547), new TOKENVALUE(10, 2545), + new TOKENVALUE(10, 2543), new TOKENVALUE(10, 2541), new TOKENVALUE(10, 2539), new TOKENVALUE(10, 2537), new TOKENVALUE(10, 2535), + new TOKENVALUE(10, 2533), new TOKENVALUE(10, 2531), new TOKENVALUE(10, 2529), new TOKENVALUE(10, 2527), new TOKENVALUE(10, 2525), + new TOKENVALUE(10, 2523), new TOKENVALUE(10, 2521), new TOKENVALUE(10, 2519), new TOKENVALUE(10, 2517), new TOKENVALUE(10, 2515), + new TOKENVALUE(10, 2513), new TOKENVALUE(10, 2511), new TOKENVALUE(10, 2509), new TOKENVALUE(10, 2507), new TOKENVALUE(10, 2505), + new TOKENVALUE(10, 2503), new TOKENVALUE(10, 2501), new TOKENVALUE(10, 2499), new TOKENVALUE(10, 2497), new TOKENVALUE(10, 2495), + new TOKENVALUE(10, 2493), new TOKENVALUE(10, 2491), new TOKENVALUE(10, 2489), new TOKENVALUE(10, 2487), new TOKENVALUE(10, 2485), + new TOKENVALUE(10, 2483), new TOKENVALUE(10, 2481), new TOKENVALUE(10, 2479), new TOKENVALUE(10, 2477), new TOKENVALUE(10, 2475), + new TOKENVALUE(10, 2473), new TOKENVALUE(10, 2471), new TOKENVALUE(10, 2469), new TOKENVALUE(10, 2467), new TOKENVALUE(10, 2465), + new TOKENVALUE(10, 2463), new TOKENVALUE(10, 2461), new TOKENVALUE(10, 2459), new TOKENVALUE(10, 2457), new TOKENVALUE(10, 2455), + new TOKENVALUE(10, 2453), new TOKENVALUE(10, 2451), new TOKENVALUE(10, 2449), new TOKENVALUE(10, 2447), new TOKENVALUE(10, 2445), + new TOKENVALUE(10, 2443), new TOKENVALUE(10, 2441), new TOKENVALUE(10, 2439), new TOKENVALUE(10, 2437), new TOKENVALUE(10, 2435), + new TOKENVALUE(10, 2433), new TOKENVALUE(10, 2431), new TOKENVALUE(10, 2429), new TOKENVALUE(10, 2427), new TOKENVALUE(10, 2425), + new TOKENVALUE(10, 2423), new TOKENVALUE(10, 2421), new TOKENVALUE(10, 2419), new TOKENVALUE(10, 2417), new TOKENVALUE(10, 2415), + new TOKENVALUE(10, 2413), new TOKENVALUE(10, 2411), new TOKENVALUE(10, 2409), new TOKENVALUE(10, 2407), new TOKENVALUE(10, 2405), + new TOKENVALUE(10, 2403), new TOKENVALUE(10, 2401), new TOKENVALUE(10, 2399), new TOKENVALUE(10, 2397), new TOKENVALUE(10, 2395), + new TOKENVALUE(10, 2393), new TOKENVALUE(10, 2391), new TOKENVALUE(10, 2389), new TOKENVALUE(10, 2387), new TOKENVALUE(10, 2385), + new TOKENVALUE(10, 2383), new TOKENVALUE(10, 2381), new TOKENVALUE(10, 2379), new TOKENVALUE(10, 2377), new TOKENVALUE(10, 2375), + new TOKENVALUE(10, 2373), new TOKENVALUE(10, 2371), new TOKENVALUE(10, 2369), new TOKENVALUE(10, 2367), new TOKENVALUE(10, 2365), + new TOKENVALUE(10, 2363), new TOKENVALUE(10, 2361), new TOKENVALUE(10, 2359), new TOKENVALUE(10, 2357), new TOKENVALUE(10, 2355), + new TOKENVALUE(10, 2353), new TOKENVALUE(10, 2351), new TOKENVALUE(10, 2349), new TOKENVALUE(10, 2347), new TOKENVALUE(10, 2345), + new TOKENVALUE(10, 2343), new TOKENVALUE(10, 2341), new TOKENVALUE(10, 2339), new TOKENVALUE(10, 2337), new TOKENVALUE(10, 2335), + new TOKENVALUE(10, 2333), new TOKENVALUE(10, 2331), new TOKENVALUE(10, 2329), new TOKENVALUE(10, 2327), new TOKENVALUE(10, 2325), + new TOKENVALUE(10, 2323), new TOKENVALUE(10, 2321), new TOKENVALUE(10, 2319), new TOKENVALUE(10, 2317), new TOKENVALUE(10, 2315), + new TOKENVALUE(10, 2313), new TOKENVALUE(10, 2311), new TOKENVALUE(10, 2309), new TOKENVALUE(10, 2307), new TOKENVALUE(10, 2305), + new TOKENVALUE(10, 2303), new TOKENVALUE(10, 2301), new TOKENVALUE(10, 2299), new TOKENVALUE(10, 2297), new TOKENVALUE(10, 2295), + new TOKENVALUE(10, 2293), new TOKENVALUE(10, 2291), new TOKENVALUE(10, 2289), new TOKENVALUE(10, 2287), new TOKENVALUE(10, 2285), + new TOKENVALUE(10, 2283), new TOKENVALUE(10, 2281), new TOKENVALUE(10, 2279), new TOKENVALUE(10, 2277), new TOKENVALUE(10, 2275), + new TOKENVALUE(10, 2273), new TOKENVALUE(10, 2271), new TOKENVALUE(10, 2269), new TOKENVALUE(10, 2267), new TOKENVALUE(10, 2265), + new TOKENVALUE(10, 2263), new TOKENVALUE(10, 2261), new TOKENVALUE(10, 2259), new TOKENVALUE(10, 2257), new TOKENVALUE(10, 2255), + new TOKENVALUE(10, 2253), new TOKENVALUE(10, 2251), new TOKENVALUE(10, 2249), new TOKENVALUE(10, 2247), new TOKENVALUE(10, 2245), + new TOKENVALUE(10, 2243), new TOKENVALUE(10, 2241), new TOKENVALUE(10, 2239), new TOKENVALUE(10, 2237), new TOKENVALUE(10, 2235), + new TOKENVALUE(10, 2233), new TOKENVALUE(10, 2231), new TOKENVALUE(10, 2229), new TOKENVALUE(10, 2227), new TOKENVALUE(10, 2225), + new TOKENVALUE(10, 2223), new TOKENVALUE(10, 2221), new TOKENVALUE(10, 2219), new TOKENVALUE(10, 2217), new TOKENVALUE(10, 2215), + new TOKENVALUE(10, 2213), new TOKENVALUE(10, 2211), new TOKENVALUE(10, 2209), new TOKENVALUE(10, 2207), new TOKENVALUE(10, 2205), + new TOKENVALUE(10, 2203), new TOKENVALUE(10, 2201), new TOKENVALUE(10, 2199), new TOKENVALUE(10, 2197), new TOKENVALUE(10, 2195), + new TOKENVALUE(10, 2193), new TOKENVALUE(10, 2191), new TOKENVALUE(10, 2189), new TOKENVALUE(10, 2187), new TOKENVALUE(10, 2185), + new TOKENVALUE(10, 2183), new TOKENVALUE(10, 2181), new TOKENVALUE(10, 2179), new TOKENVALUE(10, 2177), new TOKENVALUE(10, 2175), + new TOKENVALUE(10, 2173), new TOKENVALUE(10, 2171), new TOKENVALUE(10, 2169), new TOKENVALUE(10, 2167), new TOKENVALUE(10, 2165), + new TOKENVALUE(10, 2163), new TOKENVALUE(10, 2161), new TOKENVALUE(10, 2159), new TOKENVALUE(10, 2157), new TOKENVALUE(10, 2155), + new TOKENVALUE(10, 2153), new TOKENVALUE(10, 2151), new TOKENVALUE(10, 2149), new TOKENVALUE(10, 2147), new TOKENVALUE(10, 2145), + new TOKENVALUE(10, 2143), new TOKENVALUE(10, 2141), new TOKENVALUE(10, 2139), new TOKENVALUE(10, 2137), new TOKENVALUE(10, 2135), + new TOKENVALUE(10, 2133), new TOKENVALUE(10, 2131), new TOKENVALUE(10, 2129), new TOKENVALUE(10, 2127), new TOKENVALUE(10, 2125), + new TOKENVALUE(10, 2123), new TOKENVALUE(10, 2121), new TOKENVALUE(10, 2119), new TOKENVALUE(10, 2117), new TOKENVALUE(10, 2115), + new TOKENVALUE(10, 2113), new TOKENVALUE(10, 2111), new TOKENVALUE(10, 2109), new TOKENVALUE(10, 2107), new TOKENVALUE(10, 2105), + new TOKENVALUE(10, 2103), new TOKENVALUE(10, 2101), new TOKENVALUE(10, 2099), new TOKENVALUE(10, 2097), new TOKENVALUE(10, 2095), + new TOKENVALUE(10, 2093), new TOKENVALUE(10, 2091), new TOKENVALUE(10, 2089), new TOKENVALUE(10, 2087), new TOKENVALUE(10, 2085), + new TOKENVALUE(10, 2083), new TOKENVALUE(10, 2081), new TOKENVALUE(10, 2079), new TOKENVALUE(10, 2077), new TOKENVALUE(10, 2075), + new TOKENVALUE(10, 2073), new TOKENVALUE(10, 2071), new TOKENVALUE(10, 2069), new TOKENVALUE(10, 2067), new TOKENVALUE(10, 2065), + new TOKENVALUE(10, 2063), new TOKENVALUE(10, 2061), new TOKENVALUE(10, 2059), new TOKENVALUE(10, 2057), new TOKENVALUE(10, 2055), + new TOKENVALUE(10, 2053), new TOKENVALUE(10, 2051), new TOKENVALUE(10, 2049), new TOKENVALUE(10, 2047), new TOKENVALUE(10, 2045), + new TOKENVALUE(10, 2043), new TOKENVALUE(10, 2041), new TOKENVALUE(10, 2039), new TOKENVALUE(10, 2037), new TOKENVALUE(10, 2035), + new TOKENVALUE(10, 2033), new TOKENVALUE(10, 2031), new TOKENVALUE(10, 2029), new TOKENVALUE(10, 2027), new TOKENVALUE(10, 2025), + new TOKENVALUE(10, 2023), new TOKENVALUE(10, 2021), new TOKENVALUE(10, 2019), new TOKENVALUE(10, 2017), new TOKENVALUE(10, 2015), + new TOKENVALUE(10, 2013), new TOKENVALUE(10, 2011), new TOKENVALUE(10, 2009), new TOKENVALUE(10, 2007), new TOKENVALUE(10, 2005), + new TOKENVALUE(10, 2003), new TOKENVALUE(10, 2001), new TOKENVALUE(10, 1999), new TOKENVALUE(10, 1997), new TOKENVALUE(10, 1995), + new TOKENVALUE(10, 1993), new TOKENVALUE(10, 1991), new TOKENVALUE(10, 1989), new TOKENVALUE(10, 1987), new TOKENVALUE(10, 1985), + new TOKENVALUE(10, 1983), new TOKENVALUE(10, 1981), new TOKENVALUE(10, 1979), new TOKENVALUE(10, 1977), new TOKENVALUE(10, 1975), + new TOKENVALUE(10, 1973), new TOKENVALUE(10, 1971), new TOKENVALUE(10, 1969), new TOKENVALUE(10, 1967), new TOKENVALUE(10, 1965), + new TOKENVALUE(10, 1963), new TOKENVALUE(10, 1961), new TOKENVALUE(10, 1959), new TOKENVALUE(10, 1957), new TOKENVALUE(10, 1955), + new TOKENVALUE(10, 1953), new TOKENVALUE(10, 1951), new TOKENVALUE(10, 1949), new TOKENVALUE(10, 1947), new TOKENVALUE(10, 1945), + new TOKENVALUE(10, 1943), new TOKENVALUE(10, 1941), new TOKENVALUE(10, 1939), new TOKENVALUE(10, 1937), new TOKENVALUE(10, 1935), + new TOKENVALUE(10, 1933), new TOKENVALUE(10, 1931), new TOKENVALUE(10, 1929), new TOKENVALUE(10, 1927), new TOKENVALUE(10, 1925), + new TOKENVALUE(10, 1923), new TOKENVALUE(10, 1921), new TOKENVALUE(10, 1919), new TOKENVALUE(10, 1917), new TOKENVALUE(10, 1915), + new TOKENVALUE(10, 1913), new TOKENVALUE(10, 1911), new TOKENVALUE(10, 1909), new TOKENVALUE(10, 1907), new TOKENVALUE(10, 1905), + new TOKENVALUE(10, 1903), new TOKENVALUE(10, 1901), new TOKENVALUE(10, 1899), new TOKENVALUE(10, 1897), new TOKENVALUE(10, 1895), + new TOKENVALUE(10, 1893), new TOKENVALUE(10, 1891), new TOKENVALUE(10, 1889), new TOKENVALUE(10, 1887), new TOKENVALUE(10, 1885), + new TOKENVALUE(10, 1883), new TOKENVALUE(10, 1881), new TOKENVALUE(10, 1879), new TOKENVALUE(10, 1877), new TOKENVALUE(10, 1875), + new TOKENVALUE(10, 1873), new TOKENVALUE(10, 1871), new TOKENVALUE(10, 1869), new TOKENVALUE(10, 1867), new TOKENVALUE(10, 1865), + new TOKENVALUE(10, 1863), new TOKENVALUE(10, 1861), new TOKENVALUE(10, 1859), new TOKENVALUE(10, 1857), new TOKENVALUE(10, 1855), + new TOKENVALUE(10, 1853), new TOKENVALUE(10, 1851), new TOKENVALUE(10, 1849), new TOKENVALUE(10, 1847), new TOKENVALUE(10, 1845), + new TOKENVALUE(10, 1843), new TOKENVALUE(10, 1841), new TOKENVALUE(10, 1839), new TOKENVALUE(10, 1837), new TOKENVALUE(10, 1835), + new TOKENVALUE(10, 1833), new TOKENVALUE(10, 1831), new TOKENVALUE(10, 1829), new TOKENVALUE(10, 1827), new TOKENVALUE(10, 1825), + new TOKENVALUE(10, 1823), new TOKENVALUE(10, 1821), new TOKENVALUE(10, 1819), new TOKENVALUE(10, 1817), new TOKENVALUE(10, 1815), + new TOKENVALUE(10, 1813), new TOKENVALUE(10, 1811), new TOKENVALUE(10, 1809), new TOKENVALUE(10, 1807), new TOKENVALUE(10, 1805), + new TOKENVALUE(10, 1803), new TOKENVALUE(10, 1801), new TOKENVALUE(10, 1799), new TOKENVALUE(10, 1797), new TOKENVALUE(10, 1795), + new TOKENVALUE(10, 1793), new TOKENVALUE(10, 1791), new TOKENVALUE(10, 1789), new TOKENVALUE(10, 1787), new TOKENVALUE(10, 1785), + new TOKENVALUE(10, 1783), new TOKENVALUE(10, 1781), new TOKENVALUE(10, 1779), new TOKENVALUE(10, 1777), new TOKENVALUE(10, 1775), + new TOKENVALUE(10, 1773), new TOKENVALUE(10, 1771), new TOKENVALUE(10, 1769), new TOKENVALUE(10, 1767), new TOKENVALUE(10, 1765), + new TOKENVALUE(10, 1763), new TOKENVALUE(10, 1761), new TOKENVALUE(10, 1759), new TOKENVALUE(10, 1757), new TOKENVALUE(10, 1755), + new TOKENVALUE(10, 1753), new TOKENVALUE(10, 1751), new TOKENVALUE(10, 1749), new TOKENVALUE(10, 1747), new TOKENVALUE(10, 1745), + new TOKENVALUE(10, 1743), new TOKENVALUE(10, 1741), new TOKENVALUE(10, 1739), new TOKENVALUE(10, 1737), new TOKENVALUE(10, 1735), + new TOKENVALUE(10, 1733), new TOKENVALUE(10, 1731), new TOKENVALUE(10, 1729), new TOKENVALUE(10, 1727), new TOKENVALUE(10, 1725), + new TOKENVALUE(10, 1723), new TOKENVALUE(10, 1721), new TOKENVALUE(10, 1719), new TOKENVALUE(10, 1717), new TOKENVALUE(10, 1715), + new TOKENVALUE(10, 1713), new TOKENVALUE(10, 1711), new TOKENVALUE(10, 1709), new TOKENVALUE(10, 1707), new TOKENVALUE(10, 1705), + new TOKENVALUE(10, 1703), new TOKENVALUE(10, 1701), new TOKENVALUE(10, 1699), new TOKENVALUE(10, 1697), new TOKENVALUE(10, 1695), + new TOKENVALUE(10, 1693), new TOKENVALUE(10, 1691), new TOKENVALUE(10, 1689), new TOKENVALUE(10, 1687), new TOKENVALUE(10, 1685), + new TOKENVALUE(10, 1683), new TOKENVALUE(10, 1681), new TOKENVALUE(10, 1679), new TOKENVALUE(10, 1677), new TOKENVALUE(10, 1675), + new TOKENVALUE(10, 1673), new TOKENVALUE(10, 1671), new TOKENVALUE(10, 1669), new TOKENVALUE(10, 1667), new TOKENVALUE(10, 1665), + new TOKENVALUE(10, 1663), new TOKENVALUE(10, 1661), new TOKENVALUE(10, 1659), new TOKENVALUE(10, 1657), new TOKENVALUE(10, 1655), + new TOKENVALUE(10, 1653), new TOKENVALUE(10, 1651), new TOKENVALUE(10, 1649), new TOKENVALUE(10, 1647), new TOKENVALUE(10, 1645), + new TOKENVALUE(10, 1643), new TOKENVALUE(10, 1641), new TOKENVALUE(10, 1639), new TOKENVALUE(10, 1637), new TOKENVALUE(10, 1635), + new TOKENVALUE(10, 1633), new TOKENVALUE(10, 1631), new TOKENVALUE(10, 1629), new TOKENVALUE(10, 1627), new TOKENVALUE(10, 1625), + new TOKENVALUE(10, 1623), new TOKENVALUE(10, 1621), new TOKENVALUE(10, 1619), new TOKENVALUE(10, 1617), new TOKENVALUE(10, 1615), + new TOKENVALUE(10, 1613), new TOKENVALUE(10, 1611), new TOKENVALUE(10, 1609), new TOKENVALUE(10, 1607), new TOKENVALUE(10, 1605), + new TOKENVALUE(10, 1603), new TOKENVALUE(10, 1601), new TOKENVALUE(10, 1599), new TOKENVALUE(10, 1597), new TOKENVALUE(10, 1595), + new TOKENVALUE(10, 1593), new TOKENVALUE(10, 1591), new TOKENVALUE(10, 1589), new TOKENVALUE(10, 1587), new TOKENVALUE(10, 1585), + new TOKENVALUE(10, 1583), new TOKENVALUE(10, 1581), new TOKENVALUE(10, 1579), new TOKENVALUE(10, 1577), new TOKENVALUE(10, 1575), + new TOKENVALUE(10, 1573), new TOKENVALUE(10, 1571), new TOKENVALUE(10, 1569), new TOKENVALUE(10, 1567), new TOKENVALUE(10, 1565), + new TOKENVALUE(10, 1563), new TOKENVALUE(10, 1561), new TOKENVALUE(10, 1559), new TOKENVALUE(10, 1557), new TOKENVALUE(10, 1555), + new TOKENVALUE(10, 1553), new TOKENVALUE(10, 1551), new TOKENVALUE(10, 1549), new TOKENVALUE(10, 1547), new TOKENVALUE(10, 1545), + new TOKENVALUE(10, 1543), new TOKENVALUE(10, 1541), new TOKENVALUE(10, 1539), new TOKENVALUE(10, 1537), new TOKENVALUE(10, 1535), + new TOKENVALUE(10, 1533), new TOKENVALUE(10, 1531), new TOKENVALUE(10, 1529), new TOKENVALUE(10, 1527), new TOKENVALUE(10, 1525), + new TOKENVALUE(10, 1523), new TOKENVALUE(10, 1521), new TOKENVALUE(10, 1519), new TOKENVALUE(10, 1517), new TOKENVALUE(10, 1515), + new TOKENVALUE(10, 1513), new TOKENVALUE(10, 1511), new TOKENVALUE(10, 1509), new TOKENVALUE(10, 1507), new TOKENVALUE(10, 1505), + new TOKENVALUE(10, 1503), new TOKENVALUE(10, 1501), new TOKENVALUE(10, 1499), new TOKENVALUE(10, 1497), new TOKENVALUE(10, 1495), + new TOKENVALUE(10, 1493), new TOKENVALUE(10, 1491), new TOKENVALUE(10, 1489), new TOKENVALUE(10, 1487), new TOKENVALUE(10, 1485), + new TOKENVALUE(10, 1483), new TOKENVALUE(10, 1481), new TOKENVALUE(10, 1479), new TOKENVALUE(10, 1477), new TOKENVALUE(10, 1475), + new TOKENVALUE(10, 1473), new TOKENVALUE(10, 1471), new TOKENVALUE(10, 1469), new TOKENVALUE(10, 1467), new TOKENVALUE(10, 1465), + new TOKENVALUE(10, 1463), new TOKENVALUE(10, 1461), new TOKENVALUE(10, 1459), new TOKENVALUE(10, 1457), new TOKENVALUE(10, 1455), + new TOKENVALUE(10, 1453), new TOKENVALUE(10, 1451), new TOKENVALUE(10, 1449), new TOKENVALUE(10, 1447), new TOKENVALUE(10, 1445), + new TOKENVALUE(10, 1443), new TOKENVALUE(10, 1441), new TOKENVALUE(10, 1439), new TOKENVALUE(10, 1437), new TOKENVALUE(10, 1435), + new TOKENVALUE(10, 1433), new TOKENVALUE(10, 1431), new TOKENVALUE(10, 1429), new TOKENVALUE(10, 1427), new TOKENVALUE(10, 1425), + new TOKENVALUE(10, 1423), new TOKENVALUE(10, 1421), new TOKENVALUE(10, 1419), new TOKENVALUE(10, 1417), new TOKENVALUE(10, 1415), + new TOKENVALUE(10, 1413), new TOKENVALUE(10, 1411), new TOKENVALUE(10, 1409), new TOKENVALUE(10, 1407), new TOKENVALUE(10, 1405), + new TOKENVALUE(10, 1403), new TOKENVALUE(10, 1401), new TOKENVALUE(10, 1399), new TOKENVALUE(10, 1397), new TOKENVALUE(10, 1395), + new TOKENVALUE(10, 1393), new TOKENVALUE(10, 1391), new TOKENVALUE(10, 1389), new TOKENVALUE(10, 1387), new TOKENVALUE(10, 1385), + new TOKENVALUE(10, 1383), new TOKENVALUE(10, 1381), new TOKENVALUE(10, 1379), new TOKENVALUE(10, 1377), new TOKENVALUE(10, 1375), + new TOKENVALUE(10, 1373), new TOKENVALUE(10, 1371), new TOKENVALUE(10, 1369), new TOKENVALUE(10, 1367), new TOKENVALUE(10, 1365), + new TOKENVALUE(10, 1363), new TOKENVALUE(10, 1361), new TOKENVALUE(10, 1359), new TOKENVALUE(10, 1357), new TOKENVALUE(10, 1355), + new TOKENVALUE(10, 1353), new TOKENVALUE(10, 1351), new TOKENVALUE(10, 1349), new TOKENVALUE(10, 1347), new TOKENVALUE(10, 1345), + new TOKENVALUE(10, 1343), new TOKENVALUE(10, 1341), new TOKENVALUE(10, 1339), new TOKENVALUE(10, 1337), new TOKENVALUE(10, 1335), + new TOKENVALUE(10, 1333), new TOKENVALUE(10, 1331), new TOKENVALUE(10, 1329), new TOKENVALUE(10, 1327), new TOKENVALUE(10, 1325), + new TOKENVALUE(10, 1323), new TOKENVALUE(10, 1321), new TOKENVALUE(10, 1319), new TOKENVALUE(10, 1317), new TOKENVALUE(10, 1315), + new TOKENVALUE(10, 1313), new TOKENVALUE(10, 1311), new TOKENVALUE(10, 1309), new TOKENVALUE(10, 1307), new TOKENVALUE(10, 1305), + new TOKENVALUE(10, 1303), new TOKENVALUE(10, 1301), new TOKENVALUE(10, 1299), new TOKENVALUE(10, 1297), new TOKENVALUE(10, 1295), + new TOKENVALUE(10, 1293), new TOKENVALUE(10, 1291), new TOKENVALUE(10, 1289), new TOKENVALUE(10, 1287), new TOKENVALUE(10, 1285), + new TOKENVALUE(10, 1283), new TOKENVALUE(10, 1281), new TOKENVALUE(10, 1279), new TOKENVALUE(10, 1277), new TOKENVALUE(10, 1275), + new TOKENVALUE(10, 1273), new TOKENVALUE(10, 1271), new TOKENVALUE(10, 1269), new TOKENVALUE(10, 1267), new TOKENVALUE(10, 1265), + new TOKENVALUE(10, 1263), new TOKENVALUE(10, 1261), new TOKENVALUE(10, 1259), new TOKENVALUE(10, 1257), new TOKENVALUE(10, 1255), + new TOKENVALUE(10, 1253), new TOKENVALUE(10, 1251), new TOKENVALUE(10, 1249), new TOKENVALUE(10, 1247), new TOKENVALUE(10, 1245), + new TOKENVALUE(10, 1243), new TOKENVALUE(10, 1241), new TOKENVALUE(10, 1239), new TOKENVALUE(10, 1237), new TOKENVALUE(10, 1235), + new TOKENVALUE(10, 1233), new TOKENVALUE(10, 1231), new TOKENVALUE(10, 1229), new TOKENVALUE(10, 1227), new TOKENVALUE(10, 1225), + new TOKENVALUE(10, 1223), new TOKENVALUE(10, 1221), new TOKENVALUE(10, 1219), new TOKENVALUE(10, 1217), new TOKENVALUE(10, 1215), + new TOKENVALUE(10, 1213), new TOKENVALUE(10, 1211), new TOKENVALUE(10, 1209), new TOKENVALUE(10, 1207), new TOKENVALUE(10, 1205), + new TOKENVALUE(10, 1203), new TOKENVALUE(10, 1201), new TOKENVALUE(10, 1199), new TOKENVALUE(10, 1197), new TOKENVALUE(10, 1195), + new TOKENVALUE(10, 1193), new TOKENVALUE(10, 1191), new TOKENVALUE(10, 1189), new TOKENVALUE(10, 1187), new TOKENVALUE(10, 1185), + new TOKENVALUE(10, 1183), new TOKENVALUE(10, 1181), new TOKENVALUE(10, 1179), new TOKENVALUE(10, 1177), new TOKENVALUE(10, 1175), + new TOKENVALUE(10, 1173), new TOKENVALUE(10, 1171), new TOKENVALUE(10, 1169), new TOKENVALUE(10, 1167), new TOKENVALUE(10, 1165), + new TOKENVALUE(10, 1163), new TOKENVALUE(10, 1161), new TOKENVALUE(10, 1159), new TOKENVALUE(10, 1157), new TOKENVALUE(10, 1155), + new TOKENVALUE(10, 1153), new TOKENVALUE(10, 1151), new TOKENVALUE(10, 1149), new TOKENVALUE(10, 1147), new TOKENVALUE(10, 1145), + new TOKENVALUE(10, 1143), new TOKENVALUE(10, 1141), new TOKENVALUE(10, 1139), new TOKENVALUE(10, 1137), new TOKENVALUE(10, 1135), + new TOKENVALUE(10, 1133), new TOKENVALUE(10, 1131), new TOKENVALUE(10, 1129), new TOKENVALUE(10, 1127), new TOKENVALUE(10, 1125), + new TOKENVALUE(10, 1123), new TOKENVALUE(10, 1121), new TOKENVALUE(10, 1119), new TOKENVALUE(10, 1117), new TOKENVALUE(10, 1115), + new TOKENVALUE(10, 1113), new TOKENVALUE(10, 1111), new TOKENVALUE(10, 1109), new TOKENVALUE(10, 1107), new TOKENVALUE(10, 1105), + new TOKENVALUE(10, 1103), new TOKENVALUE(10, 1101), new TOKENVALUE(10, 1099), new TOKENVALUE(10, 1097), new TOKENVALUE(10, 1095), + new TOKENVALUE(10, 1093), new TOKENVALUE(10, 1091), new TOKENVALUE(10, 1089), new TOKENVALUE(10, 1087), new TOKENVALUE(10, 1085), + new TOKENVALUE(10, 1083), new TOKENVALUE(10, 1081), new TOKENVALUE(10, 1079), new TOKENVALUE(10, 1077), new TOKENVALUE(10, 1075), + new TOKENVALUE(10, 1073), new TOKENVALUE(10, 1071), new TOKENVALUE(10, 1069), new TOKENVALUE(10, 1067), new TOKENVALUE(10, 1065), + new TOKENVALUE(10, 1063), new TOKENVALUE(10, 1061), new TOKENVALUE(10, 1059), new TOKENVALUE(10, 1057), new TOKENVALUE(10, 1055), + new TOKENVALUE(10, 1053), new TOKENVALUE(10, 1051), new TOKENVALUE(10, 1049), new TOKENVALUE(10, 1047), new TOKENVALUE(10, 1045), + new TOKENVALUE(10, 1043), new TOKENVALUE(10, 1041), new TOKENVALUE(10, 1039), new TOKENVALUE(10, 1037), new TOKENVALUE(10, 1035), + new TOKENVALUE(10, 1033), new TOKENVALUE(10, 1031), new TOKENVALUE(10, 1029), new TOKENVALUE(10, 1027), new TOKENVALUE(10, 1025), + new TOKENVALUE(10, 1023), new TOKENVALUE(10, 1021), new TOKENVALUE(10, 1019), new TOKENVALUE(10, 1017), new TOKENVALUE(10, 1015), + new TOKENVALUE(10, 1013), new TOKENVALUE(10, 1011), new TOKENVALUE(10, 1009), new TOKENVALUE(10, 1007), new TOKENVALUE(10, 1005), + new TOKENVALUE(10, 1003), new TOKENVALUE(10, 1001), new TOKENVALUE(10, 999), new TOKENVALUE(10, 997), new TOKENVALUE(10, 995), + new TOKENVALUE(10, 993), new TOKENVALUE(10, 991), new TOKENVALUE(10, 989), new TOKENVALUE(10, 987), new TOKENVALUE(10, 985), + new TOKENVALUE(10, 983), new TOKENVALUE(10, 981), new TOKENVALUE(10, 979), new TOKENVALUE(10, 977), new TOKENVALUE(10, 975), + new TOKENVALUE(10, 973), new TOKENVALUE(10, 971), new TOKENVALUE(10, 969), new TOKENVALUE(10, 967), new TOKENVALUE(10, 965), + new TOKENVALUE(10, 963), new TOKENVALUE(10, 961), new TOKENVALUE(10, 959), new TOKENVALUE(10, 957), new TOKENVALUE(10, 955), + new TOKENVALUE(10, 953), new TOKENVALUE(10, 951), new TOKENVALUE(10, 949), new TOKENVALUE(10, 947), new TOKENVALUE(10, 945), + new TOKENVALUE(10, 943), new TOKENVALUE(10, 941), new TOKENVALUE(10, 939), new TOKENVALUE(10, 937), new TOKENVALUE(10, 935), + new TOKENVALUE(10, 933), new TOKENVALUE(10, 931), new TOKENVALUE(10, 929), new TOKENVALUE(10, 927), new TOKENVALUE(10, 925), + new TOKENVALUE(10, 923), new TOKENVALUE(10, 921), new TOKENVALUE(10, 919), new TOKENVALUE(10, 917), new TOKENVALUE(10, 915), + new TOKENVALUE(10, 913), new TOKENVALUE(10, 911), new TOKENVALUE(10, 909), new TOKENVALUE(10, 907), new TOKENVALUE(10, 905), + new TOKENVALUE(10, 903), new TOKENVALUE(10, 901), new TOKENVALUE(10, 899), new TOKENVALUE(10, 897), new TOKENVALUE(10, 895), + new TOKENVALUE(10, 893), new TOKENVALUE(10, 891), new TOKENVALUE(10, 889), new TOKENVALUE(10, 887), new TOKENVALUE(10, 885), + new TOKENVALUE(10, 883), new TOKENVALUE(10, 881), new TOKENVALUE(10, 879), new TOKENVALUE(10, 877), new TOKENVALUE(10, 875), + new TOKENVALUE(10, 873), new TOKENVALUE(10, 871), new TOKENVALUE(10, 869), new TOKENVALUE(10, 867), new TOKENVALUE(10, 865), + new TOKENVALUE(10, 863), new TOKENVALUE(10, 861), new TOKENVALUE(10, 859), new TOKENVALUE(10, 857), new TOKENVALUE(10, 855), + new TOKENVALUE(10, 853), new TOKENVALUE(10, 851), new TOKENVALUE(10, 849), new TOKENVALUE(10, 847), new TOKENVALUE(10, 845), + new TOKENVALUE(10, 843), new TOKENVALUE(10, 841), new TOKENVALUE(10, 839), new TOKENVALUE(10, 837), new TOKENVALUE(10, 835), + new TOKENVALUE(10, 833), new TOKENVALUE(10, 831), new TOKENVALUE(10, 829), new TOKENVALUE(10, 827), new TOKENVALUE(10, 825), + new TOKENVALUE(10, 823), new TOKENVALUE(10, 821), new TOKENVALUE(10, 819), new TOKENVALUE(10, 817), new TOKENVALUE(10, 815), + new TOKENVALUE(10, 813), new TOKENVALUE(10, 811), new TOKENVALUE(10, 809), new TOKENVALUE(10, 807), new TOKENVALUE(10, 805), + new TOKENVALUE(10, 803), new TOKENVALUE(10, 801), new TOKENVALUE(10, 799), new TOKENVALUE(10, 797), new TOKENVALUE(10, 795), + new TOKENVALUE(10, 793), new TOKENVALUE(10, 791), new TOKENVALUE(10, 789), new TOKENVALUE(10, 787), new TOKENVALUE(10, 785), + new TOKENVALUE(10, 783), new TOKENVALUE(10, 781), new TOKENVALUE(10, 779), new TOKENVALUE(10, 777), new TOKENVALUE(10, 775), + new TOKENVALUE(10, 773), new TOKENVALUE(10, 771), new TOKENVALUE(10, 769), new TOKENVALUE(10, 767), new TOKENVALUE(10, 765), + new TOKENVALUE(10, 763), new TOKENVALUE(10, 761), new TOKENVALUE(10, 759), new TOKENVALUE(10, 757), new TOKENVALUE(10, 755), + new TOKENVALUE(10, 753), new TOKENVALUE(10, 751), new TOKENVALUE(10, 749), new TOKENVALUE(10, 747), new TOKENVALUE(10, 745), + new TOKENVALUE(10, 743), new TOKENVALUE(10, 741), new TOKENVALUE(10, 739), new TOKENVALUE(10, 737), new TOKENVALUE(10, 735), + new TOKENVALUE(10, 733), new TOKENVALUE(10, 731), new TOKENVALUE(10, 729), new TOKENVALUE(10, 727), new TOKENVALUE(10, 725), + new TOKENVALUE(10, 723), new TOKENVALUE(10, 721), new TOKENVALUE(10, 719), new TOKENVALUE(10, 717), new TOKENVALUE(10, 715), + new TOKENVALUE(10, 713), new TOKENVALUE(10, 711), new TOKENVALUE(10, 709), new TOKENVALUE(10, 707), new TOKENVALUE(10, 705), + new TOKENVALUE(10, 703), new TOKENVALUE(10, 701), new TOKENVALUE(10, 699), new TOKENVALUE(10, 697), new TOKENVALUE(10, 695), + new TOKENVALUE(10, 693), new TOKENVALUE(10, 691), new TOKENVALUE(10, 689), new TOKENVALUE(10, 687), new TOKENVALUE(10, 685), + new TOKENVALUE(10, 683), new TOKENVALUE(10, 681), new TOKENVALUE(10, 679), new TOKENVALUE(10, 677), new TOKENVALUE(10, 675), + new TOKENVALUE(10, 673), new TOKENVALUE(10, 671), new TOKENVALUE(10, 669), new TOKENVALUE(10, 667), new TOKENVALUE(10, 665), + new TOKENVALUE(10, 663), new TOKENVALUE(10, 661), new TOKENVALUE(10, 659), new TOKENVALUE(10, 657), new TOKENVALUE(10, 655), + new TOKENVALUE(10, 653), new TOKENVALUE(10, 651), new TOKENVALUE(10, 649), new TOKENVALUE(10, 647), new TOKENVALUE(10, 645), + new TOKENVALUE(10, 643), new TOKENVALUE(10, 641), new TOKENVALUE(10, 639), new TOKENVALUE(10, 637), new TOKENVALUE(10, 635), + new TOKENVALUE(10, 633), new TOKENVALUE(10, 631), new TOKENVALUE(10, 629), new TOKENVALUE(10, 627), new TOKENVALUE(10, 625), + new TOKENVALUE(10, 623), new TOKENVALUE(10, 621), new TOKENVALUE(10, 619), new TOKENVALUE(10, 617), new TOKENVALUE(10, 615), + new TOKENVALUE(10, 613), new TOKENVALUE(10, 611), new TOKENVALUE(10, 609), new TOKENVALUE(10, 607), new TOKENVALUE(10, 605), + new TOKENVALUE(10, 603), new TOKENVALUE(10, 601), new TOKENVALUE(10, 599), new TOKENVALUE(10, 597), new TOKENVALUE(10, 595), + new TOKENVALUE(10, 593), new TOKENVALUE(10, 591), new TOKENVALUE(10, 589), new TOKENVALUE(10, 587), new TOKENVALUE(10, 585), + new TOKENVALUE(10, 583), new TOKENVALUE(10, 581), new TOKENVALUE(10, 579), new TOKENVALUE(10, 577), new TOKENVALUE(10, 575), + new TOKENVALUE(10, 573), new TOKENVALUE(10, 571), new TOKENVALUE(10, 569), new TOKENVALUE(10, 567), new TOKENVALUE(10, 565), + new TOKENVALUE(10, 563), new TOKENVALUE(10, 561), new TOKENVALUE(10, 559), new TOKENVALUE(10, 557), new TOKENVALUE(10, 555), + new TOKENVALUE(10, 553), new TOKENVALUE(10, 551), new TOKENVALUE(10, 549), new TOKENVALUE(10, 547), new TOKENVALUE(10, 545), + new TOKENVALUE(10, 543), new TOKENVALUE(10, 541), new TOKENVALUE(10, 539), new TOKENVALUE(10, 537), new TOKENVALUE(10, 535), + new TOKENVALUE(10, 533), new TOKENVALUE(10, 531), new TOKENVALUE(10, 529), new TOKENVALUE(10, 527), new TOKENVALUE(10, 525), + new TOKENVALUE(10, 523), new TOKENVALUE(10, 521), new TOKENVALUE(10, 519), new TOKENVALUE(10, 517), new TOKENVALUE(10, 515), + new TOKENVALUE(10, 513), new TOKENVALUE(10, 511), new TOKENVALUE(10, 509), new TOKENVALUE(10, 507), new TOKENVALUE(10, 505), + new TOKENVALUE(10, 503), new TOKENVALUE(10, 501), new TOKENVALUE(10, 499), new TOKENVALUE(10, 497), new TOKENVALUE(10, 495), + new TOKENVALUE(10, 493), new TOKENVALUE(10, 491), new TOKENVALUE(10, 489), new TOKENVALUE(10, 487), new TOKENVALUE(10, 485), + new TOKENVALUE(10, 483), new TOKENVALUE(10, 481), new TOKENVALUE(10, 479), new TOKENVALUE(10, 477), new TOKENVALUE(10, 475), + new TOKENVALUE(10, 473), new TOKENVALUE(10, 471), new TOKENVALUE(10, 469), new TOKENVALUE(10, 467), new TOKENVALUE(10, 465), + new TOKENVALUE(10, 463), new TOKENVALUE(10, 461), new TOKENVALUE(10, 459), new TOKENVALUE(10, 457), new TOKENVALUE(10, 455), + new TOKENVALUE(10, 453), new TOKENVALUE(10, 451), new TOKENVALUE(10, 449), new TOKENVALUE(10, 447), new TOKENVALUE(10, 445), + new TOKENVALUE(10, 443), new TOKENVALUE(10, 441), new TOKENVALUE(10, 439), new TOKENVALUE(10, 437), new TOKENVALUE(10, 435), + new TOKENVALUE(10, 433), new TOKENVALUE(10, 431), new TOKENVALUE(10, 429), new TOKENVALUE(10, 427), new TOKENVALUE(10, 425), + new TOKENVALUE(10, 423), new TOKENVALUE(10, 421), new TOKENVALUE(10, 419), new TOKENVALUE(10, 417), new TOKENVALUE(10, 415), + new TOKENVALUE(10, 413), new TOKENVALUE(10, 411), new TOKENVALUE(10, 409), new TOKENVALUE(10, 407), new TOKENVALUE(10, 405), + new TOKENVALUE(10, 403), new TOKENVALUE(10, 401), new TOKENVALUE(10, 399), new TOKENVALUE(10, 397), new TOKENVALUE(10, 395), + new TOKENVALUE(10, 393), new TOKENVALUE(10, 391), new TOKENVALUE(10, 389), new TOKENVALUE(10, 387), new TOKENVALUE(10, 385), + new TOKENVALUE(10, 383), new TOKENVALUE(10, 381), new TOKENVALUE(10, 379), new TOKENVALUE(10, 377), new TOKENVALUE(10, 375), + new TOKENVALUE(10, 373), new TOKENVALUE(10, 371), new TOKENVALUE(10, 369), new TOKENVALUE(10, 367), new TOKENVALUE(10, 365), + new TOKENVALUE(10, 363), new TOKENVALUE(10, 361), new TOKENVALUE(10, 359), new TOKENVALUE(10, 357), new TOKENVALUE(10, 355), + new TOKENVALUE(10, 353), new TOKENVALUE(10, 351), new TOKENVALUE(10, 349), new TOKENVALUE(10, 347), new TOKENVALUE(10, 345), + new TOKENVALUE(10, 343), new TOKENVALUE(10, 341), new TOKENVALUE(10, 339), new TOKENVALUE(10, 337), new TOKENVALUE(10, 335), + new TOKENVALUE(10, 333), new TOKENVALUE(10, 331), new TOKENVALUE(10, 329), new TOKENVALUE(10, 327), new TOKENVALUE(10, 325), + new TOKENVALUE(10, 323), new TOKENVALUE(10, 321), new TOKENVALUE(10, 319), new TOKENVALUE(10, 317), new TOKENVALUE(10, 315), + new TOKENVALUE(10, 313), new TOKENVALUE(10, 311), new TOKENVALUE(10, 309), new TOKENVALUE(10, 307), new TOKENVALUE(10, 305), + new TOKENVALUE(10, 303), new TOKENVALUE(10, 301), new TOKENVALUE(10, 299), new TOKENVALUE(10, 297), new TOKENVALUE(10, 295), + new TOKENVALUE(10, 293), new TOKENVALUE(10, 291), new TOKENVALUE(10, 289), new TOKENVALUE(10, 287), new TOKENVALUE(10, 285), + new TOKENVALUE(10, 283), new TOKENVALUE(10, 281), new TOKENVALUE(10, 279), new TOKENVALUE(10, 277), new TOKENVALUE(10, 275), + new TOKENVALUE(10, 273), new TOKENVALUE(10, 271), new TOKENVALUE(10, 269), new TOKENVALUE(10, 267), new TOKENVALUE(10, 265), + new TOKENVALUE(10, 263), new TOKENVALUE(10, 261), new TOKENVALUE(10, 259), new TOKENVALUE(10, 257), new TOKENVALUE(10, 255), + new TOKENVALUE(10, 253), new TOKENVALUE(10, 251), new TOKENVALUE(10, 249), new TOKENVALUE(10, 247), new TOKENVALUE(10, 245), + new TOKENVALUE(10, 243), new TOKENVALUE(10, 241), new TOKENVALUE(10, 239), new TOKENVALUE(10, 237), new TOKENVALUE(10, 235), + new TOKENVALUE(10, 233), new TOKENVALUE(10, 231), new TOKENVALUE(10, 229), new TOKENVALUE(10, 227), new TOKENVALUE(10, 225), + new TOKENVALUE(10, 223), new TOKENVALUE(10, 221), new TOKENVALUE(10, 219), new TOKENVALUE(10, 217), new TOKENVALUE(10, 215), + new TOKENVALUE(10, 213), new TOKENVALUE(10, 211), new TOKENVALUE(10, 209), new TOKENVALUE(10, 207), new TOKENVALUE(10, 205), + new TOKENVALUE(10, 203), new TOKENVALUE(10, 201), new TOKENVALUE(10, 199), new TOKENVALUE(10, 197), new TOKENVALUE(10, 195), + new TOKENVALUE(10, 193), new TOKENVALUE(10, 191), new TOKENVALUE(10, 189), new TOKENVALUE(10, 187), new TOKENVALUE(10, 185), + new TOKENVALUE(10, 183), new TOKENVALUE(10, 181), new TOKENVALUE(10, 179), new TOKENVALUE(10, 177), new TOKENVALUE(10, 175), + new TOKENVALUE(10, 173), new TOKENVALUE(10, 171), new TOKENVALUE(10, 169), new TOKENVALUE(10, 167), new TOKENVALUE(10, 165), + new TOKENVALUE(10, 163), new TOKENVALUE(10, 161), new TOKENVALUE(10, 159), new TOKENVALUE(10, 157), new TOKENVALUE(10, 155), + new TOKENVALUE(10, 153), new TOKENVALUE(10, 151), new TOKENVALUE(10, 149), new TOKENVALUE(10, 147), new TOKENVALUE(10, 145), + new TOKENVALUE(10, 143), new TOKENVALUE(10, 141), new TOKENVALUE(10, 139), new TOKENVALUE(10, 137), new TOKENVALUE(10, 135), + new TOKENVALUE(10, 133), new TOKENVALUE(10, 131), new TOKENVALUE(10, 129), new TOKENVALUE(10, 127), new TOKENVALUE(10, 125), + new TOKENVALUE(10, 123), new TOKENVALUE(10, 121), new TOKENVALUE(10, 119), new TOKENVALUE(10, 117), new TOKENVALUE(10, 115), + new TOKENVALUE(10, 113), new TOKENVALUE(10, 111), new TOKENVALUE(10, 109), new TOKENVALUE(10, 107), new TOKENVALUE(10, 105), + new TOKENVALUE(10, 103), new TOKENVALUE(10, 101), new TOKENVALUE(10, 99), new TOKENVALUE(10, 97), new TOKENVALUE(10, 95), + new TOKENVALUE(10, 93), new TOKENVALUE(10, 91), new TOKENVALUE(10, 89), new TOKENVALUE(10, 87), new TOKENVALUE(10, 85), + new TOKENVALUE(10, 83), new TOKENVALUE(10, 81), new TOKENVALUE(10, 79), new TOKENVALUE(10, 77), new TOKENVALUE(10, 75), + new TOKENVALUE(10, 73), new TOKENVALUE(10, 71), new TOKENVALUE(10, 69), new TOKENVALUE(10, 67), new TOKENVALUE(10, 65), + new TOKENVALUE(10, 63), new TOKENVALUE(10, 61), new TOKENVALUE(10, 59), new TOKENVALUE(10, 57), new TOKENVALUE(10, 55), + new TOKENVALUE(10, 53), new TOKENVALUE(10, 51), new TOKENVALUE(10, 49), new TOKENVALUE(10, 47), new TOKENVALUE(10, 45), + new TOKENVALUE(10, 43), new TOKENVALUE(10, 41), new TOKENVALUE(10, 39), new TOKENVALUE(10, 37), new TOKENVALUE(10, 35), + new TOKENVALUE(10, 33), new TOKENVALUE(10, 31), new TOKENVALUE(10, 29), new TOKENVALUE(10, 27), new TOKENVALUE(10, 25), + new TOKENVALUE(10, 23), new TOKENVALUE(10, 21), new TOKENVALUE(10, 19), new TOKENVALUE(10, 17), new TOKENVALUE(10, 15), + new TOKENVALUE(10, 13), new TOKENVALUE(10, 11), new TOKENVALUE(10, 9), new TOKENVALUE(10, 7), new TOKENVALUE(10, 5), + new TOKENVALUE(10, 3), new TOKENVALUE(10, 1), new TOKENVALUE(9, 63), new TOKENVALUE(9, 61), new TOKENVALUE(9, 59), + new TOKENVALUE(9, 57), new TOKENVALUE(9, 55), new TOKENVALUE(9, 53), new TOKENVALUE(9, 51), new TOKENVALUE(9, 49), + new TOKENVALUE(9, 47), new TOKENVALUE(9, 45), new TOKENVALUE(9, 43), new TOKENVALUE(9, 41), new TOKENVALUE(9, 39), + new TOKENVALUE(9, 37), new TOKENVALUE(9, 35), new TOKENVALUE(9, 33), new TOKENVALUE(9, 31), new TOKENVALUE(9, 29), + new TOKENVALUE(9, 27), new TOKENVALUE(9, 25), new TOKENVALUE(9, 23), new TOKENVALUE(9, 21), new TOKENVALUE(9, 19), + new TOKENVALUE(9, 17), new TOKENVALUE(9, 15), new TOKENVALUE(9, 13), new TOKENVALUE(9, 11), new TOKENVALUE(9, 9), + new TOKENVALUE(9, 7), new TOKENVALUE(9, 5), new TOKENVALUE(9, 3), new TOKENVALUE(9, 1), new TOKENVALUE(8, 31), + new TOKENVALUE(8, 29), new TOKENVALUE(8, 27), new TOKENVALUE(8, 25), new TOKENVALUE(8, 23), new TOKENVALUE(8, 21), + new TOKENVALUE(8, 19), new TOKENVALUE(8, 17), new TOKENVALUE(8, 15), new TOKENVALUE(8, 13), new TOKENVALUE(8, 11), + new TOKENVALUE(8, 9), new TOKENVALUE(8, 7), new TOKENVALUE(8, 5), new TOKENVALUE(8, 3), new TOKENVALUE(8, 1), + new TOKENVALUE(7, 15), new TOKENVALUE(7, 13), new TOKENVALUE(7, 11), new TOKENVALUE(7, 9), new TOKENVALUE(7, 7), + new TOKENVALUE(7, 5), new TOKENVALUE(7, 3), new TOKENVALUE(7, 1), new TOKENVALUE(6, 7), new TOKENVALUE(6, 5), + new TOKENVALUE(6, 3), new TOKENVALUE(6, 1), new TOKENVALUE(5, 3), new TOKENVALUE(5, 1), new TOKENVALUE(4, 1), + new TOKENVALUE(3, 1), new TOKENVALUE(2, 1), new TOKENVALUE(1, 1), new TOKENVALUE(0, 0), new TOKENVALUE(1, 0), + new TOKENVALUE(2, 0), new TOKENVALUE(3, 0), new TOKENVALUE(4, 0), new TOKENVALUE(5, 0), new TOKENVALUE(5, 2), + new TOKENVALUE(6, 0), new TOKENVALUE(6, 2), new TOKENVALUE(6, 4), new TOKENVALUE(6, 6), new TOKENVALUE(7, 0), + new TOKENVALUE(7, 2), new TOKENVALUE(7, 4), new TOKENVALUE(7, 6), new TOKENVALUE(7, 8), new TOKENVALUE(7, 10), + new TOKENVALUE(7, 12), new TOKENVALUE(7, 14), new TOKENVALUE(8, 0), new TOKENVALUE(8, 2), new TOKENVALUE(8, 4), + new TOKENVALUE(8, 6), new TOKENVALUE(8, 8), new TOKENVALUE(8, 10), new TOKENVALUE(8, 12), new TOKENVALUE(8, 14), + new TOKENVALUE(8, 16), new TOKENVALUE(8, 18), new TOKENVALUE(8, 20), new TOKENVALUE(8, 22), new TOKENVALUE(8, 24), + new TOKENVALUE(8, 26), new TOKENVALUE(8, 28), new TOKENVALUE(8, 30), new TOKENVALUE(9, 0), new TOKENVALUE(9, 2), + new TOKENVALUE(9, 4), new TOKENVALUE(9, 6), new TOKENVALUE(9, 8), new TOKENVALUE(9, 10), new TOKENVALUE(9, 12), + new TOKENVALUE(9, 14), new TOKENVALUE(9, 16), new TOKENVALUE(9, 18), new TOKENVALUE(9, 20), new TOKENVALUE(9, 22), + new TOKENVALUE(9, 24), new TOKENVALUE(9, 26), new TOKENVALUE(9, 28), new TOKENVALUE(9, 30), new TOKENVALUE(9, 32), + new TOKENVALUE(9, 34), new TOKENVALUE(9, 36), new TOKENVALUE(9, 38), new TOKENVALUE(9, 40), new TOKENVALUE(9, 42), + new TOKENVALUE(9, 44), new TOKENVALUE(9, 46), new TOKENVALUE(9, 48), new TOKENVALUE(9, 50), new TOKENVALUE(9, 52), + new TOKENVALUE(9, 54), new TOKENVALUE(9, 56), new TOKENVALUE(9, 58), new TOKENVALUE(9, 60), new TOKENVALUE(9, 62), + new TOKENVALUE(10, 0), new TOKENVALUE(10, 2), new TOKENVALUE(10, 4), new TOKENVALUE(10, 6), new TOKENVALUE(10, 8), + new TOKENVALUE(10, 10), new TOKENVALUE(10, 12), new TOKENVALUE(10, 14), new TOKENVALUE(10, 16), new TOKENVALUE(10, 18), + new TOKENVALUE(10, 20), new TOKENVALUE(10, 22), new TOKENVALUE(10, 24), new TOKENVALUE(10, 26), new TOKENVALUE(10, 28), + new TOKENVALUE(10, 30), new TOKENVALUE(10, 32), new TOKENVALUE(10, 34), new TOKENVALUE(10, 36), new TOKENVALUE(10, 38), + new TOKENVALUE(10, 40), new TOKENVALUE(10, 42), new TOKENVALUE(10, 44), new TOKENVALUE(10, 46), new TOKENVALUE(10, 48), + new TOKENVALUE(10, 50), new TOKENVALUE(10, 52), new TOKENVALUE(10, 54), new TOKENVALUE(10, 56), new TOKENVALUE(10, 58), + new TOKENVALUE(10, 60), new TOKENVALUE(10, 62), new TOKENVALUE(10, 64), new TOKENVALUE(10, 66), new TOKENVALUE(10, 68), + new TOKENVALUE(10, 70), new TOKENVALUE(10, 72), new TOKENVALUE(10, 74), new TOKENVALUE(10, 76), new TOKENVALUE(10, 78), + new TOKENVALUE(10, 80), new TOKENVALUE(10, 82), new TOKENVALUE(10, 84), new TOKENVALUE(10, 86), new TOKENVALUE(10, 88), + new TOKENVALUE(10, 90), new TOKENVALUE(10, 92), new TOKENVALUE(10, 94), new TOKENVALUE(10, 96), new TOKENVALUE(10, 98), + new TOKENVALUE(10, 100), new TOKENVALUE(10, 102), new TOKENVALUE(10, 104), new TOKENVALUE(10, 106), new TOKENVALUE(10, 108), + new TOKENVALUE(10, 110), new TOKENVALUE(10, 112), new TOKENVALUE(10, 114), new TOKENVALUE(10, 116), new TOKENVALUE(10, 118), + new TOKENVALUE(10, 120), new TOKENVALUE(10, 122), new TOKENVALUE(10, 124), new TOKENVALUE(10, 126), new TOKENVALUE(10, 128), + new TOKENVALUE(10, 130), new TOKENVALUE(10, 132), new TOKENVALUE(10, 134), new TOKENVALUE(10, 136), new TOKENVALUE(10, 138), + new TOKENVALUE(10, 140), new TOKENVALUE(10, 142), new TOKENVALUE(10, 144), new TOKENVALUE(10, 146), new TOKENVALUE(10, 148), + new TOKENVALUE(10, 150), new TOKENVALUE(10, 152), new TOKENVALUE(10, 154), new TOKENVALUE(10, 156), new TOKENVALUE(10, 158), + new TOKENVALUE(10, 160), new TOKENVALUE(10, 162), new TOKENVALUE(10, 164), new TOKENVALUE(10, 166), new TOKENVALUE(10, 168), + new TOKENVALUE(10, 170), new TOKENVALUE(10, 172), new TOKENVALUE(10, 174), new TOKENVALUE(10, 176), new TOKENVALUE(10, 178), + new TOKENVALUE(10, 180), new TOKENVALUE(10, 182), new TOKENVALUE(10, 184), new TOKENVALUE(10, 186), new TOKENVALUE(10, 188), + new TOKENVALUE(10, 190), new TOKENVALUE(10, 192), new TOKENVALUE(10, 194), new TOKENVALUE(10, 196), new TOKENVALUE(10, 198), + new TOKENVALUE(10, 200), new TOKENVALUE(10, 202), new TOKENVALUE(10, 204), new TOKENVALUE(10, 206), new TOKENVALUE(10, 208), + new TOKENVALUE(10, 210), new TOKENVALUE(10, 212), new TOKENVALUE(10, 214), new TOKENVALUE(10, 216), new TOKENVALUE(10, 218), + new TOKENVALUE(10, 220), new TOKENVALUE(10, 222), new TOKENVALUE(10, 224), new TOKENVALUE(10, 226), new TOKENVALUE(10, 228), + new TOKENVALUE(10, 230), new TOKENVALUE(10, 232), new TOKENVALUE(10, 234), new TOKENVALUE(10, 236), new TOKENVALUE(10, 238), + new TOKENVALUE(10, 240), new TOKENVALUE(10, 242), new TOKENVALUE(10, 244), new TOKENVALUE(10, 246), new TOKENVALUE(10, 248), + new TOKENVALUE(10, 250), new TOKENVALUE(10, 252), new TOKENVALUE(10, 254), new TOKENVALUE(10, 256), new TOKENVALUE(10, 258), + new TOKENVALUE(10, 260), new TOKENVALUE(10, 262), new TOKENVALUE(10, 264), new TOKENVALUE(10, 266), new TOKENVALUE(10, 268), + new TOKENVALUE(10, 270), new TOKENVALUE(10, 272), new TOKENVALUE(10, 274), new TOKENVALUE(10, 276), new TOKENVALUE(10, 278), + new TOKENVALUE(10, 280), new TOKENVALUE(10, 282), new TOKENVALUE(10, 284), new TOKENVALUE(10, 286), new TOKENVALUE(10, 288), + new TOKENVALUE(10, 290), new TOKENVALUE(10, 292), new TOKENVALUE(10, 294), new TOKENVALUE(10, 296), new TOKENVALUE(10, 298), + new TOKENVALUE(10, 300), new TOKENVALUE(10, 302), new TOKENVALUE(10, 304), new TOKENVALUE(10, 306), new TOKENVALUE(10, 308), + new TOKENVALUE(10, 310), new TOKENVALUE(10, 312), new TOKENVALUE(10, 314), new TOKENVALUE(10, 316), new TOKENVALUE(10, 318), + new TOKENVALUE(10, 320), new TOKENVALUE(10, 322), new TOKENVALUE(10, 324), new TOKENVALUE(10, 326), new TOKENVALUE(10, 328), + new TOKENVALUE(10, 330), new TOKENVALUE(10, 332), new TOKENVALUE(10, 334), new TOKENVALUE(10, 336), new TOKENVALUE(10, 338), + new TOKENVALUE(10, 340), new TOKENVALUE(10, 342), new TOKENVALUE(10, 344), new TOKENVALUE(10, 346), new TOKENVALUE(10, 348), + new TOKENVALUE(10, 350), new TOKENVALUE(10, 352), new TOKENVALUE(10, 354), new TOKENVALUE(10, 356), new TOKENVALUE(10, 358), + new TOKENVALUE(10, 360), new TOKENVALUE(10, 362), new TOKENVALUE(10, 364), new TOKENVALUE(10, 366), new TOKENVALUE(10, 368), + new TOKENVALUE(10, 370), new TOKENVALUE(10, 372), new TOKENVALUE(10, 374), new TOKENVALUE(10, 376), new TOKENVALUE(10, 378), + new TOKENVALUE(10, 380), new TOKENVALUE(10, 382), new TOKENVALUE(10, 384), new TOKENVALUE(10, 386), new TOKENVALUE(10, 388), + new TOKENVALUE(10, 390), new TOKENVALUE(10, 392), new TOKENVALUE(10, 394), new TOKENVALUE(10, 396), new TOKENVALUE(10, 398), + new TOKENVALUE(10, 400), new TOKENVALUE(10, 402), new TOKENVALUE(10, 404), new TOKENVALUE(10, 406), new TOKENVALUE(10, 408), + new TOKENVALUE(10, 410), new TOKENVALUE(10, 412), new TOKENVALUE(10, 414), new TOKENVALUE(10, 416), new TOKENVALUE(10, 418), + new TOKENVALUE(10, 420), new TOKENVALUE(10, 422), new TOKENVALUE(10, 424), new TOKENVALUE(10, 426), new TOKENVALUE(10, 428), + new TOKENVALUE(10, 430), new TOKENVALUE(10, 432), new TOKENVALUE(10, 434), new TOKENVALUE(10, 436), new TOKENVALUE(10, 438), + new TOKENVALUE(10, 440), new TOKENVALUE(10, 442), new TOKENVALUE(10, 444), new TOKENVALUE(10, 446), new TOKENVALUE(10, 448), + new TOKENVALUE(10, 450), new TOKENVALUE(10, 452), new TOKENVALUE(10, 454), new TOKENVALUE(10, 456), new TOKENVALUE(10, 458), + new TOKENVALUE(10, 460), new TOKENVALUE(10, 462), new TOKENVALUE(10, 464), new TOKENVALUE(10, 466), new TOKENVALUE(10, 468), + new TOKENVALUE(10, 470), new TOKENVALUE(10, 472), new TOKENVALUE(10, 474), new TOKENVALUE(10, 476), new TOKENVALUE(10, 478), + new TOKENVALUE(10, 480), new TOKENVALUE(10, 482), new TOKENVALUE(10, 484), new TOKENVALUE(10, 486), new TOKENVALUE(10, 488), + new TOKENVALUE(10, 490), new TOKENVALUE(10, 492), new TOKENVALUE(10, 494), new TOKENVALUE(10, 496), new TOKENVALUE(10, 498), + new TOKENVALUE(10, 500), new TOKENVALUE(10, 502), new TOKENVALUE(10, 504), new TOKENVALUE(10, 506), new TOKENVALUE(10, 508), + new TOKENVALUE(10, 510), new TOKENVALUE(10, 512), new TOKENVALUE(10, 514), new TOKENVALUE(10, 516), new TOKENVALUE(10, 518), + new TOKENVALUE(10, 520), new TOKENVALUE(10, 522), new TOKENVALUE(10, 524), new TOKENVALUE(10, 526), new TOKENVALUE(10, 528), + new TOKENVALUE(10, 530), new TOKENVALUE(10, 532), new TOKENVALUE(10, 534), new TOKENVALUE(10, 536), new TOKENVALUE(10, 538), + new TOKENVALUE(10, 540), new TOKENVALUE(10, 542), new TOKENVALUE(10, 544), new TOKENVALUE(10, 546), new TOKENVALUE(10, 548), + new TOKENVALUE(10, 550), new TOKENVALUE(10, 552), new TOKENVALUE(10, 554), new TOKENVALUE(10, 556), new TOKENVALUE(10, 558), + new TOKENVALUE(10, 560), new TOKENVALUE(10, 562), new TOKENVALUE(10, 564), new TOKENVALUE(10, 566), new TOKENVALUE(10, 568), + new TOKENVALUE(10, 570), new TOKENVALUE(10, 572), new TOKENVALUE(10, 574), new TOKENVALUE(10, 576), new TOKENVALUE(10, 578), + new TOKENVALUE(10, 580), new TOKENVALUE(10, 582), new TOKENVALUE(10, 584), new TOKENVALUE(10, 586), new TOKENVALUE(10, 588), + new TOKENVALUE(10, 590), new TOKENVALUE(10, 592), new TOKENVALUE(10, 594), new TOKENVALUE(10, 596), new TOKENVALUE(10, 598), + new TOKENVALUE(10, 600), new TOKENVALUE(10, 602), new TOKENVALUE(10, 604), new TOKENVALUE(10, 606), new TOKENVALUE(10, 608), + new TOKENVALUE(10, 610), new TOKENVALUE(10, 612), new TOKENVALUE(10, 614), new TOKENVALUE(10, 616), new TOKENVALUE(10, 618), + new TOKENVALUE(10, 620), new TOKENVALUE(10, 622), new TOKENVALUE(10, 624), new TOKENVALUE(10, 626), new TOKENVALUE(10, 628), + new TOKENVALUE(10, 630), new TOKENVALUE(10, 632), new TOKENVALUE(10, 634), new TOKENVALUE(10, 636), new TOKENVALUE(10, 638), + new TOKENVALUE(10, 640), new TOKENVALUE(10, 642), new TOKENVALUE(10, 644), new TOKENVALUE(10, 646), new TOKENVALUE(10, 648), + new TOKENVALUE(10, 650), new TOKENVALUE(10, 652), new TOKENVALUE(10, 654), new TOKENVALUE(10, 656), new TOKENVALUE(10, 658), + new TOKENVALUE(10, 660), new TOKENVALUE(10, 662), new TOKENVALUE(10, 664), new TOKENVALUE(10, 666), new TOKENVALUE(10, 668), + new TOKENVALUE(10, 670), new TOKENVALUE(10, 672), new TOKENVALUE(10, 674), new TOKENVALUE(10, 676), new TOKENVALUE(10, 678), + new TOKENVALUE(10, 680), new TOKENVALUE(10, 682), new TOKENVALUE(10, 684), new TOKENVALUE(10, 686), new TOKENVALUE(10, 688), + new TOKENVALUE(10, 690), new TOKENVALUE(10, 692), new TOKENVALUE(10, 694), new TOKENVALUE(10, 696), new TOKENVALUE(10, 698), + new TOKENVALUE(10, 700), new TOKENVALUE(10, 702), new TOKENVALUE(10, 704), new TOKENVALUE(10, 706), new TOKENVALUE(10, 708), + new TOKENVALUE(10, 710), new TOKENVALUE(10, 712), new TOKENVALUE(10, 714), new TOKENVALUE(10, 716), new TOKENVALUE(10, 718), + new TOKENVALUE(10, 720), new TOKENVALUE(10, 722), new TOKENVALUE(10, 724), new TOKENVALUE(10, 726), new TOKENVALUE(10, 728), + new TOKENVALUE(10, 730), new TOKENVALUE(10, 732), new TOKENVALUE(10, 734), new TOKENVALUE(10, 736), new TOKENVALUE(10, 738), + new TOKENVALUE(10, 740), new TOKENVALUE(10, 742), new TOKENVALUE(10, 744), new TOKENVALUE(10, 746), new TOKENVALUE(10, 748), + new TOKENVALUE(10, 750), new TOKENVALUE(10, 752), new TOKENVALUE(10, 754), new TOKENVALUE(10, 756), new TOKENVALUE(10, 758), + new TOKENVALUE(10, 760), new TOKENVALUE(10, 762), new TOKENVALUE(10, 764), new TOKENVALUE(10, 766), new TOKENVALUE(10, 768), + new TOKENVALUE(10, 770), new TOKENVALUE(10, 772), new TOKENVALUE(10, 774), new TOKENVALUE(10, 776), new TOKENVALUE(10, 778), + new TOKENVALUE(10, 780), new TOKENVALUE(10, 782), new TOKENVALUE(10, 784), new TOKENVALUE(10, 786), new TOKENVALUE(10, 788), + new TOKENVALUE(10, 790), new TOKENVALUE(10, 792), new TOKENVALUE(10, 794), new TOKENVALUE(10, 796), new TOKENVALUE(10, 798), + new TOKENVALUE(10, 800), new TOKENVALUE(10, 802), new TOKENVALUE(10, 804), new TOKENVALUE(10, 806), new TOKENVALUE(10, 808), + new TOKENVALUE(10, 810), new TOKENVALUE(10, 812), new TOKENVALUE(10, 814), new TOKENVALUE(10, 816), new TOKENVALUE(10, 818), + new TOKENVALUE(10, 820), new TOKENVALUE(10, 822), new TOKENVALUE(10, 824), new TOKENVALUE(10, 826), new TOKENVALUE(10, 828), + new TOKENVALUE(10, 830), new TOKENVALUE(10, 832), new TOKENVALUE(10, 834), new TOKENVALUE(10, 836), new TOKENVALUE(10, 838), + new TOKENVALUE(10, 840), new TOKENVALUE(10, 842), new TOKENVALUE(10, 844), new TOKENVALUE(10, 846), new TOKENVALUE(10, 848), + new TOKENVALUE(10, 850), new TOKENVALUE(10, 852), new TOKENVALUE(10, 854), new TOKENVALUE(10, 856), new TOKENVALUE(10, 858), + new TOKENVALUE(10, 860), new TOKENVALUE(10, 862), new TOKENVALUE(10, 864), new TOKENVALUE(10, 866), new TOKENVALUE(10, 868), + new TOKENVALUE(10, 870), new TOKENVALUE(10, 872), new TOKENVALUE(10, 874), new TOKENVALUE(10, 876), new TOKENVALUE(10, 878), + new TOKENVALUE(10, 880), new TOKENVALUE(10, 882), new TOKENVALUE(10, 884), new TOKENVALUE(10, 886), new TOKENVALUE(10, 888), + new TOKENVALUE(10, 890), new TOKENVALUE(10, 892), new TOKENVALUE(10, 894), new TOKENVALUE(10, 896), new TOKENVALUE(10, 898), + new TOKENVALUE(10, 900), new TOKENVALUE(10, 902), new TOKENVALUE(10, 904), new TOKENVALUE(10, 906), new TOKENVALUE(10, 908), + new TOKENVALUE(10, 910), new TOKENVALUE(10, 912), new TOKENVALUE(10, 914), new TOKENVALUE(10, 916), new TOKENVALUE(10, 918), + new TOKENVALUE(10, 920), new TOKENVALUE(10, 922), new TOKENVALUE(10, 924), new TOKENVALUE(10, 926), new TOKENVALUE(10, 928), + new TOKENVALUE(10, 930), new TOKENVALUE(10, 932), new TOKENVALUE(10, 934), new TOKENVALUE(10, 936), new TOKENVALUE(10, 938), + new TOKENVALUE(10, 940), new TOKENVALUE(10, 942), new TOKENVALUE(10, 944), new TOKENVALUE(10, 946), new TOKENVALUE(10, 948), + new TOKENVALUE(10, 950), new TOKENVALUE(10, 952), new TOKENVALUE(10, 954), new TOKENVALUE(10, 956), new TOKENVALUE(10, 958), + new TOKENVALUE(10, 960), new TOKENVALUE(10, 962), new TOKENVALUE(10, 964), new TOKENVALUE(10, 966), new TOKENVALUE(10, 968), + new TOKENVALUE(10, 970), new TOKENVALUE(10, 972), new TOKENVALUE(10, 974), new TOKENVALUE(10, 976), new TOKENVALUE(10, 978), + new TOKENVALUE(10, 980), new TOKENVALUE(10, 982), new TOKENVALUE(10, 984), new TOKENVALUE(10, 986), new TOKENVALUE(10, 988), + new TOKENVALUE(10, 990), new TOKENVALUE(10, 992), new TOKENVALUE(10, 994), new TOKENVALUE(10, 996), new TOKENVALUE(10, 998), + new TOKENVALUE(10, 1000), new TOKENVALUE(10, 1002), new TOKENVALUE(10, 1004), new TOKENVALUE(10, 1006), new TOKENVALUE(10, 1008), + new TOKENVALUE(10, 1010), new TOKENVALUE(10, 1012), new TOKENVALUE(10, 1014), new TOKENVALUE(10, 1016), new TOKENVALUE(10, 1018), + new TOKENVALUE(10, 1020), new TOKENVALUE(10, 1022), new TOKENVALUE(10, 1024), new TOKENVALUE(10, 1026), new TOKENVALUE(10, 1028), + new TOKENVALUE(10, 1030), new TOKENVALUE(10, 1032), new TOKENVALUE(10, 1034), new TOKENVALUE(10, 1036), new TOKENVALUE(10, 1038), + new TOKENVALUE(10, 1040), new TOKENVALUE(10, 1042), new TOKENVALUE(10, 1044), new TOKENVALUE(10, 1046), new TOKENVALUE(10, 1048), + new TOKENVALUE(10, 1050), new TOKENVALUE(10, 1052), new TOKENVALUE(10, 1054), new TOKENVALUE(10, 1056), new TOKENVALUE(10, 1058), + new TOKENVALUE(10, 1060), new TOKENVALUE(10, 1062), new TOKENVALUE(10, 1064), new TOKENVALUE(10, 1066), new TOKENVALUE(10, 1068), + new TOKENVALUE(10, 1070), new TOKENVALUE(10, 1072), new TOKENVALUE(10, 1074), new TOKENVALUE(10, 1076), new TOKENVALUE(10, 1078), + new TOKENVALUE(10, 1080), new TOKENVALUE(10, 1082), new TOKENVALUE(10, 1084), new TOKENVALUE(10, 1086), new TOKENVALUE(10, 1088), + new TOKENVALUE(10, 1090), new TOKENVALUE(10, 1092), new TOKENVALUE(10, 1094), new TOKENVALUE(10, 1096), new TOKENVALUE(10, 1098), + new TOKENVALUE(10, 1100), new TOKENVALUE(10, 1102), new TOKENVALUE(10, 1104), new TOKENVALUE(10, 1106), new TOKENVALUE(10, 1108), + new TOKENVALUE(10, 1110), new TOKENVALUE(10, 1112), new TOKENVALUE(10, 1114), new TOKENVALUE(10, 1116), new TOKENVALUE(10, 1118), + new TOKENVALUE(10, 1120), new TOKENVALUE(10, 1122), new TOKENVALUE(10, 1124), new TOKENVALUE(10, 1126), new TOKENVALUE(10, 1128), + new TOKENVALUE(10, 1130), new TOKENVALUE(10, 1132), new TOKENVALUE(10, 1134), new TOKENVALUE(10, 1136), new TOKENVALUE(10, 1138), + new TOKENVALUE(10, 1140), new TOKENVALUE(10, 1142), new TOKENVALUE(10, 1144), new TOKENVALUE(10, 1146), new TOKENVALUE(10, 1148), + new TOKENVALUE(10, 1150), new TOKENVALUE(10, 1152), new TOKENVALUE(10, 1154), new TOKENVALUE(10, 1156), new TOKENVALUE(10, 1158), + new TOKENVALUE(10, 1160), new TOKENVALUE(10, 1162), new TOKENVALUE(10, 1164), new TOKENVALUE(10, 1166), new TOKENVALUE(10, 1168), + new TOKENVALUE(10, 1170), new TOKENVALUE(10, 1172), new TOKENVALUE(10, 1174), new TOKENVALUE(10, 1176), new TOKENVALUE(10, 1178), + new TOKENVALUE(10, 1180), new TOKENVALUE(10, 1182), new TOKENVALUE(10, 1184), new TOKENVALUE(10, 1186), new TOKENVALUE(10, 1188), + new TOKENVALUE(10, 1190), new TOKENVALUE(10, 1192), new TOKENVALUE(10, 1194), new TOKENVALUE(10, 1196), new TOKENVALUE(10, 1198), + new TOKENVALUE(10, 1200), new TOKENVALUE(10, 1202), new TOKENVALUE(10, 1204), new TOKENVALUE(10, 1206), new TOKENVALUE(10, 1208), + new TOKENVALUE(10, 1210), new TOKENVALUE(10, 1212), new TOKENVALUE(10, 1214), new TOKENVALUE(10, 1216), new TOKENVALUE(10, 1218), + new TOKENVALUE(10, 1220), new TOKENVALUE(10, 1222), new TOKENVALUE(10, 1224), new TOKENVALUE(10, 1226), new TOKENVALUE(10, 1228), + new TOKENVALUE(10, 1230), new TOKENVALUE(10, 1232), new TOKENVALUE(10, 1234), new TOKENVALUE(10, 1236), new TOKENVALUE(10, 1238), + new TOKENVALUE(10, 1240), new TOKENVALUE(10, 1242), new TOKENVALUE(10, 1244), new TOKENVALUE(10, 1246), new TOKENVALUE(10, 1248), + new TOKENVALUE(10, 1250), new TOKENVALUE(10, 1252), new TOKENVALUE(10, 1254), new TOKENVALUE(10, 1256), new TOKENVALUE(10, 1258), + new TOKENVALUE(10, 1260), new TOKENVALUE(10, 1262), new TOKENVALUE(10, 1264), new TOKENVALUE(10, 1266), new TOKENVALUE(10, 1268), + new TOKENVALUE(10, 1270), new TOKENVALUE(10, 1272), new TOKENVALUE(10, 1274), new TOKENVALUE(10, 1276), new TOKENVALUE(10, 1278), + new TOKENVALUE(10, 1280), new TOKENVALUE(10, 1282), new TOKENVALUE(10, 1284), new TOKENVALUE(10, 1286), new TOKENVALUE(10, 1288), + new TOKENVALUE(10, 1290), new TOKENVALUE(10, 1292), new TOKENVALUE(10, 1294), new TOKENVALUE(10, 1296), new TOKENVALUE(10, 1298), + new TOKENVALUE(10, 1300), new TOKENVALUE(10, 1302), new TOKENVALUE(10, 1304), new TOKENVALUE(10, 1306), new TOKENVALUE(10, 1308), + new TOKENVALUE(10, 1310), new TOKENVALUE(10, 1312), new TOKENVALUE(10, 1314), new TOKENVALUE(10, 1316), new TOKENVALUE(10, 1318), + new TOKENVALUE(10, 1320), new TOKENVALUE(10, 1322), new TOKENVALUE(10, 1324), new TOKENVALUE(10, 1326), new TOKENVALUE(10, 1328), + new TOKENVALUE(10, 1330), new TOKENVALUE(10, 1332), new TOKENVALUE(10, 1334), new TOKENVALUE(10, 1336), new TOKENVALUE(10, 1338), + new TOKENVALUE(10, 1340), new TOKENVALUE(10, 1342), new TOKENVALUE(10, 1344), new TOKENVALUE(10, 1346), new TOKENVALUE(10, 1348), + new TOKENVALUE(10, 1350), new TOKENVALUE(10, 1352), new TOKENVALUE(10, 1354), new TOKENVALUE(10, 1356), new TOKENVALUE(10, 1358), + new TOKENVALUE(10, 1360), new TOKENVALUE(10, 1362), new TOKENVALUE(10, 1364), new TOKENVALUE(10, 1366), new TOKENVALUE(10, 1368), + new TOKENVALUE(10, 1370), new TOKENVALUE(10, 1372), new TOKENVALUE(10, 1374), new TOKENVALUE(10, 1376), new TOKENVALUE(10, 1378), + new TOKENVALUE(10, 1380), new TOKENVALUE(10, 1382), new TOKENVALUE(10, 1384), new TOKENVALUE(10, 1386), new TOKENVALUE(10, 1388), + new TOKENVALUE(10, 1390), new TOKENVALUE(10, 1392), new TOKENVALUE(10, 1394), new TOKENVALUE(10, 1396), new TOKENVALUE(10, 1398), + new TOKENVALUE(10, 1400), new TOKENVALUE(10, 1402), new TOKENVALUE(10, 1404), new TOKENVALUE(10, 1406), new TOKENVALUE(10, 1408), + new TOKENVALUE(10, 1410), new TOKENVALUE(10, 1412), new TOKENVALUE(10, 1414), new TOKENVALUE(10, 1416), new TOKENVALUE(10, 1418), + new TOKENVALUE(10, 1420), new TOKENVALUE(10, 1422), new TOKENVALUE(10, 1424), new TOKENVALUE(10, 1426), new TOKENVALUE(10, 1428), + new TOKENVALUE(10, 1430), new TOKENVALUE(10, 1432), new TOKENVALUE(10, 1434), new TOKENVALUE(10, 1436), new TOKENVALUE(10, 1438), + new TOKENVALUE(10, 1440), new TOKENVALUE(10, 1442), new TOKENVALUE(10, 1444), new TOKENVALUE(10, 1446), new TOKENVALUE(10, 1448), + new TOKENVALUE(10, 1450), new TOKENVALUE(10, 1452), new TOKENVALUE(10, 1454), new TOKENVALUE(10, 1456), new TOKENVALUE(10, 1458), + new TOKENVALUE(10, 1460), new TOKENVALUE(10, 1462), new TOKENVALUE(10, 1464), new TOKENVALUE(10, 1466), new TOKENVALUE(10, 1468), + new TOKENVALUE(10, 1470), new TOKENVALUE(10, 1472), new TOKENVALUE(10, 1474), new TOKENVALUE(10, 1476), new TOKENVALUE(10, 1478), + new TOKENVALUE(10, 1480), new TOKENVALUE(10, 1482), new TOKENVALUE(10, 1484), new TOKENVALUE(10, 1486), new TOKENVALUE(10, 1488), + new TOKENVALUE(10, 1490), new TOKENVALUE(10, 1492), new TOKENVALUE(10, 1494), new TOKENVALUE(10, 1496), new TOKENVALUE(10, 1498), + new TOKENVALUE(10, 1500), new TOKENVALUE(10, 1502), new TOKENVALUE(10, 1504), new TOKENVALUE(10, 1506), new TOKENVALUE(10, 1508), + new TOKENVALUE(10, 1510), new TOKENVALUE(10, 1512), new TOKENVALUE(10, 1514), new TOKENVALUE(10, 1516), new TOKENVALUE(10, 1518), + new TOKENVALUE(10, 1520), new TOKENVALUE(10, 1522), new TOKENVALUE(10, 1524), new TOKENVALUE(10, 1526), new TOKENVALUE(10, 1528), + new TOKENVALUE(10, 1530), new TOKENVALUE(10, 1532), new TOKENVALUE(10, 1534), new TOKENVALUE(10, 1536), new TOKENVALUE(10, 1538), + new TOKENVALUE(10, 1540), new TOKENVALUE(10, 1542), new TOKENVALUE(10, 1544), new TOKENVALUE(10, 1546), new TOKENVALUE(10, 1548), + new TOKENVALUE(10, 1550), new TOKENVALUE(10, 1552), new TOKENVALUE(10, 1554), new TOKENVALUE(10, 1556), new TOKENVALUE(10, 1558), + new TOKENVALUE(10, 1560), new TOKENVALUE(10, 1562), new TOKENVALUE(10, 1564), new TOKENVALUE(10, 1566), new TOKENVALUE(10, 1568), + new TOKENVALUE(10, 1570), new TOKENVALUE(10, 1572), new TOKENVALUE(10, 1574), new TOKENVALUE(10, 1576), new TOKENVALUE(10, 1578), + new TOKENVALUE(10, 1580), new TOKENVALUE(10, 1582), new TOKENVALUE(10, 1584), new TOKENVALUE(10, 1586), new TOKENVALUE(10, 1588), + new TOKENVALUE(10, 1590), new TOKENVALUE(10, 1592), new TOKENVALUE(10, 1594), new TOKENVALUE(10, 1596), new TOKENVALUE(10, 1598), + new TOKENVALUE(10, 1600), new TOKENVALUE(10, 1602), new TOKENVALUE(10, 1604), new TOKENVALUE(10, 1606), new TOKENVALUE(10, 1608), + new TOKENVALUE(10, 1610), new TOKENVALUE(10, 1612), new TOKENVALUE(10, 1614), new TOKENVALUE(10, 1616), new TOKENVALUE(10, 1618), + new TOKENVALUE(10, 1620), new TOKENVALUE(10, 1622), new TOKENVALUE(10, 1624), new TOKENVALUE(10, 1626), new TOKENVALUE(10, 1628), + new TOKENVALUE(10, 1630), new TOKENVALUE(10, 1632), new TOKENVALUE(10, 1634), new TOKENVALUE(10, 1636), new TOKENVALUE(10, 1638), + new TOKENVALUE(10, 1640), new TOKENVALUE(10, 1642), new TOKENVALUE(10, 1644), new TOKENVALUE(10, 1646), new TOKENVALUE(10, 1648), + new TOKENVALUE(10, 1650), new TOKENVALUE(10, 1652), new TOKENVALUE(10, 1654), new TOKENVALUE(10, 1656), new TOKENVALUE(10, 1658), + new TOKENVALUE(10, 1660), new TOKENVALUE(10, 1662), new TOKENVALUE(10, 1664), new TOKENVALUE(10, 1666), new TOKENVALUE(10, 1668), + new TOKENVALUE(10, 1670), new TOKENVALUE(10, 1672), new TOKENVALUE(10, 1674), new TOKENVALUE(10, 1676), new TOKENVALUE(10, 1678), + new TOKENVALUE(10, 1680), new TOKENVALUE(10, 1682), new TOKENVALUE(10, 1684), new TOKENVALUE(10, 1686), new TOKENVALUE(10, 1688), + new TOKENVALUE(10, 1690), new TOKENVALUE(10, 1692), new TOKENVALUE(10, 1694), new TOKENVALUE(10, 1696), new TOKENVALUE(10, 1698), + new TOKENVALUE(10, 1700), new TOKENVALUE(10, 1702), new TOKENVALUE(10, 1704), new TOKENVALUE(10, 1706), new TOKENVALUE(10, 1708), + new TOKENVALUE(10, 1710), new TOKENVALUE(10, 1712), new TOKENVALUE(10, 1714), new TOKENVALUE(10, 1716), new TOKENVALUE(10, 1718), + new TOKENVALUE(10, 1720), new TOKENVALUE(10, 1722), new TOKENVALUE(10, 1724), new TOKENVALUE(10, 1726), new TOKENVALUE(10, 1728), + new TOKENVALUE(10, 1730), new TOKENVALUE(10, 1732), new TOKENVALUE(10, 1734), new TOKENVALUE(10, 1736), new TOKENVALUE(10, 1738), + new TOKENVALUE(10, 1740), new TOKENVALUE(10, 1742), new TOKENVALUE(10, 1744), new TOKENVALUE(10, 1746), new TOKENVALUE(10, 1748), + new TOKENVALUE(10, 1750), new TOKENVALUE(10, 1752), new TOKENVALUE(10, 1754), new TOKENVALUE(10, 1756), new TOKENVALUE(10, 1758), + new TOKENVALUE(10, 1760), new TOKENVALUE(10, 1762), new TOKENVALUE(10, 1764), new TOKENVALUE(10, 1766), new TOKENVALUE(10, 1768), + new TOKENVALUE(10, 1770), new TOKENVALUE(10, 1772), new TOKENVALUE(10, 1774), new TOKENVALUE(10, 1776), new TOKENVALUE(10, 1778), + new TOKENVALUE(10, 1780), new TOKENVALUE(10, 1782), new TOKENVALUE(10, 1784), new TOKENVALUE(10, 1786), new TOKENVALUE(10, 1788), + new TOKENVALUE(10, 1790), new TOKENVALUE(10, 1792), new TOKENVALUE(10, 1794), new TOKENVALUE(10, 1796), new TOKENVALUE(10, 1798), + new TOKENVALUE(10, 1800), new TOKENVALUE(10, 1802), new TOKENVALUE(10, 1804), new TOKENVALUE(10, 1806), new TOKENVALUE(10, 1808), + new TOKENVALUE(10, 1810), new TOKENVALUE(10, 1812), new TOKENVALUE(10, 1814), new TOKENVALUE(10, 1816), new TOKENVALUE(10, 1818), + new TOKENVALUE(10, 1820), new TOKENVALUE(10, 1822), new TOKENVALUE(10, 1824), new TOKENVALUE(10, 1826), new TOKENVALUE(10, 1828), + new TOKENVALUE(10, 1830), new TOKENVALUE(10, 1832), new TOKENVALUE(10, 1834), new TOKENVALUE(10, 1836), new TOKENVALUE(10, 1838), + new TOKENVALUE(10, 1840), new TOKENVALUE(10, 1842), new TOKENVALUE(10, 1844), new TOKENVALUE(10, 1846), new TOKENVALUE(10, 1848), + new TOKENVALUE(10, 1850), new TOKENVALUE(10, 1852), new TOKENVALUE(10, 1854), new TOKENVALUE(10, 1856), new TOKENVALUE(10, 1858), + new TOKENVALUE(10, 1860), new TOKENVALUE(10, 1862), new TOKENVALUE(10, 1864), new TOKENVALUE(10, 1866), new TOKENVALUE(10, 1868), + new TOKENVALUE(10, 1870), new TOKENVALUE(10, 1872), new TOKENVALUE(10, 1874), new TOKENVALUE(10, 1876), new TOKENVALUE(10, 1878), + new TOKENVALUE(10, 1880), new TOKENVALUE(10, 1882), new TOKENVALUE(10, 1884), new TOKENVALUE(10, 1886), new TOKENVALUE(10, 1888), + new TOKENVALUE(10, 1890), new TOKENVALUE(10, 1892), new TOKENVALUE(10, 1894), new TOKENVALUE(10, 1896), new TOKENVALUE(10, 1898), + new TOKENVALUE(10, 1900), new TOKENVALUE(10, 1902), new TOKENVALUE(10, 1904), new TOKENVALUE(10, 1906), new TOKENVALUE(10, 1908), + new TOKENVALUE(10, 1910), new TOKENVALUE(10, 1912), new TOKENVALUE(10, 1914), new TOKENVALUE(10, 1916), new TOKENVALUE(10, 1918), + new TOKENVALUE(10, 1920), new TOKENVALUE(10, 1922), new TOKENVALUE(10, 1924), new TOKENVALUE(10, 1926), new TOKENVALUE(10, 1928), + new TOKENVALUE(10, 1930), new TOKENVALUE(10, 1932), new TOKENVALUE(10, 1934), new TOKENVALUE(10, 1936), new TOKENVALUE(10, 1938), + new TOKENVALUE(10, 1940), new TOKENVALUE(10, 1942), new TOKENVALUE(10, 1944), new TOKENVALUE(10, 1946), new TOKENVALUE(10, 1948), + new TOKENVALUE(10, 1950), new TOKENVALUE(10, 1952), new TOKENVALUE(10, 1954), new TOKENVALUE(10, 1956), new TOKENVALUE(10, 1958), + new TOKENVALUE(10, 1960), new TOKENVALUE(10, 1962), new TOKENVALUE(10, 1964), new TOKENVALUE(10, 1966), new TOKENVALUE(10, 1968), + new TOKENVALUE(10, 1970), new TOKENVALUE(10, 1972), new TOKENVALUE(10, 1974), new TOKENVALUE(10, 1976), new TOKENVALUE(10, 1978), + new TOKENVALUE(10, 1980), new TOKENVALUE(10, 1982), new TOKENVALUE(10, 1984), new TOKENVALUE(10, 1986), new TOKENVALUE(10, 1988), + new TOKENVALUE(10, 1990), new TOKENVALUE(10, 1992), new TOKENVALUE(10, 1994), new TOKENVALUE(10, 1996), new TOKENVALUE(10, 1998), + new TOKENVALUE(10, 2000), new TOKENVALUE(10, 2002), new TOKENVALUE(10, 2004), new TOKENVALUE(10, 2006), new TOKENVALUE(10, 2008), + new TOKENVALUE(10, 2010), new TOKENVALUE(10, 2012), new TOKENVALUE(10, 2014), new TOKENVALUE(10, 2016), new TOKENVALUE(10, 2018), + new TOKENVALUE(10, 2020), new TOKENVALUE(10, 2022), new TOKENVALUE(10, 2024), new TOKENVALUE(10, 2026), new TOKENVALUE(10, 2028), + new TOKENVALUE(10, 2030), new TOKENVALUE(10, 2032), new TOKENVALUE(10, 2034), new TOKENVALUE(10, 2036), new TOKENVALUE(10, 2038), + new TOKENVALUE(10, 2040), new TOKENVALUE(10, 2042), new TOKENVALUE(10, 2044), new TOKENVALUE(10, 2046), new TOKENVALUE(10, 2048), + new TOKENVALUE(10, 2050), new TOKENVALUE(10, 2052), new TOKENVALUE(10, 2054), new TOKENVALUE(10, 2056), new TOKENVALUE(10, 2058), + new TOKENVALUE(10, 2060), new TOKENVALUE(10, 2062), new TOKENVALUE(10, 2064), new TOKENVALUE(10, 2066), new TOKENVALUE(10, 2068), + new TOKENVALUE(10, 2070), new TOKENVALUE(10, 2072), new TOKENVALUE(10, 2074), new TOKENVALUE(10, 2076), new TOKENVALUE(10, 2078), + new TOKENVALUE(10, 2080), new TOKENVALUE(10, 2082), new TOKENVALUE(10, 2084), new TOKENVALUE(10, 2086), new TOKENVALUE(10, 2088), + new TOKENVALUE(10, 2090), new TOKENVALUE(10, 2092), new TOKENVALUE(10, 2094), new TOKENVALUE(10, 2096), new TOKENVALUE(10, 2098), + new TOKENVALUE(10, 2100), new TOKENVALUE(10, 2102), new TOKENVALUE(10, 2104), new TOKENVALUE(10, 2106), new TOKENVALUE(10, 2108), + new TOKENVALUE(10, 2110), new TOKENVALUE(10, 2112), new TOKENVALUE(10, 2114), new TOKENVALUE(10, 2116), new TOKENVALUE(10, 2118), + new TOKENVALUE(10, 2120), new TOKENVALUE(10, 2122), new TOKENVALUE(10, 2124), new TOKENVALUE(10, 2126), new TOKENVALUE(10, 2128), + new TOKENVALUE(10, 2130), new TOKENVALUE(10, 2132), new TOKENVALUE(10, 2134), new TOKENVALUE(10, 2136), new TOKENVALUE(10, 2138), + new TOKENVALUE(10, 2140), new TOKENVALUE(10, 2142), new TOKENVALUE(10, 2144), new TOKENVALUE(10, 2146), new TOKENVALUE(10, 2148), + new TOKENVALUE(10, 2150), new TOKENVALUE(10, 2152), new TOKENVALUE(10, 2154), new TOKENVALUE(10, 2156), new TOKENVALUE(10, 2158), + new TOKENVALUE(10, 2160), new TOKENVALUE(10, 2162), new TOKENVALUE(10, 2164), new TOKENVALUE(10, 2166), new TOKENVALUE(10, 2168), + new TOKENVALUE(10, 2170), new TOKENVALUE(10, 2172), new TOKENVALUE(10, 2174), new TOKENVALUE(10, 2176), new TOKENVALUE(10, 2178), + new TOKENVALUE(10, 2180), new TOKENVALUE(10, 2182), new TOKENVALUE(10, 2184), new TOKENVALUE(10, 2186), new TOKENVALUE(10, 2188), + new TOKENVALUE(10, 2190), new TOKENVALUE(10, 2192), new TOKENVALUE(10, 2194), new TOKENVALUE(10, 2196), new TOKENVALUE(10, 2198), + new TOKENVALUE(10, 2200), new TOKENVALUE(10, 2202), new TOKENVALUE(10, 2204), new TOKENVALUE(10, 2206), new TOKENVALUE(10, 2208), + new TOKENVALUE(10, 2210), new TOKENVALUE(10, 2212), new TOKENVALUE(10, 2214), new TOKENVALUE(10, 2216), new TOKENVALUE(10, 2218), + new TOKENVALUE(10, 2220), new TOKENVALUE(10, 2222), new TOKENVALUE(10, 2224), new TOKENVALUE(10, 2226), new TOKENVALUE(10, 2228), + new TOKENVALUE(10, 2230), new TOKENVALUE(10, 2232), new TOKENVALUE(10, 2234), new TOKENVALUE(10, 2236), new TOKENVALUE(10, 2238), + new TOKENVALUE(10, 2240), new TOKENVALUE(10, 2242), new TOKENVALUE(10, 2244), new TOKENVALUE(10, 2246), new TOKENVALUE(10, 2248), + new TOKENVALUE(10, 2250), new TOKENVALUE(10, 2252), new TOKENVALUE(10, 2254), new TOKENVALUE(10, 2256), new TOKENVALUE(10, 2258), + new TOKENVALUE(10, 2260), new TOKENVALUE(10, 2262), new TOKENVALUE(10, 2264), new TOKENVALUE(10, 2266), new TOKENVALUE(10, 2268), + new TOKENVALUE(10, 2270), new TOKENVALUE(10, 2272), new TOKENVALUE(10, 2274), new TOKENVALUE(10, 2276), new TOKENVALUE(10, 2278), + new TOKENVALUE(10, 2280), new TOKENVALUE(10, 2282), new TOKENVALUE(10, 2284), new TOKENVALUE(10, 2286), new TOKENVALUE(10, 2288), + new TOKENVALUE(10, 2290), new TOKENVALUE(10, 2292), new TOKENVALUE(10, 2294), new TOKENVALUE(10, 2296), new TOKENVALUE(10, 2298), + new TOKENVALUE(10, 2300), new TOKENVALUE(10, 2302), new TOKENVALUE(10, 2304), new TOKENVALUE(10, 2306), new TOKENVALUE(10, 2308), + new TOKENVALUE(10, 2310), new TOKENVALUE(10, 2312), new TOKENVALUE(10, 2314), new TOKENVALUE(10, 2316), new TOKENVALUE(10, 2318), + new TOKENVALUE(10, 2320), new TOKENVALUE(10, 2322), new TOKENVALUE(10, 2324), new TOKENVALUE(10, 2326), new TOKENVALUE(10, 2328), + new TOKENVALUE(10, 2330), new TOKENVALUE(10, 2332), new TOKENVALUE(10, 2334), new TOKENVALUE(10, 2336), new TOKENVALUE(10, 2338), + new TOKENVALUE(10, 2340), new TOKENVALUE(10, 2342), new TOKENVALUE(10, 2344), new TOKENVALUE(10, 2346), new TOKENVALUE(10, 2348), + new TOKENVALUE(10, 2350), new TOKENVALUE(10, 2352), new TOKENVALUE(10, 2354), new TOKENVALUE(10, 2356), new TOKENVALUE(10, 2358), + new TOKENVALUE(10, 2360), new TOKENVALUE(10, 2362), new TOKENVALUE(10, 2364), new TOKENVALUE(10, 2366), new TOKENVALUE(10, 2368), + new TOKENVALUE(10, 2370), new TOKENVALUE(10, 2372), new TOKENVALUE(10, 2374), new TOKENVALUE(10, 2376), new TOKENVALUE(10, 2378), + new TOKENVALUE(10, 2380), new TOKENVALUE(10, 2382), new TOKENVALUE(10, 2384), new TOKENVALUE(10, 2386), new TOKENVALUE(10, 2388), + new TOKENVALUE(10, 2390), new TOKENVALUE(10, 2392), new TOKENVALUE(10, 2394), new TOKENVALUE(10, 2396), new TOKENVALUE(10, 2398), + new TOKENVALUE(10, 2400), new TOKENVALUE(10, 2402), new TOKENVALUE(10, 2404), new TOKENVALUE(10, 2406), new TOKENVALUE(10, 2408), + new TOKENVALUE(10, 2410), new TOKENVALUE(10, 2412), new TOKENVALUE(10, 2414), new TOKENVALUE(10, 2416), new TOKENVALUE(10, 2418), + new TOKENVALUE(10, 2420), new TOKENVALUE(10, 2422), new TOKENVALUE(10, 2424), new TOKENVALUE(10, 2426), new TOKENVALUE(10, 2428), + new TOKENVALUE(10, 2430), new TOKENVALUE(10, 2432), new TOKENVALUE(10, 2434), new TOKENVALUE(10, 2436), new TOKENVALUE(10, 2438), + new TOKENVALUE(10, 2440), new TOKENVALUE(10, 2442), new TOKENVALUE(10, 2444), new TOKENVALUE(10, 2446), new TOKENVALUE(10, 2448), + new TOKENVALUE(10, 2450), new TOKENVALUE(10, 2452), new TOKENVALUE(10, 2454), new TOKENVALUE(10, 2456), new TOKENVALUE(10, 2458), + new TOKENVALUE(10, 2460), new TOKENVALUE(10, 2462), new TOKENVALUE(10, 2464), new TOKENVALUE(10, 2466), new TOKENVALUE(10, 2468), + new TOKENVALUE(10, 2470), new TOKENVALUE(10, 2472), new TOKENVALUE(10, 2474), new TOKENVALUE(10, 2476), new TOKENVALUE(10, 2478), + new TOKENVALUE(10, 2480), new TOKENVALUE(10, 2482), new TOKENVALUE(10, 2484), new TOKENVALUE(10, 2486), new TOKENVALUE(10, 2488), + new TOKENVALUE(10, 2490), new TOKENVALUE(10, 2492), new TOKENVALUE(10, 2494), new TOKENVALUE(10, 2496), new TOKENVALUE(10, 2498), + new TOKENVALUE(10, 2500), new TOKENVALUE(10, 2502), new TOKENVALUE(10, 2504), new TOKENVALUE(10, 2506), new TOKENVALUE(10, 2508), + new TOKENVALUE(10, 2510), new TOKENVALUE(10, 2512), new TOKENVALUE(10, 2514), new TOKENVALUE(10, 2516), new TOKENVALUE(10, 2518), + new TOKENVALUE(10, 2520), new TOKENVALUE(10, 2522), new TOKENVALUE(10, 2524), new TOKENVALUE(10, 2526), new TOKENVALUE(10, 2528), + new TOKENVALUE(10, 2530), new TOKENVALUE(10, 2532), new TOKENVALUE(10, 2534), new TOKENVALUE(10, 2536), new TOKENVALUE(10, 2538), + new TOKENVALUE(10, 2540), new TOKENVALUE(10, 2542), new TOKENVALUE(10, 2544), new TOKENVALUE(10, 2546), new TOKENVALUE(10, 2548), + new TOKENVALUE(10, 2550), new TOKENVALUE(10, 2552), new TOKENVALUE(10, 2554), new TOKENVALUE(10, 2556), new TOKENVALUE(10, 2558), + new TOKENVALUE(10, 2560), new TOKENVALUE(10, 2562), new TOKENVALUE(10, 2564), new TOKENVALUE(10, 2566), new TOKENVALUE(10, 2568), + new TOKENVALUE(10, 2570), new TOKENVALUE(10, 2572), new TOKENVALUE(10, 2574), new TOKENVALUE(10, 2576), new TOKENVALUE(10, 2578), + new TOKENVALUE(10, 2580), new TOKENVALUE(10, 2582), new TOKENVALUE(10, 2584), new TOKENVALUE(10, 2586), new TOKENVALUE(10, 2588), + new TOKENVALUE(10, 2590), new TOKENVALUE(10, 2592), new TOKENVALUE(10, 2594), new TOKENVALUE(10, 2596), new TOKENVALUE(10, 2598), + new TOKENVALUE(10, 2600), new TOKENVALUE(10, 2602), new TOKENVALUE(10, 2604), new TOKENVALUE(10, 2606), new TOKENVALUE(10, 2608), + new TOKENVALUE(10, 2610), new TOKENVALUE(10, 2612), new TOKENVALUE(10, 2614), new TOKENVALUE(10, 2616), new TOKENVALUE(10, 2618), + new TOKENVALUE(10, 2620), new TOKENVALUE(10, 2622), new TOKENVALUE(10, 2624), new TOKENVALUE(10, 2626), new TOKENVALUE(10, 2628), + new TOKENVALUE(10, 2630), new TOKENVALUE(10, 2632), new TOKENVALUE(10, 2634), new TOKENVALUE(10, 2636), new TOKENVALUE(10, 2638), + new TOKENVALUE(10, 2640), new TOKENVALUE(10, 2642), new TOKENVALUE(10, 2644), new TOKENVALUE(10, 2646), new TOKENVALUE(10, 2648), + new TOKENVALUE(10, 2650), new TOKENVALUE(10, 2652), new TOKENVALUE(10, 2654), new TOKENVALUE(10, 2656), new TOKENVALUE(10, 2658), + new TOKENVALUE(10, 2660), new TOKENVALUE(10, 2662), new TOKENVALUE(10, 2664), new TOKENVALUE(10, 2666), new TOKENVALUE(10, 2668), + new TOKENVALUE(10, 2670), new TOKENVALUE(10, 2672), new TOKENVALUE(10, 2674), new TOKENVALUE(10, 2676), new TOKENVALUE(10, 2678), + new TOKENVALUE(10, 2680), new TOKENVALUE(10, 2682), new TOKENVALUE(10, 2684), new TOKENVALUE(10, 2686), new TOKENVALUE(10, 2688), + new TOKENVALUE(10, 2690), new TOKENVALUE(10, 2692), new TOKENVALUE(10, 2694), new TOKENVALUE(10, 2696), new TOKENVALUE(10, 2698), + new TOKENVALUE(10, 2700), new TOKENVALUE(10, 2702), new TOKENVALUE(10, 2704), new TOKENVALUE(10, 2706), new TOKENVALUE(10, 2708), + new TOKENVALUE(10, 2710), new TOKENVALUE(10, 2712), new TOKENVALUE(10, 2714), new TOKENVALUE(10, 2716), new TOKENVALUE(10, 2718), + new TOKENVALUE(10, 2720), new TOKENVALUE(10, 2722), new TOKENVALUE(10, 2724), new TOKENVALUE(10, 2726), new TOKENVALUE(10, 2728), + new TOKENVALUE(10, 2730), new TOKENVALUE(10, 2732), new TOKENVALUE(10, 2734), new TOKENVALUE(10, 2736), new TOKENVALUE(10, 2738), + new TOKENVALUE(10, 2740), new TOKENVALUE(10, 2742), new TOKENVALUE(10, 2744), new TOKENVALUE(10, 2746), new TOKENVALUE(10, 2748), + new TOKENVALUE(10, 2750), new TOKENVALUE(10, 2752), new TOKENVALUE(10, 2754), new TOKENVALUE(10, 2756), new TOKENVALUE(10, 2758), + new TOKENVALUE(10, 2760), new TOKENVALUE(10, 2762), new TOKENVALUE(10, 2764), new TOKENVALUE(10, 2766), new TOKENVALUE(10, 2768), + new TOKENVALUE(10, 2770), new TOKENVALUE(10, 2772), new TOKENVALUE(10, 2774), new TOKENVALUE(10, 2776), new TOKENVALUE(10, 2778), + new TOKENVALUE(10, 2780), new TOKENVALUE(10, 2782), new TOKENVALUE(10, 2784), new TOKENVALUE(10, 2786), new TOKENVALUE(10, 2788), + new TOKENVALUE(10, 2790), new TOKENVALUE(10, 2792), new TOKENVALUE(10, 2794), new TOKENVALUE(10, 2796), new TOKENVALUE(10, 2798), + new TOKENVALUE(10, 2800), new TOKENVALUE(10, 2802), new TOKENVALUE(10, 2804), new TOKENVALUE(10, 2806), new TOKENVALUE(10, 2808), + new TOKENVALUE(10, 2810), new TOKENVALUE(10, 2812), new TOKENVALUE(10, 2814), new TOKENVALUE(10, 2816), new TOKENVALUE(10, 2818), + new TOKENVALUE(10, 2820), new TOKENVALUE(10, 2822), new TOKENVALUE(10, 2824), new TOKENVALUE(10, 2826), new TOKENVALUE(10, 2828), + new TOKENVALUE(10, 2830), new TOKENVALUE(10, 2832), new TOKENVALUE(10, 2834), new TOKENVALUE(10, 2836), new TOKENVALUE(10, 2838), + new TOKENVALUE(10, 2840), new TOKENVALUE(10, 2842), new TOKENVALUE(10, 2844), new TOKENVALUE(10, 2846), new TOKENVALUE(10, 2848), + new TOKENVALUE(10, 2850), new TOKENVALUE(10, 2852), new TOKENVALUE(10, 2854), new TOKENVALUE(10, 2856), new TOKENVALUE(10, 2858), + new TOKENVALUE(10, 2860), new TOKENVALUE(10, 2862), new TOKENVALUE(10, 2864), new TOKENVALUE(10, 2866), new TOKENVALUE(10, 2868), + new TOKENVALUE(10, 2870), new TOKENVALUE(10, 2872), new TOKENVALUE(10, 2874), new TOKENVALUE(10, 2876), new TOKENVALUE(10, 2878), + new TOKENVALUE(10, 2880), new TOKENVALUE(10, 2882), new TOKENVALUE(10, 2884), new TOKENVALUE(10, 2886), new TOKENVALUE(10, 2888), + new TOKENVALUE(10, 2890), new TOKENVALUE(10, 2892), new TOKENVALUE(10, 2894), new TOKENVALUE(10, 2896), new TOKENVALUE(10, 2898), + new TOKENVALUE(10, 2900), new TOKENVALUE(10, 2902), new TOKENVALUE(10, 2904), new TOKENVALUE(10, 2906), new TOKENVALUE(10, 2908), + new TOKENVALUE(10, 2910), new TOKENVALUE(10, 2912), new TOKENVALUE(10, 2914), new TOKENVALUE(10, 2916), new TOKENVALUE(10, 2918), + new TOKENVALUE(10, 2920), new TOKENVALUE(10, 2922), new TOKENVALUE(10, 2924), new TOKENVALUE(10, 2926), new TOKENVALUE(10, 2928), + new TOKENVALUE(10, 2930), new TOKENVALUE(10, 2932), new TOKENVALUE(10, 2934), new TOKENVALUE(10, 2936), new TOKENVALUE(10, 2938), + new TOKENVALUE(10, 2940), new TOKENVALUE(10, 2942), new TOKENVALUE(10, 2944), new TOKENVALUE(10, 2946), new TOKENVALUE(10, 2948), + new TOKENVALUE(10, 2950), new TOKENVALUE(10, 2952), new TOKENVALUE(10, 2954), new TOKENVALUE(10, 2956), new TOKENVALUE(10, 2958), + new TOKENVALUE(10, 2960), new TOKENVALUE(10, 2962), new TOKENVALUE(10, 2964), new TOKENVALUE(10, 2966), new TOKENVALUE(10, 2968), + new TOKENVALUE(10, 2970), new TOKENVALUE(10, 2972), new TOKENVALUE(10, 2974), new TOKENVALUE(10, 2976), new TOKENVALUE(10, 2978), + new TOKENVALUE(10, 2980), new TOKENVALUE(10, 2982), new TOKENVALUE(10, 2984), new TOKENVALUE(10, 2986), new TOKENVALUE(10, 2988), + new TOKENVALUE(10, 2990), new TOKENVALUE(10, 2992), new TOKENVALUE(10, 2994), new TOKENVALUE(10, 2996), new TOKENVALUE(10, 2998), + new TOKENVALUE(10, 3000), new TOKENVALUE(10, 3002), new TOKENVALUE(10, 3004), new TOKENVALUE(10, 3006), new TOKENVALUE(10, 3008), + new TOKENVALUE(10, 3010), new TOKENVALUE(10, 3012), new TOKENVALUE(10, 3014), new TOKENVALUE(10, 3016), new TOKENVALUE(10, 3018), + new TOKENVALUE(10, 3020), new TOKENVALUE(10, 3022), new TOKENVALUE(10, 3024), new TOKENVALUE(10, 3026), new TOKENVALUE(10, 3028), + new TOKENVALUE(10, 3030), new TOKENVALUE(10, 3032), new TOKENVALUE(10, 3034), new TOKENVALUE(10, 3036), new TOKENVALUE(10, 3038), + new TOKENVALUE(10, 3040), new TOKENVALUE(10, 3042), new TOKENVALUE(10, 3044), new TOKENVALUE(10, 3046), new TOKENVALUE(10, 3048), + new TOKENVALUE(10, 3050), new TOKENVALUE(10, 3052), new TOKENVALUE(10, 3054), new TOKENVALUE(10, 3056), new TOKENVALUE(10, 3058), + new TOKENVALUE(10, 3060), new TOKENVALUE(10, 3062), new TOKENVALUE(10, 3064), new TOKENVALUE(10, 3066), new TOKENVALUE(10, 3068), + new TOKENVALUE(10, 3070), new TOKENVALUE(10, 3072), new TOKENVALUE(10, 3074), new TOKENVALUE(10, 3076), new TOKENVALUE(10, 3078), + new TOKENVALUE(10, 3080), new TOKENVALUE(10, 3082), new TOKENVALUE(10, 3084), new TOKENVALUE(10, 3086), new TOKENVALUE(10, 3088), + new TOKENVALUE(10, 3090), new TOKENVALUE(10, 3092), new TOKENVALUE(10, 3094), new TOKENVALUE(10, 3096), new TOKENVALUE(10, 3098), + new TOKENVALUE(10, 3100), new TOKENVALUE(10, 3102), new TOKENVALUE(10, 3104), new TOKENVALUE(10, 3106), new TOKENVALUE(10, 3108), + new TOKENVALUE(10, 3110), new TOKENVALUE(10, 3112), new TOKENVALUE(10, 3114), new TOKENVALUE(10, 3116), new TOKENVALUE(10, 3118), + new TOKENVALUE(10, 3120), new TOKENVALUE(10, 3122), new TOKENVALUE(10, 3124), new TOKENVALUE(10, 3126), new TOKENVALUE(10, 3128), + new TOKENVALUE(10, 3130), new TOKENVALUE(10, 3132), new TOKENVALUE(10, 3134), new TOKENVALUE(10, 3136), new TOKENVALUE(10, 3138), + new TOKENVALUE(10, 3140), new TOKENVALUE(10, 3142), new TOKENVALUE(10, 3144), new TOKENVALUE(10, 3146), new TOKENVALUE(10, 3148), + new TOKENVALUE(10, 3150), new TOKENVALUE(10, 3152), new TOKENVALUE(10, 3154), new TOKENVALUE(10, 3156), new TOKENVALUE(10, 3158), + new TOKENVALUE(10, 3160), new TOKENVALUE(10, 3162), new TOKENVALUE(10, 3164), new TOKENVALUE(10, 3166), new TOKENVALUE(10, 3168), + new TOKENVALUE(10, 3170), new TOKENVALUE(10, 3172), new TOKENVALUE(10, 3174), new TOKENVALUE(10, 3176), new TOKENVALUE(10, 3178), + new TOKENVALUE(10, 3180), new TOKENVALUE(10, 3182), new TOKENVALUE(10, 3184), new TOKENVALUE(10, 3186), new TOKENVALUE(10, 3188), + new TOKENVALUE(10, 3190), new TOKENVALUE(10, 3192), new TOKENVALUE(10, 3194), new TOKENVALUE(10, 3196), new TOKENVALUE(10, 3198), + new TOKENVALUE(10, 3200), new TOKENVALUE(10, 3202), new TOKENVALUE(10, 3204), new TOKENVALUE(10, 3206), new TOKENVALUE(10, 3208), + new TOKENVALUE(10, 3210), new TOKENVALUE(10, 3212), new TOKENVALUE(10, 3214), new TOKENVALUE(10, 3216), new TOKENVALUE(10, 3218), + new TOKENVALUE(10, 3220), new TOKENVALUE(10, 3222), new TOKENVALUE(10, 3224), new TOKENVALUE(10, 3226), new TOKENVALUE(10, 3228), + new TOKENVALUE(10, 3230), new TOKENVALUE(10, 3232), new TOKENVALUE(10, 3234), new TOKENVALUE(10, 3236), new TOKENVALUE(10, 3238), + new TOKENVALUE(10, 3240), new TOKENVALUE(10, 3242), new TOKENVALUE(10, 3244), new TOKENVALUE(10, 3246), new TOKENVALUE(10, 3248), + new TOKENVALUE(10, 3250), new TOKENVALUE(10, 3252), new TOKENVALUE(10, 3254), new TOKENVALUE(10, 3256), new TOKENVALUE(10, 3258), + new TOKENVALUE(10, 3260), new TOKENVALUE(10, 3262), new TOKENVALUE(10, 3264), new TOKENVALUE(10, 3266), new TOKENVALUE(10, 3268), + new TOKENVALUE(10, 3270), new TOKENVALUE(10, 3272), new TOKENVALUE(10, 3274), new TOKENVALUE(10, 3276), new TOKENVALUE(10, 3278), + new TOKENVALUE(10, 3280), new TOKENVALUE(10, 3282), new TOKENVALUE(10, 3284), new TOKENVALUE(10, 3286), new TOKENVALUE(10, 3288), + new TOKENVALUE(10, 3290), new TOKENVALUE(10, 3292), new TOKENVALUE(10, 3294), new TOKENVALUE(10, 3296), new TOKENVALUE(10, 3298), + new TOKENVALUE(10, 3300), new TOKENVALUE(10, 3302), new TOKENVALUE(10, 3304), new TOKENVALUE(10, 3306), new TOKENVALUE(10, 3308), + new TOKENVALUE(10, 3310), new TOKENVALUE(10, 3312), new TOKENVALUE(10, 3314), new TOKENVALUE(10, 3316), new TOKENVALUE(10, 3318), + new TOKENVALUE(10, 3320), new TOKENVALUE(10, 3322), new TOKENVALUE(10, 3324), new TOKENVALUE(10, 3326), new TOKENVALUE(10, 3328), + new TOKENVALUE(10, 3330), new TOKENVALUE(10, 3332), new TOKENVALUE(10, 3334), new TOKENVALUE(10, 3336), new TOKENVALUE(10, 3338), + new TOKENVALUE(10, 3340), new TOKENVALUE(10, 3342), new TOKENVALUE(10, 3344), new TOKENVALUE(10, 3346), new TOKENVALUE(10, 3348), + new TOKENVALUE(10, 3350), new TOKENVALUE(10, 3352), new TOKENVALUE(10, 3354), new TOKENVALUE(10, 3356), new TOKENVALUE(10, 3358), + new TOKENVALUE(10, 3360), new TOKENVALUE(10, 3362), new TOKENVALUE(10, 3364), new TOKENVALUE(10, 3366), new TOKENVALUE(10, 3368), + new TOKENVALUE(10, 3370), new TOKENVALUE(10, 3372), new TOKENVALUE(10, 3374), new TOKENVALUE(10, 3376), new TOKENVALUE(10, 3378), + new TOKENVALUE(10, 3380), new TOKENVALUE(10, 3382), new TOKENVALUE(10, 3384), new TOKENVALUE(10, 3386), new TOKENVALUE(10, 3388), + new TOKENVALUE(10, 3390), new TOKENVALUE(10, 3392), new TOKENVALUE(10, 3394), new TOKENVALUE(10, 3396), new TOKENVALUE(10, 3398), + new TOKENVALUE(10, 3400), new TOKENVALUE(10, 3402), new TOKENVALUE(10, 3404), new TOKENVALUE(10, 3406), new TOKENVALUE(10, 3408), + new TOKENVALUE(10, 3410), new TOKENVALUE(10, 3412), new TOKENVALUE(10, 3414), new TOKENVALUE(10, 3416), new TOKENVALUE(10, 3418), + new TOKENVALUE(10, 3420), new TOKENVALUE(10, 3422), new TOKENVALUE(10, 3424), new TOKENVALUE(10, 3426), new TOKENVALUE(10, 3428), + new TOKENVALUE(10, 3430), new TOKENVALUE(10, 3432), new TOKENVALUE(10, 3434), new TOKENVALUE(10, 3436), new TOKENVALUE(10, 3438), + new TOKENVALUE(10, 3440), new TOKENVALUE(10, 3442), new TOKENVALUE(10, 3444), new TOKENVALUE(10, 3446), new TOKENVALUE(10, 3448), + new TOKENVALUE(10, 3450), new TOKENVALUE(10, 3452), new TOKENVALUE(10, 3454), new TOKENVALUE(10, 3456), new TOKENVALUE(10, 3458), + new TOKENVALUE(10, 3460), new TOKENVALUE(10, 3462), new TOKENVALUE(10, 3464), new TOKENVALUE(10, 3466), new TOKENVALUE(10, 3468), + new TOKENVALUE(10, 3470), new TOKENVALUE(10, 3472), new TOKENVALUE(10, 3474), new TOKENVALUE(10, 3476), new TOKENVALUE(10, 3478), + new TOKENVALUE(10, 3480), new TOKENVALUE(10, 3482), new TOKENVALUE(10, 3484), new TOKENVALUE(10, 3486), new TOKENVALUE(10, 3488), + new TOKENVALUE(10, 3490), new TOKENVALUE(10, 3492), new TOKENVALUE(10, 3494), new TOKENVALUE(10, 3496), new TOKENVALUE(10, 3498), + new TOKENVALUE(10, 3500), new TOKENVALUE(10, 3502), new TOKENVALUE(10, 3504), new TOKENVALUE(10, 3506), new TOKENVALUE(10, 3508), + new TOKENVALUE(10, 3510), new TOKENVALUE(10, 3512), new TOKENVALUE(10, 3514), new TOKENVALUE(10, 3516), new TOKENVALUE(10, 3518), + new TOKENVALUE(10, 3520), new TOKENVALUE(10, 3522), new TOKENVALUE(10, 3524), new TOKENVALUE(10, 3526), new TOKENVALUE(10, 3528), + new TOKENVALUE(10, 3530), new TOKENVALUE(10, 3532), new TOKENVALUE(10, 3534), new TOKENVALUE(10, 3536), new TOKENVALUE(10, 3538), + new TOKENVALUE(10, 3540), new TOKENVALUE(10, 3542), new TOKENVALUE(10, 3544), new TOKENVALUE(10, 3546), new TOKENVALUE(10, 3548), + new TOKENVALUE(10, 3550), new TOKENVALUE(10, 3552), new TOKENVALUE(10, 3554), new TOKENVALUE(10, 3556), new TOKENVALUE(10, 3558), + new TOKENVALUE(10, 3560), new TOKENVALUE(10, 3562), new TOKENVALUE(10, 3564), new TOKENVALUE(10, 3566), new TOKENVALUE(10, 3568), + new TOKENVALUE(10, 3570), new TOKENVALUE(10, 3572), new TOKENVALUE(10, 3574), new TOKENVALUE(10, 3576), new TOKENVALUE(10, 3578), + new TOKENVALUE(10, 3580), new TOKENVALUE(10, 3582), new TOKENVALUE(10, 3584), new TOKENVALUE(10, 3586), new TOKENVALUE(10, 3588), + new TOKENVALUE(10, 3590), new TOKENVALUE(10, 3592), new TOKENVALUE(10, 3594), new TOKENVALUE(10, 3596), new TOKENVALUE(10, 3598), + new TOKENVALUE(10, 3600), new TOKENVALUE(10, 3602), new TOKENVALUE(10, 3604), new TOKENVALUE(10, 3606), new TOKENVALUE(10, 3608), + new TOKENVALUE(10, 3610), new TOKENVALUE(10, 3612), new TOKENVALUE(10, 3614), new TOKENVALUE(10, 3616), new TOKENVALUE(10, 3618), + new TOKENVALUE(10, 3620), new TOKENVALUE(10, 3622), new TOKENVALUE(10, 3624), new TOKENVALUE(10, 3626), new TOKENVALUE(10, 3628), + new TOKENVALUE(10, 3630), new TOKENVALUE(10, 3632), new TOKENVALUE(10, 3634), new TOKENVALUE(10, 3636), new TOKENVALUE(10, 3638), + new TOKENVALUE(10, 3640), new TOKENVALUE(10, 3642), new TOKENVALUE(10, 3644), new TOKENVALUE(10, 3646), new TOKENVALUE(10, 3648), + new TOKENVALUE(10, 3650), new TOKENVALUE(10, 3652), new TOKENVALUE(10, 3654), new TOKENVALUE(10, 3656), new TOKENVALUE(10, 3658), + new TOKENVALUE(10, 3660), new TOKENVALUE(10, 3662), new TOKENVALUE(10, 3664), new TOKENVALUE(10, 3666), new TOKENVALUE(10, 3668), + new TOKENVALUE(10, 3670), new TOKENVALUE(10, 3672), new TOKENVALUE(10, 3674), new TOKENVALUE(10, 3676), new TOKENVALUE(10, 3678), + new TOKENVALUE(10, 3680), new TOKENVALUE(10, 3682), new TOKENVALUE(10, 3684), new TOKENVALUE(10, 3686), new TOKENVALUE(10, 3688), + new TOKENVALUE(10, 3690), new TOKENVALUE(10, 3692), new TOKENVALUE(10, 3694), new TOKENVALUE(10, 3696), new TOKENVALUE(10, 3698), + new TOKENVALUE(10, 3700), new TOKENVALUE(10, 3702), new TOKENVALUE(10, 3704), new TOKENVALUE(10, 3706), new TOKENVALUE(10, 3708), + new TOKENVALUE(10, 3710), new TOKENVALUE(10, 3712), new TOKENVALUE(10, 3714), new TOKENVALUE(10, 3716), new TOKENVALUE(10, 3718), + new TOKENVALUE(10, 3720), new TOKENVALUE(10, 3722), new TOKENVALUE(10, 3724), new TOKENVALUE(10, 3726), new TOKENVALUE(10, 3728), + new TOKENVALUE(10, 3730), new TOKENVALUE(10, 3732), new TOKENVALUE(10, 3734), new TOKENVALUE(10, 3736), new TOKENVALUE(10, 3738), + new TOKENVALUE(10, 3740), new TOKENVALUE(10, 3742), new TOKENVALUE(10, 3744), new TOKENVALUE(10, 3746), new TOKENVALUE(10, 3748), + new TOKENVALUE(10, 3750), new TOKENVALUE(10, 3752), new TOKENVALUE(10, 3754), new TOKENVALUE(10, 3756), new TOKENVALUE(10, 3758), + new TOKENVALUE(10, 3760), new TOKENVALUE(10, 3762), new TOKENVALUE(10, 3764), new TOKENVALUE(10, 3766), new TOKENVALUE(10, 3768), + new TOKENVALUE(10, 3770), new TOKENVALUE(10, 3772), new TOKENVALUE(10, 3774), new TOKENVALUE(10, 3776), new TOKENVALUE(10, 3778), + new TOKENVALUE(10, 3780), new TOKENVALUE(10, 3782), new TOKENVALUE(10, 3784), new TOKENVALUE(10, 3786), new TOKENVALUE(10, 3788), + new TOKENVALUE(10, 3790), new TOKENVALUE(10, 3792), new TOKENVALUE(10, 3794), new TOKENVALUE(10, 3796), new TOKENVALUE(10, 3798), + new TOKENVALUE(10, 3800), new TOKENVALUE(10, 3802), new TOKENVALUE(10, 3804), new TOKENVALUE(10, 3806), new TOKENVALUE(10, 3808), + new TOKENVALUE(10, 3810), new TOKENVALUE(10, 3812), new TOKENVALUE(10, 3814), new TOKENVALUE(10, 3816), new TOKENVALUE(10, 3818), + new TOKENVALUE(10, 3820), new TOKENVALUE(10, 3822), new TOKENVALUE(10, 3824), new TOKENVALUE(10, 3826), new TOKENVALUE(10, 3828), + new TOKENVALUE(10, 3830), new TOKENVALUE(10, 3832), new TOKENVALUE(10, 3834), new TOKENVALUE(10, 3836), new TOKENVALUE(10, 3838), + new TOKENVALUE(10, 3840), new TOKENVALUE(10, 3842), new TOKENVALUE(10, 3844), new TOKENVALUE(10, 3846), new TOKENVALUE(10, 3848), + new TOKENVALUE(10, 3850), new TOKENVALUE(10, 3852), new TOKENVALUE(10, 3854), new TOKENVALUE(10, 3856), new TOKENVALUE(10, 3858), + new TOKENVALUE(10, 3860), new TOKENVALUE(10, 3862), new TOKENVALUE(10, 3864), new TOKENVALUE(10, 3866), new TOKENVALUE(10, 3868), + new TOKENVALUE(10, 3870), new TOKENVALUE(10, 3872), new TOKENVALUE(10, 3874), new TOKENVALUE(10, 3876), new TOKENVALUE(10, 3878), + new TOKENVALUE(10, 3880), new TOKENVALUE(10, 3882), new TOKENVALUE(10, 3884), new TOKENVALUE(10, 3886), new TOKENVALUE(10, 3888), + new TOKENVALUE(10, 3890), new TOKENVALUE(10, 3892), new TOKENVALUE(10, 3894), new TOKENVALUE(10, 3896), new TOKENVALUE(10, 3898), + new TOKENVALUE(10, 3900), new TOKENVALUE(10, 3902), new TOKENVALUE(10, 3904), new TOKENVALUE(10, 3906), new TOKENVALUE(10, 3908), + new TOKENVALUE(10, 3910), new TOKENVALUE(10, 3912), new TOKENVALUE(10, 3914), new TOKENVALUE(10, 3916), new TOKENVALUE(10, 3918), + new TOKENVALUE(10, 3920), new TOKENVALUE(10, 3922), new TOKENVALUE(10, 3924), new TOKENVALUE(10, 3926), new TOKENVALUE(10, 3928), + new TOKENVALUE(10, 3930), new TOKENVALUE(10, 3932), new TOKENVALUE(10, 3934), new TOKENVALUE(10, 3936), new TOKENVALUE(10, 3938), + new TOKENVALUE(10, 3940), new TOKENVALUE(10, 3942), new TOKENVALUE(10, 3944), new TOKENVALUE(10, 3946), new TOKENVALUE(10, 3948), + new TOKENVALUE(10, 3950), new TOKENVALUE(10, 3952), new TOKENVALUE(10, 3954), new TOKENVALUE(10, 3956), new TOKENVALUE(10, 3958), + new TOKENVALUE(10, 3960) + + }; + + /// + /// Get the cost for a DCT coefficient value. + /// Accepts values in range [-DCT_MAX_VALUE, DCT_MAX_VALUE-1]. + /// + public static short GetDctValueCost(int value) + { + return dct_value_cost[value + DCT_MAX_VALUE]; + } + + /// + /// Get the TOKENVALUE for a DCT coefficient value. + /// Accepts values in range [-DCT_MAX_VALUE, DCT_MAX_VALUE-1]. + /// + public static TOKENVALUE GetDctValueToken(int value) + { + return dct_value_tokens[value + DCT_MAX_VALUE]; + } + + /// + /// Get a fixed pointer to the dct_value_cost array, offset to allow negative indexing. + /// IMPORTANT: This must be called within an unsafe context and the pointer must not + /// outlive the fixed statement that creates it. + /// + /// Output pointer to the middle of the cost array + /// + /// fixed (short* ptr = GetDctValueCostPtr()) + /// { + /// short cost = ptr[-100]; // Get cost for value -100 + /// } + /// + public static unsafe short[] GetDctValueCostArray() + { + return dct_value_cost; + } + + /// + /// Get a fixed pointer to the dct_value_tokens array, offset to allow negative indexing. + /// IMPORTANT: This must be called within an unsafe context and the pointer must not + /// outlive the fixed statement that creates it. + /// + public static unsafe TOKENVALUE[] GetDctValueTokensArray() + { + return dct_value_tokens; + } + } +} diff --git a/src/treewriter.cs b/src/treewriter.cs new file mode 100644 index 0000000..2c5ff37 --- /dev/null +++ b/src/treewriter.cs @@ -0,0 +1,284 @@ +//----------------------------------------------------------------------------- +// Filename: treewriter.cs +// +// Description: Port of: +// - treewriter.h +// - treewriter.c +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 17 Feb 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +using System; + +using vp8_prob = System.Byte; +using vp8_writer = Vpx.Net.BOOL_CODER; +using vp8_tree_index = System.SByte; +using vp8_tree = System.SByte; + +namespace Vpx.Net +{ + /// + /// Trees map alphabets into huffman-like codes suitable for an arithmetic + /// bit coder. Timothy S Murphy 11 October 2004 + /// + /// + /// This is the encoder equivalent of treereader.cs + /// + public struct vp8_token + { + public int value; + public int Len; + + public vp8_token(int value, int len) + { + this.value = value; + this.Len = len; + } + } + + public static class treewriter + { + public const byte vp8_prob_half = 128; + + public static byte vp8_complement(byte x) => (byte)(255 - x); + + // Approximate length of an encoded bool in 256ths of a bit at given prob + public static uint vp8_cost_zero(byte prob) => boolhuff.vp8_prob_cost[prob]; + public static uint vp8_cost_one(byte prob) => vp8_cost_zero(vp8_complement(prob)); + public static uint vp8_cost_bit(byte prob, int bit) => vp8_cost_zero(bit != 0 ? vp8_complement(prob) : prob); + + /// + /// Calculate the cost of a branch given counts. + /// + public static uint vp8_cost_branch(uint[] ct, vp8_prob p) + { + return (uint)(((((ulong)ct[0]) * vp8_cost_zero(p)) + + (((ulong)ct[1]) * vp8_cost_one(p))) >> 8); + } + + /// + /// Write a value to the bitstream using a tree. + /// + public static void vp8_treed_write(ref vp8_writer w, vp8_tree[] t, + vp8_prob[] p, int v, int n) + { + vp8_tree_index i = 0; + + do + { + int b = (v >> --n) & 1; + boolhuff.vp8_encode_bool(ref w, b, p[i >> 1]); + i = t[i + b]; + } while (n > 0); + } + + public unsafe static void vp8_treed_write(ref vp8_writer w, vp8_tree[] t, + vp8_prob* p, int v, int n) + { + vp8_tree_index i = 0; + + do + { + int b = (v >> --n) & 1; + boolhuff.vp8_encode_bool(ref w, b, p[i >> 1]); + i = t[i + b]; + } while (n > 0); + } + + /// + /// Write a token using tree. + /// + public static void vp8_write_token(ref vp8_writer w, vp8_tree[] t, + vp8_prob[] p, vp8_token x) + { + vp8_treed_write(ref w, t, p, x.value, x.Len); + } + + public unsafe static void vp8_write_token(ref vp8_writer w, vp8_tree[] t, + vp8_prob* p, vp8_token x) + { + vp8_treed_write(ref w, t, p, x.value, x.Len); + } + + /// + /// Calculate the cost of encoding a value using a tree. + /// + public static int vp8_treed_cost(vp8_tree[] t, vp8_prob[] p, int v, int n) + { + int c = 0; + vp8_tree_index i = 0; + + do + { + int b = (v >> --n) & 1; + c += (int)vp8_cost_bit(p[i >> 1], b); + i = t[i + b]; + } while (n > 0); + + return c; + } + + public unsafe static int vp8_treed_cost(vp8_tree[] t, vp8_prob* p, int v, int n) + { + int c = 0; + vp8_tree_index i = 0; + + do + { + int b = (v >> --n) & 1; + c += (int)vp8_cost_bit(p[i >> 1], b); + i = t[i + b]; + } while (n > 0); + + return c; + } + + /// + /// Calculate the cost of encoding a token. + /// + public static int vp8_cost_token(vp8_tree[] t, vp8_prob[] p, vp8_token x) + { + return vp8_treed_cost(t, p, x.value, x.Len); + } + + public unsafe static int vp8_cost_token(vp8_tree[] t, vp8_prob* p, vp8_token x) + { + return vp8_treed_cost(t, p, x.value, x.Len); + } + + /// + /// Recursively calculate costs for all possible token values. + /// + private unsafe static void cost(int* C, vp8_tree[] T, vp8_prob* P, int i, int c) + { + vp8_prob p = P[i >> 1]; + + do + { + vp8_tree_index j = T[i]; + int d = c + (int)vp8_cost_bit(p, i & 1); + + if (j <= 0) + { + C[-j] = d; + } + else + { + cost(C, T, P, j, d); + } + } while ((++i & 1) != 0); + } + + /// + /// Fill array of costs for all possible token values. + /// + public unsafe static void vp8_cost_tokens(int[] c, vp8_prob[] p, vp8_tree[] t) + { + fixed (int* pC = c) + fixed (vp8_prob* pP = p) + { + cost(pC, t, pP, 0, 0); + } + } + + public unsafe static void vp8_cost_tokens(int* c, vp8_prob* p, vp8_tree[] t) + { + cost(c, t, p, 0, 0); + } + + /// + /// Fill array of costs for all possible token values starting at a specific node. + /// + public unsafe static void vp8_cost_tokens2(int[] c, vp8_prob[] p, vp8_tree[] t, int start) + { + fixed (int* pC = c) + fixed (vp8_prob* pP = p) + { + cost(pC, t, pP, start, 0); + } + } + + public unsafe static void vp8_cost_tokens2(int* c, vp8_prob* p, vp8_tree[] t, int start) + { + cost(c, t, p, start, 0); + } + + // Convenience macros/methods for writing + public static void vp8_write(ref vp8_writer w, int bit, byte probability) + => boolhuff.vp8_encode_bool(ref w, bit, probability); + + public static void vp8_write_literal(ref vp8_writer w, int data, int bits) + => boolhuff.vp8_encode_value(ref w, data, bits); + + public static void vp8_write_bit(ref vp8_writer w, int bit) + => vp8_write(ref w, bit, vp8_prob_half); + + private unsafe static void branch_counts(int n, vp8_token[] tok, vp8_tree[] tree, + uint[,] branch_ct, uint[] num_events) + { + int t = 0; + do + { + int L = tok[t].Len; + int x = tok[t].value; + uint ct = num_events[t]; + + vp8_tree_index i = 0; + + do + { + int b = (x >> --L) & 1; + branch_ct[i >> 1, b] += ct; + i = tree[i + b]; + } while (i > 0); + + } while (++t < n); + } + + public unsafe static void vp8_tree_probs_from_distribution(int n, vp8_token[] tok, + vp8_tree[] tree, vp8_prob[] probs, + uint[,] branch_ct, uint[] num_events, + uint Pfactor, int Round) + { + int tree_len = n - 1; + int t = 0; + + branch_counts(n, tok, tree, branch_ct, num_events); + + do + { + uint c0 = branch_ct[t, 0]; + uint c1 = branch_ct[t, 1]; + ulong tot = c0 + c1; + + if (tot != 0) + { + ulong p = ((ulong)c0 * Pfactor) + (Round != 0 ? tot >> 1 : 0); + p = p / tot; + probs[t] = (vp8_prob)(p < 256 ? (p != 0 ? p : 1) : 255); + } + else + { + probs[t] = vp8_prob_half; + } + } while (++t < tree_len); + } + } +} diff --git a/src/vp8_quantize.cs b/src/vp8_quantize.cs new file mode 100644 index 0000000..8aeb960 --- /dev/null +++ b/src/vp8_quantize.cs @@ -0,0 +1,128 @@ +//----------------------------------------------------------------------------- +// Filename: vp8_quantize.cs +// +// Description: Port of: +// - vp8/encoder/quantize.h +// - vp8/encoder/vp8_quantize.c +// +// Author(s): +// Aaron Clauson (aaron@sipsorcery.com) +// +// History: +// 17 Feb 2025 Aaron Clauson Created, Dublin, Ireland. +// +// License: +// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file. +//----------------------------------------------------------------------------- + +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +namespace Vpx.Net +{ + /// + /// Forward quantization for VP8 encoder. + /// NOTE: This is a skeleton implementation. Full encoder support requires + /// complete porting of VP8_COMP, MACROBLOCK structures and related encoder infrastructure. + /// + public unsafe static class vp8_quantize + { + private static readonly int[] qrounding_factors = new int[129] + { + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 + }; + + private static readonly int[] qzbin_factors = new int[129] + { + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 + }; + + private static readonly int[] qrounding_factors_y2 = new int[129] + { + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 + }; + + private static readonly int[] qzbin_factors_y2 = new int[129] + { + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 + }; + + /// + /// Fast quantization of a 4x4 block. + /// + public static void vp8_fast_quantize_b_c(ref BLOCK b, ref BLOCKD d) + { + int i, rc, eob; + int x, y, z, sz; + short* coeff_ptr = b.coeff; + short* round_ptr = b.round; + short* quant_ptr = b.quant_fast; + + // For ArrPtr access we need to work around the managed wrapper + // This is a simplified implementation for compilation + eob = -1; + for (i = 0; i < 16; ++i) + { + rc = entropy.vp8_default_zig_zag1d[i]; + z = coeff_ptr[rc]; + + sz = z >> 31; + x = (z ^ sz) - sz; + + y = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; + x = (y ^ sz) - sz; + + // Set quantized coefficients + // Note: Full implementation requires proper ArrPtr access + if (y != 0) + { + eob = i; + } + } + // *d.eob = (sbyte)(eob + 1); + } + + /// + /// Regular quantization of a 4x4 block with deadzone. + /// + public static void vp8_regular_quantize_b_c(ref BLOCK b, ref BLOCKD d) + { + // Skeleton implementation + // Full implementation requires proper handling of ArrPtr and complete structures + } + + // Additional quantization helper methods would go here + // Full implementation requires complete VP8_COMP and MACROBLOCK structures + } +} diff --git a/src/vpx_encoder.cs b/src/vpx_encoder.cs index e08a661..da5b4dc 100644 --- a/src/vpx_encoder.cs +++ b/src/vpx_encoder.cs @@ -556,7 +556,15 @@ public class vpx_codec_enc_cfg_t public int temporal_layering_mode; } - public class vpx_encoder + public enum vp8e_tuning { + VP8_TUNE_PSNR, + VP8_TUNE_SSIM + } + + public static class vpx_encoder + { + public const int VPX_TS_MAX_PERIODICITY = 16; + public const int VPX_TS_MAX_LAYERS = 5; } }