From 91246808cf7975b1ffee04e20b768964d5fce00b Mon Sep 17 00:00:00 2001 From: godotg Date: Tue, 26 Sep 2023 23:53:16 +0800 Subject: [PATCH] feat[ts]: compatible typescript inside class --- .../test/typescript/zfoo/ProtocolManager.ts | 6 +- .../test/typescript/zfoo/buffer/ByteBuffer.ts | 136 +- .../src/test/typescript/zfoo/buffer/Long.ts | 1064 ++ .../zfoo/buffer/{longbits.js => Longbits.ts} | 134 +- .../src/test/typescript/zfoo/buffer/long.js | 1325 -- .../typescript/zfoo/packet/ComplexObject.ts | 357 +- .../typescript/zfoo/packet/EmptyObject.ts | 36 + .../typescript/zfoo/packet/NormalObject.ts | 37 +- .../test/typescript/zfoo/packet/ObjectA.ts | 21 +- .../test/typescript/zfoo/packet/ObjectB.ts | 19 +- .../typescript/zfoo/packet/SimpleObject.ts | 19 +- .../typescript/zfoo/packet/VeryBigObject.ts | 13411 ++++++++++++++++ 12 files changed, 14867 insertions(+), 1698 deletions(-) create mode 100644 protocol/src/test/typescript/zfoo/buffer/Long.ts rename protocol/src/test/typescript/zfoo/buffer/{longbits.js => Longbits.ts} (61%) delete mode 100644 protocol/src/test/typescript/zfoo/buffer/long.js create mode 100644 protocol/src/test/typescript/zfoo/packet/EmptyObject.ts create mode 100644 protocol/src/test/typescript/zfoo/packet/VeryBigObject.ts diff --git a/protocol/src/test/typescript/zfoo/ProtocolManager.ts b/protocol/src/test/typescript/zfoo/ProtocolManager.ts index 83045848..c2456ca0 100644 --- a/protocol/src/test/typescript/zfoo/ProtocolManager.ts +++ b/protocol/src/test/typescript/zfoo/ProtocolManager.ts @@ -1,3 +1,5 @@ +import EmptyObject from './packet/EmptyObject'; +import VeryBigObject from './packet/VeryBigObject'; import ComplexObject from './packet/ComplexObject'; import NormalObject from './packet/NormalObject'; import ObjectA from './packet/ObjectA'; @@ -7,6 +9,8 @@ import SimpleObject from './packet/SimpleObject'; const protocols = new Map(); // initProtocol +protocols.set(0, EmptyObject); +protocols.set(1, VeryBigObject); protocols.set(100, ComplexObject); protocols.set(101, NormalObject); protocols.set(102, ObjectA); @@ -17,7 +21,7 @@ class ProtocolManager { static getProtocol(protocolId: number): any { const protocol = protocols.get(protocolId); if (protocol === null) { - throw new Error('[protocolId:' + protocolId + ']协议不存在'); + throw '[protocolId:' + protocolId + ']协议不存在'; } return protocol; } diff --git a/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts b/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts index 77946a5a..dde42cd0 100644 --- a/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts +++ b/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts @@ -1,6 +1,6 @@ import ProtocolManager from "../ProtocolManager"; -const Longbits = require('./longbits.js'); +import {writeInt64, readInt64} from "./Longbits"; const empty_str = ''; const initSize = 128; @@ -13,13 +13,13 @@ const maxInt = 2147483647; const minInt = -2147483648; // UTF-8编码与解码 -const encoder = new TextEncoder('utf-8'); -const decoder = new TextDecoder('utf-8'); +// const encoder = new TextEncoder(); +// const decoder = new TextDecoder(); // nodejs的测试环境需要用以下方式特殊处理 -// const util = require('util'); -// const encoder = new util.TextEncoder('utf-8'); -// const decoder = new util.TextDecoder('utf-8'); +const util = require('util'); +const encoder = new util.TextEncoder('utf-8'); +const decoder = new util.TextDecoder('utf-8'); // 在js中long可以支持的最大值 // const maxLong = 9007199254740992; @@ -57,6 +57,24 @@ class ByteBuffer { this.bufferView = new DataView(this.buffer, 0, this.buffer.byteLength); } + adjustPadding(predictionLength: number, beforeWriteIndex: number): void { + const currentWriteIndex = this.writeOffset; + const predictionCount = this.writeIntCount(predictionLength); + const length = currentWriteIndex - beforeWriteIndex - predictionCount; + const lengthCount = this.writeIntCount(length); + const padding = lengthCount - predictionCount; + if (padding == 0) { + this.setWriteOffset(beforeWriteIndex); + this.writeInt(length); + this.setWriteOffset(currentWriteIndex); + } else { + const retainedByteBuf = this.buffer.slice(currentWriteIndex - length, currentWriteIndex); + this.setWriteOffset(beforeWriteIndex); + this.writeInt(length); + this.writeBytes(retainedByteBuf); + } + } + setWriteOffset(writeOffset: number): void { if (writeOffset > this.buffer.byteLength) { throw new Error('index out of bounds exception:readerIndex:' + this.readOffset + @@ -66,6 +84,10 @@ class ByteBuffer { this.writeOffset = writeOffset; } + getWriteOffset(): number { + return this.writeOffset; + } + setReadOffset(readOffset: number): void { if (readOffset > this.writeOffset) { throw new Error('index out of bounds exception:readerIndex:' + this.readOffset + @@ -75,6 +97,10 @@ class ByteBuffer { this.readOffset = readOffset; } + getReadOffset(): number { + return this.readOffset; + } + getCapacity(): number { return this.buffer.byteLength - this.writeOffset; } @@ -209,6 +235,25 @@ class ByteBuffer { this.writeByte(value >>> 28); } + writeIntCount(value: number): number { + if (!(minInt <= value && value <= maxInt)) { + throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); + } + if (value >>> 7 === 0) { + return 1; + } + if (value >>> 14 === 0) { + return 2; + } + if (value >>> 21 === 0) { + return 3; + } + if (value >>> 28 === 0) { + return 4; + } + return 5; + } + readInt(): number { let b = this.readByte(); let value = b & 0x7F; @@ -238,7 +283,7 @@ class ByteBuffer { } this.ensureCapacity(9); - Longbits.writeInt64(this, value); + writeInt64(this, value); } readLong(): number { @@ -280,7 +325,7 @@ class ByteBuffer { } } } - return Longbits.readInt64(new Uint8Array(buffer.slice(0, count))).toString(); + return readInt64(new Uint8Array(buffer.slice(0, count))).toNumber(); } writeFloat(value: number): void { @@ -313,18 +358,6 @@ class ByteBuffer { return value; } - writeChar(value: string): void { - if (value === null || value === undefined || value.length === 0) { - this.writeString(empty_str); - return; - } - this.writeString(value.charAt(0)); - } - - readChar(): string { - return this.readString(); - } - writeString(value: string): void { if (value === null || value === undefined || value.trim().length === 0) { this.writeInt(0); @@ -378,7 +411,7 @@ class ByteBuffer { }; readBooleanArray(): any { - const array = []; + const array: boolean[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -400,7 +433,7 @@ class ByteBuffer { }; readByteArray(): any { - const array = []; + const array: number[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -422,7 +455,7 @@ class ByteBuffer { }; readShortArray(): any { - const array = []; + const array: number[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -444,7 +477,7 @@ class ByteBuffer { }; readIntArray(): any { - const array = []; + const array: number[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -466,7 +499,7 @@ class ByteBuffer { }; readLongArray(): any { - const array = []; + const array: number[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -488,7 +521,7 @@ class ByteBuffer { }; readFloatArray(): any { - const array = []; + const array: number[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -510,7 +543,7 @@ class ByteBuffer { }; readDoubleArray(): any { - const array = []; + const array: number[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -532,7 +565,7 @@ class ByteBuffer { }; readStringArray(): any { - const array = []; + const array: string[] = []; const length = this.readInt(); if (length > 0) { for (let index = 0; index < length; index++) { @@ -542,28 +575,6 @@ class ByteBuffer { return array; }; - writeCharArray(array: Array | null) { - if (array === null) { - this.writeInt(0); - } else { - this.writeInt(array.length); - array.forEach(element => { - this.writeChar(element); - }); - } - }; - - readCharArray(): any { - const array = []; - const length = this.readInt(); - if (length > 0) { - for (let index = 0; index < length; index++) { - array.push(this.readChar()); - } - } - return array; - }; - writePacketArray(array: Array | null, protocolId: number) { if (array === null) { this.writeInt(0); @@ -577,7 +588,7 @@ class ByteBuffer { }; readPacketArray(protocolId: number): any { - const array = []; + const array: any[] = []; const length = this.readInt(); if (length > 0) { const protocolRegistration = ProtocolManager.getProtocol(protocolId); @@ -653,14 +664,6 @@ class ByteBuffer { return this.readStringArray(); }; - writeCharList(list: any) { - this.writeCharArray(list); - }; - - readCharList(): any { - return this.readCharArray(); - }; - writePacketList(list: any, protocolId: number) { this.writePacketArray(list, protocolId); }; @@ -790,21 +793,6 @@ class ByteBuffer { return new Set(this.readStringArray()); }; - writeCharSet(set: Set | null) { - if (set === null) { - this.writeInt(0); - } else { - this.writeInt(set.size); - set.forEach(element => { - this.writeChar(element); - }); - } - }; - - readCharSet(): any { - return new Set(this.readCharArray()); - }; - writePacketSet(set: Set | null, protocolId: number) { if (set === null) { this.writeInt(0); diff --git a/protocol/src/test/typescript/zfoo/buffer/Long.ts b/protocol/src/test/typescript/zfoo/buffer/Long.ts new file mode 100644 index 00000000..dac9a00b --- /dev/null +++ b/protocol/src/test/typescript/zfoo/buffer/Long.ts @@ -0,0 +1,1064 @@ +const INT_CACHE: Record = {}; +const UINT_CACHE: Record = {}; + +type WasmExports = { + mul: (low: number, high: number, mLow: number, mHigh: number) => number; + div_s: (low: number, high: number, dLow: number, dHigh: number) => number; + div_u: (low: number, high: number, dLow: number, dHigh: number) => number; + rem_s: (low: number, high: number, dLow: number, dHigh: number) => number; + rem_u: (low: number, high: number, dLow: number, dHigh: number) => number; + get_high: () => number; +}; + +let wasm: WasmExports; + +try { + wasm = new WebAssembly.Instance( + new WebAssembly.Module( + new Uint8Array([ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, + 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, + 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, + 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, + 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, + 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, + 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, + 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, + 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, + 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, + 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, + 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, + 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, + 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, + 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, + 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, + 11, + ]) + ), + {} + ).exports as WasmExports; +} catch { + // no wasm support +} + +export class Long { + /** + * Signed zero. + */ + static readonly ZERO = Long.fromInt(0); + + /** + * Unsigned zero. + */ + static readonly UZERO = Long.fromInt(0, true); + + /** + * Signed one. + */ + static readonly ONE = Long.fromInt(1); + + /** + * Unsigned one. + */ + static readonly UONE = Long.fromInt(1, true); + + /** + * Signed negative one. + */ + static readonly NEG_ONE = Long.fromInt(-1); + + /** + * Maximum signed value. + */ + static readonly MAX_VALUE = Long.fromBits( + 0xffffffff | 0, + 0x7fffffff | 0, + false + ); + + /** + * Maximum unsigned value. + */ + static readonly MAX_UNSIGNED_VALUE = Long.fromBits( + 0xffffffff | 0, + 0xffffffff | 0, + true + ); + + /** + * Minimum signed value. + */ + static readonly MIN_VALUE = Long.fromBits(0, 0x80000000 | 0, false); + + /** + * The low 32 bits as a signed value. + */ + low: number; + + /** + * The high 32 bits as a signed value. + */ + high: number; + + /** + * Whether unsigned or not. + */ + unsigned: boolean; + + /** + * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers. See the from* functions below for more convenient ways of constructing Longs. + */ + constructor(low: number, high: number, unsigned = false) { + this.low = low | 0; + this.high = high | 0; + this.unsigned = unsigned; + } + + /** + * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. + */ + toInt() { + return this.unsigned ? this.low >>> 0 : this.low; + } + + /** + * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). + */ + toNumber() { + if (this.unsigned) { + return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0); + } + return this.high * TWO_PWR_32_DBL + (this.low >>> 0); + } + + /** + * Converts the Long to a string written in the specified radix. + */ + toString(radix = 10): string { + if (radix < 2 || 36 < radix) { + throw RangeError("radix"); + } + if (this.isZero()) { + return "0"; + } + if (this.isNegative()) { + // Unsigned Longs are never negative + if (this.equals(Long.MIN_VALUE)) { + // We need to change the Long value before it can be negated, so we remove + // the bottom-most digit in this base and then recurse to do the rest. + const radixLong = Long.fromNumber(radix); + const div = this.divide(radixLong); + const rem1 = div.multiply(radixLong).subtract(this); + return div.toString(radix) + rem1.toInt().toString(radix); + } else { + return "-" + this.negate().toString(radix); + } + } + + // Do several (6) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + const radixToPower = Long.fromNumber(Math.pow(radix, 6), this.unsigned); + let result = ""; + let rem = this as Long; + while (true) { + const remDiv = rem.divide(radixToPower); + const intval = rem.subtract(remDiv.multiply(radixToPower)).toInt() >>> 0; + let digits = intval.toString(radix); + rem = remDiv; + if (rem.isZero()) { + return digits + result; + } else { + while (digits.length < 6) { + digits = "0" + digits; + } + result = "" + digits + result; + } + } + } + + /** + * Gets the high 32 bits as a signed integer. + */ + getHighBits() { + return this.high; + } + + /** + * Gets the high 32 bits as an unsigned integer. + */ + getHighBitsUnsigned() { + return this.high >>> 0; + } + + /** + * Gets the low 32 bits as a signed integer. + */ + getLowBits() { + return this.low; + } + + /** + * Gets the low 32 bits as an unsigned integer. + */ + getLowBitsUnsigned() { + return this.low >>> 0; + } + + /** + * Gets the number of bits needed to represent the absolute value of this Long. + */ + getNumBitsAbs(): number { + if (this.isNegative()) { + // Unsigned Longs are never negative + return this.equals(Long.MIN_VALUE) ? 64 : this.negate().getNumBitsAbs(); + } + const val = this.high != 0 ? this.high : this.low; + let bit; + for (bit = 31; bit > 0; bit--) { + if ((val & (1 << bit)) != 0) { + break; + } + } + return this.high != 0 ? bit + 33 : bit + 1; + } + + /** + * Tests if this Long's value equals zero. + */ + isZero() { + return this.high === 0 && this.low === 0; + } + + /** + * Tests if this Long's value is negative. + */ + isNegative() { + return !this.unsigned && this.high < 0; + } + + /** + * Tests if this Long's value is positive. + */ + isPositive() { + return this.unsigned || this.high >= 0; + } + + /** + * Tests if this Long's value is odd. + */ + isOdd() { + return (this.low & 1) === 1; + } + + /** + * Tests if this Long's value is even. + */ + isEven() { + return (this.low & 1) === 0; + } + + /** + * Tests if this Long's value equals the specified's. + */ + equals(other: Long | number | string) { + if (!(other instanceof Long)) { + other = Long.fromValue(other); + } + if ( + this.unsigned !== other.unsigned && + this.high >>> 31 === 1 && + other.high >>> 31 === 1 + ) { + return false; + } + return this.high === other.high && this.low === other.low; + } + + /** + * Tests if this Long's value differs from the specified's. + */ + notEquals(other: Long | number | string) { + return !this.equals(other); + } + + /** + * Tests if this Long's value is less than the specified's. + */ + lessThan(other: Long | number | string) { + return this.compare(other) < 0; + } + + /** + * Tests if this Long's value is less than or equal the specified's. + */ + lessThanOrEqual(other: Long | number | string) { + return this.compare(other) <= 0; + } + + /** + * Tests if this Long's value is greater than the specified's. + */ + greaterThan(other: Long | number | string) { + return this.compare(other) > 0; + } + + /** + * Tests if this Long's value is greater than or equal the specified's. + */ + greaterThanOrEqual(other: Long | number | string) { + return this.compare(other) >= 0; + } + + /** + * Compares this Long's value with the specified's. + */ + compare(other: Long | number | string) { + if (!(other instanceof Long)) { + other = Long.fromValue(other); + } + if (this.equals(other)) { + return 0; + } + const thisNeg = this.isNegative(); + const otherNeg = other.isNegative(); + if (thisNeg && !otherNeg) { + return -1; + } + if (!thisNeg && otherNeg) { + return 1; + } + // At this point the sign bits are the same + if (!this.unsigned) { + return this.subtract(other).isNegative() ? -1 : 1; + } + // Both are positive if at least one is unsigned + return other.high >>> 0 > this.high >>> 0 || + (other.high === this.high && other.low >>> 0 > this.low >>> 0) + ? -1 + : 1; + } + + /** + * Negates this Long's value. + */ + negate() { + if (!this.unsigned && this.equals(Long.MIN_VALUE)) { + return Long.MIN_VALUE; + } + return this.not().add(Long.ONE); + } + + /** + * Returns the sum of this and the specified Long. + */ + add(addend: Long | number | string) { + if (!(addend instanceof Long)) { + addend = Long.fromValue(addend); + } + + // Divide each number into 4 chunks of 16 bits, and then sum the chunks. + + const a48 = this.high >>> 16; + const a32 = this.high & 0xffff; + const a16 = this.low >>> 16; + const a00 = this.low & 0xffff; + + const b48 = addend.high >>> 16; + const b32 = addend.high & 0xffff; + const b16 = addend.low >>> 16; + const b00 = addend.low & 0xffff; + + let c48 = 0; + let c32 = 0; + let c16 = 0; + let c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 0xffff; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 0xffff; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 0xffff; + c48 += a48 + b48; + c48 &= 0xffff; + return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); + } + + /** + * Returns the difference of this and the specified Long. + */ + subtract(subtrahend: Long | number | string) { + if (!(subtrahend instanceof Long)) { + subtrahend = Long.fromValue(subtrahend); + } + return this.add(subtrahend.negate()); + } + + /** + * Returns the product of this and the specified Long. + */ + multiply(multiplier: Long | number | string): Long { + if (this.isZero()) { + return Long.ZERO; + } + if (!(multiplier instanceof Long)) { + multiplier = Long.fromValue(multiplier); + } + + if (wasm) { + const low = wasm.mul( + this.low, + this.high, + multiplier.low, + multiplier.high + ); + return Long.fromBits(low, wasm.get_high(), this.unsigned); + } + + if (multiplier.isZero()) { + return Long.ZERO; + } + if (this.equals(Long.MIN_VALUE)) { + return multiplier.isOdd() ? Long.MIN_VALUE : Long.ZERO; + } + if (multiplier.equals(Long.MIN_VALUE)) { + return this.isOdd() ? Long.MIN_VALUE : Long.ZERO; + } + + if (this.isNegative()) { + if (multiplier.isNegative()) { + return this.negate().multiply(multiplier.negate()); + } else { + return this.negate().multiply(multiplier).negate(); + } + } else if (multiplier.isNegative()) { + return this.multiply(multiplier.negate()).negate(); + } + + // If both longs are small, use float multiplication + if (this.lessThan(TWO_PWR_24) && multiplier.lessThan(TWO_PWR_24)) { + return Long.fromNumber( + this.toNumber() * multiplier.toNumber(), + this.unsigned + ); + } + + // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. + // We can skip products that would overflow. + + const a48 = this.high >>> 16; + const a32 = this.high & 0xffff; + const a16 = this.low >>> 16; + const a00 = this.low & 0xffff; + + const b48 = multiplier.high >>> 16; + const b32 = multiplier.high & 0xffff; + const b16 = multiplier.low >>> 16; + const b00 = multiplier.low & 0xffff; + + let c48 = 0; + let c32 = 0; + let c16 = 0; + let c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 0xffff; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 0xffff; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 0xffff; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 0xffff; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 0xffff; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 0xffff; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 0xffff; + return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); + } + + /** + * Returns this Long divided by the specified. The result is signed if this Long is signed or unsigned if this Long is unsigned. + */ + divide(divisor: Long | number | string): Long { + if (!(divisor instanceof Long)) { + divisor = Long.fromValue(divisor); + } + if (divisor.isZero()) { + throw Error("division by zero"); + } + + if (wasm) { + // guard against signed division overflow: the largest + // negative number / -1 would be 1 larger than the largest + // positive number, due to two's complement. + if ( + !this.unsigned && + this.high === -0x80000000 && + divisor.low === -1 && + divisor.high === -1 + ) { + // be consistent with non-wasm code path + return this; + } + const low = (this.unsigned ? wasm.div_u : wasm.div_s)( + this.low, + this.high, + divisor.low, + divisor.high + ); + return Long.fromBits(low, wasm.get_high(), this.unsigned); + } + + if (this.isZero()) { + return this.unsigned ? Long.UZERO : Long.ZERO; + } + let approx; + let rem; + let res; + if (!this.unsigned) { + // This section is only relevant for signed longs and is derived from the + // closure library as a whole. + if (this.equals(Long.MIN_VALUE)) { + if (divisor.equals(Long.ONE) || divisor.equals(Long.NEG_ONE)) { + return Long.MIN_VALUE; + } + // recall that -MIN_VALUE == MIN_VALUE + else if (divisor.equals(Long.MIN_VALUE)) { + return Long.ONE; + } else { + // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. + const halfThis = this.shiftRight(1); + approx = halfThis.divide(divisor).shiftLeft(1); + if (approx.equals(Long.ZERO)) { + return divisor.isNegative() ? Long.ONE : Long.NEG_ONE; + } else { + rem = this.subtract(divisor.multiply(approx)); + res = approx.add(rem.divide(divisor)); + return res; + } + } + } else if (divisor.equals(Long.MIN_VALUE)) { + return this.unsigned ? Long.UZERO : Long.ZERO; + } + if (this.isNegative()) { + if (divisor.isNegative()) { + return this.negate().divide(divisor.negate()); + } + return this.negate().divide(divisor).negate(); + } else if (divisor.isNegative()) { + return this.divide(divisor.negate()).negate(); + } + res = Long.ZERO; + } else { + // The algorithm below has not been made for unsigned longs. It's therefore + // required to take special care of the MSB prior to running it. + if (!divisor.unsigned) { + divisor = divisor.toUnsigned(); + } + if (divisor.greaterThan(this)) { + return Long.UZERO; + } + if (divisor.greaterThan(this.shiftRightUnsigned(1))) { + // 15 >>> 1 = 7 ; with divisor = 8 ; true + return Long.UONE; + } + res = Long.UZERO; + } + + // Repeat the following until the remainder is less than other: find a + // floating-point that approximates remainder / other *from below*, add this + // into the result, and subtract it from the remainder. It is critical that + // the approximate value is less than or equal to the real value so that the + // remainder never becomes negative. + rem = this; + while (rem.greaterThanOrEqual(divisor)) { + // Approximate the result of division. This may be a little greater or + // smaller than the actual value. + approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); + + // We will tweak the approximate result by changing it in the 48-th digit or + // the smallest non-fractional digit, whichever is larger. + const log2 = Math.ceil(Math.log(approx) / Math.LN2); + const delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48); + // Decrease the approximation until it is smaller than the remainder. Note + // that if it is too large, the product overflows and is negative. + let approxRes = Long.fromNumber(approx); + let approxRem = approxRes.multiply(divisor); + while (approxRem.isNegative() || approxRem.greaterThan(rem)) { + approx -= delta; + approxRes = Long.fromNumber(approx, this.unsigned); + approxRem = approxRes.multiply(divisor); + } + + // We know the answer can't be zero... and actually, zero would cause + // infinite recursion since we would make no progress. + if (approxRes.isZero()) { + approxRes = Long.ONE; + } + + res = res.add(approxRes); + rem = rem.subtract(approxRem); + } + return res; + } + + /** + * Returns this Long modulo the specified. + */ + modulo(divisor: Long | number | string) { + if (!(divisor instanceof Long)) { + divisor = Long.fromValue(divisor); + } + + if (wasm) { + const low = (this.unsigned ? wasm.rem_u : wasm.rem_s)( + this.low, + this.high, + divisor.low, + divisor.high + ); + return Long.fromBits(low, wasm.get_high(), this.unsigned); + } + + return this.subtract(this.divide(divisor).multiply(divisor)); + } + + /** + * Returns the bitwise NOT of this Long. + */ + not() { + return Long.fromBits(~this.low, ~this.high, this.unsigned); + } + + /** + * Returns the bitwise AND of this Long and the specified. + */ + and(other: Long | number | string) { + if (!(other instanceof Long)) { + other = Long.fromValue(other); + } + return Long.fromBits( + this.low & other.low, + this.high & other.high, + this.unsigned + ); + } + + /** + * Returns the bitwise OR of this Long and the specified. + */ + or(other: Long | number | string) { + if (!(other instanceof Long)) { + other = Long.fromValue(other); + } + return Long.fromBits( + this.low | other.low, + this.high | other.high, + this.unsigned + ); + } + + /** + * Returns the bitwise XOR of this Long and the given one. + */ + xor(other: Long | number | string) { + if (!(other instanceof Long)) { + other = Long.fromValue(other); + } + return Long.fromBits( + this.low ^ other.low, + this.high ^ other.high, + this.unsigned + ); + } + + /** + * Returns this Long with bits shifted to the left by the given amount. + */ + shiftLeft(numBits: number | Long) { + if (numBits instanceof Long) { + numBits = numBits.toInt(); + } + if ((numBits &= 63) === 0) { + return this; + } else if (numBits < 32) { + const lowNum: number = this.low << numBits; + return Long.fromBits(lowNum, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned); + } else { + return Long.fromBits(0, this.low << (numBits - 32), this.unsigned); + } + } + + /** + * Returns this Long with bits arithmetically shifted to the right by the given amount. + */ + shiftRight(numBits: number | Long) { + if (numBits instanceof Long) { + numBits = numBits.toInt(); + } + if ((numBits &= 63) === 0) { + return this; + } else if (numBits < 32) { + return Long.fromBits( + (this.low >>> numBits) | (this.high << (32 - numBits)), + this.high >> numBits, + this.unsigned + ); + } else { + return Long.fromBits( + this.high >> (numBits - 32), + this.high >= 0 ? 0 : -1, + this.unsigned + ); + } + } + + /** + * Returns this Long with bits logically shifted to the right by the given amount. + */ + shiftRightUnsigned(numBits: number | Long) { + if (numBits instanceof Long) { + numBits = numBits.toInt(); + } + if ((numBits &= 63) === 0) { + return this; + } + if (numBits < 32) { + return Long.fromBits( + (this.low >>> numBits) | (this.high << (32 - numBits)), + this.high >>> numBits, + this.unsigned + ); + } + if (numBits === 32) { + return Long.fromBits(this.high, 0, this.unsigned); + } + return Long.fromBits(this.high >>> (numBits - 32), 0, this.unsigned); + } + + /** + * Returns this Long with bits rotated to the left by the given amount. + */ + rotateLeft(numBits: number | Long) { + let b; + if (numBits instanceof Long) { + numBits = numBits.toInt(); + } + if ((numBits &= 63) === 0) { + return this; + } + if (numBits === 32) { + return Long.fromBits(this.high, this.low, this.unsigned); + } + if (numBits < 32) { + b = 32 - numBits; + return Long.fromBits( + (this.low << numBits) | (this.high >>> b), + (this.high << numBits) | (this.low >>> b), + this.unsigned + ); + } + numBits -= 32; + b = 32 - numBits; + return Long.fromBits( + (this.high << numBits) | (this.low >>> b), + (this.low << numBits) | (this.high >>> b), + this.unsigned + ); + } + + /** + * Returns this Long with bits rotated to the right by the given amount. + */ + rotateRight(numBits: number | Long) { + let b; + if (numBits instanceof Long) { + numBits = numBits.toInt(); + } + if ((numBits &= 63) === 0) { + return this; + } + if (numBits === 32) { + return Long.fromBits(this.high, this.low, this.unsigned); + } + if (numBits < 32) { + b = 32 - numBits; + return Long.fromBits( + (this.high << b) | (this.low >>> numBits), + (this.low << b) | (this.high >>> numBits), + this.unsigned + ); + } + numBits -= 32; + b = 32 - numBits; + return Long.fromBits( + (this.low << b) | (this.high >>> numBits), + (this.high << b) | (this.low >>> numBits), + this.unsigned + ); + } + + /** + * Converts this Long to signed. + */ + toSigned() { + if (!this.unsigned) { + return this; + } + return Long.fromBits(this.low, this.high, false); + } + + /** + * Converts this Long to unsigned. + */ + toUnsigned() { + if (this.unsigned) { + return this; + } + return Long.fromBits(this.low, this.high, true); + } + + /** + * Converts this Long to its byte representation. + */ + toBytes(le?: boolean) { + return le ? this.toBytesLE() : this.toBytesBE(); + } + + /** + * Converts this Long to its little endian byte representation. + */ + toBytesLE() { + const hi = this.high; + const lo = this.low; + return [ + lo & 0xff, + (lo >>> 8) & 0xff, + (lo >>> 16) & 0xff, + lo >>> 24, + hi & 0xff, + (hi >>> 8) & 0xff, + (hi >>> 16) & 0xff, + hi >>> 24, + ]; + } + + /** + * Converts this Long to its big endian byte representation. + */ + toBytesBE() { + const hi = this.high; + const lo = this.low; + return [ + hi >>> 24, + (hi >>> 16) & 0xff, + (hi >>> 8) & 0xff, + hi & 0xff, + lo >>> 24, + (lo >>> 16) & 0xff, + (lo >>> 8) & 0xff, + lo & 0xff, + ]; + } + + /** + * Creates a Long from its byte representation. + */ + static fromBytes(bytes: number[], unsigned?: boolean, le?: boolean) { + return le + ? Long.fromBytesLE(bytes, unsigned) + : Long.fromBytesBE(bytes, unsigned); + } + + /** + * Creates a Long from its little endian byte representation. + */ + static fromBytesLE(bytes: number[], unsigned?: boolean) { + return new Long( + bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24), + bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24), + unsigned + ); + } + + /** + * Creates a Long from its big endian byte representation. + */ + static fromBytesBE(bytes: number[], unsigned?: boolean) { + return new Long( + (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7], + (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3], + unsigned + ); + } + + /** + * Returns a Long representing the given 32 bit integer value. + */ + static fromInt(value: number, unsigned?: boolean) { + let cache; + if (unsigned) { + value >>>= 0; + if ((cache = 0 <= value && value < 256)) { + const cachedObj = UINT_CACHE[value]; + if (cachedObj) { + return cachedObj; + } + } + const obj = Long.fromBits(value, (value | 0) < 0 ? -1 : 0, true); + if (cache) { + UINT_CACHE[value] = obj; + } + return obj; + } else { + value |= 0; + if ((cache = -128 <= value && value < 128)) { + const cachedObj = INT_CACHE[value]; + if (cachedObj) { + return cachedObj; + } + } + const obj = Long.fromBits(value, value < 0 ? -1 : 0, false); + if (cache) { + INT_CACHE[value] = obj; + } + return obj; + } + } + + /** + * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned. + */ + static fromNumber(value: number, unsigned?: boolean): Long { + if (isNaN(value)) { + return unsigned ? Long.UZERO : Long.ZERO; + } + if (unsigned) { + if (value < 0) { + return Long.UZERO; + } + if (value >= TWO_PWR_64_DBL) { + return Long.MAX_UNSIGNED_VALUE; + } + } else { + if (value <= -TWO_PWR_63_DBL) { + return Long.MIN_VALUE; + } + if (value + 1 >= TWO_PWR_63_DBL) { + return Long.MAX_VALUE; + } + } + if (value < 0) { + return Long.fromNumber(-value, unsigned).negate(); + } + return Long.fromBits( + value % TWO_PWR_32_DBL | 0, + (value / TWO_PWR_32_DBL) | 0, + unsigned + ); + } + + /** + * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is assumed to use 32 bits. + */ + static fromBits(lowBits: number, highBits: number, unsigned?: boolean) { + return new Long(lowBits, highBits, unsigned); + } + + /** + * Returns a Long representation of the given string, written using the specified radix. + */ + static fromString( + str: string, + unsigned?: boolean | number, + radix?: number + ): Long { + if (str.length === 0) { + throw Error("empty string"); + } + if ( + str === "NaN" || + str === "Infinity" || + str === "+Infinity" || + str === "-Infinity" + ) { + return Long.ZERO; + } + if (typeof unsigned === "number") { + // For goog.math.long compatibility + (radix = unsigned), (unsigned = false); + } else { + unsigned = !!unsigned; + } + radix = radix || 10; + if (radix < 2 || 36 < radix) { + throw RangeError("radix"); + } + + let p; + if ((p = str.indexOf("-")) > 0) { + throw Error("interior hyphen"); + } else if (p === 0) { + return Long.fromString(str.substring(1), unsigned, radix).negate(); + } + + // Do several (8) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + const radixToPower = Long.fromNumber(Math.pow(radix, 8)); + + let result = Long.ZERO; + for (let i = 0; i < str.length; i += 8) { + const size = Math.min(8, str.length - i); + const value = parseInt(str.substring(i, i + size), radix); + if (size < 8) { + const power = Long.fromNumber(Math.pow(radix, size)); + result = result.multiply(power).add(Long.fromNumber(value)); + } else { + result = result.multiply(radixToPower); + result = result.add(Long.fromNumber(value)); + } + } + result.unsigned = unsigned; + return result; + } + + /** + * Converts the specified value to a Long using the appropriate from* function for its type. + */ + static fromValue( + val: + | Long + | number + | string + | { low: number; high: number; unsigned: boolean }, + unsigned?: boolean + ) { + if (typeof val === "number") { + return Long.fromNumber(val, unsigned); + } + if (typeof val === "string") { + return Long.fromString(val, unsigned); + } + return Long.fromBits( + val.low, + val.high, + typeof unsigned === "boolean" ? unsigned : val.unsigned + ); + } +} + +const TWO_PWR_16_DBL = 1 << 16; +const TWO_PWR_24_DBL = 1 << 24; +const TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; +const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; +const TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; +const TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL); diff --git a/protocol/src/test/typescript/zfoo/buffer/longbits.js b/protocol/src/test/typescript/zfoo/buffer/Longbits.ts similarity index 61% rename from protocol/src/test/typescript/zfoo/buffer/longbits.js rename to protocol/src/test/typescript/zfoo/buffer/Longbits.ts index 23f759ad..a538cace 100644 --- a/protocol/src/test/typescript/zfoo/buffer/longbits.js +++ b/protocol/src/test/typescript/zfoo/buffer/Longbits.ts @@ -1,7 +1,6 @@ -// from protobuf -const Long = require('./long.js') +// from https://github.com/hornta/long-ts +import {Long} from "./Long"; -module.exports = LongBits; /** * Constructs new long bits. @@ -11,101 +10,92 @@ module.exports = LongBits; * @param {number} lo Low 32 bits, unsigned * @param {number} hi High 32 bits, unsigned */ -function LongBits(lo, hi) { - // note that the casts below are theoretically unnecessary as of today, but older statically - // generated converter code might still call the ctor with signed 32bits. kept for compat. +class Longbits { + lo: number; + hi: number; - /** - * Low bits. - * @type {number} - */ + constructor(lo:number, hi:number) { this.lo = lo >>> 0; - - /** - * High bits. - * @type {number} - */ this.hi = hi >>> 0; -} + } -/** - * Zig-zag encodes this long bits. - * @returns {util.LongBits} `this` - */ -LongBits.prototype.zzEncode = function zzEncode() { + /** + * Zig-zag encodes this long bits. + */ + zzEncode(): Longbits { const mask = this.hi >> 31; this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0; this.lo = (this.lo << 1 ^ mask) >>> 0; return this; -}; + }; -/** - * Zig-zag decodes this long bits. - * @returns {util.LongBits} `this` - */ -LongBits.prototype.zzDecode = function zzDecode() { + /** + * Zig-zag decodes this long bits. + */ + zzDecode(): Longbits { const mask = -(this.lo & 1); this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0; this.hi = (this.hi >>> 1 ^ mask) >>> 0; return this; -}; + }; -/** - * Converts this long bits to a long. - * @param {boolean} [unsigned=false] Whether unsigned or not - * @returns {Long} Long - */ -LongBits.prototype.toLong = function toLong(unsigned) { + + /** + * Converts this long bits to a long. + */ + toLong(unsigned): Long { return new Long(this.lo | 0, this.hi | 0, Boolean(unsigned)); -}; + }; -/** - * Zero bits. - * @memberof util.LongBits - * @type {util.LongBits} - */ -const zero = LongBits.zero = new LongBits(0, 0); - -function from(value) { + /** + * Constructs new long bits from the specified number. + */ + static from(value: any) { if (typeof value === 'number') { - return fromNumber(value); + return Longbits.fromNumber(value as number); } if (typeof value === 'string' || value instanceof String) { - value = Long.fromString(value); + value = Long.fromString(value as string); } - return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero; -} + return value.low || value.high ? new Longbits(value.low >>> 0, value.high >>> 0) : zero; + } - -/** - * Constructs new long bits from the specified number. - * @param {number} value Value - * @returns {util.LongBits} Instance - */ -function fromNumber(value) { + /** + * Constructs new long bits from the specified number. + */ + static fromNumber(value: number): Longbits { if (value === 0) { - return zero; + return zero; } const sign = value < 0; if (sign) { - value = -value; + value = -value; } let lo = value >>> 0; let hi = (value - lo) / 4294967296 >>> 0; if (sign) { - hi = ~hi >>> 0; - lo = ~lo >>> 0; - if (++lo > 4294967295) { - lo = 0; - if (++hi > 4294967295) { - hi = 0; - } + hi = ~hi >>> 0; + lo = ~lo >>> 0; + if (++lo > 4294967295) { + lo = 0; + if (++hi > 4294967295) { + hi = 0; } + } } - return new LongBits(lo, hi); + return new Longbits(lo, hi); + } } -function writeVarint64(byteBuffer, value) { + + +/** + * Zero bits. + */ +const zero = new Longbits(0, 0); + + +function writeVarint64(byteBuffer: any, value: Longbits) { let count = 0; while (value.hi) { byteBuffer.writeByte(value.lo & 127 | 128); @@ -125,9 +115,9 @@ function writeVarint64(byteBuffer, value) { byteBuffer.writeByte(value.lo); } -function readLongVarint(buffer) { +function readLongVarint(buffer: any) { // tends to deopt with local vars for octet etc. - const bits = new LongBits(0, 0); + const bits = new Longbits(0, 0); let i = 0; const len = buffer.length; let pos = 0; @@ -175,15 +165,11 @@ function readLongVarint(buffer) { return bits; } -function writeInt64(byteBuffer, value) { - const bits = from(value).zzEncode(); +export function writeInt64(byteBuffer: any, value: any) { + const bits = Longbits.from(value).zzEncode(); writeVarint64(byteBuffer, bits); } -function readInt64(buffer) { +export function readInt64(buffer: any): Long { return readLongVarint(buffer).zzDecode().toLong(false); } - -LongBits.writeInt64 = writeInt64; - -LongBits.readInt64 = readInt64; diff --git a/protocol/src/test/typescript/zfoo/buffer/long.js b/protocol/src/test/typescript/zfoo/buffer/long.js deleted file mode 100644 index 31a8e6d7..00000000 --- a/protocol/src/test/typescript/zfoo/buffer/long.js +++ /dev/null @@ -1,1325 +0,0 @@ -/* eslint-disable */ -// from https://github.com/dcodeIO/long.js/blob/master/src/long.js -module.exports = Long; - -/** - * wasm optimizations, to do native i64 multiplication and divide - */ -var wasm = null; - -try { - wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([ - 0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11 - ])), {}).exports; -} catch (e) { - // no wasm support :( -} - -/** - * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers. - * See the from* functions below for more convenient ways of constructing Longs. - * @exports Long - * @class A Long class for representing a 64 bit two's-complement integer value. - * @param {number} low The low (signed) 32 bits of the long - * @param {number} high The high (signed) 32 bits of the long - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @constructor - */ -function Long(low, high, unsigned) { - - /** - * The low 32 bits as a signed value. - * @type {number} - */ - this.low = low | 0; - - /** - * The high 32 bits as a signed value. - * @type {number} - */ - this.high = high | 0; - - /** - * Whether unsigned or not. - * @type {boolean} - */ - this.unsigned = !!unsigned; -} - -// The internal representation of a long is the two given signed, 32-bit values. -// We use 32-bit pieces because these are the size of integers on which -// Javascript performs bit-operations. For operations like addition and -// multiplication, we split each number into 16 bit pieces, which can easily be -// multiplied within Javascript's floating-point representation without overflow -// or change in sign. -// -// In the algorithms below, we frequently reduce the negative case to the -// positive case by negating the input(s) and then post-processing the result. -// Note that we must ALWAYS check specially whether those values are MIN_VALUE -// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as -// a positive number, it overflows back into a negative). Not handling this -// case would often result in infinite recursion. -// -// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from* -// methods on which they depend. - -/** - * An indicator used to reliably determine if an object is a Long or not. - * @type {boolean} - * @const - * @private - */ -Long.prototype.__isLong__; - -Object.defineProperty(Long.prototype, "__isLong__", {value: true}); - -/** - * @function - * @param {*} obj Object - * @returns {boolean} - * @inner - */ -function isLong(obj) { - return (obj && obj["__isLong__"]) === true; -} - -/** - * Tests if the specified object is a Long. - * @function - * @param {*} obj Object - * @returns {boolean} - */ -Long.isLong = isLong; - -/** - * A cache of the Long representations of small integer values. - * @type {!Object} - * @inner - */ -var INT_CACHE = {}; - -/** - * A cache of the Long representations of small unsigned integer values. - * @type {!Object} - * @inner - */ -var UINT_CACHE = {}; - -/** - * @param {number} value - * @param {boolean=} unsigned - * @returns {!Long} - * @inner - */ -function fromInt(value, unsigned) { - var obj, cachedObj, cache; - if (unsigned) { - value >>>= 0; - if (cache = (0 <= value && value < 256)) { - cachedObj = UINT_CACHE[value]; - if (cachedObj) - return cachedObj; - } - obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true); - if (cache) - UINT_CACHE[value] = obj; - return obj; - } else { - value |= 0; - if (cache = (-128 <= value && value < 128)) { - cachedObj = INT_CACHE[value]; - if (cachedObj) - return cachedObj; - } - obj = fromBits(value, value < 0 ? -1 : 0, false); - if (cache) - INT_CACHE[value] = obj; - return obj; - } -} - -/** - * Returns a Long representing the given 32 bit integer value. - * @function - * @param {number} value The 32 bit integer in question - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @returns {!Long} The corresponding Long value - */ -Long.fromInt = fromInt; - -/** - * @param {number} value - * @param {boolean=} unsigned - * @returns {!Long} - * @inner - */ -function fromNumber(value, unsigned) { - if (isNaN(value)) - return unsigned ? UZERO : ZERO; - if (unsigned) { - if (value < 0) - return UZERO; - if (value >= TWO_PWR_64_DBL) - return MAX_UNSIGNED_VALUE; - } else { - if (value <= -TWO_PWR_63_DBL) - return MIN_VALUE; - if (value + 1 >= TWO_PWR_63_DBL) - return MAX_VALUE; - } - if (value < 0) - return fromNumber(-value, unsigned).neg(); - return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned); -} - -/** - * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned. - * @function - * @param {number} value The number in question - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @returns {!Long} The corresponding Long value - */ -Long.fromNumber = fromNumber; - -/** - * @param {number} lowBits - * @param {number} highBits - * @param {boolean=} unsigned - * @returns {!Long} - * @inner - */ -function fromBits(lowBits, highBits, unsigned) { - return new Long(lowBits, highBits, unsigned); -} - -/** - * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is - * assumed to use 32 bits. - * @function - * @param {number} lowBits The low 32 bits - * @param {number} highBits The high 32 bits - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @returns {!Long} The corresponding Long value - */ -Long.fromBits = fromBits; - -/** - * @function - * @param {number} base - * @param {number} exponent - * @returns {number} - * @inner - */ -var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4) - -/** - * @param {string} str - * @param {(boolean|number)=} unsigned - * @param {number=} radix - * @returns {!Long} - * @inner - */ -function fromString(str, unsigned, radix) { - if (str.length === 0) - throw Error('empty string'); - if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") - return ZERO; - if (typeof unsigned === 'number') { - // For goog.math.long compatibility - radix = unsigned, - unsigned = false; - } else { - unsigned = !!unsigned; - } - radix = radix || 10; - if (radix < 2 || 36 < radix) - throw RangeError('radix'); - - var p; - if ((p = str.indexOf('-')) > 0) - throw Error('interior hyphen'); - else if (p === 0) { - return fromString(str.substring(1), unsigned, radix).neg(); - } - - // Do several (8) digits each time through the loop, so as to - // minimize the calls to the very expensive emulated div. - var radixToPower = fromNumber(pow_dbl(radix, 8)); - - var result = ZERO; - for (var i = 0; i < str.length; i += 8) { - var size = Math.min(8, str.length - i), - value = parseInt(str.substring(i, i + size), radix); - if (size < 8) { - var power = fromNumber(pow_dbl(radix, size)); - result = result.mul(power).add(fromNumber(value)); - } else { - result = result.mul(radixToPower); - result = result.add(fromNumber(value)); - } - } - result.unsigned = unsigned; - return result; -} - -/** - * Returns a Long representation of the given string, written using the specified radix. - * @function - * @param {string} str The textual representation of the Long - * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed - * @param {number=} radix The radix in which the text is written (2-36), defaults to 10 - * @returns {!Long} The corresponding Long value - */ -Long.fromString = fromString; - -/** - * @function - * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val - * @param {boolean=} unsigned - * @returns {!Long} - * @inner - */ -function fromValue(val, unsigned) { - if (typeof val === 'number') - return fromNumber(val, unsigned); - if (typeof val === 'string') - return fromString(val, unsigned); - // Throws for non-objects, converts non-instanceof Long: - return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned); -} - -/** - * Converts the specified value to a Long using the appropriate from* function for its type. - * @function - * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @returns {!Long} - */ -Long.fromValue = fromValue; - -// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be -// no runtime penalty for these. - -/** - * @type {number} - * @const - * @inner - */ -var TWO_PWR_16_DBL = 1 << 16; - -/** - * @type {number} - * @const - * @inner - */ -var TWO_PWR_24_DBL = 1 << 24; - -/** - * @type {number} - * @const - * @inner - */ -var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; - -/** - * @type {number} - * @const - * @inner - */ -var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; - -/** - * @type {number} - * @const - * @inner - */ -var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; - -/** - * @type {!Long} - * @const - * @inner - */ -var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL); - -/** - * @type {!Long} - * @inner - */ -var ZERO = fromInt(0); - -/** - * Signed zero. - * @type {!Long} - */ -Long.ZERO = ZERO; - -/** - * @type {!Long} - * @inner - */ -var UZERO = fromInt(0, true); - -/** - * Unsigned zero. - * @type {!Long} - */ -Long.UZERO = UZERO; - -/** - * @type {!Long} - * @inner - */ -var ONE = fromInt(1); - -/** - * Signed one. - * @type {!Long} - */ -Long.ONE = ONE; - -/** - * @type {!Long} - * @inner - */ -var UONE = fromInt(1, true); - -/** - * Unsigned one. - * @type {!Long} - */ -Long.UONE = UONE; - -/** - * @type {!Long} - * @inner - */ -var NEG_ONE = fromInt(-1); - -/** - * Signed negative one. - * @type {!Long} - */ -Long.NEG_ONE = NEG_ONE; - -/** - * @type {!Long} - * @inner - */ -var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false); - -/** - * Maximum signed value. - * @type {!Long} - */ -Long.MAX_VALUE = MAX_VALUE; - -/** - * @type {!Long} - * @inner - */ -var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true); - -/** - * Maximum unsigned value. - * @type {!Long} - */ -Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE; - -/** - * @type {!Long} - * @inner - */ -var MIN_VALUE = fromBits(0, 0x80000000 | 0, false); - -/** - * Minimum signed value. - * @type {!Long} - */ -Long.MIN_VALUE = MIN_VALUE; - -/** - * @alias Long.prototype - * @inner - */ -var LongPrototype = Long.prototype; - -/** - * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. - * @returns {number} - */ -LongPrototype.toInt = function toInt() { - return this.unsigned ? this.low >>> 0 : this.low; -}; - -/** - * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). - * @returns {number} - */ -LongPrototype.toNumber = function toNumber() { - if (this.unsigned) - return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0); - return this.high * TWO_PWR_32_DBL + (this.low >>> 0); -}; - -/** - * Converts the Long to a string written in the specified radix. - * @param {number=} radix Radix (2-36), defaults to 10 - * @returns {string} - * @override - * @throws {RangeError} If `radix` is out of range - */ -LongPrototype.toString = function toString(radix) { - radix = radix || 10; - if (radix < 2 || 36 < radix) - throw RangeError('radix'); - if (this.isZero()) - return '0'; - if (this.isNegative()) { // Unsigned Longs are never negative - if (this.eq(MIN_VALUE)) { - // We need to change the Long value before it can be negated, so we remove - // the bottom-most digit in this base and then recurse to do the rest. - var radixLong = fromNumber(radix), - div = this.div(radixLong), - rem1 = div.mul(radixLong).sub(this); - return div.toString(radix) + rem1.toInt().toString(radix); - } else - return '-' + this.neg().toString(radix); - } - - // Do several (6) digits each time through the loop, so as to - // minimize the calls to the very expensive emulated div. - var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), - rem = this; - var result = ''; - while (true) { - var remDiv = rem.div(radixToPower), - intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, - digits = intval.toString(radix); - rem = remDiv; - if (rem.isZero()) - return digits + result; - else { - while (digits.length < 6) - digits = '0' + digits; - result = '' + digits + result; - } - } -}; - -/** - * Gets the high 32 bits as a signed integer. - * @returns {number} Signed high bits - */ -LongPrototype.getHighBits = function getHighBits() { - return this.high; -}; - -/** - * Gets the high 32 bits as an unsigned integer. - * @returns {number} Unsigned high bits - */ -LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() { - return this.high >>> 0; -}; - -/** - * Gets the low 32 bits as a signed integer. - * @returns {number} Signed low bits - */ -LongPrototype.getLowBits = function getLowBits() { - return this.low; -}; - -/** - * Gets the low 32 bits as an unsigned integer. - * @returns {number} Unsigned low bits - */ -LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() { - return this.low >>> 0; -}; - -/** - * Gets the number of bits needed to represent the absolute value of this Long. - * @returns {number} - */ -LongPrototype.getNumBitsAbs = function getNumBitsAbs() { - if (this.isNegative()) // Unsigned Longs are never negative - return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); - var val = this.high != 0 ? this.high : this.low; - for (var bit = 31; bit > 0; bit--) - if ((val & (1 << bit)) != 0) - break; - return this.high != 0 ? bit + 33 : bit + 1; -}; - -/** - * Tests if this Long's value equals zero. - * @returns {boolean} - */ -LongPrototype.isZero = function isZero() { - return this.high === 0 && this.low === 0; -}; - -/** - * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}. - * @returns {boolean} - */ -LongPrototype.eqz = LongPrototype.isZero; - -/** - * Tests if this Long's value is negative. - * @returns {boolean} - */ -LongPrototype.isNegative = function isNegative() { - return !this.unsigned && this.high < 0; -}; - -/** - * Tests if this Long's value is positive. - * @returns {boolean} - */ -LongPrototype.isPositive = function isPositive() { - return this.unsigned || this.high >= 0; -}; - -/** - * Tests if this Long's value is odd. - * @returns {boolean} - */ -LongPrototype.isOdd = function isOdd() { - return (this.low & 1) === 1; -}; - -/** - * Tests if this Long's value is even. - * @returns {boolean} - */ -LongPrototype.isEven = function isEven() { - return (this.low & 1) === 0; -}; - -/** - * Tests if this Long's value equals the specified's. - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.equals = function equals(other) { - if (!isLong(other)) - other = fromValue(other); - if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1) - return false; - return this.high === other.high && this.low === other.low; -}; - -/** - * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.eq = LongPrototype.equals; - -/** - * Tests if this Long's value differs from the specified's. - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.notEquals = function notEquals(other) { - return !this.eq(/* validates */ other); -}; - -/** - * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.neq = LongPrototype.notEquals; - -/** - * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.ne = LongPrototype.notEquals; - -/** - * Tests if this Long's value is less than the specified's. - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.lessThan = function lessThan(other) { - return this.comp(/* validates */ other) < 0; -}; - -/** - * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.lt = LongPrototype.lessThan; - -/** - * Tests if this Long's value is less than or equal the specified's. - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) { - return this.comp(/* validates */ other) <= 0; -}; - -/** - * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.lte = LongPrototype.lessThanOrEqual; - -/** - * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.le = LongPrototype.lessThanOrEqual; - -/** - * Tests if this Long's value is greater than the specified's. - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.greaterThan = function greaterThan(other) { - return this.comp(/* validates */ other) > 0; -}; - -/** - * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.gt = LongPrototype.greaterThan; - -/** - * Tests if this Long's value is greater than or equal the specified's. - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) { - return this.comp(/* validates */ other) >= 0; -}; - -/** - * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.gte = LongPrototype.greaterThanOrEqual; - -/** - * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. - * @function - * @param {!Long|number|string} other Other value - * @returns {boolean} - */ -LongPrototype.ge = LongPrototype.greaterThanOrEqual; - -/** - * Compares this Long's value with the specified's. - * @param {!Long|number|string} other Other value - * @returns {number} 0 if they are the same, 1 if the this is greater and -1 - * if the given one is greater - */ -LongPrototype.compare = function compare(other) { - if (!isLong(other)) - other = fromValue(other); - if (this.eq(other)) - return 0; - var thisNeg = this.isNegative(), - otherNeg = other.isNegative(); - if (thisNeg && !otherNeg) - return -1; - if (!thisNeg && otherNeg) - return 1; - // At this point the sign bits are the same - if (!this.unsigned) - return this.sub(other).isNegative() ? -1 : 1; - // Both are positive if at least one is unsigned - return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1; -}; - -/** - * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}. - * @function - * @param {!Long|number|string} other Other value - * @returns {number} 0 if they are the same, 1 if the this is greater and -1 - * if the given one is greater - */ -LongPrototype.comp = LongPrototype.compare; - -/** - * Negates this Long's value. - * @returns {!Long} Negated Long - */ -LongPrototype.negate = function negate() { - if (!this.unsigned && this.eq(MIN_VALUE)) - return MIN_VALUE; - return this.not().add(ONE); -}; - -/** - * Negates this Long's value. This is an alias of {@link Long#negate}. - * @function - * @returns {!Long} Negated Long - */ -LongPrototype.neg = LongPrototype.negate; - -/** - * Returns the sum of this and the specified Long. - * @param {!Long|number|string} addend Addend - * @returns {!Long} Sum - */ -LongPrototype.add = function add(addend) { - if (!isLong(addend)) - addend = fromValue(addend); - - // Divide each number into 4 chunks of 16 bits, and then sum the chunks. - - var a48 = this.high >>> 16; - var a32 = this.high & 0xFFFF; - var a16 = this.low >>> 16; - var a00 = this.low & 0xFFFF; - - var b48 = addend.high >>> 16; - var b32 = addend.high & 0xFFFF; - var b16 = addend.low >>> 16; - var b00 = addend.low & 0xFFFF; - - var c48 = 0, c32 = 0, c16 = 0, c00 = 0; - c00 += a00 + b00; - c16 += c00 >>> 16; - c00 &= 0xFFFF; - c16 += a16 + b16; - c32 += c16 >>> 16; - c16 &= 0xFFFF; - c32 += a32 + b32; - c48 += c32 >>> 16; - c32 &= 0xFFFF; - c48 += a48 + b48; - c48 &= 0xFFFF; - return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); -}; - -/** - * Returns the difference of this and the specified Long. - * @param {!Long|number|string} subtrahend Subtrahend - * @returns {!Long} Difference - */ -LongPrototype.subtract = function subtract(subtrahend) { - if (!isLong(subtrahend)) - subtrahend = fromValue(subtrahend); - return this.add(subtrahend.neg()); -}; - -/** - * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}. - * @function - * @param {!Long|number|string} subtrahend Subtrahend - * @returns {!Long} Difference - */ -LongPrototype.sub = LongPrototype.subtract; - -/** - * Returns the product of this and the specified Long. - * @param {!Long|number|string} multiplier Multiplier - * @returns {!Long} Product - */ -LongPrototype.multiply = function multiply(multiplier) { - if (this.isZero()) - return ZERO; - if (!isLong(multiplier)) - multiplier = fromValue(multiplier); - - // use wasm support if present - if (wasm) { - var low = wasm.mul(this.low, - this.high, - multiplier.low, - multiplier.high); - return fromBits(low, wasm.get_high(), this.unsigned); - } - - if (multiplier.isZero()) - return ZERO; - if (this.eq(MIN_VALUE)) - return multiplier.isOdd() ? MIN_VALUE : ZERO; - if (multiplier.eq(MIN_VALUE)) - return this.isOdd() ? MIN_VALUE : ZERO; - - if (this.isNegative()) { - if (multiplier.isNegative()) - return this.neg().mul(multiplier.neg()); - else - return this.neg().mul(multiplier).neg(); - } else if (multiplier.isNegative()) - return this.mul(multiplier.neg()).neg(); - - // If both longs are small, use float multiplication - if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24)) - return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); - - // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. - // We can skip products that would overflow. - - var a48 = this.high >>> 16; - var a32 = this.high & 0xFFFF; - var a16 = this.low >>> 16; - var a00 = this.low & 0xFFFF; - - var b48 = multiplier.high >>> 16; - var b32 = multiplier.high & 0xFFFF; - var b16 = multiplier.low >>> 16; - var b00 = multiplier.low & 0xFFFF; - - var c48 = 0, c32 = 0, c16 = 0, c00 = 0; - c00 += a00 * b00; - c16 += c00 >>> 16; - c00 &= 0xFFFF; - c16 += a16 * b00; - c32 += c16 >>> 16; - c16 &= 0xFFFF; - c16 += a00 * b16; - c32 += c16 >>> 16; - c16 &= 0xFFFF; - c32 += a32 * b00; - c48 += c32 >>> 16; - c32 &= 0xFFFF; - c32 += a16 * b16; - c48 += c32 >>> 16; - c32 &= 0xFFFF; - c32 += a00 * b32; - c48 += c32 >>> 16; - c32 &= 0xFFFF; - c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; - c48 &= 0xFFFF; - return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); -}; - -/** - * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}. - * @function - * @param {!Long|number|string} multiplier Multiplier - * @returns {!Long} Product - */ -LongPrototype.mul = LongPrototype.multiply; - -/** - * Returns this Long divided by the specified. The result is signed if this Long is signed or - * unsigned if this Long is unsigned. - * @param {!Long|number|string} divisor Divisor - * @returns {!Long} Quotient - */ -LongPrototype.divide = function divide(divisor) { - if (!isLong(divisor)) - divisor = fromValue(divisor); - if (divisor.isZero()) - throw Error('division by zero'); - - // use wasm support if present - if (wasm) { - // guard against signed division overflow: the largest - // negative number / -1 would be 1 larger than the largest - // positive number, due to two's complement. - if (!this.unsigned && - this.high === -0x80000000 && - divisor.low === -1 && divisor.high === -1) { - // be consistent with non-wasm code path - return this; - } - var low = (this.unsigned ? wasm.div_u : wasm.div_s)( - this.low, - this.high, - divisor.low, - divisor.high - ); - return fromBits(low, wasm.get_high(), this.unsigned); - } - - if (this.isZero()) - return this.unsigned ? UZERO : ZERO; - var approx, rem, res; - if (!this.unsigned) { - // This section is only relevant for signed longs and is derived from the - // closure library as a whole. - if (this.eq(MIN_VALUE)) { - if (divisor.eq(ONE) || divisor.eq(NEG_ONE)) - return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE - else if (divisor.eq(MIN_VALUE)) - return ONE; - else { - // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. - var halfThis = this.shr(1); - approx = halfThis.div(divisor).shl(1); - if (approx.eq(ZERO)) { - return divisor.isNegative() ? ONE : NEG_ONE; - } else { - rem = this.sub(divisor.mul(approx)); - res = approx.add(rem.div(divisor)); - return res; - } - } - } else if (divisor.eq(MIN_VALUE)) - return this.unsigned ? UZERO : ZERO; - if (this.isNegative()) { - if (divisor.isNegative()) - return this.neg().div(divisor.neg()); - return this.neg().div(divisor).neg(); - } else if (divisor.isNegative()) - return this.div(divisor.neg()).neg(); - res = ZERO; - } else { - // The algorithm below has not been made for unsigned longs. It's therefore - // required to take special care of the MSB prior to running it. - if (!divisor.unsigned) - divisor = divisor.toUnsigned(); - if (divisor.gt(this)) - return UZERO; - if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true - return UONE; - res = UZERO; - } - - // Repeat the following until the remainder is less than other: find a - // floating-point that approximates remainder / other *from below*, add this - // into the result, and subtract it from the remainder. It is critical that - // the approximate value is less than or equal to the real value so that the - // remainder never becomes negative. - rem = this; - while (rem.gte(divisor)) { - // Approximate the result of division. This may be a little greater or - // smaller than the actual value. - approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); - - // We will tweak the approximate result by changing it in the 48-th digit or - // the smallest non-fractional digit, whichever is larger. - var log2 = Math.ceil(Math.log(approx) / Math.LN2), - delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), - - // Decrease the approximation until it is smaller than the remainder. Note - // that if it is too large, the product overflows and is negative. - approxRes = fromNumber(approx), - approxRem = approxRes.mul(divisor); - while (approxRem.isNegative() || approxRem.gt(rem)) { - approx -= delta; - approxRes = fromNumber(approx, this.unsigned); - approxRem = approxRes.mul(divisor); - } - - // We know the answer can't be zero... and actually, zero would cause - // infinite recursion since we would make no progress. - if (approxRes.isZero()) - approxRes = ONE; - - res = res.add(approxRes); - rem = rem.sub(approxRem); - } - return res; -}; - -/** - * Returns this Long divided by the specified. This is an alias of {@link Long#divide}. - * @function - * @param {!Long|number|string} divisor Divisor - * @returns {!Long} Quotient - */ -LongPrototype.div = LongPrototype.divide; - -/** - * Returns this Long modulo the specified. - * @param {!Long|number|string} divisor Divisor - * @returns {!Long} Remainder - */ -LongPrototype.modulo = function modulo(divisor) { - if (!isLong(divisor)) - divisor = fromValue(divisor); - - // use wasm support if present - if (wasm) { - var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)( - this.low, - this.high, - divisor.low, - divisor.high - ); - return fromBits(low, wasm.get_high(), this.unsigned); - } - - return this.sub(this.div(divisor).mul(divisor)); -}; - -/** - * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. - * @function - * @param {!Long|number|string} divisor Divisor - * @returns {!Long} Remainder - */ -LongPrototype.mod = LongPrototype.modulo; - -/** - * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. - * @function - * @param {!Long|number|string} divisor Divisor - * @returns {!Long} Remainder - */ -LongPrototype.rem = LongPrototype.modulo; - -/** - * Returns the bitwise NOT of this Long. - * @returns {!Long} - */ -LongPrototype.not = function not() { - return fromBits(~this.low, ~this.high, this.unsigned); -}; - -/** - * Returns the bitwise AND of this Long and the specified. - * @param {!Long|number|string} other Other Long - * @returns {!Long} - */ -LongPrototype.and = function and(other) { - if (!isLong(other)) - other = fromValue(other); - return fromBits(this.low & other.low, this.high & other.high, this.unsigned); -}; - -/** - * Returns the bitwise OR of this Long and the specified. - * @param {!Long|number|string} other Other Long - * @returns {!Long} - */ -LongPrototype.or = function or(other) { - if (!isLong(other)) - other = fromValue(other); - return fromBits(this.low | other.low, this.high | other.high, this.unsigned); -}; - -/** - * Returns the bitwise XOR of this Long and the given one. - * @param {!Long|number|string} other Other Long - * @returns {!Long} - */ -LongPrototype.xor = function xor(other) { - if (!isLong(other)) - other = fromValue(other); - return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); -}; - -/** - * Returns this Long with bits shifted to the left by the given amount. - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shiftLeft = function shiftLeft(numBits) { - if (isLong(numBits)) - numBits = numBits.toInt(); - if ((numBits &= 63) === 0) - return this; - else if (numBits < 32) - return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned); - else - return fromBits(0, this.low << (numBits - 32), this.unsigned); -}; - -/** - * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}. - * @function - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shl = LongPrototype.shiftLeft; - -/** - * Returns this Long with bits arithmetically shifted to the right by the given amount. - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shiftRight = function shiftRight(numBits) { - if (isLong(numBits)) - numBits = numBits.toInt(); - if ((numBits &= 63) === 0) - return this; - else if (numBits < 32) - return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned); - else - return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned); -}; - -/** - * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}. - * @function - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shr = LongPrototype.shiftRight; - -/** - * Returns this Long with bits logically shifted to the right by the given amount. - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { - if (isLong(numBits)) - numBits = numBits.toInt(); - numBits &= 63; - if (numBits === 0) - return this; - else { - var high = this.high; - if (numBits < 32) { - var low = this.low; - return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned); - } else if (numBits === 32) - return fromBits(high, 0, this.unsigned); - else - return fromBits(high >>> (numBits - 32), 0, this.unsigned); - } -}; - -/** - * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. - * @function - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shru = LongPrototype.shiftRightUnsigned; - -/** - * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. - * @function - * @param {number|!Long} numBits Number of bits - * @returns {!Long} Shifted Long - */ -LongPrototype.shr_u = LongPrototype.shiftRightUnsigned; - -/** - * Converts this Long to signed. - * @returns {!Long} Signed long - */ -LongPrototype.toSigned = function toSigned() { - if (!this.unsigned) - return this; - return fromBits(this.low, this.high, false); -}; - -/** - * Converts this Long to unsigned. - * @returns {!Long} Unsigned long - */ -LongPrototype.toUnsigned = function toUnsigned() { - if (this.unsigned) - return this; - return fromBits(this.low, this.high, true); -}; - -/** - * Converts this Long to its byte representation. - * @param {boolean=} le Whether little or big endian, defaults to big endian - * @returns {!Array.} Byte representation - */ -LongPrototype.toBytes = function toBytes(le) { - return le ? this.toBytesLE() : this.toBytesBE(); -}; - -/** - * Converts this Long to its little endian byte representation. - * @returns {!Array.} Little endian byte representation - */ -LongPrototype.toBytesLE = function toBytesLE() { - var hi = this.high, - lo = this.low; - return [ - lo & 0xff, - lo >>> 8 & 0xff, - lo >>> 16 & 0xff, - lo >>> 24, - hi & 0xff, - hi >>> 8 & 0xff, - hi >>> 16 & 0xff, - hi >>> 24 - ]; -}; - -/** - * Converts this Long to its big endian byte representation. - * @returns {!Array.} Big endian byte representation - */ -LongPrototype.toBytesBE = function toBytesBE() { - var hi = this.high, - lo = this.low; - return [ - hi >>> 24, - hi >>> 16 & 0xff, - hi >>> 8 & 0xff, - hi & 0xff, - lo >>> 24, - lo >>> 16 & 0xff, - lo >>> 8 & 0xff, - lo & 0xff - ]; -}; - -/** - * Creates a Long from its byte representation. - * @param {!Array.} bytes Byte representation - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @param {boolean=} le Whether little or big endian, defaults to big endian - * @returns {Long} The corresponding Long value - */ -Long.fromBytes = function fromBytes(bytes, unsigned, le) { - return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned); -}; - -/** - * Creates a Long from its little endian byte representation. - * @param {!Array.} bytes Little endian byte representation - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @returns {Long} The corresponding Long value - */ -Long.fromBytesLE = function fromBytesLE(bytes, unsigned) { - return new Long( - bytes[0] | - bytes[1] << 8 | - bytes[2] << 16 | - bytes[3] << 24, - bytes[4] | - bytes[5] << 8 | - bytes[6] << 16 | - bytes[7] << 24, - unsigned - ); -}; - -/** - * Creates a Long from its big endian byte representation. - * @param {!Array.} bytes Big endian byte representation - * @param {boolean=} unsigned Whether unsigned or not, defaults to signed - * @returns {Long} The corresponding Long value - */ -Long.fromBytesBE = function fromBytesBE(bytes, unsigned) { - return new Long( - bytes[4] << 24 | - bytes[5] << 16 | - bytes[6] << 8 | - bytes[7], - bytes[0] << 24 | - bytes[1] << 16 | - bytes[2] << 8 | - bytes[3], - unsigned - ); -}; diff --git a/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts b/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts index 3d593393..235b9519 100644 --- a/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts +++ b/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts @@ -1,82 +1,75 @@ import ObjectA from './ObjectA'; -// 复杂的对象 -// 包括了各种复杂的结构，数组，List，Set，Map -// -// @author godotg +// 复杂的对象，包括了各种复杂的结构，数组，List，Set，Map class ComplexObject { // byte类型，最简单的整形 a: number = 0; - // byte的包装类型 - // 优先使用基础类型，包装类型会有装箱拆箱 + // byte的包装类型，优先使用基础类型，包装类型会有装箱拆箱 aa: number = 0; // 数组类型 - aaa: Array | null = null; - aaaa: Array | null = null; + aaa: Array = []; + aaaa: Array = []; b: number = 0; bb: number = 0; - bbb: Array | null = null; - bbbb: Array | null = null; + bbb: Array = []; + bbbb: Array = []; c: number = 0; cc: number = 0; - ccc: Array | null = null; - cccc: Array | null = null; + ccc: Array = []; + cccc: Array = []; d: number = 0; dd: number = 0; - ddd: Array | null = null; - dddd: Array | null = null; + ddd: Array = []; + dddd: Array = []; e: number = 0; ee: number = 0; - eee: Array | null = null; - eeee: Array | null = null; + eee: Array = []; + eeee: Array = []; f: number = 0; ff: number = 0; - fff: Array | null = null; - ffff: Array | null = null; + fff: Array = []; + ffff: Array = []; g: boolean = false; gg: boolean = false; - ggg: Array | null = null; - gggg: Array | null = null; - h: string = ''; - hh: string = ''; - hhh: Array | null = null; - hhhh: Array | null = null; + ggg: Array = []; + gggg: Array = []; jj: string = ''; - jjj: Array | null = null; + jjj: Array = []; kk: ObjectA | null = null; - kkk: Array | null = null; - l: Array | null = null; - ll: Array>> | null = null; - lll: Array> | null = null; - llll: Array | null = null; - lllll: Array> | null = null; - m: Map | null = null; - mm: Map | null = null; - mmm: Map> | null = null; - mmmm: Map>, Array>>> | null = null; - mmmmm: Map>, Set>> | null = null; - s: Set | null = null; - ss: Set>> | null = null; - sss: Set> | null = null; - ssss: Set | null = null; - sssss: Set> | null = null; + kkk: Array = []; + l: Array = []; + ll: Array>> = []; + lll: Array> = []; + llll: Array = []; + lllll: Array> = []; + m: Map = new Map(); + mm: Map = new Map(); + mmm: Map> = new Map(); + mmmm: Map>, Array>>> = new Map(); + mmmmm: Map>, Set>> = new Map(); + s: Set = new Set(); + ss: Set>> = new Set(); + sss: Set> = new Set(); + ssss: Set = new Set(); + sssss: Set> = new Set(); // 如果要修改协议并且兼容老协议，需要加上Compatible注解，按照增加的顺序添加order myCompatible: number = 0; myObject: ObjectA | null = null; + static PROTOCOL_ID: number = 100; + protocolId(): number { - return 100; + return ComplexObject.PROTOCOL_ID; } static write(buffer: any, packet: ComplexObject | null) { - if (buffer.writePacketFlag(packet)) { - return; - } if (packet === null) { + buffer.writeInt(0); return; } - + const beforeWriteIndex = buffer.getWriteOffset(); + buffer.writeInt(128); buffer.writeByte(packet.a); buffer.writeByte(packet.aa); buffer.writeByteArray(packet.aaa); @@ -105,10 +98,6 @@ class ComplexObject { buffer.writeBoolean(packet.gg); buffer.writeBooleanArray(packet.ggg); buffer.writeBooleanArray(packet.gggg); - buffer.writeChar(packet.h); - buffer.writeChar(packet.hh); - buffer.writeCharArray(packet.hhh); - buffer.writeCharArray(packet.hhhh); buffer.writeString(packet.jj); buffer.writeStringArray(packet.jjj); buffer.writePacket(packet.kk, 102); @@ -245,12 +234,15 @@ class ComplexObject { } buffer.writeInt(packet.myCompatible); buffer.writePacket(packet.myObject, 102); + buffer.adjustPadding(128, beforeWriteIndex); } static read(buffer: any): ComplexObject | null { - if (!buffer.readBoolean()) { + const length = buffer.readInt(); + if (length === 0) { return null; } + const readIndex = buffer.getReadOffset(); const packet = new ComplexObject(); const result19 = buffer.readByte(); packet.a = result19; @@ -308,177 +300,170 @@ class ComplexObject { packet.ggg = array45; const array46 = buffer.readBooleanArray(); packet.gggg = array46; - const result47 = buffer.readChar(); - packet.h = result47; - const result48 = buffer.readChar(); - packet.hh = result48; - const array49 = buffer.readCharArray(); - packet.hhh = array49; - const array50 = buffer.readCharArray(); - packet.hhhh = array50; - const result51 = buffer.readString(); - packet.jj = result51; - const array52 = buffer.readStringArray(); - packet.jjj = array52; - const result53 = buffer.readPacket(102); - packet.kk = result53; - const array54 = buffer.readPacketArray(102); - packet.kkk = array54; - const list55 = buffer.readIntList(); - packet.l = list55; - const result56 = new Array>>(); - const size57 = buffer.readInt(); - if (size57 > 0) { - for (let index58 = 0; index58 < size57; index58++) { - const result59 = new Array>(); - const size60 = buffer.readInt(); - if (size60 > 0) { - for (let index61 = 0; index61 < size60; index61++) { - const list62 = buffer.readIntList(); - result59.push(list62); + const result47 = buffer.readString(); + packet.jj = result47; + const array48 = buffer.readStringArray(); + packet.jjj = array48; + const result49 = buffer.readPacket(102); + packet.kk = result49; + const array50 = buffer.readPacketArray(102); + packet.kkk = array50; + const list51 = buffer.readIntList(); + packet.l = list51; + const result52 = new Array>>(); + const size53 = buffer.readInt(); + if (size53 > 0) { + for (let index54 = 0; index54 < size53; index54++) { + const result55 = new Array>(); + const size56 = buffer.readInt(); + if (size56 > 0) { + for (let index57 = 0; index57 < size56; index57++) { + const list58 = buffer.readIntList(); + result55.push(list58); } } - result56.push(result59); + result52.push(result55); } } - packet.ll = result56; - const result63 = new Array>(); - const size64 = buffer.readInt(); - if (size64 > 0) { - for (let index65 = 0; index65 < size64; index65++) { - const list66 = buffer.readPacketList(102); - result63.push(list66); + packet.ll = result52; + const result59 = new Array>(); + const size60 = buffer.readInt(); + if (size60 > 0) { + for (let index61 = 0; index61 < size60; index61++) { + const list62 = buffer.readPacketList(102); + result59.push(list62); } } - packet.lll = result63; - const list67 = buffer.readStringList(); - packet.llll = list67; - const result68 = new Array>(); - const size69 = buffer.readInt(); - if (size69 > 0) { - for (let index70 = 0; index70 < size69; index70++) { - const map71 = buffer.readIntStringMap(); - result68.push(map71); + packet.lll = result59; + const list63 = buffer.readStringList(); + packet.llll = list63; + const result64 = new Array>(); + const size65 = buffer.readInt(); + if (size65 > 0) { + for (let index66 = 0; index66 < size65; index66++) { + const map67 = buffer.readIntStringMap(); + result64.push(map67); } } - packet.lllll = result68; - const map72 = buffer.readIntStringMap(); - packet.m = map72; - const map73 = buffer.readIntPacketMap(102); - packet.mm = map73; - const result74 = new Map>(); - const size75 = buffer.readInt(); - if (size75 > 0) { - for (let index76 = 0; index76 < size75; index76++) { - const result77 = buffer.readPacket(102); - const list78 = buffer.readIntList(); - result74.set(result77, list78); + packet.lllll = result64; + const map68 = buffer.readIntStringMap(); + packet.m = map68; + const map69 = buffer.readIntPacketMap(102); + packet.mm = map69; + const result70 = new Map>(); + const size71 = buffer.readInt(); + if (size71 > 0) { + for (let index72 = 0; index72 < size71; index72++) { + const result73 = buffer.readPacket(102); + const list74 = buffer.readIntList(); + result70.set(result73, list74); } } - packet.mmm = result74; - const result79 = new Map>, Array>>>(); - const size80 = buffer.readInt(); - if (size80 > 0) { - for (let index81 = 0; index81 < size80; index81++) { - const result82 = new Array>(); + packet.mmm = result70; + const result75 = new Map>, Array>>>(); + const size76 = buffer.readInt(); + if (size76 > 0) { + for (let index77 = 0; index77 < size76; index77++) { + const result78 = new Array>(); + const size79 = buffer.readInt(); + if (size79 > 0) { + for (let index80 = 0; index80 < size79; index80++) { + const list81 = buffer.readPacketList(102); + result78.push(list81); + } + } + const result82 = new Array>>(); const size83 = buffer.readInt(); if (size83 > 0) { for (let index84 = 0; index84 < size83; index84++) { - const list85 = buffer.readPacketList(102); - result82.push(list85); - } - } - const result86 = new Array>>(); - const size87 = buffer.readInt(); - if (size87 > 0) { - for (let index88 = 0; index88 < size87; index88++) { - const result89 = new Array>(); - const size90 = buffer.readInt(); - if (size90 > 0) { - for (let index91 = 0; index91 < size90; index91++) { - const list92 = buffer.readIntList(); - result89.push(list92); + const result85 = new Array>(); + const size86 = buffer.readInt(); + if (size86 > 0) { + for (let index87 = 0; index87 < size86; index87++) { + const list88 = buffer.readIntList(); + result85.push(list88); } } - result86.push(result89); + result82.push(result85); } } - result79.set(result82, result86); + result75.set(result78, result82); } } - packet.mmmm = result79; - const result93 = new Map>, Set>>(); - const size94 = buffer.readInt(); - if (size94 > 0) { - for (let index95 = 0; index95 < size94; index95++) { - const result96 = new Array>(); + packet.mmmm = result75; + const result89 = new Map>, Set>>(); + const size90 = buffer.readInt(); + if (size90 > 0) { + for (let index91 = 0; index91 < size90; index91++) { + const result92 = new Array>(); + const size93 = buffer.readInt(); + if (size93 > 0) { + for (let index94 = 0; index94 < size93; index94++) { + const map95 = buffer.readIntStringMap(); + result92.push(map95); + } + } + const result96 = new Set>(); const size97 = buffer.readInt(); if (size97 > 0) { for (let index98 = 0; index98 < size97; index98++) { const map99 = buffer.readIntStringMap(); - result96.push(map99); + result96.add(map99); } } - const result100 = new Set>(); - const size101 = buffer.readInt(); - if (size101 > 0) { - for (let index102 = 0; index102 < size101; index102++) { - const map103 = buffer.readIntStringMap(); - result100.add(map103); + result89.set(result92, result96); + } + } + packet.mmmmm = result89; + const set100 = buffer.readIntSet(); + packet.s = set100; + const result101 = new Set>>(); + const size102 = buffer.readInt(); + if (size102 > 0) { + for (let index103 = 0; index103 < size102; index103++) { + const result104 = new Set>(); + const size105 = buffer.readInt(); + if (size105 > 0) { + for (let index106 = 0; index106 < size105; index106++) { + const list107 = buffer.readIntList(); + result104.add(list107); } } - result93.set(result96, result100); + result101.add(result104); } } - packet.mmmmm = result93; - const set104 = buffer.readIntSet(); - packet.s = set104; - const result105 = new Set>>(); - const size106 = buffer.readInt(); - if (size106 > 0) { - for (let index107 = 0; index107 < size106; index107++) { - const result108 = new Set>(); - const size109 = buffer.readInt(); - if (size109 > 0) { - for (let index110 = 0; index110 < size109; index110++) { - const list111 = buffer.readIntList(); - result108.add(list111); - } - } - result105.add(result108); + packet.ss = result101; + const result108 = new Set>(); + const size109 = buffer.readInt(); + if (size109 > 0) { + for (let index110 = 0; index110 < size109; index110++) { + const set111 = buffer.readPacketSet(102); + result108.add(set111); } } - packet.ss = result105; - const result112 = new Set>(); - const size113 = buffer.readInt(); - if (size113 > 0) { - for (let index114 = 0; index114 < size113; index114++) { - const set115 = buffer.readPacketSet(102); - result112.add(set115); + packet.sss = result108; + const set112 = buffer.readStringSet(); + packet.ssss = set112; + const result113 = new Set>(); + const size114 = buffer.readInt(); + if (size114 > 0) { + for (let index115 = 0; index115 < size114; index115++) { + const map116 = buffer.readIntStringMap(); + result113.add(map116); } } - packet.sss = result112; - const set116 = buffer.readStringSet(); - packet.ssss = set116; - const result117 = new Set>(); - const size118 = buffer.readInt(); - if (size118 > 0) { - for (let index119 = 0; index119 < size118; index119++) { - const map120 = buffer.readIntStringMap(); - result117.add(map120); - } + packet.sssss = result113; + if (length !== -1 && buffer.getReadOffset() - readIndex < length) { + const result117 = buffer.readInt(); + packet.myCompatible = result117; } - packet.sssss = result117; - if (!buffer.isReadable()) { - return packet; + if (length !== -1 && buffer.getReadOffset() - readIndex < length) { + const result118 = buffer.readPacket(102); + packet.myObject = result118; } - const result121 = buffer.readInt(); - packet.myCompatible = result121; - if (!buffer.isReadable()) { - return packet; + if (length > 0) { + buffer.setReadOffset(readIndex + length); } - const result122 = buffer.readPacket(102); - packet.myObject = result122; return packet; } } diff --git a/protocol/src/test/typescript/zfoo/packet/EmptyObject.ts b/protocol/src/test/typescript/zfoo/packet/EmptyObject.ts new file mode 100644 index 00000000..3f9cc1b8 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/EmptyObject.ts @@ -0,0 +1,36 @@ + + +class EmptyObject { + + + + static PROTOCOL_ID: number = 0; + + protocolId(): number { + return EmptyObject.PROTOCOL_ID; + } + + static write(buffer: any, packet: EmptyObject | null) { + if (packet === null) { + buffer.writeInt(0); + return; + } + buffer.writeInt(-1); + } + + static read(buffer: any): EmptyObject | null { + const length = buffer.readInt(); + if (length === 0) { + return null; + } + const readIndex = buffer.getReadOffset(); + const packet = new EmptyObject(); + + if (length > 0) { + buffer.setReadOffset(readIndex + length); + } + return packet; + } +} + +export default EmptyObject; diff --git a/protocol/src/test/typescript/zfoo/packet/NormalObject.ts b/protocol/src/test/typescript/zfoo/packet/NormalObject.ts index e8b64793..4a409391 100644 --- a/protocol/src/test/typescript/zfoo/packet/NormalObject.ts +++ b/protocol/src/test/typescript/zfoo/packet/NormalObject.ts @@ -1,10 +1,10 @@ import ObjectA from './ObjectA'; -// @author godotg + class NormalObject { a: number = 0; - aaa: Array | null = null; + aaa: Array = []; b: number = 0; c: number = 0; d: number = 0; @@ -13,27 +13,27 @@ class NormalObject { g: boolean = false; jj: string = ''; kk: ObjectA | null = null; - l: Array | null = null; - ll: Array | null = null; - lll: Array | null = null; - llll: Array | null = null; - m: Map | null = null; - mm: Map | null = null; - s: Set | null = null; - ssss: Set | null = null; + l: Array = []; + ll: Array = []; + lll: Array = []; + llll: Array = []; + m: Map = new Map(); + mm: Map = new Map(); + s: Set = new Set(); + ssss: Set = new Set(); + + static PROTOCOL_ID: number = 101; protocolId(): number { - return 101; + return NormalObject.PROTOCOL_ID; } static write(buffer: any, packet: NormalObject | null) { - if (buffer.writePacketFlag(packet)) { - return; - } if (packet === null) { + buffer.writeInt(0); return; } - + buffer.writeInt(-1); buffer.writeByte(packet.a); buffer.writeByteArray(packet.aaa); buffer.writeShort(packet.b); @@ -55,9 +55,11 @@ class NormalObject { } static read(buffer: any): NormalObject | null { - if (!buffer.readBoolean()) { + const length = buffer.readInt(); + if (length === 0) { return null; } + const readIndex = buffer.getReadOffset(); const packet = new NormalObject(); const result0 = buffer.readByte(); packet.a = result0; @@ -95,6 +97,9 @@ class NormalObject { packet.s = set16; const set17 = buffer.readStringSet(); packet.ssss = set17; + if (length > 0) { + buffer.setReadOffset(readIndex + length); + } return packet; } } diff --git a/protocol/src/test/typescript/zfoo/packet/ObjectA.ts b/protocol/src/test/typescript/zfoo/packet/ObjectA.ts index c6e3b5fd..22d0af0e 100644 --- a/protocol/src/test/typescript/zfoo/packet/ObjectA.ts +++ b/protocol/src/test/typescript/zfoo/packet/ObjectA.ts @@ -1,33 +1,35 @@ import ObjectB from './ObjectB'; -// @author godotg + class ObjectA { a: number = 0; - m: Map | null = null; + m: Map = new Map(); objectB: ObjectB | null = null; + static PROTOCOL_ID: number = 102; + protocolId(): number { - return 102; + return ObjectA.PROTOCOL_ID; } static write(buffer: any, packet: ObjectA | null) { - if (buffer.writePacketFlag(packet)) { - return; - } if (packet === null) { + buffer.writeInt(0); return; } - + buffer.writeInt(-1); buffer.writeInt(packet.a); buffer.writeIntStringMap(packet.m); buffer.writePacket(packet.objectB, 103); } static read(buffer: any): ObjectA | null { - if (!buffer.readBoolean()) { + const length = buffer.readInt(); + if (length === 0) { return null; } + const readIndex = buffer.getReadOffset(); const packet = new ObjectA(); const result0 = buffer.readInt(); packet.a = result0; @@ -35,6 +37,9 @@ class ObjectA { packet.m = map1; const result2 = buffer.readPacket(103); packet.objectB = result2; + if (length > 0) { + buffer.setReadOffset(readIndex + length); + } return packet; } } diff --git a/protocol/src/test/typescript/zfoo/packet/ObjectB.ts b/protocol/src/test/typescript/zfoo/packet/ObjectB.ts index 51d6be3e..d2e39dab 100644 --- a/protocol/src/test/typescript/zfoo/packet/ObjectB.ts +++ b/protocol/src/test/typescript/zfoo/packet/ObjectB.ts @@ -1,31 +1,36 @@ -// @author godotg + class ObjectB { flag: boolean = false; + static PROTOCOL_ID: number = 103; + protocolId(): number { - return 103; + return ObjectB.PROTOCOL_ID; } static write(buffer: any, packet: ObjectB | null) { - if (buffer.writePacketFlag(packet)) { - return; - } if (packet === null) { + buffer.writeInt(0); return; } - + buffer.writeInt(-1); buffer.writeBoolean(packet.flag); } static read(buffer: any): ObjectB | null { - if (!buffer.readBoolean()) { + const length = buffer.readInt(); + if (length === 0) { return null; } + const readIndex = buffer.getReadOffset(); const packet = new ObjectB(); const result0 = buffer.readBoolean(); packet.flag = result0; + if (length > 0) { + buffer.setReadOffset(readIndex + length); + } return packet; } } diff --git a/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts b/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts index efd9c361..5d57ddbd 100644 --- a/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts +++ b/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts @@ -1,35 +1,40 @@ -// @author godotg + class SimpleObject { c: number = 0; g: boolean = false; + static PROTOCOL_ID: number = 104; + protocolId(): number { - return 104; + return SimpleObject.PROTOCOL_ID; } static write(buffer: any, packet: SimpleObject | null) { - if (buffer.writePacketFlag(packet)) { - return; - } if (packet === null) { + buffer.writeInt(0); return; } - + buffer.writeInt(-1); buffer.writeInt(packet.c); buffer.writeBoolean(packet.g); } static read(buffer: any): SimpleObject | null { - if (!buffer.readBoolean()) { + const length = buffer.readInt(); + if (length === 0) { return null; } + const readIndex = buffer.getReadOffset(); const packet = new SimpleObject(); const result0 = buffer.readInt(); packet.c = result0; const result1 = buffer.readBoolean(); packet.g = result1; + if (length > 0) { + buffer.setReadOffset(readIndex + length); + } return packet; } } diff --git a/protocol/src/test/typescript/zfoo/packet/VeryBigObject.ts b/protocol/src/test/typescript/zfoo/packet/VeryBigObject.ts new file mode 100644 index 00000000..87cfa5d1 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/VeryBigObject.ts @@ -0,0 +1,13411 @@ +import ObjectA from './ObjectA'; + + +class VeryBigObject { + + a1: number = 0; + aa1: number = 0; + aaa1: Array = []; + aaaa1: Array = []; + b1: number = 0; + bb1: number = 0; + bbb1: Array = []; + bbbb1: Array = []; + c1: number = 0; + cc1: number = 0; + ccc1: Array = []; + cccc1: Array = []; + d1: number = 0; + dd1: number = 0; + ddd1: Array = []; + dddd1: Array = []; + e1: number = 0; + ee1: number = 0; + eee1: Array = []; + eeee1: Array = []; + f1: number = 0; + ff1: number = 0; + fff1: Array = []; + ffff1: Array = []; + g1: boolean = false; + gg1: boolean = false; + ggg1: Array = []; + gggg1: Array = []; + jj1: string = ''; + jjj1: Array = []; + kk1: ObjectA | null = null; + kkk1: Array = []; + l1: Array = []; + llll1: Array = []; + m1: Map = new Map(); + mm1: Map = new Map(); + s1: Set = new Set(); + ssss1: Set = new Set(); + a2: number = 0; + aa2: number = 0; + aaa2: Array = []; + aaaa2: Array = []; + b2: number = 0; + bb2: number = 0; + bbb2: Array = []; + bbbb2: Array = []; + c2: number = 0; + cc2: number = 0; + ccc2: Array = []; + cccc2: Array = []; + d2: number = 0; + dd2: number = 0; + ddd2: Array = []; + dddd2: Array = []; + e2: number = 0; + ee2: number = 0; + eee2: Array = []; + eeee2: Array = []; + f2: number = 0; + ff2: number = 0; + fff2: Array = []; + ffff2: Array = []; + g2: boolean = false; + gg2: boolean = false; + ggg2: Array = []; + gggg2: Array = []; + jj2: string = ''; + jjj2: Array = []; + kk2: ObjectA | null = null; + kkk2: Array = []; + l2: Array = []; + llll2: Array = []; + m2: Map = new Map(); + mm2: Map = new Map(); + s2: Set = new Set(); + ssss2: Set = new Set(); + a3: number = 0; + aa3: number = 0; + aaa3: Array = []; + aaaa3: Array = []; + b3: number = 0; + bb3: number = 0; + bbb3: Array = []; + bbbb3: Array = []; + c3: number = 0; + cc3: number = 0; + ccc3: Array = []; + cccc3: Array = []; + d3: number = 0; + dd3: number = 0; + ddd3: Array = []; + dddd3: Array = []; + e3: number = 0; + ee3: number = 0; + eee3: Array = []; + eeee3: Array = []; + f3: number = 0; + ff3: number = 0; + fff3: Array = []; + ffff3: Array = []; + g3: boolean = false; + gg3: boolean = false; + ggg3: Array = []; + gggg3: Array = []; + jj3: string = ''; + jjj3: Array = []; + kk3: ObjectA | null = null; + kkk3: Array = []; + l3: Array = []; + llll3: Array = []; + m3: Map = new Map(); + mm3: Map = new Map(); + s3: Set = new Set(); + ssss3: Set = new Set(); + a4: number = 0; + aa4: number = 0; + aaa4: Array = []; + aaaa4: Array = []; + b4: number = 0; + bb4: number = 0; + bbb4: Array = []; + bbbb4: Array = []; + c4: number = 0; + cc4: number = 0; + ccc4: Array = []; + cccc4: Array = []; + d4: number = 0; + dd4: number = 0; + ddd4: Array = []; + dddd4: Array = []; + e4: number = 0; + ee4: number = 0; + eee4: Array = []; + eeee4: Array = []; + f4: number = 0; + ff4: number = 0; + fff4: Array = []; + ffff4: Array = []; + g4: boolean = false; + gg4: boolean = false; + ggg4: Array = []; + gggg4: Array = []; + jj4: string = ''; + jjj4: Array = []; + kk4: ObjectA | null = null; + kkk4: Array = []; + l4: Array = []; + llll4: Array = []; + m4: Map = new Map(); + mm4: Map = new Map(); + s4: Set = new Set(); + ssss4: Set = new Set(); + a5: number = 0; + aa5: number = 0; + aaa5: Array = []; + aaaa5: Array = []; + b5: number = 0; + bb5: number = 0; + bbb5: Array = []; + bbbb5: Array = []; + c5: number = 0; + cc5: number = 0; + ccc5: Array = []; + cccc5: Array = []; + d5: number = 0; + dd5: number = 0; + ddd5: Array = []; + dddd5: Array = []; + e5: number = 0; + ee5: number = 0; + eee5: Array = []; + eeee5: Array = []; + f5: number = 0; + ff5: number = 0; + fff5: Array = []; + ffff5: Array = []; + g5: boolean = false; + gg5: boolean = false; + ggg5: Array = []; + gggg5: Array = []; + jj5: string = ''; + jjj5: Array = []; + kk5: ObjectA | null = null; + kkk5: Array = []; + l5: Array = []; + llll5: Array = []; + m5: Map = new Map(); + mm5: Map = new Map(); + s5: Set = new Set(); + ssss5: Set = new Set(); + a6: number = 0; + aa6: number = 0; + aaa6: Array = []; + aaaa6: Array = []; + b6: number = 0; + bb6: number = 0; + bbb6: Array = []; + bbbb6: Array = []; + c6: number = 0; + cc6: number = 0; + ccc6: Array = []; + cccc6: Array = []; + d6: number = 0; + dd6: number = 0; + ddd6: Array = []; + dddd6: Array = []; + e6: number = 0; + ee6: number = 0; + eee6: Array = []; + eeee6: Array = []; + f6: number = 0; + ff6: number = 0; + fff6: Array = []; + ffff6: Array = []; + g6: boolean = false; + gg6: boolean = false; + ggg6: Array = []; + gggg6: Array = []; + jj6: string = ''; + jjj6: Array = []; + kk6: ObjectA | null = null; + kkk6: Array = []; + l6: Array = []; + llll6: Array = []; + m6: Map = new Map(); + mm6: Map = new Map(); + s6: Set = new Set(); + ssss6: Set = new Set(); + a7: number = 0; + aa7: number = 0; + aaa7: Array = []; + aaaa7: Array = []; + b7: number = 0; + bb7: number = 0; + bbb7: Array = []; + bbbb7: Array = []; + c7: number = 0; + cc7: number = 0; + ccc7: Array = []; + cccc7: Array = []; + d7: number = 0; + dd7: number = 0; + ddd7: Array = []; + dddd7: Array = []; + e7: number = 0; + ee7: number = 0; + eee7: Array = []; + eeee7: Array = []; + f7: number = 0; + ff7: number = 0; + fff7: Array = []; + ffff7: Array = []; + g7: boolean = false; + gg7: boolean = false; + ggg7: Array = []; + gggg7: Array = []; + jj7: string = ''; + jjj7: Array = []; + kk7: ObjectA | null = null; + kkk7: Array = []; + l7: Array = []; + llll7: Array = []; + m7: Map = new Map(); + mm7: Map = new Map(); + s7: Set = new Set(); + ssss7: Set = new Set(); + a8: number = 0; + aa8: number = 0; + aaa8: Array = []; + aaaa8: Array = []; + b8: number = 0; + bb8: number = 0; + bbb8: Array = []; + bbbb8: Array = []; + c8: number = 0; + cc8: number = 0; + ccc8: Array = []; + cccc8: Array = []; + d8: number = 0; + dd8: number = 0; + ddd8: Array = []; + dddd8: Array = []; + e8: number = 0; + ee8: number = 0; + eee8: Array = []; + eeee8: Array = []; + f8: number = 0; + ff8: number = 0; + fff8: Array = []; + ffff8: Array = []; + g8: boolean = false; + gg8: boolean = false; + ggg8: Array = []; + gggg8: Array = []; + jj8: string = ''; + jjj8: Array = []; + kk8: ObjectA | null = null; + kkk8: Array = []; + l8: Array = []; + llll8: Array = []; + m8: Map = new Map(); + mm8: Map = new Map(); + s8: Set = new Set(); + ssss8: Set = new Set(); + a9: number = 0; + aa9: number = 0; + aaa9: Array = []; + aaaa9: Array = []; + b9: number = 0; + bb9: number = 0; + bbb9: Array = []; + bbbb9: Array = []; + c9: number = 0; + cc9: number = 0; + ccc9: Array = []; + cccc9: Array = []; + d9: number = 0; + dd9: number = 0; + ddd9: Array = []; + dddd9: Array = []; + e9: number = 0; + ee9: number = 0; + eee9: Array = []; + eeee9: Array = []; + f9: number = 0; + ff9: number = 0; + fff9: Array = []; + ffff9: Array = []; + g9: boolean = false; + gg9: boolean = false; + ggg9: Array = []; + gggg9: Array = []; + jj9: string = ''; + jjj9: Array = []; + kk9: ObjectA | null = null; + kkk9: Array = []; + l9: Array = []; + llll9: Array = []; + m9: Map = new Map(); + mm9: Map = new Map(); + s9: Set = new Set(); + ssss9: Set = new Set(); + a10: number = 0; + aa10: number = 0; + aaa10: Array = []; + aaaa10: Array = []; + b10: number = 0; + bb10: number = 0; + bbb10: Array = []; + bbbb10: Array = []; + c10: number = 0; + cc10: number = 0; + ccc10: Array = []; + cccc10: Array = []; + d10: number = 0; + dd10: number = 0; + ddd10: Array = []; + dddd10: Array = []; + e10: number = 0; + ee10: number = 0; + eee10: Array = []; + eeee10: Array = []; + f10: number = 0; + ff10: number = 0; + fff10: Array = []; + ffff10: Array = []; + g10: boolean = false; + gg10: boolean = false; + ggg10: Array = []; + gggg10: Array = []; + jj10: string = ''; + jjj10: Array = []; + kk10: ObjectA | null = null; + kkk10: Array = []; + l10: Array = []; + llll10: Array = []; + m10: Map = new Map(); + mm10: Map = new Map(); + s10: Set = new Set(); + ssss10: Set = new Set(); + a11: number = 0; + aa11: number = 0; + aaa11: Array = []; + aaaa11: Array = []; + b11: number = 0; + bb11: number = 0; + bbb11: Array = []; + bbbb11: Array = []; + c11: number = 0; + cc11: number = 0; + ccc11: Array = []; + cccc11: Array = []; + d11: number = 0; + dd11: number = 0; + ddd11: Array = []; + dddd11: Array = []; + e11: number = 0; + ee11: number = 0; + eee11: Array = []; + eeee11: Array = []; + f11: number = 0; + ff11: number = 0; + fff11: Array = []; + ffff11: Array = []; + g11: boolean = false; + gg11: boolean = false; + ggg11: Array = []; + gggg11: Array = []; + jj11: string = ''; + jjj11: Array = []; + kk11: ObjectA | null = null; + kkk11: Array = []; + l11: Array = []; + llll11: Array = []; + m11: Map = new Map(); + mm11: Map = new Map(); + s11: Set = new Set(); + ssss11: Set = new Set(); + a12: number = 0; + aa12: number = 0; + aaa12: Array = []; + aaaa12: Array = []; + b12: number = 0; + bb12: number = 0; + bbb12: Array = []; + bbbb12: Array = []; + c12: number = 0; + cc12: number = 0; + ccc12: Array = []; + cccc12: Array = []; + d12: number = 0; + dd12: number = 0; + ddd12: Array = []; + dddd12: Array = []; + e12: number = 0; + ee12: number = 0; + eee12: Array = []; + eeee12: Array = []; + f12: number = 0; + ff12: number = 0; + fff12: Array = []; + ffff12: Array = []; + g12: boolean = false; + gg12: boolean = false; + ggg12: Array = []; + gggg12: Array = []; + jj12: string = ''; + jjj12: Array = []; + kk12: ObjectA | null = null; + kkk12: Array = []; + l12: Array = []; + llll12: Array = []; + m12: Map = new Map(); + mm12: Map = new Map(); + s12: Set = new Set(); + ssss12: Set = new Set(); + a13: number = 0; + aa13: number = 0; + aaa13: Array = []; + aaaa13: Array = []; + b13: number = 0; + bb13: number = 0; + bbb13: Array = []; + bbbb13: Array = []; + c13: number = 0; + cc13: number = 0; + ccc13: Array = []; + cccc13: Array = []; + d13: number = 0; + dd13: number = 0; + ddd13: Array = []; + dddd13: Array = []; + e13: number = 0; + ee13: number = 0; + eee13: Array = []; + eeee13: Array = []; + f13: number = 0; + ff13: number = 0; + fff13: Array = []; + ffff13: Array = []; + g13: boolean = false; + gg13: boolean = false; + ggg13: Array = []; + gggg13: Array = []; + jj13: string = ''; + jjj13: Array = []; + kk13: ObjectA | null = null; + kkk13: Array = []; + l13: Array = []; + llll13: Array = []; + m13: Map = new Map(); + mm13: Map = new Map(); + s13: Set = new Set(); + ssss13: Set = new Set(); + a14: number = 0; + aa14: number = 0; + aaa14: Array = []; + aaaa14: Array = []; + b14: number = 0; + bb14: number = 0; + bbb14: Array = []; + bbbb14: Array = []; + c14: number = 0; + cc14: number = 0; + ccc14: Array = []; + cccc14: Array = []; + d14: number = 0; + dd14: number = 0; + ddd14: Array = []; + dddd14: Array = []; + e14: number = 0; + ee14: number = 0; + eee14: Array = []; + eeee14: Array = []; + f14: number = 0; + ff14: number = 0; + fff14: Array = []; + ffff14: Array = []; + g14: boolean = false; + gg14: boolean = false; + ggg14: Array = []; + gggg14: Array = []; + jj14: string = ''; + jjj14: Array = []; + kk14: ObjectA | null = null; + kkk14: Array = []; + l14: Array = []; + llll14: Array = []; + m14: Map = new Map(); + mm14: Map = new Map(); + s14: Set = new Set(); + ssss14: Set = new Set(); + a15: number = 0; + aa15: number = 0; + aaa15: Array = []; + aaaa15: Array = []; + b15: number = 0; + bb15: number = 0; + bbb15: Array = []; + bbbb15: Array = []; + c15: number = 0; + cc15: number = 0; + ccc15: Array = []; + cccc15: Array = []; + d15: number = 0; + dd15: number = 0; + ddd15: Array = []; + dddd15: Array = []; + e15: number = 0; + ee15: number = 0; + eee15: Array = []; + eeee15: Array = []; + f15: number = 0; + ff15: number = 0; + fff15: Array = []; + ffff15: Array = []; + g15: boolean = false; + gg15: boolean = false; + ggg15: Array = []; + gggg15: Array = []; + jj15: string = ''; + jjj15: Array = []; + kk15: ObjectA | null = null; + kkk15: Array = []; + l15: Array = []; + llll15: Array = []; + m15: Map = new Map(); + mm15: Map = new Map(); + s15: Set = new Set(); + ssss15: Set = new Set(); + a16: number = 0; + aa16: number = 0; + aaa16: Array = []; + aaaa16: Array = []; + b16: number = 0; + bb16: number = 0; + bbb16: Array = []; + bbbb16: Array = []; + c16: number = 0; + cc16: number = 0; + ccc16: Array = []; + cccc16: Array = []; + d16: number = 0; + dd16: number = 0; + ddd16: Array = []; + dddd16: Array = []; + e16: number = 0; + ee16: number = 0; + eee16: Array = []; + eeee16: Array = []; + f16: number = 0; + ff16: number = 0; + fff16: Array = []; + ffff16: Array = []; + g16: boolean = false; + gg16: boolean = false; + ggg16: Array = []; + gggg16: Array = []; + jj16: string = ''; + jjj16: Array = []; + kk16: ObjectA | null = null; + kkk16: Array = []; + l16: Array = []; + llll16: Array = []; + m16: Map = new Map(); + mm16: Map = new Map(); + s16: Set = new Set(); + ssss16: Set = new Set(); + a17: number = 0; + aa17: number = 0; + aaa17: Array = []; + aaaa17: Array = []; + b17: number = 0; + bb17: number = 0; + bbb17: Array = []; + bbbb17: Array = []; + c17: number = 0; + cc17: number = 0; + ccc17: Array = []; + cccc17: Array = []; + d17: number = 0; + dd17: number = 0; + ddd17: Array = []; + dddd17: Array = []; + e17: number = 0; + ee17: number = 0; + eee17: Array = []; + eeee17: Array = []; + f17: number = 0; + ff17: number = 0; + fff17: Array = []; + ffff17: Array = []; + g17: boolean = false; + gg17: boolean = false; + ggg17: Array = []; + gggg17: Array = []; + jj17: string = ''; + jjj17: Array = []; + kk17: ObjectA | null = null; + kkk17: Array = []; + l17: Array = []; + llll17: Array = []; + m17: Map = new Map(); + mm17: Map = new Map(); + s17: Set = new Set(); + ssss17: Set = new Set(); + a18: number = 0; + aa18: number = 0; + aaa18: Array = []; + aaaa18: Array = []; + b18: number = 0; + bb18: number = 0; + bbb18: Array = []; + bbbb18: Array = []; + c18: number = 0; + cc18: number = 0; + ccc18: Array = []; + cccc18: Array = []; + d18: number = 0; + dd18: number = 0; + ddd18: Array = []; + dddd18: Array = []; + e18: number = 0; + ee18: number = 0; + eee18: Array = []; + eeee18: Array = []; + f18: number = 0; + ff18: number = 0; + fff18: Array = []; + ffff18: Array = []; + g18: boolean = false; + gg18: boolean = false; + ggg18: Array = []; + gggg18: Array = []; + jj18: string = ''; + jjj18: Array = []; + kk18: ObjectA | null = null; + kkk18: Array = []; + l18: Array = []; + llll18: Array = []; + m18: Map = new Map(); + mm18: Map = new Map(); + s18: Set = new Set(); + ssss18: Set = new Set(); + a19: number = 0; + aa19: number = 0; + aaa19: Array = []; + aaaa19: Array = []; + b19: number = 0; + bb19: number = 0; + bbb19: Array = []; + bbbb19: Array = []; + c19: number = 0; + cc19: number = 0; + ccc19: Array = []; + cccc19: Array = []; + d19: number = 0; + dd19: number = 0; + ddd19: Array = []; + dddd19: Array = []; + e19: number = 0; + ee19: number = 0; + eee19: Array = []; + eeee19: Array = []; + f19: number = 0; + ff19: number = 0; + fff19: Array = []; + ffff19: Array = []; + g19: boolean = false; + gg19: boolean = false; + ggg19: Array = []; + gggg19: Array = []; + jj19: string = ''; + jjj19: Array = []; + kk19: ObjectA | null = null; + kkk19: Array = []; + l19: Array = []; + llll19: Array = []; + m19: Map = new Map(); + mm19: Map = new Map(); + s19: Set = new Set(); + ssss19: Set = new Set(); + a20: number = 0; + aa20: number = 0; + aaa20: Array = []; + aaaa20: Array = []; + b20: number = 0; + bb20: number = 0; + bbb20: Array = []; + bbbb20: Array = []; + c20: number = 0; + cc20: number = 0; + ccc20: Array = []; + cccc20: Array = []; + d20: number = 0; + dd20: number = 0; + ddd20: Array = []; + dddd20: Array = []; + e20: number = 0; + ee20: number = 0; + eee20: Array = []; + eeee20: Array = []; + f20: number = 0; + ff20: number = 0; + fff20: Array = []; + ffff20: Array = []; + g20: boolean = false; + gg20: boolean = false; + ggg20: Array = []; + gggg20: Array = []; + jj20: string = ''; + jjj20: Array = []; + kk20: ObjectA | null = null; + kkk20: Array = []; + l20: Array = []; + llll20: Array = []; + m20: Map = new Map(); + mm20: Map = new Map(); + s20: Set = new Set(); + ssss20: Set = new Set(); + a21: number = 0; + aa21: number = 0; + aaa21: Array = []; + aaaa21: Array = []; + b21: number = 0; + bb21: number = 0; + bbb21: Array = []; + bbbb21: Array = []; + c21: number = 0; + cc21: number = 0; + ccc21: Array = []; + cccc21: Array = []; + d21: number = 0; + dd21: number = 0; + ddd21: Array = []; + dddd21: Array = []; + e21: number = 0; + ee21: number = 0; + eee21: Array = []; + eeee21: Array = []; + f21: number = 0; + ff21: number = 0; + fff21: Array = []; + ffff21: Array = []; + g21: boolean = false; + gg21: boolean = false; + ggg21: Array = []; + gggg21: Array = []; + jj21: string = ''; + jjj21: Array = []; + kk21: ObjectA | null = null; + kkk21: Array = []; + l21: Array = []; + llll21: Array = []; + m21: Map = new Map(); + mm21: Map = new Map(); + s21: Set = new Set(); + ssss21: Set = new Set(); + a22: number = 0; + aa22: number = 0; + aaa22: Array = []; + aaaa22: Array = []; + b22: number = 0; + bb22: number = 0; + bbb22: Array = []; + bbbb22: Array = []; + c22: number = 0; + cc22: number = 0; + ccc22: Array = []; + cccc22: Array = []; + d22: number = 0; + dd22: number = 0; + ddd22: Array = []; + dddd22: Array = []; + e22: number = 0; + ee22: number = 0; + eee22: Array = []; + eeee22: Array = []; + f22: number = 0; + ff22: number = 0; + fff22: Array = []; + ffff22: Array = []; + g22: boolean = false; + gg22: boolean = false; + ggg22: Array = []; + gggg22: Array = []; + jj22: string = ''; + jjj22: Array = []; + kk22: ObjectA | null = null; + kkk22: Array = []; + l22: Array = []; + llll22: Array = []; + m22: Map = new Map(); + mm22: Map = new Map(); + s22: Set = new Set(); + ssss22: Set = new Set(); + a23: number = 0; + aa23: number = 0; + aaa23: Array = []; + aaaa23: Array = []; + b23: number = 0; + bb23: number = 0; + bbb23: Array = []; + bbbb23: Array = []; + c23: number = 0; + cc23: number = 0; + ccc23: Array = []; + cccc23: Array = []; + d23: number = 0; + dd23: number = 0; + ddd23: Array = []; + dddd23: Array = []; + e23: number = 0; + ee23: number = 0; + eee23: Array = []; + eeee23: Array = []; + f23: number = 0; + ff23: number = 0; + fff23: Array = []; + ffff23: Array = []; + g23: boolean = false; + gg23: boolean = false; + ggg23: Array = []; + gggg23: Array = []; + jj23: string = ''; + jjj23: Array = []; + kk23: ObjectA | null = null; + kkk23: Array = []; + l23: Array = []; + llll23: Array = []; + m23: Map = new Map(); + mm23: Map = new Map(); + s23: Set = new Set(); + ssss23: Set = new Set(); + a24: number = 0; + aa24: number = 0; + aaa24: Array = []; + aaaa24: Array = []; + b24: number = 0; + bb24: number = 0; + bbb24: Array = []; + bbbb24: Array = []; + c24: number = 0; + cc24: number = 0; + ccc24: Array = []; + cccc24: Array = []; + d24: number = 0; + dd24: number = 0; + ddd24: Array = []; + dddd24: Array = []; + e24: number = 0; + ee24: number = 0; + eee24: Array = []; + eeee24: Array = []; + f24: number = 0; + ff24: number = 0; + fff24: Array = []; + ffff24: Array = []; + g24: boolean = false; + gg24: boolean = false; + ggg24: Array = []; + gggg24: Array = []; + jj24: string = ''; + jjj24: Array = []; + kk24: ObjectA | null = null; + kkk24: Array = []; + l24: Array = []; + llll24: Array = []; + m24: Map = new Map(); + mm24: Map = new Map(); + s24: Set = new Set(); + ssss24: Set = new Set(); + a25: number = 0; + aa25: number = 0; + aaa25: Array = []; + aaaa25: Array = []; + b25: number = 0; + bb25: number = 0; + bbb25: Array = []; + bbbb25: Array = []; + c25: number = 0; + cc25: number = 0; + ccc25: Array = []; + cccc25: Array = []; + d25: number = 0; + dd25: number = 0; + ddd25: Array = []; + dddd25: Array = []; + e25: number = 0; + ee25: number = 0; + eee25: Array = []; + eeee25: Array = []; + f25: number = 0; + ff25: number = 0; + fff25: Array = []; + ffff25: Array = []; + g25: boolean = false; + gg25: boolean = false; + ggg25: Array = []; + gggg25: Array = []; + jj25: string = ''; + jjj25: Array = []; + kk25: ObjectA | null = null; + kkk25: Array = []; + l25: Array = []; + llll25: Array = []; + m25: Map = new Map(); + mm25: Map = new Map(); + s25: Set = new Set(); + ssss25: Set = new Set(); + a26: number = 0; + aa26: number = 0; + aaa26: Array = []; + aaaa26: Array = []; + b26: number = 0; + bb26: number = 0; + bbb26: Array = []; + bbbb26: Array = []; + c26: number = 0; + cc26: number = 0; + ccc26: Array = []; + cccc26: Array = []; + d26: number = 0; + dd26: number = 0; + ddd26: Array = []; + dddd26: Array = []; + e26: number = 0; + ee26: number = 0; + eee26: Array = []; + eeee26: Array = []; + f26: number = 0; + ff26: number = 0; + fff26: Array = []; + ffff26: Array = []; + g26: boolean = false; + gg26: boolean = false; + ggg26: Array = []; + gggg26: Array = []; + jj26: string = ''; + jjj26: Array = []; + kk26: ObjectA | null = null; + kkk26: Array = []; + l26: Array = []; + llll26: Array = []; + m26: Map = new Map(); + mm26: Map = new Map(); + s26: Set = new Set(); + ssss26: Set = new Set(); + a27: number = 0; + aa27: number = 0; + aaa27: Array = []; + aaaa27: Array = []; + b27: number = 0; + bb27: number = 0; + bbb27: Array = []; + bbbb27: Array = []; + c27: number = 0; + cc27: number = 0; + ccc27: Array = []; + cccc27: Array = []; + d27: number = 0; + dd27: number = 0; + ddd27: Array = []; + dddd27: Array = []; + e27: number = 0; + ee27: number = 0; + eee27: Array = []; + eeee27: Array = []; + f27: number = 0; + ff27: number = 0; + fff27: Array = []; + ffff27: Array = []; + g27: boolean = false; + gg27: boolean = false; + ggg27: Array = []; + gggg27: Array = []; + jj27: string = ''; + jjj27: Array = []; + kk27: ObjectA | null = null; + kkk27: Array = []; + l27: Array = []; + llll27: Array = []; + m27: Map = new Map(); + mm27: Map = new Map(); + s27: Set = new Set(); + ssss27: Set = new Set(); + a28: number = 0; + aa28: number = 0; + aaa28: Array = []; + aaaa28: Array = []; + b28: number = 0; + bb28: number = 0; + bbb28: Array = []; + bbbb28: Array = []; + c28: number = 0; + cc28: number = 0; + ccc28: Array = []; + cccc28: Array = []; + d28: number = 0; + dd28: number = 0; + ddd28: Array = []; + dddd28: Array = []; + e28: number = 0; + ee28: number = 0; + eee28: Array = []; + eeee28: Array = []; + f28: number = 0; + ff28: number = 0; + fff28: Array = []; + ffff28: Array = []; + g28: boolean = false; + gg28: boolean = false; + ggg28: Array = []; + gggg28: Array = []; + jj28: string = ''; + jjj28: Array = []; + kk28: ObjectA | null = null; + kkk28: Array = []; + l28: Array = []; + llll28: Array = []; + m28: Map = new Map(); + mm28: Map = new Map(); + s28: Set = new Set(); + ssss28: Set = new Set(); + a29: number = 0; + aa29: number = 0; + aaa29: Array = []; + aaaa29: Array = []; + b29: number = 0; + bb29: number = 0; + bbb29: Array = []; + bbbb29: Array = []; + c29: number = 0; + cc29: number = 0; + ccc29: Array = []; + cccc29: Array = []; + d29: number = 0; + dd29: number = 0; + ddd29: Array = []; + dddd29: Array = []; + e29: number = 0; + ee29: number = 0; + eee29: Array = []; + eeee29: Array = []; + f29: number = 0; + ff29: number = 0; + fff29: Array = []; + ffff29: Array = []; + g29: boolean = false; + gg29: boolean = false; + ggg29: Array = []; + gggg29: Array = []; + jj29: string = ''; + jjj29: Array = []; + kk29: ObjectA | null = null; + kkk29: Array = []; + l29: Array = []; + llll29: Array = []; + m29: Map = new Map(); + mm29: Map = new Map(); + s29: Set = new Set(); + ssss29: Set = new Set(); + a30: number = 0; + aa30: number = 0; + aaa30: Array = []; + aaaa30: Array = []; + b30: number = 0; + bb30: number = 0; + bbb30: Array = []; + bbbb30: Array = []; + c30: number = 0; + cc30: number = 0; + ccc30: Array = []; + cccc30: Array = []; + d30: number = 0; + dd30: number = 0; + ddd30: Array = []; + dddd30: Array = []; + e30: number = 0; + ee30: number = 0; + eee30: Array = []; + eeee30: Array = []; + f30: number = 0; + ff30: number = 0; + fff30: Array = []; + ffff30: Array = []; + g30: boolean = false; + gg30: boolean = false; + ggg30: Array = []; + gggg30: Array = []; + jj30: string = ''; + jjj30: Array = []; + kk30: ObjectA | null = null; + kkk30: Array = []; + l30: Array = []; + llll30: Array = []; + m30: Map = new Map(); + mm30: Map = new Map(); + s30: Set = new Set(); + ssss30: Set = new Set(); + a31: number = 0; + aa31: number = 0; + aaa31: Array = []; + aaaa31: Array = []; + b31: number = 0; + bb31: number = 0; + bbb31: Array = []; + bbbb31: Array = []; + c31: number = 0; + cc31: number = 0; + ccc31: Array = []; + cccc31: Array = []; + d31: number = 0; + dd31: number = 0; + ddd31: Array = []; + dddd31: Array = []; + e31: number = 0; + ee31: number = 0; + eee31: Array = []; + eeee31: Array = []; + f31: number = 0; + ff31: number = 0; + fff31: Array = []; + ffff31: Array = []; + g31: boolean = false; + gg31: boolean = false; + ggg31: Array = []; + gggg31: Array = []; + jj31: string = ''; + jjj31: Array = []; + kk31: ObjectA | null = null; + kkk31: Array = []; + l31: Array = []; + llll31: Array = []; + m31: Map = new Map(); + mm31: Map = new Map(); + s31: Set = new Set(); + ssss31: Set = new Set(); + a32: number = 0; + aa32: number = 0; + aaa32: Array = []; + aaaa32: Array = []; + b32: number = 0; + bb32: number = 0; + bbb32: Array = []; + bbbb32: Array = []; + c32: number = 0; + cc32: number = 0; + ccc32: Array = []; + cccc32: Array = []; + d32: number = 0; + dd32: number = 0; + ddd32: Array = []; + dddd32: Array = []; + e32: number = 0; + ee32: number = 0; + eee32: Array = []; + eeee32: Array = []; + f32: number = 0; + ff32: number = 0; + fff32: Array = []; + ffff32: Array = []; + g32: boolean = false; + gg32: boolean = false; + ggg32: Array = []; + gggg32: Array = []; + jj32: string = ''; + jjj32: Array = []; + kk32: ObjectA | null = null; + kkk32: Array = []; + l32: Array = []; + llll32: Array = []; + m32: Map = new Map(); + mm32: Map = new Map(); + s32: Set = new Set(); + ssss32: Set = new Set(); + a33: number = 0; + aa33: number = 0; + aaa33: Array = []; + aaaa33: Array = []; + b33: number = 0; + bb33: number = 0; + bbb33: Array = []; + bbbb33: Array = []; + c33: number = 0; + cc33: number = 0; + ccc33: Array = []; + cccc33: Array = []; + d33: number = 0; + dd33: number = 0; + ddd33: Array = []; + dddd33: Array = []; + e33: number = 0; + ee33: number = 0; + eee33: Array = []; + eeee33: Array = []; + f33: number = 0; + ff33: number = 0; + fff33: Array = []; + ffff33: Array = []; + g33: boolean = false; + gg33: boolean = false; + ggg33: Array = []; + gggg33: Array = []; + jj33: string = ''; + jjj33: Array = []; + kk33: ObjectA | null = null; + kkk33: Array = []; + l33: Array = []; + llll33: Array = []; + m33: Map = new Map(); + mm33: Map = new Map(); + s33: Set = new Set(); + ssss33: Set = new Set(); + a34: number = 0; + aa34: number = 0; + aaa34: Array = []; + aaaa34: Array = []; + b34: number = 0; + bb34: number = 0; + bbb34: Array = []; + bbbb34: Array = []; + c34: number = 0; + cc34: number = 0; + ccc34: Array = []; + cccc34: Array = []; + d34: number = 0; + dd34: number = 0; + ddd34: Array = []; + dddd34: Array = []; + e34: number = 0; + ee34: number = 0; + eee34: Array = []; + eeee34: Array = []; + f34: number = 0; + ff34: number = 0; + fff34: Array = []; + ffff34: Array = []; + g34: boolean = false; + gg34: boolean = false; + ggg34: Array = []; + gggg34: Array = []; + jj34: string = ''; + jjj34: Array = []; + kk34: ObjectA | null = null; + kkk34: Array = []; + l34: Array = []; + llll34: Array = []; + m34: Map = new Map(); + mm34: Map = new Map(); + s34: Set = new Set(); + ssss34: Set = new Set(); + a35: number = 0; + aa35: number = 0; + aaa35: Array = []; + aaaa35: Array = []; + b35: number = 0; + bb35: number = 0; + bbb35: Array = []; + bbbb35: Array = []; + c35: number = 0; + cc35: number = 0; + ccc35: Array = []; + cccc35: Array = []; + d35: number = 0; + dd35: number = 0; + ddd35: Array = []; + dddd35: Array = []; + e35: number = 0; + ee35: number = 0; + eee35: Array = []; + eeee35: Array = []; + f35: number = 0; + ff35: number = 0; + fff35: Array = []; + ffff35: Array = []; + g35: boolean = false; + gg35: boolean = false; + ggg35: Array = []; + gggg35: Array = []; + jj35: string = ''; + jjj35: Array = []; + kk35: ObjectA | null = null; + kkk35: Array = []; + l35: Array = []; + llll35: Array = []; + m35: Map = new Map(); + mm35: Map = new Map(); + s35: Set = new Set(); + ssss35: Set = new Set(); + a36: number = 0; + aa36: number = 0; + aaa36: Array = []; + aaaa36: Array = []; + b36: number = 0; + bb36: number = 0; + bbb36: Array = []; + bbbb36: Array = []; + c36: number = 0; + cc36: number = 0; + ccc36: Array = []; + cccc36: Array = []; + d36: number = 0; + dd36: number = 0; + ddd36: Array = []; + dddd36: Array = []; + e36: number = 0; + ee36: number = 0; + eee36: Array = []; + eeee36: Array = []; + f36: number = 0; + ff36: number = 0; + fff36: Array = []; + ffff36: Array = []; + g36: boolean = false; + gg36: boolean = false; + ggg36: Array = []; + gggg36: Array = []; + jj36: string = ''; + jjj36: Array = []; + kk36: ObjectA | null = null; + kkk36: Array = []; + l36: Array = []; + llll36: Array = []; + m36: Map = new Map(); + mm36: Map = new Map(); + s36: Set = new Set(); + ssss36: Set = new Set(); + a37: number = 0; + aa37: number = 0; + aaa37: Array = []; + aaaa37: Array = []; + b37: number = 0; + bb37: number = 0; + bbb37: Array = []; + bbbb37: Array = []; + c37: number = 0; + cc37: number = 0; + ccc37: Array = []; + cccc37: Array = []; + d37: number = 0; + dd37: number = 0; + ddd37: Array = []; + dddd37: Array = []; + e37: number = 0; + ee37: number = 0; + eee37: Array = []; + eeee37: Array = []; + f37: number = 0; + ff37: number = 0; + fff37: Array = []; + ffff37: Array = []; + g37: boolean = false; + gg37: boolean = false; + ggg37: Array = []; + gggg37: Array = []; + jj37: string = ''; + jjj37: Array = []; + kk37: ObjectA | null = null; + kkk37: Array = []; + l37: Array = []; + llll37: Array = []; + m37: Map = new Map(); + mm37: Map = new Map(); + s37: Set = new Set(); + ssss37: Set = new Set(); + a38: number = 0; + aa38: number = 0; + aaa38: Array = []; + aaaa38: Array = []; + b38: number = 0; + bb38: number = 0; + bbb38: Array = []; + bbbb38: Array = []; + c38: number = 0; + cc38: number = 0; + ccc38: Array = []; + cccc38: Array = []; + d38: number = 0; + dd38: number = 0; + ddd38: Array = []; + dddd38: Array = []; + e38: number = 0; + ee38: number = 0; + eee38: Array = []; + eeee38: Array = []; + f38: number = 0; + ff38: number = 0; + fff38: Array = []; + ffff38: Array = []; + g38: boolean = false; + gg38: boolean = false; + ggg38: Array = []; + gggg38: Array = []; + jj38: string = ''; + jjj38: Array = []; + kk38: ObjectA | null = null; + kkk38: Array = []; + l38: Array = []; + llll38: Array = []; + m38: Map = new Map(); + mm38: Map = new Map(); + s38: Set = new Set(); + ssss38: Set = new Set(); + a39: number = 0; + aa39: number = 0; + aaa39: Array = []; + aaaa39: Array = []; + b39: number = 0; + bb39: number = 0; + bbb39: Array = []; + bbbb39: Array = []; + c39: number = 0; + cc39: number = 0; + ccc39: Array = []; + cccc39: Array = []; + d39: number = 0; + dd39: number = 0; + ddd39: Array = []; + dddd39: Array = []; + e39: number = 0; + ee39: number = 0; + eee39: Array = []; + eeee39: Array = []; + f39: number = 0; + ff39: number = 0; + fff39: Array = []; + ffff39: Array = []; + g39: boolean = false; + gg39: boolean = false; + ggg39: Array = []; + gggg39: Array = []; + jj39: string = ''; + jjj39: Array = []; + kk39: ObjectA | null = null; + kkk39: Array = []; + l39: Array = []; + llll39: Array = []; + m39: Map = new Map(); + mm39: Map = new Map(); + s39: Set = new Set(); + ssss39: Set = new Set(); + a40: number = 0; + aa40: number = 0; + aaa40: Array = []; + aaaa40: Array = []; + b40: number = 0; + bb40: number = 0; + bbb40: Array = []; + bbbb40: Array = []; + c40: number = 0; + cc40: number = 0; + ccc40: Array = []; + cccc40: Array = []; + d40: number = 0; + dd40: number = 0; + ddd40: Array = []; + dddd40: Array = []; + e40: number = 0; + ee40: number = 0; + eee40: Array = []; + eeee40: Array = []; + f40: number = 0; + ff40: number = 0; + fff40: Array = []; + ffff40: Array = []; + g40: boolean = false; + gg40: boolean = false; + ggg40: Array = []; + gggg40: Array = []; + jj40: string = ''; + jjj40: Array = []; + kk40: ObjectA | null = null; + kkk40: Array = []; + l40: Array = []; + llll40: Array = []; + m40: Map = new Map(); + mm40: Map = new Map(); + s40: Set = new Set(); + ssss40: Set = new Set(); + a41: number = 0; + aa41: number = 0; + aaa41: Array = []; + aaaa41: Array = []; + b41: number = 0; + bb41: number = 0; + bbb41: Array = []; + bbbb41: Array = []; + c41: number = 0; + cc41: number = 0; + ccc41: Array = []; + cccc41: Array = []; + d41: number = 0; + dd41: number = 0; + ddd41: Array = []; + dddd41: Array = []; + e41: number = 0; + ee41: number = 0; + eee41: Array = []; + eeee41: Array = []; + f41: number = 0; + ff41: number = 0; + fff41: Array = []; + ffff41: Array = []; + g41: boolean = false; + gg41: boolean = false; + ggg41: Array = []; + gggg41: Array = []; + jj41: string = ''; + jjj41: Array = []; + kk41: ObjectA | null = null; + kkk41: Array = []; + l41: Array = []; + llll41: Array = []; + m41: Map = new Map(); + mm41: Map = new Map(); + s41: Set = new Set(); + ssss41: Set = new Set(); + a42: number = 0; + aa42: number = 0; + aaa42: Array = []; + aaaa42: Array = []; + b42: number = 0; + bb42: number = 0; + bbb42: Array = []; + bbbb42: Array = []; + c42: number = 0; + cc42: number = 0; + ccc42: Array = []; + cccc42: Array = []; + d42: number = 0; + dd42: number = 0; + ddd42: Array = []; + dddd42: Array = []; + e42: number = 0; + ee42: number = 0; + eee42: Array = []; + eeee42: Array = []; + f42: number = 0; + ff42: number = 0; + fff42: Array = []; + ffff42: Array = []; + g42: boolean = false; + gg42: boolean = false; + ggg42: Array = []; + gggg42: Array = []; + jj42: string = ''; + jjj42: Array = []; + kk42: ObjectA | null = null; + kkk42: Array = []; + l42: Array = []; + llll42: Array = []; + m42: Map = new Map(); + mm42: Map = new Map(); + s42: Set = new Set(); + ssss42: Set = new Set(); + a43: number = 0; + aa43: number = 0; + aaa43: Array = []; + aaaa43: Array = []; + b43: number = 0; + bb43: number = 0; + bbb43: Array = []; + bbbb43: Array = []; + c43: number = 0; + cc43: number = 0; + ccc43: Array = []; + cccc43: Array = []; + d43: number = 0; + dd43: number = 0; + ddd43: Array = []; + dddd43: Array = []; + e43: number = 0; + ee43: number = 0; + eee43: Array = []; + eeee43: Array = []; + f43: number = 0; + ff43: number = 0; + fff43: Array = []; + ffff43: Array = []; + g43: boolean = false; + gg43: boolean = false; + ggg43: Array = []; + gggg43: Array = []; + jj43: string = ''; + jjj43: Array = []; + kk43: ObjectA | null = null; + kkk43: Array = []; + l43: Array = []; + llll43: Array = []; + m43: Map = new Map(); + mm43: Map = new Map(); + s43: Set = new Set(); + ssss43: Set = new Set(); + a44: number = 0; + aa44: number = 0; + aaa44: Array = []; + aaaa44: Array = []; + b44: number = 0; + bb44: number = 0; + bbb44: Array = []; + bbbb44: Array = []; + c44: number = 0; + cc44: number = 0; + ccc44: Array = []; + cccc44: Array = []; + d44: number = 0; + dd44: number = 0; + ddd44: Array = []; + dddd44: Array = []; + e44: number = 0; + ee44: number = 0; + eee44: Array = []; + eeee44: Array = []; + f44: number = 0; + ff44: number = 0; + fff44: Array = []; + ffff44: Array = []; + g44: boolean = false; + gg44: boolean = false; + ggg44: Array = []; + gggg44: Array = []; + jj44: string = ''; + jjj44: Array = []; + kk44: ObjectA | null = null; + kkk44: Array = []; + l44: Array = []; + llll44: Array = []; + m44: Map = new Map(); + mm44: Map = new Map(); + s44: Set = new Set(); + ssss44: Set = new Set(); + a45: number = 0; + aa45: number = 0; + aaa45: Array = []; + aaaa45: Array = []; + b45: number = 0; + bb45: number = 0; + bbb45: Array = []; + bbbb45: Array = []; + c45: number = 0; + cc45: number = 0; + ccc45: Array = []; + cccc45: Array = []; + d45: number = 0; + dd45: number = 0; + ddd45: Array = []; + dddd45: Array = []; + e45: number = 0; + ee45: number = 0; + eee45: Array = []; + eeee45: Array = []; + f45: number = 0; + ff45: number = 0; + fff45: Array = []; + ffff45: Array = []; + g45: boolean = false; + gg45: boolean = false; + ggg45: Array = []; + gggg45: Array = []; + jj45: string = ''; + jjj45: Array = []; + kk45: ObjectA | null = null; + kkk45: Array = []; + l45: Array = []; + llll45: Array = []; + m45: Map = new Map(); + mm45: Map = new Map(); + s45: Set = new Set(); + ssss45: Set = new Set(); + a46: number = 0; + aa46: number = 0; + aaa46: Array = []; + aaaa46: Array = []; + b46: number = 0; + bb46: number = 0; + bbb46: Array = []; + bbbb46: Array = []; + c46: number = 0; + cc46: number = 0; + ccc46: Array = []; + cccc46: Array = []; + d46: number = 0; + dd46: number = 0; + ddd46: Array = []; + dddd46: Array = []; + e46: number = 0; + ee46: number = 0; + eee46: Array = []; + eeee46: Array = []; + f46: number = 0; + ff46: number = 0; + fff46: Array = []; + ffff46: Array = []; + g46: boolean = false; + gg46: boolean = false; + ggg46: Array = []; + gggg46: Array = []; + jj46: string = ''; + jjj46: Array = []; + kk46: ObjectA | null = null; + kkk46: Array = []; + l46: Array = []; + llll46: Array = []; + m46: Map = new Map(); + mm46: Map = new Map(); + s46: Set = new Set(); + ssss46: Set = new Set(); + a47: number = 0; + aa47: number = 0; + aaa47: Array = []; + aaaa47: Array = []; + b47: number = 0; + bb47: number = 0; + bbb47: Array = []; + bbbb47: Array = []; + c47: number = 0; + cc47: number = 0; + ccc47: Array = []; + cccc47: Array = []; + d47: number = 0; + dd47: number = 0; + ddd47: Array = []; + dddd47: Array = []; + e47: number = 0; + ee47: number = 0; + eee47: Array = []; + eeee47: Array = []; + f47: number = 0; + ff47: number = 0; + fff47: Array = []; + ffff47: Array = []; + g47: boolean = false; + gg47: boolean = false; + ggg47: Array = []; + gggg47: Array = []; + jj47: string = ''; + jjj47: Array = []; + kk47: ObjectA | null = null; + kkk47: Array = []; + l47: Array = []; + llll47: Array = []; + m47: Map = new Map(); + mm47: Map = new Map(); + s47: Set = new Set(); + ssss47: Set = new Set(); + a48: number = 0; + aa48: number = 0; + aaa48: Array = []; + aaaa48: Array = []; + b48: number = 0; + bb48: number = 0; + bbb48: Array = []; + bbbb48: Array = []; + c48: number = 0; + cc48: number = 0; + ccc48: Array = []; + cccc48: Array = []; + d48: number = 0; + dd48: number = 0; + ddd48: Array = []; + dddd48: Array = []; + e48: number = 0; + ee48: number = 0; + eee48: Array = []; + eeee48: Array = []; + f48: number = 0; + ff48: number = 0; + fff48: Array = []; + ffff48: Array = []; + g48: boolean = false; + gg48: boolean = false; + ggg48: Array = []; + gggg48: Array = []; + jj48: string = ''; + jjj48: Array = []; + kk48: ObjectA | null = null; + kkk48: Array = []; + l48: Array = []; + llll48: Array = []; + m48: Map = new Map(); + mm48: Map = new Map(); + s48: Set = new Set(); + ssss48: Set = new Set(); + a49: number = 0; + aa49: number = 0; + aaa49: Array = []; + aaaa49: Array = []; + b49: number = 0; + bb49: number = 0; + bbb49: Array = []; + bbbb49: Array = []; + c49: number = 0; + cc49: number = 0; + ccc49: Array = []; + cccc49: Array = []; + d49: number = 0; + dd49: number = 0; + ddd49: Array = []; + dddd49: Array = []; + e49: number = 0; + ee49: number = 0; + eee49: Array = []; + eeee49: Array = []; + f49: number = 0; + ff49: number = 0; + fff49: Array = []; + ffff49: Array = []; + g49: boolean = false; + gg49: boolean = false; + ggg49: Array = []; + gggg49: Array = []; + jj49: string = ''; + jjj49: Array = []; + kk49: ObjectA | null = null; + kkk49: Array = []; + l49: Array = []; + llll49: Array = []; + m49: Map = new Map(); + mm49: Map = new Map(); + s49: Set = new Set(); + ssss49: Set = new Set(); + a50: number = 0; + aa50: number = 0; + aaa50: Array = []; + aaaa50: Array = []; + b50: number = 0; + bb50: number = 0; + bbb50: Array = []; + bbbb50: Array = []; + c50: number = 0; + cc50: number = 0; + ccc50: Array = []; + cccc50: Array = []; + d50: number = 0; + dd50: number = 0; + ddd50: Array = []; + dddd50: Array = []; + e50: number = 0; + ee50: number = 0; + eee50: Array = []; + eeee50: Array = []; + f50: number = 0; + ff50: number = 0; + fff50: Array = []; + ffff50: Array = []; + g50: boolean = false; + gg50: boolean = false; + ggg50: Array = []; + gggg50: Array = []; + jj50: string = ''; + jjj50: Array = []; + kk50: ObjectA | null = null; + kkk50: Array = []; + l50: Array = []; + llll50: Array = []; + m50: Map = new Map(); + mm50: Map = new Map(); + s50: Set = new Set(); + ssss50: Set = new Set(); + a51: number = 0; + aa51: number = 0; + aaa51: Array = []; + aaaa51: Array = []; + b51: number = 0; + bb51: number = 0; + bbb51: Array = []; + bbbb51: Array = []; + c51: number = 0; + cc51: number = 0; + ccc51: Array = []; + cccc51: Array = []; + d51: number = 0; + dd51: number = 0; + ddd51: Array = []; + dddd51: Array = []; + e51: number = 0; + ee51: number = 0; + eee51: Array = []; + eeee51: Array = []; + f51: number = 0; + ff51: number = 0; + fff51: Array = []; + ffff51: Array = []; + g51: boolean = false; + gg51: boolean = false; + ggg51: Array = []; + gggg51: Array = []; + jj51: string = ''; + jjj51: Array = []; + kk51: ObjectA | null = null; + kkk51: Array = []; + l51: Array = []; + llll51: Array = []; + m51: Map = new Map(); + mm51: Map = new Map(); + s51: Set = new Set(); + ssss51: Set = new Set(); + a52: number = 0; + aa52: number = 0; + aaa52: Array = []; + aaaa52: Array = []; + b52: number = 0; + bb52: number = 0; + bbb52: Array = []; + bbbb52: Array = []; + c52: number = 0; + cc52: number = 0; + ccc52: Array = []; + cccc52: Array = []; + d52: number = 0; + dd52: number = 0; + ddd52: Array = []; + dddd52: Array = []; + e52: number = 0; + ee52: number = 0; + eee52: Array = []; + eeee52: Array = []; + f52: number = 0; + ff52: number = 0; + fff52: Array = []; + ffff52: Array = []; + g52: boolean = false; + gg52: boolean = false; + ggg52: Array = []; + gggg52: Array = []; + jj52: string = ''; + jjj52: Array = []; + kk52: ObjectA | null = null; + kkk52: Array = []; + l52: Array = []; + llll52: Array = []; + m52: Map = new Map(); + mm52: Map = new Map(); + s52: Set = new Set(); + ssss52: Set = new Set(); + a53: number = 0; + aa53: number = 0; + aaa53: Array = []; + aaaa53: Array = []; + b53: number = 0; + bb53: number = 0; + bbb53: Array = []; + bbbb53: Array = []; + c53: number = 0; + cc53: number = 0; + ccc53: Array = []; + cccc53: Array = []; + d53: number = 0; + dd53: number = 0; + ddd53: Array = []; + dddd53: Array = []; + e53: number = 0; + ee53: number = 0; + eee53: Array = []; + eeee53: Array = []; + f53: number = 0; + ff53: number = 0; + fff53: Array = []; + ffff53: Array = []; + g53: boolean = false; + gg53: boolean = false; + ggg53: Array = []; + gggg53: Array = []; + jj53: string = ''; + jjj53: Array = []; + kk53: ObjectA | null = null; + kkk53: Array = []; + l53: Array = []; + llll53: Array = []; + m53: Map = new Map(); + mm53: Map = new Map(); + s53: Set = new Set(); + ssss53: Set = new Set(); + a54: number = 0; + aa54: number = 0; + aaa54: Array = []; + aaaa54: Array = []; + b54: number = 0; + bb54: number = 0; + bbb54: Array = []; + bbbb54: Array = []; + c54: number = 0; + cc54: number = 0; + ccc54: Array = []; + cccc54: Array = []; + d54: number = 0; + dd54: number = 0; + ddd54: Array = []; + dddd54: Array = []; + e54: number = 0; + ee54: number = 0; + eee54: Array = []; + eeee54: Array = []; + f54: number = 0; + ff54: number = 0; + fff54: Array = []; + ffff54: Array = []; + g54: boolean = false; + gg54: boolean = false; + ggg54: Array = []; + gggg54: Array = []; + jj54: string = ''; + jjj54: Array = []; + kk54: ObjectA | null = null; + kkk54: Array = []; + l54: Array = []; + llll54: Array = []; + m54: Map = new Map(); + mm54: Map = new Map(); + s54: Set = new Set(); + ssss54: Set = new Set(); + a55: number = 0; + aa55: number = 0; + aaa55: Array = []; + aaaa55: Array = []; + b55: number = 0; + bb55: number = 0; + bbb55: Array = []; + bbbb55: Array = []; + c55: number = 0; + cc55: number = 0; + ccc55: Array = []; + cccc55: Array = []; + d55: number = 0; + dd55: number = 0; + ddd55: Array = []; + dddd55: Array = []; + e55: number = 0; + ee55: number = 0; + eee55: Array = []; + eeee55: Array = []; + f55: number = 0; + ff55: number = 0; + fff55: Array = []; + ffff55: Array = []; + g55: boolean = false; + gg55: boolean = false; + ggg55: Array = []; + gggg55: Array = []; + jj55: string = ''; + jjj55: Array = []; + kk55: ObjectA | null = null; + kkk55: Array = []; + l55: Array = []; + llll55: Array = []; + m55: Map = new Map(); + mm55: Map = new Map(); + s55: Set = new Set(); + ssss55: Set = new Set(); + a56: number = 0; + aa56: number = 0; + aaa56: Array = []; + aaaa56: Array = []; + b56: number = 0; + bb56: number = 0; + bbb56: Array = []; + bbbb56: Array = []; + c56: number = 0; + cc56: number = 0; + ccc56: Array = []; + cccc56: Array = []; + d56: number = 0; + dd56: number = 0; + ddd56: Array = []; + dddd56: Array = []; + e56: number = 0; + ee56: number = 0; + eee56: Array = []; + eeee56: Array = []; + f56: number = 0; + ff56: number = 0; + fff56: Array = []; + ffff56: Array = []; + g56: boolean = false; + gg56: boolean = false; + ggg56: Array = []; + gggg56: Array = []; + jj56: string = ''; + jjj56: Array = []; + kk56: ObjectA | null = null; + kkk56: Array = []; + l56: Array = []; + llll56: Array = []; + m56: Map = new Map(); + mm56: Map = new Map(); + s56: Set = new Set(); + ssss56: Set = new Set(); + a57: number = 0; + aa57: number = 0; + aaa57: Array = []; + aaaa57: Array = []; + b57: number = 0; + bb57: number = 0; + bbb57: Array = []; + bbbb57: Array = []; + c57: number = 0; + cc57: number = 0; + ccc57: Array = []; + cccc57: Array = []; + d57: number = 0; + dd57: number = 0; + ddd57: Array = []; + dddd57: Array = []; + e57: number = 0; + ee57: number = 0; + eee57: Array = []; + eeee57: Array = []; + f57: number = 0; + ff57: number = 0; + fff57: Array = []; + ffff57: Array = []; + g57: boolean = false; + gg57: boolean = false; + ggg57: Array = []; + gggg57: Array = []; + jj57: string = ''; + jjj57: Array = []; + kk57: ObjectA | null = null; + kkk57: Array = []; + l57: Array = []; + llll57: Array = []; + m57: Map = new Map(); + mm57: Map = new Map(); + s57: Set = new Set(); + ssss57: Set = new Set(); + a58: number = 0; + aa58: number = 0; + aaa58: Array = []; + aaaa58: Array = []; + b58: number = 0; + bb58: number = 0; + bbb58: Array = []; + bbbb58: Array = []; + c58: number = 0; + cc58: number = 0; + ccc58: Array = []; + cccc58: Array = []; + d58: number = 0; + dd58: number = 0; + ddd58: Array = []; + dddd58: Array = []; + e58: number = 0; + ee58: number = 0; + eee58: Array = []; + eeee58: Array = []; + f58: number = 0; + ff58: number = 0; + fff58: Array = []; + ffff58: Array = []; + g58: boolean = false; + gg58: boolean = false; + ggg58: Array = []; + gggg58: Array = []; + jj58: string = ''; + jjj58: Array = []; + kk58: ObjectA | null = null; + kkk58: Array = []; + l58: Array = []; + llll58: Array = []; + m58: Map = new Map(); + mm58: Map = new Map(); + s58: Set = new Set(); + ssss58: Set = new Set(); + a59: number = 0; + aa59: number = 0; + aaa59: Array = []; + aaaa59: Array = []; + b59: number = 0; + bb59: number = 0; + bbb59: Array = []; + bbbb59: Array = []; + c59: number = 0; + cc59: number = 0; + ccc59: Array = []; + cccc59: Array = []; + d59: number = 0; + dd59: number = 0; + ddd59: Array = []; + dddd59: Array = []; + e59: number = 0; + ee59: number = 0; + eee59: Array = []; + eeee59: Array = []; + f59: number = 0; + ff59: number = 0; + fff59: Array = []; + ffff59: Array = []; + g59: boolean = false; + gg59: boolean = false; + ggg59: Array = []; + gggg59: Array = []; + jj59: string = ''; + jjj59: Array = []; + kk59: ObjectA | null = null; + kkk59: Array = []; + l59: Array = []; + llll59: Array = []; + m59: Map = new Map(); + mm59: Map = new Map(); + s59: Set = new Set(); + ssss59: Set = new Set(); + a60: number = 0; + aa60: number = 0; + aaa60: Array = []; + aaaa60: Array = []; + b60: number = 0; + bb60: number = 0; + bbb60: Array = []; + bbbb60: Array = []; + c60: number = 0; + cc60: number = 0; + ccc60: Array = []; + cccc60: Array = []; + d60: number = 0; + dd60: number = 0; + ddd60: Array = []; + dddd60: Array = []; + e60: number = 0; + ee60: number = 0; + eee60: Array = []; + eeee60: Array = []; + f60: number = 0; + ff60: number = 0; + fff60: Array = []; + ffff60: Array = []; + g60: boolean = false; + gg60: boolean = false; + ggg60: Array = []; + gggg60: Array = []; + jj60: string = ''; + jjj60: Array = []; + kk60: ObjectA | null = null; + kkk60: Array = []; + l60: Array = []; + llll60: Array = []; + m60: Map = new Map(); + mm60: Map = new Map(); + s60: Set = new Set(); + ssss60: Set = new Set(); + a61: number = 0; + aa61: number = 0; + aaa61: Array = []; + aaaa61: Array = []; + b61: number = 0; + bb61: number = 0; + bbb61: Array = []; + bbbb61: Array = []; + c61: number = 0; + cc61: number = 0; + ccc61: Array = []; + cccc61: Array = []; + d61: number = 0; + dd61: number = 0; + ddd61: Array = []; + dddd61: Array = []; + e61: number = 0; + ee61: number = 0; + eee61: Array = []; + eeee61: Array = []; + f61: number = 0; + ff61: number = 0; + fff61: Array = []; + ffff61: Array = []; + g61: boolean = false; + gg61: boolean = false; + ggg61: Array = []; + gggg61: Array = []; + jj61: string = ''; + jjj61: Array = []; + kk61: ObjectA | null = null; + kkk61: Array = []; + l61: Array = []; + llll61: Array = []; + m61: Map = new Map(); + mm61: Map = new Map(); + s61: Set = new Set(); + ssss61: Set = new Set(); + a62: number = 0; + aa62: number = 0; + aaa62: Array = []; + aaaa62: Array = []; + b62: number = 0; + bb62: number = 0; + bbb62: Array = []; + bbbb62: Array = []; + c62: number = 0; + cc62: number = 0; + ccc62: Array = []; + cccc62: Array = []; + d62: number = 0; + dd62: number = 0; + ddd62: Array = []; + dddd62: Array = []; + e62: number = 0; + ee62: number = 0; + eee62: Array = []; + eeee62: Array = []; + f62: number = 0; + ff62: number = 0; + fff62: Array = []; + ffff62: Array = []; + g62: boolean = false; + gg62: boolean = false; + ggg62: Array = []; + gggg62: Array = []; + jj62: string = ''; + jjj62: Array = []; + kk62: ObjectA | null = null; + kkk62: Array = []; + l62: Array = []; + llll62: Array = []; + m62: Map = new Map(); + mm62: Map = new Map(); + s62: Set = new Set(); + ssss62: Set = new Set(); + a63: number = 0; + aa63: number = 0; + aaa63: Array = []; + aaaa63: Array = []; + b63: number = 0; + bb63: number = 0; + bbb63: Array = []; + bbbb63: Array = []; + c63: number = 0; + cc63: number = 0; + ccc63: Array = []; + cccc63: Array = []; + d63: number = 0; + dd63: number = 0; + ddd63: Array = []; + dddd63: Array = []; + e63: number = 0; + ee63: number = 0; + eee63: Array = []; + eeee63: Array = []; + f63: number = 0; + ff63: number = 0; + fff63: Array = []; + ffff63: Array = []; + g63: boolean = false; + gg63: boolean = false; + ggg63: Array = []; + gggg63: Array = []; + jj63: string = ''; + jjj63: Array = []; + kk63: ObjectA | null = null; + kkk63: Array = []; + l63: Array = []; + llll63: Array = []; + m63: Map = new Map(); + mm63: Map = new Map(); + s63: Set = new Set(); + ssss63: Set = new Set(); + a64: number = 0; + aa64: number = 0; + aaa64: Array = []; + aaaa64: Array = []; + b64: number = 0; + bb64: number = 0; + bbb64: Array = []; + bbbb64: Array = []; + c64: number = 0; + cc64: number = 0; + ccc64: Array = []; + cccc64: Array = []; + d64: number = 0; + dd64: number = 0; + ddd64: Array = []; + dddd64: Array = []; + e64: number = 0; + ee64: number = 0; + eee64: Array = []; + eeee64: Array = []; + f64: number = 0; + ff64: number = 0; + fff64: Array = []; + ffff64: Array = []; + g64: boolean = false; + gg64: boolean = false; + ggg64: Array = []; + gggg64: Array = []; + jj64: string = ''; + jjj64: Array = []; + kk64: ObjectA | null = null; + kkk64: Array = []; + l64: Array = []; + llll64: Array = []; + m64: Map = new Map(); + mm64: Map = new Map(); + s64: Set = new Set(); + ssss64: Set = new Set(); + a65: number = 0; + aa65: number = 0; + aaa65: Array = []; + aaaa65: Array = []; + b65: number = 0; + bb65: number = 0; + bbb65: Array = []; + bbbb65: Array = []; + c65: number = 0; + cc65: number = 0; + ccc65: Array = []; + cccc65: Array = []; + d65: number = 0; + dd65: number = 0; + ddd65: Array = []; + dddd65: Array = []; + e65: number = 0; + ee65: number = 0; + eee65: Array = []; + eeee65: Array = []; + f65: number = 0; + ff65: number = 0; + fff65: Array = []; + ffff65: Array = []; + g65: boolean = false; + gg65: boolean = false; + ggg65: Array = []; + gggg65: Array = []; + jj65: string = ''; + jjj65: Array = []; + kk65: ObjectA | null = null; + kkk65: Array = []; + l65: Array = []; + llll65: Array = []; + m65: Map = new Map(); + mm65: Map = new Map(); + s65: Set = new Set(); + ssss65: Set = new Set(); + a66: number = 0; + aa66: number = 0; + aaa66: Array = []; + aaaa66: Array = []; + b66: number = 0; + bb66: number = 0; + bbb66: Array = []; + bbbb66: Array = []; + c66: number = 0; + cc66: number = 0; + ccc66: Array = []; + cccc66: Array = []; + d66: number = 0; + dd66: number = 0; + ddd66: Array = []; + dddd66: Array = []; + e66: number = 0; + ee66: number = 0; + eee66: Array = []; + eeee66: Array = []; + f66: number = 0; + ff66: number = 0; + fff66: Array = []; + ffff66: Array = []; + g66: boolean = false; + gg66: boolean = false; + ggg66: Array = []; + gggg66: Array = []; + jj66: string = ''; + jjj66: Array = []; + kk66: ObjectA | null = null; + kkk66: Array = []; + l66: Array = []; + llll66: Array = []; + m66: Map = new Map(); + mm66: Map = new Map(); + s66: Set = new Set(); + ssss66: Set = new Set(); + a67: number = 0; + aa67: number = 0; + aaa67: Array = []; + aaaa67: Array = []; + b67: number = 0; + bb67: number = 0; + bbb67: Array = []; + bbbb67: Array = []; + c67: number = 0; + cc67: number = 0; + ccc67: Array = []; + cccc67: Array = []; + d67: number = 0; + dd67: number = 0; + ddd67: Array = []; + dddd67: Array = []; + e67: number = 0; + ee67: number = 0; + eee67: Array = []; + eeee67: Array = []; + f67: number = 0; + ff67: number = 0; + fff67: Array = []; + ffff67: Array = []; + g67: boolean = false; + gg67: boolean = false; + ggg67: Array = []; + gggg67: Array = []; + jj67: string = ''; + jjj67: Array = []; + kk67: ObjectA | null = null; + kkk67: Array = []; + l67: Array = []; + llll67: Array = []; + m67: Map = new Map(); + mm67: Map = new Map(); + s67: Set = new Set(); + ssss67: Set = new Set(); + a68: number = 0; + aa68: number = 0; + aaa68: Array = []; + aaaa68: Array = []; + b68: number = 0; + bb68: number = 0; + bbb68: Array = []; + bbbb68: Array = []; + c68: number = 0; + cc68: number = 0; + ccc68: Array = []; + cccc68: Array = []; + d68: number = 0; + dd68: number = 0; + ddd68: Array = []; + dddd68: Array = []; + e68: number = 0; + ee68: number = 0; + eee68: Array = []; + eeee68: Array = []; + f68: number = 0; + ff68: number = 0; + fff68: Array = []; + ffff68: Array = []; + g68: boolean = false; + gg68: boolean = false; + ggg68: Array = []; + gggg68: Array = []; + jj68: string = ''; + jjj68: Array = []; + kk68: ObjectA | null = null; + kkk68: Array = []; + l68: Array = []; + llll68: Array = []; + m68: Map = new Map(); + mm68: Map = new Map(); + s68: Set = new Set(); + ssss68: Set = new Set(); + a69: number = 0; + aa69: number = 0; + aaa69: Array = []; + aaaa69: Array = []; + b69: number = 0; + bb69: number = 0; + bbb69: Array = []; + bbbb69: Array = []; + c69: number = 0; + cc69: number = 0; + ccc69: Array = []; + cccc69: Array = []; + d69: number = 0; + dd69: number = 0; + ddd69: Array = []; + dddd69: Array = []; + e69: number = 0; + ee69: number = 0; + eee69: Array = []; + eeee69: Array = []; + f69: number = 0; + ff69: number = 0; + fff69: Array = []; + ffff69: Array = []; + g69: boolean = false; + gg69: boolean = false; + ggg69: Array = []; + gggg69: Array = []; + jj69: string = ''; + jjj69: Array = []; + kk69: ObjectA | null = null; + kkk69: Array = []; + l69: Array = []; + llll69: Array = []; + m69: Map = new Map(); + mm69: Map = new Map(); + s69: Set = new Set(); + ssss69: Set = new Set(); + a70: number = 0; + aa70: number = 0; + aaa70: Array = []; + aaaa70: Array = []; + b70: number = 0; + bb70: number = 0; + bbb70: Array = []; + bbbb70: Array = []; + c70: number = 0; + cc70: number = 0; + ccc70: Array = []; + cccc70: Array = []; + d70: number = 0; + dd70: number = 0; + ddd70: Array = []; + dddd70: Array = []; + e70: number = 0; + ee70: number = 0; + eee70: Array = []; + eeee70: Array = []; + f70: number = 0; + ff70: number = 0; + fff70: Array = []; + ffff70: Array = []; + g70: boolean = false; + gg70: boolean = false; + ggg70: Array = []; + gggg70: Array = []; + jj70: string = ''; + jjj70: Array = []; + kk70: ObjectA | null = null; + kkk70: Array = []; + l70: Array = []; + llll70: Array = []; + m70: Map = new Map(); + mm70: Map = new Map(); + s70: Set = new Set(); + ssss70: Set = new Set(); + a71: number = 0; + aa71: number = 0; + aaa71: Array = []; + aaaa71: Array = []; + b71: number = 0; + bb71: number = 0; + bbb71: Array = []; + bbbb71: Array = []; + c71: number = 0; + cc71: number = 0; + ccc71: Array = []; + cccc71: Array = []; + d71: number = 0; + dd71: number = 0; + ddd71: Array = []; + dddd71: Array = []; + e71: number = 0; + ee71: number = 0; + eee71: Array = []; + eeee71: Array = []; + f71: number = 0; + ff71: number = 0; + fff71: Array = []; + ffff71: Array = []; + g71: boolean = false; + gg71: boolean = false; + ggg71: Array = []; + gggg71: Array = []; + jj71: string = ''; + jjj71: Array = []; + kk71: ObjectA | null = null; + kkk71: Array = []; + l71: Array = []; + llll71: Array = []; + m71: Map = new Map(); + mm71: Map = new Map(); + s71: Set = new Set(); + ssss71: Set = new Set(); + a72: number = 0; + aa72: number = 0; + aaa72: Array = []; + aaaa72: Array = []; + b72: number = 0; + bb72: number = 0; + bbb72: Array = []; + bbbb72: Array = []; + c72: number = 0; + cc72: number = 0; + ccc72: Array = []; + cccc72: Array = []; + d72: number = 0; + dd72: number = 0; + ddd72: Array = []; + dddd72: Array = []; + e72: number = 0; + ee72: number = 0; + eee72: Array = []; + eeee72: Array = []; + f72: number = 0; + ff72: number = 0; + fff72: Array = []; + ffff72: Array = []; + g72: boolean = false; + gg72: boolean = false; + ggg72: Array = []; + gggg72: Array = []; + jj72: string = ''; + jjj72: Array = []; + kk72: ObjectA | null = null; + kkk72: Array = []; + l72: Array = []; + llll72: Array = []; + m72: Map = new Map(); + mm72: Map = new Map(); + s72: Set = new Set(); + ssss72: Set = new Set(); + a73: number = 0; + aa73: number = 0; + aaa73: Array = []; + aaaa73: Array = []; + b73: number = 0; + bb73: number = 0; + bbb73: Array = []; + bbbb73: Array = []; + c73: number = 0; + cc73: number = 0; + ccc73: Array = []; + cccc73: Array = []; + d73: number = 0; + dd73: number = 0; + ddd73: Array = []; + dddd73: Array = []; + e73: number = 0; + ee73: number = 0; + eee73: Array = []; + eeee73: Array = []; + f73: number = 0; + ff73: number = 0; + fff73: Array = []; + ffff73: Array = []; + g73: boolean = false; + gg73: boolean = false; + ggg73: Array = []; + gggg73: Array = []; + jj73: string = ''; + jjj73: Array = []; + kk73: ObjectA | null = null; + kkk73: Array = []; + l73: Array = []; + llll73: Array = []; + m73: Map = new Map(); + mm73: Map = new Map(); + s73: Set = new Set(); + ssss73: Set = new Set(); + a74: number = 0; + aa74: number = 0; + aaa74: Array = []; + aaaa74: Array = []; + b74: number = 0; + bb74: number = 0; + bbb74: Array = []; + bbbb74: Array = []; + c74: number = 0; + cc74: number = 0; + ccc74: Array = []; + cccc74: Array = []; + d74: number = 0; + dd74: number = 0; + ddd74: Array = []; + dddd74: Array = []; + e74: number = 0; + ee74: number = 0; + eee74: Array = []; + eeee74: Array = []; + f74: number = 0; + ff74: number = 0; + fff74: Array = []; + ffff74: Array = []; + g74: boolean = false; + gg74: boolean = false; + ggg74: Array = []; + gggg74: Array = []; + jj74: string = ''; + jjj74: Array = []; + kk74: ObjectA | null = null; + kkk74: Array = []; + l74: Array = []; + llll74: Array = []; + m74: Map = new Map(); + mm74: Map = new Map(); + s74: Set = new Set(); + ssss74: Set = new Set(); + a75: number = 0; + aa75: number = 0; + aaa75: Array = []; + aaaa75: Array = []; + b75: number = 0; + bb75: number = 0; + bbb75: Array = []; + bbbb75: Array = []; + c75: number = 0; + cc75: number = 0; + ccc75: Array = []; + cccc75: Array = []; + d75: number = 0; + dd75: number = 0; + ddd75: Array = []; + dddd75: Array = []; + e75: number = 0; + ee75: number = 0; + eee75: Array = []; + eeee75: Array = []; + f75: number = 0; + ff75: number = 0; + fff75: Array = []; + ffff75: Array = []; + g75: boolean = false; + gg75: boolean = false; + ggg75: Array = []; + gggg75: Array = []; + jj75: string = ''; + jjj75: Array = []; + kk75: ObjectA | null = null; + kkk75: Array = []; + l75: Array = []; + llll75: Array = []; + m75: Map = new Map(); + mm75: Map = new Map(); + s75: Set = new Set(); + ssss75: Set = new Set(); + a76: number = 0; + aa76: number = 0; + aaa76: Array = []; + aaaa76: Array = []; + b76: number = 0; + bb76: number = 0; + bbb76: Array = []; + bbbb76: Array = []; + c76: number = 0; + cc76: number = 0; + ccc76: Array = []; + cccc76: Array = []; + d76: number = 0; + dd76: number = 0; + ddd76: Array = []; + dddd76: Array = []; + e76: number = 0; + ee76: number = 0; + eee76: Array = []; + eeee76: Array = []; + f76: number = 0; + ff76: number = 0; + fff76: Array = []; + ffff76: Array = []; + g76: boolean = false; + gg76: boolean = false; + ggg76: Array = []; + gggg76: Array = []; + jj76: string = ''; + jjj76: Array = []; + kk76: ObjectA | null = null; + kkk76: Array = []; + l76: Array = []; + llll76: Array = []; + m76: Map = new Map(); + mm76: Map = new Map(); + s76: Set = new Set(); + ssss76: Set = new Set(); + a77: number = 0; + aa77: number = 0; + aaa77: Array = []; + aaaa77: Array = []; + b77: number = 0; + bb77: number = 0; + bbb77: Array = []; + bbbb77: Array = []; + c77: number = 0; + cc77: number = 0; + ccc77: Array = []; + cccc77: Array = []; + d77: number = 0; + dd77: number = 0; + ddd77: Array = []; + dddd77: Array = []; + e77: number = 0; + ee77: number = 0; + eee77: Array = []; + eeee77: Array = []; + f77: number = 0; + ff77: number = 0; + fff77: Array = []; + ffff77: Array = []; + g77: boolean = false; + gg77: boolean = false; + ggg77: Array = []; + gggg77: Array = []; + jj77: string = ''; + jjj77: Array = []; + kk77: ObjectA | null = null; + kkk77: Array = []; + l77: Array = []; + llll77: Array = []; + m77: Map = new Map(); + mm77: Map = new Map(); + s77: Set = new Set(); + ssss77: Set = new Set(); + a78: number = 0; + aa78: number = 0; + aaa78: Array = []; + aaaa78: Array = []; + b78: number = 0; + bb78: number = 0; + bbb78: Array = []; + bbbb78: Array = []; + c78: number = 0; + cc78: number = 0; + ccc78: Array = []; + cccc78: Array = []; + d78: number = 0; + dd78: number = 0; + ddd78: Array = []; + dddd78: Array = []; + e78: number = 0; + ee78: number = 0; + eee78: Array = []; + eeee78: Array = []; + f78: number = 0; + ff78: number = 0; + fff78: Array = []; + ffff78: Array = []; + g78: boolean = false; + gg78: boolean = false; + ggg78: Array = []; + gggg78: Array = []; + jj78: string = ''; + jjj78: Array = []; + kk78: ObjectA | null = null; + kkk78: Array = []; + l78: Array = []; + llll78: Array = []; + m78: Map = new Map(); + mm78: Map = new Map(); + s78: Set = new Set(); + ssss78: Set = new Set(); + a79: number = 0; + aa79: number = 0; + aaa79: Array = []; + aaaa79: Array = []; + b79: number = 0; + bb79: number = 0; + bbb79: Array = []; + bbbb79: Array = []; + c79: number = 0; + cc79: number = 0; + ccc79: Array = []; + cccc79: Array = []; + d79: number = 0; + dd79: number = 0; + ddd79: Array = []; + dddd79: Array = []; + e79: number = 0; + ee79: number = 0; + eee79: Array = []; + eeee79: Array = []; + f79: number = 0; + ff79: number = 0; + fff79: Array = []; + ffff79: Array = []; + g79: boolean = false; + gg79: boolean = false; + ggg79: Array = []; + gggg79: Array = []; + jj79: string = ''; + jjj79: Array = []; + kk79: ObjectA | null = null; + kkk79: Array = []; + l79: Array = []; + llll79: Array = []; + m79: Map = new Map(); + mm79: Map = new Map(); + s79: Set = new Set(); + ssss79: Set = new Set(); + a80: number = 0; + aa80: number = 0; + aaa80: Array = []; + aaaa80: Array = []; + b80: number = 0; + bb80: number = 0; + bbb80: Array = []; + bbbb80: Array = []; + c80: number = 0; + cc80: number = 0; + ccc80: Array = []; + cccc80: Array = []; + d80: number = 0; + dd80: number = 0; + ddd80: Array = []; + dddd80: Array = []; + e80: number = 0; + ee80: number = 0; + eee80: Array = []; + eeee80: Array = []; + f80: number = 0; + ff80: number = 0; + fff80: Array = []; + ffff80: Array = []; + g80: boolean = false; + gg80: boolean = false; + ggg80: Array = []; + gggg80: Array = []; + jj80: string = ''; + jjj80: Array = []; + kk80: ObjectA | null = null; + kkk80: Array = []; + l80: Array = []; + llll80: Array = []; + m80: Map = new Map(); + mm80: Map = new Map(); + s80: Set = new Set(); + ssss80: Set = new Set(); + a81: number = 0; + aa81: number = 0; + aaa81: Array = []; + aaaa81: Array = []; + b81: number = 0; + bb81: number = 0; + bbb81: Array = []; + bbbb81: Array = []; + c81: number = 0; + cc81: number = 0; + ccc81: Array = []; + cccc81: Array = []; + d81: number = 0; + dd81: number = 0; + ddd81: Array = []; + dddd81: Array = []; + e81: number = 0; + ee81: number = 0; + eee81: Array = []; + eeee81: Array = []; + f81: number = 0; + ff81: number = 0; + fff81: Array = []; + ffff81: Array = []; + g81: boolean = false; + gg81: boolean = false; + ggg81: Array = []; + gggg81: Array = []; + jj81: string = ''; + jjj81: Array = []; + kk81: ObjectA | null = null; + kkk81: Array = []; + l81: Array = []; + llll81: Array = []; + m81: Map = new Map(); + mm81: Map = new Map(); + s81: Set = new Set(); + ssss81: Set = new Set(); + a82: number = 0; + aa82: number = 0; + aaa82: Array = []; + aaaa82: Array = []; + b82: number = 0; + bb82: number = 0; + bbb82: Array = []; + bbbb82: Array = []; + c82: number = 0; + cc82: number = 0; + ccc82: Array = []; + cccc82: Array = []; + d82: number = 0; + dd82: number = 0; + ddd82: Array = []; + dddd82: Array = []; + e82: number = 0; + ee82: number = 0; + eee82: Array = []; + eeee82: Array = []; + f82: number = 0; + ff82: number = 0; + fff82: Array = []; + ffff82: Array = []; + g82: boolean = false; + gg82: boolean = false; + ggg82: Array = []; + gggg82: Array = []; + jj82: string = ''; + jjj82: Array = []; + kk82: ObjectA | null = null; + kkk82: Array = []; + l82: Array = []; + llll82: Array = []; + m82: Map = new Map(); + mm82: Map = new Map(); + s82: Set = new Set(); + ssss82: Set = new Set(); + a83: number = 0; + aa83: number = 0; + aaa83: Array = []; + aaaa83: Array = []; + b83: number = 0; + bb83: number = 0; + bbb83: Array = []; + bbbb83: Array = []; + c83: number = 0; + cc83: number = 0; + ccc83: Array = []; + cccc83: Array = []; + d83: number = 0; + dd83: number = 0; + ddd83: Array = []; + dddd83: Array = []; + e83: number = 0; + ee83: number = 0; + eee83: Array = []; + eeee83: Array = []; + f83: number = 0; + ff83: number = 0; + fff83: Array = []; + ffff83: Array = []; + g83: boolean = false; + gg83: boolean = false; + ggg83: Array = []; + gggg83: Array = []; + jj83: string = ''; + jjj83: Array = []; + kk83: ObjectA | null = null; + kkk83: Array = []; + l83: Array = []; + llll83: Array = []; + m83: Map = new Map(); + mm83: Map = new Map(); + s83: Set = new Set(); + ssss83: Set = new Set(); + a84: number = 0; + aa84: number = 0; + aaa84: Array = []; + aaaa84: Array = []; + b84: number = 0; + bb84: number = 0; + bbb84: Array = []; + bbbb84: Array = []; + c84: number = 0; + cc84: number = 0; + ccc84: Array = []; + cccc84: Array = []; + d84: number = 0; + dd84: number = 0; + ddd84: Array = []; + dddd84: Array = []; + e84: number = 0; + ee84: number = 0; + eee84: Array = []; + eeee84: Array = []; + f84: number = 0; + ff84: number = 0; + fff84: Array = []; + ffff84: Array = []; + g84: boolean = false; + gg84: boolean = false; + ggg84: Array = []; + gggg84: Array = []; + jj84: string = ''; + jjj84: Array = []; + kk84: ObjectA | null = null; + kkk84: Array = []; + l84: Array = []; + llll84: Array = []; + m84: Map = new Map(); + mm84: Map = new Map(); + s84: Set = new Set(); + ssss84: Set = new Set(); + a85: number = 0; + aa85: number = 0; + aaa85: Array = []; + aaaa85: Array = []; + b85: number = 0; + bb85: number = 0; + bbb85: Array = []; + bbbb85: Array = []; + c85: number = 0; + cc85: number = 0; + ccc85: Array = []; + cccc85: Array = []; + d85: number = 0; + dd85: number = 0; + ddd85: Array = []; + dddd85: Array = []; + e85: number = 0; + ee85: number = 0; + eee85: Array = []; + eeee85: Array = []; + f85: number = 0; + ff85: number = 0; + fff85: Array = []; + ffff85: Array = []; + g85: boolean = false; + gg85: boolean = false; + ggg85: Array = []; + gggg85: Array = []; + jj85: string = ''; + jjj85: Array = []; + kk85: ObjectA | null = null; + kkk85: Array = []; + l85: Array = []; + llll85: Array = []; + m85: Map = new Map(); + mm85: Map = new Map(); + s85: Set = new Set(); + ssss85: Set = new Set(); + a86: number = 0; + aa86: number = 0; + aaa86: Array = []; + aaaa86: Array = []; + b86: number = 0; + bb86: number = 0; + bbb86: Array = []; + bbbb86: Array = []; + c86: number = 0; + cc86: number = 0; + ccc86: Array = []; + cccc86: Array = []; + d86: number = 0; + dd86: number = 0; + ddd86: Array = []; + dddd86: Array = []; + e86: number = 0; + ee86: number = 0; + eee86: Array = []; + eeee86: Array = []; + f86: number = 0; + ff86: number = 0; + fff86: Array = []; + ffff86: Array = []; + g86: boolean = false; + gg86: boolean = false; + ggg86: Array = []; + gggg86: Array = []; + jj86: string = ''; + jjj86: Array = []; + kk86: ObjectA | null = null; + kkk86: Array = []; + l86: Array = []; + llll86: Array = []; + m86: Map = new Map(); + mm86: Map = new Map(); + s86: Set = new Set(); + ssss86: Set = new Set(); + a87: number = 0; + aa87: number = 0; + aaa87: Array = []; + aaaa87: Array = []; + b87: number = 0; + bb87: number = 0; + bbb87: Array = []; + bbbb87: Array = []; + c87: number = 0; + cc87: number = 0; + ccc87: Array = []; + cccc87: Array = []; + d87: number = 0; + dd87: number = 0; + ddd87: Array = []; + dddd87: Array = []; + e87: number = 0; + ee87: number = 0; + eee87: Array = []; + eeee87: Array = []; + f87: number = 0; + ff87: number = 0; + fff87: Array = []; + ffff87: Array = []; + g87: boolean = false; + gg87: boolean = false; + ggg87: Array = []; + gggg87: Array = []; + jj87: string = ''; + jjj87: Array = []; + kk87: ObjectA | null = null; + kkk87: Array = []; + l87: Array = []; + llll87: Array = []; + m87: Map = new Map(); + mm87: Map = new Map(); + s87: Set = new Set(); + ssss87: Set = new Set(); + a88: number = 0; + aa88: number = 0; + aaa88: Array = []; + aaaa88: Array = []; + b88: number = 0; + bb88: number = 0; + bbb88: Array = []; + bbbb88: Array = []; + c88: number = 0; + cc88: number = 0; + ccc88: Array = []; + cccc88: Array = []; + d88: number = 0; + dd88: number = 0; + ddd88: Array = []; + dddd88: Array = []; + e88: number = 0; + ee88: number = 0; + eee88: Array = []; + eeee88: Array = []; + f88: number = 0; + ff88: number = 0; + fff88: Array = []; + ffff88: Array = []; + g88: boolean = false; + gg88: boolean = false; + ggg88: Array = []; + gggg88: Array = []; + jj88: string = ''; + jjj88: Array = []; + kk88: ObjectA | null = null; + kkk88: Array = []; + l88: Array = []; + llll88: Array = []; + m88: Map = new Map(); + mm88: Map = new Map(); + s88: Set = new Set(); + ssss88: Set = new Set(); + + static PROTOCOL_ID: number = 1; + + protocolId(): number { + return VeryBigObject.PROTOCOL_ID; + } + + static write(buffer: any, packet: VeryBigObject | null) { + if (packet === null) { + buffer.writeInt(0); + return; + } + buffer.writeInt(-1); + buffer.writeByte(packet.a1); + buffer.writeByte(packet.a10); + buffer.writeByte(packet.a11); + buffer.writeByte(packet.a12); + buffer.writeByte(packet.a13); + buffer.writeByte(packet.a14); + buffer.writeByte(packet.a15); + buffer.writeByte(packet.a16); + buffer.writeByte(packet.a17); + buffer.writeByte(packet.a18); + buffer.writeByte(packet.a19); + buffer.writeByte(packet.a2); + buffer.writeByte(packet.a20); + buffer.writeByte(packet.a21); + buffer.writeByte(packet.a22); + buffer.writeByte(packet.a23); + buffer.writeByte(packet.a24); + buffer.writeByte(packet.a25); + buffer.writeByte(packet.a26); + buffer.writeByte(packet.a27); + buffer.writeByte(packet.a28); + buffer.writeByte(packet.a29); + buffer.writeByte(packet.a3); + buffer.writeByte(packet.a30); + buffer.writeByte(packet.a31); + buffer.writeByte(packet.a32); + buffer.writeByte(packet.a33); + buffer.writeByte(packet.a34); + buffer.writeByte(packet.a35); + buffer.writeByte(packet.a36); + buffer.writeByte(packet.a37); + buffer.writeByte(packet.a38); + buffer.writeByte(packet.a39); + buffer.writeByte(packet.a4); + buffer.writeByte(packet.a40); + buffer.writeByte(packet.a41); + buffer.writeByte(packet.a42); + buffer.writeByte(packet.a43); + buffer.writeByte(packet.a44); + buffer.writeByte(packet.a45); + buffer.writeByte(packet.a46); + buffer.writeByte(packet.a47); + buffer.writeByte(packet.a48); + buffer.writeByte(packet.a49); + buffer.writeByte(packet.a5); + buffer.writeByte(packet.a50); + buffer.writeByte(packet.a51); + buffer.writeByte(packet.a52); + buffer.writeByte(packet.a53); + buffer.writeByte(packet.a54); + buffer.writeByte(packet.a55); + buffer.writeByte(packet.a56); + buffer.writeByte(packet.a57); + buffer.writeByte(packet.a58); + buffer.writeByte(packet.a59); + buffer.writeByte(packet.a6); + buffer.writeByte(packet.a60); + buffer.writeByte(packet.a61); + buffer.writeByte(packet.a62); + buffer.writeByte(packet.a63); + buffer.writeByte(packet.a64); + buffer.writeByte(packet.a65); + buffer.writeByte(packet.a66); + buffer.writeByte(packet.a67); + buffer.writeByte(packet.a68); + buffer.writeByte(packet.a69); + buffer.writeByte(packet.a7); + buffer.writeByte(packet.a70); + buffer.writeByte(packet.a71); + buffer.writeByte(packet.a72); + buffer.writeByte(packet.a73); + buffer.writeByte(packet.a74); + buffer.writeByte(packet.a75); + buffer.writeByte(packet.a76); + buffer.writeByte(packet.a77); + buffer.writeByte(packet.a78); + buffer.writeByte(packet.a79); + buffer.writeByte(packet.a8); + buffer.writeByte(packet.a80); + buffer.writeByte(packet.a81); + buffer.writeByte(packet.a82); + buffer.writeByte(packet.a83); + buffer.writeByte(packet.a84); + buffer.writeByte(packet.a85); + buffer.writeByte(packet.a86); + buffer.writeByte(packet.a87); + buffer.writeByte(packet.a88); + buffer.writeByte(packet.a9); + buffer.writeByte(packet.aa1); + buffer.writeByte(packet.aa10); + buffer.writeByte(packet.aa11); + buffer.writeByte(packet.aa12); + buffer.writeByte(packet.aa13); + buffer.writeByte(packet.aa14); + buffer.writeByte(packet.aa15); + buffer.writeByte(packet.aa16); + buffer.writeByte(packet.aa17); + buffer.writeByte(packet.aa18); + buffer.writeByte(packet.aa19); + buffer.writeByte(packet.aa2); + buffer.writeByte(packet.aa20); + buffer.writeByte(packet.aa21); + buffer.writeByte(packet.aa22); + buffer.writeByte(packet.aa23); + buffer.writeByte(packet.aa24); + buffer.writeByte(packet.aa25); + buffer.writeByte(packet.aa26); + buffer.writeByte(packet.aa27); + buffer.writeByte(packet.aa28); + buffer.writeByte(packet.aa29); + buffer.writeByte(packet.aa3); + buffer.writeByte(packet.aa30); + buffer.writeByte(packet.aa31); + buffer.writeByte(packet.aa32); + buffer.writeByte(packet.aa33); + buffer.writeByte(packet.aa34); + buffer.writeByte(packet.aa35); + buffer.writeByte(packet.aa36); + buffer.writeByte(packet.aa37); + buffer.writeByte(packet.aa38); + buffer.writeByte(packet.aa39); + buffer.writeByte(packet.aa4); + buffer.writeByte(packet.aa40); + buffer.writeByte(packet.aa41); + buffer.writeByte(packet.aa42); + buffer.writeByte(packet.aa43); + buffer.writeByte(packet.aa44); + buffer.writeByte(packet.aa45); + buffer.writeByte(packet.aa46); + buffer.writeByte(packet.aa47); + buffer.writeByte(packet.aa48); + buffer.writeByte(packet.aa49); + buffer.writeByte(packet.aa5); + buffer.writeByte(packet.aa50); + buffer.writeByte(packet.aa51); + buffer.writeByte(packet.aa52); + buffer.writeByte(packet.aa53); + buffer.writeByte(packet.aa54); + buffer.writeByte(packet.aa55); + buffer.writeByte(packet.aa56); + buffer.writeByte(packet.aa57); + buffer.writeByte(packet.aa58); + buffer.writeByte(packet.aa59); + buffer.writeByte(packet.aa6); + buffer.writeByte(packet.aa60); + buffer.writeByte(packet.aa61); + buffer.writeByte(packet.aa62); + buffer.writeByte(packet.aa63); + buffer.writeByte(packet.aa64); + buffer.writeByte(packet.aa65); + buffer.writeByte(packet.aa66); + buffer.writeByte(packet.aa67); + buffer.writeByte(packet.aa68); + buffer.writeByte(packet.aa69); + buffer.writeByte(packet.aa7); + buffer.writeByte(packet.aa70); + buffer.writeByte(packet.aa71); + buffer.writeByte(packet.aa72); + buffer.writeByte(packet.aa73); + buffer.writeByte(packet.aa74); + buffer.writeByte(packet.aa75); + buffer.writeByte(packet.aa76); + buffer.writeByte(packet.aa77); + buffer.writeByte(packet.aa78); + buffer.writeByte(packet.aa79); + buffer.writeByte(packet.aa8); + buffer.writeByte(packet.aa80); + buffer.writeByte(packet.aa81); + buffer.writeByte(packet.aa82); + buffer.writeByte(packet.aa83); + buffer.writeByte(packet.aa84); + buffer.writeByte(packet.aa85); + buffer.writeByte(packet.aa86); + buffer.writeByte(packet.aa87); + buffer.writeByte(packet.aa88); + buffer.writeByte(packet.aa9); + buffer.writeByteArray(packet.aaa1); + buffer.writeByteArray(packet.aaa10); + buffer.writeByteArray(packet.aaa11); + buffer.writeByteArray(packet.aaa12); + buffer.writeByteArray(packet.aaa13); + buffer.writeByteArray(packet.aaa14); + buffer.writeByteArray(packet.aaa15); + buffer.writeByteArray(packet.aaa16); + buffer.writeByteArray(packet.aaa17); + buffer.writeByteArray(packet.aaa18); + buffer.writeByteArray(packet.aaa19); + buffer.writeByteArray(packet.aaa2); + buffer.writeByteArray(packet.aaa20); + buffer.writeByteArray(packet.aaa21); + buffer.writeByteArray(packet.aaa22); + buffer.writeByteArray(packet.aaa23); + buffer.writeByteArray(packet.aaa24); + buffer.writeByteArray(packet.aaa25); + buffer.writeByteArray(packet.aaa26); + buffer.writeByteArray(packet.aaa27); + buffer.writeByteArray(packet.aaa28); + buffer.writeByteArray(packet.aaa29); + buffer.writeByteArray(packet.aaa3); + buffer.writeByteArray(packet.aaa30); + buffer.writeByteArray(packet.aaa31); + buffer.writeByteArray(packet.aaa32); + buffer.writeByteArray(packet.aaa33); + buffer.writeByteArray(packet.aaa34); + buffer.writeByteArray(packet.aaa35); + buffer.writeByteArray(packet.aaa36); + buffer.writeByteArray(packet.aaa37); + buffer.writeByteArray(packet.aaa38); + buffer.writeByteArray(packet.aaa39); + buffer.writeByteArray(packet.aaa4); + buffer.writeByteArray(packet.aaa40); + buffer.writeByteArray(packet.aaa41); + buffer.writeByteArray(packet.aaa42); + buffer.writeByteArray(packet.aaa43); + buffer.writeByteArray(packet.aaa44); + buffer.writeByteArray(packet.aaa45); + buffer.writeByteArray(packet.aaa46); + buffer.writeByteArray(packet.aaa47); + buffer.writeByteArray(packet.aaa48); + buffer.writeByteArray(packet.aaa49); + buffer.writeByteArray(packet.aaa5); + buffer.writeByteArray(packet.aaa50); + buffer.writeByteArray(packet.aaa51); + buffer.writeByteArray(packet.aaa52); + buffer.writeByteArray(packet.aaa53); + buffer.writeByteArray(packet.aaa54); + buffer.writeByteArray(packet.aaa55); + buffer.writeByteArray(packet.aaa56); + buffer.writeByteArray(packet.aaa57); + buffer.writeByteArray(packet.aaa58); + buffer.writeByteArray(packet.aaa59); + buffer.writeByteArray(packet.aaa6); + buffer.writeByteArray(packet.aaa60); + buffer.writeByteArray(packet.aaa61); + buffer.writeByteArray(packet.aaa62); + buffer.writeByteArray(packet.aaa63); + buffer.writeByteArray(packet.aaa64); + buffer.writeByteArray(packet.aaa65); + buffer.writeByteArray(packet.aaa66); + buffer.writeByteArray(packet.aaa67); + buffer.writeByteArray(packet.aaa68); + buffer.writeByteArray(packet.aaa69); + buffer.writeByteArray(packet.aaa7); + buffer.writeByteArray(packet.aaa70); + buffer.writeByteArray(packet.aaa71); + buffer.writeByteArray(packet.aaa72); + buffer.writeByteArray(packet.aaa73); + buffer.writeByteArray(packet.aaa74); + buffer.writeByteArray(packet.aaa75); + buffer.writeByteArray(packet.aaa76); + buffer.writeByteArray(packet.aaa77); + buffer.writeByteArray(packet.aaa78); + buffer.writeByteArray(packet.aaa79); + buffer.writeByteArray(packet.aaa8); + buffer.writeByteArray(packet.aaa80); + buffer.writeByteArray(packet.aaa81); + buffer.writeByteArray(packet.aaa82); + buffer.writeByteArray(packet.aaa83); + buffer.writeByteArray(packet.aaa84); + buffer.writeByteArray(packet.aaa85); + buffer.writeByteArray(packet.aaa86); + buffer.writeByteArray(packet.aaa87); + buffer.writeByteArray(packet.aaa88); + buffer.writeByteArray(packet.aaa9); + buffer.writeByteArray(packet.aaaa1); + buffer.writeByteArray(packet.aaaa10); + buffer.writeByteArray(packet.aaaa11); + buffer.writeByteArray(packet.aaaa12); + buffer.writeByteArray(packet.aaaa13); + buffer.writeByteArray(packet.aaaa14); + buffer.writeByteArray(packet.aaaa15); + buffer.writeByteArray(packet.aaaa16); + buffer.writeByteArray(packet.aaaa17); + buffer.writeByteArray(packet.aaaa18); + buffer.writeByteArray(packet.aaaa19); + buffer.writeByteArray(packet.aaaa2); + buffer.writeByteArray(packet.aaaa20); + buffer.writeByteArray(packet.aaaa21); + buffer.writeByteArray(packet.aaaa22); + buffer.writeByteArray(packet.aaaa23); + buffer.writeByteArray(packet.aaaa24); + buffer.writeByteArray(packet.aaaa25); + buffer.writeByteArray(packet.aaaa26); + buffer.writeByteArray(packet.aaaa27); + buffer.writeByteArray(packet.aaaa28); + buffer.writeByteArray(packet.aaaa29); + buffer.writeByteArray(packet.aaaa3); + buffer.writeByteArray(packet.aaaa30); + buffer.writeByteArray(packet.aaaa31); + buffer.writeByteArray(packet.aaaa32); + buffer.writeByteArray(packet.aaaa33); + buffer.writeByteArray(packet.aaaa34); + buffer.writeByteArray(packet.aaaa35); + buffer.writeByteArray(packet.aaaa36); + buffer.writeByteArray(packet.aaaa37); + buffer.writeByteArray(packet.aaaa38); + buffer.writeByteArray(packet.aaaa39); + buffer.writeByteArray(packet.aaaa4); + buffer.writeByteArray(packet.aaaa40); + buffer.writeByteArray(packet.aaaa41); + buffer.writeByteArray(packet.aaaa42); + buffer.writeByteArray(packet.aaaa43); + buffer.writeByteArray(packet.aaaa44); + buffer.writeByteArray(packet.aaaa45); + buffer.writeByteArray(packet.aaaa46); + buffer.writeByteArray(packet.aaaa47); + buffer.writeByteArray(packet.aaaa48); + buffer.writeByteArray(packet.aaaa49); + buffer.writeByteArray(packet.aaaa5); + buffer.writeByteArray(packet.aaaa50); + buffer.writeByteArray(packet.aaaa51); + buffer.writeByteArray(packet.aaaa52); + buffer.writeByteArray(packet.aaaa53); + buffer.writeByteArray(packet.aaaa54); + buffer.writeByteArray(packet.aaaa55); + buffer.writeByteArray(packet.aaaa56); + buffer.writeByteArray(packet.aaaa57); + buffer.writeByteArray(packet.aaaa58); + buffer.writeByteArray(packet.aaaa59); + buffer.writeByteArray(packet.aaaa6); + buffer.writeByteArray(packet.aaaa60); + buffer.writeByteArray(packet.aaaa61); + buffer.writeByteArray(packet.aaaa62); + buffer.writeByteArray(packet.aaaa63); + buffer.writeByteArray(packet.aaaa64); + buffer.writeByteArray(packet.aaaa65); + buffer.writeByteArray(packet.aaaa66); + buffer.writeByteArray(packet.aaaa67); + buffer.writeByteArray(packet.aaaa68); + buffer.writeByteArray(packet.aaaa69); + buffer.writeByteArray(packet.aaaa7); + buffer.writeByteArray(packet.aaaa70); + buffer.writeByteArray(packet.aaaa71); + buffer.writeByteArray(packet.aaaa72); + buffer.writeByteArray(packet.aaaa73); + buffer.writeByteArray(packet.aaaa74); + buffer.writeByteArray(packet.aaaa75); + buffer.writeByteArray(packet.aaaa76); + buffer.writeByteArray(packet.aaaa77); + buffer.writeByteArray(packet.aaaa78); + buffer.writeByteArray(packet.aaaa79); + buffer.writeByteArray(packet.aaaa8); + buffer.writeByteArray(packet.aaaa80); + buffer.writeByteArray(packet.aaaa81); + buffer.writeByteArray(packet.aaaa82); + buffer.writeByteArray(packet.aaaa83); + buffer.writeByteArray(packet.aaaa84); + buffer.writeByteArray(packet.aaaa85); + buffer.writeByteArray(packet.aaaa86); + buffer.writeByteArray(packet.aaaa87); + buffer.writeByteArray(packet.aaaa88); + buffer.writeByteArray(packet.aaaa9); + buffer.writeShort(packet.b1); + buffer.writeShort(packet.b10); + buffer.writeShort(packet.b11); + buffer.writeShort(packet.b12); + buffer.writeShort(packet.b13); + buffer.writeShort(packet.b14); + buffer.writeShort(packet.b15); + buffer.writeShort(packet.b16); + buffer.writeShort(packet.b17); + buffer.writeShort(packet.b18); + buffer.writeShort(packet.b19); + buffer.writeShort(packet.b2); + buffer.writeShort(packet.b20); + buffer.writeShort(packet.b21); + buffer.writeShort(packet.b22); + buffer.writeShort(packet.b23); + buffer.writeShort(packet.b24); + buffer.writeShort(packet.b25); + buffer.writeShort(packet.b26); + buffer.writeShort(packet.b27); + buffer.writeShort(packet.b28); + buffer.writeShort(packet.b29); + buffer.writeShort(packet.b3); + buffer.writeShort(packet.b30); + buffer.writeShort(packet.b31); + buffer.writeShort(packet.b32); + buffer.writeShort(packet.b33); + buffer.writeShort(packet.b34); + buffer.writeShort(packet.b35); + buffer.writeShort(packet.b36); + buffer.writeShort(packet.b37); + buffer.writeShort(packet.b38); + buffer.writeShort(packet.b39); + buffer.writeShort(packet.b4); + buffer.writeShort(packet.b40); + buffer.writeShort(packet.b41); + buffer.writeShort(packet.b42); + buffer.writeShort(packet.b43); + buffer.writeShort(packet.b44); + buffer.writeShort(packet.b45); + buffer.writeShort(packet.b46); + buffer.writeShort(packet.b47); + buffer.writeShort(packet.b48); + buffer.writeShort(packet.b49); + buffer.writeShort(packet.b5); + buffer.writeShort(packet.b50); + buffer.writeShort(packet.b51); + buffer.writeShort(packet.b52); + buffer.writeShort(packet.b53); + buffer.writeShort(packet.b54); + buffer.writeShort(packet.b55); + buffer.writeShort(packet.b56); + buffer.writeShort(packet.b57); + buffer.writeShort(packet.b58); + buffer.writeShort(packet.b59); + buffer.writeShort(packet.b6); + buffer.writeShort(packet.b60); + buffer.writeShort(packet.b61); + buffer.writeShort(packet.b62); + buffer.writeShort(packet.b63); + buffer.writeShort(packet.b64); + buffer.writeShort(packet.b65); + buffer.writeShort(packet.b66); + buffer.writeShort(packet.b67); + buffer.writeShort(packet.b68); + buffer.writeShort(packet.b69); + buffer.writeShort(packet.b7); + buffer.writeShort(packet.b70); + buffer.writeShort(packet.b71); + buffer.writeShort(packet.b72); + buffer.writeShort(packet.b73); + buffer.writeShort(packet.b74); + buffer.writeShort(packet.b75); + buffer.writeShort(packet.b76); + buffer.writeShort(packet.b77); + buffer.writeShort(packet.b78); + buffer.writeShort(packet.b79); + buffer.writeShort(packet.b8); + buffer.writeShort(packet.b80); + buffer.writeShort(packet.b81); + buffer.writeShort(packet.b82); + buffer.writeShort(packet.b83); + buffer.writeShort(packet.b84); + buffer.writeShort(packet.b85); + buffer.writeShort(packet.b86); + buffer.writeShort(packet.b87); + buffer.writeShort(packet.b88); + buffer.writeShort(packet.b9); + buffer.writeShort(packet.bb1); + buffer.writeShort(packet.bb10); + buffer.writeShort(packet.bb11); + buffer.writeShort(packet.bb12); + buffer.writeShort(packet.bb13); + buffer.writeShort(packet.bb14); + buffer.writeShort(packet.bb15); + buffer.writeShort(packet.bb16); + buffer.writeShort(packet.bb17); + buffer.writeShort(packet.bb18); + buffer.writeShort(packet.bb19); + buffer.writeShort(packet.bb2); + buffer.writeShort(packet.bb20); + buffer.writeShort(packet.bb21); + buffer.writeShort(packet.bb22); + buffer.writeShort(packet.bb23); + buffer.writeShort(packet.bb24); + buffer.writeShort(packet.bb25); + buffer.writeShort(packet.bb26); + buffer.writeShort(packet.bb27); + buffer.writeShort(packet.bb28); + buffer.writeShort(packet.bb29); + buffer.writeShort(packet.bb3); + buffer.writeShort(packet.bb30); + buffer.writeShort(packet.bb31); + buffer.writeShort(packet.bb32); + buffer.writeShort(packet.bb33); + buffer.writeShort(packet.bb34); + buffer.writeShort(packet.bb35); + buffer.writeShort(packet.bb36); + buffer.writeShort(packet.bb37); + buffer.writeShort(packet.bb38); + buffer.writeShort(packet.bb39); + buffer.writeShort(packet.bb4); + buffer.writeShort(packet.bb40); + buffer.writeShort(packet.bb41); + buffer.writeShort(packet.bb42); + buffer.writeShort(packet.bb43); + buffer.writeShort(packet.bb44); + buffer.writeShort(packet.bb45); + buffer.writeShort(packet.bb46); + buffer.writeShort(packet.bb47); + buffer.writeShort(packet.bb48); + buffer.writeShort(packet.bb49); + buffer.writeShort(packet.bb5); + buffer.writeShort(packet.bb50); + buffer.writeShort(packet.bb51); + buffer.writeShort(packet.bb52); + buffer.writeShort(packet.bb53); + buffer.writeShort(packet.bb54); + buffer.writeShort(packet.bb55); + buffer.writeShort(packet.bb56); + buffer.writeShort(packet.bb57); + buffer.writeShort(packet.bb58); + buffer.writeShort(packet.bb59); + buffer.writeShort(packet.bb6); + buffer.writeShort(packet.bb60); + buffer.writeShort(packet.bb61); + buffer.writeShort(packet.bb62); + buffer.writeShort(packet.bb63); + buffer.writeShort(packet.bb64); + buffer.writeShort(packet.bb65); + buffer.writeShort(packet.bb66); + buffer.writeShort(packet.bb67); + buffer.writeShort(packet.bb68); + buffer.writeShort(packet.bb69); + buffer.writeShort(packet.bb7); + buffer.writeShort(packet.bb70); + buffer.writeShort(packet.bb71); + buffer.writeShort(packet.bb72); + buffer.writeShort(packet.bb73); + buffer.writeShort(packet.bb74); + buffer.writeShort(packet.bb75); + buffer.writeShort(packet.bb76); + buffer.writeShort(packet.bb77); + buffer.writeShort(packet.bb78); + buffer.writeShort(packet.bb79); + buffer.writeShort(packet.bb8); + buffer.writeShort(packet.bb80); + buffer.writeShort(packet.bb81); + buffer.writeShort(packet.bb82); + buffer.writeShort(packet.bb83); + buffer.writeShort(packet.bb84); + buffer.writeShort(packet.bb85); + buffer.writeShort(packet.bb86); + buffer.writeShort(packet.bb87); + buffer.writeShort(packet.bb88); + buffer.writeShort(packet.bb9); + buffer.writeShortArray(packet.bbb1); + buffer.writeShortArray(packet.bbb10); + buffer.writeShortArray(packet.bbb11); + buffer.writeShortArray(packet.bbb12); + buffer.writeShortArray(packet.bbb13); + buffer.writeShortArray(packet.bbb14); + buffer.writeShortArray(packet.bbb15); + buffer.writeShortArray(packet.bbb16); + buffer.writeShortArray(packet.bbb17); + buffer.writeShortArray(packet.bbb18); + buffer.writeShortArray(packet.bbb19); + buffer.writeShortArray(packet.bbb2); + buffer.writeShortArray(packet.bbb20); + buffer.writeShortArray(packet.bbb21); + buffer.writeShortArray(packet.bbb22); + buffer.writeShortArray(packet.bbb23); + buffer.writeShortArray(packet.bbb24); + buffer.writeShortArray(packet.bbb25); + buffer.writeShortArray(packet.bbb26); + buffer.writeShortArray(packet.bbb27); + buffer.writeShortArray(packet.bbb28); + buffer.writeShortArray(packet.bbb29); + buffer.writeShortArray(packet.bbb3); + buffer.writeShortArray(packet.bbb30); + buffer.writeShortArray(packet.bbb31); + buffer.writeShortArray(packet.bbb32); + buffer.writeShortArray(packet.bbb33); + buffer.writeShortArray(packet.bbb34); + buffer.writeShortArray(packet.bbb35); + buffer.writeShortArray(packet.bbb36); + buffer.writeShortArray(packet.bbb37); + buffer.writeShortArray(packet.bbb38); + buffer.writeShortArray(packet.bbb39); + buffer.writeShortArray(packet.bbb4); + buffer.writeShortArray(packet.bbb40); + buffer.writeShortArray(packet.bbb41); + buffer.writeShortArray(packet.bbb42); + buffer.writeShortArray(packet.bbb43); + buffer.writeShortArray(packet.bbb44); + buffer.writeShortArray(packet.bbb45); + buffer.writeShortArray(packet.bbb46); + buffer.writeShortArray(packet.bbb47); + buffer.writeShortArray(packet.bbb48); + buffer.writeShortArray(packet.bbb49); + buffer.writeShortArray(packet.bbb5); + buffer.writeShortArray(packet.bbb50); + buffer.writeShortArray(packet.bbb51); + buffer.writeShortArray(packet.bbb52); + buffer.writeShortArray(packet.bbb53); + buffer.writeShortArray(packet.bbb54); + buffer.writeShortArray(packet.bbb55); + buffer.writeShortArray(packet.bbb56); + buffer.writeShortArray(packet.bbb57); + buffer.writeShortArray(packet.bbb58); + buffer.writeShortArray(packet.bbb59); + buffer.writeShortArray(packet.bbb6); + buffer.writeShortArray(packet.bbb60); + buffer.writeShortArray(packet.bbb61); + buffer.writeShortArray(packet.bbb62); + buffer.writeShortArray(packet.bbb63); + buffer.writeShortArray(packet.bbb64); + buffer.writeShortArray(packet.bbb65); + buffer.writeShortArray(packet.bbb66); + buffer.writeShortArray(packet.bbb67); + buffer.writeShortArray(packet.bbb68); + buffer.writeShortArray(packet.bbb69); + buffer.writeShortArray(packet.bbb7); + buffer.writeShortArray(packet.bbb70); + buffer.writeShortArray(packet.bbb71); + buffer.writeShortArray(packet.bbb72); + buffer.writeShortArray(packet.bbb73); + buffer.writeShortArray(packet.bbb74); + buffer.writeShortArray(packet.bbb75); + buffer.writeShortArray(packet.bbb76); + buffer.writeShortArray(packet.bbb77); + buffer.writeShortArray(packet.bbb78); + buffer.writeShortArray(packet.bbb79); + buffer.writeShortArray(packet.bbb8); + buffer.writeShortArray(packet.bbb80); + buffer.writeShortArray(packet.bbb81); + buffer.writeShortArray(packet.bbb82); + buffer.writeShortArray(packet.bbb83); + buffer.writeShortArray(packet.bbb84); + buffer.writeShortArray(packet.bbb85); + buffer.writeShortArray(packet.bbb86); + buffer.writeShortArray(packet.bbb87); + buffer.writeShortArray(packet.bbb88); + buffer.writeShortArray(packet.bbb9); + buffer.writeShortArray(packet.bbbb1); + buffer.writeShortArray(packet.bbbb10); + buffer.writeShortArray(packet.bbbb11); + buffer.writeShortArray(packet.bbbb12); + buffer.writeShortArray(packet.bbbb13); + buffer.writeShortArray(packet.bbbb14); + buffer.writeShortArray(packet.bbbb15); + buffer.writeShortArray(packet.bbbb16); + buffer.writeShortArray(packet.bbbb17); + buffer.writeShortArray(packet.bbbb18); + buffer.writeShortArray(packet.bbbb19); + buffer.writeShortArray(packet.bbbb2); + buffer.writeShortArray(packet.bbbb20); + buffer.writeShortArray(packet.bbbb21); + buffer.writeShortArray(packet.bbbb22); + buffer.writeShortArray(packet.bbbb23); + buffer.writeShortArray(packet.bbbb24); + buffer.writeShortArray(packet.bbbb25); + buffer.writeShortArray(packet.bbbb26); + buffer.writeShortArray(packet.bbbb27); + buffer.writeShortArray(packet.bbbb28); + buffer.writeShortArray(packet.bbbb29); + buffer.writeShortArray(packet.bbbb3); + buffer.writeShortArray(packet.bbbb30); + buffer.writeShortArray(packet.bbbb31); + buffer.writeShortArray(packet.bbbb32); + buffer.writeShortArray(packet.bbbb33); + buffer.writeShortArray(packet.bbbb34); + buffer.writeShortArray(packet.bbbb35); + buffer.writeShortArray(packet.bbbb36); + buffer.writeShortArray(packet.bbbb37); + buffer.writeShortArray(packet.bbbb38); + buffer.writeShortArray(packet.bbbb39); + buffer.writeShortArray(packet.bbbb4); + buffer.writeShortArray(packet.bbbb40); + buffer.writeShortArray(packet.bbbb41); + buffer.writeShortArray(packet.bbbb42); + buffer.writeShortArray(packet.bbbb43); + buffer.writeShortArray(packet.bbbb44); + buffer.writeShortArray(packet.bbbb45); + buffer.writeShortArray(packet.bbbb46); + buffer.writeShortArray(packet.bbbb47); + buffer.writeShortArray(packet.bbbb48); + buffer.writeShortArray(packet.bbbb49); + buffer.writeShortArray(packet.bbbb5); + buffer.writeShortArray(packet.bbbb50); + buffer.writeShortArray(packet.bbbb51); + buffer.writeShortArray(packet.bbbb52); + buffer.writeShortArray(packet.bbbb53); + buffer.writeShortArray(packet.bbbb54); + buffer.writeShortArray(packet.bbbb55); + buffer.writeShortArray(packet.bbbb56); + buffer.writeShortArray(packet.bbbb57); + buffer.writeShortArray(packet.bbbb58); + buffer.writeShortArray(packet.bbbb59); + buffer.writeShortArray(packet.bbbb6); + buffer.writeShortArray(packet.bbbb60); + buffer.writeShortArray(packet.bbbb61); + buffer.writeShortArray(packet.bbbb62); + buffer.writeShortArray(packet.bbbb63); + buffer.writeShortArray(packet.bbbb64); + buffer.writeShortArray(packet.bbbb65); + buffer.writeShortArray(packet.bbbb66); + buffer.writeShortArray(packet.bbbb67); + buffer.writeShortArray(packet.bbbb68); + buffer.writeShortArray(packet.bbbb69); + buffer.writeShortArray(packet.bbbb7); + buffer.writeShortArray(packet.bbbb70); + buffer.writeShortArray(packet.bbbb71); + buffer.writeShortArray(packet.bbbb72); + buffer.writeShortArray(packet.bbbb73); + buffer.writeShortArray(packet.bbbb74); + buffer.writeShortArray(packet.bbbb75); + buffer.writeShortArray(packet.bbbb76); + buffer.writeShortArray(packet.bbbb77); + buffer.writeShortArray(packet.bbbb78); + buffer.writeShortArray(packet.bbbb79); + buffer.writeShortArray(packet.bbbb8); + buffer.writeShortArray(packet.bbbb80); + buffer.writeShortArray(packet.bbbb81); + buffer.writeShortArray(packet.bbbb82); + buffer.writeShortArray(packet.bbbb83); + buffer.writeShortArray(packet.bbbb84); + buffer.writeShortArray(packet.bbbb85); + buffer.writeShortArray(packet.bbbb86); + buffer.writeShortArray(packet.bbbb87); + buffer.writeShortArray(packet.bbbb88); + buffer.writeShortArray(packet.bbbb9); + buffer.writeInt(packet.c1); + buffer.writeInt(packet.c10); + buffer.writeInt(packet.c11); + buffer.writeInt(packet.c12); + buffer.writeInt(packet.c13); + buffer.writeInt(packet.c14); + buffer.writeInt(packet.c15); + buffer.writeInt(packet.c16); + buffer.writeInt(packet.c17); + buffer.writeInt(packet.c18); + buffer.writeInt(packet.c19); + buffer.writeInt(packet.c2); + buffer.writeInt(packet.c20); + buffer.writeInt(packet.c21); + buffer.writeInt(packet.c22); + buffer.writeInt(packet.c23); + buffer.writeInt(packet.c24); + buffer.writeInt(packet.c25); + buffer.writeInt(packet.c26); + buffer.writeInt(packet.c27); + buffer.writeInt(packet.c28); + buffer.writeInt(packet.c29); + buffer.writeInt(packet.c3); + buffer.writeInt(packet.c30); + buffer.writeInt(packet.c31); + buffer.writeInt(packet.c32); + buffer.writeInt(packet.c33); + buffer.writeInt(packet.c34); + buffer.writeInt(packet.c35); + buffer.writeInt(packet.c36); + buffer.writeInt(packet.c37); + buffer.writeInt(packet.c38); + buffer.writeInt(packet.c39); + buffer.writeInt(packet.c4); + buffer.writeInt(packet.c40); + buffer.writeInt(packet.c41); + buffer.writeInt(packet.c42); + buffer.writeInt(packet.c43); + buffer.writeInt(packet.c44); + buffer.writeInt(packet.c45); + buffer.writeInt(packet.c46); + buffer.writeInt(packet.c47); + buffer.writeInt(packet.c48); + buffer.writeInt(packet.c49); + buffer.writeInt(packet.c5); + buffer.writeInt(packet.c50); + buffer.writeInt(packet.c51); + buffer.writeInt(packet.c52); + buffer.writeInt(packet.c53); + buffer.writeInt(packet.c54); + buffer.writeInt(packet.c55); + buffer.writeInt(packet.c56); + buffer.writeInt(packet.c57); + buffer.writeInt(packet.c58); + buffer.writeInt(packet.c59); + buffer.writeInt(packet.c6); + buffer.writeInt(packet.c60); + buffer.writeInt(packet.c61); + buffer.writeInt(packet.c62); + buffer.writeInt(packet.c63); + buffer.writeInt(packet.c64); + buffer.writeInt(packet.c65); + buffer.writeInt(packet.c66); + buffer.writeInt(packet.c67); + buffer.writeInt(packet.c68); + buffer.writeInt(packet.c69); + buffer.writeInt(packet.c7); + buffer.writeInt(packet.c70); + buffer.writeInt(packet.c71); + buffer.writeInt(packet.c72); + buffer.writeInt(packet.c73); + buffer.writeInt(packet.c74); + buffer.writeInt(packet.c75); + buffer.writeInt(packet.c76); + buffer.writeInt(packet.c77); + buffer.writeInt(packet.c78); + buffer.writeInt(packet.c79); + buffer.writeInt(packet.c8); + buffer.writeInt(packet.c80); + buffer.writeInt(packet.c81); + buffer.writeInt(packet.c82); + buffer.writeInt(packet.c83); + buffer.writeInt(packet.c84); + buffer.writeInt(packet.c85); + buffer.writeInt(packet.c86); + buffer.writeInt(packet.c87); + buffer.writeInt(packet.c88); + buffer.writeInt(packet.c9); + buffer.writeInt(packet.cc1); + buffer.writeInt(packet.cc10); + buffer.writeInt(packet.cc11); + buffer.writeInt(packet.cc12); + buffer.writeInt(packet.cc13); + buffer.writeInt(packet.cc14); + buffer.writeInt(packet.cc15); + buffer.writeInt(packet.cc16); + buffer.writeInt(packet.cc17); + buffer.writeInt(packet.cc18); + buffer.writeInt(packet.cc19); + buffer.writeInt(packet.cc2); + buffer.writeInt(packet.cc20); + buffer.writeInt(packet.cc21); + buffer.writeInt(packet.cc22); + buffer.writeInt(packet.cc23); + buffer.writeInt(packet.cc24); + buffer.writeInt(packet.cc25); + buffer.writeInt(packet.cc26); + buffer.writeInt(packet.cc27); + buffer.writeInt(packet.cc28); + buffer.writeInt(packet.cc29); + buffer.writeInt(packet.cc3); + buffer.writeInt(packet.cc30); + buffer.writeInt(packet.cc31); + buffer.writeInt(packet.cc32); + buffer.writeInt(packet.cc33); + buffer.writeInt(packet.cc34); + buffer.writeInt(packet.cc35); + buffer.writeInt(packet.cc36); + buffer.writeInt(packet.cc37); + buffer.writeInt(packet.cc38); + buffer.writeInt(packet.cc39); + buffer.writeInt(packet.cc4); + buffer.writeInt(packet.cc40); + buffer.writeInt(packet.cc41); + buffer.writeInt(packet.cc42); + buffer.writeInt(packet.cc43); + buffer.writeInt(packet.cc44); + buffer.writeInt(packet.cc45); + buffer.writeInt(packet.cc46); + buffer.writeInt(packet.cc47); + buffer.writeInt(packet.cc48); + buffer.writeInt(packet.cc49); + buffer.writeInt(packet.cc5); + buffer.writeInt(packet.cc50); + buffer.writeInt(packet.cc51); + buffer.writeInt(packet.cc52); + buffer.writeInt(packet.cc53); + buffer.writeInt(packet.cc54); + buffer.writeInt(packet.cc55); + buffer.writeInt(packet.cc56); + buffer.writeInt(packet.cc57); + buffer.writeInt(packet.cc58); + buffer.writeInt(packet.cc59); + buffer.writeInt(packet.cc6); + buffer.writeInt(packet.cc60); + buffer.writeInt(packet.cc61); + buffer.writeInt(packet.cc62); + buffer.writeInt(packet.cc63); + buffer.writeInt(packet.cc64); + buffer.writeInt(packet.cc65); + buffer.writeInt(packet.cc66); + buffer.writeInt(packet.cc67); + buffer.writeInt(packet.cc68); + buffer.writeInt(packet.cc69); + buffer.writeInt(packet.cc7); + buffer.writeInt(packet.cc70); + buffer.writeInt(packet.cc71); + buffer.writeInt(packet.cc72); + buffer.writeInt(packet.cc73); + buffer.writeInt(packet.cc74); + buffer.writeInt(packet.cc75); + buffer.writeInt(packet.cc76); + buffer.writeInt(packet.cc77); + buffer.writeInt(packet.cc78); + buffer.writeInt(packet.cc79); + buffer.writeInt(packet.cc8); + buffer.writeInt(packet.cc80); + buffer.writeInt(packet.cc81); + buffer.writeInt(packet.cc82); + buffer.writeInt(packet.cc83); + buffer.writeInt(packet.cc84); + buffer.writeInt(packet.cc85); + buffer.writeInt(packet.cc86); + buffer.writeInt(packet.cc87); + buffer.writeInt(packet.cc88); + buffer.writeInt(packet.cc9); + buffer.writeIntArray(packet.ccc1); + buffer.writeIntArray(packet.ccc10); + buffer.writeIntArray(packet.ccc11); + buffer.writeIntArray(packet.ccc12); + buffer.writeIntArray(packet.ccc13); + buffer.writeIntArray(packet.ccc14); + buffer.writeIntArray(packet.ccc15); + buffer.writeIntArray(packet.ccc16); + buffer.writeIntArray(packet.ccc17); + buffer.writeIntArray(packet.ccc18); + buffer.writeIntArray(packet.ccc19); + buffer.writeIntArray(packet.ccc2); + buffer.writeIntArray(packet.ccc20); + buffer.writeIntArray(packet.ccc21); + buffer.writeIntArray(packet.ccc22); + buffer.writeIntArray(packet.ccc23); + buffer.writeIntArray(packet.ccc24); + buffer.writeIntArray(packet.ccc25); + buffer.writeIntArray(packet.ccc26); + buffer.writeIntArray(packet.ccc27); + buffer.writeIntArray(packet.ccc28); + buffer.writeIntArray(packet.ccc29); + buffer.writeIntArray(packet.ccc3); + buffer.writeIntArray(packet.ccc30); + buffer.writeIntArray(packet.ccc31); + buffer.writeIntArray(packet.ccc32); + buffer.writeIntArray(packet.ccc33); + buffer.writeIntArray(packet.ccc34); + buffer.writeIntArray(packet.ccc35); + buffer.writeIntArray(packet.ccc36); + buffer.writeIntArray(packet.ccc37); + buffer.writeIntArray(packet.ccc38); + buffer.writeIntArray(packet.ccc39); + buffer.writeIntArray(packet.ccc4); + buffer.writeIntArray(packet.ccc40); + buffer.writeIntArray(packet.ccc41); + buffer.writeIntArray(packet.ccc42); + buffer.writeIntArray(packet.ccc43); + buffer.writeIntArray(packet.ccc44); + buffer.writeIntArray(packet.ccc45); + buffer.writeIntArray(packet.ccc46); + buffer.writeIntArray(packet.ccc47); + buffer.writeIntArray(packet.ccc48); + buffer.writeIntArray(packet.ccc49); + buffer.writeIntArray(packet.ccc5); + buffer.writeIntArray(packet.ccc50); + buffer.writeIntArray(packet.ccc51); + buffer.writeIntArray(packet.ccc52); + buffer.writeIntArray(packet.ccc53); + buffer.writeIntArray(packet.ccc54); + buffer.writeIntArray(packet.ccc55); + buffer.writeIntArray(packet.ccc56); + buffer.writeIntArray(packet.ccc57); + buffer.writeIntArray(packet.ccc58); + buffer.writeIntArray(packet.ccc59); + buffer.writeIntArray(packet.ccc6); + buffer.writeIntArray(packet.ccc60); + buffer.writeIntArray(packet.ccc61); + buffer.writeIntArray(packet.ccc62); + buffer.writeIntArray(packet.ccc63); + buffer.writeIntArray(packet.ccc64); + buffer.writeIntArray(packet.ccc65); + buffer.writeIntArray(packet.ccc66); + buffer.writeIntArray(packet.ccc67); + buffer.writeIntArray(packet.ccc68); + buffer.writeIntArray(packet.ccc69); + buffer.writeIntArray(packet.ccc7); + buffer.writeIntArray(packet.ccc70); + buffer.writeIntArray(packet.ccc71); + buffer.writeIntArray(packet.ccc72); + buffer.writeIntArray(packet.ccc73); + buffer.writeIntArray(packet.ccc74); + buffer.writeIntArray(packet.ccc75); + buffer.writeIntArray(packet.ccc76); + buffer.writeIntArray(packet.ccc77); + buffer.writeIntArray(packet.ccc78); + buffer.writeIntArray(packet.ccc79); + buffer.writeIntArray(packet.ccc8); + buffer.writeIntArray(packet.ccc80); + buffer.writeIntArray(packet.ccc81); + buffer.writeIntArray(packet.ccc82); + buffer.writeIntArray(packet.ccc83); + buffer.writeIntArray(packet.ccc84); + buffer.writeIntArray(packet.ccc85); + buffer.writeIntArray(packet.ccc86); + buffer.writeIntArray(packet.ccc87); + buffer.writeIntArray(packet.ccc88); + buffer.writeIntArray(packet.ccc9); + buffer.writeIntArray(packet.cccc1); + buffer.writeIntArray(packet.cccc10); + buffer.writeIntArray(packet.cccc11); + buffer.writeIntArray(packet.cccc12); + buffer.writeIntArray(packet.cccc13); + buffer.writeIntArray(packet.cccc14); + buffer.writeIntArray(packet.cccc15); + buffer.writeIntArray(packet.cccc16); + buffer.writeIntArray(packet.cccc17); + buffer.writeIntArray(packet.cccc18); + buffer.writeIntArray(packet.cccc19); + buffer.writeIntArray(packet.cccc2); + buffer.writeIntArray(packet.cccc20); + buffer.writeIntArray(packet.cccc21); + buffer.writeIntArray(packet.cccc22); + buffer.writeIntArray(packet.cccc23); + buffer.writeIntArray(packet.cccc24); + buffer.writeIntArray(packet.cccc25); + buffer.writeIntArray(packet.cccc26); + buffer.writeIntArray(packet.cccc27); + buffer.writeIntArray(packet.cccc28); + buffer.writeIntArray(packet.cccc29); + buffer.writeIntArray(packet.cccc3); + buffer.writeIntArray(packet.cccc30); + buffer.writeIntArray(packet.cccc31); + buffer.writeIntArray(packet.cccc32); + buffer.writeIntArray(packet.cccc33); + buffer.writeIntArray(packet.cccc34); + buffer.writeIntArray(packet.cccc35); + buffer.writeIntArray(packet.cccc36); + buffer.writeIntArray(packet.cccc37); + buffer.writeIntArray(packet.cccc38); + buffer.writeIntArray(packet.cccc39); + buffer.writeIntArray(packet.cccc4); + buffer.writeIntArray(packet.cccc40); + buffer.writeIntArray(packet.cccc41); + buffer.writeIntArray(packet.cccc42); + buffer.writeIntArray(packet.cccc43); + buffer.writeIntArray(packet.cccc44); + buffer.writeIntArray(packet.cccc45); + buffer.writeIntArray(packet.cccc46); + buffer.writeIntArray(packet.cccc47); + buffer.writeIntArray(packet.cccc48); + buffer.writeIntArray(packet.cccc49); + buffer.writeIntArray(packet.cccc5); + buffer.writeIntArray(packet.cccc50); + buffer.writeIntArray(packet.cccc51); + buffer.writeIntArray(packet.cccc52); + buffer.writeIntArray(packet.cccc53); + buffer.writeIntArray(packet.cccc54); + buffer.writeIntArray(packet.cccc55); + buffer.writeIntArray(packet.cccc56); + buffer.writeIntArray(packet.cccc57); + buffer.writeIntArray(packet.cccc58); + buffer.writeIntArray(packet.cccc59); + buffer.writeIntArray(packet.cccc6); + buffer.writeIntArray(packet.cccc60); + buffer.writeIntArray(packet.cccc61); + buffer.writeIntArray(packet.cccc62); + buffer.writeIntArray(packet.cccc63); + buffer.writeIntArray(packet.cccc64); + buffer.writeIntArray(packet.cccc65); + buffer.writeIntArray(packet.cccc66); + buffer.writeIntArray(packet.cccc67); + buffer.writeIntArray(packet.cccc68); + buffer.writeIntArray(packet.cccc69); + buffer.writeIntArray(packet.cccc7); + buffer.writeIntArray(packet.cccc70); + buffer.writeIntArray(packet.cccc71); + buffer.writeIntArray(packet.cccc72); + buffer.writeIntArray(packet.cccc73); + buffer.writeIntArray(packet.cccc74); + buffer.writeIntArray(packet.cccc75); + buffer.writeIntArray(packet.cccc76); + buffer.writeIntArray(packet.cccc77); + buffer.writeIntArray(packet.cccc78); + buffer.writeIntArray(packet.cccc79); + buffer.writeIntArray(packet.cccc8); + buffer.writeIntArray(packet.cccc80); + buffer.writeIntArray(packet.cccc81); + buffer.writeIntArray(packet.cccc82); + buffer.writeIntArray(packet.cccc83); + buffer.writeIntArray(packet.cccc84); + buffer.writeIntArray(packet.cccc85); + buffer.writeIntArray(packet.cccc86); + buffer.writeIntArray(packet.cccc87); + buffer.writeIntArray(packet.cccc88); + buffer.writeIntArray(packet.cccc9); + buffer.writeLong(packet.d1); + buffer.writeLong(packet.d10); + buffer.writeLong(packet.d11); + buffer.writeLong(packet.d12); + buffer.writeLong(packet.d13); + buffer.writeLong(packet.d14); + buffer.writeLong(packet.d15); + buffer.writeLong(packet.d16); + buffer.writeLong(packet.d17); + buffer.writeLong(packet.d18); + buffer.writeLong(packet.d19); + buffer.writeLong(packet.d2); + buffer.writeLong(packet.d20); + buffer.writeLong(packet.d21); + buffer.writeLong(packet.d22); + buffer.writeLong(packet.d23); + buffer.writeLong(packet.d24); + buffer.writeLong(packet.d25); + buffer.writeLong(packet.d26); + buffer.writeLong(packet.d27); + buffer.writeLong(packet.d28); + buffer.writeLong(packet.d29); + buffer.writeLong(packet.d3); + buffer.writeLong(packet.d30); + buffer.writeLong(packet.d31); + buffer.writeLong(packet.d32); + buffer.writeLong(packet.d33); + buffer.writeLong(packet.d34); + buffer.writeLong(packet.d35); + buffer.writeLong(packet.d36); + buffer.writeLong(packet.d37); + buffer.writeLong(packet.d38); + buffer.writeLong(packet.d39); + buffer.writeLong(packet.d4); + buffer.writeLong(packet.d40); + buffer.writeLong(packet.d41); + buffer.writeLong(packet.d42); + buffer.writeLong(packet.d43); + buffer.writeLong(packet.d44); + buffer.writeLong(packet.d45); + buffer.writeLong(packet.d46); + buffer.writeLong(packet.d47); + buffer.writeLong(packet.d48); + buffer.writeLong(packet.d49); + buffer.writeLong(packet.d5); + buffer.writeLong(packet.d50); + buffer.writeLong(packet.d51); + buffer.writeLong(packet.d52); + buffer.writeLong(packet.d53); + buffer.writeLong(packet.d54); + buffer.writeLong(packet.d55); + buffer.writeLong(packet.d56); + buffer.writeLong(packet.d57); + buffer.writeLong(packet.d58); + buffer.writeLong(packet.d59); + buffer.writeLong(packet.d6); + buffer.writeLong(packet.d60); + buffer.writeLong(packet.d61); + buffer.writeLong(packet.d62); + buffer.writeLong(packet.d63); + buffer.writeLong(packet.d64); + buffer.writeLong(packet.d65); + buffer.writeLong(packet.d66); + buffer.writeLong(packet.d67); + buffer.writeLong(packet.d68); + buffer.writeLong(packet.d69); + buffer.writeLong(packet.d7); + buffer.writeLong(packet.d70); + buffer.writeLong(packet.d71); + buffer.writeLong(packet.d72); + buffer.writeLong(packet.d73); + buffer.writeLong(packet.d74); + buffer.writeLong(packet.d75); + buffer.writeLong(packet.d76); + buffer.writeLong(packet.d77); + buffer.writeLong(packet.d78); + buffer.writeLong(packet.d79); + buffer.writeLong(packet.d8); + buffer.writeLong(packet.d80); + buffer.writeLong(packet.d81); + buffer.writeLong(packet.d82); + buffer.writeLong(packet.d83); + buffer.writeLong(packet.d84); + buffer.writeLong(packet.d85); + buffer.writeLong(packet.d86); + buffer.writeLong(packet.d87); + buffer.writeLong(packet.d88); + buffer.writeLong(packet.d9); + buffer.writeLong(packet.dd1); + buffer.writeLong(packet.dd10); + buffer.writeLong(packet.dd11); + buffer.writeLong(packet.dd12); + buffer.writeLong(packet.dd13); + buffer.writeLong(packet.dd14); + buffer.writeLong(packet.dd15); + buffer.writeLong(packet.dd16); + buffer.writeLong(packet.dd17); + buffer.writeLong(packet.dd18); + buffer.writeLong(packet.dd19); + buffer.writeLong(packet.dd2); + buffer.writeLong(packet.dd20); + buffer.writeLong(packet.dd21); + buffer.writeLong(packet.dd22); + buffer.writeLong(packet.dd23); + buffer.writeLong(packet.dd24); + buffer.writeLong(packet.dd25); + buffer.writeLong(packet.dd26); + buffer.writeLong(packet.dd27); + buffer.writeLong(packet.dd28); + buffer.writeLong(packet.dd29); + buffer.writeLong(packet.dd3); + buffer.writeLong(packet.dd30); + buffer.writeLong(packet.dd31); + buffer.writeLong(packet.dd32); + buffer.writeLong(packet.dd33); + buffer.writeLong(packet.dd34); + buffer.writeLong(packet.dd35); + buffer.writeLong(packet.dd36); + buffer.writeLong(packet.dd37); + buffer.writeLong(packet.dd38); + buffer.writeLong(packet.dd39); + buffer.writeLong(packet.dd4); + buffer.writeLong(packet.dd40); + buffer.writeLong(packet.dd41); + buffer.writeLong(packet.dd42); + buffer.writeLong(packet.dd43); + buffer.writeLong(packet.dd44); + buffer.writeLong(packet.dd45); + buffer.writeLong(packet.dd46); + buffer.writeLong(packet.dd47); + buffer.writeLong(packet.dd48); + buffer.writeLong(packet.dd49); + buffer.writeLong(packet.dd5); + buffer.writeLong(packet.dd50); + buffer.writeLong(packet.dd51); + buffer.writeLong(packet.dd52); + buffer.writeLong(packet.dd53); + buffer.writeLong(packet.dd54); + buffer.writeLong(packet.dd55); + buffer.writeLong(packet.dd56); + buffer.writeLong(packet.dd57); + buffer.writeLong(packet.dd58); + buffer.writeLong(packet.dd59); + buffer.writeLong(packet.dd6); + buffer.writeLong(packet.dd60); + buffer.writeLong(packet.dd61); + buffer.writeLong(packet.dd62); + buffer.writeLong(packet.dd63); + buffer.writeLong(packet.dd64); + buffer.writeLong(packet.dd65); + buffer.writeLong(packet.dd66); + buffer.writeLong(packet.dd67); + buffer.writeLong(packet.dd68); + buffer.writeLong(packet.dd69); + buffer.writeLong(packet.dd7); + buffer.writeLong(packet.dd70); + buffer.writeLong(packet.dd71); + buffer.writeLong(packet.dd72); + buffer.writeLong(packet.dd73); + buffer.writeLong(packet.dd74); + buffer.writeLong(packet.dd75); + buffer.writeLong(packet.dd76); + buffer.writeLong(packet.dd77); + buffer.writeLong(packet.dd78); + buffer.writeLong(packet.dd79); + buffer.writeLong(packet.dd8); + buffer.writeLong(packet.dd80); + buffer.writeLong(packet.dd81); + buffer.writeLong(packet.dd82); + buffer.writeLong(packet.dd83); + buffer.writeLong(packet.dd84); + buffer.writeLong(packet.dd85); + buffer.writeLong(packet.dd86); + buffer.writeLong(packet.dd87); + buffer.writeLong(packet.dd88); + buffer.writeLong(packet.dd9); + buffer.writeLongArray(packet.ddd1); + buffer.writeLongArray(packet.ddd10); + buffer.writeLongArray(packet.ddd11); + buffer.writeLongArray(packet.ddd12); + buffer.writeLongArray(packet.ddd13); + buffer.writeLongArray(packet.ddd14); + buffer.writeLongArray(packet.ddd15); + buffer.writeLongArray(packet.ddd16); + buffer.writeLongArray(packet.ddd17); + buffer.writeLongArray(packet.ddd18); + buffer.writeLongArray(packet.ddd19); + buffer.writeLongArray(packet.ddd2); + buffer.writeLongArray(packet.ddd20); + buffer.writeLongArray(packet.ddd21); + buffer.writeLongArray(packet.ddd22); + buffer.writeLongArray(packet.ddd23); + buffer.writeLongArray(packet.ddd24); + buffer.writeLongArray(packet.ddd25); + buffer.writeLongArray(packet.ddd26); + buffer.writeLongArray(packet.ddd27); + buffer.writeLongArray(packet.ddd28); + buffer.writeLongArray(packet.ddd29); + buffer.writeLongArray(packet.ddd3); + buffer.writeLongArray(packet.ddd30); + buffer.writeLongArray(packet.ddd31); + buffer.writeLongArray(packet.ddd32); + buffer.writeLongArray(packet.ddd33); + buffer.writeLongArray(packet.ddd34); + buffer.writeLongArray(packet.ddd35); + buffer.writeLongArray(packet.ddd36); + buffer.writeLongArray(packet.ddd37); + buffer.writeLongArray(packet.ddd38); + buffer.writeLongArray(packet.ddd39); + buffer.writeLongArray(packet.ddd4); + buffer.writeLongArray(packet.ddd40); + buffer.writeLongArray(packet.ddd41); + buffer.writeLongArray(packet.ddd42); + buffer.writeLongArray(packet.ddd43); + buffer.writeLongArray(packet.ddd44); + buffer.writeLongArray(packet.ddd45); + buffer.writeLongArray(packet.ddd46); + buffer.writeLongArray(packet.ddd47); + buffer.writeLongArray(packet.ddd48); + buffer.writeLongArray(packet.ddd49); + buffer.writeLongArray(packet.ddd5); + buffer.writeLongArray(packet.ddd50); + buffer.writeLongArray(packet.ddd51); + buffer.writeLongArray(packet.ddd52); + buffer.writeLongArray(packet.ddd53); + buffer.writeLongArray(packet.ddd54); + buffer.writeLongArray(packet.ddd55); + buffer.writeLongArray(packet.ddd56); + buffer.writeLongArray(packet.ddd57); + buffer.writeLongArray(packet.ddd58); + buffer.writeLongArray(packet.ddd59); + buffer.writeLongArray(packet.ddd6); + buffer.writeLongArray(packet.ddd60); + buffer.writeLongArray(packet.ddd61); + buffer.writeLongArray(packet.ddd62); + buffer.writeLongArray(packet.ddd63); + buffer.writeLongArray(packet.ddd64); + buffer.writeLongArray(packet.ddd65); + buffer.writeLongArray(packet.ddd66); + buffer.writeLongArray(packet.ddd67); + buffer.writeLongArray(packet.ddd68); + buffer.writeLongArray(packet.ddd69); + buffer.writeLongArray(packet.ddd7); + buffer.writeLongArray(packet.ddd70); + buffer.writeLongArray(packet.ddd71); + buffer.writeLongArray(packet.ddd72); + buffer.writeLongArray(packet.ddd73); + buffer.writeLongArray(packet.ddd74); + buffer.writeLongArray(packet.ddd75); + buffer.writeLongArray(packet.ddd76); + buffer.writeLongArray(packet.ddd77); + buffer.writeLongArray(packet.ddd78); + buffer.writeLongArray(packet.ddd79); + buffer.writeLongArray(packet.ddd8); + buffer.writeLongArray(packet.ddd80); + buffer.writeLongArray(packet.ddd81); + buffer.writeLongArray(packet.ddd82); + buffer.writeLongArray(packet.ddd83); + buffer.writeLongArray(packet.ddd84); + buffer.writeLongArray(packet.ddd85); + buffer.writeLongArray(packet.ddd86); + buffer.writeLongArray(packet.ddd87); + buffer.writeLongArray(packet.ddd88); + buffer.writeLongArray(packet.ddd9); + buffer.writeLongArray(packet.dddd1); + buffer.writeLongArray(packet.dddd10); + buffer.writeLongArray(packet.dddd11); + buffer.writeLongArray(packet.dddd12); + buffer.writeLongArray(packet.dddd13); + buffer.writeLongArray(packet.dddd14); + buffer.writeLongArray(packet.dddd15); + buffer.writeLongArray(packet.dddd16); + buffer.writeLongArray(packet.dddd17); + buffer.writeLongArray(packet.dddd18); + buffer.writeLongArray(packet.dddd19); + buffer.writeLongArray(packet.dddd2); + buffer.writeLongArray(packet.dddd20); + buffer.writeLongArray(packet.dddd21); + buffer.writeLongArray(packet.dddd22); + buffer.writeLongArray(packet.dddd23); + buffer.writeLongArray(packet.dddd24); + buffer.writeLongArray(packet.dddd25); + buffer.writeLongArray(packet.dddd26); + buffer.writeLongArray(packet.dddd27); + buffer.writeLongArray(packet.dddd28); + buffer.writeLongArray(packet.dddd29); + buffer.writeLongArray(packet.dddd3); + buffer.writeLongArray(packet.dddd30); + buffer.writeLongArray(packet.dddd31); + buffer.writeLongArray(packet.dddd32); + buffer.writeLongArray(packet.dddd33); + buffer.writeLongArray(packet.dddd34); + buffer.writeLongArray(packet.dddd35); + buffer.writeLongArray(packet.dddd36); + buffer.writeLongArray(packet.dddd37); + buffer.writeLongArray(packet.dddd38); + buffer.writeLongArray(packet.dddd39); + buffer.writeLongArray(packet.dddd4); + buffer.writeLongArray(packet.dddd40); + buffer.writeLongArray(packet.dddd41); + buffer.writeLongArray(packet.dddd42); + buffer.writeLongArray(packet.dddd43); + buffer.writeLongArray(packet.dddd44); + buffer.writeLongArray(packet.dddd45); + buffer.writeLongArray(packet.dddd46); + buffer.writeLongArray(packet.dddd47); + buffer.writeLongArray(packet.dddd48); + buffer.writeLongArray(packet.dddd49); + buffer.writeLongArray(packet.dddd5); + buffer.writeLongArray(packet.dddd50); + buffer.writeLongArray(packet.dddd51); + buffer.writeLongArray(packet.dddd52); + buffer.writeLongArray(packet.dddd53); + buffer.writeLongArray(packet.dddd54); + buffer.writeLongArray(packet.dddd55); + buffer.writeLongArray(packet.dddd56); + buffer.writeLongArray(packet.dddd57); + buffer.writeLongArray(packet.dddd58); + buffer.writeLongArray(packet.dddd59); + buffer.writeLongArray(packet.dddd6); + buffer.writeLongArray(packet.dddd60); + buffer.writeLongArray(packet.dddd61); + buffer.writeLongArray(packet.dddd62); + buffer.writeLongArray(packet.dddd63); + buffer.writeLongArray(packet.dddd64); + buffer.writeLongArray(packet.dddd65); + buffer.writeLongArray(packet.dddd66); + buffer.writeLongArray(packet.dddd67); + buffer.writeLongArray(packet.dddd68); + buffer.writeLongArray(packet.dddd69); + buffer.writeLongArray(packet.dddd7); + buffer.writeLongArray(packet.dddd70); + buffer.writeLongArray(packet.dddd71); + buffer.writeLongArray(packet.dddd72); + buffer.writeLongArray(packet.dddd73); + buffer.writeLongArray(packet.dddd74); + buffer.writeLongArray(packet.dddd75); + buffer.writeLongArray(packet.dddd76); + buffer.writeLongArray(packet.dddd77); + buffer.writeLongArray(packet.dddd78); + buffer.writeLongArray(packet.dddd79); + buffer.writeLongArray(packet.dddd8); + buffer.writeLongArray(packet.dddd80); + buffer.writeLongArray(packet.dddd81); + buffer.writeLongArray(packet.dddd82); + buffer.writeLongArray(packet.dddd83); + buffer.writeLongArray(packet.dddd84); + buffer.writeLongArray(packet.dddd85); + buffer.writeLongArray(packet.dddd86); + buffer.writeLongArray(packet.dddd87); + buffer.writeLongArray(packet.dddd88); + buffer.writeLongArray(packet.dddd9); + buffer.writeFloat(packet.e1); + buffer.writeFloat(packet.e10); + buffer.writeFloat(packet.e11); + buffer.writeFloat(packet.e12); + buffer.writeFloat(packet.e13); + buffer.writeFloat(packet.e14); + buffer.writeFloat(packet.e15); + buffer.writeFloat(packet.e16); + buffer.writeFloat(packet.e17); + buffer.writeFloat(packet.e18); + buffer.writeFloat(packet.e19); + buffer.writeFloat(packet.e2); + buffer.writeFloat(packet.e20); + buffer.writeFloat(packet.e21); + buffer.writeFloat(packet.e22); + buffer.writeFloat(packet.e23); + buffer.writeFloat(packet.e24); + buffer.writeFloat(packet.e25); + buffer.writeFloat(packet.e26); + buffer.writeFloat(packet.e27); + buffer.writeFloat(packet.e28); + buffer.writeFloat(packet.e29); + buffer.writeFloat(packet.e3); + buffer.writeFloat(packet.e30); + buffer.writeFloat(packet.e31); + buffer.writeFloat(packet.e32); + buffer.writeFloat(packet.e33); + buffer.writeFloat(packet.e34); + buffer.writeFloat(packet.e35); + buffer.writeFloat(packet.e36); + buffer.writeFloat(packet.e37); + buffer.writeFloat(packet.e38); + buffer.writeFloat(packet.e39); + buffer.writeFloat(packet.e4); + buffer.writeFloat(packet.e40); + buffer.writeFloat(packet.e41); + buffer.writeFloat(packet.e42); + buffer.writeFloat(packet.e43); + buffer.writeFloat(packet.e44); + buffer.writeFloat(packet.e45); + buffer.writeFloat(packet.e46); + buffer.writeFloat(packet.e47); + buffer.writeFloat(packet.e48); + buffer.writeFloat(packet.e49); + buffer.writeFloat(packet.e5); + buffer.writeFloat(packet.e50); + buffer.writeFloat(packet.e51); + buffer.writeFloat(packet.e52); + buffer.writeFloat(packet.e53); + buffer.writeFloat(packet.e54); + buffer.writeFloat(packet.e55); + buffer.writeFloat(packet.e56); + buffer.writeFloat(packet.e57); + buffer.writeFloat(packet.e58); + buffer.writeFloat(packet.e59); + buffer.writeFloat(packet.e6); + buffer.writeFloat(packet.e60); + buffer.writeFloat(packet.e61); + buffer.writeFloat(packet.e62); + buffer.writeFloat(packet.e63); + buffer.writeFloat(packet.e64); + buffer.writeFloat(packet.e65); + buffer.writeFloat(packet.e66); + buffer.writeFloat(packet.e67); + buffer.writeFloat(packet.e68); + buffer.writeFloat(packet.e69); + buffer.writeFloat(packet.e7); + buffer.writeFloat(packet.e70); + buffer.writeFloat(packet.e71); + buffer.writeFloat(packet.e72); + buffer.writeFloat(packet.e73); + buffer.writeFloat(packet.e74); + buffer.writeFloat(packet.e75); + buffer.writeFloat(packet.e76); + buffer.writeFloat(packet.e77); + buffer.writeFloat(packet.e78); + buffer.writeFloat(packet.e79); + buffer.writeFloat(packet.e8); + buffer.writeFloat(packet.e80); + buffer.writeFloat(packet.e81); + buffer.writeFloat(packet.e82); + buffer.writeFloat(packet.e83); + buffer.writeFloat(packet.e84); + buffer.writeFloat(packet.e85); + buffer.writeFloat(packet.e86); + buffer.writeFloat(packet.e87); + buffer.writeFloat(packet.e88); + buffer.writeFloat(packet.e9); + buffer.writeFloat(packet.ee1); + buffer.writeFloat(packet.ee10); + buffer.writeFloat(packet.ee11); + buffer.writeFloat(packet.ee12); + buffer.writeFloat(packet.ee13); + buffer.writeFloat(packet.ee14); + buffer.writeFloat(packet.ee15); + buffer.writeFloat(packet.ee16); + buffer.writeFloat(packet.ee17); + buffer.writeFloat(packet.ee18); + buffer.writeFloat(packet.ee19); + buffer.writeFloat(packet.ee2); + buffer.writeFloat(packet.ee20); + buffer.writeFloat(packet.ee21); + buffer.writeFloat(packet.ee22); + buffer.writeFloat(packet.ee23); + buffer.writeFloat(packet.ee24); + buffer.writeFloat(packet.ee25); + buffer.writeFloat(packet.ee26); + buffer.writeFloat(packet.ee27); + buffer.writeFloat(packet.ee28); + buffer.writeFloat(packet.ee29); + buffer.writeFloat(packet.ee3); + buffer.writeFloat(packet.ee30); + buffer.writeFloat(packet.ee31); + buffer.writeFloat(packet.ee32); + buffer.writeFloat(packet.ee33); + buffer.writeFloat(packet.ee34); + buffer.writeFloat(packet.ee35); + buffer.writeFloat(packet.ee36); + buffer.writeFloat(packet.ee37); + buffer.writeFloat(packet.ee38); + buffer.writeFloat(packet.ee39); + buffer.writeFloat(packet.ee4); + buffer.writeFloat(packet.ee40); + buffer.writeFloat(packet.ee41); + buffer.writeFloat(packet.ee42); + buffer.writeFloat(packet.ee43); + buffer.writeFloat(packet.ee44); + buffer.writeFloat(packet.ee45); + buffer.writeFloat(packet.ee46); + buffer.writeFloat(packet.ee47); + buffer.writeFloat(packet.ee48); + buffer.writeFloat(packet.ee49); + buffer.writeFloat(packet.ee5); + buffer.writeFloat(packet.ee50); + buffer.writeFloat(packet.ee51); + buffer.writeFloat(packet.ee52); + buffer.writeFloat(packet.ee53); + buffer.writeFloat(packet.ee54); + buffer.writeFloat(packet.ee55); + buffer.writeFloat(packet.ee56); + buffer.writeFloat(packet.ee57); + buffer.writeFloat(packet.ee58); + buffer.writeFloat(packet.ee59); + buffer.writeFloat(packet.ee6); + buffer.writeFloat(packet.ee60); + buffer.writeFloat(packet.ee61); + buffer.writeFloat(packet.ee62); + buffer.writeFloat(packet.ee63); + buffer.writeFloat(packet.ee64); + buffer.writeFloat(packet.ee65); + buffer.writeFloat(packet.ee66); + buffer.writeFloat(packet.ee67); + buffer.writeFloat(packet.ee68); + buffer.writeFloat(packet.ee69); + buffer.writeFloat(packet.ee7); + buffer.writeFloat(packet.ee70); + buffer.writeFloat(packet.ee71); + buffer.writeFloat(packet.ee72); + buffer.writeFloat(packet.ee73); + buffer.writeFloat(packet.ee74); + buffer.writeFloat(packet.ee75); + buffer.writeFloat(packet.ee76); + buffer.writeFloat(packet.ee77); + buffer.writeFloat(packet.ee78); + buffer.writeFloat(packet.ee79); + buffer.writeFloat(packet.ee8); + buffer.writeFloat(packet.ee80); + buffer.writeFloat(packet.ee81); + buffer.writeFloat(packet.ee82); + buffer.writeFloat(packet.ee83); + buffer.writeFloat(packet.ee84); + buffer.writeFloat(packet.ee85); + buffer.writeFloat(packet.ee86); + buffer.writeFloat(packet.ee87); + buffer.writeFloat(packet.ee88); + buffer.writeFloat(packet.ee9); + buffer.writeFloatArray(packet.eee1); + buffer.writeFloatArray(packet.eee10); + buffer.writeFloatArray(packet.eee11); + buffer.writeFloatArray(packet.eee12); + buffer.writeFloatArray(packet.eee13); + buffer.writeFloatArray(packet.eee14); + buffer.writeFloatArray(packet.eee15); + buffer.writeFloatArray(packet.eee16); + buffer.writeFloatArray(packet.eee17); + buffer.writeFloatArray(packet.eee18); + buffer.writeFloatArray(packet.eee19); + buffer.writeFloatArray(packet.eee2); + buffer.writeFloatArray(packet.eee20); + buffer.writeFloatArray(packet.eee21); + buffer.writeFloatArray(packet.eee22); + buffer.writeFloatArray(packet.eee23); + buffer.writeFloatArray(packet.eee24); + buffer.writeFloatArray(packet.eee25); + buffer.writeFloatArray(packet.eee26); + buffer.writeFloatArray(packet.eee27); + buffer.writeFloatArray(packet.eee28); + buffer.writeFloatArray(packet.eee29); + buffer.writeFloatArray(packet.eee3); + buffer.writeFloatArray(packet.eee30); + buffer.writeFloatArray(packet.eee31); + buffer.writeFloatArray(packet.eee32); + buffer.writeFloatArray(packet.eee33); + buffer.writeFloatArray(packet.eee34); + buffer.writeFloatArray(packet.eee35); + buffer.writeFloatArray(packet.eee36); + buffer.writeFloatArray(packet.eee37); + buffer.writeFloatArray(packet.eee38); + buffer.writeFloatArray(packet.eee39); + buffer.writeFloatArray(packet.eee4); + buffer.writeFloatArray(packet.eee40); + buffer.writeFloatArray(packet.eee41); + buffer.writeFloatArray(packet.eee42); + buffer.writeFloatArray(packet.eee43); + buffer.writeFloatArray(packet.eee44); + buffer.writeFloatArray(packet.eee45); + buffer.writeFloatArray(packet.eee46); + buffer.writeFloatArray(packet.eee47); + buffer.writeFloatArray(packet.eee48); + buffer.writeFloatArray(packet.eee49); + buffer.writeFloatArray(packet.eee5); + buffer.writeFloatArray(packet.eee50); + buffer.writeFloatArray(packet.eee51); + buffer.writeFloatArray(packet.eee52); + buffer.writeFloatArray(packet.eee53); + buffer.writeFloatArray(packet.eee54); + buffer.writeFloatArray(packet.eee55); + buffer.writeFloatArray(packet.eee56); + buffer.writeFloatArray(packet.eee57); + buffer.writeFloatArray(packet.eee58); + buffer.writeFloatArray(packet.eee59); + buffer.writeFloatArray(packet.eee6); + buffer.writeFloatArray(packet.eee60); + buffer.writeFloatArray(packet.eee61); + buffer.writeFloatArray(packet.eee62); + buffer.writeFloatArray(packet.eee63); + buffer.writeFloatArray(packet.eee64); + buffer.writeFloatArray(packet.eee65); + buffer.writeFloatArray(packet.eee66); + buffer.writeFloatArray(packet.eee67); + buffer.writeFloatArray(packet.eee68); + buffer.writeFloatArray(packet.eee69); + buffer.writeFloatArray(packet.eee7); + buffer.writeFloatArray(packet.eee70); + buffer.writeFloatArray(packet.eee71); + buffer.writeFloatArray(packet.eee72); + buffer.writeFloatArray(packet.eee73); + buffer.writeFloatArray(packet.eee74); + buffer.writeFloatArray(packet.eee75); + buffer.writeFloatArray(packet.eee76); + buffer.writeFloatArray(packet.eee77); + buffer.writeFloatArray(packet.eee78); + buffer.writeFloatArray(packet.eee79); + buffer.writeFloatArray(packet.eee8); + buffer.writeFloatArray(packet.eee80); + buffer.writeFloatArray(packet.eee81); + buffer.writeFloatArray(packet.eee82); + buffer.writeFloatArray(packet.eee83); + buffer.writeFloatArray(packet.eee84); + buffer.writeFloatArray(packet.eee85); + buffer.writeFloatArray(packet.eee86); + buffer.writeFloatArray(packet.eee87); + buffer.writeFloatArray(packet.eee88); + buffer.writeFloatArray(packet.eee9); + buffer.writeFloatArray(packet.eeee1); + buffer.writeFloatArray(packet.eeee10); + buffer.writeFloatArray(packet.eeee11); + buffer.writeFloatArray(packet.eeee12); + buffer.writeFloatArray(packet.eeee13); + buffer.writeFloatArray(packet.eeee14); + buffer.writeFloatArray(packet.eeee15); + buffer.writeFloatArray(packet.eeee16); + buffer.writeFloatArray(packet.eeee17); + buffer.writeFloatArray(packet.eeee18); + buffer.writeFloatArray(packet.eeee19); + buffer.writeFloatArray(packet.eeee2); + buffer.writeFloatArray(packet.eeee20); + buffer.writeFloatArray(packet.eeee21); + buffer.writeFloatArray(packet.eeee22); + buffer.writeFloatArray(packet.eeee23); + buffer.writeFloatArray(packet.eeee24); + buffer.writeFloatArray(packet.eeee25); + buffer.writeFloatArray(packet.eeee26); + buffer.writeFloatArray(packet.eeee27); + buffer.writeFloatArray(packet.eeee28); + buffer.writeFloatArray(packet.eeee29); + buffer.writeFloatArray(packet.eeee3); + buffer.writeFloatArray(packet.eeee30); + buffer.writeFloatArray(packet.eeee31); + buffer.writeFloatArray(packet.eeee32); + buffer.writeFloatArray(packet.eeee33); + buffer.writeFloatArray(packet.eeee34); + buffer.writeFloatArray(packet.eeee35); + buffer.writeFloatArray(packet.eeee36); + buffer.writeFloatArray(packet.eeee37); + buffer.writeFloatArray(packet.eeee38); + buffer.writeFloatArray(packet.eeee39); + buffer.writeFloatArray(packet.eeee4); + buffer.writeFloatArray(packet.eeee40); + buffer.writeFloatArray(packet.eeee41); + buffer.writeFloatArray(packet.eeee42); + buffer.writeFloatArray(packet.eeee43); + buffer.writeFloatArray(packet.eeee44); + buffer.writeFloatArray(packet.eeee45); + buffer.writeFloatArray(packet.eeee46); + buffer.writeFloatArray(packet.eeee47); + buffer.writeFloatArray(packet.eeee48); + buffer.writeFloatArray(packet.eeee49); + buffer.writeFloatArray(packet.eeee5); + buffer.writeFloatArray(packet.eeee50); + buffer.writeFloatArray(packet.eeee51); + buffer.writeFloatArray(packet.eeee52); + buffer.writeFloatArray(packet.eeee53); + buffer.writeFloatArray(packet.eeee54); + buffer.writeFloatArray(packet.eeee55); + buffer.writeFloatArray(packet.eeee56); + buffer.writeFloatArray(packet.eeee57); + buffer.writeFloatArray(packet.eeee58); + buffer.writeFloatArray(packet.eeee59); + buffer.writeFloatArray(packet.eeee6); + buffer.writeFloatArray(packet.eeee60); + buffer.writeFloatArray(packet.eeee61); + buffer.writeFloatArray(packet.eeee62); + buffer.writeFloatArray(packet.eeee63); + buffer.writeFloatArray(packet.eeee64); + buffer.writeFloatArray(packet.eeee65); + buffer.writeFloatArray(packet.eeee66); + buffer.writeFloatArray(packet.eeee67); + buffer.writeFloatArray(packet.eeee68); + buffer.writeFloatArray(packet.eeee69); + buffer.writeFloatArray(packet.eeee7); + buffer.writeFloatArray(packet.eeee70); + buffer.writeFloatArray(packet.eeee71); + buffer.writeFloatArray(packet.eeee72); + buffer.writeFloatArray(packet.eeee73); + buffer.writeFloatArray(packet.eeee74); + buffer.writeFloatArray(packet.eeee75); + buffer.writeFloatArray(packet.eeee76); + buffer.writeFloatArray(packet.eeee77); + buffer.writeFloatArray(packet.eeee78); + buffer.writeFloatArray(packet.eeee79); + buffer.writeFloatArray(packet.eeee8); + buffer.writeFloatArray(packet.eeee80); + buffer.writeFloatArray(packet.eeee81); + buffer.writeFloatArray(packet.eeee82); + buffer.writeFloatArray(packet.eeee83); + buffer.writeFloatArray(packet.eeee84); + buffer.writeFloatArray(packet.eeee85); + buffer.writeFloatArray(packet.eeee86); + buffer.writeFloatArray(packet.eeee87); + buffer.writeFloatArray(packet.eeee88); + buffer.writeFloatArray(packet.eeee9); + buffer.writeDouble(packet.f1); + buffer.writeDouble(packet.f10); + buffer.writeDouble(packet.f11); + buffer.writeDouble(packet.f12); + buffer.writeDouble(packet.f13); + buffer.writeDouble(packet.f14); + buffer.writeDouble(packet.f15); + buffer.writeDouble(packet.f16); + buffer.writeDouble(packet.f17); + buffer.writeDouble(packet.f18); + buffer.writeDouble(packet.f19); + buffer.writeDouble(packet.f2); + buffer.writeDouble(packet.f20); + buffer.writeDouble(packet.f21); + buffer.writeDouble(packet.f22); + buffer.writeDouble(packet.f23); + buffer.writeDouble(packet.f24); + buffer.writeDouble(packet.f25); + buffer.writeDouble(packet.f26); + buffer.writeDouble(packet.f27); + buffer.writeDouble(packet.f28); + buffer.writeDouble(packet.f29); + buffer.writeDouble(packet.f3); + buffer.writeDouble(packet.f30); + buffer.writeDouble(packet.f31); + buffer.writeDouble(packet.f32); + buffer.writeDouble(packet.f33); + buffer.writeDouble(packet.f34); + buffer.writeDouble(packet.f35); + buffer.writeDouble(packet.f36); + buffer.writeDouble(packet.f37); + buffer.writeDouble(packet.f38); + buffer.writeDouble(packet.f39); + buffer.writeDouble(packet.f4); + buffer.writeDouble(packet.f40); + buffer.writeDouble(packet.f41); + buffer.writeDouble(packet.f42); + buffer.writeDouble(packet.f43); + buffer.writeDouble(packet.f44); + buffer.writeDouble(packet.f45); + buffer.writeDouble(packet.f46); + buffer.writeDouble(packet.f47); + buffer.writeDouble(packet.f48); + buffer.writeDouble(packet.f49); + buffer.writeDouble(packet.f5); + buffer.writeDouble(packet.f50); + buffer.writeDouble(packet.f51); + buffer.writeDouble(packet.f52); + buffer.writeDouble(packet.f53); + buffer.writeDouble(packet.f54); + buffer.writeDouble(packet.f55); + buffer.writeDouble(packet.f56); + buffer.writeDouble(packet.f57); + buffer.writeDouble(packet.f58); + buffer.writeDouble(packet.f59); + buffer.writeDouble(packet.f6); + buffer.writeDouble(packet.f60); + buffer.writeDouble(packet.f61); + buffer.writeDouble(packet.f62); + buffer.writeDouble(packet.f63); + buffer.writeDouble(packet.f64); + buffer.writeDouble(packet.f65); + buffer.writeDouble(packet.f66); + buffer.writeDouble(packet.f67); + buffer.writeDouble(packet.f68); + buffer.writeDouble(packet.f69); + buffer.writeDouble(packet.f7); + buffer.writeDouble(packet.f70); + buffer.writeDouble(packet.f71); + buffer.writeDouble(packet.f72); + buffer.writeDouble(packet.f73); + buffer.writeDouble(packet.f74); + buffer.writeDouble(packet.f75); + buffer.writeDouble(packet.f76); + buffer.writeDouble(packet.f77); + buffer.writeDouble(packet.f78); + buffer.writeDouble(packet.f79); + buffer.writeDouble(packet.f8); + buffer.writeDouble(packet.f80); + buffer.writeDouble(packet.f81); + buffer.writeDouble(packet.f82); + buffer.writeDouble(packet.f83); + buffer.writeDouble(packet.f84); + buffer.writeDouble(packet.f85); + buffer.writeDouble(packet.f86); + buffer.writeDouble(packet.f87); + buffer.writeDouble(packet.f88); + buffer.writeDouble(packet.f9); + buffer.writeDouble(packet.ff1); + buffer.writeDouble(packet.ff10); + buffer.writeDouble(packet.ff11); + buffer.writeDouble(packet.ff12); + buffer.writeDouble(packet.ff13); + buffer.writeDouble(packet.ff14); + buffer.writeDouble(packet.ff15); + buffer.writeDouble(packet.ff16); + buffer.writeDouble(packet.ff17); + buffer.writeDouble(packet.ff18); + buffer.writeDouble(packet.ff19); + buffer.writeDouble(packet.ff2); + buffer.writeDouble(packet.ff20); + buffer.writeDouble(packet.ff21); + buffer.writeDouble(packet.ff22); + buffer.writeDouble(packet.ff23); + buffer.writeDouble(packet.ff24); + buffer.writeDouble(packet.ff25); + buffer.writeDouble(packet.ff26); + buffer.writeDouble(packet.ff27); + buffer.writeDouble(packet.ff28); + buffer.writeDouble(packet.ff29); + buffer.writeDouble(packet.ff3); + buffer.writeDouble(packet.ff30); + buffer.writeDouble(packet.ff31); + buffer.writeDouble(packet.ff32); + buffer.writeDouble(packet.ff33); + buffer.writeDouble(packet.ff34); + buffer.writeDouble(packet.ff35); + buffer.writeDouble(packet.ff36); + buffer.writeDouble(packet.ff37); + buffer.writeDouble(packet.ff38); + buffer.writeDouble(packet.ff39); + buffer.writeDouble(packet.ff4); + buffer.writeDouble(packet.ff40); + buffer.writeDouble(packet.ff41); + buffer.writeDouble(packet.ff42); + buffer.writeDouble(packet.ff43); + buffer.writeDouble(packet.ff44); + buffer.writeDouble(packet.ff45); + buffer.writeDouble(packet.ff46); + buffer.writeDouble(packet.ff47); + buffer.writeDouble(packet.ff48); + buffer.writeDouble(packet.ff49); + buffer.writeDouble(packet.ff5); + buffer.writeDouble(packet.ff50); + buffer.writeDouble(packet.ff51); + buffer.writeDouble(packet.ff52); + buffer.writeDouble(packet.ff53); + buffer.writeDouble(packet.ff54); + buffer.writeDouble(packet.ff55); + buffer.writeDouble(packet.ff56); + buffer.writeDouble(packet.ff57); + buffer.writeDouble(packet.ff58); + buffer.writeDouble(packet.ff59); + buffer.writeDouble(packet.ff6); + buffer.writeDouble(packet.ff60); + buffer.writeDouble(packet.ff61); + buffer.writeDouble(packet.ff62); + buffer.writeDouble(packet.ff63); + buffer.writeDouble(packet.ff64); + buffer.writeDouble(packet.ff65); + buffer.writeDouble(packet.ff66); + buffer.writeDouble(packet.ff67); + buffer.writeDouble(packet.ff68); + buffer.writeDouble(packet.ff69); + buffer.writeDouble(packet.ff7); + buffer.writeDouble(packet.ff70); + buffer.writeDouble(packet.ff71); + buffer.writeDouble(packet.ff72); + buffer.writeDouble(packet.ff73); + buffer.writeDouble(packet.ff74); + buffer.writeDouble(packet.ff75); + buffer.writeDouble(packet.ff76); + buffer.writeDouble(packet.ff77); + buffer.writeDouble(packet.ff78); + buffer.writeDouble(packet.ff79); + buffer.writeDouble(packet.ff8); + buffer.writeDouble(packet.ff80); + buffer.writeDouble(packet.ff81); + buffer.writeDouble(packet.ff82); + buffer.writeDouble(packet.ff83); + buffer.writeDouble(packet.ff84); + buffer.writeDouble(packet.ff85); + buffer.writeDouble(packet.ff86); + buffer.writeDouble(packet.ff87); + buffer.writeDouble(packet.ff88); + buffer.writeDouble(packet.ff9); + buffer.writeDoubleArray(packet.fff1); + buffer.writeDoubleArray(packet.fff10); + buffer.writeDoubleArray(packet.fff11); + buffer.writeDoubleArray(packet.fff12); + buffer.writeDoubleArray(packet.fff13); + buffer.writeDoubleArray(packet.fff14); + buffer.writeDoubleArray(packet.fff15); + buffer.writeDoubleArray(packet.fff16); + buffer.writeDoubleArray(packet.fff17); + buffer.writeDoubleArray(packet.fff18); + buffer.writeDoubleArray(packet.fff19); + buffer.writeDoubleArray(packet.fff2); + buffer.writeDoubleArray(packet.fff20); + buffer.writeDoubleArray(packet.fff21); + buffer.writeDoubleArray(packet.fff22); + buffer.writeDoubleArray(packet.fff23); + buffer.writeDoubleArray(packet.fff24); + buffer.writeDoubleArray(packet.fff25); + buffer.writeDoubleArray(packet.fff26); + buffer.writeDoubleArray(packet.fff27); + buffer.writeDoubleArray(packet.fff28); + buffer.writeDoubleArray(packet.fff29); + buffer.writeDoubleArray(packet.fff3); + buffer.writeDoubleArray(packet.fff30); + buffer.writeDoubleArray(packet.fff31); + buffer.writeDoubleArray(packet.fff32); + buffer.writeDoubleArray(packet.fff33); + buffer.writeDoubleArray(packet.fff34); + buffer.writeDoubleArray(packet.fff35); + buffer.writeDoubleArray(packet.fff36); + buffer.writeDoubleArray(packet.fff37); + buffer.writeDoubleArray(packet.fff38); + buffer.writeDoubleArray(packet.fff39); + buffer.writeDoubleArray(packet.fff4); + buffer.writeDoubleArray(packet.fff40); + buffer.writeDoubleArray(packet.fff41); + buffer.writeDoubleArray(packet.fff42); + buffer.writeDoubleArray(packet.fff43); + buffer.writeDoubleArray(packet.fff44); + buffer.writeDoubleArray(packet.fff45); + buffer.writeDoubleArray(packet.fff46); + buffer.writeDoubleArray(packet.fff47); + buffer.writeDoubleArray(packet.fff48); + buffer.writeDoubleArray(packet.fff49); + buffer.writeDoubleArray(packet.fff5); + buffer.writeDoubleArray(packet.fff50); + buffer.writeDoubleArray(packet.fff51); + buffer.writeDoubleArray(packet.fff52); + buffer.writeDoubleArray(packet.fff53); + buffer.writeDoubleArray(packet.fff54); + buffer.writeDoubleArray(packet.fff55); + buffer.writeDoubleArray(packet.fff56); + buffer.writeDoubleArray(packet.fff57); + buffer.writeDoubleArray(packet.fff58); + buffer.writeDoubleArray(packet.fff59); + buffer.writeDoubleArray(packet.fff6); + buffer.writeDoubleArray(packet.fff60); + buffer.writeDoubleArray(packet.fff61); + buffer.writeDoubleArray(packet.fff62); + buffer.writeDoubleArray(packet.fff63); + buffer.writeDoubleArray(packet.fff64); + buffer.writeDoubleArray(packet.fff65); + buffer.writeDoubleArray(packet.fff66); + buffer.writeDoubleArray(packet.fff67); + buffer.writeDoubleArray(packet.fff68); + buffer.writeDoubleArray(packet.fff69); + buffer.writeDoubleArray(packet.fff7); + buffer.writeDoubleArray(packet.fff70); + buffer.writeDoubleArray(packet.fff71); + buffer.writeDoubleArray(packet.fff72); + buffer.writeDoubleArray(packet.fff73); + buffer.writeDoubleArray(packet.fff74); + buffer.writeDoubleArray(packet.fff75); + buffer.writeDoubleArray(packet.fff76); + buffer.writeDoubleArray(packet.fff77); + buffer.writeDoubleArray(packet.fff78); + buffer.writeDoubleArray(packet.fff79); + buffer.writeDoubleArray(packet.fff8); + buffer.writeDoubleArray(packet.fff80); + buffer.writeDoubleArray(packet.fff81); + buffer.writeDoubleArray(packet.fff82); + buffer.writeDoubleArray(packet.fff83); + buffer.writeDoubleArray(packet.fff84); + buffer.writeDoubleArray(packet.fff85); + buffer.writeDoubleArray(packet.fff86); + buffer.writeDoubleArray(packet.fff87); + buffer.writeDoubleArray(packet.fff88); + buffer.writeDoubleArray(packet.fff9); + buffer.writeDoubleArray(packet.ffff1); + buffer.writeDoubleArray(packet.ffff10); + buffer.writeDoubleArray(packet.ffff11); + buffer.writeDoubleArray(packet.ffff12); + buffer.writeDoubleArray(packet.ffff13); + buffer.writeDoubleArray(packet.ffff14); + buffer.writeDoubleArray(packet.ffff15); + buffer.writeDoubleArray(packet.ffff16); + buffer.writeDoubleArray(packet.ffff17); + buffer.writeDoubleArray(packet.ffff18); + buffer.writeDoubleArray(packet.ffff19); + buffer.writeDoubleArray(packet.ffff2); + buffer.writeDoubleArray(packet.ffff20); + buffer.writeDoubleArray(packet.ffff21); + buffer.writeDoubleArray(packet.ffff22); + buffer.writeDoubleArray(packet.ffff23); + buffer.writeDoubleArray(packet.ffff24); + buffer.writeDoubleArray(packet.ffff25); + buffer.writeDoubleArray(packet.ffff26); + buffer.writeDoubleArray(packet.ffff27); + buffer.writeDoubleArray(packet.ffff28); + buffer.writeDoubleArray(packet.ffff29); + buffer.writeDoubleArray(packet.ffff3); + buffer.writeDoubleArray(packet.ffff30); + buffer.writeDoubleArray(packet.ffff31); + buffer.writeDoubleArray(packet.ffff32); + buffer.writeDoubleArray(packet.ffff33); + buffer.writeDoubleArray(packet.ffff34); + buffer.writeDoubleArray(packet.ffff35); + buffer.writeDoubleArray(packet.ffff36); + buffer.writeDoubleArray(packet.ffff37); + buffer.writeDoubleArray(packet.ffff38); + buffer.writeDoubleArray(packet.ffff39); + buffer.writeDoubleArray(packet.ffff4); + buffer.writeDoubleArray(packet.ffff40); + buffer.writeDoubleArray(packet.ffff41); + buffer.writeDoubleArray(packet.ffff42); + buffer.writeDoubleArray(packet.ffff43); + buffer.writeDoubleArray(packet.ffff44); + buffer.writeDoubleArray(packet.ffff45); + buffer.writeDoubleArray(packet.ffff46); + buffer.writeDoubleArray(packet.ffff47); + buffer.writeDoubleArray(packet.ffff48); + buffer.writeDoubleArray(packet.ffff49); + buffer.writeDoubleArray(packet.ffff5); + buffer.writeDoubleArray(packet.ffff50); + buffer.writeDoubleArray(packet.ffff51); + buffer.writeDoubleArray(packet.ffff52); + buffer.writeDoubleArray(packet.ffff53); + buffer.writeDoubleArray(packet.ffff54); + buffer.writeDoubleArray(packet.ffff55); + buffer.writeDoubleArray(packet.ffff56); + buffer.writeDoubleArray(packet.ffff57); + buffer.writeDoubleArray(packet.ffff58); + buffer.writeDoubleArray(packet.ffff59); + buffer.writeDoubleArray(packet.ffff6); + buffer.writeDoubleArray(packet.ffff60); + buffer.writeDoubleArray(packet.ffff61); + buffer.writeDoubleArray(packet.ffff62); + buffer.writeDoubleArray(packet.ffff63); + buffer.writeDoubleArray(packet.ffff64); + buffer.writeDoubleArray(packet.ffff65); + buffer.writeDoubleArray(packet.ffff66); + buffer.writeDoubleArray(packet.ffff67); + buffer.writeDoubleArray(packet.ffff68); + buffer.writeDoubleArray(packet.ffff69); + buffer.writeDoubleArray(packet.ffff7); + buffer.writeDoubleArray(packet.ffff70); + buffer.writeDoubleArray(packet.ffff71); + buffer.writeDoubleArray(packet.ffff72); + buffer.writeDoubleArray(packet.ffff73); + buffer.writeDoubleArray(packet.ffff74); + buffer.writeDoubleArray(packet.ffff75); + buffer.writeDoubleArray(packet.ffff76); + buffer.writeDoubleArray(packet.ffff77); + buffer.writeDoubleArray(packet.ffff78); + buffer.writeDoubleArray(packet.ffff79); + buffer.writeDoubleArray(packet.ffff8); + buffer.writeDoubleArray(packet.ffff80); + buffer.writeDoubleArray(packet.ffff81); + buffer.writeDoubleArray(packet.ffff82); + buffer.writeDoubleArray(packet.ffff83); + buffer.writeDoubleArray(packet.ffff84); + buffer.writeDoubleArray(packet.ffff85); + buffer.writeDoubleArray(packet.ffff86); + buffer.writeDoubleArray(packet.ffff87); + buffer.writeDoubleArray(packet.ffff88); + buffer.writeDoubleArray(packet.ffff9); + buffer.writeBoolean(packet.g1); + buffer.writeBoolean(packet.g10); + buffer.writeBoolean(packet.g11); + buffer.writeBoolean(packet.g12); + buffer.writeBoolean(packet.g13); + buffer.writeBoolean(packet.g14); + buffer.writeBoolean(packet.g15); + buffer.writeBoolean(packet.g16); + buffer.writeBoolean(packet.g17); + buffer.writeBoolean(packet.g18); + buffer.writeBoolean(packet.g19); + buffer.writeBoolean(packet.g2); + buffer.writeBoolean(packet.g20); + buffer.writeBoolean(packet.g21); + buffer.writeBoolean(packet.g22); + buffer.writeBoolean(packet.g23); + buffer.writeBoolean(packet.g24); + buffer.writeBoolean(packet.g25); + buffer.writeBoolean(packet.g26); + buffer.writeBoolean(packet.g27); + buffer.writeBoolean(packet.g28); + buffer.writeBoolean(packet.g29); + buffer.writeBoolean(packet.g3); + buffer.writeBoolean(packet.g30); + buffer.writeBoolean(packet.g31); + buffer.writeBoolean(packet.g32); + buffer.writeBoolean(packet.g33); + buffer.writeBoolean(packet.g34); + buffer.writeBoolean(packet.g35); + buffer.writeBoolean(packet.g36); + buffer.writeBoolean(packet.g37); + buffer.writeBoolean(packet.g38); + buffer.writeBoolean(packet.g39); + buffer.writeBoolean(packet.g4); + buffer.writeBoolean(packet.g40); + buffer.writeBoolean(packet.g41); + buffer.writeBoolean(packet.g42); + buffer.writeBoolean(packet.g43); + buffer.writeBoolean(packet.g44); + buffer.writeBoolean(packet.g45); + buffer.writeBoolean(packet.g46); + buffer.writeBoolean(packet.g47); + buffer.writeBoolean(packet.g48); + buffer.writeBoolean(packet.g49); + buffer.writeBoolean(packet.g5); + buffer.writeBoolean(packet.g50); + buffer.writeBoolean(packet.g51); + buffer.writeBoolean(packet.g52); + buffer.writeBoolean(packet.g53); + buffer.writeBoolean(packet.g54); + buffer.writeBoolean(packet.g55); + buffer.writeBoolean(packet.g56); + buffer.writeBoolean(packet.g57); + buffer.writeBoolean(packet.g58); + buffer.writeBoolean(packet.g59); + buffer.writeBoolean(packet.g6); + buffer.writeBoolean(packet.g60); + buffer.writeBoolean(packet.g61); + buffer.writeBoolean(packet.g62); + buffer.writeBoolean(packet.g63); + buffer.writeBoolean(packet.g64); + buffer.writeBoolean(packet.g65); + buffer.writeBoolean(packet.g66); + buffer.writeBoolean(packet.g67); + buffer.writeBoolean(packet.g68); + buffer.writeBoolean(packet.g69); + buffer.writeBoolean(packet.g7); + buffer.writeBoolean(packet.g70); + buffer.writeBoolean(packet.g71); + buffer.writeBoolean(packet.g72); + buffer.writeBoolean(packet.g73); + buffer.writeBoolean(packet.g74); + buffer.writeBoolean(packet.g75); + buffer.writeBoolean(packet.g76); + buffer.writeBoolean(packet.g77); + buffer.writeBoolean(packet.g78); + buffer.writeBoolean(packet.g79); + buffer.writeBoolean(packet.g8); + buffer.writeBoolean(packet.g80); + buffer.writeBoolean(packet.g81); + buffer.writeBoolean(packet.g82); + buffer.writeBoolean(packet.g83); + buffer.writeBoolean(packet.g84); + buffer.writeBoolean(packet.g85); + buffer.writeBoolean(packet.g86); + buffer.writeBoolean(packet.g87); + buffer.writeBoolean(packet.g88); + buffer.writeBoolean(packet.g9); + buffer.writeBoolean(packet.gg1); + buffer.writeBoolean(packet.gg10); + buffer.writeBoolean(packet.gg11); + buffer.writeBoolean(packet.gg12); + buffer.writeBoolean(packet.gg13); + buffer.writeBoolean(packet.gg14); + buffer.writeBoolean(packet.gg15); + buffer.writeBoolean(packet.gg16); + buffer.writeBoolean(packet.gg17); + buffer.writeBoolean(packet.gg18); + buffer.writeBoolean(packet.gg19); + buffer.writeBoolean(packet.gg2); + buffer.writeBoolean(packet.gg20); + buffer.writeBoolean(packet.gg21); + buffer.writeBoolean(packet.gg22); + buffer.writeBoolean(packet.gg23); + buffer.writeBoolean(packet.gg24); + buffer.writeBoolean(packet.gg25); + buffer.writeBoolean(packet.gg26); + buffer.writeBoolean(packet.gg27); + buffer.writeBoolean(packet.gg28); + buffer.writeBoolean(packet.gg29); + buffer.writeBoolean(packet.gg3); + buffer.writeBoolean(packet.gg30); + buffer.writeBoolean(packet.gg31); + buffer.writeBoolean(packet.gg32); + buffer.writeBoolean(packet.gg33); + buffer.writeBoolean(packet.gg34); + buffer.writeBoolean(packet.gg35); + buffer.writeBoolean(packet.gg36); + buffer.writeBoolean(packet.gg37); + buffer.writeBoolean(packet.gg38); + buffer.writeBoolean(packet.gg39); + buffer.writeBoolean(packet.gg4); + buffer.writeBoolean(packet.gg40); + buffer.writeBoolean(packet.gg41); + buffer.writeBoolean(packet.gg42); + buffer.writeBoolean(packet.gg43); + buffer.writeBoolean(packet.gg44); + buffer.writeBoolean(packet.gg45); + buffer.writeBoolean(packet.gg46); + buffer.writeBoolean(packet.gg47); + buffer.writeBoolean(packet.gg48); + buffer.writeBoolean(packet.gg49); + buffer.writeBoolean(packet.gg5); + buffer.writeBoolean(packet.gg50); + buffer.writeBoolean(packet.gg51); + buffer.writeBoolean(packet.gg52); + buffer.writeBoolean(packet.gg53); + buffer.writeBoolean(packet.gg54); + buffer.writeBoolean(packet.gg55); + buffer.writeBoolean(packet.gg56); + buffer.writeBoolean(packet.gg57); + buffer.writeBoolean(packet.gg58); + buffer.writeBoolean(packet.gg59); + buffer.writeBoolean(packet.gg6); + buffer.writeBoolean(packet.gg60); + buffer.writeBoolean(packet.gg61); + buffer.writeBoolean(packet.gg62); + buffer.writeBoolean(packet.gg63); + buffer.writeBoolean(packet.gg64); + buffer.writeBoolean(packet.gg65); + buffer.writeBoolean(packet.gg66); + buffer.writeBoolean(packet.gg67); + buffer.writeBoolean(packet.gg68); + buffer.writeBoolean(packet.gg69); + buffer.writeBoolean(packet.gg7); + buffer.writeBoolean(packet.gg70); + buffer.writeBoolean(packet.gg71); + buffer.writeBoolean(packet.gg72); + buffer.writeBoolean(packet.gg73); + buffer.writeBoolean(packet.gg74); + buffer.writeBoolean(packet.gg75); + buffer.writeBoolean(packet.gg76); + buffer.writeBoolean(packet.gg77); + buffer.writeBoolean(packet.gg78); + buffer.writeBoolean(packet.gg79); + buffer.writeBoolean(packet.gg8); + buffer.writeBoolean(packet.gg80); + buffer.writeBoolean(packet.gg81); + buffer.writeBoolean(packet.gg82); + buffer.writeBoolean(packet.gg83); + buffer.writeBoolean(packet.gg84); + buffer.writeBoolean(packet.gg85); + buffer.writeBoolean(packet.gg86); + buffer.writeBoolean(packet.gg87); + buffer.writeBoolean(packet.gg88); + buffer.writeBoolean(packet.gg9); + buffer.writeBooleanArray(packet.ggg1); + buffer.writeBooleanArray(packet.ggg10); + buffer.writeBooleanArray(packet.ggg11); + buffer.writeBooleanArray(packet.ggg12); + buffer.writeBooleanArray(packet.ggg13); + buffer.writeBooleanArray(packet.ggg14); + buffer.writeBooleanArray(packet.ggg15); + buffer.writeBooleanArray(packet.ggg16); + buffer.writeBooleanArray(packet.ggg17); + buffer.writeBooleanArray(packet.ggg18); + buffer.writeBooleanArray(packet.ggg19); + buffer.writeBooleanArray(packet.ggg2); + buffer.writeBooleanArray(packet.ggg20); + buffer.writeBooleanArray(packet.ggg21); + buffer.writeBooleanArray(packet.ggg22); + buffer.writeBooleanArray(packet.ggg23); + buffer.writeBooleanArray(packet.ggg24); + buffer.writeBooleanArray(packet.ggg25); + buffer.writeBooleanArray(packet.ggg26); + buffer.writeBooleanArray(packet.ggg27); + buffer.writeBooleanArray(packet.ggg28); + buffer.writeBooleanArray(packet.ggg29); + buffer.writeBooleanArray(packet.ggg3); + buffer.writeBooleanArray(packet.ggg30); + buffer.writeBooleanArray(packet.ggg31); + buffer.writeBooleanArray(packet.ggg32); + buffer.writeBooleanArray(packet.ggg33); + buffer.writeBooleanArray(packet.ggg34); + buffer.writeBooleanArray(packet.ggg35); + buffer.writeBooleanArray(packet.ggg36); + buffer.writeBooleanArray(packet.ggg37); + buffer.writeBooleanArray(packet.ggg38); + buffer.writeBooleanArray(packet.ggg39); + buffer.writeBooleanArray(packet.ggg4); + buffer.writeBooleanArray(packet.ggg40); + buffer.writeBooleanArray(packet.ggg41); + buffer.writeBooleanArray(packet.ggg42); + buffer.writeBooleanArray(packet.ggg43); + buffer.writeBooleanArray(packet.ggg44); + buffer.writeBooleanArray(packet.ggg45); + buffer.writeBooleanArray(packet.ggg46); + buffer.writeBooleanArray(packet.ggg47); + buffer.writeBooleanArray(packet.ggg48); + buffer.writeBooleanArray(packet.ggg49); + buffer.writeBooleanArray(packet.ggg5); + buffer.writeBooleanArray(packet.ggg50); + buffer.writeBooleanArray(packet.ggg51); + buffer.writeBooleanArray(packet.ggg52); + buffer.writeBooleanArray(packet.ggg53); + buffer.writeBooleanArray(packet.ggg54); + buffer.writeBooleanArray(packet.ggg55); + buffer.writeBooleanArray(packet.ggg56); + buffer.writeBooleanArray(packet.ggg57); + buffer.writeBooleanArray(packet.ggg58); + buffer.writeBooleanArray(packet.ggg59); + buffer.writeBooleanArray(packet.ggg6); + buffer.writeBooleanArray(packet.ggg60); + buffer.writeBooleanArray(packet.ggg61); + buffer.writeBooleanArray(packet.ggg62); + buffer.writeBooleanArray(packet.ggg63); + buffer.writeBooleanArray(packet.ggg64); + buffer.writeBooleanArray(packet.ggg65); + buffer.writeBooleanArray(packet.ggg66); + buffer.writeBooleanArray(packet.ggg67); + buffer.writeBooleanArray(packet.ggg68); + buffer.writeBooleanArray(packet.ggg69); + buffer.writeBooleanArray(packet.ggg7); + buffer.writeBooleanArray(packet.ggg70); + buffer.writeBooleanArray(packet.ggg71); + buffer.writeBooleanArray(packet.ggg72); + buffer.writeBooleanArray(packet.ggg73); + buffer.writeBooleanArray(packet.ggg74); + buffer.writeBooleanArray(packet.ggg75); + buffer.writeBooleanArray(packet.ggg76); + buffer.writeBooleanArray(packet.ggg77); + buffer.writeBooleanArray(packet.ggg78); + buffer.writeBooleanArray(packet.ggg79); + buffer.writeBooleanArray(packet.ggg8); + buffer.writeBooleanArray(packet.ggg80); + buffer.writeBooleanArray(packet.ggg81); + buffer.writeBooleanArray(packet.ggg82); + buffer.writeBooleanArray(packet.ggg83); + buffer.writeBooleanArray(packet.ggg84); + buffer.writeBooleanArray(packet.ggg85); + buffer.writeBooleanArray(packet.ggg86); + buffer.writeBooleanArray(packet.ggg87); + buffer.writeBooleanArray(packet.ggg88); + buffer.writeBooleanArray(packet.ggg9); + buffer.writeBooleanArray(packet.gggg1); + buffer.writeBooleanArray(packet.gggg10); + buffer.writeBooleanArray(packet.gggg11); + buffer.writeBooleanArray(packet.gggg12); + buffer.writeBooleanArray(packet.gggg13); + buffer.writeBooleanArray(packet.gggg14); + buffer.writeBooleanArray(packet.gggg15); + buffer.writeBooleanArray(packet.gggg16); + buffer.writeBooleanArray(packet.gggg17); + buffer.writeBooleanArray(packet.gggg18); + buffer.writeBooleanArray(packet.gggg19); + buffer.writeBooleanArray(packet.gggg2); + buffer.writeBooleanArray(packet.gggg20); + buffer.writeBooleanArray(packet.gggg21); + buffer.writeBooleanArray(packet.gggg22); + buffer.writeBooleanArray(packet.gggg23); + buffer.writeBooleanArray(packet.gggg24); + buffer.writeBooleanArray(packet.gggg25); + buffer.writeBooleanArray(packet.gggg26); + buffer.writeBooleanArray(packet.gggg27); + buffer.writeBooleanArray(packet.gggg28); + buffer.writeBooleanArray(packet.gggg29); + buffer.writeBooleanArray(packet.gggg3); + buffer.writeBooleanArray(packet.gggg30); + buffer.writeBooleanArray(packet.gggg31); + buffer.writeBooleanArray(packet.gggg32); + buffer.writeBooleanArray(packet.gggg33); + buffer.writeBooleanArray(packet.gggg34); + buffer.writeBooleanArray(packet.gggg35); + buffer.writeBooleanArray(packet.gggg36); + buffer.writeBooleanArray(packet.gggg37); + buffer.writeBooleanArray(packet.gggg38); + buffer.writeBooleanArray(packet.gggg39); + buffer.writeBooleanArray(packet.gggg4); + buffer.writeBooleanArray(packet.gggg40); + buffer.writeBooleanArray(packet.gggg41); + buffer.writeBooleanArray(packet.gggg42); + buffer.writeBooleanArray(packet.gggg43); + buffer.writeBooleanArray(packet.gggg44); + buffer.writeBooleanArray(packet.gggg45); + buffer.writeBooleanArray(packet.gggg46); + buffer.writeBooleanArray(packet.gggg47); + buffer.writeBooleanArray(packet.gggg48); + buffer.writeBooleanArray(packet.gggg49); + buffer.writeBooleanArray(packet.gggg5); + buffer.writeBooleanArray(packet.gggg50); + buffer.writeBooleanArray(packet.gggg51); + buffer.writeBooleanArray(packet.gggg52); + buffer.writeBooleanArray(packet.gggg53); + buffer.writeBooleanArray(packet.gggg54); + buffer.writeBooleanArray(packet.gggg55); + buffer.writeBooleanArray(packet.gggg56); + buffer.writeBooleanArray(packet.gggg57); + buffer.writeBooleanArray(packet.gggg58); + buffer.writeBooleanArray(packet.gggg59); + buffer.writeBooleanArray(packet.gggg6); + buffer.writeBooleanArray(packet.gggg60); + buffer.writeBooleanArray(packet.gggg61); + buffer.writeBooleanArray(packet.gggg62); + buffer.writeBooleanArray(packet.gggg63); + buffer.writeBooleanArray(packet.gggg64); + buffer.writeBooleanArray(packet.gggg65); + buffer.writeBooleanArray(packet.gggg66); + buffer.writeBooleanArray(packet.gggg67); + buffer.writeBooleanArray(packet.gggg68); + buffer.writeBooleanArray(packet.gggg69); + buffer.writeBooleanArray(packet.gggg7); + buffer.writeBooleanArray(packet.gggg70); + buffer.writeBooleanArray(packet.gggg71); + buffer.writeBooleanArray(packet.gggg72); + buffer.writeBooleanArray(packet.gggg73); + buffer.writeBooleanArray(packet.gggg74); + buffer.writeBooleanArray(packet.gggg75); + buffer.writeBooleanArray(packet.gggg76); + buffer.writeBooleanArray(packet.gggg77); + buffer.writeBooleanArray(packet.gggg78); + buffer.writeBooleanArray(packet.gggg79); + buffer.writeBooleanArray(packet.gggg8); + buffer.writeBooleanArray(packet.gggg80); + buffer.writeBooleanArray(packet.gggg81); + buffer.writeBooleanArray(packet.gggg82); + buffer.writeBooleanArray(packet.gggg83); + buffer.writeBooleanArray(packet.gggg84); + buffer.writeBooleanArray(packet.gggg85); + buffer.writeBooleanArray(packet.gggg86); + buffer.writeBooleanArray(packet.gggg87); + buffer.writeBooleanArray(packet.gggg88); + buffer.writeBooleanArray(packet.gggg9); + buffer.writeString(packet.jj1); + buffer.writeString(packet.jj10); + buffer.writeString(packet.jj11); + buffer.writeString(packet.jj12); + buffer.writeString(packet.jj13); + buffer.writeString(packet.jj14); + buffer.writeString(packet.jj15); + buffer.writeString(packet.jj16); + buffer.writeString(packet.jj17); + buffer.writeString(packet.jj18); + buffer.writeString(packet.jj19); + buffer.writeString(packet.jj2); + buffer.writeString(packet.jj20); + buffer.writeString(packet.jj21); + buffer.writeString(packet.jj22); + buffer.writeString(packet.jj23); + buffer.writeString(packet.jj24); + buffer.writeString(packet.jj25); + buffer.writeString(packet.jj26); + buffer.writeString(packet.jj27); + buffer.writeString(packet.jj28); + buffer.writeString(packet.jj29); + buffer.writeString(packet.jj3); + buffer.writeString(packet.jj30); + buffer.writeString(packet.jj31); + buffer.writeString(packet.jj32); + buffer.writeString(packet.jj33); + buffer.writeString(packet.jj34); + buffer.writeString(packet.jj35); + buffer.writeString(packet.jj36); + buffer.writeString(packet.jj37); + buffer.writeString(packet.jj38); + buffer.writeString(packet.jj39); + buffer.writeString(packet.jj4); + buffer.writeString(packet.jj40); + buffer.writeString(packet.jj41); + buffer.writeString(packet.jj42); + buffer.writeString(packet.jj43); + buffer.writeString(packet.jj44); + buffer.writeString(packet.jj45); + buffer.writeString(packet.jj46); + buffer.writeString(packet.jj47); + buffer.writeString(packet.jj48); + buffer.writeString(packet.jj49); + buffer.writeString(packet.jj5); + buffer.writeString(packet.jj50); + buffer.writeString(packet.jj51); + buffer.writeString(packet.jj52); + buffer.writeString(packet.jj53); + buffer.writeString(packet.jj54); + buffer.writeString(packet.jj55); + buffer.writeString(packet.jj56); + buffer.writeString(packet.jj57); + buffer.writeString(packet.jj58); + buffer.writeString(packet.jj59); + buffer.writeString(packet.jj6); + buffer.writeString(packet.jj60); + buffer.writeString(packet.jj61); + buffer.writeString(packet.jj62); + buffer.writeString(packet.jj63); + buffer.writeString(packet.jj64); + buffer.writeString(packet.jj65); + buffer.writeString(packet.jj66); + buffer.writeString(packet.jj67); + buffer.writeString(packet.jj68); + buffer.writeString(packet.jj69); + buffer.writeString(packet.jj7); + buffer.writeString(packet.jj70); + buffer.writeString(packet.jj71); + buffer.writeString(packet.jj72); + buffer.writeString(packet.jj73); + buffer.writeString(packet.jj74); + buffer.writeString(packet.jj75); + buffer.writeString(packet.jj76); + buffer.writeString(packet.jj77); + buffer.writeString(packet.jj78); + buffer.writeString(packet.jj79); + buffer.writeString(packet.jj8); + buffer.writeString(packet.jj80); + buffer.writeString(packet.jj81); + buffer.writeString(packet.jj82); + buffer.writeString(packet.jj83); + buffer.writeString(packet.jj84); + buffer.writeString(packet.jj85); + buffer.writeString(packet.jj86); + buffer.writeString(packet.jj87); + buffer.writeString(packet.jj88); + buffer.writeString(packet.jj9); + buffer.writeStringArray(packet.jjj1); + buffer.writeStringArray(packet.jjj10); + buffer.writeStringArray(packet.jjj11); + buffer.writeStringArray(packet.jjj12); + buffer.writeStringArray(packet.jjj13); + buffer.writeStringArray(packet.jjj14); + buffer.writeStringArray(packet.jjj15); + buffer.writeStringArray(packet.jjj16); + buffer.writeStringArray(packet.jjj17); + buffer.writeStringArray(packet.jjj18); + buffer.writeStringArray(packet.jjj19); + buffer.writeStringArray(packet.jjj2); + buffer.writeStringArray(packet.jjj20); + buffer.writeStringArray(packet.jjj21); + buffer.writeStringArray(packet.jjj22); + buffer.writeStringArray(packet.jjj23); + buffer.writeStringArray(packet.jjj24); + buffer.writeStringArray(packet.jjj25); + buffer.writeStringArray(packet.jjj26); + buffer.writeStringArray(packet.jjj27); + buffer.writeStringArray(packet.jjj28); + buffer.writeStringArray(packet.jjj29); + buffer.writeStringArray(packet.jjj3); + buffer.writeStringArray(packet.jjj30); + buffer.writeStringArray(packet.jjj31); + buffer.writeStringArray(packet.jjj32); + buffer.writeStringArray(packet.jjj33); + buffer.writeStringArray(packet.jjj34); + buffer.writeStringArray(packet.jjj35); + buffer.writeStringArray(packet.jjj36); + buffer.writeStringArray(packet.jjj37); + buffer.writeStringArray(packet.jjj38); + buffer.writeStringArray(packet.jjj39); + buffer.writeStringArray(packet.jjj4); + buffer.writeStringArray(packet.jjj40); + buffer.writeStringArray(packet.jjj41); + buffer.writeStringArray(packet.jjj42); + buffer.writeStringArray(packet.jjj43); + buffer.writeStringArray(packet.jjj44); + buffer.writeStringArray(packet.jjj45); + buffer.writeStringArray(packet.jjj46); + buffer.writeStringArray(packet.jjj47); + buffer.writeStringArray(packet.jjj48); + buffer.writeStringArray(packet.jjj49); + buffer.writeStringArray(packet.jjj5); + buffer.writeStringArray(packet.jjj50); + buffer.writeStringArray(packet.jjj51); + buffer.writeStringArray(packet.jjj52); + buffer.writeStringArray(packet.jjj53); + buffer.writeStringArray(packet.jjj54); + buffer.writeStringArray(packet.jjj55); + buffer.writeStringArray(packet.jjj56); + buffer.writeStringArray(packet.jjj57); + buffer.writeStringArray(packet.jjj58); + buffer.writeStringArray(packet.jjj59); + buffer.writeStringArray(packet.jjj6); + buffer.writeStringArray(packet.jjj60); + buffer.writeStringArray(packet.jjj61); + buffer.writeStringArray(packet.jjj62); + buffer.writeStringArray(packet.jjj63); + buffer.writeStringArray(packet.jjj64); + buffer.writeStringArray(packet.jjj65); + buffer.writeStringArray(packet.jjj66); + buffer.writeStringArray(packet.jjj67); + buffer.writeStringArray(packet.jjj68); + buffer.writeStringArray(packet.jjj69); + buffer.writeStringArray(packet.jjj7); + buffer.writeStringArray(packet.jjj70); + buffer.writeStringArray(packet.jjj71); + buffer.writeStringArray(packet.jjj72); + buffer.writeStringArray(packet.jjj73); + buffer.writeStringArray(packet.jjj74); + buffer.writeStringArray(packet.jjj75); + buffer.writeStringArray(packet.jjj76); + buffer.writeStringArray(packet.jjj77); + buffer.writeStringArray(packet.jjj78); + buffer.writeStringArray(packet.jjj79); + buffer.writeStringArray(packet.jjj8); + buffer.writeStringArray(packet.jjj80); + buffer.writeStringArray(packet.jjj81); + buffer.writeStringArray(packet.jjj82); + buffer.writeStringArray(packet.jjj83); + buffer.writeStringArray(packet.jjj84); + buffer.writeStringArray(packet.jjj85); + buffer.writeStringArray(packet.jjj86); + buffer.writeStringArray(packet.jjj87); + buffer.writeStringArray(packet.jjj88); + buffer.writeStringArray(packet.jjj9); + buffer.writePacket(packet.kk1, 102); + buffer.writePacket(packet.kk10, 102); + buffer.writePacket(packet.kk11, 102); + buffer.writePacket(packet.kk12, 102); + buffer.writePacket(packet.kk13, 102); + buffer.writePacket(packet.kk14, 102); + buffer.writePacket(packet.kk15, 102); + buffer.writePacket(packet.kk16, 102); + buffer.writePacket(packet.kk17, 102); + buffer.writePacket(packet.kk18, 102); + buffer.writePacket(packet.kk19, 102); + buffer.writePacket(packet.kk2, 102); + buffer.writePacket(packet.kk20, 102); + buffer.writePacket(packet.kk21, 102); + buffer.writePacket(packet.kk22, 102); + buffer.writePacket(packet.kk23, 102); + buffer.writePacket(packet.kk24, 102); + buffer.writePacket(packet.kk25, 102); + buffer.writePacket(packet.kk26, 102); + buffer.writePacket(packet.kk27, 102); + buffer.writePacket(packet.kk28, 102); + buffer.writePacket(packet.kk29, 102); + buffer.writePacket(packet.kk3, 102); + buffer.writePacket(packet.kk30, 102); + buffer.writePacket(packet.kk31, 102); + buffer.writePacket(packet.kk32, 102); + buffer.writePacket(packet.kk33, 102); + buffer.writePacket(packet.kk34, 102); + buffer.writePacket(packet.kk35, 102); + buffer.writePacket(packet.kk36, 102); + buffer.writePacket(packet.kk37, 102); + buffer.writePacket(packet.kk38, 102); + buffer.writePacket(packet.kk39, 102); + buffer.writePacket(packet.kk4, 102); + buffer.writePacket(packet.kk40, 102); + buffer.writePacket(packet.kk41, 102); + buffer.writePacket(packet.kk42, 102); + buffer.writePacket(packet.kk43, 102); + buffer.writePacket(packet.kk44, 102); + buffer.writePacket(packet.kk45, 102); + buffer.writePacket(packet.kk46, 102); + buffer.writePacket(packet.kk47, 102); + buffer.writePacket(packet.kk48, 102); + buffer.writePacket(packet.kk49, 102); + buffer.writePacket(packet.kk5, 102); + buffer.writePacket(packet.kk50, 102); + buffer.writePacket(packet.kk51, 102); + buffer.writePacket(packet.kk52, 102); + buffer.writePacket(packet.kk53, 102); + buffer.writePacket(packet.kk54, 102); + buffer.writePacket(packet.kk55, 102); + buffer.writePacket(packet.kk56, 102); + buffer.writePacket(packet.kk57, 102); + buffer.writePacket(packet.kk58, 102); + buffer.writePacket(packet.kk59, 102); + buffer.writePacket(packet.kk6, 102); + buffer.writePacket(packet.kk60, 102); + buffer.writePacket(packet.kk61, 102); + buffer.writePacket(packet.kk62, 102); + buffer.writePacket(packet.kk63, 102); + buffer.writePacket(packet.kk64, 102); + buffer.writePacket(packet.kk65, 102); + buffer.writePacket(packet.kk66, 102); + buffer.writePacket(packet.kk67, 102); + buffer.writePacket(packet.kk68, 102); + buffer.writePacket(packet.kk69, 102); + buffer.writePacket(packet.kk7, 102); + buffer.writePacket(packet.kk70, 102); + buffer.writePacket(packet.kk71, 102); + buffer.writePacket(packet.kk72, 102); + buffer.writePacket(packet.kk73, 102); + buffer.writePacket(packet.kk74, 102); + buffer.writePacket(packet.kk75, 102); + buffer.writePacket(packet.kk76, 102); + buffer.writePacket(packet.kk77, 102); + buffer.writePacket(packet.kk78, 102); + buffer.writePacket(packet.kk79, 102); + buffer.writePacket(packet.kk8, 102); + buffer.writePacket(packet.kk80, 102); + buffer.writePacket(packet.kk81, 102); + buffer.writePacket(packet.kk82, 102); + buffer.writePacket(packet.kk83, 102); + buffer.writePacket(packet.kk84, 102); + buffer.writePacket(packet.kk85, 102); + buffer.writePacket(packet.kk86, 102); + buffer.writePacket(packet.kk87, 102); + buffer.writePacket(packet.kk88, 102); + buffer.writePacket(packet.kk9, 102); + buffer.writePacketArray(packet.kkk1, 102); + buffer.writePacketArray(packet.kkk10, 102); + buffer.writePacketArray(packet.kkk11, 102); + buffer.writePacketArray(packet.kkk12, 102); + buffer.writePacketArray(packet.kkk13, 102); + buffer.writePacketArray(packet.kkk14, 102); + buffer.writePacketArray(packet.kkk15, 102); + buffer.writePacketArray(packet.kkk16, 102); + buffer.writePacketArray(packet.kkk17, 102); + buffer.writePacketArray(packet.kkk18, 102); + buffer.writePacketArray(packet.kkk19, 102); + buffer.writePacketArray(packet.kkk2, 102); + buffer.writePacketArray(packet.kkk20, 102); + buffer.writePacketArray(packet.kkk21, 102); + buffer.writePacketArray(packet.kkk22, 102); + buffer.writePacketArray(packet.kkk23, 102); + buffer.writePacketArray(packet.kkk24, 102); + buffer.writePacketArray(packet.kkk25, 102); + buffer.writePacketArray(packet.kkk26, 102); + buffer.writePacketArray(packet.kkk27, 102); + buffer.writePacketArray(packet.kkk28, 102); + buffer.writePacketArray(packet.kkk29, 102); + buffer.writePacketArray(packet.kkk3, 102); + buffer.writePacketArray(packet.kkk30, 102); + buffer.writePacketArray(packet.kkk31, 102); + buffer.writePacketArray(packet.kkk32, 102); + buffer.writePacketArray(packet.kkk33, 102); + buffer.writePacketArray(packet.kkk34, 102); + buffer.writePacketArray(packet.kkk35, 102); + buffer.writePacketArray(packet.kkk36, 102); + buffer.writePacketArray(packet.kkk37, 102); + buffer.writePacketArray(packet.kkk38, 102); + buffer.writePacketArray(packet.kkk39, 102); + buffer.writePacketArray(packet.kkk4, 102); + buffer.writePacketArray(packet.kkk40, 102); + buffer.writePacketArray(packet.kkk41, 102); + buffer.writePacketArray(packet.kkk42, 102); + buffer.writePacketArray(packet.kkk43, 102); + buffer.writePacketArray(packet.kkk44, 102); + buffer.writePacketArray(packet.kkk45, 102); + buffer.writePacketArray(packet.kkk46, 102); + buffer.writePacketArray(packet.kkk47, 102); + buffer.writePacketArray(packet.kkk48, 102); + buffer.writePacketArray(packet.kkk49, 102); + buffer.writePacketArray(packet.kkk5, 102); + buffer.writePacketArray(packet.kkk50, 102); + buffer.writePacketArray(packet.kkk51, 102); + buffer.writePacketArray(packet.kkk52, 102); + buffer.writePacketArray(packet.kkk53, 102); + buffer.writePacketArray(packet.kkk54, 102); + buffer.writePacketArray(packet.kkk55, 102); + buffer.writePacketArray(packet.kkk56, 102); + buffer.writePacketArray(packet.kkk57, 102); + buffer.writePacketArray(packet.kkk58, 102); + buffer.writePacketArray(packet.kkk59, 102); + buffer.writePacketArray(packet.kkk6, 102); + buffer.writePacketArray(packet.kkk60, 102); + buffer.writePacketArray(packet.kkk61, 102); + buffer.writePacketArray(packet.kkk62, 102); + buffer.writePacketArray(packet.kkk63, 102); + buffer.writePacketArray(packet.kkk64, 102); + buffer.writePacketArray(packet.kkk65, 102); + buffer.writePacketArray(packet.kkk66, 102); + buffer.writePacketArray(packet.kkk67, 102); + buffer.writePacketArray(packet.kkk68, 102); + buffer.writePacketArray(packet.kkk69, 102); + buffer.writePacketArray(packet.kkk7, 102); + buffer.writePacketArray(packet.kkk70, 102); + buffer.writePacketArray(packet.kkk71, 102); + buffer.writePacketArray(packet.kkk72, 102); + buffer.writePacketArray(packet.kkk73, 102); + buffer.writePacketArray(packet.kkk74, 102); + buffer.writePacketArray(packet.kkk75, 102); + buffer.writePacketArray(packet.kkk76, 102); + buffer.writePacketArray(packet.kkk77, 102); + buffer.writePacketArray(packet.kkk78, 102); + buffer.writePacketArray(packet.kkk79, 102); + buffer.writePacketArray(packet.kkk8, 102); + buffer.writePacketArray(packet.kkk80, 102); + buffer.writePacketArray(packet.kkk81, 102); + buffer.writePacketArray(packet.kkk82, 102); + buffer.writePacketArray(packet.kkk83, 102); + buffer.writePacketArray(packet.kkk84, 102); + buffer.writePacketArray(packet.kkk85, 102); + buffer.writePacketArray(packet.kkk86, 102); + buffer.writePacketArray(packet.kkk87, 102); + buffer.writePacketArray(packet.kkk88, 102); + buffer.writePacketArray(packet.kkk9, 102); + buffer.writeIntList(packet.l1); + buffer.writeIntList(packet.l10); + buffer.writeIntList(packet.l11); + buffer.writeIntList(packet.l12); + buffer.writeIntList(packet.l13); + buffer.writeIntList(packet.l14); + buffer.writeIntList(packet.l15); + buffer.writeIntList(packet.l16); + buffer.writeIntList(packet.l17); + buffer.writeIntList(packet.l18); + buffer.writeIntList(packet.l19); + buffer.writeIntList(packet.l2); + buffer.writeIntList(packet.l20); + buffer.writeIntList(packet.l21); + buffer.writeIntList(packet.l22); + buffer.writeIntList(packet.l23); + buffer.writeIntList(packet.l24); + buffer.writeIntList(packet.l25); + buffer.writeIntList(packet.l26); + buffer.writeIntList(packet.l27); + buffer.writeIntList(packet.l28); + buffer.writeIntList(packet.l29); + buffer.writeIntList(packet.l3); + buffer.writeIntList(packet.l30); + buffer.writeIntList(packet.l31); + buffer.writeIntList(packet.l32); + buffer.writeIntList(packet.l33); + buffer.writeIntList(packet.l34); + buffer.writeIntList(packet.l35); + buffer.writeIntList(packet.l36); + buffer.writeIntList(packet.l37); + buffer.writeIntList(packet.l38); + buffer.writeIntList(packet.l39); + buffer.writeIntList(packet.l4); + buffer.writeIntList(packet.l40); + buffer.writeIntList(packet.l41); + buffer.writeIntList(packet.l42); + buffer.writeIntList(packet.l43); + buffer.writeIntList(packet.l44); + buffer.writeIntList(packet.l45); + buffer.writeIntList(packet.l46); + buffer.writeIntList(packet.l47); + buffer.writeIntList(packet.l48); + buffer.writeIntList(packet.l49); + buffer.writeIntList(packet.l5); + buffer.writeIntList(packet.l50); + buffer.writeIntList(packet.l51); + buffer.writeIntList(packet.l52); + buffer.writeIntList(packet.l53); + buffer.writeIntList(packet.l54); + buffer.writeIntList(packet.l55); + buffer.writeIntList(packet.l56); + buffer.writeIntList(packet.l57); + buffer.writeIntList(packet.l58); + buffer.writeIntList(packet.l59); + buffer.writeIntList(packet.l6); + buffer.writeIntList(packet.l60); + buffer.writeIntList(packet.l61); + buffer.writeIntList(packet.l62); + buffer.writeIntList(packet.l63); + buffer.writeIntList(packet.l64); + buffer.writeIntList(packet.l65); + buffer.writeIntList(packet.l66); + buffer.writeIntList(packet.l67); + buffer.writeIntList(packet.l68); + buffer.writeIntList(packet.l69); + buffer.writeIntList(packet.l7); + buffer.writeIntList(packet.l70); + buffer.writeIntList(packet.l71); + buffer.writeIntList(packet.l72); + buffer.writeIntList(packet.l73); + buffer.writeIntList(packet.l74); + buffer.writeIntList(packet.l75); + buffer.writeIntList(packet.l76); + buffer.writeIntList(packet.l77); + buffer.writeIntList(packet.l78); + buffer.writeIntList(packet.l79); + buffer.writeIntList(packet.l8); + buffer.writeIntList(packet.l80); + buffer.writeIntList(packet.l81); + buffer.writeIntList(packet.l82); + buffer.writeIntList(packet.l83); + buffer.writeIntList(packet.l84); + buffer.writeIntList(packet.l85); + buffer.writeIntList(packet.l86); + buffer.writeIntList(packet.l87); + buffer.writeIntList(packet.l88); + buffer.writeIntList(packet.l9); + buffer.writeStringList(packet.llll1); + buffer.writeStringList(packet.llll10); + buffer.writeStringList(packet.llll11); + buffer.writeStringList(packet.llll12); + buffer.writeStringList(packet.llll13); + buffer.writeStringList(packet.llll14); + buffer.writeStringList(packet.llll15); + buffer.writeStringList(packet.llll16); + buffer.writeStringList(packet.llll17); + buffer.writeStringList(packet.llll18); + buffer.writeStringList(packet.llll19); + buffer.writeStringList(packet.llll2); + buffer.writeStringList(packet.llll20); + buffer.writeStringList(packet.llll21); + buffer.writeStringList(packet.llll22); + buffer.writeStringList(packet.llll23); + buffer.writeStringList(packet.llll24); + buffer.writeStringList(packet.llll25); + buffer.writeStringList(packet.llll26); + buffer.writeStringList(packet.llll27); + buffer.writeStringList(packet.llll28); + buffer.writeStringList(packet.llll29); + buffer.writeStringList(packet.llll3); + buffer.writeStringList(packet.llll30); + buffer.writeStringList(packet.llll31); + buffer.writeStringList(packet.llll32); + buffer.writeStringList(packet.llll33); + buffer.writeStringList(packet.llll34); + buffer.writeStringList(packet.llll35); + buffer.writeStringList(packet.llll36); + buffer.writeStringList(packet.llll37); + buffer.writeStringList(packet.llll38); + buffer.writeStringList(packet.llll39); + buffer.writeStringList(packet.llll4); + buffer.writeStringList(packet.llll40); + buffer.writeStringList(packet.llll41); + buffer.writeStringList(packet.llll42); + buffer.writeStringList(packet.llll43); + buffer.writeStringList(packet.llll44); + buffer.writeStringList(packet.llll45); + buffer.writeStringList(packet.llll46); + buffer.writeStringList(packet.llll47); + buffer.writeStringList(packet.llll48); + buffer.writeStringList(packet.llll49); + buffer.writeStringList(packet.llll5); + buffer.writeStringList(packet.llll50); + buffer.writeStringList(packet.llll51); + buffer.writeStringList(packet.llll52); + buffer.writeStringList(packet.llll53); + buffer.writeStringList(packet.llll54); + buffer.writeStringList(packet.llll55); + buffer.writeStringList(packet.llll56); + buffer.writeStringList(packet.llll57); + buffer.writeStringList(packet.llll58); + buffer.writeStringList(packet.llll59); + buffer.writeStringList(packet.llll6); + buffer.writeStringList(packet.llll60); + buffer.writeStringList(packet.llll61); + buffer.writeStringList(packet.llll62); + buffer.writeStringList(packet.llll63); + buffer.writeStringList(packet.llll64); + buffer.writeStringList(packet.llll65); + buffer.writeStringList(packet.llll66); + buffer.writeStringList(packet.llll67); + buffer.writeStringList(packet.llll68); + buffer.writeStringList(packet.llll69); + buffer.writeStringList(packet.llll7); + buffer.writeStringList(packet.llll70); + buffer.writeStringList(packet.llll71); + buffer.writeStringList(packet.llll72); + buffer.writeStringList(packet.llll73); + buffer.writeStringList(packet.llll74); + buffer.writeStringList(packet.llll75); + buffer.writeStringList(packet.llll76); + buffer.writeStringList(packet.llll77); + buffer.writeStringList(packet.llll78); + buffer.writeStringList(packet.llll79); + buffer.writeStringList(packet.llll8); + buffer.writeStringList(packet.llll80); + buffer.writeStringList(packet.llll81); + buffer.writeStringList(packet.llll82); + buffer.writeStringList(packet.llll83); + buffer.writeStringList(packet.llll84); + buffer.writeStringList(packet.llll85); + buffer.writeStringList(packet.llll86); + buffer.writeStringList(packet.llll87); + buffer.writeStringList(packet.llll88); + buffer.writeStringList(packet.llll9); + buffer.writeIntStringMap(packet.m1); + buffer.writeIntStringMap(packet.m10); + buffer.writeIntStringMap(packet.m11); + buffer.writeIntStringMap(packet.m12); + buffer.writeIntStringMap(packet.m13); + buffer.writeIntStringMap(packet.m14); + buffer.writeIntStringMap(packet.m15); + buffer.writeIntStringMap(packet.m16); + buffer.writeIntStringMap(packet.m17); + buffer.writeIntStringMap(packet.m18); + buffer.writeIntStringMap(packet.m19); + buffer.writeIntStringMap(packet.m2); + buffer.writeIntStringMap(packet.m20); + buffer.writeIntStringMap(packet.m21); + buffer.writeIntStringMap(packet.m22); + buffer.writeIntStringMap(packet.m23); + buffer.writeIntStringMap(packet.m24); + buffer.writeIntStringMap(packet.m25); + buffer.writeIntStringMap(packet.m26); + buffer.writeIntStringMap(packet.m27); + buffer.writeIntStringMap(packet.m28); + buffer.writeIntStringMap(packet.m29); + buffer.writeIntStringMap(packet.m3); + buffer.writeIntStringMap(packet.m30); + buffer.writeIntStringMap(packet.m31); + buffer.writeIntStringMap(packet.m32); + buffer.writeIntStringMap(packet.m33); + buffer.writeIntStringMap(packet.m34); + buffer.writeIntStringMap(packet.m35); + buffer.writeIntStringMap(packet.m36); + buffer.writeIntStringMap(packet.m37); + buffer.writeIntStringMap(packet.m38); + buffer.writeIntStringMap(packet.m39); + buffer.writeIntStringMap(packet.m4); + buffer.writeIntStringMap(packet.m40); + buffer.writeIntStringMap(packet.m41); + buffer.writeIntStringMap(packet.m42); + buffer.writeIntStringMap(packet.m43); + buffer.writeIntStringMap(packet.m44); + buffer.writeIntStringMap(packet.m45); + buffer.writeIntStringMap(packet.m46); + buffer.writeIntStringMap(packet.m47); + buffer.writeIntStringMap(packet.m48); + buffer.writeIntStringMap(packet.m49); + buffer.writeIntStringMap(packet.m5); + buffer.writeIntStringMap(packet.m50); + buffer.writeIntStringMap(packet.m51); + buffer.writeIntStringMap(packet.m52); + buffer.writeIntStringMap(packet.m53); + buffer.writeIntStringMap(packet.m54); + buffer.writeIntStringMap(packet.m55); + buffer.writeIntStringMap(packet.m56); + buffer.writeIntStringMap(packet.m57); + buffer.writeIntStringMap(packet.m58); + buffer.writeIntStringMap(packet.m59); + buffer.writeIntStringMap(packet.m6); + buffer.writeIntStringMap(packet.m60); + buffer.writeIntStringMap(packet.m61); + buffer.writeIntStringMap(packet.m62); + buffer.writeIntStringMap(packet.m63); + buffer.writeIntStringMap(packet.m64); + buffer.writeIntStringMap(packet.m65); + buffer.writeIntStringMap(packet.m66); + buffer.writeIntStringMap(packet.m67); + buffer.writeIntStringMap(packet.m68); + buffer.writeIntStringMap(packet.m69); + buffer.writeIntStringMap(packet.m7); + buffer.writeIntStringMap(packet.m70); + buffer.writeIntStringMap(packet.m71); + buffer.writeIntStringMap(packet.m72); + buffer.writeIntStringMap(packet.m73); + buffer.writeIntStringMap(packet.m74); + buffer.writeIntStringMap(packet.m75); + buffer.writeIntStringMap(packet.m76); + buffer.writeIntStringMap(packet.m77); + buffer.writeIntStringMap(packet.m78); + buffer.writeIntStringMap(packet.m79); + buffer.writeIntStringMap(packet.m8); + buffer.writeIntStringMap(packet.m80); + buffer.writeIntStringMap(packet.m81); + buffer.writeIntStringMap(packet.m82); + buffer.writeIntStringMap(packet.m83); + buffer.writeIntStringMap(packet.m84); + buffer.writeIntStringMap(packet.m85); + buffer.writeIntStringMap(packet.m86); + buffer.writeIntStringMap(packet.m87); + buffer.writeIntStringMap(packet.m88); + buffer.writeIntStringMap(packet.m9); + buffer.writeIntPacketMap(packet.mm1, 102); + buffer.writeIntPacketMap(packet.mm10, 102); + buffer.writeIntPacketMap(packet.mm11, 102); + buffer.writeIntPacketMap(packet.mm12, 102); + buffer.writeIntPacketMap(packet.mm13, 102); + buffer.writeIntPacketMap(packet.mm14, 102); + buffer.writeIntPacketMap(packet.mm15, 102); + buffer.writeIntPacketMap(packet.mm16, 102); + buffer.writeIntPacketMap(packet.mm17, 102); + buffer.writeIntPacketMap(packet.mm18, 102); + buffer.writeIntPacketMap(packet.mm19, 102); + buffer.writeIntPacketMap(packet.mm2, 102); + buffer.writeIntPacketMap(packet.mm20, 102); + buffer.writeIntPacketMap(packet.mm21, 102); + buffer.writeIntPacketMap(packet.mm22, 102); + buffer.writeIntPacketMap(packet.mm23, 102); + buffer.writeIntPacketMap(packet.mm24, 102); + buffer.writeIntPacketMap(packet.mm25, 102); + buffer.writeIntPacketMap(packet.mm26, 102); + buffer.writeIntPacketMap(packet.mm27, 102); + buffer.writeIntPacketMap(packet.mm28, 102); + buffer.writeIntPacketMap(packet.mm29, 102); + buffer.writeIntPacketMap(packet.mm3, 102); + buffer.writeIntPacketMap(packet.mm30, 102); + buffer.writeIntPacketMap(packet.mm31, 102); + buffer.writeIntPacketMap(packet.mm32, 102); + buffer.writeIntPacketMap(packet.mm33, 102); + buffer.writeIntPacketMap(packet.mm34, 102); + buffer.writeIntPacketMap(packet.mm35, 102); + buffer.writeIntPacketMap(packet.mm36, 102); + buffer.writeIntPacketMap(packet.mm37, 102); + buffer.writeIntPacketMap(packet.mm38, 102); + buffer.writeIntPacketMap(packet.mm39, 102); + buffer.writeIntPacketMap(packet.mm4, 102); + buffer.writeIntPacketMap(packet.mm40, 102); + buffer.writeIntPacketMap(packet.mm41, 102); + buffer.writeIntPacketMap(packet.mm42, 102); + buffer.writeIntPacketMap(packet.mm43, 102); + buffer.writeIntPacketMap(packet.mm44, 102); + buffer.writeIntPacketMap(packet.mm45, 102); + buffer.writeIntPacketMap(packet.mm46, 102); + buffer.writeIntPacketMap(packet.mm47, 102); + buffer.writeIntPacketMap(packet.mm48, 102); + buffer.writeIntPacketMap(packet.mm49, 102); + buffer.writeIntPacketMap(packet.mm5, 102); + buffer.writeIntPacketMap(packet.mm50, 102); + buffer.writeIntPacketMap(packet.mm51, 102); + buffer.writeIntPacketMap(packet.mm52, 102); + buffer.writeIntPacketMap(packet.mm53, 102); + buffer.writeIntPacketMap(packet.mm54, 102); + buffer.writeIntPacketMap(packet.mm55, 102); + buffer.writeIntPacketMap(packet.mm56, 102); + buffer.writeIntPacketMap(packet.mm57, 102); + buffer.writeIntPacketMap(packet.mm58, 102); + buffer.writeIntPacketMap(packet.mm59, 102); + buffer.writeIntPacketMap(packet.mm6, 102); + buffer.writeIntPacketMap(packet.mm60, 102); + buffer.writeIntPacketMap(packet.mm61, 102); + buffer.writeIntPacketMap(packet.mm62, 102); + buffer.writeIntPacketMap(packet.mm63, 102); + buffer.writeIntPacketMap(packet.mm64, 102); + buffer.writeIntPacketMap(packet.mm65, 102); + buffer.writeIntPacketMap(packet.mm66, 102); + buffer.writeIntPacketMap(packet.mm67, 102); + buffer.writeIntPacketMap(packet.mm68, 102); + buffer.writeIntPacketMap(packet.mm69, 102); + buffer.writeIntPacketMap(packet.mm7, 102); + buffer.writeIntPacketMap(packet.mm70, 102); + buffer.writeIntPacketMap(packet.mm71, 102); + buffer.writeIntPacketMap(packet.mm72, 102); + buffer.writeIntPacketMap(packet.mm73, 102); + buffer.writeIntPacketMap(packet.mm74, 102); + buffer.writeIntPacketMap(packet.mm75, 102); + buffer.writeIntPacketMap(packet.mm76, 102); + buffer.writeIntPacketMap(packet.mm77, 102); + buffer.writeIntPacketMap(packet.mm78, 102); + buffer.writeIntPacketMap(packet.mm79, 102); + buffer.writeIntPacketMap(packet.mm8, 102); + buffer.writeIntPacketMap(packet.mm80, 102); + buffer.writeIntPacketMap(packet.mm81, 102); + buffer.writeIntPacketMap(packet.mm82, 102); + buffer.writeIntPacketMap(packet.mm83, 102); + buffer.writeIntPacketMap(packet.mm84, 102); + buffer.writeIntPacketMap(packet.mm85, 102); + buffer.writeIntPacketMap(packet.mm86, 102); + buffer.writeIntPacketMap(packet.mm87, 102); + buffer.writeIntPacketMap(packet.mm88, 102); + buffer.writeIntPacketMap(packet.mm9, 102); + buffer.writeIntSet(packet.s1); + buffer.writeIntSet(packet.s10); + buffer.writeIntSet(packet.s11); + buffer.writeIntSet(packet.s12); + buffer.writeIntSet(packet.s13); + buffer.writeIntSet(packet.s14); + buffer.writeIntSet(packet.s15); + buffer.writeIntSet(packet.s16); + buffer.writeIntSet(packet.s17); + buffer.writeIntSet(packet.s18); + buffer.writeIntSet(packet.s19); + buffer.writeIntSet(packet.s2); + buffer.writeIntSet(packet.s20); + buffer.writeIntSet(packet.s21); + buffer.writeIntSet(packet.s22); + buffer.writeIntSet(packet.s23); + buffer.writeIntSet(packet.s24); + buffer.writeIntSet(packet.s25); + buffer.writeIntSet(packet.s26); + buffer.writeIntSet(packet.s27); + buffer.writeIntSet(packet.s28); + buffer.writeIntSet(packet.s29); + buffer.writeIntSet(packet.s3); + buffer.writeIntSet(packet.s30); + buffer.writeIntSet(packet.s31); + buffer.writeIntSet(packet.s32); + buffer.writeIntSet(packet.s33); + buffer.writeIntSet(packet.s34); + buffer.writeIntSet(packet.s35); + buffer.writeIntSet(packet.s36); + buffer.writeIntSet(packet.s37); + buffer.writeIntSet(packet.s38); + buffer.writeIntSet(packet.s39); + buffer.writeIntSet(packet.s4); + buffer.writeIntSet(packet.s40); + buffer.writeIntSet(packet.s41); + buffer.writeIntSet(packet.s42); + buffer.writeIntSet(packet.s43); + buffer.writeIntSet(packet.s44); + buffer.writeIntSet(packet.s45); + buffer.writeIntSet(packet.s46); + buffer.writeIntSet(packet.s47); + buffer.writeIntSet(packet.s48); + buffer.writeIntSet(packet.s49); + buffer.writeIntSet(packet.s5); + buffer.writeIntSet(packet.s50); + buffer.writeIntSet(packet.s51); + buffer.writeIntSet(packet.s52); + buffer.writeIntSet(packet.s53); + buffer.writeIntSet(packet.s54); + buffer.writeIntSet(packet.s55); + buffer.writeIntSet(packet.s56); + buffer.writeIntSet(packet.s57); + buffer.writeIntSet(packet.s58); + buffer.writeIntSet(packet.s59); + buffer.writeIntSet(packet.s6); + buffer.writeIntSet(packet.s60); + buffer.writeIntSet(packet.s61); + buffer.writeIntSet(packet.s62); + buffer.writeIntSet(packet.s63); + buffer.writeIntSet(packet.s64); + buffer.writeIntSet(packet.s65); + buffer.writeIntSet(packet.s66); + buffer.writeIntSet(packet.s67); + buffer.writeIntSet(packet.s68); + buffer.writeIntSet(packet.s69); + buffer.writeIntSet(packet.s7); + buffer.writeIntSet(packet.s70); + buffer.writeIntSet(packet.s71); + buffer.writeIntSet(packet.s72); + buffer.writeIntSet(packet.s73); + buffer.writeIntSet(packet.s74); + buffer.writeIntSet(packet.s75); + buffer.writeIntSet(packet.s76); + buffer.writeIntSet(packet.s77); + buffer.writeIntSet(packet.s78); + buffer.writeIntSet(packet.s79); + buffer.writeIntSet(packet.s8); + buffer.writeIntSet(packet.s80); + buffer.writeIntSet(packet.s81); + buffer.writeIntSet(packet.s82); + buffer.writeIntSet(packet.s83); + buffer.writeIntSet(packet.s84); + buffer.writeIntSet(packet.s85); + buffer.writeIntSet(packet.s86); + buffer.writeIntSet(packet.s87); + buffer.writeIntSet(packet.s88); + buffer.writeIntSet(packet.s9); + buffer.writeStringSet(packet.ssss1); + buffer.writeStringSet(packet.ssss10); + buffer.writeStringSet(packet.ssss11); + buffer.writeStringSet(packet.ssss12); + buffer.writeStringSet(packet.ssss13); + buffer.writeStringSet(packet.ssss14); + buffer.writeStringSet(packet.ssss15); + buffer.writeStringSet(packet.ssss16); + buffer.writeStringSet(packet.ssss17); + buffer.writeStringSet(packet.ssss18); + buffer.writeStringSet(packet.ssss19); + buffer.writeStringSet(packet.ssss2); + buffer.writeStringSet(packet.ssss20); + buffer.writeStringSet(packet.ssss21); + buffer.writeStringSet(packet.ssss22); + buffer.writeStringSet(packet.ssss23); + buffer.writeStringSet(packet.ssss24); + buffer.writeStringSet(packet.ssss25); + buffer.writeStringSet(packet.ssss26); + buffer.writeStringSet(packet.ssss27); + buffer.writeStringSet(packet.ssss28); + buffer.writeStringSet(packet.ssss29); + buffer.writeStringSet(packet.ssss3); + buffer.writeStringSet(packet.ssss30); + buffer.writeStringSet(packet.ssss31); + buffer.writeStringSet(packet.ssss32); + buffer.writeStringSet(packet.ssss33); + buffer.writeStringSet(packet.ssss34); + buffer.writeStringSet(packet.ssss35); + buffer.writeStringSet(packet.ssss36); + buffer.writeStringSet(packet.ssss37); + buffer.writeStringSet(packet.ssss38); + buffer.writeStringSet(packet.ssss39); + buffer.writeStringSet(packet.ssss4); + buffer.writeStringSet(packet.ssss40); + buffer.writeStringSet(packet.ssss41); + buffer.writeStringSet(packet.ssss42); + buffer.writeStringSet(packet.ssss43); + buffer.writeStringSet(packet.ssss44); + buffer.writeStringSet(packet.ssss45); + buffer.writeStringSet(packet.ssss46); + buffer.writeStringSet(packet.ssss47); + buffer.writeStringSet(packet.ssss48); + buffer.writeStringSet(packet.ssss49); + buffer.writeStringSet(packet.ssss5); + buffer.writeStringSet(packet.ssss50); + buffer.writeStringSet(packet.ssss51); + buffer.writeStringSet(packet.ssss52); + buffer.writeStringSet(packet.ssss53); + buffer.writeStringSet(packet.ssss54); + buffer.writeStringSet(packet.ssss55); + buffer.writeStringSet(packet.ssss56); + buffer.writeStringSet(packet.ssss57); + buffer.writeStringSet(packet.ssss58); + buffer.writeStringSet(packet.ssss59); + buffer.writeStringSet(packet.ssss6); + buffer.writeStringSet(packet.ssss60); + buffer.writeStringSet(packet.ssss61); + buffer.writeStringSet(packet.ssss62); + buffer.writeStringSet(packet.ssss63); + buffer.writeStringSet(packet.ssss64); + buffer.writeStringSet(packet.ssss65); + buffer.writeStringSet(packet.ssss66); + buffer.writeStringSet(packet.ssss67); + buffer.writeStringSet(packet.ssss68); + buffer.writeStringSet(packet.ssss69); + buffer.writeStringSet(packet.ssss7); + buffer.writeStringSet(packet.ssss70); + buffer.writeStringSet(packet.ssss71); + buffer.writeStringSet(packet.ssss72); + buffer.writeStringSet(packet.ssss73); + buffer.writeStringSet(packet.ssss74); + buffer.writeStringSet(packet.ssss75); + buffer.writeStringSet(packet.ssss76); + buffer.writeStringSet(packet.ssss77); + buffer.writeStringSet(packet.ssss78); + buffer.writeStringSet(packet.ssss79); + buffer.writeStringSet(packet.ssss8); + buffer.writeStringSet(packet.ssss80); + buffer.writeStringSet(packet.ssss81); + buffer.writeStringSet(packet.ssss82); + buffer.writeStringSet(packet.ssss83); + buffer.writeStringSet(packet.ssss84); + buffer.writeStringSet(packet.ssss85); + buffer.writeStringSet(packet.ssss86); + buffer.writeStringSet(packet.ssss87); + buffer.writeStringSet(packet.ssss88); + buffer.writeStringSet(packet.ssss9); + } + + static read(buffer: any): VeryBigObject | null { + const length = buffer.readInt(); + if (length === 0) { + return null; + } + const readIndex = buffer.getReadOffset(); + const packet = new VeryBigObject(); + const result0 = buffer.readByte(); + packet.a1 = result0; + const result1 = buffer.readByte(); + packet.a10 = result1; + const result2 = buffer.readByte(); + packet.a11 = result2; + const result3 = buffer.readByte(); + packet.a12 = result3; + const result4 = buffer.readByte(); + packet.a13 = result4; + const result5 = buffer.readByte(); + packet.a14 = result5; + const result6 = buffer.readByte(); + packet.a15 = result6; + const result7 = buffer.readByte(); + packet.a16 = result7; + const result8 = buffer.readByte(); + packet.a17 = result8; + const result9 = buffer.readByte(); + packet.a18 = result9; + const result10 = buffer.readByte(); + packet.a19 = result10; + const result11 = buffer.readByte(); + packet.a2 = result11; + const result12 = buffer.readByte(); + packet.a20 = result12; + const result13 = buffer.readByte(); + packet.a21 = result13; + const result14 = buffer.readByte(); + packet.a22 = result14; + const result15 = buffer.readByte(); + packet.a23 = result15; + const result16 = buffer.readByte(); + packet.a24 = result16; + const result17 = buffer.readByte(); + packet.a25 = result17; + const result18 = buffer.readByte(); + packet.a26 = result18; + const result19 = buffer.readByte(); + packet.a27 = result19; + const result20 = buffer.readByte(); + packet.a28 = result20; + const result21 = buffer.readByte(); + packet.a29 = result21; + const result22 = buffer.readByte(); + packet.a3 = result22; + const result23 = buffer.readByte(); + packet.a30 = result23; + const result24 = buffer.readByte(); + packet.a31 = result24; + const result25 = buffer.readByte(); + packet.a32 = result25; + const result26 = buffer.readByte(); + packet.a33 = result26; + const result27 = buffer.readByte(); + packet.a34 = result27; + const result28 = buffer.readByte(); + packet.a35 = result28; + const result29 = buffer.readByte(); + packet.a36 = result29; + const result30 = buffer.readByte(); + packet.a37 = result30; + const result31 = buffer.readByte(); + packet.a38 = result31; + const result32 = buffer.readByte(); + packet.a39 = result32; + const result33 = buffer.readByte(); + packet.a4 = result33; + const result34 = buffer.readByte(); + packet.a40 = result34; + const result35 = buffer.readByte(); + packet.a41 = result35; + const result36 = buffer.readByte(); + packet.a42 = result36; + const result37 = buffer.readByte(); + packet.a43 = result37; + const result38 = buffer.readByte(); + packet.a44 = result38; + const result39 = buffer.readByte(); + packet.a45 = result39; + const result40 = buffer.readByte(); + packet.a46 = result40; + const result41 = buffer.readByte(); + packet.a47 = result41; + const result42 = buffer.readByte(); + packet.a48 = result42; + const result43 = buffer.readByte(); + packet.a49 = result43; + const result44 = buffer.readByte(); + packet.a5 = result44; + const result45 = buffer.readByte(); + packet.a50 = result45; + const result46 = buffer.readByte(); + packet.a51 = result46; + const result47 = buffer.readByte(); + packet.a52 = result47; + const result48 = buffer.readByte(); + packet.a53 = result48; + const result49 = buffer.readByte(); + packet.a54 = result49; + const result50 = buffer.readByte(); + packet.a55 = result50; + const result51 = buffer.readByte(); + packet.a56 = result51; + const result52 = buffer.readByte(); + packet.a57 = result52; + const result53 = buffer.readByte(); + packet.a58 = result53; + const result54 = buffer.readByte(); + packet.a59 = result54; + const result55 = buffer.readByte(); + packet.a6 = result55; + const result56 = buffer.readByte(); + packet.a60 = result56; + const result57 = buffer.readByte(); + packet.a61 = result57; + const result58 = buffer.readByte(); + packet.a62 = result58; + const result59 = buffer.readByte(); + packet.a63 = result59; + const result60 = buffer.readByte(); + packet.a64 = result60; + const result61 = buffer.readByte(); + packet.a65 = result61; + const result62 = buffer.readByte(); + packet.a66 = result62; + const result63 = buffer.readByte(); + packet.a67 = result63; + const result64 = buffer.readByte(); + packet.a68 = result64; + const result65 = buffer.readByte(); + packet.a69 = result65; + const result66 = buffer.readByte(); + packet.a7 = result66; + const result67 = buffer.readByte(); + packet.a70 = result67; + const result68 = buffer.readByte(); + packet.a71 = result68; + const result69 = buffer.readByte(); + packet.a72 = result69; + const result70 = buffer.readByte(); + packet.a73 = result70; + const result71 = buffer.readByte(); + packet.a74 = result71; + const result72 = buffer.readByte(); + packet.a75 = result72; + const result73 = buffer.readByte(); + packet.a76 = result73; + const result74 = buffer.readByte(); + packet.a77 = result74; + const result75 = buffer.readByte(); + packet.a78 = result75; + const result76 = buffer.readByte(); + packet.a79 = result76; + const result77 = buffer.readByte(); + packet.a8 = result77; + const result78 = buffer.readByte(); + packet.a80 = result78; + const result79 = buffer.readByte(); + packet.a81 = result79; + const result80 = buffer.readByte(); + packet.a82 = result80; + const result81 = buffer.readByte(); + packet.a83 = result81; + const result82 = buffer.readByte(); + packet.a84 = result82; + const result83 = buffer.readByte(); + packet.a85 = result83; + const result84 = buffer.readByte(); + packet.a86 = result84; + const result85 = buffer.readByte(); + packet.a87 = result85; + const result86 = buffer.readByte(); + packet.a88 = result86; + const result87 = buffer.readByte(); + packet.a9 = result87; + const result88 = buffer.readByte(); + packet.aa1 = result88; + const result89 = buffer.readByte(); + packet.aa10 = result89; + const result90 = buffer.readByte(); + packet.aa11 = result90; + const result91 = buffer.readByte(); + packet.aa12 = result91; + const result92 = buffer.readByte(); + packet.aa13 = result92; + const result93 = buffer.readByte(); + packet.aa14 = result93; + const result94 = buffer.readByte(); + packet.aa15 = result94; + const result95 = buffer.readByte(); + packet.aa16 = result95; + const result96 = buffer.readByte(); + packet.aa17 = result96; + const result97 = buffer.readByte(); + packet.aa18 = result97; + const result98 = buffer.readByte(); + packet.aa19 = result98; + const result99 = buffer.readByte(); + packet.aa2 = result99; + const result100 = buffer.readByte(); + packet.aa20 = result100; + const result101 = buffer.readByte(); + packet.aa21 = result101; + const result102 = buffer.readByte(); + packet.aa22 = result102; + const result103 = buffer.readByte(); + packet.aa23 = result103; + const result104 = buffer.readByte(); + packet.aa24 = result104; + const result105 = buffer.readByte(); + packet.aa25 = result105; + const result106 = buffer.readByte(); + packet.aa26 = result106; + const result107 = buffer.readByte(); + packet.aa27 = result107; + const result108 = buffer.readByte(); + packet.aa28 = result108; + const result109 = buffer.readByte(); + packet.aa29 = result109; + const result110 = buffer.readByte(); + packet.aa3 = result110; + const result111 = buffer.readByte(); + packet.aa30 = result111; + const result112 = buffer.readByte(); + packet.aa31 = result112; + const result113 = buffer.readByte(); + packet.aa32 = result113; + const result114 = buffer.readByte(); + packet.aa33 = result114; + const result115 = buffer.readByte(); + packet.aa34 = result115; + const result116 = buffer.readByte(); + packet.aa35 = result116; + const result117 = buffer.readByte(); + packet.aa36 = result117; + const result118 = buffer.readByte(); + packet.aa37 = result118; + const result119 = buffer.readByte(); + packet.aa38 = result119; + const result120 = buffer.readByte(); + packet.aa39 = result120; + const result121 = buffer.readByte(); + packet.aa4 = result121; + const result122 = buffer.readByte(); + packet.aa40 = result122; + const result123 = buffer.readByte(); + packet.aa41 = result123; + const result124 = buffer.readByte(); + packet.aa42 = result124; + const result125 = buffer.readByte(); + packet.aa43 = result125; + const result126 = buffer.readByte(); + packet.aa44 = result126; + const result127 = buffer.readByte(); + packet.aa45 = result127; + const result128 = buffer.readByte(); + packet.aa46 = result128; + const result129 = buffer.readByte(); + packet.aa47 = result129; + const result130 = buffer.readByte(); + packet.aa48 = result130; + const result131 = buffer.readByte(); + packet.aa49 = result131; + const result132 = buffer.readByte(); + packet.aa5 = result132; + const result133 = buffer.readByte(); + packet.aa50 = result133; + const result134 = buffer.readByte(); + packet.aa51 = result134; + const result135 = buffer.readByte(); + packet.aa52 = result135; + const result136 = buffer.readByte(); + packet.aa53 = result136; + const result137 = buffer.readByte(); + packet.aa54 = result137; + const result138 = buffer.readByte(); + packet.aa55 = result138; + const result139 = buffer.readByte(); + packet.aa56 = result139; + const result140 = buffer.readByte(); + packet.aa57 = result140; + const result141 = buffer.readByte(); + packet.aa58 = result141; + const result142 = buffer.readByte(); + packet.aa59 = result142; + const result143 = buffer.readByte(); + packet.aa6 = result143; + const result144 = buffer.readByte(); + packet.aa60 = result144; + const result145 = buffer.readByte(); + packet.aa61 = result145; + const result146 = buffer.readByte(); + packet.aa62 = result146; + const result147 = buffer.readByte(); + packet.aa63 = result147; + const result148 = buffer.readByte(); + packet.aa64 = result148; + const result149 = buffer.readByte(); + packet.aa65 = result149; + const result150 = buffer.readByte(); + packet.aa66 = result150; + const result151 = buffer.readByte(); + packet.aa67 = result151; + const result152 = buffer.readByte(); + packet.aa68 = result152; + const result153 = buffer.readByte(); + packet.aa69 = result153; + const result154 = buffer.readByte(); + packet.aa7 = result154; + const result155 = buffer.readByte(); + packet.aa70 = result155; + const result156 = buffer.readByte(); + packet.aa71 = result156; + const result157 = buffer.readByte(); + packet.aa72 = result157; + const result158 = buffer.readByte(); + packet.aa73 = result158; + const result159 = buffer.readByte(); + packet.aa74 = result159; + const result160 = buffer.readByte(); + packet.aa75 = result160; + const result161 = buffer.readByte(); + packet.aa76 = result161; + const result162 = buffer.readByte(); + packet.aa77 = result162; + const result163 = buffer.readByte(); + packet.aa78 = result163; + const result164 = buffer.readByte(); + packet.aa79 = result164; + const result165 = buffer.readByte(); + packet.aa8 = result165; + const result166 = buffer.readByte(); + packet.aa80 = result166; + const result167 = buffer.readByte(); + packet.aa81 = result167; + const result168 = buffer.readByte(); + packet.aa82 = result168; + const result169 = buffer.readByte(); + packet.aa83 = result169; + const result170 = buffer.readByte(); + packet.aa84 = result170; + const result171 = buffer.readByte(); + packet.aa85 = result171; + const result172 = buffer.readByte(); + packet.aa86 = result172; + const result173 = buffer.readByte(); + packet.aa87 = result173; + const result174 = buffer.readByte(); + packet.aa88 = result174; + const result175 = buffer.readByte(); + packet.aa9 = result175; + const array176 = buffer.readByteArray(); + packet.aaa1 = array176; + const array177 = buffer.readByteArray(); + packet.aaa10 = array177; + const array178 = buffer.readByteArray(); + packet.aaa11 = array178; + const array179 = buffer.readByteArray(); + packet.aaa12 = array179; + const array180 = buffer.readByteArray(); + packet.aaa13 = array180; + const array181 = buffer.readByteArray(); + packet.aaa14 = array181; + const array182 = buffer.readByteArray(); + packet.aaa15 = array182; + const array183 = buffer.readByteArray(); + packet.aaa16 = array183; + const array184 = buffer.readByteArray(); + packet.aaa17 = array184; + const array185 = buffer.readByteArray(); + packet.aaa18 = array185; + const array186 = buffer.readByteArray(); + packet.aaa19 = array186; + const array187 = buffer.readByteArray(); + packet.aaa2 = array187; + const array188 = buffer.readByteArray(); + packet.aaa20 = array188; + const array189 = buffer.readByteArray(); + packet.aaa21 = array189; + const array190 = buffer.readByteArray(); + packet.aaa22 = array190; + const array191 = buffer.readByteArray(); + packet.aaa23 = array191; + const array192 = buffer.readByteArray(); + packet.aaa24 = array192; + const array193 = buffer.readByteArray(); + packet.aaa25 = array193; + const array194 = buffer.readByteArray(); + packet.aaa26 = array194; + const array195 = buffer.readByteArray(); + packet.aaa27 = array195; + const array196 = buffer.readByteArray(); + packet.aaa28 = array196; + const array197 = buffer.readByteArray(); + packet.aaa29 = array197; + const array198 = buffer.readByteArray(); + packet.aaa3 = array198; + const array199 = buffer.readByteArray(); + packet.aaa30 = array199; + const array200 = buffer.readByteArray(); + packet.aaa31 = array200; + const array201 = buffer.readByteArray(); + packet.aaa32 = array201; + const array202 = buffer.readByteArray(); + packet.aaa33 = array202; + const array203 = buffer.readByteArray(); + packet.aaa34 = array203; + const array204 = buffer.readByteArray(); + packet.aaa35 = array204; + const array205 = buffer.readByteArray(); + packet.aaa36 = array205; + const array206 = buffer.readByteArray(); + packet.aaa37 = array206; + const array207 = buffer.readByteArray(); + packet.aaa38 = array207; + const array208 = buffer.readByteArray(); + packet.aaa39 = array208; + const array209 = buffer.readByteArray(); + packet.aaa4 = array209; + const array210 = buffer.readByteArray(); + packet.aaa40 = array210; + const array211 = buffer.readByteArray(); + packet.aaa41 = array211; + const array212 = buffer.readByteArray(); + packet.aaa42 = array212; + const array213 = buffer.readByteArray(); + packet.aaa43 = array213; + const array214 = buffer.readByteArray(); + packet.aaa44 = array214; + const array215 = buffer.readByteArray(); + packet.aaa45 = array215; + const array216 = buffer.readByteArray(); + packet.aaa46 = array216; + const array217 = buffer.readByteArray(); + packet.aaa47 = array217; + const array218 = buffer.readByteArray(); + packet.aaa48 = array218; + const array219 = buffer.readByteArray(); + packet.aaa49 = array219; + const array220 = buffer.readByteArray(); + packet.aaa5 = array220; + const array221 = buffer.readByteArray(); + packet.aaa50 = array221; + const array222 = buffer.readByteArray(); + packet.aaa51 = array222; + const array223 = buffer.readByteArray(); + packet.aaa52 = array223; + const array224 = buffer.readByteArray(); + packet.aaa53 = array224; + const array225 = buffer.readByteArray(); + packet.aaa54 = array225; + const array226 = buffer.readByteArray(); + packet.aaa55 = array226; + const array227 = buffer.readByteArray(); + packet.aaa56 = array227; + const array228 = buffer.readByteArray(); + packet.aaa57 = array228; + const array229 = buffer.readByteArray(); + packet.aaa58 = array229; + const array230 = buffer.readByteArray(); + packet.aaa59 = array230; + const array231 = buffer.readByteArray(); + packet.aaa6 = array231; + const array232 = buffer.readByteArray(); + packet.aaa60 = array232; + const array233 = buffer.readByteArray(); + packet.aaa61 = array233; + const array234 = buffer.readByteArray(); + packet.aaa62 = array234; + const array235 = buffer.readByteArray(); + packet.aaa63 = array235; + const array236 = buffer.readByteArray(); + packet.aaa64 = array236; + const array237 = buffer.readByteArray(); + packet.aaa65 = array237; + const array238 = buffer.readByteArray(); + packet.aaa66 = array238; + const array239 = buffer.readByteArray(); + packet.aaa67 = array239; + const array240 = buffer.readByteArray(); + packet.aaa68 = array240; + const array241 = buffer.readByteArray(); + packet.aaa69 = array241; + const array242 = buffer.readByteArray(); + packet.aaa7 = array242; + const array243 = buffer.readByteArray(); + packet.aaa70 = array243; + const array244 = buffer.readByteArray(); + packet.aaa71 = array244; + const array245 = buffer.readByteArray(); + packet.aaa72 = array245; + const array246 = buffer.readByteArray(); + packet.aaa73 = array246; + const array247 = buffer.readByteArray(); + packet.aaa74 = array247; + const array248 = buffer.readByteArray(); + packet.aaa75 = array248; + const array249 = buffer.readByteArray(); + packet.aaa76 = array249; + const array250 = buffer.readByteArray(); + packet.aaa77 = array250; + const array251 = buffer.readByteArray(); + packet.aaa78 = array251; + const array252 = buffer.readByteArray(); + packet.aaa79 = array252; + const array253 = buffer.readByteArray(); + packet.aaa8 = array253; + const array254 = buffer.readByteArray(); + packet.aaa80 = array254; + const array255 = buffer.readByteArray(); + packet.aaa81 = array255; + const array256 = buffer.readByteArray(); + packet.aaa82 = array256; + const array257 = buffer.readByteArray(); + packet.aaa83 = array257; + const array258 = buffer.readByteArray(); + packet.aaa84 = array258; + const array259 = buffer.readByteArray(); + packet.aaa85 = array259; + const array260 = buffer.readByteArray(); + packet.aaa86 = array260; + const array261 = buffer.readByteArray(); + packet.aaa87 = array261; + const array262 = buffer.readByteArray(); + packet.aaa88 = array262; + const array263 = buffer.readByteArray(); + packet.aaa9 = array263; + const array264 = buffer.readByteArray(); + packet.aaaa1 = array264; + const array265 = buffer.readByteArray(); + packet.aaaa10 = array265; + const array266 = buffer.readByteArray(); + packet.aaaa11 = array266; + const array267 = buffer.readByteArray(); + packet.aaaa12 = array267; + const array268 = buffer.readByteArray(); + packet.aaaa13 = array268; + const array269 = buffer.readByteArray(); + packet.aaaa14 = array269; + const array270 = buffer.readByteArray(); + packet.aaaa15 = array270; + const array271 = buffer.readByteArray(); + packet.aaaa16 = array271; + const array272 = buffer.readByteArray(); + packet.aaaa17 = array272; + const array273 = buffer.readByteArray(); + packet.aaaa18 = array273; + const array274 = buffer.readByteArray(); + packet.aaaa19 = array274; + const array275 = buffer.readByteArray(); + packet.aaaa2 = array275; + const array276 = buffer.readByteArray(); + packet.aaaa20 = array276; + const array277 = buffer.readByteArray(); + packet.aaaa21 = array277; + const array278 = buffer.readByteArray(); + packet.aaaa22 = array278; + const array279 = buffer.readByteArray(); + packet.aaaa23 = array279; + const array280 = buffer.readByteArray(); + packet.aaaa24 = array280; + const array281 = buffer.readByteArray(); + packet.aaaa25 = array281; + const array282 = buffer.readByteArray(); + packet.aaaa26 = array282; + const array283 = buffer.readByteArray(); + packet.aaaa27 = array283; + const array284 = buffer.readByteArray(); + packet.aaaa28 = array284; + const array285 = buffer.readByteArray(); + packet.aaaa29 = array285; + const array286 = buffer.readByteArray(); + packet.aaaa3 = array286; + const array287 = buffer.readByteArray(); + packet.aaaa30 = array287; + const array288 = buffer.readByteArray(); + packet.aaaa31 = array288; + const array289 = buffer.readByteArray(); + packet.aaaa32 = array289; + const array290 = buffer.readByteArray(); + packet.aaaa33 = array290; + const array291 = buffer.readByteArray(); + packet.aaaa34 = array291; + const array292 = buffer.readByteArray(); + packet.aaaa35 = array292; + const array293 = buffer.readByteArray(); + packet.aaaa36 = array293; + const array294 = buffer.readByteArray(); + packet.aaaa37 = array294; + const array295 = buffer.readByteArray(); + packet.aaaa38 = array295; + const array296 = buffer.readByteArray(); + packet.aaaa39 = array296; + const array297 = buffer.readByteArray(); + packet.aaaa4 = array297; + const array298 = buffer.readByteArray(); + packet.aaaa40 = array298; + const array299 = buffer.readByteArray(); + packet.aaaa41 = array299; + const array300 = buffer.readByteArray(); + packet.aaaa42 = array300; + const array301 = buffer.readByteArray(); + packet.aaaa43 = array301; + const array302 = buffer.readByteArray(); + packet.aaaa44 = array302; + const array303 = buffer.readByteArray(); + packet.aaaa45 = array303; + const array304 = buffer.readByteArray(); + packet.aaaa46 = array304; + const array305 = buffer.readByteArray(); + packet.aaaa47 = array305; + const array306 = buffer.readByteArray(); + packet.aaaa48 = array306; + const array307 = buffer.readByteArray(); + packet.aaaa49 = array307; + const array308 = buffer.readByteArray(); + packet.aaaa5 = array308; + const array309 = buffer.readByteArray(); + packet.aaaa50 = array309; + const array310 = buffer.readByteArray(); + packet.aaaa51 = array310; + const array311 = buffer.readByteArray(); + packet.aaaa52 = array311; + const array312 = buffer.readByteArray(); + packet.aaaa53 = array312; + const array313 = buffer.readByteArray(); + packet.aaaa54 = array313; + const array314 = buffer.readByteArray(); + packet.aaaa55 = array314; + const array315 = buffer.readByteArray(); + packet.aaaa56 = array315; + const array316 = buffer.readByteArray(); + packet.aaaa57 = array316; + const array317 = buffer.readByteArray(); + packet.aaaa58 = array317; + const array318 = buffer.readByteArray(); + packet.aaaa59 = array318; + const array319 = buffer.readByteArray(); + packet.aaaa6 = array319; + const array320 = buffer.readByteArray(); + packet.aaaa60 = array320; + const array321 = buffer.readByteArray(); + packet.aaaa61 = array321; + const array322 = buffer.readByteArray(); + packet.aaaa62 = array322; + const array323 = buffer.readByteArray(); + packet.aaaa63 = array323; + const array324 = buffer.readByteArray(); + packet.aaaa64 = array324; + const array325 = buffer.readByteArray(); + packet.aaaa65 = array325; + const array326 = buffer.readByteArray(); + packet.aaaa66 = array326; + const array327 = buffer.readByteArray(); + packet.aaaa67 = array327; + const array328 = buffer.readByteArray(); + packet.aaaa68 = array328; + const array329 = buffer.readByteArray(); + packet.aaaa69 = array329; + const array330 = buffer.readByteArray(); + packet.aaaa7 = array330; + const array331 = buffer.readByteArray(); + packet.aaaa70 = array331; + const array332 = buffer.readByteArray(); + packet.aaaa71 = array332; + const array333 = buffer.readByteArray(); + packet.aaaa72 = array333; + const array334 = buffer.readByteArray(); + packet.aaaa73 = array334; + const array335 = buffer.readByteArray(); + packet.aaaa74 = array335; + const array336 = buffer.readByteArray(); + packet.aaaa75 = array336; + const array337 = buffer.readByteArray(); + packet.aaaa76 = array337; + const array338 = buffer.readByteArray(); + packet.aaaa77 = array338; + const array339 = buffer.readByteArray(); + packet.aaaa78 = array339; + const array340 = buffer.readByteArray(); + packet.aaaa79 = array340; + const array341 = buffer.readByteArray(); + packet.aaaa8 = array341; + const array342 = buffer.readByteArray(); + packet.aaaa80 = array342; + const array343 = buffer.readByteArray(); + packet.aaaa81 = array343; + const array344 = buffer.readByteArray(); + packet.aaaa82 = array344; + const array345 = buffer.readByteArray(); + packet.aaaa83 = array345; + const array346 = buffer.readByteArray(); + packet.aaaa84 = array346; + const array347 = buffer.readByteArray(); + packet.aaaa85 = array347; + const array348 = buffer.readByteArray(); + packet.aaaa86 = array348; + const array349 = buffer.readByteArray(); + packet.aaaa87 = array349; + const array350 = buffer.readByteArray(); + packet.aaaa88 = array350; + const array351 = buffer.readByteArray(); + packet.aaaa9 = array351; + const result352 = buffer.readShort(); + packet.b1 = result352; + const result353 = buffer.readShort(); + packet.b10 = result353; + const result354 = buffer.readShort(); + packet.b11 = result354; + const result355 = buffer.readShort(); + packet.b12 = result355; + const result356 = buffer.readShort(); + packet.b13 = result356; + const result357 = buffer.readShort(); + packet.b14 = result357; + const result358 = buffer.readShort(); + packet.b15 = result358; + const result359 = buffer.readShort(); + packet.b16 = result359; + const result360 = buffer.readShort(); + packet.b17 = result360; + const result361 = buffer.readShort(); + packet.b18 = result361; + const result362 = buffer.readShort(); + packet.b19 = result362; + const result363 = buffer.readShort(); + packet.b2 = result363; + const result364 = buffer.readShort(); + packet.b20 = result364; + const result365 = buffer.readShort(); + packet.b21 = result365; + const result366 = buffer.readShort(); + packet.b22 = result366; + const result367 = buffer.readShort(); + packet.b23 = result367; + const result368 = buffer.readShort(); + packet.b24 = result368; + const result369 = buffer.readShort(); + packet.b25 = result369; + const result370 = buffer.readShort(); + packet.b26 = result370; + const result371 = buffer.readShort(); + packet.b27 = result371; + const result372 = buffer.readShort(); + packet.b28 = result372; + const result373 = buffer.readShort(); + packet.b29 = result373; + const result374 = buffer.readShort(); + packet.b3 = result374; + const result375 = buffer.readShort(); + packet.b30 = result375; + const result376 = buffer.readShort(); + packet.b31 = result376; + const result377 = buffer.readShort(); + packet.b32 = result377; + const result378 = buffer.readShort(); + packet.b33 = result378; + const result379 = buffer.readShort(); + packet.b34 = result379; + const result380 = buffer.readShort(); + packet.b35 = result380; + const result381 = buffer.readShort(); + packet.b36 = result381; + const result382 = buffer.readShort(); + packet.b37 = result382; + const result383 = buffer.readShort(); + packet.b38 = result383; + const result384 = buffer.readShort(); + packet.b39 = result384; + const result385 = buffer.readShort(); + packet.b4 = result385; + const result386 = buffer.readShort(); + packet.b40 = result386; + const result387 = buffer.readShort(); + packet.b41 = result387; + const result388 = buffer.readShort(); + packet.b42 = result388; + const result389 = buffer.readShort(); + packet.b43 = result389; + const result390 = buffer.readShort(); + packet.b44 = result390; + const result391 = buffer.readShort(); + packet.b45 = result391; + const result392 = buffer.readShort(); + packet.b46 = result392; + const result393 = buffer.readShort(); + packet.b47 = result393; + const result394 = buffer.readShort(); + packet.b48 = result394; + const result395 = buffer.readShort(); + packet.b49 = result395; + const result396 = buffer.readShort(); + packet.b5 = result396; + const result397 = buffer.readShort(); + packet.b50 = result397; + const result398 = buffer.readShort(); + packet.b51 = result398; + const result399 = buffer.readShort(); + packet.b52 = result399; + const result400 = buffer.readShort(); + packet.b53 = result400; + const result401 = buffer.readShort(); + packet.b54 = result401; + const result402 = buffer.readShort(); + packet.b55 = result402; + const result403 = buffer.readShort(); + packet.b56 = result403; + const result404 = buffer.readShort(); + packet.b57 = result404; + const result405 = buffer.readShort(); + packet.b58 = result405; + const result406 = buffer.readShort(); + packet.b59 = result406; + const result407 = buffer.readShort(); + packet.b6 = result407; + const result408 = buffer.readShort(); + packet.b60 = result408; + const result409 = buffer.readShort(); + packet.b61 = result409; + const result410 = buffer.readShort(); + packet.b62 = result410; + const result411 = buffer.readShort(); + packet.b63 = result411; + const result412 = buffer.readShort(); + packet.b64 = result412; + const result413 = buffer.readShort(); + packet.b65 = result413; + const result414 = buffer.readShort(); + packet.b66 = result414; + const result415 = buffer.readShort(); + packet.b67 = result415; + const result416 = buffer.readShort(); + packet.b68 = result416; + const result417 = buffer.readShort(); + packet.b69 = result417; + const result418 = buffer.readShort(); + packet.b7 = result418; + const result419 = buffer.readShort(); + packet.b70 = result419; + const result420 = buffer.readShort(); + packet.b71 = result420; + const result421 = buffer.readShort(); + packet.b72 = result421; + const result422 = buffer.readShort(); + packet.b73 = result422; + const result423 = buffer.readShort(); + packet.b74 = result423; + const result424 = buffer.readShort(); + packet.b75 = result424; + const result425 = buffer.readShort(); + packet.b76 = result425; + const result426 = buffer.readShort(); + packet.b77 = result426; + const result427 = buffer.readShort(); + packet.b78 = result427; + const result428 = buffer.readShort(); + packet.b79 = result428; + const result429 = buffer.readShort(); + packet.b8 = result429; + const result430 = buffer.readShort(); + packet.b80 = result430; + const result431 = buffer.readShort(); + packet.b81 = result431; + const result432 = buffer.readShort(); + packet.b82 = result432; + const result433 = buffer.readShort(); + packet.b83 = result433; + const result434 = buffer.readShort(); + packet.b84 = result434; + const result435 = buffer.readShort(); + packet.b85 = result435; + const result436 = buffer.readShort(); + packet.b86 = result436; + const result437 = buffer.readShort(); + packet.b87 = result437; + const result438 = buffer.readShort(); + packet.b88 = result438; + const result439 = buffer.readShort(); + packet.b9 = result439; + const result440 = buffer.readShort(); + packet.bb1 = result440; + const result441 = buffer.readShort(); + packet.bb10 = result441; + const result442 = buffer.readShort(); + packet.bb11 = result442; + const result443 = buffer.readShort(); + packet.bb12 = result443; + const result444 = buffer.readShort(); + packet.bb13 = result444; + const result445 = buffer.readShort(); + packet.bb14 = result445; + const result446 = buffer.readShort(); + packet.bb15 = result446; + const result447 = buffer.readShort(); + packet.bb16 = result447; + const result448 = buffer.readShort(); + packet.bb17 = result448; + const result449 = buffer.readShort(); + packet.bb18 = result449; + const result450 = buffer.readShort(); + packet.bb19 = result450; + const result451 = buffer.readShort(); + packet.bb2 = result451; + const result452 = buffer.readShort(); + packet.bb20 = result452; + const result453 = buffer.readShort(); + packet.bb21 = result453; + const result454 = buffer.readShort(); + packet.bb22 = result454; + const result455 = buffer.readShort(); + packet.bb23 = result455; + const result456 = buffer.readShort(); + packet.bb24 = result456; + const result457 = buffer.readShort(); + packet.bb25 = result457; + const result458 = buffer.readShort(); + packet.bb26 = result458; + const result459 = buffer.readShort(); + packet.bb27 = result459; + const result460 = buffer.readShort(); + packet.bb28 = result460; + const result461 = buffer.readShort(); + packet.bb29 = result461; + const result462 = buffer.readShort(); + packet.bb3 = result462; + const result463 = buffer.readShort(); + packet.bb30 = result463; + const result464 = buffer.readShort(); + packet.bb31 = result464; + const result465 = buffer.readShort(); + packet.bb32 = result465; + const result466 = buffer.readShort(); + packet.bb33 = result466; + const result467 = buffer.readShort(); + packet.bb34 = result467; + const result468 = buffer.readShort(); + packet.bb35 = result468; + const result469 = buffer.readShort(); + packet.bb36 = result469; + const result470 = buffer.readShort(); + packet.bb37 = result470; + const result471 = buffer.readShort(); + packet.bb38 = result471; + const result472 = buffer.readShort(); + packet.bb39 = result472; + const result473 = buffer.readShort(); + packet.bb4 = result473; + const result474 = buffer.readShort(); + packet.bb40 = result474; + const result475 = buffer.readShort(); + packet.bb41 = result475; + const result476 = buffer.readShort(); + packet.bb42 = result476; + const result477 = buffer.readShort(); + packet.bb43 = result477; + const result478 = buffer.readShort(); + packet.bb44 = result478; + const result479 = buffer.readShort(); + packet.bb45 = result479; + const result480 = buffer.readShort(); + packet.bb46 = result480; + const result481 = buffer.readShort(); + packet.bb47 = result481; + const result482 = buffer.readShort(); + packet.bb48 = result482; + const result483 = buffer.readShort(); + packet.bb49 = result483; + const result484 = buffer.readShort(); + packet.bb5 = result484; + const result485 = buffer.readShort(); + packet.bb50 = result485; + const result486 = buffer.readShort(); + packet.bb51 = result486; + const result487 = buffer.readShort(); + packet.bb52 = result487; + const result488 = buffer.readShort(); + packet.bb53 = result488; + const result489 = buffer.readShort(); + packet.bb54 = result489; + const result490 = buffer.readShort(); + packet.bb55 = result490; + const result491 = buffer.readShort(); + packet.bb56 = result491; + const result492 = buffer.readShort(); + packet.bb57 = result492; + const result493 = buffer.readShort(); + packet.bb58 = result493; + const result494 = buffer.readShort(); + packet.bb59 = result494; + const result495 = buffer.readShort(); + packet.bb6 = result495; + const result496 = buffer.readShort(); + packet.bb60 = result496; + const result497 = buffer.readShort(); + packet.bb61 = result497; + const result498 = buffer.readShort(); + packet.bb62 = result498; + const result499 = buffer.readShort(); + packet.bb63 = result499; + const result500 = buffer.readShort(); + packet.bb64 = result500; + const result501 = buffer.readShort(); + packet.bb65 = result501; + const result502 = buffer.readShort(); + packet.bb66 = result502; + const result503 = buffer.readShort(); + packet.bb67 = result503; + const result504 = buffer.readShort(); + packet.bb68 = result504; + const result505 = buffer.readShort(); + packet.bb69 = result505; + const result506 = buffer.readShort(); + packet.bb7 = result506; + const result507 = buffer.readShort(); + packet.bb70 = result507; + const result508 = buffer.readShort(); + packet.bb71 = result508; + const result509 = buffer.readShort(); + packet.bb72 = result509; + const result510 = buffer.readShort(); + packet.bb73 = result510; + const result511 = buffer.readShort(); + packet.bb74 = result511; + const result512 = buffer.readShort(); + packet.bb75 = result512; + const result513 = buffer.readShort(); + packet.bb76 = result513; + const result514 = buffer.readShort(); + packet.bb77 = result514; + const result515 = buffer.readShort(); + packet.bb78 = result515; + const result516 = buffer.readShort(); + packet.bb79 = result516; + const result517 = buffer.readShort(); + packet.bb8 = result517; + const result518 = buffer.readShort(); + packet.bb80 = result518; + const result519 = buffer.readShort(); + packet.bb81 = result519; + const result520 = buffer.readShort(); + packet.bb82 = result520; + const result521 = buffer.readShort(); + packet.bb83 = result521; + const result522 = buffer.readShort(); + packet.bb84 = result522; + const result523 = buffer.readShort(); + packet.bb85 = result523; + const result524 = buffer.readShort(); + packet.bb86 = result524; + const result525 = buffer.readShort(); + packet.bb87 = result525; + const result526 = buffer.readShort(); + packet.bb88 = result526; + const result527 = buffer.readShort(); + packet.bb9 = result527; + const array528 = buffer.readShortArray(); + packet.bbb1 = array528; + const array529 = buffer.readShortArray(); + packet.bbb10 = array529; + const array530 = buffer.readShortArray(); + packet.bbb11 = array530; + const array531 = buffer.readShortArray(); + packet.bbb12 = array531; + const array532 = buffer.readShortArray(); + packet.bbb13 = array532; + const array533 = buffer.readShortArray(); + packet.bbb14 = array533; + const array534 = buffer.readShortArray(); + packet.bbb15 = array534; + const array535 = buffer.readShortArray(); + packet.bbb16 = array535; + const array536 = buffer.readShortArray(); + packet.bbb17 = array536; + const array537 = buffer.readShortArray(); + packet.bbb18 = array537; + const array538 = buffer.readShortArray(); + packet.bbb19 = array538; + const array539 = buffer.readShortArray(); + packet.bbb2 = array539; + const array540 = buffer.readShortArray(); + packet.bbb20 = array540; + const array541 = buffer.readShortArray(); + packet.bbb21 = array541; + const array542 = buffer.readShortArray(); + packet.bbb22 = array542; + const array543 = buffer.readShortArray(); + packet.bbb23 = array543; + const array544 = buffer.readShortArray(); + packet.bbb24 = array544; + const array545 = buffer.readShortArray(); + packet.bbb25 = array545; + const array546 = buffer.readShortArray(); + packet.bbb26 = array546; + const array547 = buffer.readShortArray(); + packet.bbb27 = array547; + const array548 = buffer.readShortArray(); + packet.bbb28 = array548; + const array549 = buffer.readShortArray(); + packet.bbb29 = array549; + const array550 = buffer.readShortArray(); + packet.bbb3 = array550; + const array551 = buffer.readShortArray(); + packet.bbb30 = array551; + const array552 = buffer.readShortArray(); + packet.bbb31 = array552; + const array553 = buffer.readShortArray(); + packet.bbb32 = array553; + const array554 = buffer.readShortArray(); + packet.bbb33 = array554; + const array555 = buffer.readShortArray(); + packet.bbb34 = array555; + const array556 = buffer.readShortArray(); + packet.bbb35 = array556; + const array557 = buffer.readShortArray(); + packet.bbb36 = array557; + const array558 = buffer.readShortArray(); + packet.bbb37 = array558; + const array559 = buffer.readShortArray(); + packet.bbb38 = array559; + const array560 = buffer.readShortArray(); + packet.bbb39 = array560; + const array561 = buffer.readShortArray(); + packet.bbb4 = array561; + const array562 = buffer.readShortArray(); + packet.bbb40 = array562; + const array563 = buffer.readShortArray(); + packet.bbb41 = array563; + const array564 = buffer.readShortArray(); + packet.bbb42 = array564; + const array565 = buffer.readShortArray(); + packet.bbb43 = array565; + const array566 = buffer.readShortArray(); + packet.bbb44 = array566; + const array567 = buffer.readShortArray(); + packet.bbb45 = array567; + const array568 = buffer.readShortArray(); + packet.bbb46 = array568; + const array569 = buffer.readShortArray(); + packet.bbb47 = array569; + const array570 = buffer.readShortArray(); + packet.bbb48 = array570; + const array571 = buffer.readShortArray(); + packet.bbb49 = array571; + const array572 = buffer.readShortArray(); + packet.bbb5 = array572; + const array573 = buffer.readShortArray(); + packet.bbb50 = array573; + const array574 = buffer.readShortArray(); + packet.bbb51 = array574; + const array575 = buffer.readShortArray(); + packet.bbb52 = array575; + const array576 = buffer.readShortArray(); + packet.bbb53 = array576; + const array577 = buffer.readShortArray(); + packet.bbb54 = array577; + const array578 = buffer.readShortArray(); + packet.bbb55 = array578; + const array579 = buffer.readShortArray(); + packet.bbb56 = array579; + const array580 = buffer.readShortArray(); + packet.bbb57 = array580; + const array581 = buffer.readShortArray(); + packet.bbb58 = array581; + const array582 = buffer.readShortArray(); + packet.bbb59 = array582; + const array583 = buffer.readShortArray(); + packet.bbb6 = array583; + const array584 = buffer.readShortArray(); + packet.bbb60 = array584; + const array585 = buffer.readShortArray(); + packet.bbb61 = array585; + const array586 = buffer.readShortArray(); + packet.bbb62 = array586; + const array587 = buffer.readShortArray(); + packet.bbb63 = array587; + const array588 = buffer.readShortArray(); + packet.bbb64 = array588; + const array589 = buffer.readShortArray(); + packet.bbb65 = array589; + const array590 = buffer.readShortArray(); + packet.bbb66 = array590; + const array591 = buffer.readShortArray(); + packet.bbb67 = array591; + const array592 = buffer.readShortArray(); + packet.bbb68 = array592; + const array593 = buffer.readShortArray(); + packet.bbb69 = array593; + const array594 = buffer.readShortArray(); + packet.bbb7 = array594; + const array595 = buffer.readShortArray(); + packet.bbb70 = array595; + const array596 = buffer.readShortArray(); + packet.bbb71 = array596; + const array597 = buffer.readShortArray(); + packet.bbb72 = array597; + const array598 = buffer.readShortArray(); + packet.bbb73 = array598; + const array599 = buffer.readShortArray(); + packet.bbb74 = array599; + const array600 = buffer.readShortArray(); + packet.bbb75 = array600; + const array601 = buffer.readShortArray(); + packet.bbb76 = array601; + const array602 = buffer.readShortArray(); + packet.bbb77 = array602; + const array603 = buffer.readShortArray(); + packet.bbb78 = array603; + const array604 = buffer.readShortArray(); + packet.bbb79 = array604; + const array605 = buffer.readShortArray(); + packet.bbb8 = array605; + const array606 = buffer.readShortArray(); + packet.bbb80 = array606; + const array607 = buffer.readShortArray(); + packet.bbb81 = array607; + const array608 = buffer.readShortArray(); + packet.bbb82 = array608; + const array609 = buffer.readShortArray(); + packet.bbb83 = array609; + const array610 = buffer.readShortArray(); + packet.bbb84 = array610; + const array611 = buffer.readShortArray(); + packet.bbb85 = array611; + const array612 = buffer.readShortArray(); + packet.bbb86 = array612; + const array613 = buffer.readShortArray(); + packet.bbb87 = array613; + const array614 = buffer.readShortArray(); + packet.bbb88 = array614; + const array615 = buffer.readShortArray(); + packet.bbb9 = array615; + const array616 = buffer.readShortArray(); + packet.bbbb1 = array616; + const array617 = buffer.readShortArray(); + packet.bbbb10 = array617; + const array618 = buffer.readShortArray(); + packet.bbbb11 = array618; + const array619 = buffer.readShortArray(); + packet.bbbb12 = array619; + const array620 = buffer.readShortArray(); + packet.bbbb13 = array620; + const array621 = buffer.readShortArray(); + packet.bbbb14 = array621; + const array622 = buffer.readShortArray(); + packet.bbbb15 = array622; + const array623 = buffer.readShortArray(); + packet.bbbb16 = array623; + const array624 = buffer.readShortArray(); + packet.bbbb17 = array624; + const array625 = buffer.readShortArray(); + packet.bbbb18 = array625; + const array626 = buffer.readShortArray(); + packet.bbbb19 = array626; + const array627 = buffer.readShortArray(); + packet.bbbb2 = array627; + const array628 = buffer.readShortArray(); + packet.bbbb20 = array628; + const array629 = buffer.readShortArray(); + packet.bbbb21 = array629; + const array630 = buffer.readShortArray(); + packet.bbbb22 = array630; + const array631 = buffer.readShortArray(); + packet.bbbb23 = array631; + const array632 = buffer.readShortArray(); + packet.bbbb24 = array632; + const array633 = buffer.readShortArray(); + packet.bbbb25 = array633; + const array634 = buffer.readShortArray(); + packet.bbbb26 = array634; + const array635 = buffer.readShortArray(); + packet.bbbb27 = array635; + const array636 = buffer.readShortArray(); + packet.bbbb28 = array636; + const array637 = buffer.readShortArray(); + packet.bbbb29 = array637; + const array638 = buffer.readShortArray(); + packet.bbbb3 = array638; + const array639 = buffer.readShortArray(); + packet.bbbb30 = array639; + const array640 = buffer.readShortArray(); + packet.bbbb31 = array640; + const array641 = buffer.readShortArray(); + packet.bbbb32 = array641; + const array642 = buffer.readShortArray(); + packet.bbbb33 = array642; + const array643 = buffer.readShortArray(); + packet.bbbb34 = array643; + const array644 = buffer.readShortArray(); + packet.bbbb35 = array644; + const array645 = buffer.readShortArray(); + packet.bbbb36 = array645; + const array646 = buffer.readShortArray(); + packet.bbbb37 = array646; + const array647 = buffer.readShortArray(); + packet.bbbb38 = array647; + const array648 = buffer.readShortArray(); + packet.bbbb39 = array648; + const array649 = buffer.readShortArray(); + packet.bbbb4 = array649; + const array650 = buffer.readShortArray(); + packet.bbbb40 = array650; + const array651 = buffer.readShortArray(); + packet.bbbb41 = array651; + const array652 = buffer.readShortArray(); + packet.bbbb42 = array652; + const array653 = buffer.readShortArray(); + packet.bbbb43 = array653; + const array654 = buffer.readShortArray(); + packet.bbbb44 = array654; + const array655 = buffer.readShortArray(); + packet.bbbb45 = array655; + const array656 = buffer.readShortArray(); + packet.bbbb46 = array656; + const array657 = buffer.readShortArray(); + packet.bbbb47 = array657; + const array658 = buffer.readShortArray(); + packet.bbbb48 = array658; + const array659 = buffer.readShortArray(); + packet.bbbb49 = array659; + const array660 = buffer.readShortArray(); + packet.bbbb5 = array660; + const array661 = buffer.readShortArray(); + packet.bbbb50 = array661; + const array662 = buffer.readShortArray(); + packet.bbbb51 = array662; + const array663 = buffer.readShortArray(); + packet.bbbb52 = array663; + const array664 = buffer.readShortArray(); + packet.bbbb53 = array664; + const array665 = buffer.readShortArray(); + packet.bbbb54 = array665; + const array666 = buffer.readShortArray(); + packet.bbbb55 = array666; + const array667 = buffer.readShortArray(); + packet.bbbb56 = array667; + const array668 = buffer.readShortArray(); + packet.bbbb57 = array668; + const array669 = buffer.readShortArray(); + packet.bbbb58 = array669; + const array670 = buffer.readShortArray(); + packet.bbbb59 = array670; + const array671 = buffer.readShortArray(); + packet.bbbb6 = array671; + const array672 = buffer.readShortArray(); + packet.bbbb60 = array672; + const array673 = buffer.readShortArray(); + packet.bbbb61 = array673; + const array674 = buffer.readShortArray(); + packet.bbbb62 = array674; + const array675 = buffer.readShortArray(); + packet.bbbb63 = array675; + const array676 = buffer.readShortArray(); + packet.bbbb64 = array676; + const array677 = buffer.readShortArray(); + packet.bbbb65 = array677; + const array678 = buffer.readShortArray(); + packet.bbbb66 = array678; + const array679 = buffer.readShortArray(); + packet.bbbb67 = array679; + const array680 = buffer.readShortArray(); + packet.bbbb68 = array680; + const array681 = buffer.readShortArray(); + packet.bbbb69 = array681; + const array682 = buffer.readShortArray(); + packet.bbbb7 = array682; + const array683 = buffer.readShortArray(); + packet.bbbb70 = array683; + const array684 = buffer.readShortArray(); + packet.bbbb71 = array684; + const array685 = buffer.readShortArray(); + packet.bbbb72 = array685; + const array686 = buffer.readShortArray(); + packet.bbbb73 = array686; + const array687 = buffer.readShortArray(); + packet.bbbb74 = array687; + const array688 = buffer.readShortArray(); + packet.bbbb75 = array688; + const array689 = buffer.readShortArray(); + packet.bbbb76 = array689; + const array690 = buffer.readShortArray(); + packet.bbbb77 = array690; + const array691 = buffer.readShortArray(); + packet.bbbb78 = array691; + const array692 = buffer.readShortArray(); + packet.bbbb79 = array692; + const array693 = buffer.readShortArray(); + packet.bbbb8 = array693; + const array694 = buffer.readShortArray(); + packet.bbbb80 = array694; + const array695 = buffer.readShortArray(); + packet.bbbb81 = array695; + const array696 = buffer.readShortArray(); + packet.bbbb82 = array696; + const array697 = buffer.readShortArray(); + packet.bbbb83 = array697; + const array698 = buffer.readShortArray(); + packet.bbbb84 = array698; + const array699 = buffer.readShortArray(); + packet.bbbb85 = array699; + const array700 = buffer.readShortArray(); + packet.bbbb86 = array700; + const array701 = buffer.readShortArray(); + packet.bbbb87 = array701; + const array702 = buffer.readShortArray(); + packet.bbbb88 = array702; + const array703 = buffer.readShortArray(); + packet.bbbb9 = array703; + const result704 = buffer.readInt(); + packet.c1 = result704; + const result705 = buffer.readInt(); + packet.c10 = result705; + const result706 = buffer.readInt(); + packet.c11 = result706; + const result707 = buffer.readInt(); + packet.c12 = result707; + const result708 = buffer.readInt(); + packet.c13 = result708; + const result709 = buffer.readInt(); + packet.c14 = result709; + const result710 = buffer.readInt(); + packet.c15 = result710; + const result711 = buffer.readInt(); + packet.c16 = result711; + const result712 = buffer.readInt(); + packet.c17 = result712; + const result713 = buffer.readInt(); + packet.c18 = result713; + const result714 = buffer.readInt(); + packet.c19 = result714; + const result715 = buffer.readInt(); + packet.c2 = result715; + const result716 = buffer.readInt(); + packet.c20 = result716; + const result717 = buffer.readInt(); + packet.c21 = result717; + const result718 = buffer.readInt(); + packet.c22 = result718; + const result719 = buffer.readInt(); + packet.c23 = result719; + const result720 = buffer.readInt(); + packet.c24 = result720; + const result721 = buffer.readInt(); + packet.c25 = result721; + const result722 = buffer.readInt(); + packet.c26 = result722; + const result723 = buffer.readInt(); + packet.c27 = result723; + const result724 = buffer.readInt(); + packet.c28 = result724; + const result725 = buffer.readInt(); + packet.c29 = result725; + const result726 = buffer.readInt(); + packet.c3 = result726; + const result727 = buffer.readInt(); + packet.c30 = result727; + const result728 = buffer.readInt(); + packet.c31 = result728; + const result729 = buffer.readInt(); + packet.c32 = result729; + const result730 = buffer.readInt(); + packet.c33 = result730; + const result731 = buffer.readInt(); + packet.c34 = result731; + const result732 = buffer.readInt(); + packet.c35 = result732; + const result733 = buffer.readInt(); + packet.c36 = result733; + const result734 = buffer.readInt(); + packet.c37 = result734; + const result735 = buffer.readInt(); + packet.c38 = result735; + const result736 = buffer.readInt(); + packet.c39 = result736; + const result737 = buffer.readInt(); + packet.c4 = result737; + const result738 = buffer.readInt(); + packet.c40 = result738; + const result739 = buffer.readInt(); + packet.c41 = result739; + const result740 = buffer.readInt(); + packet.c42 = result740; + const result741 = buffer.readInt(); + packet.c43 = result741; + const result742 = buffer.readInt(); + packet.c44 = result742; + const result743 = buffer.readInt(); + packet.c45 = result743; + const result744 = buffer.readInt(); + packet.c46 = result744; + const result745 = buffer.readInt(); + packet.c47 = result745; + const result746 = buffer.readInt(); + packet.c48 = result746; + const result747 = buffer.readInt(); + packet.c49 = result747; + const result748 = buffer.readInt(); + packet.c5 = result748; + const result749 = buffer.readInt(); + packet.c50 = result749; + const result750 = buffer.readInt(); + packet.c51 = result750; + const result751 = buffer.readInt(); + packet.c52 = result751; + const result752 = buffer.readInt(); + packet.c53 = result752; + const result753 = buffer.readInt(); + packet.c54 = result753; + const result754 = buffer.readInt(); + packet.c55 = result754; + const result755 = buffer.readInt(); + packet.c56 = result755; + const result756 = buffer.readInt(); + packet.c57 = result756; + const result757 = buffer.readInt(); + packet.c58 = result757; + const result758 = buffer.readInt(); + packet.c59 = result758; + const result759 = buffer.readInt(); + packet.c6 = result759; + const result760 = buffer.readInt(); + packet.c60 = result760; + const result761 = buffer.readInt(); + packet.c61 = result761; + const result762 = buffer.readInt(); + packet.c62 = result762; + const result763 = buffer.readInt(); + packet.c63 = result763; + const result764 = buffer.readInt(); + packet.c64 = result764; + const result765 = buffer.readInt(); + packet.c65 = result765; + const result766 = buffer.readInt(); + packet.c66 = result766; + const result767 = buffer.readInt(); + packet.c67 = result767; + const result768 = buffer.readInt(); + packet.c68 = result768; + const result769 = buffer.readInt(); + packet.c69 = result769; + const result770 = buffer.readInt(); + packet.c7 = result770; + const result771 = buffer.readInt(); + packet.c70 = result771; + const result772 = buffer.readInt(); + packet.c71 = result772; + const result773 = buffer.readInt(); + packet.c72 = result773; + const result774 = buffer.readInt(); + packet.c73 = result774; + const result775 = buffer.readInt(); + packet.c74 = result775; + const result776 = buffer.readInt(); + packet.c75 = result776; + const result777 = buffer.readInt(); + packet.c76 = result777; + const result778 = buffer.readInt(); + packet.c77 = result778; + const result779 = buffer.readInt(); + packet.c78 = result779; + const result780 = buffer.readInt(); + packet.c79 = result780; + const result781 = buffer.readInt(); + packet.c8 = result781; + const result782 = buffer.readInt(); + packet.c80 = result782; + const result783 = buffer.readInt(); + packet.c81 = result783; + const result784 = buffer.readInt(); + packet.c82 = result784; + const result785 = buffer.readInt(); + packet.c83 = result785; + const result786 = buffer.readInt(); + packet.c84 = result786; + const result787 = buffer.readInt(); + packet.c85 = result787; + const result788 = buffer.readInt(); + packet.c86 = result788; + const result789 = buffer.readInt(); + packet.c87 = result789; + const result790 = buffer.readInt(); + packet.c88 = result790; + const result791 = buffer.readInt(); + packet.c9 = result791; + const result792 = buffer.readInt(); + packet.cc1 = result792; + const result793 = buffer.readInt(); + packet.cc10 = result793; + const result794 = buffer.readInt(); + packet.cc11 = result794; + const result795 = buffer.readInt(); + packet.cc12 = result795; + const result796 = buffer.readInt(); + packet.cc13 = result796; + const result797 = buffer.readInt(); + packet.cc14 = result797; + const result798 = buffer.readInt(); + packet.cc15 = result798; + const result799 = buffer.readInt(); + packet.cc16 = result799; + const result800 = buffer.readInt(); + packet.cc17 = result800; + const result801 = buffer.readInt(); + packet.cc18 = result801; + const result802 = buffer.readInt(); + packet.cc19 = result802; + const result803 = buffer.readInt(); + packet.cc2 = result803; + const result804 = buffer.readInt(); + packet.cc20 = result804; + const result805 = buffer.readInt(); + packet.cc21 = result805; + const result806 = buffer.readInt(); + packet.cc22 = result806; + const result807 = buffer.readInt(); + packet.cc23 = result807; + const result808 = buffer.readInt(); + packet.cc24 = result808; + const result809 = buffer.readInt(); + packet.cc25 = result809; + const result810 = buffer.readInt(); + packet.cc26 = result810; + const result811 = buffer.readInt(); + packet.cc27 = result811; + const result812 = buffer.readInt(); + packet.cc28 = result812; + const result813 = buffer.readInt(); + packet.cc29 = result813; + const result814 = buffer.readInt(); + packet.cc3 = result814; + const result815 = buffer.readInt(); + packet.cc30 = result815; + const result816 = buffer.readInt(); + packet.cc31 = result816; + const result817 = buffer.readInt(); + packet.cc32 = result817; + const result818 = buffer.readInt(); + packet.cc33 = result818; + const result819 = buffer.readInt(); + packet.cc34 = result819; + const result820 = buffer.readInt(); + packet.cc35 = result820; + const result821 = buffer.readInt(); + packet.cc36 = result821; + const result822 = buffer.readInt(); + packet.cc37 = result822; + const result823 = buffer.readInt(); + packet.cc38 = result823; + const result824 = buffer.readInt(); + packet.cc39 = result824; + const result825 = buffer.readInt(); + packet.cc4 = result825; + const result826 = buffer.readInt(); + packet.cc40 = result826; + const result827 = buffer.readInt(); + packet.cc41 = result827; + const result828 = buffer.readInt(); + packet.cc42 = result828; + const result829 = buffer.readInt(); + packet.cc43 = result829; + const result830 = buffer.readInt(); + packet.cc44 = result830; + const result831 = buffer.readInt(); + packet.cc45 = result831; + const result832 = buffer.readInt(); + packet.cc46 = result832; + const result833 = buffer.readInt(); + packet.cc47 = result833; + const result834 = buffer.readInt(); + packet.cc48 = result834; + const result835 = buffer.readInt(); + packet.cc49 = result835; + const result836 = buffer.readInt(); + packet.cc5 = result836; + const result837 = buffer.readInt(); + packet.cc50 = result837; + const result838 = buffer.readInt(); + packet.cc51 = result838; + const result839 = buffer.readInt(); + packet.cc52 = result839; + const result840 = buffer.readInt(); + packet.cc53 = result840; + const result841 = buffer.readInt(); + packet.cc54 = result841; + const result842 = buffer.readInt(); + packet.cc55 = result842; + const result843 = buffer.readInt(); + packet.cc56 = result843; + const result844 = buffer.readInt(); + packet.cc57 = result844; + const result845 = buffer.readInt(); + packet.cc58 = result845; + const result846 = buffer.readInt(); + packet.cc59 = result846; + const result847 = buffer.readInt(); + packet.cc6 = result847; + const result848 = buffer.readInt(); + packet.cc60 = result848; + const result849 = buffer.readInt(); + packet.cc61 = result849; + const result850 = buffer.readInt(); + packet.cc62 = result850; + const result851 = buffer.readInt(); + packet.cc63 = result851; + const result852 = buffer.readInt(); + packet.cc64 = result852; + const result853 = buffer.readInt(); + packet.cc65 = result853; + const result854 = buffer.readInt(); + packet.cc66 = result854; + const result855 = buffer.readInt(); + packet.cc67 = result855; + const result856 = buffer.readInt(); + packet.cc68 = result856; + const result857 = buffer.readInt(); + packet.cc69 = result857; + const result858 = buffer.readInt(); + packet.cc7 = result858; + const result859 = buffer.readInt(); + packet.cc70 = result859; + const result860 = buffer.readInt(); + packet.cc71 = result860; + const result861 = buffer.readInt(); + packet.cc72 = result861; + const result862 = buffer.readInt(); + packet.cc73 = result862; + const result863 = buffer.readInt(); + packet.cc74 = result863; + const result864 = buffer.readInt(); + packet.cc75 = result864; + const result865 = buffer.readInt(); + packet.cc76 = result865; + const result866 = buffer.readInt(); + packet.cc77 = result866; + const result867 = buffer.readInt(); + packet.cc78 = result867; + const result868 = buffer.readInt(); + packet.cc79 = result868; + const result869 = buffer.readInt(); + packet.cc8 = result869; + const result870 = buffer.readInt(); + packet.cc80 = result870; + const result871 = buffer.readInt(); + packet.cc81 = result871; + const result872 = buffer.readInt(); + packet.cc82 = result872; + const result873 = buffer.readInt(); + packet.cc83 = result873; + const result874 = buffer.readInt(); + packet.cc84 = result874; + const result875 = buffer.readInt(); + packet.cc85 = result875; + const result876 = buffer.readInt(); + packet.cc86 = result876; + const result877 = buffer.readInt(); + packet.cc87 = result877; + const result878 = buffer.readInt(); + packet.cc88 = result878; + const result879 = buffer.readInt(); + packet.cc9 = result879; + const array880 = buffer.readIntArray(); + packet.ccc1 = array880; + const array881 = buffer.readIntArray(); + packet.ccc10 = array881; + const array882 = buffer.readIntArray(); + packet.ccc11 = array882; + const array883 = buffer.readIntArray(); + packet.ccc12 = array883; + const array884 = buffer.readIntArray(); + packet.ccc13 = array884; + const array885 = buffer.readIntArray(); + packet.ccc14 = array885; + const array886 = buffer.readIntArray(); + packet.ccc15 = array886; + const array887 = buffer.readIntArray(); + packet.ccc16 = array887; + const array888 = buffer.readIntArray(); + packet.ccc17 = array888; + const array889 = buffer.readIntArray(); + packet.ccc18 = array889; + const array890 = buffer.readIntArray(); + packet.ccc19 = array890; + const array891 = buffer.readIntArray(); + packet.ccc2 = array891; + const array892 = buffer.readIntArray(); + packet.ccc20 = array892; + const array893 = buffer.readIntArray(); + packet.ccc21 = array893; + const array894 = buffer.readIntArray(); + packet.ccc22 = array894; + const array895 = buffer.readIntArray(); + packet.ccc23 = array895; + const array896 = buffer.readIntArray(); + packet.ccc24 = array896; + const array897 = buffer.readIntArray(); + packet.ccc25 = array897; + const array898 = buffer.readIntArray(); + packet.ccc26 = array898; + const array899 = buffer.readIntArray(); + packet.ccc27 = array899; + const array900 = buffer.readIntArray(); + packet.ccc28 = array900; + const array901 = buffer.readIntArray(); + packet.ccc29 = array901; + const array902 = buffer.readIntArray(); + packet.ccc3 = array902; + const array903 = buffer.readIntArray(); + packet.ccc30 = array903; + const array904 = buffer.readIntArray(); + packet.ccc31 = array904; + const array905 = buffer.readIntArray(); + packet.ccc32 = array905; + const array906 = buffer.readIntArray(); + packet.ccc33 = array906; + const array907 = buffer.readIntArray(); + packet.ccc34 = array907; + const array908 = buffer.readIntArray(); + packet.ccc35 = array908; + const array909 = buffer.readIntArray(); + packet.ccc36 = array909; + const array910 = buffer.readIntArray(); + packet.ccc37 = array910; + const array911 = buffer.readIntArray(); + packet.ccc38 = array911; + const array912 = buffer.readIntArray(); + packet.ccc39 = array912; + const array913 = buffer.readIntArray(); + packet.ccc4 = array913; + const array914 = buffer.readIntArray(); + packet.ccc40 = array914; + const array915 = buffer.readIntArray(); + packet.ccc41 = array915; + const array916 = buffer.readIntArray(); + packet.ccc42 = array916; + const array917 = buffer.readIntArray(); + packet.ccc43 = array917; + const array918 = buffer.readIntArray(); + packet.ccc44 = array918; + const array919 = buffer.readIntArray(); + packet.ccc45 = array919; + const array920 = buffer.readIntArray(); + packet.ccc46 = array920; + const array921 = buffer.readIntArray(); + packet.ccc47 = array921; + const array922 = buffer.readIntArray(); + packet.ccc48 = array922; + const array923 = buffer.readIntArray(); + packet.ccc49 = array923; + const array924 = buffer.readIntArray(); + packet.ccc5 = array924; + const array925 = buffer.readIntArray(); + packet.ccc50 = array925; + const array926 = buffer.readIntArray(); + packet.ccc51 = array926; + const array927 = buffer.readIntArray(); + packet.ccc52 = array927; + const array928 = buffer.readIntArray(); + packet.ccc53 = array928; + const array929 = buffer.readIntArray(); + packet.ccc54 = array929; + const array930 = buffer.readIntArray(); + packet.ccc55 = array930; + const array931 = buffer.readIntArray(); + packet.ccc56 = array931; + const array932 = buffer.readIntArray(); + packet.ccc57 = array932; + const array933 = buffer.readIntArray(); + packet.ccc58 = array933; + const array934 = buffer.readIntArray(); + packet.ccc59 = array934; + const array935 = buffer.readIntArray(); + packet.ccc6 = array935; + const array936 = buffer.readIntArray(); + packet.ccc60 = array936; + const array937 = buffer.readIntArray(); + packet.ccc61 = array937; + const array938 = buffer.readIntArray(); + packet.ccc62 = array938; + const array939 = buffer.readIntArray(); + packet.ccc63 = array939; + const array940 = buffer.readIntArray(); + packet.ccc64 = array940; + const array941 = buffer.readIntArray(); + packet.ccc65 = array941; + const array942 = buffer.readIntArray(); + packet.ccc66 = array942; + const array943 = buffer.readIntArray(); + packet.ccc67 = array943; + const array944 = buffer.readIntArray(); + packet.ccc68 = array944; + const array945 = buffer.readIntArray(); + packet.ccc69 = array945; + const array946 = buffer.readIntArray(); + packet.ccc7 = array946; + const array947 = buffer.readIntArray(); + packet.ccc70 = array947; + const array948 = buffer.readIntArray(); + packet.ccc71 = array948; + const array949 = buffer.readIntArray(); + packet.ccc72 = array949; + const array950 = buffer.readIntArray(); + packet.ccc73 = array950; + const array951 = buffer.readIntArray(); + packet.ccc74 = array951; + const array952 = buffer.readIntArray(); + packet.ccc75 = array952; + const array953 = buffer.readIntArray(); + packet.ccc76 = array953; + const array954 = buffer.readIntArray(); + packet.ccc77 = array954; + const array955 = buffer.readIntArray(); + packet.ccc78 = array955; + const array956 = buffer.readIntArray(); + packet.ccc79 = array956; + const array957 = buffer.readIntArray(); + packet.ccc8 = array957; + const array958 = buffer.readIntArray(); + packet.ccc80 = array958; + const array959 = buffer.readIntArray(); + packet.ccc81 = array959; + const array960 = buffer.readIntArray(); + packet.ccc82 = array960; + const array961 = buffer.readIntArray(); + packet.ccc83 = array961; + const array962 = buffer.readIntArray(); + packet.ccc84 = array962; + const array963 = buffer.readIntArray(); + packet.ccc85 = array963; + const array964 = buffer.readIntArray(); + packet.ccc86 = array964; + const array965 = buffer.readIntArray(); + packet.ccc87 = array965; + const array966 = buffer.readIntArray(); + packet.ccc88 = array966; + const array967 = buffer.readIntArray(); + packet.ccc9 = array967; + const array968 = buffer.readIntArray(); + packet.cccc1 = array968; + const array969 = buffer.readIntArray(); + packet.cccc10 = array969; + const array970 = buffer.readIntArray(); + packet.cccc11 = array970; + const array971 = buffer.readIntArray(); + packet.cccc12 = array971; + const array972 = buffer.readIntArray(); + packet.cccc13 = array972; + const array973 = buffer.readIntArray(); + packet.cccc14 = array973; + const array974 = buffer.readIntArray(); + packet.cccc15 = array974; + const array975 = buffer.readIntArray(); + packet.cccc16 = array975; + const array976 = buffer.readIntArray(); + packet.cccc17 = array976; + const array977 = buffer.readIntArray(); + packet.cccc18 = array977; + const array978 = buffer.readIntArray(); + packet.cccc19 = array978; + const array979 = buffer.readIntArray(); + packet.cccc2 = array979; + const array980 = buffer.readIntArray(); + packet.cccc20 = array980; + const array981 = buffer.readIntArray(); + packet.cccc21 = array981; + const array982 = buffer.readIntArray(); + packet.cccc22 = array982; + const array983 = buffer.readIntArray(); + packet.cccc23 = array983; + const array984 = buffer.readIntArray(); + packet.cccc24 = array984; + const array985 = buffer.readIntArray(); + packet.cccc25 = array985; + const array986 = buffer.readIntArray(); + packet.cccc26 = array986; + const array987 = buffer.readIntArray(); + packet.cccc27 = array987; + const array988 = buffer.readIntArray(); + packet.cccc28 = array988; + const array989 = buffer.readIntArray(); + packet.cccc29 = array989; + const array990 = buffer.readIntArray(); + packet.cccc3 = array990; + const array991 = buffer.readIntArray(); + packet.cccc30 = array991; + const array992 = buffer.readIntArray(); + packet.cccc31 = array992; + const array993 = buffer.readIntArray(); + packet.cccc32 = array993; + const array994 = buffer.readIntArray(); + packet.cccc33 = array994; + const array995 = buffer.readIntArray(); + packet.cccc34 = array995; + const array996 = buffer.readIntArray(); + packet.cccc35 = array996; + const array997 = buffer.readIntArray(); + packet.cccc36 = array997; + const array998 = buffer.readIntArray(); + packet.cccc37 = array998; + const array999 = buffer.readIntArray(); + packet.cccc38 = array999; + const array1000 = buffer.readIntArray(); + packet.cccc39 = array1000; + const array1001 = buffer.readIntArray(); + packet.cccc4 = array1001; + const array1002 = buffer.readIntArray(); + packet.cccc40 = array1002; + const array1003 = buffer.readIntArray(); + packet.cccc41 = array1003; + const array1004 = buffer.readIntArray(); + packet.cccc42 = array1004; + const array1005 = buffer.readIntArray(); + packet.cccc43 = array1005; + const array1006 = buffer.readIntArray(); + packet.cccc44 = array1006; + const array1007 = buffer.readIntArray(); + packet.cccc45 = array1007; + const array1008 = buffer.readIntArray(); + packet.cccc46 = array1008; + const array1009 = buffer.readIntArray(); + packet.cccc47 = array1009; + const array1010 = buffer.readIntArray(); + packet.cccc48 = array1010; + const array1011 = buffer.readIntArray(); + packet.cccc49 = array1011; + const array1012 = buffer.readIntArray(); + packet.cccc5 = array1012; + const array1013 = buffer.readIntArray(); + packet.cccc50 = array1013; + const array1014 = buffer.readIntArray(); + packet.cccc51 = array1014; + const array1015 = buffer.readIntArray(); + packet.cccc52 = array1015; + const array1016 = buffer.readIntArray(); + packet.cccc53 = array1016; + const array1017 = buffer.readIntArray(); + packet.cccc54 = array1017; + const array1018 = buffer.readIntArray(); + packet.cccc55 = array1018; + const array1019 = buffer.readIntArray(); + packet.cccc56 = array1019; + const array1020 = buffer.readIntArray(); + packet.cccc57 = array1020; + const array1021 = buffer.readIntArray(); + packet.cccc58 = array1021; + const array1022 = buffer.readIntArray(); + packet.cccc59 = array1022; + const array1023 = buffer.readIntArray(); + packet.cccc6 = array1023; + const array1024 = buffer.readIntArray(); + packet.cccc60 = array1024; + const array1025 = buffer.readIntArray(); + packet.cccc61 = array1025; + const array1026 = buffer.readIntArray(); + packet.cccc62 = array1026; + const array1027 = buffer.readIntArray(); + packet.cccc63 = array1027; + const array1028 = buffer.readIntArray(); + packet.cccc64 = array1028; + const array1029 = buffer.readIntArray(); + packet.cccc65 = array1029; + const array1030 = buffer.readIntArray(); + packet.cccc66 = array1030; + const array1031 = buffer.readIntArray(); + packet.cccc67 = array1031; + const array1032 = buffer.readIntArray(); + packet.cccc68 = array1032; + const array1033 = buffer.readIntArray(); + packet.cccc69 = array1033; + const array1034 = buffer.readIntArray(); + packet.cccc7 = array1034; + const array1035 = buffer.readIntArray(); + packet.cccc70 = array1035; + const array1036 = buffer.readIntArray(); + packet.cccc71 = array1036; + const array1037 = buffer.readIntArray(); + packet.cccc72 = array1037; + const array1038 = buffer.readIntArray(); + packet.cccc73 = array1038; + const array1039 = buffer.readIntArray(); + packet.cccc74 = array1039; + const array1040 = buffer.readIntArray(); + packet.cccc75 = array1040; + const array1041 = buffer.readIntArray(); + packet.cccc76 = array1041; + const array1042 = buffer.readIntArray(); + packet.cccc77 = array1042; + const array1043 = buffer.readIntArray(); + packet.cccc78 = array1043; + const array1044 = buffer.readIntArray(); + packet.cccc79 = array1044; + const array1045 = buffer.readIntArray(); + packet.cccc8 = array1045; + const array1046 = buffer.readIntArray(); + packet.cccc80 = array1046; + const array1047 = buffer.readIntArray(); + packet.cccc81 = array1047; + const array1048 = buffer.readIntArray(); + packet.cccc82 = array1048; + const array1049 = buffer.readIntArray(); + packet.cccc83 = array1049; + const array1050 = buffer.readIntArray(); + packet.cccc84 = array1050; + const array1051 = buffer.readIntArray(); + packet.cccc85 = array1051; + const array1052 = buffer.readIntArray(); + packet.cccc86 = array1052; + const array1053 = buffer.readIntArray(); + packet.cccc87 = array1053; + const array1054 = buffer.readIntArray(); + packet.cccc88 = array1054; + const array1055 = buffer.readIntArray(); + packet.cccc9 = array1055; + const result1056 = buffer.readLong(); + packet.d1 = result1056; + const result1057 = buffer.readLong(); + packet.d10 = result1057; + const result1058 = buffer.readLong(); + packet.d11 = result1058; + const result1059 = buffer.readLong(); + packet.d12 = result1059; + const result1060 = buffer.readLong(); + packet.d13 = result1060; + const result1061 = buffer.readLong(); + packet.d14 = result1061; + const result1062 = buffer.readLong(); + packet.d15 = result1062; + const result1063 = buffer.readLong(); + packet.d16 = result1063; + const result1064 = buffer.readLong(); + packet.d17 = result1064; + const result1065 = buffer.readLong(); + packet.d18 = result1065; + const result1066 = buffer.readLong(); + packet.d19 = result1066; + const result1067 = buffer.readLong(); + packet.d2 = result1067; + const result1068 = buffer.readLong(); + packet.d20 = result1068; + const result1069 = buffer.readLong(); + packet.d21 = result1069; + const result1070 = buffer.readLong(); + packet.d22 = result1070; + const result1071 = buffer.readLong(); + packet.d23 = result1071; + const result1072 = buffer.readLong(); + packet.d24 = result1072; + const result1073 = buffer.readLong(); + packet.d25 = result1073; + const result1074 = buffer.readLong(); + packet.d26 = result1074; + const result1075 = buffer.readLong(); + packet.d27 = result1075; + const result1076 = buffer.readLong(); + packet.d28 = result1076; + const result1077 = buffer.readLong(); + packet.d29 = result1077; + const result1078 = buffer.readLong(); + packet.d3 = result1078; + const result1079 = buffer.readLong(); + packet.d30 = result1079; + const result1080 = buffer.readLong(); + packet.d31 = result1080; + const result1081 = buffer.readLong(); + packet.d32 = result1081; + const result1082 = buffer.readLong(); + packet.d33 = result1082; + const result1083 = buffer.readLong(); + packet.d34 = result1083; + const result1084 = buffer.readLong(); + packet.d35 = result1084; + const result1085 = buffer.readLong(); + packet.d36 = result1085; + const result1086 = buffer.readLong(); + packet.d37 = result1086; + const result1087 = buffer.readLong(); + packet.d38 = result1087; + const result1088 = buffer.readLong(); + packet.d39 = result1088; + const result1089 = buffer.readLong(); + packet.d4 = result1089; + const result1090 = buffer.readLong(); + packet.d40 = result1090; + const result1091 = buffer.readLong(); + packet.d41 = result1091; + const result1092 = buffer.readLong(); + packet.d42 = result1092; + const result1093 = buffer.readLong(); + packet.d43 = result1093; + const result1094 = buffer.readLong(); + packet.d44 = result1094; + const result1095 = buffer.readLong(); + packet.d45 = result1095; + const result1096 = buffer.readLong(); + packet.d46 = result1096; + const result1097 = buffer.readLong(); + packet.d47 = result1097; + const result1098 = buffer.readLong(); + packet.d48 = result1098; + const result1099 = buffer.readLong(); + packet.d49 = result1099; + const result1100 = buffer.readLong(); + packet.d5 = result1100; + const result1101 = buffer.readLong(); + packet.d50 = result1101; + const result1102 = buffer.readLong(); + packet.d51 = result1102; + const result1103 = buffer.readLong(); + packet.d52 = result1103; + const result1104 = buffer.readLong(); + packet.d53 = result1104; + const result1105 = buffer.readLong(); + packet.d54 = result1105; + const result1106 = buffer.readLong(); + packet.d55 = result1106; + const result1107 = buffer.readLong(); + packet.d56 = result1107; + const result1108 = buffer.readLong(); + packet.d57 = result1108; + const result1109 = buffer.readLong(); + packet.d58 = result1109; + const result1110 = buffer.readLong(); + packet.d59 = result1110; + const result1111 = buffer.readLong(); + packet.d6 = result1111; + const result1112 = buffer.readLong(); + packet.d60 = result1112; + const result1113 = buffer.readLong(); + packet.d61 = result1113; + const result1114 = buffer.readLong(); + packet.d62 = result1114; + const result1115 = buffer.readLong(); + packet.d63 = result1115; + const result1116 = buffer.readLong(); + packet.d64 = result1116; + const result1117 = buffer.readLong(); + packet.d65 = result1117; + const result1118 = buffer.readLong(); + packet.d66 = result1118; + const result1119 = buffer.readLong(); + packet.d67 = result1119; + const result1120 = buffer.readLong(); + packet.d68 = result1120; + const result1121 = buffer.readLong(); + packet.d69 = result1121; + const result1122 = buffer.readLong(); + packet.d7 = result1122; + const result1123 = buffer.readLong(); + packet.d70 = result1123; + const result1124 = buffer.readLong(); + packet.d71 = result1124; + const result1125 = buffer.readLong(); + packet.d72 = result1125; + const result1126 = buffer.readLong(); + packet.d73 = result1126; + const result1127 = buffer.readLong(); + packet.d74 = result1127; + const result1128 = buffer.readLong(); + packet.d75 = result1128; + const result1129 = buffer.readLong(); + packet.d76 = result1129; + const result1130 = buffer.readLong(); + packet.d77 = result1130; + const result1131 = buffer.readLong(); + packet.d78 = result1131; + const result1132 = buffer.readLong(); + packet.d79 = result1132; + const result1133 = buffer.readLong(); + packet.d8 = result1133; + const result1134 = buffer.readLong(); + packet.d80 = result1134; + const result1135 = buffer.readLong(); + packet.d81 = result1135; + const result1136 = buffer.readLong(); + packet.d82 = result1136; + const result1137 = buffer.readLong(); + packet.d83 = result1137; + const result1138 = buffer.readLong(); + packet.d84 = result1138; + const result1139 = buffer.readLong(); + packet.d85 = result1139; + const result1140 = buffer.readLong(); + packet.d86 = result1140; + const result1141 = buffer.readLong(); + packet.d87 = result1141; + const result1142 = buffer.readLong(); + packet.d88 = result1142; + const result1143 = buffer.readLong(); + packet.d9 = result1143; + const result1144 = buffer.readLong(); + packet.dd1 = result1144; + const result1145 = buffer.readLong(); + packet.dd10 = result1145; + const result1146 = buffer.readLong(); + packet.dd11 = result1146; + const result1147 = buffer.readLong(); + packet.dd12 = result1147; + const result1148 = buffer.readLong(); + packet.dd13 = result1148; + const result1149 = buffer.readLong(); + packet.dd14 = result1149; + const result1150 = buffer.readLong(); + packet.dd15 = result1150; + const result1151 = buffer.readLong(); + packet.dd16 = result1151; + const result1152 = buffer.readLong(); + packet.dd17 = result1152; + const result1153 = buffer.readLong(); + packet.dd18 = result1153; + const result1154 = buffer.readLong(); + packet.dd19 = result1154; + const result1155 = buffer.readLong(); + packet.dd2 = result1155; + const result1156 = buffer.readLong(); + packet.dd20 = result1156; + const result1157 = buffer.readLong(); + packet.dd21 = result1157; + const result1158 = buffer.readLong(); + packet.dd22 = result1158; + const result1159 = buffer.readLong(); + packet.dd23 = result1159; + const result1160 = buffer.readLong(); + packet.dd24 = result1160; + const result1161 = buffer.readLong(); + packet.dd25 = result1161; + const result1162 = buffer.readLong(); + packet.dd26 = result1162; + const result1163 = buffer.readLong(); + packet.dd27 = result1163; + const result1164 = buffer.readLong(); + packet.dd28 = result1164; + const result1165 = buffer.readLong(); + packet.dd29 = result1165; + const result1166 = buffer.readLong(); + packet.dd3 = result1166; + const result1167 = buffer.readLong(); + packet.dd30 = result1167; + const result1168 = buffer.readLong(); + packet.dd31 = result1168; + const result1169 = buffer.readLong(); + packet.dd32 = result1169; + const result1170 = buffer.readLong(); + packet.dd33 = result1170; + const result1171 = buffer.readLong(); + packet.dd34 = result1171; + const result1172 = buffer.readLong(); + packet.dd35 = result1172; + const result1173 = buffer.readLong(); + packet.dd36 = result1173; + const result1174 = buffer.readLong(); + packet.dd37 = result1174; + const result1175 = buffer.readLong(); + packet.dd38 = result1175; + const result1176 = buffer.readLong(); + packet.dd39 = result1176; + const result1177 = buffer.readLong(); + packet.dd4 = result1177; + const result1178 = buffer.readLong(); + packet.dd40 = result1178; + const result1179 = buffer.readLong(); + packet.dd41 = result1179; + const result1180 = buffer.readLong(); + packet.dd42 = result1180; + const result1181 = buffer.readLong(); + packet.dd43 = result1181; + const result1182 = buffer.readLong(); + packet.dd44 = result1182; + const result1183 = buffer.readLong(); + packet.dd45 = result1183; + const result1184 = buffer.readLong(); + packet.dd46 = result1184; + const result1185 = buffer.readLong(); + packet.dd47 = result1185; + const result1186 = buffer.readLong(); + packet.dd48 = result1186; + const result1187 = buffer.readLong(); + packet.dd49 = result1187; + const result1188 = buffer.readLong(); + packet.dd5 = result1188; + const result1189 = buffer.readLong(); + packet.dd50 = result1189; + const result1190 = buffer.readLong(); + packet.dd51 = result1190; + const result1191 = buffer.readLong(); + packet.dd52 = result1191; + const result1192 = buffer.readLong(); + packet.dd53 = result1192; + const result1193 = buffer.readLong(); + packet.dd54 = result1193; + const result1194 = buffer.readLong(); + packet.dd55 = result1194; + const result1195 = buffer.readLong(); + packet.dd56 = result1195; + const result1196 = buffer.readLong(); + packet.dd57 = result1196; + const result1197 = buffer.readLong(); + packet.dd58 = result1197; + const result1198 = buffer.readLong(); + packet.dd59 = result1198; + const result1199 = buffer.readLong(); + packet.dd6 = result1199; + const result1200 = buffer.readLong(); + packet.dd60 = result1200; + const result1201 = buffer.readLong(); + packet.dd61 = result1201; + const result1202 = buffer.readLong(); + packet.dd62 = result1202; + const result1203 = buffer.readLong(); + packet.dd63 = result1203; + const result1204 = buffer.readLong(); + packet.dd64 = result1204; + const result1205 = buffer.readLong(); + packet.dd65 = result1205; + const result1206 = buffer.readLong(); + packet.dd66 = result1206; + const result1207 = buffer.readLong(); + packet.dd67 = result1207; + const result1208 = buffer.readLong(); + packet.dd68 = result1208; + const result1209 = buffer.readLong(); + packet.dd69 = result1209; + const result1210 = buffer.readLong(); + packet.dd7 = result1210; + const result1211 = buffer.readLong(); + packet.dd70 = result1211; + const result1212 = buffer.readLong(); + packet.dd71 = result1212; + const result1213 = buffer.readLong(); + packet.dd72 = result1213; + const result1214 = buffer.readLong(); + packet.dd73 = result1214; + const result1215 = buffer.readLong(); + packet.dd74 = result1215; + const result1216 = buffer.readLong(); + packet.dd75 = result1216; + const result1217 = buffer.readLong(); + packet.dd76 = result1217; + const result1218 = buffer.readLong(); + packet.dd77 = result1218; + const result1219 = buffer.readLong(); + packet.dd78 = result1219; + const result1220 = buffer.readLong(); + packet.dd79 = result1220; + const result1221 = buffer.readLong(); + packet.dd8 = result1221; + const result1222 = buffer.readLong(); + packet.dd80 = result1222; + const result1223 = buffer.readLong(); + packet.dd81 = result1223; + const result1224 = buffer.readLong(); + packet.dd82 = result1224; + const result1225 = buffer.readLong(); + packet.dd83 = result1225; + const result1226 = buffer.readLong(); + packet.dd84 = result1226; + const result1227 = buffer.readLong(); + packet.dd85 = result1227; + const result1228 = buffer.readLong(); + packet.dd86 = result1228; + const result1229 = buffer.readLong(); + packet.dd87 = result1229; + const result1230 = buffer.readLong(); + packet.dd88 = result1230; + const result1231 = buffer.readLong(); + packet.dd9 = result1231; + const array1232 = buffer.readLongArray(); + packet.ddd1 = array1232; + const array1233 = buffer.readLongArray(); + packet.ddd10 = array1233; + const array1234 = buffer.readLongArray(); + packet.ddd11 = array1234; + const array1235 = buffer.readLongArray(); + packet.ddd12 = array1235; + const array1236 = buffer.readLongArray(); + packet.ddd13 = array1236; + const array1237 = buffer.readLongArray(); + packet.ddd14 = array1237; + const array1238 = buffer.readLongArray(); + packet.ddd15 = array1238; + const array1239 = buffer.readLongArray(); + packet.ddd16 = array1239; + const array1240 = buffer.readLongArray(); + packet.ddd17 = array1240; + const array1241 = buffer.readLongArray(); + packet.ddd18 = array1241; + const array1242 = buffer.readLongArray(); + packet.ddd19 = array1242; + const array1243 = buffer.readLongArray(); + packet.ddd2 = array1243; + const array1244 = buffer.readLongArray(); + packet.ddd20 = array1244; + const array1245 = buffer.readLongArray(); + packet.ddd21 = array1245; + const array1246 = buffer.readLongArray(); + packet.ddd22 = array1246; + const array1247 = buffer.readLongArray(); + packet.ddd23 = array1247; + const array1248 = buffer.readLongArray(); + packet.ddd24 = array1248; + const array1249 = buffer.readLongArray(); + packet.ddd25 = array1249; + const array1250 = buffer.readLongArray(); + packet.ddd26 = array1250; + const array1251 = buffer.readLongArray(); + packet.ddd27 = array1251; + const array1252 = buffer.readLongArray(); + packet.ddd28 = array1252; + const array1253 = buffer.readLongArray(); + packet.ddd29 = array1253; + const array1254 = buffer.readLongArray(); + packet.ddd3 = array1254; + const array1255 = buffer.readLongArray(); + packet.ddd30 = array1255; + const array1256 = buffer.readLongArray(); + packet.ddd31 = array1256; + const array1257 = buffer.readLongArray(); + packet.ddd32 = array1257; + const array1258 = buffer.readLongArray(); + packet.ddd33 = array1258; + const array1259 = buffer.readLongArray(); + packet.ddd34 = array1259; + const array1260 = buffer.readLongArray(); + packet.ddd35 = array1260; + const array1261 = buffer.readLongArray(); + packet.ddd36 = array1261; + const array1262 = buffer.readLongArray(); + packet.ddd37 = array1262; + const array1263 = buffer.readLongArray(); + packet.ddd38 = array1263; + const array1264 = buffer.readLongArray(); + packet.ddd39 = array1264; + const array1265 = buffer.readLongArray(); + packet.ddd4 = array1265; + const array1266 = buffer.readLongArray(); + packet.ddd40 = array1266; + const array1267 = buffer.readLongArray(); + packet.ddd41 = array1267; + const array1268 = buffer.readLongArray(); + packet.ddd42 = array1268; + const array1269 = buffer.readLongArray(); + packet.ddd43 = array1269; + const array1270 = buffer.readLongArray(); + packet.ddd44 = array1270; + const array1271 = buffer.readLongArray(); + packet.ddd45 = array1271; + const array1272 = buffer.readLongArray(); + packet.ddd46 = array1272; + const array1273 = buffer.readLongArray(); + packet.ddd47 = array1273; + const array1274 = buffer.readLongArray(); + packet.ddd48 = array1274; + const array1275 = buffer.readLongArray(); + packet.ddd49 = array1275; + const array1276 = buffer.readLongArray(); + packet.ddd5 = array1276; + const array1277 = buffer.readLongArray(); + packet.ddd50 = array1277; + const array1278 = buffer.readLongArray(); + packet.ddd51 = array1278; + const array1279 = buffer.readLongArray(); + packet.ddd52 = array1279; + const array1280 = buffer.readLongArray(); + packet.ddd53 = array1280; + const array1281 = buffer.readLongArray(); + packet.ddd54 = array1281; + const array1282 = buffer.readLongArray(); + packet.ddd55 = array1282; + const array1283 = buffer.readLongArray(); + packet.ddd56 = array1283; + const array1284 = buffer.readLongArray(); + packet.ddd57 = array1284; + const array1285 = buffer.readLongArray(); + packet.ddd58 = array1285; + const array1286 = buffer.readLongArray(); + packet.ddd59 = array1286; + const array1287 = buffer.readLongArray(); + packet.ddd6 = array1287; + const array1288 = buffer.readLongArray(); + packet.ddd60 = array1288; + const array1289 = buffer.readLongArray(); + packet.ddd61 = array1289; + const array1290 = buffer.readLongArray(); + packet.ddd62 = array1290; + const array1291 = buffer.readLongArray(); + packet.ddd63 = array1291; + const array1292 = buffer.readLongArray(); + packet.ddd64 = array1292; + const array1293 = buffer.readLongArray(); + packet.ddd65 = array1293; + const array1294 = buffer.readLongArray(); + packet.ddd66 = array1294; + const array1295 = buffer.readLongArray(); + packet.ddd67 = array1295; + const array1296 = buffer.readLongArray(); + packet.ddd68 = array1296; + const array1297 = buffer.readLongArray(); + packet.ddd69 = array1297; + const array1298 = buffer.readLongArray(); + packet.ddd7 = array1298; + const array1299 = buffer.readLongArray(); + packet.ddd70 = array1299; + const array1300 = buffer.readLongArray(); + packet.ddd71 = array1300; + const array1301 = buffer.readLongArray(); + packet.ddd72 = array1301; + const array1302 = buffer.readLongArray(); + packet.ddd73 = array1302; + const array1303 = buffer.readLongArray(); + packet.ddd74 = array1303; + const array1304 = buffer.readLongArray(); + packet.ddd75 = array1304; + const array1305 = buffer.readLongArray(); + packet.ddd76 = array1305; + const array1306 = buffer.readLongArray(); + packet.ddd77 = array1306; + const array1307 = buffer.readLongArray(); + packet.ddd78 = array1307; + const array1308 = buffer.readLongArray(); + packet.ddd79 = array1308; + const array1309 = buffer.readLongArray(); + packet.ddd8 = array1309; + const array1310 = buffer.readLongArray(); + packet.ddd80 = array1310; + const array1311 = buffer.readLongArray(); + packet.ddd81 = array1311; + const array1312 = buffer.readLongArray(); + packet.ddd82 = array1312; + const array1313 = buffer.readLongArray(); + packet.ddd83 = array1313; + const array1314 = buffer.readLongArray(); + packet.ddd84 = array1314; + const array1315 = buffer.readLongArray(); + packet.ddd85 = array1315; + const array1316 = buffer.readLongArray(); + packet.ddd86 = array1316; + const array1317 = buffer.readLongArray(); + packet.ddd87 = array1317; + const array1318 = buffer.readLongArray(); + packet.ddd88 = array1318; + const array1319 = buffer.readLongArray(); + packet.ddd9 = array1319; + const array1320 = buffer.readLongArray(); + packet.dddd1 = array1320; + const array1321 = buffer.readLongArray(); + packet.dddd10 = array1321; + const array1322 = buffer.readLongArray(); + packet.dddd11 = array1322; + const array1323 = buffer.readLongArray(); + packet.dddd12 = array1323; + const array1324 = buffer.readLongArray(); + packet.dddd13 = array1324; + const array1325 = buffer.readLongArray(); + packet.dddd14 = array1325; + const array1326 = buffer.readLongArray(); + packet.dddd15 = array1326; + const array1327 = buffer.readLongArray(); + packet.dddd16 = array1327; + const array1328 = buffer.readLongArray(); + packet.dddd17 = array1328; + const array1329 = buffer.readLongArray(); + packet.dddd18 = array1329; + const array1330 = buffer.readLongArray(); + packet.dddd19 = array1330; + const array1331 = buffer.readLongArray(); + packet.dddd2 = array1331; + const array1332 = buffer.readLongArray(); + packet.dddd20 = array1332; + const array1333 = buffer.readLongArray(); + packet.dddd21 = array1333; + const array1334 = buffer.readLongArray(); + packet.dddd22 = array1334; + const array1335 = buffer.readLongArray(); + packet.dddd23 = array1335; + const array1336 = buffer.readLongArray(); + packet.dddd24 = array1336; + const array1337 = buffer.readLongArray(); + packet.dddd25 = array1337; + const array1338 = buffer.readLongArray(); + packet.dddd26 = array1338; + const array1339 = buffer.readLongArray(); + packet.dddd27 = array1339; + const array1340 = buffer.readLongArray(); + packet.dddd28 = array1340; + const array1341 = buffer.readLongArray(); + packet.dddd29 = array1341; + const array1342 = buffer.readLongArray(); + packet.dddd3 = array1342; + const array1343 = buffer.readLongArray(); + packet.dddd30 = array1343; + const array1344 = buffer.readLongArray(); + packet.dddd31 = array1344; + const array1345 = buffer.readLongArray(); + packet.dddd32 = array1345; + const array1346 = buffer.readLongArray(); + packet.dddd33 = array1346; + const array1347 = buffer.readLongArray(); + packet.dddd34 = array1347; + const array1348 = buffer.readLongArray(); + packet.dddd35 = array1348; + const array1349 = buffer.readLongArray(); + packet.dddd36 = array1349; + const array1350 = buffer.readLongArray(); + packet.dddd37 = array1350; + const array1351 = buffer.readLongArray(); + packet.dddd38 = array1351; + const array1352 = buffer.readLongArray(); + packet.dddd39 = array1352; + const array1353 = buffer.readLongArray(); + packet.dddd4 = array1353; + const array1354 = buffer.readLongArray(); + packet.dddd40 = array1354; + const array1355 = buffer.readLongArray(); + packet.dddd41 = array1355; + const array1356 = buffer.readLongArray(); + packet.dddd42 = array1356; + const array1357 = buffer.readLongArray(); + packet.dddd43 = array1357; + const array1358 = buffer.readLongArray(); + packet.dddd44 = array1358; + const array1359 = buffer.readLongArray(); + packet.dddd45 = array1359; + const array1360 = buffer.readLongArray(); + packet.dddd46 = array1360; + const array1361 = buffer.readLongArray(); + packet.dddd47 = array1361; + const array1362 = buffer.readLongArray(); + packet.dddd48 = array1362; + const array1363 = buffer.readLongArray(); + packet.dddd49 = array1363; + const array1364 = buffer.readLongArray(); + packet.dddd5 = array1364; + const array1365 = buffer.readLongArray(); + packet.dddd50 = array1365; + const array1366 = buffer.readLongArray(); + packet.dddd51 = array1366; + const array1367 = buffer.readLongArray(); + packet.dddd52 = array1367; + const array1368 = buffer.readLongArray(); + packet.dddd53 = array1368; + const array1369 = buffer.readLongArray(); + packet.dddd54 = array1369; + const array1370 = buffer.readLongArray(); + packet.dddd55 = array1370; + const array1371 = buffer.readLongArray(); + packet.dddd56 = array1371; + const array1372 = buffer.readLongArray(); + packet.dddd57 = array1372; + const array1373 = buffer.readLongArray(); + packet.dddd58 = array1373; + const array1374 = buffer.readLongArray(); + packet.dddd59 = array1374; + const array1375 = buffer.readLongArray(); + packet.dddd6 = array1375; + const array1376 = buffer.readLongArray(); + packet.dddd60 = array1376; + const array1377 = buffer.readLongArray(); + packet.dddd61 = array1377; + const array1378 = buffer.readLongArray(); + packet.dddd62 = array1378; + const array1379 = buffer.readLongArray(); + packet.dddd63 = array1379; + const array1380 = buffer.readLongArray(); + packet.dddd64 = array1380; + const array1381 = buffer.readLongArray(); + packet.dddd65 = array1381; + const array1382 = buffer.readLongArray(); + packet.dddd66 = array1382; + const array1383 = buffer.readLongArray(); + packet.dddd67 = array1383; + const array1384 = buffer.readLongArray(); + packet.dddd68 = array1384; + const array1385 = buffer.readLongArray(); + packet.dddd69 = array1385; + const array1386 = buffer.readLongArray(); + packet.dddd7 = array1386; + const array1387 = buffer.readLongArray(); + packet.dddd70 = array1387; + const array1388 = buffer.readLongArray(); + packet.dddd71 = array1388; + const array1389 = buffer.readLongArray(); + packet.dddd72 = array1389; + const array1390 = buffer.readLongArray(); + packet.dddd73 = array1390; + const array1391 = buffer.readLongArray(); + packet.dddd74 = array1391; + const array1392 = buffer.readLongArray(); + packet.dddd75 = array1392; + const array1393 = buffer.readLongArray(); + packet.dddd76 = array1393; + const array1394 = buffer.readLongArray(); + packet.dddd77 = array1394; + const array1395 = buffer.readLongArray(); + packet.dddd78 = array1395; + const array1396 = buffer.readLongArray(); + packet.dddd79 = array1396; + const array1397 = buffer.readLongArray(); + packet.dddd8 = array1397; + const array1398 = buffer.readLongArray(); + packet.dddd80 = array1398; + const array1399 = buffer.readLongArray(); + packet.dddd81 = array1399; + const array1400 = buffer.readLongArray(); + packet.dddd82 = array1400; + const array1401 = buffer.readLongArray(); + packet.dddd83 = array1401; + const array1402 = buffer.readLongArray(); + packet.dddd84 = array1402; + const array1403 = buffer.readLongArray(); + packet.dddd85 = array1403; + const array1404 = buffer.readLongArray(); + packet.dddd86 = array1404; + const array1405 = buffer.readLongArray(); + packet.dddd87 = array1405; + const array1406 = buffer.readLongArray(); + packet.dddd88 = array1406; + const array1407 = buffer.readLongArray(); + packet.dddd9 = array1407; + const result1408 = buffer.readFloat(); + packet.e1 = result1408; + const result1409 = buffer.readFloat(); + packet.e10 = result1409; + const result1410 = buffer.readFloat(); + packet.e11 = result1410; + const result1411 = buffer.readFloat(); + packet.e12 = result1411; + const result1412 = buffer.readFloat(); + packet.e13 = result1412; + const result1413 = buffer.readFloat(); + packet.e14 = result1413; + const result1414 = buffer.readFloat(); + packet.e15 = result1414; + const result1415 = buffer.readFloat(); + packet.e16 = result1415; + const result1416 = buffer.readFloat(); + packet.e17 = result1416; + const result1417 = buffer.readFloat(); + packet.e18 = result1417; + const result1418 = buffer.readFloat(); + packet.e19 = result1418; + const result1419 = buffer.readFloat(); + packet.e2 = result1419; + const result1420 = buffer.readFloat(); + packet.e20 = result1420; + const result1421 = buffer.readFloat(); + packet.e21 = result1421; + const result1422 = buffer.readFloat(); + packet.e22 = result1422; + const result1423 = buffer.readFloat(); + packet.e23 = result1423; + const result1424 = buffer.readFloat(); + packet.e24 = result1424; + const result1425 = buffer.readFloat(); + packet.e25 = result1425; + const result1426 = buffer.readFloat(); + packet.e26 = result1426; + const result1427 = buffer.readFloat(); + packet.e27 = result1427; + const result1428 = buffer.readFloat(); + packet.e28 = result1428; + const result1429 = buffer.readFloat(); + packet.e29 = result1429; + const result1430 = buffer.readFloat(); + packet.e3 = result1430; + const result1431 = buffer.readFloat(); + packet.e30 = result1431; + const result1432 = buffer.readFloat(); + packet.e31 = result1432; + const result1433 = buffer.readFloat(); + packet.e32 = result1433; + const result1434 = buffer.readFloat(); + packet.e33 = result1434; + const result1435 = buffer.readFloat(); + packet.e34 = result1435; + const result1436 = buffer.readFloat(); + packet.e35 = result1436; + const result1437 = buffer.readFloat(); + packet.e36 = result1437; + const result1438 = buffer.readFloat(); + packet.e37 = result1438; + const result1439 = buffer.readFloat(); + packet.e38 = result1439; + const result1440 = buffer.readFloat(); + packet.e39 = result1440; + const result1441 = buffer.readFloat(); + packet.e4 = result1441; + const result1442 = buffer.readFloat(); + packet.e40 = result1442; + const result1443 = buffer.readFloat(); + packet.e41 = result1443; + const result1444 = buffer.readFloat(); + packet.e42 = result1444; + const result1445 = buffer.readFloat(); + packet.e43 = result1445; + const result1446 = buffer.readFloat(); + packet.e44 = result1446; + const result1447 = buffer.readFloat(); + packet.e45 = result1447; + const result1448 = buffer.readFloat(); + packet.e46 = result1448; + const result1449 = buffer.readFloat(); + packet.e47 = result1449; + const result1450 = buffer.readFloat(); + packet.e48 = result1450; + const result1451 = buffer.readFloat(); + packet.e49 = result1451; + const result1452 = buffer.readFloat(); + packet.e5 = result1452; + const result1453 = buffer.readFloat(); + packet.e50 = result1453; + const result1454 = buffer.readFloat(); + packet.e51 = result1454; + const result1455 = buffer.readFloat(); + packet.e52 = result1455; + const result1456 = buffer.readFloat(); + packet.e53 = result1456; + const result1457 = buffer.readFloat(); + packet.e54 = result1457; + const result1458 = buffer.readFloat(); + packet.e55 = result1458; + const result1459 = buffer.readFloat(); + packet.e56 = result1459; + const result1460 = buffer.readFloat(); + packet.e57 = result1460; + const result1461 = buffer.readFloat(); + packet.e58 = result1461; + const result1462 = buffer.readFloat(); + packet.e59 = result1462; + const result1463 = buffer.readFloat(); + packet.e6 = result1463; + const result1464 = buffer.readFloat(); + packet.e60 = result1464; + const result1465 = buffer.readFloat(); + packet.e61 = result1465; + const result1466 = buffer.readFloat(); + packet.e62 = result1466; + const result1467 = buffer.readFloat(); + packet.e63 = result1467; + const result1468 = buffer.readFloat(); + packet.e64 = result1468; + const result1469 = buffer.readFloat(); + packet.e65 = result1469; + const result1470 = buffer.readFloat(); + packet.e66 = result1470; + const result1471 = buffer.readFloat(); + packet.e67 = result1471; + const result1472 = buffer.readFloat(); + packet.e68 = result1472; + const result1473 = buffer.readFloat(); + packet.e69 = result1473; + const result1474 = buffer.readFloat(); + packet.e7 = result1474; + const result1475 = buffer.readFloat(); + packet.e70 = result1475; + const result1476 = buffer.readFloat(); + packet.e71 = result1476; + const result1477 = buffer.readFloat(); + packet.e72 = result1477; + const result1478 = buffer.readFloat(); + packet.e73 = result1478; + const result1479 = buffer.readFloat(); + packet.e74 = result1479; + const result1480 = buffer.readFloat(); + packet.e75 = result1480; + const result1481 = buffer.readFloat(); + packet.e76 = result1481; + const result1482 = buffer.readFloat(); + packet.e77 = result1482; + const result1483 = buffer.readFloat(); + packet.e78 = result1483; + const result1484 = buffer.readFloat(); + packet.e79 = result1484; + const result1485 = buffer.readFloat(); + packet.e8 = result1485; + const result1486 = buffer.readFloat(); + packet.e80 = result1486; + const result1487 = buffer.readFloat(); + packet.e81 = result1487; + const result1488 = buffer.readFloat(); + packet.e82 = result1488; + const result1489 = buffer.readFloat(); + packet.e83 = result1489; + const result1490 = buffer.readFloat(); + packet.e84 = result1490; + const result1491 = buffer.readFloat(); + packet.e85 = result1491; + const result1492 = buffer.readFloat(); + packet.e86 = result1492; + const result1493 = buffer.readFloat(); + packet.e87 = result1493; + const result1494 = buffer.readFloat(); + packet.e88 = result1494; + const result1495 = buffer.readFloat(); + packet.e9 = result1495; + const result1496 = buffer.readFloat(); + packet.ee1 = result1496; + const result1497 = buffer.readFloat(); + packet.ee10 = result1497; + const result1498 = buffer.readFloat(); + packet.ee11 = result1498; + const result1499 = buffer.readFloat(); + packet.ee12 = result1499; + const result1500 = buffer.readFloat(); + packet.ee13 = result1500; + const result1501 = buffer.readFloat(); + packet.ee14 = result1501; + const result1502 = buffer.readFloat(); + packet.ee15 = result1502; + const result1503 = buffer.readFloat(); + packet.ee16 = result1503; + const result1504 = buffer.readFloat(); + packet.ee17 = result1504; + const result1505 = buffer.readFloat(); + packet.ee18 = result1505; + const result1506 = buffer.readFloat(); + packet.ee19 = result1506; + const result1507 = buffer.readFloat(); + packet.ee2 = result1507; + const result1508 = buffer.readFloat(); + packet.ee20 = result1508; + const result1509 = buffer.readFloat(); + packet.ee21 = result1509; + const result1510 = buffer.readFloat(); + packet.ee22 = result1510; + const result1511 = buffer.readFloat(); + packet.ee23 = result1511; + const result1512 = buffer.readFloat(); + packet.ee24 = result1512; + const result1513 = buffer.readFloat(); + packet.ee25 = result1513; + const result1514 = buffer.readFloat(); + packet.ee26 = result1514; + const result1515 = buffer.readFloat(); + packet.ee27 = result1515; + const result1516 = buffer.readFloat(); + packet.ee28 = result1516; + const result1517 = buffer.readFloat(); + packet.ee29 = result1517; + const result1518 = buffer.readFloat(); + packet.ee3 = result1518; + const result1519 = buffer.readFloat(); + packet.ee30 = result1519; + const result1520 = buffer.readFloat(); + packet.ee31 = result1520; + const result1521 = buffer.readFloat(); + packet.ee32 = result1521; + const result1522 = buffer.readFloat(); + packet.ee33 = result1522; + const result1523 = buffer.readFloat(); + packet.ee34 = result1523; + const result1524 = buffer.readFloat(); + packet.ee35 = result1524; + const result1525 = buffer.readFloat(); + packet.ee36 = result1525; + const result1526 = buffer.readFloat(); + packet.ee37 = result1526; + const result1527 = buffer.readFloat(); + packet.ee38 = result1527; + const result1528 = buffer.readFloat(); + packet.ee39 = result1528; + const result1529 = buffer.readFloat(); + packet.ee4 = result1529; + const result1530 = buffer.readFloat(); + packet.ee40 = result1530; + const result1531 = buffer.readFloat(); + packet.ee41 = result1531; + const result1532 = buffer.readFloat(); + packet.ee42 = result1532; + const result1533 = buffer.readFloat(); + packet.ee43 = result1533; + const result1534 = buffer.readFloat(); + packet.ee44 = result1534; + const result1535 = buffer.readFloat(); + packet.ee45 = result1535; + const result1536 = buffer.readFloat(); + packet.ee46 = result1536; + const result1537 = buffer.readFloat(); + packet.ee47 = result1537; + const result1538 = buffer.readFloat(); + packet.ee48 = result1538; + const result1539 = buffer.readFloat(); + packet.ee49 = result1539; + const result1540 = buffer.readFloat(); + packet.ee5 = result1540; + const result1541 = buffer.readFloat(); + packet.ee50 = result1541; + const result1542 = buffer.readFloat(); + packet.ee51 = result1542; + const result1543 = buffer.readFloat(); + packet.ee52 = result1543; + const result1544 = buffer.readFloat(); + packet.ee53 = result1544; + const result1545 = buffer.readFloat(); + packet.ee54 = result1545; + const result1546 = buffer.readFloat(); + packet.ee55 = result1546; + const result1547 = buffer.readFloat(); + packet.ee56 = result1547; + const result1548 = buffer.readFloat(); + packet.ee57 = result1548; + const result1549 = buffer.readFloat(); + packet.ee58 = result1549; + const result1550 = buffer.readFloat(); + packet.ee59 = result1550; + const result1551 = buffer.readFloat(); + packet.ee6 = result1551; + const result1552 = buffer.readFloat(); + packet.ee60 = result1552; + const result1553 = buffer.readFloat(); + packet.ee61 = result1553; + const result1554 = buffer.readFloat(); + packet.ee62 = result1554; + const result1555 = buffer.readFloat(); + packet.ee63 = result1555; + const result1556 = buffer.readFloat(); + packet.ee64 = result1556; + const result1557 = buffer.readFloat(); + packet.ee65 = result1557; + const result1558 = buffer.readFloat(); + packet.ee66 = result1558; + const result1559 = buffer.readFloat(); + packet.ee67 = result1559; + const result1560 = buffer.readFloat(); + packet.ee68 = result1560; + const result1561 = buffer.readFloat(); + packet.ee69 = result1561; + const result1562 = buffer.readFloat(); + packet.ee7 = result1562; + const result1563 = buffer.readFloat(); + packet.ee70 = result1563; + const result1564 = buffer.readFloat(); + packet.ee71 = result1564; + const result1565 = buffer.readFloat(); + packet.ee72 = result1565; + const result1566 = buffer.readFloat(); + packet.ee73 = result1566; + const result1567 = buffer.readFloat(); + packet.ee74 = result1567; + const result1568 = buffer.readFloat(); + packet.ee75 = result1568; + const result1569 = buffer.readFloat(); + packet.ee76 = result1569; + const result1570 = buffer.readFloat(); + packet.ee77 = result1570; + const result1571 = buffer.readFloat(); + packet.ee78 = result1571; + const result1572 = buffer.readFloat(); + packet.ee79 = result1572; + const result1573 = buffer.readFloat(); + packet.ee8 = result1573; + const result1574 = buffer.readFloat(); + packet.ee80 = result1574; + const result1575 = buffer.readFloat(); + packet.ee81 = result1575; + const result1576 = buffer.readFloat(); + packet.ee82 = result1576; + const result1577 = buffer.readFloat(); + packet.ee83 = result1577; + const result1578 = buffer.readFloat(); + packet.ee84 = result1578; + const result1579 = buffer.readFloat(); + packet.ee85 = result1579; + const result1580 = buffer.readFloat(); + packet.ee86 = result1580; + const result1581 = buffer.readFloat(); + packet.ee87 = result1581; + const result1582 = buffer.readFloat(); + packet.ee88 = result1582; + const result1583 = buffer.readFloat(); + packet.ee9 = result1583; + const array1584 = buffer.readFloatArray(); + packet.eee1 = array1584; + const array1585 = buffer.readFloatArray(); + packet.eee10 = array1585; + const array1586 = buffer.readFloatArray(); + packet.eee11 = array1586; + const array1587 = buffer.readFloatArray(); + packet.eee12 = array1587; + const array1588 = buffer.readFloatArray(); + packet.eee13 = array1588; + const array1589 = buffer.readFloatArray(); + packet.eee14 = array1589; + const array1590 = buffer.readFloatArray(); + packet.eee15 = array1590; + const array1591 = buffer.readFloatArray(); + packet.eee16 = array1591; + const array1592 = buffer.readFloatArray(); + packet.eee17 = array1592; + const array1593 = buffer.readFloatArray(); + packet.eee18 = array1593; + const array1594 = buffer.readFloatArray(); + packet.eee19 = array1594; + const array1595 = buffer.readFloatArray(); + packet.eee2 = array1595; + const array1596 = buffer.readFloatArray(); + packet.eee20 = array1596; + const array1597 = buffer.readFloatArray(); + packet.eee21 = array1597; + const array1598 = buffer.readFloatArray(); + packet.eee22 = array1598; + const array1599 = buffer.readFloatArray(); + packet.eee23 = array1599; + const array1600 = buffer.readFloatArray(); + packet.eee24 = array1600; + const array1601 = buffer.readFloatArray(); + packet.eee25 = array1601; + const array1602 = buffer.readFloatArray(); + packet.eee26 = array1602; + const array1603 = buffer.readFloatArray(); + packet.eee27 = array1603; + const array1604 = buffer.readFloatArray(); + packet.eee28 = array1604; + const array1605 = buffer.readFloatArray(); + packet.eee29 = array1605; + const array1606 = buffer.readFloatArray(); + packet.eee3 = array1606; + const array1607 = buffer.readFloatArray(); + packet.eee30 = array1607; + const array1608 = buffer.readFloatArray(); + packet.eee31 = array1608; + const array1609 = buffer.readFloatArray(); + packet.eee32 = array1609; + const array1610 = buffer.readFloatArray(); + packet.eee33 = array1610; + const array1611 = buffer.readFloatArray(); + packet.eee34 = array1611; + const array1612 = buffer.readFloatArray(); + packet.eee35 = array1612; + const array1613 = buffer.readFloatArray(); + packet.eee36 = array1613; + const array1614 = buffer.readFloatArray(); + packet.eee37 = array1614; + const array1615 = buffer.readFloatArray(); + packet.eee38 = array1615; + const array1616 = buffer.readFloatArray(); + packet.eee39 = array1616; + const array1617 = buffer.readFloatArray(); + packet.eee4 = array1617; + const array1618 = buffer.readFloatArray(); + packet.eee40 = array1618; + const array1619 = buffer.readFloatArray(); + packet.eee41 = array1619; + const array1620 = buffer.readFloatArray(); + packet.eee42 = array1620; + const array1621 = buffer.readFloatArray(); + packet.eee43 = array1621; + const array1622 = buffer.readFloatArray(); + packet.eee44 = array1622; + const array1623 = buffer.readFloatArray(); + packet.eee45 = array1623; + const array1624 = buffer.readFloatArray(); + packet.eee46 = array1624; + const array1625 = buffer.readFloatArray(); + packet.eee47 = array1625; + const array1626 = buffer.readFloatArray(); + packet.eee48 = array1626; + const array1627 = buffer.readFloatArray(); + packet.eee49 = array1627; + const array1628 = buffer.readFloatArray(); + packet.eee5 = array1628; + const array1629 = buffer.readFloatArray(); + packet.eee50 = array1629; + const array1630 = buffer.readFloatArray(); + packet.eee51 = array1630; + const array1631 = buffer.readFloatArray(); + packet.eee52 = array1631; + const array1632 = buffer.readFloatArray(); + packet.eee53 = array1632; + const array1633 = buffer.readFloatArray(); + packet.eee54 = array1633; + const array1634 = buffer.readFloatArray(); + packet.eee55 = array1634; + const array1635 = buffer.readFloatArray(); + packet.eee56 = array1635; + const array1636 = buffer.readFloatArray(); + packet.eee57 = array1636; + const array1637 = buffer.readFloatArray(); + packet.eee58 = array1637; + const array1638 = buffer.readFloatArray(); + packet.eee59 = array1638; + const array1639 = buffer.readFloatArray(); + packet.eee6 = array1639; + const array1640 = buffer.readFloatArray(); + packet.eee60 = array1640; + const array1641 = buffer.readFloatArray(); + packet.eee61 = array1641; + const array1642 = buffer.readFloatArray(); + packet.eee62 = array1642; + const array1643 = buffer.readFloatArray(); + packet.eee63 = array1643; + const array1644 = buffer.readFloatArray(); + packet.eee64 = array1644; + const array1645 = buffer.readFloatArray(); + packet.eee65 = array1645; + const array1646 = buffer.readFloatArray(); + packet.eee66 = array1646; + const array1647 = buffer.readFloatArray(); + packet.eee67 = array1647; + const array1648 = buffer.readFloatArray(); + packet.eee68 = array1648; + const array1649 = buffer.readFloatArray(); + packet.eee69 = array1649; + const array1650 = buffer.readFloatArray(); + packet.eee7 = array1650; + const array1651 = buffer.readFloatArray(); + packet.eee70 = array1651; + const array1652 = buffer.readFloatArray(); + packet.eee71 = array1652; + const array1653 = buffer.readFloatArray(); + packet.eee72 = array1653; + const array1654 = buffer.readFloatArray(); + packet.eee73 = array1654; + const array1655 = buffer.readFloatArray(); + packet.eee74 = array1655; + const array1656 = buffer.readFloatArray(); + packet.eee75 = array1656; + const array1657 = buffer.readFloatArray(); + packet.eee76 = array1657; + const array1658 = buffer.readFloatArray(); + packet.eee77 = array1658; + const array1659 = buffer.readFloatArray(); + packet.eee78 = array1659; + const array1660 = buffer.readFloatArray(); + packet.eee79 = array1660; + const array1661 = buffer.readFloatArray(); + packet.eee8 = array1661; + const array1662 = buffer.readFloatArray(); + packet.eee80 = array1662; + const array1663 = buffer.readFloatArray(); + packet.eee81 = array1663; + const array1664 = buffer.readFloatArray(); + packet.eee82 = array1664; + const array1665 = buffer.readFloatArray(); + packet.eee83 = array1665; + const array1666 = buffer.readFloatArray(); + packet.eee84 = array1666; + const array1667 = buffer.readFloatArray(); + packet.eee85 = array1667; + const array1668 = buffer.readFloatArray(); + packet.eee86 = array1668; + const array1669 = buffer.readFloatArray(); + packet.eee87 = array1669; + const array1670 = buffer.readFloatArray(); + packet.eee88 = array1670; + const array1671 = buffer.readFloatArray(); + packet.eee9 = array1671; + const array1672 = buffer.readFloatArray(); + packet.eeee1 = array1672; + const array1673 = buffer.readFloatArray(); + packet.eeee10 = array1673; + const array1674 = buffer.readFloatArray(); + packet.eeee11 = array1674; + const array1675 = buffer.readFloatArray(); + packet.eeee12 = array1675; + const array1676 = buffer.readFloatArray(); + packet.eeee13 = array1676; + const array1677 = buffer.readFloatArray(); + packet.eeee14 = array1677; + const array1678 = buffer.readFloatArray(); + packet.eeee15 = array1678; + const array1679 = buffer.readFloatArray(); + packet.eeee16 = array1679; + const array1680 = buffer.readFloatArray(); + packet.eeee17 = array1680; + const array1681 = buffer.readFloatArray(); + packet.eeee18 = array1681; + const array1682 = buffer.readFloatArray(); + packet.eeee19 = array1682; + const array1683 = buffer.readFloatArray(); + packet.eeee2 = array1683; + const array1684 = buffer.readFloatArray(); + packet.eeee20 = array1684; + const array1685 = buffer.readFloatArray(); + packet.eeee21 = array1685; + const array1686 = buffer.readFloatArray(); + packet.eeee22 = array1686; + const array1687 = buffer.readFloatArray(); + packet.eeee23 = array1687; + const array1688 = buffer.readFloatArray(); + packet.eeee24 = array1688; + const array1689 = buffer.readFloatArray(); + packet.eeee25 = array1689; + const array1690 = buffer.readFloatArray(); + packet.eeee26 = array1690; + const array1691 = buffer.readFloatArray(); + packet.eeee27 = array1691; + const array1692 = buffer.readFloatArray(); + packet.eeee28 = array1692; + const array1693 = buffer.readFloatArray(); + packet.eeee29 = array1693; + const array1694 = buffer.readFloatArray(); + packet.eeee3 = array1694; + const array1695 = buffer.readFloatArray(); + packet.eeee30 = array1695; + const array1696 = buffer.readFloatArray(); + packet.eeee31 = array1696; + const array1697 = buffer.readFloatArray(); + packet.eeee32 = array1697; + const array1698 = buffer.readFloatArray(); + packet.eeee33 = array1698; + const array1699 = buffer.readFloatArray(); + packet.eeee34 = array1699; + const array1700 = buffer.readFloatArray(); + packet.eeee35 = array1700; + const array1701 = buffer.readFloatArray(); + packet.eeee36 = array1701; + const array1702 = buffer.readFloatArray(); + packet.eeee37 = array1702; + const array1703 = buffer.readFloatArray(); + packet.eeee38 = array1703; + const array1704 = buffer.readFloatArray(); + packet.eeee39 = array1704; + const array1705 = buffer.readFloatArray(); + packet.eeee4 = array1705; + const array1706 = buffer.readFloatArray(); + packet.eeee40 = array1706; + const array1707 = buffer.readFloatArray(); + packet.eeee41 = array1707; + const array1708 = buffer.readFloatArray(); + packet.eeee42 = array1708; + const array1709 = buffer.readFloatArray(); + packet.eeee43 = array1709; + const array1710 = buffer.readFloatArray(); + packet.eeee44 = array1710; + const array1711 = buffer.readFloatArray(); + packet.eeee45 = array1711; + const array1712 = buffer.readFloatArray(); + packet.eeee46 = array1712; + const array1713 = buffer.readFloatArray(); + packet.eeee47 = array1713; + const array1714 = buffer.readFloatArray(); + packet.eeee48 = array1714; + const array1715 = buffer.readFloatArray(); + packet.eeee49 = array1715; + const array1716 = buffer.readFloatArray(); + packet.eeee5 = array1716; + const array1717 = buffer.readFloatArray(); + packet.eeee50 = array1717; + const array1718 = buffer.readFloatArray(); + packet.eeee51 = array1718; + const array1719 = buffer.readFloatArray(); + packet.eeee52 = array1719; + const array1720 = buffer.readFloatArray(); + packet.eeee53 = array1720; + const array1721 = buffer.readFloatArray(); + packet.eeee54 = array1721; + const array1722 = buffer.readFloatArray(); + packet.eeee55 = array1722; + const array1723 = buffer.readFloatArray(); + packet.eeee56 = array1723; + const array1724 = buffer.readFloatArray(); + packet.eeee57 = array1724; + const array1725 = buffer.readFloatArray(); + packet.eeee58 = array1725; + const array1726 = buffer.readFloatArray(); + packet.eeee59 = array1726; + const array1727 = buffer.readFloatArray(); + packet.eeee6 = array1727; + const array1728 = buffer.readFloatArray(); + packet.eeee60 = array1728; + const array1729 = buffer.readFloatArray(); + packet.eeee61 = array1729; + const array1730 = buffer.readFloatArray(); + packet.eeee62 = array1730; + const array1731 = buffer.readFloatArray(); + packet.eeee63 = array1731; + const array1732 = buffer.readFloatArray(); + packet.eeee64 = array1732; + const array1733 = buffer.readFloatArray(); + packet.eeee65 = array1733; + const array1734 = buffer.readFloatArray(); + packet.eeee66 = array1734; + const array1735 = buffer.readFloatArray(); + packet.eeee67 = array1735; + const array1736 = buffer.readFloatArray(); + packet.eeee68 = array1736; + const array1737 = buffer.readFloatArray(); + packet.eeee69 = array1737; + const array1738 = buffer.readFloatArray(); + packet.eeee7 = array1738; + const array1739 = buffer.readFloatArray(); + packet.eeee70 = array1739; + const array1740 = buffer.readFloatArray(); + packet.eeee71 = array1740; + const array1741 = buffer.readFloatArray(); + packet.eeee72 = array1741; + const array1742 = buffer.readFloatArray(); + packet.eeee73 = array1742; + const array1743 = buffer.readFloatArray(); + packet.eeee74 = array1743; + const array1744 = buffer.readFloatArray(); + packet.eeee75 = array1744; + const array1745 = buffer.readFloatArray(); + packet.eeee76 = array1745; + const array1746 = buffer.readFloatArray(); + packet.eeee77 = array1746; + const array1747 = buffer.readFloatArray(); + packet.eeee78 = array1747; + const array1748 = buffer.readFloatArray(); + packet.eeee79 = array1748; + const array1749 = buffer.readFloatArray(); + packet.eeee8 = array1749; + const array1750 = buffer.readFloatArray(); + packet.eeee80 = array1750; + const array1751 = buffer.readFloatArray(); + packet.eeee81 = array1751; + const array1752 = buffer.readFloatArray(); + packet.eeee82 = array1752; + const array1753 = buffer.readFloatArray(); + packet.eeee83 = array1753; + const array1754 = buffer.readFloatArray(); + packet.eeee84 = array1754; + const array1755 = buffer.readFloatArray(); + packet.eeee85 = array1755; + const array1756 = buffer.readFloatArray(); + packet.eeee86 = array1756; + const array1757 = buffer.readFloatArray(); + packet.eeee87 = array1757; + const array1758 = buffer.readFloatArray(); + packet.eeee88 = array1758; + const array1759 = buffer.readFloatArray(); + packet.eeee9 = array1759; + const result1760 = buffer.readDouble(); + packet.f1 = result1760; + const result1761 = buffer.readDouble(); + packet.f10 = result1761; + const result1762 = buffer.readDouble(); + packet.f11 = result1762; + const result1763 = buffer.readDouble(); + packet.f12 = result1763; + const result1764 = buffer.readDouble(); + packet.f13 = result1764; + const result1765 = buffer.readDouble(); + packet.f14 = result1765; + const result1766 = buffer.readDouble(); + packet.f15 = result1766; + const result1767 = buffer.readDouble(); + packet.f16 = result1767; + const result1768 = buffer.readDouble(); + packet.f17 = result1768; + const result1769 = buffer.readDouble(); + packet.f18 = result1769; + const result1770 = buffer.readDouble(); + packet.f19 = result1770; + const result1771 = buffer.readDouble(); + packet.f2 = result1771; + const result1772 = buffer.readDouble(); + packet.f20 = result1772; + const result1773 = buffer.readDouble(); + packet.f21 = result1773; + const result1774 = buffer.readDouble(); + packet.f22 = result1774; + const result1775 = buffer.readDouble(); + packet.f23 = result1775; + const result1776 = buffer.readDouble(); + packet.f24 = result1776; + const result1777 = buffer.readDouble(); + packet.f25 = result1777; + const result1778 = buffer.readDouble(); + packet.f26 = result1778; + const result1779 = buffer.readDouble(); + packet.f27 = result1779; + const result1780 = buffer.readDouble(); + packet.f28 = result1780; + const result1781 = buffer.readDouble(); + packet.f29 = result1781; + const result1782 = buffer.readDouble(); + packet.f3 = result1782; + const result1783 = buffer.readDouble(); + packet.f30 = result1783; + const result1784 = buffer.readDouble(); + packet.f31 = result1784; + const result1785 = buffer.readDouble(); + packet.f32 = result1785; + const result1786 = buffer.readDouble(); + packet.f33 = result1786; + const result1787 = buffer.readDouble(); + packet.f34 = result1787; + const result1788 = buffer.readDouble(); + packet.f35 = result1788; + const result1789 = buffer.readDouble(); + packet.f36 = result1789; + const result1790 = buffer.readDouble(); + packet.f37 = result1790; + const result1791 = buffer.readDouble(); + packet.f38 = result1791; + const result1792 = buffer.readDouble(); + packet.f39 = result1792; + const result1793 = buffer.readDouble(); + packet.f4 = result1793; + const result1794 = buffer.readDouble(); + packet.f40 = result1794; + const result1795 = buffer.readDouble(); + packet.f41 = result1795; + const result1796 = buffer.readDouble(); + packet.f42 = result1796; + const result1797 = buffer.readDouble(); + packet.f43 = result1797; + const result1798 = buffer.readDouble(); + packet.f44 = result1798; + const result1799 = buffer.readDouble(); + packet.f45 = result1799; + const result1800 = buffer.readDouble(); + packet.f46 = result1800; + const result1801 = buffer.readDouble(); + packet.f47 = result1801; + const result1802 = buffer.readDouble(); + packet.f48 = result1802; + const result1803 = buffer.readDouble(); + packet.f49 = result1803; + const result1804 = buffer.readDouble(); + packet.f5 = result1804; + const result1805 = buffer.readDouble(); + packet.f50 = result1805; + const result1806 = buffer.readDouble(); + packet.f51 = result1806; + const result1807 = buffer.readDouble(); + packet.f52 = result1807; + const result1808 = buffer.readDouble(); + packet.f53 = result1808; + const result1809 = buffer.readDouble(); + packet.f54 = result1809; + const result1810 = buffer.readDouble(); + packet.f55 = result1810; + const result1811 = buffer.readDouble(); + packet.f56 = result1811; + const result1812 = buffer.readDouble(); + packet.f57 = result1812; + const result1813 = buffer.readDouble(); + packet.f58 = result1813; + const result1814 = buffer.readDouble(); + packet.f59 = result1814; + const result1815 = buffer.readDouble(); + packet.f6 = result1815; + const result1816 = buffer.readDouble(); + packet.f60 = result1816; + const result1817 = buffer.readDouble(); + packet.f61 = result1817; + const result1818 = buffer.readDouble(); + packet.f62 = result1818; + const result1819 = buffer.readDouble(); + packet.f63 = result1819; + const result1820 = buffer.readDouble(); + packet.f64 = result1820; + const result1821 = buffer.readDouble(); + packet.f65 = result1821; + const result1822 = buffer.readDouble(); + packet.f66 = result1822; + const result1823 = buffer.readDouble(); + packet.f67 = result1823; + const result1824 = buffer.readDouble(); + packet.f68 = result1824; + const result1825 = buffer.readDouble(); + packet.f69 = result1825; + const result1826 = buffer.readDouble(); + packet.f7 = result1826; + const result1827 = buffer.readDouble(); + packet.f70 = result1827; + const result1828 = buffer.readDouble(); + packet.f71 = result1828; + const result1829 = buffer.readDouble(); + packet.f72 = result1829; + const result1830 = buffer.readDouble(); + packet.f73 = result1830; + const result1831 = buffer.readDouble(); + packet.f74 = result1831; + const result1832 = buffer.readDouble(); + packet.f75 = result1832; + const result1833 = buffer.readDouble(); + packet.f76 = result1833; + const result1834 = buffer.readDouble(); + packet.f77 = result1834; + const result1835 = buffer.readDouble(); + packet.f78 = result1835; + const result1836 = buffer.readDouble(); + packet.f79 = result1836; + const result1837 = buffer.readDouble(); + packet.f8 = result1837; + const result1838 = buffer.readDouble(); + packet.f80 = result1838; + const result1839 = buffer.readDouble(); + packet.f81 = result1839; + const result1840 = buffer.readDouble(); + packet.f82 = result1840; + const result1841 = buffer.readDouble(); + packet.f83 = result1841; + const result1842 = buffer.readDouble(); + packet.f84 = result1842; + const result1843 = buffer.readDouble(); + packet.f85 = result1843; + const result1844 = buffer.readDouble(); + packet.f86 = result1844; + const result1845 = buffer.readDouble(); + packet.f87 = result1845; + const result1846 = buffer.readDouble(); + packet.f88 = result1846; + const result1847 = buffer.readDouble(); + packet.f9 = result1847; + const result1848 = buffer.readDouble(); + packet.ff1 = result1848; + const result1849 = buffer.readDouble(); + packet.ff10 = result1849; + const result1850 = buffer.readDouble(); + packet.ff11 = result1850; + const result1851 = buffer.readDouble(); + packet.ff12 = result1851; + const result1852 = buffer.readDouble(); + packet.ff13 = result1852; + const result1853 = buffer.readDouble(); + packet.ff14 = result1853; + const result1854 = buffer.readDouble(); + packet.ff15 = result1854; + const result1855 = buffer.readDouble(); + packet.ff16 = result1855; + const result1856 = buffer.readDouble(); + packet.ff17 = result1856; + const result1857 = buffer.readDouble(); + packet.ff18 = result1857; + const result1858 = buffer.readDouble(); + packet.ff19 = result1858; + const result1859 = buffer.readDouble(); + packet.ff2 = result1859; + const result1860 = buffer.readDouble(); + packet.ff20 = result1860; + const result1861 = buffer.readDouble(); + packet.ff21 = result1861; + const result1862 = buffer.readDouble(); + packet.ff22 = result1862; + const result1863 = buffer.readDouble(); + packet.ff23 = result1863; + const result1864 = buffer.readDouble(); + packet.ff24 = result1864; + const result1865 = buffer.readDouble(); + packet.ff25 = result1865; + const result1866 = buffer.readDouble(); + packet.ff26 = result1866; + const result1867 = buffer.readDouble(); + packet.ff27 = result1867; + const result1868 = buffer.readDouble(); + packet.ff28 = result1868; + const result1869 = buffer.readDouble(); + packet.ff29 = result1869; + const result1870 = buffer.readDouble(); + packet.ff3 = result1870; + const result1871 = buffer.readDouble(); + packet.ff30 = result1871; + const result1872 = buffer.readDouble(); + packet.ff31 = result1872; + const result1873 = buffer.readDouble(); + packet.ff32 = result1873; + const result1874 = buffer.readDouble(); + packet.ff33 = result1874; + const result1875 = buffer.readDouble(); + packet.ff34 = result1875; + const result1876 = buffer.readDouble(); + packet.ff35 = result1876; + const result1877 = buffer.readDouble(); + packet.ff36 = result1877; + const result1878 = buffer.readDouble(); + packet.ff37 = result1878; + const result1879 = buffer.readDouble(); + packet.ff38 = result1879; + const result1880 = buffer.readDouble(); + packet.ff39 = result1880; + const result1881 = buffer.readDouble(); + packet.ff4 = result1881; + const result1882 = buffer.readDouble(); + packet.ff40 = result1882; + const result1883 = buffer.readDouble(); + packet.ff41 = result1883; + const result1884 = buffer.readDouble(); + packet.ff42 = result1884; + const result1885 = buffer.readDouble(); + packet.ff43 = result1885; + const result1886 = buffer.readDouble(); + packet.ff44 = result1886; + const result1887 = buffer.readDouble(); + packet.ff45 = result1887; + const result1888 = buffer.readDouble(); + packet.ff46 = result1888; + const result1889 = buffer.readDouble(); + packet.ff47 = result1889; + const result1890 = buffer.readDouble(); + packet.ff48 = result1890; + const result1891 = buffer.readDouble(); + packet.ff49 = result1891; + const result1892 = buffer.readDouble(); + packet.ff5 = result1892; + const result1893 = buffer.readDouble(); + packet.ff50 = result1893; + const result1894 = buffer.readDouble(); + packet.ff51 = result1894; + const result1895 = buffer.readDouble(); + packet.ff52 = result1895; + const result1896 = buffer.readDouble(); + packet.ff53 = result1896; + const result1897 = buffer.readDouble(); + packet.ff54 = result1897; + const result1898 = buffer.readDouble(); + packet.ff55 = result1898; + const result1899 = buffer.readDouble(); + packet.ff56 = result1899; + const result1900 = buffer.readDouble(); + packet.ff57 = result1900; + const result1901 = buffer.readDouble(); + packet.ff58 = result1901; + const result1902 = buffer.readDouble(); + packet.ff59 = result1902; + const result1903 = buffer.readDouble(); + packet.ff6 = result1903; + const result1904 = buffer.readDouble(); + packet.ff60 = result1904; + const result1905 = buffer.readDouble(); + packet.ff61 = result1905; + const result1906 = buffer.readDouble(); + packet.ff62 = result1906; + const result1907 = buffer.readDouble(); + packet.ff63 = result1907; + const result1908 = buffer.readDouble(); + packet.ff64 = result1908; + const result1909 = buffer.readDouble(); + packet.ff65 = result1909; + const result1910 = buffer.readDouble(); + packet.ff66 = result1910; + const result1911 = buffer.readDouble(); + packet.ff67 = result1911; + const result1912 = buffer.readDouble(); + packet.ff68 = result1912; + const result1913 = buffer.readDouble(); + packet.ff69 = result1913; + const result1914 = buffer.readDouble(); + packet.ff7 = result1914; + const result1915 = buffer.readDouble(); + packet.ff70 = result1915; + const result1916 = buffer.readDouble(); + packet.ff71 = result1916; + const result1917 = buffer.readDouble(); + packet.ff72 = result1917; + const result1918 = buffer.readDouble(); + packet.ff73 = result1918; + const result1919 = buffer.readDouble(); + packet.ff74 = result1919; + const result1920 = buffer.readDouble(); + packet.ff75 = result1920; + const result1921 = buffer.readDouble(); + packet.ff76 = result1921; + const result1922 = buffer.readDouble(); + packet.ff77 = result1922; + const result1923 = buffer.readDouble(); + packet.ff78 = result1923; + const result1924 = buffer.readDouble(); + packet.ff79 = result1924; + const result1925 = buffer.readDouble(); + packet.ff8 = result1925; + const result1926 = buffer.readDouble(); + packet.ff80 = result1926; + const result1927 = buffer.readDouble(); + packet.ff81 = result1927; + const result1928 = buffer.readDouble(); + packet.ff82 = result1928; + const result1929 = buffer.readDouble(); + packet.ff83 = result1929; + const result1930 = buffer.readDouble(); + packet.ff84 = result1930; + const result1931 = buffer.readDouble(); + packet.ff85 = result1931; + const result1932 = buffer.readDouble(); + packet.ff86 = result1932; + const result1933 = buffer.readDouble(); + packet.ff87 = result1933; + const result1934 = buffer.readDouble(); + packet.ff88 = result1934; + const result1935 = buffer.readDouble(); + packet.ff9 = result1935; + const array1936 = buffer.readDoubleArray(); + packet.fff1 = array1936; + const array1937 = buffer.readDoubleArray(); + packet.fff10 = array1937; + const array1938 = buffer.readDoubleArray(); + packet.fff11 = array1938; + const array1939 = buffer.readDoubleArray(); + packet.fff12 = array1939; + const array1940 = buffer.readDoubleArray(); + packet.fff13 = array1940; + const array1941 = buffer.readDoubleArray(); + packet.fff14 = array1941; + const array1942 = buffer.readDoubleArray(); + packet.fff15 = array1942; + const array1943 = buffer.readDoubleArray(); + packet.fff16 = array1943; + const array1944 = buffer.readDoubleArray(); + packet.fff17 = array1944; + const array1945 = buffer.readDoubleArray(); + packet.fff18 = array1945; + const array1946 = buffer.readDoubleArray(); + packet.fff19 = array1946; + const array1947 = buffer.readDoubleArray(); + packet.fff2 = array1947; + const array1948 = buffer.readDoubleArray(); + packet.fff20 = array1948; + const array1949 = buffer.readDoubleArray(); + packet.fff21 = array1949; + const array1950 = buffer.readDoubleArray(); + packet.fff22 = array1950; + const array1951 = buffer.readDoubleArray(); + packet.fff23 = array1951; + const array1952 = buffer.readDoubleArray(); + packet.fff24 = array1952; + const array1953 = buffer.readDoubleArray(); + packet.fff25 = array1953; + const array1954 = buffer.readDoubleArray(); + packet.fff26 = array1954; + const array1955 = buffer.readDoubleArray(); + packet.fff27 = array1955; + const array1956 = buffer.readDoubleArray(); + packet.fff28 = array1956; + const array1957 = buffer.readDoubleArray(); + packet.fff29 = array1957; + const array1958 = buffer.readDoubleArray(); + packet.fff3 = array1958; + const array1959 = buffer.readDoubleArray(); + packet.fff30 = array1959; + const array1960 = buffer.readDoubleArray(); + packet.fff31 = array1960; + const array1961 = buffer.readDoubleArray(); + packet.fff32 = array1961; + const array1962 = buffer.readDoubleArray(); + packet.fff33 = array1962; + const array1963 = buffer.readDoubleArray(); + packet.fff34 = array1963; + const array1964 = buffer.readDoubleArray(); + packet.fff35 = array1964; + const array1965 = buffer.readDoubleArray(); + packet.fff36 = array1965; + const array1966 = buffer.readDoubleArray(); + packet.fff37 = array1966; + const array1967 = buffer.readDoubleArray(); + packet.fff38 = array1967; + const array1968 = buffer.readDoubleArray(); + packet.fff39 = array1968; + const array1969 = buffer.readDoubleArray(); + packet.fff4 = array1969; + const array1970 = buffer.readDoubleArray(); + packet.fff40 = array1970; + const array1971 = buffer.readDoubleArray(); + packet.fff41 = array1971; + const array1972 = buffer.readDoubleArray(); + packet.fff42 = array1972; + const array1973 = buffer.readDoubleArray(); + packet.fff43 = array1973; + const array1974 = buffer.readDoubleArray(); + packet.fff44 = array1974; + const array1975 = buffer.readDoubleArray(); + packet.fff45 = array1975; + const array1976 = buffer.readDoubleArray(); + packet.fff46 = array1976; + const array1977 = buffer.readDoubleArray(); + packet.fff47 = array1977; + const array1978 = buffer.readDoubleArray(); + packet.fff48 = array1978; + const array1979 = buffer.readDoubleArray(); + packet.fff49 = array1979; + const array1980 = buffer.readDoubleArray(); + packet.fff5 = array1980; + const array1981 = buffer.readDoubleArray(); + packet.fff50 = array1981; + const array1982 = buffer.readDoubleArray(); + packet.fff51 = array1982; + const array1983 = buffer.readDoubleArray(); + packet.fff52 = array1983; + const array1984 = buffer.readDoubleArray(); + packet.fff53 = array1984; + const array1985 = buffer.readDoubleArray(); + packet.fff54 = array1985; + const array1986 = buffer.readDoubleArray(); + packet.fff55 = array1986; + const array1987 = buffer.readDoubleArray(); + packet.fff56 = array1987; + const array1988 = buffer.readDoubleArray(); + packet.fff57 = array1988; + const array1989 = buffer.readDoubleArray(); + packet.fff58 = array1989; + const array1990 = buffer.readDoubleArray(); + packet.fff59 = array1990; + const array1991 = buffer.readDoubleArray(); + packet.fff6 = array1991; + const array1992 = buffer.readDoubleArray(); + packet.fff60 = array1992; + const array1993 = buffer.readDoubleArray(); + packet.fff61 = array1993; + const array1994 = buffer.readDoubleArray(); + packet.fff62 = array1994; + const array1995 = buffer.readDoubleArray(); + packet.fff63 = array1995; + const array1996 = buffer.readDoubleArray(); + packet.fff64 = array1996; + const array1997 = buffer.readDoubleArray(); + packet.fff65 = array1997; + const array1998 = buffer.readDoubleArray(); + packet.fff66 = array1998; + const array1999 = buffer.readDoubleArray(); + packet.fff67 = array1999; + const array2000 = buffer.readDoubleArray(); + packet.fff68 = array2000; + const array2001 = buffer.readDoubleArray(); + packet.fff69 = array2001; + const array2002 = buffer.readDoubleArray(); + packet.fff7 = array2002; + const array2003 = buffer.readDoubleArray(); + packet.fff70 = array2003; + const array2004 = buffer.readDoubleArray(); + packet.fff71 = array2004; + const array2005 = buffer.readDoubleArray(); + packet.fff72 = array2005; + const array2006 = buffer.readDoubleArray(); + packet.fff73 = array2006; + const array2007 = buffer.readDoubleArray(); + packet.fff74 = array2007; + const array2008 = buffer.readDoubleArray(); + packet.fff75 = array2008; + const array2009 = buffer.readDoubleArray(); + packet.fff76 = array2009; + const array2010 = buffer.readDoubleArray(); + packet.fff77 = array2010; + const array2011 = buffer.readDoubleArray(); + packet.fff78 = array2011; + const array2012 = buffer.readDoubleArray(); + packet.fff79 = array2012; + const array2013 = buffer.readDoubleArray(); + packet.fff8 = array2013; + const array2014 = buffer.readDoubleArray(); + packet.fff80 = array2014; + const array2015 = buffer.readDoubleArray(); + packet.fff81 = array2015; + const array2016 = buffer.readDoubleArray(); + packet.fff82 = array2016; + const array2017 = buffer.readDoubleArray(); + packet.fff83 = array2017; + const array2018 = buffer.readDoubleArray(); + packet.fff84 = array2018; + const array2019 = buffer.readDoubleArray(); + packet.fff85 = array2019; + const array2020 = buffer.readDoubleArray(); + packet.fff86 = array2020; + const array2021 = buffer.readDoubleArray(); + packet.fff87 = array2021; + const array2022 = buffer.readDoubleArray(); + packet.fff88 = array2022; + const array2023 = buffer.readDoubleArray(); + packet.fff9 = array2023; + const array2024 = buffer.readDoubleArray(); + packet.ffff1 = array2024; + const array2025 = buffer.readDoubleArray(); + packet.ffff10 = array2025; + const array2026 = buffer.readDoubleArray(); + packet.ffff11 = array2026; + const array2027 = buffer.readDoubleArray(); + packet.ffff12 = array2027; + const array2028 = buffer.readDoubleArray(); + packet.ffff13 = array2028; + const array2029 = buffer.readDoubleArray(); + packet.ffff14 = array2029; + const array2030 = buffer.readDoubleArray(); + packet.ffff15 = array2030; + const array2031 = buffer.readDoubleArray(); + packet.ffff16 = array2031; + const array2032 = buffer.readDoubleArray(); + packet.ffff17 = array2032; + const array2033 = buffer.readDoubleArray(); + packet.ffff18 = array2033; + const array2034 = buffer.readDoubleArray(); + packet.ffff19 = array2034; + const array2035 = buffer.readDoubleArray(); + packet.ffff2 = array2035; + const array2036 = buffer.readDoubleArray(); + packet.ffff20 = array2036; + const array2037 = buffer.readDoubleArray(); + packet.ffff21 = array2037; + const array2038 = buffer.readDoubleArray(); + packet.ffff22 = array2038; + const array2039 = buffer.readDoubleArray(); + packet.ffff23 = array2039; + const array2040 = buffer.readDoubleArray(); + packet.ffff24 = array2040; + const array2041 = buffer.readDoubleArray(); + packet.ffff25 = array2041; + const array2042 = buffer.readDoubleArray(); + packet.ffff26 = array2042; + const array2043 = buffer.readDoubleArray(); + packet.ffff27 = array2043; + const array2044 = buffer.readDoubleArray(); + packet.ffff28 = array2044; + const array2045 = buffer.readDoubleArray(); + packet.ffff29 = array2045; + const array2046 = buffer.readDoubleArray(); + packet.ffff3 = array2046; + const array2047 = buffer.readDoubleArray(); + packet.ffff30 = array2047; + const array2048 = buffer.readDoubleArray(); + packet.ffff31 = array2048; + const array2049 = buffer.readDoubleArray(); + packet.ffff32 = array2049; + const array2050 = buffer.readDoubleArray(); + packet.ffff33 = array2050; + const array2051 = buffer.readDoubleArray(); + packet.ffff34 = array2051; + const array2052 = buffer.readDoubleArray(); + packet.ffff35 = array2052; + const array2053 = buffer.readDoubleArray(); + packet.ffff36 = array2053; + const array2054 = buffer.readDoubleArray(); + packet.ffff37 = array2054; + const array2055 = buffer.readDoubleArray(); + packet.ffff38 = array2055; + const array2056 = buffer.readDoubleArray(); + packet.ffff39 = array2056; + const array2057 = buffer.readDoubleArray(); + packet.ffff4 = array2057; + const array2058 = buffer.readDoubleArray(); + packet.ffff40 = array2058; + const array2059 = buffer.readDoubleArray(); + packet.ffff41 = array2059; + const array2060 = buffer.readDoubleArray(); + packet.ffff42 = array2060; + const array2061 = buffer.readDoubleArray(); + packet.ffff43 = array2061; + const array2062 = buffer.readDoubleArray(); + packet.ffff44 = array2062; + const array2063 = buffer.readDoubleArray(); + packet.ffff45 = array2063; + const array2064 = buffer.readDoubleArray(); + packet.ffff46 = array2064; + const array2065 = buffer.readDoubleArray(); + packet.ffff47 = array2065; + const array2066 = buffer.readDoubleArray(); + packet.ffff48 = array2066; + const array2067 = buffer.readDoubleArray(); + packet.ffff49 = array2067; + const array2068 = buffer.readDoubleArray(); + packet.ffff5 = array2068; + const array2069 = buffer.readDoubleArray(); + packet.ffff50 = array2069; + const array2070 = buffer.readDoubleArray(); + packet.ffff51 = array2070; + const array2071 = buffer.readDoubleArray(); + packet.ffff52 = array2071; + const array2072 = buffer.readDoubleArray(); + packet.ffff53 = array2072; + const array2073 = buffer.readDoubleArray(); + packet.ffff54 = array2073; + const array2074 = buffer.readDoubleArray(); + packet.ffff55 = array2074; + const array2075 = buffer.readDoubleArray(); + packet.ffff56 = array2075; + const array2076 = buffer.readDoubleArray(); + packet.ffff57 = array2076; + const array2077 = buffer.readDoubleArray(); + packet.ffff58 = array2077; + const array2078 = buffer.readDoubleArray(); + packet.ffff59 = array2078; + const array2079 = buffer.readDoubleArray(); + packet.ffff6 = array2079; + const array2080 = buffer.readDoubleArray(); + packet.ffff60 = array2080; + const array2081 = buffer.readDoubleArray(); + packet.ffff61 = array2081; + const array2082 = buffer.readDoubleArray(); + packet.ffff62 = array2082; + const array2083 = buffer.readDoubleArray(); + packet.ffff63 = array2083; + const array2084 = buffer.readDoubleArray(); + packet.ffff64 = array2084; + const array2085 = buffer.readDoubleArray(); + packet.ffff65 = array2085; + const array2086 = buffer.readDoubleArray(); + packet.ffff66 = array2086; + const array2087 = buffer.readDoubleArray(); + packet.ffff67 = array2087; + const array2088 = buffer.readDoubleArray(); + packet.ffff68 = array2088; + const array2089 = buffer.readDoubleArray(); + packet.ffff69 = array2089; + const array2090 = buffer.readDoubleArray(); + packet.ffff7 = array2090; + const array2091 = buffer.readDoubleArray(); + packet.ffff70 = array2091; + const array2092 = buffer.readDoubleArray(); + packet.ffff71 = array2092; + const array2093 = buffer.readDoubleArray(); + packet.ffff72 = array2093; + const array2094 = buffer.readDoubleArray(); + packet.ffff73 = array2094; + const array2095 = buffer.readDoubleArray(); + packet.ffff74 = array2095; + const array2096 = buffer.readDoubleArray(); + packet.ffff75 = array2096; + const array2097 = buffer.readDoubleArray(); + packet.ffff76 = array2097; + const array2098 = buffer.readDoubleArray(); + packet.ffff77 = array2098; + const array2099 = buffer.readDoubleArray(); + packet.ffff78 = array2099; + const array2100 = buffer.readDoubleArray(); + packet.ffff79 = array2100; + const array2101 = buffer.readDoubleArray(); + packet.ffff8 = array2101; + const array2102 = buffer.readDoubleArray(); + packet.ffff80 = array2102; + const array2103 = buffer.readDoubleArray(); + packet.ffff81 = array2103; + const array2104 = buffer.readDoubleArray(); + packet.ffff82 = array2104; + const array2105 = buffer.readDoubleArray(); + packet.ffff83 = array2105; + const array2106 = buffer.readDoubleArray(); + packet.ffff84 = array2106; + const array2107 = buffer.readDoubleArray(); + packet.ffff85 = array2107; + const array2108 = buffer.readDoubleArray(); + packet.ffff86 = array2108; + const array2109 = buffer.readDoubleArray(); + packet.ffff87 = array2109; + const array2110 = buffer.readDoubleArray(); + packet.ffff88 = array2110; + const array2111 = buffer.readDoubleArray(); + packet.ffff9 = array2111; + const result2112 = buffer.readBoolean(); + packet.g1 = result2112; + const result2113 = buffer.readBoolean(); + packet.g10 = result2113; + const result2114 = buffer.readBoolean(); + packet.g11 = result2114; + const result2115 = buffer.readBoolean(); + packet.g12 = result2115; + const result2116 = buffer.readBoolean(); + packet.g13 = result2116; + const result2117 = buffer.readBoolean(); + packet.g14 = result2117; + const result2118 = buffer.readBoolean(); + packet.g15 = result2118; + const result2119 = buffer.readBoolean(); + packet.g16 = result2119; + const result2120 = buffer.readBoolean(); + packet.g17 = result2120; + const result2121 = buffer.readBoolean(); + packet.g18 = result2121; + const result2122 = buffer.readBoolean(); + packet.g19 = result2122; + const result2123 = buffer.readBoolean(); + packet.g2 = result2123; + const result2124 = buffer.readBoolean(); + packet.g20 = result2124; + const result2125 = buffer.readBoolean(); + packet.g21 = result2125; + const result2126 = buffer.readBoolean(); + packet.g22 = result2126; + const result2127 = buffer.readBoolean(); + packet.g23 = result2127; + const result2128 = buffer.readBoolean(); + packet.g24 = result2128; + const result2129 = buffer.readBoolean(); + packet.g25 = result2129; + const result2130 = buffer.readBoolean(); + packet.g26 = result2130; + const result2131 = buffer.readBoolean(); + packet.g27 = result2131; + const result2132 = buffer.readBoolean(); + packet.g28 = result2132; + const result2133 = buffer.readBoolean(); + packet.g29 = result2133; + const result2134 = buffer.readBoolean(); + packet.g3 = result2134; + const result2135 = buffer.readBoolean(); + packet.g30 = result2135; + const result2136 = buffer.readBoolean(); + packet.g31 = result2136; + const result2137 = buffer.readBoolean(); + packet.g32 = result2137; + const result2138 = buffer.readBoolean(); + packet.g33 = result2138; + const result2139 = buffer.readBoolean(); + packet.g34 = result2139; + const result2140 = buffer.readBoolean(); + packet.g35 = result2140; + const result2141 = buffer.readBoolean(); + packet.g36 = result2141; + const result2142 = buffer.readBoolean(); + packet.g37 = result2142; + const result2143 = buffer.readBoolean(); + packet.g38 = result2143; + const result2144 = buffer.readBoolean(); + packet.g39 = result2144; + const result2145 = buffer.readBoolean(); + packet.g4 = result2145; + const result2146 = buffer.readBoolean(); + packet.g40 = result2146; + const result2147 = buffer.readBoolean(); + packet.g41 = result2147; + const result2148 = buffer.readBoolean(); + packet.g42 = result2148; + const result2149 = buffer.readBoolean(); + packet.g43 = result2149; + const result2150 = buffer.readBoolean(); + packet.g44 = result2150; + const result2151 = buffer.readBoolean(); + packet.g45 = result2151; + const result2152 = buffer.readBoolean(); + packet.g46 = result2152; + const result2153 = buffer.readBoolean(); + packet.g47 = result2153; + const result2154 = buffer.readBoolean(); + packet.g48 = result2154; + const result2155 = buffer.readBoolean(); + packet.g49 = result2155; + const result2156 = buffer.readBoolean(); + packet.g5 = result2156; + const result2157 = buffer.readBoolean(); + packet.g50 = result2157; + const result2158 = buffer.readBoolean(); + packet.g51 = result2158; + const result2159 = buffer.readBoolean(); + packet.g52 = result2159; + const result2160 = buffer.readBoolean(); + packet.g53 = result2160; + const result2161 = buffer.readBoolean(); + packet.g54 = result2161; + const result2162 = buffer.readBoolean(); + packet.g55 = result2162; + const result2163 = buffer.readBoolean(); + packet.g56 = result2163; + const result2164 = buffer.readBoolean(); + packet.g57 = result2164; + const result2165 = buffer.readBoolean(); + packet.g58 = result2165; + const result2166 = buffer.readBoolean(); + packet.g59 = result2166; + const result2167 = buffer.readBoolean(); + packet.g6 = result2167; + const result2168 = buffer.readBoolean(); + packet.g60 = result2168; + const result2169 = buffer.readBoolean(); + packet.g61 = result2169; + const result2170 = buffer.readBoolean(); + packet.g62 = result2170; + const result2171 = buffer.readBoolean(); + packet.g63 = result2171; + const result2172 = buffer.readBoolean(); + packet.g64 = result2172; + const result2173 = buffer.readBoolean(); + packet.g65 = result2173; + const result2174 = buffer.readBoolean(); + packet.g66 = result2174; + const result2175 = buffer.readBoolean(); + packet.g67 = result2175; + const result2176 = buffer.readBoolean(); + packet.g68 = result2176; + const result2177 = buffer.readBoolean(); + packet.g69 = result2177; + const result2178 = buffer.readBoolean(); + packet.g7 = result2178; + const result2179 = buffer.readBoolean(); + packet.g70 = result2179; + const result2180 = buffer.readBoolean(); + packet.g71 = result2180; + const result2181 = buffer.readBoolean(); + packet.g72 = result2181; + const result2182 = buffer.readBoolean(); + packet.g73 = result2182; + const result2183 = buffer.readBoolean(); + packet.g74 = result2183; + const result2184 = buffer.readBoolean(); + packet.g75 = result2184; + const result2185 = buffer.readBoolean(); + packet.g76 = result2185; + const result2186 = buffer.readBoolean(); + packet.g77 = result2186; + const result2187 = buffer.readBoolean(); + packet.g78 = result2187; + const result2188 = buffer.readBoolean(); + packet.g79 = result2188; + const result2189 = buffer.readBoolean(); + packet.g8 = result2189; + const result2190 = buffer.readBoolean(); + packet.g80 = result2190; + const result2191 = buffer.readBoolean(); + packet.g81 = result2191; + const result2192 = buffer.readBoolean(); + packet.g82 = result2192; + const result2193 = buffer.readBoolean(); + packet.g83 = result2193; + const result2194 = buffer.readBoolean(); + packet.g84 = result2194; + const result2195 = buffer.readBoolean(); + packet.g85 = result2195; + const result2196 = buffer.readBoolean(); + packet.g86 = result2196; + const result2197 = buffer.readBoolean(); + packet.g87 = result2197; + const result2198 = buffer.readBoolean(); + packet.g88 = result2198; + const result2199 = buffer.readBoolean(); + packet.g9 = result2199; + const result2200 = buffer.readBoolean(); + packet.gg1 = result2200; + const result2201 = buffer.readBoolean(); + packet.gg10 = result2201; + const result2202 = buffer.readBoolean(); + packet.gg11 = result2202; + const result2203 = buffer.readBoolean(); + packet.gg12 = result2203; + const result2204 = buffer.readBoolean(); + packet.gg13 = result2204; + const result2205 = buffer.readBoolean(); + packet.gg14 = result2205; + const result2206 = buffer.readBoolean(); + packet.gg15 = result2206; + const result2207 = buffer.readBoolean(); + packet.gg16 = result2207; + const result2208 = buffer.readBoolean(); + packet.gg17 = result2208; + const result2209 = buffer.readBoolean(); + packet.gg18 = result2209; + const result2210 = buffer.readBoolean(); + packet.gg19 = result2210; + const result2211 = buffer.readBoolean(); + packet.gg2 = result2211; + const result2212 = buffer.readBoolean(); + packet.gg20 = result2212; + const result2213 = buffer.readBoolean(); + packet.gg21 = result2213; + const result2214 = buffer.readBoolean(); + packet.gg22 = result2214; + const result2215 = buffer.readBoolean(); + packet.gg23 = result2215; + const result2216 = buffer.readBoolean(); + packet.gg24 = result2216; + const result2217 = buffer.readBoolean(); + packet.gg25 = result2217; + const result2218 = buffer.readBoolean(); + packet.gg26 = result2218; + const result2219 = buffer.readBoolean(); + packet.gg27 = result2219; + const result2220 = buffer.readBoolean(); + packet.gg28 = result2220; + const result2221 = buffer.readBoolean(); + packet.gg29 = result2221; + const result2222 = buffer.readBoolean(); + packet.gg3 = result2222; + const result2223 = buffer.readBoolean(); + packet.gg30 = result2223; + const result2224 = buffer.readBoolean(); + packet.gg31 = result2224; + const result2225 = buffer.readBoolean(); + packet.gg32 = result2225; + const result2226 = buffer.readBoolean(); + packet.gg33 = result2226; + const result2227 = buffer.readBoolean(); + packet.gg34 = result2227; + const result2228 = buffer.readBoolean(); + packet.gg35 = result2228; + const result2229 = buffer.readBoolean(); + packet.gg36 = result2229; + const result2230 = buffer.readBoolean(); + packet.gg37 = result2230; + const result2231 = buffer.readBoolean(); + packet.gg38 = result2231; + const result2232 = buffer.readBoolean(); + packet.gg39 = result2232; + const result2233 = buffer.readBoolean(); + packet.gg4 = result2233; + const result2234 = buffer.readBoolean(); + packet.gg40 = result2234; + const result2235 = buffer.readBoolean(); + packet.gg41 = result2235; + const result2236 = buffer.readBoolean(); + packet.gg42 = result2236; + const result2237 = buffer.readBoolean(); + packet.gg43 = result2237; + const result2238 = buffer.readBoolean(); + packet.gg44 = result2238; + const result2239 = buffer.readBoolean(); + packet.gg45 = result2239; + const result2240 = buffer.readBoolean(); + packet.gg46 = result2240; + const result2241 = buffer.readBoolean(); + packet.gg47 = result2241; + const result2242 = buffer.readBoolean(); + packet.gg48 = result2242; + const result2243 = buffer.readBoolean(); + packet.gg49 = result2243; + const result2244 = buffer.readBoolean(); + packet.gg5 = result2244; + const result2245 = buffer.readBoolean(); + packet.gg50 = result2245; + const result2246 = buffer.readBoolean(); + packet.gg51 = result2246; + const result2247 = buffer.readBoolean(); + packet.gg52 = result2247; + const result2248 = buffer.readBoolean(); + packet.gg53 = result2248; + const result2249 = buffer.readBoolean(); + packet.gg54 = result2249; + const result2250 = buffer.readBoolean(); + packet.gg55 = result2250; + const result2251 = buffer.readBoolean(); + packet.gg56 = result2251; + const result2252 = buffer.readBoolean(); + packet.gg57 = result2252; + const result2253 = buffer.readBoolean(); + packet.gg58 = result2253; + const result2254 = buffer.readBoolean(); + packet.gg59 = result2254; + const result2255 = buffer.readBoolean(); + packet.gg6 = result2255; + const result2256 = buffer.readBoolean(); + packet.gg60 = result2256; + const result2257 = buffer.readBoolean(); + packet.gg61 = result2257; + const result2258 = buffer.readBoolean(); + packet.gg62 = result2258; + const result2259 = buffer.readBoolean(); + packet.gg63 = result2259; + const result2260 = buffer.readBoolean(); + packet.gg64 = result2260; + const result2261 = buffer.readBoolean(); + packet.gg65 = result2261; + const result2262 = buffer.readBoolean(); + packet.gg66 = result2262; + const result2263 = buffer.readBoolean(); + packet.gg67 = result2263; + const result2264 = buffer.readBoolean(); + packet.gg68 = result2264; + const result2265 = buffer.readBoolean(); + packet.gg69 = result2265; + const result2266 = buffer.readBoolean(); + packet.gg7 = result2266; + const result2267 = buffer.readBoolean(); + packet.gg70 = result2267; + const result2268 = buffer.readBoolean(); + packet.gg71 = result2268; + const result2269 = buffer.readBoolean(); + packet.gg72 = result2269; + const result2270 = buffer.readBoolean(); + packet.gg73 = result2270; + const result2271 = buffer.readBoolean(); + packet.gg74 = result2271; + const result2272 = buffer.readBoolean(); + packet.gg75 = result2272; + const result2273 = buffer.readBoolean(); + packet.gg76 = result2273; + const result2274 = buffer.readBoolean(); + packet.gg77 = result2274; + const result2275 = buffer.readBoolean(); + packet.gg78 = result2275; + const result2276 = buffer.readBoolean(); + packet.gg79 = result2276; + const result2277 = buffer.readBoolean(); + packet.gg8 = result2277; + const result2278 = buffer.readBoolean(); + packet.gg80 = result2278; + const result2279 = buffer.readBoolean(); + packet.gg81 = result2279; + const result2280 = buffer.readBoolean(); + packet.gg82 = result2280; + const result2281 = buffer.readBoolean(); + packet.gg83 = result2281; + const result2282 = buffer.readBoolean(); + packet.gg84 = result2282; + const result2283 = buffer.readBoolean(); + packet.gg85 = result2283; + const result2284 = buffer.readBoolean(); + packet.gg86 = result2284; + const result2285 = buffer.readBoolean(); + packet.gg87 = result2285; + const result2286 = buffer.readBoolean(); + packet.gg88 = result2286; + const result2287 = buffer.readBoolean(); + packet.gg9 = result2287; + const array2288 = buffer.readBooleanArray(); + packet.ggg1 = array2288; + const array2289 = buffer.readBooleanArray(); + packet.ggg10 = array2289; + const array2290 = buffer.readBooleanArray(); + packet.ggg11 = array2290; + const array2291 = buffer.readBooleanArray(); + packet.ggg12 = array2291; + const array2292 = buffer.readBooleanArray(); + packet.ggg13 = array2292; + const array2293 = buffer.readBooleanArray(); + packet.ggg14 = array2293; + const array2294 = buffer.readBooleanArray(); + packet.ggg15 = array2294; + const array2295 = buffer.readBooleanArray(); + packet.ggg16 = array2295; + const array2296 = buffer.readBooleanArray(); + packet.ggg17 = array2296; + const array2297 = buffer.readBooleanArray(); + packet.ggg18 = array2297; + const array2298 = buffer.readBooleanArray(); + packet.ggg19 = array2298; + const array2299 = buffer.readBooleanArray(); + packet.ggg2 = array2299; + const array2300 = buffer.readBooleanArray(); + packet.ggg20 = array2300; + const array2301 = buffer.readBooleanArray(); + packet.ggg21 = array2301; + const array2302 = buffer.readBooleanArray(); + packet.ggg22 = array2302; + const array2303 = buffer.readBooleanArray(); + packet.ggg23 = array2303; + const array2304 = buffer.readBooleanArray(); + packet.ggg24 = array2304; + const array2305 = buffer.readBooleanArray(); + packet.ggg25 = array2305; + const array2306 = buffer.readBooleanArray(); + packet.ggg26 = array2306; + const array2307 = buffer.readBooleanArray(); + packet.ggg27 = array2307; + const array2308 = buffer.readBooleanArray(); + packet.ggg28 = array2308; + const array2309 = buffer.readBooleanArray(); + packet.ggg29 = array2309; + const array2310 = buffer.readBooleanArray(); + packet.ggg3 = array2310; + const array2311 = buffer.readBooleanArray(); + packet.ggg30 = array2311; + const array2312 = buffer.readBooleanArray(); + packet.ggg31 = array2312; + const array2313 = buffer.readBooleanArray(); + packet.ggg32 = array2313; + const array2314 = buffer.readBooleanArray(); + packet.ggg33 = array2314; + const array2315 = buffer.readBooleanArray(); + packet.ggg34 = array2315; + const array2316 = buffer.readBooleanArray(); + packet.ggg35 = array2316; + const array2317 = buffer.readBooleanArray(); + packet.ggg36 = array2317; + const array2318 = buffer.readBooleanArray(); + packet.ggg37 = array2318; + const array2319 = buffer.readBooleanArray(); + packet.ggg38 = array2319; + const array2320 = buffer.readBooleanArray(); + packet.ggg39 = array2320; + const array2321 = buffer.readBooleanArray(); + packet.ggg4 = array2321; + const array2322 = buffer.readBooleanArray(); + packet.ggg40 = array2322; + const array2323 = buffer.readBooleanArray(); + packet.ggg41 = array2323; + const array2324 = buffer.readBooleanArray(); + packet.ggg42 = array2324; + const array2325 = buffer.readBooleanArray(); + packet.ggg43 = array2325; + const array2326 = buffer.readBooleanArray(); + packet.ggg44 = array2326; + const array2327 = buffer.readBooleanArray(); + packet.ggg45 = array2327; + const array2328 = buffer.readBooleanArray(); + packet.ggg46 = array2328; + const array2329 = buffer.readBooleanArray(); + packet.ggg47 = array2329; + const array2330 = buffer.readBooleanArray(); + packet.ggg48 = array2330; + const array2331 = buffer.readBooleanArray(); + packet.ggg49 = array2331; + const array2332 = buffer.readBooleanArray(); + packet.ggg5 = array2332; + const array2333 = buffer.readBooleanArray(); + packet.ggg50 = array2333; + const array2334 = buffer.readBooleanArray(); + packet.ggg51 = array2334; + const array2335 = buffer.readBooleanArray(); + packet.ggg52 = array2335; + const array2336 = buffer.readBooleanArray(); + packet.ggg53 = array2336; + const array2337 = buffer.readBooleanArray(); + packet.ggg54 = array2337; + const array2338 = buffer.readBooleanArray(); + packet.ggg55 = array2338; + const array2339 = buffer.readBooleanArray(); + packet.ggg56 = array2339; + const array2340 = buffer.readBooleanArray(); + packet.ggg57 = array2340; + const array2341 = buffer.readBooleanArray(); + packet.ggg58 = array2341; + const array2342 = buffer.readBooleanArray(); + packet.ggg59 = array2342; + const array2343 = buffer.readBooleanArray(); + packet.ggg6 = array2343; + const array2344 = buffer.readBooleanArray(); + packet.ggg60 = array2344; + const array2345 = buffer.readBooleanArray(); + packet.ggg61 = array2345; + const array2346 = buffer.readBooleanArray(); + packet.ggg62 = array2346; + const array2347 = buffer.readBooleanArray(); + packet.ggg63 = array2347; + const array2348 = buffer.readBooleanArray(); + packet.ggg64 = array2348; + const array2349 = buffer.readBooleanArray(); + packet.ggg65 = array2349; + const array2350 = buffer.readBooleanArray(); + packet.ggg66 = array2350; + const array2351 = buffer.readBooleanArray(); + packet.ggg67 = array2351; + const array2352 = buffer.readBooleanArray(); + packet.ggg68 = array2352; + const array2353 = buffer.readBooleanArray(); + packet.ggg69 = array2353; + const array2354 = buffer.readBooleanArray(); + packet.ggg7 = array2354; + const array2355 = buffer.readBooleanArray(); + packet.ggg70 = array2355; + const array2356 = buffer.readBooleanArray(); + packet.ggg71 = array2356; + const array2357 = buffer.readBooleanArray(); + packet.ggg72 = array2357; + const array2358 = buffer.readBooleanArray(); + packet.ggg73 = array2358; + const array2359 = buffer.readBooleanArray(); + packet.ggg74 = array2359; + const array2360 = buffer.readBooleanArray(); + packet.ggg75 = array2360; + const array2361 = buffer.readBooleanArray(); + packet.ggg76 = array2361; + const array2362 = buffer.readBooleanArray(); + packet.ggg77 = array2362; + const array2363 = buffer.readBooleanArray(); + packet.ggg78 = array2363; + const array2364 = buffer.readBooleanArray(); + packet.ggg79 = array2364; + const array2365 = buffer.readBooleanArray(); + packet.ggg8 = array2365; + const array2366 = buffer.readBooleanArray(); + packet.ggg80 = array2366; + const array2367 = buffer.readBooleanArray(); + packet.ggg81 = array2367; + const array2368 = buffer.readBooleanArray(); + packet.ggg82 = array2368; + const array2369 = buffer.readBooleanArray(); + packet.ggg83 = array2369; + const array2370 = buffer.readBooleanArray(); + packet.ggg84 = array2370; + const array2371 = buffer.readBooleanArray(); + packet.ggg85 = array2371; + const array2372 = buffer.readBooleanArray(); + packet.ggg86 = array2372; + const array2373 = buffer.readBooleanArray(); + packet.ggg87 = array2373; + const array2374 = buffer.readBooleanArray(); + packet.ggg88 = array2374; + const array2375 = buffer.readBooleanArray(); + packet.ggg9 = array2375; + const array2376 = buffer.readBooleanArray(); + packet.gggg1 = array2376; + const array2377 = buffer.readBooleanArray(); + packet.gggg10 = array2377; + const array2378 = buffer.readBooleanArray(); + packet.gggg11 = array2378; + const array2379 = buffer.readBooleanArray(); + packet.gggg12 = array2379; + const array2380 = buffer.readBooleanArray(); + packet.gggg13 = array2380; + const array2381 = buffer.readBooleanArray(); + packet.gggg14 = array2381; + const array2382 = buffer.readBooleanArray(); + packet.gggg15 = array2382; + const array2383 = buffer.readBooleanArray(); + packet.gggg16 = array2383; + const array2384 = buffer.readBooleanArray(); + packet.gggg17 = array2384; + const array2385 = buffer.readBooleanArray(); + packet.gggg18 = array2385; + const array2386 = buffer.readBooleanArray(); + packet.gggg19 = array2386; + const array2387 = buffer.readBooleanArray(); + packet.gggg2 = array2387; + const array2388 = buffer.readBooleanArray(); + packet.gggg20 = array2388; + const array2389 = buffer.readBooleanArray(); + packet.gggg21 = array2389; + const array2390 = buffer.readBooleanArray(); + packet.gggg22 = array2390; + const array2391 = buffer.readBooleanArray(); + packet.gggg23 = array2391; + const array2392 = buffer.readBooleanArray(); + packet.gggg24 = array2392; + const array2393 = buffer.readBooleanArray(); + packet.gggg25 = array2393; + const array2394 = buffer.readBooleanArray(); + packet.gggg26 = array2394; + const array2395 = buffer.readBooleanArray(); + packet.gggg27 = array2395; + const array2396 = buffer.readBooleanArray(); + packet.gggg28 = array2396; + const array2397 = buffer.readBooleanArray(); + packet.gggg29 = array2397; + const array2398 = buffer.readBooleanArray(); + packet.gggg3 = array2398; + const array2399 = buffer.readBooleanArray(); + packet.gggg30 = array2399; + const array2400 = buffer.readBooleanArray(); + packet.gggg31 = array2400; + const array2401 = buffer.readBooleanArray(); + packet.gggg32 = array2401; + const array2402 = buffer.readBooleanArray(); + packet.gggg33 = array2402; + const array2403 = buffer.readBooleanArray(); + packet.gggg34 = array2403; + const array2404 = buffer.readBooleanArray(); + packet.gggg35 = array2404; + const array2405 = buffer.readBooleanArray(); + packet.gggg36 = array2405; + const array2406 = buffer.readBooleanArray(); + packet.gggg37 = array2406; + const array2407 = buffer.readBooleanArray(); + packet.gggg38 = array2407; + const array2408 = buffer.readBooleanArray(); + packet.gggg39 = array2408; + const array2409 = buffer.readBooleanArray(); + packet.gggg4 = array2409; + const array2410 = buffer.readBooleanArray(); + packet.gggg40 = array2410; + const array2411 = buffer.readBooleanArray(); + packet.gggg41 = array2411; + const array2412 = buffer.readBooleanArray(); + packet.gggg42 = array2412; + const array2413 = buffer.readBooleanArray(); + packet.gggg43 = array2413; + const array2414 = buffer.readBooleanArray(); + packet.gggg44 = array2414; + const array2415 = buffer.readBooleanArray(); + packet.gggg45 = array2415; + const array2416 = buffer.readBooleanArray(); + packet.gggg46 = array2416; + const array2417 = buffer.readBooleanArray(); + packet.gggg47 = array2417; + const array2418 = buffer.readBooleanArray(); + packet.gggg48 = array2418; + const array2419 = buffer.readBooleanArray(); + packet.gggg49 = array2419; + const array2420 = buffer.readBooleanArray(); + packet.gggg5 = array2420; + const array2421 = buffer.readBooleanArray(); + packet.gggg50 = array2421; + const array2422 = buffer.readBooleanArray(); + packet.gggg51 = array2422; + const array2423 = buffer.readBooleanArray(); + packet.gggg52 = array2423; + const array2424 = buffer.readBooleanArray(); + packet.gggg53 = array2424; + const array2425 = buffer.readBooleanArray(); + packet.gggg54 = array2425; + const array2426 = buffer.readBooleanArray(); + packet.gggg55 = array2426; + const array2427 = buffer.readBooleanArray(); + packet.gggg56 = array2427; + const array2428 = buffer.readBooleanArray(); + packet.gggg57 = array2428; + const array2429 = buffer.readBooleanArray(); + packet.gggg58 = array2429; + const array2430 = buffer.readBooleanArray(); + packet.gggg59 = array2430; + const array2431 = buffer.readBooleanArray(); + packet.gggg6 = array2431; + const array2432 = buffer.readBooleanArray(); + packet.gggg60 = array2432; + const array2433 = buffer.readBooleanArray(); + packet.gggg61 = array2433; + const array2434 = buffer.readBooleanArray(); + packet.gggg62 = array2434; + const array2435 = buffer.readBooleanArray(); + packet.gggg63 = array2435; + const array2436 = buffer.readBooleanArray(); + packet.gggg64 = array2436; + const array2437 = buffer.readBooleanArray(); + packet.gggg65 = array2437; + const array2438 = buffer.readBooleanArray(); + packet.gggg66 = array2438; + const array2439 = buffer.readBooleanArray(); + packet.gggg67 = array2439; + const array2440 = buffer.readBooleanArray(); + packet.gggg68 = array2440; + const array2441 = buffer.readBooleanArray(); + packet.gggg69 = array2441; + const array2442 = buffer.readBooleanArray(); + packet.gggg7 = array2442; + const array2443 = buffer.readBooleanArray(); + packet.gggg70 = array2443; + const array2444 = buffer.readBooleanArray(); + packet.gggg71 = array2444; + const array2445 = buffer.readBooleanArray(); + packet.gggg72 = array2445; + const array2446 = buffer.readBooleanArray(); + packet.gggg73 = array2446; + const array2447 = buffer.readBooleanArray(); + packet.gggg74 = array2447; + const array2448 = buffer.readBooleanArray(); + packet.gggg75 = array2448; + const array2449 = buffer.readBooleanArray(); + packet.gggg76 = array2449; + const array2450 = buffer.readBooleanArray(); + packet.gggg77 = array2450; + const array2451 = buffer.readBooleanArray(); + packet.gggg78 = array2451; + const array2452 = buffer.readBooleanArray(); + packet.gggg79 = array2452; + const array2453 = buffer.readBooleanArray(); + packet.gggg8 = array2453; + const array2454 = buffer.readBooleanArray(); + packet.gggg80 = array2454; + const array2455 = buffer.readBooleanArray(); + packet.gggg81 = array2455; + const array2456 = buffer.readBooleanArray(); + packet.gggg82 = array2456; + const array2457 = buffer.readBooleanArray(); + packet.gggg83 = array2457; + const array2458 = buffer.readBooleanArray(); + packet.gggg84 = array2458; + const array2459 = buffer.readBooleanArray(); + packet.gggg85 = array2459; + const array2460 = buffer.readBooleanArray(); + packet.gggg86 = array2460; + const array2461 = buffer.readBooleanArray(); + packet.gggg87 = array2461; + const array2462 = buffer.readBooleanArray(); + packet.gggg88 = array2462; + const array2463 = buffer.readBooleanArray(); + packet.gggg9 = array2463; + const result2464 = buffer.readString(); + packet.jj1 = result2464; + const result2465 = buffer.readString(); + packet.jj10 = result2465; + const result2466 = buffer.readString(); + packet.jj11 = result2466; + const result2467 = buffer.readString(); + packet.jj12 = result2467; + const result2468 = buffer.readString(); + packet.jj13 = result2468; + const result2469 = buffer.readString(); + packet.jj14 = result2469; + const result2470 = buffer.readString(); + packet.jj15 = result2470; + const result2471 = buffer.readString(); + packet.jj16 = result2471; + const result2472 = buffer.readString(); + packet.jj17 = result2472; + const result2473 = buffer.readString(); + packet.jj18 = result2473; + const result2474 = buffer.readString(); + packet.jj19 = result2474; + const result2475 = buffer.readString(); + packet.jj2 = result2475; + const result2476 = buffer.readString(); + packet.jj20 = result2476; + const result2477 = buffer.readString(); + packet.jj21 = result2477; + const result2478 = buffer.readString(); + packet.jj22 = result2478; + const result2479 = buffer.readString(); + packet.jj23 = result2479; + const result2480 = buffer.readString(); + packet.jj24 = result2480; + const result2481 = buffer.readString(); + packet.jj25 = result2481; + const result2482 = buffer.readString(); + packet.jj26 = result2482; + const result2483 = buffer.readString(); + packet.jj27 = result2483; + const result2484 = buffer.readString(); + packet.jj28 = result2484; + const result2485 = buffer.readString(); + packet.jj29 = result2485; + const result2486 = buffer.readString(); + packet.jj3 = result2486; + const result2487 = buffer.readString(); + packet.jj30 = result2487; + const result2488 = buffer.readString(); + packet.jj31 = result2488; + const result2489 = buffer.readString(); + packet.jj32 = result2489; + const result2490 = buffer.readString(); + packet.jj33 = result2490; + const result2491 = buffer.readString(); + packet.jj34 = result2491; + const result2492 = buffer.readString(); + packet.jj35 = result2492; + const result2493 = buffer.readString(); + packet.jj36 = result2493; + const result2494 = buffer.readString(); + packet.jj37 = result2494; + const result2495 = buffer.readString(); + packet.jj38 = result2495; + const result2496 = buffer.readString(); + packet.jj39 = result2496; + const result2497 = buffer.readString(); + packet.jj4 = result2497; + const result2498 = buffer.readString(); + packet.jj40 = result2498; + const result2499 = buffer.readString(); + packet.jj41 = result2499; + const result2500 = buffer.readString(); + packet.jj42 = result2500; + const result2501 = buffer.readString(); + packet.jj43 = result2501; + const result2502 = buffer.readString(); + packet.jj44 = result2502; + const result2503 = buffer.readString(); + packet.jj45 = result2503; + const result2504 = buffer.readString(); + packet.jj46 = result2504; + const result2505 = buffer.readString(); + packet.jj47 = result2505; + const result2506 = buffer.readString(); + packet.jj48 = result2506; + const result2507 = buffer.readString(); + packet.jj49 = result2507; + const result2508 = buffer.readString(); + packet.jj5 = result2508; + const result2509 = buffer.readString(); + packet.jj50 = result2509; + const result2510 = buffer.readString(); + packet.jj51 = result2510; + const result2511 = buffer.readString(); + packet.jj52 = result2511; + const result2512 = buffer.readString(); + packet.jj53 = result2512; + const result2513 = buffer.readString(); + packet.jj54 = result2513; + const result2514 = buffer.readString(); + packet.jj55 = result2514; + const result2515 = buffer.readString(); + packet.jj56 = result2515; + const result2516 = buffer.readString(); + packet.jj57 = result2516; + const result2517 = buffer.readString(); + packet.jj58 = result2517; + const result2518 = buffer.readString(); + packet.jj59 = result2518; + const result2519 = buffer.readString(); + packet.jj6 = result2519; + const result2520 = buffer.readString(); + packet.jj60 = result2520; + const result2521 = buffer.readString(); + packet.jj61 = result2521; + const result2522 = buffer.readString(); + packet.jj62 = result2522; + const result2523 = buffer.readString(); + packet.jj63 = result2523; + const result2524 = buffer.readString(); + packet.jj64 = result2524; + const result2525 = buffer.readString(); + packet.jj65 = result2525; + const result2526 = buffer.readString(); + packet.jj66 = result2526; + const result2527 = buffer.readString(); + packet.jj67 = result2527; + const result2528 = buffer.readString(); + packet.jj68 = result2528; + const result2529 = buffer.readString(); + packet.jj69 = result2529; + const result2530 = buffer.readString(); + packet.jj7 = result2530; + const result2531 = buffer.readString(); + packet.jj70 = result2531; + const result2532 = buffer.readString(); + packet.jj71 = result2532; + const result2533 = buffer.readString(); + packet.jj72 = result2533; + const result2534 = buffer.readString(); + packet.jj73 = result2534; + const result2535 = buffer.readString(); + packet.jj74 = result2535; + const result2536 = buffer.readString(); + packet.jj75 = result2536; + const result2537 = buffer.readString(); + packet.jj76 = result2537; + const result2538 = buffer.readString(); + packet.jj77 = result2538; + const result2539 = buffer.readString(); + packet.jj78 = result2539; + const result2540 = buffer.readString(); + packet.jj79 = result2540; + const result2541 = buffer.readString(); + packet.jj8 = result2541; + const result2542 = buffer.readString(); + packet.jj80 = result2542; + const result2543 = buffer.readString(); + packet.jj81 = result2543; + const result2544 = buffer.readString(); + packet.jj82 = result2544; + const result2545 = buffer.readString(); + packet.jj83 = result2545; + const result2546 = buffer.readString(); + packet.jj84 = result2546; + const result2547 = buffer.readString(); + packet.jj85 = result2547; + const result2548 = buffer.readString(); + packet.jj86 = result2548; + const result2549 = buffer.readString(); + packet.jj87 = result2549; + const result2550 = buffer.readString(); + packet.jj88 = result2550; + const result2551 = buffer.readString(); + packet.jj9 = result2551; + const array2552 = buffer.readStringArray(); + packet.jjj1 = array2552; + const array2553 = buffer.readStringArray(); + packet.jjj10 = array2553; + const array2554 = buffer.readStringArray(); + packet.jjj11 = array2554; + const array2555 = buffer.readStringArray(); + packet.jjj12 = array2555; + const array2556 = buffer.readStringArray(); + packet.jjj13 = array2556; + const array2557 = buffer.readStringArray(); + packet.jjj14 = array2557; + const array2558 = buffer.readStringArray(); + packet.jjj15 = array2558; + const array2559 = buffer.readStringArray(); + packet.jjj16 = array2559; + const array2560 = buffer.readStringArray(); + packet.jjj17 = array2560; + const array2561 = buffer.readStringArray(); + packet.jjj18 = array2561; + const array2562 = buffer.readStringArray(); + packet.jjj19 = array2562; + const array2563 = buffer.readStringArray(); + packet.jjj2 = array2563; + const array2564 = buffer.readStringArray(); + packet.jjj20 = array2564; + const array2565 = buffer.readStringArray(); + packet.jjj21 = array2565; + const array2566 = buffer.readStringArray(); + packet.jjj22 = array2566; + const array2567 = buffer.readStringArray(); + packet.jjj23 = array2567; + const array2568 = buffer.readStringArray(); + packet.jjj24 = array2568; + const array2569 = buffer.readStringArray(); + packet.jjj25 = array2569; + const array2570 = buffer.readStringArray(); + packet.jjj26 = array2570; + const array2571 = buffer.readStringArray(); + packet.jjj27 = array2571; + const array2572 = buffer.readStringArray(); + packet.jjj28 = array2572; + const array2573 = buffer.readStringArray(); + packet.jjj29 = array2573; + const array2574 = buffer.readStringArray(); + packet.jjj3 = array2574; + const array2575 = buffer.readStringArray(); + packet.jjj30 = array2575; + const array2576 = buffer.readStringArray(); + packet.jjj31 = array2576; + const array2577 = buffer.readStringArray(); + packet.jjj32 = array2577; + const array2578 = buffer.readStringArray(); + packet.jjj33 = array2578; + const array2579 = buffer.readStringArray(); + packet.jjj34 = array2579; + const array2580 = buffer.readStringArray(); + packet.jjj35 = array2580; + const array2581 = buffer.readStringArray(); + packet.jjj36 = array2581; + const array2582 = buffer.readStringArray(); + packet.jjj37 = array2582; + const array2583 = buffer.readStringArray(); + packet.jjj38 = array2583; + const array2584 = buffer.readStringArray(); + packet.jjj39 = array2584; + const array2585 = buffer.readStringArray(); + packet.jjj4 = array2585; + const array2586 = buffer.readStringArray(); + packet.jjj40 = array2586; + const array2587 = buffer.readStringArray(); + packet.jjj41 = array2587; + const array2588 = buffer.readStringArray(); + packet.jjj42 = array2588; + const array2589 = buffer.readStringArray(); + packet.jjj43 = array2589; + const array2590 = buffer.readStringArray(); + packet.jjj44 = array2590; + const array2591 = buffer.readStringArray(); + packet.jjj45 = array2591; + const array2592 = buffer.readStringArray(); + packet.jjj46 = array2592; + const array2593 = buffer.readStringArray(); + packet.jjj47 = array2593; + const array2594 = buffer.readStringArray(); + packet.jjj48 = array2594; + const array2595 = buffer.readStringArray(); + packet.jjj49 = array2595; + const array2596 = buffer.readStringArray(); + packet.jjj5 = array2596; + const array2597 = buffer.readStringArray(); + packet.jjj50 = array2597; + const array2598 = buffer.readStringArray(); + packet.jjj51 = array2598; + const array2599 = buffer.readStringArray(); + packet.jjj52 = array2599; + const array2600 = buffer.readStringArray(); + packet.jjj53 = array2600; + const array2601 = buffer.readStringArray(); + packet.jjj54 = array2601; + const array2602 = buffer.readStringArray(); + packet.jjj55 = array2602; + const array2603 = buffer.readStringArray(); + packet.jjj56 = array2603; + const array2604 = buffer.readStringArray(); + packet.jjj57 = array2604; + const array2605 = buffer.readStringArray(); + packet.jjj58 = array2605; + const array2606 = buffer.readStringArray(); + packet.jjj59 = array2606; + const array2607 = buffer.readStringArray(); + packet.jjj6 = array2607; + const array2608 = buffer.readStringArray(); + packet.jjj60 = array2608; + const array2609 = buffer.readStringArray(); + packet.jjj61 = array2609; + const array2610 = buffer.readStringArray(); + packet.jjj62 = array2610; + const array2611 = buffer.readStringArray(); + packet.jjj63 = array2611; + const array2612 = buffer.readStringArray(); + packet.jjj64 = array2612; + const array2613 = buffer.readStringArray(); + packet.jjj65 = array2613; + const array2614 = buffer.readStringArray(); + packet.jjj66 = array2614; + const array2615 = buffer.readStringArray(); + packet.jjj67 = array2615; + const array2616 = buffer.readStringArray(); + packet.jjj68 = array2616; + const array2617 = buffer.readStringArray(); + packet.jjj69 = array2617; + const array2618 = buffer.readStringArray(); + packet.jjj7 = array2618; + const array2619 = buffer.readStringArray(); + packet.jjj70 = array2619; + const array2620 = buffer.readStringArray(); + packet.jjj71 = array2620; + const array2621 = buffer.readStringArray(); + packet.jjj72 = array2621; + const array2622 = buffer.readStringArray(); + packet.jjj73 = array2622; + const array2623 = buffer.readStringArray(); + packet.jjj74 = array2623; + const array2624 = buffer.readStringArray(); + packet.jjj75 = array2624; + const array2625 = buffer.readStringArray(); + packet.jjj76 = array2625; + const array2626 = buffer.readStringArray(); + packet.jjj77 = array2626; + const array2627 = buffer.readStringArray(); + packet.jjj78 = array2627; + const array2628 = buffer.readStringArray(); + packet.jjj79 = array2628; + const array2629 = buffer.readStringArray(); + packet.jjj8 = array2629; + const array2630 = buffer.readStringArray(); + packet.jjj80 = array2630; + const array2631 = buffer.readStringArray(); + packet.jjj81 = array2631; + const array2632 = buffer.readStringArray(); + packet.jjj82 = array2632; + const array2633 = buffer.readStringArray(); + packet.jjj83 = array2633; + const array2634 = buffer.readStringArray(); + packet.jjj84 = array2634; + const array2635 = buffer.readStringArray(); + packet.jjj85 = array2635; + const array2636 = buffer.readStringArray(); + packet.jjj86 = array2636; + const array2637 = buffer.readStringArray(); + packet.jjj87 = array2637; + const array2638 = buffer.readStringArray(); + packet.jjj88 = array2638; + const array2639 = buffer.readStringArray(); + packet.jjj9 = array2639; + const result2640 = buffer.readPacket(102); + packet.kk1 = result2640; + const result2641 = buffer.readPacket(102); + packet.kk10 = result2641; + const result2642 = buffer.readPacket(102); + packet.kk11 = result2642; + const result2643 = buffer.readPacket(102); + packet.kk12 = result2643; + const result2644 = buffer.readPacket(102); + packet.kk13 = result2644; + const result2645 = buffer.readPacket(102); + packet.kk14 = result2645; + const result2646 = buffer.readPacket(102); + packet.kk15 = result2646; + const result2647 = buffer.readPacket(102); + packet.kk16 = result2647; + const result2648 = buffer.readPacket(102); + packet.kk17 = result2648; + const result2649 = buffer.readPacket(102); + packet.kk18 = result2649; + const result2650 = buffer.readPacket(102); + packet.kk19 = result2650; + const result2651 = buffer.readPacket(102); + packet.kk2 = result2651; + const result2652 = buffer.readPacket(102); + packet.kk20 = result2652; + const result2653 = buffer.readPacket(102); + packet.kk21 = result2653; + const result2654 = buffer.readPacket(102); + packet.kk22 = result2654; + const result2655 = buffer.readPacket(102); + packet.kk23 = result2655; + const result2656 = buffer.readPacket(102); + packet.kk24 = result2656; + const result2657 = buffer.readPacket(102); + packet.kk25 = result2657; + const result2658 = buffer.readPacket(102); + packet.kk26 = result2658; + const result2659 = buffer.readPacket(102); + packet.kk27 = result2659; + const result2660 = buffer.readPacket(102); + packet.kk28 = result2660; + const result2661 = buffer.readPacket(102); + packet.kk29 = result2661; + const result2662 = buffer.readPacket(102); + packet.kk3 = result2662; + const result2663 = buffer.readPacket(102); + packet.kk30 = result2663; + const result2664 = buffer.readPacket(102); + packet.kk31 = result2664; + const result2665 = buffer.readPacket(102); + packet.kk32 = result2665; + const result2666 = buffer.readPacket(102); + packet.kk33 = result2666; + const result2667 = buffer.readPacket(102); + packet.kk34 = result2667; + const result2668 = buffer.readPacket(102); + packet.kk35 = result2668; + const result2669 = buffer.readPacket(102); + packet.kk36 = result2669; + const result2670 = buffer.readPacket(102); + packet.kk37 = result2670; + const result2671 = buffer.readPacket(102); + packet.kk38 = result2671; + const result2672 = buffer.readPacket(102); + packet.kk39 = result2672; + const result2673 = buffer.readPacket(102); + packet.kk4 = result2673; + const result2674 = buffer.readPacket(102); + packet.kk40 = result2674; + const result2675 = buffer.readPacket(102); + packet.kk41 = result2675; + const result2676 = buffer.readPacket(102); + packet.kk42 = result2676; + const result2677 = buffer.readPacket(102); + packet.kk43 = result2677; + const result2678 = buffer.readPacket(102); + packet.kk44 = result2678; + const result2679 = buffer.readPacket(102); + packet.kk45 = result2679; + const result2680 = buffer.readPacket(102); + packet.kk46 = result2680; + const result2681 = buffer.readPacket(102); + packet.kk47 = result2681; + const result2682 = buffer.readPacket(102); + packet.kk48 = result2682; + const result2683 = buffer.readPacket(102); + packet.kk49 = result2683; + const result2684 = buffer.readPacket(102); + packet.kk5 = result2684; + const result2685 = buffer.readPacket(102); + packet.kk50 = result2685; + const result2686 = buffer.readPacket(102); + packet.kk51 = result2686; + const result2687 = buffer.readPacket(102); + packet.kk52 = result2687; + const result2688 = buffer.readPacket(102); + packet.kk53 = result2688; + const result2689 = buffer.readPacket(102); + packet.kk54 = result2689; + const result2690 = buffer.readPacket(102); + packet.kk55 = result2690; + const result2691 = buffer.readPacket(102); + packet.kk56 = result2691; + const result2692 = buffer.readPacket(102); + packet.kk57 = result2692; + const result2693 = buffer.readPacket(102); + packet.kk58 = result2693; + const result2694 = buffer.readPacket(102); + packet.kk59 = result2694; + const result2695 = buffer.readPacket(102); + packet.kk6 = result2695; + const result2696 = buffer.readPacket(102); + packet.kk60 = result2696; + const result2697 = buffer.readPacket(102); + packet.kk61 = result2697; + const result2698 = buffer.readPacket(102); + packet.kk62 = result2698; + const result2699 = buffer.readPacket(102); + packet.kk63 = result2699; + const result2700 = buffer.readPacket(102); + packet.kk64 = result2700; + const result2701 = buffer.readPacket(102); + packet.kk65 = result2701; + const result2702 = buffer.readPacket(102); + packet.kk66 = result2702; + const result2703 = buffer.readPacket(102); + packet.kk67 = result2703; + const result2704 = buffer.readPacket(102); + packet.kk68 = result2704; + const result2705 = buffer.readPacket(102); + packet.kk69 = result2705; + const result2706 = buffer.readPacket(102); + packet.kk7 = result2706; + const result2707 = buffer.readPacket(102); + packet.kk70 = result2707; + const result2708 = buffer.readPacket(102); + packet.kk71 = result2708; + const result2709 = buffer.readPacket(102); + packet.kk72 = result2709; + const result2710 = buffer.readPacket(102); + packet.kk73 = result2710; + const result2711 = buffer.readPacket(102); + packet.kk74 = result2711; + const result2712 = buffer.readPacket(102); + packet.kk75 = result2712; + const result2713 = buffer.readPacket(102); + packet.kk76 = result2713; + const result2714 = buffer.readPacket(102); + packet.kk77 = result2714; + const result2715 = buffer.readPacket(102); + packet.kk78 = result2715; + const result2716 = buffer.readPacket(102); + packet.kk79 = result2716; + const result2717 = buffer.readPacket(102); + packet.kk8 = result2717; + const result2718 = buffer.readPacket(102); + packet.kk80 = result2718; + const result2719 = buffer.readPacket(102); + packet.kk81 = result2719; + const result2720 = buffer.readPacket(102); + packet.kk82 = result2720; + const result2721 = buffer.readPacket(102); + packet.kk83 = result2721; + const result2722 = buffer.readPacket(102); + packet.kk84 = result2722; + const result2723 = buffer.readPacket(102); + packet.kk85 = result2723; + const result2724 = buffer.readPacket(102); + packet.kk86 = result2724; + const result2725 = buffer.readPacket(102); + packet.kk87 = result2725; + const result2726 = buffer.readPacket(102); + packet.kk88 = result2726; + const result2727 = buffer.readPacket(102); + packet.kk9 = result2727; + const array2728 = buffer.readPacketArray(102); + packet.kkk1 = array2728; + const array2729 = buffer.readPacketArray(102); + packet.kkk10 = array2729; + const array2730 = buffer.readPacketArray(102); + packet.kkk11 = array2730; + const array2731 = buffer.readPacketArray(102); + packet.kkk12 = array2731; + const array2732 = buffer.readPacketArray(102); + packet.kkk13 = array2732; + const array2733 = buffer.readPacketArray(102); + packet.kkk14 = array2733; + const array2734 = buffer.readPacketArray(102); + packet.kkk15 = array2734; + const array2735 = buffer.readPacketArray(102); + packet.kkk16 = array2735; + const array2736 = buffer.readPacketArray(102); + packet.kkk17 = array2736; + const array2737 = buffer.readPacketArray(102); + packet.kkk18 = array2737; + const array2738 = buffer.readPacketArray(102); + packet.kkk19 = array2738; + const array2739 = buffer.readPacketArray(102); + packet.kkk2 = array2739; + const array2740 = buffer.readPacketArray(102); + packet.kkk20 = array2740; + const array2741 = buffer.readPacketArray(102); + packet.kkk21 = array2741; + const array2742 = buffer.readPacketArray(102); + packet.kkk22 = array2742; + const array2743 = buffer.readPacketArray(102); + packet.kkk23 = array2743; + const array2744 = buffer.readPacketArray(102); + packet.kkk24 = array2744; + const array2745 = buffer.readPacketArray(102); + packet.kkk25 = array2745; + const array2746 = buffer.readPacketArray(102); + packet.kkk26 = array2746; + const array2747 = buffer.readPacketArray(102); + packet.kkk27 = array2747; + const array2748 = buffer.readPacketArray(102); + packet.kkk28 = array2748; + const array2749 = buffer.readPacketArray(102); + packet.kkk29 = array2749; + const array2750 = buffer.readPacketArray(102); + packet.kkk3 = array2750; + const array2751 = buffer.readPacketArray(102); + packet.kkk30 = array2751; + const array2752 = buffer.readPacketArray(102); + packet.kkk31 = array2752; + const array2753 = buffer.readPacketArray(102); + packet.kkk32 = array2753; + const array2754 = buffer.readPacketArray(102); + packet.kkk33 = array2754; + const array2755 = buffer.readPacketArray(102); + packet.kkk34 = array2755; + const array2756 = buffer.readPacketArray(102); + packet.kkk35 = array2756; + const array2757 = buffer.readPacketArray(102); + packet.kkk36 = array2757; + const array2758 = buffer.readPacketArray(102); + packet.kkk37 = array2758; + const array2759 = buffer.readPacketArray(102); + packet.kkk38 = array2759; + const array2760 = buffer.readPacketArray(102); + packet.kkk39 = array2760; + const array2761 = buffer.readPacketArray(102); + packet.kkk4 = array2761; + const array2762 = buffer.readPacketArray(102); + packet.kkk40 = array2762; + const array2763 = buffer.readPacketArray(102); + packet.kkk41 = array2763; + const array2764 = buffer.readPacketArray(102); + packet.kkk42 = array2764; + const array2765 = buffer.readPacketArray(102); + packet.kkk43 = array2765; + const array2766 = buffer.readPacketArray(102); + packet.kkk44 = array2766; + const array2767 = buffer.readPacketArray(102); + packet.kkk45 = array2767; + const array2768 = buffer.readPacketArray(102); + packet.kkk46 = array2768; + const array2769 = buffer.readPacketArray(102); + packet.kkk47 = array2769; + const array2770 = buffer.readPacketArray(102); + packet.kkk48 = array2770; + const array2771 = buffer.readPacketArray(102); + packet.kkk49 = array2771; + const array2772 = buffer.readPacketArray(102); + packet.kkk5 = array2772; + const array2773 = buffer.readPacketArray(102); + packet.kkk50 = array2773; + const array2774 = buffer.readPacketArray(102); + packet.kkk51 = array2774; + const array2775 = buffer.readPacketArray(102); + packet.kkk52 = array2775; + const array2776 = buffer.readPacketArray(102); + packet.kkk53 = array2776; + const array2777 = buffer.readPacketArray(102); + packet.kkk54 = array2777; + const array2778 = buffer.readPacketArray(102); + packet.kkk55 = array2778; + const array2779 = buffer.readPacketArray(102); + packet.kkk56 = array2779; + const array2780 = buffer.readPacketArray(102); + packet.kkk57 = array2780; + const array2781 = buffer.readPacketArray(102); + packet.kkk58 = array2781; + const array2782 = buffer.readPacketArray(102); + packet.kkk59 = array2782; + const array2783 = buffer.readPacketArray(102); + packet.kkk6 = array2783; + const array2784 = buffer.readPacketArray(102); + packet.kkk60 = array2784; + const array2785 = buffer.readPacketArray(102); + packet.kkk61 = array2785; + const array2786 = buffer.readPacketArray(102); + packet.kkk62 = array2786; + const array2787 = buffer.readPacketArray(102); + packet.kkk63 = array2787; + const array2788 = buffer.readPacketArray(102); + packet.kkk64 = array2788; + const array2789 = buffer.readPacketArray(102); + packet.kkk65 = array2789; + const array2790 = buffer.readPacketArray(102); + packet.kkk66 = array2790; + const array2791 = buffer.readPacketArray(102); + packet.kkk67 = array2791; + const array2792 = buffer.readPacketArray(102); + packet.kkk68 = array2792; + const array2793 = buffer.readPacketArray(102); + packet.kkk69 = array2793; + const array2794 = buffer.readPacketArray(102); + packet.kkk7 = array2794; + const array2795 = buffer.readPacketArray(102); + packet.kkk70 = array2795; + const array2796 = buffer.readPacketArray(102); + packet.kkk71 = array2796; + const array2797 = buffer.readPacketArray(102); + packet.kkk72 = array2797; + const array2798 = buffer.readPacketArray(102); + packet.kkk73 = array2798; + const array2799 = buffer.readPacketArray(102); + packet.kkk74 = array2799; + const array2800 = buffer.readPacketArray(102); + packet.kkk75 = array2800; + const array2801 = buffer.readPacketArray(102); + packet.kkk76 = array2801; + const array2802 = buffer.readPacketArray(102); + packet.kkk77 = array2802; + const array2803 = buffer.readPacketArray(102); + packet.kkk78 = array2803; + const array2804 = buffer.readPacketArray(102); + packet.kkk79 = array2804; + const array2805 = buffer.readPacketArray(102); + packet.kkk8 = array2805; + const array2806 = buffer.readPacketArray(102); + packet.kkk80 = array2806; + const array2807 = buffer.readPacketArray(102); + packet.kkk81 = array2807; + const array2808 = buffer.readPacketArray(102); + packet.kkk82 = array2808; + const array2809 = buffer.readPacketArray(102); + packet.kkk83 = array2809; + const array2810 = buffer.readPacketArray(102); + packet.kkk84 = array2810; + const array2811 = buffer.readPacketArray(102); + packet.kkk85 = array2811; + const array2812 = buffer.readPacketArray(102); + packet.kkk86 = array2812; + const array2813 = buffer.readPacketArray(102); + packet.kkk87 = array2813; + const array2814 = buffer.readPacketArray(102); + packet.kkk88 = array2814; + const array2815 = buffer.readPacketArray(102); + packet.kkk9 = array2815; + const list2816 = buffer.readIntList(); + packet.l1 = list2816; + const list2817 = buffer.readIntList(); + packet.l10 = list2817; + const list2818 = buffer.readIntList(); + packet.l11 = list2818; + const list2819 = buffer.readIntList(); + packet.l12 = list2819; + const list2820 = buffer.readIntList(); + packet.l13 = list2820; + const list2821 = buffer.readIntList(); + packet.l14 = list2821; + const list2822 = buffer.readIntList(); + packet.l15 = list2822; + const list2823 = buffer.readIntList(); + packet.l16 = list2823; + const list2824 = buffer.readIntList(); + packet.l17 = list2824; + const list2825 = buffer.readIntList(); + packet.l18 = list2825; + const list2826 = buffer.readIntList(); + packet.l19 = list2826; + const list2827 = buffer.readIntList(); + packet.l2 = list2827; + const list2828 = buffer.readIntList(); + packet.l20 = list2828; + const list2829 = buffer.readIntList(); + packet.l21 = list2829; + const list2830 = buffer.readIntList(); + packet.l22 = list2830; + const list2831 = buffer.readIntList(); + packet.l23 = list2831; + const list2832 = buffer.readIntList(); + packet.l24 = list2832; + const list2833 = buffer.readIntList(); + packet.l25 = list2833; + const list2834 = buffer.readIntList(); + packet.l26 = list2834; + const list2835 = buffer.readIntList(); + packet.l27 = list2835; + const list2836 = buffer.readIntList(); + packet.l28 = list2836; + const list2837 = buffer.readIntList(); + packet.l29 = list2837; + const list2838 = buffer.readIntList(); + packet.l3 = list2838; + const list2839 = buffer.readIntList(); + packet.l30 = list2839; + const list2840 = buffer.readIntList(); + packet.l31 = list2840; + const list2841 = buffer.readIntList(); + packet.l32 = list2841; + const list2842 = buffer.readIntList(); + packet.l33 = list2842; + const list2843 = buffer.readIntList(); + packet.l34 = list2843; + const list2844 = buffer.readIntList(); + packet.l35 = list2844; + const list2845 = buffer.readIntList(); + packet.l36 = list2845; + const list2846 = buffer.readIntList(); + packet.l37 = list2846; + const list2847 = buffer.readIntList(); + packet.l38 = list2847; + const list2848 = buffer.readIntList(); + packet.l39 = list2848; + const list2849 = buffer.readIntList(); + packet.l4 = list2849; + const list2850 = buffer.readIntList(); + packet.l40 = list2850; + const list2851 = buffer.readIntList(); + packet.l41 = list2851; + const list2852 = buffer.readIntList(); + packet.l42 = list2852; + const list2853 = buffer.readIntList(); + packet.l43 = list2853; + const list2854 = buffer.readIntList(); + packet.l44 = list2854; + const list2855 = buffer.readIntList(); + packet.l45 = list2855; + const list2856 = buffer.readIntList(); + packet.l46 = list2856; + const list2857 = buffer.readIntList(); + packet.l47 = list2857; + const list2858 = buffer.readIntList(); + packet.l48 = list2858; + const list2859 = buffer.readIntList(); + packet.l49 = list2859; + const list2860 = buffer.readIntList(); + packet.l5 = list2860; + const list2861 = buffer.readIntList(); + packet.l50 = list2861; + const list2862 = buffer.readIntList(); + packet.l51 = list2862; + const list2863 = buffer.readIntList(); + packet.l52 = list2863; + const list2864 = buffer.readIntList(); + packet.l53 = list2864; + const list2865 = buffer.readIntList(); + packet.l54 = list2865; + const list2866 = buffer.readIntList(); + packet.l55 = list2866; + const list2867 = buffer.readIntList(); + packet.l56 = list2867; + const list2868 = buffer.readIntList(); + packet.l57 = list2868; + const list2869 = buffer.readIntList(); + packet.l58 = list2869; + const list2870 = buffer.readIntList(); + packet.l59 = list2870; + const list2871 = buffer.readIntList(); + packet.l6 = list2871; + const list2872 = buffer.readIntList(); + packet.l60 = list2872; + const list2873 = buffer.readIntList(); + packet.l61 = list2873; + const list2874 = buffer.readIntList(); + packet.l62 = list2874; + const list2875 = buffer.readIntList(); + packet.l63 = list2875; + const list2876 = buffer.readIntList(); + packet.l64 = list2876; + const list2877 = buffer.readIntList(); + packet.l65 = list2877; + const list2878 = buffer.readIntList(); + packet.l66 = list2878; + const list2879 = buffer.readIntList(); + packet.l67 = list2879; + const list2880 = buffer.readIntList(); + packet.l68 = list2880; + const list2881 = buffer.readIntList(); + packet.l69 = list2881; + const list2882 = buffer.readIntList(); + packet.l7 = list2882; + const list2883 = buffer.readIntList(); + packet.l70 = list2883; + const list2884 = buffer.readIntList(); + packet.l71 = list2884; + const list2885 = buffer.readIntList(); + packet.l72 = list2885; + const list2886 = buffer.readIntList(); + packet.l73 = list2886; + const list2887 = buffer.readIntList(); + packet.l74 = list2887; + const list2888 = buffer.readIntList(); + packet.l75 = list2888; + const list2889 = buffer.readIntList(); + packet.l76 = list2889; + const list2890 = buffer.readIntList(); + packet.l77 = list2890; + const list2891 = buffer.readIntList(); + packet.l78 = list2891; + const list2892 = buffer.readIntList(); + packet.l79 = list2892; + const list2893 = buffer.readIntList(); + packet.l8 = list2893; + const list2894 = buffer.readIntList(); + packet.l80 = list2894; + const list2895 = buffer.readIntList(); + packet.l81 = list2895; + const list2896 = buffer.readIntList(); + packet.l82 = list2896; + const list2897 = buffer.readIntList(); + packet.l83 = list2897; + const list2898 = buffer.readIntList(); + packet.l84 = list2898; + const list2899 = buffer.readIntList(); + packet.l85 = list2899; + const list2900 = buffer.readIntList(); + packet.l86 = list2900; + const list2901 = buffer.readIntList(); + packet.l87 = list2901; + const list2902 = buffer.readIntList(); + packet.l88 = list2902; + const list2903 = buffer.readIntList(); + packet.l9 = list2903; + const list2904 = buffer.readStringList(); + packet.llll1 = list2904; + const list2905 = buffer.readStringList(); + packet.llll10 = list2905; + const list2906 = buffer.readStringList(); + packet.llll11 = list2906; + const list2907 = buffer.readStringList(); + packet.llll12 = list2907; + const list2908 = buffer.readStringList(); + packet.llll13 = list2908; + const list2909 = buffer.readStringList(); + packet.llll14 = list2909; + const list2910 = buffer.readStringList(); + packet.llll15 = list2910; + const list2911 = buffer.readStringList(); + packet.llll16 = list2911; + const list2912 = buffer.readStringList(); + packet.llll17 = list2912; + const list2913 = buffer.readStringList(); + packet.llll18 = list2913; + const list2914 = buffer.readStringList(); + packet.llll19 = list2914; + const list2915 = buffer.readStringList(); + packet.llll2 = list2915; + const list2916 = buffer.readStringList(); + packet.llll20 = list2916; + const list2917 = buffer.readStringList(); + packet.llll21 = list2917; + const list2918 = buffer.readStringList(); + packet.llll22 = list2918; + const list2919 = buffer.readStringList(); + packet.llll23 = list2919; + const list2920 = buffer.readStringList(); + packet.llll24 = list2920; + const list2921 = buffer.readStringList(); + packet.llll25 = list2921; + const list2922 = buffer.readStringList(); + packet.llll26 = list2922; + const list2923 = buffer.readStringList(); + packet.llll27 = list2923; + const list2924 = buffer.readStringList(); + packet.llll28 = list2924; + const list2925 = buffer.readStringList(); + packet.llll29 = list2925; + const list2926 = buffer.readStringList(); + packet.llll3 = list2926; + const list2927 = buffer.readStringList(); + packet.llll30 = list2927; + const list2928 = buffer.readStringList(); + packet.llll31 = list2928; + const list2929 = buffer.readStringList(); + packet.llll32 = list2929; + const list2930 = buffer.readStringList(); + packet.llll33 = list2930; + const list2931 = buffer.readStringList(); + packet.llll34 = list2931; + const list2932 = buffer.readStringList(); + packet.llll35 = list2932; + const list2933 = buffer.readStringList(); + packet.llll36 = list2933; + const list2934 = buffer.readStringList(); + packet.llll37 = list2934; + const list2935 = buffer.readStringList(); + packet.llll38 = list2935; + const list2936 = buffer.readStringList(); + packet.llll39 = list2936; + const list2937 = buffer.readStringList(); + packet.llll4 = list2937; + const list2938 = buffer.readStringList(); + packet.llll40 = list2938; + const list2939 = buffer.readStringList(); + packet.llll41 = list2939; + const list2940 = buffer.readStringList(); + packet.llll42 = list2940; + const list2941 = buffer.readStringList(); + packet.llll43 = list2941; + const list2942 = buffer.readStringList(); + packet.llll44 = list2942; + const list2943 = buffer.readStringList(); + packet.llll45 = list2943; + const list2944 = buffer.readStringList(); + packet.llll46 = list2944; + const list2945 = buffer.readStringList(); + packet.llll47 = list2945; + const list2946 = buffer.readStringList(); + packet.llll48 = list2946; + const list2947 = buffer.readStringList(); + packet.llll49 = list2947; + const list2948 = buffer.readStringList(); + packet.llll5 = list2948; + const list2949 = buffer.readStringList(); + packet.llll50 = list2949; + const list2950 = buffer.readStringList(); + packet.llll51 = list2950; + const list2951 = buffer.readStringList(); + packet.llll52 = list2951; + const list2952 = buffer.readStringList(); + packet.llll53 = list2952; + const list2953 = buffer.readStringList(); + packet.llll54 = list2953; + const list2954 = buffer.readStringList(); + packet.llll55 = list2954; + const list2955 = buffer.readStringList(); + packet.llll56 = list2955; + const list2956 = buffer.readStringList(); + packet.llll57 = list2956; + const list2957 = buffer.readStringList(); + packet.llll58 = list2957; + const list2958 = buffer.readStringList(); + packet.llll59 = list2958; + const list2959 = buffer.readStringList(); + packet.llll6 = list2959; + const list2960 = buffer.readStringList(); + packet.llll60 = list2960; + const list2961 = buffer.readStringList(); + packet.llll61 = list2961; + const list2962 = buffer.readStringList(); + packet.llll62 = list2962; + const list2963 = buffer.readStringList(); + packet.llll63 = list2963; + const list2964 = buffer.readStringList(); + packet.llll64 = list2964; + const list2965 = buffer.readStringList(); + packet.llll65 = list2965; + const list2966 = buffer.readStringList(); + packet.llll66 = list2966; + const list2967 = buffer.readStringList(); + packet.llll67 = list2967; + const list2968 = buffer.readStringList(); + packet.llll68 = list2968; + const list2969 = buffer.readStringList(); + packet.llll69 = list2969; + const list2970 = buffer.readStringList(); + packet.llll7 = list2970; + const list2971 = buffer.readStringList(); + packet.llll70 = list2971; + const list2972 = buffer.readStringList(); + packet.llll71 = list2972; + const list2973 = buffer.readStringList(); + packet.llll72 = list2973; + const list2974 = buffer.readStringList(); + packet.llll73 = list2974; + const list2975 = buffer.readStringList(); + packet.llll74 = list2975; + const list2976 = buffer.readStringList(); + packet.llll75 = list2976; + const list2977 = buffer.readStringList(); + packet.llll76 = list2977; + const list2978 = buffer.readStringList(); + packet.llll77 = list2978; + const list2979 = buffer.readStringList(); + packet.llll78 = list2979; + const list2980 = buffer.readStringList(); + packet.llll79 = list2980; + const list2981 = buffer.readStringList(); + packet.llll8 = list2981; + const list2982 = buffer.readStringList(); + packet.llll80 = list2982; + const list2983 = buffer.readStringList(); + packet.llll81 = list2983; + const list2984 = buffer.readStringList(); + packet.llll82 = list2984; + const list2985 = buffer.readStringList(); + packet.llll83 = list2985; + const list2986 = buffer.readStringList(); + packet.llll84 = list2986; + const list2987 = buffer.readStringList(); + packet.llll85 = list2987; + const list2988 = buffer.readStringList(); + packet.llll86 = list2988; + const list2989 = buffer.readStringList(); + packet.llll87 = list2989; + const list2990 = buffer.readStringList(); + packet.llll88 = list2990; + const list2991 = buffer.readStringList(); + packet.llll9 = list2991; + const map2992 = buffer.readIntStringMap(); + packet.m1 = map2992; + const map2993 = buffer.readIntStringMap(); + packet.m10 = map2993; + const map2994 = buffer.readIntStringMap(); + packet.m11 = map2994; + const map2995 = buffer.readIntStringMap(); + packet.m12 = map2995; + const map2996 = buffer.readIntStringMap(); + packet.m13 = map2996; + const map2997 = buffer.readIntStringMap(); + packet.m14 = map2997; + const map2998 = buffer.readIntStringMap(); + packet.m15 = map2998; + const map2999 = buffer.readIntStringMap(); + packet.m16 = map2999; + const map3000 = buffer.readIntStringMap(); + packet.m17 = map3000; + const map3001 = buffer.readIntStringMap(); + packet.m18 = map3001; + const map3002 = buffer.readIntStringMap(); + packet.m19 = map3002; + const map3003 = buffer.readIntStringMap(); + packet.m2 = map3003; + const map3004 = buffer.readIntStringMap(); + packet.m20 = map3004; + const map3005 = buffer.readIntStringMap(); + packet.m21 = map3005; + const map3006 = buffer.readIntStringMap(); + packet.m22 = map3006; + const map3007 = buffer.readIntStringMap(); + packet.m23 = map3007; + const map3008 = buffer.readIntStringMap(); + packet.m24 = map3008; + const map3009 = buffer.readIntStringMap(); + packet.m25 = map3009; + const map3010 = buffer.readIntStringMap(); + packet.m26 = map3010; + const map3011 = buffer.readIntStringMap(); + packet.m27 = map3011; + const map3012 = buffer.readIntStringMap(); + packet.m28 = map3012; + const map3013 = buffer.readIntStringMap(); + packet.m29 = map3013; + const map3014 = buffer.readIntStringMap(); + packet.m3 = map3014; + const map3015 = buffer.readIntStringMap(); + packet.m30 = map3015; + const map3016 = buffer.readIntStringMap(); + packet.m31 = map3016; + const map3017 = buffer.readIntStringMap(); + packet.m32 = map3017; + const map3018 = buffer.readIntStringMap(); + packet.m33 = map3018; + const map3019 = buffer.readIntStringMap(); + packet.m34 = map3019; + const map3020 = buffer.readIntStringMap(); + packet.m35 = map3020; + const map3021 = buffer.readIntStringMap(); + packet.m36 = map3021; + const map3022 = buffer.readIntStringMap(); + packet.m37 = map3022; + const map3023 = buffer.readIntStringMap(); + packet.m38 = map3023; + const map3024 = buffer.readIntStringMap(); + packet.m39 = map3024; + const map3025 = buffer.readIntStringMap(); + packet.m4 = map3025; + const map3026 = buffer.readIntStringMap(); + packet.m40 = map3026; + const map3027 = buffer.readIntStringMap(); + packet.m41 = map3027; + const map3028 = buffer.readIntStringMap(); + packet.m42 = map3028; + const map3029 = buffer.readIntStringMap(); + packet.m43 = map3029; + const map3030 = buffer.readIntStringMap(); + packet.m44 = map3030; + const map3031 = buffer.readIntStringMap(); + packet.m45 = map3031; + const map3032 = buffer.readIntStringMap(); + packet.m46 = map3032; + const map3033 = buffer.readIntStringMap(); + packet.m47 = map3033; + const map3034 = buffer.readIntStringMap(); + packet.m48 = map3034; + const map3035 = buffer.readIntStringMap(); + packet.m49 = map3035; + const map3036 = buffer.readIntStringMap(); + packet.m5 = map3036; + const map3037 = buffer.readIntStringMap(); + packet.m50 = map3037; + const map3038 = buffer.readIntStringMap(); + packet.m51 = map3038; + const map3039 = buffer.readIntStringMap(); + packet.m52 = map3039; + const map3040 = buffer.readIntStringMap(); + packet.m53 = map3040; + const map3041 = buffer.readIntStringMap(); + packet.m54 = map3041; + const map3042 = buffer.readIntStringMap(); + packet.m55 = map3042; + const map3043 = buffer.readIntStringMap(); + packet.m56 = map3043; + const map3044 = buffer.readIntStringMap(); + packet.m57 = map3044; + const map3045 = buffer.readIntStringMap(); + packet.m58 = map3045; + const map3046 = buffer.readIntStringMap(); + packet.m59 = map3046; + const map3047 = buffer.readIntStringMap(); + packet.m6 = map3047; + const map3048 = buffer.readIntStringMap(); + packet.m60 = map3048; + const map3049 = buffer.readIntStringMap(); + packet.m61 = map3049; + const map3050 = buffer.readIntStringMap(); + packet.m62 = map3050; + const map3051 = buffer.readIntStringMap(); + packet.m63 = map3051; + const map3052 = buffer.readIntStringMap(); + packet.m64 = map3052; + const map3053 = buffer.readIntStringMap(); + packet.m65 = map3053; + const map3054 = buffer.readIntStringMap(); + packet.m66 = map3054; + const map3055 = buffer.readIntStringMap(); + packet.m67 = map3055; + const map3056 = buffer.readIntStringMap(); + packet.m68 = map3056; + const map3057 = buffer.readIntStringMap(); + packet.m69 = map3057; + const map3058 = buffer.readIntStringMap(); + packet.m7 = map3058; + const map3059 = buffer.readIntStringMap(); + packet.m70 = map3059; + const map3060 = buffer.readIntStringMap(); + packet.m71 = map3060; + const map3061 = buffer.readIntStringMap(); + packet.m72 = map3061; + const map3062 = buffer.readIntStringMap(); + packet.m73 = map3062; + const map3063 = buffer.readIntStringMap(); + packet.m74 = map3063; + const map3064 = buffer.readIntStringMap(); + packet.m75 = map3064; + const map3065 = buffer.readIntStringMap(); + packet.m76 = map3065; + const map3066 = buffer.readIntStringMap(); + packet.m77 = map3066; + const map3067 = buffer.readIntStringMap(); + packet.m78 = map3067; + const map3068 = buffer.readIntStringMap(); + packet.m79 = map3068; + const map3069 = buffer.readIntStringMap(); + packet.m8 = map3069; + const map3070 = buffer.readIntStringMap(); + packet.m80 = map3070; + const map3071 = buffer.readIntStringMap(); + packet.m81 = map3071; + const map3072 = buffer.readIntStringMap(); + packet.m82 = map3072; + const map3073 = buffer.readIntStringMap(); + packet.m83 = map3073; + const map3074 = buffer.readIntStringMap(); + packet.m84 = map3074; + const map3075 = buffer.readIntStringMap(); + packet.m85 = map3075; + const map3076 = buffer.readIntStringMap(); + packet.m86 = map3076; + const map3077 = buffer.readIntStringMap(); + packet.m87 = map3077; + const map3078 = buffer.readIntStringMap(); + packet.m88 = map3078; + const map3079 = buffer.readIntStringMap(); + packet.m9 = map3079; + const map3080 = buffer.readIntPacketMap(102); + packet.mm1 = map3080; + const map3081 = buffer.readIntPacketMap(102); + packet.mm10 = map3081; + const map3082 = buffer.readIntPacketMap(102); + packet.mm11 = map3082; + const map3083 = buffer.readIntPacketMap(102); + packet.mm12 = map3083; + const map3084 = buffer.readIntPacketMap(102); + packet.mm13 = map3084; + const map3085 = buffer.readIntPacketMap(102); + packet.mm14 = map3085; + const map3086 = buffer.readIntPacketMap(102); + packet.mm15 = map3086; + const map3087 = buffer.readIntPacketMap(102); + packet.mm16 = map3087; + const map3088 = buffer.readIntPacketMap(102); + packet.mm17 = map3088; + const map3089 = buffer.readIntPacketMap(102); + packet.mm18 = map3089; + const map3090 = buffer.readIntPacketMap(102); + packet.mm19 = map3090; + const map3091 = buffer.readIntPacketMap(102); + packet.mm2 = map3091; + const map3092 = buffer.readIntPacketMap(102); + packet.mm20 = map3092; + const map3093 = buffer.readIntPacketMap(102); + packet.mm21 = map3093; + const map3094 = buffer.readIntPacketMap(102); + packet.mm22 = map3094; + const map3095 = buffer.readIntPacketMap(102); + packet.mm23 = map3095; + const map3096 = buffer.readIntPacketMap(102); + packet.mm24 = map3096; + const map3097 = buffer.readIntPacketMap(102); + packet.mm25 = map3097; + const map3098 = buffer.readIntPacketMap(102); + packet.mm26 = map3098; + const map3099 = buffer.readIntPacketMap(102); + packet.mm27 = map3099; + const map3100 = buffer.readIntPacketMap(102); + packet.mm28 = map3100; + const map3101 = buffer.readIntPacketMap(102); + packet.mm29 = map3101; + const map3102 = buffer.readIntPacketMap(102); + packet.mm3 = map3102; + const map3103 = buffer.readIntPacketMap(102); + packet.mm30 = map3103; + const map3104 = buffer.readIntPacketMap(102); + packet.mm31 = map3104; + const map3105 = buffer.readIntPacketMap(102); + packet.mm32 = map3105; + const map3106 = buffer.readIntPacketMap(102); + packet.mm33 = map3106; + const map3107 = buffer.readIntPacketMap(102); + packet.mm34 = map3107; + const map3108 = buffer.readIntPacketMap(102); + packet.mm35 = map3108; + const map3109 = buffer.readIntPacketMap(102); + packet.mm36 = map3109; + const map3110 = buffer.readIntPacketMap(102); + packet.mm37 = map3110; + const map3111 = buffer.readIntPacketMap(102); + packet.mm38 = map3111; + const map3112 = buffer.readIntPacketMap(102); + packet.mm39 = map3112; + const map3113 = buffer.readIntPacketMap(102); + packet.mm4 = map3113; + const map3114 = buffer.readIntPacketMap(102); + packet.mm40 = map3114; + const map3115 = buffer.readIntPacketMap(102); + packet.mm41 = map3115; + const map3116 = buffer.readIntPacketMap(102); + packet.mm42 = map3116; + const map3117 = buffer.readIntPacketMap(102); + packet.mm43 = map3117; + const map3118 = buffer.readIntPacketMap(102); + packet.mm44 = map3118; + const map3119 = buffer.readIntPacketMap(102); + packet.mm45 = map3119; + const map3120 = buffer.readIntPacketMap(102); + packet.mm46 = map3120; + const map3121 = buffer.readIntPacketMap(102); + packet.mm47 = map3121; + const map3122 = buffer.readIntPacketMap(102); + packet.mm48 = map3122; + const map3123 = buffer.readIntPacketMap(102); + packet.mm49 = map3123; + const map3124 = buffer.readIntPacketMap(102); + packet.mm5 = map3124; + const map3125 = buffer.readIntPacketMap(102); + packet.mm50 = map3125; + const map3126 = buffer.readIntPacketMap(102); + packet.mm51 = map3126; + const map3127 = buffer.readIntPacketMap(102); + packet.mm52 = map3127; + const map3128 = buffer.readIntPacketMap(102); + packet.mm53 = map3128; + const map3129 = buffer.readIntPacketMap(102); + packet.mm54 = map3129; + const map3130 = buffer.readIntPacketMap(102); + packet.mm55 = map3130; + const map3131 = buffer.readIntPacketMap(102); + packet.mm56 = map3131; + const map3132 = buffer.readIntPacketMap(102); + packet.mm57 = map3132; + const map3133 = buffer.readIntPacketMap(102); + packet.mm58 = map3133; + const map3134 = buffer.readIntPacketMap(102); + packet.mm59 = map3134; + const map3135 = buffer.readIntPacketMap(102); + packet.mm6 = map3135; + const map3136 = buffer.readIntPacketMap(102); + packet.mm60 = map3136; + const map3137 = buffer.readIntPacketMap(102); + packet.mm61 = map3137; + const map3138 = buffer.readIntPacketMap(102); + packet.mm62 = map3138; + const map3139 = buffer.readIntPacketMap(102); + packet.mm63 = map3139; + const map3140 = buffer.readIntPacketMap(102); + packet.mm64 = map3140; + const map3141 = buffer.readIntPacketMap(102); + packet.mm65 = map3141; + const map3142 = buffer.readIntPacketMap(102); + packet.mm66 = map3142; + const map3143 = buffer.readIntPacketMap(102); + packet.mm67 = map3143; + const map3144 = buffer.readIntPacketMap(102); + packet.mm68 = map3144; + const map3145 = buffer.readIntPacketMap(102); + packet.mm69 = map3145; + const map3146 = buffer.readIntPacketMap(102); + packet.mm7 = map3146; + const map3147 = buffer.readIntPacketMap(102); + packet.mm70 = map3147; + const map3148 = buffer.readIntPacketMap(102); + packet.mm71 = map3148; + const map3149 = buffer.readIntPacketMap(102); + packet.mm72 = map3149; + const map3150 = buffer.readIntPacketMap(102); + packet.mm73 = map3150; + const map3151 = buffer.readIntPacketMap(102); + packet.mm74 = map3151; + const map3152 = buffer.readIntPacketMap(102); + packet.mm75 = map3152; + const map3153 = buffer.readIntPacketMap(102); + packet.mm76 = map3153; + const map3154 = buffer.readIntPacketMap(102); + packet.mm77 = map3154; + const map3155 = buffer.readIntPacketMap(102); + packet.mm78 = map3155; + const map3156 = buffer.readIntPacketMap(102); + packet.mm79 = map3156; + const map3157 = buffer.readIntPacketMap(102); + packet.mm8 = map3157; + const map3158 = buffer.readIntPacketMap(102); + packet.mm80 = map3158; + const map3159 = buffer.readIntPacketMap(102); + packet.mm81 = map3159; + const map3160 = buffer.readIntPacketMap(102); + packet.mm82 = map3160; + const map3161 = buffer.readIntPacketMap(102); + packet.mm83 = map3161; + const map3162 = buffer.readIntPacketMap(102); + packet.mm84 = map3162; + const map3163 = buffer.readIntPacketMap(102); + packet.mm85 = map3163; + const map3164 = buffer.readIntPacketMap(102); + packet.mm86 = map3164; + const map3165 = buffer.readIntPacketMap(102); + packet.mm87 = map3165; + const map3166 = buffer.readIntPacketMap(102); + packet.mm88 = map3166; + const map3167 = buffer.readIntPacketMap(102); + packet.mm9 = map3167; + const set3168 = buffer.readIntSet(); + packet.s1 = set3168; + const set3169 = buffer.readIntSet(); + packet.s10 = set3169; + const set3170 = buffer.readIntSet(); + packet.s11 = set3170; + const set3171 = buffer.readIntSet(); + packet.s12 = set3171; + const set3172 = buffer.readIntSet(); + packet.s13 = set3172; + const set3173 = buffer.readIntSet(); + packet.s14 = set3173; + const set3174 = buffer.readIntSet(); + packet.s15 = set3174; + const set3175 = buffer.readIntSet(); + packet.s16 = set3175; + const set3176 = buffer.readIntSet(); + packet.s17 = set3176; + const set3177 = buffer.readIntSet(); + packet.s18 = set3177; + const set3178 = buffer.readIntSet(); + packet.s19 = set3178; + const set3179 = buffer.readIntSet(); + packet.s2 = set3179; + const set3180 = buffer.readIntSet(); + packet.s20 = set3180; + const set3181 = buffer.readIntSet(); + packet.s21 = set3181; + const set3182 = buffer.readIntSet(); + packet.s22 = set3182; + const set3183 = buffer.readIntSet(); + packet.s23 = set3183; + const set3184 = buffer.readIntSet(); + packet.s24 = set3184; + const set3185 = buffer.readIntSet(); + packet.s25 = set3185; + const set3186 = buffer.readIntSet(); + packet.s26 = set3186; + const set3187 = buffer.readIntSet(); + packet.s27 = set3187; + const set3188 = buffer.readIntSet(); + packet.s28 = set3188; + const set3189 = buffer.readIntSet(); + packet.s29 = set3189; + const set3190 = buffer.readIntSet(); + packet.s3 = set3190; + const set3191 = buffer.readIntSet(); + packet.s30 = set3191; + const set3192 = buffer.readIntSet(); + packet.s31 = set3192; + const set3193 = buffer.readIntSet(); + packet.s32 = set3193; + const set3194 = buffer.readIntSet(); + packet.s33 = set3194; + const set3195 = buffer.readIntSet(); + packet.s34 = set3195; + const set3196 = buffer.readIntSet(); + packet.s35 = set3196; + const set3197 = buffer.readIntSet(); + packet.s36 = set3197; + const set3198 = buffer.readIntSet(); + packet.s37 = set3198; + const set3199 = buffer.readIntSet(); + packet.s38 = set3199; + const set3200 = buffer.readIntSet(); + packet.s39 = set3200; + const set3201 = buffer.readIntSet(); + packet.s4 = set3201; + const set3202 = buffer.readIntSet(); + packet.s40 = set3202; + const set3203 = buffer.readIntSet(); + packet.s41 = set3203; + const set3204 = buffer.readIntSet(); + packet.s42 = set3204; + const set3205 = buffer.readIntSet(); + packet.s43 = set3205; + const set3206 = buffer.readIntSet(); + packet.s44 = set3206; + const set3207 = buffer.readIntSet(); + packet.s45 = set3207; + const set3208 = buffer.readIntSet(); + packet.s46 = set3208; + const set3209 = buffer.readIntSet(); + packet.s47 = set3209; + const set3210 = buffer.readIntSet(); + packet.s48 = set3210; + const set3211 = buffer.readIntSet(); + packet.s49 = set3211; + const set3212 = buffer.readIntSet(); + packet.s5 = set3212; + const set3213 = buffer.readIntSet(); + packet.s50 = set3213; + const set3214 = buffer.readIntSet(); + packet.s51 = set3214; + const set3215 = buffer.readIntSet(); + packet.s52 = set3215; + const set3216 = buffer.readIntSet(); + packet.s53 = set3216; + const set3217 = buffer.readIntSet(); + packet.s54 = set3217; + const set3218 = buffer.readIntSet(); + packet.s55 = set3218; + const set3219 = buffer.readIntSet(); + packet.s56 = set3219; + const set3220 = buffer.readIntSet(); + packet.s57 = set3220; + const set3221 = buffer.readIntSet(); + packet.s58 = set3221; + const set3222 = buffer.readIntSet(); + packet.s59 = set3222; + const set3223 = buffer.readIntSet(); + packet.s6 = set3223; + const set3224 = buffer.readIntSet(); + packet.s60 = set3224; + const set3225 = buffer.readIntSet(); + packet.s61 = set3225; + const set3226 = buffer.readIntSet(); + packet.s62 = set3226; + const set3227 = buffer.readIntSet(); + packet.s63 = set3227; + const set3228 = buffer.readIntSet(); + packet.s64 = set3228; + const set3229 = buffer.readIntSet(); + packet.s65 = set3229; + const set3230 = buffer.readIntSet(); + packet.s66 = set3230; + const set3231 = buffer.readIntSet(); + packet.s67 = set3231; + const set3232 = buffer.readIntSet(); + packet.s68 = set3232; + const set3233 = buffer.readIntSet(); + packet.s69 = set3233; + const set3234 = buffer.readIntSet(); + packet.s7 = set3234; + const set3235 = buffer.readIntSet(); + packet.s70 = set3235; + const set3236 = buffer.readIntSet(); + packet.s71 = set3236; + const set3237 = buffer.readIntSet(); + packet.s72 = set3237; + const set3238 = buffer.readIntSet(); + packet.s73 = set3238; + const set3239 = buffer.readIntSet(); + packet.s74 = set3239; + const set3240 = buffer.readIntSet(); + packet.s75 = set3240; + const set3241 = buffer.readIntSet(); + packet.s76 = set3241; + const set3242 = buffer.readIntSet(); + packet.s77 = set3242; + const set3243 = buffer.readIntSet(); + packet.s78 = set3243; + const set3244 = buffer.readIntSet(); + packet.s79 = set3244; + const set3245 = buffer.readIntSet(); + packet.s8 = set3245; + const set3246 = buffer.readIntSet(); + packet.s80 = set3246; + const set3247 = buffer.readIntSet(); + packet.s81 = set3247; + const set3248 = buffer.readIntSet(); + packet.s82 = set3248; + const set3249 = buffer.readIntSet(); + packet.s83 = set3249; + const set3250 = buffer.readIntSet(); + packet.s84 = set3250; + const set3251 = buffer.readIntSet(); + packet.s85 = set3251; + const set3252 = buffer.readIntSet(); + packet.s86 = set3252; + const set3253 = buffer.readIntSet(); + packet.s87 = set3253; + const set3254 = buffer.readIntSet(); + packet.s88 = set3254; + const set3255 = buffer.readIntSet(); + packet.s9 = set3255; + const set3256 = buffer.readStringSet(); + packet.ssss1 = set3256; + const set3257 = buffer.readStringSet(); + packet.ssss10 = set3257; + const set3258 = buffer.readStringSet(); + packet.ssss11 = set3258; + const set3259 = buffer.readStringSet(); + packet.ssss12 = set3259; + const set3260 = buffer.readStringSet(); + packet.ssss13 = set3260; + const set3261 = buffer.readStringSet(); + packet.ssss14 = set3261; + const set3262 = buffer.readStringSet(); + packet.ssss15 = set3262; + const set3263 = buffer.readStringSet(); + packet.ssss16 = set3263; + const set3264 = buffer.readStringSet(); + packet.ssss17 = set3264; + const set3265 = buffer.readStringSet(); + packet.ssss18 = set3265; + const set3266 = buffer.readStringSet(); + packet.ssss19 = set3266; + const set3267 = buffer.readStringSet(); + packet.ssss2 = set3267; + const set3268 = buffer.readStringSet(); + packet.ssss20 = set3268; + const set3269 = buffer.readStringSet(); + packet.ssss21 = set3269; + const set3270 = buffer.readStringSet(); + packet.ssss22 = set3270; + const set3271 = buffer.readStringSet(); + packet.ssss23 = set3271; + const set3272 = buffer.readStringSet(); + packet.ssss24 = set3272; + const set3273 = buffer.readStringSet(); + packet.ssss25 = set3273; + const set3274 = buffer.readStringSet(); + packet.ssss26 = set3274; + const set3275 = buffer.readStringSet(); + packet.ssss27 = set3275; + const set3276 = buffer.readStringSet(); + packet.ssss28 = set3276; + const set3277 = buffer.readStringSet(); + packet.ssss29 = set3277; + const set3278 = buffer.readStringSet(); + packet.ssss3 = set3278; + const set3279 = buffer.readStringSet(); + packet.ssss30 = set3279; + const set3280 = buffer.readStringSet(); + packet.ssss31 = set3280; + const set3281 = buffer.readStringSet(); + packet.ssss32 = set3281; + const set3282 = buffer.readStringSet(); + packet.ssss33 = set3282; + const set3283 = buffer.readStringSet(); + packet.ssss34 = set3283; + const set3284 = buffer.readStringSet(); + packet.ssss35 = set3284; + const set3285 = buffer.readStringSet(); + packet.ssss36 = set3285; + const set3286 = buffer.readStringSet(); + packet.ssss37 = set3286; + const set3287 = buffer.readStringSet(); + packet.ssss38 = set3287; + const set3288 = buffer.readStringSet(); + packet.ssss39 = set3288; + const set3289 = buffer.readStringSet(); + packet.ssss4 = set3289; + const set3290 = buffer.readStringSet(); + packet.ssss40 = set3290; + const set3291 = buffer.readStringSet(); + packet.ssss41 = set3291; + const set3292 = buffer.readStringSet(); + packet.ssss42 = set3292; + const set3293 = buffer.readStringSet(); + packet.ssss43 = set3293; + const set3294 = buffer.readStringSet(); + packet.ssss44 = set3294; + const set3295 = buffer.readStringSet(); + packet.ssss45 = set3295; + const set3296 = buffer.readStringSet(); + packet.ssss46 = set3296; + const set3297 = buffer.readStringSet(); + packet.ssss47 = set3297; + const set3298 = buffer.readStringSet(); + packet.ssss48 = set3298; + const set3299 = buffer.readStringSet(); + packet.ssss49 = set3299; + const set3300 = buffer.readStringSet(); + packet.ssss5 = set3300; + const set3301 = buffer.readStringSet(); + packet.ssss50 = set3301; + const set3302 = buffer.readStringSet(); + packet.ssss51 = set3302; + const set3303 = buffer.readStringSet(); + packet.ssss52 = set3303; + const set3304 = buffer.readStringSet(); + packet.ssss53 = set3304; + const set3305 = buffer.readStringSet(); + packet.ssss54 = set3305; + const set3306 = buffer.readStringSet(); + packet.ssss55 = set3306; + const set3307 = buffer.readStringSet(); + packet.ssss56 = set3307; + const set3308 = buffer.readStringSet(); + packet.ssss57 = set3308; + const set3309 = buffer.readStringSet(); + packet.ssss58 = set3309; + const set3310 = buffer.readStringSet(); + packet.ssss59 = set3310; + const set3311 = buffer.readStringSet(); + packet.ssss6 = set3311; + const set3312 = buffer.readStringSet(); + packet.ssss60 = set3312; + const set3313 = buffer.readStringSet(); + packet.ssss61 = set3313; + const set3314 = buffer.readStringSet(); + packet.ssss62 = set3314; + const set3315 = buffer.readStringSet(); + packet.ssss63 = set3315; + const set3316 = buffer.readStringSet(); + packet.ssss64 = set3316; + const set3317 = buffer.readStringSet(); + packet.ssss65 = set3317; + const set3318 = buffer.readStringSet(); + packet.ssss66 = set3318; + const set3319 = buffer.readStringSet(); + packet.ssss67 = set3319; + const set3320 = buffer.readStringSet(); + packet.ssss68 = set3320; + const set3321 = buffer.readStringSet(); + packet.ssss69 = set3321; + const set3322 = buffer.readStringSet(); + packet.ssss7 = set3322; + const set3323 = buffer.readStringSet(); + packet.ssss70 = set3323; + const set3324 = buffer.readStringSet(); + packet.ssss71 = set3324; + const set3325 = buffer.readStringSet(); + packet.ssss72 = set3325; + const set3326 = buffer.readStringSet(); + packet.ssss73 = set3326; + const set3327 = buffer.readStringSet(); + packet.ssss74 = set3327; + const set3328 = buffer.readStringSet(); + packet.ssss75 = set3328; + const set3329 = buffer.readStringSet(); + packet.ssss76 = set3329; + const set3330 = buffer.readStringSet(); + packet.ssss77 = set3330; + const set3331 = buffer.readStringSet(); + packet.ssss78 = set3331; + const set3332 = buffer.readStringSet(); + packet.ssss79 = set3332; + const set3333 = buffer.readStringSet(); + packet.ssss8 = set3333; + const set3334 = buffer.readStringSet(); + packet.ssss80 = set3334; + const set3335 = buffer.readStringSet(); + packet.ssss81 = set3335; + const set3336 = buffer.readStringSet(); + packet.ssss82 = set3336; + const set3337 = buffer.readStringSet(); + packet.ssss83 = set3337; + const set3338 = buffer.readStringSet(); + packet.ssss84 = set3338; + const set3339 = buffer.readStringSet(); + packet.ssss85 = set3339; + const set3340 = buffer.readStringSet(); + packet.ssss86 = set3340; + const set3341 = buffer.readStringSet(); + packet.ssss87 = set3341; + const set3342 = buffer.readStringSet(); + packet.ssss88 = set3342; + const set3343 = buffer.readStringSet(); + packet.ssss9 = set3343; + if (length > 0) { + buffer.setReadOffset(readIndex + length); + } + return packet; + } +} + +export default VeryBigObject;