diff options
Diffstat (limited to 'vere/ext/nasm/asm')
41 files changed, 44087 insertions, 0 deletions
diff --git a/vere/ext/nasm/asm/assemble.c b/vere/ext/nasm/asm/assemble.c new file mode 100644 index 0000000..7eab5ce --- /dev/null +++ b/vere/ext/nasm/asm/assemble.c @@ -0,0 +1,3411 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2022 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * assemble.c code generation for the Netwide Assembler + * + * Bytecode specification + * ---------------------- + * + * + * Codes Mnemonic Explanation + * + * \0 terminates the code. (Unless it's a literal of course.) + * \1..\4 that many literal bytes follow in the code stream + * \5 add 4 to the primary operand number (b, low octdigit) + * \6 add 4 to the secondary operand number (a, middle octdigit) + * \7 add 4 to both the primary and the secondary operand number + * \10..\13 a literal byte follows in the code stream, to be added + * to the register value of operand 0..3 + * \14..\17 the position of index register operand in MIB (BND insns) + * \20..\23 ib a byte immediate operand, from operand 0..3 + * \24..\27 ib,u a zero-extended byte immediate operand, from operand 0..3 + * \30..\33 iw a word immediate operand, from operand 0..3 + * \34..\37 iwd select between \3[0-3] and \4[0-3] depending on 16/32 bit + * assembly mode or the operand-size override on the operand + * \40..\43 id a long immediate operand, from operand 0..3 + * \44..\47 iwdq select between \3[0-3], \4[0-3] and \5[4-7] + * depending on the address size of the instruction. + * \50..\53 rel8 a byte relative operand, from operand 0..3 + * \54..\57 iq a qword immediate operand, from operand 0..3 + * \60..\63 rel16 a word relative operand, from operand 0..3 + * \64..\67 rel select between \6[0-3] and \7[0-3] depending on 16/32 bit + * assembly mode or the operand-size override on the operand + * \70..\73 rel32 a long relative operand, from operand 0..3 + * \74..\77 seg a word constant, from the _segment_ part of operand 0..3 + * \1ab /r a ModRM, calculated on EA in operand a, with the reg + * field the register value of operand b. + * \171\mab /mrb (e.g /3r0) a ModRM, with the reg field taken from operand a, and the m + * and b fields set to the specified values. + * \172\ab /is4 the register number from operand a in bits 7..4, with + * the 4-bit immediate from operand b in bits 3..0. + * \173\xab the register number from operand a in bits 7..4, with + * the value b in bits 3..0. + * \174..\177 the register number from operand 0..3 in bits 7..4, and + * an arbitrary value in bits 3..0 (assembled as zero.) + * \2ab /b a ModRM, calculated on EA in operand a, with the reg + * field equal to digit b. + * \240..\243 this instruction uses EVEX rather than REX or VEX/XOP, with the + * V field taken from operand 0..3. + * \250 this instruction uses EVEX rather than REX or VEX/XOP, with the + * V field set to 1111b. + * + * EVEX prefixes are followed by the sequence: + * \cm\wlp\tup where cm is: + * cc 00m mmm + * c = 2 for EVEX and mmmm is the M field (EVEX.P0[3:0]) + * and wlp is: + * 00 wwl lpp + * [l0] ll = 0 (.128, .lz) + * [l1] ll = 1 (.256) + * [l2] ll = 2 (.512) + * [lig] ll = 3 for EVEX.L'L don't care (always assembled as 0) + * + * [w0] ww = 0 for W = 0 + * [w1] ww = 1 for W = 1 + * [wig] ww = 2 for W don't care (always assembled as 0) + * [ww] ww = 3 for W used as REX.W + * + * [p0] pp = 0 for no prefix + * [60] pp = 1 for legacy prefix 60 + * [f3] pp = 2 + * [f2] pp = 3 + * + * tup is tuple type for Disp8*N from %tuple_codes in insns.pl + * (compressed displacement encoding) + * + * \254..\257 id,s a signed 32-bit operand to be extended to 64 bits. + * \260..\263 this instruction uses VEX/XOP rather than REX, with the + * V field taken from operand 0..3. + * \270 this instruction uses VEX/XOP rather than REX, with the + * V field set to 1111b. + * VEX/XOP prefixes are followed by the sequence: + * \tmm\wlp where mm is the M field; and wlp is: + * 00 wwl lpp + * [l0] ll = 0 for L = 0 (.128, .lz) + * [l1] ll = 1 for L = 1 (.256) + * [lig] ll = 2 for L don't care (always assembled as 0) + * + * [w0] ww = 0 for W = 0 + * [w1 ] ww = 1 for W = 1 + * [wig] ww = 2 for W don't care (always assembled as 0) + * [ww] ww = 3 for W used as REX.W + * + * t = 0 for VEX (C4/C5), t = 1 for XOP (8F). + * + * \271 hlexr instruction takes XRELEASE (F3) with or without lock + * \272 hlenl instruction takes XACQUIRE/XRELEASE with or without lock + * \273 hle instruction takes XACQUIRE/XRELEASE with lock only + * \274..\277 ib,s a byte immediate operand, from operand 0..3, sign-extended + * to the operand size (if o16/o32/o64 present) or the bit size + * \310 a16 indicates fixed 16-bit address size, i.e. optional 0x67. + * \311 a32 indicates fixed 32-bit address size, i.e. optional 0x67. + * \312 adf (disassembler only) invalid with non-default address size. + * \313 a64 indicates fixed 64-bit address size, 0x67 invalid. + * \314 norexb (disassembler only) invalid with REX.B + * \315 norexx (disassembler only) invalid with REX.X + * \316 norexr (disassembler only) invalid with REX.R + * \317 norexw (disassembler only) invalid with REX.W + * \320 o16 indicates fixed 16-bit operand size, i.e. optional 0x66. + * \321 o32 indicates fixed 32-bit operand size, i.e. optional 0x66. + * \322 odf indicates that this instruction is only valid when the + * operand size is the default (instruction to disassembler, + * generates no code in the assembler) + * \323 o64nw indicates fixed 64-bit operand size, REX on extensions only. + * \324 o64 indicates 64-bit operand size requiring REX prefix. + * \325 nohi instruction which always uses spl/bpl/sil/dil + * \326 nof3 instruction not valid with 0xF3 REP prefix. Hint for + disassembler only; for SSE instructions. + * \331 norep instruction not valid with REP prefix. Hint for + * disassembler only; for SSE instructions. + * \332 f2i REP prefix (0xF2 byte) used as opcode extension. + * \333 f3i REP prefix (0xF3 byte) used as opcode extension. + * \334 rex.l LOCK prefix used as REX.R (used in non-64-bit mode) + * \335 repe disassemble a rep (0xF3 byte) prefix as repe not rep. + * \336 mustrep force a REP(E) prefix (0xF3) even if not specified. + * \337 mustrepne force a REPNE prefix (0xF2) even if not specified. + * \336-\337 are still listed as prefixes in the disassembler. + * \340 resb reserve <operand 0> bytes of uninitialized storage. + * Operand 0 had better be a segmentless constant. + * \341 wait this instruction needs a WAIT "prefix" + * \360 np no SSE prefix (== \364\331) + * \361 66 SSE prefix (== \366\331) + * \364 !osp operand-size prefix (0x66) not permitted + * \365 !asp address-size prefix (0x67) not permitted + * \366 operand-size prefix (0x66) used as opcode extension + * \367 address-size prefix (0x67) used as opcode extension + * \370,\371 jcc8 match only if operand 0 meets byte jump criteria. + * jmp8 370 is used for Jcc, 371 is used for JMP. + * \373 jlen assemble 0x03 if bits==16, 0x05 if bits==32; + * used for conditional jump over longer jump + * \374 vsibx|vm32x|vm64x this instruction takes an XMM VSIB memory EA + * \375 vsiby|vm32y|vm64y this instruction takes an YMM VSIB memory EA + * \376 vsibz|vm32z|vm64z this instruction takes an ZMM VSIB memory EA + */ + +#include "compiler.h" + + +#include "nasm.h" +#include "nasmlib.h" +#include "error.h" +#include "assemble.h" +#include "insns.h" +#include "tables.h" +#include "disp8.h" +#include "listing.h" +#include "dbginfo.h" + +enum match_result { + /* + * Matching errors. These should be sorted so that more specific + * errors come later in the sequence. + */ + MERR_INVALOP, + MERR_OPSIZEMISSING, + MERR_OPSIZEMISMATCH, + MERR_BRNOTHERE, + MERR_BRNUMMISMATCH, + MERR_MASKNOTHERE, + MERR_DECONOTHERE, + MERR_BADCPU, + MERR_BADMODE, + MERR_BADHLE, + MERR_ENCMISMATCH, + MERR_BADBND, + MERR_BADREPNE, + MERR_REGSETSIZE, + MERR_REGSET, + /* + * Matching success; the conditional ones first + */ + MOK_JUMP, /* Matching OK but needs jmp_match() */ + MOK_GOOD /* Matching unconditionally OK */ +}; + +typedef struct { + enum ea_type type; /* what kind of EA is this? */ + int sib_present; /* is a SIB byte necessary? */ + int bytes; /* # of bytes of offset needed */ + int size; /* lazy - this is sib+bytes+1 */ + uint8_t modrm, sib, rex, rip; /* the bytes themselves */ + int8_t disp8; /* compressed displacement for EVEX */ +} ea; + +#define GEN_SIB(scale, index, base) \ + (((scale) << 6) | ((index) << 3) | ((base))) + +#define GEN_MODRM(mod, reg, rm) \ + (((mod) << 6) | (((reg) & 7) << 3) | ((rm) & 7)) + +static int64_t calcsize(int32_t, int64_t, int, insn *, + const struct itemplate *); +static int emit_prefix(struct out_data *data, const int bits, insn *ins); +static void gencode(struct out_data *data, insn *ins); +static enum match_result find_match(const struct itemplate **tempp, + insn *instruction, + int32_t segment, int64_t offset, int bits); +static enum match_result matches(const struct itemplate *, insn *, int bits); +static opflags_t regflag(const operand *); +static int32_t regval(const operand *); +static int rexflags(int, opflags_t, int); +static int op_rexflags(const operand *, int); +static int op_evexflags(const operand *, int, uint8_t); +static void add_asp(insn *, int); + +static int process_ea(operand *, ea *, int, int, opflags_t, + insn *, enum ea_type, const char **); + +static inline bool absolute_op(const struct operand *o) +{ + return o->segment == NO_SEG && o->wrt == NO_SEG && + !(o->opflags & OPFLAG_RELATIVE); +} + +static int has_prefix(insn * ins, enum prefix_pos pos, int prefix) +{ + return ins->prefixes[pos] == prefix; +} + +static void assert_no_prefix(insn * ins, enum prefix_pos pos) +{ + if (ins->prefixes[pos]) + nasm_nonfatal("invalid %s prefix", prefix_name(ins->prefixes[pos])); +} + +static const char *size_name(int size) +{ + switch (size) { + case 1: + return "byte"; + case 2: + return "word"; + case 4: + return "dword"; + case 8: + return "qword"; + case 10: + return "tword"; + case 16: + return "oword"; + case 32: + return "yword"; + case 64: + return "zword"; + default: + return "???"; + } +} + +static void warn_overflow(int size) +{ + nasm_warn(ERR_PASS2 | WARN_NUMBER_OVERFLOW, "%s data exceeds bounds", + size_name(size)); +} + +static void warn_overflow_const(int64_t data, int size) +{ + if (overflow_general(data, size)) + warn_overflow(size); +} + +static void warn_overflow_out(int64_t data, int size, enum out_flags flags) +{ + bool err; + + if (flags & OUT_SIGNED) + err = overflow_signed(data, size); + else if (flags & OUT_UNSIGNED) + err = overflow_unsigned(data, size); + else + err = overflow_general(data, size); + + if (err) + warn_overflow(size); +} + +/* + * Collect macro-related debug information, if applicable. + */ +static void debug_macro_out(const struct out_data *data) +{ + struct debug_macro_addr *addr; + uint64_t start = data->offset; + uint64_t end = start + data->size; + + addr = debug_macro_get_addr(data->segment); + while (addr) { + if (!addr->len) + addr->start = start; + addr->len = end - addr->start; + addr = addr->up; + } +} + +/* + * This routine wrappers the real output format's output routine, + * in order to pass a copy of the data off to the listing file + * generator at the same time, flatten unnecessary relocations, + * and verify backend compatibility. + */ +/* + * This warning is currently issued by backends, but in the future + * this code should be centralized. + * + *!zeroing [on] RESx in initialized section becomes zero + *! a \c{RESx} directive was used in a section which contains + *! initialized data, and the output format does not support + *! this. Instead, this will be replaced with explicit zero + *! content, which may produce a large output file. + */ +static void out(struct out_data *data) +{ + static struct last_debug_info { + struct src_location where; + int32_t segment; + } dbg; + union { + uint8_t b[8]; + uint64_t q; + } xdata; + size_t asize, amax; + uint64_t zeropad = 0; + int64_t addrval; + int32_t fixseg; /* Segment for which to produce fixed data */ + + if (!data->size) + return; /* Nothing to do */ + + /* + * Convert addresses to RAWDATA if possible + * XXX: not all backends want this for global symbols!!!! + */ + switch (data->type) { + case OUT_ADDRESS: + addrval = data->toffset; + fixseg = NO_SEG; /* Absolute address is fixed data */ + goto address; + + case OUT_RELADDR: + addrval = data->toffset - data->relbase; + fixseg = data->segment; /* Our own segment is fixed data */ + goto address; + + address: + nasm_assert(data->size <= 8); + asize = data->size; + amax = ofmt->maxbits >> 3; /* Maximum address size in bytes */ + if (!(ofmt->flags & OFMT_KEEP_ADDR) && + data->tsegment == fixseg && + data->twrt == NO_SEG) { + if (asize >= (size_t)(data->bits >> 3)) { + /* Support address space wrapping for low-bit modes */ + data->flags &= ~OUT_SIGNMASK; + } + warn_overflow_out(addrval, asize, data->flags); + xdata.q = cpu_to_le64(addrval); + data->data = xdata.b; + data->type = OUT_RAWDATA; + asize = amax = 0; /* No longer an address */ + } + break; + + case OUT_SEGMENT: + nasm_assert(data->size <= 8); + asize = data->size; + amax = 2; + break; + + default: + asize = amax = 0; /* Not an address */ + break; + } + + /* + * If the source location or output segment has changed, + * let the debug backend know. Some backends really don't + * like being given a NULL filename as can happen if we + * use -Lb and expand a macro, so filter out that case. + */ + data->where = src_where(); + if (data->where.filename && + (!src_location_same(data->where, dbg.where) | + (data->segment != dbg.segment))) { + dbg.where = data->where; + dbg.segment = data->segment; + dfmt->linenum(dbg.where.filename, dbg.where.lineno, data->segment); + } + + if (asize > amax) { + if (data->type == OUT_RELADDR || (data->flags & OUT_SIGNED)) { + nasm_nonfatal("%u-bit signed relocation unsupported by output format %s", + (unsigned int)(asize << 3), ofmt->shortname); + } else { + /*! + *!zext-reloc [on] relocation zero-extended to match output format + *! warns that a relocation has been zero-extended due + *! to limitations in the output format. + */ + nasm_warn(WARN_ZEXT_RELOC, + "%u-bit %s relocation zero-extended from %u bits", + (unsigned int)(asize << 3), + data->type == OUT_SEGMENT ? "segment" : "unsigned", + (unsigned int)(amax << 3)); + } + zeropad = data->size - amax; + data->size = amax; + } + lfmt->output(data); + + if (likely(data->segment != NO_SEG)) { + /* + * Collect macro-related information for the debugger, if applicable + */ + if (debug_current_macro) + debug_macro_out(data); + + ofmt->output(data); + } else { + /* Outputting to ABSOLUTE section - only reserve is permitted */ + if (data->type != OUT_RESERVE) + nasm_nonfatal("attempt to assemble code in [ABSOLUTE] space"); + /* No need to push to the backend */ + } + + data->offset += data->size; + data->insoffs += data->size; + + if (zeropad) { + data->type = OUT_ZERODATA; + data->size = zeropad; + lfmt->output(data); + ofmt->output(data); + data->offset += zeropad; + data->insoffs += zeropad; + data->size += zeropad; /* Restore original size value */ + } +} + +static inline void out_rawdata(struct out_data *data, const void *rawdata, + size_t size) +{ + data->type = OUT_RAWDATA; + data->data = rawdata; + data->size = size; + out(data); +} + +static void out_rawbyte(struct out_data *data, uint8_t byte) +{ + data->type = OUT_RAWDATA; + data->data = &byte; + data->size = 1; + out(data); +} + +static inline void out_reserve(struct out_data *data, uint64_t size) +{ + data->type = OUT_RESERVE; + data->size = size; + out(data); +} + +static void out_segment(struct out_data *data, const struct operand *opx) +{ + if (opx->opflags & OPFLAG_RELATIVE) + nasm_nonfatal("segment references cannot be relative"); + + data->type = OUT_SEGMENT; + data->flags = OUT_UNSIGNED; + data->size = 2; + data->toffset = opx->offset; + data->tsegment = ofmt->segbase(opx->segment | 1); + data->twrt = opx->wrt; + out(data); +} + +static void out_imm(struct out_data *data, const struct operand *opx, + int size, enum out_flags sign) +{ + if (opx->segment != NO_SEG && (opx->segment & 1)) { + /* + * This is actually a segment reference, but eval() has + * already called ofmt->segbase() for us. Sigh. + */ + if (size < 2) + nasm_nonfatal("segment reference must be 16 bits"); + + data->type = OUT_SEGMENT; + } else { + data->type = (opx->opflags & OPFLAG_RELATIVE) + ? OUT_RELADDR : OUT_ADDRESS; + } + data->flags = sign; + data->toffset = opx->offset; + data->tsegment = opx->segment; + data->twrt = opx->wrt; + /* + * XXX: improve this if at some point in the future we can + * distinguish the subtrahend in expressions like [foo - bar] + * where bar is a symbol in the current segment. However, at the + * current point, if OPFLAG_RELATIVE is set that subtraction has + * already occurred. + */ + data->relbase = 0; + data->size = size; + out(data); +} + +static void out_reladdr(struct out_data *data, const struct operand *opx, + int size) +{ + if (opx->opflags & OPFLAG_RELATIVE) + nasm_nonfatal("invalid use of self-relative expression"); + + data->type = OUT_RELADDR; + data->flags = OUT_SIGNED; + data->size = size; + data->toffset = opx->offset; + data->tsegment = opx->segment; + data->twrt = opx->wrt; + data->relbase = data->offset + (data->inslen - data->insoffs); + out(data); +} + +static bool jmp_match(int32_t segment, int64_t offset, int bits, + insn * ins, const struct itemplate *temp) +{ + int64_t isize; + const uint8_t *code = temp->code; + uint8_t c = code[0]; + bool is_byte; + + if (((c & ~1) != 0370) || (ins->oprs[0].type & STRICT)) + return false; + if (!optimizing.level || (optimizing.flag & OPTIM_DISABLE_JMP_MATCH)) + return false; + if (optimizing.level < 0 && c == 0371) + return false; + + isize = calcsize(segment, offset, bits, ins, temp); + + if (ins->oprs[0].opflags & OPFLAG_UNKNOWN) + /* Be optimistic in pass 1 */ + return true; + + if (ins->oprs[0].segment != segment) + return false; + + isize = ins->oprs[0].offset - offset - isize; /* isize is delta */ + is_byte = (isize >= -128 && isize <= 127); /* is it byte size? */ + + if (is_byte && c == 0371 && ins->prefixes[PPS_REP] == P_BND) { + /* jmp short (opcode eb) cannot be used with bnd prefix. */ + ins->prefixes[PPS_REP] = P_none; + /*! + *!prefix-bnd [on] invalid BND prefix + *!=bnd + *! warns about ineffective use of the \c{BND} prefix when the + *! \c{JMP} instruction is converted to the \c{SHORT} form. + *! This should be extremely rare since the short \c{JMP} only + *! is applicable to jumps inside the same module, but if + *! it is legitimate, it may be necessary to use + *! \c{bnd jmp dword}. + */ + nasm_warn(WARN_PREFIX_BND|ERR_PASS2 , + "jmp short does not init bnd regs - bnd prefix dropped"); + } + + return is_byte; +} + +static inline int64_t merge_resb(insn *ins, int64_t isize) +{ + int nbytes = resb_bytes(ins->opcode); + + if (likely(!nbytes)) + return isize; + + if (isize != nbytes * ins->oprs[0].offset) + return isize; /* Has prefixes of some sort */ + + ins->oprs[0].offset *= ins->times; + isize *= ins->times; + ins->times = 1; + return isize; +} + +/* This must be handle non-power-of-2 alignment values */ +static inline size_t pad_bytes(size_t len, size_t align) +{ + size_t partial = len % align; + return partial ? align - partial : 0; +} + +static void out_eops(struct out_data *data, const extop *e) +{ + while (e) { + size_t dup = e->dup; + + switch (e->type) { + case EOT_NOTHING: + break; + + case EOT_EXTOP: + while (dup--) + out_eops(data, e->val.subexpr); + break; + + case EOT_DB_NUMBER: + if (e->elem > 8) { + nasm_nonfatal("integer supplied as %d-bit data", + e->elem << 3); + } else { + while (dup--) { + data->insoffs = 0; + data->inslen = data->size = e->elem; + data->tsegment = e->val.num.segment; + data->toffset = e->val.num.offset; + data->twrt = e->val.num.wrt; + data->relbase = 0; + if (e->val.num.segment != NO_SEG && + (e->val.num.segment & 1)) { + data->type = OUT_SEGMENT; + data->flags = OUT_UNSIGNED; + } else { + data->type = e->val.num.relative + ? OUT_RELADDR : OUT_ADDRESS; + data->flags = OUT_WRAP; + } + out(data); + } + } + break; + + case EOT_DB_FLOAT: + case EOT_DB_STRING: + case EOT_DB_STRING_FREE: + { + size_t pad, len; + + pad = pad_bytes(e->val.string.len, e->elem); + len = e->val.string.len + pad; + + while (dup--) { + data->insoffs = 0; + data->inslen = len; + out_rawdata(data, e->val.string.data, e->val.string.len); + if (pad) + out_rawdata(data, zero_buffer, pad); + } + break; + } + + case EOT_DB_RESERVE: + data->insoffs = 0; + data->inslen = dup * e->elem; + out_reserve(data, data->inslen); + break; + } + + e = e->next; + } +} + +/* This is totally just a wild guess what is reasonable... */ +#define INCBIN_MAX_BUF (ZERO_BUF_SIZE * 16) + +int64_t assemble(int32_t segment, int64_t start, int bits, insn *instruction) +{ + struct out_data data; + const struct itemplate *temp; + enum match_result m; + + if (instruction->opcode == I_none) + return 0; + + nasm_zero(data); + data.offset = start; + data.segment = segment; + data.itemp = NULL; + data.bits = bits; + + if (opcode_is_db(instruction->opcode)) { + out_eops(&data, instruction->eops); + } else if (instruction->opcode == I_INCBIN) { + const char *fname = instruction->eops->val.string.data; + FILE *fp; + size_t t = instruction->times; /* INCBIN handles TIMES by itself */ + off_t base = 0; + off_t len; + const void *map = NULL; + char *buf = NULL; + size_t blk = 0; /* Buffered I/O block size */ + size_t m = 0; /* Bytes last read */ + + if (!t) + goto done; + + fp = nasm_open_read(fname, NF_BINARY|NF_FORMAP); + if (!fp) { + nasm_nonfatal("`incbin': unable to open file `%s'", + fname); + goto done; + } + + len = nasm_file_size(fp); + + if (len == (off_t)-1) { + nasm_nonfatal("`incbin': unable to get length of file `%s'", + fname); + goto close_done; + } + + if (instruction->eops->next) { + base = instruction->eops->next->val.num.offset; + if (base >= len) { + len = 0; + } else { + len -= base; + if (instruction->eops->next->next && + len > (off_t)instruction->eops->next->next->val.num.offset) + len = (off_t)instruction->eops->next->next->val.num.offset; + } + } + + lfmt->set_offset(data.offset); + lfmt->uplevel(LIST_INCBIN, len); + + if (!len) + goto end_incbin; + + /* Try to map file data */ + map = nasm_map_file(fp, base, len); + if (!map) { + blk = len < (off_t)INCBIN_MAX_BUF ? (size_t)len : INCBIN_MAX_BUF; + buf = nasm_malloc(blk); + } + + while (t--) { + /* + * Consider these irrelevant for INCBIN, since it is fully + * possible that these might be (way) bigger than an int + * can hold; there is, however, no reason to widen these + * types just for INCBIN. data.inslen == 0 signals to the + * backend that these fields are meaningless, if at all + * needed. + */ + data.insoffs = 0; + data.inslen = 0; + + if (map) { + out_rawdata(&data, map, len); + } else if ((off_t)m == len) { + out_rawdata(&data, buf, len); + } else { + off_t l = len; + + if (fseeko(fp, base, SEEK_SET) < 0 || ferror(fp)) { + nasm_nonfatal("`incbin': unable to seek on file `%s'", + fname); + goto end_incbin; + } + while (l > 0) { + m = fread(buf, 1, l < (off_t)blk ? (size_t)l : blk, fp); + if (!m || feof(fp)) { + /* + * This shouldn't happen unless the file + * actually changes while we are reading + * it. + */ + nasm_nonfatal("`incbin': unexpected EOF while" + " reading file `%s'", fname); + goto end_incbin; + } + out_rawdata(&data, buf, m); + l -= m; + } + } + } + end_incbin: + lfmt->downlevel(LIST_INCBIN); + if (instruction->times > 1) { + lfmt->uplevel(LIST_TIMES, instruction->times); + lfmt->downlevel(LIST_TIMES); + } + if (ferror(fp)) { + nasm_nonfatal("`incbin': error while" + " reading file `%s'", fname); + } + close_done: + if (buf) + nasm_free(buf); + if (map) + nasm_unmap_file(map, len); + fclose(fp); + done: + instruction->times = 1; /* Tell the upper layer not to iterate */ + ; + } else { + /* "Real" instruction */ + + /* Check to see if we need an address-size prefix */ + add_asp(instruction, bits); + + m = find_match(&temp, instruction, data.segment, data.offset, bits); + + if (m == MOK_GOOD) { + /* Matches! */ + if (unlikely(itemp_has(temp, IF_OBSOLETE))) { + errflags warning; + const char *whathappened; + const char *validity; + bool never = itemp_has(temp, IF_NEVER); + + /* + * If IF_OBSOLETE is set, warn the user. Different + * warning classes for "obsolete but valid for this + * specific CPU" and "obsolete and gone." + * + *!obsolete-removed [on] instruction obsolete and removed on the target CPU + *! warns for an instruction which has been removed + *! from the architecture, and is no longer included + *! in the CPU definition given in the \c{[CPU]} + *! directive, for example \c{POP CS}, the opcode for + *! which, \c{0Fh}, instead is an opcode prefix on + *! CPUs newer than the first generation 8086. + * + *!obsolete-nop [on] instruction obsolete and is a noop on the target CPU + *! warns for an instruction which has been removed + *! from the architecture, but has been architecturally + *! defined to be a noop for future CPUs. + * + *!obsolete-valid [on] instruction obsolete but valid on the target CPU + *! warns for an instruction which has been removed + *! from the architecture, but is still valid on the + *! specific CPU given in the \c{CPU} directive. Code + *! using these instructions is most likely not + *! forward compatible. + */ + + whathappened = never ? "never implemented" : "obsolete"; + + if (!never && !iflag_cmp_cpu_level(&insns_flags[temp->iflag_idx], &cpu)) { + warning = WARN_OBSOLETE_VALID; + validity = "but valid on"; + } else if (itemp_has(temp, IF_NOP)) { + warning = WARN_OBSOLETE_NOP; + validity = "and is a noop on"; + } else { + warning = WARN_OBSOLETE_REMOVED; + validity = never ? "and invalid on" : "and removed from"; + } + + nasm_warn(warning, "instruction %s %s the target CPU", + whathappened, validity); + } + + data.itemp = temp; + data.bits = bits; + data.insoffs = 0; + + data.inslen = calcsize(data.segment, data.offset, + bits, instruction, temp); + nasm_assert(data.inslen >= 0); + data.inslen = merge_resb(instruction, data.inslen); + + gencode(&data, instruction); + nasm_assert(data.insoffs == data.inslen); + } else { + /* No match */ + switch (m) { + case MERR_OPSIZEMISSING: + nasm_nonfatal("operation size not specified"); + break; + case MERR_OPSIZEMISMATCH: + nasm_nonfatal("mismatch in operand sizes"); + break; + case MERR_BRNOTHERE: + nasm_nonfatal("broadcast not permitted on this operand"); + break; + case MERR_BRNUMMISMATCH: + nasm_nonfatal("mismatch in the number of broadcasting elements"); + break; + case MERR_MASKNOTHERE: + nasm_nonfatal("mask not permitted on this operand"); + break; + case MERR_DECONOTHERE: + nasm_nonfatal("unsupported mode decorator for instruction"); + break; + case MERR_BADCPU: + nasm_nonfatal("no instruction for this cpu level"); + break; + case MERR_BADMODE: + nasm_nonfatal("instruction not supported in %d-bit mode", bits); + break; + case MERR_ENCMISMATCH: + if (!instruction->prefixes[PPS_REX]) { + nasm_nonfatal("instruction not encodable without explicit prefix"); + } else { + nasm_nonfatal("instruction not encodable with %s prefix", + prefix_name(instruction->prefixes[PPS_REX])); + } + break; + case MERR_BADBND: + case MERR_BADREPNE: + nasm_nonfatal("%s prefix is not allowed", + prefix_name(instruction->prefixes[PPS_REP])); + break; + case MERR_REGSETSIZE: + nasm_nonfatal("invalid register set size"); + break; + case MERR_REGSET: + nasm_nonfatal("register set not valid for operand"); + break; + default: + nasm_nonfatal("invalid combination of opcode and operands"); + break; + } + + instruction->times = 1; /* Avoid repeated error messages */ + } + } + return data.offset - start; +} + +static int32_t eops_typeinfo(const extop *e) +{ + int32_t typeinfo = 0; + + while (e) { + switch (e->type) { + case EOT_NOTHING: + break; + + case EOT_EXTOP: + typeinfo |= eops_typeinfo(e->val.subexpr); + break; + + case EOT_DB_FLOAT: + switch (e->elem) { + case 1: typeinfo |= TY_BYTE; break; + case 2: typeinfo |= TY_WORD; break; + case 4: typeinfo |= TY_FLOAT; break; + case 8: typeinfo |= TY_QWORD; break; /* double? */ + case 10: typeinfo |= TY_TBYTE; break; /* long double? */ + case 16: typeinfo |= TY_YWORD; break; + case 32: typeinfo |= TY_ZWORD; break; + default: break; + } + break; + + default: + switch (e->elem) { + case 1: typeinfo |= TY_BYTE; break; + case 2: typeinfo |= TY_WORD; break; + case 4: typeinfo |= TY_DWORD; break; + case 8: typeinfo |= TY_QWORD; break; + case 10: typeinfo |= TY_TBYTE; break; + case 16: typeinfo |= TY_YWORD; break; + case 32: typeinfo |= TY_ZWORD; break; + default: break; + } + break; + } + e = e->next; + } + + return typeinfo; +} + +static inline void debug_set_db_type(insn *instruction) +{ + + int32_t typeinfo = TYS_ELEMENTS(instruction->operands); + + typeinfo |= eops_typeinfo(instruction->eops); + dfmt->debug_typevalue(typeinfo); +} + +static void debug_set_type(insn *instruction) +{ + int32_t typeinfo; + + if (opcode_is_resb(instruction->opcode)) { + typeinfo = TYS_ELEMENTS(instruction->oprs[0].offset); + + switch (instruction->opcode) { + case I_RESB: + typeinfo |= TY_BYTE; + break; + case I_RESW: + typeinfo |= TY_WORD; + break; + case I_RESD: + typeinfo |= TY_DWORD; + break; + case I_RESQ: + typeinfo |= TY_QWORD; + break; + case I_REST: + typeinfo |= TY_TBYTE; + break; + case I_RESO: + typeinfo |= TY_OWORD; + break; + case I_RESY: + typeinfo |= TY_YWORD; + break; + case I_RESZ: + typeinfo |= TY_ZWORD; + break; + default: + panic(); + } + } else { + typeinfo = TY_LABEL; + } + + dfmt->debug_typevalue(typeinfo); +} + + +/* Proecess an EQU directive */ +static void define_equ(insn * instruction) +{ + if (!instruction->label) { + nasm_nonfatal("EQU not preceded by label"); + } else if (instruction->operands == 1 && + (instruction->oprs[0].type & IMMEDIATE) && + instruction->oprs[0].wrt == NO_SEG) { + define_label(instruction->label, + instruction->oprs[0].segment, + instruction->oprs[0].offset, false); + } else if (instruction->operands == 2 + && (instruction->oprs[0].type & IMMEDIATE) + && (instruction->oprs[0].type & COLON) + && instruction->oprs[0].segment == NO_SEG + && instruction->oprs[0].wrt == NO_SEG + && (instruction->oprs[1].type & IMMEDIATE) + && instruction->oprs[1].segment == NO_SEG + && instruction->oprs[1].wrt == NO_SEG) { + define_label(instruction->label, + instruction->oprs[0].offset | SEG_ABS, + instruction->oprs[1].offset, false); + } else { + nasm_nonfatal("bad syntax for EQU"); + } +} + +static int64_t len_extops(const extop *e) +{ + int64_t isize = 0; + size_t pad; + + while (e) { + switch (e->type) { + case EOT_NOTHING: + break; + + case EOT_EXTOP: + isize += e->dup * len_extops(e->val.subexpr); + break; + + case EOT_DB_STRING: + case EOT_DB_STRING_FREE: + case EOT_DB_FLOAT: + pad = pad_bytes(e->val.string.len, e->elem); + isize += e->dup * (e->val.string.len + pad); + break; + + case EOT_DB_NUMBER: + warn_overflow_const(e->val.num.offset, e->elem); + isize += e->dup * e->elem; + break; + + case EOT_DB_RESERVE: + isize += e->dup * e->elem; + break; + } + + e = e->next; + } + + return isize; +} + +int64_t insn_size(int32_t segment, int64_t offset, int bits, insn *instruction) +{ + const struct itemplate *temp; + enum match_result m; + int64_t isize = 0; + + if (instruction->opcode == I_none) { + return 0; + } else if (instruction->opcode == I_EQU) { + define_equ(instruction); + return 0; + } else if (opcode_is_db(instruction->opcode)) { + isize = len_extops(instruction->eops); + debug_set_db_type(instruction); + return isize; + } else if (instruction->opcode == I_INCBIN) { + const extop *e = instruction->eops; + const char *fname = e->val.string.data; + off_t len; + + len = nasm_file_size_by_path(fname); + if (len == (off_t)-1) { + nasm_nonfatal("`incbin': unable to get length of file `%s'", + fname); + return 0; + } + + e = e->next; + if (e) { + if (len <= (off_t)e->val.num.offset) { + len = 0; + } else { + len -= e->val.num.offset; + e = e->next; + if (e && len > (off_t)e->val.num.offset) { + len = (off_t)e->val.num.offset; + } + } + } + + len *= instruction->times; + instruction->times = 1; /* Tell the upper layer to not iterate */ + + return len; + } else { + /* Normal instruction, or RESx */ + + /* Check to see if we need an address-size prefix */ + add_asp(instruction, bits); + + m = find_match(&temp, instruction, segment, offset, bits); + if (m != MOK_GOOD) + return -1; /* No match */ + + isize = calcsize(segment, offset, bits, instruction, temp); + debug_set_type(instruction); + isize = merge_resb(instruction, isize); + + return isize; + } +} + +static void bad_hle_warn(const insn * ins, uint8_t hleok) +{ + enum prefixes rep_pfx = ins->prefixes[PPS_REP]; + enum whatwarn { w_none, w_lock, w_inval } ww; + static const enum whatwarn warn[2][4] = + { + { w_inval, w_inval, w_none, w_lock }, /* XACQUIRE */ + { w_inval, w_none, w_none, w_lock }, /* XRELEASE */ + }; + unsigned int n; + + n = (unsigned int)rep_pfx - P_XACQUIRE; + if (n > 1) + return; /* Not XACQUIRE/XRELEASE */ + + ww = warn[n][hleok]; + if (!is_class(MEMORY, ins->oprs[0].type)) + ww = w_inval; /* HLE requires operand 0 to be memory */ + + /*! + *!prefix-hle [on] invalid HLE prefix + *!=hle + *! warns about invalid use of the HLE \c{XACQUIRE} or \c{XRELEASE} + *! prefixes. + */ + switch (ww) { + case w_none: + break; + + case w_lock: + if (ins->prefixes[PPS_LOCK] != P_LOCK) { + nasm_warn(WARN_PREFIX_HLE|ERR_PASS2, + "%s with this instruction requires lock", + prefix_name(rep_pfx)); + } + break; + + case w_inval: + nasm_warn(WARN_PREFIX_HLE|ERR_PASS2, + "%s invalid with this instruction", + prefix_name(rep_pfx)); + break; + } +} + +/* Common construct */ +#define case3(x) case (x): case (x)+1: case (x)+2 +#define case4(x) case3(x): case (x)+3 + +static int64_t calcsize(int32_t segment, int64_t offset, int bits, + insn * ins, const struct itemplate *temp) +{ + const uint8_t *codes = temp->code; + int64_t length = 0; + uint8_t c; + int rex_mask = ~0; + int op1, op2; + struct operand *opx; + uint8_t opex = 0; + enum ea_type eat; + uint8_t hleok = 0; + bool lockcheck = true; + enum reg_enum mib_index = R_none; /* For a separate index reg form */ + const char *errmsg; + + ins->rex = 0; /* Ensure REX is reset */ + eat = EA_SCALAR; /* Expect a scalar EA */ + memset(ins->evex_p, 0, 3); /* Ensure EVEX is reset */ + + if (ins->prefixes[PPS_OSIZE] == P_O64) + ins->rex |= REX_W; + + (void)segment; /* Don't warn that this parameter is unused */ + (void)offset; /* Don't warn that this parameter is unused */ + + while (*codes) { + c = *codes++; + op1 = (c & 3) + ((opex & 1) << 2); + op2 = ((c >> 3) & 3) + ((opex & 2) << 1); + opx = &ins->oprs[op1]; + opex = 0; /* For the next iteration */ + + switch (c) { + case4(01): + codes += c, length += c; + break; + + case3(05): + opex = c; + break; + + case4(010): + ins->rex |= + op_rexflags(opx, REX_B|REX_H|REX_P|REX_W); + codes++, length++; + break; + + case4(014): + /* this is an index reg of a split SIB operand */ + mib_index = opx->basereg; + break; + + case4(020): + case4(024): + length++; + break; + + case4(030): + length += 2; + break; + + case4(034): + if (opx->type & (BITS16 | BITS32 | BITS64)) + length += (opx->type & BITS16) ? 2 : 4; + else + length += (bits == 16) ? 2 : 4; + break; + + case4(040): + length += 4; + break; + + case4(044): + length += ins->addr_size >> 3; + break; + + case4(050): + length++; + break; + + case4(054): + length += 8; /* MOV reg64/imm */ + break; + + case4(060): + length += 2; + break; + + case4(064): + if (opx->type & (BITS16 | BITS32 | BITS64)) + length += (opx->type & BITS16) ? 2 : 4; + else + length += (bits == 16) ? 2 : 4; + break; + + case4(070): + length += 4; + break; + + case4(074): + length += 2; + break; + + case 0171: + c = *codes++; + op2 = (op2 & ~3) | ((c >> 3) & 3); + opx = &ins->oprs[op2]; + ins->rex |= op_rexflags(opx, REX_R|REX_H|REX_P|REX_W); + length++; + break; + + case 0172: + case 0173: + codes++; + length++; + break; + + case4(0174): + length++; + break; + + case4(0240): + ins->rex |= REX_EV; + ins->vexreg = regval(opx); + ins->evex_p[2] |= op_evexflags(opx, EVEX_P2VP, 2); /* High-16 NDS */ + ins->vex_cm = *codes++; + ins->vex_wlp = *codes++; + ins->evex_tuple = (*codes++ - 0300); + break; + + case 0250: + ins->rex |= REX_EV; + ins->vexreg = 0; + ins->vex_cm = *codes++; + ins->vex_wlp = *codes++; + ins->evex_tuple = (*codes++ - 0300); + break; + + case4(0254): + length += 4; + break; + + case4(0260): + ins->rex |= REX_V; + ins->vexreg = regval(opx); + ins->vex_cm = *codes++; + ins->vex_wlp = *codes++; + break; + + case 0270: + ins->rex |= REX_V; + ins->vexreg = 0; + ins->vex_cm = *codes++; + ins->vex_wlp = *codes++; + break; + + case3(0271): + hleok = c & 3; + break; + + case4(0274): + length++; + break; + + case4(0300): + break; + + case 0310: + if (bits == 64) + return -1; + length += (bits != 16) && !has_prefix(ins, PPS_ASIZE, P_A16); + break; + + case 0311: + length += (bits != 32) && !has_prefix(ins, PPS_ASIZE, P_A32); + break; + + case 0312: + break; + + case 0313: + if (bits != 64 || has_prefix(ins, PPS_ASIZE, P_A16) || + has_prefix(ins, PPS_ASIZE, P_A32)) + return -1; + break; + + case4(0314): + break; + + case 0320: + { + /*! prefix-opsize [on] invalid operand size prefix + *! warns that an operand prefix (\c{o16}, \c{o32}, \c{o64}, + *! \c{osp}) invalid for the specified instruction has been specified. + *! The operand prefix will be ignored by the assembler. + */ + enum prefixes pfx = ins->prefixes[PPS_OSIZE]; + if (pfx == P_O16) + break; + if (pfx != P_none) + nasm_warn(WARN_PREFIX_OPSIZE|ERR_PASS2, + "invalid operand size prefix, must be o16"); + else + ins->prefixes[PPS_OSIZE] = P_O16; + break; + } + + case 0321: + { + enum prefixes pfx = ins->prefixes[PPS_OSIZE]; + if (pfx == P_O32) + break; + if (pfx != P_none) + nasm_warn(WARN_PREFIX_OPSIZE|ERR_PASS2, + "invalid operand size prefix, must be o32"); + else + ins->prefixes[PPS_OSIZE] = P_O32; + break; + } + + case 0322: + break; + + case 0323: + rex_mask &= ~REX_W; + break; + + case 0324: + ins->rex |= REX_W; + break; + + case 0325: + ins->rex |= REX_NH; + break; + + case 0326: + break; + + case 0331: + break; + + case 0332: + case 0333: + length++; + break; + + case 0334: + ins->rex |= REX_L; + break; + + case 0335: + break; + + case 0336: + if (!ins->prefixes[PPS_REP]) + ins->prefixes[PPS_REP] = P_REP; + break; + + case 0337: + if (!ins->prefixes[PPS_REP]) + ins->prefixes[PPS_REP] = P_REPNE; + break; + + case 0340: + /*! + *!forward [on] forward reference may have unpredictable results + *! warns that a forward reference is used which may have + *! unpredictable results, notably in a \c{RESB}-type + *! pseudo-instruction. These would be \i\e{critical + *! expressions} (see \k{crit}) but are permitted in a + *! handful of cases for compatibility with older + *! versions of NASM. This warning should be treated as a + *! severe programming error as the code could break at + *! any time for any number of reasons. + */ + if (!absolute_op(&ins->oprs[0])) + nasm_nonfatal("attempt to reserve non-constant" + " quantity of BSS space"); + else if (ins->oprs[0].opflags & OPFLAG_FORWARD) + nasm_warn(WARN_FORWARD, "forward reference in RESx " + "can have unpredictable results"); + else + length += ins->oprs[0].offset * resb_bytes(ins->opcode); + break; + + case 0341: + if (!ins->prefixes[PPS_WAIT]) + ins->prefixes[PPS_WAIT] = P_WAIT; + break; + + case 0360: + break; + + case 0361: + length++; + break; + + case 0364: + case 0365: + break; + + case 0366: + case 0367: + length++; + break; + + case 0370: + case 0371: + break; + + case 0373: + length++; + break; + + case 0374: + eat = EA_XMMVSIB; + break; + + case 0375: + eat = EA_YMMVSIB; + break; + + case 0376: + eat = EA_ZMMVSIB; + break; + + case4(0100): + case4(0110): + case4(0120): + case4(0130): + case4(0200): + case4(0204): + case4(0210): + case4(0214): + case4(0220): + case4(0224): + case4(0230): + case4(0234): + { + ea ea_data; + int rfield; + opflags_t rflags; + struct operand *opy = &ins->oprs[op2]; + struct operand *op_er_sae; + + ea_data.rex = 0; /* Ensure ea.REX is initially 0 */ + + if (c <= 0177) { + /* pick rfield from operand b (opx) */ + rflags = regflag(opx); + rfield = nasm_regvals[opx->basereg]; + } else { + rflags = 0; + rfield = c & 7; + } + + /* EVEX.b1 : evex_brerop contains the operand position */ + op_er_sae = (ins->evex_brerop >= 0 ? + &ins->oprs[ins->evex_brerop] : NULL); + + if (op_er_sae && (op_er_sae->decoflags & (ER | SAE))) { + /* set EVEX.b */ + ins->evex_p[2] |= EVEX_P2B; + if (op_er_sae->decoflags & ER) { + /* set EVEX.RC (rounding control) */ + ins->evex_p[2] |= ((ins->evex_rm - BRC_RN) << 5) + & EVEX_P2RC; + } + } else { + /* set EVEX.L'L (vector length) */ + ins->evex_p[2] |= ((ins->vex_wlp << (5 - 2)) & EVEX_P2LL); + ins->evex_p[1] |= ((ins->vex_wlp << (7 - 4)) & EVEX_P1W); + if (opy->decoflags & BRDCAST_MASK) { + /* set EVEX.b */ + ins->evex_p[2] |= EVEX_P2B; + } + } + + if (itemp_has(temp, IF_MIB)) { + opy->eaflags |= EAF_MIB; + /* + * if a separate form of MIB (ICC style) is used, + * the index reg info is merged into mem operand + */ + if (mib_index != R_none) { + opy->indexreg = mib_index; + opy->scale = 1; + opy->hintbase = mib_index; + opy->hinttype = EAH_NOTBASE; + } + } + + /* SIB encoding required */ + if (itemp_has(temp, IF_SIB)) + opy->eaflags |= EAF_SIB; + + if (process_ea(opy, &ea_data, bits, + rfield, rflags, ins, eat, &errmsg)) { + nasm_nonfatal("%s", errmsg); + return -1; + } else { + ins->rex |= ea_data.rex; + length += ea_data.size; + } + } + break; + + default: + nasm_panic("internal instruction table corrupt" + ": instruction code \\%o (0x%02X) given", c, c); + break; + } + } + + ins->rex &= rex_mask; + + if (ins->rex & REX_NH) { + if (ins->rex & REX_H) { + nasm_nonfatal("instruction cannot use high registers"); + return -1; + } + ins->rex &= ~REX_P; /* Don't force REX prefix due to high reg */ + } + + switch (ins->prefixes[PPS_REX]) { + case P_EVEX: + if (!(ins->rex & REX_EV)) + return -1; + break; + case P_VEX: + case P_VEX3: + case P_VEX2: + if (!(ins->rex & REX_V)) + return -1; + break; + case P_REX: + if (ins->rex & (REX_V|REX_EV)) + return -1; + ins->rex |= REX_P; /* Force REX prefix */ + break; + default: + break; + } + + if (ins->rex & (REX_V | REX_EV)) { + int bad32 = REX_R|REX_W|REX_X|REX_B; + + if (ins->rex & REX_H) { + nasm_nonfatal("cannot use high register in AVX instruction"); + return -1; + } + switch (ins->vex_wlp & 060) { + case 000: + case 040: + ins->rex &= ~REX_W; + break; + case 020: + ins->rex |= REX_W; + bad32 &= ~REX_W; + break; + case 060: + /* Follow REX_W */ + break; + } + + if (bits != 64 && ((ins->rex & bad32) || ins->vexreg > 7)) { + nasm_nonfatal("invalid operands in non-64-bit mode"); + return -1; + } else if (!(ins->rex & REX_EV) && + ((ins->vexreg > 15) || (ins->evex_p[0] & 0xf0))) { + nasm_nonfatal("invalid high-16 register in non-AVX-512"); + return -1; + } + if (ins->rex & REX_EV) { + length += 4; + } else if (ins->vex_cm != 1 || (ins->rex & (REX_W|REX_X|REX_B)) || + ins->prefixes[PPS_REX] == P_VEX3) { + if (ins->prefixes[PPS_REX] == P_VEX2) + nasm_nonfatal("instruction not encodable with {vex2} prefix"); + length += 3; + } else { + length += 2; + } + } else if (ins->rex & REX_MASK) { + if (ins->rex & REX_H) { + nasm_nonfatal("cannot use high byte register in rex instruction"); + return -1; + } else if (bits == 64) { + length++; + } else if ((ins->rex & REX_L) && + !(ins->rex & (REX_P|REX_W|REX_X|REX_B)) && + iflag_cpu_level_ok(&cpu, IF_X86_64)) { + /* LOCK-as-REX.R */ + assert_no_prefix(ins, PPS_LOCK); + lockcheck = false; /* Already errored, no need for warning */ + length++; + } else { + nasm_nonfatal("invalid operands in non-64-bit mode"); + return -1; + } + } + + if (has_prefix(ins, PPS_LOCK, P_LOCK) && lockcheck && + (!itemp_has(temp,IF_LOCK) || !is_class(MEMORY, ins->oprs[0].type))) { + /*! + *!prefix-lock [on] LOCK prefix on unlockable instructions + *!=lock + *! warns about \c{LOCK} prefixes on unlockable instructions. + */ + nasm_warn(WARN_PREFIX_LOCK|ERR_PASS2 , "instruction is not lockable"); + } + + bad_hle_warn(ins, hleok); + + /* + * when BND prefix is set by DEFAULT directive, + * BND prefix is added to every appropriate instruction line + * unless it is overridden by NOBND prefix. + */ + if (globalbnd && + (itemp_has(temp, IF_BND) && !has_prefix(ins, PPS_REP, P_NOBND))) + ins->prefixes[PPS_REP] = P_BND; + + /* + * Add length of legacy prefixes + */ + length += emit_prefix(NULL, bits, ins); + + return length; +} + +static inline void emit_rex(struct out_data *data, insn *ins) +{ + if (data->bits == 64) { + if ((ins->rex & REX_MASK) && + !(ins->rex & (REX_V | REX_EV)) && + !ins->rex_done) { + uint8_t rex = (ins->rex & REX_MASK) | REX_P; + out_rawbyte(data, rex); + ins->rex_done = true; + } + } +} + +static int emit_prefix(struct out_data *data, const int bits, insn *ins) +{ + int bytes = 0; + int j; + + for (j = 0; j < MAXPREFIX; j++) { + uint8_t c = 0; + switch (ins->prefixes[j]) { + case P_WAIT: + c = 0x9B; + break; + case P_LOCK: + c = 0xF0; + break; + case P_REPNE: + case P_REPNZ: + case P_XACQUIRE: + case P_BND: + c = 0xF2; + break; + case P_REPE: + case P_REPZ: + case P_REP: + case P_XRELEASE: + c = 0xF3; + break; + case R_CS: + /*! + *!prefix-seg [on] segment prefix ignored in 64-bit mode + *! warns that an \c{es}, \c{cs}, \c{ss} or \c{ds} segment override + *! prefix has no effect in 64-bit mode. The prefix will still be + *! generated as requested. + */ + if (bits == 64) + nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "cs segment base generated, " + "but will be ignored in 64-bit mode"); + c = 0x2E; + break; + case R_DS: + if (bits == 64) + nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "ds segment base generated, " + "but will be ignored in 64-bit mode"); + c = 0x3E; + break; + case R_ES: + if (bits == 64) + nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "es segment base generated, " + "but will be ignored in 64-bit mode"); + c = 0x26; + break; + case R_FS: + c = 0x64; + break; + case R_GS: + c = 0x65; + break; + case R_SS: + if (bits == 64) { + nasm_warn(WARN_PREFIX_SEG|ERR_PASS2, "ss segment base generated, " + "but will be ignored in 64-bit mode"); + } + c = 0x36; + break; + case R_SEGR6: + case R_SEGR7: + nasm_nonfatal("segr6 and segr7 cannot be used as prefixes"); + break; + case P_A16: + if (bits == 64) { + nasm_nonfatal("16-bit addressing is not supported " + "in 64-bit mode"); + } else if (bits != 16) + c = 0x67; + break; + case P_A32: + if (bits != 32) + c = 0x67; + break; + case P_A64: + if (bits != 64) { + nasm_nonfatal("64-bit addressing is only supported " + "in 64-bit mode"); + } + break; + case P_ASP: + c = 0x67; + break; + case P_O16: + if (bits != 16) + c = 0x66; + break; + case P_O32: + if (bits == 16) + c = 0x66; + break; + case P_O64: + /* REX.W */ + break; + case P_OSP: + c = 0x66; + break; + case P_REX: + case P_VEX: + case P_EVEX: + case P_VEX3: + case P_VEX2: + case P_NOBND: + case P_none: + break; + default: + nasm_panic("invalid instruction prefix"); + } + if (c) { + if (data) + out_rawbyte(data, c); + bytes++; + } + } + return bytes; +} + +static void gencode(struct out_data *data, insn *ins) +{ + uint8_t c; + uint8_t bytes[4]; + int64_t size; + int op1, op2; + struct operand *opx; + const uint8_t *codes = data->itemp->code; + uint8_t opex = 0; + enum ea_type eat = EA_SCALAR; + int r; + const int bits = data->bits; + const char *errmsg; + + ins->rex_done = false; + + emit_prefix(data, bits, ins); + + while (*codes) { + c = *codes++; + op1 = (c & 3) + ((opex & 1) << 2); + op2 = ((c >> 3) & 3) + ((opex & 2) << 1); + opx = &ins->oprs[op1]; + opex = 0; /* For the next iteration */ + + + switch (c) { + case 01: + case 02: + case 03: + case 04: + emit_rex(data, ins); + out_rawdata(data, codes, c); + codes += c; + break; + + case 05: + case 06: + case 07: + opex = c; + break; + + case4(010): + emit_rex(data, ins); + out_rawbyte(data, *codes++ + (regval(opx) & 7)); + break; + + case4(014): + break; + + case4(020): + out_imm(data, opx, 1, OUT_WRAP); + break; + + case4(024): + out_imm(data, opx, 1, OUT_UNSIGNED); + break; + + case4(030): + out_imm(data, opx, 2, OUT_WRAP); + break; + + case4(034): + if (opx->type & (BITS16 | BITS32)) + size = (opx->type & BITS16) ? 2 : 4; + else + size = (bits == 16) ? 2 : 4; + out_imm(data, opx, size, OUT_WRAP); + break; + + case4(040): + out_imm(data, opx, 4, OUT_WRAP); + break; + + case4(044): + size = ins->addr_size >> 3; + out_imm(data, opx, size, OUT_WRAP); + break; + + case4(050): + if (opx->segment == data->segment) { + int64_t delta = opx->offset - data->offset + - (data->inslen - data->insoffs); + if (delta > 127 || delta < -128) + nasm_nonfatal("short jump is out of range"); + } + out_reladdr(data, opx, 1); + break; + + case4(054): + out_imm(data, opx, 8, OUT_WRAP); + break; + + case4(060): + out_reladdr(data, opx, 2); + break; + + case4(064): + if (opx->type & (BITS16 | BITS32 | BITS64)) + size = (opx->type & BITS16) ? 2 : 4; + else + size = (bits == 16) ? 2 : 4; + + out_reladdr(data, opx, size); + break; + + case4(070): + out_reladdr(data, opx, 4); + break; + + case4(074): + if (opx->segment == NO_SEG) + nasm_nonfatal("value referenced by FAR is not relocatable"); + out_segment(data, opx); + break; + + case 0171: + c = *codes++; + op2 = (op2 & ~3) | ((c >> 3) & 3); + opx = &ins->oprs[op2]; + r = nasm_regvals[opx->basereg]; + c = (c & ~070) | ((r & 7) << 3); + out_rawbyte(data, c); + break; + + case 0172: + { + int mask = ins->prefixes[PPS_REX] == P_EVEX ? 7 : 15; + const struct operand *opy; + + c = *codes++; + opx = &ins->oprs[c >> 3]; + opy = &ins->oprs[c & 7]; + if (!absolute_op(opy)) + nasm_nonfatal("non-absolute expression not permitted " + "as argument %d", c & 7); + else if (opy->offset & ~mask) + nasm_warn(ERR_PASS2|WARN_NUMBER_OVERFLOW, + "is4 argument exceeds bounds"); + c = opy->offset & mask; + goto emit_is4; + } + + case 0173: + c = *codes++; + opx = &ins->oprs[c >> 4]; + c &= 15; + goto emit_is4; + + case4(0174): + c = 0; + emit_is4: + r = nasm_regvals[opx->basereg]; + out_rawbyte(data, (r << 4) | ((r & 0x10) >> 1) | c); + break; + + case4(0254): + if (absolute_op(opx) && + (int32_t)opx->offset != (int64_t)opx->offset) { + nasm_warn(ERR_PASS2|WARN_NUMBER_OVERFLOW, + "signed dword immediate exceeds bounds"); + } + out_imm(data, opx, 4, OUT_SIGNED); + break; + + case4(0240): + case 0250: + codes += 3; + ins->evex_p[2] |= op_evexflags(&ins->oprs[0], + EVEX_P2Z | EVEX_P2AAA, 2); + ins->evex_p[2] ^= EVEX_P2VP; /* 1's complement */ + bytes[0] = 0x62; + /* EVEX.X can be set by either REX or EVEX for different reasons */ + bytes[1] = ((((ins->rex & 7) << 5) | + (ins->evex_p[0] & (EVEX_P0X | EVEX_P0RP))) ^ 0xf0) | + (ins->vex_cm & EVEX_P0MM); + bytes[2] = ((ins->rex & REX_W) << (7 - 3)) | + ((~ins->vexreg & 15) << 3) | + (1 << 2) | (ins->vex_wlp & 3); + bytes[3] = ins->evex_p[2]; + out_rawdata(data, bytes, 4); + break; + + case4(0260): + case 0270: + codes += 2; + if (ins->vex_cm != 1 || (ins->rex & (REX_W|REX_X|REX_B)) || + ins->prefixes[PPS_REX] == P_VEX3) { + bytes[0] = (ins->vex_cm >> 6) ? 0x8f : 0xc4; + bytes[1] = (ins->vex_cm & 31) | ((~ins->rex & 7) << 5); + bytes[2] = ((ins->rex & REX_W) << (7-3)) | + ((~ins->vexreg & 15)<< 3) | (ins->vex_wlp & 07); + out_rawdata(data, bytes, 3); + } else { + bytes[0] = 0xc5; + bytes[1] = ((~ins->rex & REX_R) << (7-2)) | + ((~ins->vexreg & 15) << 3) | (ins->vex_wlp & 07); + out_rawdata(data, bytes, 2); + } + break; + + case 0271: + case 0272: + case 0273: + break; + + case4(0274): + { + uint64_t uv, um; + int s; + + if (absolute_op(opx)) { + if (ins->rex & REX_W) + s = 64; + else if (ins->prefixes[PPS_OSIZE] == P_O16) + s = 16; + else if (ins->prefixes[PPS_OSIZE] == P_O32) + s = 32; + else + s = bits; + + um = (uint64_t)2 << (s-1); + uv = opx->offset; + + if (uv > 127 && uv < (uint64_t)-128 && + (uv < um-128 || uv > um-1)) { + /* If this wasn't explicitly byte-sized, warn as though we + * had fallen through to the imm16/32/64 case. + */ + nasm_warn(ERR_PASS2|WARN_NUMBER_OVERFLOW, + "%s value exceeds bounds", + (opx->type & BITS8) ? "signed byte" : + s == 16 ? "word" : + s == 32 ? "dword" : + "signed dword"); + } + + /* Output as a raw byte to avoid byte overflow check */ + out_rawbyte(data, (uint8_t)uv); + } else { + out_imm(data, opx, 1, OUT_WRAP); /* XXX: OUT_SIGNED? */ + } + break; + } + + case4(0300): + break; + + case 0310: + if (bits == 32 && !has_prefix(ins, PPS_ASIZE, P_A16)) + out_rawbyte(data, 0x67); + break; + + case 0311: + if (bits != 32 && !has_prefix(ins, PPS_ASIZE, P_A32)) + out_rawbyte(data, 0x67); + break; + + case 0312: + break; + + case 0313: + break; + + case4(0314): + break; + + case 0320: + case 0321: + break; + + case 0322: + case 0323: + break; + + case 0324: + ins->rex |= REX_W; + break; + + case 0325: + break; + + case 0326: + break; + + case 0331: + break; + + case 0332: + case 0333: + out_rawbyte(data, c - 0332 + 0xF2); + break; + + case 0334: + if (ins->rex & REX_R) + out_rawbyte(data, 0xF0); + ins->rex &= ~(REX_L|REX_R); + break; + + case 0335: + break; + + case 0336: + case 0337: + break; + + case 0340: + if (ins->oprs[0].segment != NO_SEG) + nasm_panic("non-constant BSS size in pass two"); + + out_reserve(data, ins->oprs[0].offset * resb_bytes(ins->opcode)); + break; + + case 0341: + break; + + case 0360: + break; + + case 0361: + out_rawbyte(data, 0x66); + break; + + case 0364: + case 0365: + break; + + case 0366: + case 0367: + out_rawbyte(data, c - 0366 + 0x66); + break; + + case3(0370): + break; + + case 0373: + out_rawbyte(data, bits == 16 ? 3 : 5); + break; + + case 0374: + eat = EA_XMMVSIB; + break; + + case 0375: + eat = EA_YMMVSIB; + break; + + case 0376: + eat = EA_ZMMVSIB; + break; + + case4(0100): + case4(0110): + case4(0120): + case4(0130): + case4(0200): + case4(0204): + case4(0210): + case4(0214): + case4(0220): + case4(0224): + case4(0230): + case4(0234): + { + ea ea_data; + int rfield; + opflags_t rflags; + uint8_t *p; + struct operand *opy = &ins->oprs[op2]; + + if (c <= 0177) { + /* pick rfield from operand b (opx) */ + rflags = regflag(opx); + rfield = nasm_regvals[opx->basereg]; + } else { + /* rfield is constant */ + rflags = 0; + rfield = c & 7; + } + + if (process_ea(opy, &ea_data, bits, + rfield, rflags, ins, eat, &errmsg)) + nasm_nonfatal("%s", errmsg); + + p = bytes; + *p++ = ea_data.modrm; + if (ea_data.sib_present) + *p++ = ea_data.sib; + out_rawdata(data, bytes, p - bytes); + + /* + * Make sure the address gets the right offset in case + * the line breaks in the .lst file (BR 1197827) + */ + + if (ea_data.bytes) { + /* use compressed displacement, if available */ + if (ea_data.disp8) { + out_rawbyte(data, ea_data.disp8); + } else if (ea_data.rip) { + out_reladdr(data, opy, ea_data.bytes); + } else { + int asize = ins->addr_size >> 3; + + if (overflow_general(opy->offset, asize) || + signed_bits(opy->offset, ins->addr_size) != + signed_bits(opy->offset, ea_data.bytes << 3)) + warn_overflow(ea_data.bytes); + + out_imm(data, opy, ea_data.bytes, + (asize > ea_data.bytes) + ? OUT_SIGNED : OUT_WRAP); + } + } + } + break; + + default: + nasm_panic("internal instruction table corrupt" + ": instruction code \\%o (0x%02X) given", c, c); + break; + } + } +} + +static opflags_t regflag(const operand * o) +{ + if (!is_register(o->basereg)) + nasm_panic("invalid operand passed to regflag()"); + return nasm_reg_flags[o->basereg]; +} + +static int32_t regval(const operand * o) +{ + if (!is_register(o->basereg)) + nasm_panic("invalid operand passed to regval()"); + return nasm_regvals[o->basereg]; +} + +static int op_rexflags(const operand * o, int mask) +{ + opflags_t flags; + int val; + + if (!is_register(o->basereg)) + nasm_panic("invalid operand passed to op_rexflags()"); + + flags = nasm_reg_flags[o->basereg]; + val = nasm_regvals[o->basereg]; + + return rexflags(val, flags, mask); +} + +static int rexflags(int val, opflags_t flags, int mask) +{ + int rex = 0; + + if (val >= 0 && (val & 8)) + rex |= REX_B|REX_X|REX_R; + if (flags & BITS64) + rex |= REX_W; + if (!(REG_HIGH & ~flags)) /* AH, CH, DH, BH */ + rex |= REX_H; + else if (!(REG8 & ~flags) && val >= 4) /* SPL, BPL, SIL, DIL */ + rex |= REX_P; + + return rex & mask; +} + +static int evexflags(int val, decoflags_t deco, + int mask, uint8_t byte) +{ + int evex = 0; + + switch (byte) { + case 0: + if (val >= 0 && (val & 16)) + evex |= (EVEX_P0RP | EVEX_P0X); + break; + case 2: + if (val >= 0 && (val & 16)) + evex |= EVEX_P2VP; + if (deco & Z) + evex |= EVEX_P2Z; + if (deco & OPMASK_MASK) + evex |= deco & EVEX_P2AAA; + break; + } + return evex & mask; +} + +static int op_evexflags(const operand * o, int mask, uint8_t byte) +{ + int val; + + val = nasm_regvals[o->basereg]; + + return evexflags(val, o->decoflags, mask, byte); +} + +static enum match_result find_match(const struct itemplate **tempp, + insn *instruction, + int32_t segment, int64_t offset, int bits) +{ + const struct itemplate *temp; + enum match_result m, merr; + opflags_t xsizeflags[MAX_OPERANDS]; + bool opsizemissing = false; + int8_t broadcast = instruction->evex_brerop; + int i; + + /* broadcasting uses a different data element size */ + for (i = 0; i < instruction->operands; i++) { + if (i == broadcast) + xsizeflags[i] = instruction->oprs[i].decoflags & BRSIZE_MASK; + else + xsizeflags[i] = instruction->oprs[i].type & SIZE_MASK; + } + + merr = MERR_INVALOP; + + for (temp = nasm_instructions[instruction->opcode]; + temp->opcode != I_none; temp++) { + m = matches(temp, instruction, bits); + if (m == MOK_JUMP) { + if (jmp_match(segment, offset, bits, instruction, temp)) + m = MOK_GOOD; + else + m = MERR_INVALOP; + } else if (m == MERR_OPSIZEMISSING && !itemp_has(temp, IF_SX)) { + /* + * Missing operand size and a candidate for fuzzy matching... + */ + for (i = 0; i < temp->operands; i++) + if (i == broadcast) + xsizeflags[i] |= temp->deco[i] & BRSIZE_MASK; + else + xsizeflags[i] |= temp->opd[i] & SIZE_MASK; + opsizemissing = true; + } + if (m > merr) + merr = m; + if (merr == MOK_GOOD) + goto done; + } + + /* No match, but see if we can get a fuzzy operand size match... */ + if (!opsizemissing) + goto done; + + for (i = 0; i < instruction->operands; i++) { + /* + * We ignore extrinsic operand sizes on registers, so we should + * never try to fuzzy-match on them. This also resolves the case + * when we have e.g. "xmmrm128" in two different positions. + */ + if (is_class(REGISTER, instruction->oprs[i].type)) + continue; + + /* This tests if xsizeflags[i] has more than one bit set */ + if ((xsizeflags[i] & (xsizeflags[i]-1))) + goto done; /* No luck */ + + if (i == broadcast) { + instruction->oprs[i].decoflags |= xsizeflags[i]; + instruction->oprs[i].type |= brsize_to_size(xsizeflags[i]); + } else { + instruction->oprs[i].type |= xsizeflags[i]; /* Set the size */ + } + } + + /* Try matching again... */ + for (temp = nasm_instructions[instruction->opcode]; + temp->opcode != I_none; temp++) { + m = matches(temp, instruction, bits); + if (m == MOK_JUMP) { + if (jmp_match(segment, offset, bits, instruction, temp)) + m = MOK_GOOD; + else + m = MERR_INVALOP; + } + if (m > merr) + merr = m; + if (merr == MOK_GOOD) + goto done; + } + +done: + *tempp = temp; + return merr; +} + +static uint8_t get_broadcast_num(opflags_t opflags, opflags_t brsize) +{ + unsigned int opsize = (opflags & SIZE_MASK) >> SIZE_SHIFT; + uint8_t brcast_num; + + if (brsize > BITS64) + nasm_fatal("size of broadcasting element is greater than 64 bits"); + + /* + * The shift term is to take care of the extra BITS80 inserted + * between BITS64 and BITS128. + */ + brcast_num = ((opsize / (BITS64 >> SIZE_SHIFT)) * (BITS64 / brsize)) + >> (opsize > (BITS64 >> SIZE_SHIFT)); + + return brcast_num; +} + +static enum match_result matches(const struct itemplate *itemp, + insn *instruction, int bits) +{ + opflags_t size[MAX_OPERANDS], asize; + bool opsizemissing = false; + int i, oprs; + + /* + * Check the opcode + */ + if (itemp->opcode != instruction->opcode) + return MERR_INVALOP; + + /* + * Count the operands + */ + if (itemp->operands != instruction->operands) + return MERR_INVALOP; + + /* + * Is it legal? + */ + if (!(optimizing.level > 0) && itemp_has(itemp, IF_OPT)) + return MERR_INVALOP; + + /* + * {rex/vexn/evex} available? + */ + switch (instruction->prefixes[PPS_REX]) { + case P_EVEX: + if (!itemp_has(itemp, IF_EVEX)) + return MERR_ENCMISMATCH; + break; + case P_VEX: + case P_VEX3: + case P_VEX2: + if (!itemp_has(itemp, IF_VEX)) + return MERR_ENCMISMATCH; + break; + case P_REX: + if (itemp_has(itemp, IF_VEX) || itemp_has(itemp, IF_EVEX) || + bits != 64) + return MERR_ENCMISMATCH; + break; + default: + if (itemp_has(itemp, IF_EVEX)) { + if (!iflag_test(&cpu, IF_EVEX)) + return MERR_ENCMISMATCH; + } else if (itemp_has(itemp, IF_VEX)) { + if (!iflag_test(&cpu, IF_VEX)) { + return MERR_ENCMISMATCH; + } else if (itemp_has(itemp, IF_LATEVEX)) { + if (!iflag_test(&cpu, IF_LATEVEX) && iflag_test(&cpu, IF_EVEX)) + return MERR_ENCMISMATCH; + } + } + break; + } + + /* + * Check that no spurious colons or TOs are present + */ + for (i = 0; i < itemp->operands; i++) + if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO)) + return MERR_INVALOP; + + /* + * Process size flags + */ + switch (itemp_smask(itemp)) { + case IF_GENBIT(IF_SB): + asize = BITS8; + break; + case IF_GENBIT(IF_SW): + asize = BITS16; + break; + case IF_GENBIT(IF_SD): + asize = BITS32; + break; + case IF_GENBIT(IF_SQ): + asize = BITS64; + break; + case IF_GENBIT(IF_SO): + asize = BITS128; + break; + case IF_GENBIT(IF_SY): + asize = BITS256; + break; + case IF_GENBIT(IF_SZ): + asize = BITS512; + break; + case IF_GENBIT(IF_ANYSIZE): + asize = SIZE_MASK; + break; + case IF_GENBIT(IF_SIZE): + switch (bits) { + case 16: + asize = BITS16; + break; + case 32: + asize = BITS32; + break; + case 64: + asize = BITS64; + break; + default: + asize = 0; + break; + } + break; + default: + asize = 0; + break; + } + + if (itemp_armask(itemp)) { + /* S- flags only apply to a specific operand */ + i = itemp_arg(itemp); + memset(size, 0, sizeof size); + size[i] = asize; + } else { + /* S- flags apply to all operands */ + for (i = 0; i < MAX_OPERANDS; i++) + size[i] = asize; + } + + /* + * Check that the operand flags all match up, + * it's a bit tricky so lets be verbose: + * + * 1) Find out the size of operand. If instruction + * doesn't have one specified -- we're trying to + * guess it either from template (IF_S* flag) or + * from code bits. + * + * 2) If template operand do not match the instruction OR + * template has an operand size specified AND this size differ + * from which instruction has (perhaps we got it from code bits) + * we are: + * a) Check that only size of instruction and operand is differ + * other characteristics do match + * b) Perhaps it's a register specified in instruction so + * for such a case we just mark that operand as "size + * missing" and this will turn on fuzzy operand size + * logic facility (handled by a caller) + */ + for (i = 0; i < itemp->operands; i++) { + opflags_t type = instruction->oprs[i].type; + decoflags_t deco = instruction->oprs[i].decoflags; + decoflags_t ideco = itemp->deco[i]; + bool is_broadcast = deco & BRDCAST_MASK; + uint8_t brcast_num = 0; + opflags_t template_opsize, insn_opsize; + + if (!(type & SIZE_MASK)) + type |= size[i]; + + insn_opsize = type & SIZE_MASK; + if (!is_broadcast) { + template_opsize = itemp->opd[i] & SIZE_MASK; + } else { + decoflags_t deco_brsize = ideco & BRSIZE_MASK; + + if (~ideco & BRDCAST_MASK) + return MERR_BRNOTHERE; + + /* + * when broadcasting, the element size depends on + * the instruction type. decorator flag should match. + */ + if (deco_brsize) { + template_opsize = brsize_to_size(deco_brsize); + /* calculate the proper number : {1to<brcast_num>} */ + brcast_num = get_broadcast_num(itemp->opd[i], template_opsize); + } else { + template_opsize = 0; + } + } + + if (~ideco & deco & OPMASK_MASK) + return MERR_MASKNOTHERE; + + if (~ideco & deco & (Z_MASK|STATICRND_MASK|SAE_MASK)) + return MERR_DECONOTHERE; + + if (itemp->opd[i] & ~type & ~(SIZE_MASK|REGSET_MASK)) + return MERR_INVALOP; + + if (~itemp->opd[i] & type & REGSET_MASK) + return (itemp->opd[i] & REGSET_MASK) + ? MERR_REGSETSIZE : MERR_REGSET; + + if (template_opsize) { + if (template_opsize != insn_opsize) { + if (insn_opsize) { + return MERR_INVALOP; + } else if (!is_class(REGISTER, type)) { + /* + * Note: we don't honor extrinsic operand sizes for registers, + * so "missing operand size" for a register should be + * considered a wildcard match rather than an error. + */ + opsizemissing = true; + } else if (is_class(REG_HIGH, type) && + instruction->prefixes[PPS_REX]) { + return MERR_ENCMISMATCH; + } + } else if (is_broadcast && + (brcast_num != + (2U << ((deco & BRNUM_MASK) >> BRNUM_SHIFT)))) { + /* + * broadcasting opsize matches but the number of repeated memory + * element does not match. + * if 64b double precision float is broadcasted to ymm (256b), + * broadcasting decorator must be {1to4}. + */ + return MERR_BRNUMMISMATCH; + } + } + } + + if (opsizemissing) + return MERR_OPSIZEMISSING; + + /* + * Check operand sizes + */ + if (itemp_has(itemp, IF_SM) || itemp_has(itemp, IF_SM2)) { + oprs = (itemp_has(itemp, IF_SM2) ? 2 : itemp->operands); + for (i = 0; i < oprs; i++) { + asize = itemp->opd[i] & SIZE_MASK; + if (asize) { + for (i = 0; i < oprs; i++) + size[i] = asize; + break; + } + } + } else { + oprs = itemp->operands; + } + + for (i = 0; i < itemp->operands; i++) { + if (!(itemp->opd[i] & SIZE_MASK) && + (instruction->oprs[i].type & SIZE_MASK & ~size[i])) + return MERR_OPSIZEMISMATCH; + } + + /* + * Check template is okay at the set cpu level + */ + if (iflag_cmp_cpu_level(&insns_flags[itemp->iflag_idx], &cpu) > 0) + return MERR_BADCPU; + + /* + * Verify the appropriate long mode flag. + */ + if (itemp_has(itemp, (bits == 64 ? IF_NOLONG : IF_LONG))) + return MERR_BADMODE; + + /* + * If we have a HLE prefix, look for the NOHLE flag + */ + if (itemp_has(itemp, IF_NOHLE) && + (has_prefix(instruction, PPS_REP, P_XACQUIRE) || + has_prefix(instruction, PPS_REP, P_XRELEASE))) + return MERR_BADHLE; + + /* + * Check if special handling needed for Jumps + */ + if ((itemp->code[0] & ~1) == 0370) + return MOK_JUMP; + + /* + * Check if BND prefix is allowed. + * Other 0xF2 (REPNE/REPNZ) prefix is prohibited. + */ + if (!itemp_has(itemp, IF_BND) && + (has_prefix(instruction, PPS_REP, P_BND) || + has_prefix(instruction, PPS_REP, P_NOBND))) + return MERR_BADBND; + else if (itemp_has(itemp, IF_BND) && + (has_prefix(instruction, PPS_REP, P_REPNE) || + has_prefix(instruction, PPS_REP, P_REPNZ))) + return MERR_BADREPNE; + + return MOK_GOOD; +} + +/* + * Check if ModR/M.mod should/can be 01. + * - EAF_BYTEOFFS is set + * - offset can fit in a byte when EVEX is not used + * - offset can be compressed when EVEX is used + */ +#define IS_MOD_01() (!(input->eaflags & EAF_WORDOFFS) && \ + (ins->rex & REX_EV ? seg == NO_SEG && !forw_ref && \ + is_disp8n(input, ins, &output->disp8) : \ + input->eaflags & EAF_BYTEOFFS || (o >= -128 && \ + o <= 127 && seg == NO_SEG && !forw_ref))) + +static int process_ea(operand *input, ea *output, int bits, + int rfield, opflags_t rflags, insn *ins, + enum ea_type expected, const char **errmsgp) +{ + bool forw_ref = !!(input->opflags & OPFLAG_UNKNOWN); + const int addrbits = ins->addr_size; + const int eaflags = input->eaflags; + const char *errmsg = NULL; + + errmsg = NULL; + + output->type = EA_SCALAR; + output->rip = false; + output->disp8 = 0; + + /* REX flags for the rfield operand */ + output->rex |= rexflags(rfield, rflags, REX_R | REX_P | REX_W | REX_H); + /* EVEX.R' flag for the REG operand */ + ins->evex_p[0] |= evexflags(rfield, 0, EVEX_P0RP, 0); + + if (is_class(REGISTER, input->type)) { + /* + * It's a direct register. + */ + if (!is_register(input->basereg)) + goto err; + + if (!is_reg_class(REG_EA, input->basereg)) + goto err; + + /* broadcasting is not available with a direct register operand. */ + if (input->decoflags & BRDCAST_MASK) { + errmsg = "broadcast not allowed with register operand"; + goto err; + } + + output->rex |= op_rexflags(input, REX_B | REX_P | REX_W | REX_H); + ins->evex_p[0] |= op_evexflags(input, EVEX_P0X, 0); + output->sib_present = false; /* no SIB necessary */ + output->bytes = 0; /* no offset necessary either */ + output->modrm = GEN_MODRM(3, rfield, nasm_regvals[input->basereg]); + } else { + /* + * It's a memory reference. + */ + + /* Embedded rounding or SAE is not available with a mem ref operand. */ + if (input->decoflags & (ER | SAE)) { + errmsg = "embedded rounding is available only with " + "register-register operations"; + goto err; + } + + if (input->basereg == -1 && + (input->indexreg == -1 || input->scale == 0)) { + /* + * It's a pure offset. If it is an IMMEDIATE, it is a pattern + * in insns.dat which allows an immediate to be used as a memory + * address, in which case apply the default REL/ABS. + */ + if (bits == 64) { + if (is_class(IMMEDIATE, input->type)) { + if (!(input->eaflags & EAF_ABS) && + ((input->eaflags & EAF_REL) || globalrel)) + input->type |= IP_REL; + } + if ((input->type & IP_REL) == IP_REL) { + /*! + *!ea-absolute [on] absolute address cannot be RIP-relative + *! warns that an address that is inherently absolute cannot + *! be generated with RIP-relative encoding using \c{REL}, + *! see \k{REL & ABS}. + */ + if (input->segment == NO_SEG || + (input->opflags & OPFLAG_RELATIVE)) { + nasm_warn(WARN_EA_ABSOLUTE|ERR_PASS2, + "absolute address can not be RIP-relative"); + input->type &= ~IP_REL; + input->type |= MEMORY; + } + } + } + + if (bits == 64 && !(IP_REL & ~input->type) && (eaflags & EAF_SIB)) { + errmsg = "instruction requires SIB encoding, cannot be RIP-relative"; + goto err; + } + + if (eaflags & EAF_BYTEOFFS || + (eaflags & EAF_WORDOFFS && + input->disp_size != (addrbits != 16 ? 32 : 16))) { + /*! + *!ea-dispsize [on] displacement size ignored on absolute address + *! warns that NASM does not support generating displacements for + *! inherently absolute addresses that do not match the address size + *! of the instruction. + */ + nasm_warn(WARN_EA_DISPSIZE, "displacement size ignored on absolute address"); + } + + if ((eaflags & EAF_SIB) || (bits == 64 && (~input->type & IP_REL))) { + output->sib_present = true; + output->sib = GEN_SIB(0, 4, 5); + output->bytes = 4; + output->modrm = GEN_MODRM(0, rfield, 4); + output->rip = false; + } else { + output->sib_present = false; + output->bytes = (addrbits != 16 ? 4 : 2); + output->modrm = GEN_MODRM(0, rfield, + (addrbits != 16 ? 5 : 6)); + output->rip = bits == 64; + } + } else { + /* + * It's an indirection. + */ + int i = input->indexreg, b = input->basereg, s = input->scale; + int32_t seg = input->segment; + int hb = input->hintbase, ht = input->hinttype; + int t, it, bt; /* register numbers */ + opflags_t x, ix, bx; /* register flags */ + + if (s == 0) + i = -1; /* make this easy, at least */ + + if (is_register(i)) { + it = nasm_regvals[i]; + ix = nasm_reg_flags[i]; + } else { + it = -1; + ix = 0; + } + + if (is_register(b)) { + bt = nasm_regvals[b]; + bx = nasm_reg_flags[b]; + } else { + bt = -1; + bx = 0; + } + + /* if either one are a vector register... */ + if ((ix|bx) & (XMMREG|YMMREG|ZMMREG) & ~REG_EA) { + opflags_t sok = BITS32 | BITS64; + int32_t o = input->offset; + int mod, scale, index, base; + + /* + * For a vector SIB, one has to be a vector and the other, + * if present, a GPR. The vector must be the index operand. + */ + if (it == -1 || (bx & (XMMREG|YMMREG|ZMMREG) & ~REG_EA)) { + if (s == 0) + s = 1; + else if (s != 1) + goto err; + + t = bt, bt = it, it = t; + x = bx, bx = ix, ix = x; + } + + if (bt != -1) { + if (REG_GPR & ~bx) + goto err; + if (!(REG64 & ~bx) || !(REG32 & ~bx)) + sok &= bx; + else + goto err; + } + + /* + * While we're here, ensure the user didn't specify + * WORD or QWORD + */ + if (input->disp_size == 16 || input->disp_size == 64) + goto err; + + if (addrbits == 16 || + (addrbits == 32 && !(sok & BITS32)) || + (addrbits == 64 && !(sok & BITS64))) + goto err; + + output->type = ((ix & ZMMREG & ~REG_EA) ? EA_ZMMVSIB + : ((ix & YMMREG & ~REG_EA) + ? EA_YMMVSIB : EA_XMMVSIB)); + + output->rex |= rexflags(it, ix, REX_X); + output->rex |= rexflags(bt, bx, REX_B); + ins->evex_p[2] |= evexflags(it, 0, EVEX_P2VP, 2); + + index = it & 7; /* it is known to be != -1 */ + + switch (s) { + case 1: + scale = 0; + break; + case 2: + scale = 1; + break; + case 4: + scale = 2; + break; + case 8: + scale = 3; + break; + default: /* then what the smeg is it? */ + goto err; /* panic */ + } + + if (bt == -1) { + base = 5; + mod = 0; + } else { + base = (bt & 7); + if (base != REG_NUM_EBP && o == 0 && + seg == NO_SEG && !forw_ref && + !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS))) + mod = 0; + else if (IS_MOD_01()) + mod = 1; + else + mod = 2; + } + + output->sib_present = true; + output->bytes = (bt == -1 || mod == 2 ? 4 : mod); + output->modrm = GEN_MODRM(mod, rfield, 4); + output->sib = GEN_SIB(scale, index, base); + } else if ((ix|bx) & (BITS32|BITS64)) { + /* + * it must be a 32/64-bit memory reference. Firstly we have + * to check that all registers involved are type E/Rxx. + */ + opflags_t sok = BITS32 | BITS64; + int32_t o = input->offset; + + if (it != -1) { + if (!(REG64 & ~ix) || !(REG32 & ~ix)) + sok &= ix; + else + goto err; + } + + if (bt != -1) { + if (REG_GPR & ~bx) + goto err; /* Invalid register */ + if (~sok & bx & SIZE_MASK) + goto err; /* Invalid size */ + sok &= bx; + } + + /* + * While we're here, ensure the user didn't specify + * WORD or QWORD + */ + if (input->disp_size == 16 || input->disp_size == 64) + goto err; + + if (addrbits == 16 || + (addrbits == 32 && !(sok & BITS32)) || + (addrbits == 64 && !(sok & BITS64))) + goto err; + + /* now reorganize base/index */ + if (s == 1 && bt != it && bt != -1 && it != -1 && + ((hb == b && ht == EAH_NOTBASE) || + (hb == i && ht == EAH_MAKEBASE))) { + /* swap if hints say so */ + t = bt, bt = it, it = t; + x = bx, bx = ix, ix = x; + } + + if (bt == -1 && s == 1 && !(hb == i && ht == EAH_NOTBASE)) { + /* make single reg base, unless hint */ + bt = it, bx = ix, it = -1, ix = 0; + } + if (eaflags & EAF_MIB) { + /* MIB/split-SIB encoding */ + if (it == -1 && (hb == b && ht == EAH_NOTBASE)) { + /* + * make a single reg index [reg*1]. + * gas uses this form for an explicit index register. + */ + it = bt, ix = bx, bt = -1, bx = 0, s = 1; + } + if ((ht == EAH_SUMMED) && bt == -1) { + /* separate once summed index into [base, index] */ + bt = it, bx = ix, s--; + } + } else { + if (((s == 2 && it != REG_NUM_ESP && + (!(eaflags & EAF_TIMESTWO) || (ht == EAH_SUMMED))) || + s == 3 || s == 5 || s == 9) && bt == -1) { + /* convert 3*EAX to EAX+2*EAX */ + bt = it, bx = ix, s--; + } + if (it == -1 && (bt & 7) != REG_NUM_ESP && + (eaflags & EAF_TIMESTWO) && + (hb == b && ht == EAH_NOTBASE)) { + /* + * convert [NOSPLIT EAX*1] + * to sib format with 0x0 displacement - [EAX*1+0]. + */ + it = bt, ix = bx, bt = -1, bx = 0, s = 1; + } + } + if (s == 1 && it == REG_NUM_ESP) { + /* swap ESP into base if scale is 1 */ + t = it, it = bt, bt = t; + x = ix, ix = bx, bx = x; + } + if (it == REG_NUM_ESP || + (s != 1 && s != 2 && s != 4 && s != 8 && it != -1)) + goto err; /* wrong, for various reasons */ + + output->rex |= rexflags(it, ix, REX_X); + output->rex |= rexflags(bt, bx, REX_B); + + if (it == -1 && (bt & 7) != REG_NUM_ESP && !(eaflags & EAF_SIB)) { + /* no SIB needed */ + int mod, rm; + + if (bt == -1) { + rm = 5; + mod = 0; + } else { + rm = (bt & 7); + if (rm != REG_NUM_EBP && o == 0 && + seg == NO_SEG && !forw_ref && + !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS))) + mod = 0; + else if (IS_MOD_01()) + mod = 1; + else + mod = 2; + } + + output->sib_present = false; + output->bytes = (bt == -1 || mod == 2 ? 4 : mod); + output->modrm = GEN_MODRM(mod, rfield, rm); + } else { + /* we need a SIB */ + int mod, scale, index, base; + + if (it == -1) + index = 4, s = 1; + else + index = (it & 7); + + switch (s) { + case 1: + scale = 0; + break; + case 2: + scale = 1; + break; + case 4: + scale = 2; + break; + case 8: + scale = 3; + break; + default: /* then what the smeg is it? */ + goto err; /* panic */ + } + + if (bt == -1) { + base = 5; + mod = 0; + } else { + base = (bt & 7); + if (base != REG_NUM_EBP && o == 0 && + seg == NO_SEG && !forw_ref && + !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS))) + mod = 0; + else if (IS_MOD_01()) + mod = 1; + else + mod = 2; + } + + output->sib_present = true; + output->bytes = (bt == -1 || mod == 2 ? 4 : mod); + output->modrm = GEN_MODRM(mod, rfield, 4); + output->sib = GEN_SIB(scale, index, base); + } + } else { /* it's 16-bit */ + int mod, rm; + int16_t o = input->offset; + + /* check for 64-bit long mode */ + if (addrbits == 64) + goto err; + + /* check all registers are BX, BP, SI or DI */ + if ((b != -1 && b != R_BP && b != R_BX && b != R_SI && b != R_DI) || + (i != -1 && i != R_BP && i != R_BX && i != R_SI && i != R_DI)) + goto err; + + /* ensure the user didn't specify DWORD/QWORD */ + if (input->disp_size == 32 || input->disp_size == 64) + goto err; + + if (s != 1 && i != -1) + goto err; /* no can do, in 16-bit EA */ + if (b == -1 && i != -1) { + int tmp = b; + b = i; + i = tmp; + } /* swap */ + if ((b == R_SI || b == R_DI) && i != -1) { + int tmp = b; + b = i; + i = tmp; + } + /* have BX/BP as base, SI/DI index */ + if (b == i) + goto err; /* shouldn't ever happen, in theory */ + if (i != -1 && b != -1 && + (i == R_BP || i == R_BX || b == R_SI || b == R_DI)) + goto err; /* invalid combinations */ + if (b == -1) /* pure offset: handled above */ + goto err; /* so if it gets to here, panic! */ + + rm = -1; + if (i != -1) + switch (i * 256 + b) { + case R_SI * 256 + R_BX: + rm = 0; + break; + case R_DI * 256 + R_BX: + rm = 1; + break; + case R_SI * 256 + R_BP: + rm = 2; + break; + case R_DI * 256 + R_BP: + rm = 3; + break; + } else + switch (b) { + case R_SI: + rm = 4; + break; + case R_DI: + rm = 5; + break; + case R_BP: + rm = 6; + break; + case R_BX: + rm = 7; + break; + } + if (rm == -1) /* can't happen, in theory */ + goto err; /* so panic if it does */ + + if (o == 0 && seg == NO_SEG && !forw_ref && rm != 6 && + !(eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS))) + mod = 0; + else if (IS_MOD_01()) + mod = 1; + else + mod = 2; + + output->sib_present = false; /* no SIB - it's 16-bit */ + output->bytes = mod; /* bytes of offset needed */ + output->modrm = GEN_MODRM(mod, rfield, rm); + } + + if (eaflags & EAF_REL) { + /* Explicit REL reference with indirect memory */ + nasm_warn(WARN_OTHER, + "indirect address displacements cannot be RIP-relative"); + } + } + } + + output->size = 1 + output->sib_present + output->bytes; + /* + * The type parsed might not match one supplied by + * a caller. In this case exit with error and let + * the caller to decide how critical it is. + */ + if (output->type != expected) + goto err_set_msg; + + return 0; + +err_set_msg: + if (!errmsg) { + /* Default error message */ + static char invalid_address_msg[40]; + snprintf(invalid_address_msg, sizeof invalid_address_msg, + "invalid %d-bit effective address", bits); + errmsg = invalid_address_msg; + } + *errmsgp = errmsg; + return -1; + +err: + output->type = EA_INVALID; + goto err_set_msg; +} + +static void add_asp(insn *ins, int addrbits) +{ + int j, valid; + int defdisp; + + valid = (addrbits == 64) ? 64|32 : 32|16; + + switch (ins->prefixes[PPS_ASIZE]) { + case P_A16: + valid &= 16; + break; + case P_A32: + valid &= 32; + break; + case P_A64: + valid &= 64; + break; + case P_ASP: + valid &= (addrbits == 32) ? 16 : 32; + break; + default: + break; + } + + for (j = 0; j < ins->operands; j++) { + if (is_class(MEMORY, ins->oprs[j].type)) { + opflags_t i, b; + + /* Verify as Register */ + if (!is_register(ins->oprs[j].indexreg)) + i = 0; + else + i = nasm_reg_flags[ins->oprs[j].indexreg]; + + /* Verify as Register */ + if (!is_register(ins->oprs[j].basereg)) + b = 0; + else + b = nasm_reg_flags[ins->oprs[j].basereg]; + + if (ins->oprs[j].scale == 0) + i = 0; + + if (!i && !b) { + int ds = ins->oprs[j].disp_size; + if ((addrbits != 64 && ds > 8) || + (addrbits == 64 && ds == 16)) + valid &= ds; + } else { + if (!(REG16 & ~b)) + valid &= 16; + if (!(REG32 & ~b)) + valid &= 32; + if (!(REG64 & ~b)) + valid &= 64; + + if (!(REG16 & ~i)) + valid &= 16; + if (!(REG32 & ~i)) + valid &= 32; + if (!(REG64 & ~i)) + valid &= 64; + } + } + } + + if (valid & addrbits) { + ins->addr_size = addrbits; + } else if (valid & ((addrbits == 32) ? 16 : 32)) { + /* Add an address size prefix */ + ins->prefixes[PPS_ASIZE] = (addrbits == 32) ? P_A16 : P_A32;; + ins->addr_size = (addrbits == 32) ? 16 : 32; + } else { + /* Impossible... */ + nasm_nonfatal("impossible combination of address sizes"); + ins->addr_size = addrbits; /* Error recovery */ + } + + defdisp = ins->addr_size == 16 ? 16 : 32; + + for (j = 0; j < ins->operands; j++) { + if (!(MEM_OFFS & ~ins->oprs[j].type) && + (ins->oprs[j].disp_size ? ins->oprs[j].disp_size : defdisp) != ins->addr_size) { + /* + * mem_offs sizes must match the address size; if not, + * strip the MEM_OFFS bit and match only EA instructions + */ + ins->oprs[j].type &= ~(MEM_OFFS & ~MEMORY); + } + } +} diff --git a/vere/ext/nasm/asm/assemble.h b/vere/ext/nasm/asm/assemble.h new file mode 100644 index 0000000..5070662 --- /dev/null +++ b/vere/ext/nasm/asm/assemble.h @@ -0,0 +1,56 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2017 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * assemble.h - header file for stuff private to the assembler + */ + +#ifndef NASM_ASSEMBLE_H +#define NASM_ASSEMBLE_H + +#include "nasm.h" +#include "iflag.h" + +extern iflag_t cpu, cmd_cpu; +void set_cpu(const char *cpuspec); + +extern bool in_absolute; /* Are we in an absolute segment? */ +extern struct location absolute; + +int64_t insn_size(int32_t segment, int64_t offset, int bits, insn *instruction); +int64_t assemble(int32_t segment, int64_t offset, int bits, insn *instruction); + +bool process_directives(char *); +void process_pragma(char *); + +#endif diff --git a/vere/ext/nasm/asm/directbl.c b/vere/ext/nasm/asm/directbl.c new file mode 100644 index 0000000..2a1d058 --- /dev/null +++ b/vere/ext/nasm/asm/directbl.c @@ -0,0 +1,192 @@ +/* + * This file is generated from ./asm/directiv.dat + * by perfhash.pl; do not edit. + */ + +#include "directiv.h" + +const char * const directive_tbl[40] = { + "absolute", + "bits", + "common", + "cpu", + "debug", + "default", + "extern", + "float", + "global", + "static", + "list", + "section", + "segment", + "warning", + "sectalign", + "pragma", + "required", + "export", + "group", + "import", + "library", + "map", + "module", + "org", + "osabi", + "safeseh", + "uppercase", + "prefix", + "suffix", + "gprefix", + "gsuffix", + "lprefix", + "lsuffix", + "limit", + "options", + "subsections_via_symbols", + "no_dead_strip", + "maxdump", + "nodepend", + "noseclabels" +}; + +#define INVALID_HASH_ENTRY (65536/3) + +static const int16_t directive_hashvals[128] = { + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 6, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 3, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 32, + 0, + 4, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 12, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1, + INVALID_HASH_ENTRY, + 0, + 33, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 25, + 38, + 1, + 9, + INVALID_HASH_ENTRY, + 31, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -12, + 0, + INVALID_HASH_ENTRY, + 34, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 29, + INVALID_HASH_ENTRY, + 13, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 27, + INVALID_HASH_ENTRY, + 7, + 22, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 19, + INVALID_HASH_ENTRY, + 37, + 5, + -11, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 16, + 15, + 11, + INVALID_HASH_ENTRY, + 23, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 36, + 12, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 27, + INVALID_HASH_ENTRY, + 21, + 26, + 10, + 5, + 29, + 35, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 30, + INVALID_HASH_ENTRY, + 28, + 4, + INVALID_HASH_ENTRY +}; + +const struct perfect_hash directive_hash = { + UINT64_C(0x076259c3e291c26c), + UINT32_C(0x7e), + UINT32_C(40), + 3, + (D_unknown), + directive_hashvals, + directive_tbl +}; diff --git a/vere/ext/nasm/asm/directiv.c b/vere/ext/nasm/asm/directiv.c new file mode 100644 index 0000000..a4f54b4 --- /dev/null +++ b/vere/ext/nasm/asm/directiv.c @@ -0,0 +1,567 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2022 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * Parse and handle assembler directives + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "nasmlib.h" +#include "ilog2.h" +#include "error.h" +#include "floats.h" +#include "stdscan.h" +#include "preproc.h" +#include "eval.h" +#include "assemble.h" +#include "outform.h" +#include "listing.h" +#include "labels.h" +#include "iflag.h" + +struct cpunames { + const char *name; + unsigned int level; + /* Eventually a table of features */ +}; + +static void iflag_set_cpu(iflag_t *a, unsigned int lvl) +{ + a->field[0] = 0; /* Not applicable to the CPU type */ + iflag_set_all_features(a); /* All feature masking bits set for now */ + if (lvl >= IF_ANY) { + /* This is a hack for now */ + iflag_set(a, IF_LATEVEX); + } + a->field[IF_CPU_FIELD] &= ~IF_CPU_LEVEL_MASK; + iflag_set(a, lvl); +} + +void set_cpu(const char *value) +{ + const char *p; + char modifier; + const struct cpunames *cpuflag; + static const struct cpunames cpunames[] = { + { "default", IF_DEFAULT }, /* Must be first */ + { "8086", IF_8086 }, + { "186", IF_186 }, + { "286", IF_286 }, + { "386", IF_386 }, + { "486", IF_486 }, + { "586", IF_PENT }, + { "pentium", IF_PENT }, + { "pentiummmx", IF_PENT }, + { "686", IF_P6 }, + { "p6", IF_P6 }, + { "ppro", IF_P6 }, + { "pentiumpro", IF_P6 }, + { "p2", IF_P6 }, /* +MMX */ + { "pentiumii", IF_P6 }, + { "p3", IF_KATMAI }, + { "katmai", IF_KATMAI }, + { "p4", IF_WILLAMETTE }, + { "willamette", IF_WILLAMETTE }, + { "prescott", IF_PRESCOTT }, + { "x64", IF_X86_64 }, + { "x86-64", IF_X86_64 }, + { "ia64", IF_IA64 }, + { "ia-64", IF_IA64 }, + { "itanium", IF_IA64 }, + { "itanic", IF_IA64 }, + { "merced", IF_IA64 }, + { "nehalem", IF_NEHALEM }, + { "westmere", IF_WESTMERE }, + { "sandybridge", IF_SANDYBRIDGE }, + { "ivybridge", IF_FUTURE }, + { "any", IF_ANY }, + { "all", IF_ANY }, + { "latevex", IF_LATEVEX }, + { "evex", IF_EVEX }, + { "vex", IF_VEX }, + { NULL, 0 } + }; + + if (!value) { + iflag_set_cpu(&cpu, cpunames[0].level); + return; + } + + p = value; + modifier = '+'; + while (*p) { + int len = strcspn(p, " ,"); + + while (len && (*p == '+' || *p == '-' || *p == '*')) { + modifier = *p++; + len--; + if (!len && modifier == '*') + cpu = cmd_cpu; + } + + if (len) { + bool invert_flag = false; + + if (len >= 3 && !nasm_memicmp(p, "no", 2)) { + invert_flag = true; + p += 2; + len -= 2; + } + + for (cpuflag = cpunames; cpuflag->name; cpuflag++) + if (!nasm_strnicmp(p, cpuflag->name, len)) + break; + + if (!cpuflag->name) { + nasm_nonfatal("unknown CPU type or flag '%.*s'", len, p); + return; + } + + if (cpuflag->level >= IF_CPU_FIRST && cpuflag->level <= IF_ANY) { + iflag_set_cpu(&cpu, cpuflag->level); + } else { + switch (modifier) { + case '-': + invert_flag = !invert_flag; + break; + case '*': + invert_flag ^= iflag_test(&cmd_cpu, cpuflag->level); + break; + default: + break; + } + + iflag_set(&cpu, cpuflag->level); + if (invert_flag) + iflag_clear(&cpu, cpuflag->level); + } + } + p += len; + if (!*p) + break; + p++; /* Skip separator */ + } +} + +static int get_bits(const char *value) +{ + int i = atoi(value); + + switch (i) { + case 16: + break; /* Always safe */ + case 32: + if (!iflag_cpu_level_ok(&cpu, IF_386)) { + nasm_nonfatal("cannot specify 32-bit segment on processor below a 386"); + i = 16; + } + break; + case 64: + if (!iflag_cpu_level_ok(&cpu, IF_X86_64)) { + nasm_nonfatal("cannot specify 64-bit segment on processor below an x86-64"); + i = 16; + } + break; + default: + nasm_nonfatal("`%s' is not a valid segment size; must be 16, 32 or 64", + value); + i = 16; + break; + } + return i; +} + +static enum directive parse_directive_line(char **directive, char **value) +{ + char *p, *q, *buf; + + buf = nasm_skip_spaces(*directive); + + /* + * It should be enclosed in [ ]. + * XXX: we don't check there is nothing else on the remainder of the + * line, except a possible comment. + */ + if (*buf != '[') + return D_none; + q = strchr(buf, ']'); + if (!q) + return D_corrupt; + + /* + * Strip off the comments. XXX: this doesn't account for quoted + * strings inside a directive. We should really strip the + * comments in generic code, not here. While we're at it, it + * would be better to pass the backend a series of tokens instead + * of a raw string, and actually process quoted strings for it, + * like of like argv is handled in C. + */ + p = strchr(buf, ';'); + if (p) { + if (p < q) /* ouch! somewhere inside */ + return D_corrupt; + *p = '\0'; + } + + /* no brace, no trailing spaces */ + *q = '\0'; + nasm_zap_spaces_rev(--q); + + /* directive */ + p = nasm_skip_spaces(++buf); + q = nasm_skip_word(p); + if (!q) + return D_corrupt; /* sigh... no value there */ + *q = '\0'; + *directive = p; + + /* and value finally */ + p = nasm_skip_spaces(++q); + *value = p; + + return directive_find(*directive); +} + +/* + * Process a line from the assembler and try to handle it if it + * is a directive. Return true if the line was handled (including + * if it was an error), false otherwise. + */ +bool process_directives(char *directive) +{ + enum directive d; + char *value, *p, *q, *special; + struct tokenval tokval; + bool bad_param = false; + enum label_type type; + + d = parse_directive_line(&directive, &value); + + switch (d) { + case D_none: + return D_none; /* Not a directive */ + + case D_corrupt: + nasm_nonfatal("invalid directive line"); + break; + + default: /* It's a backend-specific directive */ + switch (ofmt->directive(d, value)) { + case DIRR_UNKNOWN: + goto unknown; + case DIRR_OK: + case DIRR_ERROR: + break; + case DIRR_BADPARAM: + bad_param = true; + break; + default: + panic(); + } + break; + + case D_unknown: + unknown: + nasm_nonfatal("unrecognized directive [%s]", directive); + break; + + case D_SEGMENT: /* [SEGMENT n] */ + case D_SECTION: + { + int sb = globalbits; + int32_t seg = ofmt->section(value, &sb); + + if (seg == NO_SEG) { + nasm_nonfatal("segment name `%s' not recognized", value); + } else { + globalbits = sb; + switch_segment(seg); + } + break; + } + + case D_SECTALIGN: /* [SECTALIGN n] */ + { + expr *e; + + if (*value) { + stdscan_reset(); + stdscan_set(value); + tokval.t_type = TOKEN_INVALID; + e = evaluate(stdscan, NULL, &tokval, NULL, true, NULL); + if (e) { + uint64_t align = e->value; + + if (!is_power2(e->value)) { + nasm_nonfatal("segment alignment `%s' is not power of two", + value); + } else if (align > UINT64_C(0x7fffffff)) { + /* + * FIXME: Please make some sane message here + * ofmt should have some 'check' method which + * would report segment alignment bounds. + */ + nasm_nonfatal("absurdly large segment alignment `%s' (2^%d)", + value, ilog2_64(align)); + } + + /* callee should be able to handle all details */ + if (location.segment != NO_SEG) + ofmt->sectalign(location.segment, align); + } + } + break; + } + + case D_BITS: /* [BITS bits] */ + globalbits = get_bits(value); + break; + + case D_GLOBAL: /* [GLOBAL|STATIC|EXTERN|COMMON symbol:special] */ + type = LBL_GLOBAL; + goto symdef; + case D_STATIC: + type = LBL_STATIC; + goto symdef; + case D_EXTERN: + type = LBL_EXTERN; + goto symdef; + case D_REQUIRED: + type = LBL_REQUIRED; + goto symdef; + case D_COMMON: + type = LBL_COMMON; + goto symdef; + + symdef: + { + bool validid = true; + int64_t size = 0; + char *sizestr; + bool rn_error; + + if (*value == '$') + value++; /* skip initial $ if present */ + + q = value; + if (!nasm_isidstart(*q)) { + validid = false; + } else { + q++; + while (*q && *q != ':' && !nasm_isspace(*q)) { + if (!nasm_isidchar(*q)) + validid = false; + q++; + } + } + if (!validid) { + nasm_nonfatal("identifier expected after %s, got `%s'", + directive, value); + break; + } + + if (nasm_isspace(*q)) { + *q++ = '\0'; + sizestr = q = nasm_skip_spaces(q); + q = strchr(q, ':'); + } else { + sizestr = NULL; + } + + if (q && *q == ':') { + *q++ = '\0'; + special = q; + } else { + special = NULL; + } + + if (type == LBL_COMMON) { + if (sizestr) + size = readnum(sizestr, &rn_error); + if (!sizestr || rn_error) + nasm_nonfatal("%s size specified in common declaration", + sizestr ? "invalid" : "no"); + } else if (sizestr) { + nasm_nonfatal("invalid syntax in %s declaration", directive); + } + + if (!declare_label(value, type, special)) + break; + + if (type == LBL_COMMON || type == LBL_EXTERN || type == LBL_REQUIRED) + define_label(value, 0, size, false); + + break; + } + + case D_ABSOLUTE: /* [ABSOLUTE address] */ + { + expr *e; + + stdscan_reset(); + stdscan_set(value); + tokval.t_type = TOKEN_INVALID; + e = evaluate(stdscan, NULL, &tokval, NULL, true, NULL); + if (e) { + if (!is_reloc(e)) { + nasm_nonfatal("cannot use non-relocatable expression as " + "ABSOLUTE address"); + } else { + absolute.segment = reloc_seg(e); + absolute.offset = reloc_value(e); + } + } else if (pass_first()) { + absolute.offset = 0x100; /* don't go near zero in case of / */ + } else { + nasm_nonfatal("invalid ABSOLUTE address"); + } + in_absolute = true; + location.segment = NO_SEG; + location.offset = absolute.offset; + break; + } + + case D_DEBUG: /* [DEBUG] */ + { + bool badid, overlong; + char debugid[128]; + + p = value; + q = debugid; + badid = overlong = false; + if (!nasm_isidstart(*p)) { + badid = true; + } else { + while (*p && !nasm_isspace(*p)) { + if (q >= debugid + sizeof debugid - 1) { + overlong = true; + break; + } + if (!nasm_isidchar(*p)) + badid = true; + *q++ = *p++; + } + *q = 0; + } + if (badid) { + nasm_nonfatal("identifier expected after DEBUG"); + break; + } + if (overlong) { + nasm_nonfatal("DEBUG identifier too long"); + break; + } + p = nasm_skip_spaces(p); + if (pass_final()) + dfmt->debug_directive(debugid, p); + break; + } + + case D_WARNING: /* [WARNING {push|pop|{+|-|*}warn-name}] */ + value = nasm_skip_spaces(value); + if ((*value | 0x20) == 'p') { + if (!nasm_stricmp(value, "push")) + push_warnings(); + else if (!nasm_stricmp(value, "pop")) + pop_warnings(); + } + set_warning_status(value); + break; + + case D_CPU: /* [CPU] */ + set_cpu(value); + break; + + case D_LIST: /* [LIST {+|-}] */ + value = nasm_skip_spaces(value); + if (*value == '+') { + user_nolist = false; + } else { + if (*value == '-') { + user_nolist = true; + } else { + bad_param = true; + } + } + break; + + case D_DEFAULT: /* [DEFAULT] */ + stdscan_reset(); + stdscan_set(value); + tokval.t_type = TOKEN_INVALID; + if (stdscan(NULL, &tokval) != TOKEN_INVALID) { + switch (tokval.t_integer) { + case S_REL: + globalrel = 1; + break; + case S_ABS: + globalrel = 0; + break; + case P_BND: + globalbnd = 1; + break; + case P_NOBND: + globalbnd = 0; + break; + default: + bad_param = true; + break; + } + } else { + bad_param = true; + } + break; + + case D_FLOAT: + if (float_option(value)) { + nasm_nonfatal("unknown 'float' directive: %s", value); + } + break; + + case D_PRAGMA: + process_pragma(value); + break; + } + + + /* A common error message */ + if (bad_param) { + nasm_nonfatal("invalid parameter to [%s] directive", directive); + } + + return d != D_none; +} diff --git a/vere/ext/nasm/asm/directiv.dat b/vere/ext/nasm/asm/directiv.dat new file mode 100644 index 0000000..5659ee1 --- /dev/null +++ b/vere/ext/nasm/asm/directiv.dat @@ -0,0 +1,110 @@ +;; -------------------------------------------------------------------------- +;; +;; Copyright 1996-2017 The NASM Authors - All Rights Reserved +;; See the file AUTHORS included with the NASM distribution for +;; the specific copyright holders. +;; +;; Redistribution and use in source and binary forms, with or without +;; modification, are permitted provided that the following +;; conditions are met: +;; +;; * Redistributions of source code must retain the above copyright +;; notice, this list of conditions and the following disclaimer. +;; * Redistributions in binary form must reproduce the above +;; copyright notice, this list of conditions and the following +;; disclaimer in the documentation and/or other materials provided +;; with the distribution. +;; +;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +;; CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +;; INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +;; MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +;; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +;; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +;; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +;; OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +;; EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +;; +;; -------------------------------------------------------------------------- +;; +;; List of global NASM directives and pragma operations codes +;; +;; ALL directives, including backend-specific, need to be added here. +;; +;; %pragma operation keywords (the second word, after facility) MAY +;; be added here too to assist in parsing, but it is not required. +;; See the definition of struct pragma in include/nasm.h. +;; +;; The same keyword can be used as a directive and as a pragma +;; operation, or as pragma operations in different namespaces. The +;; same D_ constant will be used for both, and this is perfectly +;; acceptable. +;; +;; In the future, this will be turned into a general list of keywords +;; to be parsed in special contexts. +;; + +; --- General configuration +#name directive +#prefix D_ +#errval D_unknown +#header directiv.h + +; --- Special enum values +#special none = 0 ; Must be zero +#special unknown +#special corrupt + +; --- Global directives +absolute +bits +common +cpu +debug +default +extern +float +global +static +list +section +segment +warning +sectalign +pragma +required + +; --- Format-specific directives +export ; outcoff, outobj +group ; outobj +import ; outobj +library ; outrdf2 +map ; outbin +module ; outrdf2 +org ; outbin +osabi ; outelf +safeseh ; outcoff +uppercase ; outieee, outobj + +; --- Assembler pragmas +prefix +suffix +gprefix +gsuffix +lprefix +lsuffix +limit + +; --- Listing pragmas +options + +; --- Backend pragmas +subsections_via_symbols ; macho +no_dead_strip ; macho +maxdump ; dbg +nodepend ; obj +noseclabels ; dbg diff --git a/vere/ext/nasm/asm/directiv.h b/vere/ext/nasm/asm/directiv.h new file mode 100644 index 0000000..1911264 --- /dev/null +++ b/vere/ext/nasm/asm/directiv.h @@ -0,0 +1,79 @@ +/* + * This file is generated from ./asm/directiv.dat + * by perfhash.pl; do not edit. + */ + +#ifndef DIRECTIV_H +#define DIRECTIV_H 1 + +#include "perfhash.h" + +enum directive { + D_none, + D_unknown, + D_corrupt, + D_ABSOLUTE, + D_BITS, + D_COMMON, + D_CPU, + D_DEBUG, + D_DEFAULT, + D_EXTERN, + D_FLOAT, + D_GLOBAL, + D_STATIC, + D_LIST, + D_SECTION, + D_SEGMENT, + D_WARNING, + D_SECTALIGN, + D_PRAGMA, + D_REQUIRED, + D_EXPORT, + D_GROUP, + D_IMPORT, + D_LIBRARY, + D_MAP, + D_MODULE, + D_ORG, + D_OSABI, + D_SAFESEH, + D_UPPERCASE, + D_PREFIX, + D_SUFFIX, + D_GPREFIX, + D_GSUFFIX, + D_LPREFIX, + D_LSUFFIX, + D_LIMIT, + D_OPTIONS, + D_SUBSECTIONS_VIA_SYMBOLS, + D_NO_DEAD_STRIP, + D_MAXDUMP, + D_NODEPEND, + D_NOSECLABELS +}; + +extern const struct perfect_hash directive_hash; +extern const char * const directive_tbl[40]; + +static inline enum directive directive_find(const char *str) +{ + return perfhash_find(&directive_hash, str); +} + +static inline const char * directive_name(enum directive x) +{ + size_t ix = (size_t)x - (3); + if (ix >= 40) + return NULL; + return directive_tbl[ix]; +} + +static inline const char * directive_dname(enum directive x) +{ + const char *y = directive_name(x); + return y ? y : invalid_enum_str(x); +} + +#endif /* DIRECTIV_H */ diff --git a/vere/ext/nasm/asm/error.c b/vere/ext/nasm/asm/error.c new file mode 100644 index 0000000..192555d --- /dev/null +++ b/vere/ext/nasm/asm/error.c @@ -0,0 +1,288 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2019 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * error.c - error message handling routines for the assembler + */ + +#include "compiler.h" + + +#include "nasmlib.h" +#include "error.h" + +/* Common function body */ +#define nasm_do_error(_sev,_flags) \ + va_list ap; \ + va_start(ap, fmt); \ + if ((_sev) >= ERR_CRITICAL) \ + nasm_verror_critical((_sev)|(_flags), fmt, ap); \ + else \ + nasm_verror((_sev)|(_flags), fmt, ap); \ + va_end(ap); \ + if ((_sev) >= ERR_FATAL) \ + abort(); + + +void nasm_error(errflags severity, const char *fmt, ...) +{ + nasm_do_error(severity & ERR_MASK, severity & ~ERR_MASK); +} + +#define nasm_err_helpers(_type, _name, _sev) \ +_type nasm_ ## _name ## f (errflags flags, const char *fmt, ...) \ +{ \ + nasm_do_error(_sev, flags); \ +} \ +_type nasm_ ## _name (const char *fmt, ...) \ +{ \ + nasm_do_error(_sev, 0); \ +} + +nasm_err_helpers(void, listmsg, ERR_LISTMSG) +nasm_err_helpers(void, debug, ERR_DEBUG) +nasm_err_helpers(void, info, ERR_INFO) +nasm_err_helpers(void, nonfatal, ERR_NONFATAL) +nasm_err_helpers(fatal_func, fatal, ERR_FATAL) +nasm_err_helpers(fatal_func, critical, ERR_CRITICAL) +nasm_err_helpers(fatal_func, panic, ERR_PANIC) + +/* + * Strongly discourage warnings without level by require flags on warnings. + * This means nasm_warn() is the equivalent of the -f variants of the + * other ones. + */ +void nasm_warn(errflags flags, const char *fmt, ...) +{ + nasm_do_error(ERR_WARNING, flags); +} + +fatal_func nasm_panic_from_macro(const char *file, int line) +{ + nasm_panic("internal error at %s:%d\n", file, line); +} + +fatal_func nasm_assert_failed(const char *file, int line, const char *msg) +{ + nasm_panic("assertion %s failed at %s:%d", msg, file, line); +} + + +/* + * Warning stack management. Note that there is an implicit "push" + * after the command line has been parsed, but this particular push + * cannot be popped. + */ +struct warning_stack { + struct warning_stack *next; + uint8_t state[sizeof warning_state]; +}; +static struct warning_stack *warning_stack, *warning_state_init; + +/* Push the warning status onto the warning stack */ +void push_warnings(void) +{ + struct warning_stack *ws; + + ws = nasm_malloc(sizeof *ws); + memcpy(ws->state, warning_state, sizeof warning_state); + ws->next = warning_stack; + warning_stack = ws; +} + +/* Pop the warning status off the warning stack */ +void pop_warnings(void) +{ + struct warning_stack *ws = warning_stack; + + memcpy(warning_state, ws->state, sizeof warning_state); + if (!ws->next) { + /*! + *!warn-stack-empty [on] warning stack empty + *! a [WARNING POP] directive was executed when + *! the warning stack is empty. This is treated + *! as a [WARNING *all] directive. + */ + nasm_warn(WARN_WARN_STACK_EMPTY, "warning stack empty"); + } else { + warning_stack = ws->next; + nasm_free(ws); + } +} + +/* Call after the command line is parsed, but before the first pass */ +void init_warnings(void) +{ + push_warnings(); + warning_state_init = warning_stack; +} + + +/* Call after each pass */ +void reset_warnings(void) +{ + struct warning_stack *ws = warning_stack; + + /* Unwind the warning stack. We do NOT delete the last entry! */ + while (ws->next) { + struct warning_stack *wst = ws; + ws = ws->next; + nasm_free(wst); + } + warning_stack = ws; + memcpy(warning_state, ws->state, sizeof warning_state); +} + +/* + * This is called when processing a -w or -W option, or a warning directive. + * Returns ok if the action was successful. + * + * Special pseudo-warnings: + * + *!other [on] any warning not specifically mentioned above + *! specifies any warning not included in any specific warning class. + * + *!all [all] all possible warnings + *! is an group alias for \e{all} warning classes. Thus, \c{-w+all} + *! enables all available warnings, and \c{-w-all} disables warnings + *! entirely (since NASM 2.13). + */ +bool set_warning_status(const char *value) +{ + enum warn_action { WID_OFF, WID_ON, WID_RESET }; + enum warn_action action; + const struct warning_alias *wa; + size_t vlen; + bool ok = false; + uint8_t mask; + + value = nasm_skip_spaces(value); + + switch (*value) { + case '-': + action = WID_OFF; + value++; + break; + case '+': + action = WID_ON; + value++; + break; + case '*': + action = WID_RESET; + value++; + break; + case 'N': + case 'n': + if (!nasm_strnicmp(value, "no-", 3)) { + action = WID_OFF; + value += 3; + break; + } else if (!nasm_stricmp(value, "none")) { + action = WID_OFF; + value = NULL; + break; + } + /* else fall through */ + default: + action = WID_ON; + break; + } + + mask = WARN_ST_ENABLED; + + if (value && !nasm_strnicmp(value, "error", 5)) { + switch (value[5]) { + case '=': + mask = WARN_ST_ERROR; + value += 6; + break; + case '\0': + mask = WARN_ST_ERROR; + value = NULL; + break; + default: + /* Just an accidental prefix? */ + break; + } + } + + if (value && !nasm_stricmp(value, "all")) + value = NULL; + + vlen = value ? strlen(value) : 0; + + /* + * This is inefficient, but it shouldn't matter. + * Note: warning_alias[0] is "all". + */ + for (wa = warning_alias+1; + wa < &warning_alias[NUM_WARNING_ALIAS]; wa++) { + enum warn_index i = wa->warning; + + if (value) { + char sep; + + if (nasm_strnicmp(value, wa->name, vlen)) + continue; /* Not a prefix */ + + sep = wa->name[vlen]; + if (sep != '\0' && sep != '-') + continue; /* Not a valid prefix */ + } + + ok = true; /* At least one action taken */ + switch (action) { + case WID_OFF: + warning_state[i] &= ~mask; + break; + case WID_ON: + warning_state[i] |= mask; + break; + case WID_RESET: + warning_state[i] &= ~mask; + warning_state[i] |= warning_state_init->state[i] & mask; + break; + } + } + + if (!ok && value) { + /*! + *!unknown-warning [off] unknown warning in -W/-w or warning directive + *! warns about a \c{-w} or \c{-W} option or a \c{[WARNING]} directive + *! that contains an unknown warning name or is otherwise not possible to process. + */ + nasm_warn(WARN_UNKNOWN_WARNING, "unknown warning name: %s", value); + } + + return ok; +} diff --git a/vere/ext/nasm/asm/eval.c b/vere/ext/nasm/asm/eval.c new file mode 100644 index 0000000..80fb4a2 --- /dev/null +++ b/vere/ext/nasm/asm/eval.c @@ -0,0 +1,1067 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2018 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * eval.c expression evaluator for the Netwide Assembler + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "nasmlib.h" +#include "ilog2.h" +#include "error.h" +#include "eval.h" +#include "labels.h" +#include "floats.h" +#include "assemble.h" + +#define TEMPEXPRS_DELTA 128 +#define TEMPEXPR_DELTA 8 + +static scanner scanfunc; /* Address of scanner routine */ +static void *scpriv; /* Scanner private pointer */ + +static expr **tempexprs = NULL; +static int ntempexprs; +static int tempexprs_size = 0; + +static expr *tempexpr; +static int ntempexpr; +static int tempexpr_size; + +static struct tokenval *tokval; /* The current token */ +static int tt; /* The t_type of tokval */ + +static bool critical; +static int *opflags; + +static struct eval_hints *hint; +static int64_t deadman; + + +/* + * Unimportant cleanup is done to avoid confusing people who are trying + * to debug real memory leaks + */ +void eval_cleanup(void) +{ + while (ntempexprs) + nasm_free(tempexprs[--ntempexprs]); + nasm_free(tempexprs); +} + +/* + * Construct a temporary expression. + */ +static void begintemp(void) +{ + tempexpr = NULL; + tempexpr_size = ntempexpr = 0; +} + +static void addtotemp(int32_t type, int64_t value) +{ + while (ntempexpr >= tempexpr_size) { + tempexpr_size += TEMPEXPR_DELTA; + tempexpr = nasm_realloc(tempexpr, + tempexpr_size * sizeof(*tempexpr)); + } + tempexpr[ntempexpr].type = type; + tempexpr[ntempexpr++].value = value; +} + +static expr *finishtemp(void) +{ + addtotemp(0L, 0L); /* terminate */ + while (ntempexprs >= tempexprs_size) { + tempexprs_size += TEMPEXPRS_DELTA; + tempexprs = nasm_realloc(tempexprs, + tempexprs_size * sizeof(*tempexprs)); + } + return tempexprs[ntempexprs++] = tempexpr; +} + +/* + * Add two vector datatypes. We have some bizarre behaviour on far- + * absolute segment types: we preserve them during addition _only_ + * if one of the segments is a truly pure scalar. + */ +static expr *add_vectors(expr * p, expr * q) +{ + int preserve; + + preserve = is_really_simple(p) || is_really_simple(q); + + begintemp(); + + while (p->type && q->type && + p->type < EXPR_SEGBASE + SEG_ABS && + q->type < EXPR_SEGBASE + SEG_ABS) { + int lasttype; + + if (p->type > q->type) { + addtotemp(q->type, q->value); + lasttype = q++->type; + } else if (p->type < q->type) { + addtotemp(p->type, p->value); + lasttype = p++->type; + } else { /* *p and *q have same type */ + int64_t sum = p->value + q->value; + if (sum) { + addtotemp(p->type, sum); + if (hint) + hint->type = EAH_SUMMED; + } + lasttype = p->type; + p++, q++; + } + if (lasttype == EXPR_UNKNOWN) { + return finishtemp(); + } + } + while (p->type && (preserve || p->type < EXPR_SEGBASE + SEG_ABS)) { + addtotemp(p->type, p->value); + p++; + } + while (q->type && (preserve || q->type < EXPR_SEGBASE + SEG_ABS)) { + addtotemp(q->type, q->value); + q++; + } + + return finishtemp(); +} + +/* + * Multiply a vector by a scalar. Strip far-absolute segment part + * if present. + * + * Explicit treatment of UNKNOWN is not required in this routine, + * since it will silently do the Right Thing anyway. + * + * If `affect_hints' is set, we also change the hint type to + * NOTBASE if a MAKEBASE hint points at a register being + * multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX + * as the base register. + */ +static expr *scalar_mult(expr * vect, int64_t scalar, int affect_hints) +{ + expr *p = vect; + + while (p->type && p->type < EXPR_SEGBASE + SEG_ABS) { + p->value = scalar * (p->value); + if (hint && hint->type == EAH_MAKEBASE && + p->type == hint->base && affect_hints) + hint->type = EAH_NOTBASE; + p++; + } + p->type = 0; + + return vect; +} + +static expr *scalarvect(int64_t scalar) +{ + begintemp(); + addtotemp(EXPR_SIMPLE, scalar); + return finishtemp(); +} + +static expr *unknown_expr(void) +{ + begintemp(); + addtotemp(EXPR_UNKNOWN, 1L); + return finishtemp(); +} + +/* + * The SEG operator: calculate the segment part of a relocatable + * value. Return NULL, as usual, if an error occurs. Report the + * error too. + */ +static expr *segment_part(expr * e) +{ + int32_t seg; + + if (is_unknown(e)) + return unknown_expr(); + + if (!is_reloc(e)) { + nasm_nonfatal("cannot apply SEG to a non-relocatable value"); + return NULL; + } + + seg = reloc_seg(e); + if (seg == NO_SEG) { + nasm_nonfatal("cannot apply SEG to a non-relocatable value"); + return NULL; + } else if (seg & SEG_ABS) { + return scalarvect(seg & ~SEG_ABS); + } else if (seg & 1) { + nasm_nonfatal("SEG applied to something which" + " is already a segment base"); + return NULL; + } else { + int32_t base = ofmt->segbase(seg + 1); + + begintemp(); + addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base), + 1L); + return finishtemp(); + } +} + +/* + * Recursive-descent parser. Called with a single boolean operand, + * which is true if the evaluation is critical (i.e. unresolved + * symbols are an error condition). Must update the global `tt' to + * reflect the token after the parsed string. May return NULL. + * + * evaluate() should report its own errors: on return it is assumed + * that if NULL has been returned, the error has already been + * reported. + * + */ + +/* + * Wrapper function around the scanner + */ +static int scan(void) +{ + return tt = scanfunc(scpriv, tokval); +} + +/* + * Grammar parsed is: + * + * expr : bexpr [ WRT expr6 ] + * bexpr : cexpr + * cexpr : rexp0 [ {?} bexpr {:} cexpr ] + * rexp0 : rexp1 [ {||} rexp1...] + * rexp1 : rexp2 [ {^^} rexp2...] + * rexp2 : rexp3 [ {&&} rexp3...] + * rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=,<=>} expr0... ] + * expr0 : expr1 [ {|} expr1...] + * expr1 : expr2 [ {^} expr2...] + * expr2 : expr3 [ {&} expr3...] + * expr3 : expr4 [ {<<,>>,<<<,>>>} expr4...] + * expr4 : expr5 [ {+,-} expr5...] + * expr5 : expr6 [ {*,/,%,//,%%} expr6...] + * expr6 : { ~,+,-,IFUNC,SEG } expr6 + * | (bexpr) + * | symbol + * | $ + * | number + */ + +static expr *cexpr(void); +static expr *rexp0(void), *rexp1(void), *rexp2(void), *rexp3(void); + +static expr *expr0(void), *expr1(void), *expr2(void), *expr3(void); +static expr *expr4(void), *expr5(void), *expr6(void); + +/* This inline is a placeholder for the root of the basic expression */ +static inline expr *bexpr(void) +{ + return cexpr(); +} + +static expr *cexpr(void) +{ + expr *e, *f, *g; + + e = rexp0(); + if (!e) + return NULL; + + if (tt == TOKEN_QMARK) { + scan(); + f = bexpr(); + if (!f) + return NULL; + + if (tt != ':') { + nasm_nonfatal("`?' without matching `:'"); + return NULL; + } + + scan(); + g = cexpr(); + if (!g) + return NULL; + + if (is_simple(e)) { + e = reloc_value(e) ? f : g; + } else if (is_just_unknown(e)) { + e = unknown_expr(); + } else { + nasm_nonfatal("the left-hand side of `?' must be " + "a scalar value"); + } + } + + return e; +} + +static expr *rexp0(void) +{ + expr *e, *f; + + e = rexp1(); + if (!e) + return NULL; + + while (tt == TOKEN_DBL_OR) { + scan(); + f = rexp1(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("`|' operator may only be applied to" + " scalar values"); + } + + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect((int64_t)(reloc_value(e) || reloc_value(f))); + } + return e; +} + +static expr *rexp1(void) +{ + expr *e, *f; + + e = rexp2(); + if (!e) + return NULL; + + while (tt == TOKEN_DBL_XOR) { + scan(); + f = rexp2(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("`^' operator may only be applied to" + " scalar values"); + } + + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect((int64_t)(!reloc_value(e) ^ !reloc_value(f))); + } + return e; +} + +static expr *rexp2(void) +{ + expr *e, *f; + + e = rexp3(); + if (!e) + return NULL; + while (tt == TOKEN_DBL_AND) { + scan(); + f = rexp3(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("`&' operator may only be applied to" + " scalar values"); + } + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect((int64_t)(reloc_value(e) && reloc_value(f))); + } + return e; +} + +static expr *rexp3(void) +{ + expr *e, *f; + int64_t v; + + e = expr0(); + if (!e) + return NULL; + + while (tt == TOKEN_EQ || tt == TOKEN_LT || tt == TOKEN_GT || + tt == TOKEN_NE || tt == TOKEN_LE || tt == TOKEN_GE || + tt == TOKEN_LEG) { + int tto = tt; + scan(); + f = expr0(); + if (!f) + return NULL; + + e = add_vectors(e, scalar_mult(f, -1L, false)); + + switch (tto) { + case TOKEN_EQ: + case TOKEN_NE: + if (is_unknown(e)) + v = -1; /* means unknown */ + else if (!is_really_simple(e) || reloc_value(e) != 0) + v = (tto == TOKEN_NE); /* unequal, so return true if NE */ + else + v = (tto == TOKEN_EQ); /* equal, so return true if EQ */ + break; + default: + if (is_unknown(e)) + v = -1; /* means unknown */ + else if (!is_really_simple(e)) { + nasm_nonfatal("`%s': operands differ by a non-scalar", + (tto == TOKEN_LE ? "<=" : + tto == TOKEN_LT ? "<" : + tto == TOKEN_GE ? ">=" : + tto == TOKEN_GT ? ">" : + tto == TOKEN_LEG ? "<=>" : + "<internal error>")); + v = 0; /* must set it to _something_ */ + } else { + int64_t vv = reloc_value(e); + if (tto == TOKEN_LEG) + v = (vv < 0) ? -1 : (vv > 0) ? 1 : 0; + else if (vv == 0) + v = (tto == TOKEN_LE || tto == TOKEN_GE); + else if (vv > 0) + v = (tto == TOKEN_GE || tto == TOKEN_GT); + else /* vv < 0 */ + v = (tto == TOKEN_LE || tto == TOKEN_LT); + } + break; + } + + if (v == -1) + e = unknown_expr(); + else + e = scalarvect(v); + } + return e; +} + +static expr *expr0(void) +{ + expr *e, *f; + + e = expr1(); + if (!e) + return NULL; + + while (tt == '|') { + scan(); + f = expr1(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("`|' operator may only be applied to" + " scalar values"); + } + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(reloc_value(e) | reloc_value(f)); + } + return e; +} + +static expr *expr1(void) +{ + expr *e, *f; + + e = expr2(); + if (!e) + return NULL; + + while (tt == '^') { + scan(); + f = expr2(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("`^' operator may only be applied to" + " scalar values"); + } + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(reloc_value(e) ^ reloc_value(f)); + } + return e; +} + +static expr *expr2(void) +{ + expr *e, *f; + + e = expr3(); + if (!e) + return NULL; + + while (tt == '&') { + scan(); + f = expr3(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("`&' operator may only be applied to" + " scalar values"); + } + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(reloc_value(e) & reloc_value(f)); + } + return e; +} + +static expr *expr3(void) +{ + expr *e, *f; + + e = expr4(); + if (!e) + return NULL; + + while (tt == TOKEN_SHL || tt == TOKEN_SHR || tt == TOKEN_SAR) { + int tto = tt; + scan(); + f = expr4(); + if (!f) + return NULL; + if (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f))) { + nasm_nonfatal("shift operator may only be applied to" + " scalar values"); + } else if (is_just_unknown(e) || is_just_unknown(f)) { + e = unknown_expr(); + } else { + switch (tto) { + case TOKEN_SHL: + e = scalarvect(reloc_value(e) << reloc_value(f)); + break; + case TOKEN_SHR: + e = scalarvect(((uint64_t)reloc_value(e)) >> + reloc_value(f)); + break; + case TOKEN_SAR: + e = scalarvect(((int64_t)reloc_value(e)) >> + reloc_value(f)); + break; + } + } + } + return e; +} + +static expr *expr4(void) +{ + expr *e, *f; + + e = expr5(); + if (!e) + return NULL; + while (tt == '+' || tt == '-') { + int tto = tt; + scan(); + f = expr5(); + if (!f) + return NULL; + switch (tto) { + case '+': + e = add_vectors(e, f); + break; + case '-': + e = add_vectors(e, scalar_mult(f, -1L, false)); + break; + } + } + return e; +} + +static expr *expr5(void) +{ + expr *e, *f; + + e = expr6(); + if (!e) + return NULL; + while (tt == '*' || tt == '/' || tt == '%' || + tt == TOKEN_SDIV || tt == TOKEN_SMOD) { + int tto = tt; + scan(); + f = expr6(); + if (!f) + return NULL; + if (tto != '*' && (!(is_simple(e) || is_just_unknown(e)) || + !(is_simple(f) || is_just_unknown(f)))) { + nasm_nonfatal("division operator may only be applied to" + " scalar values"); + return NULL; + } + if (tto != '*' && !is_just_unknown(f) && reloc_value(f) == 0) { + nasm_nonfatal("division by zero"); + return NULL; + } + switch (tto) { + case '*': + if (is_simple(e)) + e = scalar_mult(f, reloc_value(e), true); + else if (is_simple(f)) + e = scalar_mult(e, reloc_value(f), true); + else if (is_just_unknown(e) && is_just_unknown(f)) + e = unknown_expr(); + else { + nasm_nonfatal("unable to multiply two " + "non-scalar objects"); + return NULL; + } + break; + case '/': + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(((uint64_t)reloc_value(e)) / + ((uint64_t)reloc_value(f))); + break; + case '%': + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(((uint64_t)reloc_value(e)) % + ((uint64_t)reloc_value(f))); + break; + case TOKEN_SDIV: + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(((int64_t)reloc_value(e)) / + ((int64_t)reloc_value(f))); + break; + case TOKEN_SMOD: + if (is_just_unknown(e) || is_just_unknown(f)) + e = unknown_expr(); + else + e = scalarvect(((int64_t)reloc_value(e)) % + ((int64_t)reloc_value(f))); + break; + } + } + return e; +} + +static expr *eval_floatize(enum floatize type) +{ + uint8_t result[16], *p; /* Up to 128 bits */ + int sign = 1; + int64_t val; + size_t len; + int i; + const struct ieee_format *fmt; + + fmt = &fp_formats[type]; + + scan(); + if (tt != '(') { + nasm_nonfatal("expecting `('"); + return NULL; + } + scan(); + if (tt == '-' || tt == '+') { + sign = (tt == '-') ? -1 : 1; + scan(); + } + if (tt != TOKEN_FLOAT) { + nasm_nonfatal("expecting floating-point number"); + return NULL; + } + if (!float_const(tokval->t_charptr, sign, result, type)) + return NULL; + scan(); + if (tt != ')') { + nasm_nonfatal("expecting `)'"); + return NULL; + } + + len = fmt->bytes - fmt->offset; + if (len > 8) + len = 8; /* Max 64 bits */ + p = result + len + fmt->offset; + val = 0; + for (i = len; i; i--) { + p--; + val = (val << 8) + *p; + } + + begintemp(); + addtotemp(EXPR_SIMPLE, val); + + scan(); + return finishtemp(); +} + +static expr *eval_strfunc(enum strfunc type, const char *name) +{ + char *string; + size_t string_len; + int64_t val; + bool parens, rn_warn; + + parens = false; + scan(); + if (tt == '(') { + parens = true; + scan(); + } + if (tt != TOKEN_STR) { + nasm_nonfatal("expecting string as argument to %s", name); + return NULL; + } + string_len = string_transform(tokval->t_charptr, tokval->t_inttwo, + &string, type); + if (string_len == (size_t)-1) { + nasm_nonfatal("invalid input string to %s", name); + return NULL; + } + + val = readstrnum(string, string_len, &rn_warn); + if (parens) { + scan(); + if (tt != ')') { + nasm_nonfatal("expecting `)'"); + return NULL; + } + } + + if (rn_warn) + nasm_warn(WARN_OTHER, "character constant too long"); + + begintemp(); + addtotemp(EXPR_SIMPLE, val); + + scan(); + return finishtemp(); +} + +static int64_t eval_ifunc(int64_t val, enum ifunc func) +{ + uint64_t uval = (uint64_t)val; + int64_t rv; + + switch (func) { + case IFUNC_ILOG2E: + case IFUNC_ILOG2W: + if (!is_power2(uval)) + nasm_error((func == IFUNC_ILOG2E) ? ERR_NONFATAL : ERR_WARNING|WARN_OTHER, + "ilog2 argument is not a power of two"); + /* fall through */ + case IFUNC_ILOG2F: + rv = ilog2_64(uval); + break; + + case IFUNC_ILOG2C: + rv = (uval < 2) ? 0 : ilog2_64(uval-1) + 1; + break; + + default: + nasm_panic("invalid IFUNC token %d", func); + rv = 0; + break; + } + + return rv; +} + +static expr *expr6(void) +{ + int32_t type; + expr *e; + int32_t label_seg; + int64_t label_ofs; + int64_t tmpval; + bool rn_warn; + const char *scope; + + if (++deadman > nasm_limit[LIMIT_EVAL]) { + nasm_nonfatal("expression too long"); + return NULL; + } + + switch (tt) { + case '-': + scan(); + e = expr6(); + if (!e) + return NULL; + return scalar_mult(e, -1L, false); + + case '+': + scan(); + return expr6(); + + case '~': + scan(); + e = expr6(); + if (!e) + return NULL; + if (is_just_unknown(e)) + return unknown_expr(); + else if (!is_simple(e)) { + nasm_nonfatal("`~' operator may only be applied to" + " scalar values"); + return NULL; + } + return scalarvect(~reloc_value(e)); + + case '!': + scan(); + e = expr6(); + if (!e) + return NULL; + if (is_just_unknown(e)) + return unknown_expr(); + else if (!is_simple(e)) { + nasm_nonfatal("`!' operator may only be applied to" + " scalar values"); + return NULL; + } + return scalarvect(!reloc_value(e)); + + case TOKEN_IFUNC: + { + enum ifunc func = tokval->t_integer; + scan(); + e = expr6(); + if (!e) + return NULL; + if (is_just_unknown(e)) + return unknown_expr(); + else if (!is_simple(e)) { + nasm_nonfatal("function may only be applied to" + " scalar values"); + return NULL; + } + return scalarvect(eval_ifunc(reloc_value(e), func)); + } + + case TOKEN_SEG: + scan(); + e = expr6(); + if (!e) + return NULL; + e = segment_part(e); + if (!e) + return NULL; + if (is_unknown(e) && critical) { + nasm_nonfatal("unable to determine segment base"); + return NULL; + } + return e; + + case TOKEN_FLOATIZE: + return eval_floatize(tokval->t_integer); + + case TOKEN_STRFUNC: + return eval_strfunc(tokval->t_integer, tokval->t_charptr); + + case '(': + scan(); + e = bexpr(); + if (!e) + return NULL; + if (tt != ')') { + nasm_nonfatal("expecting `)'"); + return NULL; + } + scan(); + return e; + + case TOKEN_NUM: + case TOKEN_STR: + case TOKEN_REG: + case TOKEN_ID: + case TOKEN_INSN: /* Opcodes that occur here are really labels */ + case TOKEN_HERE: + case TOKEN_BASE: + case TOKEN_DECORATOR: + begintemp(); + switch (tt) { + case TOKEN_NUM: + addtotemp(EXPR_SIMPLE, tokval->t_integer); + break; + case TOKEN_STR: + tmpval = readstrnum(tokval->t_charptr, tokval->t_inttwo, &rn_warn); + if (rn_warn) + nasm_warn(WARN_OTHER, "character constant too long"); + addtotemp(EXPR_SIMPLE, tmpval); + break; + case TOKEN_REG: + addtotemp(tokval->t_integer, 1L); + if (hint && hint->type == EAH_NOHINT) + hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE; + break; + case TOKEN_ID: + case TOKEN_INSN: + case TOKEN_HERE: + case TOKEN_BASE: + /* + * If !location.known, this indicates that no + * symbol, Here or Base references are valid because we + * are in preprocess-only mode. + */ + if (!location.known) { + nasm_nonfatal("%s not supported in preprocess-only mode", + (tt == TOKEN_HERE ? "`$'" : + tt == TOKEN_BASE ? "`$$'" : + "symbol references")); + addtotemp(EXPR_UNKNOWN, 1L); + break; + } + + type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */ + if (tt == TOKEN_BASE) { + label_seg = in_absolute ? absolute.segment : location.segment; + label_ofs = 0; + } else if (tt == TOKEN_HERE) { + label_seg = in_absolute ? absolute.segment : location.segment; + label_ofs = in_absolute ? absolute.offset : location.offset; + } else { + enum label_type ltype; + ltype = lookup_label(tokval->t_charptr, &label_seg, &label_ofs); + if (ltype == LBL_none) { + scope = local_scope(tokval->t_charptr); + if (critical) { + nasm_nonfatal("symbol `%s%s' not defined%s", + scope,tokval->t_charptr, + pass_first() ? " before use" : ""); + return NULL; + } + if (opflags) + *opflags |= OPFLAG_FORWARD; + type = EXPR_UNKNOWN; + label_seg = NO_SEG; + label_ofs = 1; + } else if (is_extern(ltype)) { + if (opflags) + *opflags |= OPFLAG_EXTERN; + } + } + addtotemp(type, label_ofs); + if (label_seg != NO_SEG) + addtotemp(EXPR_SEGBASE + label_seg, 1L); + break; + case TOKEN_DECORATOR: + addtotemp(EXPR_RDSAE, tokval->t_integer); + break; + } + scan(); + return finishtemp(); + + default: + nasm_nonfatal("expression syntax error"); + return NULL; + } +} + +expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv, + int *fwref, bool crit, struct eval_hints *hints) +{ + expr *e; + expr *f = NULL; + + deadman = 0; + + hint = hints; + if (hint) + hint->type = EAH_NOHINT; + + critical = crit; + scanfunc = sc; + scpriv = scprivate; + tokval = tv; + opflags = fwref; + + while (ntempexprs) /* initialize temporary storage */ + nasm_free(tempexprs[--ntempexprs]); + + tt = tokval->t_type; + if (tt == TOKEN_INVALID) + scan(); + + e = bexpr(); + if (!e) + return NULL; + + if (tt == TOKEN_WRT) { + scan(); /* eat the WRT */ + f = expr6(); + if (!f) + return NULL; + } + e = scalar_mult(e, 1L, false); /* strip far-absolute segment part */ + if (f) { + expr *g; + if (is_just_unknown(f)) + g = unknown_expr(); + else { + int64_t value; + begintemp(); + if (!is_reloc(f)) { + nasm_nonfatal("invalid right-hand operand to WRT"); + return NULL; + } + value = reloc_seg(f); + if (value == NO_SEG) + value = reloc_value(f) | SEG_ABS; + else if (!(value & SEG_ABS) && !(value % 2) && critical) { + nasm_nonfatal("invalid right-hand operand to WRT"); + return NULL; + } + addtotemp(EXPR_WRT, value); + g = finishtemp(); + } + e = add_vectors(e, g); + } + return e; +} diff --git a/vere/ext/nasm/asm/eval.h b/vere/ext/nasm/asm/eval.h new file mode 100644 index 0000000..ba471a2 --- /dev/null +++ b/vere/ext/nasm/asm/eval.h @@ -0,0 +1,49 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2009 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * eval.h header file for eval.c + */ + +#ifndef NASM_EVAL_H +#define NASM_EVAL_H + +/* + * The evaluator itself. + */ +expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv, + int *fwref, bool critical, struct eval_hints *hints); + +void eval_cleanup(void); + +#endif diff --git a/vere/ext/nasm/asm/exprdump.c b/vere/ext/nasm/asm/exprdump.c new file mode 100644 index 0000000..68a9b67 --- /dev/null +++ b/vere/ext/nasm/asm/exprdump.c @@ -0,0 +1,79 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2017 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * exprdump.c + * + * Debugging code to dump the contents of an expression vector to stdout + */ + +#include "nasm.h" + +static const char *expr_type(int32_t type) +{ + static char seg_str[64]; + + switch (type) { + case 0: + return "null"; + case EXPR_UNKNOWN: + return "unknown"; + case EXPR_SIMPLE: + return "simple"; + case EXPR_WRT: + return "wrt"; + case EXPR_RDSAE: + return "sae"; + default: + break; + } + + if (type >= EXPR_REG_START && type <= EXPR_REG_END) { + return nasm_reg_names[type - EXPR_REG_START]; + } else if (type >= EXPR_SEGBASE) { + snprintf(seg_str, sizeof seg_str, "%sseg %d", + (type - EXPR_SEGBASE) == location.segment ? "this " : "", + type - EXPR_SEGBASE); + return seg_str; + } else { + return "ERR"; + } +} + +void dump_expr(const expr *e) +{ + printf("["); + for (; e->type; e++) + printf("<%s(%d),%"PRId64">", expr_type(e->type), e->type, e->value); + printf("]\n"); +} diff --git a/vere/ext/nasm/asm/exprlib.c b/vere/ext/nasm/asm/exprlib.c new file mode 100644 index 0000000..f7cfbce --- /dev/null +++ b/vere/ext/nasm/asm/exprlib.c @@ -0,0 +1,200 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2017 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * exprlib.c + * + * Library routines to manipulate expression data types. + */ + +#include "nasm.h" + +/* + * Return true if the argument is a simple scalar. (Or a far- + * absolute, which counts.) + */ +bool is_simple(const expr *vect) +{ + while (vect->type && !vect->value) + vect++; + if (!vect->type) + return true; + if (vect->type != EXPR_SIMPLE) + return false; + do { + vect++; + } while (vect->type && !vect->value); + if (vect->type && vect->type < EXPR_SEGBASE + SEG_ABS) + return false; + return true; +} + +/* + * Return true if the argument is a simple scalar, _NOT_ a far- + * absolute. + */ +bool is_really_simple(const expr *vect) +{ + while (vect->type && !vect->value) + vect++; + if (!vect->type) + return true; + if (vect->type != EXPR_SIMPLE) + return false; + do { + vect++; + } while (vect->type && !vect->value); + if (vect->type) + return false; + return true; +} + +/* + * Return true if the argument is relocatable (i.e. a simple + * scalar, plus at most one segment-base, possibly a subtraction + * of the current segment base, plus possibly a WRT). + */ +bool is_reloc(const expr *vect) +{ + bool has_rel = false; /* Has a self-segment-subtract */ + bool has_seg = false; /* Has a segment base */ + + for (; vect->type; vect++) { + if (!vect->value) { + /* skip value-0 terms */ + continue; + } else if (vect->type < EXPR_SIMPLE) { + /* false if a register is present */ + return false; + } else if (vect->type == EXPR_SIMPLE) { + /* skip over a pure number term... */ + continue; + } else if (vect->type == EXPR_WRT) { + /* skip over a WRT term... */ + continue; + } else if (vect->type < EXPR_SEGBASE) { + /* other special type -> problem */ + return false; + } else if (vect->value == 1) { + if (has_seg) + return false; /* only one segbase allowed */ + has_seg = true; + } else if (vect->value == -1) { + if (vect->type != location.segment + EXPR_SEGBASE) + return false; /* can only subtract current segment */ + if (has_rel) + return false; /* already is relative */ + has_rel = true; + } + } + + return true; +} + +/* + * Return true if the argument contains an `unknown' part. + */ +bool is_unknown(const expr *vect) +{ + while (vect->type && vect->type < EXPR_UNKNOWN) + vect++; + return (vect->type == EXPR_UNKNOWN); +} + +/* + * Return true if the argument contains nothing but an `unknown' + * part. + */ +bool is_just_unknown(const expr *vect) +{ + while (vect->type && !vect->value) + vect++; + return (vect->type == EXPR_UNKNOWN); +} + +/* + * Return the scalar part of a relocatable vector. (Including + * simple scalar vectors - those qualify as relocatable.) + */ +int64_t reloc_value(const expr *vect) +{ + while (vect->type && !vect->value) + vect++; + if (!vect->type) + return 0; + if (vect->type == EXPR_SIMPLE) + return vect->value; + else + return 0; +} + +/* + * Return the segment number of a relocatable vector, or NO_SEG for + * simple scalars. + */ +int32_t reloc_seg(const expr *vect) +{ + for (; vect->type; vect++) { + if (vect->type >= EXPR_SEGBASE && vect->value == 1) + return vect->type - EXPR_SEGBASE; + } + + return NO_SEG; +} + +/* + * Return the WRT segment number of a relocatable vector, or NO_SEG + * if no WRT part is present. + */ +int32_t reloc_wrt(const expr *vect) +{ + while (vect->type && vect->type < EXPR_WRT) + vect++; + if (vect->type == EXPR_WRT) { + return vect->value; + } else + return NO_SEG; +} + +/* + * Return true if this expression contains a subtraction of the location + */ +bool is_self_relative(const expr *vect) +{ + for (; vect->type; vect++) { + if (vect->type == location.segment + EXPR_SEGBASE && vect->value == -1) + return true; + } + + return false; +} diff --git a/vere/ext/nasm/asm/floats.c b/vere/ext/nasm/asm/floats.c new file mode 100644 index 0000000..27180bd --- /dev/null +++ b/vere/ext/nasm/asm/floats.c @@ -0,0 +1,960 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * float.c floating-point constant support for the Netwide Assembler + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "floats.h" +#include "error.h" + +/* + * ----------------- + * local variables + * ----------------- + */ +static bool daz = false; /* denormals as zero */ +static enum float_round rc = FLOAT_RC_NEAR; /* rounding control */ + +/* + * ----------- + * constants + * ----------- + */ + +/* "A limb is like a digit but bigger */ +typedef uint32_t fp_limb; +typedef uint64_t fp_2limb; + +#define LIMB_BITS 32 +#define LIMB_BYTES (LIMB_BITS/8) +#define LIMB_TOP_BIT ((fp_limb)1 << (LIMB_BITS-1)) +#define LIMB_MASK ((fp_limb)(~0)) +#define LIMB_ALL_BYTES ((fp_limb)0x01010101) +#define LIMB_BYTE(x) ((x)*LIMB_ALL_BYTES) + +/* 112 bits + 64 bits for accuracy + 16 bits for rounding */ +#define MANT_LIMBS 6 + +/* 52 digits fit in 176 bits because 10^53 > 2^176 > 10^52 */ +#define MANT_DIGITS 52 + +/* the format and the argument list depend on MANT_LIMBS */ +#define MANT_FMT "%08x_%08x_%08x_%08x_%08x_%08x" +#define MANT_ARG SOME_ARG(mant, 0) + +#define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], \ + (a)[(i)+3], (a)[(i)+4], (a)[(i)+5] + +/* + * --------------------------------------------------------------------------- + * emit a printf()-like debug message... but only if DEBUG_FLOAT was defined + * --------------------------------------------------------------------------- + */ + +#ifdef DEBUG_FLOAT +#define dprintf(x) printf x +#else +#define dprintf(x) do { } while (0) +#endif + +/* + * --------------------------------------------------------------------------- + * multiply + * --------------------------------------------------------------------------- + */ +static int float_multiply(fp_limb *to, fp_limb *from) +{ + fp_2limb temp[MANT_LIMBS * 2]; + int i, j; + + /* + * guaranteed that top bit of 'from' is set -- so we only have + * to worry about _one_ bit shift to the left + */ + dprintf(("%s=" MANT_FMT "\n", "mul1", SOME_ARG(to, 0))); + dprintf(("%s=" MANT_FMT "\n", "mul2", SOME_ARG(from, 0))); + + memset(temp, 0, sizeof temp); + + for (i = 0; i < MANT_LIMBS; i++) { + for (j = 0; j < MANT_LIMBS; j++) { + fp_2limb n; + n = (fp_2limb) to[i] * (fp_2limb) from[j]; + temp[i + j] += n >> LIMB_BITS; + temp[i + j + 1] += (fp_limb)n; + } + } + + for (i = MANT_LIMBS * 2; --i;) { + temp[i - 1] += temp[i] >> LIMB_BITS; + temp[i] &= LIMB_MASK; + } + + dprintf(("%s=" MANT_FMT "_" MANT_FMT "\n", "temp", SOME_ARG(temp, 0), + SOME_ARG(temp, MANT_LIMBS))); + + if (temp[0] & LIMB_TOP_BIT) { + for (i = 0; i < MANT_LIMBS; i++) { + to[i] = temp[i] & LIMB_MASK; + } + dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), 0)); + return 0; + } else { + for (i = 0; i < MANT_LIMBS; i++) { + to[i] = (temp[i] << 1) + !!(temp[i + 1] & LIMB_TOP_BIT); + } + dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), -1)); + return -1; + } +} + +/* + * --------------------------------------------------------------------------- + * read an exponent; returns INT32_MAX on error + * --------------------------------------------------------------------------- + */ +static int32_t read_exponent(const char *string, int32_t max) +{ + int32_t i = 0; + bool neg = false; + + if (*string == '+') { + string++; + } else if (*string == '-') { + neg = true; + string++; + } + while (*string) { + if (*string >= '0' && *string <= '9') { + i = (i * 10) + (*string - '0'); + + /* + * To ensure that underflows and overflows are + * handled properly we must avoid wraparounds of + * the signed integer value that is used to hold + * the exponent. Therefore we cap the exponent at + * +/-5000, which is slightly more/less than + * what's required for normal and denormal numbers + * in single, double, and extended precision, but + * sufficient to avoid signed integer wraparound. + */ + if (i > max) + i = max; + } else if (*string == '_') { + /* do nothing */ + } else { + nasm_nonfatal("invalid character in floating-point constant %s: '%c'", + "exponent", *string); + return INT32_MAX; + } + string++; + } + + return neg ? -i : i; +} + +/* + * --------------------------------------------------------------------------- + * convert + * --------------------------------------------------------------------------- + */ +static bool ieee_flconvert(const char *string, fp_limb *mant, + int32_t * exponent) +{ + char digits[MANT_DIGITS]; + char *p, *q, *r; + fp_limb mult[MANT_LIMBS], bit; + fp_limb *m; + int32_t tenpwr, twopwr; + int32_t extratwos; + bool started, seendot, warned; + + warned = false; + p = digits; + tenpwr = 0; + started = seendot = false; + + while (*string && *string != 'E' && *string != 'e') { + if (*string == '.') { + if (!seendot) { + seendot = true; + } else { + nasm_nonfatal("too many periods in floating-point constant"); + return false; + } + } else if (*string >= '0' && *string <= '9') { + if (*string == '0' && !started) { + if (seendot) { + tenpwr--; + } + } else { + started = true; + if (p < digits + sizeof(digits)) { + *p++ = *string - '0'; + } else { + if (!warned) { + /*! + *!float-toolong [on] too many digits in floating-point number + *! warns about too many digits in floating-point numbers. + */ + nasm_warn(WARN_FLOAT_TOOLONG|ERR_PASS2, + "floating-point constant significand contains " + "more than %i digits", MANT_DIGITS); + warned = true; + } + } + if (!seendot) { + tenpwr++; + } + } + } else if (*string == '_') { + /* do nothing */ + } else { + nasm_nonfatalf(ERR_PASS2, + "invalid character in floating-point constant %s: '%c'", + "significand", *string); + return false; + } + string++; + } + + if (*string) { + int32_t e; + + string++; /* eat the E */ + e = read_exponent(string, 5000); + if (e == INT32_MAX) + return false; + tenpwr += e; + } + + /* + * At this point, the memory interval [digits,p) contains a + * series of decimal digits zzzzzzz, such that our number X + * satisfies X = 0.zzzzzzz * 10^tenpwr. + */ + q = digits; + dprintf(("X = 0.")); + while (q < p) { + dprintf(("%c", *q + '0')); + q++; + } + dprintf((" * 10^%i\n", tenpwr)); + + /* + * Now convert [digits,p) to our internal representation. + */ + bit = LIMB_TOP_BIT; + for (m = mant; m < mant + MANT_LIMBS; m++) { + *m = 0; + } + m = mant; + q = digits; + started = false; + twopwr = 0; + while (m < mant + MANT_LIMBS) { + fp_limb carry = 0; + while (p > q && !p[-1]) { + p--; + } + if (p <= q) { + break; + } + for (r = p; r-- > q;) { + int32_t i; + i = 2 * *r + carry; + if (i >= 10) { + carry = 1; + i -= 10; + } else { + carry = 0; + } + *r = i; + } + if (carry) { + *m |= bit; + started = true; + } + if (started) { + if (bit == 1) { + bit = LIMB_TOP_BIT; + m++; + } else { + bit >>= 1; + } + } else { + twopwr--; + } + } + twopwr += tenpwr; + + /* + * At this point, the 'mant' array contains the first frac- + * tional places of a base-2^16 real number which when mul- + * tiplied by 2^twopwr and 5^tenpwr gives X. + */ + dprintf(("X = " MANT_FMT " * 2^%i * 5^%i\n", MANT_ARG, twopwr, + tenpwr)); + + /* + * Now multiply 'mant' by 5^tenpwr. + */ + if (tenpwr < 0) { /* mult = 5^-1 = 0.2 */ + for (m = mult; m < mult + MANT_LIMBS - 1; m++) { + *m = LIMB_BYTE(0xcc); + } + mult[MANT_LIMBS - 1] = LIMB_BYTE(0xcc)+1; + extratwos = -2; + tenpwr = -tenpwr; + + /* + * If tenpwr was 1000...000b, then it becomes 1000...000b. See + * the "ANSI C" comment below for more details on that case. + * + * Because we already truncated tenpwr to +5000...-5000 inside + * the exponent parsing code, this shouldn't happen though. + */ + } else if (tenpwr > 0) { /* mult = 5^+1 = 5.0 */ + mult[0] = (fp_limb)5 << (LIMB_BITS-3); /* 0xA000... */ + for (m = mult + 1; m < mult + MANT_LIMBS; m++) { + *m = 0; + } + extratwos = 3; + } else { + extratwos = 0; + } + while (tenpwr) { + dprintf(("loop=" MANT_FMT " * 2^%i * 5^%i (%i)\n", MANT_ARG, + twopwr, tenpwr, extratwos)); + if (tenpwr & 1) { + dprintf(("mant*mult\n")); + twopwr += extratwos + float_multiply(mant, mult); + } + dprintf(("mult*mult\n")); + extratwos = extratwos * 2 + float_multiply(mult, mult); + tenpwr >>= 1; + + /* + * In ANSI C, the result of right-shifting a signed integer is + * considered implementation-specific. To ensure that the loop + * terminates even if tenpwr was 1000...000b to begin with, we + * manually clear the MSB, in case a 1 was shifted in. + * + * Because we already truncated tenpwr to +5000...-5000 inside + * the exponent parsing code, this shouldn't matter; neverthe- + * less it is the right thing to do here. + */ + tenpwr &= (uint32_t) - 1 >> 1; + } + + /* + * At this point, the 'mant' array contains the first frac- + * tional places of a base-2^16 real number in [0.5,1) that + * when multiplied by 2^twopwr gives X. Or it contains zero + * of course. We are done. + */ + *exponent = twopwr; + return true; +} + +/* + * --------------------------------------------------------------------------- + * operations of specific bits + * --------------------------------------------------------------------------- + */ + +/* Set a bit, using *bigendian* bit numbering (0 = MSB) */ +static void set_bit(fp_limb *mant, int bit) +{ + mant[bit/LIMB_BITS] |= LIMB_TOP_BIT >> (bit & (LIMB_BITS-1)); +} + +/* Test a single bit */ +static int test_bit(const fp_limb *mant, int bit) +{ + return (mant[bit/LIMB_BITS] >> (~bit & (LIMB_BITS-1))) & 1; +} + +/* Report if the mantissa value is all zero */ +static bool is_zero(const fp_limb *mant) +{ + int i; + + for (i = 0; i < MANT_LIMBS; i++) + if (mant[i]) + return false; + + return true; +} + +/* + * --------------------------------------------------------------------------- + * round a mantissa off after i words + * --------------------------------------------------------------------------- + */ + +#define ROUND_COLLECT_BITS \ + do { \ + m = mant[i] & (2*bit-1); \ + for (j = i+1; j < MANT_LIMBS; j++) \ + m = m | mant[j]; \ + } while (0) + +#define ROUND_ABS_DOWN \ + do { \ + mant[i] &= ~(bit-1); \ + for (j = i+1; j < MANT_LIMBS; j++) \ + mant[j] = 0; \ + return false; \ + } while (0) + +#define ROUND_ABS_UP \ + do { \ + mant[i] = (mant[i] & ~(bit-1)) + bit; \ + for (j = i+1; j < MANT_LIMBS; j++) \ + mant[j] = 0; \ + while (i > 0 && !mant[i]) \ + ++mant[--i]; \ + return !mant[0]; \ + } while (0) + +static bool ieee_round(bool minus, fp_limb *mant, int bits) +{ + fp_limb m = 0; + int32_t j; + int i = bits / LIMB_BITS; + int p = bits % LIMB_BITS; + fp_limb bit = LIMB_TOP_BIT >> p; + + if (rc == FLOAT_RC_NEAR) { + if (mant[i] & bit) { + mant[i] &= ~bit; + ROUND_COLLECT_BITS; + mant[i] |= bit; + if (m) { + ROUND_ABS_UP; + } else { + if (test_bit(mant, bits-1)) { + ROUND_ABS_UP; + } else { + ROUND_ABS_DOWN; + } + } + } else { + ROUND_ABS_DOWN; + } + } else if (rc == FLOAT_RC_ZERO || + rc == (minus ? FLOAT_RC_UP : FLOAT_RC_DOWN)) { + ROUND_ABS_DOWN; + } else { + /* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */ + /* Round toward +/- infinity */ + ROUND_COLLECT_BITS; + if (m) { + ROUND_ABS_UP; + } else { + ROUND_ABS_DOWN; + } + } + return false; +} + +/* Returns a value >= 16 if not a valid hex digit */ +static unsigned int hexval(char c) +{ + unsigned int v = (unsigned char) c; + + if (v >= '0' && v <= '9') + return v - '0'; + else + return (v|0x20) - 'a' + 10; +} + +/* Handle floating-point numbers with radix 2^bits and binary exponent */ +static bool ieee_flconvert_bin(const char *string, int bits, + fp_limb *mant, int32_t *exponent) +{ + static const int log2tbl[16] = + { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 }; + fp_limb mult[MANT_LIMBS + 1], *mp; + int ms; + int32_t twopwr; + bool seendot, seendigit; + unsigned char c; + const int radix = 1 << bits; + fp_limb v; + + twopwr = 0; + seendot = seendigit = false; + ms = 0; + mp = NULL; + + memset(mult, 0, sizeof mult); + + while ((c = *string++) != '\0') { + if (c == '.') { + if (!seendot) + seendot = true; + else { + nasm_nonfatal("too many periods in floating-point constant"); + return false; + } + } else if ((v = hexval(c)) < (unsigned int)radix) { + if (!seendigit && v) { + int l = log2tbl[v]; + + seendigit = true; + mp = mult; + ms = (LIMB_BITS-1)-l; + + twopwr += l+1-bits; + } + + if (seendigit) { + if (ms < 0) { + /* Cast to fp_2limb as ms == -LIMB_BITS is possible. */ + *mp |= (fp_2limb)v >> -ms; + mp++; + if (mp > &mult[MANT_LIMBS]) + mp = &mult[MANT_LIMBS]; /* Guard slot */ + ms += LIMB_BITS; + } + *mp |= v << ms; + ms -= bits; + + if (!seendot) + twopwr += bits; + } else { + if (seendot) + twopwr -= bits; + } + } else if (c == 'p' || c == 'P') { + int32_t e; + e = read_exponent(string, 20000); + if (e == INT32_MAX) + return false; + twopwr += e; + break; + } else if (c == '_') { + /* ignore */ + } else { + nasm_nonfatal("floating-point constant: `%c' is invalid character", c); + return false; + } + } + + if (!seendigit) { + memset(mant, 0, MANT_LIMBS*sizeof(fp_limb)); /* Zero */ + *exponent = 0; + } else { + memcpy(mant, mult, MANT_LIMBS*sizeof(fp_limb)); + *exponent = twopwr; + } + + return true; +} + +/* + * Shift a mantissa to the right by i bits. + */ +static void ieee_shr(fp_limb *mant, int i) +{ + fp_limb n, m; + int j = 0; + int sr, sl, offs; + + sr = i % LIMB_BITS; sl = LIMB_BITS-sr; + offs = i/LIMB_BITS; + + if (sr == 0) { + if (offs) + for (j = MANT_LIMBS-1; j >= offs; j--) + mant[j] = mant[j-offs]; + } else if (MANT_LIMBS-1-offs < 0) { + j = MANT_LIMBS-1; + } else { + n = mant[MANT_LIMBS-1-offs] >> sr; + for (j = MANT_LIMBS-1; j > offs; j--) { + m = mant[j-offs-1]; + mant[j] = (m << sl) | n; + n = m >> sr; + } + mant[j--] = n; + } + while (j >= 0) + mant[j--] = 0; +} + +/* Produce standard IEEE formats, with implicit or explicit integer + bit; this makes the following assumptions: + + - the sign bit is the MSB, followed by the exponent, + followed by the integer bit if present. + - the sign bit plus exponent fit in 16 bits. + - the exponent bias is 2^(n-1)-1 for an n-bit exponent */ + +/* + * The 16- and 128-bit formats are expected to be in IEEE 754r. + * AMD SSE5 uses the 16-bit format. + * + * The 32- and 64-bit formats are the original IEEE 754 formats. + * + * The 80-bit format is x87-specific, but widely used. + * + * The 8-bit format appears to be the consensus 8-bit floating-point + * format. It is apparently used in graphics applications. + * + * The b16 format is a 16-bit format with smaller mantissa and larger + * exponent field. It is effectively a truncated version of the standard + * IEEE 32-bit (single) format, but is explicitly supported here in + * order to support proper rounding. + * + * This array must correspond to enum floatize in include/nasm.h. + * Note that there are some formats which have more than one enum; + * both need to be listed here with the appropriate offset into the + * floating-point byte array (use for the floatize operators.) + * + * FLOAT_ERR is a value that both represents "invalid format" and the + * size of this array. + */ +const struct ieee_format fp_formats[FLOAT_ERR] = { + { 1, 3, 0, 4, 0 }, /* FLOAT_8 */ + { 2, 10, 0, 5, 0 }, /* FLOAT_16 */ + { 2, 7, 0, 8, 0 }, /* FLOAT_B16 */ + { 4, 23, 0, 8, 0 }, /* FLOAT_32 */ + { 8, 52, 0, 11, 0 }, /* FLOAT_64 */ + { 10, 63, 1, 15, 0 }, /* FLOAT_80M */ + { 10, 63, 1, 15, 8 }, /* FLOAT_80E */ + { 16, 112, 0, 15, 0 }, /* FLOAT_128L */ + { 16, 112, 0, 15, 8 } /* FLOAT_128H */ +}; + +/* Types of values we can generate */ +enum floats { + FL_ZERO, + FL_DENORMAL, + FL_NORMAL, + FL_INFINITY, + FL_QNAN, + FL_SNAN +}; + +static int to_packed_bcd(const char *str, const char *p, + int s, uint8_t *result, + const struct ieee_format *fmt) +{ + int n = 0; + char c; + int tv = -1; + + if (fmt->bytes != 10) { + nasm_nonfatal("packed BCD requires an 80-bit format"); + return 0; + } + + while (p >= str) { + c = *p--; + if (c >= '0' && c <= '9') { + if (tv < 0) { + if (n == 9) + nasm_warn(WARN_OTHER|ERR_PASS2, "packed BCD truncated to 18 digits"); + tv = c-'0'; + } else { + if (n < 9) + *result++ = tv + ((c-'0') << 4); + n++; + tv = -1; + } + } else if (c == '_') { + /* do nothing */ + } else { + nasm_nonfatal("invalid character `%c' in packed BCD constant", c); + return 0; + } + } + if (tv >= 0) { + if (n < 9) + *result++ = tv; + n++; + } + while (n < 9) { + *result++ = 0; + n++; + } + *result = (s < 0) ? 0x80 : 0; + + return 1; /* success */ +} + +int float_const(const char *str, int s, uint8_t *result, enum floatize ffmt) +{ + const struct ieee_format *fmt = &fp_formats[ffmt]; + fp_limb mant[MANT_LIMBS]; + int32_t exponent = 0; + const int32_t expmax = 1 << (fmt->exponent - 1); + fp_limb one_mask = LIMB_TOP_BIT >> + ((fmt->exponent+fmt->explicit) % LIMB_BITS); + const int one_pos = (fmt->exponent+fmt->explicit)/LIMB_BITS; + int i; + int shift; + enum floats type; + bool ok; + const bool minus = s < 0; + const int bits = fmt->bytes * 8; + const char *strend; + + nasm_assert(str[0]); + + strend = strchr(str, '\0'); + if (strend[-1] == 'P' || strend[-1] == 'p') + return to_packed_bcd(str, strend-2, s, result, fmt); + + if (str[0] == '_') { + /* Special tokens */ + + switch (str[3]) { + case 'n': /* __?nan?__ */ + case 'N': + case 'q': /* __?qnan?__ */ + case 'Q': + type = FL_QNAN; + break; + case 's': /* __?snan?__ */ + case 'S': + type = FL_SNAN; + break; + case 'i': /* __?infinity?__ */ + case 'I': + type = FL_INFINITY; + break; + default: + nasm_nonfatal("internal error: unknown FP constant token `%s'", str); + type = FL_QNAN; + break; + } + } else { + if (str[0] == '0') { + switch (str[1]) { + case 'x': case 'X': + case 'h': case 'H': + ok = ieee_flconvert_bin(str+2, 4, mant, &exponent); + break; + case 'o': case 'O': + case 'q': case 'Q': + ok = ieee_flconvert_bin(str+2, 3, mant, &exponent); + break; + case 'b': case 'B': + case 'y': case 'Y': + ok = ieee_flconvert_bin(str+2, 1, mant, &exponent); + break; + case 'd': case 'D': + case 't': case 'T': + ok = ieee_flconvert(str+2, mant, &exponent); + break; + case 'p': case 'P': + return to_packed_bcd(str+2, strend-1, s, result, fmt); + default: + /* Leading zero was just a zero? */ + ok = ieee_flconvert(str, mant, &exponent); + break; + } + } else if (str[0] == '$') { + ok = ieee_flconvert_bin(str+1, 4, mant, &exponent); + } else { + ok = ieee_flconvert(str, mant, &exponent); + } + + if (!ok) { + type = FL_QNAN; + } else if (mant[0] & LIMB_TOP_BIT) { + /* + * Non-zero. + */ + exponent--; + if (exponent >= 2 - expmax && exponent <= expmax) { + type = FL_NORMAL; + } else if (exponent > 0) { + nasm_warn(WARN_FLOAT_OVERFLOW|ERR_PASS2, + "overflow in floating-point constant"); + type = FL_INFINITY; + } else { + /* underflow or denormal; the denormal code handles + actual underflow. */ + type = FL_DENORMAL; + } + } else { + /* Zero */ + type = FL_ZERO; + } + } + + switch (type) { + case FL_ZERO: + zero: + memset(mant, 0, sizeof mant); + break; + + case FL_DENORMAL: + { + shift = -(exponent + expmax - 2 - fmt->exponent) + + fmt->explicit; + ieee_shr(mant, shift); + ieee_round(minus, mant, bits); + if (mant[one_pos] & one_mask) { + /* One's position is set, we rounded up into normal range */ + exponent = 1; + if (!fmt->explicit) + mant[one_pos] &= ~one_mask; /* remove explicit one */ + mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent); + } else { + if (daz || is_zero(mant)) { + /*! + *!float-underflow [off] floating point underflow + *! warns about floating point underflow (a nonzero + *! constant rounded to zero.) + */ + nasm_warn(WARN_FLOAT_UNDERFLOW|ERR_PASS2, + "underflow in floating-point constant"); + goto zero; + } else { + /*! + *!float-denorm [off] floating point denormal + *! warns about denormal floating point constants. + */ + nasm_warn(WARN_FLOAT_DENORM|ERR_PASS2, + "denormal floating-point constant"); + } + } + break; + } + + case FL_NORMAL: + exponent += expmax - 1; + ieee_shr(mant, fmt->exponent+fmt->explicit); + ieee_round(minus, mant, bits); + /* did we scale up by one? */ + if (test_bit(mant, fmt->exponent+fmt->explicit-1)) { + ieee_shr(mant, 1); + exponent++; + if (exponent >= (expmax << 1)-1) { + /*! + *!float-overflow [on] floating point overflow + *! warns about floating point underflow. + */ + nasm_warn(WARN_FLOAT_OVERFLOW|ERR_PASS2, + "overflow in floating-point constant"); + type = FL_INFINITY; + goto overflow; + } + } + + if (!fmt->explicit) + mant[one_pos] &= ~one_mask; /* remove explicit one */ + mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent); + break; + + case FL_INFINITY: + case FL_QNAN: + case FL_SNAN: + overflow: + memset(mant, 0, sizeof mant); + mant[0] = (((fp_limb)1 << fmt->exponent)-1) + << (LIMB_BITS-1 - fmt->exponent); + if (fmt->explicit) + mant[one_pos] |= one_mask; + if (type == FL_QNAN) + set_bit(mant, fmt->exponent+fmt->explicit+1); + else if (type == FL_SNAN) + set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa); + break; + } + + mant[0] |= minus ? LIMB_TOP_BIT : 0; + + for (i = fmt->bytes - 1; i >= 0; i--) + *result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8); + + return 1; /* success */ +} + +/* + * Get the default floating point format for this specific field size. + * Used for the Dx pseudoops. + */ +enum floatize float_deffmt(int bytes) +{ + enum floatize type; + + for (type = 0; type < FLOAT_ERR; type++) { + if (fp_formats[type].bytes == bytes) + break; + } + + return type; /* FLOAT_ERR if invalid */ +} + +/* Set floating-point options */ +int float_option(const char *option) +{ + if (!nasm_stricmp(option, "daz")) { + daz = true; + return 0; + } else if (!nasm_stricmp(option, "nodaz")) { + daz = false; + return 0; + } else if (!nasm_stricmp(option, "near")) { + rc = FLOAT_RC_NEAR; + return 0; + } else if (!nasm_stricmp(option, "down")) { + rc = FLOAT_RC_DOWN; + return 0; + } else if (!nasm_stricmp(option, "up")) { + rc = FLOAT_RC_UP; + return 0; + } else if (!nasm_stricmp(option, "zero")) { + rc = FLOAT_RC_ZERO; + return 0; + } else if (!nasm_stricmp(option, "default")) { + rc = FLOAT_RC_NEAR; + daz = false; + return 0; + } else { + return -1; /* Unknown option */ + } +} diff --git a/vere/ext/nasm/asm/floats.h b/vere/ext/nasm/asm/floats.h new file mode 100644 index 0000000..c463513 --- /dev/null +++ b/vere/ext/nasm/asm/floats.h @@ -0,0 +1,67 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * floats.h header file for the floating-point constant module of + * the Netwide Assembler + */ + +#ifndef NASM_FLOATS_H +#define NASM_FLOATS_H + +#include "nasm.h" + +enum float_round { + FLOAT_RC_NEAR, + FLOAT_RC_ZERO, + FLOAT_RC_DOWN, + FLOAT_RC_UP +}; + +/* Note: enum floatize and FLOAT_ERR are defined in nasm.h */ + +/* Floating-point format description */ +struct ieee_format { + int bytes; /* Total bytes */ + int mantissa; /* Fractional bits in the mantissa */ + int explicit; /* Explicit integer */ + int exponent; /* Bits in the exponent */ + int offset; /* Offset into byte array for floatize op */ +}; +extern const struct ieee_format fp_formats[FLOAT_ERR]; + +int float_const(const char *str, int s, uint8_t *result, enum floatize ffmt); +enum floatize float_deffmt(int bytes); +int float_option(const char *option); + +#endif /* NASM_FLOATS_H */ diff --git a/vere/ext/nasm/asm/labels.c b/vere/ext/nasm/asm/labels.c new file mode 100644 index 0000000..f6b940f --- /dev/null +++ b/vere/ext/nasm/asm/labels.c @@ -0,0 +1,720 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2018 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * labels.c label handling for the Netwide Assembler + */ + +#include "compiler.h" + + +#include "nasm.h" +#include "nasmlib.h" +#include "error.h" +#include "hashtbl.h" +#include "labels.h" + +/* + * A dot-local label is one that begins with exactly one period. Things + * that begin with _two_ periods are NASM-specific things. + * + * If TASM compatibility is enabled, a local label can also begin with + * @@. + */ +static bool islocal(const char *l) +{ + if (tasm_compatible_mode) { + if (l[0] == '@' && l[1] == '@') + return true; + } + + return (l[0] == '.' && l[1] != '.'); +} + +/* + * Return true if this falls into NASM's '..' namespace + */ +static bool ismagic(const char *l) +{ + return l[0] == '.' && l[1] == '.' && l[2] != '@'; +} + +/* + * Return true if we should update the local label base + * as a result of this symbol. We must exclude local labels + * as well as any kind of special labels, including ..@ ones. + */ +static bool set_prevlabel(const char *l) +{ + if (tasm_compatible_mode) { + if (l[0] == '@' && l[1] == '@') + return false; + } + + return l[0] != '.'; +} + +#define LABEL_BLOCK 128 /* no. of labels/block */ +#define LBLK_SIZE (LABEL_BLOCK * sizeof(union label)) + +#define END_LIST -3 /* don't clash with NO_SEG! */ +#define END_BLOCK -2 + +#define PERMTS_SIZE 16384 /* size of text blocks */ +#if (PERMTS_SIZE < IDLEN_MAX) + #error "IPERMTS_SIZE must be greater than or equal to IDLEN_MAX" +#endif + +/* string values for enum label_type */ +static const char * const types[] = { + "local", "static", "global", "extern", "required", "common", + "special", "output format special" +}; + +union label { /* actual label structures */ + struct { + int32_t segment; + int32_t subsection; /* Available for ofmt->herelabel() */ + int64_t offset; + int64_t size; + int64_t defined; /* 0 if undefined, passn+1 for when defn seen */ + int64_t lastref; /* Last pass where we saw a reference */ + char *label, *mangled, *special; + const char *def_file; /* Where defined */ + int32_t def_line; + enum label_type type, mangled_type; + } defn; + struct { + int32_t movingon; + int64_t dummy; + union label *next; + } admin; +}; + +struct permts { /* permanent text storage */ + struct permts *next; /* for the linked list */ + unsigned int size, usage; /* size and used space in ... */ + char data[PERMTS_SIZE]; /* ... the data block itself */ +}; +#define PERMTS_HEADER offsetof(struct permts, data) + +uint64_t global_offset_changed; /* counter for global offset changes */ + +static struct hash_table ltab; /* labels hash table */ +static union label *ldata; /* all label data blocks */ +static union label *lfree; /* labels free block */ +static struct permts *perm_head; /* start of perm. text storage */ +static struct permts *perm_tail; /* end of perm. text storage */ + +static void init_block(union label *blk); +static char *perm_alloc(size_t len); +static char *perm_copy(const char *string); +static char *perm_copy3(const char *s1, const char *s2, const char *s3); +static const char *mangle_label_name(union label *lptr); + +static const char *prevlabel; + +static bool initialized = false; + +/* + * Emit a symdef to the output and the debug format backends. + */ +static void out_symdef(union label *lptr) +{ + int backend_type; + int64_t backend_offset; + + /* Backend-defined special segments are passed to symdef immediately */ + if (pass_final()) { + /* Emit special fixups for globals and commons */ + switch (lptr->defn.type) { + case LBL_GLOBAL: + case LBL_REQUIRED: + case LBL_COMMON: + if (lptr->defn.special) + ofmt->symdef(lptr->defn.mangled, 0, 0, 3, lptr->defn.special); + break; + default: + break; + } + return; + } + + if (pass_type() != PASS_STAB && lptr->defn.type != LBL_BACKEND) + return; + + /* Clean up this hack... */ + switch(lptr->defn.type) { + case LBL_EXTERN: + /* If not seen in the previous or this pass, drop it */ + if (lptr->defn.lastref < pass_count()) + return; + + /* Otherwise, promote to LBL_REQUIRED at this time */ + lptr->defn.type = LBL_REQUIRED; + + /* fall through */ + case LBL_GLOBAL: + case LBL_REQUIRED: + backend_type = 1; + backend_offset = lptr->defn.offset; + break; + case LBL_COMMON: + backend_type = 2; + backend_offset = lptr->defn.size; + break; + default: + backend_type = 0; + backend_offset = lptr->defn.offset; + break; + } + + /* Might be necessary for a backend symbol */ + mangle_label_name(lptr); + + ofmt->symdef(lptr->defn.mangled, lptr->defn.segment, + backend_offset, backend_type, + lptr->defn.special); + + /* + * NASM special symbols are not passed to the debug format; none + * of the current backends want to see them. + */ + if (lptr->defn.type == LBL_SPECIAL || lptr->defn.type == LBL_BACKEND) + return; + + dfmt->debug_deflabel(lptr->defn.mangled, lptr->defn.segment, + lptr->defn.offset, backend_type, + lptr->defn.special); +} + +/* + * Internal routine: finds the `union label' corresponding to the + * given label name. Creates a new one, if it isn't found, and if + * `create' is true. + */ +static union label *find_label(const char *label, bool create, bool *created) +{ + union label *lptr, **lpp; + char *label_str = NULL; + struct hash_insert ip; + + nasm_assert(label != NULL); + + if (islocal(label)) + label = label_str = nasm_strcat(prevlabel, label); + + lpp = (union label **) hash_find(<ab, label, &ip); + lptr = lpp ? *lpp : NULL; + + if (lptr || !create) { + if (created) + *created = false; + return lptr; + } + + /* Create a new label... */ + if (lfree->admin.movingon == END_BLOCK) { + /* + * must allocate a new block + */ + lfree->admin.next = nasm_malloc(LBLK_SIZE); + lfree = lfree->admin.next; + init_block(lfree); + } + + if (created) + *created = true; + + nasm_zero(*lfree); + lfree->defn.label = perm_copy(label); + lfree->defn.subsection = NO_SEG; + if (label_str) + nasm_free(label_str); + + hash_add(&ip, lfree->defn.label, lfree); + return lfree++; +} + +enum label_type lookup_label(const char *label, + int32_t *segment, int64_t *offset) +{ + union label *lptr; + + if (!initialized) + return LBL_none; + + lptr = find_label(label, false, NULL); + if (lptr && lptr->defn.defined) { + int64_t lpass = pass_count() + 1; + + lptr->defn.lastref = lpass; + *segment = lptr->defn.segment; + *offset = lptr->defn.offset; + return lptr->defn.type; + } + + return LBL_none; +} + +static inline bool is_global(enum label_type type) +{ + return type == LBL_GLOBAL || type == LBL_COMMON; +} + +static const char *mangle_strings[] = {"", "", "", ""}; +static bool mangle_string_set[ARRAY_SIZE(mangle_strings)]; + +/* + * Set a prefix or suffix + */ +void set_label_mangle(enum mangle_index which, const char *what) +{ + if (mangle_string_set[which]) + return; /* Once set, do not change */ + + mangle_strings[which] = perm_copy(what); + mangle_string_set[which] = true; +} + +/* + * Format a label name with appropriate prefixes and suffixes + */ +static const char *mangle_label_name(union label *lptr) +{ + const char *prefix; + const char *suffix; + + if (likely(lptr->defn.mangled && + lptr->defn.mangled_type == lptr->defn.type)) + return lptr->defn.mangled; /* Already mangled */ + + switch (lptr->defn.type) { + case LBL_GLOBAL: + case LBL_STATIC: + case LBL_EXTERN: + case LBL_REQUIRED: + prefix = mangle_strings[LM_GPREFIX]; + suffix = mangle_strings[LM_GSUFFIX]; + break; + case LBL_BACKEND: + case LBL_SPECIAL: + prefix = suffix = ""; + break; + default: + prefix = mangle_strings[LM_LPREFIX]; + suffix = mangle_strings[LM_LSUFFIX]; + break; + } + + lptr->defn.mangled_type = lptr->defn.type; + + if (!(*prefix) && !(*suffix)) + lptr->defn.mangled = lptr->defn.label; + else + lptr->defn.mangled = perm_copy3(prefix, lptr->defn.label, suffix); + + return lptr->defn.mangled; +} + +static void +handle_herelabel(union label *lptr, int32_t *segment, int64_t *offset) +{ + int32_t oldseg; + + if (likely(!ofmt->herelabel)) + return; + + if (unlikely(location.segment == NO_SEG)) + return; + + oldseg = *segment; + + if (oldseg == location.segment && *offset == location.offset) { + /* This label is defined at this location */ + int32_t newseg; + bool copyoffset = false; + + nasm_assert(lptr->defn.mangled); + newseg = ofmt->herelabel(lptr->defn.mangled, lptr->defn.type, + oldseg, &lptr->defn.subsection, ©offset); + if (likely(newseg == oldseg)) + return; + + *segment = newseg; + if (copyoffset) { + /* Maintain the offset from the old to the new segment */ + switch_segment(newseg); + location.offset = *offset; + } else { + /* Keep a separate offset for the new segment */ + *offset = switch_segment(newseg); + } + } +} + +static bool declare_label_lptr(union label *lptr, + enum label_type type, const char *special) +{ + enum label_type oldtype = lptr->defn.type; + + if (special && !special[0]) + special = NULL; + + if (oldtype == type || (!pass_stable() && oldtype == LBL_LOCAL) || + (oldtype == LBL_EXTERN && type == LBL_REQUIRED)) { + lptr->defn.type = type; + + if (special) { + if (!lptr->defn.special) + lptr->defn.special = perm_copy(special); + else if (nasm_stricmp(lptr->defn.special, special)) + nasm_nonfatal("symbol `%s' has inconsistent attributes `%s' and `%s'", + lptr->defn.label, lptr->defn.special, special); + } + return true; + } else if (is_extern(oldtype) && is_global(type)) { + /* EXTERN or REQUIRED can be replaced with GLOBAL or COMMON */ + lptr->defn.type = type; + + /* Override special unconditionally */ + if (special) + lptr->defn.special = perm_copy(special); + return true; + } else if (is_extern(type) && (is_global(oldtype) || is_extern(oldtype))) { + /* + * GLOBAL or COMMON ignore subsequent EXTERN or REQUIRED; + * REQUIRED ignores subsequent EXTERN. + */ + + /* Ignore special unless we don't already have one */ + if (!lptr->defn.special) + lptr->defn.special = perm_copy(special); + + return false; /* Don't call define_label() after this! */ + } + + nasm_nonfatal("symbol `%s' declared both as %s and %s", + lptr->defn.label, types[lptr->defn.type], types[type]); + return false; +} + +bool declare_label(const char *label, enum label_type type, const char *special) +{ + union label *lptr = find_label(label, true, NULL); + return declare_label_lptr(lptr, type, special); +} + +/* + * The "normal" argument decides if we should update the local segment + * base name or not. + */ +void define_label(const char *label, int32_t segment, + int64_t offset, bool normal) +{ + union label *lptr; + bool created, changed; + int64_t size; + int64_t lpass, lastdef; + + /* + * The backend may invoke this during initialization, at which + * pass_count() is zero, so add one so we never have a zero value + * for a defined variable. + */ + lpass = pass_count() + 1; + + /* + * Phase errors here can be one of two types: a new label appears, + * or the offset changes. Increment global_offset_changed when that + * happens, to tell the assembler core to make another pass. + */ + lptr = find_label(label, true, &created); + + lastdef = lptr->defn.defined; + + if (segment) { + /* We are actually defining this label */ + if (is_extern(lptr->defn.type)) { + /* auto-promote EXTERN/REQUIRED to GLOBAL */ + lptr->defn.type = LBL_GLOBAL; + lastdef = 0; /* We are "re-creating" this label */ + } + } else { + /* It's a pseudo-segment (extern, required, common) */ + segment = lptr->defn.segment ? lptr->defn.segment : seg_alloc(); + } + + if (lastdef || lptr->defn.type == LBL_BACKEND) { + /* + * We have seen this on at least one previous pass, or + * potentially earlier in this same pass (in which case we + * will probably error out further down.) + */ + mangle_label_name(lptr); + handle_herelabel(lptr, &segment, &offset); + } + + if (ismagic(label) && lptr->defn.type == LBL_LOCAL) + lptr->defn.type = LBL_SPECIAL; + + if (set_prevlabel(label) && normal) + prevlabel = lptr->defn.label; + + if (lptr->defn.type == LBL_COMMON) { + size = offset; + offset = 0; + } else { + size = 0; /* This is a hack... */ + } + + changed = created || !lastdef || + lptr->defn.segment != segment || + lptr->defn.offset != offset || + lptr->defn.size != size; + global_offset_changed += changed; + + if (lastdef == lpass) { + int32_t saved_line = 0; + const char *saved_fname = NULL; + int noteflags; + + /* + * Defined elsewhere in the program, seen in this pass. + */ + if (changed) { + nasm_nonfatal("label `%s' inconsistently redefined", lptr->defn.label); + noteflags = ERR_NONFATAL|ERR_HERE|ERR_NO_SEVERITY; + } else { + /*! + *!label-redef [off] label redefined to an identical value + *! warns if a label is defined more than once, but the + *! value is identical. It is an unconditional error to + *! define the same label more than once to \e{different} values. + */ + nasm_warn(WARN_LABEL_REDEF, + "info: label `%s' redefined to an identical value", lptr->defn.label); + noteflags = ERR_WARNING|ERR_HERE|ERR_NO_SEVERITY|WARN_LABEL_REDEF; + } + + src_get(&saved_line, &saved_fname); + src_set(lptr->defn.def_line, lptr->defn.def_file); + nasm_error(noteflags, "info: label `%s' originally defined", lptr->defn.label); + src_set(saved_line, saved_fname); + } else if (changed && pass_final() && lptr->defn.type != LBL_SPECIAL) { + /*! + *!label-redef-late [err] label (re)defined during code generation + *! the value of a label changed during the final, code-generation + *! pass. This may be the result of strange use of the + *! preprocessor. This is very likely to produce incorrect code and + *! may end up being an unconditional error in a future + *! version of NASM. + * + * WARN_LABEL_LATE defaults to an error, as this should never + * actually happen. Just in case this is a backwards + * compatibility problem, still make it a warning so that the + * user can suppress or demote it. + * + * Note: As a special case, LBL_SPECIAL symbols are allowed + * to be changed even during the last pass. + */ + nasm_warn(WARN_LABEL_REDEF_LATE|ERR_UNDEAD, + "label `%s' %s during code generation", + lptr->defn.label, created ? "defined" : "changed"); + } + lptr->defn.segment = segment; + lptr->defn.offset = offset; + lptr->defn.size = size; + lptr->defn.defined = lpass; + + if (changed || lastdef != lpass) + src_get(&lptr->defn.def_line, &lptr->defn.def_file); + + if (lastdef != lpass) + out_symdef(lptr); +} + +/* + * Define a special backend label + */ +void backend_label(const char *label, int32_t segment, int64_t offset) +{ + if (!declare_label(label, LBL_BACKEND, NULL)) + return; + + define_label(label, segment, offset, false); +} + +int init_labels(void) +{ + ldata = lfree = nasm_malloc(LBLK_SIZE); + init_block(lfree); + + perm_head = perm_tail = + nasm_malloc(sizeof(struct permts)); + + perm_head->next = NULL; + perm_head->size = PERMTS_SIZE; + perm_head->usage = 0; + + prevlabel = ""; + + initialized = true; + + return 0; +} + +void cleanup_labels(void) +{ + union label *lptr, *lhold; + + initialized = false; + + hash_free(<ab); + + lptr = lhold = ldata; + while (lptr) { + lptr = &lptr[LABEL_BLOCK-1]; + lptr = lptr->admin.next; + nasm_free(lhold); + lhold = lptr; + } + + while (perm_head) { + perm_tail = perm_head; + perm_head = perm_head->next; + nasm_free(perm_tail); + } +} + +static void init_block(union label *blk) +{ + int j; + + for (j = 0; j < LABEL_BLOCK - 1; j++) + blk[j].admin.movingon = END_LIST; + blk[LABEL_BLOCK - 1].admin.movingon = END_BLOCK; + blk[LABEL_BLOCK - 1].admin.next = NULL; +} + +static char * safe_alloc perm_alloc(size_t len) +{ + char *p; + + if (perm_tail->size - perm_tail->usage < len) { + size_t alloc_len = (len > PERMTS_SIZE) ? len : PERMTS_SIZE; + perm_tail->next = nasm_malloc(PERMTS_HEADER + alloc_len); + perm_tail = perm_tail->next; + perm_tail->next = NULL; + perm_tail->size = alloc_len; + perm_tail->usage = 0; + } + p = perm_tail->data + perm_tail->usage; + perm_tail->usage += len; + return p; +} + +static char *perm_copy(const char *string) +{ + char *p; + size_t len; + + if (!string) + return NULL; + + len = strlen(string)+1; /* Include final NUL */ + + p = perm_alloc(len); + memcpy(p, string, len); + + return p; +} + +static char * +perm_copy3(const char *s1, const char *s2, const char *s3) +{ + char *p; + size_t l1 = strlen(s1); + size_t l2 = strlen(s2); + size_t l3 = strlen(s3)+1; /* Include final NUL */ + + p = perm_alloc(l1+l2+l3); + memcpy(p, s1, l1); + memcpy(p+l1, s2, l2); + memcpy(p+l1+l2, s3, l3); + + return p; +} + +const char *local_scope(const char *label) +{ + return islocal(label) ? prevlabel : ""; +} + +/* + * Notes regarding bug involving redefinition of external segments. + * + * Up to and including v0.97, the following code didn't work. From 0.97 + * developers release 2 onwards, it will generate an error. + * + * EXTERN extlabel + * newlabel EQU extlabel + 1 + * + * The results of allowing this code through are that two import records + * are generated, one for 'extlabel' and one for 'newlabel'. + * + * The reason for this is an inadequacy in the defined interface between + * the label manager and the output formats. The problem lies in how the + * output format driver tells that a label is an external label for which + * a label import record must be produced. Most (all except bin?) produce + * the record if the segment number of the label is not one of the internal + * segments that the output driver is producing. + * + * A simple fix to this would be to make the output formats keep track of + * which symbols they've produced import records for, and make them not + * produce import records for segments that are already defined. + * + * The best way, which is slightly harder but reduces duplication of code + * and should therefore make the entire system smaller and more stable is + * to change the interface between assembler, define_label(), and + * the output module. The changes that are needed are: + * + * The semantics of the 'isextern' flag passed to define_label() need + * examining. This information may or may not tell us what we need to + * know (ie should we be generating an import record at this point for this + * label). If these aren't the semantics, the semantics should be changed + * to this. + * + * The output module interface needs changing, so that the `isextern' flag + * is passed to the module, so that it can be easily tested for. + */ diff --git a/vere/ext/nasm/asm/listing.c b/vere/ext/nasm/asm/listing.c new file mode 100644 index 0000000..186b8b4 --- /dev/null +++ b/vere/ext/nasm/asm/listing.c @@ -0,0 +1,415 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * listing.c listing file generator for the Netwide Assembler + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "nasmlib.h" +#include "error.h" +#include "strlist.h" +#include "listing.h" + +#define LIST_MAX_LEN 1024 /* something sensible */ +#define LIST_INDENT 40 +#define LIST_HEXBIT 18 + +static const char xdigit[] = "0123456789ABCDEF"; + +#define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]); + +uint64_t list_options, active_list_options; + +static char listline[LIST_MAX_LEN]; +static bool listlinep; + +static struct strlist *list_errors; + +static char listdata[2 * LIST_INDENT]; /* we need less than that actually */ +static int32_t listoffset; + +static int32_t listlineno; + +static int suppress; /* for INCBIN & TIMES special cases */ + +static int listlevel, listlevel_e; + +static FILE *listfp; + +static void list_emit(void) +{ + int i; + const struct strlist_entry *e; + + if (listlinep || *listdata) { + fprintf(listfp, "%6"PRId32" ", listlineno); + + if (listdata[0]) + fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1, + listdata); + else + fprintf(listfp, "%*s", LIST_HEXBIT + 10, ""); + + if (listlevel_e) + fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""), + listlevel_e); + else if (listlinep) + fprintf(listfp, " "); + + if (listlinep) + fprintf(listfp, " %s", listline); + + putc('\n', listfp); + listlinep = false; + listdata[0] = '\0'; + } + + if (list_errors) { + static const char fillchars[] = " --***XX"; + char fillchar; + + strlist_for_each(e, list_errors) { + fprintf(listfp, "%6"PRId32" ", listlineno); + fillchar = fillchars[e->pvt.u & ERR_MASK]; + for (i = 0; i < LIST_HEXBIT; i++) + putc(fillchar, listfp); + + if (listlevel_e) + fprintf(listfp, " %s<%d>", (listlevel < 10 ? " " : ""), + listlevel_e); + else + fprintf(listfp, " "); + + fprintf(listfp, " %s\n", e->str); + } + + strlist_free(&list_errors); + } +} + +static void list_cleanup(void) +{ + if (!listfp) + return; + + list_emit(); + fclose(listfp); + listfp = NULL; + active_list_options = 0; +} + +static void list_init(const char *fname) +{ + enum file_flags flags = NF_TEXT; + + if (listfp) + list_cleanup(); + + if (!fname || fname[0] == '\0') { + listfp = NULL; + return; + } + + if (list_option('w')) + flags |= NF_IOLBF; + + listfp = nasm_open_write(fname, flags); + if (!listfp) { + nasm_nonfatal("unable to open listing file `%s'", fname); + return; + } + + active_list_options = list_options | 1; + + *listline = '\0'; + listlineno = 0; + list_errors = NULL; + listlevel = 0; + suppress = 0; +} + +static void list_out(int64_t offset, char *str) +{ + if (strlen(listdata) + strlen(str) > LIST_HEXBIT) { + strcat(listdata, "-"); + list_emit(); + } + if (!listdata[0]) + listoffset = offset; + strcat(listdata, str); +} + +static void list_address(int64_t offset, const char *brackets, + int64_t addr, int size) +{ + char q[20]; + char *r = q; + + nasm_assert(size <= 8); + + *r++ = brackets[0]; + while (size--) { + HEX(r, addr); + addr >>= 8; + r += 2; + } + *r++ = brackets[1]; + *r = '\0'; + list_out(offset, q); +} + +static void list_size(int64_t offset, const char *tag, uint64_t size) +{ + char buf[64]; + const char *fmt; + + if (list_option('d')) + fmt = "<%s %"PRIu64">"; + else + fmt = "<%s %"PRIX64"h>"; + + snprintf(buf, sizeof buf, fmt, tag, size); + list_out(offset, buf); +} + +static void list_output(const struct out_data *data) +{ + char q[24]; + uint64_t size = data->size; + uint64_t offset = data->offset; + const uint8_t *p = data->data; + + + if (!listfp || suppress || user_nolist) + return; + + switch (data->type) { + case OUT_ZERODATA: + if (size > 16) { + list_size(offset, "zero", size); + break; + } else { + p = zero_buffer; + } + /* fall through */ + case OUT_RAWDATA: + { + if (size == 0) { + if (!listdata[0]) + listoffset = data->offset; + } else if (p) { + while (size--) { + HEX(q, *p); + q[2] = '\0'; + list_out(offset++, q); + p++; + } + } else { + /* Used for listing on non-code generation passes with -Lp */ + list_size(offset, "len", size); + } + break; + } + case OUT_ADDRESS: + list_address(offset, "[]", data->toffset, size); + break; + case OUT_SEGMENT: + q[0] = '['; + memset(q+1, 's', size << 1); + q[(size << 1)+1] = ']'; + q[(size << 1)+2] = '\0'; + list_out(offset, q); + offset += size; + break; + case OUT_RELADDR: + list_address(offset, "()", data->toffset, size); + break; + case OUT_RESERVE: + { + if (size > 8) { + list_size(offset, "res", size); + } else { + memset(q, '?', size << 1); + q[size << 1] = '\0'; + list_out(offset, q); + } + break; + } + default: + panic(); + } +} + +static void list_line(int type, int32_t lineno, const char *line) +{ + (void)type; + + if (!listfp) + return; + + if (user_nolist) + return; + + list_emit(); + if (lineno >= 0) + listlineno = lineno; + listlinep = true; + strlcpy(listline, line, LIST_MAX_LEN-3); + memcpy(listline + LIST_MAX_LEN-4, "...", 4); + listlevel_e = listlevel; +} + +static void list_uplevel(int type, int64_t size) +{ + if (!listfp) + return; + + switch (type) { + case LIST_INCBIN: + suppress |= 1; + list_size(listoffset, "bin", size); + break; + + case LIST_TIMES: + suppress |= 2; + list_size(listoffset, "rep", size); + break; + + case LIST_INCLUDE: + listlevel++; + break; + + default: + listlevel++; + break; + } +} + +static void list_downlevel(int type) +{ + if (!listfp) + return; + + switch (type) { + case LIST_INCBIN: + suppress &= ~1; + break; + + case LIST_TIMES: + suppress &= ~2; + break; + + default: + listlevel--; + break; + } +} + +static void printf_func(2, 3) list_error(errflags severity, const char *fmt, ...) +{ + va_list ap; + + if (!listfp) + return; + + if (!list_errors) + list_errors = strlist_alloc(false); + + va_start(ap, fmt); + strlist_vprintf(list_errors, fmt, ap); + va_end(ap); + strlist_tail(list_errors)->pvt.u = severity; + + if ((severity & ERR_MASK) >= ERR_FATAL) + list_emit(); +} + +static void list_set_offset(uint64_t offset) +{ + listoffset = offset; +} + +static void list_update_options(const char *str) +{ + bool state = true; + unsigned char c; + uint64_t mask; + + while ((c = *str++)) { + switch (c) { + case '+': + state = true; + break; + case '-': + state = false; + break; + default: + mask = list_option_mask(c); + if (state) + list_options |= mask; + else + list_options &= ~mask; + break; + } + } +} + +enum directive_result list_pragma(const struct pragma *pragma) +{ + switch (pragma->opcode) { + case D_OPTIONS: + list_update_options(pragma->tail); + return DIRR_OK; + + default: + return DIRR_UNKNOWN; + } +} + +static const struct lfmt nasm_list = { + list_init, + list_cleanup, + list_output, + list_line, + list_uplevel, + list_downlevel, + list_error, + list_set_offset +}; + +const struct lfmt *lfmt = &nasm_list; diff --git a/vere/ext/nasm/asm/listing.h b/vere/ext/nasm/asm/listing.h new file mode 100644 index 0000000..639a56e --- /dev/null +++ b/vere/ext/nasm/asm/listing.h @@ -0,0 +1,196 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * listing.h header file for listing.c + */ + +#ifndef NASM_LISTING_H +#define NASM_LISTING_H + +#include "nasm.h" + +/* + * List-file generators should look like this: + */ +struct lfmt { + /* + * Called to initialize the listing file generator. Before this + * is called, the other routines will silently do nothing when + * called. The `char *' parameter is the file name to write the + * listing to. + */ + void (*init)(const char *fname); + + /* + * Called to clear stuff up and close the listing file. + */ + void (*cleanup)(void); + + /* + * Called to output binary data. Parameters are: the offset; + * the data; the data type. Data types are similar to the + * output-format interface, only OUT_ADDRESS will _always_ be + * displayed as if it's relocatable, so ensure that any non- + * relocatable address has been converted to OUT_RAWDATA by + * then. + */ + void (*output)(const struct out_data *data); + + /* + * Called to send a text line to the listing generator. The + * `int' parameter is LIST_READ or LIST_MACRO depending on + * whether the line came directly from an input file or is the + * result of a multi-line macro expansion. + * + * If a line number is provided, print it; if the line number is + * -1 then use the same line number as the previous call. + */ + void (*line)(int type, int32_t lineno, const char *line); + + /* + * Called to change one of the various levelled mechanisms in the + * listing generator. LIST_INCLUDE and LIST_MACRO can be used to + * increase the nesting level of include files and macro + * expansions; LIST_TIMES and LIST_INCBIN switch on the two + * binary-output-suppression mechanisms for large-scale + * pseudo-instructions; the size argument prints the size or + * repetiiton count. + * + * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that + * it indicates the beginning of the expansion of a `nolist' + * macro, so anything under that level won't be expanded unless + * it includes another file. + */ + void (*uplevel)(int type, int64_t size); + + /* + * Reverse the effects of uplevel. + */ + void (*downlevel)(int type); + + /* + * Called on a warning or error, with the error message. + */ + void printf_func_ptr(2, 3) (*error)(errflags severity, const char *fmt, ...); + + /* + * Update the current offset. Used to give the listing generator + * an offset to work with when doing things like + * uplevel(LIST_TIMES) or uplevel(LIST_INCBIN); see + * list_set_offset(); + */ + void (*set_offset)(uint64_t offset); +}; + +extern const struct lfmt *lfmt; +extern bool user_nolist; + +/* + * list_options are the requested options; active_list_options gets + * set when a pass starts. + * + * These are simple bitmasks of ASCII-64 mapping directly to option + * letters. + */ +extern uint64_t list_options, active_list_options; + +/* + * This maps the characters a-z, A-Z and 0-9 onto a 64-bit bitmask. + * Bit 0 is used to indicate that the listing engine is active, and + * bit 1 is reserved, so this will only return mask bits 2 and higher; + * as there are 62 possible characters this fits nicely. + * + * The mask returned is 0 for invalid characters, accessing no bits at + * all. + * + * This isn't particularly efficient code, but just about every + * instance of it should be fed a constant, so the entire function can + * be precomputed at compile time. The only cases where the full + * computation is needed is when parsing the -L option or %pragma list + * options, neither of which is in any way performance critical. + * + * The character + represents ALL listing options except -Lw (flush + * after every line.) + */ +static inline const_func uint64_t list_option_mask_val(unsigned char x) +{ + if (x >= 'a') { + if (x > 'z') + return 0; + x = x - 'a' + 2; + } else if (x >= 'A') { + if (x > 'Z') + return 0; + x = x - 'A' + 2 + 26; + } else if (x >= '0') { + if (x > '9') + return 0; + x = x - '0' + 2 + 26*2; + } else { + return 0; + } + + return UINT64_C(1) << x; +} + +static inline const_func uint64_t list_option_mask(unsigned char x) +{ + if (x == '+') + return ~(list_option_mask_val('w') | 3); + else + return list_option_mask_val(x); +} + +/* Return true if the listing engine is active and a certain option is set. */ +static inline pure_func bool list_option(unsigned char x) +{ + return unlikely(active_list_options & list_option_mask(x)); +} + +/* We can't test this using active_list_options for obvious reasons... */ +static inline pure_func bool list_on_every_pass(void) +{ + return unlikely(list_options & list_option_mask('p')); +} + +/* Is the listing engine active? */ +static inline pure_func bool list_active(void) +{ + return (active_list_options & 1); +} + +/* Pragma handler */ +enum directive_result list_pragma(const struct pragma *); + +#endif diff --git a/vere/ext/nasm/asm/nasm.c b/vere/ext/nasm/asm/nasm.c new file mode 100644 index 0000000..76c70f6 --- /dev/null +++ b/vere/ext/nasm/asm/nasm.c @@ -0,0 +1,2352 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2022 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * The Netwide Assembler main program module + */ + +#include "compiler.h" + + +#include "nasm.h" +#include "nasmlib.h" +#include "nctype.h" +#include "error.h" +#include "saa.h" +#include "raa.h" +#include "floats.h" +#include "stdscan.h" +#include "insns.h" +#include "preproc.h" +#include "parser.h" +#include "eval.h" +#include "assemble.h" +#include "labels.h" +#include "outform.h" +#include "listing.h" +#include "iflag.h" +#include "quote.h" +#include "ver.h" + +/* + * This is the maximum number of optimization passes to do. If we ever + * find a case where the optimizer doesn't naturally converge, we might + * have to drop this value so the assembler doesn't appear to just hang. + */ +#define MAX_OPTIMIZE (INT_MAX >> 1) + +struct forwrefinfo { /* info held on forward refs. */ + int lineno; + int operand; +}; + +const char *_progname; + +static void parse_cmdline(int, char **, int); +static void assemble_file(const char *, struct strlist *); +static bool skip_this_pass(errflags severity); +static void usage(void); +static void help(FILE *); + +struct error_format { + const char *beforeline; /* Before line number, if present */ + const char *afterline; /* After line number, if present */ + const char *beforemsg; /* Before actual message */ +}; + +static const struct error_format errfmt_gnu = { ":", "", ": " }; +static const struct error_format errfmt_msvc = { "(", ")", " : " }; +static const struct error_format *errfmt = &errfmt_gnu; +static struct strlist *warn_list; +static struct nasm_errhold *errhold_stack; + +unsigned int debug_nasm; /* Debugging messages? */ + +static bool using_debug_info, opt_verbose_info; +static const char *debug_format; + +#ifndef ABORT_ON_PANIC +# define ABORT_ON_PANIC 0 +#endif +static bool abort_on_panic = ABORT_ON_PANIC; +static bool keep_all; + +bool tasm_compatible_mode = false; +enum pass_type _pass_type; +const char * const _pass_types[] = +{ + "init", "preproc-only", "first", "optimize", "stabilize", "final" +}; +int64_t _passn; +int globalrel = 0; +int globalbnd = 0; + +struct compile_time official_compile_time; + +const char *inname; +const char *outname; +static const char *listname; +static const char *errname; + +static int64_t globallineno; /* for forward-reference tracking */ + +const struct ofmt *ofmt = &OF_DEFAULT; +const struct ofmt_alias *ofmt_alias = NULL; +const struct dfmt *dfmt; + +FILE *error_file; /* Where to write error messages */ + +FILE *ofile = NULL; +struct optimization optimizing = + { MAX_OPTIMIZE, OPTIM_ALL_ENABLED }; /* number of optimization passes to take */ +static int cmd_sb = 16; /* by default */ + +iflag_t cpu, cmd_cpu; + +struct location location; +bool in_absolute; /* Flag we are in ABSOLUTE seg */ +struct location absolute; /* Segment/offset inside ABSOLUTE */ + +static struct RAA *offsets; + +static struct SAA *forwrefs; /* keep track of forward references */ +static const struct forwrefinfo *forwref; + +static struct strlist *include_path; +static enum preproc_opt ppopt; + +#define OP_NORMAL (1U << 0) +#define OP_PREPROCESS (1U << 1) +#define OP_DEPEND (1U << 2) + +static unsigned int operating_mode; + +/* Dependency flags */ +static bool depend_emit_phony = false; +static bool depend_missing_ok = false; +static const char *depend_target = NULL; +static const char *depend_file = NULL; +struct strlist *depend_list; + +static bool want_usage; +static bool terminate_after_phase; +bool user_nolist = false; + +static char *quote_for_pmake(const char *str); +static char *quote_for_wmake(const char *str); +static char *(*quote_for_make)(const char *) = quote_for_pmake; + +/* + * Execution limits that can be set via a command-line option or %pragma + */ + +/* + * This is really unlimited; it would take far longer than the + * current age of the universe for this limit to be reached even on + * much faster CPUs than currently exist. +*/ +#define LIMIT_MAX_VAL (INT64_MAX >> 1) + +int64_t nasm_limit[LIMIT_MAX+1]; + +struct limit_info { + const char *name; + const char *help; + int64_t default_val; +}; +/* The order here must match enum nasm_limit in nasm.h */ +static const struct limit_info limit_info[LIMIT_MAX+1] = { + { "passes", "total number of passes", LIMIT_MAX_VAL }, + { "stalled-passes", "number of passes without forward progress", 1000 }, + { "macro-levels", "levels of macro expansion", 10000 }, + { "macro-tokens", "tokens processed during single-lime macro expansion", 10000000 }, + { "mmacros", "multi-line macros before final return", 100000 }, + { "rep", "%rep count", 1000000 }, + { "eval", "expression evaluation descent", 8192 }, + { "lines", "total source lines processed", 2000000000 } +}; + +static void set_default_limits(void) +{ + int i; + size_t rl; + int64_t new_limit; + + for (i = 0; i <= LIMIT_MAX; i++) + nasm_limit[i] = limit_info[i].default_val; + + /* + * Try to set a sensible default value for the eval depth based + * on the limit of the stack size, if knowable... + */ + rl = nasm_get_stack_size_limit(); + new_limit = rl / (128 * sizeof(void *)); /* Sensible heuristic */ + if (new_limit < nasm_limit[LIMIT_EVAL]) + nasm_limit[LIMIT_EVAL] = new_limit; +} + +enum directive_result +nasm_set_limit(const char *limit, const char *valstr) +{ + int i; + int64_t val; + bool rn_error; + int errlevel; + + if (!limit) + limit = ""; + if (!valstr) + valstr = ""; + + for (i = 0; i <= LIMIT_MAX; i++) { + if (!nasm_stricmp(limit, limit_info[i].name)) + break; + } + if (i > LIMIT_MAX) { + if (not_started()) + errlevel = ERR_WARNING|WARN_OTHER|ERR_USAGE; + else + errlevel = ERR_WARNING|WARN_PRAGMA_UNKNOWN; + nasm_error(errlevel, "unknown limit: `%s'", limit); + return DIRR_ERROR; + } + + if (!nasm_stricmp(valstr, "unlimited")) { + val = LIMIT_MAX_VAL; + } else { + val = readnum(valstr, &rn_error); + if (rn_error || val < 0) { + if (not_started()) + errlevel = ERR_WARNING|WARN_OTHER|ERR_USAGE; + else + errlevel = ERR_WARNING|WARN_PRAGMA_BAD; + nasm_error(errlevel, "invalid limit value: `%s'", valstr); + return DIRR_ERROR; + } + if (val > LIMIT_MAX_VAL) + val = LIMIT_MAX_VAL; + } + + nasm_limit[i] = val; + return DIRR_OK; +} + +int64_t switch_segment(int32_t segment) +{ + location.segment = segment; + if (segment == NO_SEG) { + location.offset = absolute.offset; + in_absolute = true; + } else { + location.offset = raa_read(offsets, segment); + in_absolute = false; + } + return location.offset; +} + +static void set_curr_offs(int64_t l_off) +{ + if (in_absolute) + absolute.offset = l_off; + else + offsets = raa_write(offsets, location.segment, l_off); +} + +static void increment_offset(int64_t delta) +{ + if (unlikely(delta == 0)) + return; + + location.offset += delta; + set_curr_offs(location.offset); +} + +/* + * Define system-defined macros that are not part of + * macros/standard.mac. + */ +static void define_macros(void) +{ + const struct compile_time * const oct = &official_compile_time; + char temp[128]; + + if (oct->have_local) { + strftime(temp, sizeof temp, "__?DATE?__=\"%Y-%m-%d\"", &oct->local); + pp_pre_define(temp); + strftime(temp, sizeof temp, "__?DATE_NUM?__=%Y%m%d", &oct->local); + pp_pre_define(temp); + strftime(temp, sizeof temp, "__?TIME?__=\"%H:%M:%S\"", &oct->local); + pp_pre_define(temp); + strftime(temp, sizeof temp, "__?TIME_NUM?__=%H%M%S", &oct->local); + pp_pre_define(temp); + } + + if (oct->have_gm) { + strftime(temp, sizeof temp, "__?UTC_DATE?__=\"%Y-%m-%d\"", &oct->gm); + pp_pre_define(temp); + strftime(temp, sizeof temp, "__?UTC_DATE_NUM?__=%Y%m%d", &oct->gm); + pp_pre_define(temp); + strftime(temp, sizeof temp, "__?UTC_TIME?__=\"%H:%M:%S\"", &oct->gm); + pp_pre_define(temp); + strftime(temp, sizeof temp, "__?UTC_TIME_NUM?__=%H%M%S", &oct->gm); + pp_pre_define(temp); + } + + if (oct->have_posix) { + snprintf(temp, sizeof temp, "__?POSIX_TIME?__=%"PRId64, oct->posix); + pp_pre_define(temp); + } + + /* + * In case if output format is defined by alias + * we have to put shortname of the alias itself here + * otherwise ABI backward compatibility gets broken. + */ + snprintf(temp, sizeof(temp), "__?OUTPUT_FORMAT?__=%s", + ofmt_alias ? ofmt_alias->shortname : ofmt->shortname); + pp_pre_define(temp); + + /* + * Output-format specific macros. + */ + if (ofmt->stdmac) + pp_extra_stdmac(ofmt->stdmac); + + /* + * Debug format, if any + */ + if (dfmt != &null_debug_form) { + snprintf(temp, sizeof(temp), "__?DEBUG_FORMAT?__=%s", dfmt->shortname); + pp_pre_define(temp); + } +} + +/* + * Initialize the preprocessor, set up the include path, and define + * the system-included macros. This is called between passes 1 and 2 + * of parsing the command options; ofmt and dfmt are defined at this + * point. + * + * Command-line specified preprocessor directives (-p, -d, -u, + * --pragma, --before) are processed after this function. + */ +static void preproc_init(struct strlist *ipath) +{ + pp_init(ppopt); + define_macros(); + pp_include_path(ipath); +} + +static void emit_dependencies(struct strlist *list) +{ + FILE *deps; + int linepos, len; + bool wmake = (quote_for_make == quote_for_wmake); + const char *wrapstr, *nulltarget; + const struct strlist_entry *l; + + if (!list) + return; + + wrapstr = wmake ? " &\n " : " \\\n "; + nulltarget = wmake ? "\t%null\n" : ""; + + if (depend_file && strcmp(depend_file, "-")) { + deps = nasm_open_write(depend_file, NF_TEXT); + if (!deps) { + nasm_nonfatal("unable to write dependency file `%s'", depend_file); + return; + } + } else { + deps = stdout; + } + + linepos = fprintf(deps, "%s :", depend_target); + strlist_for_each(l, list) { + char *file = quote_for_make(l->str); + len = strlen(file); + if (linepos + len > 62 && linepos > 1) { + fputs(wrapstr, deps); + linepos = 1; + } + fprintf(deps, " %s", file); + linepos += len+1; + nasm_free(file); + } + fputs("\n\n", deps); + + strlist_for_each(l, list) { + if (depend_emit_phony) { + char *file = quote_for_make(l->str); + fprintf(deps, "%s :\n%s\n", file, nulltarget); + nasm_free(file); + } + } + + strlist_free(&list); + + if (deps != stdout) + fclose(deps); +} + +/* Convert a struct tm to a POSIX-style time constant */ +static int64_t make_posix_time(const struct tm *tm) +{ + int64_t t; + int64_t y = tm->tm_year; + + /* See IEEE 1003.1:2004, section 4.14 */ + + t = (y-70)*365 + (y-69)/4 - (y-1)/100 + (y+299)/400; + t += tm->tm_yday; + t *= 24; + t += tm->tm_hour; + t *= 60; + t += tm->tm_min; + t *= 60; + t += tm->tm_sec; + + return t; +} + +/* + * Quote a filename string if and only if it is necessary. + * It is considered necessary if any one of these is true: + * 1. The filename contains control characters; + * 2. The filename starts or ends with a space or quote mark; + * 3. The filename contains more than one space in a row; + * 4. The filename is empty. + * + * The filename is returned in a newly allocated buffer. + */ +static char *nasm_quote_filename(const char *fn) +{ + const unsigned char *p = + (const unsigned char *)fn; + size_t len; + + if (!p || !*p) + return nasm_strdup("\"\""); + + if (*p <= ' ' || nasm_isquote(*p)) { + goto quote; + } else { + unsigned char cutoff = ' '; + + while (*p) { + if (*p < cutoff) + goto quote; + cutoff = ' ' + (*p == ' '); + p++; + } + if (p[-1] <= ' ' || nasm_isquote(p[-1])) + goto quote; + } + + /* Quoting not necessary */ + return nasm_strdup(fn); + +quote: + len = strlen(fn); + return nasm_quote(fn, &len); +} + +static void timestamp(void) +{ + struct compile_time * const oct = &official_compile_time; + const struct tm *tp, *best_gm; + + time(&oct->t); + + best_gm = NULL; + + tp = localtime(&oct->t); + if (tp) { + oct->local = *tp; + best_gm = &oct->local; + oct->have_local = true; + } + + tp = gmtime(&oct->t); + if (tp) { + oct->gm = *tp; + best_gm = &oct->gm; + oct->have_gm = true; + if (!oct->have_local) + oct->local = oct->gm; + } else { + oct->gm = oct->local; + } + + if (best_gm) { + oct->posix = make_posix_time(best_gm); + oct->have_posix = true; + } +} + +int main(int argc, char **argv) +{ + /* Do these as early as possible */ + error_file = stderr; + _progname = argv[0]; + if (!_progname || !_progname[0]) + _progname = "nasm"; + + timestamp(); + + set_cpu(NULL); + cmd_cpu = cpu; + + set_default_limits(); + + include_path = strlist_alloc(true); + + _pass_type = PASS_INIT; + _passn = 0; + + want_usage = terminate_after_phase = false; + + nasm_ctype_init(); + src_init(); + + /* + * We must call init_labels() before the command line parsing, + * because we may be setting prefixes/suffixes from the command + * line. + */ + init_labels(); + + offsets = raa_init(); + forwrefs = saa_init((int32_t)sizeof(struct forwrefinfo)); + + operating_mode = OP_NORMAL; + + parse_cmdline(argc, argv, 1); + if (terminate_after_phase) { + if (want_usage) + usage(); + return 1; + } + + /* At this point we have ofmt and the name of the desired debug format */ + if (!using_debug_info) { + /* No debug info, redirect to the null backend (empty stubs) */ + dfmt = &null_debug_form; + } else if (!debug_format) { + /* Default debug format for this backend */ + dfmt = ofmt->default_dfmt; + } else { + dfmt = dfmt_find(ofmt, debug_format); + if (!dfmt) { + nasm_fatalf(ERR_USAGE, "unrecognized debug format `%s' for output format `%s'", + debug_format, ofmt->shortname); + } + } + + /* Have we enabled TASM mode? */ + if (tasm_compatible_mode) { + ppopt |= PP_TASM; + nasm_ctype_tasm_mode(); + } + preproc_init(include_path); + + parse_cmdline(argc, argv, 2); + if (terminate_after_phase) { + if (want_usage) + usage(); + return 1; + } + + /* Save away the default state of warnings */ + init_warnings(); + + /* Dependency filename if we are also doing other things */ + if (!depend_file && (operating_mode & ~OP_DEPEND)) { + if (outname) + depend_file = nasm_strcat(outname, ".d"); + else + depend_file = filename_set_extension(inname, ".d"); + } + + /* + * If no output file name provided and this + * is preprocess mode, we're perfectly + * fine to output into stdout. + */ + if (!outname && !(operating_mode & OP_PREPROCESS)) { + outname = filename_set_extension(inname, ofmt->extension); + if (!strcmp(outname, inname)) { + outname = "nasm.out"; + nasm_warn(WARN_OTHER, "default output file same as input, using `%s' for output\n", outname); + } + } + + depend_list = (operating_mode & OP_DEPEND) ? strlist_alloc(true) : NULL; + + if (!depend_target) + depend_target = quote_for_make(outname); + + if (!(operating_mode & (OP_PREPROCESS|OP_NORMAL))) { + char *line; + + if (depend_missing_ok) + pp_include_path(NULL); /* "assume generated" */ + + pp_reset(inname, PP_DEPS, depend_list); + ofile = NULL; + while ((line = pp_getline())) + nasm_free(line); + pp_cleanup_pass(); + reset_warnings(); + } else if (operating_mode & OP_PREPROCESS) { + char *line; + const char *file_name = NULL; + char *quoted_file_name = nasm_quote_filename(file_name); + int32_t linnum = 0; + int32_t lineinc = 0; + FILE *out; + + if (outname) { + ofile = nasm_open_write(outname, NF_TEXT); + if (!ofile) + nasm_fatal("unable to open output file `%s'", outname); + out = ofile; + } else { + ofile = NULL; + out = stdout; + } + + location.known = false; + + _pass_type = PASS_PREPROC; + pp_reset(inname, PP_PREPROC, depend_list); + + while ((line = pp_getline())) { + /* + * We generate %line directives if needed for later programs + */ + struct src_location where = src_where(); + if (file_name != where.filename) { + file_name = where.filename; + linnum = -1; /* Force a new %line statement */ + lineinc = file_name ? 1 : 0; + nasm_free(quoted_file_name); + quoted_file_name = nasm_quote_filename(file_name); + } else if (lineinc) { + if (linnum + lineinc == where.lineno) { + /* Add one blank line to account for increment */ + fputc('\n', out); + linnum += lineinc; + } else if (linnum - lineinc == where.lineno) { + /* + * Standing still, probably a macro. Set increment + * to zero. + */ + lineinc = 0; + } + } else { + /* lineinc == 0 */ + if (linnum + 1 == where.lineno) + lineinc = 1; + } + + /* Skip blank lines if we will need a %line anyway */ + if (linnum == -1 && !line[0]) + continue; + + if (linnum != where.lineno) { + fprintf(out, "%%line %"PRId32"%+"PRId32" %s\n", + where.lineno, lineinc, quoted_file_name); + } + linnum = where.lineno + lineinc; + + fputs(line, out); + fputc('\n', out); + } + + nasm_free(quoted_file_name); + + pp_cleanup_pass(); + reset_warnings(); + if (ofile) + fclose(ofile); + if (ofile && terminate_after_phase && !keep_all) + remove(outname); + ofile = NULL; + } + + if (operating_mode & OP_NORMAL) { + ofile = nasm_open_write(outname, (ofmt->flags & OFMT_TEXT) ? NF_TEXT : NF_BINARY); + if (!ofile) + nasm_fatal("unable to open output file `%s'", outname); + + ofmt->init(); + dfmt->init(); + + assemble_file(inname, depend_list); + + if (!terminate_after_phase) { + ofmt->cleanup(); + cleanup_labels(); + fflush(ofile); + if (ferror(ofile)) + nasm_nonfatal("write error on output file `%s'", outname); + } + + if (ofile) { + fclose(ofile); + if (terminate_after_phase && !keep_all) + remove(outname); + ofile = NULL; + } + } + + pp_cleanup_session(); + + if (depend_list && !terminate_after_phase) + emit_dependencies(depend_list); + + if (want_usage) + usage(); + + raa_free(offsets); + saa_free(forwrefs); + eval_cleanup(); + stdscan_cleanup(); + src_free(); + strlist_free(&include_path); + + return terminate_after_phase; +} + +/* + * Get a parameter for a command line option. + * First arg must be in the form of e.g. -f... + */ +static char *get_param(char *p, char *q, bool *advance) +{ + *advance = false; + if (p[2]) /* the parameter's in the option */ + return nasm_skip_spaces(p + 2); + if (q && q[0]) { + *advance = true; + return q; + } + nasm_nonfatalf(ERR_USAGE, "option `-%c' requires an argument", p[1]); + return NULL; +} + +/* + * Copy a filename + */ +static void copy_filename(const char **dst, const char *src, const char *what) +{ + if (*dst) + nasm_fatal("more than one %s file specified: %s\n", what, src); + + *dst = nasm_strdup(src); +} + +/* + * Convert a string to a POSIX make-safe form + */ +static char *quote_for_pmake(const char *str) +{ + const char *p; + char *os, *q; + + size_t n = 1; /* Terminating zero */ + size_t nbs = 0; + + if (!str) + return NULL; + + for (p = str; *p; p++) { + switch (*p) { + case ' ': + case '\t': + /* Convert N backslashes + ws -> 2N+1 backslashes + ws */ + n += nbs + 2; + nbs = 0; + break; + case '$': + case '#': + nbs = 0; + n += 2; + break; + case '\\': + nbs++; + n++; + break; + default: + nbs = 0; + n++; + break; + } + } + + /* Convert N backslashes at the end of filename to 2N backslashes */ + n += nbs; + + os = q = nasm_malloc(n); + + nbs = 0; + for (p = str; *p; p++) { + switch (*p) { + case ' ': + case '\t': + q = mempset(q, '\\', nbs); + *q++ = '\\'; + *q++ = *p; + nbs = 0; + break; + case '$': + *q++ = *p; + *q++ = *p; + nbs = 0; + break; + case '#': + *q++ = '\\'; + *q++ = *p; + nbs = 0; + break; + case '\\': + *q++ = *p; + nbs++; + break; + default: + *q++ = *p; + nbs = 0; + break; + } + } + + q = mempset(q, '\\', nbs); + *q = '\0'; + + return os; +} + +/* + * Convert a string to a Watcom make-safe form + */ +static char *quote_for_wmake(const char *str) +{ + const char *p; + char *os, *q; + bool quote = false; + + size_t n = 1; /* Terminating zero */ + + if (!str) + return NULL; + + for (p = str; *p; p++) { + switch (*p) { + case ' ': + case '\t': + case '&': + quote = true; + n++; + break; + case '\"': + quote = true; + n += 2; + break; + case '$': + case '#': + n += 2; + break; + default: + n++; + break; + } + } + + if (quote) + n += 2; + + os = q = nasm_malloc(n); + + if (quote) + *q++ = '\"'; + + for (p = str; *p; p++) { + switch (*p) { + case '$': + case '#': + *q++ = '$'; + *q++ = *p; + break; + case '\"': + *q++ = *p; + *q++ = *p; + break; + default: + *q++ = *p; + break; + } + } + + if (quote) + *q++ = '\"'; + + *q = '\0'; + + return os; +} + +enum text_options { + OPT_BOGUS, + OPT_VERSION, + OPT_HELP, + OPT_ABORT_ON_PANIC, + OPT_MANGLE, + OPT_INCLUDE, + OPT_PRAGMA, + OPT_BEFORE, + OPT_LIMIT, + OPT_KEEP_ALL, + OPT_NO_LINE, + OPT_DEBUG, + OPT_REPRODUCIBLE +}; +enum need_arg { + ARG_NO, + ARG_YES, + ARG_MAYBE +}; + +struct textargs { + const char *label; + enum text_options opt; + enum need_arg need_arg; + int pvt; +}; +static const struct textargs textopts[] = { + {"v", OPT_VERSION, ARG_NO, 0}, + {"version", OPT_VERSION, ARG_NO, 0}, + {"help", OPT_HELP, ARG_NO, 0}, + {"abort-on-panic", OPT_ABORT_ON_PANIC, ARG_NO, 0}, + {"prefix", OPT_MANGLE, ARG_YES, LM_GPREFIX}, + {"postfix", OPT_MANGLE, ARG_YES, LM_GSUFFIX}, + {"gprefix", OPT_MANGLE, ARG_YES, LM_GPREFIX}, + {"gpostfix", OPT_MANGLE, ARG_YES, LM_GSUFFIX}, + {"lprefix", OPT_MANGLE, ARG_YES, LM_LPREFIX}, + {"lpostfix", OPT_MANGLE, ARG_YES, LM_LSUFFIX}, + {"include", OPT_INCLUDE, ARG_YES, 0}, + {"pragma", OPT_PRAGMA, ARG_YES, 0}, + {"before", OPT_BEFORE, ARG_YES, 0}, + {"limit-", OPT_LIMIT, ARG_YES, 0}, + {"keep-all", OPT_KEEP_ALL, ARG_NO, 0}, + {"no-line", OPT_NO_LINE, ARG_NO, 0}, + {"debug", OPT_DEBUG, ARG_MAYBE, 0}, + {"reproducible", OPT_REPRODUCIBLE, ARG_NO, 0}, + {NULL, OPT_BOGUS, ARG_NO, 0} +}; + +static void show_version(void) +{ + printf("NASM version %s compiled on %s%s\n", + nasm_version, nasm_date, nasm_compile_options); + exit(0); +} + +static bool stopoptions = false; +static bool process_arg(char *p, char *q, int pass) +{ + char *param; + bool advance = false; + + if (!p || !p[0]) + return false; + + if (p[0] == '-' && !stopoptions) { + if (strchr("oOfpPdDiIlLFXuUZwW", p[1])) { + /* These parameters take values */ + if (!(param = get_param(p, q, &advance))) + return advance; + } + + switch (p[1]) { + case 's': + if (pass == 1) + error_file = stdout; + break; + + case 'o': /* output file */ + if (pass == 2) + copy_filename(&outname, param, "output"); + break; + + case 'f': /* output format */ + if (pass == 1) { + ofmt = ofmt_find(param, &ofmt_alias); + if (!ofmt) { + nasm_fatalf(ERR_USAGE, "unrecognised output format `%s' - use -hf for a list", param); + } + } + break; + + case 'O': /* Optimization level */ + if (pass == 1) { + int opt; + + if (!*param) { + /* Naked -O == -Ox */ + optimizing.level = MAX_OPTIMIZE; + } else { + while (*param) { + switch (*param) { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + opt = strtoul(param, ¶m, 10); + + /* -O0 -> optimizing.level == -1, 0.98 behaviour */ + /* -O1 -> optimizing.level == 0, 0.98.09 behaviour */ + if (opt < 2) + optimizing.level = opt - 1; + else + optimizing.level = opt; + break; + + case 'v': + case '+': + param++; + opt_verbose_info = true; + break; + + case 'x': + param++; + optimizing.level = MAX_OPTIMIZE; + break; + + default: + nasm_fatal("unknown optimization option -O%c\n", + *param); + break; + } + } + if (optimizing.level > MAX_OPTIMIZE) + optimizing.level = MAX_OPTIMIZE; + } + } + break; + + case 'p': /* pre-include */ + case 'P': + if (pass == 2) + pp_pre_include(param); + break; + + case 'd': /* pre-define */ + case 'D': + if (pass == 2) + pp_pre_define(param); + break; + + case 'u': /* un-define */ + case 'U': + if (pass == 2) + pp_pre_undefine(param); + break; + + case 'i': /* include search path */ + case 'I': + if (pass == 1) + strlist_add(include_path, param); + break; + + case 'l': /* listing file */ + if (pass == 2) + copy_filename(&listname, param, "listing"); + break; + + case 'L': /* listing options */ + if (pass == 2) { + while (*param) + list_options |= list_option_mask(*param++); + } + break; + + case 'Z': /* error messages file */ + if (pass == 1) + copy_filename(&errname, param, "error"); + break; + + case 'F': /* specify debug format */ + if (pass == 1) { + using_debug_info = true; + debug_format = param; + } + break; + + case 'X': /* specify error reporting format */ + if (pass == 1) { + if (!nasm_stricmp("vc", param) || !nasm_stricmp("msvc", param) || !nasm_stricmp("ms", param)) + errfmt = &errfmt_msvc; + else if (!nasm_stricmp("gnu", param) || !nasm_stricmp("gcc", param)) + errfmt = &errfmt_gnu; + else + nasm_fatalf(ERR_USAGE, "unrecognized error reporting format `%s'", param); + } + break; + + case 'g': + if (pass == 1) { + using_debug_info = true; + if (p[2]) + debug_format = nasm_skip_spaces(p + 2); + } + break; + + case 'h': + help(stdout); + exit(0); /* never need usage message here */ + break; + + case 'y': + /* legacy option */ + dfmt_list(stdout); + exit(0); + break; + + case 't': + if (pass == 1) + tasm_compatible_mode = true; + break; + + case 'v': + show_version(); + break; + + case 'e': /* preprocess only */ + case 'E': + if (pass == 1) + operating_mode = OP_PREPROCESS; + break; + + case 'a': /* assemble only - don't preprocess */ + if (pass == 1) + ppopt |= PP_TRIVIAL; + break; + + case 'w': + case 'W': + if (pass == 2) + set_warning_status(param); + break; + + case 'M': + if (pass == 1) { + switch (p[2]) { + case 'W': + quote_for_make = quote_for_wmake; + break; + case 'D': + case 'F': + case 'T': + case 'Q': + advance = true; + break; + default: + break; + } + } else { + switch (p[2]) { + case 0: + operating_mode = OP_DEPEND; + break; + case 'G': + operating_mode = OP_DEPEND; + depend_missing_ok = true; + break; + case 'P': + depend_emit_phony = true; + break; + case 'D': + operating_mode |= OP_DEPEND; + if (q && (q[0] != '-' || q[1] == '\0')) { + depend_file = q; + advance = true; + } + break; + case 'F': + depend_file = q; + advance = true; + break; + case 'T': + depend_target = q; + advance = true; + break; + case 'Q': + depend_target = quote_for_make(q); + advance = true; + break; + case 'W': + /* handled in pass 1 */ + break; + default: + nasm_nonfatalf(ERR_USAGE, "unknown dependency option `-M%c'", p[2]); + break; + } + } + if (advance && (!q || !q[0])) { + nasm_nonfatalf(ERR_USAGE, "option `-M%c' requires a parameter", p[2]); + break; + } + break; + + case '-': + { + const struct textargs *tx; + size_t olen, plen; + char *eqsave; + enum text_options opt; + + p += 2; + + if (!*p) { /* -- => stop processing options */ + stopoptions = true; + break; + } + + olen = 0; /* Placate gcc at lower optimization levels */ + plen = strlen(p); + for (tx = textopts; tx->label; tx++) { + olen = strlen(tx->label); + + if (olen > plen) + continue; + + if (nasm_memicmp(p, tx->label, olen)) + continue; + + if (tx->label[olen-1] == '-') + break; /* Incomplete option */ + + if (!p[olen] || p[olen] == '=') + break; /* Complete option */ + } + + if (!tx->label) { + nasm_nonfatalf(ERR_USAGE, "unrecognized option `--%s'", p); + } + + opt = tx->opt; + + eqsave = param = strchr(p+olen, '='); + if (param) + *param++ = '\0'; + + switch (tx->need_arg) { + case ARG_YES: /* Argument required, and may be standalone */ + if (!param) { + param = q; + advance = true; + } + + /* Note: a null string is a valid parameter */ + if (!param) { + nasm_nonfatalf(ERR_USAGE, "option `--%s' requires an argument", p); + opt = OPT_BOGUS; + } + break; + + case ARG_NO: /* Argument prohibited */ + if (param) { + nasm_nonfatalf(ERR_USAGE, "option `--%s' does not take an argument", p); + opt = OPT_BOGUS; + } + break; + + case ARG_MAYBE: /* Argument permitted, but must be attached with = */ + break; + } + + switch (opt) { + case OPT_BOGUS: + break; /* We have already errored out */ + case OPT_VERSION: + show_version(); + break; + case OPT_ABORT_ON_PANIC: + abort_on_panic = true; + break; + case OPT_MANGLE: + if (pass == 2) + set_label_mangle(tx->pvt, param); + break; + case OPT_INCLUDE: + if (pass == 2) + pp_pre_include(q); + break; + case OPT_PRAGMA: + if (pass == 2) + pp_pre_command("%pragma", param); + break; + case OPT_BEFORE: + if (pass == 2) + pp_pre_command(NULL, param); + break; + case OPT_LIMIT: + if (pass == 1) + nasm_set_limit(p+olen, param); + break; + case OPT_KEEP_ALL: + keep_all = true; + break; + case OPT_NO_LINE: + ppopt |= PP_NOLINE; + break; + case OPT_DEBUG: + debug_nasm = param ? strtoul(param, NULL, 10) : debug_nasm+1; + break; + case OPT_REPRODUCIBLE: + reproducible = true; + break; + case OPT_HELP: + help(stdout); + exit(0); + default: + panic(); + } + + if (eqsave) + *eqsave = '='; /* Restore = argument separator */ + + break; + } + + default: + nasm_nonfatalf(ERR_USAGE, "unrecognised option `-%c'", p[1]); + break; + } + } else if (pass == 2) { + /* In theory we could allow multiple input files... */ + copy_filename(&inname, p, "input"); + } + + return advance; +} + +#define ARG_BUF_DELTA 128 + +static void process_respfile(FILE * rfile, int pass) +{ + char *buffer, *p, *q, *prevarg; + int bufsize, prevargsize; + + bufsize = prevargsize = ARG_BUF_DELTA; + buffer = nasm_malloc(ARG_BUF_DELTA); + prevarg = nasm_malloc(ARG_BUF_DELTA); + prevarg[0] = '\0'; + + while (1) { /* Loop to handle all lines in file */ + p = buffer; + while (1) { /* Loop to handle long lines */ + q = fgets(p, bufsize - (p - buffer), rfile); + if (!q) + break; + p += strlen(p); + if (p > buffer && p[-1] == '\n') + break; + if (p - buffer > bufsize - 10) { + int offset; + offset = p - buffer; + bufsize += ARG_BUF_DELTA; + buffer = nasm_realloc(buffer, bufsize); + p = buffer + offset; + } + } + + if (!q && p == buffer) { + if (prevarg[0]) + process_arg(prevarg, NULL, pass); + nasm_free(buffer); + nasm_free(prevarg); + return; + } + + /* + * Play safe: remove CRs, LFs and any spurious ^Zs, if any of + * them are present at the end of the line. + */ + *(p = &buffer[strcspn(buffer, "\r\n\032")]) = '\0'; + + while (p > buffer && nasm_isspace(p[-1])) + *--p = '\0'; + + p = nasm_skip_spaces(buffer); + + if (process_arg(prevarg, p, pass)) + *p = '\0'; + + if ((int) strlen(p) > prevargsize - 10) { + prevargsize += ARG_BUF_DELTA; + prevarg = nasm_realloc(prevarg, prevargsize); + } + strncpy(prevarg, p, prevargsize); + } +} + +/* Function to process args from a string of args, rather than the + * argv array. Used by the environment variable and response file + * processing. + */ +static void process_args(char *args, int pass) +{ + char *p, *q, *arg, *prevarg; + char separator = ' '; + + p = args; + if (*p && *p != '-') + separator = *p++; + arg = NULL; + while (*p) { + q = p; + while (*p && *p != separator) + p++; + while (*p == separator) + *p++ = '\0'; + prevarg = arg; + arg = q; + if (process_arg(prevarg, arg, pass)) + arg = NULL; + } + if (arg) + process_arg(arg, NULL, pass); +} + +static void process_response_file(const char *file, int pass) +{ + char str[2048]; + FILE *f = nasm_open_read(file, NF_TEXT); + if (!f) { + perror(file); + exit(-1); + } + while (fgets(str, sizeof str, f)) { + process_args(str, pass); + } + fclose(f); +} + +static void parse_cmdline(int argc, char **argv, int pass) +{ + FILE *rfile; + char *envreal, *envcopy = NULL, *p; + + /* + * Initialize all the warnings to their default state, including + * warning index 0 used for "always on". + */ + memcpy(warning_state, warning_default, sizeof warning_state); + + /* + * First, process the NASMENV environment variable. + */ + envreal = getenv("NASMENV"); + if (envreal) { + envcopy = nasm_strdup(envreal); + process_args(envcopy, pass); + nasm_free(envcopy); + } + + /* + * Now process the actual command line. + */ + while (--argc) { + bool advance; + argv++; + if (argv[0][0] == '@') { + /* + * We have a response file, so process this as a set of + * arguments like the environment variable. This allows us + * to have multiple arguments on a single line, which is + * different to the -@resp file processing below for regular + * NASM. + */ + process_response_file(argv[0]+1, pass); + argc--; + argv++; + } + if (!stopoptions && argv[0][0] == '-' && argv[0][1] == '@') { + p = get_param(argv[0], argc > 1 ? argv[1] : NULL, &advance); + if (p) { + rfile = nasm_open_read(p, NF_TEXT); + if (rfile) { + process_respfile(rfile, pass); + fclose(rfile); + } else { + nasm_nonfatalf(ERR_USAGE, "unable to open response file `%s'", p); + } + } + } else + advance = process_arg(argv[0], argc > 1 ? argv[1] : NULL, pass); + argv += advance, argc -= advance; + } + + /* + * Look for basic command line typos. This definitely doesn't + * catch all errors, but it might help cases of fumbled fingers. + */ + if (pass != 2) + return; + + if (!inname) + nasm_fatalf(ERR_USAGE, "no input file specified"); + else if ((errname && !strcmp(inname, errname)) || + (outname && !strcmp(inname, outname)) || + (listname && !strcmp(inname, listname)) || + (depend_file && !strcmp(inname, depend_file))) + nasm_fatalf(ERR_USAGE, "will not overwrite input file"); + + if (errname) { + error_file = nasm_open_write(errname, NF_TEXT); + if (!error_file) { + error_file = stderr; /* Revert to default! */ + nasm_fatalf(ERR_USAGE, "cannot open file `%s' for error messages", errname); + } + } +} + +static void forward_refs(insn *instruction) +{ + int i; + struct forwrefinfo *fwinf; + + instruction->forw_ref = false; + + if (!optimizing.level) + return; /* For -O0 don't bother */ + + if (!forwref) + return; + + if (forwref->lineno != globallineno) + return; + + instruction->forw_ref = true; + do { + instruction->oprs[forwref->operand].opflags |= OPFLAG_FORWARD; + forwref = saa_rstruct(forwrefs); + } while (forwref && forwref->lineno == globallineno); + + if (!pass_first()) + return; + + for (i = 0; i < instruction->operands; i++) { + if (instruction->oprs[i].opflags & OPFLAG_FORWARD) { + fwinf = saa_wstruct(forwrefs); + fwinf->lineno = globallineno; + fwinf->operand = i; + } + } +} + +static void process_insn(insn *instruction) +{ + int32_t n; + int64_t l; + + if (!instruction->times) + return; /* Nothing to do... */ + + nasm_assert(instruction->times > 0); + + /* + * NOTE: insn_size() can change instruction->times + * (usually to 1) when called. + */ + if (!pass_final()) { + int64_t start = location.offset; + for (n = 1; n <= instruction->times; n++) { + l = insn_size(location.segment, location.offset, + globalbits, instruction); + /* l == -1 -> invalid instruction */ + if (l != -1) + increment_offset(l); + } + if (list_option('p')) { + struct out_data dummy; + memset(&dummy, 0, sizeof dummy); + dummy.type = OUT_RAWDATA; /* Handled specially with .data NULL */ + dummy.offset = start; + dummy.size = location.offset - start; + lfmt->output(&dummy); + } + } else { + l = assemble(location.segment, location.offset, + globalbits, instruction); + /* We can't get an invalid instruction here */ + increment_offset(l); + + if (instruction->times > 1) { + lfmt->uplevel(LIST_TIMES, instruction->times); + for (n = 2; n <= instruction->times; n++) { + l = assemble(location.segment, location.offset, + globalbits, instruction); + increment_offset(l); + } + lfmt->downlevel(LIST_TIMES); + } + } +} + +static void assemble_file(const char *fname, struct strlist *depend_list) +{ + char *line; + insn output_ins; + uint64_t prev_offset_changed; + int64_t stall_count = 0; /* Make sure we make forward progress... */ + + switch (cmd_sb) { + case 16: + break; + case 32: + if (!iflag_cpu_level_ok(&cmd_cpu, IF_386)) + nasm_fatal("command line: 32-bit segment size requires a higher cpu"); + break; + case 64: + if (!iflag_cpu_level_ok(&cmd_cpu, IF_X86_64)) + nasm_fatal("command line: 64-bit segment size requires a higher cpu"); + break; + default: + panic(); + break; + } + + prev_offset_changed = INT64_MAX; + + if (listname && !keep_all) { + /* Remove the list file in case we die before the output pass */ + remove(listname); + } + + while (!terminate_after_phase && !pass_final()) { + _passn++; + switch (pass_type()) { + case PASS_INIT: + _pass_type = PASS_FIRST; + break; + case PASS_OPT: + if (global_offset_changed) + break; /* One more optimization pass */ + /* fall through */ + default: + _pass_type++; + break; + } + + global_offset_changed = 0; + + /* + * Create a warning buffer list unless we are in + * pass 2 (everything will be emitted immediately in pass 2.) + */ + if (warn_list) { + if (warn_list->nstr || pass_final()) + strlist_free(&warn_list); + } + + if (!pass_final() && !warn_list) + warn_list = strlist_alloc(false); + + globalbits = cmd_sb; /* set 'bits' to command line default */ + cpu = cmd_cpu; + if (listname) { + if (pass_final() || list_on_every_pass()) { + lfmt->init(listname); + } else if (list_active()) { + /* + * Looks like we used the list engine on a previous pass, + * but now it is turned off, presumably via %pragma -p + */ + lfmt->cleanup(); + if (!keep_all) + remove(listname); + } + } + + in_absolute = false; + if (!pass_first()) { + saa_rewind(forwrefs); + forwref = saa_rstruct(forwrefs); + raa_free(offsets); + offsets = raa_init(); + } + location.segment = NO_SEG; + location.offset = 0; + if (pass_first()) + location.known = true; + ofmt->reset(); + switch_segment(ofmt->section(NULL, &globalbits)); + pp_reset(fname, PP_NORMAL, pass_final() ? depend_list : NULL); + + globallineno = 0; + + while ((line = pp_getline())) { + if (++globallineno > nasm_limit[LIMIT_LINES]) + nasm_fatal("overall line count exceeds the maximum %"PRId64"\n", + nasm_limit[LIMIT_LINES]); + + /* + * Here we parse our directives; this is not handled by the + * main parser. + */ + if (process_directives(line)) + goto end_of_line; /* Just do final cleanup */ + + /* Not a directive, or even something that starts with [ */ + parse_line(line, &output_ins); + forward_refs(&output_ins); + process_insn(&output_ins); + cleanup_insn(&output_ins); + + end_of_line: + nasm_free(line); + } /* end while (line = pp_getline... */ + + pp_cleanup_pass(); + + /* We better not be having an error hold still... */ + nasm_assert(!errhold_stack); + + if (global_offset_changed) { + switch (pass_type()) { + case PASS_OPT: + /* + * This is the only pass type that can be executed more + * than once, and therefore has the ability to stall. + */ + if (global_offset_changed < prev_offset_changed) { + prev_offset_changed = global_offset_changed; + stall_count = 0; + } else { + stall_count++; + } + + if (stall_count > nasm_limit[LIMIT_STALLED] || + pass_count() >= nasm_limit[LIMIT_PASSES]) { + /* No convergence, almost certainly dead */ + nasm_nonfatalf(ERR_UNDEAD, + "unable to find valid values for all labels " + "after %"PRId64" passes; " + "stalled for %"PRId64", giving up.", + pass_count(), stall_count); + nasm_nonfatalf(ERR_UNDEAD, + "Possible causes: recursive EQUs, macro abuse."); + } + break; + + case PASS_STAB: + /*! + *!phase [off] phase error during stabilization + *! warns about symbols having changed values during + *! the second-to-last assembly pass. This is not + *! inherently fatal, but may be a source of bugs. + */ + nasm_warn(WARN_PHASE|ERR_UNDEAD, + "phase error during stabilization " + "pass, hoping for the best"); + break; + + case PASS_FINAL: + nasm_nonfatalf(ERR_UNDEAD, + "phase error during code generation pass"); + break; + + default: + /* This is normal, we'll keep going... */ + break; + } + } + + reset_warnings(); + } + + if (opt_verbose_info && pass_final()) { + /* -On and -Ov switches */ + nasm_info("assembly required 1+%"PRId64"+2 passes\n", pass_count()-3); + } + + lfmt->cleanup(); + strlist_free(&warn_list); +} + +/** + * get warning index; 0 if this is non-suppressible. + */ +static size_t warn_index(errflags severity) +{ + size_t index; + + if ((severity & ERR_MASK) >= ERR_FATAL) + return 0; /* Fatal errors are never suppressible */ + + /* Warnings MUST HAVE a warning category specifier! */ + nasm_assert((severity & (ERR_MASK|WARN_MASK)) != ERR_WARNING); + + index = WARN_IDX(severity); + nasm_assert(index < WARN_IDX_ALL); + + return index; +} + +static bool skip_this_pass(errflags severity) +{ + errflags type = severity & ERR_MASK; + + /* + * See if it's a pass-specific error or warning which should be skipped. + * We can never skip fatal errors as by definition they cannot be + * resumed from. + */ + if (type >= ERR_FATAL) + return false; + + /* + * ERR_LISTMSG messages are always skipped; the list file + * receives them anyway as this function is not consulted + * for sending to the list file. + */ + if (type == ERR_LISTMSG) + return true; + + /* + * This message not applicable unless it is the last pass we are going + * to execute; this can be either the final code-generation pass or + * the single pass executed in preproc-only mode. + */ + return (severity & ERR_PASS2) && !pass_final_or_preproc(); +} + +/** + * check for suppressed message (usually warnings or notes) + * + * @param severity the severity of the warning or error + * @return true if we should abort error/warning printing + */ +static bool is_suppressed(errflags severity) +{ + /* Fatal errors must never be suppressed */ + if ((severity & ERR_MASK) >= ERR_FATAL) + return false; + + /* This error/warning is pointless if we are dead anyway */ + if ((severity & ERR_UNDEAD) && terminate_after_phase) + return true; + + if (!(warning_state[warn_index(severity)] & WARN_ST_ENABLED)) + return true; + + if (!(severity & ERR_PP_LISTMACRO)) + return pp_suppress_error(severity); + + return false; +} + +/** + * Return the true error type (the ERR_MASK part) of the given + * severity, accounting for warnings that may need to be promoted to + * error. + * + * @param severity the severity of the warning or error + * @return true if we should error out + */ +static errflags true_error_type(errflags severity) +{ + const uint8_t warn_is_err = WARN_ST_ENABLED|WARN_ST_ERROR; + int type; + + type = severity & ERR_MASK; + + /* Promote warning to error? */ + if (type == ERR_WARNING) { + uint8_t state = warning_state[warn_index(severity)]; + if ((state & warn_is_err) == warn_is_err) + type = ERR_NONFATAL; + } + + return type; +} + +/* + * The various error type prefixes + */ +static const char * const error_pfx_table[ERR_MASK+1] = { + ";;; ", "debug: ", "info: ", "warning: ", + "error: ", "fatal: ", "critical: ", "panic: " +}; +static const char no_file_name[] = "nasm"; /* What to print if no file name */ + +/* + * For fatal/critical/panic errors, kill this process. + */ +static fatal_func die_hard(errflags true_type, errflags severity) +{ + fflush(NULL); + + if (true_type == ERR_PANIC && abort_on_panic) + abort(); + + if (ofile) { + fclose(ofile); + if (!keep_all) + remove(outname); + ofile = NULL; + } + + if (severity & ERR_USAGE) + usage(); + + /* Terminate immediately */ + exit(true_type - ERR_FATAL + 1); +} + +/* + * Returns the struct src_location appropriate for use, after some + * potential filename mangling. + */ +static struct src_location error_where(errflags severity) +{ + struct src_location where; + + if (severity & ERR_NOFILE) { + where.filename = NULL; + where.lineno = 0; + } else { + where = src_where_error(); + + if (!where.filename) { + where.filename = + inname && inname[0] ? inname : + outname && outname[0] ? outname : + NULL; + where.lineno = 0; + } + } + + return where; +} + +/* + * error reporting for critical and panic errors: minimize + * the amount of system dependencies for getting a message out, + * and in particular try to avoid memory allocations. + */ +fatal_func nasm_verror_critical(errflags severity, const char *fmt, va_list args) +{ + struct src_location where; + errflags true_type = severity & ERR_MASK; + static bool been_here = false; + + if (unlikely(been_here)) + abort(); /* Recursive error... just die */ + + been_here = true; + + where = error_where(severity); + if (!where.filename) + where.filename = no_file_name; + + fputs(error_pfx_table[severity], error_file); + fputs(where.filename, error_file); + if (where.lineno) { + fprintf(error_file, "%s%"PRId32"%s", + errfmt->beforeline, where.lineno, errfmt->afterline); + } + fputs(errfmt->beforemsg, error_file); + vfprintf(error_file, fmt, args); + fputc('\n', error_file); + + die_hard(true_type, severity); +} + +/** + * Stack of tentative error hold lists. + */ +struct nasm_errtext { + struct nasm_errtext *next; + char *msg; /* Owned by this structure */ + struct src_location where; /* Owned by the srcfile system */ + errflags severity; + errflags true_type; +}; +struct nasm_errhold { + struct nasm_errhold *up; + struct nasm_errtext *head, **tail; +}; + +static void nasm_free_error(struct nasm_errtext *et) +{ + nasm_free(et->msg); + nasm_free(et); +} + +static void nasm_issue_error(struct nasm_errtext *et); + +struct nasm_errhold *nasm_error_hold_push(void) +{ + struct nasm_errhold *eh; + + nasm_new(eh); + eh->up = errhold_stack; + eh->tail = &eh->head; + errhold_stack = eh; + + return eh; +} + +void nasm_error_hold_pop(struct nasm_errhold *eh, bool issue) +{ + struct nasm_errtext *et, *etmp; + + /* Allow calling with a null argument saying no hold in the first place */ + if (!eh) + return; + + /* This *must* be the current top of the errhold stack */ + nasm_assert(eh == errhold_stack); + + if (eh->head) { + if (issue) { + if (eh->up) { + /* Commit the current hold list to the previous level */ + *eh->up->tail = eh->head; + eh->up->tail = eh->tail; + } else { + /* Issue errors */ + list_for_each_safe(et, etmp, eh->head) + nasm_issue_error(et); + } + } else { + /* Free the list, drop errors */ + list_for_each_safe(et, etmp, eh->head) + nasm_free_error(et); + } + } + + errhold_stack = eh->up; + nasm_free(eh); +} + +/** + * common error reporting + * This is the common back end of the error reporting schemes currently + * implemented. It prints the nature of the warning and then the + * specific error message to error_file and may or may not return. It + * doesn't return if the error severity is a "panic" or "debug" type. + * + * @param severity the severity of the warning or error + * @param fmt the printf style format string + */ +void nasm_verror(errflags severity, const char *fmt, va_list args) +{ + struct nasm_errtext *et; + errflags true_type = true_error_type(severity); + + if (true_type >= ERR_CRITICAL) + nasm_verror_critical(severity, fmt, args); + + if (is_suppressed(severity)) + return; + + nasm_new(et); + et->severity = severity; + et->true_type = true_type; + et->msg = nasm_vasprintf(fmt, args); + et->where = error_where(severity); + + if (errhold_stack && true_type <= ERR_NONFATAL) { + /* It is a tentative error */ + *errhold_stack->tail = et; + errhold_stack->tail = &et->next; + } else { + nasm_issue_error(et); + } + + /* + * Don't do this before then, if we do, we lose messages in the list + * file, as the list file is only generated in the last pass. + */ + if (skip_this_pass(severity)) + return; + + if (!(severity & (ERR_HERE|ERR_PP_LISTMACRO))) + pp_error_list_macros(severity); +} + +/* + * Actually print, list and take action on an error + */ +static void nasm_issue_error(struct nasm_errtext *et) +{ + const char *pfx; + char warnsuf[64]; /* Warning suffix */ + char linestr[64]; /* Formatted line number if applicable */ + const errflags severity = et->severity; + const errflags true_type = et->true_type; + const struct src_location where = et->where; + + if (severity & ERR_NO_SEVERITY) + pfx = ""; + else + pfx = error_pfx_table[true_type]; + + *warnsuf = 0; + if ((severity & (ERR_MASK|ERR_HERE|ERR_PP_LISTMACRO)) == ERR_WARNING) { + /* + * It's a warning without ERR_HERE defined, and we are not already + * unwinding the macros that led us here. + */ + snprintf(warnsuf, sizeof warnsuf, " [-w+%s%s]", + (true_type >= ERR_NONFATAL) ? "error=" : "", + warning_name[warn_index(severity)]); + } + + *linestr = 0; + if (where.lineno) { + snprintf(linestr, sizeof linestr, "%s%"PRId32"%s", + errfmt->beforeline, where.lineno, errfmt->afterline); + } + + if (!skip_this_pass(severity)) { + const char *file = where.filename ? where.filename : no_file_name; + const char *here = ""; + + if (severity & ERR_HERE) { + here = where.filename ? " here" : " in an unknown location"; + } + + if (warn_list && true_type < ERR_NONFATAL) { + /* + * Buffer up warnings until we either get an error + * or we are on the code-generation pass. + */ + strlist_printf(warn_list, "%s%s%s%s%s%s%s", + file, linestr, errfmt->beforemsg, + pfx, et->msg, here, warnsuf); + } else { + /* + * Actually output an error. If we have buffered + * warnings, and this is a non-warning, output them now. + */ + if (true_type >= ERR_NONFATAL && warn_list) { + strlist_write(warn_list, "\n", error_file); + strlist_free(&warn_list); + } + + fprintf(error_file, "%s%s%s%s%s%s%s\n", + file, linestr, errfmt->beforemsg, + pfx, et->msg, here, warnsuf); + } + } + + /* Are we recursing from error_list_macros? */ + if (severity & ERR_PP_LISTMACRO) + goto done; + + /* + * Don't suppress this with skip_this_pass(), or we don't get + * pass1 or preprocessor warnings in the list file + */ + if (severity & ERR_HERE) { + if (where.lineno) + lfmt->error(severity, "%s%s at %s:%"PRId32"%s", + pfx, et->msg, where.filename, where.lineno, warnsuf); + else if (where.filename) + lfmt->error(severity, "%s%s in file %s%s", + pfx, et->msg, where.filename, warnsuf); + else + lfmt->error(severity, "%s%s in an unknown location%s", + pfx, et->msg, warnsuf); + } else { + lfmt->error(severity, "%s%s%s", pfx, et->msg, warnsuf); + } + + if (skip_this_pass(severity)) + goto done; + + if (true_type >= ERR_FATAL) + die_hard(true_type, severity); + else if (true_type >= ERR_NONFATAL) + terminate_after_phase = true; + +done: + nasm_free_error(et); +} + +static void usage(void) +{ + fprintf(error_file, "Type %s -h for help.\n", _progname); +} + +static void help(FILE *out) +{ + int i; + + fprintf(out, + "Usage: %s [-@ response_file] [options...] [--] filename\n" + " %s -v (or --v)\n", + _progname, _progname); + fputs( + "\n" + "Options (values in brackets indicate defaults):\n" + "\n" + " -h show this text and exit (also --help)\n" + " -v (or --v) print the NASM version number and exit\n" + " -@ file response file; one command line option per line\n" + "\n" + " -o outfile write output to outfile\n" + " --keep-all output files will not be removed even if an error happens\n" + "\n" + " -Xformat specify error reporting format (gnu or vc)\n" + " -s redirect error messages to stdout\n" + " -Zfile redirect error messages to file\n" + "\n" + " -M generate Makefile dependencies on stdout\n" + " -MG d:o, missing files assumed generated\n" + " -MF file set Makefile dependency file\n" + " -MD file assemble and generate dependencies\n" + " -MT file dependency target name\n" + " -MQ file dependency target name (quoted)\n" + " -MP emit phony targets\n" + "\n" + " -f format select output file format\n" + , out); + ofmt_list(ofmt, out); + fputs( + "\n" + " -g generate debugging information\n" + " -F format select a debugging format (output format dependent)\n" + " -gformat same as -g -F format\n" + , out); + dfmt_list(out); + fputs( + "\n" + " -l listfile write listing to a list file\n" + " -Lflags... add optional information to the list file\n" + " -Lb show builtin macro packages (standard and %use)\n" + " -Ld show byte and repeat counts in decimal, not hex\n" + " -Le show the preprocessed output\n" + " -Lf ignore .nolist (force output)\n" + " -Lm show multi-line macro calls with expanded parameters\n" + " -Lp output a list file every pass, in case of errors\n" + " -Ls show all single-line macro definitions\n" + " -Lw flush the output after every line (very slow!)\n" + " -L+ enable all listing options except -Lw (very verbose!)\n" + "\n" + " -Oflags... optimize opcodes, immediates and branch offsets\n" + " -O0 no optimization\n" + " -O1 minimal optimization\n" + " -Ox multipass optimization (default)\n" + " -Ov display the number of passes executed at the end\n" + " -t assemble in limited SciTech TASM compatible mode\n" + "\n" + " -E (or -e) preprocess only (writes output to stdout by default)\n" + " -a don't preprocess (assemble only)\n" + " -Ipath add a pathname to the include file path\n" + " -Pfile pre-include a file (also --include)\n" + " -Dmacro[=str] pre-define a macro\n" + " -Umacro undefine a macro\n" + " --pragma str pre-executes a specific %%pragma\n" + " --before str add line (usually a preprocessor statement) before the input\n" + " --no-line ignore %line directives in input\n" + "\n" + " --prefix str prepend the given string to the names of all extern,\n" + " common and global symbols (also --gprefix)\n" + " --suffix str append the given string to the names of all extern,\n" + " common and global symbols (also --gprefix)\n" + " --lprefix str prepend the given string to local symbols\n" + " --lpostfix str append the given string to local symbols\n" + "\n" + " --reproducible attempt to produce run-to-run identical output\n" + "\n" + " -w+x enable warning x (also -Wx)\n" + " -w-x disable warning x (also -Wno-x)\n" + " -w[+-]error promote all warnings to errors (also -Werror)\n" + " -w[+-]error=x promote warning x to errors (also -Werror=x)\n" + , out); + + fprintf(out, " %-20s %s\n", + warning_name[WARN_IDX_ALL], warning_help[WARN_IDX_ALL]); + + for (i = 1; i < WARN_IDX_ALL; i++) { + const char *me = warning_name[i]; + const char *prev = warning_name[i-1]; + const char *next = warning_name[i+1]; + + if (prev) { + int prev_len = strlen(prev); + const char *dash = me; + + while ((dash = strchr(dash+1, '-'))) { + int prefix_len = dash - me; /* Not including final dash */ + if (strncmp(next, me, prefix_len+1)) { + /* Only one or last option with this prefix */ + break; + } + if (prefix_len >= prev_len || + strncmp(prev, me, prefix_len) || + (prev[prefix_len] != '-' && prev[prefix_len] != '\0')) { + /* This prefix is different from the previous option */ + fprintf(out, " %-20.*s all warnings prefixed with \"%.*s\"\n", + prefix_len, me, prefix_len+1, me); + } + } + } + + fprintf(out, " %-20s %s%s\n", + warning_name[i], warning_help[i], + (warning_default[i] & WARN_ST_ERROR) ? " [error]" : + (warning_default[i] & WARN_ST_ENABLED) ? " [on]" : " [off]"); + } + + fputs( + "\n" + " --limit-X val set execution limit X\n" + , out); + + + for (i = 0; i <= LIMIT_MAX; i++) { + fprintf(out, " %-20s %s [", + limit_info[i].name, limit_info[i].help); + if (nasm_limit[i] < LIMIT_MAX_VAL) { + fprintf(out, "%"PRId64"]\n", nasm_limit[i]); + } else { + fputs("unlimited]\n", out); + } + } +} diff --git a/vere/ext/nasm/asm/parser.c b/vere/ext/nasm/asm/parser.c new file mode 100644 index 0000000..6b19ffa --- /dev/null +++ b/vere/ext/nasm/asm/parser.c @@ -0,0 +1,1322 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * parser.c source line parser for the Netwide Assembler + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "insns.h" +#include "nasmlib.h" +#include "error.h" +#include "stdscan.h" +#include "eval.h" +#include "parser.h" +#include "floats.h" +#include "assemble.h" +#include "tables.h" + + +static int end_expression_next(void); + +static struct tokenval tokval; + +static void process_size_override(insn *result, operand *op) +{ + if (tasm_compatible_mode) { + switch (tokval.t_integer) { + /* For TASM compatibility a size override inside the + * brackets changes the size of the operand, not the + * address type of the operand as it does in standard + * NASM syntax. Hence: + * + * mov eax,[DWORD val] + * + * is valid syntax in TASM compatibility mode. Note that + * you lose the ability to override the default address + * type for the instruction, but we never use anything + * but 32-bit flat model addressing in our code. + */ + case S_BYTE: + op->type |= BITS8; + break; + case S_WORD: + op->type |= BITS16; + break; + case S_DWORD: + case S_LONG: + op->type |= BITS32; + break; + case S_QWORD: + op->type |= BITS64; + break; + case S_TWORD: + op->type |= BITS80; + break; + case S_OWORD: + op->type |= BITS128; + break; + default: + nasm_nonfatal("invalid operand size specification"); + break; + } + } else { + /* Standard NASM compatible syntax */ + switch (tokval.t_integer) { + case S_NOSPLIT: + op->eaflags |= EAF_TIMESTWO; + break; + case S_REL: + op->eaflags |= EAF_REL; + break; + case S_ABS: + op->eaflags |= EAF_ABS; + break; + case S_BYTE: + op->disp_size = 8; + op->eaflags |= EAF_BYTEOFFS; + break; + case P_A16: + case P_A32: + case P_A64: + if (result->prefixes[PPS_ASIZE] && + result->prefixes[PPS_ASIZE] != tokval.t_integer) + nasm_nonfatal("conflicting address size specifications"); + else + result->prefixes[PPS_ASIZE] = tokval.t_integer; + break; + case S_WORD: + op->disp_size = 16; + op->eaflags |= EAF_WORDOFFS; + break; + case S_DWORD: + case S_LONG: + op->disp_size = 32; + op->eaflags |= EAF_WORDOFFS; + break; + case S_QWORD: + op->disp_size = 64; + op->eaflags |= EAF_WORDOFFS; + break; + default: + nasm_nonfatal("invalid size specification in" + " effective address"); + break; + } + } +} + +/* + * Braced keywords are parsed here. opmask and zeroing + * decorators can be placed in any order. e.g. zmm1 {k2}{z} or zmm2 + * {z}{k3} decorator(s) are placed at the end of an operand. + */ +static bool parse_braces(decoflags_t *decoflags) +{ + int i, j; + + i = tokval.t_type; + + while (true) { + switch (i) { + case TOKEN_OPMASK: + if (*decoflags & OPMASK_MASK) { + nasm_nonfatal("opmask k%"PRIu64" is already set", + *decoflags & OPMASK_MASK); + *decoflags &= ~OPMASK_MASK; + } + *decoflags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]); + break; + case TOKEN_DECORATOR: + j = tokval.t_integer; + switch (j) { + case BRC_Z: + *decoflags |= Z_MASK; + break; + case BRC_1TO2: + case BRC_1TO4: + case BRC_1TO8: + case BRC_1TO16: + case BRC_1TO32: + *decoflags |= BRDCAST_MASK | VAL_BRNUM(j - BRC_1TO2); + break; + default: + nasm_nonfatal("{%s} is not an expected decorator", + tokval.t_charptr); + break; + } + break; + case ',': + case TOKEN_EOS: + return false; + default: + nasm_nonfatal("only a series of valid decorators expected"); + return true; + } + i = stdscan(NULL, &tokval); + } +} + +static inline unused_func +const expr *next_expr(const expr *e, const expr **next_list) +{ + e++; + if (!e->type) { + if (next_list) { + e = *next_list; + *next_list = NULL; + } else { + e = NULL; + } + } + return e; +} + +static inline void init_operand(operand *op) +{ + memset(op, 0, sizeof *op); + + op->basereg = -1; + op->indexreg = -1; + op->segment = NO_SEG; + op->wrt = NO_SEG; +} + +static int parse_mref(operand *op, const expr *e) +{ + int b, i, s; /* basereg, indexreg, scale */ + int64_t o; /* offset */ + + b = op->basereg; + i = op->indexreg; + s = op->scale; + o = op->offset; + + for (; e->type; e++) { + if (e->type <= EXPR_REG_END) { + bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]); + + if (is_gpr && e->value == 1 && b == -1) { + /* It can be basereg */ + b = e->type; + } else if (i == -1) { + /* Must be index register */ + i = e->type; + s = e->value; + } else { + if (b == -1) + nasm_nonfatal("invalid effective address: two index registers"); + else if (!is_gpr) + nasm_nonfatal("invalid effective address: impossible register"); + else + nasm_nonfatal("invalid effective address: too many registers"); + return -1; + } + } else if (e->type == EXPR_UNKNOWN) { + op->opflags |= OPFLAG_UNKNOWN; + } else if (e->type == EXPR_SIMPLE) { + o += e->value; + } else if (e->type == EXPR_WRT) { + op->wrt = e->value; + } else if (e->type >= EXPR_SEGBASE) { + if (e->value == 1) { + if (op->segment != NO_SEG) { + nasm_nonfatal("invalid effective address: multiple base segments"); + return -1; + } + op->segment = e->type - EXPR_SEGBASE; + } else if (e->value == -1 && + e->type == location.segment + EXPR_SEGBASE && + !(op->opflags & OPFLAG_RELATIVE)) { + op->opflags |= OPFLAG_RELATIVE; + } else { + nasm_nonfatal("invalid effective address: impossible segment base multiplier"); + return -1; + } + } else { + nasm_nonfatal("invalid effective address: bad subexpression type"); + return -1; + } + } + + op->basereg = b; + op->indexreg = i; + op->scale = s; + op->offset = o; + return 0; +} + +static void mref_set_optype(operand *op) +{ + int b = op->basereg; + int i = op->indexreg; + int s = op->scale; + + /* It is memory, but it can match any r/m operand */ + op->type |= MEMORY_ANY; + + if (b == -1 && (i == -1 || s == 0)) { + int is_rel = globalbits == 64 && + !(op->eaflags & EAF_ABS) && + ((globalrel && + !(op->eaflags & EAF_FSGS)) || + (op->eaflags & EAF_REL)); + + op->type |= is_rel ? IP_REL : MEM_OFFS; + } + + if (i != -1) { + opflags_t iclass = nasm_reg_flags[i]; + + if (is_class(XMMREG,iclass)) + op->type |= XMEM; + else if (is_class(YMMREG,iclass)) + op->type |= YMEM; + else if (is_class(ZMMREG,iclass)) + op->type |= ZMEM; + } +} + +/* + * Convert an expression vector returned from evaluate() into an + * extop structure. Return zero on success. Note that the eop + * already has dup and elem set, so we can't clear it here. + */ +static int value_to_extop(expr *vect, extop *eop, int32_t myseg) +{ + eop->type = EOT_DB_NUMBER; + eop->val.num.offset = 0; + eop->val.num.segment = eop->val.num.wrt = NO_SEG; + eop->val.num.relative = false; + + for (; vect->type; vect++) { + if (!vect->value) /* zero term, safe to ignore */ + continue; + + if (vect->type <= EXPR_REG_END) /* false if a register is present */ + return -1; + + if (vect->type == EXPR_UNKNOWN) /* something we can't resolve yet */ + return 0; + + if (vect->type == EXPR_SIMPLE) { + /* Simple number expression */ + eop->val.num.offset += vect->value; + continue; + } + if (eop->val.num.wrt == NO_SEG && !eop->val.num.relative && + vect->type == EXPR_WRT) { + /* WRT term */ + eop->val.num.wrt = vect->value; + continue; + } + + if (!eop->val.num.relative && + vect->type == EXPR_SEGBASE + myseg && vect->value == -1) { + /* Expression of the form: foo - $ */ + eop->val.num.relative = true; + continue; + } + + if (eop->val.num.segment == NO_SEG && + vect->type >= EXPR_SEGBASE && vect->value == 1) { + eop->val.num.segment = vect->type - EXPR_SEGBASE; + continue; + } + + /* Otherwise, badness */ + return -1; + } + + /* We got to the end and it was all okay */ + return 0; +} + +/* + * Parse an extended expression, used by db et al. "elem" is the element + * size; initially comes from the specific opcode (e.g. db == 1) but + * can be overridden. + */ +static int parse_eops(extop **result, bool critical, int elem) +{ + extop *eop = NULL, *prev = NULL; + extop **tail = result; + int sign; + int i = tokval.t_type; + int oper_num = 0; + bool do_subexpr = false; + + *tail = NULL; + + /* End of string is obvious; ) ends a sub-expression list e.g. DUP */ + for (i = tokval.t_type; i != TOKEN_EOS; i = stdscan(NULL, &tokval)) { + char endparen = ')'; /* Is a right paren the end of list? */ + + if (i == ')') + break; + + if (!eop) { + nasm_new(eop); + eop->dup = 1; + eop->elem = elem; + do_subexpr = false; + } + sign = +1; + + /* + * end_expression_next() here is to distinguish this from + * a string used as part of an expression... + */ + if (i == TOKEN_QMARK) { + eop->type = EOT_DB_RESERVE; + } else if (do_subexpr && i == '(') { + extop *subexpr; + + stdscan(NULL, &tokval); /* Skip paren */ + if (parse_eops(&eop->val.subexpr, critical, eop->elem) < 0) + goto fail; + + subexpr = eop->val.subexpr; + if (!subexpr) { + /* Subexpression is empty */ + eop->type = EOT_NOTHING; + } else if (!subexpr->next) { + /* + * Subexpression is a single element, flatten. + * Note that if subexpr has an allocated buffer associated + * with it, freeing it would free the buffer, too, so + * we need to move subexpr up, not eop down. + */ + if (!subexpr->elem) + subexpr->elem = eop->elem; + subexpr->dup *= eop->dup; + nasm_free(eop); + eop = subexpr; + } else { + eop->type = EOT_EXTOP; + } + + /* We should have ended on a closing paren */ + if (tokval.t_type != ')') { + nasm_nonfatal("expected `)' after subexpression, got `%s'", + i == TOKEN_EOS ? + "end of line" : tokval.t_charptr); + goto fail; + } + endparen = 0; /* This time the paren is not the end */ + } else if (i == '%') { + /* %(expression_list) */ + do_subexpr = true; + continue; + } else if (i == TOKEN_SIZE) { + /* Element size override */ + eop->elem = tokval.t_inttwo; + do_subexpr = true; + continue; + } else if (i == TOKEN_STR && end_expression_next()) { + eop->type = EOT_DB_STRING; + eop->val.string.data = tokval.t_charptr; + eop->val.string.len = tokval.t_inttwo; + } else if (i == TOKEN_STRFUNC) { + bool parens = false; + const char *funcname = tokval.t_charptr; + enum strfunc func = tokval.t_integer; + + i = stdscan(NULL, &tokval); + if (i == '(') { + parens = true; + endparen = 0; + i = stdscan(NULL, &tokval); + } + if (i != TOKEN_STR) { + nasm_nonfatal("%s must be followed by a string constant", + funcname); + eop->type = EOT_NOTHING; + } else { + eop->type = EOT_DB_STRING_FREE; + eop->val.string.len = + string_transform(tokval.t_charptr, tokval.t_inttwo, + &eop->val.string.data, func); + if (eop->val.string.len == (size_t)-1) { + nasm_nonfatal("invalid input string to %s", funcname); + eop->type = EOT_NOTHING; + } + } + if (parens && i && i != ')') { + i = stdscan(NULL, &tokval); + if (i != ')') + nasm_nonfatal("unterminated %s function", funcname); + } + } else if (i == '-' || i == '+') { + char *save = stdscan_get(); + struct tokenval tmptok; + + sign = (i == '-') ? -1 : 1; + if (stdscan(NULL, &tmptok) != TOKEN_FLOAT) { + stdscan_set(save); + goto is_expression; + } else { + tokval = tmptok; + goto is_float; + } + } else if (i == TOKEN_FLOAT) { + enum floatize fmt; + is_float: + eop->type = EOT_DB_FLOAT; + + fmt = float_deffmt(eop->elem); + if (fmt == FLOAT_ERR) { + nasm_nonfatal("no %d-bit floating-point format supported", + eop->elem << 3); + eop->val.string.len = 0; + } else if (eop->elem < 1) { + nasm_nonfatal("floating-point constant" + " encountered in unknown instruction"); + /* + * fix suggested by Pedro Gimeno... original line was: + * eop->type = EOT_NOTHING; + */ + eop->val.string.len = 0; + } else { + eop->val.string.len = eop->elem; + + eop = nasm_realloc(eop, sizeof(extop) + eop->val.string.len); + eop->val.string.data = (char *)eop + sizeof(extop); + if (!float_const(tokval.t_charptr, sign, + (uint8_t *)eop->val.string.data, fmt)) + eop->val.string.len = 0; + } + if (!eop->val.string.len) + eop->type = EOT_NOTHING; + } else { + /* anything else, assume it is an expression */ + expr *value; + + is_expression: + value = evaluate(stdscan, NULL, &tokval, NULL, + critical, NULL); + i = tokval.t_type; + if (!value) /* Error in evaluator */ + goto fail; + if (tokval.t_flag & TFLAG_DUP) { + /* Expression followed by DUP */ + if (!is_simple(value)) { + nasm_nonfatal("non-constant argument supplied to DUP"); + goto fail; + } else if (value->value < 0) { + nasm_nonfatal("negative argument supplied to DUP"); + goto fail; + } + eop->dup *= (size_t)value->value; + do_subexpr = true; + continue; + } + if (value_to_extop(value, eop, location.segment)) { + nasm_nonfatal("expression is not simple or relocatable"); + } + } + + if (eop->dup == 0 || eop->type == EOT_NOTHING) { + nasm_free(eop); + } else if (eop->type == EOT_DB_RESERVE && + prev && prev->type == EOT_DB_RESERVE && + prev->elem == eop->elem) { + /* Coalesce multiple EOT_DB_RESERVE */ + prev->dup += eop->dup; + nasm_free(eop); + } else { + /* Add this eop to the end of the chain */ + prev = eop; + *tail = eop; + tail = &eop->next; + } + + oper_num++; + eop = NULL; /* Done with this operand */ + + /* + * We're about to call stdscan(), which will eat the + * comma that we're currently sitting on between + * arguments. However, we'd better check first that it + * _is_ a comma. + */ + if (i == TOKEN_EOS || i == endparen) /* Already at end? */ + break; + if (i != ',') { + i = stdscan(NULL, &tokval); /* eat the comma or final paren */ + if (i == TOKEN_EOS || i == ')') /* got end of expression */ + break; + if (i != ',') { + nasm_nonfatal("comma expected after operand"); + goto fail; + } + } + } + + return oper_num; + +fail: + if (eop) + nasm_free(eop); + return -1; +} + +insn *parse_line(char *buffer, insn *result) +{ + bool insn_is_label = false; + struct eval_hints hints; + int opnum; + bool critical; + bool first; + bool recover; + bool far_jmp_ok; + int i; + + nasm_static_assert(P_none == 0); + +restart_parse: + first = true; + result->forw_ref = false; + + stdscan_reset(); + stdscan_set(buffer); + i = stdscan(NULL, &tokval); + + memset(result->prefixes, P_none, sizeof(result->prefixes)); + result->times = 1; /* No TIMES either yet */ + result->label = NULL; /* Assume no label */ + result->eops = NULL; /* must do this, whatever happens */ + result->operands = 0; /* must initialize this */ + result->evex_rm = 0; /* Ensure EVEX rounding mode is reset */ + result->evex_brerop = -1; /* Reset EVEX broadcasting/ER op position */ + + /* Ignore blank lines */ + if (i == TOKEN_EOS) + goto fail; + + if (i != TOKEN_ID && + i != TOKEN_INSN && + i != TOKEN_PREFIX && + (i != TOKEN_REG || !IS_SREG(tokval.t_integer))) { + nasm_nonfatal("label or instruction expected at start of line"); + goto fail; + } + + if (i == TOKEN_ID || (insn_is_label && i == TOKEN_INSN)) { + /* there's a label here */ + first = false; + result->label = tokval.t_charptr; + i = stdscan(NULL, &tokval); + if (i == ':') { /* skip over the optional colon */ + i = stdscan(NULL, &tokval); + } else if (i == 0) { + /*! + *!label-orphan [on] labels alone on lines without trailing `:' + *!=orphan-labels + *! warns about source lines which contain no instruction but define + *! a label without a trailing colon. This is most likely indicative + *! of a typo, but is technically correct NASM syntax (see \k{syntax}.) + */ + nasm_warn(WARN_LABEL_ORPHAN , + "label alone on a line without a colon might be in error"); + } + if (i != TOKEN_INSN || tokval.t_integer != I_EQU) { + /* + * FIXME: location.segment could be NO_SEG, in which case + * it is possible we should be passing 'absolute.segment'. Look into this. + * Work out whether that is *really* what we should be doing. + * Generally fix things. I think this is right as it is, but + * am still not certain. + */ + define_label(result->label, + in_absolute ? absolute.segment : location.segment, + location.offset, true); + } + } + + /* Just a label here */ + if (i == TOKEN_EOS) + goto fail; + + while (i) { + int slot = PPS_SEG; + + if (i == TOKEN_PREFIX) { + slot = tokval.t_inttwo; + + if (slot == PPS_TIMES) { + /* TIMES is a very special prefix */ + expr *value; + + i = stdscan(NULL, &tokval); + value = evaluate(stdscan, NULL, &tokval, NULL, + pass_stable(), NULL); + i = tokval.t_type; + if (!value) /* Error in evaluator */ + goto fail; + if (!is_simple(value)) { + nasm_nonfatal("non-constant argument supplied to TIMES"); + result->times = 1; + } else { + result->times = value->value; + if (value->value < 0) { + nasm_nonfatalf(ERR_PASS2, "TIMES value %"PRId64" is negative", value->value); + result->times = 0; + } + } + first = false; + continue; + } + } else if (i == TOKEN_REG && IS_SREG(tokval.t_integer)) { + slot = PPS_SEG; + first = false; + } else { + break; /* Not a prefix */ + } + + if (result->prefixes[slot]) { + if (result->prefixes[slot] == tokval.t_integer) + nasm_warn(WARN_OTHER, "instruction has redundant prefixes"); + else + nasm_nonfatal("instruction has conflicting prefixes"); + } + result->prefixes[slot] = tokval.t_integer; + i = stdscan(NULL, &tokval); + first = false; + } + + if (i != TOKEN_INSN) { + int j; + enum prefixes pfx; + + for (j = 0; j < MAXPREFIX; j++) { + if ((pfx = result->prefixes[j]) != P_none) + break; + } + + if (i == 0 && pfx != P_none) { + /* + * Instruction prefixes are present, but no actual + * instruction. This is allowed: at this point we + * invent a notional instruction of RESB 0. + */ + result->opcode = I_RESB; + result->operands = 1; + nasm_zero(result->oprs); + result->oprs[0].type = IMMEDIATE; + result->oprs[0].offset = 0L; + result->oprs[0].segment = result->oprs[0].wrt = NO_SEG; + return result; + } else { + nasm_nonfatal("parser: instruction expected"); + goto fail; + } + } + + result->opcode = tokval.t_integer; + + /* + * INCBIN cannot be satisfied with incorrectly + * evaluated operands, since the correct values _must_ be known + * on the first pass. Hence, even in pass one, we set the + * `critical' flag on calling evaluate(), so that it will bomb + * out on undefined symbols. + */ + critical = pass_final() || (result->opcode == I_INCBIN); + + if (opcode_is_db(result->opcode) || result->opcode == I_INCBIN) { + int oper_num; + + i = stdscan(NULL, &tokval); + + if (first && i == ':') { + /* Really a label */ + insn_is_label = true; + goto restart_parse; + } + first = false; + oper_num = parse_eops(&result->eops, critical, db_bytes(result->opcode)); + if (oper_num < 0) + goto fail; + + if (result->opcode == I_INCBIN) { + /* + * Correct syntax for INCBIN is that there should be + * one string operand, followed by one or two numeric + * operands. + */ + if (!result->eops || result->eops->type != EOT_DB_STRING) + nasm_nonfatal("`incbin' expects a file name"); + else if (result->eops->next && + result->eops->next->type != EOT_DB_NUMBER) + nasm_nonfatal("`incbin': second parameter is" + " non-numeric"); + else if (result->eops->next && result->eops->next->next && + result->eops->next->next->type != EOT_DB_NUMBER) + nasm_nonfatal("`incbin': third parameter is" + " non-numeric"); + else if (result->eops->next && result->eops->next->next && + result->eops->next->next->next) + nasm_nonfatal("`incbin': more than three parameters"); + else + return result; + /* + * If we reach here, one of the above errors happened. + * Throw the instruction away. + */ + goto fail; + } else { + /* DB et al */ + result->operands = oper_num; + if (oper_num == 0) + /*! + *!db-empty [on] no operand for data declaration + *! warns about a \c{DB}, \c{DW}, etc declaration + *! with no operands, producing no output. + *! This is permitted, but often indicative of an error. + *! See \k{db}. + */ + nasm_warn(WARN_DB_EMPTY, "no operand for data declaration"); + } + return result; + } + + /* + * Now we begin to parse the operands. There may be up to four + * of these, separated by commas, and terminated by a zero token. + */ + far_jmp_ok = result->opcode == I_JMP || result->opcode == I_CALL; + + for (opnum = 0; opnum < MAX_OPERANDS; opnum++) { + operand *op = &result->oprs[opnum]; + expr *value; /* used most of the time */ + bool mref = false; /* is this going to be a memory ref? */ + int bracket = 0; /* is it a [] mref, or a "naked" mref? */ + bool mib; /* compound (mib) mref? */ + int setsize = 0; + decoflags_t brace_flags = 0; /* flags for decorators in braces */ + + init_operand(op); + + i = stdscan(NULL, &tokval); + if (i == TOKEN_EOS) + break; /* end of operands: get out of here */ + else if (first && i == ':') { + insn_is_label = true; + goto restart_parse; + } + first = false; + op->type = 0; /* so far, no override */ + /* size specifiers */ + while (i == TOKEN_SPECIAL || i == TOKEN_SIZE) { + switch (tokval.t_integer) { + case S_BYTE: + if (!setsize) /* we want to use only the first */ + op->type |= BITS8; + setsize = 1; + break; + case S_WORD: + if (!setsize) + op->type |= BITS16; + setsize = 1; + break; + case S_DWORD: + case S_LONG: + if (!setsize) + op->type |= BITS32; + setsize = 1; + break; + case S_QWORD: + if (!setsize) + op->type |= BITS64; + setsize = 1; + break; + case S_TWORD: + if (!setsize) + op->type |= BITS80; + setsize = 1; + break; + case S_OWORD: + if (!setsize) + op->type |= BITS128; + setsize = 1; + break; + case S_YWORD: + if (!setsize) + op->type |= BITS256; + setsize = 1; + break; + case S_ZWORD: + if (!setsize) + op->type |= BITS512; + setsize = 1; + break; + case S_TO: + op->type |= TO; + break; + case S_STRICT: + op->type |= STRICT; + break; + case S_FAR: + op->type |= FAR; + break; + case S_NEAR: + op->type |= NEAR; + break; + case S_SHORT: + op->type |= SHORT; + break; + default: + nasm_nonfatal("invalid operand size specification"); + } + i = stdscan(NULL, &tokval); + } + + if (i == '[' || i == TOKEN_MASM_PTR || i == '&') { + /* memory reference */ + mref = true; + bracket += (i == '['); + i = stdscan(NULL, &tokval); + } + + mref_more: + if (mref) { + bool done = false; + bool nofw = false; + + while (!done) { + switch (i) { + case TOKEN_SPECIAL: + case TOKEN_SIZE: + case TOKEN_PREFIX: + process_size_override(result, op); + break; + + case '[': + bracket++; + break; + + case ',': + tokval.t_type = TOKEN_NUM; + tokval.t_integer = 0; + stdscan_set(stdscan_get() - 1); /* rewind the comma */ + done = nofw = true; + break; + + case TOKEN_MASM_FLAT: + i = stdscan(NULL, &tokval); + if (i != ':') { + nasm_nonfatal("unknown use of FLAT in MASM emulation"); + nofw = true; + } + done = true; + break; + + default: + done = nofw = true; + break; + } + + if (!nofw) + i = stdscan(NULL, &tokval); + } + } + + value = evaluate(stdscan, NULL, &tokval, + &op->opflags, critical, &hints); + i = tokval.t_type; + if (op->opflags & OPFLAG_FORWARD) { + result->forw_ref = true; + } + if (!value) /* Error in evaluator */ + goto fail; + + if (i == '[' && !bracket) { + /* displacement[regs] syntax */ + mref = true; + parse_mref(op, value); /* Process what we have so far */ + goto mref_more; + } + + if (i == ':' && (mref || !far_jmp_ok)) { + /* segment override? */ + mref = true; + + /* + * Process the segment override. + */ + if (!IS_SREG(value->type) || value->value != 1 || + value[1].type != 0) { + nasm_nonfatal("invalid segment override"); + } else if (result->prefixes[PPS_SEG]) { + nasm_nonfatal("instruction has conflicting segment overrides"); + } else { + result->prefixes[PPS_SEG] = value->type; + if (IS_FSGS(value->type)) + op->eaflags |= EAF_FSGS; + } + + i = stdscan(NULL, &tokval); /* then skip the colon */ + goto mref_more; + } + + mib = false; + if (mref && bracket && i == ',') { + /* [seg:base+offset,index*scale] syntax (mib) */ + operand o2; /* Index operand */ + + if (parse_mref(op, value)) + goto fail; + + i = stdscan(NULL, &tokval); /* Eat comma */ + value = evaluate(stdscan, NULL, &tokval, &op->opflags, + critical, &hints); + i = tokval.t_type; + if (!value) + goto fail; + + init_operand(&o2); + if (parse_mref(&o2, value)) + goto fail; + + if (o2.basereg != -1 && o2.indexreg == -1) { + o2.indexreg = o2.basereg; + o2.scale = 1; + o2.basereg = -1; + } + + if (op->indexreg != -1 || o2.basereg != -1 || o2.offset != 0 || + o2.segment != NO_SEG || o2.wrt != NO_SEG) { + nasm_nonfatal("invalid mib expression"); + goto fail; + } + + op->indexreg = o2.indexreg; + op->scale = o2.scale; + + if (op->basereg != -1) { + op->hintbase = op->basereg; + op->hinttype = EAH_MAKEBASE; + } else if (op->indexreg != -1) { + op->hintbase = op->indexreg; + op->hinttype = EAH_NOTBASE; + } else { + op->hintbase = -1; + op->hinttype = EAH_NOHINT; + } + + mib = true; + } + + recover = false; + if (mref) { + if (bracket == 1) { + if (i == ']') { + bracket--; + i = stdscan(NULL, &tokval); + } else { + nasm_nonfatal("expecting ] at end of memory operand"); + recover = true; + } + } else if (bracket == 0) { + /* Do nothing */ + } else if (bracket > 0) { + nasm_nonfatal("excess brackets in memory operand"); + recover = true; + } else if (bracket < 0) { + nasm_nonfatal("unmatched ] in memory operand"); + recover = true; + } + + if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) { + /* parse opmask (and zeroing) after an operand */ + recover = parse_braces(&brace_flags); + i = tokval.t_type; + } + if (!recover && i != 0 && i != ',') { + nasm_nonfatal("comma, decorator or end of line expected, got %d", i); + recover = true; + } + } else { /* immediate operand */ + if (i != 0 && i != ',' && i != ':' && + i != TOKEN_DECORATOR && i != TOKEN_OPMASK) { + nasm_nonfatal("comma, colon, decorator or end of " + "line expected after operand"); + recover = true; + } else if (i == ':') { + op->type |= COLON; + } else if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) { + /* parse opmask (and zeroing) after an operand */ + recover = parse_braces(&brace_flags); + } + } + if (recover) { + do { /* error recovery */ + i = stdscan(NULL, &tokval); + } while (i != 0 && i != ','); + } + + /* + * now convert the exprs returned from evaluate() + * into operand descriptions... + */ + op->decoflags |= brace_flags; + + if (mref) { /* it's a memory reference */ + /* A mib reference was fully parsed already */ + if (!mib) { + if (parse_mref(op, value)) + goto fail; + op->hintbase = hints.base; + op->hinttype = hints.type; + } + mref_set_optype(op); + } else if ((op->type & FAR) && !far_jmp_ok) { + nasm_nonfatal("invalid use of FAR operand specifier"); + recover = true; + } else { /* it's not a memory reference */ + if (is_just_unknown(value)) { /* it's immediate but unknown */ + op->type |= IMMEDIATE; + op->opflags |= OPFLAG_UNKNOWN; + op->offset = 0; /* don't care */ + op->segment = NO_SEG; /* don't care again */ + op->wrt = NO_SEG; /* still don't care */ + + if(optimizing.level >= 0 && !(op->type & STRICT)) { + /* Be optimistic */ + op->type |= + UNITY | SBYTEWORD | SBYTEDWORD | UDWORD | SDWORD; + } + } else if (is_reloc(value)) { /* it's immediate */ + uint64_t n = reloc_value(value); + + op->type |= IMMEDIATE; + op->offset = n; + op->segment = reloc_seg(value); + op->wrt = reloc_wrt(value); + op->opflags |= is_self_relative(value) ? OPFLAG_RELATIVE : 0; + + if (is_simple(value)) { + if (n == 1) + op->type |= UNITY; + if (optimizing.level >= 0 && !(op->type & STRICT)) { + if ((uint32_t) (n + 128) <= 255) + op->type |= SBYTEDWORD; + if ((uint16_t) (n + 128) <= 255) + op->type |= SBYTEWORD; + if (n <= UINT64_C(0xFFFFFFFF)) + op->type |= UDWORD; + if (n + UINT64_C(0x80000000) <= UINT64_C(0xFFFFFFFF)) + op->type |= SDWORD; + } + } + } else if (value->type == EXPR_RDSAE) { + /* + * it's not an operand but a rounding or SAE decorator. + * put the decorator information in the (opflag_t) type field + * of previous operand. + */ + opnum--; op--; + switch (value->value) { + case BRC_RN: + case BRC_RU: + case BRC_RD: + case BRC_RZ: + case BRC_SAE: + op->decoflags |= (value->value == BRC_SAE ? SAE : ER); + result->evex_rm = value->value; + break; + default: + nasm_nonfatal("invalid decorator"); + break; + } + } else { /* it's a register */ + opflags_t rs; + uint64_t regset_size = 0; + + if (value->type >= EXPR_SIMPLE || value->value != 1) { + nasm_nonfatal("invalid operand type"); + goto fail; + } + + /* + * We do not allow any kind of expression, except for + * reg+value in which case it is a register set. + */ + for (i = 1; value[i].type; i++) { + if (!value[i].value) + continue; + + switch (value[i].type) { + case EXPR_SIMPLE: + if (!regset_size) { + regset_size = value[i].value + 1; + break; + } + /* fallthrough */ + default: + nasm_nonfatal("invalid operand type"); + goto fail; + } + } + + if ((regset_size & (regset_size - 1)) || + regset_size >= (UINT64_C(1) << REGSET_BITS)) { + nasm_nonfatalf(ERR_PASS2, "invalid register set size"); + regset_size = 0; + } + + /* clear overrides, except TO which applies to FPU regs */ + if (op->type & ~TO) { + /* + * we want to produce a warning iff the specified size + * is different from the register size + */ + rs = op->type & SIZE_MASK; + } else { + rs = 0; + } + + /* + * Make sure we're not out of nasm_reg_flags, still + * probably this should be fixed when we're defining + * the label. + * + * An easy trigger is + * + * e equ 0x80000000:0 + * pshufw word e-0 + * + */ + if (value->type < EXPR_REG_START || + value->type > EXPR_REG_END) { + nasm_nonfatal("invalid operand type"); + goto fail; + } + + op->type &= TO; + op->type |= REGISTER; + op->type |= nasm_reg_flags[value->type]; + op->type |= (regset_size >> 1) << REGSET_SHIFT; + op->decoflags |= brace_flags; + op->basereg = value->type; + + if (rs) { + opflags_t opsize = nasm_reg_flags[value->type] & SIZE_MASK; + if (!opsize) { + op->type |= rs; /* For non-size-specific registers, permit size override */ + } else if (opsize != rs) { + /*! + *!regsize [on] register size specification ignored + *! + *! warns about a register with implicit size (such as \c{EAX}, which is always 32 bits) + *! been given an explicit size specification which is inconsistent with the size + *! of the named register, e.g. \c{WORD EAX}. \c{DWORD EAX} or \c{WORD AX} are + *! permitted, and do not trigger this warning. Some registers which \e{do not} imply + *! a specific size, such as \c{K0}, may need this specification unless the instruction + *! itself implies the instruction size: + *!- + *! \c KMOVW K0,[foo] ; Permitted, KMOVW implies 16 bits + *! \c KMOV WORD K0,[foo] ; Permitted, WORD K0 specifies instruction size + *! \c KMOV K0,WORD [foo] ; Permitted, WORD [foo] specifies instruction size + *! \c KMOV K0,[foo] ; Not permitted, instruction size ambiguous + */ + nasm_warn(WARN_REGSIZE, "invalid register size specification ignored"); + } + } + } + } + + /* remember the position of operand having broadcasting/ER mode */ + if (op->decoflags & (BRDCAST_MASK | ER | SAE)) + result->evex_brerop = opnum; + } + + result->operands = opnum; /* set operand count */ + + /* clear remaining operands */ + while (opnum < MAX_OPERANDS) + result->oprs[opnum++].type = 0; + + return result; + +fail: + result->opcode = I_none; + return result; +} + +static int end_expression_next(void) +{ + struct tokenval tv; + char *p; + int i; + + p = stdscan_get(); + i = stdscan(NULL, &tv); + stdscan_set(p); + + return (i == ',' || i == ';' || i == ')' || !i); +} + +static void free_eops(extop *e) +{ + extop *next; + + while (e) { + next = e->next; + switch (e->type) { + case EOT_EXTOP: + free_eops(e->val.subexpr); + break; + + case EOT_DB_STRING_FREE: + nasm_free(e->val.string.data); + break; + + default: + break; + } + + nasm_free(e); + e = next; + } +} + +void cleanup_insn(insn * i) +{ + free_eops(i->eops); +} diff --git a/vere/ext/nasm/asm/parser.h b/vere/ext/nasm/asm/parser.h new file mode 100644 index 0000000..15298cb --- /dev/null +++ b/vere/ext/nasm/asm/parser.h @@ -0,0 +1,45 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2009 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * parser.h header file for the parser module of the Netwide + * Assembler + */ + +#ifndef NASM_PARSER_H +#define NASM_PARSER_H + +insn *parse_line(char *buffer, insn *result); +void cleanup_insn(insn *instruction); + +#endif diff --git a/vere/ext/nasm/asm/pptok.c b/vere/ext/nasm/asm/pptok.c new file mode 100644 index 0000000..c88d130 --- /dev/null +++ b/vere/ext/nasm/asm/pptok.c @@ -0,0 +1,848 @@ +/* Automatically generated from ./asm/pptok.dat by ./asm/pptok.pl */ +/* Do not edit */ + +#include "compiler.h" +#include "nctype.h" +#include "nasmlib.h" +#include "hashtbl.h" +#include "preproc.h" + +const char * const pp_directives[120] = { + "%if", + "%ifctx", + "%ifdef", + "%ifdefalias", + "%ifdifi", + "%ifempty", + "%ifenv", + "%ifid", + "%ifidn", + "%ifidni", + "%ifmacro", + "%ifnum", + "%ifstr", + "%iftoken", + "%ifusable", + "%ifusing", + "%ifn", + "%ifnctx", + "%ifndef", + "%ifndefalias", + "%ifndifi", + "%ifnempty", + "%ifnenv", + "%ifnid", + "%ifnidn", + "%ifnidni", + "%ifnmacro", + "%ifnnum", + "%ifnstr", + "%ifntoken", + "%ifnusable", + "%ifnusing", + "%elif", + "%elifctx", + "%elifdef", + "%elifdefalias", + "%elifdifi", + "%elifempty", + "%elifenv", + "%elifid", + "%elifidn", + "%elifidni", + "%elifmacro", + "%elifnum", + "%elifstr", + "%eliftoken", + "%elifusable", + "%elifusing", + "%elifn", + "%elifnctx", + "%elifndef", + "%elifndefalias", + "%elifndifi", + "%elifnempty", + "%elifnenv", + "%elifnid", + "%elifnidn", + "%elifnidni", + "%elifnmacro", + "%elifnnum", + "%elifnstr", + "%elifntoken", + "%elifnusable", + "%elifnusing", + "%aliases", + "%arg", + "%clear", + "%depend", + "%else", + "%endif", + "%endm", + "%endmacro", + "%endrep", + "%error", + "%exitmacro", + "%exitrep", + "%fatal", + "%include", + "%line", + "%local", + "%null", + "%pop", + "%pragma", + "%push", + "%rep", + "%repl", + "%require", + "%rotate", + "%stacksize", + "%undef", + "%undefalias", + "%use", + "%warning", + NULL, + "%assign", + "%iassign", + "%defalias", + "%idefalias", + "%define", + "%idefine", + "%defstr", + "%idefstr", + "%deftok", + "%ideftok", + "%macro", + "%imacro", + "%pathsearch", + "%ipathsearch", + "%rmacro", + "%irmacro", + "%strcat", + "%istrcat", + "%strlen", + "%istrlen", + "%substr", + "%isubstr", + "%xdefine", + "%ixdefine", + "%unmacro", + "%unimacro", +}; +const uint8_t pp_directives_len[120] = { + 3, + 6, + 6, + 11, + 7, + 8, + 6, + 5, + 6, + 7, + 8, + 6, + 6, + 8, + 9, + 8, + 4, + 7, + 7, + 12, + 8, + 9, + 7, + 6, + 7, + 8, + 9, + 7, + 7, + 9, + 10, + 9, + 5, + 8, + 8, + 13, + 9, + 10, + 8, + 7, + 8, + 9, + 10, + 8, + 8, + 10, + 11, + 10, + 6, + 9, + 9, + 14, + 10, + 11, + 9, + 8, + 9, + 10, + 11, + 9, + 9, + 11, + 12, + 11, + 8, + 4, + 6, + 7, + 5, + 6, + 5, + 9, + 7, + 6, + 10, + 8, + 6, + 8, + 5, + 6, + 5, + 4, + 7, + 5, + 4, + 5, + 8, + 7, + 10, + 6, + 11, + 4, + 8, + 9, + 7, + 8, + 9, + 10, + 7, + 8, + 7, + 8, + 7, + 8, + 6, + 7, + 11, + 12, + 7, + 8, + 7, + 8, + 7, + 8, + 7, + 8, + 8, + 9, + 8, + 9, +}; + +#define INVALID_HASH_ENTRY (65535/3) + + +/* Primary preprocessor token hash */ + +enum preproc_token pp_token_hash(const char *token) +{ + static const int16_t hashdata[512] = { + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 107, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 74, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 67, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 65, + -66, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 94, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 31, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 38, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 78, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 54, + 70, + INVALID_HASH_ENTRY, + 12, + 21, + 0, + 0, + 3, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 80, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 49, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -77, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 56, + INVALID_HASH_ENTRY, + 47, + INVALID_HASH_ENTRY, + 37, + 0, + INVALID_HASH_ENTRY, + 37, + 0, + INVALID_HASH_ENTRY, + -20, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 7, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 116, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -32, + 39, + INVALID_HASH_ENTRY, + 72, + INVALID_HASH_ENTRY, + 0, + 0, + 179, + -72, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 26, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -40, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 25, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 98, + 0, + 71, + INVALID_HASH_ENTRY, + 53, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 76, + INVALID_HASH_ENTRY, + 63, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 20, + INVALID_HASH_ENTRY, + 99, + INVALID_HASH_ENTRY, + 14, + 0, + -6, + 91, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 164, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 37, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 59, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 117, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 19, + INVALID_HASH_ENTRY, + 16, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 105, + INVALID_HASH_ENTRY, + 18, + -47, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 104, + 8, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 109, + INVALID_HASH_ENTRY, + 4, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 100, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -53, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 85, + INVALID_HASH_ENTRY, + 87, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 32, + 0, + 60, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 29, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -12, + 104, + 63, + INVALID_HASH_ENTRY, + 113, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 28, + 112, + 59, + INVALID_HASH_ENTRY, + -5, + 62, + INVALID_HASH_ENTRY, + 50, + 24, + 44, + INVALID_HASH_ENTRY, + 46, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 90, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 51, + -14, + 83, + 58, + INVALID_HASH_ENTRY, + 40, + INVALID_HASH_ENTRY, + 97, + 0, + INVALID_HASH_ENTRY, + 103, + 22, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 69, + INVALID_HASH_ENTRY, + -61, + INVALID_HASH_ENTRY, + 79, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 33, + INVALID_HASH_ENTRY, + 52, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 45, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 87, + 17, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 111, + -97, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 108, + 43, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 86, + 118, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -23, + 66, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 89, + INVALID_HASH_ENTRY, + 69, + INVALID_HASH_ENTRY, + 41, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 75, + 15, + -90, + 5, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 9, + INVALID_HASH_ENTRY, + 75, + INVALID_HASH_ENTRY, + 48, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 68, + -9, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 11, + -31, + INVALID_HASH_ENTRY, + 73, + INVALID_HASH_ENTRY, + 119, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 110, + INVALID_HASH_ENTRY, + 92, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + }; + uint32_t k1, k2; + uint64_t crc; + uint16_t ix; + + crc = crc64i(UINT64_C(0x076259c3e291c26c), token); + k1 = ((uint32_t)crc & 0x1fe) + 0; + k2 = ((uint32_t)(crc >> 32) & 0x1fe) + 1; + + ix = hashdata[k1] + hashdata[k2]; + if (ix >= 120) + return PP_invalid; + + if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix], token)) + return PP_invalid; + + return ix; +} + + +/* TASM compatibility preprocessor token hash */ +enum preproc_token pp_tasm_token_hash(const char *token) +{ + static const int16_t hashdata[32] = { + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 69, + 0, + 83, + 32, + 2, + 0, + 0, + 77, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 79, + 68, + INVALID_HASH_ENTRY, + 63, + INVALID_HASH_ENTRY, + -65, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + }; + uint32_t k1, k2; + uint64_t crc; + uint16_t ix; + + crc = crc64i(UINT64_C(0x076259c3e291c26c), token); + k1 = ((uint32_t)crc & 0x1e) + 0; + k2 = ((uint32_t)(crc >> 32) & 0x1e) + 1; + + ix = hashdata[k1] + hashdata[k2]; + if (ix >= 120) + return PP_invalid; + + if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix]+1, token)) + return PP_invalid; + + return ix; +} diff --git a/vere/ext/nasm/asm/pptok.dat b/vere/ext/nasm/asm/pptok.dat new file mode 100644 index 0000000..2114497 --- /dev/null +++ b/vere/ext/nasm/asm/pptok.dat @@ -0,0 +1,117 @@ +## -------------------------------------------------------------------------- +## +## Copyright 1996-2019 The NASM Authors - All Rights Reserved +## See the file AUTHORS included with the NASM distribution for +## the specific copyright holders. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following +## conditions are met: +## +## * Redistributions of source code must retain the above copyright +## notice, this list of conditions and the following disclaimer. +## * Redistributions in binary form must reproduce the above +## copyright notice, this list of conditions and the following +## disclaimer in the documentation and/or other materials provided +## with the distribution. +## +## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +## CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +## INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +## MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +## DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +## CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +## NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +## LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +## HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +## OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +## EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +## +## -------------------------------------------------------------------------- + +# +# A * at the end indicates a condition; the list of conditions are +# on lines starting with *; the negatives are auto-generated +# + +# Condition stems. %if MUST BE FIRST in this list. +%if* +%elif* + +# Condition tests. +* +*ctx +*def +*defalias +*difi +*empty +*env +*id +*idn +*idni +*macro +*num +*str +*token +*usable +*using + +# Directives with -i- versions for case insensitive +%!assign +%!defalias +%!define +%!defstr +%!deftok +%!macro +%!pathsearch +%!rmacro +%!strcat +%!strlen +%!substr +%!xdefine +%un!macro + +# Other directives +%aliases +%arg +%clear +%depend +%else +%endif +%endm +%endmacro +%endrep +%error +%exitmacro +%exitrep +%fatal +%include +%line +%local +%null +%pop +%pragma +%push +%rep +%repl +%require +%rotate +%stacksize +%undef +%undefalias +%use +%warning + +# These directives do not require % in TASM-compatible mode +@arg +@elif +@else +@endif +@if +@ifdef +@ifdifi +@ifndef +@include +@local diff --git a/vere/ext/nasm/asm/pptok.h b/vere/ext/nasm/asm/pptok.h new file mode 100644 index 0000000..aead8b5 --- /dev/null +++ b/vere/ext/nasm/asm/pptok.h @@ -0,0 +1,202 @@ +/* Automatically generated from ./asm/pptok.dat by ./asm/pptok.pl */ +/* Do not edit */ + +enum preproc_token { + PP_IF = 0, + PP_IFCTX = 1, + PP_IFDEF = 2, + PP_IFDEFALIAS = 3, + PP_IFDIFI = 4, + PP_IFEMPTY = 5, + PP_IFENV = 6, + PP_IFID = 7, + PP_IFIDN = 8, + PP_IFIDNI = 9, + PP_IFMACRO = 10, + PP_IFNUM = 11, + PP_IFSTR = 12, + PP_IFTOKEN = 13, + PP_IFUSABLE = 14, + PP_IFUSING = 15, + PP_IFN = 16, + PP_IFNCTX = 17, + PP_IFNDEF = 18, + PP_IFNDEFALIAS = 19, + PP_IFNDIFI = 20, + PP_IFNEMPTY = 21, + PP_IFNENV = 22, + PP_IFNID = 23, + PP_IFNIDN = 24, + PP_IFNIDNI = 25, + PP_IFNMACRO = 26, + PP_IFNNUM = 27, + PP_IFNSTR = 28, + PP_IFNTOKEN = 29, + PP_IFNUSABLE = 30, + PP_IFNUSING = 31, + PP_ELIF = 32, + PP_ELIFCTX = 33, + PP_ELIFDEF = 34, + PP_ELIFDEFALIAS = 35, + PP_ELIFDIFI = 36, + PP_ELIFEMPTY = 37, + PP_ELIFENV = 38, + PP_ELIFID = 39, + PP_ELIFIDN = 40, + PP_ELIFIDNI = 41, + PP_ELIFMACRO = 42, + PP_ELIFNUM = 43, + PP_ELIFSTR = 44, + PP_ELIFTOKEN = 45, + PP_ELIFUSABLE = 46, + PP_ELIFUSING = 47, + PP_ELIFN = 48, + PP_ELIFNCTX = 49, + PP_ELIFNDEF = 50, + PP_ELIFNDEFALIAS = 51, + PP_ELIFNDIFI = 52, + PP_ELIFNEMPTY = 53, + PP_ELIFNENV = 54, + PP_ELIFNID = 55, + PP_ELIFNIDN = 56, + PP_ELIFNIDNI = 57, + PP_ELIFNMACRO = 58, + PP_ELIFNNUM = 59, + PP_ELIFNSTR = 60, + PP_ELIFNTOKEN = 61, + PP_ELIFNUSABLE = 62, + PP_ELIFNUSING = 63, + PP_ALIASES = 64, + PP_ARG = 65, + PP_CLEAR = 66, + PP_DEPEND = 67, + PP_ELSE = 68, + PP_ENDIF = 69, + PP_ENDM = 70, + PP_ENDMACRO = 71, + PP_ENDREP = 72, + PP_ERROR = 73, + PP_EXITMACRO = 74, + PP_EXITREP = 75, + PP_FATAL = 76, + PP_INCLUDE = 77, + PP_LINE = 78, + PP_LOCAL = 79, + PP_NULL = 80, + PP_POP = 81, + PP_PRAGMA = 82, + PP_PUSH = 83, + PP_REP = 84, + PP_REPL = 85, + PP_REQUIRE = 86, + PP_ROTATE = 87, + PP_STACKSIZE = 88, + PP_UNDEF = 89, + PP_UNDEFALIAS = 90, + PP_USE = 91, + PP_WARNING = 92, + PP_CASE_PAD = 93, + PP_ASSIGN = 94, + PP_IASSIGN = 95, + PP_DEFALIAS = 96, + PP_IDEFALIAS = 97, + PP_DEFINE = 98, + PP_IDEFINE = 99, + PP_DEFSTR = 100, + PP_IDEFSTR = 101, + PP_DEFTOK = 102, + PP_IDEFTOK = 103, + PP_MACRO = 104, + PP_IMACRO = 105, + PP_PATHSEARCH = 106, + PP_IPATHSEARCH = 107, + PP_RMACRO = 108, + PP_IRMACRO = 109, + PP_STRCAT = 110, + PP_ISTRCAT = 111, + PP_STRLEN = 112, + PP_ISTRLEN = 113, + PP_SUBSTR = 114, + PP_ISUBSTR = 115, + PP_XDEFINE = 116, + PP_IXDEFINE = 117, + PP_UNMACRO = 118, + PP_UNIMACRO = 119, + PP_count = 120, + PP_invalid = -1 +}; + +#define PP_COND(x) ((x) & 0xf) +#define PP_IS_COND(x) ((unsigned int)(x) < PP_ALIASES) +#define PP_COND_NEGATIVE(x) (!!((x) & 0x10)) + +#define PP_HAS_CASE(x) ((x) >= PP_ASSIGN) +#define PP_INSENSITIVE(x) ((x) & 1) +#define PP_TOKLEN_MAX 14 + +#define CASE_PP_IF \ + case PP_IF:\ + case PP_IFCTX:\ + case PP_IFDEF:\ + case PP_IFDEFALIAS:\ + case PP_IFDIFI:\ + case PP_IFEMPTY:\ + case PP_IFENV:\ + case PP_IFID:\ + case PP_IFIDN:\ + case PP_IFIDNI:\ + case PP_IFMACRO:\ + case PP_IFNUM:\ + case PP_IFSTR:\ + case PP_IFTOKEN:\ + case PP_IFUSABLE:\ + case PP_IFUSING:\ + case PP_IFN:\ + case PP_IFNCTX:\ + case PP_IFNDEF:\ + case PP_IFNDEFALIAS:\ + case PP_IFNDIFI:\ + case PP_IFNEMPTY:\ + case PP_IFNENV:\ + case PP_IFNID:\ + case PP_IFNIDN:\ + case PP_IFNIDNI:\ + case PP_IFNMACRO:\ + case PP_IFNNUM:\ + case PP_IFNSTR:\ + case PP_IFNTOKEN:\ + case PP_IFNUSABLE:\ + case PP_IFNUSING +#define CASE_PP_ELIF \ + case PP_ELIF:\ + case PP_ELIFCTX:\ + case PP_ELIFDEF:\ + case PP_ELIFDEFALIAS:\ + case PP_ELIFDIFI:\ + case PP_ELIFEMPTY:\ + case PP_ELIFENV:\ + case PP_ELIFID:\ + case PP_ELIFIDN:\ + case PP_ELIFIDNI:\ + case PP_ELIFMACRO:\ + case PP_ELIFNUM:\ + case PP_ELIFSTR:\ + case PP_ELIFTOKEN:\ + case PP_ELIFUSABLE:\ + case PP_ELIFUSING:\ + case PP_ELIFN:\ + case PP_ELIFNCTX:\ + case PP_ELIFNDEF:\ + case PP_ELIFNDEFALIAS:\ + case PP_ELIFNDIFI:\ + case PP_ELIFNEMPTY:\ + case PP_ELIFNENV:\ + case PP_ELIFNID:\ + case PP_ELIFNIDN:\ + case PP_ELIFNIDNI:\ + case PP_ELIFNMACRO:\ + case PP_ELIFNNUM:\ + case PP_ELIFNSTR:\ + case PP_ELIFNTOKEN:\ + case PP_ELIFNUSABLE:\ + case PP_ELIFNUSING diff --git a/vere/ext/nasm/asm/pptok.pl b/vere/ext/nasm/asm/pptok.pl new file mode 100755 index 0000000..0b8ef25 --- /dev/null +++ b/vere/ext/nasm/asm/pptok.pl @@ -0,0 +1,353 @@ +#!/usr/bin/perl +## -------------------------------------------------------------------------- +## +## Copyright 1996-2022 The NASM Authors - All Rights Reserved +## See the file AUTHORS included with the NASM distribution for +## the specific copyright holders. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following +## conditions are met: +## +## * Redistributions of source code must retain the above copyright +## notice, this list of conditions and the following disclaimer. +## * Redistributions in binary form must reproduce the above +## copyright notice, this list of conditions and the following +## disclaimer in the documentation and/or other materials provided +## with the distribution. +## +## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +## CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +## INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +## MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +## DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +## CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +## NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +## LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +## HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +## OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +## EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +## +## -------------------------------------------------------------------------- + +# +# Produce pptok.c, pptok.h and pptok.ph from pptok.dat +# + +require 'phash.ph'; + +my($what, $in, $out) = @ARGV; + +# +# Read pptok.dat +# +open(IN, '<', $in) or die "$0: cannot open: $in\n"; +while (defined($line = <IN>)) { + $line =~ s/\r?\n$//; # Remove trailing \r\n or \n + $line =~ s/^\s+//; # Remove leading whitespace + $line =~ s/\s*\#.*$//; # Remove comments and trailing whitespace + next if ($line eq ''); + + if ($line =~ /^\%(.*)\*$/) { + # Condition stem + push(@cctok, $1); + } elsif ($line =~ /^\%(.*\!.*)$/) { + # Directive with case insensitity "i" option + # Mnemonic: ! is "upside down i" + push(@ppitok, $1); + } elsif ($line =~ /^\%(.*)$/) { + # Other directive + push(@pptok, $1); + } elsif ($line =~ /^\*(.*)$/) { + # Condition tail + push(@cond, $1); + } elsif ($line =~ /^\@(.*)$/) { + # TASM compatibility directive + push(@tasm, $1); + } +} +close(IN); + +# Always sort %if first +@cctok = sort { $a eq 'if' ? -1 : $b eq 'if' ? 1 : $a cmp $b } @cctok; +@cond = sort @cond; +@pptok = sort @pptok; +@ppitok = sort @ppitok; +@tasm = sort @tasm; + +# Generate the expanded list including conditionals. The conditionals +# are at the beginning, padded to a power of 2, with the inverses +# following each group; this allows a simple mask to pick out the condition, +# polarity, and directive type. + +while ((scalar @cond) & (scalar @cond)-1) { + push(@cond, sprintf("_COND_%d", scalar @cond)); +} + +@cptok = (); +foreach $ct (@cctok) { + foreach $cc (@cond) { + push(@cptok, $ct.$cc); + } + foreach $cc (@cond) { + push(@cptok, $ct.'n'.$cc); + } +} +$first_uncond = scalar @cptok; +@pptok = (@cptok, @pptok); + +# Generate the list of case-specific tokens; these are in pairs +# with the -i- variant following the plain variant +if (scalar(@pptok) & 1) { + push(@pptok, 'CASE_PAD'); +} + +$first_itoken = scalar @pptok; +foreach $it (@ppitok) { + (my $at = $it) =~ s/\!//; + (my $bt = $it) =~ s/\!/i/; + + push(@pptok, $at, $bt); +} + +open(OUT, '>', $out) or die "$0: cannot open: $out\n"; + +# +# Output pptok.h +# +if ($what eq 'h') { + print OUT "/* Automatically generated from $in by $0 */\n"; + print OUT "/* Do not edit */\n"; + print OUT "\n"; + + print OUT "enum preproc_token {\n"; + $n = 0; + my $maxlen = 0; + foreach $pt (@pptok) { + if (defined($pt)) { + printf OUT " %-24s = %3d,\n", "PP_\U$pt\E", $n; + $maxlen = length($pt) if (length($pt) > $maxlen); + } + $n++; + } + printf OUT " %-24s = %3d,\n", 'PP_count', $n; + printf OUT " %-24s = %3d\n", 'PP_invalid', -1; + print OUT "};\n"; + print OUT "\n"; + + printf OUT "#define PP_COND(x) ((x) & 0x%x)\n", + (scalar(@cond)-1); + printf OUT "#define PP_IS_COND(x) ((unsigned int)(x) < PP_%s)\n", + uc($pptok[$first_uncond]); + printf OUT "#define PP_COND_NEGATIVE(x) (!!((x) & 0x%x))\n", scalar(@cond); + print OUT "\n"; + printf OUT "#define PP_HAS_CASE(x) ((x) >= PP_%s)\n", + uc($pptok[$first_itoken]); + print OUT "#define PP_INSENSITIVE(x) ((x) & 1)\n"; + # The +1 here is for the initial % sign + printf OUT "#define PP_TOKLEN_MAX %d\n", $maxlen+1; + print OUT "\n"; + + foreach $ct (@cctok) { + print OUT "#define CASE_PP_\U$ct\E"; + $pref = " \\\n"; + foreach $cc (@cond) { + print OUT "$pref\tcase PP_\U${ct}${cc}\E"; + $pref = ":\\\n"; + } + foreach $cc (@cond) { + print OUT "$pref\tcase PP_\U${ct}N${cc}\E"; + $pref = ":\\\n"; + } + print OUT "\n"; # No colon or newline on the last one + } +} + +# +# Output pptok.c +# +if ($what eq 'c') { + print OUT "/* Automatically generated from $in by $0 */\n"; + print OUT "/* Do not edit */\n"; + print OUT "\n"; + + print OUT "#include \"compiler.h\"\n"; + print OUT "#include \"nctype.h\"\n"; + print OUT "#include \"nasmlib.h\"\n"; + print OUT "#include \"hashtbl.h\"\n"; + print OUT "#include \"preproc.h\"\n"; + print OUT "\n"; + + # Note that this is global. + printf OUT "const char * const pp_directives[%d] = {\n", scalar(@pptok); + foreach $d (@pptok) { + if (defined($d) && $d !~ /[A-Z]/) { + print OUT " \"%$d\",\n"; + } else { + print OUT " NULL,\n"; + } + } + print OUT "};\n"; + + printf OUT "const uint8_t pp_directives_len[%d] = {\n", scalar(@pptok); + foreach $d (@pptok) { + printf OUT " %d,\n", defined($d) ? length($d)+1 : 0; + } + print OUT "};\n"; + + # Put a large value in unused hash slots. This makes it extremely + # unlikely that any combination that involves unused slot will + # pass the range test. This speeds up rejection of unrecognized + # tokens, i.e. identifiers. + print OUT "\n#define INVALID_HASH_ENTRY (65535/3)\n"; + + my %tokens = (); + my @tokendata = (); + + my $n = 0; + foreach $pt (@pptok) { + # Upper case characters signify internal use tokens only + if (defined($pt) && $pt !~ /[A-Z]/) { + $tokens{'%'.$pt} = $n; + if ($pt =~ /[\@\[\]\\_]/) { + # Fail on characters which look like upper-case letters + # to the quick-and-dirty downcasing in the prehash + # (see below) + die "$in: invalid character in token: $pt"; + } + } + $n++; + } + + my @hashinfo = gen_perfect_hash(\%tokens); + if (!@hashinfo) { + die "$0: no hash found\n"; + } + + # Paranoia... + verify_hash_table(\%tokens, \@hashinfo); + + ($n, $sv, $g) = @hashinfo; + die if ($n & ($n-1)); + $n <<= 1; + + + print OUT "\n\n/* Primary preprocessor token hash */\n\n"; + + print OUT "enum preproc_token pp_token_hash(const char *token)\n"; + print OUT "{\n"; + print OUT " static const int16_t hashdata[$n] = {\n"; + for ($i = 0; $i < $n; $i++) { + my $h = ${$g}[$i]; + print OUT " ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n"; + } + print OUT " };\n"; + print OUT " uint32_t k1, k2;\n"; + print OUT " uint64_t crc;\n"; + # For correct overflow behavior, "ix" should be unsigned of the same + # width as the hash arrays. + print OUT " uint16_t ix;\n"; + print OUT "\n"; + + printf OUT " crc = crc64i(UINT64_C(0x%08x%08x), token);\n", + $$sv[0], $$sv[1]; + printf OUT " k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2; + printf OUT " k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2; + print OUT "\n"; + print OUT " ix = hashdata[k1] + hashdata[k2];\n"; + printf OUT " if (ix >= %d)\n", scalar(@pptok); + print OUT " return PP_invalid;\n"; + print OUT "\n"; + + print OUT " if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix], token))\n"; + print OUT " return PP_invalid;\n"; + print OUT "\n"; + print OUT " return ix;\n"; + print OUT "}\n"; + + my %tasmtokens = (); + foreach $pt (@tasm) { + # TASM compatibility token + $nasmt = '%'.$pt; + if (!defined($tokens{$nasmt})) { + die "$in: TASM compat token $pt does not have a ". + "corresponding $nasmt\n"; + } + $tasmtokens{$pt} = $tokens{$nasmt}; + } + + @hashinfo = gen_perfect_hash(\%tasmtokens); + if (!@hashinfo) { + die "$0: no hash found\n"; + } + + # Paranoia... + verify_hash_table(\%tasmtokens, \@hashinfo); + + ($n, $sv, $g) = @hashinfo; + die if ($n & ($n-1)); + $n <<= 1; + + print OUT "\n\n/* TASM compatibility preprocessor token hash */\n"; + + print OUT "enum preproc_token pp_tasm_token_hash(const char *token)\n"; + print OUT "{\n"; + print OUT " static const int16_t hashdata[$n] = {\n"; + for ($i = 0; $i < $n; $i++) { + my $h = ${$g}[$i]; + print OUT " ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n"; + } + print OUT " };\n"; + print OUT " uint32_t k1, k2;\n"; + print OUT " uint64_t crc;\n"; + # For correct overflow behavior, "ix" should be unsigned of the same + # width as the hash arrays. + print OUT " uint16_t ix;\n"; + print OUT "\n"; + + printf OUT " crc = crc64i(UINT64_C(0x%08x%08x), token);\n", + $$sv[0], $$sv[1]; + printf OUT " k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2; + printf OUT " k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2; + print OUT "\n"; + printf OUT " ix = hashdata[k1] + hashdata[k2];\n", $n-1, $n-1; + # Comparing to pptok here is correct, because this hash produces + # an enum preproc_token value directly. + printf OUT " if (ix >= %d)\n", scalar(@pptok); + print OUT " return PP_invalid;\n"; + print OUT "\n"; + + print OUT " if (!pp_directives[ix] || nasm_stricmp(pp_directives[ix]+1, token))\n"; + print OUT " return PP_invalid;\n"; + print OUT "\n"; + print OUT " return ix;\n"; + print OUT "}\n"; +} + +# +# Output pptok.ph +# +if ($what eq 'ph') { + print OUT "# Automatically generated from $in by $0\n"; + print OUT "# Do not edit\n"; + + print OUT "\n\%pptok_hash = (\n"; + $n = 0; + foreach $tok (@pptok) { + if (defined($tok)) { + printf OUT " '%%%s' => %d,\n", $tok, $n; + } + $n++; + } + print OUT ");\n"; + + print OUT "\n\@pptok_list = (\n"; + foreach $tok (@pptok) { + print OUT " ", (defined($tok) ? "'\%$tok'" : 'undef'), ",\n"; + } + print OUT ");\n"; + + print OUT "\n1;\n"; +} diff --git a/vere/ext/nasm/asm/pragma.c b/vere/ext/nasm/asm/pragma.c new file mode 100644 index 0000000..0049c06 --- /dev/null +++ b/vere/ext/nasm/asm/pragma.c @@ -0,0 +1,369 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2019 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * Parse and handle [pragma] directives. The preprocessor handles + * %pragma preproc directives separately, all other namespaces are + * simply converted to [pragma]. + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "nasmlib.h" +#include "assemble.h" +#include "error.h" +#include "listing.h" + +static enum directive_result ignore_pragma(const struct pragma *pragma); +static enum directive_result output_pragma(const struct pragma *pragma); +static enum directive_result debug_pragma(const struct pragma *pragma); +static enum directive_result limit_pragma(const struct pragma *pragma); + +/* + * Handle [pragma] directives. [pragma] is generally produced by + * the %pragma preprocessor directive, which simply passes on any + * string that it finds *except* %pragma preproc. The idea is + * that pragmas are of the form: + * + * %pragma <facility> <opname> [<options>...] + * + * ... where "facility" can be either a generic facility or a backend + * name. + * + * The following names are currently reserved for global facilities; + * so far none of these have any defined pragmas at all: + * + * preproc - preprocessor + * limit - limit setting + * asm - assembler + * list - listing generator + * file - generic file handling + * input - input file handling + * output - backend-independent output handling + * debug - backend-independent debug handling + * ignore - dummy pragma (can be used to "comment out") + * + * This function should generally not error out if it doesn't understand + * what a pragma is for, for unknown arguments, etc; the whole point of + * a pragma is that future releases might add new ones that should be + * ignored rather than be an error. Erroring out is acceptable for + * known pragmas suffering from parsing errors and so on. + * + * Adding default-suppressed warnings would, however, be a good idea + * at some point. + */ +static struct pragma_facility global_pragmas[] = +{ + { "asm", NULL }, + { "limit", limit_pragma }, + { "list", list_pragma }, + { "file", NULL }, + { "input", NULL }, + { "output", output_pragma }, + { "debug", debug_pragma }, + { "ignore", ignore_pragma }, + + /* This will never actually get this far... */ + { "preproc", NULL }, /* Handled in the preprocessor by necessity */ + { NULL, NULL } +}; + +/* + * Invoke a pragma handler + */ +static enum directive_result +call_pragma(const struct pragma_facility *pf, struct pragma *pragma) +{ + if (!pf || !pf->handler) + return DIRR_UNKNOWN; + + pragma->facility = pf; + return pf->handler(pragma); +} + +/* + * Search a pragma list for a known pragma facility and if so, invoke + * the handler. Return true if processing is complete. The "default + * name", *or def->name*, if set, matches the final NULL entry (used + * for backends, so multiple backends can share the same list under + * some circumstances, and the backends can implement common operations.) + */ +static enum directive_result +search_pragma_list(const struct pragma_facility *list, + const char *defaultname, + const struct pragma_facility *def, + const struct pragma *cpragma) +{ + const struct pragma_facility *pf = NULL; + enum directive_result rv; + bool facility_match, is_default; + struct pragma pragma = *cpragma; + const char *facname = pragma.facility_name; + + /* Is there a default facility and we match its name? */ + is_default = def && def->name && !nasm_stricmp(facname, def->name); + facility_match = is_default; + + /* + * Promote def->name to defaultname if both are set. This handles + * e.g. output -> elf32 so that we can handle elf32-specific + * directives in that handler. + */ + if (defaultname) { + if (is_default) + facname = defaultname; + else + facility_match = !nasm_stricmp(facname, defaultname); + } + + if (facname && list) { + for (pf = list; pf->name; pf++) { + if (!nasm_stricmp(facname, pf->name)) { + facility_match = true; + rv = call_pragma(pf, &pragma); + if (rv != DIRR_UNKNOWN) + goto found_it; + } + } + + if (facility_match) { + /* + * Facility name match but no matching directive; handler in NULL + * entry at end of list? + */ + rv = call_pragma(pf, &pragma); + if (rv != DIRR_UNKNOWN) + goto found_it; + } + } + + if (facility_match) { + /* + * Facility match but still nothing: def->handler if it exists + */ + rv = call_pragma(def, &pragma); + } else { + /* + * No facility matched + */ + return DIRR_UNKNOWN; + } + + /* + * Otherwise we found the facility but not any supported directive, + * fall through... + */ + +found_it: + switch (rv) { + case DIRR_UNKNOWN: + switch (pragma.opcode) { + case D_none: + /*! + *!pragma-bad [off] malformed %pragma + *!=bad-pragma + *! warns about a malformed or otherwise unparsable + *! \c{%pragma} directive. + */ + nasm_warn(ERR_PASS2|WARN_PRAGMA_BAD, + "empty %%pragma %s", pragma.facility_name); + break; + default: + /*! + *!pragma-unknown [off] unknown %pragma facility or directive + *!=unknown-pragma + *! warns about an unknown \c{%pragma} directive. + *! This is not yet implemented for most cases. + */ + nasm_warn(ERR_PASS2|WARN_PRAGMA_UNKNOWN, + "unknown %%pragma %s %s", + pragma.facility_name, pragma.opname); + break; + } + rv = DIRR_ERROR; /* Already printed an error message */ + break; + + case DIRR_OK: + case DIRR_ERROR: + break; /* Nothing to do */ + + case DIRR_BADPARAM: + /* + * This one is an error. Don't use it if forward compatibility + * would be compromised, as opposed to an inherent error. + */ + nasm_error(ERR_NONFATAL, "bad argument to %%pragma %s %s", + pragma.facility_name, pragma.opname); + break; + + default: + panic(); + } + return rv; +} + +/* This warning message is intended for future use */ +/*! + *!pragma-na [off] %pragma not applicable to this compilation + *!=not-my-pragma + *! warns about a \c{%pragma} directive which is not applicable to + *! this particular assembly session. This is not yet implemented. + */ + +/* Naked %pragma */ +/*! + *!pragma-empty [off] empty %pragma directive + *! warns about a \c{%pragma} directive containing nothing. + *! This is treated identically to \c{%pragma ignore} except + *! for this optional warning. + */ +void process_pragma(char *str) +{ + const struct pragma_facility *pf; + struct pragma pragma; + char *p; + + nasm_zero(pragma); + + pragma.facility_name = nasm_get_word(str, &p); + if (!pragma.facility_name) { + /* Empty %pragma */ + nasm_warn(ERR_PASS2|WARN_PRAGMA_EMPTY, + "empty %%pragma directive, ignored"); + return; + } + + pragma.opname = nasm_get_word(p, &p); + if (!pragma.opname) + pragma.opcode = D_none; + else + pragma.opcode = directive_find(pragma.opname); + + pragma.tail = nasm_trim_spaces(p); + + /* + * Search the global pragma namespaces. This is done + * as a loop rather than letting search_pragma_list() + * just run, because we don't want to keep searching if + * we have a facility match, thus we want to call + * search_pragma_list() individually for each namespace. + */ + for (pf = global_pragmas; pf->name; pf++) { + if (search_pragma_list(NULL, NULL, pf, &pragma) != DIRR_UNKNOWN) + return; + } + + /* Is it an output pragma? */ + if (output_pragma(&pragma) != DIRR_UNKNOWN) + return; + + /* Is it a debug pragma */ + if (debug_pragma(&pragma) != DIRR_UNKNOWN) + return; + + /* + * Note: it would be nice to warn for an unknown namespace, + * but in order to do so we need to walk *ALL* the backends + * in order to make sure we aren't dealing with a pragma that + * is for another backend. On the other hand, that could + * also be a warning with a separate warning flag. + * + * Leave this for the future, however, the warning classes are + * already defined for future compatibility. + */ +} + +/* %pragma ignore */ +static enum directive_result ignore_pragma(const struct pragma *pragma) +{ + (void)pragma; + return DIRR_OK; /* Even for D_none! */ +} + +/* + * Process output and debug pragmas, by either list name or generic + * name. Note that the output/debug format list can hook the default + * names if they so choose. + */ +static enum directive_result output_pragma_common(const struct pragma *); +static enum directive_result output_pragma(const struct pragma *pragma) +{ + static const struct pragma_facility + output_pragma_def = { "output", output_pragma_common }; + + return search_pragma_list(ofmt->pragmas, ofmt->shortname, + &output_pragma_def, pragma); +} + +/* Generic pragmas that apply to all output backends */ +static enum directive_result output_pragma_common(const struct pragma *pragma) +{ + switch (pragma->opcode) { + case D_PREFIX: + case D_GPREFIX: + set_label_mangle(LM_GPREFIX, pragma->tail); + return DIRR_OK; + case D_SUFFIX: + case D_GSUFFIX: + set_label_mangle(LM_GSUFFIX, pragma->tail); + return DIRR_OK; + case D_LPREFIX: + set_label_mangle(LM_LPREFIX, pragma->tail); + return DIRR_OK; + case D_LSUFFIX: + set_label_mangle(LM_LSUFFIX, pragma->tail); + return DIRR_OK; + default: + return DIRR_UNKNOWN; + } +} + +static enum directive_result debug_pragma(const struct pragma *pragma) +{ + static const struct pragma_facility + debug_pragma_def = { "debug", NULL }; + + return search_pragma_list(dfmt->pragmas, dfmt->shortname, + &debug_pragma_def, pragma); +} + +/* + * %pragma limit to set resource limits + */ +static enum directive_result limit_pragma(const struct pragma *pragma) +{ + return nasm_set_limit(pragma->opname, pragma->tail); +} diff --git a/vere/ext/nasm/asm/preproc.c b/vere/ext/nasm/asm/preproc.c new file mode 100644 index 0000000..ac42131 --- /dev/null +++ b/vere/ext/nasm/asm/preproc.c @@ -0,0 +1,8070 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2022 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * preproc.c macro preprocessor for the Netwide Assembler + */ + +/* Typical flow of text through preproc + * + * pp_getline gets tokenized lines, either + * + * from a macro expansion + * + * or + * { + * read_line gets raw text from stdmacpos, or predef, or current input file + * tokenize converts to tokens + * } + * + * expand_mmac_params is used to expand %1 etc., unless a macro is being + * defined or a false conditional is being processed + * (%0, %1, %+1, %-1, %%foo + * + * do_directive checks for directives + * + * expand_smacro is used to expand single line macros + * + * expand_mmacro is used to expand multi-line macros + * + * detoken is used to convert the line back to text + */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "nasmlib.h" +#include "error.h" +#include "preproc.h" +#include "hashtbl.h" +#include "quote.h" +#include "stdscan.h" +#include "eval.h" +#include "tokens.h" +#include "tables.h" +#include "listing.h" +#include "dbginfo.h" + +/* + * Preprocessor execution options that can be controlled by %pragma or + * other directives. This structure is initialized to zero on each + * pass; this *must* reflect the default initial state. + */ +static struct pp_config { + bool noaliases; + bool sane_empty_expansion; +} ppconf; + +/* + * Preprocessor debug-related flags + */ +static enum pp_debug_flags { + PDBG_MMACROS = 1, /* Collect mmacro information */ + PDBG_SMACROS = 2, /* Collect smacro information */ + PDBG_LIST_SMACROS = 4, /* Smacros to list file (list option 's') */ + PDBG_INCLUDE = 8 /* Collect %include information */ +} ppdbg; + +/* + * Preprocessor options configured on the command line + */ +static enum preproc_opt ppopt; + +typedef struct SMacro SMacro; +typedef struct MMacro MMacro; +typedef struct Context Context; +typedef struct Token Token; +typedef struct Line Line; +typedef struct Include Include; +typedef struct Cond Cond; + +/* + * Map of preprocessor directives that are also preprocessor functions; + * if they are at the beginning of a line they are a function if and + * only if they are followed by a ( + */ +static bool pp_op_may_be_function[PP_count]; + +/* + * This is the internal form which we break input lines up into. + * Typically stored in linked lists. + * + * Note that `type' serves a double meaning: TOKEN_SMAC_START_PARAMS is + * not necessarily used as-is, but is also used to encode the number + * and expansion type of substituted parameter. So in the definition + * + * %define a(x,=y) ( (x) & ~(y) ) + * + * the token representing `x' will have its type changed to + * tok_smac_param(0) but the one representing `y' will be + * tok_smac_param(1); see the accessor functions below. + * + * TOKEN_INTERNAL_STR is a string which has been unquoted, but should + * be treated as if it was a quoted string. The code is free to change + * one into the other at will. TOKEN_NAKED_STR is a text token which + * should be treated as a string, but which MUST NOT be turned into a + * quoted string. TOKEN_INTERNAL_STRs can contain any character, + * including NUL, but TOKEN_NAKED_STR must be a valid C string. + */ + +static inline enum token_type tok_smac_param(int param) +{ + return TOKEN_SMAC_START_PARAMS + param; +} +static int smac_nparam(enum token_type toktype) +{ + return toktype - TOKEN_SMAC_START_PARAMS; +} +static bool is_smac_param(enum token_type toktype) +{ + return toktype >= TOKEN_SMAC_START_PARAMS; +} + +/* + * This is tuned so struct Token should be 64 bytes on 64-bit + * systems and 32 bytes on 32-bit systems. It enables them + * to be nicely cache aligned, and the text to still be kept + * inline for nearly all tokens. + * + * We prohibit tokens of length > MAX_TEXT even though + * length here is an unsigned int; this avoids problems + * if the length is passed through an interface with type "int", + * and is absurdly large anyway. + * + * Earlier versions of the source code incorrectly stated that + * examining the text string alone can be unconditionally valid. This + * is incorrect, as some token types strip parts of the string, + * e.g. indirect tokens. + */ +#define INLINE_TEXT (7*sizeof(char *)-sizeof(enum token_type)-sizeof(unsigned int)-1) +#define MAX_TEXT (INT_MAX-2) + +struct Token { + Token *next; + enum token_type type; + unsigned int len; + union { + char a[INLINE_TEXT+1]; + struct { + char pad[INLINE_TEXT+1 - sizeof(char *)]; + char *ptr; + } p; + } text; +}; + +/* + * Note on the storage of both SMacro and MMacros: the hash table + * indexes them case-insensitively, and we then have to go through a + * linked list of potential case aliases (and, for MMacros, parameter + * ranges); this is to preserve the matching semantics of the earlier + * code. If the number of case aliases for a specific macro is a + * performance issue, you may want to reconsider your coding style. + */ + +/* + * Function call tp obtain the expansion of an smacro + */ +typedef Token *(*ExpandSMacro)(const SMacro *s, Token **params, int nparams); + +/* + * Store the definition of a single-line macro. + * + * Note: for user-defined macros, SPARM_VARADIC and SPARM_DEFAULT are + * currently never set, and SPARM_OPTIONAL is set if and only + * if SPARM_GREEDY is set. + */ +enum sparmflags { + SPARM_PLAIN = 0, + SPARM_EVAL = 1, /* Evaluate as a numeric expression (=) */ + SPARM_STR = 2, /* Convert to quoted string ($) */ + SPARM_NOSTRIP = 4, /* Don't strip braces (!) */ + SPARM_GREEDY = 8, /* Greedy final parameter (+) */ + SPARM_VARADIC = 16, /* Any number of separate arguments */ + SPARM_OPTIONAL = 32, /* Optional argument */ + SPARM_CONDQUOTE = 64 /* With SPARM_STR, don't re-quote a string */ +}; + +struct smac_param { + Token name; + enum sparmflags flags; + const Token *def; /* Default, if any */ +}; + +struct SMacro { + SMacro *next; /* MUST BE FIRST - see free_smacro() */ + char *name; + Token *expansion; + ExpandSMacro expand; + intorptr expandpvt; + struct smac_param *params; + int nparam; /* length of the params structure */ + int nparam_min; /* allows < nparam arguments */ + int in_progress; + bool recursive; + bool varadic; /* greedy or supports > nparam arguments */ + bool casesense; + bool alias; /* This is an alias macro */ +}; + +/* + * "No listing" flags. Inside a loop (%rep..%endrep) we may have + * macro listing suppressed with .nolist, but we still need to + * update line numbers for error messages and debug information... + * unless we are nested inside an actual .nolist macro. + */ +enum nolist_flags { + NL_LIST = 1, /* Suppress list output */ + NL_LINE = 2 /* Don't update line information */ +}; + +/* + * Store the definition of a multi-line macro. This is also used to + * store the interiors of `%rep...%endrep' blocks, which are + * effectively self-re-invoking multi-line macros which simply + * don't have a name or bother to appear in the hash tables. %rep + * blocks are signified by having a NULL `name' field. + * + * In a MMacro describing a `%rep' block, the `in_progress' field + * isn't merely boolean, but gives the number of repeats left to + * run. + * + * The `next' field is used for storing MMacros in hash tables; the + * `next_active' field is for stacking them on istk entries. + * + * When a MMacro is being expanded, `params', `iline', `nparam', + * `paramlen', `rotate' and `unique' are local to the invocation. + */ + +/* + * Expansion stack. Note that .mmac can point back to the macro itself, + * whereas .mstk cannot. + */ +struct mstk { + MMacro *mstk; /* Any expansion, real macro or not */ + MMacro *mmac; /* Highest level actual mmacro */ +}; + +struct MMacro { + MMacro *next; +#if 0 + MMacroInvocation *prev; /* previous invocation */ +#endif + char *name; + int nparam_min, nparam_max; + enum nolist_flags nolist; /* is this macro listing-inhibited? */ + bool casesense; + bool plus; /* is the last parameter greedy? */ + bool capture_label; /* macro definition has %00; capture label */ + int32_t in_progress; /* is this macro currently being expanded? */ + int32_t max_depth; /* maximum number of recursive expansions allowed */ + Token *dlist; /* All defaults as one list */ + Token **defaults; /* Parameter default pointers */ + int ndefs; /* number of default parameters */ + Line *expansion; + + struct mstk mstk; /* Macro expansion stack */ + struct mstk dstk; /* Macro definitions stack */ + Token **params; /* actual parameters */ + Token *iline; /* invocation line */ + struct src_location where; /* location of definition */ + unsigned int nparam, rotate; + char *iname; /* name invoked as */ + int *paramlen; + uint64_t unique; + uint64_t condcnt; /* number of if blocks... */ + struct { /* Debug information */ + struct debug_macro_def *def; /* Definition */ + struct debug_macro_inv *inv; /* Current invocation (if any) */ + } dbg; +}; + + +/* Store the definition of a multi-line macro, as defined in a + * previous recursive macro expansion. + */ +#if 0 + +struct MMacroInvocation { + MMacroInvocation *prev; /* previous invocation */ + Token **params; /* actual parameters */ + Token *iline; /* invocation line */ + unsigned int nparam, rotate; + int *paramlen; + uint64_t unique; + uint64_t condcnt; +}; + +#endif + +/* + * The context stack is composed of a linked list of these. + */ +struct Context { + Context *next; + const char *name; + struct hash_table localmac; + uint64_t number; + unsigned int depth; +}; + + +static inline const char *tok_text(const struct Token *t) +{ + return (t->len <= INLINE_TEXT) ? t->text.a : t->text.p.ptr; +} + +/* + * Returns a mutable pointer to the text buffer. The text can be changed, + * but the length MUST NOT CHANGE, in either direction; nor is it permitted + * to pad with null characters to create an artificially shorter string. + */ +static inline char *tok_text_buf(struct Token *t) +{ + return (t->len <= INLINE_TEXT) ? t->text.a : t->text.p.ptr; +} + +static inline unsigned int tok_check_len(size_t len) +{ + if (unlikely(len > MAX_TEXT)) + nasm_fatal("impossibly large token"); + + return len; +} + +static inline bool tok_text_match(const struct Token *a, const struct Token *b) +{ + return a->len == b->len && !memcmp(tok_text(a), tok_text(b), a->len); +} + +static inline unused_func bool +tok_match(const struct Token *a, const struct Token *b) +{ + return a->type == b->type && tok_text_match(a, b); +} + +/* strlen() variant useful for set_text() and its variants */ +static size_t tok_strlen(const char *str) +{ + return strnlen(str, MAX_TEXT+1); +} + +/* + * Set the text field to a copy of the given string; the length if + * not given should be obtained with tok_strlen(). + */ +static Token *set_text(struct Token *t, const char *text, size_t len) +{ + char *textp; + + if (t->len > INLINE_TEXT) + nasm_free(t->text.p.ptr); + + nasm_zero(t->text); + + t->len = len = tok_check_len(len); + textp = (len > INLINE_TEXT) + ? (t->text.p.ptr = nasm_malloc(len+1)) : t->text.a; + memcpy(textp, text, len); + textp[len] = '\0'; + return t; +} + +/* + * Set the text field to the existing pre-allocated string, either + * taking over or freeing the allocation in the process. + */ +static Token *set_text_free(struct Token *t, char *text, unsigned int len) +{ + char *textp; + + if (t->len > INLINE_TEXT) + nasm_free(t->text.p.ptr); + + nasm_zero(t->text); + + t->len = len = tok_check_len(len); + if (len > INLINE_TEXT) { + textp = t->text.p.ptr = text; + } else { + textp = memcpy(t->text.a, text, len); + nasm_free(text); + } + textp[len] = '\0'; + + return t; +} + +/* + * Allocate a new buffer containing a copy of the text field + * of the token. + */ +static char *dup_text(const struct Token *t) +{ + size_t size = t->len + 1; + char *p = nasm_malloc(size); + + return memcpy(p, tok_text(t), size); +} + +/* + * Multi-line macro definitions are stored as a linked list of + * these, which is essentially a container to allow several linked + * lists of Tokens. + * + * Note that in this module, linked lists are treated as stacks + * wherever possible. For this reason, Lines are _pushed_ on to the + * `expansion' field in MMacro structures, so that the linked list, + * if walked, would give the macro lines in reverse order; this + * means that we can walk the list when expanding a macro, and thus + * push the lines on to the `expansion' field in _istk_ in reverse + * order (so that when popped back off they are in the right + * order). It may seem cockeyed, and it relies on my design having + * an even number of steps in, but it works... + * + * Some of these structures, rather than being actual lines, are + * markers delimiting the end of the expansion of a given macro. + * This is for use in the cycle-tracking and %rep-handling code. + * Such structures have `finishes' non-NULL, and `first' NULL. All + * others have `finishes' NULL, but `first' may still be NULL if + * the line is blank. + */ +struct Line { + Line *next; + MMacro *finishes; + Token *first; + struct src_location where; /* Where defined */ +}; + +/* + * To handle an arbitrary level of file inclusion, we maintain a + * stack (ie linked list) of these things. + * + * Note: when we issue a message for a continuation line, we want to + * issue it for the actual *start* of the continuation line. This means + * we need to remember how many lines to skip over for the next one. + */ +struct Include { + Include *next; + FILE *fp; + Cond *conds; + Line *expansion; + uint64_t nolist; /* Listing inhibit counter */ + uint64_t noline; /* Line number update inhibit counter */ + struct mstk mstk; + struct src_location where; /* Filename and current line number */ + int32_t lineinc; /* Increment given by %line */ + int32_t lineskip; /* Accounting for passed continuation lines */ +}; + +/* + * File real name hash, so we don't have to re-search the include + * path for every pass (and potentially more than that if a file + * is used more than once.) + */ +struct hash_table FileHash; + +/* + * Counters to trap on insane macro recursion or processing. + * Note: for smacros these count *down*, for mmacros they count *up*. + */ +struct deadman { + int64_t total; /* Total number of macros/tokens */ + int64_t levels; /* Descent depth across all macros */ + bool triggered; /* Already triggered, no need for error msg */ +}; + +static struct deadman smacro_deadman, mmacro_deadman; + +/* + * Conditional assembly: we maintain a separate stack of these for + * each level of file inclusion. (The only reason we keep the + * stacks separate is to ensure that a stray `%endif' in a file + * included from within the true branch of a `%if' won't terminate + * it and cause confusion: instead, rightly, it'll cause an error.) + */ +enum cond_state { + /* + * These states are for use just after %if or %elif: IF_TRUE + * means the condition has evaluated to truth so we are + * currently emitting, whereas IF_FALSE means we are not + * currently emitting but will start doing so if a %else comes + * up. In these states, all directives are admissible: %elif, + * %else and %endif. (And of course %if.) + */ + COND_IF_TRUE, COND_IF_FALSE, + /* + * These states come up after a %else: ELSE_TRUE means we're + * emitting, and ELSE_FALSE means we're not. In ELSE_* states, + * any %elif or %else will cause an error. + */ + COND_ELSE_TRUE, COND_ELSE_FALSE, + /* + * These states mean that we're not emitting now, and also that + * nothing until %endif will be emitted at all. COND_DONE is + * used when we've had our moment of emission + * and have now started seeing %elifs. COND_NEVER is used when + * the condition construct in question is contained within a + * non-emitting branch of a larger condition construct, + * or if there is an error. + */ + COND_DONE, COND_NEVER +}; +struct Cond { + Cond *next; + enum cond_state state; +}; +#define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE ) + +/* + * These defines are used as the possible return values for do_directive + */ +#define NO_DIRECTIVE_FOUND 0 +#define DIRECTIVE_FOUND 1 + +/* + * Condition codes. Note that we use c_ prefix not C_ because C_ is + * used in nasm.h for the "real" condition codes. At _this_ level, + * we treat CXZ and ECXZ as condition codes, albeit non-invertible + * ones, so we need a different enum... + */ +static const char * const conditions[] = { + "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le", + "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no", + "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z" +}; +enum pp_conds { + c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE, + c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO, + c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_RCXZ, c_S, c_Z, + c_none = -1 +}; +static const enum pp_conds inverse_ccs[] = { + c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE, + c_A, c_AE, c_B, c_BE, c_C, c_E, c_G, c_GE, c_L, c_LE, c_O, c_P, c_S, + c_Z, c_NO, c_NP, c_PO, c_PE, -1, c_NS, c_NZ +}; + +/* + * Directive names. + */ +/* If this is a an IF, ELIF, ELSE or ENDIF keyword */ +static int is_condition(enum preproc_token arg) +{ + return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF); +} + +static int StackSize = 4; +static const char *StackPointer = "ebp"; +static int ArgOffset = 8; +static int LocalOffset = 0; + +static Context *cstk; +static Include *istk; +static const struct strlist *ipath_list; + +static struct strlist *deplist; + +static uint64_t unique; /* unique identifier numbers */ + +static Line *predef = NULL; +static bool do_predef; +static enum preproc_mode pp_mode; + +/* + * The current set of multi-line macros we have defined. + */ +static struct hash_table mmacros; + +/* + * The current set of single-line macros we have defined. + */ +static struct hash_table smacros; + +/* + * The multi-line macro we are currently defining, or the %rep + * block we are currently reading, if any. + */ +static MMacro *defining; + +static uint64_t nested_mac_count; +static uint64_t nested_rep_count; + +/* + * The number of macro parameters to allocate space for at a time. + */ +#define PARAM_DELTA 16 + +/* + * The standard macro set: defined in macros.c in a set of arrays. + * This gives our position in any macro set, while we are processing it. + * The stdmacset is an array of such macro sets. + */ +static macros_t *stdmacpos; +static macros_t **stdmacnext; +static macros_t *stdmacros[8]; +static macros_t *extrastdmac; + +/* + * Map of which %use packages have been loaded + */ +static bool *use_loaded; + +/* + * Forward declarations. + */ +static void pp_add_stdmac(macros_t *macros); +static Token *expand_mmac_params(Token * tline); +static Token *expand_smacro(Token * tline); +static Token *expand_id(Token * tline); +static Context *get_ctx(const char *name, const char **namep); +static Token *make_tok_num(Token *next, int64_t val); +static int64_t get_tok_num(const Token *t, bool *err); +static Token *make_tok_qstr(Token *next, const char *str); +static Token *make_tok_qstr_len(Token *next, const char *str, size_t len); +static Token *make_tok_char(Token *next, char op); +static Token *new_Token(Token * next, enum token_type type, + const char *text, size_t txtlen); +static Token *new_Token_free(Token * next, enum token_type type, + char *text, size_t txtlen); +static Token *dup_Token(Token *next, const Token *src); +static Token *new_White(Token *next); +static Token *delete_Token(Token *t); +static Token *steal_Token(Token *dst, Token *src); +static const struct use_package * +get_use_pkg(Token *t, const char *dname, const char **name); +static void mark_smac_params(Token *tline, const SMacro *tmpl, + enum token_type type); + +/* Safe extraction of token type */ +static inline enum token_type tok_type(const Token *x) +{ + return x ? x->type : TOKEN_EOS; +} + +/* Safe test for token type, false on x == NULL */ +static inline bool tok_is(const Token *x, enum token_type t) +{ + return tok_type(x) == t; +} +/* True if token is any other kind other that "c", but not NULL */ +static inline bool tok_isnt(const Token *x, enum token_type t) +{ + return x && x->type != t; +} + +/* Whitespace token? */ +static inline bool tok_white(const Token *x) +{ + return tok_is(x, TOKEN_WHITESPACE); +} + +/* Skip past any whitespace */ +static inline Token *skip_white(Token *x) +{ + while (tok_white(x)) + x = x->next; + + return x; +} + +/* Delete any whitespace */ +static Token *zap_white(Token *x) +{ + while (tok_white(x)) + x = delete_Token(x); + + return x; +} + +/* + * Unquote a token if it is a string, and set its type to + * TOKEN_INTERNAL_STR. + */ + +/* + * Common version for any kind of quoted string; see asm/quote.c for + * information about the arguments. + */ +static const char *unquote_token_anystr(Token *t, uint32_t badctl, char qstart) +{ + size_t nlen, olen; + char *p; + + if (t->type != TOKEN_STR) + return tok_text(t); + + olen = t->len; + p = (olen > INLINE_TEXT) ? t->text.p.ptr : t->text.a; + t->len = nlen = nasm_unquote_anystr(p, NULL, badctl, qstart); + t->type = TOKEN_INTERNAL_STR; + + if (olen <= INLINE_TEXT || nlen > INLINE_TEXT) + return p; + + nasm_zero(t->text.a); + memcpy(t->text.a, p, nlen); + nasm_free(p); + return t->text.a; +} + +/* Unquote any string, can produce any arbitrary binary output */ +static const char *unquote_token(Token *t) +{ + return unquote_token_anystr(t, 0, STR_NASM); +} + +/* + * Same as unquote_token(), but error out if the resulting string + * contains unacceptable control characters. + */ +static const char *unquote_token_cstr(Token *t) +{ + return unquote_token_anystr(t, BADCTL, STR_NASM); +} + +/* + * Convert a TOKEN_INTERNAL_STR token to a quoted + * TOKEN_STR tokens. + */ +static Token *quote_any_token(Token *t); +static inline unused_func +Token *quote_token(Token *t) +{ + if (likely(!tok_is(t, TOKEN_INTERNAL_STR))) + return t; + + return quote_any_token(t); +} + +/* + * Convert *any* kind of token to a quoted + * TOKEN_STR token. + */ +static Token *quote_any_token(Token *t) +{ + size_t len = t->len; + char *p; + + p = nasm_quote(tok_text(t), &len); + t->type = TOKEN_STR; + return set_text_free(t, p, len); +} + +/* + * In-place reverse a list of tokens. + */ +static Token *reverse_tokens(Token *t) +{ + Token *prev = NULL; + Token *next; + + while (t) { + next = t->next; + t->next = prev; + prev = t; + t = next; + } + + return prev; +} + +/* + * getenv() variant operating on an input token + */ +static const char *pp_getenv(const Token *t, bool warn) +{ + const char *txt = tok_text(t); + const char *v; + char *buf = NULL; + bool is_string = false; + + if (!t) + return NULL; + + switch (t->type) { + case TOKEN_ENVIRON: + txt += 2; /* Skip leading %! */ + is_string = nasm_isquote(*txt); + break; + + case TOKEN_STR: + is_string = true; + break; + + case TOKEN_INTERNAL_STR: + case TOKEN_NAKED_STR: + case TOKEN_ID: + is_string = false; + break; + + default: + return NULL; + } + + if (is_string) { + buf = nasm_strdup(txt); + nasm_unquote_cstr(buf, NULL); + txt = buf; + } + + v = getenv(txt); + if (warn && !v) { + /*! + *!pp-environment [on] nonexistent environment variable + *!=environment + *! warns if a nonexistent environment variable + *! is accessed using the \c{%!} preprocessor + *! construct (see \k{getenv}.) Such environment + *! variables are treated as empty (with this + *! warning issued) starting in NASM 2.15; + *! earlier versions of NASM would treat this as + *! an error. + */ + nasm_warn(WARN_PP_ENVIRONMENT, + "nonexistent environment variable `%s'", txt); + v = ""; + } + + if (buf) + nasm_free(buf); + + return v; +} + +/* + * Free a linked list of tokens. + */ +static void free_tlist(Token * list) +{ + while (list) + list = delete_Token(list); +} + +/* + * Free a linked list of lines. + */ +static void free_llist(Line * list) +{ + Line *l, *tmp; + list_for_each_safe(l, tmp, list) { + free_tlist(l->first); + nasm_free(l); + } +} + +/* + * Free an array of linked lists of tokens + */ +static void free_tlist_array(Token **array, size_t nlists) +{ + Token **listp = array; + + if (!array) + return; + + while (nlists--) + free_tlist(*listp++); + + nasm_free(array); +} + +/* + * Duplicate a linked list of tokens. + */ +static Token *dup_tlist(const Token *list, Token ***tailp) +{ + Token *newlist = NULL; + Token **tailpp = &newlist; + const Token *t; + + list_for_each(t, list) { + Token *nt; + *tailpp = nt = dup_Token(NULL, t); + tailpp = &nt->next; + } + + if (tailp) { + **tailp = newlist; + *tailp = tailpp; + } + + return newlist; +} + +/* + * Duplicate a linked list of tokens with a maximum count + */ +static Token *dup_tlistn(const Token *list, size_t cnt, Token ***tailp) +{ + Token *newlist = NULL; + Token **tailpp = &newlist; + const Token *t; + + list_for_each(t, list) { + Token *nt; + if (!cnt--) + break; + *tailpp = nt = dup_Token(NULL, t); + tailpp = &nt->next; + } + + if (tailp) { + **tailp = newlist; + if (newlist) + *tailp = tailpp; + } + + return newlist; +} + +/* + * Duplicate a linked list of tokens in reverse order + */ +static Token *dup_tlist_reverse(const Token *list, Token *tail) +{ + const Token *t; + + list_for_each(t, list) + tail = dup_Token(tail, t); + + return tail; +} + +/* + * Append an existing tlist to a tail pointer and returns the + * updated tail pointer. + */ +static Token **steal_tlist(Token *tlist, Token **tailp) +{ + *tailp = tlist; + + if (!tlist) + return tailp; + + list_last(tlist, tlist); + return &tlist->next; +} + +/* + * Free an MMacro + */ +static void free_mmacro(MMacro * m) +{ + nasm_free(m->name); + free_tlist(m->dlist); + nasm_free(m->defaults); + free_llist(m->expansion); + nasm_free(m); +} + +/* + * Clear or free an SMacro + */ +static void free_smacro_members(SMacro *s) +{ + if (s->params) { + int i; + for (i = 0; i < s->nparam; i++) { + if (s->params[i].name.len > INLINE_TEXT) + nasm_free(s->params[i].name.text.p.ptr); + if (s->params[i].def) + free_tlist((Token *)s->params[i].def); + } + nasm_free(s->params); + } + nasm_free(s->name); + free_tlist(s->expansion); +} + +static void clear_smacro(SMacro *s) +{ + free_smacro_members(s); + /* Wipe everything except the next pointer */ + memset(&s->name, 0, sizeof(*s) - offsetof(SMacro, name)); +} + +/* + * Free an SMacro + */ +static void free_smacro(SMacro *s) +{ + free_smacro_members(s); + nasm_free(s); +} + +/* + * Free all currently defined macros, and free the hash tables if empty + */ +enum clear_what { + CLEAR_NONE = 0, + CLEAR_DEFINE = 1, /* Clear smacros */ + CLEAR_DEFALIAS = 2, /* Clear smacro aliases */ + CLEAR_ALLDEFINE = CLEAR_DEFINE|CLEAR_DEFALIAS, + CLEAR_MMACRO = 4, + CLEAR_ALL = CLEAR_ALLDEFINE|CLEAR_MMACRO +}; + +static void clear_smacro_table(struct hash_table *smt, enum clear_what what) +{ + struct hash_iterator it; + const struct hash_node *np; + bool empty = true; + + /* + * Walk the hash table and clear out anything we don't want + */ + hash_for_each(smt, it, np) { + SMacro *tmp; + SMacro *s = np->data; + SMacro **head = (SMacro **)&np->data; + + list_for_each_safe(s, tmp, s) { + if (what & ((enum clear_what)s->alias + 1)) { + *head = s->next; + free_smacro(s); + } else { + empty = false; + } + } + } + + /* + * Free the hash table and keys if and only if it is now empty. + * Note: we cannot free keys even for an empty list above, as that + * mucks up the hash algorithm. + */ + if (empty) + hash_free_all(smt, true); +} + +static void free_smacro_table(struct hash_table *smt) +{ + clear_smacro_table(smt, CLEAR_ALLDEFINE); +} + +static void free_mmacro_table(struct hash_table *mmt) +{ + struct hash_iterator it; + const struct hash_node *np; + + hash_for_each(mmt, it, np) { + MMacro *tmp; + MMacro *m = np->data; + nasm_free((void *)np->key); + list_for_each_safe(m, tmp, m) + free_mmacro(m); + } + hash_free(mmt); +} + +static void free_macros(void) +{ + free_smacro_table(&smacros); + free_mmacro_table(&mmacros); +} + +/* + * Initialize the hash tables + */ +static void init_macros(void) +{ +} + +/* + * Pop the context stack. + */ +static void ctx_pop(void) +{ + Context *c = cstk; + + cstk = cstk->next; + free_smacro_table(&c->localmac); + nasm_free((char *)c->name); + nasm_free(c); +} + +/* + * Search for a key in the hash index; adding it if necessary + * (in which case we initialize the data pointer to NULL.) + */ +static void ** +hash_findi_add(struct hash_table *hash, const char *str) +{ + struct hash_insert hi; + void **r; + char *strx; + size_t l = strlen(str) + 1; + + r = hash_findib(hash, str, l, &hi); + if (r) + return r; + + strx = nasm_malloc(l); /* Use a more efficient allocator here? */ + memcpy(strx, str, l); + return hash_add(&hi, strx, NULL); +} + +/* + * Like hash_findi, but returns the data element rather than a pointer + * to it. Used only when not adding a new element, hence no third + * argument. + */ +static void * +hash_findix(struct hash_table *hash, const char *str) +{ + void **p; + + p = hash_findi(hash, str, NULL); + return p ? *p : NULL; +} + +/* + * read line from standard macros set, + * if there no more left -- return NULL + */ +static char *line_from_stdmac(void) +{ + unsigned char c; + const unsigned char *p = stdmacpos; + char *line, *q; + size_t len = 0; + + if (!stdmacpos) + return NULL; + + /* + * 32-126 is ASCII, 127 is end of line, 128-31 are directives + * (allowed to wrap around) corresponding to PP_* tokens 0-159. + */ + while ((c = *p++) != 127) { + uint8_t ndir = c - 128; + if (ndir < 256-96) + len += pp_directives_len[ndir] + 1; + else + len++; + } + + line = nasm_malloc(len + 1); + q = line; + + while ((c = *stdmacpos++) != 127) { + uint8_t ndir = c - 128; + if (ndir < 256-96) { + memcpy(q, pp_directives[ndir], pp_directives_len[ndir]); + q += pp_directives_len[ndir]; + *q++ = ' '; + } else { + *q++ = c; + } + } + stdmacpos = p; + *q = '\0'; + + if (*stdmacpos == 127) { + /* This was the last of this particular macro set */ + stdmacpos = NULL; + if (*stdmacnext) { + stdmacpos = *stdmacnext++; + } else if (do_predef) { + Line *pd, *l; + + /* + * Nasty hack: here we push the contents of + * `predef' on to the top-level expansion stack, + * since this is the most convenient way to + * implement the pre-include and pre-define + * features. + */ + list_for_each(pd, predef) { + nasm_new(l); + l->next = istk->expansion; + l->first = dup_tlist(pd->first, NULL); + l->finishes = NULL; + + istk->expansion = l; + } + do_predef = false; + } + } + + return line; +} + +/* + * Read a line from a file. Return NULL on end of file. + */ +static char *line_from_file(FILE *f) +{ + int c; + unsigned int size, next; + const unsigned int delta = 512; + const unsigned int pad = 8; + bool cont = false; + char *buffer, *p; + + istk->where.lineno += istk->lineskip + istk->lineinc; + src_set_linnum(istk->where.lineno); + istk->lineskip = 0; + + size = delta; + p = buffer = nasm_malloc(size); + + do { + c = fgetc(f); + + switch (c) { + case EOF: + if (p == buffer) { + nasm_free(buffer); + return NULL; + } + c = 0; + break; + + case '\r': + next = fgetc(f); + if (next != '\n') + ungetc(next, f); + if (cont) { + cont = false; + continue; + } + c = 0; + break; + + case '\n': + if (cont) { + cont = false; + continue; + } + c = 0; + break; + + case 032: /* ^Z = legacy MS-DOS end of file mark */ + c = 0; + break; + + case '\\': + next = fgetc(f); + ungetc(next, f); + if (next == '\r' || next == '\n') { + cont = true; + istk->lineskip += istk->lineinc; + continue; + } + break; + } + + if (p >= (buffer + size - pad)) { + buffer = nasm_realloc(buffer, size + delta); + p = buffer + size - pad; + size += delta; + } + + *p++ = c; + } while (c); + + return buffer; +} + +/* + * Common read routine regardless of source + */ +static char *read_line(void) +{ + char *line; + FILE *f = istk->fp; + + if (f) + line = line_from_file(f); + else + line = line_from_stdmac(); + + if (!line) + return NULL; + + if (!istk->nolist) + lfmt->line(LIST_READ, istk->where.lineno, line); + + return line; +} + +/* + * Tokenize a line of text. This is a very simple process since we + * don't need to parse the value out of e.g. numeric tokens: we + * simply split one string into many. + */ +static Token *tokenize(const char *line) +{ + enum token_type type; + Token *list = NULL; + Token *t, **tail = &list; + + while (*line) { + const char *p = line; + const char *ep = NULL; /* End of token, for trimming the end */ + size_t toklen; + char firstchar = *p; /* Can be used to override the first char */ + + if (*p == '%') { + /* + * Preprocessor construct; find the end of the token. + * Classification is handled later, because %{...} can be + * used to create any preprocessor token. + */ + p++; + if (*p == '+' && !nasm_isdigit(p[1])) { + /* Paste token */ + p++; + } else if (nasm_isdigit(*p) || + ((*p == '-' || *p == '+') && nasm_isdigit(p[1]))) { + do { + p++; + } + while (nasm_isdigit(*p)); + } else if (*p == '{' || *p == '[') { + /* %{...} or %[...] */ + char firstchar = *p; + char endchar = *p + 2; /* } or ] */ + int lvl = 1; + line += (*p++ == '{'); /* Skip { but not [ (yet) */ + while (lvl) { + if (*p == firstchar) { + lvl++; + } else if (*p == endchar) { + lvl--; + } else if (nasm_isquote(*p)) { + p = nasm_skip_string(p); + } + + /* + * *p can have been advanced to a null character by + * nasm_skip_string() + */ + if (!*p) { + /*! + *!pp-open-brackets [on] unterminated %[...] + *! warns that a preprocessor \c{%[...]} construct + *! lacks the terminating \c{]} character. + */ + /*! + *!pp-open-braces [on] unterminated %{...} + *! warns that a preprocessor parameter + *! enclosed in braces \c{%\{...\}} lacks the + *! terminating \c{\}} character. + */ + nasm_warn(firstchar == '}' ? + WARN_PP_OPEN_BRACES : WARN_PP_OPEN_BRACKETS, + "unterminated %%%c...%c construct (missing `%c')", + firstchar, endchar, endchar); + break; + } + p++; + } + ep = lvl ? p : p-1; /* Terminal character not part of token */ + } else if (*p == '?') { + /* %? or %?? */ + p++; + if (*p == '?') + p++; + } else if (*p == '*' && p[1] == '?') { + /* %*? and %*?? */ + p += 2; + if (*p == '?') + p++; + } else if (*p == '!') { + /* Environment variable reference */ + p++; + if (nasm_isidchar(*p)) { + do { + p++; + } + while (nasm_isidchar(*p)); + } else if (nasm_isquote(*p)) { + p = nasm_skip_string(p); + if (*p) + p++; + else + nasm_nonfatal("unterminated %%! string"); + } else { + /* %! without anything else... */ + } + } else if (*p == ',') { + /* Conditional comma */ + p++; + } else if (nasm_isidchar(*p) || + ((*p == '%' || *p == '$') && nasm_isidchar(p[1]))) { + /* Identifier or some sort */ + do { + p++; + } + while (nasm_isidchar(*p)); + } else if (*p == '%') { + /* %% operator */ + p++; + } + + if (!ep) + ep = p; + toklen = ep - line; + + /* Classify here, to handle %{...} correctly */ + if (toklen < 2) { + type = '%'; /* % operator */ + if (unlikely(*line == '{')) { + /*! + *!pp-empty-braces [on] empty %{} construct + *! warns that an empty \c{%\{\}} was encountered. + *! This expands to a single \c{%} character, which + *! is normally the \c{%} arithmetic operator. + */ + nasm_warn(WARN_PP_EMPTY_BRACES, + "empty %%{} construct expands to the %% operator"); + } + } else { + char c0 = line[1]; + + switch (c0) { + case '+': + type = (toklen == 2) ? TOKEN_PASTE : TOKEN_MMACRO_PARAM; + break; + + case '-': + type = TOKEN_MMACRO_PARAM; + break; + + case '?': + if (toklen == 2) + type = TOKEN_PREPROC_Q; + else if (toklen == 3 && line[2] == '?') + type = TOKEN_PREPROC_QQ; + else + type = TOKEN_PREPROC_ID; + break; + + case '*': + type = TOKEN_OTHER; + if (line[2] == '?') { + if (toklen == 3) + type = TOKEN_PREPROC_SQ; + else if (toklen == 4 && line[3] == '?') + type = TOKEN_PREPROC_SQQ; + } + break; + + case '!': + type = (toklen == 2) ? TOKEN_OTHER : TOKEN_ENVIRON; + break; + + case '%': + type = (toklen == 2) ? TOKEN_SMOD : TOKEN_LOCAL_SYMBOL; + break; + + case '$': + type = (toklen == 2) ? TOKEN_OTHER : TOKEN_LOCAL_MACRO; + break; + + case '[': + line += 2; /* Skip %[ */ + firstchar = *line; /* Don't clobber */ + toklen -= 2; + type = TOKEN_INDIRECT; + break; + + case ',': + type = (toklen == 2) ? TOKEN_COND_COMMA : TOKEN_PREPROC_ID; + break; + + case '\'': + case '\"': + case '`': + /* %{'string'} */ + type = TOKEN_PREPROC_ID; + break; + + case ':': + type = TOKEN_MMACRO_PARAM; /* %{:..} */ + break; + + default: + if (nasm_isdigit(c0)) + type = TOKEN_MMACRO_PARAM; + else if (nasm_isidchar(c0) || toklen > 2) + type = TOKEN_PREPROC_ID; + else + type = TOKEN_OTHER; + break; + } + } + } else if (*p == '?' && !nasm_isidchar(p[1])) { + /* ? operator */ + type = TOKEN_QMARK; + p++; + } else if (nasm_isidstart(*p) || (*p == '$' && nasm_isidstart(p[1]))) { + /* + * A regular identifier. This includes keywords which are not + * special to the preprocessor. + */ + type = TOKEN_ID; + while (nasm_isidchar(*++p)) + ; + } else if (nasm_isquote(*p)) { + /* + * A string token. + */ + char quote = *p; + + type = TOKEN_STR; + p = nasm_skip_string(p); + + if (*p) { + p++; + } else { + /*! + *!pp-open-string [on] unterminated string + *! warns that a quoted string without a closing quotation + *! mark was encountered during preprocessing. + */ + nasm_warn(WARN_PP_OPEN_STRING, + "unterminated string (missing `%c')", quote); + type = TOKEN_ERRSTR; + } + } else if (p[0] == '$' && p[1] == '$') { + type = TOKEN_BASE; + p += 2; + } else if (nasm_isnumstart(*p)) { + bool is_hex = false; + bool is_float = false; + bool has_e = false; + char c; + + /* + * A numeric token. + */ + + if (*p == '$') { + p++; + is_hex = true; + } + + for (;;) { + c = *p++; + + if (!is_hex && (c == 'e' || c == 'E')) { + has_e = true; + if (*p == '+' || *p == '-') { + /* + * e can only be followed by +/- if it is either a + * prefixed hex number or a floating-point number + */ + p++; + is_float = true; + } + } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') { + is_hex = true; + } else if (c == 'P' || c == 'p') { + is_float = true; + if (*p == '+' || *p == '-') + p++; + } else if (nasm_isnumchar(c)) + ; /* just advance */ + else if (c == '.') { + /* + * we need to deal with consequences of the legacy + * parser, like "1.nolist" being two tokens + * (TOKEN_NUM, TOKEN_ID) here; at least give it + * a shot for now. In the future, we probably need + * a flex-based scanner with proper pattern matching + * to do it as well as it can be done. Nothing in + * the world is going to help the person who wants + * 0x123.p16 interpreted as two tokens, though. + */ + const char *r = p; + while (*r == '_') + r++; + + if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) || + (!is_hex && (*r == 'e' || *r == 'E')) || + (*r == 'p' || *r == 'P')) { + p = r; + is_float = true; + } else + break; /* Terminate the token */ + } else + break; + } + p--; /* Point to first character beyond number */ + + if (p == line+1 && *line == '$') { + type = TOKEN_HERE; + } else { + if (has_e && !is_hex) { + /* 1e13 is floating-point, but 1e13h is not */ + is_float = true; + } + + type = is_float ? TOKEN_FLOAT : TOKEN_NUM; + } + } else if (nasm_isspace(*p)) { + firstchar = ' '; /* Always a single space */ + type = TOKEN_WHITESPACE; + p = nasm_skip_spaces(p); + /* + * Whitespace just before end-of-line is discarded by + * pretending it's a comment; whitespace just before a + * comment gets lumped into the comment. + */ + if (!*p || *p == ';') + type = TOKEN_EOS; + } else if (*p == ';') { + type = TOKEN_EOS; + } else { + /* + * Anything else is an operator of some kind. We check + * for all the double-character operators (>>, <<, //, + * %%, <=, >=, ==, !=, <>, &&, ||, ^^) and the triple- + * character operators (<<<, >>>, <=>) but anything + * else is a single-character operator. + */ + type = (unsigned char)*p; + switch (*p++) { + case '>': + if (*p == '>') { + p++; + type = TOKEN_SHR; + if (*p == '>') { + type = TOKEN_SAR; + p++; + } + } else if (*p == '=') { + type = TOKEN_GE; + p++; + } + break; + + case '<': + if (*p == '<') { + p++; + type = TOKEN_SHL; + if (*p == '<') + p++; + } else if (*p == '=') { + p++; + type = TOKEN_LE; + if (*p == '>') { + p++; + type = TOKEN_LEG; + } + } else if (*p == '>') { + p++; + type = TOKEN_NE; + } + break; + + case '!': + if (*p == '=') { + p++; + type = TOKEN_NE; + } + break; + + case '/': + if (*p == '/') { + p++; + type = TOKEN_SDIV; + } + break; + case '=': + if (*p == '=') + p++; /* Still TOKEN_EQ == '=' though */ + break; + case '&': + if (*p == '&') { + p++; + type = TOKEN_DBL_AND; + } + break; + + case '|': + if (*p == '|') { + p++; + type = TOKEN_DBL_OR; + } + break; + + case '^': + if (*p == '^') { + p++; + type = TOKEN_DBL_XOR; + } + break; + + default: + break; + } + } + + if (type == TOKEN_EOS) + break; /* done with the string... */ + + if (!ep) + ep = p; + toklen = ep - line; + + if (toklen) { + *tail = t = new_Token(NULL, type, line, toklen); + *tok_text_buf(t) = firstchar; /* E.g. %{foo} -> {foo -> %foo */ + tail = &t->next; + } + + line = p; + } + return list; +} + +/* + * Tokens are allocated in blocks to improve speed. Set the blocksize + * to 0 to use regular nasm_malloc(); this is useful for debugging. + * + * alloc_Token() returns a zero-initialized token structure. + */ +#define TOKEN_BLOCKSIZE 4096 + +#if TOKEN_BLOCKSIZE + +static Token *freeTokens = NULL; +static Token *tokenblocks = NULL; + +static Token *alloc_Token(void) +{ + Token *t = freeTokens; + + if (unlikely(!t)) { + Token *block; + size_t i; + + nasm_newn(block, TOKEN_BLOCKSIZE); + + /* + * The first entry in each array are a linked list of + * block allocations and is not used for data. + */ + block[0].next = tokenblocks; + block[0].type = TOKEN_BLOCK; + tokenblocks = block; + + /* + * Add the rest to the free list + */ + for (i = 2; i < TOKEN_BLOCKSIZE - 1; i++) + block[i].next = &block[i+1]; + + freeTokens = &block[2]; + + /* + * Return the topmost usable token + */ + return &block[1]; + } + + freeTokens = t->next; + t->next = NULL; + return t; +} + +static Token *delete_Token(Token *t) +{ + Token *next; + + nasm_assert(t && t->type != TOKEN_FREE); + + next = t->next; + nasm_zero(*t); + t->type = TOKEN_FREE; + t->next = freeTokens; + freeTokens = t; + + return next; +} + +static void delete_Blocks(void) +{ + Token *block, *blocktmp; + + list_for_each_safe(block, blocktmp, tokenblocks) + nasm_free(block); + + freeTokens = tokenblocks = NULL; +} + +#else + +static inline Token *alloc_Token(void) +{ + Token *t; + nasm_new(t); + return t; +} + +static Token *delete_Token(Token *t) +{ + Token *next = t->next; + nasm_free(t); + return next; +} + +static inline void delete_Blocks(void) +{ + /* Nothing to do */ +} + +#endif + +/* + * this function creates a new Token and passes a pointer to it + * back to the caller. It sets the type, text, and next pointer elements. + */ +static Token *new_Token(Token * next, enum token_type type, + const char *text, size_t txtlen) +{ + Token *t = alloc_Token(); + char *textp; + + t->next = next; + t->type = type; + if (type == TOKEN_WHITESPACE) { + t->len = 1; + t->text.a[0] = ' '; + } else { + if (text && text[0] && !txtlen) + txtlen = tok_strlen(text); + + t->len = tok_check_len(txtlen); + + if (text) { + textp = (txtlen > INLINE_TEXT) + ? (t->text.p.ptr = nasm_malloc(txtlen+1)) : t->text.a; + memcpy(textp, text, txtlen); + textp[txtlen] = '\0'; /* In case we needed malloc() */ + } else { + /* + * Allocate a buffer but do not fill it. The caller + * can fill in text, but must not change the length. + * The filled in text must be exactly txtlen once + * the buffer is filled and before the token is added + * to any line lists. + */ + if (txtlen > INLINE_TEXT) + t->text.p.ptr = nasm_zalloc(txtlen+1); + } + } + return t; +} + +/* + * Same as new_Token(), but text belongs to the new token and is + * either taken over or freed. This function MUST be called + * with valid txt and txtlen, unlike new_Token(). + */ +static Token *new_Token_free(Token * next, enum token_type type, + char *text, size_t txtlen) +{ + Token *t = alloc_Token(); + + t->next = next; + t->type = type; + t->len = tok_check_len(txtlen); + + if (txtlen <= INLINE_TEXT) { + memcpy(t->text.a, text, txtlen); + nasm_free(text); + } else { + t->text.p.ptr = text; + } + + return t; +} + +static Token *dup_Token(Token *next, const Token *src) +{ + Token *t = alloc_Token(); + + memcpy(t, src, sizeof *src); + t->next = next; + + if (t->len > INLINE_TEXT) { + t->text.p.ptr = nasm_malloc(t->len + 1); + memcpy(t->text.p.ptr, src->text.p.ptr, t->len+1); + } + + return t; +} + +static Token *new_White(Token *next) +{ + Token *t = alloc_Token(); + + t->next = next; + t->type = TOKEN_WHITESPACE; + t->len = 1; + t->text.a[0] = ' '; + + return t; +} + +/* + * This *transfers* the content from one token to another, leaving the + * next pointer of the latter intact. Unlike dup_Token(), the old + * token is destroyed, except for its next pointer, and the text + * pointer allocation, if any, is simply transferred. + */ +static Token *steal_Token(Token *dst, Token *src) +{ + /* Overwrite everything except the next pointers */ + memcpy((char *)dst + sizeof(Token *), (char *)src + sizeof(Token *), + sizeof(Token) - sizeof(Token *)); + + /* Clear the donor token */ + memset((char *)src + sizeof(Token *), 0, sizeof(Token) - sizeof(Token *)); + + return dst; +} + +/* + * Convert a line of tokens back into text. This modifies the list + * by expanding environment variables. + * + * If expand_locals is not zero, identifiers of the form "%$*xxx" + * are also transformed into ..@ctxnum.xxx + */ +static char *detoken(Token * tlist, bool expand_locals) +{ + Token *t; + char *line, *p; + int len = 0; + + list_for_each(t, tlist) { + switch (t->type) { + case TOKEN_ENVIRON: + { + const char *v = pp_getenv(t, true); + set_text(t, v, tok_strlen(v)); + t->type = TOKEN_NAKED_STR; + break; + } + + case TOKEN_LOCAL_MACRO: + case TOKEN_LOCAL_SYMBOL: + if (expand_locals) { + const char *q; + char *p; + Context *ctx = get_ctx(tok_text(t), &q); + if (ctx) { + p = nasm_asprintf("..@%"PRIu64".%s", ctx->number, q); + set_text_free(t, p, nasm_last_string_len()); + t->type = TOKEN_ID; + } + } + break; + + case TOKEN_INDIRECT: + /* + * This won't happen in when emitting to the assembler, + * but can happen when emitting output for some of the + * list options. The token string doesn't actually include + * the brackets in this case. + */ + len += 3; /* %[] */ + break; + + default: + break; /* No modifications */ + } + + if (debug_level(2)) { + unsigned int t_len = t->len; + unsigned int s_len = tok_strlen(tok_text(t)); + if (t_len != s_len) { + nasm_panic("assertion failed: token \"%s\" type %u len %u has t->len %u\n", + tok_text(t), t->type, s_len, t_len); + t->len = s_len; + } + } + + len += t->len; + } + + p = line = nasm_malloc(len + 1); + + list_for_each(t, tlist) { + switch (t->type) { + case TOKEN_INDIRECT: + *p++ = '%'; + *p++ = '['; + p = mempcpy(p, tok_text(t), t->len); + *p++ = ']'; + break; + + default: + p = mempcpy(p, tok_text(t), t->len); + } + } + *p = '\0'; + + return line; +} + +/* + * A scanner, suitable for use by the expression evaluator, which + * operates on a line of Tokens. Expects a pointer to a pointer to + * the first token in the line to be passed in as its private_data + * field. + * + * FIX: This really needs to be unified with stdscan. + */ +struct ppscan { + Token *tptr; + int ntokens; +}; + +static int ppscan(void *private_data, struct tokenval *tokval) +{ + struct ppscan *pps = private_data; + Token *tline; + const char *txt; + + do { + if (pps->ntokens && (tline = pps->tptr)) { + pps->ntokens--; + pps->tptr = tline->next; + } else { + pps->tptr = NULL; + pps->ntokens = 0; + return tokval->t_type = TOKEN_EOS; + } + } while (tline->type == TOKEN_WHITESPACE); + + txt = tok_text(tline); + tokval->t_charptr = (char *)txt; /* Fix this */ + + switch (tline->type) { + default: + return tokval->t_type = tline->type; + + case TOKEN_ID: + /* This could be an assembler keyword */ + return nasm_token_hash(txt, tokval); + + case TOKEN_NUM: + { + bool rn_error; + tokval->t_integer = readnum(txt, &rn_error); + if (rn_error) + return tokval->t_type = TOKEN_ERRNUM; + else + return tokval->t_type = TOKEN_NUM; + } + + case TOKEN_STR: + tokval->t_charptr = (char *)unquote_token(tline); + /* fall through */ + case TOKEN_INTERNAL_STR: + case TOKEN_NAKED_STR: + tokval->t_inttwo = tline->len; + return tokval->t_type = TOKEN_STR; + } +} + +/* + * 1. An expression (true if nonzero 0) + * 2. The keywords true, on, yes for true + * 3. The keywords false, off, no for false + * 4. An empty line, for true + * + * On error, return defval (usually the previous value) + */ +static bool pp_get_boolean_option(Token *tline, bool defval) +{ + static const char * const noyes[] = { + "no", "yes", + "false", "true", + "off", "on" + }; + struct ppscan pps; + struct tokenval tokval; + expr *evalresult; + + tline = skip_white(tline); + if (!tline) + return true; + + if (tline->type == TOKEN_ID) { + size_t i; + const char *txt = tok_text(tline); + + for (i = 0; i < ARRAY_SIZE(noyes); i++) + if (!nasm_stricmp(txt, noyes[i])) + return i & 1; + } + + pps.tptr = NULL; + pps.tptr = tline; + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + + if (!evalresult) + return true; + + if (tokval.t_type) { + /*! + *!pp-trailing [on] trailing garbage ignored + *! warns that the preprocessor encountered additional text + *! where no such text was expected. This can + *! sometimes be the result of an incorrectly written expression, + *! or arguments that are inadvertently separated. + */ + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after expression ignored"); + } + if (!is_really_simple(evalresult)) { + nasm_nonfatal("boolean flag expression must be a constant"); + return defval; + } + + return reloc_value(evalresult) != 0; +} + +/* + * Compare a string to the name of an existing macro; this is a + * simple wrapper which calls either strcmp or nasm_stricmp + * depending on the value of the `casesense' parameter. + */ +static int mstrcmp(const char *p, const char *q, bool casesense) +{ + return casesense ? strcmp(p, q) : nasm_stricmp(p, q); +} + +/* + * Compare a string to the name of an existing macro; this is a + * simple wrapper which calls either strcmp or nasm_stricmp + * depending on the value of the `casesense' parameter. + */ +static int mmemcmp(const char *p, const char *q, size_t l, bool casesense) +{ + return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l); +} + +/* + * Return the Context structure associated with a %$ token. Return + * NULL, having _already_ reported an error condition, if the + * context stack isn't deep enough for the supplied number of $ + * signs. + * + * If "namep" is non-NULL, set it to the pointer to the macro name + * tail, i.e. the part beyond %$... + */ +static Context *get_ctx(const char *name, const char **namep) +{ + Context *ctx; + int i; + + if (namep) + *namep = name; + + if (!name || name[0] != '%' || name[1] != '$') + return NULL; + + if (!cstk) { + nasm_nonfatal("`%s': context stack is empty", name); + return NULL; + } + + name += 2; + ctx = cstk; + i = 0; + while (ctx && *name == '$') { + name++; + i++; + ctx = ctx->next; + } + if (!ctx) { + nasm_nonfatal("`%s': context stack is only" + " %d level%s deep", name, i, (i == 1 ? "" : "s")); + return NULL; + } + + if (namep) + *namep = name; + + return ctx; +} + +/* + * Open an include file. This routine must always return a valid + * file pointer if it returns - it's responsible for throwing an + * ERR_FATAL and bombing out completely if not. It should also try + * the include path one by one until it finds the file or reaches + * the end of the path. + * + * Note: for INC_PROBE the function returns NULL at all times; + * instead look for a filename in *slpath. + */ +enum incopen_mode { + INC_NEEDED, /* File must exist */ + INC_REQUIRED, /* File must exist, but only open once/pass */ + INC_OPTIONAL, /* Missing is OK */ + INC_PROBE /* Only an existence probe */ +}; + +/* This is conducts a full pathname search */ +static FILE *inc_fopen_search(const char *file, char **slpath, + enum incopen_mode omode, enum file_flags fmode) +{ + const struct strlist_entry *ip = strlist_head(ipath_list); + FILE *fp; + const char *prefix = ""; + char *sp; + bool found; + + while (1) { + sp = nasm_catfile(prefix, file); + if (omode == INC_PROBE) { + fp = NULL; + found = nasm_file_exists(sp); + } else { + fp = nasm_open_read(sp, fmode); + found = (fp != NULL); + } + if (found) { + *slpath = sp; + return fp; + } + + nasm_free(sp); + + if (!ip) { + *slpath = NULL; + return NULL; + } + + prefix = ip->str; + ip = ip->next; + } +} + +/* + * Open a file, or test for the presence of one (depending on omode), + * considering the include path. + */ +struct file_hash_entry { + const char *path; + struct file_hash_entry *full; /* Hash entry for the full path */ + int64_t include_pass; /* Pass in which last included (for %require) */ +}; + +static FILE *inc_fopen(const char *file, + struct strlist *dhead, + const char **found_path, + enum incopen_mode omode, + enum file_flags fmode) +{ + struct file_hash_entry **fhep; + struct file_hash_entry *fhe = NULL; + struct hash_insert hi; + const char *path = NULL; + FILE *fp = NULL; + const int64_t pass = pass_count(); + bool skip_open = (omode == INC_PROBE); + + fhep = (struct file_hash_entry **)hash_find(&FileHash, file, &hi); + if (fhep) { + fhe = *fhep; + if (fhe) { + path = fhe->path; + skip_open |= (omode == INC_REQUIRED) && + (fhe->full->include_pass >= pass); + } + } else { + /* Need to do the actual path search */ + char *pptr; + fp = inc_fopen_search(file, &pptr, omode, fmode); + path = pptr; + + /* Positive or negative result */ + if (path) { + nasm_new(fhe); + fhe->path = path; + fhe->full = fhe; /* It is *possible*... */ + } + hash_add(&hi, nasm_strdup(file), fhe); + + /* + * Add a hash entry for the canonical path if there isn't one + * already. Try to get the unique name from the OS best we can. + * Note that ->path and ->full->path can be different, and that + * is okay (we don't want to print out a full canonical path + * in messages, for example.) + */ + if (path) { + char *fullpath = nasm_realpath(path); + + if (!strcmp(file, fullpath)) { + nasm_free(fullpath); + } else { + struct file_hash_entry **fullp, *full; + fullp = (struct file_hash_entry **) + hash_find(&FileHash, fullpath, &hi); + + if (fullp) { + full = *fullp; + nasm_free(fullpath); + } else { + nasm_new(full); + full->path = fullpath; + full->full = full; + hash_add(&hi, path, full); + } + fhe->full = full; + } + } + + /* + * Add file to dependency path. + */ + strlist_add(dhead, path ? path : file); + } + + if (path && !fp && omode != INC_PROBE) + fp = nasm_open_read(path, fmode); + + if (omode < INC_OPTIONAL && !fp) { + if (!path) + errno = ENOENT; + + nasm_nonfatal("unable to open include file `%s': %s", + file, strerror(errno)); + } + + if (fp) + fhe->full->include_pass = pass; + + if (found_path) + *found_path = path; + + return fp; +} + +/* + * Opens an include or input file. Public version, for use by modules + * that get a file:lineno pair and need to look at the file again + * (e.g. the CodeView debug backend). Returns NULL on failure. + */ +FILE *pp_input_fopen(const char *filename, enum file_flags mode) +{ + return inc_fopen(filename, NULL, NULL, INC_OPTIONAL, mode); +} + +/* + * Determine if we should warn on defining a single-line macro of + * name `name', with `nparam' parameters. If nparam is 0 or -1, will + * return true if _any_ single-line macro of that name is defined. + * Otherwise, will return true if a single-line macro with either + * `nparam' or no parameters is defined. + * + * If a macro with precisely the right number of parameters is + * defined, or nparam is -1, the address of the definition structure + * will be returned in `defn'; otherwise NULL will be returned. If `defn' + * is NULL, no action will be taken regarding its contents, and no + * error will occur. + * + * Note that this is also called with nparam zero to resolve + * `ifdef'. + */ +static bool +smacro_defined(Context *ctx, const char *name, int nparam, SMacro **defn, + bool nocase, bool find_alias) +{ + struct hash_table *smtbl; + SMacro *m; + + smtbl = ctx ? &ctx->localmac : &smacros; + +restart: + m = (SMacro *) hash_findix(smtbl, name); + + while (m) { + if (!mstrcmp(m->name, name, m->casesense && nocase) && + (nparam <= 0 || m->nparam == 0 || + (nparam >= m->nparam_min && + (m->varadic || nparam <= m->nparam)))) { + if (m->alias && !find_alias) { + if (!ppconf.noaliases) { + name = tok_text(m->expansion); + goto restart; + } else { + continue; + } + } + if (defn) + *defn = m; + return true; + } + m = m->next; + } + + return false; +} + +/* param should be a natural number [0; INT_MAX] */ +static int read_param_count(const char *str) +{ + int result; + bool err; + + result = readnum(str, &err); + if (result < 0 || result > INT_MAX) { + result = 0; + nasm_nonfatal("parameter count `%s' is out of bounds [%d; %d]", + str, 0, INT_MAX); + } else if (err) + nasm_nonfatal("unable to parse parameter count `%s'", str); + return result; +} + +/* + * Count and mark off the parameters in a multi-line macro call. + * This is called both from within the multi-line macro expansion + * code, and also to mark off the default parameters when provided + * in a %macro definition line. + * + * Note that we need space in the params array for parameter 0 being + * a possible captured label as well as the final NULL. + * + * Returns a pointer to the pointer to a terminal comma if present; + * used to drop an empty terminal argument for legacy reasons. + */ +static Token **count_mmac_params(Token *tline, int *nparamp, Token ***paramsp) +{ + int paramsize; + int nparam = 0; + Token *t; + Token **comma = NULL, **maybe_comma = NULL; + Token **params; + + paramsize = PARAM_DELTA; + nasm_newn(params, paramsize); + + t = skip_white(tline); + if (t) { + while (true) { + /* Need two slots for captured label and NULL */ + if (unlikely(nparam+2 >= paramsize)) { + paramsize += PARAM_DELTA; + params = nasm_realloc(params, sizeof(*params) * paramsize); + } + params[++nparam] = t; + if (tok_is(t, '{')) { + int brace = 1; + + comma = NULL; /* Non-empty parameter */ + + while (brace && (t = t->next)) { + brace += tok_is(t, '{'); + brace -= tok_is(t, '}'); + } + + if (t) { + /* + * Now we've found the closing brace, look further + * for the comma. + */ + t = skip_white(t->next); + if (tok_isnt(t, ',')) + nasm_nonfatal("braces do not enclose all of macro parameter"); + } else { + nasm_nonfatal("expecting closing brace in macro parameter"); + } + } + + /* Advance to the next comma */ + maybe_comma = &t->next; + while (tok_isnt(t, ',')) { + if (!tok_white(t)) + comma = NULL; /* Non-empty parameter */ + maybe_comma = &t->next; + t = t->next; + } + + if (!t) + break; /* End of string, no comma */ + + comma = maybe_comma; /* Point to comma pointer */ + t = skip_white(t->next); /* Eat the comma and whitespace */ + } + } + + params[nparam+1] = NULL; + *paramsp = params; + *nparamp = nparam; + + return comma; +} + +/* + * Determine whether one of the various `if' conditions is true or + * not. + * + * We must free the tline we get passed. + */ +static enum cond_state if_condition(Token * tline, enum preproc_token ct) +{ + bool j; + Token *t, *tt, *origline; + struct ppscan pps; + struct tokenval tokval; + expr *evalresult; + enum token_type needtype; + const char *dname = pp_directives[ct]; + bool casesense = true; + enum preproc_token cond = PP_COND(ct); + + origline = tline; + + switch (cond) { + case PP_IFCTX: + j = false; /* have we matched yet? */ + while (true) { + tline = skip_white(tline); + if (!tline) + break; + if (tline->type != TOKEN_ID) { + nasm_nonfatal("`%s' expects context identifiers", + dname); + goto fail; + } + if (cstk && cstk->name && !nasm_stricmp(tok_text(tline), cstk->name)) + j = true; + tline = tline->next; + } + break; + + case PP_IFDEF: + case PP_IFDEFALIAS: + { + bool alias = cond == PP_IFDEFALIAS; + SMacro *smac; + Context *ctx; + const char *mname; + + j = false; /* have we matched yet? */ + while (tline) { + tline = skip_white(tline); + if (!tline || (tline->type != TOKEN_ID && + tline->type != TOKEN_LOCAL_MACRO)) { + nasm_nonfatal("`%s' expects macro identifiers", + dname); + goto fail; + } + + mname = tok_text(tline); + ctx = get_ctx(mname, &mname); + if (smacro_defined(ctx, mname, -1, &smac, true, alias) && smac + && smac->alias == alias) { + j = true; + break; + } + tline = tline->next; + } + break; + } + + case PP_IFDIFI: + /* + * %ifdifi doesn't actually exist; it ignores its argument and is + * always false. This exists solely to stub out the corresponding + * TASM directive. + */ + j = false; + goto fail; + + case PP_IFENV: + tline = expand_smacro(tline); + j = false; /* have we matched yet? */ + while (tline) { + tline = skip_white(tline); + if (!tline || (tline->type != TOKEN_ID && + tline->type != TOKEN_STR && + tline->type != TOKEN_INTERNAL_STR && + tline->type != TOKEN_ENVIRON)) { + nasm_nonfatal("`%s' expects environment variable names", + dname); + goto fail; + } + + j |= !!pp_getenv(tline, false); + tline = tline->next; + } + break; + + case PP_IFIDNI: + casesense = false; + /* fall through */ + case PP_IFIDN: + tline = expand_smacro(tline); + t = tt = tline; + while (tok_isnt(tt, ',')) + tt = tt->next; + if (!tt) { + nasm_nonfatal("`%s' expects two comma-separated arguments", + dname); + goto fail; + } + tt = tt->next; + j = true; /* assume equality unless proved not */ + while (tok_isnt(t, ',') && tt) { + unsigned int l1, l2; + const char *t1, *t2; + + if (tok_is(tt, ',')) { + nasm_nonfatal("`%s': more than one comma on line", + dname); + goto fail; + } + if (t->type == TOKEN_WHITESPACE) { + t = t->next; + continue; + } + if (tt->type == TOKEN_WHITESPACE) { + tt = tt->next; + continue; + } + if (tt->type != t->type) { + j = false; /* found mismatching tokens */ + break; + } + + t1 = unquote_token(t); + t2 = unquote_token(tt); + l1 = t->len; + l2 = tt->len; + + if (l1 != l2 || mmemcmp(t1, t2, l1, casesense)) { + j = false; + break; + } + + t = t->next; + tt = tt->next; + } + if (!tok_is(t, ',') || tt) + j = false; /* trailing gunk on one end or other */ + break; + + case PP_IFMACRO: + { + bool found = false; + MMacro searching, *mmac; + + tline = skip_white(tline); + tline = expand_id(tline); + if (!tok_is(tline, TOKEN_ID)) { + nasm_nonfatal("`%s' expects a macro name", dname); + goto fail; + } + nasm_zero(searching); + searching.name = dup_text(tline); + searching.casesense = true; + searching.nparam_min = 0; + searching.nparam_max = INT_MAX; + tline = expand_smacro(tline->next); + tline = skip_white(tline); + if (!tline) { + } else if (!tok_is(tline, TOKEN_NUM)) { + nasm_nonfatal("`%s' expects a parameter count or nothing", + dname); + } else { + searching.nparam_min = searching.nparam_max = + read_param_count(tok_text(tline)); + } + if (tline && tok_is(tline->next, '-')) { + tline = tline->next->next; + if (tok_is(tline, '*')) + searching.nparam_max = INT_MAX; + else if (!tok_is(tline, TOKEN_NUM)) + nasm_nonfatal("`%s' expects a parameter count after `-'", + dname); + else { + searching.nparam_max = read_param_count(tok_text(tline)); + if (searching.nparam_min > searching.nparam_max) { + nasm_nonfatal("minimum parameter count exceeds maximum"); + searching.nparam_max = searching.nparam_min; + } + } + } + if (tline && tok_is(tline->next, '+')) { + tline = tline->next; + searching.plus = true; + } + mmac = (MMacro *) hash_findix(&mmacros, searching.name); + while (mmac) { + if (!strcmp(mmac->name, searching.name) && + (mmac->nparam_min <= searching.nparam_max + || searching.plus) + && (searching.nparam_min <= mmac->nparam_max + || mmac->plus)) { + found = true; + break; + } + mmac = mmac->next; + } + if (tline && tline->next) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after `%s' ignored", dname); + } + nasm_free(searching.name); + j = found; + break; + } + + case PP_IFID: + needtype = TOKEN_ID; + goto iftype; + case PP_IFNUM: + needtype = TOKEN_NUM; + goto iftype; + case PP_IFSTR: + needtype = TOKEN_STR; + goto iftype; + +iftype: + t = tline = expand_smacro(tline); + + while (tok_white(t) || + (needtype == TOKEN_NUM && (tok_is(t, '-') | tok_is(t, '+')))) + t = t->next; + + j = tok_is(t, needtype); + break; + + case PP_IFTOKEN: + tline = expand_smacro(tline); + t = skip_white(tline); + + j = false; + if (t) { + t = skip_white(t->next); /* Skip the actual token + whitespace */ + j = !t; + } + break; + + case PP_IFEMPTY: + tline = expand_smacro(tline); + t = skip_white(tline); + j = !t; /* Should be empty */ + break; + + case PP_IF: + pps.tptr = tline = expand_smacro(tline); + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + if (!evalresult) + return -1; + if (tokval.t_type) { + nasm_warn(WARN_PP_TRAILING, "trailing garbage after expression ignored"); + } + if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant value given to `%s'", + dname); + goto fail; + } + j = reloc_value(evalresult) != 0; + break; + + case PP_IFUSING: + case PP_IFUSABLE: + { + const struct use_package *pkg; + const char *name; + + pkg = get_use_pkg(tline, dname, &name); + if (!name) + goto fail; + + j = pkg && ((cond == PP_IFUSABLE) | use_loaded[pkg->index]); + break; + } + + default: + nasm_nonfatal("unknown preprocessor directive `%s'", dname); + goto fail; + } + + free_tlist(origline); + return (j ^ PP_COND_NEGATIVE(ct)) ? COND_IF_TRUE : COND_IF_FALSE; + +fail: + free_tlist(origline); + return COND_NEVER; +} + +/* + * Default smacro expansion routine: just returns a copy of the + * expansion list. + */ +static Token * +smacro_expand_default(const SMacro *s, Token **params, int nparams) +{ + (void)params; + (void)nparams; + + return dup_tlist(s->expansion, NULL); +} + +/* + * Emit a macro definition or undef to the listing file or debug format + * if desired. This is similar to detoken(), but it handles the + * reverse expansion list, does not expand %! or local variable + * tokens, and does some special handling for macro parameters. + */ +static void +list_smacro_def(enum preproc_token op, const Context *ctx, const SMacro *m) +{ + Token *t; + size_t namelen, size; + char *def, *p, *end_spec; + char *context_prefix = NULL; + size_t context_len; + + namelen = strlen(m->name); + size = namelen + 2; /* Include room for space after name + NUL */ + + if (ctx) { + int context_depth = cstk->depth - ctx->depth + 1; + context_prefix = + nasm_asprintf("[%s::%"PRIu64"] %%%-*s", + ctx->name ? ctx->name : "", + ctx->number, context_depth, ""); + + context_len = nasm_last_string_len(); + memset(context_prefix + context_len - context_depth, + '$', context_depth); + size += context_len; + } + + list_for_each(t, m->expansion) + size += t->len; + + if (m->nparam) { + /* + * Space for ( and either , or ) around each + * parameter, plus up to 5 flags. + */ + int i; + + size += 1 + 5 * m->nparam; + for (i = 0; i < m->nparam; i++) + size += m->params[i].name.len; + } + + def = nasm_malloc(size); + p = def+size; + *--p = '\0'; + + list_for_each(t, m->expansion) { + p -= t->len; + memcpy(p, tok_text(t), t->len); + } + + *--p = ' '; + end_spec = p; /* Truncate here for macro def only */ + + if (m->nparam) { + int i; + + *--p = ')'; + + for (i = m->nparam-1; i >= 0; i--) { + enum sparmflags flags = m->params[i].flags; + if (flags & (SPARM_GREEDY|SPARM_VARADIC)) + *--p = '+'; + p -= m->params[i].name.len; + memcpy(p, tok_text(&m->params[i].name), m->params[i].name.len); + + if (flags & SPARM_NOSTRIP) + *--p = '!'; + if (flags & SPARM_STR) { + *--p = '&'; + if (flags & SPARM_CONDQUOTE) + *--p = '&'; + } + if (flags & SPARM_EVAL) + *--p = '='; + *--p = ','; + } + *p = '('; /* First parameter starts with ( not , */ + } + + p -= namelen; + memcpy(p, m->name, namelen); + + if (context_prefix) { + p -= context_len; + memcpy(p, context_prefix, context_len); + nasm_free(context_prefix); + } + + if (ppdbg & PDBG_LIST_SMACROS) + nasm_listmsg("%s %s", pp_directives[op], p); + if (ppdbg & PDBG_SMACROS) { + bool define = !(op == PP_UNDEF || op == PP_UNDEFALIAS); + if (!define) + *end_spec = '\0'; /* Remove the expansion (for list file only) */ + dfmt->debug_smacros(define, p); + } + nasm_free(def); +} + +/* + * Parse smacro arguments, return argument count. If the tmpl argument + * is set, set the nparam, varadic and params field in the template. + * The varadic field is not used by define_smacro(), but is provided + * in case the caller wants it for other purposes. + * + * *tpp is updated to point to the pointer to the first token after the + * prototype. + * + * The text values from any argument tokens are "stolen" and the + * corresponding text fields set to NULL. + * + * Note that the user can't define a true varadic macro; doing so + * would be meaningless. The true varadic macros are only used for + * internal "magic macro" functions. + */ +static int parse_smacro_template(Token ***tpp, SMacro *tmpl) +{ + int nparam = 0; + enum sparmflags flags; + struct smac_param *params = NULL; + bool err, done; + bool greedy = false; + Token **tn = *tpp; + Token *t = *tn; + Token *name; + + /* + * DO NOT skip whitespace here, or we won't be able to distinguish: + * + * %define foo (a,b) ; no arguments, (a,b) is the expansion + * %define bar(a,b) ; two arguments, empty expansion + * + * This ambiguity was inherited from C. + */ + + if (!tok_is(t, '(')) + goto finish; + + if (tmpl) { + Token *tx = t; + Token **txpp = &tx; + int sparam; + + /* Count parameters first */ + sparam = parse_smacro_template(&txpp, NULL); + if (!sparam) + goto finish; /* No parameters, we're done */ + nasm_newn(params, sparam); + } + + /* Skip leading paren */ + tn = &t->next; + t = *tn; + + name = NULL; + flags = 0; + err = done = false; + + while (!done) { + if (!t) { + if (name || flags) + nasm_nonfatal("`)' expected to terminate macro template"); + else + nasm_nonfatal("parameter identifier expected"); + break; + } + + switch (t->type) { + case TOKEN_ID: + if (name) + goto bad; + name = t; + break; + case '=': + flags |= SPARM_EVAL; + break; + case '&': + flags |= SPARM_STR; + break; + case TOKEN_DBL_AND: + flags |= SPARM_STR|SPARM_CONDQUOTE; + break; + case '!': + flags |= SPARM_NOSTRIP; + break; + case '+': + flags |= SPARM_GREEDY|SPARM_OPTIONAL; + greedy = true; + break; + case ',': + if (greedy) + nasm_nonfatal("greedy parameter must be last"); + goto end_param; + case ')': + done = true; + goto end_param; + end_param: + if (params) { + if (name) + steal_Token(¶ms[nparam].name, name); + params[nparam].flags = flags; + } + nparam++; + name = NULL; + flags = 0; + break; + case TOKEN_WHITESPACE: + break; + default: + bad: + if (!err) { + nasm_nonfatal("garbage `%s' in macro parameter list", + tok_text(t)); + err = true; + } + break; + } + + tn = &t->next; + t = *tn; + } + +finish: + while (t && t->type == TOKEN_WHITESPACE) { + tn = &t->next; + t = t->next; + } + *tpp = tn; + if (tmpl) { + tmpl->nparam = nparam; + tmpl->varadic = greedy; + tmpl->params = params; + } + return nparam; +} + +/* + * Common code for defining an smacro. The tmpl argument, if not NULL, + * contains any macro parameters that aren't explicit arguments; + * those are the more uncommon macro variants. + */ +static SMacro *define_smacro(const char *mname, bool casesense, + Token *expansion, SMacro *tmpl) +{ + SMacro *smac, **smhead; + struct hash_table *smtbl; + Context *ctx; + bool defining_alias = false; + int nparam = 0; + bool defined; + + if (tmpl) { + defining_alias = tmpl->alias; + nparam = tmpl->nparam; + if (nparam && !defining_alias) + mark_smac_params(expansion, tmpl, 0); + } + + ctx = get_ctx(mname, &mname); + + defined = smacro_defined(ctx, mname, nparam, &smac, casesense, true); + + if (defined) { + if (smac->alias) { + if (smac->in_progress) { + nasm_nonfatal("macro alias loop"); + goto fail; + } + + if (!defining_alias && !ppconf.noaliases) { + /* It is an alias macro; follow the alias link */ + SMacro *s; + + smac->in_progress++; + s = define_smacro(tok_text(smac->expansion), casesense, + expansion, tmpl); + smac->in_progress--; + return s; + } + } + + if (casesense ^ smac->casesense) { + /* + *!pp-macro-def-case-single [on] single-line macro defined both case sensitive and insensitive + *!=macro-def-case-single + *! warns when a single-line macro is defined both case + *! sensitive and case insensitive. + *! The new macro + *! definition will override (shadow) the original one, + *! although the original macro is not deleted, and will + *! be re-exposed if the new macro is deleted with + *! \c{%undef}, or, if the original macro is the case + *! insensitive one, the macro call is done with a + *! different case. + */ + nasm_warn(WARN_PP_MACRO_DEF_CASE_SINGLE, "case %ssensitive definition of macro `%s' will shadow %ssensitive macro `%s'", + casesense ? "" : "in", + mname, + smac->casesense ? "" : "in", + smac->name); + defined = false; + } else if ((!!nparam) ^ (!!smac->nparam)) { + /* + * Most recent versions of NASM considered this an error, + * so promote this warning to error by default. + * + *!pp-macro-def-param-single [err] single-line macro defined with and without parameters + *!=macro-def-param-single + *! warns if the same single-line macro is defined with and + *! without parameters. + *! The new macro + *! definition will override (shadow) the original one, + *! although the original macro is not deleted, and will + *! be re-exposed if the new macro is deleted with + *! \c{%undef}. + */ + nasm_warn(WARN_PP_MACRO_DEF_PARAM_SINGLE, + "macro `%s' defined both with and without parameters", + mname); + defined = false; + } else if (smac->nparam < nparam) { + /* + *!pp-macro-def-greedy-single [on] single-line macro + *!=macro-def-greedy-single + *! definition shadows greedy macro warns when a + *! single-line macro is defined which would match a + *! previously existing greedy definition. The new macro + *! definition will override (shadow) the original one, + *! although the original macro is not deleted, and will + *! be re-exposed if the new macro is deleted with + *! \c{%undef}, and will be invoked if called with a + *! parameter count that does not match the new definition. + */ + nasm_warn(WARN_PP_MACRO_DEF_GREEDY_SINGLE, + "defining macro `%s' shadows previous greedy definition", + mname); + defined = false; + } + } + + if (defined) { + /* + * We're redefinining, so we have to take over an + * existing SMacro structure. This means freeing + * what was already in it, but not the structure itself. + */ + clear_smacro(smac); + } else { + /* Create a new macro */ + smtbl = ctx ? &ctx->localmac : &smacros; + smhead = (SMacro **) hash_findi_add(smtbl, mname); + nasm_new(smac); + smac->next = *smhead; + *smhead = smac; + } + + smac->name = nasm_strdup(mname); + smac->casesense = casesense; + smac->expansion = reverse_tokens(expansion); + smac->expand = smacro_expand_default; + smac->nparam = nparam; + smac->nparam_min = nparam; + if (tmpl) { + smac->params = tmpl->params; + smac->alias = tmpl->alias; + smac->recursive = tmpl->recursive; + if (tmpl->expand) { + smac->expand = tmpl->expand; + smac->expandpvt = tmpl->expandpvt; + } + if (nparam) { + int nparam_min = nparam; + + smac->varadic = + !!(tmpl->params[nparam-1].flags & + (SPARM_GREEDY|SPARM_VARADIC)); + + while (nparam_min > 1) { + if (!(tmpl->params[nparam_min-1].flags & SPARM_OPTIONAL)) + break; + nparam_min--; + } + + smac->nparam_min = nparam_min; + } + } + if (ppdbg & (PDBG_SMACROS|PDBG_LIST_SMACROS)) { + list_smacro_def((smac->alias ? PP_DEFALIAS : PP_DEFINE) + + !casesense, ctx, smac); + } + return smac; + +fail: + free_tlist(expansion); + if (tmpl) + free_smacro_members(tmpl); + return NULL; +} + +/* + * Undefine an smacro + */ +static void undef_smacro(const char *mname, bool undefalias) +{ + SMacro **smhead, *s, **sp; + struct hash_table *smtbl; + Context *ctx; + + ctx = get_ctx(mname, &mname); + smtbl = ctx ? &ctx->localmac : &smacros; + smhead = (SMacro **)hash_findi(smtbl, mname, NULL); + + if (smhead) { + /* + * We now have a macro name... go hunt for it. + */ + sp = smhead; + while ((s = *sp) != NULL) { + if (!mstrcmp(s->name, mname, s->casesense)) { + if (s->alias && !undefalias) { + if (!ppconf.noaliases) { + if (s->in_progress) { + nasm_nonfatal("macro alias loop"); + } else { + s->in_progress = true; + undef_smacro(tok_text(s->expansion), false); + s->in_progress = false; + } + } + } else { + if (list_option('d')) + list_smacro_def(s->alias ? PP_UNDEFALIAS : PP_UNDEF, + ctx, s); + *sp = s->next; + free_smacro(s); + continue; + } + } + sp = &s->next; + } + } +} + +/* + * Parse a mmacro specification. + */ +static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive) +{ + tline = tline->next; + tline = skip_white(tline); + tline = expand_id(tline); + if (!tok_is(tline, TOKEN_ID)) { + nasm_nonfatal("`%s' expects a macro name", directive); + return false; + } + +#if 0 + def->prev = NULL; +#endif + def->name = dup_text(tline); + def->plus = false; + def->nolist = 0; + def->nparam_min = 0; + def->nparam_max = 0; + + tline = expand_smacro(tline->next); + tline = skip_white(tline); + if (!tok_is(tline, TOKEN_NUM)) + nasm_nonfatal("`%s' expects a parameter count", directive); + else + def->nparam_min = def->nparam_max = read_param_count(tok_text(tline)); + if (tline && tok_is(tline->next, '-')) { + tline = tline->next->next; + if (tok_is(tline, '*')) { + def->nparam_max = INT_MAX; + } else if (!tok_is(tline, TOKEN_NUM)) { + nasm_nonfatal("`%s' expects a parameter count after `-'", directive); + } else { + def->nparam_max = read_param_count(tok_text(tline)); + if (def->nparam_min > def->nparam_max) { + nasm_nonfatal("minimum parameter count exceeds maximum"); + def->nparam_max = def->nparam_min; + } + } + } + if (tline && tok_is(tline->next, '+')) { + tline = tline->next; + def->plus = true; + } + if (tline && tok_is(tline->next, TOKEN_ID) && + tline->next->len == 7 && + !nasm_stricmp(tline->next->text.a, ".nolist")) { + tline = tline->next; + if (!list_option('f')) + def->nolist |= NL_LIST|NL_LINE; + } + + /* + * Handle default parameters. + */ + def->ndefs = 0; + if (tline && tline->next) { + Token **comma; + def->dlist = tline->next; + tline->next = NULL; + comma = count_mmac_params(def->dlist, &def->ndefs, &def->defaults); + if (!ppconf.sane_empty_expansion && comma) { + *comma = NULL; + def->ndefs--; + nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY, + "dropping trailing empty default parameter in definition of multi-line macro `%s'", + def->name); + } + } else { + def->dlist = NULL; + def->defaults = NULL; + } + def->expansion = NULL; + + if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min && + !def->plus) { + /* + *!pp-macro-defaults [on] macros with more default than optional parameters + *!=macro-defaults + *! warns when a macro has more default parameters than optional parameters. + *! See \k{mlmacdef} for why might want to disable this warning. + */ + nasm_warn(WARN_PP_MACRO_DEFAULTS, + "too many default macro parameters in macro `%s'", def->name); + } + + return true; +} + + +/* + * Decode a size directive + */ +static int parse_size(const char *str) { + static const char *size_names[] = + { "byte", "dword", "oword", "qword", "tword", "word", "yword" }; + static const int sizes[] = + { 0, 1, 4, 16, 8, 10, 2, 32 }; + return str ? sizes[bsii(str, size_names, ARRAY_SIZE(size_names))+1] : 0; +} + +/* + * Process a preprocessor %pragma directive. Currently there are none. + * Gets passed the token list starting with the "preproc" token from + * "%pragma preproc". + */ +static void do_pragma_preproc(Token *tline) +{ + const char *txt; + + /* Skip to the real stuff */ + tline = tline->next; + tline = skip_white(tline); + + if (!tok_is(tline, TOKEN_ID)) + return; + + txt = tok_text(tline); + if (!nasm_stricmp(txt, "sane_empty_expansion")) { + tline = skip_white(tline->next); + ppconf.sane_empty_expansion = + pp_get_boolean_option(tline, ppconf.sane_empty_expansion); + } else { + /* Unknown pragma, ignore for now */ + } +} + +static bool is_macro_id(const Token *t) +{ + return tok_is(t, TOKEN_ID) || tok_is(t, TOKEN_LOCAL_MACRO); +} + +static const char *get_id(Token **tp, const char *dname) +{ + const char *id; + Token *t = *tp; + + t = t->next; /* Skip directive */ + t = skip_white(t); + t = expand_id(t); + + if (!is_macro_id(t)) { + nasm_nonfatal("`%s' expects a macro identifier", dname); + return NULL; + } + + id = tok_text(t); + t = skip_white(t); + *tp = t; + return id; +} + +/* Parse a %use package name and find the package. Set *err on syntax error. */ +static const struct use_package * +get_use_pkg(Token *t, const char *dname, const char **name) +{ + const char *id; + + t = skip_white(t); + t = expand_smacro(t); + + *name = NULL; + + if (!t) { + nasm_nonfatal("`%s' expects a package name, got end of line", dname); + return NULL; + } else if (t->type != TOKEN_ID && t->type != TOKEN_STR) { + nasm_nonfatal("`%s' expects a package name, got `%s'", + dname, tok_text(t)); + return NULL; + } + + *name = id = unquote_token(t); + + t = t->next; + t = skip_white(t); + if (t) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after `%s' ignored", dname); + } + + return nasm_find_use_package(id); +} + +/* + * Mark parameter tokens in an smacro definition. If the type argument + * is 0, create smac param tokens, otherwise use the type specified; + * normally this is used for TOKEN_XDEF_PARAM, which is used to protect + * parameter tokens during expansion during %xdefine. + * + * tmpl may not be NULL here. + */ +static void mark_smac_params(Token *tline, const SMacro *tmpl, + enum token_type type) +{ + const struct smac_param *params = tmpl->params; + int nparam = tmpl->nparam; + Token *t; + int i; + + list_for_each(t, tline) { + if (t->type != TOKEN_ID && t->type != TOKEN_XDEF_PARAM) + continue; + + for (i = 0; i < nparam; i++) { + if (tok_text_match(t, ¶ms[i].name)) + t->type = type ? type : tok_smac_param(i); + } + } +} + +/** + * %clear selected macro sets either globally or in contexts + */ +static void do_clear(enum clear_what what, bool context) +{ + if (context) { + if (what & CLEAR_ALLDEFINE) { + Context *ctx; + list_for_each(ctx, cstk) + clear_smacro_table(&ctx->localmac, what); + } + /* Nothing else can be context-local */ + } else { + if (what & CLEAR_ALLDEFINE) + clear_smacro_table(&smacros, what); + if (what & CLEAR_MMACRO) + free_mmacro_table(&mmacros); + } +} + +/* + * Process a %line directive, including the gcc/cpp compatibility + * form with a # at the front. + */ +static int line_directive(Token *origline, Token *tline) +{ + int k, m; + bool err; + const char *dname; + + /* + * Valid syntaxes: + * %line nnn[+mmm] [filename] + * %line nnn[+mmm] "filename" flags... + * + * "flags" are for gcc compatibility and are currently ignored. + * + * '#' at the beginning of the line is also treated as a %line + * directive, again for compatibility with gcc. + */ + if ((ppopt & PP_NOLINE) || istk->mstk.mstk) + goto done; + + dname = tok_text(tline); + tline = tline->next; + tline = skip_white(tline); + if (!tok_is(tline, TOKEN_NUM)) { + nasm_nonfatal("`%s' expects a line number", dname); + goto done; + } + k = readnum(tok_text(tline), &err); + m = 1; + tline = tline->next; + if (tok_is(tline, '+') || tok_is(tline, '-')) { + bool minus = tok_is(tline, '-'); + tline = tline->next; + if (!tok_is(tline, TOKEN_NUM)) { + nasm_nonfatal("`%s' expects a line increment", dname); + goto done; + } + m = readnum(tok_text(tline), &err); + if (minus) + m = -m; + tline = tline->next; + } + tline = skip_white(tline); + if (tline) { + if (tline->type == TOKEN_STR) { + const char *fname; + /* + * If this is a quoted string, ignore anything after + * it; this allows for compatibility with gcc's + * additional flags options. + */ + + fname = unquote_token_anystr(tline, BADCTL, + dname[0] == '#' ? STR_C : STR_NASM); + src_set_fname(fname); + } else { + char *fname; + fname = detoken(tline, false); + src_set_fname(fname); + nasm_free(fname); + } + } + src_set_linnum(k); + + istk->where = src_where(); + istk->lineinc = m; + goto done; + +done: + free_tlist(origline); + return DIRECTIVE_FOUND; +} + +/* + * Used for the %arg and %local directives + */ +static void define_stack_smacro(const char *name, int offset) +{ + Token *tt; + + tt = make_tok_char(NULL, ')'); + tt = make_tok_num(tt, offset); + if (!tok_is(tt, '-')) + tt = make_tok_char(tt, '+'); + tt = new_Token(tt, TOKEN_ID, StackPointer, 0); + tt = make_tok_char(tt, '('); + + define_smacro(name, true, tt, NULL); +} + + +/* + * This implements the %assign directive: expand an smacro expression, + * then evaluate it, and assign the corresponding number to an smacro. + */ +static void assign_smacro(const char *mname, bool casesense, + Token *tline, const char *dname) +{ + struct ppscan pps; + expr *evalresult; + struct tokenval tokval; + + tline = expand_smacro(tline); + + pps.tptr = tline; + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + free_tlist(tline); + if (!evalresult) + return; + + if (tokval.t_type) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after expression ignored"); + } + if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant value given to `%s'", dname); + } else { + tline = make_tok_num(NULL, reloc_value(evalresult)); + + /* + * We now have a macro name, an implicit parameter count of + * zero, and a numeric token to use as an expansion. Create + * and store an SMacro. + */ + define_smacro(mname, casesense, tline, NULL); + } +} + +/* + * Implement string concatenation as used by the %strcat directive + * and function. + */ +static Token *pp_strcat(Token *tline, const char *dname) +{ + + size_t len; + Token *t; + Token *res = NULL; + char *q, *qbuf; + + len = 0; + list_for_each(t, tline) { + switch (t->type) { + case TOKEN_WHITESPACE: + case TOKEN_COMMA: + break; + case TOKEN_STR: + unquote_token(t); + /* fall through */ + case TOKEN_INTERNAL_STR: + len += t->len; + break; + default: + nasm_nonfatal("non-string passed to `%s': %s", dname, + tok_text(t)); + goto err; + } + } + + q = qbuf = nasm_malloc(len+1); + list_for_each(t, tline) { + if (t->type == TOKEN_INTERNAL_STR) + q = mempcpy(q, tok_text(t), t->len); + } + *q = '\0'; + + res = make_tok_qstr_len(NULL, qbuf, len); + nasm_free(qbuf); +err: + free_tlist(tline); + return res; +} + + +/* + * Implement substring extraction as used by the %substr directive + * and function. + */ +static Token *pp_substr_common(Token *t, int64_t start, int64_t count); + +static Token *pp_substr(Token *tline, const char *dname) +{ + int64_t start, count; + struct ppscan pps; + Token *t; + Token *res = NULL; + expr *evalresult; + struct tokenval tokval; + + t = skip_white(tline); + + if (!tok_is(t, TOKEN_STR)) { + nasm_nonfatal("`%s' requires a string as parameter", dname); + goto err; + } + + pps.tptr = skip_white(t->next); + if (tok_is(pps.tptr, TOKEN_COMMA)) + pps.tptr = skip_white(pps.tptr->next); + if (!pps.tptr) { + nasm_nonfatal("`%s' requires a starting index", dname); + goto err; + } + + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + if (!evalresult) { + goto err; + } else if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant value given to `%s'", dname); + goto err; + } + start = evalresult->value; + + pps.tptr = skip_white(pps.tptr); + if (!pps.tptr) { + count = 1; /* Backwards compatibility: one character */ + } else { + tokval.t_type = TOKEN_INVALID; + evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + if (!evalresult) { + goto err; + } else if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant value given to `%s'", dname); + goto err; + } + count = evalresult->value; + } + + res = pp_substr_common(t, start, count); + +err: + free_tlist(tline); + return res; +} + +static Token *pp_substr_common(Token *t, int64_t start, int64_t count) +{ + size_t len; + const char *txt; + + unquote_token(t); + len = t->len; + + /* make start and count being in range */ + start -= 1; /* First character is 1 */ + + if (start < 0) + start = 0; + if (count < 0) + count = len + count + 1 - start; + if (start + count > (int64_t)len) + count = len - start; + if (!len || count < 0 || start >=(int64_t)len) + start = -1, count = 0; /* empty string */ + + txt = (start < 0) ? "" : tok_text(t) + start; + return make_tok_qstr_len(NULL, txt, count); +} + +/** + * find and process preprocessor directive in passed line + * Find out if a line contains a preprocessor directive, and deal + * with it if so. + * + * If a directive _is_ found, it is the responsibility of this routine + * (and not the caller) to free_tlist() the line. + * + * @param tline a pointer to the current tokeninzed line linked list + * @param output if this directive generated output + * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND + * + */ +static int do_directive(Token *tline, Token **output) +{ + enum preproc_token op; + int j; + enum nolist_flags nolist; + bool casesense; + int offset; + const char *p; + char *q; + const char *found_path; + const char *mname; + struct ppscan pps; + Include *inc; + Context *ctx; + Cond *cond; + MMacro *mmac, **mmhead; + Token *t = NULL, *tt, *macro_start, *last, *origline; + Line *l; + struct tokenval tokval; + expr *evalresult; + int64_t count; + errflags severity; + const char *dname; /* Name of directive, for messages */ + + *output = NULL; /* No output generated */ + origline = tline; + + /* cpp-like line directive, must not be preceded by whitespace */ + if (tok_is(tline, '#')) + return line_directive(origline, tline); + + tline = skip_white(tline); + if (!tline) + return NO_DIRECTIVE_FOUND; + + switch (tline->type) { + case TOKEN_PREPROC_ID: + dname = tok_text(tline); + /* + * For it to be a directive, the second character has to be an + * ASCII letter; this is a very quick and dirty test for that; + * all other cases will get rejected by the token hash. + */ + if ((uint8_t)(dname[1] - 'A') > (uint8_t)('z' - 'A')) + return NO_DIRECTIVE_FOUND; + + op = pp_token_hash(dname); + break; + + case TOKEN_ID: + if (likely(!(ppopt & PP_TASM))) + return NO_DIRECTIVE_FOUND; + + dname = tok_text(tline); + op = pp_tasm_token_hash(dname); + break; + + default: + return NO_DIRECTIVE_FOUND; + } + + switch (op) { + case PP_invalid: + return NO_DIRECTIVE_FOUND; + + case PP_LINE: + /* + * %line directives are always processed immediately and + * unconditionally, as they are intended to reflect position + * in externally preprocessed sources. + */ + return line_directive(origline, tline); + + default: + break; + } + + if (unlikely(ppopt & PP_TRIVIAL)) + goto done; + + casesense = true; + if (PP_HAS_CASE(op) & PP_INSENSITIVE(op)) { + casesense = false; + op--; + } + + /* + * If we're in a non-emitting branch of a condition construct, + * or walking to the end of an already terminated %rep block, + * we should ignore all directives except for condition + * directives. + */ + if (((istk->conds && !emitting(istk->conds->state)) || + (istk->mstk.mstk && !istk->mstk.mstk->in_progress)) && + !is_condition(op)) { + return NO_DIRECTIVE_FOUND; + } + + /* + * If we're defining a macro or reading a %rep block, we should + * ignore all directives except for %macro/%imacro (which nest), + * %endm/%endmacro, %line and (only if we're in a %rep block) %endrep. + * If we're in a %rep block, another %rep nests, so should be let through. + */ + if (defining && op != PP_MACRO && op != PP_RMACRO && + op != PP_ENDMACRO && op != PP_ENDM && + (defining->name || (op != PP_ENDREP && op != PP_REP))) { + return NO_DIRECTIVE_FOUND; + } + + if (defining) { + if (op == PP_MACRO || op == PP_RMACRO) { + nested_mac_count++; + return NO_DIRECTIVE_FOUND; + } else if (nested_mac_count > 0) { + if (op == PP_ENDMACRO) { + nested_mac_count--; + return NO_DIRECTIVE_FOUND; + } + } + if (!defining->name) { + if (op == PP_REP) { + nested_rep_count++; + return NO_DIRECTIVE_FOUND; + } else if (nested_rep_count > 0) { + if (op == PP_ENDREP) { + nested_rep_count--; + return NO_DIRECTIVE_FOUND; + } + } + } + } + + if (pp_op_may_be_function[op]) { + if (tok_is(skip_white(tline->next), '(')) + return NO_DIRECTIVE_FOUND; /* Expand as a preprocessor function */ + } + + switch (op) { + default: + nasm_nonfatal("unknown preprocessor directive `%s'", dname); + return NO_DIRECTIVE_FOUND; /* didn't get it */ + + case PP_PRAGMA: + /* + * %pragma namespace options... + * + * The namespace "preproc" is reserved for the preprocessor; + * all other namespaces generate a [pragma] assembly directive. + * + * Invalid %pragmas are ignored and may have different + * meaning in future versions of NASM. + */ + t = tline; + tline = tline->next; + t->next = NULL; + tline = zap_white(expand_smacro(tline)); + if (tok_is(tline, TOKEN_ID)) { + if (!nasm_stricmp(tok_text(tline), "preproc")) { + /* Preprocessor pragma */ + do_pragma_preproc(tline); + free_tlist(tline); + } else { + /* Build the assembler directive */ + + /* Append bracket to the end of the output */ + for (t = tline; t->next; t = t->next) + ; + t->next = make_tok_char(NULL, ']'); + + /* Prepend "[pragma " */ + t = new_White(tline); + t = new_Token(t, TOKEN_ID, "pragma", 6); + t = make_tok_char(t, '['); + tline = t; + *output = tline; + } + } + break; + + case PP_STACKSIZE: + { + const char *arg; + + /* Directive to tell NASM what the default stack size is. The + * default is for a 16-bit stack, and this can be overridden with + * %stacksize large. + */ + tline = skip_white(tline->next); + if (!tline || tline->type != TOKEN_ID) { + nasm_nonfatal("`%s' missing size parameter", dname); + break; + } + + arg = tok_text(tline); + + if (nasm_stricmp(arg, "flat") == 0) { + /* All subsequent ARG directives are for a 32-bit stack */ + StackSize = 4; + StackPointer = "ebp"; + ArgOffset = 8; + LocalOffset = 0; + } else if (nasm_stricmp(arg, "flat64") == 0) { + /* All subsequent ARG directives are for a 64-bit stack */ + StackSize = 8; + StackPointer = "rbp"; + ArgOffset = 16; + LocalOffset = 0; + } else if (nasm_stricmp(arg, "large") == 0) { + /* All subsequent ARG directives are for a 16-bit stack, + * far function call. + */ + StackSize = 2; + StackPointer = "bp"; + ArgOffset = 4; + LocalOffset = 0; + } else if (nasm_stricmp(arg, "small") == 0) { + /* All subsequent ARG directives are for a 16-bit stack, + * far function call. We don't support near functions. + */ + StackSize = 2; + StackPointer = "bp"; + ArgOffset = 6; + LocalOffset = 0; + } else { + nasm_nonfatal("`%s' invalid size type", dname); + } + break; + } + + case PP_ARG: + /* TASM like ARG directive to define arguments to functions, in + * the following form: + * + * ARG arg1:WORD, arg2:DWORD, arg4:QWORD + */ + offset = ArgOffset; + do { + const char *arg; + int size = StackSize; + + /* Find the argument name */ + tline = skip_white(tline->next); + if (!tline || tline->type != TOKEN_ID) { + nasm_nonfatal("`%s' missing argument parameter", dname); + goto done; + } + arg = tok_text(tline); + + /* Find the argument size type */ + tline = tline->next; + if (!tok_is(tline, ':')) { + nasm_nonfatal("syntax error processing `%s' directive", dname); + goto done; + } + tline = tline->next; + if (!tok_is(tline, TOKEN_ID)) { + nasm_nonfatal("`%s' missing size type parameter", dname); + goto done; + } + + /* Allow macro expansion of type parameter */ + tt = tokenize(tok_text(tline)); + tt = expand_smacro(tt); + size = parse_size(tok_text(tt)); + if (!size) { + nasm_nonfatal("invalid size type for `%s' missing directive", dname); + free_tlist(tt); + goto done; + } + free_tlist(tt); + + /* Round up to even stack slots */ + size = ALIGN(size, StackSize); + + /* Now define the macro for the argument */ + define_stack_smacro(arg, offset); + offset += size; + + /* Move to the next argument in the list */ + tline = skip_white(tline->next); + } while (tok_is(tline, ',')); + ArgOffset = offset; + break; + + case PP_LOCAL: + { + int total_size = 0; + + /* TASM like LOCAL directive to define local variables for a + * function, in the following form: + * + * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize + * + * The '= LocalSize' at the end is ignored by NASM, but is + * required by TASM to define the local parameter size (and used + * by the TASM macro package). + */ + offset = LocalOffset; + do { + const char *local; + int size = StackSize; + + /* Find the argument name */ + tline = skip_white(tline->next); + if (!tline || tline->type != TOKEN_ID) { + nasm_nonfatal("`%s' missing argument parameter", dname); + goto done; + } + local = tok_text(tline); + + /* Find the argument size type */ + tline = tline->next; + if (!tok_is(tline, ':')) { + nasm_nonfatal("syntax error processing `%s' directive", dname); + goto done; + } + tline = tline->next; + if (!tok_is(tline, TOKEN_ID)) { + nasm_nonfatal("`%s' missing size type parameter", dname); + goto done; + } + + /* Allow macro expansion of type parameter */ + tt = tokenize(tok_text(tline)); + tt = expand_smacro(tt); + size = parse_size(tok_text(tt)); + if (!size) { + nasm_nonfatal("invalid size type for `%s' missing directive", dname); + free_tlist(tt); + goto done; + } + free_tlist(tt); + + /* Round up to even stack slots */ + size = ALIGN(size, StackSize); + + offset += size; /* Negative offset, increment before */ + + /* Now define the macro for the argument */ + define_stack_smacro(local, -offset); + + /* How is this different from offset? */ + total_size += size; + + /* Move to the next argument in the list */ + tline = skip_white(tline->next); + } while (tok_is(tline, ',')); + + /* Now define the assign to setup the enter_c macro correctly */ + tt = make_tok_num(NULL, total_size); + tt = make_tok_char(tt, '+'); + tt = new_Token(tt, TOKEN_LOCAL_MACRO, "%$localsize", 11); + assign_smacro("%$localsize", true, tt, dname); + + LocalOffset = offset; + break; + } + case PP_CLEAR: + { + bool context = false; + + t = tline->next = expand_smacro(tline->next); + t = skip_white(t); + if (!t) { + /* Emulate legacy behavior */ + do_clear(CLEAR_DEFINE|CLEAR_MMACRO, false); + } else { + while ((t = skip_white(t)) && t->type == TOKEN_ID) { + const char *txt = tok_text(t); + if (!nasm_stricmp(txt, "all")) { + do_clear(CLEAR_ALL, context); + } else if (!nasm_stricmp(txt, "define") || + !nasm_stricmp(txt, "def") || + !nasm_stricmp(txt, "smacro")) { + do_clear(CLEAR_DEFINE, context); + } else if (!nasm_stricmp(txt, "defalias") || + !nasm_stricmp(txt, "alias") || + !nasm_stricmp(txt, "salias")) { + do_clear(CLEAR_DEFALIAS, context); + } else if (!nasm_stricmp(txt, "alldef") || + !nasm_stricmp(txt, "alldefine")) { + do_clear(CLEAR_ALLDEFINE, context); + } else if (!nasm_stricmp(txt, "macro") || + !nasm_stricmp(txt, "mmacro")) { + do_clear(CLEAR_MMACRO, context); + } else if (!nasm_stricmp(txt, "context") || + !nasm_stricmp(txt, "ctx")) { + context = true; + } else if (!nasm_stricmp(txt, "global")) { + context = false; + } else if (!nasm_stricmp(txt, "nothing") || + !nasm_stricmp(txt, "none") || + !nasm_stricmp(txt, "ignore") || + !nasm_stricmp(txt, "-") || + !nasm_stricmp(txt, "--")) { + /* Do nothing */ + } else { + nasm_nonfatal("invalid option to %s: %s", dname, txt); + t = NULL; + } + } + } + + t = skip_white(t); + if (t) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after `%s' ignored", dname); + } + break; + } + + case PP_DEPEND: + t = tline->next = expand_smacro(tline->next); + t = skip_white(t); + if (!t || (t->type != TOKEN_STR && + t->type != TOKEN_INTERNAL_STR)) { + nasm_nonfatal("`%s' expects a file name", dname); + goto done; + } + if (skip_white(t->next)) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after `%s' ignored", dname); + } + + strlist_add(deplist, unquote_token_cstr(t)); + goto done; + + case PP_INCLUDE: + case PP_REQUIRE: + t = tline->next = expand_smacro(tline->next); + t = skip_white(t); + + if (!t || (t->type != TOKEN_STR && + t->type != TOKEN_INTERNAL_STR)) { + nasm_nonfatal("`%s' expects a file name", dname); + goto done; + } + if (skip_white(t->next)) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after `%s' ignored", dname); + } + p = unquote_token_cstr(t); + nasm_new(inc); + inc->next = istk; + found_path = NULL; + inc->fp = inc_fopen(p, deplist, &found_path, + (pp_mode == PP_DEPS) ? INC_OPTIONAL : + (op == PP_REQUIRE) ? INC_REQUIRED : + INC_NEEDED, NF_TEXT); + if (!inc->fp) { + /* -MG given but file not found, or repeated %require */ + nasm_free(inc); + } else { + inc->nolist = istk->nolist; + inc->noline = istk->noline; + inc->where = istk->where; + inc->lineinc = 0; + istk = inc; + if (!istk->noline) { + src_set(0, found_path ? found_path : p); + istk->where = src_where(); + istk->lineinc = 1; + if (ppdbg & PDBG_INCLUDE) + dfmt->debug_include(true, istk->next->where, istk->where); + } + if (!istk->nolist) + lfmt->uplevel(LIST_INCLUDE, 0); + } + break; + + case PP_USE: + { + const struct use_package *pkg; + const char *name; + + pkg = get_use_pkg(tline->next, dname, &name); + if (!name) + goto done; + if (!pkg) { + nasm_nonfatal("unknown `%s' package: `%s'", dname, name); + } else if (!use_loaded[pkg->index]) { + /* + * Not already included, go ahead and include it. + * Treat it as an include file for the purpose of + * producing a listing. + */ + use_loaded[pkg->index] = true; + stdmacpos = pkg->macros; + nasm_new(inc); + inc->next = istk; + if (!list_option('b')) { + inc->nolist++; + inc->noline++; + } + istk = inc; + if (!istk->nolist) + lfmt->uplevel(LIST_INCLUDE, 0); + if (!inc->noline) + src_set(0, NULL); + } + break; + } + case PP_PUSH: + case PP_REPL: + case PP_POP: + tline = tline->next; + tline = skip_white(tline); + tline = expand_id(tline); + if (tline) { + if (!tok_is(tline, TOKEN_ID)) { + nasm_nonfatal("`%s' expects a context identifier", dname); + goto done; + } + if (skip_white(tline->next)) { + nasm_warn(WARN_PP_TRAILING, "trailing garbage after `%s' ignored", + dname); + } + p = tok_text(tline); + } else { + p = NULL; /* Anonymous */ + } + + if (op == PP_PUSH) { + nasm_new(ctx); + ctx->depth = cstk ? cstk->depth + 1 : 1; + ctx->next = cstk; + ctx->name = p ? nasm_strdup(p) : NULL; + ctx->number = unique++; + cstk = ctx; + } else { + /* %pop or %repl */ + if (!cstk) { + nasm_nonfatal("`%s': context stack is empty", dname); + } else if (op == PP_POP) { + if (p && (!cstk->name || nasm_stricmp(p, cstk->name))) + nasm_nonfatal("`%s' in wrong context: %s, " + "expected %s", + dname, cstk->name ? cstk->name : "anonymous", p); + else + ctx_pop(); + } else { + /* op == PP_REPL */ + nasm_free((char *)cstk->name); + cstk->name = p ? nasm_strdup(p) : NULL; + p = NULL; + } + } + break; + case PP_FATAL: + severity = ERR_FATAL; + goto issue_error; + case PP_ERROR: + severity = ERR_NONFATAL|ERR_PASS2; + goto issue_error; + case PP_WARNING: + /*! + *!user [on] %warning directives + *! controls output of \c{%warning} directives (see \k{pperror}). + */ + severity = ERR_WARNING|WARN_USER|ERR_PASS2; + goto issue_error; + +issue_error: + { + /* Only error out if this is the final pass */ + tline->next = expand_smacro(tline->next); + tline = tline->next; + tline = skip_white(tline); + t = tline ? tline->next : NULL; + t = skip_white(t); + if (tok_is(tline, TOKEN_STR) && !t) { + /* The line contains only a quoted string */ + p = unquote_token(tline); /* Ignore NUL character truncation */ + nasm_error(severity, "%s", p); + } else { + /* Not a quoted string, or more than a quoted string */ + q = detoken(tline, false); + nasm_error(severity, "%s", q); + nasm_free(q); + } + break; + } + + CASE_PP_IF: + if (istk->conds && !emitting(istk->conds->state)) + j = COND_NEVER; + else { + j = if_condition(tline->next, op); + tline->next = NULL; /* it got freed */ + } + cond = nasm_malloc(sizeof(Cond)); + cond->next = istk->conds; + cond->state = j; + istk->conds = cond; + if(istk->mstk.mstk) + istk->mstk.mstk->condcnt++; + break; + + CASE_PP_ELIF: + if (!istk->conds) { + nasm_nonfatal("`%s': no matching `%%if'", dname); + break; + } + switch(istk->conds->state) { + case COND_IF_TRUE: + istk->conds->state = COND_DONE; + break; + + case COND_DONE: + case COND_NEVER: + break; + + case COND_ELSE_TRUE: + case COND_ELSE_FALSE: + /*! + *!pp-else-elif [on] %elif after %else + *! warns that an \c{%%elif}-type directive was encountered + *! after \c[%%else} has already been encounted. As a result, the + *! content of the \c{%%elif} will never be expanded. + */ + nasm_warn(WARN_PP_ELSE_ELIF|ERR_PP_PRECOND, + "`%s' after `%%else', ignoring content", dname); + istk->conds->state = COND_NEVER; + break; + + case COND_IF_FALSE: + /* + * IMPORTANT: In the case of %if, we will already have + * called expand_mmac_params(); however, if we're + * processing an %elif we must have been in a + * non-emitting mode, which would have inhibited + * the normal invocation of expand_mmac_params(). + * Therefore, we have to do it explicitly here. + */ + j = if_condition(expand_mmac_params(tline->next), op); + tline->next = NULL; /* it got freed */ + istk->conds->state = j; + break; + } + break; + + case PP_ELSE: + if (tline->next) + nasm_warn(WARN_PP_TRAILING|ERR_PP_PRECOND, + "trailing garbage after `%s' ignored", dname); + if (!istk->conds) { + nasm_nonfatal("`%s': no matching `%%if'", dname); + break; + } + switch(istk->conds->state) { + case COND_IF_TRUE: + case COND_DONE: + istk->conds->state = COND_ELSE_FALSE; + break; + + case COND_NEVER: + break; + + case COND_IF_FALSE: + istk->conds->state = COND_ELSE_TRUE; + break; + + case COND_ELSE_TRUE: + case COND_ELSE_FALSE: + /*! + *!pp-else-else [on] %else after %else + *! warns that a second \c{%else} clause was found for + *! the same \c{%if} statement. The content of this \c{%else} + *! clause will never be expanded. + */ + nasm_warn(WARN_PP_ELSE_ELSE|ERR_PP_PRECOND, + "`%s' after `%%else', ignoring content", dname); + istk->conds->state = COND_NEVER; + break; + } + break; + + case PP_ENDIF: + if (tline->next) { + nasm_warn(WARN_PP_TRAILING|ERR_PP_PRECOND, + "trailing garbage after `%s' ignored", dname); + } + if (!istk->conds) { + nasm_nonfatal("`%s': no matching `%%if'", dname); + break; + } + cond = istk->conds; + istk->conds = cond->next; + nasm_free(cond); + if(istk->mstk.mstk) + istk->mstk.mstk->condcnt--; + break; + + case PP_RMACRO: + case PP_MACRO: + { + MMacro *def; + + nasm_assert(!defining); + nasm_new(def); + def->casesense = casesense; + /* + * dstk.mstk points to the previous definition bracket, + * whereas dstk.mmac points to the topmost mmacro, which + * in this case is the one we are just starting to create. + */ + def->dstk.mstk = defining; + def->dstk.mmac = def; + if (op == PP_RMACRO) + def->max_depth = nasm_limit[LIMIT_MACRO_LEVELS]; + if (!parse_mmacro_spec(tline, def, dname)) { + nasm_free(def); + goto done; + } + + defining = def; + defining->where = istk->where; + + mmac = (MMacro *) hash_findix(&mmacros, defining->name); + while (mmac) { + if (!strcmp(mmac->name, defining->name) && + (mmac->nparam_min <= defining->nparam_max + || defining->plus) + && (defining->nparam_min <= mmac->nparam_max + || mmac->plus)) { + /*! + *!pp-macro-redef-multi [on] redefining multi-line macro + *! warns that a multi-line macro is being redefined, + *! without first removing the old definition with + *! \c{%unmacro}. + */ + nasm_warn(WARN_PP_MACRO_REDEF_MULTI, + "redefining multi-line macro `%s'", + defining->name); + break; + } + mmac = mmac->next; + } + break; + } + + case PP_ENDM: + case PP_ENDMACRO: + if (!(defining && defining->name)) { + nasm_nonfatal("`%s': not defining a macro", tok_text(tline)); + goto done; + } + mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name); + defining->next = *mmhead; + *mmhead = defining; + defining = NULL; + break; + + case PP_EXITMACRO: + /* + * We must search along istk->expansion until we hit a + * macro-end marker for a macro with a name. Then we + * bypass all lines between exitmacro and endmacro. + */ + list_for_each(l, istk->expansion) + if (l->finishes && l->finishes->name) + break; + + if (l) { + /* + * Remove all conditional entries relative to this + * macro invocation. (safe to do in this context) + */ + for ( ; l->finishes->condcnt > 0; l->finishes->condcnt --) { + cond = istk->conds; + if (!cond) { + l->finishes->condcnt = 0; + break; /* Possible in case of invalid nesting */ + } + istk->conds = cond->next; + nasm_free(cond); + } + istk->expansion = l; + } else { + nasm_nonfatal("`%%exitmacro' not within `%%macro' block"); + } + break; + + case PP_UNIMACRO: + casesense = false; + /* fall through */ + case PP_UNMACRO: + { + MMacro **mmac_p; + MMacro spec; + + nasm_zero(spec); + spec.casesense = casesense; + if (!parse_mmacro_spec(tline, &spec, dname)) { + goto done; + } + mmac_p = (MMacro **) hash_findi(&mmacros, spec.name, NULL); + if (!mmac_p) { + /* No such macro */ + free_tlist(spec.dlist); + break; + } + + /* Check the macro to be undefined is not being expanded */ + list_for_each(l, istk->expansion) { + if (l->finishes == *mmac_p) { + nasm_nonfatal("`%%unmacro' can't undefine the macro being expanded"); + /* + * Do not release the macro instance to avoid using the freed + * memory while proceeding the expansion. + */ + goto done; + } + } + + while (mmac_p && *mmac_p) { + mmac = *mmac_p; + if (mmac->casesense == spec.casesense && + !mstrcmp(mmac->name, spec.name, spec.casesense) && + mmac->nparam_min == spec.nparam_min && + mmac->nparam_max == spec.nparam_max && + mmac->plus == spec.plus) { + *mmac_p = mmac->next; + free_mmacro(mmac); + } else { + mmac_p = &mmac->next; + } + } + free_tlist(spec.dlist); + break; + } + + case PP_ROTATE: + while (tok_white(tline->next)) + tline = tline->next; + if (!tline->next) { + free_tlist(origline); + nasm_nonfatal("`%s' missing rotate count", dname); + return DIRECTIVE_FOUND; + } + t = expand_smacro(tline->next); + tline->next = NULL; + pps.tptr = tline = t; + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + evalresult = + evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + free_tlist(tline); + if (!evalresult) + return DIRECTIVE_FOUND; + if (tokval.t_type) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after expression ignored"); + } + if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant value given to `%s'", dname); + return DIRECTIVE_FOUND; + } + mmac = istk->mstk.mmac; + if (!mmac) { + nasm_nonfatal("`%s' invoked outside a macro call", dname);; + } else if (mmac->nparam == 0) { + nasm_nonfatal("`%s' invoked within macro without parameters", dname); + } else { + int rotate = mmac->rotate + reloc_value(evalresult); + + rotate %= (int)mmac->nparam; + if (rotate < 0) + rotate += mmac->nparam; + + mmac->rotate = rotate; + } + break; + + case PP_REP: + { + MMacro *tmp_defining; + + nolist = 0; + tline = skip_white(tline->next); + if (tok_is(tline, TOKEN_ID) && tline->len == 7 && + !nasm_memicmp(tline->text.a, ".nolist", 7)) { + if (!list_option('f')) + nolist |= NL_LIST; /* ... but update line numbers */ + tline = skip_white(tline->next); + } + + if (tline) { + pps.tptr = expand_smacro(tline); + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + /* XXX: really critical?! */ + evalresult = + evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + if (!evalresult) + goto done; + if (tokval.t_type) + nasm_warn(WARN_PP_TRAILING, "trailing garbage after expression ignored"); + if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant value given to `%s'", dname); + goto done; + } + count = reloc_value(evalresult); + if (count > nasm_limit[LIMIT_REP]) { + nasm_nonfatal("`%s' count %"PRId64" exceeds limit (currently %"PRId64")", + dname, count, nasm_limit[LIMIT_REP]); + count = 0; + } else if (count < 0) { + /*! + *!pp-rep-negative [on] regative %rep count + *!=negative-rep + *! warns about a negative count given to the \c{%rep} + *! preprocessor directive. + */ + nasm_warn(ERR_PASS2|WARN_PP_REP_NEGATIVE, + "negative `%s' count: %"PRId64, dname, count); + count = 0; + } else { + count++; + } + } else { + nasm_nonfatal("`%s' expects a repeat count", dname); + count = 0; + } + tmp_defining = defining; + nasm_new(defining); + defining->nolist = nolist; + defining->in_progress = count; + defining->mstk = istk->mstk; + defining->dstk.mstk = tmp_defining; + defining->dstk.mmac = tmp_defining ? tmp_defining->dstk.mmac : NULL; + defining->where = istk->where; + break; + } + + case PP_ENDREP: + if (!defining || defining->name) { + nasm_nonfatal("`%%endrep': no matching `%%rep'"); + goto done; + } + + /* + * Now we have a "macro" defined - although it has no name + * and we won't be entering it in the hash tables - we must + * push a macro-end marker for it on to istk->expansion. + * After that, it will take care of propagating itself (a + * macro-end marker line for a macro which is really a %rep + * block will cause the macro to be re-expanded, complete + * with another macro-end marker to ensure the process + * continues) until the whole expansion is forcibly removed + * from istk->expansion by a %exitrep. + */ + nasm_new(l); + l->next = istk->expansion; + l->finishes = defining; + l->first = NULL; + l->where = src_where(); + istk->expansion = l; + + istk->mstk.mstk = defining; + + /* A loop does not change istk->noline */ + istk->nolist += !!(defining->nolist & NL_LIST); + if (!istk->nolist) + lfmt->uplevel(LIST_MACRO, 0); + + defining = defining->dstk.mstk; + break; + + case PP_EXITREP: + /* + * We must search along istk->expansion until we hit a + * macro-end marker for a macro with no name. Then we set + * its `in_progress' flag to 0. + */ + list_for_each(l, istk->expansion) + if (l->finishes && !l->finishes->name) + break; + + if (l) + l->finishes->in_progress = 0; + else + nasm_nonfatal("`%%exitrep' not within `%%rep' block"); + break; + + case PP_DEFINE: + case PP_XDEFINE: + case PP_DEFALIAS: + { + SMacro tmpl; + Token **lastp; + int nparam; + + if (!(mname = get_id(&tline, dname))) + goto done; + + nasm_zero(tmpl); + lastp = &tline->next; + nparam = parse_smacro_template(&lastp, &tmpl); + tline = *lastp; + *lastp = NULL; + + if (unlikely(op == PP_DEFALIAS)) { + macro_start = tline; + if (!is_macro_id(macro_start)) { + nasm_nonfatal("`%s' expects a macro identifier to alias", + dname); + goto done; + } + tt = macro_start->next; + macro_start->next = NULL; + tline = tline->next; + tline = skip_white(tline); + if (tline && tline->type) { + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after aliasing identifier ignored"); + } + free_tlist(tt); + tmpl.alias = true; + } else { + if (op == PP_XDEFINE) { + /* Protect macro parameter tokens */ + if (nparam) + mark_smac_params(tline, &tmpl, TOKEN_XDEF_PARAM); + tline = expand_smacro(tline); + } + macro_start = tline; + } + + /* + * Good. We now have a macro name, a parameter count, and a + * token list (in reverse order) for an expansion. We ought + * to be OK just to create an SMacro, store it, and let + * free_tlist have the rest of the line (which we have + * carefully re-terminated after chopping off the expansion + * from the end). + */ + define_smacro(mname, casesense, macro_start, &tmpl); + break; + } + + case PP_UNDEF: + case PP_UNDEFALIAS: + if (!(mname = get_id(&tline, dname))) + goto done; + if (tline->next) + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after macro name ignored"); + + undef_smacro(mname, op == PP_UNDEFALIAS); + break; + + case PP_DEFSTR: + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = expand_smacro(tline->next); + last->next = NULL; + + tline = zap_white(tline); + q = detoken(tline, false); + macro_start = make_tok_qstr(NULL, q); + nasm_free(q); + + /* + * We now have a macro name, an implicit parameter count of + * zero, and a string token to use as an expansion. Create + * and store an SMacro. + */ + define_smacro(mname, casesense, macro_start, NULL); + break; + + case PP_DEFTOK: + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = expand_smacro(tline->next); + last->next = NULL; + + t = skip_white(tline); + /* t should now point to the string */ + if (!tok_is(t, TOKEN_STR)) { + nasm_nonfatal("`%s' requires string as second parameter", dname); + free_tlist(tline); + goto done; + } + + /* + * Convert the string to a token stream. + */ + macro_start = tokenize(unquote_token_cstr(t)); + + /* + * We now have a macro name, an implicit parameter count of + * zero, and a numeric token to use as an expansion. Create + * and store an SMacro. + */ + define_smacro(mname, casesense, macro_start, NULL); + free_tlist(tline); + break; + + case PP_PATHSEARCH: + { + const char *found_path; + + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = expand_smacro(tline->next); + last->next = NULL; + + t = skip_white(tline); + if (!t || (t->type != TOKEN_STR && + t->type != TOKEN_INTERNAL_STR)) { + nasm_nonfatal("`%s' expects a file name", dname); + free_tlist(tline); + goto done; + } + if (t->next) + nasm_warn(WARN_PP_TRAILING, + "trailing garbage after `%s' ignored", dname); + + p = unquote_token_cstr(t); + + inc_fopen(p, NULL, &found_path, INC_PROBE, NF_BINARY); + if (!found_path) + found_path = p; + macro_start = make_tok_qstr(NULL, found_path); + + /* + * We now have a macro name, an implicit parameter count of + * zero, and a string token to use as an expansion. Create + * and store an SMacro. + */ + define_smacro(mname, casesense, macro_start, NULL); + free_tlist(tline); + break; + } + + case PP_STRLEN: + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = expand_smacro(tline->next); + last->next = NULL; + + t = skip_white(tline); + /* t should now point to the string */ + if (!tok_is(t, TOKEN_STR)) { + nasm_nonfatal("`%s' requires string as second parameter", dname); + free_tlist(tline); + free_tlist(origline); + return DIRECTIVE_FOUND; + } + + unquote_token(t); + macro_start = make_tok_num(NULL, t->len); + + /* + * We now have a macro name, an implicit parameter count of + * zero, and a numeric token to use as an expansion. Create + * and store an SMacro. + */ + define_smacro(mname, casesense, macro_start, NULL); + free_tlist(tline); + free_tlist(origline); + return DIRECTIVE_FOUND; + + case PP_STRCAT: + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = expand_smacro(tline->next); + last->next = NULL; + + macro_start = pp_strcat(tline, dname); + /* + * We now have a macro name, an implicit parameter count of + * zero, and a string token to use as an expansion. Create + * and store an SMacro. + */ + if (macro_start) + define_smacro(mname, casesense, macro_start, NULL); + break; + + case PP_SUBSTR: + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = expand_smacro(tline->next); + last->next = NULL; + + macro_start = pp_substr(tline, dname); + /* + * We now have a macro name, an implicit parameter count of + * zero, and a string token to use as an expansion. Create + * and store an SMacro. + */ + if (macro_start) + define_smacro(mname, casesense, macro_start, NULL); + break; + + case PP_ASSIGN: + if (!(mname = get_id(&tline, dname))) + goto done; + + last = tline; + tline = tline->next; + last->next = NULL; + assign_smacro(mname, casesense, tline, dname); + goto done; + + case PP_ALIASES: + tline = tline->next; + tline = expand_smacro(tline); + ppconf.noaliases = !pp_get_boolean_option(tline, !ppconf.noaliases); + break; + + case PP_LINE: + nasm_panic("`%s' directive not preprocessed early", dname); + break; + + case PP_NULL: + /* Goes nowhere, does nothing... */ + break; + + } + +done: + free_tlist(origline); + return DIRECTIVE_FOUND; +} + +/* + * Ensure that a macro parameter contains a condition code and + * nothing else. Return the condition code index if so, or -1 + * otherwise. + */ +static int find_cc(Token * t) +{ + Token *tt; + + if (!t) + return -1; /* Probably a %+ without a space */ + + t = skip_white(t); + if (!tok_is(t, TOKEN_ID)) + return -1; + tt = t->next; + tt = skip_white(tt); + if (tok_isnt(tt, ',')) + return -1; + + return bsii(tok_text(t), (const char **)conditions, + ARRAY_SIZE(conditions)); +} + +enum concat_flags { + CONCAT_ID = 0x01, + CONCAT_LOCAL_MACRO = 0x02, + CONCAT_ENVIRON = 0x04, + CONCAT_PREPROC_ID = 0x08, + CONCAT_NUM = 0x10, + CONCAT_FLOAT = 0x20, + CONCAT_OP = 0x40 /* Operators */ +}; + +struct concat_mask { + enum concat_flags mask_head; + enum concat_flags mask_tail; +}; + + +static inline bool pp_concat_match(const Token *t, enum concat_flags mask) +{ + enum concat_flags ctype = 0; + + if (!t) + return false; + + switch (t->type) { + case TOKEN_ID: + case TOKEN_QMARK: /* Keyword, treated as ID for pasting */ + ctype = CONCAT_ID; + break; + case TOKEN_LOCAL_MACRO: + ctype = CONCAT_LOCAL_MACRO; + break; + case TOKEN_ENVIRON: + ctype = CONCAT_ENVIRON; + break; + case TOKEN_PREPROC_ID: + ctype = CONCAT_PREPROC_ID; + break; + case TOKEN_NUM: + case TOKEN_FLOAT: + ctype = CONCAT_NUM; + break; + case TOKEN_HERE: + case TOKEN_BASE: + /* NASM 2.15 treats these as operators, but is that sane? */ + ctype = CONCAT_OP; + break; + case TOKEN_OTHER: + ctype = CONCAT_OP; /* For historical reasons */ + break; + default: + if (t->type > TOKEN_WHITESPACE && t->type < TOKEN_MAX_OPERATOR) + ctype = CONCAT_OP; + else + ctype = 0; + } + + return !!(ctype & mask); +} + +/* + * This routines walks over tokens stream and handles tokens + * pasting, if @handle_explicit passed then explicit pasting + * term is handled, otherwise -- implicit pastings only. + * The @m array can contain a series of token types which are + * executed as separate passes. + */ +static bool paste_tokens(Token **head, const struct concat_mask *m, + size_t mnum, bool handle_explicit) +{ + Token *tok, *t, *next, **prev_next, **prev_nonspace, **nextp; + bool pasted = false; + char *buf, *p; + size_t len, i; + + /* + * The last token before pasting. We need it + * to be able to connect new handled tokens. + * In other words if there were a tokens stream + * + * A -> B -> C -> D + * + * and we've joined tokens B and C, the resulting + * stream should be + * + * A -> BC -> D + */ + tok = *head; + prev_next = prev_nonspace = head; + + if (tok_white(tok) || tok_is(tok, TOKEN_PASTE)) + prev_nonspace = NULL; + + while (tok && (next = tok->next)) { + bool did_paste = false; + + switch (tok->type) { + case TOKEN_WHITESPACE: + /* Zap redundant whitespaces */ + tok->next = next = zap_white(next); + break; + + case TOKEN_PASTE: + /* Explicit pasting */ + if (!handle_explicit) + break; + + did_paste = true; + + /* Left pasting token is start of line, just drop %+ */ + if (!prev_nonspace) { + prev_next = nextp = head; + t = NULL; + } else { + prev_next = prev_nonspace; + t = *prev_next; + nextp = &t->next; + } + + /* + * Delete the %+ token itself plus any whitespace. + * In a sequence of %+ ... %+ ... %+ pasting sequences where + * some expansions in the middle have ended up empty, + * we can end up having multiple %+ tokens in a row; + * just drop whem in that case. + */ + next = *nextp; + while (next) { + if (next->type == TOKEN_PASTE || next->type == TOKEN_WHITESPACE) + next = delete_Token(next); + else + break; + } + *nextp = next; + + /* + * Nothing after? Just leave the existing token. + */ + if (!next) + break; + + if (!t) { + /* Nothing to actually paste, just zapping the paste */ + *prev_next = tok = next; + break; + } + + /* An actual paste */ + p = buf = nasm_malloc(t->len + next->len + 1); + p = mempcpy(p, tok_text(t), t->len); + p = mempcpy(p, tok_text(next), next->len); + *p = '\0'; + delete_Token(t); + t = tokenize(buf); + nasm_free(buf); + + if (unlikely(!t)) { + /* + * No output at all? Replace with a single whitespace. + * This should never happen. + */ + tok = t = new_White(NULL); + } else { + *prev_nonspace = tok = t; + } + while (t->next) + t = t->next; /* Find the last token produced */ + + /* Delete the second token and attach to the end of the list */ + t->next = delete_Token(next); + + /* We want to restart from the head of the pasted token */ + *prev_next = next = tok; + break; + + default: + /* implicit pasting */ + for (i = 0; i < mnum; i++) { + if (pp_concat_match(tok, m[i].mask_head)) + break; + } + + if (i >= mnum) + break; + + len = tok->len; + while (pp_concat_match(next, m[i].mask_tail)) { + len += next->len; + next = next->next; + } + + /* No match or no text to process */ + if (len == tok->len) + break; + + p = buf = nasm_malloc(len + 1); + while (tok != next) { + p = mempcpy(p, tok_text(tok), tok->len); + tok = delete_Token(tok); + } + *p = '\0'; + *prev_next = tok = t = tokenize(buf); + nasm_free(buf); + + /* + * Connect pasted into original stream, + * ie A -> new-tokens -> B + */ + while ((tok = t->next)) { + if (tok->type != TOKEN_WHITESPACE && tok->type != TOKEN_PASTE) + prev_nonspace = &t->next; + t = tok; + } + + t->next = next; + prev_next = &t->next; + did_paste = true; + break; + } + + if (did_paste) { + pasted = true; + } else { + prev_next = &tok->next; + if (next && next->type != TOKEN_WHITESPACE && + next->type != TOKEN_PASTE) + prev_nonspace = prev_next; + } + tok = next; + } + + return pasted; +} + +/* + * Computes the proper rotation of mmacro parameters + */ +static int mmac_rotate(const MMacro *mac, unsigned int n) +{ + if (--n < mac->nparam) + n = (n + mac->rotate) % mac->nparam; + + return n+1; +} + +/* + * expands to a list of tokens from %{x:y} + */ +static void expand_mmac_params_range(MMacro *mac, Token *tline, Token ***tail) +{ + Token *t; + const char *arg = tok_text(tline) + 1; + int fst, lst, incr, n; + int parsed; + + parsed = sscanf(arg, "%d:%d", &fst, &lst); + nasm_assert(parsed == 2); + + /* + * only macros params are accounted so + * if someone passes %0 -- we reject such + * value(s) + */ + if (lst == 0 || fst == 0) + goto err; + + /* the values should be sane */ + if ((fst > (int)mac->nparam || fst < (-(int)mac->nparam)) || + (lst > (int)mac->nparam || lst < (-(int)mac->nparam))) + goto err; + + fst = fst < 0 ? fst + (int)mac->nparam + 1: fst; + lst = lst < 0 ? lst + (int)mac->nparam + 1: lst; + + /* + * It will be at least one parameter, as we can loop + * in either direction. + */ + incr = (fst < lst) ? 1 : -1; + + while (true) { + n = mmac_rotate(mac, fst); + dup_tlistn(mac->params[n], mac->paramlen[n], tail); + if (fst == lst) + break; + t = make_tok_char(NULL, ','); + **tail = t; + *tail = &t->next; + fst += incr; + } + + return; + +err: + nasm_nonfatal("`%%{%s}': macro parameters out of range", arg); + return; +} + +/* + * Expand MMacro-local things: parameter references (%0, %n, %+n, + * %-n) and MMacro-local identifiers (%%foo) as well as + * macro indirection (%[...]) and range (%{..:..}). + */ +static Token *expand_mmac_params(Token * tline) +{ + Token **tail, *thead; + bool changed = false; + MMacro *mac = istk->mstk.mmac; + + tail = &thead; + thead = NULL; + + while (tline) { + bool change; + bool err_not_mac = false; + Token *t = tline; + const char *text = tok_text(t); + int type = t->type; + + tline = tline->next; + t->next = NULL; + + switch (type) { + case TOKEN_LOCAL_SYMBOL: + change = true; + + if (!mac) { + err_not_mac = true; + break; + } + + type = TOKEN_ID; + text = nasm_asprintf("..@%"PRIu64".%s", mac->unique, text+2); + break; + case TOKEN_MMACRO_PARAM: + { + Token *tt = NULL; + + change = true; + + if (!mac) { + err_not_mac = true; + break; + } + + if (strchr(text, ':')) { + /* It is a range */ + expand_mmac_params_range(mac, t, &tail); + text = NULL; + break; + } + + switch (text[1]) { + /* + * We have to make a substitution of one of the + * forms %1, %-1, %+1, %%foo, %0, %00. + */ + case '0': + if (!text[2]) { + type = TOKEN_NUM; + text = nasm_asprintf("%d", mac->nparam); + break; + } + if (text[2] != '0' || text[3]) + goto invalid; + /* a possible captured label == mac->params[0] */ + /* fall through */ + default: + { + unsigned long n; + char *ep; + + n = strtoul(text + 1, &ep, 10); + if (unlikely(*ep)) + goto invalid; + + if (n <= mac->nparam) { + n = mmac_rotate(mac, n); + dup_tlistn(mac->params[n], mac->paramlen[n], &tail); + } + text = NULL; + break; + } + case '-': + case '+': + { + int cc; + unsigned long n; + char *ep; + + n = strtoul(tok_text(t) + 2, &ep, 10); + if (unlikely(*ep)) + goto invalid; + + if (n && n <= mac->nparam) { + n = mmac_rotate(mac, n); + tt = mac->params[n]; + } + cc = find_cc(tt); + if (cc == -1) { + nasm_nonfatal("macro parameter `%s' is not a condition code", + tok_text(t)); + text = NULL; + break; + } + + type = TOKEN_ID; + if (text[1] == '-') { + int ncc = inverse_ccs[cc]; + if (unlikely(ncc == -1)) { + nasm_nonfatal("condition code `%s' is not invertible", + conditions[cc]); + break; + } + cc = ncc; + } + text = nasm_strdup(conditions[cc]); + break; + } + + invalid: + nasm_nonfatal("invalid macro parameter: `%s'", text); + text = NULL; + break; + } + break; + } + + case TOKEN_PREPROC_Q: + if (mac) { + type = TOKEN_ID; + text = nasm_strdup(mac->iname); + change = true; + } else { + change = false; + } + break; + + case TOKEN_PREPROC_QQ: + if (mac) { + type = TOKEN_ID; + text = nasm_strdup(mac->name); + change = true; + } else { + change = false; + } + break; + + case TOKEN_INDIRECT: + { + Token *tt; + + tt = tokenize(tok_text(t)); + tt = expand_mmac_params(tt); + tt = expand_smacro(tt); + tail = steal_tlist(tt, tail); + text = NULL; + change = true; + break; + } + + default: + change = false; + break; + } + + if (err_not_mac) { + nasm_nonfatal("`%s': not in a macro call", text); + text = NULL; + change = true; + } + + if (change) { + if (!text) { + delete_Token(t); + } else { + *tail = t; + tail = &t->next; + set_text(t, text, tok_strlen(text)); + t->type = type; + } + changed = true; + } else { + *tail = t; + tail = &t->next; + } + } + + *tail = NULL; + + if (changed) { + const struct concat_mask t[] = { + { + CONCAT_ID | CONCAT_FLOAT, /* head */ + CONCAT_ID | CONCAT_NUM | CONCAT_FLOAT | CONCAT_OP /* tail */ + }, + { + CONCAT_NUM, /* head */ + CONCAT_NUM /* tail */ + } + }; + paste_tokens(&thead, t, ARRAY_SIZE(t), false); + } + + return thead; +} + +static Token *expand_smacro_noreset(Token * tline); + +/* + * Expand *one* single-line macro instance. If the first token is not + * a macro at all, it is simply copied to the output and the pointer + * advanced. tpp should be a pointer to a pointer (usually the next + * pointer of the previous token) to the first token. **tpp is updated + * to point to the first token of the expansion, and *tpp updated to + * point to the next pointer of the last token of the expansion. + * + * If the expansion is empty, *tpp will be unchanged but **tpp will + * be advanced past the macro call. + * + * Return the macro expanded, or NULL if no expansion took place. + */ +static SMacro *expand_one_smacro(Token ***tpp) +{ + Token **params = NULL; + const char *mname, *mtype; + Token *mstart = **tpp; + Token *tline = mstart; + SMacro *head, *m; + int i; + Token *t, *tup, *tafter; + int nparam = 0; + bool cond_comma; + + if (!tline) + return false; /* Empty line, nothing to do */ + + mname = tok_text(mstart); + + smacro_deadman.total--; + smacro_deadman.levels--; + + if (unlikely(smacro_deadman.total < 0 || smacro_deadman.levels < 0)) { + if (unlikely(!smacro_deadman.triggered)) { + nasm_nonfatal("interminable macro recursion"); + smacro_deadman.triggered = true; + } + goto not_a_macro; + } else if (tline->type == TOKEN_ID || tline->type == TOKEN_PREPROC_ID) { + head = (SMacro *)hash_findix(&smacros, mname); + } else if (tline->type == TOKEN_LOCAL_MACRO) { + Context *ctx = get_ctx(mname, &mname); + head = ctx ? (SMacro *)hash_findix(&ctx->localmac, mname) : NULL; + } else { + goto not_a_macro; + } + + /* + * We've hit an identifier of some sort. First check whether the + * identifier is a single-line macro at all, then think about + * checking for parameters if necessary. + */ + list_for_each(m, head) { + if (unlikely(m->alias && ppconf.noaliases)) + continue; + if (!mstrcmp(m->name, mname, m->casesense)) + break; + } + + if (!m) { + goto not_a_macro; + } + + /* Parse parameters, if applicable */ + + params = NULL; + nparam = 0; + + if (m->nparam == 0) { + /* + * Simple case: the macro is parameterless. + * Nothing to parse; the expansion code will + * drop the macro name token. + */ + } else { + /* + * Complicated case: at least one macro with this name + * exists and takes parameters. We must find the + * parameters in the call, count them, find the SMacro + * that corresponds to that form of the macro call, and + * substitute for the parameters when we expand. What a + * pain. + */ + Token *t; + int paren, brackets; + + tline = tline->next; + tline = skip_white(tline); + if (!tok_is(tline, '(')) { + /* + * This macro wasn't called with parameters: ignore + * the call. (Behaviour borrowed from gnu cpp.) + */ + goto not_a_macro; + } + + paren = 1; + nparam = 1; + brackets = 0; + t = tline; /* tline points to leading ( */ + + while (paren) { + t = t->next; + + if (!t) { + nasm_nonfatal("macro call expects terminating `)'"); + goto not_a_macro; + } + + switch (t->type) { + case ',': + if (!brackets && paren == 1) + nparam++; + break; + + case '{': + brackets++; + break; + + case '}': + if (brackets > 0) + brackets--; + break; + + case '(': + if (!brackets) + paren++; + break; + + case ')': + if (!brackets) + paren--; + break; + + default: + break; /* Normal token */ + } + } + + /* + * Look for a macro matching in both name and parameter count. + * We already know any matches cannot be anywhere before the + * current position of "m", so there is no reason to + * backtrack. + */ + while (1) { + if (!m) { + /*! + *!pp-macro-params-single [on] single-line macro calls with wrong parameter count + *!=macro-params-single + *! warns about \i{single-line macros} being invoked + *! with the wrong number of parameters. + */ + nasm_warn(WARN_PP_MACRO_PARAMS_SINGLE|ERR_HOLD, + "single-line macro `%s' exists, " + "but not taking %d parameter%s", + mname, nparam, (nparam == 1) ? "" : "s"); + goto not_a_macro; + } + + if (!mstrcmp(m->name, mname, m->casesense)) { + if (nparam >= m->nparam_min && + (m->varadic || nparam <= m->nparam)) + break; /* It's good */ + } + m = m->next; + } + } + + if (m->in_progress && !m->recursive) + goto not_a_macro; + + /* Expand the macro */ + m->in_progress++; + + /* Is it a macro or a preprocessor function? Used for diagnostics. */ + mtype = m->name[0] == '%' ? "function" : "macro"; + + if (nparam) { + /* Extract parameters */ + Token **phead, **pep; + int white = 0; + int brackets = 0; + int paren; + bool bracketed = false; + bool bad_bracket = false; + enum sparmflags flags; + const struct smac_param *mparm; + + if (nparam > m->nparam) { + if (m->params[m->nparam-1].flags & SPARM_GREEDY) + nparam = m->nparam; + } else if (nparam < m->nparam) { + nparam = m->nparam; /* Missing optional arguments = empty */ + } + paren = 1; + nasm_newn(params, nparam); + i = 0; + mparm = m->params; + flags = mparm->flags; + phead = pep = ¶ms[i]; + *pep = NULL; + + while (paren) { + bool skip; + + tline = tline->next; + + if (!tline) + nasm_nonfatal("%s `%s' call expects terminating `)'", + mtype, m->name); + + skip = false; + + switch (tline->type) { + case TOKEN_WHITESPACE: + if (!(flags & SPARM_NOSTRIP)) { + if (brackets || *phead) + white++; /* Keep interior whitespace */ + skip = true; + } + break; + + case ',': + if (!brackets && paren == 1 && !(flags & SPARM_GREEDY)) { + i++; + nasm_assert(i < nparam); + phead = pep = ¶ms[i]; + *pep = NULL; + bracketed = false; + skip = true; + if (!(flags & SPARM_VARADIC)) { + mparm++; + flags = mparm->flags; + } + } + break; + + case '{': + if (!bracketed) { + bracketed = !*phead && !(flags & SPARM_NOSTRIP); + skip = bracketed; + } + brackets++; + break; + + case '}': + if (brackets > 0) { + if (!--brackets) + skip = bracketed; + } + break; + + case '(': + if (!brackets) + paren++; + break; + + case ')': + if (!brackets) { + paren--; + if (!paren) { + skip = true; + i++; /* Found last argument */ + } + } + break; + + default: + break; /* Normal token */ + } + + if (!skip) { + Token *t; + + bad_bracket |= bracketed && !brackets; + + if (white) { + *pep = t = new_White(NULL); + pep = &t->next; + white = 0; + } + *pep = t = dup_Token(NULL, tline); + pep = &t->next; + } + } + + /* + * Possible further processing of parameters. Note that the + * ordering matters here. + * + * mparm points to the current parameter specification + * structure (struct smac_param); this may not match the index + * i in the case of varadic parameters. + */ + for (i = 0, mparm = m->params; + i < nparam; + i++, mparm += !(flags & SPARM_VARADIC)) { + const enum sparmflags flags = mparm->flags; + + if (flags & SPARM_EVAL) { + /* Evaluate this parameter as a number */ + struct ppscan pps; + struct tokenval tokval; + expr *evalresult; + Token *eval_param; + + eval_param = zap_white(expand_smacro_noreset(params[i])); + params[i] = NULL; + + if (!eval_param) { + /* empty argument */ + if (mparm->def) { + params[i] = dup_tlist(mparm->def, NULL); + continue; + } else if (flags & SPARM_OPTIONAL) { + continue; + } + /* otherwise, allow evaluate() to generate an error */ + } + + pps.tptr = eval_param; + pps.ntokens = -1; + tokval.t_type = TOKEN_INVALID; + evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); + + free_tlist(eval_param); + + if (!evalresult) { + /* Nothing meaningful to do */ + } else if (tokval.t_type) { + nasm_nonfatal("invalid expression in parameter %d of %s `%s'", + i, mtype, m->name); + } else if (!is_simple(evalresult)) { + nasm_nonfatal("non-constant expression in parameter %d of %s `%s'", + i, mtype, m->name); + } else { + params[i] = make_tok_num(NULL, reloc_value(evalresult)); + } + } + + if (flags & SPARM_STR) { + /* Convert expansion to a quoted string */ + Token *qs; + + qs = expand_smacro_noreset(params[i]); + if ((flags & SPARM_CONDQUOTE) && + tok_is(qs, TOKEN_STR) && !qs->next) { + /* A single quoted string token */ + params[i] = qs; + } else { + char *arg = detoken(qs, false); + free_tlist(qs); + params[i] = make_tok_qstr(NULL, arg); + nasm_free(arg); + } + } + } + } + + /* Note: we own the expansion this returns. */ + t = m->expand(m, params, nparam); + + tafter = tline->next; /* Skip past the macro call */ + tline->next = NULL; /* Truncate list at the macro call end */ + tline = tafter; + + tup = NULL; + cond_comma = false; + + while (t) { + enum token_type type = t->type; + Token *tnext = t->next; + + switch (type) { + case TOKEN_PREPROC_Q: + case TOKEN_PREPROC_SQ: + delete_Token(t); + t = dup_Token(tline, mstart); + break; + + case TOKEN_PREPROC_QQ: + case TOKEN_PREPROC_SQQ: + { + size_t mlen = strlen(m->name); + size_t len; + char *p, *from; + + t->type = mstart->type; + if (t->type == TOKEN_LOCAL_MACRO) { + const char *psp; /* prefix start pointer */ + const char *pep; /* prefix end pointer */ + size_t plen; + + psp = tok_text(mstart); + get_ctx(psp, &pep); + plen = pep - psp; + + len = mlen + plen; + from = p = nasm_malloc(len + 1); + p = mempcpy(p, psp, plen); + } else { + len = mlen; + from = p = nasm_malloc(len + 1); + } + p = mempcpy(p, m->name, mlen); + *p = '\0'; + set_text_free(t, from, len); + + t->next = tline; + break; + } + + case TOKEN_COND_COMMA: + delete_Token(t); + t = cond_comma ? make_tok_char(tline, ',') : NULL; + break; + + case TOKEN_ID: + case TOKEN_PREPROC_ID: + case TOKEN_LOCAL_MACRO: + { + /* + * Chain this into the target line *before* expanding, + * that way we pick up any arguments to the new macro call, + * if applicable. + */ + Token **tp = &t; + t->next = tline; + expand_one_smacro(&tp); + tline = *tp; /* First token left after any macro call */ + break; + } + default: + if (is_smac_param(t->type)) { + int param = smac_nparam(t->type); + nasm_assert(!tup && param < nparam); + delete_Token(t); + t = NULL; + tup = tnext; + tnext = dup_tlist_reverse(params[param], NULL); + cond_comma = false; + } else { + t->next = tline; + } + } + + if (t) { + Token *endt = tline; + + tline = t; + while (!cond_comma && t && t != endt) { + cond_comma = t->type != TOKEN_WHITESPACE; + t = t->next; + } + } + + if (tnext) { + t = tnext; + } else { + t = tup; + tup = NULL; + } + } + + **tpp = tline; + for (t = tline; t && t != tafter; t = t->next) + *tpp = &t->next; + + /* Expansion complete */ + m->in_progress--; + + /* Don't do this until after expansion or we will clobber mname */ + free_tlist(mstart); + goto done; + + /* + * No macro expansion needed; roll back to mstart (if necessary) + * and then advance to the next input token. Note that this is + * by far the common case! + */ +not_a_macro: + *tpp = &mstart->next; + m = NULL; +done: + smacro_deadman.levels++; + free_tlist_array(params, nparam); + return m; +} + +/* + * Expand all single-line macro calls made in the given line. + * Return the expanded version of the line. The original is deemed + * to be destroyed in the process. (In reality we'll just move + * Tokens from input to output a lot of the time, rather than + * actually bothering to destroy and replicate.) + */ +static Token *expand_smacro(Token *tline) +{ + smacro_deadman.total = nasm_limit[LIMIT_MACRO_TOKENS]; + smacro_deadman.levels = nasm_limit[LIMIT_MACRO_LEVELS]; + smacro_deadman.triggered = false; + return expand_smacro_noreset(tline); +} + +static Token *expand_smacro_noreset(Token *org_tline) +{ + Token *tline; + bool expanded; + errhold errhold; /* Hold warning/errors during expansion */ + + if (!org_tline) + return NULL; /* Empty input */ + + /* + * Trick: we should avoid changing the start token pointer since it can + * be contained in "next" field of other token. Because of this + * we allocate a copy of first token and work with it; at the end of + * routine we copy it back + */ + tline = dup_Token(org_tline->next, org_tline); + + /* + * Pretend that we always end up doing expansion on the first pass; + * that way %+ get processed. However, if we process %+ before the + * first pass, we end up with things like MACRO %+ TAIL trying to + * look up the macro "MACROTAIL", which we don't want. + */ + expanded = true; + + while (true) { + static const struct concat_mask tmatch[] = { + { + CONCAT_ID | CONCAT_LOCAL_MACRO | + CONCAT_ENVIRON | CONCAT_PREPROC_ID, /* head */ + CONCAT_ID | CONCAT_LOCAL_MACRO | + CONCAT_ENVIRON | CONCAT_PREPROC_ID | + CONCAT_NUM /* tail */ + } + }; + Token **tail = &tline; + + /* + * We hold warnings/errors until we are done in this loop. It is + * possible for nuisance warnings to appear that disappear on later + * passes. + */ + errhold = nasm_error_hold_push(); + + while (*tail) /* main token loop */ + expanded |= !!expand_one_smacro(&tail); + + if (!expanded) + break; /* Done! */ + + /* + * Now scan the entire line and look for successive TOKEN_IDs + * that resulted after expansion (they can't be produced by + * tokenize()). The successive TOKEN_IDs should be concatenated. + * Also we look for %+ tokens and concatenate the tokens + * before and after them (without white spaces in between). + */ + if (!paste_tokens(&tline, tmatch, ARRAY_SIZE(tmatch), true)) + break; /* Done again! */ + + nasm_error_hold_pop(errhold, false); + expanded = false; + } + nasm_error_hold_pop(errhold, true); + + if (!tline) { + /* + * The expression expanded to empty line; + * we can't return NULL because of the "trick" above. + * Just set the line to a single WHITESPACE token. + */ + + tline = new_White(NULL); + } + + steal_Token(org_tline, tline); + org_tline->next = tline->next; + delete_Token(tline); + + return org_tline; +} + +/* + * Similar to expand_smacro but used exclusively with macro identifiers + * right before they are fetched in. The reason is that there can be + * identifiers consisting of several subparts. We consider that if there + * are more than one element forming the name, user wants a expansion, + * otherwise it will be left as-is. Example: + * + * %define %$abc cde + * + * the identifier %$abc will be left as-is so that the handler for %define + * will suck it and define the corresponding value. Other case: + * + * %define _%$abc cde + * + * In this case user wants name to be expanded *before* %define starts + * working, so we'll expand %$abc into something (if it has a value; + * otherwise it will be left as-is) then concatenate all successive + * PP_IDs into one. + */ +static Token *expand_id(Token * tline) +{ + Token *cur, *oldnext = NULL; + + if (!tline || !tline->next) + return tline; + + cur = tline; + while (cur->next && + (cur->next->type == TOKEN_ID || + cur->next->type == TOKEN_PREPROC_ID || + cur->next->type == TOKEN_LOCAL_MACRO || + cur->next->type == TOKEN_NUM)) + cur = cur->next; + + /* If identifier consists of just one token, don't expand */ + if (cur == tline) + return tline; + + if (cur) { + oldnext = cur->next; /* Detach the tail past identifier */ + cur->next = NULL; /* so that expand_smacro stops here */ + } + + tline = expand_smacro(tline); + + if (cur) { + /* expand_smacro possibly changhed tline; re-scan for EOL */ + cur = tline; + while (cur && cur->next) + cur = cur->next; + if (cur) + cur->next = oldnext; + } + + return tline; +} + +/* + * This is called from find_mmacro_in_list() after finding a suitable macro. + */ +static MMacro *use_mmacro(MMacro *m, int *nparamp, Token ***paramsp) +{ + int nparam = *nparamp; + Token **params = *paramsp; + + /* + * This one is right. Just check if cycle removal + * prohibits us using it before we actually celebrate... + */ + if (m->in_progress > m->max_depth) { + if (m->max_depth > 0) { + /* Document this properly when recursive mmacros re-implemented */ + nasm_warn(WARN_OTHER, "reached maximum recursion depth of %i", + m->max_depth); + } + nasm_free(params); + *nparamp = 0; + *paramsp = NULL; + return NULL; + } + + /* + * It's right, and we can use it. Add its default + * parameters to the end of our list if necessary. + */ + if (m->defaults && nparam < m->nparam_min + m->ndefs) { + int newnparam = m->nparam_min + m->ndefs; + params = nasm_realloc(params, sizeof(*params) * (newnparam+2)); + memcpy(¶ms[nparam+1], &m->defaults[nparam+1-m->nparam_min], + (newnparam - nparam) * sizeof(*params)); + nparam = newnparam; + } + /* + * If we've gone over the maximum parameter count (and + * we're in Plus mode), ignore parameters beyond + * nparam_max. + */ + if (m->plus && nparam > m->nparam_max) + nparam = m->nparam_max; + + /* + * If nparam was adjusted above, make sure the list is still + * NULL-terminated. + */ + params[nparam+1] = NULL; + + /* Done! */ + *paramsp = params; + *nparamp = nparam; + return m; +} + +/* + * Search a macro list and try to find a match. If matching, call + * use_mmacro() to set up the macro call. m points to the list of + * search, which is_mmacro() sets to the first *possible* match. + */ +static MMacro * +find_mmacro_in_list(MMacro *m, const char *finding, + int *nparamp, Token ***paramsp) +{ + int nparam = *nparamp; + + while (m) { + if (m->nparam_min <= nparam + && (m->plus || nparam <= m->nparam_max)) { + /* + * This one matches, use it. + */ + return use_mmacro(m, nparamp, paramsp); + } + + /* + * Otherwise search for the next one with a name match. + */ + list_for_each(m, m->next) { + if (!mstrcmp(m->name, finding, m->casesense)) + break; + } + } + + return NULL; +} + +/* + * Determine whether the given line constitutes a multi-line macro + * call, and return the MMacro structure called if so. Doesn't have + * to check for an initial label - that's taken care of in + * expand_mmacro - but must check numbers of parameters. Guaranteed + * to be called with tline->type == TOKEN_ID, so the putative macro + * name is easy to find. + */ +static MMacro *is_mmacro(Token * tline, int *nparamp, Token ***paramsp) +{ + MMacro *head, *m, *found; + Token **params, **comma; + int raw_nparam, nparam; + const char *finding = tok_text(tline); + bool empty_args = !tline->next; + + *nparamp = 0; + *paramsp = NULL; + + head = (MMacro *) hash_findix(&mmacros, finding); + + /* + * Efficiency: first we see if any macro exists with the given + * name which isn't already excluded by macro cycle removal. + * (The cycle removal test here helps optimize the case of wrapping + * instructions, and is cheap to do here.) + * + * If not, we can return NULL immediately. _Then_ we + * count the parameters, and then we look further along the + * list if necessary to find the proper MMacro. + */ + list_for_each(m, head) { + if (!mstrcmp(m->name, finding, m->casesense) && + (m->in_progress != 1 || m->max_depth > 0)) + break; /* Found something that needs consideration */ + } + if (!m) + return NULL; + + /* + * OK, we have a potential macro. Count and demarcate the + * parameters. + */ + comma = count_mmac_params(tline->next, nparamp, paramsp); + raw_nparam = *nparamp; + + /* + * Search for an exact match. This cannot come *before* the m + * found in the list search before, so we can start there. + * + * If found is NULL and *paramsp has been cleared, then we + * encountered an error for which we have already issued a + * diagnostic, so we should not proceed. + */ + found = find_mmacro_in_list(m, finding, nparamp, paramsp); + if (!*paramsp) + return NULL; + + nparam = *nparamp; + params = *paramsp; + + /* + * Special weirdness: in NASM < 2.15, an expansion of + * *only* whitespace, as can happen during macro expansion under + * certain circumstances, is counted as zero arguments for the + * purpose of %0, but one argument for the purpose of macro + * matching! In particular, this affects: + * + * foobar %1 + * + * ... with %1 being empty; this would call the one-argument + * version of "foobar" with an empty argument, equivalent to + * + * foobar {%1} + * + * ... except that %0 would be set to 0 inside foobar, even if + * foobar is declared with "%macro foobar 1" or equivalent! + * + * The proper way to do that is to define "%macro foobar 0-1". + * + * To be compatible without doing something too stupid, try to + * match a zero-argument macro first, but if that fails, try + * for a one-argument macro with the above behavior. + * + * Furthermore, NASM < 2.15 will match stripping a tailing empty + * argument, but in that case %0 *does* reflect that this argument + * have been stripped; this is handled in count_mmac_params(). + * + * To disable these insane legacy behaviors, use: + * + * %pragma preproc sane_empty_expansion yes + * + *!pp-macro-params-legacy [on] improperly calling multi-line macro for legacy support + *!=macro-params-legacy + *! warns about \i{multi-line macros} being invoked + *! with the wrong number of parameters, but for bug-compatibility + *! with NASM versions older than 2.15, NASM tried to fix up the + *! parameters to match the legacy behavior and call the macro anyway. + *! This can happen in certain cases where there are empty arguments + *! without braces, sometimes as a result of macro expansion. + *!- + *! The legacy behavior is quite strange and highly context-dependent, + *! and can be disabled with: + *!- + *! \c %pragma preproc sane_empty_expansion true + *!- + *! It is highly recommended to use this option in new code. + */ + if (!ppconf.sane_empty_expansion) { + if (!found) { + if (raw_nparam == 0 && !empty_args) { + /* + * A single all-whitespace parameter as the only thing? + * Look for a one-argument macro, but don't adjust + * *nparamp. + */ + int bogus_nparam = 1; + params[2] = NULL; + found = find_mmacro_in_list(m, finding, &bogus_nparam, paramsp); + } else if (raw_nparam > 1 && comma) { + Token *comma_tail = *comma; + + /* + * Drop the terminal argument and try again. + * If we fail, we need to restore the comma to + * preserve tlist. + */ + *comma = NULL; + *nparamp = raw_nparam - 1; + found = find_mmacro_in_list(m, finding, nparamp, paramsp); + if (found) + free_tlist(comma_tail); + else + *comma = comma_tail; + } + + if (!*paramsp) + return NULL; + } else if (comma) { + free_tlist(*comma); + *comma = NULL; + if (raw_nparam > found->nparam_min && + raw_nparam <= found->nparam_min + found->ndefs) { + /* Replace empty argument with default parameter */ + params[raw_nparam] = + found->defaults[raw_nparam - found->nparam_min]; + } else if (raw_nparam > found->nparam_max && found->plus) { + /* Just drop the comma, don't adjust argument count */ + } else { + /* Drop argument. This may cause nparam < nparam_min. */ + params[raw_nparam] = NULL; + *nparamp = nparam = raw_nparam - 1; + } + } + + if (found) { + if (raw_nparam < found->nparam_min || + (raw_nparam > found->nparam_max && !found->plus)) { + nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY, + "improperly calling multi-line macro `%s' with %d parameters", + found->name, raw_nparam); + } else if (comma) { + nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY, + "dropping trailing empty parameter in call to multi-line macro `%s'", found->name); + } + } + } + + /* + * After all that, we didn't find one with the right number of + * parameters. Issue a warning, and fail to expand the macro. + *! + *!pp-macro-params-multi [on] multi-line macro calls with wrong parameter count + *!=macro-params-multi + *! warns about \i{multi-line macros} being invoked + *! with the wrong number of parameters. See \k{mlmacover} for an + *! example of why you might want to disable this warning. + */ + if (found) + return found; + + nasm_warn(WARN_PP_MACRO_PARAMS_MULTI, + "multi-line macro `%s' exists, but not taking %d parameter%s", + finding, nparam, (nparam == 1) ? "" : "s"); + nasm_free(*paramsp); + return NULL; +} + + +#if 0 + +/* + * Save MMacro invocation specific fields in + * preparation for a recursive macro expansion + */ +static void push_mmacro(MMacro *m) +{ + MMacroInvocation *i; + + i = nasm_malloc(sizeof(MMacroInvocation)); + i->prev = m->prev; + i->params = m->params; + i->iline = m->iline; + i->nparam = m->nparam; + i->rotate = m->rotate; + i->paramlen = m->paramlen; + i->unique = m->unique; + i->condcnt = m->condcnt; + m->prev = i; +} + + +/* + * Restore MMacro invocation specific fields that were + * saved during a previous recursive macro expansion + */ +static void pop_mmacro(MMacro *m) +{ + MMacroInvocation *i; + + if (m->prev) { + i = m->prev; + m->prev = i->prev; + m->params = i->params; + m->iline = i->iline; + m->nparam = i->nparam; + m->rotate = i->rotate; + m->paramlen = i->paramlen; + m->unique = i->unique; + m->condcnt = i->condcnt; + nasm_free(i); + } +} + +#endif + +/* + * List an mmacro call with arguments (-Lm option) + */ +static void list_mmacro_call(const MMacro *m) +{ + const char prefix[] = " ;;; [macro] "; + size_t namelen, size; + char *buf, *p; + unsigned int i; + const Token *t; + + namelen = strlen(m->iname); + size = namelen + sizeof(prefix); /* Includes final null (from prefix) */ + + for (i = 1; i <= m->nparam; i++) { + int j = 0; + size += 3; /* Braces and space/comma */ + list_for_each(t, m->params[i]) { + if (j++ >= m->paramlen[i]) + break; + size += (t->type == TOKEN_WHITESPACE) ? 1 : t->len; + } + } + + buf = p = nasm_malloc(size); + p = mempcpy(p, prefix, sizeof(prefix) - 1); + p = mempcpy(p, m->iname, namelen); + *p++ = ' '; + + for (i = 1; i <= m->nparam; i++) { + int j = 0; + *p++ = '{'; + list_for_each(t, m->params[i]) { + if (j++ >= m->paramlen[i]) + break; + p = mempcpy(p, tok_text(t), t->len); + } + *p++ = '}'; + *p++ = ','; + } + + *--p = '\0'; /* Replace last delimiter with null */ + lfmt->line(LIST_MACRO, -1, buf); + nasm_free(buf); +} + +/* + * Collect information about macro invocations for the benefit of + * the debugger. During execution we create a reverse list; before + * calling the backend reverse it to definition/invocation order just + * to be nicer. [XXX: not implemented yet] + */ +struct debug_macro_inv *debug_current_macro; + +/* Get/create a addr structure for a seg:inv combo */ +static struct debug_macro_addr * +debug_macro_get_addr_inv(int32_t seg, struct debug_macro_inv *inv) +{ + struct debug_macro_addr *addr; + nasm_static_assert(offsetof(struct debug_macro_addr, tree) == 0); + + if (likely(seg == inv->lastseg)) + return inv->addr.last; + + inv->lastseg = seg; + addr = (struct debug_macro_addr *) + rb_search_exact(inv->addr.tree, seg); + if (unlikely(!addr)) { + nasm_new(addr); + addr->tree.key = seg; + inv->addr.tree = rb_insert(inv->addr.tree, &addr->tree); + inv->naddr++; + if (inv->up) + addr->up = debug_macro_get_addr_inv(seg, inv->up); + } + + return inv->addr.last = addr; +} + +/* Get/create an addr structure for a seg in debug_current_macro */ +struct debug_macro_addr *debug_macro_get_addr(int32_t seg) +{ + return debug_macro_get_addr_inv(seg, debug_current_macro); +} + +static struct debug_macro_info dmi; +static struct debug_macro_inv_list *current_inv_list = &dmi.inv; + +static void debug_macro_start(MMacro *m, struct src_location where) +{ + struct debug_macro_def *def = m->dbg.def; + struct debug_macro_inv *inv; + + nasm_assert(!m->dbg.inv); + + /* First invocation? Need to create a def structure */ + if (unlikely(!def)) { + nasm_new(def); + def->name = nasm_strdup(m->name); + def->where = m->where; + + def->next = dmi.def.l; + dmi.def.l = def; + dmi.def.n++; + + m->dbg.def = def; + } + + nasm_new(inv); + inv->lastseg = NO_SEG; + inv->where = where; + inv->up = debug_current_macro; + inv->next = current_inv_list->l; + inv->def = def; + current_inv_list->l = inv; + current_inv_list->n++; + current_inv_list = &inv->down; + + def->ninv++; + m->dbg.inv = inv; + debug_current_macro = inv; +} + +static void debug_macro_end(MMacro *m) +{ + struct debug_macro_inv *inv = m->dbg.inv; + + nasm_assert(inv == debug_current_macro); + + list_reverse(inv->down.l); + + m->dbg.inv = NULL; + inv = inv->up; + + m = istk->mstk.mmac; + if (m) { + nasm_assert(inv == m->dbg.inv); + debug_current_macro = inv; + current_inv_list = &inv->down; + } else { + nasm_assert(!inv); + debug_current_macro = NULL; + current_inv_list = &dmi.inv; + } +} + +static void free_debug_macro_addr_tree(struct rbtree *tree) +{ + struct rbtree *left, *right; + nasm_static_assert(offsetof(struct debug_macro_addr,tree) == 0); + + if (!tree) + return; + + left = rb_left(tree); + right = rb_right(tree); + + nasm_free(tree); + + free_debug_macro_addr_tree(left); + free_debug_macro_addr_tree(right); +} + +static void free_debug_macro_inv_list(struct debug_macro_inv *inv) +{ + struct debug_macro_inv *itmp; + + if (!inv) + return; + + list_for_each_safe(inv, itmp, inv) { + free_debug_macro_inv_list(inv->down.l); + free_debug_macro_addr_tree(inv->addr.tree); + nasm_free(inv); + } +} + +static void free_debug_macro_info(void) +{ + struct debug_macro_def *def, *dtmp; + + list_for_each_safe(def, dtmp, dmi.def.l) + nasm_free(def); + + free_debug_macro_inv_list(dmi.inv.l); + + nasm_zero(dmi); +} + +static void debug_macro_output(void) +{ + list_reverse(dmi.inv.l); + dfmt->debug_mmacros(&dmi); + free_debug_macro_info(); +} + +/* + * Expand the multi-line macro call made by the given line, if + * there is one to be expanded. If there is, push the expansion on + * istk->expansion and return 1. Otherwise return 0. + */ +static int expand_mmacro(Token * tline) +{ + Token *startline = tline; + Token *label = NULL; + bool dont_prepend = false; + Token **params, *t, *tt; + MMacro *m; + Line *l, *ll; + int i, *paramlen; + const char *mname; + int nparam = 0; + + t = tline; + t = skip_white(t); + if (!tok_is(t, TOKEN_ID) && !tok_is(t, TOKEN_LOCAL_MACRO)) + return 0; + m = is_mmacro(t, &nparam, ¶ms); + if (m) { + mname = tok_text(t); + } else { + Token *last; + /* + * We have an id which isn't a macro call. We'll assume + * it might be a label; we'll also check to see if a + * colon follows it. Then, if there's another id after + * that lot, we'll check it again for macro-hood. + */ + label = last = t; + t = t->next; + if (tok_white(t)) + last = t, t = t->next; + if (tok_is(t, ':')) { + dont_prepend = true; + last = t, t = t->next; + if (tok_white(t)) + last = t, t = t->next; + } + if (!tok_is(t, TOKEN_ID) || !(m = is_mmacro(t, &nparam, ¶ms))) + return 0; + last->next = NULL; + mname = tok_text(t); + tline = t; + } + + if (unlikely(mmacro_deadman.total >= nasm_limit[LIMIT_MMACROS] || + mmacro_deadman.levels >= nasm_limit[LIMIT_MACRO_LEVELS])) { + if (!mmacro_deadman.triggered) { + nasm_nonfatal("interminable multiline macro recursion"); + mmacro_deadman.triggered = true; + } + return 0; + } + + mmacro_deadman.total++; + mmacro_deadman.levels++; + + /* + * Fix up the parameters: this involves stripping leading and + * trailing whitespace and stripping braces if they are present. + */ + nasm_newn(paramlen, nparam+1); + + for (i = 1; (t = params[i]); i++) { + bool braced = false; + int brace = 0; + int white = 0; + bool comma = !m->plus || i < nparam; + + t = skip_white(t); + if (tok_is(t, '{')) { + t = t->next; + brace = 1; + braced = true; + comma = false; + } + + params[i] = t; + for (; t; t = t->next) { + if (tok_white(t)) { + white++; + continue; + } + + switch(t->type) { + case ',': + if (comma && !brace) + goto endparam; + break; + + case '{': + brace++; + break; + + case '}': + brace--; + if (braced && !brace) { + paramlen[i] += white; + goto endparam; + } + break; + + default: + break; + } + + paramlen[i] += white + 1; + white = 0; + } + endparam: + ; + } + + /* + * OK, we have a MMacro structure together with a set of + * parameters. We must now go through the expansion and push + * copies of each Line on to istk->expansion. Substitution of + * parameter tokens and macro-local tokens doesn't get done + * until the single-line macro substitution process; this is + * because delaying them allows us to change the semantics + * later through %rotate and give the right semantics for + * nested mmacros. + * + * First, push an end marker on to istk->expansion, mark this + * macro as in progress, and set up its invocation-specific + * variables. + */ + nasm_new(ll); + ll->next = istk->expansion; + ll->finishes = m; + ll->where = istk->where; + istk->expansion = ll; + + /* + * Save the previous MMacro expansion in the case of + * macro recursion + */ +#if 0 + if (m->max_depth && m->in_progress) + push_mmacro(m); +#endif + + m->in_progress ++; + m->params = params; + m->iline = tline; + m->iname = nasm_strdup(mname); + m->nparam = nparam; + m->rotate = 0; + m->paramlen = paramlen; + m->unique = unique++; + m->condcnt = 0; + + m->mstk = istk->mstk; + istk->mstk.mstk = istk->mstk.mmac = m; + + list_for_each(l, m->expansion) { + nasm_new(ll); + ll->next = istk->expansion; + istk->expansion = ll; + ll->first = dup_tlist(l->first, NULL); + ll->where = l->where; + } + + /* + * If we had a label, and this macro definition does not include + * a %00, push it on as the first line of, ot + * the macro expansion. + */ + if (label) { + /* + * We had a label. If this macro contains an %00 parameter, + * save the value as a special parameter (which is what it + * is), otherwise push it as the first line of the macro + * expansion. + */ + if (m->capture_label) { + params[0] = dup_Token(NULL, label); + paramlen[0] = 1; + free_tlist(startline); + } else { + nasm_new(ll); + ll->finishes = NULL; + ll->next = istk->expansion; + istk->expansion = ll; + ll->first = startline; + ll->where = istk->where; + if (!dont_prepend) { + while (label->next) + label = label->next; + label->next = tt = make_tok_char(NULL, ':'); + } + } + } + + istk->nolist += !!(m->nolist & NL_LIST); + istk->noline += !!(m->nolist & NL_LINE); + + if (!istk->nolist) { + if (list_option('m')) + list_mmacro_call(m); + + lfmt->uplevel(LIST_MACRO, 0); + + if (ppdbg & PDBG_MMACROS) + debug_macro_start(m, src_where()); + } + + if (!istk->noline) + src_macro_push(m, istk->where); + + return 1; +} + +/* + * This function decides if an error message should be suppressed. + * It will never be called with a severity level of ERR_FATAL or + * higher. + */ +bool pp_suppress_error(errflags severity) +{ + /* + * If we're in a dead branch of IF or something like it, ignore the error. + * However, because %else etc are evaluated in the state context + * of the previous branch, errors might get lost: + * %if 0 ... %else trailing garbage ... %endif + * So %else etc should set the ERR_PP_PRECOND flag. + */ + if (istk && istk->conds && + ((severity & ERR_PP_PRECOND) ? + istk->conds->state == COND_NEVER : + !emitting(istk->conds->state))) + return true; + + return false; +} + +static Token * +stdmac_file(const SMacro *s, Token **params, int nparams) +{ + const char *fname = src_get_fname(); + + (void)s; + (void)params; + (void)nparams; + + return fname ? make_tok_qstr(NULL, fname) : NULL; +} + +static Token * +stdmac_line(const SMacro *s, Token **params, int nparams) +{ + (void)s; + (void)params; + (void)nparams; + + return make_tok_num(NULL, src_get_linnum()); +} + +static Token * +stdmac_bits(const SMacro *s, Token **params, int nparams) +{ + (void)s; + (void)params; + (void)nparams; + + return make_tok_num(NULL, globalbits); +} + +static Token * +stdmac_ptr(const SMacro *s, Token **params, int nparams) +{ + (void)s; + (void)params; + (void)nparams; + + switch (globalbits) { + case 16: + return new_Token(NULL, TOKEN_ID, "word", 4); + case 32: + return new_Token(NULL, TOKEN_ID, "dword", 5); + case 64: + return new_Token(NULL, TOKEN_ID, "qword", 5); + default: + panic(); + } +} + +/* %is...() function macros */ +static Token * +stdmac_is(const SMacro *s, Token **params, int nparams) +{ + int retval; + struct Token *pline = params[0]; + + (void)nparams; + + params[0] = NULL; /* Don't free this later */ + + retval = if_condition(pline, s->expandpvt.u) == COND_IF_TRUE; + return make_tok_num(NULL, retval); +} + +/* + * Join all expanded macro arguments with commas, e.g. %eval(). + * Remember that this needs to output the tokens in reverse order. + * + * This can also be used when only single argument is already ready + * to be emitted, e.g. %str(). + */ +static Token * +stdmac_join(const SMacro *s, Token **params, int nparams) +{ + struct Token *tline = NULL; + int i; + + (void)s; + + for (i = 0; i < nparams; i++) { + Token *t, *ttmp; + + if (i) + tline = make_tok_char(tline, ','); + + list_for_each_safe(t, ttmp, params[i]) { + t->next = tline; + tline = t; + } + + /* Avoid freeing the tokens we "stole" */ + params[i] = NULL; + } + + return tline; +} + +/* %strcat() function */ +static Token * +stdmac_strcat(const SMacro *s, Token **params, int nparams) +{ + int i; + size_t len = 0; + char *str, *p; + + (void)s; + + for (i = 0; i < nparams; i++) { + unquote_token(params[i]); + len += params[i]->len; + } + + nasm_newn(str, len+1); + p = str; + + for (i = 0; i < nparams; i++) { + p = mempcpy(p, tok_text(params[i]), params[i]->len); + } + + return make_tok_qstr_len(NULL, str, len); +} + +/* %substr() function */ +static Token * +stdmac_substr(const SMacro *s, Token **params, int nparams) +{ + int64_t start, count; + + (void)nparams; + (void)s; + + start = get_tok_num(params[1], NULL); + count = get_tok_num(params[2], NULL); + + return pp_substr_common(params[0], start, count); +} + +/* %strlen() function */ +static Token * +stdmac_strlen(const SMacro *s, Token **params, int nparams) +{ + (void)nparams; + (void)s; + + unquote_token(params[0]); + return make_tok_num(NULL, params[0]->len); +} + +/* %tok() function */ +static Token * +stdmac_tok(const SMacro *s, Token **params, int nparams) +{ + (void)nparams; + (void)s; + + return reverse_tokens(tokenize(unquote_token_cstr(params[0]))); +} + +/* %cond() or %sel() */ +static Token * +stdmac_cond_sel(const SMacro *s, Token **params, int nparams) +{ + int64_t which; + + /* + * params[0] will have been generated by make_tok_num. + */ + which = get_tok_num(params[0], NULL); + + if (s->expandpvt.u) { + /* Booleanize (for %cond): true -> 1, false -> 2 (else) */ + which = which ? 1 : 2; + if (which >= nparams) { + /* false, and no else clause */ + return NULL; + } + } else { + /*! + *!pp-sel-range [on] %sel() argument out of range + *! warns that the %sel() preprocessor function was passed + *! a value less than 1 or larger than the number of available + *! arguments. + */ + if (unlikely(which < 1)) { + nasm_warn(WARN_PP_SEL_RANGE, + "%s(%"PRId64") is not a valid selector", s->name, which); + return NULL; + } else if (unlikely(which >= nparams)) { + nasm_warn(WARN_PP_SEL_RANGE, + "%s(%"PRId64") exceeds the number of arguments", + s->name, which); + return NULL; + } + } + + return new_Token(NULL, tok_smac_param(which), "", 0); +} + +/* %count() function */ +static Token * +stdmac_count(const SMacro *s, Token **params, int nparams) +{ + (void)s; + (void)params; + + return make_tok_num(NULL, nparams); +} + +/* %num() function */ +static Token * +stdmac_num(const SMacro *s, Token **params, int nparam) +{ + static const char num_digits[] = + "0123456789" + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "@_"; /* Compatible with bash */ + int64_t parm[3]; + uint64_t n; + int64_t dparm, bparm; + unsigned int i; + int nd; + unsigned int base; + char numstr[256]; + char * const endstr = numstr + sizeof numstr - 1; + const int maxlen = sizeof numstr - 3; + const int maxbase = sizeof num_digits - 1; + char *p; + bool moredigits; + + (void)nparam; + + for (i = 0; i < (int)ARRAY_SIZE(parm); i++) + parm[i] = get_tok_num(params[i], NULL); + + n = parm[0]; + dparm = parm[1]; + bparm = parm[2]; + + if (bparm < 2 || bparm > maxbase) { + nasm_nonfatal("invalid base %"PRId64" given to %s()", + bparm, s->name); + return NULL; + } + + base = bparm; + + if (dparm < -maxlen || dparm > maxlen) { + nasm_nonfatal("digit count %"PRId64" specified to %s() too large", + dparm, s->name); + moredigits = true; + nd = 1; + } else if (dparm <= 0) { + moredigits = true; + nd = -dparm; + } else { + moredigits = false; + nd = dparm; + } + + p = endstr; + *p = '\0'; + *--p = '\''; + + while (nd-- > 0 || (moredigits && n)) { + *--p = num_digits[n % base]; + n /= base; + } + *--p = '\''; + + return new_Token(NULL, TOKEN_STR, p, endstr - p); +} + +/* %abs() function */ +static Token * +stdmac_abs(const SMacro *s, Token **params, int nparam) +{ + char numbuf[24]; + int len; + int64_t v; + uint64_t u; + + (void)s; + (void)nparam; + + v = get_tok_num(params[0], NULL); + u = v < 0 ? -v : v; + + /* + * Don't use make_tok_num() here, to make sure we don't emit + * a minus sign for the case of v = -2^63 + */ + len = snprintf(numbuf, sizeof numbuf, "%"PRIu64, u); + return new_Token(NULL, TOKEN_NUM, numbuf, len); +} + +/* Add magic standard macros */ +struct magic_macros { + const char *name; + bool casesense; + int nparam; + enum sparmflags flags; + ExpandSMacro func; +}; + +static void pp_add_magic_stdmac(void) +{ + static const struct magic_macros magic_macros[] = { + { "__?FILE?__", true, 0, 0, stdmac_file }, + { "__?LINE?__", true, 0, 0, stdmac_line }, + { "__?BITS?__", true, 0, 0, stdmac_bits }, + { "__?PTR?__", true, 0, 0, stdmac_ptr }, + { "%abs", false, 1, SPARM_EVAL, stdmac_abs }, + { "%count", false, 1, SPARM_VARADIC, stdmac_count }, + { "%eval", false, 1, SPARM_EVAL|SPARM_VARADIC, stdmac_join }, + { "%str", false, 1, SPARM_GREEDY|SPARM_STR, stdmac_join }, + { "%strcat", false, 1, SPARM_STR|SPARM_CONDQUOTE|SPARM_VARADIC, stdmac_strcat }, + { "%strlen", false, 1, SPARM_STR|SPARM_CONDQUOTE, stdmac_strlen }, + { "%tok", false, 1, SPARM_STR|SPARM_CONDQUOTE, stdmac_tok }, + { NULL, false, 0, 0, NULL } + }; + const struct magic_macros *m; + SMacro tmpl; + enum preproc_token pt; + char name_buf[PP_TOKLEN_MAX+1]; + + /* + * Simple standard magic macros and functions. + * Note that preprocessor functions are allowed to recurse. + */ + nasm_zero(tmpl); + for (m = magic_macros; m->name; m++) { + tmpl.nparam = m->nparam; + tmpl.expand = m->func; + tmpl.recursive = m->nparam && m->name[0] == '%'; + + if (m->nparam) { + int i; + enum sparmflags flags = m->flags; + + nasm_newn(tmpl.params, m->nparam); + for (i = m->nparam-1; i >= 0; i--) { + tmpl.params[i].flags = flags; + /* These flags for the last arg only */ + flags &= ~(SPARM_GREEDY|SPARM_VARADIC|SPARM_OPTIONAL); + } + } + define_smacro(m->name, m->casesense, NULL, &tmpl); + if (m->name[0] == '%') { + enum preproc_token op = pp_token_hash(m->name); + if (op != PP_invalid) + pp_op_may_be_function[op] = true; + } + } + + /* %sel() function */ + nasm_zero(tmpl); + tmpl.nparam = 2; + tmpl.recursive = true; + tmpl.expand = stdmac_cond_sel; + nasm_newn(tmpl.params, tmpl.nparam); + tmpl.params[0].flags = SPARM_EVAL; + tmpl.params[1].flags = SPARM_VARADIC; + define_smacro("%sel", false, NULL, &tmpl); + + /* %cond() function, a variation on %sel */ + tmpl.nparam = 3; + tmpl.expandpvt.u = 1; /* Booleanize */ + nasm_newn(tmpl.params, tmpl.nparam); + tmpl.params[0].flags = SPARM_EVAL; + tmpl.params[1].flags = 0; + tmpl.params[2].flags = SPARM_OPTIONAL; + define_smacro("%cond", false, NULL, &tmpl); + + /* %num() function */ + nasm_zero(tmpl); + tmpl.nparam = 3; + tmpl.expand = stdmac_num; + tmpl.recursive = true; + nasm_newn(tmpl.params, tmpl.nparam); + tmpl.params[0].flags = SPARM_EVAL; + tmpl.params[1].flags = SPARM_EVAL|SPARM_OPTIONAL; + tmpl.params[1].def = make_tok_num(NULL, -1); + tmpl.params[2].flags = SPARM_EVAL|SPARM_OPTIONAL; + tmpl.params[2].def = make_tok_num(NULL, 10); + define_smacro("%num", false, NULL, &tmpl); + + /* %substr() function */ + nasm_zero(tmpl); + tmpl.nparam = 3; + tmpl.expand = stdmac_substr; + tmpl.recursive = true; + nasm_newn(tmpl.params, tmpl.nparam); + tmpl.params[0].flags = SPARM_STR|SPARM_CONDQUOTE; + tmpl.params[1].flags = SPARM_EVAL; + tmpl.params[2].flags = SPARM_EVAL|SPARM_OPTIONAL; + tmpl.params[2].def = make_tok_num(NULL, -1); + define_smacro("%substr", false, NULL, &tmpl); + + /* %is...() macro functions */ + nasm_zero(tmpl); + tmpl.nparam = 1; + tmpl.expand = stdmac_is; + tmpl.recursive = true; + name_buf[0] = '%'; + name_buf[1] = 'i'; + name_buf[2] = 's'; + for (pt = PP_IF; pt < (PP_IFN+(PP_IFN-PP_IF)); pt++) { + if (!pp_directives[pt]) + continue; + + nasm_new(tmpl.params); + tmpl.params[0].flags = SPARM_GREEDY; + + strcpy(name_buf+3, pp_directives[pt]+3); + tmpl.expandpvt.u = pt; + define_smacro(name_buf, false, NULL, &tmpl); + } +} + +static void pp_reset_stdmac(enum preproc_mode mode) +{ + int apass; + struct Include *inc; + + /* + * Set up the stdmac packages as a virtual include file, + * indicated by a null file pointer. + */ + nasm_new(inc); + inc->next = istk; + inc->nolist = inc->noline = !list_option('b'); + inc->where = istk->where; + istk = inc; + if (!istk->nolist) { + lfmt->uplevel(LIST_INCLUDE, 0); + } + if (!istk->noline) { + src_set(0, NULL); + istk->where = src_where(); + if (ppdbg & PDBG_INCLUDE) + dfmt->debug_include(true, istk->next->where, istk->where); + } + + pp_add_magic_stdmac(); + + if (tasm_compatible_mode) + pp_add_stdmac(nasm_stdmac_tasm); + + pp_add_stdmac(nasm_stdmac_nasm); + pp_add_stdmac(nasm_stdmac_version); + + if (extrastdmac) + pp_add_stdmac(extrastdmac); + + stdmacpos = stdmacros[0]; + stdmacnext = &stdmacros[1]; + + do_predef = true; + + /* + * Define the __?PASS?__ macro. This is defined here unlike all the + * other builtins, because it is special -- it varies between + * passes -- but there is really no particular reason to make it + * magic. + * + * 0 = dependencies only + * 1 = preparatory passes + * 2 = final pass + * 3 = preprocess only + */ + switch (mode) { + case PP_NORMAL: + apass = pass_final() ? 2 : 1; + break; + case PP_DEPS: + apass = 0; + break; + case PP_PREPROC: + apass = 3; + break; + default: + panic(); + } + + define_smacro("__?PASS?__", true, make_tok_num(NULL, apass), NULL); +} + +void pp_reset(const char *file, enum preproc_mode mode, + struct strlist *dep_list) +{ + cstk = NULL; + defining = NULL; + nested_mac_count = 0; + nested_rep_count = 0; + init_macros(); + unique = 0; + deplist = dep_list; + pp_mode = mode; + + /* Reset options to default */ + nasm_zero(ppconf); + + /* Disable all debugging info, except in the last pass */ + ppdbg = 0; + if (!(ppopt & PP_TRIVIAL)) { + if (pass_final()) { + if (dfmt->debug_mmacros) + ppdbg |= PDBG_MMACROS; + if (dfmt->debug_smacros) + ppdbg |= PDBG_SMACROS; + if (dfmt->debug_include) + ppdbg |= PDBG_INCLUDE; + } + + if (list_option('s')) + ppdbg |= PDBG_LIST_SMACROS; + } + + memset(use_loaded, 0, use_package_count * sizeof(bool)); + + /* First set up the top level input file */ + nasm_new(istk); + istk->fp = nasm_open_read(file, NF_TEXT); + if (!istk->fp) { + nasm_fatalf(ERR_NOFILE, "unable to open input file `%s'%s%s", + file, errno ? " " : "", errno ? strerror(errno) : ""); + } + src_set(0, file); + istk->where = src_where(); + istk->lineinc = 1; + + if (ppdbg & PDBG_INCLUDE) { + /* Let the debug format know the main file */ + dfmt->debug_include(true, src_nowhere(), istk->where); + } + + strlist_add(deplist, file); + + do_predef = false; + + if (!(ppopt & PP_TRIVIAL)) + pp_reset_stdmac(mode); +} + +void pp_init(enum preproc_opt opt) +{ + ppopt = opt; + nasm_newn(use_loaded, use_package_count); +} + +/* + * Get a line of tokens. If we popped the macro expansion/include stack, + * we return a pointer to the dummy token tok_pop; at that point if + * istk is NULL then we have reached end of input; + */ +static Token tok_pop; /* Dummy token placeholder */ + +static Token *pp_tokline(void) +{ + while (true) { + Line *l = istk->expansion; + Token *tline = NULL; + Token *dtline; + + /* + * Fetch a tokenized line, either from the macro-expansion + * buffer or from the input file. + */ + tline = NULL; + while (l && l->finishes) { + MMacro *fm = l->finishes; + + nasm_assert(fm == istk->mstk.mstk); + + if (!fm->name && fm->in_progress > 1) { + /* + * This is a macro-end marker for a macro with no + * name, which means it's not really a macro at all + * but a %rep block, and the `in_progress' field is + * more than 1, meaning that we still need to + * repeat. (1 means the natural last repetition; 0 + * means termination by %exitrep.) We have + * therefore expanded up to the %endrep, and must + * push the whole block on to the expansion buffer + * again. We don't bother to remove the macro-end + * marker: we'd only have to generate another one + * if we did. + */ + fm->in_progress--; + list_for_each(l, fm->expansion) { + Line *ll; + + nasm_new(ll); + ll->next = istk->expansion; + ll->first = dup_tlist(l->first, NULL); + ll->where = l->where; + istk->expansion = ll; + } + break; + } else { + MMacro *m = istk->mstk.mstk; + + /* + * Check whether a `%rep' was started and not ended + * within this macro expansion. This can happen and + * should be detected. It's a fatal error because + * I'm too confused to work out how to recover + * sensibly from it. + */ + if (defining) { + if (defining->name) + nasm_panic("defining with name in expansion"); + else if (m->name) + nasm_fatal("`%%rep' without `%%endrep' within" + " expansion of macro `%s'", m->name); + } + + /* + * FIXME: investigate the relationship at this point between + * istk->mstk.mstk and fm + */ + istk->mstk = m->mstk; + if (m->name) { + /* + * This was a real macro call, not a %rep, and + * therefore the parameter information needs to + * be freed and the iteration count/nesting + * depth adjusted. + */ + + if (!--mmacro_deadman.levels) { + /* + * If all mmacro processing done, + * clear all counters and the deadman + * message trigger. + */ + nasm_zero(mmacro_deadman); /* Clear all counters */ + } + +#if 0 + if (m->prev) { + pop_mmacro(m); + fm->in_progress --; + } else +#endif + { + nasm_free(m->params); + free_tlist(m->iline); + nasm_free(m->paramlen); + fm->in_progress = 0; + m->params = NULL; + m->iline = NULL; + m->paramlen = NULL; + } + } + + if (fm->nolist & NL_LINE) { + istk->noline--; + } else if (!istk->noline) { + if (fm == src_macro_current()) + src_macro_pop(); + src_update(l->where); + } + + if (fm->nolist & NL_LIST) { + istk->nolist--; + } else if (!istk->nolist) { + lfmt->downlevel(LIST_MACRO); + if ((ppdbg & PDBG_MMACROS) && fm->name) + debug_macro_end(fm); + } + + istk->where = l->where; + + /* + * FIXME It is incorrect to always free_mmacro here. + * It leads to usage-after-free. + * + * https://bugzilla.nasm.us/show_bug.cgi?id=3392414 + */ +#if 0 + else + free_mmacro(m); +#endif + } + istk->expansion = l->next; + nasm_free(l); + + return &tok_pop; + } + + do { /* until we get a line we can use */ + char *line; + + if (istk->expansion) { /* from a macro expansion */ + Line *l = istk->expansion; + + istk->expansion = l->next; + istk->where = l->where; + tline = l->first; + nasm_free(l); + + if (!istk->noline) + src_update(istk->where); + + if (!istk->nolist) { + line = detoken(tline, false); + lfmt->line(LIST_MACRO, istk->where.lineno, line); + nasm_free(line); + } + } else if ((line = read_line())) { + tline = tokenize(line); + nasm_free(line); + } else { + /* + * The current file has ended; work down the istk + */ + Include *i = istk; + + if (i->fp) + fclose(i->fp); + if (i->conds) { + /* nasm_fatal can't be conditionally suppressed */ + nasm_fatal("expected `%%endif' before end of file"); + } + + istk = i->next; + + if (!i->nolist) + lfmt->downlevel(LIST_INCLUDE); + if (!i->noline) { + struct src_location whereto + = istk ? istk->where : src_nowhere(); + if (ppdbg & PDBG_INCLUDE) + dfmt->debug_include(false, whereto, i->where); + if (istk) + src_update(istk->where); + } + + nasm_free(i); + return &tok_pop; + } + } while (0); + + /* + * We must expand MMacro parameters and MMacro-local labels + * _before_ we plunge into directive processing, to cope + * with things like `%define something %1' such as STRUC + * uses. Unless we're _defining_ a MMacro, in which case + * those tokens should be left alone to go into the + * definition; and unless we're in a non-emitting + * condition, in which case we don't want to meddle with + * anything. + */ + if (!defining && + !(istk->conds && !emitting(istk->conds->state)) && + !(istk->mstk.mmac && !istk->mstk.mmac->in_progress)) { + tline = expand_mmac_params(tline); + } + + /* + * Check the line to see if it's a preprocessor directive. + */ + if (do_directive(tline, &dtline) == DIRECTIVE_FOUND) { + if (dtline) + return dtline; + } else if (defining) { + /* + * We're defining a multi-line macro. We emit nothing + * at all, and just + * shove the tokenized line on to the macro definition. + */ + MMacro *mmac = defining->dstk.mmac; + Line *l; + + nasm_new(l); + l->next = defining->expansion; + l->first = tline; + l->finishes = NULL; + l->where = istk->where; + defining->expansion = l; + + /* + * Remember if this mmacro expansion contains %00: + * if it does, we will have to handle leading labels + * specially. + */ + if (mmac) { + const Token *t; + list_for_each(t, tline) { + if (t->type == TOKEN_MMACRO_PARAM && + !memcmp(t->text.a, "%00", 4)) + mmac->capture_label = true; + } + } + } else if (istk->conds && !emitting(istk->conds->state)) { + /* + * We're in a non-emitting branch of a condition block. + * Emit nothing at all, not even a blank line: when we + * emerge from the condition we'll give a line-number + * directive so we keep our place correctly. + */ + free_tlist(tline); + } else if (istk->mstk.mstk && !istk->mstk.mstk->in_progress) { + /* + * We're in a %rep block which has been terminated, so + * we're walking through to the %endrep without + * emitting anything. Emit nothing at all, not even a + * blank line: when we emerge from the %rep block we'll + * give a line-number directive so we keep our place + * correctly. + */ + free_tlist(tline); + } else { + tline = expand_smacro(tline); + if (!expand_mmacro(tline)) + return tline; + } + } +} + +char *pp_getline(void) +{ + char *line = NULL; + Token *tline; + + while (true) { + tline = pp_tokline(); + if (tline == &tok_pop) { + /* + * We popped the macro/include stack. If istk is empty, + * we are at end of input, otherwise just loop back. + */ + if (!istk) + break; + } else { + /* + * De-tokenize the line and emit it. + */ + line = detoken(tline, true); + free_tlist(tline); + break; + } + } + + if (list_option('e') && istk && !istk->nolist && line && line[0]) { + char *buf = nasm_strcat(" ;;; ", line); + lfmt->line(LIST_MACRO, -1, buf); + nasm_free(buf); + } + + return line; +} + +void pp_cleanup_pass(void) +{ + if (defining) { + if (defining->name) { + nasm_nonfatal("end of file while still defining macro `%s'", + defining->name); + } else { + nasm_nonfatal("end of file while still in %%rep"); + } + + free_mmacro(defining); + defining = NULL; + } + + while (cstk) + ctx_pop(); + free_macros(); + while (istk) { + Include *i = istk; + istk = istk->next; + fclose(i->fp); + if (!istk && (ppdbg & PDBG_INCLUDE)) { + /* Signal closing the top-level input file */ + dfmt->debug_include(false, src_nowhere(), i->where); + } + nasm_free(i); + } + while (cstk) + ctx_pop(); + src_set_fname(NULL); + + if (ppdbg & PDBG_MMACROS) + debug_macro_output(); +} + +void pp_cleanup_session(void) +{ + nasm_free(use_loaded); + free_llist(predef); + predef = NULL; + delete_Blocks(); + ipath_list = NULL; +} + +void pp_include_path(struct strlist *list) +{ + ipath_list = list; +} + +void pp_pre_include(char *fname) +{ + Token *inc, *space, *name; + Line *l; + + name = new_Token(NULL, TOKEN_INTERNAL_STR, fname, 0); + space = new_White(name); + inc = new_Token(space, TOKEN_PREPROC_ID, "%include", 0); + + l = nasm_malloc(sizeof(Line)); + l->next = predef; + l->first = inc; + l->finishes = NULL; + predef = l; +} + +void pp_pre_define(char *definition) +{ + Token *def, *space; + Line *l; + char *equals; + + equals = strchr(definition, '='); + space = new_White(NULL); + def = new_Token(space, TOKEN_PREPROC_ID, "%define", 0); + if (equals) + *equals = ' '; + space->next = tokenize(definition); + if (equals) + *equals = '='; + + nasm_new(l); + l->next = predef; + l->first = def; + l->finishes = NULL; + predef = l; +} + +void pp_pre_undefine(char *definition) +{ + Token *def, *space; + Line *l; + + space = new_White(NULL); + def = new_Token(space, TOKEN_PREPROC_ID, "%undef", 0); + space->next = tokenize(definition); + + nasm_new(l); + l->next = predef; + l->first = def; + l->finishes = NULL; + predef = l; +} + +/* Insert an early preprocessor command that doesn't need special handling */ +void pp_pre_command(const char *what, char *string) +{ + Token *def, *space; + Line *l; + + def = tokenize(string); + if (what) { + space = new_White(def); + def = new_Token(space, TOKEN_PREPROC_ID, what, 0); + } + + nasm_new(l); + l->next = predef; + l->first = def; + l->finishes = NULL; + predef = l; +} + +static void pp_add_stdmac(macros_t *macros) +{ + macros_t **mp; + + /* Find the end of the list and avoid duplicates */ + for (mp = stdmacros; *mp; mp++) { + if (*mp == macros) + return; /* Nothing to do */ + } + + nasm_assert(mp < &stdmacros[ARRAY_SIZE(stdmacros)-1]); + + *mp = macros; +} + +void pp_extra_stdmac(macros_t *macros) +{ + extrastdmac = macros; +} + +/* Create a numeric token, with possible - token in front */ +static Token *make_tok_num(Token *next, int64_t val) +{ + char numbuf[32]; + int len; + uint64_t uval; + bool minus = val < 0; + + uval = minus ? -val : val; + + len = snprintf(numbuf, sizeof numbuf, "%"PRIu64, uval); + next = new_Token(next, TOKEN_NUM, numbuf, len); + + if (minus) + next = make_tok_char(next, '-'); + + return next; +} + +/* + * Do the inverse of make_tok_num(). This only needs to be able + * to parse the output of make_tok_num(). + */ +static int64_t get_tok_num(const Token *t, bool *err) +{ + bool minus = false; + int64_t v; + + if (tok_is(t, '-')) { + minus = true; + t = t->next; + } + if (!tok_is(t, TOKEN_NUM)) { + if (err) + *err = true; + return 0; + } + + v = readnum(tok_text(t), err); + return minus ? -v : v; +} + +/* Create a quoted string token */ +static Token *make_tok_qstr_len(Token *next, const char *str, size_t len) +{ + char *p = nasm_quote(str, &len); + return new_Token_free(next, TOKEN_STR, p, len); +} +static Token *make_tok_qstr(Token *next, const char *str) +{ + return make_tok_qstr_len(next, str, strlen(str)); +} + +/* Create a single-character operator token */ +static Token *make_tok_char(Token *next, char op) +{ + Token *t = new_Token(next, op, NULL, 1); + t->text.a[0] = op; + return t; +} + +/* + * Descent the macro hierarchy and display the expansion after + * encountering an error message. + */ +void pp_error_list_macros(errflags severity) +{ + const MMacro *m; + + severity |= ERR_PP_LISTMACRO | ERR_NO_SEVERITY | ERR_HERE; + + while ((m = src_error_down())) { + if ((m->nolist & NL_LIST) || !m->where.filename) + break; + nasm_error(severity, "... from macro `%s' defined", m->name); + } + + src_error_reset(); +} diff --git a/vere/ext/nasm/asm/preproc.h b/vere/ext/nasm/asm/preproc.h new file mode 100644 index 0000000..7113046 --- /dev/null +++ b/vere/ext/nasm/asm/preproc.h @@ -0,0 +1,56 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * preproc.h header file for preproc.c + */ + +#ifndef NASM_PREPROC_H +#define NASM_PREPROC_H + +#include "nasmlib.h" +#include "pptok.h" + +extern const char * const pp_directives[]; +extern const uint8_t pp_directives_len[]; + +/* Pointer to a macro chain */ +typedef const unsigned char macros_t; + +enum preproc_token pp_token_hash(const char *token); +enum preproc_token pp_tasm_token_hash(const char *token); + +/* Opens an include file or input file. This uses the include path. */ +FILE *pp_input_fopen(const char *filename, enum file_flags mode); + +#endif diff --git a/vere/ext/nasm/asm/quote.c b/vere/ext/nasm/asm/quote.c new file mode 100644 index 0000000..074f17d --- /dev/null +++ b/vere/ext/nasm/asm/quote.c @@ -0,0 +1,563 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * quote.c + */ + +#include "compiler.h" +#include "nasmlib.h" +#include "quote.h" +#include "nctype.h" +#include "error.h" + +/* + * Create a NASM quoted string in newly allocated memory. Update the + * *lenp parameter with the output length (sans final NUL). + */ + +char *nasm_quote(const char *str, size_t *lenp) +{ + const char *p, *ep; + char c, c1, *q, *nstr; + unsigned char uc; + bool sq_ok, dq_ok; + size_t qlen; + size_t len = *lenp; + + sq_ok = dq_ok = true; + ep = str+len; + qlen = 0; /* Length if we need `...` quotes */ + for (p = str; p < ep; p++) { + c = *p; + switch (c) { + case '\'': + sq_ok = false; + qlen++; + break; + case '\"': + dq_ok = false; + qlen++; + break; + case '`': + case '\\': + qlen += 2; + break; + default: + if (c < ' ' || c > '~') { + sq_ok = dq_ok = false; + switch (c) { + case '\a': + case '\b': + case '\t': + case '\n': + case '\v': + case '\f': + case '\r': + case 27: + qlen += 2; + break; + default: + c1 = (p+1 < ep) ? p[1] : 0; + if (c1 >= '0' && c1 <= '7') + uc = 0377; /* Must use the full form */ + else + uc = c; + if (uc > 077) + qlen++; + if (uc > 07) + qlen++; + qlen += 2; + break; + } + } else { + qlen++; + } + break; + } + } + + if (sq_ok || dq_ok) { + /* Use '...' or "..." */ + nstr = nasm_malloc(len+3); + nstr[0] = nstr[len+1] = sq_ok ? '\'' : '\"'; + q = &nstr[len+2]; + if (len > 0) + memcpy(nstr+1, str, len); + } else { + /* Need to use `...` quoted syntax */ + nstr = nasm_malloc(qlen+3); + q = nstr; + *q++ = '`'; + for (p = str; p < ep; p++) { + c = *p; + switch (c) { + case '`': + case '\\': + *q++ = '\\'; + *q++ = c; + break; + case 7: + *q++ = '\\'; + *q++ = 'a'; + break; + case 8: + *q++ = '\\'; + *q++ = 'b'; + break; + case 9: + *q++ = '\\'; + *q++ = 't'; + break; + case 10: + *q++ = '\\'; + *q++ = 'n'; + break; + case 11: + *q++ = '\\'; + *q++ = 'v'; + break; + case 12: + *q++ = '\\'; + *q++ = 'f'; + break; + case 13: + *q++ = '\\'; + *q++ = 'r'; + break; + case 27: + *q++ = '\\'; + *q++ = 'e'; + break; + default: + if (c < ' ' || c > '~') { + c1 = (p+1 < ep) ? p[1] : 0; + if (c1 >= '0' && c1 <= '7') + uc = 0377; /* Must use the full form */ + else + uc = c; + *q++ = '\\'; + if (uc > 077) + *q++ = ((unsigned char)c >> 6) + '0'; + if (uc > 07) + *q++ = (((unsigned char)c >> 3) & 7) + '0'; + *q++ = ((unsigned char)c & 7) + '0'; + break; + } else { + *q++ = c; + } + break; + } + } + *q++ = '`'; + nasm_assert((size_t)(q-nstr) == qlen+2); + } + *q = '\0'; + *lenp = q - nstr; + return nstr; +} + +static unsigned char *emit_utf8(unsigned char *q, uint32_t v) +{ + uint32_t vb1, vb2, vb3, vb4, vb5; + + if (v <= 0x7f) { + *q++ = v; + goto out0; + } + + vb1 = v >> 6; + if (vb1 <= 0x1f) { + *q++ = 0xc0 + vb1; + goto out1; + } + + vb2 = vb1 >> 6; + if (vb2 <= 0x0f) { + *q++ = 0xe0 + vb2; + goto out2; + } + + vb3 = vb2 >> 6; + if (vb3 <= 0x07) { + *q++ = 0xf0 + vb3; + goto out3; + } + + vb4 = vb3 >> 6; + if (vb4 <= 0x03) { + *q++ = 0xf8 + vb4; + goto out4; + } + + /* + * Note: this is invalid even for "classic" (pre-UTF16) 31-bit + * UTF-8 if the value is >= 0x8000000. This at least tries to do + * something vaguely sensible with it. Caveat programmer. + * The __utf*__ string transform functions do reject these + * as invalid input. + * + * vb5 cannot be more than 3, as a 32-bit value has been shifted + * right by 5*6 = 30 bits already. + */ + vb5 = vb4 >> 6; + *q++ = 0xfc + vb5; + goto out5; + + /* Emit extension bytes as appropriate */ +out5: *q++ = 0x80 + (vb4 & 63); +out4: *q++ = 0x80 + (vb3 & 63); +out3: *q++ = 0x80 + (vb2 & 63); +out2: *q++ = 0x80 + (vb1 & 63); +out1: *q++ = 0x80 + (v & 63); +out0: return q; +} + +static inline uint32_t ctlbit(uint32_t v) +{ + return unlikely(v < 32) ? UINT32_C(1) << v : 0; +} + +#define CTL_ERR(c) \ + (badctl & (ctlmask |= ctlbit(c))) + +#define EMIT_UTF8(c) \ + do { \ + uint32_t ec = (c); \ + if (!CTL_ERR(ec)) \ + q = emit_utf8(q, ec); \ + } while (0) + +#define EMIT(c) \ + do { \ + unsigned char ec = (c); \ + if (!CTL_ERR(ec)) \ + *q++ = ec; \ + } while (0) + +/* + * Same as nasm_quote, but take the length of a C string; + * the lenp argument is optional. + */ +char *nasm_quote_cstr(const char *str, size_t *lenp) +{ + size_t len = strlen(str); + char *qstr = nasm_quote(str, &len); + if (lenp) + *lenp = len; + return qstr; +} + +/* + * Do an *in-place* dequoting of the specified string, returning the + * resulting length (which may be containing embedded nulls.) + * + * In-place replacement is possible since the unquoted length is always + * shorter than or equal to the quoted length. + * + * *ep points to the final quote, or to the null if improperly quoted. + * + * Issue an error if the string contains control characters + * corresponding to bits set in badctl; in that case, the output + * string, but not *ep, is truncated before the first invalid + * character. + * + * badctl is a bitmask of control characters (0-31) which are forbidden + * from appearing in the final output. + * + * The qstart character can be either '`' (NASM style) or '\"' (C style), + * to indicate the lead marker of a quoted string. If it is '\"', then + * '`' is not a special character at all. + */ + +size_t nasm_unquote_anystr(char *str, char **ep, const uint32_t badctl, + const char qstart) +{ + unsigned char bq; + const unsigned char *p; + const unsigned char *escp = NULL; + unsigned char *q; + unsigned char c; + uint32_t ctlmask = 0; /* Mask of control characters seen */ + enum unq_state { + st_start, + st_backslash, + st_hex, + st_oct, + st_ucs, + st_done + } state; + int ndig = 0; + uint32_t nval = 0; + + p = q = (unsigned char *)str; + + bq = *p++; + if (!bq) + return 0; + + if (bq == (unsigned char)qstart) { + /* `...` string */ + state = st_start; + + while (state != st_done) { + c = *p++; + switch (state) { + case st_start: + if (c == '\\') { + state = st_backslash; + } else if ((c == '\0') | (c == bq)) { + state = st_done; + } else { + EMIT(c); + } + break; + + case st_backslash: + state = st_start; + escp = p; /* Beginning of argument sequence */ + nval = 0; + switch (c) { + case 'a': + nval = 7; + break; + case 'b': + nval = 8; + break; + case 'e': + nval = 27; + break; + case 'f': + nval = 12; + break; + case 'n': + nval = 10; + break; + case 'r': + nval = 13; + break; + case 't': + nval = 9; + break; + case 'u': + state = st_ucs; + ndig = 4; + break; + case 'U': + state = st_ucs; + ndig = 8; + break; + case 'v': + nval = 11; + break; + case 'x': + case 'X': + state = st_hex; + ndig = 2; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + state = st_oct; + ndig = 2; /* Up to two more digits */ + nval = c - '0'; + break; + case '\0': + nval = '\\'; + p--; /* Reprocess; terminates string */ + break; + default: + nval = c; + break; + } + if (state == st_start) + EMIT(nval); + break; + + case st_oct: + if (c >= '0' && c <= '7') { + nval = (nval << 3) + (c - '0'); + if (--ndig) + break; /* Might have more digits */ + } else { + p--; /* Process this character again */ + } + EMIT(nval); + state = st_start; + break; + + case st_hex: + case st_ucs: + if (nasm_isxdigit(c)) { + nval = (nval << 4) + numvalue(c); + if (--ndig) + break; /* Might have more digits */ + } else { + p--; /* Process this character again */ + } + + if (unlikely(p <= escp)) + EMIT(escp[-1]); + else if (state == st_ucs) + EMIT_UTF8(nval); + else + EMIT(nval); + + state = st_start; + break; + + default: + panic(); + } + } + } else if (bq == '\'' || bq == '\"') { + /* + * '...' or "..." string, NASM legacy style (no escapes of + * * any kind, including collapsing double quote marks.) + * We obviously can't get here if qstart == '\"'. + */ + while ((c = *p++) && (c != bq)) + EMIT(c); + } else { + /* Not a quoted string, just return the input... */ + while ((c = *p++)) + EMIT(c); + } + + /* Zero-terminate the output */ + *q = '\0'; + + if (ctlmask & badctl) + nasm_nonfatal("control character in string not allowed here"); + + if (ep) + *ep = (char *)p - 1; + return (char *)q - str; +} +#undef EMIT + +/* + * Unquote any arbitrary string; may produce any bytes, including embedded + * control- and NUL characters. + */ +size_t nasm_unquote(char *str, char **ep) +{ + return nasm_unquote_anystr(str, ep, 0, STR_NASM); +} + +/* + * Unquote a string intended to be used as a C string; most control + * characters are rejected, including whitespace characters that + * would imply line endings and so on. + */ +size_t nasm_unquote_cstr(char *str, char **ep) +{ + return nasm_unquote_anystr(str, ep, BADCTL, STR_NASM); +} + +/* + * Find the end of a quoted string; returns the pointer to the terminating + * character (either the ending quote or the null character, if unterminated.) + * If the input is not a quoted string, return NULL. + * This applies to NASM style strings only. + */ +char *nasm_skip_string(const char *str) +{ + char bq; + const char *p; + char c; + enum unq_state { + st_start, + st_backslash, + st_done + } state; + + bq = str[0]; + p = str+1; + switch (bq) { + case '\'': + case '\"': + /* '...' or "..." string */ + while ((c = *p++) && (c != bq)) + ; + break; + + case '`': + /* `...` string */ + state = st_start; + while (state != st_done) { + c = *p++; + switch (state) { + case st_start: + switch (c) { + case '\\': + state = st_backslash; + break; + case '`': + case '\0': + state = st_done; + break; + default: + break; + } + break; + + case st_backslash: + /* + * Note: for the purpose of finding the end of the string, + * all successor states to st_backslash are functionally + * equivalent to st_start, since either a backslash or + * a backquote will force a return to the st_start state, + * and any possible multi-character state will terminate + * for any non-alphanumeric character. + */ + state = c ? st_start : st_done; + break; + + default: + panic(); + } + } + break; + + default: + /* Not a string at all... */ + return NULL; + } + return (char *)p - 1; +} diff --git a/vere/ext/nasm/asm/quote.h b/vere/ext/nasm/asm/quote.h new file mode 100644 index 0000000..d8226cd --- /dev/null +++ b/vere/ext/nasm/asm/quote.h @@ -0,0 +1,61 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2009 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +#ifndef NASM_QUOTE_H +#define NASM_QUOTE_H + +#include "compiler.h" + +char *nasm_quote(const char *str, size_t *len); +char *nasm_quote_cstr(const char *str, size_t *len); +size_t nasm_unquote_anystr(char *str, char **endptr, + uint32_t badctl, char qstart); +size_t nasm_unquote(char *str, char **endptr); +size_t nasm_unquote_cstr(char *str, char **endptr); +char *nasm_skip_string(const char *str); + +/* Arguments used with nasm_quote_anystr() */ + +/* + * These are the only control characters when we produce a C string: + * BEL BS TAB ESC + */ +#define OKCTL ((1U << '\a') | (1U << '\b') | (1U << '\t') | (1U << 27)) +#define BADCTL (~(uint32_t)OKCTL) + +/* Initial quotation mark */ +#define STR_C '\"' +#define STR_NASM '`' + +#endif /* NASM_QUOTE_H */ + diff --git a/vere/ext/nasm/asm/rdstrnum.c b/vere/ext/nasm/asm/rdstrnum.c new file mode 100644 index 0000000..319f140 --- /dev/null +++ b/vere/ext/nasm/asm/rdstrnum.c @@ -0,0 +1,70 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2016 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * rdstrnum.c + * + * This converts a NASM string to an integer, used when a string + * is used in an integer constant context. This is a binary conversion, + * not a conversion from a numeric constant in text form. + */ + +#include "compiler.h" +#include "nasmlib.h" +#include "nasm.h" + +int64_t readstrnum(char *str, int length, bool *warn) +{ + int64_t charconst = 0; + int i; + + *warn = false; + + str += length; + if (globalbits == 64) { + for (i = 0; i < length; i++) { + if (charconst & UINT64_C(0xFF00000000000000)) + *warn = true; + charconst &= ~UINT64_C(0xFF00000000000000); + charconst = (charconst << 8) + (uint8_t)*--str; + } + } else { + for (i = 0; i < length; i++) { + if (charconst & UINT32_C(0xFF000000)) + *warn = true; + charconst &= ~UINT32_C(0xFF000000); + charconst = (charconst << 8) + (uint8_t)*--str; + } + } + return charconst; +} diff --git a/vere/ext/nasm/asm/segalloc.c b/vere/ext/nasm/asm/segalloc.c new file mode 100644 index 0000000..6d7a420 --- /dev/null +++ b/vere/ext/nasm/asm/segalloc.c @@ -0,0 +1,51 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2018 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * nasmlib.c library routines for the Netwide Assembler + */ + +#include "compiler.h" +#include "nasm.h" +#include "nasmlib.h" +#include "insns.h" + +static int32_t next_seg = 2; + +int32_t seg_alloc(void) +{ + int32_t this_seg = next_seg; + + next_seg += 2; + return this_seg; +} diff --git a/vere/ext/nasm/asm/srcfile.c b/vere/ext/nasm/asm/srcfile.c new file mode 100644 index 0000000..b44c021 --- /dev/null +++ b/vere/ext/nasm/asm/srcfile.c @@ -0,0 +1,118 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * srcfile.c - keep track of the current position in the input stream. + * + * This is used for error messages, listing, and debug information. In + * both cases we also want to understand where inside a non-nolist + * macro we may be. + * + * This hierarchy is a stack that is kept as a doubly-linked list, as + * we want to traverse it in either top-down order or bottom-up. + */ + +#include "compiler.h" + + +#include "nasmlib.h" +#include "hashtbl.h" +#include "srcfile.h" + +struct src_location_stack _src_top; +struct src_location_stack *_src_bottom = &_src_top; +struct src_location_stack *_src_error = &_src_top; + +static struct hash_table filename_hash; + +void src_init(void) +{ +} + +void src_free(void) +{ + hash_free_all(&filename_hash, false); +} + +/* + * Set the current filename, returning the old one. The input + * filename is duplicated if needed. + */ +const char *src_set_fname(const char *newname) +{ + struct hash_insert hi; + const char *oldname; + void **dp; + + if (newname) { + dp = hash_find(&filename_hash, newname, &hi); + if (dp) { + newname = (const char *)(*dp); + } else { + newname = nasm_strdup(newname); + hash_add(&hi, newname, (void *)newname); + } + } + + oldname = _src_bottom->l.filename; + _src_bottom->l.filename = newname; + return oldname; +} + +void src_set(int32_t line, const char *fname) +{ + src_set_fname(fname); + src_set_linnum(line); +} + +void src_macro_push(const void *macro, struct src_location where) +{ + struct src_location_stack *sl; + + nasm_new(sl); + sl->l = where; + sl->macro = macro; + sl->up = _src_bottom; + _src_bottom->down = sl; + _src_bottom = sl; +} + +void src_macro_pop(void) +{ + struct src_location_stack *sl = _src_bottom; + + _src_bottom = sl->up; + _src_bottom->down = NULL; + + nasm_free(sl); +} diff --git a/vere/ext/nasm/asm/srcfile.h b/vere/ext/nasm/asm/srcfile.h new file mode 100644 index 0000000..a185354 --- /dev/null +++ b/vere/ext/nasm/asm/srcfile.h @@ -0,0 +1,183 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2020 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * These functions are used to keep track of the source code file and name. + */ +#ifndef ASM_SRCFILE_H +#define ASM_SRCFILE_H + +#include "compiler.h" + +struct src_location { + const char *filename; + int32_t lineno; +}; + +static inline const_func struct src_location src_nowhere(void) +{ + struct src_location no_where = { NULL, 0 }; + return no_where; +} + +/* + * Comparing the *pointer value* of filenames is valid, because the + * filename hash system guarantees that each unique filename string is + * permanently allocated in exactly one location. + */ +static inline bool +src_location_same(struct src_location here, struct src_location there) +{ + return here.filename == there.filename && here.lineno == there.lineno; +} + +struct src_location_stack { + struct src_location l; + struct src_location_stack *up, *down; + const void *macro; +}; +extern struct src_location_stack _src_top; +extern struct src_location_stack *_src_bottom; +extern struct src_location_stack *_src_error; + +void src_init(void); +void src_free(void); +const char *src_set_fname(const char *newname); +static inline const char *src_get_fname(void) +{ + return _src_bottom->l.filename; +} +static inline int32_t src_set_linnum(int32_t newline) +{ + int32_t oldline = _src_bottom->l.lineno; + _src_bottom->l.lineno = newline; + return oldline; +} +static inline int32_t src_get_linnum(void) +{ + return _src_bottom->l.lineno; +} + +/* Can be used when there is no need for the old information */ +void src_set(int32_t line, const char *filename); + +/* + * src_get gets both the source file name and line. + * It is also used if you maintain private status about the source location + * It return 0 if the information was the same as the last time you + * checked, -2 if the name changed and (new-old) if just the line changed. + * + * xname must point to a filename string previously returned from any + * function of this subsystem or be NULL; another string value will + * not work. + */ +static inline int32_t src_get(int32_t *xline, const char **xname) +{ + const char *xn = *xname; + int32_t xl = *xline; + int32_t line = _src_bottom->l.lineno; + + *xline = line; + *xname = _src_bottom->l.filename; + + /* The return value is expected to be optimized out almost everywhere */ + if (!xn || xn != _src_bottom->l.filename) + return -2; + else + return line - xl; +} + +/* + * Returns the current information as a structure. + */ +static inline struct src_location src_where(void) +{ + return _src_bottom->l; +} + +/* + * Returns the top-level information as a structure. Use this for panic + * errors, since descent is not possible there. + */ +static inline struct src_location src_where_top(void) +{ + return _src_top.l; +} + +/* + * Returns the appropriate level of the location stack to use for error + * messages. This is the same as the top level except during the descent + * through the macro hierarchy for elucidation; + */ +static inline struct src_location src_where_error(void) +{ + return _src_error->l; +} +static inline const void *src_error_down(void) +{ + if (_src_error->down) { + _src_error = _src_error->down; + return _src_error->macro; + } else { + return NULL; + } +} +static inline void src_error_reset(void) +{ + _src_error = &_src_top; +} + +/* + * Sets the current information. The filename member of the structure + * *must* have been previously returned by src_get(), src_where(), or + * src_get_fname() and therefore be present in the hash. + */ +static inline struct src_location src_update(struct src_location whence) +{ + struct src_location old = _src_bottom->l; + _src_bottom->l = whence; + return old; +} + +/* + * Push/pop macro expansion level. "macroname" must remain constant at + * least until the same macro expansion level is popped. + */ +void src_macro_push(const void *macroname, struct src_location where); +static inline const void *src_macro_current(void) +{ + return _src_bottom->macro; +} +void src_macro_pop(void); + +#endif /* ASM_SRCFILE_H */ diff --git a/vere/ext/nasm/asm/stdscan.c b/vere/ext/nasm/asm/stdscan.c new file mode 100644 index 0000000..cbc0fc7 --- /dev/null +++ b/vere/ext/nasm/asm/stdscan.c @@ -0,0 +1,346 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2018 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +#include "compiler.h" + +#include "nctype.h" + +#include "nasm.h" +#include "nasmlib.h" +#include "error.h" +#include "quote.h" +#include "stdscan.h" +#include "insns.h" + +/* + * Standard scanner routine used by parser.c and some output + * formats. It keeps a succession of temporary-storage strings in + * stdscan_tempstorage, which can be cleared using stdscan_reset. + */ +static char *stdscan_bufptr = NULL; +static char **stdscan_tempstorage = NULL; +static int stdscan_tempsize = 0, stdscan_templen = 0; +#define STDSCAN_TEMP_DELTA 256 + +void stdscan_set(char *str) +{ + stdscan_bufptr = str; +} + +char *stdscan_get(void) +{ + return stdscan_bufptr; +} + +static void stdscan_pop(void) +{ + nasm_free(stdscan_tempstorage[--stdscan_templen]); +} + +void stdscan_reset(void) +{ + while (stdscan_templen > 0) + stdscan_pop(); +} + +/* + * Unimportant cleanup is done to avoid confusing people who are trying + * to debug real memory leaks + */ +void stdscan_cleanup(void) +{ + stdscan_reset(); + nasm_free(stdscan_tempstorage); +} + +static char *stdscan_copy(const char *p, int len) +{ + char *text; + + text = nasm_malloc(len + 1); + memcpy(text, p, len); + text[len] = '\0'; + + if (stdscan_templen >= stdscan_tempsize) { + stdscan_tempsize += STDSCAN_TEMP_DELTA; + stdscan_tempstorage = nasm_realloc(stdscan_tempstorage, + stdscan_tempsize * + sizeof(char *)); + } + stdscan_tempstorage[stdscan_templen++] = text; + + return text; +} + +/* + * a token is enclosed with braces. proper token type will be assigned + * accordingly with the token flag. + */ +static int stdscan_handle_brace(struct tokenval *tv) +{ + if (!(tv->t_flag & TFLAG_BRC_ANY)) { + /* invalid token is put inside braces */ + nasm_nonfatal("`%s' is not a valid decorator with braces", tv->t_charptr); + tv->t_type = TOKEN_INVALID; + } else if (tv->t_flag & TFLAG_BRC_OPT) { + if (is_reg_class(OPMASKREG, tv->t_integer)) { + /* within braces, opmask register is now used as a mask */ + tv->t_type = TOKEN_OPMASK; + } + } + + return tv->t_type; +} + +int stdscan(void *private_data, struct tokenval *tv) +{ + const char *r; + + (void)private_data; /* Don't warn that this parameter is unused */ + + nasm_zero(*tv); + + stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr); + if (!*stdscan_bufptr) + return tv->t_type = TOKEN_EOS; + + /* we have a token; either an id, a number or a char */ + if (nasm_isidstart(*stdscan_bufptr) || + (*stdscan_bufptr == '$' && nasm_isidstart(stdscan_bufptr[1]))) { + /* now we've got an identifier */ + bool is_sym = false; + int token_type; + + if (*stdscan_bufptr == '$') { + is_sym = true; + stdscan_bufptr++; + } + + r = stdscan_bufptr++; + /* read the entire buffer to advance the buffer pointer but... */ + while (nasm_isidchar(*stdscan_bufptr)) + stdscan_bufptr++; + + /* ... copy only up to IDLEN_MAX-1 characters */ + tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r < IDLEN_MAX ? + stdscan_bufptr - r : IDLEN_MAX - 1); + + if (is_sym || stdscan_bufptr - r > MAX_KEYWORD) + return tv->t_type = TOKEN_ID; /* bypass all other checks */ + + token_type = nasm_token_hash(tv->t_charptr, tv); + if (unlikely(tv->t_flag & TFLAG_WARN)) { + /*! + *!ptr [on] non-NASM keyword used in other assemblers + *! warns about keywords used in other assemblers that might + *! indicate a mistake in the source code. Currently only the MASM + *! \c{PTR} keyword is recognized. See also \k{pkg_masm}. + */ + nasm_warn(WARN_PTR, "`%s' is not a NASM keyword", + tv->t_charptr); + } + + if (likely(!(tv->t_flag & TFLAG_BRC))) { + /* most of the tokens fall into this case */ + return token_type; + } else { + return tv->t_type = TOKEN_ID; + } + } else if (*stdscan_bufptr == '$' && !nasm_isnumchar(stdscan_bufptr[1])) { + /* + * It's a $ sign with no following hex number; this must + * mean it's a Here token ($), evaluating to the current + * assembly location, or a Base token ($$), evaluating to + * the base of the current segment. + */ + stdscan_bufptr++; + if (*stdscan_bufptr == '$') { + stdscan_bufptr++; + return tv->t_type = TOKEN_BASE; + } + return tv->t_type = TOKEN_HERE; + } else if (nasm_isnumstart(*stdscan_bufptr)) { /* now we've got a number */ + bool rn_error; + bool is_hex = false; + bool is_float = false; + bool has_e = false; + char c; + + r = stdscan_bufptr; + + if (*stdscan_bufptr == '$') { + stdscan_bufptr++; + is_hex = true; + } + + for (;;) { + c = *stdscan_bufptr++; + + if (!is_hex && (c == 'e' || c == 'E')) { + has_e = true; + if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-') { + /* + * e can only be followed by +/- if it is either a + * prefixed hex number or a floating-point number + */ + is_float = true; + stdscan_bufptr++; + } + } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') { + is_hex = true; + } else if (c == 'P' || c == 'p') { + is_float = true; + if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-') + stdscan_bufptr++; + } else if (nasm_isnumchar(c)) + ; /* just advance */ + else if (c == '.') + is_float = true; + else + break; + } + stdscan_bufptr--; /* Point to first character beyond number */ + + if (has_e && !is_hex) { + /* 1e13 is floating-point, but 1e13h is not */ + is_float = true; + } + + if (is_float) { + tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r); + return tv->t_type = TOKEN_FLOAT; + } else { + r = stdscan_copy(r, stdscan_bufptr - r); + tv->t_integer = readnum(r, &rn_error); + stdscan_pop(); + if (rn_error) { + /* some malformation occurred */ + return tv->t_type = TOKEN_ERRNUM; + } + tv->t_charptr = NULL; + return tv->t_type = TOKEN_NUM; + } + } else if (*stdscan_bufptr == '\'' || *stdscan_bufptr == '"' || + *stdscan_bufptr == '`') { + /* a quoted string */ + char start_quote = *stdscan_bufptr; + tv->t_charptr = stdscan_bufptr; + tv->t_inttwo = nasm_unquote(tv->t_charptr, &stdscan_bufptr); + if (*stdscan_bufptr != start_quote) + return tv->t_type = TOKEN_ERRSTR; + stdscan_bufptr++; /* Skip final quote */ + return tv->t_type = TOKEN_STR; + } else if (*stdscan_bufptr == '{') { + /* now we've got a decorator */ + int token_len; + + stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr); + + r = ++stdscan_bufptr; + /* + * read the entire buffer to advance the buffer pointer + * {rn-sae}, {rd-sae}, {ru-sae}, {rz-sae} contain '-' in tokens. + */ + while (nasm_isbrcchar(*stdscan_bufptr)) + stdscan_bufptr++; + + token_len = stdscan_bufptr - r; + + /* ... copy only up to DECOLEN_MAX-1 characters */ + tv->t_charptr = stdscan_copy(r, token_len < DECOLEN_MAX ? + token_len : DECOLEN_MAX - 1); + + stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr); + /* if brace is not closed properly or token is too long */ + if ((*stdscan_bufptr != '}') || (token_len > MAX_KEYWORD)) { + nasm_nonfatal("invalid decorator token inside braces"); + return tv->t_type = TOKEN_INVALID; + } + + stdscan_bufptr++; /* skip closing brace */ + + /* handle tokens inside braces */ + nasm_token_hash(tv->t_charptr, tv); + return stdscan_handle_brace(tv); + } else if (*stdscan_bufptr == ';') { + /* a comment has happened - stay */ + return tv->t_type = TOKEN_EOS; + } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '>') { + if (stdscan_bufptr[2] == '>') { + stdscan_bufptr += 3; + return tv->t_type = TOKEN_SAR; + } else { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SHR; + } + } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '<') { + stdscan_bufptr += stdscan_bufptr[2] == '<' ? 3 : 2; + return tv->t_type = TOKEN_SHL; + } else if (stdscan_bufptr[0] == '/' && stdscan_bufptr[1] == '/') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SDIV; + } else if (stdscan_bufptr[0] == '%' && stdscan_bufptr[1] == '%') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SMOD; + } else if (stdscan_bufptr[0] == '=' && stdscan_bufptr[1] == '=') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_EQ; + } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '>') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_NE; + } else if (stdscan_bufptr[0] == '!' && stdscan_bufptr[1] == '=') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_NE; + } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '=') { + if (stdscan_bufptr[2] == '>') { + stdscan_bufptr += 3; + return tv->t_type = TOKEN_LEG; + } else { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_LE; + } + } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '=') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_GE; + } else if (stdscan_bufptr[0] == '&' && stdscan_bufptr[1] == '&') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_DBL_AND; + } else if (stdscan_bufptr[0] == '^' && stdscan_bufptr[1] == '^') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_DBL_XOR; + } else if (stdscan_bufptr[0] == '|' && stdscan_bufptr[1] == '|') { + stdscan_bufptr += 2; + return tv->t_type = TOKEN_DBL_OR; + } else /* just an ordinary char */ + return tv->t_type = (uint8_t)(*stdscan_bufptr++); +} diff --git a/vere/ext/nasm/asm/stdscan.h b/vere/ext/nasm/asm/stdscan.h new file mode 100644 index 0000000..8dbc2d0 --- /dev/null +++ b/vere/ext/nasm/asm/stdscan.h @@ -0,0 +1,49 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2009 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * stdscan.h header file for stdscan.c + */ + +#ifndef NASM_STDSCAN_H +#define NASM_STDSCAN_H + +/* Standard scanner */ +void stdscan_set(char *str); +char *stdscan_get(void); +void stdscan_reset(void); +int stdscan(void *private_data, struct tokenval *tv); +int nasm_token_hash(const char *token, struct tokenval *tv); +void stdscan_cleanup(void); + +#endif diff --git a/vere/ext/nasm/asm/strfunc.c b/vere/ext/nasm/asm/strfunc.c new file mode 100644 index 0000000..236b9d2 --- /dev/null +++ b/vere/ext/nasm/asm/strfunc.c @@ -0,0 +1,359 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1996-2009 The NASM Authors - All Rights Reserved + * See the file AUTHORS included with the NASM distribution for + * the specific copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following + * conditions are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ----------------------------------------------------------------------- */ + +/* + * strfunc.c + * + * String transformation functions + */ + +#include "nasmlib.h" +#include "nasm.h" + +/* + * Convert a string in UTF-8 format to UTF-16LE + */ +static size_t utf8_to_16le(uint8_t *str, size_t len, char *op) +{ +#define EMIT(x) do { if (op) { WRITESHORT(op,x); } outlen++; } while(0) + + size_t outlen = 0; + int expect = 0; + uint8_t c; + uint32_t v = 0, vmin = 0; + + while (len--) { + c = *str++; + + if (expect) { + if ((c & 0xc0) != 0x80) { + expect = 0; + return -1; + } else { + v = (v << 6) | (c & 0x3f); + if (!--expect) { + if (v < vmin || v > 0x10ffff || + (v >= 0xd800 && v <= 0xdfff)) { + return -1; + } else if (v > 0xffff) { + v -= 0x10000; + EMIT(0xd800 | (v >> 10)); + EMIT(0xdc00 | (v & 0x3ff)); + } else { + EMIT(v); + } + } + continue; + } + } + + if (c < 0x80) { + EMIT(c); + } else if (c < 0xc0 || c >= 0xfe) { + /* Invalid UTF-8 */ + return -1; + } else if (c < 0xe0) { + v = c & 0x1f; + expect = 1; + vmin = 0x80; + } else if (c < 0xf0) { + v = c & 0x0f; + expect = 2; + vmin = 0x800; + } else if (c < 0xf8) { + v = c & 0x07; + expect = 3; + vmin = 0x10000; + } else if (c < 0xfc) { + v = c & 0x03; + expect = 4; + vmin = 0x200000; + } else { + v = c & 0x01; + expect = 5; + vmin = 0x4000000; + } + } + + return expect ? (size_t)-1 : outlen << 1; + +#undef EMIT +} + +/* + * Convert a string in UTF-8 format to UTF-16BE + */ +static size_t utf8_to_16be(uint8_t *str, size_t len, char *op) +{ +#define EMIT(x) \ + do { \ + uint16_t _y = (x); \ + if (op) { \ + WRITECHAR(op, _y >> 8); \ + WRITECHAR(op, _y); \ + } \ + outlen++; \ + } while (0) \ + + size_t outlen = 0; + int expect = 0; + uint8_t c; + uint32_t v = 0, vmin = 0; + + while (len--) { + c = *str++; + + if (expect) { + if ((c & 0xc0) != 0x80) { + expect = 0; + return -1; + } else { + v = (v << 6) | (c & 0x3f); + if (!--expect) { + if (v < vmin || v > 0x10ffff || + (v >= 0xd800 && v <= 0xdfff)) { + return -1; + } else if (v > 0xffff) { + v -= 0x10000; + EMIT(0xdc00 | (v & 0x3ff)); + EMIT(0xd800 | (v >> 10)); + } else { + EMIT(v); + } + } + continue; + } + } + + if (c < 0x80) { + EMIT(c); + } else if (c < 0xc0 || c >= 0xfe) { + /* Invalid UTF-8 */ + return -1; + } else if (c < 0xe0) { + v = c & 0x1f; + expect = 1; + vmin = 0x80; + } else if (c < 0xf0) { + v = c & 0x0f; + expect = 2; + vmin = 0x800; + } else if (c < 0xf8) { + v = c & 0x07; + expect = 3; + vmin = 0x10000; + } else if (c < 0xfc) { + v = c & 0x03; + expect = 4; + vmin = 0x200000; + } else { + v = c & 0x01; + expect = 5; + vmin = 0x4000000; + } + } + + return expect ? (size_t)-1 : outlen << 1; + +#undef EMIT +} + +/* + * Convert a string in UTF-8 format to UTF-32LE + */ +static size_t utf8_to_32le(uint8_t *str, size_t len, char *op) +{ +#define EMIT(x) do { if (op) { WRITELONG(op,x); } outlen++; } while(0) + + size_t outlen = 0; + int expect = 0; + uint8_t c; + uint32_t v = 0, vmin = 0; + + while (len--) { + c = *str++; + + if (expect) { + if ((c & 0xc0) != 0x80) { + return -1; + } else { + v = (v << 6) | (c & 0x3f); + if (!--expect) { + if (v < vmin || (v >= 0xd800 && v <= 0xdfff)) { + return -1; + } else { + EMIT(v); + } + } + continue; + } + } + + if (c < 0x80) { + EMIT(c); + } else if (c < 0xc0 || c >= 0xfe) { + /* Invalid UTF-8 */ + return -1; + } else if (c < 0xe0) { + v = c & 0x1f; + expect = 1; + vmin = 0x80; + } else if (c < 0xf0) { + v = c & 0x0f; + expect = 2; + vmin = 0x800; + } else if (c < 0xf8) { + v = c & 0x07; + expect = 3; + vmin = 0x10000; + } else if (c < 0xfc) { + v = c & 0x03; + expect = 4; + vmin = 0x200000; + } else { + v = c & 0x01; + expect = 5; + vmin = 0x4000000; + } + } + + return expect ? (size_t)-1 : outlen << 2; + +#undef EMIT +} + +/* + * Convert a string in UTF-8 format to UTF-32BE + */ +static size_t utf8_to_32be(uint8_t *str, size_t len, char *op) +{ +#define EMIT(x) \ + do { \ + uint32_t _y = (x); \ + if (op) { \ + WRITECHAR(op,_y >> 24); \ + WRITECHAR(op,_y >> 16); \ + WRITECHAR(op,_y >> 8); \ + WRITECHAR(op,_y); \ + } \ + outlen++; \ + } while (0) + + size_t outlen = 0; + int expect = 0; + uint8_t c; + uint32_t v = 0, vmin = 0; + + while (len--) { + c = *str++; + + if (expect) { + if ((c & 0xc0) != 0x80) { + return -1; + } else { + v = (v << 6) | (c & 0x3f); + if (!--expect) { + if (v < vmin || (v >= 0xd800 && v <= 0xdfff)) { + return -1; + } else { + EMIT(v); + } + } + continue; + } + } + + if (c < 0x80) { + EMIT(c); + } else if (c < 0xc0 || c >= 0xfe) { + /* Invalid UTF-8 */ + return -1; + } else if (c < 0xe0) { + v = c & 0x1f; + expect = 1; + vmin = 0x80; + } else if (c < 0xf0) { + v = c & 0x0f; + expect = 2; + vmin = 0x800; + } else if (c < 0xf8) { + v = c & 0x07; + expect = 3; + vmin = 0x10000; + } else if (c < 0xfc) { + v = c & 0x03; + expect = 4; + vmin = 0x200000; + } else { + v = c & 0x01; + expect = 5; + vmin = 0x4000000; + } + } + + return expect ? (size_t)-1 : outlen << 2; + +#undef EMIT +} + +typedef size_t (*transform_func)(uint8_t *, size_t, char *); + +/* + * Apply a specific string transform and return it in a nasm_malloc'd + * buffer, returning the length. On error, returns (size_t)-1 and no + * buffer is allocated. + */ +size_t string_transform(char *str, size_t len, char **out, enum strfunc func) +{ + /* This should match enum strfunc in nasm.h */ + static const transform_func str_transforms[] = { + utf8_to_16le, + utf8_to_16le, + utf8_to_16be, + utf8_to_32le, + utf8_to_32le, + utf8_to_32be, + }; + transform_func transform = str_transforms[func]; + size_t outlen; + uint8_t *s = (uint8_t *)str; + char *buf; + + outlen = transform(s, len, NULL); + if (outlen == (size_t)-1) + return -1; + + *out = buf = nasm_malloc(outlen+1); + buf[outlen] = '\0'; /* Forcibly null-terminate the buffer */ + return transform(s, len, buf); +} diff --git a/vere/ext/nasm/asm/tokens.dat b/vere/ext/nasm/asm/tokens.dat new file mode 100644 index 0000000..fc155b0 --- /dev/null +++ b/vere/ext/nasm/asm/tokens.dat @@ -0,0 +1,215 @@ +## -------------------------------------------------------------------------- +## +## Copyright 1996-2021 The NASM Authors - All Rights Reserved +## See the file AUTHORS included with the NASM distribution for +## the specific copyright holders. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following +## conditions are met: +## +## * Redistributions of source code must retain the above copyright +## notice, this list of conditions and the following disclaimer. +## * Redistributions in binary form must reproduce the above +## copyright notice, this list of conditions and the following +## disclaimer in the documentation and/or other materials provided +## with the distribution. +## +## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +## CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +## INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +## MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +## DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +## CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +## NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +## LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +## HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +## OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +## EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +## +## -------------------------------------------------------------------------- + +# The token parameters are in the other: +# TOKEN_TYPE, t_inttwo, t_flags, t_integer +# +# * is replaced with the token name converted to upper case. +# {xxx*yyy} is replaced with the token name stripped from the prefix +# xxx and suffix yyy before converting to upper case. + +# +# Tokens other than instructions and registers +# + +# The ? operator is a keyword, because ? is a legitimate symbol character +% TOKEN_QMARK, 0, 0, 0 +? + +% TOKEN_PREFIX, PPS_ASIZE, 0, P_* +a16 +a32 +a64 +asp + +% TOKEN_PREFIX, PPS_LOCK, 0, P_* +lock + +% TOKEN_PREFIX, PPS_OSIZE, 0, P_* +o16 +o32 +o64 +osp + +% TOKEN_PREFIX, PPS_REP, 0, P_* +rep +repe +repne +repnz +repz +xacquire +xrelease +bnd +nobnd + +% TOKEN_PREFIX, PPS_TIMES, 0, P_* +times + +% TOKEN_PREFIX, PPS_WAIT, 0, P_* +wait + +% TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_* +rex +evex +vex +vex3 +vex2 + +% TOKEN_SIZE, SIZE_*, 0, S_* +byte +word +dword +qword +tword +oword +yword +zword + +% TOKEN_SPECIAL, 0, 0, S_* +abs +far +long +near +nosplit +rel +short +strict +to + +# PTR is a legitimate symbol, but has an optional warning +% TOKEN_ID, 0, TFLAG_WARN, 0 +ptr + +# DUP is a legitimate symbol, but also has context-specific use in extops +% TOKEN_ID, 0, TFLAG_DUP, 0 +dup + +% TOKEN_FLOAT, 0, 0, 0 +__?infinity?__ +__?nan?__ +__?qnan?__ +__?snan?__ + +% TOKEN_FLOATIZE, 0, 0, FLOAT_{__?float*?__} +__?float8?__ +__?float16?__ +__?float32?__ +__?float64?__ +__?float80m?__ +__?float80e?__ +__?float128l?__ +__?float128h?__ + +% TOKEN_FLOATIZE, 0, 0, FLOAT_B{__?bfloat*?__} +__?bfloat16?__ + +% TOKEN_STRFUNC, 0, 0, STRFUNC_{__?*?__} +__?utf16?__ +__?utf16le?__ +__?utf16be?__ +__?utf32?__ +__?utf32le?__ +__?utf32be?__ + +% TOKEN_IFUNC, 0, 0, IFUNC_{__?*?__} +__?ilog2e?__ +__?ilog2w?__ +__?ilog2f?__ +__?ilog2c?__ + +% TOKEN_*, 0, 0, 0 +seg +wrt + +% TOKEN_{__?*?__}, 0, 0, 0 +__?masm_ptr?__ +__?masm_flat?__ + +% TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO{1to*} +1to2 +1to4 +1to8 +1to16 +1to32 + +% TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_{*-sae} +rn-sae +rd-sae +ru-sae +rz-sae + +% TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_* +sae +z + +# Multi-character operators. Used in ppscan(). +% TOKEN_SHR, 0, 0, 0 +>> + +% TOKEN_SAR, 0, 0, 0 +>>> + +% TOKEN_SHL, 0, 0, 0 +<< +<<< + +% TOKEN_SDIV, 0, 0, 0 +// + +% TOKEN_SMOD, 0, 0, 0 +%% + +% TOKEN_EQ, 0, 0, 0 +== + +% TOKEN_NE, 0, 0, 0 +!= +<> + +% TOKEN_LE, 0, 0, 0 +<= + +% TOKEN_GE, 0, 0, 0 +>= + +% TOKEN_LEG, 0, 0, 0 +<=> + +% TOKEN_DBL_AND, 0, 0, 0 +&& + +% TOKEN_DBL_OR, 0, 0, 0 +|| + +% TOKEN_DBL_XOR, 0, 0, 0 +^^ diff --git a/vere/ext/nasm/asm/tokens.h b/vere/ext/nasm/asm/tokens.h new file mode 100644 index 0000000..b0e9887 --- /dev/null +++ b/vere/ext/nasm/asm/tokens.h @@ -0,0 +1,11 @@ +/* + * This file is generated from insns.dat, regs.dat and token.dat + * by tokhash.pl; do not edit. + */ + +#ifndef NASM_TOKENS_H +#define NASM_TOKENS_H + +#define MAX_KEYWORD 17 /* length of longest keyword */ + +#endif /* NASM_TOKENS_H */ diff --git a/vere/ext/nasm/asm/tokhash.c b/vere/ext/nasm/asm/tokhash.c new file mode 100644 index 0000000..f3fd779 --- /dev/null +++ b/vere/ext/nasm/asm/tokhash.c @@ -0,0 +1,19045 @@ +/* + * This file is generated from insns.dat, regs.dat and token.dat + * by tokhash.pl; do not edit. + */ + +#include "compiler.h" +#include "nasm.h" +#include "hashtbl.h" +#include "insns.h" +#include "stdscan.h" + +struct tokendata { + const char *string; + uint16_t len; + int16_t tokentype; + int16_t aux; + uint16_t tokflag; + int32_t num; +}; + +int nasm_token_hash(const char *token, struct tokenval *tv) +{ +#define INVALID_HASH_ENTRY (65535/3) + static const int16_t hashdata[16384] = { + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -1301, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 57, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1955, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1222, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 401, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 659, + 0, + 0, + 1294, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 456, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1902, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1764, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 2154, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1218, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2105, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2345, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 226, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 247, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 824, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 643, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 1751, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1222, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 725, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 670, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 237, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2391, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1423, + 2570, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 302, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1334, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1836, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 493, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 898, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 716, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 758, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2233, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1678, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 230, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 170, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1479, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1932, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2351, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2137, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1613, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1261, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 1008, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + -184, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1076, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1434, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2040, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -521, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 291, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 318, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1625, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 729, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 1162, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 476, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1793, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 395, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1995, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1518, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1304, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 750, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1547, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2563, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1051, + 1602, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1435, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1882, + 0, + 1971, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1135, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1408, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1297, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 535, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 712, + 0, + 0, + 536, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2328, + INVALID_HASH_ENTRY, + 2490, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1465, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 1742, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 487, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 915, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1293, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -55, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 1901, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1986, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2240, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1541, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1596, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2262, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1422, + INVALID_HASH_ENTRY, + 0, + 2190, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1161, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1640, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 951, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2323, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1604, + INVALID_HASH_ENTRY, + -605, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 672, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2323, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 508, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2216, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 390, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2151, + INVALID_HASH_ENTRY, + 1253, + 0, + 749, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2425, + 0, + 1195, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 467, + INVALID_HASH_ENTRY, + 2558, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 822, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 945, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1029, + INVALID_HASH_ENTRY, + 1171, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 869, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 2349, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 788, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 519, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2104, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1413, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 757, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 1298, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1844, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1813, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -78, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 46, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2537, + INVALID_HASH_ENTRY, + 0, + -733, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1951, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 663, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2100, + 1291, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2506, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1805, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -30, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1972, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 192, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 580, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1217, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 873, + 2569, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1023, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1239, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + 1463, + 1687, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2229, + INVALID_HASH_ENTRY, + 0, + 991, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1865, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2044, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 215, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 2025, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2205, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + -1183, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 928, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1126, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 365, + 134, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 486, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2271, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -1881, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1736, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2184, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2562, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1175, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -152, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1669, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -45, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1146, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 187, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1137, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1389, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 6, + 919, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 68, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1477, + INVALID_HASH_ENTRY, + 1238, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1497, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 367, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 817, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1829, + 1312, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 433, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 977, + 1311, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 398, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1891, + 0, + 0, + 1292, + 0, + INVALID_HASH_ENTRY, + 852, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2002, + 0, + INVALID_HASH_ENTRY, + 0, + 1156, + 1450, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 419, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1191, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2465, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1079, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2098, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 3089, + 1409, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1637, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2310, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1102, + INVALID_HASH_ENTRY, + 2160, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1871, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 488, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1576, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1617, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 267, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 613, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 427, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 685, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 121, + 62, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2332, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 882, + 539, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 36, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 728, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1105, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1228, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1769, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 888, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -837, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1716, + 0, + INVALID_HASH_ENTRY, + 1491, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 605, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2337, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 865, + 1682, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1549, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 397, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 234, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 383, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 614, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1929, + 0, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 818, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -637, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1300, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2498, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2419, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1432, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -1299, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1213, + 504, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1641, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1587, + INVALID_HASH_ENTRY, + 2567, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 223, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2056, + 2129, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 935, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1271, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2371, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -522, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2404, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2305, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 653, + INVALID_HASH_ENTRY, + 554, + INVALID_HASH_ENTRY, + 902, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 606, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2298, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 239, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 315, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -184, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -2225, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1492, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1040, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 1758, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1936, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1404, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1062, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1930, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1554, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 1440, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2166, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2357, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2475, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2118, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1897, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1595, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 842, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2113, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 54, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 94, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 360, + INVALID_HASH_ENTRY, + 2076, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1457, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + -330, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2299, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 305, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 300, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2092, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1385, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 627, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1263, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1541, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 483, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2334, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 414, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2123, + 867, + 1787, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1748, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 729, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 271, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1032, + -279, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2407, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1513, + 0, + INVALID_HASH_ENTRY, + 1726, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1470, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -865, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 225, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 755, + 0, + 0, + INVALID_HASH_ENTRY, + 1126, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1123, + 0, + 55, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 976, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1274, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1316, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1006, + 1941, + 1287, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 442, + 2239, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 174, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1992, + 583, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1322, + 1216, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 744, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 163, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2112, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 17, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1496, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -492, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 880, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1686, + 1843, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 318, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1041, + 1632, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 723, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2526, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -400, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2492, + INVALID_HASH_ENTRY, + 2441, + 1094, + INVALID_HASH_ENTRY, + -1676, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2134, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 867, + INVALID_HASH_ENTRY, + 1260, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 654, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1768, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 766, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1780, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 814, + INVALID_HASH_ENTRY, + 0, + 114, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 680, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 791, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1730, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 758, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1241, + INVALID_HASH_ENTRY, + 2462, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1880, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 3445, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1856, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1365, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 731, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2375, + 0, + 801, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 827, + INVALID_HASH_ENTRY, + 1896, + INVALID_HASH_ENTRY, + 993, + 2358, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -80, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 386, + INVALID_HASH_ENTRY, + -492, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 1144, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2438, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1013, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1566, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 12, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2128, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 555, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 387, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 60, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1534, + INVALID_HASH_ENTRY, + 164, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1254, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 953, + 1057, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -343, + INVALID_HASH_ENTRY, + 1236, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 178, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 1985, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2061, + INVALID_HASH_ENTRY, + 2416, + INVALID_HASH_ENTRY, + 1455, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 80, + 918, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1605, + 577, + 346, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1199, + INVALID_HASH_ENTRY, + 1315, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2496, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1474, + 1030, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1288, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2033, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2247, + 155, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1390, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 602, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1401, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1188, + INVALID_HASH_ENTRY, + 1321, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2206, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1827, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2140, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1533, + 2480, + 1312, + 2321, + 71, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 816, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -53, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1944, + INVALID_HASH_ENTRY, + 1128, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 678, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 13, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 781, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 739, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 100, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 967, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 444, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1621, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1209, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2013, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 160, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1401, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 685, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2198, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 624, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -968, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2908, + 1755, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1066, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1860, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -525, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1685, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1362, + -1272, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2026, + INVALID_HASH_ENTRY, + 1077, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 979, + 2144, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1075, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -235, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -895, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 567, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 52, + INVALID_HASH_ENTRY, + 925, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 821, + 410, + 0, + INVALID_HASH_ENTRY, + 2483, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2159, + INVALID_HASH_ENTRY, + 452, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2556, + INVALID_HASH_ENTRY, + 2136, + -770, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1741, + INVALID_HASH_ENTRY, + 2346, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 79, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2182, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2424, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -981, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 913, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1086, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2408, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 498, + INVALID_HASH_ENTRY, + 969, + 919, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2446, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 904, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1486, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1976, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -702, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 367, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 3630, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1969, + 0, + INVALID_HASH_ENTRY, + 1527, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 380, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1022, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1273, + 2372, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 340, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1095, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2544, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 359, + INVALID_HASH_ENTRY, + 1330, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1221, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1402, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1995, + 204, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 328, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1063, + 0, + INVALID_HASH_ENTRY, + 1867, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -72, + 454, + 2313, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1223, + 571, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 984, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -40, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1336, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 459, + 765, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2542, + INVALID_HASH_ENTRY, + 1578, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 641, + INVALID_HASH_ENTRY, + 2503, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 372, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 976, + INVALID_HASH_ENTRY, + 1115, + INVALID_HASH_ENTRY, + 1055, + 0, + INVALID_HASH_ENTRY, + 1442, + 2514, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 525, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 334, + 1975, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 548, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 334, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1555, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 858, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1433, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1481, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2093, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1960, + 2578, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 87, + 1697, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 563, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 91, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2181, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 288, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -42, + INVALID_HASH_ENTRY, + 1205, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 879, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1588, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 455, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 211, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1993, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 981, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1200, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1078, + INVALID_HASH_ENTRY, + 2320, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 785, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 719, + 779, + INVALID_HASH_ENTRY, + 0, + 754, + 469, + 529, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 856, + 0, + INVALID_HASH_ENTRY, + 1152, + INVALID_HASH_ENTRY, + 0, + 1270, + 669, + 943, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -2213, + 709, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 608, + INVALID_HASH_ENTRY, + 517, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2024, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2484, + 293, + 1333, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1692, + INVALID_HASH_ENTRY, + 2461, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 462, + INVALID_HASH_ENTRY, + 2557, + 893, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 637, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 166, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 319, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1092, + INVALID_HASH_ENTRY, + 454, + INVALID_HASH_ENTRY, + 0, + 1681, + INVALID_HASH_ENTRY, + 181, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 2215, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2586, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1810, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1406, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 126, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 4, + INVALID_HASH_ENTRY, + 1334, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1374, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1886, + INVALID_HASH_ENTRY, + 0, + 694, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2201, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + 2530, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1912, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 769, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2518, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 940, + 619, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 492, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 34, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1185, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1522, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1568, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2437, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 399, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1317, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -9, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1130, + 0, + INVALID_HASH_ENTRY, + 2507, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 829, + INVALID_HASH_ENTRY, + 628, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 24, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1248, + INVALID_HASH_ENTRY, + 2197, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 649, + 0, + INVALID_HASH_ENTRY, + 1520, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1614, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 372, + INVALID_HASH_ENTRY, + 2187, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2331, + INVALID_HASH_ENTRY, + 1180, + INVALID_HASH_ENTRY, + 1246, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -315, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1067, + 1168, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 557, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -496, + INVALID_HASH_ENTRY, + 9, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 933, + 2248, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -582, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1210, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -358, + INVALID_HASH_ENTRY, + -1539, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2458, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1177, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -312, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2352, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 21, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2445, + INVALID_HASH_ENTRY, + 2251, + INVALID_HASH_ENTRY, + 2539, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -123, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 999, + INVALID_HASH_ENTRY, + 1078, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1575, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1237, + 2581, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 647, + INVALID_HASH_ENTRY, + 0, + 1819, + 140, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2552, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 449, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 872, + INVALID_HASH_ENTRY, + 64, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -2092, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1002, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 692, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1390, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1998, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1866, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 238, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 158, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2243, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 37, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1584, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1080, + INVALID_HASH_ENTRY, + 2085, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1872, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 42, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2155, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1686, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 777, + 219, + 893, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1733, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 1245, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 103, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 229, + 2466, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2202, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 129, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1732, + 0, + INVALID_HASH_ENTRY, + 384, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 828, + INVALID_HASH_ENTRY, + -730, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1885, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1546, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1838, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1648, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 323, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 986, + INVALID_HASH_ENTRY, + 2392, + 959, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 576, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 847, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 779, + INVALID_HASH_ENTRY, + -985, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1231, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 88, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 870, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1318, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 125, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 308, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -906, + INVALID_HASH_ENTRY, + 0, + 1220, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2179, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 394, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 502, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1783, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 809, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 956, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 7, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2174, + INVALID_HASH_ENTRY, + 77, + 1553, + INVALID_HASH_ENTRY, + 0, + 1942, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 938, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1609, + 2380, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1537, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2244, + 245, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -5, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 417, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2257, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1796, + 926, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1612, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 362, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 958, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 631, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 106, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2420, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -897, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2001, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 764, + 1298, + 2008, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 293, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -981, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2175, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 606, + INVALID_HASH_ENTRY, + 353, + 430, + 0, + 2371, + 1994, + INVALID_HASH_ENTRY, + 336, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 530, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -1600, + INVALID_HASH_ENTRY, + 48, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 274, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1724, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2152, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 562, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 792, + -1007, + 1503, + INVALID_HASH_ENTRY, + 203, + 1728, + INVALID_HASH_ENTRY, + 1087, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 320, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 43, + INVALID_HASH_ENTRY, + 294, + 564, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 331, + -734, + INVALID_HASH_ENTRY, + 1429, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 368, + INVALID_HASH_ENTRY, + 1336, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 762, + 1842, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 422, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 421, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 995, + INVALID_HASH_ENTRY, + 335, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 27, + 1214, + INVALID_HASH_ENTRY, + 1946, + 934, + INVALID_HASH_ENTRY, + 766, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2114, + INVALID_HASH_ENTRY, + 783, + 0, + 126, + 674, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -465, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1749, + INVALID_HASH_ENTRY, + 1928, + INVALID_HASH_ENTRY, + 1569, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1114, + 2521, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1438, + 2336, + INVALID_HASH_ENTRY, + 1511, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2385, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 280, + 2050, + 1607, + 639, + INVALID_HASH_ENTRY, + 697, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1752, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 840, + 329, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1283, + 874, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 666, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 1145, + INVALID_HASH_ENTRY, + 748, + 1622, + INVALID_HASH_ENTRY, + -880, + 2053, + 1025, + INVALID_HASH_ENTRY, + 1160, + INVALID_HASH_ENTRY, + 1073, + 1344, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 852, + 972, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 152, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1494, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 889, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 325, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2022, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 772, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1004, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2044, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1806, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 588, + -1630, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 399, + 1855, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1377, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 793, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 47, + INVALID_HASH_ENTRY, + 2405, + 2397, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1542, + INVALID_HASH_ENTRY, + 0, + 1802, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1716, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2523, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1543, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1131, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 706, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1701, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 789, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 3614, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 222, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 356, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 441, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1068, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1201, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1927, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 484, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 97, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -847, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 924, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1767, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2508, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 281, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 574, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1098, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1284, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1005, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2574, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1151, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2146, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 675, + 4413, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 186, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2294, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2356, + INVALID_HASH_ENTRY, + 1652, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 216, + 371, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1380, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 144, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 895, + INVALID_HASH_ENTRY, + 668, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2543, + INVALID_HASH_ENTRY, + 836, + INVALID_HASH_ENTRY, + 943, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2088, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1467, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 980, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1387, + INVALID_HASH_ENTRY, + 1540, + INVALID_HASH_ENTRY, + 1412, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 369, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 306, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -211, + 2302, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 439, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1737, + INVALID_HASH_ENTRY, + 116, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2573, + 1150, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -463, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 495, + INVALID_HASH_ENTRY, + 431, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 937, + INVALID_HASH_ENTRY, + 1832, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1661, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1702, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 481, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2130, + INVALID_HASH_ENTRY, + 2326, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 203, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 929, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2347, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 594, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 410, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1794, + 1136, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1276, + 814, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 4911, + INVALID_HASH_ENTRY, + 843, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2353, + 0, + 475, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2037, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2432, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1583, + INVALID_HASH_ENTRY, + 0, + 1057, + INVALID_HASH_ENTRY, + 539, + INVALID_HASH_ENTRY, + 545, + INVALID_HASH_ENTRY, + 1164, + INVALID_HASH_ENTRY, + 1137, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2393, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -733, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1033, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1378, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 843, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 412, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 429, + 172, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1172, + 2139, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1552, + INVALID_HASH_ENTRY, + 1892, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 482, + INVALID_HASH_ENTRY, + 1771, + INVALID_HASH_ENTRY, + 2196, + INVALID_HASH_ENTRY, + -1353, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1143, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 514, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2319, + 1890, + INVALID_HASH_ENTRY, + 922, + INVALID_HASH_ENTRY, + 0, + 2190, + 1140, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1419, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2176, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1369, + INVALID_HASH_ENTRY, + 877, + 757, + INVALID_HASH_ENTRY, + 1155, + 1154, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1336, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 960, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 987, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2982, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -247, + INVALID_HASH_ENTRY, + 188, + INVALID_HASH_ENTRY, + 0, + 1536, + INVALID_HASH_ENTRY, + 1574, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2291, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2456, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 66, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 633, + 580, + 2263, + 167, + 561, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1062, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1613, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1854, + 329, + 2238, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1909, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1660, + INVALID_HASH_ENTRY, + 850, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1723, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1386, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 701, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -2350, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -979, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2157, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -116, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2222, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 93, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 635, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 491, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1212, + INVALID_HASH_ENTRY, + -1452, + 2585, + 1759, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1133, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -635, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2439, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1801, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1948, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1940, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2529, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 377, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2403, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 277, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2374, + 409, + INVALID_HASH_ENTRY, + -1934, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 235, + 2511, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 388, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1416, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -115, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2308, + 162, + 149, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 875, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2207, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 250, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1548, + 2036, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2463, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 816, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1236, + INVALID_HASH_ENTRY, + 238, + INVALID_HASH_ENTRY, + 1, + 1182, + INVALID_HASH_ENTRY, + 2133, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1258, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1605, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1116, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1756, + 1869, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1933, + 578, + INVALID_HASH_ENTRY, + 343, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2362, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 838, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 998, + INVALID_HASH_ENTRY, + 0, + 2246, + 2431, + INVALID_HASH_ENTRY, + 2183, + 699, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 151, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1772, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 751, + -947, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1617, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2369, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 607, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 687, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 966, + 0, + -475, + INVALID_HASH_ENTRY, + 2417, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1257, + 1729, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2152, + 2142, + INVALID_HASH_ENTRY, + 32, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1642, + INVALID_HASH_ENTRY, + 2, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 286, + 0, + INVALID_HASH_ENTRY, + 1508, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2292, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1766, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1370, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 741, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 923, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1560, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 49, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 198, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2545, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1356, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 321, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2307, + 0, + 303, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2611, + INVALID_HASH_ENTRY, + 537, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2367, + 1517, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 169, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1346, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1739, + INVALID_HASH_ENTRY, + 1350, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 902, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 352, + INVALID_HASH_ENTRY, + 1509, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1176, + 2451, + INVALID_HASH_ENTRY, + 65, + INVALID_HASH_ENTRY, + 155, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1272, + INVALID_HASH_ENTRY, + 572, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 921, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1763, + 106, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1946, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1785, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 702, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 290, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1279, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -158, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 497, + 1689, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -2362, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 506, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 797, + INVALID_HASH_ENTRY, + 376, + 2415, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2343, + INVALID_HASH_ENTRY, + -1326, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 411, + 1936, + -1845, + 253, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 261, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2013, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1471, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 115, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + -352, + 367, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1939, + INVALID_HASH_ENTRY, + 2109, + 855, + INVALID_HASH_ENTRY, + 963, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1348, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2097, + 1529, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1277, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 499, + 0, + INVALID_HASH_ENTRY, + -1110, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1443, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2572, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1254, + 1644, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 783, + INVALID_HASH_ENTRY, + -308, + INVALID_HASH_ENTRY, + -285, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2389, + INVALID_HASH_ENTRY, + 1800, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1347, + 2527, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 496, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2145, + 971, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2536, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2260, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 626, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -438, + INVALID_HASH_ENTRY, + 1476, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1217, + 0, + 740, + 249, + 883, + -816, + INVALID_HASH_ENTRY, + 0, + 0, + 205, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1207, + 1275, + 1699, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 562, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 462, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1313, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2494, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2269, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 711, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1612, + 2411, + 470, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2409, + INVALID_HASH_ENTRY, + 283, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2330, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 581, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1485, + INVALID_HASH_ENTRY, + 1840, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1895, + 1465, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1874, + 0, + 1958, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 982, + 446, + -382, + -1246, + 2482, + 690, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 950, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2310, + 0, + 1514, + INVALID_HASH_ENTRY, + 515, + INVALID_HASH_ENTRY, + 15, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 464, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 622, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 711, + INVALID_HASH_ENTRY, + 620, + 2477, + INVALID_HASH_ENTRY, + 846, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 20, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 878, + -242, + 2119, + 1914, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 339, + INVALID_HASH_ENTRY, + 0, + -954, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 693, + 2027, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2211, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2256, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -813, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2064, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2082, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 105, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 667, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 241, + 191, + INVALID_HASH_ENTRY, + 0, + 2227, + INVALID_HASH_ENTRY, + -2183, + INVALID_HASH_ENTRY, + 1776, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -208, + 1373, + INVALID_HASH_ENTRY, + 1468, + 1505, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1449, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2471, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 123, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1783, + INVALID_HASH_ENTRY, + 154, + INVALID_HASH_ENTRY, + 2000, + 1653, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -809, + INVALID_HASH_ENTRY, + 2312, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 656, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1711, + INVALID_HASH_ENTRY, + 310, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 542, + INVALID_HASH_ENTRY, + 522, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -835, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + 1379, + INVALID_HASH_ENTRY, + 1826, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2490, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -141, + INVALID_HASH_ENTRY, + 1779, + INVALID_HASH_ENTRY, + 29, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 391, + INVALID_HASH_ENTRY, + 1467, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1601, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1186, + 1700, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 806, + 1343, + 0, + INVALID_HASH_ENTRY, + 1478, + INVALID_HASH_ENTRY, + 1314, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1532, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1591, + 0, + INVALID_HASH_ENTRY, + 958, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1495, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 309, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1441, + INVALID_HASH_ENTRY, + 1396, + INVALID_HASH_ENTRY, + 1189, + 1174, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 67, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -987, + -249, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2541, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1184, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -791, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1459, + 566, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 996, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -140, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2048, + INVALID_HASH_ENTRY, + 230, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2363, + INVALID_HASH_ENTRY, + 0, + 2285, + INVALID_HASH_ENTRY, + 617, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1169, + -1244, + 1570, + 2590, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 177, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2176, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1265, + INVALID_HASH_ENTRY, + 584, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2433, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1017, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1523, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1458, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2135, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1165, + 1830, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1521, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 798, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 10, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1991, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 255, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1680, + -378, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2095, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 591, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1577, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 730, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 489, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1796, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2546, + 854, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 650, + 83, + 1784, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -685, + 1673, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2410, + INVALID_HASH_ENTRY, + 906, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 541, + INVALID_HASH_ENTRY, + 1335, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2016, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2141, + INVALID_HASH_ENTRY, + 2214, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -241, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1493, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 596, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 150, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 99, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2041, + 590, + INVALID_HASH_ENTRY, + 949, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 639, + INVALID_HASH_ENTRY, + -820, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 509, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1107, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2177, + 18, + INVALID_HASH_ENTRY, + 892, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2518, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 281, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -825, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 72, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2381, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1166, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 165, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1847, + 413, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 177, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1490, + -138, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 920, + 1398, + 2485, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1161, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2587, + 1997, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 886, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2476, + 1500, + INVALID_HASH_ENTRY, + 1259, + 665, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1366, + 2497, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 358, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 660, + 423, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 131, + 2020, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1659, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2459, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1459, + -1439, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 110, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1271, + 217, + INVALID_HASH_ENTRY, + 1808, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1964, + 2186, + 894, + INVALID_HASH_ENTRY, + -1043, + 1507, + 791, + INVALID_HASH_ENTRY, + 192, + INVALID_HASH_ENTRY, + 1230, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1391, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 589, + 599, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 866, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -183, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1910, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 341, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1544, + INVALID_HASH_ENTRY, + 2793, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 587, + INVALID_HASH_ENTRY, + 1488, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 796, + 2339, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1338, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1516, + 1563, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 874, + INVALID_HASH_ENTRY, + 826, + INVALID_HASH_ENTRY, + 985, + -1247, + INVALID_HASH_ENTRY, + 2121, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 394, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1888, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1935, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 33, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 901, + INVALID_HASH_ENTRY, + 1009, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 710, + INVALID_HASH_ENTRY, + 2060, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1243, + INVALID_HASH_ENTRY, + -97, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1441, + INVALID_HASH_ENTRY, + 522, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2528, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2548, + 2249, + INVALID_HASH_ENTRY, + 26, + INVALID_HASH_ENTRY, + 236, + INVALID_HASH_ENTRY, + 392, + INVALID_HASH_ENTRY, + 2242, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 653, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -700, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 185, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 147, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1228, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -996, + 21, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 90, + INVALID_HASH_ENTRY, + 794, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1934, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -156, + 2500, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 208, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 983, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2057, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2054, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1987, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 700, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1720, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2234, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1137, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2090, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 978, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1121, + 1633, + 2531, + 1201, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1012, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1495, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 864, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2268, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 567, + INVALID_HASH_ENTRY, + 2457, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 592, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 472, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2218, + 330, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 349, + 2444, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1503, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2555, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 87, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1774, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 128, + 0, + INVALID_HASH_ENTRY, + 2253, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1212, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -465, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1440, + 932, + INVALID_HASH_ENTRY, + 618, + INVALID_HASH_ENTRY, + 1473, + 8, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -163, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 533, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2450, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1337, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1851, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 194, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -701, + 2264, + 111, + 1641, + 0, + 761, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2513, + -371, + INVALID_HASH_ENTRY, + 1559, + INVALID_HASH_ENTRY, + 1897, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 733, + 1111, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2366, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1472, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2004, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 480, + INVALID_HASH_ENTRY, + 2301, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1597, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1244, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1839, + 332, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2203, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 477, + INVALID_HASH_ENTRY, + 2467, + 2427, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 278, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 375, + INVALID_HASH_ENTRY, + 40, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1365, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1984, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 661, + 132, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 890, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 837, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2414, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 255, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 260, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1347, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1550, + 1861, + 448, + 848, + INVALID_HASH_ENTRY, + 364, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2279, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2035, + 2065, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 30, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1977, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 98, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 742, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 109, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2034, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1141, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 735, + 876, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1740, + 168, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 638, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1615, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1492, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1340, + 910, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 691, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1139, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 811, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1682, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1690, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 214, + INVALID_HASH_ENTRY, + 956, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2421, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1163, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 756, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 970, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1054, + INVALID_HASH_ENTRY, + 646, + 1818, + 1016, + 160, + -859, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 354, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 941, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 432, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 644, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 99, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 342, + INVALID_HASH_ENTRY, + -317, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 625, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1845, + INVALID_HASH_ENTRY, + 45, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1198, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1592, + INVALID_HASH_ENTRY, + 689, + 1058, + 0, + 2568, + 896, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 346, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1853, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1385, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2056, + 119, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 273, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1203, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1591, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1453, + 1792, + 1005, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 458, + INVALID_HASH_ENTRY, + 676, + INVALID_HASH_ENTRY, + -883, + INVALID_HASH_ENTRY, + 2509, + 1831, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1909, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1858, + INVALID_HASH_ENTRY, + 1068, + INVALID_HASH_ENTRY, + 0, + 1937, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1232, + INVALID_HASH_ENTRY, + 703, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -288, + INVALID_HASH_ENTRY, + 2277, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2015, + INVALID_HASH_ENTRY, + 707, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1196, + 1502, + 1000, + INVALID_HASH_ENTRY, + 2210, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1990, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 173, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2333, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2161, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 292, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 297, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1101, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 942, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 777, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1803, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1694, + 585, + 118, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1162, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1290, + 55, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 870, + INVALID_HASH_ENTRY, + 1049, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 752, + 1224, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2315, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1684, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1564, + 1709, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 86, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 28, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 597, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2117, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -2400, + INVALID_HASH_ENTRY, + 2280, + -471, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2283, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2051, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2360, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 107, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -7, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1469, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1811, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1722, + INVALID_HASH_ENTRY, + 1353, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 82, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2348, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1938, + 1286, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1664, + INVALID_HASH_ENTRY, + -294, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1645, + INVALID_HASH_ENTRY, + 2235, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2258, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1044, + 1159, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2178, + 0, + 2281, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 299, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2000, + 279, + INVALID_HASH_ENTRY, + 2158, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1678, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2300, + 0, + -1065, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1417, + 2266, + INVALID_HASH_ENTRY, + 1398, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1256, + INVALID_HASH_ENTRY, + 2324, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1367, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 737, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 863, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 50, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1325, + 720, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1132, + INVALID_HASH_ENTRY, + 1900, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 861, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2335, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1142, + INVALID_HASH_ENTRY, + 453, + INVALID_HASH_ENTRY, + 957, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 60, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 416, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2398, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1841, + INVALID_HASH_ENTRY, + 1567, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2468, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1289, + 193, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2344, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1979, + 0, + 2048, + 705, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 916, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -464, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1662, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2579, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 282, + INVALID_HASH_ENTRY, + 1918, + INVALID_HASH_ENTRY, + 242, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1683, + INVALID_HASH_ENTRY, + 1506, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1970, + INVALID_HASH_ENTRY, + 2036, + INVALID_HASH_ENTRY, + 1920, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1127, + INVALID_HASH_ENTRY, + 0, + -1669, + INVALID_HASH_ENTRY, + 1040, + 558, + INVALID_HASH_ENTRY, + 1355, + INVALID_HASH_ENTRY, + 2426, + 2489, + 2012, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 312, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2120, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 959, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2478, + 2390, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 152, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1143, + 296, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1082, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 156, + 0, + INVALID_HASH_ENTRY, + -1976, + INVALID_HASH_ENTRY, + 2208, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1028, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2066, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2232, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2224, + 476, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 0, + 726, + 988, + INVALID_HASH_ENTRY, + -806, + INVALID_HASH_ENTRY, + 1197, + 0, + INVALID_HASH_ENTRY, + 2350, + 2576, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1524, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 542, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 714, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 206, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1278, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1835, + -393, + -261, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 717, + INVALID_HASH_ENTRY, + 2180, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 748, + 1323, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2318, + 1823, + INVALID_HASH_ENTRY, + 1445, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1833, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 207, + INVALID_HASH_ENTRY, + 907, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1899, + 63, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 461, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1105, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1738, + -323, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 445, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1048, + INVALID_HASH_ENTRY, + 486, + INVALID_HASH_ENTRY, + -318, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2149, + INVALID_HASH_ENTRY, + 1281, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 166, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2395, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2473, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 587, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 311, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 338, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 157, + 1817, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2553, + 1837, + 435, + 1354, + 1071, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1586, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1138, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 389, + 75, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1937, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1026, + INVALID_HASH_ENTRY, + 1671, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 396, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1754, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 831, + 1857, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 973, + INVALID_HASH_ENTRY, + 2359, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1967, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1795, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1638, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1968, + -985, + 2571, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1096, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1922, + 1014, + INVALID_HASH_ENTRY, + 159, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2106, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1153, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1916, + 1489, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 127, + 2452, + INVALID_HASH_ENTRY, + 1090, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 677, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1674, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2436, + 58, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1345, + 1295, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2138, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2039, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1814, + 1361, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1770, + INVALID_HASH_ENTRY, + -1169, + 778, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1670, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 575, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1889, + 1718, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 359, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1158, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 183, + 2501, + 1965, + INVALID_HASH_ENTRY, + 1059, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2204, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 299, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 767, + 2259, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 884, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1932, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1267, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1816, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 121, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1735, + 0, + INVALID_HASH_ENTRY, + 1573, + INVALID_HASH_ENTRY, + 366, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1590, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1797, + INVALID_HASH_ENTRY, + 113, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1304, + 2110, + 2373, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2524, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -53, + -1231, + INVALID_HASH_ENTRY, + 651, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 572, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2156, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 134, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2428, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 944, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 688, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2101, + 1211, + INVALID_HASH_ENTRY, + 1062, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 937, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1407, + 2413, + 1925, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2029, + INVALID_HASH_ENTRY, + 2515, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1424, + INVALID_HASH_ENTRY, + 487, + 1192, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 153, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1371, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1047, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1415, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 773, + INVALID_HASH_ENTRY, + 1656, + INVALID_HASH_ENTRY, + 0, + 287, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 337, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -705, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 808, + 1505, + INVALID_HASH_ENTRY, + 2241, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 233, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 5, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2049, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 0, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -56, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 745, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2050, + 676, + INVALID_HASH_ENTRY, + 2289, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1104, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1436, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 243, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 812, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2365, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 124, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1676, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1309, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1427, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 96, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 871, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1703, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1753, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1439, + 2172, + 2237, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 802, + INVALID_HASH_ENTRY, + 1430, + INVALID_HASH_ENTRY, + 382, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2200, + 1110, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 673, + INVALID_HASH_ENTRY, + 2261, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1089, + INVALID_HASH_ENTRY, + 994, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1099, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1868, + 1634, + 930, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1084, + INVALID_HASH_ENTRY, + 413, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1561, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1606, + 1907, + INVALID_HASH_ENTRY, + 0, + 474, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2221, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 600, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 2071, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2317, + INVALID_HASH_ENTRY, + 1421, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1565, + 1119, + INVALID_HASH_ENTRY, + 1234, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 3355, + 1097, + 1711, + INVALID_HASH_ENTRY, + 131, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 655, + INVALID_HASH_ENTRY, + 74, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 968, + 2424, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 275, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2322, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1643, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1359, + INVALID_HASH_ENTRY, + 295, + 1400, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2284, + INVALID_HASH_ENTRY, + 1091, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2188, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 629, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1346, + 1815, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2517, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1983, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 3, + INVALID_HASH_ENTRY, + 1053, + 2342, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 624, + 1981, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 611, + -213, + INVALID_HASH_ENTRY, + 1036, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1630, + 619, + 1594, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 642, + INVALID_HASH_ENTRY, + 698, + 0, + -156, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 379, + 2270, + INVALID_HASH_ENTRY, + 810, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1202, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1788, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1904, + 569, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 381, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1762, + INVALID_HASH_ENTRY, + -1478, + INVALID_HASH_ENTRY, + 815, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2533, + 715, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2031, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2193, + 1188, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1820, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2087, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1996, + 1042, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1219, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1039, + 4, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1487, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 485, + -1382, + INVALID_HASH_ENTRY, + 1952, + 201, + 298, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2532, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1037, + 1665, + INVALID_HASH_ENTRY, + 2561, + 406, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1873, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 917, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 463, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1381, + 713, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1225, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 304, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 96, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2028, + INVALID_HASH_ENTRY, + 122, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 161, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2047, + 1705, + INVALID_HASH_ENTRY, + 1373, + 1672, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 990, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 800, + 2120, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 865, + 2018, + INVALID_HASH_ENTRY, + 2170, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2388, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1572, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2401, + 2274, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1260, + INVALID_HASH_ENTRY, + 634, + 92, + 1824, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1425, + -391, + -287, + 1034, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 955, + 1414, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2418, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1056, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1319, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 664, + INVALID_HASH_ENTRY, + 610, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1713, + INVALID_HASH_ENTRY, + 256, + 814, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -372, + 465, + 1324, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 617, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 662, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2435, + INVALID_HASH_ENTRY, + 1877, + 1227, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 526, + 887, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1319, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1898, + 200, + 1384, + 1999, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2164, + 1179, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 975, + INVALID_HASH_ENTRY, + 2085, + 2449, + INVALID_HASH_ENTRY, + 1073, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 410, + -400, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1210, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1282, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 193, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 505, + INVALID_HASH_ENTRY, + 117, + 1879, + 457, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 820, + INVALID_HASH_ENTRY, + 0, + 727, + 0, + INVALID_HASH_ENTRY, + 2797, + -14, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2499, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 859, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1848, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1060, + INVALID_HASH_ENTRY, + 0, + 1129, + INVALID_HASH_ENTRY, + 1070, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2074, + 1875, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1876, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1247, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 11, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -497, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1765, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 403, + INVALID_HASH_ENTRY, + 1027, + 171, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1170, + 2273, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1308, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1688, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2566, + INVALID_HASH_ENTRY, + 1178, + INVALID_HASH_ENTRY, + 330, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2683, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2540, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1639, + 38, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 199, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 408, + 832, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 145, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 376, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1747, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1974, + 1064, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2115, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 494, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -471, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + 1668, + 1993, + 1631, + INVALID_HASH_ENTRY, + 1663, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1655, + 1619, + INVALID_HASH_ENTRY, + 104, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 759, + 232, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 738, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2072, + 2275, + 1358, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2077, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1157, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1917, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2169, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 156, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1124, + INVALID_HASH_ENTRY, + 543, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 686, + INVALID_HASH_ENTRY, + 1356, + 658, + -671, + 2266, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2454, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 807, + 369, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2589, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2329, + 1778, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 154, + 682, + 385, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2481, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2293, + 220, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 400, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2126, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2525, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 263, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 478, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1989, + 167, + 1721, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1924, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 853, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 961, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -369, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 81, + 327, + 490, + 2191, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 804, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2070, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2493, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -754, + INVALID_HASH_ENTRY, + 1093, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 511, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1166, + INVALID_HASH_ENTRY, + -1464, + 213, + 908, + 2217, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1046, + 2042, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1732, + INVALID_HASH_ENTRY, + 1649, + 1949, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 228, + INVALID_HASH_ENTRY, + 254, + INVALID_HASH_ENTRY, + 1519, + INVALID_HASH_ENTRY, + 306, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -371, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1173, + 0, + 1307, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2212, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1243, + INVALID_HASH_ENTRY, + 1285, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2580, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1475, + 1568, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1375, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1045, + 393, + 148, + INVALID_HASH_ENTRY, + 3871, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 556, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1714, + INVALID_HASH_ENTRY, + 1825, + 152, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 601, + INVALID_HASH_ENTRY, + 576, + -12, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1859, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 851, + INVALID_HASH_ENTRY, + -371, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 909, + INVALID_HASH_ENTRY, + 734, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 435, + INVALID_HASH_ENTRY, + 1378, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2588, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1368, + INVALID_HASH_ENTRY, + 690, + 1122, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 841, + 1564, + 268, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 41, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 332, + INVALID_HASH_ENTRY, + -866, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1326, + INVALID_HASH_ENTRY, + 276, + INVALID_HASH_ENTRY, + 1410, + 1021, + INVALID_HASH_ENTRY, + 2472, + INVALID_HASH_ENTRY, + 1980, + 2382, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1928, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 770, + 496, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 1003, + 2394, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + 2098, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1910, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2577, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1894, + 0, + -40, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1445, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2228, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1202, + INVALID_HASH_ENTRY, + 1242, + -689, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 550, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -448, + 2470, + 1088, + 819, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 671, + INVALID_HASH_ENTRY, + -1440, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1154, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2386, + 2469, + 40, + INVALID_HASH_ENTRY, + 1988, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2316, + 1953, + INVALID_HASH_ENTRY, + 208, + 2150, + 954, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 899, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2290, + 1010, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1007, + -252, + 509, + 1102, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2399, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1782, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2584, + INVALID_HASH_ENTRY, + 1693, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2185, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1065, + 1725, + 424, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1093, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2002, + 2430, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 59, + 423, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2023, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1654, + INVALID_HASH_ENTRY, + 133, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1710, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 196, + 1357, + 507, + INVALID_HASH_ENTRY, + 2510, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2080, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2547, + 712, + 2094, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1300, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + -1047, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2348, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 153, + 270, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 534, + 440, + INVALID_HASH_ENTRY, + 2052, + 76, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 102, + 2102, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2069, + INVALID_HASH_ENTRY, + 1903, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1327, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1807, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 790, + 1043, + INVALID_HASH_ENTRY, + 603, + 2021, + INVALID_HASH_ENTRY, + 2516, + 1687, + 2412, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -187, + INVALID_HASH_ENTRY, + 1342, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1647, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2340, + 1552, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1651, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 225, + INVALID_HASH_ENTRY, + 425, + INVALID_HASH_ENTRY, + 248, + 1760, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2429, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2148, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 760, + INVALID_HASH_ENTRY, + 355, + 1393, + 1905, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 224, + -191, + INVALID_HASH_ENTRY, + 2303, + 2019, + 492, + 221, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 512, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2011, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1706, + 2378, + 1374, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 671, + INVALID_HASH_ENTRY, + -1651, + INVALID_HASH_ENTRY, + 1418, + INVALID_HASH_ENTRY, + 1011, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 911, + 1887, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1041, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1240, + 1962, + 885, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2502, + INVALID_HASH_ENTRY, + 2447, + 1978, + 1305, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 139, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1480, + 947, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1035, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 47, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2448, + INVALID_HASH_ENTRY, + 2442, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 977, + -678, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1302, + INVALID_HASH_ENTRY, + 1678, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1320, + 578, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 683, + 1943, + 1864, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 437, + INVALID_HASH_ENTRY, + 1001, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 456, + INVALID_HASH_ENTRY, + -1935, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 974, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 891, + INVALID_HASH_ENTRY, + 2185, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1624, + INVALID_HASH_ENTRY, + 1956, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 540, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -617, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2560, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1399, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 450, + 44, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1083, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 106, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1074, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -387, + INVALID_HASH_ENTRY, + 1264, + 2119, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -378, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2106, + 2295, + INVALID_HASH_ENTRY, + 1963, + INVALID_HASH_ENTRY, + 2479, + INVALID_HASH_ENTRY, + -42, + 1351, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2453, + 1090, + INVALID_HASH_ENTRY, + 1420, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 344, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 672, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2554, + 1744, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 736, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 0, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -223, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1148, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 210, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 615, + 1973, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 15, + 609, + 61, + 120, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1160, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1117, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1360, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 143, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 593, + 1717, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2081, + 1113, + 195, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1557, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 447, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1620, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1208, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 136, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -91, + 1579, + 1746, + 1251, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1950, + 2143, + 0, + 264, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2068, + 1125, + INVALID_HASH_ENTRY, + -263, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 500, + -95, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2550, + INVALID_HASH_ENTRY, + 2440, + 1451, + 2384, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1393, + 1883, + INVALID_HASH_ENTRY, + 345, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1167, + INVALID_HASH_ENTRY, + 527, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2086, + 1419, + 2058, + 965, + 695, + INVALID_HASH_ENTRY, + 1558, + 834, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 326, + 2059, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 407, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1262, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 931, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 345, + INVALID_HASH_ENTRY, + 1241, + 560, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 347, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 95, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 547, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1399, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 993, + INVALID_HASH_ENTRY, + 1482, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 983, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1926, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2488, + -959, + 348, + INVALID_HASH_ENTRY, + 1731, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 716, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 328, + 1301, + 16, + 1679, + INVALID_HASH_ENTRY, + 551, + 2017, + INVALID_HASH_ENTRY, + 1372, + -716, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1046, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 604, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2443, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 998, + 351, + 2265, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 552, + INVALID_HASH_ENTRY, + 1460, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1304, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 636, + INVALID_HASH_ENTRY, + 1667, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1194, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 468, + 285, + INVALID_HASH_ENTRY, + 616, + INVALID_HASH_ENTRY, + 2099, + INVALID_HASH_ENTRY, + 1200, + INVALID_HASH_ENTRY, + 0, + 140, + 1215, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 503, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + -1567, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 148, + INVALID_HASH_ENTRY, + 721, + 784, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1983, + 1103, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1650, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 598, + INVALID_HASH_ENTRY, + 269, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1906, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2219, + INVALID_HASH_ENTRY, + 212, + 210, + 1310, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1426, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1187, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2073, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 267, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2592, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1915, + 70, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1921, + INVALID_HASH_ENTRY, + 434, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 544, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1675, + 2559, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2220, + -555, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2455, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1691, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2116, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1618, + 1362, + 903, + INVALID_HASH_ENTRY, + 2003, + INVALID_HASH_ENTRY, + 271, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1252, + 117, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1635, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1916, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 258, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 108, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1551, + 1020, + 1896, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1628, + INVALID_HASH_ENTRY, + 1204, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1945, + INVALID_HASH_ENTRY, + 2195, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 591, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1852, + 190, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 479, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 78, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 48, + 378, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 85, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1453, + 970, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 39, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2226, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2189, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1881, + INVALID_HASH_ENTRY, + 1397, + INVALID_HASH_ENTRY, + 182, + -171, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2464, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 169, + INVALID_HASH_ENTRY, + 1303, + 1585, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1181, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2125, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 2147, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 31, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + 1893, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + INVALID_HASH_ENTRY, + }; + static const struct tokendata tokendata[2594] = { + { "db", 2, TOKEN_INSN, 0, 0, I_DB }, + { "dw", 2, TOKEN_INSN, 0, 0, I_DW }, + { "dd", 2, TOKEN_INSN, 0, 0, I_DD }, + { "dq", 2, TOKEN_INSN, 0, 0, I_DQ }, + { "dt", 2, TOKEN_INSN, 0, 0, I_DT }, + { "do", 2, TOKEN_INSN, 0, 0, I_DO }, + { "dy", 2, TOKEN_INSN, 0, 0, I_DY }, + { "dz", 2, TOKEN_INSN, 0, 0, I_DZ }, + { "resb", 4, TOKEN_INSN, 0, 0, I_RESB }, + { "resw", 4, TOKEN_INSN, 0, 0, I_RESW }, + { "resd", 4, TOKEN_INSN, 0, 0, I_RESD }, + { "resq", 4, TOKEN_INSN, 0, 0, I_RESQ }, + { "rest", 4, TOKEN_INSN, 0, 0, I_REST }, + { "reso", 4, TOKEN_INSN, 0, 0, I_RESO }, + { "resy", 4, TOKEN_INSN, 0, 0, I_RESY }, + { "resz", 4, TOKEN_INSN, 0, 0, I_RESZ }, + { "incbin", 6, TOKEN_INSN, 0, 0, I_INCBIN }, + { "aaa", 3, TOKEN_INSN, 0, 0, I_AAA }, + { "aad", 3, TOKEN_INSN, 0, 0, I_AAD }, + { "aam", 3, TOKEN_INSN, 0, 0, I_AAM }, + { "aas", 3, TOKEN_INSN, 0, 0, I_AAS }, + { "adc", 3, TOKEN_INSN, 0, 0, I_ADC }, + { "add", 3, TOKEN_INSN, 0, 0, I_ADD }, + { "and", 3, TOKEN_INSN, 0, 0, I_AND }, + { "arpl", 4, TOKEN_INSN, 0, 0, I_ARPL }, + { "bb0_reset", 9, TOKEN_INSN, 0, 0, I_BB0_RESET }, + { "bb1_reset", 9, TOKEN_INSN, 0, 0, I_BB1_RESET }, + { "bound", 5, TOKEN_INSN, 0, 0, I_BOUND }, + { "bsf", 3, TOKEN_INSN, 0, 0, I_BSF }, + { "bsr", 3, TOKEN_INSN, 0, 0, I_BSR }, + { "bswap", 5, TOKEN_INSN, 0, 0, I_BSWAP }, + { "bt", 2, TOKEN_INSN, 0, 0, I_BT }, + { "btc", 3, TOKEN_INSN, 0, 0, I_BTC }, + { "btr", 3, TOKEN_INSN, 0, 0, I_BTR }, + { "bts", 3, TOKEN_INSN, 0, 0, I_BTS }, + { "call", 4, TOKEN_INSN, 0, 0, I_CALL }, + { "cbw", 3, TOKEN_INSN, 0, 0, I_CBW }, + { "cdq", 3, TOKEN_INSN, 0, 0, I_CDQ }, + { "cdqe", 4, TOKEN_INSN, 0, 0, I_CDQE }, + { "clc", 3, TOKEN_INSN, 0, 0, I_CLC }, + { "cld", 3, TOKEN_INSN, 0, 0, I_CLD }, + { "cli", 3, TOKEN_INSN, 0, 0, I_CLI }, + { "clts", 4, TOKEN_INSN, 0, 0, I_CLTS }, + { "cmc", 3, TOKEN_INSN, 0, 0, I_CMC }, + { "cmp", 3, TOKEN_INSN, 0, 0, I_CMP }, + { "cmpsb", 5, TOKEN_INSN, 0, 0, I_CMPSB }, + { "cmpsd", 5, TOKEN_INSN, 0, 0, I_CMPSD }, + { "cmpsq", 5, TOKEN_INSN, 0, 0, I_CMPSQ }, + { "cmpsw", 5, TOKEN_INSN, 0, 0, I_CMPSW }, + { "cmpxchg", 7, TOKEN_INSN, 0, 0, I_CMPXCHG }, + { "cmpxchg486", 10, TOKEN_INSN, 0, 0, I_CMPXCHG486 }, + { "cmpxchg8b", 9, TOKEN_INSN, 0, 0, I_CMPXCHG8B }, + { "cmpxchg16b", 10, TOKEN_INSN, 0, 0, I_CMPXCHG16B }, + { "cpuid", 5, TOKEN_INSN, 0, 0, I_CPUID }, + { "cpu_read", 8, TOKEN_INSN, 0, 0, I_CPU_READ }, + { "cpu_write", 9, TOKEN_INSN, 0, 0, I_CPU_WRITE }, + { "cqo", 3, TOKEN_INSN, 0, 0, I_CQO }, + { "cwd", 3, TOKEN_INSN, 0, 0, I_CWD }, + { "cwde", 4, TOKEN_INSN, 0, 0, I_CWDE }, + { "daa", 3, TOKEN_INSN, 0, 0, I_DAA }, + { "das", 3, TOKEN_INSN, 0, 0, I_DAS }, + { "dec", 3, TOKEN_INSN, 0, 0, I_DEC }, + { "div", 3, TOKEN_INSN, 0, 0, I_DIV }, + { "dmint", 5, TOKEN_INSN, 0, 0, I_DMINT }, + { "emms", 4, TOKEN_INSN, 0, 0, I_EMMS }, + { "enter", 5, TOKEN_INSN, 0, 0, I_ENTER }, + { "equ", 3, TOKEN_INSN, 0, 0, I_EQU }, + { "f2xm1", 5, TOKEN_INSN, 0, 0, I_F2XM1 }, + { "fabs", 4, TOKEN_INSN, 0, 0, I_FABS }, + { "fadd", 4, TOKEN_INSN, 0, 0, I_FADD }, + { "faddp", 5, TOKEN_INSN, 0, 0, I_FADDP }, + { "fbld", 4, TOKEN_INSN, 0, 0, I_FBLD }, + { "fbstp", 5, TOKEN_INSN, 0, 0, I_FBSTP }, + { "fchs", 4, TOKEN_INSN, 0, 0, I_FCHS }, + { "fclex", 5, TOKEN_INSN, 0, 0, I_FCLEX }, + { "fcmovb", 6, TOKEN_INSN, 0, 0, I_FCMOVB }, + { "fcmovbe", 7, TOKEN_INSN, 0, 0, I_FCMOVBE }, + { "fcmove", 6, TOKEN_INSN, 0, 0, I_FCMOVE }, + { "fcmovnb", 7, TOKEN_INSN, 0, 0, I_FCMOVNB }, + { "fcmovnbe", 8, TOKEN_INSN, 0, 0, I_FCMOVNBE }, + { "fcmovne", 7, TOKEN_INSN, 0, 0, I_FCMOVNE }, + { "fcmovnu", 7, TOKEN_INSN, 0, 0, I_FCMOVNU }, + { "fcmovu", 6, TOKEN_INSN, 0, 0, I_FCMOVU }, + { "fcom", 4, TOKEN_INSN, 0, 0, I_FCOM }, + { "fcomi", 5, TOKEN_INSN, 0, 0, I_FCOMI }, + { "fcomip", 6, TOKEN_INSN, 0, 0, I_FCOMIP }, + { "fcomp", 5, TOKEN_INSN, 0, 0, I_FCOMP }, + { "fcompp", 6, TOKEN_INSN, 0, 0, I_FCOMPP }, + { "fcos", 4, TOKEN_INSN, 0, 0, I_FCOS }, + { "fdecstp", 7, TOKEN_INSN, 0, 0, I_FDECSTP }, + { "fdisi", 5, TOKEN_INSN, 0, 0, I_FDISI }, + { "fdiv", 4, TOKEN_INSN, 0, 0, I_FDIV }, + { "fdivp", 5, TOKEN_INSN, 0, 0, I_FDIVP }, + { "fdivr", 5, TOKEN_INSN, 0, 0, I_FDIVR }, + { "fdivrp", 6, TOKEN_INSN, 0, 0, I_FDIVRP }, + { "femms", 5, TOKEN_INSN, 0, 0, I_FEMMS }, + { "feni", 4, TOKEN_INSN, 0, 0, I_FENI }, + { "ffree", 5, TOKEN_INSN, 0, 0, I_FFREE }, + { "ffreep", 6, TOKEN_INSN, 0, 0, I_FFREEP }, + { "fiadd", 5, TOKEN_INSN, 0, 0, I_FIADD }, + { "ficom", 5, TOKEN_INSN, 0, 0, I_FICOM }, + { "ficomp", 6, TOKEN_INSN, 0, 0, I_FICOMP }, + { "fidiv", 5, TOKEN_INSN, 0, 0, I_FIDIV }, + { "fidivr", 6, TOKEN_INSN, 0, 0, I_FIDIVR }, + { "fild", 4, TOKEN_INSN, 0, 0, I_FILD }, + { "fimul", 5, TOKEN_INSN, 0, 0, I_FIMUL }, + { "fincstp", 7, TOKEN_INSN, 0, 0, I_FINCSTP }, + { "finit", 5, TOKEN_INSN, 0, 0, I_FINIT }, + { "fist", 4, TOKEN_INSN, 0, 0, I_FIST }, + { "fistp", 5, TOKEN_INSN, 0, 0, I_FISTP }, + { "fisttp", 6, TOKEN_INSN, 0, 0, I_FISTTP }, + { "fisub", 5, TOKEN_INSN, 0, 0, I_FISUB }, + { "fisubr", 6, TOKEN_INSN, 0, 0, I_FISUBR }, + { "fld", 3, TOKEN_INSN, 0, 0, I_FLD }, + { "fld1", 4, TOKEN_INSN, 0, 0, I_FLD1 }, + { "fldcw", 5, TOKEN_INSN, 0, 0, I_FLDCW }, + { "fldenv", 6, TOKEN_INSN, 0, 0, I_FLDENV }, + { "fldl2e", 6, TOKEN_INSN, 0, 0, I_FLDL2E }, + { "fldl2t", 6, TOKEN_INSN, 0, 0, I_FLDL2T }, + { "fldlg2", 6, TOKEN_INSN, 0, 0, I_FLDLG2 }, + { "fldln2", 6, TOKEN_INSN, 0, 0, I_FLDLN2 }, + { "fldpi", 5, TOKEN_INSN, 0, 0, I_FLDPI }, + { "fldz", 4, TOKEN_INSN, 0, 0, I_FLDZ }, + { "fmul", 4, TOKEN_INSN, 0, 0, I_FMUL }, + { "fmulp", 5, TOKEN_INSN, 0, 0, I_FMULP }, + { "fnclex", 6, TOKEN_INSN, 0, 0, I_FNCLEX }, + { "fndisi", 6, TOKEN_INSN, 0, 0, I_FNDISI }, + { "fneni", 5, TOKEN_INSN, 0, 0, I_FNENI }, + { "fninit", 6, TOKEN_INSN, 0, 0, I_FNINIT }, + { "fnop", 4, TOKEN_INSN, 0, 0, I_FNOP }, + { "fnsave", 6, TOKEN_INSN, 0, 0, I_FNSAVE }, + { "fnstcw", 6, TOKEN_INSN, 0, 0, I_FNSTCW }, + { "fnstenv", 7, TOKEN_INSN, 0, 0, I_FNSTENV }, + { "fnstsw", 6, TOKEN_INSN, 0, 0, I_FNSTSW }, + { "fpatan", 6, TOKEN_INSN, 0, 0, I_FPATAN }, + { "fprem", 5, TOKEN_INSN, 0, 0, I_FPREM }, + { "fprem1", 6, TOKEN_INSN, 0, 0, I_FPREM1 }, + { "fptan", 5, TOKEN_INSN, 0, 0, I_FPTAN }, + { "frndint", 7, TOKEN_INSN, 0, 0, I_FRNDINT }, + { "frstor", 6, TOKEN_INSN, 0, 0, I_FRSTOR }, + { "fsave", 5, TOKEN_INSN, 0, 0, I_FSAVE }, + { "fscale", 6, TOKEN_INSN, 0, 0, I_FSCALE }, + { "fsetpm", 6, TOKEN_INSN, 0, 0, I_FSETPM }, + { "fsin", 4, TOKEN_INSN, 0, 0, I_FSIN }, + { "fsincos", 7, TOKEN_INSN, 0, 0, I_FSINCOS }, + { "fsqrt", 5, TOKEN_INSN, 0, 0, I_FSQRT }, + { "fst", 3, TOKEN_INSN, 0, 0, I_FST }, + { "fstcw", 5, TOKEN_INSN, 0, 0, I_FSTCW }, + { "fstenv", 6, TOKEN_INSN, 0, 0, I_FSTENV }, + { "fstp", 4, TOKEN_INSN, 0, 0, I_FSTP }, + { "fstsw", 5, TOKEN_INSN, 0, 0, I_FSTSW }, + { "fsub", 4, TOKEN_INSN, 0, 0, I_FSUB }, + { "fsubp", 5, TOKEN_INSN, 0, 0, I_FSUBP }, + { "fsubr", 5, TOKEN_INSN, 0, 0, I_FSUBR }, + { "fsubrp", 6, TOKEN_INSN, 0, 0, I_FSUBRP }, + { "ftst", 4, TOKEN_INSN, 0, 0, I_FTST }, + { "fucom", 5, TOKEN_INSN, 0, 0, I_FUCOM }, + { "fucomi", 6, TOKEN_INSN, 0, 0, I_FUCOMI }, + { "fucomip", 7, TOKEN_INSN, 0, 0, I_FUCOMIP }, + { "fucomp", 6, TOKEN_INSN, 0, 0, I_FUCOMP }, + { "fucompp", 7, TOKEN_INSN, 0, 0, I_FUCOMPP }, + { "fxam", 4, TOKEN_INSN, 0, 0, I_FXAM }, + { "fxch", 4, TOKEN_INSN, 0, 0, I_FXCH }, + { "fxtract", 7, TOKEN_INSN, 0, 0, I_FXTRACT }, + { "fyl2x", 5, TOKEN_INSN, 0, 0, I_FYL2X }, + { "fyl2xp1", 7, TOKEN_INSN, 0, 0, I_FYL2XP1 }, + { "hlt", 3, TOKEN_INSN, 0, 0, I_HLT }, + { "ibts", 4, TOKEN_INSN, 0, 0, I_IBTS }, + { "icebp", 5, TOKEN_INSN, 0, 0, I_ICEBP }, + { "idiv", 4, TOKEN_INSN, 0, 0, I_IDIV }, + { "imul", 4, TOKEN_INSN, 0, 0, I_IMUL }, + { "in", 2, TOKEN_INSN, 0, 0, I_IN }, + { "inc", 3, TOKEN_INSN, 0, 0, I_INC }, + { "insb", 4, TOKEN_INSN, 0, 0, I_INSB }, + { "insd", 4, TOKEN_INSN, 0, 0, I_INSD }, + { "insw", 4, TOKEN_INSN, 0, 0, I_INSW }, + { "int", 3, TOKEN_INSN, 0, 0, I_INT }, + { "int01", 5, TOKEN_INSN, 0, 0, I_INT01 }, + { "int1", 4, TOKEN_INSN, 0, 0, I_INT1 }, + { "int03", 5, TOKEN_INSN, 0, 0, I_INT03 }, + { "int3", 4, TOKEN_INSN, 0, 0, I_INT3 }, + { "into", 4, TOKEN_INSN, 0, 0, I_INTO }, + { "invd", 4, TOKEN_INSN, 0, 0, I_INVD }, + { "invpcid", 7, TOKEN_INSN, 0, 0, I_INVPCID }, + { "invlpg", 6, TOKEN_INSN, 0, 0, I_INVLPG }, + { "invlpga", 7, TOKEN_INSN, 0, 0, I_INVLPGA }, + { "iret", 4, TOKEN_INSN, 0, 0, I_IRET }, + { "iretd", 5, TOKEN_INSN, 0, 0, I_IRETD }, + { "iretq", 5, TOKEN_INSN, 0, 0, I_IRETQ }, + { "iretw", 5, TOKEN_INSN, 0, 0, I_IRETW }, + { "jcxz", 4, TOKEN_INSN, 0, 0, I_JCXZ }, + { "jecxz", 5, TOKEN_INSN, 0, 0, I_JECXZ }, + { "jrcxz", 5, TOKEN_INSN, 0, 0, I_JRCXZ }, + { "jmp", 3, TOKEN_INSN, 0, 0, I_JMP }, + { "jmpe", 4, TOKEN_INSN, 0, 0, I_JMPE }, + { "lahf", 4, TOKEN_INSN, 0, 0, I_LAHF }, + { "lar", 3, TOKEN_INSN, 0, 0, I_LAR }, + { "lds", 3, TOKEN_INSN, 0, 0, I_LDS }, + { "lea", 3, TOKEN_INSN, 0, 0, I_LEA }, + { "leave", 5, TOKEN_INSN, 0, 0, I_LEAVE }, + { "les", 3, TOKEN_INSN, 0, 0, I_LES }, + { "lfence", 6, TOKEN_INSN, 0, 0, I_LFENCE }, + { "lfs", 3, TOKEN_INSN, 0, 0, I_LFS }, + { "lgdt", 4, TOKEN_INSN, 0, 0, I_LGDT }, + { "lgs", 3, TOKEN_INSN, 0, 0, I_LGS }, + { "lidt", 4, TOKEN_INSN, 0, 0, I_LIDT }, + { "lldt", 4, TOKEN_INSN, 0, 0, I_LLDT }, + { "lmsw", 4, TOKEN_INSN, 0, 0, I_LMSW }, + { "loadall", 7, TOKEN_INSN, 0, 0, I_LOADALL }, + { "loadall286", 10, TOKEN_INSN, 0, 0, I_LOADALL286 }, + { "lodsb", 5, TOKEN_INSN, 0, 0, I_LODSB }, + { "lodsd", 5, TOKEN_INSN, 0, 0, I_LODSD }, + { "lodsq", 5, TOKEN_INSN, 0, 0, I_LODSQ }, + { "lodsw", 5, TOKEN_INSN, 0, 0, I_LODSW }, + { "loop", 4, TOKEN_INSN, 0, 0, I_LOOP }, + { "loope", 5, TOKEN_INSN, 0, 0, I_LOOPE }, + { "loopne", 6, TOKEN_INSN, 0, 0, I_LOOPNE }, + { "loopnz", 6, TOKEN_INSN, 0, 0, I_LOOPNZ }, + { "loopz", 5, TOKEN_INSN, 0, 0, I_LOOPZ }, + { "lsl", 3, TOKEN_INSN, 0, 0, I_LSL }, + { "lss", 3, TOKEN_INSN, 0, 0, I_LSS }, + { "ltr", 3, TOKEN_INSN, 0, 0, I_LTR }, + { "mfence", 6, TOKEN_INSN, 0, 0, I_MFENCE }, + { "monitor", 7, TOKEN_INSN, 0, 0, I_MONITOR }, + { "monitorx", 8, TOKEN_INSN, 0, 0, I_MONITORX }, + { "mov", 3, TOKEN_INSN, 0, 0, I_MOV }, + { "movd", 4, TOKEN_INSN, 0, 0, I_MOVD }, + { "movq", 4, TOKEN_INSN, 0, 0, I_MOVQ }, + { "movsb", 5, TOKEN_INSN, 0, 0, I_MOVSB }, + { "movsd", 5, TOKEN_INSN, 0, 0, I_MOVSD }, + { "movsq", 5, TOKEN_INSN, 0, 0, I_MOVSQ }, + { "movsw", 5, TOKEN_INSN, 0, 0, I_MOVSW }, + { "movsx", 5, TOKEN_INSN, 0, 0, I_MOVSX }, + { "movsxd", 6, TOKEN_INSN, 0, 0, I_MOVSXD }, + { "movzx", 5, TOKEN_INSN, 0, 0, I_MOVZX }, + { "mul", 3, TOKEN_INSN, 0, 0, I_MUL }, + { "mwait", 5, TOKEN_INSN, 0, 0, I_MWAIT }, + { "mwaitx", 6, TOKEN_INSN, 0, 0, I_MWAITX }, + { "neg", 3, TOKEN_INSN, 0, 0, I_NEG }, + { "nop", 3, TOKEN_INSN, 0, 0, I_NOP }, + { "not", 3, TOKEN_INSN, 0, 0, I_NOT }, + { "or", 2, TOKEN_INSN, 0, 0, I_OR }, + { "out", 3, TOKEN_INSN, 0, 0, I_OUT }, + { "outsb", 5, TOKEN_INSN, 0, 0, I_OUTSB }, + { "outsd", 5, TOKEN_INSN, 0, 0, I_OUTSD }, + { "outsw", 5, TOKEN_INSN, 0, 0, I_OUTSW }, + { "packssdw", 8, TOKEN_INSN, 0, 0, I_PACKSSDW }, + { "packsswb", 8, TOKEN_INSN, 0, 0, I_PACKSSWB }, + { "packuswb", 8, TOKEN_INSN, 0, 0, I_PACKUSWB }, + { "paddb", 5, TOKEN_INSN, 0, 0, I_PADDB }, + { "paddd", 5, TOKEN_INSN, 0, 0, I_PADDD }, + { "paddsb", 6, TOKEN_INSN, 0, 0, I_PADDSB }, + { "paddsiw", 7, TOKEN_INSN, 0, 0, I_PADDSIW }, + { "paddsw", 6, TOKEN_INSN, 0, 0, I_PADDSW }, + { "paddusb", 7, TOKEN_INSN, 0, 0, I_PADDUSB }, + { "paddusw", 7, TOKEN_INSN, 0, 0, I_PADDUSW }, + { "paddw", 5, TOKEN_INSN, 0, 0, I_PADDW }, + { "pand", 4, TOKEN_INSN, 0, 0, I_PAND }, + { "pandn", 5, TOKEN_INSN, 0, 0, I_PANDN }, + { "pause", 5, TOKEN_INSN, 0, 0, I_PAUSE }, + { "paveb", 5, TOKEN_INSN, 0, 0, I_PAVEB }, + { "pavgusb", 7, TOKEN_INSN, 0, 0, I_PAVGUSB }, + { "pcmpeqb", 7, TOKEN_INSN, 0, 0, I_PCMPEQB }, + { "pcmpeqd", 7, TOKEN_INSN, 0, 0, I_PCMPEQD }, + { "pcmpeqw", 7, TOKEN_INSN, 0, 0, I_PCMPEQW }, + { "pcmpgtb", 7, TOKEN_INSN, 0, 0, I_PCMPGTB }, + { "pcmpgtd", 7, TOKEN_INSN, 0, 0, I_PCMPGTD }, + { "pcmpgtw", 7, TOKEN_INSN, 0, 0, I_PCMPGTW }, + { "pdistib", 7, TOKEN_INSN, 0, 0, I_PDISTIB }, + { "pf2id", 5, TOKEN_INSN, 0, 0, I_PF2ID }, + { "pfacc", 5, TOKEN_INSN, 0, 0, I_PFACC }, + { "pfadd", 5, TOKEN_INSN, 0, 0, I_PFADD }, + { "pfcmpeq", 7, TOKEN_INSN, 0, 0, I_PFCMPEQ }, + { "pfcmpge", 7, TOKEN_INSN, 0, 0, I_PFCMPGE }, + { "pfcmpgt", 7, TOKEN_INSN, 0, 0, I_PFCMPGT }, + { "pfmax", 5, TOKEN_INSN, 0, 0, I_PFMAX }, + { "pfmin", 5, TOKEN_INSN, 0, 0, I_PFMIN }, + { "pfmul", 5, TOKEN_INSN, 0, 0, I_PFMUL }, + { "pfrcp", 5, TOKEN_INSN, 0, 0, I_PFRCP }, + { "pfrcpit1", 8, TOKEN_INSN, 0, 0, I_PFRCPIT1 }, + { "pfrcpit2", 8, TOKEN_INSN, 0, 0, I_PFRCPIT2 }, + { "pfrsqit1", 8, TOKEN_INSN, 0, 0, I_PFRSQIT1 }, + { "pfrsqrt", 7, TOKEN_INSN, 0, 0, I_PFRSQRT }, + { "pfsub", 5, TOKEN_INSN, 0, 0, I_PFSUB }, + { "pfsubr", 6, TOKEN_INSN, 0, 0, I_PFSUBR }, + { "pi2fd", 5, TOKEN_INSN, 0, 0, I_PI2FD }, + { "pmachriw", 8, TOKEN_INSN, 0, 0, I_PMACHRIW }, + { "pmaddwd", 7, TOKEN_INSN, 0, 0, I_PMADDWD }, + { "pmagw", 5, TOKEN_INSN, 0, 0, I_PMAGW }, + { "pmulhriw", 8, TOKEN_INSN, 0, 0, I_PMULHRIW }, + { "pmulhrwa", 8, TOKEN_INSN, 0, 0, I_PMULHRWA }, + { "pmulhrwc", 8, TOKEN_INSN, 0, 0, I_PMULHRWC }, + { "pmulhw", 6, TOKEN_INSN, 0, 0, I_PMULHW }, + { "pmullw", 6, TOKEN_INSN, 0, 0, I_PMULLW }, + { "pmvgezb", 7, TOKEN_INSN, 0, 0, I_PMVGEZB }, + { "pmvlzb", 6, TOKEN_INSN, 0, 0, I_PMVLZB }, + { "pmvnzb", 6, TOKEN_INSN, 0, 0, I_PMVNZB }, + { "pmvzb", 5, TOKEN_INSN, 0, 0, I_PMVZB }, + { "pop", 3, TOKEN_INSN, 0, 0, I_POP }, + { "popa", 4, TOKEN_INSN, 0, 0, I_POPA }, + { "popad", 5, TOKEN_INSN, 0, 0, I_POPAD }, + { "popaw", 5, TOKEN_INSN, 0, 0, I_POPAW }, + { "popf", 4, TOKEN_INSN, 0, 0, I_POPF }, + { "popfd", 5, TOKEN_INSN, 0, 0, I_POPFD }, + { "popfq", 5, TOKEN_INSN, 0, 0, I_POPFQ }, + { "popfw", 5, TOKEN_INSN, 0, 0, I_POPFW }, + { "por", 3, TOKEN_INSN, 0, 0, I_POR }, + { "prefetch", 8, TOKEN_INSN, 0, 0, I_PREFETCH }, + { "prefetchw", 9, TOKEN_INSN, 0, 0, I_PREFETCHW }, + { "pslld", 5, TOKEN_INSN, 0, 0, I_PSLLD }, + { "psllq", 5, TOKEN_INSN, 0, 0, I_PSLLQ }, + { "psllw", 5, TOKEN_INSN, 0, 0, I_PSLLW }, + { "psrad", 5, TOKEN_INSN, 0, 0, I_PSRAD }, + { "psraw", 5, TOKEN_INSN, 0, 0, I_PSRAW }, + { "psrld", 5, TOKEN_INSN, 0, 0, I_PSRLD }, + { "psrlq", 5, TOKEN_INSN, 0, 0, I_PSRLQ }, + { "psrlw", 5, TOKEN_INSN, 0, 0, I_PSRLW }, + { "psubb", 5, TOKEN_INSN, 0, 0, I_PSUBB }, + { "psubd", 5, TOKEN_INSN, 0, 0, I_PSUBD }, + { "psubsb", 6, TOKEN_INSN, 0, 0, I_PSUBSB }, + { "psubsiw", 7, TOKEN_INSN, 0, 0, I_PSUBSIW }, + { "psubsw", 6, TOKEN_INSN, 0, 0, I_PSUBSW }, + { "psubusb", 7, TOKEN_INSN, 0, 0, I_PSUBUSB }, + { "psubusw", 7, TOKEN_INSN, 0, 0, I_PSUBUSW }, + { "psubw", 5, TOKEN_INSN, 0, 0, I_PSUBW }, + { "punpckhbw", 9, TOKEN_INSN, 0, 0, I_PUNPCKHBW }, + { "punpckhdq", 9, TOKEN_INSN, 0, 0, I_PUNPCKHDQ }, + { "punpckhwd", 9, TOKEN_INSN, 0, 0, I_PUNPCKHWD }, + { "punpcklbw", 9, TOKEN_INSN, 0, 0, I_PUNPCKLBW }, + { "punpckldq", 9, TOKEN_INSN, 0, 0, I_PUNPCKLDQ }, + { "punpcklwd", 9, TOKEN_INSN, 0, 0, I_PUNPCKLWD }, + { "push", 4, TOKEN_INSN, 0, 0, I_PUSH }, + { "pusha", 5, TOKEN_INSN, 0, 0, I_PUSHA }, + { "pushad", 6, TOKEN_INSN, 0, 0, I_PUSHAD }, + { "pushaw", 6, TOKEN_INSN, 0, 0, I_PUSHAW }, + { "pushf", 5, TOKEN_INSN, 0, 0, I_PUSHF }, + { "pushfd", 6, TOKEN_INSN, 0, 0, I_PUSHFD }, + { "pushfq", 6, TOKEN_INSN, 0, 0, I_PUSHFQ }, + { "pushfw", 6, TOKEN_INSN, 0, 0, I_PUSHFW }, + { "pxor", 4, TOKEN_INSN, 0, 0, I_PXOR }, + { "rcl", 3, TOKEN_INSN, 0, 0, I_RCL }, + { "rcr", 3, TOKEN_INSN, 0, 0, I_RCR }, + { "rdshr", 5, TOKEN_INSN, 0, 0, I_RDSHR }, + { "rdmsr", 5, TOKEN_INSN, 0, 0, I_RDMSR }, + { "rdpmc", 5, TOKEN_INSN, 0, 0, I_RDPMC }, + { "rdtsc", 5, TOKEN_INSN, 0, 0, I_RDTSC }, + { "rdtscp", 6, TOKEN_INSN, 0, 0, I_RDTSCP }, + { "ret", 3, TOKEN_INSN, 0, 0, I_RET }, + { "retf", 4, TOKEN_INSN, 0, 0, I_RETF }, + { "retn", 4, TOKEN_INSN, 0, 0, I_RETN }, + { "retw", 4, TOKEN_INSN, 0, 0, I_RETW }, + { "retfw", 5, TOKEN_INSN, 0, 0, I_RETFW }, + { "retnw", 5, TOKEN_INSN, 0, 0, I_RETNW }, + { "retd", 4, TOKEN_INSN, 0, 0, I_RETD }, + { "retfd", 5, TOKEN_INSN, 0, 0, I_RETFD }, + { "retnd", 5, TOKEN_INSN, 0, 0, I_RETND }, + { "retq", 4, TOKEN_INSN, 0, 0, I_RETQ }, + { "retfq", 5, TOKEN_INSN, 0, 0, I_RETFQ }, + { "retnq", 5, TOKEN_INSN, 0, 0, I_RETNQ }, + { "rol", 3, TOKEN_INSN, 0, 0, I_ROL }, + { "ror", 3, TOKEN_INSN, 0, 0, I_ROR }, + { "rdm", 3, TOKEN_INSN, 0, 0, I_RDM }, + { "rsdc", 4, TOKEN_INSN, 0, 0, I_RSDC }, + { "rsldt", 5, TOKEN_INSN, 0, 0, I_RSLDT }, + { "rsm", 3, TOKEN_INSN, 0, 0, I_RSM }, + { "rsts", 4, TOKEN_INSN, 0, 0, I_RSTS }, + { "sahf", 4, TOKEN_INSN, 0, 0, I_SAHF }, + { "sal", 3, TOKEN_INSN, 0, 0, I_SAL }, + { "salc", 4, TOKEN_INSN, 0, 0, I_SALC }, + { "sar", 3, TOKEN_INSN, 0, 0, I_SAR }, + { "sbb", 3, TOKEN_INSN, 0, 0, I_SBB }, + { "scasb", 5, TOKEN_INSN, 0, 0, I_SCASB }, + { "scasd", 5, TOKEN_INSN, 0, 0, I_SCASD }, + { "scasq", 5, TOKEN_INSN, 0, 0, I_SCASQ }, + { "scasw", 5, TOKEN_INSN, 0, 0, I_SCASW }, + { "sfence", 6, TOKEN_INSN, 0, 0, I_SFENCE }, + { "sgdt", 4, TOKEN_INSN, 0, 0, I_SGDT }, + { "shl", 3, TOKEN_INSN, 0, 0, I_SHL }, + { "shld", 4, TOKEN_INSN, 0, 0, I_SHLD }, + { "shr", 3, TOKEN_INSN, 0, 0, I_SHR }, + { "shrd", 4, TOKEN_INSN, 0, 0, I_SHRD }, + { "sidt", 4, TOKEN_INSN, 0, 0, I_SIDT }, + { "sldt", 4, TOKEN_INSN, 0, 0, I_SLDT }, + { "skinit", 6, TOKEN_INSN, 0, 0, I_SKINIT }, + { "smi", 3, TOKEN_INSN, 0, 0, I_SMI }, + { "smint", 5, TOKEN_INSN, 0, 0, I_SMINT }, + { "smintold", 8, TOKEN_INSN, 0, 0, I_SMINTOLD }, + { "smsw", 4, TOKEN_INSN, 0, 0, I_SMSW }, + { "stc", 3, TOKEN_INSN, 0, 0, I_STC }, + { "std", 3, TOKEN_INSN, 0, 0, I_STD }, + { "sti", 3, TOKEN_INSN, 0, 0, I_STI }, + { "stosb", 5, TOKEN_INSN, 0, 0, I_STOSB }, + { "stosd", 5, TOKEN_INSN, 0, 0, I_STOSD }, + { "stosq", 5, TOKEN_INSN, 0, 0, I_STOSQ }, + { "stosw", 5, TOKEN_INSN, 0, 0, I_STOSW }, + { "str", 3, TOKEN_INSN, 0, 0, I_STR }, + { "sub", 3, TOKEN_INSN, 0, 0, I_SUB }, + { "svdc", 4, TOKEN_INSN, 0, 0, I_SVDC }, + { "svldt", 5, TOKEN_INSN, 0, 0, I_SVLDT }, + { "svts", 4, TOKEN_INSN, 0, 0, I_SVTS }, + { "swapgs", 6, TOKEN_INSN, 0, 0, I_SWAPGS }, + { "syscall", 7, TOKEN_INSN, 0, 0, I_SYSCALL }, + { "sysenter", 8, TOKEN_INSN, 0, 0, I_SYSENTER }, + { "sysexit", 7, TOKEN_INSN, 0, 0, I_SYSEXIT }, + { "sysret", 6, TOKEN_INSN, 0, 0, I_SYSRET }, + { "test", 4, TOKEN_INSN, 0, 0, I_TEST }, + { "ud0", 3, TOKEN_INSN, 0, 0, I_UD0 }, + { "ud1", 3, TOKEN_INSN, 0, 0, I_UD1 }, + { "ud2b", 4, TOKEN_INSN, 0, 0, I_UD2B }, + { "ud2", 3, TOKEN_INSN, 0, 0, I_UD2 }, + { "ud2a", 4, TOKEN_INSN, 0, 0, I_UD2A }, + { "umov", 4, TOKEN_INSN, 0, 0, I_UMOV }, + { "verr", 4, TOKEN_INSN, 0, 0, I_VERR }, + { "verw", 4, TOKEN_INSN, 0, 0, I_VERW }, + { "fwait", 5, TOKEN_INSN, 0, 0, I_FWAIT }, + { "wbinvd", 6, TOKEN_INSN, 0, 0, I_WBINVD }, + { "wrshr", 5, TOKEN_INSN, 0, 0, I_WRSHR }, + { "wrmsr", 5, TOKEN_INSN, 0, 0, I_WRMSR }, + { "xadd", 4, TOKEN_INSN, 0, 0, I_XADD }, + { "xbts", 4, TOKEN_INSN, 0, 0, I_XBTS }, + { "xchg", 4, TOKEN_INSN, 0, 0, I_XCHG }, + { "xlatb", 5, TOKEN_INSN, 0, 0, I_XLATB }, + { "xlat", 4, TOKEN_INSN, 0, 0, I_XLAT }, + { "xor", 3, TOKEN_INSN, 0, 0, I_XOR }, + { "cmova", 5, TOKEN_INSN, 0, 0, I_CMOVA }, + { "cmovae", 6, TOKEN_INSN, 0, 0, I_CMOVAE }, + { "cmovb", 5, TOKEN_INSN, 0, 0, I_CMOVB }, + { "cmovbe", 6, TOKEN_INSN, 0, 0, I_CMOVBE }, + { "cmovc", 5, TOKEN_INSN, 0, 0, I_CMOVC }, + { "cmove", 5, TOKEN_INSN, 0, 0, I_CMOVE }, + { "cmovg", 5, TOKEN_INSN, 0, 0, I_CMOVG }, + { "cmovge", 6, TOKEN_INSN, 0, 0, I_CMOVGE }, + { "cmovl", 5, TOKEN_INSN, 0, 0, I_CMOVL }, + { "cmovle", 6, TOKEN_INSN, 0, 0, I_CMOVLE }, + { "cmovna", 6, TOKEN_INSN, 0, 0, I_CMOVNA }, + { "cmovnae", 7, TOKEN_INSN, 0, 0, I_CMOVNAE }, + { "cmovnb", 6, TOKEN_INSN, 0, 0, I_CMOVNB }, + { "cmovnbe", 7, TOKEN_INSN, 0, 0, I_CMOVNBE }, + { "cmovnc", 6, TOKEN_INSN, 0, 0, I_CMOVNC }, + { "cmovne", 6, TOKEN_INSN, 0, 0, I_CMOVNE }, + { "cmovng", 6, TOKEN_INSN, 0, 0, I_CMOVNG }, + { "cmovnge", 7, TOKEN_INSN, 0, 0, I_CMOVNGE }, + { "cmovnl", 6, TOKEN_INSN, 0, 0, I_CMOVNL }, + { "cmovnle", 7, TOKEN_INSN, 0, 0, I_CMOVNLE }, + { "cmovno", 6, TOKEN_INSN, 0, 0, I_CMOVNO }, + { "cmovnp", 6, TOKEN_INSN, 0, 0, I_CMOVNP }, + { "cmovns", 6, TOKEN_INSN, 0, 0, I_CMOVNS }, + { "cmovnz", 6, TOKEN_INSN, 0, 0, I_CMOVNZ }, + { "cmovo", 5, TOKEN_INSN, 0, 0, I_CMOVO }, + { "cmovp", 5, TOKEN_INSN, 0, 0, I_CMOVP }, + { "cmovpe", 6, TOKEN_INSN, 0, 0, I_CMOVPE }, + { "cmovpo", 6, TOKEN_INSN, 0, 0, I_CMOVPO }, + { "cmovs", 5, TOKEN_INSN, 0, 0, I_CMOVS }, + { "cmovz", 5, TOKEN_INSN, 0, 0, I_CMOVZ }, + { "ja", 2, TOKEN_INSN, 0, 0, I_JA }, + { "jae", 3, TOKEN_INSN, 0, 0, I_JAE }, + { "jb", 2, TOKEN_INSN, 0, 0, I_JB }, + { "jbe", 3, TOKEN_INSN, 0, 0, I_JBE }, + { "jc", 2, TOKEN_INSN, 0, 0, I_JC }, + { "je", 2, TOKEN_INSN, 0, 0, I_JE }, + { "jg", 2, TOKEN_INSN, 0, 0, I_JG }, + { "jge", 3, TOKEN_INSN, 0, 0, I_JGE }, + { "jl", 2, TOKEN_INSN, 0, 0, I_JL }, + { "jle", 3, TOKEN_INSN, 0, 0, I_JLE }, + { "jna", 3, TOKEN_INSN, 0, 0, I_JNA }, + { "jnae", 4, TOKEN_INSN, 0, 0, I_JNAE }, + { "jnb", 3, TOKEN_INSN, 0, 0, I_JNB }, + { "jnbe", 4, TOKEN_INSN, 0, 0, I_JNBE }, + { "jnc", 3, TOKEN_INSN, 0, 0, I_JNC }, + { "jne", 3, TOKEN_INSN, 0, 0, I_JNE }, + { "jng", 3, TOKEN_INSN, 0, 0, I_JNG }, + { "jnge", 4, TOKEN_INSN, 0, 0, I_JNGE }, + { "jnl", 3, TOKEN_INSN, 0, 0, I_JNL }, + { "jnle", 4, TOKEN_INSN, 0, 0, I_JNLE }, + { "jno", 3, TOKEN_INSN, 0, 0, I_JNO }, + { "jnp", 3, TOKEN_INSN, 0, 0, I_JNP }, + { "jns", 3, TOKEN_INSN, 0, 0, I_JNS }, + { "jnz", 3, TOKEN_INSN, 0, 0, I_JNZ }, + { "jo", 2, TOKEN_INSN, 0, 0, I_JO }, + { "jp", 2, TOKEN_INSN, 0, 0, I_JP }, + { "jpe", 3, TOKEN_INSN, 0, 0, I_JPE }, + { "jpo", 3, TOKEN_INSN, 0, 0, I_JPO }, + { "js", 2, TOKEN_INSN, 0, 0, I_JS }, + { "jz", 2, TOKEN_INSN, 0, 0, I_JZ }, + { "seta", 4, TOKEN_INSN, 0, 0, I_SETA }, + { "setae", 5, TOKEN_INSN, 0, 0, I_SETAE }, + { "setb", 4, TOKEN_INSN, 0, 0, I_SETB }, + { "setbe", 5, TOKEN_INSN, 0, 0, I_SETBE }, + { "setc", 4, TOKEN_INSN, 0, 0, I_SETC }, + { "sete", 4, TOKEN_INSN, 0, 0, I_SETE }, + { "setg", 4, TOKEN_INSN, 0, 0, I_SETG }, + { "setge", 5, TOKEN_INSN, 0, 0, I_SETGE }, + { "setl", 4, TOKEN_INSN, 0, 0, I_SETL }, + { "setle", 5, TOKEN_INSN, 0, 0, I_SETLE }, + { "setna", 5, TOKEN_INSN, 0, 0, I_SETNA }, + { "setnae", 6, TOKEN_INSN, 0, 0, I_SETNAE }, + { "setnb", 5, TOKEN_INSN, 0, 0, I_SETNB }, + { "setnbe", 6, TOKEN_INSN, 0, 0, I_SETNBE }, + { "setnc", 5, TOKEN_INSN, 0, 0, I_SETNC }, + { "setne", 5, TOKEN_INSN, 0, 0, I_SETNE }, + { "setng", 5, TOKEN_INSN, 0, 0, I_SETNG }, + { "setnge", 6, TOKEN_INSN, 0, 0, I_SETNGE }, + { "setnl", 5, TOKEN_INSN, 0, 0, I_SETNL }, + { "setnle", 6, TOKEN_INSN, 0, 0, I_SETNLE }, + { "setno", 5, TOKEN_INSN, 0, 0, I_SETNO }, + { "setnp", 5, TOKEN_INSN, 0, 0, I_SETNP }, + { "setns", 5, TOKEN_INSN, 0, 0, I_SETNS }, + { "setnz", 5, TOKEN_INSN, 0, 0, I_SETNZ }, + { "seto", 4, TOKEN_INSN, 0, 0, I_SETO }, + { "setp", 4, TOKEN_INSN, 0, 0, I_SETP }, + { "setpe", 5, TOKEN_INSN, 0, 0, I_SETPE }, + { "setpo", 5, TOKEN_INSN, 0, 0, I_SETPO }, + { "sets", 4, TOKEN_INSN, 0, 0, I_SETS }, + { "setz", 4, TOKEN_INSN, 0, 0, I_SETZ }, + { "addps", 5, TOKEN_INSN, 0, 0, I_ADDPS }, + { "addss", 5, TOKEN_INSN, 0, 0, I_ADDSS }, + { "andnps", 6, TOKEN_INSN, 0, 0, I_ANDNPS }, + { "andps", 5, TOKEN_INSN, 0, 0, I_ANDPS }, + { "cmpeqps", 7, TOKEN_INSN, 0, 0, I_CMPEQPS }, + { "cmpeqss", 7, TOKEN_INSN, 0, 0, I_CMPEQSS }, + { "cmpleps", 7, TOKEN_INSN, 0, 0, I_CMPLEPS }, + { "cmpless", 7, TOKEN_INSN, 0, 0, I_CMPLESS }, + { "cmpltps", 7, TOKEN_INSN, 0, 0, I_CMPLTPS }, + { "cmpltss", 7, TOKEN_INSN, 0, 0, I_CMPLTSS }, + { "cmpneqps", 8, TOKEN_INSN, 0, 0, I_CMPNEQPS }, + { "cmpneqss", 8, TOKEN_INSN, 0, 0, I_CMPNEQSS }, + { "cmpnleps", 8, TOKEN_INSN, 0, 0, I_CMPNLEPS }, + { "cmpnless", 8, TOKEN_INSN, 0, 0, I_CMPNLESS }, + { "cmpnltps", 8, TOKEN_INSN, 0, 0, I_CMPNLTPS }, + { "cmpnltss", 8, TOKEN_INSN, 0, 0, I_CMPNLTSS }, + { "cmpordps", 8, TOKEN_INSN, 0, 0, I_CMPORDPS }, + { "cmpordss", 8, TOKEN_INSN, 0, 0, I_CMPORDSS }, + { "cmpunordps", 10, TOKEN_INSN, 0, 0, I_CMPUNORDPS }, + { "cmpunordss", 10, TOKEN_INSN, 0, 0, I_CMPUNORDSS }, + { "cmpps", 5, TOKEN_INSN, 0, 0, I_CMPPS }, + { "cmpss", 5, TOKEN_INSN, 0, 0, I_CMPSS }, + { "comiss", 6, TOKEN_INSN, 0, 0, I_COMISS }, + { "cvtpi2ps", 8, TOKEN_INSN, 0, 0, I_CVTPI2PS }, + { "cvtps2pi", 8, TOKEN_INSN, 0, 0, I_CVTPS2PI }, + { "cvtsi2ss", 8, TOKEN_INSN, 0, 0, I_CVTSI2SS }, + { "cvtss2si", 8, TOKEN_INSN, 0, 0, I_CVTSS2SI }, + { "cvttps2pi", 9, TOKEN_INSN, 0, 0, I_CVTTPS2PI }, + { "cvttss2si", 9, TOKEN_INSN, 0, 0, I_CVTTSS2SI }, + { "divps", 5, TOKEN_INSN, 0, 0, I_DIVPS }, + { "divss", 5, TOKEN_INSN, 0, 0, I_DIVSS }, + { "ldmxcsr", 7, TOKEN_INSN, 0, 0, I_LDMXCSR }, + { "maxps", 5, TOKEN_INSN, 0, 0, I_MAXPS }, + { "maxss", 5, TOKEN_INSN, 0, 0, I_MAXSS }, + { "minps", 5, TOKEN_INSN, 0, 0, I_MINPS }, + { "minss", 5, TOKEN_INSN, 0, 0, I_MINSS }, + { "movaps", 6, TOKEN_INSN, 0, 0, I_MOVAPS }, + { "movhps", 6, TOKEN_INSN, 0, 0, I_MOVHPS }, + { "movlhps", 7, TOKEN_INSN, 0, 0, I_MOVLHPS }, + { "movlps", 6, TOKEN_INSN, 0, 0, I_MOVLPS }, + { "movhlps", 7, TOKEN_INSN, 0, 0, I_MOVHLPS }, + { "movmskps", 8, TOKEN_INSN, 0, 0, I_MOVMSKPS }, + { "movntps", 7, TOKEN_INSN, 0, 0, I_MOVNTPS }, + { "movss", 5, TOKEN_INSN, 0, 0, I_MOVSS }, + { "movups", 6, TOKEN_INSN, 0, 0, I_MOVUPS }, + { "mulps", 5, TOKEN_INSN, 0, 0, I_MULPS }, + { "mulss", 5, TOKEN_INSN, 0, 0, I_MULSS }, + { "orps", 4, TOKEN_INSN, 0, 0, I_ORPS }, + { "rcpps", 5, TOKEN_INSN, 0, 0, I_RCPPS }, + { "rcpss", 5, TOKEN_INSN, 0, 0, I_RCPSS }, + { "rsqrtps", 7, TOKEN_INSN, 0, 0, I_RSQRTPS }, + { "rsqrtss", 7, TOKEN_INSN, 0, 0, I_RSQRTSS }, + { "shufps", 6, TOKEN_INSN, 0, 0, I_SHUFPS }, + { "sqrtps", 6, TOKEN_INSN, 0, 0, I_SQRTPS }, + { "sqrtss", 6, TOKEN_INSN, 0, 0, I_SQRTSS }, + { "stmxcsr", 7, TOKEN_INSN, 0, 0, I_STMXCSR }, + { "subps", 5, TOKEN_INSN, 0, 0, I_SUBPS }, + { "subss", 5, TOKEN_INSN, 0, 0, I_SUBSS }, + { "ucomiss", 7, TOKEN_INSN, 0, 0, I_UCOMISS }, + { "unpckhps", 8, TOKEN_INSN, 0, 0, I_UNPCKHPS }, + { "unpcklps", 8, TOKEN_INSN, 0, 0, I_UNPCKLPS }, + { "xorps", 5, TOKEN_INSN, 0, 0, I_XORPS }, + { "fxrstor", 7, TOKEN_INSN, 0, 0, I_FXRSTOR }, + { "fxrstor64", 9, TOKEN_INSN, 0, 0, I_FXRSTOR64 }, + { "fxsave", 6, TOKEN_INSN, 0, 0, I_FXSAVE }, + { "fxsave64", 8, TOKEN_INSN, 0, 0, I_FXSAVE64 }, + { "xgetbv", 6, TOKEN_INSN, 0, 0, I_XGETBV }, + { "xsetbv", 6, TOKEN_INSN, 0, 0, I_XSETBV }, + { "xsave", 5, TOKEN_INSN, 0, 0, I_XSAVE }, + { "xsave64", 7, TOKEN_INSN, 0, 0, I_XSAVE64 }, + { "xsavec", 6, TOKEN_INSN, 0, 0, I_XSAVEC }, + { "xsavec64", 8, TOKEN_INSN, 0, 0, I_XSAVEC64 }, + { "xsaveopt", 8, TOKEN_INSN, 0, 0, I_XSAVEOPT }, + { "xsaveopt64", 10, TOKEN_INSN, 0, 0, I_XSAVEOPT64 }, + { "xsaves", 6, TOKEN_INSN, 0, 0, I_XSAVES }, + { "xsaves64", 8, TOKEN_INSN, 0, 0, I_XSAVES64 }, + { "xrstor", 6, TOKEN_INSN, 0, 0, I_XRSTOR }, + { "xrstor64", 8, TOKEN_INSN, 0, 0, I_XRSTOR64 }, + { "xrstors", 7, TOKEN_INSN, 0, 0, I_XRSTORS }, + { "xrstors64", 9, TOKEN_INSN, 0, 0, I_XRSTORS64 }, + { "prefetchnta", 11, TOKEN_INSN, 0, 0, I_PREFETCHNTA }, + { "prefetcht0", 10, TOKEN_INSN, 0, 0, I_PREFETCHT0 }, + { "prefetcht1", 10, TOKEN_INSN, 0, 0, I_PREFETCHT1 }, + { "prefetcht2", 10, TOKEN_INSN, 0, 0, I_PREFETCHT2 }, + { "prefetchit0", 11, TOKEN_INSN, 0, 0, I_PREFETCHIT0 }, + { "prefetchit1", 11, TOKEN_INSN, 0, 0, I_PREFETCHIT1 }, + { "maskmovq", 8, TOKEN_INSN, 0, 0, I_MASKMOVQ }, + { "movntq", 6, TOKEN_INSN, 0, 0, I_MOVNTQ }, + { "pavgb", 5, TOKEN_INSN, 0, 0, I_PAVGB }, + { "pavgw", 5, TOKEN_INSN, 0, 0, I_PAVGW }, + { "pextrw", 6, TOKEN_INSN, 0, 0, I_PEXTRW }, + { "pinsrw", 6, TOKEN_INSN, 0, 0, I_PINSRW }, + { "pmaxsw", 6, TOKEN_INSN, 0, 0, I_PMAXSW }, + { "pmaxub", 6, TOKEN_INSN, 0, 0, I_PMAXUB }, + { "pminsw", 6, TOKEN_INSN, 0, 0, I_PMINSW }, + { "pminub", 6, TOKEN_INSN, 0, 0, I_PMINUB }, + { "pmovmskb", 8, TOKEN_INSN, 0, 0, I_PMOVMSKB }, + { "pmulhuw", 7, TOKEN_INSN, 0, 0, I_PMULHUW }, + { "psadbw", 6, TOKEN_INSN, 0, 0, I_PSADBW }, + { "pshufw", 6, TOKEN_INSN, 0, 0, I_PSHUFW }, + { "pf2iw", 5, TOKEN_INSN, 0, 0, I_PF2IW }, + { "pfnacc", 6, TOKEN_INSN, 0, 0, I_PFNACC }, + { "pfpnacc", 7, TOKEN_INSN, 0, 0, I_PFPNACC }, + { "pi2fw", 5, TOKEN_INSN, 0, 0, I_PI2FW }, + { "pswapd", 6, TOKEN_INSN, 0, 0, I_PSWAPD }, + { "maskmovdqu", 10, TOKEN_INSN, 0, 0, I_MASKMOVDQU }, + { "clflush", 7, TOKEN_INSN, 0, 0, I_CLFLUSH }, + { "movntdq", 7, TOKEN_INSN, 0, 0, I_MOVNTDQ }, + { "movnti", 6, TOKEN_INSN, 0, 0, I_MOVNTI }, + { "movntpd", 7, TOKEN_INSN, 0, 0, I_MOVNTPD }, + { "movdqa", 6, TOKEN_INSN, 0, 0, I_MOVDQA }, + { "movdqu", 6, TOKEN_INSN, 0, 0, I_MOVDQU }, + { "movdq2q", 7, TOKEN_INSN, 0, 0, I_MOVDQ2Q }, + { "movq2dq", 7, TOKEN_INSN, 0, 0, I_MOVQ2DQ }, + { "paddq", 5, TOKEN_INSN, 0, 0, I_PADDQ }, + { "pmuludq", 7, TOKEN_INSN, 0, 0, I_PMULUDQ }, + { "pshufd", 6, TOKEN_INSN, 0, 0, I_PSHUFD }, + { "pshufhw", 7, TOKEN_INSN, 0, 0, I_PSHUFHW }, + { "pshuflw", 7, TOKEN_INSN, 0, 0, I_PSHUFLW }, + { "pslldq", 6, TOKEN_INSN, 0, 0, I_PSLLDQ }, + { "psrldq", 6, TOKEN_INSN, 0, 0, I_PSRLDQ }, + { "psubq", 5, TOKEN_INSN, 0, 0, I_PSUBQ }, + { "punpckhqdq", 10, TOKEN_INSN, 0, 0, I_PUNPCKHQDQ }, + { "punpcklqdq", 10, TOKEN_INSN, 0, 0, I_PUNPCKLQDQ }, + { "addpd", 5, TOKEN_INSN, 0, 0, I_ADDPD }, + { "addsd", 5, TOKEN_INSN, 0, 0, I_ADDSD }, + { "andnpd", 6, TOKEN_INSN, 0, 0, I_ANDNPD }, + { "andpd", 5, TOKEN_INSN, 0, 0, I_ANDPD }, + { "cmpeqpd", 7, TOKEN_INSN, 0, 0, I_CMPEQPD }, + { "cmpeqsd", 7, TOKEN_INSN, 0, 0, I_CMPEQSD }, + { "cmplepd", 7, TOKEN_INSN, 0, 0, I_CMPLEPD }, + { "cmplesd", 7, TOKEN_INSN, 0, 0, I_CMPLESD }, + { "cmpltpd", 7, TOKEN_INSN, 0, 0, I_CMPLTPD }, + { "cmpltsd", 7, TOKEN_INSN, 0, 0, I_CMPLTSD }, + { "cmpneqpd", 8, TOKEN_INSN, 0, 0, I_CMPNEQPD }, + { "cmpneqsd", 8, TOKEN_INSN, 0, 0, I_CMPNEQSD }, + { "cmpnlepd", 8, TOKEN_INSN, 0, 0, I_CMPNLEPD }, + { "cmpnlesd", 8, TOKEN_INSN, 0, 0, I_CMPNLESD }, + { "cmpnltpd", 8, TOKEN_INSN, 0, 0, I_CMPNLTPD }, + { "cmpnltsd", 8, TOKEN_INSN, 0, 0, I_CMPNLTSD }, + { "cmpordpd", 8, TOKEN_INSN, 0, 0, I_CMPORDPD }, + { "cmpordsd", 8, TOKEN_INSN, 0, 0, I_CMPORDSD }, + { "cmpunordpd", 10, TOKEN_INSN, 0, 0, I_CMPUNORDPD }, + { "cmpunordsd", 10, TOKEN_INSN, 0, 0, I_CMPUNORDSD }, + { "cmppd", 5, TOKEN_INSN, 0, 0, I_CMPPD }, + { "comisd", 6, TOKEN_INSN, 0, 0, I_COMISD }, + { "cvtdq2pd", 8, TOKEN_INSN, 0, 0, I_CVTDQ2PD }, + { "cvtdq2ps", 8, TOKEN_INSN, 0, 0, I_CVTDQ2PS }, + { "cvtpd2dq", 8, TOKEN_INSN, 0, 0, I_CVTPD2DQ }, + { "cvtpd2pi", 8, TOKEN_INSN, 0, 0, I_CVTPD2PI }, + { "cvtpd2ps", 8, TOKEN_INSN, 0, 0, I_CVTPD2PS }, + { "cvtpi2pd", 8, TOKEN_INSN, 0, 0, I_CVTPI2PD }, + { "cvtps2dq", 8, TOKEN_INSN, 0, 0, I_CVTPS2DQ }, + { "cvtps2pd", 8, TOKEN_INSN, 0, 0, I_CVTPS2PD }, + { "cvtsd2si", 8, TOKEN_INSN, 0, 0, I_CVTSD2SI }, + { "cvtsd2ss", 8, TOKEN_INSN, 0, 0, I_CVTSD2SS }, + { "cvtsi2sd", 8, TOKEN_INSN, 0, 0, I_CVTSI2SD }, + { "cvtss2sd", 8, TOKEN_INSN, 0, 0, I_CVTSS2SD }, + { "cvttpd2pi", 9, TOKEN_INSN, 0, 0, I_CVTTPD2PI }, + { "cvttpd2dq", 9, TOKEN_INSN, 0, 0, I_CVTTPD2DQ }, + { "cvttps2dq", 9, TOKEN_INSN, 0, 0, I_CVTTPS2DQ }, + { "cvttsd2si", 9, TOKEN_INSN, 0, 0, I_CVTTSD2SI }, + { "divpd", 5, TOKEN_INSN, 0, 0, I_DIVPD }, + { "divsd", 5, TOKEN_INSN, 0, 0, I_DIVSD }, + { "maxpd", 5, TOKEN_INSN, 0, 0, I_MAXPD }, + { "maxsd", 5, TOKEN_INSN, 0, 0, I_MAXSD }, + { "minpd", 5, TOKEN_INSN, 0, 0, I_MINPD }, + { "minsd", 5, TOKEN_INSN, 0, 0, I_MINSD }, + { "movapd", 6, TOKEN_INSN, 0, 0, I_MOVAPD }, + { "movhpd", 6, TOKEN_INSN, 0, 0, I_MOVHPD }, + { "movlpd", 6, TOKEN_INSN, 0, 0, I_MOVLPD }, + { "movmskpd", 8, TOKEN_INSN, 0, 0, I_MOVMSKPD }, + { "movupd", 6, TOKEN_INSN, 0, 0, I_MOVUPD }, + { "mulpd", 5, TOKEN_INSN, 0, 0, I_MULPD }, + { "mulsd", 5, TOKEN_INSN, 0, 0, I_MULSD }, + { "orpd", 4, TOKEN_INSN, 0, 0, I_ORPD }, + { "shufpd", 6, TOKEN_INSN, 0, 0, I_SHUFPD }, + { "sqrtpd", 6, TOKEN_INSN, 0, 0, I_SQRTPD }, + { "sqrtsd", 6, TOKEN_INSN, 0, 0, I_SQRTSD }, + { "subpd", 5, TOKEN_INSN, 0, 0, I_SUBPD }, + { "subsd", 5, TOKEN_INSN, 0, 0, I_SUBSD }, + { "ucomisd", 7, TOKEN_INSN, 0, 0, I_UCOMISD }, + { "unpckhpd", 8, TOKEN_INSN, 0, 0, I_UNPCKHPD }, + { "unpcklpd", 8, TOKEN_INSN, 0, 0, I_UNPCKLPD }, + { "xorpd", 5, TOKEN_INSN, 0, 0, I_XORPD }, + { "addsubpd", 8, TOKEN_INSN, 0, 0, I_ADDSUBPD }, + { "addsubps", 8, TOKEN_INSN, 0, 0, I_ADDSUBPS }, + { "haddpd", 6, TOKEN_INSN, 0, 0, I_HADDPD }, + { "haddps", 6, TOKEN_INSN, 0, 0, I_HADDPS }, + { "hsubpd", 6, TOKEN_INSN, 0, 0, I_HSUBPD }, + { "hsubps", 6, TOKEN_INSN, 0, 0, I_HSUBPS }, + { "lddqu", 5, TOKEN_INSN, 0, 0, I_LDDQU }, + { "movddup", 7, TOKEN_INSN, 0, 0, I_MOVDDUP }, + { "movshdup", 8, TOKEN_INSN, 0, 0, I_MOVSHDUP }, + { "movsldup", 8, TOKEN_INSN, 0, 0, I_MOVSLDUP }, + { "clgi", 4, TOKEN_INSN, 0, 0, I_CLGI }, + { "stgi", 4, TOKEN_INSN, 0, 0, I_STGI }, + { "vmcall", 6, TOKEN_INSN, 0, 0, I_VMCALL }, + { "vmclear", 7, TOKEN_INSN, 0, 0, I_VMCLEAR }, + { "vmfunc", 6, TOKEN_INSN, 0, 0, I_VMFUNC }, + { "vmlaunch", 8, TOKEN_INSN, 0, 0, I_VMLAUNCH }, + { "vmload", 6, TOKEN_INSN, 0, 0, I_VMLOAD }, + { "vmmcall", 7, TOKEN_INSN, 0, 0, I_VMMCALL }, + { "vmptrld", 7, TOKEN_INSN, 0, 0, I_VMPTRLD }, + { "vmptrst", 7, TOKEN_INSN, 0, 0, I_VMPTRST }, + { "vmread", 6, TOKEN_INSN, 0, 0, I_VMREAD }, + { "vmresume", 8, TOKEN_INSN, 0, 0, I_VMRESUME }, + { "vmrun", 5, TOKEN_INSN, 0, 0, I_VMRUN }, + { "vmsave", 6, TOKEN_INSN, 0, 0, I_VMSAVE }, + { "vmwrite", 7, TOKEN_INSN, 0, 0, I_VMWRITE }, + { "vmxoff", 6, TOKEN_INSN, 0, 0, I_VMXOFF }, + { "vmxon", 5, TOKEN_INSN, 0, 0, I_VMXON }, + { "invept", 6, TOKEN_INSN, 0, 0, I_INVEPT }, + { "invvpid", 7, TOKEN_INSN, 0, 0, I_INVVPID }, + { "pvalidate", 9, TOKEN_INSN, 0, 0, I_PVALIDATE }, + { "rmpadjust", 9, TOKEN_INSN, 0, 0, I_RMPADJUST }, + { "vmgexit", 7, TOKEN_INSN, 0, 0, I_VMGEXIT }, + { "pabsb", 5, TOKEN_INSN, 0, 0, I_PABSB }, + { "pabsw", 5, TOKEN_INSN, 0, 0, I_PABSW }, + { "pabsd", 5, TOKEN_INSN, 0, 0, I_PABSD }, + { "palignr", 7, TOKEN_INSN, 0, 0, I_PALIGNR }, + { "phaddw", 6, TOKEN_INSN, 0, 0, I_PHADDW }, + { "phaddd", 6, TOKEN_INSN, 0, 0, I_PHADDD }, + { "phaddsw", 7, TOKEN_INSN, 0, 0, I_PHADDSW }, + { "phsubw", 6, TOKEN_INSN, 0, 0, I_PHSUBW }, + { "phsubd", 6, TOKEN_INSN, 0, 0, I_PHSUBD }, + { "phsubsw", 7, TOKEN_INSN, 0, 0, I_PHSUBSW }, + { "pmaddubsw", 9, TOKEN_INSN, 0, 0, I_PMADDUBSW }, + { "pmulhrsw", 8, TOKEN_INSN, 0, 0, I_PMULHRSW }, + { "pshufb", 6, TOKEN_INSN, 0, 0, I_PSHUFB }, + { "psignb", 6, TOKEN_INSN, 0, 0, I_PSIGNB }, + { "psignw", 6, TOKEN_INSN, 0, 0, I_PSIGNW }, + { "psignd", 6, TOKEN_INSN, 0, 0, I_PSIGND }, + { "extrq", 5, TOKEN_INSN, 0, 0, I_EXTRQ }, + { "insertq", 7, TOKEN_INSN, 0, 0, I_INSERTQ }, + { "movntsd", 7, TOKEN_INSN, 0, 0, I_MOVNTSD }, + { "movntss", 7, TOKEN_INSN, 0, 0, I_MOVNTSS }, + { "lzcnt", 5, TOKEN_INSN, 0, 0, I_LZCNT }, + { "blendpd", 7, TOKEN_INSN, 0, 0, I_BLENDPD }, + { "blendps", 7, TOKEN_INSN, 0, 0, I_BLENDPS }, + { "blendvpd", 8, TOKEN_INSN, 0, 0, I_BLENDVPD }, + { "blendvps", 8, TOKEN_INSN, 0, 0, I_BLENDVPS }, + { "dppd", 4, TOKEN_INSN, 0, 0, I_DPPD }, + { "dpps", 4, TOKEN_INSN, 0, 0, I_DPPS }, + { "extractps", 9, TOKEN_INSN, 0, 0, I_EXTRACTPS }, + { "insertps", 8, TOKEN_INSN, 0, 0, I_INSERTPS }, + { "movntdqa", 8, TOKEN_INSN, 0, 0, I_MOVNTDQA }, + { "mpsadbw", 7, TOKEN_INSN, 0, 0, I_MPSADBW }, + { "packusdw", 8, TOKEN_INSN, 0, 0, I_PACKUSDW }, + { "pblendvb", 8, TOKEN_INSN, 0, 0, I_PBLENDVB }, + { "pblendw", 7, TOKEN_INSN, 0, 0, I_PBLENDW }, + { "pcmpeqq", 7, TOKEN_INSN, 0, 0, I_PCMPEQQ }, + { "pextrb", 6, TOKEN_INSN, 0, 0, I_PEXTRB }, + { "pextrd", 6, TOKEN_INSN, 0, 0, I_PEXTRD }, + { "pextrq", 6, TOKEN_INSN, 0, 0, I_PEXTRQ }, + { "phminposuw", 10, TOKEN_INSN, 0, 0, I_PHMINPOSUW }, + { "pinsrb", 6, TOKEN_INSN, 0, 0, I_PINSRB }, + { "pinsrd", 6, TOKEN_INSN, 0, 0, I_PINSRD }, + { "pinsrq", 6, TOKEN_INSN, 0, 0, I_PINSRQ }, + { "pmaxsb", 6, TOKEN_INSN, 0, 0, I_PMAXSB }, + { "pmaxsd", 6, TOKEN_INSN, 0, 0, I_PMAXSD }, + { "pmaxud", 6, TOKEN_INSN, 0, 0, I_PMAXUD }, + { "pmaxuw", 6, TOKEN_INSN, 0, 0, I_PMAXUW }, + { "pminsb", 6, TOKEN_INSN, 0, 0, I_PMINSB }, + { "pminsd", 6, TOKEN_INSN, 0, 0, I_PMINSD }, + { "pminud", 6, TOKEN_INSN, 0, 0, I_PMINUD }, + { "pminuw", 6, TOKEN_INSN, 0, 0, I_PMINUW }, + { "pmovsxbw", 8, TOKEN_INSN, 0, 0, I_PMOVSXBW }, + { "pmovsxbd", 8, TOKEN_INSN, 0, 0, I_PMOVSXBD }, + { "pmovsxbq", 8, TOKEN_INSN, 0, 0, I_PMOVSXBQ }, + { "pmovsxwd", 8, TOKEN_INSN, 0, 0, I_PMOVSXWD }, + { "pmovsxwq", 8, TOKEN_INSN, 0, 0, I_PMOVSXWQ }, + { "pmovsxdq", 8, TOKEN_INSN, 0, 0, I_PMOVSXDQ }, + { "pmovzxbw", 8, TOKEN_INSN, 0, 0, I_PMOVZXBW }, + { "pmovzxbd", 8, TOKEN_INSN, 0, 0, I_PMOVZXBD }, + { "pmovzxbq", 8, TOKEN_INSN, 0, 0, I_PMOVZXBQ }, + { "pmovzxwd", 8, TOKEN_INSN, 0, 0, I_PMOVZXWD }, + { "pmovzxwq", 8, TOKEN_INSN, 0, 0, I_PMOVZXWQ }, + { "pmovzxdq", 8, TOKEN_INSN, 0, 0, I_PMOVZXDQ }, + { "pmuldq", 6, TOKEN_INSN, 0, 0, I_PMULDQ }, + { "pmulld", 6, TOKEN_INSN, 0, 0, I_PMULLD }, + { "ptest", 5, TOKEN_INSN, 0, 0, I_PTEST }, + { "roundpd", 7, TOKEN_INSN, 0, 0, I_ROUNDPD }, + { "roundps", 7, TOKEN_INSN, 0, 0, I_ROUNDPS }, + { "roundsd", 7, TOKEN_INSN, 0, 0, I_ROUNDSD }, + { "roundss", 7, TOKEN_INSN, 0, 0, I_ROUNDSS }, + { "crc32", 5, TOKEN_INSN, 0, 0, I_CRC32 }, + { "pcmpestri", 9, TOKEN_INSN, 0, 0, I_PCMPESTRI }, + { "pcmpestrm", 9, TOKEN_INSN, 0, 0, I_PCMPESTRM }, + { "pcmpistri", 9, TOKEN_INSN, 0, 0, I_PCMPISTRI }, + { "pcmpistrm", 9, TOKEN_INSN, 0, 0, I_PCMPISTRM }, + { "pcmpgtq", 7, TOKEN_INSN, 0, 0, I_PCMPGTQ }, + { "popcnt", 6, TOKEN_INSN, 0, 0, I_POPCNT }, + { "getsec", 6, TOKEN_INSN, 0, 0, I_GETSEC }, + { "pfrcpv", 6, TOKEN_INSN, 0, 0, I_PFRCPV }, + { "pfrsqrtv", 8, TOKEN_INSN, 0, 0, I_PFRSQRTV }, + { "movbe", 5, TOKEN_INSN, 0, 0, I_MOVBE }, + { "aesenc", 6, TOKEN_INSN, 0, 0, I_AESENC }, + { "aesenclast", 10, TOKEN_INSN, 0, 0, I_AESENCLAST }, + { "aesdec", 6, TOKEN_INSN, 0, 0, I_AESDEC }, + { "aesdeclast", 10, TOKEN_INSN, 0, 0, I_AESDECLAST }, + { "aesimc", 6, TOKEN_INSN, 0, 0, I_AESIMC }, + { "aeskeygenassist", 15, TOKEN_INSN, 0, 0, I_AESKEYGENASSIST }, + { "vaesenc", 7, TOKEN_INSN, 0, 0, I_VAESENC }, + { "vaesenclast", 11, TOKEN_INSN, 0, 0, I_VAESENCLAST }, + { "vaesdec", 7, TOKEN_INSN, 0, 0, I_VAESDEC }, + { "vaesdeclast", 11, TOKEN_INSN, 0, 0, I_VAESDECLAST }, + { "vaesimc", 7, TOKEN_INSN, 0, 0, I_VAESIMC }, + { "vaeskeygenassist", 16, TOKEN_INSN, 0, 0, I_VAESKEYGENASSIST }, + { "vaddpd", 6, TOKEN_INSN, 0, 0, I_VADDPD }, + { "vaddps", 6, TOKEN_INSN, 0, 0, I_VADDPS }, + { "vaddsd", 6, TOKEN_INSN, 0, 0, I_VADDSD }, + { "vaddss", 6, TOKEN_INSN, 0, 0, I_VADDSS }, + { "vaddsubpd", 9, TOKEN_INSN, 0, 0, I_VADDSUBPD }, + { "vaddsubps", 9, TOKEN_INSN, 0, 0, I_VADDSUBPS }, + { "vandpd", 6, TOKEN_INSN, 0, 0, I_VANDPD }, + { "vandps", 6, TOKEN_INSN, 0, 0, I_VANDPS }, + { "vandnpd", 7, TOKEN_INSN, 0, 0, I_VANDNPD }, + { "vandnps", 7, TOKEN_INSN, 0, 0, I_VANDNPS }, + { "vblendpd", 8, TOKEN_INSN, 0, 0, I_VBLENDPD }, + { "vblendps", 8, TOKEN_INSN, 0, 0, I_VBLENDPS }, + { "vblendvpd", 9, TOKEN_INSN, 0, 0, I_VBLENDVPD }, + { "vblendvps", 9, TOKEN_INSN, 0, 0, I_VBLENDVPS }, + { "vbroadcastss", 12, TOKEN_INSN, 0, 0, I_VBROADCASTSS }, + { "vbroadcastsd", 12, TOKEN_INSN, 0, 0, I_VBROADCASTSD }, + { "vbroadcastf128", 14, TOKEN_INSN, 0, 0, I_VBROADCASTF128 }, + { "vcmpeq_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSPD }, + { "vcmpeqpd", 8, TOKEN_INSN, 0, 0, I_VCMPEQPD }, + { "vcmplt_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSPD }, + { "vcmpltpd", 8, TOKEN_INSN, 0, 0, I_VCMPLTPD }, + { "vcmple_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSPD }, + { "vcmplepd", 8, TOKEN_INSN, 0, 0, I_VCMPLEPD }, + { "vcmpunord_qpd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QPD }, + { "vcmpunordpd", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDPD }, + { "vcmpneq_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQPD }, + { "vcmpneqpd", 9, TOKEN_INSN, 0, 0, I_VCMPNEQPD }, + { "vcmpnlt_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USPD }, + { "vcmpnltpd", 9, TOKEN_INSN, 0, 0, I_VCMPNLTPD }, + { "vcmpnle_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USPD }, + { "vcmpnlepd", 9, TOKEN_INSN, 0, 0, I_VCMPNLEPD }, + { "vcmpord_qpd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QPD }, + { "vcmpordpd", 9, TOKEN_INSN, 0, 0, I_VCMPORDPD }, + { "vcmpeq_uqpd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQPD }, + { "vcmpnge_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USPD }, + { "vcmpngepd", 9, TOKEN_INSN, 0, 0, I_VCMPNGEPD }, + { "vcmpngt_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USPD }, + { "vcmpngtpd", 9, TOKEN_INSN, 0, 0, I_VCMPNGTPD }, + { "vcmpfalse_oqpd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQPD }, + { "vcmpfalsepd", 11, TOKEN_INSN, 0, 0, I_VCMPFALSEPD }, + { "vcmpneq_oqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQPD }, + { "vcmpge_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSPD }, + { "vcmpgepd", 8, TOKEN_INSN, 0, 0, I_VCMPGEPD }, + { "vcmpgt_ospd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSPD }, + { "vcmpgtpd", 8, TOKEN_INSN, 0, 0, I_VCMPGTPD }, + { "vcmptrue_uqpd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQPD }, + { "vcmptruepd", 10, TOKEN_INSN, 0, 0, I_VCMPTRUEPD }, + { "vcmplt_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQPD }, + { "vcmple_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQPD }, + { "vcmpunord_spd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SPD }, + { "vcmpneq_uspd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USPD }, + { "vcmpnlt_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQPD }, + { "vcmpnle_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQPD }, + { "vcmpord_spd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SPD }, + { "vcmpeq_uspd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USPD }, + { "vcmpnge_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQPD }, + { "vcmpngt_uqpd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQPD }, + { "vcmpfalse_ospd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSPD }, + { "vcmpneq_ospd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSPD }, + { "vcmpge_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQPD }, + { "vcmpgt_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQPD }, + { "vcmptrue_uspd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USPD }, + { "vcmppd", 6, TOKEN_INSN, 0, 0, I_VCMPPD }, + { "vcmpeq_osps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSPS }, + { "vcmpeqps", 8, TOKEN_INSN, 0, 0, I_VCMPEQPS }, + { "vcmplt_osps", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSPS }, + { "vcmpltps", 8, TOKEN_INSN, 0, 0, I_VCMPLTPS }, + { "vcmple_osps", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSPS }, + { "vcmpleps", 8, TOKEN_INSN, 0, 0, I_VCMPLEPS }, + { "vcmpunord_qps", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QPS }, + { "vcmpunordps", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDPS }, + { "vcmpneq_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQPS }, + { "vcmpneqps", 9, TOKEN_INSN, 0, 0, I_VCMPNEQPS }, + { "vcmpnlt_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USPS }, + { "vcmpnltps", 9, TOKEN_INSN, 0, 0, I_VCMPNLTPS }, + { "vcmpnle_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USPS }, + { "vcmpnleps", 9, TOKEN_INSN, 0, 0, I_VCMPNLEPS }, + { "vcmpord_qps", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QPS }, + { "vcmpordps", 9, TOKEN_INSN, 0, 0, I_VCMPORDPS }, + { "vcmpeq_uqps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQPS }, + { "vcmpnge_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USPS }, + { "vcmpngeps", 9, TOKEN_INSN, 0, 0, I_VCMPNGEPS }, + { "vcmpngt_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USPS }, + { "vcmpngtps", 9, TOKEN_INSN, 0, 0, I_VCMPNGTPS }, + { "vcmpfalse_oqps", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQPS }, + { "vcmpfalseps", 11, TOKEN_INSN, 0, 0, I_VCMPFALSEPS }, + { "vcmpneq_oqps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQPS }, + { "vcmpge_osps", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSPS }, + { "vcmpgeps", 8, TOKEN_INSN, 0, 0, I_VCMPGEPS }, + { "vcmpgt_osps", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSPS }, + { "vcmpgtps", 8, TOKEN_INSN, 0, 0, I_VCMPGTPS }, + { "vcmptrue_uqps", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQPS }, + { "vcmptrueps", 10, TOKEN_INSN, 0, 0, I_VCMPTRUEPS }, + { "vcmplt_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQPS }, + { "vcmple_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQPS }, + { "vcmpunord_sps", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SPS }, + { "vcmpneq_usps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USPS }, + { "vcmpnlt_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQPS }, + { "vcmpnle_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQPS }, + { "vcmpord_sps", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SPS }, + { "vcmpeq_usps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USPS }, + { "vcmpnge_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQPS }, + { "vcmpngt_uqps", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQPS }, + { "vcmpfalse_osps", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSPS }, + { "vcmpneq_osps", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSPS }, + { "vcmpge_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQPS }, + { "vcmpgt_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQPS }, + { "vcmptrue_usps", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USPS }, + { "vcmpps", 6, TOKEN_INSN, 0, 0, I_VCMPPS }, + { "vcmpeq_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSSD }, + { "vcmpeqsd", 8, TOKEN_INSN, 0, 0, I_VCMPEQSD }, + { "vcmplt_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSSD }, + { "vcmpltsd", 8, TOKEN_INSN, 0, 0, I_VCMPLTSD }, + { "vcmple_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSSD }, + { "vcmplesd", 8, TOKEN_INSN, 0, 0, I_VCMPLESD }, + { "vcmpunord_qsd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QSD }, + { "vcmpunordsd", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDSD }, + { "vcmpneq_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQSD }, + { "vcmpneqsd", 9, TOKEN_INSN, 0, 0, I_VCMPNEQSD }, + { "vcmpnlt_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USSD }, + { "vcmpnltsd", 9, TOKEN_INSN, 0, 0, I_VCMPNLTSD }, + { "vcmpnle_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USSD }, + { "vcmpnlesd", 9, TOKEN_INSN, 0, 0, I_VCMPNLESD }, + { "vcmpord_qsd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QSD }, + { "vcmpordsd", 9, TOKEN_INSN, 0, 0, I_VCMPORDSD }, + { "vcmpeq_uqsd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQSD }, + { "vcmpnge_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USSD }, + { "vcmpngesd", 9, TOKEN_INSN, 0, 0, I_VCMPNGESD }, + { "vcmpngt_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USSD }, + { "vcmpngtsd", 9, TOKEN_INSN, 0, 0, I_VCMPNGTSD }, + { "vcmpfalse_oqsd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQSD }, + { "vcmpfalsesd", 11, TOKEN_INSN, 0, 0, I_VCMPFALSESD }, + { "vcmpneq_oqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQSD }, + { "vcmpge_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSSD }, + { "vcmpgesd", 8, TOKEN_INSN, 0, 0, I_VCMPGESD }, + { "vcmpgt_ossd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSSD }, + { "vcmpgtsd", 8, TOKEN_INSN, 0, 0, I_VCMPGTSD }, + { "vcmptrue_uqsd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQSD }, + { "vcmptruesd", 10, TOKEN_INSN, 0, 0, I_VCMPTRUESD }, + { "vcmplt_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQSD }, + { "vcmple_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQSD }, + { "vcmpunord_ssd", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SSD }, + { "vcmpneq_ussd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USSD }, + { "vcmpnlt_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQSD }, + { "vcmpnle_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQSD }, + { "vcmpord_ssd", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SSD }, + { "vcmpeq_ussd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USSD }, + { "vcmpnge_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQSD }, + { "vcmpngt_uqsd", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQSD }, + { "vcmpfalse_ossd", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSSD }, + { "vcmpneq_ossd", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSSD }, + { "vcmpge_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQSD }, + { "vcmpgt_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQSD }, + { "vcmptrue_ussd", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USSD }, + { "vcmpsd", 6, TOKEN_INSN, 0, 0, I_VCMPSD }, + { "vcmpeq_osss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OSSS }, + { "vcmpeqss", 8, TOKEN_INSN, 0, 0, I_VCMPEQSS }, + { "vcmplt_osss", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OSSS }, + { "vcmpltss", 8, TOKEN_INSN, 0, 0, I_VCMPLTSS }, + { "vcmple_osss", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OSSS }, + { "vcmpless", 8, TOKEN_INSN, 0, 0, I_VCMPLESS }, + { "vcmpunord_qss", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_QSS }, + { "vcmpunordss", 11, TOKEN_INSN, 0, 0, I_VCMPUNORDSS }, + { "vcmpneq_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_UQSS }, + { "vcmpneqss", 9, TOKEN_INSN, 0, 0, I_VCMPNEQSS }, + { "vcmpnlt_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_USSS }, + { "vcmpnltss", 9, TOKEN_INSN, 0, 0, I_VCMPNLTSS }, + { "vcmpnle_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_USSS }, + { "vcmpnless", 9, TOKEN_INSN, 0, 0, I_VCMPNLESS }, + { "vcmpord_qss", 11, TOKEN_INSN, 0, 0, I_VCMPORD_QSS }, + { "vcmpordss", 9, TOKEN_INSN, 0, 0, I_VCMPORDSS }, + { "vcmpeq_uqss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_UQSS }, + { "vcmpnge_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_USSS }, + { "vcmpngess", 9, TOKEN_INSN, 0, 0, I_VCMPNGESS }, + { "vcmpngt_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_USSS }, + { "vcmpngtss", 9, TOKEN_INSN, 0, 0, I_VCMPNGTSS }, + { "vcmpfalse_oqss", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OQSS }, + { "vcmpfalsess", 11, TOKEN_INSN, 0, 0, I_VCMPFALSESS }, + { "vcmpneq_oqss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OQSS }, + { "vcmpge_osss", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OSSS }, + { "vcmpgess", 8, TOKEN_INSN, 0, 0, I_VCMPGESS }, + { "vcmpgt_osss", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OSSS }, + { "vcmpgtss", 8, TOKEN_INSN, 0, 0, I_VCMPGTSS }, + { "vcmptrue_uqss", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_UQSS }, + { "vcmptruess", 10, TOKEN_INSN, 0, 0, I_VCMPTRUESS }, + { "vcmplt_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPLT_OQSS }, + { "vcmple_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPLE_OQSS }, + { "vcmpunord_sss", 13, TOKEN_INSN, 0, 0, I_VCMPUNORD_SSS }, + { "vcmpneq_usss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_USSS }, + { "vcmpnlt_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNLT_UQSS }, + { "vcmpnle_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNLE_UQSS }, + { "vcmpord_sss", 11, TOKEN_INSN, 0, 0, I_VCMPORD_SSS }, + { "vcmpeq_usss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_USSS }, + { "vcmpnge_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNGE_UQSS }, + { "vcmpngt_uqss", 12, TOKEN_INSN, 0, 0, I_VCMPNGT_UQSS }, + { "vcmpfalse_osss", 14, TOKEN_INSN, 0, 0, I_VCMPFALSE_OSSS }, + { "vcmpneq_osss", 12, TOKEN_INSN, 0, 0, I_VCMPNEQ_OSSS }, + { "vcmpge_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPGE_OQSS }, + { "vcmpgt_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPGT_OQSS }, + { "vcmptrue_usss", 13, TOKEN_INSN, 0, 0, I_VCMPTRUE_USSS }, + { "vcmpss", 6, TOKEN_INSN, 0, 0, I_VCMPSS }, + { "vcomisd", 7, TOKEN_INSN, 0, 0, I_VCOMISD }, + { "vcomiss", 7, TOKEN_INSN, 0, 0, I_VCOMISS }, + { "vcvtdq2pd", 9, TOKEN_INSN, 0, 0, I_VCVTDQ2PD }, + { "vcvtdq2ps", 9, TOKEN_INSN, 0, 0, I_VCVTDQ2PS }, + { "vcvtpd2dq", 9, TOKEN_INSN, 0, 0, I_VCVTPD2DQ }, + { "vcvtpd2ps", 9, TOKEN_INSN, 0, 0, I_VCVTPD2PS }, + { "vcvtps2dq", 9, TOKEN_INSN, 0, 0, I_VCVTPS2DQ }, + { "vcvtps2pd", 9, TOKEN_INSN, 0, 0, I_VCVTPS2PD }, + { "vcvtsd2si", 9, TOKEN_INSN, 0, 0, I_VCVTSD2SI }, + { "vcvtsd2ss", 9, TOKEN_INSN, 0, 0, I_VCVTSD2SS }, + { "vcvtsi2sd", 9, TOKEN_INSN, 0, 0, I_VCVTSI2SD }, + { "vcvtsi2ss", 9, TOKEN_INSN, 0, 0, I_VCVTSI2SS }, + { "vcvtss2sd", 9, TOKEN_INSN, 0, 0, I_VCVTSS2SD }, + { "vcvtss2si", 9, TOKEN_INSN, 0, 0, I_VCVTSS2SI }, + { "vcvttpd2dq", 10, TOKEN_INSN, 0, 0, I_VCVTTPD2DQ }, + { "vcvttps2dq", 10, TOKEN_INSN, 0, 0, I_VCVTTPS2DQ }, + { "vcvttsd2si", 10, TOKEN_INSN, 0, 0, I_VCVTTSD2SI }, + { "vcvttss2si", 10, TOKEN_INSN, 0, 0, I_VCVTTSS2SI }, + { "vdivpd", 6, TOKEN_INSN, 0, 0, I_VDIVPD }, + { "vdivps", 6, TOKEN_INSN, 0, 0, I_VDIVPS }, + { "vdivsd", 6, TOKEN_INSN, 0, 0, I_VDIVSD }, + { "vdivss", 6, TOKEN_INSN, 0, 0, I_VDIVSS }, + { "vdppd", 5, TOKEN_INSN, 0, 0, I_VDPPD }, + { "vdpps", 5, TOKEN_INSN, 0, 0, I_VDPPS }, + { "vextractf128", 12, TOKEN_INSN, 0, 0, I_VEXTRACTF128 }, + { "vextractps", 10, TOKEN_INSN, 0, 0, I_VEXTRACTPS }, + { "vhaddpd", 7, TOKEN_INSN, 0, 0, I_VHADDPD }, + { "vhaddps", 7, TOKEN_INSN, 0, 0, I_VHADDPS }, + { "vhsubpd", 7, TOKEN_INSN, 0, 0, I_VHSUBPD }, + { "vhsubps", 7, TOKEN_INSN, 0, 0, I_VHSUBPS }, + { "vinsertf128", 11, TOKEN_INSN, 0, 0, I_VINSERTF128 }, + { "vinsertps", 9, TOKEN_INSN, 0, 0, I_VINSERTPS }, + { "vlddqu", 6, TOKEN_INSN, 0, 0, I_VLDDQU }, + { "vldqqu", 6, TOKEN_INSN, 0, 0, I_VLDQQU }, + { "vldmxcsr", 8, TOKEN_INSN, 0, 0, I_VLDMXCSR }, + { "vmaskmovdqu", 11, TOKEN_INSN, 0, 0, I_VMASKMOVDQU }, + { "vmaskmovps", 10, TOKEN_INSN, 0, 0, I_VMASKMOVPS }, + { "vmaskmovpd", 10, TOKEN_INSN, 0, 0, I_VMASKMOVPD }, + { "vmaxpd", 6, TOKEN_INSN, 0, 0, I_VMAXPD }, + { "vmaxps", 6, TOKEN_INSN, 0, 0, I_VMAXPS }, + { "vmaxsd", 6, TOKEN_INSN, 0, 0, I_VMAXSD }, + { "vmaxss", 6, TOKEN_INSN, 0, 0, I_VMAXSS }, + { "vminpd", 6, TOKEN_INSN, 0, 0, I_VMINPD }, + { "vminps", 6, TOKEN_INSN, 0, 0, I_VMINPS }, + { "vminsd", 6, TOKEN_INSN, 0, 0, I_VMINSD }, + { "vminss", 6, TOKEN_INSN, 0, 0, I_VMINSS }, + { "vmovapd", 7, TOKEN_INSN, 0, 0, I_VMOVAPD }, + { "vmovaps", 7, TOKEN_INSN, 0, 0, I_VMOVAPS }, + { "vmovd", 5, TOKEN_INSN, 0, 0, I_VMOVD }, + { "vmovq", 5, TOKEN_INSN, 0, 0, I_VMOVQ }, + { "vmovddup", 8, TOKEN_INSN, 0, 0, I_VMOVDDUP }, + { "vmovdqa", 7, TOKEN_INSN, 0, 0, I_VMOVDQA }, + { "vmovqqa", 7, TOKEN_INSN, 0, 0, I_VMOVQQA }, + { "vmovdqu", 7, TOKEN_INSN, 0, 0, I_VMOVDQU }, + { "vmovqqu", 7, TOKEN_INSN, 0, 0, I_VMOVQQU }, + { "vmovhlps", 8, TOKEN_INSN, 0, 0, I_VMOVHLPS }, + { "vmovhpd", 7, TOKEN_INSN, 0, 0, I_VMOVHPD }, + { "vmovhps", 7, TOKEN_INSN, 0, 0, I_VMOVHPS }, + { "vmovlhps", 8, TOKEN_INSN, 0, 0, I_VMOVLHPS }, + { "vmovlpd", 7, TOKEN_INSN, 0, 0, I_VMOVLPD }, + { "vmovlps", 7, TOKEN_INSN, 0, 0, I_VMOVLPS }, + { "vmovmskpd", 9, TOKEN_INSN, 0, 0, I_VMOVMSKPD }, + { "vmovmskps", 9, TOKEN_INSN, 0, 0, I_VMOVMSKPS }, + { "vmovntdq", 8, TOKEN_INSN, 0, 0, I_VMOVNTDQ }, + { "vmovntqq", 8, TOKEN_INSN, 0, 0, I_VMOVNTQQ }, + { "vmovntdqa", 9, TOKEN_INSN, 0, 0, I_VMOVNTDQA }, + { "vmovntpd", 8, TOKEN_INSN, 0, 0, I_VMOVNTPD }, + { "vmovntps", 8, TOKEN_INSN, 0, 0, I_VMOVNTPS }, + { "vmovsd", 6, TOKEN_INSN, 0, 0, I_VMOVSD }, + { "vmovshdup", 9, TOKEN_INSN, 0, 0, I_VMOVSHDUP }, + { "vmovsldup", 9, TOKEN_INSN, 0, 0, I_VMOVSLDUP }, + { "vmovss", 6, TOKEN_INSN, 0, 0, I_VMOVSS }, + { "vmovupd", 7, TOKEN_INSN, 0, 0, I_VMOVUPD }, + { "vmovups", 7, TOKEN_INSN, 0, 0, I_VMOVUPS }, + { "vmpsadbw", 8, TOKEN_INSN, 0, 0, I_VMPSADBW }, + { "vmulpd", 6, TOKEN_INSN, 0, 0, I_VMULPD }, + { "vmulps", 6, TOKEN_INSN, 0, 0, I_VMULPS }, + { "vmulsd", 6, TOKEN_INSN, 0, 0, I_VMULSD }, + { "vmulss", 6, TOKEN_INSN, 0, 0, I_VMULSS }, + { "vorpd", 5, TOKEN_INSN, 0, 0, I_VORPD }, + { "vorps", 5, TOKEN_INSN, 0, 0, I_VORPS }, + { "vpabsb", 6, TOKEN_INSN, 0, 0, I_VPABSB }, + { "vpabsw", 6, TOKEN_INSN, 0, 0, I_VPABSW }, + { "vpabsd", 6, TOKEN_INSN, 0, 0, I_VPABSD }, + { "vpacksswb", 9, TOKEN_INSN, 0, 0, I_VPACKSSWB }, + { "vpackssdw", 9, TOKEN_INSN, 0, 0, I_VPACKSSDW }, + { "vpackuswb", 9, TOKEN_INSN, 0, 0, I_VPACKUSWB }, + { "vpackusdw", 9, TOKEN_INSN, 0, 0, I_VPACKUSDW }, + { "vpaddb", 6, TOKEN_INSN, 0, 0, I_VPADDB }, + { "vpaddw", 6, TOKEN_INSN, 0, 0, I_VPADDW }, + { "vpaddd", 6, TOKEN_INSN, 0, 0, I_VPADDD }, + { "vpaddq", 6, TOKEN_INSN, 0, 0, I_VPADDQ }, + { "vpaddsb", 7, TOKEN_INSN, 0, 0, I_VPADDSB }, + { "vpaddsw", 7, TOKEN_INSN, 0, 0, I_VPADDSW }, + { "vpaddusb", 8, TOKEN_INSN, 0, 0, I_VPADDUSB }, + { "vpaddusw", 8, TOKEN_INSN, 0, 0, I_VPADDUSW }, + { "vpalignr", 8, TOKEN_INSN, 0, 0, I_VPALIGNR }, + { "vpand", 5, TOKEN_INSN, 0, 0, I_VPAND }, + { "vpandn", 6, TOKEN_INSN, 0, 0, I_VPANDN }, + { "vpavgb", 6, TOKEN_INSN, 0, 0, I_VPAVGB }, + { "vpavgw", 6, TOKEN_INSN, 0, 0, I_VPAVGW }, + { "vpblendvb", 9, TOKEN_INSN, 0, 0, I_VPBLENDVB }, + { "vpblendw", 8, TOKEN_INSN, 0, 0, I_VPBLENDW }, + { "vpcmpestri", 10, TOKEN_INSN, 0, 0, I_VPCMPESTRI }, + { "vpcmpestrm", 10, TOKEN_INSN, 0, 0, I_VPCMPESTRM }, + { "vpcmpistri", 10, TOKEN_INSN, 0, 0, I_VPCMPISTRI }, + { "vpcmpistrm", 10, TOKEN_INSN, 0, 0, I_VPCMPISTRM }, + { "vpcmpeqb", 8, TOKEN_INSN, 0, 0, I_VPCMPEQB }, + { "vpcmpeqw", 8, TOKEN_INSN, 0, 0, I_VPCMPEQW }, + { "vpcmpeqd", 8, TOKEN_INSN, 0, 0, I_VPCMPEQD }, + { "vpcmpeqq", 8, TOKEN_INSN, 0, 0, I_VPCMPEQQ }, + { "vpcmpgtb", 8, TOKEN_INSN, 0, 0, I_VPCMPGTB }, + { "vpcmpgtw", 8, TOKEN_INSN, 0, 0, I_VPCMPGTW }, + { "vpcmpgtd", 8, TOKEN_INSN, 0, 0, I_VPCMPGTD }, + { "vpcmpgtq", 8, TOKEN_INSN, 0, 0, I_VPCMPGTQ }, + { "vpermilpd", 9, TOKEN_INSN, 0, 0, I_VPERMILPD }, + { "vpermilps", 9, TOKEN_INSN, 0, 0, I_VPERMILPS }, + { "vperm2f128", 10, TOKEN_INSN, 0, 0, I_VPERM2F128 }, + { "vpextrb", 7, TOKEN_INSN, 0, 0, I_VPEXTRB }, + { "vpextrw", 7, TOKEN_INSN, 0, 0, I_VPEXTRW }, + { "vpextrd", 7, TOKEN_INSN, 0, 0, I_VPEXTRD }, + { "vpextrq", 7, TOKEN_INSN, 0, 0, I_VPEXTRQ }, + { "vphaddw", 7, TOKEN_INSN, 0, 0, I_VPHADDW }, + { "vphaddd", 7, TOKEN_INSN, 0, 0, I_VPHADDD }, + { "vphaddsw", 8, TOKEN_INSN, 0, 0, I_VPHADDSW }, + { "vphminposuw", 11, TOKEN_INSN, 0, 0, I_VPHMINPOSUW }, + { "vphsubw", 7, TOKEN_INSN, 0, 0, I_VPHSUBW }, + { "vphsubd", 7, TOKEN_INSN, 0, 0, I_VPHSUBD }, + { "vphsubsw", 8, TOKEN_INSN, 0, 0, I_VPHSUBSW }, + { "vpinsrb", 7, TOKEN_INSN, 0, 0, I_VPINSRB }, + { "vpinsrw", 7, TOKEN_INSN, 0, 0, I_VPINSRW }, + { "vpinsrd", 7, TOKEN_INSN, 0, 0, I_VPINSRD }, + { "vpinsrq", 7, TOKEN_INSN, 0, 0, I_VPINSRQ }, + { "vpmaddwd", 8, TOKEN_INSN, 0, 0, I_VPMADDWD }, + { "vpmaddubsw", 10, TOKEN_INSN, 0, 0, I_VPMADDUBSW }, + { "vpmaxsb", 7, TOKEN_INSN, 0, 0, I_VPMAXSB }, + { "vpmaxsw", 7, TOKEN_INSN, 0, 0, I_VPMAXSW }, + { "vpmaxsd", 7, TOKEN_INSN, 0, 0, I_VPMAXSD }, + { "vpmaxub", 7, TOKEN_INSN, 0, 0, I_VPMAXUB }, + { "vpmaxuw", 7, TOKEN_INSN, 0, 0, I_VPMAXUW }, + { "vpmaxud", 7, TOKEN_INSN, 0, 0, I_VPMAXUD }, + { "vpminsb", 7, TOKEN_INSN, 0, 0, I_VPMINSB }, + { "vpminsw", 7, TOKEN_INSN, 0, 0, I_VPMINSW }, + { "vpminsd", 7, TOKEN_INSN, 0, 0, I_VPMINSD }, + { "vpminub", 7, TOKEN_INSN, 0, 0, I_VPMINUB }, + { "vpminuw", 7, TOKEN_INSN, 0, 0, I_VPMINUW }, + { "vpminud", 7, TOKEN_INSN, 0, 0, I_VPMINUD }, + { "vpmovmskb", 9, TOKEN_INSN, 0, 0, I_VPMOVMSKB }, + { "vpmovsxbw", 9, TOKEN_INSN, 0, 0, I_VPMOVSXBW }, + { "vpmovsxbd", 9, TOKEN_INSN, 0, 0, I_VPMOVSXBD }, + { "vpmovsxbq", 9, TOKEN_INSN, 0, 0, I_VPMOVSXBQ }, + { "vpmovsxwd", 9, TOKEN_INSN, 0, 0, I_VPMOVSXWD }, + { "vpmovsxwq", 9, TOKEN_INSN, 0, 0, I_VPMOVSXWQ }, + { "vpmovsxdq", 9, TOKEN_INSN, 0, 0, I_VPMOVSXDQ }, + { "vpmovzxbw", 9, TOKEN_INSN, 0, 0, I_VPMOVZXBW }, + { "vpmovzxbd", 9, TOKEN_INSN, 0, 0, I_VPMOVZXBD }, + { "vpmovzxbq", 9, TOKEN_INSN, 0, 0, I_VPMOVZXBQ }, + { "vpmovzxwd", 9, TOKEN_INSN, 0, 0, I_VPMOVZXWD }, + { "vpmovzxwq", 9, TOKEN_INSN, 0, 0, I_VPMOVZXWQ }, + { "vpmovzxdq", 9, TOKEN_INSN, 0, 0, I_VPMOVZXDQ }, + { "vpmulhuw", 8, TOKEN_INSN, 0, 0, I_VPMULHUW }, + { "vpmulhrsw", 9, TOKEN_INSN, 0, 0, I_VPMULHRSW }, + { "vpmulhw", 7, TOKEN_INSN, 0, 0, I_VPMULHW }, + { "vpmullw", 7, TOKEN_INSN, 0, 0, I_VPMULLW }, + { "vpmulld", 7, TOKEN_INSN, 0, 0, I_VPMULLD }, + { "vpmuludq", 8, TOKEN_INSN, 0, 0, I_VPMULUDQ }, + { "vpmuldq", 7, TOKEN_INSN, 0, 0, I_VPMULDQ }, + { "vpor", 4, TOKEN_INSN, 0, 0, I_VPOR }, + { "vpsadbw", 7, TOKEN_INSN, 0, 0, I_VPSADBW }, + { "vpshufb", 7, TOKEN_INSN, 0, 0, I_VPSHUFB }, + { "vpshufd", 7, TOKEN_INSN, 0, 0, I_VPSHUFD }, + { "vpshufhw", 8, TOKEN_INSN, 0, 0, I_VPSHUFHW }, + { "vpshuflw", 8, TOKEN_INSN, 0, 0, I_VPSHUFLW }, + { "vpsignb", 7, TOKEN_INSN, 0, 0, I_VPSIGNB }, + { "vpsignw", 7, TOKEN_INSN, 0, 0, I_VPSIGNW }, + { "vpsignd", 7, TOKEN_INSN, 0, 0, I_VPSIGND }, + { "vpslldq", 7, TOKEN_INSN, 0, 0, I_VPSLLDQ }, + { "vpsrldq", 7, TOKEN_INSN, 0, 0, I_VPSRLDQ }, + { "vpsllw", 6, TOKEN_INSN, 0, 0, I_VPSLLW }, + { "vpslld", 6, TOKEN_INSN, 0, 0, I_VPSLLD }, + { "vpsllq", 6, TOKEN_INSN, 0, 0, I_VPSLLQ }, + { "vpsraw", 6, TOKEN_INSN, 0, 0, I_VPSRAW }, + { "vpsrad", 6, TOKEN_INSN, 0, 0, I_VPSRAD }, + { "vpsrlw", 6, TOKEN_INSN, 0, 0, I_VPSRLW }, + { "vpsrld", 6, TOKEN_INSN, 0, 0, I_VPSRLD }, + { "vpsrlq", 6, TOKEN_INSN, 0, 0, I_VPSRLQ }, + { "vptest", 6, TOKEN_INSN, 0, 0, I_VPTEST }, + { "vpsubb", 6, TOKEN_INSN, 0, 0, I_VPSUBB }, + { "vpsubw", 6, TOKEN_INSN, 0, 0, I_VPSUBW }, + { "vpsubd", 6, TOKEN_INSN, 0, 0, I_VPSUBD }, + { "vpsubq", 6, TOKEN_INSN, 0, 0, I_VPSUBQ }, + { "vpsubsb", 7, TOKEN_INSN, 0, 0, I_VPSUBSB }, + { "vpsubsw", 7, TOKEN_INSN, 0, 0, I_VPSUBSW }, + { "vpsubusb", 8, TOKEN_INSN, 0, 0, I_VPSUBUSB }, + { "vpsubusw", 8, TOKEN_INSN, 0, 0, I_VPSUBUSW }, + { "vpunpckhbw", 10, TOKEN_INSN, 0, 0, I_VPUNPCKHBW }, + { "vpunpckhwd", 10, TOKEN_INSN, 0, 0, I_VPUNPCKHWD }, + { "vpunpckhdq", 10, TOKEN_INSN, 0, 0, I_VPUNPCKHDQ }, + { "vpunpckhqdq", 11, TOKEN_INSN, 0, 0, I_VPUNPCKHQDQ }, + { "vpunpcklbw", 10, TOKEN_INSN, 0, 0, I_VPUNPCKLBW }, + { "vpunpcklwd", 10, TOKEN_INSN, 0, 0, I_VPUNPCKLWD }, + { "vpunpckldq", 10, TOKEN_INSN, 0, 0, I_VPUNPCKLDQ }, + { "vpunpcklqdq", 11, TOKEN_INSN, 0, 0, I_VPUNPCKLQDQ }, + { "vpxor", 5, TOKEN_INSN, 0, 0, I_VPXOR }, + { "vrcpps", 6, TOKEN_INSN, 0, 0, I_VRCPPS }, + { "vrcpss", 6, TOKEN_INSN, 0, 0, I_VRCPSS }, + { "vrsqrtps", 8, TOKEN_INSN, 0, 0, I_VRSQRTPS }, + { "vrsqrtss", 8, TOKEN_INSN, 0, 0, I_VRSQRTSS }, + { "vroundpd", 8, TOKEN_INSN, 0, 0, I_VROUNDPD }, + { "vroundps", 8, TOKEN_INSN, 0, 0, I_VROUNDPS }, + { "vroundsd", 8, TOKEN_INSN, 0, 0, I_VROUNDSD }, + { "vroundss", 8, TOKEN_INSN, 0, 0, I_VROUNDSS }, + { "vshufpd", 7, TOKEN_INSN, 0, 0, I_VSHUFPD }, + { "vshufps", 7, TOKEN_INSN, 0, 0, I_VSHUFPS }, + { "vsqrtpd", 7, TOKEN_INSN, 0, 0, I_VSQRTPD }, + { "vsqrtps", 7, TOKEN_INSN, 0, 0, I_VSQRTPS }, + { "vsqrtsd", 7, TOKEN_INSN, 0, 0, I_VSQRTSD }, + { "vsqrtss", 7, TOKEN_INSN, 0, 0, I_VSQRTSS }, + { "vstmxcsr", 8, TOKEN_INSN, 0, 0, I_VSTMXCSR }, + { "vsubpd", 6, TOKEN_INSN, 0, 0, I_VSUBPD }, + { "vsubps", 6, TOKEN_INSN, 0, 0, I_VSUBPS }, + { "vsubsd", 6, TOKEN_INSN, 0, 0, I_VSUBSD }, + { "vsubss", 6, TOKEN_INSN, 0, 0, I_VSUBSS }, + { "vtestps", 7, TOKEN_INSN, 0, 0, I_VTESTPS }, + { "vtestpd", 7, TOKEN_INSN, 0, 0, I_VTESTPD }, + { "vucomisd", 8, TOKEN_INSN, 0, 0, I_VUCOMISD }, + { "vucomiss", 8, TOKEN_INSN, 0, 0, I_VUCOMISS }, + { "vunpckhpd", 9, TOKEN_INSN, 0, 0, I_VUNPCKHPD }, + { "vunpckhps", 9, TOKEN_INSN, 0, 0, I_VUNPCKHPS }, + { "vunpcklpd", 9, TOKEN_INSN, 0, 0, I_VUNPCKLPD }, + { "vunpcklps", 9, TOKEN_INSN, 0, 0, I_VUNPCKLPS }, + { "vxorpd", 6, TOKEN_INSN, 0, 0, I_VXORPD }, + { "vxorps", 6, TOKEN_INSN, 0, 0, I_VXORPS }, + { "vzeroall", 8, TOKEN_INSN, 0, 0, I_VZEROALL }, + { "vzeroupper", 10, TOKEN_INSN, 0, 0, I_VZEROUPPER }, + { "pclmullqlqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULLQLQDQ }, + { "pclmulhqlqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULHQLQDQ }, + { "pclmullqhqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULLQHQDQ }, + { "pclmulhqhqdq", 12, TOKEN_INSN, 0, 0, I_PCLMULHQHQDQ }, + { "pclmulqdq", 9, TOKEN_INSN, 0, 0, I_PCLMULQDQ }, + { "vpclmullqlqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULLQLQDQ }, + { "vpclmulhqlqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULHQLQDQ }, + { "vpclmullqhqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULLQHQDQ }, + { "vpclmulhqhqdq", 13, TOKEN_INSN, 0, 0, I_VPCLMULHQHQDQ }, + { "vpclmulqdq", 10, TOKEN_INSN, 0, 0, I_VPCLMULQDQ }, + { "vfmadd132ps", 11, TOKEN_INSN, 0, 0, I_VFMADD132PS }, + { "vfmadd132pd", 11, TOKEN_INSN, 0, 0, I_VFMADD132PD }, + { "vfmadd312ps", 11, TOKEN_INSN, 0, 0, I_VFMADD312PS }, + { "vfmadd312pd", 11, TOKEN_INSN, 0, 0, I_VFMADD312PD }, + { "vfmadd213ps", 11, TOKEN_INSN, 0, 0, I_VFMADD213PS }, + { "vfmadd213pd", 11, TOKEN_INSN, 0, 0, I_VFMADD213PD }, + { "vfmadd123ps", 11, TOKEN_INSN, 0, 0, I_VFMADD123PS }, + { "vfmadd123pd", 11, TOKEN_INSN, 0, 0, I_VFMADD123PD }, + { "vfmadd231ps", 11, TOKEN_INSN, 0, 0, I_VFMADD231PS }, + { "vfmadd231pd", 11, TOKEN_INSN, 0, 0, I_VFMADD231PD }, + { "vfmadd321ps", 11, TOKEN_INSN, 0, 0, I_VFMADD321PS }, + { "vfmadd321pd", 11, TOKEN_INSN, 0, 0, I_VFMADD321PD }, + { "vfmaddsub132ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB132PS }, + { "vfmaddsub132pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB132PD }, + { "vfmaddsub312ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB312PS }, + { "vfmaddsub312pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB312PD }, + { "vfmaddsub213ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB213PS }, + { "vfmaddsub213pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB213PD }, + { "vfmaddsub123ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB123PS }, + { "vfmaddsub123pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB123PD }, + { "vfmaddsub231ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB231PS }, + { "vfmaddsub231pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB231PD }, + { "vfmaddsub321ps", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB321PS }, + { "vfmaddsub321pd", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB321PD }, + { "vfmsub132ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB132PS }, + { "vfmsub132pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB132PD }, + { "vfmsub312ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB312PS }, + { "vfmsub312pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB312PD }, + { "vfmsub213ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB213PS }, + { "vfmsub213pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB213PD }, + { "vfmsub123ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB123PS }, + { "vfmsub123pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB123PD }, + { "vfmsub231ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB231PS }, + { "vfmsub231pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB231PD }, + { "vfmsub321ps", 11, TOKEN_INSN, 0, 0, I_VFMSUB321PS }, + { "vfmsub321pd", 11, TOKEN_INSN, 0, 0, I_VFMSUB321PD }, + { "vfmsubadd132ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD132PS }, + { "vfmsubadd132pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD132PD }, + { "vfmsubadd312ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD312PS }, + { "vfmsubadd312pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD312PD }, + { "vfmsubadd213ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD213PS }, + { "vfmsubadd213pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD213PD }, + { "vfmsubadd123ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD123PS }, + { "vfmsubadd123pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD123PD }, + { "vfmsubadd231ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD231PS }, + { "vfmsubadd231pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD231PD }, + { "vfmsubadd321ps", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD321PS }, + { "vfmsubadd321pd", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD321PD }, + { "vfnmadd132ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD132PS }, + { "vfnmadd132pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD132PD }, + { "vfnmadd312ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD312PS }, + { "vfnmadd312pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD312PD }, + { "vfnmadd213ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD213PS }, + { "vfnmadd213pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD213PD }, + { "vfnmadd123ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD123PS }, + { "vfnmadd123pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD123PD }, + { "vfnmadd231ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD231PS }, + { "vfnmadd231pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD231PD }, + { "vfnmadd321ps", 12, TOKEN_INSN, 0, 0, I_VFNMADD321PS }, + { "vfnmadd321pd", 12, TOKEN_INSN, 0, 0, I_VFNMADD321PD }, + { "vfnmsub132ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132PS }, + { "vfnmsub132pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132PD }, + { "vfnmsub312ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312PS }, + { "vfnmsub312pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312PD }, + { "vfnmsub213ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213PS }, + { "vfnmsub213pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213PD }, + { "vfnmsub123ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123PS }, + { "vfnmsub123pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123PD }, + { "vfnmsub231ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231PS }, + { "vfnmsub231pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231PD }, + { "vfnmsub321ps", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321PS }, + { "vfnmsub321pd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321PD }, + { "vfmadd132ss", 11, TOKEN_INSN, 0, 0, I_VFMADD132SS }, + { "vfmadd132sd", 11, TOKEN_INSN, 0, 0, I_VFMADD132SD }, + { "vfmadd312ss", 11, TOKEN_INSN, 0, 0, I_VFMADD312SS }, + { "vfmadd312sd", 11, TOKEN_INSN, 0, 0, I_VFMADD312SD }, + { "vfmadd213ss", 11, TOKEN_INSN, 0, 0, I_VFMADD213SS }, + { "vfmadd213sd", 11, TOKEN_INSN, 0, 0, I_VFMADD213SD }, + { "vfmadd123ss", 11, TOKEN_INSN, 0, 0, I_VFMADD123SS }, + { "vfmadd123sd", 11, TOKEN_INSN, 0, 0, I_VFMADD123SD }, + { "vfmadd231ss", 11, TOKEN_INSN, 0, 0, I_VFMADD231SS }, + { "vfmadd231sd", 11, TOKEN_INSN, 0, 0, I_VFMADD231SD }, + { "vfmadd321ss", 11, TOKEN_INSN, 0, 0, I_VFMADD321SS }, + { "vfmadd321sd", 11, TOKEN_INSN, 0, 0, I_VFMADD321SD }, + { "vfmsub132ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB132SS }, + { "vfmsub132sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB132SD }, + { "vfmsub312ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB312SS }, + { "vfmsub312sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB312SD }, + { "vfmsub213ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB213SS }, + { "vfmsub213sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB213SD }, + { "vfmsub123ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB123SS }, + { "vfmsub123sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB123SD }, + { "vfmsub231ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB231SS }, + { "vfmsub231sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB231SD }, + { "vfmsub321ss", 11, TOKEN_INSN, 0, 0, I_VFMSUB321SS }, + { "vfmsub321sd", 11, TOKEN_INSN, 0, 0, I_VFMSUB321SD }, + { "vfnmadd132ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD132SS }, + { "vfnmadd132sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD132SD }, + { "vfnmadd312ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD312SS }, + { "vfnmadd312sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD312SD }, + { "vfnmadd213ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD213SS }, + { "vfnmadd213sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD213SD }, + { "vfnmadd123ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD123SS }, + { "vfnmadd123sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD123SD }, + { "vfnmadd231ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD231SS }, + { "vfnmadd231sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD231SD }, + { "vfnmadd321ss", 12, TOKEN_INSN, 0, 0, I_VFNMADD321SS }, + { "vfnmadd321sd", 12, TOKEN_INSN, 0, 0, I_VFNMADD321SD }, + { "vfnmsub132ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132SS }, + { "vfnmsub132sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB132SD }, + { "vfnmsub312ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312SS }, + { "vfnmsub312sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB312SD }, + { "vfnmsub213ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213SS }, + { "vfnmsub213sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB213SD }, + { "vfnmsub123ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123SS }, + { "vfnmsub123sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB123SD }, + { "vfnmsub231ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231SS }, + { "vfnmsub231sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB231SD }, + { "vfnmsub321ss", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321SS }, + { "vfnmsub321sd", 12, TOKEN_INSN, 0, 0, I_VFNMSUB321SD }, + { "rdfsbase", 8, TOKEN_INSN, 0, 0, I_RDFSBASE }, + { "rdgsbase", 8, TOKEN_INSN, 0, 0, I_RDGSBASE }, + { "rdrand", 6, TOKEN_INSN, 0, 0, I_RDRAND }, + { "wrfsbase", 8, TOKEN_INSN, 0, 0, I_WRFSBASE }, + { "wrgsbase", 8, TOKEN_INSN, 0, 0, I_WRGSBASE }, + { "vcvtph2ps", 9, TOKEN_INSN, 0, 0, I_VCVTPH2PS }, + { "vcvtps2ph", 9, TOKEN_INSN, 0, 0, I_VCVTPS2PH }, + { "adcx", 4, TOKEN_INSN, 0, 0, I_ADCX }, + { "adox", 4, TOKEN_INSN, 0, 0, I_ADOX }, + { "rdseed", 6, TOKEN_INSN, 0, 0, I_RDSEED }, + { "clac", 4, TOKEN_INSN, 0, 0, I_CLAC }, + { "stac", 4, TOKEN_INSN, 0, 0, I_STAC }, + { "xstore", 6, TOKEN_INSN, 0, 0, I_XSTORE }, + { "xcryptecb", 9, TOKEN_INSN, 0, 0, I_XCRYPTECB }, + { "xcryptcbc", 9, TOKEN_INSN, 0, 0, I_XCRYPTCBC }, + { "xcryptctr", 9, TOKEN_INSN, 0, 0, I_XCRYPTCTR }, + { "xcryptcfb", 9, TOKEN_INSN, 0, 0, I_XCRYPTCFB }, + { "xcryptofb", 9, TOKEN_INSN, 0, 0, I_XCRYPTOFB }, + { "montmul", 7, TOKEN_INSN, 0, 0, I_MONTMUL }, + { "xsha1", 5, TOKEN_INSN, 0, 0, I_XSHA1 }, + { "xsha256", 7, TOKEN_INSN, 0, 0, I_XSHA256 }, + { "llwpcb", 6, TOKEN_INSN, 0, 0, I_LLWPCB }, + { "slwpcb", 6, TOKEN_INSN, 0, 0, I_SLWPCB }, + { "lwpval", 6, TOKEN_INSN, 0, 0, I_LWPVAL }, + { "lwpins", 6, TOKEN_INSN, 0, 0, I_LWPINS }, + { "vfmaddpd", 8, TOKEN_INSN, 0, 0, I_VFMADDPD }, + { "vfmaddps", 8, TOKEN_INSN, 0, 0, I_VFMADDPS }, + { "vfmaddsd", 8, TOKEN_INSN, 0, 0, I_VFMADDSD }, + { "vfmaddss", 8, TOKEN_INSN, 0, 0, I_VFMADDSS }, + { "vfmaddsubpd", 11, TOKEN_INSN, 0, 0, I_VFMADDSUBPD }, + { "vfmaddsubps", 11, TOKEN_INSN, 0, 0, I_VFMADDSUBPS }, + { "vfmsubaddpd", 11, TOKEN_INSN, 0, 0, I_VFMSUBADDPD }, + { "vfmsubaddps", 11, TOKEN_INSN, 0, 0, I_VFMSUBADDPS }, + { "vfmsubpd", 8, TOKEN_INSN, 0, 0, I_VFMSUBPD }, + { "vfmsubps", 8, TOKEN_INSN, 0, 0, I_VFMSUBPS }, + { "vfmsubsd", 8, TOKEN_INSN, 0, 0, I_VFMSUBSD }, + { "vfmsubss", 8, TOKEN_INSN, 0, 0, I_VFMSUBSS }, + { "vfnmaddpd", 9, TOKEN_INSN, 0, 0, I_VFNMADDPD }, + { "vfnmaddps", 9, TOKEN_INSN, 0, 0, I_VFNMADDPS }, + { "vfnmaddsd", 9, TOKEN_INSN, 0, 0, I_VFNMADDSD }, + { "vfnmaddss", 9, TOKEN_INSN, 0, 0, I_VFNMADDSS }, + { "vfnmsubpd", 9, TOKEN_INSN, 0, 0, I_VFNMSUBPD }, + { "vfnmsubps", 9, TOKEN_INSN, 0, 0, I_VFNMSUBPS }, + { "vfnmsubsd", 9, TOKEN_INSN, 0, 0, I_VFNMSUBSD }, + { "vfnmsubss", 9, TOKEN_INSN, 0, 0, I_VFNMSUBSS }, + { "vfrczpd", 7, TOKEN_INSN, 0, 0, I_VFRCZPD }, + { "vfrczps", 7, TOKEN_INSN, 0, 0, I_VFRCZPS }, + { "vfrczsd", 7, TOKEN_INSN, 0, 0, I_VFRCZSD }, + { "vfrczss", 7, TOKEN_INSN, 0, 0, I_VFRCZSS }, + { "vpcmov", 6, TOKEN_INSN, 0, 0, I_VPCMOV }, + { "vpcomb", 6, TOKEN_INSN, 0, 0, I_VPCOMB }, + { "vpcomd", 6, TOKEN_INSN, 0, 0, I_VPCOMD }, + { "vpcomq", 6, TOKEN_INSN, 0, 0, I_VPCOMQ }, + { "vpcomub", 7, TOKEN_INSN, 0, 0, I_VPCOMUB }, + { "vpcomud", 7, TOKEN_INSN, 0, 0, I_VPCOMUD }, + { "vpcomuq", 7, TOKEN_INSN, 0, 0, I_VPCOMUQ }, + { "vpcomuw", 7, TOKEN_INSN, 0, 0, I_VPCOMUW }, + { "vpcomw", 6, TOKEN_INSN, 0, 0, I_VPCOMW }, + { "vphaddbd", 8, TOKEN_INSN, 0, 0, I_VPHADDBD }, + { "vphaddbq", 8, TOKEN_INSN, 0, 0, I_VPHADDBQ }, + { "vphaddbw", 8, TOKEN_INSN, 0, 0, I_VPHADDBW }, + { "vphadddq", 8, TOKEN_INSN, 0, 0, I_VPHADDDQ }, + { "vphaddubd", 9, TOKEN_INSN, 0, 0, I_VPHADDUBD }, + { "vphaddubq", 9, TOKEN_INSN, 0, 0, I_VPHADDUBQ }, + { "vphaddubw", 9, TOKEN_INSN, 0, 0, I_VPHADDUBW }, + { "vphaddudq", 9, TOKEN_INSN, 0, 0, I_VPHADDUDQ }, + { "vphadduwd", 9, TOKEN_INSN, 0, 0, I_VPHADDUWD }, + { "vphadduwq", 9, TOKEN_INSN, 0, 0, I_VPHADDUWQ }, + { "vphaddwd", 8, TOKEN_INSN, 0, 0, I_VPHADDWD }, + { "vphaddwq", 8, TOKEN_INSN, 0, 0, I_VPHADDWQ }, + { "vphsubbw", 8, TOKEN_INSN, 0, 0, I_VPHSUBBW }, + { "vphsubdq", 8, TOKEN_INSN, 0, 0, I_VPHSUBDQ }, + { "vphsubwd", 8, TOKEN_INSN, 0, 0, I_VPHSUBWD }, + { "vpmacsdd", 8, TOKEN_INSN, 0, 0, I_VPMACSDD }, + { "vpmacsdqh", 9, TOKEN_INSN, 0, 0, I_VPMACSDQH }, + { "vpmacsdql", 9, TOKEN_INSN, 0, 0, I_VPMACSDQL }, + { "vpmacssdd", 9, TOKEN_INSN, 0, 0, I_VPMACSSDD }, + { "vpmacssdqh", 10, TOKEN_INSN, 0, 0, I_VPMACSSDQH }, + { "vpmacssdql", 10, TOKEN_INSN, 0, 0, I_VPMACSSDQL }, + { "vpmacsswd", 9, TOKEN_INSN, 0, 0, I_VPMACSSWD }, + { "vpmacssww", 9, TOKEN_INSN, 0, 0, I_VPMACSSWW }, + { "vpmacswd", 8, TOKEN_INSN, 0, 0, I_VPMACSWD }, + { "vpmacsww", 8, TOKEN_INSN, 0, 0, I_VPMACSWW }, + { "vpmadcsswd", 10, TOKEN_INSN, 0, 0, I_VPMADCSSWD }, + { "vpmadcswd", 9, TOKEN_INSN, 0, 0, I_VPMADCSWD }, + { "vpperm", 6, TOKEN_INSN, 0, 0, I_VPPERM }, + { "vprotb", 6, TOKEN_INSN, 0, 0, I_VPROTB }, + { "vprotd", 6, TOKEN_INSN, 0, 0, I_VPROTD }, + { "vprotq", 6, TOKEN_INSN, 0, 0, I_VPROTQ }, + { "vprotw", 6, TOKEN_INSN, 0, 0, I_VPROTW }, + { "vpshab", 6, TOKEN_INSN, 0, 0, I_VPSHAB }, + { "vpshad", 6, TOKEN_INSN, 0, 0, I_VPSHAD }, + { "vpshaq", 6, TOKEN_INSN, 0, 0, I_VPSHAQ }, + { "vpshaw", 6, TOKEN_INSN, 0, 0, I_VPSHAW }, + { "vpshlb", 6, TOKEN_INSN, 0, 0, I_VPSHLB }, + { "vpshld", 6, TOKEN_INSN, 0, 0, I_VPSHLD }, + { "vpshlq", 6, TOKEN_INSN, 0, 0, I_VPSHLQ }, + { "vpshlw", 6, TOKEN_INSN, 0, 0, I_VPSHLW }, + { "vbroadcasti128", 14, TOKEN_INSN, 0, 0, I_VBROADCASTI128 }, + { "vpblendd", 8, TOKEN_INSN, 0, 0, I_VPBLENDD }, + { "vpbroadcastb", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTB }, + { "vpbroadcastw", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTW }, + { "vpbroadcastd", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTD }, + { "vpbroadcastq", 12, TOKEN_INSN, 0, 0, I_VPBROADCASTQ }, + { "vpermd", 6, TOKEN_INSN, 0, 0, I_VPERMD }, + { "vpermpd", 7, TOKEN_INSN, 0, 0, I_VPERMPD }, + { "vpermps", 7, TOKEN_INSN, 0, 0, I_VPERMPS }, + { "vpermq", 6, TOKEN_INSN, 0, 0, I_VPERMQ }, + { "vperm2i128", 10, TOKEN_INSN, 0, 0, I_VPERM2I128 }, + { "vextracti128", 12, TOKEN_INSN, 0, 0, I_VEXTRACTI128 }, + { "vinserti128", 11, TOKEN_INSN, 0, 0, I_VINSERTI128 }, + { "vpmaskmovd", 10, TOKEN_INSN, 0, 0, I_VPMASKMOVD }, + { "vpmaskmovq", 10, TOKEN_INSN, 0, 0, I_VPMASKMOVQ }, + { "vpsllvd", 7, TOKEN_INSN, 0, 0, I_VPSLLVD }, + { "vpsllvq", 7, TOKEN_INSN, 0, 0, I_VPSLLVQ }, + { "vpsravd", 7, TOKEN_INSN, 0, 0, I_VPSRAVD }, + { "vpsrlvd", 7, TOKEN_INSN, 0, 0, I_VPSRLVD }, + { "vpsrlvq", 7, TOKEN_INSN, 0, 0, I_VPSRLVQ }, + { "vgatherdpd", 10, TOKEN_INSN, 0, 0, I_VGATHERDPD }, + { "vgatherqpd", 10, TOKEN_INSN, 0, 0, I_VGATHERQPD }, + { "vgatherdps", 10, TOKEN_INSN, 0, 0, I_VGATHERDPS }, + { "vgatherqps", 10, TOKEN_INSN, 0, 0, I_VGATHERQPS }, + { "vpgatherdd", 10, TOKEN_INSN, 0, 0, I_VPGATHERDD }, + { "vpgatherqd", 10, TOKEN_INSN, 0, 0, I_VPGATHERQD }, + { "vpgatherdq", 10, TOKEN_INSN, 0, 0, I_VPGATHERDQ }, + { "vpgatherqq", 10, TOKEN_INSN, 0, 0, I_VPGATHERQQ }, + { "xabort", 6, TOKEN_INSN, 0, 0, I_XABORT }, + { "xbegin", 6, TOKEN_INSN, 0, 0, I_XBEGIN }, + { "xend", 4, TOKEN_INSN, 0, 0, I_XEND }, + { "xtest", 5, TOKEN_INSN, 0, 0, I_XTEST }, + { "andn", 4, TOKEN_INSN, 0, 0, I_ANDN }, + { "bextr", 5, TOKEN_INSN, 0, 0, I_BEXTR }, + { "blci", 4, TOKEN_INSN, 0, 0, I_BLCI }, + { "blcic", 5, TOKEN_INSN, 0, 0, I_BLCIC }, + { "blsi", 4, TOKEN_INSN, 0, 0, I_BLSI }, + { "blsic", 5, TOKEN_INSN, 0, 0, I_BLSIC }, + { "blcfill", 7, TOKEN_INSN, 0, 0, I_BLCFILL }, + { "blsfill", 7, TOKEN_INSN, 0, 0, I_BLSFILL }, + { "blcmsk", 6, TOKEN_INSN, 0, 0, I_BLCMSK }, + { "blsmsk", 6, TOKEN_INSN, 0, 0, I_BLSMSK }, + { "blsr", 4, TOKEN_INSN, 0, 0, I_BLSR }, + { "blcs", 4, TOKEN_INSN, 0, 0, I_BLCS }, + { "bzhi", 4, TOKEN_INSN, 0, 0, I_BZHI }, + { "mulx", 4, TOKEN_INSN, 0, 0, I_MULX }, + { "pdep", 4, TOKEN_INSN, 0, 0, I_PDEP }, + { "pext", 4, TOKEN_INSN, 0, 0, I_PEXT }, + { "rorx", 4, TOKEN_INSN, 0, 0, I_RORX }, + { "sarx", 4, TOKEN_INSN, 0, 0, I_SARX }, + { "shlx", 4, TOKEN_INSN, 0, 0, I_SHLX }, + { "shrx", 4, TOKEN_INSN, 0, 0, I_SHRX }, + { "tzcnt", 5, TOKEN_INSN, 0, 0, I_TZCNT }, + { "tzmsk", 5, TOKEN_INSN, 0, 0, I_TZMSK }, + { "t1mskc", 6, TOKEN_INSN, 0, 0, I_T1MSKC }, + { "prefetchwt1", 11, TOKEN_INSN, 0, 0, I_PREFETCHWT1 }, + { "bndmk", 5, TOKEN_INSN, 0, 0, I_BNDMK }, + { "bndcl", 5, TOKEN_INSN, 0, 0, I_BNDCL }, + { "bndcu", 5, TOKEN_INSN, 0, 0, I_BNDCU }, + { "bndcn", 5, TOKEN_INSN, 0, 0, I_BNDCN }, + { "bndmov", 6, TOKEN_INSN, 0, 0, I_BNDMOV }, + { "bndldx", 6, TOKEN_INSN, 0, 0, I_BNDLDX }, + { "bndstx", 6, TOKEN_INSN, 0, 0, I_BNDSTX }, + { "sha1msg1", 8, TOKEN_INSN, 0, 0, I_SHA1MSG1 }, + { "sha1msg2", 8, TOKEN_INSN, 0, 0, I_SHA1MSG2 }, + { "sha1nexte", 9, TOKEN_INSN, 0, 0, I_SHA1NEXTE }, + { "sha1rnds4", 9, TOKEN_INSN, 0, 0, I_SHA1RNDS4 }, + { "sha256msg1", 10, TOKEN_INSN, 0, 0, I_SHA256MSG1 }, + { "sha256msg2", 10, TOKEN_INSN, 0, 0, I_SHA256MSG2 }, + { "sha256rnds2", 11, TOKEN_INSN, 0, 0, I_SHA256RNDS2 }, + { "vbcstnebf16ps", 13, TOKEN_INSN, 0, 0, I_VBCSTNEBF16PS }, + { "vbcstnesh2ps", 12, TOKEN_INSN, 0, 0, I_VBCSTNESH2PS }, + { "vcvtneebf162ps", 14, TOKEN_INSN, 0, 0, I_VCVTNEEBF162PS }, + { "vcvtneeph2ps", 12, TOKEN_INSN, 0, 0, I_VCVTNEEPH2PS }, + { "vcvtneobf162ps", 14, TOKEN_INSN, 0, 0, I_VCVTNEOBF162PS }, + { "vcvtneoph2ps", 12, TOKEN_INSN, 0, 0, I_VCVTNEOPH2PS }, + { "vcvtneps2bf16", 13, TOKEN_INSN, 0, 0, I_VCVTNEPS2BF16 }, + { "vpdpbssd", 8, TOKEN_INSN, 0, 0, I_VPDPBSSD }, + { "vpdpbssds", 9, TOKEN_INSN, 0, 0, I_VPDPBSSDS }, + { "vpdpbsud", 8, TOKEN_INSN, 0, 0, I_VPDPBSUD }, + { "vpdpbsuds", 9, TOKEN_INSN, 0, 0, I_VPDPBSUDS }, + { "vpdpbuud", 8, TOKEN_INSN, 0, 0, I_VPDPBUUD }, + { "vpdpbuuds", 9, TOKEN_INSN, 0, 0, I_VPDPBUUDS }, + { "vpmadd52huq", 11, TOKEN_INSN, 0, 0, I_VPMADD52HUQ }, + { "vpmadd52luq", 11, TOKEN_INSN, 0, 0, I_VPMADD52LUQ }, + { "kaddb", 5, TOKEN_INSN, 0, 0, I_KADDB }, + { "kaddd", 5, TOKEN_INSN, 0, 0, I_KADDD }, + { "kaddq", 5, TOKEN_INSN, 0, 0, I_KADDQ }, + { "kaddw", 5, TOKEN_INSN, 0, 0, I_KADDW }, + { "kandb", 5, TOKEN_INSN, 0, 0, I_KANDB }, + { "kandd", 5, TOKEN_INSN, 0, 0, I_KANDD }, + { "kandnb", 6, TOKEN_INSN, 0, 0, I_KANDNB }, + { "kandnd", 6, TOKEN_INSN, 0, 0, I_KANDND }, + { "kandnq", 6, TOKEN_INSN, 0, 0, I_KANDNQ }, + { "kandnw", 6, TOKEN_INSN, 0, 0, I_KANDNW }, + { "kandq", 5, TOKEN_INSN, 0, 0, I_KANDQ }, + { "kandw", 5, TOKEN_INSN, 0, 0, I_KANDW }, + { "kmovb", 5, TOKEN_INSN, 0, 0, I_KMOVB }, + { "kmovd", 5, TOKEN_INSN, 0, 0, I_KMOVD }, + { "kmovq", 5, TOKEN_INSN, 0, 0, I_KMOVQ }, + { "kmovw", 5, TOKEN_INSN, 0, 0, I_KMOVW }, + { "knotb", 5, TOKEN_INSN, 0, 0, I_KNOTB }, + { "knotd", 5, TOKEN_INSN, 0, 0, I_KNOTD }, + { "knotq", 5, TOKEN_INSN, 0, 0, I_KNOTQ }, + { "knotw", 5, TOKEN_INSN, 0, 0, I_KNOTW }, + { "korb", 4, TOKEN_INSN, 0, 0, I_KORB }, + { "kord", 4, TOKEN_INSN, 0, 0, I_KORD }, + { "korq", 4, TOKEN_INSN, 0, 0, I_KORQ }, + { "korw", 4, TOKEN_INSN, 0, 0, I_KORW }, + { "kortestb", 8, TOKEN_INSN, 0, 0, I_KORTESTB }, + { "kortestd", 8, TOKEN_INSN, 0, 0, I_KORTESTD }, + { "kortestq", 8, TOKEN_INSN, 0, 0, I_KORTESTQ }, + { "kortestw", 8, TOKEN_INSN, 0, 0, I_KORTESTW }, + { "kshiftlb", 8, TOKEN_INSN, 0, 0, I_KSHIFTLB }, + { "kshiftld", 8, TOKEN_INSN, 0, 0, I_KSHIFTLD }, + { "kshiftlq", 8, TOKEN_INSN, 0, 0, I_KSHIFTLQ }, + { "kshiftlw", 8, TOKEN_INSN, 0, 0, I_KSHIFTLW }, + { "kshiftrb", 8, TOKEN_INSN, 0, 0, I_KSHIFTRB }, + { "kshiftrd", 8, TOKEN_INSN, 0, 0, I_KSHIFTRD }, + { "kshiftrq", 8, TOKEN_INSN, 0, 0, I_KSHIFTRQ }, + { "kshiftrw", 8, TOKEN_INSN, 0, 0, I_KSHIFTRW }, + { "ktestb", 6, TOKEN_INSN, 0, 0, I_KTESTB }, + { "ktestd", 6, TOKEN_INSN, 0, 0, I_KTESTD }, + { "ktestq", 6, TOKEN_INSN, 0, 0, I_KTESTQ }, + { "ktestw", 6, TOKEN_INSN, 0, 0, I_KTESTW }, + { "kunpckbw", 8, TOKEN_INSN, 0, 0, I_KUNPCKBW }, + { "kunpckdq", 8, TOKEN_INSN, 0, 0, I_KUNPCKDQ }, + { "kunpckwd", 8, TOKEN_INSN, 0, 0, I_KUNPCKWD }, + { "kxnorb", 6, TOKEN_INSN, 0, 0, I_KXNORB }, + { "kxnord", 6, TOKEN_INSN, 0, 0, I_KXNORD }, + { "kxnorq", 6, TOKEN_INSN, 0, 0, I_KXNORQ }, + { "kxnorw", 6, TOKEN_INSN, 0, 0, I_KXNORW }, + { "kxorb", 5, TOKEN_INSN, 0, 0, I_KXORB }, + { "kxord", 5, TOKEN_INSN, 0, 0, I_KXORD }, + { "kxorq", 5, TOKEN_INSN, 0, 0, I_KXORQ }, + { "kxorw", 5, TOKEN_INSN, 0, 0, I_KXORW }, + { "kadd", 4, TOKEN_INSN, 0, 0, I_KADD }, + { "kand", 4, TOKEN_INSN, 0, 0, I_KAND }, + { "kandn", 5, TOKEN_INSN, 0, 0, I_KANDN }, + { "kmov", 4, TOKEN_INSN, 0, 0, I_KMOV }, + { "knot", 4, TOKEN_INSN, 0, 0, I_KNOT }, + { "kor", 3, TOKEN_INSN, 0, 0, I_KOR }, + { "kortest", 7, TOKEN_INSN, 0, 0, I_KORTEST }, + { "kshiftl", 7, TOKEN_INSN, 0, 0, I_KSHIFTL }, + { "kshiftr", 7, TOKEN_INSN, 0, 0, I_KSHIFTR }, + { "ktest", 5, TOKEN_INSN, 0, 0, I_KTEST }, + { "kunpck", 6, TOKEN_INSN, 0, 0, I_KUNPCK }, + { "kxnor", 5, TOKEN_INSN, 0, 0, I_KXNOR }, + { "kxor", 4, TOKEN_INSN, 0, 0, I_KXOR }, + { "valignd", 7, TOKEN_INSN, 0, 0, I_VALIGND }, + { "valignq", 7, TOKEN_INSN, 0, 0, I_VALIGNQ }, + { "vblendmpd", 9, TOKEN_INSN, 0, 0, I_VBLENDMPD }, + { "vblendmps", 9, TOKEN_INSN, 0, 0, I_VBLENDMPS }, + { "vbroadcastf32x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF32X2 }, + { "vbroadcastf32x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF32X4 }, + { "vbroadcastf32x8", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF32X8 }, + { "vbroadcastf64x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF64X2 }, + { "vbroadcastf64x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTF64X4 }, + { "vbroadcasti32x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI32X2 }, + { "vbroadcasti32x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI32X4 }, + { "vbroadcasti32x8", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI32X8 }, + { "vbroadcasti64x2", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI64X2 }, + { "vbroadcasti64x4", 15, TOKEN_INSN, 0, 0, I_VBROADCASTI64X4 }, + { "vcmpeq_oqpd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQPD }, + { "vcmpeq_oqps", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQPS }, + { "vcmpeq_oqsd", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQSD }, + { "vcmpeq_oqss", 11, TOKEN_INSN, 0, 0, I_VCMPEQ_OQSS }, + { "vcompresspd", 11, TOKEN_INSN, 0, 0, I_VCOMPRESSPD }, + { "vcompressps", 11, TOKEN_INSN, 0, 0, I_VCOMPRESSPS }, + { "vcvtpd2qq", 9, TOKEN_INSN, 0, 0, I_VCVTPD2QQ }, + { "vcvtpd2udq", 10, TOKEN_INSN, 0, 0, I_VCVTPD2UDQ }, + { "vcvtpd2uqq", 10, TOKEN_INSN, 0, 0, I_VCVTPD2UQQ }, + { "vcvtps2qq", 9, TOKEN_INSN, 0, 0, I_VCVTPS2QQ }, + { "vcvtps2udq", 10, TOKEN_INSN, 0, 0, I_VCVTPS2UDQ }, + { "vcvtps2uqq", 10, TOKEN_INSN, 0, 0, I_VCVTPS2UQQ }, + { "vcvtqq2pd", 9, TOKEN_INSN, 0, 0, I_VCVTQQ2PD }, + { "vcvtqq2ps", 9, TOKEN_INSN, 0, 0, I_VCVTQQ2PS }, + { "vcvtsd2usi", 10, TOKEN_INSN, 0, 0, I_VCVTSD2USI }, + { "vcvtss2usi", 10, TOKEN_INSN, 0, 0, I_VCVTSS2USI }, + { "vcvttpd2qq", 10, TOKEN_INSN, 0, 0, I_VCVTTPD2QQ }, + { "vcvttpd2udq", 11, TOKEN_INSN, 0, 0, I_VCVTTPD2UDQ }, + { "vcvttpd2uqq", 11, TOKEN_INSN, 0, 0, I_VCVTTPD2UQQ }, + { "vcvttps2qq", 10, TOKEN_INSN, 0, 0, I_VCVTTPS2QQ }, + { "vcvttps2udq", 11, TOKEN_INSN, 0, 0, I_VCVTTPS2UDQ }, + { "vcvttps2uqq", 11, TOKEN_INSN, 0, 0, I_VCVTTPS2UQQ }, + { "vcvttsd2usi", 11, TOKEN_INSN, 0, 0, I_VCVTTSD2USI }, + { "vcvttss2usi", 11, TOKEN_INSN, 0, 0, I_VCVTTSS2USI }, + { "vcvtudq2pd", 10, TOKEN_INSN, 0, 0, I_VCVTUDQ2PD }, + { "vcvtudq2ps", 10, TOKEN_INSN, 0, 0, I_VCVTUDQ2PS }, + { "vcvtuqq2pd", 10, TOKEN_INSN, 0, 0, I_VCVTUQQ2PD }, + { "vcvtuqq2ps", 10, TOKEN_INSN, 0, 0, I_VCVTUQQ2PS }, + { "vcvtusi2sd", 10, TOKEN_INSN, 0, 0, I_VCVTUSI2SD }, + { "vcvtusi2ss", 10, TOKEN_INSN, 0, 0, I_VCVTUSI2SS }, + { "vdbpsadbw", 9, TOKEN_INSN, 0, 0, I_VDBPSADBW }, + { "vexp2pd", 7, TOKEN_INSN, 0, 0, I_VEXP2PD }, + { "vexp2ps", 7, TOKEN_INSN, 0, 0, I_VEXP2PS }, + { "vexpandpd", 9, TOKEN_INSN, 0, 0, I_VEXPANDPD }, + { "vexpandps", 9, TOKEN_INSN, 0, 0, I_VEXPANDPS }, + { "vextractf32x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF32X4 }, + { "vextractf32x8", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF32X8 }, + { "vextractf64x2", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF64X2 }, + { "vextractf64x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTF64X4 }, + { "vextracti32x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI32X4 }, + { "vextracti32x8", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI32X8 }, + { "vextracti64x2", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI64X2 }, + { "vextracti64x4", 13, TOKEN_INSN, 0, 0, I_VEXTRACTI64X4 }, + { "vfixupimmpd", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMPD }, + { "vfixupimmps", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMPS }, + { "vfixupimmsd", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMSD }, + { "vfixupimmss", 11, TOKEN_INSN, 0, 0, I_VFIXUPIMMSS }, + { "vfpclasspd", 10, TOKEN_INSN, 0, 0, I_VFPCLASSPD }, + { "vfpclassps", 10, TOKEN_INSN, 0, 0, I_VFPCLASSPS }, + { "vfpclasssd", 10, TOKEN_INSN, 0, 0, I_VFPCLASSSD }, + { "vfpclassss", 10, TOKEN_INSN, 0, 0, I_VFPCLASSSS }, + { "vgatherpf0dpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0DPD }, + { "vgatherpf0dps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0DPS }, + { "vgatherpf0qpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0QPD }, + { "vgatherpf0qps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF0QPS }, + { "vgatherpf1dpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1DPD }, + { "vgatherpf1dps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1DPS }, + { "vgatherpf1qpd", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1QPD }, + { "vgatherpf1qps", 13, TOKEN_INSN, 0, 0, I_VGATHERPF1QPS }, + { "vgetexppd", 9, TOKEN_INSN, 0, 0, I_VGETEXPPD }, + { "vgetexpps", 9, TOKEN_INSN, 0, 0, I_VGETEXPPS }, + { "vgetexpsd", 9, TOKEN_INSN, 0, 0, I_VGETEXPSD }, + { "vgetexpss", 9, TOKEN_INSN, 0, 0, I_VGETEXPSS }, + { "vgetmantpd", 10, TOKEN_INSN, 0, 0, I_VGETMANTPD }, + { "vgetmantps", 10, TOKEN_INSN, 0, 0, I_VGETMANTPS }, + { "vgetmantsd", 10, TOKEN_INSN, 0, 0, I_VGETMANTSD }, + { "vgetmantss", 10, TOKEN_INSN, 0, 0, I_VGETMANTSS }, + { "vinsertf32x4", 12, TOKEN_INSN, 0, 0, I_VINSERTF32X4 }, + { "vinsertf32x8", 12, TOKEN_INSN, 0, 0, I_VINSERTF32X8 }, + { "vinsertf64x2", 12, TOKEN_INSN, 0, 0, I_VINSERTF64X2 }, + { "vinsertf64x4", 12, TOKEN_INSN, 0, 0, I_VINSERTF64X4 }, + { "vinserti32x4", 12, TOKEN_INSN, 0, 0, I_VINSERTI32X4 }, + { "vinserti32x8", 12, TOKEN_INSN, 0, 0, I_VINSERTI32X8 }, + { "vinserti64x2", 12, TOKEN_INSN, 0, 0, I_VINSERTI64X2 }, + { "vinserti64x4", 12, TOKEN_INSN, 0, 0, I_VINSERTI64X4 }, + { "vmovdqa32", 9, TOKEN_INSN, 0, 0, I_VMOVDQA32 }, + { "vmovdqa64", 9, TOKEN_INSN, 0, 0, I_VMOVDQA64 }, + { "vmovdqu16", 9, TOKEN_INSN, 0, 0, I_VMOVDQU16 }, + { "vmovdqu32", 9, TOKEN_INSN, 0, 0, I_VMOVDQU32 }, + { "vmovdqu64", 9, TOKEN_INSN, 0, 0, I_VMOVDQU64 }, + { "vmovdqu8", 8, TOKEN_INSN, 0, 0, I_VMOVDQU8 }, + { "vpabsq", 6, TOKEN_INSN, 0, 0, I_VPABSQ }, + { "vpandd", 6, TOKEN_INSN, 0, 0, I_VPANDD }, + { "vpandnd", 7, TOKEN_INSN, 0, 0, I_VPANDND }, + { "vpandnq", 7, TOKEN_INSN, 0, 0, I_VPANDNQ }, + { "vpandq", 6, TOKEN_INSN, 0, 0, I_VPANDQ }, + { "vpblendmb", 9, TOKEN_INSN, 0, 0, I_VPBLENDMB }, + { "vpblendmd", 9, TOKEN_INSN, 0, 0, I_VPBLENDMD }, + { "vpblendmq", 9, TOKEN_INSN, 0, 0, I_VPBLENDMQ }, + { "vpblendmw", 9, TOKEN_INSN, 0, 0, I_VPBLENDMW }, + { "vpbroadcastmb2q", 15, TOKEN_INSN, 0, 0, I_VPBROADCASTMB2Q }, + { "vpbroadcastmw2d", 15, TOKEN_INSN, 0, 0, I_VPBROADCASTMW2D }, + { "vpcmpequb", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUB }, + { "vpcmpequd", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUD }, + { "vpcmpequq", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUQ }, + { "vpcmpequw", 9, TOKEN_INSN, 0, 0, I_VPCMPEQUW }, + { "vpcmpgeb", 8, TOKEN_INSN, 0, 0, I_VPCMPGEB }, + { "vpcmpged", 8, TOKEN_INSN, 0, 0, I_VPCMPGED }, + { "vpcmpgeq", 8, TOKEN_INSN, 0, 0, I_VPCMPGEQ }, + { "vpcmpgeub", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUB }, + { "vpcmpgeud", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUD }, + { "vpcmpgeuq", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUQ }, + { "vpcmpgeuw", 9, TOKEN_INSN, 0, 0, I_VPCMPGEUW }, + { "vpcmpgew", 8, TOKEN_INSN, 0, 0, I_VPCMPGEW }, + { "vpcmpgtub", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUB }, + { "vpcmpgtud", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUD }, + { "vpcmpgtuq", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUQ }, + { "vpcmpgtuw", 9, TOKEN_INSN, 0, 0, I_VPCMPGTUW }, + { "vpcmpleb", 8, TOKEN_INSN, 0, 0, I_VPCMPLEB }, + { "vpcmpled", 8, TOKEN_INSN, 0, 0, I_VPCMPLED }, + { "vpcmpleq", 8, TOKEN_INSN, 0, 0, I_VPCMPLEQ }, + { "vpcmpleub", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUB }, + { "vpcmpleud", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUD }, + { "vpcmpleuq", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUQ }, + { "vpcmpleuw", 9, TOKEN_INSN, 0, 0, I_VPCMPLEUW }, + { "vpcmplew", 8, TOKEN_INSN, 0, 0, I_VPCMPLEW }, + { "vpcmpltb", 8, TOKEN_INSN, 0, 0, I_VPCMPLTB }, + { "vpcmpltd", 8, TOKEN_INSN, 0, 0, I_VPCMPLTD }, + { "vpcmpltq", 8, TOKEN_INSN, 0, 0, I_VPCMPLTQ }, + { "vpcmpltub", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUB }, + { "vpcmpltud", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUD }, + { "vpcmpltuq", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUQ }, + { "vpcmpltuw", 9, TOKEN_INSN, 0, 0, I_VPCMPLTUW }, + { "vpcmpltw", 8, TOKEN_INSN, 0, 0, I_VPCMPLTW }, + { "vpcmpneqb", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQB }, + { "vpcmpneqd", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQD }, + { "vpcmpneqq", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQQ }, + { "vpcmpnequb", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUB }, + { "vpcmpnequd", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUD }, + { "vpcmpnequq", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUQ }, + { "vpcmpnequw", 10, TOKEN_INSN, 0, 0, I_VPCMPNEQUW }, + { "vpcmpneqw", 9, TOKEN_INSN, 0, 0, I_VPCMPNEQW }, + { "vpcmpngtb", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTB }, + { "vpcmpngtd", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTD }, + { "vpcmpngtq", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTQ }, + { "vpcmpngtub", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUB }, + { "vpcmpngtud", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUD }, + { "vpcmpngtuq", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUQ }, + { "vpcmpngtuw", 10, TOKEN_INSN, 0, 0, I_VPCMPNGTUW }, + { "vpcmpngtw", 9, TOKEN_INSN, 0, 0, I_VPCMPNGTW }, + { "vpcmpnleb", 9, TOKEN_INSN, 0, 0, I_VPCMPNLEB }, + { "vpcmpnled", 9, TOKEN_INSN, 0, 0, I_VPCMPNLED }, + { "vpcmpnleq", 9, TOKEN_INSN, 0, 0, I_VPCMPNLEQ }, + { "vpcmpnleub", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUB }, + { "vpcmpnleud", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUD }, + { "vpcmpnleuq", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUQ }, + { "vpcmpnleuw", 10, TOKEN_INSN, 0, 0, I_VPCMPNLEUW }, + { "vpcmpnlew", 9, TOKEN_INSN, 0, 0, I_VPCMPNLEW }, + { "vpcmpnltb", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTB }, + { "vpcmpnltd", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTD }, + { "vpcmpnltq", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTQ }, + { "vpcmpnltub", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUB }, + { "vpcmpnltud", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUD }, + { "vpcmpnltuq", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUQ }, + { "vpcmpnltuw", 10, TOKEN_INSN, 0, 0, I_VPCMPNLTUW }, + { "vpcmpnltw", 9, TOKEN_INSN, 0, 0, I_VPCMPNLTW }, + { "vpcmpb", 6, TOKEN_INSN, 0, 0, I_VPCMPB }, + { "vpcmpd", 6, TOKEN_INSN, 0, 0, I_VPCMPD }, + { "vpcmpq", 6, TOKEN_INSN, 0, 0, I_VPCMPQ }, + { "vpcmpub", 7, TOKEN_INSN, 0, 0, I_VPCMPUB }, + { "vpcmpud", 7, TOKEN_INSN, 0, 0, I_VPCMPUD }, + { "vpcmpuq", 7, TOKEN_INSN, 0, 0, I_VPCMPUQ }, + { "vpcmpuw", 7, TOKEN_INSN, 0, 0, I_VPCMPUW }, + { "vpcmpw", 6, TOKEN_INSN, 0, 0, I_VPCMPW }, + { "vpcompressd", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSD }, + { "vpcompressq", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSQ }, + { "vpconflictd", 11, TOKEN_INSN, 0, 0, I_VPCONFLICTD }, + { "vpconflictq", 11, TOKEN_INSN, 0, 0, I_VPCONFLICTQ }, + { "vpermb", 6, TOKEN_INSN, 0, 0, I_VPERMB }, + { "vpermi2b", 8, TOKEN_INSN, 0, 0, I_VPERMI2B }, + { "vpermi2d", 8, TOKEN_INSN, 0, 0, I_VPERMI2D }, + { "vpermi2pd", 9, TOKEN_INSN, 0, 0, I_VPERMI2PD }, + { "vpermi2ps", 9, TOKEN_INSN, 0, 0, I_VPERMI2PS }, + { "vpermi2q", 8, TOKEN_INSN, 0, 0, I_VPERMI2Q }, + { "vpermi2w", 8, TOKEN_INSN, 0, 0, I_VPERMI2W }, + { "vpermt2b", 8, TOKEN_INSN, 0, 0, I_VPERMT2B }, + { "vpermt2d", 8, TOKEN_INSN, 0, 0, I_VPERMT2D }, + { "vpermt2pd", 9, TOKEN_INSN, 0, 0, I_VPERMT2PD }, + { "vpermt2ps", 9, TOKEN_INSN, 0, 0, I_VPERMT2PS }, + { "vpermt2q", 8, TOKEN_INSN, 0, 0, I_VPERMT2Q }, + { "vpermt2w", 8, TOKEN_INSN, 0, 0, I_VPERMT2W }, + { "vpermw", 6, TOKEN_INSN, 0, 0, I_VPERMW }, + { "vpexpandd", 9, TOKEN_INSN, 0, 0, I_VPEXPANDD }, + { "vpexpandq", 9, TOKEN_INSN, 0, 0, I_VPEXPANDQ }, + { "vplzcntd", 8, TOKEN_INSN, 0, 0, I_VPLZCNTD }, + { "vplzcntq", 8, TOKEN_INSN, 0, 0, I_VPLZCNTQ }, + { "vpmaxsq", 7, TOKEN_INSN, 0, 0, I_VPMAXSQ }, + { "vpmaxuq", 7, TOKEN_INSN, 0, 0, I_VPMAXUQ }, + { "vpminsq", 7, TOKEN_INSN, 0, 0, I_VPMINSQ }, + { "vpminuq", 7, TOKEN_INSN, 0, 0, I_VPMINUQ }, + { "vpmovb2m", 8, TOKEN_INSN, 0, 0, I_VPMOVB2M }, + { "vpmovd2m", 8, TOKEN_INSN, 0, 0, I_VPMOVD2M }, + { "vpmovdb", 7, TOKEN_INSN, 0, 0, I_VPMOVDB }, + { "vpmovdw", 7, TOKEN_INSN, 0, 0, I_VPMOVDW }, + { "vpmovm2b", 8, TOKEN_INSN, 0, 0, I_VPMOVM2B }, + { "vpmovm2d", 8, TOKEN_INSN, 0, 0, I_VPMOVM2D }, + { "vpmovm2q", 8, TOKEN_INSN, 0, 0, I_VPMOVM2Q }, + { "vpmovm2w", 8, TOKEN_INSN, 0, 0, I_VPMOVM2W }, + { "vpmovq2m", 8, TOKEN_INSN, 0, 0, I_VPMOVQ2M }, + { "vpmovqb", 7, TOKEN_INSN, 0, 0, I_VPMOVQB }, + { "vpmovqd", 7, TOKEN_INSN, 0, 0, I_VPMOVQD }, + { "vpmovqw", 7, TOKEN_INSN, 0, 0, I_VPMOVQW }, + { "vpmovsdb", 8, TOKEN_INSN, 0, 0, I_VPMOVSDB }, + { "vpmovsdw", 8, TOKEN_INSN, 0, 0, I_VPMOVSDW }, + { "vpmovsqb", 8, TOKEN_INSN, 0, 0, I_VPMOVSQB }, + { "vpmovsqd", 8, TOKEN_INSN, 0, 0, I_VPMOVSQD }, + { "vpmovsqw", 8, TOKEN_INSN, 0, 0, I_VPMOVSQW }, + { "vpmovswb", 8, TOKEN_INSN, 0, 0, I_VPMOVSWB }, + { "vpmovusdb", 9, TOKEN_INSN, 0, 0, I_VPMOVUSDB }, + { "vpmovusdw", 9, TOKEN_INSN, 0, 0, I_VPMOVUSDW }, + { "vpmovusqb", 9, TOKEN_INSN, 0, 0, I_VPMOVUSQB }, + { "vpmovusqd", 9, TOKEN_INSN, 0, 0, I_VPMOVUSQD }, + { "vpmovusqw", 9, TOKEN_INSN, 0, 0, I_VPMOVUSQW }, + { "vpmovuswb", 9, TOKEN_INSN, 0, 0, I_VPMOVUSWB }, + { "vpmovw2m", 8, TOKEN_INSN, 0, 0, I_VPMOVW2M }, + { "vpmovwb", 7, TOKEN_INSN, 0, 0, I_VPMOVWB }, + { "vpmullq", 7, TOKEN_INSN, 0, 0, I_VPMULLQ }, + { "vpmultishiftqb", 14, TOKEN_INSN, 0, 0, I_VPMULTISHIFTQB }, + { "vpord", 5, TOKEN_INSN, 0, 0, I_VPORD }, + { "vporq", 5, TOKEN_INSN, 0, 0, I_VPORQ }, + { "vprold", 6, TOKEN_INSN, 0, 0, I_VPROLD }, + { "vprolq", 6, TOKEN_INSN, 0, 0, I_VPROLQ }, + { "vprolvd", 7, TOKEN_INSN, 0, 0, I_VPROLVD }, + { "vprolvq", 7, TOKEN_INSN, 0, 0, I_VPROLVQ }, + { "vprord", 6, TOKEN_INSN, 0, 0, I_VPRORD }, + { "vprorq", 6, TOKEN_INSN, 0, 0, I_VPRORQ }, + { "vprorvd", 7, TOKEN_INSN, 0, 0, I_VPRORVD }, + { "vprorvq", 7, TOKEN_INSN, 0, 0, I_VPRORVQ }, + { "vpscatterdd", 11, TOKEN_INSN, 0, 0, I_VPSCATTERDD }, + { "vpscatterdq", 11, TOKEN_INSN, 0, 0, I_VPSCATTERDQ }, + { "vpscatterqd", 11, TOKEN_INSN, 0, 0, I_VPSCATTERQD }, + { "vpscatterqq", 11, TOKEN_INSN, 0, 0, I_VPSCATTERQQ }, + { "vpsllvw", 7, TOKEN_INSN, 0, 0, I_VPSLLVW }, + { "vpsraq", 6, TOKEN_INSN, 0, 0, I_VPSRAQ }, + { "vpsravq", 7, TOKEN_INSN, 0, 0, I_VPSRAVQ }, + { "vpsravw", 7, TOKEN_INSN, 0, 0, I_VPSRAVW }, + { "vpsrlvw", 7, TOKEN_INSN, 0, 0, I_VPSRLVW }, + { "vpternlogd", 10, TOKEN_INSN, 0, 0, I_VPTERNLOGD }, + { "vpternlogq", 10, TOKEN_INSN, 0, 0, I_VPTERNLOGQ }, + { "vptestmb", 8, TOKEN_INSN, 0, 0, I_VPTESTMB }, + { "vptestmd", 8, TOKEN_INSN, 0, 0, I_VPTESTMD }, + { "vptestmq", 8, TOKEN_INSN, 0, 0, I_VPTESTMQ }, + { "vptestmw", 8, TOKEN_INSN, 0, 0, I_VPTESTMW }, + { "vptestnmb", 9, TOKEN_INSN, 0, 0, I_VPTESTNMB }, + { "vptestnmd", 9, TOKEN_INSN, 0, 0, I_VPTESTNMD }, + { "vptestnmq", 9, TOKEN_INSN, 0, 0, I_VPTESTNMQ }, + { "vptestnmw", 9, TOKEN_INSN, 0, 0, I_VPTESTNMW }, + { "vpxord", 6, TOKEN_INSN, 0, 0, I_VPXORD }, + { "vpxorq", 6, TOKEN_INSN, 0, 0, I_VPXORQ }, + { "vrangepd", 8, TOKEN_INSN, 0, 0, I_VRANGEPD }, + { "vrangeps", 8, TOKEN_INSN, 0, 0, I_VRANGEPS }, + { "vrangesd", 8, TOKEN_INSN, 0, 0, I_VRANGESD }, + { "vrangess", 8, TOKEN_INSN, 0, 0, I_VRANGESS }, + { "vrcp14pd", 8, TOKEN_INSN, 0, 0, I_VRCP14PD }, + { "vrcp14ps", 8, TOKEN_INSN, 0, 0, I_VRCP14PS }, + { "vrcp14sd", 8, TOKEN_INSN, 0, 0, I_VRCP14SD }, + { "vrcp14ss", 8, TOKEN_INSN, 0, 0, I_VRCP14SS }, + { "vrcp28pd", 8, TOKEN_INSN, 0, 0, I_VRCP28PD }, + { "vrcp28ps", 8, TOKEN_INSN, 0, 0, I_VRCP28PS }, + { "vrcp28sd", 8, TOKEN_INSN, 0, 0, I_VRCP28SD }, + { "vrcp28ss", 8, TOKEN_INSN, 0, 0, I_VRCP28SS }, + { "vreducepd", 9, TOKEN_INSN, 0, 0, I_VREDUCEPD }, + { "vreduceps", 9, TOKEN_INSN, 0, 0, I_VREDUCEPS }, + { "vreducesd", 9, TOKEN_INSN, 0, 0, I_VREDUCESD }, + { "vreducess", 9, TOKEN_INSN, 0, 0, I_VREDUCESS }, + { "vrndscalepd", 11, TOKEN_INSN, 0, 0, I_VRNDSCALEPD }, + { "vrndscaleps", 11, TOKEN_INSN, 0, 0, I_VRNDSCALEPS }, + { "vrndscalesd", 11, TOKEN_INSN, 0, 0, I_VRNDSCALESD }, + { "vrndscaless", 11, TOKEN_INSN, 0, 0, I_VRNDSCALESS }, + { "vrsqrt14pd", 10, TOKEN_INSN, 0, 0, I_VRSQRT14PD }, + { "vrsqrt14ps", 10, TOKEN_INSN, 0, 0, I_VRSQRT14PS }, + { "vrsqrt14sd", 10, TOKEN_INSN, 0, 0, I_VRSQRT14SD }, + { "vrsqrt14ss", 10, TOKEN_INSN, 0, 0, I_VRSQRT14SS }, + { "vrsqrt28pd", 10, TOKEN_INSN, 0, 0, I_VRSQRT28PD }, + { "vrsqrt28ps", 10, TOKEN_INSN, 0, 0, I_VRSQRT28PS }, + { "vrsqrt28sd", 10, TOKEN_INSN, 0, 0, I_VRSQRT28SD }, + { "vrsqrt28ss", 10, TOKEN_INSN, 0, 0, I_VRSQRT28SS }, + { "vscalefpd", 9, TOKEN_INSN, 0, 0, I_VSCALEFPD }, + { "vscalefps", 9, TOKEN_INSN, 0, 0, I_VSCALEFPS }, + { "vscalefsd", 9, TOKEN_INSN, 0, 0, I_VSCALEFSD }, + { "vscalefss", 9, TOKEN_INSN, 0, 0, I_VSCALEFSS }, + { "vscatterdpd", 11, TOKEN_INSN, 0, 0, I_VSCATTERDPD }, + { "vscatterdps", 11, TOKEN_INSN, 0, 0, I_VSCATTERDPS }, + { "vscatterpf0dpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0DPD }, + { "vscatterpf0dps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0DPS }, + { "vscatterpf0qpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0QPD }, + { "vscatterpf0qps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF0QPS }, + { "vscatterpf1dpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1DPD }, + { "vscatterpf1dps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1DPS }, + { "vscatterpf1qpd", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1QPD }, + { "vscatterpf1qps", 14, TOKEN_INSN, 0, 0, I_VSCATTERPF1QPS }, + { "vscatterqpd", 11, TOKEN_INSN, 0, 0, I_VSCATTERQPD }, + { "vscatterqps", 11, TOKEN_INSN, 0, 0, I_VSCATTERQPS }, + { "vshuff32x4", 10, TOKEN_INSN, 0, 0, I_VSHUFF32X4 }, + { "vshuff64x2", 10, TOKEN_INSN, 0, 0, I_VSHUFF64X2 }, + { "vshufi32x4", 10, TOKEN_INSN, 0, 0, I_VSHUFI32X4 }, + { "vshufi64x2", 10, TOKEN_INSN, 0, 0, I_VSHUFI64X2 }, + { "rdpkru", 6, TOKEN_INSN, 0, 0, I_RDPKRU }, + { "wrpkru", 6, TOKEN_INSN, 0, 0, I_WRPKRU }, + { "rdpid", 5, TOKEN_INSN, 0, 0, I_RDPID }, + { "clflushopt", 10, TOKEN_INSN, 0, 0, I_CLFLUSHOPT }, + { "clwb", 4, TOKEN_INSN, 0, 0, I_CLWB }, + { "pcommit", 7, TOKEN_INSN, 0, 0, I_PCOMMIT }, + { "clzero", 6, TOKEN_INSN, 0, 0, I_CLZERO }, + { "ptwrite", 7, TOKEN_INSN, 0, 0, I_PTWRITE }, + { "cldemote", 8, TOKEN_INSN, 0, 0, I_CLDEMOTE }, + { "movdiri", 7, TOKEN_INSN, 0, 0, I_MOVDIRI }, + { "movdir64b", 9, TOKEN_INSN, 0, 0, I_MOVDIR64B }, + { "pconfig", 7, TOKEN_INSN, 0, 0, I_PCONFIG }, + { "tpause", 6, TOKEN_INSN, 0, 0, I_TPAUSE }, + { "umonitor", 8, TOKEN_INSN, 0, 0, I_UMONITOR }, + { "umwait", 6, TOKEN_INSN, 0, 0, I_UMWAIT }, + { "wbnoinvd", 8, TOKEN_INSN, 0, 0, I_WBNOINVD }, + { "gf2p8affineinvqb", 16, TOKEN_INSN, 0, 0, I_GF2P8AFFINEINVQB }, + { "vgf2p8affineinvqb", 17, TOKEN_INSN, 0, 0, I_VGF2P8AFFINEINVQB }, + { "gf2p8affineqb", 13, TOKEN_INSN, 0, 0, I_GF2P8AFFINEQB }, + { "vgf2p8affineqb", 14, TOKEN_INSN, 0, 0, I_VGF2P8AFFINEQB }, + { "gf2p8mulb", 9, TOKEN_INSN, 0, 0, I_GF2P8MULB }, + { "vgf2p8mulb", 10, TOKEN_INSN, 0, 0, I_VGF2P8MULB }, + { "vpcompressb", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSB }, + { "vpcompressw", 11, TOKEN_INSN, 0, 0, I_VPCOMPRESSW }, + { "vpexpandb", 9, TOKEN_INSN, 0, 0, I_VPEXPANDB }, + { "vpexpandw", 9, TOKEN_INSN, 0, 0, I_VPEXPANDW }, + { "vpshldw", 7, TOKEN_INSN, 0, 0, I_VPSHLDW }, + { "vpshldd", 7, TOKEN_INSN, 0, 0, I_VPSHLDD }, + { "vpshldq", 7, TOKEN_INSN, 0, 0, I_VPSHLDQ }, + { "vpshldvw", 8, TOKEN_INSN, 0, 0, I_VPSHLDVW }, + { "vpshldvd", 8, TOKEN_INSN, 0, 0, I_VPSHLDVD }, + { "vpshldvq", 8, TOKEN_INSN, 0, 0, I_VPSHLDVQ }, + { "vpshrdw", 7, TOKEN_INSN, 0, 0, I_VPSHRDW }, + { "vpshrdd", 7, TOKEN_INSN, 0, 0, I_VPSHRDD }, + { "vpshrdq", 7, TOKEN_INSN, 0, 0, I_VPSHRDQ }, + { "vpshrdvw", 8, TOKEN_INSN, 0, 0, I_VPSHRDVW }, + { "vpshrdvd", 8, TOKEN_INSN, 0, 0, I_VPSHRDVD }, + { "vpshrdvq", 8, TOKEN_INSN, 0, 0, I_VPSHRDVQ }, + { "vpdpbusd", 8, TOKEN_INSN, 0, 0, I_VPDPBUSD }, + { "vpdpbusds", 9, TOKEN_INSN, 0, 0, I_VPDPBUSDS }, + { "vpdpwssd", 8, TOKEN_INSN, 0, 0, I_VPDPWSSD }, + { "vpdpwssds", 9, TOKEN_INSN, 0, 0, I_VPDPWSSDS }, + { "vpopcntb", 8, TOKEN_INSN, 0, 0, I_VPOPCNTB }, + { "vpopcntw", 8, TOKEN_INSN, 0, 0, I_VPOPCNTW }, + { "vpopcntd", 8, TOKEN_INSN, 0, 0, I_VPOPCNTD }, + { "vpopcntq", 8, TOKEN_INSN, 0, 0, I_VPOPCNTQ }, + { "vpshufbitqmb", 12, TOKEN_INSN, 0, 0, I_VPSHUFBITQMB }, + { "v4fmaddps", 9, TOKEN_INSN, 0, 0, I_V4FMADDPS }, + { "v4fnmaddps", 10, TOKEN_INSN, 0, 0, I_V4FNMADDPS }, + { "v4fmaddss", 9, TOKEN_INSN, 0, 0, I_V4FMADDSS }, + { "v4fnmaddss", 10, TOKEN_INSN, 0, 0, I_V4FNMADDSS }, + { "v4dpwssds", 9, TOKEN_INSN, 0, 0, I_V4DPWSSDS }, + { "v4dpwssd", 8, TOKEN_INSN, 0, 0, I_V4DPWSSD }, + { "encls", 5, TOKEN_INSN, 0, 0, I_ENCLS }, + { "enclu", 5, TOKEN_INSN, 0, 0, I_ENCLU }, + { "enclv", 5, TOKEN_INSN, 0, 0, I_ENCLV }, + { "clrssbsy", 8, TOKEN_INSN, 0, 0, I_CLRSSBSY }, + { "endbr32", 7, TOKEN_INSN, 0, 0, I_ENDBR32 }, + { "endbr64", 7, TOKEN_INSN, 0, 0, I_ENDBR64 }, + { "incsspd", 7, TOKEN_INSN, 0, 0, I_INCSSPD }, + { "incsspq", 7, TOKEN_INSN, 0, 0, I_INCSSPQ }, + { "rdsspd", 6, TOKEN_INSN, 0, 0, I_RDSSPD }, + { "rdsspq", 6, TOKEN_INSN, 0, 0, I_RDSSPQ }, + { "rstorssp", 8, TOKEN_INSN, 0, 0, I_RSTORSSP }, + { "saveprevssp", 11, TOKEN_INSN, 0, 0, I_SAVEPREVSSP }, + { "setssbsy", 8, TOKEN_INSN, 0, 0, I_SETSSBSY }, + { "wrussd", 6, TOKEN_INSN, 0, 0, I_WRUSSD }, + { "wrussq", 6, TOKEN_INSN, 0, 0, I_WRUSSQ }, + { "wrssd", 5, TOKEN_INSN, 0, 0, I_WRSSD }, + { "wrssq", 5, TOKEN_INSN, 0, 0, I_WRSSQ }, + { "enqcmd", 6, TOKEN_INSN, 0, 0, I_ENQCMD }, + { "enqcmds", 7, TOKEN_INSN, 0, 0, I_ENQCMDS }, + { "serialize", 9, TOKEN_INSN, 0, 0, I_SERIALIZE }, + { "xresldtrk", 9, TOKEN_INSN, 0, 0, I_XRESLDTRK }, + { "xsusldtrk", 9, TOKEN_INSN, 0, 0, I_XSUSLDTRK }, + { "vcvtne2ps2bf16", 14, TOKEN_INSN, 0, 0, I_VCVTNE2PS2BF16 }, + { "vdpbf16ps", 9, TOKEN_INSN, 0, 0, I_VDPBF16PS }, + { "vp2intersectd", 13, TOKEN_INSN, 0, 0, I_VP2INTERSECTD }, + { "ldtilecfg", 9, TOKEN_INSN, 0, 0, I_LDTILECFG }, + { "sttilecfg", 9, TOKEN_INSN, 0, 0, I_STTILECFG }, + { "tdpbf16ps", 9, TOKEN_INSN, 0, 0, I_TDPBF16PS }, + { "tdpbssd", 7, TOKEN_INSN, 0, 0, I_TDPBSSD }, + { "tdpbsud", 7, TOKEN_INSN, 0, 0, I_TDPBSUD }, + { "tdpbusd", 7, TOKEN_INSN, 0, 0, I_TDPBUSD }, + { "tdpbuud", 7, TOKEN_INSN, 0, 0, I_TDPBUUD }, + { "tileloadd", 9, TOKEN_INSN, 0, 0, I_TILELOADD }, + { "tileloaddt1", 11, TOKEN_INSN, 0, 0, I_TILELOADDT1 }, + { "tilerelease", 11, TOKEN_INSN, 0, 0, I_TILERELEASE }, + { "tilestored", 10, TOKEN_INSN, 0, 0, I_TILESTORED }, + { "tilezero", 8, TOKEN_INSN, 0, 0, I_TILEZERO }, + { "vaddph", 6, TOKEN_INSN, 0, 0, I_VADDPH }, + { "vaddsh", 6, TOKEN_INSN, 0, 0, I_VADDSH }, + { "vcmpph", 6, TOKEN_INSN, 0, 0, I_VCMPPH }, + { "vcmpsh", 6, TOKEN_INSN, 0, 0, I_VCMPSH }, + { "vcomish", 7, TOKEN_INSN, 0, 0, I_VCOMISH }, + { "vcvtdq2ph", 9, TOKEN_INSN, 0, 0, I_VCVTDQ2PH }, + { "vcvtpd2ph", 9, TOKEN_INSN, 0, 0, I_VCVTPD2PH }, + { "vcvtph2dq", 9, TOKEN_INSN, 0, 0, I_VCVTPH2DQ }, + { "vcvtph2pd", 9, TOKEN_INSN, 0, 0, I_VCVTPH2PD }, + { "vcvtph2psx", 10, TOKEN_INSN, 0, 0, I_VCVTPH2PSX }, + { "vcvtph2qq", 9, TOKEN_INSN, 0, 0, I_VCVTPH2QQ }, + { "vcvtph2udq", 10, TOKEN_INSN, 0, 0, I_VCVTPH2UDQ }, + { "vcvtph2uqq", 10, TOKEN_INSN, 0, 0, I_VCVTPH2UQQ }, + { "vcvtph2uw", 9, TOKEN_INSN, 0, 0, I_VCVTPH2UW }, + { "vcvtph2w", 8, TOKEN_INSN, 0, 0, I_VCVTPH2W }, + { "vcvtqq2ph", 9, TOKEN_INSN, 0, 0, I_VCVTQQ2PH }, + { "vcvtsd2sh", 9, TOKEN_INSN, 0, 0, I_VCVTSD2SH }, + { "vcvtsh2sd", 9, TOKEN_INSN, 0, 0, I_VCVTSH2SD }, + { "vcvtsh2si", 9, TOKEN_INSN, 0, 0, I_VCVTSH2SI }, + { "vcvtsh2ss", 9, TOKEN_INSN, 0, 0, I_VCVTSH2SS }, + { "vcvtsh2usi", 10, TOKEN_INSN, 0, 0, I_VCVTSH2USI }, + { "vcvtsi2sh", 9, TOKEN_INSN, 0, 0, I_VCVTSI2SH }, + { "vcvtss2sh", 9, TOKEN_INSN, 0, 0, I_VCVTSS2SH }, + { "vcvttph2dq", 10, TOKEN_INSN, 0, 0, I_VCVTTPH2DQ }, + { "vcvttph2qq", 10, TOKEN_INSN, 0, 0, I_VCVTTPH2QQ }, + { "vcvttph2udq", 11, TOKEN_INSN, 0, 0, I_VCVTTPH2UDQ }, + { "vcvttph2uqq", 11, TOKEN_INSN, 0, 0, I_VCVTTPH2UQQ }, + { "vcvttph2uw", 10, TOKEN_INSN, 0, 0, I_VCVTTPH2UW }, + { "vcvttph2w", 9, TOKEN_INSN, 0, 0, I_VCVTTPH2W }, + { "vcvttsh2si", 10, TOKEN_INSN, 0, 0, I_VCVTTSH2SI }, + { "vcvttsh2usi", 11, TOKEN_INSN, 0, 0, I_VCVTTSH2USI }, + { "vcvtudq2ph", 10, TOKEN_INSN, 0, 0, I_VCVTUDQ2PH }, + { "vcvtuqq2ph", 10, TOKEN_INSN, 0, 0, I_VCVTUQQ2PH }, + { "vcvtusi2sh", 10, TOKEN_INSN, 0, 0, I_VCVTUSI2SH }, + { "vcvtuw2ph", 9, TOKEN_INSN, 0, 0, I_VCVTUW2PH }, + { "vcvtw2ph", 8, TOKEN_INSN, 0, 0, I_VCVTW2PH }, + { "vdivph", 6, TOKEN_INSN, 0, 0, I_VDIVPH }, + { "vdivsh", 6, TOKEN_INSN, 0, 0, I_VDIVSH }, + { "vfcmaddcph", 10, TOKEN_INSN, 0, 0, I_VFCMADDCPH }, + { "vfmaddcph", 9, TOKEN_INSN, 0, 0, I_VFMADDCPH }, + { "vfcmaddcsh", 10, TOKEN_INSN, 0, 0, I_VFCMADDCSH }, + { "vfmaddcsh", 9, TOKEN_INSN, 0, 0, I_VFMADDCSH }, + { "vfcmulcpch", 10, TOKEN_INSN, 0, 0, I_VFCMULCPCH }, + { "vfmulcpch", 9, TOKEN_INSN, 0, 0, I_VFMULCPCH }, + { "vfcmulcsh", 9, TOKEN_INSN, 0, 0, I_VFCMULCSH }, + { "vfmulcsh", 8, TOKEN_INSN, 0, 0, I_VFMULCSH }, + { "vfmaddsub132ph", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB132PH }, + { "vfmaddsub213ph", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB213PH }, + { "vfmaddsub231ph", 14, TOKEN_INSN, 0, 0, I_VFMADDSUB231PH }, + { "vfmsubadd132ph", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD132PH }, + { "vfmsubadd213ph", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD213PH }, + { "vfmsubadd231ph", 14, TOKEN_INSN, 0, 0, I_VFMSUBADD231PH }, + { "vpmadd132ph", 11, TOKEN_INSN, 0, 0, I_VPMADD132PH }, + { "vpmadd213ph", 11, TOKEN_INSN, 0, 0, I_VPMADD213PH }, + { "vpmadd231ph", 11, TOKEN_INSN, 0, 0, I_VPMADD231PH }, + { "vfmadd132ph", 11, TOKEN_INSN, 0, 0, I_VFMADD132PH }, + { "vfmadd213ph", 11, TOKEN_INSN, 0, 0, I_VFMADD213PH }, + { "vfmadd231ph", 11, TOKEN_INSN, 0, 0, I_VFMADD231PH }, + { "vpmadd132sh", 11, TOKEN_INSN, 0, 0, I_VPMADD132SH }, + { "vpmadd213sh", 11, TOKEN_INSN, 0, 0, I_VPMADD213SH }, + { "vpmadd231sh", 11, TOKEN_INSN, 0, 0, I_VPMADD231SH }, + { "vpnmadd132sh", 12, TOKEN_INSN, 0, 0, I_VPNMADD132SH }, + { "vpnmadd213sh", 12, TOKEN_INSN, 0, 0, I_VPNMADD213SH }, + { "vpnmadd231sh", 12, TOKEN_INSN, 0, 0, I_VPNMADD231SH }, + { "vpmsub132ph", 11, TOKEN_INSN, 0, 0, I_VPMSUB132PH }, + { "vpmsub213ph", 11, TOKEN_INSN, 0, 0, I_VPMSUB213PH }, + { "vpmsub231ph", 11, TOKEN_INSN, 0, 0, I_VPMSUB231PH }, + { "vfmsub132ph", 11, TOKEN_INSN, 0, 0, I_VFMSUB132PH }, + { "vfmsub213ph", 11, TOKEN_INSN, 0, 0, I_VFMSUB213PH }, + { "vfmsub231ph", 11, TOKEN_INSN, 0, 0, I_VFMSUB231PH }, + { "vpmsub132sh", 11, TOKEN_INSN, 0, 0, I_VPMSUB132SH }, + { "vpmsub213sh", 11, TOKEN_INSN, 0, 0, I_VPMSUB213SH }, + { "vpmsub231sh", 11, TOKEN_INSN, 0, 0, I_VPMSUB231SH }, + { "vpnmsub132sh", 12, TOKEN_INSN, 0, 0, I_VPNMSUB132SH }, + { "vpnmsub213sh", 12, TOKEN_INSN, 0, 0, I_VPNMSUB213SH }, + { "vpnmsub231sh", 12, TOKEN_INSN, 0, 0, I_VPNMSUB231SH }, + { "vfpclassph", 10, TOKEN_INSN, 0, 0, I_VFPCLASSPH }, + { "vfpclasssh", 10, TOKEN_INSN, 0, 0, I_VFPCLASSSH }, + { "vgetexpph", 9, TOKEN_INSN, 0, 0, I_VGETEXPPH }, + { "vgetexpsh", 9, TOKEN_INSN, 0, 0, I_VGETEXPSH }, + { "vgetmantph", 10, TOKEN_INSN, 0, 0, I_VGETMANTPH }, + { "vgetmantsh", 10, TOKEN_INSN, 0, 0, I_VGETMANTSH }, + { "vgetmaxph", 9, TOKEN_INSN, 0, 0, I_VGETMAXPH }, + { "vgetmaxsh", 9, TOKEN_INSN, 0, 0, I_VGETMAXSH }, + { "vgetminph", 9, TOKEN_INSN, 0, 0, I_VGETMINPH }, + { "vgetminsh", 9, TOKEN_INSN, 0, 0, I_VGETMINSH }, + { "vmovsh", 6, TOKEN_INSN, 0, 0, I_VMOVSH }, + { "vmovw", 5, TOKEN_INSN, 0, 0, I_VMOVW }, + { "vmulph", 6, TOKEN_INSN, 0, 0, I_VMULPH }, + { "vmulsh", 6, TOKEN_INSN, 0, 0, I_VMULSH }, + { "vrcpph", 6, TOKEN_INSN, 0, 0, I_VRCPPH }, + { "vrcpsh", 6, TOKEN_INSN, 0, 0, I_VRCPSH }, + { "vreduceph", 9, TOKEN_INSN, 0, 0, I_VREDUCEPH }, + { "vreducesh", 9, TOKEN_INSN, 0, 0, I_VREDUCESH }, + { "vendscaleph", 11, TOKEN_INSN, 0, 0, I_VENDSCALEPH }, + { "vendscalesh", 11, TOKEN_INSN, 0, 0, I_VENDSCALESH }, + { "vrsqrtph", 8, TOKEN_INSN, 0, 0, I_VRSQRTPH }, + { "vrsqrtsh", 8, TOKEN_INSN, 0, 0, I_VRSQRTSH }, + { "vscalefph", 9, TOKEN_INSN, 0, 0, I_VSCALEFPH }, + { "vscalefsh", 9, TOKEN_INSN, 0, 0, I_VSCALEFSH }, + { "vsqrtph", 7, TOKEN_INSN, 0, 0, I_VSQRTPH }, + { "vsqrtsh", 7, TOKEN_INSN, 0, 0, I_VSQRTSH }, + { "vsubph", 6, TOKEN_INSN, 0, 0, I_VSUBPH }, + { "vsubsh", 6, TOKEN_INSN, 0, 0, I_VSUBSH }, + { "vucomish", 8, TOKEN_INSN, 0, 0, I_VUCOMISH }, + { "aadd", 4, TOKEN_INSN, 0, 0, I_AADD }, + { "aand", 4, TOKEN_INSN, 0, 0, I_AAND }, + { "axor", 4, TOKEN_INSN, 0, 0, I_AXOR }, + { "clui", 4, TOKEN_INSN, 0, 0, I_CLUI }, + { "senduipi", 8, TOKEN_INSN, 0, 0, I_SENDUIPI }, + { "stui", 4, TOKEN_INSN, 0, 0, I_STUI }, + { "testui", 6, TOKEN_INSN, 0, 0, I_TESTUI }, + { "uiret", 5, TOKEN_INSN, 0, 0, I_UIRET }, + { "cmpaxadd", 8, TOKEN_INSN, 0, 0, I_CMPAXADD }, + { "cmpaexadd", 9, TOKEN_INSN, 0, 0, I_CMPAEXADD }, + { "cmpbxadd", 8, TOKEN_INSN, 0, 0, I_CMPBXADD }, + { "cmpbexadd", 9, TOKEN_INSN, 0, 0, I_CMPBEXADD }, + { "cmpcxadd", 8, TOKEN_INSN, 0, 0, I_CMPCXADD }, + { "cmpexadd", 8, TOKEN_INSN, 0, 0, I_CMPEXADD }, + { "cmpgxadd", 8, TOKEN_INSN, 0, 0, I_CMPGXADD }, + { "cmpgexadd", 9, TOKEN_INSN, 0, 0, I_CMPGEXADD }, + { "cmplxadd", 8, TOKEN_INSN, 0, 0, I_CMPLXADD }, + { "cmplexadd", 9, TOKEN_INSN, 0, 0, I_CMPLEXADD }, + { "cmpnaxadd", 9, TOKEN_INSN, 0, 0, I_CMPNAXADD }, + { "cmpnaexadd", 10, TOKEN_INSN, 0, 0, I_CMPNAEXADD }, + { "cmpnbxadd", 9, TOKEN_INSN, 0, 0, I_CMPNBXADD }, + { "cmpnbexadd", 10, TOKEN_INSN, 0, 0, I_CMPNBEXADD }, + { "cmpncxadd", 9, TOKEN_INSN, 0, 0, I_CMPNCXADD }, + { "cmpnexadd", 9, TOKEN_INSN, 0, 0, I_CMPNEXADD }, + { "cmpngxadd", 9, TOKEN_INSN, 0, 0, I_CMPNGXADD }, + { "cmpngexadd", 10, TOKEN_INSN, 0, 0, I_CMPNGEXADD }, + { "cmpnlxadd", 9, TOKEN_INSN, 0, 0, I_CMPNLXADD }, + { "cmpnlexadd", 10, TOKEN_INSN, 0, 0, I_CMPNLEXADD }, + { "cmpnoxadd", 9, TOKEN_INSN, 0, 0, I_CMPNOXADD }, + { "cmpnpxadd", 9, TOKEN_INSN, 0, 0, I_CMPNPXADD }, + { "cmpnsxadd", 9, TOKEN_INSN, 0, 0, I_CMPNSXADD }, + { "cmpnzxadd", 9, TOKEN_INSN, 0, 0, I_CMPNZXADD }, + { "cmpoxadd", 8, TOKEN_INSN, 0, 0, I_CMPOXADD }, + { "cmppxadd", 8, TOKEN_INSN, 0, 0, I_CMPPXADD }, + { "cmppexadd", 9, TOKEN_INSN, 0, 0, I_CMPPEXADD }, + { "cmppoxadd", 9, TOKEN_INSN, 0, 0, I_CMPPOXADD }, + { "cmpsxadd", 8, TOKEN_INSN, 0, 0, I_CMPSXADD }, + { "cmpzxadd", 8, TOKEN_INSN, 0, 0, I_CMPZXADD }, + { "wrmsrns", 7, TOKEN_INSN, 0, 0, I_WRMSRNS }, + { "rdmsrlist", 9, TOKEN_INSN, 0, 0, I_RDMSRLIST }, + { "wrmsrlist", 9, TOKEN_INSN, 0, 0, I_WRMSRLIST }, + { "hreset", 6, TOKEN_INSN, 0, 0, I_HRESET }, + { "hint_nop0", 9, TOKEN_INSN, 0, 0, I_HINT_NOP0 }, + { "hint_nop1", 9, TOKEN_INSN, 0, 0, I_HINT_NOP1 }, + { "hint_nop2", 9, TOKEN_INSN, 0, 0, I_HINT_NOP2 }, + { "hint_nop3", 9, TOKEN_INSN, 0, 0, I_HINT_NOP3 }, + { "hint_nop4", 9, TOKEN_INSN, 0, 0, I_HINT_NOP4 }, + { "hint_nop5", 9, TOKEN_INSN, 0, 0, I_HINT_NOP5 }, + { "hint_nop6", 9, TOKEN_INSN, 0, 0, I_HINT_NOP6 }, + { "hint_nop7", 9, TOKEN_INSN, 0, 0, I_HINT_NOP7 }, + { "hint_nop8", 9, TOKEN_INSN, 0, 0, I_HINT_NOP8 }, + { "hint_nop9", 9, TOKEN_INSN, 0, 0, I_HINT_NOP9 }, + { "hint_nop10", 10, TOKEN_INSN, 0, 0, I_HINT_NOP10 }, + { "hint_nop11", 10, TOKEN_INSN, 0, 0, I_HINT_NOP11 }, + { "hint_nop12", 10, TOKEN_INSN, 0, 0, I_HINT_NOP12 }, + { "hint_nop13", 10, TOKEN_INSN, 0, 0, I_HINT_NOP13 }, + { "hint_nop14", 10, TOKEN_INSN, 0, 0, I_HINT_NOP14 }, + { "hint_nop15", 10, TOKEN_INSN, 0, 0, I_HINT_NOP15 }, + { "hint_nop16", 10, TOKEN_INSN, 0, 0, I_HINT_NOP16 }, + { "hint_nop17", 10, TOKEN_INSN, 0, 0, I_HINT_NOP17 }, + { "hint_nop18", 10, TOKEN_INSN, 0, 0, I_HINT_NOP18 }, + { "hint_nop19", 10, TOKEN_INSN, 0, 0, I_HINT_NOP19 }, + { "hint_nop20", 10, TOKEN_INSN, 0, 0, I_HINT_NOP20 }, + { "hint_nop21", 10, TOKEN_INSN, 0, 0, I_HINT_NOP21 }, + { "hint_nop22", 10, TOKEN_INSN, 0, 0, I_HINT_NOP22 }, + { "hint_nop23", 10, TOKEN_INSN, 0, 0, I_HINT_NOP23 }, + { "hint_nop24", 10, TOKEN_INSN, 0, 0, I_HINT_NOP24 }, + { "hint_nop25", 10, TOKEN_INSN, 0, 0, I_HINT_NOP25 }, + { "hint_nop26", 10, TOKEN_INSN, 0, 0, I_HINT_NOP26 }, + { "hint_nop27", 10, TOKEN_INSN, 0, 0, I_HINT_NOP27 }, + { "hint_nop28", 10, TOKEN_INSN, 0, 0, I_HINT_NOP28 }, + { "hint_nop29", 10, TOKEN_INSN, 0, 0, I_HINT_NOP29 }, + { "hint_nop30", 10, TOKEN_INSN, 0, 0, I_HINT_NOP30 }, + { "hint_nop31", 10, TOKEN_INSN, 0, 0, I_HINT_NOP31 }, + { "hint_nop32", 10, TOKEN_INSN, 0, 0, I_HINT_NOP32 }, + { "hint_nop33", 10, TOKEN_INSN, 0, 0, I_HINT_NOP33 }, + { "hint_nop34", 10, TOKEN_INSN, 0, 0, I_HINT_NOP34 }, + { "hint_nop35", 10, TOKEN_INSN, 0, 0, I_HINT_NOP35 }, + { "hint_nop36", 10, TOKEN_INSN, 0, 0, I_HINT_NOP36 }, + { "hint_nop37", 10, TOKEN_INSN, 0, 0, I_HINT_NOP37 }, + { "hint_nop38", 10, TOKEN_INSN, 0, 0, I_HINT_NOP38 }, + { "hint_nop39", 10, TOKEN_INSN, 0, 0, I_HINT_NOP39 }, + { "hint_nop40", 10, TOKEN_INSN, 0, 0, I_HINT_NOP40 }, + { "hint_nop41", 10, TOKEN_INSN, 0, 0, I_HINT_NOP41 }, + { "hint_nop42", 10, TOKEN_INSN, 0, 0, I_HINT_NOP42 }, + { "hint_nop43", 10, TOKEN_INSN, 0, 0, I_HINT_NOP43 }, + { "hint_nop44", 10, TOKEN_INSN, 0, 0, I_HINT_NOP44 }, + { "hint_nop45", 10, TOKEN_INSN, 0, 0, I_HINT_NOP45 }, + { "hint_nop46", 10, TOKEN_INSN, 0, 0, I_HINT_NOP46 }, + { "hint_nop47", 10, TOKEN_INSN, 0, 0, I_HINT_NOP47 }, + { "hint_nop48", 10, TOKEN_INSN, 0, 0, I_HINT_NOP48 }, + { "hint_nop49", 10, TOKEN_INSN, 0, 0, I_HINT_NOP49 }, + { "hint_nop50", 10, TOKEN_INSN, 0, 0, I_HINT_NOP50 }, + { "hint_nop51", 10, TOKEN_INSN, 0, 0, I_HINT_NOP51 }, + { "hint_nop52", 10, TOKEN_INSN, 0, 0, I_HINT_NOP52 }, + { "hint_nop53", 10, TOKEN_INSN, 0, 0, I_HINT_NOP53 }, + { "hint_nop54", 10, TOKEN_INSN, 0, 0, I_HINT_NOP54 }, + { "hint_nop55", 10, TOKEN_INSN, 0, 0, I_HINT_NOP55 }, + { "hint_nop56", 10, TOKEN_INSN, 0, 0, I_HINT_NOP56 }, + { "hint_nop57", 10, TOKEN_INSN, 0, 0, I_HINT_NOP57 }, + { "hint_nop58", 10, TOKEN_INSN, 0, 0, I_HINT_NOP58 }, + { "hint_nop59", 10, TOKEN_INSN, 0, 0, I_HINT_NOP59 }, + { "hint_nop60", 10, TOKEN_INSN, 0, 0, I_HINT_NOP60 }, + { "hint_nop61", 10, TOKEN_INSN, 0, 0, I_HINT_NOP61 }, + { "hint_nop62", 10, TOKEN_INSN, 0, 0, I_HINT_NOP62 }, + { "hint_nop63", 10, TOKEN_INSN, 0, 0, I_HINT_NOP63 }, + { "al", 2, TOKEN_REG, 0, 0, R_AL }, + { "ah", 2, TOKEN_REG, 0, 0, R_AH }, + { "ax", 2, TOKEN_REG, 0, 0, R_AX }, + { "eax", 3, TOKEN_REG, 0, 0, R_EAX }, + { "rax", 3, TOKEN_REG, 0, 0, R_RAX }, + { "bl", 2, TOKEN_REG, 0, 0, R_BL }, + { "bh", 2, TOKEN_REG, 0, 0, R_BH }, + { "bx", 2, TOKEN_REG, 0, 0, R_BX }, + { "ebx", 3, TOKEN_REG, 0, 0, R_EBX }, + { "rbx", 3, TOKEN_REG, 0, 0, R_RBX }, + { "cl", 2, TOKEN_REG, 0, 0, R_CL }, + { "ch", 2, TOKEN_REG, 0, 0, R_CH }, + { "cx", 2, TOKEN_REG, 0, 0, R_CX }, + { "ecx", 3, TOKEN_REG, 0, 0, R_ECX }, + { "rcx", 3, TOKEN_REG, 0, 0, R_RCX }, + { "dl", 2, TOKEN_REG, 0, 0, R_DL }, + { "dh", 2, TOKEN_REG, 0, 0, R_DH }, + { "dx", 2, TOKEN_REG, 0, 0, R_DX }, + { "edx", 3, TOKEN_REG, 0, 0, R_EDX }, + { "rdx", 3, TOKEN_REG, 0, 0, R_RDX }, + { "spl", 3, TOKEN_REG, 0, 0, R_SPL }, + { "sp", 2, TOKEN_REG, 0, 0, R_SP }, + { "esp", 3, TOKEN_REG, 0, 0, R_ESP }, + { "rsp", 3, TOKEN_REG, 0, 0, R_RSP }, + { "bpl", 3, TOKEN_REG, 0, 0, R_BPL }, + { "bp", 2, TOKEN_REG, 0, 0, R_BP }, + { "ebp", 3, TOKEN_REG, 0, 0, R_EBP }, + { "rbp", 3, TOKEN_REG, 0, 0, R_RBP }, + { "sil", 3, TOKEN_REG, 0, 0, R_SIL }, + { "si", 2, TOKEN_REG, 0, 0, R_SI }, + { "esi", 3, TOKEN_REG, 0, 0, R_ESI }, + { "rsi", 3, TOKEN_REG, 0, 0, R_RSI }, + { "dil", 3, TOKEN_REG, 0, 0, R_DIL }, + { "di", 2, TOKEN_REG, 0, 0, R_DI }, + { "edi", 3, TOKEN_REG, 0, 0, R_EDI }, + { "rdi", 3, TOKEN_REG, 0, 0, R_RDI }, + { "r8b", 3, TOKEN_REG, 0, 0, R_R8B }, + { "r9b", 3, TOKEN_REG, 0, 0, R_R9B }, + { "r10b", 4, TOKEN_REG, 0, 0, R_R10B }, + { "r11b", 4, TOKEN_REG, 0, 0, R_R11B }, + { "r12b", 4, TOKEN_REG, 0, 0, R_R12B }, + { "r13b", 4, TOKEN_REG, 0, 0, R_R13B }, + { "r14b", 4, TOKEN_REG, 0, 0, R_R14B }, + { "r15b", 4, TOKEN_REG, 0, 0, R_R15B }, + { "r8w", 3, TOKEN_REG, 0, 0, R_R8W }, + { "r9w", 3, TOKEN_REG, 0, 0, R_R9W }, + { "r10w", 4, TOKEN_REG, 0, 0, R_R10W }, + { "r11w", 4, TOKEN_REG, 0, 0, R_R11W }, + { "r12w", 4, TOKEN_REG, 0, 0, R_R12W }, + { "r13w", 4, TOKEN_REG, 0, 0, R_R13W }, + { "r14w", 4, TOKEN_REG, 0, 0, R_R14W }, + { "r15w", 4, TOKEN_REG, 0, 0, R_R15W }, + { "r8d", 3, TOKEN_REG, 0, 0, R_R8D }, + { "r9d", 3, TOKEN_REG, 0, 0, R_R9D }, + { "r10d", 4, TOKEN_REG, 0, 0, R_R10D }, + { "r11d", 4, TOKEN_REG, 0, 0, R_R11D }, + { "r12d", 4, TOKEN_REG, 0, 0, R_R12D }, + { "r13d", 4, TOKEN_REG, 0, 0, R_R13D }, + { "r14d", 4, TOKEN_REG, 0, 0, R_R14D }, + { "r15d", 4, TOKEN_REG, 0, 0, R_R15D }, + { "r8", 2, TOKEN_REG, 0, 0, R_R8 }, + { "r9", 2, TOKEN_REG, 0, 0, R_R9 }, + { "r10", 3, TOKEN_REG, 0, 0, R_R10 }, + { "r11", 3, TOKEN_REG, 0, 0, R_R11 }, + { "r12", 3, TOKEN_REG, 0, 0, R_R12 }, + { "r13", 3, TOKEN_REG, 0, 0, R_R13 }, + { "r14", 3, TOKEN_REG, 0, 0, R_R14 }, + { "r15", 3, TOKEN_REG, 0, 0, R_R15 }, + { "es", 2, TOKEN_REG, 0, 0, R_ES }, + { "cs", 2, TOKEN_REG, 0, 0, R_CS }, + { "ss", 2, TOKEN_REG, 0, 0, R_SS }, + { "ds", 2, TOKEN_REG, 0, 0, R_DS }, + { "fs", 2, TOKEN_REG, 0, 0, R_FS }, + { "gs", 2, TOKEN_REG, 0, 0, R_GS }, + { "segr6", 5, TOKEN_REG, 0, 0, R_SEGR6 }, + { "segr7", 5, TOKEN_REG, 0, 0, R_SEGR7 }, + { "cr0", 3, TOKEN_REG, 0, 0, R_CR0 }, + { "cr1", 3, TOKEN_REG, 0, 0, R_CR1 }, + { "cr2", 3, TOKEN_REG, 0, 0, R_CR2 }, + { "cr3", 3, TOKEN_REG, 0, 0, R_CR3 }, + { "cr4", 3, TOKEN_REG, 0, 0, R_CR4 }, + { "cr5", 3, TOKEN_REG, 0, 0, R_CR5 }, + { "cr6", 3, TOKEN_REG, 0, 0, R_CR6 }, + { "cr7", 3, TOKEN_REG, 0, 0, R_CR7 }, + { "cr8", 3, TOKEN_REG, 0, 0, R_CR8 }, + { "cr9", 3, TOKEN_REG, 0, 0, R_CR9 }, + { "cr10", 4, TOKEN_REG, 0, 0, R_CR10 }, + { "cr11", 4, TOKEN_REG, 0, 0, R_CR11 }, + { "cr12", 4, TOKEN_REG, 0, 0, R_CR12 }, + { "cr13", 4, TOKEN_REG, 0, 0, R_CR13 }, + { "cr14", 4, TOKEN_REG, 0, 0, R_CR14 }, + { "cr15", 4, TOKEN_REG, 0, 0, R_CR15 }, + { "dr0", 3, TOKEN_REG, 0, 0, R_DR0 }, + { "dr1", 3, TOKEN_REG, 0, 0, R_DR1 }, + { "dr2", 3, TOKEN_REG, 0, 0, R_DR2 }, + { "dr3", 3, TOKEN_REG, 0, 0, R_DR3 }, + { "dr4", 3, TOKEN_REG, 0, 0, R_DR4 }, + { "dr5", 3, TOKEN_REG, 0, 0, R_DR5 }, + { "dr6", 3, TOKEN_REG, 0, 0, R_DR6 }, + { "dr7", 3, TOKEN_REG, 0, 0, R_DR7 }, + { "dr8", 3, TOKEN_REG, 0, 0, R_DR8 }, + { "dr9", 3, TOKEN_REG, 0, 0, R_DR9 }, + { "dr10", 4, TOKEN_REG, 0, 0, R_DR10 }, + { "dr11", 4, TOKEN_REG, 0, 0, R_DR11 }, + { "dr12", 4, TOKEN_REG, 0, 0, R_DR12 }, + { "dr13", 4, TOKEN_REG, 0, 0, R_DR13 }, + { "dr14", 4, TOKEN_REG, 0, 0, R_DR14 }, + { "dr15", 4, TOKEN_REG, 0, 0, R_DR15 }, + { "tr0", 3, TOKEN_REG, 0, 0, R_TR0 }, + { "tr1", 3, TOKEN_REG, 0, 0, R_TR1 }, + { "tr2", 3, TOKEN_REG, 0, 0, R_TR2 }, + { "tr3", 3, TOKEN_REG, 0, 0, R_TR3 }, + { "tr4", 3, TOKEN_REG, 0, 0, R_TR4 }, + { "tr5", 3, TOKEN_REG, 0, 0, R_TR5 }, + { "tr6", 3, TOKEN_REG, 0, 0, R_TR6 }, + { "tr7", 3, TOKEN_REG, 0, 0, R_TR7 }, + { "st0", 3, TOKEN_REG, 0, 0, R_ST0 }, + { "st1", 3, TOKEN_REG, 0, 0, R_ST1 }, + { "st2", 3, TOKEN_REG, 0, 0, R_ST2 }, + { "st3", 3, TOKEN_REG, 0, 0, R_ST3 }, + { "st4", 3, TOKEN_REG, 0, 0, R_ST4 }, + { "st5", 3, TOKEN_REG, 0, 0, R_ST5 }, + { "st6", 3, TOKEN_REG, 0, 0, R_ST6 }, + { "st7", 3, TOKEN_REG, 0, 0, R_ST7 }, + { "mm0", 3, TOKEN_REG, 0, 0, R_MM0 }, + { "mm1", 3, TOKEN_REG, 0, 0, R_MM1 }, + { "mm2", 3, TOKEN_REG, 0, 0, R_MM2 }, + { "mm3", 3, TOKEN_REG, 0, 0, R_MM3 }, + { "mm4", 3, TOKEN_REG, 0, 0, R_MM4 }, + { "mm5", 3, TOKEN_REG, 0, 0, R_MM5 }, + { "mm6", 3, TOKEN_REG, 0, 0, R_MM6 }, + { "mm7", 3, TOKEN_REG, 0, 0, R_MM7 }, + { "xmm0", 4, TOKEN_REG, 0, 0, R_XMM0 }, + { "xmm1", 4, TOKEN_REG, 0, 0, R_XMM1 }, + { "xmm2", 4, TOKEN_REG, 0, 0, R_XMM2 }, + { "xmm3", 4, TOKEN_REG, 0, 0, R_XMM3 }, + { "xmm4", 4, TOKEN_REG, 0, 0, R_XMM4 }, + { "xmm5", 4, TOKEN_REG, 0, 0, R_XMM5 }, + { "xmm6", 4, TOKEN_REG, 0, 0, R_XMM6 }, + { "xmm7", 4, TOKEN_REG, 0, 0, R_XMM7 }, + { "xmm8", 4, TOKEN_REG, 0, 0, R_XMM8 }, + { "xmm9", 4, TOKEN_REG, 0, 0, R_XMM9 }, + { "xmm10", 5, TOKEN_REG, 0, 0, R_XMM10 }, + { "xmm11", 5, TOKEN_REG, 0, 0, R_XMM11 }, + { "xmm12", 5, TOKEN_REG, 0, 0, R_XMM12 }, + { "xmm13", 5, TOKEN_REG, 0, 0, R_XMM13 }, + { "xmm14", 5, TOKEN_REG, 0, 0, R_XMM14 }, + { "xmm15", 5, TOKEN_REG, 0, 0, R_XMM15 }, + { "xmm16", 5, TOKEN_REG, 0, 0, R_XMM16 }, + { "xmm17", 5, TOKEN_REG, 0, 0, R_XMM17 }, + { "xmm18", 5, TOKEN_REG, 0, 0, R_XMM18 }, + { "xmm19", 5, TOKEN_REG, 0, 0, R_XMM19 }, + { "xmm20", 5, TOKEN_REG, 0, 0, R_XMM20 }, + { "xmm21", 5, TOKEN_REG, 0, 0, R_XMM21 }, + { "xmm22", 5, TOKEN_REG, 0, 0, R_XMM22 }, + { "xmm23", 5, TOKEN_REG, 0, 0, R_XMM23 }, + { "xmm24", 5, TOKEN_REG, 0, 0, R_XMM24 }, + { "xmm25", 5, TOKEN_REG, 0, 0, R_XMM25 }, + { "xmm26", 5, TOKEN_REG, 0, 0, R_XMM26 }, + { "xmm27", 5, TOKEN_REG, 0, 0, R_XMM27 }, + { "xmm28", 5, TOKEN_REG, 0, 0, R_XMM28 }, + { "xmm29", 5, TOKEN_REG, 0, 0, R_XMM29 }, + { "xmm30", 5, TOKEN_REG, 0, 0, R_XMM30 }, + { "xmm31", 5, TOKEN_REG, 0, 0, R_XMM31 }, + { "ymm0", 4, TOKEN_REG, 0, 0, R_YMM0 }, + { "ymm1", 4, TOKEN_REG, 0, 0, R_YMM1 }, + { "ymm2", 4, TOKEN_REG, 0, 0, R_YMM2 }, + { "ymm3", 4, TOKEN_REG, 0, 0, R_YMM3 }, + { "ymm4", 4, TOKEN_REG, 0, 0, R_YMM4 }, + { "ymm5", 4, TOKEN_REG, 0, 0, R_YMM5 }, + { "ymm6", 4, TOKEN_REG, 0, 0, R_YMM6 }, + { "ymm7", 4, TOKEN_REG, 0, 0, R_YMM7 }, + { "ymm8", 4, TOKEN_REG, 0, 0, R_YMM8 }, + { "ymm9", 4, TOKEN_REG, 0, 0, R_YMM9 }, + { "ymm10", 5, TOKEN_REG, 0, 0, R_YMM10 }, + { "ymm11", 5, TOKEN_REG, 0, 0, R_YMM11 }, + { "ymm12", 5, TOKEN_REG, 0, 0, R_YMM12 }, + { "ymm13", 5, TOKEN_REG, 0, 0, R_YMM13 }, + { "ymm14", 5, TOKEN_REG, 0, 0, R_YMM14 }, + { "ymm15", 5, TOKEN_REG, 0, 0, R_YMM15 }, + { "ymm16", 5, TOKEN_REG, 0, 0, R_YMM16 }, + { "ymm17", 5, TOKEN_REG, 0, 0, R_YMM17 }, + { "ymm18", 5, TOKEN_REG, 0, 0, R_YMM18 }, + { "ymm19", 5, TOKEN_REG, 0, 0, R_YMM19 }, + { "ymm20", 5, TOKEN_REG, 0, 0, R_YMM20 }, + { "ymm21", 5, TOKEN_REG, 0, 0, R_YMM21 }, + { "ymm22", 5, TOKEN_REG, 0, 0, R_YMM22 }, + { "ymm23", 5, TOKEN_REG, 0, 0, R_YMM23 }, + { "ymm24", 5, TOKEN_REG, 0, 0, R_YMM24 }, + { "ymm25", 5, TOKEN_REG, 0, 0, R_YMM25 }, + { "ymm26", 5, TOKEN_REG, 0, 0, R_YMM26 }, + { "ymm27", 5, TOKEN_REG, 0, 0, R_YMM27 }, + { "ymm28", 5, TOKEN_REG, 0, 0, R_YMM28 }, + { "ymm29", 5, TOKEN_REG, 0, 0, R_YMM29 }, + { "ymm30", 5, TOKEN_REG, 0, 0, R_YMM30 }, + { "ymm31", 5, TOKEN_REG, 0, 0, R_YMM31 }, + { "zmm0", 4, TOKEN_REG, 0, 0, R_ZMM0 }, + { "zmm1", 4, TOKEN_REG, 0, 0, R_ZMM1 }, + { "zmm2", 4, TOKEN_REG, 0, 0, R_ZMM2 }, + { "zmm3", 4, TOKEN_REG, 0, 0, R_ZMM3 }, + { "zmm4", 4, TOKEN_REG, 0, 0, R_ZMM4 }, + { "zmm5", 4, TOKEN_REG, 0, 0, R_ZMM5 }, + { "zmm6", 4, TOKEN_REG, 0, 0, R_ZMM6 }, + { "zmm7", 4, TOKEN_REG, 0, 0, R_ZMM7 }, + { "zmm8", 4, TOKEN_REG, 0, 0, R_ZMM8 }, + { "zmm9", 4, TOKEN_REG, 0, 0, R_ZMM9 }, + { "zmm10", 5, TOKEN_REG, 0, 0, R_ZMM10 }, + { "zmm11", 5, TOKEN_REG, 0, 0, R_ZMM11 }, + { "zmm12", 5, TOKEN_REG, 0, 0, R_ZMM12 }, + { "zmm13", 5, TOKEN_REG, 0, 0, R_ZMM13 }, + { "zmm14", 5, TOKEN_REG, 0, 0, R_ZMM14 }, + { "zmm15", 5, TOKEN_REG, 0, 0, R_ZMM15 }, + { "zmm16", 5, TOKEN_REG, 0, 0, R_ZMM16 }, + { "zmm17", 5, TOKEN_REG, 0, 0, R_ZMM17 }, + { "zmm18", 5, TOKEN_REG, 0, 0, R_ZMM18 }, + { "zmm19", 5, TOKEN_REG, 0, 0, R_ZMM19 }, + { "zmm20", 5, TOKEN_REG, 0, 0, R_ZMM20 }, + { "zmm21", 5, TOKEN_REG, 0, 0, R_ZMM21 }, + { "zmm22", 5, TOKEN_REG, 0, 0, R_ZMM22 }, + { "zmm23", 5, TOKEN_REG, 0, 0, R_ZMM23 }, + { "zmm24", 5, TOKEN_REG, 0, 0, R_ZMM24 }, + { "zmm25", 5, TOKEN_REG, 0, 0, R_ZMM25 }, + { "zmm26", 5, TOKEN_REG, 0, 0, R_ZMM26 }, + { "zmm27", 5, TOKEN_REG, 0, 0, R_ZMM27 }, + { "zmm28", 5, TOKEN_REG, 0, 0, R_ZMM28 }, + { "zmm29", 5, TOKEN_REG, 0, 0, R_ZMM29 }, + { "zmm30", 5, TOKEN_REG, 0, 0, R_ZMM30 }, + { "zmm31", 5, TOKEN_REG, 0, 0, R_ZMM31 }, + { "tmm0", 4, TOKEN_REG, 0, 0, R_TMM0 }, + { "tmm1", 4, TOKEN_REG, 0, 0, R_TMM1 }, + { "tmm2", 4, TOKEN_REG, 0, 0, R_TMM2 }, + { "tmm3", 4, TOKEN_REG, 0, 0, R_TMM3 }, + { "tmm4", 4, TOKEN_REG, 0, 0, R_TMM4 }, + { "tmm5", 4, TOKEN_REG, 0, 0, R_TMM5 }, + { "tmm6", 4, TOKEN_REG, 0, 0, R_TMM6 }, + { "tmm7", 4, TOKEN_REG, 0, 0, R_TMM7 }, + { "k0", 2, TOKEN_REG, 0, 0, R_K0 }, + { "k1", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K1 }, + { "k2", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K2 }, + { "k3", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K3 }, + { "k4", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K4 }, + { "k5", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K5 }, + { "k6", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K6 }, + { "k7", 2, TOKEN_REG, 0, TFLAG_BRC_OPT, R_K7 }, + { "bnd0", 4, TOKEN_REG, 0, 0, R_BND0 }, + { "bnd1", 4, TOKEN_REG, 0, 0, R_BND1 }, + { "bnd2", 4, TOKEN_REG, 0, 0, R_BND2 }, + { "bnd3", 4, TOKEN_REG, 0, 0, R_BND3 }, + { "?", 1, TOKEN_QMARK, 0, 0, 0 }, + { "a16", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_A16 }, + { "a32", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_A32 }, + { "a64", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_A64 }, + { "asp", 3, TOKEN_PREFIX, PPS_ASIZE, 0, P_ASP }, + { "lock", 4, TOKEN_PREFIX, PPS_LOCK, 0, P_LOCK }, + { "o16", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_O16 }, + { "o32", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_O32 }, + { "o64", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_O64 }, + { "osp", 3, TOKEN_PREFIX, PPS_OSIZE, 0, P_OSP }, + { "rep", 3, TOKEN_PREFIX, PPS_REP, 0, P_REP }, + { "repe", 4, TOKEN_PREFIX, PPS_REP, 0, P_REPE }, + { "repne", 5, TOKEN_PREFIX, PPS_REP, 0, P_REPNE }, + { "repnz", 5, TOKEN_PREFIX, PPS_REP, 0, P_REPNZ }, + { "repz", 4, TOKEN_PREFIX, PPS_REP, 0, P_REPZ }, + { "xacquire", 8, TOKEN_PREFIX, PPS_REP, 0, P_XACQUIRE }, + { "xrelease", 8, TOKEN_PREFIX, PPS_REP, 0, P_XRELEASE }, + { "bnd", 3, TOKEN_PREFIX, PPS_REP, 0, P_BND }, + { "nobnd", 5, TOKEN_PREFIX, PPS_REP, 0, P_NOBND }, + { "times", 5, TOKEN_PREFIX, PPS_TIMES, 0, P_TIMES }, + { "wait", 4, TOKEN_PREFIX, PPS_WAIT, 0, P_WAIT }, + { "rex", 3, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_REX }, + { "evex", 4, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_EVEX }, + { "vex", 3, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_VEX }, + { "vex3", 4, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_VEX3 }, + { "vex2", 4, TOKEN_PREFIX, PPS_REX, TFLAG_BRC, P_VEX2 }, + { "byte", 4, TOKEN_SIZE, SIZE_BYTE, 0, S_BYTE }, + { "word", 4, TOKEN_SIZE, SIZE_WORD, 0, S_WORD }, + { "dword", 5, TOKEN_SIZE, SIZE_DWORD, 0, S_DWORD }, + { "qword", 5, TOKEN_SIZE, SIZE_QWORD, 0, S_QWORD }, + { "tword", 5, TOKEN_SIZE, SIZE_TWORD, 0, S_TWORD }, + { "oword", 5, TOKEN_SIZE, SIZE_OWORD, 0, S_OWORD }, + { "yword", 5, TOKEN_SIZE, SIZE_YWORD, 0, S_YWORD }, + { "zword", 5, TOKEN_SIZE, SIZE_ZWORD, 0, S_ZWORD }, + { "abs", 3, TOKEN_SPECIAL, 0, 0, S_ABS }, + { "far", 3, TOKEN_SPECIAL, 0, 0, S_FAR }, + { "long", 4, TOKEN_SPECIAL, 0, 0, S_LONG }, + { "near", 4, TOKEN_SPECIAL, 0, 0, S_NEAR }, + { "nosplit", 7, TOKEN_SPECIAL, 0, 0, S_NOSPLIT }, + { "rel", 3, TOKEN_SPECIAL, 0, 0, S_REL }, + { "short", 5, TOKEN_SPECIAL, 0, 0, S_SHORT }, + { "strict", 6, TOKEN_SPECIAL, 0, 0, S_STRICT }, + { "to", 2, TOKEN_SPECIAL, 0, 0, S_TO }, + { "ptr", 3, TOKEN_ID, 0, TFLAG_WARN, 0 }, + { "dup", 3, TOKEN_ID, 0, TFLAG_DUP, 0 }, + { "__?infinity?__", 14, TOKEN_FLOAT, 0, 0, 0 }, + { "__?nan?__", 9, TOKEN_FLOAT, 0, 0, 0 }, + { "__?qnan?__", 10, TOKEN_FLOAT, 0, 0, 0 }, + { "__?snan?__", 10, TOKEN_FLOAT, 0, 0, 0 }, + { "__?float8?__", 12, TOKEN_FLOATIZE, 0, 0, FLOAT_8 }, + { "__?float16?__", 13, TOKEN_FLOATIZE, 0, 0, FLOAT_16 }, + { "__?float32?__", 13, TOKEN_FLOATIZE, 0, 0, FLOAT_32 }, + { "__?float64?__", 13, TOKEN_FLOATIZE, 0, 0, FLOAT_64 }, + { "__?float80m?__", 14, TOKEN_FLOATIZE, 0, 0, FLOAT_80M }, + { "__?float80e?__", 14, TOKEN_FLOATIZE, 0, 0, FLOAT_80E }, + { "__?float128l?__", 15, TOKEN_FLOATIZE, 0, 0, FLOAT_128L }, + { "__?float128h?__", 15, TOKEN_FLOATIZE, 0, 0, FLOAT_128H }, + { "__?bfloat16?__", 14, TOKEN_FLOATIZE, 0, 0, FLOAT_B16 }, + { "__?utf16?__", 11, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF16 }, + { "__?utf16le?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF16LE }, + { "__?utf16be?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF16BE }, + { "__?utf32?__", 11, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF32 }, + { "__?utf32le?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF32LE }, + { "__?utf32be?__", 13, TOKEN_STRFUNC, 0, 0, STRFUNC_UTF32BE }, + { "__?ilog2e?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2E }, + { "__?ilog2w?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2W }, + { "__?ilog2f?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2F }, + { "__?ilog2c?__", 12, TOKEN_IFUNC, 0, 0, IFUNC_ILOG2C }, + { "seg", 3, TOKEN_SEG, 0, 0, 0 }, + { "wrt", 3, TOKEN_WRT, 0, 0, 0 }, + { "__?masm_ptr?__", 14, TOKEN_MASM_PTR, 0, 0, 0 }, + { "__?masm_flat?__", 15, TOKEN_MASM_FLAT, 0, 0, 0 }, + { "1to2", 4, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO2 }, + { "1to4", 4, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO4 }, + { "1to8", 4, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO8 }, + { "1to16", 5, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO16 }, + { "1to32", 5, TOKEN_DECORATOR, 0, TFLAG_BRC | TFLAG_BRDCAST , BRC_1TO32 }, + { "rn-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RN }, + { "rd-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RD }, + { "ru-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RU }, + { "rz-sae", 6, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_RZ }, + { "sae", 3, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_SAE }, + { "z", 1, TOKEN_DECORATOR, 0, TFLAG_BRC, BRC_Z }, + { ">>", 2, TOKEN_SHR, 0, 0, 0 }, + { ">>>", 3, TOKEN_SAR, 0, 0, 0 }, + { "<<", 2, TOKEN_SHL, 0, 0, 0 }, + { "<<<", 3, TOKEN_SHL, 0, 0, 0 }, + { "//", 2, TOKEN_SDIV, 0, 0, 0 }, + { "%%", 2, TOKEN_SMOD, 0, 0, 0 }, + { "==", 2, TOKEN_EQ, 0, 0, 0 }, + { "!=", 2, TOKEN_NE, 0, 0, 0 }, + { "<>", 2, TOKEN_NE, 0, 0, 0 }, + { "<=", 2, TOKEN_LE, 0, 0, 0 }, + { ">=", 2, TOKEN_GE, 0, 0, 0 }, + { "<=>", 3, TOKEN_LEG, 0, 0, 0 }, + { "&&", 2, TOKEN_DBL_AND, 0, 0, 0 }, + { "||", 2, TOKEN_DBL_OR, 0, 0, 0 }, + { "^^", 2, TOKEN_DBL_XOR, 0, 0, 0 }, + }; + uint32_t k1, k2; + uint16_t ix; + const struct tokendata *data; + char lcbuf[18]; + const char *p = token; + char c, *q = lcbuf; + size_t len = 0; + uint64_t crc = UINT64_C(0x076259c3e291c26c); + + while ((c = *p++)) { + if (++len > 17) + goto notfound; + *q++ = c = nasm_tolower(c); + crc = crc64_byte(crc, c); + }; + + k1 = ((uint32_t)crc & 0x3ffe) + 0; + k2 = ((uint32_t)(crc >> 32) & 0x3ffe) + 1; + + ix = hashdata[k1] + hashdata[k2]; + if (ix >= 2594) + goto notfound; + + data = &tokendata[ix]; + if (data->len != len) + goto notfound; + if (memcmp(data->string, lcbuf, len)) + goto notfound; + + tv->t_integer = data->num; + tv->t_inttwo = data->aux; + tv->t_flag = data->tokflag; + return tv->t_type = data->tokentype; + +notfound: + tv->t_integer = 0; + tv->t_inttwo = 0; + tv->t_flag = 0; + return tv->t_type = TOKEN_ID; +} diff --git a/vere/ext/nasm/asm/tokhash.pl b/vere/ext/nasm/asm/tokhash.pl new file mode 100755 index 0000000..1f19647 --- /dev/null +++ b/vere/ext/nasm/asm/tokhash.pl @@ -0,0 +1,282 @@ +#!/usr/bin/perl +## -------------------------------------------------------------------------- +## +## Copyright 1996-2020 The NASM Authors - All Rights Reserved +## See the file AUTHORS included with the NASM distribution for +## the specific copyright holders. +## +## Redistribution and use in source and binary forms, with or without +## modification, are permitted provided that the following +## conditions are met: +## +## * Redistributions of source code must retain the above copyright +## notice, this list of conditions and the following disclaimer. +## * Redistributions in binary form must reproduce the above +## copyright notice, this list of conditions and the following +## disclaimer in the documentation and/or other materials provided +## with the distribution. +## +## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +## CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +## INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +## MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +## DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +## CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +## NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +## LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +## HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +## OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +## EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +## +## -------------------------------------------------------------------------- + +# +# Generate a perfect hash for token parsing +# +# Usage: tokenhash.pl insns.dat regs.dat tokens.dat +# + +require 'phash.ph'; + +my($output, $insnsn_c, $regs_dat, $tokens_dat) = @ARGV; + +%tokens = (); +@tokendata = (); + +# +# List of condition codes +# +@conditions = ('a', 'ae', 'b', 'be', 'c', 'e', 'g', 'ge', 'l', 'le', + 'na', 'nae', 'nb', 'nbe', 'nc', 'ne', 'ng', 'nge', 'nl', + 'nle', 'no', 'np', 'ns', 'nz', 'o', 'p', 'pe', 'po', 's', 'z'); + +# +# Read insnsn.c +# +open(ID, '<', $insnsn_c) or die "$0: cannot open $insnsn_c: $!\n"; +while (defined($line = <ID>)) { + next unless ($line =~ /^\s*\"([\?\@a-z0-9_]+)\"/); + + my $token = $1; + next if (defined($tokens{$token})); # This should never happen + + $tokens{$token} = scalar @tokendata; + push(@tokendata, "\"${token}\", ".length($token). + ", TOKEN_INSN, 0, 0, I_\U${token}"); +} +close(ID); + +# +# Read regs.dat +# +open(RD, '<', $regs_dat) or die "$0: cannot open $regs_dat: $!\n"; +while (defined($line = <RD>)) { + if ($line =~ /^([\?\@a-z0-9_-]+)\s*\S+\s*\S+\s*[0-9]+\s*(\S*)/) { + $reg = $1; + $reg_flag = $2; + + if ($reg =~ /^(.*[^0-9])([0-9]+)\-([0-9]+)(|[^0-9].*)$/) { + $nregs = $3-$2+1; + $reg = $1.$2.$4; + $reg_nr = $2; + $reg_prefix = $1; + $reg_suffix = $4; + } else { + $nregs = 1; + undef $reg_prefix; + undef $reg_suffix; + } + + while ($nregs--) { + if (defined($tokens{$reg})) { + die "Duplicate definition: $reg\n"; + } + $tokens{$reg} = scalar @tokendata; + $reg_flag = '0' if ($reg_flag eq ''); + push(@tokendata, "\"${reg}\", ".length($reg).", TOKEN_REG, 0, ${reg_flag}, R_\U${reg}\E"); + + if (defined($reg_prefix)) { + $reg_nr++; + $reg = sprintf("%s%u%s", $reg_prefix, $reg_nr, $reg_suffix); + } else { + # Not a dashed sequence + die if ($nregs); + } + } + } +} +close(RD); + +# +# Read tokens.dat +# +open(TD, '<', $tokens_dat) or die "$0: cannot open $tokens_dat: $!\n"; +while (defined($line = <TD>)) { + $line =~ s/\s*(|\#.*)$//; + if ($line =~ /^\%\s+(.*)$/) { + $pattern = $1; + } elsif ($line =~ /^(\S+)/) { + $token = $1; + + if (defined($tokens{$token})) { + die "Duplicate definition: $token\n"; + } + $tokens{$token} = scalar @tokendata; + + $data = $pattern; + if ($data =~ /^(.*)\{(.*)\}(.*)$/) { + my $head = $1, $tail = $3; + my $px = $2; + + $px =~ s/\?/\\?/g; + $px =~ s/\*/(.*)/g; + if ($token =~ /$px/i) { + $data = $head."\U$1".$tail; + } else { + die "$0: token $token doesn't match $px\n"; + } + } + + $data =~ s/\*/\U$token/g; + $data =~ s/\?//g; + + push(@tokendata, "\"$token\", ".length($token).", $data"); + } +} +close(TD); + +$max_len = 0; +foreach $token (keys(%tokens)) { + if (length($token) > $max_len) { + $max_len = length($token); + } +} + +if ($output eq 'h') { + # + # tokens.h + # + + print "/*\n"; + print " * This file is generated from insns.dat, regs.dat and token.dat\n"; + print " * by tokhash.pl; do not edit.\n"; + print " */\n"; + print "\n"; + + print "#ifndef NASM_TOKENS_H\n"; + print "#define NASM_TOKENS_H\n"; + print "\n"; + print "#define MAX_KEYWORD $max_len /* length of longest keyword */\n"; + print "\n"; + print "#endif /* NASM_TOKENS_H */\n"; +} elsif ($output eq 'c') { + # + # tokhash.c + # + + @hashinfo = gen_perfect_hash(\%tokens); + if (!@hashinfo) { + die "$0: no hash found\n"; + } + + # Paranoia... + verify_hash_table(\%tokens, \@hashinfo); + + ($n, $sv, $g) = @hashinfo; + die if ($n & ($n-1)); + $n <<= 1; + + print "/*\n"; + print " * This file is generated from insns.dat, regs.dat and token.dat\n"; + print " * by tokhash.pl; do not edit.\n"; + print " */\n"; + print "\n"; + + print "#include \"compiler.h\"\n"; + print "#include \"nasm.h\"\n"; + print "#include \"hashtbl.h\"\n"; + print "#include \"insns.h\"\n"; + print "#include \"stdscan.h\"\n"; + print "\n"; + + # These somewhat odd sizes and ordering thereof are due to the + # relative ranges of the types; this makes it fit in 16 bytes on + # 64-bit machines and 12 bytes on 32-bit machines. + print "struct tokendata {\n"; + print " const char *string;\n"; + print " uint16_t len;\n"; + print " int16_t tokentype;\n"; + print " int16_t aux;\n"; + print " uint16_t tokflag;\n"; + print " int32_t num;\n"; + print "};\n"; + print "\n"; + + print "int nasm_token_hash(const char *token, struct tokenval *tv)\n"; + print "{\n"; + + # Put a large value in unused slots. This makes it extremely unlikely + # that any combination that involves unused slot will pass the range test. + # This speeds up rejection of unrecognized tokens, i.e. identifiers. + print "#define INVALID_HASH_ENTRY (65535/3)\n"; + + printf " static const int16_t hashdata[%d] = {\n", $n; + for ($i = 0; $i < $n; $i++) { + my $h = ${$g}[$i]; + print " ", defined($h) ? $h : 'INVALID_HASH_ENTRY', ",\n"; + } + print " };\n"; + + printf " static const struct tokendata tokendata[%d] = {\n", + scalar(@tokendata); + foreach $d (@tokendata) { + print " { ", $d, " },\n"; + } + print " };\n"; + + print " uint32_t k1, k2;\n"; + # For correct overflow behavior, "ix" should be unsigned of the same + # width as the hash arrays. + print " uint16_t ix;\n"; + print " const struct tokendata *data;\n"; + printf " char lcbuf[%d];\n", $max_len+1; + print " const char *p = token;\n"; + print " char c, *q = lcbuf;\n"; + print " size_t len = 0;\n"; + printf " uint64_t crc = UINT64_C(0x%08x%08x);\n", $$sv[0], $$sv[1]; + print "\n"; + print " while ((c = *p++)) {\n"; + printf " if (++len > %d)\n", $max_len; + print " goto notfound;\n"; + print " *q++ = c = nasm_tolower(c);\n"; + print " crc = crc64_byte(crc, c);\n"; + print " };\n"; + print "\n"; + printf " k1 = ((uint32_t)crc & 0x%x) + 0;\n", $n-2; + printf " k2 = ((uint32_t)(crc >> 32) & 0x%x) + 1;\n", $n-2; + print "\n"; + printf " ix = hashdata[k1] + hashdata[k2];\n", + $n-2, $n-2; + printf " if (ix >= %d)\n", scalar(@tokendata); + print " goto notfound;\n"; + print "\n"; + print " data = &tokendata[ix];\n"; + print " if (data->len != len)\n"; + print " goto notfound;\n"; + print " if (memcmp(data->string, lcbuf, len))\n"; + print " goto notfound;\n"; + print "\n"; + print " tv->t_integer = data->num;\n"; + print " tv->t_inttwo = data->aux;\n"; + print " tv->t_flag = data->tokflag;\n"; + print " return tv->t_type = data->tokentype;\n"; + print "\n"; + print "notfound:\n"; + print " tv->t_integer = 0;\n"; + print " tv->t_inttwo = 0;\n"; + print " tv->t_flag = 0;\n"; + print " return tv->t_type = TOKEN_ID;\n"; + print "}\n"; +} diff --git a/vere/ext/nasm/asm/warnings.c b/vere/ext/nasm/asm/warnings.c new file mode 100644 index 0000000..f825e0c --- /dev/null +++ b/vere/ext/nasm/asm/warnings.c @@ -0,0 +1,241 @@ +#include "error.h" + +const char * const warning_name[53] = { + NULL, + "db-empty", + "ea-absolute", + "ea-dispsize", + "float-denorm", + "float-overflow", + "float-toolong", + "float-underflow", + "forward", + "label-orphan", + "label-redef", + "label-redef-late", + "number-overflow", + "obsolete-nop", + "obsolete-removed", + "obsolete-valid", + "phase", + "pp-else-elif", + "pp-else-else", + "pp-empty-braces", + "pp-environment", + "pp-macro-def-case-single", + "pp-macro-def-greedy-single", + "pp-macro-def-param-single", + "pp-macro-defaults", + "pp-macro-params-legacy", + "pp-macro-params-multi", + "pp-macro-params-single", + "pp-macro-redef-multi", + "pp-open-braces", + "pp-open-brackets", + "pp-open-string", + "pp-rep-negative", + "pp-sel-range", + "pp-trailing", + "pragma-bad", + "pragma-empty", + "pragma-na", + "pragma-unknown", + "prefix-bnd", + "prefix-hle", + "prefix-lock", + "prefix-opsize", + "prefix-seg", + "ptr", + "regsize", + "unknown-warning", + "user", + "warn-stack-empty", + "zeroing", + "zext-reloc", + "other", + "all" +}; + +const struct warning_alias warning_alias[68] = { + { "all", WARN_IDX_ALL }, + { "bad-pragma", WARN_IDX_PRAGMA_BAD }, + { "bnd", WARN_IDX_PREFIX_BND }, + { "db-empty", WARN_IDX_DB_EMPTY }, + { "ea-absolute", WARN_IDX_EA_ABSOLUTE }, + { "ea-dispsize", WARN_IDX_EA_DISPSIZE }, + { "environment", WARN_IDX_PP_ENVIRONMENT }, + { "float-denorm", WARN_IDX_FLOAT_DENORM }, + { "float-overflow", WARN_IDX_FLOAT_OVERFLOW }, + { "float-toolong", WARN_IDX_FLOAT_TOOLONG }, + { "float-underflow", WARN_IDX_FLOAT_UNDERFLOW }, + { "forward", WARN_IDX_FORWARD }, + { "hle", WARN_IDX_PREFIX_HLE }, + { "label-orphan", WARN_IDX_LABEL_ORPHAN }, + { "label-redef", WARN_IDX_LABEL_REDEF }, + { "label-redef-late", WARN_IDX_LABEL_REDEF_LATE }, + { "lock", WARN_IDX_PREFIX_LOCK }, + { "macro-def-case-single", WARN_IDX_PP_MACRO_DEF_CASE_SINGLE }, + { "macro-def-greedy-single", WARN_IDX_PP_MACRO_DEF_GREEDY_SINGLE }, + { "macro-def-param-single", WARN_IDX_PP_MACRO_DEF_PARAM_SINGLE }, + { "macro-defaults", WARN_IDX_PP_MACRO_DEFAULTS }, + { "macro-params-legacy", WARN_IDX_PP_MACRO_PARAMS_LEGACY }, + { "macro-params-multi", WARN_IDX_PP_MACRO_PARAMS_MULTI }, + { "macro-params-single", WARN_IDX_PP_MACRO_PARAMS_SINGLE }, + { "negative-rep", WARN_IDX_PP_REP_NEGATIVE }, + { "not-my-pragma", WARN_IDX_PRAGMA_NA }, + { "number-overflow", WARN_IDX_NUMBER_OVERFLOW }, + { "obsolete-nop", WARN_IDX_OBSOLETE_NOP }, + { "obsolete-removed", WARN_IDX_OBSOLETE_REMOVED }, + { "obsolete-valid", WARN_IDX_OBSOLETE_VALID }, + { "orphan-labels", WARN_IDX_LABEL_ORPHAN }, + { "other", WARN_IDX_OTHER }, + { "phase", WARN_IDX_PHASE }, + { "pp-else-elif", WARN_IDX_PP_ELSE_ELIF }, + { "pp-else-else", WARN_IDX_PP_ELSE_ELSE }, + { "pp-empty-braces", WARN_IDX_PP_EMPTY_BRACES }, + { "pp-environment", WARN_IDX_PP_ENVIRONMENT }, + { "pp-macro-def-case-single", WARN_IDX_PP_MACRO_DEF_CASE_SINGLE }, + { "pp-macro-def-greedy-single", WARN_IDX_PP_MACRO_DEF_GREEDY_SINGLE }, + { "pp-macro-def-param-single", WARN_IDX_PP_MACRO_DEF_PARAM_SINGLE }, + { "pp-macro-defaults", WARN_IDX_PP_MACRO_DEFAULTS }, + { "pp-macro-params-legacy", WARN_IDX_PP_MACRO_PARAMS_LEGACY }, + { "pp-macro-params-multi", WARN_IDX_PP_MACRO_PARAMS_MULTI }, + { "pp-macro-params-single", WARN_IDX_PP_MACRO_PARAMS_SINGLE }, + { "pp-macro-redef-multi", WARN_IDX_PP_MACRO_REDEF_MULTI }, + { "pp-open-braces", WARN_IDX_PP_OPEN_BRACES }, + { "pp-open-brackets", WARN_IDX_PP_OPEN_BRACKETS }, + { "pp-open-string", WARN_IDX_PP_OPEN_STRING }, + { "pp-rep-negative", WARN_IDX_PP_REP_NEGATIVE }, + { "pp-sel-range", WARN_IDX_PP_SEL_RANGE }, + { "pp-trailing", WARN_IDX_PP_TRAILING }, + { "pragma-bad", WARN_IDX_PRAGMA_BAD }, + { "pragma-empty", WARN_IDX_PRAGMA_EMPTY }, + { "pragma-na", WARN_IDX_PRAGMA_NA }, + { "pragma-unknown", WARN_IDX_PRAGMA_UNKNOWN }, + { "prefix-bnd", WARN_IDX_PREFIX_BND }, + { "prefix-hle", WARN_IDX_PREFIX_HLE }, + { "prefix-lock", WARN_IDX_PREFIX_LOCK }, + { "prefix-opsize", WARN_IDX_PREFIX_OPSIZE }, + { "prefix-seg", WARN_IDX_PREFIX_SEG }, + { "ptr", WARN_IDX_PTR }, + { "regsize", WARN_IDX_REGSIZE }, + { "unknown-pragma", WARN_IDX_PRAGMA_UNKNOWN }, + { "unknown-warning", WARN_IDX_UNKNOWN_WARNING }, + { "user", WARN_IDX_USER }, + { "warn-stack-empty", WARN_IDX_WARN_STACK_EMPTY }, + { "zeroing", WARN_IDX_ZEROING }, + { "zext-reloc", WARN_IDX_ZEXT_RELOC } +}; + +const char * const warning_help[53] = { + NULL, + "no operand for data declaration", + "absolute address cannot be RIP-relative", + "displacement size ignored on absolute address", + "floating point denormal", + "floating point overflow", + "too many digits in floating-point number", + "floating point underflow", + "forward reference may have unpredictable results", + "labels alone on lines without trailing `:\'", + "label redefined to an identical value", + "label (re)defined during code generation", + "numeric constant does not fit", + "instruction obsolete and is a noop on the target CPU", + "instruction obsolete and removed on the target CPU", + "instruction obsolete but valid on the target CPU", + "phase error during stabilization", + "%elif after %else", + "%else after %else", + "empty %{} construct", + "nonexistent environment variable", + "single-line macro defined both case sensitive and insensitive", + "single-line macro", + "single-line macro defined with and without parameters", + "macros with more default than optional parameters", + "improperly calling multi-line macro for legacy support", + "multi-line macro calls with wrong parameter count", + "single-line macro calls with wrong parameter count", + "redefining multi-line macro", + "unterminated %{...}", + "unterminated %[...]", + "unterminated string", + "regative %rep count", + "%sel() argument out of range", + "trailing garbage ignored", + "malformed %pragma", + "empty %pragma directive", + "%pragma not applicable to this compilation", + "unknown %pragma facility or directive", + "invalid BND prefix", + "invalid HLE prefix", + "LOCK prefix on unlockable instructions", + "invalid operand size prefix", + "segment prefix ignored in 64-bit mode", + "non-NASM keyword used in other assemblers", + "register size specification ignored", + "unknown warning in -W/-w or warning directive", + "%warning directives", + "warning stack empty", + "RESx in initialized section becomes zero", + "relocation zero-extended to match output format", + "any warning not specifically mentioned above", + "all possible warnings" +}; + +const uint8_t warning_default[52] = { + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_OFF, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_OFF, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_OFF, + WARN_INIT_ERR, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_OFF, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ERR, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_OFF, + WARN_INIT_OFF, + WARN_INIT_OFF, + WARN_INIT_OFF, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_OFF, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON, + WARN_INIT_ON +}; + +uint8_t warning_state[52]; /* Current state */ diff --git a/vere/ext/nasm/asm/warnings.pl b/vere/ext/nasm/asm/warnings.pl new file mode 100755 index 0000000..599a42d --- /dev/null +++ b/vere/ext/nasm/asm/warnings.pl @@ -0,0 +1,303 @@ +#!/usr/bin/perl + +use strict; +use Fcntl qw(:seek); +use File::Find; +use File::Basename; + +my @warnings = (); +my %aliases = (); +my %prefixes = (); +my $err = 0; +my $nwarn = 0; + +sub quote_for_c($) { + my $s = join('', @_); + + $s =~ s/([\"\'\\])/\\$1/g; + return $s; +} + +sub add_alias($$) { + my($a, $this) = @_; + my @comp = split(/-/, $a); + + $aliases{$a} = $this; + + # All names are prefixes in their own right, although we only + # list the ones that are either prefixes of "proper names" or + # the complete alias name. + for (my $i = ($a eq $this->{name}) ? 0 : $#comp; $i <= $#comp; $i++) { + my $prefix = join('-', @comp[0..$i]); + $prefixes{$prefix} = [] unless defined($prefixes{$prefix}); + push(@{$prefixes{$prefix}}, $a); + } +} + +sub find_warnings { + my $infile = $_; + + return unless (basename($infile) =~ /^\w.*\.[ch]$/i); + open(my $in, '<', $infile) + or die "$0: cannot open input file $infile: $!\n"; + + my $in_comment = 0; + my $nline = 0; + my $this; + my @doc; + + while (defined(my $l = <$in>)) { + $nline++; + chomp $l; + + if (!$in_comment) { + $l =~ s/^.*?\/\*.*?\*\///g; # Remove single-line comments + + if ($l =~ /^.*?(\/\*.*)$/) { + # Begin block comment + $l = $1; + $in_comment = 1; + } + } + + if ($in_comment) { + if ($l =~ /\*\//) { + # End block comment + $in_comment = 0; + undef $this; + } elsif ($l =~ /^\s*\/?\*\!(\-|\=|\s*)(.*?)\s*$/) { + my $opr = $1; + my $str = $2; + + if ($opr eq '' && $str eq '') { + next; + } elsif ((!defined($this) || ($opr eq '')) && + ($str =~ /^([\w\-]+)\s+\[(\w+)\]\s(.*\S)\s*$/)) { + my $name = $1; + my $def = $2; + my $help = $3; + + my $cname = uc($name); + $cname =~ s/[^A-Z0-9_]+/_/g; + + $this = {name => $name, cname => $cname, + def => $def, help => $help, + doc => [], file => $infile, line => $nline}; + + if (defined(my $that = $aliases{$name})) { + # Duplicate definition?! + printf STDERR "%s:%s: warning %s previously defined at %s:%s\n", + $infile, $nline, $name, $that->{file}, $that->{line}; + } else { + push(@warnings, $this); + # Every warning name is also a valid warning alias + add_alias($name, $this); + $nwarn++; + } + } elsif ($opr eq '=') { + # Alias names for warnings + for my $a (split(/,+/, $str)) { + add_alias($a, $this); + } + } elsif ($opr =~ /^[\-\s]/) { + push(@{$this->{doc}}, "$str\n"); + } else { + print STDERR "$infile:$nline: malformed warning definition\n"; + print STDERR " $l\n"; + $err++; + } + } else { + undef $this; + } + } + } + close($in); +} + +my($what, $outfile, @indirs) = @ARGV; + +if (!defined($outfile)) { + die "$0: usage: [c|h|doc] outfile indir...\n"; +} + +find({ wanted => \&find_warnings, no_chdir => 1, follow => 1 }, @indirs); + +exit(1) if ($err); + +my %sort_special = ( 'other' => 1, 'all' => 2 ); +sub sort_warnings { + my $an = $a->{name}; + my $bn = $b->{name}; + return ($sort_special{$an} <=> $sort_special{$bn}) || ($an cmp $bn); +} + +@warnings = sort sort_warnings @warnings; +my @warn_noall = @warnings; +pop @warn_noall if ($warn_noall[$#warn_noall]->{name} eq 'all'); + +my $outdata; +open(my $out, '>', \$outdata) + or die "$0: cannot create memory file: $!\n"; + +if ($what eq 'c') { + print $out "#include \"error.h\"\n\n"; + printf $out "const char * const warning_name[%d] = {\n", + $#warnings + 2; + print $out "\tNULL"; + foreach my $warn (@warnings) { + print $out ",\n\t\"", $warn->{name}, "\""; + } + print $out "\n};\n\n"; + printf $out "const struct warning_alias warning_alias[%d] = {", + scalar(keys %aliases); + my $sep = ''; + foreach my $alias (sort { $a cmp $b } keys(%aliases)) { + printf $out "%s\n\t{ %-27s WARN_IDX_%s }", + $sep, "\"$alias\",", $aliases{$alias}->{cname}; + $sep = ','; + } + print $out "\n};\n\n"; + + printf $out "const char * const warning_help[%d] = {\n", + $#warnings + 2; + print $out "\tNULL"; + foreach my $warn (@warnings) { + my $help = quote_for_c($warn->{help}); + print $out ",\n\t\"", $help, "\""; + } + print $out "\n};\n\n"; + printf $out "const uint8_t warning_default[%d] = {\n", + $#warn_noall + 2; + print $out "\tWARN_INIT_ON"; # for entry 0 + foreach my $warn (@warn_noall) { + print $out ",\n\tWARN_INIT_", uc($warn->{def}); + } + print $out "\n};\n\n"; + printf $out "uint8_t warning_state[%d];\t/* Current state */\n", + $#warn_noall + 2; +} elsif ($what eq 'h') { + my $filename = basename($outfile); + my $guard = $filename; + $guard =~ s/[^A-Za-z0-9_]+/_/g; + $guard = "NASM_\U$guard"; + + print $out "#ifndef $guard\n"; + print $out "#define $guard\n"; + print $out "\n"; + print $out "#ifndef WARN_SHR\n"; + print $out "# error \"$filename should only be included from within error.h\"\n"; + print $out "#endif\n\n"; + print $out "enum warn_index {\n"; + printf $out "\tWARN_IDX_%-23s = %3d, /* not suppressible */\n", 'NONE', 0; + my $n = 1; + foreach my $warn (@warnings) { + printf $out "\tWARN_IDX_%-23s = %3d%s /* %s */\n", + $warn->{cname}, $n, + ($n == $#warnings + 1) ? " " : ",", + $warn->{help}; + $n++; + } + print $out "};\n\n"; + + print $out "enum warn_const {\n"; + printf $out "\tWARN_%-27s = %3d << WARN_SHR", 'NONE', 0; + $n = 1; + foreach my $warn (@warn_noall) { + printf $out ",\n\tWARN_%-27s = %3d << WARN_SHR", $warn->{cname}, $n++; + } + print $out "\n};\n\n"; + + print $out "struct warning_alias {\n"; + print $out "\tconst char *name;\n"; + print $out "\tenum warn_index warning;\n"; + print $out "};\n\n"; + printf $out "#define NUM_WARNING_ALIAS %d\n", scalar(keys %aliases); + + printf $out "extern const char * const warning_name[%d];\n", + $#warnings + 2; + printf $out "extern const char * const warning_help[%d];\n", + $#warnings + 2; + print $out "extern const struct warning_alias warning_alias[NUM_WARNING_ALIAS];\n"; + printf $out "extern const uint8_t warning_default[%d];\n", + $#warn_noall + 2; + printf $out "extern uint8_t warning_state[%d];\n", + $#warn_noall + 2; + print $out "\n#endif /* $guard */\n"; +} elsif ($what eq 'doc') { + my %whatdef = ( 'on' => 'Enabled', + 'off' => 'Disabled', + 'err' => 'Enabled and promoted to error' ); + + my @indexinfo = (); + my @outtxt = (); + + foreach my $pfx (sort { $a cmp $b } keys(%prefixes)) { + my $warn = $aliases{$pfx}; + my @doc; + + if (!defined($warn)) { + my @plist = sort { $a cmp $b } @{$prefixes{$pfx}}; + next if ( $#plist < 1 ); + + @doc = ("all \\c{$pfx-} warnings\n\n", + "\\> \\c{$pfx} is a group alias for all warning classes\n", + "prefixed by \\c{$pfx-}; currently\n"); + # Just commas is bad grammar to be sure, but it is more + # legible than the alternative. + push(@doc, join(scalar(@plist) < 3 ? ' and ' : ', ', + map { "\\c{$_}" } @plist).".\n"); + } elsif ($pfx ne $warn->{name}) { + my $awarn = $aliases{$warn->{name}}; + @doc = ($awarn->{help}."\n\n", + "\\> \\c{$pfx} is a backwards compatibility alias for \\c{". + $warn->{name}."}.\n"); + } else { + my $docdef = $whatdef{$warn->{def}}; + + @doc = ($warn->{help}."\n\n", + "\\> \\c{".$warn->{name}."} "); + + my $newpara = 0; + foreach my $l (@{$warn->{doc}}) { + if ($l =~ /^\s*$/) { + $newpara = 1; + } else { + if ($newpara && $l !~ /^\\c\s+/) { + $l = '\> ' . $l; + } + $newpara = 0; + } + push(@doc, $l); + } + if (defined($docdef)) { + push(@doc, "\n", "\\> $docdef by default.\n"); + } + } + + push(@indexinfo, "\\IR{w-$pfx} warning class, \\c{$pfx}\n"); + push(@outtxt, "\\b \\I{w-$pfx} \\c{$pfx}: ", @doc, "\n"); + } + + print $out "\n", @indexinfo, "\n", @outtxt; +} + +close($out); + +# Write data to file if and only if it has changed +# For some systems, even if we don't write, opening for append +# apparently touches the timestamp, so we need to read and write +# as separate operations. +if (open(my $out, '<', $outfile)) { + my $datalen = length($outdata); + my $oldlen = read($out, my $oldoutdata, $datalen+1); + close($out); + exit 0 if (defined($oldlen) && $oldlen == $datalen && + ($oldoutdata eq $outdata)); +} + +# Data changed, must rewrite +open(my $out, '>', $outfile) + or die "$0: cannot open output file $outfile: $!\n"; + +print $out $outdata; +close($out); |